drivers/tty/vt/vt_ioctl.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  *  Copyright (C) 1992 obz under the linux copyright
   4  *
   5  *  Dynamic diacritical handling - aeb@cwi.nl - Dec 1993
   6  *  Dynamic keymap and string allocation - aeb@cwi.nl - May 1994
   7  *  Restrict VT switching via ioctl() - grif@cs.ucr.edu - Dec 1995
   8  *  Some code moved for less code duplication - Andi Kleen - Mar 1997
   9  *  Check put/get_user, cleanups - acme@conectiva.com.br - Jun 2001
  10  */
  11
  12 #include <linux/types.h>
  13 #include <linux/errno.h>
  14 #include <linux/sched/signal.h>
  15 #include <linux/tty.h>
  16 #include <linux/timer.h>
  17 #include <linux/kernel.h>
  18 #include <linux/compat.h>
  19 #include <linux/module.h>
  20 #include <linux/kd.h>
  21 #include <linux/vt.h>
  22 #include <linux/string.h>
  23 #include <linux/slab.h>
  24 #include <linux/major.h>
  25 #include <linux/fs.h>
  26 #include <linux/console.h>
  27 #include <linux/consolemap.h>
  28 #include <linux/signal.h>
  29 #include <linux/suspend.h>
  30 #include <linux/timex.h>
  31
  32 #include <asm/io.h>
  33 #include <linux/uaccess.h>
  34
  35 #include <linux/nospec.h>
  36
  37 #include <linux/kbd_kern.h>
  38 #include <linux/vt_kern.h>
  39 #include <linux/kbd_diacr.h>
  40 #include <linux/selection.h>
  41
  42 bool vt_dont_switch;
  43
  44 static inline bool vt_in_use(unsigned int i)
  45 {
  46         const struct vc_data *vc = vc_cons[i].d;
  47
  48         /*
  49          * console_lock must be held to prevent the vc from being deallocated
  50          * while we're checking whether it's in-use.
  51          */
  52         WARN_CONSOLE_UNLOCKED();
  53
  54         return vc && kref_read(&vc->port.kref) > 1;
  55 }
  56
  57 static inline bool vt_busy(int i)
  58 {
  59         if (vt_in_use(i))
  60                 return true;
  61         if (i == fg_console)
  62                 return true;
  63         if (vc_is_sel(vc_cons[i].d))
  64                 return true;
  65
  66         return false;
  67 }
  68
  69 /*
  70  * Console (vt and kd) routines, as defined by USL SVR4 manual, and by
  71  * experimentation and study of X386 SYSV handling.
  72  *
  73  * One point of difference: SYSV vt's are /dev/vtX, which X >= 0, and
  74  * /dev/console is a separate ttyp. Under Linux, /dev/tty0 is /dev/console,
  75  * and the vc start at /dev/ttyX, X >= 1. We maintain that here, so we will
  76  * always treat our set of vt as numbered 1..MAX_NR_CONSOLES (corresponding to
  77  * ttys 0..MAX_NR_CONSOLES-1). Explicitly naming VT 0 is illegal, but using
  78  * /dev/tty0 (fg_console) as a target is legal, since an implicit aliasing
  79  * to the current console is done by the main ioctl code.
  80  */
  81
  82 #ifdef CONFIG_X86
  83 #include <asm/syscalls.h>
  84 #endif
  85
  86 static void complete_change_console(struct vc_data *vc);
  87
  88 /*
  89  *      User space VT_EVENT handlers
  90  */
  91
  92 struct vt_event_wait {
  93         struct list_head list;
  94         struct vt_event event;
  95         int done;
  96 };
  97
  98 static LIST_HEAD(vt_events);
  99 static DEFINE_SPINLOCK(vt_event_lock);
 100 static DECLARE_WAIT_QUEUE_HEAD(vt_event_waitqueue);
 101
 102 /**
 103  *      vt_event_post
 104  *      @event: the event that occurred
 105  *      @old: old console
 106  *      @new: new console
 107  *
 108  *      Post an VT event to interested VT handlers
 109  */
 110
 111 void vt_event_post(unsigned int event, unsigned int old, unsigned int new)
 112 {
 113         struct list_head *pos, *head;
 114         unsigned long flags;
 115         int wake = 0;
 116
 117         spin_lock_irqsave(&vt_event_lock, flags);
 118         head = &vt_events;
 119
 120         list_for_each(pos, head) {
 121                 struct vt_event_wait *ve = list_entry(pos,
 122                                                 struct vt_event_wait, list);
 123                 if (!(ve->event.event & event))
 124                         continue;
 125                 ve->event.event = event;
 126                 /* kernel view is consoles 0..n-1, user space view is
 127                    console 1..n with 0 meaning current, so we must bias */
 128                 ve->event.oldev = old + 1;
 129                 ve->event.newev = new + 1;
 130                 wake = 1;
 131                 ve->done = 1;
 132         }
 133         spin_unlock_irqrestore(&vt_event_lock, flags);
 134         if (wake)
 135                 wake_up_interruptible(&vt_event_waitqueue);
 136 }
 137
 138 static void __vt_event_queue(struct vt_event_wait *vw)
 139 {
 140         unsigned long flags;
 141         /* Prepare the event */
 142         INIT_LIST_HEAD(&vw->list);
 143         vw->done = 0;
 144         /* Queue our event */
 145         spin_lock_irqsave(&vt_event_lock, flags);
 146         list_add(&vw->list, &vt_events);
 147         spin_unlock_irqrestore(&vt_event_lock, flags);
 148 }
 149
 150 static void __vt_event_wait(struct vt_event_wait *vw)
 151 {
 152         /* Wait for it to pass */
 153         wait_event_interruptible(vt_event_waitqueue, vw->done);
 154 }
 155
 156 static void __vt_event_dequeue(struct vt_event_wait *vw)
 157 {
 158         unsigned long flags;
 159
 160         /* Dequeue it */
 161         spin_lock_irqsave(&vt_event_lock, flags);
 162         list_del(&vw->list);
 163         spin_unlock_irqrestore(&vt_event_lock, flags);
 164 }
 165
 166 /**
 167  *      vt_event_wait           -       wait for an event
 168  *      @vw: our event
 169  *
 170  *      Waits for an event to occur which completes our vt_event_wait
 171  *      structure. On return the structure has wv->done set to 1 for success
 172  *      or 0 if some event such as a signal ended the wait.
 173  */
 174
 175 static void vt_event_wait(struct vt_event_wait *vw)
 176 {
 177         __vt_event_queue(vw);
 178         __vt_event_wait(vw);
 179         __vt_event_dequeue(vw);
 180 }
 181
 182 /**
 183  *      vt_event_wait_ioctl     -       event ioctl handler
 184  *      @event: argument to ioctl (the event)
 185  *
 186  *      Implement the VT_WAITEVENT ioctl using the VT event interface
 187  */
 188
 189 static int vt_event_wait_ioctl(struct vt_event __user *event)
 190 {
 191         struct vt_event_wait vw;
 192
 193         if (copy_from_user(&vw.event, event, sizeof(struct vt_event)))
 194                 return -EFAULT;
 195         /* Highest supported event for now */
 196         if (vw.event.event & ~VT_MAX_EVENT)
 197                 return -EINVAL;
 198
 199         vt_event_wait(&vw);
 200         /* If it occurred report it */
 201         if (vw.done) {
 202                 if (copy_to_user(event, &vw.event, sizeof(struct vt_event)))
 203                         return -EFAULT;
 204                 return 0;
 205         }
 206         return -EINTR;
 207 }
 208
 209 /**
 210  *      vt_waitactive   -       active console wait
 211  *      @n: new console
 212  *
 213  *      Helper for event waits. Used to implement the legacy
 214  *      event waiting ioctls in terms of events
 215  */
 216
 217 int vt_waitactive(int n)
 218 {
 219         struct vt_event_wait vw;
 220         do {
 221                 vw.event.event = VT_EVENT_SWITCH;
 222                 __vt_event_queue(&vw);
 223                 if (n == fg_console + 1) {
 224                         __vt_event_dequeue(&vw);
 225                         break;
 226                 }
 227                 __vt_event_wait(&vw);
 228                 __vt_event_dequeue(&vw);
 229                 if (vw.done == 0)
 230                         return -EINTR;
 231         } while (vw.event.newev != n);
 232         return 0;
 233 }
 234
 235 /*
 236  * these are the valid i/o ports we're allowed to change. they map all the
 237  * video ports
 238  */
 239 #define GPFIRST 0x3b4
 240 #define GPLAST 0x3df
 241 #define GPNUM (GPLAST - GPFIRST + 1)
 242
 243 /*
 244  * currently, setting the mode from KD_TEXT to KD_GRAPHICS doesn't do a whole
 245  * lot. i'm not sure if it should do any restoration of modes or what...
 246  *
 247  * XXX It should at least call into the driver, fbdev's definitely need to
 248  * restore their engine state. --BenH
 249  */
 250 static int vt_kdsetmode(struct vc_data *vc, unsigned long mode)
 251 {
 252         switch (mode) {
 253         case KD_GRAPHICS:
 254                 break;
 255         case KD_TEXT0:
 256         case KD_TEXT1:
 257                 mode = KD_TEXT;
 258                 fallthrough;
 259         case KD_TEXT:
 260                 break;
 261         default:
 262                 return -EINVAL;
 263         }
 264
 265         /* FIXME: this needs the console lock extending */
 266         if (vc->vc_mode == mode)
 267                 return 0;
 268
 269         vc->vc_mode = mode;
 270         if (vc->vc_num != fg_console)
 271                 return 0;
 272
 273         /* explicitly blank/unblank the screen if switching modes */
 274         console_lock();
 275         if (mode == KD_TEXT)
 276                 do_unblank_screen(1);
 277         else
 278                 do_blank_screen(1);
 279         console_unlock();
 280
 281         return 0;
 282 }
 283
 284 static int vt_k_ioctl(struct tty_struct *tty, unsigned int cmd,
 285                 unsigned long arg, bool perm)
 286 {
 287         struct vc_data *vc = tty->driver_data;
 288         void __user *up = (void __user *)arg;
 289         unsigned int console = vc->vc_num;
 290         int ret;
 291
 292         switch (cmd) {
 293         case KIOCSOUND:
 294                 if (!perm)
 295                         return -EPERM;
 296                 /*
 297                  * The use of PIT_TICK_RATE is historic, it used to be
 298                  * the platform-dependent CLOCK_TICK_RATE between 2.6.12
 299                  * and 2.6.36, which was a minor but unfortunate ABI
 300                  * change. kd_mksound is locked by the input layer.
 301                  */
 302                 if (arg)
 303                         arg = PIT_TICK_RATE / arg;
 304                 kd_mksound(arg, 0);
 305                 break;
 306
 307         case KDMKTONE:
 308                 if (!perm)
 309                         return -EPERM;
 310         {
 311                 unsigned int ticks, count;
 312
 313                 /*
 314                  * Generate the tone for the appropriate number of ticks.
 315                  * If the time is zero, turn off sound ourselves.
 316                  */
 317                 ticks = msecs_to_jiffies((arg >> 16) & 0xffff);
 318                 count = ticks ? (arg & 0xffff) : 0;
 319                 if (count)
 320                         count = PIT_TICK_RATE / count;
 321                 kd_mksound(count, ticks);
 322                 break;
 323         }
 324
 325         case KDGKBTYPE:
 326                 /*
 327                  * this is naïve.
 328                  */
 329                 return put_user(KB_101, (char __user *)arg);
 330
 331                 /*
 332                  * These cannot be implemented on any machine that implements
 333                  * ioperm() in user level (such as Alpha PCs) or not at all.
 334                  *
 335                  * XXX: you should never use these, just call ioperm directly..
 336                  */
 337 #ifdef CONFIG_X86
 338         case KDADDIO:
 339         case KDDELIO:
 340                 /*
 341                  * KDADDIO and KDDELIO may be able to add ports beyond what
 342                  * we reject here, but to be safe...
 343                  *
 344                  * These are locked internally via sys_ioperm
 345                  */
 346                 if (arg < GPFIRST || arg > GPLAST)
 347                         return -EINVAL;
 348
 349                 return ksys_ioperm(arg, 1, (cmd == KDADDIO)) ? -ENXIO : 0;
 350
 351         case KDENABIO:
 352         case KDDISABIO:
 353                 return ksys_ioperm(GPFIRST, GPNUM,
 354                                   (cmd == KDENABIO)) ? -ENXIO : 0;
 355 #endif
 356
 357         /* Linux m68k/i386 interface for setting the keyboard delay/repeat rate */
 358
 359         case KDKBDREP:
 360         {
 361                 struct kbd_repeat kbrep;
 362
 363                 if (!capable(CAP_SYS_TTY_CONFIG))
 364                         return -EPERM;
 365
 366                 if (copy_from_user(&kbrep, up, sizeof(struct kbd_repeat)))
 367                         return -EFAULT;
 368
 369                 ret = kbd_rate(&kbrep);
 370                 if (ret)
 371                         return ret;
 372                 if (copy_to_user(up, &kbrep, sizeof(struct kbd_repeat)))
 373                         return -EFAULT;
 374                 break;
 375         }
 376
 377         case KDSETMODE:
 378                 if (!perm)
 379                         return -EPERM;
 380
 381                 return vt_kdsetmode(vc, arg);
 382
 383         case KDGETMODE:
 384                 return put_user(vc->vc_mode, (int __user *)arg);
 385
 386         case KDMAPDISP:
 387         case KDUNMAPDISP:
 388                 /*
 389                  * these work like a combination of mmap and KDENABIO.
 390                  * this could be easily finished.
 391                  */
 392                 return -EINVAL;
 393
 394         case KDSKBMODE:
 395                 if (!perm)
 396                         return -EPERM;
 397                 ret = vt_do_kdskbmode(console, arg);
 398                 if (ret)
 399                         return ret;
 400                 tty_ldisc_flush(tty);
 401                 break;
 402
 403         case KDGKBMODE:
 404                 return put_user(vt_do_kdgkbmode(console), (int __user *)arg);
 405
 406         /* this could be folded into KDSKBMODE, but for compatibility
 407            reasons it is not so easy to fold KDGKBMETA into KDGKBMODE */
 408         case KDSKBMETA:
 409                 return vt_do_kdskbmeta(console, arg);
 410
 411         case KDGKBMETA:
 412                 /* FIXME: should review whether this is worth locking */
 413                 return put_user(vt_do_kdgkbmeta(console), (int __user *)arg);
 414
 415         case KDGETKEYCODE:
 416         case KDSETKEYCODE:
 417                 if(!capable(CAP_SYS_TTY_CONFIG))
 418                         perm = 0;
 419                 return vt_do_kbkeycode_ioctl(cmd, up, perm);
 420
 421         case KDGKBENT:
 422         case KDSKBENT:
 423                 return vt_do_kdsk_ioctl(cmd, up, perm, console);
 424
 425         case KDGKBSENT:
 426         case KDSKBSENT:
 427                 return vt_do_kdgkb_ioctl(cmd, up, perm);
 428
 429         /* Diacritical processing. Handled in keyboard.c as it has
 430            to operate on the keyboard locks and structures */
 431         case KDGKBDIACR:
 432         case KDGKBDIACRUC:
 433         case KDSKBDIACR:
 434         case KDSKBDIACRUC:
 435                 return vt_do_diacrit(cmd, up, perm);
 436
 437         /* the ioctls below read/set the flags usually shown in the leds */
 438         /* don't use them - they will go away without warning */
 439         case KDGKBLED:
 440         case KDSKBLED:
 441         case KDGETLED:
 442         case KDSETLED:
 443                 return vt_do_kdskled(console, cmd, arg, perm);
 444
 445         /*
 446          * A process can indicate its willingness to accept signals
 447          * generated by pressing an appropriate key combination.
 448          * Thus, one can have a daemon that e.g. spawns a new console
 449          * upon a keypress and then changes to it.
 450          * See also the kbrequest field of inittab(5).
 451          */
 452         case KDSIGACCEPT:
 453                 if (!perm || !capable(CAP_KILL))
 454                         return -EPERM;
 455                 if (!valid_signal(arg) || arg < 1 || arg == SIGKILL)
 456                         return -EINVAL;
 457
 458                 spin_lock_irq(&vt_spawn_con.lock);
 459                 put_pid(vt_spawn_con.pid);
 460                 vt_spawn_con.pid = get_pid(task_pid(current));
 461                 vt_spawn_con.sig = arg;
 462                 spin_unlock_irq(&vt_spawn_con.lock);
 463                 break;
 464
 465         case KDFONTOP: {
 466                 struct console_font_op op;
 467
 468                 if (copy_from_user(&op, up, sizeof(op)))
 469                         return -EFAULT;
 470                 if (!perm && op.op != KD_FONT_OP_GET)
 471                         return -EPERM;
 472                 ret = con_font_op(vc, &op);
 473                 if (ret)
 474                         return ret;
 475                 if (copy_to_user(up, &op, sizeof(op)))
 476                         return -EFAULT;
 477                 break;
 478         }
 479
 480         default:
 481                 return -ENOIOCTLCMD;
 482         }
 483
 484         return 0;
 485 }
 486
 487 static inline int do_fontx_ioctl(int cmd,
 488                 struct consolefontdesc __user *user_cfd,
 489                 struct console_font_op *op)
 490 {
 491         struct consolefontdesc cfdarg;
 492         int i;
 493
 494         if (copy_from_user(&cfdarg, user_cfd, sizeof(struct consolefontdesc)))
 495                 return -EFAULT;
 496
 497         switch (cmd) {
 498         case PIO_FONTX:
 499                 op->op = KD_FONT_OP_SET;
 500                 op->flags = KD_FONT_FLAG_OLD;
 501                 op->width = 8;
 502                 op->height = cfdarg.charheight;
 503                 op->charcount = cfdarg.charcount;
 504                 op->data = cfdarg.chardata;
 505                 return con_font_op(vc_cons[fg_console].d, op);
 506         case GIO_FONTX: {
 507                 op->op = KD_FONT_OP_GET;
 508                 op->flags = KD_FONT_FLAG_OLD;
 509                 op->width = 8;
 510                 op->height = cfdarg.charheight;
 511                 op->charcount = cfdarg.charcount;
 512                 op->data = cfdarg.chardata;
 513                 i = con_font_op(vc_cons[fg_console].d, op);
 514                 if (i)
 515                         return i;
 516                 cfdarg.charheight = op->height;
 517                 cfdarg.charcount = op->charcount;
 518                 if (copy_to_user(user_cfd, &cfdarg, sizeof(struct consolefontdesc)))
 519                         return -EFAULT;
 520                 return 0;
 521                 }
 522         }
 523         return -EINVAL;
 524 }
 525
 526 static int vt_io_fontreset(struct console_font_op *op)
 527 {
 528         int ret;
 529
 530         if (__is_defined(BROKEN_GRAPHICS_PROGRAMS)) {
 531                 /*
 532                  * With BROKEN_GRAPHICS_PROGRAMS defined, the default font is
 533                  * not saved.
 534                  */
 535                 return -ENOSYS;
 536         }
 537
 538         op->op = KD_FONT_OP_SET_DEFAULT;
 539         op->data = NULL;
 540         ret = con_font_op(vc_cons[fg_console].d, op);
 541         if (ret)
 542                 return ret;
 543
 544         console_lock();
 545         con_set_default_unimap(vc_cons[fg_console].d);
 546         console_unlock();
 547
 548         return 0;
 549 }
 550
 551 static inline int do_unimap_ioctl(int cmd, struct unimapdesc __user *user_ud,
 552                 struct vc_data *vc)
 553 {
 554         struct unimapdesc tmp;
 555
 556         if (copy_from_user(&tmp, user_ud, sizeof tmp))
 557                 return -EFAULT;
 558         switch (cmd) {
 559         case PIO_UNIMAP:
 560                 return con_set_unimap(vc, tmp.entry_ct, tmp.entries);
 561         case GIO_UNIMAP:
 562                 if (fg_console != vc->vc_num)
 563                         return -EPERM;
 564                 return con_get_unimap(vc, tmp.entry_ct, &(user_ud->entry_ct),
 565                                 tmp.entries);
 566         }
 567         return 0;
 568 }
 569
 570 static int vt_io_ioctl(struct vc_data *vc, unsigned int cmd, void __user *up,
 571                 bool perm)
 572 {
 573         struct console_font_op op;      /* used in multiple places here */
 574
 575         switch (cmd) {
 576         case PIO_FONT:
 577                 if (!perm)
 578                         return -EPERM;
 579                 op.op = KD_FONT_OP_SET;
 580                 op.flags = KD_FONT_FLAG_OLD | KD_FONT_FLAG_DONT_RECALC; /* Compatibility */
 581                 op.width = 8;
 582                 op.height = 0;
 583                 op.charcount = 256;
 584                 op.data = up;
 585                 return con_font_op(vc_cons[fg_console].d, &op);
 586
 587         case GIO_FONT:
 588                 op.op = KD_FONT_OP_GET;
 589                 op.flags = KD_FONT_FLAG_OLD;
 590                 op.width = 8;
 591                 op.height = 32;
 592                 op.charcount = 256;
 593                 op.data = up;
 594                 return con_font_op(vc_cons[fg_console].d, &op);
 595
 596         case PIO_CMAP:
 597                 if (!perm)
 598                         return -EPERM;
 599                 return con_set_cmap(up);
 600
 601         case GIO_CMAP:
 602                 return con_get_cmap(up);
 603
 604         case PIO_FONTX:
 605                 if (!perm)
 606                         return -EPERM;
 607
 608                 fallthrough;
 609         case GIO_FONTX:
 610                 return do_fontx_ioctl(cmd, up, &op);
 611
 612         case PIO_FONTRESET:
 613                 if (!perm)
 614                         return -EPERM;
 615
 616                 return vt_io_fontreset(&op);
 617
 618         case PIO_SCRNMAP:
 619                 if (!perm)
 620                         return -EPERM;
 621                 return con_set_trans_old(up);
 622
 623         case GIO_SCRNMAP:
 624                 return con_get_trans_old(up);
 625
 626         case PIO_UNISCRNMAP:
 627                 if (!perm)
 628                         return -EPERM;
 629                 return con_set_trans_new(up);
 630
 631         case GIO_UNISCRNMAP:
 632                 return con_get_trans_new(up);
 633
 634         case PIO_UNIMAPCLR:
 635                 if (!perm)
 636                         return -EPERM;
 637                 con_clear_unimap(vc);
 638                 break;
 639
 640         case PIO_UNIMAP:
 641         case GIO_UNIMAP:
 642                 if (!perm)
 643                         return -EPERM;
 644
 645                 return do_unimap_ioctl(cmd, up, vc);
 646
 647         default:
 648                 return -ENOIOCTLCMD;
 649         }
 650
 651         return 0;
 652 }
 653
 654 static int vt_reldisp(struct vc_data *vc, unsigned int swtch)
 655 {
 656         int newvt, ret;
 657
 658         if (vc->vt_mode.mode != VT_PROCESS)
 659                 return -EINVAL;
 660
 661         /* Switched-to response */
 662         if (vc->vt_newvt < 0) {
 663                  /* If it's just an ACK, ignore it */
 664                 return swtch == VT_ACKACQ ? 0 : -EINVAL;
 665         }
 666
 667         /* Switching-from response */
 668         if (swtch == 0) {
 669                 /* Switch disallowed, so forget we were trying to do it. */
 670                 vc->vt_newvt = -1;
 671                 return 0;
 672         }
 673
 674         /* The current vt has been released, so complete the switch. */
 675         newvt = vc->vt_newvt;
 676         vc->vt_newvt = -1;
 677         ret = vc_allocate(newvt);
 678         if (ret)
 679                 return ret;
 680
 681         /*
 682          * When we actually do the console switch, make sure we are atomic with
 683          * respect to other console switches..
 684          */
 685         complete_change_console(vc_cons[newvt].d);
 686
 687         return 0;
 688 }
 689
 690 static int vt_setactivate(struct vt_setactivate __user *sa)
 691 {
 692         struct vt_setactivate vsa;
 693         struct vc_data *nvc;
 694         int ret;
 695
 696         if (copy_from_user(&vsa, sa, sizeof(vsa)))
 697                 return -EFAULT;
 698         if (vsa.console == 0 || vsa.console > MAX_NR_CONSOLES)
 699                 return -ENXIO;
 700
 701         vsa.console = array_index_nospec(vsa.console, MAX_NR_CONSOLES + 1);
 702         vsa.console--;
 703         console_lock();
 704         ret = vc_allocate(vsa.console);
 705         if (ret) {
 706                 console_unlock();
 707                 return ret;
 708         }
 709
 710         /*
 711          * This is safe providing we don't drop the console sem between
 712          * vc_allocate and finishing referencing nvc.
 713          */
 714         nvc = vc_cons[vsa.console].d;
 715         nvc->vt_mode = vsa.mode;
 716         nvc->vt_mode.frsig = 0;
 717         put_pid(nvc->vt_pid);
 718         nvc->vt_pid = get_pid(task_pid(current));
 719         console_unlock();
 720
 721         /* Commence switch and lock */
 722         /* Review set_console locks */
 723         set_console(vsa.console);
 724
 725         return 0;
 726 }
 727
 728 /* deallocate a single console, if possible (leave 0) */
 729 static int vt_disallocate(unsigned int vc_num)
 730 {
 731         struct vc_data *vc = NULL;
 732         int ret = 0;
 733
 734         console_lock();
 735         if (vt_busy(vc_num))
 736                 ret = -EBUSY;
 737         else if (vc_num)
 738                 vc = vc_deallocate(vc_num);
 739         console_unlock();
 740
 741         if (vc && vc_num >= MIN_NR_CONSOLES)
 742                 tty_port_put(&vc->port);
 743
 744         return ret;
 745 }
 746
 747 /* deallocate all unused consoles, but leave 0 */
 748 static void vt_disallocate_all(void)
 749 {
 750         struct vc_data *vc[MAX_NR_CONSOLES];
 751         int i;
 752
 753         console_lock();
 754         for (i = 1; i < MAX_NR_CONSOLES; i++)
 755                 if (!vt_busy(i))
 756                         vc[i] = vc_deallocate(i);
 757                 else
 758                         vc[i] = NULL;
 759         console_unlock();
 760
 761         for (i = 1; i < MAX_NR_CONSOLES; i++) {
 762                 if (vc[i] && i >= MIN_NR_CONSOLES)
 763                         tty_port_put(&vc[i]->port);
 764         }
 765 }
 766
 767 static int vt_resizex(struct vc_data *vc, struct vt_consize __user *cs)
 768 {
 769         struct vt_consize v;
 770         int i;
 771
 772         if (copy_from_user(&v, cs, sizeof(struct vt_consize)))
 773                 return -EFAULT;
 774
 775         if (v.v_vlin)
 776                 pr_info_once("\"struct vt_consize\"->v_vlin is ignored. Please report if you need this.\n");
 777         if (v.v_clin)
 778                 pr_info_once("\"struct vt_consize\"->v_clin is ignored. Please report if you need this.\n");
 779
 780         console_lock();
 781         for (i = 0; i < MAX_NR_CONSOLES; i++) {
 782                 vc = vc_cons[i].d;
 783
 784                 if (vc) {
 785                         vc->vc_resize_user = 1;
 786                         vc_resize(vc, v.v_cols, v.v_rows);
 787                 }
 788         }
 789         console_unlock();
 790
 791         return 0;
 792 }
 793
 794 /*
 795  * We handle the console-specific ioctl's here.  We allow the
 796  * capability to modify any console, not just the fg_console.
 797  */
 798 int vt_ioctl(struct tty_struct *tty,
 799              unsigned int cmd, unsigned long arg)
 800 {
 801         struct vc_data *vc = tty->driver_data;
 802         void __user *up = (void __user *)arg;
 803         int i, perm;
 804         int ret;
 805
 806         /*
 807          * To have permissions to do most of the vt ioctls, we either have
 808          * to be the owner of the tty, or have CAP_SYS_TTY_CONFIG.
 809          */
 810         perm = 0;
 811         if (current->signal->tty == tty || capable(CAP_SYS_TTY_CONFIG))
 812                 perm = 1;
 813
 814         ret = vt_k_ioctl(tty, cmd, arg, perm);
 815         if (ret != -ENOIOCTLCMD)
 816                 return ret;
 817
 818         ret = vt_io_ioctl(vc, cmd, up, perm);
 819         if (ret != -ENOIOCTLCMD)
 820                 return ret;
 821
 822         switch (cmd) {
 823         case TIOCLINUX:
 824                 return tioclinux(tty, arg);
 825         case VT_SETMODE:
 826         {
 827                 struct vt_mode tmp;
 828
 829                 if (!perm)
 830                         return -EPERM;
 831                 if (copy_from_user(&tmp, up, sizeof(struct vt_mode)))
 832                         return -EFAULT;
 833                 if (tmp.mode != VT_AUTO && tmp.mode != VT_PROCESS)
 834                         return -EINVAL;
 835
 836                 console_lock();
 837                 vc->vt_mode = tmp;
 838                 /* the frsig is ignored, so we set it to 0 */
 839                 vc->vt_mode.frsig = 0;
 840                 put_pid(vc->vt_pid);
 841                 vc->vt_pid = get_pid(task_pid(current));
 842                 /* no switch is required -- saw@shade.msu.ru */
 843                 vc->vt_newvt = -1;
 844                 console_unlock();
 845                 break;
 846         }
 847
 848         case VT_GETMODE:
 849         {
 850                 struct vt_mode tmp;
 851                 int rc;
 852
 853                 console_lock();
 854                 memcpy(&tmp, &vc->vt_mode, sizeof(struct vt_mode));
 855                 console_unlock();
 856
 857                 rc = copy_to_user(up, &tmp, sizeof(struct vt_mode));
 858                 if (rc)
 859                         return -EFAULT;
 860                 break;
 861         }
 862
 863         /*
 864          * Returns global vt state. Note that VT 0 is always open, since
 865          * it's an alias for the current VT, and people can't use it here.
 866          * We cannot return state for more than 16 VTs, since v_state is short.
 867          */
 868         case VT_GETSTATE:
 869         {
 870                 struct vt_stat __user *vtstat = up;
 871                 unsigned short state, mask;
 872
 873                 if (put_user(fg_console + 1, &vtstat->v_active))
 874                         return -EFAULT;
 875
 876                 state = 1;      /* /dev/tty0 is always open */
 877                 console_lock(); /* required by vt_in_use() */
 878                 for (i = 0, mask = 2; i < MAX_NR_CONSOLES && mask;
 879                                 ++i, mask <<= 1)
 880                         if (vt_in_use(i))
 881                                 state |= mask;
 882                 console_unlock();
 883                 return put_user(state, &vtstat->v_state);
 884         }
 885
 886         /*
 887          * Returns the first available (non-opened) console.
 888          */
 889         case VT_OPENQRY:
 890                 console_lock(); /* required by vt_in_use() */
 891                 for (i = 0; i < MAX_NR_CONSOLES; ++i)
 892                         if (!vt_in_use(i))
 893                                 break;
 894                 console_unlock();
 895                 i = i < MAX_NR_CONSOLES ? (i+1) : -1;
 896                 return put_user(i, (int __user *)arg);
 897
 898         /*
 899          * ioctl(fd, VT_ACTIVATE, num) will cause us to switch to vt # num,
 900          * with num >= 1 (switches to vt 0, our console, are not allowed, just
 901          * to preserve sanity).
 902          */
 903         case VT_ACTIVATE:
 904                 if (!perm)
 905                         return -EPERM;
 906                 if (arg == 0 || arg > MAX_NR_CONSOLES)
 907                         return -ENXIO;
 908
 909                 arg--;
 910                 console_lock();
 911                 ret = vc_allocate(arg);
 912                 console_unlock();
 913                 if (ret)
 914                         return ret;
 915                 set_console(arg);
 916                 break;
 917
 918         case VT_SETACTIVATE:
 919                 if (!perm)
 920                         return -EPERM;
 921
 922                 return vt_setactivate(up);
 923
 924         /*
 925          * wait until the specified VT has been activated
 926          */
 927         case VT_WAITACTIVE:
 928                 if (!perm)
 929                         return -EPERM;
 930                 if (arg == 0 || arg > MAX_NR_CONSOLES)
 931                         return -ENXIO;
 932                 return vt_waitactive(arg);
 933
 934         /*
 935          * If a vt is under process control, the kernel will not switch to it
 936          * immediately, but postpone the operation until the process calls this
 937          * ioctl, allowing the switch to complete.
 938          *
 939          * According to the X sources this is the behavior:
 940          *      0:      pending switch-from not OK
 941          *      1:      pending switch-from OK
 942          *      2:      completed switch-to OK
 943          */
 944         case VT_RELDISP:
 945                 if (!perm)
 946                         return -EPERM;
 947
 948                 console_lock();
 949                 ret = vt_reldisp(vc, arg);
 950                 console_unlock();
 951
 952                 return ret;
 953
 954
 955          /*
 956           * Disallocate memory associated to VT (but leave VT1)
 957           */
 958          case VT_DISALLOCATE:
 959                 if (arg > MAX_NR_CONSOLES)
 960                         return -ENXIO;
 961
 962                 if (arg == 0)
 963                         vt_disallocate_all();
 964                 else
 965                         return vt_disallocate(--arg);
 966                 break;
 967
 968         case VT_RESIZE:
 969         {
 970                 struct vt_sizes __user *vtsizes = up;
 971                 struct vc_data *vc;
 972                 ushort ll,cc;
 973
 974                 if (!perm)
 975                         return -EPERM;
 976                 if (get_user(ll, &vtsizes->v_rows) ||
 977                     get_user(cc, &vtsizes->v_cols))
 978                         return -EFAULT;
 979
 980                 console_lock();
 981                 for (i = 0; i < MAX_NR_CONSOLES; i++) {
 982                         vc = vc_cons[i].d;
 983
 984                         if (vc) {
 985                                 vc->vc_resize_user = 1;
 986                                 /* FIXME: review v tty lock */
 987                                 vc_resize(vc_cons[i].d, cc, ll);
 988                         }
 989                 }
 990                 console_unlock();
 991                 break;
 992         }
 993
 994         case VT_RESIZEX:
 995                 if (!perm)
 996                         return -EPERM;
 997
 998                 return vt_resizex(vc, up);
 999
1000         case VT_LOCKSWITCH:
1001                 if (!capable(CAP_SYS_TTY_CONFIG))
1002                         return -EPERM;
1003                 vt_dont_switch = true;
1004                 break;
1005         case VT_UNLOCKSWITCH:
1006                 if (!capable(CAP_SYS_TTY_CONFIG))
1007                         return -EPERM;
1008                 vt_dont_switch = false;
1009                 break;
1010         case VT_GETHIFONTMASK:
1011                 return put_user(vc->vc_hi_font_mask,
1012                                         (unsigned short __user *)arg);
1013         case VT_WAITEVENT:
1014                 return vt_event_wait_ioctl((struct vt_event __user *)arg);
1015         default:
1016                 return -ENOIOCTLCMD;
1017         }
1018
1019         return 0;
1020 }
1021
1022 void reset_vc(struct vc_data *vc)
1023 {
1024         vc->vc_mode = KD_TEXT;
1025         vt_reset_unicode(vc->vc_num);
1026         vc->vt_mode.mode = VT_AUTO;
1027         vc->vt_mode.waitv = 0;
1028         vc->vt_mode.relsig = 0;
1029         vc->vt_mode.acqsig = 0;
1030         vc->vt_mode.frsig = 0;
1031         put_pid(vc->vt_pid);
1032         vc->vt_pid = NULL;
1033         vc->vt_newvt = -1;
1034         if (!in_interrupt())    /* Via keyboard.c:SAK() - akpm */
1035                 reset_palette(vc);
1036 }
1037
1038 void vc_SAK(struct work_struct *work)
1039 {
1040         struct vc *vc_con =
1041                 container_of(work, struct vc, SAK_work);
1042         struct vc_data *vc;
1043         struct tty_struct *tty;
1044
1045         console_lock();
1046         vc = vc_con->d;
1047         if (vc) {
1048                 /* FIXME: review tty ref counting */
1049                 tty = vc->port.tty;
1050                 /*
1051                  * SAK should also work in all raw modes and reset
1052                  * them properly.
1053                  */
1054                 if (tty)
1055                         __do_SAK(tty);
1056                 reset_vc(vc);
1057         }
1058         console_unlock();
1059 }
1060
1061 #ifdef CONFIG_COMPAT
1062
1063 struct compat_consolefontdesc {
1064         unsigned short charcount;       /* characters in font (256 or 512) */
1065         unsigned short charheight;      /* scan lines per character (1-32) */
1066         compat_caddr_t chardata;        /* font data in expanded form */
1067 };
1068
1069 static inline int
1070 compat_fontx_ioctl(int cmd, struct compat_consolefontdesc __user *user_cfd,
1071                          int perm, struct console_font_op *op)
1072 {
1073         struct compat_consolefontdesc cfdarg;
1074         int i;
1075
1076         if (copy_from_user(&cfdarg, user_cfd, sizeof(struct compat_consolefontdesc)))
1077                 return -EFAULT;
1078
1079         switch (cmd) {
1080         case PIO_FONTX:
1081                 if (!perm)
1082                         return -EPERM;
1083                 op->op = KD_FONT_OP_SET;
1084                 op->flags = KD_FONT_FLAG_OLD;
1085                 op->width = 8;
1086                 op->height = cfdarg.charheight;
1087                 op->charcount = cfdarg.charcount;
1088                 op->data = compat_ptr(cfdarg.chardata);
1089                 return con_font_op(vc_cons[fg_console].d, op);
1090         case GIO_FONTX:
1091                 op->op = KD_FONT_OP_GET;
1092                 op->flags = KD_FONT_FLAG_OLD;
1093                 op->width = 8;
1094                 op->height = cfdarg.charheight;
1095                 op->charcount = cfdarg.charcount;
1096                 op->data = compat_ptr(cfdarg.chardata);
1097                 i = con_font_op(vc_cons[fg_console].d, op);
1098                 if (i)
1099                         return i;
1100                 cfdarg.charheight = op->height;
1101                 cfdarg.charcount = op->charcount;
1102                 if (copy_to_user(user_cfd, &cfdarg, sizeof(struct compat_consolefontdesc)))
1103                         return -EFAULT;
1104                 return 0;
1105         }
1106         return -EINVAL;
1107 }
1108
1109 struct compat_console_font_op {
1110         compat_uint_t op;        /* operation code KD_FONT_OP_* */
1111         compat_uint_t flags;     /* KD_FONT_FLAG_* */
1112         compat_uint_t width, height;     /* font size */
1113         compat_uint_t charcount;
1114         compat_caddr_t data;    /* font data with height fixed to 32 */
1115 };
1116
1117 static inline int
1118 compat_kdfontop_ioctl(struct compat_console_font_op __user *fontop,
1119                          int perm, struct console_font_op *op, struct vc_data *vc)
1120 {
1121         int i;
1122
1123         if (copy_from_user(op, fontop, sizeof(struct compat_console_font_op)))
1124                 return -EFAULT;
1125         if (!perm && op->op != KD_FONT_OP_GET)
1126                 return -EPERM;
1127         op->data = compat_ptr(((struct compat_console_font_op *)op)->data);
1128         i = con_font_op(vc, op);
1129         if (i)
1130                 return i;
1131         ((struct compat_console_font_op *)op)->data = (unsigned long)op->data;
1132         if (copy_to_user(fontop, op, sizeof(struct compat_console_font_op)))
1133                 return -EFAULT;
1134         return 0;
1135 }
1136
1137 struct compat_unimapdesc {
1138         unsigned short entry_ct;
1139         compat_caddr_t entries;
1140 };
1141
1142 static inline int
1143 compat_unimap_ioctl(unsigned int cmd, struct compat_unimapdesc __user *user_ud,
1144                          int perm, struct vc_data *vc)
1145 {
1146         struct compat_unimapdesc tmp;
1147         struct unipair __user *tmp_entries;
1148
1149         if (copy_from_user(&tmp, user_ud, sizeof tmp))
1150                 return -EFAULT;
1151         tmp_entries = compat_ptr(tmp.entries);
1152         switch (cmd) {
1153         case PIO_UNIMAP:
1154                 if (!perm)
1155                         return -EPERM;
1156                 return con_set_unimap(vc, tmp.entry_ct, tmp_entries);
1157         case GIO_UNIMAP:
1158                 if (!perm && fg_console != vc->vc_num)
1159                         return -EPERM;
1160                 return con_get_unimap(vc, tmp.entry_ct, &(user_ud->entry_ct), tmp_entries);
1161         }
1162         return 0;
1163 }
1164
1165 long vt_compat_ioctl(struct tty_struct *tty,
1166              unsigned int cmd, unsigned long arg)
1167 {
1168         struct vc_data *vc = tty->driver_data;
1169         struct console_font_op op;      /* used in multiple places here */
1170         void __user *up = compat_ptr(arg);
1171         int perm;
1172
1173         /*
1174          * To have permissions to do most of the vt ioctls, we either have
1175          * to be the owner of the tty, or have CAP_SYS_TTY_CONFIG.
1176          */
1177         perm = 0;
1178         if (current->signal->tty == tty || capable(CAP_SYS_TTY_CONFIG))
1179                 perm = 1;
1180
1181         switch (cmd) {
1182         /*
1183          * these need special handlers for incompatible data structures
1184          */
1185         case PIO_FONTX:
1186         case GIO_FONTX:
1187                 return compat_fontx_ioctl(cmd, up, perm, &op);
1188
1189         case KDFONTOP:
1190                 return compat_kdfontop_ioctl(up, perm, &op, vc);
1191
1192         case PIO_UNIMAP:
1193         case GIO_UNIMAP:
1194                 return compat_unimap_ioctl(cmd, up, perm, vc);
1195
1196         /*
1197          * all these treat 'arg' as an integer
1198          */
1199         case KIOCSOUND:
1200         case KDMKTONE:
1201 #ifdef CONFIG_X86
1202         case KDADDIO:
1203         case KDDELIO:
1204 #endif
1205         case KDSETMODE:
1206         case KDMAPDISP:
1207         case KDUNMAPDISP:
1208         case KDSKBMODE:
1209         case KDSKBMETA:
1210         case KDSKBLED:
1211         case KDSETLED:
1212         case KDSIGACCEPT:
1213         case VT_ACTIVATE:
1214         case VT_WAITACTIVE:
1215         case VT_RELDISP:
1216         case VT_DISALLOCATE:
1217         case VT_RESIZE:
1218         case VT_RESIZEX:
1219                 return vt_ioctl(tty, cmd, arg);
1220
1221         /*
1222          * the rest has a compatible data structure behind arg,
1223          * but we have to convert it to a proper 64 bit pointer.
1224          */
1225         default:
1226                 return vt_ioctl(tty, cmd, (unsigned long)up);
1227         }
1228 }
1229
1230
1231 #endif /* CONFIG_COMPAT */
1232
1233
1234 /*
1235  * Performs the back end of a vt switch. Called under the console
1236  * semaphore.
1237  */
1238 static void complete_change_console(struct vc_data *vc)
1239 {
1240         unsigned char old_vc_mode;
1241         int old = fg_console;
1242
1243         last_console = fg_console;
1244
1245         /*
1246          * If we're switching, we could be going from KD_GRAPHICS to
1247          * KD_TEXT mode or vice versa, which means we need to blank or
1248          * unblank the screen later.
1249          */
1250         old_vc_mode = vc_cons[fg_console].d->vc_mode;
1251         switch_screen(vc);
1252
1253         /*
1254          * This can't appear below a successful kill_pid().  If it did,
1255          * then the *blank_screen operation could occur while X, having
1256          * received acqsig, is waking up on another processor.  This
1257          * condition can lead to overlapping accesses to the VGA range
1258          * and the framebuffer (causing system lockups).
1259          *
1260          * To account for this we duplicate this code below only if the
1261          * controlling process is gone and we've called reset_vc.
1262          */
1263         if (old_vc_mode != vc->vc_mode) {
1264                 if (vc->vc_mode == KD_TEXT)
1265                         do_unblank_screen(1);
1266                 else
1267                         do_blank_screen(1);
1268         }
1269
1270         /*
1271          * If this new console is under process control, send it a signal
1272          * telling it that it has acquired. Also check if it has died and
1273          * clean up (similar to logic employed in change_console())
1274          */
1275         if (vc->vt_mode.mode == VT_PROCESS) {
1276                 /*
1277                  * Send the signal as privileged - kill_pid() will
1278                  * tell us if the process has gone or something else
1279                  * is awry
1280                  */
1281                 if (kill_pid(vc->vt_pid, vc->vt_mode.acqsig, 1) != 0) {
1282                 /*
1283                  * The controlling process has died, so we revert back to
1284                  * normal operation. In this case, we'll also change back
1285                  * to KD_TEXT mode. I'm not sure if this is strictly correct
1286                  * but it saves the agony when the X server dies and the screen
1287                  * remains blanked due to KD_GRAPHICS! It would be nice to do
1288                  * this outside of VT_PROCESS but there is no single process
1289                  * to account for and tracking tty count may be undesirable.
1290                  */
1291                         reset_vc(vc);
1292
1293                         if (old_vc_mode != vc->vc_mode) {
1294                                 if (vc->vc_mode == KD_TEXT)
1295                                         do_unblank_screen(1);
1296                                 else
1297                                         do_blank_screen(1);
1298                         }
1299                 }
1300         }
1301
1302         /*
1303          * Wake anyone waiting for their VT to activate
1304          */
1305         vt_event_post(VT_EVENT_SWITCH, old, vc->vc_num);
1306         return;
1307 }
1308
1309 /*
1310  * Performs the front-end of a vt switch
1311  */
1312 void change_console(struct vc_data *new_vc)
1313 {
1314         struct vc_data *vc;
1315
1316         if (!new_vc || new_vc->vc_num == fg_console || vt_dont_switch)
1317                 return;
1318
1319         /*
1320          * If this vt is in process mode, then we need to handshake with
1321          * that process before switching. Essentially, we store where that
1322          * vt wants to switch to and wait for it to tell us when it's done
1323          * (via VT_RELDISP ioctl).
1324          *
1325          * We also check to see if the controlling process still exists.
1326          * If it doesn't, we reset this vt to auto mode and continue.
1327          * This is a cheap way to track process control. The worst thing
1328          * that can happen is: we send a signal to a process, it dies, and
1329          * the switch gets "lost" waiting for a response; hopefully, the
1330          * user will try again, we'll detect the process is gone (unless
1331          * the user waits just the right amount of time :-) and revert the
1332          * vt to auto control.
1333          */
1334         vc = vc_cons[fg_console].d;
1335         if (vc->vt_mode.mode == VT_PROCESS) {
1336                 /*
1337                  * Send the signal as privileged - kill_pid() will
1338                  * tell us if the process has gone or something else
1339                  * is awry.
1340                  *
1341                  * We need to set vt_newvt *before* sending the signal or we
1342                  * have a race.
1343                  */
1344                 vc->vt_newvt = new_vc->vc_num;
1345                 if (kill_pid(vc->vt_pid, vc->vt_mode.relsig, 1) == 0) {
1346                         /*
1347                          * It worked. Mark the vt to switch to and
1348                          * return. The process needs to send us a
1349                          * VT_RELDISP ioctl to complete the switch.
1350                          */
1351                         return;
1352                 }
1353
1354                 /*
1355                  * The controlling process has died, so we revert back to
1356                  * normal operation. In this case, we'll also change back
1357                  * to KD_TEXT mode. I'm not sure if this is strictly correct
1358                  * but it saves the agony when the X server dies and the screen
1359                  * remains blanked due to KD_GRAPHICS! It would be nice to do
1360                  * this outside of VT_PROCESS but there is no single process
1361                  * to account for and tracking tty count may be undesirable.
1362                  */
1363                 reset_vc(vc);
1364
1365                 /*
1366                  * Fall through to normal (VT_AUTO) handling of the switch...
1367                  */
1368         }
1369
1370         /*
1371          * Ignore all switches in KD_GRAPHICS+VT_AUTO mode
1372          */
1373         if (vc->vc_mode == KD_GRAPHICS)
1374                 return;
1375
1376         complete_change_console(new_vc);
1377 }
1378
1379 /* Perform a kernel triggered VT switch for suspend/resume */
1380
1381 static int disable_vt_switch;
1382
1383 int vt_move_to_console(unsigned int vt, int alloc)
1384 {
1385         int prev;
1386
1387         console_lock();
1388         /* Graphics mode - up to X */
1389         if (disable_vt_switch) {
1390                 console_unlock();
1391                 return 0;
1392         }
1393         prev = fg_console;
1394
1395         if (alloc && vc_allocate(vt)) {
1396                 /* we can't have a free VC for now. Too bad,
1397                  * we don't want to mess the screen for now. */
1398                 console_unlock();
1399                 return -ENOSPC;
1400         }
1401
1402         if (set_console(vt)) {
1403                 /*
1404                  * We're unable to switch to the SUSPEND_CONSOLE.
1405                  * Let the calling function know so it can decide
1406                  * what to do.
1407                  */
1408                 console_unlock();
1409                 return -EIO;
1410         }
1411         console_unlock();
1412         if (vt_waitactive(vt + 1)) {
1413                 pr_debug("Suspend: Can't switch VCs.");
1414                 return -EINTR;
1415         }
1416         return prev;
1417 }
1418
1419 /*
1420  * Normally during a suspend, we allocate a new console and switch to it.
1421  * When we resume, we switch back to the original console.  This switch
1422  * can be slow, so on systems where the framebuffer can handle restoration
1423  * of video registers anyways, there's little point in doing the console
1424  * switch.  This function allows you to disable it by passing it '0'.
1425  */
1426 void pm_set_vt_switch(int do_switch)
1427 {
1428         console_lock();
1429         disable_vt_switch = !do_switch;
1430         console_unlock();
1431 }
1432 EXPORT_SYMBOL(pm_set_vt_switch);