/usr/src/usr.sbin/btrace/btrace.c

Bug Summary

File:	src/usr.sbin/btrace/btrace.c
Warning:	line 1195, column 17 Division by zero
Annotated Source Code

Press '?' to see keyboard shortcuts
Show analyzer invocation
clang -cc1 -cc1 -triple amd64-unknown-openbsd7.0 -analyze -disable-free -disable-llvm-verifier -discard-value-names -main-file-name btrace.c -analyzer-store=region -analyzer-opt-analyze-nested-blocks -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -mrelocation-model pic -pic-level 1 -pic-is-pie -mframe-pointer=all -relaxed-aliasing -fno-rounding-math -mconstructor-aliases -munwind-tables -target-cpu x86-64 -target-feature +retpoline-indirect-calls -target-feature +retpoline-indirect-branches -tune-cpu generic -debugger-tuning=gdb -fcoverage-compilation-dir=/usr/src/usr.sbin/btrace/obj -resource-dir /usr/local/lib/clang/13.0.0 -D PTRACE -D KTRACE -D ACCOUNTING -D NFSCLIENT -D SYSVSHM -D SYSVSEM -D SYSVMSG -I /usr/src/usr.sbin/btrace -internal-isystem /usr/local/lib/clang/13.0.0/include -internal-externc-isystem /usr/include -O2 -Wno-unused -fdebug-compilation-dir=/usr/src/usr.sbin/btrace/obj -ferror-limit 19 -fwrapv -D_RET_PROTECTOR -ret-protector -fgnuc-version=4.2.1 -vectorize-loops -vectorize-slp -fno-builtin-malloc -fno-builtin-calloc -fno-builtin-realloc -fno-builtin-valloc -fno-builtin-free -fno-builtin-strdup -fno-builtin-strndup -analyzer-output=html -faddrsig -D__GCC_HAVE_DWARF2_CFI_ASM=1 -o /home/ben/Projects/vmm/scan-build/2022-01-12-194120-40624-1 -x c /usr/src/usr.sbin/btrace/btrace.c
1/*	$OpenBSD: btrace.c,v 1.61 2021/12/07 22:17:03 guenther Exp $ */

3/*
* Copyright (c) 2019 - 2021 Martin Pieuchot <mpi@openbsd.org>
*
* Permission to use, copy, modify, and distribute this software for any
* purpose with or without fee is hereby granted, provided that the above
* copyright notice and this permission notice appear in all copies.
*
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*/

19#include <sys/ioctl.h>
20#include <sys/exec_elf.h>
21#include <sys/stat.h>
22#include <sys/syscall.h>
23#include <sys/queue.h>

25#include <assert.h>
26#include <err.h>
27#include <errno(*__errno()).h>
28#include <fcntl.h>
29#include <limits.h>
30#include <locale.h>
31#include <paths.h>
32#include <signal.h>
33#include <stdarg.h>
34#include <stdbool.h>
35#include <stdio.h>
36#include <stdlib.h>
37#include <string.h>
38#include <time.h>
39#include <unistd.h>

41#include <dev/dt/dtvar.h>

43#include "btrace.h"
44#include "bt_parser.h"

46#define MINIMUM(a, b)(((a) < (b)) ? (a) : (b))	(((a) < (b)) ? (a) : (b))
47#define MAXIMUM(a, b)(((a) > (b)) ? (a) : (b))	(((a) > (b)) ? (a) : (b))

49/*
* Maximum number of operands an arithmetic operation can have.  This
* is necessary to stop infinite recursion when evaluating expressions.
*/
53#define __MAXOPERANDS5	5

55#define __PATH_DEVDT"/dev/dt" "/dev/dt"

57__dead__attribute__((__noreturn__)) void		 usage(void);
58char			*read_btfile(const char *, size_t *);

60/*
* Retrieve & parse probe information.
*/
63void			 dtpi_cache(int);
64void			 dtpi_print_list(void);
65const char		*dtpi_func(struct dtioc_probe_info *);
66int			 dtpi_is_unit(const char *);
67struct dtioc_probe_info	*dtpi_get_by_value(const char *, const char *,
	     const char *);

70/*
* Main loop and rule evaluation.
*/
73void			 rules_do(int);
74void			 rules_setup(int);
75void			 rules_apply(struct dt_evt *);
76void			 rules_teardown(int);
77void			 rule_eval(struct bt_rule *, struct dt_evt *);
78void			 rule_printmaps(struct bt_rule *);

80/*
* Language builtins & functions.
*/
83uint64_t		 builtin_nsecs(struct dt_evt *);
84const char		*builtin_kstack(struct dt_evt *);
85const char		*builtin_arg(struct dt_evt *, enum bt_argtype);
86struct bt_arg		*fn_str(struct bt_arg *, struct dt_evt *, char *);
87void			 stmt_eval(struct bt_stmt *, struct dt_evt *);
88void			 stmt_bucketize(struct bt_stmt *, struct dt_evt *);
89void			 stmt_clear(struct bt_stmt *);
90void			 stmt_delete(struct bt_stmt *, struct dt_evt *);
91void			 stmt_insert(struct bt_stmt *, struct dt_evt *);
92void			 stmt_print(struct bt_stmt *, struct dt_evt *);
93void			 stmt_store(struct bt_stmt *, struct dt_evt *);
94bool_Bool			 stmt_test(struct bt_stmt *, struct dt_evt *);
95void			 stmt_time(struct bt_stmt *, struct dt_evt *);
96void			 stmt_zero(struct bt_stmt *);
97struct bt_arg		*ba_read(struct bt_arg *);
98const char		*ba2hash(struct bt_arg *, struct dt_evt *);
99long			 baexpr2long(struct bt_arg *, struct dt_evt *);
100const char		*ba2bucket(struct bt_arg *, struct bt_arg *,
	     struct dt_evt *, long *);
102int			 ba2dtflags(struct bt_arg *);

104/*
* Debug routines.
*/
107__dead__attribute__((__noreturn__)) void		 xabort(const char *, ...);
108void			 debug(const char *, ...);
109void			 debugx(const char *, ...);
110const char		*debug_probe_name(struct bt_probe *);
111void			 debug_dump_term(struct bt_arg *);
112void			 debug_dump_expr(struct bt_arg *);
113void			 debug_dump_filter(struct bt_rule *);

115struct dtioc_probe_info	*dt_dtpis;	/* array of available probes */
116size_t			 dt_ndtpi;	/* # of elements in the array */

118struct dt_evt		 bt_devt;	/* fake event for BEGIN/END */
119uint64_t		 bt_filtered;	/* # of events filtered out */

121char			**vargs;
122int			 nargs = 0;
123int			 verbose = 0;
124volatile sig_atomic_t	 quit_pending;

126static void
127signal_handler(int sig)
128{
quit_pending = sig;
130}


133int
134main(int argc, char *argv[])
135{
int fd = -1, ch, error = 0;
const char *filename = NULL((void *)0), *btscript = NULL((void *)0);
int showprobes = 0, noaction = 0;
size_t btslen = 0;

setlocale(LC_ALL0, "");

while ((ch = getopt(argc, argv, "e:lnp:v")) != -1) {
switch (ch) {
case 'e':
	btscript = optarg;
	btslen = strlen(btscript);
	break;
case 'l':
	showprobes = 1;
	break;
case 'n':
	noaction = 1;
	break;
case 'v':
	verbose++;
	break;
default:
	usage();
}
}

argc -= optind;
argv += optind;

if (argc > 0 && btscript == NULL((void *)0))
filename = argv[0];

/* Cannot pledge due to special ioctl()s */
if (unveil(__PATH_DEVDT"/dev/dt", "r") == -1)
err(1, "unveil %s", __PATH_DEVDT"/dev/dt");
if (unveil(_PATH_KSYMS"/dev/ksyms", "r") == -1)
err(1, "unveil %s", _PATH_KSYMS"/dev/ksyms");
if (filename != NULL((void *)0)) {
if (unveil(filename, "r") == -1)
	err(1, "unveil %s", filename);
}
if (unveil(NULL((void *)0), NULL((void *)0)) == -1)
err(1, "unveil");

if (filename != NULL((void *)0)) {
btscript = read_btfile(filename, &btslen);
argc--;
argv++;
}

nargs = argc;
vargs = argv;

if (btscript == NULL((void *)0) && !showprobes)
usage();

if (btscript != NULL((void *)0)) {
error = btparse(btscript, btslen, filename, 1);
if (error)
	return error;
}

if (noaction)
return error;

if (showprobes || g_nprobes > 0) {
fd = open(__PATH_DEVDT"/dev/dt", O_RDONLY0x0000);
if (fd == -1)
	err(1, "could not open %s", __PATH_DEVDT"/dev/dt");
}

if (showprobes) {
dtpi_cache(fd);
dtpi_print_list();
}

if (!TAILQ_EMPTY(&g_rules)(((&g_rules)->tqh_first) == ((void *)0)))
rules_do(fd);

if (fd != -1)
close(fd);

return error;
220}

222__dead__attribute__((__noreturn__)) void
223usage(void)
224{
fprintf(stderr(&__sF[2]), "usage: %s [-lnv] [-e program | file] [argument ...]\n",
   getprogname());
exit(1);
228}

230char *
231read_btfile(const char *filename, size_t *len)
232{
FILE *fp;
char *fcontent;
struct stat st;
size_t fsize;

if (stat(filename, &st))
err(1, "can't stat '%s'", filename);

fsize = st.st_size;
fcontent = malloc(fsize + 1);
if (fcontent == NULL((void *)0))
err(1, "malloc");

fp = fopen(filename, "r");
if (fp == NULL((void *)0))
err(1, "can't open '%s'", filename);

if (fread(fcontent, 1, fsize, fp) != fsize)
err(1, "can't read '%s'", filename);
fcontent[fsize] = '\0';

fclose(fp);
*len = fsize;
return fcontent;
257}

259static int
260dtpi_cmp(const void *a, const void *b)
261{
const struct dtioc_probe_info *ai = a, *bi = b;

if (ai->dtpi_pbn > bi->dtpi_pbn)
return 1;
if (ai->dtpi_pbn < bi->dtpi_pbn)
return -1;
return 0;
269}

271void
272dtpi_cache(int fd)
273{
struct dtioc_probe dtpr;

if (dt_dtpis != NULL((void *)0))
return;

memset(&dtpr, 0, sizeof(dtpr));
if (ioctl(fd, DTIOCGPLIST(((unsigned long)0x80000000|(unsigned long)0x40000000) | ((sizeof
(struct dtioc_probe) & 0x1fff) << 16) | ((('D')) <<
 8) | ((1))), &dtpr))
err(1, "DTIOCGPLIST");

dt_ndtpi = (dtpr.dtpr_size / sizeof(*dt_dtpis));
dt_dtpis = reallocarray(NULL((void *)0), dt_ndtpi, sizeof(*dt_dtpis));
if (dt_dtpis == NULL((void *)0))
err(1, "malloc");

dtpr.dtpr_probes = dt_dtpis;
if (ioctl(fd, DTIOCGPLIST(((unsigned long)0x80000000|(unsigned long)0x40000000) | ((sizeof
(struct dtioc_probe) & 0x1fff) << 16) | ((('D')) <<
 8) | ((1))), &dtpr))
err(1, "DTIOCGPLIST");

qsort(dt_dtpis, dt_ndtpi, sizeof(*dt_dtpis), dtpi_cmp);
293}

295void
296dtpi_print_list(void)
297{
struct dtioc_probe_info *dtpi;
size_t i;

dtpi = dt_dtpis;
for (i = 0; i < dt_ndtpi; i++, dtpi++) {
printf("%s:%s:%s\n", dtpi->dtpi_prov, dtpi_func(dtpi),
    dtpi->dtpi_name);
}
306}

308const char *
309dtpi_func(struct dtioc_probe_info *dtpi)
310{
char *sysnb, func[DTNAMESIZE16];
const char *errstr;
int idx;

if (strncmp(dtpi->dtpi_prov, "syscall", DTNAMESIZE16))
return dtpi->dtpi_func;

/* Translate syscall names */
strlcpy(func, dtpi->dtpi_func, sizeof(func));
sysnb = func;
if (strsep(&sysnb, "%") == NULL((void *)0))
return dtpi->dtpi_func;

idx = strtonum(sysnb, 1, SYS_MAXSYSCALL331, &errstr);
if (errstr != NULL((void *)0))
return dtpi->dtpi_func;

return syscallnames[idx];
329}

331int
332dtpi_is_unit(const char *unit)
333{
return !strncmp("hz", unit, sizeof("hz"));
335}

337struct dtioc_probe_info *
338dtpi_get_by_value(const char *prov, const char *func, const char *name)
339{
struct dtioc_probe_info *dtpi;
size_t i;

dtpi = dt_dtpis;
for (i = 0; i < dt_ndtpi; i++, dtpi++) {
if (prov != NULL((void *)0) &&
    strncmp(prov, dtpi->dtpi_prov, DTNAMESIZE16))
	continue;

if (func != NULL((void *)0)) {
	if (dtpi_is_unit(func))
		return dtpi;

	if (strncmp(func, dtpi_func(dtpi), DTNAMESIZE16))
		continue;
}

if (strncmp(name, dtpi->dtpi_name, DTNAMESIZE16))
	continue;

debug("matched probe %s:%s:%s\n", dtpi->dtpi_prov,
    dtpi_func(dtpi), dtpi->dtpi_name);
return dtpi;
}

return NULL((void *)0);
366}

368static struct dtioc_probe_info *
369dtpi_get_by_id(unsigned int pbn)
370{
struct dtioc_probe_info d;

d.dtpi_pbn = pbn;
return bsearch(&d, dt_dtpis, dt_ndtpi, sizeof(*dt_dtpis), dtpi_cmp);
375}

377void
378rules_do(int fd)
379{
struct sigaction sa;

memset(&sa, 0, sizeof(sa));
sigemptyset(&sa.sa_mask);
sa.sa_flags = 0;
sa.sa_handler__sigaction_u.__sa_handler = signal_handler;
if (sigaction(SIGINT2, &sa, NULL((void *)0)))
err(1, "sigaction");

rules_setup(fd);

while (!quit_pending && g_nprobes > 0) {
static struct dt_evt devtbuf[64];
ssize_t rlen;
size_t i;

rlen = read(fd, devtbuf, sizeof(devtbuf) - 1);
if (rlen == -1) {
	if (errno(*__errno()) == EINTR4 && quit_pending) {
		printf("\n");
		break;
	}
	err(1, "read");
}

if ((rlen % sizeof(struct dt_evt)) != 0)
	err(1, "incorrect read");

for (i = 0; i < rlen / sizeof(struct dt_evt); i++)
	rules_apply(&devtbuf[i]);
}

rules_teardown(fd);

if (verbose && fd != -1) {
struct dtioc_stat dtst;

memset(&dtst, 0, sizeof(dtst));
if (ioctl(fd, DTIOCGSTATS((unsigned long)0x40000000 | ((sizeof(struct dtioc_stat) &
 0x1fff) << 16) | ((('D')) << 8) | ((2))), &dtst))
	warn("DTIOCGSTATS");

printf("%llu events read\n", dtst.dtst_readevt);
printf("%llu events dropped\n", dtst.dtst_dropevt);
printf("%llu events filtered\n", bt_filtered);
}
425}

427void
428rules_setup(int fd)
429{
struct dtioc_probe_info *dtpi;
struct dtioc_req *dtrq;
struct bt_rule *r, *rbegin = NULL((void *)0);
struct bt_probe *bp;
struct bt_stmt *bs;
int dokstack = 0, on = 1;
uint64_t evtflags;

TAILQ_FOREACH(r, &g_rules, br_next)for((r) = ((&g_rules)->tqh_first); (r) != ((void *)0);
 (r) = ((r)->br_next.tqe_next)) {
evtflags = 0;
SLIST_FOREACH(bs, &r->br_action, bs_next)for((bs) = ((&r->br_action)->slh_first); (bs) != ((
void *)0); (bs) = ((bs)->bs_next.sle_next)) {
	struct bt_arg *ba;

	SLIST_FOREACH(ba, &bs->bs_args, ba_next)for((ba) = ((&bs->bs_args)->slh_first); (ba) != ((void
 *)0); (ba) = ((ba)->ba_next.sle_next))
		evtflags |= ba2dtflags(ba);

	/* Also check the value for map/hist insertion */
	switch (bs->bs_act) {
	case B_AC_BUCKETIZE:
	case B_AC_INSERT:
		ba = (struct bt_arg *)bs->bs_var;
		evtflags |= ba2dtflags(ba);
		break;
	default:
		break;
	}
}

SLIST_FOREACH(bp, &r->br_probes, bp_next)for((bp) = ((&r->br_probes)->slh_first); (bp) != ((
void *)0); (bp) = ((bp)->bp_next.sle_next)) {
	debug("parsed probe '%s'", debug_probe_name(bp));
	debug_dump_filter(r);

	if (bp->bp_type != B_PT_PROBE) {
		if (bp->bp_type == B_PT_BEGIN)
			rbegin = r;
		continue;
	}

	dtpi_cache(fd);
	dtpi = dtpi_get_by_value(bp->bp_prov, bp->bp_func,
	    bp->bp_name);
	if (dtpi == NULL((void *)0)) {
		errx(1, "probe '%s:%s:%s' not found",
		    bp->bp_prov, bp->bp_func, bp->bp_name);
	}

	dtrq = calloc(1, sizeof(*dtrq));
	if (dtrq == NULL((void *)0))
		err(1, "dtrq: 1alloc");

	bp->bp_pbn = dtpi->dtpi_pbn;
	dtrq->dtrq_pbn = dtpi->dtpi_pbn;
	dtrq->dtrq_rate = bp->bp_rate;
	dtrq->dtrq_evtflags = evtflags;
	if (dtrq->dtrq_evtflags & DTEVT_KSTACK(1 << 2))
		dokstack = 1;
	bp->bp_cookie = dtrq;
}
}

if (dokstack)
kelf_open();

/* Initialize "fake" event for BEGIN/END */
bt_devt.dtev_pbn = -1;
memcpy(&bt_devt.dtev_comm, getprogname(), sizeof(bt_devt.dtev_comm));
bt_devt.dtev_pid = getpid();
bt_devt.dtev_tid = getthrid();
clock_gettime(CLOCK_REALTIME0, &bt_devt.dtev_tsp);

if (rbegin)
rule_eval(rbegin, &bt_devt);

/* Enable all probes */
TAILQ_FOREACH(r, &g_rules, br_next)for((r) = ((&g_rules)->tqh_first); (r) != ((void *)0);
 (r) = ((r)->br_next.tqe_next)) {
SLIST_FOREACH(bp, &r->br_probes, bp_next)for((bp) = ((&r->br_probes)->slh_first); (bp) != ((
void *)0); (bp) = ((bp)->bp_next.sle_next)) {
	if (bp->bp_type != B_PT_PROBE)
		continue;

	dtrq = bp->bp_cookie;
	if (ioctl(fd, DTIOCPRBENABLE((unsigned long)0x80000000 | ((sizeof(struct dtioc_req) &
 0x1fff) << 16) | ((('D')) << 8) | ((4))), dtrq))
		err(1, "DTIOCPRBENABLE");
}
}

if (g_nprobes > 0) {
if (ioctl(fd, DTIOCRECORD((unsigned long)0x80000000 | ((sizeof(int) & 0x1fff) <<
 16) | ((('D')) << 8) | ((3))), &on))
	err(1, "DTIOCRECORD");
}
519}

521void
522rules_apply(struct dt_evt *dtev)
523{
struct bt_rule *r;
struct bt_probe *bp;

TAILQ_FOREACH(r, &g_rules, br_next)for((r) = ((&g_rules)->tqh_first); (r) != ((void *)0);
 (r) = ((r)->br_next.tqe_next)) {
SLIST_FOREACH(bp, &r->br_probes, bp_next)for((bp) = ((&r->br_probes)->slh_first); (bp) != ((
void *)0); (bp) = ((bp)->bp_next.sle_next)) {
	if (bp->bp_type != B_PT_PROBE ||
	    bp->bp_pbn != dtev->dtev_pbn)
		continue;

	rule_eval(r, dtev);
}
}
536}

538void
539rules_teardown(int fd)
540{
struct dtioc_req *dtrq;
struct bt_probe *bp;
struct bt_rule *r, *rend = NULL((void *)0);
int dokstack = 0, off = 0;

if (g_nprobes > 0) {
if (ioctl(fd, DTIOCRECORD((unsigned long)0x80000000 | ((sizeof(int) & 0x1fff) <<
 16) | ((('D')) << 8) | ((3))), &off))
	err(1, "DTIOCRECORD");
}

TAILQ_FOREACH(r, &g_rules, br_next)for((r) = ((&g_rules)->tqh_first); (r) != ((void *)0);
 (r) = ((r)->br_next.tqe_next)) {
SLIST_FOREACH(bp, &r->br_probes, bp_next)for((bp) = ((&r->br_probes)->slh_first); (bp) != ((
void *)0); (bp) = ((bp)->bp_next.sle_next)) {
	if (bp->bp_type != B_PT_PROBE) {
		if (bp->bp_type == B_PT_END)
			rend = r;
		continue;
	}

	dtrq = bp->bp_cookie;
	if (ioctl(fd, DTIOCPRBDISABLE((unsigned long)0x80000000 | ((sizeof(struct dtioc_req) &
 0x1fff) << 16) | ((('D')) << 8) | ((5))), dtrq))
		err(1, "DTIOCPRBDISABLE");
	if (dtrq->dtrq_evtflags & DTEVT_KSTACK(1 << 2))
		dokstack = 1;
}
}

if (dokstack)
kelf_close();

/* Update "fake" event for BEGIN/END */
clock_gettime(CLOCK_REALTIME0, &bt_devt.dtev_tsp);

if (rend)
rule_eval(rend, &bt_devt);

/* Print non-empty map & hist */
TAILQ_FOREACH(r, &g_rules, br_next)for((r) = ((&g_rules)->tqh_first); (r) != ((void *)0);
 (r) = ((r)->br_next.tqe_next))
rule_printmaps(r);
579}

581void
582rule_eval(struct bt_rule *r, struct dt_evt *dtev)
583{
struct bt_stmt *bs;
struct bt_probe *bp;

SLIST_FOREACH(bp, &r->br_probes, bp_next)for((bp) = ((&r->br_probes)->slh_first); (bp) != ((
void *)0); (bp) = ((bp)->bp_next.sle_next)) {
debug("eval rule '%s'", debug_probe_name(bp));
debug_dump_filter(r);
}

if (r->br_filter != NULL((void *)0) && r->br_filter->bf_condition != NULL((void *)0)) {
if (stmt_test(r->br_filter->bf_condition, dtev) == false0) {
	bt_filtered++;
	return;
}
}

SLIST_FOREACH(bs, &r->br_action, bs_next)for((bs) = ((&r->br_action)->slh_first); (bs) != ((
void *)0); (bs) = ((bs)->bs_next.sle_next)) {
if ((bs->bs_act == B_AC_TEST) && stmt_test(bs, dtev) == true1)
	stmt_eval((struct bt_stmt *)bs->bs_var, dtev);

stmt_eval(bs, dtev);
}
605}

607void
608rule_printmaps(struct bt_rule *r)
609{
struct bt_stmt *bs;

SLIST_FOREACH(bs, &r->br_action, bs_next)for((bs) = ((&r->br_action)->slh_first); (bs) != ((
void *)0); (bs) = ((bs)->bs_next.sle_next)) {
struct bt_arg *ba;

SLIST_FOREACH(ba, &bs->bs_args, ba_next)for((ba) = ((&bs->bs_args)->slh_first); (ba) != ((void
 *)0); (ba) = ((ba)->ba_next.sle_next)) {
	struct bt_var *bv = ba->ba_value;
	struct map *map;

	if (ba->ba_type != B_AT_MAP && ba->ba_type != B_AT_HIST)
		continue;

	map = (struct map *)bv->bv_value;
	if (map == NULL((void *)0))
		continue;

	if (ba->ba_type == B_AT_MAP)
		map_print(map, SIZE_T_MAX(9223372036854775807L *2UL+1UL), bv_name(bv));
	else
		hist_print((struct hist *)map, bv_name(bv));
	map_clear(map);
	bv->bv_value = NULL((void *)0);
}
}
634}

636time_t
637builtin_gettime(struct dt_evt *dtev)
638{
struct timespec ts;

if (dtev == NULL((void *)0)) {
clock_gettime(CLOCK_REALTIME0, &ts);
return ts.tv_sec;
}

return dtev->dtev_tsp.tv_sec;
647}

649static inline uint64_t
650TIMESPEC_TO_NSEC(struct timespec *ts)
651{
return (ts->tv_sec * 1000000000L + ts->tv_nsec);
653}

655uint64_t
656builtin_nsecs(struct dt_evt *dtev)
657{
struct timespec ts;

if (dtev == NULL((void *)0)) {
clock_gettime(CLOCK_REALTIME0, &ts);
return TIMESPEC_TO_NSEC(&ts);
}

return TIMESPEC_TO_NSEC(&dtev->dtev_tsp);
666}

668const char *
669builtin_stack(struct dt_evt *dtev, int kernel)
670{
struct stacktrace *st = &dtev->dtev_kstack;
static char buf[4096], *bp;
size_t i;
int sz;

if (!kernel)
return "";
if (st->st_count == 0)
return "\nuserland\n";

buf[0] = '\0';
bp = buf;
sz = sizeof(buf);
for (i = 0; i < st->st_count; i++) {
int l;

l = kelf_snprintsym(bp, sz - 1, st->st_pc[i]);
if (l < 0)
	break;
if (l >= sz - 1) {
	bp += sz - 1;
	sz = 1;
	break;
}
bp += l;
sz -= l;
}
snprintf(bp, sz, "\nkernel\n");

return buf;
701}

703const char *
704builtin_arg(struct dt_evt *dtev, enum bt_argtype dat)
705{
static char buf[sizeof("18446744073709551615")]; /* UINT64_MAX */

snprintf(buf, sizeof(buf), "%lu",
   dtev->dtev_args_args.E_entry[dat - B_AT_BI_ARG0]);

return buf;
712}

714void
715stmt_eval(struct bt_stmt *bs, struct dt_evt *dtev)
716{
switch (bs->bs_act) {
case B_AC_BUCKETIZE:
stmt_bucketize(bs, dtev);
break;
case B_AC_CLEAR:
stmt_clear(bs);
break;
case B_AC_DELETE:
stmt_delete(bs, dtev);
break;
case B_AC_EXIT:
exit(0);
break;
case B_AC_INSERT:
stmt_insert(bs, dtev);
break;
case B_AC_PRINT:
stmt_print(bs, dtev);
break;
case B_AC_PRINTF:
stmt_printf(bs, dtev);
break;
case B_AC_STORE:
stmt_store(bs, dtev);
break;
case B_AC_TEST:
/* done before */
break;
case B_AC_TIME:
stmt_time(bs, dtev);
break;
case B_AC_ZERO:
stmt_zero(bs);
break;
default:
xabort("no handler for action type %d", bs->bs_act);
}
754}

756/*
* Increment a bucket:	{ @h = hist(v); } or { @h = lhist(v, min, max, step); }
*
* In this case 'h' is represented by `bv' and '(min, max, step)' by `brange'.
*/
761void
762stmt_bucketize(struct bt_stmt *bs, struct dt_evt *dtev)
763{
struct bt_arg *brange, *bhist = SLIST_FIRST(&bs->bs_args)((&bs->bs_args)->slh_first);
struct bt_arg *bval = (struct bt_arg *)bs->bs_var;
struct bt_var *bv = bhist->ba_value;
const char *bucket;
long step = 0;

assert(bhist->ba_type == B_AT_HIST)((bhist->ba_type == B_AT_HIST) ? (void)0 : __assert2("/usr/src/usr.sbin/btrace/btrace.c"
, 770, __func__, "bhist->ba_type == B_AT_HIST"));
assert(SLIST_NEXT(bval, ba_next) == NULL)((((bval)->ba_next.sle_next) == ((void *)0)) ? (void)0 : __assert2
("/usr/src/usr.sbin/btrace/btrace.c", 771, __func__, "SLIST_NEXT(bval, ba_next) == NULL"
));

brange = bhist->ba_key;
bucket = ba2bucket(bval, brange, dtev, &step);
if (bucket == NULL((void *)0)) {
debug("hist=%p '%s' value=%lu out of range\n", bv->bv_value,
    bv_name(bv), ba2long(bval, dtev));
return;
}
debug("hist=%p '%s' increment bucket '%s'\n", bv->bv_value,
   bv_name(bv), bucket);

bv->bv_value = (struct bt_arg *)
   hist_increment((struct hist *)bv->bv_value, bucket, step);
bv->bv_type = B_VT_HIST;
786}


789/*
* Empty a map:		{ clear(@map); }
*/
792void
793stmt_clear(struct bt_stmt *bs)
794{
struct bt_arg *ba = SLIST_FIRST(&bs->bs_args)((&bs->bs_args)->slh_first);
struct bt_var *bv = ba->ba_value;
struct map *map;

assert(bs->bs_var == NULL)((bs->bs_var == ((void *)0)) ? (void)0 : __assert2("/usr/src/usr.sbin/btrace/btrace.c"
, 799, __func__, "bs->bs_var == NULL"));
assert(ba->ba_type == B_AT_VAR)((ba->ba_type == B_AT_VAR) ? (void)0 : __assert2("/usr/src/usr.sbin/btrace/btrace.c"
, 800, __func__, "ba->ba_type == B_AT_VAR"));

map = (struct map *)bv->bv_value;
if (map == NULL((void *)0))
return;

if (bv->bv_type != B_VT_MAP && bv->bv_type != B_VT_HIST)
errx(1, "invalid variable type for clear(%s)", ba_name(ba));

map_clear(map);
bv->bv_value = NULL((void *)0);

debug("map=%p '%s' clear\n", map, bv_name(bv));
813}

815/*
* Map delete:	 	{ delete(@map[key]); }
*
* In this case 'map' is represented by `bv' and 'key' by `bkey'.
*/
820void
821stmt_delete(struct bt_stmt *bs, struct dt_evt *dtev)
822{
struct bt_arg *bkey, *bmap = SLIST_FIRST(&bs->bs_args)((&bs->bs_args)->slh_first);
struct bt_var *bv = bmap->ba_value;
struct map *map;
const char *hash;

assert(bmap->ba_type == B_AT_MAP)((bmap->ba_type == B_AT_MAP) ? (void)0 : __assert2("/usr/src/usr.sbin/btrace/btrace.c"
, 828, __func__, "bmap->ba_type == B_AT_MAP"));
assert(bs->bs_var == NULL)((bs->bs_var == ((void *)0)) ? (void)0 : __assert2("/usr/src/usr.sbin/btrace/btrace.c"
, 829, __func__, "bs->bs_var == NULL"));

map = (struct map *)bv->bv_value;
if (map == NULL((void *)0))
return;

bkey = bmap->ba_key;
hash = ba2hash(bkey, dtev);
debug("map=%p '%s' delete key=%p '%s'\n", map, bv_name(bv), bkey, hash);

map_delete(map, hash);
840}

842/*
* Map insert:	 	{ @map[key] = 42; }
*
* In this case 'map' is represented by `bv', 'key' by `bkey' and
* '42' by `bval'.
*/
848void
849stmt_insert(struct bt_stmt *bs, struct dt_evt *dtev)
850{
struct bt_arg *bkey, *bmap = SLIST_FIRST(&bs->bs_args)((&bs->bs_args)->slh_first);
struct bt_arg *bval = (struct bt_arg *)bs->bs_var;
struct bt_var *bv = bmap->ba_value;
struct map *map;
const char *hash;

assert(bmap->ba_type == B_AT_MAP)((bmap->ba_type == B_AT_MAP) ? (void)0 : __assert2("/usr/src/usr.sbin/btrace/btrace.c"
, 857, __func__, "bmap->ba_type == B_AT_MAP"));
assert(SLIST_NEXT(bval, ba_next) == NULL)((((bval)->ba_next.sle_next) == ((void *)0)) ? (void)0 : __assert2
("/usr/src/usr.sbin/btrace/btrace.c", 858, __func__, "SLIST_NEXT(bval, ba_next) == NULL"
));

bkey = bmap->ba_key;
hash = ba2hash(bkey, dtev);

/* map is NULL before first insert or after clear() */
map = (struct map *)bv->bv_value;
map = map_insert(map, hash, bval, dtev);

debug("map=%p '%s' insert key=%p '%s' bval=%p\n", map,
   bv_name(bv), bkey, hash, bval);

bv->bv_value = (struct bt_arg *)map;
bv->bv_type = B_VT_MAP;
872}

874/*
* Print variables:	{ print(890); print(@map[, 8]); print(comm); }
*
* In this case the global variable 'map' is pointed at by `ba'
* and '8' is represented by `btop'.
*/
880void
881stmt_print(struct bt_stmt *bs, struct dt_evt *dtev)
882{
struct bt_arg *btop, *ba = SLIST_FIRST(&bs->bs_args)((&bs->bs_args)->slh_first);
struct bt_var *bv = ba->ba_value;
struct map *map;
size_t top = SIZE_T_MAX(9223372036854775807L *2UL+1UL);

assert(bs->bs_var == NULL)((bs->bs_var == ((void *)0)) ? (void)0 : __assert2("/usr/src/usr.sbin/btrace/btrace.c"
, 888, __func__, "bs->bs_var == NULL"));

/* Parse optional `top' argument. */
btop = SLIST_NEXT(ba, ba_next)((ba)->ba_next.sle_next);
if (btop != NULL((void *)0)) {
assert(SLIST_NEXT(btop, ba_next) == NULL)((((btop)->ba_next.sle_next) == ((void *)0)) ? (void)0 : __assert2
("/usr/src/usr.sbin/btrace/btrace.c", 893, __func__, "SLIST_NEXT(btop, ba_next) == NULL"
));
top = ba2long(btop, dtev);
}

/* Static argument. */
if (ba->ba_type != B_AT_VAR) {
assert(btop == NULL)((btop == ((void *)0)) ? (void)0 : __assert2("/usr/src/usr.sbin/btrace/btrace.c"
, 899, __func__, "btop == NULL"));
printf("%s\n", ba2str(ba, dtev));
return;
}

map = (struct map *)bv->bv_value;
if (map == NULL((void *)0))
return;

debug("map=%p '%s' print (top=%d)\n", bv->bv_value, bv_name(bv), top);

if (bv->bv_type == B_VT_MAP)
map_print(map, top, bv_name(bv));
else if (bv->bv_type == B_VT_HIST)
hist_print((struct hist *)map, bv_name(bv));
else
printf("%s\n", ba2str(ba, dtev));
916}

918/*
* Variable store: 	{ @var = 3; }
*
* In this case '3' is represented by `ba', the argument of a STORE
* action.
*
* If the argument depends of the value of an event (builtin) or is
* the result of an operation, its evaluation is stored in a new `ba'.
*/
927void
928stmt_store(struct bt_stmt *bs, struct dt_evt *dtev)
929{
struct bt_arg *ba = SLIST_FIRST(&bs->bs_args)((&bs->bs_args)->slh_first);
struct bt_var *bv = bs->bs_var;

assert(SLIST_NEXT(ba, ba_next) == NULL)((((ba)->ba_next.sle_next) == ((void *)0)) ? (void)0 : __assert2
("/usr/src/usr.sbin/btrace/btrace.c", 933, __func__, "SLIST_NEXT(ba, ba_next) == NULL"
));
1
Assuming field 'sle_next' is equal to null→
2
←
'?' condition is true→

switch (ba->ba_type) {
3
←
Control jumps to 'case B_AT_OP_PLUS:'  at line 948→
case B_AT_STR:
bv->bv_value = ba;
bv->bv_type = B_VT_STR;
break;
case B_AT_LONG:
bv->bv_value = ba;
bv->bv_type = B_VT_LONG;
break;
case B_AT_BI_NSECS:
bv->bv_value = ba_new(builtin_nsecs(dtev), B_AT_LONG)ba_new0((void *)(builtin_nsecs(dtev)), (B_AT_LONG));
bv->bv_type = B_VT_LONG;
break;
case B_AT_OP_PLUS ... B_AT_OP_LOR:
bv->bv_value = ba_new(ba2long(ba, dtev), B_AT_LONG)ba_new0((void *)(ba2long(ba, dtev)), (B_AT_LONG));
4
←
Calling 'ba2long'→
bv->bv_type = B_VT_LONG;
break;
case B_AT_FN_STR:
bv->bv_value = ba_new(ba2str(ba, dtev), B_AT_STR)ba_new0((void *)(ba2str(ba, dtev)), (B_AT_STR));
bv->bv_type = B_VT_STR;
break;
default:
xabort("store not implemented for type %d", ba->ba_type);
}

debug("bv=%p var '%s' store (%p)\n", bv, bv_name(bv), bv->bv_value);
961}

963/*
* String conversion	{ str($1); string($1, 3); }
*
* Since fn_str is currently only called in ba2str, *buf should be a pointer
* to the static buffer provided by ba2str.
*/
969struct bt_arg *
970fn_str(struct bt_arg *ba, struct dt_evt *dtev, char *buf)
971{
struct bt_arg *arg, *index;
ssize_t len = STRLEN64;

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"
, 975, __func__, "ba->ba_type == B_AT_FN_STR"));

arg = (struct bt_arg*)ba->ba_value;
assert(arg != NULL)((arg != ((void *)0)) ? (void)0 : __assert2("/usr/src/usr.sbin/btrace/btrace.c"
, 978, __func__, "arg != NULL"));

index = SLIST_NEXT(arg, ba_next)((arg)->ba_next.sle_next);
if (index != NULL((void *)0)) {
/* Should have only 1 optional argument. */
assert(SLIST_NEXT(index, ba_next) == NULL)((((index)->ba_next.sle_next) == ((void *)0)) ? (void)0 : __assert2
("/usr/src/usr.sbin/btrace/btrace.c", 983, __func__, "SLIST_NEXT(index, ba_next) == NULL"
));
len = MINIMUM(ba2long(index, dtev) + 1, STRLEN)(((ba2long(index, dtev) + 1) < (64)) ? (ba2long(index, dtev
) + 1) : (64));
}

/* All negative lengths behave the same as a zero length. */
if (len < 1)
return ba_new("", B_AT_STR)ba_new0((void *)(""), (B_AT_STR));

strlcpy(buf, ba2str(arg, dtev), len);
return ba_new(buf, B_AT_STR)ba_new0((void *)(buf), (B_AT_STR));
993}

995/*
* Expression test:	{ if (expr) stmt; }
*/
998bool_Bool
999stmt_test(struct bt_stmt *bs, struct dt_evt *dtev)
1000{
struct bt_arg *ba;

if (bs == NULL((void *)0))
return true1;

ba = SLIST_FIRST(&bs->bs_args)((&bs->bs_args)->slh_first);

return baexpr2long(ba, dtev) != 0;
1009}

1011/*
* Print time: 		{ time("%H:%M:%S"); }
*/
1014void
1015stmt_time(struct bt_stmt *bs, struct dt_evt *dtev)
1016{
struct bt_arg *ba = SLIST_FIRST(&bs->bs_args)((&bs->bs_args)->slh_first);
time_t time;
struct tm *tm;
char buf[64];

assert(bs->bs_var == NULL)((bs->bs_var == ((void *)0)) ? (void)0 : __assert2("/usr/src/usr.sbin/btrace/btrace.c"
, 1022, __func__, "bs->bs_var == NULL"));
assert(ba->ba_type == B_AT_STR)((ba->ba_type == B_AT_STR) ? (void)0 : __assert2("/usr/src/usr.sbin/btrace/btrace.c"
, 1023, __func__, "ba->ba_type == B_AT_STR"));
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", 1024, __func__
, "strlen(ba2str(ba, dtev)) < (sizeof(buf) - 1)"));

time = builtin_gettime(dtev);
tm = localtime(&time);
strftime(buf, sizeof(buf), ba2str(ba, dtev), tm);
printf("%s", buf);
1030}

1032/*
* Set entries to 0:	{ zero(@map); }
*/
1035void
1036stmt_zero(struct bt_stmt *bs)
1037{
struct bt_arg *ba = SLIST_FIRST(&bs->bs_args)((&bs->bs_args)->slh_first);
struct bt_var *bv = ba->ba_value;
struct map *map;

assert(bs->bs_var == NULL)((bs->bs_var == ((void *)0)) ? (void)0 : __assert2("/usr/src/usr.sbin/btrace/btrace.c"
, 1042, __func__, "bs->bs_var == NULL"));
assert(ba->ba_type == B_AT_VAR)((ba->ba_type == B_AT_VAR) ? (void)0 : __assert2("/usr/src/usr.sbin/btrace/btrace.c"
, 1043, __func__, "ba->ba_type == B_AT_VAR"));

map = (struct map *)bv->bv_value;
if (map == NULL((void *)0))
return;

if (bv->bv_type != B_VT_MAP && bv->bv_type != B_VT_HIST)
errx(1, "invalid variable type for zero(%s)", ba_name(ba));

map_zero(map);

debug("map=%p '%s' zero\n", map, bv_name(bv));
1055}

1057struct bt_arg *
1058ba_read(struct bt_arg *ba)
1059{
struct bt_var *bv = ba->ba_value;

assert(ba->ba_type == B_AT_VAR)((ba->ba_type == B_AT_VAR) ? (void)0 : __assert2("/usr/src/usr.sbin/btrace/btrace.c"
, 1062, __func__, "ba->ba_type == B_AT_VAR"));

debug("bv=%p read '%s' (%p)\n", bv, bv_name(bv), bv->bv_value);

/* Handle map/hist access after clear(). */
if (bv->bv_value == NULL((void *)0))
return &g_nullba;

return bv->bv_value;
1071}

1073const char *
1074ba2hash(struct bt_arg *ba, struct dt_evt *dtev)
1075{
static char buf[KLEN512];
char *hash;
int l, len;

buf[0] = '\0';
l = snprintf(buf, sizeof(buf), "%s", ba2str(ba, dtev));
if (l < 0 || (size_t)l > sizeof(buf)) {
warn("string too long %d > %lu", l, sizeof(buf));
return buf;
}

len = 0;
while ((ba = SLIST_NEXT(ba, ba_next)((ba)->ba_next.sle_next)) != NULL((void *)0)) {
len += l;
hash = buf + len;

l = snprintf(hash, sizeof(buf) - len, ", %s", ba2str(ba, dtev));
if (l < 0 || (size_t)l > (sizeof(buf) - len)) {
	warn("hash too long %d > %lu", l + len, sizeof(buf));
	break;
}
}

return buf;
1100}

1102static unsigned long
1103next_pow2(unsigned long x)
1104{
size_t i;

x--;
for (i = 0; i < (sizeof(x)  * 8) - 1; i++)
x |= (x >> 1);

return x + 1;
1112}

1114/*
* Return the ceiling value the interval holding `ba' or NULL if it is
* out of the (min, max) values.
*/
1118const char *
1119ba2bucket(struct bt_arg *ba, struct bt_arg *brange, struct dt_evt *dtev,
  long *pstep)
1121{
static char buf[KLEN512];
long val, bucket;
int l;

val = ba2long(ba, dtev);
if (brange == NULL((void *)0))
bucket = next_pow2(val);
else {
long min, max, step;

assert(brange->ba_type == B_AT_LONG)((brange->ba_type == B_AT_LONG) ? (void)0 : __assert2("/usr/src/usr.sbin/btrace/btrace.c"
, 1132, __func__, "brange->ba_type == B_AT_LONG"));
min = ba2long(brange, NULL((void *)0));

brange = SLIST_NEXT(brange, ba_next)((brange)->ba_next.sle_next);
assert(brange->ba_type == B_AT_LONG)((brange->ba_type == B_AT_LONG) ? (void)0 : __assert2("/usr/src/usr.sbin/btrace/btrace.c"
, 1136, __func__, "brange->ba_type == B_AT_LONG"));
max = ba2long(brange, NULL((void *)0));

if ((val < min) || (val > max))
	return NULL((void *)0);

brange = SLIST_NEXT(brange, ba_next)((brange)->ba_next.sle_next);
assert(brange->ba_type == B_AT_LONG)((brange->ba_type == B_AT_LONG) ? (void)0 : __assert2("/usr/src/usr.sbin/btrace/btrace.c"
, 1143, __func__, "brange->ba_type == B_AT_LONG"));
step = ba2long(brange, NULL((void *)0));

bucket = ((val / step) + 1) * step;
*pstep = step;
}

buf[0] = '\0';
l = snprintf(buf, sizeof(buf), "%lu", bucket);
if (l < 0 || (size_t)l > sizeof(buf)) {
warn("string too long %d > %lu", l, sizeof(buf));
return buf;
}

return buf;
1158}

1160/*
* Evaluate the operation encoded in `ba' and return its result.
*/
1163long
1164baexpr2long(struct bt_arg *ba, struct dt_evt *dtev)
1165{
static long recursions;
struct bt_arg *lhs, *rhs;
long lval, rval, result;

if (++recursions >= __MAXOPERANDS5)
7
←
Taking false branch→
errx(1, "too many operands (>%d) in expression", __MAXOPERANDS5);

lhs = ba->ba_value;
rhs = SLIST_NEXT(lhs, ba_next)((lhs)->ba_next.sle_next);

lval = ba2long(lhs, dtev);
if (rhs == NULL((void *)0)) {
8
←
Assuming 'rhs' is equal to NULL→
9
←
Taking true branch→
rval = 0;
10
←
The value 0 is assigned to 'rval'→
} else {
assert(SLIST_NEXT(rhs, ba_next) == NULL)((((rhs)->ba_next.sle_next) == ((void *)0)) ? (void)0 : __assert2
("/usr/src/usr.sbin/btrace/btrace.c", 1180, __func__, "SLIST_NEXT(rhs, ba_next) == NULL"
));
rval = ba2long(rhs, dtev);
}

switch (ba->ba_type) {
11
←
Control jumps to 'case B_AT_OP_DIVIDE:'  at line 1194→
case B_AT_OP_PLUS:
result = lval + rval;
break;
case B_AT_OP_MINUS:
result = lval - rval;
break;
case B_AT_OP_MULT:
result = lval * rval;
break;
case B_AT_OP_DIVIDE:
result = lval / rval;
12
←
Division by zero
break;
case B_AT_OP_BAND:
result = lval & rval;
break;
case B_AT_OP_XOR:
result = lval ^ rval;
break;
case B_AT_OP_BOR:
result = lval | rval;
break;
case B_AT_OP_EQ:
result = (lval == rval);
break;
case B_AT_OP_NE:
result = (lval != rval);
break;
case B_AT_OP_LE:
result = (lval <= rval);
break;
case B_AT_OP_LT:
result = (lval < rval);
break;
case B_AT_OP_GE:
result = (lval >= rval);
break;
case B_AT_OP_GT:
result = (lval > rval);
break;
case B_AT_OP_LAND:
result = (lval && rval);
break;
case B_AT_OP_LOR:
result = (lval || rval);
break;
default:
xabort("unsuported operation %d", ba->ba_type);
}

debug("ba=%p eval '%ld %s %ld = %d'\n", ba, lval, ba_name(ba),
  rval, result);

--recursions;

return result;
1240}

1242const char *
1243ba_name(struct bt_arg *ba)
1244{
switch (ba->ba_type) {
case B_AT_NIL:
return "0";
case B_AT_VAR:
case B_AT_MAP:
break;
case B_AT_BI_PID:
return "pid";
case B_AT_BI_TID:
return "tid";
case B_AT_BI_COMM:
return "comm";
case B_AT_BI_CPU:
return "cpu";
case B_AT_BI_NSECS:
return "nsecs";
case B_AT_BI_KSTACK:
return "kstack";
case B_AT_BI_USTACK:
return "ustack";
case B_AT_BI_ARG0:
return "arg0";
case B_AT_BI_ARG1:
return "arg1";
case B_AT_BI_ARG2:
return "arg2";
case B_AT_BI_ARG3:
return "arg3";
case B_AT_BI_ARG4:
return "arg4";
case B_AT_BI_ARG5:
return "arg5";
case B_AT_BI_ARG6:
return "arg6";
case B_AT_BI_ARG7:
return "arg7";
case B_AT_BI_ARG8:
return "arg8";
case B_AT_BI_ARG9:
return "arg9";
case B_AT_BI_ARGS:
return "args";
case B_AT_BI_RETVAL:
return "retval";
case B_AT_BI_PROBE:
return "probe";
case B_AT_FN_STR:
return "str";
case B_AT_OP_PLUS:
return "+";
case B_AT_OP_MINUS:
return "-";
case B_AT_OP_MULT:
return "*";
case B_AT_OP_DIVIDE:
return "/";
case B_AT_OP_BAND:
return "&";
case B_AT_OP_XOR:
return "^";
case B_AT_OP_BOR:
return "|";
case B_AT_OP_EQ:
return "==";
case B_AT_OP_NE:
return "!=";
case B_AT_OP_LE:
return "<=";
case B_AT_OP_LT:
return "<";
case B_AT_OP_GE:
return ">=";
case B_AT_OP_GT:
return ">";
case B_AT_OP_LAND:
return "&&";
case B_AT_OP_LOR:
return "||";
default:
xabort("unsuported type %d", ba->ba_type);
}

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) ?
 (void)0 : __assert2("/usr/src/usr.sbin/btrace/btrace.c", 1327
, __func__, "ba->ba_type == B_AT_VAR || ba->ba_type == B_AT_MAP"
));

static char buf[64];
size_t sz;
int l;

buf[0] = '@';
buf[1] = '\0';
sz = sizeof(buf) - 1;
l = snprintf(buf+1, sz, "%s", bv_name(ba->ba_value));
if (l < 0 || (size_t)l > sz) {
warn("string too long %d > %zu", l, sz);
return buf;
}

if (ba->ba_type == B_AT_MAP) {
sz -= l;
l = snprintf(buf+1+l, sz, "[%s]", ba_name(ba->ba_key));
if (l < 0 || (size_t)l > sz) {
	warn("string too long %d > %zu", l, sz);
	return buf;
}
}

return buf;
1352}

1354/*
* Return the representation of `ba' as long.
*/
1357long
1358ba2long(struct bt_arg *ba, struct dt_evt *dtev)
1359{
struct bt_var *bv;
long val;

switch (ba->ba_type) {
5
←
Control jumps to 'case B_AT_OP_PLUS:'  at line 1403→
case B_AT_LONG:
val = (long)ba->ba_value;
break;
case B_AT_VAR:
ba = ba_read(ba);
val = (long)ba->ba_value;
break;
case B_AT_MAP:
bv = ba->ba_value;
/* Unitialized map */
if (bv->bv_value == NULL((void *)0))
	return 0;
val = ba2long(map_get((struct map *)bv->bv_value,
    ba2str(ba->ba_key, dtev)), dtev);
break;
case B_AT_NIL:
val = 0L;
break;
case B_AT_BI_PID:
val = dtev->dtev_pid;
break;
case B_AT_BI_TID:
val = dtev->dtev_tid;
break;
case B_AT_BI_CPU:
val = dtev->dtev_cpu;
break;
case B_AT_BI_NSECS:
val = builtin_nsecs(dtev);
break;
case B_AT_BI_ARG0 ... B_AT_BI_ARG9:
val = dtev->dtev_args_args.E_entry[ba->ba_type - B_AT_BI_ARG0];
break;
case B_AT_BI_RETVAL:
val = dtev->dtev_retval_args.E_return.__retval[0];
break;
case B_AT_BI_PROBE:
val = dtev->dtev_pbn;
break;
case B_AT_OP_PLUS ... B_AT_OP_LOR:
val = baexpr2long(ba, dtev);
6
←
Calling 'baexpr2long'→
break;
default:
xabort("no long conversion for type %d", ba->ba_type);
}

return  val;
1411}

1413/*
* Return the representation of `ba' as string.
*/
1416const char *
1417ba2str(struct bt_arg *ba, struct dt_evt *dtev)
1418{
static char buf[STRLEN64];
struct bt_var *bv;
struct dtioc_probe_info *dtpi;
const char *str;

buf[0] = '\0';
switch (ba->ba_type) {
case B_AT_STR:
str = (const char *)ba->ba_value;
break;
case B_AT_LONG:
snprintf(buf, sizeof(buf), "%ld",(long)ba->ba_value);
str = buf;
break;
case B_AT_NIL:
str = "";
break;
case B_AT_BI_KSTACK:
str = builtin_stack(dtev, 1);
break;
case B_AT_BI_USTACK:
str = builtin_stack(dtev, 0);
break;
case B_AT_BI_COMM:
str = dtev->dtev_comm;
break;
case B_AT_BI_CPU:
snprintf(buf, sizeof(buf), "%u", dtev->dtev_cpu);
str = buf;
break;
case B_AT_BI_PID:
snprintf(buf, sizeof(buf), "%d", dtev->dtev_pid);
str = buf;
break;
case B_AT_BI_TID:
snprintf(buf, sizeof(buf), "%d", dtev->dtev_tid);
str = buf;
break;
case B_AT_BI_NSECS:
snprintf(buf, sizeof(buf), "%llu", builtin_nsecs(dtev));
str = buf;
break;
case B_AT_BI_ARG0 ... B_AT_BI_ARG9:
str = builtin_arg(dtev, ba->ba_type);
break;
case B_AT_BI_RETVAL:
snprintf(buf, sizeof(buf), "%ld", (long)dtev->dtev_retval_args.E_return.__retval[0]);
str = buf;
break;
case B_AT_BI_PROBE:
dtpi = dtpi_get_by_id(dtev->dtev_pbn);
if (dtpi != NULL((void *)0))
	snprintf(buf, sizeof(buf), "%s:%s:%s",
	    dtpi->dtpi_prov, dtpi_func(dtpi), dtpi->dtpi_name);
else
	snprintf(buf, sizeof(buf), "%u", dtev->dtev_pbn);
str = buf;
break;
case B_AT_MAP:
bv = ba->ba_value;
/* Unitialized map */
if (bv->bv_value == NULL((void *)0)) {
	str = buf;
	break;
}
str = ba2str(map_get((struct map *)bv->bv_value,
    ba2str(ba->ba_key, dtev)), dtev);
break;
case B_AT_VAR:
str = ba2str(ba_read(ba), dtev);
break;
case B_AT_FN_STR:
str = (const char*)(fn_str(ba, dtev, buf))->ba_value;
break;
case B_AT_OP_PLUS ... B_AT_OP_LOR:
snprintf(buf, sizeof(buf), "%ld", ba2long(ba, dtev));
str = buf;
break;
case B_AT_MF_COUNT:
case B_AT_MF_MAX:
case B_AT_MF_MIN:
case B_AT_MF_SUM:
assert(0)((0) ? (void)0 : __assert2("/usr/src/usr.sbin/btrace/btrace.c"
, 1501, __func__, "0"));
break;
default:
xabort("no string conversion for type %d", ba->ba_type);
}

return str;
1508}

1510/*
* Return dt(4) flags indicating which data should be recorded by the
* kernel, if any, for a given `ba'.
*/
1514int
1515ba2dtflags(struct bt_arg *ba)
1516{
struct bt_arg *bval;
int flags = 0;

do {
if (ba->ba_type == B_AT_MAP)
	bval = ba->ba_key;
else
	bval = ba;

switch (bval->ba_type) {
case B_AT_STR:
case B_AT_LONG:
case B_AT_VAR:
   	case B_AT_HIST:
case B_AT_NIL:
	break;
case B_AT_BI_KSTACK:
	flags |= DTEVT_KSTACK(1 << 2);
	break;
case B_AT_BI_USTACK:
	flags |= DTEVT_USTACK(1 << 1);
	break;
case B_AT_BI_COMM:
	flags |= DTEVT_EXECNAME(1 << 0);
	break;
case B_AT_BI_CPU:
case B_AT_BI_PID:
case B_AT_BI_TID:
case B_AT_BI_NSECS:
	break;
case B_AT_BI_ARG0 ... B_AT_BI_ARG9:
	flags |= DTEVT_FUNCARGS(1 << 3);
	break;
case B_AT_BI_RETVAL:
case B_AT_BI_PROBE:
	break;
case B_AT_MF_COUNT:
case B_AT_MF_MAX:
case B_AT_MF_MIN:
case B_AT_MF_SUM:
case B_AT_FN_STR:
case B_AT_OP_PLUS ... B_AT_OP_LOR:
	break;
default:
	xabort("invalid argument type %d", bval->ba_type);
}
} while ((ba = SLIST_NEXT(ba, ba_next)((ba)->ba_next.sle_next)) != NULL((void *)0));

return flags;
1566}

1568long
1569bacmp(struct bt_arg *a, struct bt_arg *b)
1570{
assert(a->ba_type == b->ba_type)((a->ba_type == b->ba_type) ? (void)0 : __assert2("/usr/src/usr.sbin/btrace/btrace.c"
, 1571, __func__, "a->ba_type == b->ba_type"));
assert(a->ba_type == B_AT_LONG)((a->ba_type == B_AT_LONG) ? (void)0 : __assert2("/usr/src/usr.sbin/btrace/btrace.c"
, 1572, __func__, "a->ba_type == B_AT_LONG"));

return ba2long(a, NULL((void *)0)) - ba2long(b, NULL((void *)0));
1575}

1577__dead__attribute__((__noreturn__)) void
1578xabort(const char *fmt, ...)
1579{
va_list ap;

va_start(ap, fmt)__builtin_va_start(ap, fmt);
vfprintf(stderr(&__sF[2]), fmt, ap);
va_end(ap)__builtin_va_end(ap);

fprintf(stderr(&__sF[2]), "\n");
abort();
1588}

1590void
1591debug(const char *fmt, ...)
1592{
va_list ap;

if (verbose < 2)
return;

fprintf(stderr(&__sF[2]), "debug: ");

va_start(ap, fmt)__builtin_va_start(ap, fmt);
vfprintf(stderr(&__sF[2]), fmt, ap);
va_end(ap)__builtin_va_end(ap);
1603}

1605void
1606debugx(const char *fmt, ...)
1607{
va_list ap;

if (verbose < 2)
return;

va_start(ap, fmt)__builtin_va_start(ap, fmt);
vfprintf(stderr(&__sF[2]), fmt, ap);
va_end(ap)__builtin_va_end(ap);
1616}

1618void
1619debug_dump_term(struct bt_arg *ba)
1620{
switch (ba->ba_type) {
case B_AT_LONG:
debugx("%s", ba2str(ba, NULL((void *)0)));
break;
case B_AT_OP_PLUS ... B_AT_OP_LOR:
debug_dump_expr(ba);
break;
default:
debugx("%s", ba_name(ba));
}
1631}

1633void
1634debug_dump_expr(struct bt_arg *ba)
1635{
struct bt_arg *lhs, *rhs;

lhs = ba->ba_value;
rhs = SLIST_NEXT(lhs, ba_next)((lhs)->ba_next.sle_next);

/* Left */
debug_dump_term(lhs);

/* Right */
if (rhs != NULL((void *)0)) {
debugx(" %s ", ba_name(ba));
debug_dump_term(rhs);
} else {
if (ba->ba_type != B_AT_OP_NE)
	debugx(" %s NULL", ba_name(ba));
}
1652}

1654void
1655debug_dump_filter(struct bt_rule *r)
1656{
struct bt_stmt *bs;

if (verbose < 2)
return;

if (r->br_filter == NULL((void *)0)) {
debugx("\n");
return;
}

bs = r->br_filter->bf_condition;

debugx(" /");
debug_dump_expr(SLIST_FIRST(&bs->bs_args)((&bs->bs_args)->slh_first));
debugx("/\n");
1672}

1674const char *
1675debug_probe_name(struct bt_probe *bp)
1676{
static char buf[64];

if (verbose < 2)
return "";

if (bp->bp_type == B_PT_BEGIN)
return "BEGIN";

if (bp->bp_type == B_PT_END)
return "END";

assert(bp->bp_type == B_PT_PROBE)((bp->bp_type == B_PT_PROBE) ? (void)0 : __assert2("/usr/src/usr.sbin/btrace/btrace.c"
, 1688, __func__, "bp->bp_type == B_PT_PROBE"));

if (bp->bp_rate) {
snprintf(buf, sizeof(buf), "%s:%s:%u", bp->bp_prov,
    bp->bp_unitbp_func, bp->bp_rate);
} else {
snprintf(buf, sizeof(buf), "%s:%s:%s", bp->bp_prov,
    bp->bp_unitbp_func, bp->bp_name);
}

return buf;
1699}