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 * Copyright 2007 Sun Microsystems, Inc. All rights reserved.
23 * Use is subject to license terms.
24 */
25
26 #pragma ident "%Z%%M% %I% %E% SMI"
27
28 #include <stddef.h>
29 #include <stdlib.h>
30 #include <strings.h>
31 #include <errno.h>
32 #include <unistd.h>
33 #include <assert.h>
34 #include <alloca.h>
35
36 #include <dt_impl.h>
37 #include <dt_program.h>
38
39 static const char _dt_errprog[] =
40 "dtrace:::ERROR"
41 "{"
42 " trace(arg1);"
43 " trace(arg2);"
44 " trace(arg3);"
45 " trace(arg4);"
46 " trace(arg5);"
47 "}";
48
49 int
50 dtrace_handle_err(dtrace_hdl_t *dtp, dtrace_handle_err_f *hdlr, void *arg)
51 {
52 dtrace_prog_t *pgp = NULL;
53 dt_stmt_t *stp;
54 dtrace_ecbdesc_t *edp;
55
56 /*
57 * We don't currently support multiple error handlers.
58 */
59 if (dtp->dt_errhdlr != NULL)
60 return (dt_set_errno(dtp, EALREADY));
61
62 /*
63 * If the DTRACEOPT_GRABANON is enabled, the anonymous enabling will
64 * already have a dtrace:::ERROR probe enabled; save 'hdlr' and 'arg'
65 * but do not bother compiling and enabling _dt_errprog.
66 */
67 if (dtp->dt_options[DTRACEOPT_GRABANON] != DTRACEOPT_UNSET)
68 goto out;
69
70 if ((pgp = dtrace_program_strcompile(dtp, _dt_errprog,
71 DTRACE_PROBESPEC_NAME, DTRACE_C_ZDEFS, 0, NULL)) == NULL)
72 return (dt_set_errno(dtp, dtrace_errno(dtp)));
73
74 stp = dt_list_next(&pgp->dp_stmts);
75 assert(stp != NULL);
76
77 edp = stp->ds_desc->dtsd_ecbdesc;
78 assert(edp != NULL);
79 edp->dted_uarg = DT_ECB_ERROR;
80
81 out:
82 dtp->dt_errhdlr = hdlr;
83 dtp->dt_errarg = arg;
84 dtp->dt_errprog = pgp;
85
86 return (0);
87 }
88
89 int
90 dtrace_handle_drop(dtrace_hdl_t *dtp, dtrace_handle_drop_f *hdlr, void *arg)
91 {
92 if (dtp->dt_drophdlr != NULL)
93 return (dt_set_errno(dtp, EALREADY));
94
95 dtp->dt_drophdlr = hdlr;
96 dtp->dt_droparg = arg;
97
98 return (0);
99 }
100
101 int
102 dtrace_handle_proc(dtrace_hdl_t *dtp, dtrace_handle_proc_f *hdlr, void *arg)
103 {
104 if (dtp->dt_prochdlr != NULL)
105 return (dt_set_errno(dtp, EALREADY));
106
107 dtp->dt_prochdlr = hdlr;
108 dtp->dt_procarg = arg;
109
110 return (0);
111 }
112
113 int
114 dtrace_handle_buffered(dtrace_hdl_t *dtp, dtrace_handle_buffered_f *hdlr,
115 void *arg)
116 {
117 if (dtp->dt_bufhdlr != NULL)
118 return (dt_set_errno(dtp, EALREADY));
119
120 if (hdlr == NULL)
121 return (dt_set_errno(dtp, EINVAL));
122
123 dtp->dt_bufhdlr = hdlr;
124 dtp->dt_bufarg = arg;
125
126 return (0);
127 }
128
129 int
130 dtrace_handle_setopt(dtrace_hdl_t *dtp, dtrace_handle_setopt_f *hdlr,
131 void *arg)
132 {
133 if (hdlr == NULL)
134 return (dt_set_errno(dtp, EINVAL));
135
136 dtp->dt_setopthdlr = hdlr;
137 dtp->dt_setoptarg = arg;
138
139 return (0);
140 }
141
142 #define DT_REC(type, ndx) *((type *)((uintptr_t)data->dtpda_data + \
143 epd->dtepd_rec[(ndx)].dtrd_offset))
144
145 static int
146 dt_handle_err(dtrace_hdl_t *dtp, dtrace_probedata_t *data)
147 {
148 dtrace_eprobedesc_t *epd = data->dtpda_edesc, *errepd;
149 dtrace_probedesc_t *pd = data->dtpda_pdesc, *errpd;
150 dtrace_errdata_t err;
151 dtrace_epid_t epid;
152
153 char where[30];
154 char details[30];
155 char offinfo[30];
156 const int slop = 80;
157 const char *faultstr;
158 char *str;
159 int len;
160
161 assert(epd->dtepd_uarg == DT_ECB_ERROR);
162
163 if (epd->dtepd_nrecs != 5 || strcmp(pd->dtpd_provider, "dtrace") != 0 ||
164 strcmp(pd->dtpd_name, "ERROR") != 0)
165 return (dt_set_errno(dtp, EDT_BADERROR));
166
167 /*
168 * This is an error. We have the following items here: EPID,
169 * faulting action, DIF offset, fault code and faulting address.
170 */
171 epid = (uint32_t)DT_REC(uint64_t, 0);
172
173 if (dt_epid_lookup(dtp, epid, &errepd, &errpd) != 0)
174 return (dt_set_errno(dtp, EDT_BADERROR));
175
176 err.dteda_edesc = errepd;
177 err.dteda_pdesc = errpd;
178 err.dteda_cpu = data->dtpda_cpu;
179 err.dteda_action = (int)DT_REC(uint64_t, 1);
180 err.dteda_offset = (int)DT_REC(uint64_t, 2);
181 err.dteda_fault = (int)DT_REC(uint64_t, 3);
182 err.dteda_addr = DT_REC(uint64_t, 4);
183
184 faultstr = dtrace_faultstr(dtp, err.dteda_fault);
185 len = sizeof (where) + sizeof (offinfo) + strlen(faultstr) +
186 strlen(errpd->dtpd_provider) + strlen(errpd->dtpd_mod) +
187 strlen(errpd->dtpd_name) + strlen(errpd->dtpd_func) +
188 slop;
189
190 str = (char *)alloca(len);
191
192 if (err.dteda_action == 0) {
193 (void) sprintf(where, "predicate");
194 } else {
195 (void) sprintf(where, "action #%d", err.dteda_action);
196 }
197
198 if (err.dteda_offset != -1) {
199 (void) sprintf(offinfo, " at DIF offset %d", err.dteda_offset);
200 } else {
201 offinfo[0] = 0;
202 }
203
204 switch (err.dteda_fault) {
205 case DTRACEFLT_BADADDR:
206 case DTRACEFLT_BADALIGN:
207 case DTRACEFLT_BADSTACK:
208 (void) sprintf(details, " (0x%llx)",
209 (u_longlong_t)err.dteda_addr);
210 break;
211
212 default:
213 details[0] = 0;
214 }
215
216 (void) snprintf(str, len, "error on enabled probe ID %u "
217 "(ID %u: %s:%s:%s:%s): %s%s in %s%s\n",
218 epid, errpd->dtpd_id, errpd->dtpd_provider,
219 errpd->dtpd_mod, errpd->dtpd_func,
220 errpd->dtpd_name, dtrace_faultstr(dtp, err.dteda_fault),
221 details, where, offinfo);
222
223 err.dteda_msg = str;
224
225 if (dtp->dt_errhdlr == NULL)
226 return (dt_set_errno(dtp, EDT_ERRABORT));
227
228 if ((*dtp->dt_errhdlr)(&err, dtp->dt_errarg) == DTRACE_HANDLE_ABORT)
229 return (dt_set_errno(dtp, EDT_ERRABORT));
230
231 return (0);
232 }
233
234 int
235 dt_handle_liberr(dtrace_hdl_t *dtp, const dtrace_probedata_t *data,
236 const char *faultstr)
237 {
238 dtrace_probedesc_t *errpd = data->dtpda_pdesc;
239 dtrace_errdata_t err;
240 const int slop = 80;
241 char *str;
242 int len;
243
244 err.dteda_edesc = data->dtpda_edesc;
245 err.dteda_pdesc = errpd;
246 err.dteda_cpu = data->dtpda_cpu;
247 err.dteda_action = -1;
248 err.dteda_offset = -1;
249 err.dteda_fault = DTRACEFLT_LIBRARY;
250 err.dteda_addr = 0L;
251
252 len = strlen(faultstr) +
253 strlen(errpd->dtpd_provider) + strlen(errpd->dtpd_mod) +
254 strlen(errpd->dtpd_name) + strlen(errpd->dtpd_func) +
255 slop;
256
257 str = alloca(len);
258
259 (void) snprintf(str, len, "error on enabled probe ID %u "
260 "(ID %u: %s:%s:%s:%s): %s\n",
261 data->dtpda_edesc->dtepd_epid,
262 errpd->dtpd_id, errpd->dtpd_provider,
263 errpd->dtpd_mod, errpd->dtpd_func,
264 errpd->dtpd_name, faultstr);
265
266 err.dteda_msg = str;
267
268 if (dtp->dt_errhdlr == NULL)
269 return (dt_set_errno(dtp, EDT_ERRABORT));
270
271 if ((*dtp->dt_errhdlr)(&err, dtp->dt_errarg) == DTRACE_HANDLE_ABORT)
272 return (dt_set_errno(dtp, EDT_ERRABORT));
273
274 return (0);
275 }
276
277 #define DROPTAG(x) x, #x
278
279 static const struct {
280 dtrace_dropkind_t dtdrg_kind;
281 char *dtdrg_tag;
282 } _dt_droptags[] = {
283 { DROPTAG(DTRACEDROP_PRINCIPAL) },
284 { DROPTAG(DTRACEDROP_AGGREGATION) },
285 { DROPTAG(DTRACEDROP_DYNAMIC) },
286 { DROPTAG(DTRACEDROP_DYNRINSE) },
287 { DROPTAG(DTRACEDROP_DYNDIRTY) },
288 { DROPTAG(DTRACEDROP_SPEC) },
289 { DROPTAG(DTRACEDROP_SPECBUSY) },
290 { DROPTAG(DTRACEDROP_SPECUNAVAIL) },
291 { DROPTAG(DTRACEDROP_DBLERROR) },
292 { DROPTAG(DTRACEDROP_STKSTROVERFLOW) },
293 { 0, NULL }
294 };
295
296 static const char *
297 dt_droptag(dtrace_dropkind_t kind)
298 {
299 int i;
300
301 for (i = 0; _dt_droptags[i].dtdrg_tag != NULL; i++) {
302 if (_dt_droptags[i].dtdrg_kind == kind)
303 return (_dt_droptags[i].dtdrg_tag);
304 }
305
306 return ("DTRACEDROP_UNKNOWN");
307 }
308
309 int
310 dt_handle_cpudrop(dtrace_hdl_t *dtp, processorid_t cpu,
311 dtrace_dropkind_t what, uint64_t howmany)
312 {
313 dtrace_dropdata_t drop;
314 char str[80], *s;
315 int size;
316
317 assert(what == DTRACEDROP_PRINCIPAL || what == DTRACEDROP_AGGREGATION);
318
319 bzero(&drop, sizeof (drop));
320 drop.dtdda_handle = dtp;
321 drop.dtdda_cpu = cpu;
322 drop.dtdda_kind = what;
323 drop.dtdda_drops = howmany;
324 drop.dtdda_msg = str;
325
326 if (dtp->dt_droptags) {
327 (void) snprintf(str, sizeof (str), "[%s] ", dt_droptag(what));
328 s = &str[strlen(str)];
329 size = sizeof (str) - (s - str);
330 } else {
331 s = str;
332 size = sizeof (str);
333 }
334
335 (void) snprintf(s, size, "%llu %sdrop%s on CPU %d\n",
336 howmany, what == DTRACEDROP_PRINCIPAL ? "" : "aggregation ",
337 howmany > 1 ? "s" : "", cpu);
338
339 if (dtp->dt_drophdlr == NULL)
340 return (dt_set_errno(dtp, EDT_DROPABORT));
341
342 if ((*dtp->dt_drophdlr)(&drop, dtp->dt_droparg) == DTRACE_HANDLE_ABORT)
343 return (dt_set_errno(dtp, EDT_DROPABORT));
344
345 return (0);
346 }
347
348 static const struct {
349 dtrace_dropkind_t dtdrt_kind;
350 uintptr_t dtdrt_offset;
351 const char *dtdrt_str;
352 const char *dtdrt_msg;
353 } _dt_droptab[] = {
354 { DTRACEDROP_DYNAMIC,
355 offsetof(dtrace_status_t, dtst_dyndrops),
356 "dynamic variable drop" },
357
358 { DTRACEDROP_DYNRINSE,
359 offsetof(dtrace_status_t, dtst_dyndrops_rinsing),
360 "dynamic variable drop", " with non-empty rinsing list" },
361
362 { DTRACEDROP_DYNDIRTY,
363 offsetof(dtrace_status_t, dtst_dyndrops_dirty),
364 "dynamic variable drop", " with non-empty dirty list" },
365
366 { DTRACEDROP_SPEC,
367 offsetof(dtrace_status_t, dtst_specdrops),
368 "speculative drop" },
369
370 { DTRACEDROP_SPECBUSY,
371 offsetof(dtrace_status_t, dtst_specdrops_busy),
372 "failed speculation", " (available buffer(s) still busy)" },
373
374 { DTRACEDROP_SPECUNAVAIL,
375 offsetof(dtrace_status_t, dtst_specdrops_unavail),
376 "failed speculation", " (no speculative buffer available)" },
377
378 { DTRACEDROP_STKSTROVERFLOW,
379 offsetof(dtrace_status_t, dtst_stkstroverflows),
380 "jstack()/ustack() string table overflow" },
381
382 { DTRACEDROP_DBLERROR,
383 offsetof(dtrace_status_t, dtst_dblerrors),
384 "error", " in ERROR probe enabling" },
385
386 { 0, 0, NULL }
387 };
388
389 int
390 dt_handle_status(dtrace_hdl_t *dtp, dtrace_status_t *old, dtrace_status_t *new)
391 {
392 dtrace_dropdata_t drop;
393 char str[80], *s;
394 uintptr_t base = (uintptr_t)new, obase = (uintptr_t)old;
395 int i, size;
396
397 bzero(&drop, sizeof (drop));
398 drop.dtdda_handle = dtp;
399 drop.dtdda_cpu = DTRACE_CPUALL;
400 drop.dtdda_msg = str;
401
402 /*
403 * First, check to see if we've been killed -- in which case we abort.
404 */
405 if (new->dtst_killed && !old->dtst_killed)
406 return (dt_set_errno(dtp, EDT_BRICKED));
407
408 for (i = 0; _dt_droptab[i].dtdrt_str != NULL; i++) {
409 uintptr_t naddr = base + _dt_droptab[i].dtdrt_offset;
410 uintptr_t oaddr = obase + _dt_droptab[i].dtdrt_offset;
411
412 uint64_t nval = *((uint64_t *)naddr);
413 uint64_t oval = *((uint64_t *)oaddr);
414
415 if (nval == oval)
416 continue;
417
418 if (dtp->dt_droptags) {
419 (void) snprintf(str, sizeof (str), "[%s] ",
420 dt_droptag(_dt_droptab[i].dtdrt_kind));
421 s = &str[strlen(str)];
422 size = sizeof (str) - (s - str);
423 } else {
424 s = str;
425 size = sizeof (str);
426 }
427
428 (void) snprintf(s, size, "%llu %s%s%s\n", nval - oval,
429 _dt_droptab[i].dtdrt_str, (nval - oval > 1) ? "s" : "",
430 _dt_droptab[i].dtdrt_msg != NULL ?
431 _dt_droptab[i].dtdrt_msg : "");
432
433 drop.dtdda_kind = _dt_droptab[i].dtdrt_kind;
434 drop.dtdda_total = nval;
435 drop.dtdda_drops = nval - oval;
436
437 if (dtp->dt_drophdlr == NULL)
438 return (dt_set_errno(dtp, EDT_DROPABORT));
439
440 if ((*dtp->dt_drophdlr)(&drop,
441 dtp->dt_droparg) == DTRACE_HANDLE_ABORT)
442 return (dt_set_errno(dtp, EDT_DROPABORT));
443 }
444
445 return (0);
446 }
447
448 int
449 dt_handle_setopt(dtrace_hdl_t *dtp, dtrace_setoptdata_t *data)
450 {
451 void *arg = dtp->dt_setoptarg;
452
453 if (dtp->dt_setopthdlr == NULL)
454 return (0);
455
456 if ((*dtp->dt_setopthdlr)(data, arg) == DTRACE_HANDLE_ABORT)
457 return (dt_set_errno(dtp, EDT_DIRABORT));
458
459 return (0);
460 }
461
462 int
463 dt_handle(dtrace_hdl_t *dtp, dtrace_probedata_t *data)
464 {
465 dtrace_eprobedesc_t *epd = data->dtpda_edesc;
466 int rval;
467
468 switch (epd->dtepd_uarg) {
469 case DT_ECB_ERROR:
470 rval = dt_handle_err(dtp, data);
471 break;
472
473 default:
474 return (DTRACE_CONSUME_THIS);
475 }
476
477 if (rval == 0)
478 return (DTRACE_CONSUME_NEXT);
479
480 return (DTRACE_CONSUME_ERROR);
481 }