kern_ktr.c revision 243046
1119936Sjhb/*- 2119936Sjhb * Copyright (c) 2000 John Baldwin <jhb@FreeBSD.org> 3119936Sjhb * All rights reserved. 465556Sjasone * 565556Sjasone * Redistribution and use in source and binary forms, with or without 665556Sjasone * modification, are permitted provided that the following conditions 765556Sjasone * are met: 865556Sjasone * 1. Redistributions of source code must retain the above copyright 965556Sjasone * notice, this list of conditions and the following disclaimer. 1065556Sjasone * 2. Redistributions in binary form must reproduce the above copyright 1165556Sjasone * notice, this list of conditions and the following disclaimer in the 1265556Sjasone * documentation and/or other materials provided with the distribution. 13119936Sjhb * 3. Neither the name of the author nor the names of any co-contributors 1465556Sjasone * may be used to endorse or promote products derived from this software 1565556Sjasone * without specific prior written permission. 1665556Sjasone * 17119936Sjhb * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND 1865556Sjasone * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 1965556Sjasone * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 20119936Sjhb * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE 21119936Sjhb * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 22119936Sjhb * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 23119936Sjhb * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 24119936Sjhb * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 25119936Sjhb * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 26119936Sjhb * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 27119936Sjhb * SUCH DAMAGE. 2865556Sjasone */ 2965556Sjasone 3065556Sjasone/* 3168420Sjhb * This module holds the global variables used by KTR and the ktr_tracepoint() 3268420Sjhb * function that does the actual tracing. 3365556Sjasone */ 3465556Sjasone 35116182Sobrien#include <sys/cdefs.h> 36116182Sobrien__FBSDID("$FreeBSD: head/sys/kern/kern_ktr.c 243046 2012-11-15 00:51:57Z jeff $"); 37116182Sobrien 3870035Sjhb#include "opt_ddb.h" 3968420Sjhb#include "opt_ktr.h" 40103787Sjeff#include "opt_alq.h" 4168420Sjhb 4270035Sjhb#include <sys/param.h> 43222813Sattilio#include <sys/queue.h> 44103787Sjeff#include <sys/alq.h> 4570035Sjhb#include <sys/cons.h> 46222813Sattilio#include <sys/cpuset.h> 4770705Sjhb#include <sys/kernel.h> 4865556Sjasone#include <sys/ktr.h> 4968420Sjhb#include <sys/libkern.h> 50243046Sjeff#include <sys/lock.h> 51243046Sjeff#include <sys/malloc.h> 52243046Sjeff#include <sys/mutex.h> 5387793Sjhb#include <sys/proc.h> 54243046Sjeff#include <sys/smp.h> 5565556Sjasone#include <sys/sysctl.h> 5668420Sjhb#include <sys/systm.h> 5778784Sjhb#include <sys/time.h> 5865556Sjasone 5993503Sjake#include <machine/cpu.h> 6093950Sjake#ifdef __sparc64__ 6193950Sjake#include <machine/ktr.h> 6293950Sjake#endif 6393503Sjake 64160312Sjhb#ifdef DDB 6570035Sjhb#include <ddb/ddb.h> 66160312Sjhb#include <ddb/db_output.h> 67160312Sjhb#endif 6870035Sjhb 6978784Sjhb#ifndef KTR_ENTRIES 7078784Sjhb#define KTR_ENTRIES 1024 7178784Sjhb#endif 7278784Sjhb 73243046Sjeff/* Limit the allocations to something manageable. */ 74243046Sjeff#define KTR_ENTRIES_MAX (8 * 1024 * 1024) 75243046Sjeff 7668420Sjhb#ifndef KTR_MASK 77210337Sattilio#define KTR_MASK (0) 7868420Sjhb#endif 7968420Sjhb 80239923Sattilio#ifndef KTR_CPUMASK 81239923Sattilio#define KTR_CPUMASK CPUSET_FSET 82239923Sattilio#endif 83239923Sattilio 8493503Sjake#ifndef KTR_TIME 8593503Sjake#define KTR_TIME get_cyclecount() 8668420Sjhb#endif 8768420Sjhb 8893503Sjake#ifndef KTR_CPU 8993503Sjake#define KTR_CPU PCPU_GET(cpuid) 9070705Sjhb#endif 9170705Sjhb 92243046Sjeffstatic MALLOC_DEFINE(M_KTR, "KTR", "KTR"); 93243046Sjeff 94219028SnetchildFEATURE(ktr, "Kernel support for KTR kernel tracing facility"); 95219028Snetchild 96243046Sjeffvolatile int ktr_idx = 0; 97243046Sjeffint ktr_mask = KTR_MASK; 98243046Sjeffint ktr_compile = KTR_COMPILE; 99243046Sjeffint ktr_entries = KTR_ENTRIES; 100243046Sjeffint ktr_version = KTR_VERSION; 101243046Sjeffstruct ktr_entry ktr_buf_init[KTR_ENTRIES]; 102243046Sjeffstruct ktr_entry *ktr_buf = ktr_buf_init; 103243046Sjeffcpuset_t ktr_cpumask = CPUSET_T_INITIALIZER(KTR_CPUMASK); 104243046Sjeffstatic char ktr_cpumask_str[CPUSETBUFSIZ]; 10570705Sjhb 10677900SpeterTUNABLE_INT("debug.ktr.mask", &ktr_mask); 10765556Sjasone 108243046SjeffTUNABLE_STR("debug.ktr.cpumask", ktr_cpumask_str, sizeof(ktr_cpumask_str)); 109132583Srwatson 110243046Sjeffstatic SYSCTL_NODE(_debug, OID_AUTO, ktr, CTLFLAG_RD, 0, "KTR options"); 11165556Sjasone 112205017SjhbSYSCTL_INT(_debug_ktr, OID_AUTO, version, CTLFLAG_RD, 113205017Sjhb &ktr_version, 0, "Version of the KTR interface"); 11493503Sjake 115243046SjeffSYSCTL_INT(_debug_ktr, OID_AUTO, compile, CTLFLAG_RD, 116243046Sjeff &ktr_compile, 0, "Bitmask of KTR event classes compiled into the kernel"); 117222813Sattilio 118222813Sattiliostatic void 119222813Sattilioktr_cpumask_initializer(void *dummy __unused) 120222813Sattilio{ 121222813Sattilio 122222813Sattilio /* 123222813Sattilio * TUNABLE_STR() runs with SI_ORDER_MIDDLE priority, thus it must be 124222813Sattilio * already set, if necessary. 125222813Sattilio */ 126222813Sattilio if (ktr_cpumask_str[0] != '\0' && 127222813Sattilio cpusetobj_strscan(&ktr_cpumask, ktr_cpumask_str) == -1) 128222813Sattilio CPU_FILL(&ktr_cpumask); 129222813Sattilio} 130222813SattilioSYSINIT(ktr_cpumask_initializer, SI_SUB_TUNABLES, SI_ORDER_ANY, 131222813Sattilio ktr_cpumask_initializer, NULL); 132222813Sattilio 133222813Sattiliostatic int 134222813Sattiliosysctl_debug_ktr_cpumask(SYSCTL_HANDLER_ARGS) 135222813Sattilio{ 136222813Sattilio char lktr_cpumask_str[CPUSETBUFSIZ]; 137222813Sattilio cpuset_t imask; 138222813Sattilio int error; 139222813Sattilio 140222813Sattilio cpusetobj_strprint(lktr_cpumask_str, &ktr_cpumask); 141222813Sattilio error = sysctl_handle_string(oidp, lktr_cpumask_str, 142222813Sattilio sizeof(lktr_cpumask_str), req); 143222813Sattilio if (error != 0 || req->newptr == NULL) 144222813Sattilio return (error); 145222813Sattilio if (cpusetobj_strscan(&imask, lktr_cpumask_str) == -1) 146222813Sattilio return (EINVAL); 147222813Sattilio CPU_COPY(&imask, &ktr_cpumask); 148222813Sattilio 149222813Sattilio return (error); 150222813Sattilio} 151222813SattilioSYSCTL_PROC(_debug_ktr, OID_AUTO, cpumask, 152222813Sattilio CTLFLAG_RW | CTLFLAG_MPSAFE | CTLTYPE_STRING, NULL, 0, 153222813Sattilio sysctl_debug_ktr_cpumask, "S", 154222813Sattilio "Bitmask of CPUs on which KTR logging is enabled"); 155222813Sattilio 156154933Sjhbstatic int 157154933Sjhbsysctl_debug_ktr_clear(SYSCTL_HANDLER_ARGS) 158154933Sjhb{ 159154933Sjhb int clear, error; 160154933Sjhb 161154933Sjhb clear = 0; 162154933Sjhb error = sysctl_handle_int(oidp, &clear, 0, req); 163154933Sjhb if (error || !req->newptr) 164154933Sjhb return (error); 165154933Sjhb 166154933Sjhb if (clear) { 167243046Sjeff bzero(ktr_buf, sizeof(*ktr_buf) * ktr_entries); 168154933Sjhb ktr_idx = 0; 169154933Sjhb } 170154933Sjhb 171154933Sjhb return (error); 172154933Sjhb} 173154933SjhbSYSCTL_PROC(_debug_ktr, OID_AUTO, clear, CTLTYPE_INT|CTLFLAG_RW, 0, 0, 174154933Sjhb sysctl_debug_ktr_clear, "I", "Clear KTR Buffer"); 175154933Sjhb 176243046Sjeff/* 177243046Sjeff * This is a sysctl proc so that it is serialized as !MPSAFE along with 178243046Sjeff * the other ktr sysctl procs. 179243046Sjeff */ 180243046Sjeffstatic int 181243046Sjeffsysctl_debug_ktr_mask(SYSCTL_HANDLER_ARGS) 182243046Sjeff{ 183243046Sjeff int mask, error; 184243046Sjeff 185243046Sjeff mask = ktr_mask; 186243046Sjeff error = sysctl_handle_int(oidp, &mask, 0, req); 187243046Sjeff if (error || !req->newptr) 188243046Sjeff return (error); 189243046Sjeff ktr_mask = mask; 190243046Sjeff return (error); 191243046Sjeff} 192243046Sjeff 193243046SjeffSYSCTL_PROC(_debug_ktr, OID_AUTO, mask, CTLTYPE_INT|CTLFLAG_RW, 0, 0, 194243046Sjeff sysctl_debug_ktr_mask, "I", 195243046Sjeff "Bitmask of KTR event classes for which logging is enabled"); 196243046Sjeff 197243046Sjeffstatic int 198243046Sjeffsysctl_debug_ktr_entries(SYSCTL_HANDLER_ARGS) 199243046Sjeff{ 200243046Sjeff int entries, error, mask; 201243046Sjeff struct ktr_entry *buf, *oldbuf; 202243046Sjeff 203243046Sjeff entries = ktr_entries; 204243046Sjeff error = sysctl_handle_int(oidp, &entries, 0, req); 205243046Sjeff if (error || !req->newptr) 206243046Sjeff return (error); 207243046Sjeff if (entries > KTR_ENTRIES_MAX) 208243046Sjeff return (ERANGE); 209243046Sjeff /* Disable ktr temporarily. */ 210243046Sjeff mask = ktr_mask; 211243046Sjeff atomic_store_rel_int(&ktr_mask, 0); 212243046Sjeff /* Wait for threads to go idle. */ 213243046Sjeff if ((error = quiesce_all_cpus("ktrent", PCATCH)) != 0) { 214243046Sjeff ktr_mask = mask; 215243046Sjeff return (error); 216243046Sjeff } 217243046Sjeff if (ktr_buf != ktr_buf_init) 218243046Sjeff oldbuf = ktr_buf; 219243046Sjeff else 220243046Sjeff oldbuf = NULL; 221243046Sjeff /* Allocate a new buffer. */ 222243046Sjeff buf = malloc(sizeof(*buf) * entries, M_KTR, M_WAITOK | M_ZERO); 223243046Sjeff /* Install the new buffer and restart ktr. */ 224243046Sjeff ktr_buf = buf; 225243046Sjeff ktr_entries = entries; 226243046Sjeff ktr_idx = 0; 227243046Sjeff atomic_store_rel_int(&ktr_mask, mask); 228243046Sjeff if (oldbuf != NULL) 229243046Sjeff free(oldbuf, M_KTR); 230243046Sjeff 231243046Sjeff return (error); 232243046Sjeff} 233243046Sjeff 234243046SjeffSYSCTL_PROC(_debug_ktr, OID_AUTO, entries, CTLTYPE_INT|CTLFLAG_RW, 0, 0, 235243046Sjeff sysctl_debug_ktr_entries, "I", "Number of entries in the KTR buffer"); 236243046Sjeff 23793503Sjake#ifdef KTR_VERBOSE 23893503Sjakeint ktr_verbose = KTR_VERBOSE; 23977900SpeterTUNABLE_INT("debug.ktr.verbose", &ktr_verbose); 24070705SjhbSYSCTL_INT(_debug_ktr, OID_AUTO, verbose, CTLFLAG_RW, &ktr_verbose, 0, ""); 24193503Sjake#endif 24268420Sjhb 243103787Sjeff#ifdef KTR_ALQ 244103787Sjeffstruct alq *ktr_alq; 245103787Sjeffchar ktr_alq_file[MAXPATHLEN] = "/tmp/ktr.out"; 246103787Sjeffint ktr_alq_cnt = 0; 247103787Sjeffint ktr_alq_depth = KTR_ENTRIES; 248103787Sjeffint ktr_alq_enabled = 0; 249103787Sjeffint ktr_alq_failed = 0; 250103787Sjeffint ktr_alq_max = 0; 251103787Sjeff 252103787SjeffSYSCTL_INT(_debug_ktr, OID_AUTO, alq_max, CTLFLAG_RW, &ktr_alq_max, 0, 253103787Sjeff "Maximum number of entries to write"); 254103787SjeffSYSCTL_INT(_debug_ktr, OID_AUTO, alq_cnt, CTLFLAG_RD, &ktr_alq_cnt, 0, 255103787Sjeff "Current number of written entries"); 256103787SjeffSYSCTL_INT(_debug_ktr, OID_AUTO, alq_failed, CTLFLAG_RD, &ktr_alq_failed, 0, 257103787Sjeff "Number of times we overran the buffer"); 258103787SjeffSYSCTL_INT(_debug_ktr, OID_AUTO, alq_depth, CTLFLAG_RW, &ktr_alq_depth, 0, 259103787Sjeff "Number of items in the write buffer"); 260103787SjeffSYSCTL_STRING(_debug_ktr, OID_AUTO, alq_file, CTLFLAG_RW, ktr_alq_file, 261103787Sjeff sizeof(ktr_alq_file), "KTR logging file"); 262103787Sjeff 263103787Sjeffstatic int 264103787Sjeffsysctl_debug_ktr_alq_enable(SYSCTL_HANDLER_ARGS) 265103787Sjeff{ 266103787Sjeff int error; 267103787Sjeff int enable; 268103787Sjeff 269103787Sjeff enable = ktr_alq_enabled; 270103787Sjeff 271154940Sjhb error = sysctl_handle_int(oidp, &enable, 0, req); 272154940Sjhb if (error || !req->newptr) 273154940Sjhb return (error); 274103787Sjeff 275103787Sjeff if (enable) { 276103787Sjeff if (ktr_alq_enabled) 277103787Sjeff return (0); 278116697Srwatson error = alq_open(&ktr_alq, (const char *)ktr_alq_file, 279145142Srwatson req->td->td_ucred, ALQ_DEFAULT_CMODE, 280145142Srwatson sizeof(struct ktr_entry), ktr_alq_depth); 281103787Sjeff if (error == 0) { 282103787Sjeff ktr_alq_cnt = 0; 283103787Sjeff ktr_alq_failed = 0; 284103787Sjeff ktr_alq_enabled = 1; 285103787Sjeff } 286103787Sjeff } else { 287103787Sjeff if (ktr_alq_enabled == 0) 288103787Sjeff return (0); 289103787Sjeff ktr_alq_enabled = 0; 290103787Sjeff alq_close(ktr_alq); 291103787Sjeff ktr_alq = NULL; 292103787Sjeff } 293103787Sjeff 294103787Sjeff return (error); 295103787Sjeff} 296103787SjeffSYSCTL_PROC(_debug_ktr, OID_AUTO, alq_enable, 297103787Sjeff CTLTYPE_INT|CTLFLAG_RW, 0, 0, sysctl_debug_ktr_alq_enable, 298103787Sjeff "I", "Enable KTR logging"); 299103787Sjeff#endif 300103787Sjeff 30168420Sjhbvoid 30293503Sjakektr_tracepoint(u_int mask, const char *file, int line, const char *format, 30393503Sjake u_long arg1, u_long arg2, u_long arg3, u_long arg4, u_long arg5, 30493503Sjake u_long arg6) 30568420Sjhb{ 30668420Sjhb struct ktr_entry *entry; 307103787Sjeff#ifdef KTR_ALQ 308103787Sjeff struct ale *ale = NULL; 309206632Sjulian#endif 31074903Sjhb int newindex, saveindex; 311103787Sjeff#if defined(KTR_VERBOSE) || defined(KTR_ALQ) 31287793Sjhb struct thread *td; 31393503Sjake#endif 31491904Sjhb int cpu; 31568420Sjhb 31669880Sjhb if (panicstr) 31769880Sjhb return; 318243046Sjeff if ((ktr_mask & mask) == 0 || ktr_buf == NULL) 31968420Sjhb return; 32093503Sjake cpu = KTR_CPU; 321222813Sattilio if (!CPU_ISSET(cpu, &ktr_cpumask)) 32293503Sjake return; 323103787Sjeff#if defined(KTR_VERBOSE) || defined(KTR_ALQ) 32487793Sjhb td = curthread; 325116101Sjhb if (td->td_pflags & TDP_INKTR) 32687793Sjhb return; 327116101Sjhb td->td_pflags |= TDP_INKTR; 32893503Sjake#endif 329103787Sjeff#ifdef KTR_ALQ 330206632Sjulian if (ktr_alq_enabled) { 331206632Sjulian if (td->td_critnest == 0 && 332206632Sjulian (td->td_flags & TDF_IDLETD) == 0 && 333206632Sjulian td != ald_thread) { 334206632Sjulian if (ktr_alq_max && ktr_alq_cnt > ktr_alq_max) 335206632Sjulian goto done; 336206632Sjulian if ((ale = alq_get(ktr_alq, ALQ_NOWAIT)) == NULL) { 337206632Sjulian ktr_alq_failed++; 338206632Sjulian goto done; 339206632Sjulian } 340206632Sjulian ktr_alq_cnt++; 341206632Sjulian entry = (struct ktr_entry *)ale->ae_data; 342206632Sjulian } else { 343103787Sjeff goto done; 344103787Sjeff } 345103787Sjeff } else 346103787Sjeff#endif 347206632Sjulian { 348206632Sjulian do { 349206632Sjulian saveindex = ktr_idx; 350243046Sjeff newindex = (saveindex + 1) % ktr_entries; 351206632Sjulian } while (atomic_cmpset_rel_int(&ktr_idx, saveindex, newindex) == 0); 352206632Sjulian entry = &ktr_buf[saveindex]; 353206632Sjulian } 35493503Sjake entry->ktr_timestamp = KTR_TIME; 35591904Sjhb entry->ktr_cpu = cpu; 356147278Sjeff entry->ktr_thread = curthread; 357112105Sjhb if (file != NULL) 358112105Sjhb while (strncmp(file, "../", 3) == 0) 359112105Sjhb file += 3; 36093503Sjake entry->ktr_file = file; 36168420Sjhb entry->ktr_line = line; 36293503Sjake#ifdef KTR_VERBOSE 36368420Sjhb if (ktr_verbose) { 36468782Sjhb#ifdef SMP 36593503Sjake printf("cpu%d ", cpu); 36668782Sjhb#endif 36793503Sjake if (ktr_verbose > 1) { 36893503Sjake printf("%s.%d\t", entry->ktr_file, 36993503Sjake entry->ktr_line); 37093503Sjake } 37193503Sjake printf(format, arg1, arg2, arg3, arg4, arg5, arg6); 37268420Sjhb printf("\n"); 37368420Sjhb } 37493503Sjake#endif 37568420Sjhb entry->ktr_desc = format; 37693503Sjake entry->ktr_parms[0] = arg1; 37793503Sjake entry->ktr_parms[1] = arg2; 37893503Sjake entry->ktr_parms[2] = arg3; 37993503Sjake entry->ktr_parms[3] = arg4; 38093503Sjake entry->ktr_parms[4] = arg5; 38193503Sjake entry->ktr_parms[5] = arg6; 382103787Sjeff#ifdef KTR_ALQ 383206632Sjulian if (ktr_alq_enabled && ale) 384103787Sjeff alq_post(ktr_alq, ale); 385103787Sjeffdone: 386103787Sjeff#endif 387103787Sjeff#if defined(KTR_VERBOSE) || defined(KTR_ALQ) 388116101Sjhb td->td_pflags &= ~TDP_INKTR; 38968420Sjhb#endif 39068420Sjhb} 39170035Sjhb 39270035Sjhb#ifdef DDB 39370035Sjhb 39470035Sjhbstruct tstate { 39570035Sjhb int cur; 39670035Sjhb int first; 39770035Sjhb}; 39870035Sjhbstatic struct tstate tstate; 39970035Sjhbstatic int db_ktr_verbose; 40070035Sjhbstatic int db_mach_vtrace(void); 40170035Sjhb 40272755SjhbDB_SHOW_COMMAND(ktr, db_ktr_all) 40370035Sjhb{ 404118269Sjhb 405243046Sjeff tstate.cur = (ktr_idx - 1) % ktr_entries; 40670035Sjhb tstate.first = -1; 407206632Sjulian db_ktr_verbose = 0; 408229272Sed db_ktr_verbose |= (strchr(modif, 'v') != NULL) ? 2 : 0; 409229272Sed db_ktr_verbose |= (strchr(modif, 'V') != NULL) ? 1 : 0; /* just timestap please */ 410229272Sed if (strchr(modif, 'a') != NULL) { 411160312Sjhb db_disable_pager(); 412118269Sjhb while (cncheckc() != -1) 413118269Sjhb if (db_mach_vtrace() == 0) 41472755Sjhb break; 415118269Sjhb } else { 416160312Sjhb while (!db_pager_quit) 417118269Sjhb if (db_mach_vtrace() == 0) 41872755Sjhb break; 419118269Sjhb } 42070035Sjhb} 42170035Sjhb 42270035Sjhbstatic int 42370035Sjhbdb_mach_vtrace(void) 42470035Sjhb{ 42570035Sjhb struct ktr_entry *kp; 42670035Sjhb 427243046Sjeff if (tstate.cur == tstate.first || ktr_buf == NULL) { 42870035Sjhb db_printf("--- End of trace buffer ---\n"); 42970035Sjhb return (0); 43070035Sjhb } 43170035Sjhb kp = &ktr_buf[tstate.cur]; 43270035Sjhb 43370035Sjhb /* Skip over unused entries. */ 43472755Sjhb if (kp->ktr_desc == NULL) { 43572755Sjhb db_printf("--- End of trace buffer ---\n"); 43672755Sjhb return (0); 43772755Sjhb } 438147278Sjeff db_printf("%d (%p", tstate.cur, kp->ktr_thread); 43970035Sjhb#ifdef SMP 440147278Sjeff db_printf(":cpu%d", kp->ktr_cpu); 44170035Sjhb#endif 442147278Sjeff db_printf(")"); 443206632Sjulian if (db_ktr_verbose >= 1) { 444206632Sjulian db_printf(" %10.10lld", (long long)kp->ktr_timestamp); 44593503Sjake } 446206632Sjulian if (db_ktr_verbose >= 2) { 447206632Sjulian db_printf(" %s.%d", kp->ktr_file, kp->ktr_line); 448206632Sjulian } 449147278Sjeff db_printf(": "); 45093503Sjake db_printf(kp->ktr_desc, kp->ktr_parms[0], kp->ktr_parms[1], 45193503Sjake kp->ktr_parms[2], kp->ktr_parms[3], kp->ktr_parms[4], 45293503Sjake kp->ktr_parms[5]); 45372755Sjhb db_printf("\n"); 45470035Sjhb 45570035Sjhb if (tstate.first == -1) 45670035Sjhb tstate.first = tstate.cur; 45770035Sjhb 45870035Sjhb if (--tstate.cur < 0) 459243046Sjeff tstate.cur = ktr_entries - 1; 46070035Sjhb 46170035Sjhb return (1); 46270035Sjhb} 46370035Sjhb 46470035Sjhb#endif /* DDB */ 465