vt_ioctl.c revision 99edb3d10a9d384d69557bd09cc39b9ec62aa04e
1/* 2 * Copyright (C) 1992 obz under the linux copyright 3 * 4 * Dynamic diacritical handling - aeb@cwi.nl - Dec 1993 5 * Dynamic keymap and string allocation - aeb@cwi.nl - May 1994 6 * Restrict VT switching via ioctl() - grif@cs.ucr.edu - Dec 1995 7 * Some code moved for less code duplication - Andi Kleen - Mar 1997 8 * Check put/get_user, cleanups - acme@conectiva.com.br - Jun 2001 9 */ 10 11#include <linux/types.h> 12#include <linux/errno.h> 13#include <linux/sched.h> 14#include <linux/tty.h> 15#include <linux/timer.h> 16#include <linux/kernel.h> 17#include <linux/compat.h> 18#include <linux/module.h> 19#include <linux/kd.h> 20#include <linux/vt.h> 21#include <linux/string.h> 22#include <linux/slab.h> 23#include <linux/major.h> 24#include <linux/fs.h> 25#include <linux/console.h> 26#include <linux/consolemap.h> 27#include <linux/signal.h> 28#include <linux/timex.h> 29 30#include <asm/io.h> 31#include <asm/uaccess.h> 32 33#include <linux/kbd_kern.h> 34#include <linux/vt_kern.h> 35#include <linux/kbd_diacr.h> 36#include <linux/selection.h> 37 38char vt_dont_switch; 39extern struct tty_driver *console_driver; 40 41#define VT_IS_IN_USE(i) (console_driver->ttys[i] && console_driver->ttys[i]->count) 42#define VT_BUSY(i) (VT_IS_IN_USE(i) || i == fg_console || vc_cons[i].d == sel_cons) 43 44/* 45 * Console (vt and kd) routines, as defined by USL SVR4 manual, and by 46 * experimentation and study of X386 SYSV handling. 47 * 48 * One point of difference: SYSV vt's are /dev/vtX, which X >= 0, and 49 * /dev/console is a separate ttyp. Under Linux, /dev/tty0 is /dev/console, 50 * and the vc start at /dev/ttyX, X >= 1. We maintain that here, so we will 51 * always treat our set of vt as numbered 1..MAX_NR_CONSOLES (corresponding to 52 * ttys 0..MAX_NR_CONSOLES-1). Explicitly naming VT 0 is illegal, but using 53 * /dev/tty0 (fg_console) as a target is legal, since an implicit aliasing 54 * to the current console is done by the main ioctl code. 55 */ 56 57#ifdef CONFIG_X86 58#include <linux/syscalls.h> 59#endif 60 61static void complete_change_console(struct vc_data *vc); 62 63/* 64 * User space VT_EVENT handlers 65 */ 66 67struct vt_event_wait { 68 struct list_head list; 69 struct vt_event event; 70 int done; 71}; 72 73static LIST_HEAD(vt_events); 74static DEFINE_SPINLOCK(vt_event_lock); 75static DECLARE_WAIT_QUEUE_HEAD(vt_event_waitqueue); 76 77/** 78 * vt_event_post 79 * @event: the event that occurred 80 * @old: old console 81 * @new: new console 82 * 83 * Post an VT event to interested VT handlers 84 */ 85 86void vt_event_post(unsigned int event, unsigned int old, unsigned int new) 87{ 88 struct list_head *pos, *head; 89 unsigned long flags; 90 int wake = 0; 91 92 spin_lock_irqsave(&vt_event_lock, flags); 93 head = &vt_events; 94 95 list_for_each(pos, head) { 96 struct vt_event_wait *ve = list_entry(pos, 97 struct vt_event_wait, list); 98 if (!(ve->event.event & event)) 99 continue; 100 ve->event.event = event; 101 /* kernel view is consoles 0..n-1, user space view is 102 console 1..n with 0 meaning current, so we must bias */ 103 ve->event.oldev = old + 1; 104 ve->event.newev = new + 1; 105 wake = 1; 106 ve->done = 1; 107 } 108 spin_unlock_irqrestore(&vt_event_lock, flags); 109 if (wake) 110 wake_up_interruptible(&vt_event_waitqueue); 111} 112 113/** 114 * vt_event_wait - wait for an event 115 * @vw: our event 116 * 117 * Waits for an event to occur which completes our vt_event_wait 118 * structure. On return the structure has wv->done set to 1 for success 119 * or 0 if some event such as a signal ended the wait. 120 */ 121 122static void vt_event_wait(struct vt_event_wait *vw) 123{ 124 unsigned long flags; 125 /* Prepare the event */ 126 INIT_LIST_HEAD(&vw->list); 127 vw->done = 0; 128 /* Queue our event */ 129 spin_lock_irqsave(&vt_event_lock, flags); 130 list_add(&vw->list, &vt_events); 131 spin_unlock_irqrestore(&vt_event_lock, flags); 132 /* Wait for it to pass */ 133 wait_event_interruptible_tty(vt_event_waitqueue, vw->done); 134 /* Dequeue it */ 135 spin_lock_irqsave(&vt_event_lock, flags); 136 list_del(&vw->list); 137 spin_unlock_irqrestore(&vt_event_lock, flags); 138} 139 140/** 141 * vt_event_wait_ioctl - event ioctl handler 142 * @arg: argument to ioctl 143 * 144 * Implement the VT_WAITEVENT ioctl using the VT event interface 145 */ 146 147static int vt_event_wait_ioctl(struct vt_event __user *event) 148{ 149 struct vt_event_wait vw; 150 151 if (copy_from_user(&vw.event, event, sizeof(struct vt_event))) 152 return -EFAULT; 153 /* Highest supported event for now */ 154 if (vw.event.event & ~VT_MAX_EVENT) 155 return -EINVAL; 156 157 vt_event_wait(&vw); 158 /* If it occurred report it */ 159 if (vw.done) { 160 if (copy_to_user(event, &vw.event, sizeof(struct vt_event))) 161 return -EFAULT; 162 return 0; 163 } 164 return -EINTR; 165} 166 167/** 168 * vt_waitactive - active console wait 169 * @event: event code 170 * @n: new console 171 * 172 * Helper for event waits. Used to implement the legacy 173 * event waiting ioctls in terms of events 174 */ 175 176int vt_waitactive(int n) 177{ 178 struct vt_event_wait vw; 179 do { 180 if (n == fg_console + 1) 181 break; 182 vw.event.event = VT_EVENT_SWITCH; 183 vt_event_wait(&vw); 184 if (vw.done == 0) 185 return -EINTR; 186 } while (vw.event.newev != n); 187 return 0; 188} 189 190/* 191 * these are the valid i/o ports we're allowed to change. they map all the 192 * video ports 193 */ 194#define GPFIRST 0x3b4 195#define GPLAST 0x3df 196#define GPNUM (GPLAST - GPFIRST + 1) 197 198#define i (tmp.kb_index) 199#define s (tmp.kb_table) 200#define v (tmp.kb_value) 201static inline int 202do_kdsk_ioctl(int cmd, struct kbentry __user *user_kbe, int perm, struct kbd_struct *kbd) 203{ 204 struct kbentry tmp; 205 ushort *key_map, val, ov; 206 207 if (copy_from_user(&tmp, user_kbe, sizeof(struct kbentry))) 208 return -EFAULT; 209 210 if (!capable(CAP_SYS_TTY_CONFIG)) 211 perm = 0; 212 213 switch (cmd) { 214 case KDGKBENT: 215 key_map = key_maps[s]; 216 if (key_map) { 217 val = U(key_map[i]); 218 if (kbd->kbdmode != VC_UNICODE && KTYP(val) >= NR_TYPES) 219 val = K_HOLE; 220 } else 221 val = (i ? K_HOLE : K_NOSUCHMAP); 222 return put_user(val, &user_kbe->kb_value); 223 case KDSKBENT: 224 if (!perm) 225 return -EPERM; 226 if (!i && v == K_NOSUCHMAP) { 227 /* deallocate map */ 228 key_map = key_maps[s]; 229 if (s && key_map) { 230 key_maps[s] = NULL; 231 if (key_map[0] == U(K_ALLOCATED)) { 232 kfree(key_map); 233 keymap_count--; 234 } 235 } 236 break; 237 } 238 239 if (KTYP(v) < NR_TYPES) { 240 if (KVAL(v) > max_vals[KTYP(v)]) 241 return -EINVAL; 242 } else 243 if (kbd->kbdmode != VC_UNICODE) 244 return -EINVAL; 245 246 /* ++Geert: non-PC keyboards may generate keycode zero */ 247#if !defined(__mc68000__) && !defined(__powerpc__) 248 /* assignment to entry 0 only tests validity of args */ 249 if (!i) 250 break; 251#endif 252 253 if (!(key_map = key_maps[s])) { 254 int j; 255 256 if (keymap_count >= MAX_NR_OF_USER_KEYMAPS && 257 !capable(CAP_SYS_RESOURCE)) 258 return -EPERM; 259 260 key_map = kmalloc(sizeof(plain_map), 261 GFP_KERNEL); 262 if (!key_map) 263 return -ENOMEM; 264 key_maps[s] = key_map; 265 key_map[0] = U(K_ALLOCATED); 266 for (j = 1; j < NR_KEYS; j++) 267 key_map[j] = U(K_HOLE); 268 keymap_count++; 269 } 270 ov = U(key_map[i]); 271 if (v == ov) 272 break; /* nothing to do */ 273 /* 274 * Attention Key. 275 */ 276 if (((ov == K_SAK) || (v == K_SAK)) && !capable(CAP_SYS_ADMIN)) 277 return -EPERM; 278 key_map[i] = U(v); 279 if (!s && (KTYP(ov) == KT_SHIFT || KTYP(v) == KT_SHIFT)) 280 compute_shiftstate(); 281 break; 282 } 283 return 0; 284} 285#undef i 286#undef s 287#undef v 288 289static inline int 290do_kbkeycode_ioctl(int cmd, struct kbkeycode __user *user_kbkc, int perm) 291{ 292 struct kbkeycode tmp; 293 int kc = 0; 294 295 if (copy_from_user(&tmp, user_kbkc, sizeof(struct kbkeycode))) 296 return -EFAULT; 297 switch (cmd) { 298 case KDGETKEYCODE: 299 kc = getkeycode(tmp.scancode); 300 if (kc >= 0) 301 kc = put_user(kc, &user_kbkc->keycode); 302 break; 303 case KDSETKEYCODE: 304 if (!perm) 305 return -EPERM; 306 kc = setkeycode(tmp.scancode, tmp.keycode); 307 break; 308 } 309 return kc; 310} 311 312static inline int 313do_kdgkb_ioctl(int cmd, struct kbsentry __user *user_kdgkb, int perm) 314{ 315 struct kbsentry *kbs; 316 char *p; 317 u_char *q; 318 u_char __user *up; 319 int sz; 320 int delta; 321 char *first_free, *fj, *fnw; 322 int i, j, k; 323 int ret; 324 325 if (!capable(CAP_SYS_TTY_CONFIG)) 326 perm = 0; 327 328 kbs = kmalloc(sizeof(*kbs), GFP_KERNEL); 329 if (!kbs) { 330 ret = -ENOMEM; 331 goto reterr; 332 } 333 334 /* we mostly copy too much here (512bytes), but who cares ;) */ 335 if (copy_from_user(kbs, user_kdgkb, sizeof(struct kbsentry))) { 336 ret = -EFAULT; 337 goto reterr; 338 } 339 kbs->kb_string[sizeof(kbs->kb_string)-1] = '\0'; 340 i = kbs->kb_func; 341 342 switch (cmd) { 343 case KDGKBSENT: 344 sz = sizeof(kbs->kb_string) - 1; /* sz should have been 345 a struct member */ 346 up = user_kdgkb->kb_string; 347 p = func_table[i]; 348 if(p) 349 for ( ; *p && sz; p++, sz--) 350 if (put_user(*p, up++)) { 351 ret = -EFAULT; 352 goto reterr; 353 } 354 if (put_user('\0', up)) { 355 ret = -EFAULT; 356 goto reterr; 357 } 358 kfree(kbs); 359 return ((p && *p) ? -EOVERFLOW : 0); 360 case KDSKBSENT: 361 if (!perm) { 362 ret = -EPERM; 363 goto reterr; 364 } 365 366 q = func_table[i]; 367 first_free = funcbufptr + (funcbufsize - funcbufleft); 368 for (j = i+1; j < MAX_NR_FUNC && !func_table[j]; j++) 369 ; 370 if (j < MAX_NR_FUNC) 371 fj = func_table[j]; 372 else 373 fj = first_free; 374 375 delta = (q ? -strlen(q) : 1) + strlen(kbs->kb_string); 376 if (delta <= funcbufleft) { /* it fits in current buf */ 377 if (j < MAX_NR_FUNC) { 378 memmove(fj + delta, fj, first_free - fj); 379 for (k = j; k < MAX_NR_FUNC; k++) 380 if (func_table[k]) 381 func_table[k] += delta; 382 } 383 if (!q) 384 func_table[i] = fj; 385 funcbufleft -= delta; 386 } else { /* allocate a larger buffer */ 387 sz = 256; 388 while (sz < funcbufsize - funcbufleft + delta) 389 sz <<= 1; 390 fnw = kmalloc(sz, GFP_KERNEL); 391 if(!fnw) { 392 ret = -ENOMEM; 393 goto reterr; 394 } 395 396 if (!q) 397 func_table[i] = fj; 398 if (fj > funcbufptr) 399 memmove(fnw, funcbufptr, fj - funcbufptr); 400 for (k = 0; k < j; k++) 401 if (func_table[k]) 402 func_table[k] = fnw + (func_table[k] - funcbufptr); 403 404 if (first_free > fj) { 405 memmove(fnw + (fj - funcbufptr) + delta, fj, first_free - fj); 406 for (k = j; k < MAX_NR_FUNC; k++) 407 if (func_table[k]) 408 func_table[k] = fnw + (func_table[k] - funcbufptr) + delta; 409 } 410 if (funcbufptr != func_buf) 411 kfree(funcbufptr); 412 funcbufptr = fnw; 413 funcbufleft = funcbufleft - delta + sz - funcbufsize; 414 funcbufsize = sz; 415 } 416 strcpy(func_table[i], kbs->kb_string); 417 break; 418 } 419 ret = 0; 420reterr: 421 kfree(kbs); 422 return ret; 423} 424 425static inline int 426do_fontx_ioctl(int cmd, struct consolefontdesc __user *user_cfd, int perm, struct console_font_op *op) 427{ 428 struct consolefontdesc cfdarg; 429 int i; 430 431 if (copy_from_user(&cfdarg, user_cfd, sizeof(struct consolefontdesc))) 432 return -EFAULT; 433 434 switch (cmd) { 435 case PIO_FONTX: 436 if (!perm) 437 return -EPERM; 438 op->op = KD_FONT_OP_SET; 439 op->flags = KD_FONT_FLAG_OLD; 440 op->width = 8; 441 op->height = cfdarg.charheight; 442 op->charcount = cfdarg.charcount; 443 op->data = cfdarg.chardata; 444 return con_font_op(vc_cons[fg_console].d, op); 445 case GIO_FONTX: { 446 op->op = KD_FONT_OP_GET; 447 op->flags = KD_FONT_FLAG_OLD; 448 op->width = 8; 449 op->height = cfdarg.charheight; 450 op->charcount = cfdarg.charcount; 451 op->data = cfdarg.chardata; 452 i = con_font_op(vc_cons[fg_console].d, op); 453 if (i) 454 return i; 455 cfdarg.charheight = op->height; 456 cfdarg.charcount = op->charcount; 457 if (copy_to_user(user_cfd, &cfdarg, sizeof(struct consolefontdesc))) 458 return -EFAULT; 459 return 0; 460 } 461 } 462 return -EINVAL; 463} 464 465static inline int 466do_unimap_ioctl(int cmd, struct unimapdesc __user *user_ud, int perm, struct vc_data *vc) 467{ 468 struct unimapdesc tmp; 469 470 if (copy_from_user(&tmp, user_ud, sizeof tmp)) 471 return -EFAULT; 472 if (tmp.entries) 473 if (!access_ok(VERIFY_WRITE, tmp.entries, 474 tmp.entry_ct*sizeof(struct unipair))) 475 return -EFAULT; 476 switch (cmd) { 477 case PIO_UNIMAP: 478 if (!perm) 479 return -EPERM; 480 return con_set_unimap(vc, tmp.entry_ct, tmp.entries); 481 case GIO_UNIMAP: 482 if (!perm && fg_console != vc->vc_num) 483 return -EPERM; 484 return con_get_unimap(vc, tmp.entry_ct, &(user_ud->entry_ct), tmp.entries); 485 } 486 return 0; 487} 488 489 490 491/* 492 * We handle the console-specific ioctl's here. We allow the 493 * capability to modify any console, not just the fg_console. 494 */ 495int vt_ioctl(struct tty_struct *tty, 496 unsigned int cmd, unsigned long arg) 497{ 498 struct vc_data *vc = tty->driver_data; 499 struct console_font_op op; /* used in multiple places here */ 500 struct kbd_struct * kbd; 501 unsigned int console; 502 unsigned char ucval; 503 unsigned int uival; 504 void __user *up = (void __user *)arg; 505 int i, perm; 506 int ret = 0; 507 508 console = vc->vc_num; 509 510 tty_lock(); 511 512 if (!vc_cons_allocated(console)) { /* impossible? */ 513 ret = -ENOIOCTLCMD; 514 goto out; 515 } 516 517 518 /* 519 * To have permissions to do most of the vt ioctls, we either have 520 * to be the owner of the tty, or have CAP_SYS_TTY_CONFIG. 521 */ 522 perm = 0; 523 if (current->signal->tty == tty || capable(CAP_SYS_TTY_CONFIG)) 524 perm = 1; 525 526 kbd = kbd_table + console; 527 switch (cmd) { 528 case TIOCLINUX: 529 ret = tioclinux(tty, arg); 530 break; 531 case KIOCSOUND: 532 if (!perm) 533 goto eperm; 534 /* 535 * The use of PIT_TICK_RATE is historic, it used to be 536 * the platform-dependent CLOCK_TICK_RATE between 2.6.12 537 * and 2.6.36, which was a minor but unfortunate ABI 538 * change. 539 */ 540 if (arg) 541 arg = PIT_TICK_RATE / arg; 542 kd_mksound(arg, 0); 543 break; 544 545 case KDMKTONE: 546 if (!perm) 547 goto eperm; 548 { 549 unsigned int ticks, count; 550 551 /* 552 * Generate the tone for the appropriate number of ticks. 553 * If the time is zero, turn off sound ourselves. 554 */ 555 ticks = HZ * ((arg >> 16) & 0xffff) / 1000; 556 count = ticks ? (arg & 0xffff) : 0; 557 if (count) 558 count = PIT_TICK_RATE / count; 559 kd_mksound(count, ticks); 560 break; 561 } 562 563 case KDGKBTYPE: 564 /* 565 * this is naive. 566 */ 567 ucval = KB_101; 568 goto setchar; 569 570 /* 571 * These cannot be implemented on any machine that implements 572 * ioperm() in user level (such as Alpha PCs) or not at all. 573 * 574 * XXX: you should never use these, just call ioperm directly.. 575 */ 576#ifdef CONFIG_X86 577 case KDADDIO: 578 case KDDELIO: 579 /* 580 * KDADDIO and KDDELIO may be able to add ports beyond what 581 * we reject here, but to be safe... 582 */ 583 if (arg < GPFIRST || arg > GPLAST) { 584 ret = -EINVAL; 585 break; 586 } 587 ret = sys_ioperm(arg, 1, (cmd == KDADDIO)) ? -ENXIO : 0; 588 break; 589 590 case KDENABIO: 591 case KDDISABIO: 592 ret = sys_ioperm(GPFIRST, GPNUM, 593 (cmd == KDENABIO)) ? -ENXIO : 0; 594 break; 595#endif 596 597 /* Linux m68k/i386 interface for setting the keyboard delay/repeat rate */ 598 599 case KDKBDREP: 600 { 601 struct kbd_repeat kbrep; 602 603 if (!capable(CAP_SYS_TTY_CONFIG)) 604 goto eperm; 605 606 if (copy_from_user(&kbrep, up, sizeof(struct kbd_repeat))) { 607 ret = -EFAULT; 608 break; 609 } 610 ret = kbd_rate(&kbrep); 611 if (ret) 612 break; 613 if (copy_to_user(up, &kbrep, sizeof(struct kbd_repeat))) 614 ret = -EFAULT; 615 break; 616 } 617 618 case KDSETMODE: 619 /* 620 * currently, setting the mode from KD_TEXT to KD_GRAPHICS 621 * doesn't do a whole lot. i'm not sure if it should do any 622 * restoration of modes or what... 623 * 624 * XXX It should at least call into the driver, fbdev's definitely 625 * need to restore their engine state. --BenH 626 */ 627 if (!perm) 628 goto eperm; 629 switch (arg) { 630 case KD_GRAPHICS: 631 break; 632 case KD_TEXT0: 633 case KD_TEXT1: 634 arg = KD_TEXT; 635 case KD_TEXT: 636 break; 637 default: 638 ret = -EINVAL; 639 goto out; 640 } 641 if (vc->vc_mode == (unsigned char) arg) 642 break; 643 vc->vc_mode = (unsigned char) arg; 644 if (console != fg_console) 645 break; 646 /* 647 * explicitly blank/unblank the screen if switching modes 648 */ 649 console_lock(); 650 if (arg == KD_TEXT) 651 do_unblank_screen(1); 652 else 653 do_blank_screen(1); 654 console_unlock(); 655 break; 656 657 case KDGETMODE: 658 uival = vc->vc_mode; 659 goto setint; 660 661 case KDMAPDISP: 662 case KDUNMAPDISP: 663 /* 664 * these work like a combination of mmap and KDENABIO. 665 * this could be easily finished. 666 */ 667 ret = -EINVAL; 668 break; 669 670 case KDSKBMODE: 671 if (!perm) 672 goto eperm; 673 switch(arg) { 674 case K_RAW: 675 kbd->kbdmode = VC_RAW; 676 break; 677 case K_MEDIUMRAW: 678 kbd->kbdmode = VC_MEDIUMRAW; 679 break; 680 case K_XLATE: 681 kbd->kbdmode = VC_XLATE; 682 compute_shiftstate(); 683 break; 684 case K_UNICODE: 685 kbd->kbdmode = VC_UNICODE; 686 compute_shiftstate(); 687 break; 688 case K_OFF: 689 kbd->kbdmode = VC_OFF; 690 break; 691 default: 692 ret = -EINVAL; 693 goto out; 694 } 695 tty_ldisc_flush(tty); 696 break; 697 698 case KDGKBMODE: 699 switch (kbd->kbdmode) { 700 case VC_RAW: 701 uival = K_RAW; 702 break; 703 case VC_MEDIUMRAW: 704 uival = K_MEDIUMRAW; 705 break; 706 case VC_UNICODE: 707 uival = K_UNICODE; 708 break; 709 case VC_OFF: 710 uival = K_OFF; 711 break; 712 default: 713 uival = K_XLATE; 714 break; 715 } 716 goto setint; 717 718 /* this could be folded into KDSKBMODE, but for compatibility 719 reasons it is not so easy to fold KDGKBMETA into KDGKBMODE */ 720 case KDSKBMETA: 721 switch(arg) { 722 case K_METABIT: 723 clr_vc_kbd_mode(kbd, VC_META); 724 break; 725 case K_ESCPREFIX: 726 set_vc_kbd_mode(kbd, VC_META); 727 break; 728 default: 729 ret = -EINVAL; 730 } 731 break; 732 733 case KDGKBMETA: 734 uival = (vc_kbd_mode(kbd, VC_META) ? K_ESCPREFIX : K_METABIT); 735 setint: 736 ret = put_user(uival, (int __user *)arg); 737 break; 738 739 case KDGETKEYCODE: 740 case KDSETKEYCODE: 741 if(!capable(CAP_SYS_TTY_CONFIG)) 742 perm = 0; 743 ret = do_kbkeycode_ioctl(cmd, up, perm); 744 break; 745 746 case KDGKBENT: 747 case KDSKBENT: 748 ret = do_kdsk_ioctl(cmd, up, perm, kbd); 749 break; 750 751 case KDGKBSENT: 752 case KDSKBSENT: 753 ret = do_kdgkb_ioctl(cmd, up, perm); 754 break; 755 756 case KDGKBDIACR: 757 { 758 struct kbdiacrs __user *a = up; 759 struct kbdiacr diacr; 760 int i; 761 762 if (put_user(accent_table_size, &a->kb_cnt)) { 763 ret = -EFAULT; 764 break; 765 } 766 for (i = 0; i < accent_table_size; i++) { 767 diacr.diacr = conv_uni_to_8bit(accent_table[i].diacr); 768 diacr.base = conv_uni_to_8bit(accent_table[i].base); 769 diacr.result = conv_uni_to_8bit(accent_table[i].result); 770 if (copy_to_user(a->kbdiacr + i, &diacr, sizeof(struct kbdiacr))) { 771 ret = -EFAULT; 772 break; 773 } 774 } 775 break; 776 } 777 case KDGKBDIACRUC: 778 { 779 struct kbdiacrsuc __user *a = up; 780 781 if (put_user(accent_table_size, &a->kb_cnt)) 782 ret = -EFAULT; 783 else if (copy_to_user(a->kbdiacruc, accent_table, 784 accent_table_size*sizeof(struct kbdiacruc))) 785 ret = -EFAULT; 786 break; 787 } 788 789 case KDSKBDIACR: 790 { 791 struct kbdiacrs __user *a = up; 792 struct kbdiacr diacr; 793 unsigned int ct; 794 int i; 795 796 if (!perm) 797 goto eperm; 798 if (get_user(ct,&a->kb_cnt)) { 799 ret = -EFAULT; 800 break; 801 } 802 if (ct >= MAX_DIACR) { 803 ret = -EINVAL; 804 break; 805 } 806 accent_table_size = ct; 807 for (i = 0; i < ct; i++) { 808 if (copy_from_user(&diacr, a->kbdiacr + i, sizeof(struct kbdiacr))) { 809 ret = -EFAULT; 810 break; 811 } 812 accent_table[i].diacr = conv_8bit_to_uni(diacr.diacr); 813 accent_table[i].base = conv_8bit_to_uni(diacr.base); 814 accent_table[i].result = conv_8bit_to_uni(diacr.result); 815 } 816 break; 817 } 818 819 case KDSKBDIACRUC: 820 { 821 struct kbdiacrsuc __user *a = up; 822 unsigned int ct; 823 824 if (!perm) 825 goto eperm; 826 if (get_user(ct,&a->kb_cnt)) { 827 ret = -EFAULT; 828 break; 829 } 830 if (ct >= MAX_DIACR) { 831 ret = -EINVAL; 832 break; 833 } 834 accent_table_size = ct; 835 if (copy_from_user(accent_table, a->kbdiacruc, ct*sizeof(struct kbdiacruc))) 836 ret = -EFAULT; 837 break; 838 } 839 840 /* the ioctls below read/set the flags usually shown in the leds */ 841 /* don't use them - they will go away without warning */ 842 case KDGKBLED: 843 ucval = kbd->ledflagstate | (kbd->default_ledflagstate << 4); 844 goto setchar; 845 846 case KDSKBLED: 847 if (!perm) 848 goto eperm; 849 if (arg & ~0x77) { 850 ret = -EINVAL; 851 break; 852 } 853 kbd->ledflagstate = (arg & 7); 854 kbd->default_ledflagstate = ((arg >> 4) & 7); 855 set_leds(); 856 break; 857 858 /* the ioctls below only set the lights, not the functions */ 859 /* for those, see KDGKBLED and KDSKBLED above */ 860 case KDGETLED: 861 ucval = getledstate(); 862 setchar: 863 ret = put_user(ucval, (char __user *)arg); 864 break; 865 866 case KDSETLED: 867 if (!perm) 868 goto eperm; 869 setledstate(kbd, arg); 870 break; 871 872 /* 873 * A process can indicate its willingness to accept signals 874 * generated by pressing an appropriate key combination. 875 * Thus, one can have a daemon that e.g. spawns a new console 876 * upon a keypress and then changes to it. 877 * See also the kbrequest field of inittab(5). 878 */ 879 case KDSIGACCEPT: 880 { 881 if (!perm || !capable(CAP_KILL)) 882 goto eperm; 883 if (!valid_signal(arg) || arg < 1 || arg == SIGKILL) 884 ret = -EINVAL; 885 else { 886 spin_lock_irq(&vt_spawn_con.lock); 887 put_pid(vt_spawn_con.pid); 888 vt_spawn_con.pid = get_pid(task_pid(current)); 889 vt_spawn_con.sig = arg; 890 spin_unlock_irq(&vt_spawn_con.lock); 891 } 892 break; 893 } 894 895 case VT_SETMODE: 896 { 897 struct vt_mode tmp; 898 899 if (!perm) 900 goto eperm; 901 if (copy_from_user(&tmp, up, sizeof(struct vt_mode))) { 902 ret = -EFAULT; 903 goto out; 904 } 905 if (tmp.mode != VT_AUTO && tmp.mode != VT_PROCESS) { 906 ret = -EINVAL; 907 goto out; 908 } 909 console_lock(); 910 vc->vt_mode = tmp; 911 /* the frsig is ignored, so we set it to 0 */ 912 vc->vt_mode.frsig = 0; 913 put_pid(vc->vt_pid); 914 vc->vt_pid = get_pid(task_pid(current)); 915 /* no switch is required -- saw@shade.msu.ru */ 916 vc->vt_newvt = -1; 917 console_unlock(); 918 break; 919 } 920 921 case VT_GETMODE: 922 { 923 struct vt_mode tmp; 924 int rc; 925 926 console_lock(); 927 memcpy(&tmp, &vc->vt_mode, sizeof(struct vt_mode)); 928 console_unlock(); 929 930 rc = copy_to_user(up, &tmp, sizeof(struct vt_mode)); 931 if (rc) 932 ret = -EFAULT; 933 break; 934 } 935 936 /* 937 * Returns global vt state. Note that VT 0 is always open, since 938 * it's an alias for the current VT, and people can't use it here. 939 * We cannot return state for more than 16 VTs, since v_state is short. 940 */ 941 case VT_GETSTATE: 942 { 943 struct vt_stat __user *vtstat = up; 944 unsigned short state, mask; 945 946 if (put_user(fg_console + 1, &vtstat->v_active)) 947 ret = -EFAULT; 948 else { 949 state = 1; /* /dev/tty0 is always open */ 950 for (i = 0, mask = 2; i < MAX_NR_CONSOLES && mask; 951 ++i, mask <<= 1) 952 if (VT_IS_IN_USE(i)) 953 state |= mask; 954 ret = put_user(state, &vtstat->v_state); 955 } 956 break; 957 } 958 959 /* 960 * Returns the first available (non-opened) console. 961 */ 962 case VT_OPENQRY: 963 for (i = 0; i < MAX_NR_CONSOLES; ++i) 964 if (! VT_IS_IN_USE(i)) 965 break; 966 uival = i < MAX_NR_CONSOLES ? (i+1) : -1; 967 goto setint; 968 969 /* 970 * ioctl(fd, VT_ACTIVATE, num) will cause us to switch to vt # num, 971 * with num >= 1 (switches to vt 0, our console, are not allowed, just 972 * to preserve sanity). 973 */ 974 case VT_ACTIVATE: 975 if (!perm) 976 goto eperm; 977 if (arg == 0 || arg > MAX_NR_CONSOLES) 978 ret = -ENXIO; 979 else { 980 arg--; 981 console_lock(); 982 ret = vc_allocate(arg); 983 console_unlock(); 984 if (ret) 985 break; 986 set_console(arg); 987 } 988 break; 989 990 case VT_SETACTIVATE: 991 { 992 struct vt_setactivate vsa; 993 994 if (!perm) 995 goto eperm; 996 997 if (copy_from_user(&vsa, (struct vt_setactivate __user *)arg, 998 sizeof(struct vt_setactivate))) { 999 ret = -EFAULT; 1000 goto out; 1001 } 1002 if (vsa.console == 0 || vsa.console > MAX_NR_CONSOLES) 1003 ret = -ENXIO; 1004 else { 1005 vsa.console--; 1006 console_lock(); 1007 ret = vc_allocate(vsa.console); 1008 if (ret == 0) { 1009 struct vc_data *nvc; 1010 /* This is safe providing we don't drop the 1011 console sem between vc_allocate and 1012 finishing referencing nvc */ 1013 nvc = vc_cons[vsa.console].d; 1014 nvc->vt_mode = vsa.mode; 1015 nvc->vt_mode.frsig = 0; 1016 put_pid(nvc->vt_pid); 1017 nvc->vt_pid = get_pid(task_pid(current)); 1018 } 1019 console_unlock(); 1020 if (ret) 1021 break; 1022 /* Commence switch and lock */ 1023 set_console(vsa.console); 1024 } 1025 break; 1026 } 1027 1028 /* 1029 * wait until the specified VT has been activated 1030 */ 1031 case VT_WAITACTIVE: 1032 if (!perm) 1033 goto eperm; 1034 if (arg == 0 || arg > MAX_NR_CONSOLES) 1035 ret = -ENXIO; 1036 else 1037 ret = vt_waitactive(arg); 1038 break; 1039 1040 /* 1041 * If a vt is under process control, the kernel will not switch to it 1042 * immediately, but postpone the operation until the process calls this 1043 * ioctl, allowing the switch to complete. 1044 * 1045 * According to the X sources this is the behavior: 1046 * 0: pending switch-from not OK 1047 * 1: pending switch-from OK 1048 * 2: completed switch-to OK 1049 */ 1050 case VT_RELDISP: 1051 if (!perm) 1052 goto eperm; 1053 1054 if (vc->vt_mode.mode != VT_PROCESS) { 1055 ret = -EINVAL; 1056 break; 1057 } 1058 /* 1059 * Switching-from response 1060 */ 1061 console_lock(); 1062 if (vc->vt_newvt >= 0) { 1063 if (arg == 0) 1064 /* 1065 * Switch disallowed, so forget we were trying 1066 * to do it. 1067 */ 1068 vc->vt_newvt = -1; 1069 1070 else { 1071 /* 1072 * The current vt has been released, so 1073 * complete the switch. 1074 */ 1075 int newvt; 1076 newvt = vc->vt_newvt; 1077 vc->vt_newvt = -1; 1078 ret = vc_allocate(newvt); 1079 if (ret) { 1080 console_unlock(); 1081 break; 1082 } 1083 /* 1084 * When we actually do the console switch, 1085 * make sure we are atomic with respect to 1086 * other console switches.. 1087 */ 1088 complete_change_console(vc_cons[newvt].d); 1089 } 1090 } else { 1091 /* 1092 * Switched-to response 1093 */ 1094 /* 1095 * If it's just an ACK, ignore it 1096 */ 1097 if (arg != VT_ACKACQ) 1098 ret = -EINVAL; 1099 } 1100 console_unlock(); 1101 break; 1102 1103 /* 1104 * Disallocate memory associated to VT (but leave VT1) 1105 */ 1106 case VT_DISALLOCATE: 1107 if (arg > MAX_NR_CONSOLES) { 1108 ret = -ENXIO; 1109 break; 1110 } 1111 if (arg == 0) { 1112 /* deallocate all unused consoles, but leave 0 */ 1113 console_lock(); 1114 for (i=1; i<MAX_NR_CONSOLES; i++) 1115 if (! VT_BUSY(i)) 1116 vc_deallocate(i); 1117 console_unlock(); 1118 } else { 1119 /* deallocate a single console, if possible */ 1120 arg--; 1121 if (VT_BUSY(arg)) 1122 ret = -EBUSY; 1123 else if (arg) { /* leave 0 */ 1124 console_lock(); 1125 vc_deallocate(arg); 1126 console_unlock(); 1127 } 1128 } 1129 break; 1130 1131 case VT_RESIZE: 1132 { 1133 struct vt_sizes __user *vtsizes = up; 1134 struct vc_data *vc; 1135 1136 ushort ll,cc; 1137 if (!perm) 1138 goto eperm; 1139 if (get_user(ll, &vtsizes->v_rows) || 1140 get_user(cc, &vtsizes->v_cols)) 1141 ret = -EFAULT; 1142 else { 1143 console_lock(); 1144 for (i = 0; i < MAX_NR_CONSOLES; i++) { 1145 vc = vc_cons[i].d; 1146 1147 if (vc) { 1148 vc->vc_resize_user = 1; 1149 vc_resize(vc_cons[i].d, cc, ll); 1150 } 1151 } 1152 console_unlock(); 1153 } 1154 break; 1155 } 1156 1157 case VT_RESIZEX: 1158 { 1159 struct vt_consize __user *vtconsize = up; 1160 ushort ll,cc,vlin,clin,vcol,ccol; 1161 if (!perm) 1162 goto eperm; 1163 if (!access_ok(VERIFY_READ, vtconsize, 1164 sizeof(struct vt_consize))) { 1165 ret = -EFAULT; 1166 break; 1167 } 1168 /* FIXME: Should check the copies properly */ 1169 __get_user(ll, &vtconsize->v_rows); 1170 __get_user(cc, &vtconsize->v_cols); 1171 __get_user(vlin, &vtconsize->v_vlin); 1172 __get_user(clin, &vtconsize->v_clin); 1173 __get_user(vcol, &vtconsize->v_vcol); 1174 __get_user(ccol, &vtconsize->v_ccol); 1175 vlin = vlin ? vlin : vc->vc_scan_lines; 1176 if (clin) { 1177 if (ll) { 1178 if (ll != vlin/clin) { 1179 /* Parameters don't add up */ 1180 ret = -EINVAL; 1181 break; 1182 } 1183 } else 1184 ll = vlin/clin; 1185 } 1186 if (vcol && ccol) { 1187 if (cc) { 1188 if (cc != vcol/ccol) { 1189 ret = -EINVAL; 1190 break; 1191 } 1192 } else 1193 cc = vcol/ccol; 1194 } 1195 1196 if (clin > 32) { 1197 ret = -EINVAL; 1198 break; 1199 } 1200 1201 for (i = 0; i < MAX_NR_CONSOLES; i++) { 1202 if (!vc_cons[i].d) 1203 continue; 1204 console_lock(); 1205 if (vlin) 1206 vc_cons[i].d->vc_scan_lines = vlin; 1207 if (clin) 1208 vc_cons[i].d->vc_font.height = clin; 1209 vc_cons[i].d->vc_resize_user = 1; 1210 vc_resize(vc_cons[i].d, cc, ll); 1211 console_unlock(); 1212 } 1213 break; 1214 } 1215 1216 case PIO_FONT: { 1217 if (!perm) 1218 goto eperm; 1219 op.op = KD_FONT_OP_SET; 1220 op.flags = KD_FONT_FLAG_OLD | KD_FONT_FLAG_DONT_RECALC; /* Compatibility */ 1221 op.width = 8; 1222 op.height = 0; 1223 op.charcount = 256; 1224 op.data = up; 1225 ret = con_font_op(vc_cons[fg_console].d, &op); 1226 break; 1227 } 1228 1229 case GIO_FONT: { 1230 op.op = KD_FONT_OP_GET; 1231 op.flags = KD_FONT_FLAG_OLD; 1232 op.width = 8; 1233 op.height = 32; 1234 op.charcount = 256; 1235 op.data = up; 1236 ret = con_font_op(vc_cons[fg_console].d, &op); 1237 break; 1238 } 1239 1240 case PIO_CMAP: 1241 if (!perm) 1242 ret = -EPERM; 1243 else 1244 ret = con_set_cmap(up); 1245 break; 1246 1247 case GIO_CMAP: 1248 ret = con_get_cmap(up); 1249 break; 1250 1251 case PIO_FONTX: 1252 case GIO_FONTX: 1253 ret = do_fontx_ioctl(cmd, up, perm, &op); 1254 break; 1255 1256 case PIO_FONTRESET: 1257 { 1258 if (!perm) 1259 goto eperm; 1260 1261#ifdef BROKEN_GRAPHICS_PROGRAMS 1262 /* With BROKEN_GRAPHICS_PROGRAMS defined, the default 1263 font is not saved. */ 1264 ret = -ENOSYS; 1265 break; 1266#else 1267 { 1268 op.op = KD_FONT_OP_SET_DEFAULT; 1269 op.data = NULL; 1270 ret = con_font_op(vc_cons[fg_console].d, &op); 1271 if (ret) 1272 break; 1273 con_set_default_unimap(vc_cons[fg_console].d); 1274 break; 1275 } 1276#endif 1277 } 1278 1279 case KDFONTOP: { 1280 if (copy_from_user(&op, up, sizeof(op))) { 1281 ret = -EFAULT; 1282 break; 1283 } 1284 if (!perm && op.op != KD_FONT_OP_GET) 1285 goto eperm; 1286 ret = con_font_op(vc, &op); 1287 if (ret) 1288 break; 1289 if (copy_to_user(up, &op, sizeof(op))) 1290 ret = -EFAULT; 1291 break; 1292 } 1293 1294 case PIO_SCRNMAP: 1295 if (!perm) 1296 ret = -EPERM; 1297 else 1298 ret = con_set_trans_old(up); 1299 break; 1300 1301 case GIO_SCRNMAP: 1302 ret = con_get_trans_old(up); 1303 break; 1304 1305 case PIO_UNISCRNMAP: 1306 if (!perm) 1307 ret = -EPERM; 1308 else 1309 ret = con_set_trans_new(up); 1310 break; 1311 1312 case GIO_UNISCRNMAP: 1313 ret = con_get_trans_new(up); 1314 break; 1315 1316 case PIO_UNIMAPCLR: 1317 { struct unimapinit ui; 1318 if (!perm) 1319 goto eperm; 1320 ret = copy_from_user(&ui, up, sizeof(struct unimapinit)); 1321 if (ret) 1322 ret = -EFAULT; 1323 else 1324 con_clear_unimap(vc, &ui); 1325 break; 1326 } 1327 1328 case PIO_UNIMAP: 1329 case GIO_UNIMAP: 1330 ret = do_unimap_ioctl(cmd, up, perm, vc); 1331 break; 1332 1333 case VT_LOCKSWITCH: 1334 if (!capable(CAP_SYS_TTY_CONFIG)) 1335 goto eperm; 1336 vt_dont_switch = 1; 1337 break; 1338 case VT_UNLOCKSWITCH: 1339 if (!capable(CAP_SYS_TTY_CONFIG)) 1340 goto eperm; 1341 vt_dont_switch = 0; 1342 break; 1343 case VT_GETHIFONTMASK: 1344 ret = put_user(vc->vc_hi_font_mask, 1345 (unsigned short __user *)arg); 1346 break; 1347 case VT_WAITEVENT: 1348 ret = vt_event_wait_ioctl((struct vt_event __user *)arg); 1349 break; 1350 default: 1351 ret = -ENOIOCTLCMD; 1352 } 1353out: 1354 tty_unlock(); 1355 return ret; 1356eperm: 1357 ret = -EPERM; 1358 goto out; 1359} 1360 1361void reset_vc(struct vc_data *vc) 1362{ 1363 vc->vc_mode = KD_TEXT; 1364 kbd_table[vc->vc_num].kbdmode = default_utf8 ? VC_UNICODE : VC_XLATE; 1365 vc->vt_mode.mode = VT_AUTO; 1366 vc->vt_mode.waitv = 0; 1367 vc->vt_mode.relsig = 0; 1368 vc->vt_mode.acqsig = 0; 1369 vc->vt_mode.frsig = 0; 1370 put_pid(vc->vt_pid); 1371 vc->vt_pid = NULL; 1372 vc->vt_newvt = -1; 1373 if (!in_interrupt()) /* Via keyboard.c:SAK() - akpm */ 1374 reset_palette(vc); 1375} 1376 1377void vc_SAK(struct work_struct *work) 1378{ 1379 struct vc *vc_con = 1380 container_of(work, struct vc, SAK_work); 1381 struct vc_data *vc; 1382 struct tty_struct *tty; 1383 1384 console_lock(); 1385 vc = vc_con->d; 1386 if (vc) { 1387 tty = vc->port.tty; 1388 /* 1389 * SAK should also work in all raw modes and reset 1390 * them properly. 1391 */ 1392 if (tty) 1393 __do_SAK(tty); 1394 reset_vc(vc); 1395 } 1396 console_unlock(); 1397} 1398 1399#ifdef CONFIG_COMPAT 1400 1401struct compat_consolefontdesc { 1402 unsigned short charcount; /* characters in font (256 or 512) */ 1403 unsigned short charheight; /* scan lines per character (1-32) */ 1404 compat_caddr_t chardata; /* font data in expanded form */ 1405}; 1406 1407static inline int 1408compat_fontx_ioctl(int cmd, struct compat_consolefontdesc __user *user_cfd, 1409 int perm, struct console_font_op *op) 1410{ 1411 struct compat_consolefontdesc cfdarg; 1412 int i; 1413 1414 if (copy_from_user(&cfdarg, user_cfd, sizeof(struct compat_consolefontdesc))) 1415 return -EFAULT; 1416 1417 switch (cmd) { 1418 case PIO_FONTX: 1419 if (!perm) 1420 return -EPERM; 1421 op->op = KD_FONT_OP_SET; 1422 op->flags = KD_FONT_FLAG_OLD; 1423 op->width = 8; 1424 op->height = cfdarg.charheight; 1425 op->charcount = cfdarg.charcount; 1426 op->data = compat_ptr(cfdarg.chardata); 1427 return con_font_op(vc_cons[fg_console].d, op); 1428 case GIO_FONTX: 1429 op->op = KD_FONT_OP_GET; 1430 op->flags = KD_FONT_FLAG_OLD; 1431 op->width = 8; 1432 op->height = cfdarg.charheight; 1433 op->charcount = cfdarg.charcount; 1434 op->data = compat_ptr(cfdarg.chardata); 1435 i = con_font_op(vc_cons[fg_console].d, op); 1436 if (i) 1437 return i; 1438 cfdarg.charheight = op->height; 1439 cfdarg.charcount = op->charcount; 1440 if (copy_to_user(user_cfd, &cfdarg, sizeof(struct compat_consolefontdesc))) 1441 return -EFAULT; 1442 return 0; 1443 } 1444 return -EINVAL; 1445} 1446 1447struct compat_console_font_op { 1448 compat_uint_t op; /* operation code KD_FONT_OP_* */ 1449 compat_uint_t flags; /* KD_FONT_FLAG_* */ 1450 compat_uint_t width, height; /* font size */ 1451 compat_uint_t charcount; 1452 compat_caddr_t data; /* font data with height fixed to 32 */ 1453}; 1454 1455static inline int 1456compat_kdfontop_ioctl(struct compat_console_font_op __user *fontop, 1457 int perm, struct console_font_op *op, struct vc_data *vc) 1458{ 1459 int i; 1460 1461 if (copy_from_user(op, fontop, sizeof(struct compat_console_font_op))) 1462 return -EFAULT; 1463 if (!perm && op->op != KD_FONT_OP_GET) 1464 return -EPERM; 1465 op->data = compat_ptr(((struct compat_console_font_op *)op)->data); 1466 op->flags |= KD_FONT_FLAG_OLD; 1467 i = con_font_op(vc, op); 1468 if (i) 1469 return i; 1470 ((struct compat_console_font_op *)op)->data = (unsigned long)op->data; 1471 if (copy_to_user(fontop, op, sizeof(struct compat_console_font_op))) 1472 return -EFAULT; 1473 return 0; 1474} 1475 1476struct compat_unimapdesc { 1477 unsigned short entry_ct; 1478 compat_caddr_t entries; 1479}; 1480 1481static inline int 1482compat_unimap_ioctl(unsigned int cmd, struct compat_unimapdesc __user *user_ud, 1483 int perm, struct vc_data *vc) 1484{ 1485 struct compat_unimapdesc tmp; 1486 struct unipair __user *tmp_entries; 1487 1488 if (copy_from_user(&tmp, user_ud, sizeof tmp)) 1489 return -EFAULT; 1490 tmp_entries = compat_ptr(tmp.entries); 1491 if (tmp_entries) 1492 if (!access_ok(VERIFY_WRITE, tmp_entries, 1493 tmp.entry_ct*sizeof(struct unipair))) 1494 return -EFAULT; 1495 switch (cmd) { 1496 case PIO_UNIMAP: 1497 if (!perm) 1498 return -EPERM; 1499 return con_set_unimap(vc, tmp.entry_ct, tmp_entries); 1500 case GIO_UNIMAP: 1501 if (!perm && fg_console != vc->vc_num) 1502 return -EPERM; 1503 return con_get_unimap(vc, tmp.entry_ct, &(user_ud->entry_ct), tmp_entries); 1504 } 1505 return 0; 1506} 1507 1508long vt_compat_ioctl(struct tty_struct *tty, 1509 unsigned int cmd, unsigned long arg) 1510{ 1511 struct vc_data *vc = tty->driver_data; 1512 struct console_font_op op; /* used in multiple places here */ 1513 unsigned int console; 1514 void __user *up = (void __user *)arg; 1515 int perm; 1516 int ret = 0; 1517 1518 console = vc->vc_num; 1519 1520 tty_lock(); 1521 1522 if (!vc_cons_allocated(console)) { /* impossible? */ 1523 ret = -ENOIOCTLCMD; 1524 goto out; 1525 } 1526 1527 /* 1528 * To have permissions to do most of the vt ioctls, we either have 1529 * to be the owner of the tty, or have CAP_SYS_TTY_CONFIG. 1530 */ 1531 perm = 0; 1532 if (current->signal->tty == tty || capable(CAP_SYS_TTY_CONFIG)) 1533 perm = 1; 1534 1535 switch (cmd) { 1536 /* 1537 * these need special handlers for incompatible data structures 1538 */ 1539 case PIO_FONTX: 1540 case GIO_FONTX: 1541 ret = compat_fontx_ioctl(cmd, up, perm, &op); 1542 break; 1543 1544 case KDFONTOP: 1545 ret = compat_kdfontop_ioctl(up, perm, &op, vc); 1546 break; 1547 1548 case PIO_UNIMAP: 1549 case GIO_UNIMAP: 1550 ret = compat_unimap_ioctl(cmd, up, perm, vc); 1551 break; 1552 1553 /* 1554 * all these treat 'arg' as an integer 1555 */ 1556 case KIOCSOUND: 1557 case KDMKTONE: 1558#ifdef CONFIG_X86 1559 case KDADDIO: 1560 case KDDELIO: 1561#endif 1562 case KDSETMODE: 1563 case KDMAPDISP: 1564 case KDUNMAPDISP: 1565 case KDSKBMODE: 1566 case KDSKBMETA: 1567 case KDSKBLED: 1568 case KDSETLED: 1569 case KDSIGACCEPT: 1570 case VT_ACTIVATE: 1571 case VT_WAITACTIVE: 1572 case VT_RELDISP: 1573 case VT_DISALLOCATE: 1574 case VT_RESIZE: 1575 case VT_RESIZEX: 1576 goto fallback; 1577 1578 /* 1579 * the rest has a compatible data structure behind arg, 1580 * but we have to convert it to a proper 64 bit pointer. 1581 */ 1582 default: 1583 arg = (unsigned long)compat_ptr(arg); 1584 goto fallback; 1585 } 1586out: 1587 tty_unlock(); 1588 return ret; 1589 1590fallback: 1591 tty_unlock(); 1592 return vt_ioctl(tty, cmd, arg); 1593} 1594 1595 1596#endif /* CONFIG_COMPAT */ 1597 1598 1599/* 1600 * Performs the back end of a vt switch. Called under the console 1601 * semaphore. 1602 */ 1603static void complete_change_console(struct vc_data *vc) 1604{ 1605 unsigned char old_vc_mode; 1606 int old = fg_console; 1607 1608 last_console = fg_console; 1609 1610 /* 1611 * If we're switching, we could be going from KD_GRAPHICS to 1612 * KD_TEXT mode or vice versa, which means we need to blank or 1613 * unblank the screen later. 1614 */ 1615 old_vc_mode = vc_cons[fg_console].d->vc_mode; 1616 switch_screen(vc); 1617 1618 /* 1619 * This can't appear below a successful kill_pid(). If it did, 1620 * then the *blank_screen operation could occur while X, having 1621 * received acqsig, is waking up on another processor. This 1622 * condition can lead to overlapping accesses to the VGA range 1623 * and the framebuffer (causing system lockups). 1624 * 1625 * To account for this we duplicate this code below only if the 1626 * controlling process is gone and we've called reset_vc. 1627 */ 1628 if (old_vc_mode != vc->vc_mode) { 1629 if (vc->vc_mode == KD_TEXT) 1630 do_unblank_screen(1); 1631 else 1632 do_blank_screen(1); 1633 } 1634 1635 /* 1636 * If this new console is under process control, send it a signal 1637 * telling it that it has acquired. Also check if it has died and 1638 * clean up (similar to logic employed in change_console()) 1639 */ 1640 if (vc->vt_mode.mode == VT_PROCESS) { 1641 /* 1642 * Send the signal as privileged - kill_pid() will 1643 * tell us if the process has gone or something else 1644 * is awry 1645 */ 1646 if (kill_pid(vc->vt_pid, vc->vt_mode.acqsig, 1) != 0) { 1647 /* 1648 * The controlling process has died, so we revert back to 1649 * normal operation. In this case, we'll also change back 1650 * to KD_TEXT mode. I'm not sure if this is strictly correct 1651 * but it saves the agony when the X server dies and the screen 1652 * remains blanked due to KD_GRAPHICS! It would be nice to do 1653 * this outside of VT_PROCESS but there is no single process 1654 * to account for and tracking tty count may be undesirable. 1655 */ 1656 reset_vc(vc); 1657 1658 if (old_vc_mode != vc->vc_mode) { 1659 if (vc->vc_mode == KD_TEXT) 1660 do_unblank_screen(1); 1661 else 1662 do_blank_screen(1); 1663 } 1664 } 1665 } 1666 1667 /* 1668 * Wake anyone waiting for their VT to activate 1669 */ 1670 vt_event_post(VT_EVENT_SWITCH, old, vc->vc_num); 1671 return; 1672} 1673 1674/* 1675 * Performs the front-end of a vt switch 1676 */ 1677void change_console(struct vc_data *new_vc) 1678{ 1679 struct vc_data *vc; 1680 1681 if (!new_vc || new_vc->vc_num == fg_console || vt_dont_switch) 1682 return; 1683 1684 /* 1685 * If this vt is in process mode, then we need to handshake with 1686 * that process before switching. Essentially, we store where that 1687 * vt wants to switch to and wait for it to tell us when it's done 1688 * (via VT_RELDISP ioctl). 1689 * 1690 * We also check to see if the controlling process still exists. 1691 * If it doesn't, we reset this vt to auto mode and continue. 1692 * This is a cheap way to track process control. The worst thing 1693 * that can happen is: we send a signal to a process, it dies, and 1694 * the switch gets "lost" waiting for a response; hopefully, the 1695 * user will try again, we'll detect the process is gone (unless 1696 * the user waits just the right amount of time :-) and revert the 1697 * vt to auto control. 1698 */ 1699 vc = vc_cons[fg_console].d; 1700 if (vc->vt_mode.mode == VT_PROCESS) { 1701 /* 1702 * Send the signal as privileged - kill_pid() will 1703 * tell us if the process has gone or something else 1704 * is awry. 1705 * 1706 * We need to set vt_newvt *before* sending the signal or we 1707 * have a race. 1708 */ 1709 vc->vt_newvt = new_vc->vc_num; 1710 if (kill_pid(vc->vt_pid, vc->vt_mode.relsig, 1) == 0) { 1711 /* 1712 * It worked. Mark the vt to switch to and 1713 * return. The process needs to send us a 1714 * VT_RELDISP ioctl to complete the switch. 1715 */ 1716 return; 1717 } 1718 1719 /* 1720 * The controlling process has died, so we revert back to 1721 * normal operation. In this case, we'll also change back 1722 * to KD_TEXT mode. I'm not sure if this is strictly correct 1723 * but it saves the agony when the X server dies and the screen 1724 * remains blanked due to KD_GRAPHICS! It would be nice to do 1725 * this outside of VT_PROCESS but there is no single process 1726 * to account for and tracking tty count may be undesirable. 1727 */ 1728 reset_vc(vc); 1729 1730 /* 1731 * Fall through to normal (VT_AUTO) handling of the switch... 1732 */ 1733 } 1734 1735 /* 1736 * Ignore all switches in KD_GRAPHICS+VT_AUTO mode 1737 */ 1738 if (vc->vc_mode == KD_GRAPHICS) 1739 return; 1740 1741 complete_change_console(new_vc); 1742} 1743 1744/* Perform a kernel triggered VT switch for suspend/resume */ 1745 1746static int disable_vt_switch; 1747 1748int vt_move_to_console(unsigned int vt, int alloc) 1749{ 1750 int prev; 1751 1752 console_lock(); 1753 /* Graphics mode - up to X */ 1754 if (disable_vt_switch) { 1755 console_unlock(); 1756 return 0; 1757 } 1758 prev = fg_console; 1759 1760 if (alloc && vc_allocate(vt)) { 1761 /* we can't have a free VC for now. Too bad, 1762 * we don't want to mess the screen for now. */ 1763 console_unlock(); 1764 return -ENOSPC; 1765 } 1766 1767 if (set_console(vt)) { 1768 /* 1769 * We're unable to switch to the SUSPEND_CONSOLE. 1770 * Let the calling function know so it can decide 1771 * what to do. 1772 */ 1773 console_unlock(); 1774 return -EIO; 1775 } 1776 console_unlock(); 1777 tty_lock(); 1778 if (vt_waitactive(vt + 1)) { 1779 pr_debug("Suspend: Can't switch VCs."); 1780 tty_unlock(); 1781 return -EINTR; 1782 } 1783 tty_unlock(); 1784 return prev; 1785} 1786 1787/* 1788 * Normally during a suspend, we allocate a new console and switch to it. 1789 * When we resume, we switch back to the original console. This switch 1790 * can be slow, so on systems where the framebuffer can handle restoration 1791 * of video registers anyways, there's little point in doing the console 1792 * switch. This function allows you to disable it by passing it '0'. 1793 */ 1794void pm_set_vt_switch(int do_switch) 1795{ 1796 console_lock(); 1797 disable_vt_switch = !do_switch; 1798 console_unlock(); 1799} 1800EXPORT_SYMBOL(pm_set_vt_switch); 1801