d/freebsd-skq
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Implement multiple low-level console support.

Browse Source
This commit is contained in:
jlemon 2001-10-23 20:25:50 +00:00
parent 6a7e9433d1
commit b7e177fee6
6 changed files with 341 additions and 247 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
sys/amd64/amd64/autoconf.c
View File

@ -176,7 +176,7 @@ configure_final(dummy)
{
int i;
cninit_finish();
/* cninit_finish(); */
if (bootverbose) {

2
sys/i386/i386/autoconf.c
View File

@ -176,7 +176,7 @@ configure_final(dummy)
{
int i;
cninit_finish();
/* cninit_finish(); */
if (bootverbose) {

563
sys/kern/tty_cons.c
View File

@ -44,11 +44,15 @@
#include <sys/conf.h>
#include <sys/cons.h>
#include <sys/kernel.h>
#include <sys/malloc.h>
#include <sys/namei.h>
#include <sys/proc.h>
#include <sys/queue.h>
#include <sys/reboot.h>
#include <sys/sysctl.h>
#include <sys/tty.h>
#include <sys/uio.h>
#include <sys/vnode.h>
#include <machine/cpu.h>
@ -78,47 +82,43 @@ static struct cdevsw cn_cdevsw = {
/* kqfilter */ cnkqfilter,
};
static dev_t cn_dev_t; /* seems to be never really used */
struct cn_device {
STAILQ_ENTRY(cn_device) cnd_next;
char cnd_name[16];
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)))
static udev_t cn_udev_t;
SYSCTL_OPAQUE(_machdep, CPU_CONSDEV, consdev, CTLFLAG_RD,
&cn_udev_t, sizeof cn_udev_t, "T,dev_t", "");
static int cn_mute;
int cons_unavail = 0; /* XXX:
* physical console not available for
* input (i.e., it is in graphics mode)
*/
static u_char cn_is_open; /* nonzero if logical console is open */
static int openmode, openflag; /* how /dev/console was openned */
static int cn_mute;
static int openflag; /* how /dev/console was opened */
static int cn_is_open;
static dev_t cn_devfsdev; /* represents the device private info */
static u_char cn_phys_is_open; /* nonzero if physical device is open */
static d_close_t *cn_phys_close; /* physical device close function */
static d_open_t *cn_phys_open; /* physical device open function */
struct consdev *cn_tab; /* physical console device info */
CONS_DRIVER(cons, NULL, NULL, NULL, NULL, NULL, NULL, NULL);
SET_DECLARE(cons_set, struct consdev);
void
cninit()
cninit(void)
{
struct consdev *best_cp, *cp, **list;
/*
* Find the first console with the highest priority.
*/
best_cp = NULL;
SET_FOREACH(list, cons_set) {
cp = *list;
if (cp->cn_probe == NULL)
continue;
(*cp->cn_probe)(cp);
if (cp->cn_pri > CN_DEAD &&
(best_cp == NULL || cp->cn_pri > best_cp->cn_pri))
best_cp = cp;
}
struct consdev *best_cn, *cn, **list;
/*
* Check if we should mute the console (for security reasons perhaps)
@ -131,74 +131,176 @@ cninit()
|RB_VERBOSE
|RB_ASKNAME
|RB_CONFIG)) == RB_MUTE);
/*
* If no console, give up.
*/
if (best_cp == NULL) {
if (cn_tab != NULL && cn_tab->cn_term != NULL)
(*cn_tab->cn_term)(cn_tab);
cn_tab = best_cp;
return;
}
/*
* Initialize console, then attach to it. This ordering allows
* debugging using the previous console, if any.
* Find the first console with the highest priority.
*/
(*best_cp->cn_init)(best_cp);
if (cn_tab != NULL && cn_tab != best_cp) {
/* Turn off the previous console. */
if (cn_tab->cn_term != NULL)
(*cn_tab->cn_term)(cn_tab);
best_cn = NULL;
SET_FOREACH(list, cons_set) {
cn = *list;
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.
*/
cnadd(cn);
cn->cn_init(cn);
}
}
cn_tab = best_cp;
if (best_cn == NULL)
return;
if ((boothowto & RB_MULTIPLE) == 0) {
cnadd(best_cn);
best_cn->cn_init(best_cn);
}
/*
* Make the best console the preferred console.
*/
cnselect(best_cn);
}
/* 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;
}
if (cnd->cnd_cn != NULL)
return (ENOMEM);
cnd->cnd_cn = cn;
STAILQ_INSERT_TAIL(&cn_devlist, cnd, cnd_next);
return (0);
}
void
cninit_finish()
cnremove(struct consdev *cn)
{
struct cdevsw *cdp;
struct cn_device *cnd;
if ((cn_tab == NULL) || cn_mute)
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;
cnd->cnd_name[0] = '\0';
#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
return;
/*
* Hook the open and close functions.
*/
cdp = devsw(cn_tab->cn_dev);
if (cdp != NULL) {
cn_phys_close = cdp->d_close;
cdp->d_close = cnclose;
cn_phys_open = cdp->d_open;
cdp->d_open = cnopen;
}
cn_dev_t = cn_tab->cn_dev;
cn_udev_t = dev2udev(cn_dev_t);
}
static void
cnuninit(void)
void
cnselect(struct consdev *cn)
{
struct cdevsw *cdp;
struct cn_device *cnd;
if (cn_tab == NULL)
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);
return;
/*
* Unhook the open and close functions.
*/
cdp = devsw(cn_tab->cn_dev);
if (cdp != NULL) {
cdp->d_close = cn_phys_close;
cdp->d_open = cn_phys_open;
}
cn_phys_close = NULL;
cn_phys_open = NULL;
cn_dev_t = NODEV;
cn_udev_t = NOUDEV;
}
void
cndebug(char *str)
{
int i, len;
len = strlen(str);
cnputc('>'); cnputc('>'); cnputc('>'); cnputc(' ');
for (i = 0; i < len; i++)
cnputc(str[i]);
cnputc('\n');
}
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;
if (cp->cn_dev != NULL)
len += strlen(devtoname(cp->cn_dev)) + 1;
}
STAILQ_FOREACH(cnd, &cn_devlist, cnd_next)
len += strlen(devtoname(cnd->cnd_cn->cn_dev)) + 1;
len = len > CNDEVPATHMAX ? len : CNDEVPATHMAX;
MALLOC(name, char *, len, M_TEMP, M_WAITOK | M_ZERO);
p = name;
STAILQ_FOREACH(cnd, &cn_devlist, cnd_next)
p += sprintf(p, "%s,", devtoname(cnd->cnd_cn->cn_dev));
*p++ = '/';
SET_FOREACH(list, cons_set) {
cp = *list;
if (cp->cn_dev != NULL)
p += sprintf(p, "%s,", devtoname(cp->cn_dev));
}
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;
if (cp->cn_dev == NULL ||
strcmp(p, devtoname(cp->cn_dev)) != 0)
continue;
if (delete) {
cnremove(cp);
error = 0;
} else {
error = cnadd(cp);
if (error == 0)
cnselect(cp);
}
break;
}
}
FREE(name, M_TEMP);
return (error);
}
SYSCTL_PROC(_kern, OID_AUTO, console, CTLTYPE_STRING|CTLFLAG_RW,
0, 0, sysctl_kern_console, "A", "Console device control");
/*
* User has changed the state of the console muting.
* This may require us to open or close the device in question.
@ -211,165 +313,123 @@ sysctl_kern_consmute(SYSCTL_HANDLER_ARGS)
ocn_mute = cn_mute;
error = sysctl_handle_int(oidp, &cn_mute, 0, req);
if((error == 0) && (cn_tab != NULL) && (req->newptr != NULL)) {
if(ocn_mute && !cn_mute) {
/*
* going from muted to unmuted.. open the physical dev
* if the console has been openned
*/
cninit_finish();
if(cn_is_open)
/* XXX curthread is not what we want really */
error = cnopen(cn_dev_t, openflag,
openmode, curthread);
/* if it failed, back it out */
if ( error != 0) cnuninit();
} else if (!ocn_mute && cn_mute) {
/*
* going from unmuted to muted.. close the physical dev
* if it's only open via /dev/console
*/
if(cn_is_open)
error = cnclose(cn_dev_t, openflag,
openmode, curthread);
if ( error == 0) cnuninit();
}
if (error != 0) {
/*
* back out the change if there was an error
*/
cn_mute = ocn_mute;
}
if (error != 0 || req->newptr == NULL)
return (error);
if (ocn_mute && !cn_mute && cn_is_open)
error = cnopen(NODEV, openflag, 0, curthread);
else if (!ocn_mute && cn_mute && cn_is_open) {
error = cnclose(NODEV, openflag, 0, curthread);
cn_is_open = 1; /* XXX hack */
}
return (error);
}
SYSCTL_PROC(_kern, OID_AUTO, consmute, CTLTYPE_INT|CTLFLAG_RW,
0, sizeof cn_mute, sysctl_kern_consmute, "I", "");
0, sizeof(cn_mute), sysctl_kern_consmute, "I", "");
static int
cnopen(dev, flag, mode, td)
dev_t dev;
int flag, mode;
struct thread *td;
cn_devopen(struct cn_device *cnd, struct thread *td, int forceopen)
{
dev_t cndev, physdev;
int retval = 0;
char path[CNDEVPATHMAX];
struct nameidata nd;
dev_t dev;
int error;
if (cn_tab == NULL || cn_phys_open == NULL)
return (0);
cndev = cn_tab->cn_dev;
physdev = (major(dev) == major(cndev) ? dev : cndev);
/*
* If mute is active, then non console opens don't get here
* so we don't need to check for that. They
* bypass this and go straight to the device.
*/
if(!cn_mute)
retval = (*cn_phys_open)(physdev, flag, mode, td);
if (retval == 0) {
/*
* check if we openned it via /dev/console or
* via the physical entry (e.g. /dev/sio0).
*/
if (dev == cndev)
cn_phys_is_open = 1;
else if (physdev == cndev) {
openmode = mode;
openflag = flag;
cn_is_open = 1;
if (cnd->cnd_vp != NULL) {
if (!forceopen) {
dev = cnd->cnd_vp->v_rdev;
return ((*devsw(dev)->d_open)(dev, openflag, 0, td));
}
dev->si_tty = physdev->si_tty;
vn_close(cnd->cnd_vp, openflag, td->td_proc->p_ucred, td);
cnd->cnd_vp = NULL;
}
return (retval);
if (cnd->cnd_name[0] == '\0')
strncpy(cnd->cnd_name, devtoname(cnd->cnd_cn->cn_dev),
sizeof(cnd->cnd_name));
snprintf(path, sizeof(path), "/dev/%s", cnd->cnd_name);
NDINIT(&nd, LOOKUP, FOLLOW, UIO_SYSSPACE, path, td);
error = vn_open(&nd, &openflag, 0);
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
vn_close(nd.ni_vp, openflag, td->td_proc->p_ucred, td);
}
return (cnd->cnd_vp != NULL);
}
static int
cnclose(dev, flag, mode, td)
dev_t dev;
int flag, mode;
struct thread *td;
cnopen(dev_t dev, int flag, int mode, struct thread *td)
{
dev_t cndev;
struct tty *cn_tp;
struct cn_device *cnd;
if (cn_tab == NULL || cn_phys_open == NULL)
openflag = flag;
cn_is_open = 1; /* console is logically open */
if (cn_mute)
return (0);
cndev = cn_tab->cn_dev;
cn_tp = cndev->si_tty;
/*
* act appropriatly depending on whether it's /dev/console
* or the pysical device (e.g. /dev/sio) that's being closed.
* in either case, don't actually close the device unless
* both are closed.
*/
if (dev == cndev) {
/* the physical device is about to be closed */
cn_phys_is_open = 0;
if (cn_is_open) {
if (cn_tp) {
/* perform a ttyhalfclose() */
/* reset session and proc group */
cn_tp->t_pgrp = NULL;
cn_tp->t_session = NULL;
}
return (0);
}
} else if (major(dev) != major(cndev)) {
/* the logical console is about to be closed */
cn_is_open = 0;
if (cn_phys_is_open)
return (0);
dev = cndev;
}
if(cn_phys_close)
return ((*cn_phys_close)(dev, flag, mode, td));
STAILQ_FOREACH(cnd, &cn_devlist, cnd_next)
cn_devopen(cnd, td, 0);
return (0);
}
static int
cnread(dev, uio, flag)
dev_t dev;
struct uio *uio;
int flag;
cnclose(dev_t dev, int flag, int mode, struct thread *td)
{
struct cn_device *cnd;
if (cn_tab == NULL || cn_phys_open == NULL)
STAILQ_FOREACH(cnd, &cn_devlist, cnd_next) {
if (cnd->cnd_vp == NULL)
continue;
vn_close(cnd->cnd_vp, mode, td->td_proc->p_ucred, td);
cnd->cnd_vp = NULL;
}
cn_is_open = 0;
return (0);
}
static int
cnread(dev_t dev, struct uio *uio, int flag)
{
struct cn_device *cnd;
cnd = STAILQ_FIRST(&cn_devlist);
if (cn_mute || CND_INVALID(cnd, curthread))
return (0);
dev = cn_tab->cn_dev;
dev = cnd->cnd_vp->v_rdev;
return ((*devsw(dev)->d_read)(dev, uio, flag));
}
static int
cnwrite(dev, uio, flag)
dev_t dev;
struct uio *uio;
int flag;
cnwrite(dev_t dev, struct uio *uio, int flag)
{
struct cn_device *cnd;
if (cn_tab == NULL || cn_phys_open == NULL) {
uio->uio_resid = 0; /* dump the data */
return (0);
}
cnd = STAILQ_FIRST(&cn_devlist);
if (cn_mute || CND_INVALID(cnd, curthread))
goto done;
if (constty)
dev = constty->t_dev;
else
dev = cn_tab->cn_dev;
log_console(uio);
return ((*devsw(dev)->d_write)(dev, uio, flag));
dev = cnd->cnd_vp->v_rdev;
if (dev != NULL) {
log_console(uio);
return ((*devsw(dev)->d_write)(dev, uio, flag));
}
done:
uio->uio_resid = 0; /* dump the data */
return (0);
}
static int
cnioctl(dev, cmd, data, flag, td)
dev_t dev;
u_long cmd;
caddr_t data;
int flag;
struct thread *td;
cnioctl(dev_t dev, u_long cmd, caddr_t data, int flag, struct thread *td)
{
struct cn_device *cnd;
int error;
if (cn_tab == NULL || cn_phys_open == NULL)
cnd = STAILQ_FIRST(&cn_devlist);
if (cn_mute || CND_INVALID(cnd, td))
return (0);
/*
* Superuser can always use this to wrest control of console
@ -382,82 +442,111 @@ cnioctl(dev, cmd, data, flag, td)
constty = NULL;
return (0);
}
dev = cn_tab->cn_dev;
return ((*devsw(dev)->d_ioctl)(dev, cmd, data, flag, td));
dev = cnd->cnd_vp->v_rdev;
if (dev != NULL)
return ((*devsw(dev)->d_ioctl)(dev, cmd, data, flag, td));
return (0);
}
/*
* XXX
* poll/kqfilter do not appear to be correct
*/
static int
cnpoll(dev_t dev, int events, struct thread *td)
{
struct cn_device *cnd;
cnd = STAILQ_FIRST(&cn_devlist);
if (cn_mute || CND_INVALID(cnd, td))
return (0);
dev = cnd->cnd_vp->v_rdev;
if (dev != NULL)
return ((*devsw(dev)->d_poll)(dev, events, td));
return (0);
}
static int
cnpoll(dev, events, td)
dev_t dev;
int events;
struct thread *td;
cnkqfilter(dev_t dev, struct knote *kn)
{
if ((cn_tab == NULL) || cn_mute)
struct cn_device *cnd;
cnd = STAILQ_FIRST(&cn_devlist);
if (cn_mute || CND_INVALID(cnd, curthread))
return (1);
dev = cn_tab->cn_dev;
return ((*devsw(dev)->d_poll)(dev, events, td));
}
static int
cnkqfilter(dev, kn)
dev_t dev;
struct knote *kn;
{
if ((cn_tab == NULL) || cn_mute)
return (1);
dev = cn_tab->cn_dev;
if (devsw(dev)->d_flags & D_KQFILTER)
dev = cnd->cnd_vp->v_rdev;
if (dev != NULL)
return ((*devsw(dev)->d_kqfilter)(dev, kn));
return (1);
}
/*
* Low level console routines.
*/
int
cngetc()
cngetc(void)
{
int c;
if ((cn_tab == NULL) || cn_mute)
if (cn_mute)
return (-1);
c = (*cn_tab->cn_getc)(cn_tab->cn_dev);
if (c == '\r') c = '\n'; /* console input is always ICRNL */
while ((c = cncheckc()) == -1)
;
if (c == '\r')
c = '\n'; /* console input is always ICRNL */
return (c);
}
int
cncheckc()
cncheckc(void)
{
if ((cn_tab == NULL) || cn_mute)
struct cn_device *cnd;
struct consdev *cn;
int c;
if (cn_mute)
return (-1);
return ((*cn_tab->cn_checkc)(cn_tab->cn_dev));
STAILQ_FOREACH(cnd, &cn_devlist, cnd_next) {
cn = cnd->cnd_cn;
c = cn->cn_checkc(cn->cn_dev);
if (c != -1) {
return (c);
}
}
return (-1);
}
void
cnputc(c)
register int c;
cnputc(int c)
{
if ((cn_tab == NULL) || cn_mute)
struct cn_device *cnd;
struct consdev *cn;
if (cn_mute || c == '\0')
return;
if (c) {
STAILQ_FOREACH(cnd, &cn_devlist, cnd_next) {
cn = cnd->cnd_cn;
if (c == '\n')
(*cn_tab->cn_putc)(cn_tab->cn_dev, '\r');
(*cn_tab->cn_putc)(cn_tab->cn_dev, c);
cn->cn_putc(cn->cn_dev, '\r');
cn->cn_putc(cn->cn_dev, c);
}
}
void
cndbctl(on)
int on;
cndbctl(int on)
{
struct cn_device *cnd;
struct consdev *cn;
static int refcount;
if (cn_tab == NULL)
return;
if (!on)
refcount--;
if (refcount == 0 && cn_tab->cn_dbctl != NULL)
(*cn_tab->cn_dbctl)(cn_tab->cn_dev, on);
if (refcount == 0)
STAILQ_FOREACH(cnd, &cn_devlist, cnd_next) {
cn = cnd->cnd_cn;
if (cn->cn_dbctl != NULL)
cn->cn_dbctl(cn->cn_dev, on);
}
if (on)
refcount++;
}

2
sys/sys/conf.h
View File

@ -60,6 +60,8 @@ struct specinfo {
#define SI_NAMED 0x0004 /* make_dev{_alias} has been called */
#define SI_CHEAPCLONE 0x0008 /* can be removed_dev'ed when vnode reclaims */
#define SI_CHILD 0x0010 /* child of another dev_t */
#define SI_DEVOPEN 0x0020 /* opened by device */
#define SI_CONSOPEN 0x0040 /* opened by console */
struct timespec si_atime;
struct timespec si_ctime;
struct timespec si_mtime;

17
sys/sys/cons.h
View File

@ -78,8 +78,7 @@ struct consdev {
#define CN_REMOTE 3 /* serial interface with remote bit set */
#ifdef _KERNEL
extern int cons_unavail;
extern struct consdev *cn_tab;
extern int cons_unavail;
#define CONS_DRIVER(name, probe, init, term, getc, checkc, putc, dbctl) \
static struct consdev name##_consdev = { \
@ -88,12 +87,14 @@ extern struct consdev *cn_tab;
DATA_SET(cons_set, name##_consdev)
/* Other kernel entry points. */
int cncheckc __P((void));
int cngetc __P((void));
void cninit __P((void));
void cninit_finish __P((void));
void cndbctl __P((int));
void cnputc __P((int));
void cninit(void);
int cnadd(struct consdev *);
void cnremove(struct consdev *);
void cnselect(struct consdev *);
int cncheckc(void);
int cngetc(void);
void cndbctl(int);
void cnputc(int);
#endif /* _KERNEL */

2
sys/sys/linedisc.h
View File

@ -60,6 +60,8 @@ struct specinfo {
#define SI_NAMED 0x0004 /* make_dev{_alias} has been called */
#define SI_CHEAPCLONE 0x0008 /* can be removed_dev'ed when vnode reclaims */
#define SI_CHILD 0x0010 /* child of another dev_t */
#define SI_DEVOPEN 0x0020 /* opened by device */
#define SI_CONSOPEN 0x0040 /* opened by console */
struct timespec si_atime;
struct timespec si_ctime;
struct timespec si_mtime;