Print this page
2916 DTrace in a zone should be able to access fds[]
| Split |
Close |
| Expand all |
| Collapse all |
--- old/usr/src/uts/common/os/dtrace_subr.c
+++ new/usr/src/uts/common/os/dtrace_subr.c
1 1 /*
2 2 * CDDL HEADER START
3 3 *
4 4 * The contents of this file are subject to the terms of the
5 5 * Common Development and Distribution License (the "License").
6 6 * You may not use this file except in compliance with the License.
7 7 *
8 8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9 9 * or http://www.opensolaris.org/os/licensing.
10 10 * See the License for the specific language governing permissions
11 11 * and limitations under the License.
12 12 *
13 13 * When distributing Covered Code, include this CDDL HEADER in each
14 14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15 15 * If applicable, add the following below this CDDL HEADER, with the
16 16 * fields enclosed by brackets "[]" replaced with your own identifying
17 17 * information: Portions Copyright [yyyy] [name of copyright owner]
18 18 *
19 19 * CDDL HEADER END
20 20 */
21 21
22 22 /*
23 23 * Copyright 2009 Sun Microsystems, Inc. All rights reserved.
24 24 * Use is subject to license terms.
25 25 */
26 26
27 27 #include <sys/dtrace.h>
28 28 #include <sys/cmn_err.h>
29 29 #include <sys/tnf.h>
30 30 #include <sys/atomic.h>
31 31 #include <sys/prsystm.h>
32 32 #include <sys/modctl.h>
33 33 #include <sys/aio_impl.h>
34 34
35 35 #ifdef __sparc
36 36 #include <sys/privregs.h>
|
↓ open down ↓ |
36 lines elided |
↑ open up ↑ |
37 37 #endif
38 38
39 39 void (*dtrace_cpu_init)(processorid_t);
40 40 void (*dtrace_modload)(struct modctl *);
41 41 void (*dtrace_modunload)(struct modctl *);
42 42 void (*dtrace_helpers_cleanup)(void);
43 43 void (*dtrace_helpers_fork)(proc_t *, proc_t *);
44 44 void (*dtrace_cpustart_init)(void);
45 45 void (*dtrace_cpustart_fini)(void);
46 46 void (*dtrace_cpc_fire)(uint64_t);
47 +void (*dtrace_closef)(void);
47 48
48 49 void (*dtrace_debugger_init)(void);
49 50 void (*dtrace_debugger_fini)(void);
50 51
51 52 dtrace_vtime_state_t dtrace_vtime_active = 0;
52 53 dtrace_cacheid_t dtrace_predcache_id = DTRACE_CACHEIDNONE + 1;
53 54
54 55 /*
55 56 * dtrace_cpc_in_use usage statement: this global variable is used by the cpc
56 57 * hardware overflow interrupt handler and the kernel cpc framework to check
57 58 * whether or not the DTrace cpc provider is currently in use. The variable is
58 59 * set before counters are enabled with the first enabling and cleared when
59 60 * the last enabling is disabled. Its value at any given time indicates the
60 61 * number of active dcpc based enablings. The global 'kcpc_cpuctx_lock' rwlock
61 62 * is held during initial setting to protect races between kcpc_open() and the
62 63 * first enabling. The locking provided by the DTrace subsystem, the kernel
63 64 * cpc framework and the cpu management framework protect consumers from race
64 65 * conditions on enabling and disabling probes.
65 66 */
66 67 uint32_t dtrace_cpc_in_use = 0;
67 68
68 69 typedef struct dtrace_hrestime {
69 70 lock_t dthr_lock; /* lock for this element */
70 71 timestruc_t dthr_hrestime; /* hrestime value */
71 72 int64_t dthr_adj; /* hrestime_adj value */
72 73 hrtime_t dthr_hrtime; /* hrtime value */
73 74 } dtrace_hrestime_t;
74 75
75 76 static dtrace_hrestime_t dtrace_hrestime[2];
76 77
77 78 /*
78 79 * Making available adjustable high-resolution time in DTrace is regrettably
79 80 * more complicated than one might think it should be. The problem is that
80 81 * the variables related to adjusted high-resolution time (hrestime,
81 82 * hrestime_adj and friends) are adjusted under hres_lock -- and this lock may
82 83 * be held when we enter probe context. One might think that we could address
83 84 * this by having a single snapshot copy that is stored under a different lock
84 85 * from hres_tick(), using the snapshot iff hres_lock is locked in probe
85 86 * context. Unfortunately, this too won't work: because hres_lock is grabbed
86 87 * in more than just hres_tick() context, we could enter probe context
87 88 * concurrently on two different CPUs with both locks (hres_lock and the
88 89 * snapshot lock) held. As this implies, the fundamental problem is that we
89 90 * need to have access to a snapshot of these variables that we _know_ will
90 91 * not be locked in probe context. To effect this, we have two snapshots
91 92 * protected by two different locks, and we mandate that these snapshots are
92 93 * recorded in succession by a single thread calling dtrace_hres_tick(). (We
93 94 * assure this by calling it out of the same CY_HIGH_LEVEL cyclic that calls
94 95 * hres_tick().) A single thread can't be in two places at once: one of the
95 96 * snapshot locks is guaranteed to be unheld at all times. The
96 97 * dtrace_gethrestime() algorithm is thus to check first one snapshot and then
97 98 * the other to find the unlocked snapshot.
98 99 */
99 100 void
100 101 dtrace_hres_tick(void)
101 102 {
102 103 int i;
103 104 ushort_t spl;
104 105
105 106 for (i = 0; i < 2; i++) {
106 107 dtrace_hrestime_t tmp;
107 108
108 109 spl = hr_clock_lock();
109 110 tmp.dthr_hrestime = hrestime;
110 111 tmp.dthr_adj = hrestime_adj;
111 112 tmp.dthr_hrtime = dtrace_gethrtime();
112 113 hr_clock_unlock(spl);
113 114
114 115 lock_set(&dtrace_hrestime[i].dthr_lock);
115 116 dtrace_hrestime[i].dthr_hrestime = tmp.dthr_hrestime;
116 117 dtrace_hrestime[i].dthr_adj = tmp.dthr_adj;
117 118 dtrace_hrestime[i].dthr_hrtime = tmp.dthr_hrtime;
118 119 dtrace_membar_producer();
119 120
120 121 /*
121 122 * To allow for lock-free examination of this lock, we use
122 123 * the same trick that is used hres_lock; for more details,
123 124 * see the description of this technique in sun4u/sys/clock.h.
124 125 */
125 126 dtrace_hrestime[i].dthr_lock++;
126 127 }
127 128 }
128 129
129 130 hrtime_t
130 131 dtrace_gethrestime(void)
131 132 {
132 133 dtrace_hrestime_t snap;
133 134 hrtime_t now;
134 135 int i = 0, adj, nslt;
135 136
136 137 for (;;) {
137 138 snap.dthr_lock = dtrace_hrestime[i].dthr_lock;
138 139 dtrace_membar_consumer();
139 140 snap.dthr_hrestime = dtrace_hrestime[i].dthr_hrestime;
140 141 snap.dthr_hrtime = dtrace_hrestime[i].dthr_hrtime;
141 142 snap.dthr_adj = dtrace_hrestime[i].dthr_adj;
142 143 dtrace_membar_consumer();
143 144
144 145 if ((snap.dthr_lock & ~1) == dtrace_hrestime[i].dthr_lock)
145 146 break;
146 147
147 148 /*
148 149 * If we're here, the lock was either locked, or it
149 150 * transitioned while we were taking the snapshot. Either
150 151 * way, we're going to try the other dtrace_hrestime element;
151 152 * we know that it isn't possible for both to be locked
152 153 * simultaneously, so we will ultimately get a good snapshot.
153 154 */
154 155 i ^= 1;
155 156 }
156 157
157 158 /*
158 159 * We have a good snapshot. Now perform any necessary adjustments.
159 160 */
160 161 nslt = dtrace_gethrtime() - snap.dthr_hrtime;
161 162 ASSERT(nslt >= 0);
162 163
163 164 now = ((hrtime_t)snap.dthr_hrestime.tv_sec * (hrtime_t)NANOSEC) +
164 165 snap.dthr_hrestime.tv_nsec;
165 166
166 167 if (snap.dthr_adj != 0) {
167 168 if (snap.dthr_adj > 0) {
168 169 adj = (nslt >> adj_shift);
169 170 if (adj > snap.dthr_adj)
170 171 adj = (int)snap.dthr_adj;
171 172 } else {
172 173 adj = -(nslt >> adj_shift);
173 174 if (adj < snap.dthr_adj)
174 175 adj = (int)snap.dthr_adj;
175 176 }
176 177 now += adj;
177 178 }
178 179
179 180 return (now);
180 181 }
181 182
182 183 void
183 184 dtrace_vtime_enable(void)
184 185 {
185 186 dtrace_vtime_state_t state, nstate;
186 187
187 188 do {
188 189 state = dtrace_vtime_active;
189 190
190 191 switch (state) {
191 192 case DTRACE_VTIME_INACTIVE:
192 193 nstate = DTRACE_VTIME_ACTIVE;
193 194 break;
194 195
195 196 case DTRACE_VTIME_INACTIVE_TNF:
196 197 nstate = DTRACE_VTIME_ACTIVE_TNF;
197 198 break;
198 199
199 200 case DTRACE_VTIME_ACTIVE:
200 201 case DTRACE_VTIME_ACTIVE_TNF:
201 202 panic("DTrace virtual time already enabled");
202 203 /*NOTREACHED*/
203 204 }
204 205
205 206 } while (cas32((uint32_t *)&dtrace_vtime_active,
206 207 state, nstate) != state);
207 208 }
208 209
209 210 void
210 211 dtrace_vtime_disable(void)
211 212 {
212 213 dtrace_vtime_state_t state, nstate;
213 214
214 215 do {
215 216 state = dtrace_vtime_active;
216 217
217 218 switch (state) {
218 219 case DTRACE_VTIME_ACTIVE:
219 220 nstate = DTRACE_VTIME_INACTIVE;
220 221 break;
221 222
222 223 case DTRACE_VTIME_ACTIVE_TNF:
223 224 nstate = DTRACE_VTIME_INACTIVE_TNF;
224 225 break;
225 226
226 227 case DTRACE_VTIME_INACTIVE:
227 228 case DTRACE_VTIME_INACTIVE_TNF:
228 229 panic("DTrace virtual time already disabled");
229 230 /*NOTREACHED*/
230 231 }
231 232
232 233 } while (cas32((uint32_t *)&dtrace_vtime_active,
233 234 state, nstate) != state);
234 235 }
235 236
236 237 void
237 238 dtrace_vtime_enable_tnf(void)
238 239 {
239 240 dtrace_vtime_state_t state, nstate;
240 241
241 242 do {
242 243 state = dtrace_vtime_active;
243 244
244 245 switch (state) {
245 246 case DTRACE_VTIME_ACTIVE:
246 247 nstate = DTRACE_VTIME_ACTIVE_TNF;
247 248 break;
248 249
249 250 case DTRACE_VTIME_INACTIVE:
250 251 nstate = DTRACE_VTIME_INACTIVE_TNF;
251 252 break;
252 253
253 254 case DTRACE_VTIME_ACTIVE_TNF:
254 255 case DTRACE_VTIME_INACTIVE_TNF:
255 256 panic("TNF already active");
256 257 /*NOTREACHED*/
257 258 }
258 259
259 260 } while (cas32((uint32_t *)&dtrace_vtime_active,
260 261 state, nstate) != state);
261 262 }
262 263
263 264 void
264 265 dtrace_vtime_disable_tnf(void)
265 266 {
266 267 dtrace_vtime_state_t state, nstate;
267 268
268 269 do {
269 270 state = dtrace_vtime_active;
270 271
271 272 switch (state) {
272 273 case DTRACE_VTIME_ACTIVE_TNF:
273 274 nstate = DTRACE_VTIME_ACTIVE;
274 275 break;
275 276
276 277 case DTRACE_VTIME_INACTIVE_TNF:
277 278 nstate = DTRACE_VTIME_INACTIVE;
278 279 break;
279 280
280 281 case DTRACE_VTIME_ACTIVE:
281 282 case DTRACE_VTIME_INACTIVE:
282 283 panic("TNF already inactive");
283 284 /*NOTREACHED*/
284 285 }
285 286
286 287 } while (cas32((uint32_t *)&dtrace_vtime_active,
287 288 state, nstate) != state);
288 289 }
289 290
290 291 void
291 292 dtrace_vtime_switch(kthread_t *next)
292 293 {
293 294 dtrace_icookie_t cookie;
294 295 hrtime_t ts;
295 296
296 297 if (tnf_tracing_active) {
297 298 tnf_thread_switch(next);
298 299
299 300 if (dtrace_vtime_active == DTRACE_VTIME_INACTIVE_TNF)
300 301 return;
301 302 }
302 303
303 304 cookie = dtrace_interrupt_disable();
304 305 ts = dtrace_gethrtime();
305 306
306 307 if (curthread->t_dtrace_start != 0) {
307 308 curthread->t_dtrace_vtime += ts - curthread->t_dtrace_start;
308 309 curthread->t_dtrace_start = 0;
309 310 }
310 311
311 312 next->t_dtrace_start = ts;
312 313
313 314 dtrace_interrupt_enable(cookie);
314 315 }
315 316
316 317 void (*dtrace_fasttrap_fork_ptr)(proc_t *, proc_t *);
317 318 void (*dtrace_fasttrap_exec_ptr)(proc_t *);
318 319 void (*dtrace_fasttrap_exit_ptr)(proc_t *);
319 320
320 321 /*
321 322 * This function is called by cfork() in the event that it appears that
322 323 * there may be dtrace tracepoints active in the parent process's address
323 324 * space. This first confirms the existence of dtrace tracepoints in the
324 325 * parent process and calls into the fasttrap module to remove the
325 326 * corresponding tracepoints from the child. By knowing that there are
326 327 * existing tracepoints, and ensuring they can't be removed, we can rely
327 328 * on the fasttrap module remaining loaded.
328 329 */
329 330 void
330 331 dtrace_fasttrap_fork(proc_t *p, proc_t *cp)
331 332 {
332 333 ASSERT(p->p_proc_flag & P_PR_LOCK);
333 334 ASSERT(p->p_dtrace_count > 0);
334 335 ASSERT(dtrace_fasttrap_fork_ptr != NULL);
335 336
336 337 dtrace_fasttrap_fork_ptr(p, cp);
337 338 }
|
↓ open down ↓ |
281 lines elided |
↑ open up ↑ |
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX