blob: 6556f7452ba6f960a9f083068f1674164c93ff11 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
Linus Torvalds1da177e2005-04-16 15:20:36 -07002 * Copyright (C) 1991, 1992 Linus Torvalds
3 */
4
5/*
6 * 'tty_io.c' gives an orthogonal feeling to tty's, be they consoles
7 * or rs-channels. It also implements echoing, cooked mode etc.
8 *
9 * Kill-line thanks to John T Kohl, who also corrected VMIN = VTIME = 0.
10 *
11 * Modified by Theodore Ts'o, 9/14/92, to dynamically allocate the
12 * tty_struct and tty_queue structures. Previously there was an array
13 * of 256 tty_struct's which was statically allocated, and the
14 * tty_queue structures were allocated at boot time. Both are now
15 * dynamically allocated only when the tty is open.
16 *
17 * Also restructured routines so that there is more of a separation
18 * between the high-level tty routines (tty_io.c and tty_ioctl.c) and
19 * the low-level tty routines (serial.c, pty.c, console.c). This
Alan Cox37bdfb02008-02-08 04:18:47 -080020 * makes for cleaner and more compact code. -TYT, 9/17/92
Linus Torvalds1da177e2005-04-16 15:20:36 -070021 *
22 * Modified by Fred N. van Kempen, 01/29/93, to add line disciplines
23 * which can be dynamically activated and de-activated by the line
24 * discipline handling modules (like SLIP).
25 *
26 * NOTE: pay no attention to the line discipline code (yet); its
27 * interface is still subject to change in this version...
28 * -- TYT, 1/31/92
29 *
30 * Added functionality to the OPOST tty handling. No delays, but all
31 * other bits should be there.
32 * -- Nick Holloway <alfie@dcs.warwick.ac.uk>, 27th May 1993.
33 *
34 * Rewrote canonical mode and added more termios flags.
35 * -- julian@uhunix.uhcc.hawaii.edu (J. Cowley), 13Jan94
36 *
37 * Reorganized FASYNC support so mouse code can share it.
38 * -- ctm@ardi.com, 9Sep95
39 *
40 * New TIOCLINUX variants added.
41 * -- mj@k332.feld.cvut.cz, 19-Nov-95
Alan Cox37bdfb02008-02-08 04:18:47 -080042 *
Linus Torvalds1da177e2005-04-16 15:20:36 -070043 * Restrict vt switching via ioctl()
44 * -- grif@cs.ucr.edu, 5-Dec-95
45 *
46 * Move console and virtual terminal code to more appropriate files,
47 * implement CONFIG_VT and generalize console device interface.
48 * -- Marko Kohtala <Marko.Kohtala@hut.fi>, March 97
49 *
Alan Coxd81ed102008-10-13 10:41:42 +010050 * Rewrote tty_init_dev and tty_release_dev to eliminate races.
Linus Torvalds1da177e2005-04-16 15:20:36 -070051 * -- Bill Hawes <whawes@star.net>, June 97
52 *
53 * Added devfs support.
54 * -- C. Scott Ananian <cananian@alumni.princeton.edu>, 13-Jan-1998
55 *
56 * Added support for a Unix98-style ptmx device.
57 * -- C. Scott Ananian <cananian@alumni.princeton.edu>, 14-Jan-1998
58 *
59 * Reduced memory usage for older ARM systems
60 * -- Russell King <rmk@arm.linux.org.uk>
61 *
62 * Move do_SAK() into process context. Less stack use in devfs functions.
Alan Cox37bdfb02008-02-08 04:18:47 -080063 * alloc_tty_struct() always uses kmalloc()
64 * -- Andrew Morton <andrewm@uow.edu.eu> 17Mar01
Linus Torvalds1da177e2005-04-16 15:20:36 -070065 */
66
Linus Torvalds1da177e2005-04-16 15:20:36 -070067#include <linux/types.h>
68#include <linux/major.h>
69#include <linux/errno.h>
70#include <linux/signal.h>
71#include <linux/fcntl.h>
72#include <linux/sched.h>
73#include <linux/interrupt.h>
74#include <linux/tty.h>
75#include <linux/tty_driver.h>
76#include <linux/tty_flip.h>
77#include <linux/devpts_fs.h>
78#include <linux/file.h>
Al Viro9f3acc32008-04-24 07:44:08 -040079#include <linux/fdtable.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070080#include <linux/console.h>
81#include <linux/timer.h>
82#include <linux/ctype.h>
83#include <linux/kd.h>
84#include <linux/mm.h>
85#include <linux/string.h>
86#include <linux/slab.h>
87#include <linux/poll.h>
88#include <linux/proc_fs.h>
89#include <linux/init.h>
90#include <linux/module.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070091#include <linux/device.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070092#include <linux/wait.h>
93#include <linux/bitops.h>
Domen Puncerb20f3ae2005-06-25 14:58:42 -070094#include <linux/delay.h>
Alan Coxa352def2008-07-16 21:53:12 +010095#include <linux/seq_file.h>
Alan Coxd281da72010-09-16 18:21:24 +010096#include <linux/serial.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070097
Alan Coxa352def2008-07-16 21:53:12 +010098#include <linux/uaccess.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070099#include <asm/system.h>
100
101#include <linux/kbd_kern.h>
102#include <linux/vt_kern.h>
103#include <linux/selection.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -0700104
105#include <linux/kmod.h>
Pavel Emelyanovb4888932007-10-18 23:40:14 -0700106#include <linux/nsproxy.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -0700107
108#undef TTY_DEBUG_HANGUP
109
110#define TTY_PARANOIA_CHECK 1
111#define CHECK_TTY_COUNT 1
112
Alan Coxedc6afc2006-12-08 02:38:44 -0800113struct ktermios tty_std_termios = { /* for the benefit of tty drivers */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700114 .c_iflag = ICRNL | IXON,
115 .c_oflag = OPOST | ONLCR,
116 .c_cflag = B38400 | CS8 | CREAD | HUPCL,
117 .c_lflag = ISIG | ICANON | ECHO | ECHOE | ECHOK |
118 ECHOCTL | ECHOKE | IEXTEN,
Alan Coxedc6afc2006-12-08 02:38:44 -0800119 .c_cc = INIT_C_CC,
120 .c_ispeed = 38400,
121 .c_ospeed = 38400
Linus Torvalds1da177e2005-04-16 15:20:36 -0700122};
123
124EXPORT_SYMBOL(tty_std_termios);
125
126/* This list gets poked at by procfs and various bits of boot up code. This
127 could do with some rationalisation such as pulling the tty proc function
128 into this file */
Alan Cox37bdfb02008-02-08 04:18:47 -0800129
Linus Torvalds1da177e2005-04-16 15:20:36 -0700130LIST_HEAD(tty_drivers); /* linked list of tty drivers */
131
Peter Zijlstra24ec8392006-12-08 02:36:04 -0800132/* Mutex to protect creating and releasing a tty. This is shared with
Linus Torvalds1da177e2005-04-16 15:20:36 -0700133 vt.c for deeply disgusting hack reasons */
Ingo Molnar70522e12006-03-23 03:00:31 -0800134DEFINE_MUTEX(tty_mutex);
Alan Coxde2a84f2006-09-29 02:00:57 -0700135EXPORT_SYMBOL(tty_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700136
Nick Pigginee2ffa02010-08-18 04:37:35 +1000137/* Spinlock to protect the tty->tty_files list */
138DEFINE_SPINLOCK(tty_files_lock);
139
Linus Torvalds1da177e2005-04-16 15:20:36 -0700140static ssize_t tty_read(struct file *, char __user *, size_t, loff_t *);
141static ssize_t tty_write(struct file *, const char __user *, size_t, loff_t *);
Alan Cox37bdfb02008-02-08 04:18:47 -0800142ssize_t redirected_tty_write(struct file *, const char __user *,
143 size_t, loff_t *);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700144static unsigned int tty_poll(struct file *, poll_table *);
145static int tty_open(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
Arnd Bergmannec79d602010-06-01 22:53:01 +0200153static int __tty_fasync(int fd, struct file *filp, int on);
Alan Cox37bdfb02008-02-08 04:18:47 -0800154static int tty_fasync(int fd, struct file *filp, int on);
Christoph Hellwigd5698c22007-02-10 01:46:46 -0800155static void release_tty(struct tty_struct *tty, int idx);
Eric W. Biederman2a65f1d2007-05-08 00:26:53 -0700156static void __proc_set_tty(struct task_struct *tsk, struct tty_struct *tty);
Eric W. Biederman98a27ba2007-05-08 00:26:56 -0700157static void proc_set_tty(struct task_struct *tsk, struct tty_struct *tty);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700158
Alan Coxaf9b8972006-08-27 01:24:01 -0700159/**
160 * alloc_tty_struct - allocate a tty object
161 *
162 * Return a new empty tty structure. The data fields have not
163 * been initialized in any way but has been zeroed
164 *
165 * Locking: none
Alan Coxaf9b8972006-08-27 01:24:01 -0700166 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700167
Alan Coxbf970ee2008-10-13 10:42:39 +0100168struct tty_struct *alloc_tty_struct(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700169{
Alan Cox1266b1e2006-09-29 02:00:40 -0700170 return kzalloc(sizeof(struct tty_struct), GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700171}
172
Alan Coxaf9b8972006-08-27 01:24:01 -0700173/**
174 * free_tty_struct - free a disused tty
175 * @tty: tty struct to free
176 *
177 * Free the write buffers, tty queue and tty memory itself.
178 *
179 * Locking: none. Must be called after tty is definitely unused
180 */
181
Alan Coxbf970ee2008-10-13 10:42:39 +0100182void free_tty_struct(struct tty_struct *tty)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700183{
Dmitry Eremin-Solenikov30004ac2010-08-09 18:22:49 +0400184 if (tty->dev)
185 put_device(tty->dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700186 kfree(tty->write_buf);
Alan Cox33f0f882006-01-09 20:54:13 -0800187 tty_buffer_free_all(tty);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700188 kfree(tty);
189}
190
Nick Piggind996b622010-08-18 04:37:36 +1000191static inline struct tty_struct *file_tty(struct file *file)
192{
193 return ((struct tty_file_private *)file->private_data)->tty;
194}
195
196/* Associate a new file with the tty structure */
Pekka Enbergf573bd12010-08-24 07:48:34 +0300197int tty_add_file(struct tty_struct *tty, struct file *file)
Nick Piggind996b622010-08-18 04:37:36 +1000198{
199 struct tty_file_private *priv;
200
Pekka Enbergf573bd12010-08-24 07:48:34 +0300201 priv = kmalloc(sizeof(*priv), GFP_KERNEL);
202 if (!priv)
203 return -ENOMEM;
Nick Piggind996b622010-08-18 04:37:36 +1000204
205 priv->tty = tty;
206 priv->file = file;
207 file->private_data = priv;
208
209 spin_lock(&tty_files_lock);
210 list_add(&priv->list, &tty->tty_files);
211 spin_unlock(&tty_files_lock);
Pekka Enbergf573bd12010-08-24 07:48:34 +0300212
213 return 0;
Nick Piggind996b622010-08-18 04:37:36 +1000214}
215
216/* Delete file from its tty */
217void tty_del_file(struct file *file)
218{
219 struct tty_file_private *priv = file->private_data;
220
221 spin_lock(&tty_files_lock);
222 list_del(&priv->list);
223 spin_unlock(&tty_files_lock);
224 file->private_data = NULL;
225 kfree(priv);
226}
227
228
Linus Torvalds1da177e2005-04-16 15:20:36 -0700229#define TTY_NUMBER(tty) ((tty)->index + (tty)->driver->name_base)
230
Alan Coxaf9b8972006-08-27 01:24:01 -0700231/**
232 * tty_name - return tty naming
233 * @tty: tty structure
234 * @buf: buffer for output
235 *
236 * Convert a tty structure into a name. The name reflects the kernel
237 * naming policy and if udev is in use may not reflect user space
238 *
239 * Locking: none
240 */
241
Linus Torvalds1da177e2005-04-16 15:20:36 -0700242char *tty_name(struct tty_struct *tty, char *buf)
243{
244 if (!tty) /* Hmm. NULL pointer. That's fun. */
245 strcpy(buf, "NULL tty");
246 else
247 strcpy(buf, tty->name);
248 return buf;
249}
250
251EXPORT_SYMBOL(tty_name);
252
Andrew Mortond769a662005-05-05 16:15:50 -0700253int tty_paranoia_check(struct tty_struct *tty, struct inode *inode,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700254 const char *routine)
255{
256#ifdef TTY_PARANOIA_CHECK
257 if (!tty) {
258 printk(KERN_WARNING
259 "null TTY for (%d:%d) in %s\n",
260 imajor(inode), iminor(inode), routine);
261 return 1;
262 }
263 if (tty->magic != TTY_MAGIC) {
264 printk(KERN_WARNING
265 "bad magic number for tty struct (%d:%d) in %s\n",
266 imajor(inode), iminor(inode), routine);
267 return 1;
268 }
269#endif
270 return 0;
271}
272
273static int check_tty_count(struct tty_struct *tty, const char *routine)
274{
275#ifdef CHECK_TTY_COUNT
276 struct list_head *p;
277 int count = 0;
Alan Cox37bdfb02008-02-08 04:18:47 -0800278
Nick Pigginee2ffa02010-08-18 04:37:35 +1000279 spin_lock(&tty_files_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700280 list_for_each(p, &tty->tty_files) {
281 count++;
282 }
Nick Pigginee2ffa02010-08-18 04:37:35 +1000283 spin_unlock(&tty_files_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700284 if (tty->driver->type == TTY_DRIVER_TYPE_PTY &&
285 tty->driver->subtype == PTY_TYPE_SLAVE &&
286 tty->link && tty->link->count)
287 count++;
288 if (tty->count != count) {
289 printk(KERN_WARNING "Warning: dev (%s) tty->count(%d) "
290 "!= #fd's(%d) in %s\n",
291 tty->name, tty->count, count, routine);
292 return count;
Peter Zijlstra24ec8392006-12-08 02:36:04 -0800293 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700294#endif
295 return 0;
296}
297
Alan Coxaf9b8972006-08-27 01:24:01 -0700298/**
Alan Coxaf9b8972006-08-27 01:24:01 -0700299 * get_tty_driver - find device of a tty
300 * @dev_t: device identifier
301 * @index: returns the index of the tty
302 *
303 * This routine returns a tty driver structure, given a device number
304 * and also passes back the index number.
305 *
306 * Locking: caller must hold tty_mutex
Linus Torvalds1da177e2005-04-16 15:20:36 -0700307 */
Alan Coxaf9b8972006-08-27 01:24:01 -0700308
Linus Torvalds1da177e2005-04-16 15:20:36 -0700309static struct tty_driver *get_tty_driver(dev_t device, int *index)
310{
311 struct tty_driver *p;
312
313 list_for_each_entry(p, &tty_drivers, tty_drivers) {
314 dev_t base = MKDEV(p->major, p->minor_start);
315 if (device < base || device >= base + p->num)
316 continue;
317 *index = device - base;
Alan Cox7d7b93c2008-10-13 10:42:09 +0100318 return tty_driver_kref_get(p);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700319 }
320 return NULL;
321}
322
Jason Wesself2d937f2008-04-17 20:05:37 +0200323#ifdef CONFIG_CONSOLE_POLL
324
325/**
326 * tty_find_polling_driver - find device of a polled tty
327 * @name: name string to match
328 * @line: pointer to resulting tty line nr
329 *
330 * This routine returns a tty driver structure, given a name
331 * and the condition that the tty driver is capable of polled
332 * operation.
333 */
334struct tty_driver *tty_find_polling_driver(char *name, int *line)
335{
336 struct tty_driver *p, *res = NULL;
337 int tty_line = 0;
Jason Wessel0dca0fd2008-09-26 10:36:42 -0500338 int len;
Alan Cox5f0878a2009-06-11 12:46:41 +0100339 char *str, *stp;
Jason Wesself2d937f2008-04-17 20:05:37 +0200340
Jason Wessel0dca0fd2008-09-26 10:36:42 -0500341 for (str = name; *str; str++)
342 if ((*str >= '0' && *str <= '9') || *str == ',')
343 break;
344 if (!*str)
345 return NULL;
346
347 len = str - name;
348 tty_line = simple_strtoul(str, &str, 10);
349
Jason Wesself2d937f2008-04-17 20:05:37 +0200350 mutex_lock(&tty_mutex);
351 /* Search through the tty devices to look for a match */
352 list_for_each_entry(p, &tty_drivers, tty_drivers) {
Jason Wessel0dca0fd2008-09-26 10:36:42 -0500353 if (strncmp(name, p->name, len) != 0)
354 continue;
Alan Cox5f0878a2009-06-11 12:46:41 +0100355 stp = str;
356 if (*stp == ',')
357 stp++;
358 if (*stp == '\0')
359 stp = NULL;
Jason Wesself2d937f2008-04-17 20:05:37 +0200360
Nathael Pajani6eb68d62010-09-02 16:06:16 +0200361 if (tty_line >= 0 && tty_line < p->num && p->ops &&
Alan Cox5f0878a2009-06-11 12:46:41 +0100362 p->ops->poll_init && !p->ops->poll_init(p, tty_line, stp)) {
Alan Cox7d7b93c2008-10-13 10:42:09 +0100363 res = tty_driver_kref_get(p);
Jason Wesself2d937f2008-04-17 20:05:37 +0200364 *line = tty_line;
365 break;
366 }
367 }
368 mutex_unlock(&tty_mutex);
369
370 return res;
371}
372EXPORT_SYMBOL_GPL(tty_find_polling_driver);
373#endif
374
Alan Coxaf9b8972006-08-27 01:24:01 -0700375/**
376 * tty_check_change - check for POSIX terminal changes
377 * @tty: tty to check
378 *
379 * If we try to write to, or set the state of, a terminal and we're
380 * not in the foreground, send a SIGTTOU. If the signal is blocked or
381 * ignored, go ahead and perform the operation. (POSIX 7.2)
382 *
Alan Cox978e5952008-04-30 00:53:59 -0700383 * Locking: ctrl_lock
Linus Torvalds1da177e2005-04-16 15:20:36 -0700384 */
Alan Coxaf9b8972006-08-27 01:24:01 -0700385
Alan Cox37bdfb02008-02-08 04:18:47 -0800386int tty_check_change(struct tty_struct *tty)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700387{
Alan Cox47f86832008-04-30 00:53:30 -0700388 unsigned long flags;
389 int ret = 0;
390
Linus Torvalds1da177e2005-04-16 15:20:36 -0700391 if (current->signal->tty != tty)
392 return 0;
Alan Cox47f86832008-04-30 00:53:30 -0700393
394 spin_lock_irqsave(&tty->ctrl_lock, flags);
395
Eric W. Biedermanab521dc2007-02-12 00:53:00 -0800396 if (!tty->pgrp) {
397 printk(KERN_WARNING "tty_check_change: tty->pgrp == NULL!\n");
Andrew Morton9ffee4c2008-05-14 16:05:58 -0700398 goto out_unlock;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700399 }
Eric W. Biedermanab521dc2007-02-12 00:53:00 -0800400 if (task_pgrp(current) == tty->pgrp)
Andrew Morton9ffee4c2008-05-14 16:05:58 -0700401 goto out_unlock;
402 spin_unlock_irqrestore(&tty->ctrl_lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700403 if (is_ignored(SIGTTOU))
Alan Cox47f86832008-04-30 00:53:30 -0700404 goto out;
405 if (is_current_pgrp_orphaned()) {
406 ret = -EIO;
407 goto out;
408 }
Oleg Nesterov040b6362007-06-01 00:46:53 -0700409 kill_pgrp(task_pgrp(current), SIGTTOU, 1);
410 set_thread_flag(TIF_SIGPENDING);
Alan Cox47f86832008-04-30 00:53:30 -0700411 ret = -ERESTARTSYS;
412out:
Andrew Morton9ffee4c2008-05-14 16:05:58 -0700413 return ret;
414out_unlock:
Alan Cox47f86832008-04-30 00:53:30 -0700415 spin_unlock_irqrestore(&tty->ctrl_lock, flags);
416 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700417}
418
419EXPORT_SYMBOL(tty_check_change);
420
Alan Cox37bdfb02008-02-08 04:18:47 -0800421static ssize_t hung_up_tty_read(struct file *file, char __user *buf,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700422 size_t count, loff_t *ppos)
423{
424 return 0;
425}
426
Alan Cox37bdfb02008-02-08 04:18:47 -0800427static ssize_t hung_up_tty_write(struct file *file, const char __user *buf,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700428 size_t count, loff_t *ppos)
429{
430 return -EIO;
431}
432
433/* No kernel lock held - none needed ;) */
Alan Cox37bdfb02008-02-08 04:18:47 -0800434static unsigned int hung_up_tty_poll(struct file *filp, poll_table *wait)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700435{
436 return POLLIN | POLLOUT | POLLERR | POLLHUP | POLLRDNORM | POLLWRNORM;
437}
438
Alan Cox04f378b2008-04-30 00:53:29 -0700439static long hung_up_tty_ioctl(struct file *file, unsigned int cmd,
440 unsigned long arg)
Paul Fulghum38ad2ed2007-06-16 10:15:55 -0700441{
442 return cmd == TIOCSPGRP ? -ENOTTY : -EIO;
443}
444
Alan Cox37bdfb02008-02-08 04:18:47 -0800445static long hung_up_tty_compat_ioctl(struct file *file,
Paul Fulghum38ad2ed2007-06-16 10:15:55 -0700446 unsigned int cmd, unsigned long arg)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700447{
448 return cmd == TIOCSPGRP ? -ENOTTY : -EIO;
449}
450
Arjan van de Ven62322d22006-07-03 00:24:21 -0700451static const struct file_operations tty_fops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700452 .llseek = no_llseek,
453 .read = tty_read,
454 .write = tty_write,
455 .poll = tty_poll,
Alan Cox04f378b2008-04-30 00:53:29 -0700456 .unlocked_ioctl = tty_ioctl,
Paul Fulghume10cc1d2007-05-10 22:22:50 -0700457 .compat_ioctl = tty_compat_ioctl,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700458 .open = tty_open,
459 .release = tty_release,
460 .fasync = tty_fasync,
461};
462
Arjan van de Ven62322d22006-07-03 00:24:21 -0700463static const struct file_operations console_fops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700464 .llseek = no_llseek,
465 .read = tty_read,
466 .write = redirected_tty_write,
467 .poll = tty_poll,
Alan Cox04f378b2008-04-30 00:53:29 -0700468 .unlocked_ioctl = tty_ioctl,
Paul Fulghume10cc1d2007-05-10 22:22:50 -0700469 .compat_ioctl = tty_compat_ioctl,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700470 .open = tty_open,
471 .release = tty_release,
472 .fasync = tty_fasync,
473};
474
Arjan van de Ven62322d22006-07-03 00:24:21 -0700475static const struct file_operations hung_up_tty_fops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700476 .llseek = no_llseek,
477 .read = hung_up_tty_read,
478 .write = hung_up_tty_write,
479 .poll = hung_up_tty_poll,
Alan Cox04f378b2008-04-30 00:53:29 -0700480 .unlocked_ioctl = hung_up_tty_ioctl,
Paul Fulghum38ad2ed2007-06-16 10:15:55 -0700481 .compat_ioctl = hung_up_tty_compat_ioctl,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700482 .release = tty_release,
483};
484
485static DEFINE_SPINLOCK(redirect_lock);
486static struct file *redirect;
487
488/**
489 * tty_wakeup - request more data
490 * @tty: terminal
491 *
492 * Internal and external helper for wakeups of tty. This function
493 * informs the line discipline if present that the driver is ready
494 * to receive more output data.
495 */
Alan Cox37bdfb02008-02-08 04:18:47 -0800496
Linus Torvalds1da177e2005-04-16 15:20:36 -0700497void tty_wakeup(struct tty_struct *tty)
498{
499 struct tty_ldisc *ld;
Alan Cox37bdfb02008-02-08 04:18:47 -0800500
Linus Torvalds1da177e2005-04-16 15:20:36 -0700501 if (test_bit(TTY_DO_WRITE_WAKEUP, &tty->flags)) {
502 ld = tty_ldisc_ref(tty);
Alan Cox37bdfb02008-02-08 04:18:47 -0800503 if (ld) {
Alan Coxa352def2008-07-16 21:53:12 +0100504 if (ld->ops->write_wakeup)
505 ld->ops->write_wakeup(tty);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700506 tty_ldisc_deref(ld);
507 }
508 }
Davide Libenzi4b194492009-03-31 15:24:24 -0700509 wake_up_interruptible_poll(&tty->write_wait, POLLOUT);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700510}
511
512EXPORT_SYMBOL_GPL(tty_wakeup);
513
514/**
Arnd Bergmann11dbf202010-06-18 14:58:07 +0200515 * __tty_hangup - actual handler for hangup events
David Howells65f27f32006-11-22 14:55:48 +0000516 * @work: tty device
Alan Coxaf9b8972006-08-27 01:24:01 -0700517 *
Alan Cox1bad8792008-07-22 23:38:04 +0100518 * This can be called by the "eventd" kernel thread. That is process
Alan Coxaf9b8972006-08-27 01:24:01 -0700519 * synchronous but doesn't hold any locks, so we need to make sure we
520 * have the appropriate locks for what we're doing.
521 *
522 * The hangup event clears any pending redirections onto the hung up
523 * device. It ensures future writes will error and it does the needed
524 * line discipline hangup and signal delivery. The tty object itself
525 * remains intact.
526 *
527 * Locking:
Arnd Bergmannec79d602010-06-01 22:53:01 +0200528 * BTM
Peter Zijlstra24ec8392006-12-08 02:36:04 -0800529 * redirect lock for undoing redirection
530 * file list lock for manipulating list of ttys
531 * tty_ldisc_lock from called functions
532 * termios_mutex resetting termios data
533 * tasklist_lock to walk task list for hangup event
534 * ->siglock to protect ->signal/->sighand
Linus Torvalds1da177e2005-04-16 15:20:36 -0700535 */
Arnd Bergmann11dbf202010-06-18 14:58:07 +0200536void __tty_hangup(struct tty_struct *tty)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700537{
Alan Cox37bdfb02008-02-08 04:18:47 -0800538 struct file *cons_filp = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700539 struct file *filp, *f = NULL;
540 struct task_struct *p;
Nick Piggind996b622010-08-18 04:37:36 +1000541 struct tty_file_private *priv;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700542 int closecount = 0, n;
Alan Cox47f86832008-04-30 00:53:30 -0700543 unsigned long flags;
Alan Cox9c9f4de2008-10-13 10:37:26 +0100544 int refs = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700545
546 if (!tty)
547 return;
548
Linus Torvalds1da177e2005-04-16 15:20:36 -0700549
550 spin_lock(&redirect_lock);
Nick Piggind996b622010-08-18 04:37:36 +1000551 if (redirect && file_tty(redirect) == tty) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700552 f = redirect;
553 redirect = NULL;
554 }
555 spin_unlock(&redirect_lock);
Alan Cox37bdfb02008-02-08 04:18:47 -0800556
Arnd Bergmann11dbf202010-06-18 14:58:07 +0200557 tty_lock();
558
Jiri Slabyacfa7472010-11-29 10:16:54 +0100559 /* some functions below drop BTM, so we need this bit */
560 set_bit(TTY_HUPPING, &tty->flags);
561
Arnd Bergmannec79d602010-06-01 22:53:01 +0200562 /* inuse_filps is protected by the single tty lock,
563 this really needs to change if we want to flush the
564 workqueue with the lock held */
Arnd Bergmann11dbf202010-06-18 14:58:07 +0200565 check_tty_count(tty, "tty_hangup");
Alan Cox36ba7822009-11-30 13:18:51 +0000566
Nick Pigginee2ffa02010-08-18 04:37:35 +1000567 spin_lock(&tty_files_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700568 /* This breaks for file handles being sent over AF_UNIX sockets ? */
Nick Piggind996b622010-08-18 04:37:36 +1000569 list_for_each_entry(priv, &tty->tty_files, list) {
570 filp = priv->file;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700571 if (filp->f_op->write == redirected_tty_write)
572 cons_filp = filp;
573 if (filp->f_op->write != tty_write)
574 continue;
575 closecount++;
Arnd Bergmannec79d602010-06-01 22:53:01 +0200576 __tty_fasync(-1, filp, 0); /* can't block */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700577 filp->f_op = &hung_up_tty_fops;
578 }
Nick Pigginee2ffa02010-08-18 04:37:35 +1000579 spin_unlock(&tty_files_lock);
Alan Cox37bdfb02008-02-08 04:18:47 -0800580
Jiri Slabyacfa7472010-11-29 10:16:54 +0100581 /*
582 * it drops BTM and thus races with reopen
583 * we protect the race by TTY_HUPPING
584 */
Alan Coxc65c9bc2009-06-11 12:50:12 +0100585 tty_ldisc_hangup(tty);
Alan Cox37bdfb02008-02-08 04:18:47 -0800586
Linus Torvalds1da177e2005-04-16 15:20:36 -0700587 read_lock(&tasklist_lock);
Eric W. Biedermanab521dc2007-02-12 00:53:00 -0800588 if (tty->session) {
589 do_each_pid_task(tty->session, PIDTYPE_SID, p) {
Peter Zijlstra24ec8392006-12-08 02:36:04 -0800590 spin_lock_irq(&p->sighand->siglock);
Alan Cox9c9f4de2008-10-13 10:37:26 +0100591 if (p->signal->tty == tty) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700592 p->signal->tty = NULL;
Alan Cox9c9f4de2008-10-13 10:37:26 +0100593 /* We defer the dereferences outside fo
594 the tasklist lock */
595 refs++;
596 }
Peter Zijlstra24ec8392006-12-08 02:36:04 -0800597 if (!p->signal->leader) {
598 spin_unlock_irq(&p->sighand->siglock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700599 continue;
Peter Zijlstra24ec8392006-12-08 02:36:04 -0800600 }
601 __group_send_sig_info(SIGHUP, SEND_SIG_PRIV, p);
602 __group_send_sig_info(SIGCONT, SEND_SIG_PRIV, p);
Eric W. Biedermanab521dc2007-02-12 00:53:00 -0800603 put_pid(p->signal->tty_old_pgrp); /* A noop */
Alan Cox47f86832008-04-30 00:53:30 -0700604 spin_lock_irqsave(&tty->ctrl_lock, flags);
Eric W. Biedermanab521dc2007-02-12 00:53:00 -0800605 if (tty->pgrp)
606 p->signal->tty_old_pgrp = get_pid(tty->pgrp);
Alan Cox47f86832008-04-30 00:53:30 -0700607 spin_unlock_irqrestore(&tty->ctrl_lock, flags);
Peter Zijlstra24ec8392006-12-08 02:36:04 -0800608 spin_unlock_irq(&p->sighand->siglock);
Eric W. Biedermanab521dc2007-02-12 00:53:00 -0800609 } while_each_pid_task(tty->session, PIDTYPE_SID, p);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700610 }
611 read_unlock(&tasklist_lock);
612
Alan Cox47f86832008-04-30 00:53:30 -0700613 spin_lock_irqsave(&tty->ctrl_lock, flags);
Alan Coxc65c9bc2009-06-11 12:50:12 +0100614 clear_bit(TTY_THROTTLED, &tty->flags);
615 clear_bit(TTY_PUSH, &tty->flags);
616 clear_bit(TTY_DO_WRITE_WAKEUP, &tty->flags);
Eric W. Biedermand9c1e9a2007-03-18 12:45:44 -0600617 put_pid(tty->session);
618 put_pid(tty->pgrp);
Eric W. Biedermanab521dc2007-02-12 00:53:00 -0800619 tty->session = NULL;
620 tty->pgrp = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700621 tty->ctrl_status = 0;
Alan Cox47f86832008-04-30 00:53:30 -0700622 spin_unlock_irqrestore(&tty->ctrl_lock, flags);
623
Alan Cox9c9f4de2008-10-13 10:37:26 +0100624 /* Account for the p->signal references we killed */
625 while (refs--)
626 tty_kref_put(tty);
627
Linus Torvalds1da177e2005-04-16 15:20:36 -0700628 /*
Alan Cox37bdfb02008-02-08 04:18:47 -0800629 * If one of the devices matches a console pointer, we
630 * cannot just call hangup() because that will cause
631 * tty->count and state->count to go out of sync.
632 * So we just call close() the right number of times.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700633 */
634 if (cons_filp) {
Alan Coxf34d7a52008-04-30 00:54:13 -0700635 if (tty->ops->close)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700636 for (n = 0; n < closecount; n++)
Alan Coxf34d7a52008-04-30 00:54:13 -0700637 tty->ops->close(tty, cons_filp);
638 } else if (tty->ops->hangup)
639 (tty->ops->hangup)(tty);
Alan Cox37bdfb02008-02-08 04:18:47 -0800640 /*
641 * We don't want to have driver/ldisc interactions beyond
642 * the ones we did here. The driver layer expects no
643 * calls after ->hangup() from the ldisc side. However we
644 * can't yet guarantee all that.
645 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700646 set_bit(TTY_HUPPED, &tty->flags);
Jiri Slabyacfa7472010-11-29 10:16:54 +0100647 clear_bit(TTY_HUPPING, &tty->flags);
Alan Coxc65c9bc2009-06-11 12:50:12 +0100648 tty_ldisc_enable(tty);
Arnd Bergmann11dbf202010-06-18 14:58:07 +0200649
650 tty_unlock();
651
Linus Torvalds1da177e2005-04-16 15:20:36 -0700652 if (f)
653 fput(f);
654}
655
Arnd Bergmannddcd9fb2010-06-01 22:53:08 +0200656static void do_tty_hangup(struct work_struct *work)
657{
658 struct tty_struct *tty =
659 container_of(work, struct tty_struct, hangup_work);
660
Arnd Bergmann11dbf202010-06-18 14:58:07 +0200661 __tty_hangup(tty);
Arnd Bergmannddcd9fb2010-06-01 22:53:08 +0200662}
663
Alan Coxaf9b8972006-08-27 01:24:01 -0700664/**
665 * tty_hangup - trigger a hangup event
666 * @tty: tty to hangup
667 *
668 * A carrier loss (virtual or otherwise) has occurred on this like
669 * schedule a hangup sequence to run after this event.
670 */
671
Alan Cox37bdfb02008-02-08 04:18:47 -0800672void tty_hangup(struct tty_struct *tty)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700673{
674#ifdef TTY_DEBUG_HANGUP
675 char buf[64];
Linus Torvalds1da177e2005-04-16 15:20:36 -0700676 printk(KERN_DEBUG "%s hangup...\n", tty_name(tty, buf));
677#endif
678 schedule_work(&tty->hangup_work);
679}
680
681EXPORT_SYMBOL(tty_hangup);
682
Alan Coxaf9b8972006-08-27 01:24:01 -0700683/**
684 * tty_vhangup - process vhangup
685 * @tty: tty to hangup
686 *
687 * The user has asked via system call for the terminal to be hung up.
688 * We do this synchronously so that when the syscall returns the process
Robert P. J. Day3a4fa0a2007-10-19 23:10:43 +0200689 * is complete. That guarantee is necessary for security reasons.
Alan Coxaf9b8972006-08-27 01:24:01 -0700690 */
691
Alan Cox37bdfb02008-02-08 04:18:47 -0800692void tty_vhangup(struct tty_struct *tty)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700693{
694#ifdef TTY_DEBUG_HANGUP
695 char buf[64];
696
697 printk(KERN_DEBUG "%s vhangup...\n", tty_name(tty, buf));
698#endif
Arnd Bergmann11dbf202010-06-18 14:58:07 +0200699 __tty_hangup(tty);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700700}
Alan Cox37bdfb02008-02-08 04:18:47 -0800701
Linus Torvalds1da177e2005-04-16 15:20:36 -0700702EXPORT_SYMBOL(tty_vhangup);
703
Arnd Bergmann11dbf202010-06-18 14:58:07 +0200704
Alan Coxaf9b8972006-08-27 01:24:01 -0700705/**
Alan Cox2cb59982008-10-13 10:40:30 +0100706 * tty_vhangup_self - process vhangup for own ctty
707 *
708 * Perform a vhangup on the current controlling tty
709 */
710
711void tty_vhangup_self(void)
712{
713 struct tty_struct *tty;
714
Alan Cox2cb59982008-10-13 10:40:30 +0100715 tty = get_current_tty();
716 if (tty) {
717 tty_vhangup(tty);
718 tty_kref_put(tty);
719 }
Alan Cox2cb59982008-10-13 10:40:30 +0100720}
721
722/**
Alan Coxaf9b8972006-08-27 01:24:01 -0700723 * tty_hung_up_p - was tty hung up
724 * @filp: file pointer of tty
725 *
726 * Return true if the tty has been subject to a vhangup or a carrier
727 * loss
728 */
729
Alan Cox37bdfb02008-02-08 04:18:47 -0800730int tty_hung_up_p(struct file *filp)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700731{
732 return (filp->f_op == &hung_up_tty_fops);
733}
734
735EXPORT_SYMBOL(tty_hung_up_p);
736
Eric W. Biedermanab521dc2007-02-12 00:53:00 -0800737static void session_clear_tty(struct pid *session)
Peter Zijlstra24ec8392006-12-08 02:36:04 -0800738{
739 struct task_struct *p;
Eric W. Biedermanab521dc2007-02-12 00:53:00 -0800740 do_each_pid_task(session, PIDTYPE_SID, p) {
Peter Zijlstra24ec8392006-12-08 02:36:04 -0800741 proc_clear_tty(p);
Eric W. Biedermanab521dc2007-02-12 00:53:00 -0800742 } while_each_pid_task(session, PIDTYPE_SID, p);
Peter Zijlstra24ec8392006-12-08 02:36:04 -0800743}
744
Alan Coxaf9b8972006-08-27 01:24:01 -0700745/**
746 * disassociate_ctty - disconnect controlling tty
747 * @on_exit: true if exiting so need to "hang up" the session
Linus Torvalds1da177e2005-04-16 15:20:36 -0700748 *
Alan Coxaf9b8972006-08-27 01:24:01 -0700749 * This function is typically called only by the session leader, when
750 * it wants to disassociate itself from its controlling tty.
751 *
752 * It performs the following functions:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700753 * (1) Sends a SIGHUP and SIGCONT to the foreground process group
754 * (2) Clears the tty from being controlling the session
755 * (3) Clears the controlling tty for all processes in the
756 * session group.
757 *
Alan Coxaf9b8972006-08-27 01:24:01 -0700758 * The argument on_exit is set to 1 if called when a process is
759 * exiting; it is 0 if called by the ioctl TIOCNOTTY.
760 *
Peter Zijlstra24ec8392006-12-08 02:36:04 -0800761 * Locking:
Arnd Bergmannec79d602010-06-01 22:53:01 +0200762 * BTM is taken for hysterical raisins, and held when
763 * called from no_tty().
Peter Zijlstra24ec8392006-12-08 02:36:04 -0800764 * tty_mutex is taken to protect tty
765 * ->siglock is taken to protect ->signal/->sighand
766 * tasklist_lock is taken to walk process list for sessions
767 * ->siglock is taken to protect ->signal/->sighand
Linus Torvalds1da177e2005-04-16 15:20:36 -0700768 */
Alan Coxaf9b8972006-08-27 01:24:01 -0700769
Linus Torvalds1da177e2005-04-16 15:20:36 -0700770void disassociate_ctty(int on_exit)
771{
772 struct tty_struct *tty;
Eric W. Biedermanab521dc2007-02-12 00:53:00 -0800773 struct pid *tty_pgrp = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700774
Alan Cox5ec93d12009-11-30 13:18:45 +0000775 if (!current->signal->leader)
776 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700777
Peter Zijlstra24ec8392006-12-08 02:36:04 -0800778 tty = get_current_tty();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700779 if (tty) {
Eric W. Biedermanab521dc2007-02-12 00:53:00 -0800780 tty_pgrp = get_pid(tty->pgrp);
Arnd Bergmannddcd9fb2010-06-01 22:53:08 +0200781 if (on_exit) {
Arnd Bergmannddcd9fb2010-06-01 22:53:08 +0200782 if (tty->driver->type != TTY_DRIVER_TYPE_PTY)
Arnd Bergmann11dbf202010-06-18 14:58:07 +0200783 tty_vhangup(tty);
Arnd Bergmannddcd9fb2010-06-01 22:53:08 +0200784 }
Alan Cox452a00d2008-10-13 10:39:13 +0100785 tty_kref_put(tty);
Eric W. Biederman680a9672007-02-12 00:52:52 -0800786 } else if (on_exit) {
Eric W. Biedermanab521dc2007-02-12 00:53:00 -0800787 struct pid *old_pgrp;
Eric W. Biederman680a9672007-02-12 00:52:52 -0800788 spin_lock_irq(&current->sighand->siglock);
789 old_pgrp = current->signal->tty_old_pgrp;
Eric W. Biedermanab521dc2007-02-12 00:53:00 -0800790 current->signal->tty_old_pgrp = NULL;
Eric W. Biederman680a9672007-02-12 00:52:52 -0800791 spin_unlock_irq(&current->sighand->siglock);
Peter Zijlstra24ec8392006-12-08 02:36:04 -0800792 if (old_pgrp) {
Eric W. Biedermanab521dc2007-02-12 00:53:00 -0800793 kill_pgrp(old_pgrp, SIGHUP, on_exit);
794 kill_pgrp(old_pgrp, SIGCONT, on_exit);
795 put_pid(old_pgrp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700796 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700797 return;
798 }
Eric W. Biedermanab521dc2007-02-12 00:53:00 -0800799 if (tty_pgrp) {
800 kill_pgrp(tty_pgrp, SIGHUP, on_exit);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700801 if (!on_exit)
Eric W. Biedermanab521dc2007-02-12 00:53:00 -0800802 kill_pgrp(tty_pgrp, SIGCONT, on_exit);
803 put_pid(tty_pgrp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700804 }
805
Peter Zijlstra24ec8392006-12-08 02:36:04 -0800806 spin_lock_irq(&current->sighand->siglock);
Eric W. Biederman2a65f1d2007-05-08 00:26:53 -0700807 put_pid(current->signal->tty_old_pgrp);
Randy Dunlap23cac8d2007-02-20 13:58:05 -0800808 current->signal->tty_old_pgrp = NULL;
Peter Zijlstra24ec8392006-12-08 02:36:04 -0800809 spin_unlock_irq(&current->sighand->siglock);
810
Peter Zijlstra24ec8392006-12-08 02:36:04 -0800811 tty = get_current_tty();
812 if (tty) {
Alan Cox47f86832008-04-30 00:53:30 -0700813 unsigned long flags;
814 spin_lock_irqsave(&tty->ctrl_lock, flags);
Eric W. Biedermanab521dc2007-02-12 00:53:00 -0800815 put_pid(tty->session);
816 put_pid(tty->pgrp);
817 tty->session = NULL;
818 tty->pgrp = NULL;
Alan Cox47f86832008-04-30 00:53:30 -0700819 spin_unlock_irqrestore(&tty->ctrl_lock, flags);
Alan Cox452a00d2008-10-13 10:39:13 +0100820 tty_kref_put(tty);
Peter Zijlstra24ec8392006-12-08 02:36:04 -0800821 } else {
822#ifdef TTY_DEBUG_HANGUP
823 printk(KERN_DEBUG "error attempted to write to tty [0x%p]"
824 " = NULL", tty);
825#endif
826 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700827
828 /* Now clear signal->tty under the lock */
829 read_lock(&tasklist_lock);
Eric W. Biedermanab521dc2007-02-12 00:53:00 -0800830 session_clear_tty(task_session(current));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700831 read_unlock(&tasklist_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700832}
833
Eric W. Biederman98a27ba2007-05-08 00:26:56 -0700834/**
835 *
836 * no_tty - Ensure the current process does not have a controlling tty
837 */
838void no_tty(void)
839{
840 struct task_struct *tsk = current;
Arnd Bergmannec79d602010-06-01 22:53:01 +0200841 tty_lock();
Alan Cox5ec93d12009-11-30 13:18:45 +0000842 disassociate_ctty(0);
Arnd Bergmannec79d602010-06-01 22:53:01 +0200843 tty_unlock();
Eric W. Biederman98a27ba2007-05-08 00:26:56 -0700844 proc_clear_tty(tsk);
845}
846
Alan Coxaf9b8972006-08-27 01:24:01 -0700847
848/**
Robert P. J. Daybeb7dd82007-05-09 07:14:03 +0200849 * stop_tty - propagate flow control
Alan Coxaf9b8972006-08-27 01:24:01 -0700850 * @tty: tty to stop
851 *
852 * Perform flow control to the driver. For PTY/TTY pairs we
Robert P. J. Daybeb7dd82007-05-09 07:14:03 +0200853 * must also propagate the TIOCKPKT status. May be called
Alan Coxaf9b8972006-08-27 01:24:01 -0700854 * on an already stopped device and will not re-call the driver
855 * method.
856 *
857 * This functionality is used by both the line disciplines for
858 * halting incoming flow and by the driver. It may therefore be
859 * called from any context, may be under the tty atomic_write_lock
860 * but not always.
861 *
862 * Locking:
Alan Cox04f378b2008-04-30 00:53:29 -0700863 * Uses the tty control lock internally
Alan Coxaf9b8972006-08-27 01:24:01 -0700864 */
865
Linus Torvalds1da177e2005-04-16 15:20:36 -0700866void stop_tty(struct tty_struct *tty)
867{
Alan Cox04f378b2008-04-30 00:53:29 -0700868 unsigned long flags;
869 spin_lock_irqsave(&tty->ctrl_lock, flags);
870 if (tty->stopped) {
871 spin_unlock_irqrestore(&tty->ctrl_lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700872 return;
Alan Cox04f378b2008-04-30 00:53:29 -0700873 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700874 tty->stopped = 1;
875 if (tty->link && tty->link->packet) {
876 tty->ctrl_status &= ~TIOCPKT_START;
877 tty->ctrl_status |= TIOCPKT_STOP;
Davide Libenzi4b194492009-03-31 15:24:24 -0700878 wake_up_interruptible_poll(&tty->link->read_wait, POLLIN);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700879 }
Alan Cox04f378b2008-04-30 00:53:29 -0700880 spin_unlock_irqrestore(&tty->ctrl_lock, flags);
Alan Coxf34d7a52008-04-30 00:54:13 -0700881 if (tty->ops->stop)
882 (tty->ops->stop)(tty);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700883}
884
885EXPORT_SYMBOL(stop_tty);
886
Alan Coxaf9b8972006-08-27 01:24:01 -0700887/**
Robert P. J. Daybeb7dd82007-05-09 07:14:03 +0200888 * start_tty - propagate flow control
Alan Coxaf9b8972006-08-27 01:24:01 -0700889 * @tty: tty to start
890 *
891 * Start a tty that has been stopped if at all possible. Perform
Robert P. J. Day3a4fa0a2007-10-19 23:10:43 +0200892 * any necessary wakeups and propagate the TIOCPKT status. If this
Alan Coxaf9b8972006-08-27 01:24:01 -0700893 * is the tty was previous stopped and is being started then the
894 * driver start method is invoked and the line discipline woken.
895 *
896 * Locking:
Alan Cox04f378b2008-04-30 00:53:29 -0700897 * ctrl_lock
Alan Coxaf9b8972006-08-27 01:24:01 -0700898 */
899
Linus Torvalds1da177e2005-04-16 15:20:36 -0700900void start_tty(struct tty_struct *tty)
901{
Alan Cox04f378b2008-04-30 00:53:29 -0700902 unsigned long flags;
903 spin_lock_irqsave(&tty->ctrl_lock, flags);
904 if (!tty->stopped || tty->flow_stopped) {
905 spin_unlock_irqrestore(&tty->ctrl_lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700906 return;
Alan Cox04f378b2008-04-30 00:53:29 -0700907 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700908 tty->stopped = 0;
909 if (tty->link && tty->link->packet) {
910 tty->ctrl_status &= ~TIOCPKT_STOP;
911 tty->ctrl_status |= TIOCPKT_START;
Davide Libenzi4b194492009-03-31 15:24:24 -0700912 wake_up_interruptible_poll(&tty->link->read_wait, POLLIN);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700913 }
Alan Cox04f378b2008-04-30 00:53:29 -0700914 spin_unlock_irqrestore(&tty->ctrl_lock, flags);
Alan Coxf34d7a52008-04-30 00:54:13 -0700915 if (tty->ops->start)
916 (tty->ops->start)(tty);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700917 /* If we have a running line discipline it may need kicking */
918 tty_wakeup(tty);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700919}
920
921EXPORT_SYMBOL(start_tty);
922
Alan Coxaf9b8972006-08-27 01:24:01 -0700923/**
924 * tty_read - read method for tty device files
925 * @file: pointer to tty file
926 * @buf: user buffer
927 * @count: size of user buffer
928 * @ppos: unused
929 *
930 * Perform the read system call function on this terminal device. Checks
931 * for hung up devices before calling the line discipline method.
932 *
933 * Locking:
Alan Cox47f86832008-04-30 00:53:30 -0700934 * Locks the line discipline internally while needed. Multiple
935 * read calls may be outstanding in parallel.
Alan Coxaf9b8972006-08-27 01:24:01 -0700936 */
937
Alan Cox37bdfb02008-02-08 04:18:47 -0800938static ssize_t tty_read(struct file *file, char __user *buf, size_t count,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700939 loff_t *ppos)
940{
941 int i;
Nick Piggind996b622010-08-18 04:37:36 +1000942 struct inode *inode = file->f_path.dentry->d_inode;
943 struct tty_struct *tty = file_tty(file);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700944 struct tty_ldisc *ld;
945
Linus Torvalds1da177e2005-04-16 15:20:36 -0700946 if (tty_paranoia_check(tty, inode, "tty_read"))
947 return -EIO;
948 if (!tty || (test_bit(TTY_IO_ERROR, &tty->flags)))
949 return -EIO;
950
951 /* We want to wait for the line discipline to sort out in this
952 situation */
953 ld = tty_ldisc_ref_wait(tty);
Alan Coxa352def2008-07-16 21:53:12 +0100954 if (ld->ops->read)
955 i = (ld->ops->read)(tty, file, buf, count);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700956 else
957 i = -EIO;
958 tty_ldisc_deref(ld);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700959 if (i > 0)
960 inode->i_atime = current_fs_time(inode->i_sb);
961 return i;
962}
963
Alan Cox9c1729d2007-07-15 23:39:43 -0700964void tty_write_unlock(struct tty_struct *tty)
Jiri Slaby83c67572011-04-20 10:43:18 +0200965 __releases(&tty->atomic_write_lock)
Alan Cox9c1729d2007-07-15 23:39:43 -0700966{
967 mutex_unlock(&tty->atomic_write_lock);
Davide Libenzi4b194492009-03-31 15:24:24 -0700968 wake_up_interruptible_poll(&tty->write_wait, POLLOUT);
Alan Cox9c1729d2007-07-15 23:39:43 -0700969}
970
971int tty_write_lock(struct tty_struct *tty, int ndelay)
Jiri Slaby83c67572011-04-20 10:43:18 +0200972 __acquires(&tty->atomic_write_lock)
Alan Cox9c1729d2007-07-15 23:39:43 -0700973{
974 if (!mutex_trylock(&tty->atomic_write_lock)) {
975 if (ndelay)
976 return -EAGAIN;
977 if (mutex_lock_interruptible(&tty->atomic_write_lock))
978 return -ERESTARTSYS;
979 }
980 return 0;
981}
982
Linus Torvalds1da177e2005-04-16 15:20:36 -0700983/*
984 * Split writes up in sane blocksizes to avoid
985 * denial-of-service type attacks
986 */
987static inline ssize_t do_tty_write(
988 ssize_t (*write)(struct tty_struct *, struct file *, const unsigned char *, size_t),
989 struct tty_struct *tty,
990 struct file *file,
991 const char __user *buf,
992 size_t count)
993{
Alan Cox9c1729d2007-07-15 23:39:43 -0700994 ssize_t ret, written = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700995 unsigned int chunk;
Alan Cox37bdfb02008-02-08 04:18:47 -0800996
Alan Cox9c1729d2007-07-15 23:39:43 -0700997 ret = tty_write_lock(tty, file->f_flags & O_NDELAY);
998 if (ret < 0)
999 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001000
1001 /*
1002 * We chunk up writes into a temporary buffer. This
1003 * simplifies low-level drivers immensely, since they
1004 * don't have locking issues and user mode accesses.
1005 *
1006 * But if TTY_NO_WRITE_SPLIT is set, we should use a
1007 * big chunk-size..
1008 *
1009 * The default chunk-size is 2kB, because the NTTY
1010 * layer has problems with bigger chunks. It will
1011 * claim to be able to handle more characters than
1012 * it actually does.
Alan Coxaf9b8972006-08-27 01:24:01 -07001013 *
1014 * FIXME: This can probably go away now except that 64K chunks
1015 * are too likely to fail unless switched to vmalloc...
Linus Torvalds1da177e2005-04-16 15:20:36 -07001016 */
1017 chunk = 2048;
1018 if (test_bit(TTY_NO_WRITE_SPLIT, &tty->flags))
1019 chunk = 65536;
1020 if (count < chunk)
1021 chunk = count;
1022
Ingo Molnar70522e12006-03-23 03:00:31 -08001023 /* write_buf/write_cnt is protected by the atomic_write_lock mutex */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001024 if (tty->write_cnt < chunk) {
Jason Wessel402fda92008-10-13 10:45:36 +01001025 unsigned char *buf_chunk;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001026
1027 if (chunk < 1024)
1028 chunk = 1024;
1029
Jason Wessel402fda92008-10-13 10:45:36 +01001030 buf_chunk = kmalloc(chunk, GFP_KERNEL);
1031 if (!buf_chunk) {
Alan Cox9c1729d2007-07-15 23:39:43 -07001032 ret = -ENOMEM;
1033 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001034 }
1035 kfree(tty->write_buf);
1036 tty->write_cnt = chunk;
Jason Wessel402fda92008-10-13 10:45:36 +01001037 tty->write_buf = buf_chunk;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001038 }
1039
1040 /* Do the write .. */
1041 for (;;) {
1042 size_t size = count;
1043 if (size > chunk)
1044 size = chunk;
1045 ret = -EFAULT;
1046 if (copy_from_user(tty->write_buf, buf, size))
1047 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001048 ret = write(tty, file, tty->write_buf, size);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001049 if (ret <= 0)
1050 break;
1051 written += ret;
1052 buf += ret;
1053 count -= ret;
1054 if (!count)
1055 break;
1056 ret = -ERESTARTSYS;
1057 if (signal_pending(current))
1058 break;
1059 cond_resched();
1060 }
1061 if (written) {
Josef Sipeka7113a92006-12-08 02:36:55 -08001062 struct inode *inode = file->f_path.dentry->d_inode;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001063 inode->i_mtime = current_fs_time(inode->i_sb);
1064 ret = written;
1065 }
Alan Cox9c1729d2007-07-15 23:39:43 -07001066out:
1067 tty_write_unlock(tty);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001068 return ret;
1069}
1070
Alan Cox95f9bfc2008-10-13 10:39:23 +01001071/**
1072 * tty_write_message - write a message to a certain tty, not just the console.
1073 * @tty: the destination tty_struct
1074 * @msg: the message to write
1075 *
1076 * This is used for messages that need to be redirected to a specific tty.
1077 * We don't put it into the syslog queue right now maybe in the future if
1078 * really needed.
1079 *
Arnd Bergmannec79d602010-06-01 22:53:01 +02001080 * We must still hold the BTM and test the CLOSING flag for the moment.
Alan Cox95f9bfc2008-10-13 10:39:23 +01001081 */
1082
1083void tty_write_message(struct tty_struct *tty, char *msg)
1084{
Alan Cox95f9bfc2008-10-13 10:39:23 +01001085 if (tty) {
1086 mutex_lock(&tty->atomic_write_lock);
Arnd Bergmannec79d602010-06-01 22:53:01 +02001087 tty_lock();
Alan Coxeeb89d92009-11-30 13:18:29 +00001088 if (tty->ops->write && !test_bit(TTY_CLOSING, &tty->flags)) {
Arnd Bergmannec79d602010-06-01 22:53:01 +02001089 tty_unlock();
Alan Cox95f9bfc2008-10-13 10:39:23 +01001090 tty->ops->write(tty, msg, strlen(msg));
Alan Coxeeb89d92009-11-30 13:18:29 +00001091 } else
Arnd Bergmannec79d602010-06-01 22:53:01 +02001092 tty_unlock();
Alan Cox95f9bfc2008-10-13 10:39:23 +01001093 tty_write_unlock(tty);
1094 }
Alan Cox95f9bfc2008-10-13 10:39:23 +01001095 return;
1096}
1097
Linus Torvalds1da177e2005-04-16 15:20:36 -07001098
Alan Coxaf9b8972006-08-27 01:24:01 -07001099/**
1100 * tty_write - write method for tty device file
1101 * @file: tty file pointer
1102 * @buf: user data to write
1103 * @count: bytes to write
1104 * @ppos: unused
1105 *
1106 * Write data to a tty device via the line discipline.
1107 *
1108 * Locking:
1109 * Locks the line discipline as required
1110 * Writes to the tty driver are serialized by the atomic_write_lock
1111 * and are then processed in chunks to the device. The line discipline
Joe Petersona88a69c2009-01-02 13:40:53 +00001112 * write method will not be invoked in parallel for each device.
Alan Coxaf9b8972006-08-27 01:24:01 -07001113 */
1114
Alan Cox37bdfb02008-02-08 04:18:47 -08001115static ssize_t tty_write(struct file *file, const char __user *buf,
1116 size_t count, loff_t *ppos)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001117{
Josef Sipeka7113a92006-12-08 02:36:55 -08001118 struct inode *inode = file->f_path.dentry->d_inode;
Nick Piggind996b622010-08-18 04:37:36 +10001119 struct tty_struct *tty = file_tty(file);
1120 struct tty_ldisc *ld;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001121 ssize_t ret;
Alan Cox37bdfb02008-02-08 04:18:47 -08001122
Linus Torvalds1da177e2005-04-16 15:20:36 -07001123 if (tty_paranoia_check(tty, inode, "tty_write"))
1124 return -EIO;
Alan Coxf34d7a52008-04-30 00:54:13 -07001125 if (!tty || !tty->ops->write ||
Alan Cox37bdfb02008-02-08 04:18:47 -08001126 (test_bit(TTY_IO_ERROR, &tty->flags)))
1127 return -EIO;
Alan Coxf34d7a52008-04-30 00:54:13 -07001128 /* Short term debug to catch buggy drivers */
1129 if (tty->ops->write_room == NULL)
1130 printk(KERN_ERR "tty driver %s lacks a write_room method.\n",
1131 tty->driver->name);
Alan Cox37bdfb02008-02-08 04:18:47 -08001132 ld = tty_ldisc_ref_wait(tty);
Alan Coxa352def2008-07-16 21:53:12 +01001133 if (!ld->ops->write)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001134 ret = -EIO;
1135 else
Alan Coxa352def2008-07-16 21:53:12 +01001136 ret = do_tty_write(ld->ops->write, tty, file, buf, count);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001137 tty_ldisc_deref(ld);
1138 return ret;
1139}
1140
Alan Cox37bdfb02008-02-08 04:18:47 -08001141ssize_t redirected_tty_write(struct file *file, const char __user *buf,
1142 size_t count, loff_t *ppos)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001143{
1144 struct file *p = NULL;
1145
1146 spin_lock(&redirect_lock);
1147 if (redirect) {
1148 get_file(redirect);
1149 p = redirect;
1150 }
1151 spin_unlock(&redirect_lock);
1152
1153 if (p) {
1154 ssize_t res;
1155 res = vfs_write(p, buf, count, &p->f_pos);
1156 fput(p);
1157 return res;
1158 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001159 return tty_write(file, buf, count, ppos);
1160}
1161
1162static char ptychar[] = "pqrstuvwxyzabcde";
1163
Alan Coxaf9b8972006-08-27 01:24:01 -07001164/**
1165 * pty_line_name - generate name for a pty
1166 * @driver: the tty driver in use
1167 * @index: the minor number
1168 * @p: output buffer of at least 6 bytes
1169 *
1170 * Generate a name from a driver reference and write it to the output
1171 * buffer.
1172 *
1173 * Locking: None
1174 */
1175static void pty_line_name(struct tty_driver *driver, int index, char *p)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001176{
1177 int i = index + driver->name_base;
1178 /* ->name is initialized to "ttyp", but "tty" is expected */
1179 sprintf(p, "%s%c%x",
Alan Cox37bdfb02008-02-08 04:18:47 -08001180 driver->subtype == PTY_TYPE_SLAVE ? "tty" : driver->name,
1181 ptychar[i >> 4 & 0xf], i & 0xf);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001182}
1183
Alan Coxaf9b8972006-08-27 01:24:01 -07001184/**
Alan Cox8b0a88d2008-10-13 10:42:19 +01001185 * tty_line_name - generate name for a tty
Alan Coxaf9b8972006-08-27 01:24:01 -07001186 * @driver: the tty driver in use
1187 * @index: the minor number
1188 * @p: output buffer of at least 7 bytes
1189 *
1190 * Generate a name from a driver reference and write it to the output
1191 * buffer.
1192 *
1193 * Locking: None
1194 */
1195static void tty_line_name(struct tty_driver *driver, int index, char *p)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001196{
1197 sprintf(p, "%s%d", driver->name, index + driver->name_base);
1198}
1199
Alan Cox99f1fe12008-10-13 10:42:00 +01001200/**
1201 * tty_driver_lookup_tty() - find an existing tty, if any
1202 * @driver: the driver for the tty
1203 * @idx: the minor number
Sukadev Bhattiprolu23499702008-10-13 10:41:51 +01001204 *
Alan Cox99f1fe12008-10-13 10:42:00 +01001205 * Return the tty, if found or ERR_PTR() otherwise.
Sukadev Bhattiprolu23499702008-10-13 10:41:51 +01001206 *
Alan Cox99f1fe12008-10-13 10:42:00 +01001207 * Locking: tty_mutex must be held. If tty is found, the mutex must
1208 * be held until the 'fast-open' is also done. Will change once we
1209 * have refcounting in the driver and per driver locking
Sukadev Bhattiprolu23499702008-10-13 10:41:51 +01001210 */
Jason Wessela47d5452009-01-02 13:43:04 +00001211static struct tty_struct *tty_driver_lookup_tty(struct tty_driver *driver,
Sukadev Bhattiprolu15f1a632008-10-13 10:42:59 +01001212 struct inode *inode, int idx)
Sukadev Bhattiprolu23499702008-10-13 10:41:51 +01001213{
1214 struct tty_struct *tty;
1215
Alan Cox99f1fe12008-10-13 10:42:00 +01001216 if (driver->ops->lookup)
Sukadev Bhattiprolu15f1a632008-10-13 10:42:59 +01001217 return driver->ops->lookup(driver, inode, idx);
Sukadev Bhattiprolu23499702008-10-13 10:41:51 +01001218
Alan Cox8b0a88d2008-10-13 10:42:19 +01001219 tty = driver->ttys[idx];
Sukadev Bhattiprolu23499702008-10-13 10:41:51 +01001220 return tty;
1221}
1222
Alan Cox99f1fe12008-10-13 10:42:00 +01001223/**
Alan Coxbf970ee2008-10-13 10:42:39 +01001224 * tty_init_termios - helper for termios setup
1225 * @tty: the tty to set up
1226 *
1227 * Initialise the termios structures for this tty. Thus runs under
1228 * the tty_mutex currently so we can be relaxed about ordering.
1229 */
1230
1231int tty_init_termios(struct tty_struct *tty)
1232{
Alan Coxfe6e29f2008-10-13 10:44:08 +01001233 struct ktermios *tp;
Alan Coxbf970ee2008-10-13 10:42:39 +01001234 int idx = tty->index;
1235
1236 tp = tty->driver->termios[idx];
Alan Coxbf970ee2008-10-13 10:42:39 +01001237 if (tp == NULL) {
Alan Coxfe6e29f2008-10-13 10:44:08 +01001238 tp = kzalloc(sizeof(struct ktermios[2]), GFP_KERNEL);
1239 if (tp == NULL)
Alan Coxbf970ee2008-10-13 10:42:39 +01001240 return -ENOMEM;
Alan Coxbf970ee2008-10-13 10:42:39 +01001241 memcpy(tp, &tty->driver->init_termios,
1242 sizeof(struct ktermios));
1243 tty->driver->termios[idx] = tp;
Alan Coxbf970ee2008-10-13 10:42:39 +01001244 }
1245 tty->termios = tp;
Alan Coxfe6e29f2008-10-13 10:44:08 +01001246 tty->termios_locked = tp + 1;
Alan Coxbf970ee2008-10-13 10:42:39 +01001247
1248 /* Compatibility until drivers always set this */
1249 tty->termios->c_ispeed = tty_termios_input_baud_rate(tty->termios);
1250 tty->termios->c_ospeed = tty_termios_baud_rate(tty->termios);
1251 return 0;
1252}
Alan Coxfe1ae7f2009-09-19 13:13:33 -07001253EXPORT_SYMBOL_GPL(tty_init_termios);
Alan Coxbf970ee2008-10-13 10:42:39 +01001254
1255/**
Alan Cox8b0a88d2008-10-13 10:42:19 +01001256 * tty_driver_install_tty() - install a tty entry in the driver
1257 * @driver: the driver for the tty
1258 * @tty: the tty
1259 *
1260 * Install a tty object into the driver tables. The tty->index field
Alan Coxbf970ee2008-10-13 10:42:39 +01001261 * will be set by the time this is called. This method is responsible
1262 * for ensuring any need additional structures are allocated and
1263 * configured.
Alan Cox8b0a88d2008-10-13 10:42:19 +01001264 *
1265 * Locking: tty_mutex for now
1266 */
1267static int tty_driver_install_tty(struct tty_driver *driver,
1268 struct tty_struct *tty)
1269{
Alan Coxbf970ee2008-10-13 10:42:39 +01001270 int idx = tty->index;
Alan Coxeeb89d92009-11-30 13:18:29 +00001271 int ret;
Alan Coxbf970ee2008-10-13 10:42:39 +01001272
Alan Coxeeb89d92009-11-30 13:18:29 +00001273 if (driver->ops->install) {
Alan Coxeeb89d92009-11-30 13:18:29 +00001274 ret = driver->ops->install(driver, tty);
Alan Coxeeb89d92009-11-30 13:18:29 +00001275 return ret;
1276 }
Alan Coxbf970ee2008-10-13 10:42:39 +01001277
1278 if (tty_init_termios(tty) == 0) {
1279 tty_driver_kref_get(driver);
1280 tty->count++;
1281 driver->ttys[idx] = tty;
1282 return 0;
1283 }
1284 return -ENOMEM;
Alan Cox8b0a88d2008-10-13 10:42:19 +01001285}
1286
1287/**
1288 * tty_driver_remove_tty() - remove a tty from the driver tables
1289 * @driver: the driver for the tty
1290 * @idx: the minor number
1291 *
1292 * Remvoe a tty object from the driver tables. The tty->index field
1293 * will be set by the time this is called.
1294 *
1295 * Locking: tty_mutex for now
1296 */
1297static void tty_driver_remove_tty(struct tty_driver *driver,
1298 struct tty_struct *tty)
1299{
1300 if (driver->ops->remove)
1301 driver->ops->remove(driver, tty);
1302 else
1303 driver->ttys[tty->index] = NULL;
1304}
1305
1306/*
1307 * tty_reopen() - fast re-open of an open tty
1308 * @tty - the tty to open
Sukadev Bhattiprolu23499702008-10-13 10:41:51 +01001309 *
Alan Cox99f1fe12008-10-13 10:42:00 +01001310 * Return 0 on success, -errno on error.
Sukadev Bhattiprolu23499702008-10-13 10:41:51 +01001311 *
Alan Cox99f1fe12008-10-13 10:42:00 +01001312 * Locking: tty_mutex must be held from the time the tty was found
1313 * till this open completes.
Sukadev Bhattiprolu23499702008-10-13 10:41:51 +01001314 */
Alan Cox99f1fe12008-10-13 10:42:00 +01001315static int tty_reopen(struct tty_struct *tty)
Sukadev Bhattiprolu23499702008-10-13 10:41:51 +01001316{
1317 struct tty_driver *driver = tty->driver;
1318
Jiri Slabye2efafb2010-11-29 10:16:53 +01001319 if (test_bit(TTY_CLOSING, &tty->flags) ||
Jiri Slabyacfa7472010-11-29 10:16:54 +01001320 test_bit(TTY_HUPPING, &tty->flags) ||
Jiri Slabye2efafb2010-11-29 10:16:53 +01001321 test_bit(TTY_LDISC_CHANGING, &tty->flags))
Sukadev Bhattiprolu23499702008-10-13 10:41:51 +01001322 return -EIO;
1323
1324 if (driver->type == TTY_DRIVER_TYPE_PTY &&
1325 driver->subtype == PTY_TYPE_MASTER) {
1326 /*
1327 * special case for PTY masters: only one open permitted,
1328 * and the slave side open count is incremented as well.
1329 */
1330 if (tty->count)
1331 return -EIO;
1332
1333 tty->link->count++;
1334 }
1335 tty->count++;
1336 tty->driver = driver; /* N.B. why do this every time?? */
1337
Alan Cox1aa4bed2009-06-16 17:01:33 +01001338 mutex_lock(&tty->ldisc_mutex);
Alan Cox99f1fe12008-10-13 10:42:00 +01001339 WARN_ON(!test_bit(TTY_LDISC, &tty->flags));
Alan Cox1aa4bed2009-06-16 17:01:33 +01001340 mutex_unlock(&tty->ldisc_mutex);
Sukadev Bhattiprolu23499702008-10-13 10:41:51 +01001341
1342 return 0;
1343}
1344
Alan Coxaf9b8972006-08-27 01:24:01 -07001345/**
Alan Coxd81ed102008-10-13 10:41:42 +01001346 * tty_init_dev - initialise a tty device
Alan Coxaf9b8972006-08-27 01:24:01 -07001347 * @driver: tty driver we are opening a device on
1348 * @idx: device index
Alan Cox15582d32008-10-13 10:41:03 +01001349 * @ret_tty: returned tty structure
1350 * @first_ok: ok to open a new device (used by ptmx)
Alan Coxaf9b8972006-08-27 01:24:01 -07001351 *
1352 * Prepare a tty device. This may not be a "new" clean device but
1353 * could also be an active device. The pty drivers require special
1354 * handling because of this.
1355 *
1356 * Locking:
1357 * The function is called under the tty_mutex, which
1358 * protects us from the tty struct or driver itself going away.
1359 *
1360 * On exit the tty device has the line discipline attached and
1361 * a reference count of 1. If a pair was created for pty/tty use
1362 * and the other was a pty master then it too has a reference count of 1.
1363 *
Linus Torvalds1da177e2005-04-16 15:20:36 -07001364 * WSH 06/09/97: Rewritten to remove races and properly clean up after a
Ingo Molnar70522e12006-03-23 03:00:31 -08001365 * failed open. The new code protects the open with a mutex, so it's
1366 * really quite straightforward. The mutex locking can probably be
Linus Torvalds1da177e2005-04-16 15:20:36 -07001367 * relaxed for the (most common) case of reopening a tty.
1368 */
Alan Coxaf9b8972006-08-27 01:24:01 -07001369
Alan Cox73ec06f2008-10-13 10:42:29 +01001370struct tty_struct *tty_init_dev(struct tty_driver *driver, int idx,
1371 int first_ok)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001372{
Alan Coxbf970ee2008-10-13 10:42:39 +01001373 struct tty_struct *tty;
Alan Cox73ec06f2008-10-13 10:42:29 +01001374 int retval;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001375
Sukadev Bhattiprolu23499702008-10-13 10:41:51 +01001376 /* Check if pty master is being opened multiple times */
Alan Cox15582d32008-10-13 10:41:03 +01001377 if (driver->subtype == PTY_TYPE_MASTER &&
Alan Coxeeb89d92009-11-30 13:18:29 +00001378 (driver->flags & TTY_DRIVER_DEVPTS_MEM) && !first_ok) {
Alan Cox73ec06f2008-10-13 10:42:29 +01001379 return ERR_PTR(-EIO);
Alan Coxeeb89d92009-11-30 13:18:29 +00001380 }
Alan Cox73ec06f2008-10-13 10:42:29 +01001381
Linus Torvalds1da177e2005-04-16 15:20:36 -07001382 /*
1383 * First time open is complex, especially for PTY devices.
1384 * This code guarantees that either everything succeeds and the
1385 * TTY is ready for operation, or else the table slots are vacated
Alan Cox37bdfb02008-02-08 04:18:47 -08001386 * and the allocated memory released. (Except that the termios
Linus Torvalds1da177e2005-04-16 15:20:36 -07001387 * and locked termios may be retained.)
1388 */
1389
Alan Cox73ec06f2008-10-13 10:42:29 +01001390 if (!try_module_get(driver->owner))
1391 return ERR_PTR(-ENODEV);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001392
Linus Torvalds1da177e2005-04-16 15:20:36 -07001393 tty = alloc_tty_struct();
Jiri Slabyd5543502011-03-23 10:48:32 +01001394 if (!tty) {
1395 retval = -ENOMEM;
1396 goto err_module_put;
1397 }
Alan Coxbf970ee2008-10-13 10:42:39 +01001398 initialize_tty_struct(tty, driver, idx);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001399
Alan Cox73ec06f2008-10-13 10:42:29 +01001400 retval = tty_driver_install_tty(driver, tty);
Jiri Slabyd5543502011-03-23 10:48:32 +01001401 if (retval < 0)
Jiri Slabya9dccdd2011-03-23 10:48:36 +01001402 goto err_deinit_tty;
Alan Cox8b0a88d2008-10-13 10:42:19 +01001403
Alan Cox37bdfb02008-02-08 04:18:47 -08001404 /*
Linus Torvalds1da177e2005-04-16 15:20:36 -07001405 * Structures all installed ... call the ldisc open routines.
Christoph Hellwigd5698c22007-02-10 01:46:46 -08001406 * If we fail here just call release_tty to clean up. No need
1407 * to decrement the use counts, as release_tty doesn't care.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001408 */
Alan Coxbf970ee2008-10-13 10:42:39 +01001409 retval = tty_ldisc_setup(tty, tty->link);
Alan Cox01e1abb2008-07-22 11:16:55 +01001410 if (retval)
Jiri Slabyd5543502011-03-23 10:48:32 +01001411 goto err_release_tty;
Alan Cox73ec06f2008-10-13 10:42:29 +01001412 return tty;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001413
Jiri Slabya9dccdd2011-03-23 10:48:36 +01001414err_deinit_tty:
1415 deinitialize_tty_struct(tty);
Jiri Slabyd5543502011-03-23 10:48:32 +01001416 free_tty_struct(tty);
1417err_module_put:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001418 module_put(driver->owner);
Jiri Slabyd5543502011-03-23 10:48:32 +01001419 return ERR_PTR(retval);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001420
Christoph Hellwigd5698c22007-02-10 01:46:46 -08001421 /* call the tty release_tty routine to clean out this slot */
Jiri Slabyd5543502011-03-23 10:48:32 +01001422err_release_tty:
Akinobu Mita40509142006-09-29 02:01:27 -07001423 if (printk_ratelimit())
Alan Coxd81ed102008-10-13 10:41:42 +01001424 printk(KERN_INFO "tty_init_dev: ldisc open failed, "
Akinobu Mita40509142006-09-29 02:01:27 -07001425 "clearing slot %d\n", idx);
Christoph Hellwigd5698c22007-02-10 01:46:46 -08001426 release_tty(tty, idx);
Alan Cox73ec06f2008-10-13 10:42:29 +01001427 return ERR_PTR(retval);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001428}
1429
Alan Coxfeebed62008-10-13 10:41:30 +01001430void tty_free_termios(struct tty_struct *tty)
1431{
1432 struct ktermios *tp;
1433 int idx = tty->index;
1434 /* Kill this flag and push into drivers for locking etc */
1435 if (tty->driver->flags & TTY_DRIVER_RESET_TERMIOS) {
1436 /* FIXME: Locking on ->termios array */
1437 tp = tty->termios;
1438 tty->driver->termios[idx] = NULL;
1439 kfree(tp);
Alan Coxfeebed62008-10-13 10:41:30 +01001440 }
1441}
1442EXPORT_SYMBOL(tty_free_termios);
1443
1444void tty_shutdown(struct tty_struct *tty)
1445{
Alan Cox8b0a88d2008-10-13 10:42:19 +01001446 tty_driver_remove_tty(tty->driver, tty);
Alan Coxfeebed62008-10-13 10:41:30 +01001447 tty_free_termios(tty);
1448}
1449EXPORT_SYMBOL(tty_shutdown);
1450
Alan Coxaf9b8972006-08-27 01:24:01 -07001451/**
Christoph Hellwigd5698c22007-02-10 01:46:46 -08001452 * release_one_tty - release tty structure memory
Alan Cox9c9f4de2008-10-13 10:37:26 +01001453 * @kref: kref of tty we are obliterating
Alan Coxaf9b8972006-08-27 01:24:01 -07001454 *
1455 * Releases memory associated with a tty structure, and clears out the
1456 * driver table slots. This function is called when a device is no longer
1457 * in use. It also gets called when setup of a device fails.
1458 *
1459 * Locking:
1460 * tty_mutex - sometimes only
1461 * takes the file list lock internally when working on the list
1462 * of ttys that the driver keeps.
Alan Coxb50989d2009-09-19 13:13:22 -07001463 *
1464 * This method gets called from a work queue so that the driver private
Dave Youngf278a2f2009-09-27 16:00:42 +00001465 * cleanup ops can sleep (needed for USB at least)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001466 */
Alan Coxb50989d2009-09-19 13:13:22 -07001467static void release_one_tty(struct work_struct *work)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001468{
Alan Coxb50989d2009-09-19 13:13:22 -07001469 struct tty_struct *tty =
1470 container_of(work, struct tty_struct, hangup_work);
Alan Cox6f967f72008-10-13 10:37:36 +01001471 struct tty_driver *driver = tty->driver;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001472
Dave Youngf278a2f2009-09-27 16:00:42 +00001473 if (tty->ops->cleanup)
1474 tty->ops->cleanup(tty);
1475
Linus Torvalds1da177e2005-04-16 15:20:36 -07001476 tty->magic = 0;
Alan Cox7d7b93c2008-10-13 10:42:09 +01001477 tty_driver_kref_put(driver);
Alan Cox6f967f72008-10-13 10:37:36 +01001478 module_put(driver->owner);
Christoph Hellwigd5698c22007-02-10 01:46:46 -08001479
Nick Pigginee2ffa02010-08-18 04:37:35 +10001480 spin_lock(&tty_files_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001481 list_del_init(&tty->tty_files);
Nick Pigginee2ffa02010-08-18 04:37:35 +10001482 spin_unlock(&tty_files_lock);
Christoph Hellwigd5698c22007-02-10 01:46:46 -08001483
Oleg Nesterov6da8d862010-04-02 18:05:12 +02001484 put_pid(tty->pgrp);
1485 put_pid(tty->session);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001486 free_tty_struct(tty);
1487}
1488
Alan Coxb50989d2009-09-19 13:13:22 -07001489static void queue_release_one_tty(struct kref *kref)
1490{
1491 struct tty_struct *tty = container_of(kref, struct tty_struct, kref);
Dave Youngf278a2f2009-09-27 16:00:42 +00001492
1493 if (tty->ops->shutdown)
1494 tty->ops->shutdown(tty);
1495 else
1496 tty_shutdown(tty);
1497
Alan Coxb50989d2009-09-19 13:13:22 -07001498 /* The hangup queue is now free so we can reuse it rather than
1499 waste a chunk of memory for each port */
1500 INIT_WORK(&tty->hangup_work, release_one_tty);
1501 schedule_work(&tty->hangup_work);
1502}
1503
Christoph Hellwigd5698c22007-02-10 01:46:46 -08001504/**
Alan Cox9c9f4de2008-10-13 10:37:26 +01001505 * tty_kref_put - release a tty kref
1506 * @tty: tty device
1507 *
1508 * Release a reference to a tty device and if need be let the kref
1509 * layer destruct the object for us
1510 */
1511
1512void tty_kref_put(struct tty_struct *tty)
1513{
1514 if (tty)
Alan Coxb50989d2009-09-19 13:13:22 -07001515 kref_put(&tty->kref, queue_release_one_tty);
Alan Cox9c9f4de2008-10-13 10:37:26 +01001516}
1517EXPORT_SYMBOL(tty_kref_put);
1518
1519/**
Christoph Hellwigd5698c22007-02-10 01:46:46 -08001520 * release_tty - release tty structure memory
1521 *
1522 * Release both @tty and a possible linked partner (think pty pair),
1523 * and decrement the refcount of the backing module.
1524 *
1525 * Locking:
1526 * tty_mutex - sometimes only
1527 * takes the file list lock internally when working on the list
1528 * of ttys that the driver keeps.
1529 * FIXME: should we require tty_mutex is held here ??
Alan Cox9c9f4de2008-10-13 10:37:26 +01001530 *
Christoph Hellwigd5698c22007-02-10 01:46:46 -08001531 */
1532static void release_tty(struct tty_struct *tty, int idx)
1533{
Alan Cox9c9f4de2008-10-13 10:37:26 +01001534 /* This should always be true but check for the moment */
1535 WARN_ON(tty->index != idx);
1536
Christoph Hellwigd5698c22007-02-10 01:46:46 -08001537 if (tty->link)
Alan Cox9c9f4de2008-10-13 10:37:26 +01001538 tty_kref_put(tty->link);
1539 tty_kref_put(tty);
Christoph Hellwigd5698c22007-02-10 01:46:46 -08001540}
1541
Alan Coxeeb89d92009-11-30 13:18:29 +00001542/**
1543 * tty_release - vfs callback for close
1544 * @inode: inode of tty
1545 * @filp: file pointer for handle to tty
1546 *
1547 * Called the last time each file handle is closed that references
1548 * this tty. There may however be several such references.
1549 *
1550 * Locking:
1551 * Takes bkl. See tty_release_dev
1552 *
Linus Torvalds1da177e2005-04-16 15:20:36 -07001553 * Even releasing the tty structures is a tricky business.. We have
1554 * to be very careful that the structures are all released at the
1555 * same time, as interrupts might otherwise get the wrong pointers.
1556 *
1557 * WSH 09/09/97: rewritten to avoid some nasty race conditions that could
1558 * lead to double frees or releasing memory still in use.
1559 */
Alan Coxeeb89d92009-11-30 13:18:29 +00001560
1561int tty_release(struct inode *inode, struct file *filp)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001562{
Nick Piggind996b622010-08-18 04:37:36 +10001563 struct tty_struct *tty = file_tty(filp);
1564 struct tty_struct *o_tty;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001565 int pty_master, tty_closing, o_tty_closing, do_sleep;
Paul Fulghum14a62832006-04-10 22:54:19 -07001566 int devpts;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001567 int idx;
1568 char buf[64];
Alan Cox37bdfb02008-02-08 04:18:47 -08001569
Sukadev Bhattiprolu15f1a632008-10-13 10:42:59 +01001570 if (tty_paranoia_check(tty, inode, "tty_release_dev"))
Alan Coxeeb89d92009-11-30 13:18:29 +00001571 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001572
Arnd Bergmannec79d602010-06-01 22:53:01 +02001573 tty_lock();
Alan Coxd81ed102008-10-13 10:41:42 +01001574 check_tty_count(tty, "tty_release_dev");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001575
Arnd Bergmannec79d602010-06-01 22:53:01 +02001576 __tty_fasync(-1, filp, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001577
1578 idx = tty->index;
1579 pty_master = (tty->driver->type == TTY_DRIVER_TYPE_PTY &&
1580 tty->driver->subtype == PTY_TYPE_MASTER);
1581 devpts = (tty->driver->flags & TTY_DRIVER_DEVPTS_MEM) != 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001582 o_tty = tty->link;
1583
1584#ifdef TTY_PARANOIA_CHECK
1585 if (idx < 0 || idx >= tty->driver->num) {
Alan Coxd81ed102008-10-13 10:41:42 +01001586 printk(KERN_DEBUG "tty_release_dev: bad idx when trying to "
Linus Torvalds1da177e2005-04-16 15:20:36 -07001587 "free (%s)\n", tty->name);
Arnd Bergmannec79d602010-06-01 22:53:01 +02001588 tty_unlock();
Alan Coxeeb89d92009-11-30 13:18:29 +00001589 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001590 }
Alan Cox8b0a88d2008-10-13 10:42:19 +01001591 if (!devpts) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001592 if (tty != tty->driver->ttys[idx]) {
Arnd Bergmannec79d602010-06-01 22:53:01 +02001593 tty_unlock();
Alan Coxd81ed102008-10-13 10:41:42 +01001594 printk(KERN_DEBUG "tty_release_dev: driver.table[%d] not tty "
Linus Torvalds1da177e2005-04-16 15:20:36 -07001595 "for (%s)\n", idx, tty->name);
Alan Coxeeb89d92009-11-30 13:18:29 +00001596 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001597 }
1598 if (tty->termios != tty->driver->termios[idx]) {
Arnd Bergmannec79d602010-06-01 22:53:01 +02001599 tty_unlock();
Alan Coxd81ed102008-10-13 10:41:42 +01001600 printk(KERN_DEBUG "tty_release_dev: driver.termios[%d] not termios "
Linus Torvalds1da177e2005-04-16 15:20:36 -07001601 "for (%s)\n",
1602 idx, tty->name);
Alan Coxeeb89d92009-11-30 13:18:29 +00001603 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001604 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001605 }
1606#endif
1607
1608#ifdef TTY_DEBUG_HANGUP
Alan Coxd81ed102008-10-13 10:41:42 +01001609 printk(KERN_DEBUG "tty_release_dev of %s (tty count=%d)...",
Linus Torvalds1da177e2005-04-16 15:20:36 -07001610 tty_name(tty, buf), tty->count);
1611#endif
1612
1613#ifdef TTY_PARANOIA_CHECK
1614 if (tty->driver->other &&
1615 !(tty->driver->flags & TTY_DRIVER_DEVPTS_MEM)) {
1616 if (o_tty != tty->driver->other->ttys[idx]) {
Arnd Bergmannec79d602010-06-01 22:53:01 +02001617 tty_unlock();
Alan Coxd81ed102008-10-13 10:41:42 +01001618 printk(KERN_DEBUG "tty_release_dev: other->table[%d] "
Linus Torvalds1da177e2005-04-16 15:20:36 -07001619 "not o_tty for (%s)\n",
1620 idx, tty->name);
Alan Coxeeb89d92009-11-30 13:18:29 +00001621 return 0 ;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001622 }
1623 if (o_tty->termios != tty->driver->other->termios[idx]) {
Arnd Bergmannec79d602010-06-01 22:53:01 +02001624 tty_unlock();
Alan Coxd81ed102008-10-13 10:41:42 +01001625 printk(KERN_DEBUG "tty_release_dev: other->termios[%d] "
Linus Torvalds1da177e2005-04-16 15:20:36 -07001626 "not o_termios for (%s)\n",
1627 idx, tty->name);
Alan Coxeeb89d92009-11-30 13:18:29 +00001628 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001629 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001630 if (o_tty->link != tty) {
Arnd Bergmannec79d602010-06-01 22:53:01 +02001631 tty_unlock();
Alan Coxd81ed102008-10-13 10:41:42 +01001632 printk(KERN_DEBUG "tty_release_dev: bad pty pointers\n");
Alan Coxeeb89d92009-11-30 13:18:29 +00001633 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001634 }
1635 }
1636#endif
Alan Coxf34d7a52008-04-30 00:54:13 -07001637 if (tty->ops->close)
1638 tty->ops->close(tty, filp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001639
Arnd Bergmannec79d602010-06-01 22:53:01 +02001640 tty_unlock();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001641 /*
1642 * Sanity check: if tty->count is going to zero, there shouldn't be
1643 * any waiters on tty->read_wait or tty->write_wait. We test the
1644 * wait queues and kick everyone out _before_ actually starting to
1645 * close. This ensures that we won't block while releasing the tty
1646 * structure.
1647 *
1648 * The test for the o_tty closing is necessary, since the master and
1649 * slave sides may close in any order. If the slave side closes out
1650 * first, its count will be one, since the master side holds an open.
1651 * Thus this test wouldn't be triggered at the time the slave closes,
1652 * so we do it now.
1653 *
1654 * Note that it's possible for the tty to be opened again while we're
1655 * flushing out waiters. By recalculating the closing flags before
1656 * each iteration we avoid any problems.
1657 */
1658 while (1) {
1659 /* Guard against races with tty->count changes elsewhere and
1660 opens on /dev/tty */
Alan Cox37bdfb02008-02-08 04:18:47 -08001661
Ingo Molnar70522e12006-03-23 03:00:31 -08001662 mutex_lock(&tty_mutex);
Arnd Bergmannec79d602010-06-01 22:53:01 +02001663 tty_lock();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001664 tty_closing = tty->count <= 1;
1665 o_tty_closing = o_tty &&
1666 (o_tty->count <= (pty_master ? 1 : 0));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001667 do_sleep = 0;
1668
1669 if (tty_closing) {
1670 if (waitqueue_active(&tty->read_wait)) {
Davide Libenzi4b194492009-03-31 15:24:24 -07001671 wake_up_poll(&tty->read_wait, POLLIN);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001672 do_sleep++;
1673 }
1674 if (waitqueue_active(&tty->write_wait)) {
Davide Libenzi4b194492009-03-31 15:24:24 -07001675 wake_up_poll(&tty->write_wait, POLLOUT);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001676 do_sleep++;
1677 }
1678 }
1679 if (o_tty_closing) {
1680 if (waitqueue_active(&o_tty->read_wait)) {
Davide Libenzi4b194492009-03-31 15:24:24 -07001681 wake_up_poll(&o_tty->read_wait, POLLIN);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001682 do_sleep++;
1683 }
1684 if (waitqueue_active(&o_tty->write_wait)) {
Davide Libenzi4b194492009-03-31 15:24:24 -07001685 wake_up_poll(&o_tty->write_wait, POLLOUT);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001686 do_sleep++;
1687 }
1688 }
1689 if (!do_sleep)
1690 break;
1691
Alan Coxd81ed102008-10-13 10:41:42 +01001692 printk(KERN_WARNING "tty_release_dev: %s: read/write wait queue "
Linus Torvalds1da177e2005-04-16 15:20:36 -07001693 "active!\n", tty_name(tty, buf));
Arnd Bergmannec79d602010-06-01 22:53:01 +02001694 tty_unlock();
Ingo Molnar70522e12006-03-23 03:00:31 -08001695 mutex_unlock(&tty_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001696 schedule();
Alan Cox37bdfb02008-02-08 04:18:47 -08001697 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001698
1699 /*
Alan Cox37bdfb02008-02-08 04:18:47 -08001700 * The closing flags are now consistent with the open counts on
1701 * both sides, and we've completed the last operation that could
Linus Torvalds1da177e2005-04-16 15:20:36 -07001702 * block, so it's safe to proceed with closing.
1703 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001704 if (pty_master) {
1705 if (--o_tty->count < 0) {
Alan Coxd81ed102008-10-13 10:41:42 +01001706 printk(KERN_WARNING "tty_release_dev: bad pty slave count "
Linus Torvalds1da177e2005-04-16 15:20:36 -07001707 "(%d) for %s\n",
1708 o_tty->count, tty_name(o_tty, buf));
1709 o_tty->count = 0;
1710 }
1711 }
1712 if (--tty->count < 0) {
Alan Coxd81ed102008-10-13 10:41:42 +01001713 printk(KERN_WARNING "tty_release_dev: bad tty->count (%d) for %s\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -07001714 tty->count, tty_name(tty, buf));
1715 tty->count = 0;
1716 }
Alan Cox37bdfb02008-02-08 04:18:47 -08001717
Linus Torvalds1da177e2005-04-16 15:20:36 -07001718 /*
1719 * We've decremented tty->count, so we need to remove this file
1720 * descriptor off the tty->tty_files list; this serves two
1721 * purposes:
1722 * - check_tty_count sees the correct number of file descriptors
1723 * associated with this tty.
1724 * - do_tty_hangup no longer sees this file descriptor as
1725 * something that needs to be handled for hangups.
1726 */
Nick Piggind996b622010-08-18 04:37:36 +10001727 tty_del_file(filp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001728
1729 /*
1730 * Perform some housekeeping before deciding whether to return.
1731 *
1732 * Set the TTY_CLOSING flag if this was the last open. In the
1733 * case of a pty we may have to wait around for the other side
1734 * to close, and TTY_CLOSING makes sure we can't be reopened.
1735 */
Alan Cox37bdfb02008-02-08 04:18:47 -08001736 if (tty_closing)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001737 set_bit(TTY_CLOSING, &tty->flags);
Alan Cox37bdfb02008-02-08 04:18:47 -08001738 if (o_tty_closing)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001739 set_bit(TTY_CLOSING, &o_tty->flags);
1740
1741 /*
1742 * If _either_ side is closing, make sure there aren't any
1743 * processes that still think tty or o_tty is their controlling
1744 * tty.
1745 */
1746 if (tty_closing || o_tty_closing) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001747 read_lock(&tasklist_lock);
Peter Zijlstra24ec8392006-12-08 02:36:04 -08001748 session_clear_tty(tty->session);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001749 if (o_tty)
Peter Zijlstra24ec8392006-12-08 02:36:04 -08001750 session_clear_tty(o_tty->session);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001751 read_unlock(&tasklist_lock);
1752 }
1753
Ingo Molnar70522e12006-03-23 03:00:31 -08001754 mutex_unlock(&tty_mutex);
Paul Fulghumda965822006-02-14 13:53:00 -08001755
Linus Torvalds1da177e2005-04-16 15:20:36 -07001756 /* check whether both sides are closing ... */
Alan Coxeeb89d92009-11-30 13:18:29 +00001757 if (!tty_closing || (o_tty && !o_tty_closing)) {
Arnd Bergmannec79d602010-06-01 22:53:01 +02001758 tty_unlock();
Alan Coxeeb89d92009-11-30 13:18:29 +00001759 return 0;
1760 }
Alan Cox37bdfb02008-02-08 04:18:47 -08001761
Linus Torvalds1da177e2005-04-16 15:20:36 -07001762#ifdef TTY_DEBUG_HANGUP
1763 printk(KERN_DEBUG "freeing tty structure...");
1764#endif
1765 /*
Alan Cox01e1abb2008-07-22 11:16:55 +01001766 * Ask the line discipline code to release its structures
Linus Torvalds1da177e2005-04-16 15:20:36 -07001767 */
Alan Cox01e1abb2008-07-22 11:16:55 +01001768 tty_ldisc_release(tty, o_tty);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001769 /*
Christoph Hellwigd5698c22007-02-10 01:46:46 -08001770 * The release_tty function takes care of the details of clearing
Linus Torvalds1da177e2005-04-16 15:20:36 -07001771 * the slots and preserving the termios structure.
1772 */
Christoph Hellwigd5698c22007-02-10 01:46:46 -08001773 release_tty(tty, idx);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001774
Linus Torvalds1da177e2005-04-16 15:20:36 -07001775 /* Make this pty number available for reallocation */
Sukadev Bhattiprolu718a9162008-04-30 00:54:21 -07001776 if (devpts)
Sukadev Bhattiprolu15f1a632008-10-13 10:42:59 +01001777 devpts_kill_index(inode, idx);
Arnd Bergmannec79d602010-06-01 22:53:01 +02001778 tty_unlock();
Alan Coxeeb89d92009-11-30 13:18:29 +00001779 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001780}
1781
Alan Coxaf9b8972006-08-27 01:24:01 -07001782/**
Alan Coxeeb89d92009-11-30 13:18:29 +00001783 * tty_open - open a tty device
Alan Coxaf9b8972006-08-27 01:24:01 -07001784 * @inode: inode of device file
1785 * @filp: file pointer to tty
Linus Torvalds1da177e2005-04-16 15:20:36 -07001786 *
Alan Coxaf9b8972006-08-27 01:24:01 -07001787 * tty_open and tty_release keep up the tty count that contains the
1788 * number of opens done on a tty. We cannot use the inode-count, as
1789 * different inodes might point to the same tty.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001790 *
Alan Coxaf9b8972006-08-27 01:24:01 -07001791 * Open-counting is needed for pty masters, as well as for keeping
1792 * track of serial lines: DTR is dropped when the last close happens.
1793 * (This is not done solely through tty->count, now. - Ted 1/27/92)
1794 *
1795 * The termios state of a pty is reset on first open so that
1796 * settings don't persist across reuse.
1797 *
Alan Coxd81ed102008-10-13 10:41:42 +01001798 * Locking: tty_mutex protects tty, get_tty_driver and tty_init_dev work.
Peter Zijlstra24ec8392006-12-08 02:36:04 -08001799 * tty->count should protect the rest.
1800 * ->siglock protects ->signal/->sighand
Linus Torvalds1da177e2005-04-16 15:20:36 -07001801 */
Alan Coxaf9b8972006-08-27 01:24:01 -07001802
Alan Coxeeb89d92009-11-30 13:18:29 +00001803static int tty_open(struct inode *inode, struct file *filp)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001804{
Sukadev Bhattiprolu4a2b5fd2008-10-13 10:42:49 +01001805 struct tty_struct *tty = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001806 int noctty, retval;
1807 struct tty_driver *driver;
1808 int index;
1809 dev_t device = inode->i_rdev;
Andrew Morton846c1512009-04-02 16:56:36 -07001810 unsigned saved_flags = filp->f_flags;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001811
1812 nonseekable_open(inode, filp);
Alan Cox37bdfb02008-02-08 04:18:47 -08001813
Linus Torvalds1da177e2005-04-16 15:20:36 -07001814retry_open:
1815 noctty = filp->f_flags & O_NOCTTY;
1816 index = -1;
1817 retval = 0;
Alan Cox37bdfb02008-02-08 04:18:47 -08001818
Ingo Molnar70522e12006-03-23 03:00:31 -08001819 mutex_lock(&tty_mutex);
Arnd Bergmannec79d602010-06-01 22:53:01 +02001820 tty_lock();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001821
Alan Cox37bdfb02008-02-08 04:18:47 -08001822 if (device == MKDEV(TTYAUX_MAJOR, 0)) {
Peter Zijlstra24ec8392006-12-08 02:36:04 -08001823 tty = get_current_tty();
1824 if (!tty) {
Arnd Bergmannec79d602010-06-01 22:53:01 +02001825 tty_unlock();
Ingo Molnar70522e12006-03-23 03:00:31 -08001826 mutex_unlock(&tty_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001827 return -ENXIO;
1828 }
Alan Cox7d7b93c2008-10-13 10:42:09 +01001829 driver = tty_driver_kref_get(tty->driver);
Peter Zijlstra24ec8392006-12-08 02:36:04 -08001830 index = tty->index;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001831 filp->f_flags |= O_NONBLOCK; /* Don't let /dev/tty block */
1832 /* noctty = 1; */
Alan Cox452a00d2008-10-13 10:39:13 +01001833 /* FIXME: Should we take a driver reference ? */
1834 tty_kref_put(tty);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001835 goto got_driver;
1836 }
1837#ifdef CONFIG_VT
Alan Cox37bdfb02008-02-08 04:18:47 -08001838 if (device == MKDEV(TTY_MAJOR, 0)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001839 extern struct tty_driver *console_driver;
Alan Cox7d7b93c2008-10-13 10:42:09 +01001840 driver = tty_driver_kref_get(console_driver);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001841 index = fg_console;
1842 noctty = 1;
1843 goto got_driver;
1844 }
1845#endif
Alan Cox37bdfb02008-02-08 04:18:47 -08001846 if (device == MKDEV(TTYAUX_MAJOR, 1)) {
Will Newton296fa7f2008-12-01 11:36:06 +00001847 struct tty_driver *console_driver = console_device(&index);
1848 if (console_driver) {
1849 driver = tty_driver_kref_get(console_driver);
1850 if (driver) {
1851 /* Don't let /dev/console block */
1852 filp->f_flags |= O_NONBLOCK;
1853 noctty = 1;
1854 goto got_driver;
1855 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001856 }
Arnd Bergmannec79d602010-06-01 22:53:01 +02001857 tty_unlock();
Ingo Molnar70522e12006-03-23 03:00:31 -08001858 mutex_unlock(&tty_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001859 return -ENODEV;
1860 }
1861
1862 driver = get_tty_driver(device, &index);
1863 if (!driver) {
Arnd Bergmannec79d602010-06-01 22:53:01 +02001864 tty_unlock();
Ingo Molnar70522e12006-03-23 03:00:31 -08001865 mutex_unlock(&tty_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001866 return -ENODEV;
1867 }
1868got_driver:
Sukadev Bhattiprolu4a2b5fd2008-10-13 10:42:49 +01001869 if (!tty) {
1870 /* check whether we're reopening an existing tty */
Sukadev Bhattiprolu15f1a632008-10-13 10:42:59 +01001871 tty = tty_driver_lookup_tty(driver, inode, index);
Sukadev Bhattiprolu4a2b5fd2008-10-13 10:42:49 +01001872
Eric Paris808ffa32009-01-27 11:50:37 +00001873 if (IS_ERR(tty)) {
Arnd Bergmannec79d602010-06-01 22:53:01 +02001874 tty_unlock();
Eric Paris808ffa32009-01-27 11:50:37 +00001875 mutex_unlock(&tty_mutex);
Sukadev Bhattiprolu4a2b5fd2008-10-13 10:42:49 +01001876 return PTR_ERR(tty);
Eric Paris808ffa32009-01-27 11:50:37 +00001877 }
Sukadev Bhattiprolu4a2b5fd2008-10-13 10:42:49 +01001878 }
1879
1880 if (tty) {
1881 retval = tty_reopen(tty);
1882 if (retval)
1883 tty = ERR_PTR(retval);
1884 } else
1885 tty = tty_init_dev(driver, index, 0);
1886
Ingo Molnar70522e12006-03-23 03:00:31 -08001887 mutex_unlock(&tty_mutex);
Alan Cox7d7b93c2008-10-13 10:42:09 +01001888 tty_driver_kref_put(driver);
Alan Coxeeb89d92009-11-30 13:18:29 +00001889 if (IS_ERR(tty)) {
Arnd Bergmannec79d602010-06-01 22:53:01 +02001890 tty_unlock();
Alan Cox73ec06f2008-10-13 10:42:29 +01001891 return PTR_ERR(tty);
Alan Coxeeb89d92009-11-30 13:18:29 +00001892 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001893
Pekka Enbergf573bd12010-08-24 07:48:34 +03001894 retval = tty_add_file(tty, filp);
1895 if (retval) {
1896 tty_unlock();
Jiri Slaby02598942011-03-23 10:48:37 +01001897 tty_release(inode, filp);
Pekka Enbergf573bd12010-08-24 07:48:34 +03001898 return retval;
1899 }
Nick Piggind996b622010-08-18 04:37:36 +10001900
Linus Torvalds1da177e2005-04-16 15:20:36 -07001901 check_tty_count(tty, "tty_open");
1902 if (tty->driver->type == TTY_DRIVER_TYPE_PTY &&
1903 tty->driver->subtype == PTY_TYPE_MASTER)
1904 noctty = 1;
1905#ifdef TTY_DEBUG_HANGUP
1906 printk(KERN_DEBUG "opening %s...", tty->name);
1907#endif
Herton Ronaldo Krzesinski909bc772011-03-31 15:35:31 -03001908 if (tty->ops->open)
1909 retval = tty->ops->open(tty, filp);
1910 else
1911 retval = -ENODEV;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001912 filp->f_flags = saved_flags;
1913
Alan Cox37bdfb02008-02-08 04:18:47 -08001914 if (!retval && test_bit(TTY_EXCLUSIVE, &tty->flags) &&
1915 !capable(CAP_SYS_ADMIN))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001916 retval = -EBUSY;
1917
1918 if (retval) {
1919#ifdef TTY_DEBUG_HANGUP
1920 printk(KERN_DEBUG "error %d in opening %s...", retval,
1921 tty->name);
1922#endif
Arnd Bergmann64ba3dc2010-06-01 22:53:02 +02001923 tty_unlock(); /* need to call tty_release without BTM */
Alan Coxeeb89d92009-11-30 13:18:29 +00001924 tty_release(inode, filp);
Arnd Bergmann64ba3dc2010-06-01 22:53:02 +02001925 if (retval != -ERESTARTSYS)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001926 return retval;
Arnd Bergmann64ba3dc2010-06-01 22:53:02 +02001927
1928 if (signal_pending(current))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001929 return retval;
Arnd Bergmann64ba3dc2010-06-01 22:53:02 +02001930
Linus Torvalds1da177e2005-04-16 15:20:36 -07001931 schedule();
1932 /*
1933 * Need to reset f_op in case a hangup happened.
1934 */
Arnd Bergmann64ba3dc2010-06-01 22:53:02 +02001935 tty_lock();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001936 if (filp->f_op == &hung_up_tty_fops)
1937 filp->f_op = &tty_fops;
Arnd Bergmannec79d602010-06-01 22:53:01 +02001938 tty_unlock();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001939 goto retry_open;
1940 }
Arnd Bergmannec79d602010-06-01 22:53:01 +02001941 tty_unlock();
Alan Coxeeb89d92009-11-30 13:18:29 +00001942
Peter Zijlstra24ec8392006-12-08 02:36:04 -08001943
1944 mutex_lock(&tty_mutex);
Arnd Bergmannec79d602010-06-01 22:53:01 +02001945 tty_lock();
Peter Zijlstra24ec8392006-12-08 02:36:04 -08001946 spin_lock_irq(&current->sighand->siglock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001947 if (!noctty &&
1948 current->signal->leader &&
1949 !current->signal->tty &&
Eric W. Biedermanab521dc2007-02-12 00:53:00 -08001950 tty->session == NULL)
Eric W. Biederman2a65f1d2007-05-08 00:26:53 -07001951 __proc_set_tty(current, tty);
Peter Zijlstra24ec8392006-12-08 02:36:04 -08001952 spin_unlock_irq(&current->sighand->siglock);
Arnd Bergmannec79d602010-06-01 22:53:01 +02001953 tty_unlock();
Peter Zijlstra24ec8392006-12-08 02:36:04 -08001954 mutex_unlock(&tty_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001955 return 0;
1956}
1957
Jonathan Corbet39d95b92008-05-16 09:10:50 -06001958
Linus Torvalds1da177e2005-04-16 15:20:36 -07001959
Alan Coxaf9b8972006-08-27 01:24:01 -07001960/**
1961 * tty_poll - check tty status
1962 * @filp: file being polled
1963 * @wait: poll wait structures to update
1964 *
1965 * Call the line discipline polling method to obtain the poll
1966 * status of the device.
1967 *
1968 * Locking: locks called line discipline but ldisc poll method
1969 * may be re-entered freely by other callers.
1970 */
1971
Alan Cox37bdfb02008-02-08 04:18:47 -08001972static unsigned int tty_poll(struct file *filp, poll_table *wait)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001973{
Nick Piggind996b622010-08-18 04:37:36 +10001974 struct tty_struct *tty = file_tty(filp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001975 struct tty_ldisc *ld;
1976 int ret = 0;
1977
Josef Sipeka7113a92006-12-08 02:36:55 -08001978 if (tty_paranoia_check(tty, filp->f_path.dentry->d_inode, "tty_poll"))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001979 return 0;
Alan Cox37bdfb02008-02-08 04:18:47 -08001980
Linus Torvalds1da177e2005-04-16 15:20:36 -07001981 ld = tty_ldisc_ref_wait(tty);
Alan Coxa352def2008-07-16 21:53:12 +01001982 if (ld->ops->poll)
1983 ret = (ld->ops->poll)(tty, filp, wait);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001984 tty_ldisc_deref(ld);
1985 return ret;
1986}
1987
Arnd Bergmannec79d602010-06-01 22:53:01 +02001988static int __tty_fasync(int fd, struct file *filp, int on)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001989{
Nick Piggind996b622010-08-18 04:37:36 +10001990 struct tty_struct *tty = file_tty(filp);
Alan Cox47f86832008-04-30 00:53:30 -07001991 unsigned long flags;
Jonathan Corbet5d1e3232008-06-19 16:04:53 -06001992 int retval = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001993
Josef Sipeka7113a92006-12-08 02:36:55 -08001994 if (tty_paranoia_check(tty, filp->f_path.dentry->d_inode, "tty_fasync"))
Jonathan Corbet5d1e3232008-06-19 16:04:53 -06001995 goto out;
Alan Cox37bdfb02008-02-08 04:18:47 -08001996
Linus Torvalds1da177e2005-04-16 15:20:36 -07001997 retval = fasync_helper(fd, filp, on, &tty->fasync);
1998 if (retval <= 0)
Jonathan Corbet5d1e3232008-06-19 16:04:53 -06001999 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002000
2001 if (on) {
Eric W. Biedermanab521dc2007-02-12 00:53:00 -08002002 enum pid_type type;
2003 struct pid *pid;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002004 if (!waitqueue_active(&tty->read_wait))
2005 tty->minimum_to_wake = 1;
Alan Cox47f86832008-04-30 00:53:30 -07002006 spin_lock_irqsave(&tty->ctrl_lock, flags);
Eric W. Biedermanab521dc2007-02-12 00:53:00 -08002007 if (tty->pgrp) {
2008 pid = tty->pgrp;
2009 type = PIDTYPE_PGID;
2010 } else {
2011 pid = task_pid(current);
2012 type = PIDTYPE_PID;
2013 }
Linus Torvalds80e1e822010-02-07 10:11:23 -08002014 get_pid(pid);
Greg Kroah-Hartman70362512009-12-17 07:07:19 -08002015 spin_unlock_irqrestore(&tty->ctrl_lock, flags);
Linus Torvalds80e1e822010-02-07 10:11:23 -08002016 retval = __f_setown(filp, pid, type, 0);
2017 put_pid(pid);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002018 if (retval)
Jonathan Corbet5d1e3232008-06-19 16:04:53 -06002019 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002020 } else {
2021 if (!tty->fasync && !waitqueue_active(&tty->read_wait))
2022 tty->minimum_to_wake = N_TTY_BUF_SIZE;
2023 }
Jonathan Corbet5d1e3232008-06-19 16:04:53 -06002024 retval = 0;
2025out:
Arnd Bergmannec79d602010-06-01 22:53:01 +02002026 return retval;
2027}
2028
2029static int tty_fasync(int fd, struct file *filp, int on)
2030{
2031 int retval;
2032 tty_lock();
2033 retval = __tty_fasync(fd, filp, on);
2034 tty_unlock();
Jonathan Corbet5d1e3232008-06-19 16:04:53 -06002035 return retval;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002036}
2037
Alan Coxaf9b8972006-08-27 01:24:01 -07002038/**
2039 * tiocsti - fake input character
2040 * @tty: tty to fake input into
2041 * @p: pointer to character
2042 *
Robert P. J. Day3a4fa0a2007-10-19 23:10:43 +02002043 * Fake input to a tty device. Does the necessary locking and
Alan Coxaf9b8972006-08-27 01:24:01 -07002044 * input management.
2045 *
2046 * FIXME: does not honour flow control ??
2047 *
2048 * Locking:
2049 * Called functions take tty_ldisc_lock
2050 * current->signal->tty check is safe without locks
Alan Cox28298232006-09-29 02:00:58 -07002051 *
2052 * FIXME: may race normal receive processing
Alan Coxaf9b8972006-08-27 01:24:01 -07002053 */
2054
Linus Torvalds1da177e2005-04-16 15:20:36 -07002055static int tiocsti(struct tty_struct *tty, char __user *p)
2056{
2057 char ch, mbz = 0;
2058 struct tty_ldisc *ld;
Alan Cox37bdfb02008-02-08 04:18:47 -08002059
Linus Torvalds1da177e2005-04-16 15:20:36 -07002060 if ((current->signal->tty != tty) && !capable(CAP_SYS_ADMIN))
2061 return -EPERM;
2062 if (get_user(ch, p))
2063 return -EFAULT;
Al Viro1e641742008-12-09 09:23:33 +00002064 tty_audit_tiocsti(tty, ch);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002065 ld = tty_ldisc_ref_wait(tty);
Alan Coxa352def2008-07-16 21:53:12 +01002066 ld->ops->receive_buf(tty, &ch, &mbz, 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002067 tty_ldisc_deref(ld);
2068 return 0;
2069}
2070
Alan Coxaf9b8972006-08-27 01:24:01 -07002071/**
2072 * tiocgwinsz - implement window query ioctl
2073 * @tty; tty
2074 * @arg: user buffer for result
2075 *
Alan Cox808a0d32006-09-29 02:00:40 -07002076 * Copies the kernel idea of the window size into the user buffer.
Alan Coxaf9b8972006-08-27 01:24:01 -07002077 *
Peter Zijlstra24ec8392006-12-08 02:36:04 -08002078 * Locking: tty->termios_mutex is taken to ensure the winsize data
Alan Cox808a0d32006-09-29 02:00:40 -07002079 * is consistent.
Alan Coxaf9b8972006-08-27 01:24:01 -07002080 */
2081
Alan Cox37bdfb02008-02-08 04:18:47 -08002082static int tiocgwinsz(struct tty_struct *tty, struct winsize __user *arg)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002083{
Alan Cox808a0d32006-09-29 02:00:40 -07002084 int err;
2085
Arjan van de Ven5785c952006-09-29 02:00:43 -07002086 mutex_lock(&tty->termios_mutex);
Alan Cox808a0d32006-09-29 02:00:40 -07002087 err = copy_to_user(arg, &tty->winsize, sizeof(*arg));
Arjan van de Ven5785c952006-09-29 02:00:43 -07002088 mutex_unlock(&tty->termios_mutex);
Alan Cox808a0d32006-09-29 02:00:40 -07002089
2090 return err ? -EFAULT: 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002091}
2092
Alan Coxaf9b8972006-08-27 01:24:01 -07002093/**
Alan Cox8c9a9dd2008-08-15 10:39:38 +01002094 * tty_do_resize - resize event
2095 * @tty: tty being resized
Alan Cox8c9a9dd2008-08-15 10:39:38 +01002096 * @rows: rows (character)
2097 * @cols: cols (character)
Alan Coxaf9b8972006-08-27 01:24:01 -07002098 *
Daniel Mack3ad2f3f2010-02-03 08:01:28 +08002099 * Update the termios variables and send the necessary signals to
Alan Cox8c9a9dd2008-08-15 10:39:38 +01002100 * peform a terminal resize correctly
Alan Coxaf9b8972006-08-27 01:24:01 -07002101 */
2102
Alan Coxfc6f6232009-01-02 13:43:17 +00002103int tty_do_resize(struct tty_struct *tty, struct winsize *ws)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002104{
Alan Coxfc6f6232009-01-02 13:43:17 +00002105 struct pid *pgrp;
Alan Cox47f86832008-04-30 00:53:30 -07002106 unsigned long flags;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002107
Alan Coxfc6f6232009-01-02 13:43:17 +00002108 /* Lock the tty */
2109 mutex_lock(&tty->termios_mutex);
2110 if (!memcmp(ws, &tty->winsize, sizeof(*ws)))
Alan Coxca9bda02006-09-29 02:00:03 -07002111 goto done;
Alan Cox47f86832008-04-30 00:53:30 -07002112 /* Get the PID values and reference them so we can
2113 avoid holding the tty ctrl lock while sending signals */
2114 spin_lock_irqsave(&tty->ctrl_lock, flags);
2115 pgrp = get_pid(tty->pgrp);
Alan Cox47f86832008-04-30 00:53:30 -07002116 spin_unlock_irqrestore(&tty->ctrl_lock, flags);
2117
2118 if (pgrp)
2119 kill_pgrp(pgrp, SIGWINCH, 1);
Alan Cox47f86832008-04-30 00:53:30 -07002120 put_pid(pgrp);
Alan Cox47f86832008-04-30 00:53:30 -07002121
Alan Cox8c9a9dd2008-08-15 10:39:38 +01002122 tty->winsize = *ws;
Alan Coxca9bda02006-09-29 02:00:03 -07002123done:
Alan Coxfc6f6232009-01-02 13:43:17 +00002124 mutex_unlock(&tty->termios_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002125 return 0;
2126}
2127
Alan Coxaf9b8972006-08-27 01:24:01 -07002128/**
Alan Cox8c9a9dd2008-08-15 10:39:38 +01002129 * tiocswinsz - implement window size set ioctl
Alan Coxfc6f6232009-01-02 13:43:17 +00002130 * @tty; tty side of tty
Alan Cox8c9a9dd2008-08-15 10:39:38 +01002131 * @arg: user buffer for result
2132 *
2133 * Copies the user idea of the window size to the kernel. Traditionally
2134 * this is just advisory information but for the Linux console it
2135 * actually has driver level meaning and triggers a VC resize.
2136 *
2137 * Locking:
Lucas De Marchi25985ed2011-03-30 22:57:33 -03002138 * Driver dependent. The default do_resize method takes the
Alan Cox8c9a9dd2008-08-15 10:39:38 +01002139 * tty termios mutex and ctrl_lock. The console takes its own lock
2140 * then calls into the default method.
2141 */
2142
Alan Coxfc6f6232009-01-02 13:43:17 +00002143static int tiocswinsz(struct tty_struct *tty, struct winsize __user *arg)
Alan Cox8c9a9dd2008-08-15 10:39:38 +01002144{
2145 struct winsize tmp_ws;
2146 if (copy_from_user(&tmp_ws, arg, sizeof(*arg)))
2147 return -EFAULT;
2148
2149 if (tty->ops->resize)
Alan Coxfc6f6232009-01-02 13:43:17 +00002150 return tty->ops->resize(tty, &tmp_ws);
Alan Cox8c9a9dd2008-08-15 10:39:38 +01002151 else
Alan Coxfc6f6232009-01-02 13:43:17 +00002152 return tty_do_resize(tty, &tmp_ws);
Alan Cox8c9a9dd2008-08-15 10:39:38 +01002153}
2154
2155/**
Alan Coxaf9b8972006-08-27 01:24:01 -07002156 * tioccons - allow admin to move logical console
2157 * @file: the file to become console
2158 *
Lucas De Marchi25985ed2011-03-30 22:57:33 -03002159 * Allow the administrator to move the redirected console device
Alan Coxaf9b8972006-08-27 01:24:01 -07002160 *
2161 * Locking: uses redirect_lock to guard the redirect information
2162 */
2163
Linus Torvalds1da177e2005-04-16 15:20:36 -07002164static int tioccons(struct file *file)
2165{
2166 if (!capable(CAP_SYS_ADMIN))
2167 return -EPERM;
2168 if (file->f_op->write == redirected_tty_write) {
2169 struct file *f;
2170 spin_lock(&redirect_lock);
2171 f = redirect;
2172 redirect = NULL;
2173 spin_unlock(&redirect_lock);
2174 if (f)
2175 fput(f);
2176 return 0;
2177 }
2178 spin_lock(&redirect_lock);
2179 if (redirect) {
2180 spin_unlock(&redirect_lock);
2181 return -EBUSY;
2182 }
2183 get_file(file);
2184 redirect = file;
2185 spin_unlock(&redirect_lock);
2186 return 0;
2187}
2188
Alan Coxaf9b8972006-08-27 01:24:01 -07002189/**
2190 * fionbio - non blocking ioctl
2191 * @file: file to set blocking value
2192 * @p: user parameter
2193 *
2194 * Historical tty interfaces had a blocking control ioctl before
2195 * the generic functionality existed. This piece of history is preserved
2196 * in the expected tty API of posix OS's.
2197 *
Alan Cox6146b9a2009-09-19 13:13:19 -07002198 * Locking: none, the open file handle ensures it won't go away.
Alan Coxaf9b8972006-08-27 01:24:01 -07002199 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002200
2201static int fionbio(struct file *file, int __user *p)
2202{
2203 int nonblock;
2204
2205 if (get_user(nonblock, p))
2206 return -EFAULT;
2207
Jonathan Corbetdb1dd4d2009-02-06 15:25:24 -07002208 spin_lock(&file->f_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002209 if (nonblock)
2210 file->f_flags |= O_NONBLOCK;
2211 else
2212 file->f_flags &= ~O_NONBLOCK;
Jonathan Corbetdb1dd4d2009-02-06 15:25:24 -07002213 spin_unlock(&file->f_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002214 return 0;
2215}
2216
Alan Coxaf9b8972006-08-27 01:24:01 -07002217/**
2218 * tiocsctty - set controlling tty
2219 * @tty: tty structure
2220 * @arg: user argument
2221 *
2222 * This ioctl is used to manage job control. It permits a session
2223 * leader to set this tty as the controlling tty for the session.
2224 *
2225 * Locking:
Alan Cox28298232006-09-29 02:00:58 -07002226 * Takes tty_mutex() to protect tty instance
Peter Zijlstra24ec8392006-12-08 02:36:04 -08002227 * Takes tasklist_lock internally to walk sessions
2228 * Takes ->siglock() when updating signal->tty
Alan Coxaf9b8972006-08-27 01:24:01 -07002229 */
2230
Linus Torvalds1da177e2005-04-16 15:20:36 -07002231static int tiocsctty(struct tty_struct *tty, int arg)
2232{
Peter Zijlstra24ec8392006-12-08 02:36:04 -08002233 int ret = 0;
Eric W. Biedermanab521dc2007-02-12 00:53:00 -08002234 if (current->signal->leader && (task_session(current) == tty->session))
Peter Zijlstra24ec8392006-12-08 02:36:04 -08002235 return ret;
2236
2237 mutex_lock(&tty_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002238 /*
2239 * The process must be a session leader and
2240 * not have a controlling tty already.
2241 */
Peter Zijlstra24ec8392006-12-08 02:36:04 -08002242 if (!current->signal->leader || current->signal->tty) {
2243 ret = -EPERM;
2244 goto unlock;
2245 }
2246
Eric W. Biedermanab521dc2007-02-12 00:53:00 -08002247 if (tty->session) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002248 /*
2249 * This tty is already the controlling
2250 * tty for another session group!
2251 */
Alan Cox37bdfb02008-02-08 04:18:47 -08002252 if (arg == 1 && capable(CAP_SYS_ADMIN)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002253 /*
2254 * Steal it away
2255 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002256 read_lock(&tasklist_lock);
Peter Zijlstra24ec8392006-12-08 02:36:04 -08002257 session_clear_tty(tty->session);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002258 read_unlock(&tasklist_lock);
Peter Zijlstra24ec8392006-12-08 02:36:04 -08002259 } else {
2260 ret = -EPERM;
2261 goto unlock;
2262 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002263 }
Peter Zijlstra24ec8392006-12-08 02:36:04 -08002264 proc_set_tty(current, tty);
2265unlock:
Alan Cox28298232006-09-29 02:00:58 -07002266 mutex_unlock(&tty_mutex);
Peter Zijlstra24ec8392006-12-08 02:36:04 -08002267 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002268}
2269
Alan Coxaf9b8972006-08-27 01:24:01 -07002270/**
Alan Cox5d0fdf12008-04-30 00:53:31 -07002271 * tty_get_pgrp - return a ref counted pgrp pid
2272 * @tty: tty to read
2273 *
2274 * Returns a refcounted instance of the pid struct for the process
2275 * group controlling the tty.
2276 */
2277
2278struct pid *tty_get_pgrp(struct tty_struct *tty)
2279{
2280 unsigned long flags;
2281 struct pid *pgrp;
2282
2283 spin_lock_irqsave(&tty->ctrl_lock, flags);
2284 pgrp = get_pid(tty->pgrp);
2285 spin_unlock_irqrestore(&tty->ctrl_lock, flags);
2286
2287 return pgrp;
2288}
2289EXPORT_SYMBOL_GPL(tty_get_pgrp);
2290
2291/**
Alan Coxaf9b8972006-08-27 01:24:01 -07002292 * tiocgpgrp - get process group
2293 * @tty: tty passed by user
Lucas De Marchi25985ed2011-03-30 22:57:33 -03002294 * @real_tty: tty side of the tty passed by the user if a pty else the tty
Alan Coxaf9b8972006-08-27 01:24:01 -07002295 * @p: returned pid
2296 *
2297 * Obtain the process group of the tty. If there is no process group
2298 * return an error.
2299 *
Peter Zijlstra24ec8392006-12-08 02:36:04 -08002300 * Locking: none. Reference to current->signal->tty is safe.
Alan Coxaf9b8972006-08-27 01:24:01 -07002301 */
2302
Linus Torvalds1da177e2005-04-16 15:20:36 -07002303static int tiocgpgrp(struct tty_struct *tty, struct tty_struct *real_tty, pid_t __user *p)
2304{
Alan Cox5d0fdf12008-04-30 00:53:31 -07002305 struct pid *pid;
2306 int ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002307 /*
2308 * (tty == real_tty) is a cheap way of
2309 * testing if the tty is NOT a master pty.
2310 */
2311 if (tty == real_tty && current->signal->tty != real_tty)
2312 return -ENOTTY;
Alan Cox5d0fdf12008-04-30 00:53:31 -07002313 pid = tty_get_pgrp(real_tty);
2314 ret = put_user(pid_vnr(pid), p);
2315 put_pid(pid);
2316 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002317}
2318
Alan Coxaf9b8972006-08-27 01:24:01 -07002319/**
2320 * tiocspgrp - attempt to set process group
2321 * @tty: tty passed by user
2322 * @real_tty: tty side device matching tty passed by user
2323 * @p: pid pointer
2324 *
2325 * Set the process group of the tty to the session passed. Only
2326 * permitted where the tty session is our session.
2327 *
Alan Cox47f86832008-04-30 00:53:30 -07002328 * Locking: RCU, ctrl lock
Alan Coxaf9b8972006-08-27 01:24:01 -07002329 */
2330
Linus Torvalds1da177e2005-04-16 15:20:36 -07002331static int tiocspgrp(struct tty_struct *tty, struct tty_struct *real_tty, pid_t __user *p)
2332{
Eric W. Biederman04a2e6a2007-02-12 00:52:56 -08002333 struct pid *pgrp;
2334 pid_t pgrp_nr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002335 int retval = tty_check_change(real_tty);
Alan Cox47f86832008-04-30 00:53:30 -07002336 unsigned long flags;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002337
2338 if (retval == -EIO)
2339 return -ENOTTY;
2340 if (retval)
2341 return retval;
2342 if (!current->signal->tty ||
2343 (current->signal->tty != real_tty) ||
Eric W. Biedermanab521dc2007-02-12 00:53:00 -08002344 (real_tty->session != task_session(current)))
Linus Torvalds1da177e2005-04-16 15:20:36 -07002345 return -ENOTTY;
Eric W. Biederman04a2e6a2007-02-12 00:52:56 -08002346 if (get_user(pgrp_nr, p))
Linus Torvalds1da177e2005-04-16 15:20:36 -07002347 return -EFAULT;
Eric W. Biederman04a2e6a2007-02-12 00:52:56 -08002348 if (pgrp_nr < 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002349 return -EINVAL;
Eric W. Biederman04a2e6a2007-02-12 00:52:56 -08002350 rcu_read_lock();
Pavel Emelyanovb4888932007-10-18 23:40:14 -07002351 pgrp = find_vpid(pgrp_nr);
Eric W. Biederman04a2e6a2007-02-12 00:52:56 -08002352 retval = -ESRCH;
2353 if (!pgrp)
2354 goto out_unlock;
2355 retval = -EPERM;
2356 if (session_of_pgrp(pgrp) != task_session(current))
2357 goto out_unlock;
2358 retval = 0;
Alan Cox47f86832008-04-30 00:53:30 -07002359 spin_lock_irqsave(&tty->ctrl_lock, flags);
Eric W. Biedermanab521dc2007-02-12 00:53:00 -08002360 put_pid(real_tty->pgrp);
2361 real_tty->pgrp = get_pid(pgrp);
Alan Cox47f86832008-04-30 00:53:30 -07002362 spin_unlock_irqrestore(&tty->ctrl_lock, flags);
Eric W. Biederman04a2e6a2007-02-12 00:52:56 -08002363out_unlock:
2364 rcu_read_unlock();
2365 return retval;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002366}
2367
Alan Coxaf9b8972006-08-27 01:24:01 -07002368/**
2369 * tiocgsid - get session id
2370 * @tty: tty passed by user
Lucas De Marchi25985ed2011-03-30 22:57:33 -03002371 * @real_tty: tty side of the tty passed by the user if a pty else the tty
Alan Coxaf9b8972006-08-27 01:24:01 -07002372 * @p: pointer to returned session id
2373 *
2374 * Obtain the session id of the tty. If there is no session
2375 * return an error.
2376 *
Peter Zijlstra24ec8392006-12-08 02:36:04 -08002377 * Locking: none. Reference to current->signal->tty is safe.
Alan Coxaf9b8972006-08-27 01:24:01 -07002378 */
2379
Linus Torvalds1da177e2005-04-16 15:20:36 -07002380static int tiocgsid(struct tty_struct *tty, struct tty_struct *real_tty, pid_t __user *p)
2381{
2382 /*
2383 * (tty == real_tty) is a cheap way of
2384 * testing if the tty is NOT a master pty.
2385 */
2386 if (tty == real_tty && current->signal->tty != real_tty)
2387 return -ENOTTY;
Eric W. Biedermanab521dc2007-02-12 00:53:00 -08002388 if (!real_tty->session)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002389 return -ENOTTY;
Pavel Emelyanovb4888932007-10-18 23:40:14 -07002390 return put_user(pid_vnr(real_tty->session), p);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002391}
2392
Alan Coxaf9b8972006-08-27 01:24:01 -07002393/**
2394 * tiocsetd - set line discipline
2395 * @tty: tty device
2396 * @p: pointer to user data
2397 *
2398 * Set the line discipline according to user request.
2399 *
2400 * Locking: see tty_set_ldisc, this function is just a helper
2401 */
2402
Linus Torvalds1da177e2005-04-16 15:20:36 -07002403static int tiocsetd(struct tty_struct *tty, int __user *p)
2404{
2405 int ldisc;
Alan Cox04f378b2008-04-30 00:53:29 -07002406 int ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002407
2408 if (get_user(ldisc, p))
2409 return -EFAULT;
Alan Cox04f378b2008-04-30 00:53:29 -07002410
Alan Cox04f378b2008-04-30 00:53:29 -07002411 ret = tty_set_ldisc(tty, ldisc);
Alan Cox04f378b2008-04-30 00:53:29 -07002412
2413 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002414}
2415
Alan Coxaf9b8972006-08-27 01:24:01 -07002416/**
2417 * send_break - performed time break
2418 * @tty: device to break on
2419 * @duration: timeout in mS
2420 *
2421 * Perform a timed break on hardware that lacks its own driver level
2422 * timed break functionality.
2423 *
2424 * Locking:
Alan Cox28298232006-09-29 02:00:58 -07002425 * atomic_write_lock serializes
Alan Coxaf9b8972006-08-27 01:24:01 -07002426 *
Alan Coxaf9b8972006-08-27 01:24:01 -07002427 */
2428
Domen Puncerb20f3ae2005-06-25 14:58:42 -07002429static int send_break(struct tty_struct *tty, unsigned int duration)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002430{
Alan Cox9e989662008-07-22 11:18:03 +01002431 int retval;
2432
2433 if (tty->ops->break_ctl == NULL)
2434 return 0;
2435
2436 if (tty->driver->flags & TTY_DRIVER_HARDWARE_BREAK)
2437 retval = tty->ops->break_ctl(tty, duration);
2438 else {
2439 /* Do the work ourselves */
2440 if (tty_write_lock(tty, 0) < 0)
2441 return -EINTR;
2442 retval = tty->ops->break_ctl(tty, -1);
2443 if (retval)
2444 goto out;
2445 if (!signal_pending(current))
2446 msleep_interruptible(duration);
2447 retval = tty->ops->break_ctl(tty, 0);
2448out:
2449 tty_write_unlock(tty);
2450 if (signal_pending(current))
2451 retval = -EINTR;
2452 }
2453 return retval;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002454}
2455
Alan Coxaf9b8972006-08-27 01:24:01 -07002456/**
Alan Coxf34d7a52008-04-30 00:54:13 -07002457 * tty_tiocmget - get modem status
Alan Coxaf9b8972006-08-27 01:24:01 -07002458 * @tty: tty device
2459 * @file: user file pointer
2460 * @p: pointer to result
2461 *
2462 * Obtain the modem status bits from the tty driver if the feature
2463 * is supported. Return -EINVAL if it is not available.
2464 *
2465 * Locking: none (up to the driver)
2466 */
2467
Alan Cox60b33c12011-02-14 16:26:14 +00002468static int tty_tiocmget(struct tty_struct *tty, int __user *p)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002469{
2470 int retval = -EINVAL;
2471
Alan Coxf34d7a52008-04-30 00:54:13 -07002472 if (tty->ops->tiocmget) {
Alan Cox60b33c12011-02-14 16:26:14 +00002473 retval = tty->ops->tiocmget(tty);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002474
2475 if (retval >= 0)
2476 retval = put_user(retval, p);
2477 }
2478 return retval;
2479}
2480
Alan Coxaf9b8972006-08-27 01:24:01 -07002481/**
Alan Coxf34d7a52008-04-30 00:54:13 -07002482 * tty_tiocmset - set modem status
Alan Coxaf9b8972006-08-27 01:24:01 -07002483 * @tty: tty device
Alan Coxaf9b8972006-08-27 01:24:01 -07002484 * @cmd: command - clear bits, set bits or set all
2485 * @p: pointer to desired bits
2486 *
2487 * Set the modem status bits from the tty driver if the feature
2488 * is supported. Return -EINVAL if it is not available.
2489 *
2490 * Locking: none (up to the driver)
2491 */
2492
Alan Cox20b9d172011-02-14 16:26:50 +00002493static int tty_tiocmset(struct tty_struct *tty, unsigned int cmd,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002494 unsigned __user *p)
2495{
Alan Coxae677512008-07-16 21:56:54 +01002496 int retval;
2497 unsigned int set, clear, val;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002498
Alan Coxae677512008-07-16 21:56:54 +01002499 if (tty->ops->tiocmset == NULL)
2500 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002501
Alan Coxae677512008-07-16 21:56:54 +01002502 retval = get_user(val, p);
2503 if (retval)
2504 return retval;
2505 set = clear = 0;
2506 switch (cmd) {
2507 case TIOCMBIS:
2508 set = val;
2509 break;
2510 case TIOCMBIC:
2511 clear = val;
2512 break;
2513 case TIOCMSET:
2514 set = val;
2515 clear = ~val;
2516 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002517 }
Alan Coxae677512008-07-16 21:56:54 +01002518 set &= TIOCM_DTR|TIOCM_RTS|TIOCM_OUT1|TIOCM_OUT2|TIOCM_LOOP;
2519 clear &= TIOCM_DTR|TIOCM_RTS|TIOCM_OUT1|TIOCM_OUT2|TIOCM_LOOP;
Alan Cox20b9d172011-02-14 16:26:50 +00002520 return tty->ops->tiocmset(tty, set, clear);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002521}
2522
Alan Coxd281da72010-09-16 18:21:24 +01002523static int tty_tiocgicount(struct tty_struct *tty, void __user *arg)
2524{
2525 int retval = -EINVAL;
2526 struct serial_icounter_struct icount;
2527 memset(&icount, 0, sizeof(icount));
2528 if (tty->ops->get_icount)
2529 retval = tty->ops->get_icount(tty, &icount);
2530 if (retval != 0)
2531 return retval;
2532 if (copy_to_user(arg, &icount, sizeof(icount)))
2533 return -EFAULT;
2534 return 0;
2535}
2536
Alan Coxe8b70e72009-06-11 12:48:02 +01002537struct tty_struct *tty_pair_get_tty(struct tty_struct *tty)
2538{
2539 if (tty->driver->type == TTY_DRIVER_TYPE_PTY &&
2540 tty->driver->subtype == PTY_TYPE_MASTER)
2541 tty = tty->link;
2542 return tty;
2543}
2544EXPORT_SYMBOL(tty_pair_get_tty);
2545
2546struct tty_struct *tty_pair_get_pty(struct tty_struct *tty)
2547{
2548 if (tty->driver->type == TTY_DRIVER_TYPE_PTY &&
2549 tty->driver->subtype == PTY_TYPE_MASTER)
2550 return tty;
2551 return tty->link;
2552}
2553EXPORT_SYMBOL(tty_pair_get_pty);
2554
Linus Torvalds1da177e2005-04-16 15:20:36 -07002555/*
2556 * Split this up, as gcc can choke on it otherwise..
2557 */
Alan Cox04f378b2008-04-30 00:53:29 -07002558long tty_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002559{
Nick Piggind996b622010-08-18 04:37:36 +10002560 struct tty_struct *tty = file_tty(file);
2561 struct tty_struct *real_tty;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002562 void __user *p = (void __user *)arg;
2563 int retval;
2564 struct tty_ldisc *ld;
Alan Cox04f378b2008-04-30 00:53:29 -07002565 struct inode *inode = file->f_dentry->d_inode;
Alan Cox37bdfb02008-02-08 04:18:47 -08002566
Linus Torvalds1da177e2005-04-16 15:20:36 -07002567 if (tty_paranoia_check(tty, inode, "tty_ioctl"))
2568 return -EINVAL;
2569
Alan Coxe8b70e72009-06-11 12:48:02 +01002570 real_tty = tty_pair_get_tty(tty);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002571
2572 /*
2573 * Factor out some common prep work
2574 */
2575 switch (cmd) {
2576 case TIOCSETD:
2577 case TIOCSBRK:
2578 case TIOCCBRK:
2579 case TCSBRK:
Alan Cox37bdfb02008-02-08 04:18:47 -08002580 case TCSBRKP:
Linus Torvalds1da177e2005-04-16 15:20:36 -07002581 retval = tty_check_change(tty);
2582 if (retval)
2583 return retval;
2584 if (cmd != TIOCCBRK) {
2585 tty_wait_until_sent(tty, 0);
2586 if (signal_pending(current))
2587 return -EINTR;
2588 }
2589 break;
2590 }
2591
Alan Cox9e989662008-07-22 11:18:03 +01002592 /*
2593 * Now do the stuff.
2594 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002595 switch (cmd) {
Alan Cox37bdfb02008-02-08 04:18:47 -08002596 case TIOCSTI:
2597 return tiocsti(tty, p);
2598 case TIOCGWINSZ:
Alan Cox8f520022008-10-13 10:38:46 +01002599 return tiocgwinsz(real_tty, p);
Alan Cox37bdfb02008-02-08 04:18:47 -08002600 case TIOCSWINSZ:
Alan Coxfc6f6232009-01-02 13:43:17 +00002601 return tiocswinsz(real_tty, p);
Alan Cox37bdfb02008-02-08 04:18:47 -08002602 case TIOCCONS:
2603 return real_tty != tty ? -EINVAL : tioccons(file);
2604 case FIONBIO:
2605 return fionbio(file, p);
2606 case TIOCEXCL:
2607 set_bit(TTY_EXCLUSIVE, &tty->flags);
2608 return 0;
2609 case TIOCNXCL:
2610 clear_bit(TTY_EXCLUSIVE, &tty->flags);
2611 return 0;
2612 case TIOCNOTTY:
2613 if (current->signal->tty != tty)
2614 return -ENOTTY;
2615 no_tty();
2616 return 0;
2617 case TIOCSCTTY:
2618 return tiocsctty(tty, arg);
2619 case TIOCGPGRP:
2620 return tiocgpgrp(tty, real_tty, p);
2621 case TIOCSPGRP:
2622 return tiocspgrp(tty, real_tty, p);
2623 case TIOCGSID:
2624 return tiocgsid(tty, real_tty, p);
2625 case TIOCGETD:
Alan Coxc65c9bc2009-06-11 12:50:12 +01002626 return put_user(tty->ldisc->ops->num, (int __user *)p);
Alan Cox37bdfb02008-02-08 04:18:47 -08002627 case TIOCSETD:
2628 return tiocsetd(tty, p);
Kay Sievers3c95c982011-02-17 18:39:28 +01002629 case TIOCVHANGUP:
2630 if (!capable(CAP_SYS_ADMIN))
2631 return -EPERM;
2632 tty_vhangup(tty);
2633 return 0;
Werner Finkb7b8de02010-12-03 12:48:23 +01002634 case TIOCGDEV:
2635 {
2636 unsigned int ret = new_encode_dev(tty_devnum(real_tty));
2637 return put_user(ret, (unsigned int __user *)p);
2638 }
Alan Cox37bdfb02008-02-08 04:18:47 -08002639 /*
2640 * Break handling
2641 */
2642 case TIOCSBRK: /* Turn break on, unconditionally */
Alan Coxf34d7a52008-04-30 00:54:13 -07002643 if (tty->ops->break_ctl)
Alan Cox9e989662008-07-22 11:18:03 +01002644 return tty->ops->break_ctl(tty, -1);
Alan Cox37bdfb02008-02-08 04:18:47 -08002645 return 0;
Alan Cox37bdfb02008-02-08 04:18:47 -08002646 case TIOCCBRK: /* Turn break off, unconditionally */
Alan Coxf34d7a52008-04-30 00:54:13 -07002647 if (tty->ops->break_ctl)
Alan Cox9e989662008-07-22 11:18:03 +01002648 return tty->ops->break_ctl(tty, 0);
Alan Cox37bdfb02008-02-08 04:18:47 -08002649 return 0;
2650 case TCSBRK: /* SVID version: non-zero arg --> no break */
2651 /* non-zero arg means wait for all output data
2652 * to be sent (performed above) but don't send break.
2653 * This is used by the tcdrain() termios function.
Linus Torvalds1da177e2005-04-16 15:20:36 -07002654 */
Alan Cox37bdfb02008-02-08 04:18:47 -08002655 if (!arg)
2656 return send_break(tty, 250);
2657 return 0;
2658 case TCSBRKP: /* support for POSIX tcsendbreak() */
2659 return send_break(tty, arg ? arg*100 : 250);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002660
Alan Cox37bdfb02008-02-08 04:18:47 -08002661 case TIOCMGET:
Alan Cox60b33c12011-02-14 16:26:14 +00002662 return tty_tiocmget(tty, p);
Alan Cox37bdfb02008-02-08 04:18:47 -08002663 case TIOCMSET:
2664 case TIOCMBIC:
2665 case TIOCMBIS:
Alan Cox20b9d172011-02-14 16:26:50 +00002666 return tty_tiocmset(tty, cmd, p);
Alan Coxd281da72010-09-16 18:21:24 +01002667 case TIOCGICOUNT:
2668 retval = tty_tiocgicount(tty, p);
2669 /* For the moment allow fall through to the old method */
2670 if (retval != -EINVAL)
2671 return retval;
2672 break;
Alan Cox37bdfb02008-02-08 04:18:47 -08002673 case TCFLSH:
2674 switch (arg) {
2675 case TCIFLUSH:
2676 case TCIOFLUSH:
2677 /* flush tty buffer and allow ldisc to process ioctl */
2678 tty_buffer_flush(tty);
Paul Fulghumc5c34d42007-05-12 10:36:55 -07002679 break;
Alan Cox37bdfb02008-02-08 04:18:47 -08002680 }
2681 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002682 }
Alan Coxf34d7a52008-04-30 00:54:13 -07002683 if (tty->ops->ioctl) {
Alan Cox6caa76b2011-02-14 16:27:22 +00002684 retval = (tty->ops->ioctl)(tty, cmd, arg);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002685 if (retval != -ENOIOCTLCMD)
2686 return retval;
2687 }
2688 ld = tty_ldisc_ref_wait(tty);
2689 retval = -EINVAL;
Alan Coxa352def2008-07-16 21:53:12 +01002690 if (ld->ops->ioctl) {
2691 retval = ld->ops->ioctl(tty, file, cmd, arg);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002692 if (retval == -ENOIOCTLCMD)
2693 retval = -EINVAL;
2694 }
2695 tty_ldisc_deref(ld);
2696 return retval;
2697}
2698
Paul Fulghume10cc1d2007-05-10 22:22:50 -07002699#ifdef CONFIG_COMPAT
Alan Cox37bdfb02008-02-08 04:18:47 -08002700static long tty_compat_ioctl(struct file *file, unsigned int cmd,
Paul Fulghume10cc1d2007-05-10 22:22:50 -07002701 unsigned long arg)
2702{
2703 struct inode *inode = file->f_dentry->d_inode;
Nick Piggind996b622010-08-18 04:37:36 +10002704 struct tty_struct *tty = file_tty(file);
Paul Fulghume10cc1d2007-05-10 22:22:50 -07002705 struct tty_ldisc *ld;
2706 int retval = -ENOIOCTLCMD;
2707
2708 if (tty_paranoia_check(tty, inode, "tty_ioctl"))
2709 return -EINVAL;
2710
Alan Coxf34d7a52008-04-30 00:54:13 -07002711 if (tty->ops->compat_ioctl) {
Alan Cox6caa76b2011-02-14 16:27:22 +00002712 retval = (tty->ops->compat_ioctl)(tty, cmd, arg);
Paul Fulghume10cc1d2007-05-10 22:22:50 -07002713 if (retval != -ENOIOCTLCMD)
2714 return retval;
2715 }
2716
2717 ld = tty_ldisc_ref_wait(tty);
Alan Coxa352def2008-07-16 21:53:12 +01002718 if (ld->ops->compat_ioctl)
2719 retval = ld->ops->compat_ioctl(tty, file, cmd, arg);
Paul Fulghume10cc1d2007-05-10 22:22:50 -07002720 tty_ldisc_deref(ld);
2721
2722 return retval;
2723}
2724#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07002725
2726/*
2727 * This implements the "Secure Attention Key" --- the idea is to
2728 * prevent trojan horses by killing all processes associated with this
2729 * tty when the user hits the "Secure Attention Key". Required for
2730 * super-paranoid applications --- see the Orange Book for more details.
Alan Cox37bdfb02008-02-08 04:18:47 -08002731 *
Linus Torvalds1da177e2005-04-16 15:20:36 -07002732 * This code could be nicer; ideally it should send a HUP, wait a few
2733 * seconds, then send a INT, and then a KILL signal. But you then
2734 * have to coordinate with the init process, since all processes associated
2735 * with the current tty must be dead before the new getty is allowed
2736 * to spawn.
2737 *
2738 * Now, if it would be correct ;-/ The current code has a nasty hole -
2739 * it doesn't catch files in flight. We may send the descriptor to ourselves
2740 * via AF_UNIX socket, close it and later fetch from socket. FIXME.
2741 *
2742 * Nasty bug: do_SAK is being called in interrupt context. This can
2743 * deadlock. We punt it up to process context. AKPM - 16Mar2001
2744 */
Eric W. Biederman8b6312f2007-02-10 01:44:34 -08002745void __do_SAK(struct tty_struct *tty)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002746{
2747#ifdef TTY_SOFT_SAK
2748 tty_hangup(tty);
2749#else
Eric W. Biederman652486f2006-03-28 16:11:02 -08002750 struct task_struct *g, *p;
Eric W. Biedermanab521dc2007-02-12 00:53:00 -08002751 struct pid *session;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002752 int i;
2753 struct file *filp;
Dipankar Sarmabadf1662005-09-09 13:04:10 -07002754 struct fdtable *fdt;
Alan Cox37bdfb02008-02-08 04:18:47 -08002755
Linus Torvalds1da177e2005-04-16 15:20:36 -07002756 if (!tty)
2757 return;
Peter Zijlstra24ec8392006-12-08 02:36:04 -08002758 session = tty->session;
Alan Cox37bdfb02008-02-08 04:18:47 -08002759
Dan Carpenterb3f13de2006-12-13 00:35:09 -08002760 tty_ldisc_flush(tty);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002761
Alan Coxf34d7a52008-04-30 00:54:13 -07002762 tty_driver_flush_buffer(tty);
Alan Cox37bdfb02008-02-08 04:18:47 -08002763
Linus Torvalds1da177e2005-04-16 15:20:36 -07002764 read_lock(&tasklist_lock);
Eric W. Biederman652486f2006-03-28 16:11:02 -08002765 /* Kill the entire session */
Eric W. Biedermanab521dc2007-02-12 00:53:00 -08002766 do_each_pid_task(session, PIDTYPE_SID, p) {
Eric W. Biederman652486f2006-03-28 16:11:02 -08002767 printk(KERN_NOTICE "SAK: killed process %d"
Oleg Nesterov1b0f7ff2009-04-02 16:58:39 -07002768 " (%s): task_session(p)==tty->session\n",
Pavel Emelyanovba25f9d2007-10-18 23:40:40 -07002769 task_pid_nr(p), p->comm);
Eric W. Biederman652486f2006-03-28 16:11:02 -08002770 send_sig(SIGKILL, p, 1);
Eric W. Biedermanab521dc2007-02-12 00:53:00 -08002771 } while_each_pid_task(session, PIDTYPE_SID, p);
Eric W. Biederman652486f2006-03-28 16:11:02 -08002772 /* Now kill any processes that happen to have the
2773 * tty open.
2774 */
2775 do_each_thread(g, p) {
2776 if (p->signal->tty == tty) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002777 printk(KERN_NOTICE "SAK: killed process %d"
Oleg Nesterov1b0f7ff2009-04-02 16:58:39 -07002778 " (%s): task_session(p)==tty->session\n",
Pavel Emelyanovba25f9d2007-10-18 23:40:40 -07002779 task_pid_nr(p), p->comm);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002780 send_sig(SIGKILL, p, 1);
2781 continue;
2782 }
2783 task_lock(p);
2784 if (p->files) {
Dipankar Sarmaca99c1d2006-04-18 22:21:46 -07002785 /*
2786 * We don't take a ref to the file, so we must
2787 * hold ->file_lock instead.
2788 */
2789 spin_lock(&p->files->file_lock);
Dipankar Sarmabadf1662005-09-09 13:04:10 -07002790 fdt = files_fdtable(p->files);
Alan Cox37bdfb02008-02-08 04:18:47 -08002791 for (i = 0; i < fdt->max_fds; i++) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002792 filp = fcheck_files(p->files, i);
2793 if (!filp)
2794 continue;
2795 if (filp->f_op->read == tty_read &&
Nick Piggind996b622010-08-18 04:37:36 +10002796 file_tty(filp) == tty) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002797 printk(KERN_NOTICE "SAK: killed process %d"
2798 " (%s): fd#%d opened to the tty\n",
Pavel Emelyanovba25f9d2007-10-18 23:40:40 -07002799 task_pid_nr(p), p->comm, i);
Eric W. Biederman20ac9432006-04-13 04:49:07 -06002800 force_sig(SIGKILL, p);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002801 break;
2802 }
2803 }
Dipankar Sarmaca99c1d2006-04-18 22:21:46 -07002804 spin_unlock(&p->files->file_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002805 }
2806 task_unlock(p);
Eric W. Biederman652486f2006-03-28 16:11:02 -08002807 } while_each_thread(g, p);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002808 read_unlock(&tasklist_lock);
2809#endif
2810}
2811
Eric W. Biederman8b6312f2007-02-10 01:44:34 -08002812static void do_SAK_work(struct work_struct *work)
2813{
2814 struct tty_struct *tty =
2815 container_of(work, struct tty_struct, SAK_work);
2816 __do_SAK(tty);
2817}
2818
Linus Torvalds1da177e2005-04-16 15:20:36 -07002819/*
2820 * The tq handling here is a little racy - tty->SAK_work may already be queued.
2821 * Fortunately we don't need to worry, because if ->SAK_work is already queued,
2822 * the values which we write to it will be identical to the values which it
2823 * already has. --akpm
2824 */
2825void do_SAK(struct tty_struct *tty)
2826{
2827 if (!tty)
2828 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002829 schedule_work(&tty->SAK_work);
2830}
2831
2832EXPORT_SYMBOL(do_SAK);
2833
Dmitry Eremin-Solenikov30004ac2010-08-09 18:22:49 +04002834static int dev_match_devt(struct device *dev, void *data)
2835{
2836 dev_t *devt = data;
2837 return dev->devt == *devt;
2838}
2839
2840/* Must put_device() after it's unused! */
2841static struct device *tty_get_device(struct tty_struct *tty)
2842{
2843 dev_t devt = tty_devnum(tty);
2844 return class_find_device(tty_class, NULL, &devt, dev_match_devt);
2845}
2846
2847
Alan Coxaf9b8972006-08-27 01:24:01 -07002848/**
Alan Coxaf9b8972006-08-27 01:24:01 -07002849 * initialize_tty_struct
2850 * @tty: tty to initialize
2851 *
2852 * This subroutine initializes a tty structure that has been newly
2853 * allocated.
2854 *
2855 * Locking: none - tty in question must not be exposed at this point
Linus Torvalds1da177e2005-04-16 15:20:36 -07002856 */
Alan Coxaf9b8972006-08-27 01:24:01 -07002857
Alan Coxbf970ee2008-10-13 10:42:39 +01002858void initialize_tty_struct(struct tty_struct *tty,
2859 struct tty_driver *driver, int idx)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002860{
2861 memset(tty, 0, sizeof(struct tty_struct));
Alan Cox9c9f4de2008-10-13 10:37:26 +01002862 kref_init(&tty->kref);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002863 tty->magic = TTY_MAGIC;
Alan Cox01e1abb2008-07-22 11:16:55 +01002864 tty_ldisc_init(tty);
Eric W. Biedermanab521dc2007-02-12 00:53:00 -08002865 tty->session = NULL;
2866 tty->pgrp = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002867 tty->overrun_time = jiffies;
Alan Cox33f0f882006-01-09 20:54:13 -08002868 tty->buf.head = tty->buf.tail = NULL;
2869 tty_buffer_init(tty);
Arjan van de Ven5785c952006-09-29 02:00:43 -07002870 mutex_init(&tty->termios_mutex);
Alan Coxc65c9bc2009-06-11 12:50:12 +01002871 mutex_init(&tty->ldisc_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002872 init_waitqueue_head(&tty->write_wait);
2873 init_waitqueue_head(&tty->read_wait);
David Howells65f27f32006-11-22 14:55:48 +00002874 INIT_WORK(&tty->hangup_work, do_tty_hangup);
Ingo Molnar70522e12006-03-23 03:00:31 -08002875 mutex_init(&tty->atomic_read_lock);
2876 mutex_init(&tty->atomic_write_lock);
Joe Petersona88a69c2009-01-02 13:40:53 +00002877 mutex_init(&tty->output_lock);
2878 mutex_init(&tty->echo_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002879 spin_lock_init(&tty->read_lock);
Alan Cox04f378b2008-04-30 00:53:29 -07002880 spin_lock_init(&tty->ctrl_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002881 INIT_LIST_HEAD(&tty->tty_files);
Eric W. Biederman7f1f86a2007-02-13 14:38:58 -07002882 INIT_WORK(&tty->SAK_work, do_SAK_work);
Alan Coxbf970ee2008-10-13 10:42:39 +01002883
2884 tty->driver = driver;
2885 tty->ops = driver->ops;
2886 tty->index = idx;
2887 tty_line_name(driver, idx, tty->name);
Dmitry Eremin-Solenikov30004ac2010-08-09 18:22:49 +04002888 tty->dev = tty_get_device(tty);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002889}
2890
Alan Coxf34d7a52008-04-30 00:54:13 -07002891/**
Jiri Slaby67166712011-03-23 10:48:35 +01002892 * deinitialize_tty_struct
2893 * @tty: tty to deinitialize
2894 *
2895 * This subroutine deinitializes a tty structure that has been newly
2896 * allocated but tty_release cannot be called on that yet.
2897 *
2898 * Locking: none - tty in question must not be exposed at this point
2899 */
2900void deinitialize_tty_struct(struct tty_struct *tty)
2901{
2902 tty_ldisc_deinit(tty);
2903}
2904
2905/**
Alan Coxf34d7a52008-04-30 00:54:13 -07002906 * tty_put_char - write one character to a tty
2907 * @tty: tty
2908 * @ch: character
2909 *
2910 * Write one byte to the tty using the provided put_char method
2911 * if present. Returns the number of characters successfully output.
2912 *
2913 * Note: the specific put_char operation in the driver layer may go
2914 * away soon. Don't call it directly, use this method
Linus Torvalds1da177e2005-04-16 15:20:36 -07002915 */
Alan Coxaf9b8972006-08-27 01:24:01 -07002916
Alan Coxf34d7a52008-04-30 00:54:13 -07002917int tty_put_char(struct tty_struct *tty, unsigned char ch)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002918{
Alan Coxf34d7a52008-04-30 00:54:13 -07002919 if (tty->ops->put_char)
2920 return tty->ops->put_char(tty, ch);
2921 return tty->ops->write(tty, &ch, 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002922}
Alan Coxf34d7a52008-04-30 00:54:13 -07002923EXPORT_SYMBOL_GPL(tty_put_char);
2924
Alan Coxd81ed102008-10-13 10:41:42 +01002925struct class *tty_class;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002926
2927/**
Alan Coxaf9b8972006-08-27 01:24:01 -07002928 * tty_register_device - register a tty device
2929 * @driver: the tty driver that describes the tty device
2930 * @index: the index in the tty driver for this tty device
2931 * @device: a struct device that is associated with this tty device.
2932 * This field is optional, if there is no known struct device
2933 * for this tty device it can be set to NULL safely.
Linus Torvalds1da177e2005-04-16 15:20:36 -07002934 *
Greg Kroah-Hartman01107d32006-08-07 22:19:37 -07002935 * Returns a pointer to the struct device for this tty device
2936 * (or ERR_PTR(-EFOO) on error).
Hansjoerg Lipp1cdcb6b2006-04-22 18:36:53 +02002937 *
Alan Coxaf9b8972006-08-27 01:24:01 -07002938 * This call is required to be made to register an individual tty device
2939 * if the tty driver's flags have the TTY_DRIVER_DYNAMIC_DEV bit set. If
2940 * that bit is not set, this function should not be called by a tty
2941 * driver.
2942 *
2943 * Locking: ??
Linus Torvalds1da177e2005-04-16 15:20:36 -07002944 */
Alan Coxaf9b8972006-08-27 01:24:01 -07002945
Greg Kroah-Hartman01107d32006-08-07 22:19:37 -07002946struct device *tty_register_device(struct tty_driver *driver, unsigned index,
2947 struct device *device)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002948{
2949 char name[64];
2950 dev_t dev = MKDEV(driver->major, driver->minor_start) + index;
2951
2952 if (index >= driver->num) {
2953 printk(KERN_ERR "Attempt to register invalid tty line number "
2954 " (%d).\n", index);
Hansjoerg Lipp1cdcb6b2006-04-22 18:36:53 +02002955 return ERR_PTR(-EINVAL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002956 }
2957
Linus Torvalds1da177e2005-04-16 15:20:36 -07002958 if (driver->type == TTY_DRIVER_TYPE_PTY)
2959 pty_line_name(driver, index, name);
2960 else
2961 tty_line_name(driver, index, name);
Hansjoerg Lipp1cdcb6b2006-04-22 18:36:53 +02002962
Greg Kroah-Hartman03457cd2008-07-21 20:03:34 -07002963 return device_create(tty_class, device, dev, NULL, name);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002964}
Alan Cox7d7b93c2008-10-13 10:42:09 +01002965EXPORT_SYMBOL(tty_register_device);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002966
2967/**
Alan Coxaf9b8972006-08-27 01:24:01 -07002968 * tty_unregister_device - unregister a tty device
2969 * @driver: the tty driver that describes the tty device
2970 * @index: the index in the tty driver for this tty device
Linus Torvalds1da177e2005-04-16 15:20:36 -07002971 *
Alan Coxaf9b8972006-08-27 01:24:01 -07002972 * If a tty device is registered with a call to tty_register_device() then
2973 * this function must be called when the tty device is gone.
2974 *
2975 * Locking: ??
Linus Torvalds1da177e2005-04-16 15:20:36 -07002976 */
Alan Coxaf9b8972006-08-27 01:24:01 -07002977
Linus Torvalds1da177e2005-04-16 15:20:36 -07002978void tty_unregister_device(struct tty_driver *driver, unsigned index)
2979{
Alan Cox37bdfb02008-02-08 04:18:47 -08002980 device_destroy(tty_class,
2981 MKDEV(driver->major, driver->minor_start) + index);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002982}
Linus Torvalds1da177e2005-04-16 15:20:36 -07002983EXPORT_SYMBOL(tty_unregister_device);
2984
2985struct tty_driver *alloc_tty_driver(int lines)
2986{
2987 struct tty_driver *driver;
2988
Jean Delvare506eb992007-07-15 23:40:14 -07002989 driver = kzalloc(sizeof(struct tty_driver), GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002990 if (driver) {
Alan Cox7d7b93c2008-10-13 10:42:09 +01002991 kref_init(&driver->kref);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002992 driver->magic = TTY_DRIVER_MAGIC;
2993 driver->num = lines;
2994 /* later we'll move allocation of tables here */
2995 }
2996 return driver;
2997}
Alan Cox7d7b93c2008-10-13 10:42:09 +01002998EXPORT_SYMBOL(alloc_tty_driver);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002999
Alan Cox7d7b93c2008-10-13 10:42:09 +01003000static void destruct_tty_driver(struct kref *kref)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003001{
Alan Cox7d7b93c2008-10-13 10:42:09 +01003002 struct tty_driver *driver = container_of(kref, struct tty_driver, kref);
3003 int i;
3004 struct ktermios *tp;
3005 void *p;
3006
3007 if (driver->flags & TTY_DRIVER_INSTALLED) {
3008 /*
3009 * Free the termios and termios_locked structures because
3010 * we don't want to get memory leaks when modular tty
3011 * drivers are removed from the kernel.
3012 */
3013 for (i = 0; i < driver->num; i++) {
3014 tp = driver->termios[i];
3015 if (tp) {
3016 driver->termios[i] = NULL;
3017 kfree(tp);
3018 }
Alan Cox7d7b93c2008-10-13 10:42:09 +01003019 if (!(driver->flags & TTY_DRIVER_DYNAMIC_DEV))
3020 tty_unregister_device(driver, i);
3021 }
3022 p = driver->ttys;
3023 proc_tty_unregister_driver(driver);
3024 driver->ttys = NULL;
Alan Coxfe6e29f2008-10-13 10:44:08 +01003025 driver->termios = NULL;
Alan Cox7d7b93c2008-10-13 10:42:09 +01003026 kfree(p);
3027 cdev_del(&driver->cdev);
3028 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07003029 kfree(driver);
3030}
3031
Alan Cox7d7b93c2008-10-13 10:42:09 +01003032void tty_driver_kref_put(struct tty_driver *driver)
3033{
3034 kref_put(&driver->kref, destruct_tty_driver);
3035}
3036EXPORT_SYMBOL(tty_driver_kref_put);
3037
Jeff Dikeb68e31d2006-10-02 02:17:18 -07003038void tty_set_operations(struct tty_driver *driver,
3039 const struct tty_operations *op)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003040{
Alan Coxf34d7a52008-04-30 00:54:13 -07003041 driver->ops = op;
3042};
Linus Torvalds1da177e2005-04-16 15:20:36 -07003043EXPORT_SYMBOL(tty_set_operations);
3044
Alan Cox7d7b93c2008-10-13 10:42:09 +01003045void put_tty_driver(struct tty_driver *d)
3046{
3047 tty_driver_kref_put(d);
3048}
3049EXPORT_SYMBOL(put_tty_driver);
3050
Linus Torvalds1da177e2005-04-16 15:20:36 -07003051/*
3052 * Called by a tty driver to register itself.
3053 */
3054int tty_register_driver(struct tty_driver *driver)
3055{
3056 int error;
Alan Cox37bdfb02008-02-08 04:18:47 -08003057 int i;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003058 dev_t dev;
3059 void **p = NULL;
Vasiliy Kulikovb670bde2010-09-05 22:32:22 +04003060 struct device *d;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003061
Andy Whitcroft543691a2007-05-06 14:49:33 -07003062 if (!(driver->flags & TTY_DRIVER_DEVPTS_MEM) && driver->num) {
Alan Coxfe6e29f2008-10-13 10:44:08 +01003063 p = kzalloc(driver->num * 2 * sizeof(void *), GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003064 if (!p)
3065 return -ENOMEM;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003066 }
3067
3068 if (!driver->major) {
Alan Cox37bdfb02008-02-08 04:18:47 -08003069 error = alloc_chrdev_region(&dev, driver->minor_start,
3070 driver->num, driver->name);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003071 if (!error) {
3072 driver->major = MAJOR(dev);
3073 driver->minor_start = MINOR(dev);
3074 }
3075 } else {
3076 dev = MKDEV(driver->major, driver->minor_start);
Geert Uytterhoevene5717c42007-02-20 15:45:21 +01003077 error = register_chrdev_region(dev, driver->num, driver->name);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003078 }
3079 if (error < 0) {
3080 kfree(p);
3081 return error;
3082 }
3083
3084 if (p) {
3085 driver->ttys = (struct tty_struct **)p;
Alan Coxedc6afc2006-12-08 02:38:44 -08003086 driver->termios = (struct ktermios **)(p + driver->num);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003087 } else {
3088 driver->ttys = NULL;
3089 driver->termios = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003090 }
3091
3092 cdev_init(&driver->cdev, &tty_fops);
3093 driver->cdev.owner = driver->owner;
3094 error = cdev_add(&driver->cdev, dev, driver->num);
3095 if (error) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07003096 unregister_chrdev_region(dev, driver->num);
3097 driver->ttys = NULL;
Alan Coxfe6e29f2008-10-13 10:44:08 +01003098 driver->termios = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003099 kfree(p);
3100 return error;
3101 }
3102
Alexey Dobriyanca509f62007-05-08 00:27:12 -07003103 mutex_lock(&tty_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003104 list_add(&driver->tty_drivers, &tty_drivers);
Alexey Dobriyanca509f62007-05-08 00:27:12 -07003105 mutex_unlock(&tty_mutex);
Alan Cox37bdfb02008-02-08 04:18:47 -08003106
3107 if (!(driver->flags & TTY_DRIVER_DYNAMIC_DEV)) {
Vasiliy Kulikovb670bde2010-09-05 22:32:22 +04003108 for (i = 0; i < driver->num; i++) {
3109 d = tty_register_device(driver, i, NULL);
3110 if (IS_ERR(d)) {
3111 error = PTR_ERR(d);
3112 goto err;
3113 }
3114 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07003115 }
3116 proc_tty_register_driver(driver);
Alan Cox7d7b93c2008-10-13 10:42:09 +01003117 driver->flags |= TTY_DRIVER_INSTALLED;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003118 return 0;
Vasiliy Kulikovb670bde2010-09-05 22:32:22 +04003119
3120err:
3121 for (i--; i >= 0; i--)
3122 tty_unregister_device(driver, i);
3123
3124 mutex_lock(&tty_mutex);
3125 list_del(&driver->tty_drivers);
3126 mutex_unlock(&tty_mutex);
3127
3128 unregister_chrdev_region(dev, driver->num);
3129 driver->ttys = NULL;
3130 driver->termios = NULL;
3131 kfree(p);
3132 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003133}
3134
3135EXPORT_SYMBOL(tty_register_driver);
3136
3137/*
3138 * Called by a tty driver to unregister itself.
3139 */
3140int tty_unregister_driver(struct tty_driver *driver)
3141{
Alan Cox7d7b93c2008-10-13 10:42:09 +01003142#if 0
3143 /* FIXME */
Linus Torvalds1da177e2005-04-16 15:20:36 -07003144 if (driver->refcount)
3145 return -EBUSY;
Alan Cox7d7b93c2008-10-13 10:42:09 +01003146#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07003147 unregister_chrdev_region(MKDEV(driver->major, driver->minor_start),
3148 driver->num);
Alexey Dobriyanca509f62007-05-08 00:27:12 -07003149 mutex_lock(&tty_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003150 list_del(&driver->tty_drivers);
Alexey Dobriyanca509f62007-05-08 00:27:12 -07003151 mutex_unlock(&tty_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003152 return 0;
3153}
Alan Cox7d7b93c2008-10-13 10:42:09 +01003154
Linus Torvalds1da177e2005-04-16 15:20:36 -07003155EXPORT_SYMBOL(tty_unregister_driver);
3156
Peter Zijlstra24ec8392006-12-08 02:36:04 -08003157dev_t tty_devnum(struct tty_struct *tty)
3158{
3159 return MKDEV(tty->driver->major, tty->driver->minor_start) + tty->index;
3160}
3161EXPORT_SYMBOL(tty_devnum);
3162
3163void proc_clear_tty(struct task_struct *p)
3164{
Arjan van de Ven7c3b1dc2008-10-15 10:52:34 +01003165 unsigned long flags;
Alan Cox9c9f4de2008-10-13 10:37:26 +01003166 struct tty_struct *tty;
Arjan van de Ven7c3b1dc2008-10-15 10:52:34 +01003167 spin_lock_irqsave(&p->sighand->siglock, flags);
Alan Cox9c9f4de2008-10-13 10:37:26 +01003168 tty = p->signal->tty;
Peter Zijlstra24ec8392006-12-08 02:36:04 -08003169 p->signal->tty = NULL;
Arjan van de Ven7c3b1dc2008-10-15 10:52:34 +01003170 spin_unlock_irqrestore(&p->sighand->siglock, flags);
Alan Cox9c9f4de2008-10-13 10:37:26 +01003171 tty_kref_put(tty);
Peter Zijlstra24ec8392006-12-08 02:36:04 -08003172}
Peter Zijlstra24ec8392006-12-08 02:36:04 -08003173
Alan Cox47f86832008-04-30 00:53:30 -07003174/* Called under the sighand lock */
3175
Eric W. Biederman2a65f1d2007-05-08 00:26:53 -07003176static void __proc_set_tty(struct task_struct *tsk, struct tty_struct *tty)
Peter Zijlstra24ec8392006-12-08 02:36:04 -08003177{
3178 if (tty) {
Alan Cox47f86832008-04-30 00:53:30 -07003179 unsigned long flags;
3180 /* We should not have a session or pgrp to put here but.... */
3181 spin_lock_irqsave(&tty->ctrl_lock, flags);
Eric W. Biedermand9c1e9a2007-03-18 12:45:44 -06003182 put_pid(tty->session);
3183 put_pid(tty->pgrp);
Eric W. Biedermanab521dc2007-02-12 00:53:00 -08003184 tty->pgrp = get_pid(task_pgrp(tsk));
Alan Cox47f86832008-04-30 00:53:30 -07003185 spin_unlock_irqrestore(&tty->ctrl_lock, flags);
3186 tty->session = get_pid(task_session(tsk));
Alan Cox9c9f4de2008-10-13 10:37:26 +01003187 if (tsk->signal->tty) {
3188 printk(KERN_DEBUG "tty not NULL!!\n");
3189 tty_kref_put(tsk->signal->tty);
3190 }
Peter Zijlstra24ec8392006-12-08 02:36:04 -08003191 }
Eric W. Biederman2a65f1d2007-05-08 00:26:53 -07003192 put_pid(tsk->signal->tty_old_pgrp);
Alan Cox9c9f4de2008-10-13 10:37:26 +01003193 tsk->signal->tty = tty_kref_get(tty);
Eric W. Biedermanab521dc2007-02-12 00:53:00 -08003194 tsk->signal->tty_old_pgrp = NULL;
Peter Zijlstra24ec8392006-12-08 02:36:04 -08003195}
3196
Eric W. Biederman98a27ba2007-05-08 00:26:56 -07003197static void proc_set_tty(struct task_struct *tsk, struct tty_struct *tty)
Peter Zijlstra24ec8392006-12-08 02:36:04 -08003198{
3199 spin_lock_irq(&tsk->sighand->siglock);
Eric W. Biederman2a65f1d2007-05-08 00:26:53 -07003200 __proc_set_tty(tsk, tty);
Peter Zijlstra24ec8392006-12-08 02:36:04 -08003201 spin_unlock_irq(&tsk->sighand->siglock);
3202}
3203
3204struct tty_struct *get_current_tty(void)
3205{
3206 struct tty_struct *tty;
Alan Cox934e6eb2008-10-13 10:40:43 +01003207 unsigned long flags;
3208
3209 spin_lock_irqsave(&current->sighand->siglock, flags);
Alan Cox452a00d2008-10-13 10:39:13 +01003210 tty = tty_kref_get(current->signal->tty);
Alan Cox934e6eb2008-10-13 10:40:43 +01003211 spin_unlock_irqrestore(&current->sighand->siglock, flags);
Peter Zijlstra24ec8392006-12-08 02:36:04 -08003212 return tty;
3213}
Heiko Carstensa311f742006-12-13 00:33:41 -08003214EXPORT_SYMBOL_GPL(get_current_tty);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003215
Alan Coxd81ed102008-10-13 10:41:42 +01003216void tty_default_fops(struct file_operations *fops)
3217{
3218 *fops = tty_fops;
3219}
3220
Linus Torvalds1da177e2005-04-16 15:20:36 -07003221/*
3222 * Initialize the console device. This is called *early*, so
3223 * we can't necessarily depend on lots of kernel help here.
3224 * Just do some early initializations, and do the complex setup
3225 * later.
3226 */
3227void __init console_init(void)
3228{
3229 initcall_t *call;
3230
3231 /* Setup the default TTY line discipline. */
Alan Cox01e1abb2008-07-22 11:16:55 +01003232 tty_ldisc_begin();
Linus Torvalds1da177e2005-04-16 15:20:36 -07003233
3234 /*
Alan Cox37bdfb02008-02-08 04:18:47 -08003235 * set up the console device so that later boot sequences can
Linus Torvalds1da177e2005-04-16 15:20:36 -07003236 * inform about problems etc..
3237 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07003238 call = __con_initcall_start;
3239 while (call < __con_initcall_end) {
3240 (*call)();
3241 call++;
3242 }
3243}
3244
Kay Sieverse454cea2009-09-18 23:01:12 +02003245static char *tty_devnode(struct device *dev, mode_t *mode)
3246{
3247 if (!mode)
3248 return NULL;
3249 if (dev->devt == MKDEV(TTYAUX_MAJOR, 0) ||
3250 dev->devt == MKDEV(TTYAUX_MAJOR, 2))
3251 *mode = 0666;
3252 return NULL;
3253}
3254
Linus Torvalds1da177e2005-04-16 15:20:36 -07003255static int __init tty_class_init(void)
3256{
gregkh@suse.de7fe845d2005-03-15 14:23:15 -08003257 tty_class = class_create(THIS_MODULE, "tty");
Linus Torvalds1da177e2005-04-16 15:20:36 -07003258 if (IS_ERR(tty_class))
3259 return PTR_ERR(tty_class);
Kay Sieverse454cea2009-09-18 23:01:12 +02003260 tty_class->devnode = tty_devnode;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003261 return 0;
3262}
3263
3264postcore_initcall(tty_class_init);
3265
3266/* 3/2004 jmc: why do these devices exist? */
Linus Torvalds1da177e2005-04-16 15:20:36 -07003267static struct cdev tty_cdev, console_cdev;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003268
Kay Sieversfbc92a32010-12-01 18:51:05 +01003269static ssize_t show_cons_active(struct device *dev,
3270 struct device_attribute *attr, char *buf)
3271{
3272 struct console *cs[16];
3273 int i = 0;
3274 struct console *c;
3275 ssize_t count = 0;
3276
Torben Hohnac751ef2011-01-25 15:07:35 -08003277 console_lock();
Kay Sieversa2a6a822011-01-09 16:39:14 +01003278 for_each_console(c) {
Kay Sieversfbc92a32010-12-01 18:51:05 +01003279 if (!c->device)
3280 continue;
3281 if (!c->write)
3282 continue;
3283 if ((c->flags & CON_ENABLED) == 0)
3284 continue;
3285 cs[i++] = c;
3286 if (i >= ARRAY_SIZE(cs))
3287 break;
3288 }
3289 while (i--)
3290 count += sprintf(buf + count, "%s%d%c",
3291 cs[i]->name, cs[i]->index, i ? ' ':'\n');
Torben Hohnac751ef2011-01-25 15:07:35 -08003292 console_unlock();
Kay Sieversfbc92a32010-12-01 18:51:05 +01003293
3294 return count;
3295}
3296static DEVICE_ATTR(active, S_IRUGO, show_cons_active, NULL);
3297
3298static struct device *consdev;
3299
3300void console_sysfs_notify(void)
3301{
3302 if (consdev)
3303 sysfs_notify(&consdev->kobj, NULL, "active");
3304}
3305
Linus Torvalds1da177e2005-04-16 15:20:36 -07003306/*
3307 * Ok, now we can initialize the rest of the tty devices and can count
3308 * on memory allocations, interrupts etc..
3309 */
David Howells31d1d482010-08-06 16:34:43 +01003310int __init tty_init(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003311{
3312 cdev_init(&tty_cdev, &tty_fops);
3313 if (cdev_add(&tty_cdev, MKDEV(TTYAUX_MAJOR, 0), 1) ||
3314 register_chrdev_region(MKDEV(TTYAUX_MAJOR, 0), 1, "/dev/tty") < 0)
3315 panic("Couldn't register /dev/tty driver\n");
Kay Sieversfbc92a32010-12-01 18:51:05 +01003316 device_create(tty_class, NULL, MKDEV(TTYAUX_MAJOR, 0), NULL, "tty");
Linus Torvalds1da177e2005-04-16 15:20:36 -07003317
3318 cdev_init(&console_cdev, &console_fops);
3319 if (cdev_add(&console_cdev, MKDEV(TTYAUX_MAJOR, 1), 1) ||
3320 register_chrdev_region(MKDEV(TTYAUX_MAJOR, 1), 1, "/dev/console") < 0)
3321 panic("Couldn't register /dev/console driver\n");
Kay Sieversfbc92a32010-12-01 18:51:05 +01003322 consdev = device_create(tty_class, NULL, MKDEV(TTYAUX_MAJOR, 1), NULL,
Greg Kroah-Hartman47aa5792008-05-21 12:52:33 -07003323 "console");
Kay Sieversfbc92a32010-12-01 18:51:05 +01003324 if (IS_ERR(consdev))
3325 consdev = NULL;
3326 else
Kay Sieversa2a6a822011-01-09 16:39:14 +01003327 WARN_ON(device_create_file(consdev, &dev_attr_active) < 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003328
Linus Torvalds1da177e2005-04-16 15:20:36 -07003329#ifdef CONFIG_VT
Alan Coxd81ed102008-10-13 10:41:42 +01003330 vty_init(&console_fops);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003331#endif
3332 return 0;
3333}
David Howells31d1d482010-08-06 16:34:43 +01003334