blob: e41b9bbc107dcb688bc6653e5dc379794657dbf9 [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#include <asm/system.h>
101
102#include <linux/kbd_kern.h>
103#include <linux/vt_kern.h>
104#include <linux/selection.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -0700105
106#include <linux/kmod.h>
Pavel Emelyanovb4888932007-10-18 23:40:14 -0700107#include <linux/nsproxy.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -0700108
109#undef TTY_DEBUG_HANGUP
110
111#define TTY_PARANOIA_CHECK 1
112#define CHECK_TTY_COUNT 1
113
Alan Coxedc6afc2006-12-08 02:38:44 -0800114struct ktermios tty_std_termios = { /* for the benefit of tty drivers */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700115 .c_iflag = ICRNL | IXON,
116 .c_oflag = OPOST | ONLCR,
117 .c_cflag = B38400 | CS8 | CREAD | HUPCL,
118 .c_lflag = ISIG | ICANON | ECHO | ECHOE | ECHOK |
119 ECHOCTL | ECHOKE | IEXTEN,
Alan Coxedc6afc2006-12-08 02:38:44 -0800120 .c_cc = INIT_C_CC,
121 .c_ispeed = 38400,
122 .c_ospeed = 38400
Linus Torvalds1da177e2005-04-16 15:20:36 -0700123};
124
125EXPORT_SYMBOL(tty_std_termios);
126
127/* This list gets poked at by procfs and various bits of boot up code. This
128 could do with some rationalisation such as pulling the tty proc function
129 into this file */
Alan Cox37bdfb02008-02-08 04:18:47 -0800130
Linus Torvalds1da177e2005-04-16 15:20:36 -0700131LIST_HEAD(tty_drivers); /* linked list of tty drivers */
132
Peter Zijlstra24ec8392006-12-08 02:36:04 -0800133/* Mutex to protect creating and releasing a tty. This is shared with
Linus Torvalds1da177e2005-04-16 15:20:36 -0700134 vt.c for deeply disgusting hack reasons */
Ingo Molnar70522e12006-03-23 03:00:31 -0800135DEFINE_MUTEX(tty_mutex);
Alan Coxde2a84f2006-09-29 02:00:57 -0700136EXPORT_SYMBOL(tty_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700137
Nick Pigginee2ffa02010-08-18 04:37:35 +1000138/* Spinlock to protect the tty->tty_files list */
139DEFINE_SPINLOCK(tty_files_lock);
140
Linus Torvalds1da177e2005-04-16 15:20:36 -0700141static ssize_t tty_read(struct file *, char __user *, size_t, loff_t *);
142static ssize_t tty_write(struct file *, const char __user *, size_t, loff_t *);
Alan Cox37bdfb02008-02-08 04:18:47 -0800143ssize_t redirected_tty_write(struct file *, const char __user *,
144 size_t, loff_t *);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700145static unsigned int tty_poll(struct file *, poll_table *);
146static int tty_open(struct inode *, struct file *);
Alan Cox04f378b2008-04-30 00:53:29 -0700147long tty_ioctl(struct file *file, unsigned int cmd, unsigned long arg);
Paul Fulghume10cc1d2007-05-10 22:22:50 -0700148#ifdef CONFIG_COMPAT
Alan Cox37bdfb02008-02-08 04:18:47 -0800149static long tty_compat_ioctl(struct file *file, unsigned int cmd,
Paul Fulghume10cc1d2007-05-10 22:22:50 -0700150 unsigned long arg);
151#else
152#define tty_compat_ioctl NULL
153#endif
Arnd Bergmannec79d602010-06-01 22:53:01 +0200154static int __tty_fasync(int fd, struct file *filp, int on);
Alan Cox37bdfb02008-02-08 04:18:47 -0800155static int tty_fasync(int fd, struct file *filp, int on);
Christoph Hellwigd5698c22007-02-10 01:46:46 -0800156static void release_tty(struct tty_struct *tty, int idx);
Eric W. Biederman2a65f1d2007-05-08 00:26:53 -0700157static void __proc_set_tty(struct task_struct *tsk, struct tty_struct *tty);
Eric W. Biederman98a27ba2007-05-08 00:26:56 -0700158static void proc_set_tty(struct task_struct *tsk, struct tty_struct *tty);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700159
Alan Coxaf9b8972006-08-27 01:24:01 -0700160/**
161 * alloc_tty_struct - allocate a tty object
162 *
163 * Return a new empty tty structure. The data fields have not
164 * been initialized in any way but has been zeroed
165 *
166 * Locking: none
Alan Coxaf9b8972006-08-27 01:24:01 -0700167 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700168
Alan Coxbf970ee2008-10-13 10:42:39 +0100169struct tty_struct *alloc_tty_struct(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700170{
Alan Cox1266b1e2006-09-29 02:00:40 -0700171 return kzalloc(sizeof(struct tty_struct), GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700172}
173
Alan Coxaf9b8972006-08-27 01:24:01 -0700174/**
175 * free_tty_struct - free a disused tty
176 * @tty: tty struct to free
177 *
178 * Free the write buffers, tty queue and tty memory itself.
179 *
180 * Locking: none. Must be called after tty is definitely unused
181 */
182
Alan Coxbf970ee2008-10-13 10:42:39 +0100183void free_tty_struct(struct tty_struct *tty)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700184{
Dmitry Eremin-Solenikov30004ac2010-08-09 18:22:49 +0400185 if (tty->dev)
186 put_device(tty->dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700187 kfree(tty->write_buf);
Alan Cox33f0f882006-01-09 20:54:13 -0800188 tty_buffer_free_all(tty);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700189 kfree(tty);
190}
191
Nick Piggind996b622010-08-18 04:37:36 +1000192static inline struct tty_struct *file_tty(struct file *file)
193{
194 return ((struct tty_file_private *)file->private_data)->tty;
195}
196
Jiri Slabyfa90e1c2011-10-12 11:32:43 +0200197int tty_alloc_file(struct file *file)
Nick Piggind996b622010-08-18 04:37:36 +1000198{
199 struct tty_file_private *priv;
200
Pekka Enbergf573bd12010-08-24 07:48:34 +0300201 priv = kmalloc(sizeof(*priv), GFP_KERNEL);
202 if (!priv)
203 return -ENOMEM;
Nick Piggind996b622010-08-18 04:37:36 +1000204
Jiri Slabyfa90e1c2011-10-12 11:32:43 +0200205 file->private_data = priv;
206
207 return 0;
208}
209
210/* Associate a new file with the tty structure */
211void tty_add_file(struct tty_struct *tty, struct file *file)
212{
213 struct tty_file_private *priv = file->private_data;
214
Nick Piggind996b622010-08-18 04:37:36 +1000215 priv->tty = tty;
216 priv->file = file;
Nick Piggind996b622010-08-18 04:37:36 +1000217
218 spin_lock(&tty_files_lock);
219 list_add(&priv->list, &tty->tty_files);
220 spin_unlock(&tty_files_lock);
Jiri Slabyfa90e1c2011-10-12 11:32:43 +0200221}
Pekka Enbergf573bd12010-08-24 07:48:34 +0300222
Jiri Slabyfa90e1c2011-10-12 11:32:43 +0200223/**
224 * tty_free_file - free file->private_data
225 *
226 * This shall be used only for fail path handling when tty_add_file was not
227 * called yet.
228 */
229void tty_free_file(struct file *file)
230{
231 struct tty_file_private *priv = file->private_data;
232
233 file->private_data = NULL;
234 kfree(priv);
Nick Piggind996b622010-08-18 04:37:36 +1000235}
236
237/* Delete file from its tty */
238void tty_del_file(struct file *file)
239{
240 struct tty_file_private *priv = file->private_data;
241
242 spin_lock(&tty_files_lock);
243 list_del(&priv->list);
244 spin_unlock(&tty_files_lock);
Jiri Slabyfa90e1c2011-10-12 11:32:43 +0200245 tty_free_file(file);
Nick Piggind996b622010-08-18 04:37:36 +1000246}
247
248
Linus Torvalds1da177e2005-04-16 15:20:36 -0700249#define TTY_NUMBER(tty) ((tty)->index + (tty)->driver->name_base)
250
Alan Coxaf9b8972006-08-27 01:24:01 -0700251/**
252 * tty_name - return tty naming
253 * @tty: tty structure
254 * @buf: buffer for output
255 *
256 * Convert a tty structure into a name. The name reflects the kernel
257 * naming policy and if udev is in use may not reflect user space
258 *
259 * Locking: none
260 */
261
Linus Torvalds1da177e2005-04-16 15:20:36 -0700262char *tty_name(struct tty_struct *tty, char *buf)
263{
264 if (!tty) /* Hmm. NULL pointer. That's fun. */
265 strcpy(buf, "NULL tty");
266 else
267 strcpy(buf, tty->name);
268 return buf;
269}
270
271EXPORT_SYMBOL(tty_name);
272
Andrew Mortond769a662005-05-05 16:15:50 -0700273int tty_paranoia_check(struct tty_struct *tty, struct inode *inode,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700274 const char *routine)
275{
276#ifdef TTY_PARANOIA_CHECK
277 if (!tty) {
278 printk(KERN_WARNING
279 "null TTY for (%d:%d) in %s\n",
280 imajor(inode), iminor(inode), routine);
281 return 1;
282 }
283 if (tty->magic != TTY_MAGIC) {
284 printk(KERN_WARNING
285 "bad magic number for tty struct (%d:%d) in %s\n",
286 imajor(inode), iminor(inode), routine);
287 return 1;
288 }
289#endif
290 return 0;
291}
292
293static int check_tty_count(struct tty_struct *tty, const char *routine)
294{
295#ifdef CHECK_TTY_COUNT
296 struct list_head *p;
297 int count = 0;
Alan Cox37bdfb02008-02-08 04:18:47 -0800298
Nick Pigginee2ffa02010-08-18 04:37:35 +1000299 spin_lock(&tty_files_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700300 list_for_each(p, &tty->tty_files) {
301 count++;
302 }
Nick Pigginee2ffa02010-08-18 04:37:35 +1000303 spin_unlock(&tty_files_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700304 if (tty->driver->type == TTY_DRIVER_TYPE_PTY &&
305 tty->driver->subtype == PTY_TYPE_SLAVE &&
306 tty->link && tty->link->count)
307 count++;
308 if (tty->count != count) {
309 printk(KERN_WARNING "Warning: dev (%s) tty->count(%d) "
310 "!= #fd's(%d) in %s\n",
311 tty->name, tty->count, count, routine);
312 return count;
Peter Zijlstra24ec8392006-12-08 02:36:04 -0800313 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700314#endif
315 return 0;
316}
317
Alan Coxaf9b8972006-08-27 01:24:01 -0700318/**
Alan Coxaf9b8972006-08-27 01:24:01 -0700319 * get_tty_driver - find device of a tty
320 * @dev_t: device identifier
321 * @index: returns the index of the tty
322 *
323 * This routine returns a tty driver structure, given a device number
324 * and also passes back the index number.
325 *
326 * Locking: caller must hold tty_mutex
Linus Torvalds1da177e2005-04-16 15:20:36 -0700327 */
Alan Coxaf9b8972006-08-27 01:24:01 -0700328
Linus Torvalds1da177e2005-04-16 15:20:36 -0700329static struct tty_driver *get_tty_driver(dev_t device, int *index)
330{
331 struct tty_driver *p;
332
333 list_for_each_entry(p, &tty_drivers, tty_drivers) {
334 dev_t base = MKDEV(p->major, p->minor_start);
335 if (device < base || device >= base + p->num)
336 continue;
337 *index = device - base;
Alan Cox7d7b93c2008-10-13 10:42:09 +0100338 return tty_driver_kref_get(p);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700339 }
340 return NULL;
341}
342
Jason Wesself2d937f2008-04-17 20:05:37 +0200343#ifdef CONFIG_CONSOLE_POLL
344
345/**
346 * tty_find_polling_driver - find device of a polled tty
347 * @name: name string to match
348 * @line: pointer to resulting tty line nr
349 *
350 * This routine returns a tty driver structure, given a name
351 * and the condition that the tty driver is capable of polled
352 * operation.
353 */
354struct tty_driver *tty_find_polling_driver(char *name, int *line)
355{
356 struct tty_driver *p, *res = NULL;
357 int tty_line = 0;
Jason Wessel0dca0fd2008-09-26 10:36:42 -0500358 int len;
Alan Cox5f0878a2009-06-11 12:46:41 +0100359 char *str, *stp;
Jason Wesself2d937f2008-04-17 20:05:37 +0200360
Jason Wessel0dca0fd2008-09-26 10:36:42 -0500361 for (str = name; *str; str++)
362 if ((*str >= '0' && *str <= '9') || *str == ',')
363 break;
364 if (!*str)
365 return NULL;
366
367 len = str - name;
368 tty_line = simple_strtoul(str, &str, 10);
369
Jason Wesself2d937f2008-04-17 20:05:37 +0200370 mutex_lock(&tty_mutex);
371 /* Search through the tty devices to look for a match */
372 list_for_each_entry(p, &tty_drivers, tty_drivers) {
Jason Wessel0dca0fd2008-09-26 10:36:42 -0500373 if (strncmp(name, p->name, len) != 0)
374 continue;
Alan Cox5f0878a2009-06-11 12:46:41 +0100375 stp = str;
376 if (*stp == ',')
377 stp++;
378 if (*stp == '\0')
379 stp = NULL;
Jason Wesself2d937f2008-04-17 20:05:37 +0200380
Nathael Pajani6eb68d62010-09-02 16:06:16 +0200381 if (tty_line >= 0 && tty_line < p->num && p->ops &&
Alan Cox5f0878a2009-06-11 12:46:41 +0100382 p->ops->poll_init && !p->ops->poll_init(p, tty_line, stp)) {
Alan Cox7d7b93c2008-10-13 10:42:09 +0100383 res = tty_driver_kref_get(p);
Jason Wesself2d937f2008-04-17 20:05:37 +0200384 *line = tty_line;
385 break;
386 }
387 }
388 mutex_unlock(&tty_mutex);
389
390 return res;
391}
392EXPORT_SYMBOL_GPL(tty_find_polling_driver);
393#endif
394
Alan Coxaf9b8972006-08-27 01:24:01 -0700395/**
396 * tty_check_change - check for POSIX terminal changes
397 * @tty: tty to check
398 *
399 * If we try to write to, or set the state of, a terminal and we're
400 * not in the foreground, send a SIGTTOU. If the signal is blocked or
401 * ignored, go ahead and perform the operation. (POSIX 7.2)
402 *
Alan Cox978e5952008-04-30 00:53:59 -0700403 * Locking: ctrl_lock
Linus Torvalds1da177e2005-04-16 15:20:36 -0700404 */
Alan Coxaf9b8972006-08-27 01:24:01 -0700405
Alan Cox37bdfb02008-02-08 04:18:47 -0800406int tty_check_change(struct tty_struct *tty)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700407{
Alan Cox47f86832008-04-30 00:53:30 -0700408 unsigned long flags;
409 int ret = 0;
410
Linus Torvalds1da177e2005-04-16 15:20:36 -0700411 if (current->signal->tty != tty)
412 return 0;
Alan Cox47f86832008-04-30 00:53:30 -0700413
414 spin_lock_irqsave(&tty->ctrl_lock, flags);
415
Eric W. Biedermanab521dc2007-02-12 00:53:00 -0800416 if (!tty->pgrp) {
417 printk(KERN_WARNING "tty_check_change: tty->pgrp == NULL!\n");
Andrew Morton9ffee4c2008-05-14 16:05:58 -0700418 goto out_unlock;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700419 }
Eric W. Biedermanab521dc2007-02-12 00:53:00 -0800420 if (task_pgrp(current) == tty->pgrp)
Andrew Morton9ffee4c2008-05-14 16:05:58 -0700421 goto out_unlock;
422 spin_unlock_irqrestore(&tty->ctrl_lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700423 if (is_ignored(SIGTTOU))
Alan Cox47f86832008-04-30 00:53:30 -0700424 goto out;
425 if (is_current_pgrp_orphaned()) {
426 ret = -EIO;
427 goto out;
428 }
Oleg Nesterov040b6362007-06-01 00:46:53 -0700429 kill_pgrp(task_pgrp(current), SIGTTOU, 1);
430 set_thread_flag(TIF_SIGPENDING);
Alan Cox47f86832008-04-30 00:53:30 -0700431 ret = -ERESTARTSYS;
432out:
Andrew Morton9ffee4c2008-05-14 16:05:58 -0700433 return ret;
434out_unlock:
Alan Cox47f86832008-04-30 00:53:30 -0700435 spin_unlock_irqrestore(&tty->ctrl_lock, flags);
436 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700437}
438
439EXPORT_SYMBOL(tty_check_change);
440
Alan Cox37bdfb02008-02-08 04:18:47 -0800441static ssize_t hung_up_tty_read(struct file *file, char __user *buf,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700442 size_t count, loff_t *ppos)
443{
444 return 0;
445}
446
Alan Cox37bdfb02008-02-08 04:18:47 -0800447static ssize_t hung_up_tty_write(struct file *file, const char __user *buf,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700448 size_t count, loff_t *ppos)
449{
450 return -EIO;
451}
452
453/* No kernel lock held - none needed ;) */
Alan Cox37bdfb02008-02-08 04:18:47 -0800454static unsigned int hung_up_tty_poll(struct file *filp, poll_table *wait)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700455{
456 return POLLIN | POLLOUT | POLLERR | POLLHUP | POLLRDNORM | POLLWRNORM;
457}
458
Alan Cox04f378b2008-04-30 00:53:29 -0700459static long hung_up_tty_ioctl(struct file *file, unsigned int cmd,
460 unsigned long arg)
Paul Fulghum38ad2ed2007-06-16 10:15:55 -0700461{
462 return cmd == TIOCSPGRP ? -ENOTTY : -EIO;
463}
464
Alan Cox37bdfb02008-02-08 04:18:47 -0800465static long hung_up_tty_compat_ioctl(struct file *file,
Paul Fulghum38ad2ed2007-06-16 10:15:55 -0700466 unsigned int cmd, unsigned long arg)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700467{
468 return cmd == TIOCSPGRP ? -ENOTTY : -EIO;
469}
470
Arjan van de Ven62322d22006-07-03 00:24:21 -0700471static const struct file_operations tty_fops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700472 .llseek = no_llseek,
473 .read = tty_read,
474 .write = tty_write,
475 .poll = tty_poll,
Alan Cox04f378b2008-04-30 00:53:29 -0700476 .unlocked_ioctl = tty_ioctl,
Paul Fulghume10cc1d2007-05-10 22:22:50 -0700477 .compat_ioctl = tty_compat_ioctl,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700478 .open = tty_open,
479 .release = tty_release,
480 .fasync = tty_fasync,
481};
482
Arjan van de Ven62322d22006-07-03 00:24:21 -0700483static const struct file_operations console_fops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700484 .llseek = no_llseek,
485 .read = tty_read,
486 .write = redirected_tty_write,
487 .poll = tty_poll,
Alan Cox04f378b2008-04-30 00:53:29 -0700488 .unlocked_ioctl = tty_ioctl,
Paul Fulghume10cc1d2007-05-10 22:22:50 -0700489 .compat_ioctl = tty_compat_ioctl,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700490 .open = tty_open,
491 .release = tty_release,
492 .fasync = tty_fasync,
493};
494
Arjan van de Ven62322d22006-07-03 00:24:21 -0700495static const struct file_operations hung_up_tty_fops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700496 .llseek = no_llseek,
497 .read = hung_up_tty_read,
498 .write = hung_up_tty_write,
499 .poll = hung_up_tty_poll,
Alan Cox04f378b2008-04-30 00:53:29 -0700500 .unlocked_ioctl = hung_up_tty_ioctl,
Paul Fulghum38ad2ed2007-06-16 10:15:55 -0700501 .compat_ioctl = hung_up_tty_compat_ioctl,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700502 .release = tty_release,
503};
504
505static DEFINE_SPINLOCK(redirect_lock);
506static struct file *redirect;
507
508/**
509 * tty_wakeup - request more data
510 * @tty: terminal
511 *
512 * Internal and external helper for wakeups of tty. This function
513 * informs the line discipline if present that the driver is ready
514 * to receive more output data.
515 */
Alan Cox37bdfb02008-02-08 04:18:47 -0800516
Linus Torvalds1da177e2005-04-16 15:20:36 -0700517void tty_wakeup(struct tty_struct *tty)
518{
519 struct tty_ldisc *ld;
Alan Cox37bdfb02008-02-08 04:18:47 -0800520
Linus Torvalds1da177e2005-04-16 15:20:36 -0700521 if (test_bit(TTY_DO_WRITE_WAKEUP, &tty->flags)) {
522 ld = tty_ldisc_ref(tty);
Alan Cox37bdfb02008-02-08 04:18:47 -0800523 if (ld) {
Alan Coxa352def2008-07-16 21:53:12 +0100524 if (ld->ops->write_wakeup)
525 ld->ops->write_wakeup(tty);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700526 tty_ldisc_deref(ld);
527 }
528 }
Davide Libenzi4b194492009-03-31 15:24:24 -0700529 wake_up_interruptible_poll(&tty->write_wait, POLLOUT);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700530}
531
532EXPORT_SYMBOL_GPL(tty_wakeup);
533
534/**
Arnd Bergmann11dbf202010-06-18 14:58:07 +0200535 * __tty_hangup - actual handler for hangup events
David Howells65f27f32006-11-22 14:55:48 +0000536 * @work: tty device
Alan Coxaf9b8972006-08-27 01:24:01 -0700537 *
Alan Cox1bad8792008-07-22 23:38:04 +0100538 * This can be called by the "eventd" kernel thread. That is process
Alan Coxaf9b8972006-08-27 01:24:01 -0700539 * synchronous but doesn't hold any locks, so we need to make sure we
540 * have the appropriate locks for what we're doing.
541 *
542 * The hangup event clears any pending redirections onto the hung up
543 * device. It ensures future writes will error and it does the needed
544 * line discipline hangup and signal delivery. The tty object itself
545 * remains intact.
546 *
547 * Locking:
Arnd Bergmannec79d602010-06-01 22:53:01 +0200548 * BTM
Peter Zijlstra24ec8392006-12-08 02:36:04 -0800549 * redirect lock for undoing redirection
550 * file list lock for manipulating list of ttys
551 * tty_ldisc_lock from called functions
552 * termios_mutex resetting termios data
553 * tasklist_lock to walk task list for hangup event
554 * ->siglock to protect ->signal/->sighand
Linus Torvalds1da177e2005-04-16 15:20:36 -0700555 */
Arnd Bergmann11dbf202010-06-18 14:58:07 +0200556void __tty_hangup(struct tty_struct *tty)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700557{
Alan Cox37bdfb02008-02-08 04:18:47 -0800558 struct file *cons_filp = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700559 struct file *filp, *f = NULL;
560 struct task_struct *p;
Nick Piggind996b622010-08-18 04:37:36 +1000561 struct tty_file_private *priv;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700562 int closecount = 0, n;
Alan Cox47f86832008-04-30 00:53:30 -0700563 unsigned long flags;
Alan Cox9c9f4de2008-10-13 10:37:26 +0100564 int refs = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700565
566 if (!tty)
567 return;
568
Linus Torvalds1da177e2005-04-16 15:20:36 -0700569
570 spin_lock(&redirect_lock);
Nick Piggind996b622010-08-18 04:37:36 +1000571 if (redirect && file_tty(redirect) == tty) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700572 f = redirect;
573 redirect = NULL;
574 }
575 spin_unlock(&redirect_lock);
Alan Cox37bdfb02008-02-08 04:18:47 -0800576
Arnd Bergmann11dbf202010-06-18 14:58:07 +0200577 tty_lock();
578
Jiri Slabyacfa7472010-11-29 10:16:54 +0100579 /* some functions below drop BTM, so we need this bit */
580 set_bit(TTY_HUPPING, &tty->flags);
581
Arnd Bergmannec79d602010-06-01 22:53:01 +0200582 /* inuse_filps is protected by the single tty lock,
583 this really needs to change if we want to flush the
584 workqueue with the lock held */
Arnd Bergmann11dbf202010-06-18 14:58:07 +0200585 check_tty_count(tty, "tty_hangup");
Alan Cox36ba7822009-11-30 13:18:51 +0000586
Nick Pigginee2ffa02010-08-18 04:37:35 +1000587 spin_lock(&tty_files_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700588 /* This breaks for file handles being sent over AF_UNIX sockets ? */
Nick Piggind996b622010-08-18 04:37:36 +1000589 list_for_each_entry(priv, &tty->tty_files, list) {
590 filp = priv->file;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700591 if (filp->f_op->write == redirected_tty_write)
592 cons_filp = filp;
593 if (filp->f_op->write != tty_write)
594 continue;
595 closecount++;
Arnd Bergmannec79d602010-06-01 22:53:01 +0200596 __tty_fasync(-1, filp, 0); /* can't block */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700597 filp->f_op = &hung_up_tty_fops;
598 }
Nick Pigginee2ffa02010-08-18 04:37:35 +1000599 spin_unlock(&tty_files_lock);
Alan Cox37bdfb02008-02-08 04:18:47 -0800600
Jiri Slabyacfa7472010-11-29 10:16:54 +0100601 /*
602 * it drops BTM and thus races with reopen
603 * we protect the race by TTY_HUPPING
604 */
Alan Coxc65c9bc2009-06-11 12:50:12 +0100605 tty_ldisc_hangup(tty);
Alan Cox37bdfb02008-02-08 04:18:47 -0800606
Linus Torvalds1da177e2005-04-16 15:20:36 -0700607 read_lock(&tasklist_lock);
Eric W. Biedermanab521dc2007-02-12 00:53:00 -0800608 if (tty->session) {
609 do_each_pid_task(tty->session, PIDTYPE_SID, p) {
Peter Zijlstra24ec8392006-12-08 02:36:04 -0800610 spin_lock_irq(&p->sighand->siglock);
Alan Cox9c9f4de2008-10-13 10:37:26 +0100611 if (p->signal->tty == tty) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700612 p->signal->tty = NULL;
Alan Cox9c9f4de2008-10-13 10:37:26 +0100613 /* We defer the dereferences outside fo
614 the tasklist lock */
615 refs++;
616 }
Peter Zijlstra24ec8392006-12-08 02:36:04 -0800617 if (!p->signal->leader) {
618 spin_unlock_irq(&p->sighand->siglock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700619 continue;
Peter Zijlstra24ec8392006-12-08 02:36:04 -0800620 }
621 __group_send_sig_info(SIGHUP, SEND_SIG_PRIV, p);
622 __group_send_sig_info(SIGCONT, SEND_SIG_PRIV, p);
Eric W. Biedermanab521dc2007-02-12 00:53:00 -0800623 put_pid(p->signal->tty_old_pgrp); /* A noop */
Alan Cox47f86832008-04-30 00:53:30 -0700624 spin_lock_irqsave(&tty->ctrl_lock, flags);
Eric W. Biedermanab521dc2007-02-12 00:53:00 -0800625 if (tty->pgrp)
626 p->signal->tty_old_pgrp = get_pid(tty->pgrp);
Alan Cox47f86832008-04-30 00:53:30 -0700627 spin_unlock_irqrestore(&tty->ctrl_lock, flags);
Peter Zijlstra24ec8392006-12-08 02:36:04 -0800628 spin_unlock_irq(&p->sighand->siglock);
Eric W. Biedermanab521dc2007-02-12 00:53:00 -0800629 } while_each_pid_task(tty->session, PIDTYPE_SID, p);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700630 }
631 read_unlock(&tasklist_lock);
632
Alan Cox47f86832008-04-30 00:53:30 -0700633 spin_lock_irqsave(&tty->ctrl_lock, flags);
Alan Coxc65c9bc2009-06-11 12:50:12 +0100634 clear_bit(TTY_THROTTLED, &tty->flags);
635 clear_bit(TTY_PUSH, &tty->flags);
636 clear_bit(TTY_DO_WRITE_WAKEUP, &tty->flags);
Eric W. Biedermand9c1e9a2007-03-18 12:45:44 -0600637 put_pid(tty->session);
638 put_pid(tty->pgrp);
Eric W. Biedermanab521dc2007-02-12 00:53:00 -0800639 tty->session = NULL;
640 tty->pgrp = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700641 tty->ctrl_status = 0;
Alan Cox47f86832008-04-30 00:53:30 -0700642 spin_unlock_irqrestore(&tty->ctrl_lock, flags);
643
Alan Cox9c9f4de2008-10-13 10:37:26 +0100644 /* Account for the p->signal references we killed */
645 while (refs--)
646 tty_kref_put(tty);
647
Linus Torvalds1da177e2005-04-16 15:20:36 -0700648 /*
Alan Cox37bdfb02008-02-08 04:18:47 -0800649 * If one of the devices matches a console pointer, we
650 * cannot just call hangup() because that will cause
651 * tty->count and state->count to go out of sync.
652 * So we just call close() the right number of times.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700653 */
654 if (cons_filp) {
Alan Coxf34d7a52008-04-30 00:54:13 -0700655 if (tty->ops->close)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700656 for (n = 0; n < closecount; n++)
Alan Coxf34d7a52008-04-30 00:54:13 -0700657 tty->ops->close(tty, cons_filp);
658 } else if (tty->ops->hangup)
659 (tty->ops->hangup)(tty);
Alan Cox37bdfb02008-02-08 04:18:47 -0800660 /*
661 * We don't want to have driver/ldisc interactions beyond
662 * the ones we did here. The driver layer expects no
663 * calls after ->hangup() from the ldisc side. However we
664 * can't yet guarantee all that.
665 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700666 set_bit(TTY_HUPPED, &tty->flags);
Jiri Slabyacfa7472010-11-29 10:16:54 +0100667 clear_bit(TTY_HUPPING, &tty->flags);
Alan Coxc65c9bc2009-06-11 12:50:12 +0100668 tty_ldisc_enable(tty);
Arnd Bergmann11dbf202010-06-18 14:58:07 +0200669
670 tty_unlock();
671
Linus Torvalds1da177e2005-04-16 15:20:36 -0700672 if (f)
673 fput(f);
674}
675
Arnd Bergmannddcd9fb2010-06-01 22:53:08 +0200676static void do_tty_hangup(struct work_struct *work)
677{
678 struct tty_struct *tty =
679 container_of(work, struct tty_struct, hangup_work);
680
Arnd Bergmann11dbf202010-06-18 14:58:07 +0200681 __tty_hangup(tty);
Arnd Bergmannddcd9fb2010-06-01 22:53:08 +0200682}
683
Alan Coxaf9b8972006-08-27 01:24:01 -0700684/**
685 * tty_hangup - trigger a hangup event
686 * @tty: tty to hangup
687 *
688 * A carrier loss (virtual or otherwise) has occurred on this like
689 * schedule a hangup sequence to run after this event.
690 */
691
Alan Cox37bdfb02008-02-08 04:18:47 -0800692void tty_hangup(struct tty_struct *tty)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700693{
694#ifdef TTY_DEBUG_HANGUP
695 char buf[64];
Linus Torvalds1da177e2005-04-16 15:20:36 -0700696 printk(KERN_DEBUG "%s hangup...\n", tty_name(tty, buf));
697#endif
698 schedule_work(&tty->hangup_work);
699}
700
701EXPORT_SYMBOL(tty_hangup);
702
Alan Coxaf9b8972006-08-27 01:24:01 -0700703/**
704 * tty_vhangup - process vhangup
705 * @tty: tty to hangup
706 *
707 * The user has asked via system call for the terminal to be hung up.
708 * We do this synchronously so that when the syscall returns the process
Robert P. J. Day3a4fa0a2007-10-19 23:10:43 +0200709 * is complete. That guarantee is necessary for security reasons.
Alan Coxaf9b8972006-08-27 01:24:01 -0700710 */
711
Alan Cox37bdfb02008-02-08 04:18:47 -0800712void tty_vhangup(struct tty_struct *tty)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700713{
714#ifdef TTY_DEBUG_HANGUP
715 char buf[64];
716
717 printk(KERN_DEBUG "%s vhangup...\n", tty_name(tty, buf));
718#endif
Arnd Bergmann11dbf202010-06-18 14:58:07 +0200719 __tty_hangup(tty);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700720}
Alan Cox37bdfb02008-02-08 04:18:47 -0800721
Linus Torvalds1da177e2005-04-16 15:20:36 -0700722EXPORT_SYMBOL(tty_vhangup);
723
Arnd Bergmann11dbf202010-06-18 14:58:07 +0200724
Alan Coxaf9b8972006-08-27 01:24:01 -0700725/**
Alan Cox2cb59982008-10-13 10:40:30 +0100726 * tty_vhangup_self - process vhangup for own ctty
727 *
728 * Perform a vhangup on the current controlling tty
729 */
730
731void tty_vhangup_self(void)
732{
733 struct tty_struct *tty;
734
Alan Cox2cb59982008-10-13 10:40:30 +0100735 tty = get_current_tty();
736 if (tty) {
737 tty_vhangup(tty);
738 tty_kref_put(tty);
739 }
Alan Cox2cb59982008-10-13 10:40:30 +0100740}
741
742/**
Alan Coxaf9b8972006-08-27 01:24:01 -0700743 * tty_hung_up_p - was tty hung up
744 * @filp: file pointer of tty
745 *
746 * Return true if the tty has been subject to a vhangup or a carrier
747 * loss
748 */
749
Alan Cox37bdfb02008-02-08 04:18:47 -0800750int tty_hung_up_p(struct file *filp)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700751{
752 return (filp->f_op == &hung_up_tty_fops);
753}
754
755EXPORT_SYMBOL(tty_hung_up_p);
756
Eric W. Biedermanab521dc2007-02-12 00:53:00 -0800757static void session_clear_tty(struct pid *session)
Peter Zijlstra24ec8392006-12-08 02:36:04 -0800758{
759 struct task_struct *p;
Eric W. Biedermanab521dc2007-02-12 00:53:00 -0800760 do_each_pid_task(session, PIDTYPE_SID, p) {
Peter Zijlstra24ec8392006-12-08 02:36:04 -0800761 proc_clear_tty(p);
Eric W. Biedermanab521dc2007-02-12 00:53:00 -0800762 } while_each_pid_task(session, PIDTYPE_SID, p);
Peter Zijlstra24ec8392006-12-08 02:36:04 -0800763}
764
Alan Coxaf9b8972006-08-27 01:24:01 -0700765/**
766 * disassociate_ctty - disconnect controlling tty
767 * @on_exit: true if exiting so need to "hang up" the session
Linus Torvalds1da177e2005-04-16 15:20:36 -0700768 *
Alan Coxaf9b8972006-08-27 01:24:01 -0700769 * This function is typically called only by the session leader, when
770 * it wants to disassociate itself from its controlling tty.
771 *
772 * It performs the following functions:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700773 * (1) Sends a SIGHUP and SIGCONT to the foreground process group
774 * (2) Clears the tty from being controlling the session
775 * (3) Clears the controlling tty for all processes in the
776 * session group.
777 *
Alan Coxaf9b8972006-08-27 01:24:01 -0700778 * The argument on_exit is set to 1 if called when a process is
779 * exiting; it is 0 if called by the ioctl TIOCNOTTY.
780 *
Peter Zijlstra24ec8392006-12-08 02:36:04 -0800781 * Locking:
Arnd Bergmannec79d602010-06-01 22:53:01 +0200782 * BTM is taken for hysterical raisins, and held when
783 * called from no_tty().
Peter Zijlstra24ec8392006-12-08 02:36:04 -0800784 * tty_mutex is taken to protect tty
785 * ->siglock is taken to protect ->signal/->sighand
786 * tasklist_lock is taken to walk process list for sessions
787 * ->siglock is taken to protect ->signal/->sighand
Linus Torvalds1da177e2005-04-16 15:20:36 -0700788 */
Alan Coxaf9b8972006-08-27 01:24:01 -0700789
Linus Torvalds1da177e2005-04-16 15:20:36 -0700790void disassociate_ctty(int on_exit)
791{
792 struct tty_struct *tty;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700793
Alan Cox5ec93d12009-11-30 13:18:45 +0000794 if (!current->signal->leader)
795 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700796
Peter Zijlstra24ec8392006-12-08 02:36:04 -0800797 tty = get_current_tty();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700798 if (tty) {
Jiri Slaby1411dc42011-11-09 21:33:18 +0100799 struct pid *tty_pgrp = get_pid(tty->pgrp);
Arnd Bergmannddcd9fb2010-06-01 22:53:08 +0200800 if (on_exit) {
Arnd Bergmannddcd9fb2010-06-01 22:53:08 +0200801 if (tty->driver->type != TTY_DRIVER_TYPE_PTY)
Arnd Bergmann11dbf202010-06-18 14:58:07 +0200802 tty_vhangup(tty);
Arnd Bergmannddcd9fb2010-06-01 22:53:08 +0200803 }
Alan Cox452a00d2008-10-13 10:39:13 +0100804 tty_kref_put(tty);
Jiri Slaby1411dc42011-11-09 21:33:18 +0100805 if (tty_pgrp) {
806 kill_pgrp(tty_pgrp, SIGHUP, on_exit);
807 if (!on_exit)
808 kill_pgrp(tty_pgrp, SIGCONT, on_exit);
809 put_pid(tty_pgrp);
810 }
Eric W. Biederman680a9672007-02-12 00:52:52 -0800811 } else if (on_exit) {
Eric W. Biedermanab521dc2007-02-12 00:53:00 -0800812 struct pid *old_pgrp;
Eric W. Biederman680a9672007-02-12 00:52:52 -0800813 spin_lock_irq(&current->sighand->siglock);
814 old_pgrp = current->signal->tty_old_pgrp;
Eric W. Biedermanab521dc2007-02-12 00:53:00 -0800815 current->signal->tty_old_pgrp = NULL;
Eric W. Biederman680a9672007-02-12 00:52:52 -0800816 spin_unlock_irq(&current->sighand->siglock);
Peter Zijlstra24ec8392006-12-08 02:36:04 -0800817 if (old_pgrp) {
Eric W. Biedermanab521dc2007-02-12 00:53:00 -0800818 kill_pgrp(old_pgrp, SIGHUP, on_exit);
819 kill_pgrp(old_pgrp, SIGCONT, on_exit);
820 put_pid(old_pgrp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700821 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700822 return;
823 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700824
Peter Zijlstra24ec8392006-12-08 02:36:04 -0800825 spin_lock_irq(&current->sighand->siglock);
Eric W. Biederman2a65f1d2007-05-08 00:26:53 -0700826 put_pid(current->signal->tty_old_pgrp);
Randy Dunlap23cac8d2007-02-20 13:58:05 -0800827 current->signal->tty_old_pgrp = NULL;
Peter Zijlstra24ec8392006-12-08 02:36:04 -0800828 spin_unlock_irq(&current->sighand->siglock);
829
Peter Zijlstra24ec8392006-12-08 02:36:04 -0800830 tty = get_current_tty();
831 if (tty) {
Alan Cox47f86832008-04-30 00:53:30 -0700832 unsigned long flags;
833 spin_lock_irqsave(&tty->ctrl_lock, flags);
Eric W. Biedermanab521dc2007-02-12 00:53:00 -0800834 put_pid(tty->session);
835 put_pid(tty->pgrp);
836 tty->session = NULL;
837 tty->pgrp = NULL;
Alan Cox47f86832008-04-30 00:53:30 -0700838 spin_unlock_irqrestore(&tty->ctrl_lock, flags);
Alan Cox452a00d2008-10-13 10:39:13 +0100839 tty_kref_put(tty);
Peter Zijlstra24ec8392006-12-08 02:36:04 -0800840 } else {
841#ifdef TTY_DEBUG_HANGUP
842 printk(KERN_DEBUG "error attempted to write to tty [0x%p]"
843 " = NULL", tty);
844#endif
845 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700846
847 /* Now clear signal->tty under the lock */
848 read_lock(&tasklist_lock);
Eric W. Biedermanab521dc2007-02-12 00:53:00 -0800849 session_clear_tty(task_session(current));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700850 read_unlock(&tasklist_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700851}
852
Eric W. Biederman98a27ba2007-05-08 00:26:56 -0700853/**
854 *
855 * no_tty - Ensure the current process does not have a controlling tty
856 */
857void no_tty(void)
858{
859 struct task_struct *tsk = current;
Arnd Bergmannec79d602010-06-01 22:53:01 +0200860 tty_lock();
Alan Cox5ec93d12009-11-30 13:18:45 +0000861 disassociate_ctty(0);
Arnd Bergmannec79d602010-06-01 22:53:01 +0200862 tty_unlock();
Eric W. Biederman98a27ba2007-05-08 00:26:56 -0700863 proc_clear_tty(tsk);
864}
865
Alan Coxaf9b8972006-08-27 01:24:01 -0700866
867/**
Robert P. J. Daybeb7dd82007-05-09 07:14:03 +0200868 * stop_tty - propagate flow control
Alan Coxaf9b8972006-08-27 01:24:01 -0700869 * @tty: tty to stop
870 *
871 * Perform flow control to the driver. For PTY/TTY pairs we
Robert P. J. Daybeb7dd82007-05-09 07:14:03 +0200872 * must also propagate the TIOCKPKT status. May be called
Alan Coxaf9b8972006-08-27 01:24:01 -0700873 * on an already stopped device and will not re-call the driver
874 * method.
875 *
876 * This functionality is used by both the line disciplines for
877 * halting incoming flow and by the driver. It may therefore be
878 * called from any context, may be under the tty atomic_write_lock
879 * but not always.
880 *
881 * Locking:
Alan Cox04f378b2008-04-30 00:53:29 -0700882 * Uses the tty control lock internally
Alan Coxaf9b8972006-08-27 01:24:01 -0700883 */
884
Linus Torvalds1da177e2005-04-16 15:20:36 -0700885void stop_tty(struct tty_struct *tty)
886{
Alan Cox04f378b2008-04-30 00:53:29 -0700887 unsigned long flags;
888 spin_lock_irqsave(&tty->ctrl_lock, flags);
889 if (tty->stopped) {
890 spin_unlock_irqrestore(&tty->ctrl_lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700891 return;
Alan Cox04f378b2008-04-30 00:53:29 -0700892 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700893 tty->stopped = 1;
894 if (tty->link && tty->link->packet) {
895 tty->ctrl_status &= ~TIOCPKT_START;
896 tty->ctrl_status |= TIOCPKT_STOP;
Davide Libenzi4b194492009-03-31 15:24:24 -0700897 wake_up_interruptible_poll(&tty->link->read_wait, POLLIN);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700898 }
Alan Cox04f378b2008-04-30 00:53:29 -0700899 spin_unlock_irqrestore(&tty->ctrl_lock, flags);
Alan Coxf34d7a52008-04-30 00:54:13 -0700900 if (tty->ops->stop)
901 (tty->ops->stop)(tty);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700902}
903
904EXPORT_SYMBOL(stop_tty);
905
Alan Coxaf9b8972006-08-27 01:24:01 -0700906/**
Robert P. J. Daybeb7dd82007-05-09 07:14:03 +0200907 * start_tty - propagate flow control
Alan Coxaf9b8972006-08-27 01:24:01 -0700908 * @tty: tty to start
909 *
910 * Start a tty that has been stopped if at all possible. Perform
Robert P. J. Day3a4fa0a2007-10-19 23:10:43 +0200911 * any necessary wakeups and propagate the TIOCPKT status. If this
Alan Coxaf9b8972006-08-27 01:24:01 -0700912 * is the tty was previous stopped and is being started then the
913 * driver start method is invoked and the line discipline woken.
914 *
915 * Locking:
Alan Cox04f378b2008-04-30 00:53:29 -0700916 * ctrl_lock
Alan Coxaf9b8972006-08-27 01:24:01 -0700917 */
918
Linus Torvalds1da177e2005-04-16 15:20:36 -0700919void start_tty(struct tty_struct *tty)
920{
Alan Cox04f378b2008-04-30 00:53:29 -0700921 unsigned long flags;
922 spin_lock_irqsave(&tty->ctrl_lock, flags);
923 if (!tty->stopped || tty->flow_stopped) {
924 spin_unlock_irqrestore(&tty->ctrl_lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700925 return;
Alan Cox04f378b2008-04-30 00:53:29 -0700926 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700927 tty->stopped = 0;
928 if (tty->link && tty->link->packet) {
929 tty->ctrl_status &= ~TIOCPKT_STOP;
930 tty->ctrl_status |= TIOCPKT_START;
Davide Libenzi4b194492009-03-31 15:24:24 -0700931 wake_up_interruptible_poll(&tty->link->read_wait, POLLIN);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700932 }
Alan Cox04f378b2008-04-30 00:53:29 -0700933 spin_unlock_irqrestore(&tty->ctrl_lock, flags);
Alan Coxf34d7a52008-04-30 00:54:13 -0700934 if (tty->ops->start)
935 (tty->ops->start)(tty);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700936 /* If we have a running line discipline it may need kicking */
937 tty_wakeup(tty);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700938}
939
940EXPORT_SYMBOL(start_tty);
941
Alan Coxaf9b8972006-08-27 01:24:01 -0700942/**
943 * tty_read - read method for tty device files
944 * @file: pointer to tty file
945 * @buf: user buffer
946 * @count: size of user buffer
947 * @ppos: unused
948 *
949 * Perform the read system call function on this terminal device. Checks
950 * for hung up devices before calling the line discipline method.
951 *
952 * Locking:
Alan Cox47f86832008-04-30 00:53:30 -0700953 * Locks the line discipline internally while needed. Multiple
954 * read calls may be outstanding in parallel.
Alan Coxaf9b8972006-08-27 01:24:01 -0700955 */
956
Alan Cox37bdfb02008-02-08 04:18:47 -0800957static ssize_t tty_read(struct file *file, char __user *buf, size_t count,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700958 loff_t *ppos)
959{
960 int i;
Nick Piggind996b622010-08-18 04:37:36 +1000961 struct inode *inode = file->f_path.dentry->d_inode;
962 struct tty_struct *tty = file_tty(file);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700963 struct tty_ldisc *ld;
964
Linus Torvalds1da177e2005-04-16 15:20:36 -0700965 if (tty_paranoia_check(tty, inode, "tty_read"))
966 return -EIO;
967 if (!tty || (test_bit(TTY_IO_ERROR, &tty->flags)))
968 return -EIO;
969
970 /* We want to wait for the line discipline to sort out in this
971 situation */
972 ld = tty_ldisc_ref_wait(tty);
Alan Coxa352def2008-07-16 21:53:12 +0100973 if (ld->ops->read)
974 i = (ld->ops->read)(tty, file, buf, count);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700975 else
976 i = -EIO;
977 tty_ldisc_deref(ld);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700978 if (i > 0)
979 inode->i_atime = current_fs_time(inode->i_sb);
980 return i;
981}
982
Alan Cox9c1729d2007-07-15 23:39:43 -0700983void tty_write_unlock(struct tty_struct *tty)
Jiri Slaby83c67572011-04-20 10:43:18 +0200984 __releases(&tty->atomic_write_lock)
Alan Cox9c1729d2007-07-15 23:39:43 -0700985{
986 mutex_unlock(&tty->atomic_write_lock);
Davide Libenzi4b194492009-03-31 15:24:24 -0700987 wake_up_interruptible_poll(&tty->write_wait, POLLOUT);
Alan Cox9c1729d2007-07-15 23:39:43 -0700988}
989
990int tty_write_lock(struct tty_struct *tty, int ndelay)
Jiri Slaby83c67572011-04-20 10:43:18 +0200991 __acquires(&tty->atomic_write_lock)
Alan Cox9c1729d2007-07-15 23:39:43 -0700992{
993 if (!mutex_trylock(&tty->atomic_write_lock)) {
994 if (ndelay)
995 return -EAGAIN;
996 if (mutex_lock_interruptible(&tty->atomic_write_lock))
997 return -ERESTARTSYS;
998 }
999 return 0;
1000}
1001
Linus Torvalds1da177e2005-04-16 15:20:36 -07001002/*
1003 * Split writes up in sane blocksizes to avoid
1004 * denial-of-service type attacks
1005 */
1006static inline ssize_t do_tty_write(
1007 ssize_t (*write)(struct tty_struct *, struct file *, const unsigned char *, size_t),
1008 struct tty_struct *tty,
1009 struct file *file,
1010 const char __user *buf,
1011 size_t count)
1012{
Alan Cox9c1729d2007-07-15 23:39:43 -07001013 ssize_t ret, written = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001014 unsigned int chunk;
Alan Cox37bdfb02008-02-08 04:18:47 -08001015
Alan Cox9c1729d2007-07-15 23:39:43 -07001016 ret = tty_write_lock(tty, file->f_flags & O_NDELAY);
1017 if (ret < 0)
1018 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001019
1020 /*
1021 * We chunk up writes into a temporary buffer. This
1022 * simplifies low-level drivers immensely, since they
1023 * don't have locking issues and user mode accesses.
1024 *
1025 * But if TTY_NO_WRITE_SPLIT is set, we should use a
1026 * big chunk-size..
1027 *
1028 * The default chunk-size is 2kB, because the NTTY
1029 * layer has problems with bigger chunks. It will
1030 * claim to be able to handle more characters than
1031 * it actually does.
Alan Coxaf9b8972006-08-27 01:24:01 -07001032 *
1033 * FIXME: This can probably go away now except that 64K chunks
1034 * are too likely to fail unless switched to vmalloc...
Linus Torvalds1da177e2005-04-16 15:20:36 -07001035 */
1036 chunk = 2048;
1037 if (test_bit(TTY_NO_WRITE_SPLIT, &tty->flags))
1038 chunk = 65536;
1039 if (count < chunk)
1040 chunk = count;
1041
Ingo Molnar70522e12006-03-23 03:00:31 -08001042 /* write_buf/write_cnt is protected by the atomic_write_lock mutex */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001043 if (tty->write_cnt < chunk) {
Jason Wessel402fda92008-10-13 10:45:36 +01001044 unsigned char *buf_chunk;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001045
1046 if (chunk < 1024)
1047 chunk = 1024;
1048
Jason Wessel402fda92008-10-13 10:45:36 +01001049 buf_chunk = kmalloc(chunk, GFP_KERNEL);
1050 if (!buf_chunk) {
Alan Cox9c1729d2007-07-15 23:39:43 -07001051 ret = -ENOMEM;
1052 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001053 }
1054 kfree(tty->write_buf);
1055 tty->write_cnt = chunk;
Jason Wessel402fda92008-10-13 10:45:36 +01001056 tty->write_buf = buf_chunk;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001057 }
1058
1059 /* Do the write .. */
1060 for (;;) {
1061 size_t size = count;
1062 if (size > chunk)
1063 size = chunk;
1064 ret = -EFAULT;
1065 if (copy_from_user(tty->write_buf, buf, size))
1066 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001067 ret = write(tty, file, tty->write_buf, size);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001068 if (ret <= 0)
1069 break;
1070 written += ret;
1071 buf += ret;
1072 count -= ret;
1073 if (!count)
1074 break;
1075 ret = -ERESTARTSYS;
1076 if (signal_pending(current))
1077 break;
1078 cond_resched();
1079 }
1080 if (written) {
Josef Sipeka7113a92006-12-08 02:36:55 -08001081 struct inode *inode = file->f_path.dentry->d_inode;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001082 inode->i_mtime = current_fs_time(inode->i_sb);
1083 ret = written;
1084 }
Alan Cox9c1729d2007-07-15 23:39:43 -07001085out:
1086 tty_write_unlock(tty);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001087 return ret;
1088}
1089
Alan Cox95f9bfc2008-10-13 10:39:23 +01001090/**
1091 * tty_write_message - write a message to a certain tty, not just the console.
1092 * @tty: the destination tty_struct
1093 * @msg: the message to write
1094 *
1095 * This is used for messages that need to be redirected to a specific tty.
1096 * We don't put it into the syslog queue right now maybe in the future if
1097 * really needed.
1098 *
Arnd Bergmannec79d602010-06-01 22:53:01 +02001099 * We must still hold the BTM and test the CLOSING flag for the moment.
Alan Cox95f9bfc2008-10-13 10:39:23 +01001100 */
1101
1102void tty_write_message(struct tty_struct *tty, char *msg)
1103{
Alan Cox95f9bfc2008-10-13 10:39:23 +01001104 if (tty) {
1105 mutex_lock(&tty->atomic_write_lock);
Arnd Bergmannec79d602010-06-01 22:53:01 +02001106 tty_lock();
Alan Coxeeb89d92009-11-30 13:18:29 +00001107 if (tty->ops->write && !test_bit(TTY_CLOSING, &tty->flags)) {
Arnd Bergmannec79d602010-06-01 22:53:01 +02001108 tty_unlock();
Alan Cox95f9bfc2008-10-13 10:39:23 +01001109 tty->ops->write(tty, msg, strlen(msg));
Alan Coxeeb89d92009-11-30 13:18:29 +00001110 } else
Arnd Bergmannec79d602010-06-01 22:53:01 +02001111 tty_unlock();
Alan Cox95f9bfc2008-10-13 10:39:23 +01001112 tty_write_unlock(tty);
1113 }
Alan Cox95f9bfc2008-10-13 10:39:23 +01001114 return;
1115}
1116
Linus Torvalds1da177e2005-04-16 15:20:36 -07001117
Alan Coxaf9b8972006-08-27 01:24:01 -07001118/**
1119 * tty_write - write method for tty device file
1120 * @file: tty file pointer
1121 * @buf: user data to write
1122 * @count: bytes to write
1123 * @ppos: unused
1124 *
1125 * Write data to a tty device via the line discipline.
1126 *
1127 * Locking:
1128 * Locks the line discipline as required
1129 * Writes to the tty driver are serialized by the atomic_write_lock
1130 * and are then processed in chunks to the device. The line discipline
Joe Petersona88a69c2009-01-02 13:40:53 +00001131 * write method will not be invoked in parallel for each device.
Alan Coxaf9b8972006-08-27 01:24:01 -07001132 */
1133
Alan Cox37bdfb02008-02-08 04:18:47 -08001134static ssize_t tty_write(struct file *file, const char __user *buf,
1135 size_t count, loff_t *ppos)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001136{
Josef Sipeka7113a92006-12-08 02:36:55 -08001137 struct inode *inode = file->f_path.dentry->d_inode;
Nick Piggind996b622010-08-18 04:37:36 +10001138 struct tty_struct *tty = file_tty(file);
1139 struct tty_ldisc *ld;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001140 ssize_t ret;
Alan Cox37bdfb02008-02-08 04:18:47 -08001141
Linus Torvalds1da177e2005-04-16 15:20:36 -07001142 if (tty_paranoia_check(tty, inode, "tty_write"))
1143 return -EIO;
Alan Coxf34d7a52008-04-30 00:54:13 -07001144 if (!tty || !tty->ops->write ||
Alan Cox37bdfb02008-02-08 04:18:47 -08001145 (test_bit(TTY_IO_ERROR, &tty->flags)))
1146 return -EIO;
Alan Coxf34d7a52008-04-30 00:54:13 -07001147 /* Short term debug to catch buggy drivers */
1148 if (tty->ops->write_room == NULL)
1149 printk(KERN_ERR "tty driver %s lacks a write_room method.\n",
1150 tty->driver->name);
Alan Cox37bdfb02008-02-08 04:18:47 -08001151 ld = tty_ldisc_ref_wait(tty);
Alan Coxa352def2008-07-16 21:53:12 +01001152 if (!ld->ops->write)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001153 ret = -EIO;
1154 else
Alan Coxa352def2008-07-16 21:53:12 +01001155 ret = do_tty_write(ld->ops->write, tty, file, buf, count);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001156 tty_ldisc_deref(ld);
1157 return ret;
1158}
1159
Alan Cox37bdfb02008-02-08 04:18:47 -08001160ssize_t redirected_tty_write(struct file *file, const char __user *buf,
1161 size_t count, loff_t *ppos)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001162{
1163 struct file *p = NULL;
1164
1165 spin_lock(&redirect_lock);
1166 if (redirect) {
1167 get_file(redirect);
1168 p = redirect;
1169 }
1170 spin_unlock(&redirect_lock);
1171
1172 if (p) {
1173 ssize_t res;
1174 res = vfs_write(p, buf, count, &p->f_pos);
1175 fput(p);
1176 return res;
1177 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001178 return tty_write(file, buf, count, ppos);
1179}
1180
1181static char ptychar[] = "pqrstuvwxyzabcde";
1182
Alan Coxaf9b8972006-08-27 01:24:01 -07001183/**
1184 * pty_line_name - generate name for a pty
1185 * @driver: the tty driver in use
1186 * @index: the minor number
1187 * @p: output buffer of at least 6 bytes
1188 *
1189 * Generate a name from a driver reference and write it to the output
1190 * buffer.
1191 *
1192 * Locking: None
1193 */
1194static void pty_line_name(struct tty_driver *driver, int index, char *p)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001195{
1196 int i = index + driver->name_base;
1197 /* ->name is initialized to "ttyp", but "tty" is expected */
1198 sprintf(p, "%s%c%x",
Alan Cox37bdfb02008-02-08 04:18:47 -08001199 driver->subtype == PTY_TYPE_SLAVE ? "tty" : driver->name,
1200 ptychar[i >> 4 & 0xf], i & 0xf);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001201}
1202
Alan Coxaf9b8972006-08-27 01:24:01 -07001203/**
Alan Cox8b0a88d2008-10-13 10:42:19 +01001204 * tty_line_name - generate name for a tty
Alan Coxaf9b8972006-08-27 01:24:01 -07001205 * @driver: the tty driver in use
1206 * @index: the minor number
1207 * @p: output buffer of at least 7 bytes
1208 *
1209 * Generate a name from a driver reference and write it to the output
1210 * buffer.
1211 *
1212 * Locking: None
1213 */
1214static void tty_line_name(struct tty_driver *driver, int index, char *p)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001215{
1216 sprintf(p, "%s%d", driver->name, index + driver->name_base);
1217}
1218
Alan Cox99f1fe12008-10-13 10:42:00 +01001219/**
1220 * tty_driver_lookup_tty() - find an existing tty, if any
1221 * @driver: the driver for the tty
1222 * @idx: the minor number
Sukadev Bhattiprolu23499702008-10-13 10:41:51 +01001223 *
Alan Cox99f1fe12008-10-13 10:42:00 +01001224 * Return the tty, if found or ERR_PTR() otherwise.
Sukadev Bhattiprolu23499702008-10-13 10:41:51 +01001225 *
Alan Cox99f1fe12008-10-13 10:42:00 +01001226 * Locking: tty_mutex must be held. If tty is found, the mutex must
1227 * be held until the 'fast-open' is also done. Will change once we
1228 * have refcounting in the driver and per driver locking
Sukadev Bhattiprolu23499702008-10-13 10:41:51 +01001229 */
Jason Wessela47d5452009-01-02 13:43:04 +00001230static struct tty_struct *tty_driver_lookup_tty(struct tty_driver *driver,
Sukadev Bhattiprolu15f1a632008-10-13 10:42:59 +01001231 struct inode *inode, int idx)
Sukadev Bhattiprolu23499702008-10-13 10:41:51 +01001232{
1233 struct tty_struct *tty;
1234
Alan Cox99f1fe12008-10-13 10:42:00 +01001235 if (driver->ops->lookup)
Sukadev Bhattiprolu15f1a632008-10-13 10:42:59 +01001236 return driver->ops->lookup(driver, inode, idx);
Sukadev Bhattiprolu23499702008-10-13 10:41:51 +01001237
Alan Cox8b0a88d2008-10-13 10:42:19 +01001238 tty = driver->ttys[idx];
Sukadev Bhattiprolu23499702008-10-13 10:41:51 +01001239 return tty;
1240}
1241
Alan Cox99f1fe12008-10-13 10:42:00 +01001242/**
Alan Coxbf970ee2008-10-13 10:42:39 +01001243 * tty_init_termios - helper for termios setup
1244 * @tty: the tty to set up
1245 *
1246 * Initialise the termios structures for this tty. Thus runs under
1247 * the tty_mutex currently so we can be relaxed about ordering.
1248 */
1249
1250int tty_init_termios(struct tty_struct *tty)
1251{
Alan Coxfe6e29f2008-10-13 10:44:08 +01001252 struct ktermios *tp;
Alan Coxbf970ee2008-10-13 10:42:39 +01001253 int idx = tty->index;
1254
1255 tp = tty->driver->termios[idx];
Alan Coxbf970ee2008-10-13 10:42:39 +01001256 if (tp == NULL) {
Alan Coxfe6e29f2008-10-13 10:44:08 +01001257 tp = kzalloc(sizeof(struct ktermios[2]), GFP_KERNEL);
1258 if (tp == NULL)
Alan Coxbf970ee2008-10-13 10:42:39 +01001259 return -ENOMEM;
Alan Coxbf970ee2008-10-13 10:42:39 +01001260 memcpy(tp, &tty->driver->init_termios,
1261 sizeof(struct ktermios));
1262 tty->driver->termios[idx] = tp;
Alan Coxbf970ee2008-10-13 10:42:39 +01001263 }
1264 tty->termios = tp;
Alan Coxfe6e29f2008-10-13 10:44:08 +01001265 tty->termios_locked = tp + 1;
Alan Coxbf970ee2008-10-13 10:42:39 +01001266
1267 /* Compatibility until drivers always set this */
1268 tty->termios->c_ispeed = tty_termios_input_baud_rate(tty->termios);
1269 tty->termios->c_ospeed = tty_termios_baud_rate(tty->termios);
1270 return 0;
1271}
Alan Coxfe1ae7f2009-09-19 13:13:33 -07001272EXPORT_SYMBOL_GPL(tty_init_termios);
Alan Coxbf970ee2008-10-13 10:42:39 +01001273
1274/**
Alan Cox8b0a88d2008-10-13 10:42:19 +01001275 * tty_driver_install_tty() - install a tty entry in the driver
1276 * @driver: the driver for the tty
1277 * @tty: the tty
1278 *
1279 * Install a tty object into the driver tables. The tty->index field
Alan Coxbf970ee2008-10-13 10:42:39 +01001280 * will be set by the time this is called. This method is responsible
1281 * for ensuring any need additional structures are allocated and
1282 * configured.
Alan Cox8b0a88d2008-10-13 10:42:19 +01001283 *
1284 * Locking: tty_mutex for now
1285 */
1286static int tty_driver_install_tty(struct tty_driver *driver,
1287 struct tty_struct *tty)
1288{
Alan Coxbf970ee2008-10-13 10:42:39 +01001289 int idx = tty->index;
Alan Coxeeb89d92009-11-30 13:18:29 +00001290 int ret;
Alan Coxbf970ee2008-10-13 10:42:39 +01001291
Alan Coxeeb89d92009-11-30 13:18:29 +00001292 if (driver->ops->install) {
Alan Coxeeb89d92009-11-30 13:18:29 +00001293 ret = driver->ops->install(driver, tty);
Alan Coxeeb89d92009-11-30 13:18:29 +00001294 return ret;
1295 }
Alan Coxbf970ee2008-10-13 10:42:39 +01001296
1297 if (tty_init_termios(tty) == 0) {
1298 tty_driver_kref_get(driver);
1299 tty->count++;
1300 driver->ttys[idx] = tty;
1301 return 0;
1302 }
1303 return -ENOMEM;
Alan Cox8b0a88d2008-10-13 10:42:19 +01001304}
1305
1306/**
1307 * tty_driver_remove_tty() - remove a tty from the driver tables
1308 * @driver: the driver for the tty
1309 * @idx: the minor number
1310 *
1311 * Remvoe a tty object from the driver tables. The tty->index field
1312 * will be set by the time this is called.
1313 *
1314 * Locking: tty_mutex for now
1315 */
Jiri Slaby24d406a2011-08-10 14:59:28 +02001316void tty_driver_remove_tty(struct tty_driver *driver, struct tty_struct *tty)
Alan Cox8b0a88d2008-10-13 10:42:19 +01001317{
1318 if (driver->ops->remove)
1319 driver->ops->remove(driver, tty);
1320 else
1321 driver->ttys[tty->index] = NULL;
1322}
1323
1324/*
1325 * tty_reopen() - fast re-open of an open tty
1326 * @tty - the tty to open
Sukadev Bhattiprolu23499702008-10-13 10:41:51 +01001327 *
Alan Cox99f1fe12008-10-13 10:42:00 +01001328 * Return 0 on success, -errno on error.
Sukadev Bhattiprolu23499702008-10-13 10:41:51 +01001329 *
Alan Cox99f1fe12008-10-13 10:42:00 +01001330 * Locking: tty_mutex must be held from the time the tty was found
1331 * till this open completes.
Sukadev Bhattiprolu23499702008-10-13 10:41:51 +01001332 */
Alan Cox99f1fe12008-10-13 10:42:00 +01001333static int tty_reopen(struct tty_struct *tty)
Sukadev Bhattiprolu23499702008-10-13 10:41:51 +01001334{
1335 struct tty_driver *driver = tty->driver;
1336
Jiri Slabye2efafb2010-11-29 10:16:53 +01001337 if (test_bit(TTY_CLOSING, &tty->flags) ||
Jiri Slabyacfa7472010-11-29 10:16:54 +01001338 test_bit(TTY_HUPPING, &tty->flags) ||
Jiri Slabye2efafb2010-11-29 10:16:53 +01001339 test_bit(TTY_LDISC_CHANGING, &tty->flags))
Sukadev Bhattiprolu23499702008-10-13 10:41:51 +01001340 return -EIO;
1341
1342 if (driver->type == TTY_DRIVER_TYPE_PTY &&
1343 driver->subtype == PTY_TYPE_MASTER) {
1344 /*
1345 * special case for PTY masters: only one open permitted,
1346 * and the slave side open count is incremented as well.
1347 */
1348 if (tty->count)
1349 return -EIO;
1350
1351 tty->link->count++;
1352 }
1353 tty->count++;
1354 tty->driver = driver; /* N.B. why do this every time?? */
1355
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
1368 * @first_ok: ok to open a new device (used by ptmx)
Alan Coxaf9b8972006-08-27 01:24:01 -07001369 *
1370 * Prepare a tty device. This may not be a "new" clean device but
1371 * could also be an active device. The pty drivers require special
1372 * handling because of this.
1373 *
1374 * Locking:
1375 * The function is called under the tty_mutex, which
1376 * protects us from the tty struct or driver itself going away.
1377 *
1378 * On exit the tty device has the line discipline attached and
1379 * a reference count of 1. If a pair was created for pty/tty use
1380 * and the other was a pty master then it too has a reference count of 1.
1381 *
Linus Torvalds1da177e2005-04-16 15:20:36 -07001382 * WSH 06/09/97: Rewritten to remove races and properly clean up after a
Ingo Molnar70522e12006-03-23 03:00:31 -08001383 * failed open. The new code protects the open with a mutex, so it's
1384 * really quite straightforward. The mutex locking can probably be
Linus Torvalds1da177e2005-04-16 15:20:36 -07001385 * relaxed for the (most common) case of reopening a tty.
1386 */
Alan Coxaf9b8972006-08-27 01:24:01 -07001387
Alan Cox73ec06f2008-10-13 10:42:29 +01001388struct tty_struct *tty_init_dev(struct tty_driver *driver, int idx,
1389 int first_ok)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001390{
Alan Coxbf970ee2008-10-13 10:42:39 +01001391 struct tty_struct *tty;
Alan Cox73ec06f2008-10-13 10:42:29 +01001392 int retval;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001393
Sukadev Bhattiprolu23499702008-10-13 10:41:51 +01001394 /* Check if pty master is being opened multiple times */
Alan Cox15582d32008-10-13 10:41:03 +01001395 if (driver->subtype == PTY_TYPE_MASTER &&
Alan Coxeeb89d92009-11-30 13:18:29 +00001396 (driver->flags & TTY_DRIVER_DEVPTS_MEM) && !first_ok) {
Alan Cox73ec06f2008-10-13 10:42:29 +01001397 return ERR_PTR(-EIO);
Alan Coxeeb89d92009-11-30 13:18:29 +00001398 }
Alan Cox73ec06f2008-10-13 10:42:29 +01001399
Linus Torvalds1da177e2005-04-16 15:20:36 -07001400 /*
1401 * First time open is complex, especially for PTY devices.
1402 * This code guarantees that either everything succeeds and the
1403 * TTY is ready for operation, or else the table slots are vacated
Alan Cox37bdfb02008-02-08 04:18:47 -08001404 * and the allocated memory released. (Except that the termios
Linus Torvalds1da177e2005-04-16 15:20:36 -07001405 * and locked termios may be retained.)
1406 */
1407
Alan Cox73ec06f2008-10-13 10:42:29 +01001408 if (!try_module_get(driver->owner))
1409 return ERR_PTR(-ENODEV);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001410
Linus Torvalds1da177e2005-04-16 15:20:36 -07001411 tty = alloc_tty_struct();
Jiri Slabyd5543502011-03-23 10:48:32 +01001412 if (!tty) {
1413 retval = -ENOMEM;
1414 goto err_module_put;
1415 }
Alan Coxbf970ee2008-10-13 10:42:39 +01001416 initialize_tty_struct(tty, driver, idx);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001417
Alan Cox73ec06f2008-10-13 10:42:29 +01001418 retval = tty_driver_install_tty(driver, tty);
Jiri Slabyd5543502011-03-23 10:48:32 +01001419 if (retval < 0)
Jiri Slabya9dccdd2011-03-23 10:48:36 +01001420 goto err_deinit_tty;
Alan Cox8b0a88d2008-10-13 10:42:19 +01001421
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 Cox73ec06f2008-10-13 10:42:29 +01001430 return tty;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001431
Jiri Slabya9dccdd2011-03-23 10:48:36 +01001432err_deinit_tty:
1433 deinitialize_tty_struct(tty);
Jiri Slabyd5543502011-03-23 10:48:32 +01001434 free_tty_struct(tty);
1435err_module_put:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001436 module_put(driver->owner);
Jiri Slabyd5543502011-03-23 10:48:32 +01001437 return ERR_PTR(retval);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001438
Christoph Hellwigd5698c22007-02-10 01:46:46 -08001439 /* call the tty release_tty routine to clean out this slot */
Jiri Slabyd5543502011-03-23 10:48:32 +01001440err_release_tty:
Manuel Zerpies5a3c6b22011-06-16 14:07:22 +02001441 printk_ratelimited(KERN_INFO "tty_init_dev: ldisc open failed, "
Akinobu Mita40509142006-09-29 02:01:27 -07001442 "clearing slot %d\n", idx);
Christoph Hellwigd5698c22007-02-10 01:46:46 -08001443 release_tty(tty, idx);
Alan Cox73ec06f2008-10-13 10:42:29 +01001444 return ERR_PTR(retval);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001445}
1446
Alan Coxfeebed62008-10-13 10:41:30 +01001447void tty_free_termios(struct tty_struct *tty)
1448{
1449 struct ktermios *tp;
1450 int idx = tty->index;
1451 /* Kill this flag and push into drivers for locking etc */
1452 if (tty->driver->flags & TTY_DRIVER_RESET_TERMIOS) {
1453 /* FIXME: Locking on ->termios array */
1454 tp = tty->termios;
1455 tty->driver->termios[idx] = NULL;
1456 kfree(tp);
Alan Coxfeebed62008-10-13 10:41:30 +01001457 }
1458}
1459EXPORT_SYMBOL(tty_free_termios);
1460
1461void tty_shutdown(struct tty_struct *tty)
1462{
Alan Cox8b0a88d2008-10-13 10:42:19 +01001463 tty_driver_remove_tty(tty->driver, tty);
Alan Coxfeebed62008-10-13 10:41:30 +01001464 tty_free_termios(tty);
1465}
1466EXPORT_SYMBOL(tty_shutdown);
1467
Alan Coxaf9b8972006-08-27 01:24:01 -07001468/**
Christoph Hellwigd5698c22007-02-10 01:46:46 -08001469 * release_one_tty - release tty structure memory
Alan Cox9c9f4de2008-10-13 10:37:26 +01001470 * @kref: kref of tty we are obliterating
Alan Coxaf9b8972006-08-27 01:24:01 -07001471 *
1472 * Releases memory associated with a tty structure, and clears out the
1473 * driver table slots. This function is called when a device is no longer
1474 * in use. It also gets called when setup of a device fails.
1475 *
1476 * Locking:
1477 * tty_mutex - sometimes only
1478 * takes the file list lock internally when working on the list
1479 * of ttys that the driver keeps.
Alan Coxb50989d2009-09-19 13:13:22 -07001480 *
1481 * This method gets called from a work queue so that the driver private
Dave Youngf278a2f2009-09-27 16:00:42 +00001482 * cleanup ops can sleep (needed for USB at least)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001483 */
Alan Coxb50989d2009-09-19 13:13:22 -07001484static void release_one_tty(struct work_struct *work)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001485{
Alan Coxb50989d2009-09-19 13:13:22 -07001486 struct tty_struct *tty =
1487 container_of(work, struct tty_struct, hangup_work);
Alan Cox6f967f72008-10-13 10:37:36 +01001488 struct tty_driver *driver = tty->driver;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001489
Dave Youngf278a2f2009-09-27 16:00:42 +00001490 if (tty->ops->cleanup)
1491 tty->ops->cleanup(tty);
1492
Linus Torvalds1da177e2005-04-16 15:20:36 -07001493 tty->magic = 0;
Alan Cox7d7b93c2008-10-13 10:42:09 +01001494 tty_driver_kref_put(driver);
Alan Cox6f967f72008-10-13 10:37:36 +01001495 module_put(driver->owner);
Christoph Hellwigd5698c22007-02-10 01:46:46 -08001496
Nick Pigginee2ffa02010-08-18 04:37:35 +10001497 spin_lock(&tty_files_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001498 list_del_init(&tty->tty_files);
Nick Pigginee2ffa02010-08-18 04:37:35 +10001499 spin_unlock(&tty_files_lock);
Christoph Hellwigd5698c22007-02-10 01:46:46 -08001500
Oleg Nesterov6da8d862010-04-02 18:05:12 +02001501 put_pid(tty->pgrp);
1502 put_pid(tty->session);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001503 free_tty_struct(tty);
1504}
1505
Alan Coxb50989d2009-09-19 13:13:22 -07001506static void queue_release_one_tty(struct kref *kref)
1507{
1508 struct tty_struct *tty = container_of(kref, struct tty_struct, kref);
Dave Youngf278a2f2009-09-27 16:00:42 +00001509
1510 if (tty->ops->shutdown)
1511 tty->ops->shutdown(tty);
1512 else
1513 tty_shutdown(tty);
1514
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:
1543 * tty_mutex - sometimes only
1544 * takes the file list lock internally when working on the list
1545 * of ttys that the driver keeps.
1546 * FIXME: should we require tty_mutex is held here ??
Alan Cox9c9f4de2008-10-13 10:37:26 +01001547 *
Christoph Hellwigd5698c22007-02-10 01:46:46 -08001548 */
1549static void release_tty(struct tty_struct *tty, int idx)
1550{
Alan Cox9c9f4de2008-10-13 10:37:26 +01001551 /* This should always be true but check for the moment */
1552 WARN_ON(tty->index != idx);
1553
Christoph Hellwigd5698c22007-02-10 01:46:46 -08001554 if (tty->link)
Alan Cox9c9f4de2008-10-13 10:37:26 +01001555 tty_kref_put(tty->link);
1556 tty_kref_put(tty);
Christoph Hellwigd5698c22007-02-10 01:46:46 -08001557}
1558
Alan Coxeeb89d92009-11-30 13:18:29 +00001559/**
Jiri Slaby955787c2011-11-11 10:47:23 +01001560 * tty_release_checks - check a tty before real release
1561 * @tty: tty to check
1562 * @o_tty: link of @tty (if any)
1563 * @idx: index of the tty
1564 *
1565 * Performs some paranoid checking before true release of the @tty.
1566 * This is a no-op unless TTY_PARANOIA_CHECK is defined.
1567 */
1568static int tty_release_checks(struct tty_struct *tty, struct tty_struct *o_tty,
1569 int idx)
1570{
1571#ifdef TTY_PARANOIA_CHECK
1572 if (idx < 0 || idx >= tty->driver->num) {
Jiri Slaby9de44bd2011-11-09 21:33:24 +01001573 printk(KERN_DEBUG "%s: bad idx when trying to free (%s)\n",
1574 __func__, tty->name);
Jiri Slaby955787c2011-11-11 10:47:23 +01001575 return -1;
1576 }
1577
1578 /* not much to check for devpts */
1579 if (tty->driver->flags & TTY_DRIVER_DEVPTS_MEM)
1580 return 0;
1581
1582 if (tty != tty->driver->ttys[idx]) {
Jiri Slaby9de44bd2011-11-09 21:33:24 +01001583 printk(KERN_DEBUG "%s: driver.table[%d] not tty for (%s)\n",
1584 __func__, idx, tty->name);
Jiri Slaby955787c2011-11-11 10:47:23 +01001585 return -1;
1586 }
1587 if (tty->termios != tty->driver->termios[idx]) {
Jiri Slaby9de44bd2011-11-09 21:33:24 +01001588 printk(KERN_DEBUG "%s: driver.termios[%d] not termios for (%s)\n",
1589 __func__, idx, tty->name);
Jiri Slaby955787c2011-11-11 10:47:23 +01001590 return -1;
1591 }
1592 if (tty->driver->other) {
1593 if (o_tty != tty->driver->other->ttys[idx]) {
Jiri Slaby9de44bd2011-11-09 21:33:24 +01001594 printk(KERN_DEBUG "%s: other->table[%d] not o_tty for (%s)\n",
1595 __func__, idx, tty->name);
Jiri Slaby955787c2011-11-11 10:47:23 +01001596 return -1;
1597 }
1598 if (o_tty->termios != tty->driver->other->termios[idx]) {
Jiri Slaby9de44bd2011-11-09 21:33:24 +01001599 printk(KERN_DEBUG "%s: other->termios[%d] not o_termios for (%s)\n",
1600 __func__, idx, tty->name);
Jiri Slaby955787c2011-11-11 10:47:23 +01001601 return -1;
1602 }
1603 if (o_tty->link != tty) {
Jiri Slaby9de44bd2011-11-09 21:33:24 +01001604 printk(KERN_DEBUG "%s: bad pty pointers\n", __func__);
Jiri Slaby955787c2011-11-11 10:47:23 +01001605 return -1;
1606 }
1607 }
1608#endif
1609 return 0;
1610}
1611
1612/**
Alan Coxeeb89d92009-11-30 13:18:29 +00001613 * tty_release - vfs callback for close
1614 * @inode: inode of tty
1615 * @filp: file pointer for handle to tty
1616 *
1617 * Called the last time each file handle is closed that references
1618 * this tty. There may however be several such references.
1619 *
1620 * Locking:
1621 * Takes bkl. See tty_release_dev
1622 *
Linus Torvalds1da177e2005-04-16 15:20:36 -07001623 * Even releasing the tty structures is a tricky business.. We have
1624 * to be very careful that the structures are all released at the
1625 * same time, as interrupts might otherwise get the wrong pointers.
1626 *
1627 * WSH 09/09/97: rewritten to avoid some nasty race conditions that could
1628 * lead to double frees or releasing memory still in use.
1629 */
Alan Coxeeb89d92009-11-30 13:18:29 +00001630
1631int tty_release(struct inode *inode, struct file *filp)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001632{
Nick Piggind996b622010-08-18 04:37:36 +10001633 struct tty_struct *tty = file_tty(filp);
1634 struct tty_struct *o_tty;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001635 int pty_master, tty_closing, o_tty_closing, do_sleep;
Paul Fulghum14a62832006-04-10 22:54:19 -07001636 int devpts;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001637 int idx;
1638 char buf[64];
Alan Cox37bdfb02008-02-08 04:18:47 -08001639
Jiri Slaby9de44bd2011-11-09 21:33:24 +01001640 if (tty_paranoia_check(tty, inode, __func__))
Alan Coxeeb89d92009-11-30 13:18:29 +00001641 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001642
Arnd Bergmannec79d602010-06-01 22:53:01 +02001643 tty_lock();
Jiri Slaby9de44bd2011-11-09 21:33:24 +01001644 check_tty_count(tty, __func__);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001645
Arnd Bergmannec79d602010-06-01 22:53:01 +02001646 __tty_fasync(-1, filp, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001647
1648 idx = tty->index;
1649 pty_master = (tty->driver->type == TTY_DRIVER_TYPE_PTY &&
1650 tty->driver->subtype == PTY_TYPE_MASTER);
1651 devpts = (tty->driver->flags & TTY_DRIVER_DEVPTS_MEM) != 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001652 o_tty = tty->link;
1653
Jiri Slaby955787c2011-11-11 10:47:23 +01001654 if (tty_release_checks(tty, o_tty, idx)) {
Arnd Bergmannec79d602010-06-01 22:53:01 +02001655 tty_unlock();
Alan Coxeeb89d92009-11-30 13:18:29 +00001656 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001657 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001658
1659#ifdef TTY_DEBUG_HANGUP
Jiri Slaby9de44bd2011-11-09 21:33:24 +01001660 printk(KERN_DEBUG "%s: %s (tty count=%d)...\n", __func__,
1661 tty_name(tty, buf), tty->count);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001662#endif
1663
Alan Coxf34d7a52008-04-30 00:54:13 -07001664 if (tty->ops->close)
1665 tty->ops->close(tty, filp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001666
Arnd Bergmannec79d602010-06-01 22:53:01 +02001667 tty_unlock();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001668 /*
1669 * Sanity check: if tty->count is going to zero, there shouldn't be
1670 * any waiters on tty->read_wait or tty->write_wait. We test the
1671 * wait queues and kick everyone out _before_ actually starting to
1672 * close. This ensures that we won't block while releasing the tty
1673 * structure.
1674 *
1675 * The test for the o_tty closing is necessary, since the master and
1676 * slave sides may close in any order. If the slave side closes out
1677 * first, its count will be one, since the master side holds an open.
1678 * Thus this test wouldn't be triggered at the time the slave closes,
1679 * so we do it now.
1680 *
1681 * Note that it's possible for the tty to be opened again while we're
1682 * flushing out waiters. By recalculating the closing flags before
1683 * each iteration we avoid any problems.
1684 */
1685 while (1) {
1686 /* Guard against races with tty->count changes elsewhere and
1687 opens on /dev/tty */
Alan Cox37bdfb02008-02-08 04:18:47 -08001688
Ingo Molnar70522e12006-03-23 03:00:31 -08001689 mutex_lock(&tty_mutex);
Arnd Bergmannec79d602010-06-01 22:53:01 +02001690 tty_lock();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001691 tty_closing = tty->count <= 1;
1692 o_tty_closing = o_tty &&
1693 (o_tty->count <= (pty_master ? 1 : 0));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001694 do_sleep = 0;
1695
1696 if (tty_closing) {
1697 if (waitqueue_active(&tty->read_wait)) {
Davide Libenzi4b194492009-03-31 15:24:24 -07001698 wake_up_poll(&tty->read_wait, POLLIN);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001699 do_sleep++;
1700 }
1701 if (waitqueue_active(&tty->write_wait)) {
Davide Libenzi4b194492009-03-31 15:24:24 -07001702 wake_up_poll(&tty->write_wait, POLLOUT);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001703 do_sleep++;
1704 }
1705 }
1706 if (o_tty_closing) {
1707 if (waitqueue_active(&o_tty->read_wait)) {
Davide Libenzi4b194492009-03-31 15:24:24 -07001708 wake_up_poll(&o_tty->read_wait, POLLIN);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001709 do_sleep++;
1710 }
1711 if (waitqueue_active(&o_tty->write_wait)) {
Davide Libenzi4b194492009-03-31 15:24:24 -07001712 wake_up_poll(&o_tty->write_wait, POLLOUT);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001713 do_sleep++;
1714 }
1715 }
1716 if (!do_sleep)
1717 break;
1718
Jiri Slaby9de44bd2011-11-09 21:33:24 +01001719 printk(KERN_WARNING "%s: %s: read/write wait queue active!\n",
1720 __func__, tty_name(tty, buf));
Arnd Bergmannec79d602010-06-01 22:53:01 +02001721 tty_unlock();
Ingo Molnar70522e12006-03-23 03:00:31 -08001722 mutex_unlock(&tty_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001723 schedule();
Alan Cox37bdfb02008-02-08 04:18:47 -08001724 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001725
1726 /*
Alan Cox37bdfb02008-02-08 04:18:47 -08001727 * The closing flags are now consistent with the open counts on
1728 * both sides, and we've completed the last operation that could
Linus Torvalds1da177e2005-04-16 15:20:36 -07001729 * block, so it's safe to proceed with closing.
1730 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001731 if (pty_master) {
1732 if (--o_tty->count < 0) {
Jiri Slaby9de44bd2011-11-09 21:33:24 +01001733 printk(KERN_WARNING "%s: bad pty slave count (%d) for %s\n",
1734 __func__, o_tty->count, tty_name(o_tty, buf));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001735 o_tty->count = 0;
1736 }
1737 }
1738 if (--tty->count < 0) {
Jiri Slaby9de44bd2011-11-09 21:33:24 +01001739 printk(KERN_WARNING "%s: bad tty->count (%d) for %s\n",
1740 __func__, tty->count, tty_name(tty, buf));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001741 tty->count = 0;
1742 }
Alan Cox37bdfb02008-02-08 04:18:47 -08001743
Linus Torvalds1da177e2005-04-16 15:20:36 -07001744 /*
1745 * We've decremented tty->count, so we need to remove this file
1746 * descriptor off the tty->tty_files list; this serves two
1747 * purposes:
1748 * - check_tty_count sees the correct number of file descriptors
1749 * associated with this tty.
1750 * - do_tty_hangup no longer sees this file descriptor as
1751 * something that needs to be handled for hangups.
1752 */
Nick Piggind996b622010-08-18 04:37:36 +10001753 tty_del_file(filp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001754
1755 /*
1756 * Perform some housekeeping before deciding whether to return.
1757 *
1758 * Set the TTY_CLOSING flag if this was the last open. In the
1759 * case of a pty we may have to wait around for the other side
1760 * to close, and TTY_CLOSING makes sure we can't be reopened.
1761 */
Alan Cox37bdfb02008-02-08 04:18:47 -08001762 if (tty_closing)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001763 set_bit(TTY_CLOSING, &tty->flags);
Alan Cox37bdfb02008-02-08 04:18:47 -08001764 if (o_tty_closing)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001765 set_bit(TTY_CLOSING, &o_tty->flags);
1766
1767 /*
1768 * If _either_ side is closing, make sure there aren't any
1769 * processes that still think tty or o_tty is their controlling
1770 * tty.
1771 */
1772 if (tty_closing || o_tty_closing) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001773 read_lock(&tasklist_lock);
Peter Zijlstra24ec8392006-12-08 02:36:04 -08001774 session_clear_tty(tty->session);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001775 if (o_tty)
Peter Zijlstra24ec8392006-12-08 02:36:04 -08001776 session_clear_tty(o_tty->session);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001777 read_unlock(&tasklist_lock);
1778 }
1779
Ingo Molnar70522e12006-03-23 03:00:31 -08001780 mutex_unlock(&tty_mutex);
Paul Fulghumda965822006-02-14 13:53:00 -08001781
Linus Torvalds1da177e2005-04-16 15:20:36 -07001782 /* check whether both sides are closing ... */
Alan Coxeeb89d92009-11-30 13:18:29 +00001783 if (!tty_closing || (o_tty && !o_tty_closing)) {
Arnd Bergmannec79d602010-06-01 22:53:01 +02001784 tty_unlock();
Alan Coxeeb89d92009-11-30 13:18:29 +00001785 return 0;
1786 }
Alan Cox37bdfb02008-02-08 04:18:47 -08001787
Linus Torvalds1da177e2005-04-16 15:20:36 -07001788#ifdef TTY_DEBUG_HANGUP
Jiri Slaby9de44bd2011-11-09 21:33:24 +01001789 printk(KERN_DEBUG "%s: freeing tty structure...\n", __func__);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001790#endif
1791 /*
Alan Cox01e1abb2008-07-22 11:16:55 +01001792 * Ask the line discipline code to release its structures
Linus Torvalds1da177e2005-04-16 15:20:36 -07001793 */
Alan Cox01e1abb2008-07-22 11:16:55 +01001794 tty_ldisc_release(tty, o_tty);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001795 /*
Christoph Hellwigd5698c22007-02-10 01:46:46 -08001796 * The release_tty function takes care of the details of clearing
Linus Torvalds1da177e2005-04-16 15:20:36 -07001797 * the slots and preserving the termios structure.
1798 */
Christoph Hellwigd5698c22007-02-10 01:46:46 -08001799 release_tty(tty, idx);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001800
Linus Torvalds1da177e2005-04-16 15:20:36 -07001801 /* Make this pty number available for reallocation */
Sukadev Bhattiprolu718a9162008-04-30 00:54:21 -07001802 if (devpts)
Sukadev Bhattiprolu15f1a632008-10-13 10:42:59 +01001803 devpts_kill_index(inode, idx);
Arnd Bergmannec79d602010-06-01 22:53:01 +02001804 tty_unlock();
Alan Coxeeb89d92009-11-30 13:18:29 +00001805 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001806}
1807
Alan Coxaf9b8972006-08-27 01:24:01 -07001808/**
Jiri Slabyb82154a2011-11-09 21:33:19 +01001809 * tty_open_current_tty - get tty of current task for open
1810 * @device: device number
1811 * @filp: file pointer to tty
1812 * @return: tty of the current task iff @device is /dev/tty
1813 *
1814 * We cannot return driver and index like for the other nodes because
1815 * devpts will not work then. It expects inodes to be from devpts FS.
1816 */
1817static struct tty_struct *tty_open_current_tty(dev_t device, struct file *filp)
1818{
1819 struct tty_struct *tty;
1820
1821 if (device != MKDEV(TTYAUX_MAJOR, 0))
1822 return NULL;
1823
1824 tty = get_current_tty();
1825 if (!tty)
1826 return ERR_PTR(-ENXIO);
1827
1828 filp->f_flags |= O_NONBLOCK; /* Don't let /dev/tty block */
1829 /* noctty = 1; */
1830 tty_kref_put(tty);
1831 /* FIXME: we put a reference and return a TTY! */
1832 return tty;
1833}
1834
1835/**
Jiri Slaby5b5e7042011-11-09 21:33:20 +01001836 * tty_lookup_driver - lookup a tty driver for a given device file
1837 * @device: device number
1838 * @filp: file pointer to tty
1839 * @noctty: set if the device should not become a controlling tty
1840 * @index: index for the device in the @return driver
1841 * @return: driver for this inode (with increased refcount)
1842 *
1843 * If @return is not erroneous, the caller is responsible to decrement the
1844 * refcount by tty_driver_kref_put.
1845 *
1846 * Locking: tty_mutex protects get_tty_driver
1847 */
1848static struct tty_driver *tty_lookup_driver(dev_t device, struct file *filp,
1849 int *noctty, int *index)
1850{
1851 struct tty_driver *driver;
1852
Jiri Slaby2cd00502011-11-09 21:33:22 +01001853 switch (device) {
Jiri Slaby5b5e7042011-11-09 21:33:20 +01001854#ifdef CONFIG_VT
Jiri Slaby2cd00502011-11-09 21:33:22 +01001855 case MKDEV(TTY_MAJOR, 0): {
Jiri Slaby5b5e7042011-11-09 21:33:20 +01001856 extern struct tty_driver *console_driver;
1857 driver = tty_driver_kref_get(console_driver);
1858 *index = fg_console;
1859 *noctty = 1;
Jiri Slaby2cd00502011-11-09 21:33:22 +01001860 break;
Jiri Slaby5b5e7042011-11-09 21:33:20 +01001861 }
1862#endif
Jiri Slaby2cd00502011-11-09 21:33:22 +01001863 case MKDEV(TTYAUX_MAJOR, 1): {
Jiri Slaby5b5e7042011-11-09 21:33:20 +01001864 struct tty_driver *console_driver = console_device(index);
1865 if (console_driver) {
1866 driver = tty_driver_kref_get(console_driver);
1867 if (driver) {
1868 /* Don't let /dev/console block */
1869 filp->f_flags |= O_NONBLOCK;
1870 *noctty = 1;
Jiri Slaby2cd00502011-11-09 21:33:22 +01001871 break;
Jiri Slaby5b5e7042011-11-09 21:33:20 +01001872 }
1873 }
1874 return ERR_PTR(-ENODEV);
1875 }
Jiri Slaby2cd00502011-11-09 21:33:22 +01001876 default:
1877 driver = get_tty_driver(device, index);
1878 if (!driver)
1879 return ERR_PTR(-ENODEV);
1880 break;
1881 }
Jiri Slaby5b5e7042011-11-09 21:33:20 +01001882 return driver;
1883}
1884
1885/**
Alan Coxeeb89d92009-11-30 13:18:29 +00001886 * tty_open - open a tty device
Alan Coxaf9b8972006-08-27 01:24:01 -07001887 * @inode: inode of device file
1888 * @filp: file pointer to tty
Linus Torvalds1da177e2005-04-16 15:20:36 -07001889 *
Alan Coxaf9b8972006-08-27 01:24:01 -07001890 * tty_open and tty_release keep up the tty count that contains the
1891 * number of opens done on a tty. We cannot use the inode-count, as
1892 * different inodes might point to the same tty.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001893 *
Alan Coxaf9b8972006-08-27 01:24:01 -07001894 * Open-counting is needed for pty masters, as well as for keeping
1895 * track of serial lines: DTR is dropped when the last close happens.
1896 * (This is not done solely through tty->count, now. - Ted 1/27/92)
1897 *
1898 * The termios state of a pty is reset on first open so that
1899 * settings don't persist across reuse.
1900 *
Jiri Slaby5b5e7042011-11-09 21:33:20 +01001901 * Locking: tty_mutex protects tty, tty_lookup_driver and tty_init_dev.
Peter Zijlstra24ec8392006-12-08 02:36:04 -08001902 * tty->count should protect the rest.
1903 * ->siglock protects ->signal/->sighand
Linus Torvalds1da177e2005-04-16 15:20:36 -07001904 */
Alan Coxaf9b8972006-08-27 01:24:01 -07001905
Alan Coxeeb89d92009-11-30 13:18:29 +00001906static int tty_open(struct inode *inode, struct file *filp)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001907{
Jiri Slabyb82154a2011-11-09 21:33:19 +01001908 struct tty_struct *tty;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001909 int noctty, retval;
Jiri Slabyb82154a2011-11-09 21:33:19 +01001910 struct tty_driver *driver = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001911 int index;
1912 dev_t device = inode->i_rdev;
Andrew Morton846c1512009-04-02 16:56:36 -07001913 unsigned saved_flags = filp->f_flags;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001914
1915 nonseekable_open(inode, filp);
Alan Cox37bdfb02008-02-08 04:18:47 -08001916
Linus Torvalds1da177e2005-04-16 15:20:36 -07001917retry_open:
Jiri Slabyfa90e1c2011-10-12 11:32:43 +02001918 retval = tty_alloc_file(filp);
1919 if (retval)
1920 return -ENOMEM;
1921
Linus Torvalds1da177e2005-04-16 15:20:36 -07001922 noctty = filp->f_flags & O_NOCTTY;
1923 index = -1;
1924 retval = 0;
Alan Cox37bdfb02008-02-08 04:18:47 -08001925
Ingo Molnar70522e12006-03-23 03:00:31 -08001926 mutex_lock(&tty_mutex);
Arnd Bergmannec79d602010-06-01 22:53:01 +02001927 tty_lock();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001928
Jiri Slabyb82154a2011-11-09 21:33:19 +01001929 tty = tty_open_current_tty(device, filp);
1930 if (IS_ERR(tty)) {
Jiri Slabyba5db442011-11-09 21:33:21 +01001931 retval = PTR_ERR(tty);
1932 goto err_unlock;
Jiri Slaby5b5e7042011-11-09 21:33:20 +01001933 } else if (!tty) {
1934 driver = tty_lookup_driver(device, filp, &noctty, &index);
1935 if (IS_ERR(driver)) {
Jiri Slabyba5db442011-11-09 21:33:21 +01001936 retval = PTR_ERR(driver);
1937 goto err_unlock;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001938 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001939
Sukadev Bhattiprolu4a2b5fd2008-10-13 10:42:49 +01001940 /* check whether we're reopening an existing tty */
Sukadev Bhattiprolu15f1a632008-10-13 10:42:59 +01001941 tty = tty_driver_lookup_tty(driver, inode, index);
Eric Paris808ffa32009-01-27 11:50:37 +00001942 if (IS_ERR(tty)) {
Jiri Slabyba5db442011-11-09 21:33:21 +01001943 retval = PTR_ERR(tty);
1944 goto err_unlock;
Eric Paris808ffa32009-01-27 11:50:37 +00001945 }
Sukadev Bhattiprolu4a2b5fd2008-10-13 10:42:49 +01001946 }
1947
1948 if (tty) {
1949 retval = tty_reopen(tty);
1950 if (retval)
1951 tty = ERR_PTR(retval);
1952 } else
1953 tty = tty_init_dev(driver, index, 0);
1954
Ingo Molnar70522e12006-03-23 03:00:31 -08001955 mutex_unlock(&tty_mutex);
Jiri Slabyb82154a2011-11-09 21:33:19 +01001956 if (driver)
1957 tty_driver_kref_put(driver);
Alan Coxeeb89d92009-11-30 13:18:29 +00001958 if (IS_ERR(tty)) {
Arnd Bergmannec79d602010-06-01 22:53:01 +02001959 tty_unlock();
Jiri Slabyba5db442011-11-09 21:33:21 +01001960 retval = PTR_ERR(tty);
1961 goto err_file;
Alan Coxeeb89d92009-11-30 13:18:29 +00001962 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001963
Jiri Slabyfa90e1c2011-10-12 11:32:43 +02001964 tty_add_file(tty, filp);
Nick Piggind996b622010-08-18 04:37:36 +10001965
Jiri Slaby9de44bd2011-11-09 21:33:24 +01001966 check_tty_count(tty, __func__);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001967 if (tty->driver->type == TTY_DRIVER_TYPE_PTY &&
1968 tty->driver->subtype == PTY_TYPE_MASTER)
1969 noctty = 1;
1970#ifdef TTY_DEBUG_HANGUP
Jiri Slaby9de44bd2011-11-09 21:33:24 +01001971 printk(KERN_DEBUG "%s: opening %s...\n", __func__, tty->name);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001972#endif
Herton Ronaldo Krzesinski909bc772011-03-31 15:35:31 -03001973 if (tty->ops->open)
1974 retval = tty->ops->open(tty, filp);
1975 else
1976 retval = -ENODEV;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001977 filp->f_flags = saved_flags;
1978
Alan Cox37bdfb02008-02-08 04:18:47 -08001979 if (!retval && test_bit(TTY_EXCLUSIVE, &tty->flags) &&
1980 !capable(CAP_SYS_ADMIN))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001981 retval = -EBUSY;
1982
1983 if (retval) {
1984#ifdef TTY_DEBUG_HANGUP
Jiri Slaby9de44bd2011-11-09 21:33:24 +01001985 printk(KERN_DEBUG "%s: error %d in opening %s...\n", __func__,
1986 retval, tty->name);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001987#endif
Arnd Bergmann64ba3dc2010-06-01 22:53:02 +02001988 tty_unlock(); /* need to call tty_release without BTM */
Alan Coxeeb89d92009-11-30 13:18:29 +00001989 tty_release(inode, filp);
Arnd Bergmann64ba3dc2010-06-01 22:53:02 +02001990 if (retval != -ERESTARTSYS)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001991 return retval;
Arnd Bergmann64ba3dc2010-06-01 22:53:02 +02001992
1993 if (signal_pending(current))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001994 return retval;
Arnd Bergmann64ba3dc2010-06-01 22:53:02 +02001995
Linus Torvalds1da177e2005-04-16 15:20:36 -07001996 schedule();
1997 /*
1998 * Need to reset f_op in case a hangup happened.
1999 */
Arnd Bergmann64ba3dc2010-06-01 22:53:02 +02002000 tty_lock();
Linus Torvalds1da177e2005-04-16 15:20:36 -07002001 if (filp->f_op == &hung_up_tty_fops)
2002 filp->f_op = &tty_fops;
Arnd Bergmannec79d602010-06-01 22:53:01 +02002003 tty_unlock();
Linus Torvalds1da177e2005-04-16 15:20:36 -07002004 goto retry_open;
2005 }
Arnd Bergmannec79d602010-06-01 22:53:01 +02002006 tty_unlock();
Alan Coxeeb89d92009-11-30 13:18:29 +00002007
Peter Zijlstra24ec8392006-12-08 02:36:04 -08002008
2009 mutex_lock(&tty_mutex);
Arnd Bergmannec79d602010-06-01 22:53:01 +02002010 tty_lock();
Peter Zijlstra24ec8392006-12-08 02:36:04 -08002011 spin_lock_irq(&current->sighand->siglock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002012 if (!noctty &&
2013 current->signal->leader &&
2014 !current->signal->tty &&
Eric W. Biedermanab521dc2007-02-12 00:53:00 -08002015 tty->session == NULL)
Eric W. Biederman2a65f1d2007-05-08 00:26:53 -07002016 __proc_set_tty(current, tty);
Peter Zijlstra24ec8392006-12-08 02:36:04 -08002017 spin_unlock_irq(&current->sighand->siglock);
Arnd Bergmannec79d602010-06-01 22:53:01 +02002018 tty_unlock();
Peter Zijlstra24ec8392006-12-08 02:36:04 -08002019 mutex_unlock(&tty_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002020 return 0;
Jiri Slabyba5db442011-11-09 21:33:21 +01002021err_unlock:
2022 tty_unlock();
2023 mutex_unlock(&tty_mutex);
2024 /* after locks to avoid deadlock */
2025 if (!IS_ERR_OR_NULL(driver))
2026 tty_driver_kref_put(driver);
2027err_file:
2028 tty_free_file(filp);
2029 return retval;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002030}
2031
Jonathan Corbet39d95b92008-05-16 09:10:50 -06002032
Linus Torvalds1da177e2005-04-16 15:20:36 -07002033
Alan Coxaf9b8972006-08-27 01:24:01 -07002034/**
2035 * tty_poll - check tty status
2036 * @filp: file being polled
2037 * @wait: poll wait structures to update
2038 *
2039 * Call the line discipline polling method to obtain the poll
2040 * status of the device.
2041 *
2042 * Locking: locks called line discipline but ldisc poll method
2043 * may be re-entered freely by other callers.
2044 */
2045
Alan Cox37bdfb02008-02-08 04:18:47 -08002046static unsigned int tty_poll(struct file *filp, poll_table *wait)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002047{
Nick Piggind996b622010-08-18 04:37:36 +10002048 struct tty_struct *tty = file_tty(filp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002049 struct tty_ldisc *ld;
2050 int ret = 0;
2051
Josef Sipeka7113a92006-12-08 02:36:55 -08002052 if (tty_paranoia_check(tty, filp->f_path.dentry->d_inode, "tty_poll"))
Linus Torvalds1da177e2005-04-16 15:20:36 -07002053 return 0;
Alan Cox37bdfb02008-02-08 04:18:47 -08002054
Linus Torvalds1da177e2005-04-16 15:20:36 -07002055 ld = tty_ldisc_ref_wait(tty);
Alan Coxa352def2008-07-16 21:53:12 +01002056 if (ld->ops->poll)
2057 ret = (ld->ops->poll)(tty, filp, wait);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002058 tty_ldisc_deref(ld);
2059 return ret;
2060}
2061
Arnd Bergmannec79d602010-06-01 22:53:01 +02002062static int __tty_fasync(int fd, struct file *filp, int on)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002063{
Nick Piggind996b622010-08-18 04:37:36 +10002064 struct tty_struct *tty = file_tty(filp);
Alan Cox47f86832008-04-30 00:53:30 -07002065 unsigned long flags;
Jonathan Corbet5d1e3232008-06-19 16:04:53 -06002066 int retval = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002067
Josef Sipeka7113a92006-12-08 02:36:55 -08002068 if (tty_paranoia_check(tty, filp->f_path.dentry->d_inode, "tty_fasync"))
Jonathan Corbet5d1e3232008-06-19 16:04:53 -06002069 goto out;
Alan Cox37bdfb02008-02-08 04:18:47 -08002070
Linus Torvalds1da177e2005-04-16 15:20:36 -07002071 retval = fasync_helper(fd, filp, on, &tty->fasync);
2072 if (retval <= 0)
Jonathan Corbet5d1e3232008-06-19 16:04:53 -06002073 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002074
2075 if (on) {
Eric W. Biedermanab521dc2007-02-12 00:53:00 -08002076 enum pid_type type;
2077 struct pid *pid;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002078 if (!waitqueue_active(&tty->read_wait))
2079 tty->minimum_to_wake = 1;
Alan Cox47f86832008-04-30 00:53:30 -07002080 spin_lock_irqsave(&tty->ctrl_lock, flags);
Eric W. Biedermanab521dc2007-02-12 00:53:00 -08002081 if (tty->pgrp) {
2082 pid = tty->pgrp;
2083 type = PIDTYPE_PGID;
2084 } else {
2085 pid = task_pid(current);
2086 type = PIDTYPE_PID;
2087 }
Linus Torvalds80e1e822010-02-07 10:11:23 -08002088 get_pid(pid);
Greg Kroah-Hartman70362512009-12-17 07:07:19 -08002089 spin_unlock_irqrestore(&tty->ctrl_lock, flags);
Linus Torvalds80e1e822010-02-07 10:11:23 -08002090 retval = __f_setown(filp, pid, type, 0);
2091 put_pid(pid);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002092 if (retval)
Jonathan Corbet5d1e3232008-06-19 16:04:53 -06002093 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002094 } else {
2095 if (!tty->fasync && !waitqueue_active(&tty->read_wait))
2096 tty->minimum_to_wake = N_TTY_BUF_SIZE;
2097 }
Jonathan Corbet5d1e3232008-06-19 16:04:53 -06002098 retval = 0;
2099out:
Arnd Bergmannec79d602010-06-01 22:53:01 +02002100 return retval;
2101}
2102
2103static int tty_fasync(int fd, struct file *filp, int on)
2104{
2105 int retval;
2106 tty_lock();
2107 retval = __tty_fasync(fd, filp, on);
2108 tty_unlock();
Jonathan Corbet5d1e3232008-06-19 16:04:53 -06002109 return retval;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002110}
2111
Alan Coxaf9b8972006-08-27 01:24:01 -07002112/**
2113 * tiocsti - fake input character
2114 * @tty: tty to fake input into
2115 * @p: pointer to character
2116 *
Robert P. J. Day3a4fa0a2007-10-19 23:10:43 +02002117 * Fake input to a tty device. Does the necessary locking and
Alan Coxaf9b8972006-08-27 01:24:01 -07002118 * input management.
2119 *
2120 * FIXME: does not honour flow control ??
2121 *
2122 * Locking:
2123 * Called functions take tty_ldisc_lock
2124 * current->signal->tty check is safe without locks
Alan Cox28298232006-09-29 02:00:58 -07002125 *
2126 * FIXME: may race normal receive processing
Alan Coxaf9b8972006-08-27 01:24:01 -07002127 */
2128
Linus Torvalds1da177e2005-04-16 15:20:36 -07002129static int tiocsti(struct tty_struct *tty, char __user *p)
2130{
2131 char ch, mbz = 0;
2132 struct tty_ldisc *ld;
Alan Cox37bdfb02008-02-08 04:18:47 -08002133
Linus Torvalds1da177e2005-04-16 15:20:36 -07002134 if ((current->signal->tty != tty) && !capable(CAP_SYS_ADMIN))
2135 return -EPERM;
2136 if (get_user(ch, p))
2137 return -EFAULT;
Al Viro1e641742008-12-09 09:23:33 +00002138 tty_audit_tiocsti(tty, ch);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002139 ld = tty_ldisc_ref_wait(tty);
Alan Coxa352def2008-07-16 21:53:12 +01002140 ld->ops->receive_buf(tty, &ch, &mbz, 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002141 tty_ldisc_deref(ld);
2142 return 0;
2143}
2144
Alan Coxaf9b8972006-08-27 01:24:01 -07002145/**
2146 * tiocgwinsz - implement window query ioctl
2147 * @tty; tty
2148 * @arg: user buffer for result
2149 *
Alan Cox808a0d32006-09-29 02:00:40 -07002150 * Copies the kernel idea of the window size into the user buffer.
Alan Coxaf9b8972006-08-27 01:24:01 -07002151 *
Peter Zijlstra24ec8392006-12-08 02:36:04 -08002152 * Locking: tty->termios_mutex is taken to ensure the winsize data
Alan Cox808a0d32006-09-29 02:00:40 -07002153 * is consistent.
Alan Coxaf9b8972006-08-27 01:24:01 -07002154 */
2155
Alan Cox37bdfb02008-02-08 04:18:47 -08002156static int tiocgwinsz(struct tty_struct *tty, struct winsize __user *arg)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002157{
Alan Cox808a0d32006-09-29 02:00:40 -07002158 int err;
2159
Arjan van de Ven5785c952006-09-29 02:00:43 -07002160 mutex_lock(&tty->termios_mutex);
Alan Cox808a0d32006-09-29 02:00:40 -07002161 err = copy_to_user(arg, &tty->winsize, sizeof(*arg));
Arjan van de Ven5785c952006-09-29 02:00:43 -07002162 mutex_unlock(&tty->termios_mutex);
Alan Cox808a0d32006-09-29 02:00:40 -07002163
2164 return err ? -EFAULT: 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002165}
2166
Alan Coxaf9b8972006-08-27 01:24:01 -07002167/**
Alan Cox8c9a9dd2008-08-15 10:39:38 +01002168 * tty_do_resize - resize event
2169 * @tty: tty being resized
Alan Cox8c9a9dd2008-08-15 10:39:38 +01002170 * @rows: rows (character)
2171 * @cols: cols (character)
Alan Coxaf9b8972006-08-27 01:24:01 -07002172 *
Daniel Mack3ad2f3f2010-02-03 08:01:28 +08002173 * Update the termios variables and send the necessary signals to
Alan Cox8c9a9dd2008-08-15 10:39:38 +01002174 * peform a terminal resize correctly
Alan Coxaf9b8972006-08-27 01:24:01 -07002175 */
2176
Alan Coxfc6f6232009-01-02 13:43:17 +00002177int tty_do_resize(struct tty_struct *tty, struct winsize *ws)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002178{
Alan Coxfc6f6232009-01-02 13:43:17 +00002179 struct pid *pgrp;
Alan Cox47f86832008-04-30 00:53:30 -07002180 unsigned long flags;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002181
Alan Coxfc6f6232009-01-02 13:43:17 +00002182 /* Lock the tty */
2183 mutex_lock(&tty->termios_mutex);
2184 if (!memcmp(ws, &tty->winsize, sizeof(*ws)))
Alan Coxca9bda02006-09-29 02:00:03 -07002185 goto done;
Alan Cox47f86832008-04-30 00:53:30 -07002186 /* Get the PID values and reference them so we can
2187 avoid holding the tty ctrl lock while sending signals */
2188 spin_lock_irqsave(&tty->ctrl_lock, flags);
2189 pgrp = get_pid(tty->pgrp);
Alan Cox47f86832008-04-30 00:53:30 -07002190 spin_unlock_irqrestore(&tty->ctrl_lock, flags);
2191
2192 if (pgrp)
2193 kill_pgrp(pgrp, SIGWINCH, 1);
Alan Cox47f86832008-04-30 00:53:30 -07002194 put_pid(pgrp);
Alan Cox47f86832008-04-30 00:53:30 -07002195
Alan Cox8c9a9dd2008-08-15 10:39:38 +01002196 tty->winsize = *ws;
Alan Coxca9bda02006-09-29 02:00:03 -07002197done:
Alan Coxfc6f6232009-01-02 13:43:17 +00002198 mutex_unlock(&tty->termios_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002199 return 0;
2200}
2201
Alan Coxaf9b8972006-08-27 01:24:01 -07002202/**
Alan Cox8c9a9dd2008-08-15 10:39:38 +01002203 * tiocswinsz - implement window size set ioctl
Alan Coxfc6f6232009-01-02 13:43:17 +00002204 * @tty; tty side of tty
Alan Cox8c9a9dd2008-08-15 10:39:38 +01002205 * @arg: user buffer for result
2206 *
2207 * Copies the user idea of the window size to the kernel. Traditionally
2208 * this is just advisory information but for the Linux console it
2209 * actually has driver level meaning and triggers a VC resize.
2210 *
2211 * Locking:
Lucas De Marchi25985ed2011-03-30 22:57:33 -03002212 * Driver dependent. The default do_resize method takes the
Alan Cox8c9a9dd2008-08-15 10:39:38 +01002213 * tty termios mutex and ctrl_lock. The console takes its own lock
2214 * then calls into the default method.
2215 */
2216
Alan Coxfc6f6232009-01-02 13:43:17 +00002217static int tiocswinsz(struct tty_struct *tty, struct winsize __user *arg)
Alan Cox8c9a9dd2008-08-15 10:39:38 +01002218{
2219 struct winsize tmp_ws;
2220 if (copy_from_user(&tmp_ws, arg, sizeof(*arg)))
2221 return -EFAULT;
2222
2223 if (tty->ops->resize)
Alan Coxfc6f6232009-01-02 13:43:17 +00002224 return tty->ops->resize(tty, &tmp_ws);
Alan Cox8c9a9dd2008-08-15 10:39:38 +01002225 else
Alan Coxfc6f6232009-01-02 13:43:17 +00002226 return tty_do_resize(tty, &tmp_ws);
Alan Cox8c9a9dd2008-08-15 10:39:38 +01002227}
2228
2229/**
Alan Coxaf9b8972006-08-27 01:24:01 -07002230 * tioccons - allow admin to move logical console
2231 * @file: the file to become console
2232 *
Lucas De Marchi25985ed2011-03-30 22:57:33 -03002233 * Allow the administrator to move the redirected console device
Alan Coxaf9b8972006-08-27 01:24:01 -07002234 *
2235 * Locking: uses redirect_lock to guard the redirect information
2236 */
2237
Linus Torvalds1da177e2005-04-16 15:20:36 -07002238static int tioccons(struct file *file)
2239{
2240 if (!capable(CAP_SYS_ADMIN))
2241 return -EPERM;
2242 if (file->f_op->write == redirected_tty_write) {
2243 struct file *f;
2244 spin_lock(&redirect_lock);
2245 f = redirect;
2246 redirect = NULL;
2247 spin_unlock(&redirect_lock);
2248 if (f)
2249 fput(f);
2250 return 0;
2251 }
2252 spin_lock(&redirect_lock);
2253 if (redirect) {
2254 spin_unlock(&redirect_lock);
2255 return -EBUSY;
2256 }
2257 get_file(file);
2258 redirect = file;
2259 spin_unlock(&redirect_lock);
2260 return 0;
2261}
2262
Alan Coxaf9b8972006-08-27 01:24:01 -07002263/**
2264 * fionbio - non blocking ioctl
2265 * @file: file to set blocking value
2266 * @p: user parameter
2267 *
2268 * Historical tty interfaces had a blocking control ioctl before
2269 * the generic functionality existed. This piece of history is preserved
2270 * in the expected tty API of posix OS's.
2271 *
Alan Cox6146b9a2009-09-19 13:13:19 -07002272 * Locking: none, the open file handle ensures it won't go away.
Alan Coxaf9b8972006-08-27 01:24:01 -07002273 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002274
2275static int fionbio(struct file *file, int __user *p)
2276{
2277 int nonblock;
2278
2279 if (get_user(nonblock, p))
2280 return -EFAULT;
2281
Jonathan Corbetdb1dd4d2009-02-06 15:25:24 -07002282 spin_lock(&file->f_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002283 if (nonblock)
2284 file->f_flags |= O_NONBLOCK;
2285 else
2286 file->f_flags &= ~O_NONBLOCK;
Jonathan Corbetdb1dd4d2009-02-06 15:25:24 -07002287 spin_unlock(&file->f_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002288 return 0;
2289}
2290
Alan Coxaf9b8972006-08-27 01:24:01 -07002291/**
2292 * tiocsctty - set controlling tty
2293 * @tty: tty structure
2294 * @arg: user argument
2295 *
2296 * This ioctl is used to manage job control. It permits a session
2297 * leader to set this tty as the controlling tty for the session.
2298 *
2299 * Locking:
Alan Cox28298232006-09-29 02:00:58 -07002300 * Takes tty_mutex() to protect tty instance
Peter Zijlstra24ec8392006-12-08 02:36:04 -08002301 * Takes tasklist_lock internally to walk sessions
2302 * Takes ->siglock() when updating signal->tty
Alan Coxaf9b8972006-08-27 01:24:01 -07002303 */
2304
Linus Torvalds1da177e2005-04-16 15:20:36 -07002305static int tiocsctty(struct tty_struct *tty, int arg)
2306{
Peter Zijlstra24ec8392006-12-08 02:36:04 -08002307 int ret = 0;
Eric W. Biedermanab521dc2007-02-12 00:53:00 -08002308 if (current->signal->leader && (task_session(current) == tty->session))
Peter Zijlstra24ec8392006-12-08 02:36:04 -08002309 return ret;
2310
2311 mutex_lock(&tty_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002312 /*
2313 * The process must be a session leader and
2314 * not have a controlling tty already.
2315 */
Peter Zijlstra24ec8392006-12-08 02:36:04 -08002316 if (!current->signal->leader || current->signal->tty) {
2317 ret = -EPERM;
2318 goto unlock;
2319 }
2320
Eric W. Biedermanab521dc2007-02-12 00:53:00 -08002321 if (tty->session) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002322 /*
2323 * This tty is already the controlling
2324 * tty for another session group!
2325 */
Alan Cox37bdfb02008-02-08 04:18:47 -08002326 if (arg == 1 && capable(CAP_SYS_ADMIN)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002327 /*
2328 * Steal it away
2329 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002330 read_lock(&tasklist_lock);
Peter Zijlstra24ec8392006-12-08 02:36:04 -08002331 session_clear_tty(tty->session);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002332 read_unlock(&tasklist_lock);
Peter Zijlstra24ec8392006-12-08 02:36:04 -08002333 } else {
2334 ret = -EPERM;
2335 goto unlock;
2336 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002337 }
Peter Zijlstra24ec8392006-12-08 02:36:04 -08002338 proc_set_tty(current, tty);
2339unlock:
Alan Cox28298232006-09-29 02:00:58 -07002340 mutex_unlock(&tty_mutex);
Peter Zijlstra24ec8392006-12-08 02:36:04 -08002341 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002342}
2343
Alan Coxaf9b8972006-08-27 01:24:01 -07002344/**
Alan Cox5d0fdf12008-04-30 00:53:31 -07002345 * tty_get_pgrp - return a ref counted pgrp pid
2346 * @tty: tty to read
2347 *
2348 * Returns a refcounted instance of the pid struct for the process
2349 * group controlling the tty.
2350 */
2351
2352struct pid *tty_get_pgrp(struct tty_struct *tty)
2353{
2354 unsigned long flags;
2355 struct pid *pgrp;
2356
2357 spin_lock_irqsave(&tty->ctrl_lock, flags);
2358 pgrp = get_pid(tty->pgrp);
2359 spin_unlock_irqrestore(&tty->ctrl_lock, flags);
2360
2361 return pgrp;
2362}
2363EXPORT_SYMBOL_GPL(tty_get_pgrp);
2364
2365/**
Alan Coxaf9b8972006-08-27 01:24:01 -07002366 * tiocgpgrp - get process group
2367 * @tty: tty passed by user
Lucas De Marchi25985ed2011-03-30 22:57:33 -03002368 * @real_tty: tty side of the tty passed by the user if a pty else the tty
Alan Coxaf9b8972006-08-27 01:24:01 -07002369 * @p: returned pid
2370 *
2371 * Obtain the process group of the tty. If there is no process group
2372 * return an error.
2373 *
Peter Zijlstra24ec8392006-12-08 02:36:04 -08002374 * Locking: none. Reference to current->signal->tty is safe.
Alan Coxaf9b8972006-08-27 01:24:01 -07002375 */
2376
Linus Torvalds1da177e2005-04-16 15:20:36 -07002377static int tiocgpgrp(struct tty_struct *tty, struct tty_struct *real_tty, pid_t __user *p)
2378{
Alan Cox5d0fdf12008-04-30 00:53:31 -07002379 struct pid *pid;
2380 int ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002381 /*
2382 * (tty == real_tty) is a cheap way of
2383 * testing if the tty is NOT a master pty.
2384 */
2385 if (tty == real_tty && current->signal->tty != real_tty)
2386 return -ENOTTY;
Alan Cox5d0fdf12008-04-30 00:53:31 -07002387 pid = tty_get_pgrp(real_tty);
2388 ret = put_user(pid_vnr(pid), p);
2389 put_pid(pid);
2390 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002391}
2392
Alan Coxaf9b8972006-08-27 01:24:01 -07002393/**
2394 * tiocspgrp - attempt to set process group
2395 * @tty: tty passed by user
2396 * @real_tty: tty side device matching tty passed by user
2397 * @p: pid pointer
2398 *
2399 * Set the process group of the tty to the session passed. Only
2400 * permitted where the tty session is our session.
2401 *
Alan Cox47f86832008-04-30 00:53:30 -07002402 * Locking: RCU, ctrl lock
Alan Coxaf9b8972006-08-27 01:24:01 -07002403 */
2404
Linus Torvalds1da177e2005-04-16 15:20:36 -07002405static int tiocspgrp(struct tty_struct *tty, struct tty_struct *real_tty, pid_t __user *p)
2406{
Eric W. Biederman04a2e6a2007-02-12 00:52:56 -08002407 struct pid *pgrp;
2408 pid_t pgrp_nr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002409 int retval = tty_check_change(real_tty);
Alan Cox47f86832008-04-30 00:53:30 -07002410 unsigned long flags;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002411
2412 if (retval == -EIO)
2413 return -ENOTTY;
2414 if (retval)
2415 return retval;
2416 if (!current->signal->tty ||
2417 (current->signal->tty != real_tty) ||
Eric W. Biedermanab521dc2007-02-12 00:53:00 -08002418 (real_tty->session != task_session(current)))
Linus Torvalds1da177e2005-04-16 15:20:36 -07002419 return -ENOTTY;
Eric W. Biederman04a2e6a2007-02-12 00:52:56 -08002420 if (get_user(pgrp_nr, p))
Linus Torvalds1da177e2005-04-16 15:20:36 -07002421 return -EFAULT;
Eric W. Biederman04a2e6a2007-02-12 00:52:56 -08002422 if (pgrp_nr < 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002423 return -EINVAL;
Eric W. Biederman04a2e6a2007-02-12 00:52:56 -08002424 rcu_read_lock();
Pavel Emelyanovb4888932007-10-18 23:40:14 -07002425 pgrp = find_vpid(pgrp_nr);
Eric W. Biederman04a2e6a2007-02-12 00:52:56 -08002426 retval = -ESRCH;
2427 if (!pgrp)
2428 goto out_unlock;
2429 retval = -EPERM;
2430 if (session_of_pgrp(pgrp) != task_session(current))
2431 goto out_unlock;
2432 retval = 0;
Alan Cox47f86832008-04-30 00:53:30 -07002433 spin_lock_irqsave(&tty->ctrl_lock, flags);
Eric W. Biedermanab521dc2007-02-12 00:53:00 -08002434 put_pid(real_tty->pgrp);
2435 real_tty->pgrp = get_pid(pgrp);
Alan Cox47f86832008-04-30 00:53:30 -07002436 spin_unlock_irqrestore(&tty->ctrl_lock, flags);
Eric W. Biederman04a2e6a2007-02-12 00:52:56 -08002437out_unlock:
2438 rcu_read_unlock();
2439 return retval;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002440}
2441
Alan Coxaf9b8972006-08-27 01:24:01 -07002442/**
2443 * tiocgsid - get session id
2444 * @tty: tty passed by user
Lucas De Marchi25985ed2011-03-30 22:57:33 -03002445 * @real_tty: tty side of the tty passed by the user if a pty else the tty
Alan Coxaf9b8972006-08-27 01:24:01 -07002446 * @p: pointer to returned session id
2447 *
2448 * Obtain the session id of the tty. If there is no session
2449 * return an error.
2450 *
Peter Zijlstra24ec8392006-12-08 02:36:04 -08002451 * Locking: none. Reference to current->signal->tty is safe.
Alan Coxaf9b8972006-08-27 01:24:01 -07002452 */
2453
Linus Torvalds1da177e2005-04-16 15:20:36 -07002454static int tiocgsid(struct tty_struct *tty, struct tty_struct *real_tty, pid_t __user *p)
2455{
2456 /*
2457 * (tty == real_tty) is a cheap way of
2458 * testing if the tty is NOT a master pty.
2459 */
2460 if (tty == real_tty && current->signal->tty != real_tty)
2461 return -ENOTTY;
Eric W. Biedermanab521dc2007-02-12 00:53:00 -08002462 if (!real_tty->session)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002463 return -ENOTTY;
Pavel Emelyanovb4888932007-10-18 23:40:14 -07002464 return put_user(pid_vnr(real_tty->session), p);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002465}
2466
Alan Coxaf9b8972006-08-27 01:24:01 -07002467/**
2468 * tiocsetd - set line discipline
2469 * @tty: tty device
2470 * @p: pointer to user data
2471 *
2472 * Set the line discipline according to user request.
2473 *
2474 * Locking: see tty_set_ldisc, this function is just a helper
2475 */
2476
Linus Torvalds1da177e2005-04-16 15:20:36 -07002477static int tiocsetd(struct tty_struct *tty, int __user *p)
2478{
2479 int ldisc;
Alan Cox04f378b2008-04-30 00:53:29 -07002480 int ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002481
2482 if (get_user(ldisc, p))
2483 return -EFAULT;
Alan Cox04f378b2008-04-30 00:53:29 -07002484
Alan Cox04f378b2008-04-30 00:53:29 -07002485 ret = tty_set_ldisc(tty, ldisc);
Alan Cox04f378b2008-04-30 00:53:29 -07002486
2487 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002488}
2489
Alan Coxaf9b8972006-08-27 01:24:01 -07002490/**
2491 * send_break - performed time break
2492 * @tty: device to break on
2493 * @duration: timeout in mS
2494 *
2495 * Perform a timed break on hardware that lacks its own driver level
2496 * timed break functionality.
2497 *
2498 * Locking:
Alan Cox28298232006-09-29 02:00:58 -07002499 * atomic_write_lock serializes
Alan Coxaf9b8972006-08-27 01:24:01 -07002500 *
Alan Coxaf9b8972006-08-27 01:24:01 -07002501 */
2502
Domen Puncerb20f3ae2005-06-25 14:58:42 -07002503static int send_break(struct tty_struct *tty, unsigned int duration)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002504{
Alan Cox9e989662008-07-22 11:18:03 +01002505 int retval;
2506
2507 if (tty->ops->break_ctl == NULL)
2508 return 0;
2509
2510 if (tty->driver->flags & TTY_DRIVER_HARDWARE_BREAK)
2511 retval = tty->ops->break_ctl(tty, duration);
2512 else {
2513 /* Do the work ourselves */
2514 if (tty_write_lock(tty, 0) < 0)
2515 return -EINTR;
2516 retval = tty->ops->break_ctl(tty, -1);
2517 if (retval)
2518 goto out;
2519 if (!signal_pending(current))
2520 msleep_interruptible(duration);
2521 retval = tty->ops->break_ctl(tty, 0);
2522out:
2523 tty_write_unlock(tty);
2524 if (signal_pending(current))
2525 retval = -EINTR;
2526 }
2527 return retval;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002528}
2529
Alan Coxaf9b8972006-08-27 01:24:01 -07002530/**
Alan Coxf34d7a52008-04-30 00:54:13 -07002531 * tty_tiocmget - get modem status
Alan Coxaf9b8972006-08-27 01:24:01 -07002532 * @tty: tty device
2533 * @file: user file pointer
2534 * @p: pointer to result
2535 *
2536 * Obtain the modem status bits from the tty driver if the feature
2537 * is supported. Return -EINVAL if it is not available.
2538 *
2539 * Locking: none (up to the driver)
2540 */
2541
Alan Cox60b33c12011-02-14 16:26:14 +00002542static int tty_tiocmget(struct tty_struct *tty, int __user *p)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002543{
2544 int retval = -EINVAL;
2545
Alan Coxf34d7a52008-04-30 00:54:13 -07002546 if (tty->ops->tiocmget) {
Alan Cox60b33c12011-02-14 16:26:14 +00002547 retval = tty->ops->tiocmget(tty);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002548
2549 if (retval >= 0)
2550 retval = put_user(retval, p);
2551 }
2552 return retval;
2553}
2554
Alan Coxaf9b8972006-08-27 01:24:01 -07002555/**
Alan Coxf34d7a52008-04-30 00:54:13 -07002556 * tty_tiocmset - set modem status
Alan Coxaf9b8972006-08-27 01:24:01 -07002557 * @tty: tty device
Alan Coxaf9b8972006-08-27 01:24:01 -07002558 * @cmd: command - clear bits, set bits or set all
2559 * @p: pointer to desired bits
2560 *
2561 * Set the modem status bits from the tty driver if the feature
2562 * is supported. Return -EINVAL if it is not available.
2563 *
2564 * Locking: none (up to the driver)
2565 */
2566
Alan Cox20b9d172011-02-14 16:26:50 +00002567static int tty_tiocmset(struct tty_struct *tty, unsigned int cmd,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002568 unsigned __user *p)
2569{
Alan Coxae677512008-07-16 21:56:54 +01002570 int retval;
2571 unsigned int set, clear, val;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002572
Alan Coxae677512008-07-16 21:56:54 +01002573 if (tty->ops->tiocmset == NULL)
2574 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002575
Alan Coxae677512008-07-16 21:56:54 +01002576 retval = get_user(val, p);
2577 if (retval)
2578 return retval;
2579 set = clear = 0;
2580 switch (cmd) {
2581 case TIOCMBIS:
2582 set = val;
2583 break;
2584 case TIOCMBIC:
2585 clear = val;
2586 break;
2587 case TIOCMSET:
2588 set = val;
2589 clear = ~val;
2590 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002591 }
Alan Coxae677512008-07-16 21:56:54 +01002592 set &= TIOCM_DTR|TIOCM_RTS|TIOCM_OUT1|TIOCM_OUT2|TIOCM_LOOP;
2593 clear &= TIOCM_DTR|TIOCM_RTS|TIOCM_OUT1|TIOCM_OUT2|TIOCM_LOOP;
Alan Cox20b9d172011-02-14 16:26:50 +00002594 return tty->ops->tiocmset(tty, set, clear);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002595}
2596
Alan Coxd281da72010-09-16 18:21:24 +01002597static int tty_tiocgicount(struct tty_struct *tty, void __user *arg)
2598{
2599 int retval = -EINVAL;
2600 struct serial_icounter_struct icount;
2601 memset(&icount, 0, sizeof(icount));
2602 if (tty->ops->get_icount)
2603 retval = tty->ops->get_icount(tty, &icount);
2604 if (retval != 0)
2605 return retval;
2606 if (copy_to_user(arg, &icount, sizeof(icount)))
2607 return -EFAULT;
2608 return 0;
2609}
2610
Alan Coxe8b70e72009-06-11 12:48:02 +01002611struct tty_struct *tty_pair_get_tty(struct tty_struct *tty)
2612{
2613 if (tty->driver->type == TTY_DRIVER_TYPE_PTY &&
2614 tty->driver->subtype == PTY_TYPE_MASTER)
2615 tty = tty->link;
2616 return tty;
2617}
2618EXPORT_SYMBOL(tty_pair_get_tty);
2619
2620struct tty_struct *tty_pair_get_pty(struct tty_struct *tty)
2621{
2622 if (tty->driver->type == TTY_DRIVER_TYPE_PTY &&
2623 tty->driver->subtype == PTY_TYPE_MASTER)
2624 return tty;
2625 return tty->link;
2626}
2627EXPORT_SYMBOL(tty_pair_get_pty);
2628
Linus Torvalds1da177e2005-04-16 15:20:36 -07002629/*
2630 * Split this up, as gcc can choke on it otherwise..
2631 */
Alan Cox04f378b2008-04-30 00:53:29 -07002632long tty_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002633{
Nick Piggind996b622010-08-18 04:37:36 +10002634 struct tty_struct *tty = file_tty(file);
2635 struct tty_struct *real_tty;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002636 void __user *p = (void __user *)arg;
2637 int retval;
2638 struct tty_ldisc *ld;
Alan Cox04f378b2008-04-30 00:53:29 -07002639 struct inode *inode = file->f_dentry->d_inode;
Alan Cox37bdfb02008-02-08 04:18:47 -08002640
Linus Torvalds1da177e2005-04-16 15:20:36 -07002641 if (tty_paranoia_check(tty, inode, "tty_ioctl"))
2642 return -EINVAL;
2643
Alan Coxe8b70e72009-06-11 12:48:02 +01002644 real_tty = tty_pair_get_tty(tty);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002645
2646 /*
2647 * Factor out some common prep work
2648 */
2649 switch (cmd) {
2650 case TIOCSETD:
2651 case TIOCSBRK:
2652 case TIOCCBRK:
2653 case TCSBRK:
Alan Cox37bdfb02008-02-08 04:18:47 -08002654 case TCSBRKP:
Linus Torvalds1da177e2005-04-16 15:20:36 -07002655 retval = tty_check_change(tty);
2656 if (retval)
2657 return retval;
2658 if (cmd != TIOCCBRK) {
2659 tty_wait_until_sent(tty, 0);
2660 if (signal_pending(current))
2661 return -EINTR;
2662 }
2663 break;
2664 }
2665
Alan Cox9e989662008-07-22 11:18:03 +01002666 /*
2667 * Now do the stuff.
2668 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002669 switch (cmd) {
Alan Cox37bdfb02008-02-08 04:18:47 -08002670 case TIOCSTI:
2671 return tiocsti(tty, p);
2672 case TIOCGWINSZ:
Alan Cox8f520022008-10-13 10:38:46 +01002673 return tiocgwinsz(real_tty, p);
Alan Cox37bdfb02008-02-08 04:18:47 -08002674 case TIOCSWINSZ:
Alan Coxfc6f6232009-01-02 13:43:17 +00002675 return tiocswinsz(real_tty, p);
Alan Cox37bdfb02008-02-08 04:18:47 -08002676 case TIOCCONS:
2677 return real_tty != tty ? -EINVAL : tioccons(file);
2678 case FIONBIO:
2679 return fionbio(file, p);
2680 case TIOCEXCL:
2681 set_bit(TTY_EXCLUSIVE, &tty->flags);
2682 return 0;
2683 case TIOCNXCL:
2684 clear_bit(TTY_EXCLUSIVE, &tty->flags);
2685 return 0;
2686 case TIOCNOTTY:
2687 if (current->signal->tty != tty)
2688 return -ENOTTY;
2689 no_tty();
2690 return 0;
2691 case TIOCSCTTY:
2692 return tiocsctty(tty, arg);
2693 case TIOCGPGRP:
2694 return tiocgpgrp(tty, real_tty, p);
2695 case TIOCSPGRP:
2696 return tiocspgrp(tty, real_tty, p);
2697 case TIOCGSID:
2698 return tiocgsid(tty, real_tty, p);
2699 case TIOCGETD:
Alan Coxc65c9bc2009-06-11 12:50:12 +01002700 return put_user(tty->ldisc->ops->num, (int __user *)p);
Alan Cox37bdfb02008-02-08 04:18:47 -08002701 case TIOCSETD:
2702 return tiocsetd(tty, p);
Kay Sievers3c95c982011-02-17 18:39:28 +01002703 case TIOCVHANGUP:
2704 if (!capable(CAP_SYS_ADMIN))
2705 return -EPERM;
2706 tty_vhangup(tty);
2707 return 0;
Werner Finkb7b8de02010-12-03 12:48:23 +01002708 case TIOCGDEV:
2709 {
2710 unsigned int ret = new_encode_dev(tty_devnum(real_tty));
2711 return put_user(ret, (unsigned int __user *)p);
2712 }
Alan Cox37bdfb02008-02-08 04:18:47 -08002713 /*
2714 * Break handling
2715 */
2716 case TIOCSBRK: /* Turn break on, unconditionally */
Alan Coxf34d7a52008-04-30 00:54:13 -07002717 if (tty->ops->break_ctl)
Alan Cox9e989662008-07-22 11:18:03 +01002718 return tty->ops->break_ctl(tty, -1);
Alan Cox37bdfb02008-02-08 04:18:47 -08002719 return 0;
Alan Cox37bdfb02008-02-08 04:18:47 -08002720 case TIOCCBRK: /* Turn break off, unconditionally */
Alan Coxf34d7a52008-04-30 00:54:13 -07002721 if (tty->ops->break_ctl)
Alan Cox9e989662008-07-22 11:18:03 +01002722 return tty->ops->break_ctl(tty, 0);
Alan Cox37bdfb02008-02-08 04:18:47 -08002723 return 0;
2724 case TCSBRK: /* SVID version: non-zero arg --> no break */
2725 /* non-zero arg means wait for all output data
2726 * to be sent (performed above) but don't send break.
2727 * This is used by the tcdrain() termios function.
Linus Torvalds1da177e2005-04-16 15:20:36 -07002728 */
Alan Cox37bdfb02008-02-08 04:18:47 -08002729 if (!arg)
2730 return send_break(tty, 250);
2731 return 0;
2732 case TCSBRKP: /* support for POSIX tcsendbreak() */
2733 return send_break(tty, arg ? arg*100 : 250);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002734
Alan Cox37bdfb02008-02-08 04:18:47 -08002735 case TIOCMGET:
Alan Cox60b33c12011-02-14 16:26:14 +00002736 return tty_tiocmget(tty, p);
Alan Cox37bdfb02008-02-08 04:18:47 -08002737 case TIOCMSET:
2738 case TIOCMBIC:
2739 case TIOCMBIS:
Alan Cox20b9d172011-02-14 16:26:50 +00002740 return tty_tiocmset(tty, cmd, p);
Alan Coxd281da72010-09-16 18:21:24 +01002741 case TIOCGICOUNT:
2742 retval = tty_tiocgicount(tty, p);
2743 /* For the moment allow fall through to the old method */
2744 if (retval != -EINVAL)
2745 return retval;
2746 break;
Alan Cox37bdfb02008-02-08 04:18:47 -08002747 case TCFLSH:
2748 switch (arg) {
2749 case TCIFLUSH:
2750 case TCIOFLUSH:
2751 /* flush tty buffer and allow ldisc to process ioctl */
2752 tty_buffer_flush(tty);
Paul Fulghumc5c34d42007-05-12 10:36:55 -07002753 break;
Alan Cox37bdfb02008-02-08 04:18:47 -08002754 }
2755 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002756 }
Alan Coxf34d7a52008-04-30 00:54:13 -07002757 if (tty->ops->ioctl) {
Alan Cox6caa76b2011-02-14 16:27:22 +00002758 retval = (tty->ops->ioctl)(tty, cmd, arg);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002759 if (retval != -ENOIOCTLCMD)
2760 return retval;
2761 }
2762 ld = tty_ldisc_ref_wait(tty);
2763 retval = -EINVAL;
Alan Coxa352def2008-07-16 21:53:12 +01002764 if (ld->ops->ioctl) {
2765 retval = ld->ops->ioctl(tty, file, cmd, arg);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002766 if (retval == -ENOIOCTLCMD)
2767 retval = -EINVAL;
2768 }
2769 tty_ldisc_deref(ld);
2770 return retval;
2771}
2772
Paul Fulghume10cc1d2007-05-10 22:22:50 -07002773#ifdef CONFIG_COMPAT
Alan Cox37bdfb02008-02-08 04:18:47 -08002774static long tty_compat_ioctl(struct file *file, unsigned int cmd,
Paul Fulghume10cc1d2007-05-10 22:22:50 -07002775 unsigned long arg)
2776{
2777 struct inode *inode = file->f_dentry->d_inode;
Nick Piggind996b622010-08-18 04:37:36 +10002778 struct tty_struct *tty = file_tty(file);
Paul Fulghume10cc1d2007-05-10 22:22:50 -07002779 struct tty_ldisc *ld;
2780 int retval = -ENOIOCTLCMD;
2781
2782 if (tty_paranoia_check(tty, inode, "tty_ioctl"))
2783 return -EINVAL;
2784
Alan Coxf34d7a52008-04-30 00:54:13 -07002785 if (tty->ops->compat_ioctl) {
Alan Cox6caa76b2011-02-14 16:27:22 +00002786 retval = (tty->ops->compat_ioctl)(tty, cmd, arg);
Paul Fulghume10cc1d2007-05-10 22:22:50 -07002787 if (retval != -ENOIOCTLCMD)
2788 return retval;
2789 }
2790
2791 ld = tty_ldisc_ref_wait(tty);
Alan Coxa352def2008-07-16 21:53:12 +01002792 if (ld->ops->compat_ioctl)
2793 retval = ld->ops->compat_ioctl(tty, file, cmd, arg);
Thomas Meyer8193c422011-10-05 23:13:13 +02002794 else
2795 retval = n_tty_compat_ioctl_helper(tty, file, cmd, arg);
Paul Fulghume10cc1d2007-05-10 22:22:50 -07002796 tty_ldisc_deref(ld);
2797
2798 return retval;
2799}
2800#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07002801
2802/*
2803 * This implements the "Secure Attention Key" --- the idea is to
2804 * prevent trojan horses by killing all processes associated with this
2805 * tty when the user hits the "Secure Attention Key". Required for
2806 * super-paranoid applications --- see the Orange Book for more details.
Alan Cox37bdfb02008-02-08 04:18:47 -08002807 *
Linus Torvalds1da177e2005-04-16 15:20:36 -07002808 * This code could be nicer; ideally it should send a HUP, wait a few
2809 * seconds, then send a INT, and then a KILL signal. But you then
2810 * have to coordinate with the init process, since all processes associated
2811 * with the current tty must be dead before the new getty is allowed
2812 * to spawn.
2813 *
2814 * Now, if it would be correct ;-/ The current code has a nasty hole -
2815 * it doesn't catch files in flight. We may send the descriptor to ourselves
2816 * via AF_UNIX socket, close it and later fetch from socket. FIXME.
2817 *
2818 * Nasty bug: do_SAK is being called in interrupt context. This can
2819 * deadlock. We punt it up to process context. AKPM - 16Mar2001
2820 */
Eric W. Biederman8b6312f2007-02-10 01:44:34 -08002821void __do_SAK(struct tty_struct *tty)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002822{
2823#ifdef TTY_SOFT_SAK
2824 tty_hangup(tty);
2825#else
Eric W. Biederman652486f2006-03-28 16:11:02 -08002826 struct task_struct *g, *p;
Eric W. Biedermanab521dc2007-02-12 00:53:00 -08002827 struct pid *session;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002828 int i;
2829 struct file *filp;
Dipankar Sarmabadf1662005-09-09 13:04:10 -07002830 struct fdtable *fdt;
Alan Cox37bdfb02008-02-08 04:18:47 -08002831
Linus Torvalds1da177e2005-04-16 15:20:36 -07002832 if (!tty)
2833 return;
Peter Zijlstra24ec8392006-12-08 02:36:04 -08002834 session = tty->session;
Alan Cox37bdfb02008-02-08 04:18:47 -08002835
Dan Carpenterb3f13de2006-12-13 00:35:09 -08002836 tty_ldisc_flush(tty);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002837
Alan Coxf34d7a52008-04-30 00:54:13 -07002838 tty_driver_flush_buffer(tty);
Alan Cox37bdfb02008-02-08 04:18:47 -08002839
Linus Torvalds1da177e2005-04-16 15:20:36 -07002840 read_lock(&tasklist_lock);
Eric W. Biederman652486f2006-03-28 16:11:02 -08002841 /* Kill the entire session */
Eric W. Biedermanab521dc2007-02-12 00:53:00 -08002842 do_each_pid_task(session, PIDTYPE_SID, p) {
Eric W. Biederman652486f2006-03-28 16:11:02 -08002843 printk(KERN_NOTICE "SAK: killed process %d"
Oleg Nesterov1b0f7ff2009-04-02 16:58:39 -07002844 " (%s): task_session(p)==tty->session\n",
Pavel Emelyanovba25f9d2007-10-18 23:40:40 -07002845 task_pid_nr(p), p->comm);
Eric W. Biederman652486f2006-03-28 16:11:02 -08002846 send_sig(SIGKILL, p, 1);
Eric W. Biedermanab521dc2007-02-12 00:53:00 -08002847 } while_each_pid_task(session, PIDTYPE_SID, p);
Eric W. Biederman652486f2006-03-28 16:11:02 -08002848 /* Now kill any processes that happen to have the
2849 * tty open.
2850 */
2851 do_each_thread(g, p) {
2852 if (p->signal->tty == tty) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002853 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);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002856 send_sig(SIGKILL, p, 1);
2857 continue;
2858 }
2859 task_lock(p);
2860 if (p->files) {
Dipankar Sarmaca99c1d2006-04-18 22:21:46 -07002861 /*
2862 * We don't take a ref to the file, so we must
2863 * hold ->file_lock instead.
2864 */
2865 spin_lock(&p->files->file_lock);
Dipankar Sarmabadf1662005-09-09 13:04:10 -07002866 fdt = files_fdtable(p->files);
Alan Cox37bdfb02008-02-08 04:18:47 -08002867 for (i = 0; i < fdt->max_fds; i++) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002868 filp = fcheck_files(p->files, i);
2869 if (!filp)
2870 continue;
2871 if (filp->f_op->read == tty_read &&
Nick Piggind996b622010-08-18 04:37:36 +10002872 file_tty(filp) == tty) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002873 printk(KERN_NOTICE "SAK: killed process %d"
2874 " (%s): fd#%d opened to the tty\n",
Pavel Emelyanovba25f9d2007-10-18 23:40:40 -07002875 task_pid_nr(p), p->comm, i);
Eric W. Biederman20ac9432006-04-13 04:49:07 -06002876 force_sig(SIGKILL, p);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002877 break;
2878 }
2879 }
Dipankar Sarmaca99c1d2006-04-18 22:21:46 -07002880 spin_unlock(&p->files->file_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002881 }
2882 task_unlock(p);
Eric W. Biederman652486f2006-03-28 16:11:02 -08002883 } while_each_thread(g, p);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002884 read_unlock(&tasklist_lock);
2885#endif
2886}
2887
Eric W. Biederman8b6312f2007-02-10 01:44:34 -08002888static void do_SAK_work(struct work_struct *work)
2889{
2890 struct tty_struct *tty =
2891 container_of(work, struct tty_struct, SAK_work);
2892 __do_SAK(tty);
2893}
2894
Linus Torvalds1da177e2005-04-16 15:20:36 -07002895/*
2896 * The tq handling here is a little racy - tty->SAK_work may already be queued.
2897 * Fortunately we don't need to worry, because if ->SAK_work is already queued,
2898 * the values which we write to it will be identical to the values which it
2899 * already has. --akpm
2900 */
2901void do_SAK(struct tty_struct *tty)
2902{
2903 if (!tty)
2904 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002905 schedule_work(&tty->SAK_work);
2906}
2907
2908EXPORT_SYMBOL(do_SAK);
2909
Dmitry Eremin-Solenikov30004ac2010-08-09 18:22:49 +04002910static int dev_match_devt(struct device *dev, void *data)
2911{
2912 dev_t *devt = data;
2913 return dev->devt == *devt;
2914}
2915
2916/* Must put_device() after it's unused! */
2917static struct device *tty_get_device(struct tty_struct *tty)
2918{
2919 dev_t devt = tty_devnum(tty);
2920 return class_find_device(tty_class, NULL, &devt, dev_match_devt);
2921}
2922
2923
Alan Coxaf9b8972006-08-27 01:24:01 -07002924/**
Alan Coxaf9b8972006-08-27 01:24:01 -07002925 * initialize_tty_struct
2926 * @tty: tty to initialize
2927 *
2928 * This subroutine initializes a tty structure that has been newly
2929 * allocated.
2930 *
2931 * Locking: none - tty in question must not be exposed at this point
Linus Torvalds1da177e2005-04-16 15:20:36 -07002932 */
Alan Coxaf9b8972006-08-27 01:24:01 -07002933
Alan Coxbf970ee2008-10-13 10:42:39 +01002934void initialize_tty_struct(struct tty_struct *tty,
2935 struct tty_driver *driver, int idx)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002936{
2937 memset(tty, 0, sizeof(struct tty_struct));
Alan Cox9c9f4de2008-10-13 10:37:26 +01002938 kref_init(&tty->kref);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002939 tty->magic = TTY_MAGIC;
Alan Cox01e1abb2008-07-22 11:16:55 +01002940 tty_ldisc_init(tty);
Eric W. Biedermanab521dc2007-02-12 00:53:00 -08002941 tty->session = NULL;
2942 tty->pgrp = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002943 tty->overrun_time = jiffies;
Alan Cox33f0f882006-01-09 20:54:13 -08002944 tty->buf.head = tty->buf.tail = NULL;
2945 tty_buffer_init(tty);
Arjan van de Ven5785c952006-09-29 02:00:43 -07002946 mutex_init(&tty->termios_mutex);
Alan Coxc65c9bc2009-06-11 12:50:12 +01002947 mutex_init(&tty->ldisc_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002948 init_waitqueue_head(&tty->write_wait);
2949 init_waitqueue_head(&tty->read_wait);
David Howells65f27f32006-11-22 14:55:48 +00002950 INIT_WORK(&tty->hangup_work, do_tty_hangup);
Ingo Molnar70522e12006-03-23 03:00:31 -08002951 mutex_init(&tty->atomic_read_lock);
2952 mutex_init(&tty->atomic_write_lock);
Joe Petersona88a69c2009-01-02 13:40:53 +00002953 mutex_init(&tty->output_lock);
2954 mutex_init(&tty->echo_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002955 spin_lock_init(&tty->read_lock);
Alan Cox04f378b2008-04-30 00:53:29 -07002956 spin_lock_init(&tty->ctrl_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002957 INIT_LIST_HEAD(&tty->tty_files);
Eric W. Biederman7f1f86a2007-02-13 14:38:58 -07002958 INIT_WORK(&tty->SAK_work, do_SAK_work);
Alan Coxbf970ee2008-10-13 10:42:39 +01002959
2960 tty->driver = driver;
2961 tty->ops = driver->ops;
2962 tty->index = idx;
2963 tty_line_name(driver, idx, tty->name);
Dmitry Eremin-Solenikov30004ac2010-08-09 18:22:49 +04002964 tty->dev = tty_get_device(tty);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002965}
2966
Alan Coxf34d7a52008-04-30 00:54:13 -07002967/**
Jiri Slaby67166712011-03-23 10:48:35 +01002968 * deinitialize_tty_struct
2969 * @tty: tty to deinitialize
2970 *
2971 * This subroutine deinitializes a tty structure that has been newly
2972 * allocated but tty_release cannot be called on that yet.
2973 *
2974 * Locking: none - tty in question must not be exposed at this point
2975 */
2976void deinitialize_tty_struct(struct tty_struct *tty)
2977{
2978 tty_ldisc_deinit(tty);
2979}
2980
2981/**
Alan Coxf34d7a52008-04-30 00:54:13 -07002982 * tty_put_char - write one character to a tty
2983 * @tty: tty
2984 * @ch: character
2985 *
2986 * Write one byte to the tty using the provided put_char method
2987 * if present. Returns the number of characters successfully output.
2988 *
2989 * Note: the specific put_char operation in the driver layer may go
2990 * away soon. Don't call it directly, use this method
Linus Torvalds1da177e2005-04-16 15:20:36 -07002991 */
Alan Coxaf9b8972006-08-27 01:24:01 -07002992
Alan Coxf34d7a52008-04-30 00:54:13 -07002993int tty_put_char(struct tty_struct *tty, unsigned char ch)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002994{
Alan Coxf34d7a52008-04-30 00:54:13 -07002995 if (tty->ops->put_char)
2996 return tty->ops->put_char(tty, ch);
2997 return tty->ops->write(tty, &ch, 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002998}
Alan Coxf34d7a52008-04-30 00:54:13 -07002999EXPORT_SYMBOL_GPL(tty_put_char);
3000
Alan Coxd81ed102008-10-13 10:41:42 +01003001struct class *tty_class;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003002
3003/**
Alan Coxaf9b8972006-08-27 01:24:01 -07003004 * tty_register_device - register a tty device
3005 * @driver: the tty driver that describes the tty device
3006 * @index: the index in the tty driver for this tty device
3007 * @device: a struct device that is associated with this tty device.
3008 * This field is optional, if there is no known struct device
3009 * for this tty device it can be set to NULL safely.
Linus Torvalds1da177e2005-04-16 15:20:36 -07003010 *
Greg Kroah-Hartman01107d32006-08-07 22:19:37 -07003011 * Returns a pointer to the struct device for this tty device
3012 * (or ERR_PTR(-EFOO) on error).
Hansjoerg Lipp1cdcb6b2006-04-22 18:36:53 +02003013 *
Alan Coxaf9b8972006-08-27 01:24:01 -07003014 * This call is required to be made to register an individual tty device
3015 * if the tty driver's flags have the TTY_DRIVER_DYNAMIC_DEV bit set. If
3016 * that bit is not set, this function should not be called by a tty
3017 * driver.
3018 *
3019 * Locking: ??
Linus Torvalds1da177e2005-04-16 15:20:36 -07003020 */
Alan Coxaf9b8972006-08-27 01:24:01 -07003021
Greg Kroah-Hartman01107d32006-08-07 22:19:37 -07003022struct device *tty_register_device(struct tty_driver *driver, unsigned index,
3023 struct device *device)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003024{
3025 char name[64];
3026 dev_t dev = MKDEV(driver->major, driver->minor_start) + index;
3027
3028 if (index >= driver->num) {
3029 printk(KERN_ERR "Attempt to register invalid tty line number "
3030 " (%d).\n", index);
Hansjoerg Lipp1cdcb6b2006-04-22 18:36:53 +02003031 return ERR_PTR(-EINVAL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003032 }
3033
Linus Torvalds1da177e2005-04-16 15:20:36 -07003034 if (driver->type == TTY_DRIVER_TYPE_PTY)
3035 pty_line_name(driver, index, name);
3036 else
3037 tty_line_name(driver, index, name);
Hansjoerg Lipp1cdcb6b2006-04-22 18:36:53 +02003038
Greg Kroah-Hartman03457cd2008-07-21 20:03:34 -07003039 return device_create(tty_class, device, dev, NULL, name);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003040}
Alan Cox7d7b93c2008-10-13 10:42:09 +01003041EXPORT_SYMBOL(tty_register_device);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003042
3043/**
Alan Coxaf9b8972006-08-27 01:24:01 -07003044 * tty_unregister_device - unregister a tty device
3045 * @driver: the tty driver that describes the tty device
3046 * @index: the index in the tty driver for this tty device
Linus Torvalds1da177e2005-04-16 15:20:36 -07003047 *
Alan Coxaf9b8972006-08-27 01:24:01 -07003048 * If a tty device is registered with a call to tty_register_device() then
3049 * this function must be called when the tty device is gone.
3050 *
3051 * Locking: ??
Linus Torvalds1da177e2005-04-16 15:20:36 -07003052 */
Alan Coxaf9b8972006-08-27 01:24:01 -07003053
Linus Torvalds1da177e2005-04-16 15:20:36 -07003054void tty_unregister_device(struct tty_driver *driver, unsigned index)
3055{
Alan Cox37bdfb02008-02-08 04:18:47 -08003056 device_destroy(tty_class,
3057 MKDEV(driver->major, driver->minor_start) + index);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003058}
Linus Torvalds1da177e2005-04-16 15:20:36 -07003059EXPORT_SYMBOL(tty_unregister_device);
3060
3061struct tty_driver *alloc_tty_driver(int lines)
3062{
3063 struct tty_driver *driver;
3064
Jean Delvare506eb992007-07-15 23:40:14 -07003065 driver = kzalloc(sizeof(struct tty_driver), GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003066 if (driver) {
Alan Cox7d7b93c2008-10-13 10:42:09 +01003067 kref_init(&driver->kref);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003068 driver->magic = TTY_DRIVER_MAGIC;
3069 driver->num = lines;
3070 /* later we'll move allocation of tables here */
3071 }
3072 return driver;
3073}
Alan Cox7d7b93c2008-10-13 10:42:09 +01003074EXPORT_SYMBOL(alloc_tty_driver);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003075
Alan Cox7d7b93c2008-10-13 10:42:09 +01003076static void destruct_tty_driver(struct kref *kref)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003077{
Alan Cox7d7b93c2008-10-13 10:42:09 +01003078 struct tty_driver *driver = container_of(kref, struct tty_driver, kref);
3079 int i;
3080 struct ktermios *tp;
3081 void *p;
3082
3083 if (driver->flags & TTY_DRIVER_INSTALLED) {
3084 /*
3085 * Free the termios and termios_locked structures because
3086 * we don't want to get memory leaks when modular tty
3087 * drivers are removed from the kernel.
3088 */
3089 for (i = 0; i < driver->num; i++) {
3090 tp = driver->termios[i];
3091 if (tp) {
3092 driver->termios[i] = NULL;
3093 kfree(tp);
3094 }
Alan Cox7d7b93c2008-10-13 10:42:09 +01003095 if (!(driver->flags & TTY_DRIVER_DYNAMIC_DEV))
3096 tty_unregister_device(driver, i);
3097 }
3098 p = driver->ttys;
3099 proc_tty_unregister_driver(driver);
3100 driver->ttys = NULL;
Alan Coxfe6e29f2008-10-13 10:44:08 +01003101 driver->termios = NULL;
Alan Cox7d7b93c2008-10-13 10:42:09 +01003102 kfree(p);
3103 cdev_del(&driver->cdev);
3104 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07003105 kfree(driver);
3106}
3107
Alan Cox7d7b93c2008-10-13 10:42:09 +01003108void tty_driver_kref_put(struct tty_driver *driver)
3109{
3110 kref_put(&driver->kref, destruct_tty_driver);
3111}
3112EXPORT_SYMBOL(tty_driver_kref_put);
3113
Jeff Dikeb68e31d2006-10-02 02:17:18 -07003114void tty_set_operations(struct tty_driver *driver,
3115 const struct tty_operations *op)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003116{
Alan Coxf34d7a52008-04-30 00:54:13 -07003117 driver->ops = op;
3118};
Linus Torvalds1da177e2005-04-16 15:20:36 -07003119EXPORT_SYMBOL(tty_set_operations);
3120
Alan Cox7d7b93c2008-10-13 10:42:09 +01003121void put_tty_driver(struct tty_driver *d)
3122{
3123 tty_driver_kref_put(d);
3124}
3125EXPORT_SYMBOL(put_tty_driver);
3126
Linus Torvalds1da177e2005-04-16 15:20:36 -07003127/*
3128 * Called by a tty driver to register itself.
3129 */
3130int tty_register_driver(struct tty_driver *driver)
3131{
3132 int error;
Alan Cox37bdfb02008-02-08 04:18:47 -08003133 int i;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003134 dev_t dev;
3135 void **p = NULL;
Vasiliy Kulikovb670bde2010-09-05 22:32:22 +04003136 struct device *d;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003137
Andy Whitcroft543691a2007-05-06 14:49:33 -07003138 if (!(driver->flags & TTY_DRIVER_DEVPTS_MEM) && driver->num) {
Alan Coxfe6e29f2008-10-13 10:44:08 +01003139 p = kzalloc(driver->num * 2 * sizeof(void *), GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003140 if (!p)
3141 return -ENOMEM;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003142 }
3143
3144 if (!driver->major) {
Alan Cox37bdfb02008-02-08 04:18:47 -08003145 error = alloc_chrdev_region(&dev, driver->minor_start,
3146 driver->num, driver->name);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003147 if (!error) {
3148 driver->major = MAJOR(dev);
3149 driver->minor_start = MINOR(dev);
3150 }
3151 } else {
3152 dev = MKDEV(driver->major, driver->minor_start);
Geert Uytterhoevene5717c42007-02-20 15:45:21 +01003153 error = register_chrdev_region(dev, driver->num, driver->name);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003154 }
3155 if (error < 0) {
3156 kfree(p);
3157 return error;
3158 }
3159
3160 if (p) {
3161 driver->ttys = (struct tty_struct **)p;
Alan Coxedc6afc2006-12-08 02:38:44 -08003162 driver->termios = (struct ktermios **)(p + driver->num);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003163 } else {
3164 driver->ttys = NULL;
3165 driver->termios = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003166 }
3167
3168 cdev_init(&driver->cdev, &tty_fops);
3169 driver->cdev.owner = driver->owner;
3170 error = cdev_add(&driver->cdev, dev, driver->num);
3171 if (error) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07003172 unregister_chrdev_region(dev, driver->num);
3173 driver->ttys = NULL;
Alan Coxfe6e29f2008-10-13 10:44:08 +01003174 driver->termios = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003175 kfree(p);
3176 return error;
3177 }
3178
Alexey Dobriyanca509f62007-05-08 00:27:12 -07003179 mutex_lock(&tty_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003180 list_add(&driver->tty_drivers, &tty_drivers);
Alexey Dobriyanca509f62007-05-08 00:27:12 -07003181 mutex_unlock(&tty_mutex);
Alan Cox37bdfb02008-02-08 04:18:47 -08003182
3183 if (!(driver->flags & TTY_DRIVER_DYNAMIC_DEV)) {
Vasiliy Kulikovb670bde2010-09-05 22:32:22 +04003184 for (i = 0; i < driver->num; i++) {
3185 d = tty_register_device(driver, i, NULL);
3186 if (IS_ERR(d)) {
3187 error = PTR_ERR(d);
3188 goto err;
3189 }
3190 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07003191 }
3192 proc_tty_register_driver(driver);
Alan Cox7d7b93c2008-10-13 10:42:09 +01003193 driver->flags |= TTY_DRIVER_INSTALLED;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003194 return 0;
Vasiliy Kulikovb670bde2010-09-05 22:32:22 +04003195
3196err:
3197 for (i--; i >= 0; i--)
3198 tty_unregister_device(driver, i);
3199
3200 mutex_lock(&tty_mutex);
3201 list_del(&driver->tty_drivers);
3202 mutex_unlock(&tty_mutex);
3203
3204 unregister_chrdev_region(dev, driver->num);
3205 driver->ttys = NULL;
3206 driver->termios = NULL;
3207 kfree(p);
3208 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003209}
3210
3211EXPORT_SYMBOL(tty_register_driver);
3212
3213/*
3214 * Called by a tty driver to unregister itself.
3215 */
3216int tty_unregister_driver(struct tty_driver *driver)
3217{
Alan Cox7d7b93c2008-10-13 10:42:09 +01003218#if 0
3219 /* FIXME */
Linus Torvalds1da177e2005-04-16 15:20:36 -07003220 if (driver->refcount)
3221 return -EBUSY;
Alan Cox7d7b93c2008-10-13 10:42:09 +01003222#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07003223 unregister_chrdev_region(MKDEV(driver->major, driver->minor_start),
3224 driver->num);
Alexey Dobriyanca509f62007-05-08 00:27:12 -07003225 mutex_lock(&tty_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003226 list_del(&driver->tty_drivers);
Alexey Dobriyanca509f62007-05-08 00:27:12 -07003227 mutex_unlock(&tty_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003228 return 0;
3229}
Alan Cox7d7b93c2008-10-13 10:42:09 +01003230
Linus Torvalds1da177e2005-04-16 15:20:36 -07003231EXPORT_SYMBOL(tty_unregister_driver);
3232
Peter Zijlstra24ec8392006-12-08 02:36:04 -08003233dev_t tty_devnum(struct tty_struct *tty)
3234{
3235 return MKDEV(tty->driver->major, tty->driver->minor_start) + tty->index;
3236}
3237EXPORT_SYMBOL(tty_devnum);
3238
3239void proc_clear_tty(struct task_struct *p)
3240{
Arjan van de Ven7c3b1dc2008-10-15 10:52:34 +01003241 unsigned long flags;
Alan Cox9c9f4de2008-10-13 10:37:26 +01003242 struct tty_struct *tty;
Arjan van de Ven7c3b1dc2008-10-15 10:52:34 +01003243 spin_lock_irqsave(&p->sighand->siglock, flags);
Alan Cox9c9f4de2008-10-13 10:37:26 +01003244 tty = p->signal->tty;
Peter Zijlstra24ec8392006-12-08 02:36:04 -08003245 p->signal->tty = NULL;
Arjan van de Ven7c3b1dc2008-10-15 10:52:34 +01003246 spin_unlock_irqrestore(&p->sighand->siglock, flags);
Alan Cox9c9f4de2008-10-13 10:37:26 +01003247 tty_kref_put(tty);
Peter Zijlstra24ec8392006-12-08 02:36:04 -08003248}
Peter Zijlstra24ec8392006-12-08 02:36:04 -08003249
Alan Cox47f86832008-04-30 00:53:30 -07003250/* Called under the sighand lock */
3251
Eric W. Biederman2a65f1d2007-05-08 00:26:53 -07003252static void __proc_set_tty(struct task_struct *tsk, struct tty_struct *tty)
Peter Zijlstra24ec8392006-12-08 02:36:04 -08003253{
3254 if (tty) {
Alan Cox47f86832008-04-30 00:53:30 -07003255 unsigned long flags;
3256 /* We should not have a session or pgrp to put here but.... */
3257 spin_lock_irqsave(&tty->ctrl_lock, flags);
Eric W. Biedermand9c1e9a2007-03-18 12:45:44 -06003258 put_pid(tty->session);
3259 put_pid(tty->pgrp);
Eric W. Biedermanab521dc2007-02-12 00:53:00 -08003260 tty->pgrp = get_pid(task_pgrp(tsk));
Alan Cox47f86832008-04-30 00:53:30 -07003261 spin_unlock_irqrestore(&tty->ctrl_lock, flags);
3262 tty->session = get_pid(task_session(tsk));
Alan Cox9c9f4de2008-10-13 10:37:26 +01003263 if (tsk->signal->tty) {
3264 printk(KERN_DEBUG "tty not NULL!!\n");
3265 tty_kref_put(tsk->signal->tty);
3266 }
Peter Zijlstra24ec8392006-12-08 02:36:04 -08003267 }
Eric W. Biederman2a65f1d2007-05-08 00:26:53 -07003268 put_pid(tsk->signal->tty_old_pgrp);
Alan Cox9c9f4de2008-10-13 10:37:26 +01003269 tsk->signal->tty = tty_kref_get(tty);
Eric W. Biedermanab521dc2007-02-12 00:53:00 -08003270 tsk->signal->tty_old_pgrp = NULL;
Peter Zijlstra24ec8392006-12-08 02:36:04 -08003271}
3272
Eric W. Biederman98a27ba2007-05-08 00:26:56 -07003273static void proc_set_tty(struct task_struct *tsk, struct tty_struct *tty)
Peter Zijlstra24ec8392006-12-08 02:36:04 -08003274{
3275 spin_lock_irq(&tsk->sighand->siglock);
Eric W. Biederman2a65f1d2007-05-08 00:26:53 -07003276 __proc_set_tty(tsk, tty);
Peter Zijlstra24ec8392006-12-08 02:36:04 -08003277 spin_unlock_irq(&tsk->sighand->siglock);
3278}
3279
3280struct tty_struct *get_current_tty(void)
3281{
3282 struct tty_struct *tty;
Alan Cox934e6eb2008-10-13 10:40:43 +01003283 unsigned long flags;
3284
3285 spin_lock_irqsave(&current->sighand->siglock, flags);
Alan Cox452a00d2008-10-13 10:39:13 +01003286 tty = tty_kref_get(current->signal->tty);
Alan Cox934e6eb2008-10-13 10:40:43 +01003287 spin_unlock_irqrestore(&current->sighand->siglock, flags);
Peter Zijlstra24ec8392006-12-08 02:36:04 -08003288 return tty;
3289}
Heiko Carstensa311f742006-12-13 00:33:41 -08003290EXPORT_SYMBOL_GPL(get_current_tty);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003291
Alan Coxd81ed102008-10-13 10:41:42 +01003292void tty_default_fops(struct file_operations *fops)
3293{
3294 *fops = tty_fops;
3295}
3296
Linus Torvalds1da177e2005-04-16 15:20:36 -07003297/*
3298 * Initialize the console device. This is called *early*, so
3299 * we can't necessarily depend on lots of kernel help here.
3300 * Just do some early initializations, and do the complex setup
3301 * later.
3302 */
3303void __init console_init(void)
3304{
3305 initcall_t *call;
3306
3307 /* Setup the default TTY line discipline. */
Alan Cox01e1abb2008-07-22 11:16:55 +01003308 tty_ldisc_begin();
Linus Torvalds1da177e2005-04-16 15:20:36 -07003309
3310 /*
Alan Cox37bdfb02008-02-08 04:18:47 -08003311 * set up the console device so that later boot sequences can
Linus Torvalds1da177e2005-04-16 15:20:36 -07003312 * inform about problems etc..
3313 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07003314 call = __con_initcall_start;
3315 while (call < __con_initcall_end) {
3316 (*call)();
3317 call++;
3318 }
3319}
3320
Al Viro2c9ede52011-07-23 20:24:48 -04003321static char *tty_devnode(struct device *dev, umode_t *mode)
Kay Sieverse454cea2009-09-18 23:01:12 +02003322{
3323 if (!mode)
3324 return NULL;
3325 if (dev->devt == MKDEV(TTYAUX_MAJOR, 0) ||
3326 dev->devt == MKDEV(TTYAUX_MAJOR, 2))
3327 *mode = 0666;
3328 return NULL;
3329}
3330
Linus Torvalds1da177e2005-04-16 15:20:36 -07003331static int __init tty_class_init(void)
3332{
gregkh@suse.de7fe845d2005-03-15 14:23:15 -08003333 tty_class = class_create(THIS_MODULE, "tty");
Linus Torvalds1da177e2005-04-16 15:20:36 -07003334 if (IS_ERR(tty_class))
3335 return PTR_ERR(tty_class);
Kay Sieverse454cea2009-09-18 23:01:12 +02003336 tty_class->devnode = tty_devnode;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003337 return 0;
3338}
3339
3340postcore_initcall(tty_class_init);
3341
3342/* 3/2004 jmc: why do these devices exist? */
Linus Torvalds1da177e2005-04-16 15:20:36 -07003343static struct cdev tty_cdev, console_cdev;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003344
Kay Sieversfbc92a32010-12-01 18:51:05 +01003345static ssize_t show_cons_active(struct device *dev,
3346 struct device_attribute *attr, char *buf)
3347{
3348 struct console *cs[16];
3349 int i = 0;
3350 struct console *c;
3351 ssize_t count = 0;
3352
Torben Hohnac751ef2011-01-25 15:07:35 -08003353 console_lock();
Kay Sieversa2a6a822011-01-09 16:39:14 +01003354 for_each_console(c) {
Kay Sieversfbc92a32010-12-01 18:51:05 +01003355 if (!c->device)
3356 continue;
3357 if (!c->write)
3358 continue;
3359 if ((c->flags & CON_ENABLED) == 0)
3360 continue;
3361 cs[i++] = c;
3362 if (i >= ARRAY_SIZE(cs))
3363 break;
3364 }
3365 while (i--)
3366 count += sprintf(buf + count, "%s%d%c",
3367 cs[i]->name, cs[i]->index, i ? ' ':'\n');
Torben Hohnac751ef2011-01-25 15:07:35 -08003368 console_unlock();
Kay Sieversfbc92a32010-12-01 18:51:05 +01003369
3370 return count;
3371}
3372static DEVICE_ATTR(active, S_IRUGO, show_cons_active, NULL);
3373
3374static struct device *consdev;
3375
3376void console_sysfs_notify(void)
3377{
3378 if (consdev)
3379 sysfs_notify(&consdev->kobj, NULL, "active");
3380}
3381
Linus Torvalds1da177e2005-04-16 15:20:36 -07003382/*
3383 * Ok, now we can initialize the rest of the tty devices and can count
3384 * on memory allocations, interrupts etc..
3385 */
David Howells31d1d482010-08-06 16:34:43 +01003386int __init tty_init(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003387{
3388 cdev_init(&tty_cdev, &tty_fops);
3389 if (cdev_add(&tty_cdev, MKDEV(TTYAUX_MAJOR, 0), 1) ||
3390 register_chrdev_region(MKDEV(TTYAUX_MAJOR, 0), 1, "/dev/tty") < 0)
3391 panic("Couldn't register /dev/tty driver\n");
Kay Sieversfbc92a32010-12-01 18:51:05 +01003392 device_create(tty_class, NULL, MKDEV(TTYAUX_MAJOR, 0), NULL, "tty");
Linus Torvalds1da177e2005-04-16 15:20:36 -07003393
3394 cdev_init(&console_cdev, &console_fops);
3395 if (cdev_add(&console_cdev, MKDEV(TTYAUX_MAJOR, 1), 1) ||
3396 register_chrdev_region(MKDEV(TTYAUX_MAJOR, 1), 1, "/dev/console") < 0)
3397 panic("Couldn't register /dev/console driver\n");
Kay Sieversfbc92a32010-12-01 18:51:05 +01003398 consdev = device_create(tty_class, NULL, MKDEV(TTYAUX_MAJOR, 1), NULL,
Greg Kroah-Hartman47aa5792008-05-21 12:52:33 -07003399 "console");
Kay Sieversfbc92a32010-12-01 18:51:05 +01003400 if (IS_ERR(consdev))
3401 consdev = NULL;
3402 else
Kay Sieversa2a6a822011-01-09 16:39:14 +01003403 WARN_ON(device_create_file(consdev, &dev_attr_active) < 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003404
Linus Torvalds1da177e2005-04-16 15:20:36 -07003405#ifdef CONFIG_VT
Alan Coxd81ed102008-10-13 10:41:42 +01003406 vty_init(&console_fops);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003407#endif
3408 return 0;
3409}
David Howells31d1d482010-08-06 16:34:43 +01003410