nptl/sysdeps/unix/sysv/linux/register-atfork.c

   1 /* Copyright (C) 2002-2014 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 <errno.h>
  20 #include <stdlib.h>
  21 #include <string.h>
  22 #include <fork.h>
  23 #include <atomic.h>
  24
  25
  26 /* Lock to protect allocation and deallocation of fork handlers.  */
  27 int __fork_lock = LLL_LOCK_INITIALIZER;
  28
  29
  30 /* Number of pre-allocated handler entries.  */
  31 #define NHANDLER 48
  32
  33 /* Memory pool for fork handler structures.  */
  34 static struct fork_handler_pool
  35 {
  36   struct fork_handler_pool *next;
  37   struct fork_handler mem[NHANDLER];
  38 } fork_handler_pool;
  39
  40
  41 static struct fork_handler *
  42 fork_handler_alloc (void)
  43 {
  44   struct fork_handler_pool *runp = &fork_handler_pool;
  45   struct fork_handler *result = NULL;
  46   unsigned int i;
  47
  48   do
  49     {
  50       /* Search for an empty entry.  */
  51       for (i = 0; i < NHANDLER; ++i)
  52         if (runp->mem[i].refcntr == 0)
  53           goto found;
  54     }
  55   while ((runp = runp->next) != NULL);
  56
  57   /* We have to allocate a new entry.  */
  58   runp = (struct fork_handler_pool *) calloc (1, sizeof (*runp));
  59   if (runp != NULL)
  60     {
  61       /* Enqueue the new memory pool into the list.  */
  62       runp->next = fork_handler_pool.next;
  63       fork_handler_pool.next = runp;
  64
  65       /* We use the last entry on the page.  This means when we start
  66          searching from the front the next time we will find the first
  67          entry unused.  */
  68       i = NHANDLER - 1;
  69
  70     found:
  71       result = &runp->mem[i];
  72       result->refcntr = 1;
  73       result->need_signal = 0;
  74     }
  75
  76   return result;
  77 }
  78
  79
  80 int
  81 __register_atfork (prepare, parent, child, dso_handle)
  82      void (*prepare) (void);
  83      void (*parent) (void);
  84      void (*child) (void);
  85      void *dso_handle;
  86 {
  87   /* Get the lock to not conflict with other allocations.  */
  88   lll_lock (__fork_lock, LLL_PRIVATE);
  89
  90   struct fork_handler *newp = fork_handler_alloc ();
  91
  92   if (newp != NULL)
  93     {
  94       /* Initialize the new record.  */
  95       newp->prepare_handler = prepare;
  96       newp->parent_handler = parent;
  97       newp->child_handler = child;
  98       newp->dso_handle = dso_handle;
  99
 100       __linkin_atfork (newp);
 101     }
 102
 103   /* Release the lock.  */
 104   lll_unlock (__fork_lock, LLL_PRIVATE);
 105
 106   return newp == NULL ? ENOMEM : 0;
 107 }
 108 libc_hidden_def (__register_atfork)
 109
 110
 111 void
 112 attribute_hidden
 113 __linkin_atfork (struct fork_handler *newp)
 114 {
 115   do
 116     newp->next = __fork_handlers;
 117   while (catomic_compare_and_exchange_bool_acq (&__fork_handlers,
 118                                                 newp, newp->next) != 0);
 119 }
 120
 121
 122 libc_freeres_fn (free_mem)
 123 {
 124   /* Get the lock to not conflict with running forks.  */
 125   lll_lock (__fork_lock, LLL_PRIVATE);
 126
 127   /* No more fork handlers.  */
 128   __fork_handlers = NULL;
 129
 130   /* Free eventually allocated memory blocks for the object pool.  */
 131   struct fork_handler_pool *runp = fork_handler_pool.next;
 132
 133   memset (&fork_handler_pool, '\0', sizeof (fork_handler_pool));
 134
 135   /* Release the lock.  */
 136   lll_unlock (__fork_lock, LLL_PRIVATE);
 137
 138   /* We can free the memory after releasing the lock.  */
 139   while (runp != NULL)
 140     {
 141       struct fork_handler_pool *oldp = runp;
 142       runp = runp->next;
 143       free (oldp);
 144     }
 145 }