2 * Copyright (C) 2008 John Birrell <jb@freebsd.org>.
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
8 * 1. Redistributions of source code must retain the above copyright
9 * notice(s), this list of conditions and the following disclaimer as
10 * the first lines of this file unmodified other than the possible
11 * addition of one or more copyright notices.
12 * 2. Redistributions in binary form must reproduce the above copyright
13 * notice(s), this list of conditions and the following disclaimer in the
14 * documentation and/or other materials provided with the distribution.
16 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDER(S) ``AS IS'' AND ANY
17 * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
18 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
19 * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER(S) BE LIABLE FOR ANY
20 * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
21 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
22 * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
23 * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
24 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
25 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
34 #if defined(__amd64__)
36 dtrace_cmpset_long(volatile u_long *dst, u_long exp, u_long src)
45 "# dtrace_cmpset_long"
55 #elif defined(__i386__)
57 dtrace_cmpset_long(volatile u_long *dst, u_long exp, u_long src)
66 "# dtrace_cmpset_long"
78 #define DTRACE_DEBUG_BUFR_SIZE (32 * 1024)
80 struct dtrace_debug_data {
81 char bufr[DTRACE_DEBUG_BUFR_SIZE];
85 } dtrace_debug_data[MAXCPU];
87 static char dtrace_debug_bufr[DTRACE_DEBUG_BUFR_SIZE];
89 static volatile u_long dtrace_debug_flag[MAXCPU];
92 dtrace_debug_lock(int cpu)
94 while (dtrace_cmpset_long(&dtrace_debug_flag[cpu], 0, 1) == 0)
95 /* Loop until the lock is obtained. */
100 dtrace_debug_unlock(int cpu)
102 dtrace_debug_flag[cpu] = 0;
106 dtrace_debug_init(void *dummy)
109 struct dtrace_debug_data *d;
112 d = &dtrace_debug_data[i];
114 if (d->first == NULL) {
117 d->last = d->bufr + DTRACE_DEBUG_BUFR_SIZE - 1;
123 SYSINIT(dtrace_debug_init, SI_SUB_KDTRACE, SI_ORDER_ANY, dtrace_debug_init, NULL);
124 SYSINIT(dtrace_debug_smpinit, SI_SUB_SMP, SI_ORDER_ANY, dtrace_debug_init, NULL);
127 dtrace_debug_output(void)
131 struct dtrace_debug_data *d;
135 dtrace_debug_lock(i);
137 d = &dtrace_debug_data[i];
141 if (d->first < d->next) {
142 char *p1 = dtrace_debug_bufr;
144 count = (uintptr_t) d->next - (uintptr_t) d->first;
146 for (p = d->first; p < d->next; p++)
148 } else if (d->next > d->first) {
149 char *p1 = dtrace_debug_bufr;
151 count = (uintptr_t) d->last - (uintptr_t) d->first;
153 for (p = d->first; p < d->last; p++)
156 count += (uintptr_t) d->next - (uintptr_t) d->bufr;
158 for (p = d->bufr; p < d->next; p++)
165 dtrace_debug_unlock(i);
168 char *last = dtrace_debug_bufr + count;
170 p = dtrace_debug_bufr;
187 * Functions below here are called from the probe context, so they can't call
188 * _any_ functions outside the dtrace module without running foul of the function
189 * boundary trace provider (fbt). The purpose of these functions is limited to
190 * buffering debug strings for output when the probe completes on the current CPU.
194 dtrace_debug__putc(char c)
196 struct dtrace_debug_data *d = &dtrace_debug_data[curcpu];
200 if (d->next == d->last)
205 if (d->next == d->first)
208 if (d->first == d->last)
213 dtrace_debug_putc(char c)
215 dtrace_debug_lock(curcpu);
217 dtrace_debug__putc(c);
219 dtrace_debug_unlock(curcpu);
223 dtrace_debug_puts(const char *s)
225 dtrace_debug_lock(curcpu);
228 dtrace_debug__putc(*s++);
230 dtrace_debug__putc('\0');
232 dtrace_debug_unlock(curcpu);
236 * Snaffled from sys/kern/subr_prf.c
238 * Put a NUL-terminated ASCII number (base <= 36) in a buffer in reverse
239 * order; return an optional length and a pointer to the last character
240 * written in the buffer (i.e., the first character of the string).
241 * The buffer pointed to by `nbuf' must have length >= MAXNBUF.
244 dtrace_debug_ksprintn(char *nbuf, uintmax_t num, int base, int *lenp, int upper)
251 c = hex2ascii(num % base);
252 *++p = upper ? toupper(c) : c;
253 } while (num /= base);
259 #define MAXNBUF (sizeof(intmax_t) * NBBY + 1)
262 dtrace_debug_vprintf(const char *fmt, va_list ap)
265 const char *p, *percent, *q;
269 int base, lflag, qflag, tmp, width, ladjust, sharpflag, neg, sign, dot;
270 int cflag, hflag, jflag, tflag, zflag;
274 int stop = 0, retval = 0;
279 fmt = "(fmt null)\n";
284 while ((ch = (u_char)*fmt++) != '%' || stop) {
286 dtrace_debug__putc('\0');
289 dtrace_debug__putc(ch);
292 qflag = 0; lflag = 0; ladjust = 0; sharpflag = 0; neg = 0;
293 sign = 0; dot = 0; dwidth = 0; upper = 0;
294 cflag = 0; hflag = 0; jflag = 0; tflag = 0; zflag = 0;
295 reswitch: switch (ch = (u_char)*fmt++) {
309 dtrace_debug__putc(ch);
313 width = va_arg(ap, int);
319 dwidth = va_arg(ap, int);
327 case '1': case '2': case '3': case '4':
328 case '5': case '6': case '7': case '8': case '9':
329 for (n = 0;; ++fmt) {
330 n = n * 10 + ch - '0';
332 if (ch < '0' || ch > '9')
341 num = (u_int)va_arg(ap, int);
342 p = va_arg(ap, char *);
343 for (q = dtrace_debug_ksprintn(nbuf, num, *p++, NULL, 0); *q;)
344 dtrace_debug__putc(*q--);
351 if (num & (1 << (n - 1))) {
352 dtrace_debug__putc(tmp ? ',' : '<');
353 for (; (n = *p) > ' '; ++p)
354 dtrace_debug__putc(n);
357 for (; *p > ' '; ++p)
361 dtrace_debug__putc('>');
364 dtrace_debug__putc(va_arg(ap, int));
367 up = va_arg(ap, u_char *);
368 p = va_arg(ap, char *);
372 dtrace_debug__putc(hex2ascii(*up >> 4));
373 dtrace_debug__putc(hex2ascii(*up & 0x0f));
377 dtrace_debug__putc(*q);
404 *(va_arg(ap, intmax_t *)) = retval;
406 *(va_arg(ap, quad_t *)) = retval;
408 *(va_arg(ap, long *)) = retval;
410 *(va_arg(ap, size_t *)) = retval;
412 *(va_arg(ap, short *)) = retval;
414 *(va_arg(ap, char *)) = retval;
416 *(va_arg(ap, int *)) = retval;
423 sharpflag = (width == 0);
425 num = (uintptr_t)va_arg(ap, void *);
436 p = va_arg(ap, char *);
442 for (n = 0; n < dwidth && p[n]; n++)
447 if (!ladjust && width > 0)
449 dtrace_debug__putc(padc);
451 dtrace_debug__putc(*p++);
452 if (ladjust && width > 0)
454 dtrace_debug__putc(padc);
477 num = va_arg(ap, uintmax_t);
479 num = va_arg(ap, u_quad_t);
481 num = va_arg(ap, ptrdiff_t);
483 num = va_arg(ap, u_long);
485 num = va_arg(ap, size_t);
487 num = (u_short)va_arg(ap, int);
489 num = (u_char)va_arg(ap, int);
491 num = va_arg(ap, u_int);
495 num = va_arg(ap, intmax_t);
497 num = va_arg(ap, quad_t);
499 num = va_arg(ap, ptrdiff_t);
501 num = va_arg(ap, long);
503 num = va_arg(ap, size_t);
505 num = (short)va_arg(ap, int);
507 num = (char)va_arg(ap, int);
509 num = va_arg(ap, int);
511 if (sign && (intmax_t)num < 0) {
513 num = -(intmax_t)num;
515 p = dtrace_debug_ksprintn(nbuf, num, base, &tmp, upper);
516 if (sharpflag && num != 0) {
525 if (!ladjust && padc != '0' && width
526 && (width -= tmp) > 0)
528 dtrace_debug__putc(padc);
530 dtrace_debug__putc('-');
531 if (sharpflag && num != 0) {
533 dtrace_debug__putc('0');
534 } else if (base == 16) {
535 dtrace_debug__putc('0');
536 dtrace_debug__putc('x');
539 if (!ladjust && width && (width -= tmp) > 0)
541 dtrace_debug__putc(padc);
544 dtrace_debug__putc(*p--);
546 if (ladjust && width && (width -= tmp) > 0)
548 dtrace_debug__putc(padc);
552 while (percent < fmt)
553 dtrace_debug__putc(*percent++);
555 * Since we ignore an formatting argument it is no
556 * longer safe to obey the remaining formatting
557 * arguments as the arguments will no longer match
565 dtrace_debug__putc('\0');
569 dtrace_debug_printf(const char *fmt, ...)
573 dtrace_debug_lock(curcpu);
577 dtrace_debug_vprintf(fmt, ap);
581 dtrace_debug_unlock(curcpu);
586 #define dtrace_debug_output()
587 #define dtrace_debug_puts(_s)
588 #define dtrace_debug_printf(fmt, ...)