#
259065 |
|
07-Dec-2013 |
gjb |
- Copy stable/10 (r259064) to releng/10.0 as part of the 10.0-RELEASE cycle. - Update __FreeBSD_version [1] - Set branch name to -RC1
[1] 10.0-CURRENT __FreeBSD_version value ended at '55', so start releng/10.0 at '100' so the branch is started with a value ending in zero.
Approved by: re (implicit) Sponsored by: The FreeBSD Foundation |
#
256281 |
|
10-Oct-2013 |
gjb |
Copy head (r256279) to stable/10 as part of the 10.0-RELEASE cycle.
Approved by: re (implicit) Sponsored by: The FreeBSD Foundation
|
#
177626 |
|
26-Mar-2008 |
brueffer |
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
|
#
174112 |
|
30-Nov-2007 |
deischen |
WARNS=3'ify.
|
#
172491 |
|
09-Oct-2007 |
obrien |
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)
|
#
165967 |
|
12-Jan-2007 |
imp |
Remove 3rd clause, renumber, ok per email
|
#
159462 |
|
09-Jun-2006 |
maxim |
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
|
#
156330 |
|
06-Mar-2006 |
deischen |
Only catch SIGINFO (for dumping thread states) when LIBPTHREAD_DEBUG is defined in the environment.
Requested by: jmg & a few others
|
#
139023 |
|
18-Dec-2004 |
deischen |
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
|
#
137105 |
|
01-Nov-2004 |
davidxu |
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
|
#
136846 |
|
23-Oct-2004 |
davidxu |
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
|
#
136735 |
|
21-Oct-2004 |
davidxu |
Decrease reference count if we won't use the thread, this avoids memory leak under some cases.
|
#
132122 |
|
13-Jul-2004 |
davidxu |
Let debugger check signal, make SIGINFO works.
|
#
130374 |
|
12-Jun-2004 |
davidxu |
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>
|
#
124095 |
|
03-Jan-2004 |
davidxu |
Kernel now supports per-thread sigaltstack, follow the change to enable sigaltstack for scope system thread.
|
#
124055 |
|
01-Jan-2004 |
davidxu |
Fix a typo.
|
#
123974 |
|
29-Dec-2003 |
davidxu |
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
|
#
123933 |
|
28-Dec-2003 |
davidxu |
Correctly retrieve sigaction flags.
|
#
120338 |
|
22-Sep-2003 |
davidxu |
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.
|
#
120079 |
|
14-Sep-2003 |
davidxu |
Fix bogus comment and assign sigmask in critical region, use SIG_CANTMASK to remove unmaskable signal masks.
|
#
120073 |
|
14-Sep-2003 |
davidxu |
When invoking an old style signal handler, use true traditional BSD style to invoke signal handler.
Reviewed by: deischen
|
#
119249 |
|
21-Aug-2003 |
davidxu |
Repost masked signal to kernel for scope system thread, it hardly happens in real world.
Reviewed by: deischen
|
#
119177 |
|
20-Aug-2003 |
davidxu |
_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.
|
#
119063 |
|
18-Aug-2003 |
davidxu |
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
|
#
118748 |
|
10-Aug-2003 |
davidxu |
Add some quick pathes to exit process when signal action is default and signal can causes process to exit.
Reviewed by: deischen
|
#
118747 |
|
10-Aug-2003 |
davidxu |
Initialize rtld lock just before turning on thread mode and uninitialize rtld lock after thread mode shutdown.
|
#
118510 |
|
05-Aug-2003 |
deischen |
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
|
#
118075 |
|
27-Jul-2003 |
davidxu |
Simplify sigwait code a bit by using a waitset and removing oldsigmask.
Reviewed by: deischen
|
#
117907 |
|
23-Jul-2003 |
deischen |
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
|
#
117706 |
|
17-Jul-2003 |
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
|
#
117366 |
|
09-Jul-2003 |
davidxu |
Don't resume sigwait thread If signal is masked.
|
#
117353 |
|
09-Jul-2003 |
davidxu |
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.
|
#
117345 |
|
08-Jul-2003 |
davidxu |
Restore signal mask correctly after fork().
|
#
117301 |
|
07-Jul-2003 |
davidxu |
Add a newline to debug message.
|
#
117066 |
|
30-Jun-2003 |
davidxu |
Because there are only _SIG_MAXSIG elements in thread siginfo array, use [signal number - 1] as subscript to access the array.
|
#
116977 |
|
28-Jun-2003 |
davidxu |
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().
|
#
116773 |
|
23-Jun-2003 |
marcel |
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
|
#
116061 |
|
08-Jun-2003 |
deischen |
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.
|
#
115413 |
|
30-May-2003 |
davidxu |
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)
|
#
115381 |
|
29-May-2003 |
deischen |
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)
|
#
115278 |
|
24-May-2003 |
deischen |
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)
|
#
115080 |
|
16-May-2003 |
deischen |
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)
|
#
114664 |
|
04-May-2003 |
deischen |
Fix suspend and resume.
Submitted (in part) by: Kazuaki Oda <kaakun@highway.ne.jp>
|
#
114254 |
|
29-Apr-2003 |
deischen |
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
|
#
114180 |
|
28-Apr-2003 |
deischen |
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>
|
#
113658 |
|
18-Apr-2003 |
deischen |
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
|
#
111360 |
|
23-Feb-2003 |
mini |
Insert threads interrupted by a signal while running onto the run queue.
|
#
111035 |
|
17-Feb-2003 |
mini |
Deliver signals posted via an upcall to the appropriate thread.
|
#
103388 |
|
16-Sep-2002 |
mini |
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
|
#
102590 |
|
29-Aug-2002 |
deischen |
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
|
#
97204 |
|
24-May-2002 |
deischen |
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.
|
#
90431 |
|
09-Feb-2002 |
deischen |
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
|
#
86499 |
|
17-Nov-2001 |
deischen |
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
|
#
78979 |
|
29-Jun-2001 |
deischen |
Clear the in thread scheduler flag after jumping to the start of a signal handler from the scheduler.
MFC after: 1 week
|
#
76909 |
|
20-May-2001 |
jasone |
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
|
#
76280 |
|
04-May-2001 |
deischen |
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
|
#
74038 |
|
09-Mar-2001 |
deischen |
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
|
#
72374 |
|
11-Feb-2001 |
deischen |
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).
|
#
71581 |
|
24-Jan-2001 |
deischen |
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
|
#
68941 |
|
20-Nov-2000 |
deischen |
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
|
#
68726 |
|
14-Nov-2000 |
deischen |
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
|
#
68516 |
|
09-Nov-2000 |
deischen |
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
|
#
67566 |
|
25-Oct-2000 |
deischen |
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]).
|
#
67444 |
|
22-Oct-2000 |
deischen |
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>
|
#
67097 |
|
13-Oct-2000 |
deischen |
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
|
#
58094 |
|
15-Mar-2000 |
deischen |
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
|
#
56310 |
|
20-Jan-2000 |
jasone |
Do signal deferral for pthread_kill() as it was done in the old days.
Submitted by: deischen
|
#
56277 |
|
19-Jan-2000 |
jasone |
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
|
#
55192 |
|
28-Dec-1999 |
deischen |
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
|
#
54707 |
|
16-Dec-1999 |
deischen |
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
|
#
54138 |
|
04-Dec-1999 |
deischen |
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
|
#
51794 |
|
29-Sep-1999 |
marcel |
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.
|
#
50476 |
|
27-Aug-1999 |
peter |
$Id$ -> $FreeBSD$
|
#
49439 |
|
05-Aug-1999 |
deischen |
Add RCS IDs to those files without them. Fix copyrights (s/REGENTS/AUTHOR).
Suggested by: tg Approved by: jb
|
#
48046 |
|
20-Jun-1999 |
jb |
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>
|
#
44963 |
|
23-Mar-1999 |
jb |
[ 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.
|
#
39805 |
|
30-Sep-1998 |
jb |
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>
|
#
38925 |
|
07-Sep-1998 |
alex |
Removed unused variables.
|
#
38563 |
|
26-Aug-1998 |
jb |
Back out most of the last commit. It created problems with sigpause.
|
#
38539 |
|
25-Aug-1998 |
jb |
Fix for sigwait problem.
Submitted by: Daniel M. Eischen <eischen@vigrid.com> PR: misc/7039
|
#
37045 |
|
17-Jun-1998 |
jb |
Don't allow a SIGCHLD to wake up a thread if the process has the default signal handler installed for SIGCHLD. The ACE MT_SOCK_Test was hanging as the result of being interrupted when it didn't expect to be.
|
#
37021 |
|
17-Jun-1998 |
jb |
If a thread is waiting on a child process to complete, the SIGCHLD signal can arrive before the thread is woken from it's wait4. In this case, don't return an EINTR, just set the thread state to running and the wait4 wrapper will loop and get the exit status of the process.
|
#
36876 |
|
10-Jun-1998 |
jb |
Remove SA_RESTART from the signal dispatch in user-space since this seems to be tripping up a lot of applications.
|
#
36830 |
|
09-Jun-1998 |
jb |
Implement compile time debug support instead of tracking file name and line number every time a file descriptor is locked.
This looks like a big change but it isn't. It should reduce the size of libc_r and make it run slightly faster.
|
#
36694 |
|
06-Jun-1998 |
jb |
I got the last commit back to front.
|
#
36680 |
|
05-Jun-1998 |
jb |
Fix the signal behaviour for internal states which set the thread state to running despite the SA_RESTART flag which is really just for syscalls.
|
#
36548 |
|
31-May-1998 |
jb |
Don't restart a syscall when a SIGCHLD is received by a thread waiting on a child process.
|
#
35509 |
|
29-Apr-1998 |
jb |
Change signal model to match POSIX (i.e. one set of signal handlers for the process, not a separate set for each thread). By default, the process now only has signal handlers installed for SIGVTALRM, SIGINFO and SIGCHLD. The thread kernel signal handler is installed for other signals on demand. This means that SIG_IGN and SIG_DFL processing is now left to the kernel, not the thread kernel.
Change the signal dispatch to no longer use a signal thread, and call the signal handler using the stack of the thread that has the signal pending.
Change the atomic lock method to use test-and-set asm code with a yield if blocked. This introduces separate locks for each type of object instead of blocking signals to prevent a context switch. It was this blocking of signals that caused the performance degradation the people have noted.
This is a *big* change!
|
#
22315 |
|
05-Feb-1997 |
julian |
Submitted by: John Birrell uthreads update from the author.
|
#
17706 |
|
20-Aug-1996 |
julian |
Submitted by: John Birrell <cimaxp1!jb@werple.net.au>
Here are the diffs for libc_r to get it one step closer to P1003.1c These make most of the thread/mutex/condvar structures opaque to the user. There are three functions which have been renamed with _np suffixes because they are extensions to P1003.1c (I did them for JAVA, which needs to suspend/resume threads and also start threads suspended).
I've created a new header (pthread_np.h) for the non-POSIX stuff.
The egrep tags stuff in /usr/src/lib/libc_r/Makefile that I uncommented doesn't work. I think its best to delete it. I don't think libc_r needs tags anyway, 'cause most of the source is in libc which does have tags.
also:
Here's the first batch of man pages for the thread functions. The diff to /usr/src/lib/libc_r/Makefile removes some stuff that was inherited from /usr/src/lib/libc/Makefile that should only be done with libc.
also:
I should have sent this diff with the pthread(3) man page. It allows people to type
make -DWANT_LIBC_R world
to get libc_r built with the rest of the world. I put this in the pthread(3) man page. The default is still not to build libc_r.
also: The diff attached adds a pthread(3) man page to /usr/src/share/man/man3. The idea is that without libc_r installed, this man page will give people enough info to know that they have to build libc_r.
|
#
13546 |
|
21-Jan-1996 |
julian |
Reviewed by: julian Submitted by: john birrel
One version of the pthreads library another will follow with differnt actions under some cases.. not QUITE complete
|