LCOV - code coverage report
Current view: top level - drivers/tty - tty_io.c (source / functions) Hit Total Coverage
Test: Real Lines: 601 1039 57.8 %
Date: 2020-10-17 15:46:16 Functions: 1 106 0.9 %
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) 1991, 1992  Linus Torvalds
       4                 :            :  */
       5                 :            : 
       6                 :            : /*
       7                 :            :  * 'tty_io.c' gives an orthogonal feeling to tty's, be they consoles
       8                 :            :  * or rs-channels. It also implements echoing, cooked mode etc.
       9                 :            :  *
      10                 :            :  * Kill-line thanks to John T Kohl, who also corrected VMIN = VTIME = 0.
      11                 :            :  *
      12                 :            :  * Modified by Theodore Ts'o, 9/14/92, to dynamically allocate the
      13                 :            :  * tty_struct and tty_queue structures.  Previously there was an array
      14                 :            :  * of 256 tty_struct's which was statically allocated, and the
      15                 :            :  * tty_queue structures were allocated at boot time.  Both are now
      16                 :            :  * dynamically allocated only when the tty is open.
      17                 :            :  *
      18                 :            :  * Also restructured routines so that there is more of a separation
      19                 :            :  * between the high-level tty routines (tty_io.c and tty_ioctl.c) and
      20                 :            :  * the low-level tty routines (serial.c, pty.c, console.c).  This
      21                 :            :  * makes for cleaner and more compact code.  -TYT, 9/17/92
      22                 :            :  *
      23                 :            :  * Modified by Fred N. van Kempen, 01/29/93, to add line disciplines
      24                 :            :  * which can be dynamically activated and de-activated by the line
      25                 :            :  * discipline handling modules (like SLIP).
      26                 :            :  *
      27                 :            :  * NOTE: pay no attention to the line discipline code (yet); its
      28                 :            :  * interface is still subject to change in this version...
      29                 :            :  * -- TYT, 1/31/92
      30                 :            :  *
      31                 :            :  * Added functionality to the OPOST tty handling.  No delays, but all
      32                 :            :  * other bits should be there.
      33                 :            :  *      -- Nick Holloway <alfie@dcs.warwick.ac.uk>, 27th May 1993.
      34                 :            :  *
      35                 :            :  * Rewrote canonical mode and added more termios flags.
      36                 :            :  *      -- julian@uhunix.uhcc.hawaii.edu (J. Cowley), 13Jan94
      37                 :            :  *
      38                 :            :  * Reorganized FASYNC support so mouse code can share it.
      39                 :            :  *      -- ctm@ardi.com, 9Sep95
      40                 :            :  *
      41                 :            :  * New TIOCLINUX variants added.
      42                 :            :  *      -- mj@k332.feld.cvut.cz, 19-Nov-95
      43                 :            :  *
      44                 :            :  * Restrict vt switching via ioctl()
      45                 :            :  *      -- grif@cs.ucr.edu, 5-Dec-95
      46                 :            :  *
      47                 :            :  * Move console and virtual terminal code to more appropriate files,
      48                 :            :  * implement CONFIG_VT and generalize console device interface.
      49                 :            :  *      -- Marko Kohtala <Marko.Kohtala@hut.fi>, March 97
      50                 :            :  *
      51                 :            :  * Rewrote tty_init_dev and tty_release_dev to eliminate races.
      52                 :            :  *      -- Bill Hawes <whawes@star.net>, June 97
      53                 :            :  *
      54                 :            :  * Added devfs support.
      55                 :            :  *      -- C. Scott Ananian <cananian@alumni.princeton.edu>, 13-Jan-1998
      56                 :            :  *
      57                 :            :  * Added support for a Unix98-style ptmx device.
      58                 :            :  *      -- C. Scott Ananian <cananian@alumni.princeton.edu>, 14-Jan-1998
      59                 :            :  *
      60                 :            :  * Reduced memory usage for older ARM systems
      61                 :            :  *      -- Russell King <rmk@arm.linux.org.uk>
      62                 :            :  *
      63                 :            :  * Move do_SAK() into process context.  Less stack use in devfs functions.
      64                 :            :  * alloc_tty_struct() always uses kmalloc()
      65                 :            :  *                       -- Andrew Morton <andrewm@uow.edu.eu> 17Mar01
      66                 :            :  */
      67                 :            : 
      68                 :            : #include <linux/types.h>
      69                 :            : #include <linux/major.h>
      70                 :            : #include <linux/errno.h>
      71                 :            : #include <linux/signal.h>
      72                 :            : #include <linux/fcntl.h>
      73                 :            : #include <linux/sched/signal.h>
      74                 :            : #include <linux/sched/task.h>
      75                 :            : #include <linux/interrupt.h>
      76                 :            : #include <linux/tty.h>
      77                 :            : #include <linux/tty_driver.h>
      78                 :            : #include <linux/tty_flip.h>
      79                 :            : #include <linux/devpts_fs.h>
      80                 :            : #include <linux/file.h>
      81                 :            : #include <linux/fdtable.h>
      82                 :            : #include <linux/console.h>
      83                 :            : #include <linux/timer.h>
      84                 :            : #include <linux/ctype.h>
      85                 :            : #include <linux/kd.h>
      86                 :            : #include <linux/mm.h>
      87                 :            : #include <linux/string.h>
      88                 :            : #include <linux/slab.h>
      89                 :            : #include <linux/poll.h>
      90                 :            : #include <linux/proc_fs.h>
      91                 :            : #include <linux/init.h>
      92                 :            : #include <linux/module.h>
      93                 :            : #include <linux/device.h>
      94                 :            : #include <linux/wait.h>
      95                 :            : #include <linux/bitops.h>
      96                 :            : #include <linux/delay.h>
      97                 :            : #include <linux/seq_file.h>
      98                 :            : #include <linux/serial.h>
      99                 :            : #include <linux/ratelimit.h>
     100                 :            : #include <linux/compat.h>
     101                 :            : 
     102                 :            : #include <linux/uaccess.h>
     103                 :            : 
     104                 :            : #include <linux/kbd_kern.h>
     105                 :            : #include <linux/vt_kern.h>
     106                 :            : #include <linux/selection.h>
     107                 :            : 
     108                 :            : #include <linux/kmod.h>
     109                 :            : #include <linux/nsproxy.h>
     110                 :            : 
     111                 :            : #undef TTY_DEBUG_HANGUP
     112                 :            : #ifdef TTY_DEBUG_HANGUP
     113                 :            : # define tty_debug_hangup(tty, f, args...)      tty_debug(tty, f, ##args)
     114                 :            : #else
     115                 :            : # define tty_debug_hangup(tty, f, args...)      do { } while (0)
     116                 :            : #endif
     117                 :            : 
     118                 :            : #define TTY_PARANOIA_CHECK 1
     119                 :            : #define CHECK_TTY_COUNT 1
     120                 :            : 
     121                 :            : struct ktermios tty_std_termios = {     /* for the benefit of tty drivers  */
     122                 :            :         .c_iflag = ICRNL | IXON,
     123                 :            :         .c_oflag = OPOST | ONLCR,
     124                 :            :         .c_cflag = B38400 | CS8 | CREAD | HUPCL,
     125                 :            :         .c_lflag = ISIG | ICANON | ECHO | ECHOE | ECHOK |
     126                 :            :                    ECHOCTL | ECHOKE | IEXTEN,
     127                 :            :         .c_cc = INIT_C_CC,
     128                 :            :         .c_ispeed = 38400,
     129                 :            :         .c_ospeed = 38400,
     130                 :            :         /* .c_line = N_TTY, */
     131                 :            : };
     132                 :            : 
     133                 :            : EXPORT_SYMBOL(tty_std_termios);
     134                 :            : 
     135                 :            : /* This list gets poked at by procfs and various bits of boot up code. This
     136                 :            :    could do with some rationalisation such as pulling the tty proc function
     137                 :            :    into this file */
     138                 :            : 
     139                 :            : LIST_HEAD(tty_drivers);                 /* linked list of tty drivers */
     140                 :            : 
     141                 :            : /* Mutex to protect creating and releasing a tty */
     142                 :            : DEFINE_MUTEX(tty_mutex);
     143                 :            : 
     144                 :            : static ssize_t tty_read(struct file *, char __user *, size_t, loff_t *);
     145                 :            : static ssize_t tty_write(struct file *, const char __user *, size_t, loff_t *);
     146                 :            : ssize_t redirected_tty_write(struct file *, const char __user *,
     147                 :            :                                                         size_t, loff_t *);
     148                 :            : static __poll_t tty_poll(struct file *, poll_table *);
     149                 :            : static int tty_open(struct inode *, struct file *);
     150                 :            : long tty_ioctl(struct file *file, unsigned int cmd, unsigned long arg);
     151                 :            : #ifdef CONFIG_COMPAT
     152                 :            : static long tty_compat_ioctl(struct file *file, unsigned int cmd,
     153                 :            :                                 unsigned long arg);
     154                 :            : #else
     155                 :            : #define tty_compat_ioctl NULL
     156                 :            : #endif
     157                 :            : static int __tty_fasync(int fd, struct file *filp, int on);
     158                 :            : static int tty_fasync(int fd, struct file *filp, int on);
     159                 :            : static void release_tty(struct tty_struct *tty, int idx);
     160                 :            : 
     161                 :            : /**
     162                 :            :  *      free_tty_struct         -       free a disused tty
     163                 :            :  *      @tty: tty struct to free
     164                 :            :  *
     165                 :            :  *      Free the write buffers, tty queue and tty memory itself.
     166                 :            :  *
     167                 :            :  *      Locking: none. Must be called after tty is definitely unused
     168                 :            :  */
     169                 :            : 
     170                 :          3 : static void free_tty_struct(struct tty_struct *tty)
     171                 :            : {
     172                 :          3 :         tty_ldisc_deinit(tty);
     173                 :          3 :         put_device(tty->dev);
     174                 :          3 :         kfree(tty->write_buf);
     175                 :          3 :         tty->magic = 0xDEADDEAD;
     176                 :          3 :         kfree(tty);
     177                 :          3 : }
     178                 :            : 
     179                 :            : static inline struct tty_struct *file_tty(struct file *file)
     180                 :            : {
     181                 :          3 :         return ((struct tty_file_private *)file->private_data)->tty;
     182                 :            : }
     183                 :            : 
     184                 :          3 : int tty_alloc_file(struct file *file)
     185                 :            : {
     186                 :            :         struct tty_file_private *priv;
     187                 :            : 
     188                 :            :         priv = kmalloc(sizeof(*priv), GFP_KERNEL);
     189                 :          3 :         if (!priv)
     190                 :            :                 return -ENOMEM;
     191                 :            : 
     192                 :          3 :         file->private_data = priv;
     193                 :            : 
     194                 :          3 :         return 0;
     195                 :            : }
     196                 :            : 
     197                 :            : /* Associate a new file with the tty structure */
     198                 :          3 : void tty_add_file(struct tty_struct *tty, struct file *file)
     199                 :            : {
     200                 :          3 :         struct tty_file_private *priv = file->private_data;
     201                 :            : 
     202                 :          3 :         priv->tty = tty;
     203                 :          3 :         priv->file = file;
     204                 :            : 
     205                 :            :         spin_lock(&tty->files_lock);
     206                 :          3 :         list_add(&priv->list, &tty->tty_files);
     207                 :            :         spin_unlock(&tty->files_lock);
     208                 :          3 : }
     209                 :            : 
     210                 :            : /**
     211                 :            :  * tty_free_file - free file->private_data
     212                 :            :  *
     213                 :            :  * This shall be used only for fail path handling when tty_add_file was not
     214                 :            :  * called yet.
     215                 :            :  */
     216                 :          0 : void tty_free_file(struct file *file)
     217                 :            : {
     218                 :          3 :         struct tty_file_private *priv = file->private_data;
     219                 :            : 
     220                 :          3 :         file->private_data = NULL;
     221                 :          3 :         kfree(priv);
     222                 :          0 : }
     223                 :            : 
     224                 :            : /* Delete file from its tty */
     225                 :          3 : static void tty_del_file(struct file *file)
     226                 :            : {
     227                 :          3 :         struct tty_file_private *priv = file->private_data;
     228                 :          3 :         struct tty_struct *tty = priv->tty;
     229                 :            : 
     230                 :            :         spin_lock(&tty->files_lock);
     231                 :            :         list_del(&priv->list);
     232                 :            :         spin_unlock(&tty->files_lock);
     233                 :            :         tty_free_file(file);
     234                 :          3 : }
     235                 :            : 
     236                 :            : /**
     237                 :            :  *      tty_name        -       return tty naming
     238                 :            :  *      @tty: tty structure
     239                 :            :  *
     240                 :            :  *      Convert a tty structure into a name. The name reflects the kernel
     241                 :            :  *      naming policy and if udev is in use may not reflect user space
     242                 :            :  *
     243                 :            :  *      Locking: none
     244                 :            :  */
     245                 :            : 
     246                 :          0 : const char *tty_name(const struct tty_struct *tty)
     247                 :            : {
     248                 :          0 :         if (!tty) /* Hmm.  NULL pointer.  That's fun. */
     249                 :            :                 return "NULL tty";
     250                 :          0 :         return tty->name;
     251                 :            : }
     252                 :            : 
     253                 :            : EXPORT_SYMBOL(tty_name);
     254                 :            : 
     255                 :          0 : const char *tty_driver_name(const struct tty_struct *tty)
     256                 :            : {
     257                 :          0 :         if (!tty || !tty->driver)
     258                 :            :                 return "";
     259                 :          0 :         return tty->driver->name;
     260                 :            : }
     261                 :            : 
     262                 :          3 : static int tty_paranoia_check(struct tty_struct *tty, struct inode *inode,
     263                 :            :                               const char *routine)
     264                 :            : {
     265                 :            : #ifdef TTY_PARANOIA_CHECK
     266                 :          3 :         if (!tty) {
     267                 :          0 :                 pr_warn("(%d:%d): %s: NULL tty\n",
     268                 :            :                         imajor(inode), iminor(inode), routine);
     269                 :          0 :                 return 1;
     270                 :            :         }
     271                 :          3 :         if (tty->magic != TTY_MAGIC) {
     272                 :          0 :                 pr_warn("(%d:%d): %s: bad magic number\n",
     273                 :            :                         imajor(inode), iminor(inode), routine);
     274                 :          0 :                 return 1;
     275                 :            :         }
     276                 :            : #endif
     277                 :            :         return 0;
     278                 :            : }
     279                 :            : 
     280                 :            : /* Caller must hold tty_lock */
     281                 :          3 : static int check_tty_count(struct tty_struct *tty, const char *routine)
     282                 :            : {
     283                 :            : #ifdef CHECK_TTY_COUNT
     284                 :            :         struct list_head *p;
     285                 :            :         int count = 0, kopen_count = 0;
     286                 :            : 
     287                 :            :         spin_lock(&tty->files_lock);
     288                 :          3 :         list_for_each(p, &tty->tty_files) {
     289                 :          3 :                 count++;
     290                 :            :         }
     291                 :            :         spin_unlock(&tty->files_lock);
     292                 :          3 :         if (tty->driver->type == TTY_DRIVER_TYPE_PTY &&
     293                 :          3 :             tty->driver->subtype == PTY_TYPE_SLAVE &&
     294                 :          3 :             tty->link && tty->link->count)
     295                 :          3 :                 count++;
     296                 :          3 :         if (tty_port_kopened(tty->port))
     297                 :            :                 kopen_count++;
     298                 :          3 :         if (tty->count != (count + kopen_count)) {
     299                 :          0 :                 tty_warn(tty, "%s: tty->count(%d) != (#fd's(%d) + #kopen's(%d))\n",
     300                 :            :                          routine, tty->count, count, kopen_count);
     301                 :          0 :                 return (count + kopen_count);
     302                 :            :         }
     303                 :            : #endif
     304                 :            :         return 0;
     305                 :            : }
     306                 :            : 
     307                 :            : /**
     308                 :            :  *      get_tty_driver          -       find device of a tty
     309                 :            :  *      @dev_t: device identifier
     310                 :            :  *      @index: returns the index of the tty
     311                 :            :  *
     312                 :            :  *      This routine returns a tty driver structure, given a device number
     313                 :            :  *      and also passes back the index number.
     314                 :            :  *
     315                 :            :  *      Locking: caller must hold tty_mutex
     316                 :            :  */
     317                 :            : 
     318                 :          3 : static struct tty_driver *get_tty_driver(dev_t device, int *index)
     319                 :            : {
     320                 :            :         struct tty_driver *p;
     321                 :            : 
     322                 :          3 :         list_for_each_entry(p, &tty_drivers, tty_drivers) {
     323                 :          3 :                 dev_t base = MKDEV(p->major, p->minor_start);
     324                 :          3 :                 if (device < base || device >= base + p->num)
     325                 :          3 :                         continue;
     326                 :          3 :                 *index = device - base;
     327                 :          3 :                 return tty_driver_kref_get(p);
     328                 :            :         }
     329                 :            :         return NULL;
     330                 :            : }
     331                 :            : 
     332                 :            : /**
     333                 :            :  *      tty_dev_name_to_number  -       return dev_t for device name
     334                 :            :  *      @name: user space name of device under /dev
     335                 :            :  *      @number: pointer to dev_t that this function will populate
     336                 :            :  *
     337                 :            :  *      This function converts device names like ttyS0 or ttyUSB1 into dev_t
     338                 :            :  *      like (4, 64) or (188, 1). If no corresponding driver is registered then
     339                 :            :  *      the function returns -ENODEV.
     340                 :            :  *
     341                 :            :  *      Locking: this acquires tty_mutex to protect the tty_drivers list from
     342                 :            :  *              being modified while we are traversing it, and makes sure to
     343                 :            :  *              release it before exiting.
     344                 :            :  */
     345                 :          0 : int tty_dev_name_to_number(const char *name, dev_t *number)
     346                 :            : {
     347                 :            :         struct tty_driver *p;
     348                 :            :         int ret;
     349                 :            :         int index, prefix_length = 0;
     350                 :            :         const char *str;
     351                 :            : 
     352                 :          0 :         for (str = name; *str && !isdigit(*str); str++)
     353                 :            :                 ;
     354                 :            : 
     355                 :          0 :         if (!*str)
     356                 :            :                 return -EINVAL;
     357                 :            : 
     358                 :          0 :         ret = kstrtoint(str, 10, &index);
     359                 :          0 :         if (ret)
     360                 :            :                 return ret;
     361                 :            : 
     362                 :          0 :         prefix_length = str - name;
     363                 :          0 :         mutex_lock(&tty_mutex);
     364                 :            : 
     365                 :          0 :         list_for_each_entry(p, &tty_drivers, tty_drivers)
     366                 :          0 :                 if (prefix_length == strlen(p->name) && strncmp(name,
     367                 :            :                                         p->name, prefix_length) == 0) {
     368                 :          0 :                         if (index < p->num) {
     369                 :          0 :                                 *number = MKDEV(p->major, p->minor_start + index);
     370                 :          0 :                                 goto out;
     371                 :            :                         }
     372                 :            :                 }
     373                 :            : 
     374                 :            :         /* if here then driver wasn't found */
     375                 :            :         ret = -ENODEV;
     376                 :            : out:
     377                 :          0 :         mutex_unlock(&tty_mutex);
     378                 :          0 :         return ret;
     379                 :            : }
     380                 :            : EXPORT_SYMBOL_GPL(tty_dev_name_to_number);
     381                 :            : 
     382                 :            : #ifdef CONFIG_CONSOLE_POLL
     383                 :            : 
     384                 :            : /**
     385                 :            :  *      tty_find_polling_driver -       find device of a polled tty
     386                 :            :  *      @name: name string to match
     387                 :            :  *      @line: pointer to resulting tty line nr
     388                 :            :  *
     389                 :            :  *      This routine returns a tty driver structure, given a name
     390                 :            :  *      and the condition that the tty driver is capable of polled
     391                 :            :  *      operation.
     392                 :            :  */
     393                 :          0 : struct tty_driver *tty_find_polling_driver(char *name, int *line)
     394                 :            : {
     395                 :            :         struct tty_driver *p, *res = NULL;
     396                 :            :         int tty_line = 0;
     397                 :            :         int len;
     398                 :            :         char *str, *stp;
     399                 :            : 
     400                 :          0 :         for (str = name; *str; str++)
     401                 :          0 :                 if ((*str >= '0' && *str <= '9') || *str == ',')
     402                 :            :                         break;
     403                 :          0 :         if (!*str)
     404                 :            :                 return NULL;
     405                 :            : 
     406                 :          0 :         len = str - name;
     407                 :          0 :         tty_line = simple_strtoul(str, &str, 10);
     408                 :            : 
     409                 :          0 :         mutex_lock(&tty_mutex);
     410                 :            :         /* Search through the tty devices to look for a match */
     411                 :          0 :         list_for_each_entry(p, &tty_drivers, tty_drivers) {
     412                 :          0 :                 if (!len || strncmp(name, p->name, len) != 0)
     413                 :          0 :                         continue;
     414                 :          0 :                 stp = str;
     415                 :          0 :                 if (*stp == ',')
     416                 :          0 :                         stp++;
     417                 :          0 :                 if (*stp == '\0')
     418                 :            :                         stp = NULL;
     419                 :            : 
     420                 :          0 :                 if (tty_line >= 0 && tty_line < p->num && p->ops &&
     421                 :          0 :                     p->ops->poll_init && !p->ops->poll_init(p, tty_line, stp)) {
     422                 :            :                         res = tty_driver_kref_get(p);
     423                 :          0 :                         *line = tty_line;
     424                 :          0 :                         break;
     425                 :            :                 }
     426                 :            :         }
     427                 :          0 :         mutex_unlock(&tty_mutex);
     428                 :            : 
     429                 :          0 :         return res;
     430                 :            : }
     431                 :            : EXPORT_SYMBOL_GPL(tty_find_polling_driver);
     432                 :            : #endif
     433                 :            : 
     434                 :          0 : static ssize_t hung_up_tty_read(struct file *file, char __user *buf,
     435                 :            :                                 size_t count, loff_t *ppos)
     436                 :            : {
     437                 :          0 :         return 0;
     438                 :            : }
     439                 :            : 
     440                 :          0 : static ssize_t hung_up_tty_write(struct file *file, const char __user *buf,
     441                 :            :                                  size_t count, loff_t *ppos)
     442                 :            : {
     443                 :          0 :         return -EIO;
     444                 :            : }
     445                 :            : 
     446                 :            : /* No kernel lock held - none needed ;) */
     447                 :          0 : static __poll_t hung_up_tty_poll(struct file *filp, poll_table *wait)
     448                 :            : {
     449                 :          0 :         return EPOLLIN | EPOLLOUT | EPOLLERR | EPOLLHUP | EPOLLRDNORM | EPOLLWRNORM;
     450                 :            : }
     451                 :            : 
     452                 :          0 : static long hung_up_tty_ioctl(struct file *file, unsigned int cmd,
     453                 :            :                 unsigned long arg)
     454                 :            : {
     455                 :          0 :         return cmd == TIOCSPGRP ? -ENOTTY : -EIO;
     456                 :            : }
     457                 :            : 
     458                 :          0 : static long hung_up_tty_compat_ioctl(struct file *file,
     459                 :            :                                      unsigned int cmd, unsigned long arg)
     460                 :            : {
     461                 :          0 :         return cmd == TIOCSPGRP ? -ENOTTY : -EIO;
     462                 :            : }
     463                 :            : 
     464                 :          0 : static int hung_up_tty_fasync(int fd, struct file *file, int on)
     465                 :            : {
     466                 :          0 :         return -ENOTTY;
     467                 :            : }
     468                 :            : 
     469                 :          0 : static void tty_show_fdinfo(struct seq_file *m, struct file *file)
     470                 :            : {
     471                 :            :         struct tty_struct *tty = file_tty(file);
     472                 :            : 
     473                 :          0 :         if (tty && tty->ops && tty->ops->show_fdinfo)
     474                 :          0 :                 tty->ops->show_fdinfo(tty, m);
     475                 :          0 : }
     476                 :            : 
     477                 :            : static const struct file_operations tty_fops = {
     478                 :            :         .llseek         = no_llseek,
     479                 :            :         .read           = tty_read,
     480                 :            :         .write          = tty_write,
     481                 :            :         .poll           = tty_poll,
     482                 :            :         .unlocked_ioctl = tty_ioctl,
     483                 :            :         .compat_ioctl   = tty_compat_ioctl,
     484                 :            :         .open           = tty_open,
     485                 :            :         .release        = tty_release,
     486                 :            :         .fasync         = tty_fasync,
     487                 :            :         .show_fdinfo    = tty_show_fdinfo,
     488                 :            : };
     489                 :            : 
     490                 :            : static const struct file_operations console_fops = {
     491                 :            :         .llseek         = no_llseek,
     492                 :            :         .read           = tty_read,
     493                 :            :         .write          = redirected_tty_write,
     494                 :            :         .poll           = tty_poll,
     495                 :            :         .unlocked_ioctl = tty_ioctl,
     496                 :            :         .compat_ioctl   = tty_compat_ioctl,
     497                 :            :         .open           = tty_open,
     498                 :            :         .release        = tty_release,
     499                 :            :         .fasync         = tty_fasync,
     500                 :            : };
     501                 :            : 
     502                 :            : static const struct file_operations hung_up_tty_fops = {
     503                 :            :         .llseek         = no_llseek,
     504                 :            :         .read           = hung_up_tty_read,
     505                 :            :         .write          = hung_up_tty_write,
     506                 :            :         .poll           = hung_up_tty_poll,
     507                 :            :         .unlocked_ioctl = hung_up_tty_ioctl,
     508                 :            :         .compat_ioctl   = hung_up_tty_compat_ioctl,
     509                 :            :         .release        = tty_release,
     510                 :            :         .fasync         = hung_up_tty_fasync,
     511                 :            : };
     512                 :            : 
     513                 :            : static DEFINE_SPINLOCK(redirect_lock);
     514                 :            : static struct file *redirect;
     515                 :            : 
     516                 :            : extern void tty_sysctl_init(void);
     517                 :            : 
     518                 :            : /**
     519                 :            :  *      tty_wakeup      -       request more data
     520                 :            :  *      @tty: terminal
     521                 :            :  *
     522                 :            :  *      Internal and external helper for wakeups of tty. This function
     523                 :            :  *      informs the line discipline if present that the driver is ready
     524                 :            :  *      to receive more output data.
     525                 :            :  */
     526                 :            : 
     527                 :          3 : void tty_wakeup(struct tty_struct *tty)
     528                 :            : {
     529                 :            :         struct tty_ldisc *ld;
     530                 :            : 
     531                 :          3 :         if (test_bit(TTY_DO_WRITE_WAKEUP, &tty->flags)) {
     532                 :          0 :                 ld = tty_ldisc_ref(tty);
     533                 :          0 :                 if (ld) {
     534                 :          0 :                         if (ld->ops->write_wakeup)
     535                 :          0 :                                 ld->ops->write_wakeup(tty);
     536                 :          0 :                         tty_ldisc_deref(ld);
     537                 :            :                 }
     538                 :            :         }
     539                 :          3 :         wake_up_interruptible_poll(&tty->write_wait, EPOLLOUT);
     540                 :          3 : }
     541                 :            : 
     542                 :            : EXPORT_SYMBOL_GPL(tty_wakeup);
     543                 :            : 
     544                 :            : /**
     545                 :            :  *      __tty_hangup            -       actual handler for hangup events
     546                 :            :  *      @work: tty device
     547                 :            :  *
     548                 :            :  *      This can be called by a "kworker" kernel thread.  That is process
     549                 :            :  *      synchronous but doesn't hold any locks, so we need to make sure we
     550                 :            :  *      have the appropriate locks for what we're doing.
     551                 :            :  *
     552                 :            :  *      The hangup event clears any pending redirections onto the hung up
     553                 :            :  *      device. It ensures future writes will error and it does the needed
     554                 :            :  *      line discipline hangup and signal delivery. The tty object itself
     555                 :            :  *      remains intact.
     556                 :            :  *
     557                 :            :  *      Locking:
     558                 :            :  *              BTM
     559                 :            :  *                redirect lock for undoing redirection
     560                 :            :  *                file list lock for manipulating list of ttys
     561                 :            :  *                tty_ldiscs_lock from called functions
     562                 :            :  *                termios_rwsem resetting termios data
     563                 :            :  *                tasklist_lock to walk task list for hangup event
     564                 :            :  *                  ->siglock to protect ->signal/->sighand
     565                 :            :  */
     566                 :          3 : static void __tty_hangup(struct tty_struct *tty, int exit_session)
     567                 :            : {
     568                 :            :         struct file *cons_filp = NULL;
     569                 :            :         struct file *filp, *f = NULL;
     570                 :            :         struct tty_file_private *priv;
     571                 :            :         int    closecount = 0, n;
     572                 :            :         int refs;
     573                 :            : 
     574                 :          3 :         if (!tty)
     575                 :            :                 return;
     576                 :            : 
     577                 :            : 
     578                 :            :         spin_lock(&redirect_lock);
     579                 :          3 :         if (redirect && file_tty(redirect) == tty) {
     580                 :            :                 f = redirect;
     581                 :          0 :                 redirect = NULL;
     582                 :            :         }
     583                 :            :         spin_unlock(&redirect_lock);
     584                 :            : 
     585                 :          3 :         tty_lock(tty);
     586                 :            : 
     587                 :          3 :         if (test_bit(TTY_HUPPED, &tty->flags)) {
     588                 :          0 :                 tty_unlock(tty);
     589                 :          0 :                 return;
     590                 :            :         }
     591                 :            : 
     592                 :            :         /*
     593                 :            :          * Some console devices aren't actually hung up for technical and
     594                 :            :          * historical reasons, which can lead to indefinite interruptible
     595                 :            :          * sleep in n_tty_read().  The following explicitly tells
     596                 :            :          * n_tty_read() to abort readers.
     597                 :            :          */
     598                 :          3 :         set_bit(TTY_HUPPING, &tty->flags);
     599                 :            : 
     600                 :            :         /* inuse_filps is protected by the single tty lock,
     601                 :            :            this really needs to change if we want to flush the
     602                 :            :            workqueue with the lock held */
     603                 :          3 :         check_tty_count(tty, "tty_hangup");
     604                 :            : 
     605                 :            :         spin_lock(&tty->files_lock);
     606                 :            :         /* This breaks for file handles being sent over AF_UNIX sockets ? */
     607                 :          3 :         list_for_each_entry(priv, &tty->tty_files, list) {
     608                 :          3 :                 filp = priv->file;
     609                 :          3 :                 if (filp->f_op->write == redirected_tty_write)
     610                 :            :                         cons_filp = filp;
     611                 :          3 :                 if (filp->f_op->write != tty_write)
     612                 :          0 :                         continue;
     613                 :          3 :                 closecount++;
     614                 :          3 :                 __tty_fasync(-1, filp, 0);      /* can't block */
     615                 :          3 :                 filp->f_op = &hung_up_tty_fops;
     616                 :            :         }
     617                 :            :         spin_unlock(&tty->files_lock);
     618                 :            : 
     619                 :          3 :         refs = tty_signal_session_leader(tty, exit_session);
     620                 :            :         /* Account for the p->signal references we killed */
     621                 :          3 :         while (refs--)
     622                 :            :                 tty_kref_put(tty);
     623                 :            : 
     624                 :          3 :         tty_ldisc_hangup(tty, cons_filp != NULL);
     625                 :            : 
     626                 :            :         spin_lock_irq(&tty->ctrl_lock);
     627                 :          3 :         clear_bit(TTY_THROTTLED, &tty->flags);
     628                 :          3 :         clear_bit(TTY_DO_WRITE_WAKEUP, &tty->flags);
     629                 :          3 :         put_pid(tty->session);
     630                 :          3 :         put_pid(tty->pgrp);
     631                 :          3 :         tty->session = NULL;
     632                 :          3 :         tty->pgrp = NULL;
     633                 :          3 :         tty->ctrl_status = 0;
     634                 :            :         spin_unlock_irq(&tty->ctrl_lock);
     635                 :            : 
     636                 :            :         /*
     637                 :            :          * If one of the devices matches a console pointer, we
     638                 :            :          * cannot just call hangup() because that will cause
     639                 :            :          * tty->count and state->count to go out of sync.
     640                 :            :          * So we just call close() the right number of times.
     641                 :            :          */
     642                 :          3 :         if (cons_filp) {
     643                 :          0 :                 if (tty->ops->close)
     644                 :          0 :                         for (n = 0; n < closecount; n++)
     645                 :          0 :                                 tty->ops->close(tty, cons_filp);
     646                 :          3 :         } else if (tty->ops->hangup)
     647                 :          3 :                 tty->ops->hangup(tty);
     648                 :            :         /*
     649                 :            :          * We don't want to have driver/ldisc interactions beyond the ones
     650                 :            :          * we did here. The driver layer expects no calls after ->hangup()
     651                 :            :          * from the ldisc side, which is now guaranteed.
     652                 :            :          */
     653                 :          3 :         set_bit(TTY_HUPPED, &tty->flags);
     654                 :          3 :         clear_bit(TTY_HUPPING, &tty->flags);
     655                 :          3 :         tty_unlock(tty);
     656                 :            : 
     657                 :          3 :         if (f)
     658                 :          0 :                 fput(f);
     659                 :            : }
     660                 :            : 
     661                 :          0 : static void do_tty_hangup(struct work_struct *work)
     662                 :            : {
     663                 :            :         struct tty_struct *tty =
     664                 :          0 :                 container_of(work, struct tty_struct, hangup_work);
     665                 :            : 
     666                 :          0 :         __tty_hangup(tty, 0);
     667                 :          0 : }
     668                 :            : 
     669                 :            : /**
     670                 :            :  *      tty_hangup              -       trigger a hangup event
     671                 :            :  *      @tty: tty to hangup
     672                 :            :  *
     673                 :            :  *      A carrier loss (virtual or otherwise) has occurred on this like
     674                 :            :  *      schedule a hangup sequence to run after this event.
     675                 :            :  */
     676                 :            : 
     677                 :          0 : void tty_hangup(struct tty_struct *tty)
     678                 :            : {
     679                 :            :         tty_debug_hangup(tty, "hangup\n");
     680                 :          0 :         schedule_work(&tty->hangup_work);
     681                 :          0 : }
     682                 :            : 
     683                 :            : EXPORT_SYMBOL(tty_hangup);
     684                 :            : 
     685                 :            : /**
     686                 :            :  *      tty_vhangup             -       process vhangup
     687                 :            :  *      @tty: tty to hangup
     688                 :            :  *
     689                 :            :  *      The user has asked via system call for the terminal to be hung up.
     690                 :            :  *      We do this synchronously so that when the syscall returns the process
     691                 :            :  *      is complete. That guarantee is necessary for security reasons.
     692                 :            :  */
     693                 :            : 
     694                 :          3 : void tty_vhangup(struct tty_struct *tty)
     695                 :            : {
     696                 :            :         tty_debug_hangup(tty, "vhangup\n");
     697                 :          3 :         __tty_hangup(tty, 0);
     698                 :          3 : }
     699                 :            : 
     700                 :            : EXPORT_SYMBOL(tty_vhangup);
     701                 :            : 
     702                 :            : 
     703                 :            : /**
     704                 :            :  *      tty_vhangup_self        -       process vhangup for own ctty
     705                 :            :  *
     706                 :            :  *      Perform a vhangup on the current controlling tty
     707                 :            :  */
     708                 :            : 
     709                 :          0 : void tty_vhangup_self(void)
     710                 :            : {
     711                 :            :         struct tty_struct *tty;
     712                 :            : 
     713                 :          0 :         tty = get_current_tty();
     714                 :          0 :         if (tty) {
     715                 :            :                 tty_vhangup(tty);
     716                 :            :                 tty_kref_put(tty);
     717                 :            :         }
     718                 :          0 : }
     719                 :            : 
     720                 :            : /**
     721                 :            :  *      tty_vhangup_session             -       hangup session leader exit
     722                 :            :  *      @tty: tty to hangup
     723                 :            :  *
     724                 :            :  *      The session leader is exiting and hanging up its controlling terminal.
     725                 :            :  *      Every process in the foreground process group is signalled SIGHUP.
     726                 :            :  *
     727                 :            :  *      We do this synchronously so that when the syscall returns the process
     728                 :            :  *      is complete. That guarantee is necessary for security reasons.
     729                 :            :  */
     730                 :            : 
     731                 :          0 : void tty_vhangup_session(struct tty_struct *tty)
     732                 :            : {
     733                 :            :         tty_debug_hangup(tty, "session hangup\n");
     734                 :          0 :         __tty_hangup(tty, 1);
     735                 :          0 : }
     736                 :            : 
     737                 :            : /**
     738                 :            :  *      tty_hung_up_p           -       was tty hung up
     739                 :            :  *      @filp: file pointer of tty
     740                 :            :  *
     741                 :            :  *      Return true if the tty has been subject to a vhangup or a carrier
     742                 :            :  *      loss
     743                 :            :  */
     744                 :            : 
     745                 :          3 : int tty_hung_up_p(struct file *filp)
     746                 :            : {
     747                 :          3 :         return (filp && filp->f_op == &hung_up_tty_fops);
     748                 :            : }
     749                 :            : 
     750                 :            : EXPORT_SYMBOL(tty_hung_up_p);
     751                 :            : 
     752                 :            : /**
     753                 :            :  *      stop_tty        -       propagate flow control
     754                 :            :  *      @tty: tty to stop
     755                 :            :  *
     756                 :            :  *      Perform flow control to the driver. May be called
     757                 :            :  *      on an already stopped device and will not re-call the driver
     758                 :            :  *      method.
     759                 :            :  *
     760                 :            :  *      This functionality is used by both the line disciplines for
     761                 :            :  *      halting incoming flow and by the driver. It may therefore be
     762                 :            :  *      called from any context, may be under the tty atomic_write_lock
     763                 :            :  *      but not always.
     764                 :            :  *
     765                 :            :  *      Locking:
     766                 :            :  *              flow_lock
     767                 :            :  */
     768                 :            : 
     769                 :          0 : void __stop_tty(struct tty_struct *tty)
     770                 :            : {
     771                 :          0 :         if (tty->stopped)
     772                 :          0 :                 return;
     773                 :          0 :         tty->stopped = 1;
     774                 :          0 :         if (tty->ops->stop)
     775                 :          0 :                 tty->ops->stop(tty);
     776                 :            : }
     777                 :            : 
     778                 :          0 : void stop_tty(struct tty_struct *tty)
     779                 :            : {
     780                 :            :         unsigned long flags;
     781                 :            : 
     782                 :          0 :         spin_lock_irqsave(&tty->flow_lock, flags);
     783                 :            :         __stop_tty(tty);
     784                 :            :         spin_unlock_irqrestore(&tty->flow_lock, flags);
     785                 :          0 : }
     786                 :            : EXPORT_SYMBOL(stop_tty);
     787                 :            : 
     788                 :            : /**
     789                 :            :  *      start_tty       -       propagate flow control
     790                 :            :  *      @tty: tty to start
     791                 :            :  *
     792                 :            :  *      Start a tty that has been stopped if at all possible. If this
     793                 :            :  *      tty was previous stopped and is now being started, the driver
     794                 :            :  *      start method is invoked and the line discipline woken.
     795                 :            :  *
     796                 :            :  *      Locking:
     797                 :            :  *              flow_lock
     798                 :            :  */
     799                 :            : 
     800                 :          3 : void __start_tty(struct tty_struct *tty)
     801                 :            : {
     802                 :          3 :         if (!tty->stopped || tty->flow_stopped)
     803                 :          3 :                 return;
     804                 :          0 :         tty->stopped = 0;
     805                 :          0 :         if (tty->ops->start)
     806                 :          0 :                 tty->ops->start(tty);
     807                 :          0 :         tty_wakeup(tty);
     808                 :            : }
     809                 :            : 
     810                 :          3 : void start_tty(struct tty_struct *tty)
     811                 :            : {
     812                 :            :         unsigned long flags;
     813                 :            : 
     814                 :          3 :         spin_lock_irqsave(&tty->flow_lock, flags);
     815                 :          3 :         __start_tty(tty);
     816                 :            :         spin_unlock_irqrestore(&tty->flow_lock, flags);
     817                 :          3 : }
     818                 :            : EXPORT_SYMBOL(start_tty);
     819                 :            : 
     820                 :          3 : static void tty_update_time(struct timespec64 *time)
     821                 :            : {
     822                 :          3 :         time64_t sec = ktime_get_real_seconds();
     823                 :            : 
     824                 :            :         /*
     825                 :            :          * We only care if the two values differ in anything other than the
     826                 :            :          * lower three bits (i.e every 8 seconds).  If so, then we can update
     827                 :            :          * the time of the tty device, otherwise it could be construded as a
     828                 :            :          * security leak to let userspace know the exact timing of the tty.
     829                 :            :          */
     830                 :          3 :         if ((sec ^ time->tv_sec) & ~7)
     831                 :          3 :                 time->tv_sec = sec;
     832                 :          3 : }
     833                 :            : 
     834                 :            : /**
     835                 :            :  *      tty_read        -       read method for tty device files
     836                 :            :  *      @file: pointer to tty file
     837                 :            :  *      @buf: user buffer
     838                 :            :  *      @count: size of user buffer
     839                 :            :  *      @ppos: unused
     840                 :            :  *
     841                 :            :  *      Perform the read system call function on this terminal device. Checks
     842                 :            :  *      for hung up devices before calling the line discipline method.
     843                 :            :  *
     844                 :            :  *      Locking:
     845                 :            :  *              Locks the line discipline internally while needed. Multiple
     846                 :            :  *      read calls may be outstanding in parallel.
     847                 :            :  */
     848                 :            : 
     849                 :          3 : static ssize_t tty_read(struct file *file, char __user *buf, size_t count,
     850                 :            :                         loff_t *ppos)
     851                 :            : {
     852                 :            :         int i;
     853                 :            :         struct inode *inode = file_inode(file);
     854                 :            :         struct tty_struct *tty = file_tty(file);
     855                 :            :         struct tty_ldisc *ld;
     856                 :            : 
     857                 :          3 :         if (tty_paranoia_check(tty, inode, "tty_read"))
     858                 :            :                 return -EIO;
     859                 :          3 :         if (!tty || tty_io_error(tty))
     860                 :            :                 return -EIO;
     861                 :            : 
     862                 :            :         /* We want to wait for the line discipline to sort out in this
     863                 :            :            situation */
     864                 :          3 :         ld = tty_ldisc_ref_wait(tty);
     865                 :          3 :         if (!ld)
     866                 :            :                 return hung_up_tty_read(file, buf, count, ppos);
     867                 :          3 :         if (ld->ops->read)
     868                 :          3 :                 i = ld->ops->read(tty, file, buf, count);
     869                 :            :         else
     870                 :            :                 i = -EIO;
     871                 :          3 :         tty_ldisc_deref(ld);
     872                 :            : 
     873                 :          3 :         if (i > 0)
     874                 :          3 :                 tty_update_time(&inode->i_atime);
     875                 :            : 
     876                 :          3 :         return i;
     877                 :            : }
     878                 :            : 
     879                 :          3 : static void tty_write_unlock(struct tty_struct *tty)
     880                 :            : {
     881                 :          3 :         mutex_unlock(&tty->atomic_write_lock);
     882                 :          3 :         wake_up_interruptible_poll(&tty->write_wait, EPOLLOUT);
     883                 :          3 : }
     884                 :            : 
     885                 :          3 : static int tty_write_lock(struct tty_struct *tty, int ndelay)
     886                 :            : {
     887                 :          3 :         if (!mutex_trylock(&tty->atomic_write_lock)) {
     888                 :          3 :                 if (ndelay)
     889                 :            :                         return -EAGAIN;
     890                 :          3 :                 if (mutex_lock_interruptible(&tty->atomic_write_lock))
     891                 :            :                         return -ERESTARTSYS;
     892                 :            :         }
     893                 :            :         return 0;
     894                 :            : }
     895                 :            : 
     896                 :            : /*
     897                 :            :  * Split writes up in sane blocksizes to avoid
     898                 :            :  * denial-of-service type attacks
     899                 :            :  */
     900                 :          3 : static inline ssize_t do_tty_write(
     901                 :            :         ssize_t (*write)(struct tty_struct *, struct file *, const unsigned char *, size_t),
     902                 :            :         struct tty_struct *tty,
     903                 :            :         struct file *file,
     904                 :            :         const char __user *buf,
     905                 :            :         size_t count)
     906                 :            : {
     907                 :            :         ssize_t ret, written = 0;
     908                 :            :         unsigned int chunk;
     909                 :            : 
     910                 :          3 :         ret = tty_write_lock(tty, file->f_flags & O_NDELAY);
     911                 :          3 :         if (ret < 0)
     912                 :            :                 return ret;
     913                 :            : 
     914                 :            :         /*
     915                 :            :          * We chunk up writes into a temporary buffer. This
     916                 :            :          * simplifies low-level drivers immensely, since they
     917                 :            :          * don't have locking issues and user mode accesses.
     918                 :            :          *
     919                 :            :          * But if TTY_NO_WRITE_SPLIT is set, we should use a
     920                 :            :          * big chunk-size..
     921                 :            :          *
     922                 :            :          * The default chunk-size is 2kB, because the NTTY
     923                 :            :          * layer has problems with bigger chunks. It will
     924                 :            :          * claim to be able to handle more characters than
     925                 :            :          * it actually does.
     926                 :            :          *
     927                 :            :          * FIXME: This can probably go away now except that 64K chunks
     928                 :            :          * are too likely to fail unless switched to vmalloc...
     929                 :            :          */
     930                 :            :         chunk = 2048;
     931                 :          3 :         if (test_bit(TTY_NO_WRITE_SPLIT, &tty->flags))
     932                 :            :                 chunk = 65536;
     933                 :          3 :         if (count < chunk)
     934                 :            :                 chunk = count;
     935                 :            : 
     936                 :            :         /* write_buf/write_cnt is protected by the atomic_write_lock mutex */
     937                 :          3 :         if (tty->write_cnt < chunk) {
     938                 :            :                 unsigned char *buf_chunk;
     939                 :            : 
     940                 :          3 :                 if (chunk < 1024)
     941                 :            :                         chunk = 1024;
     942                 :            : 
     943                 :            :                 buf_chunk = kmalloc(chunk, GFP_KERNEL);
     944                 :          3 :                 if (!buf_chunk) {
     945                 :            :                         ret = -ENOMEM;
     946                 :            :                         goto out;
     947                 :            :                 }
     948                 :          3 :                 kfree(tty->write_buf);
     949                 :          3 :                 tty->write_cnt = chunk;
     950                 :          3 :                 tty->write_buf = buf_chunk;
     951                 :            :         }
     952                 :            : 
     953                 :            :         /* Do the write .. */
     954                 :            :         for (;;) {
     955                 :            :                 size_t size = count;
     956                 :          3 :                 if (size > chunk)
     957                 :            :                         size = chunk;
     958                 :            :                 ret = -EFAULT;
     959                 :          3 :                 if (copy_from_user(tty->write_buf, buf, size))
     960                 :            :                         break;
     961                 :          3 :                 ret = write(tty, file, tty->write_buf, size);
     962                 :          3 :                 if (ret <= 0)
     963                 :            :                         break;
     964                 :          3 :                 written += ret;
     965                 :          3 :                 buf += ret;
     966                 :          3 :                 count -= ret;
     967                 :          3 :                 if (!count)
     968                 :            :                         break;
     969                 :            :                 ret = -ERESTARTSYS;
     970                 :          0 :                 if (signal_pending(current))
     971                 :            :                         break;
     972                 :          0 :                 cond_resched();
     973                 :          0 :         }
     974                 :          3 :         if (written) {
     975                 :          3 :                 tty_update_time(&file_inode(file)->i_mtime);
     976                 :            :                 ret = written;
     977                 :            :         }
     978                 :            : out:
     979                 :          3 :         tty_write_unlock(tty);
     980                 :          3 :         return ret;
     981                 :            : }
     982                 :            : 
     983                 :            : /**
     984                 :            :  * tty_write_message - write a message to a certain tty, not just the console.
     985                 :            :  * @tty: the destination tty_struct
     986                 :            :  * @msg: the message to write
     987                 :            :  *
     988                 :            :  * This is used for messages that need to be redirected to a specific tty.
     989                 :            :  * We don't put it into the syslog queue right now maybe in the future if
     990                 :            :  * really needed.
     991                 :            :  *
     992                 :            :  * We must still hold the BTM and test the CLOSING flag for the moment.
     993                 :            :  */
     994                 :            : 
     995                 :          0 : void tty_write_message(struct tty_struct *tty, char *msg)
     996                 :            : {
     997                 :          0 :         if (tty) {
     998                 :          0 :                 mutex_lock(&tty->atomic_write_lock);
     999                 :          0 :                 tty_lock(tty);
    1000                 :          0 :                 if (tty->ops->write && tty->count > 0)
    1001                 :          0 :                         tty->ops->write(tty, msg, strlen(msg));
    1002                 :          0 :                 tty_unlock(tty);
    1003                 :          0 :                 tty_write_unlock(tty);
    1004                 :            :         }
    1005                 :          0 :         return;
    1006                 :            : }
    1007                 :            : 
    1008                 :            : 
    1009                 :            : /**
    1010                 :            :  *      tty_write               -       write method for tty device file
    1011                 :            :  *      @file: tty file pointer
    1012                 :            :  *      @buf: user data to write
    1013                 :            :  *      @count: bytes to write
    1014                 :            :  *      @ppos: unused
    1015                 :            :  *
    1016                 :            :  *      Write data to a tty device via the line discipline.
    1017                 :            :  *
    1018                 :            :  *      Locking:
    1019                 :            :  *              Locks the line discipline as required
    1020                 :            :  *              Writes to the tty driver are serialized by the atomic_write_lock
    1021                 :            :  *      and are then processed in chunks to the device. The line discipline
    1022                 :            :  *      write method will not be invoked in parallel for each device.
    1023                 :            :  */
    1024                 :            : 
    1025                 :          3 : static ssize_t tty_write(struct file *file, const char __user *buf,
    1026                 :            :                                                 size_t count, loff_t *ppos)
    1027                 :            : {
    1028                 :            :         struct tty_struct *tty = file_tty(file);
    1029                 :            :         struct tty_ldisc *ld;
    1030                 :            :         ssize_t ret;
    1031                 :            : 
    1032                 :          3 :         if (tty_paranoia_check(tty, file_inode(file), "tty_write"))
    1033                 :            :                 return -EIO;
    1034                 :          3 :         if (!tty || !tty->ops->write ||   tty_io_error(tty))
    1035                 :            :                         return -EIO;
    1036                 :            :         /* Short term debug to catch buggy drivers */
    1037                 :          3 :         if (tty->ops->write_room == NULL)
    1038                 :          0 :                 tty_err(tty, "missing write_room method\n");
    1039                 :          3 :         ld = tty_ldisc_ref_wait(tty);
    1040                 :          3 :         if (!ld)
    1041                 :            :                 return hung_up_tty_write(file, buf, count, ppos);
    1042                 :          3 :         if (!ld->ops->write)
    1043                 :            :                 ret = -EIO;
    1044                 :            :         else
    1045                 :          3 :                 ret = do_tty_write(ld->ops->write, tty, file, buf, count);
    1046                 :          3 :         tty_ldisc_deref(ld);
    1047                 :          3 :         return ret;
    1048                 :            : }
    1049                 :            : 
    1050                 :          3 : ssize_t redirected_tty_write(struct file *file, const char __user *buf,
    1051                 :            :                                                 size_t count, loff_t *ppos)
    1052                 :            : {
    1053                 :            :         struct file *p = NULL;
    1054                 :            : 
    1055                 :            :         spin_lock(&redirect_lock);
    1056                 :          3 :         if (redirect)
    1057                 :            :                 p = get_file(redirect);
    1058                 :            :         spin_unlock(&redirect_lock);
    1059                 :            : 
    1060                 :          3 :         if (p) {
    1061                 :            :                 ssize_t res;
    1062                 :          3 :                 res = vfs_write(p, buf, count, &p->f_pos);
    1063                 :          3 :                 fput(p);
    1064                 :          3 :                 return res;
    1065                 :            :         }
    1066                 :          1 :         return tty_write(file, buf, count, ppos);
    1067                 :            : }
    1068                 :            : 
    1069                 :            : /**
    1070                 :            :  *      tty_send_xchar  -       send priority character
    1071                 :            :  *
    1072                 :            :  *      Send a high priority character to the tty even if stopped
    1073                 :            :  *
    1074                 :            :  *      Locking: none for xchar method, write ordering for write method.
    1075                 :            :  */
    1076                 :            : 
    1077                 :          0 : int tty_send_xchar(struct tty_struct *tty, char ch)
    1078                 :            : {
    1079                 :          0 :         int     was_stopped = tty->stopped;
    1080                 :            : 
    1081                 :          0 :         if (tty->ops->send_xchar) {
    1082                 :          0 :                 down_read(&tty->termios_rwsem);
    1083                 :          0 :                 tty->ops->send_xchar(tty, ch);
    1084                 :          0 :                 up_read(&tty->termios_rwsem);
    1085                 :          0 :                 return 0;
    1086                 :            :         }
    1087                 :            : 
    1088                 :          0 :         if (tty_write_lock(tty, 0) < 0)
    1089                 :            :                 return -ERESTARTSYS;
    1090                 :            : 
    1091                 :          0 :         down_read(&tty->termios_rwsem);
    1092                 :          0 :         if (was_stopped)
    1093                 :          0 :                 start_tty(tty);
    1094                 :          0 :         tty->ops->write(tty, &ch, 1);
    1095                 :          0 :         if (was_stopped)
    1096                 :          0 :                 stop_tty(tty);
    1097                 :          0 :         up_read(&tty->termios_rwsem);
    1098                 :          0 :         tty_write_unlock(tty);
    1099                 :          0 :         return 0;
    1100                 :            : }
    1101                 :            : 
    1102                 :            : static char ptychar[] = "pqrstuvwxyzabcde";
    1103                 :            : 
    1104                 :            : /**
    1105                 :            :  *      pty_line_name   -       generate name for a pty
    1106                 :            :  *      @driver: the tty driver in use
    1107                 :            :  *      @index: the minor number
    1108                 :            :  *      @p: output buffer of at least 6 bytes
    1109                 :            :  *
    1110                 :            :  *      Generate a name from a driver reference and write it to the output
    1111                 :            :  *      buffer.
    1112                 :            :  *
    1113                 :            :  *      Locking: None
    1114                 :            :  */
    1115                 :          0 : static void pty_line_name(struct tty_driver *driver, int index, char *p)
    1116                 :            : {
    1117                 :          0 :         int i = index + driver->name_base;
    1118                 :            :         /* ->name is initialized to "ttyp", but "tty" is expected */
    1119                 :          0 :         sprintf(p, "%s%c%x",
    1120                 :          0 :                 driver->subtype == PTY_TYPE_SLAVE ? "tty" : driver->name,
    1121                 :          0 :                 ptychar[i >> 4 & 0xf], i & 0xf);
    1122                 :          0 : }
    1123                 :            : 
    1124                 :            : /**
    1125                 :            :  *      tty_line_name   -       generate name for a tty
    1126                 :            :  *      @driver: the tty driver in use
    1127                 :            :  *      @index: the minor number
    1128                 :            :  *      @p: output buffer of at least 7 bytes
    1129                 :            :  *
    1130                 :            :  *      Generate a name from a driver reference and write it to the output
    1131                 :            :  *      buffer.
    1132                 :            :  *
    1133                 :            :  *      Locking: None
    1134                 :            :  */
    1135                 :          3 : static ssize_t tty_line_name(struct tty_driver *driver, int index, char *p)
    1136                 :            : {
    1137                 :          3 :         if (driver->flags & TTY_DRIVER_UNNUMBERED_NODE)
    1138                 :          3 :                 return sprintf(p, "%s", driver->name);
    1139                 :            :         else
    1140                 :          3 :                 return sprintf(p, "%s%d", driver->name,
    1141                 :          3 :                                index + driver->name_base);
    1142                 :            : }
    1143                 :            : 
    1144                 :            : /**
    1145                 :            :  *      tty_driver_lookup_tty() - find an existing tty, if any
    1146                 :            :  *      @driver: the driver for the tty
    1147                 :            :  *      @idx:    the minor number
    1148                 :            :  *
    1149                 :            :  *      Return the tty, if found. If not found, return NULL or ERR_PTR() if the
    1150                 :            :  *      driver lookup() method returns an error.
    1151                 :            :  *
    1152                 :            :  *      Locking: tty_mutex must be held. If the tty is found, bump the tty kref.
    1153                 :            :  */
    1154                 :          3 : static struct tty_struct *tty_driver_lookup_tty(struct tty_driver *driver,
    1155                 :            :                 struct file *file, int idx)
    1156                 :            : {
    1157                 :            :         struct tty_struct *tty;
    1158                 :            : 
    1159                 :          3 :         if (driver->ops->lookup)
    1160                 :          3 :                 if (!file)
    1161                 :            :                         tty = ERR_PTR(-EIO);
    1162                 :            :                 else
    1163                 :          3 :                         tty = driver->ops->lookup(driver, file, idx);
    1164                 :            :         else
    1165                 :          3 :                 tty = driver->ttys[idx];
    1166                 :            : 
    1167                 :          3 :         if (!IS_ERR(tty))
    1168                 :            :                 tty_kref_get(tty);
    1169                 :          3 :         return tty;
    1170                 :            : }
    1171                 :            : 
    1172                 :            : /**
    1173                 :            :  *      tty_init_termios        -  helper for termios setup
    1174                 :            :  *      @tty: the tty to set up
    1175                 :            :  *
    1176                 :            :  *      Initialise the termios structure for this tty. This runs under
    1177                 :            :  *      the tty_mutex currently so we can be relaxed about ordering.
    1178                 :            :  */
    1179                 :            : 
    1180                 :          3 : void tty_init_termios(struct tty_struct *tty)
    1181                 :            : {
    1182                 :            :         struct ktermios *tp;
    1183                 :          3 :         int idx = tty->index;
    1184                 :            : 
    1185                 :          3 :         if (tty->driver->flags & TTY_DRIVER_RESET_TERMIOS)
    1186                 :          3 :                 tty->termios = tty->driver->init_termios;
    1187                 :            :         else {
    1188                 :            :                 /* Check for lazy saved data */
    1189                 :          3 :                 tp = tty->driver->termios[idx];
    1190                 :          3 :                 if (tp != NULL) {
    1191                 :          3 :                         tty->termios = *tp;
    1192                 :          3 :                         tty->termios.c_line  = tty->driver->init_termios.c_line;
    1193                 :            :                 } else
    1194                 :          3 :                         tty->termios = tty->driver->init_termios;
    1195                 :            :         }
    1196                 :            :         /* Compatibility until drivers always set this */
    1197                 :          3 :         tty->termios.c_ispeed = tty_termios_input_baud_rate(&tty->termios);
    1198                 :          3 :         tty->termios.c_ospeed = tty_termios_baud_rate(&tty->termios);
    1199                 :          3 : }
    1200                 :            : EXPORT_SYMBOL_GPL(tty_init_termios);
    1201                 :            : 
    1202                 :          3 : int tty_standard_install(struct tty_driver *driver, struct tty_struct *tty)
    1203                 :            : {
    1204                 :          3 :         tty_init_termios(tty);
    1205                 :            :         tty_driver_kref_get(driver);
    1206                 :          3 :         tty->count++;
    1207                 :          3 :         driver->ttys[tty->index] = tty;
    1208                 :          3 :         return 0;
    1209                 :            : }
    1210                 :            : EXPORT_SYMBOL_GPL(tty_standard_install);
    1211                 :            : 
    1212                 :            : /**
    1213                 :            :  *      tty_driver_install_tty() - install a tty entry in the driver
    1214                 :            :  *      @driver: the driver for the tty
    1215                 :            :  *      @tty: the tty
    1216                 :            :  *
    1217                 :            :  *      Install a tty object into the driver tables. The tty->index field
    1218                 :            :  *      will be set by the time this is called. This method is responsible
    1219                 :            :  *      for ensuring any need additional structures are allocated and
    1220                 :            :  *      configured.
    1221                 :            :  *
    1222                 :            :  *      Locking: tty_mutex for now
    1223                 :            :  */
    1224                 :          3 : static int tty_driver_install_tty(struct tty_driver *driver,
    1225                 :            :                                                 struct tty_struct *tty)
    1226                 :            : {
    1227                 :          3 :         return driver->ops->install ? driver->ops->install(driver, tty) :
    1228                 :            :                 tty_standard_install(driver, tty);
    1229                 :            : }
    1230                 :            : 
    1231                 :            : /**
    1232                 :            :  *      tty_driver_remove_tty() - remove a tty from the driver tables
    1233                 :            :  *      @driver: the driver for the tty
    1234                 :            :  *      @idx:    the minor number
    1235                 :            :  *
    1236                 :            :  *      Remvoe a tty object from the driver tables. The tty->index field
    1237                 :            :  *      will be set by the time this is called.
    1238                 :            :  *
    1239                 :            :  *      Locking: tty_mutex for now
    1240                 :            :  */
    1241                 :            : static void tty_driver_remove_tty(struct tty_driver *driver, struct tty_struct *tty)
    1242                 :            : {
    1243                 :          3 :         if (driver->ops->remove)
    1244                 :          3 :                 driver->ops->remove(driver, tty);
    1245                 :            :         else
    1246                 :          3 :                 driver->ttys[tty->index] = NULL;
    1247                 :            : }
    1248                 :            : 
    1249                 :            : /*
    1250                 :            :  *      tty_reopen()    - fast re-open of an open tty
    1251                 :            :  *      @tty    - the tty to open
    1252                 :            :  *
    1253                 :            :  *      Return 0 on success, -errno on error.
    1254                 :            :  *      Re-opens on master ptys are not allowed and return -EIO.
    1255                 :            :  *
    1256                 :            :  *      Locking: Caller must hold tty_lock
    1257                 :            :  */
    1258                 :          3 : static int tty_reopen(struct tty_struct *tty)
    1259                 :            : {
    1260                 :          3 :         struct tty_driver *driver = tty->driver;
    1261                 :            :         struct tty_ldisc *ld;
    1262                 :            :         int retval = 0;
    1263                 :            : 
    1264                 :          3 :         if (driver->type == TTY_DRIVER_TYPE_PTY &&
    1265                 :            :             driver->subtype == PTY_TYPE_MASTER)
    1266                 :            :                 return -EIO;
    1267                 :            : 
    1268                 :          3 :         if (!tty->count)
    1269                 :            :                 return -EAGAIN;
    1270                 :            : 
    1271                 :          3 :         if (test_bit(TTY_EXCLUSIVE, &tty->flags) && !capable(CAP_SYS_ADMIN))
    1272                 :            :                 return -EBUSY;
    1273                 :            : 
    1274                 :          3 :         ld = tty_ldisc_ref_wait(tty);
    1275                 :          3 :         if (ld) {
    1276                 :          3 :                 tty_ldisc_deref(ld);
    1277                 :            :         } else {
    1278                 :          0 :                 retval = tty_ldisc_lock(tty, 5 * HZ);
    1279                 :          0 :                 if (retval)
    1280                 :            :                         return retval;
    1281                 :            : 
    1282                 :          0 :                 if (!tty->ldisc)
    1283                 :          0 :                         retval = tty_ldisc_reinit(tty, tty->termios.c_line);
    1284                 :          0 :                 tty_ldisc_unlock(tty);
    1285                 :            :         }
    1286                 :            : 
    1287                 :          3 :         if (retval == 0)
    1288                 :          3 :                 tty->count++;
    1289                 :            : 
    1290                 :          3 :         return retval;
    1291                 :            : }
    1292                 :            : 
    1293                 :            : /**
    1294                 :            :  *      tty_init_dev            -       initialise a tty device
    1295                 :            :  *      @driver: tty driver we are opening a device on
    1296                 :            :  *      @idx: device index
    1297                 :            :  *      @ret_tty: returned tty structure
    1298                 :            :  *
    1299                 :            :  *      Prepare a tty device. This may not be a "new" clean device but
    1300                 :            :  *      could also be an active device. The pty drivers require special
    1301                 :            :  *      handling because of this.
    1302                 :            :  *
    1303                 :            :  *      Locking:
    1304                 :            :  *              The function is called under the tty_mutex, which
    1305                 :            :  *      protects us from the tty struct or driver itself going away.
    1306                 :            :  *
    1307                 :            :  *      On exit the tty device has the line discipline attached and
    1308                 :            :  *      a reference count of 1. If a pair was created for pty/tty use
    1309                 :            :  *      and the other was a pty master then it too has a reference count of 1.
    1310                 :            :  *
    1311                 :            :  * WSH 06/09/97: Rewritten to remove races and properly clean up after a
    1312                 :            :  * failed open.  The new code protects the open with a mutex, so it's
    1313                 :            :  * really quite straightforward.  The mutex locking can probably be
    1314                 :            :  * relaxed for the (most common) case of reopening a tty.
    1315                 :            :  */
    1316                 :            : 
    1317                 :          3 : struct tty_struct *tty_init_dev(struct tty_driver *driver, int idx)
    1318                 :            : {
    1319                 :            :         struct tty_struct *tty;
    1320                 :            :         int retval;
    1321                 :            : 
    1322                 :            :         /*
    1323                 :            :          * First time open is complex, especially for PTY devices.
    1324                 :            :          * This code guarantees that either everything succeeds and the
    1325                 :            :          * TTY is ready for operation, or else the table slots are vacated
    1326                 :            :          * and the allocated memory released.  (Except that the termios
    1327                 :            :          * may be retained.)
    1328                 :            :          */
    1329                 :            : 
    1330                 :          3 :         if (!try_module_get(driver->owner))
    1331                 :            :                 return ERR_PTR(-ENODEV);
    1332                 :            : 
    1333                 :          3 :         tty = alloc_tty_struct(driver, idx);
    1334                 :          3 :         if (!tty) {
    1335                 :            :                 retval = -ENOMEM;
    1336                 :            :                 goto err_module_put;
    1337                 :            :         }
    1338                 :            : 
    1339                 :          3 :         tty_lock(tty);
    1340                 :          3 :         retval = tty_driver_install_tty(driver, tty);
    1341                 :          3 :         if (retval < 0)
    1342                 :            :                 goto err_free_tty;
    1343                 :            : 
    1344                 :          3 :         if (!tty->port)
    1345                 :          3 :                 tty->port = driver->ports[idx];
    1346                 :            : 
    1347                 :          3 :         WARN_RATELIMIT(!tty->port,
    1348                 :            :                         "%s: %s driver does not set tty->port. This will crash the kernel later. Fix the driver!\n",
    1349                 :            :                         __func__, tty->driver->name);
    1350                 :            : 
    1351                 :          3 :         retval = tty_ldisc_lock(tty, 5 * HZ);
    1352                 :          3 :         if (retval)
    1353                 :            :                 goto err_release_lock;
    1354                 :          3 :         tty->port->itty = tty;
    1355                 :            : 
    1356                 :            :         /*
    1357                 :            :          * Structures all installed ... call the ldisc open routines.
    1358                 :            :          * If we fail here just call release_tty to clean up.  No need
    1359                 :            :          * to decrement the use counts, as release_tty doesn't care.
    1360                 :            :          */
    1361                 :          3 :         retval = tty_ldisc_setup(tty, tty->link);
    1362                 :          3 :         if (retval)
    1363                 :            :                 goto err_release_tty;
    1364                 :          3 :         tty_ldisc_unlock(tty);
    1365                 :            :         /* Return the tty locked so that it cannot vanish under the caller */
    1366                 :          3 :         return tty;
    1367                 :            : 
    1368                 :            : err_free_tty:
    1369                 :          0 :         tty_unlock(tty);
    1370                 :          0 :         free_tty_struct(tty);
    1371                 :            : err_module_put:
    1372                 :          0 :         module_put(driver->owner);
    1373                 :          0 :         return ERR_PTR(retval);
    1374                 :            : 
    1375                 :            :         /* call the tty release_tty routine to clean out this slot */
    1376                 :            : err_release_tty:
    1377                 :          0 :         tty_ldisc_unlock(tty);
    1378                 :          0 :         tty_info_ratelimited(tty, "ldisc open failed (%d), clearing slot %d\n",
    1379                 :            :                              retval, idx);
    1380                 :            : err_release_lock:
    1381                 :          0 :         tty_unlock(tty);
    1382                 :          0 :         release_tty(tty, idx);
    1383                 :          0 :         return ERR_PTR(retval);
    1384                 :            : }
    1385                 :            : 
    1386                 :            : /**
    1387                 :            :  * tty_save_termios() - save tty termios data in driver table
    1388                 :            :  * @tty: tty whose termios data to save
    1389                 :            :  *
    1390                 :            :  * Locking: Caller guarantees serialisation with tty_init_termios().
    1391                 :            :  */
    1392                 :          3 : void tty_save_termios(struct tty_struct *tty)
    1393                 :            : {
    1394                 :            :         struct ktermios *tp;
    1395                 :          3 :         int idx = tty->index;
    1396                 :            : 
    1397                 :            :         /* If the port is going to reset then it has no termios to save */
    1398                 :          3 :         if (tty->driver->flags & TTY_DRIVER_RESET_TERMIOS)
    1399                 :            :                 return;
    1400                 :            : 
    1401                 :            :         /* Stash the termios data */
    1402                 :          3 :         tp = tty->driver->termios[idx];
    1403                 :          3 :         if (tp == NULL) {
    1404                 :            :                 tp = kmalloc(sizeof(struct ktermios), GFP_KERNEL);
    1405                 :          3 :                 if (tp == NULL)
    1406                 :            :                         return;
    1407                 :          3 :                 tty->driver->termios[idx] = tp;
    1408                 :            :         }
    1409                 :          3 :         *tp = tty->termios;
    1410                 :            : }
    1411                 :            : EXPORT_SYMBOL_GPL(tty_save_termios);
    1412                 :            : 
    1413                 :            : /**
    1414                 :            :  *      tty_flush_works         -       flush all works of a tty/pty pair
    1415                 :            :  *      @tty: tty device to flush works for (or either end of a pty pair)
    1416                 :            :  *
    1417                 :            :  *      Sync flush all works belonging to @tty (and the 'other' tty).
    1418                 :            :  */
    1419                 :          3 : static void tty_flush_works(struct tty_struct *tty)
    1420                 :            : {
    1421                 :          3 :         flush_work(&tty->SAK_work);
    1422                 :          3 :         flush_work(&tty->hangup_work);
    1423                 :          3 :         if (tty->link) {
    1424                 :          3 :                 flush_work(&tty->link->SAK_work);
    1425                 :          3 :                 flush_work(&tty->link->hangup_work);
    1426                 :            :         }
    1427                 :          3 : }
    1428                 :            : 
    1429                 :            : /**
    1430                 :            :  *      release_one_tty         -       release tty structure memory
    1431                 :            :  *      @kref: kref of tty we are obliterating
    1432                 :            :  *
    1433                 :            :  *      Releases memory associated with a tty structure, and clears out the
    1434                 :            :  *      driver table slots. This function is called when a device is no longer
    1435                 :            :  *      in use. It also gets called when setup of a device fails.
    1436                 :            :  *
    1437                 :            :  *      Locking:
    1438                 :            :  *              takes the file list lock internally when working on the list
    1439                 :            :  *      of ttys that the driver keeps.
    1440                 :            :  *
    1441                 :            :  *      This method gets called from a work queue so that the driver private
    1442                 :            :  *      cleanup ops can sleep (needed for USB at least)
    1443                 :            :  */
    1444                 :          3 : static void release_one_tty(struct work_struct *work)
    1445                 :            : {
    1446                 :            :         struct tty_struct *tty =
    1447                 :          3 :                 container_of(work, struct tty_struct, hangup_work);
    1448                 :          3 :         struct tty_driver *driver = tty->driver;
    1449                 :          3 :         struct module *owner = driver->owner;
    1450                 :            : 
    1451                 :          3 :         if (tty->ops->cleanup)
    1452                 :          3 :                 tty->ops->cleanup(tty);
    1453                 :            : 
    1454                 :          3 :         tty->magic = 0;
    1455                 :            :         tty_driver_kref_put(driver);
    1456                 :          3 :         module_put(owner);
    1457                 :            : 
    1458                 :            :         spin_lock(&tty->files_lock);
    1459                 :          3 :         list_del_init(&tty->tty_files);
    1460                 :            :         spin_unlock(&tty->files_lock);
    1461                 :            : 
    1462                 :          3 :         put_pid(tty->pgrp);
    1463                 :          3 :         put_pid(tty->session);
    1464                 :          3 :         free_tty_struct(tty);
    1465                 :          3 : }
    1466                 :            : 
    1467                 :          3 : static void queue_release_one_tty(struct kref *kref)
    1468                 :            : {
    1469                 :            :         struct tty_struct *tty = container_of(kref, struct tty_struct, kref);
    1470                 :            : 
    1471                 :            :         /* The hangup queue is now free so we can reuse it rather than
    1472                 :            :            waste a chunk of memory for each port */
    1473                 :          3 :         INIT_WORK(&tty->hangup_work, release_one_tty);
    1474                 :          3 :         schedule_work(&tty->hangup_work);
    1475                 :          3 : }
    1476                 :            : 
    1477                 :            : /**
    1478                 :            :  *      tty_kref_put            -       release a tty kref
    1479                 :            :  *      @tty: tty device
    1480                 :            :  *
    1481                 :            :  *      Release a reference to a tty device and if need be let the kref
    1482                 :            :  *      layer destruct the object for us
    1483                 :            :  */
    1484                 :            : 
    1485                 :          3 : void tty_kref_put(struct tty_struct *tty)
    1486                 :            : {
    1487                 :          3 :         if (tty)
    1488                 :          3 :                 kref_put(&tty->kref, queue_release_one_tty);
    1489                 :          3 : }
    1490                 :            : EXPORT_SYMBOL(tty_kref_put);
    1491                 :            : 
    1492                 :            : /**
    1493                 :            :  *      release_tty             -       release tty structure memory
    1494                 :            :  *
    1495                 :            :  *      Release both @tty and a possible linked partner (think pty pair),
    1496                 :            :  *      and decrement the refcount of the backing module.
    1497                 :            :  *
    1498                 :            :  *      Locking:
    1499                 :            :  *              tty_mutex
    1500                 :            :  *              takes the file list lock internally when working on the list
    1501                 :            :  *      of ttys that the driver keeps.
    1502                 :            :  *
    1503                 :            :  */
    1504                 :          3 : static void release_tty(struct tty_struct *tty, int idx)
    1505                 :            : {
    1506                 :            :         /* This should always be true but check for the moment */
    1507                 :          3 :         WARN_ON(tty->index != idx);
    1508                 :          3 :         WARN_ON(!mutex_is_locked(&tty_mutex));
    1509                 :          3 :         if (tty->ops->shutdown)
    1510                 :          3 :                 tty->ops->shutdown(tty);
    1511                 :          3 :         tty_save_termios(tty);
    1512                 :          3 :         tty_driver_remove_tty(tty->driver, tty);
    1513                 :          3 :         tty->port->itty = NULL;
    1514                 :          3 :         if (tty->link)
    1515                 :          3 :                 tty->link->port->itty = NULL;
    1516                 :          3 :         tty_buffer_cancel_work(tty->port);
    1517                 :          3 :         if (tty->link)
    1518                 :          3 :                 tty_buffer_cancel_work(tty->link->port);
    1519                 :            : 
    1520                 :          3 :         tty_kref_put(tty->link);
    1521                 :            :         tty_kref_put(tty);
    1522                 :          3 : }
    1523                 :            : 
    1524                 :            : /**
    1525                 :            :  *      tty_release_checks - check a tty before real release
    1526                 :            :  *      @tty: tty to check
    1527                 :            :  *      @o_tty: link of @tty (if any)
    1528                 :            :  *      @idx: index of the tty
    1529                 :            :  *
    1530                 :            :  *      Performs some paranoid checking before true release of the @tty.
    1531                 :            :  *      This is a no-op unless TTY_PARANOIA_CHECK is defined.
    1532                 :            :  */
    1533                 :          3 : static int tty_release_checks(struct tty_struct *tty, int idx)
    1534                 :            : {
    1535                 :            : #ifdef TTY_PARANOIA_CHECK
    1536                 :          3 :         if (idx < 0 || idx >= tty->driver->num) {
    1537                 :            :                 tty_debug(tty, "bad idx %d\n", idx);
    1538                 :            :                 return -1;
    1539                 :            :         }
    1540                 :            : 
    1541                 :            :         /* not much to check for devpts */
    1542                 :          3 :         if (tty->driver->flags & TTY_DRIVER_DEVPTS_MEM)
    1543                 :            :                 return 0;
    1544                 :            : 
    1545                 :          3 :         if (tty != tty->driver->ttys[idx]) {
    1546                 :            :                 tty_debug(tty, "bad driver table[%d] = %p\n",
    1547                 :            :                           idx, tty->driver->ttys[idx]);
    1548                 :            :                 return -1;
    1549                 :            :         }
    1550                 :          3 :         if (tty->driver->other) {
    1551                 :          0 :                 struct tty_struct *o_tty = tty->link;
    1552                 :            : 
    1553                 :          0 :                 if (o_tty != tty->driver->other->ttys[idx]) {
    1554                 :            :                         tty_debug(tty, "bad other table[%d] = %p\n",
    1555                 :            :                                   idx, tty->driver->other->ttys[idx]);
    1556                 :            :                         return -1;
    1557                 :            :                 }
    1558                 :          0 :                 if (o_tty->link != tty) {
    1559                 :            :                         tty_debug(tty, "bad link = %p\n", o_tty->link);
    1560                 :            :                         return -1;
    1561                 :            :                 }
    1562                 :            :         }
    1563                 :            : #endif
    1564                 :          3 :         return 0;
    1565                 :            : }
    1566                 :            : 
    1567                 :            : /**
    1568                 :            :  *      tty_kclose      -       closes tty opened by tty_kopen
    1569                 :            :  *      @tty: tty device
    1570                 :            :  *
    1571                 :            :  *      Performs the final steps to release and free a tty device. It is the
    1572                 :            :  *      same as tty_release_struct except that it also resets TTY_PORT_KOPENED
    1573                 :            :  *      flag on tty->port.
    1574                 :            :  */
    1575                 :          0 : void tty_kclose(struct tty_struct *tty)
    1576                 :            : {
    1577                 :            :         /*
    1578                 :            :          * Ask the line discipline code to release its structures
    1579                 :            :          */
    1580                 :          0 :         tty_ldisc_release(tty);
    1581                 :            : 
    1582                 :            :         /* Wait for pending work before tty destruction commmences */
    1583                 :          0 :         tty_flush_works(tty);
    1584                 :            : 
    1585                 :            :         tty_debug_hangup(tty, "freeing structure\n");
    1586                 :            :         /*
    1587                 :            :          * The release_tty function takes care of the details of clearing
    1588                 :            :          * the slots and preserving the termios structure. The tty_unlock_pair
    1589                 :            :          * should be safe as we keep a kref while the tty is locked (so the
    1590                 :            :          * unlock never unlocks a freed tty).
    1591                 :            :          */
    1592                 :          0 :         mutex_lock(&tty_mutex);
    1593                 :          0 :         tty_port_set_kopened(tty->port, 0);
    1594                 :          0 :         release_tty(tty, tty->index);
    1595                 :          0 :         mutex_unlock(&tty_mutex);
    1596                 :          0 : }
    1597                 :            : EXPORT_SYMBOL_GPL(tty_kclose);
    1598                 :            : 
    1599                 :            : /**
    1600                 :            :  *      tty_release_struct      -       release a tty struct
    1601                 :            :  *      @tty: tty device
    1602                 :            :  *      @idx: index of the tty
    1603                 :            :  *
    1604                 :            :  *      Performs the final steps to release and free a tty device. It is
    1605                 :            :  *      roughly the reverse of tty_init_dev.
    1606                 :            :  */
    1607                 :          3 : void tty_release_struct(struct tty_struct *tty, int idx)
    1608                 :            : {
    1609                 :            :         /*
    1610                 :            :          * Ask the line discipline code to release its structures
    1611                 :            :          */
    1612                 :          3 :         tty_ldisc_release(tty);
    1613                 :            : 
    1614                 :            :         /* Wait for pending work before tty destruction commmences */
    1615                 :          3 :         tty_flush_works(tty);
    1616                 :            : 
    1617                 :            :         tty_debug_hangup(tty, "freeing structure\n");
    1618                 :            :         /*
    1619                 :            :          * The release_tty function takes care of the details of clearing
    1620                 :            :          * the slots and preserving the termios structure. The tty_unlock_pair
    1621                 :            :          * should be safe as we keep a kref while the tty is locked (so the
    1622                 :            :          * unlock never unlocks a freed tty).
    1623                 :            :          */
    1624                 :          3 :         mutex_lock(&tty_mutex);
    1625                 :          3 :         release_tty(tty, idx);
    1626                 :          3 :         mutex_unlock(&tty_mutex);
    1627                 :          3 : }
    1628                 :            : EXPORT_SYMBOL_GPL(tty_release_struct);
    1629                 :            : 
    1630                 :            : /**
    1631                 :            :  *      tty_release             -       vfs callback for close
    1632                 :            :  *      @inode: inode of tty
    1633                 :            :  *      @filp: file pointer for handle to tty
    1634                 :            :  *
    1635                 :            :  *      Called the last time each file handle is closed that references
    1636                 :            :  *      this tty. There may however be several such references.
    1637                 :            :  *
    1638                 :            :  *      Locking:
    1639                 :            :  *              Takes bkl. See tty_release_dev
    1640                 :            :  *
    1641                 :            :  * Even releasing the tty structures is a tricky business.. We have
    1642                 :            :  * to be very careful that the structures are all released at the
    1643                 :            :  * same time, as interrupts might otherwise get the wrong pointers.
    1644                 :            :  *
    1645                 :            :  * WSH 09/09/97: rewritten to avoid some nasty race conditions that could
    1646                 :            :  * lead to double frees or releasing memory still in use.
    1647                 :            :  */
    1648                 :            : 
    1649                 :          3 : int tty_release(struct inode *inode, struct file *filp)
    1650                 :            : {
    1651                 :            :         struct tty_struct *tty = file_tty(filp);
    1652                 :            :         struct tty_struct *o_tty = NULL;
    1653                 :            :         int     do_sleep, final;
    1654                 :            :         int     idx;
    1655                 :            :         long    timeout = 0;
    1656                 :            :         int     once = 1;
    1657                 :            : 
    1658                 :          3 :         if (tty_paranoia_check(tty, inode, __func__))
    1659                 :            :                 return 0;
    1660                 :            : 
    1661                 :          3 :         tty_lock(tty);
    1662                 :          3 :         check_tty_count(tty, __func__);
    1663                 :            : 
    1664                 :          3 :         __tty_fasync(-1, filp, 0);
    1665                 :            : 
    1666                 :          3 :         idx = tty->index;
    1667                 :          3 :         if (tty->driver->type == TTY_DRIVER_TYPE_PTY &&
    1668                 :            :             tty->driver->subtype == PTY_TYPE_MASTER)
    1669                 :          3 :                 o_tty = tty->link;
    1670                 :            : 
    1671                 :          3 :         if (tty_release_checks(tty, idx)) {
    1672                 :          0 :                 tty_unlock(tty);
    1673                 :          0 :                 return 0;
    1674                 :            :         }
    1675                 :            : 
    1676                 :            :         tty_debug_hangup(tty, "releasing (count=%d)\n", tty->count);
    1677                 :            : 
    1678                 :          3 :         if (tty->ops->close)
    1679                 :          3 :                 tty->ops->close(tty, filp);
    1680                 :            : 
    1681                 :            :         /* If tty is pty master, lock the slave pty (stable lock order) */
    1682                 :          3 :         tty_lock_slave(o_tty);
    1683                 :            : 
    1684                 :            :         /*
    1685                 :            :          * Sanity check: if tty->count is going to zero, there shouldn't be
    1686                 :            :          * any waiters on tty->read_wait or tty->write_wait.  We test the
    1687                 :            :          * wait queues and kick everyone out _before_ actually starting to
    1688                 :            :          * close.  This ensures that we won't block while releasing the tty
    1689                 :            :          * structure.
    1690                 :            :          *
    1691                 :            :          * The test for the o_tty closing is necessary, since the master and
    1692                 :            :          * slave sides may close in any order.  If the slave side closes out
    1693                 :            :          * first, its count will be one, since the master side holds an open.
    1694                 :            :          * Thus this test wouldn't be triggered at the time the slave closed,
    1695                 :            :          * so we do it now.
    1696                 :            :          */
    1697                 :            :         while (1) {
    1698                 :            :                 do_sleep = 0;
    1699                 :            : 
    1700                 :          3 :                 if (tty->count <= 1) {
    1701                 :          3 :                         if (waitqueue_active(&tty->read_wait)) {
    1702                 :          0 :                                 wake_up_poll(&tty->read_wait, EPOLLIN);
    1703                 :            :                                 do_sleep++;
    1704                 :            :                         }
    1705                 :          3 :                         if (waitqueue_active(&tty->write_wait)) {
    1706                 :          0 :                                 wake_up_poll(&tty->write_wait, EPOLLOUT);
    1707                 :          0 :                                 do_sleep++;
    1708                 :            :                         }
    1709                 :            :                 }
    1710                 :          3 :                 if (o_tty && o_tty->count <= 1) {
    1711                 :          3 :                         if (waitqueue_active(&o_tty->read_wait)) {
    1712                 :          0 :                                 wake_up_poll(&o_tty->read_wait, EPOLLIN);
    1713                 :          0 :                                 do_sleep++;
    1714                 :            :                         }
    1715                 :          3 :                         if (waitqueue_active(&o_tty->write_wait)) {
    1716                 :          0 :                                 wake_up_poll(&o_tty->write_wait, EPOLLOUT);
    1717                 :          0 :                                 do_sleep++;
    1718                 :            :                         }
    1719                 :            :                 }
    1720                 :          3 :                 if (!do_sleep)
    1721                 :            :                         break;
    1722                 :            : 
    1723                 :          0 :                 if (once) {
    1724                 :            :                         once = 0;
    1725                 :          0 :                         tty_warn(tty, "read/write wait queue active!\n");
    1726                 :            :                 }
    1727                 :          0 :                 schedule_timeout_killable(timeout);
    1728                 :          0 :                 if (timeout < 120 * HZ)
    1729                 :          0 :                         timeout = 2 * timeout + 1;
    1730                 :            :                 else
    1731                 :            :                         timeout = MAX_SCHEDULE_TIMEOUT;
    1732                 :            :         }
    1733                 :            : 
    1734                 :          3 :         if (o_tty) {
    1735                 :          3 :                 if (--o_tty->count < 0) {
    1736                 :          0 :                         tty_warn(tty, "bad slave count (%d)\n", o_tty->count);
    1737                 :          0 :                         o_tty->count = 0;
    1738                 :            :                 }
    1739                 :            :         }
    1740                 :          3 :         if (--tty->count < 0) {
    1741                 :          0 :                 tty_warn(tty, "bad tty->count (%d)\n", tty->count);
    1742                 :          0 :                 tty->count = 0;
    1743                 :            :         }
    1744                 :            : 
    1745                 :            :         /*
    1746                 :            :          * We've decremented tty->count, so we need to remove this file
    1747                 :            :          * descriptor off the tty->tty_files list; this serves two
    1748                 :            :          * purposes:
    1749                 :            :          *  - check_tty_count sees the correct number of file descriptors
    1750                 :            :          *    associated with this tty.
    1751                 :            :          *  - do_tty_hangup no longer sees this file descriptor as
    1752                 :            :          *    something that needs to be handled for hangups.
    1753                 :            :          */
    1754                 :          3 :         tty_del_file(filp);
    1755                 :            : 
    1756                 :            :         /*
    1757                 :            :          * Perform some housekeeping before deciding whether to return.
    1758                 :            :          *
    1759                 :            :          * If _either_ side is closing, make sure there aren't any
    1760                 :            :          * processes that still think tty or o_tty is their controlling
    1761                 :            :          * tty.
    1762                 :            :          */
    1763                 :          3 :         if (!tty->count) {
    1764                 :          3 :                 read_lock(&tasklist_lock);
    1765                 :          3 :                 session_clear_tty(tty->session);
    1766                 :          3 :                 if (o_tty)
    1767                 :          3 :                         session_clear_tty(o_tty->session);
    1768                 :            :                 read_unlock(&tasklist_lock);
    1769                 :            :         }
    1770                 :            : 
    1771                 :            :         /* check whether both sides are closing ... */
    1772                 :          3 :         final = !tty->count && !(o_tty && o_tty->count);
    1773                 :            : 
    1774                 :          3 :         tty_unlock_slave(o_tty);
    1775                 :          3 :         tty_unlock(tty);
    1776                 :            : 
    1777                 :            :         /* At this point, the tty->count == 0 should ensure a dead tty
    1778                 :            :            cannot be re-opened by a racing opener */
    1779                 :            : 
    1780                 :          3 :         if (!final)
    1781                 :            :                 return 0;
    1782                 :            : 
    1783                 :            :         tty_debug_hangup(tty, "final close\n");
    1784                 :            : 
    1785                 :          3 :         tty_release_struct(tty, idx);
    1786                 :          3 :         return 0;
    1787                 :            : }
    1788                 :            : 
    1789                 :            : /**
    1790                 :            :  *      tty_open_current_tty - get locked tty of current task
    1791                 :            :  *      @device: device number
    1792                 :            :  *      @filp: file pointer to tty
    1793                 :            :  *      @return: locked tty of the current task iff @device is /dev/tty
    1794                 :            :  *
    1795                 :            :  *      Performs a re-open of the current task's controlling tty.
    1796                 :            :  *
    1797                 :            :  *      We cannot return driver and index like for the other nodes because
    1798                 :            :  *      devpts will not work then. It expects inodes to be from devpts FS.
    1799                 :            :  */
    1800                 :          3 : static struct tty_struct *tty_open_current_tty(dev_t device, struct file *filp)
    1801                 :            : {
    1802                 :            :         struct tty_struct *tty;
    1803                 :            :         int retval;
    1804                 :            : 
    1805                 :          3 :         if (device != MKDEV(TTYAUX_MAJOR, 0))
    1806                 :            :                 return NULL;
    1807                 :            : 
    1808                 :          3 :         tty = get_current_tty();
    1809                 :          3 :         if (!tty)
    1810                 :            :                 return ERR_PTR(-ENXIO);
    1811                 :            : 
    1812                 :          3 :         filp->f_flags |= O_NONBLOCK; /* Don't let /dev/tty block */
    1813                 :            :         /* noctty = 1; */
    1814                 :          3 :         tty_lock(tty);
    1815                 :            :         tty_kref_put(tty);      /* safe to drop the kref now */
    1816                 :            : 
    1817                 :          3 :         retval = tty_reopen(tty);
    1818                 :          3 :         if (retval < 0) {
    1819                 :          0 :                 tty_unlock(tty);
    1820                 :            :                 tty = ERR_PTR(retval);
    1821                 :            :         }
    1822                 :          3 :         return tty;
    1823                 :            : }
    1824                 :            : 
    1825                 :            : /**
    1826                 :            :  *      tty_lookup_driver - lookup a tty driver for a given device file
    1827                 :            :  *      @device: device number
    1828                 :            :  *      @filp: file pointer to tty
    1829                 :            :  *      @index: index for the device in the @return driver
    1830                 :            :  *      @return: driver for this inode (with increased refcount)
    1831                 :            :  *
    1832                 :            :  *      If @return is not erroneous, the caller is responsible to decrement the
    1833                 :            :  *      refcount by tty_driver_kref_put.
    1834                 :            :  *
    1835                 :            :  *      Locking: tty_mutex protects get_tty_driver
    1836                 :            :  */
    1837                 :          3 : static struct tty_driver *tty_lookup_driver(dev_t device, struct file *filp,
    1838                 :            :                 int *index)
    1839                 :            : {
    1840                 :            :         struct tty_driver *driver = NULL;
    1841                 :            : 
    1842                 :          3 :         switch (device) {
    1843                 :            : #ifdef CONFIG_VT
    1844                 :            :         case MKDEV(TTY_MAJOR, 0): {
    1845                 :            :                 extern struct tty_driver *console_driver;
    1846                 :          3 :                 driver = tty_driver_kref_get(console_driver);
    1847                 :          3 :                 *index = fg_console;
    1848                 :          3 :                 break;
    1849                 :            :         }
    1850                 :            : #endif
    1851                 :            :         case MKDEV(TTYAUX_MAJOR, 1): {
    1852                 :          3 :                 struct tty_driver *console_driver = console_device(index);
    1853                 :          3 :                 if (console_driver) {
    1854                 :            :                         driver = tty_driver_kref_get(console_driver);
    1855                 :          3 :                         if (driver && filp) {
    1856                 :            :                                 /* Don't let /dev/console block */
    1857                 :          3 :                                 filp->f_flags |= O_NONBLOCK;
    1858                 :          3 :                                 break;
    1859                 :            :                         }
    1860                 :            :                 }
    1861                 :          0 :                 if (driver)
    1862                 :            :                         tty_driver_kref_put(driver);
    1863                 :            :                 return ERR_PTR(-ENODEV);
    1864                 :            :         }
    1865                 :            :         default:
    1866                 :          3 :                 driver = get_tty_driver(device, index);
    1867                 :          3 :                 if (!driver)
    1868                 :            :                         return ERR_PTR(-ENODEV);
    1869                 :            :                 break;
    1870                 :            :         }
    1871                 :          3 :         return driver;
    1872                 :            : }
    1873                 :            : 
    1874                 :            : /**
    1875                 :            :  *      tty_kopen       -       open a tty device for kernel
    1876                 :            :  *      @device: dev_t of device to open
    1877                 :            :  *
    1878                 :            :  *      Opens tty exclusively for kernel. Performs the driver lookup,
    1879                 :            :  *      makes sure it's not already opened and performs the first-time
    1880                 :            :  *      tty initialization.
    1881                 :            :  *
    1882                 :            :  *      Returns the locked initialized &tty_struct
    1883                 :            :  *
    1884                 :            :  *      Claims the global tty_mutex to serialize:
    1885                 :            :  *        - concurrent first-time tty initialization
    1886                 :            :  *        - concurrent tty driver removal w/ lookup
    1887                 :            :  *        - concurrent tty removal from driver table
    1888                 :            :  */
    1889                 :          0 : struct tty_struct *tty_kopen(dev_t device)
    1890                 :            : {
    1891                 :            :         struct tty_struct *tty;
    1892                 :            :         struct tty_driver *driver = NULL;
    1893                 :          0 :         int index = -1;
    1894                 :            : 
    1895                 :          0 :         mutex_lock(&tty_mutex);
    1896                 :          0 :         driver = tty_lookup_driver(device, NULL, &index);
    1897                 :          0 :         if (IS_ERR(driver)) {
    1898                 :          0 :                 mutex_unlock(&tty_mutex);
    1899                 :          0 :                 return ERR_CAST(driver);
    1900                 :            :         }
    1901                 :            : 
    1902                 :            :         /* check whether we're reopening an existing tty */
    1903                 :          0 :         tty = tty_driver_lookup_tty(driver, NULL, index);
    1904                 :          0 :         if (IS_ERR(tty))
    1905                 :            :                 goto out;
    1906                 :            : 
    1907                 :          0 :         if (tty) {
    1908                 :            :                 /* drop kref from tty_driver_lookup_tty() */
    1909                 :            :                 tty_kref_put(tty);
    1910                 :            :                 tty = ERR_PTR(-EBUSY);
    1911                 :            :         } else { /* tty_init_dev returns tty with the tty_lock held */
    1912                 :          0 :                 tty = tty_init_dev(driver, index);
    1913                 :          0 :                 if (IS_ERR(tty))
    1914                 :            :                         goto out;
    1915                 :          0 :                 tty_port_set_kopened(tty->port, 1);
    1916                 :            :         }
    1917                 :            : out:
    1918                 :          0 :         mutex_unlock(&tty_mutex);
    1919                 :            :         tty_driver_kref_put(driver);
    1920                 :          0 :         return tty;
    1921                 :            : }
    1922                 :            : EXPORT_SYMBOL_GPL(tty_kopen);
    1923                 :            : 
    1924                 :            : /**
    1925                 :            :  *      tty_open_by_driver      -       open a tty device
    1926                 :            :  *      @device: dev_t of device to open
    1927                 :            :  *      @inode: inode of device file
    1928                 :            :  *      @filp: file pointer to tty
    1929                 :            :  *
    1930                 :            :  *      Performs the driver lookup, checks for a reopen, or otherwise
    1931                 :            :  *      performs the first-time tty initialization.
    1932                 :            :  *
    1933                 :            :  *      Returns the locked initialized or re-opened &tty_struct
    1934                 :            :  *
    1935                 :            :  *      Claims the global tty_mutex to serialize:
    1936                 :            :  *        - concurrent first-time tty initialization
    1937                 :            :  *        - concurrent tty driver removal w/ lookup
    1938                 :            :  *        - concurrent tty removal from driver table
    1939                 :            :  */
    1940                 :          3 : static struct tty_struct *tty_open_by_driver(dev_t device, struct inode *inode,
    1941                 :            :                                              struct file *filp)
    1942                 :            : {
    1943                 :            :         struct tty_struct *tty;
    1944                 :            :         struct tty_driver *driver = NULL;
    1945                 :          3 :         int index = -1;
    1946                 :            :         int retval;
    1947                 :            : 
    1948                 :          3 :         mutex_lock(&tty_mutex);
    1949                 :          3 :         driver = tty_lookup_driver(device, filp, &index);
    1950                 :          3 :         if (IS_ERR(driver)) {
    1951                 :          0 :                 mutex_unlock(&tty_mutex);
    1952                 :          0 :                 return ERR_CAST(driver);
    1953                 :            :         }
    1954                 :            : 
    1955                 :            :         /* check whether we're reopening an existing tty */
    1956                 :          3 :         tty = tty_driver_lookup_tty(driver, filp, index);
    1957                 :          3 :         if (IS_ERR(tty)) {
    1958                 :          0 :                 mutex_unlock(&tty_mutex);
    1959                 :          0 :                 goto out;
    1960                 :            :         }
    1961                 :            : 
    1962                 :          3 :         if (tty) {
    1963                 :          3 :                 if (tty_port_kopened(tty->port)) {
    1964                 :            :                         tty_kref_put(tty);
    1965                 :          0 :                         mutex_unlock(&tty_mutex);
    1966                 :            :                         tty = ERR_PTR(-EBUSY);
    1967                 :          0 :                         goto out;
    1968                 :            :                 }
    1969                 :          3 :                 mutex_unlock(&tty_mutex);
    1970                 :          3 :                 retval = tty_lock_interruptible(tty);
    1971                 :            :                 tty_kref_put(tty);  /* drop kref from tty_driver_lookup_tty() */
    1972                 :          3 :                 if (retval) {
    1973                 :          0 :                         if (retval == -EINTR)
    1974                 :            :                                 retval = -ERESTARTSYS;
    1975                 :            :                         tty = ERR_PTR(retval);
    1976                 :          0 :                         goto out;
    1977                 :            :                 }
    1978                 :          3 :                 retval = tty_reopen(tty);
    1979                 :          3 :                 if (retval < 0) {
    1980                 :          3 :                         tty_unlock(tty);
    1981                 :            :                         tty = ERR_PTR(retval);
    1982                 :            :                 }
    1983                 :            :         } else { /* Returns with the tty_lock held for now */
    1984                 :          3 :                 tty = tty_init_dev(driver, index);
    1985                 :          3 :                 mutex_unlock(&tty_mutex);
    1986                 :            :         }
    1987                 :            : out:
    1988                 :            :         tty_driver_kref_put(driver);
    1989                 :          3 :         return tty;
    1990                 :            : }
    1991                 :            : 
    1992                 :            : /**
    1993                 :            :  *      tty_open                -       open a tty device
    1994                 :            :  *      @inode: inode of device file
    1995                 :            :  *      @filp: file pointer to tty
    1996                 :            :  *
    1997                 :            :  *      tty_open and tty_release keep up the tty count that contains the
    1998                 :            :  *      number of opens done on a tty. We cannot use the inode-count, as
    1999                 :            :  *      different inodes might point to the same tty.
    2000                 :            :  *
    2001                 :            :  *      Open-counting is needed for pty masters, as well as for keeping
    2002                 :            :  *      track of serial lines: DTR is dropped when the last close happens.
    2003                 :            :  *      (This is not done solely through tty->count, now.  - Ted 1/27/92)
    2004                 :            :  *
    2005                 :            :  *      The termios state of a pty is reset on first open so that
    2006                 :            :  *      settings don't persist across reuse.
    2007                 :            :  *
    2008                 :            :  *      Locking: tty_mutex protects tty, tty_lookup_driver and tty_init_dev.
    2009                 :            :  *               tty->count should protect the rest.
    2010                 :            :  *               ->siglock protects ->signal/->sighand
    2011                 :            :  *
    2012                 :            :  *      Note: the tty_unlock/lock cases without a ref are only safe due to
    2013                 :            :  *      tty_mutex
    2014                 :            :  */
    2015                 :            : 
    2016                 :          3 : static int tty_open(struct inode *inode, struct file *filp)
    2017                 :            : {
    2018                 :            :         struct tty_struct *tty;
    2019                 :            :         int noctty, retval;
    2020                 :          3 :         dev_t device = inode->i_rdev;
    2021                 :          3 :         unsigned saved_flags = filp->f_flags;
    2022                 :            : 
    2023                 :          3 :         nonseekable_open(inode, filp);
    2024                 :            : 
    2025                 :            : retry_open:
    2026                 :          3 :         retval = tty_alloc_file(filp);
    2027                 :          3 :         if (retval)
    2028                 :            :                 return -ENOMEM;
    2029                 :            : 
    2030                 :          3 :         tty = tty_open_current_tty(device, filp);
    2031                 :          3 :         if (!tty)
    2032                 :          3 :                 tty = tty_open_by_driver(device, inode, filp);
    2033                 :            : 
    2034                 :          3 :         if (IS_ERR(tty)) {
    2035                 :            :                 tty_free_file(filp);
    2036                 :            :                 retval = PTR_ERR(tty);
    2037                 :          3 :                 if (retval != -EAGAIN || signal_pending(current))
    2038                 :          3 :                         return retval;
    2039                 :          3 :                 schedule();
    2040                 :          3 :                 goto retry_open;
    2041                 :            :         }
    2042                 :            : 
    2043                 :          3 :         tty_add_file(tty, filp);
    2044                 :            : 
    2045                 :          3 :         check_tty_count(tty, __func__);
    2046                 :            :         tty_debug_hangup(tty, "opening (count=%d)\n", tty->count);
    2047                 :            : 
    2048                 :          3 :         if (tty->ops->open)
    2049                 :          3 :                 retval = tty->ops->open(tty, filp);
    2050                 :            :         else
    2051                 :            :                 retval = -ENODEV;
    2052                 :          3 :         filp->f_flags = saved_flags;
    2053                 :            : 
    2054                 :          3 :         if (retval) {
    2055                 :            :                 tty_debug_hangup(tty, "open error %d, releasing\n", retval);
    2056                 :            : 
    2057                 :          0 :                 tty_unlock(tty); /* need to call tty_release without BTM */
    2058                 :          0 :                 tty_release(inode, filp);
    2059                 :          0 :                 if (retval != -ERESTARTSYS)
    2060                 :          0 :                         return retval;
    2061                 :            : 
    2062                 :          0 :                 if (signal_pending(current))
    2063                 :          0 :                         return retval;
    2064                 :            : 
    2065                 :          0 :                 schedule();
    2066                 :            :                 /*
    2067                 :            :                  * Need to reset f_op in case a hangup happened.
    2068                 :            :                  */
    2069                 :          0 :                 if (tty_hung_up_p(filp))
    2070                 :          0 :                         filp->f_op = &tty_fops;
    2071                 :            :                 goto retry_open;
    2072                 :            :         }
    2073                 :          3 :         clear_bit(TTY_HUPPED, &tty->flags);
    2074                 :            : 
    2075                 :          3 :         noctty = (filp->f_flags & O_NOCTTY) ||
    2076                 :          3 :                  (IS_ENABLED(CONFIG_VT) && device == MKDEV(TTY_MAJOR, 0)) ||
    2077                 :          3 :                  device == MKDEV(TTYAUX_MAJOR, 1) ||
    2078                 :          3 :                  (tty->driver->type == TTY_DRIVER_TYPE_PTY &&
    2079                 :            :                   tty->driver->subtype == PTY_TYPE_MASTER);
    2080                 :          3 :         if (!noctty)
    2081                 :          3 :                 tty_open_proc_set_tty(filp, tty);
    2082                 :          3 :         tty_unlock(tty);
    2083                 :          3 :         return 0;
    2084                 :            : }
    2085                 :            : 
    2086                 :            : 
    2087                 :            : 
    2088                 :            : /**
    2089                 :            :  *      tty_poll        -       check tty status
    2090                 :            :  *      @filp: file being polled
    2091                 :            :  *      @wait: poll wait structures to update
    2092                 :            :  *
    2093                 :            :  *      Call the line discipline polling method to obtain the poll
    2094                 :            :  *      status of the device.
    2095                 :            :  *
    2096                 :            :  *      Locking: locks called line discipline but ldisc poll method
    2097                 :            :  *      may be re-entered freely by other callers.
    2098                 :            :  */
    2099                 :            : 
    2100                 :          3 : static __poll_t tty_poll(struct file *filp, poll_table *wait)
    2101                 :            : {
    2102                 :            :         struct tty_struct *tty = file_tty(filp);
    2103                 :            :         struct tty_ldisc *ld;
    2104                 :            :         __poll_t ret = 0;
    2105                 :            : 
    2106                 :          3 :         if (tty_paranoia_check(tty, file_inode(filp), "tty_poll"))
    2107                 :            :                 return 0;
    2108                 :            : 
    2109                 :          3 :         ld = tty_ldisc_ref_wait(tty);
    2110                 :          3 :         if (!ld)
    2111                 :            :                 return hung_up_tty_poll(filp, wait);
    2112                 :          3 :         if (ld->ops->poll)
    2113                 :          3 :                 ret = ld->ops->poll(tty, filp, wait);
    2114                 :          3 :         tty_ldisc_deref(ld);
    2115                 :          3 :         return ret;
    2116                 :            : }
    2117                 :            : 
    2118                 :          3 : static int __tty_fasync(int fd, struct file *filp, int on)
    2119                 :            : {
    2120                 :            :         struct tty_struct *tty = file_tty(filp);
    2121                 :            :         unsigned long flags;
    2122                 :            :         int retval = 0;
    2123                 :            : 
    2124                 :          3 :         if (tty_paranoia_check(tty, file_inode(filp), "tty_fasync"))
    2125                 :            :                 goto out;
    2126                 :            : 
    2127                 :          3 :         retval = fasync_helper(fd, filp, on, &tty->fasync);
    2128                 :          3 :         if (retval <= 0)
    2129                 :            :                 goto out;
    2130                 :            : 
    2131                 :          0 :         if (on) {
    2132                 :            :                 enum pid_type type;
    2133                 :            :                 struct pid *pid;
    2134                 :            : 
    2135                 :          0 :                 spin_lock_irqsave(&tty->ctrl_lock, flags);
    2136                 :          0 :                 if (tty->pgrp) {
    2137                 :            :                         pid = tty->pgrp;
    2138                 :            :                         type = PIDTYPE_PGID;
    2139                 :            :                 } else {
    2140                 :          0 :                         pid = task_pid(current);
    2141                 :            :                         type = PIDTYPE_TGID;
    2142                 :            :                 }
    2143                 :            :                 get_pid(pid);
    2144                 :            :                 spin_unlock_irqrestore(&tty->ctrl_lock, flags);
    2145                 :          0 :                 __f_setown(filp, pid, type, 0);
    2146                 :          0 :                 put_pid(pid);
    2147                 :            :                 retval = 0;
    2148                 :            :         }
    2149                 :            : out:
    2150                 :          3 :         return retval;
    2151                 :            : }
    2152                 :            : 
    2153                 :          0 : static int tty_fasync(int fd, struct file *filp, int on)
    2154                 :            : {
    2155                 :            :         struct tty_struct *tty = file_tty(filp);
    2156                 :            :         int retval = -ENOTTY;
    2157                 :            : 
    2158                 :          0 :         tty_lock(tty);
    2159                 :          0 :         if (!tty_hung_up_p(filp))
    2160                 :          0 :                 retval = __tty_fasync(fd, filp, on);
    2161                 :          0 :         tty_unlock(tty);
    2162                 :            : 
    2163                 :          0 :         return retval;
    2164                 :            : }
    2165                 :            : 
    2166                 :            : /**
    2167                 :            :  *      tiocsti                 -       fake input character
    2168                 :            :  *      @tty: tty to fake input into
    2169                 :            :  *      @p: pointer to character
    2170                 :            :  *
    2171                 :            :  *      Fake input to a tty device. Does the necessary locking and
    2172                 :            :  *      input management.
    2173                 :            :  *
    2174                 :            :  *      FIXME: does not honour flow control ??
    2175                 :            :  *
    2176                 :            :  *      Locking:
    2177                 :            :  *              Called functions take tty_ldiscs_lock
    2178                 :            :  *              current->signal->tty check is safe without locks
    2179                 :            :  *
    2180                 :            :  *      FIXME: may race normal receive processing
    2181                 :            :  */
    2182                 :            : 
    2183                 :          0 : static int tiocsti(struct tty_struct *tty, char __user *p)
    2184                 :            : {
    2185                 :          0 :         char ch, mbz = 0;
    2186                 :            :         struct tty_ldisc *ld;
    2187                 :            : 
    2188                 :          0 :         if ((current->signal->tty != tty) && !capable(CAP_SYS_ADMIN))
    2189                 :            :                 return -EPERM;
    2190                 :          0 :         if (get_user(ch, p))
    2191                 :            :                 return -EFAULT;
    2192                 :          0 :         tty_audit_tiocsti(tty, ch);
    2193                 :          0 :         ld = tty_ldisc_ref_wait(tty);
    2194                 :          0 :         if (!ld)
    2195                 :            :                 return -EIO;
    2196                 :          0 :         if (ld->ops->receive_buf)
    2197                 :          0 :                 ld->ops->receive_buf(tty, &ch, &mbz, 1);
    2198                 :          0 :         tty_ldisc_deref(ld);
    2199                 :          0 :         return 0;
    2200                 :            : }
    2201                 :            : 
    2202                 :            : /**
    2203                 :            :  *      tiocgwinsz              -       implement window query ioctl
    2204                 :            :  *      @tty; tty
    2205                 :            :  *      @arg: user buffer for result
    2206                 :            :  *
    2207                 :            :  *      Copies the kernel idea of the window size into the user buffer.
    2208                 :            :  *
    2209                 :            :  *      Locking: tty->winsize_mutex is taken to ensure the winsize data
    2210                 :            :  *              is consistent.
    2211                 :            :  */
    2212                 :            : 
    2213                 :          3 : static int tiocgwinsz(struct tty_struct *tty, struct winsize __user *arg)
    2214                 :            : {
    2215                 :            :         int err;
    2216                 :            : 
    2217                 :          3 :         mutex_lock(&tty->winsize_mutex);
    2218                 :          3 :         err = copy_to_user(arg, &tty->winsize, sizeof(*arg));
    2219                 :          3 :         mutex_unlock(&tty->winsize_mutex);
    2220                 :            : 
    2221                 :          3 :         return err ? -EFAULT: 0;
    2222                 :            : }
    2223                 :            : 
    2224                 :            : /**
    2225                 :            :  *      tty_do_resize           -       resize event
    2226                 :            :  *      @tty: tty being resized
    2227                 :            :  *      @rows: rows (character)
    2228                 :            :  *      @cols: cols (character)
    2229                 :            :  *
    2230                 :            :  *      Update the termios variables and send the necessary signals to
    2231                 :            :  *      peform a terminal resize correctly
    2232                 :            :  */
    2233                 :            : 
    2234                 :          3 : int tty_do_resize(struct tty_struct *tty, struct winsize *ws)
    2235                 :            : {
    2236                 :            :         struct pid *pgrp;
    2237                 :            : 
    2238                 :            :         /* Lock the tty */
    2239                 :          3 :         mutex_lock(&tty->winsize_mutex);
    2240                 :          3 :         if (!memcmp(ws, &tty->winsize, sizeof(*ws)))
    2241                 :            :                 goto done;
    2242                 :            : 
    2243                 :            :         /* Signal the foreground process group */
    2244                 :          3 :         pgrp = tty_get_pgrp(tty);
    2245                 :          3 :         if (pgrp)
    2246                 :          3 :                 kill_pgrp(pgrp, SIGWINCH, 1);
    2247                 :          3 :         put_pid(pgrp);
    2248                 :            : 
    2249                 :          3 :         tty->winsize = *ws;
    2250                 :            : done:
    2251                 :          3 :         mutex_unlock(&tty->winsize_mutex);
    2252                 :          3 :         return 0;
    2253                 :            : }
    2254                 :            : EXPORT_SYMBOL(tty_do_resize);
    2255                 :            : 
    2256                 :            : /**
    2257                 :            :  *      tiocswinsz              -       implement window size set ioctl
    2258                 :            :  *      @tty; tty side of tty
    2259                 :            :  *      @arg: user buffer for result
    2260                 :            :  *
    2261                 :            :  *      Copies the user idea of the window size to the kernel. Traditionally
    2262                 :            :  *      this is just advisory information but for the Linux console it
    2263                 :            :  *      actually has driver level meaning and triggers a VC resize.
    2264                 :            :  *
    2265                 :            :  *      Locking:
    2266                 :            :  *              Driver dependent. The default do_resize method takes the
    2267                 :            :  *      tty termios mutex and ctrl_lock. The console takes its own lock
    2268                 :            :  *      then calls into the default method.
    2269                 :            :  */
    2270                 :            : 
    2271                 :          3 : static int tiocswinsz(struct tty_struct *tty, struct winsize __user *arg)
    2272                 :            : {
    2273                 :            :         struct winsize tmp_ws;
    2274                 :          3 :         if (copy_from_user(&tmp_ws, arg, sizeof(*arg)))
    2275                 :            :                 return -EFAULT;
    2276                 :            : 
    2277                 :          3 :         if (tty->ops->resize)
    2278                 :          3 :                 return tty->ops->resize(tty, &tmp_ws);
    2279                 :            :         else
    2280                 :          3 :                 return tty_do_resize(tty, &tmp_ws);
    2281                 :            : }
    2282                 :            : 
    2283                 :            : /**
    2284                 :            :  *      tioccons        -       allow admin to move logical console
    2285                 :            :  *      @file: the file to become console
    2286                 :            :  *
    2287                 :            :  *      Allow the administrator to move the redirected console device
    2288                 :            :  *
    2289                 :            :  *      Locking: uses redirect_lock to guard the redirect information
    2290                 :            :  */
    2291                 :            : 
    2292                 :          3 : static int tioccons(struct file *file)
    2293                 :            : {
    2294                 :          3 :         if (!capable(CAP_SYS_ADMIN))
    2295                 :            :                 return -EPERM;
    2296                 :          3 :         if (file->f_op->write == redirected_tty_write) {
    2297                 :            :                 struct file *f;
    2298                 :            :                 spin_lock(&redirect_lock);
    2299                 :          3 :                 f = redirect;
    2300                 :          3 :                 redirect = NULL;
    2301                 :            :                 spin_unlock(&redirect_lock);
    2302                 :          3 :                 if (f)
    2303                 :          3 :                         fput(f);
    2304                 :            :                 return 0;
    2305                 :            :         }
    2306                 :            :         spin_lock(&redirect_lock);
    2307                 :          3 :         if (redirect) {
    2308                 :            :                 spin_unlock(&redirect_lock);
    2309                 :          0 :                 return -EBUSY;
    2310                 :            :         }
    2311                 :          3 :         redirect = get_file(file);
    2312                 :            :         spin_unlock(&redirect_lock);
    2313                 :          3 :         return 0;
    2314                 :            : }
    2315                 :            : 
    2316                 :            : /**
    2317                 :            :  *      tiocsetd        -       set line discipline
    2318                 :            :  *      @tty: tty device
    2319                 :            :  *      @p: pointer to user data
    2320                 :            :  *
    2321                 :            :  *      Set the line discipline according to user request.
    2322                 :            :  *
    2323                 :            :  *      Locking: see tty_set_ldisc, this function is just a helper
    2324                 :            :  */
    2325                 :            : 
    2326                 :          0 : static int tiocsetd(struct tty_struct *tty, int __user *p)
    2327                 :            : {
    2328                 :            :         int disc;
    2329                 :            :         int ret;
    2330                 :            : 
    2331                 :          0 :         if (get_user(disc, p))
    2332                 :            :                 return -EFAULT;
    2333                 :            : 
    2334                 :          0 :         ret = tty_set_ldisc(tty, disc);
    2335                 :            : 
    2336                 :          0 :         return ret;
    2337                 :            : }
    2338                 :            : 
    2339                 :            : /**
    2340                 :            :  *      tiocgetd        -       get line discipline
    2341                 :            :  *      @tty: tty device
    2342                 :            :  *      @p: pointer to user data
    2343                 :            :  *
    2344                 :            :  *      Retrieves the line discipline id directly from the ldisc.
    2345                 :            :  *
    2346                 :            :  *      Locking: waits for ldisc reference (in case the line discipline
    2347                 :            :  *              is changing or the tty is being hungup)
    2348                 :            :  */
    2349                 :            : 
    2350                 :          0 : static int tiocgetd(struct tty_struct *tty, int __user *p)
    2351                 :            : {
    2352                 :            :         struct tty_ldisc *ld;
    2353                 :            :         int ret;
    2354                 :            : 
    2355                 :          0 :         ld = tty_ldisc_ref_wait(tty);
    2356                 :          0 :         if (!ld)
    2357                 :            :                 return -EIO;
    2358                 :          0 :         ret = put_user(ld->ops->num, p);
    2359                 :          0 :         tty_ldisc_deref(ld);
    2360                 :          0 :         return ret;
    2361                 :            : }
    2362                 :            : 
    2363                 :            : /**
    2364                 :            :  *      send_break      -       performed time break
    2365                 :            :  *      @tty: device to break on
    2366                 :            :  *      @duration: timeout in mS
    2367                 :            :  *
    2368                 :            :  *      Perform a timed break on hardware that lacks its own driver level
    2369                 :            :  *      timed break functionality.
    2370                 :            :  *
    2371                 :            :  *      Locking:
    2372                 :            :  *              atomic_write_lock serializes
    2373                 :            :  *
    2374                 :            :  */
    2375                 :            : 
    2376                 :          0 : static int send_break(struct tty_struct *tty, unsigned int duration)
    2377                 :            : {
    2378                 :            :         int retval;
    2379                 :            : 
    2380                 :          0 :         if (tty->ops->break_ctl == NULL)
    2381                 :            :                 return 0;
    2382                 :            : 
    2383                 :          0 :         if (tty->driver->flags & TTY_DRIVER_HARDWARE_BREAK)
    2384                 :          0 :                 retval = tty->ops->break_ctl(tty, duration);
    2385                 :            :         else {
    2386                 :            :                 /* Do the work ourselves */
    2387                 :          0 :                 if (tty_write_lock(tty, 0) < 0)
    2388                 :            :                         return -EINTR;
    2389                 :          0 :                 retval = tty->ops->break_ctl(tty, -1);
    2390                 :          0 :                 if (retval)
    2391                 :            :                         goto out;
    2392                 :          0 :                 if (!signal_pending(current))
    2393                 :          0 :                         msleep_interruptible(duration);
    2394                 :          0 :                 retval = tty->ops->break_ctl(tty, 0);
    2395                 :            : out:
    2396                 :          0 :                 tty_write_unlock(tty);
    2397                 :          0 :                 if (signal_pending(current))
    2398                 :            :                         retval = -EINTR;
    2399                 :            :         }
    2400                 :          0 :         return retval;
    2401                 :            : }
    2402                 :            : 
    2403                 :            : /**
    2404                 :            :  *      tty_tiocmget            -       get modem status
    2405                 :            :  *      @tty: tty device
    2406                 :            :  *      @file: user file pointer
    2407                 :            :  *      @p: pointer to result
    2408                 :            :  *
    2409                 :            :  *      Obtain the modem status bits from the tty driver if the feature
    2410                 :            :  *      is supported. Return -EINVAL if it is not available.
    2411                 :            :  *
    2412                 :            :  *      Locking: none (up to the driver)
    2413                 :            :  */
    2414                 :            : 
    2415                 :          0 : static int tty_tiocmget(struct tty_struct *tty, int __user *p)
    2416                 :            : {
    2417                 :            :         int retval = -EINVAL;
    2418                 :            : 
    2419                 :          0 :         if (tty->ops->tiocmget) {
    2420                 :          0 :                 retval = tty->ops->tiocmget(tty);
    2421                 :            : 
    2422                 :          0 :                 if (retval >= 0)
    2423                 :          0 :                         retval = put_user(retval, p);
    2424                 :            :         }
    2425                 :          0 :         return retval;
    2426                 :            : }
    2427                 :            : 
    2428                 :            : /**
    2429                 :            :  *      tty_tiocmset            -       set modem status
    2430                 :            :  *      @tty: tty device
    2431                 :            :  *      @cmd: command - clear bits, set bits or set all
    2432                 :            :  *      @p: pointer to desired bits
    2433                 :            :  *
    2434                 :            :  *      Set the modem status bits from the tty driver if the feature
    2435                 :            :  *      is supported. Return -EINVAL if it is not available.
    2436                 :            :  *
    2437                 :            :  *      Locking: none (up to the driver)
    2438                 :            :  */
    2439                 :            : 
    2440                 :          0 : static int tty_tiocmset(struct tty_struct *tty, unsigned int cmd,
    2441                 :            :              unsigned __user *p)
    2442                 :            : {
    2443                 :            :         int retval;
    2444                 :            :         unsigned int set, clear, val;
    2445                 :            : 
    2446                 :          0 :         if (tty->ops->tiocmset == NULL)
    2447                 :            :                 return -EINVAL;
    2448                 :            : 
    2449                 :          0 :         retval = get_user(val, p);
    2450                 :          0 :         if (retval)
    2451                 :            :                 return retval;
    2452                 :            :         set = clear = 0;
    2453                 :          0 :         switch (cmd) {
    2454                 :            :         case TIOCMBIS:
    2455                 :            :                 set = val;
    2456                 :          0 :                 break;
    2457                 :            :         case TIOCMBIC:
    2458                 :            :                 clear = val;
    2459                 :          0 :                 break;
    2460                 :            :         case TIOCMSET:
    2461                 :            :                 set = val;
    2462                 :          0 :                 clear = ~val;
    2463                 :          0 :                 break;
    2464                 :            :         }
    2465                 :          0 :         set &= TIOCM_DTR|TIOCM_RTS|TIOCM_OUT1|TIOCM_OUT2|TIOCM_LOOP;
    2466                 :          0 :         clear &= TIOCM_DTR|TIOCM_RTS|TIOCM_OUT1|TIOCM_OUT2|TIOCM_LOOP;
    2467                 :          0 :         return tty->ops->tiocmset(tty, set, clear);
    2468                 :            : }
    2469                 :            : 
    2470                 :          0 : static int tty_tiocgicount(struct tty_struct *tty, void __user *arg)
    2471                 :            : {
    2472                 :            :         int retval = -EINVAL;
    2473                 :            :         struct serial_icounter_struct icount;
    2474                 :          0 :         memset(&icount, 0, sizeof(icount));
    2475                 :          0 :         if (tty->ops->get_icount)
    2476                 :          0 :                 retval = tty->ops->get_icount(tty, &icount);
    2477                 :          0 :         if (retval != 0)
    2478                 :            :                 return retval;
    2479                 :          0 :         if (copy_to_user(arg, &icount, sizeof(icount)))
    2480                 :            :                 return -EFAULT;
    2481                 :          0 :         return 0;
    2482                 :            : }
    2483                 :            : 
    2484                 :          0 : static int tty_tiocsserial(struct tty_struct *tty, struct serial_struct __user *ss)
    2485                 :            : {
    2486                 :            :         static DEFINE_RATELIMIT_STATE(depr_flags,
    2487                 :            :                         DEFAULT_RATELIMIT_INTERVAL,
    2488                 :            :                         DEFAULT_RATELIMIT_BURST);
    2489                 :            :         char comm[TASK_COMM_LEN];
    2490                 :            :         struct serial_struct v;
    2491                 :            :         int flags;
    2492                 :            : 
    2493                 :          0 :         if (copy_from_user(&v, ss, sizeof(struct serial_struct)))
    2494                 :            :                 return -EFAULT;
    2495                 :            : 
    2496                 :          0 :         flags = v.flags & ASYNC_DEPRECATED;
    2497                 :            : 
    2498                 :          0 :         if (flags && __ratelimit(&depr_flags))
    2499                 :          0 :                 pr_warn("%s: '%s' is using deprecated serial flags (with no effect): %.8x\n",
    2500                 :            :                         __func__, get_task_comm(comm, current), flags);
    2501                 :          0 :         if (!tty->ops->set_serial)
    2502                 :            :                 return -ENOTTY;
    2503                 :          0 :         return tty->ops->set_serial(tty, &v);
    2504                 :            : }
    2505                 :            : 
    2506                 :          0 : static int tty_tiocgserial(struct tty_struct *tty, struct serial_struct __user *ss)
    2507                 :            : {
    2508                 :            :         struct serial_struct v;
    2509                 :            :         int err;
    2510                 :            : 
    2511                 :          0 :         memset(&v, 0, sizeof(struct serial_struct));
    2512                 :          0 :         if (!tty->ops->get_serial)
    2513                 :            :                 return -ENOTTY;
    2514                 :          0 :         err = tty->ops->get_serial(tty, &v);
    2515                 :          0 :         if (!err && copy_to_user(ss, &v, sizeof(struct serial_struct)))
    2516                 :            :                 err = -EFAULT;
    2517                 :          0 :         return err;
    2518                 :            : }
    2519                 :            : 
    2520                 :            : /*
    2521                 :            :  * if pty, return the slave side (real_tty)
    2522                 :            :  * otherwise, return self
    2523                 :            :  */
    2524                 :            : static struct tty_struct *tty_pair_get_tty(struct tty_struct *tty)
    2525                 :            : {
    2526                 :          3 :         if (tty->driver->type == TTY_DRIVER_TYPE_PTY &&
    2527                 :            :             tty->driver->subtype == PTY_TYPE_MASTER)
    2528                 :          3 :                 tty = tty->link;
    2529                 :            :         return tty;
    2530                 :            : }
    2531                 :            : 
    2532                 :            : /*
    2533                 :            :  * Split this up, as gcc can choke on it otherwise..
    2534                 :            :  */
    2535                 :          3 : long tty_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
    2536                 :            : {
    2537                 :            :         struct tty_struct *tty = file_tty(file);
    2538                 :            :         struct tty_struct *real_tty;
    2539                 :          3 :         void __user *p = (void __user *)arg;
    2540                 :            :         int retval;
    2541                 :            :         struct tty_ldisc *ld;
    2542                 :            : 
    2543                 :          3 :         if (tty_paranoia_check(tty, file_inode(file), "tty_ioctl"))
    2544                 :            :                 return -EINVAL;
    2545                 :            : 
    2546                 :            :         real_tty = tty_pair_get_tty(tty);
    2547                 :            : 
    2548                 :            :         /*
    2549                 :            :          * Factor out some common prep work
    2550                 :            :          */
    2551                 :          3 :         switch (cmd) {
    2552                 :            :         case TIOCSETD:
    2553                 :            :         case TIOCSBRK:
    2554                 :            :         case TIOCCBRK:
    2555                 :            :         case TCSBRK:
    2556                 :            :         case TCSBRKP:
    2557                 :          0 :                 retval = tty_check_change(tty);
    2558                 :          0 :                 if (retval)
    2559                 :            :                         return retval;
    2560                 :          0 :                 if (cmd != TIOCCBRK) {
    2561                 :          0 :                         tty_wait_until_sent(tty, 0);
    2562                 :          0 :                         if (signal_pending(current))
    2563                 :            :                                 return -EINTR;
    2564                 :            :                 }
    2565                 :            :                 break;
    2566                 :            :         }
    2567                 :            : 
    2568                 :            :         /*
    2569                 :            :          *      Now do the stuff.
    2570                 :            :          */
    2571                 :          3 :         switch (cmd) {
    2572                 :            :         case TIOCSTI:
    2573                 :          0 :                 return tiocsti(tty, p);
    2574                 :            :         case TIOCGWINSZ:
    2575                 :          3 :                 return tiocgwinsz(real_tty, p);
    2576                 :            :         case TIOCSWINSZ:
    2577                 :          3 :                 return tiocswinsz(real_tty, p);
    2578                 :            :         case TIOCCONS:
    2579                 :          3 :                 return real_tty != tty ? -EINVAL : tioccons(file);
    2580                 :            :         case TIOCEXCL:
    2581                 :          0 :                 set_bit(TTY_EXCLUSIVE, &tty->flags);
    2582                 :          0 :                 return 0;
    2583                 :            :         case TIOCNXCL:
    2584                 :          3 :                 clear_bit(TTY_EXCLUSIVE, &tty->flags);
    2585                 :          3 :                 return 0;
    2586                 :            :         case TIOCGEXCL:
    2587                 :            :         {
    2588                 :            :                 int excl = test_bit(TTY_EXCLUSIVE, &tty->flags);
    2589                 :          0 :                 return put_user(excl, (int __user *)p);
    2590                 :            :         }
    2591                 :            :         case TIOCGETD:
    2592                 :          0 :                 return tiocgetd(tty, p);
    2593                 :            :         case TIOCSETD:
    2594                 :          0 :                 return tiocsetd(tty, p);
    2595                 :            :         case TIOCVHANGUP:
    2596                 :          3 :                 if (!capable(CAP_SYS_ADMIN))
    2597                 :            :                         return -EPERM;
    2598                 :            :                 tty_vhangup(tty);
    2599                 :          3 :                 return 0;
    2600                 :            :         case TIOCGDEV:
    2601                 :            :         {
    2602                 :            :                 unsigned int ret = new_encode_dev(tty_devnum(real_tty));
    2603                 :          0 :                 return put_user(ret, (unsigned int __user *)p);
    2604                 :            :         }
    2605                 :            :         /*
    2606                 :            :          * Break handling
    2607                 :            :          */
    2608                 :            :         case TIOCSBRK:  /* Turn break on, unconditionally */
    2609                 :          0 :                 if (tty->ops->break_ctl)
    2610                 :          0 :                         return tty->ops->break_ctl(tty, -1);
    2611                 :            :                 return 0;
    2612                 :            :         case TIOCCBRK:  /* Turn break off, unconditionally */
    2613                 :          0 :                 if (tty->ops->break_ctl)
    2614                 :          0 :                         return tty->ops->break_ctl(tty, 0);
    2615                 :            :                 return 0;
    2616                 :            :         case TCSBRK:   /* SVID version: non-zero arg --> no break */
    2617                 :            :                 /* non-zero arg means wait for all output data
    2618                 :            :                  * to be sent (performed above) but don't send break.
    2619                 :            :                  * This is used by the tcdrain() termios function.
    2620                 :            :                  */
    2621                 :          0 :                 if (!arg)
    2622                 :          0 :                         return send_break(tty, 250);
    2623                 :            :                 return 0;
    2624                 :            :         case TCSBRKP:   /* support for POSIX tcsendbreak() */
    2625                 :          0 :                 return send_break(tty, arg ? arg*100 : 250);
    2626                 :            : 
    2627                 :            :         case TIOCMGET:
    2628                 :          0 :                 return tty_tiocmget(tty, p);
    2629                 :            :         case TIOCMSET:
    2630                 :            :         case TIOCMBIC:
    2631                 :            :         case TIOCMBIS:
    2632                 :          0 :                 return tty_tiocmset(tty, cmd, p);
    2633                 :            :         case TIOCGICOUNT:
    2634                 :          0 :                 return tty_tiocgicount(tty, p);
    2635                 :            :         case TCFLSH:
    2636                 :          3 :                 switch (arg) {
    2637                 :            :                 case TCIFLUSH:
    2638                 :            :                 case TCIOFLUSH:
    2639                 :            :                 /* flush tty buffer and allow ldisc to process ioctl */
    2640                 :          3 :                         tty_buffer_flush(tty, NULL);
    2641                 :          3 :                         break;
    2642                 :            :                 }
    2643                 :            :                 break;
    2644                 :            :         case TIOCSSERIAL:
    2645                 :          0 :                 return tty_tiocsserial(tty, p);
    2646                 :            :         case TIOCGSERIAL:
    2647                 :          0 :                 return tty_tiocgserial(tty, p);
    2648                 :            :         case TIOCGPTPEER:
    2649                 :            :                 /* Special because the struct file is needed */
    2650                 :          0 :                 return ptm_open_peer(file, tty, (int)arg);
    2651                 :            :         default:
    2652                 :          3 :                 retval = tty_jobctrl_ioctl(tty, real_tty, file, cmd, arg);
    2653                 :          3 :                 if (retval != -ENOIOCTLCMD)
    2654                 :            :                         return retval;
    2655                 :            :         }
    2656                 :          3 :         if (tty->ops->ioctl) {
    2657                 :          3 :                 retval = tty->ops->ioctl(tty, cmd, arg);
    2658                 :          3 :                 if (retval != -ENOIOCTLCMD)
    2659                 :            :                         return retval;
    2660                 :            :         }
    2661                 :          3 :         ld = tty_ldisc_ref_wait(tty);
    2662                 :          3 :         if (!ld)
    2663                 :          0 :                 return hung_up_tty_ioctl(file, cmd, arg);
    2664                 :            :         retval = -EINVAL;
    2665                 :          3 :         if (ld->ops->ioctl) {
    2666                 :          3 :                 retval = ld->ops->ioctl(tty, file, cmd, arg);
    2667                 :          3 :                 if (retval == -ENOIOCTLCMD)
    2668                 :            :                         retval = -ENOTTY;
    2669                 :            :         }
    2670                 :          3 :         tty_ldisc_deref(ld);
    2671                 :          3 :         return retval;
    2672                 :            : }
    2673                 :            : 
    2674                 :            : #ifdef CONFIG_COMPAT
    2675                 :            : 
    2676                 :            : struct serial_struct32 {
    2677                 :            :         compat_int_t    type;
    2678                 :            :         compat_int_t    line;
    2679                 :            :         compat_uint_t   port;
    2680                 :            :         compat_int_t    irq;
    2681                 :            :         compat_int_t    flags;
    2682                 :            :         compat_int_t    xmit_fifo_size;
    2683                 :            :         compat_int_t    custom_divisor;
    2684                 :            :         compat_int_t    baud_base;
    2685                 :            :         unsigned short  close_delay;
    2686                 :            :         char    io_type;
    2687                 :            :         char    reserved_char[1];
    2688                 :            :         compat_int_t    hub6;
    2689                 :            :         unsigned short  closing_wait; /* time to wait before closing */
    2690                 :            :         unsigned short  closing_wait2; /* no longer used... */
    2691                 :            :         compat_uint_t   iomem_base;
    2692                 :            :         unsigned short  iomem_reg_shift;
    2693                 :            :         unsigned int    port_high;
    2694                 :            :      /* compat_ulong_t  iomap_base FIXME */
    2695                 :            :         compat_int_t    reserved[1];
    2696                 :            : };
    2697                 :            : 
    2698                 :            : static int compat_tty_tiocsserial(struct tty_struct *tty,
    2699                 :            :                 struct serial_struct32 __user *ss)
    2700                 :            : {
    2701                 :            :         static DEFINE_RATELIMIT_STATE(depr_flags,
    2702                 :            :                         DEFAULT_RATELIMIT_INTERVAL,
    2703                 :            :                         DEFAULT_RATELIMIT_BURST);
    2704                 :            :         char comm[TASK_COMM_LEN];
    2705                 :            :         struct serial_struct32 v32;
    2706                 :            :         struct serial_struct v;
    2707                 :            :         int flags;
    2708                 :            : 
    2709                 :            :         if (copy_from_user(&v32, ss, sizeof(struct serial_struct32)))
    2710                 :            :                 return -EFAULT;
    2711                 :            : 
    2712                 :            :         memcpy(&v, &v32, offsetof(struct serial_struct32, iomem_base));
    2713                 :            :         v.iomem_base = compat_ptr(v32.iomem_base);
    2714                 :            :         v.iomem_reg_shift = v32.iomem_reg_shift;
    2715                 :            :         v.port_high = v32.port_high;
    2716                 :            :         v.iomap_base = 0;
    2717                 :            : 
    2718                 :            :         flags = v.flags & ASYNC_DEPRECATED;
    2719                 :            : 
    2720                 :            :         if (flags && __ratelimit(&depr_flags))
    2721                 :            :                 pr_warn("%s: '%s' is using deprecated serial flags (with no effect): %.8x\n",
    2722                 :            :                         __func__, get_task_comm(comm, current), flags);
    2723                 :            :         if (!tty->ops->set_serial)
    2724                 :            :                 return -ENOTTY;
    2725                 :            :         return tty->ops->set_serial(tty, &v);
    2726                 :            : }
    2727                 :            : 
    2728                 :            : static int compat_tty_tiocgserial(struct tty_struct *tty,
    2729                 :            :                         struct serial_struct32 __user *ss)
    2730                 :            : {
    2731                 :            :         struct serial_struct32 v32;
    2732                 :            :         struct serial_struct v;
    2733                 :            :         int err;
    2734                 :            : 
    2735                 :            :         memset(&v, 0, sizeof(v));
    2736                 :            :         memset(&v32, 0, sizeof(v32));
    2737                 :            : 
    2738                 :            :         if (!tty->ops->get_serial)
    2739                 :            :                 return -ENOTTY;
    2740                 :            :         err = tty->ops->get_serial(tty, &v);
    2741                 :            :         if (!err) {
    2742                 :            :                 memcpy(&v32, &v, offsetof(struct serial_struct32, iomem_base));
    2743                 :            :                 v32.iomem_base = (unsigned long)v.iomem_base >> 32 ?
    2744                 :            :                         0xfffffff : ptr_to_compat(v.iomem_base);
    2745                 :            :                 v32.iomem_reg_shift = v.iomem_reg_shift;
    2746                 :            :                 v32.port_high = v.port_high;
    2747                 :            :                 if (copy_to_user(ss, &v32, sizeof(struct serial_struct32)))
    2748                 :            :                         err = -EFAULT;
    2749                 :            :         }
    2750                 :            :         return err;
    2751                 :            : }
    2752                 :            : static long tty_compat_ioctl(struct file *file, unsigned int cmd,
    2753                 :            :                                 unsigned long arg)
    2754                 :            : {
    2755                 :            :         struct tty_struct *tty = file_tty(file);
    2756                 :            :         struct tty_ldisc *ld;
    2757                 :            :         int retval = -ENOIOCTLCMD;
    2758                 :            : 
    2759                 :            :         switch (cmd) {
    2760                 :            :         case TIOCSTI:
    2761                 :            :         case TIOCGWINSZ:
    2762                 :            :         case TIOCSWINSZ:
    2763                 :            :         case TIOCGEXCL:
    2764                 :            :         case TIOCGETD:
    2765                 :            :         case TIOCSETD:
    2766                 :            :         case TIOCGDEV:
    2767                 :            :         case TIOCMGET:
    2768                 :            :         case TIOCMSET:
    2769                 :            :         case TIOCMBIC:
    2770                 :            :         case TIOCMBIS:
    2771                 :            :         case TIOCGICOUNT:
    2772                 :            :         case TIOCGPGRP:
    2773                 :            :         case TIOCSPGRP:
    2774                 :            :         case TIOCGSID:
    2775                 :            :         case TIOCSERGETLSR:
    2776                 :            :         case TIOCGRS485:
    2777                 :            :         case TIOCSRS485:
    2778                 :            : #ifdef TIOCGETP
    2779                 :            :         case TIOCGETP:
    2780                 :            :         case TIOCSETP:
    2781                 :            :         case TIOCSETN:
    2782                 :            : #endif
    2783                 :            : #ifdef TIOCGETC
    2784                 :            :         case TIOCGETC:
    2785                 :            :         case TIOCSETC:
    2786                 :            : #endif
    2787                 :            : #ifdef TIOCGLTC
    2788                 :            :         case TIOCGLTC:
    2789                 :            :         case TIOCSLTC:
    2790                 :            : #endif
    2791                 :            :         case TCSETSF:
    2792                 :            :         case TCSETSW:
    2793                 :            :         case TCSETS:
    2794                 :            :         case TCGETS:
    2795                 :            : #ifdef TCGETS2
    2796                 :            :         case TCGETS2:
    2797                 :            :         case TCSETSF2:
    2798                 :            :         case TCSETSW2:
    2799                 :            :         case TCSETS2:
    2800                 :            : #endif
    2801                 :            :         case TCGETA:
    2802                 :            :         case TCSETAF:
    2803                 :            :         case TCSETAW:
    2804                 :            :         case TCSETA:
    2805                 :            :         case TIOCGLCKTRMIOS:
    2806                 :            :         case TIOCSLCKTRMIOS:
    2807                 :            : #ifdef TCGETX
    2808                 :            :         case TCGETX:
    2809                 :            :         case TCSETX:
    2810                 :            :         case TCSETXW:
    2811                 :            :         case TCSETXF:
    2812                 :            : #endif
    2813                 :            :         case TIOCGSOFTCAR:
    2814                 :            :         case TIOCSSOFTCAR:
    2815                 :            :                 return tty_ioctl(file, cmd, (unsigned long)compat_ptr(arg));
    2816                 :            :         case TIOCCONS:
    2817                 :            :         case TIOCEXCL:
    2818                 :            :         case TIOCNXCL:
    2819                 :            :         case TIOCVHANGUP:
    2820                 :            :         case TIOCSBRK:
    2821                 :            :         case TIOCCBRK:
    2822                 :            :         case TCSBRK:
    2823                 :            :         case TCSBRKP:
    2824                 :            :         case TCFLSH:
    2825                 :            :         case TIOCGPTPEER:
    2826                 :            :         case TIOCNOTTY:
    2827                 :            :         case TIOCSCTTY:
    2828                 :            :         case TCXONC:
    2829                 :            :         case TIOCMIWAIT:
    2830                 :            :         case TIOCSERCONFIG:
    2831                 :            :                 return tty_ioctl(file, cmd, arg);
    2832                 :            :         }
    2833                 :            : 
    2834                 :            :         if (tty_paranoia_check(tty, file_inode(file), "tty_ioctl"))
    2835                 :            :                 return -EINVAL;
    2836                 :            : 
    2837                 :            :         switch (cmd) {
    2838                 :            :         case TIOCSSERIAL:
    2839                 :            :                 return compat_tty_tiocsserial(tty, compat_ptr(arg));
    2840                 :            :         case TIOCGSERIAL:
    2841                 :            :                 return compat_tty_tiocgserial(tty, compat_ptr(arg));
    2842                 :            :         }
    2843                 :            :         if (tty->ops->compat_ioctl) {
    2844                 :            :                 retval = tty->ops->compat_ioctl(tty, cmd, arg);
    2845                 :            :                 if (retval != -ENOIOCTLCMD)
    2846                 :            :                         return retval;
    2847                 :            :         }
    2848                 :            : 
    2849                 :            :         ld = tty_ldisc_ref_wait(tty);
    2850                 :            :         if (!ld)
    2851                 :            :                 return hung_up_tty_compat_ioctl(file, cmd, arg);
    2852                 :            :         if (ld->ops->compat_ioctl)
    2853                 :            :                 retval = ld->ops->compat_ioctl(tty, file, cmd, arg);
    2854                 :            :         if (retval == -ENOIOCTLCMD && ld->ops->ioctl)
    2855                 :            :                 retval = ld->ops->ioctl(tty, file,
    2856                 :            :                                 (unsigned long)compat_ptr(cmd), arg);
    2857                 :            :         tty_ldisc_deref(ld);
    2858                 :            : 
    2859                 :            :         return retval;
    2860                 :            : }
    2861                 :            : #endif
    2862                 :            : 
    2863                 :          0 : static int this_tty(const void *t, struct file *file, unsigned fd)
    2864                 :            : {
    2865                 :          0 :         if (likely(file->f_op->read != tty_read))
    2866                 :            :                 return 0;
    2867                 :          0 :         return file_tty(file) != t ? 0 : fd + 1;
    2868                 :            : }
    2869                 :            :         
    2870                 :            : /*
    2871                 :            :  * This implements the "Secure Attention Key" ---  the idea is to
    2872                 :            :  * prevent trojan horses by killing all processes associated with this
    2873                 :            :  * tty when the user hits the "Secure Attention Key".  Required for
    2874                 :            :  * super-paranoid applications --- see the Orange Book for more details.
    2875                 :            :  *
    2876                 :            :  * This code could be nicer; ideally it should send a HUP, wait a few
    2877                 :            :  * seconds, then send a INT, and then a KILL signal.  But you then
    2878                 :            :  * have to coordinate with the init process, since all processes associated
    2879                 :            :  * with the current tty must be dead before the new getty is allowed
    2880                 :            :  * to spawn.
    2881                 :            :  *
    2882                 :            :  * Now, if it would be correct ;-/ The current code has a nasty hole -
    2883                 :            :  * it doesn't catch files in flight. We may send the descriptor to ourselves
    2884                 :            :  * via AF_UNIX socket, close it and later fetch from socket. FIXME.
    2885                 :            :  *
    2886                 :            :  * Nasty bug: do_SAK is being called in interrupt context.  This can
    2887                 :            :  * deadlock.  We punt it up to process context.  AKPM - 16Mar2001
    2888                 :            :  */
    2889                 :          0 : void __do_SAK(struct tty_struct *tty)
    2890                 :            : {
    2891                 :            : #ifdef TTY_SOFT_SAK
    2892                 :            :         tty_hangup(tty);
    2893                 :            : #else
    2894                 :            :         struct task_struct *g, *p;
    2895                 :            :         struct pid *session;
    2896                 :            :         int             i;
    2897                 :            : 
    2898                 :          0 :         if (!tty)
    2899                 :          0 :                 return;
    2900                 :          0 :         session = tty->session;
    2901                 :            : 
    2902                 :          0 :         tty_ldisc_flush(tty);
    2903                 :            : 
    2904                 :          0 :         tty_driver_flush_buffer(tty);
    2905                 :            : 
    2906                 :          0 :         read_lock(&tasklist_lock);
    2907                 :            :         /* Kill the entire session */
    2908                 :          0 :         do_each_pid_task(session, PIDTYPE_SID, p) {
    2909                 :          0 :                 tty_notice(tty, "SAK: killed process %d (%s): by session\n",
    2910                 :            :                            task_pid_nr(p), p->comm);
    2911                 :          0 :                 group_send_sig_info(SIGKILL, SEND_SIG_PRIV, p, PIDTYPE_SID);
    2912                 :            :         } while_each_pid_task(session, PIDTYPE_SID, p);
    2913                 :            : 
    2914                 :            :         /* Now kill any processes that happen to have the tty open */
    2915                 :          0 :         do_each_thread(g, p) {
    2916                 :          0 :                 if (p->signal->tty == tty) {
    2917                 :          0 :                         tty_notice(tty, "SAK: killed process %d (%s): by controlling tty\n",
    2918                 :            :                                    task_pid_nr(p), p->comm);
    2919                 :          0 :                         group_send_sig_info(SIGKILL, SEND_SIG_PRIV, p, PIDTYPE_SID);
    2920                 :          0 :                         continue;
    2921                 :            :                 }
    2922                 :            :                 task_lock(p);
    2923                 :          0 :                 i = iterate_fd(p->files, 0, this_tty, tty);
    2924                 :          0 :                 if (i != 0) {
    2925                 :          0 :                         tty_notice(tty, "SAK: killed process %d (%s): by fd#%d\n",
    2926                 :            :                                    task_pid_nr(p), p->comm, i - 1);
    2927                 :          0 :                         group_send_sig_info(SIGKILL, SEND_SIG_PRIV, p, PIDTYPE_SID);
    2928                 :            :                 }
    2929                 :            :                 task_unlock(p);
    2930                 :          0 :         } while_each_thread(g, p);
    2931                 :            :         read_unlock(&tasklist_lock);
    2932                 :            : #endif
    2933                 :            : }
    2934                 :            : 
    2935                 :          0 : static void do_SAK_work(struct work_struct *work)
    2936                 :            : {
    2937                 :            :         struct tty_struct *tty =
    2938                 :          0 :                 container_of(work, struct tty_struct, SAK_work);
    2939                 :          0 :         __do_SAK(tty);
    2940                 :          0 : }
    2941                 :            : 
    2942                 :            : /*
    2943                 :            :  * The tq handling here is a little racy - tty->SAK_work may already be queued.
    2944                 :            :  * Fortunately we don't need to worry, because if ->SAK_work is already queued,
    2945                 :            :  * the values which we write to it will be identical to the values which it
    2946                 :            :  * already has. --akpm
    2947                 :            :  */
    2948                 :          0 : void do_SAK(struct tty_struct *tty)
    2949                 :            : {
    2950                 :          0 :         if (!tty)
    2951                 :          0 :                 return;
    2952                 :          0 :         schedule_work(&tty->SAK_work);
    2953                 :            : }
    2954                 :            : 
    2955                 :            : EXPORT_SYMBOL(do_SAK);
    2956                 :            : 
    2957                 :            : /* Must put_device() after it's unused! */
    2958                 :          3 : static struct device *tty_get_device(struct tty_struct *tty)
    2959                 :            : {
    2960                 :            :         dev_t devt = tty_devnum(tty);
    2961                 :          3 :         return class_find_device_by_devt(tty_class, devt);
    2962                 :            : }
    2963                 :            : 
    2964                 :            : 
    2965                 :            : /**
    2966                 :            :  *      alloc_tty_struct
    2967                 :            :  *
    2968                 :            :  *      This subroutine allocates and initializes a tty structure.
    2969                 :            :  *
    2970                 :            :  *      Locking: none - tty in question is not exposed at this point
    2971                 :            :  */
    2972                 :            : 
    2973                 :          3 : struct tty_struct *alloc_tty_struct(struct tty_driver *driver, int idx)
    2974                 :            : {
    2975                 :            :         struct tty_struct *tty;
    2976                 :            : 
    2977                 :          3 :         tty = kzalloc(sizeof(*tty), GFP_KERNEL);
    2978                 :          3 :         if (!tty)
    2979                 :            :                 return NULL;
    2980                 :            : 
    2981                 :            :         kref_init(&tty->kref);
    2982                 :          3 :         tty->magic = TTY_MAGIC;
    2983                 :          3 :         if (tty_ldisc_init(tty)) {
    2984                 :          0 :                 kfree(tty);
    2985                 :          0 :                 return NULL;
    2986                 :            :         }
    2987                 :          3 :         tty->session = NULL;
    2988                 :          3 :         tty->pgrp = NULL;
    2989                 :          3 :         mutex_init(&tty->legacy_mutex);
    2990                 :          3 :         mutex_init(&tty->throttle_mutex);
    2991                 :          3 :         init_rwsem(&tty->termios_rwsem);
    2992                 :          3 :         mutex_init(&tty->winsize_mutex);
    2993                 :          3 :         init_ldsem(&tty->ldisc_sem);
    2994                 :          3 :         init_waitqueue_head(&tty->write_wait);
    2995                 :          3 :         init_waitqueue_head(&tty->read_wait);
    2996                 :          3 :         INIT_WORK(&tty->hangup_work, do_tty_hangup);
    2997                 :          3 :         mutex_init(&tty->atomic_write_lock);
    2998                 :          3 :         spin_lock_init(&tty->ctrl_lock);
    2999                 :          3 :         spin_lock_init(&tty->flow_lock);
    3000                 :          3 :         spin_lock_init(&tty->files_lock);
    3001                 :          3 :         INIT_LIST_HEAD(&tty->tty_files);
    3002                 :          3 :         INIT_WORK(&tty->SAK_work, do_SAK_work);
    3003                 :            : 
    3004                 :          3 :         tty->driver = driver;
    3005                 :          3 :         tty->ops = driver->ops;
    3006                 :          3 :         tty->index = idx;
    3007                 :          3 :         tty_line_name(driver, idx, tty->name);
    3008                 :          3 :         tty->dev = tty_get_device(tty);
    3009                 :            : 
    3010                 :          3 :         return tty;
    3011                 :            : }
    3012                 :            : 
    3013                 :            : /**
    3014                 :            :  *      tty_put_char    -       write one character to a tty
    3015                 :            :  *      @tty: tty
    3016                 :            :  *      @ch: character
    3017                 :            :  *
    3018                 :            :  *      Write one byte to the tty using the provided put_char method
    3019                 :            :  *      if present. Returns the number of characters successfully output.
    3020                 :            :  *
    3021                 :            :  *      Note: the specific put_char operation in the driver layer may go
    3022                 :            :  *      away soon. Don't call it directly, use this method
    3023                 :            :  */
    3024                 :            : 
    3025                 :          0 : int tty_put_char(struct tty_struct *tty, unsigned char ch)
    3026                 :            : {
    3027                 :          0 :         if (tty->ops->put_char)
    3028                 :          0 :                 return tty->ops->put_char(tty, ch);
    3029                 :          0 :         return tty->ops->write(tty, &ch, 1);
    3030                 :            : }
    3031                 :            : EXPORT_SYMBOL_GPL(tty_put_char);
    3032                 :            : 
    3033                 :            : struct class *tty_class;
    3034                 :            : 
    3035                 :          3 : static int tty_cdev_add(struct tty_driver *driver, dev_t dev,
    3036                 :            :                 unsigned int index, unsigned int count)
    3037                 :            : {
    3038                 :            :         int err;
    3039                 :            : 
    3040                 :            :         /* init here, since reused cdevs cause crashes */
    3041                 :          3 :         driver->cdevs[index] = cdev_alloc();
    3042                 :          3 :         if (!driver->cdevs[index])
    3043                 :            :                 return -ENOMEM;
    3044                 :          3 :         driver->cdevs[index]->ops = &tty_fops;
    3045                 :          3 :         driver->cdevs[index]->owner = driver->owner;
    3046                 :          3 :         err = cdev_add(driver->cdevs[index], dev, count);
    3047                 :          3 :         if (err)
    3048                 :          0 :                 kobject_put(&driver->cdevs[index]->kobj);
    3049                 :          3 :         return err;
    3050                 :            : }
    3051                 :            : 
    3052                 :            : /**
    3053                 :            :  *      tty_register_device - register a tty device
    3054                 :            :  *      @driver: the tty driver that describes the tty device
    3055                 :            :  *      @index: the index in the tty driver for this tty device
    3056                 :            :  *      @device: a struct device that is associated with this tty device.
    3057                 :            :  *              This field is optional, if there is no known struct device
    3058                 :            :  *              for this tty device it can be set to NULL safely.
    3059                 :            :  *
    3060                 :            :  *      Returns a pointer to the struct device for this tty device
    3061                 :            :  *      (or ERR_PTR(-EFOO) on error).
    3062                 :            :  *
    3063                 :            :  *      This call is required to be made to register an individual tty device
    3064                 :            :  *      if the tty driver's flags have the TTY_DRIVER_DYNAMIC_DEV bit set.  If
    3065                 :            :  *      that bit is not set, this function should not be called by a tty
    3066                 :            :  *      driver.
    3067                 :            :  *
    3068                 :            :  *      Locking: ??
    3069                 :            :  */
    3070                 :            : 
    3071                 :          0 : struct device *tty_register_device(struct tty_driver *driver, unsigned index,
    3072                 :            :                                    struct device *device)
    3073                 :            : {
    3074                 :          3 :         return tty_register_device_attr(driver, index, device, NULL, NULL);
    3075                 :            : }
    3076                 :            : EXPORT_SYMBOL(tty_register_device);
    3077                 :            : 
    3078                 :          0 : static void tty_device_create_release(struct device *dev)
    3079                 :            : {
    3080                 :            :         dev_dbg(dev, "releasing...\n");
    3081                 :          0 :         kfree(dev);
    3082                 :          0 : }
    3083                 :            : 
    3084                 :            : /**
    3085                 :            :  *      tty_register_device_attr - register a tty device
    3086                 :            :  *      @driver: the tty driver that describes the tty device
    3087                 :            :  *      @index: the index in the tty driver for this tty device
    3088                 :            :  *      @device: a struct device that is associated with this tty device.
    3089                 :            :  *              This field is optional, if there is no known struct device
    3090                 :            :  *              for this tty device it can be set to NULL safely.
    3091                 :            :  *      @drvdata: Driver data to be set to device.
    3092                 :            :  *      @attr_grp: Attribute group to be set on device.
    3093                 :            :  *
    3094                 :            :  *      Returns a pointer to the struct device for this tty device
    3095                 :            :  *      (or ERR_PTR(-EFOO) on error).
    3096                 :            :  *
    3097                 :            :  *      This call is required to be made to register an individual tty device
    3098                 :            :  *      if the tty driver's flags have the TTY_DRIVER_DYNAMIC_DEV bit set.  If
    3099                 :            :  *      that bit is not set, this function should not be called by a tty
    3100                 :            :  *      driver.
    3101                 :            :  *
    3102                 :            :  *      Locking: ??
    3103                 :            :  */
    3104                 :          3 : struct device *tty_register_device_attr(struct tty_driver *driver,
    3105                 :            :                                    unsigned index, struct device *device,
    3106                 :            :                                    void *drvdata,
    3107                 :            :                                    const struct attribute_group **attr_grp)
    3108                 :            : {
    3109                 :            :         char name[64];
    3110                 :          3 :         dev_t devt = MKDEV(driver->major, driver->minor_start) + index;
    3111                 :            :         struct ktermios *tp;
    3112                 :            :         struct device *dev;
    3113                 :            :         int retval;
    3114                 :            : 
    3115                 :          3 :         if (index >= driver->num) {
    3116                 :          0 :                 pr_err("%s: Attempt to register invalid tty line number (%d)\n",
    3117                 :            :                        driver->name, index);
    3118                 :          0 :                 return ERR_PTR(-EINVAL);
    3119                 :            :         }
    3120                 :            : 
    3121                 :          3 :         if (driver->type == TTY_DRIVER_TYPE_PTY)
    3122                 :          0 :                 pty_line_name(driver, index, name);
    3123                 :            :         else
    3124                 :          3 :                 tty_line_name(driver, index, name);
    3125                 :            : 
    3126                 :          3 :         dev = kzalloc(sizeof(*dev), GFP_KERNEL);
    3127                 :          3 :         if (!dev)
    3128                 :            :                 return ERR_PTR(-ENOMEM);
    3129                 :            : 
    3130                 :          3 :         dev->devt = devt;
    3131                 :          3 :         dev->class = tty_class;
    3132                 :          3 :         dev->parent = device;
    3133                 :          3 :         dev->release = tty_device_create_release;
    3134                 :          3 :         dev_set_name(dev, "%s", name);
    3135                 :          3 :         dev->groups = attr_grp;
    3136                 :            :         dev_set_drvdata(dev, drvdata);
    3137                 :            : 
    3138                 :            :         dev_set_uevent_suppress(dev, 1);
    3139                 :            : 
    3140                 :          3 :         retval = device_register(dev);
    3141                 :          3 :         if (retval)
    3142                 :            :                 goto err_put;
    3143                 :            : 
    3144                 :          3 :         if (!(driver->flags & TTY_DRIVER_DYNAMIC_ALLOC)) {
    3145                 :            :                 /*
    3146                 :            :                  * Free any saved termios data so that the termios state is
    3147                 :            :                  * reset when reusing a minor number.
    3148                 :            :                  */
    3149                 :          3 :                 tp = driver->termios[index];
    3150                 :          3 :                 if (tp) {
    3151                 :          0 :                         driver->termios[index] = NULL;
    3152                 :          0 :                         kfree(tp);
    3153                 :            :                 }
    3154                 :            : 
    3155                 :          3 :                 retval = tty_cdev_add(driver, devt, index, 1);
    3156                 :          3 :                 if (retval)
    3157                 :            :                         goto err_del;
    3158                 :            :         }
    3159                 :            : 
    3160                 :            :         dev_set_uevent_suppress(dev, 0);
    3161                 :          3 :         kobject_uevent(&dev->kobj, KOBJ_ADD);
    3162                 :            : 
    3163                 :          3 :         return dev;
    3164                 :            : 
    3165                 :            : err_del:
    3166                 :          0 :         device_del(dev);
    3167                 :            : err_put:
    3168                 :          0 :         put_device(dev);
    3169                 :            : 
    3170                 :          0 :         return ERR_PTR(retval);
    3171                 :            : }
    3172                 :            : EXPORT_SYMBOL_GPL(tty_register_device_attr);
    3173                 :            : 
    3174                 :            : /**
    3175                 :            :  *      tty_unregister_device - unregister a tty device
    3176                 :            :  *      @driver: the tty driver that describes the tty device
    3177                 :            :  *      @index: the index in the tty driver for this tty device
    3178                 :            :  *
    3179                 :            :  *      If a tty device is registered with a call to tty_register_device() then
    3180                 :            :  *      this function must be called when the tty device is gone.
    3181                 :            :  *
    3182                 :            :  *      Locking: ??
    3183                 :            :  */
    3184                 :            : 
    3185                 :          0 : void tty_unregister_device(struct tty_driver *driver, unsigned index)
    3186                 :            : {
    3187                 :          0 :         device_destroy(tty_class,
    3188                 :          0 :                 MKDEV(driver->major, driver->minor_start) + index);
    3189                 :          0 :         if (!(driver->flags & TTY_DRIVER_DYNAMIC_ALLOC)) {
    3190                 :          0 :                 cdev_del(driver->cdevs[index]);
    3191                 :          0 :                 driver->cdevs[index] = NULL;
    3192                 :            :         }
    3193                 :          0 : }
    3194                 :            : EXPORT_SYMBOL(tty_unregister_device);
    3195                 :            : 
    3196                 :            : /**
    3197                 :            :  * __tty_alloc_driver -- allocate tty driver
    3198                 :            :  * @lines: count of lines this driver can handle at most
    3199                 :            :  * @owner: module which is responsible for this driver
    3200                 :            :  * @flags: some of TTY_DRIVER_* flags, will be set in driver->flags
    3201                 :            :  *
    3202                 :            :  * This should not be called directly, some of the provided macros should be
    3203                 :            :  * used instead. Use IS_ERR and friends on @retval.
    3204                 :            :  */
    3205                 :          3 : struct tty_driver *__tty_alloc_driver(unsigned int lines, struct module *owner,
    3206                 :            :                 unsigned long flags)
    3207                 :            : {
    3208                 :            :         struct tty_driver *driver;
    3209                 :            :         unsigned int cdevs = 1;
    3210                 :            :         int err;
    3211                 :            : 
    3212                 :          3 :         if (!lines || (flags & TTY_DRIVER_UNNUMBERED_NODE && lines > 1))
    3213                 :            :                 return ERR_PTR(-EINVAL);
    3214                 :            : 
    3215                 :          3 :         driver = kzalloc(sizeof(struct tty_driver), GFP_KERNEL);
    3216                 :          3 :         if (!driver)
    3217                 :            :                 return ERR_PTR(-ENOMEM);
    3218                 :            : 
    3219                 :            :         kref_init(&driver->kref);
    3220                 :          3 :         driver->magic = TTY_DRIVER_MAGIC;
    3221                 :          3 :         driver->num = lines;
    3222                 :          3 :         driver->owner = owner;
    3223                 :          3 :         driver->flags = flags;
    3224                 :            : 
    3225                 :          3 :         if (!(flags & TTY_DRIVER_DEVPTS_MEM)) {
    3226                 :          3 :                 driver->ttys = kcalloc(lines, sizeof(*driver->ttys),
    3227                 :            :                                 GFP_KERNEL);
    3228                 :          3 :                 driver->termios = kcalloc(lines, sizeof(*driver->termios),
    3229                 :            :                                 GFP_KERNEL);
    3230                 :          3 :                 if (!driver->ttys || !driver->termios) {
    3231                 :            :                         err = -ENOMEM;
    3232                 :            :                         goto err_free_all;
    3233                 :            :                 }
    3234                 :            :         }
    3235                 :            : 
    3236                 :          3 :         if (!(flags & TTY_DRIVER_DYNAMIC_ALLOC)) {
    3237                 :          3 :                 driver->ports = kcalloc(lines, sizeof(*driver->ports),
    3238                 :            :                                 GFP_KERNEL);
    3239                 :          3 :                 if (!driver->ports) {
    3240                 :            :                         err = -ENOMEM;
    3241                 :            :                         goto err_free_all;
    3242                 :            :                 }
    3243                 :            :                 cdevs = lines;
    3244                 :            :         }
    3245                 :            : 
    3246                 :          3 :         driver->cdevs = kcalloc(cdevs, sizeof(*driver->cdevs), GFP_KERNEL);
    3247                 :          3 :         if (!driver->cdevs) {
    3248                 :            :                 err = -ENOMEM;
    3249                 :            :                 goto err_free_all;
    3250                 :            :         }
    3251                 :            : 
    3252                 :            :         return driver;
    3253                 :            : err_free_all:
    3254                 :          0 :         kfree(driver->ports);
    3255                 :          0 :         kfree(driver->ttys);
    3256                 :          0 :         kfree(driver->termios);
    3257                 :          0 :         kfree(driver->cdevs);
    3258                 :          0 :         kfree(driver);
    3259                 :          0 :         return ERR_PTR(err);
    3260                 :            : }
    3261                 :            : EXPORT_SYMBOL(__tty_alloc_driver);
    3262                 :            : 
    3263                 :          0 : static void destruct_tty_driver(struct kref *kref)
    3264                 :            : {
    3265                 :          0 :         struct tty_driver *driver = container_of(kref, struct tty_driver, kref);
    3266                 :            :         int i;
    3267                 :            :         struct ktermios *tp;
    3268                 :            : 
    3269                 :          0 :         if (driver->flags & TTY_DRIVER_INSTALLED) {
    3270                 :          0 :                 for (i = 0; i < driver->num; i++) {
    3271                 :          0 :                         tp = driver->termios[i];
    3272                 :          0 :                         if (tp) {
    3273                 :          0 :                                 driver->termios[i] = NULL;
    3274                 :          0 :                                 kfree(tp);
    3275                 :            :                         }
    3276                 :          0 :                         if (!(driver->flags & TTY_DRIVER_DYNAMIC_DEV))
    3277                 :          0 :                                 tty_unregister_device(driver, i);
    3278                 :            :                 }
    3279                 :          0 :                 proc_tty_unregister_driver(driver);
    3280                 :          0 :                 if (driver->flags & TTY_DRIVER_DYNAMIC_ALLOC)
    3281                 :          0 :                         cdev_del(driver->cdevs[0]);
    3282                 :            :         }
    3283                 :          0 :         kfree(driver->cdevs);
    3284                 :          0 :         kfree(driver->ports);
    3285                 :          0 :         kfree(driver->termios);
    3286                 :          0 :         kfree(driver->ttys);
    3287                 :          0 :         kfree(driver);
    3288                 :          0 : }
    3289                 :            : 
    3290                 :          0 : void tty_driver_kref_put(struct tty_driver *driver)
    3291                 :            : {
    3292                 :          3 :         kref_put(&driver->kref, destruct_tty_driver);
    3293                 :          0 : }
    3294                 :            : EXPORT_SYMBOL(tty_driver_kref_put);
    3295                 :            : 
    3296                 :          3 : void tty_set_operations(struct tty_driver *driver,
    3297                 :            :                         const struct tty_operations *op)
    3298                 :            : {
    3299                 :          3 :         driver->ops = op;
    3300                 :          3 : };
    3301                 :            : EXPORT_SYMBOL(tty_set_operations);
    3302                 :            : 
    3303                 :          0 : void put_tty_driver(struct tty_driver *d)
    3304                 :            : {
    3305                 :            :         tty_driver_kref_put(d);
    3306                 :          0 : }
    3307                 :            : EXPORT_SYMBOL(put_tty_driver);
    3308                 :            : 
    3309                 :            : /*
    3310                 :            :  * Called by a tty driver to register itself.
    3311                 :            :  */
    3312                 :          3 : int tty_register_driver(struct tty_driver *driver)
    3313                 :            : {
    3314                 :            :         int error;
    3315                 :            :         int i;
    3316                 :            :         dev_t dev;
    3317                 :            :         struct device *d;
    3318                 :            : 
    3319                 :          3 :         if (!driver->major) {
    3320                 :          0 :                 error = alloc_chrdev_region(&dev, driver->minor_start,
    3321                 :            :                                                 driver->num, driver->name);
    3322                 :          0 :                 if (!error) {
    3323                 :          0 :                         driver->major = MAJOR(dev);
    3324                 :          0 :                         driver->minor_start = MINOR(dev);
    3325                 :            :                 }
    3326                 :            :         } else {
    3327                 :          3 :                 dev = MKDEV(driver->major, driver->minor_start);
    3328                 :          3 :                 error = register_chrdev_region(dev, driver->num, driver->name);
    3329                 :            :         }
    3330                 :          3 :         if (error < 0)
    3331                 :            :                 goto err;
    3332                 :            : 
    3333                 :          3 :         if (driver->flags & TTY_DRIVER_DYNAMIC_ALLOC) {
    3334                 :          3 :                 error = tty_cdev_add(driver, dev, 0, driver->num);
    3335                 :          3 :                 if (error)
    3336                 :            :                         goto err_unreg_char;
    3337                 :            :         }
    3338                 :            : 
    3339                 :          3 :         mutex_lock(&tty_mutex);
    3340                 :          3 :         list_add(&driver->tty_drivers, &tty_drivers);
    3341                 :          3 :         mutex_unlock(&tty_mutex);
    3342                 :            : 
    3343                 :          3 :         if (!(driver->flags & TTY_DRIVER_DYNAMIC_DEV)) {
    3344                 :          3 :                 for (i = 0; i < driver->num; i++) {
    3345                 :            :                         d = tty_register_device(driver, i, NULL);
    3346                 :          3 :                         if (IS_ERR(d)) {
    3347                 :            :                                 error = PTR_ERR(d);
    3348                 :            :                                 goto err_unreg_devs;
    3349                 :            :                         }
    3350                 :            :                 }
    3351                 :            :         }
    3352                 :          3 :         proc_tty_register_driver(driver);
    3353                 :          3 :         driver->flags |= TTY_DRIVER_INSTALLED;
    3354                 :          3 :         return 0;
    3355                 :            : 
    3356                 :            : err_unreg_devs:
    3357                 :          0 :         for (i--; i >= 0; i--)
    3358                 :          0 :                 tty_unregister_device(driver, i);
    3359                 :            : 
    3360                 :          0 :         mutex_lock(&tty_mutex);
    3361                 :            :         list_del(&driver->tty_drivers);
    3362                 :          0 :         mutex_unlock(&tty_mutex);
    3363                 :            : 
    3364                 :            : err_unreg_char:
    3365                 :          0 :         unregister_chrdev_region(dev, driver->num);
    3366                 :            : err:
    3367                 :          0 :         return error;
    3368                 :            : }
    3369                 :            : EXPORT_SYMBOL(tty_register_driver);
    3370                 :            : 
    3371                 :            : /*
    3372                 :            :  * Called by a tty driver to unregister itself.
    3373                 :            :  */
    3374                 :          0 : int tty_unregister_driver(struct tty_driver *driver)
    3375                 :            : {
    3376                 :            : #if 0
    3377                 :            :         /* FIXME */
    3378                 :            :         if (driver->refcount)
    3379                 :            :                 return -EBUSY;
    3380                 :            : #endif
    3381                 :          0 :         unregister_chrdev_region(MKDEV(driver->major, driver->minor_start),
    3382                 :            :                                 driver->num);
    3383                 :          0 :         mutex_lock(&tty_mutex);
    3384                 :            :         list_del(&driver->tty_drivers);
    3385                 :          0 :         mutex_unlock(&tty_mutex);
    3386                 :          0 :         return 0;
    3387                 :            : }
    3388                 :            : 
    3389                 :            : EXPORT_SYMBOL(tty_unregister_driver);
    3390                 :            : 
    3391                 :          3 : dev_t tty_devnum(struct tty_struct *tty)
    3392                 :            : {
    3393                 :          3 :         return MKDEV(tty->driver->major, tty->driver->minor_start) + tty->index;
    3394                 :            : }
    3395                 :            : EXPORT_SYMBOL(tty_devnum);
    3396                 :            : 
    3397                 :          3 : void tty_default_fops(struct file_operations *fops)
    3398                 :            : {
    3399                 :          3 :         *fops = tty_fops;
    3400                 :          3 : }
    3401                 :            : 
    3402                 :          3 : static char *tty_devnode(struct device *dev, umode_t *mode)
    3403                 :            : {
    3404                 :          3 :         if (!mode)
    3405                 :            :                 return NULL;
    3406                 :          3 :         if (dev->devt == MKDEV(TTYAUX_MAJOR, 0) ||
    3407                 :            :             dev->devt == MKDEV(TTYAUX_MAJOR, 2))
    3408                 :          3 :                 *mode = 0666;
    3409                 :            :         return NULL;
    3410                 :            : }
    3411                 :            : 
    3412                 :          3 : static int __init tty_class_init(void)
    3413                 :            : {
    3414                 :          3 :         tty_class = class_create(THIS_MODULE, "tty");
    3415                 :          3 :         if (IS_ERR(tty_class))
    3416                 :          0 :                 return PTR_ERR(tty_class);
    3417                 :          3 :         tty_class->devnode = tty_devnode;
    3418                 :          3 :         return 0;
    3419                 :            : }
    3420                 :            : 
    3421                 :            : postcore_initcall(tty_class_init);
    3422                 :            : 
    3423                 :            : /* 3/2004 jmc: why do these devices exist? */
    3424                 :            : static struct cdev tty_cdev, console_cdev;
    3425                 :            : 
    3426                 :          3 : static ssize_t show_cons_active(struct device *dev,
    3427                 :            :                                 struct device_attribute *attr, char *buf)
    3428                 :            : {
    3429                 :            :         struct console *cs[16];
    3430                 :            :         int i = 0;
    3431                 :            :         struct console *c;
    3432                 :            :         ssize_t count = 0;
    3433                 :            : 
    3434                 :          3 :         console_lock();
    3435                 :          3 :         for_each_console(c) {
    3436                 :          3 :                 if (!c->device)
    3437                 :          0 :                         continue;
    3438                 :          3 :                 if (!c->write)
    3439                 :          0 :                         continue;
    3440                 :          3 :                 if ((c->flags & CON_ENABLED) == 0)
    3441                 :          0 :                         continue;
    3442                 :          3 :                 cs[i++] = c;
    3443                 :          3 :                 if (i >= ARRAY_SIZE(cs))
    3444                 :            :                         break;
    3445                 :            :         }
    3446                 :          3 :         while (i--) {
    3447                 :          3 :                 int index = cs[i]->index;
    3448                 :          3 :                 struct tty_driver *drv = cs[i]->device(cs[i], &index);
    3449                 :            : 
    3450                 :            :                 /* don't resolve tty0 as some programs depend on it */
    3451                 :          3 :                 if (drv && (cs[i]->index > 0 || drv->major != TTY_MAJOR))
    3452                 :          3 :                         count += tty_line_name(drv, index, buf + count);
    3453                 :            :                 else
    3454                 :          0 :                         count += sprintf(buf + count, "%s%d",
    3455                 :          0 :                                          cs[i]->name, cs[i]->index);
    3456                 :            : 
    3457                 :          3 :                 count += sprintf(buf + count, "%c", i ? ' ':'\n');
    3458                 :            :         }
    3459                 :          3 :         console_unlock();
    3460                 :            : 
    3461                 :          3 :         return count;
    3462                 :            : }
    3463                 :            : static DEVICE_ATTR(active, S_IRUGO, show_cons_active, NULL);
    3464                 :            : 
    3465                 :            : static struct attribute *cons_dev_attrs[] = {
    3466                 :            :         &dev_attr_active.attr,
    3467                 :            :         NULL
    3468                 :            : };
    3469                 :            : 
    3470                 :            : ATTRIBUTE_GROUPS(cons_dev);
    3471                 :            : 
    3472                 :            : static struct device *consdev;
    3473                 :            : 
    3474                 :          3 : void console_sysfs_notify(void)
    3475                 :            : {
    3476                 :          3 :         if (consdev)
    3477                 :          3 :                 sysfs_notify(&consdev->kobj, NULL, "active");
    3478                 :          3 : }
    3479                 :            : 
    3480                 :            : /*
    3481                 :            :  * Ok, now we can initialize the rest of the tty devices and can count
    3482                 :            :  * on memory allocations, interrupts etc..
    3483                 :            :  */
    3484                 :          3 : int __init tty_init(void)
    3485                 :            : {
    3486                 :          3 :         tty_sysctl_init();
    3487                 :          3 :         cdev_init(&tty_cdev, &tty_fops);
    3488                 :          3 :         if (cdev_add(&tty_cdev, MKDEV(TTYAUX_MAJOR, 0), 1) ||
    3489                 :          3 :             register_chrdev_region(MKDEV(TTYAUX_MAJOR, 0), 1, "/dev/tty") < 0)
    3490                 :          0 :                 panic("Couldn't register /dev/tty driver\n");
    3491                 :          3 :         device_create(tty_class, NULL, MKDEV(TTYAUX_MAJOR, 0), NULL, "tty");
    3492                 :            : 
    3493                 :          3 :         cdev_init(&console_cdev, &console_fops);
    3494                 :          3 :         if (cdev_add(&console_cdev, MKDEV(TTYAUX_MAJOR, 1), 1) ||
    3495                 :          3 :             register_chrdev_region(MKDEV(TTYAUX_MAJOR, 1), 1, "/dev/console") < 0)
    3496                 :          0 :                 panic("Couldn't register /dev/console driver\n");
    3497                 :          3 :         consdev = device_create_with_groups(tty_class, NULL,
    3498                 :            :                                             MKDEV(TTYAUX_MAJOR, 1), NULL,
    3499                 :            :                                             cons_dev_groups, "console");
    3500                 :          3 :         if (IS_ERR(consdev))
    3501                 :          0 :                 consdev = NULL;
    3502                 :            : 
    3503                 :            : #ifdef CONFIG_VT
    3504                 :          3 :         vty_init(&console_fops);
    3505                 :            : #endif
    3506                 :          3 :         return 0;
    3507                 :            : }
    3508                 :            : 
    

Generated by: LCOV version 1.14