File: | src/usr.sbin/btrace/btrace.c |
Warning: | line 1440, column 17 Division by zero |
Press '?' to see keyboard shortcuts
Keyboard shortcuts:
1 | /* $OpenBSD: btrace.c,v 1.81 2023/11/10 18:56:21 jasper Exp $ */ | |||
2 | ||||
3 | /* | |||
4 | * Copyright (c) 2019 - 2023 Martin Pieuchot <mpi@openbsd.org> | |||
5 | * | |||
6 | * Permission to use, copy, modify, and distribute this software for any | |||
7 | * purpose with or without fee is hereby granted, provided that the above | |||
8 | * copyright notice and this permission notice appear in all copies. | |||
9 | * | |||
10 | * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES | |||
11 | * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF | |||
12 | * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR | |||
13 | * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES | |||
14 | * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN | |||
15 | * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF | |||
16 | * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. | |||
17 | */ | |||
18 | ||||
19 | #include <sys/ioctl.h> | |||
20 | #include <sys/stat.h> | |||
21 | #include <sys/syscall.h> | |||
22 | #include <sys/queue.h> | |||
23 | ||||
24 | #include <assert.h> | |||
25 | #include <err.h> | |||
26 | #include <errno(*__errno()).h> | |||
27 | #include <fcntl.h> | |||
28 | #include <limits.h> | |||
29 | #include <locale.h> | |||
30 | #include <paths.h> | |||
31 | #include <signal.h> | |||
32 | #include <stdarg.h> | |||
33 | #include <stdbool.h> | |||
34 | #include <stdio.h> | |||
35 | #include <stdlib.h> | |||
36 | #include <string.h> | |||
37 | #include <time.h> | |||
38 | #include <unistd.h> | |||
39 | ||||
40 | #include <dev/dt/dtvar.h> | |||
41 | ||||
42 | #include "btrace.h" | |||
43 | #include "bt_parser.h" | |||
44 | ||||
45 | #define MINIMUM(a, b)(((a) < (b)) ? (a) : (b)) (((a) < (b)) ? (a) : (b)) | |||
46 | #define MAXIMUM(a, b)(((a) > (b)) ? (a) : (b)) (((a) > (b)) ? (a) : (b)) | |||
47 | ||||
48 | /* | |||
49 | * Maximum number of operands an arithmetic operation can have. This | |||
50 | * is necessary to stop infinite recursion when evaluating expressions. | |||
51 | */ | |||
52 | #define __MAXOPERANDS5 5 | |||
53 | ||||
54 | #define __PATH_DEVDT"/dev/dt" "/dev/dt" | |||
55 | ||||
56 | __dead__attribute__((__noreturn__)) void usage(void); | |||
57 | char *read_btfile(const char *, size_t *); | |||
58 | ||||
59 | /* | |||
60 | * Retrieve & parse probe information. | |||
61 | */ | |||
62 | void dtpi_cache(int); | |||
63 | void dtpi_print_list(int); | |||
64 | const char *dtpi_func(struct dtioc_probe_info *); | |||
65 | int dtpi_is_unit(const char *); | |||
66 | struct dtioc_probe_info *dtpi_get_by_value(const char *, const char *, | |||
67 | const char *); | |||
68 | ||||
69 | /* | |||
70 | * Main loop and rule evaluation. | |||
71 | */ | |||
72 | void rules_do(int); | |||
73 | int rules_setup(int); | |||
74 | int rules_apply(int, struct dt_evt *); | |||
75 | void rules_teardown(int); | |||
76 | int rule_eval(struct bt_rule *, struct dt_evt *); | |||
77 | void rule_printmaps(struct bt_rule *); | |||
78 | ||||
79 | /* | |||
80 | * Language builtins & functions. | |||
81 | */ | |||
82 | uint64_t builtin_nsecs(struct dt_evt *); | |||
83 | const char *builtin_kstack(struct dt_evt *); | |||
84 | const char *builtin_arg(struct dt_evt *, enum bt_argtype); | |||
85 | struct bt_arg *fn_str(struct bt_arg *, struct dt_evt *, char *); | |||
86 | int stmt_eval(struct bt_stmt *, struct dt_evt *); | |||
87 | void stmt_bucketize(struct bt_stmt *, struct dt_evt *); | |||
88 | void stmt_clear(struct bt_stmt *); | |||
89 | void stmt_delete(struct bt_stmt *, struct dt_evt *); | |||
90 | void stmt_insert(struct bt_stmt *, struct dt_evt *); | |||
91 | void stmt_print(struct bt_stmt *, struct dt_evt *); | |||
92 | void stmt_store(struct bt_stmt *, struct dt_evt *); | |||
93 | bool_Bool stmt_test(struct bt_stmt *, struct dt_evt *); | |||
94 | void stmt_time(struct bt_stmt *, struct dt_evt *); | |||
95 | void stmt_zero(struct bt_stmt *); | |||
96 | struct bt_arg *ba_read(struct bt_arg *); | |||
97 | struct bt_arg *baeval(struct bt_arg *, struct dt_evt *); | |||
98 | const char *ba2hash(struct bt_arg *, struct dt_evt *); | |||
99 | long baexpr2long(struct bt_arg *, struct dt_evt *); | |||
100 | const char *ba2bucket(struct bt_arg *, struct bt_arg *, | |||
101 | struct dt_evt *, long *); | |||
102 | int ba2dtflags(struct bt_arg *); | |||
103 | ||||
104 | /* | |||
105 | * Debug routines. | |||
106 | */ | |||
107 | __dead__attribute__((__noreturn__)) void xabort(const char *, ...); | |||
108 | void debug(const char *, ...); | |||
109 | void debugx(const char *, ...); | |||
110 | const char *debug_probe_name(struct bt_probe *); | |||
111 | void debug_dump_term(struct bt_arg *); | |||
112 | void debug_dump_expr(struct bt_arg *); | |||
113 | void debug_dump_filter(struct bt_rule *); | |||
114 | ||||
115 | struct dtioc_probe_info *dt_dtpis; /* array of available probes */ | |||
116 | size_t dt_ndtpi; /* # of elements in the array */ | |||
117 | struct dtioc_arg_info **dt_args; /* array of probe arguments */ | |||
118 | ||||
119 | struct dt_evt bt_devt; /* fake event for BEGIN/END */ | |||
120 | #define EVENT_BEGIN0 0 | |||
121 | #define EVENT_END(unsigned int)(-1) (unsigned int)(-1) | |||
122 | uint64_t bt_filtered; /* # of events filtered out */ | |||
123 | ||||
124 | struct syms *kelf, *uelf; | |||
125 | ||||
126 | char **vargs; | |||
127 | int nargs = 0; | |||
128 | int verbose = 0; | |||
129 | int dtfd; | |||
130 | volatile sig_atomic_t quit_pending; | |||
131 | ||||
132 | static void | |||
133 | signal_handler(int sig) | |||
134 | { | |||
135 | quit_pending = sig; | |||
136 | } | |||
137 | ||||
138 | ||||
139 | int | |||
140 | main(int argc, char *argv[]) | |||
141 | { | |||
142 | int fd = -1, ch, error = 0; | |||
143 | const char *filename = NULL((void *)0), *btscript = NULL((void *)0); | |||
144 | int showprobes = 0, noaction = 0; | |||
145 | size_t btslen = 0; | |||
146 | ||||
147 | setlocale(LC_ALL0, ""); | |||
148 | ||||
149 | while ((ch = getopt(argc, argv, "e:lnp:v")) != -1) { | |||
150 | switch (ch) { | |||
151 | case 'e': | |||
152 | btscript = optarg; | |||
153 | btslen = strlen(btscript); | |||
154 | break; | |||
155 | case 'l': | |||
156 | showprobes = 1; | |||
157 | break; | |||
158 | case 'n': | |||
159 | noaction = 1; | |||
160 | break; | |||
161 | case 'p': | |||
162 | uelf = kelf_open(optarg); | |||
163 | break; | |||
164 | case 'v': | |||
165 | verbose++; | |||
166 | break; | |||
167 | default: | |||
168 | usage(); | |||
169 | } | |||
170 | } | |||
171 | ||||
172 | argc -= optind; | |||
173 | argv += optind; | |||
174 | ||||
175 | if (argc > 0 && btscript == NULL((void *)0)) | |||
176 | filename = argv[0]; | |||
177 | ||||
178 | /* Cannot pledge due to special ioctl()s */ | |||
179 | if (unveil(__PATH_DEVDT"/dev/dt", "r") == -1) | |||
180 | err(1, "unveil %s", __PATH_DEVDT"/dev/dt"); | |||
181 | if (unveil(_PATH_KSYMS"/dev/ksyms", "r") == -1) | |||
182 | err(1, "unveil %s", _PATH_KSYMS"/dev/ksyms"); | |||
183 | if (filename != NULL((void *)0)) { | |||
184 | if (unveil(filename, "r") == -1) | |||
185 | err(1, "unveil %s", filename); | |||
186 | } | |||
187 | if (unveil(NULL((void *)0), NULL((void *)0)) == -1) | |||
188 | err(1, "unveil"); | |||
189 | ||||
190 | if (filename != NULL((void *)0)) { | |||
191 | btscript = read_btfile(filename, &btslen); | |||
192 | argc--; | |||
193 | argv++; | |||
194 | } | |||
195 | ||||
196 | nargs = argc; | |||
197 | vargs = argv; | |||
198 | ||||
199 | if (btscript == NULL((void *)0) && !showprobes) | |||
200 | usage(); | |||
201 | ||||
202 | if (btscript != NULL((void *)0)) { | |||
203 | error = btparse(btscript, btslen, filename, 1); | |||
204 | if (error) | |||
205 | return error; | |||
206 | } | |||
207 | ||||
208 | if (noaction) | |||
209 | return error; | |||
210 | ||||
211 | if (showprobes || g_nprobes > 0) { | |||
212 | fd = open(__PATH_DEVDT"/dev/dt", O_RDONLY0x0000); | |||
213 | if (fd == -1) | |||
214 | err(1, "could not open %s", __PATH_DEVDT"/dev/dt"); | |||
215 | dtfd = fd; | |||
216 | } | |||
217 | ||||
218 | if (showprobes) { | |||
219 | dtpi_cache(fd); | |||
220 | dtpi_print_list(fd); | |||
221 | } | |||
222 | ||||
223 | if (!TAILQ_EMPTY(&g_rules)(((&g_rules)->tqh_first) == ((void *)0))) | |||
224 | rules_do(fd); | |||
225 | ||||
226 | if (fd != -1) | |||
227 | close(fd); | |||
228 | ||||
229 | return error; | |||
230 | } | |||
231 | ||||
232 | __dead__attribute__((__noreturn__)) void | |||
233 | usage(void) | |||
234 | { | |||
235 | fprintf(stderr(&__sF[2]), "usage: %s [-lnv] [-e program | file] [-p file] " | |||
236 | "[argument ...]\n", getprogname()); | |||
237 | exit(1); | |||
238 | } | |||
239 | ||||
240 | char * | |||
241 | read_btfile(const char *filename, size_t *len) | |||
242 | { | |||
243 | FILE *fp; | |||
244 | char *fcontent; | |||
245 | struct stat st; | |||
246 | size_t fsize; | |||
247 | ||||
248 | if (stat(filename, &st)) | |||
249 | err(1, "can't stat '%s'", filename); | |||
250 | ||||
251 | fsize = st.st_size; | |||
252 | fcontent = malloc(fsize + 1); | |||
253 | if (fcontent == NULL((void *)0)) | |||
254 | err(1, "malloc"); | |||
255 | ||||
256 | fp = fopen(filename, "r"); | |||
257 | if (fp == NULL((void *)0)) | |||
258 | err(1, "can't open '%s'", filename); | |||
259 | ||||
260 | if (fread(fcontent, 1, fsize, fp) != fsize) | |||
261 | err(1, "can't read '%s'", filename); | |||
262 | fcontent[fsize] = '\0'; | |||
263 | ||||
264 | fclose(fp); | |||
265 | *len = fsize; | |||
266 | return fcontent; | |||
267 | } | |||
268 | ||||
269 | void | |||
270 | dtpi_cache(int fd) | |||
271 | { | |||
272 | struct dtioc_probe dtpr; | |||
273 | ||||
274 | if (dt_dtpis != NULL((void *)0)) | |||
275 | return; | |||
276 | ||||
277 | memset(&dtpr, 0, sizeof(dtpr)); | |||
278 | if (ioctl(fd, DTIOCGPLIST(((unsigned long)0x80000000|(unsigned long)0x40000000) | ((sizeof (struct dtioc_probe) & 0x1fff) << 16) | ((('D')) << 8) | ((1))), &dtpr)) | |||
279 | err(1, "DTIOCGPLIST"); | |||
280 | ||||
281 | dt_ndtpi = dtpr.dtpr_size / sizeof(*dt_dtpis); | |||
282 | dt_dtpis = reallocarray(NULL((void *)0), dt_ndtpi, sizeof(*dt_dtpis)); | |||
283 | if (dt_dtpis == NULL((void *)0)) | |||
284 | err(1, NULL((void *)0)); | |||
285 | ||||
286 | dtpr.dtpr_probes = dt_dtpis; | |||
287 | if (ioctl(fd, DTIOCGPLIST(((unsigned long)0x80000000|(unsigned long)0x40000000) | ((sizeof (struct dtioc_probe) & 0x1fff) << 16) | ((('D')) << 8) | ((1))), &dtpr)) | |||
288 | err(1, "DTIOCGPLIST"); | |||
289 | } | |||
290 | ||||
291 | void | |||
292 | dtai_cache(int fd, struct dtioc_probe_info *dtpi) | |||
293 | { | |||
294 | struct dtioc_arg dtar; | |||
295 | ||||
296 | if (dt_args == NULL((void *)0)) { | |||
297 | dt_args = calloc(dt_ndtpi, sizeof(*dt_args)); | |||
298 | if (dt_args == NULL((void *)0)) | |||
299 | err(1, NULL((void *)0)); | |||
300 | } | |||
301 | ||||
302 | if (dt_args[dtpi->dtpi_pbn - 1] != NULL((void *)0)) | |||
303 | return; | |||
304 | ||||
305 | dt_args[dtpi->dtpi_pbn - 1] = reallocarray(NULL((void *)0), dtpi->dtpi_nargs, | |||
306 | sizeof(**dt_args)); | |||
307 | if (dt_args[dtpi->dtpi_pbn - 1] == NULL((void *)0)) | |||
308 | err(1, NULL((void *)0)); | |||
309 | ||||
310 | dtar.dtar_pbn = dtpi->dtpi_pbn; | |||
311 | dtar.dtar_size = dtpi->dtpi_nargs * sizeof(**dt_args); | |||
312 | dtar.dtar_args = dt_args[dtpi->dtpi_pbn - 1]; | |||
313 | if (ioctl(fd, DTIOCGARGS(((unsigned long)0x80000000|(unsigned long)0x40000000) | ((sizeof (struct dtioc_arg) & 0x1fff) << 16) | ((('D')) << 8) | ((6))), &dtar)) | |||
314 | err(1, "DTIOCGARGS"); | |||
315 | } | |||
316 | ||||
317 | void | |||
318 | dtpi_print_list(int fd) | |||
319 | { | |||
320 | struct dtioc_probe_info *dtpi; | |||
321 | struct dtioc_arg_info *dtai; | |||
322 | size_t i, j; | |||
323 | ||||
324 | dtpi = dt_dtpis; | |||
325 | for (i = 0; i < dt_ndtpi; i++, dtpi++) { | |||
326 | printf("%s:%s:%s", dtpi->dtpi_prov, dtpi_func(dtpi), | |||
327 | dtpi->dtpi_name); | |||
328 | if (strncmp(dtpi->dtpi_prov, "tracepoint", DTNAMESIZE16) == 0) { | |||
329 | dtai_cache(fd, dtpi); | |||
330 | dtai = dt_args[dtpi->dtpi_pbn - 1]; | |||
331 | printf("("); | |||
332 | for (j = 0; j < dtpi->dtpi_nargs; j++, dtai++) { | |||
333 | if (j > 0) | |||
334 | printf(", "); | |||
335 | printf("%s", dtai->dtai_argtype); | |||
336 | } | |||
337 | printf(")"); | |||
338 | } | |||
339 | printf("\n"); | |||
340 | } | |||
341 | } | |||
342 | ||||
343 | const char * | |||
344 | dtpi_func(struct dtioc_probe_info *dtpi) | |||
345 | { | |||
346 | char *sysnb, func[DTNAMESIZE16]; | |||
347 | const char *errstr; | |||
348 | int idx; | |||
349 | ||||
350 | if (strncmp(dtpi->dtpi_prov, "syscall", DTNAMESIZE16)) | |||
351 | return dtpi->dtpi_func; | |||
352 | ||||
353 | /* Translate syscall names */ | |||
354 | strlcpy(func, dtpi->dtpi_func, sizeof(func)); | |||
355 | sysnb = func; | |||
356 | if (strsep(&sysnb, "%") == NULL((void *)0)) | |||
357 | return dtpi->dtpi_func; | |||
358 | ||||
359 | idx = strtonum(sysnb, 1, SYS_MAXSYSCALL331, &errstr); | |||
360 | if (errstr != NULL((void *)0)) | |||
361 | return dtpi->dtpi_func; | |||
362 | ||||
363 | return syscallnames[idx]; | |||
364 | } | |||
365 | ||||
366 | int | |||
367 | dtpi_is_unit(const char *unit) | |||
368 | { | |||
369 | return !strncmp("hz", unit, sizeof("hz")); | |||
370 | } | |||
371 | ||||
372 | struct dtioc_probe_info * | |||
373 | dtpi_get_by_value(const char *prov, const char *func, const char *name) | |||
374 | { | |||
375 | struct dtioc_probe_info *dtpi; | |||
376 | size_t i; | |||
377 | ||||
378 | dtpi = dt_dtpis; | |||
379 | for (i = 0; i < dt_ndtpi; i++, dtpi++) { | |||
380 | if (prov != NULL((void *)0) && | |||
381 | strncmp(prov, dtpi->dtpi_prov, DTNAMESIZE16)) | |||
382 | continue; | |||
383 | ||||
384 | if (func != NULL((void *)0)) { | |||
385 | if (dtpi_is_unit(func)) | |||
386 | return dtpi; | |||
387 | ||||
388 | if (strncmp(func, dtpi_func(dtpi), DTNAMESIZE16)) | |||
389 | continue; | |||
390 | } | |||
391 | ||||
392 | if (strncmp(name, dtpi->dtpi_name, DTNAMESIZE16)) | |||
393 | continue; | |||
394 | ||||
395 | debug("matched probe %s:%s:%s\n", dtpi->dtpi_prov, | |||
396 | dtpi_func(dtpi), dtpi->dtpi_name); | |||
397 | return dtpi; | |||
398 | } | |||
399 | ||||
400 | return NULL((void *)0); | |||
401 | } | |||
402 | ||||
403 | void | |||
404 | rules_do(int fd) | |||
405 | { | |||
406 | struct sigaction sa; | |||
407 | int halt = 0; | |||
408 | ||||
409 | memset(&sa, 0, sizeof(sa)); | |||
410 | sigemptyset(&sa.sa_mask); | |||
411 | sa.sa_flags = 0; | |||
412 | sa.sa_handler__sigaction_u.__sa_handler = signal_handler; | |||
413 | if (sigaction(SIGINT2, &sa, NULL((void *)0))) | |||
414 | err(1, "sigaction"); | |||
415 | if (sigaction(SIGTERM15, &sa, NULL((void *)0))) | |||
416 | err(1, "sigaction"); | |||
417 | ||||
418 | halt = rules_setup(fd); | |||
419 | ||||
420 | while (!quit_pending && !halt && g_nprobes > 0) { | |||
421 | static struct dt_evt devtbuf[64]; | |||
422 | ssize_t rlen; | |||
423 | size_t i; | |||
424 | ||||
425 | rlen = read(fd, devtbuf, sizeof(devtbuf) - 1); | |||
426 | if (rlen == -1) { | |||
427 | if (errno(*__errno()) == EINTR4 && quit_pending) { | |||
428 | printf("\n"); | |||
429 | break; | |||
430 | } | |||
431 | err(1, "read"); | |||
432 | } | |||
433 | ||||
434 | if ((rlen % sizeof(struct dt_evt)) != 0) | |||
435 | err(1, "incorrect read"); | |||
436 | ||||
437 | for (i = 0; i < rlen / sizeof(struct dt_evt); i++) { | |||
438 | halt = rules_apply(fd, &devtbuf[i]); | |||
439 | if (halt) | |||
440 | break; | |||
441 | } | |||
442 | } | |||
443 | ||||
444 | rules_teardown(fd); | |||
445 | ||||
446 | if (verbose && fd != -1) { | |||
447 | struct dtioc_stat dtst; | |||
448 | ||||
449 | memset(&dtst, 0, sizeof(dtst)); | |||
450 | if (ioctl(fd, DTIOCGSTATS((unsigned long)0x40000000 | ((sizeof(struct dtioc_stat) & 0x1fff) << 16) | ((('D')) << 8) | ((2))), &dtst)) | |||
451 | warn("DTIOCGSTATS"); | |||
452 | ||||
453 | printf("%llu events read\n", dtst.dtst_readevt); | |||
454 | printf("%llu events dropped\n", dtst.dtst_dropevt); | |||
455 | printf("%llu events filtered\n", bt_filtered); | |||
456 | } | |||
457 | } | |||
458 | ||||
459 | static uint64_t | |||
460 | rules_action_scan(struct bt_stmt *bs) | |||
461 | { | |||
462 | struct bt_arg *ba; | |||
463 | uint64_t evtflags = 0; | |||
464 | ||||
465 | while (bs != NULL((void *)0)) { | |||
466 | SLIST_FOREACH(ba, &bs->bs_args, ba_next)for((ba) = ((&bs->bs_args)->slh_first); (ba) != ((void *)0); (ba) = ((ba)->ba_next.sle_next)) | |||
467 | evtflags |= ba2dtflags(ba); | |||
468 | ||||
469 | /* Also check the value for map/hist insertion */ | |||
470 | switch (bs->bs_act) { | |||
471 | case B_AC_BUCKETIZE: | |||
472 | case B_AC_INSERT: | |||
473 | ba = (struct bt_arg *)bs->bs_var; | |||
474 | evtflags |= ba2dtflags(ba); | |||
475 | break; | |||
476 | case B_AC_TEST: | |||
477 | evtflags |= rules_action_scan( | |||
478 | (struct bt_stmt *)bs->bs_var); | |||
479 | break; | |||
480 | default: | |||
481 | break; | |||
482 | } | |||
483 | ||||
484 | bs = SLIST_NEXT(bs, bs_next)((bs)->bs_next.sle_next); | |||
485 | } | |||
486 | ||||
487 | return evtflags; | |||
488 | } | |||
489 | ||||
490 | int | |||
491 | rules_setup(int fd) | |||
492 | { | |||
493 | struct dtioc_probe_info *dtpi; | |||
494 | struct dtioc_req *dtrq; | |||
495 | struct bt_rule *r, *rbegin = NULL((void *)0); | |||
496 | struct bt_probe *bp; | |||
497 | struct bt_stmt *bs; | |||
498 | struct bt_arg *ba; | |||
499 | int dokstack = 0, halt = 0, on = 1; | |||
500 | uint64_t evtflags; | |||
501 | ||||
502 | TAILQ_FOREACH(r, &g_rules, br_next)for((r) = ((&g_rules)->tqh_first); (r) != ((void *)0); (r) = ((r)->br_next.tqe_next)) { | |||
503 | evtflags = 0; | |||
504 | ||||
505 | if (r->br_filter != NULL((void *)0) && | |||
506 | r->br_filter->bf_condition != NULL((void *)0)) { | |||
507 | ||||
508 | bs = r->br_filter->bf_condition; | |||
509 | ba = SLIST_FIRST(&bs->bs_args)((&bs->bs_args)->slh_first); | |||
510 | ||||
511 | evtflags |= ba2dtflags(ba); | |||
512 | } | |||
513 | ||||
514 | evtflags |= rules_action_scan(SLIST_FIRST(&r->br_action)((&r->br_action)->slh_first)); | |||
515 | ||||
516 | SLIST_FOREACH(bp, &r->br_probes, bp_next)for((bp) = ((&r->br_probes)->slh_first); (bp) != (( void *)0); (bp) = ((bp)->bp_next.sle_next)) { | |||
517 | debug("parsed probe '%s'", debug_probe_name(bp)); | |||
518 | debug_dump_filter(r); | |||
519 | ||||
520 | if (bp->bp_type != B_PT_PROBE) { | |||
521 | if (bp->bp_type == B_PT_BEGIN) | |||
522 | rbegin = r; | |||
523 | continue; | |||
524 | } | |||
525 | ||||
526 | dtpi_cache(fd); | |||
527 | dtpi = dtpi_get_by_value(bp->bp_prov, bp->bp_func, | |||
528 | bp->bp_name); | |||
529 | if (dtpi == NULL((void *)0)) { | |||
530 | errx(1, "probe '%s:%s:%s' not found", | |||
531 | bp->bp_prov, bp->bp_func, bp->bp_name); | |||
532 | } | |||
533 | ||||
534 | dtrq = calloc(1, sizeof(*dtrq)); | |||
535 | if (dtrq == NULL((void *)0)) | |||
536 | err(1, "dtrq: 1alloc"); | |||
537 | ||||
538 | bp->bp_pbn = dtpi->dtpi_pbn; | |||
539 | dtrq->dtrq_pbn = dtpi->dtpi_pbn; | |||
540 | dtrq->dtrq_rate = bp->bp_rate; | |||
541 | dtrq->dtrq_evtflags = evtflags; | |||
542 | if (dtrq->dtrq_evtflags & DTEVT_KSTACK(1 << 2)) | |||
543 | dokstack = 1; | |||
544 | bp->bp_cookie = dtrq; | |||
545 | } | |||
546 | } | |||
547 | ||||
548 | if (dokstack) | |||
549 | kelf = kelf_open(_PATH_KSYMS"/dev/ksyms"); | |||
550 | ||||
551 | /* Initialize "fake" event for BEGIN/END */ | |||
552 | bt_devt.dtev_pbn = EVENT_BEGIN0; | |||
553 | strlcpy(bt_devt.dtev_comm, getprogname(), sizeof(bt_devt.dtev_comm)); | |||
554 | bt_devt.dtev_pid = getpid(); | |||
555 | bt_devt.dtev_tid = getthrid(); | |||
556 | clock_gettime(CLOCK_REALTIME0, &bt_devt.dtev_tsp); | |||
557 | ||||
558 | if (rbegin) | |||
559 | halt = rule_eval(rbegin, &bt_devt); | |||
560 | ||||
561 | /* Enable all probes */ | |||
562 | TAILQ_FOREACH(r, &g_rules, br_next)for((r) = ((&g_rules)->tqh_first); (r) != ((void *)0); (r) = ((r)->br_next.tqe_next)) { | |||
563 | SLIST_FOREACH(bp, &r->br_probes, bp_next)for((bp) = ((&r->br_probes)->slh_first); (bp) != (( void *)0); (bp) = ((bp)->bp_next.sle_next)) { | |||
564 | if (bp->bp_type != B_PT_PROBE) | |||
565 | continue; | |||
566 | ||||
567 | dtrq = bp->bp_cookie; | |||
568 | if (ioctl(fd, DTIOCPRBENABLE((unsigned long)0x80000000 | ((sizeof(struct dtioc_req) & 0x1fff) << 16) | ((('D')) << 8) | ((4))), dtrq)) | |||
569 | err(1, "DTIOCPRBENABLE"); | |||
570 | } | |||
571 | } | |||
572 | ||||
573 | if (g_nprobes > 0) { | |||
574 | if (ioctl(fd, DTIOCRECORD((unsigned long)0x80000000 | ((sizeof(int) & 0x1fff) << 16) | ((('D')) << 8) | ((3))), &on)) | |||
575 | err(1, "DTIOCRECORD"); | |||
576 | } | |||
577 | ||||
578 | return halt; | |||
579 | } | |||
580 | ||||
581 | /* | |||
582 | * Returns non-zero if the program should halt. | |||
583 | */ | |||
584 | int | |||
585 | rules_apply(int fd, struct dt_evt *dtev) | |||
586 | { | |||
587 | struct bt_rule *r; | |||
588 | struct bt_probe *bp; | |||
589 | ||||
590 | TAILQ_FOREACH(r, &g_rules, br_next)for((r) = ((&g_rules)->tqh_first); (r) != ((void *)0); (r) = ((r)->br_next.tqe_next)) { | |||
591 | SLIST_FOREACH(bp, &r->br_probes, bp_next)for((bp) = ((&r->br_probes)->slh_first); (bp) != (( void *)0); (bp) = ((bp)->bp_next.sle_next)) { | |||
592 | if (bp->bp_type != B_PT_PROBE || | |||
593 | bp->bp_pbn != dtev->dtev_pbn) | |||
594 | continue; | |||
595 | ||||
596 | dtai_cache(fd, &dt_dtpis[dtev->dtev_pbn - 1]); | |||
597 | if (rule_eval(r, dtev)) | |||
598 | return 1; | |||
599 | } | |||
600 | } | |||
601 | return 0; | |||
602 | } | |||
603 | ||||
604 | void | |||
605 | rules_teardown(int fd) | |||
606 | { | |||
607 | struct dtioc_req *dtrq; | |||
608 | struct bt_probe *bp; | |||
609 | struct bt_rule *r, *rend = NULL((void *)0); | |||
610 | int dokstack = 0, off = 0; | |||
611 | ||||
612 | if (g_nprobes > 0) { | |||
613 | if (ioctl(fd, DTIOCRECORD((unsigned long)0x80000000 | ((sizeof(int) & 0x1fff) << 16) | ((('D')) << 8) | ((3))), &off)) | |||
614 | err(1, "DTIOCRECORD"); | |||
615 | } | |||
616 | ||||
617 | TAILQ_FOREACH(r, &g_rules, br_next)for((r) = ((&g_rules)->tqh_first); (r) != ((void *)0); (r) = ((r)->br_next.tqe_next)) { | |||
618 | SLIST_FOREACH(bp, &r->br_probes, bp_next)for((bp) = ((&r->br_probes)->slh_first); (bp) != (( void *)0); (bp) = ((bp)->bp_next.sle_next)) { | |||
619 | if (bp->bp_type != B_PT_PROBE) { | |||
620 | if (bp->bp_type == B_PT_END) | |||
621 | rend = r; | |||
622 | continue; | |||
623 | } | |||
624 | ||||
625 | dtrq = bp->bp_cookie; | |||
626 | if (ioctl(fd, DTIOCPRBDISABLE((unsigned long)0x80000000 | ((sizeof(struct dtioc_req) & 0x1fff) << 16) | ((('D')) << 8) | ((5))), dtrq)) | |||
627 | err(1, "DTIOCPRBDISABLE"); | |||
628 | if (dtrq->dtrq_evtflags & DTEVT_KSTACK(1 << 2)) | |||
629 | dokstack = 1; | |||
630 | } | |||
631 | } | |||
632 | ||||
633 | kelf_close(kelf); | |||
634 | kelf = NULL((void *)0); | |||
635 | kelf_close(uelf); | |||
636 | uelf = NULL((void *)0); | |||
637 | ||||
638 | /* Update "fake" event for BEGIN/END */ | |||
639 | bt_devt.dtev_pbn = EVENT_END(unsigned int)(-1); | |||
640 | clock_gettime(CLOCK_REALTIME0, &bt_devt.dtev_tsp); | |||
641 | ||||
642 | if (rend) | |||
643 | rule_eval(rend, &bt_devt); | |||
644 | ||||
645 | /* Print non-empty map & hist */ | |||
646 | TAILQ_FOREACH(r, &g_rules, br_next)for((r) = ((&g_rules)->tqh_first); (r) != ((void *)0); (r) = ((r)->br_next.tqe_next)) | |||
647 | rule_printmaps(r); | |||
648 | } | |||
649 | ||||
650 | /* | |||
651 | * Returns non-zero if the program should halt. | |||
652 | */ | |||
653 | int | |||
654 | rule_eval(struct bt_rule *r, struct dt_evt *dtev) | |||
655 | { | |||
656 | struct bt_stmt *bs; | |||
657 | struct bt_probe *bp; | |||
658 | ||||
659 | SLIST_FOREACH(bp, &r->br_probes, bp_next)for((bp) = ((&r->br_probes)->slh_first); (bp) != (( void *)0); (bp) = ((bp)->bp_next.sle_next)) { | |||
660 | debug("eval rule '%s'", debug_probe_name(bp)); | |||
661 | debug_dump_filter(r); | |||
662 | } | |||
663 | ||||
664 | if (r->br_filter != NULL((void *)0) && r->br_filter->bf_condition != NULL((void *)0)) { | |||
665 | if (stmt_test(r->br_filter->bf_condition, dtev) == false0) { | |||
666 | bt_filtered++; | |||
667 | return 0; | |||
668 | } | |||
669 | } | |||
670 | ||||
671 | SLIST_FOREACH(bs, &r->br_action, bs_next)for((bs) = ((&r->br_action)->slh_first); (bs) != (( void *)0); (bs) = ((bs)->bs_next.sle_next)) { | |||
672 | if ((bs->bs_act == B_AC_TEST) && stmt_test(bs, dtev) == true1) { | |||
673 | struct bt_stmt *bbs = (struct bt_stmt *)bs->bs_var; | |||
674 | ||||
675 | while (bbs != NULL((void *)0)) { | |||
676 | if (stmt_eval(bbs, dtev)) | |||
677 | return 1; | |||
678 | bbs = SLIST_NEXT(bbs, bs_next)((bbs)->bs_next.sle_next); | |||
679 | } | |||
680 | ||||
681 | continue; | |||
682 | } | |||
683 | ||||
684 | if (stmt_eval(bs, dtev)) | |||
685 | return 1; | |||
686 | } | |||
687 | ||||
688 | return 0; | |||
689 | } | |||
690 | ||||
691 | void | |||
692 | rule_printmaps(struct bt_rule *r) | |||
693 | { | |||
694 | struct bt_stmt *bs; | |||
695 | ||||
696 | SLIST_FOREACH(bs, &r->br_action, bs_next)for((bs) = ((&r->br_action)->slh_first); (bs) != (( void *)0); (bs) = ((bs)->bs_next.sle_next)) { | |||
697 | struct bt_arg *ba; | |||
698 | ||||
699 | SLIST_FOREACH(ba, &bs->bs_args, ba_next)for((ba) = ((&bs->bs_args)->slh_first); (ba) != ((void *)0); (ba) = ((ba)->ba_next.sle_next)) { | |||
700 | struct bt_var *bv = ba->ba_value; | |||
701 | struct map *map; | |||
702 | ||||
703 | if (ba->ba_type != B_AT_MAP && ba->ba_type != B_AT_HIST) | |||
704 | continue; | |||
705 | ||||
706 | map = (struct map *)bv->bv_value; | |||
707 | if (map == NULL((void *)0)) | |||
708 | continue; | |||
709 | ||||
710 | if (ba->ba_type == B_AT_MAP) | |||
711 | map_print(map, SIZE_T_MAX0xffffffffffffffffUL, bv_name(bv)); | |||
712 | else | |||
713 | hist_print((struct hist *)map, bv_name(bv)); | |||
714 | map_clear(map); | |||
715 | bv->bv_value = NULL((void *)0); | |||
716 | } | |||
717 | } | |||
718 | } | |||
719 | ||||
720 | time_t | |||
721 | builtin_gettime(struct dt_evt *dtev) | |||
722 | { | |||
723 | struct timespec ts; | |||
724 | ||||
725 | if (dtev == NULL((void *)0)) { | |||
726 | clock_gettime(CLOCK_REALTIME0, &ts); | |||
727 | return ts.tv_sec; | |||
728 | } | |||
729 | ||||
730 | return dtev->dtev_tsp.tv_sec; | |||
731 | } | |||
732 | ||||
733 | static inline uint64_t | |||
734 | TIMESPEC_TO_NSEC(struct timespec *ts) | |||
735 | { | |||
736 | return (ts->tv_sec * 1000000000L + ts->tv_nsec); | |||
737 | } | |||
738 | ||||
739 | uint64_t | |||
740 | builtin_nsecs(struct dt_evt *dtev) | |||
741 | { | |||
742 | struct timespec ts; | |||
743 | ||||
744 | if (dtev == NULL((void *)0)) { | |||
745 | clock_gettime(CLOCK_REALTIME0, &ts); | |||
746 | return TIMESPEC_TO_NSEC(&ts); | |||
747 | } | |||
748 | ||||
749 | return TIMESPEC_TO_NSEC(&dtev->dtev_tsp); | |||
750 | } | |||
751 | ||||
752 | const char * | |||
753 | builtin_stack(struct dt_evt *dtev, int kernel, unsigned long offset) | |||
754 | { | |||
755 | struct stacktrace *st = &dtev->dtev_kstack; | |||
756 | static char buf[4096]; | |||
757 | const char *last = "\nkernel\n"; | |||
758 | char *bp; | |||
759 | size_t i; | |||
760 | int sz; | |||
761 | ||||
762 | if (!kernel) { | |||
763 | st = &dtev->dtev_ustack; | |||
764 | last = "\nuserland\n"; | |||
765 | } else if (st->st_count == 0) { | |||
766 | return "\nuserland\n"; | |||
767 | } | |||
768 | ||||
769 | buf[0] = '\0'; | |||
770 | bp = buf; | |||
771 | sz = sizeof(buf); | |||
772 | for (i = 0; i < st->st_count; i++) { | |||
773 | int l; | |||
774 | ||||
775 | if (!kernel) | |||
776 | l = kelf_snprintsym(uelf, bp, sz - 1, st->st_pc[i], | |||
777 | offset); | |||
778 | else | |||
779 | l = kelf_snprintsym(kelf, bp, sz - 1, st->st_pc[i], | |||
780 | offset); | |||
781 | if (l < 0) | |||
782 | break; | |||
783 | if (l >= sz - 1) { | |||
784 | bp += sz - 1; | |||
785 | sz = 1; | |||
786 | break; | |||
787 | } | |||
788 | bp += l; | |||
789 | sz -= l; | |||
790 | } | |||
791 | snprintf(bp, sz, "%s", last); | |||
792 | ||||
793 | return buf; | |||
794 | } | |||
795 | ||||
796 | const char * | |||
797 | builtin_arg(struct dt_evt *dtev, enum bt_argtype dat) | |||
798 | { | |||
799 | static char buf[sizeof("18446744073709551615")]; /* UINT64_MAX */ | |||
800 | unsigned int argn; | |||
801 | struct dtioc_arg_info *dtai; | |||
802 | const char *argtype, *fmt; | |||
803 | long value; | |||
804 | ||||
805 | dtai = dt_args[dtev->dtev_pbn - 1]; | |||
806 | argn = dat - B_AT_BI_ARG0; | |||
807 | argtype = dtai[argn].dtai_argtype; | |||
808 | ||||
809 | if (strncmp(argtype, "int", DTNAMESIZE16) == 0) { | |||
810 | fmt = "%d"; | |||
811 | value = (int)dtev->dtev_args_args.E_entry[argn]; | |||
812 | } else { | |||
813 | fmt = "%lu"; | |||
814 | value = dtev->dtev_args_args.E_entry[argn]; | |||
815 | } | |||
816 | ||||
817 | snprintf(buf, sizeof(buf), fmt, dtev->dtev_args_args.E_entry[argn]); | |||
818 | ||||
819 | return buf; | |||
820 | } | |||
821 | ||||
822 | /* | |||
823 | * Returns non-zero if the program should halt. | |||
824 | */ | |||
825 | int | |||
826 | stmt_eval(struct bt_stmt *bs, struct dt_evt *dtev) | |||
827 | { | |||
828 | int halt = 0; | |||
829 | ||||
830 | switch (bs->bs_act) { | |||
831 | case B_AC_BUCKETIZE: | |||
832 | stmt_bucketize(bs, dtev); | |||
833 | break; | |||
834 | case B_AC_CLEAR: | |||
835 | stmt_clear(bs); | |||
836 | break; | |||
837 | case B_AC_DELETE: | |||
838 | stmt_delete(bs, dtev); | |||
839 | break; | |||
840 | case B_AC_EXIT: | |||
841 | halt = 1; | |||
842 | break; | |||
843 | case B_AC_INSERT: | |||
844 | stmt_insert(bs, dtev); | |||
845 | break; | |||
846 | case B_AC_PRINT: | |||
847 | stmt_print(bs, dtev); | |||
848 | break; | |||
849 | case B_AC_PRINTF: | |||
850 | stmt_printf(bs, dtev); | |||
851 | break; | |||
852 | case B_AC_STORE: | |||
853 | stmt_store(bs, dtev); | |||
854 | break; | |||
855 | case B_AC_TEST: | |||
856 | /* done before */ | |||
857 | break; | |||
858 | case B_AC_TIME: | |||
859 | stmt_time(bs, dtev); | |||
860 | break; | |||
861 | case B_AC_ZERO: | |||
862 | stmt_zero(bs); | |||
863 | break; | |||
864 | default: | |||
865 | xabort("no handler for action type %d", bs->bs_act); | |||
866 | } | |||
867 | return halt; | |||
868 | } | |||
869 | ||||
870 | /* | |||
871 | * Increment a bucket: { @h = hist(v); } or { @h = lhist(v, min, max, step); } | |||
872 | * | |||
873 | * In this case 'h' is represented by `bv' and '(min, max, step)' by `brange'. | |||
874 | */ | |||
875 | void | |||
876 | stmt_bucketize(struct bt_stmt *bs, struct dt_evt *dtev) | |||
877 | { | |||
878 | struct bt_arg *brange, *bhist = SLIST_FIRST(&bs->bs_args)((&bs->bs_args)->slh_first); | |||
879 | struct bt_arg *bval = (struct bt_arg *)bs->bs_var; | |||
880 | struct bt_var *bv = bhist->ba_value; | |||
881 | struct hist *hist; | |||
882 | const char *bucket; | |||
883 | long step = 0; | |||
884 | ||||
885 | assert(bhist->ba_type == B_AT_HIST)((bhist->ba_type == B_AT_HIST) ? (void)0 : __assert2("/usr/src/usr.sbin/btrace/btrace.c" , 885, __func__, "bhist->ba_type == B_AT_HIST")); | |||
886 | assert(SLIST_NEXT(bval, ba_next) == NULL)((((bval)->ba_next.sle_next) == ((void *)0)) ? (void)0 : __assert2 ("/usr/src/usr.sbin/btrace/btrace.c", 886, __func__, "SLIST_NEXT(bval, ba_next) == NULL" )); | |||
887 | ||||
888 | brange = bhist->ba_key; | |||
889 | bucket = ba2bucket(bval, brange, dtev, &step); | |||
890 | if (bucket == NULL((void *)0)) { | |||
891 | debug("hist=%p '%s' value=%lu out of range\n", bv->bv_value, | |||
892 | bv_name(bv), ba2long(bval, dtev)); | |||
893 | return; | |||
894 | } | |||
895 | debug("hist=%p '%s' increment bucket '%s'\n", bv->bv_value, | |||
896 | bv_name(bv), bucket); | |||
897 | ||||
898 | /* hist is NULL before first insert or after clear() */ | |||
899 | hist = (struct hist *)bv->bv_value; | |||
900 | if (hist == NULL((void *)0)) | |||
901 | hist = hist_new(step); | |||
902 | ||||
903 | hist_increment(hist, bucket); | |||
904 | ||||
905 | debug("hist=%p '%s' increment bucket=%p '%s' bval=%p\n", hist, | |||
906 | bv_name(bv), brange, bucket, bval); | |||
907 | ||||
908 | bv->bv_value = (struct bt_arg *)hist; | |||
909 | bv->bv_type = B_VT_HIST; | |||
910 | } | |||
911 | ||||
912 | ||||
913 | /* | |||
914 | * Empty a map: { clear(@map); } | |||
915 | */ | |||
916 | void | |||
917 | stmt_clear(struct bt_stmt *bs) | |||
918 | { | |||
919 | struct bt_arg *ba = SLIST_FIRST(&bs->bs_args)((&bs->bs_args)->slh_first); | |||
920 | struct bt_var *bv = ba->ba_value; | |||
921 | struct map *map; | |||
922 | ||||
923 | assert(bs->bs_var == NULL)((bs->bs_var == ((void *)0)) ? (void)0 : __assert2("/usr/src/usr.sbin/btrace/btrace.c" , 923, __func__, "bs->bs_var == NULL")); | |||
924 | assert(ba->ba_type == B_AT_VAR)((ba->ba_type == B_AT_VAR) ? (void)0 : __assert2("/usr/src/usr.sbin/btrace/btrace.c" , 924, __func__, "ba->ba_type == B_AT_VAR")); | |||
925 | ||||
926 | map = (struct map *)bv->bv_value; | |||
927 | if (map == NULL((void *)0)) | |||
928 | return; | |||
929 | ||||
930 | if (bv->bv_type != B_VT_MAP && bv->bv_type != B_VT_HIST) | |||
931 | errx(1, "invalid variable type for clear(%s)", ba_name(ba)); | |||
932 | ||||
933 | map_clear(map); | |||
934 | bv->bv_value = NULL((void *)0); | |||
935 | ||||
936 | debug("map=%p '%s' clear\n", map, bv_name(bv)); | |||
937 | } | |||
938 | ||||
939 | /* | |||
940 | * Map delete: { delete(@map[key]); } | |||
941 | * | |||
942 | * In this case 'map' is represented by `bv' and 'key' by `bkey'. | |||
943 | */ | |||
944 | void | |||
945 | stmt_delete(struct bt_stmt *bs, struct dt_evt *dtev) | |||
946 | { | |||
947 | struct bt_arg *bkey, *bmap = SLIST_FIRST(&bs->bs_args)((&bs->bs_args)->slh_first); | |||
948 | struct bt_var *bv = bmap->ba_value; | |||
949 | struct map *map; | |||
950 | const char *hash; | |||
951 | ||||
952 | assert(bmap->ba_type == B_AT_MAP)((bmap->ba_type == B_AT_MAP) ? (void)0 : __assert2("/usr/src/usr.sbin/btrace/btrace.c" , 952, __func__, "bmap->ba_type == B_AT_MAP")); | |||
953 | assert(bs->bs_var == NULL)((bs->bs_var == ((void *)0)) ? (void)0 : __assert2("/usr/src/usr.sbin/btrace/btrace.c" , 953, __func__, "bs->bs_var == NULL")); | |||
954 | ||||
955 | map = (struct map *)bv->bv_value; | |||
956 | if (map == NULL((void *)0)) | |||
957 | return; | |||
958 | ||||
959 | bkey = bmap->ba_key; | |||
960 | hash = ba2hash(bkey, dtev); | |||
961 | debug("map=%p '%s' delete key=%p '%s'\n", map, bv_name(bv), bkey, hash); | |||
962 | ||||
963 | map_delete(map, hash); | |||
964 | } | |||
965 | ||||
966 | /* | |||
967 | * Map insert: { @map[key] = 42; } | |||
968 | * | |||
969 | * In this case 'map' is represented by `bv', 'key' by `bkey' and | |||
970 | * '42' by `bval'. | |||
971 | */ | |||
972 | void | |||
973 | stmt_insert(struct bt_stmt *bs, struct dt_evt *dtev) | |||
974 | { | |||
975 | struct bt_arg *bkey, *bmap = SLIST_FIRST(&bs->bs_args)((&bs->bs_args)->slh_first); | |||
976 | struct bt_arg *bval = (struct bt_arg *)bs->bs_var; | |||
977 | struct bt_var *bv = bmap->ba_value; | |||
978 | struct map *map; | |||
979 | const char *hash; | |||
980 | long val; | |||
981 | ||||
982 | assert(bmap->ba_type == B_AT_MAP)((bmap->ba_type == B_AT_MAP) ? (void)0 : __assert2("/usr/src/usr.sbin/btrace/btrace.c" , 982, __func__, "bmap->ba_type == B_AT_MAP")); | |||
983 | assert(SLIST_NEXT(bval, ba_next) == NULL)((((bval)->ba_next.sle_next) == ((void *)0)) ? (void)0 : __assert2 ("/usr/src/usr.sbin/btrace/btrace.c", 983, __func__, "SLIST_NEXT(bval, ba_next) == NULL" )); | |||
984 | ||||
985 | bkey = bmap->ba_key; | |||
986 | hash = ba2hash(bkey, dtev); | |||
987 | ||||
988 | /* map is NULL before first insert or after clear() */ | |||
989 | map = (struct map *)bv->bv_value; | |||
990 | if (map == NULL((void *)0)) | |||
991 | map = map_new(); | |||
992 | ||||
993 | /* Operate on existring value for count(), max(), min() and sum(). */ | |||
994 | switch (bval->ba_type) { | |||
995 | case B_AT_MF_COUNT: | |||
996 | val = ba2long(map_get(map, hash), NULL((void *)0)); | |||
997 | val++; | |||
998 | bval = ba_new(val, B_AT_LONG)ba_new0((void *)(val), (B_AT_LONG)); | |||
999 | break; | |||
1000 | case B_AT_MF_MAX: | |||
1001 | val = ba2long(map_get(map, hash), NULL((void *)0)); | |||
1002 | val = MAXIMUM(val, ba2long(bval->ba_value, dtev))(((val) > (ba2long(bval->ba_value, dtev))) ? (val) : (ba2long (bval->ba_value, dtev))); | |||
1003 | bval = ba_new(val, B_AT_LONG)ba_new0((void *)(val), (B_AT_LONG)); | |||
1004 | break; | |||
1005 | case B_AT_MF_MIN: | |||
1006 | val = ba2long(map_get(map, hash), NULL((void *)0)); | |||
1007 | val = MINIMUM(val, ba2long(bval->ba_value, dtev))(((val) < (ba2long(bval->ba_value, dtev))) ? (val) : (ba2long (bval->ba_value, dtev))); | |||
1008 | bval = ba_new(val, B_AT_LONG)ba_new0((void *)(val), (B_AT_LONG)); | |||
1009 | break; | |||
1010 | case B_AT_MF_SUM: | |||
1011 | val = ba2long(map_get(map, hash), NULL((void *)0)); | |||
1012 | val += ba2long(bval->ba_value, dtev); | |||
1013 | bval = ba_new(val, B_AT_LONG)ba_new0((void *)(val), (B_AT_LONG)); | |||
1014 | break; | |||
1015 | default: | |||
1016 | bval = baeval(bval, dtev); | |||
1017 | break; | |||
1018 | } | |||
1019 | ||||
1020 | map_insert(map, hash, bval); | |||
1021 | ||||
1022 | debug("map=%p '%s' insert key=%p '%s' bval=%p\n", map, | |||
1023 | bv_name(bv), bkey, hash, bval); | |||
1024 | ||||
1025 | bv->bv_value = (struct bt_arg *)map; | |||
1026 | bv->bv_type = B_VT_MAP; | |||
1027 | } | |||
1028 | ||||
1029 | /* | |||
1030 | * Print variables: { print(890); print(@map[, 8]); print(comm); } | |||
1031 | * | |||
1032 | * In this case the global variable 'map' is pointed at by `ba' | |||
1033 | * and '8' is represented by `btop'. | |||
1034 | */ | |||
1035 | void | |||
1036 | stmt_print(struct bt_stmt *bs, struct dt_evt *dtev) | |||
1037 | { | |||
1038 | struct bt_arg *btop, *ba = SLIST_FIRST(&bs->bs_args)((&bs->bs_args)->slh_first); | |||
1039 | struct bt_var *bv = ba->ba_value; | |||
1040 | struct map *map; | |||
1041 | size_t top = SIZE_T_MAX0xffffffffffffffffUL; | |||
1042 | ||||
1043 | assert(bs->bs_var == NULL)((bs->bs_var == ((void *)0)) ? (void)0 : __assert2("/usr/src/usr.sbin/btrace/btrace.c" , 1043, __func__, "bs->bs_var == NULL")); | |||
1044 | ||||
1045 | /* Parse optional `top' argument. */ | |||
1046 | btop = SLIST_NEXT(ba, ba_next)((ba)->ba_next.sle_next); | |||
1047 | if (btop != NULL((void *)0)) { | |||
1048 | assert(SLIST_NEXT(btop, ba_next) == NULL)((((btop)->ba_next.sle_next) == ((void *)0)) ? (void)0 : __assert2 ("/usr/src/usr.sbin/btrace/btrace.c", 1048, __func__, "SLIST_NEXT(btop, ba_next) == NULL" )); | |||
1049 | top = ba2long(btop, dtev); | |||
1050 | } | |||
1051 | ||||
1052 | /* Static argument. */ | |||
1053 | if (ba->ba_type != B_AT_VAR) { | |||
1054 | assert(btop == NULL)((btop == ((void *)0)) ? (void)0 : __assert2("/usr/src/usr.sbin/btrace/btrace.c" , 1054, __func__, "btop == NULL")); | |||
1055 | printf("%s\n", ba2str(ba, dtev)); | |||
1056 | return; | |||
1057 | } | |||
1058 | ||||
1059 | map = (struct map *)bv->bv_value; | |||
1060 | if (map == NULL((void *)0)) | |||
1061 | return; | |||
1062 | ||||
1063 | debug("map=%p '%s' print (top=%d)\n", bv->bv_value, bv_name(bv), top); | |||
1064 | ||||
1065 | if (bv->bv_type == B_VT_MAP) | |||
1066 | map_print(map, top, bv_name(bv)); | |||
1067 | else if (bv->bv_type == B_VT_HIST) | |||
1068 | hist_print((struct hist *)map, bv_name(bv)); | |||
1069 | else | |||
1070 | printf("%s\n", ba2str(ba, dtev)); | |||
1071 | } | |||
1072 | ||||
1073 | /* | |||
1074 | * Variable store: { @var = 3; } | |||
1075 | * | |||
1076 | * In this case '3' is represented by `ba', the argument of a STORE | |||
1077 | * action. | |||
1078 | * | |||
1079 | * If the argument depends of the value of an event (builtin) or is | |||
1080 | * the result of an operation, its evaluation is stored in a new `ba'. | |||
1081 | */ | |||
1082 | void | |||
1083 | stmt_store(struct bt_stmt *bs, struct dt_evt *dtev) | |||
1084 | { | |||
1085 | struct bt_arg *ba = SLIST_FIRST(&bs->bs_args)((&bs->bs_args)->slh_first); | |||
1086 | struct bt_var *bvar, *bv = bs->bs_var; | |||
1087 | ||||
1088 | assert(SLIST_NEXT(ba, ba_next) == NULL)((((ba)->ba_next.sle_next) == ((void *)0)) ? (void)0 : __assert2 ("/usr/src/usr.sbin/btrace/btrace.c", 1088, __func__, "SLIST_NEXT(ba, ba_next) == NULL" )); | |||
| ||||
1089 | ||||
1090 | switch (ba->ba_type) { | |||
1091 | case B_AT_STR: | |||
1092 | bv->bv_value = ba; | |||
1093 | bv->bv_type = B_VT_STR; | |||
1094 | break; | |||
1095 | case B_AT_LONG: | |||
1096 | bv->bv_value = ba; | |||
1097 | bv->bv_type = B_VT_LONG; | |||
1098 | break; | |||
1099 | case B_AT_VAR: | |||
1100 | bvar = ba->ba_value; | |||
1101 | bv->bv_type = bvar->bv_type; | |||
1102 | bv->bv_value = bvar->bv_value; | |||
1103 | break; | |||
1104 | case B_AT_TUPLE: | |||
1105 | bv->bv_value = baeval(ba, dtev); | |||
1106 | bv->bv_type = B_VT_TUPLE; | |||
1107 | break; | |||
1108 | case B_AT_BI_PID: | |||
1109 | case B_AT_BI_TID: | |||
1110 | case B_AT_BI_NSECS: | |||
1111 | case B_AT_BI_ARG0 ... B_AT_BI_ARG9: | |||
1112 | case B_AT_OP_PLUS ... B_AT_OP_LOR: | |||
1113 | bv->bv_value = baeval(ba, dtev); | |||
1114 | bv->bv_type = B_VT_LONG; | |||
1115 | break; | |||
1116 | case B_AT_FN_STR: | |||
1117 | bv->bv_value = baeval(ba, dtev); | |||
1118 | bv->bv_type = B_VT_STR; | |||
1119 | break; | |||
1120 | default: | |||
1121 | xabort("store not implemented for type %d", ba->ba_type); | |||
1122 | } | |||
1123 | ||||
1124 | debug("bv=%p var '%s' store (%p)='%s'\n", bv, bv_name(bv), bv->bv_value, | |||
1125 | ba2str(bv->bv_value, dtev)); | |||
1126 | } | |||
1127 | ||||
1128 | /* | |||
1129 | * String conversion { str($1); string($1, 3); } | |||
1130 | * | |||
1131 | * Since fn_str is currently only called in ba2str, *buf should be a pointer | |||
1132 | * to the static buffer provided by ba2str. | |||
1133 | */ | |||
1134 | struct bt_arg * | |||
1135 | fn_str(struct bt_arg *ba, struct dt_evt *dtev, char *buf) | |||
1136 | { | |||
1137 | struct bt_arg *arg, *index; | |||
1138 | ssize_t len = STRLEN64; | |||
1139 | ||||
1140 | assert(ba->ba_type == B_AT_FN_STR)((ba->ba_type == B_AT_FN_STR) ? (void)0 : __assert2("/usr/src/usr.sbin/btrace/btrace.c" , 1140, __func__, "ba->ba_type == B_AT_FN_STR")); | |||
1141 | ||||
1142 | arg = (struct bt_arg*)ba->ba_value; | |||
1143 | assert(arg != NULL)((arg != ((void *)0)) ? (void)0 : __assert2("/usr/src/usr.sbin/btrace/btrace.c" , 1143, __func__, "arg != NULL")); | |||
1144 | ||||
1145 | index = SLIST_NEXT(arg, ba_next)((arg)->ba_next.sle_next); | |||
1146 | if (index != NULL((void *)0)) { | |||
1147 | /* Should have only 1 optional argument. */ | |||
1148 | assert(SLIST_NEXT(index, ba_next) == NULL)((((index)->ba_next.sle_next) == ((void *)0)) ? (void)0 : __assert2 ("/usr/src/usr.sbin/btrace/btrace.c", 1148, __func__, "SLIST_NEXT(index, ba_next) == NULL" )); | |||
1149 | len = MINIMUM(ba2long(index, dtev) + 1, STRLEN)(((ba2long(index, dtev) + 1) < (64)) ? (ba2long(index, dtev ) + 1) : (64)); | |||
1150 | } | |||
1151 | ||||
1152 | /* All negative lengths behave the same as a zero length. */ | |||
1153 | if (len < 1) | |||
1154 | return ba_new("", B_AT_STR)ba_new0((void *)(""), (B_AT_STR)); | |||
1155 | ||||
1156 | strlcpy(buf, ba2str(arg, dtev), len); | |||
1157 | return ba_new(buf, B_AT_STR)ba_new0((void *)(buf), (B_AT_STR)); | |||
1158 | } | |||
1159 | ||||
1160 | /* | |||
1161 | * Expression test: { if (expr) stmt; } | |||
1162 | */ | |||
1163 | bool_Bool | |||
1164 | stmt_test(struct bt_stmt *bs, struct dt_evt *dtev) | |||
1165 | { | |||
1166 | struct bt_arg *ba; | |||
1167 | ||||
1168 | if (bs == NULL((void *)0)) | |||
1169 | return true1; | |||
1170 | ||||
1171 | ba = SLIST_FIRST(&bs->bs_args)((&bs->bs_args)->slh_first); | |||
1172 | ||||
1173 | return baexpr2long(ba, dtev) != 0; | |||
1174 | } | |||
1175 | ||||
1176 | /* | |||
1177 | * Print time: { time("%H:%M:%S"); } | |||
1178 | */ | |||
1179 | void | |||
1180 | stmt_time(struct bt_stmt *bs, struct dt_evt *dtev) | |||
1181 | { | |||
1182 | struct bt_arg *ba = SLIST_FIRST(&bs->bs_args)((&bs->bs_args)->slh_first); | |||
1183 | time_t time; | |||
1184 | struct tm *tm; | |||
1185 | char buf[64]; | |||
1186 | ||||
1187 | assert(bs->bs_var == NULL)((bs->bs_var == ((void *)0)) ? (void)0 : __assert2("/usr/src/usr.sbin/btrace/btrace.c" , 1187, __func__, "bs->bs_var == NULL")); | |||
1188 | assert(ba->ba_type == B_AT_STR)((ba->ba_type == B_AT_STR) ? (void)0 : __assert2("/usr/src/usr.sbin/btrace/btrace.c" , 1188, __func__, "ba->ba_type == B_AT_STR")); | |||
1189 | assert(strlen(ba2str(ba, dtev)) < (sizeof(buf) - 1))((strlen(ba2str(ba, dtev)) < (sizeof(buf) - 1)) ? (void)0 : __assert2("/usr/src/usr.sbin/btrace/btrace.c", 1189, __func__ , "strlen(ba2str(ba, dtev)) < (sizeof(buf) - 1)")); | |||
1190 | ||||
1191 | time = builtin_gettime(dtev); | |||
1192 | tm = localtime(&time); | |||
1193 | strftime(buf, sizeof(buf), ba2str(ba, dtev), tm); | |||
1194 | printf("%s", buf); | |||
1195 | } | |||
1196 | ||||
1197 | /* | |||
1198 | * Set entries to 0: { zero(@map); } | |||
1199 | */ | |||
1200 | void | |||
1201 | stmt_zero(struct bt_stmt *bs) | |||
1202 | { | |||
1203 | struct bt_arg *ba = SLIST_FIRST(&bs->bs_args)((&bs->bs_args)->slh_first); | |||
1204 | struct bt_var *bv = ba->ba_value; | |||
1205 | struct map *map; | |||
1206 | ||||
1207 | assert(bs->bs_var == NULL)((bs->bs_var == ((void *)0)) ? (void)0 : __assert2("/usr/src/usr.sbin/btrace/btrace.c" , 1207, __func__, "bs->bs_var == NULL")); | |||
1208 | assert(ba->ba_type == B_AT_VAR)((ba->ba_type == B_AT_VAR) ? (void)0 : __assert2("/usr/src/usr.sbin/btrace/btrace.c" , 1208, __func__, "ba->ba_type == B_AT_VAR")); | |||
1209 | ||||
1210 | map = (struct map *)bv->bv_value; | |||
1211 | if (map == NULL((void *)0)) | |||
1212 | return; | |||
1213 | ||||
1214 | if (bv->bv_type != B_VT_MAP && bv->bv_type != B_VT_HIST) | |||
1215 | errx(1, "invalid variable type for zero(%s)", ba_name(ba)); | |||
1216 | ||||
1217 | map_zero(map); | |||
1218 | ||||
1219 | debug("map=%p '%s' zero\n", map, bv_name(bv)); | |||
1220 | } | |||
1221 | ||||
1222 | struct bt_arg * | |||
1223 | ba_read(struct bt_arg *ba) | |||
1224 | { | |||
1225 | struct bt_var *bv = ba->ba_value; | |||
1226 | ||||
1227 | assert(ba->ba_type == B_AT_VAR)((ba->ba_type == B_AT_VAR) ? (void)0 : __assert2("/usr/src/usr.sbin/btrace/btrace.c" , 1227, __func__, "ba->ba_type == B_AT_VAR")); | |||
1228 | debug("bv=%p read '%s' (%p)\n", bv, bv_name(bv), bv->bv_value); | |||
1229 | ||||
1230 | /* Handle map/hist access after clear(). */ | |||
1231 | if (bv->bv_value == NULL((void *)0)) | |||
1232 | return &g_nullba; | |||
1233 | ||||
1234 | return bv->bv_value; | |||
1235 | } | |||
1236 | ||||
1237 | // XXX | |||
1238 | extern struct bt_arg *ba_append(struct bt_arg *, struct bt_arg *); | |||
1239 | ||||
1240 | /* | |||
1241 | * Return a new argument that doesn't depend on `dtev'. This is used | |||
1242 | * when storing values in variables, maps, etc. | |||
1243 | */ | |||
1244 | struct bt_arg * | |||
1245 | baeval(struct bt_arg *bval, struct dt_evt *dtev) | |||
1246 | { | |||
1247 | struct bt_arg *ba, *bh = NULL((void *)0); | |||
1248 | ||||
1249 | switch (bval->ba_type) { | |||
1250 | case B_AT_VAR: | |||
1251 | ba = baeval(ba_read(bval), NULL((void *)0)); | |||
1252 | break; | |||
1253 | case B_AT_LONG: | |||
1254 | case B_AT_BI_PID: | |||
1255 | case B_AT_BI_TID: | |||
1256 | case B_AT_BI_CPU: | |||
1257 | case B_AT_BI_NSECS: | |||
1258 | case B_AT_BI_ARG0 ... B_AT_BI_ARG9: | |||
1259 | case B_AT_BI_RETVAL: | |||
1260 | case B_AT_OP_PLUS ... B_AT_OP_LOR: | |||
1261 | ba = ba_new(ba2long(bval, dtev), B_AT_LONG)ba_new0((void *)(ba2long(bval, dtev)), (B_AT_LONG)); | |||
1262 | break; | |||
1263 | case B_AT_STR: | |||
1264 | case B_AT_BI_COMM: | |||
1265 | case B_AT_BI_KSTACK: | |||
1266 | case B_AT_BI_USTACK: | |||
1267 | case B_AT_BI_PROBE: | |||
1268 | case B_AT_FN_STR: | |||
1269 | ba = ba_new(ba2str(bval, dtev), B_AT_STR)ba_new0((void *)(ba2str(bval, dtev)), (B_AT_STR)); | |||
1270 | break; | |||
1271 | case B_AT_TUPLE: | |||
1272 | ba = bval->ba_value; | |||
1273 | do { | |||
1274 | bh = ba_append(bh, baeval(ba, dtev)); | |||
1275 | } while ((ba = SLIST_NEXT(ba, ba_next)((ba)->ba_next.sle_next)) != NULL((void *)0)); | |||
1276 | ba = ba_new(bh, B_AT_TUPLE)ba_new0((void *)(bh), (B_AT_TUPLE)); | |||
1277 | break; | |||
1278 | default: | |||
1279 | xabort("no eval support for type %d", bval->ba_type); | |||
1280 | } | |||
1281 | ||||
1282 | return ba; | |||
1283 | } | |||
1284 | ||||
1285 | /* | |||
1286 | * Return a string of coma-separated values | |||
1287 | */ | |||
1288 | const char * | |||
1289 | ba2hash(struct bt_arg *ba, struct dt_evt *dtev) | |||
1290 | { | |||
1291 | static char buf[KLEN1024]; | |||
1292 | char *hash; | |||
1293 | int l, len; | |||
1294 | ||||
1295 | buf[0] = '\0'; | |||
1296 | l = snprintf(buf, sizeof(buf), "%s", ba2str(ba, dtev)); | |||
1297 | if (l < 0 || (size_t)l > sizeof(buf)) { | |||
1298 | warn("string too long %d > %lu", l, sizeof(buf)); | |||
1299 | return buf; | |||
1300 | } | |||
1301 | ||||
1302 | len = 0; | |||
1303 | while ((ba = SLIST_NEXT(ba, ba_next)((ba)->ba_next.sle_next)) != NULL((void *)0)) { | |||
1304 | len += l; | |||
1305 | hash = buf + len; | |||
1306 | ||||
1307 | l = snprintf(hash, sizeof(buf) - len, ", %s", ba2str(ba, dtev)); | |||
1308 | if (l < 0 || (size_t)l > (sizeof(buf) - len)) { | |||
1309 | warn("hash too long %d > %lu", l + len, sizeof(buf)); | |||
1310 | break; | |||
1311 | } | |||
1312 | } | |||
1313 | ||||
1314 | return buf; | |||
1315 | } | |||
1316 | ||||
1317 | static unsigned long | |||
1318 | next_pow2(unsigned long x) | |||
1319 | { | |||
1320 | size_t i; | |||
1321 | ||||
1322 | x--; | |||
1323 | for (i = 0; i < (sizeof(x) * 8) - 1; i++) | |||
1324 | x |= (x >> 1); | |||
1325 | ||||
1326 | return x + 1; | |||
1327 | } | |||
1328 | ||||
1329 | /* | |||
1330 | * Return the ceiling value the interval holding `ba' or NULL if it is | |||
1331 | * out of the (min, max) values. | |||
1332 | */ | |||
1333 | const char * | |||
1334 | ba2bucket(struct bt_arg *ba, struct bt_arg *brange, struct dt_evt *dtev, | |||
1335 | long *pstep) | |||
1336 | { | |||
1337 | static char buf[KLEN1024]; | |||
1338 | long val, bucket; | |||
1339 | int l; | |||
1340 | ||||
1341 | val = ba2long(ba, dtev); | |||
1342 | if (brange == NULL((void *)0)) | |||
1343 | bucket = next_pow2(val); | |||
1344 | else { | |||
1345 | long min, max, step; | |||
1346 | ||||
1347 | assert(brange->ba_type == B_AT_LONG)((brange->ba_type == B_AT_LONG) ? (void)0 : __assert2("/usr/src/usr.sbin/btrace/btrace.c" , 1347, __func__, "brange->ba_type == B_AT_LONG")); | |||
1348 | min = ba2long(brange, NULL((void *)0)); | |||
1349 | ||||
1350 | brange = SLIST_NEXT(brange, ba_next)((brange)->ba_next.sle_next); | |||
1351 | assert(brange->ba_type == B_AT_LONG)((brange->ba_type == B_AT_LONG) ? (void)0 : __assert2("/usr/src/usr.sbin/btrace/btrace.c" , 1351, __func__, "brange->ba_type == B_AT_LONG")); | |||
1352 | max = ba2long(brange, NULL((void *)0)); | |||
1353 | ||||
1354 | if ((val < min) || (val > max)) | |||
1355 | return NULL((void *)0); | |||
1356 | ||||
1357 | brange = SLIST_NEXT(brange, ba_next)((brange)->ba_next.sle_next); | |||
1358 | assert(brange->ba_type == B_AT_LONG)((brange->ba_type == B_AT_LONG) ? (void)0 : __assert2("/usr/src/usr.sbin/btrace/btrace.c" , 1358, __func__, "brange->ba_type == B_AT_LONG")); | |||
1359 | step = ba2long(brange, NULL((void *)0)); | |||
1360 | ||||
1361 | bucket = ((val / step) + 1) * step; | |||
1362 | *pstep = step; | |||
1363 | } | |||
1364 | ||||
1365 | buf[0] = '\0'; | |||
1366 | l = snprintf(buf, sizeof(buf), "%lu", bucket); | |||
1367 | if (l < 0 || (size_t)l > sizeof(buf)) { | |||
1368 | warn("string too long %d > %lu", l, sizeof(buf)); | |||
1369 | return buf; | |||
1370 | } | |||
1371 | ||||
1372 | return buf; | |||
1373 | } | |||
1374 | ||||
1375 | /* | |||
1376 | * Evaluate the operation encoded in `ba' and return its result. | |||
1377 | */ | |||
1378 | long | |||
1379 | baexpr2long(struct bt_arg *ba, struct dt_evt *dtev) | |||
1380 | { | |||
1381 | static long recursions; | |||
1382 | struct bt_arg *lhs, *rhs; | |||
1383 | long lval, rval, result; | |||
1384 | ||||
1385 | if (++recursions >= __MAXOPERANDS5) | |||
1386 | errx(1, "too many operands (>%d) in expression", __MAXOPERANDS5); | |||
1387 | ||||
1388 | lhs = ba->ba_value; | |||
1389 | rhs = SLIST_NEXT(lhs, ba_next)((lhs)->ba_next.sle_next); | |||
1390 | ||||
1391 | /* | |||
1392 | * String comparison also use '==' and '!='. | |||
1393 | */ | |||
1394 | if (lhs->ba_type == B_AT_STR || | |||
1395 | (rhs != NULL((void *)0) && rhs->ba_type == B_AT_STR)) { | |||
1396 | char lstr[STRLEN64], rstr[STRLEN64]; | |||
1397 | ||||
1398 | strlcpy(lstr, ba2str(lhs, dtev), sizeof(lstr)); | |||
1399 | strlcpy(rstr, ba2str(rhs, dtev), sizeof(rstr)); | |||
1400 | ||||
1401 | result = strncmp(lstr, rstr, STRLEN64) == 0; | |||
1402 | ||||
1403 | switch (ba->ba_type) { | |||
1404 | case B_AT_OP_EQ: | |||
1405 | break; | |||
1406 | case B_AT_OP_NE: | |||
1407 | result = !result; | |||
1408 | break; | |||
1409 | default: | |||
1410 | warnx("operation '%d' unsupported on strings", | |||
1411 | ba->ba_type); | |||
1412 | result = 1; | |||
1413 | } | |||
1414 | ||||
1415 | debug("ba=%p eval '(%s %s %s) = %d'\n", ba, lstr, ba_name(ba), | |||
1416 | rstr, result); | |||
1417 | ||||
1418 | goto out; | |||
1419 | } | |||
1420 | ||||
1421 | lval = ba2long(lhs, dtev); | |||
1422 | if (rhs
| |||
1423 | rval = 0; | |||
1424 | } else { | |||
1425 | assert(SLIST_NEXT(rhs, ba_next) == NULL)((((rhs)->ba_next.sle_next) == ((void *)0)) ? (void)0 : __assert2 ("/usr/src/usr.sbin/btrace/btrace.c", 1425, __func__, "SLIST_NEXT(rhs, ba_next) == NULL" )); | |||
1426 | rval = ba2long(rhs, dtev); | |||
1427 | } | |||
1428 | ||||
1429 | switch (ba->ba_type) { | |||
1430 | case B_AT_OP_PLUS: | |||
1431 | result = lval + rval; | |||
1432 | break; | |||
1433 | case B_AT_OP_MINUS: | |||
1434 | result = lval - rval; | |||
1435 | break; | |||
1436 | case B_AT_OP_MULT: | |||
1437 | result = lval * rval; | |||
1438 | break; | |||
1439 | case B_AT_OP_DIVIDE: | |||
1440 | result = lval / rval; | |||
| ||||
1441 | break; | |||
1442 | case B_AT_OP_MODULO: | |||
1443 | result = lval % rval; | |||
1444 | break; | |||
1445 | case B_AT_OP_BAND: | |||
1446 | result = lval & rval; | |||
1447 | break; | |||
1448 | case B_AT_OP_XOR: | |||
1449 | result = lval ^ rval; | |||
1450 | break; | |||
1451 | case B_AT_OP_BOR: | |||
1452 | result = lval | rval; | |||
1453 | break; | |||
1454 | case B_AT_OP_EQ: | |||
1455 | result = (lval == rval); | |||
1456 | break; | |||
1457 | case B_AT_OP_NE: | |||
1458 | result = (lval != rval); | |||
1459 | break; | |||
1460 | case B_AT_OP_LE: | |||
1461 | result = (lval <= rval); | |||
1462 | break; | |||
1463 | case B_AT_OP_LT: | |||
1464 | result = (lval < rval); | |||
1465 | break; | |||
1466 | case B_AT_OP_GE: | |||
1467 | result = (lval >= rval); | |||
1468 | break; | |||
1469 | case B_AT_OP_GT: | |||
1470 | result = (lval > rval); | |||
1471 | break; | |||
1472 | case B_AT_OP_LAND: | |||
1473 | result = (lval && rval); | |||
1474 | break; | |||
1475 | case B_AT_OP_LOR: | |||
1476 | result = (lval || rval); | |||
1477 | break; | |||
1478 | default: | |||
1479 | xabort("unsupported operation %d", ba->ba_type); | |||
1480 | } | |||
1481 | ||||
1482 | debug("ba=%p eval '(%ld %s %ld) = %d'\n", ba, lval, ba_name(ba), | |||
1483 | rval, result); | |||
1484 | ||||
1485 | out: | |||
1486 | --recursions; | |||
1487 | ||||
1488 | return result; | |||
1489 | } | |||
1490 | ||||
1491 | const char * | |||
1492 | ba_name(struct bt_arg *ba) | |||
1493 | { | |||
1494 | switch (ba->ba_type) { | |||
1495 | case B_AT_STR: | |||
1496 | return (const char *)ba->ba_value; | |||
1497 | case B_AT_LONG: | |||
1498 | return ba2str(ba, NULL((void *)0)); | |||
1499 | case B_AT_NIL: | |||
1500 | return "0"; | |||
1501 | case B_AT_VAR: | |||
1502 | case B_AT_MAP: | |||
1503 | case B_AT_HIST: | |||
1504 | break; | |||
1505 | case B_AT_BI_PID: | |||
1506 | return "pid"; | |||
1507 | case B_AT_BI_TID: | |||
1508 | return "tid"; | |||
1509 | case B_AT_BI_COMM: | |||
1510 | return "comm"; | |||
1511 | case B_AT_BI_CPU: | |||
1512 | return "cpu"; | |||
1513 | case B_AT_BI_NSECS: | |||
1514 | return "nsecs"; | |||
1515 | case B_AT_BI_KSTACK: | |||
1516 | return "kstack"; | |||
1517 | case B_AT_BI_USTACK: | |||
1518 | return "ustack"; | |||
1519 | case B_AT_BI_ARG0: | |||
1520 | return "arg0"; | |||
1521 | case B_AT_BI_ARG1: | |||
1522 | return "arg1"; | |||
1523 | case B_AT_BI_ARG2: | |||
1524 | return "arg2"; | |||
1525 | case B_AT_BI_ARG3: | |||
1526 | return "arg3"; | |||
1527 | case B_AT_BI_ARG4: | |||
1528 | return "arg4"; | |||
1529 | case B_AT_BI_ARG5: | |||
1530 | return "arg5"; | |||
1531 | case B_AT_BI_ARG6: | |||
1532 | return "arg6"; | |||
1533 | case B_AT_BI_ARG7: | |||
1534 | return "arg7"; | |||
1535 | case B_AT_BI_ARG8: | |||
1536 | return "arg8"; | |||
1537 | case B_AT_BI_ARG9: | |||
1538 | return "arg9"; | |||
1539 | case B_AT_BI_ARGS: | |||
1540 | return "args"; | |||
1541 | case B_AT_BI_RETVAL: | |||
1542 | return "retval"; | |||
1543 | case B_AT_BI_PROBE: | |||
1544 | return "probe"; | |||
1545 | case B_AT_FN_STR: | |||
1546 | return "str"; | |||
1547 | case B_AT_OP_PLUS: | |||
1548 | return "+"; | |||
1549 | case B_AT_OP_MINUS: | |||
1550 | return "-"; | |||
1551 | case B_AT_OP_MULT: | |||
1552 | return "*"; | |||
1553 | case B_AT_OP_DIVIDE: | |||
1554 | return "/"; | |||
1555 | case B_AT_OP_MODULO: | |||
1556 | return "%"; | |||
1557 | case B_AT_OP_BAND: | |||
1558 | return "&"; | |||
1559 | case B_AT_OP_XOR: | |||
1560 | return "^"; | |||
1561 | case B_AT_OP_BOR: | |||
1562 | return "|"; | |||
1563 | case B_AT_OP_EQ: | |||
1564 | return "=="; | |||
1565 | case B_AT_OP_NE: | |||
1566 | return "!="; | |||
1567 | case B_AT_OP_LE: | |||
1568 | return "<="; | |||
1569 | case B_AT_OP_LT: | |||
1570 | return "<"; | |||
1571 | case B_AT_OP_GE: | |||
1572 | return ">="; | |||
1573 | case B_AT_OP_GT: | |||
1574 | return ">"; | |||
1575 | case B_AT_OP_LAND: | |||
1576 | return "&&"; | |||
1577 | case B_AT_OP_LOR: | |||
1578 | return "||"; | |||
1579 | default: | |||
1580 | xabort("unsupported type %d", ba->ba_type); | |||
1581 | } | |||
1582 | ||||
1583 | assert(ba->ba_type == B_AT_VAR || ba->ba_type == B_AT_MAP ||((ba->ba_type == B_AT_VAR || ba->ba_type == B_AT_MAP || ba->ba_type == B_AT_HIST) ? (void)0 : __assert2("/usr/src/usr.sbin/btrace/btrace.c" , 1584, __func__, "ba->ba_type == B_AT_VAR || ba->ba_type == B_AT_MAP || ba->ba_type == B_AT_HIST" )) | |||
1584 | ba->ba_type == B_AT_HIST)((ba->ba_type == B_AT_VAR || ba->ba_type == B_AT_MAP || ba->ba_type == B_AT_HIST) ? (void)0 : __assert2("/usr/src/usr.sbin/btrace/btrace.c" , 1584, __func__, "ba->ba_type == B_AT_VAR || ba->ba_type == B_AT_MAP || ba->ba_type == B_AT_HIST" )); | |||
1585 | ||||
1586 | static char buf[64]; | |||
1587 | size_t sz; | |||
1588 | int l; | |||
1589 | ||||
1590 | buf[0] = '@'; | |||
1591 | buf[1] = '\0'; | |||
1592 | sz = sizeof(buf) - 1; | |||
1593 | l = snprintf(buf+1, sz, "%s", bv_name(ba->ba_value)); | |||
1594 | if (l < 0 || (size_t)l > sz) { | |||
1595 | warn("string too long %d > %zu", l, sz); | |||
1596 | return buf; | |||
1597 | } | |||
1598 | ||||
1599 | if (ba->ba_type == B_AT_MAP) { | |||
1600 | sz -= l; | |||
1601 | l = snprintf(buf+1+l, sz, "[%s]", ba_name(ba->ba_key)); | |||
1602 | if (l < 0 || (size_t)l > sz) { | |||
1603 | warn("string too long %d > %zu", l, sz); | |||
1604 | return buf; | |||
1605 | } | |||
1606 | } | |||
1607 | ||||
1608 | return buf; | |||
1609 | } | |||
1610 | ||||
1611 | /* | |||
1612 | * Return the representation of `ba' as long. | |||
1613 | */ | |||
1614 | long | |||
1615 | ba2long(struct bt_arg *ba, struct dt_evt *dtev) | |||
1616 | { | |||
1617 | struct bt_var *bv; | |||
1618 | long val; | |||
1619 | ||||
1620 | switch (ba->ba_type) { | |||
1621 | case B_AT_LONG: | |||
1622 | val = (long)ba->ba_value; | |||
1623 | break; | |||
1624 | case B_AT_VAR: | |||
1625 | ba = ba_read(ba); | |||
1626 | val = (long)ba->ba_value; | |||
1627 | break; | |||
1628 | case B_AT_MAP: | |||
1629 | bv = ba->ba_value; | |||
1630 | /* Uninitialized map */ | |||
1631 | if (bv->bv_value == NULL((void *)0)) | |||
1632 | return 0; | |||
1633 | val = ba2long(map_get((struct map *)bv->bv_value, | |||
1634 | ba2str(ba->ba_key, dtev)), dtev); | |||
1635 | break; | |||
1636 | case B_AT_NIL: | |||
1637 | val = 0L; | |||
1638 | break; | |||
1639 | case B_AT_BI_PID: | |||
1640 | val = dtev->dtev_pid; | |||
1641 | break; | |||
1642 | case B_AT_BI_TID: | |||
1643 | val = dtev->dtev_tid; | |||
1644 | break; | |||
1645 | case B_AT_BI_CPU: | |||
1646 | val = dtev->dtev_cpu; | |||
1647 | break; | |||
1648 | case B_AT_BI_NSECS: | |||
1649 | val = builtin_nsecs(dtev); | |||
1650 | break; | |||
1651 | case B_AT_BI_ARG0 ... B_AT_BI_ARG9: | |||
1652 | val = dtev->dtev_args_args.E_entry[ba->ba_type - B_AT_BI_ARG0]; | |||
1653 | break; | |||
1654 | case B_AT_BI_RETVAL: | |||
1655 | val = dtev->dtev_retval_args.E_return.__retval[0]; | |||
1656 | break; | |||
1657 | case B_AT_BI_PROBE: | |||
1658 | val = dtev->dtev_pbn; | |||
1659 | break; | |||
1660 | case B_AT_OP_PLUS ... B_AT_OP_LOR: | |||
1661 | val = baexpr2long(ba, dtev); | |||
1662 | break; | |||
1663 | default: | |||
1664 | xabort("no long conversion for type %d", ba->ba_type); | |||
1665 | } | |||
1666 | ||||
1667 | return val; | |||
1668 | } | |||
1669 | ||||
1670 | /* | |||
1671 | * Return the representation of `ba' as string. | |||
1672 | */ | |||
1673 | const char * | |||
1674 | ba2str(struct bt_arg *ba, struct dt_evt *dtev) | |||
1675 | { | |||
1676 | static char buf[STRLEN64]; | |||
1677 | struct bt_var *bv; | |||
1678 | struct dtioc_probe_info *dtpi; | |||
1679 | unsigned long idx; | |||
1680 | const char *str; | |||
1681 | ||||
1682 | buf[0] = '\0'; | |||
1683 | switch (ba->ba_type) { | |||
1684 | case B_AT_STR: | |||
1685 | str = (const char *)ba->ba_value; | |||
1686 | break; | |||
1687 | case B_AT_LONG: | |||
1688 | snprintf(buf, sizeof(buf), "%ld",(long)ba->ba_value); | |||
1689 | str = buf; | |||
1690 | break; | |||
1691 | case B_AT_TUPLE: | |||
1692 | snprintf(buf, sizeof(buf), "(%s)", ba2hash(ba->ba_value, dtev)); | |||
1693 | str = buf; | |||
1694 | break; | |||
1695 | case B_AT_TMEMBER: | |||
1696 | idx = (unsigned long)ba->ba_key; | |||
1697 | bv = ba->ba_value; | |||
1698 | /* Uninitialized tuple */ | |||
1699 | if (bv->bv_value == NULL((void *)0)) { | |||
1700 | str = buf; | |||
1701 | break; | |||
1702 | } | |||
1703 | ba = bv->bv_value; | |||
1704 | assert(ba->ba_type == B_AT_TUPLE)((ba->ba_type == B_AT_TUPLE) ? (void)0 : __assert2("/usr/src/usr.sbin/btrace/btrace.c" , 1704, __func__, "ba->ba_type == B_AT_TUPLE")); | |||
1705 | ba = ba->ba_value; | |||
1706 | while (ba != NULL((void *)0) && idx-- > 0) { | |||
1707 | ba = SLIST_NEXT(ba, ba_next)((ba)->ba_next.sle_next); | |||
1708 | } | |||
1709 | str = ba2str(ba, dtev); | |||
1710 | break; | |||
1711 | case B_AT_NIL: | |||
1712 | str = ""; | |||
1713 | break; | |||
1714 | case B_AT_BI_KSTACK: | |||
1715 | str = builtin_stack(dtev, 1, 0); | |||
1716 | break; | |||
1717 | case B_AT_BI_USTACK: | |||
1718 | str = builtin_stack(dtev, 0, dt_get_offset(dtev->dtev_pid)); | |||
1719 | break; | |||
1720 | case B_AT_BI_COMM: | |||
1721 | str = dtev->dtev_comm; | |||
1722 | break; | |||
1723 | case B_AT_BI_CPU: | |||
1724 | snprintf(buf, sizeof(buf), "%u", dtev->dtev_cpu); | |||
1725 | str = buf; | |||
1726 | break; | |||
1727 | case B_AT_BI_PID: | |||
1728 | snprintf(buf, sizeof(buf), "%d", dtev->dtev_pid); | |||
1729 | str = buf; | |||
1730 | break; | |||
1731 | case B_AT_BI_TID: | |||
1732 | snprintf(buf, sizeof(buf), "%d", dtev->dtev_tid); | |||
1733 | str = buf; | |||
1734 | break; | |||
1735 | case B_AT_BI_NSECS: | |||
1736 | snprintf(buf, sizeof(buf), "%llu", builtin_nsecs(dtev)); | |||
1737 | str = buf; | |||
1738 | break; | |||
1739 | case B_AT_BI_ARG0 ... B_AT_BI_ARG9: | |||
1740 | str = builtin_arg(dtev, ba->ba_type); | |||
1741 | break; | |||
1742 | case B_AT_BI_RETVAL: | |||
1743 | snprintf(buf, sizeof(buf), "%ld", (long)dtev->dtev_retval_args.E_return.__retval[0]); | |||
1744 | str = buf; | |||
1745 | break; | |||
1746 | case B_AT_BI_PROBE: | |||
1747 | if (dtev->dtev_pbn == EVENT_BEGIN0) { | |||
1748 | str = "BEGIN"; | |||
1749 | break; | |||
1750 | } else if (dtev->dtev_pbn == EVENT_END(unsigned int)(-1)) { | |||
1751 | str = "END"; | |||
1752 | break; | |||
1753 | } | |||
1754 | dtpi = &dt_dtpis[dtev->dtev_pbn - 1]; | |||
1755 | if (dtpi != NULL((void *)0)) | |||
1756 | snprintf(buf, sizeof(buf), "%s:%s:%s", | |||
1757 | dtpi->dtpi_prov, dtpi_func(dtpi), dtpi->dtpi_name); | |||
1758 | else | |||
1759 | snprintf(buf, sizeof(buf), "%u", dtev->dtev_pbn); | |||
1760 | str = buf; | |||
1761 | break; | |||
1762 | case B_AT_MAP: | |||
1763 | bv = ba->ba_value; | |||
1764 | /* Uninitialized map */ | |||
1765 | if (bv->bv_value == NULL((void *)0)) { | |||
1766 | str = buf; | |||
1767 | break; | |||
1768 | } | |||
1769 | str = ba2str(map_get((struct map *)bv->bv_value, | |||
1770 | ba2str(ba->ba_key, dtev)), dtev); | |||
1771 | break; | |||
1772 | case B_AT_VAR: | |||
1773 | str = ba2str(ba_read(ba), dtev); | |||
1774 | break; | |||
1775 | case B_AT_FN_STR: | |||
1776 | str = (const char*)(fn_str(ba, dtev, buf))->ba_value; | |||
1777 | break; | |||
1778 | case B_AT_OP_PLUS ... B_AT_OP_LOR: | |||
1779 | snprintf(buf, sizeof(buf), "%ld", ba2long(ba, dtev)); | |||
1780 | str = buf; | |||
1781 | break; | |||
1782 | case B_AT_MF_COUNT: | |||
1783 | case B_AT_MF_MAX: | |||
1784 | case B_AT_MF_MIN: | |||
1785 | case B_AT_MF_SUM: | |||
1786 | assert(0)((0) ? (void)0 : __assert2("/usr/src/usr.sbin/btrace/btrace.c" , 1786, __func__, "0")); | |||
1787 | break; | |||
1788 | default: | |||
1789 | xabort("no string conversion for type %d", ba->ba_type); | |||
1790 | } | |||
1791 | ||||
1792 | return str; | |||
1793 | } | |||
1794 | ||||
1795 | /* | |||
1796 | * Return dt(4) flags indicating which data should be recorded by the | |||
1797 | * kernel, if any, for a given `ba'. | |||
1798 | */ | |||
1799 | int | |||
1800 | ba2dtflags(struct bt_arg *ba) | |||
1801 | { | |||
1802 | static long recursions; | |||
1803 | struct bt_arg *bval; | |||
1804 | int flags = 0; | |||
1805 | ||||
1806 | if (++recursions >= __MAXOPERANDS5) | |||
1807 | errx(1, "too many operands (>%d) in expression", __MAXOPERANDS5); | |||
1808 | ||||
1809 | do { | |||
1810 | if (ba->ba_type == B_AT_MAP) | |||
1811 | bval = ba->ba_key; | |||
1812 | else | |||
1813 | bval = ba; | |||
1814 | ||||
1815 | switch (bval->ba_type) { | |||
1816 | case B_AT_STR: | |||
1817 | case B_AT_LONG: | |||
1818 | case B_AT_TUPLE: | |||
1819 | case B_AT_TMEMBER: | |||
1820 | case B_AT_VAR: | |||
1821 | case B_AT_HIST: | |||
1822 | case B_AT_NIL: | |||
1823 | break; | |||
1824 | case B_AT_BI_KSTACK: | |||
1825 | flags |= DTEVT_KSTACK(1 << 2); | |||
1826 | break; | |||
1827 | case B_AT_BI_USTACK: | |||
1828 | flags |= DTEVT_USTACK(1 << 1); | |||
1829 | break; | |||
1830 | case B_AT_BI_COMM: | |||
1831 | flags |= DTEVT_EXECNAME(1 << 0); | |||
1832 | break; | |||
1833 | case B_AT_BI_CPU: | |||
1834 | case B_AT_BI_PID: | |||
1835 | case B_AT_BI_TID: | |||
1836 | case B_AT_BI_NSECS: | |||
1837 | break; | |||
1838 | case B_AT_BI_ARG0 ... B_AT_BI_ARG9: | |||
1839 | flags |= DTEVT_FUNCARGS(1 << 3); | |||
1840 | break; | |||
1841 | case B_AT_BI_RETVAL: | |||
1842 | case B_AT_BI_PROBE: | |||
1843 | break; | |||
1844 | case B_AT_MF_COUNT: | |||
1845 | case B_AT_MF_MAX: | |||
1846 | case B_AT_MF_MIN: | |||
1847 | case B_AT_MF_SUM: | |||
1848 | case B_AT_FN_STR: | |||
1849 | break; | |||
1850 | case B_AT_OP_PLUS ... B_AT_OP_LOR: | |||
1851 | flags |= ba2dtflags(bval->ba_value); | |||
1852 | break; | |||
1853 | default: | |||
1854 | xabort("invalid argument type %d", bval->ba_type); | |||
1855 | } | |||
1856 | } while ((ba = SLIST_NEXT(ba, ba_next)((ba)->ba_next.sle_next)) != NULL((void *)0)); | |||
1857 | ||||
1858 | --recursions; | |||
1859 | ||||
1860 | return flags; | |||
1861 | } | |||
1862 | ||||
1863 | long | |||
1864 | bacmp(struct bt_arg *a, struct bt_arg *b) | |||
1865 | { | |||
1866 | long val; | |||
1867 | ||||
1868 | if (a->ba_type != b->ba_type) | |||
1869 | return a->ba_type - b->ba_type; | |||
1870 | ||||
1871 | switch (a->ba_type) { | |||
1872 | case B_AT_LONG: | |||
1873 | return ba2long(a, NULL((void *)0)) - ba2long(b, NULL((void *)0)); | |||
1874 | case B_AT_STR: | |||
1875 | return strcmp(ba2str(a, NULL((void *)0)), ba2str(b, NULL((void *)0))); | |||
1876 | case B_AT_TUPLE: | |||
1877 | /* Compare two lists of arguments one by one. */ | |||
1878 | do { | |||
1879 | val = bacmp(a, b); | |||
1880 | if (val != 0) | |||
1881 | break; | |||
1882 | ||||
1883 | a = SLIST_NEXT(a, ba_next)((a)->ba_next.sle_next); | |||
1884 | b = SLIST_NEXT(b, ba_next)((b)->ba_next.sle_next); | |||
1885 | if (a == NULL((void *)0) && b != NULL((void *)0)) | |||
1886 | val = -1; | |||
1887 | else if (a != NULL((void *)0) && b == NULL((void *)0)) | |||
1888 | val = 1; | |||
1889 | } while (a != NULL((void *)0) && b != NULL((void *)0)); | |||
1890 | ||||
1891 | return val; | |||
1892 | default: | |||
1893 | xabort("no compare support for type %d", a->ba_type); | |||
1894 | } | |||
1895 | } | |||
1896 | ||||
1897 | __dead__attribute__((__noreturn__)) void | |||
1898 | xabort(const char *fmt, ...) | |||
1899 | { | |||
1900 | va_list ap; | |||
1901 | ||||
1902 | va_start(ap, fmt)__builtin_va_start((ap), fmt); | |||
1903 | vfprintf(stderr(&__sF[2]), fmt, ap); | |||
1904 | va_end(ap)__builtin_va_end((ap)); | |||
1905 | ||||
1906 | fprintf(stderr(&__sF[2]), "\n"); | |||
1907 | abort(); | |||
1908 | } | |||
1909 | ||||
1910 | void | |||
1911 | debug(const char *fmt, ...) | |||
1912 | { | |||
1913 | va_list ap; | |||
1914 | ||||
1915 | if (verbose < 2) | |||
1916 | return; | |||
1917 | ||||
1918 | fprintf(stderr(&__sF[2]), "debug: "); | |||
1919 | ||||
1920 | va_start(ap, fmt)__builtin_va_start((ap), fmt); | |||
1921 | vfprintf(stderr(&__sF[2]), fmt, ap); | |||
1922 | va_end(ap)__builtin_va_end((ap)); | |||
1923 | } | |||
1924 | ||||
1925 | void | |||
1926 | debugx(const char *fmt, ...) | |||
1927 | { | |||
1928 | va_list ap; | |||
1929 | ||||
1930 | if (verbose < 2) | |||
1931 | return; | |||
1932 | ||||
1933 | va_start(ap, fmt)__builtin_va_start((ap), fmt); | |||
1934 | vfprintf(stderr(&__sF[2]), fmt, ap); | |||
1935 | va_end(ap)__builtin_va_end((ap)); | |||
1936 | } | |||
1937 | ||||
1938 | void | |||
1939 | debug_dump_term(struct bt_arg *ba) | |||
1940 | { | |||
1941 | switch (ba->ba_type) { | |||
1942 | case B_AT_LONG: | |||
1943 | debugx("%s", ba2str(ba, NULL((void *)0))); | |||
1944 | break; | |||
1945 | case B_AT_OP_PLUS ... B_AT_OP_LOR: | |||
1946 | debug_dump_expr(ba); | |||
1947 | break; | |||
1948 | default: | |||
1949 | debugx("%s", ba_name(ba)); | |||
1950 | } | |||
1951 | } | |||
1952 | ||||
1953 | void | |||
1954 | debug_dump_expr(struct bt_arg *ba) | |||
1955 | { | |||
1956 | struct bt_arg *lhs, *rhs; | |||
1957 | ||||
1958 | lhs = ba->ba_value; | |||
1959 | rhs = SLIST_NEXT(lhs, ba_next)((lhs)->ba_next.sle_next); | |||
1960 | ||||
1961 | /* Left */ | |||
1962 | debug_dump_term(lhs); | |||
1963 | ||||
1964 | /* Right */ | |||
1965 | if (rhs != NULL((void *)0)) { | |||
1966 | debugx(" %s ", ba_name(ba)); | |||
1967 | debug_dump_term(rhs); | |||
1968 | } else { | |||
1969 | if (ba->ba_type != B_AT_OP_NE) | |||
1970 | debugx(" %s NULL", ba_name(ba)); | |||
1971 | } | |||
1972 | } | |||
1973 | ||||
1974 | void | |||
1975 | debug_dump_filter(struct bt_rule *r) | |||
1976 | { | |||
1977 | struct bt_stmt *bs; | |||
1978 | ||||
1979 | if (verbose < 2) | |||
1980 | return; | |||
1981 | ||||
1982 | if (r->br_filter == NULL((void *)0)) { | |||
1983 | debugx("\n"); | |||
1984 | return; | |||
1985 | } | |||
1986 | ||||
1987 | bs = r->br_filter->bf_condition; | |||
1988 | ||||
1989 | debugx(" /"); | |||
1990 | debug_dump_expr(SLIST_FIRST(&bs->bs_args)((&bs->bs_args)->slh_first)); | |||
1991 | debugx("/\n"); | |||
1992 | } | |||
1993 | ||||
1994 | const char * | |||
1995 | debug_probe_name(struct bt_probe *bp) | |||
1996 | { | |||
1997 | static char buf[64]; | |||
1998 | ||||
1999 | if (verbose < 2) | |||
2000 | return ""; | |||
2001 | ||||
2002 | if (bp->bp_type == B_PT_BEGIN) | |||
2003 | return "BEGIN"; | |||
2004 | ||||
2005 | if (bp->bp_type == B_PT_END) | |||
2006 | return "END"; | |||
2007 | ||||
2008 | assert(bp->bp_type == B_PT_PROBE)((bp->bp_type == B_PT_PROBE) ? (void)0 : __assert2("/usr/src/usr.sbin/btrace/btrace.c" , 2008, __func__, "bp->bp_type == B_PT_PROBE")); | |||
2009 | ||||
2010 | if (bp->bp_rate) { | |||
2011 | snprintf(buf, sizeof(buf), "%s:%s:%u", bp->bp_prov, | |||
2012 | bp->bp_unitbp_func, bp->bp_rate); | |||
2013 | } else { | |||
2014 | snprintf(buf, sizeof(buf), "%s:%s:%s", bp->bp_prov, | |||
2015 | bp->bp_unitbp_func, bp->bp_name); | |||
2016 | } | |||
2017 | ||||
2018 | return buf; | |||
2019 | } | |||
2020 | ||||
2021 | unsigned long | |||
2022 | dt_get_offset(pid_t pid) | |||
2023 | { | |||
2024 | static struct dtioc_getaux cache[32]; | |||
2025 | static int next; | |||
2026 | struct dtioc_getaux *aux = NULL((void *)0); | |||
2027 | int i; | |||
2028 | ||||
2029 | for (i = 0; i < 32; i++) { | |||
2030 | if (cache[i].dtga_pid != pid) | |||
2031 | continue; | |||
2032 | aux = cache + i; | |||
2033 | break; | |||
2034 | } | |||
2035 | ||||
2036 | if (aux == NULL((void *)0)) { | |||
2037 | aux = &cache[next++]; | |||
2038 | next %= 32; | |||
2039 | ||||
2040 | aux->dtga_pid = pid; | |||
2041 | if (ioctl(dtfd, DTIOCGETAUXBASE(((unsigned long)0x80000000|(unsigned long)0x40000000) | ((sizeof (struct dtioc_getaux) & 0x1fff) << 16) | ((('D')) << 8) | ((7))), aux)) | |||
2042 | aux->dtga_auxbase = 0; | |||
2043 | } | |||
2044 | ||||
2045 | return aux->dtga_auxbase; | |||
2046 | } |