some linux headers useful from user apps.

i'm still not sure whether it's a good idea to include or use any of
these, but i'll add them for now. it may make more sense to just add
official kernel headers to the include path for compiling programs
that need them.

various legacy and linux-specific stuff

this commit is part of an effort to make more of busybox work
out-of-the-box.

document changes for 0.7.1

implement [v]swprintf

implement wprintf family of functions

this implementation is extremely ugly and inefficient, but it avoids a
good deal of code duplication and bloat. it may be cleaned up later to
eliminate the remaining code duplication and some of the warts, but i
don't really care about its performance.

note that swprintf is not yet implemented.

fix broken wmemchr (unbounded search)

implement robust mutexes

some of this code should be cleaned up, e.g. using macros for some of
the bit flags, masks, etc. nonetheless, the code is believed to be
working and correct at this point.

avoid function call to pthread_self in mutex unlock

if the mutex was previously locked, we can assume pthread_self was
already called at the time of locking, and thus that the thread
pointer is initialized.

reorder mutex struct fields to make room for pointers (upcoming robust mutexes)

the layout has been chosen so that pointer slots 3 and 4 fit between
the integer slots on 32-bit archs, and come after the integer slots on
64-bit archs.

unify lock and owner fields of mutex structure

this change is necessary to free up one slot in the mutex structure so
that we can use doubly-linked lists in the implementation of robust
mutexes.

optimize contended normal mutex case; add int compare-and-swap atomic

simplify logic, slightly optimize contended case for non-default mutex types

correct error returns for error-checking mutexes

cut out a syscall on thread creation in the case where guard size is 0

don't expose EAGAIN, etc. from timed futex wait to caller

optimize file locking: avoid cache-polluting writes to global storage

partially-written draft of fmemopen, still in #if 0

remove some old cruft from sys/types.h

misplaced & in times() made it fail to work, and clobber the stack

implement flockfile api, rework stdio locking

pthread.h needs clockid_t

actually it gets this from time.h if _POSIX_C_SOURCE or any other
feature test macros are defined, but it breaks if they're not.

document some additional important changes

update whatsnew file for release of 0.7.0

match dimensions so we can use all slots without invoking OOB-array-access

implement dummy pthread_attr_[gs]etschedparam functions

for some reason these functions are not shaded by the PS/TPS option in
POSIX, so presumably they are mandatory, even though the functionality
they offer is optional. for now, provide them in case any programs
depend on their existence, but disallow any priority except the
default.

fix pthread_attr_* implementations to match corrected prototypes

fix missing ENOTSUP error code

missing const in some pthread_attr_* prototypes

formatting whatsnew file

list major changes in preparation for release

fix failure behavior of sem_open when sem does not exist

fix some semaphore wait semantics (race condition deadlock and error checking)

fix sem_open and sem_close to obey posix semantics

multiple opens of the same named semaphore must return the same
pointer, and only the last close can unmap it. thus the ugly global
state keeping track of mappings. the maximum number of distinct named
semaphores that can be opened is limited sufficiently small that the
linear searches take trivial time, especially compared to the syscall
overhead of these functions.

optimize pthread termination in the non-detached case

we can avoid blocking signals by simply using a flag to mark that the
thread has exited and prevent it from getting counted in the rsyscall
signal-pingpong. this restores the original pthread create/join
throughput from before the sigprocmask call was added.

fix errors in sigqueue (potential information leak, wrong behavior)

1. any padding in the siginfo struct was not necessarily zero-filled,
so it might have contained private data off the caller's stack.

2. the uid and pid must be filled in from userspace. the previous
rsyscall fix broke rsyscalls because the values were always incorrect.

security fix: check that cancel/rsyscall signal was sent by the process itself

more cancellation points: tcdrain, clock_nanosleep

remove useless return value checks for functions that cannot fail

make sigsuspend a cancellation point

make sigtimedwait a cancellation point

don't fail with EINTR in sigtimedwait

POSIX allows either behavior, but sigwait is not allowed to fail with
EINTR, so the retry loop would have to be in one or the other anyway.

fix sigsuspend syscall

make sigaltstack work (missing macros in signal.h, error conditions)

fix errno behavior in clock_* functions

these functions are specified inconsistent in whether they're
specified to return an error value, or return -1 and set errno.
hopefully now they all match what POSIX requires.

fix error handling for pthread_sigmask

it must return errno, not -1, and should reject invalud values for how.

make fork properly initialize the main thread in the child process

optimize pthread initialization

the set_tid_address returns the tid (which is also the pid when called
from the initial thread) so there is no need to make a separate
syscall to get pid/tid.

fix race condition in raise - just mask signals

a signal handler could fork after the pid/tid were read, causing the
wrong process to be signalled. i'm not sure if this is supposed to
have UB or not, but raise is async-signal-safe, so it probably is
allowed. the current solution is slightly expensive so this
implementation is likely to be changed in the future.

fix raise semantics with threads.

fix typos in dirent.h

fcntl.h should make availabel the mode constants from sys/stat.h

also remove some legacy nonsense that crept in.

simplify and optimize pthread_mutex_trylock

rwlock trylock functions were wrongly returning EAGAIN instead of EBUSY

fix major breakage in pthread_once (it was always deadlocking)

the issue was a break statement that was breaking only from the
switch, not the enclosing for loop, and a failure to set the final
success state.

fix and optimize non-default-type mutex behavior

problem 1: mutex type from the attribute was being ignored by
pthread_mutex_init, so recursive/errorchecking mutexes were never
being used at all.

problem 2: ownership of recursive mutexes was not being enforced at
unlock time.

implement pthread_mutexattr_[gs]etpshared functions

disallow cpu time clocks as condattr clock values

add macros for use with d_type extension field in dirent

fix off-by-one error in sem_(timed)wait (using old sem value instead of new)

use the selected clock from the condattr for pthread_cond_timedwait

add prototypes for pthread_condattr_* and pthread_rwlockattr_*

implement pthread_rwlockattr_* (essentially no-ops)

implement pthread_condattr_* interfaces

note that, while the attributes are stored, they are not used in
pthread_cond_init yet.

reject invalid attribute settings

note that this is a pedantic conformance issue and waste of code. it
only affects broken code or code that is probing for conformance.

implement barrier attribute functions (essentially no-ops)

enforce stack size min in pthread_attr_setstacksize

implement POSIX semaphores

preliminaries to adding POSIX semaphores

optimize POSIX TSD for fast pthread_getspecific

namespace cleanup in sys/mman.h

implement POSIX shared memory

use -L/...../ -lgcc instead of /...../libgcc.a in musl-gcc wrapper

this should avoid warnings about unused libs when not linking, and
might fix some other obscure issues too. i might replace this approach
with a completely different one soon though.

depends on settimeofday which needs _GNU_SOURCE feature test

implement futimens and utimensat

cleanup namespace in sys/time.h

implement fexecve

cleanup utf-8 multibyte code, use visibility if possible

this code was written independently of musl, with support for a the
backwards, nonstandard "31-bit unicode" some libraries/apps might
want. unfortunately the extra code (inside #ifdef) makes the source
harder to read and makes code that should be simple look complex, so
i'm removing it. anyone who wants to use the old code can find it in
the history or from elsewhere.

also, change the visibility of the __fsmu8 state machine table to
hidden, if supported. this should improve performance slightly in
shared-library builds.

fix missing prototype for strsignal

various changes in preparation for dynamic linking support

prefer using visibility=hidden for __libc internal data, rather than
an accessor function, if the compiler has visibility.

optimize with -O3 for PIC targets (shared library). without heavy
inlining, reloading the GOT register in small functions kills
performance. 20-30% size increase for a single libc.so is not a big
deal, compared to comparaible size increase in every static binaries.

use -Bsymbolic-functions, not -Bsymbolic. global variables are subject
to COPY relocations, and thus binding their addresses in the library
at link time will cause library functions to read the wrong (original)
copies instead of the copies made in the main program's bss section.

add entry point, _start, for dynamic linker.

apply feature test protection to memccpy

add implementation of memccpy function

fix backwards conditional in stpncpy

this only made the function unnecessarily slow on systems with
unaligned access, but would of course crash on systems that can't do
unaligned accesses (none of which have ports yet).

rewind must clear the error indicator in addition to seeking

change errno to static linkage (improves PIC code generation)

cleanup comment cruft in startup code

make startup code PIE-compatible

remove sample utf-8 code that's not part of the standard library

use an accessor function for __libc data pointer when compiled as PIC

prior to this change, a large portion of libc was unusable prior to
relocation by the dynamic linker, due to dependence on the global data
in the __libc structure and the need to obtain its address through the
GOT. with this patch, the accessor function __libc_loc is now able to
obtain the address of __libc via PC-relative addressing without using
the GOT. this means the majority of libc functionality is now
accessible right away.

naturally, the above statements all depend on having an architecture
where PC-relative addressing and jumps/calls are feasible, and a
compiler that generates the appropriate code.

avoid referencing address of extern function from vdprintf

this change is in preparation for upcoming PIC/shared library support.
the intent is to avoid going through the GOT, mainly so that dprintf
is operable immediately, prior to processing of relocations. having
dprintf accessible from the dynamic linker will make writing and
debugging the dynamic linker much easier.

shave off 2 bytes from crt1.o _start

cleanup asprintf stuff

prototypes for GNU asprintf/vasprintf

fix %n specifier, again. this time it was storing the wrong value.

include sys/sysmacros.h from sys/types.h when _GNU_SOURCE is defined

fix typo in inotify structure

make malloc(0) return unique pointers rather than NULL

this change is made with some reluctance, but i think it's for the
best. correct programs must handle either behavior, so there is little
advantage to having malloc(0) return NULL. and i managed to actually
make the malloc code slightly smaller with this change.

fix simple_malloc malloc(0) behavior not to return non-unique pointers

fix simple_malloc size restrictions

do not allow allocations that overflow ptrdiff_t; fix some overflow
checks that were not quite right but didn't matter due to address
layout implementation.

fix null pointer dereference introduced in last sigprocmask commit

make real symbols for the legacy (nonstandardized) utmp functions

this is needed in the long term for ABI compatibility anyway, and in
the immediate, it helps with building broken programs like GNU screen
that try to prototype the functions themselves rather than using the
header.