libpthread/nptl/sysdeps/unix/sysv/linux/fork.c

   1 /* Copyright (C) 2002, 2003, 2007, 2008 Free Software Foundation, Inc.
   2    This file is part of the GNU C Library.
   3    Contributed by Ulrich Drepper <drepper@redhat.com>, 2002.
   4
   5    The GNU C Library is free software; you can redistribute it and/or
   6    modify it under the terms of the GNU Lesser General Public
   7    License as published by the Free Software Foundation; either
   8    version 2.1 of the License, or (at your option) any later version.
   9
  10    The GNU C Library is distributed in the hope that it will be useful,
  11    but WITHOUT ANY WARRANTY; without even the implied warranty of
  12    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13    Lesser General Public License for more details.
  14
  15    You should have received a copy of the GNU Lesser General Public
  16    License along with the GNU C Library; if not, see
  17    <http://www.gnu.org/licenses/>.  */
  18
  19 #include <assert.h>
  20 #include <stdlib.h>
  21 #include <stdio.h>
  22 #include <unistd.h>
  23 #include <sys/types.h>
  24 #include <sysdep.h>
  25 #include <tls.h>
  26 #include "fork.h"
  27 #include <ldsodefs.h>
  28 #include <atomic.h>
  29 #include <errno.h>
  30
  31 unsigned long int *__fork_generation_pointer;
  32
  33
  34
  35 /* The single linked list of all currently registered for handlers.  */
  36 struct fork_handler *__fork_handlers;
  37
  38
  39 static void
  40 fresetlockfiles (void)
  41 {
  42   FILE *fp;
  43 #ifdef __USE_STDIO_FUTEXES__
  44   for (fp = _stdio_openlist; fp != NULL; fp = fp->__nextopen)
  45     STDIO_INIT_MUTEX(fp->__lock);
  46 #else
  47   pthread_mutexattr_t attr;
  48
  49   pthread_mutexattr_init(&attr);
  50   pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE_NP);
  51
  52   for (fp = _stdio_openlist; fp != NULL; fp = fp->__nextopen)
  53     pthread_mutex_init(&fp->__lock, &attr);
  54
  55   pthread_mutexattr_destroy(&attr);
  56 #endif
  57 }
  58
  59 pid_t
  60 #if defined __arm__ && defined __thumb__ && __GNUC_PREREQ (4,6)
  61 /* GCC PR target/53735
  62  * In thumb1 we run out of registers when compiling with Os so relax that
  63  * to have more registers available for spilling by using O2 here.
  64  */
  65 attribute_optimize("O2")
  66 #endif
  67 fork (void)
  68 {
  69   pid_t pid;
  70   struct used_handler
  71   {
  72     struct fork_handler *handler;
  73     struct used_handler *next;
  74   } *allp = NULL;
  75
  76   /* Run all the registered preparation handlers.  In reverse order.
  77      While doing this we build up a list of all the entries.  */
  78   struct fork_handler *runp;
  79   while ((runp = __fork_handlers) != NULL)
  80     {
  81       /* Make sure we read from the current RUNP pointer.  */
  82       atomic_full_barrier ();
  83
  84       unsigned int oldval = runp->refcntr;
  85
  86       if (oldval == 0)
  87         /* This means some other thread removed the list just after
  88            the pointer has been loaded.  Try again.  Either the list
  89            is empty or we can retry it.  */
  90         continue;
  91
  92       /* Bump the reference counter.  */
  93       if (atomic_compare_and_exchange_bool_acq (&__fork_handlers->refcntr,
  94                                                 oldval + 1, oldval))
  95         /* The value changed, try again.  */
  96         continue;
  97
  98       /* We bumped the reference counter for the first entry in the
  99          list.  That means that none of the following entries will
 100          just go away.  The unloading code works in the order of the
 101          list.
 102
 103          While executing the registered handlers we are building a
 104          list of all the entries so that we can go backward later on.  */
 105       while (1)
 106         {
 107           /* Execute the handler if there is one.  */
 108           if (runp->prepare_handler != NULL)
 109             runp->prepare_handler ();
 110
 111           /* Create a new element for the list.  */
 112           struct used_handler *newp
 113             = (struct used_handler *) alloca (sizeof (*newp));
 114           newp->handler = runp;
 115           newp->next = allp;
 116           allp = newp;
 117
 118           /* Advance to the next handler.  */
 119           runp = runp->next;
 120           if (runp == NULL)
 121             break;
 122
 123           /* Bump the reference counter for the next entry.  */
 124           atomic_increment (&runp->refcntr);
 125         }
 126
 127       /* We are done.  */
 128       break;
 129     }
 130
 131   __UCLIBC_IO_MUTEX_LOCK_CANCEL_UNSAFE(_stdio_openlist_add_lock);
 132
 133 #ifndef NDEBUG
 134   pid_t ppid = THREAD_GETMEM (THREAD_SELF, tid);
 135 #endif
 136
 137 #ifdef ARCH_FORK
 138   pid = ARCH_FORK ();
 139 #else
 140 # error "ARCH_FORK must be defined so that the CLONE_SETTID flag is used"
 141   pid = INLINE_SYSCALL (fork, 0);
 142 #endif
 143
 144
 145   if (pid == 0)
 146     {
 147       struct pthread *self = THREAD_SELF;
 148
 149       assert (THREAD_GETMEM (self, tid) != ppid);
 150
 151       if (__fork_generation_pointer != NULL)
 152         *__fork_generation_pointer += 4;
 153
 154       /* Reset the file list.  These are recursive mutexes.  */
 155       fresetlockfiles ();
 156
 157       /* Reset locks in the I/O code.  */
 158       STDIO_INIT_MUTEX(_stdio_openlist_add_lock);
 159
 160       /* XXX reset any locks in dynamic loader */
 161
 162       /* Run the handlers registered for the child.  */
 163       while (allp != NULL)
 164         {
 165           if (allp->handler->child_handler != NULL)
 166             allp->handler->child_handler ();
 167
 168           /* Note that we do not have to wake any possible waiter.
 169              This is the only thread in the new process.  The count
 170              may have been bumped up by other threads doing a fork.
 171              We reset it to 1, to avoid waiting for non-existing
 172              thread(s) to release the count.  */
 173           allp->handler->refcntr = 1;
 174
 175           /* XXX We could at this point look through the object pool
 176              and mark all objects not on the __fork_handlers list as
 177              unused.  This is necessary in case the fork() happened
 178              while another thread called dlclose() and that call had
 179              to create a new list.  */
 180
 181           allp = allp->next;
 182         }
 183
 184       /* Initialize the fork lock.  */
 185       __fork_lock = LLL_LOCK_INITIALIZER;
 186     }
 187   else
 188     {
 189       assert (THREAD_GETMEM (THREAD_SELF, tid) == ppid);
 190
 191       /* We execute this even if the 'fork' call failed.  */
 192       __UCLIBC_IO_MUTEX_UNLOCK_CANCEL_UNSAFE(_stdio_openlist_add_lock);
 193
 194       /* Run the handlers registered for the parent.  */
 195       while (allp != NULL)
 196         {
 197           if (allp->handler->parent_handler != NULL)
 198             allp->handler->parent_handler ();
 199
 200           if (atomic_decrement_and_test (&allp->handler->refcntr)
 201               && allp->handler->need_signal)
 202             lll_futex_wake (allp->handler->refcntr, 1, LLL_PRIVATE);
 203
 204           allp = allp->next;
 205         }
 206     }
 207
 208   return pid;
 209 }
 210 libc_hidden_def(fork)