blob: 4c4030c12d3a9ddd3ca55818413f8f9631c7231a [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
2 * linux/drivers/char/tty_io.c
3 *
4 * Copyright (C) 1991, 1992 Linus Torvalds
5 */
6
7/*
8 * 'tty_io.c' gives an orthogonal feeling to tty's, be they consoles
9 * or rs-channels. It also implements echoing, cooked mode etc.
10 *
11 * Kill-line thanks to John T Kohl, who also corrected VMIN = VTIME = 0.
12 *
13 * Modified by Theodore Ts'o, 9/14/92, to dynamically allocate the
14 * tty_struct and tty_queue structures. Previously there was an array
15 * of 256 tty_struct's which was statically allocated, and the
16 * tty_queue structures were allocated at boot time. Both are now
17 * dynamically allocated only when the tty is open.
18 *
19 * Also restructured routines so that there is more of a separation
20 * between the high-level tty routines (tty_io.c and tty_ioctl.c) and
21 * the low-level tty routines (serial.c, pty.c, console.c). This
Alan Cox37bdfb02008-02-08 04:18:47 -080022 * makes for cleaner and more compact code. -TYT, 9/17/92
Linus Torvalds1da177e2005-04-16 15:20:36 -070023 *
24 * Modified by Fred N. van Kempen, 01/29/93, to add line disciplines
25 * which can be dynamically activated and de-activated by the line
26 * discipline handling modules (like SLIP).
27 *
28 * NOTE: pay no attention to the line discipline code (yet); its
29 * interface is still subject to change in this version...
30 * -- TYT, 1/31/92
31 *
32 * Added functionality to the OPOST tty handling. No delays, but all
33 * other bits should be there.
34 * -- Nick Holloway <alfie@dcs.warwick.ac.uk>, 27th May 1993.
35 *
36 * Rewrote canonical mode and added more termios flags.
37 * -- julian@uhunix.uhcc.hawaii.edu (J. Cowley), 13Jan94
38 *
39 * Reorganized FASYNC support so mouse code can share it.
40 * -- ctm@ardi.com, 9Sep95
41 *
42 * New TIOCLINUX variants added.
43 * -- mj@k332.feld.cvut.cz, 19-Nov-95
Alan Cox37bdfb02008-02-08 04:18:47 -080044 *
Linus Torvalds1da177e2005-04-16 15:20:36 -070045 * Restrict vt switching via ioctl()
46 * -- grif@cs.ucr.edu, 5-Dec-95
47 *
48 * Move console and virtual terminal code to more appropriate files,
49 * implement CONFIG_VT and generalize console device interface.
50 * -- Marko Kohtala <Marko.Kohtala@hut.fi>, March 97
51 *
Alan Coxd81ed102008-10-13 10:41:42 +010052 * Rewrote tty_init_dev and tty_release_dev to eliminate races.
Linus Torvalds1da177e2005-04-16 15:20:36 -070053 * -- Bill Hawes <whawes@star.net>, June 97
54 *
55 * Added devfs support.
56 * -- C. Scott Ananian <cananian@alumni.princeton.edu>, 13-Jan-1998
57 *
58 * Added support for a Unix98-style ptmx device.
59 * -- C. Scott Ananian <cananian@alumni.princeton.edu>, 14-Jan-1998
60 *
61 * Reduced memory usage for older ARM systems
62 * -- Russell King <rmk@arm.linux.org.uk>
63 *
64 * Move do_SAK() into process context. Less stack use in devfs functions.
Alan Cox37bdfb02008-02-08 04:18:47 -080065 * alloc_tty_struct() always uses kmalloc()
66 * -- Andrew Morton <andrewm@uow.edu.eu> 17Mar01
Linus Torvalds1da177e2005-04-16 15:20:36 -070067 */
68
Linus Torvalds1da177e2005-04-16 15:20:36 -070069#include <linux/types.h>
70#include <linux/major.h>
71#include <linux/errno.h>
72#include <linux/signal.h>
73#include <linux/fcntl.h>
74#include <linux/sched.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>
Al Viro9f3acc32008-04-24 07:44:08 -040081#include <linux/fdtable.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070082#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/smp_lock.h>
94#include <linux/device.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070095#include <linux/wait.h>
96#include <linux/bitops.h>
Domen Puncerb20f3ae2005-06-25 14:58:42 -070097#include <linux/delay.h>
Alan Coxa352def2008-07-16 21:53:12 +010098#include <linux/seq_file.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070099
Alan Coxa352def2008-07-16 21:53:12 +0100100#include <linux/uaccess.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -0700101#include <asm/system.h>
102
103#include <linux/kbd_kern.h>
104#include <linux/vt_kern.h>
105#include <linux/selection.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -0700106
107#include <linux/kmod.h>
Pavel Emelyanovb4888932007-10-18 23:40:14 -0700108#include <linux/nsproxy.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -0700109
110#undef TTY_DEBUG_HANGUP
111
112#define TTY_PARANOIA_CHECK 1
113#define CHECK_TTY_COUNT 1
114
Alan Coxedc6afc2006-12-08 02:38:44 -0800115struct ktermios tty_std_termios = { /* for the benefit of tty drivers */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700116 .c_iflag = ICRNL | IXON,
117 .c_oflag = OPOST | ONLCR,
118 .c_cflag = B38400 | CS8 | CREAD | HUPCL,
119 .c_lflag = ISIG | ICANON | ECHO | ECHOE | ECHOK |
120 ECHOCTL | ECHOKE | IEXTEN,
Alan Coxedc6afc2006-12-08 02:38:44 -0800121 .c_cc = INIT_C_CC,
122 .c_ispeed = 38400,
123 .c_ospeed = 38400
Linus Torvalds1da177e2005-04-16 15:20:36 -0700124};
125
126EXPORT_SYMBOL(tty_std_termios);
127
128/* This list gets poked at by procfs and various bits of boot up code. This
129 could do with some rationalisation such as pulling the tty proc function
130 into this file */
Alan Cox37bdfb02008-02-08 04:18:47 -0800131
Linus Torvalds1da177e2005-04-16 15:20:36 -0700132LIST_HEAD(tty_drivers); /* linked list of tty drivers */
133
Peter Zijlstra24ec8392006-12-08 02:36:04 -0800134/* Mutex to protect creating and releasing a tty. This is shared with
Linus Torvalds1da177e2005-04-16 15:20:36 -0700135 vt.c for deeply disgusting hack reasons */
Ingo Molnar70522e12006-03-23 03:00:31 -0800136DEFINE_MUTEX(tty_mutex);
Alan Coxde2a84f2006-09-29 02:00:57 -0700137EXPORT_SYMBOL(tty_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700138
Linus Torvalds1da177e2005-04-16 15:20:36 -0700139static ssize_t tty_read(struct file *, char __user *, size_t, loff_t *);
140static ssize_t tty_write(struct file *, const char __user *, size_t, loff_t *);
Alan Cox37bdfb02008-02-08 04:18:47 -0800141ssize_t redirected_tty_write(struct file *, const char __user *,
142 size_t, loff_t *);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700143static unsigned int tty_poll(struct file *, poll_table *);
144static int tty_open(struct inode *, struct file *);
Alan Cox04f378b2008-04-30 00:53:29 -0700145long tty_ioctl(struct file *file, unsigned int cmd, unsigned long arg);
Paul Fulghume10cc1d2007-05-10 22:22:50 -0700146#ifdef CONFIG_COMPAT
Alan Cox37bdfb02008-02-08 04:18:47 -0800147static long tty_compat_ioctl(struct file *file, unsigned int cmd,
Paul Fulghume10cc1d2007-05-10 22:22:50 -0700148 unsigned long arg);
149#else
150#define tty_compat_ioctl NULL
151#endif
Arnd Bergmannec79d602010-06-01 22:53:01 +0200152static int __tty_fasync(int fd, struct file *filp, int on);
Alan Cox37bdfb02008-02-08 04:18:47 -0800153static int tty_fasync(int fd, struct file *filp, int on);
Christoph Hellwigd5698c22007-02-10 01:46:46 -0800154static void release_tty(struct tty_struct *tty, int idx);
Eric W. Biederman2a65f1d2007-05-08 00:26:53 -0700155static void __proc_set_tty(struct task_struct *tsk, struct tty_struct *tty);
Eric W. Biederman98a27ba2007-05-08 00:26:56 -0700156static void proc_set_tty(struct task_struct *tsk, struct tty_struct *tty);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700157
Alan Coxaf9b8972006-08-27 01:24:01 -0700158/**
159 * alloc_tty_struct - allocate a tty object
160 *
161 * Return a new empty tty structure. The data fields have not
162 * been initialized in any way but has been zeroed
163 *
164 * Locking: none
Alan Coxaf9b8972006-08-27 01:24:01 -0700165 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700166
Alan Coxbf970ee2008-10-13 10:42:39 +0100167struct tty_struct *alloc_tty_struct(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700168{
Alan Cox1266b1e2006-09-29 02:00:40 -0700169 return kzalloc(sizeof(struct tty_struct), GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700170}
171
Alan Coxaf9b8972006-08-27 01:24:01 -0700172/**
173 * free_tty_struct - free a disused tty
174 * @tty: tty struct to free
175 *
176 * Free the write buffers, tty queue and tty memory itself.
177 *
178 * Locking: none. Must be called after tty is definitely unused
179 */
180
Alan Coxbf970ee2008-10-13 10:42:39 +0100181void free_tty_struct(struct tty_struct *tty)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700182{
183 kfree(tty->write_buf);
Alan Cox33f0f882006-01-09 20:54:13 -0800184 tty_buffer_free_all(tty);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700185 kfree(tty);
186}
187
188#define TTY_NUMBER(tty) ((tty)->index + (tty)->driver->name_base)
189
Alan Coxaf9b8972006-08-27 01:24:01 -0700190/**
191 * tty_name - return tty naming
192 * @tty: tty structure
193 * @buf: buffer for output
194 *
195 * Convert a tty structure into a name. The name reflects the kernel
196 * naming policy and if udev is in use may not reflect user space
197 *
198 * Locking: none
199 */
200
Linus Torvalds1da177e2005-04-16 15:20:36 -0700201char *tty_name(struct tty_struct *tty, char *buf)
202{
203 if (!tty) /* Hmm. NULL pointer. That's fun. */
204 strcpy(buf, "NULL tty");
205 else
206 strcpy(buf, tty->name);
207 return buf;
208}
209
210EXPORT_SYMBOL(tty_name);
211
Andrew Mortond769a662005-05-05 16:15:50 -0700212int tty_paranoia_check(struct tty_struct *tty, struct inode *inode,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700213 const char *routine)
214{
215#ifdef TTY_PARANOIA_CHECK
216 if (!tty) {
217 printk(KERN_WARNING
218 "null TTY for (%d:%d) in %s\n",
219 imajor(inode), iminor(inode), routine);
220 return 1;
221 }
222 if (tty->magic != TTY_MAGIC) {
223 printk(KERN_WARNING
224 "bad magic number for tty struct (%d:%d) in %s\n",
225 imajor(inode), iminor(inode), routine);
226 return 1;
227 }
228#endif
229 return 0;
230}
231
232static int check_tty_count(struct tty_struct *tty, const char *routine)
233{
234#ifdef CHECK_TTY_COUNT
235 struct list_head *p;
236 int count = 0;
Alan Cox37bdfb02008-02-08 04:18:47 -0800237
Linus Torvalds1da177e2005-04-16 15:20:36 -0700238 file_list_lock();
239 list_for_each(p, &tty->tty_files) {
240 count++;
241 }
242 file_list_unlock();
243 if (tty->driver->type == TTY_DRIVER_TYPE_PTY &&
244 tty->driver->subtype == PTY_TYPE_SLAVE &&
245 tty->link && tty->link->count)
246 count++;
247 if (tty->count != count) {
248 printk(KERN_WARNING "Warning: dev (%s) tty->count(%d) "
249 "!= #fd's(%d) in %s\n",
250 tty->name, tty->count, count, routine);
251 return count;
Peter Zijlstra24ec8392006-12-08 02:36:04 -0800252 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700253#endif
254 return 0;
255}
256
Alan Coxaf9b8972006-08-27 01:24:01 -0700257/**
Alan Coxaf9b8972006-08-27 01:24:01 -0700258 * get_tty_driver - find device of a tty
259 * @dev_t: device identifier
260 * @index: returns the index of the tty
261 *
262 * This routine returns a tty driver structure, given a device number
263 * and also passes back the index number.
264 *
265 * Locking: caller must hold tty_mutex
Linus Torvalds1da177e2005-04-16 15:20:36 -0700266 */
Alan Coxaf9b8972006-08-27 01:24:01 -0700267
Linus Torvalds1da177e2005-04-16 15:20:36 -0700268static struct tty_driver *get_tty_driver(dev_t device, int *index)
269{
270 struct tty_driver *p;
271
272 list_for_each_entry(p, &tty_drivers, tty_drivers) {
273 dev_t base = MKDEV(p->major, p->minor_start);
274 if (device < base || device >= base + p->num)
275 continue;
276 *index = device - base;
Alan Cox7d7b93c2008-10-13 10:42:09 +0100277 return tty_driver_kref_get(p);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700278 }
279 return NULL;
280}
281
Jason Wesself2d937f2008-04-17 20:05:37 +0200282#ifdef CONFIG_CONSOLE_POLL
283
284/**
285 * tty_find_polling_driver - find device of a polled tty
286 * @name: name string to match
287 * @line: pointer to resulting tty line nr
288 *
289 * This routine returns a tty driver structure, given a name
290 * and the condition that the tty driver is capable of polled
291 * operation.
292 */
293struct tty_driver *tty_find_polling_driver(char *name, int *line)
294{
295 struct tty_driver *p, *res = NULL;
296 int tty_line = 0;
Jason Wessel0dca0fd2008-09-26 10:36:42 -0500297 int len;
Alan Cox5f0878a2009-06-11 12:46:41 +0100298 char *str, *stp;
Jason Wesself2d937f2008-04-17 20:05:37 +0200299
Jason Wessel0dca0fd2008-09-26 10:36:42 -0500300 for (str = name; *str; str++)
301 if ((*str >= '0' && *str <= '9') || *str == ',')
302 break;
303 if (!*str)
304 return NULL;
305
306 len = str - name;
307 tty_line = simple_strtoul(str, &str, 10);
308
Jason Wesself2d937f2008-04-17 20:05:37 +0200309 mutex_lock(&tty_mutex);
310 /* Search through the tty devices to look for a match */
311 list_for_each_entry(p, &tty_drivers, tty_drivers) {
Jason Wessel0dca0fd2008-09-26 10:36:42 -0500312 if (strncmp(name, p->name, len) != 0)
313 continue;
Alan Cox5f0878a2009-06-11 12:46:41 +0100314 stp = str;
315 if (*stp == ',')
316 stp++;
317 if (*stp == '\0')
318 stp = NULL;
Jason Wesself2d937f2008-04-17 20:05:37 +0200319
Alan Coxf34d7a52008-04-30 00:54:13 -0700320 if (tty_line >= 0 && tty_line <= p->num && p->ops &&
Alan Cox5f0878a2009-06-11 12:46:41 +0100321 p->ops->poll_init && !p->ops->poll_init(p, tty_line, stp)) {
Alan Cox7d7b93c2008-10-13 10:42:09 +0100322 res = tty_driver_kref_get(p);
Jason Wesself2d937f2008-04-17 20:05:37 +0200323 *line = tty_line;
324 break;
325 }
326 }
327 mutex_unlock(&tty_mutex);
328
329 return res;
330}
331EXPORT_SYMBOL_GPL(tty_find_polling_driver);
332#endif
333
Alan Coxaf9b8972006-08-27 01:24:01 -0700334/**
335 * tty_check_change - check for POSIX terminal changes
336 * @tty: tty to check
337 *
338 * If we try to write to, or set the state of, a terminal and we're
339 * not in the foreground, send a SIGTTOU. If the signal is blocked or
340 * ignored, go ahead and perform the operation. (POSIX 7.2)
341 *
Alan Cox978e5952008-04-30 00:53:59 -0700342 * Locking: ctrl_lock
Linus Torvalds1da177e2005-04-16 15:20:36 -0700343 */
Alan Coxaf9b8972006-08-27 01:24:01 -0700344
Alan Cox37bdfb02008-02-08 04:18:47 -0800345int tty_check_change(struct tty_struct *tty)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700346{
Alan Cox47f86832008-04-30 00:53:30 -0700347 unsigned long flags;
348 int ret = 0;
349
Linus Torvalds1da177e2005-04-16 15:20:36 -0700350 if (current->signal->tty != tty)
351 return 0;
Alan Cox47f86832008-04-30 00:53:30 -0700352
353 spin_lock_irqsave(&tty->ctrl_lock, flags);
354
Eric W. Biedermanab521dc2007-02-12 00:53:00 -0800355 if (!tty->pgrp) {
356 printk(KERN_WARNING "tty_check_change: tty->pgrp == NULL!\n");
Andrew Morton9ffee4c2008-05-14 16:05:58 -0700357 goto out_unlock;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700358 }
Eric W. Biedermanab521dc2007-02-12 00:53:00 -0800359 if (task_pgrp(current) == tty->pgrp)
Andrew Morton9ffee4c2008-05-14 16:05:58 -0700360 goto out_unlock;
361 spin_unlock_irqrestore(&tty->ctrl_lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700362 if (is_ignored(SIGTTOU))
Alan Cox47f86832008-04-30 00:53:30 -0700363 goto out;
364 if (is_current_pgrp_orphaned()) {
365 ret = -EIO;
366 goto out;
367 }
Oleg Nesterov040b6362007-06-01 00:46:53 -0700368 kill_pgrp(task_pgrp(current), SIGTTOU, 1);
369 set_thread_flag(TIF_SIGPENDING);
Alan Cox47f86832008-04-30 00:53:30 -0700370 ret = -ERESTARTSYS;
371out:
Andrew Morton9ffee4c2008-05-14 16:05:58 -0700372 return ret;
373out_unlock:
Alan Cox47f86832008-04-30 00:53:30 -0700374 spin_unlock_irqrestore(&tty->ctrl_lock, flags);
375 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700376}
377
378EXPORT_SYMBOL(tty_check_change);
379
Alan Cox37bdfb02008-02-08 04:18:47 -0800380static ssize_t hung_up_tty_read(struct file *file, char __user *buf,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700381 size_t count, loff_t *ppos)
382{
383 return 0;
384}
385
Alan Cox37bdfb02008-02-08 04:18:47 -0800386static ssize_t hung_up_tty_write(struct file *file, const char __user *buf,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700387 size_t count, loff_t *ppos)
388{
389 return -EIO;
390}
391
392/* No kernel lock held - none needed ;) */
Alan Cox37bdfb02008-02-08 04:18:47 -0800393static unsigned int hung_up_tty_poll(struct file *filp, poll_table *wait)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700394{
395 return POLLIN | POLLOUT | POLLERR | POLLHUP | POLLRDNORM | POLLWRNORM;
396}
397
Alan Cox04f378b2008-04-30 00:53:29 -0700398static long hung_up_tty_ioctl(struct file *file, unsigned int cmd,
399 unsigned long arg)
Paul Fulghum38ad2ed2007-06-16 10:15:55 -0700400{
401 return cmd == TIOCSPGRP ? -ENOTTY : -EIO;
402}
403
Alan Cox37bdfb02008-02-08 04:18:47 -0800404static long hung_up_tty_compat_ioctl(struct file *file,
Paul Fulghum38ad2ed2007-06-16 10:15:55 -0700405 unsigned int cmd, unsigned long arg)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700406{
407 return cmd == TIOCSPGRP ? -ENOTTY : -EIO;
408}
409
Arjan van de Ven62322d22006-07-03 00:24:21 -0700410static const struct file_operations tty_fops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700411 .llseek = no_llseek,
412 .read = tty_read,
413 .write = tty_write,
414 .poll = tty_poll,
Alan Cox04f378b2008-04-30 00:53:29 -0700415 .unlocked_ioctl = tty_ioctl,
Paul Fulghume10cc1d2007-05-10 22:22:50 -0700416 .compat_ioctl = tty_compat_ioctl,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700417 .open = tty_open,
418 .release = tty_release,
419 .fasync = tty_fasync,
420};
421
Arjan van de Ven62322d22006-07-03 00:24:21 -0700422static const struct file_operations console_fops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700423 .llseek = no_llseek,
424 .read = tty_read,
425 .write = redirected_tty_write,
426 .poll = tty_poll,
Alan Cox04f378b2008-04-30 00:53:29 -0700427 .unlocked_ioctl = tty_ioctl,
Paul Fulghume10cc1d2007-05-10 22:22:50 -0700428 .compat_ioctl = tty_compat_ioctl,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700429 .open = tty_open,
430 .release = tty_release,
431 .fasync = tty_fasync,
432};
433
Arjan van de Ven62322d22006-07-03 00:24:21 -0700434static const struct file_operations hung_up_tty_fops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700435 .llseek = no_llseek,
436 .read = hung_up_tty_read,
437 .write = hung_up_tty_write,
438 .poll = hung_up_tty_poll,
Alan Cox04f378b2008-04-30 00:53:29 -0700439 .unlocked_ioctl = hung_up_tty_ioctl,
Paul Fulghum38ad2ed2007-06-16 10:15:55 -0700440 .compat_ioctl = hung_up_tty_compat_ioctl,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700441 .release = tty_release,
442};
443
444static DEFINE_SPINLOCK(redirect_lock);
445static struct file *redirect;
446
447/**
448 * tty_wakeup - request more data
449 * @tty: terminal
450 *
451 * Internal and external helper for wakeups of tty. This function
452 * informs the line discipline if present that the driver is ready
453 * to receive more output data.
454 */
Alan Cox37bdfb02008-02-08 04:18:47 -0800455
Linus Torvalds1da177e2005-04-16 15:20:36 -0700456void tty_wakeup(struct tty_struct *tty)
457{
458 struct tty_ldisc *ld;
Alan Cox37bdfb02008-02-08 04:18:47 -0800459
Linus Torvalds1da177e2005-04-16 15:20:36 -0700460 if (test_bit(TTY_DO_WRITE_WAKEUP, &tty->flags)) {
461 ld = tty_ldisc_ref(tty);
Alan Cox37bdfb02008-02-08 04:18:47 -0800462 if (ld) {
Alan Coxa352def2008-07-16 21:53:12 +0100463 if (ld->ops->write_wakeup)
464 ld->ops->write_wakeup(tty);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700465 tty_ldisc_deref(ld);
466 }
467 }
Davide Libenzi4b194492009-03-31 15:24:24 -0700468 wake_up_interruptible_poll(&tty->write_wait, POLLOUT);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700469}
470
471EXPORT_SYMBOL_GPL(tty_wakeup);
472
473/**
Arnd Bergmann11dbf202010-06-18 14:58:07 +0200474 * __tty_hangup - actual handler for hangup events
David Howells65f27f32006-11-22 14:55:48 +0000475 * @work: tty device
Alan Coxaf9b8972006-08-27 01:24:01 -0700476 *
Alan Cox1bad8792008-07-22 23:38:04 +0100477 * This can be called by the "eventd" kernel thread. That is process
Alan Coxaf9b8972006-08-27 01:24:01 -0700478 * synchronous but doesn't hold any locks, so we need to make sure we
479 * have the appropriate locks for what we're doing.
480 *
481 * The hangup event clears any pending redirections onto the hung up
482 * device. It ensures future writes will error and it does the needed
483 * line discipline hangup and signal delivery. The tty object itself
484 * remains intact.
485 *
486 * Locking:
Arnd Bergmannec79d602010-06-01 22:53:01 +0200487 * BTM
Peter Zijlstra24ec8392006-12-08 02:36:04 -0800488 * redirect lock for undoing redirection
489 * file list lock for manipulating list of ttys
490 * tty_ldisc_lock from called functions
491 * termios_mutex resetting termios data
492 * tasklist_lock to walk task list for hangup event
493 * ->siglock to protect ->signal/->sighand
Linus Torvalds1da177e2005-04-16 15:20:36 -0700494 */
Arnd Bergmann11dbf202010-06-18 14:58:07 +0200495void __tty_hangup(struct tty_struct *tty)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700496{
Alan Cox37bdfb02008-02-08 04:18:47 -0800497 struct file *cons_filp = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700498 struct file *filp, *f = NULL;
499 struct task_struct *p;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700500 int closecount = 0, n;
Alan Cox47f86832008-04-30 00:53:30 -0700501 unsigned long flags;
Alan Cox9c9f4de2008-10-13 10:37:26 +0100502 int refs = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700503
504 if (!tty)
505 return;
506
Linus Torvalds1da177e2005-04-16 15:20:36 -0700507
508 spin_lock(&redirect_lock);
509 if (redirect && redirect->private_data == tty) {
510 f = redirect;
511 redirect = NULL;
512 }
513 spin_unlock(&redirect_lock);
Alan Cox37bdfb02008-02-08 04:18:47 -0800514
Arnd Bergmann11dbf202010-06-18 14:58:07 +0200515 tty_lock();
516
Arnd Bergmannec79d602010-06-01 22:53:01 +0200517 /* inuse_filps is protected by the single tty lock,
518 this really needs to change if we want to flush the
519 workqueue with the lock held */
Arnd Bergmann11dbf202010-06-18 14:58:07 +0200520 check_tty_count(tty, "tty_hangup");
Alan Cox36ba7822009-11-30 13:18:51 +0000521
Linus Torvalds1da177e2005-04-16 15:20:36 -0700522 file_list_lock();
523 /* This breaks for file handles being sent over AF_UNIX sockets ? */
Eric Dumazet2f512012005-10-30 15:02:16 -0800524 list_for_each_entry(filp, &tty->tty_files, f_u.fu_list) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700525 if (filp->f_op->write == redirected_tty_write)
526 cons_filp = filp;
527 if (filp->f_op->write != tty_write)
528 continue;
529 closecount++;
Arnd Bergmannec79d602010-06-01 22:53:01 +0200530 __tty_fasync(-1, filp, 0); /* can't block */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700531 filp->f_op = &hung_up_tty_fops;
532 }
533 file_list_unlock();
Alan Cox37bdfb02008-02-08 04:18:47 -0800534
Alan Coxc65c9bc2009-06-11 12:50:12 +0100535 tty_ldisc_hangup(tty);
Alan Cox37bdfb02008-02-08 04:18:47 -0800536
Linus Torvalds1da177e2005-04-16 15:20:36 -0700537 read_lock(&tasklist_lock);
Eric W. Biedermanab521dc2007-02-12 00:53:00 -0800538 if (tty->session) {
539 do_each_pid_task(tty->session, PIDTYPE_SID, p) {
Peter Zijlstra24ec8392006-12-08 02:36:04 -0800540 spin_lock_irq(&p->sighand->siglock);
Alan Cox9c9f4de2008-10-13 10:37:26 +0100541 if (p->signal->tty == tty) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700542 p->signal->tty = NULL;
Alan Cox9c9f4de2008-10-13 10:37:26 +0100543 /* We defer the dereferences outside fo
544 the tasklist lock */
545 refs++;
546 }
Peter Zijlstra24ec8392006-12-08 02:36:04 -0800547 if (!p->signal->leader) {
548 spin_unlock_irq(&p->sighand->siglock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700549 continue;
Peter Zijlstra24ec8392006-12-08 02:36:04 -0800550 }
551 __group_send_sig_info(SIGHUP, SEND_SIG_PRIV, p);
552 __group_send_sig_info(SIGCONT, SEND_SIG_PRIV, p);
Eric W. Biedermanab521dc2007-02-12 00:53:00 -0800553 put_pid(p->signal->tty_old_pgrp); /* A noop */
Alan Cox47f86832008-04-30 00:53:30 -0700554 spin_lock_irqsave(&tty->ctrl_lock, flags);
Eric W. Biedermanab521dc2007-02-12 00:53:00 -0800555 if (tty->pgrp)
556 p->signal->tty_old_pgrp = get_pid(tty->pgrp);
Alan Cox47f86832008-04-30 00:53:30 -0700557 spin_unlock_irqrestore(&tty->ctrl_lock, flags);
Peter Zijlstra24ec8392006-12-08 02:36:04 -0800558 spin_unlock_irq(&p->sighand->siglock);
Eric W. Biedermanab521dc2007-02-12 00:53:00 -0800559 } while_each_pid_task(tty->session, PIDTYPE_SID, p);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700560 }
561 read_unlock(&tasklist_lock);
562
Alan Cox47f86832008-04-30 00:53:30 -0700563 spin_lock_irqsave(&tty->ctrl_lock, flags);
Alan Coxc65c9bc2009-06-11 12:50:12 +0100564 clear_bit(TTY_THROTTLED, &tty->flags);
565 clear_bit(TTY_PUSH, &tty->flags);
566 clear_bit(TTY_DO_WRITE_WAKEUP, &tty->flags);
Eric W. Biedermand9c1e9a2007-03-18 12:45:44 -0600567 put_pid(tty->session);
568 put_pid(tty->pgrp);
Eric W. Biedermanab521dc2007-02-12 00:53:00 -0800569 tty->session = NULL;
570 tty->pgrp = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700571 tty->ctrl_status = 0;
Alan Coxc65c9bc2009-06-11 12:50:12 +0100572 set_bit(TTY_HUPPED, &tty->flags);
Alan Cox47f86832008-04-30 00:53:30 -0700573 spin_unlock_irqrestore(&tty->ctrl_lock, flags);
574
Alan Cox9c9f4de2008-10-13 10:37:26 +0100575 /* Account for the p->signal references we killed */
576 while (refs--)
577 tty_kref_put(tty);
578
Linus Torvalds1da177e2005-04-16 15:20:36 -0700579 /*
Alan Cox37bdfb02008-02-08 04:18:47 -0800580 * If one of the devices matches a console pointer, we
581 * cannot just call hangup() because that will cause
582 * tty->count and state->count to go out of sync.
583 * So we just call close() the right number of times.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700584 */
585 if (cons_filp) {
Alan Coxf34d7a52008-04-30 00:54:13 -0700586 if (tty->ops->close)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700587 for (n = 0; n < closecount; n++)
Alan Coxf34d7a52008-04-30 00:54:13 -0700588 tty->ops->close(tty, cons_filp);
589 } else if (tty->ops->hangup)
590 (tty->ops->hangup)(tty);
Alan Cox37bdfb02008-02-08 04:18:47 -0800591 /*
592 * We don't want to have driver/ldisc interactions beyond
593 * the ones we did here. The driver layer expects no
594 * calls after ->hangup() from the ldisc side. However we
595 * can't yet guarantee all that.
596 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700597 set_bit(TTY_HUPPED, &tty->flags);
Alan Coxc65c9bc2009-06-11 12:50:12 +0100598 tty_ldisc_enable(tty);
Arnd Bergmann11dbf202010-06-18 14:58:07 +0200599
600 tty_unlock();
601
Linus Torvalds1da177e2005-04-16 15:20:36 -0700602 if (f)
603 fput(f);
604}
605
Arnd Bergmannddcd9fb2010-06-01 22:53:08 +0200606static void do_tty_hangup(struct work_struct *work)
607{
608 struct tty_struct *tty =
609 container_of(work, struct tty_struct, hangup_work);
610
Arnd Bergmann11dbf202010-06-18 14:58:07 +0200611 __tty_hangup(tty);
Arnd Bergmannddcd9fb2010-06-01 22:53:08 +0200612}
613
Alan Coxaf9b8972006-08-27 01:24:01 -0700614/**
615 * tty_hangup - trigger a hangup event
616 * @tty: tty to hangup
617 *
618 * A carrier loss (virtual or otherwise) has occurred on this like
619 * schedule a hangup sequence to run after this event.
620 */
621
Alan Cox37bdfb02008-02-08 04:18:47 -0800622void tty_hangup(struct tty_struct *tty)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700623{
624#ifdef TTY_DEBUG_HANGUP
625 char buf[64];
Linus Torvalds1da177e2005-04-16 15:20:36 -0700626 printk(KERN_DEBUG "%s hangup...\n", tty_name(tty, buf));
627#endif
628 schedule_work(&tty->hangup_work);
629}
630
631EXPORT_SYMBOL(tty_hangup);
632
Alan Coxaf9b8972006-08-27 01:24:01 -0700633/**
634 * tty_vhangup - process vhangup
635 * @tty: tty to hangup
636 *
637 * The user has asked via system call for the terminal to be hung up.
638 * We do this synchronously so that when the syscall returns the process
Robert P. J. Day3a4fa0a2007-10-19 23:10:43 +0200639 * is complete. That guarantee is necessary for security reasons.
Alan Coxaf9b8972006-08-27 01:24:01 -0700640 */
641
Alan Cox37bdfb02008-02-08 04:18:47 -0800642void tty_vhangup(struct tty_struct *tty)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700643{
644#ifdef TTY_DEBUG_HANGUP
645 char buf[64];
646
647 printk(KERN_DEBUG "%s vhangup...\n", tty_name(tty, buf));
648#endif
Arnd Bergmann11dbf202010-06-18 14:58:07 +0200649 __tty_hangup(tty);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700650}
Alan Cox37bdfb02008-02-08 04:18:47 -0800651
Linus Torvalds1da177e2005-04-16 15:20:36 -0700652EXPORT_SYMBOL(tty_vhangup);
653
Arnd Bergmann11dbf202010-06-18 14:58:07 +0200654
Alan Coxaf9b8972006-08-27 01:24:01 -0700655/**
Alan Cox2cb59982008-10-13 10:40:30 +0100656 * tty_vhangup_self - process vhangup for own ctty
657 *
658 * Perform a vhangup on the current controlling tty
659 */
660
661void tty_vhangup_self(void)
662{
663 struct tty_struct *tty;
664
Alan Cox2cb59982008-10-13 10:40:30 +0100665 tty = get_current_tty();
666 if (tty) {
667 tty_vhangup(tty);
668 tty_kref_put(tty);
669 }
Alan Cox2cb59982008-10-13 10:40:30 +0100670}
671
672/**
Alan Coxaf9b8972006-08-27 01:24:01 -0700673 * tty_hung_up_p - was tty hung up
674 * @filp: file pointer of tty
675 *
676 * Return true if the tty has been subject to a vhangup or a carrier
677 * loss
678 */
679
Alan Cox37bdfb02008-02-08 04:18:47 -0800680int tty_hung_up_p(struct file *filp)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700681{
682 return (filp->f_op == &hung_up_tty_fops);
683}
684
685EXPORT_SYMBOL(tty_hung_up_p);
686
Eric W. Biedermanab521dc2007-02-12 00:53:00 -0800687static void session_clear_tty(struct pid *session)
Peter Zijlstra24ec8392006-12-08 02:36:04 -0800688{
689 struct task_struct *p;
Eric W. Biedermanab521dc2007-02-12 00:53:00 -0800690 do_each_pid_task(session, PIDTYPE_SID, p) {
Peter Zijlstra24ec8392006-12-08 02:36:04 -0800691 proc_clear_tty(p);
Eric W. Biedermanab521dc2007-02-12 00:53:00 -0800692 } while_each_pid_task(session, PIDTYPE_SID, p);
Peter Zijlstra24ec8392006-12-08 02:36:04 -0800693}
694
Alan Coxaf9b8972006-08-27 01:24:01 -0700695/**
696 * disassociate_ctty - disconnect controlling tty
697 * @on_exit: true if exiting so need to "hang up" the session
Linus Torvalds1da177e2005-04-16 15:20:36 -0700698 *
Alan Coxaf9b8972006-08-27 01:24:01 -0700699 * This function is typically called only by the session leader, when
700 * it wants to disassociate itself from its controlling tty.
701 *
702 * It performs the following functions:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700703 * (1) Sends a SIGHUP and SIGCONT to the foreground process group
704 * (2) Clears the tty from being controlling the session
705 * (3) Clears the controlling tty for all processes in the
706 * session group.
707 *
Alan Coxaf9b8972006-08-27 01:24:01 -0700708 * The argument on_exit is set to 1 if called when a process is
709 * exiting; it is 0 if called by the ioctl TIOCNOTTY.
710 *
Peter Zijlstra24ec8392006-12-08 02:36:04 -0800711 * Locking:
Arnd Bergmannec79d602010-06-01 22:53:01 +0200712 * BTM is taken for hysterical raisins, and held when
713 * called from no_tty().
Peter Zijlstra24ec8392006-12-08 02:36:04 -0800714 * tty_mutex is taken to protect tty
715 * ->siglock is taken to protect ->signal/->sighand
716 * tasklist_lock is taken to walk process list for sessions
717 * ->siglock is taken to protect ->signal/->sighand
Linus Torvalds1da177e2005-04-16 15:20:36 -0700718 */
Alan Coxaf9b8972006-08-27 01:24:01 -0700719
Linus Torvalds1da177e2005-04-16 15:20:36 -0700720void disassociate_ctty(int on_exit)
721{
722 struct tty_struct *tty;
Eric W. Biedermanab521dc2007-02-12 00:53:00 -0800723 struct pid *tty_pgrp = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700724
Alan Cox5ec93d12009-11-30 13:18:45 +0000725 if (!current->signal->leader)
726 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700727
Peter Zijlstra24ec8392006-12-08 02:36:04 -0800728 tty = get_current_tty();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700729 if (tty) {
Eric W. Biedermanab521dc2007-02-12 00:53:00 -0800730 tty_pgrp = get_pid(tty->pgrp);
Arnd Bergmannddcd9fb2010-06-01 22:53:08 +0200731 if (on_exit) {
Arnd Bergmannddcd9fb2010-06-01 22:53:08 +0200732 if (tty->driver->type != TTY_DRIVER_TYPE_PTY)
Arnd Bergmann11dbf202010-06-18 14:58:07 +0200733 tty_vhangup(tty);
Arnd Bergmannddcd9fb2010-06-01 22:53:08 +0200734 }
Alan Cox452a00d2008-10-13 10:39:13 +0100735 tty_kref_put(tty);
Eric W. Biederman680a9672007-02-12 00:52:52 -0800736 } else if (on_exit) {
Eric W. Biedermanab521dc2007-02-12 00:53:00 -0800737 struct pid *old_pgrp;
Eric W. Biederman680a9672007-02-12 00:52:52 -0800738 spin_lock_irq(&current->sighand->siglock);
739 old_pgrp = current->signal->tty_old_pgrp;
Eric W. Biedermanab521dc2007-02-12 00:53:00 -0800740 current->signal->tty_old_pgrp = NULL;
Eric W. Biederman680a9672007-02-12 00:52:52 -0800741 spin_unlock_irq(&current->sighand->siglock);
Peter Zijlstra24ec8392006-12-08 02:36:04 -0800742 if (old_pgrp) {
Eric W. Biedermanab521dc2007-02-12 00:53:00 -0800743 kill_pgrp(old_pgrp, SIGHUP, on_exit);
744 kill_pgrp(old_pgrp, SIGCONT, on_exit);
745 put_pid(old_pgrp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700746 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700747 return;
748 }
Eric W. Biedermanab521dc2007-02-12 00:53:00 -0800749 if (tty_pgrp) {
750 kill_pgrp(tty_pgrp, SIGHUP, on_exit);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700751 if (!on_exit)
Eric W. Biedermanab521dc2007-02-12 00:53:00 -0800752 kill_pgrp(tty_pgrp, SIGCONT, on_exit);
753 put_pid(tty_pgrp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700754 }
755
Peter Zijlstra24ec8392006-12-08 02:36:04 -0800756 spin_lock_irq(&current->sighand->siglock);
Eric W. Biederman2a65f1d2007-05-08 00:26:53 -0700757 put_pid(current->signal->tty_old_pgrp);
Randy Dunlap23cac8d2007-02-20 13:58:05 -0800758 current->signal->tty_old_pgrp = NULL;
Peter Zijlstra24ec8392006-12-08 02:36:04 -0800759 spin_unlock_irq(&current->sighand->siglock);
760
Peter Zijlstra24ec8392006-12-08 02:36:04 -0800761 tty = get_current_tty();
762 if (tty) {
Alan Cox47f86832008-04-30 00:53:30 -0700763 unsigned long flags;
764 spin_lock_irqsave(&tty->ctrl_lock, flags);
Eric W. Biedermanab521dc2007-02-12 00:53:00 -0800765 put_pid(tty->session);
766 put_pid(tty->pgrp);
767 tty->session = NULL;
768 tty->pgrp = NULL;
Alan Cox47f86832008-04-30 00:53:30 -0700769 spin_unlock_irqrestore(&tty->ctrl_lock, flags);
Alan Cox452a00d2008-10-13 10:39:13 +0100770 tty_kref_put(tty);
Peter Zijlstra24ec8392006-12-08 02:36:04 -0800771 } else {
772#ifdef TTY_DEBUG_HANGUP
773 printk(KERN_DEBUG "error attempted to write to tty [0x%p]"
774 " = NULL", tty);
775#endif
776 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700777
778 /* Now clear signal->tty under the lock */
779 read_lock(&tasklist_lock);
Eric W. Biedermanab521dc2007-02-12 00:53:00 -0800780 session_clear_tty(task_session(current));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700781 read_unlock(&tasklist_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700782}
783
Eric W. Biederman98a27ba2007-05-08 00:26:56 -0700784/**
785 *
786 * no_tty - Ensure the current process does not have a controlling tty
787 */
788void no_tty(void)
789{
790 struct task_struct *tsk = current;
Arnd Bergmannec79d602010-06-01 22:53:01 +0200791 tty_lock();
Alan Cox5ec93d12009-11-30 13:18:45 +0000792 disassociate_ctty(0);
Arnd Bergmannec79d602010-06-01 22:53:01 +0200793 tty_unlock();
Eric W. Biederman98a27ba2007-05-08 00:26:56 -0700794 proc_clear_tty(tsk);
795}
796
Alan Coxaf9b8972006-08-27 01:24:01 -0700797
798/**
Robert P. J. Daybeb7dd82007-05-09 07:14:03 +0200799 * stop_tty - propagate flow control
Alan Coxaf9b8972006-08-27 01:24:01 -0700800 * @tty: tty to stop
801 *
802 * Perform flow control to the driver. For PTY/TTY pairs we
Robert P. J. Daybeb7dd82007-05-09 07:14:03 +0200803 * must also propagate the TIOCKPKT status. May be called
Alan Coxaf9b8972006-08-27 01:24:01 -0700804 * on an already stopped device and will not re-call the driver
805 * method.
806 *
807 * This functionality is used by both the line disciplines for
808 * halting incoming flow and by the driver. It may therefore be
809 * called from any context, may be under the tty atomic_write_lock
810 * but not always.
811 *
812 * Locking:
Alan Cox04f378b2008-04-30 00:53:29 -0700813 * Uses the tty control lock internally
Alan Coxaf9b8972006-08-27 01:24:01 -0700814 */
815
Linus Torvalds1da177e2005-04-16 15:20:36 -0700816void stop_tty(struct tty_struct *tty)
817{
Alan Cox04f378b2008-04-30 00:53:29 -0700818 unsigned long flags;
819 spin_lock_irqsave(&tty->ctrl_lock, flags);
820 if (tty->stopped) {
821 spin_unlock_irqrestore(&tty->ctrl_lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700822 return;
Alan Cox04f378b2008-04-30 00:53:29 -0700823 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700824 tty->stopped = 1;
825 if (tty->link && tty->link->packet) {
826 tty->ctrl_status &= ~TIOCPKT_START;
827 tty->ctrl_status |= TIOCPKT_STOP;
Davide Libenzi4b194492009-03-31 15:24:24 -0700828 wake_up_interruptible_poll(&tty->link->read_wait, POLLIN);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700829 }
Alan Cox04f378b2008-04-30 00:53:29 -0700830 spin_unlock_irqrestore(&tty->ctrl_lock, flags);
Alan Coxf34d7a52008-04-30 00:54:13 -0700831 if (tty->ops->stop)
832 (tty->ops->stop)(tty);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700833}
834
835EXPORT_SYMBOL(stop_tty);
836
Alan Coxaf9b8972006-08-27 01:24:01 -0700837/**
Robert P. J. Daybeb7dd82007-05-09 07:14:03 +0200838 * start_tty - propagate flow control
Alan Coxaf9b8972006-08-27 01:24:01 -0700839 * @tty: tty to start
840 *
841 * Start a tty that has been stopped if at all possible. Perform
Robert P. J. Day3a4fa0a2007-10-19 23:10:43 +0200842 * any necessary wakeups and propagate the TIOCPKT status. If this
Alan Coxaf9b8972006-08-27 01:24:01 -0700843 * is the tty was previous stopped and is being started then the
844 * driver start method is invoked and the line discipline woken.
845 *
846 * Locking:
Alan Cox04f378b2008-04-30 00:53:29 -0700847 * ctrl_lock
Alan Coxaf9b8972006-08-27 01:24:01 -0700848 */
849
Linus Torvalds1da177e2005-04-16 15:20:36 -0700850void start_tty(struct tty_struct *tty)
851{
Alan Cox04f378b2008-04-30 00:53:29 -0700852 unsigned long flags;
853 spin_lock_irqsave(&tty->ctrl_lock, flags);
854 if (!tty->stopped || tty->flow_stopped) {
855 spin_unlock_irqrestore(&tty->ctrl_lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700856 return;
Alan Cox04f378b2008-04-30 00:53:29 -0700857 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700858 tty->stopped = 0;
859 if (tty->link && tty->link->packet) {
860 tty->ctrl_status &= ~TIOCPKT_STOP;
861 tty->ctrl_status |= TIOCPKT_START;
Davide Libenzi4b194492009-03-31 15:24:24 -0700862 wake_up_interruptible_poll(&tty->link->read_wait, POLLIN);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700863 }
Alan Cox04f378b2008-04-30 00:53:29 -0700864 spin_unlock_irqrestore(&tty->ctrl_lock, flags);
Alan Coxf34d7a52008-04-30 00:54:13 -0700865 if (tty->ops->start)
866 (tty->ops->start)(tty);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700867 /* If we have a running line discipline it may need kicking */
868 tty_wakeup(tty);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700869}
870
871EXPORT_SYMBOL(start_tty);
872
Alan Coxaf9b8972006-08-27 01:24:01 -0700873/**
874 * tty_read - read method for tty device files
875 * @file: pointer to tty file
876 * @buf: user buffer
877 * @count: size of user buffer
878 * @ppos: unused
879 *
880 * Perform the read system call function on this terminal device. Checks
881 * for hung up devices before calling the line discipline method.
882 *
883 * Locking:
Alan Cox47f86832008-04-30 00:53:30 -0700884 * Locks the line discipline internally while needed. Multiple
885 * read calls may be outstanding in parallel.
Alan Coxaf9b8972006-08-27 01:24:01 -0700886 */
887
Alan Cox37bdfb02008-02-08 04:18:47 -0800888static ssize_t tty_read(struct file *file, char __user *buf, size_t count,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700889 loff_t *ppos)
890{
891 int i;
Alan Cox37bdfb02008-02-08 04:18:47 -0800892 struct tty_struct *tty;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700893 struct inode *inode;
894 struct tty_ldisc *ld;
895
896 tty = (struct tty_struct *)file->private_data;
Josef Sipeka7113a92006-12-08 02:36:55 -0800897 inode = file->f_path.dentry->d_inode;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700898 if (tty_paranoia_check(tty, inode, "tty_read"))
899 return -EIO;
900 if (!tty || (test_bit(TTY_IO_ERROR, &tty->flags)))
901 return -EIO;
902
903 /* We want to wait for the line discipline to sort out in this
904 situation */
905 ld = tty_ldisc_ref_wait(tty);
Alan Coxa352def2008-07-16 21:53:12 +0100906 if (ld->ops->read)
907 i = (ld->ops->read)(tty, file, buf, count);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700908 else
909 i = -EIO;
910 tty_ldisc_deref(ld);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700911 if (i > 0)
912 inode->i_atime = current_fs_time(inode->i_sb);
913 return i;
914}
915
Alan Cox9c1729d2007-07-15 23:39:43 -0700916void tty_write_unlock(struct tty_struct *tty)
917{
918 mutex_unlock(&tty->atomic_write_lock);
Davide Libenzi4b194492009-03-31 15:24:24 -0700919 wake_up_interruptible_poll(&tty->write_wait, POLLOUT);
Alan Cox9c1729d2007-07-15 23:39:43 -0700920}
921
922int tty_write_lock(struct tty_struct *tty, int ndelay)
923{
924 if (!mutex_trylock(&tty->atomic_write_lock)) {
925 if (ndelay)
926 return -EAGAIN;
927 if (mutex_lock_interruptible(&tty->atomic_write_lock))
928 return -ERESTARTSYS;
929 }
930 return 0;
931}
932
Linus Torvalds1da177e2005-04-16 15:20:36 -0700933/*
934 * Split writes up in sane blocksizes to avoid
935 * denial-of-service type attacks
936 */
937static inline ssize_t do_tty_write(
938 ssize_t (*write)(struct tty_struct *, struct file *, const unsigned char *, size_t),
939 struct tty_struct *tty,
940 struct file *file,
941 const char __user *buf,
942 size_t count)
943{
Alan Cox9c1729d2007-07-15 23:39:43 -0700944 ssize_t ret, written = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700945 unsigned int chunk;
Alan Cox37bdfb02008-02-08 04:18:47 -0800946
Alan Cox9c1729d2007-07-15 23:39:43 -0700947 ret = tty_write_lock(tty, file->f_flags & O_NDELAY);
948 if (ret < 0)
949 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700950
951 /*
952 * We chunk up writes into a temporary buffer. This
953 * simplifies low-level drivers immensely, since they
954 * don't have locking issues and user mode accesses.
955 *
956 * But if TTY_NO_WRITE_SPLIT is set, we should use a
957 * big chunk-size..
958 *
959 * The default chunk-size is 2kB, because the NTTY
960 * layer has problems with bigger chunks. It will
961 * claim to be able to handle more characters than
962 * it actually does.
Alan Coxaf9b8972006-08-27 01:24:01 -0700963 *
964 * FIXME: This can probably go away now except that 64K chunks
965 * are too likely to fail unless switched to vmalloc...
Linus Torvalds1da177e2005-04-16 15:20:36 -0700966 */
967 chunk = 2048;
968 if (test_bit(TTY_NO_WRITE_SPLIT, &tty->flags))
969 chunk = 65536;
970 if (count < chunk)
971 chunk = count;
972
Ingo Molnar70522e12006-03-23 03:00:31 -0800973 /* write_buf/write_cnt is protected by the atomic_write_lock mutex */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700974 if (tty->write_cnt < chunk) {
Jason Wessel402fda92008-10-13 10:45:36 +0100975 unsigned char *buf_chunk;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700976
977 if (chunk < 1024)
978 chunk = 1024;
979
Jason Wessel402fda92008-10-13 10:45:36 +0100980 buf_chunk = kmalloc(chunk, GFP_KERNEL);
981 if (!buf_chunk) {
Alan Cox9c1729d2007-07-15 23:39:43 -0700982 ret = -ENOMEM;
983 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700984 }
985 kfree(tty->write_buf);
986 tty->write_cnt = chunk;
Jason Wessel402fda92008-10-13 10:45:36 +0100987 tty->write_buf = buf_chunk;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700988 }
989
990 /* Do the write .. */
991 for (;;) {
992 size_t size = count;
993 if (size > chunk)
994 size = chunk;
995 ret = -EFAULT;
996 if (copy_from_user(tty->write_buf, buf, size))
997 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700998 ret = write(tty, file, tty->write_buf, size);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700999 if (ret <= 0)
1000 break;
1001 written += ret;
1002 buf += ret;
1003 count -= ret;
1004 if (!count)
1005 break;
1006 ret = -ERESTARTSYS;
1007 if (signal_pending(current))
1008 break;
1009 cond_resched();
1010 }
1011 if (written) {
Josef Sipeka7113a92006-12-08 02:36:55 -08001012 struct inode *inode = file->f_path.dentry->d_inode;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001013 inode->i_mtime = current_fs_time(inode->i_sb);
1014 ret = written;
1015 }
Alan Cox9c1729d2007-07-15 23:39:43 -07001016out:
1017 tty_write_unlock(tty);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001018 return ret;
1019}
1020
Alan Cox95f9bfc2008-10-13 10:39:23 +01001021/**
1022 * tty_write_message - write a message to a certain tty, not just the console.
1023 * @tty: the destination tty_struct
1024 * @msg: the message to write
1025 *
1026 * This is used for messages that need to be redirected to a specific tty.
1027 * We don't put it into the syslog queue right now maybe in the future if
1028 * really needed.
1029 *
Arnd Bergmannec79d602010-06-01 22:53:01 +02001030 * We must still hold the BTM and test the CLOSING flag for the moment.
Alan Cox95f9bfc2008-10-13 10:39:23 +01001031 */
1032
1033void tty_write_message(struct tty_struct *tty, char *msg)
1034{
Alan Cox95f9bfc2008-10-13 10:39:23 +01001035 if (tty) {
1036 mutex_lock(&tty->atomic_write_lock);
Arnd Bergmannec79d602010-06-01 22:53:01 +02001037 tty_lock();
Alan Coxeeb89d92009-11-30 13:18:29 +00001038 if (tty->ops->write && !test_bit(TTY_CLOSING, &tty->flags)) {
Arnd Bergmannec79d602010-06-01 22:53:01 +02001039 tty_unlock();
Alan Cox95f9bfc2008-10-13 10:39:23 +01001040 tty->ops->write(tty, msg, strlen(msg));
Alan Coxeeb89d92009-11-30 13:18:29 +00001041 } else
Arnd Bergmannec79d602010-06-01 22:53:01 +02001042 tty_unlock();
Alan Cox95f9bfc2008-10-13 10:39:23 +01001043 tty_write_unlock(tty);
1044 }
Alan Cox95f9bfc2008-10-13 10:39:23 +01001045 return;
1046}
1047
Linus Torvalds1da177e2005-04-16 15:20:36 -07001048
Alan Coxaf9b8972006-08-27 01:24:01 -07001049/**
1050 * tty_write - write method for tty device file
1051 * @file: tty file pointer
1052 * @buf: user data to write
1053 * @count: bytes to write
1054 * @ppos: unused
1055 *
1056 * Write data to a tty device via the line discipline.
1057 *
1058 * Locking:
1059 * Locks the line discipline as required
1060 * Writes to the tty driver are serialized by the atomic_write_lock
1061 * and are then processed in chunks to the device. The line discipline
Joe Petersona88a69c2009-01-02 13:40:53 +00001062 * write method will not be invoked in parallel for each device.
Alan Coxaf9b8972006-08-27 01:24:01 -07001063 */
1064
Alan Cox37bdfb02008-02-08 04:18:47 -08001065static ssize_t tty_write(struct file *file, const char __user *buf,
1066 size_t count, loff_t *ppos)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001067{
Alan Cox37bdfb02008-02-08 04:18:47 -08001068 struct tty_struct *tty;
Josef Sipeka7113a92006-12-08 02:36:55 -08001069 struct inode *inode = file->f_path.dentry->d_inode;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001070 ssize_t ret;
1071 struct tty_ldisc *ld;
Alan Cox37bdfb02008-02-08 04:18:47 -08001072
Linus Torvalds1da177e2005-04-16 15:20:36 -07001073 tty = (struct tty_struct *)file->private_data;
1074 if (tty_paranoia_check(tty, inode, "tty_write"))
1075 return -EIO;
Alan Coxf34d7a52008-04-30 00:54:13 -07001076 if (!tty || !tty->ops->write ||
Alan Cox37bdfb02008-02-08 04:18:47 -08001077 (test_bit(TTY_IO_ERROR, &tty->flags)))
1078 return -EIO;
Alan Coxf34d7a52008-04-30 00:54:13 -07001079 /* Short term debug to catch buggy drivers */
1080 if (tty->ops->write_room == NULL)
1081 printk(KERN_ERR "tty driver %s lacks a write_room method.\n",
1082 tty->driver->name);
Alan Cox37bdfb02008-02-08 04:18:47 -08001083 ld = tty_ldisc_ref_wait(tty);
Alan Coxa352def2008-07-16 21:53:12 +01001084 if (!ld->ops->write)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001085 ret = -EIO;
1086 else
Alan Coxa352def2008-07-16 21:53:12 +01001087 ret = do_tty_write(ld->ops->write, tty, file, buf, count);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001088 tty_ldisc_deref(ld);
1089 return ret;
1090}
1091
Alan Cox37bdfb02008-02-08 04:18:47 -08001092ssize_t redirected_tty_write(struct file *file, const char __user *buf,
1093 size_t count, loff_t *ppos)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001094{
1095 struct file *p = NULL;
1096
1097 spin_lock(&redirect_lock);
1098 if (redirect) {
1099 get_file(redirect);
1100 p = redirect;
1101 }
1102 spin_unlock(&redirect_lock);
1103
1104 if (p) {
1105 ssize_t res;
1106 res = vfs_write(p, buf, count, &p->f_pos);
1107 fput(p);
1108 return res;
1109 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001110 return tty_write(file, buf, count, ppos);
1111}
1112
1113static char ptychar[] = "pqrstuvwxyzabcde";
1114
Alan Coxaf9b8972006-08-27 01:24:01 -07001115/**
1116 * pty_line_name - generate name for a pty
1117 * @driver: the tty driver in use
1118 * @index: the minor number
1119 * @p: output buffer of at least 6 bytes
1120 *
1121 * Generate a name from a driver reference and write it to the output
1122 * buffer.
1123 *
1124 * Locking: None
1125 */
1126static void pty_line_name(struct tty_driver *driver, int index, char *p)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001127{
1128 int i = index + driver->name_base;
1129 /* ->name is initialized to "ttyp", but "tty" is expected */
1130 sprintf(p, "%s%c%x",
Alan Cox37bdfb02008-02-08 04:18:47 -08001131 driver->subtype == PTY_TYPE_SLAVE ? "tty" : driver->name,
1132 ptychar[i >> 4 & 0xf], i & 0xf);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001133}
1134
Alan Coxaf9b8972006-08-27 01:24:01 -07001135/**
Alan Cox8b0a88d2008-10-13 10:42:19 +01001136 * tty_line_name - generate name for a tty
Alan Coxaf9b8972006-08-27 01:24:01 -07001137 * @driver: the tty driver in use
1138 * @index: the minor number
1139 * @p: output buffer of at least 7 bytes
1140 *
1141 * Generate a name from a driver reference and write it to the output
1142 * buffer.
1143 *
1144 * Locking: None
1145 */
1146static void tty_line_name(struct tty_driver *driver, int index, char *p)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001147{
1148 sprintf(p, "%s%d", driver->name, index + driver->name_base);
1149}
1150
Alan Cox99f1fe12008-10-13 10:42:00 +01001151/**
1152 * tty_driver_lookup_tty() - find an existing tty, if any
1153 * @driver: the driver for the tty
1154 * @idx: the minor number
Sukadev Bhattiprolu23499702008-10-13 10:41:51 +01001155 *
Alan Cox99f1fe12008-10-13 10:42:00 +01001156 * Return the tty, if found or ERR_PTR() otherwise.
Sukadev Bhattiprolu23499702008-10-13 10:41:51 +01001157 *
Alan Cox99f1fe12008-10-13 10:42:00 +01001158 * Locking: tty_mutex must be held. If tty is found, the mutex must
1159 * be held until the 'fast-open' is also done. Will change once we
1160 * have refcounting in the driver and per driver locking
Sukadev Bhattiprolu23499702008-10-13 10:41:51 +01001161 */
Jason Wessela47d5452009-01-02 13:43:04 +00001162static struct tty_struct *tty_driver_lookup_tty(struct tty_driver *driver,
Sukadev Bhattiprolu15f1a632008-10-13 10:42:59 +01001163 struct inode *inode, int idx)
Sukadev Bhattiprolu23499702008-10-13 10:41:51 +01001164{
1165 struct tty_struct *tty;
1166
Alan Cox99f1fe12008-10-13 10:42:00 +01001167 if (driver->ops->lookup)
Sukadev Bhattiprolu15f1a632008-10-13 10:42:59 +01001168 return driver->ops->lookup(driver, inode, idx);
Sukadev Bhattiprolu23499702008-10-13 10:41:51 +01001169
Alan Cox8b0a88d2008-10-13 10:42:19 +01001170 tty = driver->ttys[idx];
Sukadev Bhattiprolu23499702008-10-13 10:41:51 +01001171 return tty;
1172}
1173
Alan Cox99f1fe12008-10-13 10:42:00 +01001174/**
Alan Coxbf970ee2008-10-13 10:42:39 +01001175 * tty_init_termios - helper for termios setup
1176 * @tty: the tty to set up
1177 *
1178 * Initialise the termios structures for this tty. Thus runs under
1179 * the tty_mutex currently so we can be relaxed about ordering.
1180 */
1181
1182int tty_init_termios(struct tty_struct *tty)
1183{
Alan Coxfe6e29f2008-10-13 10:44:08 +01001184 struct ktermios *tp;
Alan Coxbf970ee2008-10-13 10:42:39 +01001185 int idx = tty->index;
1186
1187 tp = tty->driver->termios[idx];
Alan Coxbf970ee2008-10-13 10:42:39 +01001188 if (tp == NULL) {
Alan Coxfe6e29f2008-10-13 10:44:08 +01001189 tp = kzalloc(sizeof(struct ktermios[2]), GFP_KERNEL);
1190 if (tp == NULL)
Alan Coxbf970ee2008-10-13 10:42:39 +01001191 return -ENOMEM;
Alan Coxbf970ee2008-10-13 10:42:39 +01001192 memcpy(tp, &tty->driver->init_termios,
1193 sizeof(struct ktermios));
1194 tty->driver->termios[idx] = tp;
Alan Coxbf970ee2008-10-13 10:42:39 +01001195 }
1196 tty->termios = tp;
Alan Coxfe6e29f2008-10-13 10:44:08 +01001197 tty->termios_locked = tp + 1;
Alan Coxbf970ee2008-10-13 10:42:39 +01001198
1199 /* Compatibility until drivers always set this */
1200 tty->termios->c_ispeed = tty_termios_input_baud_rate(tty->termios);
1201 tty->termios->c_ospeed = tty_termios_baud_rate(tty->termios);
1202 return 0;
1203}
Alan Coxfe1ae7f2009-09-19 13:13:33 -07001204EXPORT_SYMBOL_GPL(tty_init_termios);
Alan Coxbf970ee2008-10-13 10:42:39 +01001205
1206/**
Alan Cox8b0a88d2008-10-13 10:42:19 +01001207 * tty_driver_install_tty() - install a tty entry in the driver
1208 * @driver: the driver for the tty
1209 * @tty: the tty
1210 *
1211 * Install a tty object into the driver tables. The tty->index field
Alan Coxbf970ee2008-10-13 10:42:39 +01001212 * will be set by the time this is called. This method is responsible
1213 * for ensuring any need additional structures are allocated and
1214 * configured.
Alan Cox8b0a88d2008-10-13 10:42:19 +01001215 *
1216 * Locking: tty_mutex for now
1217 */
1218static int tty_driver_install_tty(struct tty_driver *driver,
1219 struct tty_struct *tty)
1220{
Alan Coxbf970ee2008-10-13 10:42:39 +01001221 int idx = tty->index;
Alan Coxeeb89d92009-11-30 13:18:29 +00001222 int ret;
Alan Coxbf970ee2008-10-13 10:42:39 +01001223
Alan Coxeeb89d92009-11-30 13:18:29 +00001224 if (driver->ops->install) {
Alan Coxeeb89d92009-11-30 13:18:29 +00001225 ret = driver->ops->install(driver, tty);
Alan Coxeeb89d92009-11-30 13:18:29 +00001226 return ret;
1227 }
Alan Coxbf970ee2008-10-13 10:42:39 +01001228
1229 if (tty_init_termios(tty) == 0) {
1230 tty_driver_kref_get(driver);
1231 tty->count++;
1232 driver->ttys[idx] = tty;
1233 return 0;
1234 }
1235 return -ENOMEM;
Alan Cox8b0a88d2008-10-13 10:42:19 +01001236}
1237
1238/**
1239 * tty_driver_remove_tty() - remove a tty from the driver tables
1240 * @driver: the driver for the tty
1241 * @idx: the minor number
1242 *
1243 * Remvoe a tty object from the driver tables. The tty->index field
1244 * will be set by the time this is called.
1245 *
1246 * Locking: tty_mutex for now
1247 */
1248static void tty_driver_remove_tty(struct tty_driver *driver,
1249 struct tty_struct *tty)
1250{
1251 if (driver->ops->remove)
1252 driver->ops->remove(driver, tty);
1253 else
1254 driver->ttys[tty->index] = NULL;
1255}
1256
1257/*
1258 * tty_reopen() - fast re-open of an open tty
1259 * @tty - the tty to open
Sukadev Bhattiprolu23499702008-10-13 10:41:51 +01001260 *
Alan Cox99f1fe12008-10-13 10:42:00 +01001261 * Return 0 on success, -errno on error.
Sukadev Bhattiprolu23499702008-10-13 10:41:51 +01001262 *
Alan Cox99f1fe12008-10-13 10:42:00 +01001263 * Locking: tty_mutex must be held from the time the tty was found
1264 * till this open completes.
Sukadev Bhattiprolu23499702008-10-13 10:41:51 +01001265 */
Alan Cox99f1fe12008-10-13 10:42:00 +01001266static int tty_reopen(struct tty_struct *tty)
Sukadev Bhattiprolu23499702008-10-13 10:41:51 +01001267{
1268 struct tty_driver *driver = tty->driver;
1269
1270 if (test_bit(TTY_CLOSING, &tty->flags))
1271 return -EIO;
1272
1273 if (driver->type == TTY_DRIVER_TYPE_PTY &&
1274 driver->subtype == PTY_TYPE_MASTER) {
1275 /*
1276 * special case for PTY masters: only one open permitted,
1277 * and the slave side open count is incremented as well.
1278 */
1279 if (tty->count)
1280 return -EIO;
1281
1282 tty->link->count++;
1283 }
1284 tty->count++;
1285 tty->driver = driver; /* N.B. why do this every time?? */
1286
Alan Cox1aa4bed2009-06-16 17:01:33 +01001287 mutex_lock(&tty->ldisc_mutex);
Alan Cox99f1fe12008-10-13 10:42:00 +01001288 WARN_ON(!test_bit(TTY_LDISC, &tty->flags));
Alan Cox1aa4bed2009-06-16 17:01:33 +01001289 mutex_unlock(&tty->ldisc_mutex);
Sukadev Bhattiprolu23499702008-10-13 10:41:51 +01001290
1291 return 0;
1292}
1293
Alan Coxaf9b8972006-08-27 01:24:01 -07001294/**
Alan Coxd81ed102008-10-13 10:41:42 +01001295 * tty_init_dev - initialise a tty device
Alan Coxaf9b8972006-08-27 01:24:01 -07001296 * @driver: tty driver we are opening a device on
1297 * @idx: device index
Alan Cox15582d32008-10-13 10:41:03 +01001298 * @ret_tty: returned tty structure
1299 * @first_ok: ok to open a new device (used by ptmx)
Alan Coxaf9b8972006-08-27 01:24:01 -07001300 *
1301 * Prepare a tty device. This may not be a "new" clean device but
1302 * could also be an active device. The pty drivers require special
1303 * handling because of this.
1304 *
1305 * Locking:
1306 * The function is called under the tty_mutex, which
1307 * protects us from the tty struct or driver itself going away.
1308 *
1309 * On exit the tty device has the line discipline attached and
1310 * a reference count of 1. If a pair was created for pty/tty use
1311 * and the other was a pty master then it too has a reference count of 1.
1312 *
Linus Torvalds1da177e2005-04-16 15:20:36 -07001313 * WSH 06/09/97: Rewritten to remove races and properly clean up after a
Ingo Molnar70522e12006-03-23 03:00:31 -08001314 * failed open. The new code protects the open with a mutex, so it's
1315 * really quite straightforward. The mutex locking can probably be
Linus Torvalds1da177e2005-04-16 15:20:36 -07001316 * relaxed for the (most common) case of reopening a tty.
1317 */
Alan Coxaf9b8972006-08-27 01:24:01 -07001318
Alan Cox73ec06f2008-10-13 10:42:29 +01001319struct tty_struct *tty_init_dev(struct tty_driver *driver, int idx,
1320 int first_ok)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001321{
Alan Coxbf970ee2008-10-13 10:42:39 +01001322 struct tty_struct *tty;
Alan Cox73ec06f2008-10-13 10:42:29 +01001323 int retval;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001324
Sukadev Bhattiprolu23499702008-10-13 10:41:51 +01001325 /* Check if pty master is being opened multiple times */
Alan Cox15582d32008-10-13 10:41:03 +01001326 if (driver->subtype == PTY_TYPE_MASTER &&
Alan Coxeeb89d92009-11-30 13:18:29 +00001327 (driver->flags & TTY_DRIVER_DEVPTS_MEM) && !first_ok) {
Alan Cox73ec06f2008-10-13 10:42:29 +01001328 return ERR_PTR(-EIO);
Alan Coxeeb89d92009-11-30 13:18:29 +00001329 }
Alan Cox73ec06f2008-10-13 10:42:29 +01001330
Linus Torvalds1da177e2005-04-16 15:20:36 -07001331 /*
1332 * First time open is complex, especially for PTY devices.
1333 * This code guarantees that either everything succeeds and the
1334 * TTY is ready for operation, or else the table slots are vacated
Alan Cox37bdfb02008-02-08 04:18:47 -08001335 * and the allocated memory released. (Except that the termios
Linus Torvalds1da177e2005-04-16 15:20:36 -07001336 * and locked termios may be retained.)
1337 */
1338
Alan Cox73ec06f2008-10-13 10:42:29 +01001339 if (!try_module_get(driver->owner))
1340 return ERR_PTR(-ENODEV);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001341
Linus Torvalds1da177e2005-04-16 15:20:36 -07001342 tty = alloc_tty_struct();
Alan Cox37bdfb02008-02-08 04:18:47 -08001343 if (!tty)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001344 goto fail_no_mem;
Alan Coxbf970ee2008-10-13 10:42:39 +01001345 initialize_tty_struct(tty, driver, idx);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001346
Alan Cox73ec06f2008-10-13 10:42:29 +01001347 retval = tty_driver_install_tty(driver, tty);
Alan Coxbf970ee2008-10-13 10:42:39 +01001348 if (retval < 0) {
1349 free_tty_struct(tty);
1350 module_put(driver->owner);
1351 return ERR_PTR(retval);
1352 }
Alan Cox8b0a88d2008-10-13 10:42:19 +01001353
Alan Cox37bdfb02008-02-08 04:18:47 -08001354 /*
Linus Torvalds1da177e2005-04-16 15:20:36 -07001355 * Structures all installed ... call the ldisc open routines.
Christoph Hellwigd5698c22007-02-10 01:46:46 -08001356 * If we fail here just call release_tty to clean up. No need
1357 * to decrement the use counts, as release_tty doesn't care.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001358 */
Alan Coxbf970ee2008-10-13 10:42:39 +01001359 retval = tty_ldisc_setup(tty, tty->link);
Alan Cox01e1abb2008-07-22 11:16:55 +01001360 if (retval)
1361 goto release_mem_out;
Alan Cox73ec06f2008-10-13 10:42:29 +01001362 return tty;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001363
Linus Torvalds1da177e2005-04-16 15:20:36 -07001364fail_no_mem:
1365 module_put(driver->owner);
Alan Cox73ec06f2008-10-13 10:42:29 +01001366 return ERR_PTR(-ENOMEM);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001367
Christoph Hellwigd5698c22007-02-10 01:46:46 -08001368 /* call the tty release_tty routine to clean out this slot */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001369release_mem_out:
Akinobu Mita40509142006-09-29 02:01:27 -07001370 if (printk_ratelimit())
Alan Coxd81ed102008-10-13 10:41:42 +01001371 printk(KERN_INFO "tty_init_dev: ldisc open failed, "
Akinobu Mita40509142006-09-29 02:01:27 -07001372 "clearing slot %d\n", idx);
Christoph Hellwigd5698c22007-02-10 01:46:46 -08001373 release_tty(tty, idx);
Alan Cox73ec06f2008-10-13 10:42:29 +01001374 return ERR_PTR(retval);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001375}
1376
Alan Coxfeebed62008-10-13 10:41:30 +01001377void tty_free_termios(struct tty_struct *tty)
1378{
1379 struct ktermios *tp;
1380 int idx = tty->index;
1381 /* Kill this flag and push into drivers for locking etc */
1382 if (tty->driver->flags & TTY_DRIVER_RESET_TERMIOS) {
1383 /* FIXME: Locking on ->termios array */
1384 tp = tty->termios;
1385 tty->driver->termios[idx] = NULL;
1386 kfree(tp);
Alan Coxfeebed62008-10-13 10:41:30 +01001387 }
1388}
1389EXPORT_SYMBOL(tty_free_termios);
1390
1391void tty_shutdown(struct tty_struct *tty)
1392{
Alan Cox8b0a88d2008-10-13 10:42:19 +01001393 tty_driver_remove_tty(tty->driver, tty);
Alan Coxfeebed62008-10-13 10:41:30 +01001394 tty_free_termios(tty);
1395}
1396EXPORT_SYMBOL(tty_shutdown);
1397
Alan Coxaf9b8972006-08-27 01:24:01 -07001398/**
Christoph Hellwigd5698c22007-02-10 01:46:46 -08001399 * release_one_tty - release tty structure memory
Alan Cox9c9f4de2008-10-13 10:37:26 +01001400 * @kref: kref of tty we are obliterating
Alan Coxaf9b8972006-08-27 01:24:01 -07001401 *
1402 * Releases memory associated with a tty structure, and clears out the
1403 * driver table slots. This function is called when a device is no longer
1404 * in use. It also gets called when setup of a device fails.
1405 *
1406 * Locking:
1407 * tty_mutex - sometimes only
1408 * takes the file list lock internally when working on the list
1409 * of ttys that the driver keeps.
Alan Coxb50989d2009-09-19 13:13:22 -07001410 *
1411 * This method gets called from a work queue so that the driver private
Dave Youngf278a2f2009-09-27 16:00:42 +00001412 * cleanup ops can sleep (needed for USB at least)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001413 */
Alan Coxb50989d2009-09-19 13:13:22 -07001414static void release_one_tty(struct work_struct *work)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001415{
Alan Coxb50989d2009-09-19 13:13:22 -07001416 struct tty_struct *tty =
1417 container_of(work, struct tty_struct, hangup_work);
Alan Cox6f967f72008-10-13 10:37:36 +01001418 struct tty_driver *driver = tty->driver;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001419
Dave Youngf278a2f2009-09-27 16:00:42 +00001420 if (tty->ops->cleanup)
1421 tty->ops->cleanup(tty);
1422
Linus Torvalds1da177e2005-04-16 15:20:36 -07001423 tty->magic = 0;
Alan Cox7d7b93c2008-10-13 10:42:09 +01001424 tty_driver_kref_put(driver);
Alan Cox6f967f72008-10-13 10:37:36 +01001425 module_put(driver->owner);
Christoph Hellwigd5698c22007-02-10 01:46:46 -08001426
Linus Torvalds1da177e2005-04-16 15:20:36 -07001427 file_list_lock();
1428 list_del_init(&tty->tty_files);
1429 file_list_unlock();
Christoph Hellwigd5698c22007-02-10 01:46:46 -08001430
Oleg Nesterov6da8d862010-04-02 18:05:12 +02001431 put_pid(tty->pgrp);
1432 put_pid(tty->session);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001433 free_tty_struct(tty);
1434}
1435
Alan Coxb50989d2009-09-19 13:13:22 -07001436static void queue_release_one_tty(struct kref *kref)
1437{
1438 struct tty_struct *tty = container_of(kref, struct tty_struct, kref);
Dave Youngf278a2f2009-09-27 16:00:42 +00001439
1440 if (tty->ops->shutdown)
1441 tty->ops->shutdown(tty);
1442 else
1443 tty_shutdown(tty);
1444
Alan Coxb50989d2009-09-19 13:13:22 -07001445 /* The hangup queue is now free so we can reuse it rather than
1446 waste a chunk of memory for each port */
1447 INIT_WORK(&tty->hangup_work, release_one_tty);
1448 schedule_work(&tty->hangup_work);
1449}
1450
Christoph Hellwigd5698c22007-02-10 01:46:46 -08001451/**
Alan Cox9c9f4de2008-10-13 10:37:26 +01001452 * tty_kref_put - release a tty kref
1453 * @tty: tty device
1454 *
1455 * Release a reference to a tty device and if need be let the kref
1456 * layer destruct the object for us
1457 */
1458
1459void tty_kref_put(struct tty_struct *tty)
1460{
1461 if (tty)
Alan Coxb50989d2009-09-19 13:13:22 -07001462 kref_put(&tty->kref, queue_release_one_tty);
Alan Cox9c9f4de2008-10-13 10:37:26 +01001463}
1464EXPORT_SYMBOL(tty_kref_put);
1465
1466/**
Christoph Hellwigd5698c22007-02-10 01:46:46 -08001467 * release_tty - release tty structure memory
1468 *
1469 * Release both @tty and a possible linked partner (think pty pair),
1470 * and decrement the refcount of the backing module.
1471 *
1472 * Locking:
1473 * tty_mutex - sometimes only
1474 * takes the file list lock internally when working on the list
1475 * of ttys that the driver keeps.
1476 * FIXME: should we require tty_mutex is held here ??
Alan Cox9c9f4de2008-10-13 10:37:26 +01001477 *
Christoph Hellwigd5698c22007-02-10 01:46:46 -08001478 */
1479static void release_tty(struct tty_struct *tty, int idx)
1480{
Alan Cox9c9f4de2008-10-13 10:37:26 +01001481 /* This should always be true but check for the moment */
1482 WARN_ON(tty->index != idx);
1483
Christoph Hellwigd5698c22007-02-10 01:46:46 -08001484 if (tty->link)
Alan Cox9c9f4de2008-10-13 10:37:26 +01001485 tty_kref_put(tty->link);
1486 tty_kref_put(tty);
Christoph Hellwigd5698c22007-02-10 01:46:46 -08001487}
1488
Alan Coxeeb89d92009-11-30 13:18:29 +00001489/**
1490 * tty_release - vfs callback for close
1491 * @inode: inode of tty
1492 * @filp: file pointer for handle to tty
1493 *
1494 * Called the last time each file handle is closed that references
1495 * this tty. There may however be several such references.
1496 *
1497 * Locking:
1498 * Takes bkl. See tty_release_dev
1499 *
Linus Torvalds1da177e2005-04-16 15:20:36 -07001500 * Even releasing the tty structures is a tricky business.. We have
1501 * to be very careful that the structures are all released at the
1502 * same time, as interrupts might otherwise get the wrong pointers.
1503 *
1504 * WSH 09/09/97: rewritten to avoid some nasty race conditions that could
1505 * lead to double frees or releasing memory still in use.
1506 */
Alan Coxeeb89d92009-11-30 13:18:29 +00001507
1508int tty_release(struct inode *inode, struct file *filp)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001509{
1510 struct tty_struct *tty, *o_tty;
1511 int pty_master, tty_closing, o_tty_closing, do_sleep;
Paul Fulghum14a62832006-04-10 22:54:19 -07001512 int devpts;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001513 int idx;
1514 char buf[64];
Alan Cox37bdfb02008-02-08 04:18:47 -08001515
Linus Torvalds1da177e2005-04-16 15:20:36 -07001516 tty = (struct tty_struct *)filp->private_data;
Sukadev Bhattiprolu15f1a632008-10-13 10:42:59 +01001517 if (tty_paranoia_check(tty, inode, "tty_release_dev"))
Alan Coxeeb89d92009-11-30 13:18:29 +00001518 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001519
Arnd Bergmannec79d602010-06-01 22:53:01 +02001520 tty_lock();
Alan Coxd81ed102008-10-13 10:41:42 +01001521 check_tty_count(tty, "tty_release_dev");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001522
Arnd Bergmannec79d602010-06-01 22:53:01 +02001523 __tty_fasync(-1, filp, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001524
1525 idx = tty->index;
1526 pty_master = (tty->driver->type == TTY_DRIVER_TYPE_PTY &&
1527 tty->driver->subtype == PTY_TYPE_MASTER);
1528 devpts = (tty->driver->flags & TTY_DRIVER_DEVPTS_MEM) != 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001529 o_tty = tty->link;
1530
1531#ifdef TTY_PARANOIA_CHECK
1532 if (idx < 0 || idx >= tty->driver->num) {
Alan Coxd81ed102008-10-13 10:41:42 +01001533 printk(KERN_DEBUG "tty_release_dev: bad idx when trying to "
Linus Torvalds1da177e2005-04-16 15:20:36 -07001534 "free (%s)\n", tty->name);
Arnd Bergmannec79d602010-06-01 22:53:01 +02001535 tty_unlock();
Alan Coxeeb89d92009-11-30 13:18:29 +00001536 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001537 }
Alan Cox8b0a88d2008-10-13 10:42:19 +01001538 if (!devpts) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001539 if (tty != tty->driver->ttys[idx]) {
Arnd Bergmannec79d602010-06-01 22:53:01 +02001540 tty_unlock();
Alan Coxd81ed102008-10-13 10:41:42 +01001541 printk(KERN_DEBUG "tty_release_dev: driver.table[%d] not tty "
Linus Torvalds1da177e2005-04-16 15:20:36 -07001542 "for (%s)\n", idx, tty->name);
Alan Coxeeb89d92009-11-30 13:18:29 +00001543 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001544 }
1545 if (tty->termios != tty->driver->termios[idx]) {
Arnd Bergmannec79d602010-06-01 22:53:01 +02001546 tty_unlock();
Alan Coxd81ed102008-10-13 10:41:42 +01001547 printk(KERN_DEBUG "tty_release_dev: driver.termios[%d] not termios "
Linus Torvalds1da177e2005-04-16 15:20:36 -07001548 "for (%s)\n",
1549 idx, tty->name);
Alan Coxeeb89d92009-11-30 13:18:29 +00001550 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001551 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001552 }
1553#endif
1554
1555#ifdef TTY_DEBUG_HANGUP
Alan Coxd81ed102008-10-13 10:41:42 +01001556 printk(KERN_DEBUG "tty_release_dev of %s (tty count=%d)...",
Linus Torvalds1da177e2005-04-16 15:20:36 -07001557 tty_name(tty, buf), tty->count);
1558#endif
1559
1560#ifdef TTY_PARANOIA_CHECK
1561 if (tty->driver->other &&
1562 !(tty->driver->flags & TTY_DRIVER_DEVPTS_MEM)) {
1563 if (o_tty != tty->driver->other->ttys[idx]) {
Arnd Bergmannec79d602010-06-01 22:53:01 +02001564 tty_unlock();
Alan Coxd81ed102008-10-13 10:41:42 +01001565 printk(KERN_DEBUG "tty_release_dev: other->table[%d] "
Linus Torvalds1da177e2005-04-16 15:20:36 -07001566 "not o_tty for (%s)\n",
1567 idx, tty->name);
Alan Coxeeb89d92009-11-30 13:18:29 +00001568 return 0 ;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001569 }
1570 if (o_tty->termios != tty->driver->other->termios[idx]) {
Arnd Bergmannec79d602010-06-01 22:53:01 +02001571 tty_unlock();
Alan Coxd81ed102008-10-13 10:41:42 +01001572 printk(KERN_DEBUG "tty_release_dev: other->termios[%d] "
Linus Torvalds1da177e2005-04-16 15:20:36 -07001573 "not o_termios for (%s)\n",
1574 idx, tty->name);
Alan Coxeeb89d92009-11-30 13:18:29 +00001575 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001576 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001577 if (o_tty->link != tty) {
Arnd Bergmannec79d602010-06-01 22:53:01 +02001578 tty_unlock();
Alan Coxd81ed102008-10-13 10:41:42 +01001579 printk(KERN_DEBUG "tty_release_dev: bad pty pointers\n");
Alan Coxeeb89d92009-11-30 13:18:29 +00001580 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001581 }
1582 }
1583#endif
Alan Coxf34d7a52008-04-30 00:54:13 -07001584 if (tty->ops->close)
1585 tty->ops->close(tty, filp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001586
Arnd Bergmannec79d602010-06-01 22:53:01 +02001587 tty_unlock();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001588 /*
1589 * Sanity check: if tty->count is going to zero, there shouldn't be
1590 * any waiters on tty->read_wait or tty->write_wait. We test the
1591 * wait queues and kick everyone out _before_ actually starting to
1592 * close. This ensures that we won't block while releasing the tty
1593 * structure.
1594 *
1595 * The test for the o_tty closing is necessary, since the master and
1596 * slave sides may close in any order. If the slave side closes out
1597 * first, its count will be one, since the master side holds an open.
1598 * Thus this test wouldn't be triggered at the time the slave closes,
1599 * so we do it now.
1600 *
1601 * Note that it's possible for the tty to be opened again while we're
1602 * flushing out waiters. By recalculating the closing flags before
1603 * each iteration we avoid any problems.
1604 */
1605 while (1) {
1606 /* Guard against races with tty->count changes elsewhere and
1607 opens on /dev/tty */
Alan Cox37bdfb02008-02-08 04:18:47 -08001608
Ingo Molnar70522e12006-03-23 03:00:31 -08001609 mutex_lock(&tty_mutex);
Arnd Bergmannec79d602010-06-01 22:53:01 +02001610 tty_lock();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001611 tty_closing = tty->count <= 1;
1612 o_tty_closing = o_tty &&
1613 (o_tty->count <= (pty_master ? 1 : 0));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001614 do_sleep = 0;
1615
1616 if (tty_closing) {
1617 if (waitqueue_active(&tty->read_wait)) {
Davide Libenzi4b194492009-03-31 15:24:24 -07001618 wake_up_poll(&tty->read_wait, POLLIN);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001619 do_sleep++;
1620 }
1621 if (waitqueue_active(&tty->write_wait)) {
Davide Libenzi4b194492009-03-31 15:24:24 -07001622 wake_up_poll(&tty->write_wait, POLLOUT);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001623 do_sleep++;
1624 }
1625 }
1626 if (o_tty_closing) {
1627 if (waitqueue_active(&o_tty->read_wait)) {
Davide Libenzi4b194492009-03-31 15:24:24 -07001628 wake_up_poll(&o_tty->read_wait, POLLIN);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001629 do_sleep++;
1630 }
1631 if (waitqueue_active(&o_tty->write_wait)) {
Davide Libenzi4b194492009-03-31 15:24:24 -07001632 wake_up_poll(&o_tty->write_wait, POLLOUT);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001633 do_sleep++;
1634 }
1635 }
1636 if (!do_sleep)
1637 break;
1638
Alan Coxd81ed102008-10-13 10:41:42 +01001639 printk(KERN_WARNING "tty_release_dev: %s: read/write wait queue "
Linus Torvalds1da177e2005-04-16 15:20:36 -07001640 "active!\n", tty_name(tty, buf));
Arnd Bergmannec79d602010-06-01 22:53:01 +02001641 tty_unlock();
Ingo Molnar70522e12006-03-23 03:00:31 -08001642 mutex_unlock(&tty_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001643 schedule();
Alan Cox37bdfb02008-02-08 04:18:47 -08001644 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001645
1646 /*
Alan Cox37bdfb02008-02-08 04:18:47 -08001647 * The closing flags are now consistent with the open counts on
1648 * both sides, and we've completed the last operation that could
Linus Torvalds1da177e2005-04-16 15:20:36 -07001649 * block, so it's safe to proceed with closing.
1650 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001651 if (pty_master) {
1652 if (--o_tty->count < 0) {
Alan Coxd81ed102008-10-13 10:41:42 +01001653 printk(KERN_WARNING "tty_release_dev: bad pty slave count "
Linus Torvalds1da177e2005-04-16 15:20:36 -07001654 "(%d) for %s\n",
1655 o_tty->count, tty_name(o_tty, buf));
1656 o_tty->count = 0;
1657 }
1658 }
1659 if (--tty->count < 0) {
Alan Coxd81ed102008-10-13 10:41:42 +01001660 printk(KERN_WARNING "tty_release_dev: bad tty->count (%d) for %s\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -07001661 tty->count, tty_name(tty, buf));
1662 tty->count = 0;
1663 }
Alan Cox37bdfb02008-02-08 04:18:47 -08001664
Linus Torvalds1da177e2005-04-16 15:20:36 -07001665 /*
1666 * We've decremented tty->count, so we need to remove this file
1667 * descriptor off the tty->tty_files list; this serves two
1668 * purposes:
1669 * - check_tty_count sees the correct number of file descriptors
1670 * associated with this tty.
1671 * - do_tty_hangup no longer sees this file descriptor as
1672 * something that needs to be handled for hangups.
1673 */
1674 file_kill(filp);
1675 filp->private_data = NULL;
1676
1677 /*
1678 * Perform some housekeeping before deciding whether to return.
1679 *
1680 * Set the TTY_CLOSING flag if this was the last open. In the
1681 * case of a pty we may have to wait around for the other side
1682 * to close, and TTY_CLOSING makes sure we can't be reopened.
1683 */
Alan Cox37bdfb02008-02-08 04:18:47 -08001684 if (tty_closing)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001685 set_bit(TTY_CLOSING, &tty->flags);
Alan Cox37bdfb02008-02-08 04:18:47 -08001686 if (o_tty_closing)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001687 set_bit(TTY_CLOSING, &o_tty->flags);
1688
1689 /*
1690 * If _either_ side is closing, make sure there aren't any
1691 * processes that still think tty or o_tty is their controlling
1692 * tty.
1693 */
1694 if (tty_closing || o_tty_closing) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001695 read_lock(&tasklist_lock);
Peter Zijlstra24ec8392006-12-08 02:36:04 -08001696 session_clear_tty(tty->session);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001697 if (o_tty)
Peter Zijlstra24ec8392006-12-08 02:36:04 -08001698 session_clear_tty(o_tty->session);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001699 read_unlock(&tasklist_lock);
1700 }
1701
Ingo Molnar70522e12006-03-23 03:00:31 -08001702 mutex_unlock(&tty_mutex);
Paul Fulghumda965822006-02-14 13:53:00 -08001703
Linus Torvalds1da177e2005-04-16 15:20:36 -07001704 /* check whether both sides are closing ... */
Alan Coxeeb89d92009-11-30 13:18:29 +00001705 if (!tty_closing || (o_tty && !o_tty_closing)) {
Arnd Bergmannec79d602010-06-01 22:53:01 +02001706 tty_unlock();
Alan Coxeeb89d92009-11-30 13:18:29 +00001707 return 0;
1708 }
Alan Cox37bdfb02008-02-08 04:18:47 -08001709
Linus Torvalds1da177e2005-04-16 15:20:36 -07001710#ifdef TTY_DEBUG_HANGUP
1711 printk(KERN_DEBUG "freeing tty structure...");
1712#endif
1713 /*
Alan Cox01e1abb2008-07-22 11:16:55 +01001714 * Ask the line discipline code to release its structures
Linus Torvalds1da177e2005-04-16 15:20:36 -07001715 */
Alan Cox01e1abb2008-07-22 11:16:55 +01001716 tty_ldisc_release(tty, o_tty);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001717 /*
Christoph Hellwigd5698c22007-02-10 01:46:46 -08001718 * The release_tty function takes care of the details of clearing
Linus Torvalds1da177e2005-04-16 15:20:36 -07001719 * the slots and preserving the termios structure.
1720 */
Christoph Hellwigd5698c22007-02-10 01:46:46 -08001721 release_tty(tty, idx);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001722
Linus Torvalds1da177e2005-04-16 15:20:36 -07001723 /* Make this pty number available for reallocation */
Sukadev Bhattiprolu718a9162008-04-30 00:54:21 -07001724 if (devpts)
Sukadev Bhattiprolu15f1a632008-10-13 10:42:59 +01001725 devpts_kill_index(inode, idx);
Arnd Bergmannec79d602010-06-01 22:53:01 +02001726 tty_unlock();
Alan Coxeeb89d92009-11-30 13:18:29 +00001727 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001728}
1729
Alan Coxaf9b8972006-08-27 01:24:01 -07001730/**
Alan Coxeeb89d92009-11-30 13:18:29 +00001731 * tty_open - open a tty device
Alan Coxaf9b8972006-08-27 01:24:01 -07001732 * @inode: inode of device file
1733 * @filp: file pointer to tty
Linus Torvalds1da177e2005-04-16 15:20:36 -07001734 *
Alan Coxaf9b8972006-08-27 01:24:01 -07001735 * tty_open and tty_release keep up the tty count that contains the
1736 * number of opens done on a tty. We cannot use the inode-count, as
1737 * different inodes might point to the same tty.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001738 *
Alan Coxaf9b8972006-08-27 01:24:01 -07001739 * Open-counting is needed for pty masters, as well as for keeping
1740 * track of serial lines: DTR is dropped when the last close happens.
1741 * (This is not done solely through tty->count, now. - Ted 1/27/92)
1742 *
1743 * The termios state of a pty is reset on first open so that
1744 * settings don't persist across reuse.
1745 *
Alan Coxd81ed102008-10-13 10:41:42 +01001746 * Locking: tty_mutex protects tty, get_tty_driver and tty_init_dev work.
Peter Zijlstra24ec8392006-12-08 02:36:04 -08001747 * tty->count should protect the rest.
1748 * ->siglock protects ->signal/->sighand
Linus Torvalds1da177e2005-04-16 15:20:36 -07001749 */
Alan Coxaf9b8972006-08-27 01:24:01 -07001750
Alan Coxeeb89d92009-11-30 13:18:29 +00001751static int tty_open(struct inode *inode, struct file *filp)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001752{
Sukadev Bhattiprolu4a2b5fd2008-10-13 10:42:49 +01001753 struct tty_struct *tty = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001754 int noctty, retval;
1755 struct tty_driver *driver;
1756 int index;
1757 dev_t device = inode->i_rdev;
Andrew Morton846c1512009-04-02 16:56:36 -07001758 unsigned saved_flags = filp->f_flags;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001759
1760 nonseekable_open(inode, filp);
Alan Cox37bdfb02008-02-08 04:18:47 -08001761
Linus Torvalds1da177e2005-04-16 15:20:36 -07001762retry_open:
1763 noctty = filp->f_flags & O_NOCTTY;
1764 index = -1;
1765 retval = 0;
Alan Cox37bdfb02008-02-08 04:18:47 -08001766
Ingo Molnar70522e12006-03-23 03:00:31 -08001767 mutex_lock(&tty_mutex);
Arnd Bergmannec79d602010-06-01 22:53:01 +02001768 tty_lock();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001769
Alan Cox37bdfb02008-02-08 04:18:47 -08001770 if (device == MKDEV(TTYAUX_MAJOR, 0)) {
Peter Zijlstra24ec8392006-12-08 02:36:04 -08001771 tty = get_current_tty();
1772 if (!tty) {
Arnd Bergmannec79d602010-06-01 22:53:01 +02001773 tty_unlock();
Ingo Molnar70522e12006-03-23 03:00:31 -08001774 mutex_unlock(&tty_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001775 return -ENXIO;
1776 }
Alan Cox7d7b93c2008-10-13 10:42:09 +01001777 driver = tty_driver_kref_get(tty->driver);
Peter Zijlstra24ec8392006-12-08 02:36:04 -08001778 index = tty->index;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001779 filp->f_flags |= O_NONBLOCK; /* Don't let /dev/tty block */
1780 /* noctty = 1; */
Alan Cox452a00d2008-10-13 10:39:13 +01001781 /* FIXME: Should we take a driver reference ? */
1782 tty_kref_put(tty);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001783 goto got_driver;
1784 }
1785#ifdef CONFIG_VT
Alan Cox37bdfb02008-02-08 04:18:47 -08001786 if (device == MKDEV(TTY_MAJOR, 0)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001787 extern struct tty_driver *console_driver;
Alan Cox7d7b93c2008-10-13 10:42:09 +01001788 driver = tty_driver_kref_get(console_driver);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001789 index = fg_console;
1790 noctty = 1;
1791 goto got_driver;
1792 }
1793#endif
Alan Cox37bdfb02008-02-08 04:18:47 -08001794 if (device == MKDEV(TTYAUX_MAJOR, 1)) {
Will Newton296fa7f2008-12-01 11:36:06 +00001795 struct tty_driver *console_driver = console_device(&index);
1796 if (console_driver) {
1797 driver = tty_driver_kref_get(console_driver);
1798 if (driver) {
1799 /* Don't let /dev/console block */
1800 filp->f_flags |= O_NONBLOCK;
1801 noctty = 1;
1802 goto got_driver;
1803 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001804 }
Arnd Bergmannec79d602010-06-01 22:53:01 +02001805 tty_unlock();
Ingo Molnar70522e12006-03-23 03:00:31 -08001806 mutex_unlock(&tty_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001807 return -ENODEV;
1808 }
1809
1810 driver = get_tty_driver(device, &index);
1811 if (!driver) {
Arnd Bergmannec79d602010-06-01 22:53:01 +02001812 tty_unlock();
Ingo Molnar70522e12006-03-23 03:00:31 -08001813 mutex_unlock(&tty_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001814 return -ENODEV;
1815 }
1816got_driver:
Sukadev Bhattiprolu4a2b5fd2008-10-13 10:42:49 +01001817 if (!tty) {
1818 /* check whether we're reopening an existing tty */
Sukadev Bhattiprolu15f1a632008-10-13 10:42:59 +01001819 tty = tty_driver_lookup_tty(driver, inode, index);
Sukadev Bhattiprolu4a2b5fd2008-10-13 10:42:49 +01001820
Eric Paris808ffa32009-01-27 11:50:37 +00001821 if (IS_ERR(tty)) {
Arnd Bergmannec79d602010-06-01 22:53:01 +02001822 tty_unlock();
Eric Paris808ffa32009-01-27 11:50:37 +00001823 mutex_unlock(&tty_mutex);
Sukadev Bhattiprolu4a2b5fd2008-10-13 10:42:49 +01001824 return PTR_ERR(tty);
Eric Paris808ffa32009-01-27 11:50:37 +00001825 }
Sukadev Bhattiprolu4a2b5fd2008-10-13 10:42:49 +01001826 }
1827
1828 if (tty) {
1829 retval = tty_reopen(tty);
1830 if (retval)
1831 tty = ERR_PTR(retval);
1832 } else
1833 tty = tty_init_dev(driver, index, 0);
1834
Ingo Molnar70522e12006-03-23 03:00:31 -08001835 mutex_unlock(&tty_mutex);
Alan Cox7d7b93c2008-10-13 10:42:09 +01001836 tty_driver_kref_put(driver);
Alan Coxeeb89d92009-11-30 13:18:29 +00001837 if (IS_ERR(tty)) {
Arnd Bergmannec79d602010-06-01 22:53:01 +02001838 tty_unlock();
Alan Cox73ec06f2008-10-13 10:42:29 +01001839 return PTR_ERR(tty);
Alan Coxeeb89d92009-11-30 13:18:29 +00001840 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001841
1842 filp->private_data = tty;
1843 file_move(filp, &tty->tty_files);
1844 check_tty_count(tty, "tty_open");
1845 if (tty->driver->type == TTY_DRIVER_TYPE_PTY &&
1846 tty->driver->subtype == PTY_TYPE_MASTER)
1847 noctty = 1;
1848#ifdef TTY_DEBUG_HANGUP
1849 printk(KERN_DEBUG "opening %s...", tty->name);
1850#endif
1851 if (!retval) {
Alan Coxf34d7a52008-04-30 00:54:13 -07001852 if (tty->ops->open)
1853 retval = tty->ops->open(tty, filp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001854 else
1855 retval = -ENODEV;
1856 }
1857 filp->f_flags = saved_flags;
1858
Alan Cox37bdfb02008-02-08 04:18:47 -08001859 if (!retval && test_bit(TTY_EXCLUSIVE, &tty->flags) &&
1860 !capable(CAP_SYS_ADMIN))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001861 retval = -EBUSY;
1862
1863 if (retval) {
1864#ifdef TTY_DEBUG_HANGUP
1865 printk(KERN_DEBUG "error %d in opening %s...", retval,
1866 tty->name);
1867#endif
Arnd Bergmann64ba3dc2010-06-01 22:53:02 +02001868 tty_unlock(); /* need to call tty_release without BTM */
Alan Coxeeb89d92009-11-30 13:18:29 +00001869 tty_release(inode, filp);
Arnd Bergmann64ba3dc2010-06-01 22:53:02 +02001870 if (retval != -ERESTARTSYS)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001871 return retval;
Arnd Bergmann64ba3dc2010-06-01 22:53:02 +02001872
1873 if (signal_pending(current))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001874 return retval;
Arnd Bergmann64ba3dc2010-06-01 22:53:02 +02001875
Linus Torvalds1da177e2005-04-16 15:20:36 -07001876 schedule();
1877 /*
1878 * Need to reset f_op in case a hangup happened.
1879 */
Arnd Bergmann64ba3dc2010-06-01 22:53:02 +02001880 tty_lock();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001881 if (filp->f_op == &hung_up_tty_fops)
1882 filp->f_op = &tty_fops;
Arnd Bergmannec79d602010-06-01 22:53:01 +02001883 tty_unlock();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001884 goto retry_open;
1885 }
Arnd Bergmannec79d602010-06-01 22:53:01 +02001886 tty_unlock();
Alan Coxeeb89d92009-11-30 13:18:29 +00001887
Peter Zijlstra24ec8392006-12-08 02:36:04 -08001888
1889 mutex_lock(&tty_mutex);
Arnd Bergmannec79d602010-06-01 22:53:01 +02001890 tty_lock();
Peter Zijlstra24ec8392006-12-08 02:36:04 -08001891 spin_lock_irq(&current->sighand->siglock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001892 if (!noctty &&
1893 current->signal->leader &&
1894 !current->signal->tty &&
Eric W. Biedermanab521dc2007-02-12 00:53:00 -08001895 tty->session == NULL)
Eric W. Biederman2a65f1d2007-05-08 00:26:53 -07001896 __proc_set_tty(current, tty);
Peter Zijlstra24ec8392006-12-08 02:36:04 -08001897 spin_unlock_irq(&current->sighand->siglock);
Arnd Bergmannec79d602010-06-01 22:53:01 +02001898 tty_unlock();
Peter Zijlstra24ec8392006-12-08 02:36:04 -08001899 mutex_unlock(&tty_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001900 return 0;
1901}
1902
Jonathan Corbet39d95b92008-05-16 09:10:50 -06001903
Linus Torvalds1da177e2005-04-16 15:20:36 -07001904
Alan Coxaf9b8972006-08-27 01:24:01 -07001905/**
1906 * tty_poll - check tty status
1907 * @filp: file being polled
1908 * @wait: poll wait structures to update
1909 *
1910 * Call the line discipline polling method to obtain the poll
1911 * status of the device.
1912 *
1913 * Locking: locks called line discipline but ldisc poll method
1914 * may be re-entered freely by other callers.
1915 */
1916
Alan Cox37bdfb02008-02-08 04:18:47 -08001917static unsigned int tty_poll(struct file *filp, poll_table *wait)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001918{
Alan Cox37bdfb02008-02-08 04:18:47 -08001919 struct tty_struct *tty;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001920 struct tty_ldisc *ld;
1921 int ret = 0;
1922
1923 tty = (struct tty_struct *)filp->private_data;
Josef Sipeka7113a92006-12-08 02:36:55 -08001924 if (tty_paranoia_check(tty, filp->f_path.dentry->d_inode, "tty_poll"))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001925 return 0;
Alan Cox37bdfb02008-02-08 04:18:47 -08001926
Linus Torvalds1da177e2005-04-16 15:20:36 -07001927 ld = tty_ldisc_ref_wait(tty);
Alan Coxa352def2008-07-16 21:53:12 +01001928 if (ld->ops->poll)
1929 ret = (ld->ops->poll)(tty, filp, wait);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001930 tty_ldisc_deref(ld);
1931 return ret;
1932}
1933
Arnd Bergmannec79d602010-06-01 22:53:01 +02001934static int __tty_fasync(int fd, struct file *filp, int on)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001935{
Alan Cox37bdfb02008-02-08 04:18:47 -08001936 struct tty_struct *tty;
Alan Cox47f86832008-04-30 00:53:30 -07001937 unsigned long flags;
Jonathan Corbet5d1e3232008-06-19 16:04:53 -06001938 int retval = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001939
1940 tty = (struct tty_struct *)filp->private_data;
Josef Sipeka7113a92006-12-08 02:36:55 -08001941 if (tty_paranoia_check(tty, filp->f_path.dentry->d_inode, "tty_fasync"))
Jonathan Corbet5d1e3232008-06-19 16:04:53 -06001942 goto out;
Alan Cox37bdfb02008-02-08 04:18:47 -08001943
Linus Torvalds1da177e2005-04-16 15:20:36 -07001944 retval = fasync_helper(fd, filp, on, &tty->fasync);
1945 if (retval <= 0)
Jonathan Corbet5d1e3232008-06-19 16:04:53 -06001946 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001947
1948 if (on) {
Eric W. Biedermanab521dc2007-02-12 00:53:00 -08001949 enum pid_type type;
1950 struct pid *pid;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001951 if (!waitqueue_active(&tty->read_wait))
1952 tty->minimum_to_wake = 1;
Alan Cox47f86832008-04-30 00:53:30 -07001953 spin_lock_irqsave(&tty->ctrl_lock, flags);
Eric W. Biedermanab521dc2007-02-12 00:53:00 -08001954 if (tty->pgrp) {
1955 pid = tty->pgrp;
1956 type = PIDTYPE_PGID;
1957 } else {
1958 pid = task_pid(current);
1959 type = PIDTYPE_PID;
1960 }
Linus Torvalds80e1e822010-02-07 10:11:23 -08001961 get_pid(pid);
Greg Kroah-Hartman70362512009-12-17 07:07:19 -08001962 spin_unlock_irqrestore(&tty->ctrl_lock, flags);
Linus Torvalds80e1e822010-02-07 10:11:23 -08001963 retval = __f_setown(filp, pid, type, 0);
1964 put_pid(pid);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001965 if (retval)
Jonathan Corbet5d1e3232008-06-19 16:04:53 -06001966 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001967 } else {
1968 if (!tty->fasync && !waitqueue_active(&tty->read_wait))
1969 tty->minimum_to_wake = N_TTY_BUF_SIZE;
1970 }
Jonathan Corbet5d1e3232008-06-19 16:04:53 -06001971 retval = 0;
1972out:
Arnd Bergmannec79d602010-06-01 22:53:01 +02001973 return retval;
1974}
1975
1976static int tty_fasync(int fd, struct file *filp, int on)
1977{
1978 int retval;
1979 tty_lock();
1980 retval = __tty_fasync(fd, filp, on);
1981 tty_unlock();
Jonathan Corbet5d1e3232008-06-19 16:04:53 -06001982 return retval;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001983}
1984
Alan Coxaf9b8972006-08-27 01:24:01 -07001985/**
1986 * tiocsti - fake input character
1987 * @tty: tty to fake input into
1988 * @p: pointer to character
1989 *
Robert P. J. Day3a4fa0a2007-10-19 23:10:43 +02001990 * Fake input to a tty device. Does the necessary locking and
Alan Coxaf9b8972006-08-27 01:24:01 -07001991 * input management.
1992 *
1993 * FIXME: does not honour flow control ??
1994 *
1995 * Locking:
1996 * Called functions take tty_ldisc_lock
1997 * current->signal->tty check is safe without locks
Alan Cox28298232006-09-29 02:00:58 -07001998 *
1999 * FIXME: may race normal receive processing
Alan Coxaf9b8972006-08-27 01:24:01 -07002000 */
2001
Linus Torvalds1da177e2005-04-16 15:20:36 -07002002static int tiocsti(struct tty_struct *tty, char __user *p)
2003{
2004 char ch, mbz = 0;
2005 struct tty_ldisc *ld;
Alan Cox37bdfb02008-02-08 04:18:47 -08002006
Linus Torvalds1da177e2005-04-16 15:20:36 -07002007 if ((current->signal->tty != tty) && !capable(CAP_SYS_ADMIN))
2008 return -EPERM;
2009 if (get_user(ch, p))
2010 return -EFAULT;
Al Viro1e641742008-12-09 09:23:33 +00002011 tty_audit_tiocsti(tty, ch);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002012 ld = tty_ldisc_ref_wait(tty);
Alan Coxa352def2008-07-16 21:53:12 +01002013 ld->ops->receive_buf(tty, &ch, &mbz, 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002014 tty_ldisc_deref(ld);
2015 return 0;
2016}
2017
Alan Coxaf9b8972006-08-27 01:24:01 -07002018/**
2019 * tiocgwinsz - implement window query ioctl
2020 * @tty; tty
2021 * @arg: user buffer for result
2022 *
Alan Cox808a0d32006-09-29 02:00:40 -07002023 * Copies the kernel idea of the window size into the user buffer.
Alan Coxaf9b8972006-08-27 01:24:01 -07002024 *
Peter Zijlstra24ec8392006-12-08 02:36:04 -08002025 * Locking: tty->termios_mutex is taken to ensure the winsize data
Alan Cox808a0d32006-09-29 02:00:40 -07002026 * is consistent.
Alan Coxaf9b8972006-08-27 01:24:01 -07002027 */
2028
Alan Cox37bdfb02008-02-08 04:18:47 -08002029static int tiocgwinsz(struct tty_struct *tty, struct winsize __user *arg)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002030{
Alan Cox808a0d32006-09-29 02:00:40 -07002031 int err;
2032
Arjan van de Ven5785c952006-09-29 02:00:43 -07002033 mutex_lock(&tty->termios_mutex);
Alan Cox808a0d32006-09-29 02:00:40 -07002034 err = copy_to_user(arg, &tty->winsize, sizeof(*arg));
Arjan van de Ven5785c952006-09-29 02:00:43 -07002035 mutex_unlock(&tty->termios_mutex);
Alan Cox808a0d32006-09-29 02:00:40 -07002036
2037 return err ? -EFAULT: 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002038}
2039
Alan Coxaf9b8972006-08-27 01:24:01 -07002040/**
Alan Cox8c9a9dd2008-08-15 10:39:38 +01002041 * tty_do_resize - resize event
2042 * @tty: tty being resized
Alan Cox8c9a9dd2008-08-15 10:39:38 +01002043 * @rows: rows (character)
2044 * @cols: cols (character)
Alan Coxaf9b8972006-08-27 01:24:01 -07002045 *
Daniel Mack3ad2f3f2010-02-03 08:01:28 +08002046 * Update the termios variables and send the necessary signals to
Alan Cox8c9a9dd2008-08-15 10:39:38 +01002047 * peform a terminal resize correctly
Alan Coxaf9b8972006-08-27 01:24:01 -07002048 */
2049
Alan Coxfc6f6232009-01-02 13:43:17 +00002050int tty_do_resize(struct tty_struct *tty, struct winsize *ws)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002051{
Alan Coxfc6f6232009-01-02 13:43:17 +00002052 struct pid *pgrp;
Alan Cox47f86832008-04-30 00:53:30 -07002053 unsigned long flags;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002054
Alan Coxfc6f6232009-01-02 13:43:17 +00002055 /* Lock the tty */
2056 mutex_lock(&tty->termios_mutex);
2057 if (!memcmp(ws, &tty->winsize, sizeof(*ws)))
Alan Coxca9bda02006-09-29 02:00:03 -07002058 goto done;
Alan Cox47f86832008-04-30 00:53:30 -07002059 /* Get the PID values and reference them so we can
2060 avoid holding the tty ctrl lock while sending signals */
2061 spin_lock_irqsave(&tty->ctrl_lock, flags);
2062 pgrp = get_pid(tty->pgrp);
Alan Cox47f86832008-04-30 00:53:30 -07002063 spin_unlock_irqrestore(&tty->ctrl_lock, flags);
2064
2065 if (pgrp)
2066 kill_pgrp(pgrp, SIGWINCH, 1);
Alan Cox47f86832008-04-30 00:53:30 -07002067 put_pid(pgrp);
Alan Cox47f86832008-04-30 00:53:30 -07002068
Alan Cox8c9a9dd2008-08-15 10:39:38 +01002069 tty->winsize = *ws;
Alan Coxca9bda02006-09-29 02:00:03 -07002070done:
Alan Coxfc6f6232009-01-02 13:43:17 +00002071 mutex_unlock(&tty->termios_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002072 return 0;
2073}
2074
Alan Coxaf9b8972006-08-27 01:24:01 -07002075/**
Alan Cox8c9a9dd2008-08-15 10:39:38 +01002076 * tiocswinsz - implement window size set ioctl
Alan Coxfc6f6232009-01-02 13:43:17 +00002077 * @tty; tty side of tty
Alan Cox8c9a9dd2008-08-15 10:39:38 +01002078 * @arg: user buffer for result
2079 *
2080 * Copies the user idea of the window size to the kernel. Traditionally
2081 * this is just advisory information but for the Linux console it
2082 * actually has driver level meaning and triggers a VC resize.
2083 *
2084 * Locking:
2085 * Driver dependant. The default do_resize method takes the
2086 * tty termios mutex and ctrl_lock. The console takes its own lock
2087 * then calls into the default method.
2088 */
2089
Alan Coxfc6f6232009-01-02 13:43:17 +00002090static int tiocswinsz(struct tty_struct *tty, struct winsize __user *arg)
Alan Cox8c9a9dd2008-08-15 10:39:38 +01002091{
2092 struct winsize tmp_ws;
2093 if (copy_from_user(&tmp_ws, arg, sizeof(*arg)))
2094 return -EFAULT;
2095
2096 if (tty->ops->resize)
Alan Coxfc6f6232009-01-02 13:43:17 +00002097 return tty->ops->resize(tty, &tmp_ws);
Alan Cox8c9a9dd2008-08-15 10:39:38 +01002098 else
Alan Coxfc6f6232009-01-02 13:43:17 +00002099 return tty_do_resize(tty, &tmp_ws);
Alan Cox8c9a9dd2008-08-15 10:39:38 +01002100}
2101
2102/**
Alan Coxaf9b8972006-08-27 01:24:01 -07002103 * tioccons - allow admin to move logical console
2104 * @file: the file to become console
2105 *
2106 * Allow the adminstrator to move the redirected console device
2107 *
2108 * Locking: uses redirect_lock to guard the redirect information
2109 */
2110
Linus Torvalds1da177e2005-04-16 15:20:36 -07002111static int tioccons(struct file *file)
2112{
2113 if (!capable(CAP_SYS_ADMIN))
2114 return -EPERM;
2115 if (file->f_op->write == redirected_tty_write) {
2116 struct file *f;
2117 spin_lock(&redirect_lock);
2118 f = redirect;
2119 redirect = NULL;
2120 spin_unlock(&redirect_lock);
2121 if (f)
2122 fput(f);
2123 return 0;
2124 }
2125 spin_lock(&redirect_lock);
2126 if (redirect) {
2127 spin_unlock(&redirect_lock);
2128 return -EBUSY;
2129 }
2130 get_file(file);
2131 redirect = file;
2132 spin_unlock(&redirect_lock);
2133 return 0;
2134}
2135
Alan Coxaf9b8972006-08-27 01:24:01 -07002136/**
2137 * fionbio - non blocking ioctl
2138 * @file: file to set blocking value
2139 * @p: user parameter
2140 *
2141 * Historical tty interfaces had a blocking control ioctl before
2142 * the generic functionality existed. This piece of history is preserved
2143 * in the expected tty API of posix OS's.
2144 *
Alan Cox6146b9a2009-09-19 13:13:19 -07002145 * Locking: none, the open file handle ensures it won't go away.
Alan Coxaf9b8972006-08-27 01:24:01 -07002146 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002147
2148static int fionbio(struct file *file, int __user *p)
2149{
2150 int nonblock;
2151
2152 if (get_user(nonblock, p))
2153 return -EFAULT;
2154
Jonathan Corbetdb1dd4d2009-02-06 15:25:24 -07002155 spin_lock(&file->f_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002156 if (nonblock)
2157 file->f_flags |= O_NONBLOCK;
2158 else
2159 file->f_flags &= ~O_NONBLOCK;
Jonathan Corbetdb1dd4d2009-02-06 15:25:24 -07002160 spin_unlock(&file->f_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002161 return 0;
2162}
2163
Alan Coxaf9b8972006-08-27 01:24:01 -07002164/**
2165 * tiocsctty - set controlling tty
2166 * @tty: tty structure
2167 * @arg: user argument
2168 *
2169 * This ioctl is used to manage job control. It permits a session
2170 * leader to set this tty as the controlling tty for the session.
2171 *
2172 * Locking:
Alan Cox28298232006-09-29 02:00:58 -07002173 * Takes tty_mutex() to protect tty instance
Peter Zijlstra24ec8392006-12-08 02:36:04 -08002174 * Takes tasklist_lock internally to walk sessions
2175 * Takes ->siglock() when updating signal->tty
Alan Coxaf9b8972006-08-27 01:24:01 -07002176 */
2177
Linus Torvalds1da177e2005-04-16 15:20:36 -07002178static int tiocsctty(struct tty_struct *tty, int arg)
2179{
Peter Zijlstra24ec8392006-12-08 02:36:04 -08002180 int ret = 0;
Eric W. Biedermanab521dc2007-02-12 00:53:00 -08002181 if (current->signal->leader && (task_session(current) == tty->session))
Peter Zijlstra24ec8392006-12-08 02:36:04 -08002182 return ret;
2183
2184 mutex_lock(&tty_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002185 /*
2186 * The process must be a session leader and
2187 * not have a controlling tty already.
2188 */
Peter Zijlstra24ec8392006-12-08 02:36:04 -08002189 if (!current->signal->leader || current->signal->tty) {
2190 ret = -EPERM;
2191 goto unlock;
2192 }
2193
Eric W. Biedermanab521dc2007-02-12 00:53:00 -08002194 if (tty->session) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002195 /*
2196 * This tty is already the controlling
2197 * tty for another session group!
2198 */
Alan Cox37bdfb02008-02-08 04:18:47 -08002199 if (arg == 1 && capable(CAP_SYS_ADMIN)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002200 /*
2201 * Steal it away
2202 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002203 read_lock(&tasklist_lock);
Peter Zijlstra24ec8392006-12-08 02:36:04 -08002204 session_clear_tty(tty->session);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002205 read_unlock(&tasklist_lock);
Peter Zijlstra24ec8392006-12-08 02:36:04 -08002206 } else {
2207 ret = -EPERM;
2208 goto unlock;
2209 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002210 }
Peter Zijlstra24ec8392006-12-08 02:36:04 -08002211 proc_set_tty(current, tty);
2212unlock:
Alan Cox28298232006-09-29 02:00:58 -07002213 mutex_unlock(&tty_mutex);
Peter Zijlstra24ec8392006-12-08 02:36:04 -08002214 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002215}
2216
Alan Coxaf9b8972006-08-27 01:24:01 -07002217/**
Alan Cox5d0fdf12008-04-30 00:53:31 -07002218 * tty_get_pgrp - return a ref counted pgrp pid
2219 * @tty: tty to read
2220 *
2221 * Returns a refcounted instance of the pid struct for the process
2222 * group controlling the tty.
2223 */
2224
2225struct pid *tty_get_pgrp(struct tty_struct *tty)
2226{
2227 unsigned long flags;
2228 struct pid *pgrp;
2229
2230 spin_lock_irqsave(&tty->ctrl_lock, flags);
2231 pgrp = get_pid(tty->pgrp);
2232 spin_unlock_irqrestore(&tty->ctrl_lock, flags);
2233
2234 return pgrp;
2235}
2236EXPORT_SYMBOL_GPL(tty_get_pgrp);
2237
2238/**
Alan Coxaf9b8972006-08-27 01:24:01 -07002239 * tiocgpgrp - get process group
2240 * @tty: tty passed by user
2241 * @real_tty: tty side of the tty pased by the user if a pty else the tty
2242 * @p: returned pid
2243 *
2244 * Obtain the process group of the tty. If there is no process group
2245 * return an error.
2246 *
Peter Zijlstra24ec8392006-12-08 02:36:04 -08002247 * Locking: none. Reference to current->signal->tty is safe.
Alan Coxaf9b8972006-08-27 01:24:01 -07002248 */
2249
Linus Torvalds1da177e2005-04-16 15:20:36 -07002250static int tiocgpgrp(struct tty_struct *tty, struct tty_struct *real_tty, pid_t __user *p)
2251{
Alan Cox5d0fdf12008-04-30 00:53:31 -07002252 struct pid *pid;
2253 int ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002254 /*
2255 * (tty == real_tty) is a cheap way of
2256 * testing if the tty is NOT a master pty.
2257 */
2258 if (tty == real_tty && current->signal->tty != real_tty)
2259 return -ENOTTY;
Alan Cox5d0fdf12008-04-30 00:53:31 -07002260 pid = tty_get_pgrp(real_tty);
2261 ret = put_user(pid_vnr(pid), p);
2262 put_pid(pid);
2263 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002264}
2265
Alan Coxaf9b8972006-08-27 01:24:01 -07002266/**
2267 * tiocspgrp - attempt to set process group
2268 * @tty: tty passed by user
2269 * @real_tty: tty side device matching tty passed by user
2270 * @p: pid pointer
2271 *
2272 * Set the process group of the tty to the session passed. Only
2273 * permitted where the tty session is our session.
2274 *
Alan Cox47f86832008-04-30 00:53:30 -07002275 * Locking: RCU, ctrl lock
Alan Coxaf9b8972006-08-27 01:24:01 -07002276 */
2277
Linus Torvalds1da177e2005-04-16 15:20:36 -07002278static int tiocspgrp(struct tty_struct *tty, struct tty_struct *real_tty, pid_t __user *p)
2279{
Eric W. Biederman04a2e6a2007-02-12 00:52:56 -08002280 struct pid *pgrp;
2281 pid_t pgrp_nr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002282 int retval = tty_check_change(real_tty);
Alan Cox47f86832008-04-30 00:53:30 -07002283 unsigned long flags;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002284
2285 if (retval == -EIO)
2286 return -ENOTTY;
2287 if (retval)
2288 return retval;
2289 if (!current->signal->tty ||
2290 (current->signal->tty != real_tty) ||
Eric W. Biedermanab521dc2007-02-12 00:53:00 -08002291 (real_tty->session != task_session(current)))
Linus Torvalds1da177e2005-04-16 15:20:36 -07002292 return -ENOTTY;
Eric W. Biederman04a2e6a2007-02-12 00:52:56 -08002293 if (get_user(pgrp_nr, p))
Linus Torvalds1da177e2005-04-16 15:20:36 -07002294 return -EFAULT;
Eric W. Biederman04a2e6a2007-02-12 00:52:56 -08002295 if (pgrp_nr < 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002296 return -EINVAL;
Eric W. Biederman04a2e6a2007-02-12 00:52:56 -08002297 rcu_read_lock();
Pavel Emelyanovb4888932007-10-18 23:40:14 -07002298 pgrp = find_vpid(pgrp_nr);
Eric W. Biederman04a2e6a2007-02-12 00:52:56 -08002299 retval = -ESRCH;
2300 if (!pgrp)
2301 goto out_unlock;
2302 retval = -EPERM;
2303 if (session_of_pgrp(pgrp) != task_session(current))
2304 goto out_unlock;
2305 retval = 0;
Alan Cox47f86832008-04-30 00:53:30 -07002306 spin_lock_irqsave(&tty->ctrl_lock, flags);
Eric W. Biedermanab521dc2007-02-12 00:53:00 -08002307 put_pid(real_tty->pgrp);
2308 real_tty->pgrp = get_pid(pgrp);
Alan Cox47f86832008-04-30 00:53:30 -07002309 spin_unlock_irqrestore(&tty->ctrl_lock, flags);
Eric W. Biederman04a2e6a2007-02-12 00:52:56 -08002310out_unlock:
2311 rcu_read_unlock();
2312 return retval;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002313}
2314
Alan Coxaf9b8972006-08-27 01:24:01 -07002315/**
2316 * tiocgsid - get session id
2317 * @tty: tty passed by user
2318 * @real_tty: tty side of the tty pased by the user if a pty else the tty
2319 * @p: pointer to returned session id
2320 *
2321 * Obtain the session id of the tty. If there is no session
2322 * return an error.
2323 *
Peter Zijlstra24ec8392006-12-08 02:36:04 -08002324 * Locking: none. Reference to current->signal->tty is safe.
Alan Coxaf9b8972006-08-27 01:24:01 -07002325 */
2326
Linus Torvalds1da177e2005-04-16 15:20:36 -07002327static int tiocgsid(struct tty_struct *tty, struct tty_struct *real_tty, pid_t __user *p)
2328{
2329 /*
2330 * (tty == real_tty) is a cheap way of
2331 * testing if the tty is NOT a master pty.
2332 */
2333 if (tty == real_tty && current->signal->tty != real_tty)
2334 return -ENOTTY;
Eric W. Biedermanab521dc2007-02-12 00:53:00 -08002335 if (!real_tty->session)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002336 return -ENOTTY;
Pavel Emelyanovb4888932007-10-18 23:40:14 -07002337 return put_user(pid_vnr(real_tty->session), p);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002338}
2339
Alan Coxaf9b8972006-08-27 01:24:01 -07002340/**
2341 * tiocsetd - set line discipline
2342 * @tty: tty device
2343 * @p: pointer to user data
2344 *
2345 * Set the line discipline according to user request.
2346 *
2347 * Locking: see tty_set_ldisc, this function is just a helper
2348 */
2349
Linus Torvalds1da177e2005-04-16 15:20:36 -07002350static int tiocsetd(struct tty_struct *tty, int __user *p)
2351{
2352 int ldisc;
Alan Cox04f378b2008-04-30 00:53:29 -07002353 int ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002354
2355 if (get_user(ldisc, p))
2356 return -EFAULT;
Alan Cox04f378b2008-04-30 00:53:29 -07002357
Alan Cox04f378b2008-04-30 00:53:29 -07002358 ret = tty_set_ldisc(tty, ldisc);
Alan Cox04f378b2008-04-30 00:53:29 -07002359
2360 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002361}
2362
Alan Coxaf9b8972006-08-27 01:24:01 -07002363/**
2364 * send_break - performed time break
2365 * @tty: device to break on
2366 * @duration: timeout in mS
2367 *
2368 * Perform a timed break on hardware that lacks its own driver level
2369 * timed break functionality.
2370 *
2371 * Locking:
Alan Cox28298232006-09-29 02:00:58 -07002372 * atomic_write_lock serializes
Alan Coxaf9b8972006-08-27 01:24:01 -07002373 *
Alan Coxaf9b8972006-08-27 01:24:01 -07002374 */
2375
Domen Puncerb20f3ae2005-06-25 14:58:42 -07002376static int send_break(struct tty_struct *tty, unsigned int duration)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002377{
Alan Cox9e989662008-07-22 11:18:03 +01002378 int retval;
2379
2380 if (tty->ops->break_ctl == NULL)
2381 return 0;
2382
2383 if (tty->driver->flags & TTY_DRIVER_HARDWARE_BREAK)
2384 retval = tty->ops->break_ctl(tty, duration);
2385 else {
2386 /* Do the work ourselves */
2387 if (tty_write_lock(tty, 0) < 0)
2388 return -EINTR;
2389 retval = tty->ops->break_ctl(tty, -1);
2390 if (retval)
2391 goto out;
2392 if (!signal_pending(current))
2393 msleep_interruptible(duration);
2394 retval = tty->ops->break_ctl(tty, 0);
2395out:
2396 tty_write_unlock(tty);
2397 if (signal_pending(current))
2398 retval = -EINTR;
2399 }
2400 return retval;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002401}
2402
Alan Coxaf9b8972006-08-27 01:24:01 -07002403/**
Alan Coxf34d7a52008-04-30 00:54:13 -07002404 * tty_tiocmget - get modem status
Alan Coxaf9b8972006-08-27 01:24:01 -07002405 * @tty: tty device
2406 * @file: user file pointer
2407 * @p: pointer to result
2408 *
2409 * Obtain the modem status bits from the tty driver if the feature
2410 * is supported. Return -EINVAL if it is not available.
2411 *
2412 * Locking: none (up to the driver)
2413 */
2414
2415static int tty_tiocmget(struct tty_struct *tty, struct file *file, int __user *p)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002416{
2417 int retval = -EINVAL;
2418
Alan Coxf34d7a52008-04-30 00:54:13 -07002419 if (tty->ops->tiocmget) {
2420 retval = tty->ops->tiocmget(tty, file);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002421
2422 if (retval >= 0)
2423 retval = put_user(retval, p);
2424 }
2425 return retval;
2426}
2427
Alan Coxaf9b8972006-08-27 01:24:01 -07002428/**
Alan Coxf34d7a52008-04-30 00:54:13 -07002429 * tty_tiocmset - set modem status
Alan Coxaf9b8972006-08-27 01:24:01 -07002430 * @tty: tty device
2431 * @file: user file pointer
2432 * @cmd: command - clear bits, set bits or set all
2433 * @p: pointer to desired bits
2434 *
2435 * Set the modem status bits from the tty driver if the feature
2436 * is supported. Return -EINVAL if it is not available.
2437 *
2438 * Locking: none (up to the driver)
2439 */
2440
2441static int tty_tiocmset(struct tty_struct *tty, struct file *file, unsigned int cmd,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002442 unsigned __user *p)
2443{
Alan Coxae677512008-07-16 21:56:54 +01002444 int retval;
2445 unsigned int set, clear, val;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002446
Alan Coxae677512008-07-16 21:56:54 +01002447 if (tty->ops->tiocmset == NULL)
2448 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002449
Alan Coxae677512008-07-16 21:56:54 +01002450 retval = get_user(val, p);
2451 if (retval)
2452 return retval;
2453 set = clear = 0;
2454 switch (cmd) {
2455 case TIOCMBIS:
2456 set = val;
2457 break;
2458 case TIOCMBIC:
2459 clear = val;
2460 break;
2461 case TIOCMSET:
2462 set = val;
2463 clear = ~val;
2464 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002465 }
Alan Coxae677512008-07-16 21:56:54 +01002466 set &= TIOCM_DTR|TIOCM_RTS|TIOCM_OUT1|TIOCM_OUT2|TIOCM_LOOP;
2467 clear &= TIOCM_DTR|TIOCM_RTS|TIOCM_OUT1|TIOCM_OUT2|TIOCM_LOOP;
2468 return tty->ops->tiocmset(tty, file, set, clear);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002469}
2470
Alan Coxe8b70e72009-06-11 12:48:02 +01002471struct tty_struct *tty_pair_get_tty(struct tty_struct *tty)
2472{
2473 if (tty->driver->type == TTY_DRIVER_TYPE_PTY &&
2474 tty->driver->subtype == PTY_TYPE_MASTER)
2475 tty = tty->link;
2476 return tty;
2477}
2478EXPORT_SYMBOL(tty_pair_get_tty);
2479
2480struct tty_struct *tty_pair_get_pty(struct tty_struct *tty)
2481{
2482 if (tty->driver->type == TTY_DRIVER_TYPE_PTY &&
2483 tty->driver->subtype == PTY_TYPE_MASTER)
2484 return tty;
2485 return tty->link;
2486}
2487EXPORT_SYMBOL(tty_pair_get_pty);
2488
Linus Torvalds1da177e2005-04-16 15:20:36 -07002489/*
2490 * Split this up, as gcc can choke on it otherwise..
2491 */
Alan Cox04f378b2008-04-30 00:53:29 -07002492long tty_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002493{
2494 struct tty_struct *tty, *real_tty;
2495 void __user *p = (void __user *)arg;
2496 int retval;
2497 struct tty_ldisc *ld;
Alan Cox04f378b2008-04-30 00:53:29 -07002498 struct inode *inode = file->f_dentry->d_inode;
Alan Cox37bdfb02008-02-08 04:18:47 -08002499
Linus Torvalds1da177e2005-04-16 15:20:36 -07002500 tty = (struct tty_struct *)file->private_data;
2501 if (tty_paranoia_check(tty, inode, "tty_ioctl"))
2502 return -EINVAL;
2503
Alan Coxe8b70e72009-06-11 12:48:02 +01002504 real_tty = tty_pair_get_tty(tty);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002505
2506 /*
2507 * Factor out some common prep work
2508 */
2509 switch (cmd) {
2510 case TIOCSETD:
2511 case TIOCSBRK:
2512 case TIOCCBRK:
2513 case TCSBRK:
Alan Cox37bdfb02008-02-08 04:18:47 -08002514 case TCSBRKP:
Linus Torvalds1da177e2005-04-16 15:20:36 -07002515 retval = tty_check_change(tty);
2516 if (retval)
2517 return retval;
2518 if (cmd != TIOCCBRK) {
2519 tty_wait_until_sent(tty, 0);
2520 if (signal_pending(current))
2521 return -EINTR;
2522 }
2523 break;
2524 }
2525
Alan Cox9e989662008-07-22 11:18:03 +01002526 /*
2527 * Now do the stuff.
2528 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002529 switch (cmd) {
Alan Cox37bdfb02008-02-08 04:18:47 -08002530 case TIOCSTI:
2531 return tiocsti(tty, p);
2532 case TIOCGWINSZ:
Alan Cox8f520022008-10-13 10:38:46 +01002533 return tiocgwinsz(real_tty, p);
Alan Cox37bdfb02008-02-08 04:18:47 -08002534 case TIOCSWINSZ:
Alan Coxfc6f6232009-01-02 13:43:17 +00002535 return tiocswinsz(real_tty, p);
Alan Cox37bdfb02008-02-08 04:18:47 -08002536 case TIOCCONS:
2537 return real_tty != tty ? -EINVAL : tioccons(file);
2538 case FIONBIO:
2539 return fionbio(file, p);
2540 case TIOCEXCL:
2541 set_bit(TTY_EXCLUSIVE, &tty->flags);
2542 return 0;
2543 case TIOCNXCL:
2544 clear_bit(TTY_EXCLUSIVE, &tty->flags);
2545 return 0;
2546 case TIOCNOTTY:
2547 if (current->signal->tty != tty)
2548 return -ENOTTY;
2549 no_tty();
2550 return 0;
2551 case TIOCSCTTY:
2552 return tiocsctty(tty, arg);
2553 case TIOCGPGRP:
2554 return tiocgpgrp(tty, real_tty, p);
2555 case TIOCSPGRP:
2556 return tiocspgrp(tty, real_tty, p);
2557 case TIOCGSID:
2558 return tiocgsid(tty, real_tty, p);
2559 case TIOCGETD:
Alan Coxc65c9bc2009-06-11 12:50:12 +01002560 return put_user(tty->ldisc->ops->num, (int __user *)p);
Alan Cox37bdfb02008-02-08 04:18:47 -08002561 case TIOCSETD:
2562 return tiocsetd(tty, p);
Alan Cox37bdfb02008-02-08 04:18:47 -08002563 /*
2564 * Break handling
2565 */
2566 case TIOCSBRK: /* Turn break on, unconditionally */
Alan Coxf34d7a52008-04-30 00:54:13 -07002567 if (tty->ops->break_ctl)
Alan Cox9e989662008-07-22 11:18:03 +01002568 return tty->ops->break_ctl(tty, -1);
Alan Cox37bdfb02008-02-08 04:18:47 -08002569 return 0;
Alan Cox37bdfb02008-02-08 04:18:47 -08002570 case TIOCCBRK: /* Turn break off, unconditionally */
Alan Coxf34d7a52008-04-30 00:54:13 -07002571 if (tty->ops->break_ctl)
Alan Cox9e989662008-07-22 11:18:03 +01002572 return tty->ops->break_ctl(tty, 0);
Alan Cox37bdfb02008-02-08 04:18:47 -08002573 return 0;
2574 case TCSBRK: /* SVID version: non-zero arg --> no break */
2575 /* non-zero arg means wait for all output data
2576 * to be sent (performed above) but don't send break.
2577 * This is used by the tcdrain() termios function.
Linus Torvalds1da177e2005-04-16 15:20:36 -07002578 */
Alan Cox37bdfb02008-02-08 04:18:47 -08002579 if (!arg)
2580 return send_break(tty, 250);
2581 return 0;
2582 case TCSBRKP: /* support for POSIX tcsendbreak() */
2583 return send_break(tty, arg ? arg*100 : 250);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002584
Alan Cox37bdfb02008-02-08 04:18:47 -08002585 case TIOCMGET:
2586 return tty_tiocmget(tty, file, p);
2587 case TIOCMSET:
2588 case TIOCMBIC:
2589 case TIOCMBIS:
2590 return tty_tiocmset(tty, file, cmd, p);
2591 case TCFLSH:
2592 switch (arg) {
2593 case TCIFLUSH:
2594 case TCIOFLUSH:
2595 /* flush tty buffer and allow ldisc to process ioctl */
2596 tty_buffer_flush(tty);
Paul Fulghumc5c34d42007-05-12 10:36:55 -07002597 break;
Alan Cox37bdfb02008-02-08 04:18:47 -08002598 }
2599 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002600 }
Alan Coxf34d7a52008-04-30 00:54:13 -07002601 if (tty->ops->ioctl) {
2602 retval = (tty->ops->ioctl)(tty, file, cmd, arg);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002603 if (retval != -ENOIOCTLCMD)
2604 return retval;
2605 }
2606 ld = tty_ldisc_ref_wait(tty);
2607 retval = -EINVAL;
Alan Coxa352def2008-07-16 21:53:12 +01002608 if (ld->ops->ioctl) {
2609 retval = ld->ops->ioctl(tty, file, cmd, arg);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002610 if (retval == -ENOIOCTLCMD)
2611 retval = -EINVAL;
2612 }
2613 tty_ldisc_deref(ld);
2614 return retval;
2615}
2616
Paul Fulghume10cc1d2007-05-10 22:22:50 -07002617#ifdef CONFIG_COMPAT
Alan Cox37bdfb02008-02-08 04:18:47 -08002618static long tty_compat_ioctl(struct file *file, unsigned int cmd,
Paul Fulghume10cc1d2007-05-10 22:22:50 -07002619 unsigned long arg)
2620{
2621 struct inode *inode = file->f_dentry->d_inode;
2622 struct tty_struct *tty = file->private_data;
2623 struct tty_ldisc *ld;
2624 int retval = -ENOIOCTLCMD;
2625
2626 if (tty_paranoia_check(tty, inode, "tty_ioctl"))
2627 return -EINVAL;
2628
Alan Coxf34d7a52008-04-30 00:54:13 -07002629 if (tty->ops->compat_ioctl) {
2630 retval = (tty->ops->compat_ioctl)(tty, file, cmd, arg);
Paul Fulghume10cc1d2007-05-10 22:22:50 -07002631 if (retval != -ENOIOCTLCMD)
2632 return retval;
2633 }
2634
2635 ld = tty_ldisc_ref_wait(tty);
Alan Coxa352def2008-07-16 21:53:12 +01002636 if (ld->ops->compat_ioctl)
2637 retval = ld->ops->compat_ioctl(tty, file, cmd, arg);
Paul Fulghume10cc1d2007-05-10 22:22:50 -07002638 tty_ldisc_deref(ld);
2639
2640 return retval;
2641}
2642#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07002643
2644/*
2645 * This implements the "Secure Attention Key" --- the idea is to
2646 * prevent trojan horses by killing all processes associated with this
2647 * tty when the user hits the "Secure Attention Key". Required for
2648 * super-paranoid applications --- see the Orange Book for more details.
Alan Cox37bdfb02008-02-08 04:18:47 -08002649 *
Linus Torvalds1da177e2005-04-16 15:20:36 -07002650 * This code could be nicer; ideally it should send a HUP, wait a few
2651 * seconds, then send a INT, and then a KILL signal. But you then
2652 * have to coordinate with the init process, since all processes associated
2653 * with the current tty must be dead before the new getty is allowed
2654 * to spawn.
2655 *
2656 * Now, if it would be correct ;-/ The current code has a nasty hole -
2657 * it doesn't catch files in flight. We may send the descriptor to ourselves
2658 * via AF_UNIX socket, close it and later fetch from socket. FIXME.
2659 *
2660 * Nasty bug: do_SAK is being called in interrupt context. This can
2661 * deadlock. We punt it up to process context. AKPM - 16Mar2001
2662 */
Eric W. Biederman8b6312f2007-02-10 01:44:34 -08002663void __do_SAK(struct tty_struct *tty)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002664{
2665#ifdef TTY_SOFT_SAK
2666 tty_hangup(tty);
2667#else
Eric W. Biederman652486f2006-03-28 16:11:02 -08002668 struct task_struct *g, *p;
Eric W. Biedermanab521dc2007-02-12 00:53:00 -08002669 struct pid *session;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002670 int i;
2671 struct file *filp;
Dipankar Sarmabadf1662005-09-09 13:04:10 -07002672 struct fdtable *fdt;
Alan Cox37bdfb02008-02-08 04:18:47 -08002673
Linus Torvalds1da177e2005-04-16 15:20:36 -07002674 if (!tty)
2675 return;
Peter Zijlstra24ec8392006-12-08 02:36:04 -08002676 session = tty->session;
Alan Cox37bdfb02008-02-08 04:18:47 -08002677
Dan Carpenterb3f13de2006-12-13 00:35:09 -08002678 tty_ldisc_flush(tty);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002679
Alan Coxf34d7a52008-04-30 00:54:13 -07002680 tty_driver_flush_buffer(tty);
Alan Cox37bdfb02008-02-08 04:18:47 -08002681
Linus Torvalds1da177e2005-04-16 15:20:36 -07002682 read_lock(&tasklist_lock);
Eric W. Biederman652486f2006-03-28 16:11:02 -08002683 /* Kill the entire session */
Eric W. Biedermanab521dc2007-02-12 00:53:00 -08002684 do_each_pid_task(session, PIDTYPE_SID, p) {
Eric W. Biederman652486f2006-03-28 16:11:02 -08002685 printk(KERN_NOTICE "SAK: killed process %d"
Oleg Nesterov1b0f7ff2009-04-02 16:58:39 -07002686 " (%s): task_session(p)==tty->session\n",
Pavel Emelyanovba25f9d2007-10-18 23:40:40 -07002687 task_pid_nr(p), p->comm);
Eric W. Biederman652486f2006-03-28 16:11:02 -08002688 send_sig(SIGKILL, p, 1);
Eric W. Biedermanab521dc2007-02-12 00:53:00 -08002689 } while_each_pid_task(session, PIDTYPE_SID, p);
Eric W. Biederman652486f2006-03-28 16:11:02 -08002690 /* Now kill any processes that happen to have the
2691 * tty open.
2692 */
2693 do_each_thread(g, p) {
2694 if (p->signal->tty == tty) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002695 printk(KERN_NOTICE "SAK: killed process %d"
Oleg Nesterov1b0f7ff2009-04-02 16:58:39 -07002696 " (%s): task_session(p)==tty->session\n",
Pavel Emelyanovba25f9d2007-10-18 23:40:40 -07002697 task_pid_nr(p), p->comm);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002698 send_sig(SIGKILL, p, 1);
2699 continue;
2700 }
2701 task_lock(p);
2702 if (p->files) {
Dipankar Sarmaca99c1d2006-04-18 22:21:46 -07002703 /*
2704 * We don't take a ref to the file, so we must
2705 * hold ->file_lock instead.
2706 */
2707 spin_lock(&p->files->file_lock);
Dipankar Sarmabadf1662005-09-09 13:04:10 -07002708 fdt = files_fdtable(p->files);
Alan Cox37bdfb02008-02-08 04:18:47 -08002709 for (i = 0; i < fdt->max_fds; i++) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002710 filp = fcheck_files(p->files, i);
2711 if (!filp)
2712 continue;
2713 if (filp->f_op->read == tty_read &&
2714 filp->private_data == tty) {
2715 printk(KERN_NOTICE "SAK: killed process %d"
2716 " (%s): fd#%d opened to the tty\n",
Pavel Emelyanovba25f9d2007-10-18 23:40:40 -07002717 task_pid_nr(p), p->comm, i);
Eric W. Biederman20ac9432006-04-13 04:49:07 -06002718 force_sig(SIGKILL, p);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002719 break;
2720 }
2721 }
Dipankar Sarmaca99c1d2006-04-18 22:21:46 -07002722 spin_unlock(&p->files->file_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002723 }
2724 task_unlock(p);
Eric W. Biederman652486f2006-03-28 16:11:02 -08002725 } while_each_thread(g, p);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002726 read_unlock(&tasklist_lock);
2727#endif
2728}
2729
Eric W. Biederman8b6312f2007-02-10 01:44:34 -08002730static void do_SAK_work(struct work_struct *work)
2731{
2732 struct tty_struct *tty =
2733 container_of(work, struct tty_struct, SAK_work);
2734 __do_SAK(tty);
2735}
2736
Linus Torvalds1da177e2005-04-16 15:20:36 -07002737/*
2738 * The tq handling here is a little racy - tty->SAK_work may already be queued.
2739 * Fortunately we don't need to worry, because if ->SAK_work is already queued,
2740 * the values which we write to it will be identical to the values which it
2741 * already has. --akpm
2742 */
2743void do_SAK(struct tty_struct *tty)
2744{
2745 if (!tty)
2746 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002747 schedule_work(&tty->SAK_work);
2748}
2749
2750EXPORT_SYMBOL(do_SAK);
2751
Alan Coxaf9b8972006-08-27 01:24:01 -07002752/**
Alan Coxaf9b8972006-08-27 01:24:01 -07002753 * initialize_tty_struct
2754 * @tty: tty to initialize
2755 *
2756 * This subroutine initializes a tty structure that has been newly
2757 * allocated.
2758 *
2759 * Locking: none - tty in question must not be exposed at this point
Linus Torvalds1da177e2005-04-16 15:20:36 -07002760 */
Alan Coxaf9b8972006-08-27 01:24:01 -07002761
Alan Coxbf970ee2008-10-13 10:42:39 +01002762void initialize_tty_struct(struct tty_struct *tty,
2763 struct tty_driver *driver, int idx)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002764{
2765 memset(tty, 0, sizeof(struct tty_struct));
Alan Cox9c9f4de2008-10-13 10:37:26 +01002766 kref_init(&tty->kref);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002767 tty->magic = TTY_MAGIC;
Alan Cox01e1abb2008-07-22 11:16:55 +01002768 tty_ldisc_init(tty);
Eric W. Biedermanab521dc2007-02-12 00:53:00 -08002769 tty->session = NULL;
2770 tty->pgrp = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002771 tty->overrun_time = jiffies;
Alan Cox33f0f882006-01-09 20:54:13 -08002772 tty->buf.head = tty->buf.tail = NULL;
2773 tty_buffer_init(tty);
Arjan van de Ven5785c952006-09-29 02:00:43 -07002774 mutex_init(&tty->termios_mutex);
Alan Coxc65c9bc2009-06-11 12:50:12 +01002775 mutex_init(&tty->ldisc_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002776 init_waitqueue_head(&tty->write_wait);
2777 init_waitqueue_head(&tty->read_wait);
David Howells65f27f32006-11-22 14:55:48 +00002778 INIT_WORK(&tty->hangup_work, do_tty_hangup);
Ingo Molnar70522e12006-03-23 03:00:31 -08002779 mutex_init(&tty->atomic_read_lock);
2780 mutex_init(&tty->atomic_write_lock);
Joe Petersona88a69c2009-01-02 13:40:53 +00002781 mutex_init(&tty->output_lock);
2782 mutex_init(&tty->echo_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002783 spin_lock_init(&tty->read_lock);
Alan Cox04f378b2008-04-30 00:53:29 -07002784 spin_lock_init(&tty->ctrl_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002785 INIT_LIST_HEAD(&tty->tty_files);
Eric W. Biederman7f1f86a2007-02-13 14:38:58 -07002786 INIT_WORK(&tty->SAK_work, do_SAK_work);
Alan Coxbf970ee2008-10-13 10:42:39 +01002787
2788 tty->driver = driver;
2789 tty->ops = driver->ops;
2790 tty->index = idx;
2791 tty_line_name(driver, idx, tty->name);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002792}
2793
Alan Coxf34d7a52008-04-30 00:54:13 -07002794/**
2795 * tty_put_char - write one character to a tty
2796 * @tty: tty
2797 * @ch: character
2798 *
2799 * Write one byte to the tty using the provided put_char method
2800 * if present. Returns the number of characters successfully output.
2801 *
2802 * Note: the specific put_char operation in the driver layer may go
2803 * away soon. Don't call it directly, use this method
Linus Torvalds1da177e2005-04-16 15:20:36 -07002804 */
Alan Coxaf9b8972006-08-27 01:24:01 -07002805
Alan Coxf34d7a52008-04-30 00:54:13 -07002806int tty_put_char(struct tty_struct *tty, unsigned char ch)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002807{
Alan Coxf34d7a52008-04-30 00:54:13 -07002808 if (tty->ops->put_char)
2809 return tty->ops->put_char(tty, ch);
2810 return tty->ops->write(tty, &ch, 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002811}
Alan Coxf34d7a52008-04-30 00:54:13 -07002812EXPORT_SYMBOL_GPL(tty_put_char);
2813
Alan Coxd81ed102008-10-13 10:41:42 +01002814struct class *tty_class;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002815
2816/**
Alan Coxaf9b8972006-08-27 01:24:01 -07002817 * tty_register_device - register a tty device
2818 * @driver: the tty driver that describes the tty device
2819 * @index: the index in the tty driver for this tty device
2820 * @device: a struct device that is associated with this tty device.
2821 * This field is optional, if there is no known struct device
2822 * for this tty device it can be set to NULL safely.
Linus Torvalds1da177e2005-04-16 15:20:36 -07002823 *
Greg Kroah-Hartman01107d32006-08-07 22:19:37 -07002824 * Returns a pointer to the struct device for this tty device
2825 * (or ERR_PTR(-EFOO) on error).
Hansjoerg Lipp1cdcb6b2006-04-22 18:36:53 +02002826 *
Alan Coxaf9b8972006-08-27 01:24:01 -07002827 * This call is required to be made to register an individual tty device
2828 * if the tty driver's flags have the TTY_DRIVER_DYNAMIC_DEV bit set. If
2829 * that bit is not set, this function should not be called by a tty
2830 * driver.
2831 *
2832 * Locking: ??
Linus Torvalds1da177e2005-04-16 15:20:36 -07002833 */
Alan Coxaf9b8972006-08-27 01:24:01 -07002834
Greg Kroah-Hartman01107d32006-08-07 22:19:37 -07002835struct device *tty_register_device(struct tty_driver *driver, unsigned index,
2836 struct device *device)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002837{
2838 char name[64];
2839 dev_t dev = MKDEV(driver->major, driver->minor_start) + index;
2840
2841 if (index >= driver->num) {
2842 printk(KERN_ERR "Attempt to register invalid tty line number "
2843 " (%d).\n", index);
Hansjoerg Lipp1cdcb6b2006-04-22 18:36:53 +02002844 return ERR_PTR(-EINVAL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002845 }
2846
Linus Torvalds1da177e2005-04-16 15:20:36 -07002847 if (driver->type == TTY_DRIVER_TYPE_PTY)
2848 pty_line_name(driver, index, name);
2849 else
2850 tty_line_name(driver, index, name);
Hansjoerg Lipp1cdcb6b2006-04-22 18:36:53 +02002851
Greg Kroah-Hartman03457cd2008-07-21 20:03:34 -07002852 return device_create(tty_class, device, dev, NULL, name);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002853}
Alan Cox7d7b93c2008-10-13 10:42:09 +01002854EXPORT_SYMBOL(tty_register_device);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002855
2856/**
Alan Coxaf9b8972006-08-27 01:24:01 -07002857 * tty_unregister_device - unregister a tty device
2858 * @driver: the tty driver that describes the tty device
2859 * @index: the index in the tty driver for this tty device
Linus Torvalds1da177e2005-04-16 15:20:36 -07002860 *
Alan Coxaf9b8972006-08-27 01:24:01 -07002861 * If a tty device is registered with a call to tty_register_device() then
2862 * this function must be called when the tty device is gone.
2863 *
2864 * Locking: ??
Linus Torvalds1da177e2005-04-16 15:20:36 -07002865 */
Alan Coxaf9b8972006-08-27 01:24:01 -07002866
Linus Torvalds1da177e2005-04-16 15:20:36 -07002867void tty_unregister_device(struct tty_driver *driver, unsigned index)
2868{
Alan Cox37bdfb02008-02-08 04:18:47 -08002869 device_destroy(tty_class,
2870 MKDEV(driver->major, driver->minor_start) + index);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002871}
Linus Torvalds1da177e2005-04-16 15:20:36 -07002872EXPORT_SYMBOL(tty_unregister_device);
2873
2874struct tty_driver *alloc_tty_driver(int lines)
2875{
2876 struct tty_driver *driver;
2877
Jean Delvare506eb992007-07-15 23:40:14 -07002878 driver = kzalloc(sizeof(struct tty_driver), GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002879 if (driver) {
Alan Cox7d7b93c2008-10-13 10:42:09 +01002880 kref_init(&driver->kref);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002881 driver->magic = TTY_DRIVER_MAGIC;
2882 driver->num = lines;
2883 /* later we'll move allocation of tables here */
2884 }
2885 return driver;
2886}
Alan Cox7d7b93c2008-10-13 10:42:09 +01002887EXPORT_SYMBOL(alloc_tty_driver);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002888
Alan Cox7d7b93c2008-10-13 10:42:09 +01002889static void destruct_tty_driver(struct kref *kref)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002890{
Alan Cox7d7b93c2008-10-13 10:42:09 +01002891 struct tty_driver *driver = container_of(kref, struct tty_driver, kref);
2892 int i;
2893 struct ktermios *tp;
2894 void *p;
2895
2896 if (driver->flags & TTY_DRIVER_INSTALLED) {
2897 /*
2898 * Free the termios and termios_locked structures because
2899 * we don't want to get memory leaks when modular tty
2900 * drivers are removed from the kernel.
2901 */
2902 for (i = 0; i < driver->num; i++) {
2903 tp = driver->termios[i];
2904 if (tp) {
2905 driver->termios[i] = NULL;
2906 kfree(tp);
2907 }
Alan Cox7d7b93c2008-10-13 10:42:09 +01002908 if (!(driver->flags & TTY_DRIVER_DYNAMIC_DEV))
2909 tty_unregister_device(driver, i);
2910 }
2911 p = driver->ttys;
2912 proc_tty_unregister_driver(driver);
2913 driver->ttys = NULL;
Alan Coxfe6e29f2008-10-13 10:44:08 +01002914 driver->termios = NULL;
Alan Cox7d7b93c2008-10-13 10:42:09 +01002915 kfree(p);
2916 cdev_del(&driver->cdev);
2917 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002918 kfree(driver);
2919}
2920
Alan Cox7d7b93c2008-10-13 10:42:09 +01002921void tty_driver_kref_put(struct tty_driver *driver)
2922{
2923 kref_put(&driver->kref, destruct_tty_driver);
2924}
2925EXPORT_SYMBOL(tty_driver_kref_put);
2926
Jeff Dikeb68e31d2006-10-02 02:17:18 -07002927void tty_set_operations(struct tty_driver *driver,
2928 const struct tty_operations *op)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002929{
Alan Coxf34d7a52008-04-30 00:54:13 -07002930 driver->ops = op;
2931};
Linus Torvalds1da177e2005-04-16 15:20:36 -07002932EXPORT_SYMBOL(tty_set_operations);
2933
Alan Cox7d7b93c2008-10-13 10:42:09 +01002934void put_tty_driver(struct tty_driver *d)
2935{
2936 tty_driver_kref_put(d);
2937}
2938EXPORT_SYMBOL(put_tty_driver);
2939
Linus Torvalds1da177e2005-04-16 15:20:36 -07002940/*
2941 * Called by a tty driver to register itself.
2942 */
2943int tty_register_driver(struct tty_driver *driver)
2944{
2945 int error;
Alan Cox37bdfb02008-02-08 04:18:47 -08002946 int i;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002947 dev_t dev;
2948 void **p = NULL;
2949
Andy Whitcroft543691a2007-05-06 14:49:33 -07002950 if (!(driver->flags & TTY_DRIVER_DEVPTS_MEM) && driver->num) {
Alan Coxfe6e29f2008-10-13 10:44:08 +01002951 p = kzalloc(driver->num * 2 * sizeof(void *), GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002952 if (!p)
2953 return -ENOMEM;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002954 }
2955
2956 if (!driver->major) {
Alan Cox37bdfb02008-02-08 04:18:47 -08002957 error = alloc_chrdev_region(&dev, driver->minor_start,
2958 driver->num, driver->name);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002959 if (!error) {
2960 driver->major = MAJOR(dev);
2961 driver->minor_start = MINOR(dev);
2962 }
2963 } else {
2964 dev = MKDEV(driver->major, driver->minor_start);
Geert Uytterhoevene5717c42007-02-20 15:45:21 +01002965 error = register_chrdev_region(dev, driver->num, driver->name);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002966 }
2967 if (error < 0) {
2968 kfree(p);
2969 return error;
2970 }
2971
2972 if (p) {
2973 driver->ttys = (struct tty_struct **)p;
Alan Coxedc6afc2006-12-08 02:38:44 -08002974 driver->termios = (struct ktermios **)(p + driver->num);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002975 } else {
2976 driver->ttys = NULL;
2977 driver->termios = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002978 }
2979
2980 cdev_init(&driver->cdev, &tty_fops);
2981 driver->cdev.owner = driver->owner;
2982 error = cdev_add(&driver->cdev, dev, driver->num);
2983 if (error) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002984 unregister_chrdev_region(dev, driver->num);
2985 driver->ttys = NULL;
Alan Coxfe6e29f2008-10-13 10:44:08 +01002986 driver->termios = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002987 kfree(p);
2988 return error;
2989 }
2990
Alexey Dobriyanca509f62007-05-08 00:27:12 -07002991 mutex_lock(&tty_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002992 list_add(&driver->tty_drivers, &tty_drivers);
Alexey Dobriyanca509f62007-05-08 00:27:12 -07002993 mutex_unlock(&tty_mutex);
Alan Cox37bdfb02008-02-08 04:18:47 -08002994
2995 if (!(driver->flags & TTY_DRIVER_DYNAMIC_DEV)) {
2996 for (i = 0; i < driver->num; i++)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002997 tty_register_device(driver, i, NULL);
2998 }
2999 proc_tty_register_driver(driver);
Alan Cox7d7b93c2008-10-13 10:42:09 +01003000 driver->flags |= TTY_DRIVER_INSTALLED;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003001 return 0;
3002}
3003
3004EXPORT_SYMBOL(tty_register_driver);
3005
3006/*
3007 * Called by a tty driver to unregister itself.
3008 */
3009int tty_unregister_driver(struct tty_driver *driver)
3010{
Alan Cox7d7b93c2008-10-13 10:42:09 +01003011#if 0
3012 /* FIXME */
Linus Torvalds1da177e2005-04-16 15:20:36 -07003013 if (driver->refcount)
3014 return -EBUSY;
Alan Cox7d7b93c2008-10-13 10:42:09 +01003015#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07003016 unregister_chrdev_region(MKDEV(driver->major, driver->minor_start),
3017 driver->num);
Alexey Dobriyanca509f62007-05-08 00:27:12 -07003018 mutex_lock(&tty_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003019 list_del(&driver->tty_drivers);
Alexey Dobriyanca509f62007-05-08 00:27:12 -07003020 mutex_unlock(&tty_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003021 return 0;
3022}
Alan Cox7d7b93c2008-10-13 10:42:09 +01003023
Linus Torvalds1da177e2005-04-16 15:20:36 -07003024EXPORT_SYMBOL(tty_unregister_driver);
3025
Peter Zijlstra24ec8392006-12-08 02:36:04 -08003026dev_t tty_devnum(struct tty_struct *tty)
3027{
3028 return MKDEV(tty->driver->major, tty->driver->minor_start) + tty->index;
3029}
3030EXPORT_SYMBOL(tty_devnum);
3031
3032void proc_clear_tty(struct task_struct *p)
3033{
Arjan van de Ven7c3b1dc2008-10-15 10:52:34 +01003034 unsigned long flags;
Alan Cox9c9f4de2008-10-13 10:37:26 +01003035 struct tty_struct *tty;
Arjan van de Ven7c3b1dc2008-10-15 10:52:34 +01003036 spin_lock_irqsave(&p->sighand->siglock, flags);
Alan Cox9c9f4de2008-10-13 10:37:26 +01003037 tty = p->signal->tty;
Peter Zijlstra24ec8392006-12-08 02:36:04 -08003038 p->signal->tty = NULL;
Arjan van de Ven7c3b1dc2008-10-15 10:52:34 +01003039 spin_unlock_irqrestore(&p->sighand->siglock, flags);
Alan Cox9c9f4de2008-10-13 10:37:26 +01003040 tty_kref_put(tty);
Peter Zijlstra24ec8392006-12-08 02:36:04 -08003041}
Peter Zijlstra24ec8392006-12-08 02:36:04 -08003042
Alan Cox47f86832008-04-30 00:53:30 -07003043/* Called under the sighand lock */
3044
Eric W. Biederman2a65f1d2007-05-08 00:26:53 -07003045static void __proc_set_tty(struct task_struct *tsk, struct tty_struct *tty)
Peter Zijlstra24ec8392006-12-08 02:36:04 -08003046{
3047 if (tty) {
Alan Cox47f86832008-04-30 00:53:30 -07003048 unsigned long flags;
3049 /* We should not have a session or pgrp to put here but.... */
3050 spin_lock_irqsave(&tty->ctrl_lock, flags);
Eric W. Biedermand9c1e9a2007-03-18 12:45:44 -06003051 put_pid(tty->session);
3052 put_pid(tty->pgrp);
Eric W. Biedermanab521dc2007-02-12 00:53:00 -08003053 tty->pgrp = get_pid(task_pgrp(tsk));
Alan Cox47f86832008-04-30 00:53:30 -07003054 spin_unlock_irqrestore(&tty->ctrl_lock, flags);
3055 tty->session = get_pid(task_session(tsk));
Alan Cox9c9f4de2008-10-13 10:37:26 +01003056 if (tsk->signal->tty) {
3057 printk(KERN_DEBUG "tty not NULL!!\n");
3058 tty_kref_put(tsk->signal->tty);
3059 }
Peter Zijlstra24ec8392006-12-08 02:36:04 -08003060 }
Eric W. Biederman2a65f1d2007-05-08 00:26:53 -07003061 put_pid(tsk->signal->tty_old_pgrp);
Alan Cox9c9f4de2008-10-13 10:37:26 +01003062 tsk->signal->tty = tty_kref_get(tty);
Eric W. Biedermanab521dc2007-02-12 00:53:00 -08003063 tsk->signal->tty_old_pgrp = NULL;
Peter Zijlstra24ec8392006-12-08 02:36:04 -08003064}
3065
Eric W. Biederman98a27ba2007-05-08 00:26:56 -07003066static void proc_set_tty(struct task_struct *tsk, struct tty_struct *tty)
Peter Zijlstra24ec8392006-12-08 02:36:04 -08003067{
3068 spin_lock_irq(&tsk->sighand->siglock);
Eric W. Biederman2a65f1d2007-05-08 00:26:53 -07003069 __proc_set_tty(tsk, tty);
Peter Zijlstra24ec8392006-12-08 02:36:04 -08003070 spin_unlock_irq(&tsk->sighand->siglock);
3071}
3072
3073struct tty_struct *get_current_tty(void)
3074{
3075 struct tty_struct *tty;
Alan Cox934e6eb2008-10-13 10:40:43 +01003076 unsigned long flags;
3077
3078 spin_lock_irqsave(&current->sighand->siglock, flags);
Alan Cox452a00d2008-10-13 10:39:13 +01003079 tty = tty_kref_get(current->signal->tty);
Alan Cox934e6eb2008-10-13 10:40:43 +01003080 spin_unlock_irqrestore(&current->sighand->siglock, flags);
Peter Zijlstra24ec8392006-12-08 02:36:04 -08003081 return tty;
3082}
Heiko Carstensa311f742006-12-13 00:33:41 -08003083EXPORT_SYMBOL_GPL(get_current_tty);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003084
Alan Coxd81ed102008-10-13 10:41:42 +01003085void tty_default_fops(struct file_operations *fops)
3086{
3087 *fops = tty_fops;
3088}
3089
Linus Torvalds1da177e2005-04-16 15:20:36 -07003090/*
3091 * Initialize the console device. This is called *early*, so
3092 * we can't necessarily depend on lots of kernel help here.
3093 * Just do some early initializations, and do the complex setup
3094 * later.
3095 */
3096void __init console_init(void)
3097{
3098 initcall_t *call;
3099
3100 /* Setup the default TTY line discipline. */
Alan Cox01e1abb2008-07-22 11:16:55 +01003101 tty_ldisc_begin();
Linus Torvalds1da177e2005-04-16 15:20:36 -07003102
3103 /*
Alan Cox37bdfb02008-02-08 04:18:47 -08003104 * set up the console device so that later boot sequences can
Linus Torvalds1da177e2005-04-16 15:20:36 -07003105 * inform about problems etc..
3106 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07003107 call = __con_initcall_start;
3108 while (call < __con_initcall_end) {
3109 (*call)();
3110 call++;
3111 }
3112}
3113
Kay Sieverse454cea2009-09-18 23:01:12 +02003114static char *tty_devnode(struct device *dev, mode_t *mode)
3115{
3116 if (!mode)
3117 return NULL;
3118 if (dev->devt == MKDEV(TTYAUX_MAJOR, 0) ||
3119 dev->devt == MKDEV(TTYAUX_MAJOR, 2))
3120 *mode = 0666;
3121 return NULL;
3122}
3123
Linus Torvalds1da177e2005-04-16 15:20:36 -07003124static int __init tty_class_init(void)
3125{
gregkh@suse.de7fe845d2005-03-15 14:23:15 -08003126 tty_class = class_create(THIS_MODULE, "tty");
Linus Torvalds1da177e2005-04-16 15:20:36 -07003127 if (IS_ERR(tty_class))
3128 return PTR_ERR(tty_class);
Kay Sieverse454cea2009-09-18 23:01:12 +02003129 tty_class->devnode = tty_devnode;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003130 return 0;
3131}
3132
3133postcore_initcall(tty_class_init);
3134
3135/* 3/2004 jmc: why do these devices exist? */
3136
3137static struct cdev tty_cdev, console_cdev;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003138
3139/*
3140 * Ok, now we can initialize the rest of the tty devices and can count
3141 * on memory allocations, interrupts etc..
3142 */
David Howells31d1d482010-08-06 16:34:43 +01003143int __init tty_init(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003144{
3145 cdev_init(&tty_cdev, &tty_fops);
3146 if (cdev_add(&tty_cdev, MKDEV(TTYAUX_MAJOR, 0), 1) ||
3147 register_chrdev_region(MKDEV(TTYAUX_MAJOR, 0), 1, "/dev/tty") < 0)
3148 panic("Couldn't register /dev/tty driver\n");
Alan Coxd81ed102008-10-13 10:41:42 +01003149 device_create(tty_class, NULL, MKDEV(TTYAUX_MAJOR, 0), NULL,
Greg Kroah-Hartman47aa5792008-05-21 12:52:33 -07003150 "tty");
Linus Torvalds1da177e2005-04-16 15:20:36 -07003151
3152 cdev_init(&console_cdev, &console_fops);
3153 if (cdev_add(&console_cdev, MKDEV(TTYAUX_MAJOR, 1), 1) ||
3154 register_chrdev_region(MKDEV(TTYAUX_MAJOR, 1), 1, "/dev/console") < 0)
3155 panic("Couldn't register /dev/console driver\n");
Alan Coxd81ed102008-10-13 10:41:42 +01003156 device_create(tty_class, NULL, MKDEV(TTYAUX_MAJOR, 1), NULL,
Greg Kroah-Hartman47aa5792008-05-21 12:52:33 -07003157 "console");
Linus Torvalds1da177e2005-04-16 15:20:36 -07003158
Linus Torvalds1da177e2005-04-16 15:20:36 -07003159#ifdef CONFIG_VT
Alan Coxd81ed102008-10-13 10:41:42 +01003160 vty_init(&console_fops);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003161#endif
3162 return 0;
3163}
David Howells31d1d482010-08-06 16:34:43 +01003164