kernel/os/console.c

   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 2008 Sun Microsystems, Inc.  All rights reserved.
  24  * Use is subject to license terms.
  25  */
  26
  27 #include <sys/types.h>
  28 #include <sys/varargs.h>
  29 #include <sys/modctl.h>
  30 #include <sys/cmn_err.h>
  31 #include <sys/console.h>
  32 #include <sys/consdev.h>
  33 #include <sys/promif.h>
  34 #include <sys/note.h>
  35 #include <sys/polled_io.h>
  36 #include <sys/systm.h>
  37 #include <sys/file.h>
  38 #include <sys/conf.h>
  39 #include <sys/kmem.h>
  40 #include <sys/taskq.h>
  41 #include <sys/log.h>
  42 #include <sys/ddi.h>
  43 #include <sys/sunddi.h>
  44 #include <sys/esunddi.h>
  45 #include <sys/fs/snode.h>
  46 #include <sys/termios.h>
  47 #include <sys/tem_impl.h>
  48
  49 #define MINLINES        10
  50 #define MAXLINES        48
  51 #define LOSCREENLINES   34
  52 #define HISCREENLINES   48
  53
  54 #define MINCOLS         10
  55 #define MAXCOLS         120
  56 #define LOSCREENCOLS    80
  57 #define HISCREENCOLS    120
  58
  59 vnode_t *console_vnode;
  60 taskq_t *console_taskq;
  61
  62 /*
  63  * The current set of polled I/O routines (if any)
  64  */
  65 struct cons_polledio *cons_polledio;
  66
  67 /*
  68  * Console I/O Routines
  69  *
  70  * In the event that kernel messages are generated with cmn_err(9F) or printf()
  71  * early in boot, after a panic, in resource-constrained situations, or sent
  72  * through /dev/console to the wscons driver, we may be called upon to render
  73  * characters directly to the frame buffer using the underlying prom_*()
  74  * routines.  These in turn may attempt to use PROM services directly, or may
  75  * use a kernel console emulator if one is available.  Unfortunately, if PROM
  76  * services are being used by the kernel on a multi-CPU system, these routines
  77  * might be called while another CPU is simultaneously accessing a frame buffer
  78  * memory mapping (perhaps through the X server).  This situation may not be
  79  * supported by the frame buffer hardware.
  80  *
  81  * To handle this situation, we implement a two-phase locking scheme which we
  82  * use to protect accesses to the underlying prom_*() rendering routines.  The
  83  * common-code functions console_hold() and console_rele() are used to gain
  84  * exclusive access to the console from within the kernel.  We use a standard
  85  * r/w lock in writer-mode only to implement the kernel lock.  We use an r/w
  86  * lock instead of a mutex here because character rendering is slow and hold
  87  * times will be relatively long, and there is no point in adaptively spinning.
  88  * These routines may be called recursively, in which case subsequent calls
  89  * just increment the console_depth hold count.  Once exclusive access is
  90  * gained, we grab the frame buffer device node and block further mappings to
  91  * it by holding the specfs node lock and the device node's lock.  We then
  92  * observe if any mappings are present by examining the specfs node's s_mapcnt
  93  * (non-clone mmaps) and the devinfo node's devi_ref count (clone opens).
  94  *
  95  * Then, around each character rendering call, the routines console_enter()
  96  * and console_exit() are used to inform the platform code that we are
  97  * accessing the character rendering routines.  These platform routines can
  98  * then examine the "busy" flag returned by console_enter() and briefly stop
  99  * the other CPUs so that they cannot access the frame buffer hardware while
 100  * we are busy rendering characters.  This mess can all be removed when the
 101  * impossible dream of a unified kernel console emulator is someday realized.
 102  */
 103
 104 static krwlock_t console_lock;
 105 static uint_t console_depth;
 106 static int console_busy;
 107
 108 extern void pm_cfb_check_and_powerup(void);
 109 extern void pm_cfb_rele(void);
 110
 111 static int
 112 console_hold(void)
 113 {
 114         if (panicstr != NULL)
 115                 return (console_busy); /* assume exclusive access in panic */
 116
 117         if (rw_owner(&console_lock) != curthread)
 118                 rw_enter(&console_lock, RW_WRITER);
 119
 120         if (console_depth++ != 0)
 121                 return (console_busy); /* lock is being entered recursively */
 122
 123         pm_cfb_check_and_powerup();
 124
 125 #ifdef _HAVE_TEM_FIRMWARE
 126         if (consmode == CONS_FW && ncpus > 1 && fbvp != NULL) {
 127                 struct snode *csp = VTOS(VTOS(fbvp)->s_commonvp);
 128
 129                 mutex_enter(&csp->s_lock);
 130                 console_busy = csp->s_mapcnt != 0;
 131
 132                 if (csp->s_mapcnt == 0 && fbdip != NULL) {
 133                         mutex_enter(&DEVI(fbdip)->devi_lock);
 134                         console_busy = DEVI(fbdip)->devi_ref != 0;
 135                 }
 136         }
 137 #endif /* _HAVE_TEM_FIRMWARE */
 138         return (console_busy);
 139 }
 140
 141 static void
 142 console_rele(void)
 143 {
 144         if (panicstr != NULL)
 145                 return; /* do not modify lock states if we are panicking */
 146
 147         ASSERT(RW_WRITE_HELD(&console_lock));
 148         ASSERT(console_depth != 0);
 149
 150         if (--console_depth != 0)
 151                 return; /* lock is being dropped recursively */
 152
 153 #ifdef _HAVE_TEM_FIRMWARE
 154         if (consmode == CONS_FW && ncpus > 1 && fbvp != NULL) {
 155                 struct snode *csp = VTOS(VTOS(fbvp)->s_commonvp);
 156
 157                 ASSERT(MUTEX_HELD(&csp->s_lock));
 158                 if (csp->s_mapcnt == 0 && fbdip != NULL)
 159                         mutex_exit(&DEVI(fbdip)->devi_lock);
 160
 161                 mutex_exit(&csp->s_lock);
 162         }
 163 #endif /* _HAVE_TEM_FIRMWARE */
 164         pm_cfb_rele();
 165         console_busy = 0;
 166         rw_exit(&console_lock);
 167 }
 168
 169 static void
 170 console_getprop(dev_t dev, dev_info_t *dip, char *name, ushort_t *sp)
 171 {
 172         uchar_t *data;
 173         uint_t len;
 174         uint_t i;
 175
 176         *sp = 0;
 177         if (ddi_prop_lookup_byte_array(dev, dip, 0, name, &data, &len) ==
 178             DDI_PROP_SUCCESS) {
 179                 for (i = 0; i < len; i++) {
 180                         if (data[i] < '0' || data[i] > '9')
 181                                 break;
 182                         *sp = *sp * 10 + data[i] - '0';
 183                 }
 184                 ddi_prop_free(data);
 185         }
 186 }
 187
 188 /*
 189  * Gets the number of rows and columns (in char's) and the
 190  * width and height (in pixels) of the console.
 191  */
 192 void
 193 console_get_size(ushort_t *r, ushort_t *c, ushort_t *x, ushort_t *y)
 194 {
 195         int rel_needed = 0;
 196         dev_info_t *dip;
 197         dev_t dev;
 198
 199         /*
 200          * If we have loaded the console IO stuff, then ask for the screen
 201          * size properties from the layered terminal emulator.  Else ask for
 202          * them from the root node, which will eventually fall through to the
 203          * options node and get them from the prom.
 204          */
 205         if (rwsconsvp == NULL || consmode == CONS_FW) {
 206                 dip = ddi_root_node();
 207                 dev = DDI_DEV_T_ANY;
 208         } else {
 209                 dev = rwsconsvp->v_rdev; /* layering is wc -> tem */
 210                 dip = e_ddi_hold_devi_by_dev(dev, 0);
 211                 rel_needed = 1;
 212         }
 213
 214         /*
 215          * If we have not initialized a console yet and don't have a root
 216          * node (ie. we have not initialized the DDI yet) return our default
 217          * size for the screen.
 218          */
 219         if (dip == NULL) {
 220                 *r = LOSCREENLINES;
 221                 *c = LOSCREENCOLS;
 222                 *x = *y = 0;
 223                 return;
 224         }
 225
 226         console_getprop(DDI_DEV_T_ANY, dip, "screen-#columns", c);
 227         console_getprop(DDI_DEV_T_ANY, dip, "screen-#rows", r);
 228         console_getprop(DDI_DEV_T_ANY, dip, "screen-width", x);
 229         console_getprop(DDI_DEV_T_ANY, dip, "screen-height", y);
 230
 231         if (*c < MINCOLS)
 232                 *c = LOSCREENCOLS;
 233         else if (*c > MAXCOLS)
 234                 *c = HISCREENCOLS;
 235
 236         if (*r < MINLINES)
 237                 *r = LOSCREENLINES;
 238         else if (*r > MAXLINES)
 239                 *r = HISCREENLINES;
 240
 241         if (rel_needed)
 242                 ddi_release_devi(dip);
 243 }
 244
 245 typedef struct console_msg {
 246         size_t  cm_size;
 247         char    cm_text[1];
 248 } console_msg_t;
 249
 250 /*
 251  * If we can't access the console stream, fall through to PROM, which redirects
 252  * it back into to terminal emulator as appropriate.  The console stream should
 253  * be available after consconfig runs.
 254  */
 255 static void
 256 console_putmsg(console_msg_t *cm)
 257 {
 258         int busy, spl;
 259         ssize_t res;
 260
 261         ASSERT(taskq_member(console_taskq, curthread));
 262
 263         if (rconsvp == NULL || panicstr ||
 264             vn_rdwr(UIO_WRITE, console_vnode, cm->cm_text, strlen(cm->cm_text),
 265             0, UIO_SYSSPACE, FAPPEND, (rlim64_t)LOG_HIWAT, kcred, &res) != 0) {
 266
 267                 busy = console_hold();
 268                 spl = console_enter(busy);
 269
 270                 prom_printf("%s", cm->cm_text);
 271
 272                 console_exit(busy, spl);
 273                 console_rele();
 274         }
 275
 276         kmem_free(cm, cm->cm_size);
 277 }
 278
 279 void
 280 console_vprintf(const char *fmt, va_list adx)
 281 {
 282         console_msg_t *cm;
 283         size_t len = vsnprintf(NULL, 0, fmt, adx);
 284         int busy, spl;
 285
 286         if (console_taskq != NULL && rconsvp != NULL && panicstr == NULL &&
 287             (cm = kmem_alloc(sizeof (*cm) + len, KM_NOSLEEP)) != NULL) {
 288                 cm->cm_size = sizeof (*cm) + len;
 289                 (void) vsnprintf(cm->cm_text, len + 1, fmt, adx);
 290                 if (taskq_dispatch(console_taskq, (task_func_t *)console_putmsg,
 291                     cm, TQ_NOSLEEP) != 0)
 292                         return;
 293                 kmem_free(cm, cm->cm_size);
 294         }
 295
 296         busy = console_hold();
 297         spl = console_enter(busy);
 298
 299         prom_vprintf(fmt, adx);
 300
 301         console_exit(busy, spl);
 302         console_rele();
 303 }
 304
 305 /*PRINTFLIKE1*/
 306 void
 307 console_printf(const char *fmt, ...)
 308 {
 309         va_list adx;
 310
 311         va_start(adx, fmt);
 312         console_vprintf(fmt, adx);
 313         va_end(adx);
 314 }
 315
 316 /*
 317  * Avoid calling this function.
 318  *
 319  * Nothing in the kernel besides the wscons driver (wc) uses this
 320  * function. It may hopefully one day be removed altogether.
 321  * If a wayward module calls this they will pass through to PROM,
 322  * get redirected into the kernel emulator as appropriate.
 323  */
 324 void
 325 console_puts(const char *s, size_t n)
 326 {
 327         int busy, spl;
 328
 329         busy = console_hold();
 330         spl = console_enter(busy);
 331
 332         prom_writestr(s, n);
 333
 334         console_exit(busy, spl);
 335         console_rele();
 336 }
 337
 338 /*
 339  * Let this function just go straight through to the PROM, since
 340  * we are called in early boot prior to the kernel terminal
 341  * emulator being available, and prior to the PROM stdout redirect
 342  * vector being set.
 343  */
 344 static void
 345 console_putc(int c)
 346 {
 347         int busy = console_hold();
 348         int spl = console_enter(busy);
 349
 350         if (c == '\n')
 351                 prom_putchar('\r');
 352         prom_putchar(c);
 353
 354         console_exit(busy, spl);
 355         console_rele();
 356 }
 357
 358 /*
 359  * Read a string from the console device.  We only permit synchronous
 360  * conversation between the kernel and a console user early in boot prior to
 361  * the initialization of rconsvp.
 362  */
 363 void
 364 console_gets(char *s, size_t len)
 365 {
 366         char *p = s;
 367         char *q = s + len - 1;
 368         int c;
 369
 370         ASSERT(rconsvp == NULL);
 371         (void) console_hold();
 372
 373         for (;;) {
 374                 switch (c = (prom_getchar() & 0x7f)) {
 375                 case 0x7f: /* DEL */
 376                         if (p == s)
 377                                 break;
 378                         console_putc(c);
 379                         c = '\b';
 380                         /*FALLTHRU*/
 381
 382                 case '\b':
 383                         if (p == s)
 384                                 break;
 385                         console_putc('\b');
 386                         console_putc(' ');
 387                         /*FALLTHRU*/
 388
 389                 case '#': /* historical backspace alias */
 390                         console_putc(c);
 391                         if (p > s)
 392                                 p--;
 393                         break;
 394
 395                 case CTRL('u'):
 396                         console_putc(c);
 397                         console_putc('\n');
 398                         p = s;
 399                         break;
 400
 401                 case '\r':
 402                 case '\n':
 403                         console_putc('\n');
 404                         goto done;
 405
 406                 default:
 407                         if (p < q) {
 408                                 console_putc(c);
 409                                 *p++ = c;
 410                         } else
 411                                 console_putc('\a');
 412                 }
 413         }
 414 done:
 415         console_rele();
 416         *p = '\0';
 417 }
 418
 419 /*
 420  * Read a character from the console device.  Synchronous conversation between
 421  * the kernel and a console user is only permitted early in boot prior to the
 422  * initialization of rconsvp.
 423  */
 424 int
 425 console_getc(void)
 426 {
 427         int c;
 428
 429         ASSERT(rconsvp == NULL);
 430         c = prom_getchar();
 431
 432         if (c == '\r')
 433                 c = '\n';
 434
 435         console_putc(c);
 436         return (c);
 437 }