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