common/os/console.c

/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License (the "License").
 * You may not use this file except in compliance with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */

/*
 * Copyright 2008 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 *
 * Copyright 2026 Oxide Computer Company
 */

#include <sys/types.h>
#include <sys/varargs.h>
#include <sys/modctl.h>
#include <sys/cmn_err.h>
#include <sys/console.h>
#include <sys/consdev.h>
#include <sys/promif.h>
#include <sys/note.h>
#include <sys/systm.h>
#include <sys/file.h>
#include <sys/conf.h>
#include <sys/kmem.h>
#include <sys/taskq.h>
#include <sys/log.h>
#include <sys/ddi.h>
#include <sys/sunddi.h>
#include <sys/esunddi.h>
#include <sys/fs/snode.h>
#include <sys/termios.h>
#include <sys/tem_impl.h>

#define	MINLINES	10
#define	MAXLINES	48
#define	LOSCREENLINES	34
#define	HISCREENLINES	48

#define	MINCOLS		10
#define	MAXCOLS		120
#define	LOSCREENCOLS	80
#define	HISCREENCOLS	120

vnode_t *console_vnode;
taskq_t *console_taskq;

/*
 * The current set of polled I/O routines (if any)
 */
struct cons_polledio *cons_polledio;

/*
 * Ask the console driver to prepare for polled use by the debugger or by
 * panic, and to undo that afterwards. These may be called with the system in
 * an arbitrary state, including from the debugger with every other CPU
 * stopped, so the driver hooks behind them must not take any locks nor
 * depend on any other kernel service.
 */
void
console_polled_enter(void)
{
	if (cons_polledio != NULL &&
	    cons_polledio->cons_polledio_enter != NULL) {
		cons_polledio->cons_polledio_enter(
		    cons_polledio->cons_polledio_argument);
	}
}

void
console_polled_exit(void)
{
	if (cons_polledio != NULL &&
	    cons_polledio->cons_polledio_exit != NULL) {
		cons_polledio->cons_polledio_exit(
		    cons_polledio->cons_polledio_argument);
	}
}

/*
 * Console I/O Routines
 *
 * In the event that kernel messages are generated with cmn_err(9F) or printf()
 * early in boot, after a panic, in resource-constrained situations, or sent
 * through /dev/console to the wscons driver, we may be called upon to render
 * characters directly to the frame buffer using the underlying prom_*()
 * routines.  These in turn may attempt to use PROM services directly, or may
 * use a kernel console emulator if one is available.  Unfortunately, if PROM
 * services are being used by the kernel on a multi-CPU system, these routines
 * might be called while another CPU is simultaneously accessing a frame buffer
 * memory mapping (perhaps through the X server).  This situation may not be
 * supported by the frame buffer hardware.
 *
 * To handle this situation, we implement a two-phase locking scheme which we
 * use to protect accesses to the underlying prom_*() rendering routines.  The
 * common-code functions console_hold() and console_rele() are used to gain
 * exclusive access to the console from within the kernel.  We use a standard
 * r/w lock in writer-mode only to implement the kernel lock.  We use an r/w
 * lock instead of a mutex here because character rendering is slow and hold
 * times will be relatively long, and there is no point in adaptively spinning.
 * These routines may be called recursively, in which case subsequent calls
 * just increment the console_depth hold count.  Once exclusive access is
 * gained, we grab the frame buffer device node and block further mappings to
 * it by holding the specfs node lock and the device node's lock.  We then
 * observe if any mappings are present by examining the specfs node's s_mapcnt
 * (non-clone mmaps) and the devinfo node's devi_ref count (clone opens).
 *
 * Then, around each character rendering call, the routines console_enter()
 * and console_exit() are used to inform the platform code that we are
 * accessing the character rendering routines.  These platform routines can
 * then examine the "busy" flag returned by console_enter() and briefly stop
 * the other CPUs so that they cannot access the frame buffer hardware while
 * we are busy rendering characters.  This mess can all be removed when the
 * impossible dream of a unified kernel console emulator is someday realized.
 */

static krwlock_t console_lock;
static uint_t console_depth;
static int console_busy;

extern void pm_cfb_check_and_powerup(void);
extern void pm_cfb_rele(void);

static int
console_hold(void)
{
	if (panicstr != NULL)
		return (console_busy); /* assume exclusive access in panic */

	if (rw_owner(&console_lock) != curthread)
		rw_enter(&console_lock, RW_WRITER);

	if (console_depth++ != 0)
		return (console_busy); /* lock is being entered recursively */

	pm_cfb_check_and_powerup();

#ifdef _HAVE_TEM_FIRMWARE
	if (consmode == CONS_FW && ncpus > 1 && fbvp != NULL) {
		struct snode *csp = VTOS(VTOS(fbvp)->s_commonvp);

		mutex_enter(&csp->s_lock);
		console_busy = csp->s_mapcnt != 0;

		if (csp->s_mapcnt == 0 && fbdip != NULL) {
			mutex_enter(&DEVI(fbdip)->devi_lock);
			console_busy = DEVI(fbdip)->devi_ref != 0;
		}
	}
#endif /* _HAVE_TEM_FIRMWARE */
	return (console_busy);
}

static void
console_rele(void)
{
	if (panicstr != NULL)
		return; /* do not modify lock states if we are panicking */

	ASSERT(RW_WRITE_HELD(&console_lock));
	ASSERT(console_depth != 0);

	if (--console_depth != 0)
		return; /* lock is being dropped recursively */

#ifdef _HAVE_TEM_FIRMWARE
	if (consmode == CONS_FW && ncpus > 1 && fbvp != NULL) {
		struct snode *csp = VTOS(VTOS(fbvp)->s_commonvp);

		ASSERT(MUTEX_HELD(&csp->s_lock));
		if (csp->s_mapcnt == 0 && fbdip != NULL)
			mutex_exit(&DEVI(fbdip)->devi_lock);

		mutex_exit(&csp->s_lock);
	}
#endif /* _HAVE_TEM_FIRMWARE */
	pm_cfb_rele();
	console_busy = 0;
	rw_exit(&console_lock);
}

static void
console_getprop(dev_t dev, dev_info_t *dip, char *name, ushort_t *sp)
{
	uchar_t *data;
	uint_t len;
	uint_t i;

	*sp = 0;
	if (ddi_prop_lookup_byte_array(dev, dip, 0, name, &data, &len) ==
	    DDI_PROP_SUCCESS) {
		for (i = 0; i < len; i++) {
			if (data[i] < '0' || data[i] > '9')
				break;
			*sp = *sp * 10 + data[i] - '0';
		}
		ddi_prop_free(data);
	}
}

/*
 * Gets the number of rows and columns (in char's) and the
 * width and height (in pixels) of the console.
 */
void
console_get_size(ushort_t *r, ushort_t *c, ushort_t *x, ushort_t *y)
{
	int rel_needed = 0;
	dev_info_t *dip;
	dev_t dev;

	/*
	 * If we have loaded the console IO stuff, then ask for the screen
	 * size properties from the layered terminal emulator.  Else ask for
	 * them from the root node, which will eventually fall through to the
	 * options node and get them from the prom.
	 */
	if (rwsconsvp == NULL || consmode == CONS_FW) {
		dip = ddi_root_node();
		dev = DDI_DEV_T_ANY;
	} else {
		dev = rwsconsvp->v_rdev; /* layering is wc -> tem */
		dip = e_ddi_hold_devi_by_dev(dev, 0);
		rel_needed = 1;
	}

	/*
	 * If we have not initialized a console yet and don't have a root
	 * node (ie. we have not initialized the DDI yet) return our default
	 * size for the screen.
	 */
	if (dip == NULL) {
		*r = LOSCREENLINES;
		*c = LOSCREENCOLS;
		*x = *y = 0;
		return;
	}

	console_getprop(DDI_DEV_T_ANY, dip, "screen-#columns", c);
	console_getprop(DDI_DEV_T_ANY, dip, "screen-#rows", r);
	console_getprop(DDI_DEV_T_ANY, dip, "screen-width", x);
	console_getprop(DDI_DEV_T_ANY, dip, "screen-height", y);

	if (*c < MINCOLS)
		*c = LOSCREENCOLS;
	else if (*c > MAXCOLS)
		*c = HISCREENCOLS;

	if (*r < MINLINES)
		*r = LOSCREENLINES;
	else if (*r > MAXLINES)
		*r = HISCREENLINES;

	if (rel_needed)
		ddi_release_devi(dip);
}

typedef struct console_msg {
	size_t	cm_size;
	char	cm_text[1];
} console_msg_t;

/*
 * If we can't access the console stream, fall through to PROM, which redirects
 * it back into to terminal emulator as appropriate.  The console stream should
 * be available after consconfig runs.
 */
static void
console_putmsg(console_msg_t *cm)
{
	int busy, spl;
	ssize_t res;

	ASSERT(taskq_member(console_taskq, curthread));

	if (rconsvp == NULL || panicstr ||
	    vn_rdwr(UIO_WRITE, console_vnode, cm->cm_text, strlen(cm->cm_text),
	    0, UIO_SYSSPACE, FAPPEND, (rlim64_t)LOG_HIWAT, kcred, &res) != 0) {

		busy = console_hold();
		spl = console_enter(busy);

		prom_printf("%s", cm->cm_text);

		console_exit(busy, spl);
		console_rele();
	}

	kmem_free(cm, cm->cm_size);
}

void
console_vprintf(const char *fmt, va_list adx)
{
	console_msg_t *cm;
	size_t len = vsnprintf(NULL, 0, fmt, adx);
	int busy, spl;

	if (console_taskq != NULL && rconsvp != NULL && panicstr == NULL &&
	    (cm = kmem_alloc(sizeof (*cm) + len, KM_NOSLEEP)) != NULL) {
		cm->cm_size = sizeof (*cm) + len;
		(void) vsnprintf(cm->cm_text, len + 1, fmt, adx);
		if (taskq_dispatch(console_taskq, (task_func_t *)console_putmsg,
		    cm, TQ_NOSLEEP) != TASKQID_INVALID)
			return;
		kmem_free(cm, cm->cm_size);
	}

	busy = console_hold();
	spl = console_enter(busy);

	prom_vprintf(fmt, adx);

	console_exit(busy, spl);
	console_rele();
}

/*PRINTFLIKE1*/
void
console_printf(const char *fmt, ...)
{
	va_list adx;

	va_start(adx, fmt);
	console_vprintf(fmt, adx);
	va_end(adx);
}

/*
 * Avoid calling this function.
 *
 * Nothing in the kernel besides the wscons driver (wc) uses this
 * function. It may hopefully one day be removed altogether.
 * If a wayward module calls this they will pass through to PROM,
 * get redirected into the kernel emulator as appropriate.
 */
void
console_puts(const char *s, size_t n)
{
	int busy, spl;

	busy = console_hold();
	spl = console_enter(busy);

	prom_writestr(s, n);

	console_exit(busy, spl);
	console_rele();
}

/*
 * Let this function just go straight through to the PROM, since
 * we are called in early boot prior to the kernel terminal
 * emulator being available, and prior to the PROM stdout redirect
 * vector being set.
 */
static void
console_putc(int c)
{
	int busy = console_hold();
	int spl = console_enter(busy);

	if (c == '\n')
		prom_putchar('\r');
	prom_putchar(c);

	console_exit(busy, spl);
	console_rele();
}

/*
 * Read a string from the console device.  We only permit synchronous
 * conversation between the kernel and a console user early in boot prior to
 * the initialization of rconsvp.
 */
void
console_gets(char *s, size_t len)
{
	char *p = s;
	char *q = s + len - 1;
	int c;

	ASSERT(rconsvp == NULL);
	(void) console_hold();

	for (;;) {
		switch (c = (prom_getchar() & 0x7f)) {
		case 0x7f: /* DEL */
			if (p == s)
				break;
			console_putc(c);
			c = '\b';
			/*FALLTHRU*/

		case '\b':
			if (p == s)
				break;
			console_putc('\b');
			console_putc(' ');
			/*FALLTHRU*/

		case '#': /* historical backspace alias */
			console_putc(c);
			if (p > s)
				p--;
			break;

		case CTRL('u'):
			console_putc(c);
			console_putc('\n');
			p = s;
			break;

		case '\r':
		case '\n':
			console_putc('\n');
			goto done;

		default:
			if (p < q) {
				console_putc(c);
				*p++ = c;
			} else
				console_putc('\a');
		}
	}
done:
	console_rele();
	*p = '\0';
}

/*
 * Read a character from the console device.  Synchronous conversation between
 * the kernel and a console user is only permitted early in boot prior to the
 * initialization of rconsvp.
 */
int
console_getc(void)
{
	int c;

	ASSERT(rconsvp == NULL);
	c = prom_getchar();

	if (c == '\r')
		c = '\n';

	console_putc(c);
	return (c);
}