Index: head/sys/kern/kern_ktr.c =================================================================== --- head/sys/kern/kern_ktr.c (revision 283282) +++ head/sys/kern/kern_ktr.c (revision 283283) @@ -1,475 +1,477 @@ /*- * Copyright (c) 2000 John Baldwin * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. */ /* * This module holds the global variables used by KTR and the ktr_tracepoint() * function that does the actual tracing. */ #include __FBSDID("$FreeBSD$"); #include "opt_ddb.h" #include "opt_ktr.h" #include "opt_alq.h" #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #ifdef __sparc64__ #include #endif #ifdef DDB #include #include #endif #ifndef KTR_BOOT_ENTRIES #define KTR_BOOT_ENTRIES 1024 #endif #ifndef KTR_ENTRIES #define KTR_ENTRIES 1024 #endif /* Limit the allocations to something manageable. */ #define KTR_ENTRIES_MAX (8 * 1024 * 1024) #ifndef KTR_MASK #define KTR_MASK (0) #endif #ifndef KTR_CPUMASK #define KTR_CPUMASK CPUSET_FSET #endif #ifndef KTR_TIME #define KTR_TIME get_cyclecount() #endif #ifndef KTR_CPU #define KTR_CPU PCPU_GET(cpuid) #endif static MALLOC_DEFINE(M_KTR, "KTR", "KTR"); FEATURE(ktr, "Kernel support for KTR kernel tracing facility"); volatile int ktr_idx = 0; -int ktr_mask = KTR_MASK; -int ktr_compile = KTR_COMPILE; +uint64_t ktr_mask = KTR_MASK; +uint64_t ktr_compile = KTR_COMPILE; int ktr_entries = KTR_BOOT_ENTRIES; int ktr_version = KTR_VERSION; struct ktr_entry ktr_buf_init[KTR_BOOT_ENTRIES]; struct ktr_entry *ktr_buf = ktr_buf_init; cpuset_t ktr_cpumask = CPUSET_T_INITIALIZER(KTR_CPUMASK); static SYSCTL_NODE(_debug, OID_AUTO, ktr, CTLFLAG_RD, 0, "KTR options"); SYSCTL_INT(_debug_ktr, OID_AUTO, version, CTLFLAG_RD, &ktr_version, 0, "Version of the KTR interface"); -SYSCTL_UINT(_debug_ktr, OID_AUTO, compile, CTLFLAG_RD, +SYSCTL_UQUAD(_debug_ktr, OID_AUTO, compile, CTLFLAG_RD, &ktr_compile, 0, "Bitmask of KTR event classes compiled into the kernel"); static int sysctl_debug_ktr_cpumask(SYSCTL_HANDLER_ARGS) { char lktr_cpumask_str[CPUSETBUFSIZ]; cpuset_t imask; int error; cpusetobj_strprint(lktr_cpumask_str, &ktr_cpumask); error = sysctl_handle_string(oidp, lktr_cpumask_str, sizeof(lktr_cpumask_str), req); if (error != 0 || req->newptr == NULL) return (error); if (cpusetobj_strscan(&imask, lktr_cpumask_str) == -1) return (EINVAL); CPU_COPY(&imask, &ktr_cpumask); return (error); } SYSCTL_PROC(_debug_ktr, OID_AUTO, cpumask, CTLFLAG_RWTUN | CTLFLAG_MPSAFE | CTLTYPE_STRING, NULL, 0, sysctl_debug_ktr_cpumask, "S", "Bitmask of CPUs on which KTR logging is enabled"); static int sysctl_debug_ktr_clear(SYSCTL_HANDLER_ARGS) { int clear, error; clear = 0; error = sysctl_handle_int(oidp, &clear, 0, req); if (error || !req->newptr) return (error); if (clear) { bzero(ktr_buf, sizeof(*ktr_buf) * ktr_entries); ktr_idx = 0; } return (error); } SYSCTL_PROC(_debug_ktr, OID_AUTO, clear, CTLTYPE_INT|CTLFLAG_RW, 0, 0, sysctl_debug_ktr_clear, "I", "Clear KTR Buffer"); /* * This is a sysctl proc so that it is serialized as !MPSAFE along with * the other ktr sysctl procs. */ static int sysctl_debug_ktr_mask(SYSCTL_HANDLER_ARGS) { - int mask, error; + uint64_t mask; + int error; mask = ktr_mask; - error = sysctl_handle_int(oidp, &mask, 0, req); + error = sysctl_handle_64(oidp, &mask, 0, req); if (error || !req->newptr) return (error); ktr_mask = mask; return (error); } -SYSCTL_PROC(_debug_ktr, OID_AUTO, mask, CTLTYPE_UINT|CTLFLAG_RWTUN, 0, 0, - sysctl_debug_ktr_mask, "IU", +SYSCTL_PROC(_debug_ktr, OID_AUTO, mask, CTLTYPE_U64 | CTLFLAG_RWTUN, 0, 0, + sysctl_debug_ktr_mask, "QU", "Bitmask of KTR event classes for which logging is enabled"); #if KTR_ENTRIES > KTR_BOOT_ENTRIES /* * A simplified version of sysctl_debug_ktr_entries. * No need to care about SMP, scheduling, etc. */ static void ktr_entries_initializer(void *dummy __unused) { - int mask; + uint64_t mask; /* Temporarily disable ktr in case malloc() is being traced. */ mask = ktr_mask; ktr_mask = 0; ktr_buf = malloc(sizeof(*ktr_buf) * KTR_ENTRIES, M_KTR, M_WAITOK | M_ZERO); memcpy(ktr_buf, ktr_buf_init + ktr_idx, (KTR_BOOT_ENTRIES - ktr_idx) * sizeof(*ktr_buf)); if (ktr_idx != 0) { memcpy(ktr_buf + KTR_BOOT_ENTRIES - ktr_idx, ktr_buf_init, ktr_idx * sizeof(*ktr_buf)); ktr_idx = KTR_BOOT_ENTRIES; } ktr_entries = KTR_ENTRIES; ktr_mask = mask; } SYSINIT(ktr_entries_initializer, SI_SUB_KMEM, SI_ORDER_ANY, ktr_entries_initializer, NULL); #endif static int sysctl_debug_ktr_entries(SYSCTL_HANDLER_ARGS) { - int entries, error, mask; + uint64_t mask; + int entries, error; struct ktr_entry *buf, *oldbuf; entries = ktr_entries; error = sysctl_handle_int(oidp, &entries, 0, req); if (error || !req->newptr) return (error); if (entries > KTR_ENTRIES_MAX) return (ERANGE); /* Disable ktr temporarily. */ mask = ktr_mask; - atomic_store_rel_int(&ktr_mask, 0); + ktr_mask = 0; /* Wait for threads to go idle. */ if ((error = quiesce_all_cpus("ktrent", PCATCH)) != 0) { ktr_mask = mask; return (error); } if (ktr_buf != ktr_buf_init) oldbuf = ktr_buf; else oldbuf = NULL; /* Allocate a new buffer. */ buf = malloc(sizeof(*buf) * entries, M_KTR, M_WAITOK | M_ZERO); /* Install the new buffer and restart ktr. */ ktr_buf = buf; ktr_entries = entries; ktr_idx = 0; - atomic_store_rel_int(&ktr_mask, mask); + ktr_mask = mask; if (oldbuf != NULL) free(oldbuf, M_KTR); return (error); } SYSCTL_PROC(_debug_ktr, OID_AUTO, entries, CTLTYPE_INT|CTLFLAG_RW, 0, 0, sysctl_debug_ktr_entries, "I", "Number of entries in the KTR buffer"); #ifdef KTR_VERBOSE int ktr_verbose = KTR_VERBOSE; TUNABLE_INT("debug.ktr.verbose", &ktr_verbose); SYSCTL_INT(_debug_ktr, OID_AUTO, verbose, CTLFLAG_RW, &ktr_verbose, 0, ""); #endif #ifdef KTR_ALQ struct alq *ktr_alq; char ktr_alq_file[MAXPATHLEN] = "/tmp/ktr.out"; int ktr_alq_cnt = 0; int ktr_alq_depth = KTR_ENTRIES; int ktr_alq_enabled = 0; int ktr_alq_failed = 0; int ktr_alq_max = 0; SYSCTL_INT(_debug_ktr, OID_AUTO, alq_max, CTLFLAG_RW, &ktr_alq_max, 0, "Maximum number of entries to write"); SYSCTL_INT(_debug_ktr, OID_AUTO, alq_cnt, CTLFLAG_RD, &ktr_alq_cnt, 0, "Current number of written entries"); SYSCTL_INT(_debug_ktr, OID_AUTO, alq_failed, CTLFLAG_RD, &ktr_alq_failed, 0, "Number of times we overran the buffer"); SYSCTL_INT(_debug_ktr, OID_AUTO, alq_depth, CTLFLAG_RW, &ktr_alq_depth, 0, "Number of items in the write buffer"); SYSCTL_STRING(_debug_ktr, OID_AUTO, alq_file, CTLFLAG_RW, ktr_alq_file, sizeof(ktr_alq_file), "KTR logging file"); static int sysctl_debug_ktr_alq_enable(SYSCTL_HANDLER_ARGS) { int error; int enable; enable = ktr_alq_enabled; error = sysctl_handle_int(oidp, &enable, 0, req); if (error || !req->newptr) return (error); if (enable) { if (ktr_alq_enabled) return (0); error = alq_open(&ktr_alq, (const char *)ktr_alq_file, req->td->td_ucred, ALQ_DEFAULT_CMODE, sizeof(struct ktr_entry), ktr_alq_depth); if (error == 0) { ktr_alq_cnt = 0; ktr_alq_failed = 0; ktr_alq_enabled = 1; } } else { if (ktr_alq_enabled == 0) return (0); ktr_alq_enabled = 0; alq_close(ktr_alq); ktr_alq = NULL; } return (error); } SYSCTL_PROC(_debug_ktr, OID_AUTO, alq_enable, CTLTYPE_INT|CTLFLAG_RW, 0, 0, sysctl_debug_ktr_alq_enable, "I", "Enable KTR logging"); #endif void -ktr_tracepoint(u_int mask, const char *file, int line, const char *format, +ktr_tracepoint(uint64_t mask, const char *file, int line, const char *format, u_long arg1, u_long arg2, u_long arg3, u_long arg4, u_long arg5, u_long arg6) { struct ktr_entry *entry; #ifdef KTR_ALQ struct ale *ale = NULL; #endif int newindex, saveindex; #if defined(KTR_VERBOSE) || defined(KTR_ALQ) struct thread *td; #endif int cpu; if (panicstr || kdb_active) return; if ((ktr_mask & mask) == 0 || ktr_buf == NULL) return; cpu = KTR_CPU; if (!CPU_ISSET(cpu, &ktr_cpumask)) return; #if defined(KTR_VERBOSE) || defined(KTR_ALQ) td = curthread; if (td->td_pflags & TDP_INKTR) return; td->td_pflags |= TDP_INKTR; #endif #ifdef KTR_ALQ if (ktr_alq_enabled) { if (td->td_critnest == 0 && (td->td_flags & TDF_IDLETD) == 0 && td != ald_thread) { if (ktr_alq_max && ktr_alq_cnt > ktr_alq_max) goto done; if ((ale = alq_get(ktr_alq, ALQ_NOWAIT)) == NULL) { ktr_alq_failed++; goto done; } ktr_alq_cnt++; entry = (struct ktr_entry *)ale->ae_data; } else { goto done; } } else #endif { do { saveindex = ktr_idx; newindex = (saveindex + 1) % ktr_entries; } while (atomic_cmpset_rel_int(&ktr_idx, saveindex, newindex) == 0); entry = &ktr_buf[saveindex]; } entry->ktr_timestamp = KTR_TIME; entry->ktr_cpu = cpu; entry->ktr_thread = curthread; if (file != NULL) while (strncmp(file, "../", 3) == 0) file += 3; entry->ktr_file = file; entry->ktr_line = line; #ifdef KTR_VERBOSE if (ktr_verbose) { #ifdef SMP printf("cpu%d ", cpu); #endif if (ktr_verbose > 1) { printf("%s.%d\t", entry->ktr_file, entry->ktr_line); } printf(format, arg1, arg2, arg3, arg4, arg5, arg6); printf("\n"); } #endif entry->ktr_desc = format; entry->ktr_parms[0] = arg1; entry->ktr_parms[1] = arg2; entry->ktr_parms[2] = arg3; entry->ktr_parms[3] = arg4; entry->ktr_parms[4] = arg5; entry->ktr_parms[5] = arg6; #ifdef KTR_ALQ if (ktr_alq_enabled && ale) alq_post(ktr_alq, ale); done: #endif #if defined(KTR_VERBOSE) || defined(KTR_ALQ) td->td_pflags &= ~TDP_INKTR; #endif } #ifdef DDB struct tstate { int cur; int first; }; static struct tstate tstate; static int db_ktr_verbose; static int db_mach_vtrace(void); DB_SHOW_COMMAND(ktr, db_ktr_all) { tstate.cur = (ktr_idx - 1) % ktr_entries; tstate.first = -1; db_ktr_verbose = 0; db_ktr_verbose |= (strchr(modif, 'v') != NULL) ? 2 : 0; db_ktr_verbose |= (strchr(modif, 'V') != NULL) ? 1 : 0; /* just timestap please */ if (strchr(modif, 'a') != NULL) { db_disable_pager(); while (cncheckc() != -1) if (db_mach_vtrace() == 0) break; } else { while (!db_pager_quit) if (db_mach_vtrace() == 0) break; } } static int db_mach_vtrace(void) { struct ktr_entry *kp; if (tstate.cur == tstate.first || ktr_buf == NULL) { db_printf("--- End of trace buffer ---\n"); return (0); } kp = &ktr_buf[tstate.cur]; /* Skip over unused entries. */ if (kp->ktr_desc == NULL) { db_printf("--- End of trace buffer ---\n"); return (0); } db_printf("%d (%p", tstate.cur, kp->ktr_thread); #ifdef SMP db_printf(":cpu%d", kp->ktr_cpu); #endif db_printf(")"); if (db_ktr_verbose >= 1) { db_printf(" %10.10lld", (long long)kp->ktr_timestamp); } if (db_ktr_verbose >= 2) { db_printf(" %s.%d", kp->ktr_file, kp->ktr_line); } db_printf(": "); db_printf(kp->ktr_desc, kp->ktr_parms[0], kp->ktr_parms[1], kp->ktr_parms[2], kp->ktr_parms[3], kp->ktr_parms[4], kp->ktr_parms[5]); db_printf("\n"); if (tstate.first == -1) tstate.first = tstate.cur; if (--tstate.cur < 0) tstate.cur = ktr_entries - 1; return (1); } #endif /* DDB */ Index: head/sys/sys/ktr.h =================================================================== --- head/sys/sys/ktr.h (revision 283282) +++ head/sys/sys/ktr.h (revision 283283) @@ -1,267 +1,267 @@ /*- * Copyright (c) 1996 Berkeley Software Design, Inc. All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * 3. Berkeley Software Design Inc's name may not be used to endorse or * promote products derived from this software without specific prior * written permission. * * THIS SOFTWARE IS PROVIDED BY BERKELEY SOFTWARE DESIGN INC ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL BERKELEY SOFTWARE DESIGN INC BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. * * from BSDI $Id: ktr.h,v 1.10.2.7 2000/03/16 21:44:42 cp Exp $ * $FreeBSD$ */ /* * Wraparound kernel trace buffer support. */ #ifndef _SYS_KTR_H_ #define _SYS_KTR_H_ #include /* * Version number for ktr_entry struct. Increment this when you break binary * compatibility. */ #define KTR_VERSION 2 #define KTR_PARMS 6 #ifndef LOCORE #include #include struct ktr_entry { u_int64_t ktr_timestamp; int ktr_cpu; int ktr_line; const char *ktr_file; const char *ktr_desc; struct thread *ktr_thread; u_long ktr_parms[KTR_PARMS]; }; extern cpuset_t ktr_cpumask; -extern int ktr_mask; +extern uint64_t ktr_mask; extern int ktr_entries; extern int ktr_verbose; extern volatile int ktr_idx; extern struct ktr_entry *ktr_buf; #ifdef KTR -void ktr_tracepoint(u_int mask, const char *file, int line, +void ktr_tracepoint(uint64_t mask, const char *file, int line, const char *format, u_long arg1, u_long arg2, u_long arg3, u_long arg4, u_long arg5, u_long arg6); #define CTR6(m, format, p1, p2, p3, p4, p5, p6) do { \ if (KTR_COMPILE & (m)) \ ktr_tracepoint((m), __FILE__, __LINE__, format, \ (u_long)(p1), (u_long)(p2), (u_long)(p3), \ (u_long)(p4), (u_long)(p5), (u_long)(p6)); \ } while(0) #define CTR0(m, format) CTR6(m, format, 0, 0, 0, 0, 0, 0) #define CTR1(m, format, p1) CTR6(m, format, p1, 0, 0, 0, 0, 0) #define CTR2(m, format, p1, p2) CTR6(m, format, p1, p2, 0, 0, 0, 0) #define CTR3(m, format, p1, p2, p3) CTR6(m, format, p1, p2, p3, 0, 0, 0) #define CTR4(m, format, p1, p2, p3, p4) CTR6(m, format, p1, p2, p3, p4, 0, 0) #define CTR5(m, format, p1, p2, p3, p4, p5) CTR6(m, format, p1, p2, p3, p4, p5, 0) #else /* KTR */ #define CTR0(m, d) (void)0 #define CTR1(m, d, p1) (void)0 #define CTR2(m, d, p1, p2) (void)0 #define CTR3(m, d, p1, p2, p3) (void)0 #define CTR4(m, d, p1, p2, p3, p4) (void)0 #define CTR5(m, d, p1, p2, p3, p4, p5) (void)0 #define CTR6(m, d, p1, p2, p3, p4, p5, p6) (void)0 #endif /* KTR */ #define TR0(d) CTR0(KTR_GEN, d) #define TR1(d, p1) CTR1(KTR_GEN, d, p1) #define TR2(d, p1, p2) CTR2(KTR_GEN, d, p1, p2) #define TR3(d, p1, p2, p3) CTR3(KTR_GEN, d, p1, p2, p3) #define TR4(d, p1, p2, p3, p4) CTR4(KTR_GEN, d, p1, p2, p3, p4) #define TR5(d, p1, p2, p3, p4, p5) CTR5(KTR_GEN, d, p1, p2, p3, p4, p5) #define TR6(d, p1, p2, p3, p4, p5, p6) CTR6(KTR_GEN, d, p1, p2, p3, p4, p5, p6) /* * The event macros implement KTR graphic plotting facilities provided * by src/tools/sched/schedgraph.py. Three generic types of events are * supported: states, counters, and points. * * m is the ktr class for ktr_mask. * ident is the string identifier that owns the event (ie: "thread 10001") * etype is the type of event to plot (state, counter, point) * edat is the event specific data (state name, counter value, point name) * up to four attributes may be supplied as a name, value pair of arguments. * * etype and attribute names must be string constants. This minimizes the * number of ktr slots required by construction the final format strings * at compile time. Both must also include a colon and format specifier * (ie. "prio:%d", prio). It is recommended that string arguments be * contained within escaped quotes if they may contain ',' or ':' characters. * * The special attribute (KTR_ATTR_LINKED, ident) creates a reference to another * id on the graph for easy traversal of related graph elements. */ #define KTR_ATTR_LINKED "linkedto:\"%s\"" #define KTR_EFMT(egroup, ident, etype) \ "KTRGRAPH group:\"" egroup "\", id:\"%s\", " etype ", attributes: " #define KTR_EVENT0(m, egroup, ident, etype, edat) \ CTR2(m, KTR_EFMT(egroup, ident, etype) "none", ident, edat) #define KTR_EVENT1(m, egroup, ident, etype, edat, a0, v0) \ CTR3(m, KTR_EFMT(egroup, ident, etype) a0, ident, edat, (v0)) #define KTR_EVENT2(m, egroup, ident, etype, edat, a0, v0, a1, v1) \ CTR4(m, KTR_EFMT(egroup, ident, etype) a0 ", " a1, \ ident, edat, (v0), (v1)) #define KTR_EVENT3(m, egroup, ident, etype, edat, a0, v0, a1, v1, a2, v2)\ CTR5(m,KTR_EFMT(egroup, ident, etype) a0 ", " a1 ", " a2, \ ident, edat, (v0), (v1), (v2)) #define KTR_EVENT4(m, egroup, ident, etype, edat, \ a0, v0, a1, v1, a2, v2, a3, v3) \ CTR6(m,KTR_EFMT(egroup, ident, etype) a0 ", " a1 ", " a2 ", " a3,\ ident, edat, (v0), (v1), (v2), (v3)) /* * State functions graph state changes on an ident. */ #define KTR_STATE0(m, egroup, ident, state) \ KTR_EVENT0(m, egroup, ident, "state:\"%s\"", state) #define KTR_STATE1(m, egroup, ident, state, a0, v0) \ KTR_EVENT1(m, egroup, ident, "state:\"%s\"", state, a0, (v0)) #define KTR_STATE2(m, egroup, ident, state, a0, v0, a1, v1) \ KTR_EVENT2(m, egroup, ident, "state:\"%s\"", state, a0, (v0), a1, (v1)) #define KTR_STATE3(m, egroup, ident, state, a0, v0, a1, v1, a2, v2) \ KTR_EVENT3(m, egroup, ident, "state:\"%s\"", \ state, a0, (v0), a1, (v1), a2, (v2)) #define KTR_STATE4(m, egroup, ident, state, a0, v0, a1, v1, a2, v2, a3, v3)\ KTR_EVENT4(m, egroup, ident, "state:\"%s\"", \ state, a0, (v0), a1, (v1), a2, (v2), a3, (v3)) /* * Counter functions graph counter values. The counter id * must not be intermixed with a state id. */ #define KTR_COUNTER0(m, egroup, ident, counter) \ KTR_EVENT0(m, egroup, ident, "counter:%d", counter) #define KTR_COUNTER1(m, egroup, ident, edat, a0, v0) \ KTR_EVENT1(m, egroup, ident, "counter:%d", counter, a0, (v0)) #define KTR_COUNTER2(m, egroup, ident, counter, a0, v0, a1, v1) \ KTR_EVENT2(m, egroup, ident, "counter:%d", counter, a0, (v0), a1, (v1)) #define KTR_COUNTER3(m, egroup, ident, counter, a0, v0, a1, v1, a2, v2) \ KTR_EVENT3(m, egroup, ident, "counter:%d", \ counter, a0, (v0), a1, (v1), a2, (v2)) #define KTR_COUNTER4(m, egroup, ident, counter, a0, v0, a1, v1, a2, v2, a3, v3)\ KTR_EVENT4(m, egroup, ident, "counter:%d", \ counter, a0, (v0), a1, (v1), a2, (v2), a3, (v3)) /* * Point functions plot points of interest on counter or state graphs. */ #define KTR_POINT0(m, egroup, ident, point) \ KTR_EVENT0(m, egroup, ident, "point:\"%s\"", point) #define KTR_POINT1(m, egroup, ident, point, a0, v0) \ KTR_EVENT1(m, egroup, ident, "point:\"%s\"", point, a0, (v0)) #define KTR_POINT2(m, egroup, ident, point, a0, v0, a1, v1) \ KTR_EVENT2(m, egroup, ident, "point:\"%s\"", point, a0, (v0), a1, (v1)) #define KTR_POINT3(m, egroup, ident, point, a0, v0, a1, v1, a2, v2) \ KTR_EVENT3(m, egroup, ident, "point:\"%s\"", point, \ a0, (v0), a1, (v1), a2, (v2)) #define KTR_POINT4(m, egroup, ident, point, a0, v0, a1, v1, a2, v2, a3, v3)\ KTR_EVENT4(m, egroup, ident, "point:\"%s\"", \ point, a0, (v0), a1, (v1), a2, (v2), a3, (v3)) /* * Start functions denote the start of a region of code or operation * and should be paired with stop functions for timing of nested * sequences. * * Specifying extra attributes with the name "key" will result in * multi-part keys. For example a block device and offset pair * might be used to describe a buf undergoing I/O. */ #define KTR_START0(m, egroup, ident, key) \ KTR_EVENT0(m, egroup, ident, "start:0x%jX", (uintmax_t)key) #define KTR_START1(m, egroup, ident, key, a0, v0) \ KTR_EVENT1(m, egroup, ident, "start:0x%jX", (uintmax_t)key, a0, (v0)) #define KTR_START2(m, egroup, ident, key, a0, v0, a1, v1) \ KTR_EVENT2(m, egroup, ident, "start:0x%jX", (uintmax_t)key, \ a0, (v0), a1, (v1)) #define KTR_START3(m, egroup, ident, key, a0, v0, a1, v1, a2, v2)\ KTR_EVENT3(m, egroup, ident, "start:0x%jX", (uintmax_t)key, \ a0, (v0), a1, (v1), a2, (v2)) #define KTR_START4(m, egroup, ident, key, \ a0, v0, a1, v1, a2, v2, a3, v3) \ KTR_EVENT4(m, egroup, ident, "start:0x%jX", (uintmax_t)key, \ a0, (v0), a1, (v1), a2, (v2), a3, (v3)) /* * Stop functions denote the end of a region of code or operation * and should be paired with start functions for timing of nested * sequences. */ #define KTR_STOP0(m, egroup, ident, key) \ KTR_EVENT0(m, egroup, ident, "stop:0x%jX", (uintmax_t)key) #define KTR_STOP1(m, egroup, ident, key, a0, v0) \ KTR_EVENT1(m, egroup, ident, "stop:0x%jX", (uintmax_t)key, a0, (v0)) #define KTR_STOP2(m, egroup, ident, key, a0, v0, a1, v1) \ KTR_EVENT2(m, egroup, ident, "stop:0x%jX", (uintmax_t)key, \ a0, (v0), a1, (v1)) #define KTR_STOP3(m, egroup, ident, key, a0, v0, a1, v1, a2, v2)\ KTR_EVENT3(m, egroup, ident, "stop:0x%jX", (uintmax_t)key, \ a0, (v0), a1, (v1), a2, (v2)) #define KTR_STOP4(m, egroup, ident, \ key, a0, v0, a1, v1, a2, v2, a3, v3) \ KTR_EVENT4(m, egroup, ident, "stop:0x%jX", (uintmax_t)key, \ a0, (v0), a1, (v1), a2, (v2), a3, (v3)) /* * Trace initialization events, similar to CTR with KTR_INIT, but * completely ifdef'ed out if KTR_INIT isn't in KTR_COMPILE (to * save string space, the compiler doesn't optimize out strings * for the conditional ones above). */ #if (KTR_COMPILE & KTR_INIT) != 0 #define ITR0(d) CTR0(KTR_INIT, d) #define ITR1(d, p1) CTR1(KTR_INIT, d, p1) #define ITR2(d, p1, p2) CTR2(KTR_INIT, d, p1, p2) #define ITR3(d, p1, p2, p3) CTR3(KTR_INIT, d, p1, p2, p3) #define ITR4(d, p1, p2, p3, p4) CTR4(KTR_INIT, d, p1, p2, p3, p4) #define ITR5(d, p1, p2, p3, p4, p5) CTR5(KTR_INIT, d, p1, p2, p3, p4, p5) #define ITR6(d, p1, p2, p3, p4, p5, p6) CTR6(KTR_INIT, d, p1, p2, p3, p4, p5, p6) #else #define ITR0(d) #define ITR1(d, p1) #define ITR2(d, p1, p2) #define ITR3(d, p1, p2, p3) #define ITR4(d, p1, p2, p3, p4) #define ITR5(d, p1, p2, p3, p4, p5) #define ITR6(d, p1, p2, p3, p4, p5, p6) #endif #endif /* !LOCORE */ #endif /* !_SYS_KTR_H_ */