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