2005-01-06 23:35:40 +00:00
|
|
|
/*-
|
1993-06-12 14:58:17 +00:00
|
|
|
* Copyright (c) 1988 University of Utah.
|
|
|
|
* Copyright (c) 1991 The Regents of the University of California.
|
|
|
|
* All rights reserved.
|
|
|
|
*
|
|
|
|
* This code is derived from software contributed to Berkeley by
|
|
|
|
* the Systems Programming Group of the University of Utah Computer
|
|
|
|
* Science Department.
|
|
|
|
*
|
|
|
|
* Redistribution and use in source and binary forms, with or without
|
|
|
|
* modification, are permitted provided that the following conditions
|
|
|
|
* are met:
|
|
|
|
* 1. Redistributions of source code must retain the above copyright
|
|
|
|
* notice, this list of conditions and the following disclaimer.
|
|
|
|
* 2. Redistributions in binary form must reproduce the above copyright
|
|
|
|
* notice, this list of conditions and the following disclaimer in the
|
|
|
|
* documentation and/or other materials provided with the distribution.
|
|
|
|
* 4. Neither the name of the University nor the names of its contributors
|
|
|
|
* may be used to endorse or promote products derived from this software
|
|
|
|
* without specific prior written permission.
|
|
|
|
*
|
|
|
|
* THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
|
|
|
|
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
|
|
|
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
|
|
|
* ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
|
|
|
|
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
|
|
|
|
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
|
|
|
|
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
|
|
|
|
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
|
|
|
|
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
|
|
|
|
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
|
|
|
|
* SUCH DAMAGE.
|
|
|
|
*
|
1993-10-16 14:15:10 +00:00
|
|
|
* from: @(#)cons.c 7.2 (Berkeley) 5/9/91
|
1993-06-12 14:58:17 +00:00
|
|
|
*/
|
|
|
|
|
2003-06-11 00:56:59 +00:00
|
|
|
#include <sys/cdefs.h>
|
|
|
|
__FBSDID("$FreeBSD$");
|
|
|
|
|
2001-12-11 10:21:26 +00:00
|
|
|
#include "opt_ddb.h"
|
|
|
|
|
1994-08-13 03:50:34 +00:00
|
|
|
#include <sys/param.h>
|
1994-05-25 09:21:21 +00:00
|
|
|
#include <sys/systm.h>
|
2006-11-01 04:54:51 +00:00
|
|
|
#include <sys/lock.h>
|
|
|
|
#include <sys/mutex.h>
|
1995-01-21 14:12:15 +00:00
|
|
|
#include <sys/conf.h>
|
2000-01-24 11:48:11 +00:00
|
|
|
#include <sys/cons.h>
|
2001-10-25 00:14:16 +00:00
|
|
|
#include <sys/fcntl.h>
|
2004-07-10 21:43:23 +00:00
|
|
|
#include <sys/kdb.h>
|
1995-12-08 11:19:42 +00:00
|
|
|
#include <sys/kernel.h>
|
2001-10-23 20:25:50 +00:00
|
|
|
#include <sys/malloc.h>
|
2003-06-22 02:54:33 +00:00
|
|
|
#include <sys/msgbuf.h>
|
2001-10-23 20:25:50 +00:00
|
|
|
#include <sys/namei.h>
|
2000-12-12 21:18:13 +00:00
|
|
|
#include <sys/proc.h>
|
2001-10-23 20:25:50 +00:00
|
|
|
#include <sys/queue.h>
|
1996-10-16 00:19:40 +00:00
|
|
|
#include <sys/reboot.h>
|
1995-12-09 20:39:47 +00:00
|
|
|
#include <sys/sysctl.h>
|
1994-08-13 03:50:34 +00:00
|
|
|
#include <sys/tty.h>
|
1998-03-28 10:33:27 +00:00
|
|
|
#include <sys/uio.h>
|
2001-10-23 20:25:50 +00:00
|
|
|
#include <sys/vnode.h>
|
1993-06-12 14:58:17 +00:00
|
|
|
|
2001-12-10 20:02:22 +00:00
|
|
|
#include <ddb/ddb.h>
|
|
|
|
|
1995-12-09 20:39:47 +00:00
|
|
|
#include <machine/cpu.h>
|
1993-06-12 14:58:17 +00:00
|
|
|
|
1995-12-08 11:19:42 +00:00
|
|
|
static d_open_t cnopen;
|
|
|
|
static d_close_t cnclose;
|
|
|
|
static d_read_t cnread;
|
|
|
|
static d_write_t cnwrite;
|
|
|
|
static d_ioctl_t cnioctl;
|
1997-09-14 03:19:42 +00:00
|
|
|
static d_poll_t cnpoll;
|
2001-02-15 16:34:11 +00:00
|
|
|
static d_kqfilter_t cnkqfilter;
|
1995-12-08 11:19:42 +00:00
|
|
|
|
1999-05-30 16:53:49 +00:00
|
|
|
static struct cdevsw cn_cdevsw = {
|
2004-02-21 21:10:55 +00:00
|
|
|
.d_version = D_VERSION,
|
2003-03-03 12:15:54 +00:00
|
|
|
.d_open = cnopen,
|
|
|
|
.d_close = cnclose,
|
|
|
|
.d_read = cnread,
|
|
|
|
.d_write = cnwrite,
|
|
|
|
.d_ioctl = cnioctl,
|
|
|
|
.d_poll = cnpoll,
|
|
|
|
.d_name = "console",
|
2004-02-21 21:10:55 +00:00
|
|
|
.d_flags = D_TTY | D_NEEDGIANT,
|
2003-03-03 12:15:54 +00:00
|
|
|
.d_kqfilter = cnkqfilter,
|
1998-08-23 08:26:42 +00:00
|
|
|
};
|
1995-12-08 11:19:42 +00:00
|
|
|
|
2001-10-23 20:25:50 +00:00
|
|
|
struct cn_device {
|
|
|
|
STAILQ_ENTRY(cn_device) cnd_next;
|
|
|
|
struct vnode *cnd_vp;
|
|
|
|
struct consdev *cnd_cn;
|
|
|
|
};
|
|
|
|
|
|
|
|
#define CNDEVPATHMAX 32
|
|
|
|
#define CNDEVTAB_SIZE 4
|
|
|
|
static struct cn_device cn_devtab[CNDEVTAB_SIZE];
|
|
|
|
static STAILQ_HEAD(, cn_device) cn_devlist =
|
|
|
|
STAILQ_HEAD_INITIALIZER(cn_devlist);
|
|
|
|
|
|
|
|
#define CND_INVALID(cnd, td) \
|
|
|
|
(cnd == NULL || cnd->cnd_vp == NULL || \
|
|
|
|
(cnd->cnd_vp->v_type == VBAD && !cn_devopen(cnd, td, 1)))
|
|
|
|
|
2004-06-17 17:16:53 +00:00
|
|
|
static dev_t cn_udev_t;
|
2006-05-11 17:53:26 +00:00
|
|
|
SYSCTL_OPAQUE(_machdep, OID_AUTO, consdev, CTLFLAG_RD,
|
2004-06-16 09:47:26 +00:00
|
|
|
&cn_udev_t, sizeof cn_udev_t, "T,struct cdev *", "");
|
1997-08-08 20:09:50 +00:00
|
|
|
|
2004-02-05 01:56:43 +00:00
|
|
|
int cons_avail_mask = 0; /* Bit mask. Each registered low level console
|
|
|
|
* which is currently unavailable for inpit
|
|
|
|
* (i.e., if it is in graphics mode) will have
|
|
|
|
* this bit cleared.
|
1995-04-08 21:32:11 +00:00
|
|
|
*/
|
2001-10-23 20:25:50 +00:00
|
|
|
static int cn_mute;
|
|
|
|
static int openflag; /* how /dev/console was opened */
|
|
|
|
static int cn_is_open;
|
2003-06-22 02:54:33 +00:00
|
|
|
static char *consbuf; /* buffer used by `consmsgbuf' */
|
|
|
|
static struct callout conscallout; /* callout for outputting to constty */
|
|
|
|
struct msgbuf consmsgbuf; /* message buffer for console tty */
|
2001-12-10 20:02:22 +00:00
|
|
|
static u_char console_pausing; /* pause after each line during probe */
|
|
|
|
static char *console_pausestr=
|
|
|
|
"<pause; press any key to proceed to next line or '.' to end pause mode>";
|
2003-06-22 02:54:33 +00:00
|
|
|
struct tty *constty; /* pointer to console "window" tty */
|
2006-11-01 04:54:51 +00:00
|
|
|
static struct mtx cnputs_mtx; /* Mutex for cnputs(). */
|
|
|
|
static int use_cnputs_mtx = 0; /* != 0 if cnputs_mtx locking reqd. */
|
1995-01-21 14:12:15 +00:00
|
|
|
|
2003-06-22 02:54:33 +00:00
|
|
|
static void constty_timeout(void *arg);
|
2001-10-25 00:14:16 +00:00
|
|
|
|
2006-05-26 10:46:38 +00:00
|
|
|
static struct consdev cons_consdev;
|
|
|
|
DATA_SET(cons_set, cons_consdev);
|
2001-06-13 10:58:39 +00:00
|
|
|
SET_DECLARE(cons_set, struct consdev);
|
1999-01-07 14:14:24 +00:00
|
|
|
|
1993-11-25 01:38:01 +00:00
|
|
|
void
|
2001-10-23 20:25:50 +00:00
|
|
|
cninit(void)
|
1993-06-12 14:58:17 +00:00
|
|
|
{
|
2001-10-23 20:25:50 +00:00
|
|
|
struct consdev *best_cn, *cn, **list;
|
1995-09-10 18:57:26 +00:00
|
|
|
|
1996-10-16 00:19:40 +00:00
|
|
|
/*
|
|
|
|
* Check if we should mute the console (for security reasons perhaps)
|
|
|
|
* It can be changes dynamically using sysctl kern.consmute
|
|
|
|
* once we are up and going.
|
|
|
|
*
|
|
|
|
*/
|
|
|
|
cn_mute = ((boothowto & (RB_MUTE
|
|
|
|
|RB_SINGLE
|
|
|
|
|RB_VERBOSE
|
2004-12-01 04:59:33 +00:00
|
|
|
|RB_ASKNAME)) == RB_MUTE);
|
2001-10-23 20:25:50 +00:00
|
|
|
|
1993-06-12 14:58:17 +00:00
|
|
|
/*
|
2001-10-23 20:25:50 +00:00
|
|
|
* Find the first console with the highest priority.
|
1993-06-12 14:58:17 +00:00
|
|
|
*/
|
2001-10-23 20:25:50 +00:00
|
|
|
best_cn = NULL;
|
|
|
|
SET_FOREACH(list, cons_set) {
|
|
|
|
cn = *list;
|
2002-08-06 18:56:41 +00:00
|
|
|
cnremove(cn);
|
2001-10-23 20:25:50 +00:00
|
|
|
if (cn->cn_probe == NULL)
|
|
|
|
continue;
|
|
|
|
cn->cn_probe(cn);
|
|
|
|
if (cn->cn_pri == CN_DEAD)
|
|
|
|
continue;
|
|
|
|
if (best_cn == NULL || cn->cn_pri > best_cn->cn_pri)
|
|
|
|
best_cn = cn;
|
|
|
|
if (boothowto & RB_MULTIPLE) {
|
|
|
|
/*
|
|
|
|
* Initialize console, and attach to it.
|
|
|
|
*/
|
|
|
|
cn->cn_init(cn);
|
2006-11-03 06:23:53 +00:00
|
|
|
cnadd(cn);
|
2001-10-23 20:25:50 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
if (best_cn == NULL)
|
1995-09-10 18:57:26 +00:00
|
|
|
return;
|
2001-10-23 20:25:50 +00:00
|
|
|
if ((boothowto & RB_MULTIPLE) == 0) {
|
|
|
|
best_cn->cn_init(best_cn);
|
2006-11-03 06:23:53 +00:00
|
|
|
cnadd(best_cn);
|
1995-09-10 18:57:26 +00:00
|
|
|
}
|
2001-12-10 20:02:22 +00:00
|
|
|
if (boothowto & RB_PAUSE)
|
|
|
|
console_pausing = 1;
|
1995-09-10 18:57:26 +00:00
|
|
|
/*
|
2001-10-23 20:25:50 +00:00
|
|
|
* Make the best console the preferred console.
|
1995-09-10 18:57:26 +00:00
|
|
|
*/
|
2001-10-23 20:25:50 +00:00
|
|
|
cnselect(best_cn);
|
|
|
|
}
|
|
|
|
|
2001-12-10 20:02:22 +00:00
|
|
|
void
|
|
|
|
cninit_finish()
|
|
|
|
{
|
|
|
|
console_pausing = 0;
|
|
|
|
}
|
|
|
|
|
2001-10-23 20:25:50 +00:00
|
|
|
/* add a new physical console to back the virtual console */
|
|
|
|
int
|
|
|
|
cnadd(struct consdev *cn)
|
|
|
|
{
|
|
|
|
struct cn_device *cnd;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
STAILQ_FOREACH(cnd, &cn_devlist, cnd_next)
|
|
|
|
if (cnd->cnd_cn == cn)
|
|
|
|
return (0);
|
|
|
|
for (i = 0; i < CNDEVTAB_SIZE; i++) {
|
|
|
|
cnd = &cn_devtab[i];
|
|
|
|
if (cnd->cnd_cn == NULL)
|
|
|
|
break;
|
The second phase of syscons reorganization.
- Split syscons source code into manageable chunks and reorganize
some of complicated functions.
- Many static variables are moved to the softc structure.
- Added a new key function, PREV. When this key is pressed, the vty
immediately before the current vty will become foreground. Analogue
to PREV, which is usually assigned to the PrntScrn key.
PR: kern/10113
Submitted by: Christian Weisgerber <naddy@mips.rhein-neckar.de>
- Modified the kernel console input function sccngetc() so that it
handles function keys properly.
- Reorganized the screen update routine.
- VT switching code is reorganized. It now should be slightly more
robust than before.
- Added the DEVICE_RESUME function so that syscons no longer hooks the
APM resume event directly.
- New kernel configuration options: SC_NO_CUTPASTE, SC_NO_FONT_LOADING,
SC_NO_HISTORY and SC_NO_SYSMOUSE.
Various parts of syscons can be omitted so that the kernel size is
reduced.
SC_PIXEL_MODE
Made the VESA 800x600 mode an option, rather than a standard part of
syscons.
SC_DISABLE_DDBKEY
Disables the `debug' key combination.
SC_ALT_MOUSE_IMAGE
Inverse the character cell at the mouse cursor position in the text
console, rather than drawing an arrow on the screen.
Submitted by: Nick Hibma (n_hibma@FreeBSD.ORG)
SC_DFLT_FONT
makeoptions "SC_DFLT_FONT=_font_name_"
Include the named font as the default font of syscons. 16-line,
14-line and 8-line font data will be compiled in. This option replaces
the existing STD8X16FONT option, which loads 16-line font data only.
- The VGA driver is split into /sys/dev/fb/vga.c and /sys/isa/vga_isa.c.
- The video driver provides a set of ioctl commands to manipulate the
frame buffer.
- New kernel configuration option: VGA_WIDTH90
Enables 90 column modes: 90x25, 90x30, 90x43, 90x50, 90x60. These
modes are mot always supported by the video card.
PR: i386/7510
Submitted by: kbyanc@freedomnet.com and alexv@sui.gda.itesm.mx.
- The header file machine/console.h is reorganized; its contents is now
split into sys/fbio.h, sys/kbio.h (a new file) and sys/consio.h
(another new file). machine/console.h is still maintained for
compatibility reasons.
- Kernel console selection/installation routines are fixed and
slightly rebumped so that it should now be possible to switch between
the interanl kernel console (sc or vt) and a remote kernel console
(sio) again, as it was in 2.x, 3.0 and 3.1.
- Screen savers and splash screen decoders
Because of the header file reorganization described above, screen
savers and splash screen decoders are slightly modified. After this
update, /sys/modules/syscons/saver.h is no longer necessary and is
removed.
1999-06-22 14:14:06 +00:00
|
|
|
}
|
2001-10-23 20:25:50 +00:00
|
|
|
if (cnd->cnd_cn != NULL)
|
|
|
|
return (ENOMEM);
|
|
|
|
cnd->cnd_cn = cn;
|
2003-09-26 07:26:54 +00:00
|
|
|
if (cn->cn_name[0] == '\0') {
|
|
|
|
/* XXX: it is unclear if/where this print might output */
|
|
|
|
printf("WARNING: console at %p has no name\n", cn);
|
|
|
|
}
|
2001-10-23 20:25:50 +00:00
|
|
|
STAILQ_INSERT_TAIL(&cn_devlist, cnd, cnd_next);
|
2004-02-05 01:56:43 +00:00
|
|
|
|
|
|
|
/* Add device to the active mask. */
|
|
|
|
cnavailable(cn, (cn->cn_flags & CN_FLAG_NOAVAIL) == 0);
|
|
|
|
|
2001-10-23 20:25:50 +00:00
|
|
|
return (0);
|
1995-09-10 18:57:26 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void
|
2001-10-23 20:25:50 +00:00
|
|
|
cnremove(struct consdev *cn)
|
1995-09-10 18:57:26 +00:00
|
|
|
{
|
2001-10-23 20:25:50 +00:00
|
|
|
struct cn_device *cnd;
|
2004-02-05 01:56:43 +00:00
|
|
|
int i;
|
1995-09-10 18:57:26 +00:00
|
|
|
|
2001-10-23 20:25:50 +00:00
|
|
|
STAILQ_FOREACH(cnd, &cn_devlist, cnd_next) {
|
|
|
|
if (cnd->cnd_cn != cn)
|
|
|
|
continue;
|
|
|
|
STAILQ_REMOVE(&cn_devlist, cnd, cn_device, cnd_next);
|
|
|
|
if (cnd->cnd_vp != NULL)
|
|
|
|
vn_close(cnd->cnd_vp, openflag, NOCRED, NULL);
|
|
|
|
cnd->cnd_vp = NULL;
|
|
|
|
cnd->cnd_cn = NULL;
|
2004-02-05 01:56:43 +00:00
|
|
|
|
|
|
|
/* Remove this device from available mask. */
|
|
|
|
for (i = 0; i < CNDEVTAB_SIZE; i++)
|
|
|
|
if (cnd == &cn_devtab[i]) {
|
|
|
|
cons_avail_mask &= ~(1 << i);
|
|
|
|
break;
|
|
|
|
}
|
2001-10-23 20:25:50 +00:00
|
|
|
#if 0
|
|
|
|
/*
|
|
|
|
* XXX
|
|
|
|
* syscons gets really confused if console resources are
|
|
|
|
* freed after the system has initialized.
|
|
|
|
*/
|
|
|
|
if (cn->cn_term != NULL)
|
|
|
|
cn->cn_term(cn);
|
|
|
|
#endif
|
1993-06-12 14:58:17 +00:00
|
|
|
return;
|
2000-01-25 09:20:08 +00:00
|
|
|
}
|
1993-06-12 14:58:17 +00:00
|
|
|
}
|
|
|
|
|
2001-10-23 20:25:50 +00:00
|
|
|
void
|
|
|
|
cnselect(struct consdev *cn)
|
1997-08-08 20:09:50 +00:00
|
|
|
{
|
2001-10-23 20:25:50 +00:00
|
|
|
struct cn_device *cnd;
|
1997-08-08 20:09:50 +00:00
|
|
|
|
2001-10-23 20:25:50 +00:00
|
|
|
STAILQ_FOREACH(cnd, &cn_devlist, cnd_next) {
|
|
|
|
if (cnd->cnd_cn != cn)
|
|
|
|
continue;
|
|
|
|
if (cnd == STAILQ_FIRST(&cn_devlist))
|
|
|
|
return;
|
|
|
|
STAILQ_REMOVE(&cn_devlist, cnd, cn_device, cnd_next);
|
|
|
|
STAILQ_INSERT_HEAD(&cn_devlist, cnd, cnd_next);
|
1997-08-08 20:09:50 +00:00
|
|
|
return;
|
2001-10-23 20:25:50 +00:00
|
|
|
}
|
|
|
|
}
|
1997-08-08 20:09:50 +00:00
|
|
|
|
2004-02-05 01:56:43 +00:00
|
|
|
void
|
|
|
|
cnavailable(struct consdev *cn, int available)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
|
|
|
for (i = 0; i < CNDEVTAB_SIZE; i++) {
|
|
|
|
if (cn_devtab[i].cnd_cn == cn)
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
if (available) {
|
|
|
|
if (i < CNDEVTAB_SIZE)
|
|
|
|
cons_avail_mask |= (1 << i);
|
|
|
|
cn->cn_flags &= ~CN_FLAG_NOAVAIL;
|
|
|
|
} else {
|
|
|
|
if (i < CNDEVTAB_SIZE)
|
|
|
|
cons_avail_mask &= ~(1 << i);
|
|
|
|
cn->cn_flags |= CN_FLAG_NOAVAIL;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
int
|
2004-02-05 17:35:28 +00:00
|
|
|
cnunavailable(void)
|
2004-02-05 01:56:43 +00:00
|
|
|
{
|
2001-10-23 20:25:50 +00:00
|
|
|
|
2004-02-05 17:35:28 +00:00
|
|
|
return (cons_avail_mask == 0);
|
2001-10-23 20:25:50 +00:00
|
|
|
}
|
|
|
|
|
2003-09-26 07:26:54 +00:00
|
|
|
/*
|
|
|
|
* XXX: rewrite to use sbufs instead
|
|
|
|
*/
|
|
|
|
|
2001-10-23 20:25:50 +00:00
|
|
|
static int
|
|
|
|
sysctl_kern_console(SYSCTL_HANDLER_ARGS)
|
|
|
|
{
|
|
|
|
struct cn_device *cnd;
|
|
|
|
struct consdev *cp, **list;
|
|
|
|
char *name, *p;
|
|
|
|
int delete, len, error;
|
|
|
|
|
|
|
|
len = 2;
|
|
|
|
SET_FOREACH(list, cons_set) {
|
|
|
|
cp = *list;
|
2003-09-26 07:26:54 +00:00
|
|
|
if (cp->cn_name[0] != '\0')
|
|
|
|
len += strlen(cp->cn_name) + 1;
|
2001-10-23 20:25:50 +00:00
|
|
|
}
|
|
|
|
STAILQ_FOREACH(cnd, &cn_devlist, cnd_next)
|
2003-09-26 07:26:54 +00:00
|
|
|
len += strlen(cnd->cnd_cn->cn_name) + 1;
|
2001-10-23 20:25:50 +00:00
|
|
|
len = len > CNDEVPATHMAX ? len : CNDEVPATHMAX;
|
2003-02-19 05:47:46 +00:00
|
|
|
MALLOC(name, char *, len, M_TEMP, M_WAITOK | M_ZERO);
|
2001-10-23 20:25:50 +00:00
|
|
|
p = name;
|
|
|
|
STAILQ_FOREACH(cnd, &cn_devlist, cnd_next)
|
2003-09-26 07:26:54 +00:00
|
|
|
p += sprintf(p, "%s,", cnd->cnd_cn->cn_name);
|
2001-10-23 20:25:50 +00:00
|
|
|
*p++ = '/';
|
|
|
|
SET_FOREACH(list, cons_set) {
|
|
|
|
cp = *list;
|
2003-09-26 07:26:54 +00:00
|
|
|
if (cp->cn_name[0] != '\0')
|
|
|
|
p += sprintf(p, "%s,", cp->cn_name);
|
2001-10-23 20:25:50 +00:00
|
|
|
}
|
|
|
|
error = sysctl_handle_string(oidp, name, len, req);
|
|
|
|
if (error == 0 && req->newptr != NULL) {
|
|
|
|
p = name;
|
|
|
|
error = ENXIO;
|
|
|
|
delete = 0;
|
|
|
|
if (*p == '-') {
|
|
|
|
delete = 1;
|
|
|
|
p++;
|
|
|
|
}
|
|
|
|
SET_FOREACH(list, cons_set) {
|
|
|
|
cp = *list;
|
2003-09-26 07:26:54 +00:00
|
|
|
if (strcmp(p, cp->cn_name) != 0)
|
2001-10-23 20:25:50 +00:00
|
|
|
continue;
|
|
|
|
if (delete) {
|
|
|
|
cnremove(cp);
|
|
|
|
error = 0;
|
|
|
|
} else {
|
|
|
|
error = cnadd(cp);
|
|
|
|
if (error == 0)
|
|
|
|
cnselect(cp);
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
2000-01-25 09:20:08 +00:00
|
|
|
}
|
2001-10-23 20:25:50 +00:00
|
|
|
FREE(name, M_TEMP);
|
|
|
|
return (error);
|
1997-08-08 20:09:50 +00:00
|
|
|
}
|
|
|
|
|
2001-10-23 20:25:50 +00:00
|
|
|
SYSCTL_PROC(_kern, OID_AUTO, console, CTLTYPE_STRING|CTLFLAG_RW,
|
|
|
|
0, 0, sysctl_kern_console, "A", "Console device control");
|
|
|
|
|
1997-08-08 20:09:50 +00:00
|
|
|
/*
|
|
|
|
* User has changed the state of the console muting.
|
|
|
|
* This may require us to open or close the device in question.
|
|
|
|
*/
|
|
|
|
static int
|
2000-07-04 11:25:35 +00:00
|
|
|
sysctl_kern_consmute(SYSCTL_HANDLER_ARGS)
|
1997-08-08 20:09:50 +00:00
|
|
|
{
|
|
|
|
int error;
|
|
|
|
int ocn_mute;
|
|
|
|
|
|
|
|
ocn_mute = cn_mute;
|
|
|
|
error = sysctl_handle_int(oidp, &cn_mute, 0, req);
|
2001-10-23 20:25:50 +00:00
|
|
|
if (error != 0 || req->newptr == NULL)
|
|
|
|
return (error);
|
|
|
|
if (ocn_mute && !cn_mute && cn_is_open)
|
2004-06-17 17:16:53 +00:00
|
|
|
error = cnopen(NULL, openflag, 0, curthread);
|
2001-10-23 20:25:50 +00:00
|
|
|
else if (!ocn_mute && cn_mute && cn_is_open) {
|
2004-06-17 17:16:53 +00:00
|
|
|
error = cnclose(NULL, openflag, 0, curthread);
|
2001-10-23 20:25:50 +00:00
|
|
|
cn_is_open = 1; /* XXX hack */
|
1997-08-08 20:09:50 +00:00
|
|
|
}
|
|
|
|
return (error);
|
|
|
|
}
|
|
|
|
|
|
|
|
SYSCTL_PROC(_kern, OID_AUTO, consmute, CTLTYPE_INT|CTLFLAG_RW,
|
2001-10-23 20:25:50 +00:00
|
|
|
0, sizeof(cn_mute), sysctl_kern_consmute, "I", "");
|
1997-08-08 20:09:50 +00:00
|
|
|
|
1995-12-08 11:19:42 +00:00
|
|
|
static int
|
2001-10-23 20:25:50 +00:00
|
|
|
cn_devopen(struct cn_device *cnd, struct thread *td, int forceopen)
|
1993-06-12 14:58:17 +00:00
|
|
|
{
|
2001-10-23 20:25:50 +00:00
|
|
|
char path[CNDEVPATHMAX];
|
2001-11-02 17:04:32 +00:00
|
|
|
struct nameidata nd;
|
|
|
|
struct vnode *vp;
|
2004-06-16 09:47:26 +00:00
|
|
|
struct cdev *dev;
|
2004-09-24 07:16:56 +00:00
|
|
|
struct cdevsw *csw;
|
2001-10-23 20:25:50 +00:00
|
|
|
int error;
|
1994-01-23 19:17:17 +00:00
|
|
|
|
2001-11-02 17:04:32 +00:00
|
|
|
if ((vp = cnd->cnd_vp) != NULL) {
|
|
|
|
if (!forceopen && vp->v_type != VBAD) {
|
|
|
|
dev = vp->v_rdev;
|
2004-09-24 07:16:56 +00:00
|
|
|
csw = dev_refthread(dev);
|
|
|
|
if (csw == NULL)
|
|
|
|
return (ENXIO);
|
|
|
|
error = (*csw->d_open)(dev, openflag, 0, td);
|
|
|
|
dev_relthread(dev);
|
|
|
|
return (error);
|
1997-08-08 20:09:50 +00:00
|
|
|
}
|
2001-10-23 20:25:50 +00:00
|
|
|
cnd->cnd_vp = NULL;
|
2002-02-27 18:32:23 +00:00
|
|
|
vn_close(vp, openflag, td->td_ucred, td);
|
2001-10-23 20:25:50 +00:00
|
|
|
}
|
2003-09-26 07:26:54 +00:00
|
|
|
snprintf(path, sizeof(path), "/dev/%s", cnd->cnd_cn->cn_name);
|
2001-10-23 20:25:50 +00:00
|
|
|
NDINIT(&nd, LOOKUP, FOLLOW, UIO_SYSSPACE, path, td);
|
2003-07-27 17:04:56 +00:00
|
|
|
error = vn_open(&nd, &openflag, 0, -1);
|
2001-10-23 20:25:50 +00:00
|
|
|
if (error == 0) {
|
|
|
|
NDFREE(&nd, NDF_ONLY_PNBUF);
|
|
|
|
VOP_UNLOCK(nd.ni_vp, 0, td);
|
|
|
|
if (nd.ni_vp->v_type == VCHR)
|
|
|
|
cnd->cnd_vp = nd.ni_vp;
|
|
|
|
else
|
2002-02-27 18:32:23 +00:00
|
|
|
vn_close(nd.ni_vp, openflag, td->td_ucred, td);
|
1995-01-21 14:12:15 +00:00
|
|
|
}
|
2001-10-23 20:25:50 +00:00
|
|
|
return (cnd->cnd_vp != NULL);
|
1993-06-12 14:58:17 +00:00
|
|
|
}
|
1995-05-30 08:16:23 +00:00
|
|
|
|
1995-12-08 11:19:42 +00:00
|
|
|
static int
|
2004-06-16 09:47:26 +00:00
|
|
|
cnopen(struct cdev *dev, int flag, int mode, struct thread *td)
|
1993-06-12 14:58:17 +00:00
|
|
|
{
|
2001-10-23 20:25:50 +00:00
|
|
|
struct cn_device *cnd;
|
1994-01-23 19:17:17 +00:00
|
|
|
|
2001-10-25 00:14:16 +00:00
|
|
|
openflag = flag | FWRITE; /* XXX */
|
2001-10-23 20:25:50 +00:00
|
|
|
cn_is_open = 1; /* console is logically open */
|
|
|
|
if (cn_mute)
|
1993-06-12 14:58:17 +00:00
|
|
|
return (0);
|
2001-10-23 20:25:50 +00:00
|
|
|
STAILQ_FOREACH(cnd, &cn_devlist, cnd_next)
|
|
|
|
cn_devopen(cnd, td, 0);
|
|
|
|
return (0);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
2004-06-16 09:47:26 +00:00
|
|
|
cnclose(struct cdev *dev, int flag, int mode, struct thread *td)
|
2001-10-23 20:25:50 +00:00
|
|
|
{
|
|
|
|
struct cn_device *cnd;
|
2001-10-25 04:51:37 +00:00
|
|
|
struct vnode *vp;
|
2001-10-23 20:25:50 +00:00
|
|
|
|
|
|
|
STAILQ_FOREACH(cnd, &cn_devlist, cnd_next) {
|
2001-10-25 04:51:37 +00:00
|
|
|
if ((vp = cnd->cnd_vp) == NULL)
|
2001-10-23 20:25:50 +00:00
|
|
|
continue;
|
|
|
|
cnd->cnd_vp = NULL;
|
2002-02-27 18:32:23 +00:00
|
|
|
vn_close(vp, openflag, td->td_ucred, td);
|
1995-01-21 14:12:15 +00:00
|
|
|
}
|
2001-10-23 20:25:50 +00:00
|
|
|
cn_is_open = 0;
|
1997-08-08 20:09:50 +00:00
|
|
|
return (0);
|
1993-06-12 14:58:17 +00:00
|
|
|
}
|
1995-05-30 08:16:23 +00:00
|
|
|
|
1995-12-08 11:19:42 +00:00
|
|
|
static int
|
2004-06-16 09:47:26 +00:00
|
|
|
cnread(struct cdev *dev, struct uio *uio, int flag)
|
1993-06-12 14:58:17 +00:00
|
|
|
{
|
2001-10-23 20:25:50 +00:00
|
|
|
struct cn_device *cnd;
|
2004-09-24 07:16:56 +00:00
|
|
|
struct cdevsw *csw;
|
|
|
|
int error;
|
2000-01-25 09:20:08 +00:00
|
|
|
|
2001-10-23 20:25:50 +00:00
|
|
|
cnd = STAILQ_FIRST(&cn_devlist);
|
|
|
|
if (cn_mute || CND_INVALID(cnd, curthread))
|
1993-06-12 14:58:17 +00:00
|
|
|
return (0);
|
2001-10-23 20:25:50 +00:00
|
|
|
dev = cnd->cnd_vp->v_rdev;
|
2004-09-24 07:16:56 +00:00
|
|
|
csw = dev_refthread(dev);
|
|
|
|
if (csw == NULL)
|
|
|
|
return (ENXIO);
|
|
|
|
error = (csw->d_read)(dev, uio, flag);
|
|
|
|
dev_relthread(dev);
|
|
|
|
return (error);
|
1993-06-12 14:58:17 +00:00
|
|
|
}
|
1995-05-30 08:16:23 +00:00
|
|
|
|
1995-12-08 11:19:42 +00:00
|
|
|
static int
|
2004-06-16 09:47:26 +00:00
|
|
|
cnwrite(struct cdev *dev, struct uio *uio, int flag)
|
1993-06-12 14:58:17 +00:00
|
|
|
{
|
2001-10-23 20:25:50 +00:00
|
|
|
struct cn_device *cnd;
|
2004-09-24 07:16:56 +00:00
|
|
|
struct cdevsw *csw;
|
|
|
|
int error;
|
2000-01-25 09:20:08 +00:00
|
|
|
|
2001-10-23 20:25:50 +00:00
|
|
|
cnd = STAILQ_FIRST(&cn_devlist);
|
|
|
|
if (cn_mute || CND_INVALID(cnd, curthread))
|
|
|
|
goto done;
|
1994-01-26 20:42:18 +00:00
|
|
|
if (constty)
|
1993-06-12 14:58:17 +00:00
|
|
|
dev = constty->t_dev;
|
|
|
|
else
|
2001-10-23 20:25:50 +00:00
|
|
|
dev = cnd->cnd_vp->v_rdev;
|
|
|
|
if (dev != NULL) {
|
|
|
|
log_console(uio);
|
2004-09-24 07:16:56 +00:00
|
|
|
csw = dev_refthread(dev);
|
|
|
|
if (csw == NULL)
|
|
|
|
return (ENXIO);
|
|
|
|
error = (csw->d_write)(dev, uio, flag);
|
|
|
|
dev_relthread(dev);
|
|
|
|
return (error);
|
2001-10-23 20:25:50 +00:00
|
|
|
}
|
|
|
|
done:
|
|
|
|
uio->uio_resid = 0; /* dump the data */
|
|
|
|
return (0);
|
1993-06-12 14:58:17 +00:00
|
|
|
}
|
1995-05-30 08:16:23 +00:00
|
|
|
|
1995-12-08 11:19:42 +00:00
|
|
|
static int
|
2004-06-16 09:47:26 +00:00
|
|
|
cnioctl(struct cdev *dev, u_long cmd, caddr_t data, int flag, struct thread *td)
|
1993-06-12 14:58:17 +00:00
|
|
|
{
|
2001-10-23 20:25:50 +00:00
|
|
|
struct cn_device *cnd;
|
2004-09-24 07:16:56 +00:00
|
|
|
struct cdevsw *csw;
|
1993-06-12 14:58:17 +00:00
|
|
|
int error;
|
|
|
|
|
2001-10-23 20:25:50 +00:00
|
|
|
cnd = STAILQ_FIRST(&cn_devlist);
|
|
|
|
if (cn_mute || CND_INVALID(cnd, td))
|
1993-06-12 14:58:17 +00:00
|
|
|
return (0);
|
|
|
|
/*
|
|
|
|
* Superuser can always use this to wrest control of console
|
|
|
|
* output from the "virtual" console.
|
|
|
|
*/
|
|
|
|
if (cmd == TIOCCONS && constty) {
|
2002-04-01 21:31:13 +00:00
|
|
|
error = suser(td);
|
1993-06-12 14:58:17 +00:00
|
|
|
if (error)
|
|
|
|
return (error);
|
|
|
|
constty = NULL;
|
|
|
|
return (0);
|
|
|
|
}
|
2001-10-23 20:25:50 +00:00
|
|
|
dev = cnd->cnd_vp->v_rdev;
|
2004-09-24 07:16:56 +00:00
|
|
|
if (dev == NULL)
|
|
|
|
return (0); /* XXX : ENOTTY ? */
|
|
|
|
csw = dev_refthread(dev);
|
|
|
|
if (csw == NULL)
|
|
|
|
return (ENXIO);
|
|
|
|
error = (csw->d_ioctl)(dev, cmd, data, flag, td);
|
|
|
|
dev_relthread(dev);
|
|
|
|
return (error);
|
1993-06-12 14:58:17 +00:00
|
|
|
}
|
|
|
|
|
2001-10-23 20:25:50 +00:00
|
|
|
/*
|
|
|
|
* XXX
|
|
|
|
* poll/kqfilter do not appear to be correct
|
|
|
|
*/
|
1995-12-08 11:19:42 +00:00
|
|
|
static int
|
2004-06-16 09:47:26 +00:00
|
|
|
cnpoll(struct cdev *dev, int events, struct thread *td)
|
1993-06-12 14:58:17 +00:00
|
|
|
{
|
2001-10-23 20:25:50 +00:00
|
|
|
struct cn_device *cnd;
|
2004-09-24 07:16:56 +00:00
|
|
|
struct cdevsw *csw;
|
|
|
|
int error;
|
1995-02-25 20:09:44 +00:00
|
|
|
|
2001-10-23 20:25:50 +00:00
|
|
|
cnd = STAILQ_FIRST(&cn_devlist);
|
|
|
|
if (cn_mute || CND_INVALID(cnd, td))
|
|
|
|
return (0);
|
|
|
|
dev = cnd->cnd_vp->v_rdev;
|
2004-09-24 07:16:56 +00:00
|
|
|
if (dev == NULL)
|
|
|
|
return (0);
|
|
|
|
csw = dev_refthread(dev);
|
|
|
|
if (csw == NULL)
|
|
|
|
return (ENXIO);
|
|
|
|
error = (csw->d_poll)(dev, events, td);
|
|
|
|
dev_relthread(dev);
|
|
|
|
return (error);
|
1993-06-12 14:58:17 +00:00
|
|
|
}
|
|
|
|
|
2001-02-15 16:34:11 +00:00
|
|
|
static int
|
2004-06-16 09:47:26 +00:00
|
|
|
cnkqfilter(struct cdev *dev, struct knote *kn)
|
2001-02-15 16:34:11 +00:00
|
|
|
{
|
2001-10-23 20:25:50 +00:00
|
|
|
struct cn_device *cnd;
|
2004-09-24 07:16:56 +00:00
|
|
|
struct cdevsw *csw;
|
|
|
|
int error;
|
2001-02-15 16:34:11 +00:00
|
|
|
|
2001-10-23 20:25:50 +00:00
|
|
|
cnd = STAILQ_FIRST(&cn_devlist);
|
|
|
|
if (cn_mute || CND_INVALID(cnd, curthread))
|
2004-08-15 06:24:42 +00:00
|
|
|
return (EINVAL);
|
2001-10-23 20:25:50 +00:00
|
|
|
dev = cnd->cnd_vp->v_rdev;
|
2004-09-24 07:16:56 +00:00
|
|
|
if (dev == NULL)
|
|
|
|
return (ENXIO);
|
|
|
|
csw = dev_refthread(dev);
|
|
|
|
if (csw == NULL)
|
|
|
|
return (ENXIO);
|
|
|
|
error = (csw->d_kqfilter)(dev, kn);
|
|
|
|
dev_relthread(dev);
|
|
|
|
return (error);
|
2001-02-15 16:34:11 +00:00
|
|
|
}
|
|
|
|
|
2001-10-23 20:25:50 +00:00
|
|
|
/*
|
|
|
|
* Low level console routines.
|
|
|
|
*/
|
1993-11-25 01:38:01 +00:00
|
|
|
int
|
2001-10-23 20:25:50 +00:00
|
|
|
cngetc(void)
|
1993-06-12 14:58:17 +00:00
|
|
|
{
|
1994-12-18 19:35:59 +00:00
|
|
|
int c;
|
2001-10-23 20:25:50 +00:00
|
|
|
|
|
|
|
if (cn_mute)
|
1996-10-30 21:40:25 +00:00
|
|
|
return (-1);
|
2001-10-23 20:25:50 +00:00
|
|
|
while ((c = cncheckc()) == -1)
|
|
|
|
;
|
|
|
|
if (c == '\r')
|
|
|
|
c = '\n'; /* console input is always ICRNL */
|
1994-12-18 19:35:59 +00:00
|
|
|
return (c);
|
1993-06-12 14:58:17 +00:00
|
|
|
}
|
|
|
|
|
1994-10-20 00:08:31 +00:00
|
|
|
int
|
2001-10-23 20:25:50 +00:00
|
|
|
cncheckc(void)
|
1994-10-20 00:08:31 +00:00
|
|
|
{
|
2001-10-23 20:25:50 +00:00
|
|
|
struct cn_device *cnd;
|
|
|
|
struct consdev *cn;
|
|
|
|
int c;
|
|
|
|
|
|
|
|
if (cn_mute)
|
1996-09-14 04:25:32 +00:00
|
|
|
return (-1);
|
2001-10-23 20:25:50 +00:00
|
|
|
STAILQ_FOREACH(cnd, &cn_devlist, cnd_next) {
|
|
|
|
cn = cnd->cnd_cn;
|
2004-07-10 21:43:23 +00:00
|
|
|
if (!kdb_active || !(cn->cn_flags & CN_FLAG_NODEBUG)) {
|
2006-05-26 11:00:20 +00:00
|
|
|
if (cn->cn_checkc != NULL)
|
|
|
|
c = cn->cn_checkc(cn);
|
|
|
|
else
|
|
|
|
c = cn->cn_getc(cn);
|
2003-10-18 02:13:39 +00:00
|
|
|
if (c != -1) {
|
|
|
|
return (c);
|
|
|
|
}
|
2001-10-23 20:25:50 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
return (-1);
|
1994-10-20 00:08:31 +00:00
|
|
|
}
|
|
|
|
|
1993-11-25 01:38:01 +00:00
|
|
|
void
|
2001-10-23 20:25:50 +00:00
|
|
|
cnputc(int c)
|
1993-06-12 14:58:17 +00:00
|
|
|
{
|
2001-10-23 20:25:50 +00:00
|
|
|
struct cn_device *cnd;
|
|
|
|
struct consdev *cn;
|
2001-12-10 20:02:22 +00:00
|
|
|
char *cp;
|
2001-10-23 20:25:50 +00:00
|
|
|
|
|
|
|
if (cn_mute || c == '\0')
|
1993-06-12 14:58:17 +00:00
|
|
|
return;
|
2001-10-23 20:25:50 +00:00
|
|
|
STAILQ_FOREACH(cnd, &cn_devlist, cnd_next) {
|
|
|
|
cn = cnd->cnd_cn;
|
2004-07-10 21:43:23 +00:00
|
|
|
if (!kdb_active || !(cn->cn_flags & CN_FLAG_NODEBUG)) {
|
2003-10-18 02:13:39 +00:00
|
|
|
if (c == '\n')
|
|
|
|
cn->cn_putc(cn, '\r');
|
|
|
|
cn->cn_putc(cn, c);
|
|
|
|
}
|
1993-06-12 14:58:17 +00:00
|
|
|
}
|
2004-07-10 21:43:23 +00:00
|
|
|
if (console_pausing && c == '\n' && !kdb_active) {
|
2001-12-10 20:02:22 +00:00
|
|
|
for (cp = console_pausestr; *cp != '\0'; cp++)
|
|
|
|
cnputc(*cp);
|
|
|
|
if (cngetc() == '.')
|
|
|
|
console_pausing = 0;
|
|
|
|
cnputc('\r');
|
|
|
|
for (cp = console_pausestr; *cp != '\0'; cp++)
|
|
|
|
cnputc(' ');
|
|
|
|
cnputc('\r');
|
|
|
|
}
|
1993-06-12 14:58:17 +00:00
|
|
|
}
|
|
|
|
|
2006-11-01 04:54:51 +00:00
|
|
|
void
|
|
|
|
cnputs(char *p)
|
|
|
|
{
|
|
|
|
int c;
|
|
|
|
int unlock_reqd = 0;
|
|
|
|
|
|
|
|
if (use_cnputs_mtx) {
|
|
|
|
mtx_lock_spin(&cnputs_mtx);
|
|
|
|
unlock_reqd = 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
while ((c = *p++) != '\0')
|
|
|
|
cnputc(c);
|
|
|
|
|
|
|
|
if (unlock_reqd)
|
|
|
|
mtx_unlock_spin(&cnputs_mtx);
|
|
|
|
}
|
|
|
|
|
2003-06-22 02:54:33 +00:00
|
|
|
static int consmsgbuf_size = 8192;
|
|
|
|
SYSCTL_INT(_kern, OID_AUTO, consmsgbuf_size, CTLFLAG_RW, &consmsgbuf_size, 0,
|
|
|
|
"");
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Redirect console output to a tty.
|
|
|
|
*/
|
|
|
|
void
|
|
|
|
constty_set(struct tty *tp)
|
|
|
|
{
|
|
|
|
int size;
|
|
|
|
|
|
|
|
KASSERT(tp != NULL, ("constty_set: NULL tp"));
|
|
|
|
if (consbuf == NULL) {
|
|
|
|
size = consmsgbuf_size;
|
|
|
|
consbuf = malloc(size, M_TTYS, M_WAITOK);
|
|
|
|
msgbuf_init(&consmsgbuf, consbuf, size);
|
|
|
|
callout_init(&conscallout, 0);
|
|
|
|
}
|
|
|
|
constty = tp;
|
|
|
|
constty_timeout(NULL);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Disable console redirection to a tty.
|
|
|
|
*/
|
|
|
|
void
|
|
|
|
constty_clear(void)
|
|
|
|
{
|
|
|
|
int c;
|
|
|
|
|
|
|
|
constty = NULL;
|
|
|
|
if (consbuf == NULL)
|
|
|
|
return;
|
|
|
|
callout_stop(&conscallout);
|
|
|
|
while ((c = msgbuf_getchar(&consmsgbuf)) != -1)
|
|
|
|
cnputc(c);
|
|
|
|
free(consbuf, M_TTYS);
|
|
|
|
consbuf = NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Times per second to check for pending console tty messages. */
|
|
|
|
static int constty_wakeups_per_second = 5;
|
|
|
|
SYSCTL_INT(_kern, OID_AUTO, constty_wakeups_per_second, CTLFLAG_RW,
|
|
|
|
&constty_wakeups_per_second, 0, "");
|
|
|
|
|
|
|
|
static void
|
|
|
|
constty_timeout(void *arg)
|
|
|
|
{
|
|
|
|
int c;
|
|
|
|
|
|
|
|
while (constty != NULL && (c = msgbuf_getchar(&consmsgbuf)) != -1) {
|
|
|
|
if (tputchar(c, constty) < 0)
|
|
|
|
constty = NULL;
|
|
|
|
}
|
|
|
|
if (constty != NULL) {
|
|
|
|
callout_reset(&conscallout, hz / constty_wakeups_per_second,
|
|
|
|
constty_timeout, NULL);
|
|
|
|
} else {
|
|
|
|
/* Deallocate the constty buffer memory. */
|
|
|
|
constty_clear();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2003-03-09 20:42:49 +00:00
|
|
|
static void
|
|
|
|
cn_drvinit(void *unused)
|
|
|
|
{
|
|
|
|
|
|
|
|
make_dev(&cn_cdevsw, 0, UID_ROOT, GID_WHEEL, 0600, "console");
|
2006-11-01 04:54:51 +00:00
|
|
|
|
|
|
|
mtx_init(&cnputs_mtx, "cnputs_mtx", NULL, MTX_SPIN | MTX_NOWITNESS);
|
|
|
|
use_cnputs_mtx = 1;
|
2003-03-09 20:42:49 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
SYSINIT(cndev, SI_SUB_DRIVERS, SI_ORDER_MIDDLE, cn_drvinit, NULL)
|