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
console_hold(void)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
console_rele(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
console_getprop(dev_t dev,dev_info_t * dip,char * name,ushort_t * sp)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
console_get_size(ushort_t * r,ushort_t * c,ushort_t * x,ushort_t * y)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
console_putmsg(console_msg_t * cm)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
console_vprintf(const char * fmt,va_list adx)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
console_printf(const char * fmt,...)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
console_puts(const char * s,size_t n)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
console_putc(int c)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
console_gets(char * s,size_t len)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
console_getc(void)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 }
438