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