generic-library/bionic
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

eclair snapshot

Browse Source
This commit is contained in:
Jean-Baptiste Queru 2009-11-12 18:45:14 -08:00
parent fde8642fc4
commit 194d3fa048
50 changed files with 5101 additions and 3134 deletions

11
libc/Android.mk

@ -288,6 +288,7 @@ libc_common_src_files += \
arch-arm/bionic/clone.S \
arch-arm/bionic/ffs.S \
arch-arm/bionic/kill.S \
arch-arm/bionic/libgcc_compat.c \
arch-arm/bionic/tkill.S \
arch-arm/bionic/memcmp.S \
arch-arm/bionic/memcmp16.S \
@ -366,6 +367,16 @@ endif
ifeq ($(TARGET_ARCH),arm)
libc_common_cflags += -fstrict-aliasing
libc_crt_target_cflags := -mthumb-interwork
#
# Define HAVE_ARM_TLS_REGISTER macro to indicate to the C library
# that it should access the hardware TLS register directly in
# private/bionic_tls.h
#
# The value must match your kernel configuration
#
ifeq ($(ARCH_ARM_HAVE_TLS_REGISTER),true)
libc_common_cflags += -DHAVE_ARM_TLS_REGISTER
endif
else # !arm
ifeq ($(TARGET_ARCH),x86)
libc_crt_target_cflags := -m32

9
libc/arch-arm/bionic/atomics_arm.S

@ -41,6 +41,8 @@
.equ kernel_cmpxchg, 0xFFFF0FC0
.equ kernel_atomic_base, 0xFFFF0FFF
__atomic_dec:
.fnstart
.save {r4, lr}
stmdb sp!, {r4, lr}
mov r2, r0
1: @ atomic_dec
@ -53,8 +55,11 @@ __atomic_dec:
add r0, r1, #1
ldmia sp!, {r4, lr}
bx lr
.fnend
__atomic_inc:
.fnstart
.save {r4, lr}
stmdb sp!, {r4, lr}
mov r2, r0
1: @ atomic_inc
@ -67,9 +72,12 @@ __atomic_inc:
sub r0, r1, #1
ldmia sp!, {r4, lr}
bx lr
.fnend
/* r0(old) r1(new) r2(addr) -> r0(zero_if_succeeded) */
__atomic_cmpxchg:
.fnstart
.save {r4, lr}
stmdb sp!, {r4, lr}
mov r4, r0 /* r4 = save oldvalue */
1: @ atomic_cmpxchg
@ -84,6 +92,7 @@ __atomic_cmpxchg:
2: @ atomic_cmpxchg
ldmia sp!, {r4, lr}
bx lr
.fnend
#else
#define KUSER_CMPXCHG 0xffffffc0

152
libc/arch-arm/bionic/libgcc_compat.c Normal file

@ -0,0 +1,152 @@
/*
* Copyright (C) 2008 The Android Open Source Project
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in
* the documentation and/or other materials provided with the
* distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
* FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
* COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
* BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
* OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
* AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
* OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*/
/* This file contains dummy references to libgcc.a functions to force the
* dynamic linker to copy their definition into the final libc.so binary.
*
* They are required to ensure backwards binary compatibility with
* Android 1.5 and Android 1.6 system images. Some applications built
* using the NDK require them to be here.
*
* Now, for a more elaborate description of the issue:
*
* libgcc.a is a compiler-specific library containing various helper
* functions used to implement certain operations that are not necessarily
* supported by the target CPU. For example, integer division doesn't have a
* corresponding CPU instruction on ARMv5, and is instead implemented in the
* compiler-generated machine code as a call to an __idiv helper function.
*
* Normally, one has to place libgcc.a in the link command used to generate
* target binaries (shared libraries and executables) after all objects and
* static libraries, but before dependent shared libraries, i.e. something
* like:
* gcc <options> -o libfoo.so foo.a libgcc.a -lc -lm
*
* This ensures that any helper function needed by the code in foo.a is copied
* into the final libfoo.so. Unfortunately, the Android build system has been
* using this instead:
*
* gcc <options> -o libfoo.so foo.a -lc -lm libgcc.a
*
* The problem with this is that if one helper function needed by foo.a has
* already been copied into libc.so or libm.so, then nothing will be copied
* into libfoo.so. Instead, a symbol import definition will be added to it
* so libfoo.so can directly call the one in libc.so at runtime.
*
* When changing toolchains for 2.0, the set of helper functions copied to
* libc.so changed, which resulted in some native shared libraries generated
* with the NDK to fail to load properly.
*
* The NDK has been fixed after 1.6_r1 to use the correct link command, so
* any native shared library generated with it should now be safe from that
* problem. On the other hand, existing shared libraries distributed with
* applications that were generated with a previous version of the NDK
* still need all 1.5/1.6 helper functions in libc.so and libn.so
*
* Final note: some of the functions below should really be in libm.so to
* completely reflect the state of 1.5/1.6 system images. However,
* since libm.so depends on libc.so, it's easier to put all of
* these in libc.so instead, since the dynamic linker will always
* search in libc.so before libm.so for dependencies.
*/
#define COMPAT_FUNCTIONS_LIST \
XX(__adddf3) \
XX(__addsf3) \
XX(__aeabi_cdcmpeq) \
XX(__aeabi_cdcmple) \
XX(__aeabi_cdrcmple) \
XX(__aeabi_d2f) \
XX(__aeabi_d2iz) \
XX(__aeabi_dadd) \
XX(__aeabi_dcmpeq) \
XX(__aeabi_dcmpge) \
XX(__aeabi_dcmpgt) \
XX(__aeabi_dcmple) \
XX(__aeabi_dcmplt) \
XX(__aeabi_dcmpun) \
XX(__aeabi_ddiv) \
XX(__aeabi_dmul) \
XX(__aeabi_drsub) \
XX(__aeabi_dsub) \
XX(__aeabi_f2d) \
XX(__aeabi_f2iz) \
XX(__aeabi_fadd) \
XX(__aeabi_fcmpun) \
XX(__aeabi_fdiv) \
XX(__aeabi_fmul) \
XX(__aeabi_frsub) \
XX(__aeabi_fsub) \
XX(__aeabi_i2d) \
XX(__aeabi_i2f) \
XX(__aeabi_l2d) \
XX(__aeabi_l2f) \
XX(__aeabi_lmul) \
XX(__aeabi_ui2d) \
XX(__aeabi_ui2f) \
XX(__aeabi_ul2d) \
XX(__aeabi_ul2f) \
XX(__cmpdf2) \
XX(__divdf3) \
XX(__divsf3) \
XX(__eqdf2) \
XX(__extendsfdf2) \
XX(__fixdfsi) \
XX(__fixsfsi) \
XX(__floatdidf) \
XX(__floatdisf) \
XX(__floatsidf) \
XX(__floatsisf) \
XX(__floatundidf) \
XX(__floatundisf) \
XX(__floatunsidf) \
XX(__floatunsisf) \
XX(__gedf2) \
XX(__gtdf2) \
XX(__ledf2) \
XX(__ltdf2) \
XX(__muldf3) \
XX(__muldi3) \
XX(__mulsf3) \
XX(__nedf2) \
XX(__subdf3) \
XX(__subsf3) \
XX(__truncdfsf2) \
XX(__unorddf2) \
XX(__unordsf2) \
#define XX(f) extern void f(void);
COMPAT_FUNCTIONS_LIST
#undef XX
void __bionic_libgcc_compat_hooks(void)
{
#define XX(f) f();
COMPAT_FUNCTIONS_LIST
#undef XX
}

3
libc/arch-arm/bionic/memcmp.S

@ -44,6 +44,7 @@
*/
memcmp:
.fnstart
PLD (r0, #0)
PLD (r1, #0)
@ -53,6 +54,7 @@ memcmp:
moveq r0, #0
bxeq lr
.save {r4, lr}
/* save registers */
stmfd sp!, {r4, lr}
@ -174,6 +176,7 @@ memcmp:
9: /* restore registers and return */
ldmfd sp!, {r4, lr}
bx lr
.fnend

3
libc/arch-arm/bionic/memcmp16.S

@ -44,6 +44,7 @@
*/
__memcmp16:
.fnstart
PLD (r0, #0)
PLD (r1, #0)
@ -79,6 +80,7 @@ __memcmp16:
bx lr
.save {r4, lr}
/* save registers */
0: stmfd sp!, {r4, lr}
@ -93,6 +95,7 @@ __memcmp16:
/* restore registers and return */
ldmnefd sp!, {r4, lr}
bxne lr
.fnend

123
libc/arch-arm/bionic/memcpy.S

@ -28,6 +28,127 @@
#include <machine/cpu-features.h>
#if __ARM_ARCH__ == 7 || defined(__ARM_NEON__)
.text
.fpu neon
.global memcpy
.type memcpy, %function
.align 4
/* a prefetch distance of 4 cache-lines works best experimentally */
#define CACHE_LINE_SIZE 64
#define PREFETCH_DISTANCE (CACHE_LINE_SIZE*4)
memcpy:
.fnstart
.save {r0, lr}
stmfd sp!, {r0, lr}
/* start preloading as early as possible */
pld [r1, #(CACHE_LINE_SIZE*0)]
pld [r1, #(CACHE_LINE_SIZE*1)]
/* do we have at least 16-bytes to copy (needed for alignment below) */
cmp r2, #16
blo 5f
/* align destination to half cache-line for the write-buffer */
rsb r3, r0, #0
ands r3, r3, #0xF
beq 0f
/* copy up to 15-bytes (count in r3) */
sub r2, r2, r3
movs ip, r3, lsl #31
ldrmib lr, [r1], #1
strmib lr, [r0], #1
ldrcsb ip, [r1], #1
ldrcsb lr, [r1], #1
strcsb ip, [r0], #1
strcsb lr, [r0], #1
movs ip, r3, lsl #29
bge 1f
// copies 4 bytes, destination 32-bits aligned
vld4.8 {d0[0], d1[0], d2[0], d3[0]}, [r1]!
vst4.8 {d0[0], d1[0], d2[0], d3[0]}, [r0, :32]!
1: bcc 2f
// copies 8 bytes, destination 64-bits aligned
vld1.8 {d0}, [r1]!
vst1.8 {d0}, [r0, :64]!
2:
0: /* preload immediately the next cache line, which we may need */
pld [r1, #(CACHE_LINE_SIZE*0)]
pld [r1, #(CACHE_LINE_SIZE*1)]
/* make sure we have at least 64 bytes to copy */
subs r2, r2, #64
blo 2f
/* preload all the cache lines we need.
* NOTE: the number of pld below depends on PREFETCH_DISTANCE,
* ideally would would increase the distance in the main loop to
* avoid the goofy code below. In practice this doesn't seem to make
* a big difference.
*/
pld [r1, #(CACHE_LINE_SIZE*2)]
pld [r1, #(CACHE_LINE_SIZE*3)]
pld [r1, #(PREFETCH_DISTANCE)]
1: /* The main loop copies 64 bytes at a time */
vld1.8 {d0 - d3}, [r1]!
vld1.8 {d4 - d7}, [r1]!
pld [r1, #(PREFETCH_DISTANCE)]
subs r2, r2, #64
vst1.8 {d0 - d3}, [r0, :128]!
vst1.8 {d4 - d7}, [r0, :128]!
bhs 1b
2: /* fix-up the remaining count and make sure we have >= 32 bytes left */
add r2, r2, #64
subs r2, r2, #32
blo 4f
3: /* 32 bytes at a time. These cache lines were already preloaded */
vld1.8 {d0 - d3}, [r1]!
subs r2, r2, #32
vst1.8 {d0 - d3}, [r0, :128]!
bhs 3b
4: /* less than 32 left */
add r2, r2, #32
tst r2, #0x10
beq 5f
// copies 16 bytes, 128-bits aligned
vld1.8 {d0, d1}, [r1]!
vst1.8 {d0, d1}, [r0, :128]!
5: /* copy up to 15-bytes (count in r2) */
movs ip, r2, lsl #29
bcc 1f
vld1.8 {d0}, [r1]!
vst1.8 {d0}, [r0]!
1: bge 2f
vld4.8 {d0[0], d1[0], d2[0], d3[0]}, [r1]!
vst4.8 {d0[0], d1[0], d2[0], d3[0]}, [r0]!
2: movs ip, r2, lsl #31
ldrmib r3, [r1], #1
ldrcsb ip, [r1], #1
ldrcsb lr, [r1], #1
strmib r3, [r0], #1
strcsb ip, [r0], #1
strcsb lr, [r0], #1
ldmfd sp!, {r0, lr}
bx lr
.fnend
#else /* __ARM_ARCH__ < 7 */
.text
.global memcpy
@ -385,3 +506,5 @@ copy_last_3_and_return:
bx lr
.fnend
#endif /* __ARM_ARCH__ < 7 */

4
libc/arch-arm/bionic/memset.S

@ -80,7 +80,7 @@ memset:
rsb r3, r0, #0
ands r3, r3, #0x1C
beq aligned32
beq 3f
cmp r3, r2
andhi r3, r2, #0x1C
sub r2, r2, r3
@ -93,7 +93,7 @@ memset:
movs r3, r3, lsl #2
strcs r1, [r0], #4
aligned32:
3:
subs r2, r2, #32
mov r3, r1
bmi 2f

1
libc/arch-arm/include/machine/cpu-features.h

@ -149,7 +149,6 @@
# define __ARM_HAVE_PC_INTERWORK
#endif
/* Assembly-only macros */
/* define a handy PLD(address) macro since the cache preload

73
libc/bionic/dlmalloc.c

@ -1154,6 +1154,23 @@ void mspace_free(mspace msp, void* mem);
*/
void* mspace_realloc(mspace msp, void* mem, size_t newsize);
#if ANDROID /* Added for Android, not part of dlmalloc as released */
/*
mspace_merge_objects will merge allocated memory mema and memb
together, provided memb immediately follows mema. It is roughly as
if memb has been freed and mema has been realloced to a larger size.
On successfully merging, mema will be returned. If either argument
is null or memb does not immediately follow mema, null will be
returned.
Both mema and memb should have been previously allocated using
malloc or a related routine such as realloc. If either mema or memb
was not malloced or was previously freed, the result is undefined,
but like mspace_free, the default is to abort the program.
*/
void* mspace_merge_objects(mspace msp, void* mema, void* memb);
#endif
/*
mspace_calloc behaves as calloc, but operates within
the given space.
@ -4872,6 +4889,62 @@ void* mspace_realloc(mspace msp, void* oldmem, size_t bytes) {
}
}
#if ANDROID
void* mspace_merge_objects(mspace msp, void* mema, void* memb)
{
/* PREACTION/POSTACTION aren't necessary because we are only
modifying fields of inuse chunks owned by the current thread, in
which case no other malloc operations can touch them.
*/
if (mema == NULL || memb == NULL) {
return NULL;
}
mchunkptr pa = mem2chunk(mema);
mchunkptr pb = mem2chunk(memb);
#if FOOTERS
mstate fm = get_mstate_for(pa);
#else /* FOOTERS */
mstate fm = (mstate)msp;
#endif /* FOOTERS */
if (!ok_magic(fm)) {
USAGE_ERROR_ACTION(fm, pa);
return NULL;
}
check_inuse_chunk(fm, pa);
if (RTCHECK(ok_address(fm, pa) && ok_cinuse(pa))) {
if (next_chunk(pa) != pb) {
/* Since pb may not be in fm, we can't check ok_address(fm, pb);
since ok_cinuse(pb) would be unsafe before an address check,
return NULL rather than invoke USAGE_ERROR_ACTION if pb is not
in use or is a bogus address.
*/
return NULL;
}
/* Since b follows a, they share the mspace. */
#if FOOTERS
assert(fm == get_mstate_for(pb));
#endif /* FOOTERS */
check_inuse_chunk(fm, pb);
if (RTCHECK(ok_address(fm, pb) && ok_cinuse(pb))) {
size_t sz = chunksize(pb);
pa->head += sz;
/* Make sure pa still passes. */
check_inuse_chunk(fm, pa);
return mema;
}
else {
USAGE_ERROR_ACTION(fm, pb);
return NULL;
}
}
else {
USAGE_ERROR_ACTION(fm, pa);
return NULL;
}
}
#endif /* ANDROID */
void* mspace_memalign(mspace msp, size_t alignment, size_t bytes) {
mstate ms = (mstate)msp;
if (!ok_magic(ms)) {

15
libc/bionic/dlmalloc.h

@ -546,6 +546,21 @@ void mspace_free(mspace msp, void* mem);
*/
void* mspace_realloc(mspace msp, void* mem, size_t newsize);
/*
mspace_merge_objects will merge allocated memory mema and memb
together, provided memb immediately follows mema. It is roughly as
if memb has been freed and mema has been realloced to a larger size.
On successfully merging, mema will be returned. If either argument
is null or memb does not immediately follow mema, null will be
returned.
Both mema and memb should have been previously allocated using
malloc or a related routine such as realloc. If either mema or memb
was not malloced or was previously freed, the result is undefined,
but like mspace_free, the default is to abort the program.
*/
void* mspace_merge_objects(mspace msp, void* mema, void* memb);
/*
mspace_calloc behaves as calloc, but operates within
the given space.

169
libc/bionic/pthread.c

@ -441,7 +441,7 @@ int pthread_attr_setstackaddr(pthread_attr_t * attr, void * stack_addr)
int pthread_attr_getstackaddr(pthread_attr_t const * attr, void ** stack_addr)
{
*stack_addr = attr->stack_base + attr->stack_size;
*stack_addr = (char*)attr->stack_base + attr->stack_size;
return 0;
}
@ -789,7 +789,18 @@ int pthread_mutexattr_setpshared(pthread_mutexattr_t *attr, int pshared)
if (!attr)
return EINVAL;
return (pshared == PTHREAD_PROCESS_PRIVATE) ? 0 : ENOTSUP;
switch (pshared) {
case PTHREAD_PROCESS_PRIVATE:
case PTHREAD_PROCESS_SHARED:
/* our current implementation of pthread actually supports shared
* mutexes but won't cleanup if a process dies with the mutex held.
* Nevertheless, it's better than nothing. Shared mutexes are used
* by surfaceflinger and audioflinger.
*/
return 0;
}
return ENOTSUP;
}
int pthread_mutexattr_getpshared(pthread_mutexattr_t *attr, int *pshared)
@ -1114,6 +1125,135 @@ int pthread_mutex_trylock(pthread_mutex_t *mutex)
}
/* initialize 'ts' with the difference between 'abstime' and the current time
* according to 'clock'. Returns -1 if abstime already expired, or 0 otherwise.
*/
static int
__timespec_to_absolute(struct timespec* ts, const struct timespec* abstime, clockid_t clock)
{
clock_gettime(clock, ts);
ts->tv_sec = abstime->tv_sec - ts->tv_sec;
ts->tv_nsec = abstime->tv_nsec - ts->tv_nsec;
if (ts->tv_nsec < 0) {
ts->tv_sec--;
ts->tv_nsec += 1000000000;
}
if ((ts->tv_nsec < 0) || (ts->tv_sec < 0))
return -1;
return 0;
}
/* initialize 'abstime' to the current time according to 'clock' plus 'msecs'
* milliseconds.
*/
static void
__timespec_to_relative_msec(struct timespec* abstime, unsigned msecs, clockid_t clock)
{
clock_gettime(clock, abstime);
abstime->tv_sec += msecs/1000;
abstime->tv_nsec += (msecs%1000)*1000000;
if (abstime->tv_nsec >= 1000000000) {
abstime->tv_sec++;
abstime->tv_nsec -= 1000000000;
}
}
int pthread_mutex_lock_timeout_np(pthread_mutex_t *mutex, unsigned msecs)
{
clockid_t clock = CLOCK_MONOTONIC;
struct timespec abstime;
struct timespec ts;
/* compute absolute expiration time */
__timespec_to_relative_msec(&abstime, msecs, clock);
if (__likely(mutex != NULL))
{
int mtype = (mutex->value & MUTEX_TYPE_MASK);
if ( __likely(mtype == MUTEX_TYPE_NORMAL) )
{
/* fast path for unconteded lock */
if (__atomic_cmpxchg(0, 1, &mutex->value) == 0)
return 0;
/* loop while needed */
while (__atomic_swap(2, &mutex->value) != 0) {
if (__timespec_to_absolute(&ts, &abstime, clock) < 0)
return EBUSY;
__futex_wait(&mutex->value, 2, &ts);
}
return 0;
}
else
{
int tid = __get_thread()->kernel_id;
int oldv;
if ( tid == MUTEX_OWNER(mutex) )
{
int oldv, counter;
if (mtype == MUTEX_TYPE_ERRORCHECK) {
/* already locked by ourselves */
return EDEADLK;
}
_recursive_lock();
oldv = mutex->value;
counter = (oldv + (1 << MUTEX_COUNTER_SHIFT)) & MUTEX_COUNTER_MASK;
mutex->value = (oldv & ~MUTEX_COUNTER_MASK) | counter;
_recursive_unlock();
return 0;
}
else
{
/*
* If the new lock is available immediately, we grab it in
* the "uncontended" state.
*/
int new_lock_type = 1;
for (;;) {
int oldv;
struct timespec ts;
_recursive_lock();
oldv = mutex->value;
if (oldv == mtype) { /* uncontended released lock => 1 or 2 */
mutex->value = ((tid << 16) | mtype | new_lock_type);
} else if ((oldv & 3) == 1) { /* locked state 1 => state 2 */
oldv ^= 3;
mutex->value = oldv;
}
_recursive_unlock();
if (oldv == mtype)
break;
/*
* The lock was held, possibly contended by others. From
* now on, if we manage to acquire the lock, we have to
* assume that others are still contending for it so that
* we'll wake them when we unlock it.
*/
new_lock_type = 2;
if (__timespec_to_absolute(&ts, &abstime, clock) < 0)
return EBUSY;
__futex_wait( &mutex->value, oldv, &ts );
}
return 0;
}
}
}
return EINVAL;
}
/* XXX *technically* there is a race condition that could allow
* XXX a signal to be missed. If thread A is preempted in _wait()
* XXX after unlocking the mutex and before waiting, and if other
@ -1178,16 +1318,8 @@ int __pthread_cond_timedwait(pthread_cond_t *cond,
struct timespec * tsp;
if (abstime != NULL) {
clock_gettime(clock, &ts);
ts.tv_sec = abstime->tv_sec - ts.tv_sec;
ts.tv_nsec = abstime->tv_nsec - ts.tv_nsec;
if (ts.tv_nsec < 0) {
ts.tv_sec--;
ts.tv_nsec += 1000000000;
}
if((ts.tv_nsec < 0) || (ts.tv_sec < 0)) {
if (__timespec_to_absolute(&ts, abstime, clock) < 0)
return ETIMEDOUT;
}
tsp = &ts;
} else {
tsp = NULL;
@ -1204,6 +1336,7 @@ int pthread_cond_timedwait(pthread_cond_t *cond,
}
/* this one exists only for backward binary compatibility */
int pthread_cond_timedwait_monotonic(pthread_cond_t *cond,
pthread_mutex_t * mutex,
const struct timespec *abstime)
@ -1211,6 +1344,20 @@ int pthread_cond_timedwait_monotonic(pthread_cond_t *cond,
return __pthread_cond_timedwait(cond, mutex, abstime, CLOCK_MONOTONIC);
}
int pthread_cond_timedwait_monotonic_np(pthread_cond_t *cond,
pthread_mutex_t * mutex,
const struct timespec *abstime)
{
return __pthread_cond_timedwait(cond, mutex, abstime, CLOCK_MONOTONIC);
}
int pthread_cond_timedwait_relative_np(pthread_cond_t *cond,
pthread_mutex_t * mutex,
const struct timespec *reltime)
{
return __pthread_cond_timedwait_relative(cond, mutex, reltime);
}
int pthread_cond_timeout_np(pthread_cond_t *cond,
pthread_mutex_t * mutex,
unsigned msecs)

12
libc/docs/OVERVIEW.TXT

@ -63,6 +63,18 @@ time_t:
Instead, Bionic provides a <time64.h> header that defines a time64_t type,
and related functions like mktime64(), localtime64(), etc...
strftime() uses time64_t internally, so the '%s' format (seconds since the
epoch) is supported for dates >= 2038.
strftime_tz():
Bionic also provides the non-standard strftime_tz() function, a variant
of strftime() which also accepts a time locale descriptor as defined
by "struct strftime_locale" in <time.h>.
This function is used by the low-level framework code in Android.
Timezone management:

1
libc/include/arpa/inet.h

@ -31,7 +31,6 @@
#include <stdint.h>
#include <sys/types.h>
#include <netinet/in.h>
#include <netinet/in6.h>
__BEGIN_DECLS

4
libc/include/netinet/in.h

@ -32,6 +32,7 @@
#include <linux/socket.h>
#include <linux/in.h>
#include <linux/in6.h>
#include <netinet/in6.h>
__BEGIN_DECLS
@ -39,6 +40,9 @@ __BEGIN_DECLS
extern int bindresvport (int sd, struct sockaddr_in *sin);
static const struct in6_addr in6addr_any = IN6ADDR_ANY_INIT;
static const struct in6_addr in6addr_loopback = IN6ADDR_LOOPBACK_INIT;
__END_DECLS
#endif /* _NETINET_IN_H_ */

8
libc/include/netinet/in6.h

@ -90,4 +90,12 @@
#define INET6_ADDRSTRLEN 46
#define IPV6_JOIN_GROUP IPV6_ADD_MEMBERSHIP
#define IPV6_LEAVE_GROUP IPV6_DROP_MEMBERSHIP
#define IN6ADDR_ANY_INIT {{{0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0}}}
#define ipv6mr_interface ipv6mr_ifindex
#endif /* _NETINET_IN6_H */

27
libc/include/pthread.h

@ -179,14 +179,41 @@ int pthread_cond_timedwait(pthread_cond_t *cond,
* to the CLOCK_MONOTONIC clock instead, to avoid any problems when
* the wall-clock time is changed brutally
*/
int pthread_cond_timedwait_monotonic_np(pthread_cond_t *cond,
pthread_mutex_t *mutex,
const struct timespec *abstime);
/* BIONIC: DEPRECATED. same as pthread_cond_timedwait_monotonic_np()
* unfortunately pthread_cond_timedwait_monotonic has shipped already
*/
int pthread_cond_timedwait_monotonic(pthread_cond_t *cond,
pthread_mutex_t *mutex,
const struct timespec *abstime);
#define HAVE_PTHREAD_COND_TIMEDWAIT_MONOTONIC 1
/* BIONIC: same as pthread_cond_timedwait, except the 'reltime' given refers
* is relative to the current time.
*/
int pthread_cond_timedwait_relative_np(pthread_cond_t *cond,
pthread_mutex_t *mutex,
const struct timespec *reltime);
#define HAVE_PTHREAD_COND_TIMEDWAIT_RELATIVE 1
int pthread_cond_timeout_np(pthread_cond_t *cond,
pthread_mutex_t * mutex,
unsigned msecs);
/* same as pthread_mutex_lock(), but will wait up to 'msecs' milli-seconds
* before returning. same return values than pthread_mutex_trylock though, i.e.
* returns EBUSY if the lock could not be acquired after the timeout
* expired.
*/
int pthread_mutex_lock_timeout_np(pthread_mutex_t *mutex, unsigned msecs);
int pthread_key_create(pthread_key_t *key, void (*destructor_function)(void *));
int pthread_key_delete (pthread_key_t);
int pthread_setspecific(pthread_key_t key, const void *value);

22
libc/include/time.h

@ -79,9 +79,29 @@ extern struct tm* gmtime_r(const time_t *timep, struct tm *result);
extern char* strptime(const char *buf, const char *fmt, struct tm *tm);
extern size_t strftime(char *s, size_t max, const char *format, const struct tm *tm);
/* ANDROID-BEGIN */
struct strftime_locale {
const char * mon[12];
const char * month[12];
const char * standalone_month[12];
const char * wday[7];
const char * weekday[7];
const char * X_fmt;
const char * x_fmt;
const char * c_fmt;
const char * am;
const char * pm;
const char * date_fmt;
};
extern size_t strftime_tz(char *s, size_t max, const char *format, const struct tm *tm, const struct strftime_locale* lc);
/* ANDROID-END */
extern char *ctime(const time_t *timep);
extern char *ctime_r(const time_t *timep, char *buf);
extern void tzset(void);
/* global includes */
extern char* tzname[];
extern int daylight;
@ -89,7 +109,7 @@ extern long int timezone;
#define CLOCKS_PER_SEC 1000000
extern clock_t clock();
extern clock_t clock(void);
/* BIONIC: extra linux clock goodies */
extern int clock_getres(int, struct timespec *);

45
libc/kernel/common/linux/akm8973.h Normal file

@ -0,0 +1,45 @@
/****************************************************************************
****************************************************************************
***
*** This header was automatically generated from a Linux kernel header
*** of the same name, to make information necessary for userspace to
*** call into the kernel available to libc. It contains only constants,
*** structures, and macros generated from the original header, and thus,
*** contains no copyrightable information.
***
****************************************************************************
****************************************************************************/
#ifndef AKM8973_H
#define AKM8973_H
#include <linux/ioctl.h>
#define AKMIO 0xA1
#define ECS_IOCTL_WRITE _IOW(AKMIO, 0x01, char[5])
#define ECS_IOCTL_READ _IOWR(AKMIO, 0x02, char[5])
#define ECS_IOCTL_RESET _IO(AKMIO, 0x03)
#define ECS_IOCTL_SET_MODE _IOW(AKMIO, 0x04, short)
#define ECS_IOCTL_GETDATA _IOR(AKMIO, 0x05, char[RBUFF_SIZE+1])
#define ECS_IOCTL_SET_YPR _IOW(AKMIO, 0x06, short[12])
#define ECS_IOCTL_GET_OPEN_STATUS _IOR(AKMIO, 0x07, int)
#define ECS_IOCTL_GET_CLOSE_STATUS _IOR(AKMIO, 0x08, int)
#define ECS_IOCTL_GET_DELAY _IOR(AKMIO, 0x30, short)
#define ECS_IOCTL_APP_SET_MODE _IOW(AKMIO, 0x10, short)
#define ECS_IOCTL_APP_SET_MFLAG _IOW(AKMIO, 0x11, short)
#define ECS_IOCTL_APP_GET_MFLAG _IOW(AKMIO, 0x12, short)
#define ECS_IOCTL_APP_SET_AFLAG _IOW(AKMIO, 0x13, short)
#define ECS_IOCTL_APP_GET_AFLAG _IOR(AKMIO, 0x14, short)
#define ECS_IOCTL_APP_SET_TFLAG _IOR(AKMIO, 0x15, short)
#define ECS_IOCTL_APP_GET_TFLAG _IOR(AKMIO, 0x16, short)
#define ECS_IOCTL_APP_RESET_PEDOMETER _IO(AKMIO, 0x17)
#define ECS_IOCTL_APP_SET_DELAY _IOW(AKMIO, 0x18, short)
#define ECS_IOCTL_APP_GET_DELAY ECS_IOCTL_GET_DELAY
#define ECS_IOCTL_APP_SET_MVFLAG _IOW(AKMIO, 0x19, short)
#define ECS_IOCTL_APP_GET_MVFLAG _IOR(AKMIO, 0x1A, short)
#define ECS_IOCTL_SET_STEP_CNT _IOW(AKMIO, 0x20, short)
#endif

54
libc/kernel/common/linux/android_pmem.h

@ -12,41 +12,37 @@
#ifndef _ANDROID_PMEM_H_
#define _ANDROID_PMEM_H_
#include <stdint.h>
#define PMEM_IOCTL_MAGIC 'p'
#define PMEM_GET_PHYS _IOW(PMEM_IOCTL_MAGIC, 1, unsigned int)
#define PMEM_MAP _IOW(PMEM_IOCTL_MAGIC, 2, unsigned int)
#define PMEM_GET_SIZE _IOW(PMEM_IOCTL_MAGIC, 3, unsigned int)
#define PMEM_UNMAP _IOW(PMEM_IOCTL_MAGIC, 4, unsigned int)
#ifndef __user
#define __user
#endif
#define PMEM_ALLOCATE _IOW(PMEM_IOCTL_MAGIC, 5, unsigned int)
#define PMEM_CONNECT _IOW(PMEM_IOCTL_MAGIC, 6, unsigned int)
#define PMEM_GET_TOTAL_SIZE _IOW(PMEM_IOCTL_MAGIC, 7, unsigned int)
struct android_pmem_platform_data
{
const char* name;
unsigned long start;
unsigned long size;
unsigned no_allocator;
unsigned cached;
unsigned buffered;
};
struct pmem_region {
unsigned long offset;
unsigned long len;
};
#define PMEM_IOCTL_MAGIC 'p'
#define PMEM_GET_PHYS _IOW(PMEM_IOCTL_MAGIC, 1, struct pmem_region *)
#define PMEM_MAP _IOW(PMEM_IOCTL_MAGIC, 2, struct pmem_region *)
#define PMEM_GET_SIZE _IOW(PMEM_IOCTL_MAGIC, 3, struct pmem_region *)
#define PMEM_UNMAP _IOW(PMEM_IOCTL_MAGIC, 4, struct pmem_region *)
#define PMEM_ALLOCATE _IOW(PMEM_IOCTL_MAGIC, 5, unsigned int)
#define PMEM_CONNECT _IOW(PMEM_IOCTL_MAGIC, 6, unsigned int)
#define PMEM_GET_TOTAL_SIZE _IOW(PMEM_IOCTL_MAGIC, 7, struct pmem_region *)
#define HW3D_REVOKE_GPU _IOW(PMEM_IOCTL_MAGIC, 8, unsigned int)
#define HW3D_GRANT_GPU _IOW(PMEM_IOCTL_MAGIC, 9, unsigned int)
#define HW3D_WAIT_IRQ _IOW(PMEM_IOCTL_MAGIC,10, unsigned int)
struct android_pmem_platform_data;
struct pmem_file_operations {
int (*mmap) (struct file *, struct vm_area_struct *);
int (*open) (struct inode *, struct file *);
ssize_t (*read) (struct file *, char __user *, size_t, long long *);
int (*release) (struct inode *, struct file *);
long (*ioctl) (struct file *, unsigned int, unsigned long);
};
#endif

23
libc/kernel/common/linux/capella_cm3602.h Normal file

@ -0,0 +1,23 @@
/****************************************************************************
****************************************************************************
***
*** This header was automatically generated from a Linux kernel header
*** of the same name, to make information necessary for userspace to
*** call into the kernel available to libc. It contains only constants,
*** structures, and macros generated from the original header, and thus,
*** contains no copyrightable information.
***
****************************************************************************
****************************************************************************/
#ifndef __LINUX_CAPELLA_CM3602_H
#define __LINUX_CAPELLA_CM3602_H
#include <linux/types.h>
#include <linux/ioctl.h>
#define CAPELLA_CM3602_IOCTL_MAGIC 'c'
#define CAPELLA_CM3602_IOCTL_GET_ENABLED _IOR(CAPELLA_CM3602_IOCTL_MAGIC, 1, int *)
#define CAPELLA_CM3602_IOCTL_ENABLE _IOW(CAPELLA_CM3602_IOCTL_MAGIC, 2, int *)
#endif

321
libc/kernel/common/linux/ethtool.h Normal file

@ -0,0 +1,321 @@
/****************************************************************************
****************************************************************************
***
*** This header was automatically generated from a Linux kernel header
*** of the same name, to make information necessary for userspace to
*** call into the kernel available to libc. It contains only constants,
*** structures, and macros generated from the original header, and thus,
*** contains no copyrightable information.
***
****************************************************************************
****************************************************************************/
#ifndef _LINUX_ETHTOOL_H
#define _LINUX_ETHTOOL_H
#include <linux/types.h>
struct ethtool_cmd {
__u32 cmd;
__u32 supported;
__u32 advertising;
__u16 speed;
__u8 duplex;
__u8 port;
__u8 phy_address;
__u8 transceiver;
__u8 autoneg;
__u32 maxtxpkt;
__u32 maxrxpkt;
__u16 speed_hi;
__u16 reserved2;
__u32 reserved[3];
};
#define ETHTOOL_BUSINFO_LEN 32
struct ethtool_drvinfo {
__u32 cmd;
char driver[32];
char version[32];
char fw_version[32];
char bus_info[ETHTOOL_BUSINFO_LEN];
char reserved1[32];
char reserved2[12];
__u32 n_priv_flags;
__u32 n_stats;
__u32 testinfo_len;
__u32 eedump_len;
__u32 regdump_len;
};
#define SOPASS_MAX 6
struct ethtool_wolinfo {
__u32 cmd;
__u32 supported;
__u32 wolopts;
__u8 sopass[SOPASS_MAX];
};
struct ethtool_value {
__u32 cmd;
__u32 data;
};
struct ethtool_regs {
__u32 cmd;
__u32 version;
__u32 len;
__u8 data[0];
};
struct ethtool_eeprom {
__u32 cmd;
__u32 magic;
__u32 offset;
__u32 len;
__u8 data[0];
};
struct ethtool_coalesce {
__u32 cmd;
__u32 rx_coalesce_usecs;
__u32 rx_max_coalesced_frames;
__u32 rx_coalesce_usecs_irq;
__u32 rx_max_coalesced_frames_irq;
__u32 tx_coalesce_usecs;
__u32 tx_max_coalesced_frames;
__u32 tx_coalesce_usecs_irq;
__u32 tx_max_coalesced_frames_irq;
__u32 stats_block_coalesce_usecs;
__u32 use_adaptive_rx_coalesce;
__u32 use_adaptive_tx_coalesce;
__u32 pkt_rate_low;
__u32 rx_coalesce_usecs_low;
__u32 rx_max_coalesced_frames_low;
__u32 tx_coalesce_usecs_low;
__u32 tx_max_coalesced_frames_low;
__u32 pkt_rate_high;
__u32 rx_coalesce_usecs_high;
__u32 rx_max_coalesced_frames_high;
__u32 tx_coalesce_usecs_high;
__u32 tx_max_coalesced_frames_high;
__u32 rate_sample_interval;
};
struct ethtool_ringparam {
__u32 cmd;
__u32 rx_max_pending;
__u32 rx_mini_max_pending;
__u32 rx_jumbo_max_pending;
__u32 tx_max_pending;
__u32 rx_pending;
__u32 rx_mini_pending;
__u32 rx_jumbo_pending;
__u32 tx_pending;
};
struct ethtool_pauseparam {
__u32 cmd;
__u32 autoneg;
__u32 rx_pause;
__u32 tx_pause;
};
#define ETH_GSTRING_LEN 32
enum ethtool_stringset {
ETH_SS_TEST = 0,
ETH_SS_STATS,
ETH_SS_PRIV_FLAGS,
};
struct ethtool_gstrings {
__u32 cmd;
__u32 string_set;
__u32 len;
__u8 data[0];
};
enum ethtool_test_flags {
ETH_TEST_FL_OFFLINE = (1 << 0),
ETH_TEST_FL_FAILED = (1 << 1),
};
struct ethtool_test {
__u32 cmd;
__u32 flags;
__u32 reserved;
__u32 len;
__u64 data[0];
};
struct ethtool_stats {
__u32 cmd;
__u32 n_stats;
__u64 data[0];
};
struct ethtool_perm_addr {
__u32 cmd;
__u32 size;
__u8 data[0];
};
enum ethtool_flags {
ETH_FLAG_LRO = (1 << 15),
};
struct ethtool_rxnfc {
__u32 cmd;
__u32 flow_type;
__u64 data;
};
#define ETHTOOL_GSET 0x00000001
#define ETHTOOL_SSET 0x00000002
#define ETHTOOL_GDRVINFO 0x00000003
#define ETHTOOL_GREGS 0x00000004
#define ETHTOOL_GWOL 0x00000005
#define ETHTOOL_SWOL 0x00000006
#define ETHTOOL_GMSGLVL 0x00000007
#define ETHTOOL_SMSGLVL 0x00000008
#define ETHTOOL_NWAY_RST 0x00000009
#define ETHTOOL_GLINK 0x0000000a
#define ETHTOOL_GEEPROM 0x0000000b
#define ETHTOOL_SEEPROM 0x0000000c
#define ETHTOOL_GCOALESCE 0x0000000e
#define ETHTOOL_SCOALESCE 0x0000000f
#define ETHTOOL_GRINGPARAM 0x00000010
#define ETHTOOL_SRINGPARAM 0x00000011
#define ETHTOOL_GPAUSEPARAM 0x00000012
#define ETHTOOL_SPAUSEPARAM 0x00000013
#define ETHTOOL_GRXCSUM 0x00000014
#define ETHTOOL_SRXCSUM 0x00000015
#define ETHTOOL_GTXCSUM 0x00000016
#define ETHTOOL_STXCSUM 0x00000017
#define ETHTOOL_GSG 0x00000018
#define ETHTOOL_SSG 0x00000019
#define ETHTOOL_TEST 0x0000001a
#define ETHTOOL_GSTRINGS 0x0000001b
#define ETHTOOL_PHYS_ID 0x0000001c
#define ETHTOOL_GSTATS 0x0000001d
#define ETHTOOL_GTSO 0x0000001e
#define ETHTOOL_STSO 0x0000001f
#define ETHTOOL_GPERMADDR 0x00000020
#define ETHTOOL_GUFO 0x00000021
#define ETHTOOL_SUFO 0x00000022
#define ETHTOOL_GGSO 0x00000023
#define ETHTOOL_SGSO 0x00000024
#define ETHTOOL_GFLAGS 0x00000025
#define ETHTOOL_SFLAGS 0x00000026
#define ETHTOOL_GPFLAGS 0x00000027
#define ETHTOOL_SPFLAGS 0x00000028
#define ETHTOOL_GRXFH 0x00000029
#define ETHTOOL_SRXFH 0x0000002a
#define ETHTOOL_GGRO 0x0000002b
#define ETHTOOL_SGRO 0x0000002c
#define SPARC_ETH_GSET ETHTOOL_GSET
#define SPARC_ETH_SSET ETHTOOL_SSET
#define SUPPORTED_10baseT_Half (1 << 0)
#define SUPPORTED_10baseT_Full (1 << 1)
#define SUPPORTED_100baseT_Half (1 << 2)
#define SUPPORTED_100baseT_Full (1 << 3)
#define SUPPORTED_1000baseT_Half (1 << 4)
#define SUPPORTED_1000baseT_Full (1 << 5)
#define SUPPORTED_Autoneg (1 << 6)
#define SUPPORTED_TP (1 << 7)
#define SUPPORTED_AUI (1 << 8)
#define SUPPORTED_MII (1 << 9)
#define SUPPORTED_FIBRE (1 << 10)
#define SUPPORTED_BNC (1 << 11)
#define SUPPORTED_10000baseT_Full (1 << 12)
#define SUPPORTED_Pause (1 << 13)
#define SUPPORTED_Asym_Pause (1 << 14)
#define SUPPORTED_2500baseX_Full (1 << 15)
#define ADVERTISED_10baseT_Half (1 << 0)
#define ADVERTISED_10baseT_Full (1 << 1)
#define ADVERTISED_100baseT_Half (1 << 2)
#define ADVERTISED_100baseT_Full (1 << 3)
#define ADVERTISED_1000baseT_Half (1 << 4)
#define ADVERTISED_1000baseT_Full (1 << 5)
#define ADVERTISED_Autoneg (1 << 6)
#define ADVERTISED_TP (1 << 7)
#define ADVERTISED_AUI (1 << 8)
#define ADVERTISED_MII (1 << 9)
#define ADVERTISED_FIBRE (1 << 10)
#define ADVERTISED_BNC (1 << 11)
#define ADVERTISED_10000baseT_Full (1 << 12)
#define ADVERTISED_Pause (1 << 13)
#define ADVERTISED_Asym_Pause (1 << 14)
#define ADVERTISED_2500baseX_Full (1 << 15)
#define SPEED_10 10
#define SPEED_100 100
#define SPEED_1000 1000
#define SPEED_2500 2500
#define SPEED_10000 10000
#define DUPLEX_HALF 0x00
#define DUPLEX_FULL 0x01
#define PORT_TP 0x00
#define PORT_AUI 0x01
#define PORT_MII 0x02
#define PORT_FIBRE 0x03
#define PORT_BNC 0x04
#define XCVR_INTERNAL 0x00
#define XCVR_EXTERNAL 0x01
#define XCVR_DUMMY1 0x02
#define XCVR_DUMMY2 0x03
#define XCVR_DUMMY3 0x04
#define AUTONEG_DISABLE 0x00
#define AUTONEG_ENABLE 0x01
#define WAKE_PHY (1 << 0)
#define WAKE_UCAST (1 << 1)
#define WAKE_MCAST (1 << 2)
#define WAKE_BCAST (1 << 3)
#define WAKE_ARP (1 << 4)
#define WAKE_MAGIC (1 << 5)
#define WAKE_MAGICSECURE (1 << 6)
#define TCP_V4_FLOW 0x01
#define UDP_V4_FLOW 0x02
#define SCTP_V4_FLOW 0x03
#define AH_ESP_V4_FLOW 0x04
#define TCP_V6_FLOW 0x05
#define UDP_V6_FLOW 0x06
#define SCTP_V6_FLOW 0x07
#define AH_ESP_V6_FLOW 0x08
#define RXH_DEV_PORT (1 << 0)
#define RXH_L2DA (1 << 1)
#define RXH_VLAN (1 << 2)
#define RXH_L3_PROTO (1 << 3)
#define RXH_IP_SRC (1 << 4)
#define RXH_IP_DST (1 << 5)
#define RXH_L4_B_0_1 (1 << 6)
#define RXH_L4_B_2_3 (1 << 7)
#define RXH_DISCARD (1 << 31)
#endif

24
libc/kernel/common/linux/lightsensor.h Normal file

@ -0,0 +1,24 @@
/****************************************************************************
****************************************************************************
***
*** This header was automatically generated from a Linux kernel header
*** of the same name, to make information necessary for userspace to
*** call into the kernel available to libc. It contains only constants,
*** structures, and macros generated from the original header, and thus,
*** contains no copyrightable information.
***
****************************************************************************
****************************************************************************/
#ifndef __LINUX_LIGHTSENSOR_H
#define __LINUX_LIGHTSENSOR_H
#include <linux/types.h>
#include <linux/ioctl.h>
#define LIGHTSENSOR_IOCTL_MAGIC 'l'
#define LIGHTSENSOR_IOCTL_GET_ENABLED _IOR(LIGHTSENSOR_IOCTL_MAGIC, 1, int *)
#define LIGHTSENSOR_IOCTL_ENABLE _IOW(LIGHTSENSOR_IOCTL_MAGIC, 2, int *)
#endif

30
libc/kernel/common/linux/lis331dlh.h Normal file

@ -0,0 +1,30 @@
/****************************************************************************
****************************************************************************
***
*** This header was automatically generated from a Linux kernel header
*** of the same name, to make information necessary for userspace to
*** call into the kernel available to libc. It contains only constants,
*** structures, and macros generated from the original header, and thus,
*** contains no copyrightable information.
***
****************************************************************************
****************************************************************************/
#ifndef __LIS331DLH_H__
#define __LIS331DLH_H__
#include <linux/ioctl.h>
#define LIS331DLH_IOCTL_BASE 77
#define LIS331DLH_IOCTL_SET_DELAY _IOW(LIS331DLH_IOCTL_BASE, 0, int)
#define LIS331DLH_IOCTL_GET_DELAY _IOR(LIS331DLH_IOCTL_BASE, 1, int)
#define LIS331DLH_IOCTL_SET_ENABLE _IOW(LIS331DLH_IOCTL_BASE, 2, int)
#define LIS331DLH_IOCTL_GET_ENABLE _IOR(LIS331DLH_IOCTL_BASE, 3, int)
#define LIS331DLH_IOCTL_SET_G_RANGE _IOW(LIS331DLH_IOCTL_BASE, 4, int)
#define LIS331DLH_G_2G 0x00
#define LIS331DLH_G_4G 0x10
#define LIS331DLH_G_8G 0x30
#endif

44
libc/kernel/common/linux/msm_hw3d.h Normal file

@ -0,0 +1,44 @@
/****************************************************************************
****************************************************************************
***
*** This header was automatically generated from a Linux kernel header
*** of the same name, to make information necessary for userspace to
*** call into the kernel available to libc. It contains only constants,
*** structures, and macros generated from the original header, and thus,
*** contains no copyrightable information.
***
****************************************************************************
****************************************************************************/
#ifndef _MSM_HW3D_H_
#define _MSM_HW3D_H_
#include <linux/fs.h>
#include <linux/ioctl.h>
struct hw3d_region;
#define HW3D_IOCTL_MAGIC 'h'
#define HW3D_WAIT_FOR_REVOKE _IO(HW3D_IOCTL_MAGIC, 0x80)
#define HW3D_WAIT_FOR_INTERRUPT _IO(HW3D_IOCTL_MAGIC, 0x81)
#define HW3D_GET_REGIONS _IOR(HW3D_IOCTL_MAGIC, 0x82, struct hw3d_region *)
#define HW3D_REGION_OFFSET(id) ((((uint32_t)(id)) & 0xf) << 28)
#define HW3D_REGION_ID(addr) (((uint32_t)(addr) >> 28) & 0xf)
#define HW3D_OFFSET_IN_REGION(addr) ((uint32_t)(addr) & ~(0xfUL << 28))
enum {
HW3D_EBI = 0,
HW3D_SMI = 1,
HW3D_REGS = 2,
HW3D_NUM_REGIONS = HW3D_REGS + 1,
};
struct hw3d_region {
unsigned long phys;
unsigned long map_offset;
unsigned long len;
};
#endif

192
libc/kernel/common/linux/msm_kgsl.h Normal file

@ -0,0 +1,192 @@
/****************************************************************************
****************************************************************************
***
*** This header was automatically generated from a Linux kernel header
*** of the same name, to make information necessary for userspace to
*** call into the kernel available to libc. It contains only constants,
*** structures, and macros generated from the original header, and thus,
*** contains no copyrightable information.
***
****************************************************************************
****************************************************************************/
#ifndef _MSM_KGSL_H
#define _MSM_KGSL_H
#define KGSL_CONTEXT_SAVE_GMEM 1
#define KGSL_CONTEXT_NO_GMEM_ALLOC 2
#define KGSL_FLAGS_NORMALMODE 0x00000000
#define KGSL_FLAGS_SAFEMODE 0x00000001
#define KGSL_FLAGS_INITIALIZED0 0x00000002
#define KGSL_FLAGS_INITIALIZED 0x00000004
#define KGSL_FLAGS_STARTED 0x00000008
#define KGSL_FLAGS_ACTIVE 0x00000010
#define KGSL_FLAGS_RESERVED0 0x00000020
#define KGSL_FLAGS_RESERVED1 0x00000040
#define KGSL_FLAGS_RESERVED2 0x00000080
enum kgsl_deviceid {
KGSL_DEVICE_ANY = 0x00000000,
KGSL_DEVICE_YAMATO = 0x00000001,
KGSL_DEVICE_G12 = 0x00000002,
KGSL_DEVICE_MAX = 0x00000002
};
struct kgsl_devinfo {
unsigned int device_id;
unsigned int chip_id;
unsigned int mmu_enabled;
unsigned int gmem_gpubaseaddr;
unsigned int gmem_hostbaseaddr;
unsigned int gmem_sizebytes;
};
struct kgsl_devmemstore {
volatile unsigned int soptimestamp;
unsigned int sbz;
volatile unsigned int eoptimestamp;
unsigned int sbz2;
};
#define KGSL_DEVICE_MEMSTORE_OFFSET(field) offsetof(struct kgsl_devmemstore, field)
enum kgsl_timestamp_type {
KGSL_TIMESTAMP_CONSUMED = 0x00000001,
KGSL_TIMESTAMP_RETIRED = 0x00000002,
KGSL_TIMESTAMP_MAX = 0x00000002,
};
enum kgsl_property_type {
KGSL_PROP_DEVICE_INFO = 0x00000001,
KGSL_PROP_DEVICE_SHADOW = 0x00000002,
KGSL_PROP_DEVICE_POWER = 0x00000003,
KGSL_PROP_SHMEM = 0x00000004,
KGSL_PROP_SHMEM_APERTURES = 0x00000005,
KGSL_PROP_MMU_ENABLE = 0x00000006
};
struct kgsl_shadowprop {
unsigned int gpuaddr;
unsigned int size;
unsigned int flags;
};
#define KGSL_IOC_TYPE 0x09
struct kgsl_device_getproperty {
unsigned int type;
void *value;
unsigned int sizebytes;
};
#define IOCTL_KGSL_DEVICE_GETPROPERTY _IOWR(KGSL_IOC_TYPE, 0x2, struct kgsl_device_getproperty)
struct kgsl_device_regread {
unsigned int offsetwords;
unsigned int value;
};
#define IOCTL_KGSL_DEVICE_REGREAD _IOWR(KGSL_IOC_TYPE, 0x3, struct kgsl_device_regread)
struct kgsl_device_waittimestamp {
unsigned int timestamp;
unsigned int timeout;
};
#define IOCTL_KGSL_DEVICE_WAITTIMESTAMP _IOW(KGSL_IOC_TYPE, 0x6, struct kgsl_device_waittimestamp)
struct kgsl_ringbuffer_issueibcmds {
unsigned int drawctxt_id;
unsigned int ibaddr;
unsigned int sizedwords;
unsigned int timestamp;
unsigned int flags;
};
#define IOCTL_KGSL_RINGBUFFER_ISSUEIBCMDS _IOWR(KGSL_IOC_TYPE, 0x10, struct kgsl_ringbuffer_issueibcmds)
struct kgsl_cmdstream_readtimestamp {
unsigned int type;
unsigned int timestamp;
};
#define IOCTL_KGSL_CMDSTREAM_READTIMESTAMP _IOR(KGSL_IOC_TYPE, 0x11, struct kgsl_cmdstream_readtimestamp)
struct kgsl_cmdstream_freememontimestamp {
unsigned int gpuaddr;
unsigned int type;
unsigned int timestamp;
};
#define IOCTL_KGSL_CMDSTREAM_FREEMEMONTIMESTAMP _IOR(KGSL_IOC_TYPE, 0x12, struct kgsl_cmdstream_freememontimestamp)
struct kgsl_drawctxt_create {
unsigned int flags;
unsigned int drawctxt_id;
};
#define IOCTL_KGSL_DRAWCTXT_CREATE _IOWR(KGSL_IOC_TYPE, 0x13, struct kgsl_drawctxt_create)
struct kgsl_drawctxt_destroy {
unsigned int drawctxt_id;
};
#define IOCTL_KGSL_DRAWCTXT_DESTROY _IOW(KGSL_IOC_TYPE, 0x14, struct kgsl_drawctxt_destroy)
struct kgsl_sharedmem_from_pmem {
int pmem_fd;
unsigned int gpuaddr;
};
#define IOCTL_KGSL_SHAREDMEM_FROM_PMEM _IOWR(KGSL_IOC_TYPE, 0x20, struct kgsl_sharedmem_from_pmem)
struct kgsl_sharedmem_free {
unsigned int gpuaddr;
};
#define IOCTL_KGSL_SHAREDMEM_FREE _IOW(KGSL_IOC_TYPE, 0x21, struct kgsl_sharedmem_free)
struct kgsl_gmem_desc {
unsigned int x;
unsigned int y;
unsigned int width;
unsigned int height;
unsigned int pitch;
};
struct kgsl_buffer_desc {
void *hostptr;
unsigned int gpuaddr;
int size;
unsigned int format;
unsigned int pitch;
unsigned int enabled;
};
struct kgsl_bind_gmem_shadow {
unsigned int drawctxt_id;
struct kgsl_gmem_desc gmem_desc;
unsigned int shadow_x;
unsigned int shadow_y;
struct kgsl_buffer_desc shadow_buffer;
unsigned int buffer_id;
};
#define IOCTL_KGSL_DRAWCTXT_BIND_GMEM_SHADOW _IOW(KGSL_IOC_TYPE, 0x22, struct kgsl_bind_gmem_shadow)
struct kgsl_sharedmem_from_vmalloc {
unsigned int gpuaddr;
unsigned int hostptr;
int force_no_low_watermark;
};
#define IOCTL_KGSL_SHAREDMEM_FROM_VMALLOC _IOWR(KGSL_IOC_TYPE, 0x23, struct kgsl_sharedmem_from_vmalloc)
#define IOCTL_KGSL_SHAREDMEM_FLUSH_CACHE _IOW(KGSL_IOC_TYPE, 0x24, struct kgsl_sharedmem_free)
#endif

3
libc/kernel/common/linux/msm_mdp.h

@ -30,6 +30,7 @@ enum {
MDP_Y_CBCR_H2V1,
MDP_RGBA_8888,
MDP_BGRA_8888,
MDP_RGBX_8888,
MDP_IMGTYPE_LIMIT
};
@ -46,6 +47,7 @@ enum {
#define MDP_ROT_270 (MDP_ROT_90|MDP_FLIP_UD|MDP_FLIP_LR)
#define MDP_DITHER 0x8
#define MDP_BLUR 0x10
#define MDP_BLEND_FG_PREMULT 0x20000
#define MDP_TRANSP_NOP 0xffffffff
#define MDP_ALPHA_NOP 0xff
@ -81,3 +83,4 @@ struct mdp_blit_req_list {
};
#endif

212
libc/kernel/common/linux/msm_q6vdec.h Normal file

@ -0,0 +1,212 @@
/****************************************************************************
****************************************************************************
***
*** This header was automatically generated from a Linux kernel header
*** of the same name, to make information necessary for userspace to
*** call into the kernel available to libc. It contains only constants,
*** structures, and macros generated from the original header, and thus,
*** contains no copyrightable information.
***
****************************************************************************
****************************************************************************/
#ifndef _MSM_VDEC_H_
#define _MSM_VDEC_H_
#include <linux/types.h>
#define VDEC_IOCTL_MAGIC 'v'
#define VDEC_IOCTL_INITIALIZE _IOWR(VDEC_IOCTL_MAGIC, 1, struct vdec_init)
#define VDEC_IOCTL_SETBUFFERS _IOW(VDEC_IOCTL_MAGIC, 2, struct vdec_buffer)
#define VDEC_IOCTL_QUEUE _IOWR(VDEC_IOCTL_MAGIC, 3, struct vdec_input_buf)
#define VDEC_IOCTL_REUSEFRAMEBUFFER _IOW(VDEC_IOCTL_MAGIC, 4, unsigned int)
#define VDEC_IOCTL_FLUSH _IOW(VDEC_IOCTL_MAGIC, 5, unsigned int)
#define VDEC_IOCTL_EOS _IO(VDEC_IOCTL_MAGIC, 6)
#define VDEC_IOCTL_GETMSG _IOR(VDEC_IOCTL_MAGIC, 7, struct vdec_msg)
#define VDEC_IOCTL_CLOSE _IO(VDEC_IOCTL_MAGIC, 8)
#define VDEC_IOCTL_FREEBUFFERS _IOW(VDEC_IOCTL_MAGIC, 9, struct vdec_buf_info)
#define VDEC_IOCTL_GETDECATTRIBUTES _IOR(VDEC_IOCTL_MAGIC, 10, struct vdec_dec_attributes)
enum {
VDEC_FRAME_DECODE_OK,
VDEC_FRAME_DECODE_ERR,
VDEC_FATAL_ERR,
VDEC_FLUSH_FINISH,
VDEC_EOS,
VDEC_FRAME_FLUSH,
VDEC_STREAM_SWITCH,
VDEC_SUSPEND_FINISH,
VDEC_BUFFER_CONSUMED
};
enum {
VDEC_FLUSH_INPUT,
VDEC_FLUSH_OUTPUT,
VDEC_FLUSH_ALL
};
enum {
VDEC_BUFFER_TYPE_INPUT,
VDEC_BUFFER_TYPE_OUTPUT,
VDEC_BUFFER_TYPE_INTERNAL1,
VDEC_BUFFER_TYPE_INTERNAL2,
};
enum {
VDEC_QUEUE_SUCCESS,
VDEC_QUEUE_FAILED,
VDEC_QUEUE_BADSTATE,
};
struct vdec_input_buf_info {
u32 offset;
u32 data;
u32 size;
int timestamp_lo;
int timestamp_hi;
int avsync_state;
u32 flags;
};
struct vdec_buf_desc {
u32 bufsize;
u32 num_min_buffers;
u32 num_max_buffers;
};
struct vdec_buf_req {
u32 max_input_queue_size;
struct vdec_buf_desc input;
struct vdec_buf_desc output;
struct vdec_buf_desc dec_req1;
struct vdec_buf_desc dec_req2;
};
struct vdec_region_info {
u32 src_id;
u32 offset;
u32 size;
};
struct vdec_config {
u32 fourcc;
u32 width;
u32 height;
u32 order;
u32 notify_enable;
u32 vc1_rowbase;
u32 h264_startcode_detect;
u32 h264_nal_len_size;
u32 postproc_flag;
u32 fruc_enable;
u32 reserved;
};
struct vdec_vc1_panscan_regions {
int num;
int width[4];
int height[4];
int xoffset[4];
int yoffset[4];
};
struct vdec_cropping_window {
u32 x1;
u32 y1;
u32 x2;
u32 y2;
};
struct vdec_frame_info {
u32 status;
u32 offset;
u32 data1;
u32 data2;
int timestamp_lo;
int timestamp_hi;
int cal_timestamp_lo;
int cal_timestamp_hi;
u32 dec_width;
u32 dec_height;
struct vdec_cropping_window cwin;
u32 picture_type[2];
u32 picture_format;
u32 vc1_rangeY;
u32 vc1_rangeUV;
u32 picture_resolution;
u32 frame_disp_repeat;
u32 repeat_first_field;
u32 top_field_first;
u32 interframe_interp;
struct vdec_vc1_panscan_regions panscan;
u32 concealed_macblk_num;
u32 flags;
u32 performance_stats;
u32 data3;
};
struct vdec_buf_info {
u32 buf_type;
struct vdec_region_info region;
u32 num_buf;
u32 islast;
};
struct vdec_buffer {
u32 pmem_id;
struct vdec_buf_info buf;
};
struct vdec_sequence {
u8 *header;
u32 len;
};
struct vdec_config_sps {
struct vdec_config cfg;
struct vdec_sequence seq;
};
#define VDEC_MSG_REUSEINPUTBUFFER 1
#define VDEC_MSG_FRAMEDONE 2
struct vdec_msg {
u32 id;
union {
u32 buf_id;
struct vdec_frame_info vfr_info;
};
};
struct vdec_init {
struct vdec_config_sps sps_cfg;
struct vdec_buf_req *buf_req;
};
struct vdec_input_buf {
u32 pmem_id;
struct vdec_input_buf_info buffer;
struct vdec_queue_status *queue_status;
};
struct vdec_queue_status {
u32 status;
};
struct vdec_dec_attributes {
u32 fourcc;
u32 profile;
u32 level;
u32 dec_pic_width;
u32 dec_pic_height;
struct vdec_buf_desc input;
struct vdec_buf_desc output;
struct vdec_buf_desc dec_req1;
struct vdec_buf_desc dec_req2;
};
#endif

109
libc/kernel/common/linux/msm_q6venc.h Executable file

@ -0,0 +1,109 @@
/****************************************************************************
****************************************************************************
***
*** This header was automatically generated from a Linux kernel header
*** of the same name, to make information necessary for userspace to
*** call into the kernel available to libc. It contains only constants,
*** structures, and macros generated from the original header, and thus,
*** contains no copyrightable information.
***
****************************************************************************
****************************************************************************/
#ifndef _MSM_VENC_H_
#define _MSM_VENC_H_
#include <linux/types.h>
struct venc_buf {
unsigned int src_id;
int fd;
unsigned long offset;
unsigned long size;
};
struct q6_init_config {
unsigned short venc_standard;
unsigned short partial_run_length_flag;
unsigned short h263_annex_ispt;
unsigned short h263_annex_jspt;
unsigned short h263_annex_tspt;
unsigned short rc_flag;
unsigned short one_mv_flag;
unsigned short acdc_pred_enable;
unsigned short rounding_bit_ctrl;
unsigned short rotation_flag;
unsigned short max_mvx;
unsigned short max_mvy;
unsigned short enc_frame_height_inmb;
unsigned short enc_frame_width_inmb;
unsigned short dvs_frame_height;
unsigned short dvs_frame_width;
unsigned int ref_frame_buf1_phy;
unsigned int ref_frame_buf2_phy;
unsigned int rlc_buf1_phy;
unsigned int rlc_buf2_phy;
unsigned int rlc_buf_length;
};
struct init_config {
struct venc_buf ref_frame_buf1;
struct venc_buf ref_frame_buf2;
struct venc_buf rlc_buf1;
struct venc_buf rlc_buf2;
struct q6_init_config q6_init_config;
};
struct q6_encode_param {
unsigned int luma_addr;
unsigned int chroma_addr;
unsigned int x_offset;
unsigned int y_offset;
unsigned int frame_rho_budget;
unsigned int frame_type;
unsigned int qp;
};
struct encode_param {
struct venc_buf y_addr;
unsigned long uv_offset;
struct q6_encode_param q6_encode_param;
};
struct intra_refresh {
unsigned int intra_refresh_enable;
unsigned int intra_mb_num;
};
struct rc_config {
unsigned short max_frame_qp_up_delta;
unsigned short max_frame_qp_down_delta;
unsigned short min_frame_qp;
unsigned short max_frame_qp;
};
struct q6_frame_type {
unsigned int frame_type;
unsigned int frame_len;
unsigned int frame_addr;
unsigned int map_table;
};
struct frame_type {
struct venc_buf frame_addr;
struct q6_frame_type q6_frame_type;
};
#define VENC_IOCTL_MAGIC 'V'
#define VENC_IOCTL_INITIALIZE _IOW(VENC_IOCTL_MAGIC, 1, struct init_config)
#define VENC_IOCTL_ENCODE _IOW(VENC_IOCTL_MAGIC, 2, struct encode_param)
#define VENC_IOCTL_INTRA_REFRESH _IOW(VENC_IOCTL_MAGIC, 3, struct intra_refresh)
#define VENC_IOCTL_RC_CONFIG _IOW(VENC_IOCTL_MAGIC, 4, struct rc_config)
#define VENC_IOCTL_ENCODE_CONFIG _IOW(VENC_IOCTL_MAGIC, 5, struct init_config)
#define VENC_IOCTL_STOP _IO(VENC_IOCTL_MAGIC, 6)
#define VENC_IOCTL_WAIT_FOR_ENCODE _IOR(VENC_IOCTL_MAGIC, 7, struct frame_type)
#define VENC_IOCTL_STOP_ENCODE _IO(VENC_IOCTL_MAGIC, 8)
#endif

22
libc/kernel/common/linux/sfh7743.h Normal file

@ -0,0 +1,22 @@
/****************************************************************************
****************************************************************************
***
*** This header was automatically generated from a Linux kernel header
*** of the same name, to make information necessary for userspace to
*** call into the kernel available to libc. It contains only constants,
*** structures, and macros generated from the original header, and thus,
*** contains no copyrightable information.
***
****************************************************************************
****************************************************************************/
#ifndef _LINUX_SFH7743_H_
#define _LINUX_SFH7743_H_
#include <linux/ioctl.h>
#define SFH7743_IO 0xA2
#define SFH7743_IOCTL_GET_ENABLE _IOR(SFH7743_IO, 0x00, char)
#define SFH7743_IOCTL_SET_ENABLE _IOW(SFH7743_IO, 0x01, char)
#endif

58
libc/kernel/common/linux/videodev.h

@ -12,8 +12,25 @@
#ifndef __LINUX_VIDEODEV_H
#define __LINUX_VIDEODEV_H
#include <linux/types.h>
#include <linux/ioctl.h>
#include <linux/videodev2.h>
#define VID_TYPE_CAPTURE 1
#define VID_TYPE_TUNER 2
#define VID_TYPE_TELETEXT 4
#define VID_TYPE_OVERLAY 8
#define VID_TYPE_CHROMAKEY 16
#define VID_TYPE_CLIPPING 32
#define VID_TYPE_FRAMERAM 64
#define VID_TYPE_SCALES 128
#define VID_TYPE_MONOCHROME 256
#define VID_TYPE_SUBCAPTURE 512
#define VID_TYPE_MPEG_DECODER 1024
#define VID_TYPE_MPEG_ENCODER 2048
#define VID_TYPE_MJPEG_DECODER 4096
#define VID_TYPE_MJPEG_ENCODER 8192
struct video_capability
{
char name[32];
@ -283,45 +300,6 @@ struct video_code
#define VID_PLAY_RESET 13
#define VID_PLAY_END_MARK 14
#define VID_HARDWARE_BT848 1
#define VID_HARDWARE_QCAM_BW 2
#define VID_HARDWARE_PMS 3
#define VID_HARDWARE_QCAM_C 4
#define VID_HARDWARE_PSEUDO 5
#define VID_HARDWARE_SAA5249 6
#define VID_HARDWARE_AZTECH 7
#define VID_HARDWARE_SF16MI 8
#define VID_HARDWARE_RTRACK 9
#define VID_HARDWARE_ZOLTRIX 10
#define VID_HARDWARE_SAA7146 11
#define VID_HARDWARE_VIDEUM 12
#define VID_HARDWARE_RTRACK2 13
#define VID_HARDWARE_PERMEDIA2 14
#define VID_HARDWARE_RIVA128 15
#define VID_HARDWARE_PLANB 16
#define VID_HARDWARE_BROADWAY 17
#define VID_HARDWARE_GEMTEK 18
#define VID_HARDWARE_TYPHOON 19
#define VID_HARDWARE_VINO 20
#define VID_HARDWARE_CADET 21
#define VID_HARDWARE_TRUST 22
#define VID_HARDWARE_TERRATEC 23
#define VID_HARDWARE_CPIA 24
#define VID_HARDWARE_ZR36120 25
#define VID_HARDWARE_ZR36067 26
#define VID_HARDWARE_OV511 27
#define VID_HARDWARE_ZR356700 28
#define VID_HARDWARE_W9966 29
#define VID_HARDWARE_SE401 30
#define VID_HARDWARE_PWC 31
#define VID_HARDWARE_MEYE 32
#define VID_HARDWARE_CPIA2 33
#define VID_HARDWARE_VICAM 34
#define VID_HARDWARE_SF16FMR2 35
#define VID_HARDWARE_W9968CF 36
#define VID_HARDWARE_SAA7114H 37
#define VID_HARDWARE_SN9C102 38
#define VID_HARDWARE_ARV 39
#endif

396
libc/kernel/common/linux/videodev2.h

@ -11,7 +11,10 @@
****************************************************************************/
#ifndef __LINUX_VIDEODEV2_H
#define __LINUX_VIDEODEV2_H
#define __user
#include <sys/time.h>
#include <linux/compiler.h>
#include <linux/ioctl.h>
#include <linux/types.h>
#define VIDEO_MAX_FRAME 32
@ -31,7 +34,7 @@
#define VID_TYPE_MJPEG_DECODER 4096
#define VID_TYPE_MJPEG_ENCODER 8192
#define v4l2_fourcc(a,b,c,d) (((__u32)(a)<<0)|((__u32)(b)<<8)|((__u32)(c)<<16)|((__u32)(d)<<24))
#define v4l2_fourcc(a, b, c, d) ((__u32)(a) | ((__u32)(b) << 8) | ((__u32)(c) << 16) | ((__u32)(d) << 24))
enum v4l2_field {
V4L2_FIELD_ANY = 0,
@ -42,10 +45,12 @@ enum v4l2_field {
V4L2_FIELD_SEQ_TB = 5,
V4L2_FIELD_SEQ_BT = 6,
V4L2_FIELD_ALTERNATE = 7,
V4L2_FIELD_INTERLACED_TB = 8,
V4L2_FIELD_INTERLACED_BT = 9,
};
#define V4L2_FIELD_HAS_TOP(field) ((field) == V4L2_FIELD_TOP || (field) == V4L2_FIELD_INTERLACED || (field) == V4L2_FIELD_SEQ_TB || (field) == V4L2_FIELD_SEQ_BT)
#define V4L2_FIELD_HAS_BOTTOM(field) ((field) == V4L2_FIELD_BOTTOM || (field) == V4L2_FIELD_INTERLACED || (field) == V4L2_FIELD_SEQ_TB || (field) == V4L2_FIELD_SEQ_BT)
#define V4L2_FIELD_HAS_BOTH(field) ((field) == V4L2_FIELD_INTERLACED || (field) == V4L2_FIELD_SEQ_TB || (field) == V4L2_FIELD_SEQ_BT)
#define V4L2_FIELD_HAS_TOP(field) ((field) == V4L2_FIELD_TOP || (field) == V4L2_FIELD_INTERLACED || (field) == V4L2_FIELD_INTERLACED_TB || (field) == V4L2_FIELD_INTERLACED_BT || (field) == V4L2_FIELD_SEQ_TB || (field) == V4L2_FIELD_SEQ_BT)
#define V4L2_FIELD_HAS_BOTTOM(field) ((field) == V4L2_FIELD_BOTTOM || (field) == V4L2_FIELD_INTERLACED || (field) == V4L2_FIELD_INTERLACED_TB || (field) == V4L2_FIELD_INTERLACED_BT || (field) == V4L2_FIELD_SEQ_TB || (field) == V4L2_FIELD_SEQ_BT)
#define V4L2_FIELD_HAS_BOTH(field) ((field) == V4L2_FIELD_INTERLACED || (field) == V4L2_FIELD_INTERLACED_TB || (field) == V4L2_FIELD_INTERLACED_BT || (field) == V4L2_FIELD_SEQ_TB || (field) == V4L2_FIELD_SEQ_BT)
enum v4l2_buf_type {
V4L2_BUF_TYPE_VIDEO_CAPTURE = 1,
@ -53,9 +58,10 @@ enum v4l2_buf_type {
V4L2_BUF_TYPE_VIDEO_OVERLAY = 3,
V4L2_BUF_TYPE_VBI_CAPTURE = 4,
V4L2_BUF_TYPE_VBI_OUTPUT = 5,
V4L2_BUF_TYPE_SLICED_VBI_CAPTURE = 6,
V4L2_BUF_TYPE_SLICED_VBI_OUTPUT = 7,
V4L2_BUF_TYPE_VIDEO_OUTPUT_OVERLAY = 8,
V4L2_BUF_TYPE_PRIVATE = 0x80,
};
@ -118,8 +124,7 @@ struct v4l2_fract {
__u32 denominator;
};
struct v4l2_capability
{
struct v4l2_capability {
__u8 driver[16];
__u8 card[32];
__u8 bus_info[32];
@ -136,6 +141,8 @@ struct v4l2_capability
#define V4L2_CAP_SLICED_VBI_CAPTURE 0x00000040
#define V4L2_CAP_SLICED_VBI_OUTPUT 0x00000080
#define V4L2_CAP_RDS_CAPTURE 0x00000100
#define V4L2_CAP_VIDEO_OUTPUT_OVERLAY 0x00000200
#define V4L2_CAP_HW_FREQ_SEEK 0x00000400
#define V4L2_CAP_TUNER 0x00010000
#define V4L2_CAP_AUDIO 0x00020000
@ -145,8 +152,7 @@ struct v4l2_capability
#define V4L2_CAP_ASYNCIO 0x02000000
#define V4L2_CAP_STREAMING 0x04000000
struct v4l2_pix_format
{
struct v4l2_pix_format {
__u32 width;
__u32 height;
__u32 pixelformat;
@ -158,6 +164,7 @@ struct v4l2_pix_format
};
#define V4L2_PIX_FMT_RGB332 v4l2_fourcc('R', 'G', 'B', '1')
#define V4L2_PIX_FMT_RGB444 v4l2_fourcc('R', '4', '4', '4')
#define V4L2_PIX_FMT_RGB555 v4l2_fourcc('R', 'G', 'B', 'O')
#define V4L2_PIX_FMT_RGB565 v4l2_fourcc('R', 'G', 'B', 'P')
#define V4L2_PIX_FMT_RGB555X v4l2_fourcc('R', 'G', 'B', 'Q')
@ -167,16 +174,25 @@ struct v4l2_pix_format
#define V4L2_PIX_FMT_BGR32 v4l2_fourcc('B', 'G', 'R', '4')
#define V4L2_PIX_FMT_RGB32 v4l2_fourcc('R', 'G', 'B', '4')
#define V4L2_PIX_FMT_GREY v4l2_fourcc('G', 'R', 'E', 'Y')
#define V4L2_PIX_FMT_Y16 v4l2_fourcc('Y', '1', '6', ' ')
#define V4L2_PIX_FMT_PAL8 v4l2_fourcc('P', 'A', 'L', '8')
#define V4L2_PIX_FMT_YVU410 v4l2_fourcc('Y', 'V', 'U', '9')
#define V4L2_PIX_FMT_YVU420 v4l2_fourcc('Y', 'V', '1', '2')
#define V4L2_PIX_FMT_YUYV v4l2_fourcc('Y', 'U', 'Y', 'V')
#define V4L2_PIX_FMT_UYVY v4l2_fourcc('U', 'Y', 'V', 'Y')
#define V4L2_PIX_FMT_VYUY v4l2_fourcc('V', 'Y', 'U', 'Y')
#define V4L2_PIX_FMT_YUV422P v4l2_fourcc('4', '2', '2', 'P')
#define V4L2_PIX_FMT_YUV411P v4l2_fourcc('4', '1', '1', 'P')
#define V4L2_PIX_FMT_Y41P v4l2_fourcc('Y', '4', '1', 'P')
#define V4L2_PIX_FMT_YUV444 v4l2_fourcc('Y', '4', '4', '4')
#define V4L2_PIX_FMT_YUV555 v4l2_fourcc('Y', 'U', 'V', 'O')
#define V4L2_PIX_FMT_YUV565 v4l2_fourcc('Y', 'U', 'V', 'P')
#define V4L2_PIX_FMT_YUV32 v4l2_fourcc('Y', 'U', 'V', '4')
#define V4L2_PIX_FMT_NV12 v4l2_fourcc('N', 'V', '1', '2')
#define V4L2_PIX_FMT_NV21 v4l2_fourcc('N', 'V', '2', '1')
#define V4L2_PIX_FMT_NV16 v4l2_fourcc('N', 'V', '1', '6')
#define V4L2_PIX_FMT_NV61 v4l2_fourcc('N', 'V', '6', '1')
#define V4L2_PIX_FMT_YUV410 v4l2_fourcc('Y', 'U', 'V', '9')
#define V4L2_PIX_FMT_YUV420 v4l2_fourcc('Y', 'U', '1', '2')
@ -185,6 +201,13 @@ struct v4l2_pix_format
#define V4L2_PIX_FMT_HM12 v4l2_fourcc('H', 'M', '1', '2')
#define V4L2_PIX_FMT_SBGGR8 v4l2_fourcc('B', 'A', '8', '1')
#define V4L2_PIX_FMT_SGBRG8 v4l2_fourcc('G', 'B', 'R', 'G')
#define V4L2_PIX_FMT_SGRBG10 v4l2_fourcc('B', 'A', '1', '0')
#define V4L2_PIX_FMT_SGRBG10DPCM8 v4l2_fourcc('B', 'D', '1', '0')
#define V4L2_PIX_FMT_SBGGR16 v4l2_fourcc('B', 'Y', 'R', '2')
#define V4L2_PIX_FMT_W1S_PATT v4l2_fourcc('P', 'A', 'T', '1')
#define V4L2_PIX_FMT_MJPEG v4l2_fourcc('M', 'J', 'P', 'G')
#define V4L2_PIX_FMT_JPEG v4l2_fourcc('J', 'P', 'E', 'G')
@ -196,9 +219,15 @@ struct v4l2_pix_format
#define V4L2_PIX_FMT_PWC1 v4l2_fourcc('P', 'W', 'C', '1')
#define V4L2_PIX_FMT_PWC2 v4l2_fourcc('P', 'W', 'C', '2')
#define V4L2_PIX_FMT_ET61X251 v4l2_fourcc('E', '6', '2', '5')
#define V4L2_PIX_FMT_SPCA501 v4l2_fourcc('S', '5', '0', '1')
#define V4L2_PIX_FMT_SPCA505 v4l2_fourcc('S', '5', '0', '5')
#define V4L2_PIX_FMT_SPCA508 v4l2_fourcc('S', '5', '0', '8')
#define V4L2_PIX_FMT_SPCA561 v4l2_fourcc('S', '5', '6', '1')
#define V4L2_PIX_FMT_PAC207 v4l2_fourcc('P', '2', '0', '7')
#define V4L2_PIX_FMT_PJPG v4l2_fourcc('P', 'J', 'P', 'G')
#define V4L2_PIX_FMT_YVYU v4l2_fourcc('Y', 'V', 'Y', 'U')
struct v4l2_fmtdesc
{
struct v4l2_fmtdesc {
__u32 index;
enum v4l2_buf_type type;
__u32 flags;
@ -209,8 +238,67 @@ struct v4l2_fmtdesc
#define V4L2_FMT_FLAG_COMPRESSED 0x0001
struct v4l2_timecode
{
enum v4l2_frmsizetypes {
V4L2_FRMSIZE_TYPE_DISCRETE = 1,
V4L2_FRMSIZE_TYPE_CONTINUOUS = 2,
V4L2_FRMSIZE_TYPE_STEPWISE = 3,
};
struct v4l2_frmsize_discrete {
__u32 width;
__u32 height;
};
struct v4l2_frmsize_stepwise {
__u32 min_width;
__u32 max_width;
__u32 step_width;
__u32 min_height;
__u32 max_height;
__u32 step_height;
};
struct v4l2_frmsizeenum {
__u32 index;
__u32 pixel_format;
__u32 type;
union {
struct v4l2_frmsize_discrete discrete;
struct v4l2_frmsize_stepwise stepwise;
};
__u32 reserved[2];
};
enum v4l2_frmivaltypes {
V4L2_FRMIVAL_TYPE_DISCRETE = 1,
V4L2_FRMIVAL_TYPE_CONTINUOUS = 2,
V4L2_FRMIVAL_TYPE_STEPWISE = 3,
};
struct v4l2_frmival_stepwise {
struct v4l2_fract min;
struct v4l2_fract max;
struct v4l2_fract step;
};
struct v4l2_frmivalenum {
__u32 index;
__u32 pixel_format;
__u32 width;
__u32 height;
__u32 type;
union {
struct v4l2_fract discrete;
struct v4l2_frmival_stepwise stepwise;
};
__u32 reserved[2];
};
struct v4l2_timecode {
__u32 type;
__u32 flags;
__u8 frames;
@ -232,8 +320,7 @@ struct v4l2_timecode
#define V4L2_TC_USERBITS_USERDEFINED 0x0000
#define V4L2_TC_USERBITS_8BITCHARS 0x0008
struct v4l2_jpegcompression
{
struct v4l2_jpegcompression {
int quality;
int APPn;
@ -252,16 +339,14 @@ struct v4l2_jpegcompression
#define V4L2_JPEG_MARKER_APP (1<<7)
};
struct v4l2_requestbuffers
{
struct v4l2_requestbuffers {
__u32 count;
enum v4l2_buf_type type;
enum v4l2_memory memory;
__u32 reserved[2];
};
struct v4l2_buffer
{
struct v4l2_buffer {
__u32 index;
enum v4l2_buf_type type;
__u32 bytesused;
@ -290,8 +375,7 @@ struct v4l2_buffer
#define V4L2_BUF_FLAG_TIMECODE 0x0100
#define V4L2_BUF_FLAG_INPUT 0x0200
struct v4l2_framebuffer
{
struct v4l2_framebuffer {
__u32 capability;
__u32 flags;
@ -303,29 +387,35 @@ struct v4l2_framebuffer
#define V4L2_FBUF_CAP_CHROMAKEY 0x0002
#define V4L2_FBUF_CAP_LIST_CLIPPING 0x0004
#define V4L2_FBUF_CAP_BITMAP_CLIPPING 0x0008
#define V4L2_FBUF_CAP_LOCAL_ALPHA 0x0010
#define V4L2_FBUF_CAP_GLOBAL_ALPHA 0x0020
#define V4L2_FBUF_CAP_LOCAL_INV_ALPHA 0x0040
#define V4L2_FBUF_CAP_SRC_CHROMAKEY 0x0080
#define V4L2_FBUF_FLAG_PRIMARY 0x0001
#define V4L2_FBUF_FLAG_OVERLAY 0x0002
#define V4L2_FBUF_FLAG_CHROMAKEY 0x0004
#define V4L2_FBUF_FLAG_LOCAL_ALPHA 0x0008
#define V4L2_FBUF_FLAG_GLOBAL_ALPHA 0x0010
#define V4L2_FBUF_FLAG_LOCAL_INV_ALPHA 0x0020
#define V4L2_FBUF_FLAG_SRC_CHROMAKEY 0x0040
struct v4l2_clip
{
struct v4l2_clip {
struct v4l2_rect c;
struct v4l2_clip __user *next;
};
struct v4l2_window
{
struct v4l2_window {
struct v4l2_rect w;
enum v4l2_field field;
__u32 chromakey;
struct v4l2_clip __user *clips;
__u32 clipcount;
void __user *bitmap;
__u8 global_alpha;
};
struct v4l2_captureparm
{
struct v4l2_captureparm {
__u32 capability;
__u32 capturemode;
struct v4l2_fract timeperframe;
@ -337,8 +427,7 @@ struct v4l2_captureparm
#define V4L2_MODE_HIGHQUALITY 0x0001
#define V4L2_CAP_TIMEPERFRAME 0x1000
struct v4l2_outputparm
{
struct v4l2_outputparm {
__u32 capability;
__u32 outputmode;
struct v4l2_fract timeperframe;
@ -411,8 +500,7 @@ typedef __u64 v4l2_std_id;
#define V4L2_STD_UNKNOWN 0
#define V4L2_STD_ALL (V4L2_STD_525_60 | V4L2_STD_625_50)
struct v4l2_standard
{
struct v4l2_standard {
__u32 index;
v4l2_std_id id;
__u8 name[24];
@ -421,8 +509,7 @@ struct v4l2_standard
__u32 reserved[4];
};
struct v4l2_input
{
struct v4l2_input {
__u32 index;
__u8 name[32];
__u32 type;
@ -451,8 +538,7 @@ struct v4l2_input
#define V4L2_IN_ST_NO_ACCESS 0x02000000
#define V4L2_IN_ST_VTR 0x04000000
struct v4l2_output
{
struct v4l2_output {
__u32 index;
__u8 name[32];
__u32 type;
@ -466,14 +552,12 @@ struct v4l2_output
#define V4L2_OUTPUT_TYPE_ANALOG 2
#define V4L2_OUTPUT_TYPE_ANALOGVGAOVERLAY 3
struct v4l2_control
{
struct v4l2_control {
__u32 id;
__s32 value;
};
struct v4l2_ext_control
{
struct v4l2_ext_control {
__u32 id;
__u32 reserved2[2];
union {
@ -483,8 +567,7 @@ struct v4l2_ext_control
};
} __attribute__ ((packed));
struct v4l2_ext_controls
{
struct v4l2_ext_controls {
__u32 ctrl_class;
__u32 count;
__u32 error_idx;
@ -494,13 +577,13 @@ struct v4l2_ext_controls
#define V4L2_CTRL_CLASS_USER 0x00980000
#define V4L2_CTRL_CLASS_MPEG 0x00990000
#define V4L2_CTRL_CLASS_CAMERA 0x009a0000
#define V4L2_CTRL_ID_MASK (0x0fffffff)
#define V4L2_CTRL_ID2CLASS(id) ((id) & 0x0fff0000UL)
#define V4L2_CTRL_DRIVER_PRIV(id) (((id) & 0xffff) >= 0x1000)
struct v4l2_queryctrl
{
struct v4l2_queryctrl {
__u32 id;
enum v4l2_ctrl_type type;
__u8 name[32];
@ -512,8 +595,7 @@ struct v4l2_queryctrl
__u32 reserved[2];
};
struct v4l2_querymenu
{
struct v4l2_querymenu {
__u32 id;
__u32 index;
__u8 name[32];
@ -557,9 +639,31 @@ struct v4l2_querymenu
#define V4L2_CID_GAIN (V4L2_CID_BASE+19)
#define V4L2_CID_HFLIP (V4L2_CID_BASE+20)
#define V4L2_CID_VFLIP (V4L2_CID_BASE+21)
#define V4L2_CID_HCENTER (V4L2_CID_BASE+22)
#define V4L2_CID_VCENTER (V4L2_CID_BASE+23)
#define V4L2_CID_LASTP1 (V4L2_CID_BASE+24)
#define V4L2_CID_POWER_LINE_FREQUENCY (V4L2_CID_BASE+24)
enum v4l2_power_line_frequency {
V4L2_CID_POWER_LINE_FREQUENCY_DISABLED = 0,
V4L2_CID_POWER_LINE_FREQUENCY_50HZ = 1,
V4L2_CID_POWER_LINE_FREQUENCY_60HZ = 2,
};
#define V4L2_CID_HUE_AUTO (V4L2_CID_BASE+25)
#define V4L2_CID_WHITE_BALANCE_TEMPERATURE (V4L2_CID_BASE+26)
#define V4L2_CID_SHARPNESS (V4L2_CID_BASE+27)
#define V4L2_CID_BACKLIGHT_COMPENSATION (V4L2_CID_BASE+28)
#define V4L2_CID_CHROMA_AGC (V4L2_CID_BASE+29)
#define V4L2_CID_COLOR_KILLER (V4L2_CID_BASE+30)
#define V4L2_CID_COLORFX (V4L2_CID_BASE+31)
#define V4L2_CID_ROTATE (V4L2_CID_BASE+32)
#define V4L2_CID_BG_COLOR (V4L2_CID_BASE+33)
#define V4L2_CID_LASTP1 (V4L2_CID_BASE+34)
enum v4l2_colorfx {
V4L2_COLORFX_NONE = 0,
V4L2_COLORFX_BW = 1,
V4L2_COLORFX_SEPIA = 2,
};
#define V4L2_CID_MPEG_BASE (V4L2_CTRL_CLASS_MPEG | 0x900)
#define V4L2_CID_MPEG_CLASS (V4L2_CTRL_CLASS_MPEG | 1)
@ -596,6 +700,8 @@ enum v4l2_mpeg_audio_encoding {
V4L2_MPEG_AUDIO_ENCODING_LAYER_1 = 0,
V4L2_MPEG_AUDIO_ENCODING_LAYER_2 = 1,
V4L2_MPEG_AUDIO_ENCODING_LAYER_3 = 2,
V4L2_MPEG_AUDIO_ENCODING_AAC = 3,
V4L2_MPEG_AUDIO_ENCODING_AC3 = 4,
};
#define V4L2_CID_MPEG_AUDIO_L1_BITRATE (V4L2_CID_MPEG_BASE+102)
enum v4l2_mpeg_audio_l1_bitrate {
@ -673,11 +779,36 @@ enum v4l2_mpeg_audio_crc {
V4L2_MPEG_AUDIO_CRC_NONE = 0,
V4L2_MPEG_AUDIO_CRC_CRC16 = 1,
};
#define V4L2_CID_MPEG_AUDIO_MUTE (V4L2_CID_MPEG_BASE+109)
#define V4L2_CID_MPEG_AUDIO_AAC_BITRATE (V4L2_CID_MPEG_BASE+110)
#define V4L2_CID_MPEG_AUDIO_AC3_BITRATE (V4L2_CID_MPEG_BASE+111)
enum v4l2_mpeg_audio_ac3_bitrate {
V4L2_MPEG_AUDIO_AC3_BITRATE_32K = 0,
V4L2_MPEG_AUDIO_AC3_BITRATE_40K = 1,
V4L2_MPEG_AUDIO_AC3_BITRATE_48K = 2,
V4L2_MPEG_AUDIO_AC3_BITRATE_56K = 3,
V4L2_MPEG_AUDIO_AC3_BITRATE_64K = 4,
V4L2_MPEG_AUDIO_AC3_BITRATE_80K = 5,
V4L2_MPEG_AUDIO_AC3_BITRATE_96K = 6,
V4L2_MPEG_AUDIO_AC3_BITRATE_112K = 7,
V4L2_MPEG_AUDIO_AC3_BITRATE_128K = 8,
V4L2_MPEG_AUDIO_AC3_BITRATE_160K = 9,
V4L2_MPEG_AUDIO_AC3_BITRATE_192K = 10,
V4L2_MPEG_AUDIO_AC3_BITRATE_224K = 11,
V4L2_MPEG_AUDIO_AC3_BITRATE_256K = 12,
V4L2_MPEG_AUDIO_AC3_BITRATE_320K = 13,
V4L2_MPEG_AUDIO_AC3_BITRATE_384K = 14,
V4L2_MPEG_AUDIO_AC3_BITRATE_448K = 15,
V4L2_MPEG_AUDIO_AC3_BITRATE_512K = 16,
V4L2_MPEG_AUDIO_AC3_BITRATE_576K = 17,
V4L2_MPEG_AUDIO_AC3_BITRATE_640K = 18,
};
#define V4L2_CID_MPEG_VIDEO_ENCODING (V4L2_CID_MPEG_BASE+200)
enum v4l2_mpeg_video_encoding {
V4L2_MPEG_VIDEO_ENCODING_MPEG_1 = 0,
V4L2_MPEG_VIDEO_ENCODING_MPEG_2 = 1,
V4L2_MPEG_VIDEO_ENCODING_MPEG_4_AVC = 2,
};
#define V4L2_CID_MPEG_VIDEO_ASPECT (V4L2_CID_MPEG_BASE+201)
enum v4l2_mpeg_video_aspect {
@ -698,6 +829,8 @@ enum v4l2_mpeg_video_bitrate_mode {
#define V4L2_CID_MPEG_VIDEO_BITRATE (V4L2_CID_MPEG_BASE+207)
#define V4L2_CID_MPEG_VIDEO_BITRATE_PEAK (V4L2_CID_MPEG_BASE+208)
#define V4L2_CID_MPEG_VIDEO_TEMPORAL_DECIMATION (V4L2_CID_MPEG_BASE+209)
#define V4L2_CID_MPEG_VIDEO_MUTE (V4L2_CID_MPEG_BASE+210)
#define V4L2_CID_MPEG_VIDEO_MUTE_YUV (V4L2_CID_MPEG_BASE+211)
#define V4L2_CID_MPEG_CX2341X_BASE (V4L2_CTRL_CLASS_MPEG | 0x1000)
#define V4L2_CID_MPEG_CX2341X_VIDEO_SPATIAL_FILTER_MODE (V4L2_CID_MPEG_CX2341X_BASE+0)
@ -737,9 +870,40 @@ enum v4l2_mpeg_cx2341x_video_median_filter_type {
#define V4L2_CID_MPEG_CX2341X_VIDEO_LUMA_MEDIAN_FILTER_TOP (V4L2_CID_MPEG_CX2341X_BASE+8)
#define V4L2_CID_MPEG_CX2341X_VIDEO_CHROMA_MEDIAN_FILTER_BOTTOM (V4L2_CID_MPEG_CX2341X_BASE+9)
#define V4L2_CID_MPEG_CX2341X_VIDEO_CHROMA_MEDIAN_FILTER_TOP (V4L2_CID_MPEG_CX2341X_BASE+10)
#define V4L2_CID_MPEG_CX2341X_STREAM_INSERT_NAV_PACKETS (V4L2_CID_MPEG_CX2341X_BASE+11)
struct v4l2_tuner
{
#define V4L2_CID_CAMERA_CLASS_BASE (V4L2_CTRL_CLASS_CAMERA | 0x900)
#define V4L2_CID_CAMERA_CLASS (V4L2_CTRL_CLASS_CAMERA | 1)
#define V4L2_CID_EXPOSURE_AUTO (V4L2_CID_CAMERA_CLASS_BASE+1)
enum v4l2_exposure_auto_type {
V4L2_EXPOSURE_AUTO = 0,
V4L2_EXPOSURE_MANUAL = 1,
V4L2_EXPOSURE_SHUTTER_PRIORITY = 2,
V4L2_EXPOSURE_APERTURE_PRIORITY = 3
};
#define V4L2_CID_EXPOSURE_ABSOLUTE (V4L2_CID_CAMERA_CLASS_BASE+2)
#define V4L2_CID_EXPOSURE_AUTO_PRIORITY (V4L2_CID_CAMERA_CLASS_BASE+3)
#define V4L2_CID_PAN_RELATIVE (V4L2_CID_CAMERA_CLASS_BASE+4)
#define V4L2_CID_TILT_RELATIVE (V4L2_CID_CAMERA_CLASS_BASE+5)
#define V4L2_CID_PAN_RESET (V4L2_CID_CAMERA_CLASS_BASE+6)
#define V4L2_CID_TILT_RESET (V4L2_CID_CAMERA_CLASS_BASE+7)
#define V4L2_CID_PAN_ABSOLUTE (V4L2_CID_CAMERA_CLASS_BASE+8)
#define V4L2_CID_TILT_ABSOLUTE (V4L2_CID_CAMERA_CLASS_BASE+9)
#define V4L2_CID_FOCUS_ABSOLUTE (V4L2_CID_CAMERA_CLASS_BASE+10)
#define V4L2_CID_FOCUS_RELATIVE (V4L2_CID_CAMERA_CLASS_BASE+11)
#define V4L2_CID_FOCUS_AUTO (V4L2_CID_CAMERA_CLASS_BASE+12)
#define V4L2_CID_ZOOM_ABSOLUTE (V4L2_CID_CAMERA_CLASS_BASE+13)
#define V4L2_CID_ZOOM_RELATIVE (V4L2_CID_CAMERA_CLASS_BASE+14)
#define V4L2_CID_ZOOM_CONTINUOUS (V4L2_CID_CAMERA_CLASS_BASE+15)
#define V4L2_CID_PRIVACY (V4L2_CID_CAMERA_CLASS_BASE+16)
struct v4l2_tuner {
__u32 index;
__u8 name[32];
enum v4l2_tuner_type type;
@ -753,8 +917,7 @@ struct v4l2_tuner
__u32 reserved[4];
};
struct v4l2_modulator
{
struct v4l2_modulator {
__u32 index;
__u8 name[32];
__u32 capability;
@ -784,16 +947,22 @@ struct v4l2_modulator
#define V4L2_TUNER_MODE_LANG1 0x0003
#define V4L2_TUNER_MODE_LANG1_LANG2 0x0004
struct v4l2_frequency
{
struct v4l2_frequency {
__u32 tuner;
enum v4l2_tuner_type type;
__u32 frequency;
__u32 reserved[8];
};
struct v4l2_audio
{
struct v4l2_hw_freq_seek {
__u32 tuner;
enum v4l2_tuner_type type;
__u32 seek_upward;
__u32 wrap_around;
__u32 reserved[8];
};
struct v4l2_audio {
__u32 index;
__u8 name[32];
__u32 capability;
@ -806,8 +975,7 @@ struct v4l2_audio
#define V4L2_AUDMODE_AVL 0x00001
struct v4l2_audioout
{
struct v4l2_audioout {
__u32 index;
__u8 name[32];
__u32 capability;
@ -815,8 +983,45 @@ struct v4l2_audioout
__u32 reserved[2];
};
struct v4l2_vbi_format
{
#define V4L2_ENC_IDX_FRAME_I (0)
#define V4L2_ENC_IDX_FRAME_P (1)
#define V4L2_ENC_IDX_FRAME_B (2)
#define V4L2_ENC_IDX_FRAME_MASK (0xf)
struct v4l2_enc_idx_entry {
__u64 offset;
__u64 pts;
__u32 length;
__u32 flags;
__u32 reserved[2];
};
#define V4L2_ENC_IDX_ENTRIES (64)
struct v4l2_enc_idx {
__u32 entries;
__u32 entries_cap;
__u32 reserved[4];
struct v4l2_enc_idx_entry entry[V4L2_ENC_IDX_ENTRIES];
};
#define V4L2_ENC_CMD_START (0)
#define V4L2_ENC_CMD_STOP (1)
#define V4L2_ENC_CMD_PAUSE (2)
#define V4L2_ENC_CMD_RESUME (3)
#define V4L2_ENC_CMD_STOP_AT_GOP_END (1 << 0)
struct v4l2_encoder_cmd {
__u32 cmd;
__u32 flags;
union {
struct {
__u32 data[8];
} raw;
};
};
struct v4l2_vbi_format {
__u32 sampling_rate;
__u32 offset;
__u32 samples_per_line;
@ -830,8 +1035,7 @@ struct v4l2_vbi_format
#define V4L2_VBI_UNSYNC (1 << 0)
#define V4L2_VBI_INTERLACED (1 << 1)
struct v4l2_sliced_vbi_format
{
struct v4l2_sliced_vbi_format {
__u16 service_set;
__u16 service_lines[2][24];
@ -850,16 +1054,15 @@ struct v4l2_sliced_vbi_format
#define V4L2_SLICED_VBI_525 (V4L2_SLICED_CAPTION_525)
#define V4L2_SLICED_VBI_625 (V4L2_SLICED_TELETEXT_B | V4L2_SLICED_VPS | V4L2_SLICED_WSS_625)
struct v4l2_sliced_vbi_cap
{
struct v4l2_sliced_vbi_cap {
__u16 service_set;
__u16 service_lines[2][24];
__u32 reserved[4];
enum v4l2_buf_type type;
__u32 reserved[3];
};
struct v4l2_sliced_vbi_data
{
struct v4l2_sliced_vbi_data {
__u32 id;
__u32 field;
__u32 line;
@ -867,11 +1070,9 @@ struct v4l2_sliced_vbi_data
__u8 data[48];
};
struct v4l2_format
{
struct v4l2_format {
enum v4l2_buf_type type;
union
{
union {
struct v4l2_pix_format pix;
struct v4l2_window win;
struct v4l2_vbi_format vbi;
@ -880,17 +1081,48 @@ struct v4l2_format
} fmt;
};
struct v4l2_streamparm
{
struct v4l2_streamparm {
enum v4l2_buf_type type;
union
{
union {
struct v4l2_captureparm capture;
struct v4l2_outputparm output;
__u8 raw_data[200];
} parm;
};
#define V4L2_CHIP_MATCH_HOST 0
#define V4L2_CHIP_MATCH_I2C_DRIVER 1
#define V4L2_CHIP_MATCH_I2C_ADDR 2
#define V4L2_CHIP_MATCH_AC97 3
struct v4l2_dbg_match {
__u32 type;
union {
__u32 addr;
char name[32];
};
} __attribute__ ((packed));
struct v4l2_dbg_register {
struct v4l2_dbg_match match;
__u32 size;
__u64 reg;
__u64 val;
} __attribute__ ((packed));
struct v4l2_dbg_chip_ident {
struct v4l2_dbg_match match;
__u32 ident;
__u32 revision;
} __attribute__ ((packed));
struct v4l2_chip_ident_old {
__u32 match_type;
__u32 match_chip;
__u32 ident;
__u32 revision;
};
#define VIDIOC_QUERYCAP _IOR('V', 0, struct v4l2_capability)
#define VIDIOC_RESERVED _IO('V', 1)
#define VIDIOC_ENUM_FMT _IOWR('V', 2, struct v4l2_fmtdesc)
@ -941,11 +1173,25 @@ struct v4l2_streamparm
#define VIDIOC_ENUMAUDOUT _IOWR('V', 66, struct v4l2_audioout)
#define VIDIOC_G_PRIORITY _IOR('V', 67, enum v4l2_priority)
#define VIDIOC_S_PRIORITY _IOW('V', 68, enum v4l2_priority)
#define VIDIOC_G_SLICED_VBI_CAP _IOR ('V', 69, struct v4l2_sliced_vbi_cap)
#define VIDIOC_G_SLICED_VBI_CAP _IOWR('V', 69, struct v4l2_sliced_vbi_cap)
#define VIDIOC_LOG_STATUS _IO('V', 70)
#define VIDIOC_G_EXT_CTRLS _IOWR('V', 71, struct v4l2_ext_controls)
#define VIDIOC_S_EXT_CTRLS _IOWR('V', 72, struct v4l2_ext_controls)
#define VIDIOC_TRY_EXT_CTRLS _IOWR('V', 73, struct v4l2_ext_controls)
#define VIDIOC_ENUM_FRAMESIZES _IOWR('V', 74, struct v4l2_frmsizeenum)
#define VIDIOC_ENUM_FRAMEINTERVALS _IOWR('V', 75, struct v4l2_frmivalenum)
#define VIDIOC_G_ENC_INDEX _IOR('V', 76, struct v4l2_enc_idx)
#define VIDIOC_ENCODER_CMD _IOWR('V', 77, struct v4l2_encoder_cmd)
#define VIDIOC_TRY_ENCODER_CMD _IOWR('V', 78, struct v4l2_encoder_cmd)
#define VIDIOC_DBG_S_REGISTER _IOW('V', 79, struct v4l2_dbg_register)
#define VIDIOC_DBG_G_REGISTER _IOWR('V', 80, struct v4l2_dbg_register)
#define VIDIOC_DBG_G_CHIP_IDENT _IOWR('V', 81, struct v4l2_dbg_chip_ident)
#define VIDIOC_G_CHIP_IDENT_OLD _IOWR('V', 81, struct v4l2_chip_ident_old)
#define VIDIOC_S_HW_FREQ_SEEK _IOW('V', 82, struct v4l2_hw_freq_seek)
#ifdef __OLD_VIDIOC_

16
libc/kernel/common/media/msm_camera.h

@ -54,9 +54,9 @@
#define MSM_CAM_IOCTL_SET_CROP _IOW(MSM_CAM_IOCTL_MAGIC, 18, struct crop_info *)
#define MSM_CAM_IOCTL_PICT_PP _IOW(MSM_CAM_IOCTL_MAGIC, 19, uint8_t *)
#define MSM_CAM_IOCTL_PP _IOW(MSM_CAM_IOCTL_MAGIC, 19, uint8_t *)
#define MSM_CAM_IOCTL_PICT_PP_DONE _IOW(MSM_CAM_IOCTL_MAGIC, 20, struct msm_snapshot_pp_status *)
#define MSM_CAM_IOCTL_PP_DONE _IOW(MSM_CAM_IOCTL_MAGIC, 20, struct msm_snapshot_pp_status *)
#define MSM_CAM_IOCTL_SENSOR_IO_CFG _IOW(MSM_CAM_IOCTL_MAGIC, 21, struct sensor_cfg_data *)
@ -73,6 +73,11 @@
#define MAX_SENSOR_NUM 3
#define MAX_SENSOR_NAME 32
#define PP_SNAP 1
#define PP_RAW_SNAP (1<<1)
#define PP_PREV (1<<2)
#define PP_MASK (PP_SNAP|PP_RAW_SNAP|PP_PREV)
#define MSM_CAM_CTRL_CMD_DONE 0
#define MSM_CAM_SENSOR_VFE_CMD 1
@ -130,11 +135,12 @@ struct msm_camera_cfg_cmd {
#define CMD_SNAP_BUF_RELEASE 11
#define CMD_SNAP_BUF_CFG 12
#define CMD_STATS_DISABLE 13
#define CMD_STATS_ENABLE 14
#define CMD_STATS_AEC_AWB_ENABLE 14
#define CMD_STATS_AF_ENABLE 15
#define CMD_STATS_BUF_RELEASE 16
#define CMD_STATS_AF_BUF_RELEASE 17
#define UPDATE_STATS_INVALID 18
#define CMD_STATS_ENABLE 18
#define UPDATE_STATS_INVALID 19
struct msm_vfe_cfg_cmd {
int cmd_type;
@ -150,7 +156,7 @@ struct camera_enable_cmd {
#define MSM_PMEM_OUTPUT1 0
#define MSM_PMEM_OUTPUT2 1
#define MSM_PMEM_OUTPUT1_OUTPUT2 2
#define MSM_PMEM_THUMBAIL 3
#define MSM_PMEM_THUMBNAIL 3
#define MSM_PMEM_MAINIMG 4
#define MSM_PMEM_RAW_MAINIMG 5
#define MSM_PMEM_AEC_AWB 6

4
libc/kernel/tools/clean_header.py

@ -96,7 +96,7 @@ if __name__ == "__main__":
sys.exit(1)
try:
optlist, args = getopt.getopt( sys.argv[1:], 'uv' )
optlist, args = getopt.getopt( sys.argv[1:], 'uvk:' )
except:
# unrecognized option
sys.stderr.write( "error: unrecognized option\n" )
@ -108,6 +108,8 @@ if __name__ == "__main__":
elif opt == '-v':
verbose = 1
D_setlevel(1)
elif opt == '-k':
kernel_original_path = arg
if len(args) == 0:
usage()

38
libc/netbsd/net/getaddrinfo.c

@ -335,6 +335,36 @@ str2number(const char *p)
return -1;
}
/* Determine whether IPv6 connectivity is available. */
static int
_have_ipv6() {
/*
* Connect a UDP socket to an global unicast IPv6 address. This will
* cause no network traffic, but will fail fast if the system has no or
* limited IPv6 connectivity (e.g., only a link-local address).
*/
static const struct sockaddr_in6 sin6_test = {
/* family, port, flow label */
AF_INET6, 0, 0,
/* 2000:: */
{{{ 0x20, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }}},
/* scope ID */
0};
static const struct sockaddr *sa_test = (struct sockaddr *) &sin6_test;
int s = socket(PF_INET6, SOCK_DGRAM, IPPROTO_UDP);
if (s < 0)
return 0;
int ret;
do {
ret = connect(s, sa_test, sizeof(sin6_test));
} while (ret < 0 && errno == EINTR);
int have_ipv6 = (ret == 0);
do {
ret = close(s);
} while (ret < 0 && errno == EINTR);
return have_ipv6;
}
int
getaddrinfo(const char *hostname, const char *servname,
const struct addrinfo *hints, struct addrinfo **res)
@ -1274,7 +1304,6 @@ _dns_getaddrinfo(void *rv, void *cb_data, va_list ap)
name = va_arg(ap, char *);
pai = va_arg(ap, const struct addrinfo *);
//fprintf(stderr, "_dns_getaddrinfo() name = '%s'\n", name);
memset(&q, 0, sizeof(q));
@ -1299,15 +1328,20 @@ _dns_getaddrinfo(void *rv, void *cb_data, va_list ap)
/* prefer IPv6 */
q.name = name;
q.qclass = C_IN;
q.qtype = T_AAAA;
q.answer = buf->buf;
q.anslen = sizeof(buf->buf);
/* If AI_ADDRCONFIG, lookup IPv6 only if we have connectivity */
if (!(pai->ai_flags & AI_ADDRCONFIG) || _have_ipv6()) {
q.qtype = T_AAAA;
q.next = &q2;
q2.name = name;
q2.qclass = C_IN;
q2.qtype = T_A;
q2.answer = buf2->buf;
q2.anslen = sizeof(buf2->buf);
} else {
q.qtype = T_A;
}
break;
case AF_INET:
q.name = name;

1
libc/netbsd/resolv/res_send.c

@ -95,7 +95,6 @@ __RCSID("$NetBSD: res_send.c,v 1.9 2006/01/24 17:41:25 christos Exp $");
#include <sys/uio.h>
#include <netinet/in.h>
#include <netinet/in6.h>
#include "arpa_nameser.h"
#include <arpa/inet.h>

11
libc/private/bionic_tls.h

@ -88,7 +88,18 @@ extern int __set_tls(void *ptr);
/* get the TLS */
#ifdef __arm__
/* For performance reasons, avoid calling the kernel helper
* Note that HAVE_ARM_TLS_REGISTER is build-specific
* (it must match your kernel configuration)
*/
# ifdef HAVE_ARM_TLS_REGISTER
# define __get_tls() \
({ register unsigned int __val asm("r0"); \
asm ("mrc p15, 0, r0, c13, c0, 3" : "=r"(__val) ); \
(volatile void*)__val; })
# else /* !HAVE_ARM_TLS_REGISTER */
# define __get_tls() ( *((volatile void **) 0xffff0ff0) )
# endif
#else
extern void* __get_tls( void );
#endif

152
libc/tzcode/localtime.c

@ -21,6 +21,7 @@ static char elsieid[] = "@(#)localtime.c 8.3";
#include "fcntl.h"
#include "float.h" /* for FLT_MAX and DBL_MAX */
#include "thread_private.h"
#include <sys/system_properties.h>
#ifndef TZ_ABBR_MAX_LEN
@ -59,6 +60,45 @@ static char elsieid[] = "@(#)localtime.c 8.3";
# define XLOG(x) do{}while (0)
#endif
/* THREAD-SAFETY SUPPORT GOES HERE */
static pthread_mutex_t _tzMutex = PTHREAD_MUTEX_INITIALIZER;
static __inline__ void _tzLock(void)
{
if (__isthreaded)
pthread_mutex_lock(&_tzMutex);
}
static __inline__ void _tzUnlock(void)
{
if (__isthreaded)
pthread_mutex_unlock(&_tzMutex);
}
/* Complex computations to determine the min/max of time_t depending
* on TYPE_BIT / TYPE_SIGNED / TYPE_INTEGRAL.
* These macros cannot be used in pre-processor directives, so we
* let the C compiler do the work, which makes things a bit funky.
*/
static const time_t TIME_T_MAX =
TYPE_INTEGRAL(time_t) ?
( TYPE_SIGNED(time_t) ?
~((time_t)1 << (TYPE_BIT(time_t)-1))
:
~(time_t)0
)
: /* if time_t is a floating point number */
( sizeof(time_t) > sizeof(float) ? (time_t)DBL_MAX : (time_t)FLT_MAX );
static const time_t TIME_T_MIN =
TYPE_INTEGRAL(time_t) ?
( TYPE_SIGNED(time_t) ?
((time_t)1 << (TYPE_BIT(time_t)-1))
:
0
)
:
( sizeof(time_t) > sizeof(float) ? (time_t)DBL_MIN : (time_t)FLT_MIN );
#ifndef WILDABBR
/*
@ -120,6 +160,10 @@ struct lsinfo { /* leap second information */
#define MY_TZNAME_MAX 255
#endif /* !defined TZNAME_MAX */
/* XXX: This code should really use time64_t instead of time_t
* but we can't change it without re-generating the index
* file first with the correct data.
*/
struct state {
int leapcnt;
int timecnt;
@ -151,6 +195,8 @@ struct rule {
** Prototypes for static functions.
*/
/* NOTE: all internal functions assume that _tzLock() was already called */
static long detzcode P((const char * codep));
static time_t detzcode64 P((const char * codep));
static int differ_by_repeat P((time_t t1, time_t t0));
@ -230,7 +276,7 @@ char * tzname[2] = {
** Thanks to Paul Eggert for noting this.
*/
static struct tm tm;
static struct tm tmGlobal;
#ifdef USG_COMPAT
time_t timezone = 0;
@ -1184,14 +1230,7 @@ struct state * const sp;
(void) tzparse(gmt, sp, TRUE);
}
#ifndef STD_INSPIRED
/*
** A non-static declaration of tzsetwall in a system header file
** may cause a warning about this upcoming static declaration...
*/
static
#endif /* !defined STD_INSPIRED */
void
static void
tzsetwall P((void))
{
if (lcl_is_set < 0)
@ -1212,8 +1251,8 @@ tzsetwall P((void))
settzname();
}
void
tzset P((void))
static void
tzset_locked P((void))
{
register const char * name = NULL;
static char buf[PROP_VALUE_MAX];
@ -1261,6 +1300,14 @@ tzset P((void))
settzname();
}
void
tzset P((void))
{
_tzLock();
tzset_locked();
_tzUnlock();
}
/*
** The easy way to behave "as if no library function calls" localtime
** is to not call it--so we drop its guts into "localsub", which can be
@ -1367,8 +1414,7 @@ struct tm *
localtime(timep)
const time_t * const timep;
{
tzset();
return localsub(timep, 0L, &tm);
return localtime_r(timep, &tmGlobal);
}
/*
@ -1380,8 +1426,14 @@ localtime_r(timep, tmp)
const time_t * const timep;
struct tm * tmp;
{
tzset();
return localsub(timep, 0L, tmp);
struct tm* result;
_tzLock();
tzset_locked();
result = localsub(timep, 0L, tmp);
_tzUnlock();
return result;
}
/*
@ -1431,7 +1483,7 @@ struct tm *
gmtime(timep)
const time_t * const timep;
{
return gmtsub(timep, 0L, &tm);
return gmtime_r(timep, &tmGlobal);
}
/*
@ -1443,7 +1495,13 @@ gmtime_r(timep, tmp)
const time_t * const timep;
struct tm * tmp;
{
return gmtsub(timep, 0L, tmp);
struct tm* result;
_tzLock();
result = gmtsub(timep, 0L, tmp);
_tzUnlock();
return result;
}
#ifdef STD_INSPIRED
@ -1453,7 +1511,7 @@ offtime(timep, offset)
const time_t * const timep;
const long offset;
{
return gmtsub(timep, offset, &tm);
return gmtsub(timep, offset, &tmGlobal);
}
#endif /* defined STD_INSPIRED */
@ -1650,11 +1708,16 @@ increment_overflow(number, delta)
int * number;
int delta;
{
int number0;
unsigned number0 = (unsigned)*number;
unsigned number1 = (unsigned)(number0 + delta);
number0 = *number;
*number += delta;
return (*number < number0) != (delta < 0);
*number = (int)number1;
if (delta >= 0) {
return ((int)number1 < (int)number0);
} else {
return ((int)number1 > (int)number0);
}
}
static int
@ -1662,11 +1725,16 @@ long_increment_overflow(number, delta)
long * number;
int delta;
{
long number0;
unsigned long number0 = (unsigned long)*number;
unsigned long number1 = (unsigned long)(number0 + delta);
number0 = *number;
*number += delta;
return (*number < number0) != (delta < 0);
*number = (long)number1;
if (delta >= 0) {
return ((long)number1 < (long)number0);
} else {
return ((long)number1 > (long)number0);
}
}
static int
@ -1835,14 +1903,14 @@ const int do_norm_secs;
} else dir = tmcomp(&mytm, &yourtm);
if (dir != 0) {
if (t == lo) {
++t;
if (t <= lo)
if (t == TIME_T_MAX)
return WRONG;
++t;
++lo;
} else if (t == hi) {
--t;
if (t >= hi)
if (t == TIME_T_MIN)
return WRONG;
--t;
--hi;
}
if (lo > hi)
@ -2002,8 +2070,12 @@ time_t
mktime(tmp)
struct tm * const tmp;
{
tzset();
return time1(tmp, localsub, 0L);
time_t result;
_tzLock();
tzset_locked();
result = time1(tmp, localsub, 0L);
_tzUnlock();
return result;
}
#ifdef STD_INSPIRED
@ -2020,8 +2092,14 @@ time_t
timegm(tmp)
struct tm * const tmp;
{
time_t result;
tmp->tm_isdst = 0;
return time1(tmp, gmtsub, 0L);
_tzLock();
result = time1(tmp, gmtsub, 0L);
_tzUnlock();
return result;
}
time_t
@ -2029,8 +2107,14 @@ timeoff(tmp, offset)
struct tm * const tmp;
const long offset;
{
time_t result;
tmp->tm_isdst = 0;
return time1(tmp, gmtsub, offset);
_tzLock();
result = time1(tmp, gmtsub, offset);
_tzUnlock();
return result;
}
#endif /* defined STD_INSPIRED */

4
libc/tzcode/private.h

@ -72,10 +72,6 @@ static char privatehid[] = "@(#)private.h 8.2";
#define HAVE_UTMPX_H 0
#endif /* !defined HAVE_UTMPX_H */
#ifndef LOCALE_HOME
#define LOCALE_HOME "/usr/lib/locale"
#endif /* !defined LOCALE_HOME */
#if HAVE_INCOMPATIBLE_CTIME_R
#define asctime_r _incompatible_asctime_r
#define ctime_r _incompatible_ctime_r

226
libc/tzcode/strftime.c

@ -37,7 +37,14 @@ static const char sccsid[] = "@(#)strftime.c 5.4 (Berkeley) 3/14/89";
#include "fcntl.h"
#include "locale.h"
#include <ctype.h>
#include <time64.h>
/* struct lc_time_T is now defined as strftime_locale
* in <time.h>
*/
#if 1
#define lc_time_T strftime_locale
#else
struct lc_time_T {
const char * mon[MONSPERYEAR];
const char * month[MONSPERYEAR];
@ -50,16 +57,9 @@ struct lc_time_T {
const char * pm;
const char * date_fmt;
};
#endif
#ifdef LOCALE_HOME
#include "sys/stat.h"
static struct lc_time_T localebuf;
static struct lc_time_T * _loc P((void));
#define Locale _loc()
#endif /* defined LOCALE_HOME */
#ifndef LOCALE_HOME
#define Locale (&C_time_locale)
#endif /* !defined LOCALE_HOME */
static const struct lc_time_T C_time_locale = {
{
@ -68,6 +68,9 @@ static const struct lc_time_T C_time_locale = {
}, {
"January", "February", "March", "April", "May", "June",
"July", "August", "September", "October", "November", "December"
}, {
"January", "February", "March", "April", "May", "June",
"July", "August", "September", "October", "November", "December"
}, {
"Sun", "Mon", "Tue", "Wed",
"Thu", "Fri", "Sat"
@ -110,7 +113,7 @@ static const struct lc_time_T C_time_locale = {
static char * _add P((const char *, char *, const char *, int));
static char * _conv P((int, const char *, char *, const char *));
static char * _fmt P((const char *, const struct tm *, char *, const char *,
int *));
int *, const struct strftime_locale*));
static char * _yconv P((int, int, int, int, char *, const char *, int));
static char * getformat P((int, char *, char *, char *, char *));
@ -133,17 +136,25 @@ char * const s;
const size_t maxsize;
const char * const format;
const struct tm * const t;
{
return strftime_tz(s, maxsize, format, t, Locale);
}
size_t
strftime_tz(s, maxsize, format, t, locale)
char * const s;
const size_t maxsize;
const char * const format;
const struct tm * const t;
const struct strftime_locale *locale;
{
char * p;
int warn;
tzset();
#ifdef LOCALE_HOME
localebuf.mon[0] = 0;
#endif /* defined LOCALE_HOME */
warn = IN_NONE;
p = _fmt(((format == NULL) ? "%c" : format), t, s, s + maxsize, &warn);
#ifndef NO_RUN_TIME_WARNINGS_ABOUT_YEAR_2000_PROBLEMS_THANK_YOU
p = _fmt(((format == NULL) ? "%c" : format), t, s, s + maxsize, &warn, locale);
#if 0 /* ifndef NO_RUN_TIME_WARNINGS_ABOUT_YEAR_2000_PROBLEMS_THANK_YOU */
if (warn != IN_NONE && getenv(YEAR_2000_NAME) != NULL) {
(void) fprintf(stderr, "\n");
if (format == NULL)
@ -182,12 +193,13 @@ static char *getformat(int modifier, char *normal, char *underscore,
}
static char *
_fmt(format, t, pt, ptlim, warnp)
_fmt(format, t, pt, ptlim, warnp, locale)
const char * format;
const struct tm * const t;
char * pt;
const char * const ptlim;
int * warnp;
const struct strftime_locale* locale;
{
for ( ; *format; ++format) {
if (*format == '%') {
@ -200,26 +212,33 @@ label:
case 'A':
pt = _add((t->tm_wday < 0 ||
t->tm_wday >= DAYSPERWEEK) ?
"?" : Locale->weekday[t->tm_wday],
"?" : locale->weekday[t->tm_wday],
pt, ptlim, modifier);
continue;
case 'a':
pt = _add((t->tm_wday < 0 ||
t->tm_wday >= DAYSPERWEEK) ?
"?" : Locale->wday[t->tm_wday],
"?" : locale->wday[t->tm_wday],
pt, ptlim, modifier);
continue;
case 'B':
if (modifier == '-') {
pt = _add((t->tm_mon < 0 ||
t->tm_mon >= MONSPERYEAR) ?
"?" : Locale->month[t->tm_mon],
"?" : locale->standalone_month[t->tm_mon],
pt, ptlim, modifier);
} else {
pt = _add((t->tm_mon < 0 ||
t->tm_mon >= MONSPERYEAR) ?
"?" : locale->month[t->tm_mon],
pt, ptlim, modifier);
}
continue;
case 'b':
case 'h':
pt = _add((t->tm_mon < 0 ||
t->tm_mon >= MONSPERYEAR) ?
"?" : Locale->mon[t->tm_mon],
"?" : locale->mon[t->tm_mon],
pt, ptlim, modifier);
continue;
case 'C':
@ -237,7 +256,7 @@ label:
{
int warn2 = IN_SOME;
pt = _fmt(Locale->c_fmt, t, pt, ptlim, warnp);
pt = _fmt(locale->c_fmt, t, pt, ptlim, warnp, locale);
if (warn2 == IN_ALL)
warn2 = IN_THIS;
if (warn2 > *warnp)
@ -245,7 +264,7 @@ label:
}
continue;
case 'D':
pt = _fmt("%m/%d/%y", t, pt, ptlim, warnp);
pt = _fmt("%m/%d/%y", t, pt, ptlim, warnp, locale);
continue;
case 'd':
pt = _conv(t->tm_mday,
@ -279,7 +298,7 @@ label:
pt, ptlim);
continue;
case 'F':
pt = _fmt("%Y-%m-%d", t, pt, ptlim, warnp);
pt = _fmt("%Y-%m-%d", t, pt, ptlim, warnp, locale);
continue;
case 'H':
pt = _conv(t->tm_hour,
@ -356,21 +375,21 @@ label:
continue;
case 'p':
pt = _add((t->tm_hour >= (HOURSPERDAY / 2)) ?
Locale->pm :
Locale->am,
locale->pm :
locale->am,
pt, ptlim, modifier);
continue;
case 'P':
pt = _add((t->tm_hour >= (HOURSPERDAY / 2)) ?
Locale->pm :
Locale->am,
locale->pm :
locale->am,
pt, ptlim, FORCE_LOWER_CASE);
continue;
case 'R':
pt = _fmt("%H:%M", t, pt, ptlim, warnp);
pt = _fmt("%H:%M", t, pt, ptlim, warnp, locale);
continue;
case 'r':
pt = _fmt("%I:%M:%S %p", t, pt, ptlim, warnp);
pt = _fmt("%I:%M:%S %p", t, pt, ptlim, warnp, locale);
continue;
case 'S':
pt = _conv(t->tm_sec,
@ -382,21 +401,21 @@ label:
{
struct tm tm;
char buf[INT_STRLEN_MAXIMUM(
time_t) + 1];
time_t mkt;
time64_t) + 1];
time64_t mkt;
tm = *t;
mkt = mktime(&tm);
if (TYPE_SIGNED(time_t))
(void) sprintf(buf, "%ld",
(long) mkt);
else (void) sprintf(buf, "%lu",
(unsigned long) mkt);
mkt = mktime64(&tm);
if (TYPE_SIGNED(time64_t))
(void) sprintf(buf, "%lld",
(long long) mkt);
else (void) sprintf(buf, "%llu",
(unsigned long long) mkt);
pt = _add(buf, pt, ptlim, modifier);
}
continue;
case 'T':
pt = _fmt("%H:%M:%S", t, pt, ptlim, warnp);
pt = _fmt("%H:%M:%S", t, pt, ptlim, warnp, locale);
continue;
case 't':
pt = _add("\t", pt, ptlim, modifier);
@ -517,7 +536,7 @@ label:
** "date as dd-bbb-YYYY"
** (ado, 1993-05-24)
*/
pt = _fmt("%e-%b-%Y", t, pt, ptlim, warnp);
pt = _fmt("%e-%b-%Y", t, pt, ptlim, warnp, locale);
continue;
case 'W':
pt = _conv((t->tm_yday + DAYSPERWEEK -
@ -532,13 +551,13 @@ label:
pt = _conv(t->tm_wday, "%d", pt, ptlim);
continue;
case 'X':
pt = _fmt(Locale->X_fmt, t, pt, ptlim, warnp);
pt = _fmt(locale->X_fmt, t, pt, ptlim, warnp, locale);
continue;
case 'x':
{
int warn2 = IN_SOME;
pt = _fmt(Locale->x_fmt, t, pt, ptlim, &warn2);
pt = _fmt(locale->x_fmt, t, pt, ptlim, &warn2, locale);
if (warn2 == IN_ALL)
warn2 = IN_THIS;
if (warn2 > *warnp)
@ -627,8 +646,8 @@ label:
}
continue;
case '+':
pt = _fmt(Locale->date_fmt, t, pt, ptlim,
warnp);
pt = _fmt(locale->date_fmt, t, pt, ptlim,
warnp, locale);
continue;
case '%':
/*
@ -656,7 +675,7 @@ const char * const ptlim;
{
char buf[INT_STRLEN_MAXIMUM(int) + 1];
(void) sprintf(buf, format, n);
(void) snprintf(buf, sizeof(buf), format, n);
return _add(buf, pt, ptlim, 0);
}
@ -749,124 +768,3 @@ int modifier;
pt, ptlim);
return pt;
}
#ifdef LOCALE_HOME
static struct lc_time_T *
_loc P((void))
{
static const char locale_home[] = LOCALE_HOME;
static const char lc_time[] = "LC_TIME";
static char * locale_buf;
int fd;
int oldsun; /* "...ain't got nothin' to do..." */
char * lbuf;
char * name;
char * p;
const char ** ap;
const char * plim;
char filename[FILENAME_MAX];
struct stat st;
size_t namesize;
size_t bufsize;
/*
** Use localebuf.mon[0] to signal whether locale is already set up.
*/
if (localebuf.mon[0])
return &localebuf;
name = setlocale(LC_TIME, (char *) NULL);
if (name == NULL || *name == '\0')
goto no_locale;
/*
** If the locale name is the same as our cache, use the cache.
*/
lbuf = locale_buf;
if (lbuf != NULL && strcmp(name, lbuf) == 0) {
p = lbuf;
for (ap = (const char **) &localebuf;
ap < (const char **) (&localebuf + 1);
++ap)
*ap = p += strlen(p) + 1;
return &localebuf;
}
/*
** Slurp the locale file into the cache.
*/
namesize = strlen(name) + 1;
if (sizeof filename <
((sizeof locale_home) + namesize + (sizeof lc_time)))
goto no_locale;
oldsun = 0;
(void) sprintf(filename, "%s/%s/%s", locale_home, name, lc_time);
fd = open(filename, O_RDONLY);
if (fd < 0) {
/*
** Old Sun systems have a different naming and data convention.
*/
oldsun = 1;
(void) sprintf(filename, "%s/%s/%s", locale_home,
lc_time, name);
fd = open(filename, O_RDONLY);
if (fd < 0)
goto no_locale;
}
if (fstat(fd, &st) != 0)
goto bad_locale;
if (st.st_size <= 0)
goto bad_locale;
bufsize = namesize + st.st_size;
locale_buf = NULL;
lbuf = (lbuf == NULL) ? malloc(bufsize) : realloc(lbuf, bufsize);
if (lbuf == NULL)
goto bad_locale;
(void) strcpy(lbuf, name);
p = lbuf + namesize;
plim = p + st.st_size;
if (read(fd, p, (size_t) st.st_size) != st.st_size)
goto bad_lbuf;
if (close(fd) != 0)
goto bad_lbuf;
/*
** Parse the locale file into localebuf.
*/
if (plim[-1] != '\n')
goto bad_lbuf;
for (ap = (const char **) &localebuf;
ap < (const char **) (&localebuf + 1);
++ap) {
if (p == plim)
goto bad_lbuf;
*ap = p;
while (*p != '\n')
++p;
*p++ = '\0';
}
if (oldsun) {
/*
** SunOS 4 used an obsolescent format; see localdtconv(3).
** c_fmt had the ``short format for dates and times together''
** (SunOS 4 date, "%a %b %e %T %Z %Y" in the C locale);
** date_fmt had the ``long format for dates''
** (SunOS 4 strftime %C, "%A, %B %e, %Y" in the C locale).
** Discard the latter in favor of the former.
*/
localebuf.date_fmt = localebuf.c_fmt;
}
/*
** Record the successful parse in the cache.
*/
locale_buf = lbuf;
return &localebuf;
bad_lbuf:
free(lbuf);
bad_locale:
(void) close(fd);
no_locale:
localebuf = C_time_locale;
locale_buf = NULL;
return &localebuf;
}
#endif /* defined LOCALE_HOME */

24
libc/tzcode/strptime.c

@ -90,21 +90,21 @@ static const struct {
static int _conv_num(const unsigned char **, int *, int, int);
static char *_strptime(const char *, const char *, struct tm *, int);
static unsigned char *_strptime(const unsigned char *, const char *, struct tm *, int);
char *
strptime(const char *buf, const char *fmt, struct tm *tm)
{
return(_strptime(buf, fmt, tm, 1));
return (char*)(_strptime((const unsigned char*)buf, fmt, tm, 1));
}
static char *
_strptime(const char *buf, const char *fmt, struct tm *tm, int initialize)
static unsigned char *
_strptime(const unsigned char *buf, const char *fmt, struct tm *tm, int initialize)
{
unsigned char c;
const unsigned char *bp;
size_t len;
size_t len = 0;
int alt_format, i;
static int century, relyear;
@ -207,12 +207,12 @@ literal:
for (i = 0; i < 7; i++) {
/* Full name. */
len = strlen(_ctloc(day[i]));
if (strncasecmp(_ctloc(day[i]), bp, len) == 0)
if (strncasecmp(_ctloc(day[i]), (const char*)bp, len) == 0)
break;
/* Abbreviated name. */
len = strlen(_ctloc(abday[i]));
if (strncasecmp(_ctloc(abday[i]), bp, len) == 0)
if (strncasecmp(_ctloc(abday[i]), (const char*)bp, len) == 0)
break;
}
@ -231,12 +231,12 @@ literal:
for (i = 0; i < 12; i++) {
/* Full name. */
len = strlen(_ctloc(mon[i]));
if (strncasecmp(_ctloc(mon[i]), bp, len) == 0)
if (strncasecmp(_ctloc(mon[i]), (const char*)bp, len) == 0)
break;
/* Abbreviated name. */
len = strlen(_ctloc(abmon[i]));
if (strncasecmp(_ctloc(abmon[i]), bp, len) == 0)
if (strncasecmp(_ctloc(abmon[i]), (const char*)bp, len) == 0)
break;
}
@ -305,7 +305,7 @@ literal:
_LEGAL_ALT(0);
/* AM? */
len = strlen(_ctloc(am_pm[0]));
if (strncasecmp(_ctloc(am_pm[0]), bp, len) == 0) {
if (strncasecmp(_ctloc(am_pm[0]), (const char*)bp, len) == 0) {
if (tm->tm_hour > 12) /* i.e., 13:00 AM ?! */
return (NULL);
else if (tm->tm_hour == 12)
@ -316,7 +316,7 @@ literal:
}
/* PM? */
len = strlen(_ctloc(am_pm[1]));
if (strncasecmp(_ctloc(am_pm[1]), bp, len) == 0) {
if (strncasecmp(_ctloc(am_pm[1]), (const char*)bp, len) == 0) {
if (tm->tm_hour > 12) /* i.e., 13:00 PM ?! */
return (NULL);
else if (tm->tm_hour < 12)
@ -402,7 +402,7 @@ literal:
}
}
return ((char *)bp);
return (unsigned char*)bp;
}

33
libc/unistd/abort.c

@ -39,8 +39,13 @@
#define debug_log(format, ...) \
__libc_android_log_print(ANDROID_LOG_DEBUG, "libc-abort", (format), ##__VA_ARGS__ )
#ifdef __arm__
void
__libc_android_abort(void)
#else
void
abort(void)
#endif
{
struct atexit *p = __atexit;
static int cleanup_called = 0;
@ -73,10 +78,8 @@ abort(void)
}
/* temporary, for bug hunting */
debug_log("abort() called in pid %d\n", getpid());
/* seg fault seems to produce better debuggerd results than SIGABRT */
*((char*)0xdeadbaad) = 39;
debug_log("somehow we're not dead?\n");
/* -- */
(void)kill(getpid(), SIGABRT);
@ -99,3 +102,29 @@ abort(void)
(void)kill(getpid(), SIGABRT);
_exit(1);
}
#ifdef __arm__
/*
* abort() does not return, which gcc interprets to mean that it doesn't
* need to preserve any of the callee-save registers. Unfortunately this
* includes the link register, so if LR is used there is no way to determine
* which function called abort().
*
* We work around this by inserting a trivial stub that doesn't alter
* any of the "interesting" registers and thus doesn't need to save them.
* We can't just call __libc_android_abort from C because gcc uses "bl"
* without first saving LR, so we use an asm statement. This also has
* the side-effect of replacing abort() with __libc_android_abort() in
* the stack trace.
*
* Ideally __libc_android_abort would be static, but I haven't figured out
* how to tell gcc to call a static function from an asm statement.
*/
void
abort(void)
{
asm ("b __libc_android_abort");
_exit(1); /* suppress gcc noreturn warnings */
}
#endif

49
libstdc++/include/cstring

@ -39,59 +39,28 @@
namespace std
{
using ::memccpy;
using ::memchr;
using ::memrchr;
using ::memcmp;
using ::memcpy;
using ::memmove;
using ::memset;
using ::memmem;
// In string.h but not part of the std
// using ::memswap;
using ::index;
using ::rindex;
using ::strchr;
using ::strrchr;
using ::strlen;
using ::strcmp;
using ::strcpy;
using ::strcat;
using ::strcasecmp;
using ::strncasecmp;
using ::strdup;
using ::strstr;
using ::strcasestr;
using ::strtok;
using ::strtok_r;
using ::strchr;
using ::strcmp;
using ::strcoll;
using ::strcpy;
using ::strcspn;
using ::strerror;
using ::strerror_r;
using ::strnlen;
using ::strlen;
using ::strncat;
using ::strndup;
using ::strncmp;
using ::strncpy;
// In string.h but not part of the std
// using ::strlcat;
// using ::strlcpy;
using ::strcspn;
using ::strpbrk;
using ::strsep;
using ::strrchr;
using ::strspn;
using ::strsignal;
using ::strcoll;
using ::strstr;
using ::strtok;
using ::strxfrm;
} // namespace std
#endif // BIONIC_LIBSTDCPP_INCLUDE_CSTRING__

76
linker/ba.c

@ -30,65 +30,41 @@
#include "linker_debug.h"
#include "ba.h"
struct ba_bits {
unsigned allocated:1; /* 1 if allocated, 0 if free */
unsigned order:7; /* size of the region in ba space */
};
struct ba_info {
/* start address of the ba space */
unsigned long base;
/* total size of the ba space */
unsigned long size;
/* number of entries in the ba space */
int num_entries;
/* the bitmap for the region indicating which entries are allocated
* and which are free */
struct ba_bits *bitmap;
};
#undef min
#define min(a,b) ((a)<(b)?(a):(b))
#define BA_MIN_ALLOC LIBINC
#define BA_MAX_ORDER 128
#define BA_START LIBBASE
#define BA_SIZE (LIBLAST - LIBBASE)
#define BA_IS_FREE(index) (!(ba.bitmap[index].allocated))
#define BA_ORDER(index) ba.bitmap[index].order
#define BA_IS_FREE(index) (!(ba->bitmap[index].allocated))
#define BA_ORDER(index) ba->bitmap[index].order
#define BA_BUDDY_INDEX(index) ((index) ^ (1 << BA_ORDER(index)))
#define BA_NEXT_INDEX(index) ((index) + (1 << BA_ORDER(index)))
#define BA_OFFSET(index) ((index) * BA_MIN_ALLOC)
#define BA_START_ADDR(index) (BA_OFFSET(index) + ba.base)
#define BA_LEN(index) ((1 << BA_ORDER(index)) * BA_MIN_ALLOC)
#define BA_OFFSET(index) ((index) * ba->min_alloc)
#define BA_START_ADDR(index) (BA_OFFSET(index) + ba->base)
#define BA_LEN(index) ((1 << BA_ORDER(index)) * ba->min_alloc)
static struct ba_bits ba_bitmap[BA_SIZE / BA_MIN_ALLOC];
static unsigned long ba_order(struct ba *ba, unsigned long len);
static struct ba_info ba = {
.base = BA_START,
.size = BA_SIZE,
.bitmap = ba_bitmap,
.num_entries = sizeof(ba_bitmap)/sizeof(ba_bitmap[0]),
};
void ba_init(void)
void ba_init(struct ba *ba)
{
int i, index = 0;
for (i = sizeof(ba.num_entries) * 8 - 1; i >= 0; i--) {
if (ba.num_entries & 1<<i) {
unsigned long max_order = ba_order(ba, ba->size);
if (ba->max_order == 0 || ba->max_order > max_order)
ba->max_order = max_order;
for (i = sizeof(ba->num_entries) * 8 - 1; i >= 0; i--) {
if (ba->num_entries & 1<<i) {
BA_ORDER(index) = i;
index = BA_NEXT_INDEX(index);
}
}
}
int ba_free(int index)
int ba_free(struct ba *ba, int index)
{
int buddy, curr = index;
/* clean up the bitmap, merging any buddies */
ba.bitmap[curr].allocated = 0;
ba->bitmap[curr].allocated = 0;
/* find a slots buddy Buddy# = Slot# ^ (1 << order)
* if the buddy is also free merge them
* repeat until the buddy is not free or end of the bitmap is reached
@ -103,16 +79,16 @@ int ba_free(int index)
} else {
break;
}
} while (curr < ba.num_entries);
} while (curr < ba->num_entries);
return 0;
}
static unsigned long ba_order(unsigned long len)
static unsigned long ba_order(struct ba *ba, unsigned long len)
{
unsigned long i;
len = (len + BA_MIN_ALLOC - 1) / BA_MIN_ALLOC;
len = (len + ba->min_alloc - 1) / ba->min_alloc;
len--;
for (i = 0; i < sizeof(len)*8; i++)
if (len >> i == 0)
@ -120,14 +96,14 @@ static unsigned long ba_order(unsigned long len)
return i;
}
int ba_allocate(unsigned long len)
int ba_allocate(struct ba *ba, unsigned long len)
{
int curr = 0;
int end = ba.num_entries;
int end = ba->num_entries;
int best_fit = -1;
unsigned long order = ba_order(len);
unsigned long order = ba_order(ba, len);
if (order > BA_MAX_ORDER)
if (order > ba->max_order)
return -1;
/* look through the bitmap:
@ -165,16 +141,16 @@ int ba_allocate(unsigned long len)
buddy = BA_BUDDY_INDEX(best_fit);
BA_ORDER(buddy) = BA_ORDER(best_fit);
}
ba.bitmap[best_fit].allocated = 1;
ba->bitmap[best_fit].allocated = 1;
return best_fit;
}
unsigned long ba_start_addr(int index)
unsigned long ba_start_addr(struct ba *ba, int index)
{
return BA_START_ADDR(index);
}
unsigned long ba_len(int index)
unsigned long ba_len(struct ba *ba, int index)
{
return BA_LEN(index);
}

31
linker/ba.h

@ -29,10 +29,31 @@
#ifndef __LINKER_BA_H
#define __LINKER_BA_H
extern void ba_init(void);
extern int ba_allocate(unsigned long len);
extern int ba_free(int index);
extern unsigned long ba_start_addr(int index);
extern unsigned long ba_len(int index);
struct ba_bits {
unsigned allocated:1; /* 1 if allocated, 0 if free */
unsigned order:7; /* size of the region in ba space */
};
struct ba {
/* start address of the ba space */
unsigned long base;
/* total size of the ba space */
unsigned long size;
/* the smaller allocation that can be made */
unsigned long min_alloc;
/* the order of the largest allocation that can be made */
unsigned long max_order;
/* number of entries in the ba space */
int num_entries;
/* the bitmap for the region indicating which entries are allocated
* and which are free */
struct ba_bits *bitmap;
};
extern void ba_init(struct ba *ba);
extern int ba_allocate(struct ba *ba, unsigned long len);
extern int ba_free(struct ba *ba, int index);
extern unsigned long ba_start_addr(struct ba *ba, int index);
extern unsigned long ba_len(struct ba *ba, int index);
#endif

12
linker/dlfcn.c

@ -74,7 +74,7 @@ const char *dlerror(void)
void *dlsym(void *handle, const char *symbol)
{
unsigned base;
soinfo *found;
Elf32_Sym *sym;
unsigned bind;
@ -90,19 +90,19 @@ void *dlsym(void *handle, const char *symbol)
}
if(handle == RTLD_DEFAULT) {
sym = lookup(symbol, &base);
sym = lookup(symbol, &found);
} else if(handle == RTLD_NEXT) {
sym = lookup(symbol, &base);
sym = lookup(symbol, &found);
} else {
sym = lookup_in_library((soinfo*) handle, symbol);
base = ((soinfo*) handle)->base;
found = (soinfo*)handle;
sym = lookup_in_library(found, symbol);
}
if(likely(sym != 0)) {
bind = ELF32_ST_BIND(sym->st_info);
if(likely((bind == STB_GLOBAL) && (sym->st_shndx != 0))) {
unsigned ret = sym->st_value + base;
unsigned ret = sym->st_value + found->base;
pthread_mutex_unlock(&dl_lock);
return (void*)ret;
}

162
linker/linker.c

@ -51,6 +51,7 @@
#include "ba.h"
#define ALLOW_SYMBOLS_FROM_MAIN 1
#define SO_MAX 96
/* Assume average path length of 64 and max 8 paths */
@ -86,6 +87,27 @@ static soinfo sopool[SO_MAX];
static soinfo *freelist = NULL;
static soinfo *solist = &libdl_info;
static soinfo *sonext = &libdl_info;
#if ALLOW_SYMBOLS_FROM_MAIN
static soinfo *somain; /* main process, always the one after libdl_info */
#endif
/* Set up for the buddy allocator managing the prelinked libraries. */
static struct ba_bits ba_prelink_bitmap[(LIBLAST - LIBBASE) / LIBINC];
static struct ba ba_prelink = {
.base = LIBBASE,
.size = LIBLAST - LIBBASE,
.min_alloc = LIBINC,
/* max_order will be determined automatically */
.bitmap = ba_prelink_bitmap,
.num_entries = sizeof(ba_prelink_bitmap)/sizeof(ba_prelink_bitmap[0]),
};
static inline int validate_soinfo(soinfo *si)
{
return (si >= sopool && si < sopool + SO_MAX) ||
si == &libdl_info;
}
static char ldpaths_buf[LDPATH_BUFSIZE];
static const char *ldpaths[LDPATH_MAX + 1];
@ -421,36 +443,87 @@ _do_lookup_in_so(soinfo *si, const char *name, unsigned *elf_hash)
return _elf_lookup (si, *elf_hash, name);
}
/* This is used by dl_sym() */
static Elf32_Sym *
_do_lookup(soinfo *si, const char *name, unsigned *base)
{
unsigned elf_hash = 0;
Elf32_Sym *s;
unsigned *d;
soinfo *lsi = si;
/* Look for symbols in the local scope first (the object who is
* searching). This happens with C++ templates on i386 for some
* reason. */
s = _do_lookup_in_so(si, name, &elf_hash);
if(s != NULL)
goto done;
for(d = si->dynamic; *d; d += 2) {
if(d[0] == DT_NEEDED){
lsi = (soinfo *)d[1];
if (!validate_soinfo(lsi)) {
DL_ERR("%5d bad DT_NEEDED pointer in %s",
pid, si->name);
return 0;
}
DEBUG("%5d %s: looking up %s in %s\n",
pid, si->name, name, lsi->name);
s = _do_lookup_in_so(lsi, name, &elf_hash);
if(s != NULL)
goto done;
}
}
#if ALLOW_SYMBOLS_FROM_MAIN
/* If we are resolving relocations while dlopen()ing a library, it's OK for
* the library to resolve a symbol that's defined in the executable itself,
* although this is rare and is generally a bad idea.
*/
if (somain) {
lsi = somain;
DEBUG("%5d %s: looking up %s in executable %s\n",
pid, si->name, name, lsi->name);
s = _do_lookup_in_so(lsi, name, &elf_hash);
}
#endif
done:
if(s != NULL) {
TRACE_TYPE(LOOKUP, "%5d si %s sym %s s->st_value = 0x%08x, "
"found in %s, base = 0x%08x\n",
pid, si->name, name, s->st_value, lsi->name, lsi->base);
*base = lsi->base;
return s;
}
return 0;
}
/* This is used by dl_sym(). It performs symbol lookup only within the
specified soinfo object and not in any of its dependencies.
*/
Elf32_Sym *lookup_in_library(soinfo *si, const char *name)
{
unsigned unused = 0;
return _do_lookup_in_so(si, name, &unused);
}
static Elf32_Sym *
_do_lookup(soinfo *user_si, const char *name, unsigned *base)
/* This is used by dl_sym(). It performs a global symbol lookup.
*/
Elf32_Sym *lookup(const char *name, soinfo **found)
{
unsigned elf_hash = 0;
Elf32_Sym *s = NULL;
soinfo *si;
/* Look for symbols in the local scope first (the object who is
* searching). This happens with C++ templates on i386 for some
* reason. */
if (user_si) {
s = _do_lookup_in_so(user_si, name, &elf_hash);
if (s != NULL)
*base = user_si->base;
}
for(si = solist; (s == NULL) && (si != NULL); si = si->next)
{
if((si->flags & FLAG_ERROR) || (si == user_si))
if(si->flags & FLAG_ERROR)
continue;
s = _do_lookup_in_so(si, name, &elf_hash);
if (s != NULL) {
*base = si->base;
*found = si;
break;
}
}
@ -464,12 +537,6 @@ _do_lookup(soinfo *user_si, const char *name, unsigned *base)
return 0;
}
/* This is used by dl_sym() */
Elf32_Sym *lookup(const char *name, unsigned *base)
{
return _do_lookup(NULL, name, base);
}
#if 0
static void dump(soinfo *si)
{
@ -728,14 +795,14 @@ alloc_mem_region(soinfo *si)
for it from the buddy allocator, which manages the area between
LIBBASE and LIBLAST.
*/
si->ba_index = ba_allocate(si->size);
si->ba_index = ba_allocate(&ba_prelink, si->size);
if(si->ba_index >= 0) {
si->base = ba_start_addr(si->ba_index);
si->base = ba_start_addr(&ba_prelink, si->ba_index);
PRINT("%5d mapping library '%s' at %08x (index %d) " \
"through buddy allocator.\n",
pid, si->name, si->base, si->ba_index);
if (reserve_mem_region(si) < 0) {
ba_free(si->ba_index);
ba_free(&ba_prelink, si->ba_index);
si->ba_index = -1;
si->base = 0;
goto err;
@ -1031,7 +1098,7 @@ load_library(const char *name)
/* Now actually load the library's segments into right places in memory */
if (load_segments(fd, &__header[0], si) < 0) {
if (si->ba_index >= 0) {
ba_free(si->ba_index);
ba_free(&ba_prelink, si->ba_index);
si->ba_index = -1;
}
goto fail;
@ -1085,7 +1152,10 @@ soinfo *find_library(const char *name)
for(si = solist; si != 0; si = si->next){
if(!strcmp(bname, si->name)) {
if(si->flags & FLAG_ERROR) return 0;
if(si->flags & FLAG_ERROR) {
DL_ERR("%5d '%s' failed to load previously", pid, bname);
return NULL;
}
if(si->flags & FLAG_LINKED) return si;
DL_ERR("OOPS: %5d recursive link to '%s'", pid, si->name);
return NULL;
@ -1113,14 +1183,16 @@ unsigned unload_library(soinfo *si)
for(d = si->dynamic; *d; d += 2) {
if(d[0] == DT_NEEDED){
soinfo *lsi = (soinfo *)d[1];
d[1] = 0;
if (validate_soinfo(lsi)) {
TRACE("%5d %s needs to unload %s\n", pid,
si->name, si->strtab + d[1]);
soinfo *lsi = find_library(si->strtab + d[1]);
if(lsi)
si->name, lsi->name);
unload_library(lsi);
}
else
DL_ERR("%5d could not unload '%s'",
pid, si->strtab + d[1]);
DL_ERR("%5d %s: could not unload dependent library",
pid, si->name);
}
}
@ -1129,7 +1201,7 @@ unsigned unload_library(soinfo *si)
PRINT("%5d releasing library '%s' address space at %08x "\
"through buddy allocator.\n",
pid, si->name, si->base);
ba_free(si->ba_index);
ba_free(&ba_prelink, si->ba_index);
}
notify_gdb_of_unload(si);
free_info(si);
@ -1180,9 +1252,13 @@ static int reloc_library(soinfo *si, Elf32_Rel *rel, unsigned count)
return -1;
}
#endif
if ((s->st_shndx == SHN_UNDEF) && (s->st_value != 0)) {
DL_ERR("%5d In '%s', shndx=%d && value=0x%08x. We do not "
"handle this yet", pid, si->name, s->st_shndx,
// st_shndx==SHN_UNDEF means an undefined symbol.
// st_value should be 0 then, except that the low bit of st_value is
// used to indicate whether the symbol points to an ARM or thumb function,
// and should be ignored in the following check.
if ((s->st_shndx == SHN_UNDEF) && ((s->st_value & ~1) != 0)) {
DL_ERR("%5d In '%s', symbol=%s shndx=%d && value=0x%08x. We do not "
"handle this yet", pid, si->name, sym_name, s->st_shndx,
s->st_value);
return -1;
}
@ -1638,6 +1714,14 @@ static int link_image(soinfo *si, unsigned wr_offset)
pid, si->strtab + d[1], si->name, tmp_err_buf);
goto fail;
}
/* Save the soinfo of the loaded DT_NEEDED library in the payload
of the DT_NEEDED entry itself, so that we can retrieve the
soinfo directly later from the dynamic segment. This is a hack,
but it allows us to map from DT_NEEDED to soinfo efficiently
later on when we resolve relocations, trying to look up a symgol
with dlsym().
*/
d[1] = (unsigned)lsi;
lsi->refcount++;
}
}
@ -1825,7 +1909,7 @@ unsigned __linker_init(unsigned **elfdata)
vecs += 2;
}
ba_init();
ba_init(&ba_prelink);
si->base = 0;
si->dynamic = (unsigned *)-1;
@ -1843,6 +1927,14 @@ unsigned __linker_init(unsigned **elfdata)
exit(-1);
}
#if ALLOW_SYMBOLS_FROM_MAIN
/* Set somain after we've loaded all the libraries in order to prevent
* linking of symbols back to the main image, which is not set up at that
* point yet.
*/
somain = si;
#endif
#if TIMING
gettimeofday(&t1,NULL);
PRINT("LINKER TIME: %s: %d microseconds\n", argv[0], (int) (

2
linker/linker.h

@ -203,7 +203,7 @@ extern soinfo libdl_info;
soinfo *find_library(const char *name);
unsigned unload_library(soinfo *si);
Elf32_Sym *lookup_in_library(soinfo *si, const char *name);
Elf32_Sym *lookup(const char *name, unsigned *base);
Elf32_Sym *lookup(const char *name, soinfo **found);
const char *linker_get_error(void);
#ifdef ANDROID_ARM_LINKER