Copy stable/9 to releng/9.3 as part of the 9.3-RELEASE cycle.

Approved by: re (implicit)
Sponsored by: The FreeBSD Foundation

Copy head to stable/9 as part of 9.0-RELEASE release cycle.

Approved by: re (implicit)

Merge from tbemd:

Convert from using MACHINE_ARCH to MACHINE_CPUARCH. Hoist path statement
up into the top Makefile rather than repeating it on every arch Makefile.

Though these libraries are disconnected from the build and don't
currently build, they should be kept. [1]

Unbreak their makefiles by removing the support for the long gone
DEFAULT_THREAD_LIB knob. (Allows the tools/make_libdeps.sh script
to succeed.)

According to: davidxu and deischen [1]
MFC after: 3 days

Bump the version of all non-symbol-versioned shared libraries in
preparation for 8.0-RELEASE. Add the previous version of those
libraries to ObsoleteFiles.inc and bump __FreeBSD_Version.

Reviewed by: kib
Approved by: re (rwatson)

Honor WITHOUT_INSTALLLIB in some places.

Call the fcntl compatiblity wrapper from the thread library fcntl wrappers
so that they get the benefit of the (limited) forward ABI compatibility.

MFC after: 1 week

Fix some "in in" typos in comments.

PR: 121490
Submitted by: Anatoly Borodin <anatoly.borodin@gmail.com>
Approved by: rwatson (mentor), jkoshy
MFC after: 3 days

Add missing #include

Spotted by: tinderbox
Submitted by: Pietro Cerutti <gahr@gahr.ch>
Pointy hat to: des

Add pthread_mutex_isowned_np() here as well; libthr and libkse are supposed
to have identical functionality.

MFC after: 2 weeks

Previous commit had a typo that resulted in symbol versioning being
(silently) disabled for libkse...

Pointy hat to: des

Give libkse the same treatment as libthr re. symbol versioning.

MFC after: 2 weeks

When reinitializing a lockuser, don't assume that the lock is in
use. If it is in use, use the watched request, otherwise use the
lockuser's own request. Only allocate a lockuser request if both
requests are null.

PR: 119920
Tested by (6.x): Landon Fuller <landonf -at- bikemonkey -dot- org>

Remove hacks to allow libkse to export its symbols in the LIBTHREAD_1_0
version namespace which was needed before the library version was
bumped.

Set the tcb (thread control block) in the child process after a fork.
This protects against a race with an upcall in the parent during the
fork which can clobber the parent's tcb before the vm space is copied
in the child. The child then gets a corrupted tcb that is either null
or that points to another thread that doesn't exist in the child (after
a fork, only the fork()ing thread exists in the child).

Reported by: Arno J. Klaassen (arno at heho / snv / jussieu / fr)

For un-prototyped static inline functions declared in pthread_md.h on
ia64, powerpc, and sparc64, use ANSI function headers and specifically
indicate the lack of arguments with 'void'. Otherwise, warnings are
generated at WARNS=3, leading to a compile failure with -Werror.

WARNS=3'ify.

Initialize the current thread and signal locks so that sigaction()
will work after a fork().

WARNS=3'ify.

To reduce the impact of possible removal of the syscalls required by
libkse in FreeBSD 8.0, do not build or install static versions of libkse
(i.e. libkse*.a) in the default case. Static versions will be built and
installed if libthr is not built or if libkse is the default threading
library.

Discussed on: freebsd-arch
MFC after: 3 days

Fix pointer dereferencing problems in _pthread_mutex_init_calloc_cb() that
were obscured by pseudo-opaque pthreads API pointer casting.

Add _pthread_mutex_init_calloc_cb() to libthr and libkse, so that malloc(3)
(part of libc) can use pthreads mutexes without causing infinite recursion
during initialization.

Move the added code in revision 1.26 into function pthread_key_create,
it should be there.

These are the things that the tinderbox has problems with because it
doesn't use the default CFLAGS which contain -fno-strict-aliasing.

Until the code is cleaned up, just add -fno-strict-aliasing to the
CFLAGS of these for the tinderboxes' sake, allowing the rest of the
tree to have -Werror enabled again.

MFlibthr:
In _pthread_key_create() ensure that libkse is initialized.

Add a new "non-portable" mutex type, PTHREAD_MUTEX_ADAPTIVE_NP. This
is also implemented in glibc and is used by a number of existing
applications (mysql, firefox, etc).

This mutex type is a default mutex with the additional property that
it spins briefly when attempting to acquire a contested lock, doing
trylock operations in userland before entering the kernel to block if
eventually unsuccessful.

The expectation is that applications requesting this mutex type know
that the mutex is likely to be only held for very brief periods, so it
is faster to spin in userland and probably succeed in acquiring the
mutex, than to enter the kernel and sleep, only to be woken up almost
immediately. This can help significantly in certain cases when
pthread mutexes are heavily contended and held for brief durations
(such as mysql).

Spin up to 200 times before entering the kernel, which represents only
a few us on modern CPUs. No performance degradation was observed with
this value and it is sufficient to avoid a large performance drop in
mysql performance in the heavily contended pthread mutex case.

The libkse implementation is a NOP.

Reviewed by: jeff
MFC after: 3 days

For 7.0 make the shared lib "version" '3'.
Approved by: re(kensmith)

Repo copy libpthreads to libkse.
This introduces the WITHOUT_LIBKSE nob,
and changes WITHOUT_LIBPTHREADS to mean with neither threading libs.
Approved by: re(kensmith)

Always install libpthread.* symlinks if at least one of
the threading libraries is built. This simplifies the
logic in makefiles that need to check if the pthreads
support is present. It also fixes a bug where we would
build a threading library that we shouldn't have built:
for example, building with WITHOUT_LIBTHR and the default
value of DEFAULT_THREADING_LIB (libthr) would mistakenly
build the libthr library, but not install it.

Approved by: re (kensmith)

Bump library versions in preparation for 7.0.

Ok'd by: kan

Fix a logic bug I re-introduced in my patch I sent to Daniel
that would cause the selected shared threading library to be
overwritten with its 32-bit version on amd64.

PR: amd64/112509

Allow DEFAULT_THREAD_LIB to be set from /etc/src.conf.

Submitted by: ru

Enable symbol versioning by default. Use WITHOUT_SYMVER to disable it.
Warning, after symbol versioning is enabled, going back is not easy
(use WITHOUT_SYMVER at your own risk).

Change the default thread library to libthr.

There most likely still needs to be a version bump for at least the
thread libraries. If necessary, this will happen later.

Catch up with the renaming of the private version namespace.

Add a reference and lock the target thread when setting its name.

Submitted by: davidxu (via libthr)

Oops, fix a typo in the last commit :-/

In the NOTYET code path when a process forks, the remaining
child thread goes back to system scope rather than process
scope. This allows an ensuing exec() to actually work.

This change was made a year ago here, but I "forgot" to
commit it :(

Approved by: deischen
MFC after: 3 weeks

Remove 3rd clause, renumber, ok per email

Clean bound and non-bound pthread structures consistently before
they become candidates for reuse. Without this fix, some of the
state from a thread structure's previous incarnation could interfere
with its new one. Specifically, a non-bound thread started as
"suspended" (see pthread_attr_setcreatesuspend_np()) might not get
scheduled at all when resumed, as the "active" flag would be set
spuriously.

Reviewed by: deischen@, davidxu@
MFC after: 1 week

If a thread was detached, return EINVAL instead, the error code
is also returned by pthread_detach() if a thread was already
detached, the error code was already documented:

> [EINVAL] The implementation has detected that the value speci-
> fied by thread does not refer to a joinable thread.

Stylize:
o avoid using a global register variable.
o redefine struct ia64_tp as a union. We don't have to get to the
fields themselves. We just need it to be of the right size with
the right alignment.

The ucontext is 16-byte aligned, which means that struct tcb is
16-byte aligned. Consequently, struct tcb is a multiple of 16
bytes in size. We need to make sure there's no padding after
struct ppc32_tp. We do this by explicitly adding the necessary
padding in front of it.

Stylize. Introduce ppc_{get|set}_tp() and ppc_{get|set}_tcb() to
abstract the magic that happens when deriving one or the other.

Implement TLS.

Remove alpha left-overs.

o Remove a cruft prevented libpthread sigaction(2) wrapper to
do its work for SIGINFO. Always install libpthread signal handler
wrapper for SIGINFO even if user SIG_IGN's or SIG_DFL's it.

SIGINFO has a special meaning for libpthread: when LIBPTHREAD_DEBUG
enviroment variable defined it is used for dumping an information
about threads to /tmp/.

Reported by: mi
Reviewed by: deischen
MFC after: 2 weeks

Export offsets of thread signal pending set and signal mask for debugger.

In order to let new binutils can compile it, replace movl with
movw for segment saving and restoring.

Submitted by: Diego 'Flameeyes' Petteno flameeyes at gentoo dot org

Unexpand TAILQ_FIRST(foo) == NULL to TAILQ_EMPTY.

Ok'ed by: davidxu

Install shared libpthread library into /lib; needed by some
/sbin programs.

Bring libpthread up to WARNS level 2.

Reviewed by: deischen

Fix prototype mismatch and use of un-namespaced pthread functions.

Use the correct type for and argument. Recent changes to namespace.h
exposed this bug.

Reported by: kris

Suuply the name of the version map and let bsd.lib.mk supply
the link arguments.

Add compatibility symbol maps. libpthread (.so.1 and .so.2)
used LIBTHREAD_1_0 as its version definition, but now needs
to define its symbols in the same namespace used by libc.
The compatibility hooks allows you to use libraries and
binaries built and linked to libpthread before libc was
built with symbol versioning. The shims can be removed if
libpthread is given a version bump.

Reviewed by: davidxu

Only catch SIGINFO (for dumping thread states) when LIBPTHREAD_DEBUG
is defined in the environment.

Requested by: jmg & a few others

Add some more pthread stubs so that librt can use them.
The thread jump table has been resorted, so you need to
keep libc, libpthread, and libthr in sync.

Submitted by: xu

Fix a race condition introduced when redzones were added. Use an
atomic operation to return and adjust the stack.

Submitted by: luoqi

Eliminate a race condition in timed waits (cv, mutex, and sleeps).
MFC Candidate.

PR: 93592

Don't forget to initialize a tailq before using it.

MFC candidate
Noticed by: luoqi

Increase the number of spinlocks, since libc's malloc implementation is
about to significantly increase the number of spinlocks used.

Approved by: markm (mentor)

In preparation for a new malloc implementation:

* Add posix_memalign().

* Move calloc() from calloc.c to malloc.c. Add a calloc() implementation in
rtld-elf in order to make the loader happy (even though calloc() isn't
used in rtld-elf).

* Add _malloc_prefork() and _malloc_postfork(), and use them instead of
directly manipulating __malloc_lock.

Approved by: phk, markm (mentor)

For the ``#ifdef NOTYET'' code that allows calling non-async-safe
functions in the child after a fork() from a threaded process,
use __sys_setprocmask() rather than setprocmask() to keep our
signal handling sane. Without this fix, signals are essentially
ignored in said child and things such as protection violations
result in an endless busy loop.

Reviewed by: deischen

o Include <sys/time.h>
o Make this ILP32/LP64 clean: cast pointers to long
o Code conditional upon DEBUG must also be conditional
upon _LIBC_R_

o Include <string.h>
o Make this ILP32/LP64 clean: cast pointers to long.

Fix typo: s/_LIBC_R/_LIBC_R_/

Include files thr_condattr_pshared.c and thr_mattr_pshare.c.

Add functions pthread_mutexattr_setpshared and pthread_mutexattr_getpshared.

Add function pthread_condattr_setpshared and pthread_condattr_getpshared.

Modify the code path of the ifdef NOTYET part of _kse_single_thread():

o Don't reinitialise the atfork() handler list in the child. We
are meant to call the child handler, and on subsequent fork()s
should call all three functions as normal.
o Don't reinitialise the thread specific keyed data in the
child after a fork. Applications may require this for context.
o Reinitialise curthread->tlflags after removing ourselves from
(and reinitialising) the various internal thread lists.
o Reinitialise __malloc_lock in the child after fork() (to balance
our explicitly taking the lock prior to the fork()).

With these changes, it is possible to enable the NOTYET code in
thr_kern.c to allow the use of non-async-safe functions after
fork()ing from a threaded program.

Reviewed by: Daniel Eischen <deischen@freebsd.org>
[_malloc_lock reinitialisation has since been moved to avoid polluting the
!NOTYET code]

Include needed headers that were obtained through <pthread.h>. Sort headers
while here.

Allocate a thread's tcb last so it is easier to handle failures to
malloc() siginfo.

PR: 85468

Handle failure to malloc() part of the thread structure.

PR: 83457

Don't attempt to initialize the rtld lock if it can't be malloc()'d.

PR: 83452

- Prefix MUTEX_TYPE_MAX with PTHREAD_ to avoid namespace pollution.
- Remove the macros MUTEX_TYPE_FAST and MUTEX_TYPE_COUNTING_FAST.

OK'ed by: deischen

Add a cancellation point for usleep().

Remove an unused variable.

Catch up with the atomic_FOO_ptr() changes and silence a few warnings.

Bump the shared library version number of all libraries that have not
been bumped since RELENG_5.

Reviewed by: ru
Approved by: re (not needed for commit check but in principle...)

Clean out the leftovers from the i386_set_gsbase() TLS conversion.

Like on libthr, there is an i386_set_gsbase() stub implementation here
to avoid libc.so.5 issues. This should likely be a weak symbol and I
expect this will be fixed soon.

Approved by: re

Fix off-by-one nanosecond in macro TIMESPEC_ADD.

Reviewed by: deischen
Approved by: re (dwhite)
MFC after : 4 days

Remove the special _amd64_set_gsbase() code for #ifdef COMPAT_32BIT, now
that the amd64 kernel implements i386_get/set_gsbase(). All the rest of
the ldt backwards compat code should go away soon.

Use the i386_set_gsbase() syscall if it is implemented in the kernel.

This is a little hairy here because the allocation and usage of this
functionality is split into two places in libpthread.

Use the new atomic_cmpset_32().

Eliminate plt relocation for kse_switchin.

Change the spin lock logic to a reasonable one. We should spin when
the lock is held by other thread, but not when nobody owns it. According
to deischen@, this part of code will never be hit in our threads
library, since it does not use locks without wait/wakeup functions.

Spotted by: mingyanguo via ChinaUnix.net forum
Reviewed by: deischen

Bring in a more healthy version of the libpthread for arm, which uses
ARM_TP_ADDRESS.

Somewhere along the line, tick accumulation for SA threads was
changed to use the statclock. Make sure we calculate the value
of a tick correctly in userland.

Noticed by: Kazuaki Oda <kaakun at highway dot ne dot jp>

Set the default guardsize and stacksize in the default thread
attribute when the library is initialized.

Increase the default stacksizes:

32-bit 64-bit
main thread 2MB 4MB
other threads 1MB 2MB

Don't panic when sigsuspend is interrupted by a cancellation.

PR: 75273

Use a generic way to back threads out of wait queues when handling
signals instead of having more intricate knowledge of thread state
within signal handling.

Simplify signal code because of above (by David Xu).

Use macros for libpthread usage of pthread_cleanup_push() and
pthread_cleanup_pop(). This removes some instances of malloc()
and free() from the semaphore and pthread_once() implementations.

When single threaded and forking(), make sure that the current
thread's signal mask is inherited by the forked thread.

Use private mutexes for libc and libpthread. Signals are
deferred while threads hold private mutexes. This fix also
breaks www/linuxpluginwrapper; a patch that fixes it is at
http://people.freebsd.org/~deischen/kse/linuxpluginwrapper.diff

Fix race condition in condition variables where handling a
signal (pthread_kill() or kill()) may not see a wakeup
(pthread_cond_signal() or pthread_cond_broadcast()).

In collaboration with: davidxu

i386_set_ldt() is not available when running 32 bit binaries on amd64
kernels. Use the recently exposed direct-set routines instead. This is
only activated for when we compile i386 support libraries on amd64.

Cosmetic tweaks to reduce diffs to the i386 counterpart.

Partial support of KSE for arm.

Save cancelflags in signal frame, this fixes a problem that
a thread in pthread_cond_wait handled a signal can no longer
be canceled.

Reviewed by: deischen

Make pthread_mutex_trylock(3) return EBUSY on failure, as all software
packages expect and seems to be most correct according to the slightly-
ambiguous standards.

MFC after: 1 month
Corroborated by: POSIX <http://tinyurl.com/4uvub>
Reviewed by: silence on threads@

For variables that are only checked with defined(), don't provide
any fake value.

Check unhandled signals before thread marks itself as DEAD,
this reduces chances of signal losting problem found by
Peter Holm <peter@holm.cc>

1. Move thread list flags into new separate member, and atomically
put DEAD thread on GC list, this closes a race between pthread_join
and thr_cleanup.
2. Introduce a mutex to protect tcb initialization, tls allocation and
deallocation code in rtld seems no lock protection or it is broken,
under stress testing, memory is corrupted.

Reviewed by: deischen
patch partly provided by: deischen

Decrease reference count if we won't use the thread, this avoids memory
leak under some cases.

if system scope thread didn't set timeout, don't call clock_gettime syscall
before and after sleeping.

Reviewed by: deischen

Use PTHREAD_SCOPE_SYSTEM to decide what should be done.

Follow kernel change, restore signal mask correctly by using a command
of kse_thr_interrupt.

Allocate red zone and stack space together and then split red zone from
allocated space, orignal code left red zone unallocated, but those space
can be allocated by user code, and result was providing no protection.

Add a wrapper for execve(). The exec'd process must be started with
the signal mask and pending signals of the calling thread. These
are stored in userland in libpthread.

There is a small race condition in this patch which could cause
problems if a signal arrives after setting the (kernel) signal
mask and before exec'ing. The thread's set of pending signals
also are not yet installed in the exec'd process. Both of these
will be corrected with the addition of a special syscall.

Reported & Tested by: Joost Bekkers <joost at jodocus dot org>
Reviewed by: julian, davidxu

_tcb_ctor takes two args.

Make sure we don't call _thr_start_sig_daemon() when SYSTEM_SCOPE_ONLY is defined. This makes libpthread usable on powerpc.

Approved by: grehan (mentor), deischen

Add missing brackets. It was committed from wrong tree.

gcc -O2 cleanup. tested for a long time.

Reviewed by: deischen

Pull debug symbols in for statically linked binary.

Reviewed by: desichen

Fix compile, s/tp_dtv/tp_tdv/g.

Bring PPC up to date with latest TLS changes.

1. Add macro DTV_OFFSET to calculate dtv offset in tcb.
2. Export symbols needed by debugger.

Add a file to collection all symbols will be needed by debugger.

Add TLS support for i386 and amd64.

As long as we have a knob to force system scope threads, why not have
a knob to force process scope threads. If the environment variable
LIBPTHREAD_PROCESS_SCOPE is set, force all threads to be process
scope threads regardless of how the application creates them. If
LIBPTHREAD_SYSTEM_SCOPE is set (forcing system scope threads), it
overrides LIBPTHREAD_PROCESS_SCOPE.

$ # To force system scope threads
$ LIBPTHREAD_SYSTEM_SCOPE=anything threaded_app
$ # To force process scope threads
$ LIBPTHREAD_PROCESS_SCOPE=anything threaded_app

Check debugger suspending flag for system scope thread.

Reviewed by: deischen

Add a way to force 1:1 mode for libpthread. To do this, define
LIBPTHREAD_SYSTEM_SCOPE in the environment.

You can still force libpthread to be built in strictly 1:1 by
adding -DSYSTEM_SCOPE_ONLY to CFLAGS. This is kept for archs
that don't yet support M:N mode.

Requested by: rwatson
Reviewed by: davidxu

s/TMDF_DONOTRUNUSER/TMDF_SUSPEND/g

Dicussed with: deischen

Save context in kernel fashion, so it can be restored by
kse_switchin syscall.

Remove unused field.

Macro optimize, this increases context switch speed about 2% on my
athlon64 machine.

PPC MD bits for KSE. Runs test cases OK. Crippled to 1:1 mode for
the time being.

Don't include lock.h and pthread_md.h when we're being included by
libthread_db. Both headers are included seperately.

Copy lwp id to thread mailbox.

Call kse_switchin to switch context when being debugged.

Remove unused symbols.

Let debugger check signal, make SIGINFO works.

If _libkse_debug is not zero, activate thread mode.

Add code to support thread debugging.
1. Add global varible _libkse_debug, debugger uses the varible to identify
libpthread. when the varible is written to non-zero by debugger, libpthread
will take some special action at context switch time, it will check
TMDF_DOTRUNUSER flags, if a thread has the flags set by debugger, it won't
be scheduled, when a thread leaves KSE critical region, thread checks
the flag, if it was set, the thread relinquish CPU.

2. Add pq_first_debug to select a thread allowd to run by debugger.

3. Some names prefixed with _thr are renamed to _thread prefix.

which is allowed to run by debugger.

kse_switchin ABI was changed in kernel.

Check pending signals, if there is signal will be unblocked by
sigsuspend, thread shouldn't wait, in old code, it may be
ignored.
When a signal handler is invoked in sigsuspend, thread gets
two different signal masks, one is in thread structure,
sigprocmask() can retrieve it, another is in ucontext
which is a third parameter of signal handler, the former is
the result of sigsuspend mask ORed with sigaction's sa_mask
and current signal, the later is the mask in thread structure
before sigsuspend is called. After signal handler is called,
the mask in ucontext should be copied into thread structure,
and becomes CURRENT signal mask, then sigsuspend returns to
user code.

Reviewed by: deischen
Tested by: Sean McNeil <sean@mcneil.com>

Avoid clobbering the red zone when running on the new context's stack in
_amd64_restore_context().

Arm bits for libpthread. It has no chances to work and should be considered
as stubs.

After forking and initializing the library to single-threaded
mode (where the forked thread is the one and only thread and
is marked as system scope), set the system scope flag before
initializing the signal mask. This prevents trying to use
internal locks that haven't yet been initialized.

Reported by: Dan Nelson <dnelson at allantgroup.com>
Reviewed by: davidxu

Fix a POSIX conformance bug. POSIX says sigwait should return error number
in return value not in errno.

Fixed a misspelling of 0 as NULL.

style cleanup: Remove duplicate $FreeBSD$ tags.

These files had tags after the copyright notice,
inside the comment block (incorrect, removed),
and outside the comment block (correct).

Approved by: rwatson (mentor)

Add cancellation point to sem_wait() and sem_timedwait() for pshared
semaphores. Also add cancellation cleanup handlers to keep semaphores
in a consistent state.

Submitted in part by: davidxu
Reviewed by: davidxu

libkse was renamed to libpthread.

Provide a userland version of non-pshared semaphores and add cancellation
points to sem_wait() and sem_timedwait(). Also make sem_post signal-safe.

Now that libpthread is the default threading library, remove the
compatibility link from libc_r to libpthread (previously a link
from libc_r to libkse).

Change libkse back to libpthread and make it the default
thread library for i386, amd64, and ia64. For alpha
and sparc64 the library is not changed and remains libkse,
and links are installed so that libpthread -> libc_r.

The gcc -pthread option will be changed in a separate
commit so that it links to -lpthread instead of -lc_r.

Approved by: re@

Return EPERM if mutex owner is not current thread but it tries to
unlock the mutex, old code confuses some programs when it returns EINVAL.

Noticed by: bland

Add a simple work-around for deadlocking on recursive read locks
on a rwlock while there are writers waiting. We normally favor
writers but when a reader already has at least one other read lock,
we favor the reader. We don't track all the rwlocks owned by a
thread, nor all the threads that own a rwlock -- we just keep
a count of all the read locks owned by a thread.

PR: 24641

Kernel now supports per-thread sigaltstack, follow the change to
enable sigaltstack for scope system thread.

Return error code in errno, not in return value.

Fix a typo.

Forgot to commit this file for last commit. :(

Implement sigaltstack() as per-threaded. Current only scope process thread
is supported, for scope system process, kernel signal bits need to be
changed.

Reviewed by: deischen
Tested on : i386 amd64 ia64

Correctly retrieve sigaction flags.

Replace a comment with more accurated one, memory heap is now protected by
new fork() wrapper.

Code clean up, remove unused MACROS and function prototypes.

accept() returns a file descriptor when it succeeds which is very
likely to be non-zero. When leaving the cancellation point, check
the return value against -1 to see if cancellation should be
checked. While I'm here, make the same change to connect() just
to be consisitent.

Pointed out by: davidxu

Remove an unused struct definition.

Add cancellation points for accept() and connect().

Use mutex instead of low level thread lock to implement spinlock, this
avoids signal to be blocked when otherwise it can be handled.

Rename _thr_enter_cancellation_point to _thr_cancel_enter, rename
_thr_leave_cancellation_point to _thr_cancel_leave, add a parameter
to _thr_cancel_leave to indicate whether cancellation point should be
checked, this gives us an option to not check cancallation point if
a syscall successfully returns to avoid any leaks, current I have
creat(), open() and fcntl(F_DUPFD) to not check cancellation point
after they sucessfully returned.

Replace some members in structure kse with bit flags to same some
memory.

Conditionally compile THR_ASSERT to nothing if _PTHREAD_INVARIANTS is
not defined.

Inline some small functions in thr_cancel.c.

Use __predict_false in thr_kern.c for some executed only once code.

Reviewd by: deischen

More reliably check timeout for pthread_mutex_timedlock.

Go back to using rev 1.18 where thread locks are used instead of KSE
locks for [libc] spinlock implementation. This was previously backed
out because it exposed a bug in ia64 implementation.

OK'd by: marcel

Simplify the contexts created by the kernel and remove the related
flags. We now create asynchronous contexts or syscall contexts only.
Syscall contexts differ from the minimal ABI dictated contexts by
having the scratch registers saved and restored because that's where
we keep the syscall arguments and syscall return values.
Since this change affects KSE, have it use kse_switchin(2) for the
"new" syscall context.

Apply a second fix for stack alignment with libkse. This time, enter the
UTS with the stack correctly aligned. Also, while here, use an indirect
jump rather than the pushq/ret hack.

This fixes threaded apps that use floating point for me, although
it hasn't solved all the problems. It is an improvement though.
Preservation of the 128 byte red zone hasn't been resolved yet.

Approved by: re (scottl)

Eliminate two pushl by using call instruction directly, this really
helps branch predict a lot for INTEL P4.

Approved by: re (scottl)

1.Macro optimizing KSE_LOCK_ACQUIRE and THR_LOCK_ACQUIRE to use static fall
through branch predict as suggested in INTEL IA32 optimization guide.

2.Allocate siginfo arrary separately to avoid pthread to be allocated at
2K boundary, which hits L1 address alias problem and causes context
switch to be slow down.

3.Simplify context switch code by removing redundant code, code size is
reduced, so it is expected to run faster.

Reviewed by: deischen
Approved by: re (scottl)

Remove surplus mmap() call for stack guard page in init_private, it is done
in init_main_thread. Also don't initialize lock and lockuser again for initial
thread, it is already done by _thr_alloc().

Reviewed by: deischen
Approved by: re (scottl)

Back out last change and go back to using KSE locks instead of thread
locks until we know why this breaks ia64.

Reported by: marcel

If a thread in critical region got a synchronous signal, according current
signal handling mode, there is no chance to handle the signal, something
must be wrong in the library, just call kse_thr_interrupt to dump its core.
I have the code for a long time, but forgot to commit it.

Use THR lock instead of KSE lock to avoid scheduler be blocked in spinlock.

Reviewed by: deischen

style(9)

Reviewed by: bde

Don't declare the malloc lock; use the declaration provided in libc.

Noticed by: bde

Add pthread_atfork() source code. Dan forgot to commit this file.

Add an implementation for pthread_atfork().

Aside from the POSIX requirements for pthread_atfork(), when
fork()ing, take the malloc lock to keep malloc state consistent
in the child.

Reviewed by: davidxu

Add the ability to reinitialize libpthread's internal FIFO-queueing
locks.

Reviewed by: davidxu

Add the ability to reinitialize a spinlock (libc/libpthread
internal lock, not a pthread spinlock).

Reviewed by: davidxu

s/foo()/foo(void)/

Add a blank line after a variable declaration.

Libpthread uses the convention that all of its (non-weak) symbols
begin with underscores and provide weak definitions without
underscores. Make the pthread spinlock conform to this convention.

Add the ability to reinitialize a mutex (internally, not a userland
API).

Reviewed by: davidxu

Use amd64_set_fsbase() instead of calling sysarch() directly.

This test relies on the concurrency level being 1; make it so.

Update context code for my last ABI breakage of mcontext. I'm worried
about the fpu code here. It should be using fxsave/fxrstor instead of
saving/restoring the control word. The SSE registers are used a lot in
gcc generated code on amd64. I'm not sure how this all fits together
though.

Don't forget to initialize the fake tcb when the kcb is allocated.

Reverse the order of the first two arguments to _sparc64_enter_uts().
The first argument is the UTS function, the second argument is the
first argument to the UTS function. Who's on first.

Convert a couple of hardcoded values to constants. Make thr_getcontext()
return 0 when called the first time, and return 1 when resumed by
thr_setcontext().

Add preliminary sparc64 support to libpthread. This does not
yet work, but hopefully someone familiar with the sparc64
port can pick up the reins.

Submitted by: jake
With mods by: deischen

Fix some comments for last commit.

Complete cancellation support for M:N threads, check cancelling flag when
thread state is changed from RUNNING to WAIT state and do some cancellation
operations for every cancellable state.

Reviewed by: deischen

Use thread lock instead of scheduler lock to eliminate lock contention
for all wrapped syscalls under SMP.

Reviewed by: deischen

Only generate code for _LCK_ASSERT if _LCK_DEBUG is defined.

When concurrency level is reduced and a kse is exiting, make sure no other
threads are still referencing the kse by migrating them to initial kse.

Reviewed by: deischen

Remove unused variable.

Relink libc_r.a, libc_r.so and libc_r_p.so from libthr to libkse.
On ia64, where there's no libc_r at all, libkse is now the default
thread library by virtue of these links.

The reasons for this change are:
1. libkse is slated to become the default thread library anyway,
2. active development and maintenance is only present for libkse,
3. GNOME and KDE, both in the process of being supported on ia64,
work better with KSE; even on ia64.

pthread API should return error code in return value not in errno.

Reviewed by: deischen

If syscall failed, restore old sigaction and return error to thread.

As comments in _mutex_lock_backout state, only current thread
can clear the pointer to mutex, not the thread doing mutex
handoff. Because _mutex_lock_backout does not hold scheduler
lock while testing THR_FLAGS_IN_SYNCQ and then reading mutex
pointer, it is possible mutex owner begin to unlock and
handoff the mutex to the current thread, and mutex pointer
will be cleared to NULL before current thread reading it, so
current thread will end up with deferencing a NULL pointer,
Fix the race by making mutex waiters to clear their mutex pointers.
While I am here, also save inherited priority in mutex for
PTHREAD_PRIO_INERIT mutex in mutex_trylock_common just like what
we did in mutex_lock_common.

Free thread name memory if there is.

Save and restore timeout field for signal frame just like what we did
for interrupted field.
Also in _thr_sig_handler, retrieve current signal mask from kernel not
from ucp, the later is pre-unioned mask, not current signal mask.

Fix FPU state restoring bug by jumping to right position.

Print waitset correctly.

Make KSE_STACKSIZE machine dependent by moving it from thr_kern.c to
pthread_md.h. This commit only moves the definition; it does not
change it for any of the platforms. This more easily allows 64-bit
architectures (in particular) to pick a slightly larger stack size.

_ia64_break_setcontext() now takes a mcontext_t. While here, define
THR_SETCONTEXT as PANIC(). The THR_SETCONTEXT macro is currently not
used, which means that the definition we had could be wrong, overly
pessimistic or unknowingly right. I don't like the odds...

The new _ia64_break_setcontext() and corresponding kernel fixes make
KSE mostly usable. There's still a case where we don't properly
restore a context and end up with a NaT consumption fault (typically
an indication for not handling NaT collection points correctly),
but at least now mutex_d works...

Stop using the setcontext() syscall to restore an async context.
Instead use the break instruction with an immediate specially
created for us.

pthread api should return error code in return value, not in errno.

Fix a typo. Also turn on PTHREAD_SCOPE_SYSTEM after fork().

Remove a comment that questioned why the size of the FPU
state for amd64 was twice as large as necessary. Peter
recently fixed this, so the comment no longer applies.

Also, since the size of struct mcontext changed, adjust
the threads library version of get&set context to match.

FYI, any change layout/size change to any arch's struct
mcontext will likely need some minor changes in libpthread.

Fix bogus comment and assign sigmask in critical region, use
SIG_CANTMASK to remove unmaskable signal masks.

Fix a bogus comment, sigmask must be maintained correctly,
it will be inherited in pthread_create.

1. Allocating and freeing lock related resource in _thr_alloc and _thr_free
to avoid potential memory leak, also fix a bug in pthread_create, contention
scope should be inherited when PTHREAD_INHERIT_SCHED is set, and also check
right field for PTHREAD_INHERIT_SCHED, scheduling inherit flag is in sched_inherit.
2. Execute hooks registered by atexit() on thread stack but not on scheduler
stack.
3. Simplify some code in _kse_single_thread by calling xxx_destroy functions.

Reviewed by: deischen

When invoking an old style signal handler, use true traditional BSD style to
invoke signal handler.

Reviewed by: deischen

Respect POSIX specification, a value return from pthread_attr_getguardsize
should be a value past to pthread_attr_setguardsize, not a rounded up value.
Also fix a stack size matching bug in thr_stack.c, now stack matching code
uses number of pages but not bytes length to match stack size, so for example,
size 512 bytes and size 513 bytes should both match 1 page stack size.

Reviewed by: deischen

Avoid garbage bits in c_flags by direct assigning value.

Reviewed by: deischen

If user is seting scope process flag, clear PTHREAD_SCOPE_SYSTEM bit
accordingly.

Reviewed by: deischen

Check invalid parameter and return EINVAL.

Reviewed by: deischen

Original pthread_once code has memory leak if pthread_once_t is used in
a shared library or any other dyanmic allocated data block, once
pthread_once_t is initialized, a mutex is allocated, if we unload the
shared library or free those data block, then there is no way to deallocate
the mutex, result is memory leak.
To fix this problem, we don't use mutex field in pthread_once_t, instead,
we use its state field and an internal mutex and conditional variable in
libkse to do any synchronization, we introduce a third state IN_PROGRESS to
wait if another thread is already in invoking init_routine().
Also while I am here, make pthread_once() conformed to pthread cancellation
point specification.

Reviewed by: deischen

Add code to support pthread spin lock.

Reviewed by: deischen

Add small piece of code to support pthread_rwlock_timedrdlock and
pthread_rwlock_timedrwlock.

The caller is expected to set up PIC register corectly before
jumping to .cerror. This means .cerror has to be present in the
same module with its consumers, or bad things will happen.

Add code to support barrier synchronous object and implement
pthread_mutex_timedlock().

Reviewed by: deischen

Remove repeated macro THR_IN_CONDQ.

Allow hooks registered by atexit() to run with current thread pointer set,
without this change, my atexit test dumps core.

Don't assume sizeof(long) = sizeof(int) on x86; use int
instead of long types for low-level locks.

Add prototypes for some internal libc functions that are
wrapped by the library as cancellation points.

Add memory barriers to alpha atomic swap functions (submitted
by davidxu).

Requested by: bde

Move kse_wakeup_multi call to just before KSE_SCHED_UNLOCK.

Tested on: SMP

Rethink the way thr_libc.So is generated. Relying on GCC to extract
only needed symbols from libc_pic is not working on sparc64.

Requested by: jake

Allow the concurrency level to be reduced.

Reviewed by: davidxu

Repost masked signal to kernel for scope system thread, it hardly happens
in real world.

Reviewed by: deischen

_thr_sig_check_pending is also called by scope system thread when it leaves
critical region, we wrap some syscalls for thread cancellation point, and
when syscalls returns, we call _thr_leave_cancellation_point, at the time
if a signal comes in, it would be buffered, and when the thread leaves
_thr_leave_cancellation_point, buffered signals will be processed, to avoid
messing up normal syscall errno, we should save and restore errno around
signal handling code.

Add back a loop for up to PTHREAD_DESTRUCTOR_ITERATIONS to
destroy thread-specific data. Display a warning when thread
specific data remains after PTHREAD_DESTRUCTOR_ITERATIONS.

Reviewed by: davidxu

Support printing 64 bits pointer and long integer.

Reviewed by: deischen

Save and restore errno around sigprocmask.

Direct call exit if thread was never created. This makes it safe to call
pthread_exit in main() without creating any thread.

Tessted by: deischen

Treat initial thread as scope system thread when KSE mode is not activated
yet, so we can protect some locking code from being interrupted by signal
handling. When KSE mode is turned on, reset the thread flag to scope process
except we are running in 1:1 mode which we needn't turn it off.
Also remove some unused member variables in structure kse.

Tested by: deischen

If threaded mode is not turned on yet, direct call __sys_sched_yield.

Keep initial kse and kse group just like we keep initial thread,
Don't free them, so some code can still reference them.

Reviewed by: deischen

Access user provided pointer out of lock, and also check the case when
a key is less than 0.

Don't run verify directly as that would require the perl script to
have execute permissions. Run "perl verify" instead. Replace all
occurences of the hardcoding of ./verify with $(VERIFY) to allow
it to be overridden as well.

Always set tcb for bound thread, and switch tcb for M:N thread at correct
time.

Don't forget to set kcb_self.

Correctly set current tcb. This fixes some IA64/KSE problems.

Reviewed by: deischen, julian

Add some quick pathes to exit process when signal action is default and
signal can causes process to exit.

Reviewed by: deischen

Initialize rtld lock just before turning on thread mode and
uninitialize rtld lock after thread mode shutdown.

If thread mode is not activated yet, just call __sys_fork() directly,
otherwise masks all signals until fork() returns, in child process,
we reset library state before restoring signal masks until we reach
a safe to point.

Reviewed by: deischen

Tweak rtld lock to allow recursive on reader lock and detect recursive
on writer lock. This is first cut at rwlock for rtld.

Submitted by: desichen

If thread mode is not activated yet, don't do extra work.

Reviewed by: deischen

o Add code to GC freed KSEs and KSE groups
o Fix a bug in kse_free_unlocked(), kcb_dtor shouldn't be called because
the KSE is cached and will be resued in _kse_alloc().

Reviewed by: deischen

Allow gcc driver to process -r option iself, do not use -Wl,-r to
bypass it. Doing otherwise did not allow compiler to detect and disable
conflicting options generated from specs.

Reported by: jake

Grok async contexts. When a thread is interrupted and an upcall
happens, the context of the interrupted thread is exported to
userland. Unlike most contexts, it will be an async context and
we cannot easily use our existing functions to set such a
context.
To avoid a lot of complexity that may possibly interfere with
the common case, we simply let the kernel deal with it. However,
we don't use the EPC based syscall path to invoke setcontext(2).
No, we use the break-based syscall path. That way the trapframe
will be compatible with the context we're trying to restore and
we save the kernel a lot of trouble. The kind of trouble we did
not want to go though ourselves...

However, we also need to set the threads mailbox and there's no
syscall to help us out. To avoid creating a new syscall, we use
the context itself to pass the information to the kernel so that
the kernel can update the mailbox. This involves setting a flag
(_MC_FLAGS_KSE_SET_MBOX) and setting ifa (the address) and isr
(the value).

Fix a typo. s/Line/Like/

Avoid a level of indirection to get from the thread pointer to the
TCB. We know that the thread pointer points to &tcb->tcb_tp, so all
we have to do is subtract offsetof(struct tcb, tcb_tp) from the
thread pointer to get to the TCB. Any reasonably smart compiler will
translate accesses to fields in the TCB as negative offsets from TP.

In _tcb_set() make sure the fake TCB gets a pointer to the current
KCB, just like any other TCB. This fixes a NULL-pointer dereference
in _thr_ref_add() when it tried to get the current KSE.

Don't call kse_set_curthread() when scheduling a new bound
thread. It should only be called by the current kse and
never by a KSE on behalf of another.

Submitted by: davidxu

Fix an off by one error in the number of arguments passed to
makecontext(). We only supply 3, not 4. This is mostly harmless,
except that on ia64 the garbage can include NaT bits, resulting
in NaT consumption faults.

Define the static TLS as an array of long double. This will guarantee
that the TLS is 16-byte aligned, as well as guarantee that the thread
pointer is 16-byte aligned as it points to struct ia64_tp. Likewise,
struct tcb and struct ksd are also guaranteed to be 16-byte aligned
(if they weren't already).

Use auto LDT allocation for i386.

Rethink the MD interfaces for libpthread to account for
archs that can (or are required to) have per-thread registers.

Tested on i386, amd64; marcel is testing on ia64 and will
have some follow-up commits.

Reviewed by: davidxu

Define THR_GETCONTEXT and THR_SETCONTEXT in terms of the userland
context functions. We don't need to enter the kernel anymore. The
contexts are compatible (ie a context created by getcontext() can
be restored by _ia64_restore_context()).

While here, make the use of THR_ALIGNBYTES and THR_ALIGN a no-op.
They are going to be removed anyway.

o In _ia64_save_context() clear the return registers except for r8.
We write 1 for r8 in the context so that _ia64_restore_context()
will return with a non-zero value. _ia64_save_context() always
return 0.
o In _ia64_restore_context(), don't restore the thread pointer. It
is not normally part of the context. Also, restore the return
registers. We get called for contexts created by getcontext(),
which means we have to restore all the syscall return values.

-15 is incorrect to be used to align stack to 16 bytes, use ~15 instead.

Take the same approach for i386 as that for ia64 and amd64. Use
the userland version of [gs]etcontext to switch between a thread
and the UTS scheduler (and back again). This also fixes a bug
in i386 _thr_setcontext() which wasn't properly restoring the
context.

Reviewed by: davidxu

Fix some typos, correctly jump into UTS.

sysctlbyname needs size_t type, not int.

Don't forget to unlock the scheduler lock. Somehow this got removed
from one of my last commits. This only affected priority ceiling
mutexes.

Pointy hat to: deischen

Simplify sigwait code a bit by using a waitset and removing oldsigmask.

Reviewed by: deischen

Fix typo.

Move idle kse wakeup to outside of regions where locks are held.
This eliminates ping-ponging of locks, where the idle KSE wakes
up only to find the lock it needs is being held. This gives
little or no gain to M:N mode but greatly speeds up 1:1 mode.

Reviewed & Tested by: davidxu

Add missing arguments to _amd64_restore_context() when called from
THR_SETCONTEXT().

Override libc function raise(), in threading mode, raise() will
send signal to current thread.

Reviewed by: deischen

Add some very beta amd64 bits. These will also need some tweaking.

Cleanup thread accounting. Don't reset a threads timeslice
when it blocks; it only gets reset when it yields.

Properly set a thread's default stack guardsize.

Reviewed by: davidxu

Add a preemption point when a mutex or condition variable is
handed-off/signaled to a higher priority thread. Note that when
there are idle KSEs that could run the higher priority thread,
we still add the preemption point because it seems to take the
kernel a while to schedule an idle KSE. The drawbacks are that
threads will be swapped more often between CPUs (KSEs) and
that there will be an extra userland context switch (the idle
KSE is still woken and will probably resume the preempted
thread). We'll revisit this if and when idle CPU/KSE wakeup
times improve.

Inspired by: Petri Helenius <pete@he.iki.fi>
Reviewed by: davidxu

o Eliminate upcall for PTHREAD_SYSTEM_SCOPE thread, now it
is system bound thread and when it is blocked, no upcall is generated.

o Add ability to libkse to allow it run in pure 1:1 threading mode,
defining SYSTEM_SCOPE_ONLY in Makefile can turn on this option.

o Eliminate code for installing dummy signal handler for sigwait call.

o Add hash table to find thread.

Reviewed by: deischen

Don't resume sigwait thread If signal is masked.

POSIX says if a thread is in sigwait state, although a signal may not in
its waitset, but if the signal is not masked by the thread, the signal
can interrupt the thread and signal action can be invoked by the thread,
sigwait should return with errno set to EINTR.
Also save and restore thread internal state(timeout and interrupted)
around signal handler invoking.

Restore signal mask correctly after fork().

Save and restore thread's error code around signal handling.

Reviewed by: deischen

Correctly print signal mask, the bug was introduced by cut and paste
in last commit.

Add a newline to debug message.

Avoid accessing user provided parameters in critical region.

Reviewed by: deischen

Print thread's scope, also print signal mask for every thread and print
it in one line.

Correctly lock/unlock signal lock. I must be in bad state, need to sleep.

Always check and restore sigaction previously set, also access user parameter
outside of lock.

If select() is only used for sleep, convert it to nanosleep,
it only need purely wait in user space.

Check if thread is in critical region, only testing check_pending
is not enough.

Style.

Take thr_support.c out of SRCS so that it does not end up in libraries.
Record the missing dependency of thr_libc.So on the libc_pic.a library.

OK'ed by: kan

Set unlock_mutex to 1 after locked mutex.
Use THR_CONDQ_CLEAR not THR_COND_SET in cond_queue_deq, current
cond_queue_deq is not used.

Fix typo.

Unbreak "make checkdpadd".

Axe AINC.

Submitted by: bde

Because there are only _SIG_MAXSIG elements in thread siginfo array,
use [signal number - 1] as subscript to access the array.

Remove surplus unlocking code I accidentally checked in. This won't be
triggered until LDT entry is exhausted.

o Use a daemon thread to monitor signal events in kernel, if pending
signals were changed in kernel, it will retrieve the pending set and
try to find a thread to dispatch the signal. The dispatching process
can be rolled back if the signal is no longer in kernel.

o Create two functions _thr_signal_init() and _thr_signal_deinit(),
all signal action settings are retrieved from kernel when threading
mode is turned on, after a fork(), child process will reset them to
user settings by calling _thr_signal_deinit(). when threading mode
is not turned on, all signal operations are direct past to kernel.

o When a thread generated a synchoronous signals and its context returned
from completed list, UTS will retrieve the signal from its mailbox and try
to deliver the signal to thread.

o Context signal mask is now only used when delivering signals, thread's
current signal mask is always the one in pthread structure.

o Remove have_signals field in pthread structure, replace it with
psf_valid in pthread_signal_frame. when psf_valid is true, in context
switch time, thread will backout itself from some mutex/condition
internal queues, then begin to process signals. when a thread is not
at blocked state and running, check_pending indicates there are signals
for the thread, after preempted and then resumed time, UTS will try to
deliver signals to the thread.

o At signal delivering time, not only pending signals in thread will be
scanned, process's pending signals will be scanned too.

o Change sigwait code a bit, remove field sigwait in pthread_wait_data,
replace it with oldsigmask in pthread structure, when a thread calls
sigwait(), its current signal mask is backuped to oldsigmask, and waitset
is copied to its signal mask and when the thread gets a signal in the
waitset range, its current signal mask is restored from oldsigmask,
these are done in atomic fashion.

o Two additional POSIX APIs are implemented, sigwaitinfo() and sigtimedwait().

o Signal code locking is better than previous, there is fewer race conditions.

o Temporary disable most of code in _kse_single_thread as it is not safe
after fork().

Use mmap retuned value.

Reviewed by: deischen

Temporary disable rwlock based code, replace it with low level KSE locking
code until rtld-elf and libkse can cooperate better, those code can be
restored.

Reviewed by: deischen

Write new thread pointer back only when success.

Reviewed by: deischen

After thread was interrupted by signal, it should relock mutex.

Reviewed by: deischen

if thread is exiting, just returns. kse_thr_interrupt interface
was changed, it needs signal parameter, pass -1 to it, it indicates to
interrupt syscall.

Reviewed by: deischen

Implement _ia64_save_context() and _ia64_restore_context(). Both
functions are derived from the swapctx() and restorectx() (resp)
from sys/ia64/ia64/context.s. The code is expected to be 99%
correct, but has not yet been tested.

Note that with these functions operating on mcontext_t, we also
created the foundation upon which we can implement getcontext(2)
and setcontext(2) replacements. It's not guaranteed that the use
of these syscalls and _ia64_{save|restore}_context() on the same
uicontext_t is actually going to work. Replacing the syscalls is
now trivially achieved.

This commit completes the ia64 port of libpthread itself (modulo
testing and bugfixes).

Implement _ia64_enter_uts(). The purpose of this function is to switch
the register stack and memory stack and call the function given to it.

While here, provide empty, non-working, stubs for the context functions
(_ia64_save_context() and _ia64_restore_context()) so that anyone can at
least compile libkse from CVS sources. Real implementations will follow
soon.

Implement _thr_enter_uts() and _thr_switch() as inline functions to
minimize the amount and complexity of assembly code that needs to be
written. This way the core functionality is spread over 3 elementary
functions that don't have to do anything that can more easily and
more safely be done in C. As such, assembly code will only have to
know about the definition of mcontext_t.
The runtime cost of not having these functions being inlined is less
important than the cleanliness and maintainability of the code at
this stage of the implementation.

Explicitly widen int types before casting to pointer types. On 64-bit
platforms the compiler warns about incompatible integer/pointer casts
and on ia64 this generally is bad news. We know that what we're doing
here is valid/correct, so suppress the warning. No functional change.

Sleeps better: marcel

Untangle the inter-dependency of kse types and ksd types/functions
by moving the definition of struct ksd to pthread_md.h and removing
the inclusion of ksd.h from thr_private.h (which has the definition
of struct kse and kse_critical_t). This allows ksd.h to have inline
functions that use struct kse and kse_critical_t and generally
yields a cleaner implementation at the cost of not having all ksd
related types/definitions in one header.

Implement the ksd functionality on ia64 by using inline functions
and permanently remove ksd.c from the ia64 specific makefile.

This change does not clean up the i386 specific version of ksd.h.

NOTE: The ksd code on ia64 abuses the tp register in the same way
as it is abused in libthr in that it is incompatible with the
runtime specification. This will be address when support for TLS
hits the tree.

Change the definition of _ksd_curkse, _ksd_curthread and
_ksd_readandclear_tmbx to be function-like. That way we
can define them as inline functions or create prototypes
for them.

This change allows the ksd interface on ia64 to be fully
inlined.

Define THR_{G|S}ETCONTEXT to expand to {g|s}etcontext(2).
Define THR_ALIGN to align at 16-byte boundaries.

Implement atomic_swap_{int|long|ptr}. Define atomic_swap_ptr as a
macro that expands to atomic_swap_long() to avoid compiler warnings
caused by incompatible pointer passing.

Move the machine specific files from sys/Makefile.inc and put them
in a machine specific makefile. While here, sort the sub-directories
in Makefile and remove _atomic_lock.S from all makefiles.

Don't lock scheduler lock twice.

After selecting a thread to handle a signal and taking
its scheduling lock, make sure that the thread still has
the signal unmasked.

Make a debug statement conditional on debugging being
enabled.

Insert threads at the end of the free thread list so that
the chance of getting the same thread id when allocating a
new thread is reduced. This won't work if the application
creates a new thread for every time a thread exits, but
we're still within the allowances of POSIX.

Provide a reference to __sys_write. The implementation uses this when
debugging is enabled so the symbol needs to be resolved before rtld
locking is enabled. I may not really know what I'm talking about,
but it works.

Submitted by: kan

Don't force -L/usr/lib. This is incorrect because we should not be
looking at the host environment for anything. This breaks building
-CURRENT on 4.x as well.

Submitted by: kan@

Only init _thread_sigact once, needn't init it again after a fork().

Obtained from: deischen

Despite whether threaded mode is turned on, always save thread's
signal mask.

KMF_DONE is now in /sys/sys/kse.h, no longer need to define it here.

Free memory of internal low level lock when mutex and condition variable
are destroyed.

Submitted by: tegge

Save THR_FLAGS_IN_TDLIST in signal frame, otherwise if a thread received
a signal will can not be removed from thread list after it exited.

Reviewed by: deischen
Approved by: re (jhb)

Attempt to eliminate PLT relocations from rwlock aquire/release
path, making them suitable for direct use by the dynamic loader.

Register libpthread-specific locking API with rtld on startup.

This still has some rough edges with signals which should be
addresses later.

Approved by: re (scottl)

Call the __sys_sigprocmask(the system call) when sigprocmask()
is called and the application is not threaded. This works around
a problem when an application that hasn't yet become threaded
tries to jump out of a signal handler.

Reported by: mbr
Approved by: re@ (rwatson)

Don't really spin on a spinlock; silently convert it to the same
low-level lock used by the libpthread implementation. In the
future, we'll eliminate spinlocks from libc but that will wait
until after 5.1-release.

Don't call an application signal handler if the handler is
the same as the library-installed handler. This seems to
be possible after a fork and is the cause of konsole hangs.

Approved by: re@ (jhb)

Change low-level locking a bit so that we can tell if
a lock is being waitied on.

Fix a races in join and cancellation.

When trying to wait on a CV and the library is not yet
threaded, make it threaded so that waiting actually works.

When trying to nanosleep() and we're not threaded, just
call the system call nanosleep instead of adding the thread
to the wait queue.

Clean up adding/removing new threads to the "all threads queue",
assigning them unique ids, and tracking how many active threads
there are. Do it all when the thread is added to the scheduling
queue instead of making pthread_create() know how to do it.

Fix a race where a thread could be marked for signal delivery
but it could be exited before we actually add the signal to it.

Other minor cleanups and bug fixes.

Submitted by: davidxu
Approved by: re@ (blanket for libpthread)

Eek, staticize a couple of functions that shouldn't
be external (initialize()!).

Remove cancellation points from _pthread_cond_wait and
_pthread_cond_timedwait (single underscore versions are
libc private functions). Point the weak reference(!) for
these functions to the versions with cancellation points.

Approved by: re@(blanket till 5/19)
Pointed out by: kan (cancellation point bug)

Add a method of yielding the current thread with the scheduler
lock held (_thr_sched_switch_unlocked()) and use this to avoid
dropping the scheduler lock and having the scheduler retake the
same lock again.

Add a better way of detecting if a low-level lock is in use.

When switching out a thread due to blocking in the UTS, don't
switch to the KSE's scheduler stack only to switch back to
another thread. If possible switch to the new thread directly
from the old thread and avoid the overhead of the extra
context switch.

Check for pending signals on a thread when entering the scheduler
and add them to the threads signal frame. This includes some
other minor signal fixes.

Most of this was a joint effor between davidxu and myself.

Reviewed by: davidxu
Approved by: re@ (blanket for libpthread)

Make pthread_join() async-cancel-safe. David was going to commit
this, but I think he's asleep and want to be sure it gets in before
the freeze.

Submitted by: davidxu

call dump_queues() only when DEBUG_THREAD_KERN is defined, save some
cpu cycles.

Protect against a race between granting a lock and accessing
other parts of the lock.

Submitted by: davidxu

Fix suspend and resume.

Submitted (in part) by: Kazuaki Oda <kaakun@highway.ne.jp>

Handle thread canceled case, it is same as signal caused backout,
but will break out of loop.

Move the mailbox to the beginning of the thread and align the
thread so that the context (SSE FPU state) is also aligned.

Call kse_wakeup_mutli() after remove current thread from RUNQ to avoid
doing unnecessary idle kse wakeup.

Call kse_wakeup_multi() to wakeup idle KSEs when there are threads ready
to run.

Create the thread signal lock as a KSE lock (as opposed to
a thread lock).

Better protect access to thread state while searching for
threads to handle a signal.

Better protect access to process pending signals while processing
a thread in sigwait().

Submitted by: davidxu

o Don't add a scope system thread's KSE to the list of available
KSEs when it's thread exits; allow the GC handler to do that.

o Make spinlock/spinlock critical regions.

The following were submitted by davidxu

o Alow thr_switch() to take a null mailbox argument.

o Better protect cancellation checks.

o Don't set KSE specific data when creating new KSEs; rely on the
first upcall of the KSE to set it.

o Add the ability to set the maximum concurrency level and do this
automatically. We should have a way to enable/disable this with
some sort of tunable because some applications may not want this
to be the default.

o Hold the scheduling lock across thread switch calls.

o If scheduling of a thread fails, make sure to remove it from the list
of active threads.

o Better protect accesses to a joining threads when the target thread is
exited and detached.

o Remove some macro definitions that are now provided by <sys/kse.h>.

o Don't leave the library in threaded mode if creation of the initial
KSE fails.

o Wakeup idle KSEs when there are threads ready to run.

o Maintain the number of threads active in the priority queue.

Use the correct link entry for walking the list of threads.

While I'm here, use the TAILQ_FOREACH macro instead of a more
manual method which was inherited from libc_r (so we could
remove elements from the list which isn't needed for libpthread).

Submitted by: Kazuaki Oda <kaakun@highway.ne.jp>

Remove the %gs restoring hack (already commented out).
Don't install man pages.

Temporarily (again) rename the library to libkse. It will be put back
to libpthread after more wide-spread testing.

Remove the i386-specific hack (well, we only run on i386 anyways)
to always set %gs when resuming a thread.

Install this library as libpthread instead of libkse.

Protect thread errno from being changed while operating
on behalf of the KSE.

Add a kse_reinit function to reinitialize a reused KSE.

Submitted by: davidxu

Set the quantum for scope system threads to 0 (no quantum).

Add a working pthread_[gs]etconcurrency. Initial null implementation
provided by Sergey A. Osokin <osa@freebsd.org.ru>.

In order to test this on a single CPU machine, you need to:

sysctl kern.threads.debug=1
sysctl kern.threads.virtual_cpu=2

Add a couple asserts to pthread_cond_foo to ensure the (low-level)
lock level is 0. Thus far, the threads implementation doesn't use
mutexes or condition variables so the lock level should be 0.

Save the return value when trying to schedule a new thread and
use this to return an error from pthread_create().

Change the max sleep time for an idle KSE to 1 minute from 2 minutes.

Maintain a count of the number of KSEs within a KSEG.

With these changes scope system threads seem to work, but heavy
use of them crash the kernel (supposedly VM bugs).

Add an i386-specifc hack to always set %gs. There still seems
to be instances where the kernel doesn't properly save and/or
restore it.

Use noupcall and nocompleted flags in the KSE mailbox. These
require kernel changes to work which will be committed sometime
later. Things still work without the changes.

Remove the general kse entry function and use two different
functions -- one for scope system threads and one for scope
process threads. The scope system function is not yet enabled
and we use the same function for all threads at the moment.

Keep a copy of the KSE stack for the case that a KSE runs
a scope system thread and uses the same stack as the thread
(no upcalls are generated, so a separate stack isn't needed).
This isn't enabled yet.

Use a separate field for the KSE waiting flag. It isn't
correct to use the mailbox flags field.

The following fixes were provided by David Xu:

o Initialize condition variable locks with thread versions
of the low-level locking functions instead of the kse versions.

o Enable threading before creating the first thread instead
of after.

o Don't enter critical regions when trying to malloc/free
or call functions that malloc/free.

o Take the scheduling lock when inheriting thread attributes.

o Check the attribute's stack pointer instead of the
attributes stack size for null when allocating a
thread's stack.

o Add a kseg reinit function so we don't have to destroy and
then recreate the same lock.

o Check the return value of kse_create() and return an
appropriate error if it fails.

o Don't forget to destroy a thread's locks when freeing it.

o Examine the correct flags word for checking to see if
a thread is in a synchronization queue.

Things should now work on an SMP kernel.

Remove duplicate $FreeBSD$ id.

Sorry folks; I accidentally committed a patch from what I was working
on a couple of days ago. This should be the most recent changes.

Noticed by: davidxu

Comment out the addition of -g to CFLAGS. This snuck in from
my local version.

Revamp libpthread so that it has a chance of working in an SMP
environment. This includes support for multiple KSEs and KSEGs.

The ability to create more than 1 KSE via pthread_setconcurrency()
is in the works as well as support for PTHREAD_SCOPE_SYSTEM threads.
Those should come shortly.

There are still some known issues which davidxu and I are working
on, but it'll make it easier for us by committing what we have.

This library now passes all of the ACE tests that libc_r passes
with the exception of one. It also seems to work OK with KDE
including konqueror, kwrite, etc. I haven't been able to get
mozilla to run due to lack of java plugin, so I'd be interested
to see how it works with that.

Reviewed by: davidxu

Add FIFO queueing locking operations based on atomic swap.

Modify thread errno for the new libpthread changes.

Reviewed by: davidxu

Add architecture dependent atomic ops (atomic_swap only), KSE specific
data, and userland versions of [gs]etcontext().

Modify the UTS entry and exit functions to account of FPU validity
and format.

- Define a _spinunlock() function so that threading implementations may do
more complicated things than just setting the lock to 0.
- Implement stubs for this function in libc and the two threading libraries
that are currently in the tree.

Backout last commit.
Requested by: jhb

Fix a bug in rwlock. When a rwlock was locked by reader threads, a
writter thread can block reader threads to get read lock.

Fix cut'n'paste error

Noticed by: julian

MFlibc_r: add and document pthread_attr_get_np() function.

Fix compiling error.

Insert threads interrupted by a signal while running onto the run queue.

Add signal logic to the build.

Deliver signals posted via an upcall to the appropriate thread.

Actually link in the attr_{set,get}stack.

Add pthread_attr_getstack() and pthread_attr_setstack().

Submitted by: Craig Rodrigues <rodrigc@attbi.com>

remove #ifdef _THREAD_SAFE

For now, build and install this as libkse instead of libpthread.
This will avoid any accidental use of an experimental library.

Suggested by: rwatson
Approved by: re (jhb)

Schedule spinlocked threads by moving them through the work queue, instead
of the wait queue.

Approved by: re (blanket)
Stolen from: davidxu

Get the wall clock time from the KSE mailbox, rather than doing another
syscall.

In _thread_enter_uts, fix eflags saving bug.
In _thread_switch, set current thread pointer in kse mailbox
only after all registers copied out of thread mailbox, kernel will do
upcall at trap time, if set current thread pointer before loading all
registers from thread mailbox, at trap time, the thread mailbox data
will be overwritten by kernel, result is junk data is loaded into CPU.

Fix idle timeout bug, use correct current time of day.

Adjust code for new mailbox format.

Reviewed by: deischen, mini

Schedule an idle context to block until timeouts expire without blocking
further upcalls.

Make pthread_sigmask(3) operate on the thread signal mask, not the process
signal mask.

Use KSE to schedule threads.

Add the 'restrict' type qualifier to the prototypes of `sigaction',
`sigprocmask', `sigaltstack', and `sigwait' as well as to the
prototypes of the apparantly unimplemented functions `sigtimedwait'
and `sigwaitinfo'. This complies with IEEE Std 1003.1-2001.

Zap now-unused SHLIB_MINOR

Make libpthread KSE aware.

Reviewed by: deischen, julian
Approved by: -arch

Mechanically change all libc_r references to libpthread.

Make the changes needed for libpthread to compile in its new home.
The new libpthread will provide POSIX threading support using KSE.
These files were previously repo-copied from src/lib/libc_r.

Reviewed by: deischen
Approved by: -arch

Remove much of the dereferencing of the fd table entries to look
at file flags and replace it with functions that will avoid null
pointer checks.

MFC to be done by archie ;-)

PR: 42100
Reviewed by: archie, robert
MFC after: 3 days

Make the libc_r version of select() set the readable or writable
file descriptor bit if poll() returns POLLERR, POLLHUP, or POLLNVAL.
Othewise, it's possible for select() to return successfully but
with no bits set.

Reviewed by: deischen
MFC after: 3 days
PR: bin/42175

When poll(2)'ing for readability or writability of a file descriptor
on behalf of a thread, we should check the POLLERR, POLLHUP, and
POLLNVAL flags as well to wake up the thread in these cases.

Suggested by: deischen
MFC after: 3 days

Replace various spelling with FALLTHROUGH which is lint()able

Oops, forgot to set the suspended flag for threads that are created
initially suspended. This was preventing such threads from getting
resumed.

Reported by: Bill Huey <billh@gnuppy.monkey.org>

Fix a couple of minor nits that prevented this from compiling.

Pointed out by: julian

Make sigpending and sigsuspend account for signals that are pending on
the process as well as pending on the current thread.

Reported by: Andrew MacIntyre <andymac@bullseye.apana.org.au>

Add a wrapper for pselect() in order to make it a cancellation point.

Prompted by: wollman

Missed in earlier commit -- I did cvs commit src/lib/libc. Oops.

Revamp suspend and resume. While I'm here add pthread_suspend_all_np()
and pthread_resume_all_np(). These suspend and resume all threads except
the current thread, respectively. The existing functions pthread_single_np()
and pthread_multi_np(), which formerly had no effect, now exhibit the same
behaviour and pthread_suspend_all_np() and pthread_resume_all_np(). These
functions have been added mostly for the native java port.

Don't allow the uthread kernel pipe to use the same descriptors as
stdio. Mostily submitted by Oswald Buddenhagen <ossi@kde.org>.

Correct some minor style nits.

Undo namespace pollution by prefixing the globals pthread_guard_default and
pthread_page_size.

Fix a bunch line wrapping.

Pointed out by: deischen

Don't use PAGE_SIZE in userland, instead use getpagesize(), this is to
allow running on other arches when the instructions are supported but
the page size granularity is not.

Glanced at by: peter

Use GCC's __attribute__ ((constructor)) mechanism to invoke the pthread
startup code rather than a static C++ object since c++ seems to be broken.

This doesn't seem to work for staticically linked program just yet, I'll
give that some more work when I get a chance.

Make these functions cancellation points like they should be:
poll(2), readv(2), select(2), wait4(2), writev(2).

PR: bin/37658
Reviewed by: deischen
MFC after: 1 week

Make sure calls to pthread_cancel() do not take effect if the target
thread is already exiting.

PR: bin/37614
Reviewed by: deischen
MFC after: 1 week

Usage style sweep: spell "usage" with a small 'u'.
Also change one case of blatant __progname abuse (several more remain)
This commit does not touch anything in src/{contrib,crypto,gnu}/.

The GCC developers have made good on their threats against #pragma for 3.1.
Use __weak_reference in place of the #pragma.

Submitted by: eischen

Sync SCM ID comments with libc.

Return correct number of total bits set in all fd_set's.
Change case of POLLNVAL as an error.
Remove POLLHUP and POLLERR from one case, their place is most likely
amongst read events.

PR: 33723
Submitted by: Alexander Litvin <archer@whichever.org>
Reviewed by: deischen [Provided a small change to the PR patch as well]
MFC after: 4 weeks

Do not use __progname directly (except in [gs]etprogname(3)).
Also, make an internal _getprogname() that is used only inside
libc. For libc, getprogname(3) is a weak symbol in case a
function of the same name is defined in userland.

Add the ability to recognize old references to keys, and return NULL
when old keys are referenced (after pthread_key_delete()) via
pthread_getspecific().

Fix the return code from pthread_rwlock_try[rw|rd]lock() functions;
these should return EBUSY when the calling thread would block.

MFC after: 2 weeks

Properly clear the status of a join operation if the joining thread is
canceled or the joinee is detached.

Don't rely on <sys/signal.h> to include <sys/ucontext.h>

Correct a typo pthread_attr_setscope() function fails unconditionally
due to.

PR: misc/30699
Reviewed by: jasone, ru
Approved by: jasone, ru
MFC after: 1 week

This has been sitting in my local tree long enough. Remove the use
of an alternate signal stack for handling signals. Let the kernel
send signals on the stack of the current thread and teach the threads
signal handler how to deliver signals to the current thread if it
needs to. Also, always store a threads context as a jmp_buf. Eventually
this will change to be a ucontext_t or mcontext_t.

Other small nits. Use struct pthread * instead of pthread_t in internal
library routines. The threads code wants struct pthread *, and pthread_t
doesn't necessarily have to be the same.

Reviewed by: jasone

Use the real function address (instead of function address + 8) for the
return address when modifying a jmp_buf to create a new thread context.
Also set t12 with the return address.

This should fix libc_r on alpha.

With much detective work by: Bernd Walter <ticso@cicely.de>

Fix the retrieval of USRSTACK via sysctl so that it works for 64-bit
archs. This should fix libc_r on alpha.

Submitted by: Bernd Walter <ticso@cicely9.cicely.de>

When cancelling a thread while in a join operation, do not detach
the target thread of the join operation. This allows the cancelled
thread to detach the target thread in its cancellation handler.
This bug was found by Butenhof's cancel_subcontract test.

Reviewed by: jasone

Pull the target thread of a join operation from the correct place
when cancelling a thread.

Fix pthread_join so that it works if the target thread exits while
the joining thread is in a signal handler.

Reported by: Loren James Rittle <rittle@labs.mot.com>
MFC after: 1 week

Make libc_r check the kern.usrstack sysctl instead of using internal
kernel #defines to figure out where the stack is located. This stops
libc_r from exploding when the kernel is compiled with a different
KVM size. IMHO this is all kinda bogus, it would be better to just
check %esp and work from that.

Style: sort __sys_foo() prototypes, tabs -> spaces, etc.

Removed:

- uthread_signal.c; libc_r does not wrap signal() since 1998/04/29.

- uthread_attr_setprio.c; it was never connected to the build, and
pthread_attr_setprio() does not exist in POSIX.

- uthread_sigblock.c and uthread_sigsetmask.c; these were no-ops
bloating libc_r's space.

pthread_private.h:

- Removed prototypes of non-syscalls: send().

- Removed prototypes of unused syscalls: sigpending(), sigsuspend(),
and select().

- Fixed prototype of fork().

- MFS: Fixed prototypes of <sys/socket.h> syscalls.

Reviewed by: deischen
Approved by: deischen, jasone

Compensate for "Compensate for header dethreading" by backing it out.

Limit maximum poll interval to 60 seconds. This prevents an overflow
from occurring when converting from a timeval/timespec to a timeout in
milliseconds.

Submitted by: dwmalone

Mark some functions as __printflike() and/or taking const char * arguments
instead of char *.

MFC after: 2 weeks

Fix logic errors in pthread_cond_wait() and pthread_cond_timedwait() that
could cause deadlock after interruption due to a signal.

Reviewed by: deischen

Fix a bug in canceling joining threads.
Do not detach canceled threads.

Reported by: Arno Klaassen <arno@heho.snv.jussieu.fr>
Collaboration with: deischen

Make the name parameter const char *.

Implement pthread_attr_[gs]etguardsize(). Non-default-size stacks used to
be malloc()ed, but they are now allocated using mmap(), just as the
default-size stacks are. A separate cache of stacks is kept for
non-default-size stacks.

Collaboration with: deischen

Clear the in thread scheduler flag after jumping to the start of
a signal handler from the scheduler.

MFC after: 1 week

Fix a race condition in pthread_join(). All of the following must occur
atomically:

1) Search _thread_list for the thread to join.
2) Search _dead_list for the thread to join.
3) Set the running thread as the joiner.

While we're at it, fix a race in the case where multiple threads try to
join on the same thread. POSIX says that the behavior of multiple joiners
is undefined, but the fix is cheap as a result of the other fix.

Add a test for PR 24345.

Update the verify script.

Don't define _REENTRANT, since the Makefile does so.

Fix a typo.

Instead of using a join queue for each thread, use a single pointer to
keep track of a joiner. POSIX only supports a single joiner, so this
simplification is acceptable.

At the same time, make sure to mark a joined thread as detached so that
its resources can be freed.

Reviewed by: deischen
PR: 24345

Condition variable waiters are queued in descending priority order, so
there is no need to wake all waiters to assure that the highest priority
thread is run. As the semaphore code is written, there was no correctness
problem, but the change improves sem_post() performance.

Pointed out by: deischen

Mark a thread that is suspended while sleeping as interrupted.

Properly copy the P_ALTSTACK flag in struct proc::p_flag to the child
process on fork(2).

It is the supposed behavior stated in the manpage of sigaction(2), and
Solaris, NetBSD and FreeBSD 3-STABLE correctly do so.

The previous fix against libc_r/uthread/uthread_fork.c fixed the
problem only for the programs linked with libc_r, so back it out and
fix fork(2) itself to help those not linked with libc_r as well.

PR: kern/26705
Submitted by: KUROSAWA Takahiro <fwkg7679@mb.infoweb.ne.jp>
Tested by: knu, GOTOU Yuuzou <gotoyuzo@notwork.org>,
and some other people
Not objected by: hackers
MFC in: 3 days

Move the check for a pending signals to after the thread has been
placed in any scheduling queue(s). The process of dispatching
signals to a thread can change its state which will attempt to add
or remove the thread from any scheduling queue to which it belongs.
This can break some assertions if the thread isn't in the queue(s)
implied by its state.

When adding dispatching a pending signal to a thread, be sure to
remove the signal from the threads set of pending signals.

PR: 27035
Tested by: brian
MFC in: 1 week

Compenate for header dethreading.

Typo; fix open() so that it is not a cancellation point when called
from libc.

Reinstall the alternate signal stack after a fork.

PR: 25110
Tested by: knu

Clean up a bit. Use the correct TAILQ link when walking the thread
lists to free thread resources after a fork (in the child). Also
remember to free the dead thread list.

To be consistent, use the __weak_reference macro from <sys/cdefs.h>
instead of #pragma weak to create weak definitions.

Suggested by: bde

Activate build of posix1e extensions in libc and libc_r that have been
moved in from libposix1e, and deactivate build of the soon-to-be-removed
libposix1e.

Approved by: rwatson
Obtained from: TrustedBSD Project

Add thread safety wrappers for the posix1e syscalls that deal with file
descriptors.

Approved by: rwatson
Obtained from: TrustedBSD Project

Add a leading underscore to the pthread_main_np function name, and
a "#pragma weak" directive linking the external symbol. This matches
the other pthread_* definitions, and ensures that users of this
function from within libc get the real version, not the stub.

Suggested by: deischen
Reviewed by: deischen, alfred

Bring in a hybrid of SunSoft's transport-independent RPC (TI-RPC) and
associated changes that had to happen to make this possible as well as
bugs fixed along the way.

Bring in required TLI library routines to support this.

Since we don't support TLI we've essentially copied what NetBSD
has done, adding a thin layer to emulate direct the TLI calls
into BSD socket calls.

This is mostly from Sun's tirpc release that was made in 1994,
however some fixes were backported from the 1999 release (supposedly
only made available after this porting effort was underway).

The submitter has agreed to continue on and bring us up to the
1999 release.

Several key features are introduced with this update:
Client calls are thread safe. (1999 code has server side thread
safe)
Updated, a more modern interface.

Many userland updates were done to bring the code up to par with
the recent RPC API.

There is an update to the pthreads library, a function
pthread_main_np() was added to emulate a function of Sun's threads
library.

While we're at it, bring in NetBSD's lockd, it's been far too
long of a wait.

New rpcbind(8) replaces portmap(8) (supporting communication over
an authenticated Unix-domain socket, and by default only allowing
set and unset requests over that channel). It's much more secure
than the old portmapper.

Umount(8), mountd(8), mount_nfs(8), nfsd(8) have also been upgraded
to support TI-RPC and to support IPV6.

Umount(8) is also fixed to unmount pathnames longer than 80 chars,
which are currently truncated by the Kernel statfs structure.

Submitted by: Martin Blapp <mb@imp.ch>
Manpage review: ru
Secure RPC implemented by: wpaul

Correct a race condition where it was possible for a signaled
thread to become stranded and not placed in the run queue.

MFC Candidate

Reported by: tegge

Really set the flags for a private mutex (used by libc/libc_r).

Limit threads clock resolution to no less than 1000usec (1000Hz).

PR: 25300
Submitted by: Tom Pavel <pavel@alum.mit.edu> (in part)

Remove (int) file descriptor locking. It should be up to the
application to provide locking for I/O operations. This doesn't
break any of my tests, but the old behavior can be restored by
compiling with _FDLOCKS_ENABLED. This will eventually be removed
when it is obvious it does not cause any problems.

Remove most of flockfile implementation, with the exception of
flockfile_debug.

Make error messages more informational (submitted by Mike Heffner
<spock@techfour.net>, who's now known as mikeh@FreeBSD.org).

s/_thread_sys_write/__sys_write/

Submitted by: Mike Heffner <mheffner@vt.edu>

Unbreak world by correctly specifying the prototype for __sys_aio_suspend.
A make buildworld was done but not with the committed pthread_private.h.

Reported by: Manfred Antar <null@pozo.com>

_exit in libc is now __sys_exit not __sys__exit.

Add another check for thread library initialization (jdp, we
really need a way to get _thread_init called at program start
before any constructors are run).

-pthread -> -lc_r

Add weak definitions for wrapped system calls. In general:

_foo - wrapped system call
foo - weak definition to _foo

and for cancellation points:

_foo - wrapped system call
__foo - enter cancellation point, call _foo(), leave
cancellation point
foo - weak definition to __foo

Change use of global _thread_run to call a function to get the
currently running thread.

Make all pthread_foo functions weak definitions to _pthread_foo,
where _pthread_foo is the implementation. This allows an application
to provide its own pthread functions.

Provide slightly different versions of pthread_mutex_lock and
pthread_mutex_init so that we can tell the difference between
a libc mutex and an application mutex. Threads holding mutexes
internal to libc should never be allowed to exit, call signal
handlers, or cancel.

Approved by: -arch

Force strong references to several pthread_* functions which are weakly
referenced to by libgcc.a.

This is needed when linking statically as SVR4 (ie, ELF) behavior is to only
link in a module if it satisfies an undefined strong reference from somewhere.
(this surprises a lot of people) Things are different when using shared libs,
the entire library and its modules and their symbols are available at run-time
(when the weak reference is seen to still be unsatisfied and is satisfied on
the spot), this is not the case with static libs.

Thus one can have a static binary with unresolved week references, and at
run-time dereference a NULL pointer.

Submitted by: eischen

When retrieving the time of day in nanosleep(), store it in the
global time of day. This costs us nothing, but is a bit of a hack
to work around a process blocking and not having the time updated
by an ITIMER_PROF signal.

PR: 23679

Enable check for pending signals after calling a signal handler.
Restoration of a threads signal mask after invocation of a signal
handler may allow pending signals to become deliverable.

PR: 23647

Change a "while {}" loop to a "do {} while" to allow it to be
executed at least once, fixing pthread_mutex_lock() for recursive
mutex lock attempts.

Correctly set a threads signal mask while it is executing a signal
handler. The mask should be the union of its current mask, the
signal being handled, and the mask from the signal action.

Reported by: Dan Nelson <dnelson@emsphone.com>

MFC Candidate

Fix MD macros to work for alpha. Without this fix, threads under alpha
seem to be totally broke.

MFC Candidate

Submitted by: gallatin

Fix a bug where a statically initialized condition variable
was not getting properly initialized in pthread_cond_signal()
and pthread_cond_broadcast(). Reportedly, this can cause
an application to die.

MFC candidate

Submitted by: ade

Delete 4 lines of misleading/incorrect comments.

When entering the scheduler from the signal handler, tell
the kernel to (re)use the alternate signal stack. In this
case, we don't return normally from the signal handler,
so the kernel still thinks we are using the signal stack.
The fixes a nasty bug where the signal handler can start
fiddling with the stack of a thread while the handler is
actually running on the same stack.

MFC candidate

Bump the shared lib version. There seems to have been an incompatible
change committed to RELENG_4 where a bump there is now necessary.
We've got to go before RELENG_4 does.

Correct the logic for checking the emptiness of the waiting queue.
This fixes a potential problem where the file descriptors would not
be polled causing waiting threads to stay waiting. Doh!

MFC candidate.

Don't needlessly poll file descriptors when there are no
file descriptors needing to be polled (Doh!). Reported
by Dan Nelson <dnelson@emsphone.com>.

Don't install and start the scheduling timer until the
first thread is created. This prevents the overhead of
having a periodic scheduling signal in a single threaded
program. Reported by Dan Nelson <dnelson@emsphone.com>.

Allow builtin longjmps out of application installed
signal handlers without the need perform any post-handler
cleanup:

o Change signal handling to save the threads interrupted
context on the stack. The threads current context is
now always stored in the same place (in the pthread).
If and when a signal handler returns, the interrupted
context is copied back to the storage area in the pthread.

o Before calling invoking a signal handler for a thread,
back the thread out of any internal waiting queues
(mutex, CV, join, etc) to which it belongs.

Rework uthread_info.c a bit to make it easier to change
the format of a thread dump.

Use an alternal signal stack for the thread library's
signal handler. This allows us to fiddle with the main
threads stack without fear of it being in use.

Reviewed by: jasone

At the beginning of pthread_mutex_lock(), call _thread_init() if
necessary. This works around a bug in old versions of libgcc_r.a
which are statically linked into old executables.

Make pthread_kill() know about temporary signal handlers installed
by sigwait(). This prevents a signal from being sent to the process
when there are no application installed signal handlers.

Correct a typo in sigwait (foo -> foo[i]).

We use ___setjmp (non-signal saving) to setup a signal frame. When
adding a signal frame to a thread, be sure to label the context
correctly so we don't restore an uninitialized process mask.

Reported by: kimc@W8HD.ORG and Andrey Rouskol <anry@sovintel.ru>

Try and get libc_r to compile again on the alpha after deischen's commit

#include <sys/types.h>

Enable _PTHREADS_INVARIANTS until the recent libc_r changes are
shaken out.

Implement zero system call thread switching. Performance of
thread switches should be on par with that under scheduler
activations.

o Timing is achieved through the use of a fixed interval
timer (ITIMER_PROF) to count scheduling ticks instead
of retrieving the time-of-day upon every thread switch
and calculating elapsed real time.

o Polling for I/O readiness is performed once for each
scheduling tick instead of every thread switch.

o The non-signal saving/restoring versions of setjmp/longjmp
are used to save and restore thread contexts. This may
allow the removal of _THREAD_SAFE macros from setjmp()
and longjmp() - needs more investigation.

Change signal handling so that signals are handled in the
context of the thread that is receiving the signal. When
signals are dispatched to a thread, a special signal handling
frame is created on top of the target threads stack. The
frame contains the threads saved state information and a new
context in which the thread can run. The applications signal
handler is invoked through a wrapper routine that knows how
to restore the threads saved state and unwind to previous
frames.

Fix interruption of threads due to signals. Some states
were being improperly interrupted while other states were
not being interrupted. This should fix several PRs.

Signal handlers, which are invoked as a result of a process
signal (not by pthread_kill()), are now called with the
code (or siginfo_t if SA_SIGINFO was set in sa_flags) and
sigcontext_t as received from the process signal handler.

Modify the search for a thread to which a signal is delivered.
The search algorithm is now:

o First thread found in sigwait() with signal in wait mask.
o First thread found sigsuspend()'d on the signal.
o Current thread if signal is unmasked.
o First thread found with signal unmasked.

Collapse machine dependent support into macros defined in
pthread_private.h. These should probably eventually be moved
into separate MD files.

Change the range of settable priorities to be compliant with
POSIX (0-31). The threads library uses higher priorities
internally for real-time threads (not yet implemented) and
threads executing signal handlers. Real-time threads and
threads running signal handlers add 64 and 32, respectively,
to a threads base priority.

Some other small changes and cleanups.

PR: 17757 18559 21943
Reviewed by: jasone

Add thread-safe wrapper for fpathconf(2) syscall.

Reviewed by: jlemon

The second call to _thread_kern_sig_defer() in sem_post() should be a call
to _thread_kern_sig_undefer().

Fix an off-by-one error in the recursive mutex handling that made it
prematurely release recursive mutexes.

Test case provided by: Bradley T. Hughes <bhughes@trolltech.com>
Reviewed by: deischen

Add wrapper for kevent() syscall

Noted as missing by: nicolas.leonard@animaths.com

Make sem_post() safe to call from within a signal handler, as required by
POSIX/SUSv2.

Call _thread_init() from pthread_once() if it has not already been called.
This fixes a segfault in some C++ programs which use exceptions before
main() has been called (i.e. from global constructors).

Reviewed by: deischen

Change my email address in the copyright notices for the sake of consistency
(jasone@canonware.com --> jasone@freebsd.org).

Deal correctly with statically initialized condition variables in
pthread_cond_signal(), pthread_cond_broadcast(), and pthread_cond_timedwait().

Do not dump core in pthread_cond_timedwait() (due to a NULL pointer
dereference) if attempting to wait on an uninitialized condition variable.

PR: bin/18099

Remove DEBUG_FLAGS=-g3, which never should have been committed.

If multiple threads are blocked in sigwait() for the same signal that does
not have a user-supplied signal handler, when a signal is delivered, one
thread will receive the signal, and then the code reverts to having no
signal handler for the signal. This can leave the other sigwait()ing
threads stranded permanently if the signal is later ignored, or can result
in process termination when the process should have delivered the signal to
one of the threads in sigwait().

To fix this problem, maintain a count of sigwait()ers for each signal that
has no default signal handler. Use the count to correctly install/uninstall
dummy signal handlers.

Reviewed by: deischen

pthread_mutex_lock(), pthread_cond_trywait(), and pthread_cond_wait() are
not allowed to return EINTR, but use of pthread_suspend_np() could cause
EINTR to be returned. To fix this, restructure pthread_suspend_np() so that
it does not interrupt a thread that is waiting on a mutex or condition, and
keep enough state around that pthread_resume_np() can fix things up
afterwards.

Reviewed by: deischen

Back out the previous change to the queue(3) interface.
It was not discussed and should probably not happen.

Requested by: msmith and others

Change the way that the queue(3) structures are declared; don't assume that
the type argument to *_HEAD and *_ENTRY is a struct.

Suggested by: phk
Reviewed by: phk
Approved by: mdodd

Fix a memory leak. pthread_set_name_np() allocates space for a name, but
was not deallocating space for the previous name, if any.

PR: misc/18504

Fixed missing consts for function parameters, so that the code matches
the man page and POSIX.1. Fixed nearby misformatting. Fixed a missing
prototype.

Add missing man pages. Fix various compliance bugs, mostly having to do with
error return values. Implement pthread_mutexattr_gettype().

PR: docs/16537, docs/17538

Add a wrapper for the sendfile() system call.

PR: bin/17366

Add test to detect propagation of cancellation points within libc_r.

Automated regression test harness for libc_r. Existing tests are integrated,
a new test for POSIX semaphores was added, and examples of harness usage are
included.

Explicitly include sys/cdefs.h to get the definition of __strong_reference(),
rather than getting lucky due to header dependencies.

Fix pthread_suspend_np/pthread_resume_np. For the record, suspending a
thread waiting on an event (I/O, condvar, etc) will, when resumed using
pthread_resume_np, return with EINTR. For example, suspending and resuming
a thread blocked on read() will not requeue the thread for the read, but
will return -1 with errno = EINTR. If the suspended thread is in a critical
region, the thread is suspended as soon as it leaves the critical region.

Fix a bogon in pthread_kill() where a signal was being delivered twice
to threads waiting in sigwait().

Reported by (suspend/resume bug): jdp
Reviewed by: jasone

For errors, return -1 and set errno to indicate the error type, rather than
returning the error directly.

For sem_post(), make sure that the correct thread is woken up. This has
unfortunate performance implications, but is necessary for POSIX compliance.

Approved by: jkh

Use __strong_reference() instead of __weak_reference() to assure that the
weak symbols of the same name are not used.

Use _fcntl() (not fcntl()) inside of fcntl().

Reported by: green

Simplify sytem call renaming. Instead of _foo() <-- _libc_foo <-- foo(),
just use _foo() <-- foo(). In the case of a libpthread that doesn't do
call conversion (such as linuxthreads and our upcoming libpthread), this
is adequate. In the case of libc_r, we still need three names, which are
now _thread_sys_foo() <-- _foo() <-- foo().

Convert all internal libc usage of: aio_suspend(), close(), fsync(), msync(),
nanosleep(), open(), fcntl(), read(), and write() to _foo() instead of foo().

Remove all internal libc usage of: creat(), pause(), sleep(), system(),
tcdrain(), wait(), and waitpid().

Make thread cancellation fully POSIX-compliant.

Suggested by: deischen

Fix millisecond to nanosecond conversion.

PR: misc/16245

Minor *jmp() cleanups.

Add sem_*() functions. Named semaphores and process-shared semaphores
are not supported by this implementation, and the error return values
from sem_init(), sem_open(), sem_close(), and sem_unlink() reflect this.

Approved by: jkh

Do signal deferral for pthread_kill() as it was done in the old days.

Submitted by: deischen

Implement continuations to correctly handle [sig|_]longjmp() inside of a
signal handler. Explicitly check for jumps to anywhere other than the
current stack, since such jumps are undefined according to POSIX.

While we're at it, convert thread cancellation to use continuations, since
it's cleaner than the original cancellation code.

Avoid delivering a signal to a thread twice. This was a pre-existing bug,
but was likely unexposed until these other changes were made.

Defer signals generated by pthread_kill() so that they can be delivered on
the appropriate stack. deischen claims that this is unnecessary, which is
likely true, but without this change, pthread_kill() can cause undefined
priority queue states and/or PANICs in [sig|_]longjmp(), so I'm leaving
this in for now. To compile this code out and exercise the bug, define
the _NO_UNDISPATCH cpp macro. Defining _PTHREADS_INVARIANTS as well will
cause earlier crashes.

PR: kern/14685
Collaboration with: deischen

Properly initialize the last active time of the initial thread. This fixes
the case that a CPU hungry main thread is prevented from being preempted
due to a negative calculation of its time slice.

Reported by: Alexander Litvin <archer@lucky.net>

Track libc's three-tier symbol naming. libc_r must currently implement
the _libc_*() entry points and add *() weak aliases. This will all
change for the better when libc_r becomes libpthread.

Make sched_param parameter a const to comply with POSIX and SUSv2 specs.
This doesn't need to be applied to stable, because somehow -stable seems
to have gotten it right.

Reviewed by: jasone

Don't explicitly mmap() red zones at the bottom of thread stacks (except
the initial thread). Instead, just leave an unmapped gap between thread
stacks and make sure that the thread stacks won't grow into these gaps,
simply by limiting the size of the stacks with the 'len' argument to
mmap(). This (if I understand correctly) reduces VM overhead
considerably.

Reviewed by: deischen

-Wall and minor style(9) cleanups.

Change stack allocation algorithm to make better use of memory
(it was leaving an unused block). Also protect the global stack
pointer from context changes while fiddling with it.

Don't wakeup threads when there is a process signal and no installed
handler. Thread-to-thread signals (pthread_signal) are treated differently
than process signals; a pthread_signal can wakeup a blocked thread if
a signal handler is not installed for that signal.

Found by: ACE tests

Fix some minor POSIX/SUSv2 compliance nits.

PR: kern/11982

Fix problems with cancellation while in critical regions.

o Cancellation flags were not getting properly set/cleared.
o Loops waiting for internal locks were not being exited
correctly by a cancelled thread.
o Minor spelling (cancelation -> cancellation) and formatting
corrections (missing tab).

Found by: tg
Reviewed by: jasone

Fixes for signal handling:

o Don't call signal handlers with the signal handler access lock
held.
o Remove pending signals before calling signal handlers. If
pending signals were not removed prior to handling them,
invocation of the handler could cause the handler to be
called more than once for the same signal. Found by: JB
o When SIGCHLD arrives, wake up all threads in PS_WAIT_WAIT
(wait4).

PR: bin/15328
Reviewed by: jasone

Avoid an infinite loop if the last element of the iov array passed to
writev() has an iov_len of 0.

PR: bin/8281

Change signal handling to conform to POSIX specified semantics.
Before this change, a signal was delivered to each thread that
didn't have the signal masked. Signals also improperly woke up
threads waiting on I/O. With this change, signals are now
handled in the following way:

o If a thread is waiting in a sigwait for the signal,
then the thread is woken up.

o If no threads are sigwait'ing on the signal and a
thread is in a sigsuspend waiting for the signal,
then the thread is woken up.

o In the case that no threads are waiting or suspended
on the signal, then the signal is delivered to the
first thread we find that has the signal unmasked.

o If no threads are waiting or suspended on the signal,
and no threads have the signal unmasked, then the signal
is added to the process wide pending signal set. The
signal will be delivered to the first thread that unmasks
the signal.

If there is an installed signal handler, it is only invoked
if the chosen thread was not in a sigwait.

In the case that multiple threads are waiting or suspended
on a signal, or multiple threads have the signal unmasked,
we wake up/deliver the signal to the first thread we find.
The above rules still apply.

Reported by: Scott Hess <scott@avantgo.com>
Reviewed by: jb, jasone

* Fix the stack allocation code so that it works for alpha. Change it
to use mmap(..., MAP_STACK, ...) on alpha too since that should work
now.
* Add hooks to allow GDB to access the internals of pthreads without
having to know the exact layout of struct pthread.

Reviewed by: deischen

add pthread_cancel, obtained from OpenBSD.

eischen (Daniel Eischen) added wrappers to protect against cancled
threads orphaning internal resources.

the cancelability code is still a bit fuzzy but works for test
programs of my own, OpenBSD's and some examples from ORA's books.

add readdir_r to both libc and libc_r

add some 'const' attributes to function parameters

Reviewed by: eischen, jasone

Add sigsuspend.o and sigpending.o to HIDDEN_SYSCALLS as well.

Pointed out by: jdp

Add sigprocmask to HIDDEN_SYSCALLS. This renames the syscall to
_thread_sys_sisprocmask in libc_r. This solves the undefined symbol...

Reported by: Kenneth Wayne Culver

Add the proper headers so that the SIGNOTEMPTY and SIGSETAND
macros are defined.

sigset_t change (part 5 of 5)
-----------------------------

Most of the userland changes are in libc. For both the alpha
and the i386 setjmp has been changed to accomodate for the
new sigset_t. Internally, libc is mostly rewritten to use the
new syscalls. The exception is in compat-43/sigcompat.c

The POSIX thread library has also been rewritten to use the
new sigset_t. Except, that it currently only handles NSIG
signals instead of the maximum _SIG_MAXSIG. This should not
be a problem because current applications don't use any
signals higher than NSIG.

There are version bumps for the following libraries:
libdialog
libreadline
libc
libc_r
libedit
libftpio
libss

These libraries either a) have one of the modified structures
visible in the interface, or b) use sigset_t internally and
may cause breakage if new binaries are used against libraries
that don't have the sigset_t change. This not an immediate
issue, but will be as soon as applications start using the
new range to its fullest.

NOTE: libncurses already had an version bump and has not been
given one now.

NOTE: doscmd is a real casualty and has been disconnected for
the moment. Reconnection will eventually happen after
doscmd has been fixed. I'm aware that being the last one
to touch it, I'm automaticly promoted to being maintainer.
According to good taste this means that I will receive a
badge which either will be glued or mechanically stapled,
drilled or otherwise violently forced onto me :-)

NOTE: pcvt/vttest cannot be compiled with -traditional. The
change cause sys/types to be included along the way which
contains the const and volatile modifiers. I don't consider
this a solution, but more a workaround.

Fix a memory leak: free the thread-specific poll_data, used in the select()
implementation.

PR: 13368
Submitted by: Steve Bernacki, Jr. <steve@copacetic.net>

When checking for valid timevals in the wrapped select() and poll()
routines, don't return EINVAL but set errno to EINVAL and return -1.
Added a check in pthread_cond_timedwait for a null timespec pointer.

$Id$ -> $FreeBSD$

move sanity check of timeval struct so as not to segfault when passed
a null pointer.

Pointed out by: Thomas Gellekum <tg@ihf.rwth-aachen.de>
Reviewed by: eivind

When checking if there is a stack to free, observe the fact that it
might have been mmapped, and if so, passing the pointer to free() is
really not a good idea.

[ In the next millenium, when I've taken over the world, I'm going
to ban 8 character tabs. You've been warned. ]

time_to_sleep->tv_nsec > 1000000000
-to-
time_to_sleep->tv_nsec >= 1000000000

Sanity check time structures passed in, return EINVAL like the system
calls do to avoid corrupting the thread library's concept of wakeup
time.

PR: kern/12141
Reviewed by: deischen, eivind

handle under/overflow of time values in a more robust manner,
there may be an overflow that need to be adjusted more than once.

Pointed out by: Fabian Thylmann <fthylmann@stats.net>

Reviewed by: eivind, jb

Add check for runnable threads before polling file descriptors.

Submitted by: tegge

Add RCS IDs to those files without them.
Fix copyrights (s/REGENTS/AUTHOR).

Suggested by: tg
Approved by: jb

Fix thread initialization to allow for the case where stdio file
descriptors are not opened.

PR: bin/12853
Reviewed by: jb

Use USRSTACK (defined in <machine/vmparam.h>) to get top of the initial stack.
PTHREAD_STACK_TOP was wrong for all supported architectures.

Fix a couple more coding style nits.

Modify previous changes to conform better to libc_r's coding style.

Always use mmap() for default-size stack allocation. Use MAP_ANON instead
of MAP_STACK on the alpha architecture.

Reduce the amount of code executed while owning _gc_mutex during stack
allocation.

Always use growable thread stacks on the i386. The VM_STACK kernel option
must be made default for the alpha before growable thread stacks are
enabled for the alpha.

Disable growable stacks by default, as advertised.

Use growable stacks for thread stacks that are the default stack size.

Cache discarded default thread stacks for use in subsequent thread creations.

Create a red zone at the end of each stack (including the initial thread
stack), with the hope of causing a segfault if a stack overflows.

To activate these modifications, add -D_PTHREAD_GSTACK to CFLAGS in
src/lib/libc_r/Makefile. Since the modifications depend on the VM_STACK
kernel option, I'm not sure how to safely use growable stacks by default.

Testing, as well as algorithmic and stylistic comments are welcome.

Defer signals, so we will not wait for SIGCHLD after it was delivered.

Fix few warnings on the alpha.

Remove -DNOPOLL from the compilation flags now that there is a poll wrapper
in libc_r.

Bump the library version number (the scheduler now uses a poll syscall
instead of select).

In the words of the author:

o The polling mechanism for I/O readiness was changed from
select() to poll(). In additon, a wrapped version of poll()
is now provided.

o The wrapped select routine now converts each fd_set to a
poll array so that the thread scheduler doesn't have to
perform a bitwise search for selected fds each time file
descriptors are polled for I/O readiness.

o The thread scheduler was modified to use a new queue (_workq)
for threads that need work. Threads waiting for I/O readiness
and spinblocks are added to the work queue in addition to the
waiting queue. This reduces the time spent forming/searching
the array of file descriptors being polled.

o The waiting queue (_waitingq) is now maintained in order of
thread wakeup time. This allows the thread scheduler to
find the nearest wakeup time by looking at the first thread
in the queue instead of searching the entire queue.

o Removed file descriptor locking for select/poll routines. An
application should not rely on the threads library for providing
this locking; if necessary, the application should use mutexes
to protect selecting/polling of file descriptors.

o Retrieve and use the kernel clock rate/resolution at startup
instead of hardcoding the clock resolution to 10 msec (tested
with kernel running at 1000 HZ).

o All queues have been changed to use queue.h macros. These
include the queues of all threads, dead threads, and threads
waiting for file descriptor locks.

o Added reinitialization of the GC mutex and condition variable
after a fork. Also prevented reallocation of the ready queue
after a fork.

o Prevented the wrapped close routine from closing the thread
kernel pipes.

o Initialized file descriptor table for stdio entries at thread
init.

o Provided additional flags to indicate to what queues threads
belong.

o Moved TAILQ initialization for statically allocated mutex and
condition variables to after the spinlock.

o Added dispatching of signals to pthread_kill. Removing the
dispatching of signals from thread activation broke sigsuspend
when pthread_kill was used to send a signal to a thread.

o Temporarily set the state of a thread to PS_SUSPENDED when it
is first created and placed in the list of threads so that it
will not be accidentally scheduled before becoming a member
of one of the scheduling queues.

o Change the signal handler to queue signals to the thread kernel
pipe if the scheduling queues are protected. When scheduling
queues are unprotected, signals are then dequeued and handled.

o Ensured that all installed signal handlers block the scheduling
signal and that the scheduling signal handler blocks all
other signals. This ensures that the signal handler is only
interruptible for and by non-scheduling signals. An atomic
lock is used to decide which instance of the signal handler
will handle pending signals.

o Removed _lock_thread_list and _unlock_thread_list as they are
no longer used to protect the thread list.

o Added missing RCS IDs to modified files.

o Added checks for appropriate queue membership and activity when
adding, removing, and searching the scheduling queues. These
checks add very little overhead and are enabled when compiled
with _PTHREADS_INVARIANTS defined. Suggested and implemented
by Tor Egge with some modification by me.

o Close a race condition in uthread_close. (Tor Egge)

o Protect the scheduling queues while modifying them in
pthread_cond_signal and _thread_fd_unlock. (Tor Egge)

o Ensure that when a thread gets a mutex, the mutex is on that
threads list of owned mutexes. (Tor Egge)

o Set the kernel-in-scheduler flag in _thread_kern_sched_state
and _thread_kern_sched_state_unlock to prevent a scheduling
signal from calling the scheduler again. (Tor Egge)

o Don't use TAILQ_FOREACH macro while searching the waiting
queue for threads in a sigwait state, because a change of
state destroys the TAILQ link. It is actually safe to do
so, though, because once a sigwaiting thread is found, the
loop ends and the function returns. (Tor Egge)

o When dispatching signals to threads, make the thread inherit
the signal deferral flag of the currently running thread.
(Tor Egge)

Submitted by: Daniel Eischen <eischen@vigrid.com> and
Tor Egge <Tor.Egge@fast.no>

Added a missing comma to the static condition variable initialisation
definition.

Submitted by: David Leonard <David.Leonard@csee.uq.edu.au>, an OpenBSD guy.

Fix a problem with static initialisation of mutexes and condition
variables.

Submitted by: Dan Eischen <eischen@vigrid.com>

Ensure that an existing thread gets it's state set to PS_DEAD to
prevent being rescheduled.

Submitted by: Dan Eischen <eischen@vigrid.com>

- Fixed bug where we NULL'd before we freed the data causing a memory leak.

Submitted by: Ralf S. Engelschall
Obtained from: PR i386/11713

Add mutex test program.

Back out patch for cond_timedwait() bug from -current, since other changes
have made the patch obsolete, as pointed out by Daniel Eischen
<eischen@vigrid.com>.

PR: bin/8872

Apply patch included in bin/8872. This fixes a bug that occurs when
pthread_cond_timedwait() times out.

PR: bin/8872
Submitted by: Jason Evans <jasone@canonware.com>
Reviewed by: David Schwartz <davids@webmaster.com>

[ The author's description... ]

o Runnable threads are now maintained in priority queues. The
implementation requires two things:

1.) The priority queues must be protected during insertion
and removal of threads. Since the kernel scheduler
must modify the priority queues, a spinlock for
protection cannot be used. The functions
_thread_kern_sched_defer() and _thread_kern_sched_undefer()
were added to {un}defer kernel scheduler activation.

2.) A thread (active) priority change can be performed only
when the thread is removed from the priority queue. The
implementation uses a threads active priority when
inserting it into the queue.

A by-product is that thread switches are much faster. A
separate queue is used for waiting and/or blocked threads,
and it is searched at most 2 times in the kernel scheduler
when there are active threads. It should be possible to
reduce this to once by combining polling of threads waiting
on I/O with the loop that looks for timed out threads and
the minimum timeout value.

o Functions to defer kernel scheduler activation were added. These
are _thread_kern_sched_defer() and _thread_kern_sched_undefer()
and may be called recursively. These routines do not block the
scheduling signal, but latch its occurrence. The signal handler
will not call the kernel scheduler when the running thread has
deferred scheduling, but it will be called when running thread
undefers scheduling.

o Added support for _POSIX_THREAD_PRIORITY_SCHEDULING. All the
POSIX routines required by this should now be implemented.
One note, SCHED_OTHER, SCHED_FIFO, and SCHED_RR are required
to be defined by including pthread.h. These defines are currently
in sched.h. I modified pthread.h to include sched.h but don't
know if this is the proper thing to do.

o Added support for priority protection and inheritence mutexes.
This allows definition of _POSIX_THREAD_PRIO_PROTECT and
_POSIX_THREAD_PRIO_INHERIT.

o Added additional error checks required by POSIX for mutexes and
condition variables.

o Provided a wrapper for sigpending which is marked as a hidden
syscall.

o Added a non-portable function as a debugging aid to allow an
application to monitor thread context switches. An application
can install a routine that gets called everytime a thread
(explicitly created by the application) gets context switched.
The routine gets passed the pthread IDs of the threads that are
being switched in and out.

Submitted by: Dan Eischen <eischen@vigrid.com>

Changes by me:

o Added a PS_SPINBLOCK state to deal with the priority inversion
problem most often (I think) seen by threads calling malloc/free/realloc.

o Dispatch signals to the running thread directly rather than at a
context switch to avoid the situation where the switch never occurs.

Increase the size of private thread flags so that the test for a
thread trying to call pthread_exit() from a cleanup handler actually
works.

Submitted by: David Leonard <david.leonard@csee.uq.edu.au> OpenBSD

Fix a minor security problem in libc_r.

Submitted by: Alexandre Snarskii <snar@paranoia.ru>
Approved by: John Birrell
Reminded me that I'd been sitting on this too long: snar@paranoia.ru

Don't hide mknod, it doesn't need a wrapper and never has had one.

Add support for pthread_mutexattr_settype(). As a side effect of
testing this, fix MUTEX_TYPE_COUNTING_FAST. Recursive locks now work.

Interrupt threads waiting in select etc.

Submitted by: Alec Wolman <wolman@cs.washington.edu>

Close a window between unlocking a spinlock and changing the thread state.

Don't call pthread_mutex_lock with _SPINLOCK held.
Made pthread_cond_wait() more similar to pthread_cond_timedwait().

PR: 8375

Fix some bugs in pthread scheduler:
make pthread_yield() more reliable,
threads always (I hope) preempted at least every 0.1 sec, as intended.

PR: bin/7744
Submitted by: "Richard Seaman, Jr." <dick@tar.com>

Revise test code for sigwait and add test code for sigsuspend.

Submitted by: Daniel M. Eischen <eischen@vigrid.com>

Cosmetic cleansing. This code requires extra work to keep the garbage
collector thread running after a fork.

Move the cleanup code that frees memory allocated for a dead thread from
the thread kernel into a garbage collector thread which is started when
the fisrt thread is created (other than the initial thread). This
removes the window of opportunity where a context switch will cause a
thread that has locked the malloc spinlock, to enter the thread kernel,
find there is a dead thread and try to free memory, therefore trying
to lock the malloc spinlock against itself.

The garbage collector thread acts just like any other thread, so
instead of having a spinlock to control accesses to the dead thread
list, it uses a mutex and a condition variable so that it can happily
wait to be signalled when a thread exists.

Use snprintf instead of sprintf to avoid long source file paths from
launching an application into space when someone tries to debug it.

The dead thread list now has it's own link pointer, so use that when
reporting the grateful dead.

Implementation of an additional state called SIGWAIT (with the previous
one renamed to SIGSUSPEND) to fix sigwait().

Submitted by: Daniel M. Eischen <eischen@vigrid.com>

NULL a pointer after it is freed to avoid trying to free it again.

- Fix the debug macros.
- Add support of a thread being listed in the dead thread list as well
as the thread list.
- Add a new thread state to make sigwait work properly. (Submitted by
Daniel M. Eischen <eischen@vigrid.com>)
- Add global variable for the garbage collector mutex and condition
variable.
- Delete a couple of prototypes that are no longer required.
- Add a prototype for the garbage collector thread.

In libc_r, rename vfork syscall to _thread_sys_vfork and make vfork an alias
to fork. It is difficult to do real vfork in libc_r, since almost every
operation with file descriptsor changes _thread_fd_table and friends.

popen(3) works much better with this change.

Removed unused variables.

Removed some variable initializations which were unnecessary and divergent
from style(9).

-Wall clean.

Implement pthread read/write locks as defined by Version 2 of the Single
UNIX Specification.

As with our standard mutexes, process shared locks are not supported at
this time.

Don't automatically restart syscalls for the signals that the thread
kernel needs.

Back out most of the last commit. It created problems with sigpause.

Add support for building test programs.