osfmk/kern/xpr.c

   1 /*
   2  * Copyright (c) 2000-2004 Apple Computer, Inc. All rights reserved.
   3  *
   4  * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
   5  *
   6  * This file contains Original Code and/or Modifications of Original Code
   7  * as defined in and that are subject to the Apple Public Source License
   8  * Version 2.0 (the 'License'). You may not use this file except in
   9  * compliance with the License. The rights granted to you under the License
  10  * may not be used to create, or enable the creation or redistribution of,
  11  * unlawful or unlicensed copies of an Apple operating system, or to
  12  * circumvent, violate, or enable the circumvention or violation of, any
  13  * terms of an Apple operating system software license agreement.
  14  *
  15  * Please obtain a copy of the License at
  16  * http://www.opensource.apple.com/apsl/ and read it before using this file.
  17  *
  18  * The Original Code and all software distributed under the License are
  19  * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
  20  * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
  21  * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
  22  * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
  23  * Please see the License for the specific language governing rights and
  24  * limitations under the License.
  25  *
  26  * @APPLE_OSREFERENCE_LICENSE_HEADER_END@
  27  */
  28 /*
  29  * @OSF_COPYRIGHT@
  30  */
  31 /*
  32  * Mach Operating System
  33  * Copyright (c) 1991,1990,1989,1988,1987 Carnegie Mellon University
  34  * All Rights Reserved.
  35  *
  36  * Permission to use, copy, modify and distribute this software and its
  37  * documentation is hereby granted, provided that both the copyright
  38  * notice and this permission notice appear in all copies of the
  39  * software, derivative works or modified versions, and any portions
  40  * thereof, and that both notices appear in supporting documentation.
  41  *
  42  * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
  43  * CONDITION.  CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND FOR
  44  * ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
  45  *
  46  * Carnegie Mellon requests users of this software to return to
  47  *
  48  *  Software Distribution Coordinator  or  Software.Distribution@CS.CMU.EDU
  49  *  School of Computer Science
  50  *  Carnegie Mellon University
  51  *  Pittsburgh PA 15213-3890
  52  *
  53  * any improvements or extensions that they make and grant Carnegie Mellon
  54  * the rights to redistribute these changes.
  55  */
  56 #include <mach_kdb.h>
  57 /*
  58  * xpr silent tracing circular buffer.
  59  */
  60
  61 #include <mach/machine/vm_types.h>
  62 #include <kern/xpr.h>
  63 #include <kern/lock.h>
  64 #include <kern/spl.h>
  65 #include <kern/cpu_number.h>
  66 #include <kern/misc_protos.h>
  67 #include <kern/thread.h>
  68 #include <vm/vm_kern.h>
  69 #include <string.h>
  70
  71 /*
  72  *      After a spontaneous reboot, it is desirable to look
  73  *      at the old xpr buffer.  Assuming xprbootstrap allocates
  74  *      the buffer in the same place in physical memory and
  75  *      the reboot doesn't clear memory, this should work.
  76  *      xprptr will be reset, but the saved value should be OK.
  77  *      Just set xprenable false so the buffer isn't overwritten.
  78  */
  79
  80 decl_simple_lock_data(,xprlock)
  81 boolean_t xprenable = TRUE;     /* Enable xpr tracing */
  82 int nxprbufs = 0;       /* Number of contiguous xprbufs allocated */
  83 int xprflags = 0;       /* Bit mask of xpr flags enabled */
  84 struct xprbuf *xprbase; /* Pointer to circular buffer nxprbufs*sizeof(xprbuf)*/
  85 struct xprbuf *xprptr;  /* Currently allocated xprbuf */
  86 struct xprbuf *xprlast; /* Pointer to end of circular buffer */
  87
  88 void
  89 xpr(
  90         const char      *msg,
  91         long            arg1,
  92         long            arg2,
  93         long            arg3,
  94         long            arg4,
  95         long            arg5)
  96 {
  97         spl_t s;
  98         register struct xprbuf *x;
  99
 100         /* If we aren't initialized, ignore trace request */
 101         if (!xprenable || (xprptr == 0))
 102                 return;
 103         /* Guard against all interrupts and allocate next buffer. */
 104
 105         s = splhigh();
 106         simple_lock(&xprlock);
 107         x = xprptr++;
 108         if (xprptr >= xprlast) {
 109                 /* wrap around */
 110                 xprptr = xprbase;
 111         }
 112         /* Save xprptr in allocated memory. */
 113         *(struct xprbuf **)xprlast = xprptr;
 114         simple_unlock(&xprlock);
 115         x->timestamp = XPR_TIMESTAMP;
 116         splx(s);
 117         x->msg = msg;
 118         x->arg1 = arg1;
 119         x->arg2 = arg2;
 120         x->arg3 = arg3;
 121         x->arg4 = arg4;
 122         x->arg5 = arg5;
 123         mp_disable_preemption();
 124         x->cpuinfo = cpu_number();
 125         mp_enable_preemption();
 126 }
 127
 128 void
 129 xprbootstrap(void)
 130 {
 131         vm_offset_t     addr;
 132         vm_size_t       size;
 133         kern_return_t   kr;
 134
 135         simple_lock_init(&xprlock, 0);
 136         if (nxprbufs == 0)
 137                 return; /* assume XPR support not desired */
 138
 139         /* leave room at the end for a saved copy of xprptr */
 140         size = nxprbufs * sizeof(struct xprbuf) + sizeof xprptr;
 141
 142         kr = kmem_alloc_wired(kernel_map, &addr, size);
 143         if (kr != KERN_SUCCESS)
 144                 panic("xprbootstrap");
 145
 146         if (xprenable) {
 147                 /*
 148                  *      If xprenable is set (the default) then we zero
 149                  *      the buffer so xpr_dump doesn't encounter bad pointers.
 150                  *      If xprenable isn't set, then we preserve
 151                  *      the original contents of the buffer.  This is useful
 152                  *      if memory survives reboots, so xpr_dump can show
 153                  *      the previous buffer contents.
 154                  */
 155
 156                 (void) memset((void *) addr, 0, size);
 157         }
 158
 159         xprbase = (struct xprbuf *) addr;
 160         xprlast = &xprbase[nxprbufs];
 161         xprptr = xprbase;       /* setting xprptr enables tracing */
 162 }
 163
 164 int             xprinitial = 0;
 165
 166 void
 167 xprinit(void)
 168 {
 169         xprflags |= xprinitial;
 170 }
 171
 172 #if     MACH_KDB
 173 #include <ddb/db_output.h>
 174
 175 /*
 176  * Prototypes for functions called from the debugger
 177  */
 178 void
 179 xpr_dump(
 180         struct xprbuf   *base,
 181         int             nbufs);
 182
 183 void
 184 xpr_search(
 185         int     arg_index,
 186         int     value);
 187
 188 extern jmp_buf_t *db_recover;
 189
 190 /*
 191  *      Print current content of xpr buffers (KDB's sake)
 192  *      Use stack order to make it understandable.
 193  *
 194  *      Called as "!xpr_dump" this dumps the kernel's xpr buffer.
 195  *      Called with arguments, it can dump xpr buffers in user tasks,
 196  *      assuming they use the same format as the kernel.
 197  */
 198 void
 199 xpr_dump(
 200         struct xprbuf   *base,
 201         int             nbufs)
 202 {
 203         jmp_buf_t db_jmpbuf;
 204         jmp_buf_t *prev;
 205         struct xprbuf *last, *ptr;
 206         register struct xprbuf *x;
 207         int i;
 208         spl_t s;
 209
 210         if (base == 0) {
 211                 base = xprbase;
 212                 nbufs = nxprbufs;
 213         }
 214
 215         if (nbufs == 0)
 216                 return;
 217
 218         if (base == xprbase) {
 219                 s = splhigh();
 220                 simple_lock(&xprlock);
 221         }
 222
 223         last = base + nbufs;
 224         ptr = * (struct xprbuf **) last;
 225
 226         prev = db_recover;
 227         if (_setjmp(db_recover = &db_jmpbuf) == 0)
 228             for (x = ptr, i = 0; i < nbufs; i++) {
 229                 if (--x < base)
 230                         x = last - 1;
 231
 232                 if (x->msg == 0)
 233                         break;
 234
 235                 db_printf("<%d:%x:%x> ", x - base, x->cpuinfo, x->timestamp);
 236                 db_printf(x->msg, x->arg1,x->arg2,x->arg3,x->arg4,x->arg5);
 237             }
 238         db_recover = prev;
 239
 240         if (base == xprbase) {
 241                 simple_unlock(&xprlock);
 242                 splx(s);
 243         }
 244 }
 245
 246 /*
 247  * dump xpr table with a selection criteria.
 248  * argument number "arg_index" must equal "value"
 249  */
 250
 251 void
 252 xpr_search(
 253         int     arg_index,
 254         int     value)
 255 {
 256         jmp_buf_t db_jmpbuf;
 257         jmp_buf_t *prev;
 258         register struct xprbuf *x;
 259         spl_t s;
 260         int n;
 261
 262         if (!nxprbufs)
 263                 return;
 264
 265         n = nxprbufs;
 266
 267         s = splhigh();
 268         simple_lock(&xprlock);
 269
 270         prev = db_recover;
 271         if (_setjmp(db_recover = &db_jmpbuf) == 0)
 272             for (x = *(struct xprbuf **)xprlast ; n--; ) {
 273                 if (--x < xprbase)
 274                         x = xprlast - 1;
 275
 276                 if (x->msg == 0) {
 277                         break;
 278                 }
 279
 280                 if (*((&x->arg1)+arg_index) != value)
 281                         continue;
 282
 283                 db_printf("<%d:%d:%x> ", x - xprbase,
 284                           x->cpuinfo, x->timestamp);
 285                 db_printf(x->msg, x->arg1,x->arg2,x->arg3,x->arg4,x->arg5);
 286             }
 287         db_recover = prev;
 288
 289         simple_unlock(&xprlock);
 290         splx(s);
 291 }
 292 #endif  /* MACH_KDB */