FreeBSD/Linux Kernel Cross Reference
sys/kern/kern_cons.c
1 /*-
2 * SPDX-License-Identifier: BSD-3-Clause
3 *
4 * Copyright (c) 1988 University of Utah.
5 * Copyright (c) 1991 The Regents of the University of California.
6 * Copyright (c) 1999 Michael Smith
7 * Copyright (c) 2005 Pawel Jakub Dawidek <pjd@FreeBSD.org>
8 *
9 * All rights reserved.
10 *
11 * This code is derived from software contributed to Berkeley by
12 * the Systems Programming Group of the University of Utah Computer
13 * Science Department.
14 *
15 * Redistribution and use in source and binary forms, with or without
16 * modification, are permitted provided that the following conditions
17 * are met:
18 * 1. Redistributions of source code must retain the above copyright
19 * notice, this list of conditions and the following disclaimer.
20 * 2. Redistributions in binary form must reproduce the above copyright
21 * notice, this list of conditions and the following disclaimer in the
22 * documentation and/or other materials provided with the distribution.
23 * 3. Neither the name of the University nor the names of its contributors
24 * may be used to endorse or promote products derived from this software
25 * without specific prior written permission.
26 *
27 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
28 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
29 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
30 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
31 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
32 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
33 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
34 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
35 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
36 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
37 * SUCH DAMAGE.
38 *
39 * from: @(#)cons.c 7.2 (Berkeley) 5/9/91
40 */
41
42 #include <sys/cdefs.h>
43 __FBSDID("$FreeBSD: releng/12.0/sys/kern/kern_cons.c 334340 2018-05-29 16:16:24Z avg $");
44
45 #include "opt_ddb.h"
46 #include "opt_syscons.h"
47
48 #include <sys/param.h>
49 #include <sys/systm.h>
50 #include <sys/lock.h>
51 #include <sys/mutex.h>
52 #include <sys/conf.h>
53 #include <sys/cons.h>
54 #include <sys/fcntl.h>
55 #include <sys/kdb.h>
56 #include <sys/kernel.h>
57 #include <sys/malloc.h>
58 #include <sys/msgbuf.h>
59 #include <sys/namei.h>
60 #include <sys/priv.h>
61 #include <sys/proc.h>
62 #include <sys/queue.h>
63 #include <sys/reboot.h>
64 #include <sys/sysctl.h>
65 #include <sys/sbuf.h>
66 #include <sys/tty.h>
67 #include <sys/uio.h>
68 #include <sys/vnode.h>
69
70 #include <ddb/ddb.h>
71
72 #include <machine/cpu.h>
73 #include <machine/clock.h>
74
75 static MALLOC_DEFINE(M_TTYCONS, "tty console", "tty console handling");
76
77 struct cn_device {
78 STAILQ_ENTRY(cn_device) cnd_next;
79 struct consdev *cnd_cn;
80 };
81
82 #define CNDEVPATHMAX 32
83 #define CNDEVTAB_SIZE 4
84 static struct cn_device cn_devtab[CNDEVTAB_SIZE];
85 static STAILQ_HEAD(, cn_device) cn_devlist =
86 STAILQ_HEAD_INITIALIZER(cn_devlist);
87
88 int cons_avail_mask = 0; /* Bit mask. Each registered low level console
89 * which is currently unavailable for inpit
90 * (i.e., if it is in graphics mode) will have
91 * this bit cleared.
92 */
93 static int cn_mute;
94 static char *consbuf; /* buffer used by `consmsgbuf' */
95 static struct callout conscallout; /* callout for outputting to constty */
96 struct msgbuf consmsgbuf; /* message buffer for console tty */
97 static u_char console_pausing; /* pause after each line during probe */
98 static char *console_pausestr=
99 "<pause; press any key to proceed to next line or '.' to end pause mode>";
100 struct tty *constty; /* pointer to console "window" tty */
101 static struct mtx cnputs_mtx; /* Mutex for cnputs(). */
102 static int use_cnputs_mtx = 0; /* != 0 if cnputs_mtx locking reqd. */
103
104 static void constty_timeout(void *arg);
105
106 static struct consdev cons_consdev;
107 DATA_SET(cons_set, cons_consdev);
108 SET_DECLARE(cons_set, struct consdev);
109
110 void
111 cninit(void)
112 {
113 struct consdev *best_cn, *cn, **list;
114
115 /*
116 * Check if we should mute the console (for security reasons perhaps)
117 * It can be changes dynamically using sysctl kern.consmute
118 * once we are up and going.
119 *
120 */
121 cn_mute = ((boothowto & (RB_MUTE
122 |RB_SINGLE
123 |RB_VERBOSE
124 |RB_ASKNAME)) == RB_MUTE);
125
126 /*
127 * Find the first console with the highest priority.
128 */
129 best_cn = NULL;
130 SET_FOREACH(list, cons_set) {
131 cn = *list;
132 cnremove(cn);
133 /* Skip cons_consdev. */
134 if (cn->cn_ops == NULL)
135 continue;
136 cn->cn_ops->cn_probe(cn);
137 if (cn->cn_pri == CN_DEAD)
138 continue;
139 if (best_cn == NULL || cn->cn_pri > best_cn->cn_pri)
140 best_cn = cn;
141 if (boothowto & RB_MULTIPLE) {
142 /*
143 * Initialize console, and attach to it.
144 */
145 cn->cn_ops->cn_init(cn);
146 cnadd(cn);
147 }
148 }
149 if (best_cn == NULL)
150 return;
151 if ((boothowto & RB_MULTIPLE) == 0) {
152 best_cn->cn_ops->cn_init(best_cn);
153 cnadd(best_cn);
154 }
155 if (boothowto & RB_PAUSE)
156 console_pausing = 1;
157 /*
158 * Make the best console the preferred console.
159 */
160 cnselect(best_cn);
161
162 #ifdef EARLY_PRINTF
163 /*
164 * Release early console.
165 */
166 early_putc = NULL;
167 #endif
168 }
169
170 void
171 cninit_finish()
172 {
173 console_pausing = 0;
174 }
175
176 /* add a new physical console to back the virtual console */
177 int
178 cnadd(struct consdev *cn)
179 {
180 struct cn_device *cnd;
181 int i;
182
183 STAILQ_FOREACH(cnd, &cn_devlist, cnd_next)
184 if (cnd->cnd_cn == cn)
185 return (0);
186 for (i = 0; i < CNDEVTAB_SIZE; i++) {
187 cnd = &cn_devtab[i];
188 if (cnd->cnd_cn == NULL)
189 break;
190 }
191 if (cnd->cnd_cn != NULL)
192 return (ENOMEM);
193 cnd->cnd_cn = cn;
194 if (cn->cn_name[0] == '\0') {
195 /* XXX: it is unclear if/where this print might output */
196 printf("WARNING: console at %p has no name\n", cn);
197 }
198 STAILQ_INSERT_TAIL(&cn_devlist, cnd, cnd_next);
199 if (STAILQ_FIRST(&cn_devlist) == cnd)
200 ttyconsdev_select(cnd->cnd_cn->cn_name);
201
202 /* Add device to the active mask. */
203 cnavailable(cn, (cn->cn_flags & CN_FLAG_NOAVAIL) == 0);
204
205 return (0);
206 }
207
208 void
209 cnremove(struct consdev *cn)
210 {
211 struct cn_device *cnd;
212 int i;
213
214 STAILQ_FOREACH(cnd, &cn_devlist, cnd_next) {
215 if (cnd->cnd_cn != cn)
216 continue;
217 if (STAILQ_FIRST(&cn_devlist) == cnd)
218 ttyconsdev_select(NULL);
219 STAILQ_REMOVE(&cn_devlist, cnd, cn_device, cnd_next);
220 cnd->cnd_cn = NULL;
221
222 /* Remove this device from available mask. */
223 for (i = 0; i < CNDEVTAB_SIZE; i++)
224 if (cnd == &cn_devtab[i]) {
225 cons_avail_mask &= ~(1 << i);
226 break;
227 }
228 #if 0
229 /*
230 * XXX
231 * syscons gets really confused if console resources are
232 * freed after the system has initialized.
233 */
234 if (cn->cn_term != NULL)
235 cn->cn_ops->cn_term(cn);
236 #endif
237 return;
238 }
239 }
240
241 void
242 cnselect(struct consdev *cn)
243 {
244 struct cn_device *cnd;
245
246 STAILQ_FOREACH(cnd, &cn_devlist, cnd_next) {
247 if (cnd->cnd_cn != cn)
248 continue;
249 if (cnd == STAILQ_FIRST(&cn_devlist))
250 return;
251 STAILQ_REMOVE(&cn_devlist, cnd, cn_device, cnd_next);
252 STAILQ_INSERT_HEAD(&cn_devlist, cnd, cnd_next);
253 ttyconsdev_select(cnd->cnd_cn->cn_name);
254 return;
255 }
256 }
257
258 void
259 cnavailable(struct consdev *cn, int available)
260 {
261 int i;
262
263 for (i = 0; i < CNDEVTAB_SIZE; i++) {
264 if (cn_devtab[i].cnd_cn == cn)
265 break;
266 }
267 if (available) {
268 if (i < CNDEVTAB_SIZE)
269 cons_avail_mask |= (1 << i);
270 cn->cn_flags &= ~CN_FLAG_NOAVAIL;
271 } else {
272 if (i < CNDEVTAB_SIZE)
273 cons_avail_mask &= ~(1 << i);
274 cn->cn_flags |= CN_FLAG_NOAVAIL;
275 }
276 }
277
278 int
279 cnunavailable(void)
280 {
281
282 return (cons_avail_mask == 0);
283 }
284
285 /*
286 * sysctl_kern_console() provides output parseable in conscontrol(1).
287 */
288 static int
289 sysctl_kern_console(SYSCTL_HANDLER_ARGS)
290 {
291 struct cn_device *cnd;
292 struct consdev *cp, **list;
293 char *p;
294 int delete, error;
295 struct sbuf *sb;
296
297 sb = sbuf_new(NULL, NULL, CNDEVPATHMAX * 2, SBUF_AUTOEXTEND |
298 SBUF_INCLUDENUL);
299 if (sb == NULL)
300 return (ENOMEM);
301 sbuf_clear(sb);
302 STAILQ_FOREACH(cnd, &cn_devlist, cnd_next)
303 sbuf_printf(sb, "%s,", cnd->cnd_cn->cn_name);
304 sbuf_printf(sb, "/");
305 SET_FOREACH(list, cons_set) {
306 cp = *list;
307 if (cp->cn_name[0] != '\0')
308 sbuf_printf(sb, "%s,", cp->cn_name);
309 }
310 sbuf_finish(sb);
311 error = sysctl_handle_string(oidp, sbuf_data(sb), sbuf_len(sb), req);
312 if (error == 0 && req->newptr != NULL) {
313 p = sbuf_data(sb);
314 error = ENXIO;
315 delete = 0;
316 if (*p == '-') {
317 delete = 1;
318 p++;
319 }
320 SET_FOREACH(list, cons_set) {
321 cp = *list;
322 if (strcmp(p, cp->cn_name) != 0)
323 continue;
324 if (delete) {
325 cnremove(cp);
326 error = 0;
327 } else {
328 error = cnadd(cp);
329 if (error == 0)
330 cnselect(cp);
331 }
332 break;
333 }
334 }
335 sbuf_delete(sb);
336 return (error);
337 }
338
339 SYSCTL_PROC(_kern, OID_AUTO, console, CTLTYPE_STRING|CTLFLAG_RW,
340 0, 0, sysctl_kern_console, "A", "Console device control");
341
342 /*
343 * User has changed the state of the console muting.
344 * This may require us to open or close the device in question.
345 */
346 static int
347 sysctl_kern_consmute(SYSCTL_HANDLER_ARGS)
348 {
349 int error;
350
351 error = sysctl_handle_int(oidp, &cn_mute, 0, req);
352 if (error != 0 || req->newptr == NULL)
353 return (error);
354 return (error);
355 }
356
357 SYSCTL_PROC(_kern, OID_AUTO, consmute, CTLTYPE_INT|CTLFLAG_RW,
358 0, sizeof(cn_mute), sysctl_kern_consmute, "I",
359 "State of the console muting");
360
361 void
362 cngrab()
363 {
364 struct cn_device *cnd;
365 struct consdev *cn;
366
367 STAILQ_FOREACH(cnd, &cn_devlist, cnd_next) {
368 cn = cnd->cnd_cn;
369 if (!kdb_active || !(cn->cn_flags & CN_FLAG_NODEBUG))
370 cn->cn_ops->cn_grab(cn);
371 }
372 }
373
374 void
375 cnungrab()
376 {
377 struct cn_device *cnd;
378 struct consdev *cn;
379
380 STAILQ_FOREACH(cnd, &cn_devlist, cnd_next) {
381 cn = cnd->cnd_cn;
382 if (!kdb_active || !(cn->cn_flags & CN_FLAG_NODEBUG))
383 cn->cn_ops->cn_ungrab(cn);
384 }
385 }
386
387 void
388 cnresume()
389 {
390 struct cn_device *cnd;
391 struct consdev *cn;
392
393 STAILQ_FOREACH(cnd, &cn_devlist, cnd_next) {
394 cn = cnd->cnd_cn;
395 if (cn->cn_ops->cn_resume != NULL)
396 cn->cn_ops->cn_resume(cn);
397 }
398 }
399
400 /*
401 * Low level console routines.
402 */
403 int
404 cngetc(void)
405 {
406 int c;
407
408 if (cn_mute)
409 return (-1);
410 while ((c = cncheckc()) == -1)
411 cpu_spinwait();
412 if (c == '\r')
413 c = '\n'; /* console input is always ICRNL */
414 return (c);
415 }
416
417 int
418 cncheckc(void)
419 {
420 struct cn_device *cnd;
421 struct consdev *cn;
422 int c;
423
424 if (cn_mute)
425 return (-1);
426 STAILQ_FOREACH(cnd, &cn_devlist, cnd_next) {
427 cn = cnd->cnd_cn;
428 if (!kdb_active || !(cn->cn_flags & CN_FLAG_NODEBUG)) {
429 c = cn->cn_ops->cn_getc(cn);
430 if (c != -1)
431 return (c);
432 }
433 }
434 return (-1);
435 }
436
437 void
438 cngets(char *cp, size_t size, int visible)
439 {
440 char *lp, *end;
441 int c;
442
443 cngrab();
444
445 lp = cp;
446 end = cp + size - 1;
447 for (;;) {
448 c = cngetc() & 0177;
449 switch (c) {
450 case '\n':
451 case '\r':
452 cnputc(c);
453 *lp = '\0';
454 cnungrab();
455 return;
456 case '\b':
457 case '\177':
458 if (lp > cp) {
459 if (visible)
460 cnputs("\b \b");
461 lp--;
462 }
463 continue;
464 case '\0':
465 continue;
466 default:
467 if (lp < end) {
468 switch (visible) {
469 case GETS_NOECHO:
470 break;
471 case GETS_ECHOPASS:
472 cnputc('*');
473 break;
474 default:
475 cnputc(c);
476 break;
477 }
478 *lp++ = c;
479 }
480 }
481 }
482 }
483
484 void
485 cnputc(int c)
486 {
487 struct cn_device *cnd;
488 struct consdev *cn;
489 char *cp;
490
491 #ifdef EARLY_PRINTF
492 if (early_putc != NULL) {
493 if (c == '\n')
494 early_putc('\r');
495 early_putc(c);
496 return;
497 }
498 #endif
499
500 if (cn_mute || c == '\0')
501 return;
502 STAILQ_FOREACH(cnd, &cn_devlist, cnd_next) {
503 cn = cnd->cnd_cn;
504 if (!kdb_active || !(cn->cn_flags & CN_FLAG_NODEBUG)) {
505 if (c == '\n')
506 cn->cn_ops->cn_putc(cn, '\r');
507 cn->cn_ops->cn_putc(cn, c);
508 }
509 }
510 if (console_pausing && c == '\n' && !kdb_active) {
511 for (cp = console_pausestr; *cp != '\0'; cp++)
512 cnputc(*cp);
513 cngrab();
514 if (cngetc() == '.')
515 console_pausing = 0;
516 cnungrab();
517 cnputc('\r');
518 for (cp = console_pausestr; *cp != '\0'; cp++)
519 cnputc(' ');
520 cnputc('\r');
521 }
522 }
523
524 void
525 cnputs(char *p)
526 {
527 int c;
528 int unlock_reqd = 0;
529
530 if (use_cnputs_mtx) {
531 /*
532 * NOTE: Debug prints and/or witness printouts in
533 * console driver clients can cause the "cnputs_mtx"
534 * mutex to recurse. Simply return if that happens.
535 */
536 if (mtx_owned(&cnputs_mtx))
537 return;
538 mtx_lock_spin(&cnputs_mtx);
539 unlock_reqd = 1;
540 }
541
542 while ((c = *p++) != '\0')
543 cnputc(c);
544
545 if (unlock_reqd)
546 mtx_unlock_spin(&cnputs_mtx);
547 }
548
549 static int consmsgbuf_size = 8192;
550 SYSCTL_INT(_kern, OID_AUTO, consmsgbuf_size, CTLFLAG_RW, &consmsgbuf_size, 0,
551 "Console tty buffer size");
552
553 /*
554 * Redirect console output to a tty.
555 */
556 void
557 constty_set(struct tty *tp)
558 {
559 int size;
560
561 KASSERT(tp != NULL, ("constty_set: NULL tp"));
562 if (consbuf == NULL) {
563 size = consmsgbuf_size;
564 consbuf = malloc(size, M_TTYCONS, M_WAITOK);
565 msgbuf_init(&consmsgbuf, consbuf, size);
566 callout_init(&conscallout, 0);
567 }
568 constty = tp;
569 constty_timeout(NULL);
570 }
571
572 /*
573 * Disable console redirection to a tty.
574 */
575 void
576 constty_clear(void)
577 {
578 int c;
579
580 constty = NULL;
581 if (consbuf == NULL)
582 return;
583 callout_stop(&conscallout);
584 while ((c = msgbuf_getchar(&consmsgbuf)) != -1)
585 cnputc(c);
586 free(consbuf, M_TTYCONS);
587 consbuf = NULL;
588 }
589
590 /* Times per second to check for pending console tty messages. */
591 static int constty_wakeups_per_second = 5;
592 SYSCTL_INT(_kern, OID_AUTO, constty_wakeups_per_second, CTLFLAG_RW,
593 &constty_wakeups_per_second, 0,
594 "Times per second to check for pending console tty messages");
595
596 static void
597 constty_timeout(void *arg)
598 {
599 int c;
600
601 if (constty != NULL) {
602 tty_lock(constty);
603 while ((c = msgbuf_getchar(&consmsgbuf)) != -1) {
604 if (tty_putchar(constty, c) < 0) {
605 tty_unlock(constty);
606 constty = NULL;
607 break;
608 }
609 }
610
611 if (constty != NULL)
612 tty_unlock(constty);
613 }
614 if (constty != NULL) {
615 callout_reset(&conscallout, hz / constty_wakeups_per_second,
616 constty_timeout, NULL);
617 } else {
618 /* Deallocate the constty buffer memory. */
619 constty_clear();
620 }
621 }
622
623 static void
624 cn_drvinit(void *unused)
625 {
626
627 mtx_init(&cnputs_mtx, "cnputs_mtx", NULL, MTX_SPIN | MTX_NOWITNESS);
628 use_cnputs_mtx = 1;
629 }
630
631 SYSINIT(cndev, SI_SUB_DRIVERS, SI_ORDER_MIDDLE, cn_drvinit, NULL);
632
633 /*
634 * Sysbeep(), if we have hardware for it
635 */
636
637 #ifdef HAS_TIMER_SPKR
638
639 static int beeping;
640 static struct callout beeping_timer;
641
642 static void
643 sysbeepstop(void *chan)
644 {
645
646 timer_spkr_release();
647 beeping = 0;
648 }
649
650 int
651 sysbeep(int pitch, int period)
652 {
653
654 if (timer_spkr_acquire()) {
655 if (!beeping) {
656 /* Something else owns it. */
657 return (EBUSY);
658 }
659 }
660 timer_spkr_setfreq(pitch);
661 if (!beeping) {
662 beeping = period;
663 callout_reset(&beeping_timer, period, sysbeepstop, NULL);
664 }
665 return (0);
666 }
667
668 static void
669 sysbeep_init(void *unused)
670 {
671
672 callout_init(&beeping_timer, 1);
673 }
674 SYSINIT(sysbeep, SI_SUB_SOFTINTR, SI_ORDER_ANY, sysbeep_init, NULL);
675 #else
676
677 /*
678 * No hardware, no sound
679 */
680
681 int
682 sysbeep(int pitch __unused, int period __unused)
683 {
684
685 return (ENODEV);
686 }
687
688 #endif
689
690 /*
691 * Temporary support for sc(4) to vt(4) transition.
692 */
693 static unsigned vty_prefer;
694 static char vty_name[16];
695 SYSCTL_STRING(_kern, OID_AUTO, vty, CTLFLAG_RDTUN | CTLFLAG_NOFETCH, vty_name,
696 0, "Console vty driver");
697
698 int
699 vty_enabled(unsigned vty)
700 {
701 static unsigned vty_selected = 0;
702
703 if (vty_selected == 0) {
704 TUNABLE_STR_FETCH("kern.vty", vty_name, sizeof(vty_name));
705 do {
706 #if defined(DEV_SC)
707 if (strcmp(vty_name, "sc") == 0) {
708 vty_selected = VTY_SC;
709 break;
710 }
711 #endif
712 #if defined(DEV_VT)
713 if (strcmp(vty_name, "vt") == 0) {
714 vty_selected = VTY_VT;
715 break;
716 }
717 #endif
718 if (vty_prefer != 0) {
719 vty_selected = vty_prefer;
720 break;
721 }
722 #if defined(DEV_VT)
723 vty_selected = VTY_VT;
724 #elif defined(DEV_SC)
725 vty_selected = VTY_SC;
726 #endif
727 } while (0);
728
729 if (vty_selected == VTY_VT)
730 strcpy(vty_name, "vt");
731 else if (vty_selected == VTY_SC)
732 strcpy(vty_name, "sc");
733 }
734 return ((vty_selected & vty) != 0);
735 }
736
737 void
738 vty_set_preferred(unsigned vty)
739 {
740
741 vty_prefer = vty;
742 #if !defined(DEV_SC)
743 vty_prefer &= ~VTY_SC;
744 #endif
745 #if !defined(DEV_VT)
746 vty_prefer &= ~VTY_VT;
747 #endif
748 }
749
Cache object: eb3d5e62f73278e341ed75baccc5064b
|