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
  40 #include <sys/cdefs.h>
  41 #include "opt_ddb.h"
  42 #include "opt_syscons.h"
  43
  44 #include <sys/param.h>
  45 #include <sys/systm.h>
  46 #include <sys/lock.h>
  47 #include <sys/mutex.h>
  48 #include <sys/conf.h>
  49 #include <sys/cons.h>
  50 #include <sys/fcntl.h>
  51 #include <sys/kbio.h>
  52 #include <sys/kdb.h>
  53 #include <sys/kernel.h>
  54 #include <sys/malloc.h>
  55 #include <sys/msgbuf.h>
  56 #include <sys/namei.h>
  57 #include <sys/priv.h>
  58 #include <sys/proc.h>
  59 #include <sys/queue.h>
  60 #include <sys/reboot.h>
  61 #include <sys/sysctl.h>
  62 #include <sys/sbuf.h>
  63 #include <sys/tslog.h>
  64 #include <sys/tty.h>
  65 #include <sys/uio.h>
  66 #include <sys/vnode.h>
  67
  68 #include <ddb/ddb.h>
  69
  70 #include <dev/kbd/kbdreg.h>
  71
  72 #include <machine/cpu.h>
  73 #include <machine/clock.h>
  74
  75 /*
  76  * Check for 'options EARLY_PRINTF' that may have been used in old kernel
  77  * config files. If you are hitting this error you should update your
  78  * config to use 'options EARLY_PRINTF=<device name>', e.g. with the
  79  * Arm pl011 use:
  80  *
  81  * options EARLY_PRINTF=pl011
  82  */
  83 #if CHECK_EARLY_PRINTF(1)
  84 #error Update your config to use 'options EARLY_PRINTF=<device name>'
  85 #endif
  86
  87 static MALLOC_DEFINE(M_TTYCONS, "tty console", "tty console handling");
  88
  89 struct cn_device {
  90         STAILQ_ENTRY(cn_device) cnd_next;
  91         struct          consdev *cnd_cn;
  92 };
  93
  94 #define CNDEVPATHMAX    32
  95 #define CNDEVTAB_SIZE   4
  96 static struct cn_device cn_devtab[CNDEVTAB_SIZE];
  97 static STAILQ_HEAD(, cn_device) cn_devlist =
  98     STAILQ_HEAD_INITIALIZER(cn_devlist);
  99
 100 int     cons_avail_mask = 0;    /* Bit mask. Each registered low level console
 101                                  * which is currently unavailable for inpit
 102                                  * (i.e., if it is in graphics mode) will have
 103                                  * this bit cleared.
 104                                  */
 105
 106 int cn_mute;
 107 SYSCTL_INT(_kern, OID_AUTO, consmute, CTLFLAG_RW, &cn_mute, 0,
 108     "State of the console muting");
 109
 110 static char *consbuf;                   /* buffer used by `consmsgbuf' */
 111 static struct callout conscallout;      /* callout for outputting to constty */
 112 struct msgbuf consmsgbuf;               /* message buffer for console tty */
 113 static bool console_pausing;            /* pause after each line during probe */
 114 static const char console_pausestr[] =
 115 "<pause; press any key to proceed to next line or '.' to end pause mode>";
 116 struct tty *constty;                    /* pointer to console "window" tty */
 117 static struct mtx constty_mtx;          /* Mutex for constty assignment. */
 118 MTX_SYSINIT(constty_mtx, &constty_mtx, "constty_mtx", MTX_DEF);
 119 static struct mtx cnputs_mtx;           /* Mutex for cnputs(). */
 120 MTX_SYSINIT(cnputs_mtx, &cnputs_mtx, "cnputs_mtx", MTX_SPIN | MTX_NOWITNESS);
 121
 122 static void constty_timeout(void *arg);
 123
 124 static struct consdev cons_consdev;
 125 DATA_SET(cons_set, cons_consdev);
 126 SET_DECLARE(cons_set, struct consdev);
 127
 128 /*
 129  * Stub for configurations that don't actually have a keyboard driver. Inclusion
 130  * of kbd.c is contingent on any number of keyboard/console drivers being
 131  * present in the kernel; rather than trying to catch them all, we'll just
 132  * maintain this weak kbdinit that will be overridden by the strong version in
 133  * kbd.c if it's present.
 134  */
 135 __weak_symbol void
 136 kbdinit(void)
 137 {
 138
 139 }
 140
 141 static void
 142 mute_console(void *data __unused)
 143 {
 144
 145         if ((boothowto & (RB_MUTEMSGS | RB_VERBOSE)) == RB_MUTEMSGS) {
 146                 printf("-- Muting boot messages --\n");
 147                 cn_mute = 1;
 148         }
 149 }
 150
 151 SYSINIT(mute_console, SI_SUB_COPYRIGHT, SI_ORDER_ANY, mute_console, NULL);
 152
 153 void
 154 cninit(void)
 155 {
 156         struct consdev *best_cn, *cn, **list;
 157
 158         TSENTER();
 159         /*
 160          * Check if we should mute the console (for security reasons perhaps)
 161          * It can be changes dynamically using sysctl kern.consmute
 162          * once we are up and going.
 163          *
 164          */
 165         cn_mute = ((boothowto & (RB_MUTE
 166                         |RB_SINGLE
 167                         |RB_VERBOSE
 168                         |RB_ASKNAME)) == RB_MUTE);
 169
 170         /*
 171          * Bring up the kbd layer just in time for cnprobe.  Console drivers
 172          * have a dependency on kbd being ready, so this fits nicely between the
 173          * machdep callers of cninit() and MI probing/initialization of consoles
 174          * here.
 175          */
 176         kbdinit();
 177
 178         /*
 179          * Find the first console with the highest priority.
 180          */
 181         best_cn = NULL;
 182         SET_FOREACH(list, cons_set) {
 183                 cn = *list;
 184                 cnremove(cn);
 185                 /* Skip cons_consdev. */
 186                 if (cn->cn_ops == NULL)
 187                         continue;
 188                 cn->cn_ops->cn_probe(cn);
 189                 if (cn->cn_pri == CN_DEAD)
 190                         continue;
 191                 if (best_cn == NULL || cn->cn_pri > best_cn->cn_pri)
 192                         best_cn = cn;
 193                 if (boothowto & RB_MULTIPLE) {
 194                         /*
 195                          * Initialize console, and attach to it.
 196                          */
 197                         cn->cn_ops->cn_init(cn);
 198                         cnadd(cn);
 199                 }
 200         }
 201         if (best_cn == NULL)
 202                 return;
 203         if ((boothowto & RB_MULTIPLE) == 0) {
 204                 best_cn->cn_ops->cn_init(best_cn);
 205                 cnadd(best_cn);
 206         }
 207         if (boothowto & RB_PAUSE)
 208                 console_pausing = true;
 209         /*
 210          * Make the best console the preferred console.
 211          */
 212         cnselect(best_cn);
 213
 214 #ifdef EARLY_PRINTF
 215         /*
 216          * Release early console.
 217          */
 218         early_putc = NULL;
 219 #endif
 220         TSEXIT();
 221 }
 222
 223 void
 224 cninit_finish(void)
 225 {
 226         console_pausing = false;
 227 }
 228
 229 /* add a new physical console to back the virtual console */
 230 int
 231 cnadd(struct consdev *cn)
 232 {
 233         struct cn_device *cnd;
 234         int i;
 235
 236         STAILQ_FOREACH(cnd, &cn_devlist, cnd_next)
 237                 if (cnd->cnd_cn == cn)
 238                         return (0);
 239         for (i = 0; i < CNDEVTAB_SIZE; i++) {
 240                 cnd = &cn_devtab[i];
 241                 if (cnd->cnd_cn == NULL)
 242                         break;
 243         }
 244         if (cnd->cnd_cn != NULL)
 245                 return (ENOMEM);
 246         cnd->cnd_cn = cn;
 247         if (cn->cn_name[0] == '\0') {
 248                 /* XXX: it is unclear if/where this print might output */
 249                 printf("WARNING: console at %p has no name\n", cn);
 250         }
 251         STAILQ_INSERT_TAIL(&cn_devlist, cnd, cnd_next);
 252         if (STAILQ_FIRST(&cn_devlist) == cnd)
 253                 ttyconsdev_select(cnd->cnd_cn->cn_name);
 254
 255         /* Add device to the active mask. */
 256         cnavailable(cn, (cn->cn_flags & CN_FLAG_NOAVAIL) == 0);
 257
 258         return (0);
 259 }
 260
 261 void
 262 cnremove(struct consdev *cn)
 263 {
 264         struct cn_device *cnd;
 265         int i;
 266
 267         STAILQ_FOREACH(cnd, &cn_devlist, cnd_next) {
 268                 if (cnd->cnd_cn != cn)
 269                         continue;
 270                 if (STAILQ_FIRST(&cn_devlist) == cnd)
 271                         ttyconsdev_select(NULL);
 272                 STAILQ_REMOVE(&cn_devlist, cnd, cn_device, cnd_next);
 273                 cnd->cnd_cn = NULL;
 274
 275                 /* Remove this device from available mask. */
 276                 for (i = 0; i < CNDEVTAB_SIZE; i++)
 277                         if (cnd == &cn_devtab[i]) {
 278                                 cons_avail_mask &= ~(1 << i);
 279                                 break;
 280                         }
 281 #if 0
 282                 /*
 283                  * XXX
 284                  * syscons gets really confused if console resources are
 285                  * freed after the system has initialized.
 286                  */
 287                 if (cn->cn_term != NULL)
 288                         cn->cn_ops->cn_term(cn);
 289 #endif
 290                 return;
 291         }
 292 }
 293
 294 void
 295 cnselect(struct consdev *cn)
 296 {
 297         struct cn_device *cnd;
 298
 299         STAILQ_FOREACH(cnd, &cn_devlist, cnd_next) {
 300                 if (cnd->cnd_cn != cn)
 301                         continue;
 302                 if (cnd == STAILQ_FIRST(&cn_devlist))
 303                         return;
 304                 STAILQ_REMOVE(&cn_devlist, cnd, cn_device, cnd_next);
 305                 STAILQ_INSERT_HEAD(&cn_devlist, cnd, cnd_next);
 306                 ttyconsdev_select(cnd->cnd_cn->cn_name);
 307                 return;
 308         }
 309 }
 310
 311 void
 312 cnavailable(struct consdev *cn, int available)
 313 {
 314         int i;
 315
 316         for (i = 0; i < CNDEVTAB_SIZE; i++) {
 317                 if (cn_devtab[i].cnd_cn == cn)
 318                         break;
 319         }
 320         if (available) {
 321                 if (i < CNDEVTAB_SIZE)
 322                         cons_avail_mask |= (1 << i);
 323                 cn->cn_flags &= ~CN_FLAG_NOAVAIL;
 324         } else {
 325                 if (i < CNDEVTAB_SIZE)
 326                         cons_avail_mask &= ~(1 << i);
 327                 cn->cn_flags |= CN_FLAG_NOAVAIL;
 328         }
 329 }
 330
 331 int
 332 cnunavailable(void)
 333 {
 334
 335         return (cons_avail_mask == 0);
 336 }
 337
 338 /*
 339  * sysctl_kern_console() provides output parseable in conscontrol(1).
 340  */
 341 static int
 342 sysctl_kern_console(SYSCTL_HANDLER_ARGS)
 343 {
 344         struct cn_device *cnd;
 345         struct consdev *cp, **list;
 346         char *p;
 347         bool delete;
 348         int error;
 349         struct sbuf *sb;
 350
 351         sb = sbuf_new(NULL, NULL, CNDEVPATHMAX * 2, SBUF_AUTOEXTEND |
 352             SBUF_INCLUDENUL);
 353         if (sb == NULL)
 354                 return (ENOMEM);
 355         sbuf_clear(sb);
 356         STAILQ_FOREACH(cnd, &cn_devlist, cnd_next)
 357                 sbuf_printf(sb, "%s,", cnd->cnd_cn->cn_name);
 358         sbuf_putc(sb, '/');
 359         SET_FOREACH(list, cons_set) {
 360                 cp = *list;
 361                 if (cp->cn_name[0] != '\0')
 362                         sbuf_printf(sb, "%s,", cp->cn_name);
 363         }
 364         sbuf_finish(sb);
 365         error = sysctl_handle_string(oidp, sbuf_data(sb), sbuf_len(sb), req);
 366         if (error == 0 && req->newptr != NULL) {
 367                 p = sbuf_data(sb);
 368                 error = ENXIO;
 369                 delete = false;
 370                 if (*p == '-') {
 371                         delete = true;
 372                         p++;
 373                 }
 374                 SET_FOREACH(list, cons_set) {
 375                         cp = *list;
 376                         if (strcmp(p, cp->cn_name) != 0)
 377                                 continue;
 378                         if (delete) {
 379                                 cnremove(cp);
 380                                 error = 0;
 381                         } else {
 382                                 error = cnadd(cp);
 383                                 if (error == 0)
 384                                         cnselect(cp);
 385                         }
 386                         break;
 387                 }
 388         }
 389         sbuf_delete(sb);
 390         return (error);
 391 }
 392
 393 SYSCTL_PROC(_kern, OID_AUTO, console,
 394     CTLTYPE_STRING | CTLFLAG_RW | CTLFLAG_NEEDGIANT, 0, 0,
 395     sysctl_kern_console, "A",
 396     "Console device control");
 397
 398 void
 399 cngrab(void)
 400 {
 401         struct cn_device *cnd;
 402         struct consdev *cn;
 403
 404         STAILQ_FOREACH(cnd, &cn_devlist, cnd_next) {
 405                 cn = cnd->cnd_cn;
 406                 if (!kdb_active || !(cn->cn_flags & CN_FLAG_NODEBUG))
 407                         cn->cn_ops->cn_grab(cn);
 408         }
 409 }
 410
 411 void
 412 cnungrab(void)
 413 {
 414         struct cn_device *cnd;
 415         struct consdev *cn;
 416
 417         STAILQ_FOREACH(cnd, &cn_devlist, cnd_next) {
 418                 cn = cnd->cnd_cn;
 419                 if (!kdb_active || !(cn->cn_flags & CN_FLAG_NODEBUG))
 420                         cn->cn_ops->cn_ungrab(cn);
 421         }
 422 }
 423
 424 void
 425 cnresume(void)
 426 {
 427         struct cn_device *cnd;
 428         struct consdev *cn;
 429
 430         STAILQ_FOREACH(cnd, &cn_devlist, cnd_next) {
 431                 cn = cnd->cnd_cn;
 432                 if (cn->cn_ops->cn_resume != NULL)
 433                         cn->cn_ops->cn_resume(cn);
 434         }
 435 }
 436
 437 /*
 438  * Low level console routines.
 439  */
 440 int
 441 cngetc(void)
 442 {
 443         int c;
 444
 445         if (cn_mute)
 446                 return (-1);
 447         while ((c = cncheckc()) == -1)
 448                 cpu_spinwait();
 449         if (c == '\r')
 450                 c = '\n';               /* console input is always ICRNL */
 451         return (c);
 452 }
 453
 454 int
 455 cncheckc(void)
 456 {
 457         struct cn_device *cnd;
 458         struct consdev *cn;
 459         int c;
 460
 461         if (cn_mute)
 462                 return (-1);
 463         STAILQ_FOREACH(cnd, &cn_devlist, cnd_next) {
 464                 cn = cnd->cnd_cn;
 465                 if (!kdb_active || !(cn->cn_flags & CN_FLAG_NODEBUG)) {
 466                         c = cn->cn_ops->cn_getc(cn);
 467                         if (c != -1)
 468                                 return (c);
 469                 }
 470         }
 471         return (-1);
 472 }
 473
 474 void
 475 cngets(char *cp, size_t size, int visible)
 476 {
 477         char *lp, *end;
 478         int c;
 479
 480         cngrab();
 481
 482         lp = cp;
 483         end = cp + size - 1;
 484         for (;;) {
 485                 c = cngetc() & 0177;
 486                 switch (c) {
 487                 case '\n':
 488                 case '\r':
 489                         cnputc(c);
 490                         *lp = '\0';
 491                         cnungrab();
 492                         return;
 493                 case '\b':
 494                 case '\177':
 495                         if (lp > cp) {
 496                                 if (visible)
 497                                         cnputs("\b \b");
 498                                 lp--;
 499                         }
 500                         continue;
 501                 case '\0':
 502                         continue;
 503                 default:
 504                         if (lp < end) {
 505                                 switch (visible) {
 506                                 case GETS_NOECHO:
 507                                         break;
 508                                 case GETS_ECHOPASS:
 509                                         cnputc('*');
 510                                         break;
 511                                 default:
 512                                         cnputc(c);
 513                                         break;
 514                                 }
 515                                 *lp++ = c;
 516                         }
 517                 }
 518         }
 519 }
 520
 521 void
 522 cnputc(int c)
 523 {
 524         struct cn_device *cnd;
 525         struct consdev *cn;
 526         const char *cp;
 527
 528 #ifdef EARLY_PRINTF
 529         if (early_putc != NULL) {
 530                 if (c == '\n')
 531                         early_putc('\r');
 532                 early_putc(c);
 533                 return;
 534         }
 535 #endif
 536
 537         if (cn_mute || c == '\0')
 538                 return;
 539         STAILQ_FOREACH(cnd, &cn_devlist, cnd_next) {
 540                 cn = cnd->cnd_cn;
 541                 if (!kdb_active || !(cn->cn_flags & CN_FLAG_NODEBUG)) {
 542                         if (c == '\n')
 543                                 cn->cn_ops->cn_putc(cn, '\r');
 544                         cn->cn_ops->cn_putc(cn, c);
 545                 }
 546         }
 547         if (console_pausing && c == '\n' && !kdb_active) {
 548                 for (cp = console_pausestr; *cp != '\0'; cp++)
 549                         cnputc(*cp);
 550                 cngrab();
 551                 if (cngetc() == '.')
 552                         console_pausing = false;
 553                 cnungrab();
 554                 cnputc('\r');
 555                 for (cp = console_pausestr; *cp != '\0'; cp++)
 556                         cnputc(' ');
 557                 cnputc('\r');
 558         }
 559 }
 560
 561 void
 562 cnputsn(const char *p, size_t n)
 563 {
 564         size_t i;
 565         bool unlock_reqd = false;
 566
 567         if (mtx_initialized(&cnputs_mtx)) {
 568                 /*
 569                  * NOTE: Debug prints and/or witness printouts in
 570                  * console driver clients can cause the "cnputs_mtx"
 571                  * mutex to recurse. Simply return if that happens.
 572                  */
 573                 if (mtx_owned(&cnputs_mtx))
 574                         return;
 575                 mtx_lock_spin(&cnputs_mtx);
 576                 unlock_reqd = true;
 577         }
 578
 579         for (i = 0; i < n; i++)
 580                 cnputc(p[i]);
 581
 582         if (unlock_reqd)
 583                 mtx_unlock_spin(&cnputs_mtx);
 584 }
 585
 586 void
 587 cnputs(const char *p)
 588 {
 589         cnputsn(p, strlen(p));
 590 }
 591
 592 static unsigned int consmsgbuf_size = 65536;
 593 SYSCTL_UINT(_kern, OID_AUTO, consmsgbuf_size, CTLFLAG_RWTUN, &consmsgbuf_size,
 594     0, "Console tty buffer size");
 595
 596 /*
 597  * Redirect console output to a tty.
 598  */
 599 int
 600 constty_set(struct tty *tp)
 601 {
 602         int size = consmsgbuf_size;
 603         void *buf = NULL;
 604
 605         tty_assert_locked(tp);
 606         if (constty == tp)
 607                 return (0);
 608         if (constty != NULL)
 609                 return (EBUSY);
 610
 611         if (consbuf == NULL) {
 612                 tty_unlock(tp);
 613                 buf = malloc(size, M_TTYCONS, M_WAITOK);
 614                 tty_lock(tp);
 615         }
 616         mtx_lock(&constty_mtx);
 617         if (constty != NULL) {
 618                 mtx_unlock(&constty_mtx);
 619                 free(buf, M_TTYCONS);
 620                 return (EBUSY);
 621         }
 622         if (consbuf == NULL) {
 623                 consbuf = buf;
 624                 msgbuf_init(&consmsgbuf, buf, size);
 625         } else
 626                 free(buf, M_TTYCONS);
 627         constty = tp;
 628         mtx_unlock(&constty_mtx);
 629
 630         callout_init_mtx(&conscallout, tty_getlock(tp), 0);
 631         constty_timeout(tp);
 632         return (0);
 633 }
 634
 635 /*
 636  * Disable console redirection to a tty.
 637  */
 638 int
 639 constty_clear(struct tty *tp)
 640 {
 641         int c;
 642
 643         tty_assert_locked(tp);
 644         if (constty != tp)
 645                 return (ENXIO);
 646         callout_stop(&conscallout);
 647         mtx_lock(&constty_mtx);
 648         constty = NULL;
 649         mtx_unlock(&constty_mtx);
 650         while ((c = msgbuf_getchar(&consmsgbuf)) != -1)
 651                 cnputc(c);
 652         /* We never free consbuf because it can still be in use. */
 653         return (0);
 654 }
 655
 656 /* Times per second to check for pending console tty messages. */
 657 static int constty_wakeups_per_second = 15;
 658 SYSCTL_INT(_kern, OID_AUTO, constty_wakeups_per_second, CTLFLAG_RW,
 659     &constty_wakeups_per_second, 0,
 660     "Times per second to check for pending console tty messages");
 661
 662 static void
 663 constty_timeout(void *arg)
 664 {
 665         struct tty *tp = arg;
 666         int c;
 667
 668         tty_assert_locked(tp);
 669         while ((c = msgbuf_getchar(&consmsgbuf)) != -1) {
 670                 if (tty_putchar(tp, c) < 0) {
 671                         constty_clear(tp);
 672                         return;
 673                 }
 674         }
 675         callout_reset_sbt(&conscallout, SBT_1S / constty_wakeups_per_second,
 676             0, constty_timeout, tp, C_PREL(1));
 677 }
 678
 679 /*
 680  * Sysbeep(), if we have hardware for it
 681  */
 682
 683 #ifdef HAS_TIMER_SPKR
 684
 685 static bool beeping;
 686 static struct callout beeping_timer;
 687
 688 static void
 689 sysbeepstop(void *chan)
 690 {
 691
 692         timer_spkr_release();
 693         beeping = false;
 694 }
 695
 696 int
 697 sysbeep(int pitch, sbintime_t duration)
 698 {
 699
 700         if (timer_spkr_acquire()) {
 701                 if (!beeping) {
 702                         /* Something else owns it. */
 703                         return (EBUSY);
 704                 }
 705         }
 706         timer_spkr_setfreq(pitch);
 707         if (!beeping) {
 708                 beeping = true;
 709                 callout_reset_sbt(&beeping_timer, duration, 0, sysbeepstop,
 710                     NULL, C_PREL(5));
 711         }
 712         return (0);
 713 }
 714
 715 static void
 716 sysbeep_init(void *unused)
 717 {
 718
 719         callout_init(&beeping_timer, 1);
 720 }
 721 SYSINIT(sysbeep, SI_SUB_SOFTINTR, SI_ORDER_ANY, sysbeep_init, NULL);
 722 #else
 723
 724 /*
 725  * No hardware, no sound
 726  */
 727
 728 int
 729 sysbeep(int pitch __unused, sbintime_t duration __unused)
 730 {
 731
 732         return (ENODEV);
 733 }
 734
 735 #endif
 736
 737 /*
 738  * Temporary support for sc(4) to vt(4) transition.
 739  */
 740 static unsigned vty_prefer;
 741 static char vty_name[16];
 742 SYSCTL_STRING(_kern, OID_AUTO, vty, CTLFLAG_RDTUN | CTLFLAG_NOFETCH, vty_name,
 743     0, "Console vty driver");
 744
 745 int
 746 vty_enabled(unsigned vty)
 747 {
 748         static unsigned vty_selected = 0;
 749
 750         if (vty_selected == 0) {
 751                 TUNABLE_STR_FETCH("kern.vty", vty_name, sizeof(vty_name));
 752                 do {
 753 #if defined(DEV_SC)
 754                         if (strcmp(vty_name, "sc") == 0) {
 755                                 vty_selected = VTY_SC;
 756                                 break;
 757                         }
 758 #endif
 759 #if defined(DEV_VT)
 760                         if (strcmp(vty_name, "vt") == 0) {
 761                                 vty_selected = VTY_VT;
 762                                 break;
 763                         }
 764 #endif
 765                         if (vty_prefer != 0) {
 766                                 vty_selected = vty_prefer;
 767                                 break;
 768                         }
 769 #if defined(DEV_VT)
 770                         vty_selected = VTY_VT;
 771 #elif defined(DEV_SC)
 772                         vty_selected = VTY_SC;
 773 #endif
 774                 } while (0);
 775
 776                 if (vty_selected == VTY_VT)
 777                         strcpy(vty_name, "vt");
 778                 else if (vty_selected == VTY_SC)
 779                         strcpy(vty_name, "sc");
 780         }
 781         return ((vty_selected & vty) != 0);
 782 }
 783
 784 void
 785 vty_set_preferred(unsigned vty)
 786 {
 787
 788         vty_prefer = vty;
 789 #if !defined(DEV_SC)
 790         vty_prefer &= ~VTY_SC;
 791 #endif
 792 #if !defined(DEV_VT)
 793         vty_prefer &= ~VTY_VT;
 794 #endif
 795 }