1 /* 2 * CDDL HEADER START 3 * 4 * The contents of this file are subject to the terms of the 5 * Common Development and Distribution License (the "License"). 6 * You may not use this file except in compliance with the License. 7 * 8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 9 * or http://www.opensolaris.org/os/licensing. 10 * See the License for the specific language governing permissions 11 * and limitations under the License. 12 * 13 * When distributing Covered Code, include this CDDL HEADER in each 14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 15 * If applicable, add the following below this CDDL HEADER, with the 16 * fields enclosed by brackets "[]" replaced with your own identifying 17 * information: Portions Copyright [yyyy] [name of copyright owner] 18 * 19 * CDDL HEADER END 20 */ 21 22 /* 23 * Copyright 2006 Sun Microsystems, Inc. All rights reserved. 24 * Use is subject to license terms. 25 */ 26 27 #pragma ident "%Z%%M% %I% %E% SMI" 28 29 #include <sys/types.h> 30 #include <sys/param.h> 31 #include <sys/varargs.h> 32 #include <sys/systm.h> 33 #include <sys/cmn_err.h> 34 #include <sys/stream.h> 35 #include <sys/strsubr.h> 36 #include <sys/strsun.h> 37 #include <sys/sysmacros.h> 38 #include <sys/kmem.h> 39 #include <sys/log.h> 40 #include <sys/spl.h> 41 #include <sys/syslog.h> 42 #include <sys/console.h> 43 #include <sys/debug.h> 44 #include <sys/utsname.h> 45 #include <sys/id_space.h> 46 #include <sys/zone.h> 47 48 log_zone_t log_global; 49 queue_t *log_consq; 50 queue_t *log_backlogq; 51 queue_t *log_intrq; 52 53 #define LOG_PRISIZE 8 /* max priority size: 7 characters + null */ 54 #define LOG_FACSIZE 9 /* max priority size: 8 characters + null */ 55 56 static krwlock_t log_rwlock; 57 static int log_rwlock_depth; 58 static int log_seq_no[SL_CONSOLE + 1]; 59 static stdata_t log_fakestr; 60 static id_space_t *log_minorspace; 61 static log_t log_backlog; 62 static struct kmem_cache *log_cons_cache; /* log_t cache */ 63 64 static queue_t *log_recentq; 65 static queue_t *log_freeq; 66 67 static zone_key_t log_zone_key; 68 69 static char log_overflow_msg[] = "message overflow on /dev/log minor #%d%s\n"; 70 71 static char log_pri[LOG_PRIMASK + 1][LOG_PRISIZE] = { 72 "emerg", "alert", "crit", "error", 73 "warning", "notice", "info", "debug" 74 }; 75 76 static char log_fac[LOG_NFACILITIES + 1][LOG_FACSIZE] = { 77 "kern", "user", "mail", "daemon", 78 "auth", "syslog", "lpr", "news", 79 "uucp", "resv9", "resv10", "resv11", 80 "resv12", "audit", "resv14", "cron", 81 "local0", "local1", "local2", "local3", 82 "local4", "local5", "local6", "local7", 83 "unknown" 84 }; 85 static int log_cons_constructor(void *, void *, int); 86 static void log_cons_destructor(void *, void *); 87 88 /* 89 * Get exclusive access to the logging system; this includes all minor 90 * devices. We use an rwlock rather than a mutex because hold times 91 * are potentially long, so we don't want to waste cycles in adaptive mutex 92 * spin (rwlocks always block when contended). Note that we explicitly 93 * support recursive calls (e.g. printf() calls foo() calls printf()). 94 * 95 * Clients may use log_enter() / log_exit() to guarantee that a group 96 * of messages is treated atomically (i.e. they appear in order and are 97 * not interspersed with any other messages), e.g. for multiline printf(). 98 * 99 * This could probably be changed to a per-zone lock if contention becomes 100 * an issue. 101 */ 102 void 103 log_enter(void) 104 { 105 if (rw_owner(&log_rwlock) != curthread) 106 rw_enter(&log_rwlock, RW_WRITER); 107 log_rwlock_depth++; 108 } 109 110 void 111 log_exit(void) 112 { 113 if (--log_rwlock_depth == 0) 114 rw_exit(&log_rwlock); 115 } 116 117 void 118 log_flushq(queue_t *q) 119 { 120 mblk_t *mp; 121 log_t *lp = (log_t *)q->q_ptr; 122 123 /* lp will be NULL if the queue was created via log_makeq */ 124 while ((mp = getq_noenab(q)) != NULL) 125 log_sendmsg(mp, lp == NULL ? GLOBAL_ZONEID : lp->log_zoneid); 126 } 127 128 /* 129 * Create a minimal queue with just enough fields filled in to support 130 * canput(9F), putq(9F), and getq_noenab(9F). We set QNOENB to ensure 131 * that the queue will never be enabled. 132 */ 133 static queue_t * 134 log_makeq(size_t lowat, size_t hiwat, void *ibc) 135 { 136 queue_t *q; 137 138 q = kmem_zalloc(sizeof (queue_t), KM_SLEEP); 139 q->q_stream = &log_fakestr; 140 q->q_flag = QISDRV | QMTSAFE | QNOENB | QREADR | QUSE; 141 q->q_nfsrv = q; 142 q->q_lowat = lowat; 143 q->q_hiwat = hiwat; 144 mutex_init(QLOCK(q), NULL, MUTEX_DRIVER, ibc); 145 146 return (q); 147 } 148 149 /* 150 * Initialize the log structure for a new zone. 151 */ 152 static void * 153 log_zoneinit(zoneid_t zoneid) 154 { 155 int i; 156 log_zone_t *lzp; 157 158 if (zoneid == GLOBAL_ZONEID) 159 lzp = &log_global; /* use statically allocated struct */ 160 else 161 lzp = kmem_zalloc(sizeof (log_zone_t), KM_SLEEP); 162 163 for (i = 0; i < LOG_NUMCLONES; i++) { 164 lzp->lz_clones[i].log_minor = 165 (minor_t)id_alloc(log_minorspace); 166 lzp->lz_clones[i].log_zoneid = zoneid; 167 } 168 return (lzp); 169 } 170 171 /*ARGSUSED*/ 172 static void 173 log_zonefree(zoneid_t zoneid, void *arg) 174 { 175 log_zone_t *lzp = arg; 176 int i; 177 178 ASSERT(lzp != &log_global && zoneid != GLOBAL_ZONEID); 179 if (lzp == NULL) 180 return; 181 for (i = 0; i < LOG_NUMCLONES; i++) 182 id_free(log_minorspace, lzp->lz_clones[i].log_minor); 183 kmem_free(lzp, sizeof (log_zone_t)); 184 } 185 186 void 187 log_init(void) 188 { 189 int log_maxzones; 190 191 /* 192 * Create a backlog queue to consume console messages during periods 193 * when there is no console reader (e.g. before syslogd(1M) starts). 194 */ 195 log_backlogq = log_consq = log_makeq(0, LOG_HIWAT, NULL); 196 197 /* 198 * Create a queue to hold free message of size <= LOG_MSGSIZE. 199 * Calls from high-level interrupt handlers will do a getq_noenab() 200 * from this queue, so its q_lock must be a maximum SPL spin lock. 201 */ 202 log_freeq = log_makeq(LOG_MINFREE, LOG_MAXFREE, (void *)ipltospl(SPL8)); 203 204 /* 205 * Create a queue for messages from high-level interrupt context. 206 * These messages are drained via softcall, or explicitly by panic(). 207 */ 208 log_intrq = log_makeq(0, LOG_HIWAT, (void *)ipltospl(SPL8)); 209 210 /* 211 * Create a queue to hold the most recent 8K of console messages. 212 * Useful for debugging. Required by the "$<msgbuf" adb macro. 213 */ 214 log_recentq = log_makeq(0, LOG_RECENTSIZE, NULL); 215 216 /* 217 * Create an id space for clone devices opened via /dev/log. 218 * Need to limit the number of zones to avoid exceeding the 219 * available minor number space. 220 */ 221 log_maxzones = (L_MAXMIN32 - LOG_LOGMIN) / LOG_NUMCLONES - 1; 222 if (log_maxzones < maxzones) 223 maxzones = log_maxzones; 224 log_minorspace = id_space_create("logminor_space", LOG_LOGMIN + 1, 225 L_MAXMIN32); 226 /* 227 * Put ourselves on the ZSD list. Note that zones have not been 228 * initialized yet, but our constructor will be called on the global 229 * zone when they are. 230 */ 231 zone_key_create(&log_zone_key, log_zoneinit, NULL, log_zonefree); 232 233 /* 234 * Initialize backlog structure. 235 */ 236 log_backlog.log_zoneid = GLOBAL_ZONEID; 237 log_backlog.log_minor = LOG_BACKLOG; 238 239 /* Allocate kmem cache for conslog's log structures */ 240 log_cons_cache = kmem_cache_create("log_cons_cache", 241 sizeof (struct log), 0, log_cons_constructor, log_cons_destructor, 242 NULL, NULL, NULL, 0); 243 244 /* 245 * Let the logging begin. 246 */ 247 log_update(&log_backlog, log_backlogq, SL_CONSOLE, log_console); 248 249 /* 250 * Now that logging is enabled, emit the SunOS banner. 251 */ 252 printf("\rSunOS Release %s Version %s %u-bit\n", 253 utsname.release, utsname.version, NBBY * (uint_t)sizeof (void *)); 254 printf("Copyright 1983-2006 Sun Microsystems, Inc. " 255 "All rights reserved.\nUse is subject to license terms.\n"); 256 #ifdef DEBUG 257 printf("DEBUG enabled\n"); 258 #endif 259 } 260 261 /* 262 * Allocate a log device corresponding to supplied device type. 263 * Both devices are clonable. /dev/log devices are allocated per zone. 264 * /dev/conslog devices are allocated from kmem cache. 265 */ 266 log_t * 267 log_alloc(minor_t type) 268 { 269 zone_t *zptr = curproc->p_zone; 270 log_zone_t *lzp; 271 log_t *lp; 272 int i; 273 minor_t minor; 274 275 if (type == LOG_CONSMIN) { 276 277 /* 278 * Return a write-only /dev/conslog device. 279 * No point allocating log_t until there's a free minor number. 280 */ 281 minor = (minor_t)id_alloc(log_minorspace); 282 lp = kmem_cache_alloc(log_cons_cache, KM_SLEEP); 283 lp->log_minor = minor; 284 return (lp); 285 } else { 286 ASSERT(type == LOG_LOGMIN); 287 288 lzp = zone_getspecific(log_zone_key, zptr); 289 ASSERT(lzp != NULL); 290 291 /* search for an available /dev/log device for the zone */ 292 for (i = LOG_LOGMINIDX; i <= LOG_LOGMAXIDX; i++) { 293 lp = &lzp->lz_clones[i]; 294 if (lp->log_inuse == 0) 295 break; 296 } 297 if (i > LOG_LOGMAXIDX) 298 lp = NULL; 299 else 300 /* Indicate which device type */ 301 lp->log_major = LOG_LOGMIN; 302 return (lp); 303 } 304 } 305 306 void 307 log_free(log_t *lp) 308 { 309 id_free(log_minorspace, lp->log_minor); 310 kmem_cache_free(log_cons_cache, lp); 311 } 312 313 /* 314 * Move console messages from src to dst. The time of day isn't known 315 * early in boot, so fix up the message timestamps if necessary. 316 */ 317 static void 318 log_conswitch(log_t *src, log_t *dst) 319 { 320 mblk_t *mp; 321 mblk_t *hmp = NULL; 322 mblk_t *tmp = NULL; 323 log_ctl_t *hlc; 324 325 while ((mp = getq_noenab(src->log_q)) != NULL) { 326 log_ctl_t *lc = (log_ctl_t *)mp->b_rptr; 327 lc->flags |= SL_LOGONLY; 328 329 /* 330 * In the early boot phase hrestime is invalid. 331 * hrestime becomes valid when clock() runs for the first time. 332 * At this time is lbolt == 1. log_sendmsg() saves the lbolt 333 * value in ltime. 334 */ 335 if (lc->ltime < 2) { 336 /* 337 * Look ahead to first early boot message with time. 338 */ 339 if (hmp) { 340 tmp->b_next = mp; 341 tmp = mp; 342 } else 343 hmp = tmp = mp; 344 continue; 345 } 346 347 while (hmp) { 348 tmp = hmp->b_next; 349 hmp->b_next = NULL; 350 hlc = (log_ctl_t *)hmp->b_rptr; 351 /* 352 * Calculate hrestime for an early log message with 353 * an invalid time stamp. We know: 354 * - the lbolt of the invalid time stamp. 355 * - the hrestime and lbolt of the first valid 356 * time stamp. 357 */ 358 hlc->ttime = lc->ttime - (lc->ltime - hlc->ltime) / hz; 359 (void) putq(dst->log_q, hmp); 360 hmp = tmp; 361 } 362 (void) putq(dst->log_q, mp); 363 } 364 while (hmp) { 365 tmp = hmp->b_next; 366 hmp->b_next = NULL; 367 hlc = (log_ctl_t *)hmp->b_rptr; 368 hlc->ttime = gethrestime_sec() - (lbolt - hlc->ltime) / hz; 369 (void) putq(dst->log_q, hmp); 370 hmp = tmp; 371 } 372 dst->log_overflow = src->log_overflow; 373 src->log_flags = 0; 374 dst->log_flags = SL_CONSOLE; 375 log_consq = dst->log_q; 376 } 377 378 /* 379 * Set the fields in the 'target' clone to the specified values. 380 * Then, look at all clones to determine which message types are 381 * currently active and which clone is the primary console queue. 382 * If the primary console queue changes to or from the backlog 383 * queue, copy all messages from backlog to primary or vice versa. 384 */ 385 void 386 log_update(log_t *target, queue_t *q, short flags, log_filter_t *filter) 387 { 388 log_t *lp; 389 short active = SL_CONSOLE; 390 zone_t *zptr = NULL; 391 log_zone_t *lzp; 392 zoneid_t zoneid = target->log_zoneid; 393 int i; 394 395 log_enter(); 396 397 if (q != NULL) 398 target->log_q = q; 399 target->log_wanted = filter; 400 target->log_flags = flags; 401 target->log_overflow = 0; 402 403 /* 404 * Need to special case the global zone here since this may be 405 * called before zone_init. 406 */ 407 if (zoneid == GLOBAL_ZONEID) { 408 lzp = &log_global; 409 } else if ((zptr = zone_find_by_id(zoneid)) == NULL) { 410 log_exit(); 411 return; /* zone is being destroyed, ignore update */ 412 } else { 413 lzp = zone_getspecific(log_zone_key, zptr); 414 } 415 ASSERT(lzp != NULL); 416 for (i = LOG_LOGMAXIDX; i >= LOG_LOGMINIDX; i--) { 417 lp = &lzp->lz_clones[i]; 418 if (zoneid == GLOBAL_ZONEID && (lp->log_flags & SL_CONSOLE)) 419 log_consq = lp->log_q; 420 active |= lp->log_flags; 421 } 422 lzp->lz_active = active; 423 424 if (zptr) 425 zone_rele(zptr); 426 427 if (log_consq == target->log_q) { 428 if (flags & SL_CONSOLE) 429 log_conswitch(&log_backlog, target); 430 else 431 log_conswitch(target, &log_backlog); 432 } 433 target->log_q = q; 434 435 log_exit(); 436 } 437 438 /*ARGSUSED*/ 439 int 440 log_error(log_t *lp, log_ctl_t *lc) 441 { 442 if ((lc->pri & LOG_FACMASK) == LOG_KERN) 443 lc->pri = LOG_KERN | LOG_ERR; 444 return (1); 445 } 446 447 int 448 log_trace(log_t *lp, log_ctl_t *lc) 449 { 450 trace_ids_t *tid = (trace_ids_t *)lp->log_data->b_rptr; 451 trace_ids_t *tidend = (trace_ids_t *)lp->log_data->b_wptr; 452 453 /* 454 * We use `tid + 1 <= tidend' here rather than the more traditional 455 * `tid < tidend', since the former ensures that there's at least 456 * `sizeof (trace_ids_t)' bytes available before executing the 457 * loop, whereas the latter only ensures that there's a single byte. 458 */ 459 for (; tid + 1 <= tidend; tid++) { 460 if (tid->ti_level < lc->level && tid->ti_level >= 0) 461 continue; 462 if (tid->ti_mid != lc->mid && tid->ti_mid >= 0) 463 continue; 464 if (tid->ti_sid != lc->sid && tid->ti_sid >= 0) 465 continue; 466 if ((lc->pri & LOG_FACMASK) == LOG_KERN) 467 lc->pri = LOG_KERN | LOG_DEBUG; 468 return (1); 469 } 470 return (0); 471 } 472 473 /*ARGSUSED*/ 474 int 475 log_console(log_t *lp, log_ctl_t *lc) 476 { 477 if ((lc->pri & LOG_FACMASK) == LOG_KERN) { 478 if (lc->flags & SL_FATAL) 479 lc->pri = LOG_KERN | LOG_CRIT; 480 else if (lc->flags & SL_ERROR) 481 lc->pri = LOG_KERN | LOG_ERR; 482 else if (lc->flags & SL_WARN) 483 lc->pri = LOG_KERN | LOG_WARNING; 484 else if (lc->flags & SL_NOTE) 485 lc->pri = LOG_KERN | LOG_NOTICE; 486 else if (lc->flags & SL_TRACE) 487 lc->pri = LOG_KERN | LOG_DEBUG; 488 else 489 lc->pri = LOG_KERN | LOG_INFO; 490 } 491 return (1); 492 } 493 494 mblk_t * 495 log_makemsg(int mid, int sid, int level, int sl, int pri, void *msg, 496 size_t size, int on_intr) 497 { 498 mblk_t *mp = NULL; 499 mblk_t *mp2; 500 log_ctl_t *lc; 501 502 if (size <= LOG_MSGSIZE && 503 (on_intr || log_freeq->q_count > log_freeq->q_lowat)) 504 mp = getq_noenab(log_freeq); 505 506 if (mp == NULL) { 507 if (on_intr || 508 (mp = allocb(sizeof (log_ctl_t), BPRI_HI)) == NULL || 509 (mp2 = allocb(MAX(size, LOG_MSGSIZE), BPRI_HI)) == NULL) { 510 freemsg(mp); 511 return (NULL); 512 } 513 DB_TYPE(mp) = M_PROTO; 514 mp->b_wptr += sizeof (log_ctl_t); 515 mp->b_cont = mp2; 516 } else { 517 mp2 = mp->b_cont; 518 mp2->b_wptr = mp2->b_rptr; 519 } 520 521 lc = (log_ctl_t *)mp->b_rptr; 522 lc->mid = mid; 523 lc->sid = sid; 524 lc->level = level; 525 lc->flags = sl; 526 lc->pri = pri; 527 528 bcopy(msg, mp2->b_wptr, size - 1); 529 mp2->b_wptr[size - 1] = '\0'; 530 mp2->b_wptr += strlen((char *)mp2->b_wptr) + 1; 531 532 return (mp); 533 } 534 535 void 536 log_freemsg(mblk_t *mp) 537 { 538 mblk_t *mp2 = mp->b_cont; 539 540 ASSERT(MBLKL(mp) == sizeof (log_ctl_t)); 541 ASSERT(mp2->b_rptr == mp2->b_datap->db_base); 542 543 if ((log_freeq->q_flag & QFULL) == 0 && 544 MBLKL(mp2) <= LOG_MSGSIZE && MBLKSIZE(mp2) >= LOG_MSGSIZE) 545 (void) putq(log_freeq, mp); 546 else 547 freemsg(mp); 548 } 549 550 void 551 log_sendmsg(mblk_t *mp, zoneid_t zoneid) 552 { 553 log_t *lp; 554 char *src, *dst; 555 mblk_t *mp2 = mp->b_cont; 556 log_ctl_t *lc = (log_ctl_t *)mp->b_rptr; 557 int flags, fac; 558 off_t facility = 0; 559 off_t body = 0; 560 zone_t *zptr = NULL; 561 log_zone_t *lzp; 562 int i; 563 int backlog; 564 565 /* 566 * Need to special case the global zone here since this may be 567 * called before zone_init. 568 */ 569 if (zoneid == GLOBAL_ZONEID) { 570 lzp = &log_global; 571 } else if ((zptr = zone_find_by_id(zoneid)) == NULL) { 572 /* specified zone doesn't exist, free message and return */ 573 log_freemsg(mp); 574 return; 575 } else { 576 lzp = zone_getspecific(log_zone_key, zptr); 577 } 578 ASSERT(lzp != NULL); 579 580 if ((lc->flags & lzp->lz_active) == 0) { 581 if (zptr) 582 zone_rele(zptr); 583 log_freemsg(mp); 584 return; 585 } 586 587 if (panicstr) { 588 /* 589 * Raise the console queue's q_hiwat to ensure that we 590 * capture all panic messages. 591 */ 592 log_consq->q_hiwat = 2 * LOG_HIWAT; 593 log_consq->q_flag &= ~QFULL; 594 595 /* Message was created while panicking. */ 596 lc->flags |= SL_PANICMSG; 597 } 598 599 src = (char *)mp2->b_rptr; 600 dst = strstr(src, "FACILITY_AND_PRIORITY] "); 601 if (dst != NULL) { 602 facility = dst - src; 603 body = facility + 23; /* strlen("FACILITY_AND_PRIORITY] ") */ 604 } 605 606 log_enter(); 607 608 lc->ltime = lbolt; 609 lc->ttime = gethrestime_sec(); 610 611 flags = lc->flags & lzp->lz_active; 612 log_seq_no[flags & SL_ERROR]++; 613 log_seq_no[flags & SL_TRACE]++; 614 log_seq_no[flags & SL_CONSOLE]++; 615 616 /* 617 * If this is in the global zone, start with the backlog, then 618 * walk through the clone logs. If not, just do the clone logs. 619 */ 620 backlog = (zoneid == GLOBAL_ZONEID); 621 i = LOG_LOGMINIDX; 622 while (i <= LOG_LOGMAXIDX) { 623 if (backlog) { 624 /* 625 * Do the backlog this time, then start on the 626 * others. 627 */ 628 backlog = 0; 629 lp = &log_backlog; 630 } else { 631 lp = &lzp->lz_clones[i++]; 632 } 633 634 if ((lp->log_flags & flags) && lp->log_wanted(lp, lc)) { 635 if (canput(lp->log_q)) { 636 lp->log_overflow = 0; 637 lc->seq_no = log_seq_no[lp->log_flags]; 638 if ((mp2 = copymsg(mp)) == NULL) 639 break; 640 if (facility != 0) { 641 src = (char *)mp2->b_cont->b_rptr; 642 dst = src + facility; 643 fac = (lc->pri & LOG_FACMASK) >> 3; 644 dst += snprintf(dst, 645 LOG_FACSIZE + LOG_PRISIZE, "%s.%s", 646 log_fac[MIN(fac, LOG_NFACILITIES)], 647 log_pri[lc->pri & LOG_PRIMASK]); 648 src += body - 2; /* copy "] " too */ 649 while (*src != '\0') 650 *dst++ = *src++; 651 *dst++ = '\0'; 652 mp2->b_cont->b_wptr = (uchar_t *)dst; 653 } 654 (void) putq(lp->log_q, mp2); 655 } else if (++lp->log_overflow == 1) { 656 if (lp->log_q == log_consq) { 657 console_printf(log_overflow_msg, 658 lp->log_minor, 659 " -- is syslogd(1M) running?"); 660 } else { 661 printf(log_overflow_msg, 662 lp->log_minor, ""); 663 } 664 } 665 } 666 } 667 668 if (zptr) 669 zone_rele(zptr); 670 671 if ((flags & SL_CONSOLE) && (lc->pri & LOG_FACMASK) == LOG_KERN) { 672 if ((mp2 == NULL || log_consq == log_backlogq || panicstr) && 673 (lc->flags & SL_LOGONLY) == 0) 674 console_printf("%s", (char *)mp->b_cont->b_rptr + body); 675 if ((lc->flags & SL_CONSONLY) == 0 && 676 (mp2 = copymsg(mp)) != NULL) { 677 mp2->b_cont->b_rptr += body; 678 if (log_recentq->q_flag & QFULL) 679 freemsg(getq_noenab(log_recentq)); 680 (void) putq(log_recentq, mp2); 681 } 682 } 683 684 log_freemsg(mp); 685 686 log_exit(); 687 } 688 689 /* 690 * Print queued messages to console. 691 */ 692 void 693 log_printq(queue_t *qfirst) 694 { 695 mblk_t *mp; 696 queue_t *q, *qlast; 697 char *cp, *msgp; 698 log_ctl_t *lc; 699 700 /* 701 * Look ahead to first queued message in the stream. 702 */ 703 qlast = NULL; 704 do { 705 for (q = qfirst; q->q_next != qlast; q = q->q_next) 706 continue; 707 for (mp = q->q_first; mp != NULL; mp = mp->b_next) { 708 lc = (log_ctl_t *)mp->b_rptr; 709 /* 710 * Check if message is already displayed at 711 * /dev/console. 712 */ 713 if (lc->flags & SL_PANICMSG) 714 continue; 715 716 cp = (char *)mp->b_cont->b_rptr; 717 718 /* Strip off the message ID. */ 719 if ((msgp = strstr(cp, "[ID ")) != NULL && 720 (msgp = strstr(msgp, "] ")) != NULL) { 721 cp = msgp + 2; 722 } 723 724 /* 725 * Using console_printf instead of printf to avoid 726 * queueing messages to log_consq. 727 */ 728 console_printf("%s", cp); 729 } 730 } while ((qlast = q) != qfirst); 731 } 732 733 /* ARGSUSED */ 734 static int 735 log_cons_constructor(void *buf, void *cdrarg, int kmflags) 736 { 737 struct log *lp = buf; 738 739 lp->log_zoneid = GLOBAL_ZONEID; 740 lp->log_major = LOG_CONSMIN; /* Indicate which device type */ 741 lp->log_data = NULL; 742 return (0); 743 } 744 745 /* ARGSUSED */ 746 static void 747 log_cons_destructor(void *buf, void *cdrarg) 748 { 749 struct log *lp = buf; 750 751 ASSERT(lp->log_zoneid == GLOBAL_ZONEID); 752 ASSERT(lp->log_major == LOG_CONSMIN); 753 ASSERT(lp->log_data == NULL); 754 } 755