2005-12-21 Roland McGrath <roland@redhat.com>
[kopensolaris-gnu/glibc.git] / nptl / sysdeps / unix / sysv / linux / register-atfork.c
1 /* Copyright (C) 2002, 2003, 2005 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, write to the Free
17    Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
18    02111-1307 USA.  */
19
20 #include <errno.h>
21 #include <stdlib.h>
22 #include <string.h>
23 #include <fork.h>
24
25
26 /* Lock to protect allocation and deallocation of fork handlers.  */
27 lll_lock_t __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);
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       newp->next = __fork_handlers;
101       __fork_handlers = newp;
102     }
103
104   /* Release the lock.  */
105   lll_unlock (__fork_lock);
106
107   return newp == NULL ? ENOMEM : 0;
108 }
109 libc_hidden_def (__register_atfork)
110
111
112 libc_freeres_fn (free_mem)
113 {
114   /* Get the lock to not conflict with running forks.  */
115   lll_lock (__fork_lock);
116
117   /* No more fork handlers.  */
118   __fork_handlers = NULL;
119
120   /* Free eventually alloated memory blocks for the object pool.  */
121   struct fork_handler_pool *runp = fork_handler_pool.next;
122
123   memset (&fork_handler_pool, '\0', sizeof (fork_handler_pool));
124
125   /* Release the lock.  */
126   lll_unlock (__fork_lock);
127
128   /* We can free the memory after releasing the lock.  */
129   while (runp != NULL)
130     {
131       struct fork_handler_pool *oldp = runp;
132       runp = runp->next;
133       free (oldp);
134     }
135 }