Update.

2003-07-07  Ulrich Drepper  <drepper@redhat.com>

	* descr.h (struct pthread): Add pid field.
	* allocatestack.c (allocate_stack): Initialize pid field in descriptor.
	(__reclaim_stacks): Likewise.
	* init.c (sigcancel_handler): If __ASSUME_CORRECT_SI_PID is defined
	also check for PID of the signal source.
	(__pthread_initialize_minimal_internal): Also initialize pid field
	of initial thread's descriptor.
	* pthread_cancel.c: Use tgkill instead of tkill if possible.
	* sysdeps/unix/sysv/linux/fork.c: Likewise.
	* sysdeps/unix/sysv/linux/pt-raise.c: Likewise.
	* sysdeps/unix/sysv/linux/pthread_kill.c: Likewise.
	* sysdeps/unix/sysv/linux/raise.c: Likewise.

diff --git a/nptl/ChangeLog b/nptl/ChangeLog
index 9dd2465..4fa3910 100644 (file)
--- a/nptl/ChangeLog
+++ b/nptl/ChangeLog
@@ -1,3 +1,18 @@
+2003-07-07  Ulrich Drepper  <drepper@redhat.com>
+
+       * descr.h (struct pthread): Add pid field.
+       * allocatestack.c (allocate_stack): Initialize pid field in descriptor.
+       (__reclaim_stacks): Likewise.
+       * init.c (sigcancel_handler): If __ASSUME_CORRECT_SI_PID is defined
+       also check for PID of the signal source.
+       (__pthread_initialize_minimal_internal): Also initialize pid field
+       of initial thread's descriptor.
+       * pthread_cancel.c: Use tgkill instead of tkill if possible.
+       * sysdeps/unix/sysv/linux/fork.c: Likewise.
+       * sysdeps/unix/sysv/linux/pt-raise.c: Likewise.
+       * sysdeps/unix/sysv/linux/pthread_kill.c: Likewise.
+       * sysdeps/unix/sysv/linux/raise.c: Likewise.
+
 2003-07-05  Ulrich Drepper  <drepper@redhat.com>
 
        * sysdeps/pthread/bits/libc-lock.h (__libc_cleanup_push): Renamed.

diff --git a/nptl/allocatestack.c b/nptl/allocatestack.c
index 223f0e4..e042cf4 100644 (file)
--- a/nptl/allocatestack.c
+++ b/nptl/allocatestack.c
@@ -332,6 +332,9 @@ allocate_stack (const struct pthread_attr *attr, struct pthread **pdp,
       pd->header.sysinfo = THREAD_GETMEM (THREAD_SELF, header.sysinfo);
 #endif
 
+      /* The process ID is also the same as that of the caller.  */
+      pd->pid = THREAD_GETMEM (THREAD_SELF, pid);
+
       /* Allocate the DTV for this thread.  */
       if (_dl_allocate_tls (TLS_TPADJ (pd)) == NULL)
        /* Something went wrong.  */
@@ -464,6 +467,9 @@ allocate_stack (const struct pthread_attr *attr, struct pthread **pdp,
          pd->header.sysinfo = THREAD_GETMEM (THREAD_SELF, header.sysinfo);
 #endif
 
+         /* The process ID is also the same as that of the caller.  */
+         pd->pid = THREAD_GETMEM (THREAD_SELF, pid);
+
          /* Allocate the DTV for this thread.  */
          if (_dl_allocate_tls (TLS_TPADJ (pd)) == NULL)
            {
@@ -626,6 +632,9 @@ __reclaim_stacks (void)
          /* This marks the stack as free.  */
          curp->tid = 0;
 
+         /* The PID field must be initialized for the new process.  */
+         curp->pid = self->pid;
+
          /* Account for the size of the stack.  */
          stack_cache_actsize += curp->stackblock_size;
        }

diff --git a/nptl/descr.h b/nptl/descr.h
index 26ee42d..fb364b9 100644 (file)
--- a/nptl/descr.h
+++ b/nptl/descr.h
@@ -177,6 +177,9 @@ struct pthread
   /* Two-level array for the thread-specific data.  */
   struct pthread_key_data *specific[PTHREAD_KEY_1STLEVEL_SIZE];
 
+  /* Process ID - thread group ID in kernel speak.  */
+  pid_t pid;
+
   /* True if events must be reported.  */
   bool report_events;
 

diff --git a/nptl/init.c b/nptl/init.c
index abc7857..9c76773 100644 (file)
--- a/nptl/init.c
+++ b/nptl/init.c
@@ -139,10 +139,12 @@ sigcancel_handler (int sig, siginfo_t *si, void *ctx)
      correct and might even be a security problem.  Try to catch as
      many incorrect invocations as possible.  */
   if (sig != SIGCANCEL
+#ifdef __ASSUME_CORRECT_SI_PID
+      /* Kernels before 2.5.75 stored the thread ID and not the process
+        ID in si_pid so we skip this test.  */
+      || si->si_pid != THREAD_GETMEM (THREAD_SELF, pid)
+#endif
       || si->si_code != SI_TKILL)
-    /* XXX The Linux kernel currently does not report the correct PID
-       in the si->si_pid field.  Once this is changed another test
-       will be added.  */
     return;
 
   struct pthread *self = THREAD_SELF;
@@ -202,7 +204,7 @@ __pthread_initialize_minimal_internal (void)
   /* Minimal initialization of the thread descriptor.  */
   struct pthread *pd = THREAD_SELF;
   INTERNAL_SYSCALL_DECL (err);
-  pd->tid = INTERNAL_SYSCALL (set_tid_address, err, 1, &pd->tid);
+  pd->pid = pd->tid = INTERNAL_SYSCALL (set_tid_address, err, 1, &pd->tid);
   THREAD_SETMEM (pd, specific[0], &pd->specific_1stblock[0]);
   THREAD_SETMEM (pd, user_stack, true);
   if (LLL_LOCK_INITIALIZER != 0)

diff --git a/nptl/pthread_cancel.c b/nptl/pthread_cancel.c
index 43b65b6..9e3dfda 100644 (file)
--- a/nptl/pthread_cancel.c
+++ b/nptl/pthread_cancel.c
@@ -22,6 +22,7 @@
 #include "pthreadP.h"
 #include "atomic.h"
 #include <sysdep.h>
+#include <kernel-features.h>
 
 
 int
@@ -61,7 +62,21 @@ pthread_cancel (th)
             thread as canceled.  */
          INTERNAL_SYSCALL_DECL (err);
 
-         int val = INTERNAL_SYSCALL (tkill, err, 2, pd->tid, SIGCANCEL);
+         int val;
+#if __ASSUME_TGKILL
+         val = INTERNAL_SYSCALL (tgkill, err, 3,
+                                 THREAD_GETMEM (THREAD_SELF, pid), pd->tid,
+                                 SIGCANCEL);
+#else
+# ifdef __NR_tgkill
+         val = INTERNAL_SYSCALL (tgkill, err, 3,
+                                 THREAD_GETMEM (THREAD_SELF, pid), pd->tid,
+                                 SIGCANCEL);
+         if (INTERNAL_SYSCALL_ERROR_P (val, err)
+             && INTERNAL_SYSCALL_ERRNO (val, err) == ENOSYS)
+# endif
+           val = INTERNAL_SYSCALL (tkill, err, 2, pd->tid, SIGCANCEL);
+#endif
 
          if (INTERNAL_SYSCALL_ERROR_P (val, err))
            result = INTERNAL_SYSCALL_ERRNO (val, err);

diff --git a/nptl/sysdeps/unix/sysv/linux/fork.c b/nptl/sysdeps/unix/sysv/linux/fork.c
index 8bca6b4..43e1b43 100644 (file)
--- a/nptl/sysdeps/unix/sysv/linux/fork.c
+++ b/nptl/sysdeps/unix/sysv/linux/fork.c
@@ -134,6 +134,9 @@ __libc_fork (void)
       if (__fork_generation_pointer != NULL)
        *__fork_generation_pointer += 4;
 
+      /* Adjust the PID field for the new process.  */
+      self->pid = self->tid;
+
 #if HP_TIMING_AVAIL
       /* The CPU clock of the thread and process have to be set to zero.  */
       hp_timing_t now;

diff --git a/nptl/sysdeps/unix/sysv/linux/pt-raise.c b/nptl/sysdeps/unix/sysv/linux/pt-raise.c
index 0c68960..2efd761 100644 (file)
--- a/nptl/sysdeps/unix/sysv/linux/pt-raise.c
+++ b/nptl/sysdeps/unix/sysv/linux/pt-raise.c
@@ -1,4 +1,4 @@
-/* Copyright (C) 2002 Free Software Foundation, Inc.
+/* Copyright (C) 2002, 2003 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
    Contributed by Ulrich Drepper <drepper@redhat.com>, 2002.
 
@@ -21,11 +21,23 @@
 #include <signal.h>
 #include <sysdep.h>
 #include <tls.h>
+#include <kernel-features.h>
 
 
 int
 raise (sig)
      int sig;
 {
-  return INLINE_SYSCALL (tkill, 2, THREAD_SELF->tid, sig);
+#if __ASSUME_TGKILL
+  return INLINE_SYSCALL (tgkill, 3, THREAD_GETMEM (THREAD_SELF, pid),
+                        THREAD_GETMEM (THREAD_SELF, tid), sig);
+#else
+# ifdef __NR_tgkill
+  int res = INLINE_SYSCALL (tgkill, 3, THREAD_GETMEM (THREAD_SELF, pid),
+                           THREAD_GETMEM (THREAD_SELF, tid), sig);
+  if (res != -1 || errno != ENOSYS)
+    return res;
+# endif
+  return INLINE_SYSCALL (tkill, 2, THREAD_GETMEM (THREAD_SELF, tid), sig);
+#endif
 }

diff --git a/nptl/sysdeps/unix/sysv/linux/pthread_kill.c b/nptl/sysdeps/unix/sysv/linux/pthread_kill.c
index 8da195a..6967acd 100644 (file)
--- a/nptl/sysdeps/unix/sysv/linux/pthread_kill.c
+++ b/nptl/sysdeps/unix/sysv/linux/pthread_kill.c
@@ -22,6 +22,7 @@
 #include <pthreadP.h>
 #include <tls.h>
 #include <sysdep.h>
+#include <kernel-features.h>
 
 
 int
@@ -43,7 +44,19 @@ __pthread_kill (threadid, signo)
   /* We have a special syscall to do the work.  */
   INTERNAL_SYSCALL_DECL (err);
 
-  int val = INTERNAL_SYSCALL (tkill, err, 2, pd->tid, signo);
+  int val;
+#if __ASSUME_TGKILL
+  val = INTERNAL_SYSCALL (tgkill, err, 3, THREAD_GETMEM (THREAD_SELF, pid),
+                         pd->tid, signo);
+#else
+# ifdef __NR_tgkill
+  val = INTERNAL_SYSCALL (tgkill, err, 3, THREAD_GETMEM (THREAD_SELF, pid),
+                         pd->tid, signo);
+  if (INTERNAL_SYSCALL_ERROR_P (val, err)
+      && INTERNAL_SYSCALL_ERRNO (val, err) == ENOSYS)
+# endif
+    val = INTERNAL_SYSCALL (tkill, err, 2, pd->tid, signo);
+#endif
 
   return (INTERNAL_SYSCALL_ERROR_P (val, err)
          ? INTERNAL_SYSCALL_ERRNO (val, err) : 0);

diff --git a/nptl/sysdeps/unix/sysv/linux/raise.c b/nptl/sysdeps/unix/sysv/linux/raise.c
index 24a00b1..25d3ed8 100644 (file)
--- a/nptl/sysdeps/unix/sysv/linux/raise.c
+++ b/nptl/sysdeps/unix/sysv/linux/raise.c
@@ -21,6 +21,7 @@
 #include <signal.h>
 #include <sysdep.h>
 #include <nptl/pthreadP.h>
+#include <kernel-features.h>
 
 
 int
@@ -28,7 +29,7 @@ raise (sig)
      int sig;
 {
   struct pthread *pd = THREAD_SELF;
-  pid_t selftid = pd->tid;
+  pid_t selftid = THREAD_GETMEM (pd, tid);
   if (selftid == 0)
     {
       /* This system call is not supposed to fail.  */
@@ -39,9 +40,21 @@ raise (sig)
       selftid = INLINE_SYSCALL (gettid, 0);
 #endif
       THREAD_SETMEM (pd, tid, selftid);
+
+      /* In this case the TID and PID are the same.  */
+      THREAD_SETMEM (pd, pid, selftid);
     }
 
+#if __ASSUME_TGKILL
+  return INLINE_SYSCALL (tgkill, 3, THREAD_GETMEM (pd, pid), selftid, sig);
+#else
+# ifdef __NR_tgkill
+  int res = INLINE_SYSCALL (tgkill, 3, THREAD_GETMEM (pd, pid), selftid, sig);
+  if (res != -1 || errno != ENOSYS)
+    return res;
+# endif
   return INLINE_SYSCALL (tkill, 2, selftid, sig);
+#endif
 }
 libc_hidden_def (raise)
 weak_alias (raise, gsignal)

diff --git a/sysdeps/unix/sysv/linux/kernel-features.h b/sysdeps/unix/sysv/linux/kernel-features.h
index 256e77b..4d19238 100644 (file)
--- a/sysdeps/unix/sysv/linux/kernel-features.h
+++ b/sysdeps/unix/sysv/linux/kernel-features.h
@@ -333,3 +333,15 @@
 #if __LINUX_KERNEL_VERSION >= 132426
 # define __ASSUME_AT_SECURE    1
 #endif
+
+/* Starting with the 2.5.75 kernel the kernel fills in the correct value
+   in the si_pid field passed as part of the siginfo_t struct to signal
+   handlers.  */
+#if __LINUX_KERNEL_VERSION >= 132427
+# define __ASSUME_CORRECT_SI_PID       1
+#endif
+
+/* The tgkill syscall was instroduced for i386 in 2.5.75.  */
+#if __LINUX_KERNEL_VERSION >= 132427 && defined __i386__
+# define __ASSUME_TGKILL       1
+#endif