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, NULL) == DDI_FAILURE) {
211 return (DDI_FAILURE);
212 }
213 if (ddi_create_minor_node(devi, "systty", S_IFCHR,
214 0, DDI_PSEUDO, NULL) == 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, NULL) == 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 }