xref: /openbsd-src/lib/librthread/rthread_fork.c (revision 4c1e55dc91edd6e69ccc60ce855900fbc12cf34f)
1 /*	$OpenBSD: rthread_fork.c,v 1.4 2011/11/06 11:48:59 guenther Exp $ */
2 
3 /*
4  * Copyright (c) 2008 Kurt Miller <kurt@openbsd.org>
5  * Copyright (c) 2008 Philip Guenther <guenther@gmail.com>
6  * Copyright (c) 2003 Daniel Eischen <deischen@freebsd.org>
7  * All rights reserved.
8  *
9  * Redistribution and use in source and binary forms, with or without
10  * modification, are permitted provided that the following conditions
11  * are met:
12  * 1. Redistributions of source code must retain the above copyright
13  *    notice, this list of conditions and the following disclaimer.
14  * 2. Neither the name of the author nor the names of any co-contributors
15  *    may be used to endorse or promote products derived from this software
16  *    without specific prior written permission.
17  *
18  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
19  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
20  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
21  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
22  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
23  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
24  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
25  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
26  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
27  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
28  * SUCH DAMAGE.
29  *
30  * $FreeBSD: /repoman/r/ncvs/src/lib/libc_r/uthread/uthread_atfork.c,v 1.1 2004/12/10 03:36:45 grog Exp $
31  */
32 
33 #include <errno.h>
34 #include <pthread.h>
35 #include <stdlib.h>
36 #include <unistd.h>
37 
38 #include "thread_private.h"	/* in libc/include */
39 
40 #include "rthread.h"
41 
42 struct rthread_atfork {
43 	TAILQ_ENTRY(rthread_atfork) next;
44 	void (*prepare)(void);
45 	void (*parent)(void);
46 	void (*child)(void);
47 };
48 
49 static TAILQ_HEAD(atfork_listhead, rthread_atfork) _atfork_list =
50     TAILQ_HEAD_INITIALIZER(_atfork_list);
51 
52 static _spinlock_lock_t _atfork_lock = _SPINLOCK_UNLOCKED;
53 
54 pid_t   _thread_sys_fork(void);
55 pid_t   _thread_sys_vfork(void);
56 pid_t	_dofork(int);
57 
58 pid_t
59 _dofork(int is_vfork)
60 {
61 	pthread_t me;
62 	pid_t (*sys_fork)(void);
63 	pid_t newid;
64 
65 	sys_fork = is_vfork ? &_thread_sys_vfork : &_thread_sys_fork;
66 
67 	if (!_threads_ready)
68 		return sys_fork();
69 
70 	me = pthread_self();
71 
72 	/*
73 	 * Protect important libc/ld.so critical areas across the fork call.
74 	 * dlclose() will grab the atexit lock via __cxa_finalize() so lock
75 	 * the dl_lock first. malloc()/free() can grab the arc4 lock so lock
76 	 * malloc_lock first. Finally lock the bind_lock last so that any lazy
77 	 * binding in the other locking functions can succeed.
78 	 */
79 
80 #if defined(__ELF__) && defined(PIC)
81 	_rthread_dl_lock(0);
82 #endif
83 
84 	_thread_atexit_lock();
85 	_thread_malloc_lock();
86 	_thread_arc4_lock();
87 
88 #if defined(__ELF__) && defined(PIC)
89 	_rthread_bind_lock(0);
90 #endif
91 
92 	newid = sys_fork();
93 
94 #if defined(__ELF__) && defined(PIC)
95 	_rthread_bind_lock(1);
96 #endif
97 
98 	_thread_arc4_unlock();
99 	_thread_malloc_unlock();
100 	_thread_atexit_unlock();
101 
102 #if defined(__ELF__) && defined(PIC)
103 	_rthread_dl_lock(1);
104 #endif
105 
106 	if (newid == 0) {
107 		/* update this thread's structure */
108 		me->tid = getthrid();
109 		me->donesem.lock = _SPINLOCK_UNLOCKED;
110 		me->flags &= ~THREAD_DETACHED;
111 		me->flags_lock = _SPINLOCK_UNLOCKED;
112 
113 		/* this thread is the initial thread for the new process */
114 		_initial_thread = *me;
115 
116 		/* reinit the thread list */
117 		LIST_INIT(&_thread_list);
118 		LIST_INSERT_HEAD(&_thread_list, &_initial_thread, threads);
119 		_thread_lock = _SPINLOCK_UNLOCKED;
120 
121 		/* single threaded now */
122 		__isthreaded = 0;
123 	}
124 	return newid;
125 }
126 
127 pid_t
128 fork(void)
129 {
130 	struct rthread_atfork *p;
131 	pid_t newid;
132 
133 	_spinlock(&_atfork_lock);
134 	TAILQ_FOREACH_REVERSE(p, &_atfork_list, atfork_listhead, next)
135 		if (p->prepare)
136 			p->prepare();
137 	newid = _dofork(0);
138 	if (newid == 0) {
139 		TAILQ_FOREACH(p, &_atfork_list, next)
140 			if (p->child)
141 				p->child();
142 	} else {
143 		TAILQ_FOREACH(p, &_atfork_list, next)
144 			if (p->parent)
145 				p->parent();
146 	}
147 	_spinunlock(&_atfork_lock);
148 	return newid;
149 }
150 
151 pid_t
152 vfork(void)
153 {
154 	return _dofork(1);
155 }
156 
157 int
158 pthread_atfork(void (*prepare)(void), void (*parent)(void),
159     void (*child)(void))
160 {
161 	struct rthread_atfork *af;
162 
163 	if ((af = malloc(sizeof *af)) == NULL)
164 		return (ENOMEM);
165 
166 	af->prepare = prepare;
167 	af->parent = parent;
168 	af->child = child;
169 	_spinlock(&_atfork_lock);
170 	TAILQ_INSERT_TAIL(&_atfork_list, af, next);
171 	_spinunlock(&_atfork_lock);
172 	return (0);
173 }
174