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 <assert.h> |
20 | #include <stdlib.h> |
21 | #include <unistd.h> |
22 | #include <sys/types.h> |
23 | #include <sysdep.h> |
24 | #include <libio/libioP.h> |
25 | #include <tls.h> |
26 | #include <hp-timing.h> |
27 | #include <ldsodefs.h> |
28 | #include <stdio-lock.h> |
29 | #include <atomic.h> |
30 | #include <nptl/pthreadP.h> |
31 | #include <fork.h> |
32 | #include <arch-fork.h> |
33 | #include <futex-internal.h> |
34 | #include <malloc/malloc-internal.h> |
35 | |
36 | static void |
37 | fresetlockfiles (void) |
38 | { |
39 | _IO_ITER i; |
40 | |
41 | for (i = _IO_iter_begin(); i != _IO_iter_end(); i = _IO_iter_next(i)) |
42 | if ((_IO_iter_file (i)->_flags & _IO_USER_LOCK) == 0) |
43 | _IO_lock_init (*((_IO_lock_t *) _IO_iter_file(i)->_lock)); |
44 | } |
45 | |
46 | |
47 | pid_t |
48 | __libc_fork (void) |
49 | { |
50 | pid_t pid; |
51 | struct used_handler |
52 | { |
53 | struct fork_handler *handler; |
54 | struct used_handler *next; |
55 | } *allp = NULL; |
56 | |
57 | /* Determine if we are running multiple threads. We skip some fork |
58 | handlers in the single-thread case, to make fork safer to use in |
59 | signal handlers. POSIX requires that fork is async-signal-safe, |
60 | but our current fork implementation is not. */ |
61 | bool multiple_threads = THREAD_GETMEM (THREAD_SELF, header.multiple_threads); |
62 | |
63 | /* Run all the registered preparation handlers. In reverse order. |
64 | While doing this we build up a list of all the entries. */ |
65 | struct fork_handler *runp; |
66 | while ((runp = __fork_handlers) != NULL) |
67 | { |
68 | /* Make sure we read from the current RUNP pointer. */ |
69 | atomic_full_barrier (); |
70 | |
71 | unsigned int oldval = runp->refcntr; |
72 | |
73 | if (oldval == 0) |
74 | /* This means some other thread removed the list just after |
75 | the pointer has been loaded. Try again. Either the list |
76 | is empty or we can retry it. */ |
77 | continue; |
78 | |
79 | /* Bump the reference counter. */ |
80 | if (atomic_compare_and_exchange_bool_acq (&__fork_handlers->refcntr, |
81 | oldval + 1, oldval)) |
82 | /* The value changed, try again. */ |
83 | continue; |
84 | |
85 | /* We bumped the reference counter for the first entry in the |
86 | list. That means that none of the following entries will |
87 | just go away. The unloading code works in the order of the |
88 | list. |
89 | |
90 | While executing the registered handlers we are building a |
91 | list of all the entries so that we can go backward later on. */ |
92 | while (1) |
93 | { |
94 | /* Execute the handler if there is one. */ |
95 | if (runp->prepare_handler != NULL) |
96 | runp->prepare_handler (); |
97 | |
98 | /* Create a new element for the list. */ |
99 | struct used_handler *newp |
100 | = (struct used_handler *) alloca (sizeof (*newp)); |
101 | newp->handler = runp; |
102 | newp->next = allp; |
103 | allp = newp; |
104 | |
105 | /* Advance to the next handler. */ |
106 | runp = runp->next; |
107 | if (runp == NULL) |
108 | break; |
109 | |
110 | /* Bump the reference counter for the next entry. */ |
111 | atomic_increment (&runp->refcntr); |
112 | } |
113 | |
114 | /* We are done. */ |
115 | break; |
116 | } |
117 | |
118 | /* If we are not running multiple threads, we do not have to |
119 | preserve lock state. If fork runs from a signal handler, only |
120 | async-signal-safe functions can be used in the child. These data |
121 | structures are only used by unsafe functions, so their state does |
122 | not matter if fork was called from a signal handler. */ |
123 | if (multiple_threads) |
124 | { |
125 | _IO_list_lock (); |
126 | |
127 | /* Acquire malloc locks. This needs to come last because fork |
128 | handlers may use malloc, and the libio list lock has an |
129 | indirect malloc dependency as well (via the getdelim |
130 | function). */ |
131 | call_function_static_weak (__malloc_fork_lock_parent); |
132 | } |
133 | |
134 | #ifdef ARCH_FORK |
135 | pid = ARCH_FORK (); |
136 | #else |
137 | # error "ARCH_FORK must be defined so that the CLONE_SETTID flag is used" |
138 | pid = INLINE_SYSCALL (fork, 0); |
139 | #endif |
140 | |
141 | |
142 | if (pid == 0) |
143 | { |
144 | struct pthread *self = THREAD_SELF; |
145 | |
146 | /* See __pthread_once. */ |
147 | if (__fork_generation_pointer != NULL) |
148 | *__fork_generation_pointer += __PTHREAD_ONCE_FORK_GEN_INCR; |
149 | |
150 | #if HP_TIMING_AVAIL |
151 | /* The CPU clock of the thread and process have to be set to zero. */ |
152 | hp_timing_t now; |
153 | HP_TIMING_NOW (now); |
154 | THREAD_SETMEM (self, cpuclock_offset, now); |
155 | GL(dl_cpuclock_offset) = now; |
156 | #endif |
157 | |
158 | #ifdef __NR_set_robust_list |
159 | /* Initialize the robust mutex list setting in the kernel which has |
160 | been reset during the fork. We do not check for errors because if |
161 | it fails here, it must have failed at process startup as well and |
162 | nobody could have used robust mutexes. |
163 | Before we do that, we have to clear the list of robust mutexes |
164 | because we do not inherit ownership of mutexes from the parent. |
165 | We do not have to set self->robust_head.futex_offset since we do |
166 | inherit the correct value from the parent. We do not need to clear |
167 | the pending operation because it must have been zero when fork was |
168 | called. */ |
169 | # if __PTHREAD_MUTEX_HAVE_PREV |
170 | self->robust_prev = &self->robust_head; |
171 | # endif |
172 | self->robust_head.list = &self->robust_head; |
173 | # ifdef SHARED |
174 | if (__builtin_expect (__libc_pthread_functions_init, 0)) |
175 | PTHFCT_CALL (ptr_set_robust, (self)); |
176 | # else |
177 | extern __typeof (__nptl_set_robust) __nptl_set_robust |
178 | __attribute__((weak)); |
179 | if (__builtin_expect (__nptl_set_robust != NULL, 0)) |
180 | __nptl_set_robust (self); |
181 | # endif |
182 | #endif |
183 | |
184 | /* Reset the lock state in the multi-threaded case. */ |
185 | if (multiple_threads) |
186 | { |
187 | /* Release malloc locks. */ |
188 | call_function_static_weak (__malloc_fork_unlock_child); |
189 | |
190 | /* Reset the file list. These are recursive mutexes. */ |
191 | fresetlockfiles (); |
192 | |
193 | /* Reset locks in the I/O code. */ |
194 | _IO_list_resetlock (); |
195 | } |
196 | |
197 | /* Reset the lock the dynamic loader uses to protect its data. */ |
198 | __rtld_lock_initialize (GL(dl_load_lock)); |
199 | |
200 | /* Run the handlers registered for the child. */ |
201 | while (allp != NULL) |
202 | { |
203 | if (allp->handler->child_handler != NULL) |
204 | allp->handler->child_handler (); |
205 | |
206 | /* Note that we do not have to wake any possible waiter. |
207 | This is the only thread in the new process. The count |
208 | may have been bumped up by other threads doing a fork. |
209 | We reset it to 1, to avoid waiting for non-existing |
210 | thread(s) to release the count. */ |
211 | allp->handler->refcntr = 1; |
212 | |
213 | /* XXX We could at this point look through the object pool |
214 | and mark all objects not on the __fork_handlers list as |
215 | unused. This is necessary in case the fork() happened |
216 | while another thread called dlclose() and that call had |
217 | to create a new list. */ |
218 | |
219 | allp = allp->next; |
220 | } |
221 | |
222 | /* Initialize the fork lock. */ |
223 | __fork_lock = LLL_LOCK_INITIALIZER; |
224 | } |
225 | else |
226 | { |
227 | /* Release acquired locks in the multi-threaded case. */ |
228 | if (multiple_threads) |
229 | { |
230 | /* Release malloc locks, parent process variant. */ |
231 | call_function_static_weak (__malloc_fork_unlock_parent); |
232 | |
233 | /* We execute this even if the 'fork' call failed. */ |
234 | _IO_list_unlock (); |
235 | } |
236 | |
237 | /* Run the handlers registered for the parent. */ |
238 | while (allp != NULL) |
239 | { |
240 | if (allp->handler->parent_handler != NULL) |
241 | allp->handler->parent_handler (); |
242 | |
243 | if (atomic_decrement_and_test (&allp->handler->refcntr) |
244 | && allp->handler->need_signal) |
245 | futex_wake (&allp->handler->refcntr, 1, FUTEX_PRIVATE); |
246 | |
247 | allp = allp->next; |
248 | } |
249 | } |
250 | |
251 | return pid; |
252 | } |
253 | weak_alias (__libc_fork, __fork) |
254 | libc_hidden_def (__fork) |
255 | weak_alias (__libc_fork, fork) |
256 | |