r5041 - in glibc-package/trunk/debian: . debhelper.in patches patches/kfreebsd sysdeps
Author: ps-guest
Date: 2011-11-26 10:20:34 +0000 (Sat, 26 Nov 2011)
New Revision: 5041
Added:
glibc-package/trunk/debian/patches/kfreebsd/local-use-thr-primitives.diff
Modified:
glibc-package/trunk/debian/changelog
glibc-package/trunk/debian/debhelper.in/libc.preinst
glibc-package/trunk/debian/patches/series.kfreebsd-amd64
glibc-package/trunk/debian/patches/series.kfreebsd-i386
glibc-package/trunk/debian/sysdeps/kfreebsd.mk
Log:
* add kfreebsd/local-use-thr-primitives.diff to use kernel thr* primitives inside linuxthreads.
* bump minimal FreeBSD kernel version to 8.1.
Modified: glibc-package/trunk/debian/changelog
===================================================================
--- glibc-package/trunk/debian/changelog 2011-11-21 21:41:07 UTC (rev 5040)
+++ glibc-package/trunk/debian/changelog 2011-11-26 10:20:34 UTC (rev 5041)
@@ -51,6 +51,10 @@
[ Petr Salinger ]
* kfreebsd/local-sysdeps.diff: update to revision 3763 (from glibc-bsd).
+ * add kfreebsd/local-use-thr-primitives.diff to use kernel thr*
+ primitives inside linuxthreads. Closes: #639658.
+ * debian/sysdeps/sysdeps/kfreebsd.mk, debhelper.in/libc.preinst:
+ bump minimal FreeBSD kernel version to 8.1.
[ Steve Langasek ]
* Add a new debconf template, libraries/restart-without-asking, shared
Modified: glibc-package/trunk/debian/debhelper.in/libc.preinst
===================================================================
--- glibc-package/trunk/debian/debhelper.in/libc.preinst 2011-11-21 21:41:07 UTC (rev 5040)
+++ glibc-package/trunk/debian/debhelper.in/libc.preinst 2011-11-26 10:20:34 UTC (rev 5041)
@@ -396,10 +396,10 @@
fi
elif [ $system = "GNU/kFreeBSD" ] ; then
kernel_ver=`uname -r`
- if kfreebsd_compare_versions "$kernel_ver" lt 8.0
+ if kfreebsd_compare_versions "$kernel_ver" lt 8.1
then
echo WARNING: this version of the GNU libc requires kernel version
- echo 8.0 or later. Please upgrade your kernel before installing
+ echo 8.1 or later. Please upgrade your kernel before installing
echo glibc.
exit 1
fi
Added: glibc-package/trunk/debian/patches/kfreebsd/local-use-thr-primitives.diff
===================================================================
--- glibc-package/trunk/debian/patches/kfreebsd/local-use-thr-primitives.diff (rev 0)
+++ glibc-package/trunk/debian/patches/kfreebsd/local-use-thr-primitives.diff 2011-11-26 10:20:34 UTC (rev 5041)
@@ -0,0 +1,673 @@
+--- a/linuxthreads/attr.c
++++ b/linuxthreads/attr.c
+@@ -365,11 +365,11 @@
+ ? PTHREAD_CREATE_DETACHED
+ : PTHREAD_CREATE_JOINABLE);
+
+- attr->__schedpolicy = __sched_getscheduler (descr->p_pid);
++ attr->__schedpolicy = __sched_getscheduler (getpid());
+ if (attr->__schedpolicy == -1)
+ return errno;
+
+- if (__sched_getparam (descr->p_pid,
++ if (__sched_getparam (getpid(),
+ (struct sched_param *) &attr->__schedparam) != 0)
+ return errno;
+
+--- a/linuxthreads/cancel.c
++++ b/linuxthreads/cancel.c
+@@ -89,7 +89,7 @@
+ int pthread_cancel(pthread_t thread)
+ {
+ pthread_handle handle = thread_handle(thread);
+- int pid;
++ long ktid;
+ int dorestart = 0;
+ pthread_descr th;
+ pthread_extricate_if *pextricate;
+@@ -112,7 +112,7 @@
+ }
+
+ pextricate = th->p_extricate;
+- pid = th->p_pid;
++ ktid = th->p_ktid;
+
+ /* If the thread has registered an extrication interface, then
+ invoke the interface. If it returns 1, then we succeeded in
+@@ -139,7 +139,7 @@
+ if (dorestart)
+ restart(th);
+ else
+- kill(pid, __pthread_sig_cancel);
++ __thr_kill(ktid, __pthread_sig_cancel);
+
+ return 0;
+ }
+--- a/linuxthreads/descr.h
++++ b/linuxthreads/descr.h
+@@ -26,6 +26,42 @@
+ #include <lowlevellock.h>
+ #include <tls.h>
+
++
++extern long int syscall (long int __sysno, ...);
++#include <sys/syscall.h>
++// should be in <sys/thr.h>
++struct rtprio;
++struct thr_param {
++ void (*start_func)(void *); /* thread entry function. */
++ void *arg; /* argument for entry function. */
++ char *stack_base; /* stack base address. */
++ size_t stack_size; /* stack size. */
++ char *tls_base; /* tls base address. */
++ size_t tls_size; /* tls size. */
++ long *child_tid; /* address to store new TID. */
++ long *parent_tid; /* parent accesses the new TID here. */
++ int flags; /* thread flags. */
++ struct rtprio *rtp; /* Real-time scheduling priority */
++ void *spare[3]; /* TODO: cpu affinity mask etc. */
++};
++
++#define KTID_TERMINATED 1
++static inline int __thr_self(long *ktid)
++{ return syscall(SYS_thr_self, ktid);};
++
++static inline int __thr_kill(long ktid, int signo)
++{ return syscall(SYS_thr_kill, ktid, signo);};
++
++static inline int __thr_exit(long *ktid) // also *ktid = KTID_TERMINATED, wakeup(ktid)
++{ return syscall(SYS_thr_exit, ktid);}; // returns only for last thread in process
++
++static inline int __thr_new(struct thr_param *param, int param_size)
++{ return syscall(SYS_thr_new, param, param_size);};
++
++static inline int __lll_wait(long *addr, long val)
++{ return syscall(SYS__umtx_op, addr, UMTX_OP_WAIT, val, NULL, NULL);};
++
++
+ /* Fast thread-specific data internal to libc. */
+ enum __libc_tsd_key_t { _LIBC_TSD_KEY_MALLOC = 0,
+ _LIBC_TSD_KEY_DL_ERROR,
+@@ -202,6 +238,8 @@
+ size_t p_alloca_cutoff; /* Maximum size which should be allocated
+ using alloca() instead of malloc(). */
+ /* New elements must be added at the end. */
++ long p_ktid; /* kernel thread ID */
++
+
+ /* This member must be last. */
+ char end_padding[];
+--- a/linuxthreads/join.c
++++ b/linuxthreads/join.c
+@@ -89,6 +89,9 @@
+ }
+ /* Threads other than the main one terminate without flushing stdio streams
+ or running atexit functions. */
++
++ __thr_kill(__manager_thread->p_ktid, __pthread_sig_cancel);
++ __thr_exit(&(self->p_ktid));
+ _exit(0);
+ }
+
+--- a/linuxthreads/manager.c
++++ b/linuxthreads/manager.c
+@@ -151,13 +151,16 @@
+ while(1) {
+ n = __poll(&ufd, 1, 2000);
+
++#if 0
++ /* iff the main thread terminated abnormally, the signal should kill all threads already */
+ /* Check for termination of the main thread */
+ if (getppid() == 1) {
+ pthread_kill_all_threads(SIGKILL, 0);
+ _exit(0);
+ }
++#endif
+ /* Check for dead children */
+- if (terminated_children) {
++ if (terminated_children || main_thread_exiting) {
+ terminated_children = 0;
+ pthread_reap_children();
+ }
+@@ -182,7 +185,7 @@
+ request.req_args.create.fn,
+ request.req_args.create.arg,
+ &request.req_args.create.mask,
+- request.req_thread->p_pid,
++ request.req_thread->p_ktid,
+ request.req_thread->p_report_events,
+ &request.req_thread->p_eventbuf.eventmask);
+ restart(request.req_thread);
+@@ -271,10 +274,13 @@
+ #endif
+ /* Make sure our pid field is initialized, just in case we get there
+ before our father has initialized it. */
+- THREAD_SETMEM(self, p_pid, __getpid());
++ // done in kernel
++ // __thr_self(&ktid);
++ // THREAD_SETMEM(self, p_ktid, ktid);
+ /* Initial signal mask is that of the creating thread. (Otherwise,
+ we'd just inherit the mask of the thread manager.) */
+ sigprocmask(SIG_SETMASK, &self->p_start_args.mask, NULL);
++#if 0
+ /* Set the scheduling policy and priority for the new thread, if needed */
+ if (THREAD_GETMEM(self, p_start_args.schedpolicy) >= 0)
+ /* Explicit scheduling attributes were provided: apply them */
+@@ -290,6 +296,7 @@
+ __sched_setscheduler(THREAD_GETMEM(self, p_pid),
+ SCHED_OTHER, &default_params);
+ }
++#endif
+ #if !(USE_TLS && HAVE___THREAD)
+ /* Initialize thread-locale current locale to point to the global one.
+ With __thread support, the variable's initializer takes care of this. */
+@@ -324,7 +331,9 @@
+ #endif
+ /* Make sure our pid field is initialized, just in case we get there
+ before our father has initialized it. */
+- THREAD_SETMEM(self, p_pid, __getpid());
++ // done in kernel
++ // __thr_self(&ktid);
++ // THREAD_SETMEM(self, p_ktid, ktid);
+ /* Get the lock the manager will free once all is correctly set up. */
+ __pthread_lock (THREAD_GETMEM(self, p_lock), NULL);
+ /* Free it immediately. */
+@@ -586,7 +595,7 @@
+ td_thr_events_t *event_maskp)
+ {
+ size_t sseg;
+- int pid;
++ int rv;
+ pthread_descr new_thread;
+ char *stack_addr;
+ char * new_thread_bottom;
+@@ -595,6 +604,7 @@
+ size_t guardsize = 0, stksize = 0;
+ int pagesize = __getpagesize();
+ int saved_errno = 0;
++ struct thr_param p;
+
+ #ifdef USE_TLS
+ new_thread = _dl_allocate_tls (NULL);
+@@ -691,6 +701,7 @@
+ new_thread->p_detached = attr->__detachstate;
+ new_thread->p_userstack = attr->__stackaddr_set;
+
++#if 0
+ switch(attr->__inheritsched) {
+ case PTHREAD_EXPLICIT_SCHED:
+ new_thread->p_start_args.schedpolicy = attr->__schedpolicy;
+@@ -702,6 +713,7 @@
+ __sched_getparam(father_pid, &new_thread->p_start_args.schedparam);
+ break;
+ }
++#endif
+ new_thread->p_priority =
+ new_thread->p_start_args.schedparam.sched_priority;
+ }
+@@ -717,7 +729,7 @@
+ __pthread_manager_adjust_prio(new_thread->p_priority);
+ /* Do the cloning. We have to use two different functions depending
+ on whether we are debugging or not. */
+- pid = 0; /* Note that the thread never can have PID zero. */
++ rv = 0;
+ if (report_events)
+ {
+ /* See whether the TD_CREATE event bit is set in any of the
+@@ -733,30 +745,22 @@
+
+ /* We have to report this event. */
+ #ifdef NEED_SEPARATE_REGISTER_STACK
+- /* Perhaps this version should be used on all platforms. But
+- this requires that __clone2 be uniformly supported
+- everywhere.
+-
+- And there is some argument for changing the __clone2
+- interface to pass sp and bsp instead, making it more IA64
+- specific, but allowing stacks to grow outward from each
+- other, to get less paging and fewer mmaps. */
+- pid = __clone2(pthread_start_thread_event,
+- (void **)new_thread_bottom,
+- (char *)stack_addr - new_thread_bottom,
+- CLONE_VM | CLONE_FS | CLONE_FILES | CLONE_SIGHAND | CLONE_SYSVSEM |
+- __pthread_sig_cancel, new_thread);
++#error unimplemented SEPARATE_REGISTER_STACK
+ #elif _STACK_GROWS_UP
+- pid = __clone(pthread_start_thread_event, (void *) new_thread_bottom,
+- CLONE_VM | CLONE_FS | CLONE_FILES | CLONE_SIGHAND | CLONE_SYSVSEM |
+- __pthread_sig_cancel, new_thread);
++#error unimplemented _STACK_GROWS_UP
+ #else
+- pid = __clone(pthread_start_thread_event, stack_addr,
+- CLONE_VM | CLONE_FS | CLONE_FILES | CLONE_SIGHAND | CLONE_SYSVSEM |
+- __pthread_sig_cancel, new_thread);
++ memset(&p, 0, sizeof(p));
++ p.start_func = pthread_start_thread_event;
++ p.arg = new_thread;
++ p.stack_base = new_thread_bottom;
++ p.stack_size = stack_addr - new_thread_bottom;
++ p.tls_base = new_thread;
++ p.child_tid = &(new_thread->p_ktid);
++
++ rv = __thr_new(&p, sizeof(p));
+ #endif
+ saved_errno = errno;
+- if (pid != -1)
++ if (rv != -1)
+ {
+ /* Now fill in the information about the new thread in
+ the newly created thread's data structure. We cannot let
+@@ -769,7 +773,7 @@
+ /* We have to set the PID here since the callback function
+ in the debug library will need it and we cannot guarantee
+ the child got scheduled before the debugger. */
+- new_thread->p_pid = pid;
++ // kernel already done that
+
+ /* Now call the function which signals the event. */
+ __linuxthreads_create_event ();
+@@ -779,27 +783,31 @@
+ }
+ }
+ }
+- if (pid == 0)
++
++ if (rv == 0)
+ {
+ #ifdef NEED_SEPARATE_REGISTER_STACK
+- pid = __clone2(pthread_start_thread,
+- (void **)new_thread_bottom,
+- (char *)stack_addr - new_thread_bottom,
+- CLONE_VM | CLONE_FS | CLONE_FILES | CLONE_SIGHAND | CLONE_SYSVSEM |
+- __pthread_sig_cancel, new_thread);
++#error unimplemented SEPARATE_REGISTER_STACK
+ #elif _STACK_GROWS_UP
+- pid = __clone(pthread_start_thread, (void *) new_thread_bottom,
+- CLONE_VM | CLONE_FS | CLONE_FILES | CLONE_SIGHAND | CLONE_SYSVSEM |
+- __pthread_sig_cancel, new_thread);
++#error unimplemented _STACK_GROWS_UP
+ #else
+- pid = __clone(pthread_start_thread, stack_addr,
+- CLONE_VM | CLONE_FS | CLONE_FILES | CLONE_SIGHAND | CLONE_SYSVSEM |
+- __pthread_sig_cancel, new_thread);
++
++ memset(&p, 0, sizeof(p));
++ p.start_func = pthread_start_thread;
++ p.arg = new_thread;
++ p.stack_base = new_thread_bottom;
++ p.stack_size = stack_addr - new_thread_bottom;
++ p.tls_base = new_thread;
++ p.child_tid = &(new_thread->p_ktid);
++
++ rv = __thr_new(&p, sizeof(p));
++
+ #endif /* !NEED_SEPARATE_REGISTER_STACK */
+ saved_errno = errno;
+ }
++
+ /* Check if cloning succeeded */
+- if (pid == -1) {
++ if (rv == -1) {
+ /* Free the stack if we allocated it */
+ if (attr == NULL || !attr->__stackaddr_set)
+ {
+@@ -843,7 +851,7 @@
+ __pthread_main_thread->p_nextlive = new_thread;
+ /* Set pid field of the new thread, in case we get there before the
+ child starts. */
+- new_thread->p_pid = pid;
++ // kernel already done that
+ return 0;
+ }
+
+@@ -928,17 +936,18 @@
+
+ /* Handle threads that have exited */
+
+-static void pthread_exited(pid_t pid)
++static void pthread_reap_children(void)
+ {
+- pthread_descr th;
++ pthread_descr th, tth;
+ int detached;
++
+ /* Find thread with that pid */
+ for (th = __pthread_main_thread->p_nextlive;
+ th != __pthread_main_thread;
+ th = th->p_nextlive) {
+- if (th->p_pid == pid) {
++ if (th->p_ktid == KTID_TERMINATED) {
+ /* Remove thread from list of active threads */
+- th->p_nextlive->p_prevlive = th->p_prevlive;
++ tth = th->p_nextlive->p_prevlive = th->p_prevlive;
+ th->p_prevlive->p_nextlive = th->p_nextlive;
+ /* Mark thread as exited, and if detached, free its resources */
+ __pthread_lock(th->p_lock, NULL);
+@@ -966,7 +975,7 @@
+ __pthread_unlock(th->p_lock);
+ if (detached)
+ pthread_free(th);
+- break;
++ th = tth;
+ }
+ }
+ /* If all threads have exited and the main thread is pending on a
+@@ -978,22 +987,6 @@
+ }
+ }
+
+-static void pthread_reap_children(void)
+-{
+- pid_t pid;
+- int status;
+-
+- while ((pid = waitpid_not_cancel(-1, &status, WNOHANG | __WCLONE)) > 0) {
+- pthread_exited(pid);
+- if (WIFSIGNALED(status)) {
+- /* If a thread died due to a signal, send the same signal to
+- all other threads, including the main thread. */
+- pthread_kill_all_threads(WTERMSIG(status), 1);
+- _exit(0);
+- }
+- }
+-}
+-
+ /* Try to free the resources of a thread when requested by pthread_join
+ or pthread_detach on a terminated thread. */
+
+@@ -1030,10 +1023,10 @@
+ for (th = __pthread_main_thread->p_nextlive;
+ th != __pthread_main_thread;
+ th = th->p_nextlive) {
+- kill(th->p_pid, sig);
++ __thr_kill(th->p_ktid, sig);
+ }
+ if (main_thread_also) {
+- kill(__pthread_main_thread->p_pid, sig);
++ __thr_kill(__pthread_main_thread->p_ktid, sig);
+ }
+ }
+
+@@ -1071,18 +1064,24 @@
+ for (th = issuing_thread->p_nextlive;
+ th != issuing_thread;
+ th = th->p_nextlive) {
+- kill(th->p_pid, __pthread_sig_cancel);
++ __thr_kill(th->p_ktid, __pthread_sig_cancel);
+ }
+ /* Now, wait for all these threads, so that they don't become zombies
+ and their times are properly added to the thread manager's times. */
+ for (th = issuing_thread->p_nextlive;
+ th != issuing_thread;
+ th = th->p_nextlive) {
+- waitpid(th->p_pid, NULL, __WCLONE);
++ if (th == __pthread_main_thread) // it waits for thread manager
++ continue;
++ long ktid;
++ while (KTID_TERMINATED != (ktid = th->p_ktid))
++ __lll_wait(&(th->p_ktid), ktid);
+ }
+ __fresetlockfiles();
+ restart(issuing_thread);
+- _exit(0);
++ __thr_exit(&(manager_thread->p_ktid));
++ // should not return */
++ _exit(__pthread_exit_code);
+ }
+
+ /* Handler for __pthread_sig_cancel in thread manager thread */
+@@ -1114,11 +1113,12 @@
+ void __pthread_manager_adjust_prio(int thread_prio)
+ {
+ struct sched_param param;
+-
++#if 0
+ if (thread_prio <= manager_thread->p_priority) return;
+ param.sched_priority =
+ thread_prio < __sched_get_priority_max(SCHED_FIFO)
+ ? thread_prio + 1 : thread_prio;
+ __sched_setscheduler(manager_thread->p_pid, SCHED_FIFO, ¶m);
+ manager_thread->p_priority = thread_prio;
++#endif
+ }
+--- a/linuxthreads/pthread.c
++++ b/linuxthreads/pthread.c
+@@ -520,6 +520,7 @@
+ {
+ struct sigaction sa;
+ sigset_t mask;
++ long ktid;
+
+ /* If already done (e.g. by a constructor called earlier!), bail out */
+ if (__pthread_initial_thread_bos != NULL) return;
+@@ -548,14 +549,16 @@
+ #endif
+ #ifdef USE_TLS
+ /* Update the descriptor for the initial thread. */
+- THREAD_SETMEM (((pthread_descr) NULL), p_pid, __getpid());
++ __thr_self(&ktid);
++ THREAD_SETMEM (((pthread_descr) NULL), p_ktid, ktid);
+ # ifndef HAVE___THREAD
+ /* Likewise for the resolver state _res. */
+ THREAD_SETMEM (((pthread_descr) NULL), p_resp, &_res);
+ # endif
+ #else
+ /* Update the descriptor for the initial thread. */
+- __pthread_initial_thread.p_pid = __getpid();
++ __thr_self(&ktid);
++ __pthread_initial_thread.p_ktid = ktid;
+ /* Likewise for the resolver state _res. */
+ __pthread_initial_thread.p_resp = &_res;
+ #endif
+@@ -629,7 +632,8 @@
+ int __pthread_initialize_manager(void)
+ {
+ int manager_pipe[2];
+- int pid;
++ int rv;
++ struct thr_param p;
+ struct pthread_request request;
+ int report_events;
+ pthread_descr mgr;
+@@ -743,7 +747,7 @@
+ __pthread_manager_reader = manager_pipe[0]; /* reading end */
+
+ /* Start the thread manager */
+- pid = 0;
++ rv = 0;
+ #ifdef USE_TLS
+ if (__linuxthreads_initial_report_events != 0)
+ THREAD_SETMEM (((pthread_descr) NULL), p_report_events,
+@@ -776,24 +780,22 @@
+ __pthread_lock(mgr->p_lock, NULL);
+
+ #ifdef NEED_SEPARATE_REGISTER_STACK
+- pid = __clone2(__pthread_manager_event,
+- (void **) __pthread_manager_thread_bos,
+- THREAD_MANAGER_STACK_SIZE,
+- CLONE_VM | CLONE_FS | CLONE_FILES | CLONE_SIGHAND | CLONE_SYSVSEM,
+- mgr);
++#error unimplemented SEPARATE_REGISTER_STACK
+ #elif _STACK_GROWS_UP
+- pid = __clone(__pthread_manager_event,
+- (void **) __pthread_manager_thread_bos,
+- CLONE_VM | CLONE_FS | CLONE_FILES | CLONE_SIGHAND | CLONE_SYSVSEM,
+- mgr);
++#error unimplemented STACK_GROWS_UP
+ #else
+- pid = __clone(__pthread_manager_event,
+- (void **) __pthread_manager_thread_tos,
+- CLONE_VM | CLONE_FS | CLONE_FILES | CLONE_SIGHAND | CLONE_SYSVSEM,
+- mgr);
++ memset(&p, 0, sizeof(p));
++ p.start_func = __pthread_manager_event;
++ p.arg = mgr;
++ p.stack_base = __pthread_manager_thread_bos;
++ p.stack_size = __pthread_manager_thread_tos - __pthread_manager_thread_bos;
++ p.tls_base = mgr;
++ p.child_tid = &(mgr->p_ktid);
++
++ rv = __thr_new(&p, sizeof(p));
+ #endif
+
+- if (pid != -1)
++ if (rv != -1)
+ {
+ /* Now fill in the information about the new thread in
+ the newly created thread's data structure. We cannot let
+@@ -803,7 +805,6 @@
+ mgr->p_eventbuf.eventnum = TD_CREATE;
+ __pthread_last_event = mgr;
+ mgr->p_tid = 2* PTHREAD_THREADS_MAX + 1;
+- mgr->p_pid = pid;
+
+ /* Now call the function which signals the event. */
+ __linuxthreads_create_event ();
+@@ -814,21 +815,26 @@
+ }
+ }
+
+- if (__builtin_expect (pid, 0) == 0)
++ if (__builtin_expect (rv, 0) == 0)
+ {
++
+ #ifdef NEED_SEPARATE_REGISTER_STACK
+- pid = __clone2(__pthread_manager, (void **) __pthread_manager_thread_bos,
+- THREAD_MANAGER_STACK_SIZE,
+- CLONE_VM | CLONE_FS | CLONE_FILES | CLONE_SIGHAND | CLONE_SYSVSEM, mgr);
++#error unimplemented SEPARATE_REGISTER_STACK
+ #elif _STACK_GROWS_UP
+- pid = __clone(__pthread_manager, (void **) __pthread_manager_thread_bos,
+- CLONE_VM | CLONE_FS | CLONE_FILES | CLONE_SIGHAND | CLONE_SYSVSEM, mgr);
++#error unimplemented STACK_GROWS_UP
+ #else
+- pid = __clone(__pthread_manager, (void **) __pthread_manager_thread_tos,
+- CLONE_VM | CLONE_FS | CLONE_FILES | CLONE_SIGHAND | CLONE_SYSVSEM, mgr);
++ memset(&p, 0, sizeof(p));
++ p.start_func = __pthread_manager;
++ p.arg = mgr;
++ p.stack_base = __pthread_manager_thread_bos;
++ p.stack_size = __pthread_manager_thread_tos - __pthread_manager_thread_bos;
++ p.tls_base = mgr;
++ p.child_tid = &(mgr->p_ktid);
++
++ rv = __thr_new(&p, sizeof(p));
+ #endif
+ }
+- if (__builtin_expect (pid, 0) == -1) {
++ if (__builtin_expect (rv, 0) == -1) {
+ #ifdef USE_TLS
+ _dl_deallocate_tls (tcbp, true);
+ #endif
+@@ -838,7 +844,6 @@
+ return -1;
+ }
+ mgr->p_tid = 2* PTHREAD_THREADS_MAX + 1;
+- mgr->p_pid = pid;
+ /* Make gdb aware of new thread manager */
+ if (__builtin_expect (__pthread_threads_debug, 0) && __pthread_sig_debug > 0)
+ {
+@@ -998,7 +1003,7 @@
+ return ESRCH;
+ }
+ th = handle->h_descr;
+- if (__builtin_expect (__sched_setscheduler(th->p_pid, policy, param) == -1,
++ if (__builtin_expect (__sched_setscheduler(getpid(), policy, param) == -1,
+ 0)) {
+ __pthread_unlock(&handle->h_lock);
+ return errno;
+@@ -1022,7 +1027,7 @@
+ __pthread_unlock(&handle->h_lock);
+ return ESRCH;
+ }
+- pid = handle->h_descr->p_pid;
++ pid = getpid();
+ __pthread_unlock(&handle->h_lock);
+ pol = __sched_getscheduler(pid);
+ if (__builtin_expect (pol, 0) == -1) return errno;
+@@ -1062,9 +1067,11 @@
+ if (self == __pthread_main_thread)
+ {
+ #ifdef USE_TLS
+- waitpid(manager_thread->p_pid, NULL, __WCLONE);
++ long ktid;
++ while (KTID_TERMINATED != (ktid = manager_thread->p_ktid))
++ __lll_wait(&(manager_thread->p_ktid), ktid);
+ #else
+- waitpid(__pthread_manager_thread.p_pid, NULL, __WCLONE);
++#error TLS required
+ #endif
+ /* Since all threads have been asynchronously terminated
+ (possibly holding locks), free cannot be used any more.
+@@ -1128,9 +1135,11 @@
+ children, so that timings for main thread account for all threads. */
+ if (self == __pthread_main_thread) {
+ #ifdef USE_TLS
+- waitpid(manager_thread->p_pid, NULL, __WCLONE);
++ long ktid;
++ while (KTID_TERMINATED != (ktid = manager_thread->p_ktid))
++ __lll_wait(&(manager_thread->p_ktid), ktid);
+ #else
+- waitpid(__pthread_manager_thread.p_pid, NULL, __WCLONE);
++#error TLS required
+ #endif
+ }
+ _exit(__pthread_exit_code);
+@@ -1170,6 +1179,7 @@
+
+ void __pthread_reset_main_thread(void)
+ {
++ long ktid;
+ pthread_descr self = thread_self();
+
+ if (__pthread_manager_request != -1) {
+@@ -1183,7 +1193,8 @@
+ }
+
+ /* Update the pid of the main thread */
+- THREAD_SETMEM(self, p_pid, __getpid());
++ __thr_self(&ktid);
++ THREAD_SETMEM(self, p_ktid, ktid);
+ /* Make the forked thread the main thread */
+ __pthread_main_thread = self;
+ THREAD_SETMEM(self, p_nextlive, self);
+@@ -1289,7 +1300,7 @@
+ void __pthread_restart_old(pthread_descr th)
+ {
+ if (pthread_atomic_increment(&th->p_resume_count) == -1)
+- kill(th->p_pid, __pthread_sig_restart);
++ __thr_kill(th->p_ktid, __pthread_sig_restart);
+ }
+
+ void __pthread_suspend_old(pthread_descr self)
+@@ -1383,7 +1394,7 @@
+ memory so the woken thread will have a consistent view. Complementary
+ read barriers are present to the suspend functions. */
+ WRITE_MEMORY_BARRIER();
+- kill(th->p_pid, __pthread_sig_restart);
++ __thr_kill(th->p_ktid, __pthread_sig_restart);
+ }
+
+ /* There is no __pthread_suspend_new because it would just
+--- a/linuxthreads/signals.c
++++ b/linuxthreads/signals.c
+@@ -57,16 +57,16 @@
+ int pthread_kill(pthread_t thread, int signo)
+ {
+ pthread_handle handle = thread_handle(thread);
+- int pid;
++ long ktid;
+
+ __pthread_lock(&handle->h_lock, NULL);
+ if (invalid_handle(handle, thread)) {
+ __pthread_unlock(&handle->h_lock);
+ return ESRCH;
+ }
+- pid = handle->h_descr->p_pid;
++ ktid = handle->h_descr->p_ktid;
+ __pthread_unlock(&handle->h_lock);
+- if (kill(pid, signo) == -1)
++ if (__thr_kill(ktid, signo) == -1)
+ return errno;
+ else
+ return 0;
Modified: glibc-package/trunk/debian/patches/series.kfreebsd-amd64
===================================================================
--- glibc-package/trunk/debian/patches/series.kfreebsd-amd64 2011-11-21 21:41:07 UTC (rev 5040)
+++ glibc-package/trunk/debian/patches/series.kfreebsd-amd64 2011-11-26 10:20:34 UTC (rev 5041)
@@ -9,3 +9,4 @@
kfreebsd/local-sys_queue_h.diff
kfreebsd/local-sysdeps.diff
kfreebsd/local-undef-glibc.diff
+kfreebsd/local-use-thr-primitives.diff
Modified: glibc-package/trunk/debian/patches/series.kfreebsd-i386
===================================================================
--- glibc-package/trunk/debian/patches/series.kfreebsd-i386 2011-11-21 21:41:07 UTC (rev 5040)
+++ glibc-package/trunk/debian/patches/series.kfreebsd-i386 2011-11-26 10:20:34 UTC (rev 5041)
@@ -9,3 +9,4 @@
kfreebsd/local-sys_queue_h.diff
kfreebsd/local-sysdeps.diff
kfreebsd/local-undef-glibc.diff
+kfreebsd/local-use-thr-primitives.diff
Modified: glibc-package/trunk/debian/sysdeps/kfreebsd.mk
===================================================================
--- glibc-package/trunk/debian/sysdeps/kfreebsd.mk 2011-11-21 21:41:07 UTC (rev 5040)
+++ glibc-package/trunk/debian/sysdeps/kfreebsd.mk 2011-11-26 10:20:34 UTC (rev 5041)
@@ -1,5 +1,5 @@
EGLIBC_OVERLAYS ?= $(shell ls glibc-linuxthreads* glibc-ports* glibc-libidn*)
-MIN_KERNEL_SUPPORTED := 8.0.0
+MIN_KERNEL_SUPPORTED := 8.1.0
libc = libc0.1
# Linuxthreads Config
Reply to: