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