LCOV - code coverage report
Current view: top level - drivers/tty/vt - vt_ioctl.c (source / functions) Hit Total Coverage
Test: Real Lines: 142 425 33.4 %
Date: 2020-10-17 15:46:16 Functions: 2 20 10.0 %
Legend: Neither, QEMU, Real, Both Branches: 0 0 -

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

Generated by: LCOV version 1.14