1 /*
2  * CDDL HEADER START
3  *
4  * The contents of this file are subject to the terms of the
5  * Common Development and Distribution License (the "License").
6  * You may not use this file except in compliance with the License.
7  *
8  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9  * or http://www.opensolaris.org/os/licensing.
10  * See the License for the specific language governing permissions
11  * and limitations under the License.
12  *
13  * When distributing Covered Code, include this CDDL HEADER in each
14  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15  * If applicable, add the following below this CDDL HEADER, with the
16  * fields enclosed by brackets "[]" replaced with your own identifying
17  * information: Portions Copyright [yyyy] [name of copyright owner]
18  *
19  * CDDL HEADER END
20  */
21 
22 /*
23  * Copyright (c) 2003, 2010, Oracle and/or its affiliates. All rights reserved.
24  * Copyright (c) 2012 by Delphix. All rights reserved.
25  */
26 
27 #include <sys/sysmacros.h>
28 
29 #include <strings.h>
30 #include <unistd.h>
31 #include <stdarg.h>
32 #include <stddef.h>
33 #include <stdlib.h>
34 #include <stdio.h>
35 #include <errno.h>
36 #include <ctype.h>
37 #include <alloca.h>
38 #include <assert.h>
39 #include <libgen.h>
40 #include <limits.h>
41 
42 #include <dt_impl.h>
43 
44 static const struct {
45 	size_t dtps_offset;
46 	size_t dtps_len;
47 } dtrace_probespecs[] = {
48 	{ offsetof(dtrace_probedesc_t, dtpd_provider),	DTRACE_PROVNAMELEN },
49 	{ offsetof(dtrace_probedesc_t, dtpd_mod),	DTRACE_MODNAMELEN },
50 	{ offsetof(dtrace_probedesc_t, dtpd_func),	DTRACE_FUNCNAMELEN },
51 	{ offsetof(dtrace_probedesc_t, dtpd_name),	DTRACE_NAMELEN }
52 };
53 
54 int
55 dtrace_xstr2desc(dtrace_hdl_t *dtp, dtrace_probespec_t spec,
56     const char *s, int argc, char *const argv[], dtrace_probedesc_t *pdp)
57 {
58 	size_t off, len, vlen, wlen;
59 	const char *p, *q, *v, *w;
60 
61 	char buf[32]; /* for id_t as %d (see below) */
62 
63 	if (spec < DTRACE_PROBESPEC_NONE || spec > DTRACE_PROBESPEC_NAME)
64 		return (dt_set_errno(dtp, EINVAL));
65 
66 	bzero(pdp, sizeof (dtrace_probedesc_t));
67 	p = s + strlen(s) - 1;
68 
69 	do {
70 		for (len = 0; p >= s && *p != ':'; len++)
71 			p--; /* move backward until we find a delimiter */
72 
73 		q = p + 1;
74 		vlen = 0;
75 		w = NULL;
76 		wlen = 0;
77 
78 		if ((v = strchr(q, '$')) != NULL && v < q + len) {
79 			/*
80 			 * Set vlen to the length of the variable name and then
81 			 * reset len to the length of the text prior to '$'. If
82 			 * the name begins with a digit, interpret it using the
83 			 * the argv[] array.  Otherwise we look in dt_macros.
84 			 * For the moment, all dt_macros variables are of type
85 			 * id_t (see dtrace_update() for more details on that).
86 			 */
87 			vlen = (size_t)(q + len - v);
88 			len = (size_t)(v - q);
89 
90 			/*
91 			 * If the variable string begins with $$, skip past the
92 			 * leading dollar sign since $ and $$ are equivalent
93 			 * macro reference operators in a probe description.
94 			 */
95 			if (vlen > 2 && v[1] == '$') {
96 				vlen--;
97 				v++;
98 			}
99 
100 			if (isdigit(v[1])) {
101 				long i;
102 
103 				errno = 0;
104 				i = strtol(v + 1, (char **)&w, 10);
105 
106 				wlen = vlen - (w - v);
107 
108 				if (i < 0 || i >= argc || errno != 0)
109 					return (dt_set_errno(dtp, EDT_BADSPCV));
110 
111 				v = argv[i];
112 				vlen = strlen(v);
113 
114 				if (yypcb != NULL && yypcb->pcb_sargv == argv)
115 					yypcb->pcb_sflagv[i] |= DT_IDFLG_REF;
116 
117 			} else if (vlen > 1) {
118 				char *vstr = alloca(vlen);
119 				dt_ident_t *idp;
120 
121 				(void) strncpy(vstr, v + 1, vlen - 1);
122 				vstr[vlen - 1] = '\0';
123 				idp = dt_idhash_lookup(dtp->dt_macros, vstr);
124 
125 				if (idp == NULL)
126 					return (dt_set_errno(dtp, EDT_BADSPCV));
127 
128 				v = buf;
129 				vlen = snprintf(buf, 32, "%d", idp->di_id);
130 
131 			} else
132 				return (dt_set_errno(dtp, EDT_BADSPCV));
133 		}
134 
135 		if (spec == DTRACE_PROBESPEC_NONE)
136 			return (dt_set_errno(dtp, EDT_BADSPEC));
137 
138 		if (len + vlen >= dtrace_probespecs[spec].dtps_len)
139 			return (dt_set_errno(dtp, ENAMETOOLONG));
140 
141 		off = dtrace_probespecs[spec--].dtps_offset;
142 		bcopy(q, (char *)pdp + off, len);
143 		bcopy(v, (char *)pdp + off + len, vlen);
144 		bcopy(w, (char *)pdp + off + len + vlen, wlen);
145 	} while (--p >= s);
146 
147 	pdp->dtpd_id = DTRACE_IDNONE;
148 	return (0);
149 }
150 
151 int
152 dtrace_str2desc(dtrace_hdl_t *dtp, dtrace_probespec_t spec,
153     const char *s, dtrace_probedesc_t *pdp)
154 {
155 	return (dtrace_xstr2desc(dtp, spec, s, 0, NULL, pdp));
156 }
157 
158 int
159 dtrace_id2desc(dtrace_hdl_t *dtp, dtrace_id_t id, dtrace_probedesc_t *pdp)
160 {
161 	bzero(pdp, sizeof (dtrace_probedesc_t));
162 	pdp->dtpd_id = id;
163 
164 	if (dt_ioctl(dtp, DTRACEIOC_PROBES, pdp) == -1 ||
165 	    pdp->dtpd_id != id)
166 		return (dt_set_errno(dtp, EDT_BADID));
167 
168 	return (0);
169 }
170 
171 char *
172 dtrace_desc2str(const dtrace_probedesc_t *pdp, char *buf, size_t len)
173 {
174 	if (pdp->dtpd_id == 0) {
175 		(void) snprintf(buf, len, "%s:%s:%s:%s", pdp->dtpd_provider,
176 		    pdp->dtpd_mod, pdp->dtpd_func, pdp->dtpd_name);
177 	} else
178 		(void) snprintf(buf, len, "%u", pdp->dtpd_id);
179 
180 	return (buf);
181 }
182 
183 char *
184 dtrace_attr2str(dtrace_attribute_t attr, char *buf, size_t len)
185 {
186 	const char *name = dtrace_stability_name(attr.dtat_name);
187 	const char *data = dtrace_stability_name(attr.dtat_data);
188 	const char *class = dtrace_class_name(attr.dtat_class);
189 
190 	if (name == NULL || data == NULL || class == NULL)
191 		return (NULL); /* one or more invalid attributes */
192 
193 	(void) snprintf(buf, len, "%s/%s/%s", name, data, class);
194 	return (buf);
195 }
196 
197 static char *
198 dt_getstrattr(char *p, char **qp)
199 {
200 	char *q;
201 
202 	if (*p == '\0')
203 		return (NULL);
204 
205 	if ((q = strchr(p, '/')) == NULL)
206 		q = p + strlen(p);
207 	else
208 		*q++ = '\0';
209 
210 	*qp = q;
211 	return (p);
212 }
213 
214 int
215 dtrace_str2attr(const char *str, dtrace_attribute_t *attr)
216 {
217 	dtrace_stability_t s;
218 	dtrace_class_t c;
219 	char *p, *q;
220 
221 	if (str == NULL || attr == NULL)
222 		return (-1); /* invalid function arguments */
223 
224 	*attr = _dtrace_maxattr;
225 	p = strdupa(str);
226 
227 	if ((p = dt_getstrattr(p, &q)) == NULL)
228 		return (0);
229 
230 	for (s = 0; s <= DTRACE_STABILITY_MAX; s++) {
231 		if (strcasecmp(p, dtrace_stability_name(s)) == 0) {
232 			attr->dtat_name = s;
233 			break;
234 		}
235 	}
236 
237 	if (s > DTRACE_STABILITY_MAX)
238 		return (-1);
239 
240 	if ((p = dt_getstrattr(q, &q)) == NULL)
241 		return (0);
242 
243 	for (s = 0; s <= DTRACE_STABILITY_MAX; s++) {
244 		if (strcasecmp(p, dtrace_stability_name(s)) == 0) {
245 			attr->dtat_data = s;
246 			break;
247 		}
248 	}
249 
250 	if (s > DTRACE_STABILITY_MAX)
251 		return (-1);
252 
253 	if ((p = dt_getstrattr(q, &q)) == NULL)
254 		return (0);
255 
256 	for (c = 0; c <= DTRACE_CLASS_MAX; c++) {
257 		if (strcasecmp(p, dtrace_class_name(c)) == 0) {
258 			attr->dtat_class = c;
259 			break;
260 		}
261 	}
262 
263 	if (c > DTRACE_CLASS_MAX || (p = dt_getstrattr(q, &q)) != NULL)
264 		return (-1);
265 
266 	return (0);
267 }
268 
269 const char *
270 dtrace_stability_name(dtrace_stability_t s)
271 {
272 	switch (s) {
273 	case DTRACE_STABILITY_INTERNAL:	return ("Internal");
274 	case DTRACE_STABILITY_PRIVATE:	return ("Private");
275 	case DTRACE_STABILITY_OBSOLETE:	return ("Obsolete");
276 	case DTRACE_STABILITY_EXTERNAL:	return ("External");
277 	case DTRACE_STABILITY_UNSTABLE:	return ("Unstable");
278 	case DTRACE_STABILITY_EVOLVING:	return ("Evolving");
279 	case DTRACE_STABILITY_STABLE:	return ("Stable");
280 	case DTRACE_STABILITY_STANDARD:	return ("Standard");
281 	default:			return (NULL);
282 	}
283 }
284 
285 const char *
286 dtrace_class_name(dtrace_class_t c)
287 {
288 	switch (c) {
289 	case DTRACE_CLASS_UNKNOWN:	return ("Unknown");
290 	case DTRACE_CLASS_CPU:		return ("CPU");
291 	case DTRACE_CLASS_PLATFORM:	return ("Platform");
292 	case DTRACE_CLASS_GROUP:	return ("Group");
293 	case DTRACE_CLASS_ISA:		return ("ISA");
294 	case DTRACE_CLASS_COMMON:	return ("Common");
295 	default:			return (NULL);
296 	}
297 }
298 
299 dtrace_attribute_t
300 dt_attr_min(dtrace_attribute_t a1, dtrace_attribute_t a2)
301 {
302 	dtrace_attribute_t am;
303 
304 	am.dtat_name = MIN(a1.dtat_name, a2.dtat_name);
305 	am.dtat_data = MIN(a1.dtat_data, a2.dtat_data);
306 	am.dtat_class = MIN(a1.dtat_class, a2.dtat_class);
307 
308 	return (am);
309 }
310 
311 dtrace_attribute_t
312 dt_attr_max(dtrace_attribute_t a1, dtrace_attribute_t a2)
313 {
314 	dtrace_attribute_t am;
315 
316 	am.dtat_name = MAX(a1.dtat_name, a2.dtat_name);
317 	am.dtat_data = MAX(a1.dtat_data, a2.dtat_data);
318 	am.dtat_class = MAX(a1.dtat_class, a2.dtat_class);
319 
320 	return (am);
321 }
322 
323 /*
324  * Compare two attributes and return an integer value in the following ranges:
325  *
326  * <0 if any of a1's attributes are less than a2's attributes
327  * =0 if all of a1's attributes are equal to a2's attributes
328  * >0 if all of a1's attributes are greater than or equal to a2's attributes
329  *
330  * To implement this function efficiently, we subtract a2's attributes from
331  * a1's to obtain a negative result if an a1 attribute is less than its a2
332  * counterpart.  We then OR the intermediate results together, relying on the
333  * twos-complement property that if any result is negative, the bitwise union
334  * will also be negative since the highest bit will be set in the result.
335  */
336 int
337 dt_attr_cmp(dtrace_attribute_t a1, dtrace_attribute_t a2)
338 {
339 	return (((int)a1.dtat_name - a2.dtat_name) |
340 	    ((int)a1.dtat_data - a2.dtat_data) |
341 	    ((int)a1.dtat_class - a2.dtat_class));
342 }
343 
344 char *
345 dt_attr_str(dtrace_attribute_t a, char *buf, size_t len)
346 {
347 	static const char stability[] = "ipoxuesS";
348 	static const char class[] = "uCpgIc";
349 
350 	if (a.dtat_name < sizeof (stability) &&
351 	    a.dtat_data < sizeof (stability) && a.dtat_class < sizeof (class)) {
352 		(void) snprintf(buf, len, "[%c/%c/%c]", stability[a.dtat_name],
353 		    stability[a.dtat_data], class[a.dtat_class]);
354 	} else {
355 		(void) snprintf(buf, len, "[%u/%u/%u]",
356 		    a.dtat_name, a.dtat_data, a.dtat_class);
357 	}
358 
359 	return (buf);
360 }
361 
362 char *
363 dt_version_num2str(dt_version_t v, char *buf, size_t len)
364 {
365 	uint_t M = DT_VERSION_MAJOR(v);
366 	uint_t m = DT_VERSION_MINOR(v);
367 	uint_t u = DT_VERSION_MICRO(v);
368 
369 	if (u == 0)
370 		(void) snprintf(buf, len, "%u.%u", M, m);
371 	else
372 		(void) snprintf(buf, len, "%u.%u.%u", M, m, u);
373 
374 	return (buf);
375 }
376 
377 int
378 dt_version_str2num(const char *s, dt_version_t *vp)
379 {
380 	int i = 0, n[3] = { 0, 0, 0 };
381 	char c;
382 
383 	while ((c = *s++) != '\0') {
384 		if (isdigit(c))
385 			n[i] = n[i] * 10 + c - '0';
386 		else if (c != '.' || i++ >= sizeof (n) / sizeof (n[0]) - 1)
387 			return (-1);
388 	}
389 
390 	if (n[0] > DT_VERSION_MAJMAX ||
391 	    n[1] > DT_VERSION_MINMAX ||
392 	    n[2] > DT_VERSION_MICMAX)
393 		return (-1);
394 
395 	if (vp != NULL)
396 		*vp = DT_VERSION_NUMBER(n[0], n[1], n[2]);
397 
398 	return (0);
399 }
400 
401 int
402 dt_version_defined(dt_version_t v)
403 {
404 	int i;
405 
406 	for (i = 0; _dtrace_versions[i] != 0; i++) {
407 		if (_dtrace_versions[i] == v)
408 			return (1);
409 	}
410 
411 	return (0);
412 }
413 
414 char *
415 dt_cpp_add_arg(dtrace_hdl_t *dtp, const char *str)
416 {
417 	char *arg;
418 
419 	if (dtp->dt_cpp_argc == dtp->dt_cpp_args) {
420 		int olds = dtp->dt_cpp_args;
421 		int news = olds * 2;
422 		char **argv = realloc(dtp->dt_cpp_argv, sizeof (char *) * news);
423 
424 		if (argv == NULL)
425 			return (NULL);
426 
427 		bzero(&argv[olds], sizeof (char *) * olds);
428 		dtp->dt_cpp_argv = argv;
429 		dtp->dt_cpp_args = news;
430 	}
431 
432 	if ((arg = strdup(str)) == NULL)
433 		return (NULL);
434 
435 	assert(dtp->dt_cpp_argc < dtp->dt_cpp_args);
436 	dtp->dt_cpp_argv[dtp->dt_cpp_argc++] = arg;
437 	return (arg);
438 }
439 
440 char *
441 dt_cpp_pop_arg(dtrace_hdl_t *dtp)
442 {
443 	char *arg;
444 
445 	if (dtp->dt_cpp_argc <= 1)
446 		return (NULL); /* dt_cpp_argv[0] cannot be popped */
447 
448 	arg = dtp->dt_cpp_argv[--dtp->dt_cpp_argc];
449 	dtp->dt_cpp_argv[dtp->dt_cpp_argc] = NULL;
450 
451 	return (arg);
452 }
453 
454 /*PRINTFLIKE1*/
455 void
456 dt_dprintf(const char *format, ...)
457 {
458 	if (_dtrace_debug) {
459 		va_list alist;
460 
461 		va_start(alist, format);
462 		(void) fputs("libdtrace DEBUG: ", stderr);
463 		(void) vfprintf(stderr, format, alist);
464 		va_end(alist);
465 	}
466 }
467 
468 int
469 dt_ioctl(dtrace_hdl_t *dtp, int val, void *arg)
470 {
471 	const dtrace_vector_t *v = dtp->dt_vector;
472 
473 	if (v != NULL)
474 		return (v->dtv_ioctl(dtp->dt_varg, val, arg));
475 
476 	if (dtp->dt_fd >= 0)
477 		return (ioctl(dtp->dt_fd, val, arg));
478 
479 	errno = EBADF;
480 	return (-1);
481 }
482 
483 int
484 dt_status(dtrace_hdl_t *dtp, processorid_t cpu)
485 {
486 	const dtrace_vector_t *v = dtp->dt_vector;
487 
488 	if (v == NULL)
489 		return (p_online(cpu, P_STATUS));
490 
491 	return (v->dtv_status(dtp->dt_varg, cpu));
492 }
493 
494 long
495 dt_sysconf(dtrace_hdl_t *dtp, int name)
496 {
497 	const dtrace_vector_t *v = dtp->dt_vector;
498 
499 	if (v == NULL)
500 		return (sysconf(name));
501 
502 	return (v->dtv_sysconf(dtp->dt_varg, name));
503 }
504 
505 /*
506  * Wrapper around write(2) to handle partial writes.  For maximum safety of
507  * output files and proper error reporting, we continuing writing in the
508  * face of partial writes until write(2) fails or 'buf' is completely written.
509  * We also record any errno in the specified dtrace_hdl_t as well as 'errno'.
510  */
511 ssize_t
512 dt_write(dtrace_hdl_t *dtp, int fd, const void *buf, size_t n)
513 {
514 	ssize_t resid = n;
515 	ssize_t len;
516 
517 	while (resid != 0) {
518 		if ((len = write(fd, buf, resid)) <= 0)
519 			break;
520 
521 		resid -= len;
522 		buf = (char *)buf + len;
523 	}
524 
525 	if (resid == n && n != 0)
526 		return (dt_set_errno(dtp, errno));
527 
528 	return (n - resid);
529 }
530 
531 /*
532  * This function handles all output from libdtrace, as well as the
533  * dtrace_sprintf() case.  If we're here due to dtrace_sprintf(), then
534  * dt_sprintf_buflen will be non-zero; in this case, we sprintf into the
535  * specified buffer and return.  Otherwise, if output is buffered (denoted by
536  * a NULL fp), we sprintf the desired output into the buffered buffer
537  * (expanding the buffer if required).  If we don't satisfy either of these
538  * conditions (that is, if we are to actually generate output), then we call
539  * fprintf with the specified fp.  In this case, we need to deal with one of
540  * the more annoying peculiarities of libc's printf routines:  any failed
541  * write persistently sets an error flag inside the FILE causing every
542  * subsequent write to fail, but only the caller that initiated the error gets
543  * the errno.  Since libdtrace clients often intercept SIGINT, this case is
544  * particularly frustrating since we don't want the EINTR on one attempt to
545  * write to the output file to preclude later attempts to write.  This
546  * function therefore does a clearerr() if any error occurred, and saves the
547  * errno for the caller inside the specified dtrace_hdl_t.
548  */
549 /*PRINTFLIKE3*/
550 int
551 dt_printf(dtrace_hdl_t *dtp, FILE *fp, const char *format, ...)
552 {
553 	va_list ap;
554 	int n;
555 
556 	va_start(ap, format);
557 
558 	if (dtp->dt_sprintf_buflen != 0) {
559 		int len;
560 		char *buf;
561 
562 		assert(dtp->dt_sprintf_buf != NULL);
563 
564 		buf = &dtp->dt_sprintf_buf[len = strlen(dtp->dt_sprintf_buf)];
565 		len = dtp->dt_sprintf_buflen - len;
566 		assert(len >= 0);
567 
568 		if ((n = vsnprintf(buf, len, format, ap)) < 0)
569 			n = dt_set_errno(dtp, errno);
570 
571 		va_end(ap);
572 
573 		return (n);
574 	}
575 
576 	if (fp == NULL) {
577 		int needed, rval;
578 		size_t avail;
579 
580 		/*
581 		 * Using buffered output is not allowed if a handler has
582 		 * not been installed.
583 		 */
584 		if (dtp->dt_bufhdlr == NULL) {
585 			va_end(ap);
586 			return (dt_set_errno(dtp, EDT_NOBUFFERED));
587 		}
588 
589 		if (dtp->dt_buffered_buf == NULL) {
590 			assert(dtp->dt_buffered_size == 0);
591 			dtp->dt_buffered_size = 1;
592 			dtp->dt_buffered_buf = malloc(dtp->dt_buffered_size);
593 
594 			if (dtp->dt_buffered_buf == NULL) {
595 				va_end(ap);
596 				return (dt_set_errno(dtp, EDT_NOMEM));
597 			}
598 
599 			dtp->dt_buffered_offs = 0;
600 			dtp->dt_buffered_buf[0] = '\0';
601 		}
602 
603 		if ((needed = vsnprintf(NULL, 0, format, ap)) < 0) {
604 			rval = dt_set_errno(dtp, errno);
605 			va_end(ap);
606 			return (rval);
607 		}
608 
609 		if (needed == 0) {
610 			va_end(ap);
611 			return (0);
612 		}
613 
614 		for (;;) {
615 			char *newbuf;
616 
617 			assert(dtp->dt_buffered_offs < dtp->dt_buffered_size);
618 			avail = dtp->dt_buffered_size - dtp->dt_buffered_offs;
619 
620 			if (needed + 1 < avail)
621 				break;
622 
623 			if ((newbuf = realloc(dtp->dt_buffered_buf,
624 			    dtp->dt_buffered_size << 1)) == NULL) {
625 				va_end(ap);
626 				return (dt_set_errno(dtp, EDT_NOMEM));
627 			}
628 
629 			dtp->dt_buffered_buf = newbuf;
630 			dtp->dt_buffered_size <<= 1;
631 		}
632 
633 		if (vsnprintf(&dtp->dt_buffered_buf[dtp->dt_buffered_offs],
634 		    avail, format, ap) < 0) {
635 			rval = dt_set_errno(dtp, errno);
636 			va_end(ap);
637 			return (rval);
638 		}
639 
640 		dtp->dt_buffered_offs += needed;
641 		assert(dtp->dt_buffered_buf[dtp->dt_buffered_offs] == '\0');
642 		return (0);
643 	}
644 
645 	n = vfprintf(fp, format, ap);
646 	va_end(ap);
647 
648 	if (n < 0) {
649 		clearerr(fp);
650 		return (dt_set_errno(dtp, errno));
651 	}
652 
653 	return (n);
654 }
655 
656 int
657 dt_buffered_flush(dtrace_hdl_t *dtp, dtrace_probedata_t *pdata,
658     const dtrace_recdesc_t *rec, const dtrace_aggdata_t *agg, uint32_t flags)
659 {
660 	dtrace_bufdata_t data;
661 
662 	if (dtp->dt_buffered_offs == 0)
663 		return (0);
664 
665 	data.dtbda_handle = dtp;
666 	data.dtbda_buffered = dtp->dt_buffered_buf;
667 	data.dtbda_probe = pdata;
668 	data.dtbda_recdesc = rec;
669 	data.dtbda_aggdata = agg;
670 	data.dtbda_flags = flags;
671 
672 	if ((*dtp->dt_bufhdlr)(&data, dtp->dt_bufarg) == DTRACE_HANDLE_ABORT)
673 		return (dt_set_errno(dtp, EDT_DIRABORT));
674 
675 	dtp->dt_buffered_offs = 0;
676 	dtp->dt_buffered_buf[0] = '\0';
677 
678 	return (0);
679 }
680 
681 void
682 dt_buffered_destroy(dtrace_hdl_t *dtp)
683 {
684 	free(dtp->dt_buffered_buf);
685 	dtp->dt_buffered_buf = NULL;
686 	dtp->dt_buffered_offs = 0;
687 	dtp->dt_buffered_size = 0;
688 }
689 
690 void *
691 dt_zalloc(dtrace_hdl_t *dtp, size_t size)
692 {
693 	void *data;
694 
695 	if ((data = malloc(size)) == NULL)
696 		(void) dt_set_errno(dtp, EDT_NOMEM);
697 	else
698 		bzero(data, size);
699 
700 	return (data);
701 }
702 
703 void *
704 dt_alloc(dtrace_hdl_t *dtp, size_t size)
705 {
706 	void *data;
707 
708 	if ((data = malloc(size)) == NULL)
709 		(void) dt_set_errno(dtp, EDT_NOMEM);
710 
711 	return (data);
712 }
713 
714 void
715 dt_free(dtrace_hdl_t *dtp, void *data)
716 {
717 	assert(dtp != NULL); /* ensure sane use of this interface */
718 	free(data);
719 }
720 
721 void
722 dt_difo_free(dtrace_hdl_t *dtp, dtrace_difo_t *dp)
723 {
724 	if (dp == NULL)
725 		return; /* simplify caller code */
726 
727 	dt_free(dtp, dp->dtdo_buf);
728 	dt_free(dtp, dp->dtdo_inttab);
729 	dt_free(dtp, dp->dtdo_strtab);
730 	dt_free(dtp, dp->dtdo_vartab);
731 	dt_free(dtp, dp->dtdo_kreltab);
732 	dt_free(dtp, dp->dtdo_ureltab);
733 	dt_free(dtp, dp->dtdo_xlmtab);
734 
735 	dt_free(dtp, dp);
736 }
737 
738 /*
739  * dt_gmatch() is similar to gmatch(3GEN) and dtrace(7D) globbing, but also
740  * implements the behavior that an empty pattern matches any string.
741  */
742 int
743 dt_gmatch(const char *s, const char *p)
744 {
745 	return (p == NULL || *p == '\0' || gmatch(s, p));
746 }
747 
748 char *
749 dt_basename(char *str)
750 {
751 	char *last = strrchr(str, '/');
752 
753 	if (last == NULL)
754 		return (str);
755 
756 	return (last + 1);
757 }
758 
759 /*
760  * dt_popc() is a fast implementation of population count.  The algorithm is
761  * from "Hacker's Delight" by Henry Warren, Jr with a 64-bit equivalent added.
762  */
763 ulong_t
764 dt_popc(ulong_t x)
765 {
766 #ifdef _ILP32
767 	x = x - ((x >> 1) & 0x55555555UL);
768 	x = (x & 0x33333333UL) + ((x >> 2) & 0x33333333UL);
769 	x = (x + (x >> 4)) & 0x0F0F0F0FUL;
770 	x = x + (x >> 8);
771 	x = x + (x >> 16);
772 	return (x & 0x3F);
773 #endif
774 #ifdef _LP64
775 	x = x - ((x >> 1) & 0x5555555555555555ULL);
776 	x = (x & 0x3333333333333333ULL) + ((x >> 2) & 0x3333333333333333ULL);
777 	x = (x + (x >> 4)) & 0x0F0F0F0F0F0F0F0FULL;
778 	x = x + (x >> 8);
779 	x = x + (x >> 16);
780 	x = x + (x >> 32);
781 	return (x & 0x7F);
782 #endif
783 }
784 
785 /*
786  * dt_popcb() is a bitmap-based version of population count that returns the
787  * number of one bits in the specified bitmap 'bp' at bit positions below 'n'.
788  */
789 ulong_t
790 dt_popcb(const ulong_t *bp, ulong_t n)
791 {
792 	ulong_t maxb = n & BT_ULMASK;
793 	ulong_t maxw = n >> BT_ULSHIFT;
794 	ulong_t w, popc = 0;
795 
796 	if (n == 0)
797 		return (0);
798 
799 	for (w = 0; w < maxw; w++)
800 		popc += dt_popc(bp[w]);
801 
802 	return (popc + dt_popc(bp[maxw] & ((1UL << maxb) - 1)));
803 }
804 
805 static int
806 dt_string2str(char *s, char *str, int nbytes)
807 {
808 	int len = strlen(s);
809 
810 	if (nbytes == 0) {
811 		/*
812 		 * Like snprintf(3C), we don't check the value of str if the
813 		 * number of bytes is 0.
814 		 */
815 		return (len);
816 	}
817 
818 	if (nbytes <= len) {
819 		(void) strncpy(str, s, nbytes - 1);
820 		/*
821 		 * Like snprintf(3C) (and unlike strncpy(3C)), we guarantee
822 		 * that the string is null-terminated.
823 		 */
824 		str[nbytes - 1] = '\0';
825 	} else {
826 		(void) strcpy(str, s);
827 	}
828 
829 	return (len);
830 }
831 
832 int
833 dtrace_addr2str(dtrace_hdl_t *dtp, uint64_t addr, char *str, int nbytes)
834 {
835 	dtrace_syminfo_t dts;
836 	GElf_Sym sym;
837 
838 	size_t n = 20; /* for 0x%llx\0 */
839 	char *s;
840 	int err;
841 
842 	if ((err = dtrace_lookup_by_addr(dtp, addr, &sym, &dts)) == 0)
843 		n += strlen(dts.dts_object) + strlen(dts.dts_name) + 2; /* +` */
844 
845 	s = alloca(n);
846 
847 	if (err == 0 && addr != sym.st_value) {
848 		(void) snprintf(s, n, "%s`%s+0x%llx", dts.dts_object,
849 		    dts.dts_name, (u_longlong_t)addr - sym.st_value);
850 	} else if (err == 0) {
851 		(void) snprintf(s, n, "%s`%s",
852 		    dts.dts_object, dts.dts_name);
853 	} else {
854 		/*
855 		 * We'll repeat the lookup, but this time we'll specify a NULL
856 		 * GElf_Sym -- indicating that we're only interested in the
857 		 * containing module.
858 		 */
859 		if (dtrace_lookup_by_addr(dtp, addr, NULL, &dts) == 0) {
860 			(void) snprintf(s, n, "%s`0x%llx", dts.dts_object,
861 			    (u_longlong_t)addr);
862 		} else {
863 			(void) snprintf(s, n, "0x%llx", (u_longlong_t)addr);
864 		}
865 	}
866 
867 	return (dt_string2str(s, str, nbytes));
868 }
869 
870 int
871 dtrace_uaddr2str(dtrace_hdl_t *dtp, pid_t pid,
872     uint64_t addr, char *str, int nbytes)
873 {
874 	char name[PATH_MAX], objname[PATH_MAX], c[PATH_MAX * 2];
875 	struct ps_prochandle *P = NULL;
876 	GElf_Sym sym;
877 	char *obj;
878 
879 	if (pid != 0)
880 		P = dt_proc_grab(dtp, pid, PGRAB_RDONLY | PGRAB_FORCE, 0);
881 
882 	if (P == NULL) {
883 		(void) snprintf(c, sizeof (c), "0x%llx", addr);
884 		return (dt_string2str(c, str, nbytes));
885 	}
886 
887 	dt_proc_lock(dtp, P);
888 
889 	if (Plookup_by_addr(P, addr, name, sizeof (name), &sym) == 0) {
890 		(void) Pobjname(P, addr, objname, sizeof (objname));
891 
892 		obj = dt_basename(objname);
893 
894 		if (addr > sym.st_value) {
895 			(void) snprintf(c, sizeof (c), "%s`%s+0x%llx", obj,
896 			    name, (u_longlong_t)(addr - sym.st_value));
897 		} else {
898 			(void) snprintf(c, sizeof (c), "%s`%s", obj, name);
899 		}
900 	} else if (Pobjname(P, addr, objname, sizeof (objname)) != NULL) {
901 		(void) snprintf(c, sizeof (c), "%s`0x%llx",
902 		    dt_basename(objname), addr);
903 	} else {
904 		(void) snprintf(c, sizeof (c), "0x%llx", addr);
905 	}
906 
907 	dt_proc_unlock(dtp, P);
908 	dt_proc_release(dtp, P);
909 
910 	return (dt_string2str(c, str, nbytes));
911 }
912