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