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) 2008, 2010, Oracle and/or its affiliates. All rights reserved.
24 */
25
26 #include <sys/types.h>
27 #include <sys/param.h>
28 #include <sys/signal.h>
29 #include <sys/cred.h>
30 #include <sys/vnode.h>
31 #include <sys/termios.h>
32 #include <sys/termio.h>
33 #include <sys/ttold.h>
34 #include <sys/stropts.h>
35 #include <sys/stream.h>
36 #include <sys/strsun.h>
37 #include <sys/tty.h>
38 #include <sys/buf.h>
39 #include <sys/uio.h>
40 #include <sys/stat.h>
41 #include <sys/sysmacros.h>
42 #include <sys/errno.h>
43 #include <sys/proc.h>
44 #include <sys/procset.h>
45 #include <sys/fault.h>
46 #include <sys/siginfo.h>
47 #include <sys/debug.h>
48 #include <sys/kd.h>
49 #include <sys/vt.h>
50 #include <sys/vtdaemon.h>
51 #include <sys/session.h>
52 #include <sys/door.h>
53 #include <sys/kmem.h>
54 #include <sys/cpuvar.h>
55 #include <sys/kbio.h>
56 #include <sys/strredir.h>
57 #include <sys/fs/snode.h>
58 #include <sys/consdev.h>
59 #include <sys/conf.h>
60 #include <sys/cmn_err.h>
61 #include <sys/console.h>
62 #include <sys/promif.h>
63 #include <sys/note.h>
64 #include <sys/polled_io.h>
65 #include <sys/systm.h>
66 #include <sys/ddi.h>
67 #include <sys/sunddi.h>
68 #include <sys/sunndi.h>
69 #include <sys/esunddi.h>
70 #include <sys/sunldi.h>
71 #include <sys/debug.h>
72 #include <sys/console.h>
73 #include <sys/ddi_impldefs.h>
74 #include <sys/policy.h>
75 #include <sys/tem.h>
76 #include <sys/wscons.h>
77 #include <sys/systm.h>
78 #include <sys/modctl.h>
79 #include <sys/vt_impl.h>
80 #include <sys/consconfig_dacf.h>
81
82 /*
83 * This file belongs to wc STREAMS module which has a D_MTPERMODE
84 * inner perimeter. See "Locking Policy" comment in wscons.c for
85 * more information.
86 */
87
88 /*
89 * Minor name device file Hotkeys
90 *
91 * 0 the system console /dev/console Alt + F1
92 * 0: virtual console #1 /dev/vt/0 Alt + F1
93 *
94 * 2: virtual console #2 /dev/vt/2 Alt + F2
95 * 3: virtual console #3 /dev/vt/3 Alt + F3
96 * ......
97 * n: virtual console #n /dev/vt/n Alt + Fn
98 *
99 * Note that vtdaemon is running on /dev/vt/1 (minor=1),
100 * which is not available to end users.
101 *
102 */
103
104 #define VT_DAEMON_MINOR 1
105 #define VT_IS_DAEMON(minor) ((minor) == VT_DAEMON_MINOR)
106
107 extern void wc_get_size(vc_state_t *pvc);
108 extern boolean_t consconfig_console_is_tipline(void);
109
110
111 minor_t vc_last_console = VT_MINOR_INVALID; /* the last used console */
112 volatile uint_t vc_target_console; /* arg (1..n) */
113
114 static volatile minor_t vc_inuse_max_minor = 0;
115 static list_t vc_waitactive_list;
116 _NOTE(SCHEME_PROTECTS_DATA("D_MTPERMOD protected data", vc_target_console))
117 _NOTE(SCHEME_PROTECTS_DATA("D_MTPERMOD protected data", vc_last_console))
118 _NOTE(SCHEME_PROTECTS_DATA("D_MTPERMOD protected data", vc_inuse_max_minor))
119 _NOTE(SCHEME_PROTECTS_DATA("D_MTPERMOD protected data", vc_waitactive_list))
120
121 static int vt_pending_vtno = -1;
122 kmutex_t vt_pending_vtno_lock;
123 _NOTE(MUTEX_PROTECTS_DATA(vt_pending_vtno_lock, vt_pending_vtno))
124
125 static int vt_activate(uint_t vt_no, cred_t *credp);
126 static void vt_copyout(queue_t *qp, mblk_t *mp, mblk_t *tmp, uint_t size);
127 static void vt_copyin(queue_t *qp, mblk_t *mp, uint_t size);
128 static void vt_iocnak(queue_t *qp, mblk_t *mp, int error);
129 static void vt_iocack(queue_t *qp, mblk_t *mp);
130
131 static uint_t vt_minor2arg(minor_t minor);
132 static minor_t vt_arg2minor(uint_t arg);
133
134 /*
135 * If the system console is directed to tipline, consider /dev/vt/0 as
136 * not being used.
137 * For other VT, if it is opened and tty is initialized, consider it
138 * as being used.
139 */
140 #define VT_IS_INUSE(id) \
141 (((vt_minor2vc(id))->vc_flags & WCS_ISOPEN) && \
142 ((vt_minor2vc(id))->vc_flags & WCS_INIT) && \
143 (id != 0 || !consconfig_console_is_tipline()))
144
145 /*
146 * the vt switching message is encoded as:
147 *
148 * -------------------------------------------------------------
149 * | \033 | 'Q' | vtno + 'A' | opcode | 'z' | '\0' |
150 * -------------------------------------------------------------
151 */
152 #define VT_MSG_SWITCH(mp) \
153 ((int)((mp)->b_wptr - (mp)->b_rptr) >= 5 && \
154 *((mp)->b_rptr) == '\033' && \
155 *((mp)->b_rptr + 1) == 'Q' && \
156 *((mp)->b_rptr + 4) == 'z')
157
158 #define VT_MSG_VTNO(mp) (*((mp)->b_rptr + 2) - 'A')
159 #define VT_MSG_OPCODE(mp) (*((mp)->b_rptr + 3))
160
161 #define VT_DOORCALL_MAX_RETRY 3
162
163 static void
164 vt_init_ttycommon(tty_common_t *pcommon)
165 {
166 struct termios *termiosp;
167 int len;
168
169 mutex_init(&pcommon->t_excl, NULL, MUTEX_DEFAULT, NULL);
170 pcommon->t_iflag = 0;
171
172 /*
173 * Get the default termios settings (cflag).
174 * These are stored as a property in the
175 * "options" node.
176 */
177 if (ddi_getlongprop(DDI_DEV_T_ANY,
178 ddi_root_node(), 0, "ttymodes",
179 (caddr_t)&termiosp, &len) == DDI_PROP_SUCCESS) {
180
181 if (len == sizeof (struct termios))
182 pcommon->t_cflag = termiosp->c_cflag;
183 else
184 cmn_err(CE_WARN,
185 "wc: Couldn't get ttymodes property!");
186
187 kmem_free(termiosp, len);
188 } else {
189 /*
190 * Gack! Whine about it.
191 */
192 cmn_err(CE_WARN,
193 "wc: Couldn't get ttymodes property!");
194 }
195
196 pcommon->t_iocpending = NULL;
197 }
198
199 static int
200 vt_config(uint_t count)
201 {
202 if (consmode != CONS_KFB)
203 return (ENOTSUP);
204
205 /* one for system console, one for vtdaemon */
206 if (count < 2)
207 return (ENXIO);
208
209 /*
210 * Shouldn't allow to shrink the max vt minor to be smaller than
211 * the max in used minor.
212 */
213 if (count <= vc_inuse_max_minor)
214 return (EBUSY);
215
216 mutex_enter(&vc_lock);
217 vt_resize(count);
218 mutex_exit(&vc_lock);
219
220 return (0);
221 }
222
223 void
224 vt_clean(queue_t *q, vc_state_t *pvc)
225 {
226 ASSERT(MUTEX_HELD(&pvc->vc_state_lock));
227
228 if (pvc->vc_bufcallid != 0) {
229 qunbufcall(q, pvc->vc_bufcallid);
230 pvc->vc_bufcallid = 0;
231 }
232 if (pvc->vc_timeoutid != 0) {
233 (void) quntimeout(q, pvc->vc_timeoutid);
234 pvc->vc_timeoutid = 0;
235 }
236 ttycommon_close(&pvc->vc_ttycommon);
237
238 pvc->vc_flags &= ~WCS_INIT;
239 }
240
241 /*
242 * Reply the VT_WAITACTIVE ioctl.
243 * Argument 'close' usage:
244 * B_TRUE: the vt designated by argument 'minor' is being closed.
245 * B_FALSE: the vt designated by argument 'minor' has been activated just now.
246 */
247 static void
248 vc_waitactive_reply(int minor, boolean_t close)
249 {
250 vc_waitactive_msg_t *index, *tmp;
251 vc_state_t *pvc;
252
253 index = list_head(&vc_waitactive_list);
254
255 while (index != NULL) {
256 tmp = index;
257 index = list_next(&vc_waitactive_list, index);
258
259 if ((close && tmp->wa_msg_minor == minor) ||
260 (!close && tmp->wa_wait_minor == minor)) {
261 list_remove(&vc_waitactive_list, tmp);
262 pvc = vt_minor2vc(tmp->wa_msg_minor);
263
264 if (close)
265 vt_iocnak(pvc->vc_wq, tmp->wa_mp, ENXIO);
266 else
267 vt_iocack(pvc->vc_wq, tmp->wa_mp);
268
269 kmem_free(tmp, sizeof (vc_waitactive_msg_t));
270 }
271 }
272 }
273
274 void
275 vt_close(queue_t *q, vc_state_t *pvc, cred_t *credp)
276 {
277 minor_t index;
278
279 mutex_enter(&pvc->vc_state_lock);
280 vt_clean(q, pvc);
281 pvc->vc_flags &= ~WCS_ISOPEN;
282 mutex_exit(&pvc->vc_state_lock);
283
284 tem_destroy(pvc->vc_tem, credp);
285 pvc->vc_tem = NULL;
286
287 index = pvc->vc_minor;
288 if (index == vc_inuse_max_minor) {
289 while ((--index > 0) && !VT_IS_INUSE(index))
290 ;
291 vc_inuse_max_minor = index;
292 }
293
294 vc_waitactive_reply(pvc->vc_minor, B_TRUE);
295 }
296
297 static void
298 vt_init_tty(vc_state_t *pvc)
299 {
300 ASSERT(MUTEX_HELD(&pvc->vc_state_lock));
301
302 pvc->vc_flags |= WCS_INIT;
303 vt_init_ttycommon(&pvc->vc_ttycommon);
304 wc_get_size(pvc);
305 }
306
307 /*
308 * minor 0: /dev/vt/0 (index = 0, indicating the system console)
309 * minor 1: /dev/vt/1 (index = 1, vtdaemon special console)
310 * minor 2: /dev/vt/2 (index = 2, virtual consoles)
311 * ......
312 * minor n: /dev/vt/n (index = n)
313 *
314 *
315 * The system console (minor 0), is opened firstly and used during console
316 * configuration. It also acts as the system hard console even when all
317 * virtual consoles go off.
318 *
319 * In tipline case, minor 0 (/dev/vt/0) is reserved, and cannot be switched to.
320 * And the system console is redirected to the tipline. During normal cases,
321 * we can switch from virtual consoles to it by pressing 'Alt + F1'.
322 *
323 * minor 1 (/dev/vt/1) is reserved for vtdaemon special console, and it's
324 * not available to end users.
325 *
326 * During early console configuration, consconfig_dacf opens wscons and then
327 * issue a WC_OPEN_FB ioctl to kick off terminal init process. So during
328 * consconfig_dacf first opening of wscons, tems (of type tem_state_t) is
329 * not initialized. We do not initialize the tem_vt_state_t instance returned
330 * by tem_init() for this open, since we do not have enough info to handle
331 * normal terminal operation at this moment. This tem_vt_state_t instance
332 * will get initialized when handling WC_OPEN_FB.
333 */
334 int
335 vt_open(minor_t minor, queue_t *rq, cred_t *crp)
336 {
337 vc_state_t *pvc;
338
339 if (!vt_minor_valid(minor))
340 return (ENXIO);
341
342 pvc = vt_minor2vc(minor);
343 if (pvc == NULL)
344 return (ENXIO);
345
346 mutex_enter(&vc_lock);
347 mutex_enter(&pvc->vc_state_lock);
348
349 if (!(pvc->vc_flags & WCS_ISOPEN)) {
350 /*
351 * vc_tem might not be intialized if !tems.ts_initialized,
352 * and this only happens during console configuration.
353 */
354 pvc->vc_tem = tem_init(crp);
355 }
356
357 if (!(pvc->vc_flags & WCS_INIT))
358 vt_init_tty(pvc);
359
360 /*
361 * In normal case, the first screen is the system console;
362 * In tipline case, the first screen is the first VT that gets started.
363 */
364 if (vc_active_console == VT_MINOR_INVALID && minor != VT_DAEMON_MINOR)
365 if (minor == 0 || consmode == CONS_KFB) {
366 boolean_t unblank = B_FALSE;
367
368 vc_active_console = minor;
369 vc_last_console = minor;
370 if (minor != 0) {
371 /*
372 * If we are not opening the system console
373 * as the first console, clear the phyical
374 * screen.
375 */
376 unblank = B_TRUE;
377 }
378
379 tem_activate(pvc->vc_tem, unblank, crp);
380 }
381
382 if ((pvc->vc_ttycommon.t_flags & TS_XCLUDE) &&
383 (secpolicy_excl_open(crp) != 0)) {
384 mutex_exit(&pvc->vc_state_lock);
385 mutex_exit(&vc_lock);
386 return (EBUSY);
387 }
388
389 if (minor > vc_inuse_max_minor)
390 vc_inuse_max_minor = minor;
391
392 pvc->vc_flags |= WCS_ISOPEN;
393 pvc->vc_ttycommon.t_readq = rq;
394 pvc->vc_ttycommon.t_writeq = WR(rq);
395
396 mutex_exit(&pvc->vc_state_lock);
397 mutex_exit(&vc_lock);
398
399 rq->q_ptr = pvc;
400 WR(rq)->q_ptr = pvc;
401 pvc->vc_wq = WR(rq);
402
403 qprocson(rq);
404 return (0);
405 }
406
407 static minor_t
408 vt_find_prev(minor_t cur)
409 {
410 minor_t i, t, max;
411
412 ASSERT(vc_active_console != VT_MINOR_INVALID);
413
414 max = VC_INSTANCES_COUNT;
415
416 for (i = cur - 1; (t = (i + max) % max) != cur; i--)
417 if (!VT_IS_DAEMON(t) && VT_IS_INUSE(t))
418 return (t);
419
420 return (VT_MINOR_INVALID);
421 }
422
423 static minor_t
424 vt_find_next(minor_t cur)
425 {
426 minor_t i, t, max;
427
428 ASSERT(vc_active_console != VT_MINOR_INVALID);
429
430 max = VC_INSTANCES_COUNT;
431
432 for (i = cur + 1; (t = (i + max) % max) != cur; i++)
433 if (!VT_IS_DAEMON(t) && VT_IS_INUSE(t))
434 return (t);
435
436 return (VT_MINOR_INVALID);
437 }
438
439 /* ARGSUSED */
440 void
441 vt_send_hotkeys(void *timeout_arg)
442 {
443 door_handle_t door;
444 vt_cmd_arg_t arg;
445 int error = 0;
446 int retries = 0;
447 door_arg_t door_arg;
448
449 arg.vt_ev = VT_EV_HOTKEYS;
450
451 mutex_enter(&vt_pending_vtno_lock);
452 arg.vt_num = vt_pending_vtno;
453 mutex_exit(&vt_pending_vtno_lock);
454
455 /* only available in kernel context or user context */
456 if (door_ki_open(VT_DAEMON_DOOR_FILE, &door) != 0) {
457 mutex_enter(&vt_pending_vtno_lock);
458 vt_pending_vtno = -1;
459 mutex_exit(&vt_pending_vtno_lock);
460 return;
461 }
462
463 door_arg.rbuf = NULL;
464 door_arg.rsize = 0;
465 door_arg.data_ptr = (void *)&arg;
466 door_arg.data_size = sizeof (arg);
467 door_arg.desc_ptr = NULL;
468 door_arg.desc_num = 0;
469
470 /*
471 * Make door upcall
472 */
473 while ((error = door_ki_upcall(door, &door_arg)) != 0 &&
474 retries < VT_DOORCALL_MAX_RETRY)
475 if (error == EAGAIN || error == EINTR)
476 retries++;
477 else
478 break;
479
480 door_ki_rele(door);
481
482 mutex_enter(&vt_pending_vtno_lock);
483 vt_pending_vtno = -1;
484 mutex_exit(&vt_pending_vtno_lock);
485 }
486
487 static boolean_t
488 vt_validate_hotkeys(int minor)
489 {
490 /*
491 * minor should not succeed the existing minor numbers range.
492 */
493 if (!vt_minor_valid(minor))
494 return (B_FALSE);
495
496 /*
497 * Shouldn't switch to /dev/vt/1 or an unused vt.
498 */
499 if (!VT_IS_DAEMON(minor) && VT_IS_INUSE(minor))
500 return (B_TRUE);
501
502 return (B_FALSE);
503 }
504
505 static void
506 vt_trigger_hotkeys(int vtno)
507 {
508 mutex_enter(&vt_pending_vtno_lock);
509
510 if (vt_pending_vtno != -1) {
511 mutex_exit(&vt_pending_vtno_lock);
512 return;
513 }
514
515 vt_pending_vtno = vtno;
516 mutex_exit(&vt_pending_vtno_lock);
517 (void) timeout(vt_send_hotkeys, NULL, 1);
518 }
519
520 /*
521 * return value:
522 * 0: non msg of vt hotkeys
523 * 1: msg of vt hotkeys
524 */
525 int
526 vt_check_hotkeys(mblk_t *mp)
527 {
528 int vtno = 0;
529 minor_t minor = 0;
530
531 /* LINTED E_PTRDIFF_OVERFLOW */
532 if (!VT_MSG_SWITCH(mp))
533 return (0);
534
535 switch (VT_MSG_OPCODE(mp)) {
536 case 'B':
537 /* find out the previous vt */
538 if (vc_active_console == VT_MINOR_INVALID)
539 return (1);
540
541 if (VT_IS_DAEMON(vc_active_console)) {
542 minor = vt_find_prev(vt_arg2minor(vc_target_console));
543 break;
544 }
545
546 minor = vt_find_prev(vc_active_console);
547 break;
548 case 'F':
549 /* find out the next vt */
550 if (vc_active_console == VT_MINOR_INVALID)
551 return (1);
552
553 if (VT_IS_DAEMON(vc_active_console)) {
554 minor = vt_find_next(vt_arg2minor(vc_target_console));
555 break;
556 }
557
558 minor = vt_find_next(vc_active_console);
559 break;
560 case 'H':
561 /* find out the specified vt */
562 minor = VT_MSG_VTNO(mp);
563
564 /* check for system console, Alt + F1 */
565 if (minor == 1)
566 minor = 0;
567 break;
568 case 'L':
569 /* find out the last vt */
570 if ((minor = vc_last_console) == VT_MINOR_INVALID)
571 return (1);
572 break;
573 default:
574 return (1);
575 }
576
577 if (!vt_validate_hotkeys(minor))
578 return (1);
579
580 /*
581 * for system console, the argument of vtno for
582 * vt_activate is 1, though its minor is 0
583 */
584 if (minor == 0)
585 vtno = 1; /* for system console */
586 else
587 vtno = minor;
588
589 vt_trigger_hotkeys(vtno);
590 return (1);
591 }
592
593 static void
594 vt_proc_sendsig(pid_t pid, int sig)
595 {
596 register proc_t *p;
597
598 if (pid <= 0)
599 return;
600
601 mutex_enter(&pidlock);
602 if ((p = prfind(pid)) == NULL || p->p_stat == SIDL) {
603 mutex_exit(&pidlock);
604 return;
605 }
606
607 psignal(p, sig);
608 mutex_exit(&pidlock);
609 }
610
611 static int
612 vt_proc_exists(pid_t pid)
613 {
614 register proc_t *p;
615
616 if (pid <= 0)
617 return (EINVAL);
618
619 mutex_enter(&pidlock);
620 if ((p = prfind(pid)) == NULL || p->p_stat == SIDL) {
621 mutex_exit(&pidlock);
622 return (ESRCH);
623 }
624 mutex_exit(&pidlock);
625
626 return (0);
627 }
628
629 #define SIG_VALID(x) (((x) > 0) && ((x) <= MAXSIG) && \
630 ((x) != SIGKILL) && ((x) != SIGSTOP))
631
632 static int
633 vt_setmode(vc_state_t *pvc, struct vt_mode *pmode)
634 {
635 if ((pmode->mode != VT_PROCESS) && (pmode->mode != VT_AUTO))
636 return (EINVAL);
637
638 if (!SIG_VALID(pmode->relsig) || !SIG_VALID(pmode->acqsig))
639 return (EINVAL);
640
641 if (pmode->mode == VT_PROCESS) {
642 pvc->vc_pid = curproc->p_pid;
643 } else {
644 pvc->vc_dispnum = 0;
645 pvc->vc_login = 0;
646 }
647
648 pvc->vc_switch_mode = pmode->mode;
649 pvc->vc_waitv = pmode->waitv;
650 pvc->vc_relsig = pmode->relsig;
651 pvc->vc_acqsig = pmode->acqsig;
652
653 return (0);
654 }
655
656 static void
657 vt_reset(vc_state_t *pvc)
658 {
659 pvc->vc_switch_mode = VT_AUTO;
660 pvc->vc_pid = -1;
661 pvc->vc_dispnum = 0;
662 pvc->vc_login = 0;
663 pvc->vc_switchto = VT_MINOR_INVALID;
664 }
665
666 /*
667 * switch to vt_no from vc_active_console
668 */
669 static int
670 vt_switch(uint_t vt_no, cred_t *credp)
671 {
672 vc_state_t *pvc_active = vt_minor2vc(vc_active_console);
673 vc_state_t *pvc = vt_minor2vc(vt_no);
674 minor_t index;
675
676 ASSERT(pvc_active && pvc);
677
678 /* sanity test for the target VT and the active VT */
679 if (!((pvc->vc_flags & WCS_ISOPEN) && (pvc->vc_flags & WCS_INIT)))
680 return (EINVAL);
681
682 if (!((pvc_active->vc_flags & WCS_ISOPEN) &&
683 (pvc_active->vc_flags & WCS_INIT)))
684 return (EINVAL);
685
686 mutex_enter(&vc_lock);
687
688 tem_switch(pvc_active->vc_tem, pvc->vc_tem, credp);
689
690 if (!VT_IS_DAEMON(vc_active_console))
691 vc_last_console = vc_active_console;
692 else
693 vc_last_console = vt_arg2minor(vc_target_console);
694
695 vc_active_console = pvc->vc_minor;
696
697 if (pvc->vc_switch_mode == VT_PROCESS) {
698 pvc->vc_switchto = pvc->vc_minor;
699
700 /* send it an acquired signal */
701 vt_proc_sendsig(pvc->vc_pid, pvc->vc_acqsig);
702 }
703
704 vc_waitactive_reply(vc_active_console, B_FALSE);
705
706 mutex_exit(&vc_lock);
707
708 if (!VT_IS_DAEMON(vt_no)) {
709 /*
710 * Applications that open the virtual console device may request
711 * asynchronous notification of VT switching from a previous VT
712 * to another one by setting the S_MSG flag in an I_SETSIG
713 * STREAMS ioctl. Such processes receive a SIGPOLL signal when
714 * a VT switching succeeds.
715 */
716 for (index = 0; index < VC_INSTANCES_COUNT; index++) {
717 vc_state_t *tmp_pvc = vt_minor2vc(index);
718 mblk_t *mp;
719
720 if ((tmp_pvc->vc_flags & WCS_ISOPEN) &&
721 (tmp_pvc->vc_flags & WCS_INIT) &&
722 (mp = allocb(sizeof (unsigned char), BPRI_HI))) {
723 mp->b_datap->db_type = M_PCSIG;
724 *mp->b_wptr = SIGPOLL;
725 mp->b_wptr += sizeof (unsigned char);
726 putnext(RD(tmp_pvc->vc_wq), mp);
727 }
728 }
729 }
730
731 return (0);
732
733 }
734
735 /*
736 * vt_no from 0 to n
737 *
738 * 0 for the vtdaemon sepcial console (only vtdaemon will use it)
739 * 1 for the system console (Alt + F1, or Alt + Ctrl + F1),
740 * aka Virtual Console #1
741 *
742 * 2 for Virtual Console #2
743 * n for Virtual Console #n
744 */
745 static minor_t
746 vt_arg2minor(uint_t arg)
747 {
748 if (arg == 0)
749 return (1);
750
751 if (arg == 1)
752 return (0);
753
754 return (arg);
755 }
756
757 static uint_t
758 vt_minor2arg(minor_t minor)
759 {
760 if (minor == 0)
761 return (1);
762
763 if (VT_IS_DAEMON(minor)) {
764 /* here it should be the real console */
765 return (vc_target_console);
766 }
767
768 return (minor);
769 }
770
771 static int
772 vt_activate(uint_t vt_no, cred_t *credp)
773 {
774 vc_state_t *pvc;
775 minor_t minor;
776
777 minor = vt_arg2minor(vt_no);
778 if (!vt_minor_valid(minor))
779 return (ENXIO);
780 if (minor == vc_active_console) {
781 if (VT_IS_DAEMON(minor)) {
782 /*
783 * vtdaemon is reactivating itself to do locking
784 * on behalf of another console, so record current
785 * target console as the last console.
786 */
787 vc_last_console = vt_arg2minor(vc_target_console);
788 }
789
790 return (0);
791 }
792
793 /*
794 * In tipline case, the system console is redirected to tipline
795 * and thus is always available.
796 */
797 if (minor == 0 && consconfig_console_is_tipline())
798 return (0);
799
800 if (!VT_IS_INUSE(minor))
801 return (ENXIO);
802
803 pvc = vt_minor2vc(minor);
804 if (pvc == NULL)
805 return (ENXIO);
806 if (pvc->vc_tem == NULL)
807 return (ENXIO);
808
809 pvc = vt_minor2vc(vc_active_console);
810 if (pvc == NULL)
811 return (ENXIO);
812 if (pvc->vc_switch_mode != VT_PROCESS)
813 return (vt_switch(minor, credp));
814
815 /*
816 * Validate the process, reset the
817 * vt to auto mode if failed.
818 */
819 if (pvc->vc_pid == -1 || vt_proc_exists(pvc->vc_pid) != 0) {
820 /*
821 * Xserver has not started up yet,
822 * or it dose not exist.
823 */
824 vt_reset(pvc);
825 return (0);
826 }
827
828 /*
829 * Send the release signal to the process,
830 * and wait VT_RELDISP ioctl from Xserver
831 * after its leaving VT.
832 */
833 vt_proc_sendsig(pvc->vc_pid, pvc->vc_relsig);
834 pvc->vc_switchto = minor;
835
836 /*
837 * We don't need a timeout here, for if Xserver refuses
838 * or fails to respond to release signal using VT_RELDISP,
839 * we cannot successfully switch to our text mode. Actually
840 * users can try again. At present we don't support force
841 * switch.
842 */
843 return (0);
844 }
845
846 static int
847 vt_reldisp(vc_state_t *pvc, int arg, cred_t *credp)
848 {
849 minor_t target_vtno = pvc->vc_switchto;
850
851 if ((pvc->vc_switch_mode != VT_PROCESS) ||
852 (pvc->vc_minor != vc_active_console))
853 return (EACCES);
854
855 if (target_vtno == VT_MINOR_INVALID)
856 return (EINVAL);
857
858 pvc->vc_switchto = VT_MINOR_INVALID;
859
860 if (arg == VT_ACKACQ)
861 return (0);
862
863 if (arg == 0)
864 return (0); /* refuse to release */
865
866 /* Xserver has left VT */
867 return (vt_switch(target_vtno, credp));
868 }
869
870 void
871 vt_ioctl(queue_t *q, mblk_t *mp)
872 {
873 vc_state_t *pvc = (vc_state_t *)q->q_ptr;
874 struct iocblk *iocp;
875 struct vt_mode vtmode;
876 struct vt_stat vtinfo;
877 struct vt_dispinfo vtdisp;
878 mblk_t *tmp;
879 int minor;
880 int arg;
881 int error = 0;
882 vc_waitactive_msg_t *wait_msg;
883
884 iocp = (struct iocblk *)(void *)mp->b_rptr;
885 if (consmode != CONS_KFB && iocp->ioc_cmd != VT_ENABLED) {
886 vt_iocnak(q, mp, EINVAL);
887 return;
888 }
889
890 switch (iocp->ioc_cmd) {
891 case VT_ENABLED:
892 if (!(tmp = allocb(sizeof (int), BPRI_MED))) {
893 error = ENOMEM;
894 break;
895 }
896 *(int *)(void *)tmp->b_rptr = consmode;
897 tmp->b_wptr += sizeof (int);
898 vt_copyout(q, mp, tmp, sizeof (int));
899 return;
900
901 case KDSETMODE:
902 arg = *(intptr_t *)(void *)mp->b_cont->b_rptr;
903 if (arg != KD_TEXT && arg != KD_GRAPHICS) {
904 error = EINVAL;
905 break;
906 }
907 if (tem_get_fbmode(pvc->vc_tem) == arg)
908 break;
909
910 tem_set_fbmode(pvc->vc_tem, (uchar_t)arg, iocp->ioc_cr);
911
912 break;
913
914 case KDGETMODE:
915 if (!(tmp = allocb(sizeof (int), BPRI_MED))) {
916 error = ENOMEM;
917 break;
918 }
919 *(int *)(void *)tmp->b_rptr = tem_get_fbmode(pvc->vc_tem);
920 tmp->b_wptr += sizeof (int);
921 vt_copyout(q, mp, tmp, sizeof (int));
922 return;
923
924 case VT_OPENQRY: /* return number of first free VT */
925 if (!(tmp = allocb(sizeof (int), BPRI_MED))) {
926 error = ENOMEM;
927 break;
928 }
929
930 /* minors of 0 and 1 are not available to end users */
931 for (minor = 2; vt_minor_valid(minor); minor++)
932 if (!VT_IS_INUSE(minor))
933 break;
934
935 if (!vt_minor_valid(minor))
936 minor = -1;
937 *(int *)(void *)tmp->b_rptr = minor; /* /dev/vt/minor */
938 tmp->b_wptr += sizeof (int);
939 vt_copyout(q, mp, tmp, sizeof (int));
940 return;
941
942 case VT_GETMODE:
943 vtmode.mode = pvc->vc_switch_mode;
944 vtmode.waitv = pvc->vc_waitv;
945 vtmode.relsig = pvc->vc_relsig;
946 vtmode.acqsig = pvc->vc_acqsig;
947 vtmode.frsig = 0;
948 if (!(tmp = allocb(sizeof (struct vt_mode), BPRI_MED))) {
949 error = ENOMEM;
950 break;
951 }
952 *(struct vt_mode *)(void *)tmp->b_rptr = vtmode;
953 tmp->b_wptr += sizeof (struct vt_mode);
954 vt_copyout(q, mp, tmp, sizeof (struct vt_mode));
955 return;
956
957 case VT_SETMODE:
958 vt_copyin(q, mp, sizeof (struct vt_mode));
959 return;
960
961 case VT_SETDISPINFO:
962 /* always enforce sys_devices privilege for setdispinfo */
963 if ((error = secpolicy_console(iocp->ioc_cr)) != 0)
964 break;
965
966 pvc->vc_dispnum = *(intptr_t *)(void *)mp->b_cont->b_rptr;
967 break;
968
969 case VT_SETDISPLOGIN:
970 pvc->vc_login = *(intptr_t *)(void *)mp->b_cont->b_rptr;
971 break;
972
973 case VT_GETDISPINFO:
974 vtdisp.v_pid = pvc->vc_pid;
975 vtdisp.v_dispnum = pvc->vc_dispnum;
976 vtdisp.v_login = pvc->vc_login;
977 if (!(tmp = allocb(sizeof (struct vt_dispinfo), BPRI_MED))) {
978 error = ENOMEM;
979 break;
980 }
981 *(struct vt_dispinfo *)(void *)tmp->b_rptr = vtdisp;
982 tmp->b_wptr += sizeof (struct vt_dispinfo);
983 vt_copyout(q, mp, tmp, sizeof (struct vt_dispinfo));
984 return;
985
986 case VT_RELDISP:
987 arg = *(intptr_t *)(void *)mp->b_cont->b_rptr;
988 error = vt_reldisp(pvc, arg, iocp->ioc_cr);
989 break;
990
991 case VT_CONFIG:
992 /* always enforce sys_devices privilege for config */
993 if ((error = secpolicy_console(iocp->ioc_cr)) != 0)
994 break;
995
996 arg = *(intptr_t *)(void *)mp->b_cont->b_rptr;
997 error = vt_config(arg);
998 break;
999
1000 case VT_ACTIVATE:
1001 /* always enforce sys_devices privilege for secure switch */
1002 if ((error = secpolicy_console(iocp->ioc_cr)) != 0)
1003 break;
1004
1005 arg = *(intptr_t *)(void *)mp->b_cont->b_rptr;
1006 error = vt_activate(arg, iocp->ioc_cr);
1007 break;
1008
1009 case VT_WAITACTIVE:
1010 arg = *(intptr_t *)(void *)mp->b_cont->b_rptr;
1011 arg = vt_arg2minor(arg);
1012 if (!vt_minor_valid(arg)) {
1013 error = ENXIO;
1014 break;
1015 }
1016 if (arg == vc_active_console)
1017 break;
1018
1019 wait_msg = kmem_zalloc(sizeof (vc_waitactive_msg_t),
1020 KM_NOSLEEP);
1021 if (wait_msg == NULL) {
1022 error = ENXIO;
1023 break;
1024 }
1025
1026 wait_msg->wa_mp = mp;
1027 wait_msg->wa_msg_minor = pvc->vc_minor;
1028 wait_msg->wa_wait_minor = arg;
1029 list_insert_head(&vc_waitactive_list, wait_msg);
1030
1031 return;
1032
1033 case VT_GETSTATE:
1034 /*
1035 * Here v_active is the argument for vt_activate,
1036 * not minor.
1037 */
1038 vtinfo.v_active = vt_minor2arg(vc_active_console);
1039 vtinfo.v_state = 3; /* system console and vtdaemon */
1040
1041 /* we only support 16 vt states since the v_state is short */
1042 for (minor = 2; minor < 16; minor++) {
1043 pvc = vt_minor2vc(minor);
1044 if (pvc == NULL)
1045 break;
1046 if (VT_IS_INUSE(minor))
1047 vtinfo.v_state |= (1 << pvc->vc_minor);
1048 }
1049
1050 if (!(tmp = allocb(sizeof (struct vt_stat), BPRI_MED))) {
1051 error = ENOMEM;
1052 break;
1053 }
1054 *(struct vt_stat *)(void *)tmp->b_rptr = vtinfo;
1055 tmp->b_wptr += sizeof (struct vt_stat);
1056 vt_copyout(q, mp, tmp, sizeof (struct vt_stat));
1057 return;
1058
1059 case VT_SET_TARGET:
1060 /* always enforce sys_devices privilege */
1061 if ((error = secpolicy_console(iocp->ioc_cr)) != 0)
1062 break;
1063
1064 arg = *(intptr_t *)(void *)mp->b_cont->b_rptr;
1065
1066 /* vtdaemon is doing authentication for this target console */
1067 vc_target_console = arg;
1068 break;
1069
1070 case VT_GETACTIVE: /* get real active console (minor) */
1071 if (!(tmp = allocb(sizeof (int), BPRI_MED))) {
1072 error = ENOMEM;
1073 break;
1074 }
1075 *(int *)(void *)tmp->b_rptr = vc_active_console;
1076 tmp->b_wptr += sizeof (int);
1077 vt_copyout(q, mp, tmp, sizeof (int));
1078 return;
1079
1080 case VT_GET_CONSUSER:
1081 if (!(tmp = allocb(sizeof (int), BPRI_MED))) {
1082 error = ENOMEM;
1083 break;
1084 }
1085
1086 if (vc_cons_user == VT_MINOR_INVALID) {
1087 /*
1088 * Return -1 if console user link points to
1089 * /dev/console
1090 */
1091 *(int *)(void *)tmp->b_rptr = -1;
1092 } else {
1093 *(int *)(void *)tmp->b_rptr = vc_cons_user;
1094 }
1095
1096 tmp->b_wptr += sizeof (int);
1097 vt_copyout(q, mp, tmp, sizeof (int));
1098 return;
1099
1100 case VT_RESET_CONSUSER:
1101 /* always enforce sys_devices privilege */
1102 if ((error = secpolicy_console(iocp->ioc_cr)) != 0)
1103 break;
1104
1105 /* Ensure it comes from /dev/console */
1106 if (pvc->vc_minor != 0) {
1107 error = ENXIO;
1108 break;
1109 }
1110
1111 mutex_enter(&vc_lock);
1112 vc_cons_user = VT_MINOR_INVALID;
1113 mutex_exit(&vc_lock);
1114 break;
1115
1116 case VT_SET_CONSUSER:
1117 /* always enforce sys_devices privilege */
1118 if ((error = secpolicy_console(iocp->ioc_cr)) != 0)
1119 break;
1120
1121 mutex_enter(&vc_lock);
1122 vc_cons_user = pvc->vc_minor;
1123 mutex_exit(&vc_lock);
1124 break;
1125
1126 default:
1127 error = ENXIO;
1128 break;
1129 }
1130
1131 if (error != 0)
1132 vt_iocnak(q, mp, error);
1133 else
1134 vt_iocack(q, mp);
1135 }
1136
1137 void
1138 vt_miocdata(queue_t *qp, mblk_t *mp)
1139 {
1140 vc_state_t *pvc = (vc_state_t *)qp->q_ptr;
1141 struct copyresp *copyresp;
1142 struct vt_mode *pmode;
1143 int error = 0;
1144
1145 copyresp = (struct copyresp *)(void *)mp->b_rptr;
1146 if (copyresp->cp_rval) {
1147 vt_iocnak(qp, mp, EAGAIN);
1148 return;
1149 }
1150
1151 switch (copyresp->cp_cmd) {
1152 case VT_SETMODE:
1153 pmode = (struct vt_mode *)(void *)mp->b_cont->b_rptr;
1154 error = vt_setmode(pvc, pmode);
1155 break;
1156
1157 case KDGETMODE:
1158 case VT_OPENQRY:
1159 case VT_GETMODE:
1160 case VT_GETDISPINFO:
1161 case VT_GETSTATE:
1162 case VT_ENABLED:
1163 case VT_GETACTIVE:
1164 break;
1165
1166 default:
1167 error = ENXIO;
1168 break;
1169 }
1170
1171 if (error != 0)
1172 vt_iocnak(qp, mp, error);
1173 else
1174 vt_iocack(qp, mp);
1175 }
1176
1177 static void
1178 vt_iocack(queue_t *qp, mblk_t *mp)
1179 {
1180 struct iocblk *iocbp = (struct iocblk *)(void *)mp->b_rptr;
1181
1182 mp->b_datap->db_type = M_IOCACK;
1183 mp->b_wptr = mp->b_rptr + sizeof (struct iocblk);
1184 iocbp->ioc_error = 0;
1185 iocbp->ioc_count = 0;
1186 iocbp->ioc_rval = 0;
1187 if (mp->b_cont != NULL) {
1188 freemsg(mp->b_cont);
1189 mp->b_cont = NULL;
1190 }
1191 qreply(qp, mp);
1192 }
1193
1194 static void
1195 vt_iocnak(queue_t *qp, mblk_t *mp, int error)
1196 {
1197 struct iocblk *iocp = (struct iocblk *)(void *)mp->b_rptr;
1198
1199 mp->b_datap->db_type = M_IOCNAK;
1200 iocp->ioc_rval = 0;
1201 iocp->ioc_count = 0;
1202 iocp->ioc_error = error;
1203 if (mp->b_cont != NULL) {
1204 freemsg(mp->b_cont);
1205 mp->b_cont = NULL;
1206 }
1207 qreply(qp, mp);
1208 }
1209
1210 static void
1211 vt_copyin(queue_t *qp, mblk_t *mp, uint_t size)
1212 {
1213 struct copyreq *cqp;
1214
1215 cqp = (struct copyreq *)(void *)mp->b_rptr;
1216 cqp->cq_addr = *((caddr_t *)(void *)mp->b_cont->b_rptr);
1217 cqp->cq_size = size;
1218 cqp->cq_flag = 0;
1219 cqp->cq_private = (mblk_t *)NULL;
1220 mp->b_wptr = mp->b_rptr + sizeof (struct copyreq);
1221 mp->b_datap->db_type = M_COPYIN;
1222 if (mp->b_cont)
1223 freemsg(mp->b_cont);
1224 mp->b_cont = (mblk_t *)NULL;
1225 qreply(qp, mp);
1226 }
1227
1228 static void
1229 vt_copyout(queue_t *qp, mblk_t *mp, mblk_t *tmp, uint_t size)
1230 {
1231 struct copyreq *cqp;
1232
1233 cqp = (struct copyreq *)(void *)mp->b_rptr;
1234 cqp->cq_size = size;
1235 cqp->cq_addr = *((caddr_t *)(void *)mp->b_cont->b_rptr);
1236 cqp->cq_flag = 0;
1237 cqp->cq_private = (mblk_t *)NULL;
1238 mp->b_wptr = mp->b_rptr + sizeof (struct copyreq);
1239 mp->b_datap->db_type = M_COPYOUT;
1240 if (mp->b_cont)
1241 freemsg(mp->b_cont);
1242 mp->b_cont = tmp;
1243 qreply(qp, mp);
1244 }
1245
1246 /*
1247 * Get vc state from minor.
1248 * Once a caller gets a vc_state_t from this function,
1249 * the vc_state_t is guaranteed not being freed before
1250 * the caller leaves this STREAMS module by the D_MTPERMOD
1251 * perimeter.
1252 */
1253 vc_state_t *
1254 vt_minor2vc(minor_t minor)
1255 {
1256 avl_index_t where;
1257 vc_state_t target;
1258
1259 if (minor != VT_ACTIVE) {
1260 target.vc_minor = minor;
1261 return (avl_find(&vc_avl_root, &target, &where));
1262 }
1263
1264 if (vc_active_console == VT_MINOR_INVALID)
1265 target.vc_minor = 0;
1266 else
1267 target.vc_minor = vc_active_console;
1268
1269 return (avl_find(&vc_avl_root, &target, &where));
1270 }
1271
1272 static void
1273 vt_state_init(vc_state_t *vcptr, minor_t minor)
1274 {
1275 mutex_init(&vcptr->vc_state_lock, NULL, MUTEX_DRIVER, NULL);
1276
1277 mutex_enter(&vcptr->vc_state_lock);
1278 vcptr->vc_flags = 0;
1279 mutex_exit(&vcptr->vc_state_lock);
1280
1281 vcptr->vc_pid = -1;
1282 vcptr->vc_dispnum = 0;
1283 vcptr->vc_login = 0;
1284 vcptr->vc_switchto = VT_MINOR_INVALID;
1285 vcptr->vc_switch_mode = VT_AUTO;
1286 vcptr->vc_relsig = SIGUSR1;
1287 vcptr->vc_acqsig = SIGUSR1;
1288 vcptr->vc_tem = NULL;
1289 vcptr->vc_bufcallid = 0;
1290 vcptr->vc_timeoutid = 0;
1291 vcptr->vc_wq = NULL;
1292 vcptr->vc_minor = minor;
1293 }
1294
1295 void
1296 vt_resize(uint_t count)
1297 {
1298 uint_t vc_num, i;
1299
1300 ASSERT(MUTEX_HELD(&vc_lock));
1301
1302 vc_num = VC_INSTANCES_COUNT;
1303
1304 if (count == vc_num)
1305 return;
1306
1307 if (count > vc_num) {
1308 for (i = vc_num; i < count; i++) {
1309 vc_state_t *vcptr = kmem_zalloc(sizeof (vc_state_t),
1310 KM_SLEEP);
1311 vt_state_init(vcptr, i);
1312 avl_add(&vc_avl_root, vcptr);
1313 }
1314 return;
1315 }
1316
1317 for (i = vc_num; i > count; i--) {
1318 avl_index_t where;
1319 vc_state_t target, *found;
1320
1321 target.vc_minor = i - 1;
1322 found = avl_find(&vc_avl_root, &target, &where);
1323 ASSERT(found != NULL && found->vc_flags == 0);
1324 avl_remove(&vc_avl_root, found);
1325 kmem_free(found, sizeof (vc_state_t));
1326 }
1327 }
1328
1329 static int
1330 vc_avl_compare(const void *first, const void *second)
1331 {
1332 const vc_state_t *vcptr1 = first;
1333 const vc_state_t *vcptr2 = second;
1334
1335 if (vcptr1->vc_minor < vcptr2->vc_minor)
1336 return (-1);
1337
1338 if (vcptr1->vc_minor == vcptr2->vc_minor)
1339 return (0);
1340
1341 return (1);
1342 }
1343
1344 /*
1345 * Only called from wc init().
1346 */
1347 void
1348 vt_init(void)
1349 {
1350 #ifdef __lock_lint
1351 ASSERT(NO_COMPETING_THREADS);
1352 #endif
1353
1354 avl_create(&vc_avl_root, vc_avl_compare, sizeof (vc_state_t),
1355 offsetof(vc_state_t, vc_avl_node));
1356
1357 list_create(&vc_waitactive_list, sizeof (vc_waitactive_msg_t),
1358 offsetof(vc_waitactive_msg_t, wa_list_node));
1359
1360 mutex_init(&vc_lock, NULL, MUTEX_DRIVER, NULL);
1361 mutex_init(&vt_pending_vtno_lock, NULL, MUTEX_DRIVER, NULL);
1362 }