blob: a3afa0c387cdeb79c9dc9a406eb70935ceaf50d4 [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 *);
145static int tty_release(struct inode *, struct file *);
Alan Cox04f378b2008-04-30 00:53:29 -0700146long tty_ioctl(struct file *file, unsigned int cmd, unsigned long arg);
Paul Fulghume10cc1d2007-05-10 22:22:50 -0700147#ifdef CONFIG_COMPAT
Alan Cox37bdfb02008-02-08 04:18:47 -0800148static long tty_compat_ioctl(struct file *file, unsigned int cmd,
Paul Fulghume10cc1d2007-05-10 22:22:50 -0700149 unsigned long arg);
150#else
151#define tty_compat_ioctl NULL
152#endif
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/**
Alan Coxaf9b8972006-08-27 01:24:01 -0700474 * do_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:
487 * BKL
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 */
David Howells65f27f32006-11-22 14:55:48 +0000495static void do_tty_hangup(struct work_struct *work)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700496{
David Howells65f27f32006-11-22 14:55:48 +0000497 struct tty_struct *tty =
498 container_of(work, struct tty_struct, hangup_work);
Alan Cox37bdfb02008-02-08 04:18:47 -0800499 struct file *cons_filp = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700500 struct file *filp, *f = NULL;
501 struct task_struct *p;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700502 int closecount = 0, n;
Alan Cox47f86832008-04-30 00:53:30 -0700503 unsigned long flags;
Alan Cox9c9f4de2008-10-13 10:37:26 +0100504 int refs = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700505
506 if (!tty)
507 return;
508
509 /* inuse_filps is protected by the single kernel lock */
510 lock_kernel();
511
512 spin_lock(&redirect_lock);
513 if (redirect && redirect->private_data == tty) {
514 f = redirect;
515 redirect = NULL;
516 }
517 spin_unlock(&redirect_lock);
Alan Cox37bdfb02008-02-08 04:18:47 -0800518
Linus Torvalds1da177e2005-04-16 15:20:36 -0700519 check_tty_count(tty, "do_tty_hangup");
520 file_list_lock();
521 /* This breaks for file handles being sent over AF_UNIX sockets ? */
Eric Dumazet2f512012005-10-30 15:02:16 -0800522 list_for_each_entry(filp, &tty->tty_files, f_u.fu_list) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700523 if (filp->f_op->write == redirected_tty_write)
524 cons_filp = filp;
525 if (filp->f_op->write != tty_write)
526 continue;
527 closecount++;
528 tty_fasync(-1, filp, 0); /* can't block */
529 filp->f_op = &hung_up_tty_fops;
530 }
531 file_list_unlock();
Alan Cox37bdfb02008-02-08 04:18:47 -0800532
Alan Coxc65c9bc2009-06-11 12:50:12 +0100533 tty_ldisc_hangup(tty);
Alan Cox37bdfb02008-02-08 04:18:47 -0800534
Linus Torvalds1da177e2005-04-16 15:20:36 -0700535 read_lock(&tasklist_lock);
Eric W. Biedermanab521dc2007-02-12 00:53:00 -0800536 if (tty->session) {
537 do_each_pid_task(tty->session, PIDTYPE_SID, p) {
Peter Zijlstra24ec8392006-12-08 02:36:04 -0800538 spin_lock_irq(&p->sighand->siglock);
Alan Cox9c9f4de2008-10-13 10:37:26 +0100539 if (p->signal->tty == tty) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700540 p->signal->tty = NULL;
Alan Cox9c9f4de2008-10-13 10:37:26 +0100541 /* We defer the dereferences outside fo
542 the tasklist lock */
543 refs++;
544 }
Peter Zijlstra24ec8392006-12-08 02:36:04 -0800545 if (!p->signal->leader) {
546 spin_unlock_irq(&p->sighand->siglock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700547 continue;
Peter Zijlstra24ec8392006-12-08 02:36:04 -0800548 }
549 __group_send_sig_info(SIGHUP, SEND_SIG_PRIV, p);
550 __group_send_sig_info(SIGCONT, SEND_SIG_PRIV, p);
Eric W. Biedermanab521dc2007-02-12 00:53:00 -0800551 put_pid(p->signal->tty_old_pgrp); /* A noop */
Alan Cox47f86832008-04-30 00:53:30 -0700552 spin_lock_irqsave(&tty->ctrl_lock, flags);
Eric W. Biedermanab521dc2007-02-12 00:53:00 -0800553 if (tty->pgrp)
554 p->signal->tty_old_pgrp = get_pid(tty->pgrp);
Alan Cox47f86832008-04-30 00:53:30 -0700555 spin_unlock_irqrestore(&tty->ctrl_lock, flags);
Peter Zijlstra24ec8392006-12-08 02:36:04 -0800556 spin_unlock_irq(&p->sighand->siglock);
Eric W. Biedermanab521dc2007-02-12 00:53:00 -0800557 } while_each_pid_task(tty->session, PIDTYPE_SID, p);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700558 }
559 read_unlock(&tasklist_lock);
560
Alan Cox47f86832008-04-30 00:53:30 -0700561 spin_lock_irqsave(&tty->ctrl_lock, flags);
Alan Coxc65c9bc2009-06-11 12:50:12 +0100562 clear_bit(TTY_THROTTLED, &tty->flags);
563 clear_bit(TTY_PUSH, &tty->flags);
564 clear_bit(TTY_DO_WRITE_WAKEUP, &tty->flags);
Eric W. Biedermand9c1e9a2007-03-18 12:45:44 -0600565 put_pid(tty->session);
566 put_pid(tty->pgrp);
Eric W. Biedermanab521dc2007-02-12 00:53:00 -0800567 tty->session = NULL;
568 tty->pgrp = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700569 tty->ctrl_status = 0;
Alan Coxc65c9bc2009-06-11 12:50:12 +0100570 set_bit(TTY_HUPPED, &tty->flags);
Alan Cox47f86832008-04-30 00:53:30 -0700571 spin_unlock_irqrestore(&tty->ctrl_lock, flags);
572
Alan Cox9c9f4de2008-10-13 10:37:26 +0100573 /* Account for the p->signal references we killed */
574 while (refs--)
575 tty_kref_put(tty);
576
Linus Torvalds1da177e2005-04-16 15:20:36 -0700577 /*
Alan Cox37bdfb02008-02-08 04:18:47 -0800578 * If one of the devices matches a console pointer, we
579 * cannot just call hangup() because that will cause
580 * tty->count and state->count to go out of sync.
581 * So we just call close() the right number of times.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700582 */
583 if (cons_filp) {
Alan Coxf34d7a52008-04-30 00:54:13 -0700584 if (tty->ops->close)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700585 for (n = 0; n < closecount; n++)
Alan Coxf34d7a52008-04-30 00:54:13 -0700586 tty->ops->close(tty, cons_filp);
587 } else if (tty->ops->hangup)
588 (tty->ops->hangup)(tty);
Alan Cox37bdfb02008-02-08 04:18:47 -0800589 /*
590 * We don't want to have driver/ldisc interactions beyond
591 * the ones we did here. The driver layer expects no
592 * calls after ->hangup() from the ldisc side. However we
593 * can't yet guarantee all that.
594 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700595 set_bit(TTY_HUPPED, &tty->flags);
Alan Coxc65c9bc2009-06-11 12:50:12 +0100596 tty_ldisc_enable(tty);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700597 unlock_kernel();
598 if (f)
599 fput(f);
600}
601
Alan Coxaf9b8972006-08-27 01:24:01 -0700602/**
603 * tty_hangup - trigger a hangup event
604 * @tty: tty to hangup
605 *
606 * A carrier loss (virtual or otherwise) has occurred on this like
607 * schedule a hangup sequence to run after this event.
608 */
609
Alan Cox37bdfb02008-02-08 04:18:47 -0800610void tty_hangup(struct tty_struct *tty)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700611{
612#ifdef TTY_DEBUG_HANGUP
613 char buf[64];
Linus Torvalds1da177e2005-04-16 15:20:36 -0700614 printk(KERN_DEBUG "%s hangup...\n", tty_name(tty, buf));
615#endif
616 schedule_work(&tty->hangup_work);
617}
618
619EXPORT_SYMBOL(tty_hangup);
620
Alan Coxaf9b8972006-08-27 01:24:01 -0700621/**
622 * tty_vhangup - process vhangup
623 * @tty: tty to hangup
624 *
625 * The user has asked via system call for the terminal to be hung up.
626 * We do this synchronously so that when the syscall returns the process
Robert P. J. Day3a4fa0a2007-10-19 23:10:43 +0200627 * is complete. That guarantee is necessary for security reasons.
Alan Coxaf9b8972006-08-27 01:24:01 -0700628 */
629
Alan Cox37bdfb02008-02-08 04:18:47 -0800630void tty_vhangup(struct tty_struct *tty)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700631{
632#ifdef TTY_DEBUG_HANGUP
633 char buf[64];
634
635 printk(KERN_DEBUG "%s vhangup...\n", tty_name(tty, buf));
636#endif
David Howells65f27f32006-11-22 14:55:48 +0000637 do_tty_hangup(&tty->hangup_work);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700638}
Alan Cox37bdfb02008-02-08 04:18:47 -0800639
Linus Torvalds1da177e2005-04-16 15:20:36 -0700640EXPORT_SYMBOL(tty_vhangup);
641
Alan Coxaf9b8972006-08-27 01:24:01 -0700642/**
Alan Cox2cb59982008-10-13 10:40:30 +0100643 * tty_vhangup_self - process vhangup for own ctty
644 *
645 * Perform a vhangup on the current controlling tty
646 */
647
648void tty_vhangup_self(void)
649{
650 struct tty_struct *tty;
651
Alan Cox2cb59982008-10-13 10:40:30 +0100652 tty = get_current_tty();
653 if (tty) {
654 tty_vhangup(tty);
655 tty_kref_put(tty);
656 }
Alan Cox2cb59982008-10-13 10:40:30 +0100657}
658
659/**
Alan Coxaf9b8972006-08-27 01:24:01 -0700660 * tty_hung_up_p - was tty hung up
661 * @filp: file pointer of tty
662 *
663 * Return true if the tty has been subject to a vhangup or a carrier
664 * loss
665 */
666
Alan Cox37bdfb02008-02-08 04:18:47 -0800667int tty_hung_up_p(struct file *filp)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700668{
669 return (filp->f_op == &hung_up_tty_fops);
670}
671
672EXPORT_SYMBOL(tty_hung_up_p);
673
Eric W. Biedermanab521dc2007-02-12 00:53:00 -0800674static void session_clear_tty(struct pid *session)
Peter Zijlstra24ec8392006-12-08 02:36:04 -0800675{
676 struct task_struct *p;
Eric W. Biedermanab521dc2007-02-12 00:53:00 -0800677 do_each_pid_task(session, PIDTYPE_SID, p) {
Peter Zijlstra24ec8392006-12-08 02:36:04 -0800678 proc_clear_tty(p);
Eric W. Biedermanab521dc2007-02-12 00:53:00 -0800679 } while_each_pid_task(session, PIDTYPE_SID, p);
Peter Zijlstra24ec8392006-12-08 02:36:04 -0800680}
681
Alan Coxaf9b8972006-08-27 01:24:01 -0700682/**
683 * disassociate_ctty - disconnect controlling tty
684 * @on_exit: true if exiting so need to "hang up" the session
Linus Torvalds1da177e2005-04-16 15:20:36 -0700685 *
Alan Coxaf9b8972006-08-27 01:24:01 -0700686 * This function is typically called only by the session leader, when
687 * it wants to disassociate itself from its controlling tty.
688 *
689 * It performs the following functions:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700690 * (1) Sends a SIGHUP and SIGCONT to the foreground process group
691 * (2) Clears the tty from being controlling the session
692 * (3) Clears the controlling tty for all processes in the
693 * session group.
694 *
Alan Coxaf9b8972006-08-27 01:24:01 -0700695 * The argument on_exit is set to 1 if called when a process is
696 * exiting; it is 0 if called by the ioctl TIOCNOTTY.
697 *
Peter Zijlstra24ec8392006-12-08 02:36:04 -0800698 * Locking:
Alan Coxaf9b8972006-08-27 01:24:01 -0700699 * BKL is taken for hysterical raisins
Peter Zijlstra24ec8392006-12-08 02:36:04 -0800700 * tty_mutex is taken to protect tty
701 * ->siglock is taken to protect ->signal/->sighand
702 * tasklist_lock is taken to walk process list for sessions
703 * ->siglock is taken to protect ->signal/->sighand
Linus Torvalds1da177e2005-04-16 15:20:36 -0700704 */
Alan Coxaf9b8972006-08-27 01:24:01 -0700705
Linus Torvalds1da177e2005-04-16 15:20:36 -0700706void disassociate_ctty(int on_exit)
707{
708 struct tty_struct *tty;
Eric W. Biedermanab521dc2007-02-12 00:53:00 -0800709 struct pid *tty_pgrp = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700710
Linus Torvalds1da177e2005-04-16 15:20:36 -0700711
Peter Zijlstra24ec8392006-12-08 02:36:04 -0800712 tty = get_current_tty();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700713 if (tty) {
Eric W. Biedermanab521dc2007-02-12 00:53:00 -0800714 tty_pgrp = get_pid(tty->pgrp);
Alan Cox452a00d2008-10-13 10:39:13 +0100715 lock_kernel();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700716 if (on_exit && tty->driver->type != TTY_DRIVER_TYPE_PTY)
717 tty_vhangup(tty);
Alan Cox04f378b2008-04-30 00:53:29 -0700718 unlock_kernel();
Alan Cox452a00d2008-10-13 10:39:13 +0100719 tty_kref_put(tty);
Eric W. Biederman680a9672007-02-12 00:52:52 -0800720 } else if (on_exit) {
Eric W. Biedermanab521dc2007-02-12 00:53:00 -0800721 struct pid *old_pgrp;
Eric W. Biederman680a9672007-02-12 00:52:52 -0800722 spin_lock_irq(&current->sighand->siglock);
723 old_pgrp = current->signal->tty_old_pgrp;
Eric W. Biedermanab521dc2007-02-12 00:53:00 -0800724 current->signal->tty_old_pgrp = NULL;
Eric W. Biederman680a9672007-02-12 00:52:52 -0800725 spin_unlock_irq(&current->sighand->siglock);
Peter Zijlstra24ec8392006-12-08 02:36:04 -0800726 if (old_pgrp) {
Eric W. Biedermanab521dc2007-02-12 00:53:00 -0800727 kill_pgrp(old_pgrp, SIGHUP, on_exit);
728 kill_pgrp(old_pgrp, SIGCONT, on_exit);
729 put_pid(old_pgrp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700730 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700731 return;
732 }
Eric W. Biedermanab521dc2007-02-12 00:53:00 -0800733 if (tty_pgrp) {
734 kill_pgrp(tty_pgrp, SIGHUP, on_exit);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700735 if (!on_exit)
Eric W. Biedermanab521dc2007-02-12 00:53:00 -0800736 kill_pgrp(tty_pgrp, SIGCONT, on_exit);
737 put_pid(tty_pgrp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700738 }
739
Peter Zijlstra24ec8392006-12-08 02:36:04 -0800740 spin_lock_irq(&current->sighand->siglock);
Eric W. Biederman2a65f1d2007-05-08 00:26:53 -0700741 put_pid(current->signal->tty_old_pgrp);
Randy Dunlap23cac8d2007-02-20 13:58:05 -0800742 current->signal->tty_old_pgrp = NULL;
Peter Zijlstra24ec8392006-12-08 02:36:04 -0800743 spin_unlock_irq(&current->sighand->siglock);
744
Peter Zijlstra24ec8392006-12-08 02:36:04 -0800745 tty = get_current_tty();
746 if (tty) {
Alan Cox47f86832008-04-30 00:53:30 -0700747 unsigned long flags;
748 spin_lock_irqsave(&tty->ctrl_lock, flags);
Eric W. Biedermanab521dc2007-02-12 00:53:00 -0800749 put_pid(tty->session);
750 put_pid(tty->pgrp);
751 tty->session = NULL;
752 tty->pgrp = NULL;
Alan Cox47f86832008-04-30 00:53:30 -0700753 spin_unlock_irqrestore(&tty->ctrl_lock, flags);
Alan Cox452a00d2008-10-13 10:39:13 +0100754 tty_kref_put(tty);
Peter Zijlstra24ec8392006-12-08 02:36:04 -0800755 } else {
756#ifdef TTY_DEBUG_HANGUP
757 printk(KERN_DEBUG "error attempted to write to tty [0x%p]"
758 " = NULL", tty);
759#endif
760 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700761
762 /* Now clear signal->tty under the lock */
763 read_lock(&tasklist_lock);
Eric W. Biedermanab521dc2007-02-12 00:53:00 -0800764 session_clear_tty(task_session(current));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700765 read_unlock(&tasklist_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700766}
767
Eric W. Biederman98a27ba2007-05-08 00:26:56 -0700768/**
769 *
770 * no_tty - Ensure the current process does not have a controlling tty
771 */
772void no_tty(void)
773{
774 struct task_struct *tsk = current;
Alan Cox04f378b2008-04-30 00:53:29 -0700775 lock_kernel();
Eric W. Biederman98a27ba2007-05-08 00:26:56 -0700776 if (tsk->signal->leader)
777 disassociate_ctty(0);
Alan Cox04f378b2008-04-30 00:53:29 -0700778 unlock_kernel();
Eric W. Biederman98a27ba2007-05-08 00:26:56 -0700779 proc_clear_tty(tsk);
780}
781
Alan Coxaf9b8972006-08-27 01:24:01 -0700782
783/**
Robert P. J. Daybeb7dd82007-05-09 07:14:03 +0200784 * stop_tty - propagate flow control
Alan Coxaf9b8972006-08-27 01:24:01 -0700785 * @tty: tty to stop
786 *
787 * Perform flow control to the driver. For PTY/TTY pairs we
Robert P. J. Daybeb7dd82007-05-09 07:14:03 +0200788 * must also propagate the TIOCKPKT status. May be called
Alan Coxaf9b8972006-08-27 01:24:01 -0700789 * on an already stopped device and will not re-call the driver
790 * method.
791 *
792 * This functionality is used by both the line disciplines for
793 * halting incoming flow and by the driver. It may therefore be
794 * called from any context, may be under the tty atomic_write_lock
795 * but not always.
796 *
797 * Locking:
Alan Cox04f378b2008-04-30 00:53:29 -0700798 * Uses the tty control lock internally
Alan Coxaf9b8972006-08-27 01:24:01 -0700799 */
800
Linus Torvalds1da177e2005-04-16 15:20:36 -0700801void stop_tty(struct tty_struct *tty)
802{
Alan Cox04f378b2008-04-30 00:53:29 -0700803 unsigned long flags;
804 spin_lock_irqsave(&tty->ctrl_lock, flags);
805 if (tty->stopped) {
806 spin_unlock_irqrestore(&tty->ctrl_lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700807 return;
Alan Cox04f378b2008-04-30 00:53:29 -0700808 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700809 tty->stopped = 1;
810 if (tty->link && tty->link->packet) {
811 tty->ctrl_status &= ~TIOCPKT_START;
812 tty->ctrl_status |= TIOCPKT_STOP;
Davide Libenzi4b194492009-03-31 15:24:24 -0700813 wake_up_interruptible_poll(&tty->link->read_wait, POLLIN);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700814 }
Alan Cox04f378b2008-04-30 00:53:29 -0700815 spin_unlock_irqrestore(&tty->ctrl_lock, flags);
Alan Coxf34d7a52008-04-30 00:54:13 -0700816 if (tty->ops->stop)
817 (tty->ops->stop)(tty);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700818}
819
820EXPORT_SYMBOL(stop_tty);
821
Alan Coxaf9b8972006-08-27 01:24:01 -0700822/**
Robert P. J. Daybeb7dd82007-05-09 07:14:03 +0200823 * start_tty - propagate flow control
Alan Coxaf9b8972006-08-27 01:24:01 -0700824 * @tty: tty to start
825 *
826 * Start a tty that has been stopped if at all possible. Perform
Robert P. J. Day3a4fa0a2007-10-19 23:10:43 +0200827 * any necessary wakeups and propagate the TIOCPKT status. If this
Alan Coxaf9b8972006-08-27 01:24:01 -0700828 * is the tty was previous stopped and is being started then the
829 * driver start method is invoked and the line discipline woken.
830 *
831 * Locking:
Alan Cox04f378b2008-04-30 00:53:29 -0700832 * ctrl_lock
Alan Coxaf9b8972006-08-27 01:24:01 -0700833 */
834
Linus Torvalds1da177e2005-04-16 15:20:36 -0700835void start_tty(struct tty_struct *tty)
836{
Alan Cox04f378b2008-04-30 00:53:29 -0700837 unsigned long flags;
838 spin_lock_irqsave(&tty->ctrl_lock, flags);
839 if (!tty->stopped || tty->flow_stopped) {
840 spin_unlock_irqrestore(&tty->ctrl_lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700841 return;
Alan Cox04f378b2008-04-30 00:53:29 -0700842 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700843 tty->stopped = 0;
844 if (tty->link && tty->link->packet) {
845 tty->ctrl_status &= ~TIOCPKT_STOP;
846 tty->ctrl_status |= TIOCPKT_START;
Davide Libenzi4b194492009-03-31 15:24:24 -0700847 wake_up_interruptible_poll(&tty->link->read_wait, POLLIN);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700848 }
Alan Cox04f378b2008-04-30 00:53:29 -0700849 spin_unlock_irqrestore(&tty->ctrl_lock, flags);
Alan Coxf34d7a52008-04-30 00:54:13 -0700850 if (tty->ops->start)
851 (tty->ops->start)(tty);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700852 /* If we have a running line discipline it may need kicking */
853 tty_wakeup(tty);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700854}
855
856EXPORT_SYMBOL(start_tty);
857
Alan Coxaf9b8972006-08-27 01:24:01 -0700858/**
859 * tty_read - read method for tty device files
860 * @file: pointer to tty file
861 * @buf: user buffer
862 * @count: size of user buffer
863 * @ppos: unused
864 *
865 * Perform the read system call function on this terminal device. Checks
866 * for hung up devices before calling the line discipline method.
867 *
868 * Locking:
Alan Cox47f86832008-04-30 00:53:30 -0700869 * Locks the line discipline internally while needed. Multiple
870 * read calls may be outstanding in parallel.
Alan Coxaf9b8972006-08-27 01:24:01 -0700871 */
872
Alan Cox37bdfb02008-02-08 04:18:47 -0800873static ssize_t tty_read(struct file *file, char __user *buf, size_t count,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700874 loff_t *ppos)
875{
876 int i;
Alan Cox37bdfb02008-02-08 04:18:47 -0800877 struct tty_struct *tty;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700878 struct inode *inode;
879 struct tty_ldisc *ld;
880
881 tty = (struct tty_struct *)file->private_data;
Josef Sipeka7113a92006-12-08 02:36:55 -0800882 inode = file->f_path.dentry->d_inode;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700883 if (tty_paranoia_check(tty, inode, "tty_read"))
884 return -EIO;
885 if (!tty || (test_bit(TTY_IO_ERROR, &tty->flags)))
886 return -EIO;
887
888 /* We want to wait for the line discipline to sort out in this
889 situation */
890 ld = tty_ldisc_ref_wait(tty);
Alan Coxa352def2008-07-16 21:53:12 +0100891 if (ld->ops->read)
892 i = (ld->ops->read)(tty, file, buf, count);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700893 else
894 i = -EIO;
895 tty_ldisc_deref(ld);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700896 if (i > 0)
897 inode->i_atime = current_fs_time(inode->i_sb);
898 return i;
899}
900
Alan Cox9c1729d2007-07-15 23:39:43 -0700901void tty_write_unlock(struct tty_struct *tty)
902{
903 mutex_unlock(&tty->atomic_write_lock);
Davide Libenzi4b194492009-03-31 15:24:24 -0700904 wake_up_interruptible_poll(&tty->write_wait, POLLOUT);
Alan Cox9c1729d2007-07-15 23:39:43 -0700905}
906
907int tty_write_lock(struct tty_struct *tty, int ndelay)
908{
909 if (!mutex_trylock(&tty->atomic_write_lock)) {
910 if (ndelay)
911 return -EAGAIN;
912 if (mutex_lock_interruptible(&tty->atomic_write_lock))
913 return -ERESTARTSYS;
914 }
915 return 0;
916}
917
Linus Torvalds1da177e2005-04-16 15:20:36 -0700918/*
919 * Split writes up in sane blocksizes to avoid
920 * denial-of-service type attacks
921 */
922static inline ssize_t do_tty_write(
923 ssize_t (*write)(struct tty_struct *, struct file *, const unsigned char *, size_t),
924 struct tty_struct *tty,
925 struct file *file,
926 const char __user *buf,
927 size_t count)
928{
Alan Cox9c1729d2007-07-15 23:39:43 -0700929 ssize_t ret, written = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700930 unsigned int chunk;
Alan Cox37bdfb02008-02-08 04:18:47 -0800931
Alan Cox9c1729d2007-07-15 23:39:43 -0700932 ret = tty_write_lock(tty, file->f_flags & O_NDELAY);
933 if (ret < 0)
934 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700935
936 /*
937 * We chunk up writes into a temporary buffer. This
938 * simplifies low-level drivers immensely, since they
939 * don't have locking issues and user mode accesses.
940 *
941 * But if TTY_NO_WRITE_SPLIT is set, we should use a
942 * big chunk-size..
943 *
944 * The default chunk-size is 2kB, because the NTTY
945 * layer has problems with bigger chunks. It will
946 * claim to be able to handle more characters than
947 * it actually does.
Alan Coxaf9b8972006-08-27 01:24:01 -0700948 *
949 * FIXME: This can probably go away now except that 64K chunks
950 * are too likely to fail unless switched to vmalloc...
Linus Torvalds1da177e2005-04-16 15:20:36 -0700951 */
952 chunk = 2048;
953 if (test_bit(TTY_NO_WRITE_SPLIT, &tty->flags))
954 chunk = 65536;
955 if (count < chunk)
956 chunk = count;
957
Ingo Molnar70522e12006-03-23 03:00:31 -0800958 /* write_buf/write_cnt is protected by the atomic_write_lock mutex */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700959 if (tty->write_cnt < chunk) {
Jason Wessel402fda92008-10-13 10:45:36 +0100960 unsigned char *buf_chunk;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700961
962 if (chunk < 1024)
963 chunk = 1024;
964
Jason Wessel402fda92008-10-13 10:45:36 +0100965 buf_chunk = kmalloc(chunk, GFP_KERNEL);
966 if (!buf_chunk) {
Alan Cox9c1729d2007-07-15 23:39:43 -0700967 ret = -ENOMEM;
968 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700969 }
970 kfree(tty->write_buf);
971 tty->write_cnt = chunk;
Jason Wessel402fda92008-10-13 10:45:36 +0100972 tty->write_buf = buf_chunk;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700973 }
974
975 /* Do the write .. */
976 for (;;) {
977 size_t size = count;
978 if (size > chunk)
979 size = chunk;
980 ret = -EFAULT;
981 if (copy_from_user(tty->write_buf, buf, size))
982 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700983 ret = write(tty, file, tty->write_buf, size);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700984 if (ret <= 0)
985 break;
986 written += ret;
987 buf += ret;
988 count -= ret;
989 if (!count)
990 break;
991 ret = -ERESTARTSYS;
992 if (signal_pending(current))
993 break;
994 cond_resched();
995 }
996 if (written) {
Josef Sipeka7113a92006-12-08 02:36:55 -0800997 struct inode *inode = file->f_path.dentry->d_inode;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700998 inode->i_mtime = current_fs_time(inode->i_sb);
999 ret = written;
1000 }
Alan Cox9c1729d2007-07-15 23:39:43 -07001001out:
1002 tty_write_unlock(tty);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001003 return ret;
1004}
1005
Alan Cox95f9bfc2008-10-13 10:39:23 +01001006/**
1007 * tty_write_message - write a message to a certain tty, not just the console.
1008 * @tty: the destination tty_struct
1009 * @msg: the message to write
1010 *
1011 * This is used for messages that need to be redirected to a specific tty.
1012 * We don't put it into the syslog queue right now maybe in the future if
1013 * really needed.
1014 *
1015 * We must still hold the BKL and test the CLOSING flag for the moment.
1016 */
1017
1018void tty_write_message(struct tty_struct *tty, char *msg)
1019{
1020 lock_kernel();
1021 if (tty) {
1022 mutex_lock(&tty->atomic_write_lock);
1023 if (tty->ops->write && !test_bit(TTY_CLOSING, &tty->flags))
1024 tty->ops->write(tty, msg, strlen(msg));
1025 tty_write_unlock(tty);
1026 }
1027 unlock_kernel();
1028 return;
1029}
1030
Linus Torvalds1da177e2005-04-16 15:20:36 -07001031
Alan Coxaf9b8972006-08-27 01:24:01 -07001032/**
1033 * tty_write - write method for tty device file
1034 * @file: tty file pointer
1035 * @buf: user data to write
1036 * @count: bytes to write
1037 * @ppos: unused
1038 *
1039 * Write data to a tty device via the line discipline.
1040 *
1041 * Locking:
1042 * Locks the line discipline as required
1043 * Writes to the tty driver are serialized by the atomic_write_lock
1044 * and are then processed in chunks to the device. The line discipline
Joe Petersona88a69c2009-01-02 13:40:53 +00001045 * write method will not be invoked in parallel for each device.
Alan Coxaf9b8972006-08-27 01:24:01 -07001046 */
1047
Alan Cox37bdfb02008-02-08 04:18:47 -08001048static ssize_t tty_write(struct file *file, const char __user *buf,
1049 size_t count, loff_t *ppos)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001050{
Alan Cox37bdfb02008-02-08 04:18:47 -08001051 struct tty_struct *tty;
Josef Sipeka7113a92006-12-08 02:36:55 -08001052 struct inode *inode = file->f_path.dentry->d_inode;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001053 ssize_t ret;
1054 struct tty_ldisc *ld;
Alan Cox37bdfb02008-02-08 04:18:47 -08001055
Linus Torvalds1da177e2005-04-16 15:20:36 -07001056 tty = (struct tty_struct *)file->private_data;
1057 if (tty_paranoia_check(tty, inode, "tty_write"))
1058 return -EIO;
Alan Coxf34d7a52008-04-30 00:54:13 -07001059 if (!tty || !tty->ops->write ||
Alan Cox37bdfb02008-02-08 04:18:47 -08001060 (test_bit(TTY_IO_ERROR, &tty->flags)))
1061 return -EIO;
Alan Coxf34d7a52008-04-30 00:54:13 -07001062 /* Short term debug to catch buggy drivers */
1063 if (tty->ops->write_room == NULL)
1064 printk(KERN_ERR "tty driver %s lacks a write_room method.\n",
1065 tty->driver->name);
Alan Cox37bdfb02008-02-08 04:18:47 -08001066 ld = tty_ldisc_ref_wait(tty);
Alan Coxa352def2008-07-16 21:53:12 +01001067 if (!ld->ops->write)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001068 ret = -EIO;
1069 else
Alan Coxa352def2008-07-16 21:53:12 +01001070 ret = do_tty_write(ld->ops->write, tty, file, buf, count);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001071 tty_ldisc_deref(ld);
1072 return ret;
1073}
1074
Alan Cox37bdfb02008-02-08 04:18:47 -08001075ssize_t redirected_tty_write(struct file *file, const char __user *buf,
1076 size_t count, loff_t *ppos)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001077{
1078 struct file *p = NULL;
1079
1080 spin_lock(&redirect_lock);
1081 if (redirect) {
1082 get_file(redirect);
1083 p = redirect;
1084 }
1085 spin_unlock(&redirect_lock);
1086
1087 if (p) {
1088 ssize_t res;
1089 res = vfs_write(p, buf, count, &p->f_pos);
1090 fput(p);
1091 return res;
1092 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001093 return tty_write(file, buf, count, ppos);
1094}
1095
1096static char ptychar[] = "pqrstuvwxyzabcde";
1097
Alan Coxaf9b8972006-08-27 01:24:01 -07001098/**
1099 * pty_line_name - generate name for a pty
1100 * @driver: the tty driver in use
1101 * @index: the minor number
1102 * @p: output buffer of at least 6 bytes
1103 *
1104 * Generate a name from a driver reference and write it to the output
1105 * buffer.
1106 *
1107 * Locking: None
1108 */
1109static void pty_line_name(struct tty_driver *driver, int index, char *p)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001110{
1111 int i = index + driver->name_base;
1112 /* ->name is initialized to "ttyp", but "tty" is expected */
1113 sprintf(p, "%s%c%x",
Alan Cox37bdfb02008-02-08 04:18:47 -08001114 driver->subtype == PTY_TYPE_SLAVE ? "tty" : driver->name,
1115 ptychar[i >> 4 & 0xf], i & 0xf);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001116}
1117
Alan Coxaf9b8972006-08-27 01:24:01 -07001118/**
Alan Cox8b0a88d2008-10-13 10:42:19 +01001119 * tty_line_name - generate name for a tty
Alan Coxaf9b8972006-08-27 01:24:01 -07001120 * @driver: the tty driver in use
1121 * @index: the minor number
1122 * @p: output buffer of at least 7 bytes
1123 *
1124 * Generate a name from a driver reference and write it to the output
1125 * buffer.
1126 *
1127 * Locking: None
1128 */
1129static void tty_line_name(struct tty_driver *driver, int index, char *p)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001130{
1131 sprintf(p, "%s%d", driver->name, index + driver->name_base);
1132}
1133
Alan Cox99f1fe12008-10-13 10:42:00 +01001134/**
1135 * tty_driver_lookup_tty() - find an existing tty, if any
1136 * @driver: the driver for the tty
1137 * @idx: the minor number
Sukadev Bhattiprolu23499702008-10-13 10:41:51 +01001138 *
Alan Cox99f1fe12008-10-13 10:42:00 +01001139 * Return the tty, if found or ERR_PTR() otherwise.
Sukadev Bhattiprolu23499702008-10-13 10:41:51 +01001140 *
Alan Cox99f1fe12008-10-13 10:42:00 +01001141 * Locking: tty_mutex must be held. If tty is found, the mutex must
1142 * be held until the 'fast-open' is also done. Will change once we
1143 * have refcounting in the driver and per driver locking
Sukadev Bhattiprolu23499702008-10-13 10:41:51 +01001144 */
Jason Wessela47d5452009-01-02 13:43:04 +00001145static struct tty_struct *tty_driver_lookup_tty(struct tty_driver *driver,
Sukadev Bhattiprolu15f1a632008-10-13 10:42:59 +01001146 struct inode *inode, int idx)
Sukadev Bhattiprolu23499702008-10-13 10:41:51 +01001147{
1148 struct tty_struct *tty;
1149
Alan Cox99f1fe12008-10-13 10:42:00 +01001150 if (driver->ops->lookup)
Sukadev Bhattiprolu15f1a632008-10-13 10:42:59 +01001151 return driver->ops->lookup(driver, inode, idx);
Sukadev Bhattiprolu23499702008-10-13 10:41:51 +01001152
Alan Cox8b0a88d2008-10-13 10:42:19 +01001153 tty = driver->ttys[idx];
Sukadev Bhattiprolu23499702008-10-13 10:41:51 +01001154 return tty;
1155}
1156
Alan Cox99f1fe12008-10-13 10:42:00 +01001157/**
Alan Coxbf970ee2008-10-13 10:42:39 +01001158 * tty_init_termios - helper for termios setup
1159 * @tty: the tty to set up
1160 *
1161 * Initialise the termios structures for this tty. Thus runs under
1162 * the tty_mutex currently so we can be relaxed about ordering.
1163 */
1164
1165int tty_init_termios(struct tty_struct *tty)
1166{
Alan Coxfe6e29f2008-10-13 10:44:08 +01001167 struct ktermios *tp;
Alan Coxbf970ee2008-10-13 10:42:39 +01001168 int idx = tty->index;
1169
1170 tp = tty->driver->termios[idx];
Alan Coxbf970ee2008-10-13 10:42:39 +01001171 if (tp == NULL) {
Alan Coxfe6e29f2008-10-13 10:44:08 +01001172 tp = kzalloc(sizeof(struct ktermios[2]), GFP_KERNEL);
1173 if (tp == NULL)
Alan Coxbf970ee2008-10-13 10:42:39 +01001174 return -ENOMEM;
Alan Coxbf970ee2008-10-13 10:42:39 +01001175 memcpy(tp, &tty->driver->init_termios,
1176 sizeof(struct ktermios));
1177 tty->driver->termios[idx] = tp;
Alan Coxbf970ee2008-10-13 10:42:39 +01001178 }
1179 tty->termios = tp;
Alan Coxfe6e29f2008-10-13 10:44:08 +01001180 tty->termios_locked = tp + 1;
Alan Coxbf970ee2008-10-13 10:42:39 +01001181
1182 /* Compatibility until drivers always set this */
1183 tty->termios->c_ispeed = tty_termios_input_baud_rate(tty->termios);
1184 tty->termios->c_ospeed = tty_termios_baud_rate(tty->termios);
1185 return 0;
1186}
1187
1188/**
Alan Cox8b0a88d2008-10-13 10:42:19 +01001189 * tty_driver_install_tty() - install a tty entry in the driver
1190 * @driver: the driver for the tty
1191 * @tty: the tty
1192 *
1193 * Install a tty object into the driver tables. The tty->index field
Alan Coxbf970ee2008-10-13 10:42:39 +01001194 * will be set by the time this is called. This method is responsible
1195 * for ensuring any need additional structures are allocated and
1196 * configured.
Alan Cox8b0a88d2008-10-13 10:42:19 +01001197 *
1198 * Locking: tty_mutex for now
1199 */
1200static int tty_driver_install_tty(struct tty_driver *driver,
1201 struct tty_struct *tty)
1202{
Alan Coxbf970ee2008-10-13 10:42:39 +01001203 int idx = tty->index;
1204
Alan Cox8b0a88d2008-10-13 10:42:19 +01001205 if (driver->ops->install)
1206 return driver->ops->install(driver, tty);
Alan Coxbf970ee2008-10-13 10:42:39 +01001207
1208 if (tty_init_termios(tty) == 0) {
1209 tty_driver_kref_get(driver);
1210 tty->count++;
1211 driver->ttys[idx] = tty;
1212 return 0;
1213 }
1214 return -ENOMEM;
Alan Cox8b0a88d2008-10-13 10:42:19 +01001215}
1216
1217/**
1218 * tty_driver_remove_tty() - remove a tty from the driver tables
1219 * @driver: the driver for the tty
1220 * @idx: the minor number
1221 *
1222 * Remvoe a tty object from the driver tables. The tty->index field
1223 * will be set by the time this is called.
1224 *
1225 * Locking: tty_mutex for now
1226 */
1227static void tty_driver_remove_tty(struct tty_driver *driver,
1228 struct tty_struct *tty)
1229{
1230 if (driver->ops->remove)
1231 driver->ops->remove(driver, tty);
1232 else
1233 driver->ttys[tty->index] = NULL;
1234}
1235
1236/*
1237 * tty_reopen() - fast re-open of an open tty
1238 * @tty - the tty to open
Sukadev Bhattiprolu23499702008-10-13 10:41:51 +01001239 *
Alan Cox99f1fe12008-10-13 10:42:00 +01001240 * Return 0 on success, -errno on error.
Sukadev Bhattiprolu23499702008-10-13 10:41:51 +01001241 *
Alan Cox99f1fe12008-10-13 10:42:00 +01001242 * Locking: tty_mutex must be held from the time the tty was found
1243 * till this open completes.
Sukadev Bhattiprolu23499702008-10-13 10:41:51 +01001244 */
Alan Cox99f1fe12008-10-13 10:42:00 +01001245static int tty_reopen(struct tty_struct *tty)
Sukadev Bhattiprolu23499702008-10-13 10:41:51 +01001246{
1247 struct tty_driver *driver = tty->driver;
1248
1249 if (test_bit(TTY_CLOSING, &tty->flags))
1250 return -EIO;
1251
1252 if (driver->type == TTY_DRIVER_TYPE_PTY &&
1253 driver->subtype == PTY_TYPE_MASTER) {
1254 /*
1255 * special case for PTY masters: only one open permitted,
1256 * and the slave side open count is incremented as well.
1257 */
1258 if (tty->count)
1259 return -EIO;
1260
1261 tty->link->count++;
1262 }
1263 tty->count++;
1264 tty->driver = driver; /* N.B. why do this every time?? */
1265
Alan Cox1aa4bed2009-06-16 17:01:33 +01001266 mutex_lock(&tty->ldisc_mutex);
Alan Cox99f1fe12008-10-13 10:42:00 +01001267 WARN_ON(!test_bit(TTY_LDISC, &tty->flags));
Alan Cox1aa4bed2009-06-16 17:01:33 +01001268 mutex_unlock(&tty->ldisc_mutex);
Sukadev Bhattiprolu23499702008-10-13 10:41:51 +01001269
1270 return 0;
1271}
1272
Alan Coxaf9b8972006-08-27 01:24:01 -07001273/**
Alan Coxd81ed102008-10-13 10:41:42 +01001274 * tty_init_dev - initialise a tty device
Alan Coxaf9b8972006-08-27 01:24:01 -07001275 * @driver: tty driver we are opening a device on
1276 * @idx: device index
Alan Cox15582d32008-10-13 10:41:03 +01001277 * @ret_tty: returned tty structure
1278 * @first_ok: ok to open a new device (used by ptmx)
Alan Coxaf9b8972006-08-27 01:24:01 -07001279 *
1280 * Prepare a tty device. This may not be a "new" clean device but
1281 * could also be an active device. The pty drivers require special
1282 * handling because of this.
1283 *
1284 * Locking:
1285 * The function is called under the tty_mutex, which
1286 * protects us from the tty struct or driver itself going away.
1287 *
1288 * On exit the tty device has the line discipline attached and
1289 * a reference count of 1. If a pair was created for pty/tty use
1290 * and the other was a pty master then it too has a reference count of 1.
1291 *
Linus Torvalds1da177e2005-04-16 15:20:36 -07001292 * WSH 06/09/97: Rewritten to remove races and properly clean up after a
Ingo Molnar70522e12006-03-23 03:00:31 -08001293 * failed open. The new code protects the open with a mutex, so it's
1294 * really quite straightforward. The mutex locking can probably be
Linus Torvalds1da177e2005-04-16 15:20:36 -07001295 * relaxed for the (most common) case of reopening a tty.
1296 */
Alan Coxaf9b8972006-08-27 01:24:01 -07001297
Alan Cox73ec06f2008-10-13 10:42:29 +01001298struct tty_struct *tty_init_dev(struct tty_driver *driver, int idx,
1299 int first_ok)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001300{
Alan Coxbf970ee2008-10-13 10:42:39 +01001301 struct tty_struct *tty;
Alan Cox73ec06f2008-10-13 10:42:29 +01001302 int retval;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001303
Sukadev Bhattiprolu23499702008-10-13 10:41:51 +01001304 /* Check if pty master is being opened multiple times */
Alan Cox15582d32008-10-13 10:41:03 +01001305 if (driver->subtype == PTY_TYPE_MASTER &&
Alan Cox73ec06f2008-10-13 10:42:29 +01001306 (driver->flags & TTY_DRIVER_DEVPTS_MEM) && !first_ok)
1307 return ERR_PTR(-EIO);
1308
Linus Torvalds1da177e2005-04-16 15:20:36 -07001309 /*
1310 * First time open is complex, especially for PTY devices.
1311 * This code guarantees that either everything succeeds and the
1312 * TTY is ready for operation, or else the table slots are vacated
Alan Cox37bdfb02008-02-08 04:18:47 -08001313 * and the allocated memory released. (Except that the termios
Linus Torvalds1da177e2005-04-16 15:20:36 -07001314 * and locked termios may be retained.)
1315 */
1316
Alan Cox73ec06f2008-10-13 10:42:29 +01001317 if (!try_module_get(driver->owner))
1318 return ERR_PTR(-ENODEV);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001319
Linus Torvalds1da177e2005-04-16 15:20:36 -07001320 tty = alloc_tty_struct();
Alan Cox37bdfb02008-02-08 04:18:47 -08001321 if (!tty)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001322 goto fail_no_mem;
Alan Coxbf970ee2008-10-13 10:42:39 +01001323 initialize_tty_struct(tty, driver, idx);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001324
Alan Cox73ec06f2008-10-13 10:42:29 +01001325 retval = tty_driver_install_tty(driver, tty);
Alan Coxbf970ee2008-10-13 10:42:39 +01001326 if (retval < 0) {
1327 free_tty_struct(tty);
1328 module_put(driver->owner);
1329 return ERR_PTR(retval);
1330 }
Alan Cox8b0a88d2008-10-13 10:42:19 +01001331
Alan Cox37bdfb02008-02-08 04:18:47 -08001332 /*
Linus Torvalds1da177e2005-04-16 15:20:36 -07001333 * Structures all installed ... call the ldisc open routines.
Christoph Hellwigd5698c22007-02-10 01:46:46 -08001334 * If we fail here just call release_tty to clean up. No need
1335 * to decrement the use counts, as release_tty doesn't care.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001336 */
1337
Alan Coxbf970ee2008-10-13 10:42:39 +01001338 retval = tty_ldisc_setup(tty, tty->link);
Alan Cox01e1abb2008-07-22 11:16:55 +01001339 if (retval)
1340 goto release_mem_out;
Alan Cox73ec06f2008-10-13 10:42:29 +01001341 return tty;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001342
Linus Torvalds1da177e2005-04-16 15:20:36 -07001343fail_no_mem:
1344 module_put(driver->owner);
Alan Cox73ec06f2008-10-13 10:42:29 +01001345 return ERR_PTR(-ENOMEM);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001346
Christoph Hellwigd5698c22007-02-10 01:46:46 -08001347 /* call the tty release_tty routine to clean out this slot */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001348release_mem_out:
Akinobu Mita40509142006-09-29 02:01:27 -07001349 if (printk_ratelimit())
Alan Coxd81ed102008-10-13 10:41:42 +01001350 printk(KERN_INFO "tty_init_dev: ldisc open failed, "
Akinobu Mita40509142006-09-29 02:01:27 -07001351 "clearing slot %d\n", idx);
Christoph Hellwigd5698c22007-02-10 01:46:46 -08001352 release_tty(tty, idx);
Alan Cox73ec06f2008-10-13 10:42:29 +01001353 return ERR_PTR(retval);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001354}
1355
Alan Coxfeebed62008-10-13 10:41:30 +01001356void tty_free_termios(struct tty_struct *tty)
1357{
1358 struct ktermios *tp;
1359 int idx = tty->index;
1360 /* Kill this flag and push into drivers for locking etc */
1361 if (tty->driver->flags & TTY_DRIVER_RESET_TERMIOS) {
1362 /* FIXME: Locking on ->termios array */
1363 tp = tty->termios;
1364 tty->driver->termios[idx] = NULL;
1365 kfree(tp);
Alan Coxfeebed62008-10-13 10:41:30 +01001366 }
1367}
1368EXPORT_SYMBOL(tty_free_termios);
1369
1370void tty_shutdown(struct tty_struct *tty)
1371{
Alan Cox8b0a88d2008-10-13 10:42:19 +01001372 tty_driver_remove_tty(tty->driver, tty);
Alan Coxfeebed62008-10-13 10:41:30 +01001373 tty_free_termios(tty);
1374}
1375EXPORT_SYMBOL(tty_shutdown);
1376
Alan Coxaf9b8972006-08-27 01:24:01 -07001377/**
Christoph Hellwigd5698c22007-02-10 01:46:46 -08001378 * release_one_tty - release tty structure memory
Alan Cox9c9f4de2008-10-13 10:37:26 +01001379 * @kref: kref of tty we are obliterating
Alan Coxaf9b8972006-08-27 01:24:01 -07001380 *
1381 * Releases memory associated with a tty structure, and clears out the
1382 * driver table slots. This function is called when a device is no longer
1383 * in use. It also gets called when setup of a device fails.
1384 *
1385 * Locking:
1386 * tty_mutex - sometimes only
1387 * takes the file list lock internally when working on the list
1388 * of ttys that the driver keeps.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001389 */
Alan Cox9c9f4de2008-10-13 10:37:26 +01001390static void release_one_tty(struct kref *kref)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001391{
Alan Cox9c9f4de2008-10-13 10:37:26 +01001392 struct tty_struct *tty = container_of(kref, struct tty_struct, kref);
Alan Cox6f967f72008-10-13 10:37:36 +01001393 struct tty_driver *driver = tty->driver;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001394
Alan Coxfeebed62008-10-13 10:41:30 +01001395 if (tty->ops->shutdown)
1396 tty->ops->shutdown(tty);
1397 else
1398 tty_shutdown(tty);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001399 tty->magic = 0;
Alan Cox7d7b93c2008-10-13 10:42:09 +01001400 tty_driver_kref_put(driver);
Alan Cox6f967f72008-10-13 10:37:36 +01001401 module_put(driver->owner);
Christoph Hellwigd5698c22007-02-10 01:46:46 -08001402
Linus Torvalds1da177e2005-04-16 15:20:36 -07001403 file_list_lock();
1404 list_del_init(&tty->tty_files);
1405 file_list_unlock();
Christoph Hellwigd5698c22007-02-10 01:46:46 -08001406
Linus Torvalds1da177e2005-04-16 15:20:36 -07001407 free_tty_struct(tty);
1408}
1409
Christoph Hellwigd5698c22007-02-10 01:46:46 -08001410/**
Alan Cox9c9f4de2008-10-13 10:37:26 +01001411 * tty_kref_put - release a tty kref
1412 * @tty: tty device
1413 *
1414 * Release a reference to a tty device and if need be let the kref
1415 * layer destruct the object for us
1416 */
1417
1418void tty_kref_put(struct tty_struct *tty)
1419{
1420 if (tty)
1421 kref_put(&tty->kref, release_one_tty);
1422}
1423EXPORT_SYMBOL(tty_kref_put);
1424
1425/**
Christoph Hellwigd5698c22007-02-10 01:46:46 -08001426 * release_tty - release tty structure memory
1427 *
1428 * Release both @tty and a possible linked partner (think pty pair),
1429 * and decrement the refcount of the backing module.
1430 *
1431 * Locking:
1432 * tty_mutex - sometimes only
1433 * takes the file list lock internally when working on the list
1434 * of ttys that the driver keeps.
1435 * FIXME: should we require tty_mutex is held here ??
Alan Cox9c9f4de2008-10-13 10:37:26 +01001436 *
Christoph Hellwigd5698c22007-02-10 01:46:46 -08001437 */
1438static void release_tty(struct tty_struct *tty, int idx)
1439{
Alan Cox9c9f4de2008-10-13 10:37:26 +01001440 /* This should always be true but check for the moment */
1441 WARN_ON(tty->index != idx);
1442
Christoph Hellwigd5698c22007-02-10 01:46:46 -08001443 if (tty->link)
Alan Cox9c9f4de2008-10-13 10:37:26 +01001444 tty_kref_put(tty->link);
1445 tty_kref_put(tty);
Christoph Hellwigd5698c22007-02-10 01:46:46 -08001446}
1447
Linus Torvalds1da177e2005-04-16 15:20:36 -07001448/*
1449 * Even releasing the tty structures is a tricky business.. We have
1450 * to be very careful that the structures are all released at the
1451 * same time, as interrupts might otherwise get the wrong pointers.
1452 *
1453 * WSH 09/09/97: rewritten to avoid some nasty race conditions that could
1454 * lead to double frees or releasing memory still in use.
1455 */
Alan Coxd81ed102008-10-13 10:41:42 +01001456void tty_release_dev(struct file *filp)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001457{
1458 struct tty_struct *tty, *o_tty;
1459 int pty_master, tty_closing, o_tty_closing, do_sleep;
Paul Fulghum14a62832006-04-10 22:54:19 -07001460 int devpts;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001461 int idx;
1462 char buf[64];
Sukadev Bhattiprolu15f1a632008-10-13 10:42:59 +01001463 struct inode *inode;
Alan Cox37bdfb02008-02-08 04:18:47 -08001464
Sukadev Bhattiprolu15f1a632008-10-13 10:42:59 +01001465 inode = filp->f_path.dentry->d_inode;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001466 tty = (struct tty_struct *)filp->private_data;
Sukadev Bhattiprolu15f1a632008-10-13 10:42:59 +01001467 if (tty_paranoia_check(tty, inode, "tty_release_dev"))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001468 return;
1469
Alan Coxd81ed102008-10-13 10:41:42 +01001470 check_tty_count(tty, "tty_release_dev");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001471
1472 tty_fasync(-1, filp, 0);
1473
1474 idx = tty->index;
1475 pty_master = (tty->driver->type == TTY_DRIVER_TYPE_PTY &&
1476 tty->driver->subtype == PTY_TYPE_MASTER);
1477 devpts = (tty->driver->flags & TTY_DRIVER_DEVPTS_MEM) != 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001478 o_tty = tty->link;
1479
1480#ifdef TTY_PARANOIA_CHECK
1481 if (idx < 0 || idx >= tty->driver->num) {
Alan Coxd81ed102008-10-13 10:41:42 +01001482 printk(KERN_DEBUG "tty_release_dev: bad idx when trying to "
Linus Torvalds1da177e2005-04-16 15:20:36 -07001483 "free (%s)\n", tty->name);
1484 return;
1485 }
Alan Cox8b0a88d2008-10-13 10:42:19 +01001486 if (!devpts) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001487 if (tty != tty->driver->ttys[idx]) {
Alan Coxd81ed102008-10-13 10:41:42 +01001488 printk(KERN_DEBUG "tty_release_dev: driver.table[%d] not tty "
Linus Torvalds1da177e2005-04-16 15:20:36 -07001489 "for (%s)\n", idx, tty->name);
1490 return;
1491 }
1492 if (tty->termios != tty->driver->termios[idx]) {
Alan Coxd81ed102008-10-13 10:41:42 +01001493 printk(KERN_DEBUG "tty_release_dev: driver.termios[%d] not termios "
Linus Torvalds1da177e2005-04-16 15:20:36 -07001494 "for (%s)\n",
1495 idx, tty->name);
1496 return;
1497 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001498 }
1499#endif
1500
1501#ifdef TTY_DEBUG_HANGUP
Alan Coxd81ed102008-10-13 10:41:42 +01001502 printk(KERN_DEBUG "tty_release_dev of %s (tty count=%d)...",
Linus Torvalds1da177e2005-04-16 15:20:36 -07001503 tty_name(tty, buf), tty->count);
1504#endif
1505
1506#ifdef TTY_PARANOIA_CHECK
1507 if (tty->driver->other &&
1508 !(tty->driver->flags & TTY_DRIVER_DEVPTS_MEM)) {
1509 if (o_tty != tty->driver->other->ttys[idx]) {
Alan Coxd81ed102008-10-13 10:41:42 +01001510 printk(KERN_DEBUG "tty_release_dev: other->table[%d] "
Linus Torvalds1da177e2005-04-16 15:20:36 -07001511 "not o_tty for (%s)\n",
1512 idx, tty->name);
1513 return;
1514 }
1515 if (o_tty->termios != tty->driver->other->termios[idx]) {
Alan Coxd81ed102008-10-13 10:41:42 +01001516 printk(KERN_DEBUG "tty_release_dev: other->termios[%d] "
Linus Torvalds1da177e2005-04-16 15:20:36 -07001517 "not o_termios for (%s)\n",
1518 idx, tty->name);
1519 return;
1520 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001521 if (o_tty->link != tty) {
Alan Coxd81ed102008-10-13 10:41:42 +01001522 printk(KERN_DEBUG "tty_release_dev: bad pty pointers\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001523 return;
1524 }
1525 }
1526#endif
Alan Coxf34d7a52008-04-30 00:54:13 -07001527 if (tty->ops->close)
1528 tty->ops->close(tty, filp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001529
1530 /*
1531 * Sanity check: if tty->count is going to zero, there shouldn't be
1532 * any waiters on tty->read_wait or tty->write_wait. We test the
1533 * wait queues and kick everyone out _before_ actually starting to
1534 * close. This ensures that we won't block while releasing the tty
1535 * structure.
1536 *
1537 * The test for the o_tty closing is necessary, since the master and
1538 * slave sides may close in any order. If the slave side closes out
1539 * first, its count will be one, since the master side holds an open.
1540 * Thus this test wouldn't be triggered at the time the slave closes,
1541 * so we do it now.
1542 *
1543 * Note that it's possible for the tty to be opened again while we're
1544 * flushing out waiters. By recalculating the closing flags before
1545 * each iteration we avoid any problems.
1546 */
1547 while (1) {
1548 /* Guard against races with tty->count changes elsewhere and
1549 opens on /dev/tty */
Alan Cox37bdfb02008-02-08 04:18:47 -08001550
Ingo Molnar70522e12006-03-23 03:00:31 -08001551 mutex_lock(&tty_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001552 tty_closing = tty->count <= 1;
1553 o_tty_closing = o_tty &&
1554 (o_tty->count <= (pty_master ? 1 : 0));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001555 do_sleep = 0;
1556
1557 if (tty_closing) {
1558 if (waitqueue_active(&tty->read_wait)) {
Davide Libenzi4b194492009-03-31 15:24:24 -07001559 wake_up_poll(&tty->read_wait, POLLIN);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001560 do_sleep++;
1561 }
1562 if (waitqueue_active(&tty->write_wait)) {
Davide Libenzi4b194492009-03-31 15:24:24 -07001563 wake_up_poll(&tty->write_wait, POLLOUT);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001564 do_sleep++;
1565 }
1566 }
1567 if (o_tty_closing) {
1568 if (waitqueue_active(&o_tty->read_wait)) {
Davide Libenzi4b194492009-03-31 15:24:24 -07001569 wake_up_poll(&o_tty->read_wait, POLLIN);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001570 do_sleep++;
1571 }
1572 if (waitqueue_active(&o_tty->write_wait)) {
Davide Libenzi4b194492009-03-31 15:24:24 -07001573 wake_up_poll(&o_tty->write_wait, POLLOUT);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001574 do_sleep++;
1575 }
1576 }
1577 if (!do_sleep)
1578 break;
1579
Alan Coxd81ed102008-10-13 10:41:42 +01001580 printk(KERN_WARNING "tty_release_dev: %s: read/write wait queue "
Linus Torvalds1da177e2005-04-16 15:20:36 -07001581 "active!\n", tty_name(tty, buf));
Ingo Molnar70522e12006-03-23 03:00:31 -08001582 mutex_unlock(&tty_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001583 schedule();
Alan Cox37bdfb02008-02-08 04:18:47 -08001584 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001585
1586 /*
Alan Cox37bdfb02008-02-08 04:18:47 -08001587 * The closing flags are now consistent with the open counts on
1588 * both sides, and we've completed the last operation that could
Linus Torvalds1da177e2005-04-16 15:20:36 -07001589 * block, so it's safe to proceed with closing.
1590 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001591 if (pty_master) {
1592 if (--o_tty->count < 0) {
Alan Coxd81ed102008-10-13 10:41:42 +01001593 printk(KERN_WARNING "tty_release_dev: bad pty slave count "
Linus Torvalds1da177e2005-04-16 15:20:36 -07001594 "(%d) for %s\n",
1595 o_tty->count, tty_name(o_tty, buf));
1596 o_tty->count = 0;
1597 }
1598 }
1599 if (--tty->count < 0) {
Alan Coxd81ed102008-10-13 10:41:42 +01001600 printk(KERN_WARNING "tty_release_dev: bad tty->count (%d) for %s\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -07001601 tty->count, tty_name(tty, buf));
1602 tty->count = 0;
1603 }
Alan Cox37bdfb02008-02-08 04:18:47 -08001604
Linus Torvalds1da177e2005-04-16 15:20:36 -07001605 /*
1606 * We've decremented tty->count, so we need to remove this file
1607 * descriptor off the tty->tty_files list; this serves two
1608 * purposes:
1609 * - check_tty_count sees the correct number of file descriptors
1610 * associated with this tty.
1611 * - do_tty_hangup no longer sees this file descriptor as
1612 * something that needs to be handled for hangups.
1613 */
1614 file_kill(filp);
1615 filp->private_data = NULL;
1616
1617 /*
1618 * Perform some housekeeping before deciding whether to return.
1619 *
1620 * Set the TTY_CLOSING flag if this was the last open. In the
1621 * case of a pty we may have to wait around for the other side
1622 * to close, and TTY_CLOSING makes sure we can't be reopened.
1623 */
Alan Cox37bdfb02008-02-08 04:18:47 -08001624 if (tty_closing)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001625 set_bit(TTY_CLOSING, &tty->flags);
Alan Cox37bdfb02008-02-08 04:18:47 -08001626 if (o_tty_closing)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001627 set_bit(TTY_CLOSING, &o_tty->flags);
1628
1629 /*
1630 * If _either_ side is closing, make sure there aren't any
1631 * processes that still think tty or o_tty is their controlling
1632 * tty.
1633 */
1634 if (tty_closing || o_tty_closing) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001635 read_lock(&tasklist_lock);
Peter Zijlstra24ec8392006-12-08 02:36:04 -08001636 session_clear_tty(tty->session);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001637 if (o_tty)
Peter Zijlstra24ec8392006-12-08 02:36:04 -08001638 session_clear_tty(o_tty->session);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001639 read_unlock(&tasklist_lock);
1640 }
1641
Ingo Molnar70522e12006-03-23 03:00:31 -08001642 mutex_unlock(&tty_mutex);
Paul Fulghumda965822006-02-14 13:53:00 -08001643
Linus Torvalds1da177e2005-04-16 15:20:36 -07001644 /* check whether both sides are closing ... */
1645 if (!tty_closing || (o_tty && !o_tty_closing))
1646 return;
Alan Cox37bdfb02008-02-08 04:18:47 -08001647
Linus Torvalds1da177e2005-04-16 15:20:36 -07001648#ifdef TTY_DEBUG_HANGUP
1649 printk(KERN_DEBUG "freeing tty structure...");
1650#endif
1651 /*
Alan Cox01e1abb2008-07-22 11:16:55 +01001652 * Ask the line discipline code to release its structures
Linus Torvalds1da177e2005-04-16 15:20:36 -07001653 */
Alan Cox01e1abb2008-07-22 11:16:55 +01001654 tty_ldisc_release(tty, o_tty);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001655 /*
Christoph Hellwigd5698c22007-02-10 01:46:46 -08001656 * The release_tty function takes care of the details of clearing
Linus Torvalds1da177e2005-04-16 15:20:36 -07001657 * the slots and preserving the termios structure.
1658 */
Christoph Hellwigd5698c22007-02-10 01:46:46 -08001659 release_tty(tty, idx);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001660
Linus Torvalds1da177e2005-04-16 15:20:36 -07001661 /* Make this pty number available for reallocation */
Sukadev Bhattiprolu718a9162008-04-30 00:54:21 -07001662 if (devpts)
Sukadev Bhattiprolu15f1a632008-10-13 10:42:59 +01001663 devpts_kill_index(inode, idx);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001664}
1665
Alan Coxaf9b8972006-08-27 01:24:01 -07001666/**
Alan Cox15582d32008-10-13 10:41:03 +01001667 * __tty_open - open a tty device
Alan Coxaf9b8972006-08-27 01:24:01 -07001668 * @inode: inode of device file
1669 * @filp: file pointer to tty
Linus Torvalds1da177e2005-04-16 15:20:36 -07001670 *
Alan Coxaf9b8972006-08-27 01:24:01 -07001671 * tty_open and tty_release keep up the tty count that contains the
1672 * number of opens done on a tty. We cannot use the inode-count, as
1673 * different inodes might point to the same tty.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001674 *
Alan Coxaf9b8972006-08-27 01:24:01 -07001675 * Open-counting is needed for pty masters, as well as for keeping
1676 * track of serial lines: DTR is dropped when the last close happens.
1677 * (This is not done solely through tty->count, now. - Ted 1/27/92)
1678 *
1679 * The termios state of a pty is reset on first open so that
1680 * settings don't persist across reuse.
1681 *
Alan Coxd81ed102008-10-13 10:41:42 +01001682 * Locking: tty_mutex protects tty, get_tty_driver and tty_init_dev work.
Peter Zijlstra24ec8392006-12-08 02:36:04 -08001683 * tty->count should protect the rest.
1684 * ->siglock protects ->signal/->sighand
Linus Torvalds1da177e2005-04-16 15:20:36 -07001685 */
Alan Coxaf9b8972006-08-27 01:24:01 -07001686
Jonathan Corbet39d95b92008-05-16 09:10:50 -06001687static int __tty_open(struct inode *inode, struct file *filp)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001688{
Sukadev Bhattiprolu4a2b5fd2008-10-13 10:42:49 +01001689 struct tty_struct *tty = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001690 int noctty, retval;
1691 struct tty_driver *driver;
1692 int index;
1693 dev_t device = inode->i_rdev;
Andrew Morton846c1512009-04-02 16:56:36 -07001694 unsigned saved_flags = filp->f_flags;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001695
1696 nonseekable_open(inode, filp);
Alan Cox37bdfb02008-02-08 04:18:47 -08001697
Linus Torvalds1da177e2005-04-16 15:20:36 -07001698retry_open:
1699 noctty = filp->f_flags & O_NOCTTY;
1700 index = -1;
1701 retval = 0;
Alan Cox37bdfb02008-02-08 04:18:47 -08001702
Ingo Molnar70522e12006-03-23 03:00:31 -08001703 mutex_lock(&tty_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001704
Alan Cox37bdfb02008-02-08 04:18:47 -08001705 if (device == MKDEV(TTYAUX_MAJOR, 0)) {
Peter Zijlstra24ec8392006-12-08 02:36:04 -08001706 tty = get_current_tty();
1707 if (!tty) {
Ingo Molnar70522e12006-03-23 03:00:31 -08001708 mutex_unlock(&tty_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001709 return -ENXIO;
1710 }
Alan Cox7d7b93c2008-10-13 10:42:09 +01001711 driver = tty_driver_kref_get(tty->driver);
Peter Zijlstra24ec8392006-12-08 02:36:04 -08001712 index = tty->index;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001713 filp->f_flags |= O_NONBLOCK; /* Don't let /dev/tty block */
1714 /* noctty = 1; */
Alan Cox452a00d2008-10-13 10:39:13 +01001715 /* FIXME: Should we take a driver reference ? */
1716 tty_kref_put(tty);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001717 goto got_driver;
1718 }
1719#ifdef CONFIG_VT
Alan Cox37bdfb02008-02-08 04:18:47 -08001720 if (device == MKDEV(TTY_MAJOR, 0)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001721 extern struct tty_driver *console_driver;
Alan Cox7d7b93c2008-10-13 10:42:09 +01001722 driver = tty_driver_kref_get(console_driver);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001723 index = fg_console;
1724 noctty = 1;
1725 goto got_driver;
1726 }
1727#endif
Alan Cox37bdfb02008-02-08 04:18:47 -08001728 if (device == MKDEV(TTYAUX_MAJOR, 1)) {
Will Newton296fa7f2008-12-01 11:36:06 +00001729 struct tty_driver *console_driver = console_device(&index);
1730 if (console_driver) {
1731 driver = tty_driver_kref_get(console_driver);
1732 if (driver) {
1733 /* Don't let /dev/console block */
1734 filp->f_flags |= O_NONBLOCK;
1735 noctty = 1;
1736 goto got_driver;
1737 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001738 }
Ingo Molnar70522e12006-03-23 03:00:31 -08001739 mutex_unlock(&tty_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001740 return -ENODEV;
1741 }
1742
1743 driver = get_tty_driver(device, &index);
1744 if (!driver) {
Ingo Molnar70522e12006-03-23 03:00:31 -08001745 mutex_unlock(&tty_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001746 return -ENODEV;
1747 }
1748got_driver:
Sukadev Bhattiprolu4a2b5fd2008-10-13 10:42:49 +01001749 if (!tty) {
1750 /* check whether we're reopening an existing tty */
Sukadev Bhattiprolu15f1a632008-10-13 10:42:59 +01001751 tty = tty_driver_lookup_tty(driver, inode, index);
Sukadev Bhattiprolu4a2b5fd2008-10-13 10:42:49 +01001752
Eric Paris808ffa32009-01-27 11:50:37 +00001753 if (IS_ERR(tty)) {
1754 mutex_unlock(&tty_mutex);
Sukadev Bhattiprolu4a2b5fd2008-10-13 10:42:49 +01001755 return PTR_ERR(tty);
Eric Paris808ffa32009-01-27 11:50:37 +00001756 }
Sukadev Bhattiprolu4a2b5fd2008-10-13 10:42:49 +01001757 }
1758
1759 if (tty) {
1760 retval = tty_reopen(tty);
1761 if (retval)
1762 tty = ERR_PTR(retval);
1763 } else
1764 tty = tty_init_dev(driver, index, 0);
1765
Ingo Molnar70522e12006-03-23 03:00:31 -08001766 mutex_unlock(&tty_mutex);
Alan Cox7d7b93c2008-10-13 10:42:09 +01001767 tty_driver_kref_put(driver);
Alan Cox73ec06f2008-10-13 10:42:29 +01001768 if (IS_ERR(tty))
1769 return PTR_ERR(tty);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001770
1771 filp->private_data = tty;
1772 file_move(filp, &tty->tty_files);
1773 check_tty_count(tty, "tty_open");
1774 if (tty->driver->type == TTY_DRIVER_TYPE_PTY &&
1775 tty->driver->subtype == PTY_TYPE_MASTER)
1776 noctty = 1;
1777#ifdef TTY_DEBUG_HANGUP
1778 printk(KERN_DEBUG "opening %s...", tty->name);
1779#endif
1780 if (!retval) {
Alan Coxf34d7a52008-04-30 00:54:13 -07001781 if (tty->ops->open)
1782 retval = tty->ops->open(tty, filp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001783 else
1784 retval = -ENODEV;
1785 }
1786 filp->f_flags = saved_flags;
1787
Alan Cox37bdfb02008-02-08 04:18:47 -08001788 if (!retval && test_bit(TTY_EXCLUSIVE, &tty->flags) &&
1789 !capable(CAP_SYS_ADMIN))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001790 retval = -EBUSY;
1791
1792 if (retval) {
1793#ifdef TTY_DEBUG_HANGUP
1794 printk(KERN_DEBUG "error %d in opening %s...", retval,
1795 tty->name);
1796#endif
Alan Coxd81ed102008-10-13 10:41:42 +01001797 tty_release_dev(filp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001798 if (retval != -ERESTARTSYS)
1799 return retval;
1800 if (signal_pending(current))
1801 return retval;
1802 schedule();
1803 /*
1804 * Need to reset f_op in case a hangup happened.
1805 */
1806 if (filp->f_op == &hung_up_tty_fops)
1807 filp->f_op = &tty_fops;
1808 goto retry_open;
1809 }
Peter Zijlstra24ec8392006-12-08 02:36:04 -08001810
1811 mutex_lock(&tty_mutex);
1812 spin_lock_irq(&current->sighand->siglock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001813 if (!noctty &&
1814 current->signal->leader &&
1815 !current->signal->tty &&
Eric W. Biedermanab521dc2007-02-12 00:53:00 -08001816 tty->session == NULL)
Eric W. Biederman2a65f1d2007-05-08 00:26:53 -07001817 __proc_set_tty(current, tty);
Peter Zijlstra24ec8392006-12-08 02:36:04 -08001818 spin_unlock_irq(&current->sighand->siglock);
1819 mutex_unlock(&tty_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001820 return 0;
1821}
1822
Jonathan Corbet39d95b92008-05-16 09:10:50 -06001823/* BKL pushdown: scary code avoidance wrapper */
1824static int tty_open(struct inode *inode, struct file *filp)
1825{
1826 int ret;
1827
1828 lock_kernel();
1829 ret = __tty_open(inode, filp);
1830 unlock_kernel();
1831 return ret;
1832}
1833
1834
1835
Linus Torvalds1da177e2005-04-16 15:20:36 -07001836
Alan Coxaf9b8972006-08-27 01:24:01 -07001837/**
1838 * tty_release - vfs callback for close
1839 * @inode: inode of tty
1840 * @filp: file pointer for handle to tty
1841 *
1842 * Called the last time each file handle is closed that references
1843 * this tty. There may however be several such references.
1844 *
1845 * Locking:
Alan Coxd81ed102008-10-13 10:41:42 +01001846 * Takes bkl. See tty_release_dev
Alan Coxaf9b8972006-08-27 01:24:01 -07001847 */
1848
Alan Cox37bdfb02008-02-08 04:18:47 -08001849static int tty_release(struct inode *inode, struct file *filp)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001850{
1851 lock_kernel();
Alan Coxd81ed102008-10-13 10:41:42 +01001852 tty_release_dev(filp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001853 unlock_kernel();
1854 return 0;
1855}
1856
Alan Coxaf9b8972006-08-27 01:24:01 -07001857/**
1858 * tty_poll - check tty status
1859 * @filp: file being polled
1860 * @wait: poll wait structures to update
1861 *
1862 * Call the line discipline polling method to obtain the poll
1863 * status of the device.
1864 *
1865 * Locking: locks called line discipline but ldisc poll method
1866 * may be re-entered freely by other callers.
1867 */
1868
Alan Cox37bdfb02008-02-08 04:18:47 -08001869static unsigned int tty_poll(struct file *filp, poll_table *wait)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001870{
Alan Cox37bdfb02008-02-08 04:18:47 -08001871 struct tty_struct *tty;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001872 struct tty_ldisc *ld;
1873 int ret = 0;
1874
1875 tty = (struct tty_struct *)filp->private_data;
Josef Sipeka7113a92006-12-08 02:36:55 -08001876 if (tty_paranoia_check(tty, filp->f_path.dentry->d_inode, "tty_poll"))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001877 return 0;
Alan Cox37bdfb02008-02-08 04:18:47 -08001878
Linus Torvalds1da177e2005-04-16 15:20:36 -07001879 ld = tty_ldisc_ref_wait(tty);
Alan Coxa352def2008-07-16 21:53:12 +01001880 if (ld->ops->poll)
1881 ret = (ld->ops->poll)(tty, filp, wait);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001882 tty_ldisc_deref(ld);
1883 return ret;
1884}
1885
Alan Cox37bdfb02008-02-08 04:18:47 -08001886static int tty_fasync(int fd, struct file *filp, int on)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001887{
Alan Cox37bdfb02008-02-08 04:18:47 -08001888 struct tty_struct *tty;
Alan Cox47f86832008-04-30 00:53:30 -07001889 unsigned long flags;
Jonathan Corbet5d1e3232008-06-19 16:04:53 -06001890 int retval = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001891
Jonathan Corbet5d1e3232008-06-19 16:04:53 -06001892 lock_kernel();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001893 tty = (struct tty_struct *)filp->private_data;
Josef Sipeka7113a92006-12-08 02:36:55 -08001894 if (tty_paranoia_check(tty, filp->f_path.dentry->d_inode, "tty_fasync"))
Jonathan Corbet5d1e3232008-06-19 16:04:53 -06001895 goto out;
Alan Cox37bdfb02008-02-08 04:18:47 -08001896
Linus Torvalds1da177e2005-04-16 15:20:36 -07001897 retval = fasync_helper(fd, filp, on, &tty->fasync);
1898 if (retval <= 0)
Jonathan Corbet5d1e3232008-06-19 16:04:53 -06001899 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001900
1901 if (on) {
Eric W. Biedermanab521dc2007-02-12 00:53:00 -08001902 enum pid_type type;
1903 struct pid *pid;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001904 if (!waitqueue_active(&tty->read_wait))
1905 tty->minimum_to_wake = 1;
Alan Cox47f86832008-04-30 00:53:30 -07001906 spin_lock_irqsave(&tty->ctrl_lock, flags);
Eric W. Biedermanab521dc2007-02-12 00:53:00 -08001907 if (tty->pgrp) {
1908 pid = tty->pgrp;
1909 type = PIDTYPE_PGID;
1910 } else {
1911 pid = task_pid(current);
1912 type = PIDTYPE_PID;
1913 }
Alan Cox47f86832008-04-30 00:53:30 -07001914 spin_unlock_irqrestore(&tty->ctrl_lock, flags);
Eric W. Biedermanab521dc2007-02-12 00:53:00 -08001915 retval = __f_setown(filp, pid, type, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001916 if (retval)
Jonathan Corbet5d1e3232008-06-19 16:04:53 -06001917 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001918 } else {
1919 if (!tty->fasync && !waitqueue_active(&tty->read_wait))
1920 tty->minimum_to_wake = N_TTY_BUF_SIZE;
1921 }
Jonathan Corbet5d1e3232008-06-19 16:04:53 -06001922 retval = 0;
1923out:
1924 unlock_kernel();
1925 return retval;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001926}
1927
Alan Coxaf9b8972006-08-27 01:24:01 -07001928/**
1929 * tiocsti - fake input character
1930 * @tty: tty to fake input into
1931 * @p: pointer to character
1932 *
Robert P. J. Day3a4fa0a2007-10-19 23:10:43 +02001933 * Fake input to a tty device. Does the necessary locking and
Alan Coxaf9b8972006-08-27 01:24:01 -07001934 * input management.
1935 *
1936 * FIXME: does not honour flow control ??
1937 *
1938 * Locking:
1939 * Called functions take tty_ldisc_lock
1940 * current->signal->tty check is safe without locks
Alan Cox28298232006-09-29 02:00:58 -07001941 *
1942 * FIXME: may race normal receive processing
Alan Coxaf9b8972006-08-27 01:24:01 -07001943 */
1944
Linus Torvalds1da177e2005-04-16 15:20:36 -07001945static int tiocsti(struct tty_struct *tty, char __user *p)
1946{
1947 char ch, mbz = 0;
1948 struct tty_ldisc *ld;
Alan Cox37bdfb02008-02-08 04:18:47 -08001949
Linus Torvalds1da177e2005-04-16 15:20:36 -07001950 if ((current->signal->tty != tty) && !capable(CAP_SYS_ADMIN))
1951 return -EPERM;
1952 if (get_user(ch, p))
1953 return -EFAULT;
Al Viro1e641742008-12-09 09:23:33 +00001954 tty_audit_tiocsti(tty, ch);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001955 ld = tty_ldisc_ref_wait(tty);
Alan Coxa352def2008-07-16 21:53:12 +01001956 ld->ops->receive_buf(tty, &ch, &mbz, 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001957 tty_ldisc_deref(ld);
1958 return 0;
1959}
1960
Alan Coxaf9b8972006-08-27 01:24:01 -07001961/**
1962 * tiocgwinsz - implement window query ioctl
1963 * @tty; tty
1964 * @arg: user buffer for result
1965 *
Alan Cox808a0d32006-09-29 02:00:40 -07001966 * Copies the kernel idea of the window size into the user buffer.
Alan Coxaf9b8972006-08-27 01:24:01 -07001967 *
Peter Zijlstra24ec8392006-12-08 02:36:04 -08001968 * Locking: tty->termios_mutex is taken to ensure the winsize data
Alan Cox808a0d32006-09-29 02:00:40 -07001969 * is consistent.
Alan Coxaf9b8972006-08-27 01:24:01 -07001970 */
1971
Alan Cox37bdfb02008-02-08 04:18:47 -08001972static int tiocgwinsz(struct tty_struct *tty, struct winsize __user *arg)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001973{
Alan Cox808a0d32006-09-29 02:00:40 -07001974 int err;
1975
Arjan van de Ven5785c952006-09-29 02:00:43 -07001976 mutex_lock(&tty->termios_mutex);
Alan Cox808a0d32006-09-29 02:00:40 -07001977 err = copy_to_user(arg, &tty->winsize, sizeof(*arg));
Arjan van de Ven5785c952006-09-29 02:00:43 -07001978 mutex_unlock(&tty->termios_mutex);
Alan Cox808a0d32006-09-29 02:00:40 -07001979
1980 return err ? -EFAULT: 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001981}
1982
Alan Coxaf9b8972006-08-27 01:24:01 -07001983/**
Alan Cox8c9a9dd2008-08-15 10:39:38 +01001984 * tty_do_resize - resize event
1985 * @tty: tty being resized
Alan Cox8c9a9dd2008-08-15 10:39:38 +01001986 * @rows: rows (character)
1987 * @cols: cols (character)
Alan Coxaf9b8972006-08-27 01:24:01 -07001988 *
Alan Cox8c9a9dd2008-08-15 10:39:38 +01001989 * Update the termios variables and send the neccessary signals to
1990 * peform a terminal resize correctly
Alan Coxaf9b8972006-08-27 01:24:01 -07001991 */
1992
Alan Coxfc6f6232009-01-02 13:43:17 +00001993int tty_do_resize(struct tty_struct *tty, struct winsize *ws)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001994{
Alan Coxfc6f6232009-01-02 13:43:17 +00001995 struct pid *pgrp;
Alan Cox47f86832008-04-30 00:53:30 -07001996 unsigned long flags;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001997
Alan Coxfc6f6232009-01-02 13:43:17 +00001998 /* Lock the tty */
1999 mutex_lock(&tty->termios_mutex);
2000 if (!memcmp(ws, &tty->winsize, sizeof(*ws)))
Alan Coxca9bda02006-09-29 02:00:03 -07002001 goto done;
Alan Cox47f86832008-04-30 00:53:30 -07002002 /* Get the PID values and reference them so we can
2003 avoid holding the tty ctrl lock while sending signals */
2004 spin_lock_irqsave(&tty->ctrl_lock, flags);
2005 pgrp = get_pid(tty->pgrp);
Alan Cox47f86832008-04-30 00:53:30 -07002006 spin_unlock_irqrestore(&tty->ctrl_lock, flags);
2007
2008 if (pgrp)
2009 kill_pgrp(pgrp, SIGWINCH, 1);
Alan Cox47f86832008-04-30 00:53:30 -07002010 put_pid(pgrp);
Alan Cox47f86832008-04-30 00:53:30 -07002011
Alan Cox8c9a9dd2008-08-15 10:39:38 +01002012 tty->winsize = *ws;
Alan Coxca9bda02006-09-29 02:00:03 -07002013done:
Alan Coxfc6f6232009-01-02 13:43:17 +00002014 mutex_unlock(&tty->termios_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002015 return 0;
2016}
2017
Alan Coxaf9b8972006-08-27 01:24:01 -07002018/**
Alan Cox8c9a9dd2008-08-15 10:39:38 +01002019 * tiocswinsz - implement window size set ioctl
Alan Coxfc6f6232009-01-02 13:43:17 +00002020 * @tty; tty side of tty
Alan Cox8c9a9dd2008-08-15 10:39:38 +01002021 * @arg: user buffer for result
2022 *
2023 * Copies the user idea of the window size to the kernel. Traditionally
2024 * this is just advisory information but for the Linux console it
2025 * actually has driver level meaning and triggers a VC resize.
2026 *
2027 * Locking:
2028 * Driver dependant. The default do_resize method takes the
2029 * tty termios mutex and ctrl_lock. The console takes its own lock
2030 * then calls into the default method.
2031 */
2032
Alan Coxfc6f6232009-01-02 13:43:17 +00002033static int tiocswinsz(struct tty_struct *tty, struct winsize __user *arg)
Alan Cox8c9a9dd2008-08-15 10:39:38 +01002034{
2035 struct winsize tmp_ws;
2036 if (copy_from_user(&tmp_ws, arg, sizeof(*arg)))
2037 return -EFAULT;
2038
2039 if (tty->ops->resize)
Alan Coxfc6f6232009-01-02 13:43:17 +00002040 return tty->ops->resize(tty, &tmp_ws);
Alan Cox8c9a9dd2008-08-15 10:39:38 +01002041 else
Alan Coxfc6f6232009-01-02 13:43:17 +00002042 return tty_do_resize(tty, &tmp_ws);
Alan Cox8c9a9dd2008-08-15 10:39:38 +01002043}
2044
2045/**
Alan Coxaf9b8972006-08-27 01:24:01 -07002046 * tioccons - allow admin to move logical console
2047 * @file: the file to become console
2048 *
2049 * Allow the adminstrator to move the redirected console device
2050 *
2051 * Locking: uses redirect_lock to guard the redirect information
2052 */
2053
Linus Torvalds1da177e2005-04-16 15:20:36 -07002054static int tioccons(struct file *file)
2055{
2056 if (!capable(CAP_SYS_ADMIN))
2057 return -EPERM;
2058 if (file->f_op->write == redirected_tty_write) {
2059 struct file *f;
2060 spin_lock(&redirect_lock);
2061 f = redirect;
2062 redirect = NULL;
2063 spin_unlock(&redirect_lock);
2064 if (f)
2065 fput(f);
2066 return 0;
2067 }
2068 spin_lock(&redirect_lock);
2069 if (redirect) {
2070 spin_unlock(&redirect_lock);
2071 return -EBUSY;
2072 }
2073 get_file(file);
2074 redirect = file;
2075 spin_unlock(&redirect_lock);
2076 return 0;
2077}
2078
Alan Coxaf9b8972006-08-27 01:24:01 -07002079/**
2080 * fionbio - non blocking ioctl
2081 * @file: file to set blocking value
2082 * @p: user parameter
2083 *
2084 * Historical tty interfaces had a blocking control ioctl before
2085 * the generic functionality existed. This piece of history is preserved
2086 * in the expected tty API of posix OS's.
2087 *
2088 * Locking: none, the open fle handle ensures it won't go away.
2089 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002090
2091static int fionbio(struct file *file, int __user *p)
2092{
2093 int nonblock;
2094
2095 if (get_user(nonblock, p))
2096 return -EFAULT;
2097
Jonathan Corbetdb1dd4d2009-02-06 15:25:24 -07002098 spin_lock(&file->f_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002099 if (nonblock)
2100 file->f_flags |= O_NONBLOCK;
2101 else
2102 file->f_flags &= ~O_NONBLOCK;
Jonathan Corbetdb1dd4d2009-02-06 15:25:24 -07002103 spin_unlock(&file->f_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002104 return 0;
2105}
2106
Alan Coxaf9b8972006-08-27 01:24:01 -07002107/**
2108 * tiocsctty - set controlling tty
2109 * @tty: tty structure
2110 * @arg: user argument
2111 *
2112 * This ioctl is used to manage job control. It permits a session
2113 * leader to set this tty as the controlling tty for the session.
2114 *
2115 * Locking:
Alan Cox28298232006-09-29 02:00:58 -07002116 * Takes tty_mutex() to protect tty instance
Peter Zijlstra24ec8392006-12-08 02:36:04 -08002117 * Takes tasklist_lock internally to walk sessions
2118 * Takes ->siglock() when updating signal->tty
Alan Coxaf9b8972006-08-27 01:24:01 -07002119 */
2120
Linus Torvalds1da177e2005-04-16 15:20:36 -07002121static int tiocsctty(struct tty_struct *tty, int arg)
2122{
Peter Zijlstra24ec8392006-12-08 02:36:04 -08002123 int ret = 0;
Eric W. Biedermanab521dc2007-02-12 00:53:00 -08002124 if (current->signal->leader && (task_session(current) == tty->session))
Peter Zijlstra24ec8392006-12-08 02:36:04 -08002125 return ret;
2126
2127 mutex_lock(&tty_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002128 /*
2129 * The process must be a session leader and
2130 * not have a controlling tty already.
2131 */
Peter Zijlstra24ec8392006-12-08 02:36:04 -08002132 if (!current->signal->leader || current->signal->tty) {
2133 ret = -EPERM;
2134 goto unlock;
2135 }
2136
Eric W. Biedermanab521dc2007-02-12 00:53:00 -08002137 if (tty->session) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002138 /*
2139 * This tty is already the controlling
2140 * tty for another session group!
2141 */
Alan Cox37bdfb02008-02-08 04:18:47 -08002142 if (arg == 1 && capable(CAP_SYS_ADMIN)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002143 /*
2144 * Steal it away
2145 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002146 read_lock(&tasklist_lock);
Peter Zijlstra24ec8392006-12-08 02:36:04 -08002147 session_clear_tty(tty->session);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002148 read_unlock(&tasklist_lock);
Peter Zijlstra24ec8392006-12-08 02:36:04 -08002149 } else {
2150 ret = -EPERM;
2151 goto unlock;
2152 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002153 }
Peter Zijlstra24ec8392006-12-08 02:36:04 -08002154 proc_set_tty(current, tty);
2155unlock:
Alan Cox28298232006-09-29 02:00:58 -07002156 mutex_unlock(&tty_mutex);
Peter Zijlstra24ec8392006-12-08 02:36:04 -08002157 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002158}
2159
Alan Coxaf9b8972006-08-27 01:24:01 -07002160/**
Alan Cox5d0fdf12008-04-30 00:53:31 -07002161 * tty_get_pgrp - return a ref counted pgrp pid
2162 * @tty: tty to read
2163 *
2164 * Returns a refcounted instance of the pid struct for the process
2165 * group controlling the tty.
2166 */
2167
2168struct pid *tty_get_pgrp(struct tty_struct *tty)
2169{
2170 unsigned long flags;
2171 struct pid *pgrp;
2172
2173 spin_lock_irqsave(&tty->ctrl_lock, flags);
2174 pgrp = get_pid(tty->pgrp);
2175 spin_unlock_irqrestore(&tty->ctrl_lock, flags);
2176
2177 return pgrp;
2178}
2179EXPORT_SYMBOL_GPL(tty_get_pgrp);
2180
2181/**
Alan Coxaf9b8972006-08-27 01:24:01 -07002182 * tiocgpgrp - get process group
2183 * @tty: tty passed by user
2184 * @real_tty: tty side of the tty pased by the user if a pty else the tty
2185 * @p: returned pid
2186 *
2187 * Obtain the process group of the tty. If there is no process group
2188 * return an error.
2189 *
Peter Zijlstra24ec8392006-12-08 02:36:04 -08002190 * Locking: none. Reference to current->signal->tty is safe.
Alan Coxaf9b8972006-08-27 01:24:01 -07002191 */
2192
Linus Torvalds1da177e2005-04-16 15:20:36 -07002193static int tiocgpgrp(struct tty_struct *tty, struct tty_struct *real_tty, pid_t __user *p)
2194{
Alan Cox5d0fdf12008-04-30 00:53:31 -07002195 struct pid *pid;
2196 int ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002197 /*
2198 * (tty == real_tty) is a cheap way of
2199 * testing if the tty is NOT a master pty.
2200 */
2201 if (tty == real_tty && current->signal->tty != real_tty)
2202 return -ENOTTY;
Alan Cox5d0fdf12008-04-30 00:53:31 -07002203 pid = tty_get_pgrp(real_tty);
2204 ret = put_user(pid_vnr(pid), p);
2205 put_pid(pid);
2206 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002207}
2208
Alan Coxaf9b8972006-08-27 01:24:01 -07002209/**
2210 * tiocspgrp - attempt to set process group
2211 * @tty: tty passed by user
2212 * @real_tty: tty side device matching tty passed by user
2213 * @p: pid pointer
2214 *
2215 * Set the process group of the tty to the session passed. Only
2216 * permitted where the tty session is our session.
2217 *
Alan Cox47f86832008-04-30 00:53:30 -07002218 * Locking: RCU, ctrl lock
Alan Coxaf9b8972006-08-27 01:24:01 -07002219 */
2220
Linus Torvalds1da177e2005-04-16 15:20:36 -07002221static int tiocspgrp(struct tty_struct *tty, struct tty_struct *real_tty, pid_t __user *p)
2222{
Eric W. Biederman04a2e6a2007-02-12 00:52:56 -08002223 struct pid *pgrp;
2224 pid_t pgrp_nr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002225 int retval = tty_check_change(real_tty);
Alan Cox47f86832008-04-30 00:53:30 -07002226 unsigned long flags;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002227
2228 if (retval == -EIO)
2229 return -ENOTTY;
2230 if (retval)
2231 return retval;
2232 if (!current->signal->tty ||
2233 (current->signal->tty != real_tty) ||
Eric W. Biedermanab521dc2007-02-12 00:53:00 -08002234 (real_tty->session != task_session(current)))
Linus Torvalds1da177e2005-04-16 15:20:36 -07002235 return -ENOTTY;
Eric W. Biederman04a2e6a2007-02-12 00:52:56 -08002236 if (get_user(pgrp_nr, p))
Linus Torvalds1da177e2005-04-16 15:20:36 -07002237 return -EFAULT;
Eric W. Biederman04a2e6a2007-02-12 00:52:56 -08002238 if (pgrp_nr < 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002239 return -EINVAL;
Eric W. Biederman04a2e6a2007-02-12 00:52:56 -08002240 rcu_read_lock();
Pavel Emelyanovb4888932007-10-18 23:40:14 -07002241 pgrp = find_vpid(pgrp_nr);
Eric W. Biederman04a2e6a2007-02-12 00:52:56 -08002242 retval = -ESRCH;
2243 if (!pgrp)
2244 goto out_unlock;
2245 retval = -EPERM;
2246 if (session_of_pgrp(pgrp) != task_session(current))
2247 goto out_unlock;
2248 retval = 0;
Alan Cox47f86832008-04-30 00:53:30 -07002249 spin_lock_irqsave(&tty->ctrl_lock, flags);
Eric W. Biedermanab521dc2007-02-12 00:53:00 -08002250 put_pid(real_tty->pgrp);
2251 real_tty->pgrp = get_pid(pgrp);
Alan Cox47f86832008-04-30 00:53:30 -07002252 spin_unlock_irqrestore(&tty->ctrl_lock, flags);
Eric W. Biederman04a2e6a2007-02-12 00:52:56 -08002253out_unlock:
2254 rcu_read_unlock();
2255 return retval;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002256}
2257
Alan Coxaf9b8972006-08-27 01:24:01 -07002258/**
2259 * tiocgsid - get session id
2260 * @tty: tty passed by user
2261 * @real_tty: tty side of the tty pased by the user if a pty else the tty
2262 * @p: pointer to returned session id
2263 *
2264 * Obtain the session id of the tty. If there is no session
2265 * return an error.
2266 *
Peter Zijlstra24ec8392006-12-08 02:36:04 -08002267 * Locking: none. Reference to current->signal->tty is safe.
Alan Coxaf9b8972006-08-27 01:24:01 -07002268 */
2269
Linus Torvalds1da177e2005-04-16 15:20:36 -07002270static int tiocgsid(struct tty_struct *tty, struct tty_struct *real_tty, pid_t __user *p)
2271{
2272 /*
2273 * (tty == real_tty) is a cheap way of
2274 * testing if the tty is NOT a master pty.
2275 */
2276 if (tty == real_tty && current->signal->tty != real_tty)
2277 return -ENOTTY;
Eric W. Biedermanab521dc2007-02-12 00:53:00 -08002278 if (!real_tty->session)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002279 return -ENOTTY;
Pavel Emelyanovb4888932007-10-18 23:40:14 -07002280 return put_user(pid_vnr(real_tty->session), p);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002281}
2282
Alan Coxaf9b8972006-08-27 01:24:01 -07002283/**
2284 * tiocsetd - set line discipline
2285 * @tty: tty device
2286 * @p: pointer to user data
2287 *
2288 * Set the line discipline according to user request.
2289 *
2290 * Locking: see tty_set_ldisc, this function is just a helper
2291 */
2292
Linus Torvalds1da177e2005-04-16 15:20:36 -07002293static int tiocsetd(struct tty_struct *tty, int __user *p)
2294{
2295 int ldisc;
Alan Cox04f378b2008-04-30 00:53:29 -07002296 int ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002297
2298 if (get_user(ldisc, p))
2299 return -EFAULT;
Alan Cox04f378b2008-04-30 00:53:29 -07002300
2301 lock_kernel();
2302 ret = tty_set_ldisc(tty, ldisc);
2303 unlock_kernel();
2304
2305 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002306}
2307
Alan Coxaf9b8972006-08-27 01:24:01 -07002308/**
2309 * send_break - performed time break
2310 * @tty: device to break on
2311 * @duration: timeout in mS
2312 *
2313 * Perform a timed break on hardware that lacks its own driver level
2314 * timed break functionality.
2315 *
2316 * Locking:
Alan Cox28298232006-09-29 02:00:58 -07002317 * atomic_write_lock serializes
Alan Coxaf9b8972006-08-27 01:24:01 -07002318 *
Alan Coxaf9b8972006-08-27 01:24:01 -07002319 */
2320
Domen Puncerb20f3ae2005-06-25 14:58:42 -07002321static int send_break(struct tty_struct *tty, unsigned int duration)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002322{
Alan Cox9e989662008-07-22 11:18:03 +01002323 int retval;
2324
2325 if (tty->ops->break_ctl == NULL)
2326 return 0;
2327
2328 if (tty->driver->flags & TTY_DRIVER_HARDWARE_BREAK)
2329 retval = tty->ops->break_ctl(tty, duration);
2330 else {
2331 /* Do the work ourselves */
2332 if (tty_write_lock(tty, 0) < 0)
2333 return -EINTR;
2334 retval = tty->ops->break_ctl(tty, -1);
2335 if (retval)
2336 goto out;
2337 if (!signal_pending(current))
2338 msleep_interruptible(duration);
2339 retval = tty->ops->break_ctl(tty, 0);
2340out:
2341 tty_write_unlock(tty);
2342 if (signal_pending(current))
2343 retval = -EINTR;
2344 }
2345 return retval;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002346}
2347
Alan Coxaf9b8972006-08-27 01:24:01 -07002348/**
Alan Coxf34d7a52008-04-30 00:54:13 -07002349 * tty_tiocmget - get modem status
Alan Coxaf9b8972006-08-27 01:24:01 -07002350 * @tty: tty device
2351 * @file: user file pointer
2352 * @p: pointer to result
2353 *
2354 * Obtain the modem status bits from the tty driver if the feature
2355 * is supported. Return -EINVAL if it is not available.
2356 *
2357 * Locking: none (up to the driver)
2358 */
2359
2360static int tty_tiocmget(struct tty_struct *tty, struct file *file, int __user *p)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002361{
2362 int retval = -EINVAL;
2363
Alan Coxf34d7a52008-04-30 00:54:13 -07002364 if (tty->ops->tiocmget) {
2365 retval = tty->ops->tiocmget(tty, file);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002366
2367 if (retval >= 0)
2368 retval = put_user(retval, p);
2369 }
2370 return retval;
2371}
2372
Alan Coxaf9b8972006-08-27 01:24:01 -07002373/**
Alan Coxf34d7a52008-04-30 00:54:13 -07002374 * tty_tiocmset - set modem status
Alan Coxaf9b8972006-08-27 01:24:01 -07002375 * @tty: tty device
2376 * @file: user file pointer
2377 * @cmd: command - clear bits, set bits or set all
2378 * @p: pointer to desired bits
2379 *
2380 * Set the modem status bits from the tty driver if the feature
2381 * is supported. Return -EINVAL if it is not available.
2382 *
2383 * Locking: none (up to the driver)
2384 */
2385
2386static int tty_tiocmset(struct tty_struct *tty, struct file *file, unsigned int cmd,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002387 unsigned __user *p)
2388{
Alan Coxae677512008-07-16 21:56:54 +01002389 int retval;
2390 unsigned int set, clear, val;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002391
Alan Coxae677512008-07-16 21:56:54 +01002392 if (tty->ops->tiocmset == NULL)
2393 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002394
Alan Coxae677512008-07-16 21:56:54 +01002395 retval = get_user(val, p);
2396 if (retval)
2397 return retval;
2398 set = clear = 0;
2399 switch (cmd) {
2400 case TIOCMBIS:
2401 set = val;
2402 break;
2403 case TIOCMBIC:
2404 clear = val;
2405 break;
2406 case TIOCMSET:
2407 set = val;
2408 clear = ~val;
2409 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002410 }
Alan Coxae677512008-07-16 21:56:54 +01002411 set &= TIOCM_DTR|TIOCM_RTS|TIOCM_OUT1|TIOCM_OUT2|TIOCM_LOOP;
2412 clear &= TIOCM_DTR|TIOCM_RTS|TIOCM_OUT1|TIOCM_OUT2|TIOCM_LOOP;
2413 return tty->ops->tiocmset(tty, file, set, clear);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002414}
2415
Alan Coxe8b70e72009-06-11 12:48:02 +01002416struct tty_struct *tty_pair_get_tty(struct tty_struct *tty)
2417{
2418 if (tty->driver->type == TTY_DRIVER_TYPE_PTY &&
2419 tty->driver->subtype == PTY_TYPE_MASTER)
2420 tty = tty->link;
2421 return tty;
2422}
2423EXPORT_SYMBOL(tty_pair_get_tty);
2424
2425struct tty_struct *tty_pair_get_pty(struct tty_struct *tty)
2426{
2427 if (tty->driver->type == TTY_DRIVER_TYPE_PTY &&
2428 tty->driver->subtype == PTY_TYPE_MASTER)
2429 return tty;
2430 return tty->link;
2431}
2432EXPORT_SYMBOL(tty_pair_get_pty);
2433
Linus Torvalds1da177e2005-04-16 15:20:36 -07002434/*
2435 * Split this up, as gcc can choke on it otherwise..
2436 */
Alan Cox04f378b2008-04-30 00:53:29 -07002437long tty_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002438{
2439 struct tty_struct *tty, *real_tty;
2440 void __user *p = (void __user *)arg;
2441 int retval;
2442 struct tty_ldisc *ld;
Alan Cox04f378b2008-04-30 00:53:29 -07002443 struct inode *inode = file->f_dentry->d_inode;
Alan Cox37bdfb02008-02-08 04:18:47 -08002444
Linus Torvalds1da177e2005-04-16 15:20:36 -07002445 tty = (struct tty_struct *)file->private_data;
2446 if (tty_paranoia_check(tty, inode, "tty_ioctl"))
2447 return -EINVAL;
2448
Alan Coxe8b70e72009-06-11 12:48:02 +01002449 real_tty = tty_pair_get_tty(tty);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002450
2451 /*
2452 * Factor out some common prep work
2453 */
2454 switch (cmd) {
2455 case TIOCSETD:
2456 case TIOCSBRK:
2457 case TIOCCBRK:
2458 case TCSBRK:
Alan Cox37bdfb02008-02-08 04:18:47 -08002459 case TCSBRKP:
Linus Torvalds1da177e2005-04-16 15:20:36 -07002460 retval = tty_check_change(tty);
2461 if (retval)
2462 return retval;
2463 if (cmd != TIOCCBRK) {
2464 tty_wait_until_sent(tty, 0);
2465 if (signal_pending(current))
2466 return -EINTR;
2467 }
2468 break;
2469 }
2470
Alan Cox9e989662008-07-22 11:18:03 +01002471 /*
2472 * Now do the stuff.
2473 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002474 switch (cmd) {
Alan Cox37bdfb02008-02-08 04:18:47 -08002475 case TIOCSTI:
2476 return tiocsti(tty, p);
2477 case TIOCGWINSZ:
Alan Cox8f520022008-10-13 10:38:46 +01002478 return tiocgwinsz(real_tty, p);
Alan Cox37bdfb02008-02-08 04:18:47 -08002479 case TIOCSWINSZ:
Alan Coxfc6f6232009-01-02 13:43:17 +00002480 return tiocswinsz(real_tty, p);
Alan Cox37bdfb02008-02-08 04:18:47 -08002481 case TIOCCONS:
2482 return real_tty != tty ? -EINVAL : tioccons(file);
2483 case FIONBIO:
2484 return fionbio(file, p);
2485 case TIOCEXCL:
2486 set_bit(TTY_EXCLUSIVE, &tty->flags);
2487 return 0;
2488 case TIOCNXCL:
2489 clear_bit(TTY_EXCLUSIVE, &tty->flags);
2490 return 0;
2491 case TIOCNOTTY:
2492 if (current->signal->tty != tty)
2493 return -ENOTTY;
2494 no_tty();
2495 return 0;
2496 case TIOCSCTTY:
2497 return tiocsctty(tty, arg);
2498 case TIOCGPGRP:
2499 return tiocgpgrp(tty, real_tty, p);
2500 case TIOCSPGRP:
2501 return tiocspgrp(tty, real_tty, p);
2502 case TIOCGSID:
2503 return tiocgsid(tty, real_tty, p);
2504 case TIOCGETD:
Alan Coxc65c9bc2009-06-11 12:50:12 +01002505 return put_user(tty->ldisc->ops->num, (int __user *)p);
Alan Cox37bdfb02008-02-08 04:18:47 -08002506 case TIOCSETD:
2507 return tiocsetd(tty, p);
Alan Cox37bdfb02008-02-08 04:18:47 -08002508 /*
2509 * Break handling
2510 */
2511 case TIOCSBRK: /* Turn break on, unconditionally */
Alan Coxf34d7a52008-04-30 00:54:13 -07002512 if (tty->ops->break_ctl)
Alan Cox9e989662008-07-22 11:18:03 +01002513 return tty->ops->break_ctl(tty, -1);
Alan Cox37bdfb02008-02-08 04:18:47 -08002514 return 0;
Alan Cox37bdfb02008-02-08 04:18:47 -08002515 case TIOCCBRK: /* Turn break off, unconditionally */
Alan Coxf34d7a52008-04-30 00:54:13 -07002516 if (tty->ops->break_ctl)
Alan Cox9e989662008-07-22 11:18:03 +01002517 return tty->ops->break_ctl(tty, 0);
Alan Cox37bdfb02008-02-08 04:18:47 -08002518 return 0;
2519 case TCSBRK: /* SVID version: non-zero arg --> no break */
2520 /* non-zero arg means wait for all output data
2521 * to be sent (performed above) but don't send break.
2522 * This is used by the tcdrain() termios function.
Linus Torvalds1da177e2005-04-16 15:20:36 -07002523 */
Alan Cox37bdfb02008-02-08 04:18:47 -08002524 if (!arg)
2525 return send_break(tty, 250);
2526 return 0;
2527 case TCSBRKP: /* support for POSIX tcsendbreak() */
2528 return send_break(tty, arg ? arg*100 : 250);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002529
Alan Cox37bdfb02008-02-08 04:18:47 -08002530 case TIOCMGET:
2531 return tty_tiocmget(tty, file, p);
2532 case TIOCMSET:
2533 case TIOCMBIC:
2534 case TIOCMBIS:
2535 return tty_tiocmset(tty, file, cmd, p);
2536 case TCFLSH:
2537 switch (arg) {
2538 case TCIFLUSH:
2539 case TCIOFLUSH:
2540 /* flush tty buffer and allow ldisc to process ioctl */
2541 tty_buffer_flush(tty);
Paul Fulghumc5c34d42007-05-12 10:36:55 -07002542 break;
Alan Cox37bdfb02008-02-08 04:18:47 -08002543 }
2544 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002545 }
Alan Coxf34d7a52008-04-30 00:54:13 -07002546 if (tty->ops->ioctl) {
2547 retval = (tty->ops->ioctl)(tty, file, cmd, arg);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002548 if (retval != -ENOIOCTLCMD)
2549 return retval;
2550 }
2551 ld = tty_ldisc_ref_wait(tty);
2552 retval = -EINVAL;
Alan Coxa352def2008-07-16 21:53:12 +01002553 if (ld->ops->ioctl) {
2554 retval = ld->ops->ioctl(tty, file, cmd, arg);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002555 if (retval == -ENOIOCTLCMD)
2556 retval = -EINVAL;
2557 }
2558 tty_ldisc_deref(ld);
2559 return retval;
2560}
2561
Paul Fulghume10cc1d2007-05-10 22:22:50 -07002562#ifdef CONFIG_COMPAT
Alan Cox37bdfb02008-02-08 04:18:47 -08002563static long tty_compat_ioctl(struct file *file, unsigned int cmd,
Paul Fulghume10cc1d2007-05-10 22:22:50 -07002564 unsigned long arg)
2565{
2566 struct inode *inode = file->f_dentry->d_inode;
2567 struct tty_struct *tty = file->private_data;
2568 struct tty_ldisc *ld;
2569 int retval = -ENOIOCTLCMD;
2570
2571 if (tty_paranoia_check(tty, inode, "tty_ioctl"))
2572 return -EINVAL;
2573
Alan Coxf34d7a52008-04-30 00:54:13 -07002574 if (tty->ops->compat_ioctl) {
2575 retval = (tty->ops->compat_ioctl)(tty, file, cmd, arg);
Paul Fulghume10cc1d2007-05-10 22:22:50 -07002576 if (retval != -ENOIOCTLCMD)
2577 return retval;
2578 }
2579
2580 ld = tty_ldisc_ref_wait(tty);
Alan Coxa352def2008-07-16 21:53:12 +01002581 if (ld->ops->compat_ioctl)
2582 retval = ld->ops->compat_ioctl(tty, file, cmd, arg);
Paul Fulghume10cc1d2007-05-10 22:22:50 -07002583 tty_ldisc_deref(ld);
2584
2585 return retval;
2586}
2587#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07002588
2589/*
2590 * This implements the "Secure Attention Key" --- the idea is to
2591 * prevent trojan horses by killing all processes associated with this
2592 * tty when the user hits the "Secure Attention Key". Required for
2593 * super-paranoid applications --- see the Orange Book for more details.
Alan Cox37bdfb02008-02-08 04:18:47 -08002594 *
Linus Torvalds1da177e2005-04-16 15:20:36 -07002595 * This code could be nicer; ideally it should send a HUP, wait a few
2596 * seconds, then send a INT, and then a KILL signal. But you then
2597 * have to coordinate with the init process, since all processes associated
2598 * with the current tty must be dead before the new getty is allowed
2599 * to spawn.
2600 *
2601 * Now, if it would be correct ;-/ The current code has a nasty hole -
2602 * it doesn't catch files in flight. We may send the descriptor to ourselves
2603 * via AF_UNIX socket, close it and later fetch from socket. FIXME.
2604 *
2605 * Nasty bug: do_SAK is being called in interrupt context. This can
2606 * deadlock. We punt it up to process context. AKPM - 16Mar2001
2607 */
Eric W. Biederman8b6312f2007-02-10 01:44:34 -08002608void __do_SAK(struct tty_struct *tty)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002609{
2610#ifdef TTY_SOFT_SAK
2611 tty_hangup(tty);
2612#else
Eric W. Biederman652486f2006-03-28 16:11:02 -08002613 struct task_struct *g, *p;
Eric W. Biedermanab521dc2007-02-12 00:53:00 -08002614 struct pid *session;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002615 int i;
2616 struct file *filp;
Dipankar Sarmabadf1662005-09-09 13:04:10 -07002617 struct fdtable *fdt;
Alan Cox37bdfb02008-02-08 04:18:47 -08002618
Linus Torvalds1da177e2005-04-16 15:20:36 -07002619 if (!tty)
2620 return;
Peter Zijlstra24ec8392006-12-08 02:36:04 -08002621 session = tty->session;
Alan Cox37bdfb02008-02-08 04:18:47 -08002622
Dan Carpenterb3f13de2006-12-13 00:35:09 -08002623 tty_ldisc_flush(tty);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002624
Alan Coxf34d7a52008-04-30 00:54:13 -07002625 tty_driver_flush_buffer(tty);
Alan Cox37bdfb02008-02-08 04:18:47 -08002626
Linus Torvalds1da177e2005-04-16 15:20:36 -07002627 read_lock(&tasklist_lock);
Eric W. Biederman652486f2006-03-28 16:11:02 -08002628 /* Kill the entire session */
Eric W. Biedermanab521dc2007-02-12 00:53:00 -08002629 do_each_pid_task(session, PIDTYPE_SID, p) {
Eric W. Biederman652486f2006-03-28 16:11:02 -08002630 printk(KERN_NOTICE "SAK: killed process %d"
Oleg Nesterov1b0f7ff2009-04-02 16:58:39 -07002631 " (%s): task_session(p)==tty->session\n",
Pavel Emelyanovba25f9d2007-10-18 23:40:40 -07002632 task_pid_nr(p), p->comm);
Eric W. Biederman652486f2006-03-28 16:11:02 -08002633 send_sig(SIGKILL, p, 1);
Eric W. Biedermanab521dc2007-02-12 00:53:00 -08002634 } while_each_pid_task(session, PIDTYPE_SID, p);
Eric W. Biederman652486f2006-03-28 16:11:02 -08002635 /* Now kill any processes that happen to have the
2636 * tty open.
2637 */
2638 do_each_thread(g, p) {
2639 if (p->signal->tty == tty) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002640 printk(KERN_NOTICE "SAK: killed process %d"
Oleg Nesterov1b0f7ff2009-04-02 16:58:39 -07002641 " (%s): task_session(p)==tty->session\n",
Pavel Emelyanovba25f9d2007-10-18 23:40:40 -07002642 task_pid_nr(p), p->comm);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002643 send_sig(SIGKILL, p, 1);
2644 continue;
2645 }
2646 task_lock(p);
2647 if (p->files) {
Dipankar Sarmaca99c1d2006-04-18 22:21:46 -07002648 /*
2649 * We don't take a ref to the file, so we must
2650 * hold ->file_lock instead.
2651 */
2652 spin_lock(&p->files->file_lock);
Dipankar Sarmabadf1662005-09-09 13:04:10 -07002653 fdt = files_fdtable(p->files);
Alan Cox37bdfb02008-02-08 04:18:47 -08002654 for (i = 0; i < fdt->max_fds; i++) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002655 filp = fcheck_files(p->files, i);
2656 if (!filp)
2657 continue;
2658 if (filp->f_op->read == tty_read &&
2659 filp->private_data == tty) {
2660 printk(KERN_NOTICE "SAK: killed process %d"
2661 " (%s): fd#%d opened to the tty\n",
Pavel Emelyanovba25f9d2007-10-18 23:40:40 -07002662 task_pid_nr(p), p->comm, i);
Eric W. Biederman20ac9432006-04-13 04:49:07 -06002663 force_sig(SIGKILL, p);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002664 break;
2665 }
2666 }
Dipankar Sarmaca99c1d2006-04-18 22:21:46 -07002667 spin_unlock(&p->files->file_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002668 }
2669 task_unlock(p);
Eric W. Biederman652486f2006-03-28 16:11:02 -08002670 } while_each_thread(g, p);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002671 read_unlock(&tasklist_lock);
2672#endif
2673}
2674
Eric W. Biederman8b6312f2007-02-10 01:44:34 -08002675static void do_SAK_work(struct work_struct *work)
2676{
2677 struct tty_struct *tty =
2678 container_of(work, struct tty_struct, SAK_work);
2679 __do_SAK(tty);
2680}
2681
Linus Torvalds1da177e2005-04-16 15:20:36 -07002682/*
2683 * The tq handling here is a little racy - tty->SAK_work may already be queued.
2684 * Fortunately we don't need to worry, because if ->SAK_work is already queued,
2685 * the values which we write to it will be identical to the values which it
2686 * already has. --akpm
2687 */
2688void do_SAK(struct tty_struct *tty)
2689{
2690 if (!tty)
2691 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002692 schedule_work(&tty->SAK_work);
2693}
2694
2695EXPORT_SYMBOL(do_SAK);
2696
Alan Coxaf9b8972006-08-27 01:24:01 -07002697/**
Alan Coxaf9b8972006-08-27 01:24:01 -07002698 * initialize_tty_struct
2699 * @tty: tty to initialize
2700 *
2701 * This subroutine initializes a tty structure that has been newly
2702 * allocated.
2703 *
2704 * Locking: none - tty in question must not be exposed at this point
Linus Torvalds1da177e2005-04-16 15:20:36 -07002705 */
Alan Coxaf9b8972006-08-27 01:24:01 -07002706
Alan Coxbf970ee2008-10-13 10:42:39 +01002707void initialize_tty_struct(struct tty_struct *tty,
2708 struct tty_driver *driver, int idx)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002709{
2710 memset(tty, 0, sizeof(struct tty_struct));
Alan Cox9c9f4de2008-10-13 10:37:26 +01002711 kref_init(&tty->kref);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002712 tty->magic = TTY_MAGIC;
Alan Cox01e1abb2008-07-22 11:16:55 +01002713 tty_ldisc_init(tty);
Eric W. Biedermanab521dc2007-02-12 00:53:00 -08002714 tty->session = NULL;
2715 tty->pgrp = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002716 tty->overrun_time = jiffies;
Alan Cox33f0f882006-01-09 20:54:13 -08002717 tty->buf.head = tty->buf.tail = NULL;
2718 tty_buffer_init(tty);
Arjan van de Ven5785c952006-09-29 02:00:43 -07002719 mutex_init(&tty->termios_mutex);
Alan Coxc65c9bc2009-06-11 12:50:12 +01002720 mutex_init(&tty->ldisc_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002721 init_waitqueue_head(&tty->write_wait);
2722 init_waitqueue_head(&tty->read_wait);
David Howells65f27f32006-11-22 14:55:48 +00002723 INIT_WORK(&tty->hangup_work, do_tty_hangup);
Ingo Molnar70522e12006-03-23 03:00:31 -08002724 mutex_init(&tty->atomic_read_lock);
2725 mutex_init(&tty->atomic_write_lock);
Joe Petersona88a69c2009-01-02 13:40:53 +00002726 mutex_init(&tty->output_lock);
2727 mutex_init(&tty->echo_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002728 spin_lock_init(&tty->read_lock);
Alan Cox04f378b2008-04-30 00:53:29 -07002729 spin_lock_init(&tty->ctrl_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002730 INIT_LIST_HEAD(&tty->tty_files);
Eric W. Biederman7f1f86a2007-02-13 14:38:58 -07002731 INIT_WORK(&tty->SAK_work, do_SAK_work);
Alan Coxbf970ee2008-10-13 10:42:39 +01002732
2733 tty->driver = driver;
2734 tty->ops = driver->ops;
2735 tty->index = idx;
2736 tty_line_name(driver, idx, tty->name);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002737}
2738
Alan Coxf34d7a52008-04-30 00:54:13 -07002739/**
2740 * tty_put_char - write one character to a tty
2741 * @tty: tty
2742 * @ch: character
2743 *
2744 * Write one byte to the tty using the provided put_char method
2745 * if present. Returns the number of characters successfully output.
2746 *
2747 * Note: the specific put_char operation in the driver layer may go
2748 * away soon. Don't call it directly, use this method
Linus Torvalds1da177e2005-04-16 15:20:36 -07002749 */
Alan Coxaf9b8972006-08-27 01:24:01 -07002750
Alan Coxf34d7a52008-04-30 00:54:13 -07002751int tty_put_char(struct tty_struct *tty, unsigned char ch)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002752{
Alan Coxf34d7a52008-04-30 00:54:13 -07002753 if (tty->ops->put_char)
2754 return tty->ops->put_char(tty, ch);
2755 return tty->ops->write(tty, &ch, 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002756}
Alan Coxf34d7a52008-04-30 00:54:13 -07002757EXPORT_SYMBOL_GPL(tty_put_char);
2758
Alan Coxd81ed102008-10-13 10:41:42 +01002759struct class *tty_class;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002760
2761/**
Alan Coxaf9b8972006-08-27 01:24:01 -07002762 * tty_register_device - register a tty device
2763 * @driver: the tty driver that describes the tty device
2764 * @index: the index in the tty driver for this tty device
2765 * @device: a struct device that is associated with this tty device.
2766 * This field is optional, if there is no known struct device
2767 * for this tty device it can be set to NULL safely.
Linus Torvalds1da177e2005-04-16 15:20:36 -07002768 *
Greg Kroah-Hartman01107d32006-08-07 22:19:37 -07002769 * Returns a pointer to the struct device for this tty device
2770 * (or ERR_PTR(-EFOO) on error).
Hansjoerg Lipp1cdcb6b2006-04-22 18:36:53 +02002771 *
Alan Coxaf9b8972006-08-27 01:24:01 -07002772 * This call is required to be made to register an individual tty device
2773 * if the tty driver's flags have the TTY_DRIVER_DYNAMIC_DEV bit set. If
2774 * that bit is not set, this function should not be called by a tty
2775 * driver.
2776 *
2777 * Locking: ??
Linus Torvalds1da177e2005-04-16 15:20:36 -07002778 */
Alan Coxaf9b8972006-08-27 01:24:01 -07002779
Greg Kroah-Hartman01107d32006-08-07 22:19:37 -07002780struct device *tty_register_device(struct tty_driver *driver, unsigned index,
2781 struct device *device)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002782{
2783 char name[64];
2784 dev_t dev = MKDEV(driver->major, driver->minor_start) + index;
2785
2786 if (index >= driver->num) {
2787 printk(KERN_ERR "Attempt to register invalid tty line number "
2788 " (%d).\n", index);
Hansjoerg Lipp1cdcb6b2006-04-22 18:36:53 +02002789 return ERR_PTR(-EINVAL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002790 }
2791
Linus Torvalds1da177e2005-04-16 15:20:36 -07002792 if (driver->type == TTY_DRIVER_TYPE_PTY)
2793 pty_line_name(driver, index, name);
2794 else
2795 tty_line_name(driver, index, name);
Hansjoerg Lipp1cdcb6b2006-04-22 18:36:53 +02002796
Greg Kroah-Hartman03457cd2008-07-21 20:03:34 -07002797 return device_create(tty_class, device, dev, NULL, name);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002798}
Alan Cox7d7b93c2008-10-13 10:42:09 +01002799EXPORT_SYMBOL(tty_register_device);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002800
2801/**
Alan Coxaf9b8972006-08-27 01:24:01 -07002802 * tty_unregister_device - unregister a tty device
2803 * @driver: the tty driver that describes the tty device
2804 * @index: the index in the tty driver for this tty device
Linus Torvalds1da177e2005-04-16 15:20:36 -07002805 *
Alan Coxaf9b8972006-08-27 01:24:01 -07002806 * If a tty device is registered with a call to tty_register_device() then
2807 * this function must be called when the tty device is gone.
2808 *
2809 * Locking: ??
Linus Torvalds1da177e2005-04-16 15:20:36 -07002810 */
Alan Coxaf9b8972006-08-27 01:24:01 -07002811
Linus Torvalds1da177e2005-04-16 15:20:36 -07002812void tty_unregister_device(struct tty_driver *driver, unsigned index)
2813{
Alan Cox37bdfb02008-02-08 04:18:47 -08002814 device_destroy(tty_class,
2815 MKDEV(driver->major, driver->minor_start) + index);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002816}
Linus Torvalds1da177e2005-04-16 15:20:36 -07002817EXPORT_SYMBOL(tty_unregister_device);
2818
2819struct tty_driver *alloc_tty_driver(int lines)
2820{
2821 struct tty_driver *driver;
2822
Jean Delvare506eb992007-07-15 23:40:14 -07002823 driver = kzalloc(sizeof(struct tty_driver), GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002824 if (driver) {
Alan Cox7d7b93c2008-10-13 10:42:09 +01002825 kref_init(&driver->kref);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002826 driver->magic = TTY_DRIVER_MAGIC;
2827 driver->num = lines;
2828 /* later we'll move allocation of tables here */
2829 }
2830 return driver;
2831}
Alan Cox7d7b93c2008-10-13 10:42:09 +01002832EXPORT_SYMBOL(alloc_tty_driver);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002833
Alan Cox7d7b93c2008-10-13 10:42:09 +01002834static void destruct_tty_driver(struct kref *kref)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002835{
Alan Cox7d7b93c2008-10-13 10:42:09 +01002836 struct tty_driver *driver = container_of(kref, struct tty_driver, kref);
2837 int i;
2838 struct ktermios *tp;
2839 void *p;
2840
2841 if (driver->flags & TTY_DRIVER_INSTALLED) {
2842 /*
2843 * Free the termios and termios_locked structures because
2844 * we don't want to get memory leaks when modular tty
2845 * drivers are removed from the kernel.
2846 */
2847 for (i = 0; i < driver->num; i++) {
2848 tp = driver->termios[i];
2849 if (tp) {
2850 driver->termios[i] = NULL;
2851 kfree(tp);
2852 }
Alan Cox7d7b93c2008-10-13 10:42:09 +01002853 if (!(driver->flags & TTY_DRIVER_DYNAMIC_DEV))
2854 tty_unregister_device(driver, i);
2855 }
2856 p = driver->ttys;
2857 proc_tty_unregister_driver(driver);
2858 driver->ttys = NULL;
Alan Coxfe6e29f2008-10-13 10:44:08 +01002859 driver->termios = NULL;
Alan Cox7d7b93c2008-10-13 10:42:09 +01002860 kfree(p);
2861 cdev_del(&driver->cdev);
2862 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002863 kfree(driver);
2864}
2865
Alan Cox7d7b93c2008-10-13 10:42:09 +01002866void tty_driver_kref_put(struct tty_driver *driver)
2867{
2868 kref_put(&driver->kref, destruct_tty_driver);
2869}
2870EXPORT_SYMBOL(tty_driver_kref_put);
2871
Jeff Dikeb68e31d2006-10-02 02:17:18 -07002872void tty_set_operations(struct tty_driver *driver,
2873 const struct tty_operations *op)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002874{
Alan Coxf34d7a52008-04-30 00:54:13 -07002875 driver->ops = op;
2876};
Linus Torvalds1da177e2005-04-16 15:20:36 -07002877EXPORT_SYMBOL(tty_set_operations);
2878
Alan Cox7d7b93c2008-10-13 10:42:09 +01002879void put_tty_driver(struct tty_driver *d)
2880{
2881 tty_driver_kref_put(d);
2882}
2883EXPORT_SYMBOL(put_tty_driver);
2884
Linus Torvalds1da177e2005-04-16 15:20:36 -07002885/*
2886 * Called by a tty driver to register itself.
2887 */
2888int tty_register_driver(struct tty_driver *driver)
2889{
2890 int error;
Alan Cox37bdfb02008-02-08 04:18:47 -08002891 int i;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002892 dev_t dev;
2893 void **p = NULL;
2894
Andy Whitcroft543691a62007-05-06 14:49:33 -07002895 if (!(driver->flags & TTY_DRIVER_DEVPTS_MEM) && driver->num) {
Alan Coxfe6e29f2008-10-13 10:44:08 +01002896 p = kzalloc(driver->num * 2 * sizeof(void *), GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002897 if (!p)
2898 return -ENOMEM;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002899 }
2900
2901 if (!driver->major) {
Alan Cox37bdfb02008-02-08 04:18:47 -08002902 error = alloc_chrdev_region(&dev, driver->minor_start,
2903 driver->num, driver->name);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002904 if (!error) {
2905 driver->major = MAJOR(dev);
2906 driver->minor_start = MINOR(dev);
2907 }
2908 } else {
2909 dev = MKDEV(driver->major, driver->minor_start);
Geert Uytterhoevene5717c42007-02-20 15:45:21 +01002910 error = register_chrdev_region(dev, driver->num, driver->name);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002911 }
2912 if (error < 0) {
2913 kfree(p);
2914 return error;
2915 }
2916
2917 if (p) {
2918 driver->ttys = (struct tty_struct **)p;
Alan Coxedc6afc2006-12-08 02:38:44 -08002919 driver->termios = (struct ktermios **)(p + driver->num);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002920 } else {
2921 driver->ttys = NULL;
2922 driver->termios = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002923 }
2924
2925 cdev_init(&driver->cdev, &tty_fops);
2926 driver->cdev.owner = driver->owner;
2927 error = cdev_add(&driver->cdev, dev, driver->num);
2928 if (error) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002929 unregister_chrdev_region(dev, driver->num);
2930 driver->ttys = NULL;
Alan Coxfe6e29f2008-10-13 10:44:08 +01002931 driver->termios = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002932 kfree(p);
2933 return error;
2934 }
2935
Alexey Dobriyanca509f62007-05-08 00:27:12 -07002936 mutex_lock(&tty_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002937 list_add(&driver->tty_drivers, &tty_drivers);
Alexey Dobriyanca509f62007-05-08 00:27:12 -07002938 mutex_unlock(&tty_mutex);
Alan Cox37bdfb02008-02-08 04:18:47 -08002939
2940 if (!(driver->flags & TTY_DRIVER_DYNAMIC_DEV)) {
2941 for (i = 0; i < driver->num; i++)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002942 tty_register_device(driver, i, NULL);
2943 }
2944 proc_tty_register_driver(driver);
Alan Cox7d7b93c2008-10-13 10:42:09 +01002945 driver->flags |= TTY_DRIVER_INSTALLED;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002946 return 0;
2947}
2948
2949EXPORT_SYMBOL(tty_register_driver);
2950
2951/*
2952 * Called by a tty driver to unregister itself.
2953 */
2954int tty_unregister_driver(struct tty_driver *driver)
2955{
Alan Cox7d7b93c2008-10-13 10:42:09 +01002956#if 0
2957 /* FIXME */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002958 if (driver->refcount)
2959 return -EBUSY;
Alan Cox7d7b93c2008-10-13 10:42:09 +01002960#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07002961 unregister_chrdev_region(MKDEV(driver->major, driver->minor_start),
2962 driver->num);
Alexey Dobriyanca509f62007-05-08 00:27:12 -07002963 mutex_lock(&tty_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002964 list_del(&driver->tty_drivers);
Alexey Dobriyanca509f62007-05-08 00:27:12 -07002965 mutex_unlock(&tty_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002966 return 0;
2967}
Alan Cox7d7b93c2008-10-13 10:42:09 +01002968
Linus Torvalds1da177e2005-04-16 15:20:36 -07002969EXPORT_SYMBOL(tty_unregister_driver);
2970
Peter Zijlstra24ec8392006-12-08 02:36:04 -08002971dev_t tty_devnum(struct tty_struct *tty)
2972{
2973 return MKDEV(tty->driver->major, tty->driver->minor_start) + tty->index;
2974}
2975EXPORT_SYMBOL(tty_devnum);
2976
2977void proc_clear_tty(struct task_struct *p)
2978{
Arjan van de Ven7c3b1dc2008-10-15 10:52:34 +01002979 unsigned long flags;
Alan Cox9c9f4de2008-10-13 10:37:26 +01002980 struct tty_struct *tty;
Arjan van de Ven7c3b1dc2008-10-15 10:52:34 +01002981 spin_lock_irqsave(&p->sighand->siglock, flags);
Alan Cox9c9f4de2008-10-13 10:37:26 +01002982 tty = p->signal->tty;
Peter Zijlstra24ec8392006-12-08 02:36:04 -08002983 p->signal->tty = NULL;
Arjan van de Ven7c3b1dc2008-10-15 10:52:34 +01002984 spin_unlock_irqrestore(&p->sighand->siglock, flags);
Alan Cox9c9f4de2008-10-13 10:37:26 +01002985 tty_kref_put(tty);
Peter Zijlstra24ec8392006-12-08 02:36:04 -08002986}
Peter Zijlstra24ec8392006-12-08 02:36:04 -08002987
Alan Cox47f86832008-04-30 00:53:30 -07002988/* Called under the sighand lock */
2989
Eric W. Biederman2a65f1d2007-05-08 00:26:53 -07002990static void __proc_set_tty(struct task_struct *tsk, struct tty_struct *tty)
Peter Zijlstra24ec8392006-12-08 02:36:04 -08002991{
2992 if (tty) {
Alan Cox47f86832008-04-30 00:53:30 -07002993 unsigned long flags;
2994 /* We should not have a session or pgrp to put here but.... */
2995 spin_lock_irqsave(&tty->ctrl_lock, flags);
Eric W. Biedermand9c1e9a2007-03-18 12:45:44 -06002996 put_pid(tty->session);
2997 put_pid(tty->pgrp);
Eric W. Biedermanab521dc2007-02-12 00:53:00 -08002998 tty->pgrp = get_pid(task_pgrp(tsk));
Alan Cox47f86832008-04-30 00:53:30 -07002999 spin_unlock_irqrestore(&tty->ctrl_lock, flags);
3000 tty->session = get_pid(task_session(tsk));
Alan Cox9c9f4de2008-10-13 10:37:26 +01003001 if (tsk->signal->tty) {
3002 printk(KERN_DEBUG "tty not NULL!!\n");
3003 tty_kref_put(tsk->signal->tty);
3004 }
Peter Zijlstra24ec8392006-12-08 02:36:04 -08003005 }
Eric W. Biederman2a65f1d2007-05-08 00:26:53 -07003006 put_pid(tsk->signal->tty_old_pgrp);
Alan Cox9c9f4de2008-10-13 10:37:26 +01003007 tsk->signal->tty = tty_kref_get(tty);
Eric W. Biedermanab521dc2007-02-12 00:53:00 -08003008 tsk->signal->tty_old_pgrp = NULL;
Peter Zijlstra24ec8392006-12-08 02:36:04 -08003009}
3010
Eric W. Biederman98a27ba2007-05-08 00:26:56 -07003011static void proc_set_tty(struct task_struct *tsk, struct tty_struct *tty)
Peter Zijlstra24ec8392006-12-08 02:36:04 -08003012{
3013 spin_lock_irq(&tsk->sighand->siglock);
Eric W. Biederman2a65f1d2007-05-08 00:26:53 -07003014 __proc_set_tty(tsk, tty);
Peter Zijlstra24ec8392006-12-08 02:36:04 -08003015 spin_unlock_irq(&tsk->sighand->siglock);
3016}
3017
3018struct tty_struct *get_current_tty(void)
3019{
3020 struct tty_struct *tty;
Alan Cox934e6eb2008-10-13 10:40:43 +01003021 unsigned long flags;
3022
3023 spin_lock_irqsave(&current->sighand->siglock, flags);
Alan Cox452a00d2008-10-13 10:39:13 +01003024 tty = tty_kref_get(current->signal->tty);
Alan Cox934e6eb2008-10-13 10:40:43 +01003025 spin_unlock_irqrestore(&current->sighand->siglock, flags);
Peter Zijlstra24ec8392006-12-08 02:36:04 -08003026 return tty;
3027}
Heiko Carstensa311f742006-12-13 00:33:41 -08003028EXPORT_SYMBOL_GPL(get_current_tty);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003029
Alan Coxd81ed102008-10-13 10:41:42 +01003030void tty_default_fops(struct file_operations *fops)
3031{
3032 *fops = tty_fops;
3033}
3034
Linus Torvalds1da177e2005-04-16 15:20:36 -07003035/*
3036 * Initialize the console device. This is called *early*, so
3037 * we can't necessarily depend on lots of kernel help here.
3038 * Just do some early initializations, and do the complex setup
3039 * later.
3040 */
3041void __init console_init(void)
3042{
3043 initcall_t *call;
3044
3045 /* Setup the default TTY line discipline. */
Alan Cox01e1abb2008-07-22 11:16:55 +01003046 tty_ldisc_begin();
Linus Torvalds1da177e2005-04-16 15:20:36 -07003047
3048 /*
Alan Cox37bdfb02008-02-08 04:18:47 -08003049 * set up the console device so that later boot sequences can
Linus Torvalds1da177e2005-04-16 15:20:36 -07003050 * inform about problems etc..
3051 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07003052 call = __con_initcall_start;
3053 while (call < __con_initcall_end) {
3054 (*call)();
3055 call++;
3056 }
3057}
3058
Linus Torvalds1da177e2005-04-16 15:20:36 -07003059static int __init tty_class_init(void)
3060{
gregkh@suse.de7fe845d2005-03-15 14:23:15 -08003061 tty_class = class_create(THIS_MODULE, "tty");
Linus Torvalds1da177e2005-04-16 15:20:36 -07003062 if (IS_ERR(tty_class))
3063 return PTR_ERR(tty_class);
3064 return 0;
3065}
3066
3067postcore_initcall(tty_class_init);
3068
3069/* 3/2004 jmc: why do these devices exist? */
3070
3071static struct cdev tty_cdev, console_cdev;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003072
3073/*
3074 * Ok, now we can initialize the rest of the tty devices and can count
3075 * on memory allocations, interrupts etc..
3076 */
3077static int __init tty_init(void)
3078{
3079 cdev_init(&tty_cdev, &tty_fops);
3080 if (cdev_add(&tty_cdev, MKDEV(TTYAUX_MAJOR, 0), 1) ||
3081 register_chrdev_region(MKDEV(TTYAUX_MAJOR, 0), 1, "/dev/tty") < 0)
3082 panic("Couldn't register /dev/tty driver\n");
Alan Coxd81ed102008-10-13 10:41:42 +01003083 device_create(tty_class, NULL, MKDEV(TTYAUX_MAJOR, 0), NULL,
Greg Kroah-Hartman47aa5792008-05-21 12:52:33 -07003084 "tty");
Linus Torvalds1da177e2005-04-16 15:20:36 -07003085
3086 cdev_init(&console_cdev, &console_fops);
3087 if (cdev_add(&console_cdev, MKDEV(TTYAUX_MAJOR, 1), 1) ||
3088 register_chrdev_region(MKDEV(TTYAUX_MAJOR, 1), 1, "/dev/console") < 0)
3089 panic("Couldn't register /dev/console driver\n");
Alan Coxd81ed102008-10-13 10:41:42 +01003090 device_create(tty_class, NULL, MKDEV(TTYAUX_MAJOR, 1), NULL,
Greg Kroah-Hartman47aa5792008-05-21 12:52:33 -07003091 "console");
Linus Torvalds1da177e2005-04-16 15:20:36 -07003092
Linus Torvalds1da177e2005-04-16 15:20:36 -07003093#ifdef CONFIG_VT
Alan Coxd81ed102008-10-13 10:41:42 +01003094 vty_init(&console_fops);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003095#endif
3096 return 0;
3097}
3098module_init(tty_init);