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