1 /*
2 * CDDL HEADER START
3 *
4 * The contents of this file are subject to the terms of the
5 * Common Development and Distribution License (the "License").
6 * You may not use this file except in compliance with the License.
7 *
8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9 * or http://www.opensolaris.org/os/licensing.
10 * See the License for the specific language governing permissions
11 * and limitations under the License.
12 *
13 * When distributing Covered Code, include this CDDL HEADER in each
14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15 * If applicable, add the following below this CDDL HEADER, with the
16 * fields enclosed by brackets "[]" replaced with your own identifying
17 * information: Portions Copyright [yyyy] [name of copyright owner]
18 *
19 * CDDL HEADER END
20 */
21
22 /*
23 * Copyright 2008 Sun Microsystems, Inc. All rights reserved.
24 * Use is subject to license terms.
25 */
26
27 #include "umem_base.h"
28 #include "vmem_base.h"
29
30 #include <unistd.h>
31
32 /*
33 * The following functions are for pre- and post-fork1(2) handling. See
34 * "Lock Ordering" in lib/libumem/common/umem.c for the lock ordering used.
35 */
36
37 static void
umem_lockup_cache(umem_cache_t * cp)38 umem_lockup_cache(umem_cache_t *cp)
39 {
40 int idx;
41 int ncpus = cp->cache_cpu_mask + 1;
42
43 for (idx = 0; idx < ncpus; idx++)
44 (void) mutex_lock(&cp->cache_cpu[idx].cc_lock);
45
46 (void) mutex_lock(&cp->cache_depot_lock);
47 (void) mutex_lock(&cp->cache_lock);
48 }
49
50 static void
umem_release_cache(umem_cache_t * cp)51 umem_release_cache(umem_cache_t *cp)
52 {
53 int idx;
54 int ncpus = cp->cache_cpu_mask + 1;
55
56 (void) mutex_unlock(&cp->cache_lock);
57 (void) mutex_unlock(&cp->cache_depot_lock);
58
59 for (idx = 0; idx < ncpus; idx++)
60 (void) mutex_unlock(&cp->cache_cpu[idx].cc_lock);
61 }
62
63 static void
umem_lockup_log_header(umem_log_header_t * lhp)64 umem_lockup_log_header(umem_log_header_t *lhp)
65 {
66 int idx;
67 if (lhp == NULL)
68 return;
69 for (idx = 0; idx < umem_max_ncpus; idx++)
70 (void) mutex_lock(&lhp->lh_cpu[idx].clh_lock);
71
72 (void) mutex_lock(&lhp->lh_lock);
73 }
74
75 static void
umem_release_log_header(umem_log_header_t * lhp)76 umem_release_log_header(umem_log_header_t *lhp)
77 {
78 int idx;
79 if (lhp == NULL)
80 return;
81
82 (void) mutex_unlock(&lhp->lh_lock);
83
84 for (idx = 0; idx < umem_max_ncpus; idx++)
85 (void) mutex_unlock(&lhp->lh_cpu[idx].clh_lock);
86 }
87
88 static void
umem_lockup(void)89 umem_lockup(void)
90 {
91 umem_cache_t *cp;
92
93 (void) mutex_lock(&umem_init_lock);
94 /*
95 * If another thread is busy initializing the library, we must
96 * wait for it to complete (by calling umem_init()) before allowing
97 * the fork() to proceed.
98 */
99 if (umem_ready == UMEM_READY_INITING && umem_init_thr != thr_self()) {
100 (void) mutex_unlock(&umem_init_lock);
101 (void) umem_init();
102 (void) mutex_lock(&umem_init_lock);
103 }
104
105 vmem_lockup();
106 vmem_sbrk_lockup();
107
108 (void) mutex_lock(&umem_cache_lock);
109 (void) mutex_lock(&umem_update_lock);
110 (void) mutex_lock(&umem_flags_lock);
111
112 umem_lockup_cache(&umem_null_cache);
113 for (cp = umem_null_cache.cache_prev; cp != &umem_null_cache;
114 cp = cp->cache_prev)
115 umem_lockup_cache(cp);
116
117 umem_lockup_log_header(umem_transaction_log);
118 umem_lockup_log_header(umem_content_log);
119 umem_lockup_log_header(umem_failure_log);
120 umem_lockup_log_header(umem_slab_log);
121
122 (void) cond_broadcast(&umem_update_cv);
123
124 }
125
126 static void
umem_do_release(int as_child)127 umem_do_release(int as_child)
128 {
129 umem_cache_t *cp;
130 int cleanup_update = 0;
131
132 /*
133 * Clean up the update state if we are the child process and
134 * another thread was processing updates.
135 */
136 if (as_child) {
137 if (umem_update_thr != thr_self()) {
138 umem_update_thr = 0;
139 cleanup_update = 1;
140 }
141 if (umem_st_update_thr != thr_self()) {
142 umem_st_update_thr = 0;
143 cleanup_update = 1;
144 }
145 }
146
147 if (cleanup_update) {
148 umem_reaping = UMEM_REAP_DONE;
149
150 for (cp = umem_null_cache.cache_next; cp != &umem_null_cache;
151 cp = cp->cache_next) {
152 if (cp->cache_uflags & UMU_NOTIFY)
153 cp->cache_uflags &= ~UMU_NOTIFY;
154
155 /*
156 * If the cache is active, we just re-add it to
157 * the update list. This will re-do any active
158 * updates on the cache, but that won't break
159 * anything.
160 *
161 * The worst that can happen is a cache has
162 * its magazines rescaled twice, instead of once.
163 */
164 if (cp->cache_uflags & UMU_ACTIVE) {
165 umem_cache_t *cnext, *cprev;
166
167 ASSERT(cp->cache_unext == NULL &&
168 cp->cache_uprev == NULL);
169
170 cp->cache_uflags &= ~UMU_ACTIVE;
171 cp->cache_unext = cnext = &umem_null_cache;
172 cp->cache_uprev = cprev =
173 umem_null_cache.cache_uprev;
174 cnext->cache_uprev = cp;
175 cprev->cache_unext = cp;
176 }
177 }
178 }
179
180 umem_release_log_header(umem_slab_log);
181 umem_release_log_header(umem_failure_log);
182 umem_release_log_header(umem_content_log);
183 umem_release_log_header(umem_transaction_log);
184
185 for (cp = umem_null_cache.cache_next; cp != &umem_null_cache;
186 cp = cp->cache_next)
187 umem_release_cache(cp);
188 umem_release_cache(&umem_null_cache);
189
190 (void) mutex_unlock(&umem_flags_lock);
191 (void) mutex_unlock(&umem_update_lock);
192 (void) mutex_unlock(&umem_cache_lock);
193
194 vmem_sbrk_release();
195 vmem_release();
196
197 (void) mutex_unlock(&umem_init_lock);
198 }
199
200 static void
umem_release(void)201 umem_release(void)
202 {
203 umem_do_release(0);
204 }
205
206 static void
umem_release_child(void)207 umem_release_child(void)
208 {
209 umem_do_release(1);
210 }
211
212 void
umem_forkhandler_init(void)213 umem_forkhandler_init(void)
214 {
215 /*
216 * There is no way to unregister these atfork functions,
217 * but we don't need to. The dynamic linker and libc take
218 * care of unregistering them if/when the library is unloaded.
219 */
220 (void) pthread_atfork(umem_lockup, umem_release, umem_release_child);
221 }
222