blob: d3bf91a293038b110bddcc51774303bae9f21ddd [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>
Manuel Zerpies5a3c6b22011-06-16 14:07:22 +020097#include <linux/ratelimit.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070098
Alan Coxa352def2008-07-16 21:53:12 +010099#include <linux/uaccess.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -0700100
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{
Dan Carpenterdc6802a2012-07-24 12:52:04 +0100184 if (!tty)
185 return;
Dmitry Eremin-Solenikov30004ac2010-08-09 18:22:49 +0400186 if (tty->dev)
187 put_device(tty->dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700188 kfree(tty->write_buf);
Alan Cox33f0f882006-01-09 20:54:13 -0800189 tty_buffer_free_all(tty);
Alan Cox89c8d912012-08-08 16:30:13 +0100190 tty->magic = 0xDEADDEAD;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700191 kfree(tty);
192}
193
Nick Piggind996b622010-08-18 04:37:36 +1000194static inline struct tty_struct *file_tty(struct file *file)
195{
196 return ((struct tty_file_private *)file->private_data)->tty;
197}
198
Jiri Slabyfa90e1c2011-10-12 11:32:43 +0200199int tty_alloc_file(struct file *file)
Nick Piggind996b622010-08-18 04:37:36 +1000200{
201 struct tty_file_private *priv;
202
Pekka Enbergf573bd12010-08-24 07:48:34 +0300203 priv = kmalloc(sizeof(*priv), GFP_KERNEL);
204 if (!priv)
205 return -ENOMEM;
Nick Piggind996b622010-08-18 04:37:36 +1000206
Jiri Slabyfa90e1c2011-10-12 11:32:43 +0200207 file->private_data = priv;
208
209 return 0;
210}
211
212/* Associate a new file with the tty structure */
213void tty_add_file(struct tty_struct *tty, struct file *file)
214{
215 struct tty_file_private *priv = file->private_data;
216
Nick Piggind996b622010-08-18 04:37:36 +1000217 priv->tty = tty;
218 priv->file = file;
Nick Piggind996b622010-08-18 04:37:36 +1000219
220 spin_lock(&tty_files_lock);
221 list_add(&priv->list, &tty->tty_files);
222 spin_unlock(&tty_files_lock);
Jiri Slabyfa90e1c2011-10-12 11:32:43 +0200223}
Pekka Enbergf573bd12010-08-24 07:48:34 +0300224
Jiri Slabyfa90e1c2011-10-12 11:32:43 +0200225/**
226 * tty_free_file - free file->private_data
227 *
228 * This shall be used only for fail path handling when tty_add_file was not
229 * called yet.
230 */
231void tty_free_file(struct file *file)
232{
233 struct tty_file_private *priv = file->private_data;
234
235 file->private_data = NULL;
236 kfree(priv);
Nick Piggind996b622010-08-18 04:37:36 +1000237}
238
239/* Delete file from its tty */
240void tty_del_file(struct file *file)
241{
242 struct tty_file_private *priv = file->private_data;
243
244 spin_lock(&tty_files_lock);
245 list_del(&priv->list);
246 spin_unlock(&tty_files_lock);
Jiri Slabyfa90e1c2011-10-12 11:32:43 +0200247 tty_free_file(file);
Nick Piggind996b622010-08-18 04:37:36 +1000248}
249
250
Linus Torvalds1da177e2005-04-16 15:20:36 -0700251#define TTY_NUMBER(tty) ((tty)->index + (tty)->driver->name_base)
252
Alan Coxaf9b8972006-08-27 01:24:01 -0700253/**
254 * tty_name - return tty naming
255 * @tty: tty structure
256 * @buf: buffer for output
257 *
258 * Convert a tty structure into a name. The name reflects the kernel
259 * naming policy and if udev is in use may not reflect user space
260 *
261 * Locking: none
262 */
263
Linus Torvalds1da177e2005-04-16 15:20:36 -0700264char *tty_name(struct tty_struct *tty, char *buf)
265{
266 if (!tty) /* Hmm. NULL pointer. That's fun. */
267 strcpy(buf, "NULL tty");
268 else
269 strcpy(buf, tty->name);
270 return buf;
271}
272
273EXPORT_SYMBOL(tty_name);
274
Andrew Mortond769a662005-05-05 16:15:50 -0700275int tty_paranoia_check(struct tty_struct *tty, struct inode *inode,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700276 const char *routine)
277{
278#ifdef TTY_PARANOIA_CHECK
279 if (!tty) {
280 printk(KERN_WARNING
281 "null TTY for (%d:%d) in %s\n",
282 imajor(inode), iminor(inode), routine);
283 return 1;
284 }
285 if (tty->magic != TTY_MAGIC) {
286 printk(KERN_WARNING
287 "bad magic number for tty struct (%d:%d) in %s\n",
288 imajor(inode), iminor(inode), routine);
289 return 1;
290 }
291#endif
292 return 0;
293}
294
295static int check_tty_count(struct tty_struct *tty, const char *routine)
296{
297#ifdef CHECK_TTY_COUNT
298 struct list_head *p;
299 int count = 0;
Alan Cox37bdfb02008-02-08 04:18:47 -0800300
Nick Pigginee2ffa02010-08-18 04:37:35 +1000301 spin_lock(&tty_files_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700302 list_for_each(p, &tty->tty_files) {
303 count++;
304 }
Nick Pigginee2ffa02010-08-18 04:37:35 +1000305 spin_unlock(&tty_files_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700306 if (tty->driver->type == TTY_DRIVER_TYPE_PTY &&
307 tty->driver->subtype == PTY_TYPE_SLAVE &&
308 tty->link && tty->link->count)
309 count++;
310 if (tty->count != count) {
311 printk(KERN_WARNING "Warning: dev (%s) tty->count(%d) "
312 "!= #fd's(%d) in %s\n",
313 tty->name, tty->count, count, routine);
314 return count;
Peter Zijlstra24ec8392006-12-08 02:36:04 -0800315 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700316#endif
317 return 0;
318}
319
Alan Coxaf9b8972006-08-27 01:24:01 -0700320/**
Alan Coxaf9b8972006-08-27 01:24:01 -0700321 * get_tty_driver - find device of a tty
322 * @dev_t: device identifier
323 * @index: returns the index of the tty
324 *
325 * This routine returns a tty driver structure, given a device number
326 * and also passes back the index number.
327 *
328 * Locking: caller must hold tty_mutex
Linus Torvalds1da177e2005-04-16 15:20:36 -0700329 */
Alan Coxaf9b8972006-08-27 01:24:01 -0700330
Linus Torvalds1da177e2005-04-16 15:20:36 -0700331static struct tty_driver *get_tty_driver(dev_t device, int *index)
332{
333 struct tty_driver *p;
334
335 list_for_each_entry(p, &tty_drivers, tty_drivers) {
336 dev_t base = MKDEV(p->major, p->minor_start);
337 if (device < base || device >= base + p->num)
338 continue;
339 *index = device - base;
Alan Cox7d7b93c2008-10-13 10:42:09 +0100340 return tty_driver_kref_get(p);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700341 }
342 return NULL;
343}
344
Jason Wesself2d937f2008-04-17 20:05:37 +0200345#ifdef CONFIG_CONSOLE_POLL
346
347/**
348 * tty_find_polling_driver - find device of a polled tty
349 * @name: name string to match
350 * @line: pointer to resulting tty line nr
351 *
352 * This routine returns a tty driver structure, given a name
353 * and the condition that the tty driver is capable of polled
354 * operation.
355 */
356struct tty_driver *tty_find_polling_driver(char *name, int *line)
357{
358 struct tty_driver *p, *res = NULL;
359 int tty_line = 0;
Jason Wessel0dca0fd2008-09-26 10:36:42 -0500360 int len;
Alan Cox5f0878a2009-06-11 12:46:41 +0100361 char *str, *stp;
Jason Wesself2d937f2008-04-17 20:05:37 +0200362
Jason Wessel0dca0fd2008-09-26 10:36:42 -0500363 for (str = name; *str; str++)
364 if ((*str >= '0' && *str <= '9') || *str == ',')
365 break;
366 if (!*str)
367 return NULL;
368
369 len = str - name;
370 tty_line = simple_strtoul(str, &str, 10);
371
Jason Wesself2d937f2008-04-17 20:05:37 +0200372 mutex_lock(&tty_mutex);
373 /* Search through the tty devices to look for a match */
374 list_for_each_entry(p, &tty_drivers, tty_drivers) {
Jason Wessel0dca0fd2008-09-26 10:36:42 -0500375 if (strncmp(name, p->name, len) != 0)
376 continue;
Alan Cox5f0878a2009-06-11 12:46:41 +0100377 stp = str;
378 if (*stp == ',')
379 stp++;
380 if (*stp == '\0')
381 stp = NULL;
Jason Wesself2d937f2008-04-17 20:05:37 +0200382
Nathael Pajani6eb68d62010-09-02 16:06:16 +0200383 if (tty_line >= 0 && tty_line < p->num && p->ops &&
Alan Cox5f0878a2009-06-11 12:46:41 +0100384 p->ops->poll_init && !p->ops->poll_init(p, tty_line, stp)) {
Alan Cox7d7b93c2008-10-13 10:42:09 +0100385 res = tty_driver_kref_get(p);
Jason Wesself2d937f2008-04-17 20:05:37 +0200386 *line = tty_line;
387 break;
388 }
389 }
390 mutex_unlock(&tty_mutex);
391
392 return res;
393}
394EXPORT_SYMBOL_GPL(tty_find_polling_driver);
395#endif
396
Alan Coxaf9b8972006-08-27 01:24:01 -0700397/**
398 * tty_check_change - check for POSIX terminal changes
399 * @tty: tty to check
400 *
401 * If we try to write to, or set the state of, a terminal and we're
402 * not in the foreground, send a SIGTTOU. If the signal is blocked or
403 * ignored, go ahead and perform the operation. (POSIX 7.2)
404 *
Alan Cox978e5952008-04-30 00:53:59 -0700405 * Locking: ctrl_lock
Linus Torvalds1da177e2005-04-16 15:20:36 -0700406 */
Alan Coxaf9b8972006-08-27 01:24:01 -0700407
Alan Cox37bdfb02008-02-08 04:18:47 -0800408int tty_check_change(struct tty_struct *tty)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700409{
Alan Cox47f86832008-04-30 00:53:30 -0700410 unsigned long flags;
411 int ret = 0;
412
Linus Torvalds1da177e2005-04-16 15:20:36 -0700413 if (current->signal->tty != tty)
414 return 0;
Alan Cox47f86832008-04-30 00:53:30 -0700415
416 spin_lock_irqsave(&tty->ctrl_lock, flags);
417
Eric W. Biedermanab521dc2007-02-12 00:53:00 -0800418 if (!tty->pgrp) {
419 printk(KERN_WARNING "tty_check_change: tty->pgrp == NULL!\n");
Andrew Morton9ffee4c2008-05-14 16:05:58 -0700420 goto out_unlock;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700421 }
Eric W. Biedermanab521dc2007-02-12 00:53:00 -0800422 if (task_pgrp(current) == tty->pgrp)
Andrew Morton9ffee4c2008-05-14 16:05:58 -0700423 goto out_unlock;
424 spin_unlock_irqrestore(&tty->ctrl_lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700425 if (is_ignored(SIGTTOU))
Alan Cox47f86832008-04-30 00:53:30 -0700426 goto out;
427 if (is_current_pgrp_orphaned()) {
428 ret = -EIO;
429 goto out;
430 }
Oleg Nesterov040b6362007-06-01 00:46:53 -0700431 kill_pgrp(task_pgrp(current), SIGTTOU, 1);
432 set_thread_flag(TIF_SIGPENDING);
Alan Cox47f86832008-04-30 00:53:30 -0700433 ret = -ERESTARTSYS;
434out:
Andrew Morton9ffee4c2008-05-14 16:05:58 -0700435 return ret;
436out_unlock:
Alan Cox47f86832008-04-30 00:53:30 -0700437 spin_unlock_irqrestore(&tty->ctrl_lock, flags);
438 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700439}
440
441EXPORT_SYMBOL(tty_check_change);
442
Alan Cox37bdfb02008-02-08 04:18:47 -0800443static ssize_t hung_up_tty_read(struct file *file, char __user *buf,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700444 size_t count, loff_t *ppos)
445{
446 return 0;
447}
448
Alan Cox37bdfb02008-02-08 04:18:47 -0800449static ssize_t hung_up_tty_write(struct file *file, const char __user *buf,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700450 size_t count, loff_t *ppos)
451{
452 return -EIO;
453}
454
455/* No kernel lock held - none needed ;) */
Alan Cox37bdfb02008-02-08 04:18:47 -0800456static unsigned int hung_up_tty_poll(struct file *filp, poll_table *wait)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700457{
458 return POLLIN | POLLOUT | POLLERR | POLLHUP | POLLRDNORM | POLLWRNORM;
459}
460
Alan Cox04f378b2008-04-30 00:53:29 -0700461static long hung_up_tty_ioctl(struct file *file, unsigned int cmd,
462 unsigned long arg)
Paul Fulghum38ad2ed2007-06-16 10:15:55 -0700463{
464 return cmd == TIOCSPGRP ? -ENOTTY : -EIO;
465}
466
Alan Cox37bdfb02008-02-08 04:18:47 -0800467static long hung_up_tty_compat_ioctl(struct file *file,
Paul Fulghum38ad2ed2007-06-16 10:15:55 -0700468 unsigned int cmd, unsigned long arg)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700469{
470 return cmd == TIOCSPGRP ? -ENOTTY : -EIO;
471}
472
Arjan van de Ven62322d22006-07-03 00:24:21 -0700473static const struct file_operations tty_fops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700474 .llseek = no_llseek,
475 .read = tty_read,
476 .write = tty_write,
477 .poll = tty_poll,
Alan Cox04f378b2008-04-30 00:53:29 -0700478 .unlocked_ioctl = tty_ioctl,
Paul Fulghume10cc1d2007-05-10 22:22:50 -0700479 .compat_ioctl = tty_compat_ioctl,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700480 .open = tty_open,
481 .release = tty_release,
482 .fasync = tty_fasync,
483};
484
Arjan van de Ven62322d22006-07-03 00:24:21 -0700485static const struct file_operations console_fops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700486 .llseek = no_llseek,
487 .read = tty_read,
488 .write = redirected_tty_write,
489 .poll = tty_poll,
Alan Cox04f378b2008-04-30 00:53:29 -0700490 .unlocked_ioctl = tty_ioctl,
Paul Fulghume10cc1d2007-05-10 22:22:50 -0700491 .compat_ioctl = tty_compat_ioctl,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700492 .open = tty_open,
493 .release = tty_release,
494 .fasync = tty_fasync,
495};
496
Arjan van de Ven62322d22006-07-03 00:24:21 -0700497static const struct file_operations hung_up_tty_fops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700498 .llseek = no_llseek,
499 .read = hung_up_tty_read,
500 .write = hung_up_tty_write,
501 .poll = hung_up_tty_poll,
Alan Cox04f378b2008-04-30 00:53:29 -0700502 .unlocked_ioctl = hung_up_tty_ioctl,
Paul Fulghum38ad2ed2007-06-16 10:15:55 -0700503 .compat_ioctl = hung_up_tty_compat_ioctl,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700504 .release = tty_release,
505};
506
507static DEFINE_SPINLOCK(redirect_lock);
508static struct file *redirect;
509
510/**
511 * tty_wakeup - request more data
512 * @tty: terminal
513 *
514 * Internal and external helper for wakeups of tty. This function
515 * informs the line discipline if present that the driver is ready
516 * to receive more output data.
517 */
Alan Cox37bdfb02008-02-08 04:18:47 -0800518
Linus Torvalds1da177e2005-04-16 15:20:36 -0700519void tty_wakeup(struct tty_struct *tty)
520{
521 struct tty_ldisc *ld;
Alan Cox37bdfb02008-02-08 04:18:47 -0800522
Linus Torvalds1da177e2005-04-16 15:20:36 -0700523 if (test_bit(TTY_DO_WRITE_WAKEUP, &tty->flags)) {
524 ld = tty_ldisc_ref(tty);
Alan Cox37bdfb02008-02-08 04:18:47 -0800525 if (ld) {
Alan Coxa352def2008-07-16 21:53:12 +0100526 if (ld->ops->write_wakeup)
527 ld->ops->write_wakeup(tty);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700528 tty_ldisc_deref(ld);
529 }
530 }
Davide Libenzi4b194492009-03-31 15:24:24 -0700531 wake_up_interruptible_poll(&tty->write_wait, POLLOUT);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700532}
533
534EXPORT_SYMBOL_GPL(tty_wakeup);
535
536/**
Arnd Bergmann11dbf202010-06-18 14:58:07 +0200537 * __tty_hangup - actual handler for hangup events
David Howells65f27f32006-11-22 14:55:48 +0000538 * @work: tty device
Alan Coxaf9b8972006-08-27 01:24:01 -0700539 *
Alan Cox1bad8792008-07-22 23:38:04 +0100540 * This can be called by the "eventd" kernel thread. That is process
Alan Coxaf9b8972006-08-27 01:24:01 -0700541 * synchronous but doesn't hold any locks, so we need to make sure we
542 * have the appropriate locks for what we're doing.
543 *
544 * The hangup event clears any pending redirections onto the hung up
545 * device. It ensures future writes will error and it does the needed
546 * line discipline hangup and signal delivery. The tty object itself
547 * remains intact.
548 *
549 * Locking:
Arnd Bergmannec79d602010-06-01 22:53:01 +0200550 * BTM
Peter Zijlstra24ec8392006-12-08 02:36:04 -0800551 * redirect lock for undoing redirection
552 * file list lock for manipulating list of ttys
553 * tty_ldisc_lock from called functions
554 * termios_mutex resetting termios data
555 * tasklist_lock to walk task list for hangup event
556 * ->siglock to protect ->signal/->sighand
Linus Torvalds1da177e2005-04-16 15:20:36 -0700557 */
Arnd Bergmann11dbf202010-06-18 14:58:07 +0200558void __tty_hangup(struct tty_struct *tty)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700559{
Alan Cox37bdfb02008-02-08 04:18:47 -0800560 struct file *cons_filp = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700561 struct file *filp, *f = NULL;
562 struct task_struct *p;
Nick Piggind996b622010-08-18 04:37:36 +1000563 struct tty_file_private *priv;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700564 int closecount = 0, n;
Alan Cox47f86832008-04-30 00:53:30 -0700565 unsigned long flags;
Alan Cox9c9f4de2008-10-13 10:37:26 +0100566 int refs = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700567
568 if (!tty)
569 return;
570
Linus Torvalds1da177e2005-04-16 15:20:36 -0700571
572 spin_lock(&redirect_lock);
Nick Piggind996b622010-08-18 04:37:36 +1000573 if (redirect && file_tty(redirect) == tty) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700574 f = redirect;
575 redirect = NULL;
576 }
577 spin_unlock(&redirect_lock);
Alan Cox37bdfb02008-02-08 04:18:47 -0800578
Alan Cox89c8d912012-08-08 16:30:13 +0100579 tty_lock(tty);
Arnd Bergmann11dbf202010-06-18 14:58:07 +0200580
Jiri Slabyacfa7472010-11-29 10:16:54 +0100581 /* some functions below drop BTM, so we need this bit */
582 set_bit(TTY_HUPPING, &tty->flags);
583
Arnd Bergmannec79d602010-06-01 22:53:01 +0200584 /* inuse_filps is protected by the single tty lock,
585 this really needs to change if we want to flush the
586 workqueue with the lock held */
Arnd Bergmann11dbf202010-06-18 14:58:07 +0200587 check_tty_count(tty, "tty_hangup");
Alan Cox36ba7822009-11-30 13:18:51 +0000588
Nick Pigginee2ffa02010-08-18 04:37:35 +1000589 spin_lock(&tty_files_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700590 /* This breaks for file handles being sent over AF_UNIX sockets ? */
Nick Piggind996b622010-08-18 04:37:36 +1000591 list_for_each_entry(priv, &tty->tty_files, list) {
592 filp = priv->file;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700593 if (filp->f_op->write == redirected_tty_write)
594 cons_filp = filp;
595 if (filp->f_op->write != tty_write)
596 continue;
597 closecount++;
Arnd Bergmannec79d602010-06-01 22:53:01 +0200598 __tty_fasync(-1, filp, 0); /* can't block */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700599 filp->f_op = &hung_up_tty_fops;
600 }
Nick Pigginee2ffa02010-08-18 04:37:35 +1000601 spin_unlock(&tty_files_lock);
Alan Cox37bdfb02008-02-08 04:18:47 -0800602
Jiri Slabyacfa7472010-11-29 10:16:54 +0100603 /*
604 * it drops BTM and thus races with reopen
605 * we protect the race by TTY_HUPPING
606 */
Alan Coxc65c9bc2009-06-11 12:50:12 +0100607 tty_ldisc_hangup(tty);
Alan Cox37bdfb02008-02-08 04:18:47 -0800608
Linus Torvalds1da177e2005-04-16 15:20:36 -0700609 read_lock(&tasklist_lock);
Eric W. Biedermanab521dc2007-02-12 00:53:00 -0800610 if (tty->session) {
611 do_each_pid_task(tty->session, PIDTYPE_SID, p) {
Peter Zijlstra24ec8392006-12-08 02:36:04 -0800612 spin_lock_irq(&p->sighand->siglock);
Alan Cox9c9f4de2008-10-13 10:37:26 +0100613 if (p->signal->tty == tty) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700614 p->signal->tty = NULL;
Alan Cox9c9f4de2008-10-13 10:37:26 +0100615 /* We defer the dereferences outside fo
616 the tasklist lock */
617 refs++;
618 }
Peter Zijlstra24ec8392006-12-08 02:36:04 -0800619 if (!p->signal->leader) {
620 spin_unlock_irq(&p->sighand->siglock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700621 continue;
Peter Zijlstra24ec8392006-12-08 02:36:04 -0800622 }
623 __group_send_sig_info(SIGHUP, SEND_SIG_PRIV, p);
624 __group_send_sig_info(SIGCONT, SEND_SIG_PRIV, p);
Eric W. Biedermanab521dc2007-02-12 00:53:00 -0800625 put_pid(p->signal->tty_old_pgrp); /* A noop */
Alan Cox47f86832008-04-30 00:53:30 -0700626 spin_lock_irqsave(&tty->ctrl_lock, flags);
Eric W. Biedermanab521dc2007-02-12 00:53:00 -0800627 if (tty->pgrp)
628 p->signal->tty_old_pgrp = get_pid(tty->pgrp);
Alan Cox47f86832008-04-30 00:53:30 -0700629 spin_unlock_irqrestore(&tty->ctrl_lock, flags);
Peter Zijlstra24ec8392006-12-08 02:36:04 -0800630 spin_unlock_irq(&p->sighand->siglock);
Eric W. Biedermanab521dc2007-02-12 00:53:00 -0800631 } while_each_pid_task(tty->session, PIDTYPE_SID, p);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700632 }
633 read_unlock(&tasklist_lock);
634
Alan Cox47f86832008-04-30 00:53:30 -0700635 spin_lock_irqsave(&tty->ctrl_lock, flags);
Alan Coxc65c9bc2009-06-11 12:50:12 +0100636 clear_bit(TTY_THROTTLED, &tty->flags);
637 clear_bit(TTY_PUSH, &tty->flags);
638 clear_bit(TTY_DO_WRITE_WAKEUP, &tty->flags);
Eric W. Biedermand9c1e9a2007-03-18 12:45:44 -0600639 put_pid(tty->session);
640 put_pid(tty->pgrp);
Eric W. Biedermanab521dc2007-02-12 00:53:00 -0800641 tty->session = NULL;
642 tty->pgrp = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700643 tty->ctrl_status = 0;
Alan Cox47f86832008-04-30 00:53:30 -0700644 spin_unlock_irqrestore(&tty->ctrl_lock, flags);
645
Alan Cox9c9f4de2008-10-13 10:37:26 +0100646 /* Account for the p->signal references we killed */
647 while (refs--)
648 tty_kref_put(tty);
649
Linus Torvalds1da177e2005-04-16 15:20:36 -0700650 /*
Alan Cox37bdfb02008-02-08 04:18:47 -0800651 * If one of the devices matches a console pointer, we
652 * cannot just call hangup() because that will cause
653 * tty->count and state->count to go out of sync.
654 * So we just call close() the right number of times.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700655 */
656 if (cons_filp) {
Alan Coxf34d7a52008-04-30 00:54:13 -0700657 if (tty->ops->close)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700658 for (n = 0; n < closecount; n++)
Alan Coxf34d7a52008-04-30 00:54:13 -0700659 tty->ops->close(tty, cons_filp);
660 } else if (tty->ops->hangup)
661 (tty->ops->hangup)(tty);
Alan Cox37bdfb02008-02-08 04:18:47 -0800662 /*
663 * We don't want to have driver/ldisc interactions beyond
664 * the ones we did here. The driver layer expects no
665 * calls after ->hangup() from the ldisc side. However we
666 * can't yet guarantee all that.
667 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700668 set_bit(TTY_HUPPED, &tty->flags);
Jiri Slabyacfa7472010-11-29 10:16:54 +0100669 clear_bit(TTY_HUPPING, &tty->flags);
Alan Coxc65c9bc2009-06-11 12:50:12 +0100670 tty_ldisc_enable(tty);
Arnd Bergmann11dbf202010-06-18 14:58:07 +0200671
Alan Cox89c8d912012-08-08 16:30:13 +0100672 tty_unlock(tty);
Arnd Bergmann11dbf202010-06-18 14:58:07 +0200673
Linus Torvalds1da177e2005-04-16 15:20:36 -0700674 if (f)
675 fput(f);
676}
677
Arnd Bergmannddcd9fb2010-06-01 22:53:08 +0200678static void do_tty_hangup(struct work_struct *work)
679{
680 struct tty_struct *tty =
681 container_of(work, struct tty_struct, hangup_work);
682
Arnd Bergmann11dbf202010-06-18 14:58:07 +0200683 __tty_hangup(tty);
Arnd Bergmannddcd9fb2010-06-01 22:53:08 +0200684}
685
Alan Coxaf9b8972006-08-27 01:24:01 -0700686/**
687 * tty_hangup - trigger a hangup event
688 * @tty: tty to hangup
689 *
690 * A carrier loss (virtual or otherwise) has occurred on this like
691 * schedule a hangup sequence to run after this event.
692 */
693
Alan Cox37bdfb02008-02-08 04:18:47 -0800694void tty_hangup(struct tty_struct *tty)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700695{
696#ifdef TTY_DEBUG_HANGUP
697 char buf[64];
Linus Torvalds1da177e2005-04-16 15:20:36 -0700698 printk(KERN_DEBUG "%s hangup...\n", tty_name(tty, buf));
699#endif
700 schedule_work(&tty->hangup_work);
701}
702
703EXPORT_SYMBOL(tty_hangup);
704
Alan Coxaf9b8972006-08-27 01:24:01 -0700705/**
706 * tty_vhangup - process vhangup
707 * @tty: tty to hangup
708 *
709 * The user has asked via system call for the terminal to be hung up.
710 * We do this synchronously so that when the syscall returns the process
Robert P. J. Day3a4fa0a2007-10-19 23:10:43 +0200711 * is complete. That guarantee is necessary for security reasons.
Alan Coxaf9b8972006-08-27 01:24:01 -0700712 */
713
Alan Cox37bdfb02008-02-08 04:18:47 -0800714void tty_vhangup(struct tty_struct *tty)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700715{
716#ifdef TTY_DEBUG_HANGUP
717 char buf[64];
718
719 printk(KERN_DEBUG "%s vhangup...\n", tty_name(tty, buf));
720#endif
Arnd Bergmann11dbf202010-06-18 14:58:07 +0200721 __tty_hangup(tty);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700722}
Alan Cox37bdfb02008-02-08 04:18:47 -0800723
Linus Torvalds1da177e2005-04-16 15:20:36 -0700724EXPORT_SYMBOL(tty_vhangup);
725
Arnd Bergmann11dbf202010-06-18 14:58:07 +0200726
Alan Coxaf9b8972006-08-27 01:24:01 -0700727/**
Alan Cox2cb59982008-10-13 10:40:30 +0100728 * tty_vhangup_self - process vhangup for own ctty
729 *
730 * Perform a vhangup on the current controlling tty
731 */
732
733void tty_vhangup_self(void)
734{
735 struct tty_struct *tty;
736
Alan Cox2cb59982008-10-13 10:40:30 +0100737 tty = get_current_tty();
738 if (tty) {
739 tty_vhangup(tty);
740 tty_kref_put(tty);
741 }
Alan Cox2cb59982008-10-13 10:40:30 +0100742}
743
744/**
Alan Coxaf9b8972006-08-27 01:24:01 -0700745 * tty_hung_up_p - was tty hung up
746 * @filp: file pointer of tty
747 *
748 * Return true if the tty has been subject to a vhangup or a carrier
749 * loss
750 */
751
Alan Cox37bdfb02008-02-08 04:18:47 -0800752int tty_hung_up_p(struct file *filp)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700753{
754 return (filp->f_op == &hung_up_tty_fops);
755}
756
757EXPORT_SYMBOL(tty_hung_up_p);
758
Eric W. Biedermanab521dc2007-02-12 00:53:00 -0800759static void session_clear_tty(struct pid *session)
Peter Zijlstra24ec8392006-12-08 02:36:04 -0800760{
761 struct task_struct *p;
Eric W. Biedermanab521dc2007-02-12 00:53:00 -0800762 do_each_pid_task(session, PIDTYPE_SID, p) {
Peter Zijlstra24ec8392006-12-08 02:36:04 -0800763 proc_clear_tty(p);
Eric W. Biedermanab521dc2007-02-12 00:53:00 -0800764 } while_each_pid_task(session, PIDTYPE_SID, p);
Peter Zijlstra24ec8392006-12-08 02:36:04 -0800765}
766
Alan Coxaf9b8972006-08-27 01:24:01 -0700767/**
768 * disassociate_ctty - disconnect controlling tty
769 * @on_exit: true if exiting so need to "hang up" the session
Linus Torvalds1da177e2005-04-16 15:20:36 -0700770 *
Alan Coxaf9b8972006-08-27 01:24:01 -0700771 * This function is typically called only by the session leader, when
772 * it wants to disassociate itself from its controlling tty.
773 *
774 * It performs the following functions:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700775 * (1) Sends a SIGHUP and SIGCONT to the foreground process group
776 * (2) Clears the tty from being controlling the session
777 * (3) Clears the controlling tty for all processes in the
778 * session group.
779 *
Alan Coxaf9b8972006-08-27 01:24:01 -0700780 * The argument on_exit is set to 1 if called when a process is
781 * exiting; it is 0 if called by the ioctl TIOCNOTTY.
782 *
Peter Zijlstra24ec8392006-12-08 02:36:04 -0800783 * Locking:
Arnd Bergmannec79d602010-06-01 22:53:01 +0200784 * BTM is taken for hysterical raisins, and held when
785 * called from no_tty().
Peter Zijlstra24ec8392006-12-08 02:36:04 -0800786 * tty_mutex is taken to protect tty
787 * ->siglock is taken to protect ->signal/->sighand
788 * tasklist_lock is taken to walk process list for sessions
789 * ->siglock is taken to protect ->signal/->sighand
Linus Torvalds1da177e2005-04-16 15:20:36 -0700790 */
Alan Coxaf9b8972006-08-27 01:24:01 -0700791
Linus Torvalds1da177e2005-04-16 15:20:36 -0700792void disassociate_ctty(int on_exit)
793{
794 struct tty_struct *tty;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700795
Alan Cox5ec93d12009-11-30 13:18:45 +0000796 if (!current->signal->leader)
797 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700798
Peter Zijlstra24ec8392006-12-08 02:36:04 -0800799 tty = get_current_tty();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700800 if (tty) {
Jiri Slaby1411dc42011-11-09 21:33:18 +0100801 struct pid *tty_pgrp = get_pid(tty->pgrp);
Arnd Bergmannddcd9fb2010-06-01 22:53:08 +0200802 if (on_exit) {
Arnd Bergmannddcd9fb2010-06-01 22:53:08 +0200803 if (tty->driver->type != TTY_DRIVER_TYPE_PTY)
Arnd Bergmann11dbf202010-06-18 14:58:07 +0200804 tty_vhangup(tty);
Arnd Bergmannddcd9fb2010-06-01 22:53:08 +0200805 }
Alan Cox452a00d2008-10-13 10:39:13 +0100806 tty_kref_put(tty);
Jiri Slaby1411dc42011-11-09 21:33:18 +0100807 if (tty_pgrp) {
808 kill_pgrp(tty_pgrp, SIGHUP, on_exit);
809 if (!on_exit)
810 kill_pgrp(tty_pgrp, SIGCONT, on_exit);
811 put_pid(tty_pgrp);
812 }
Eric W. Biederman680a9672007-02-12 00:52:52 -0800813 } else if (on_exit) {
Eric W. Biedermanab521dc2007-02-12 00:53:00 -0800814 struct pid *old_pgrp;
Eric W. Biederman680a9672007-02-12 00:52:52 -0800815 spin_lock_irq(&current->sighand->siglock);
816 old_pgrp = current->signal->tty_old_pgrp;
Eric W. Biedermanab521dc2007-02-12 00:53:00 -0800817 current->signal->tty_old_pgrp = NULL;
Eric W. Biederman680a9672007-02-12 00:52:52 -0800818 spin_unlock_irq(&current->sighand->siglock);
Peter Zijlstra24ec8392006-12-08 02:36:04 -0800819 if (old_pgrp) {
Eric W. Biedermanab521dc2007-02-12 00:53:00 -0800820 kill_pgrp(old_pgrp, SIGHUP, on_exit);
821 kill_pgrp(old_pgrp, SIGCONT, on_exit);
822 put_pid(old_pgrp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700823 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700824 return;
825 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700826
Peter Zijlstra24ec8392006-12-08 02:36:04 -0800827 spin_lock_irq(&current->sighand->siglock);
Eric W. Biederman2a65f1d2007-05-08 00:26:53 -0700828 put_pid(current->signal->tty_old_pgrp);
Randy Dunlap23cac8d2007-02-20 13:58:05 -0800829 current->signal->tty_old_pgrp = NULL;
Peter Zijlstra24ec8392006-12-08 02:36:04 -0800830 spin_unlock_irq(&current->sighand->siglock);
831
Peter Zijlstra24ec8392006-12-08 02:36:04 -0800832 tty = get_current_tty();
833 if (tty) {
Alan Cox47f86832008-04-30 00:53:30 -0700834 unsigned long flags;
835 spin_lock_irqsave(&tty->ctrl_lock, flags);
Eric W. Biedermanab521dc2007-02-12 00:53:00 -0800836 put_pid(tty->session);
837 put_pid(tty->pgrp);
838 tty->session = NULL;
839 tty->pgrp = NULL;
Alan Cox47f86832008-04-30 00:53:30 -0700840 spin_unlock_irqrestore(&tty->ctrl_lock, flags);
Alan Cox452a00d2008-10-13 10:39:13 +0100841 tty_kref_put(tty);
Peter Zijlstra24ec8392006-12-08 02:36:04 -0800842 } else {
843#ifdef TTY_DEBUG_HANGUP
844 printk(KERN_DEBUG "error attempted to write to tty [0x%p]"
845 " = NULL", tty);
846#endif
847 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700848
849 /* Now clear signal->tty under the lock */
850 read_lock(&tasklist_lock);
Eric W. Biedermanab521dc2007-02-12 00:53:00 -0800851 session_clear_tty(task_session(current));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700852 read_unlock(&tasklist_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700853}
854
Eric W. Biederman98a27ba2007-05-08 00:26:56 -0700855/**
856 *
857 * no_tty - Ensure the current process does not have a controlling tty
858 */
859void no_tty(void)
860{
Alan Cox3af502b2012-05-03 22:21:53 +0100861 /* FIXME: Review locking here. The tty_lock never covered any race
862 between a new association and proc_clear_tty but possible we need
863 to protect against this anyway */
Eric W. Biederman98a27ba2007-05-08 00:26:56 -0700864 struct task_struct *tsk = current;
Alan Cox5ec93d12009-11-30 13:18:45 +0000865 disassociate_ctty(0);
Eric W. Biederman98a27ba2007-05-08 00:26:56 -0700866 proc_clear_tty(tsk);
867}
868
Alan Coxaf9b8972006-08-27 01:24:01 -0700869
870/**
Robert P. J. Daybeb7dd82007-05-09 07:14:03 +0200871 * stop_tty - propagate flow control
Alan Coxaf9b8972006-08-27 01:24:01 -0700872 * @tty: tty to stop
873 *
874 * Perform flow control to the driver. For PTY/TTY pairs we
Robert P. J. Daybeb7dd82007-05-09 07:14:03 +0200875 * must also propagate the TIOCKPKT status. May be called
Alan Coxaf9b8972006-08-27 01:24:01 -0700876 * on an already stopped device and will not re-call the driver
877 * method.
878 *
879 * This functionality is used by both the line disciplines for
880 * halting incoming flow and by the driver. It may therefore be
881 * called from any context, may be under the tty atomic_write_lock
882 * but not always.
883 *
884 * Locking:
Alan Cox04f378b2008-04-30 00:53:29 -0700885 * Uses the tty control lock internally
Alan Coxaf9b8972006-08-27 01:24:01 -0700886 */
887
Linus Torvalds1da177e2005-04-16 15:20:36 -0700888void stop_tty(struct tty_struct *tty)
889{
Alan Cox04f378b2008-04-30 00:53:29 -0700890 unsigned long flags;
891 spin_lock_irqsave(&tty->ctrl_lock, flags);
892 if (tty->stopped) {
893 spin_unlock_irqrestore(&tty->ctrl_lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700894 return;
Alan Cox04f378b2008-04-30 00:53:29 -0700895 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700896 tty->stopped = 1;
897 if (tty->link && tty->link->packet) {
898 tty->ctrl_status &= ~TIOCPKT_START;
899 tty->ctrl_status |= TIOCPKT_STOP;
Davide Libenzi4b194492009-03-31 15:24:24 -0700900 wake_up_interruptible_poll(&tty->link->read_wait, POLLIN);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700901 }
Alan Cox04f378b2008-04-30 00:53:29 -0700902 spin_unlock_irqrestore(&tty->ctrl_lock, flags);
Alan Coxf34d7a52008-04-30 00:54:13 -0700903 if (tty->ops->stop)
904 (tty->ops->stop)(tty);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700905}
906
907EXPORT_SYMBOL(stop_tty);
908
Alan Coxaf9b8972006-08-27 01:24:01 -0700909/**
Robert P. J. Daybeb7dd82007-05-09 07:14:03 +0200910 * start_tty - propagate flow control
Alan Coxaf9b8972006-08-27 01:24:01 -0700911 * @tty: tty to start
912 *
913 * Start a tty that has been stopped if at all possible. Perform
Robert P. J. Day3a4fa0a2007-10-19 23:10:43 +0200914 * any necessary wakeups and propagate the TIOCPKT status. If this
Alan Coxaf9b8972006-08-27 01:24:01 -0700915 * is the tty was previous stopped and is being started then the
916 * driver start method is invoked and the line discipline woken.
917 *
918 * Locking:
Alan Cox04f378b2008-04-30 00:53:29 -0700919 * ctrl_lock
Alan Coxaf9b8972006-08-27 01:24:01 -0700920 */
921
Linus Torvalds1da177e2005-04-16 15:20:36 -0700922void start_tty(struct tty_struct *tty)
923{
Alan Cox04f378b2008-04-30 00:53:29 -0700924 unsigned long flags;
925 spin_lock_irqsave(&tty->ctrl_lock, flags);
926 if (!tty->stopped || tty->flow_stopped) {
927 spin_unlock_irqrestore(&tty->ctrl_lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700928 return;
Alan Cox04f378b2008-04-30 00:53:29 -0700929 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700930 tty->stopped = 0;
931 if (tty->link && tty->link->packet) {
932 tty->ctrl_status &= ~TIOCPKT_STOP;
933 tty->ctrl_status |= TIOCPKT_START;
Davide Libenzi4b194492009-03-31 15:24:24 -0700934 wake_up_interruptible_poll(&tty->link->read_wait, POLLIN);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700935 }
Alan Cox04f378b2008-04-30 00:53:29 -0700936 spin_unlock_irqrestore(&tty->ctrl_lock, flags);
Alan Coxf34d7a52008-04-30 00:54:13 -0700937 if (tty->ops->start)
938 (tty->ops->start)(tty);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700939 /* If we have a running line discipline it may need kicking */
940 tty_wakeup(tty);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700941}
942
943EXPORT_SYMBOL(start_tty);
944
Alan Coxaf9b8972006-08-27 01:24:01 -0700945/**
946 * tty_read - read method for tty device files
947 * @file: pointer to tty file
948 * @buf: user buffer
949 * @count: size of user buffer
950 * @ppos: unused
951 *
952 * Perform the read system call function on this terminal device. Checks
953 * for hung up devices before calling the line discipline method.
954 *
955 * Locking:
Alan Cox47f86832008-04-30 00:53:30 -0700956 * Locks the line discipline internally while needed. Multiple
957 * read calls may be outstanding in parallel.
Alan Coxaf9b8972006-08-27 01:24:01 -0700958 */
959
Alan Cox37bdfb02008-02-08 04:18:47 -0800960static ssize_t tty_read(struct file *file, char __user *buf, size_t count,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700961 loff_t *ppos)
962{
963 int i;
Nick Piggind996b622010-08-18 04:37:36 +1000964 struct inode *inode = file->f_path.dentry->d_inode;
965 struct tty_struct *tty = file_tty(file);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700966 struct tty_ldisc *ld;
967
Linus Torvalds1da177e2005-04-16 15:20:36 -0700968 if (tty_paranoia_check(tty, inode, "tty_read"))
969 return -EIO;
970 if (!tty || (test_bit(TTY_IO_ERROR, &tty->flags)))
971 return -EIO;
972
973 /* We want to wait for the line discipline to sort out in this
974 situation */
975 ld = tty_ldisc_ref_wait(tty);
Alan Coxa352def2008-07-16 21:53:12 +0100976 if (ld->ops->read)
977 i = (ld->ops->read)(tty, file, buf, count);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700978 else
979 i = -EIO;
980 tty_ldisc_deref(ld);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700981 if (i > 0)
982 inode->i_atime = current_fs_time(inode->i_sb);
983 return i;
984}
985
Alan Cox9c1729d2007-07-15 23:39:43 -0700986void tty_write_unlock(struct tty_struct *tty)
Jiri Slaby83c67572011-04-20 10:43:18 +0200987 __releases(&tty->atomic_write_lock)
Alan Cox9c1729d2007-07-15 23:39:43 -0700988{
989 mutex_unlock(&tty->atomic_write_lock);
Davide Libenzi4b194492009-03-31 15:24:24 -0700990 wake_up_interruptible_poll(&tty->write_wait, POLLOUT);
Alan Cox9c1729d2007-07-15 23:39:43 -0700991}
992
993int tty_write_lock(struct tty_struct *tty, int ndelay)
Jiri Slaby83c67572011-04-20 10:43:18 +0200994 __acquires(&tty->atomic_write_lock)
Alan Cox9c1729d2007-07-15 23:39:43 -0700995{
996 if (!mutex_trylock(&tty->atomic_write_lock)) {
997 if (ndelay)
998 return -EAGAIN;
999 if (mutex_lock_interruptible(&tty->atomic_write_lock))
1000 return -ERESTARTSYS;
1001 }
1002 return 0;
1003}
1004
Linus Torvalds1da177e2005-04-16 15:20:36 -07001005/*
1006 * Split writes up in sane blocksizes to avoid
1007 * denial-of-service type attacks
1008 */
1009static inline ssize_t do_tty_write(
1010 ssize_t (*write)(struct tty_struct *, struct file *, const unsigned char *, size_t),
1011 struct tty_struct *tty,
1012 struct file *file,
1013 const char __user *buf,
1014 size_t count)
1015{
Alan Cox9c1729d2007-07-15 23:39:43 -07001016 ssize_t ret, written = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001017 unsigned int chunk;
Alan Cox37bdfb02008-02-08 04:18:47 -08001018
Alan Cox9c1729d2007-07-15 23:39:43 -07001019 ret = tty_write_lock(tty, file->f_flags & O_NDELAY);
1020 if (ret < 0)
1021 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001022
1023 /*
1024 * We chunk up writes into a temporary buffer. This
1025 * simplifies low-level drivers immensely, since they
1026 * don't have locking issues and user mode accesses.
1027 *
1028 * But if TTY_NO_WRITE_SPLIT is set, we should use a
1029 * big chunk-size..
1030 *
1031 * The default chunk-size is 2kB, because the NTTY
1032 * layer has problems with bigger chunks. It will
1033 * claim to be able to handle more characters than
1034 * it actually does.
Alan Coxaf9b8972006-08-27 01:24:01 -07001035 *
1036 * FIXME: This can probably go away now except that 64K chunks
1037 * are too likely to fail unless switched to vmalloc...
Linus Torvalds1da177e2005-04-16 15:20:36 -07001038 */
1039 chunk = 2048;
1040 if (test_bit(TTY_NO_WRITE_SPLIT, &tty->flags))
1041 chunk = 65536;
1042 if (count < chunk)
1043 chunk = count;
1044
Ingo Molnar70522e12006-03-23 03:00:31 -08001045 /* write_buf/write_cnt is protected by the atomic_write_lock mutex */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001046 if (tty->write_cnt < chunk) {
Jason Wessel402fda92008-10-13 10:45:36 +01001047 unsigned char *buf_chunk;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001048
1049 if (chunk < 1024)
1050 chunk = 1024;
1051
Jason Wessel402fda92008-10-13 10:45:36 +01001052 buf_chunk = kmalloc(chunk, GFP_KERNEL);
1053 if (!buf_chunk) {
Alan Cox9c1729d2007-07-15 23:39:43 -07001054 ret = -ENOMEM;
1055 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001056 }
1057 kfree(tty->write_buf);
1058 tty->write_cnt = chunk;
Jason Wessel402fda92008-10-13 10:45:36 +01001059 tty->write_buf = buf_chunk;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001060 }
1061
1062 /* Do the write .. */
1063 for (;;) {
1064 size_t size = count;
1065 if (size > chunk)
1066 size = chunk;
1067 ret = -EFAULT;
1068 if (copy_from_user(tty->write_buf, buf, size))
1069 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001070 ret = write(tty, file, tty->write_buf, size);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001071 if (ret <= 0)
1072 break;
1073 written += ret;
1074 buf += ret;
1075 count -= ret;
1076 if (!count)
1077 break;
1078 ret = -ERESTARTSYS;
1079 if (signal_pending(current))
1080 break;
1081 cond_resched();
1082 }
1083 if (written) {
Josef Sipeka7113a92006-12-08 02:36:55 -08001084 struct inode *inode = file->f_path.dentry->d_inode;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001085 inode->i_mtime = current_fs_time(inode->i_sb);
1086 ret = written;
1087 }
Alan Cox9c1729d2007-07-15 23:39:43 -07001088out:
1089 tty_write_unlock(tty);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001090 return ret;
1091}
1092
Alan Cox95f9bfc2008-10-13 10:39:23 +01001093/**
1094 * tty_write_message - write a message to a certain tty, not just the console.
1095 * @tty: the destination tty_struct
1096 * @msg: the message to write
1097 *
1098 * This is used for messages that need to be redirected to a specific tty.
1099 * We don't put it into the syslog queue right now maybe in the future if
1100 * really needed.
1101 *
Arnd Bergmannec79d602010-06-01 22:53:01 +02001102 * We must still hold the BTM and test the CLOSING flag for the moment.
Alan Cox95f9bfc2008-10-13 10:39:23 +01001103 */
1104
1105void tty_write_message(struct tty_struct *tty, char *msg)
1106{
Alan Cox95f9bfc2008-10-13 10:39:23 +01001107 if (tty) {
1108 mutex_lock(&tty->atomic_write_lock);
Alan Cox89c8d912012-08-08 16:30:13 +01001109 tty_lock(tty);
Alan Coxeeb89d92009-11-30 13:18:29 +00001110 if (tty->ops->write && !test_bit(TTY_CLOSING, &tty->flags)) {
Alan Cox89c8d912012-08-08 16:30:13 +01001111 tty_unlock(tty);
Alan Cox95f9bfc2008-10-13 10:39:23 +01001112 tty->ops->write(tty, msg, strlen(msg));
Alan Coxeeb89d92009-11-30 13:18:29 +00001113 } else
Alan Cox89c8d912012-08-08 16:30:13 +01001114 tty_unlock(tty);
Alan Cox95f9bfc2008-10-13 10:39:23 +01001115 tty_write_unlock(tty);
1116 }
Alan Cox95f9bfc2008-10-13 10:39:23 +01001117 return;
1118}
1119
Linus Torvalds1da177e2005-04-16 15:20:36 -07001120
Alan Coxaf9b8972006-08-27 01:24:01 -07001121/**
1122 * tty_write - write method for tty device file
1123 * @file: tty file pointer
1124 * @buf: user data to write
1125 * @count: bytes to write
1126 * @ppos: unused
1127 *
1128 * Write data to a tty device via the line discipline.
1129 *
1130 * Locking:
1131 * Locks the line discipline as required
1132 * Writes to the tty driver are serialized by the atomic_write_lock
1133 * and are then processed in chunks to the device. The line discipline
Joe Petersona88a69c2009-01-02 13:40:53 +00001134 * write method will not be invoked in parallel for each device.
Alan Coxaf9b8972006-08-27 01:24:01 -07001135 */
1136
Alan Cox37bdfb02008-02-08 04:18:47 -08001137static ssize_t tty_write(struct file *file, const char __user *buf,
1138 size_t count, loff_t *ppos)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001139{
Josef Sipeka7113a92006-12-08 02:36:55 -08001140 struct inode *inode = file->f_path.dentry->d_inode;
Nick Piggind996b622010-08-18 04:37:36 +10001141 struct tty_struct *tty = file_tty(file);
1142 struct tty_ldisc *ld;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001143 ssize_t ret;
Alan Cox37bdfb02008-02-08 04:18:47 -08001144
Linus Torvalds1da177e2005-04-16 15:20:36 -07001145 if (tty_paranoia_check(tty, inode, "tty_write"))
1146 return -EIO;
Alan Coxf34d7a52008-04-30 00:54:13 -07001147 if (!tty || !tty->ops->write ||
Alan Cox37bdfb02008-02-08 04:18:47 -08001148 (test_bit(TTY_IO_ERROR, &tty->flags)))
1149 return -EIO;
Alan Coxf34d7a52008-04-30 00:54:13 -07001150 /* Short term debug to catch buggy drivers */
1151 if (tty->ops->write_room == NULL)
1152 printk(KERN_ERR "tty driver %s lacks a write_room method.\n",
1153 tty->driver->name);
Alan Cox37bdfb02008-02-08 04:18:47 -08001154 ld = tty_ldisc_ref_wait(tty);
Alan Coxa352def2008-07-16 21:53:12 +01001155 if (!ld->ops->write)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001156 ret = -EIO;
1157 else
Alan Coxa352def2008-07-16 21:53:12 +01001158 ret = do_tty_write(ld->ops->write, tty, file, buf, count);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001159 tty_ldisc_deref(ld);
1160 return ret;
1161}
1162
Alan Cox37bdfb02008-02-08 04:18:47 -08001163ssize_t redirected_tty_write(struct file *file, const char __user *buf,
1164 size_t count, loff_t *ppos)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001165{
1166 struct file *p = NULL;
1167
1168 spin_lock(&redirect_lock);
1169 if (redirect) {
1170 get_file(redirect);
1171 p = redirect;
1172 }
1173 spin_unlock(&redirect_lock);
1174
1175 if (p) {
1176 ssize_t res;
1177 res = vfs_write(p, buf, count, &p->f_pos);
1178 fput(p);
1179 return res;
1180 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001181 return tty_write(file, buf, count, ppos);
1182}
1183
1184static char ptychar[] = "pqrstuvwxyzabcde";
1185
Alan Coxaf9b8972006-08-27 01:24:01 -07001186/**
1187 * pty_line_name - generate name for a pty
1188 * @driver: the tty driver in use
1189 * @index: the minor number
1190 * @p: output buffer of at least 6 bytes
1191 *
1192 * Generate a name from a driver reference and write it to the output
1193 * buffer.
1194 *
1195 * Locking: None
1196 */
1197static void pty_line_name(struct tty_driver *driver, int index, char *p)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001198{
1199 int i = index + driver->name_base;
1200 /* ->name is initialized to "ttyp", but "tty" is expected */
1201 sprintf(p, "%s%c%x",
Alan Cox37bdfb02008-02-08 04:18:47 -08001202 driver->subtype == PTY_TYPE_SLAVE ? "tty" : driver->name,
1203 ptychar[i >> 4 & 0xf], i & 0xf);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001204}
1205
Alan Coxaf9b8972006-08-27 01:24:01 -07001206/**
Alan Cox8b0a88d2008-10-13 10:42:19 +01001207 * tty_line_name - generate name for a tty
Alan Coxaf9b8972006-08-27 01:24:01 -07001208 * @driver: the tty driver in use
1209 * @index: the minor number
1210 * @p: output buffer of at least 7 bytes
1211 *
1212 * Generate a name from a driver reference and write it to the output
1213 * buffer.
1214 *
1215 * Locking: None
1216 */
1217static void tty_line_name(struct tty_driver *driver, int index, char *p)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001218{
Jiri Slaby0019b402012-08-08 22:26:43 +02001219 if (driver->flags & TTY_DRIVER_UNNUMBERED_NODE)
1220 strcpy(p, driver->name);
1221 else
1222 sprintf(p, "%s%d", driver->name, index + driver->name_base);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001223}
1224
Alan Cox99f1fe12008-10-13 10:42:00 +01001225/**
1226 * tty_driver_lookup_tty() - find an existing tty, if any
1227 * @driver: the driver for the tty
1228 * @idx: the minor number
Sukadev Bhattiprolu23499702008-10-13 10:41:51 +01001229 *
Alan Cox99f1fe12008-10-13 10:42:00 +01001230 * Return the tty, if found or ERR_PTR() otherwise.
Sukadev Bhattiprolu23499702008-10-13 10:41:51 +01001231 *
Alan Cox99f1fe12008-10-13 10:42:00 +01001232 * Locking: tty_mutex must be held. If tty is found, the mutex must
1233 * be held until the 'fast-open' is also done. Will change once we
1234 * have refcounting in the driver and per driver locking
Sukadev Bhattiprolu23499702008-10-13 10:41:51 +01001235 */
Jason Wessela47d5452009-01-02 13:43:04 +00001236static struct tty_struct *tty_driver_lookup_tty(struct tty_driver *driver,
Sukadev Bhattiprolu15f1a632008-10-13 10:42:59 +01001237 struct inode *inode, int idx)
Sukadev Bhattiprolu23499702008-10-13 10:41:51 +01001238{
Alan Cox99f1fe12008-10-13 10:42:00 +01001239 if (driver->ops->lookup)
Sukadev Bhattiprolu15f1a632008-10-13 10:42:59 +01001240 return driver->ops->lookup(driver, inode, idx);
Sukadev Bhattiprolu23499702008-10-13 10:41:51 +01001241
Jiri Slabyd4834262012-03-05 14:51:53 +01001242 return driver->ttys[idx];
Sukadev Bhattiprolu23499702008-10-13 10:41:51 +01001243}
1244
Alan Cox99f1fe12008-10-13 10:42:00 +01001245/**
Alan Coxbf970ee2008-10-13 10:42:39 +01001246 * tty_init_termios - helper for termios setup
1247 * @tty: the tty to set up
1248 *
1249 * Initialise the termios structures for this tty. Thus runs under
1250 * the tty_mutex currently so we can be relaxed about ordering.
1251 */
1252
1253int tty_init_termios(struct tty_struct *tty)
1254{
Alan Coxfe6e29f2008-10-13 10:44:08 +01001255 struct ktermios *tp;
Alan Coxbf970ee2008-10-13 10:42:39 +01001256 int idx = tty->index;
1257
Alan Cox36b3c072012-07-17 17:06:57 +01001258 if (tty->driver->flags & TTY_DRIVER_RESET_TERMIOS)
1259 tty->termios = tty->driver->init_termios;
1260 else {
1261 /* Check for lazy saved data */
1262 tp = tty->driver->termios[idx];
1263 if (tp != NULL)
1264 tty->termios = *tp;
1265 else
1266 tty->termios = tty->driver->init_termios;
Alan Coxbf970ee2008-10-13 10:42:39 +01001267 }
Alan Coxbf970ee2008-10-13 10:42:39 +01001268 /* Compatibility until drivers always set this */
Alan Coxadc8d742012-07-14 15:31:47 +01001269 tty->termios.c_ispeed = tty_termios_input_baud_rate(&tty->termios);
1270 tty->termios.c_ospeed = tty_termios_baud_rate(&tty->termios);
Alan Coxbf970ee2008-10-13 10:42:39 +01001271 return 0;
1272}
Alan Coxfe1ae7f2009-09-19 13:13:33 -07001273EXPORT_SYMBOL_GPL(tty_init_termios);
Alan Coxbf970ee2008-10-13 10:42:39 +01001274
Jiri Slaby66d450e2012-01-30 21:14:28 +01001275int tty_standard_install(struct tty_driver *driver, struct tty_struct *tty)
1276{
1277 int ret = tty_init_termios(tty);
1278 if (ret)
1279 return ret;
1280
1281 tty_driver_kref_get(driver);
1282 tty->count++;
1283 driver->ttys[tty->index] = tty;
1284 return 0;
1285}
1286EXPORT_SYMBOL_GPL(tty_standard_install);
1287
Alan Coxbf970ee2008-10-13 10:42:39 +01001288/**
Alan Cox8b0a88d2008-10-13 10:42:19 +01001289 * tty_driver_install_tty() - install a tty entry in the driver
1290 * @driver: the driver for the tty
1291 * @tty: the tty
1292 *
1293 * Install a tty object into the driver tables. The tty->index field
Alan Coxbf970ee2008-10-13 10:42:39 +01001294 * will be set by the time this is called. This method is responsible
1295 * for ensuring any need additional structures are allocated and
1296 * configured.
Alan Cox8b0a88d2008-10-13 10:42:19 +01001297 *
1298 * Locking: tty_mutex for now
1299 */
1300static int tty_driver_install_tty(struct tty_driver *driver,
1301 struct tty_struct *tty)
1302{
Jiri Slaby66d450e2012-01-30 21:14:28 +01001303 return driver->ops->install ? driver->ops->install(driver, tty) :
1304 tty_standard_install(driver, tty);
Alan Cox8b0a88d2008-10-13 10:42:19 +01001305}
1306
1307/**
1308 * tty_driver_remove_tty() - remove a tty from the driver tables
1309 * @driver: the driver for the tty
1310 * @idx: the minor number
1311 *
1312 * Remvoe a tty object from the driver tables. The tty->index field
1313 * will be set by the time this is called.
1314 *
1315 * Locking: tty_mutex for now
1316 */
Jiri Slaby24d406a2011-08-10 14:59:28 +02001317void tty_driver_remove_tty(struct tty_driver *driver, struct tty_struct *tty)
Alan Cox8b0a88d2008-10-13 10:42:19 +01001318{
1319 if (driver->ops->remove)
1320 driver->ops->remove(driver, tty);
1321 else
1322 driver->ttys[tty->index] = NULL;
1323}
1324
1325/*
1326 * tty_reopen() - fast re-open of an open tty
1327 * @tty - the tty to open
Sukadev Bhattiprolu23499702008-10-13 10:41:51 +01001328 *
Alan Cox99f1fe12008-10-13 10:42:00 +01001329 * Return 0 on success, -errno on error.
Sukadev Bhattiprolu23499702008-10-13 10:41:51 +01001330 *
Alan Cox99f1fe12008-10-13 10:42:00 +01001331 * Locking: tty_mutex must be held from the time the tty was found
1332 * till this open completes.
Sukadev Bhattiprolu23499702008-10-13 10:41:51 +01001333 */
Alan Cox99f1fe12008-10-13 10:42:00 +01001334static int tty_reopen(struct tty_struct *tty)
Sukadev Bhattiprolu23499702008-10-13 10:41:51 +01001335{
1336 struct tty_driver *driver = tty->driver;
1337
Jiri Slabye2efafb2010-11-29 10:16:53 +01001338 if (test_bit(TTY_CLOSING, &tty->flags) ||
Jiri Slabyacfa7472010-11-29 10:16:54 +01001339 test_bit(TTY_HUPPING, &tty->flags) ||
Jiri Slabye2efafb2010-11-29 10:16:53 +01001340 test_bit(TTY_LDISC_CHANGING, &tty->flags))
Sukadev Bhattiprolu23499702008-10-13 10:41:51 +01001341 return -EIO;
1342
1343 if (driver->type == TTY_DRIVER_TYPE_PTY &&
1344 driver->subtype == PTY_TYPE_MASTER) {
1345 /*
1346 * special case for PTY masters: only one open permitted,
1347 * and the slave side open count is incremented as well.
1348 */
1349 if (tty->count)
1350 return -EIO;
1351
1352 tty->link->count++;
1353 }
1354 tty->count++;
Sukadev Bhattiprolu23499702008-10-13 10:41:51 +01001355
Alan Cox1aa4bed2009-06-16 17:01:33 +01001356 mutex_lock(&tty->ldisc_mutex);
Alan Cox99f1fe12008-10-13 10:42:00 +01001357 WARN_ON(!test_bit(TTY_LDISC, &tty->flags));
Alan Cox1aa4bed2009-06-16 17:01:33 +01001358 mutex_unlock(&tty->ldisc_mutex);
Sukadev Bhattiprolu23499702008-10-13 10:41:51 +01001359
1360 return 0;
1361}
1362
Alan Coxaf9b8972006-08-27 01:24:01 -07001363/**
Alan Coxd81ed102008-10-13 10:41:42 +01001364 * tty_init_dev - initialise a tty device
Alan Coxaf9b8972006-08-27 01:24:01 -07001365 * @driver: tty driver we are opening a device on
1366 * @idx: device index
Alan Cox15582d32008-10-13 10:41:03 +01001367 * @ret_tty: returned tty structure
Alan Coxaf9b8972006-08-27 01:24:01 -07001368 *
1369 * Prepare a tty device. This may not be a "new" clean device but
1370 * could also be an active device. The pty drivers require special
1371 * handling because of this.
1372 *
1373 * Locking:
1374 * The function is called under the tty_mutex, which
1375 * protects us from the tty struct or driver itself going away.
1376 *
1377 * On exit the tty device has the line discipline attached and
1378 * a reference count of 1. If a pair was created for pty/tty use
1379 * and the other was a pty master then it too has a reference count of 1.
1380 *
Linus Torvalds1da177e2005-04-16 15:20:36 -07001381 * WSH 06/09/97: Rewritten to remove races and properly clean up after a
Ingo Molnar70522e12006-03-23 03:00:31 -08001382 * failed open. The new code protects the open with a mutex, so it's
1383 * really quite straightforward. The mutex locking can probably be
Linus Torvalds1da177e2005-04-16 15:20:36 -07001384 * relaxed for the (most common) case of reopening a tty.
1385 */
Alan Coxaf9b8972006-08-27 01:24:01 -07001386
Konstantin Khlebnikov593a27c2012-01-05 13:04:21 +04001387struct tty_struct *tty_init_dev(struct tty_driver *driver, int idx)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001388{
Alan Coxbf970ee2008-10-13 10:42:39 +01001389 struct tty_struct *tty;
Alan Cox73ec06f2008-10-13 10:42:29 +01001390 int retval;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001391
Linus Torvalds1da177e2005-04-16 15:20:36 -07001392 /*
1393 * First time open is complex, especially for PTY devices.
1394 * This code guarantees that either everything succeeds and the
1395 * TTY is ready for operation, or else the table slots are vacated
Alan Cox37bdfb02008-02-08 04:18:47 -08001396 * and the allocated memory released. (Except that the termios
Linus Torvalds1da177e2005-04-16 15:20:36 -07001397 * and locked termios may be retained.)
1398 */
1399
Alan Cox73ec06f2008-10-13 10:42:29 +01001400 if (!try_module_get(driver->owner))
1401 return ERR_PTR(-ENODEV);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001402
Linus Torvalds1da177e2005-04-16 15:20:36 -07001403 tty = alloc_tty_struct();
Jiri Slabyd5543502011-03-23 10:48:32 +01001404 if (!tty) {
1405 retval = -ENOMEM;
1406 goto err_module_put;
1407 }
Alan Coxbf970ee2008-10-13 10:42:39 +01001408 initialize_tty_struct(tty, driver, idx);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001409
Alan Cox89c8d912012-08-08 16:30:13 +01001410 tty_lock(tty);
Alan Cox73ec06f2008-10-13 10:42:29 +01001411 retval = tty_driver_install_tty(driver, tty);
Jiri Slabyd5543502011-03-23 10:48:32 +01001412 if (retval < 0)
Jiri Slabya9dccdd2011-03-23 10:48:36 +01001413 goto err_deinit_tty;
Alan Cox8b0a88d2008-10-13 10:42:19 +01001414
Jiri Slaby04831dc2012-06-04 13:35:36 +02001415 if (!tty->port)
1416 tty->port = driver->ports[idx];
1417
Jiri Slaby5d4121c2012-08-17 14:27:52 +02001418 WARN_RATELIMIT(!tty->port,
1419 "%s: %s driver does not set tty->port. This will crash the kernel later. Fix the driver!\n",
1420 __func__, tty->driver->name);
1421
Alan Cox37bdfb02008-02-08 04:18:47 -08001422 /*
Linus Torvalds1da177e2005-04-16 15:20:36 -07001423 * Structures all installed ... call the ldisc open routines.
Christoph Hellwigd5698c22007-02-10 01:46:46 -08001424 * If we fail here just call release_tty to clean up. No need
1425 * to decrement the use counts, as release_tty doesn't care.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001426 */
Alan Coxbf970ee2008-10-13 10:42:39 +01001427 retval = tty_ldisc_setup(tty, tty->link);
Alan Cox01e1abb2008-07-22 11:16:55 +01001428 if (retval)
Jiri Slabyd5543502011-03-23 10:48:32 +01001429 goto err_release_tty;
Alan Cox89c8d912012-08-08 16:30:13 +01001430 /* Return the tty locked so that it cannot vanish under the caller */
Alan Cox73ec06f2008-10-13 10:42:29 +01001431 return tty;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001432
Jiri Slabya9dccdd2011-03-23 10:48:36 +01001433err_deinit_tty:
Alan Cox89c8d912012-08-08 16:30:13 +01001434 tty_unlock(tty);
Jiri Slabya9dccdd2011-03-23 10:48:36 +01001435 deinitialize_tty_struct(tty);
Jiri Slabyd5543502011-03-23 10:48:32 +01001436 free_tty_struct(tty);
1437err_module_put:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001438 module_put(driver->owner);
Jiri Slabyd5543502011-03-23 10:48:32 +01001439 return ERR_PTR(retval);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001440
Christoph Hellwigd5698c22007-02-10 01:46:46 -08001441 /* call the tty release_tty routine to clean out this slot */
Jiri Slabyd5543502011-03-23 10:48:32 +01001442err_release_tty:
Alan Cox89c8d912012-08-08 16:30:13 +01001443 tty_unlock(tty);
Manuel Zerpies5a3c6b22011-06-16 14:07:22 +02001444 printk_ratelimited(KERN_INFO "tty_init_dev: ldisc open failed, "
Akinobu Mita40509142006-09-29 02:01:27 -07001445 "clearing slot %d\n", idx);
Christoph Hellwigd5698c22007-02-10 01:46:46 -08001446 release_tty(tty, idx);
Alan Cox73ec06f2008-10-13 10:42:29 +01001447 return ERR_PTR(retval);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001448}
1449
Alan Coxfeebed62008-10-13 10:41:30 +01001450void tty_free_termios(struct tty_struct *tty)
1451{
1452 struct ktermios *tp;
1453 int idx = tty->index;
Alan Cox36b3c072012-07-17 17:06:57 +01001454
1455 /* If the port is going to reset then it has no termios to save */
1456 if (tty->driver->flags & TTY_DRIVER_RESET_TERMIOS)
1457 return;
1458
1459 /* Stash the termios data */
1460 tp = tty->driver->termios[idx];
1461 if (tp == NULL) {
1462 tp = kmalloc(sizeof(struct ktermios), GFP_KERNEL);
1463 if (tp == NULL) {
1464 pr_warn("tty: no memory to save termios state.\n");
1465 return;
1466 }
Dan Carpenter4ac5d702012-07-24 12:51:52 +01001467 tty->driver->termios[idx] = tp;
Alan Coxfeebed62008-10-13 10:41:30 +01001468 }
Alan Cox36b3c072012-07-17 17:06:57 +01001469 *tp = tty->termios;
Alan Coxfeebed62008-10-13 10:41:30 +01001470}
1471EXPORT_SYMBOL(tty_free_termios);
1472
Alan Coxfeebed62008-10-13 10:41:30 +01001473
Alan Coxaf9b8972006-08-27 01:24:01 -07001474/**
Christoph Hellwigd5698c22007-02-10 01:46:46 -08001475 * release_one_tty - release tty structure memory
Alan Cox9c9f4de2008-10-13 10:37:26 +01001476 * @kref: kref of tty we are obliterating
Alan Coxaf9b8972006-08-27 01:24:01 -07001477 *
1478 * Releases memory associated with a tty structure, and clears out the
1479 * driver table slots. This function is called when a device is no longer
1480 * in use. It also gets called when setup of a device fails.
1481 *
1482 * Locking:
Alan Coxaf9b8972006-08-27 01:24:01 -07001483 * takes the file list lock internally when working on the list
1484 * of ttys that the driver keeps.
Alan Coxb50989d2009-09-19 13:13:22 -07001485 *
1486 * This method gets called from a work queue so that the driver private
Dave Youngf278a2f2009-09-27 16:00:42 +00001487 * cleanup ops can sleep (needed for USB at least)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001488 */
Alan Coxb50989d2009-09-19 13:13:22 -07001489static void release_one_tty(struct work_struct *work)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001490{
Alan Coxb50989d2009-09-19 13:13:22 -07001491 struct tty_struct *tty =
1492 container_of(work, struct tty_struct, hangup_work);
Alan Cox6f967f72008-10-13 10:37:36 +01001493 struct tty_driver *driver = tty->driver;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001494
Dave Youngf278a2f2009-09-27 16:00:42 +00001495 if (tty->ops->cleanup)
1496 tty->ops->cleanup(tty);
1497
Linus Torvalds1da177e2005-04-16 15:20:36 -07001498 tty->magic = 0;
Alan Cox7d7b93c2008-10-13 10:42:09 +01001499 tty_driver_kref_put(driver);
Alan Cox6f967f72008-10-13 10:37:36 +01001500 module_put(driver->owner);
Christoph Hellwigd5698c22007-02-10 01:46:46 -08001501
Nick Pigginee2ffa02010-08-18 04:37:35 +10001502 spin_lock(&tty_files_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001503 list_del_init(&tty->tty_files);
Nick Pigginee2ffa02010-08-18 04:37:35 +10001504 spin_unlock(&tty_files_lock);
Christoph Hellwigd5698c22007-02-10 01:46:46 -08001505
Oleg Nesterov6da8d862010-04-02 18:05:12 +02001506 put_pid(tty->pgrp);
1507 put_pid(tty->session);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001508 free_tty_struct(tty);
1509}
1510
Alan Coxb50989d2009-09-19 13:13:22 -07001511static void queue_release_one_tty(struct kref *kref)
1512{
1513 struct tty_struct *tty = container_of(kref, struct tty_struct, kref);
Dave Youngf278a2f2009-09-27 16:00:42 +00001514
Alan Coxb50989d2009-09-19 13:13:22 -07001515 /* The hangup queue is now free so we can reuse it rather than
1516 waste a chunk of memory for each port */
1517 INIT_WORK(&tty->hangup_work, release_one_tty);
1518 schedule_work(&tty->hangup_work);
1519}
1520
Christoph Hellwigd5698c22007-02-10 01:46:46 -08001521/**
Alan Cox9c9f4de2008-10-13 10:37:26 +01001522 * tty_kref_put - release a tty kref
1523 * @tty: tty device
1524 *
1525 * Release a reference to a tty device and if need be let the kref
1526 * layer destruct the object for us
1527 */
1528
1529void tty_kref_put(struct tty_struct *tty)
1530{
1531 if (tty)
Alan Coxb50989d2009-09-19 13:13:22 -07001532 kref_put(&tty->kref, queue_release_one_tty);
Alan Cox9c9f4de2008-10-13 10:37:26 +01001533}
1534EXPORT_SYMBOL(tty_kref_put);
1535
1536/**
Christoph Hellwigd5698c22007-02-10 01:46:46 -08001537 * release_tty - release tty structure memory
1538 *
1539 * Release both @tty and a possible linked partner (think pty pair),
1540 * and decrement the refcount of the backing module.
1541 *
1542 * Locking:
Alan Coxd1552552012-07-27 18:02:54 +01001543 * tty_mutex
Christoph Hellwigd5698c22007-02-10 01:46:46 -08001544 * takes the file list lock internally when working on the list
1545 * of ttys that the driver keeps.
Alan Cox9c9f4de2008-10-13 10:37:26 +01001546 *
Christoph Hellwigd5698c22007-02-10 01:46:46 -08001547 */
1548static void release_tty(struct tty_struct *tty, int idx)
1549{
Alan Cox9c9f4de2008-10-13 10:37:26 +01001550 /* This should always be true but check for the moment */
1551 WARN_ON(tty->index != idx);
Alan Coxd1552552012-07-27 18:02:54 +01001552 WARN_ON(!mutex_is_locked(&tty_mutex));
Alan Cox36b3c072012-07-17 17:06:57 +01001553 if (tty->ops->shutdown)
1554 tty->ops->shutdown(tty);
1555 tty_free_termios(tty);
1556 tty_driver_remove_tty(tty->driver, tty);
1557
Christoph Hellwigd5698c22007-02-10 01:46:46 -08001558 if (tty->link)
Alan Cox9c9f4de2008-10-13 10:37:26 +01001559 tty_kref_put(tty->link);
1560 tty_kref_put(tty);
Christoph Hellwigd5698c22007-02-10 01:46:46 -08001561}
1562
Alan Coxeeb89d92009-11-30 13:18:29 +00001563/**
Jiri Slaby955787ca2011-11-11 10:47:23 +01001564 * tty_release_checks - check a tty before real release
1565 * @tty: tty to check
1566 * @o_tty: link of @tty (if any)
1567 * @idx: index of the tty
1568 *
1569 * Performs some paranoid checking before true release of the @tty.
1570 * This is a no-op unless TTY_PARANOIA_CHECK is defined.
1571 */
1572static int tty_release_checks(struct tty_struct *tty, struct tty_struct *o_tty,
1573 int idx)
1574{
1575#ifdef TTY_PARANOIA_CHECK
1576 if (idx < 0 || idx >= tty->driver->num) {
Jiri Slaby9de44bd2011-11-09 21:33:24 +01001577 printk(KERN_DEBUG "%s: bad idx when trying to free (%s)\n",
1578 __func__, tty->name);
Jiri Slaby955787ca2011-11-11 10:47:23 +01001579 return -1;
1580 }
1581
1582 /* not much to check for devpts */
1583 if (tty->driver->flags & TTY_DRIVER_DEVPTS_MEM)
1584 return 0;
1585
1586 if (tty != tty->driver->ttys[idx]) {
Jiri Slaby9de44bd2011-11-09 21:33:24 +01001587 printk(KERN_DEBUG "%s: driver.table[%d] not tty for (%s)\n",
1588 __func__, idx, tty->name);
Jiri Slaby955787ca2011-11-11 10:47:23 +01001589 return -1;
1590 }
Jiri Slaby955787ca2011-11-11 10:47:23 +01001591 if (tty->driver->other) {
1592 if (o_tty != tty->driver->other->ttys[idx]) {
Jiri Slaby9de44bd2011-11-09 21:33:24 +01001593 printk(KERN_DEBUG "%s: other->table[%d] not o_tty for (%s)\n",
1594 __func__, idx, tty->name);
Jiri Slaby955787ca2011-11-11 10:47:23 +01001595 return -1;
1596 }
Jiri Slaby955787ca2011-11-11 10:47:23 +01001597 if (o_tty->link != tty) {
Jiri Slaby9de44bd2011-11-09 21:33:24 +01001598 printk(KERN_DEBUG "%s: bad pty pointers\n", __func__);
Jiri Slaby955787ca2011-11-11 10:47:23 +01001599 return -1;
1600 }
1601 }
1602#endif
1603 return 0;
1604}
1605
1606/**
Alan Coxeeb89d92009-11-30 13:18:29 +00001607 * tty_release - vfs callback for close
1608 * @inode: inode of tty
1609 * @filp: file pointer for handle to tty
1610 *
1611 * Called the last time each file handle is closed that references
1612 * this tty. There may however be several such references.
1613 *
1614 * Locking:
1615 * Takes bkl. See tty_release_dev
1616 *
Linus Torvalds1da177e2005-04-16 15:20:36 -07001617 * Even releasing the tty structures is a tricky business.. We have
1618 * to be very careful that the structures are all released at the
1619 * same time, as interrupts might otherwise get the wrong pointers.
1620 *
1621 * WSH 09/09/97: rewritten to avoid some nasty race conditions that could
1622 * lead to double frees or releasing memory still in use.
1623 */
Alan Coxeeb89d92009-11-30 13:18:29 +00001624
1625int tty_release(struct inode *inode, struct file *filp)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001626{
Nick Piggind996b622010-08-18 04:37:36 +10001627 struct tty_struct *tty = file_tty(filp);
1628 struct tty_struct *o_tty;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001629 int pty_master, tty_closing, o_tty_closing, do_sleep;
Paul Fulghum14a62832006-04-10 22:54:19 -07001630 int devpts;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001631 int idx;
1632 char buf[64];
Alan Cox37bdfb02008-02-08 04:18:47 -08001633
Jiri Slaby9de44bd2011-11-09 21:33:24 +01001634 if (tty_paranoia_check(tty, inode, __func__))
Alan Coxeeb89d92009-11-30 13:18:29 +00001635 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001636
Alan Cox89c8d912012-08-08 16:30:13 +01001637 tty_lock(tty);
Jiri Slaby9de44bd2011-11-09 21:33:24 +01001638 check_tty_count(tty, __func__);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001639
Arnd Bergmannec79d602010-06-01 22:53:01 +02001640 __tty_fasync(-1, filp, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001641
1642 idx = tty->index;
1643 pty_master = (tty->driver->type == TTY_DRIVER_TYPE_PTY &&
1644 tty->driver->subtype == PTY_TYPE_MASTER);
1645 devpts = (tty->driver->flags & TTY_DRIVER_DEVPTS_MEM) != 0;
Alan Cox89c8d912012-08-08 16:30:13 +01001646 /* Review: parallel close */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001647 o_tty = tty->link;
1648
Jiri Slaby955787ca2011-11-11 10:47:23 +01001649 if (tty_release_checks(tty, o_tty, idx)) {
Alan Cox89c8d912012-08-08 16:30:13 +01001650 tty_unlock(tty);
Alan Coxeeb89d92009-11-30 13:18:29 +00001651 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001652 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001653
1654#ifdef TTY_DEBUG_HANGUP
Jiri Slaby9de44bd2011-11-09 21:33:24 +01001655 printk(KERN_DEBUG "%s: %s (tty count=%d)...\n", __func__,
1656 tty_name(tty, buf), tty->count);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001657#endif
1658
Alan Coxf34d7a52008-04-30 00:54:13 -07001659 if (tty->ops->close)
1660 tty->ops->close(tty, filp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001661
Alan Cox89c8d912012-08-08 16:30:13 +01001662 tty_unlock(tty);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001663 /*
1664 * Sanity check: if tty->count is going to zero, there shouldn't be
1665 * any waiters on tty->read_wait or tty->write_wait. We test the
1666 * wait queues and kick everyone out _before_ actually starting to
1667 * close. This ensures that we won't block while releasing the tty
1668 * structure.
1669 *
1670 * The test for the o_tty closing is necessary, since the master and
1671 * slave sides may close in any order. If the slave side closes out
1672 * first, its count will be one, since the master side holds an open.
1673 * Thus this test wouldn't be triggered at the time the slave closes,
1674 * so we do it now.
1675 *
1676 * Note that it's possible for the tty to be opened again while we're
1677 * flushing out waiters. By recalculating the closing flags before
1678 * each iteration we avoid any problems.
1679 */
1680 while (1) {
1681 /* Guard against races with tty->count changes elsewhere and
1682 opens on /dev/tty */
Alan Cox37bdfb02008-02-08 04:18:47 -08001683
Ingo Molnar70522e12006-03-23 03:00:31 -08001684 mutex_lock(&tty_mutex);
Alan Cox89c8d912012-08-08 16:30:13 +01001685 tty_lock_pair(tty, o_tty);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001686 tty_closing = tty->count <= 1;
1687 o_tty_closing = o_tty &&
1688 (o_tty->count <= (pty_master ? 1 : 0));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001689 do_sleep = 0;
1690
1691 if (tty_closing) {
1692 if (waitqueue_active(&tty->read_wait)) {
Davide Libenzi4b194492009-03-31 15:24:24 -07001693 wake_up_poll(&tty->read_wait, POLLIN);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001694 do_sleep++;
1695 }
1696 if (waitqueue_active(&tty->write_wait)) {
Davide Libenzi4b194492009-03-31 15:24:24 -07001697 wake_up_poll(&tty->write_wait, POLLOUT);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001698 do_sleep++;
1699 }
1700 }
1701 if (o_tty_closing) {
1702 if (waitqueue_active(&o_tty->read_wait)) {
Davide Libenzi4b194492009-03-31 15:24:24 -07001703 wake_up_poll(&o_tty->read_wait, POLLIN);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001704 do_sleep++;
1705 }
1706 if (waitqueue_active(&o_tty->write_wait)) {
Davide Libenzi4b194492009-03-31 15:24:24 -07001707 wake_up_poll(&o_tty->write_wait, POLLOUT);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001708 do_sleep++;
1709 }
1710 }
1711 if (!do_sleep)
1712 break;
1713
Jiri Slaby9de44bd2011-11-09 21:33:24 +01001714 printk(KERN_WARNING "%s: %s: read/write wait queue active!\n",
1715 __func__, tty_name(tty, buf));
Alan Cox89c8d912012-08-08 16:30:13 +01001716 tty_unlock_pair(tty, o_tty);
Ingo Molnar70522e12006-03-23 03:00:31 -08001717 mutex_unlock(&tty_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001718 schedule();
Alan Cox37bdfb02008-02-08 04:18:47 -08001719 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001720
1721 /*
Alan Cox37bdfb02008-02-08 04:18:47 -08001722 * The closing flags are now consistent with the open counts on
1723 * both sides, and we've completed the last operation that could
Linus Torvalds1da177e2005-04-16 15:20:36 -07001724 * block, so it's safe to proceed with closing.
Alan Coxd1552552012-07-27 18:02:54 +01001725 *
1726 * We must *not* drop the tty_mutex until we ensure that a further
1727 * entry into tty_open can not pick up this tty.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001728 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001729 if (pty_master) {
1730 if (--o_tty->count < 0) {
Jiri Slaby9de44bd2011-11-09 21:33:24 +01001731 printk(KERN_WARNING "%s: bad pty slave count (%d) for %s\n",
1732 __func__, o_tty->count, tty_name(o_tty, buf));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001733 o_tty->count = 0;
1734 }
1735 }
1736 if (--tty->count < 0) {
Jiri Slaby9de44bd2011-11-09 21:33:24 +01001737 printk(KERN_WARNING "%s: bad tty->count (%d) for %s\n",
1738 __func__, tty->count, tty_name(tty, buf));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001739 tty->count = 0;
1740 }
Alan Cox37bdfb02008-02-08 04:18:47 -08001741
Linus Torvalds1da177e2005-04-16 15:20:36 -07001742 /*
1743 * We've decremented tty->count, so we need to remove this file
1744 * descriptor off the tty->tty_files list; this serves two
1745 * purposes:
1746 * - check_tty_count sees the correct number of file descriptors
1747 * associated with this tty.
1748 * - do_tty_hangup no longer sees this file descriptor as
1749 * something that needs to be handled for hangups.
1750 */
Nick Piggind996b622010-08-18 04:37:36 +10001751 tty_del_file(filp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001752
1753 /*
1754 * Perform some housekeeping before deciding whether to return.
1755 *
1756 * Set the TTY_CLOSING flag if this was the last open. In the
1757 * case of a pty we may have to wait around for the other side
1758 * to close, and TTY_CLOSING makes sure we can't be reopened.
1759 */
Alan Cox37bdfb02008-02-08 04:18:47 -08001760 if (tty_closing)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001761 set_bit(TTY_CLOSING, &tty->flags);
Alan Cox37bdfb02008-02-08 04:18:47 -08001762 if (o_tty_closing)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001763 set_bit(TTY_CLOSING, &o_tty->flags);
1764
1765 /*
1766 * If _either_ side is closing, make sure there aren't any
1767 * processes that still think tty or o_tty is their controlling
1768 * tty.
1769 */
1770 if (tty_closing || o_tty_closing) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001771 read_lock(&tasklist_lock);
Peter Zijlstra24ec8392006-12-08 02:36:04 -08001772 session_clear_tty(tty->session);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001773 if (o_tty)
Peter Zijlstra24ec8392006-12-08 02:36:04 -08001774 session_clear_tty(o_tty->session);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001775 read_unlock(&tasklist_lock);
1776 }
1777
Ingo Molnar70522e12006-03-23 03:00:31 -08001778 mutex_unlock(&tty_mutex);
Alan Cox89c8d912012-08-08 16:30:13 +01001779 tty_unlock_pair(tty, o_tty);
Alan Coxd1552552012-07-27 18:02:54 +01001780 /* At this point the TTY_CLOSING flag should ensure a dead tty
1781 cannot be re-opened by a racing opener */
Paul Fulghumda965822006-02-14 13:53:00 -08001782
Linus Torvalds1da177e2005-04-16 15:20:36 -07001783 /* check whether both sides are closing ... */
Alan Coxd1552552012-07-27 18:02:54 +01001784 if (!tty_closing || (o_tty && !o_tty_closing))
Alan Coxeeb89d92009-11-30 13:18:29 +00001785 return 0;
Alan Cox37bdfb02008-02-08 04:18:47 -08001786
Linus Torvalds1da177e2005-04-16 15:20:36 -07001787#ifdef TTY_DEBUG_HANGUP
Jiri Slaby9de44bd2011-11-09 21:33:24 +01001788 printk(KERN_DEBUG "%s: freeing tty structure...\n", __func__);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001789#endif
1790 /*
Alan Cox01e1abb2008-07-22 11:16:55 +01001791 * Ask the line discipline code to release its structures
Linus Torvalds1da177e2005-04-16 15:20:36 -07001792 */
Alan Cox01e1abb2008-07-22 11:16:55 +01001793 tty_ldisc_release(tty, o_tty);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001794 /*
Christoph Hellwigd5698c22007-02-10 01:46:46 -08001795 * The release_tty function takes care of the details of clearing
Alan Cox89c8d912012-08-08 16:30:13 +01001796 * the slots and preserving the termios structure. The tty_unlock_pair
1797 * should be safe as we keep a kref while the tty is locked (so the
1798 * unlock never unlocks a freed tty).
Linus Torvalds1da177e2005-04-16 15:20:36 -07001799 */
Alan Coxd1552552012-07-27 18:02:54 +01001800 mutex_lock(&tty_mutex);
Christoph Hellwigd5698c22007-02-10 01:46:46 -08001801 release_tty(tty, idx);
Alan Coxd1552552012-07-27 18:02:54 +01001802 mutex_unlock(&tty_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001803
Linus Torvalds1da177e2005-04-16 15:20:36 -07001804 /* Make this pty number available for reallocation */
Sukadev Bhattiprolu718a9162008-04-30 00:54:21 -07001805 if (devpts)
Sukadev Bhattiprolu15f1a632008-10-13 10:42:59 +01001806 devpts_kill_index(inode, idx);
Alan Coxeeb89d92009-11-30 13:18:29 +00001807 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001808}
1809
Alan Coxaf9b8972006-08-27 01:24:01 -07001810/**
Jiri Slabyb82154a2011-11-09 21:33:19 +01001811 * tty_open_current_tty - get tty of current task for open
1812 * @device: device number
1813 * @filp: file pointer to tty
1814 * @return: tty of the current task iff @device is /dev/tty
1815 *
1816 * We cannot return driver and index like for the other nodes because
1817 * devpts will not work then. It expects inodes to be from devpts FS.
Alan Cox3af502b2012-05-03 22:21:53 +01001818 *
1819 * We need to move to returning a refcounted object from all the lookup
1820 * paths including this one.
Jiri Slabyb82154a2011-11-09 21:33:19 +01001821 */
1822static struct tty_struct *tty_open_current_tty(dev_t device, struct file *filp)
1823{
1824 struct tty_struct *tty;
1825
1826 if (device != MKDEV(TTYAUX_MAJOR, 0))
1827 return NULL;
1828
1829 tty = get_current_tty();
1830 if (!tty)
1831 return ERR_PTR(-ENXIO);
1832
1833 filp->f_flags |= O_NONBLOCK; /* Don't let /dev/tty block */
1834 /* noctty = 1; */
1835 tty_kref_put(tty);
1836 /* FIXME: we put a reference and return a TTY! */
Alan Cox3af502b2012-05-03 22:21:53 +01001837 /* This is only safe because the caller holds tty_mutex */
Jiri Slabyb82154a2011-11-09 21:33:19 +01001838 return tty;
1839}
1840
1841/**
Jiri Slaby5b5e7042011-11-09 21:33:20 +01001842 * tty_lookup_driver - lookup a tty driver for a given device file
1843 * @device: device number
1844 * @filp: file pointer to tty
1845 * @noctty: set if the device should not become a controlling tty
1846 * @index: index for the device in the @return driver
1847 * @return: driver for this inode (with increased refcount)
1848 *
1849 * If @return is not erroneous, the caller is responsible to decrement the
1850 * refcount by tty_driver_kref_put.
1851 *
1852 * Locking: tty_mutex protects get_tty_driver
1853 */
1854static struct tty_driver *tty_lookup_driver(dev_t device, struct file *filp,
1855 int *noctty, int *index)
1856{
1857 struct tty_driver *driver;
1858
Jiri Slaby2cd00502011-11-09 21:33:22 +01001859 switch (device) {
Jiri Slaby5b5e7042011-11-09 21:33:20 +01001860#ifdef CONFIG_VT
Jiri Slaby2cd00502011-11-09 21:33:22 +01001861 case MKDEV(TTY_MAJOR, 0): {
Jiri Slaby5b5e7042011-11-09 21:33:20 +01001862 extern struct tty_driver *console_driver;
1863 driver = tty_driver_kref_get(console_driver);
1864 *index = fg_console;
1865 *noctty = 1;
Jiri Slaby2cd00502011-11-09 21:33:22 +01001866 break;
Jiri Slaby5b5e7042011-11-09 21:33:20 +01001867 }
1868#endif
Jiri Slaby2cd00502011-11-09 21:33:22 +01001869 case MKDEV(TTYAUX_MAJOR, 1): {
Jiri Slaby5b5e7042011-11-09 21:33:20 +01001870 struct tty_driver *console_driver = console_device(index);
1871 if (console_driver) {
1872 driver = tty_driver_kref_get(console_driver);
1873 if (driver) {
1874 /* Don't let /dev/console block */
1875 filp->f_flags |= O_NONBLOCK;
1876 *noctty = 1;
Jiri Slaby2cd00502011-11-09 21:33:22 +01001877 break;
Jiri Slaby5b5e7042011-11-09 21:33:20 +01001878 }
1879 }
1880 return ERR_PTR(-ENODEV);
1881 }
Jiri Slaby2cd00502011-11-09 21:33:22 +01001882 default:
1883 driver = get_tty_driver(device, index);
1884 if (!driver)
1885 return ERR_PTR(-ENODEV);
1886 break;
1887 }
Jiri Slaby5b5e7042011-11-09 21:33:20 +01001888 return driver;
1889}
1890
1891/**
Alan Coxeeb89d92009-11-30 13:18:29 +00001892 * tty_open - open a tty device
Alan Coxaf9b8972006-08-27 01:24:01 -07001893 * @inode: inode of device file
1894 * @filp: file pointer to tty
Linus Torvalds1da177e2005-04-16 15:20:36 -07001895 *
Alan Coxaf9b8972006-08-27 01:24:01 -07001896 * tty_open and tty_release keep up the tty count that contains the
1897 * number of opens done on a tty. We cannot use the inode-count, as
1898 * different inodes might point to the same tty.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001899 *
Alan Coxaf9b8972006-08-27 01:24:01 -07001900 * Open-counting is needed for pty masters, as well as for keeping
1901 * track of serial lines: DTR is dropped when the last close happens.
1902 * (This is not done solely through tty->count, now. - Ted 1/27/92)
1903 *
1904 * The termios state of a pty is reset on first open so that
1905 * settings don't persist across reuse.
1906 *
Jiri Slaby5b5e7042011-11-09 21:33:20 +01001907 * Locking: tty_mutex protects tty, tty_lookup_driver and tty_init_dev.
Peter Zijlstra24ec8392006-12-08 02:36:04 -08001908 * tty->count should protect the rest.
1909 * ->siglock protects ->signal/->sighand
Alan Cox89c8d912012-08-08 16:30:13 +01001910 *
1911 * Note: the tty_unlock/lock cases without a ref are only safe due to
1912 * tty_mutex
Linus Torvalds1da177e2005-04-16 15:20:36 -07001913 */
Alan Coxaf9b8972006-08-27 01:24:01 -07001914
Alan Coxeeb89d92009-11-30 13:18:29 +00001915static int tty_open(struct inode *inode, struct file *filp)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001916{
Jiri Slabyb82154a2011-11-09 21:33:19 +01001917 struct tty_struct *tty;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001918 int noctty, retval;
Jiri Slabyb82154a2011-11-09 21:33:19 +01001919 struct tty_driver *driver = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001920 int index;
1921 dev_t device = inode->i_rdev;
Andrew Morton846c1512009-04-02 16:56:36 -07001922 unsigned saved_flags = filp->f_flags;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001923
1924 nonseekable_open(inode, filp);
Alan Cox37bdfb02008-02-08 04:18:47 -08001925
Linus Torvalds1da177e2005-04-16 15:20:36 -07001926retry_open:
Jiri Slabyfa90e1c2011-10-12 11:32:43 +02001927 retval = tty_alloc_file(filp);
1928 if (retval)
1929 return -ENOMEM;
1930
Linus Torvalds1da177e2005-04-16 15:20:36 -07001931 noctty = filp->f_flags & O_NOCTTY;
1932 index = -1;
1933 retval = 0;
Alan Cox37bdfb02008-02-08 04:18:47 -08001934
Ingo Molnar70522e12006-03-23 03:00:31 -08001935 mutex_lock(&tty_mutex);
Alan Cox89c8d912012-08-08 16:30:13 +01001936 /* This is protected by the tty_mutex */
Jiri Slabyb82154a2011-11-09 21:33:19 +01001937 tty = tty_open_current_tty(device, filp);
1938 if (IS_ERR(tty)) {
Jiri Slabyba5db442011-11-09 21:33:21 +01001939 retval = PTR_ERR(tty);
1940 goto err_unlock;
Jiri Slaby5b5e7042011-11-09 21:33:20 +01001941 } else if (!tty) {
1942 driver = tty_lookup_driver(device, filp, &noctty, &index);
1943 if (IS_ERR(driver)) {
Jiri Slabyba5db442011-11-09 21:33:21 +01001944 retval = PTR_ERR(driver);
1945 goto err_unlock;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001946 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001947
Sukadev Bhattiprolu4a2b5fd2008-10-13 10:42:49 +01001948 /* check whether we're reopening an existing tty */
Sukadev Bhattiprolu15f1a632008-10-13 10:42:59 +01001949 tty = tty_driver_lookup_tty(driver, inode, index);
Eric Paris808ffa32009-01-27 11:50:37 +00001950 if (IS_ERR(tty)) {
Jiri Slabyba5db442011-11-09 21:33:21 +01001951 retval = PTR_ERR(tty);
1952 goto err_unlock;
Eric Paris808ffa32009-01-27 11:50:37 +00001953 }
Sukadev Bhattiprolu4a2b5fd2008-10-13 10:42:49 +01001954 }
1955
1956 if (tty) {
Alan Cox89c8d912012-08-08 16:30:13 +01001957 tty_lock(tty);
Sukadev Bhattiprolu4a2b5fd2008-10-13 10:42:49 +01001958 retval = tty_reopen(tty);
Alan Cox89c8d912012-08-08 16:30:13 +01001959 if (retval < 0) {
1960 tty_unlock(tty);
Sukadev Bhattiprolu4a2b5fd2008-10-13 10:42:49 +01001961 tty = ERR_PTR(retval);
Alan Cox89c8d912012-08-08 16:30:13 +01001962 }
1963 } else /* Returns with the tty_lock held for now */
Konstantin Khlebnikov593a27c2012-01-05 13:04:21 +04001964 tty = tty_init_dev(driver, index);
Sukadev Bhattiprolu4a2b5fd2008-10-13 10:42:49 +01001965
Ingo Molnar70522e12006-03-23 03:00:31 -08001966 mutex_unlock(&tty_mutex);
Jiri Slabyb82154a2011-11-09 21:33:19 +01001967 if (driver)
1968 tty_driver_kref_put(driver);
Alan Coxeeb89d92009-11-30 13:18:29 +00001969 if (IS_ERR(tty)) {
Jiri Slabyba5db442011-11-09 21:33:21 +01001970 retval = PTR_ERR(tty);
1971 goto err_file;
Alan Coxeeb89d92009-11-30 13:18:29 +00001972 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001973
Jiri Slabyfa90e1c2011-10-12 11:32:43 +02001974 tty_add_file(tty, filp);
Nick Piggind996b622010-08-18 04:37:36 +10001975
Jiri Slaby9de44bd2011-11-09 21:33:24 +01001976 check_tty_count(tty, __func__);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001977 if (tty->driver->type == TTY_DRIVER_TYPE_PTY &&
1978 tty->driver->subtype == PTY_TYPE_MASTER)
1979 noctty = 1;
1980#ifdef TTY_DEBUG_HANGUP
Jiri Slaby9de44bd2011-11-09 21:33:24 +01001981 printk(KERN_DEBUG "%s: opening %s...\n", __func__, tty->name);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001982#endif
Herton Ronaldo Krzesinski909bc772011-03-31 15:35:31 -03001983 if (tty->ops->open)
1984 retval = tty->ops->open(tty, filp);
1985 else
1986 retval = -ENODEV;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001987 filp->f_flags = saved_flags;
1988
Alan Cox37bdfb02008-02-08 04:18:47 -08001989 if (!retval && test_bit(TTY_EXCLUSIVE, &tty->flags) &&
1990 !capable(CAP_SYS_ADMIN))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001991 retval = -EBUSY;
1992
1993 if (retval) {
1994#ifdef TTY_DEBUG_HANGUP
Jiri Slaby9de44bd2011-11-09 21:33:24 +01001995 printk(KERN_DEBUG "%s: error %d in opening %s...\n", __func__,
1996 retval, tty->name);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001997#endif
Alan Cox89c8d912012-08-08 16:30:13 +01001998 tty_unlock(tty); /* need to call tty_release without BTM */
Alan Coxeeb89d92009-11-30 13:18:29 +00001999 tty_release(inode, filp);
Arnd Bergmann64ba3dc2010-06-01 22:53:02 +02002000 if (retval != -ERESTARTSYS)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002001 return retval;
Arnd Bergmann64ba3dc2010-06-01 22:53:02 +02002002
2003 if (signal_pending(current))
Linus Torvalds1da177e2005-04-16 15:20:36 -07002004 return retval;
Arnd Bergmann64ba3dc2010-06-01 22:53:02 +02002005
Linus Torvalds1da177e2005-04-16 15:20:36 -07002006 schedule();
2007 /*
2008 * Need to reset f_op in case a hangup happened.
2009 */
2010 if (filp->f_op == &hung_up_tty_fops)
2011 filp->f_op = &tty_fops;
2012 goto retry_open;
2013 }
Alan Cox89c8d912012-08-08 16:30:13 +01002014 tty_unlock(tty);
Alan Coxeeb89d92009-11-30 13:18:29 +00002015
Peter Zijlstra24ec8392006-12-08 02:36:04 -08002016
2017 mutex_lock(&tty_mutex);
Alan Cox89c8d912012-08-08 16:30:13 +01002018 tty_lock(tty);
Peter Zijlstra24ec8392006-12-08 02:36:04 -08002019 spin_lock_irq(&current->sighand->siglock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002020 if (!noctty &&
2021 current->signal->leader &&
2022 !current->signal->tty &&
Eric W. Biedermanab521dc2007-02-12 00:53:00 -08002023 tty->session == NULL)
Eric W. Biederman2a65f1d2007-05-08 00:26:53 -07002024 __proc_set_tty(current, tty);
Peter Zijlstra24ec8392006-12-08 02:36:04 -08002025 spin_unlock_irq(&current->sighand->siglock);
Alan Cox89c8d912012-08-08 16:30:13 +01002026 tty_unlock(tty);
Peter Zijlstra24ec8392006-12-08 02:36:04 -08002027 mutex_unlock(&tty_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002028 return 0;
Jiri Slabyba5db442011-11-09 21:33:21 +01002029err_unlock:
Jiri Slabyba5db442011-11-09 21:33:21 +01002030 mutex_unlock(&tty_mutex);
2031 /* after locks to avoid deadlock */
2032 if (!IS_ERR_OR_NULL(driver))
2033 tty_driver_kref_put(driver);
2034err_file:
2035 tty_free_file(filp);
2036 return retval;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002037}
2038
Jonathan Corbet39d95b92008-05-16 09:10:50 -06002039
Linus Torvalds1da177e2005-04-16 15:20:36 -07002040
Alan Coxaf9b8972006-08-27 01:24:01 -07002041/**
2042 * tty_poll - check tty status
2043 * @filp: file being polled
2044 * @wait: poll wait structures to update
2045 *
2046 * Call the line discipline polling method to obtain the poll
2047 * status of the device.
2048 *
2049 * Locking: locks called line discipline but ldisc poll method
2050 * may be re-entered freely by other callers.
2051 */
2052
Alan Cox37bdfb02008-02-08 04:18:47 -08002053static unsigned int tty_poll(struct file *filp, poll_table *wait)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002054{
Nick Piggind996b622010-08-18 04:37:36 +10002055 struct tty_struct *tty = file_tty(filp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002056 struct tty_ldisc *ld;
2057 int ret = 0;
2058
Josef Sipeka7113a92006-12-08 02:36:55 -08002059 if (tty_paranoia_check(tty, filp->f_path.dentry->d_inode, "tty_poll"))
Linus Torvalds1da177e2005-04-16 15:20:36 -07002060 return 0;
Alan Cox37bdfb02008-02-08 04:18:47 -08002061
Linus Torvalds1da177e2005-04-16 15:20:36 -07002062 ld = tty_ldisc_ref_wait(tty);
Alan Coxa352def2008-07-16 21:53:12 +01002063 if (ld->ops->poll)
2064 ret = (ld->ops->poll)(tty, filp, wait);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002065 tty_ldisc_deref(ld);
2066 return ret;
2067}
2068
Arnd Bergmannec79d602010-06-01 22:53:01 +02002069static int __tty_fasync(int fd, struct file *filp, int on)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002070{
Nick Piggind996b622010-08-18 04:37:36 +10002071 struct tty_struct *tty = file_tty(filp);
Alan Cox47f86832008-04-30 00:53:30 -07002072 unsigned long flags;
Jonathan Corbet5d1e3232008-06-19 16:04:53 -06002073 int retval = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002074
Josef Sipeka7113a92006-12-08 02:36:55 -08002075 if (tty_paranoia_check(tty, filp->f_path.dentry->d_inode, "tty_fasync"))
Jonathan Corbet5d1e3232008-06-19 16:04:53 -06002076 goto out;
Alan Cox37bdfb02008-02-08 04:18:47 -08002077
Linus Torvalds1da177e2005-04-16 15:20:36 -07002078 retval = fasync_helper(fd, filp, on, &tty->fasync);
2079 if (retval <= 0)
Jonathan Corbet5d1e3232008-06-19 16:04:53 -06002080 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002081
2082 if (on) {
Eric W. Biedermanab521dc2007-02-12 00:53:00 -08002083 enum pid_type type;
2084 struct pid *pid;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002085 if (!waitqueue_active(&tty->read_wait))
2086 tty->minimum_to_wake = 1;
Alan Cox47f86832008-04-30 00:53:30 -07002087 spin_lock_irqsave(&tty->ctrl_lock, flags);
Eric W. Biedermanab521dc2007-02-12 00:53:00 -08002088 if (tty->pgrp) {
2089 pid = tty->pgrp;
2090 type = PIDTYPE_PGID;
2091 } else {
2092 pid = task_pid(current);
2093 type = PIDTYPE_PID;
2094 }
Linus Torvalds80e1e822010-02-07 10:11:23 -08002095 get_pid(pid);
Greg Kroah-Hartman70362512009-12-17 07:07:19 -08002096 spin_unlock_irqrestore(&tty->ctrl_lock, flags);
Linus Torvalds80e1e822010-02-07 10:11:23 -08002097 retval = __f_setown(filp, pid, type, 0);
2098 put_pid(pid);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002099 if (retval)
Jonathan Corbet5d1e3232008-06-19 16:04:53 -06002100 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002101 } else {
2102 if (!tty->fasync && !waitqueue_active(&tty->read_wait))
2103 tty->minimum_to_wake = N_TTY_BUF_SIZE;
2104 }
Jonathan Corbet5d1e3232008-06-19 16:04:53 -06002105 retval = 0;
2106out:
Arnd Bergmannec79d602010-06-01 22:53:01 +02002107 return retval;
2108}
2109
2110static int tty_fasync(int fd, struct file *filp, int on)
2111{
Alan Cox89c8d912012-08-08 16:30:13 +01002112 struct tty_struct *tty = file_tty(filp);
Arnd Bergmannec79d602010-06-01 22:53:01 +02002113 int retval;
Alan Cox89c8d912012-08-08 16:30:13 +01002114
2115 tty_lock(tty);
Arnd Bergmannec79d602010-06-01 22:53:01 +02002116 retval = __tty_fasync(fd, filp, on);
Alan Cox89c8d912012-08-08 16:30:13 +01002117 tty_unlock(tty);
2118
Jonathan Corbet5d1e3232008-06-19 16:04:53 -06002119 return retval;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002120}
2121
Alan Coxaf9b8972006-08-27 01:24:01 -07002122/**
2123 * tiocsti - fake input character
2124 * @tty: tty to fake input into
2125 * @p: pointer to character
2126 *
Robert P. J. Day3a4fa0a2007-10-19 23:10:43 +02002127 * Fake input to a tty device. Does the necessary locking and
Alan Coxaf9b8972006-08-27 01:24:01 -07002128 * input management.
2129 *
2130 * FIXME: does not honour flow control ??
2131 *
2132 * Locking:
2133 * Called functions take tty_ldisc_lock
2134 * current->signal->tty check is safe without locks
Alan Cox28298232006-09-29 02:00:58 -07002135 *
2136 * FIXME: may race normal receive processing
Alan Coxaf9b8972006-08-27 01:24:01 -07002137 */
2138
Linus Torvalds1da177e2005-04-16 15:20:36 -07002139static int tiocsti(struct tty_struct *tty, char __user *p)
2140{
2141 char ch, mbz = 0;
2142 struct tty_ldisc *ld;
Alan Cox37bdfb02008-02-08 04:18:47 -08002143
Linus Torvalds1da177e2005-04-16 15:20:36 -07002144 if ((current->signal->tty != tty) && !capable(CAP_SYS_ADMIN))
2145 return -EPERM;
2146 if (get_user(ch, p))
2147 return -EFAULT;
Al Viro1e641742008-12-09 09:23:33 +00002148 tty_audit_tiocsti(tty, ch);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002149 ld = tty_ldisc_ref_wait(tty);
Alan Coxa352def2008-07-16 21:53:12 +01002150 ld->ops->receive_buf(tty, &ch, &mbz, 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002151 tty_ldisc_deref(ld);
2152 return 0;
2153}
2154
Alan Coxaf9b8972006-08-27 01:24:01 -07002155/**
2156 * tiocgwinsz - implement window query ioctl
2157 * @tty; tty
2158 * @arg: user buffer for result
2159 *
Alan Cox808a0d32006-09-29 02:00:40 -07002160 * Copies the kernel idea of the window size into the user buffer.
Alan Coxaf9b8972006-08-27 01:24:01 -07002161 *
Peter Zijlstra24ec8392006-12-08 02:36:04 -08002162 * Locking: tty->termios_mutex is taken to ensure the winsize data
Alan Cox808a0d32006-09-29 02:00:40 -07002163 * is consistent.
Alan Coxaf9b8972006-08-27 01:24:01 -07002164 */
2165
Alan Cox37bdfb02008-02-08 04:18:47 -08002166static int tiocgwinsz(struct tty_struct *tty, struct winsize __user *arg)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002167{
Alan Cox808a0d32006-09-29 02:00:40 -07002168 int err;
2169
Arjan van de Ven5785c952006-09-29 02:00:43 -07002170 mutex_lock(&tty->termios_mutex);
Alan Cox808a0d32006-09-29 02:00:40 -07002171 err = copy_to_user(arg, &tty->winsize, sizeof(*arg));
Arjan van de Ven5785c952006-09-29 02:00:43 -07002172 mutex_unlock(&tty->termios_mutex);
Alan Cox808a0d32006-09-29 02:00:40 -07002173
2174 return err ? -EFAULT: 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002175}
2176
Alan Coxaf9b8972006-08-27 01:24:01 -07002177/**
Alan Cox8c9a9dd2008-08-15 10:39:38 +01002178 * tty_do_resize - resize event
2179 * @tty: tty being resized
Alan Cox8c9a9dd2008-08-15 10:39:38 +01002180 * @rows: rows (character)
2181 * @cols: cols (character)
Alan Coxaf9b8972006-08-27 01:24:01 -07002182 *
Daniel Mack3ad2f3f2010-02-03 08:01:28 +08002183 * Update the termios variables and send the necessary signals to
Alan Cox8c9a9dd2008-08-15 10:39:38 +01002184 * peform a terminal resize correctly
Alan Coxaf9b8972006-08-27 01:24:01 -07002185 */
2186
Alan Coxfc6f6232009-01-02 13:43:17 +00002187int tty_do_resize(struct tty_struct *tty, struct winsize *ws)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002188{
Alan Coxfc6f6232009-01-02 13:43:17 +00002189 struct pid *pgrp;
Alan Cox47f86832008-04-30 00:53:30 -07002190 unsigned long flags;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002191
Alan Coxfc6f6232009-01-02 13:43:17 +00002192 /* Lock the tty */
2193 mutex_lock(&tty->termios_mutex);
2194 if (!memcmp(ws, &tty->winsize, sizeof(*ws)))
Alan Coxca9bda02006-09-29 02:00:03 -07002195 goto done;
Alan Cox47f86832008-04-30 00:53:30 -07002196 /* Get the PID values and reference them so we can
2197 avoid holding the tty ctrl lock while sending signals */
2198 spin_lock_irqsave(&tty->ctrl_lock, flags);
2199 pgrp = get_pid(tty->pgrp);
Alan Cox47f86832008-04-30 00:53:30 -07002200 spin_unlock_irqrestore(&tty->ctrl_lock, flags);
2201
2202 if (pgrp)
2203 kill_pgrp(pgrp, SIGWINCH, 1);
Alan Cox47f86832008-04-30 00:53:30 -07002204 put_pid(pgrp);
Alan Cox47f86832008-04-30 00:53:30 -07002205
Alan Cox8c9a9dd2008-08-15 10:39:38 +01002206 tty->winsize = *ws;
Alan Coxca9bda02006-09-29 02:00:03 -07002207done:
Alan Coxfc6f6232009-01-02 13:43:17 +00002208 mutex_unlock(&tty->termios_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002209 return 0;
2210}
2211
Alan Coxaf9b8972006-08-27 01:24:01 -07002212/**
Alan Cox8c9a9dd2008-08-15 10:39:38 +01002213 * tiocswinsz - implement window size set ioctl
Alan Coxfc6f6232009-01-02 13:43:17 +00002214 * @tty; tty side of tty
Alan Cox8c9a9dd2008-08-15 10:39:38 +01002215 * @arg: user buffer for result
2216 *
2217 * Copies the user idea of the window size to the kernel. Traditionally
2218 * this is just advisory information but for the Linux console it
2219 * actually has driver level meaning and triggers a VC resize.
2220 *
2221 * Locking:
Lucas De Marchi25985ed2011-03-30 22:57:33 -03002222 * Driver dependent. The default do_resize method takes the
Alan Cox8c9a9dd2008-08-15 10:39:38 +01002223 * tty termios mutex and ctrl_lock. The console takes its own lock
2224 * then calls into the default method.
2225 */
2226
Alan Coxfc6f6232009-01-02 13:43:17 +00002227static int tiocswinsz(struct tty_struct *tty, struct winsize __user *arg)
Alan Cox8c9a9dd2008-08-15 10:39:38 +01002228{
2229 struct winsize tmp_ws;
2230 if (copy_from_user(&tmp_ws, arg, sizeof(*arg)))
2231 return -EFAULT;
2232
2233 if (tty->ops->resize)
Alan Coxfc6f6232009-01-02 13:43:17 +00002234 return tty->ops->resize(tty, &tmp_ws);
Alan Cox8c9a9dd2008-08-15 10:39:38 +01002235 else
Alan Coxfc6f6232009-01-02 13:43:17 +00002236 return tty_do_resize(tty, &tmp_ws);
Alan Cox8c9a9dd2008-08-15 10:39:38 +01002237}
2238
2239/**
Alan Coxaf9b8972006-08-27 01:24:01 -07002240 * tioccons - allow admin to move logical console
2241 * @file: the file to become console
2242 *
Lucas De Marchi25985ed2011-03-30 22:57:33 -03002243 * Allow the administrator to move the redirected console device
Alan Coxaf9b8972006-08-27 01:24:01 -07002244 *
2245 * Locking: uses redirect_lock to guard the redirect information
2246 */
2247
Linus Torvalds1da177e2005-04-16 15:20:36 -07002248static int tioccons(struct file *file)
2249{
2250 if (!capable(CAP_SYS_ADMIN))
2251 return -EPERM;
2252 if (file->f_op->write == redirected_tty_write) {
2253 struct file *f;
2254 spin_lock(&redirect_lock);
2255 f = redirect;
2256 redirect = NULL;
2257 spin_unlock(&redirect_lock);
2258 if (f)
2259 fput(f);
2260 return 0;
2261 }
2262 spin_lock(&redirect_lock);
2263 if (redirect) {
2264 spin_unlock(&redirect_lock);
2265 return -EBUSY;
2266 }
2267 get_file(file);
2268 redirect = file;
2269 spin_unlock(&redirect_lock);
2270 return 0;
2271}
2272
Alan Coxaf9b8972006-08-27 01:24:01 -07002273/**
2274 * fionbio - non blocking ioctl
2275 * @file: file to set blocking value
2276 * @p: user parameter
2277 *
2278 * Historical tty interfaces had a blocking control ioctl before
2279 * the generic functionality existed. This piece of history is preserved
2280 * in the expected tty API of posix OS's.
2281 *
Alan Cox6146b9a2009-09-19 13:13:19 -07002282 * Locking: none, the open file handle ensures it won't go away.
Alan Coxaf9b8972006-08-27 01:24:01 -07002283 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002284
2285static int fionbio(struct file *file, int __user *p)
2286{
2287 int nonblock;
2288
2289 if (get_user(nonblock, p))
2290 return -EFAULT;
2291
Jonathan Corbetdb1dd4d2009-02-06 15:25:24 -07002292 spin_lock(&file->f_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002293 if (nonblock)
2294 file->f_flags |= O_NONBLOCK;
2295 else
2296 file->f_flags &= ~O_NONBLOCK;
Jonathan Corbetdb1dd4d2009-02-06 15:25:24 -07002297 spin_unlock(&file->f_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002298 return 0;
2299}
2300
Alan Coxaf9b8972006-08-27 01:24:01 -07002301/**
2302 * tiocsctty - set controlling tty
2303 * @tty: tty structure
2304 * @arg: user argument
2305 *
2306 * This ioctl is used to manage job control. It permits a session
2307 * leader to set this tty as the controlling tty for the session.
2308 *
2309 * Locking:
Alan Cox28298232006-09-29 02:00:58 -07002310 * Takes tty_mutex() to protect tty instance
Peter Zijlstra24ec8392006-12-08 02:36:04 -08002311 * Takes tasklist_lock internally to walk sessions
2312 * Takes ->siglock() when updating signal->tty
Alan Coxaf9b8972006-08-27 01:24:01 -07002313 */
2314
Linus Torvalds1da177e2005-04-16 15:20:36 -07002315static int tiocsctty(struct tty_struct *tty, int arg)
2316{
Peter Zijlstra24ec8392006-12-08 02:36:04 -08002317 int ret = 0;
Eric W. Biedermanab521dc2007-02-12 00:53:00 -08002318 if (current->signal->leader && (task_session(current) == tty->session))
Peter Zijlstra24ec8392006-12-08 02:36:04 -08002319 return ret;
2320
2321 mutex_lock(&tty_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002322 /*
2323 * The process must be a session leader and
2324 * not have a controlling tty already.
2325 */
Peter Zijlstra24ec8392006-12-08 02:36:04 -08002326 if (!current->signal->leader || current->signal->tty) {
2327 ret = -EPERM;
2328 goto unlock;
2329 }
2330
Eric W. Biedermanab521dc2007-02-12 00:53:00 -08002331 if (tty->session) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002332 /*
2333 * This tty is already the controlling
2334 * tty for another session group!
2335 */
Alan Cox37bdfb02008-02-08 04:18:47 -08002336 if (arg == 1 && capable(CAP_SYS_ADMIN)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002337 /*
2338 * Steal it away
2339 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002340 read_lock(&tasklist_lock);
Peter Zijlstra24ec8392006-12-08 02:36:04 -08002341 session_clear_tty(tty->session);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002342 read_unlock(&tasklist_lock);
Peter Zijlstra24ec8392006-12-08 02:36:04 -08002343 } else {
2344 ret = -EPERM;
2345 goto unlock;
2346 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002347 }
Peter Zijlstra24ec8392006-12-08 02:36:04 -08002348 proc_set_tty(current, tty);
2349unlock:
Alan Cox28298232006-09-29 02:00:58 -07002350 mutex_unlock(&tty_mutex);
Peter Zijlstra24ec8392006-12-08 02:36:04 -08002351 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002352}
2353
Alan Coxaf9b8972006-08-27 01:24:01 -07002354/**
Alan Cox5d0fdf12008-04-30 00:53:31 -07002355 * tty_get_pgrp - return a ref counted pgrp pid
2356 * @tty: tty to read
2357 *
2358 * Returns a refcounted instance of the pid struct for the process
2359 * group controlling the tty.
2360 */
2361
2362struct pid *tty_get_pgrp(struct tty_struct *tty)
2363{
2364 unsigned long flags;
2365 struct pid *pgrp;
2366
2367 spin_lock_irqsave(&tty->ctrl_lock, flags);
2368 pgrp = get_pid(tty->pgrp);
2369 spin_unlock_irqrestore(&tty->ctrl_lock, flags);
2370
2371 return pgrp;
2372}
2373EXPORT_SYMBOL_GPL(tty_get_pgrp);
2374
2375/**
Alan Coxaf9b8972006-08-27 01:24:01 -07002376 * tiocgpgrp - get process group
2377 * @tty: tty passed by user
Lucas De Marchi25985ed2011-03-30 22:57:33 -03002378 * @real_tty: tty side of the tty passed by the user if a pty else the tty
Alan Coxaf9b8972006-08-27 01:24:01 -07002379 * @p: returned pid
2380 *
2381 * Obtain the process group of the tty. If there is no process group
2382 * return an error.
2383 *
Peter Zijlstra24ec8392006-12-08 02:36:04 -08002384 * Locking: none. Reference to current->signal->tty is safe.
Alan Coxaf9b8972006-08-27 01:24:01 -07002385 */
2386
Linus Torvalds1da177e2005-04-16 15:20:36 -07002387static int tiocgpgrp(struct tty_struct *tty, struct tty_struct *real_tty, pid_t __user *p)
2388{
Alan Cox5d0fdf12008-04-30 00:53:31 -07002389 struct pid *pid;
2390 int ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002391 /*
2392 * (tty == real_tty) is a cheap way of
2393 * testing if the tty is NOT a master pty.
2394 */
2395 if (tty == real_tty && current->signal->tty != real_tty)
2396 return -ENOTTY;
Alan Cox5d0fdf12008-04-30 00:53:31 -07002397 pid = tty_get_pgrp(real_tty);
2398 ret = put_user(pid_vnr(pid), p);
2399 put_pid(pid);
2400 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002401}
2402
Alan Coxaf9b8972006-08-27 01:24:01 -07002403/**
2404 * tiocspgrp - attempt to set process group
2405 * @tty: tty passed by user
2406 * @real_tty: tty side device matching tty passed by user
2407 * @p: pid pointer
2408 *
2409 * Set the process group of the tty to the session passed. Only
2410 * permitted where the tty session is our session.
2411 *
Alan Cox47f86832008-04-30 00:53:30 -07002412 * Locking: RCU, ctrl lock
Alan Coxaf9b8972006-08-27 01:24:01 -07002413 */
2414
Linus Torvalds1da177e2005-04-16 15:20:36 -07002415static int tiocspgrp(struct tty_struct *tty, struct tty_struct *real_tty, pid_t __user *p)
2416{
Eric W. Biederman04a2e6a2007-02-12 00:52:56 -08002417 struct pid *pgrp;
2418 pid_t pgrp_nr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002419 int retval = tty_check_change(real_tty);
Alan Cox47f86832008-04-30 00:53:30 -07002420 unsigned long flags;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002421
2422 if (retval == -EIO)
2423 return -ENOTTY;
2424 if (retval)
2425 return retval;
2426 if (!current->signal->tty ||
2427 (current->signal->tty != real_tty) ||
Eric W. Biedermanab521dc2007-02-12 00:53:00 -08002428 (real_tty->session != task_session(current)))
Linus Torvalds1da177e2005-04-16 15:20:36 -07002429 return -ENOTTY;
Eric W. Biederman04a2e6a2007-02-12 00:52:56 -08002430 if (get_user(pgrp_nr, p))
Linus Torvalds1da177e2005-04-16 15:20:36 -07002431 return -EFAULT;
Eric W. Biederman04a2e6a2007-02-12 00:52:56 -08002432 if (pgrp_nr < 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002433 return -EINVAL;
Eric W. Biederman04a2e6a2007-02-12 00:52:56 -08002434 rcu_read_lock();
Pavel Emelyanovb4888932007-10-18 23:40:14 -07002435 pgrp = find_vpid(pgrp_nr);
Eric W. Biederman04a2e6a2007-02-12 00:52:56 -08002436 retval = -ESRCH;
2437 if (!pgrp)
2438 goto out_unlock;
2439 retval = -EPERM;
2440 if (session_of_pgrp(pgrp) != task_session(current))
2441 goto out_unlock;
2442 retval = 0;
Alan Cox47f86832008-04-30 00:53:30 -07002443 spin_lock_irqsave(&tty->ctrl_lock, flags);
Eric W. Biedermanab521dc2007-02-12 00:53:00 -08002444 put_pid(real_tty->pgrp);
2445 real_tty->pgrp = get_pid(pgrp);
Alan Cox47f86832008-04-30 00:53:30 -07002446 spin_unlock_irqrestore(&tty->ctrl_lock, flags);
Eric W. Biederman04a2e6a2007-02-12 00:52:56 -08002447out_unlock:
2448 rcu_read_unlock();
2449 return retval;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002450}
2451
Alan Coxaf9b8972006-08-27 01:24:01 -07002452/**
2453 * tiocgsid - get session id
2454 * @tty: tty passed by user
Lucas De Marchi25985ed2011-03-30 22:57:33 -03002455 * @real_tty: tty side of the tty passed by the user if a pty else the tty
Alan Coxaf9b8972006-08-27 01:24:01 -07002456 * @p: pointer to returned session id
2457 *
2458 * Obtain the session id of the tty. If there is no session
2459 * return an error.
2460 *
Peter Zijlstra24ec8392006-12-08 02:36:04 -08002461 * Locking: none. Reference to current->signal->tty is safe.
Alan Coxaf9b8972006-08-27 01:24:01 -07002462 */
2463
Linus Torvalds1da177e2005-04-16 15:20:36 -07002464static int tiocgsid(struct tty_struct *tty, struct tty_struct *real_tty, pid_t __user *p)
2465{
2466 /*
2467 * (tty == real_tty) is a cheap way of
2468 * testing if the tty is NOT a master pty.
2469 */
2470 if (tty == real_tty && current->signal->tty != real_tty)
2471 return -ENOTTY;
Eric W. Biedermanab521dc2007-02-12 00:53:00 -08002472 if (!real_tty->session)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002473 return -ENOTTY;
Pavel Emelyanovb4888932007-10-18 23:40:14 -07002474 return put_user(pid_vnr(real_tty->session), p);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002475}
2476
Alan Coxaf9b8972006-08-27 01:24:01 -07002477/**
2478 * tiocsetd - set line discipline
2479 * @tty: tty device
2480 * @p: pointer to user data
2481 *
2482 * Set the line discipline according to user request.
2483 *
2484 * Locking: see tty_set_ldisc, this function is just a helper
2485 */
2486
Linus Torvalds1da177e2005-04-16 15:20:36 -07002487static int tiocsetd(struct tty_struct *tty, int __user *p)
2488{
2489 int ldisc;
Alan Cox04f378b2008-04-30 00:53:29 -07002490 int ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002491
2492 if (get_user(ldisc, p))
2493 return -EFAULT;
Alan Cox04f378b2008-04-30 00:53:29 -07002494
Alan Cox04f378b2008-04-30 00:53:29 -07002495 ret = tty_set_ldisc(tty, ldisc);
Alan Cox04f378b2008-04-30 00:53:29 -07002496
2497 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002498}
2499
Alan Coxaf9b8972006-08-27 01:24:01 -07002500/**
2501 * send_break - performed time break
2502 * @tty: device to break on
2503 * @duration: timeout in mS
2504 *
2505 * Perform a timed break on hardware that lacks its own driver level
2506 * timed break functionality.
2507 *
2508 * Locking:
Alan Cox28298232006-09-29 02:00:58 -07002509 * atomic_write_lock serializes
Alan Coxaf9b8972006-08-27 01:24:01 -07002510 *
Alan Coxaf9b8972006-08-27 01:24:01 -07002511 */
2512
Domen Puncerb20f3ae2005-06-25 14:58:42 -07002513static int send_break(struct tty_struct *tty, unsigned int duration)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002514{
Alan Cox9e989662008-07-22 11:18:03 +01002515 int retval;
2516
2517 if (tty->ops->break_ctl == NULL)
2518 return 0;
2519
2520 if (tty->driver->flags & TTY_DRIVER_HARDWARE_BREAK)
2521 retval = tty->ops->break_ctl(tty, duration);
2522 else {
2523 /* Do the work ourselves */
2524 if (tty_write_lock(tty, 0) < 0)
2525 return -EINTR;
2526 retval = tty->ops->break_ctl(tty, -1);
2527 if (retval)
2528 goto out;
2529 if (!signal_pending(current))
2530 msleep_interruptible(duration);
2531 retval = tty->ops->break_ctl(tty, 0);
2532out:
2533 tty_write_unlock(tty);
2534 if (signal_pending(current))
2535 retval = -EINTR;
2536 }
2537 return retval;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002538}
2539
Alan Coxaf9b8972006-08-27 01:24:01 -07002540/**
Alan Coxf34d7a52008-04-30 00:54:13 -07002541 * tty_tiocmget - get modem status
Alan Coxaf9b8972006-08-27 01:24:01 -07002542 * @tty: tty device
2543 * @file: user file pointer
2544 * @p: pointer to result
2545 *
2546 * Obtain the modem status bits from the tty driver if the feature
2547 * is supported. Return -EINVAL if it is not available.
2548 *
2549 * Locking: none (up to the driver)
2550 */
2551
Alan Cox60b33c12011-02-14 16:26:14 +00002552static int tty_tiocmget(struct tty_struct *tty, int __user *p)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002553{
2554 int retval = -EINVAL;
2555
Alan Coxf34d7a52008-04-30 00:54:13 -07002556 if (tty->ops->tiocmget) {
Alan Cox60b33c12011-02-14 16:26:14 +00002557 retval = tty->ops->tiocmget(tty);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002558
2559 if (retval >= 0)
2560 retval = put_user(retval, p);
2561 }
2562 return retval;
2563}
2564
Alan Coxaf9b8972006-08-27 01:24:01 -07002565/**
Alan Coxf34d7a52008-04-30 00:54:13 -07002566 * tty_tiocmset - set modem status
Alan Coxaf9b8972006-08-27 01:24:01 -07002567 * @tty: tty device
Alan Coxaf9b8972006-08-27 01:24:01 -07002568 * @cmd: command - clear bits, set bits or set all
2569 * @p: pointer to desired bits
2570 *
2571 * Set the modem status bits from the tty driver if the feature
2572 * is supported. Return -EINVAL if it is not available.
2573 *
2574 * Locking: none (up to the driver)
2575 */
2576
Alan Cox20b9d172011-02-14 16:26:50 +00002577static int tty_tiocmset(struct tty_struct *tty, unsigned int cmd,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002578 unsigned __user *p)
2579{
Alan Coxae677512008-07-16 21:56:54 +01002580 int retval;
2581 unsigned int set, clear, val;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002582
Alan Coxae677512008-07-16 21:56:54 +01002583 if (tty->ops->tiocmset == NULL)
2584 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002585
Alan Coxae677512008-07-16 21:56:54 +01002586 retval = get_user(val, p);
2587 if (retval)
2588 return retval;
2589 set = clear = 0;
2590 switch (cmd) {
2591 case TIOCMBIS:
2592 set = val;
2593 break;
2594 case TIOCMBIC:
2595 clear = val;
2596 break;
2597 case TIOCMSET:
2598 set = val;
2599 clear = ~val;
2600 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002601 }
Alan Coxae677512008-07-16 21:56:54 +01002602 set &= TIOCM_DTR|TIOCM_RTS|TIOCM_OUT1|TIOCM_OUT2|TIOCM_LOOP;
2603 clear &= TIOCM_DTR|TIOCM_RTS|TIOCM_OUT1|TIOCM_OUT2|TIOCM_LOOP;
Alan Cox20b9d172011-02-14 16:26:50 +00002604 return tty->ops->tiocmset(tty, set, clear);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002605}
2606
Alan Coxd281da72010-09-16 18:21:24 +01002607static int tty_tiocgicount(struct tty_struct *tty, void __user *arg)
2608{
2609 int retval = -EINVAL;
2610 struct serial_icounter_struct icount;
2611 memset(&icount, 0, sizeof(icount));
2612 if (tty->ops->get_icount)
2613 retval = tty->ops->get_icount(tty, &icount);
2614 if (retval != 0)
2615 return retval;
2616 if (copy_to_user(arg, &icount, sizeof(icount)))
2617 return -EFAULT;
2618 return 0;
2619}
2620
Alan Coxe8b70e72009-06-11 12:48:02 +01002621struct tty_struct *tty_pair_get_tty(struct tty_struct *tty)
2622{
2623 if (tty->driver->type == TTY_DRIVER_TYPE_PTY &&
2624 tty->driver->subtype == PTY_TYPE_MASTER)
2625 tty = tty->link;
2626 return tty;
2627}
2628EXPORT_SYMBOL(tty_pair_get_tty);
2629
2630struct tty_struct *tty_pair_get_pty(struct tty_struct *tty)
2631{
2632 if (tty->driver->type == TTY_DRIVER_TYPE_PTY &&
2633 tty->driver->subtype == PTY_TYPE_MASTER)
2634 return tty;
2635 return tty->link;
2636}
2637EXPORT_SYMBOL(tty_pair_get_pty);
2638
Linus Torvalds1da177e2005-04-16 15:20:36 -07002639/*
2640 * Split this up, as gcc can choke on it otherwise..
2641 */
Alan Cox04f378b2008-04-30 00:53:29 -07002642long tty_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002643{
Nick Piggind996b622010-08-18 04:37:36 +10002644 struct tty_struct *tty = file_tty(file);
2645 struct tty_struct *real_tty;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002646 void __user *p = (void __user *)arg;
2647 int retval;
2648 struct tty_ldisc *ld;
Alan Cox04f378b2008-04-30 00:53:29 -07002649 struct inode *inode = file->f_dentry->d_inode;
Alan Cox37bdfb02008-02-08 04:18:47 -08002650
Linus Torvalds1da177e2005-04-16 15:20:36 -07002651 if (tty_paranoia_check(tty, inode, "tty_ioctl"))
2652 return -EINVAL;
2653
Alan Coxe8b70e72009-06-11 12:48:02 +01002654 real_tty = tty_pair_get_tty(tty);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002655
2656 /*
2657 * Factor out some common prep work
2658 */
2659 switch (cmd) {
2660 case TIOCSETD:
2661 case TIOCSBRK:
2662 case TIOCCBRK:
2663 case TCSBRK:
Alan Cox37bdfb02008-02-08 04:18:47 -08002664 case TCSBRKP:
Linus Torvalds1da177e2005-04-16 15:20:36 -07002665 retval = tty_check_change(tty);
2666 if (retval)
2667 return retval;
2668 if (cmd != TIOCCBRK) {
2669 tty_wait_until_sent(tty, 0);
2670 if (signal_pending(current))
2671 return -EINTR;
2672 }
2673 break;
2674 }
2675
Alan Cox9e989662008-07-22 11:18:03 +01002676 /*
2677 * Now do the stuff.
2678 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002679 switch (cmd) {
Alan Cox37bdfb02008-02-08 04:18:47 -08002680 case TIOCSTI:
2681 return tiocsti(tty, p);
2682 case TIOCGWINSZ:
Alan Cox8f520022008-10-13 10:38:46 +01002683 return tiocgwinsz(real_tty, p);
Alan Cox37bdfb02008-02-08 04:18:47 -08002684 case TIOCSWINSZ:
Alan Coxfc6f6232009-01-02 13:43:17 +00002685 return tiocswinsz(real_tty, p);
Alan Cox37bdfb02008-02-08 04:18:47 -08002686 case TIOCCONS:
2687 return real_tty != tty ? -EINVAL : tioccons(file);
2688 case FIONBIO:
2689 return fionbio(file, p);
2690 case TIOCEXCL:
2691 set_bit(TTY_EXCLUSIVE, &tty->flags);
2692 return 0;
2693 case TIOCNXCL:
2694 clear_bit(TTY_EXCLUSIVE, &tty->flags);
2695 return 0;
2696 case TIOCNOTTY:
2697 if (current->signal->tty != tty)
2698 return -ENOTTY;
2699 no_tty();
2700 return 0;
2701 case TIOCSCTTY:
2702 return tiocsctty(tty, arg);
2703 case TIOCGPGRP:
2704 return tiocgpgrp(tty, real_tty, p);
2705 case TIOCSPGRP:
2706 return tiocspgrp(tty, real_tty, p);
2707 case TIOCGSID:
2708 return tiocgsid(tty, real_tty, p);
2709 case TIOCGETD:
Alan Coxc65c9bc2009-06-11 12:50:12 +01002710 return put_user(tty->ldisc->ops->num, (int __user *)p);
Alan Cox37bdfb02008-02-08 04:18:47 -08002711 case TIOCSETD:
2712 return tiocsetd(tty, p);
Kay Sievers3c95c982011-02-17 18:39:28 +01002713 case TIOCVHANGUP:
2714 if (!capable(CAP_SYS_ADMIN))
2715 return -EPERM;
2716 tty_vhangup(tty);
2717 return 0;
Werner Finkb7b8de02010-12-03 12:48:23 +01002718 case TIOCGDEV:
2719 {
2720 unsigned int ret = new_encode_dev(tty_devnum(real_tty));
2721 return put_user(ret, (unsigned int __user *)p);
2722 }
Alan Cox37bdfb02008-02-08 04:18:47 -08002723 /*
2724 * Break handling
2725 */
2726 case TIOCSBRK: /* Turn break on, unconditionally */
Alan Coxf34d7a52008-04-30 00:54:13 -07002727 if (tty->ops->break_ctl)
Alan Cox9e989662008-07-22 11:18:03 +01002728 return tty->ops->break_ctl(tty, -1);
Alan Cox37bdfb02008-02-08 04:18:47 -08002729 return 0;
Alan Cox37bdfb02008-02-08 04:18:47 -08002730 case TIOCCBRK: /* Turn break off, unconditionally */
Alan Coxf34d7a52008-04-30 00:54:13 -07002731 if (tty->ops->break_ctl)
Alan Cox9e989662008-07-22 11:18:03 +01002732 return tty->ops->break_ctl(tty, 0);
Alan Cox37bdfb02008-02-08 04:18:47 -08002733 return 0;
2734 case TCSBRK: /* SVID version: non-zero arg --> no break */
2735 /* non-zero arg means wait for all output data
2736 * to be sent (performed above) but don't send break.
2737 * This is used by the tcdrain() termios function.
Linus Torvalds1da177e2005-04-16 15:20:36 -07002738 */
Alan Cox37bdfb02008-02-08 04:18:47 -08002739 if (!arg)
2740 return send_break(tty, 250);
2741 return 0;
2742 case TCSBRKP: /* support for POSIX tcsendbreak() */
2743 return send_break(tty, arg ? arg*100 : 250);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002744
Alan Cox37bdfb02008-02-08 04:18:47 -08002745 case TIOCMGET:
Alan Cox60b33c12011-02-14 16:26:14 +00002746 return tty_tiocmget(tty, p);
Alan Cox37bdfb02008-02-08 04:18:47 -08002747 case TIOCMSET:
2748 case TIOCMBIC:
2749 case TIOCMBIS:
Alan Cox20b9d172011-02-14 16:26:50 +00002750 return tty_tiocmset(tty, cmd, p);
Alan Coxd281da72010-09-16 18:21:24 +01002751 case TIOCGICOUNT:
2752 retval = tty_tiocgicount(tty, p);
2753 /* For the moment allow fall through to the old method */
2754 if (retval != -EINVAL)
2755 return retval;
2756 break;
Alan Cox37bdfb02008-02-08 04:18:47 -08002757 case TCFLSH:
2758 switch (arg) {
2759 case TCIFLUSH:
2760 case TCIOFLUSH:
2761 /* flush tty buffer and allow ldisc to process ioctl */
2762 tty_buffer_flush(tty);
Paul Fulghumc5c34d42007-05-12 10:36:55 -07002763 break;
Alan Cox37bdfb02008-02-08 04:18:47 -08002764 }
2765 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002766 }
Alan Coxf34d7a52008-04-30 00:54:13 -07002767 if (tty->ops->ioctl) {
Alan Cox6caa76b2011-02-14 16:27:22 +00002768 retval = (tty->ops->ioctl)(tty, cmd, arg);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002769 if (retval != -ENOIOCTLCMD)
2770 return retval;
2771 }
2772 ld = tty_ldisc_ref_wait(tty);
2773 retval = -EINVAL;
Alan Coxa352def2008-07-16 21:53:12 +01002774 if (ld->ops->ioctl) {
2775 retval = ld->ops->ioctl(tty, file, cmd, arg);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002776 if (retval == -ENOIOCTLCMD)
Wanlong Gaobbb63c52012-08-27 15:23:12 +08002777 retval = -ENOTTY;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002778 }
2779 tty_ldisc_deref(ld);
2780 return retval;
2781}
2782
Paul Fulghume10cc1d2007-05-10 22:22:50 -07002783#ifdef CONFIG_COMPAT
Alan Cox37bdfb02008-02-08 04:18:47 -08002784static long tty_compat_ioctl(struct file *file, unsigned int cmd,
Paul Fulghume10cc1d2007-05-10 22:22:50 -07002785 unsigned long arg)
2786{
2787 struct inode *inode = file->f_dentry->d_inode;
Nick Piggind996b622010-08-18 04:37:36 +10002788 struct tty_struct *tty = file_tty(file);
Paul Fulghume10cc1d2007-05-10 22:22:50 -07002789 struct tty_ldisc *ld;
2790 int retval = -ENOIOCTLCMD;
2791
2792 if (tty_paranoia_check(tty, inode, "tty_ioctl"))
2793 return -EINVAL;
2794
Alan Coxf34d7a52008-04-30 00:54:13 -07002795 if (tty->ops->compat_ioctl) {
Alan Cox6caa76b2011-02-14 16:27:22 +00002796 retval = (tty->ops->compat_ioctl)(tty, cmd, arg);
Paul Fulghume10cc1d2007-05-10 22:22:50 -07002797 if (retval != -ENOIOCTLCMD)
2798 return retval;
2799 }
2800
2801 ld = tty_ldisc_ref_wait(tty);
Alan Coxa352def2008-07-16 21:53:12 +01002802 if (ld->ops->compat_ioctl)
2803 retval = ld->ops->compat_ioctl(tty, file, cmd, arg);
Thomas Meyer8193c422011-10-05 23:13:13 +02002804 else
2805 retval = n_tty_compat_ioctl_helper(tty, file, cmd, arg);
Paul Fulghume10cc1d2007-05-10 22:22:50 -07002806 tty_ldisc_deref(ld);
2807
2808 return retval;
2809}
2810#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07002811
2812/*
2813 * This implements the "Secure Attention Key" --- the idea is to
2814 * prevent trojan horses by killing all processes associated with this
2815 * tty when the user hits the "Secure Attention Key". Required for
2816 * super-paranoid applications --- see the Orange Book for more details.
Alan Cox37bdfb02008-02-08 04:18:47 -08002817 *
Linus Torvalds1da177e2005-04-16 15:20:36 -07002818 * This code could be nicer; ideally it should send a HUP, wait a few
2819 * seconds, then send a INT, and then a KILL signal. But you then
2820 * have to coordinate with the init process, since all processes associated
2821 * with the current tty must be dead before the new getty is allowed
2822 * to spawn.
2823 *
2824 * Now, if it would be correct ;-/ The current code has a nasty hole -
2825 * it doesn't catch files in flight. We may send the descriptor to ourselves
2826 * via AF_UNIX socket, close it and later fetch from socket. FIXME.
2827 *
2828 * Nasty bug: do_SAK is being called in interrupt context. This can
2829 * deadlock. We punt it up to process context. AKPM - 16Mar2001
2830 */
Eric W. Biederman8b6312f2007-02-10 01:44:34 -08002831void __do_SAK(struct tty_struct *tty)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002832{
2833#ifdef TTY_SOFT_SAK
2834 tty_hangup(tty);
2835#else
Eric W. Biederman652486f2006-03-28 16:11:02 -08002836 struct task_struct *g, *p;
Eric W. Biedermanab521dc2007-02-12 00:53:00 -08002837 struct pid *session;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002838 int i;
2839 struct file *filp;
Dipankar Sarmabadf1662005-09-09 13:04:10 -07002840 struct fdtable *fdt;
Alan Cox37bdfb02008-02-08 04:18:47 -08002841
Linus Torvalds1da177e2005-04-16 15:20:36 -07002842 if (!tty)
2843 return;
Peter Zijlstra24ec8392006-12-08 02:36:04 -08002844 session = tty->session;
Alan Cox37bdfb02008-02-08 04:18:47 -08002845
Dan Carpenterb3f13de2006-12-13 00:35:09 -08002846 tty_ldisc_flush(tty);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002847
Alan Coxf34d7a52008-04-30 00:54:13 -07002848 tty_driver_flush_buffer(tty);
Alan Cox37bdfb02008-02-08 04:18:47 -08002849
Linus Torvalds1da177e2005-04-16 15:20:36 -07002850 read_lock(&tasklist_lock);
Eric W. Biederman652486f2006-03-28 16:11:02 -08002851 /* Kill the entire session */
Eric W. Biedermanab521dc2007-02-12 00:53:00 -08002852 do_each_pid_task(session, PIDTYPE_SID, p) {
Eric W. Biederman652486f2006-03-28 16:11:02 -08002853 printk(KERN_NOTICE "SAK: killed process %d"
Oleg Nesterov1b0f7ff2009-04-02 16:58:39 -07002854 " (%s): task_session(p)==tty->session\n",
Pavel Emelyanovba25f9d2007-10-18 23:40:40 -07002855 task_pid_nr(p), p->comm);
Eric W. Biederman652486f2006-03-28 16:11:02 -08002856 send_sig(SIGKILL, p, 1);
Eric W. Biedermanab521dc2007-02-12 00:53:00 -08002857 } while_each_pid_task(session, PIDTYPE_SID, p);
Eric W. Biederman652486f2006-03-28 16:11:02 -08002858 /* Now kill any processes that happen to have the
2859 * tty open.
2860 */
2861 do_each_thread(g, p) {
2862 if (p->signal->tty == tty) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002863 printk(KERN_NOTICE "SAK: killed process %d"
Oleg Nesterov1b0f7ff2009-04-02 16:58:39 -07002864 " (%s): task_session(p)==tty->session\n",
Pavel Emelyanovba25f9d2007-10-18 23:40:40 -07002865 task_pid_nr(p), p->comm);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002866 send_sig(SIGKILL, p, 1);
2867 continue;
2868 }
2869 task_lock(p);
2870 if (p->files) {
Dipankar Sarmaca99c1d2006-04-18 22:21:46 -07002871 /*
2872 * We don't take a ref to the file, so we must
2873 * hold ->file_lock instead.
2874 */
2875 spin_lock(&p->files->file_lock);
Dipankar Sarmabadf1662005-09-09 13:04:10 -07002876 fdt = files_fdtable(p->files);
Alan Cox37bdfb02008-02-08 04:18:47 -08002877 for (i = 0; i < fdt->max_fds; i++) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002878 filp = fcheck_files(p->files, i);
2879 if (!filp)
2880 continue;
2881 if (filp->f_op->read == tty_read &&
Nick Piggind996b622010-08-18 04:37:36 +10002882 file_tty(filp) == tty) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002883 printk(KERN_NOTICE "SAK: killed process %d"
2884 " (%s): fd#%d opened to the tty\n",
Pavel Emelyanovba25f9d2007-10-18 23:40:40 -07002885 task_pid_nr(p), p->comm, i);
Eric W. Biederman20ac9432006-04-13 04:49:07 -06002886 force_sig(SIGKILL, p);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002887 break;
2888 }
2889 }
Dipankar Sarmaca99c1d2006-04-18 22:21:46 -07002890 spin_unlock(&p->files->file_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002891 }
2892 task_unlock(p);
Eric W. Biederman652486f2006-03-28 16:11:02 -08002893 } while_each_thread(g, p);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002894 read_unlock(&tasklist_lock);
2895#endif
2896}
2897
Eric W. Biederman8b6312f2007-02-10 01:44:34 -08002898static void do_SAK_work(struct work_struct *work)
2899{
2900 struct tty_struct *tty =
2901 container_of(work, struct tty_struct, SAK_work);
2902 __do_SAK(tty);
2903}
2904
Linus Torvalds1da177e2005-04-16 15:20:36 -07002905/*
2906 * The tq handling here is a little racy - tty->SAK_work may already be queued.
2907 * Fortunately we don't need to worry, because if ->SAK_work is already queued,
2908 * the values which we write to it will be identical to the values which it
2909 * already has. --akpm
2910 */
2911void do_SAK(struct tty_struct *tty)
2912{
2913 if (!tty)
2914 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002915 schedule_work(&tty->SAK_work);
2916}
2917
2918EXPORT_SYMBOL(do_SAK);
2919
Dmitry Eremin-Solenikov30004ac2010-08-09 18:22:49 +04002920static int dev_match_devt(struct device *dev, void *data)
2921{
2922 dev_t *devt = data;
2923 return dev->devt == *devt;
2924}
2925
2926/* Must put_device() after it's unused! */
2927static struct device *tty_get_device(struct tty_struct *tty)
2928{
2929 dev_t devt = tty_devnum(tty);
2930 return class_find_device(tty_class, NULL, &devt, dev_match_devt);
2931}
2932
2933
Alan Coxaf9b8972006-08-27 01:24:01 -07002934/**
Alan Coxaf9b8972006-08-27 01:24:01 -07002935 * initialize_tty_struct
2936 * @tty: tty to initialize
2937 *
2938 * This subroutine initializes a tty structure that has been newly
2939 * allocated.
2940 *
2941 * Locking: none - tty in question must not be exposed at this point
Linus Torvalds1da177e2005-04-16 15:20:36 -07002942 */
Alan Coxaf9b8972006-08-27 01:24:01 -07002943
Alan Coxbf970ee2008-10-13 10:42:39 +01002944void initialize_tty_struct(struct tty_struct *tty,
2945 struct tty_driver *driver, int idx)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002946{
2947 memset(tty, 0, sizeof(struct tty_struct));
Alan Cox9c9f4de2008-10-13 10:37:26 +01002948 kref_init(&tty->kref);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002949 tty->magic = TTY_MAGIC;
Alan Cox01e1abb2008-07-22 11:16:55 +01002950 tty_ldisc_init(tty);
Eric W. Biedermanab521dc2007-02-12 00:53:00 -08002951 tty->session = NULL;
2952 tty->pgrp = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002953 tty->overrun_time = jiffies;
Alan Cox33f0f882006-01-09 20:54:13 -08002954 tty_buffer_init(tty);
Alan Cox89c8d912012-08-08 16:30:13 +01002955 mutex_init(&tty->legacy_mutex);
Arjan van de Ven5785c952006-09-29 02:00:43 -07002956 mutex_init(&tty->termios_mutex);
Alan Coxc65c9bc2009-06-11 12:50:12 +01002957 mutex_init(&tty->ldisc_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002958 init_waitqueue_head(&tty->write_wait);
2959 init_waitqueue_head(&tty->read_wait);
David Howells65f27f32006-11-22 14:55:48 +00002960 INIT_WORK(&tty->hangup_work, do_tty_hangup);
Ingo Molnar70522e12006-03-23 03:00:31 -08002961 mutex_init(&tty->atomic_read_lock);
2962 mutex_init(&tty->atomic_write_lock);
Joe Petersona88a69c2009-01-02 13:40:53 +00002963 mutex_init(&tty->output_lock);
2964 mutex_init(&tty->echo_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002965 spin_lock_init(&tty->read_lock);
Alan Cox04f378b2008-04-30 00:53:29 -07002966 spin_lock_init(&tty->ctrl_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002967 INIT_LIST_HEAD(&tty->tty_files);
Eric W. Biederman7f1f86a2007-02-13 14:38:58 -07002968 INIT_WORK(&tty->SAK_work, do_SAK_work);
Alan Coxbf970ee2008-10-13 10:42:39 +01002969
2970 tty->driver = driver;
2971 tty->ops = driver->ops;
2972 tty->index = idx;
2973 tty_line_name(driver, idx, tty->name);
Dmitry Eremin-Solenikov30004ac2010-08-09 18:22:49 +04002974 tty->dev = tty_get_device(tty);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002975}
2976
Alan Coxf34d7a52008-04-30 00:54:13 -07002977/**
Jiri Slaby67166712011-03-23 10:48:35 +01002978 * deinitialize_tty_struct
2979 * @tty: tty to deinitialize
2980 *
2981 * This subroutine deinitializes a tty structure that has been newly
2982 * allocated but tty_release cannot be called on that yet.
2983 *
2984 * Locking: none - tty in question must not be exposed at this point
2985 */
2986void deinitialize_tty_struct(struct tty_struct *tty)
2987{
2988 tty_ldisc_deinit(tty);
2989}
2990
2991/**
Alan Coxf34d7a52008-04-30 00:54:13 -07002992 * tty_put_char - write one character to a tty
2993 * @tty: tty
2994 * @ch: character
2995 *
2996 * Write one byte to the tty using the provided put_char method
2997 * if present. Returns the number of characters successfully output.
2998 *
2999 * Note: the specific put_char operation in the driver layer may go
3000 * away soon. Don't call it directly, use this method
Linus Torvalds1da177e2005-04-16 15:20:36 -07003001 */
Alan Coxaf9b8972006-08-27 01:24:01 -07003002
Alan Coxf34d7a52008-04-30 00:54:13 -07003003int tty_put_char(struct tty_struct *tty, unsigned char ch)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003004{
Alan Coxf34d7a52008-04-30 00:54:13 -07003005 if (tty->ops->put_char)
3006 return tty->ops->put_char(tty, ch);
3007 return tty->ops->write(tty, &ch, 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003008}
Alan Coxf34d7a52008-04-30 00:54:13 -07003009EXPORT_SYMBOL_GPL(tty_put_char);
3010
Alan Coxd81ed102008-10-13 10:41:42 +01003011struct class *tty_class;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003012
Jiri Slaby7e73eca2012-08-08 22:26:44 +02003013static int tty_cdev_add(struct tty_driver *driver, dev_t dev,
3014 unsigned int index, unsigned int count)
3015{
3016 /* init here, since reused cdevs cause crashes */
3017 cdev_init(&driver->cdevs[index], &tty_fops);
3018 driver->cdevs[index].owner = driver->owner;
3019 return cdev_add(&driver->cdevs[index], dev, count);
3020}
3021
Linus Torvalds1da177e2005-04-16 15:20:36 -07003022/**
Alan Coxaf9b8972006-08-27 01:24:01 -07003023 * tty_register_device - register a tty device
3024 * @driver: the tty driver that describes the tty device
3025 * @index: the index in the tty driver for this tty device
3026 * @device: a struct device that is associated with this tty device.
3027 * This field is optional, if there is no known struct device
3028 * for this tty device it can be set to NULL safely.
Linus Torvalds1da177e2005-04-16 15:20:36 -07003029 *
Greg Kroah-Hartman01107d32006-08-07 22:19:37 -07003030 * Returns a pointer to the struct device for this tty device
3031 * (or ERR_PTR(-EFOO) on error).
Hansjoerg Lipp1cdcb6b2006-04-22 18:36:53 +02003032 *
Alan Coxaf9b8972006-08-27 01:24:01 -07003033 * This call is required to be made to register an individual tty device
3034 * if the tty driver's flags have the TTY_DRIVER_DYNAMIC_DEV bit set. If
3035 * that bit is not set, this function should not be called by a tty
3036 * driver.
3037 *
3038 * Locking: ??
Linus Torvalds1da177e2005-04-16 15:20:36 -07003039 */
Alan Coxaf9b8972006-08-27 01:24:01 -07003040
Greg Kroah-Hartman01107d32006-08-07 22:19:37 -07003041struct device *tty_register_device(struct tty_driver *driver, unsigned index,
3042 struct device *device)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003043{
Jiri Slaby7e73eca2012-08-08 22:26:44 +02003044 struct device *ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003045 char name[64];
3046 dev_t dev = MKDEV(driver->major, driver->minor_start) + index;
Jiri Slaby7e73eca2012-08-08 22:26:44 +02003047 bool cdev = false;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003048
3049 if (index >= driver->num) {
3050 printk(KERN_ERR "Attempt to register invalid tty line number "
3051 " (%d).\n", index);
Hansjoerg Lipp1cdcb6b2006-04-22 18:36:53 +02003052 return ERR_PTR(-EINVAL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003053 }
3054
Linus Torvalds1da177e2005-04-16 15:20:36 -07003055 if (driver->type == TTY_DRIVER_TYPE_PTY)
3056 pty_line_name(driver, index, name);
3057 else
3058 tty_line_name(driver, index, name);
Hansjoerg Lipp1cdcb6b2006-04-22 18:36:53 +02003059
Jiri Slaby7e73eca2012-08-08 22:26:44 +02003060 if (!(driver->flags & TTY_DRIVER_DYNAMIC_ALLOC)) {
3061 int error = tty_cdev_add(driver, dev, index, 1);
3062 if (error)
3063 return ERR_PTR(error);
3064 cdev = true;
3065 }
3066
3067 ret = device_create(tty_class, device, dev, NULL, name);
3068 if (IS_ERR(ret) && cdev)
3069 cdev_del(&driver->cdevs[index]);
3070
3071 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003072}
Alan Cox7d7b93c2008-10-13 10:42:09 +01003073EXPORT_SYMBOL(tty_register_device);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003074
3075/**
Alan Coxaf9b8972006-08-27 01:24:01 -07003076 * tty_unregister_device - unregister a tty device
3077 * @driver: the tty driver that describes the tty device
3078 * @index: the index in the tty driver for this tty device
Linus Torvalds1da177e2005-04-16 15:20:36 -07003079 *
Alan Coxaf9b8972006-08-27 01:24:01 -07003080 * If a tty device is registered with a call to tty_register_device() then
3081 * this function must be called when the tty device is gone.
3082 *
3083 * Locking: ??
Linus Torvalds1da177e2005-04-16 15:20:36 -07003084 */
Alan Coxaf9b8972006-08-27 01:24:01 -07003085
Linus Torvalds1da177e2005-04-16 15:20:36 -07003086void tty_unregister_device(struct tty_driver *driver, unsigned index)
3087{
Alan Cox37bdfb02008-02-08 04:18:47 -08003088 device_destroy(tty_class,
3089 MKDEV(driver->major, driver->minor_start) + index);
Jiri Slaby7e73eca2012-08-08 22:26:44 +02003090 if (!(driver->flags & TTY_DRIVER_DYNAMIC_ALLOC))
3091 cdev_del(&driver->cdevs[index]);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003092}
Linus Torvalds1da177e2005-04-16 15:20:36 -07003093EXPORT_SYMBOL(tty_unregister_device);
3094
Jiri Slaby7f0bc6a2012-08-07 21:47:42 +02003095/**
3096 * __tty_alloc_driver -- allocate tty driver
3097 * @lines: count of lines this driver can handle at most
3098 * @owner: module which is repsonsible for this driver
3099 * @flags: some of TTY_DRIVER_* flags, will be set in driver->flags
3100 *
3101 * This should not be called directly, some of the provided macros should be
3102 * used instead. Use IS_ERR and friends on @retval.
3103 */
3104struct tty_driver *__tty_alloc_driver(unsigned int lines, struct module *owner,
3105 unsigned long flags)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003106{
3107 struct tty_driver *driver;
Jiri Slaby7e73eca2012-08-08 22:26:44 +02003108 unsigned int cdevs = 1;
Jiri Slaby16a02082012-08-08 22:26:42 +02003109 int err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003110
Jiri Slaby0019b402012-08-08 22:26:43 +02003111 if (!lines || (flags & TTY_DRIVER_UNNUMBERED_NODE && lines > 1))
Jiri Slaby7f0bc6a2012-08-07 21:47:42 +02003112 return ERR_PTR(-EINVAL);
3113
Jean Delvare506eb992007-07-15 23:40:14 -07003114 driver = kzalloc(sizeof(struct tty_driver), GFP_KERNEL);
Jiri Slaby7f0bc6a2012-08-07 21:47:42 +02003115 if (!driver)
3116 return ERR_PTR(-ENOMEM);
3117
3118 kref_init(&driver->kref);
3119 driver->magic = TTY_DRIVER_MAGIC;
3120 driver->num = lines;
3121 driver->owner = owner;
3122 driver->flags = flags;
Jiri Slaby16a02082012-08-08 22:26:42 +02003123
3124 if (!(flags & TTY_DRIVER_DEVPTS_MEM)) {
3125 driver->ttys = kcalloc(lines, sizeof(*driver->ttys),
3126 GFP_KERNEL);
3127 driver->termios = kcalloc(lines, sizeof(*driver->termios),
3128 GFP_KERNEL);
3129 if (!driver->ttys || !driver->termios) {
3130 err = -ENOMEM;
3131 goto err_free_all;
3132 }
3133 }
3134
3135 if (!(flags & TTY_DRIVER_DYNAMIC_ALLOC)) {
3136 driver->ports = kcalloc(lines, sizeof(*driver->ports),
3137 GFP_KERNEL);
3138 if (!driver->ports) {
3139 err = -ENOMEM;
3140 goto err_free_all;
3141 }
Jiri Slaby7e73eca2012-08-08 22:26:44 +02003142 cdevs = lines;
3143 }
3144
3145 driver->cdevs = kcalloc(cdevs, sizeof(*driver->cdevs), GFP_KERNEL);
3146 if (!driver->cdevs) {
3147 err = -ENOMEM;
3148 goto err_free_all;
Jiri Slaby16a02082012-08-08 22:26:42 +02003149 }
Jiri Slaby7f0bc6a2012-08-07 21:47:42 +02003150
Linus Torvalds1da177e2005-04-16 15:20:36 -07003151 return driver;
Jiri Slaby16a02082012-08-08 22:26:42 +02003152err_free_all:
3153 kfree(driver->ports);
3154 kfree(driver->ttys);
3155 kfree(driver->termios);
3156 kfree(driver);
3157 return ERR_PTR(err);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003158}
Jiri Slaby7f0bc6a2012-08-07 21:47:42 +02003159EXPORT_SYMBOL(__tty_alloc_driver);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003160
Alan Cox7d7b93c2008-10-13 10:42:09 +01003161static void destruct_tty_driver(struct kref *kref)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003162{
Alan Cox7d7b93c2008-10-13 10:42:09 +01003163 struct tty_driver *driver = container_of(kref, struct tty_driver, kref);
3164 int i;
3165 struct ktermios *tp;
Alan Cox7d7b93c2008-10-13 10:42:09 +01003166
3167 if (driver->flags & TTY_DRIVER_INSTALLED) {
3168 /*
3169 * Free the termios and termios_locked structures because
3170 * we don't want to get memory leaks when modular tty
3171 * drivers are removed from the kernel.
3172 */
3173 for (i = 0; i < driver->num; i++) {
3174 tp = driver->termios[i];
3175 if (tp) {
3176 driver->termios[i] = NULL;
3177 kfree(tp);
3178 }
Alan Cox7d7b93c2008-10-13 10:42:09 +01003179 if (!(driver->flags & TTY_DRIVER_DYNAMIC_DEV))
3180 tty_unregister_device(driver, i);
3181 }
Alan Cox7d7b93c2008-10-13 10:42:09 +01003182 proc_tty_unregister_driver(driver);
Jiri Slaby7e73eca2012-08-08 22:26:44 +02003183 if (driver->flags & TTY_DRIVER_DYNAMIC_ALLOC)
3184 cdev_del(&driver->cdevs[0]);
Alan Cox7d7b93c2008-10-13 10:42:09 +01003185 }
Jiri Slaby7e73eca2012-08-08 22:26:44 +02003186 kfree(driver->cdevs);
Jiri Slaby04831dc2012-06-04 13:35:36 +02003187 kfree(driver->ports);
Jiri Slaby16a02082012-08-08 22:26:42 +02003188 kfree(driver->termios);
3189 kfree(driver->ttys);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003190 kfree(driver);
3191}
3192
Alan Cox7d7b93c2008-10-13 10:42:09 +01003193void tty_driver_kref_put(struct tty_driver *driver)
3194{
3195 kref_put(&driver->kref, destruct_tty_driver);
3196}
3197EXPORT_SYMBOL(tty_driver_kref_put);
3198
Jeff Dikeb68e31d2006-10-02 02:17:18 -07003199void tty_set_operations(struct tty_driver *driver,
3200 const struct tty_operations *op)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003201{
Alan Coxf34d7a52008-04-30 00:54:13 -07003202 driver->ops = op;
3203};
Linus Torvalds1da177e2005-04-16 15:20:36 -07003204EXPORT_SYMBOL(tty_set_operations);
3205
Alan Cox7d7b93c2008-10-13 10:42:09 +01003206void put_tty_driver(struct tty_driver *d)
3207{
3208 tty_driver_kref_put(d);
3209}
3210EXPORT_SYMBOL(put_tty_driver);
3211
Linus Torvalds1da177e2005-04-16 15:20:36 -07003212/*
3213 * Called by a tty driver to register itself.
3214 */
3215int tty_register_driver(struct tty_driver *driver)
3216{
3217 int error;
Alan Cox37bdfb02008-02-08 04:18:47 -08003218 int i;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003219 dev_t dev;
Vasiliy Kulikovb670bde2010-09-05 22:32:22 +04003220 struct device *d;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003221
Linus Torvalds1da177e2005-04-16 15:20:36 -07003222 if (!driver->major) {
Alan Cox37bdfb02008-02-08 04:18:47 -08003223 error = alloc_chrdev_region(&dev, driver->minor_start,
3224 driver->num, driver->name);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003225 if (!error) {
3226 driver->major = MAJOR(dev);
3227 driver->minor_start = MINOR(dev);
3228 }
3229 } else {
3230 dev = MKDEV(driver->major, driver->minor_start);
Geert Uytterhoevene5717c42007-02-20 15:45:21 +01003231 error = register_chrdev_region(dev, driver->num, driver->name);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003232 }
Jiri Slaby9bb8a3d2012-06-04 13:35:35 +02003233 if (error < 0)
Jiri Slaby16a02082012-08-08 22:26:42 +02003234 goto err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003235
Jiri Slaby7e73eca2012-08-08 22:26:44 +02003236 if (driver->flags & TTY_DRIVER_DYNAMIC_ALLOC) {
3237 error = tty_cdev_add(driver, dev, 0, driver->num);
3238 if (error)
3239 goto err_unreg_char;
3240 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07003241
Alexey Dobriyanca509f62007-05-08 00:27:12 -07003242 mutex_lock(&tty_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003243 list_add(&driver->tty_drivers, &tty_drivers);
Alexey Dobriyanca509f62007-05-08 00:27:12 -07003244 mutex_unlock(&tty_mutex);
Alan Cox37bdfb02008-02-08 04:18:47 -08003245
3246 if (!(driver->flags & TTY_DRIVER_DYNAMIC_DEV)) {
Vasiliy Kulikovb670bde2010-09-05 22:32:22 +04003247 for (i = 0; i < driver->num; i++) {
3248 d = tty_register_device(driver, i, NULL);
3249 if (IS_ERR(d)) {
3250 error = PTR_ERR(d);
Jiri Slaby16a02082012-08-08 22:26:42 +02003251 goto err_unreg_devs;
Vasiliy Kulikovb670bde2010-09-05 22:32:22 +04003252 }
3253 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07003254 }
3255 proc_tty_register_driver(driver);
Alan Cox7d7b93c2008-10-13 10:42:09 +01003256 driver->flags |= TTY_DRIVER_INSTALLED;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003257 return 0;
Vasiliy Kulikovb670bde2010-09-05 22:32:22 +04003258
Jiri Slaby16a02082012-08-08 22:26:42 +02003259err_unreg_devs:
Vasiliy Kulikovb670bde2010-09-05 22:32:22 +04003260 for (i--; i >= 0; i--)
3261 tty_unregister_device(driver, i);
3262
3263 mutex_lock(&tty_mutex);
3264 list_del(&driver->tty_drivers);
3265 mutex_unlock(&tty_mutex);
3266
Jiri Slaby9bb8a3d2012-06-04 13:35:35 +02003267err_unreg_char:
Vasiliy Kulikovb670bde2010-09-05 22:32:22 +04003268 unregister_chrdev_region(dev, driver->num);
Jiri Slaby16a02082012-08-08 22:26:42 +02003269err:
Vasiliy Kulikovb670bde2010-09-05 22:32:22 +04003270 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003271}
Linus Torvalds1da177e2005-04-16 15:20:36 -07003272EXPORT_SYMBOL(tty_register_driver);
3273
3274/*
3275 * Called by a tty driver to unregister itself.
3276 */
3277int tty_unregister_driver(struct tty_driver *driver)
3278{
Alan Cox7d7b93c2008-10-13 10:42:09 +01003279#if 0
3280 /* FIXME */
Linus Torvalds1da177e2005-04-16 15:20:36 -07003281 if (driver->refcount)
3282 return -EBUSY;
Alan Cox7d7b93c2008-10-13 10:42:09 +01003283#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07003284 unregister_chrdev_region(MKDEV(driver->major, driver->minor_start),
3285 driver->num);
Alexey Dobriyanca509f62007-05-08 00:27:12 -07003286 mutex_lock(&tty_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003287 list_del(&driver->tty_drivers);
Alexey Dobriyanca509f62007-05-08 00:27:12 -07003288 mutex_unlock(&tty_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003289 return 0;
3290}
Alan Cox7d7b93c2008-10-13 10:42:09 +01003291
Linus Torvalds1da177e2005-04-16 15:20:36 -07003292EXPORT_SYMBOL(tty_unregister_driver);
3293
Peter Zijlstra24ec8392006-12-08 02:36:04 -08003294dev_t tty_devnum(struct tty_struct *tty)
3295{
3296 return MKDEV(tty->driver->major, tty->driver->minor_start) + tty->index;
3297}
3298EXPORT_SYMBOL(tty_devnum);
3299
3300void proc_clear_tty(struct task_struct *p)
3301{
Arjan van de Ven7c3b1dc2008-10-15 10:52:34 +01003302 unsigned long flags;
Alan Cox9c9f4de2008-10-13 10:37:26 +01003303 struct tty_struct *tty;
Arjan van de Ven7c3b1dc2008-10-15 10:52:34 +01003304 spin_lock_irqsave(&p->sighand->siglock, flags);
Alan Cox9c9f4de2008-10-13 10:37:26 +01003305 tty = p->signal->tty;
Peter Zijlstra24ec8392006-12-08 02:36:04 -08003306 p->signal->tty = NULL;
Arjan van de Ven7c3b1dc2008-10-15 10:52:34 +01003307 spin_unlock_irqrestore(&p->sighand->siglock, flags);
Alan Cox9c9f4de2008-10-13 10:37:26 +01003308 tty_kref_put(tty);
Peter Zijlstra24ec8392006-12-08 02:36:04 -08003309}
Peter Zijlstra24ec8392006-12-08 02:36:04 -08003310
Alan Cox47f86832008-04-30 00:53:30 -07003311/* Called under the sighand lock */
3312
Eric W. Biederman2a65f1d2007-05-08 00:26:53 -07003313static void __proc_set_tty(struct task_struct *tsk, struct tty_struct *tty)
Peter Zijlstra24ec8392006-12-08 02:36:04 -08003314{
3315 if (tty) {
Alan Cox47f86832008-04-30 00:53:30 -07003316 unsigned long flags;
3317 /* We should not have a session or pgrp to put here but.... */
3318 spin_lock_irqsave(&tty->ctrl_lock, flags);
Eric W. Biedermand9c1e9a2007-03-18 12:45:44 -06003319 put_pid(tty->session);
3320 put_pid(tty->pgrp);
Eric W. Biedermanab521dc2007-02-12 00:53:00 -08003321 tty->pgrp = get_pid(task_pgrp(tsk));
Alan Cox47f86832008-04-30 00:53:30 -07003322 spin_unlock_irqrestore(&tty->ctrl_lock, flags);
3323 tty->session = get_pid(task_session(tsk));
Alan Cox9c9f4de2008-10-13 10:37:26 +01003324 if (tsk->signal->tty) {
3325 printk(KERN_DEBUG "tty not NULL!!\n");
3326 tty_kref_put(tsk->signal->tty);
3327 }
Peter Zijlstra24ec8392006-12-08 02:36:04 -08003328 }
Eric W. Biederman2a65f1d2007-05-08 00:26:53 -07003329 put_pid(tsk->signal->tty_old_pgrp);
Alan Cox9c9f4de2008-10-13 10:37:26 +01003330 tsk->signal->tty = tty_kref_get(tty);
Eric W. Biedermanab521dc2007-02-12 00:53:00 -08003331 tsk->signal->tty_old_pgrp = NULL;
Peter Zijlstra24ec8392006-12-08 02:36:04 -08003332}
3333
Eric W. Biederman98a27ba2007-05-08 00:26:56 -07003334static void proc_set_tty(struct task_struct *tsk, struct tty_struct *tty)
Peter Zijlstra24ec8392006-12-08 02:36:04 -08003335{
3336 spin_lock_irq(&tsk->sighand->siglock);
Eric W. Biederman2a65f1d2007-05-08 00:26:53 -07003337 __proc_set_tty(tsk, tty);
Peter Zijlstra24ec8392006-12-08 02:36:04 -08003338 spin_unlock_irq(&tsk->sighand->siglock);
3339}
3340
3341struct tty_struct *get_current_tty(void)
3342{
3343 struct tty_struct *tty;
Alan Cox934e6eb2008-10-13 10:40:43 +01003344 unsigned long flags;
3345
3346 spin_lock_irqsave(&current->sighand->siglock, flags);
Alan Cox452a00d2008-10-13 10:39:13 +01003347 tty = tty_kref_get(current->signal->tty);
Alan Cox934e6eb2008-10-13 10:40:43 +01003348 spin_unlock_irqrestore(&current->sighand->siglock, flags);
Peter Zijlstra24ec8392006-12-08 02:36:04 -08003349 return tty;
3350}
Heiko Carstensa311f742006-12-13 00:33:41 -08003351EXPORT_SYMBOL_GPL(get_current_tty);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003352
Alan Coxd81ed102008-10-13 10:41:42 +01003353void tty_default_fops(struct file_operations *fops)
3354{
3355 *fops = tty_fops;
3356}
3357
Linus Torvalds1da177e2005-04-16 15:20:36 -07003358/*
3359 * Initialize the console device. This is called *early*, so
3360 * we can't necessarily depend on lots of kernel help here.
3361 * Just do some early initializations, and do the complex setup
3362 * later.
3363 */
3364void __init console_init(void)
3365{
3366 initcall_t *call;
3367
3368 /* Setup the default TTY line discipline. */
Alan Cox01e1abb2008-07-22 11:16:55 +01003369 tty_ldisc_begin();
Linus Torvalds1da177e2005-04-16 15:20:36 -07003370
3371 /*
Alan Cox37bdfb02008-02-08 04:18:47 -08003372 * set up the console device so that later boot sequences can
Linus Torvalds1da177e2005-04-16 15:20:36 -07003373 * inform about problems etc..
3374 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07003375 call = __con_initcall_start;
3376 while (call < __con_initcall_end) {
3377 (*call)();
3378 call++;
3379 }
3380}
3381
Al Viro2c9ede52011-07-23 20:24:48 -04003382static char *tty_devnode(struct device *dev, umode_t *mode)
Kay Sieverse454cea2009-09-18 23:01:12 +02003383{
3384 if (!mode)
3385 return NULL;
3386 if (dev->devt == MKDEV(TTYAUX_MAJOR, 0) ||
3387 dev->devt == MKDEV(TTYAUX_MAJOR, 2))
3388 *mode = 0666;
3389 return NULL;
3390}
3391
Linus Torvalds1da177e2005-04-16 15:20:36 -07003392static int __init tty_class_init(void)
3393{
gregkh@suse.de7fe845d2005-03-15 14:23:15 -08003394 tty_class = class_create(THIS_MODULE, "tty");
Linus Torvalds1da177e2005-04-16 15:20:36 -07003395 if (IS_ERR(tty_class))
3396 return PTR_ERR(tty_class);
Kay Sieverse454cea2009-09-18 23:01:12 +02003397 tty_class->devnode = tty_devnode;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003398 return 0;
3399}
3400
3401postcore_initcall(tty_class_init);
3402
3403/* 3/2004 jmc: why do these devices exist? */
Linus Torvalds1da177e2005-04-16 15:20:36 -07003404static struct cdev tty_cdev, console_cdev;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003405
Kay Sieversfbc92a32010-12-01 18:51:05 +01003406static ssize_t show_cons_active(struct device *dev,
3407 struct device_attribute *attr, char *buf)
3408{
3409 struct console *cs[16];
3410 int i = 0;
3411 struct console *c;
3412 ssize_t count = 0;
3413
Torben Hohnac751ef2011-01-25 15:07:35 -08003414 console_lock();
Kay Sieversa2a6a822011-01-09 16:39:14 +01003415 for_each_console(c) {
Kay Sieversfbc92a32010-12-01 18:51:05 +01003416 if (!c->device)
3417 continue;
3418 if (!c->write)
3419 continue;
3420 if ((c->flags & CON_ENABLED) == 0)
3421 continue;
3422 cs[i++] = c;
3423 if (i >= ARRAY_SIZE(cs))
3424 break;
3425 }
3426 while (i--)
3427 count += sprintf(buf + count, "%s%d%c",
3428 cs[i]->name, cs[i]->index, i ? ' ':'\n');
Torben Hohnac751ef2011-01-25 15:07:35 -08003429 console_unlock();
Kay Sieversfbc92a32010-12-01 18:51:05 +01003430
3431 return count;
3432}
3433static DEVICE_ATTR(active, S_IRUGO, show_cons_active, NULL);
3434
3435static struct device *consdev;
3436
3437void console_sysfs_notify(void)
3438{
3439 if (consdev)
3440 sysfs_notify(&consdev->kobj, NULL, "active");
3441}
3442
Linus Torvalds1da177e2005-04-16 15:20:36 -07003443/*
3444 * Ok, now we can initialize the rest of the tty devices and can count
3445 * on memory allocations, interrupts etc..
3446 */
David Howells31d1d482010-08-06 16:34:43 +01003447int __init tty_init(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003448{
3449 cdev_init(&tty_cdev, &tty_fops);
3450 if (cdev_add(&tty_cdev, MKDEV(TTYAUX_MAJOR, 0), 1) ||
3451 register_chrdev_region(MKDEV(TTYAUX_MAJOR, 0), 1, "/dev/tty") < 0)
3452 panic("Couldn't register /dev/tty driver\n");
Kay Sieversfbc92a32010-12-01 18:51:05 +01003453 device_create(tty_class, NULL, MKDEV(TTYAUX_MAJOR, 0), NULL, "tty");
Linus Torvalds1da177e2005-04-16 15:20:36 -07003454
3455 cdev_init(&console_cdev, &console_fops);
3456 if (cdev_add(&console_cdev, MKDEV(TTYAUX_MAJOR, 1), 1) ||
3457 register_chrdev_region(MKDEV(TTYAUX_MAJOR, 1), 1, "/dev/console") < 0)
3458 panic("Couldn't register /dev/console driver\n");
Kay Sieversfbc92a32010-12-01 18:51:05 +01003459 consdev = device_create(tty_class, NULL, MKDEV(TTYAUX_MAJOR, 1), NULL,
Greg Kroah-Hartman47aa5792008-05-21 12:52:33 -07003460 "console");
Kay Sieversfbc92a32010-12-01 18:51:05 +01003461 if (IS_ERR(consdev))
3462 consdev = NULL;
3463 else
Kay Sieversa2a6a822011-01-09 16:39:14 +01003464 WARN_ON(device_create_file(consdev, &dev_attr_active) < 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003465
Linus Torvalds1da177e2005-04-16 15:20:36 -07003466#ifdef CONFIG_VT
Alan Coxd81ed102008-10-13 10:41:42 +01003467 vty_init(&console_fops);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003468#endif
3469 return 0;
3470}
David Howells31d1d482010-08-06 16:34:43 +01003471