![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to subr_prf.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Apple Darwin 0.x] / kernel / bsd / kern|
Return to subr_prf.c CVS log | Up to [Apple Darwin 0.x] / kernel / bsd / kern |
1.1 ! root 1: /* ! 2: * Copyright (c) 1999 Apple Computer, Inc. All rights reserved. ! 3: * ! 4: * @APPLE_LICENSE_HEADER_START@ ! 5: * ! 6: * Portions Copyright (c) 1999 Apple Computer, Inc. All Rights ! 7: * Reserved. This file contains Original Code and/or Modifications of ! 8: * Original Code as defined in and that are subject to the Apple Public ! 9: * Source License Version 1.1 (the "License"). You may not use this file ! 10: * except in compliance with the License. Please obtain a copy of the ! 11: * License at http://www.apple.com/publicsource and read it before using ! 12: * this file. ! 13: * ! 14: * The Original Code and all software distributed under the License are ! 15: * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER ! 16: * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES, ! 17: * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, ! 18: * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT. Please see the ! 19: * License for the specific language governing rights and limitations ! 20: * under the License. ! 21: * ! 22: * @APPLE_LICENSE_HEADER_END@ ! 23: */ ! 24: ! 25: /* Copyright (c) 1995 NeXT Computer, Inc. All Rights Reserved */ ! 26: /*- ! 27: * Copyright (c) 1986, 1988, 1991, 1993 ! 28: * The Regents of the University of California. All rights reserved. ! 29: * (c) UNIX System Laboratories, Inc. ! 30: * All or some portions of this file are derived from material licensed ! 31: * to the University of California by American Telephone and Telegraph ! 32: * Co. or Unix System Laboratories, Inc. and are reproduced herein with ! 33: * the permission of UNIX System Laboratories, Inc. ! 34: * ! 35: * Redistribution and use in source and binary forms, with or without ! 36: * modification, are permitted provided that the following conditions ! 37: * are met: ! 38: * 1. Redistributions of source code must retain the above copyright ! 39: * notice, this list of conditions and the following disclaimer. ! 40: * 2. Redistributions in binary form must reproduce the above copyright ! 41: * notice, this list of conditions and the following disclaimer in the ! 42: * documentation and/or other materials provided with the distribution. ! 43: * 3. All advertising materials mentioning features or use of this software ! 44: * must display the following acknowledgement: ! 45: * This product includes software developed by the University of ! 46: * California, Berkeley and its contributors. ! 47: * 4. Neither the name of the University nor the names of its contributors ! 48: * may be used to endorse or promote products derived from this software ! 49: * without specific prior written permission. ! 50: * ! 51: * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND ! 52: * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE ! 53: * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ! 54: * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE ! 55: * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL ! 56: * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS ! 57: * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) ! 58: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT ! 59: * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY ! 60: * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF ! 61: * SUCH DAMAGE. ! 62: * ! 63: * @(#)subr_prf.c 8.4 (Berkeley) 5/4/95 ! 64: */ ! 65: /* HISTORY ! 66: * 22-Sep-1997 Umesh Vaishampayan ([email protected]) ! 67: * Cleaned up m68k crud. Fixed vlog() to do logpri() for ppc, too. ! 68: * ! 69: * 17-July-97 Umesh Vaishampayan ([email protected]) ! 70: * Eliminated multiple definition of constty which is defined ! 71: * in bsd/dev/XXX/cons.c ! 72: * ! 73: * 26-MAR-1997 Umesh Vaishampayan ([email protected] ! 74: * Fixed tharshing format in many functions. Cleanup. ! 75: * ! 76: * 17-Jun-1995 Mac Gillon (mgillon) at NeXT ! 77: * Purged old history ! 78: * New version based on 4.4 and NS3.3 ! 79: */ ! 80: ! 81: #include <cpus.h> ! 82: #include <cputypes.h> ! 83: ! 84: #include <sys/param.h> ! 85: #include <sys/systm.h> ! 86: #include <sys/buf.h> ! 87: #include <sys/conf.h> ! 88: #include <sys/reboot.h> ! 89: #include <sys/msgbuf.h> ! 90: #include <sys/proc.h> ! 91: #include <sys/ioctl.h> ! 92: #include <sys/tty.h> ! 93: #include <sys/file.h> ! 94: #include <sys/tprintf.h> ! 95: #include <sys/syslog.h> ! 96: #include <stdarg.h> ! 97: #include <sys/malloc.h> ! 98: #include <kern/lock.h> ! 99: #include <kern/parallel.h> ! 100: #import <sys/subr_prf.h> ! 101: ! 102: #include <machine/cpu.h> /* for cpu_number() */ ! 103: #include <machine/spl.h> ! 104: ! 105: /* ! 106: * In case console is off, ! 107: * panicstr contains argument to last ! 108: * call to panic. ! 109: */ ! 110: const char *panicstr; ! 111: ! 112: extern cnputc(); /* standard console putc */ ! 113: int (*v_putc)() = cnputc; /* routine to putc on virtual console */ ! 114: ! 115: extern struct tty cons; /* standard console tty */ ! 116: extern struct tty *constty; /* pointer to console "window" tty */ ! 117: ! 118: /* ! 119: * Record cpu that panic'd and lock around panic data ! 120: */ ! 121: decl_simple_lock_data(,panic_lock) ! 122: int paniccpu; ! 123: ! 124: static void puts(const char *s, int flags, struct tty *ttyp); ! 125: static void printn(u_long n, int b, int flags, struct tty *ttyp, int zf, int fld_size); ! 126: ! 127: /* MP printf stuff */ ! 128: decl_simple_lock_data(,printf_lock) ! 129: #if NCPUS > 1 ! 130: boolean_t new_printf_cpu_number; /* do we need to output who we are */ ! 131: #endif ! 132: ! 133: extern void logwakeup(); ! 134: extern void halt_cpu(); ! 135: #if NeXT ! 136: extern void mini_mon(); ! 137: #endif /* NeXT */ ! 138: extern boot(); ! 139: int putchar(); ! 140: ! 141: ! 142: /* ! 143: * Scaled down version of C Library printf. ! 144: * Used to print diagnostic information directly on console tty. ! 145: * Since it is not interrupt driven, all system activities are ! 146: * suspended. Printf should not be used for chit-chat. ! 147: * ! 148: * One additional format: %b is supported to decode error registers. ! 149: * Usage is: ! 150: * printf("reg=%b\n", regval, "<base><arg>*"); ! 151: * Where <base> is the output base expressed as a control character, ! 152: * e.g. \10 gives octal; \20 gives hex. Each arg is a sequence of ! 153: * characters, the first of which gives the bit number to be inspected ! 154: * (origin 1), and the next characters (up to a control character, i.e. ! 155: * a character <= 32), give the name of the register. Thus ! 156: * printf("reg=%b\n", 3, "\10\2BITTWO\1BITONE\n"); ! 157: * would produce output: ! 158: * reg=3<BITTWO,BITONE> ! 159: * ! 160: */ ! 161: ! 162: void printf(const char *format, ...) ! 163: { ! 164: va_list ap; ! 165: ! 166: va_start(ap, format); ! 167: prf(format, ap, TOCONS | TOLOG, (struct tty *)0); ! 168: va_end(ap); ! 169: ! 170: if (!panicstr) ! 171: logwakeup(); ! 172: } ! 173: ! 174: int sprintf(char *s, const char *format, ...) ! 175: { ! 176: char *sptr = s; ! 177: char *s0 = s; ! 178: va_list ap; ! 179: ! 180: va_start(ap, format); ! 181: prf(format, ap, TOSTR, (struct tty *)&sptr); ! 182: va_end(ap); ! 183: *sptr = 0; ! 184: return sptr - s0; ! 185: } ! 186: ! 187: /* ! 188: * Uprintf prints to the controlling terminal for the current process. ! 189: * It may block if the tty queue is overfull. No message is printed if ! 190: * the queue does not clear in a reasonable time. ! 191: */ ! 192: void ! 193: uprintf(const char *fmt, ...) ! 194: { ! 195: register struct proc *p = current_proc(); ! 196: va_list ap; ! 197: ! 198: unix_master(); /* sessions, sigh */ ! 199: if (p->p_flag & P_CONTROLT && p->p_session->s_ttyvp) { ! 200: va_start(ap, fmt); ! 201: prf(fmt, ap, TOTTY, (struct tty *)p->p_session->s_ttyvp); ! 202: va_end(ap); ! 203: } ! 204: unix_release(); ! 205: } ! 206: ! 207: tpr_t ! 208: tprintf_open(p) ! 209: register struct proc *p; ! 210: { ! 211: unix_master(); /* sessions, sigh */ ! 212: if (p->p_flag & P_CONTROLT && p->p_session->s_ttyvp) { ! 213: SESSHOLD(p->p_session); ! 214: unix_release(); ! 215: return ((tpr_t) p->p_session); ! 216: } ! 217: unix_release(); ! 218: return ((tpr_t) NULL); ! 219: } ! 220: ! 221: void ! 222: tprintf_close(sess) ! 223: tpr_t sess; ! 224: { ! 225: unix_master(); /* sessions, sigh */ ! 226: if (sess) ! 227: SESSRELE((struct session *) sess); ! 228: unix_release(); ! 229: } ! 230: ! 231: /* ! 232: * tprintf prints on the controlling terminal associated ! 233: * with the given session. ! 234: */ ! 235: void ! 236: tprintf(tpr_t tpr, const char *fmt, ...) ! 237: { ! 238: register struct session *sess = (struct session *)tpr; ! 239: struct tty *tp = NULL; ! 240: int flags = TOLOG; ! 241: va_list ap; ! 242: ! 243: logpri(LOG_INFO); ! 244: unix_master(); /* sessions, sigh */ ! 245: if (sess && sess->s_ttyvp && ttycheckoutq(sess->s_ttyp, 0)) { ! 246: flags |= TOTTY; ! 247: tp = sess->s_ttyp; ! 248: } ! 249: if (tp != NULL) { ! 250: va_start(ap, fmt); ! 251: prf(fmt, ap, TOTTY, tp); ! 252: va_end(ap); ! 253: } ! 254: unix_release(); ! 255: logwakeup(); ! 256: } ! 257: ! 258: /* ! 259: * Ttyprintf displays a message on a tty; it should be used only by ! 260: * the tty driver, or anything that knows the underlying tty will not ! 261: * be revoke(2)'d away. Other callers should use tprintf. ! 262: */ ! 263: void ! 264: ttyprintf(struct tty *tp, const char *fmt, ...) ! 265: { ! 266: va_list ap; ! 267: ! 268: if (tp != NULL) { ! 269: va_start(ap, fmt); ! 270: prf(fmt, ap, TOTTY, tp); ! 271: va_end(ap); ! 272: } ! 273: } ! 274: ! 275: extern int log_open; ! 276: ! 277: /* ! 278: * Log writes to the log buffer, ! 279: * and guarantees not to sleep (so can be called by interrupt routines). ! 280: * If there is no process reading the log yet, it writes to the console also. ! 281: */ ! 282: void ! 283: log(int level, const char *fmt, ...) ! 284: { ! 285: extern void vlog(); ! 286: va_list ap; ! 287: ! 288: va_start(ap, fmt); ! 289: vlog(level, fmt, ap); ! 290: va_end(ap); ! 291: } ! 292: ! 293: /* ! 294: * driverkit needs vlog to be called from IOLog ! 295: */ ! 296: void ! 297: vlog(int level, const char *fmt, va_list ap) ! 298: { ! 299: register s = splhigh(); ! 300: ! 301: #if !NeXT ! 302: logpri(level); ! 303: #endif ! 304: prf(fmt, ap, TOLOG, (struct tty *)0); ! 305: splx(s); ! 306: if (!log_open) ! 307: prf(fmt, ap, TOCONS, (struct tty *)0); ! 308: logwakeup(); ! 309: } ! 310: ! 311: void ! 312: logpri(level) ! 313: int level; ! 314: { ! 315: ! 316: putchar('<', TOLOG, (struct tty *)0); ! 317: printn((u_long)level, 10, TOLOG, (struct tty *)0, 0, 0); ! 318: putchar('>', TOLOG, (struct tty *)0); ! 319: } ! 320: ! 321: void ! 322: addlog(const char *fmt, ...) ! 323: { ! 324: register s = splhigh(); ! 325: va_list ap; ! 326: ! 327: va_start(ap, fmt); ! 328: prf(fmt, ap, TOLOG, (struct tty *)0); ! 329: splx(s); ! 330: if (!log_open) ! 331: prf(fmt, ap, TOCONS, (struct tty *)0); ! 332: va_end(ap); ! 333: logwakeup(); ! 334: } ! 335: #warning pulled in from mksparc check encumbered or not ! 336: void _printf(int flags, struct tty *ttyp, const char *format, ...) ! 337: { ! 338: va_list ap; ! 339: ! 340: va_start(ap, format); ! 341: prf(format, ap, flags, ttyp); ! 342: va_end(ap); ! 343: } ! 344: ! 345: int prf(const char *fmt, va_list ap, int flags, struct tty *ttyp) ! 346: { ! 347: register int b, c, i; ! 348: char *s; ! 349: int any; ! 350: int zf = 0, fld_size; ! 351: ! 352: #if NCPUS > 1 ! 353: int cpun = cpu_number(); ! 354: ! 355: if(ttyp == 0) { ! 356: simple_lock(&printf_lock); ! 357: } else ! 358: TTY_LOCK(ttyp); ! 359: ! 360: if (cpun != master_cpu) ! 361: new_printf_cpu_number = TRUE; ! 362: ! 363: if (new_printf_cpu_number) { ! 364: putchar('{', flags, ttyp); ! 365: printn((u_long)cpun, 10, flags, ttyp, 0, 0); ! 366: putchar('}', flags, ttyp); ! 367: } ! 368: #endif /* NCPUS > 1 */ ! 369: loop: ! 370: while ((c = *fmt++) != '%') { ! 371: if (c == '\0') { ! 372: #if NCPUS > 1 ! 373: if(ttyp == 0) { ! 374: simple_unlock(&printf_lock); ! 375: } else ! 376: TTY_UNLOCK(ttyp); ! 377: #endif ! 378: return 0; ! 379: } ! 380: putchar(c, flags, ttyp); ! 381: } ! 382: again: ! 383: zf = 0; ! 384: fld_size = 0; ! 385: c = *fmt++; ! 386: if (c == '0') ! 387: zf = '0'; ! 388: fld_size = 0; ! 389: for (;c <= '9' && c >= '0'; c = *fmt++) ! 390: fld_size = fld_size * 10 + c - '0'; ! 391: ! 392: /* THIS CODE IS VAX DEPENDENT IN HANDLING %l? AND %c */ ! 393: switch (c) { ! 394: ! 395: case 'l': ! 396: goto again; ! 397: case 'x': case 'X': ! 398: b = 16; ! 399: goto number; ! 400: case 'd': case 'D': ! 401: case 'u': /* what a joke */ ! 402: b = 10; ! 403: goto number; ! 404: case 'o': case 'O': ! 405: b = 8; ! 406: number: ! 407: printn(va_arg(ap, unsigned), b, flags, ttyp, zf, fld_size); ! 408: break; ! 409: case 'c': ! 410: b = va_arg(ap, unsigned); ! 411: #if BYTE_ORDER == LITTLE_ENDIAN ! 412: for (i = 24; i >= 0; i -= 8) ! 413: if (c = (b >> i) & 0x7f) ! 414: putchar(c, flags, ttyp); ! 415: #endif ! 416: #if BYTE_ORDER == BIG_ENDIAN ! 417: if ((c = (b & 0x7f))) ! 418: putchar(c, flags, ttyp); ! 419: #endif ! 420: break; ! 421: case 'b': ! 422: b = va_arg(ap, unsigned); ! 423: s = va_arg(ap, char *); ! 424: printn((u_long)b, *s++, flags, ttyp, 0, 0); ! 425: any = 0; ! 426: if (b) { ! 427: while ((i = *s++)) { ! 428: if (*s <= 32) { ! 429: register int j; ! 430: ! 431: if (any++) ! 432: putchar(',', flags, ttyp); ! 433: j = *s++ ; ! 434: for (; (c = *s) > 32 ; s++) ! 435: putchar(c, flags, ttyp); ! 436: printn( (u_long)( (b >> (j-1)) & ! 437: ( (2 << (i-j)) -1)), ! 438: 8, flags, ttyp, 0, 0); ! 439: } else if (b & (1 << (i-1))) { ! 440: putchar(any? ',' : '<', flags, ttyp); ! 441: any = 1; ! 442: for (; (c = *s) > 32; s++) ! 443: putchar(c, flags, ttyp); ! 444: } else ! 445: for (; *s > 32; s++) ! 446: ; ! 447: } ! 448: putchar('>', flags, ttyp); ! 449: } ! 450: break; ! 451: ! 452: case 's': ! 453: s = va_arg(ap, char *); ! 454: #ifdef DEBUG ! 455: if (fld_size) { ! 456: while (fld_size-- > 0) ! 457: putchar((c = *s++)? c : '_', flags, ttyp); ! 458: } else { ! 459: while ((c = *s++)) ! 460: putchar(c, flags, ttyp); ! 461: } ! 462: #else ! 463: while (c = *s++) ! 464: putchar(c, flags, ttyp); ! 465: #endif ! 466: break; ! 467: ! 468: case '%': ! 469: putchar('%', flags, ttyp); ! 470: goto loop; ! 471: case 'C': ! 472: b = va_arg(ap, unsigned); ! 473: #if BYTE_ORDER == LITTLE_ENDIAN ! 474: for (i = 24; i >= 0; i -= 8) ! 475: if (c = (b >> i) & 0x7f) ! 476: putchar(c, flags, ttyp); ! 477: #endif ! 478: #if BYTE_ORDER == BIG_ENDIAN ! 479: if ((c = (b & 0x7f))) ! 480: putchar(c, flags, ttyp); ! 481: #endif ! 482: ! 483: case 'r': ! 484: case 'R': ! 485: b = va_arg(ap, unsigned); ! 486: s = va_arg(ap, char *); ! 487: if (c == 'R') { ! 488: puts("0x", flags, ttyp); ! 489: printn((u_long)b, 16, flags, ttyp, 0, 0); ! 490: } ! 491: any = 0; ! 492: if (c == 'r' || b) { ! 493: register struct reg_desc *rd; ! 494: register struct reg_values *rv; ! 495: unsigned field; ! 496: ! 497: putchar('<', flags, ttyp); ! 498: for (rd = (struct reg_desc *)s; rd->rd_mask; rd++) { ! 499: field = b & rd->rd_mask; ! 500: field = (rd->rd_shift > 0) ! 501: ? field << rd->rd_shift ! 502: : field >> -rd->rd_shift; ! 503: if (any && ! 504: (rd->rd_format || rd->rd_values ! 505: || (rd->rd_name && field) ! 506: ) ! 507: ) ! 508: putchar(',', flags, ttyp); ! 509: if (rd->rd_name) { ! 510: if (rd->rd_format || rd->rd_values ! 511: || field) { ! 512: puts(rd->rd_name, flags, ttyp); ! 513: any = 1; ! 514: } ! 515: if (rd->rd_format || rd->rd_values) { ! 516: putchar('=', flags, ttyp); ! 517: any = 1; ! 518: } ! 519: } ! 520: if (rd->rd_format) { ! 521: _printf(flags, ttyp, rd->rd_format, ! 522: field); ! 523: any = 1; ! 524: if (rd->rd_values) ! 525: putchar(':', flags, ttyp); ! 526: } ! 527: if (rd->rd_values) { ! 528: any = 1; ! 529: for (rv = rd->rd_values; ! 530: rv->rv_name; ! 531: rv++) { ! 532: if (field == rv->rv_value) { ! 533: puts(rv->rv_name, flags, ! 534: ttyp); ! 535: break; ! 536: } ! 537: } ! 538: if (rv->rv_name == NULL) ! 539: puts("???", flags, ttyp); ! 540: } ! 541: } ! 542: putchar('>', flags, ttyp); ! 543: } ! 544: break; ! 545: ! 546: case 'n': ! 547: case 'N': ! 548: { ! 549: register struct reg_values *rv; ! 550: ! 551: b = va_arg(ap, unsigned); ! 552: s = va_arg(ap,char *); ! 553: for (rv = (struct reg_values *)s; rv->rv_name; rv++) { ! 554: if (b == rv->rv_value) { ! 555: puts(rv->rv_name, flags, ttyp); ! 556: break; ! 557: } ! 558: } ! 559: if (rv->rv_name == NULL) ! 560: puts("???", flags, ttyp); ! 561: if (c == 'N' || rv->rv_name == NULL) { ! 562: putchar(':', flags, ttyp); ! 563: printn((u_long)b, 10, flags, ttyp, 0, 0); ! 564: } ! 565: } ! 566: break; ! 567: } ! 568: goto loop; ! 569: } ! 570: ! 571: static void puts(const char *s, int flags, struct tty *ttyp) ! 572: { ! 573: register char c; ! 574: ! 575: while ((c = *s++)) ! 576: putchar(c, flags, ttyp); ! 577: } ! 578: ! 579: /* ! 580: * Printn prints a number n in base b. ! 581: * We don't use recursion to avoid deep kernel stacks. ! 582: */ ! 583: static void printn(u_long n, int b, int flags, struct tty *ttyp, int zf, int fld_size) ! 584: { ! 585: char prbuf[11]; ! 586: register char *cp; ! 587: ! 588: if (b == 10 && (int)n < 0) { ! 589: putchar('-', flags, ttyp); ! 590: n = (unsigned)(-(int)n); ! 591: } ! 592: cp = prbuf; ! 593: do { ! 594: *cp++ = "0123456789abcdef"[n%b]; ! 595: n /= b; ! 596: } while (n); ! 597: if (fld_size) { ! 598: for (fld_size -= cp - prbuf; fld_size > 0; fld_size--) ! 599: if (zf) ! 600: putchar('0', flags, ttyp); ! 601: else ! 602: putchar(' ', flags, ttyp); ! 603: } ! 604: do ! 605: putchar(*--cp, flags, ttyp); ! 606: while (cp > prbuf); ! 607: } ! 608: ! 609: void panic_init() ! 610: { ! 611: simple_lock_init(&panic_lock); ! 612: } ! 613: ! 614: /* ! 615: * Panic is called on unresolvable fatal errors. It prints "panic: mesg", ! 616: * and then reboots. If we are called twice, then we avoid trying to sync ! 617: * the disks as this often leads to recursive panics. ! 618: */ ! 619: #ifdef __GNUC__ ! 620: volatile ! 621: #endif ! 622: void ! 623: panic(const char *fmt, ...) ! 624: { ! 625: #if MACH_LDEBUG ! 626: extern int mach_ldebug; ! 627: #endif /* MACH_LDEBUG */ ! 628: int bootopt; ! 629: va_list ap; ! 630: char buffer[256]; ! 631: ! 632: simple_lock(&panic_lock); ! 633: bootopt = RB_AUTOBOOT; ! 634: if (panicstr) { ! 635: if (cpu_number() == paniccpu) { ! 636: bootopt |= RB_NOSYNC; ! 637: } else { ! 638: simple_unlock(&panic_lock); ! 639: halt_cpu(); ! 640: /* NOTREACHED */ ! 641: } ! 642: } else { ! 643: panicstr = fmt; ! 644: paniccpu = cpu_number(); ! 645: } ! 646: ! 647: simple_unlock(&panic_lock); ! 648: ! 649: #if MACH_LDEBUG ! 650: mach_ldebug = 0; // turn off simple lock debugging. ! 651: #endif /* MACH_LDEBUG */ ! 652: ! 653: va_start(ap, fmt); ! 654: sprintf(buffer, "panic: %s", fmt); ! 655: prf(buffer, ap, TOCONS, (struct tty *)0); ! 656: va_end(ap); ! 657: ! 658: #if NeXT ! 659: if( panicstr == fmt) { ! 660: // make panicstr for minimon ! 661: char * strOut = buffer; ! 662: va_start(ap, fmt); ! 663: prf(fmt, ap, TOSTR, (struct tty *)&strOut ); ! 664: va_end(ap); ! 665: *strOut = 0; ! 666: panicstr = buffer; ! 667: } ! 668: mini_mon ("panic", "System Panic", current_thread()->pcb); ! 669: #endif /* NeXT */ ! 670: boot(RB_PANIC, bootopt, ""); ! 671: } ! 672: ! 673: /* ! 674: * Warn that a system table is full. ! 675: */ ! 676: void tablefull(const char *tab) ! 677: { ! 678: log(LOG_ERR, "%s: table is full\n", tab); ! 679: } ! 680: ! 681: /* ! 682: * Hard error is the preface to plaintive error messages ! 683: * about failing disk transfers. ! 684: */ ! 685: void harderr(struct buf *bp, const char *cp) ! 686: { ! 687: ! 688: printf("%s%d%c: hard error sn%d ", cp, ! 689: minor(bp->b_dev) >> 3, 'a'+(minor(bp->b_dev)&07), bp->b_blkno); ! 690: } ! 691: ! 692: /* ! 693: * Print a character on console or users terminal. ! 694: * If destination is console then the last MSGBUFS characters ! 695: * are saved in msgbuf for inspection later. ! 696: */ ! 697: /*ARGSUSED*/ ! 698: int ! 699: putchar(c, flags, tp) ! 700: register int c; ! 701: struct tty *tp; ! 702: { ! 703: register struct msgbuf *mbp; ! 704: char **sp = (char**) tp; ! 705: ! 706: if (panicstr) ! 707: constty = 0; ! 708: if ((flags & TOCONS) && tp == NULL && constty) { ! 709: tp = constty; ! 710: flags |= TOTTY; ! 711: } ! 712: if ((flags & TOTTY) && tp && tputchar(c, tp) < 0 && ! 713: (flags & TOCONS) && tp == constty) ! 714: constty = 0; ! 715: if ((flags & TOLOG) && c != '\0' && c != '\r' && c != 0177) { ! 716: mbp = msgbufp; ! 717: if (mbp-> msg_magic != MSG_MAGIC) { ! 718: register int i; ! 719: ! 720: mbp->msg_magic = MSG_MAGIC; ! 721: mbp->msg_bufx = mbp->msg_bufr = 0; ! 722: for (i=0; i < MSG_BSIZE; i++) ! 723: mbp->msg_bufc[i] = 0; ! 724: } ! 725: mbp->msg_bufc[mbp->msg_bufx++] = c; ! 726: if (mbp->msg_bufx < 0 || mbp->msg_bufx >= MSG_BSIZE) ! 727: mbp->msg_bufx = 0; ! 728: } ! 729: if ((flags & TOCONS) && constty == 0 && c != '\0') ! 730: (*v_putc)(c); ! 731: if (flags & TOSTR) { ! 732: **sp = c; ! 733: (*sp)++; ! 734: } ! 735: return 0; ! 736: } ! 737:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.