xref: /illumos-gate/usr/src/uts/common/io/cons.c (revision a64c6771e32828fb411900a3d0921d4da3c4459c)
1 /*
2  * CDDL HEADER START
3  *
4  * The contents of this file are subject to the terms of the
5  * Common Development and Distribution License (the "License").
6  * You may not use this file except in compliance with the License.
7  *
8  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9  * or http://www.opensolaris.org/os/licensing.
10  * See the License for the specific language governing permissions
11  * and limitations under the License.
12  *
13  * When distributing Covered Code, include this CDDL HEADER in each
14  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15  * If applicable, add the following below this CDDL HEADER, with the
16  * fields enclosed by brackets "[]" replaced with your own identifying
17  * information: Portions Copyright [yyyy] [name of copyright owner]
18  *
19  * CDDL HEADER END
20  */
21 
22 /*
23  * Copyright (c) 1982, 2010, Oracle and/or its affiliates. All rights reserved.
24  */
25 
26 /*
27  * Indirect console driver for Sun.
28  *
29  * Redirects all I/O to the device designated as the underlying "hardware"
30  * console, as given by the value of rconsvp.  The implementation assumes that
31  * rconsvp denotes a STREAMS device; the assumption is justified since
32  * consoles must be capable of effecting tty semantics.
33  *
34  * rconsvp is set in autoconf.c:consconfig(), based on information obtained
35  * from the EEPROM.
36  *
37  * XXX:	The driver still needs to be converted to use ANSI C consistently
38  *	throughout.
39  */
40 
41 #include <sys/types.h>
42 #include <sys/open.h>
43 #include <sys/param.h>
44 #include <sys/systm.h>
45 #include <sys/signal.h>
46 #include <sys/cred.h>
47 #include <sys/user.h>
48 #include <sys/proc.h>
49 #include <sys/disp.h>
50 #include <sys/file.h>
51 #include <sys/taskq.h>
52 #include <sys/log.h>
53 #include <sys/vnode.h>
54 #include <sys/uio.h>
55 #include <sys/stat.h>
56 
57 #include <sys/console.h>
58 #include <sys/consdev.h>
59 
60 #include <sys/stream.h>
61 #include <sys/strsubr.h>
62 #include <sys/poll.h>
63 
64 #include <sys/debug.h>
65 
66 #include <sys/conf.h>
67 #include <sys/ddi.h>
68 #include <sys/sunddi.h>
69 #include <sys/vt.h>
70 
71 static int cnopen(dev_t *, int, int, struct cred *);
72 static int cnclose(dev_t, int, int, struct cred *);
73 static int cnread(dev_t, struct uio *, struct cred *);
74 static int cnwrite(dev_t, struct uio *, struct cred *);
75 static int cnioctl(dev_t, int, intptr_t, int, struct cred *, int *);
76 static int cnpoll(dev_t, short, int, short *, struct pollhead **);
77 static int cn_info(dev_info_t *, ddi_info_cmd_t, void *, void **);
78 static int cn_attach(dev_info_t *, ddi_attach_cmd_t);
79 static int cn_detach(dev_info_t *, ddi_detach_cmd_t);
80 
81 static dev_info_t *cn_dip;		/* private copy of devinfo pointer */
82 
83 static struct cb_ops cn_cb_ops = {
84 
85 	cnopen,			/* open */
86 	cnclose,		/* close */
87 	nodev,			/* strategy */
88 	nodev,			/* print */
89 	nodev,			/* dump */
90 	cnread,			/* read */
91 	cnwrite,		/* write */
92 	cnioctl,		/* ioctl */
93 	nodev,			/* devmap */
94 	nodev,			/* mmap */
95 	nodev, 			/* segmap */
96 	cnpoll,			/* poll */
97 	ddi_prop_op,		/* cb_prop_op */
98 	0,			/* streamtab  */
99 	D_NEW | D_MP		/* Driver compatibility flag */
100 
101 };
102 
103 static struct dev_ops cn_ops = {
104 
105 	DEVO_REV,		/* devo_rev, */
106 	0,			/* refcnt  */
107 	cn_info,		/* info */
108 	nulldev,		/* identify */
109 	nulldev,		/* probe */
110 	cn_attach,		/* attach */
111 	cn_detach,		/* detach */
112 	nodev,			/* reset */
113 	&cn_cb_ops,		/* driver operations */
114 	(struct bus_ops *)0,	/* bus operations */
115 	NULL,			/* power */
116 	ddi_quiesce_not_needed,		/* quiesce */
117 
118 };
119 
120 /*
121  * Global variables associated with the console device:
122  *
123  * XXX:	There are too many of these!
124  * moved to space.c to become resident in the kernel so that cons
125  * can be loadable.
126  */
127 
128 extern dev_t	rconsdev;	/* "hardware" console */
129 extern vnode_t	*rconsvp;	/* pointer to vnode for that device */
130 
131 /*
132  * XXX: consulted in prsubr.c, for /proc entry point for obtaining ps info.
133  */
134 extern dev_t	uconsdev;	/* What the user thinks is the console device */
135 
136 /*
137  * Private driver state:
138  */
139 
140 /*
141  * The underlying console device potentially can be opened through (at least)
142  * two paths: through this driver and through the underlying device's driver.
143  * To ensure that reference counts are meaningful and therefore that close
144  * routines are called at the right time, it's important to make sure that
145  * rconsvp's s_count field (i.e., the count on the underlying device) never
146  * has a contribution of more than one through this driver, regardless of how
147  * many times this driver's been opened.  rconsopen keeps track of the
148  * necessary information to ensure this property.
149  */
150 static uint_t	rconsopen;
151 
152 
153 #include <sys/types.h>
154 #include <sys/conf.h>
155 #include <sys/param.h>
156 #include <sys/systm.h>
157 #include <sys/errno.h>
158 #include <sys/modctl.h>
159 
160 
161 extern int nodev(), nulldev();
162 extern int dseekneg_flag;
163 extern struct mod_ops mod_driverops;
164 extern struct dev_ops cn_ops;
165 
166 /*
167  * Module linkage information for the kernel.
168  */
169 
170 static struct modldrv modldrv = {
171 	&mod_driverops, /* Type of module.  This one is a pseudo driver */
172 	"Console redirection driver",
173 	&cn_ops,	/* driver ops */
174 };
175 
176 static struct modlinkage modlinkage = {
177 	MODREV_1,
178 	&modldrv,
179 	NULL
180 };
181 
182 int
183 _init(void)
184 {
185 	return (mod_install(&modlinkage));
186 }
187 
188 int
189 _fini(void)
190 {
191 	return (EBUSY);
192 }
193 
194 int
195 _info(struct modinfo *modinfop)
196 {
197 	return (mod_info(&modlinkage, modinfop));
198 }
199 
200 /*
201  * DDI glue routines
202  */
203 static int
204 cn_attach(dev_info_t *devi, ddi_attach_cmd_t cmd)
205 {
206 	if (cmd != DDI_ATTACH)
207 		return (DDI_FAILURE);
208 
209 	if (ddi_create_minor_node(devi, "syscon", S_IFCHR,
210 	    0, DDI_PSEUDO, 0) == DDI_FAILURE) {
211 		return (DDI_FAILURE);
212 	}
213 	if (ddi_create_minor_node(devi, "systty", S_IFCHR,
214 	    0, DDI_PSEUDO, 0) == DDI_FAILURE) {
215 		ddi_remove_minor_node(devi, NULL);
216 		return (DDI_FAILURE);
217 	}
218 	if (ddi_create_minor_node(devi, "console", S_IFCHR,
219 	    0, DDI_PSEUDO, 0) == DDI_FAILURE) {
220 		ddi_remove_minor_node(devi, NULL);
221 		return (DDI_FAILURE);
222 	}
223 
224 	cn_dip = devi;
225 	return (DDI_SUCCESS);
226 }
227 
228 static int
229 cn_detach(dev_info_t *devi, ddi_detach_cmd_t cmd)
230 {
231 	if (cmd != DDI_DETACH)
232 		return (DDI_FAILURE);
233 	ddi_remove_minor_node(devi, NULL);
234 	uconsdev = NODEV;
235 	return (DDI_SUCCESS);
236 }
237 
238 /* ARGSUSED */
239 static int
240 cn_info(dev_info_t *dip, ddi_info_cmd_t infocmd, void *arg, void **result)
241 {
242 	int error = DDI_FAILURE;
243 
244 	switch (infocmd) {
245 	case DDI_INFO_DEVT2DEVINFO:
246 		if (getminor((dev_t)arg) == 0 && cn_dip != NULL) {
247 			*result = (void *) cn_dip;
248 			error = DDI_SUCCESS;
249 		}
250 		break;
251 
252 	case DDI_INFO_DEVT2INSTANCE:
253 		if (getminor((dev_t)arg) == 0) {
254 			*result = (void *)0;
255 			error = DDI_SUCCESS;
256 		}
257 		break;
258 
259 	default:
260 		break;
261 	}
262 
263 	return (error);
264 }
265 
266 /*
267  * XXX	Caution: before allowing more than 256 minor devices on the
268  *	console, make sure you understand the 'compatibility' hack
269  *	in ufs_iget() that translates old dev_t's to new dev_t's.
270  *	See bugid 1098104 for the sordid details.
271  */
272 
273 /* ARGSUSED */
274 static int
275 cnopen(dev_t *dev, int flag, int state, struct cred *cred)
276 {
277 	int	err;
278 	static int	been_here;
279 	vnode_t	*vp = rconsvp;
280 
281 	ASSERT(cred != NULL);
282 
283 	if (rconsvp == NULL)
284 		return (0);
285 
286 	/*
287 	 * Enable virtual console I/O for console logging if needed.
288 	 */
289 	if (vsconsvp != NULL && vsconsvp->v_stream == NULL) {
290 		if (VOP_OPEN(&vsconsvp, FREAD | FWRITE, cred, NULL) != 0) {
291 			cmn_err(CE_WARN, "cnopen: failed to open vsconsvp "
292 			    "for virtual console logging");
293 		}
294 	}
295 
296 	/*
297 	 * XXX: Clean up inactive PIDs from previous opens if any.
298 	 * These would have been created as a result of an I_SETSIG
299 	 * issued against console.  This is a workaround, and
300 	 * console driver must be correctly redesigned not to need
301 	 * this hook.
302 	 */
303 	if (vp->v_stream) {
304 		str_cn_clean(vp);
305 	}
306 
307 	/*
308 	 * XXX:	Set hook to tell /proc about underlying console.  (There's
309 	 *	gotta be a better way...)
310 	 */
311 	if (state != OTYP_CHR || getminor(*dev) != 0)
312 		return (ENXIO);
313 	if (been_here == 0) {
314 		uconsdev = *dev;
315 		been_here = 1;
316 		if (vn_open("/dev/console", UIO_SYSSPACE, FWRITE | FNOCTTY,
317 		    0, &console_vnode, 0, 0) == 0)
318 			console_taskq = taskq_create("console_taskq",
319 			    1, maxclsyspri - 1, LOG_LOWAT / LOG_MSGSIZE,
320 			    LOG_HIWAT / LOG_MSGSIZE, TASKQ_PREPOPULATE);
321 	}
322 
323 	if ((err = VOP_OPEN(&vp, flag, cred, NULL)) != 0)
324 		return (err);
325 
326 	/*
327 	 * The underlying driver is not allowed to have cloned itself
328 	 * for this open.
329 	 */
330 	if (vp != rconsvp) {
331 		/*
332 		 * It might happen that someone set rconsvp to NULL
333 		 * whilst we were in the middle of the open.
334 		 */
335 		if (rconsvp == NULL) {
336 			(void) VOP_CLOSE(vp, flag, 1, (offset_t)0, cred, NULL);
337 			return (0);
338 		}
339 		cmn_err(CE_PANIC, "cnopen: cloned open");
340 	}
341 
342 	rconsopen++;
343 
344 	return (0);
345 }
346 
347 /* ARGSUSED */
348 static int
349 cnclose(dev_t dev, int flag, int state, struct cred *cred)
350 {
351 	int	err = 0;
352 	vnode_t	*vp;
353 
354 	/*
355 	 * Since this is the _last_ close, it's our last chance to close the
356 	 * underlying device.  (Note that if someone else has the underlying
357 	 * hardware console device open, we won't get here, since spec_close
358 	 * will see s_count > 1.)
359 	 */
360 	if (state != OTYP_CHR)
361 		return (ENXIO);
362 
363 	if (rconsvp == NULL)
364 		return (0);
365 
366 	while ((rconsopen != 0) && ((vp = rconsvp) != NULL)) {
367 		err = VOP_CLOSE(vp, flag, 1, (offset_t)0, cred, NULL);
368 		if (!err) {
369 			rconsopen--;
370 		}
371 	}
372 	return (err);
373 }
374 
375 /* ARGSUSED */
376 static int
377 cnread(dev_t dev, struct uio *uio, struct cred *cred)
378 {
379 	kcondvar_t	sleep_forever;
380 	kmutex_t	sleep_forever_mutex;
381 
382 	if (rconsvp == NULL) {
383 		/*
384 		 * Go to sleep forever.  This seems like the least
385 		 * harmful thing to do if there's no console.
386 		 * EOF might be better if we're ending up single-user
387 		 * mode.
388 		 */
389 		cv_init(&sleep_forever, NULL, CV_DRIVER, NULL);
390 		mutex_init(&sleep_forever_mutex, NULL, MUTEX_DRIVER, NULL);
391 		mutex_enter(&sleep_forever_mutex);
392 		(void) cv_wait_sig(&sleep_forever, &sleep_forever_mutex);
393 		mutex_exit(&sleep_forever_mutex);
394 		return (EIO);
395 	}
396 
397 	if (rconsvp->v_stream != NULL)
398 		return (strread(rconsvp, uio, cred));
399 	else
400 		return (cdev_read(rconsdev, uio, cred));
401 }
402 
403 /* ARGSUSED */
404 static int
405 cnwrite(dev_t dev, struct uio *uio, struct cred *cred)
406 {
407 	if (rconsvp == NULL) {
408 		uio->uio_resid = 0;
409 		return (0);
410 	}
411 
412 	/*
413 	 * Output to virtual console for logging if enabled.
414 	 */
415 	if (vsconsvp != NULL && vsconsvp->v_stream != NULL) {
416 		struiod_t uiod;
417 
418 		/*
419 		 * strwrite modifies uio so need to make copy.
420 		 */
421 		(void) uiodup(uio, &uiod.d_uio, uiod.d_iov,
422 		    sizeof (uiod.d_iov) / sizeof (*uiod.d_iov));
423 
424 		(void) strwrite(vsconsvp, &uiod.d_uio, cred);
425 	}
426 
427 	if (rconsvp->v_stream != NULL)
428 		return (strwrite(rconsvp, uio, cred));
429 	else
430 		return (cdev_write(rconsdev, uio, cred));
431 }
432 
433 /* ARGSUSED */
434 static int
435 cnprivateioc(dev_t dev, int cmd, intptr_t arg, int flag, struct cred *cred,
436 	int *rvalp)
437 {
438 
439 	/* currently we only support one ioctl */
440 	if (cmd != CONS_GETTERM)
441 		return (EINVAL);
442 
443 	/* Confirm iwscn is immediate target of cn redirection */
444 	if (rconsvp != wsconsvp)
445 		return (ENODEV);
446 
447 	/*
448 	 * If the redirection client is not wc, it should return
449 	 * error upon receiving the CONS_GETTERM ioctl.
450 	 *
451 	 * if it is wc, we know that the target supports the CONS_GETTERM
452 	 * ioctl, which very conviently has the exact same data
453 	 * format as this ioctl...  so let's just pass it on.
454 	 */
455 	return (cdev_ioctl(rconsdev, CONS_GETTERM, arg, flag, cred, rvalp));
456 }
457 
458 /* ARGSUSED */
459 static int
460 cnioctl(dev_t dev, int cmd, intptr_t arg, int flag, struct cred *cred,
461 	int *rvalp)
462 {
463 	if (rconsvp == NULL)
464 		return (0);
465 
466 	/*
467 	 * In wc, VT_SET_CONSUSER which comes from minor node 0
468 	 * has two sources -- either /dev/console or /dev/vt/0 .
469 	 * We need a way to differentiate them, so here we
470 	 * change VT_SET_CONSUSER to a private VT_RESET_CONSUSER
471 	 * ioctl.
472 	 */
473 	if (cmd == VT_SET_CONSUSER)
474 		cmd = VT_RESET_CONSUSER;
475 
476 	if ((cmd & _CNIOC_MASK) == _CNIOC)
477 		return (cnprivateioc(dev, cmd, arg, flag, cred, rvalp));
478 
479 	if (rconsvp->v_stream != NULL)
480 		return (strioctl(rconsvp, cmd, arg, flag, U_TO_K,
481 		    cred, rvalp));
482 
483 	return (cdev_ioctl(rconsdev, cmd, arg, flag, cred, rvalp));
484 }
485 
486 /* ARGSUSED */
487 static int
488 cnpoll(dev_t dev, short events, int anyyet, short *reventsp,
489 	struct pollhead **phpp)
490 {
491 	if (rconsvp == NULL)
492 		return (nochpoll(dev, events, anyyet, reventsp, phpp));
493 
494 	if (rconsvp->v_stream != NULL)
495 		return (strpoll(rconsvp->v_stream, events, anyyet, reventsp,
496 		    phpp));
497 	else
498 		return (cdev_poll(rconsdev, events, anyyet, reventsp, phpp));
499 }
500