Doug / smarc-fsl-linux-kernel

Download as
Browse Code ยป

Commit 38c70b27f9502c31c1d0c29676275f7362cdb0d9

Authored by Alan Cox
Committed by Greg Kroah-Hartman
1 parent f18f9498e9
Exists in master and in 7 other branches imx_3.0.35_4.1.0, imx_3.10.17_1.0.1_ga, imx_3.10.53_1.1.0_ga, imx_3.14.28_1.0.0_ga, smarc-imx_3.10.53_1.1.0_ga, smarc-imx_3.14.28_1.0.0_ga, smarc-l5.0.0_1.0.0-ga

tty: Push the bkl down a bit in the hangup code 

We know that the redirect field is handled via its own locking in all
places

Signed-off-by: Alan Cox <alan@linux.intel.com>
Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de>

Showing 1 changed file with 2 additions and 2 deletions Inline Diff

drivers/char/tty_io.c
Diff comments   View file @ 38c70b2
1 /* 1 /*
2 * linux/drivers/char/tty_io.c 2 * linux/drivers/char/tty_io.c
3 * 3 *
4 * Copyright (C) 1991, 1992 Linus Torvalds 4 * Copyright (C) 1991, 1992 Linus Torvalds
5 */ 5 */
6 6
7 /* 7 /*
8 * 'tty_io.c' gives an orthogonal feeling to tty's, be they consoles 8 * 'tty_io.c' gives an orthogonal feeling to tty's, be they consoles
9 * or rs-channels. It also implements echoing, cooked mode etc. 9 * or rs-channels. It also implements echoing, cooked mode etc.
10 * 10 *
11 * Kill-line thanks to John T Kohl, who also corrected VMIN = VTIME = 0. 11 * Kill-line thanks to John T Kohl, who also corrected VMIN = VTIME = 0.
12 * 12 *
13 * Modified by Theodore Ts'o, 9/14/92, to dynamically allocate the 13 * Modified by Theodore Ts'o, 9/14/92, to dynamically allocate the
14 * tty_struct and tty_queue structures. Previously there was an array 14 * tty_struct and tty_queue structures. Previously there was an array
15 * of 256 tty_struct's which was statically allocated, and the 15 * of 256 tty_struct's which was statically allocated, and the
16 * tty_queue structures were allocated at boot time. Both are now 16 * tty_queue structures were allocated at boot time. Both are now
17 * dynamically allocated only when the tty is open. 17 * dynamically allocated only when the tty is open.
18 * 18 *
19 * Also restructured routines so that there is more of a separation 19 * Also restructured routines so that there is more of a separation
20 * between the high-level tty routines (tty_io.c and tty_ioctl.c) and 20 * between the high-level tty routines (tty_io.c and tty_ioctl.c) and
21 * the low-level tty routines (serial.c, pty.c, console.c). This 21 * the low-level tty routines (serial.c, pty.c, console.c). This
22 * makes for cleaner and more compact code. -TYT, 9/17/92 22 * makes for cleaner and more compact code. -TYT, 9/17/92
23 * 23 *
24 * Modified by Fred N. van Kempen, 01/29/93, to add line disciplines 24 * Modified by Fred N. van Kempen, 01/29/93, to add line disciplines
25 * which can be dynamically activated and de-activated by the line 25 * which can be dynamically activated and de-activated by the line
26 * discipline handling modules (like SLIP). 26 * discipline handling modules (like SLIP).
27 * 27 *
28 * NOTE: pay no attention to the line discipline code (yet); its 28 * NOTE: pay no attention to the line discipline code (yet); its
29 * interface is still subject to change in this version... 29 * interface is still subject to change in this version...
30 * -- TYT, 1/31/92 30 * -- TYT, 1/31/92
31 * 31 *
32 * Added functionality to the OPOST tty handling. No delays, but all 32 * Added functionality to the OPOST tty handling. No delays, but all
33 * other bits should be there. 33 * other bits should be there.
34 * -- Nick Holloway <alfie@dcs.warwick.ac.uk>, 27th May 1993. 34 * -- Nick Holloway <alfie@dcs.warwick.ac.uk>, 27th May 1993.
35 * 35 *
36 * Rewrote canonical mode and added more termios flags. 36 * Rewrote canonical mode and added more termios flags.
37 * -- julian@uhunix.uhcc.hawaii.edu (J. Cowley), 13Jan94 37 * -- julian@uhunix.uhcc.hawaii.edu (J. Cowley), 13Jan94
38 * 38 *
39 * Reorganized FASYNC support so mouse code can share it. 39 * Reorganized FASYNC support so mouse code can share it.
40 * -- ctm@ardi.com, 9Sep95 40 * -- ctm@ardi.com, 9Sep95
41 * 41 *
42 * New TIOCLINUX variants added. 42 * New TIOCLINUX variants added.
43 * -- mj@k332.feld.cvut.cz, 19-Nov-95 43 * -- mj@k332.feld.cvut.cz, 19-Nov-95
44 * 44 *
45 * Restrict vt switching via ioctl() 45 * Restrict vt switching via ioctl()
46 * -- grif@cs.ucr.edu, 5-Dec-95 46 * -- grif@cs.ucr.edu, 5-Dec-95
47 * 47 *
48 * Move console and virtual terminal code to more appropriate files, 48 * Move console and virtual terminal code to more appropriate files,
49 * implement CONFIG_VT and generalize console device interface. 49 * implement CONFIG_VT and generalize console device interface.
50 * -- Marko Kohtala <Marko.Kohtala@hut.fi>, March 97 50 * -- Marko Kohtala <Marko.Kohtala@hut.fi>, March 97
51 * 51 *
52 * Rewrote tty_init_dev and tty_release_dev to eliminate races. 52 * Rewrote tty_init_dev and tty_release_dev to eliminate races.
53 * -- Bill Hawes <whawes@star.net>, June 97 53 * -- Bill Hawes <whawes@star.net>, June 97
54 * 54 *
55 * Added devfs support. 55 * Added devfs support.
56 * -- C. Scott Ananian <cananian@alumni.princeton.edu>, 13-Jan-1998 56 * -- C. Scott Ananian <cananian@alumni.princeton.edu>, 13-Jan-1998
57 * 57 *
58 * Added support for a Unix98-style ptmx device. 58 * Added support for a Unix98-style ptmx device.
59 * -- C. Scott Ananian <cananian@alumni.princeton.edu>, 14-Jan-1998 59 * -- C. Scott Ananian <cananian@alumni.princeton.edu>, 14-Jan-1998
60 * 60 *
61 * Reduced memory usage for older ARM systems 61 * Reduced memory usage for older ARM systems
62 * -- Russell King <rmk@arm.linux.org.uk> 62 * -- Russell King <rmk@arm.linux.org.uk>
63 * 63 *
64 * Move do_SAK() into process context. Less stack use in devfs functions. 64 * Move do_SAK() into process context. Less stack use in devfs functions.
65 * alloc_tty_struct() always uses kmalloc() 65 * alloc_tty_struct() always uses kmalloc()
66 * -- Andrew Morton <andrewm@uow.edu.eu> 17Mar01 66 * -- Andrew Morton <andrewm@uow.edu.eu> 17Mar01
67 */ 67 */
68 68
69 #include <linux/types.h> 69 #include <linux/types.h>
70 #include <linux/major.h> 70 #include <linux/major.h>
71 #include <linux/errno.h> 71 #include <linux/errno.h>
72 #include <linux/signal.h> 72 #include <linux/signal.h>
73 #include <linux/fcntl.h> 73 #include <linux/fcntl.h>
74 #include <linux/sched.h> 74 #include <linux/sched.h>
75 #include <linux/interrupt.h> 75 #include <linux/interrupt.h>
76 #include <linux/tty.h> 76 #include <linux/tty.h>
77 #include <linux/tty_driver.h> 77 #include <linux/tty_driver.h>
78 #include <linux/tty_flip.h> 78 #include <linux/tty_flip.h>
79 #include <linux/devpts_fs.h> 79 #include <linux/devpts_fs.h>
80 #include <linux/file.h> 80 #include <linux/file.h>
81 #include <linux/fdtable.h> 81 #include <linux/fdtable.h>
82 #include <linux/console.h> 82 #include <linux/console.h>
83 #include <linux/timer.h> 83 #include <linux/timer.h>
84 #include <linux/ctype.h> 84 #include <linux/ctype.h>
85 #include <linux/kd.h> 85 #include <linux/kd.h>
86 #include <linux/mm.h> 86 #include <linux/mm.h>
87 #include <linux/string.h> 87 #include <linux/string.h>
88 #include <linux/slab.h> 88 #include <linux/slab.h>
89 #include <linux/poll.h> 89 #include <linux/poll.h>
90 #include <linux/proc_fs.h> 90 #include <linux/proc_fs.h>
91 #include <linux/init.h> 91 #include <linux/init.h>
92 #include <linux/module.h> 92 #include <linux/module.h>
93 #include <linux/smp_lock.h> 93 #include <linux/smp_lock.h>
94 #include <linux/device.h> 94 #include <linux/device.h>
95 #include <linux/wait.h> 95 #include <linux/wait.h>
96 #include <linux/bitops.h> 96 #include <linux/bitops.h>
97 #include <linux/delay.h> 97 #include <linux/delay.h>
98 #include <linux/seq_file.h> 98 #include <linux/seq_file.h>
99 99
100 #include <linux/uaccess.h> 100 #include <linux/uaccess.h>
101 #include <asm/system.h> 101 #include <asm/system.h>
102 102
103 #include <linux/kbd_kern.h> 103 #include <linux/kbd_kern.h>
104 #include <linux/vt_kern.h> 104 #include <linux/vt_kern.h>
105 #include <linux/selection.h> 105 #include <linux/selection.h>
106 106
107 #include <linux/kmod.h> 107 #include <linux/kmod.h>
108 #include <linux/nsproxy.h> 108 #include <linux/nsproxy.h>
109 109
110 #undef TTY_DEBUG_HANGUP 110 #undef TTY_DEBUG_HANGUP
111 111
112 #define TTY_PARANOIA_CHECK 1 112 #define TTY_PARANOIA_CHECK 1
113 #define CHECK_TTY_COUNT 1 113 #define CHECK_TTY_COUNT 1
114 114
115 struct ktermios tty_std_termios = { /* for the benefit of tty drivers */ 115 struct ktermios tty_std_termios = { /* for the benefit of tty drivers */
116 .c_iflag = ICRNL | IXON, 116 .c_iflag = ICRNL | IXON,
117 .c_oflag = OPOST | ONLCR, 117 .c_oflag = OPOST | ONLCR,
118 .c_cflag = B38400 | CS8 | CREAD | HUPCL, 118 .c_cflag = B38400 | CS8 | CREAD | HUPCL,
119 .c_lflag = ISIG | ICANON | ECHO | ECHOE | ECHOK | 119 .c_lflag = ISIG | ICANON | ECHO | ECHOE | ECHOK |
120 ECHOCTL | ECHOKE | IEXTEN, 120 ECHOCTL | ECHOKE | IEXTEN,
121 .c_cc = INIT_C_CC, 121 .c_cc = INIT_C_CC,
122 .c_ispeed = 38400, 122 .c_ispeed = 38400,
123 .c_ospeed = 38400 123 .c_ospeed = 38400
124 }; 124 };
125 125
126 EXPORT_SYMBOL(tty_std_termios); 126 EXPORT_SYMBOL(tty_std_termios);
127 127
128 /* This list gets poked at by procfs and various bits of boot up code. This 128 /* This list gets poked at by procfs and various bits of boot up code. This
129 could do with some rationalisation such as pulling the tty proc function 129 could do with some rationalisation such as pulling the tty proc function
130 into this file */ 130 into this file */
131 131
132 LIST_HEAD(tty_drivers); /* linked list of tty drivers */ 132 LIST_HEAD(tty_drivers); /* linked list of tty drivers */
133 133
134 /* Mutex to protect creating and releasing a tty. This is shared with 134 /* Mutex to protect creating and releasing a tty. This is shared with
135 vt.c for deeply disgusting hack reasons */ 135 vt.c for deeply disgusting hack reasons */
136 DEFINE_MUTEX(tty_mutex); 136 DEFINE_MUTEX(tty_mutex);
137 EXPORT_SYMBOL(tty_mutex); 137 EXPORT_SYMBOL(tty_mutex);
138 138
139 static ssize_t tty_read(struct file *, char __user *, size_t, loff_t *); 139 static ssize_t tty_read(struct file *, char __user *, size_t, loff_t *);
140 static ssize_t tty_write(struct file *, const char __user *, size_t, loff_t *); 140 static ssize_t tty_write(struct file *, const char __user *, size_t, loff_t *);
141 ssize_t redirected_tty_write(struct file *, const char __user *, 141 ssize_t redirected_tty_write(struct file *, const char __user *,
142 size_t, loff_t *); 142 size_t, loff_t *);
143 static unsigned int tty_poll(struct file *, poll_table *); 143 static unsigned int tty_poll(struct file *, poll_table *);
144 static int tty_open(struct inode *, struct file *); 144 static int tty_open(struct inode *, struct file *);
145 long tty_ioctl(struct file *file, unsigned int cmd, unsigned long arg); 145 long tty_ioctl(struct file *file, unsigned int cmd, unsigned long arg);
146 #ifdef CONFIG_COMPAT 146 #ifdef CONFIG_COMPAT
147 static long tty_compat_ioctl(struct file *file, unsigned int cmd, 147 static long tty_compat_ioctl(struct file *file, unsigned int cmd,
148 unsigned long arg); 148 unsigned long arg);
149 #else 149 #else
150 #define tty_compat_ioctl NULL 150 #define tty_compat_ioctl NULL
151 #endif 151 #endif
152 static int tty_fasync(int fd, struct file *filp, int on); 152 static int tty_fasync(int fd, struct file *filp, int on);
153 static void release_tty(struct tty_struct *tty, int idx); 153 static void release_tty(struct tty_struct *tty, int idx);
154 static void __proc_set_tty(struct task_struct *tsk, struct tty_struct *tty); 154 static void __proc_set_tty(struct task_struct *tsk, struct tty_struct *tty);
155 static void proc_set_tty(struct task_struct *tsk, struct tty_struct *tty); 155 static void proc_set_tty(struct task_struct *tsk, struct tty_struct *tty);
156 156
157 /** 157 /**
158 * alloc_tty_struct - allocate a tty object 158 * alloc_tty_struct - allocate a tty object
159 * 159 *
160 * Return a new empty tty structure. The data fields have not 160 * Return a new empty tty structure. The data fields have not
161 * been initialized in any way but has been zeroed 161 * been initialized in any way but has been zeroed
162 * 162 *
163 * Locking: none 163 * Locking: none
164 */ 164 */
165 165
166 struct tty_struct *alloc_tty_struct(void) 166 struct tty_struct *alloc_tty_struct(void)
167 { 167 {
168 return kzalloc(sizeof(struct tty_struct), GFP_KERNEL); 168 return kzalloc(sizeof(struct tty_struct), GFP_KERNEL);
169 } 169 }
170 170
171 /** 171 /**
172 * free_tty_struct - free a disused tty 172 * free_tty_struct - free a disused tty
173 * @tty: tty struct to free 173 * @tty: tty struct to free
174 * 174 *
175 * Free the write buffers, tty queue and tty memory itself. 175 * Free the write buffers, tty queue and tty memory itself.
176 * 176 *
177 * Locking: none. Must be called after tty is definitely unused 177 * Locking: none. Must be called after tty is definitely unused
178 */ 178 */
179 179
180 void free_tty_struct(struct tty_struct *tty) 180 void free_tty_struct(struct tty_struct *tty)
181 { 181 {
182 kfree(tty->write_buf); 182 kfree(tty->write_buf);
183 tty_buffer_free_all(tty); 183 tty_buffer_free_all(tty);
184 kfree(tty); 184 kfree(tty);
185 } 185 }
186 186
187 #define TTY_NUMBER(tty) ((tty)->index + (tty)->driver->name_base) 187 #define TTY_NUMBER(tty) ((tty)->index + (tty)->driver->name_base)
188 188
189 /** 189 /**
190 * tty_name - return tty naming 190 * tty_name - return tty naming
191 * @tty: tty structure 191 * @tty: tty structure
192 * @buf: buffer for output 192 * @buf: buffer for output
193 * 193 *
194 * Convert a tty structure into a name. The name reflects the kernel 194 * Convert a tty structure into a name. The name reflects the kernel
195 * naming policy and if udev is in use may not reflect user space 195 * naming policy and if udev is in use may not reflect user space
196 * 196 *
197 * Locking: none 197 * Locking: none
198 */ 198 */
199 199
200 char *tty_name(struct tty_struct *tty, char *buf) 200 char *tty_name(struct tty_struct *tty, char *buf)
201 { 201 {
202 if (!tty) /* Hmm. NULL pointer. That's fun. */ 202 if (!tty) /* Hmm. NULL pointer. That's fun. */
203 strcpy(buf, "NULL tty"); 203 strcpy(buf, "NULL tty");
204 else 204 else
205 strcpy(buf, tty->name); 205 strcpy(buf, tty->name);
206 return buf; 206 return buf;
207 } 207 }
208 208
209 EXPORT_SYMBOL(tty_name); 209 EXPORT_SYMBOL(tty_name);
210 210
211 int tty_paranoia_check(struct tty_struct *tty, struct inode *inode, 211 int tty_paranoia_check(struct tty_struct *tty, struct inode *inode,
212 const char *routine) 212 const char *routine)
213 { 213 {
214 #ifdef TTY_PARANOIA_CHECK 214 #ifdef TTY_PARANOIA_CHECK
215 if (!tty) { 215 if (!tty) {
216 printk(KERN_WARNING 216 printk(KERN_WARNING
217 "null TTY for (%d:%d) in %s\n", 217 "null TTY for (%d:%d) in %s\n",
218 imajor(inode), iminor(inode), routine); 218 imajor(inode), iminor(inode), routine);
219 return 1; 219 return 1;
220 } 220 }
221 if (tty->magic != TTY_MAGIC) { 221 if (tty->magic != TTY_MAGIC) {
222 printk(KERN_WARNING 222 printk(KERN_WARNING
223 "bad magic number for tty struct (%d:%d) in %s\n", 223 "bad magic number for tty struct (%d:%d) in %s\n",
224 imajor(inode), iminor(inode), routine); 224 imajor(inode), iminor(inode), routine);
225 return 1; 225 return 1;
226 } 226 }
227 #endif 227 #endif
228 return 0; 228 return 0;
229 } 229 }
230 230
231 static int check_tty_count(struct tty_struct *tty, const char *routine) 231 static int check_tty_count(struct tty_struct *tty, const char *routine)
232 { 232 {
233 #ifdef CHECK_TTY_COUNT 233 #ifdef CHECK_TTY_COUNT
234 struct list_head *p; 234 struct list_head *p;
235 int count = 0; 235 int count = 0;
236 236
237 file_list_lock(); 237 file_list_lock();
238 list_for_each(p, &tty->tty_files) { 238 list_for_each(p, &tty->tty_files) {
239 count++; 239 count++;
240 } 240 }
241 file_list_unlock(); 241 file_list_unlock();
242 if (tty->driver->type == TTY_DRIVER_TYPE_PTY && 242 if (tty->driver->type == TTY_DRIVER_TYPE_PTY &&
243 tty->driver->subtype == PTY_TYPE_SLAVE && 243 tty->driver->subtype == PTY_TYPE_SLAVE &&
244 tty->link && tty->link->count) 244 tty->link && tty->link->count)
245 count++; 245 count++;
246 if (tty->count != count) { 246 if (tty->count != count) {
247 printk(KERN_WARNING "Warning: dev (%s) tty->count(%d) " 247 printk(KERN_WARNING "Warning: dev (%s) tty->count(%d) "
248 "!= #fd's(%d) in %s\n", 248 "!= #fd's(%d) in %s\n",
249 tty->name, tty->count, count, routine); 249 tty->name, tty->count, count, routine);
250 return count; 250 return count;
251 } 251 }
252 #endif 252 #endif
253 return 0; 253 return 0;
254 } 254 }
255 255
256 /** 256 /**
257 * get_tty_driver - find device of a tty 257 * get_tty_driver - find device of a tty
258 * @dev_t: device identifier 258 * @dev_t: device identifier
259 * @index: returns the index of the tty 259 * @index: returns the index of the tty
260 * 260 *
261 * This routine returns a tty driver structure, given a device number 261 * This routine returns a tty driver structure, given a device number
262 * and also passes back the index number. 262 * and also passes back the index number.
263 * 263 *
264 * Locking: caller must hold tty_mutex 264 * Locking: caller must hold tty_mutex
265 */ 265 */
266 266
267 static struct tty_driver *get_tty_driver(dev_t device, int *index) 267 static struct tty_driver *get_tty_driver(dev_t device, int *index)
268 { 268 {
269 struct tty_driver *p; 269 struct tty_driver *p;
270 270
271 list_for_each_entry(p, &tty_drivers, tty_drivers) { 271 list_for_each_entry(p, &tty_drivers, tty_drivers) {
272 dev_t base = MKDEV(p->major, p->minor_start); 272 dev_t base = MKDEV(p->major, p->minor_start);
273 if (device < base || device >= base + p->num) 273 if (device < base || device >= base + p->num)
274 continue; 274 continue;
275 *index = device - base; 275 *index = device - base;
276 return tty_driver_kref_get(p); 276 return tty_driver_kref_get(p);
277 } 277 }
278 return NULL; 278 return NULL;
279 } 279 }
280 280
281 #ifdef CONFIG_CONSOLE_POLL 281 #ifdef CONFIG_CONSOLE_POLL
282 282
283 /** 283 /**
284 * tty_find_polling_driver - find device of a polled tty 284 * tty_find_polling_driver - find device of a polled tty
285 * @name: name string to match 285 * @name: name string to match
286 * @line: pointer to resulting tty line nr 286 * @line: pointer to resulting tty line nr
287 * 287 *
288 * This routine returns a tty driver structure, given a name 288 * This routine returns a tty driver structure, given a name
289 * and the condition that the tty driver is capable of polled 289 * and the condition that the tty driver is capable of polled
290 * operation. 290 * operation.
291 */ 291 */
292 struct tty_driver *tty_find_polling_driver(char *name, int *line) 292 struct tty_driver *tty_find_polling_driver(char *name, int *line)
293 { 293 {
294 struct tty_driver *p, *res = NULL; 294 struct tty_driver *p, *res = NULL;
295 int tty_line = 0; 295 int tty_line = 0;
296 int len; 296 int len;
297 char *str, *stp; 297 char *str, *stp;
298 298
299 for (str = name; *str; str++) 299 for (str = name; *str; str++)
300 if ((*str >= '0' && *str <= '9') || *str == ',') 300 if ((*str >= '0' && *str <= '9') || *str == ',')
301 break; 301 break;
302 if (!*str) 302 if (!*str)
303 return NULL; 303 return NULL;
304 304
305 len = str - name; 305 len = str - name;
306 tty_line = simple_strtoul(str, &str, 10); 306 tty_line = simple_strtoul(str, &str, 10);
307 307
308 mutex_lock(&tty_mutex); 308 mutex_lock(&tty_mutex);
309 /* Search through the tty devices to look for a match */ 309 /* Search through the tty devices to look for a match */
310 list_for_each_entry(p, &tty_drivers, tty_drivers) { 310 list_for_each_entry(p, &tty_drivers, tty_drivers) {
311 if (strncmp(name, p->name, len) != 0) 311 if (strncmp(name, p->name, len) != 0)
312 continue; 312 continue;
313 stp = str; 313 stp = str;
314 if (*stp == ',') 314 if (*stp == ',')
315 stp++; 315 stp++;
316 if (*stp == '\0') 316 if (*stp == '\0')
317 stp = NULL; 317 stp = NULL;
318 318
319 if (tty_line >= 0 && tty_line <= p->num && p->ops && 319 if (tty_line >= 0 && tty_line <= p->num && p->ops &&
320 p->ops->poll_init && !p->ops->poll_init(p, tty_line, stp)) { 320 p->ops->poll_init && !p->ops->poll_init(p, tty_line, stp)) {
321 res = tty_driver_kref_get(p); 321 res = tty_driver_kref_get(p);
322 *line = tty_line; 322 *line = tty_line;
323 break; 323 break;
324 } 324 }
325 } 325 }
326 mutex_unlock(&tty_mutex); 326 mutex_unlock(&tty_mutex);
327 327
328 return res; 328 return res;
329 } 329 }
330 EXPORT_SYMBOL_GPL(tty_find_polling_driver); 330 EXPORT_SYMBOL_GPL(tty_find_polling_driver);
331 #endif 331 #endif
332 332
333 /** 333 /**
334 * tty_check_change - check for POSIX terminal changes 334 * tty_check_change - check for POSIX terminal changes
335 * @tty: tty to check 335 * @tty: tty to check
336 * 336 *
337 * If we try to write to, or set the state of, a terminal and we're 337 * If we try to write to, or set the state of, a terminal and we're
338 * not in the foreground, send a SIGTTOU. If the signal is blocked or 338 * not in the foreground, send a SIGTTOU. If the signal is blocked or
339 * ignored, go ahead and perform the operation. (POSIX 7.2) 339 * ignored, go ahead and perform the operation. (POSIX 7.2)
340 * 340 *
341 * Locking: ctrl_lock 341 * Locking: ctrl_lock
342 */ 342 */
343 343
344 int tty_check_change(struct tty_struct *tty) 344 int tty_check_change(struct tty_struct *tty)
345 { 345 {
346 unsigned long flags; 346 unsigned long flags;
347 int ret = 0; 347 int ret = 0;
348 348
349 if (current->signal->tty != tty) 349 if (current->signal->tty != tty)
350 return 0; 350 return 0;
351 351
352 spin_lock_irqsave(&tty->ctrl_lock, flags); 352 spin_lock_irqsave(&tty->ctrl_lock, flags);
353 353
354 if (!tty->pgrp) { 354 if (!tty->pgrp) {
355 printk(KERN_WARNING "tty_check_change: tty->pgrp == NULL!\n"); 355 printk(KERN_WARNING "tty_check_change: tty->pgrp == NULL!\n");
356 goto out_unlock; 356 goto out_unlock;
357 } 357 }
358 if (task_pgrp(current) == tty->pgrp) 358 if (task_pgrp(current) == tty->pgrp)
359 goto out_unlock; 359 goto out_unlock;
360 spin_unlock_irqrestore(&tty->ctrl_lock, flags); 360 spin_unlock_irqrestore(&tty->ctrl_lock, flags);
361 if (is_ignored(SIGTTOU)) 361 if (is_ignored(SIGTTOU))
362 goto out; 362 goto out;
363 if (is_current_pgrp_orphaned()) { 363 if (is_current_pgrp_orphaned()) {
364 ret = -EIO; 364 ret = -EIO;
365 goto out; 365 goto out;
366 } 366 }
367 kill_pgrp(task_pgrp(current), SIGTTOU, 1); 367 kill_pgrp(task_pgrp(current), SIGTTOU, 1);
368 set_thread_flag(TIF_SIGPENDING); 368 set_thread_flag(TIF_SIGPENDING);
369 ret = -ERESTARTSYS; 369 ret = -ERESTARTSYS;
370 out: 370 out:
371 return ret; 371 return ret;
372 out_unlock: 372 out_unlock:
373 spin_unlock_irqrestore(&tty->ctrl_lock, flags); 373 spin_unlock_irqrestore(&tty->ctrl_lock, flags);
374 return ret; 374 return ret;
375 } 375 }
376 376
377 EXPORT_SYMBOL(tty_check_change); 377 EXPORT_SYMBOL(tty_check_change);
378 378
379 static ssize_t hung_up_tty_read(struct file *file, char __user *buf, 379 static ssize_t hung_up_tty_read(struct file *file, char __user *buf,
380 size_t count, loff_t *ppos) 380 size_t count, loff_t *ppos)
381 { 381 {
382 return 0; 382 return 0;
383 } 383 }
384 384
385 static ssize_t hung_up_tty_write(struct file *file, const char __user *buf, 385 static ssize_t hung_up_tty_write(struct file *file, const char __user *buf,
386 size_t count, loff_t *ppos) 386 size_t count, loff_t *ppos)
387 { 387 {
388 return -EIO; 388 return -EIO;
389 } 389 }
390 390
391 /* No kernel lock held - none needed ;) */ 391 /* No kernel lock held - none needed ;) */
392 static unsigned int hung_up_tty_poll(struct file *filp, poll_table *wait) 392 static unsigned int hung_up_tty_poll(struct file *filp, poll_table *wait)
393 { 393 {
394 return POLLIN | POLLOUT | POLLERR | POLLHUP | POLLRDNORM | POLLWRNORM; 394 return POLLIN | POLLOUT | POLLERR | POLLHUP | POLLRDNORM | POLLWRNORM;
395 } 395 }
396 396
397 static long hung_up_tty_ioctl(struct file *file, unsigned int cmd, 397 static long hung_up_tty_ioctl(struct file *file, unsigned int cmd,
398 unsigned long arg) 398 unsigned long arg)
399 { 399 {
400 return cmd == TIOCSPGRP ? -ENOTTY : -EIO; 400 return cmd == TIOCSPGRP ? -ENOTTY : -EIO;
401 } 401 }
402 402
403 static long hung_up_tty_compat_ioctl(struct file *file, 403 static long hung_up_tty_compat_ioctl(struct file *file,
404 unsigned int cmd, unsigned long arg) 404 unsigned int cmd, unsigned long arg)
405 { 405 {
406 return cmd == TIOCSPGRP ? -ENOTTY : -EIO; 406 return cmd == TIOCSPGRP ? -ENOTTY : -EIO;
407 } 407 }
408 408
409 static const struct file_operations tty_fops = { 409 static const struct file_operations tty_fops = {
410 .llseek = no_llseek, 410 .llseek = no_llseek,
411 .read = tty_read, 411 .read = tty_read,
412 .write = tty_write, 412 .write = tty_write,
413 .poll = tty_poll, 413 .poll = tty_poll,
414 .unlocked_ioctl = tty_ioctl, 414 .unlocked_ioctl = tty_ioctl,
415 .compat_ioctl = tty_compat_ioctl, 415 .compat_ioctl = tty_compat_ioctl,
416 .open = tty_open, 416 .open = tty_open,
417 .release = tty_release, 417 .release = tty_release,
418 .fasync = tty_fasync, 418 .fasync = tty_fasync,
419 }; 419 };
420 420
421 static const struct file_operations console_fops = { 421 static const struct file_operations console_fops = {
422 .llseek = no_llseek, 422 .llseek = no_llseek,
423 .read = tty_read, 423 .read = tty_read,
424 .write = redirected_tty_write, 424 .write = redirected_tty_write,
425 .poll = tty_poll, 425 .poll = tty_poll,
426 .unlocked_ioctl = tty_ioctl, 426 .unlocked_ioctl = tty_ioctl,
427 .compat_ioctl = tty_compat_ioctl, 427 .compat_ioctl = tty_compat_ioctl,
428 .open = tty_open, 428 .open = tty_open,
429 .release = tty_release, 429 .release = tty_release,
430 .fasync = tty_fasync, 430 .fasync = tty_fasync,
431 }; 431 };
432 432
433 static const struct file_operations hung_up_tty_fops = { 433 static const struct file_operations hung_up_tty_fops = {
434 .llseek = no_llseek, 434 .llseek = no_llseek,
435 .read = hung_up_tty_read, 435 .read = hung_up_tty_read,
436 .write = hung_up_tty_write, 436 .write = hung_up_tty_write,
437 .poll = hung_up_tty_poll, 437 .poll = hung_up_tty_poll,
438 .unlocked_ioctl = hung_up_tty_ioctl, 438 .unlocked_ioctl = hung_up_tty_ioctl,
439 .compat_ioctl = hung_up_tty_compat_ioctl, 439 .compat_ioctl = hung_up_tty_compat_ioctl,
440 .release = tty_release, 440 .release = tty_release,
441 }; 441 };
442 442
443 static DEFINE_SPINLOCK(redirect_lock); 443 static DEFINE_SPINLOCK(redirect_lock);
444 static struct file *redirect; 444 static struct file *redirect;
445 445
446 /** 446 /**
447 * tty_wakeup - request more data 447 * tty_wakeup - request more data
448 * @tty: terminal 448 * @tty: terminal
449 * 449 *
450 * Internal and external helper for wakeups of tty. This function 450 * Internal and external helper for wakeups of tty. This function
451 * informs the line discipline if present that the driver is ready 451 * informs the line discipline if present that the driver is ready
452 * to receive more output data. 452 * to receive more output data.
453 */ 453 */
454 454
455 void tty_wakeup(struct tty_struct *tty) 455 void tty_wakeup(struct tty_struct *tty)
456 { 456 {
457 struct tty_ldisc *ld; 457 struct tty_ldisc *ld;
458 458
459 if (test_bit(TTY_DO_WRITE_WAKEUP, &tty->flags)) { 459 if (test_bit(TTY_DO_WRITE_WAKEUP, &tty->flags)) {
460 ld = tty_ldisc_ref(tty); 460 ld = tty_ldisc_ref(tty);
461 if (ld) { 461 if (ld) {
462 if (ld->ops->write_wakeup) 462 if (ld->ops->write_wakeup)
463 ld->ops->write_wakeup(tty); 463 ld->ops->write_wakeup(tty);
464 tty_ldisc_deref(ld); 464 tty_ldisc_deref(ld);
465 } 465 }
466 } 466 }
467 wake_up_interruptible_poll(&tty->write_wait, POLLOUT); 467 wake_up_interruptible_poll(&tty->write_wait, POLLOUT);
468 } 468 }
469 469
470 EXPORT_SYMBOL_GPL(tty_wakeup); 470 EXPORT_SYMBOL_GPL(tty_wakeup);
471 471
472 /** 472 /**
473 * do_tty_hangup - actual handler for hangup events 473 * do_tty_hangup - actual handler for hangup events
474 * @work: tty device 474 * @work: tty device
475 * 475 *
476 * This can be called by the "eventd" kernel thread. That is process 476 * This can be called by the "eventd" kernel thread. That is process
477 * synchronous but doesn't hold any locks, so we need to make sure we 477 * synchronous but doesn't hold any locks, so we need to make sure we
478 * have the appropriate locks for what we're doing. 478 * have the appropriate locks for what we're doing.
479 * 479 *
480 * The hangup event clears any pending redirections onto the hung up 480 * The hangup event clears any pending redirections onto the hung up
481 * device. It ensures future writes will error and it does the needed 481 * device. It ensures future writes will error and it does the needed
482 * line discipline hangup and signal delivery. The tty object itself 482 * line discipline hangup and signal delivery. The tty object itself
483 * remains intact. 483 * remains intact.
484 * 484 *
485 * Locking: 485 * Locking:
486 * BKL 486 * BKL
487 * redirect lock for undoing redirection 487 * redirect lock for undoing redirection
488 * file list lock for manipulating list of ttys 488 * file list lock for manipulating list of ttys
489 * tty_ldisc_lock from called functions 489 * tty_ldisc_lock from called functions
490 * termios_mutex resetting termios data 490 * termios_mutex resetting termios data
491 * tasklist_lock to walk task list for hangup event 491 * tasklist_lock to walk task list for hangup event
492 * ->siglock to protect ->signal/->sighand 492 * ->siglock to protect ->signal/->sighand
493 */ 493 */
494 static void do_tty_hangup(struct work_struct *work) 494 static void do_tty_hangup(struct work_struct *work)
495 { 495 {
496 struct tty_struct *tty = 496 struct tty_struct *tty =
497 container_of(work, struct tty_struct, hangup_work); 497 container_of(work, struct tty_struct, hangup_work);
498 struct file *cons_filp = NULL; 498 struct file *cons_filp = NULL;
499 struct file *filp, *f = NULL; 499 struct file *filp, *f = NULL;
500 struct task_struct *p; 500 struct task_struct *p;
501 int closecount = 0, n; 501 int closecount = 0, n;
502 unsigned long flags; 502 unsigned long flags;
503 int refs = 0; 503 int refs = 0;
504 504
505 if (!tty) 505 if (!tty)
506 return; 506 return;
507 507
508 /* inuse_filps is protected by the single kernel lock */
509 lock_kernel();
510 508
511 spin_lock(&redirect_lock); 509 spin_lock(&redirect_lock);
512 if (redirect && redirect->private_data == tty) { 510 if (redirect && redirect->private_data == tty) {
513 f = redirect; 511 f = redirect;
514 redirect = NULL; 512 redirect = NULL;
515 } 513 }
516 spin_unlock(&redirect_lock); 514 spin_unlock(&redirect_lock);
517 515
516 /* inuse_filps is protected by the single kernel lock */
517 lock_kernel();
518 check_tty_count(tty, "do_tty_hangup"); 518 check_tty_count(tty, "do_tty_hangup");
519 file_list_lock(); 519 file_list_lock();
520 /* This breaks for file handles being sent over AF_UNIX sockets ? */ 520 /* This breaks for file handles being sent over AF_UNIX sockets ? */
521 list_for_each_entry(filp, &tty->tty_files, f_u.fu_list) { 521 list_for_each_entry(filp, &tty->tty_files, f_u.fu_list) {
522 if (filp->f_op->write == redirected_tty_write) 522 if (filp->f_op->write == redirected_tty_write)
523 cons_filp = filp; 523 cons_filp = filp;
524 if (filp->f_op->write != tty_write) 524 if (filp->f_op->write != tty_write)
525 continue; 525 continue;
526 closecount++; 526 closecount++;
527 tty_fasync(-1, filp, 0); /* can't block */ 527 tty_fasync(-1, filp, 0); /* can't block */
528 filp->f_op = &hung_up_tty_fops; 528 filp->f_op = &hung_up_tty_fops;
529 } 529 }
530 file_list_unlock(); 530 file_list_unlock();
531 531
532 tty_ldisc_hangup(tty); 532 tty_ldisc_hangup(tty);
533 533
534 read_lock(&tasklist_lock); 534 read_lock(&tasklist_lock);
535 if (tty->session) { 535 if (tty->session) {
536 do_each_pid_task(tty->session, PIDTYPE_SID, p) { 536 do_each_pid_task(tty->session, PIDTYPE_SID, p) {
537 spin_lock_irq(&p->sighand->siglock); 537 spin_lock_irq(&p->sighand->siglock);
538 if (p->signal->tty == tty) { 538 if (p->signal->tty == tty) {
539 p->signal->tty = NULL; 539 p->signal->tty = NULL;
540 /* We defer the dereferences outside fo 540 /* We defer the dereferences outside fo
541 the tasklist lock */ 541 the tasklist lock */
542 refs++; 542 refs++;
543 } 543 }
544 if (!p->signal->leader) { 544 if (!p->signal->leader) {
545 spin_unlock_irq(&p->sighand->siglock); 545 spin_unlock_irq(&p->sighand->siglock);
546 continue; 546 continue;
547 } 547 }
548 __group_send_sig_info(SIGHUP, SEND_SIG_PRIV, p); 548 __group_send_sig_info(SIGHUP, SEND_SIG_PRIV, p);
549 __group_send_sig_info(SIGCONT, SEND_SIG_PRIV, p); 549 __group_send_sig_info(SIGCONT, SEND_SIG_PRIV, p);
550 put_pid(p->signal->tty_old_pgrp); /* A noop */ 550 put_pid(p->signal->tty_old_pgrp); /* A noop */
551 spin_lock_irqsave(&tty->ctrl_lock, flags); 551 spin_lock_irqsave(&tty->ctrl_lock, flags);
552 if (tty->pgrp) 552 if (tty->pgrp)
553 p->signal->tty_old_pgrp = get_pid(tty->pgrp); 553 p->signal->tty_old_pgrp = get_pid(tty->pgrp);
554 spin_unlock_irqrestore(&tty->ctrl_lock, flags); 554 spin_unlock_irqrestore(&tty->ctrl_lock, flags);
555 spin_unlock_irq(&p->sighand->siglock); 555 spin_unlock_irq(&p->sighand->siglock);
556 } while_each_pid_task(tty->session, PIDTYPE_SID, p); 556 } while_each_pid_task(tty->session, PIDTYPE_SID, p);
557 } 557 }
558 read_unlock(&tasklist_lock); 558 read_unlock(&tasklist_lock);
559 559
560 spin_lock_irqsave(&tty->ctrl_lock, flags); 560 spin_lock_irqsave(&tty->ctrl_lock, flags);
561 clear_bit(TTY_THROTTLED, &tty->flags); 561 clear_bit(TTY_THROTTLED, &tty->flags);
562 clear_bit(TTY_PUSH, &tty->flags); 562 clear_bit(TTY_PUSH, &tty->flags);
563 clear_bit(TTY_DO_WRITE_WAKEUP, &tty->flags); 563 clear_bit(TTY_DO_WRITE_WAKEUP, &tty->flags);
564 put_pid(tty->session); 564 put_pid(tty->session);
565 put_pid(tty->pgrp); 565 put_pid(tty->pgrp);
566 tty->session = NULL; 566 tty->session = NULL;
567 tty->pgrp = NULL; 567 tty->pgrp = NULL;
568 tty->ctrl_status = 0; 568 tty->ctrl_status = 0;
569 set_bit(TTY_HUPPED, &tty->flags); 569 set_bit(TTY_HUPPED, &tty->flags);
570 spin_unlock_irqrestore(&tty->ctrl_lock, flags); 570 spin_unlock_irqrestore(&tty->ctrl_lock, flags);
571 571
572 /* Account for the p->signal references we killed */ 572 /* Account for the p->signal references we killed */
573 while (refs--) 573 while (refs--)
574 tty_kref_put(tty); 574 tty_kref_put(tty);
575 575
576 /* 576 /*
577 * If one of the devices matches a console pointer, we 577 * If one of the devices matches a console pointer, we
578 * cannot just call hangup() because that will cause 578 * cannot just call hangup() because that will cause
579 * tty->count and state->count to go out of sync. 579 * tty->count and state->count to go out of sync.
580 * So we just call close() the right number of times. 580 * So we just call close() the right number of times.
581 */ 581 */
582 if (cons_filp) { 582 if (cons_filp) {
583 if (tty->ops->close) 583 if (tty->ops->close)
584 for (n = 0; n < closecount; n++) 584 for (n = 0; n < closecount; n++)
585 tty->ops->close(tty, cons_filp); 585 tty->ops->close(tty, cons_filp);
586 } else if (tty->ops->hangup) 586 } else if (tty->ops->hangup)
587 (tty->ops->hangup)(tty); 587 (tty->ops->hangup)(tty);
588 /* 588 /*
589 * We don't want to have driver/ldisc interactions beyond 589 * We don't want to have driver/ldisc interactions beyond
590 * the ones we did here. The driver layer expects no 590 * the ones we did here. The driver layer expects no
591 * calls after ->hangup() from the ldisc side. However we 591 * calls after ->hangup() from the ldisc side. However we
592 * can't yet guarantee all that. 592 * can't yet guarantee all that.
593 */ 593 */
594 set_bit(TTY_HUPPED, &tty->flags); 594 set_bit(TTY_HUPPED, &tty->flags);
595 tty_ldisc_enable(tty); 595 tty_ldisc_enable(tty);
596 unlock_kernel(); 596 unlock_kernel();
597 if (f) 597 if (f)
598 fput(f); 598 fput(f);
599 } 599 }
600 600
601 /** 601 /**
602 * tty_hangup - trigger a hangup event 602 * tty_hangup - trigger a hangup event
603 * @tty: tty to hangup 603 * @tty: tty to hangup
604 * 604 *
605 * A carrier loss (virtual or otherwise) has occurred on this like 605 * A carrier loss (virtual or otherwise) has occurred on this like
606 * schedule a hangup sequence to run after this event. 606 * schedule a hangup sequence to run after this event.
607 */ 607 */
608 608
609 void tty_hangup(struct tty_struct *tty) 609 void tty_hangup(struct tty_struct *tty)
610 { 610 {
611 #ifdef TTY_DEBUG_HANGUP 611 #ifdef TTY_DEBUG_HANGUP
612 char buf[64]; 612 char buf[64];
613 printk(KERN_DEBUG "%s hangup...\n", tty_name(tty, buf)); 613 printk(KERN_DEBUG "%s hangup...\n", tty_name(tty, buf));
614 #endif 614 #endif
615 schedule_work(&tty->hangup_work); 615 schedule_work(&tty->hangup_work);
616 } 616 }
617 617
618 EXPORT_SYMBOL(tty_hangup); 618 EXPORT_SYMBOL(tty_hangup);
619 619
620 /** 620 /**
621 * tty_vhangup - process vhangup 621 * tty_vhangup - process vhangup
622 * @tty: tty to hangup 622 * @tty: tty to hangup
623 * 623 *
624 * The user has asked via system call for the terminal to be hung up. 624 * The user has asked via system call for the terminal to be hung up.
625 * We do this synchronously so that when the syscall returns the process 625 * We do this synchronously so that when the syscall returns the process
626 * is complete. That guarantee is necessary for security reasons. 626 * is complete. That guarantee is necessary for security reasons.
627 */ 627 */
628 628
629 void tty_vhangup(struct tty_struct *tty) 629 void tty_vhangup(struct tty_struct *tty)
630 { 630 {
631 #ifdef TTY_DEBUG_HANGUP 631 #ifdef TTY_DEBUG_HANGUP
632 char buf[64]; 632 char buf[64];
633 633
634 printk(KERN_DEBUG "%s vhangup...\n", tty_name(tty, buf)); 634 printk(KERN_DEBUG "%s vhangup...\n", tty_name(tty, buf));
635 #endif 635 #endif
636 do_tty_hangup(&tty->hangup_work); 636 do_tty_hangup(&tty->hangup_work);
637 } 637 }
638 638
639 EXPORT_SYMBOL(tty_vhangup); 639 EXPORT_SYMBOL(tty_vhangup);
640 640
641 /** 641 /**
642 * tty_vhangup_self - process vhangup for own ctty 642 * tty_vhangup_self - process vhangup for own ctty
643 * 643 *
644 * Perform a vhangup on the current controlling tty 644 * Perform a vhangup on the current controlling tty
645 */ 645 */
646 646
647 void tty_vhangup_self(void) 647 void tty_vhangup_self(void)
648 { 648 {
649 struct tty_struct *tty; 649 struct tty_struct *tty;
650 650
651 tty = get_current_tty(); 651 tty = get_current_tty();
652 if (tty) { 652 if (tty) {
653 tty_vhangup(tty); 653 tty_vhangup(tty);
654 tty_kref_put(tty); 654 tty_kref_put(tty);
655 } 655 }
656 } 656 }
657 657
658 /** 658 /**
659 * tty_hung_up_p - was tty hung up 659 * tty_hung_up_p - was tty hung up
660 * @filp: file pointer of tty 660 * @filp: file pointer of tty
661 * 661 *
662 * Return true if the tty has been subject to a vhangup or a carrier 662 * Return true if the tty has been subject to a vhangup or a carrier
663 * loss 663 * loss
664 */ 664 */
665 665
666 int tty_hung_up_p(struct file *filp) 666 int tty_hung_up_p(struct file *filp)
667 { 667 {
668 return (filp->f_op == &hung_up_tty_fops); 668 return (filp->f_op == &hung_up_tty_fops);
669 } 669 }
670 670
671 EXPORT_SYMBOL(tty_hung_up_p); 671 EXPORT_SYMBOL(tty_hung_up_p);
672 672
673 static void session_clear_tty(struct pid *session) 673 static void session_clear_tty(struct pid *session)
674 { 674 {
675 struct task_struct *p; 675 struct task_struct *p;
676 do_each_pid_task(session, PIDTYPE_SID, p) { 676 do_each_pid_task(session, PIDTYPE_SID, p) {
677 proc_clear_tty(p); 677 proc_clear_tty(p);
678 } while_each_pid_task(session, PIDTYPE_SID, p); 678 } while_each_pid_task(session, PIDTYPE_SID, p);
679 } 679 }
680 680
681 /** 681 /**
682 * disassociate_ctty - disconnect controlling tty 682 * disassociate_ctty - disconnect controlling tty
683 * @on_exit: true if exiting so need to "hang up" the session 683 * @on_exit: true if exiting so need to "hang up" the session
684 * 684 *
685 * This function is typically called only by the session leader, when 685 * This function is typically called only by the session leader, when
686 * it wants to disassociate itself from its controlling tty. 686 * it wants to disassociate itself from its controlling tty.
687 * 687 *
688 * It performs the following functions: 688 * It performs the following functions:
689 * (1) Sends a SIGHUP and SIGCONT to the foreground process group 689 * (1) Sends a SIGHUP and SIGCONT to the foreground process group
690 * (2) Clears the tty from being controlling the session 690 * (2) Clears the tty from being controlling the session
691 * (3) Clears the controlling tty for all processes in the 691 * (3) Clears the controlling tty for all processes in the
692 * session group. 692 * session group.
693 * 693 *
694 * The argument on_exit is set to 1 if called when a process is 694 * The argument on_exit is set to 1 if called when a process is
695 * exiting; it is 0 if called by the ioctl TIOCNOTTY. 695 * exiting; it is 0 if called by the ioctl TIOCNOTTY.
696 * 696 *
697 * Locking: 697 * Locking:
698 * BKL is taken for hysterical raisins 698 * BKL is taken for hysterical raisins
699 * tty_mutex is taken to protect tty 699 * tty_mutex is taken to protect tty
700 * ->siglock is taken to protect ->signal/->sighand 700 * ->siglock is taken to protect ->signal/->sighand
701 * tasklist_lock is taken to walk process list for sessions 701 * tasklist_lock is taken to walk process list for sessions
702 * ->siglock is taken to protect ->signal/->sighand 702 * ->siglock is taken to protect ->signal/->sighand
703 */ 703 */
704 704
705 void disassociate_ctty(int on_exit) 705 void disassociate_ctty(int on_exit)
706 { 706 {
707 struct tty_struct *tty; 707 struct tty_struct *tty;
708 struct pid *tty_pgrp = NULL; 708 struct pid *tty_pgrp = NULL;
709 709
710 710
711 tty = get_current_tty(); 711 tty = get_current_tty();
712 if (tty) { 712 if (tty) {
713 tty_pgrp = get_pid(tty->pgrp); 713 tty_pgrp = get_pid(tty->pgrp);
714 lock_kernel(); 714 lock_kernel();
715 if (on_exit && tty->driver->type != TTY_DRIVER_TYPE_PTY) 715 if (on_exit && tty->driver->type != TTY_DRIVER_TYPE_PTY)
716 tty_vhangup(tty); 716 tty_vhangup(tty);
717 unlock_kernel(); 717 unlock_kernel();
718 tty_kref_put(tty); 718 tty_kref_put(tty);
719 } else if (on_exit) { 719 } else if (on_exit) {
720 struct pid *old_pgrp; 720 struct pid *old_pgrp;
721 spin_lock_irq(&current->sighand->siglock); 721 spin_lock_irq(&current->sighand->siglock);
722 old_pgrp = current->signal->tty_old_pgrp; 722 old_pgrp = current->signal->tty_old_pgrp;
723 current->signal->tty_old_pgrp = NULL; 723 current->signal->tty_old_pgrp = NULL;
724 spin_unlock_irq(&current->sighand->siglock); 724 spin_unlock_irq(&current->sighand->siglock);
725 if (old_pgrp) { 725 if (old_pgrp) {
726 kill_pgrp(old_pgrp, SIGHUP, on_exit); 726 kill_pgrp(old_pgrp, SIGHUP, on_exit);
727 kill_pgrp(old_pgrp, SIGCONT, on_exit); 727 kill_pgrp(old_pgrp, SIGCONT, on_exit);
728 put_pid(old_pgrp); 728 put_pid(old_pgrp);
729 } 729 }
730 return; 730 return;
731 } 731 }
732 if (tty_pgrp) { 732 if (tty_pgrp) {
733 kill_pgrp(tty_pgrp, SIGHUP, on_exit); 733 kill_pgrp(tty_pgrp, SIGHUP, on_exit);
734 if (!on_exit) 734 if (!on_exit)
735 kill_pgrp(tty_pgrp, SIGCONT, on_exit); 735 kill_pgrp(tty_pgrp, SIGCONT, on_exit);
736 put_pid(tty_pgrp); 736 put_pid(tty_pgrp);
737 } 737 }
738 738
739 spin_lock_irq(&current->sighand->siglock); 739 spin_lock_irq(&current->sighand->siglock);
740 put_pid(current->signal->tty_old_pgrp); 740 put_pid(current->signal->tty_old_pgrp);
741 current->signal->tty_old_pgrp = NULL; 741 current->signal->tty_old_pgrp = NULL;
742 spin_unlock_irq(&current->sighand->siglock); 742 spin_unlock_irq(&current->sighand->siglock);
743 743
744 tty = get_current_tty(); 744 tty = get_current_tty();
745 if (tty) { 745 if (tty) {
746 unsigned long flags; 746 unsigned long flags;
747 spin_lock_irqsave(&tty->ctrl_lock, flags); 747 spin_lock_irqsave(&tty->ctrl_lock, flags);
748 put_pid(tty->session); 748 put_pid(tty->session);
749 put_pid(tty->pgrp); 749 put_pid(tty->pgrp);
750 tty->session = NULL; 750 tty->session = NULL;
751 tty->pgrp = NULL; 751 tty->pgrp = NULL;
752 spin_unlock_irqrestore(&tty->ctrl_lock, flags); 752 spin_unlock_irqrestore(&tty->ctrl_lock, flags);
753 tty_kref_put(tty); 753 tty_kref_put(tty);
754 } else { 754 } else {
755 #ifdef TTY_DEBUG_HANGUP 755 #ifdef TTY_DEBUG_HANGUP
756 printk(KERN_DEBUG "error attempted to write to tty [0x%p]" 756 printk(KERN_DEBUG "error attempted to write to tty [0x%p]"
757 " = NULL", tty); 757 " = NULL", tty);
758 #endif 758 #endif
759 } 759 }
760 760
761 /* Now clear signal->tty under the lock */ 761 /* Now clear signal->tty under the lock */
762 read_lock(&tasklist_lock); 762 read_lock(&tasklist_lock);
763 session_clear_tty(task_session(current)); 763 session_clear_tty(task_session(current));
764 read_unlock(&tasklist_lock); 764 read_unlock(&tasklist_lock);
765 } 765 }
766 766
767 /** 767 /**
768 * 768 *
769 * no_tty - Ensure the current process does not have a controlling tty 769 * no_tty - Ensure the current process does not have a controlling tty
770 */ 770 */
771 void no_tty(void) 771 void no_tty(void)
772 { 772 {
773 struct task_struct *tsk = current; 773 struct task_struct *tsk = current;
774 lock_kernel(); 774 lock_kernel();
775 if (tsk->signal->leader) 775 if (tsk->signal->leader)
776 disassociate_ctty(0); 776 disassociate_ctty(0);
777 unlock_kernel(); 777 unlock_kernel();
778 proc_clear_tty(tsk); 778 proc_clear_tty(tsk);
779 } 779 }
780 780
781 781
782 /** 782 /**
783 * stop_tty - propagate flow control 783 * stop_tty - propagate flow control
784 * @tty: tty to stop 784 * @tty: tty to stop
785 * 785 *
786 * Perform flow control to the driver. For PTY/TTY pairs we 786 * Perform flow control to the driver. For PTY/TTY pairs we
787 * must also propagate the TIOCKPKT status. May be called 787 * must also propagate the TIOCKPKT status. May be called
788 * on an already stopped device and will not re-call the driver 788 * on an already stopped device and will not re-call the driver
789 * method. 789 * method.
790 * 790 *
791 * This functionality is used by both the line disciplines for 791 * This functionality is used by both the line disciplines for
792 * halting incoming flow and by the driver. It may therefore be 792 * halting incoming flow and by the driver. It may therefore be
793 * called from any context, may be under the tty atomic_write_lock 793 * called from any context, may be under the tty atomic_write_lock
794 * but not always. 794 * but not always.
795 * 795 *
796 * Locking: 796 * Locking:
797 * Uses the tty control lock internally 797 * Uses the tty control lock internally
798 */ 798 */
799 799
800 void stop_tty(struct tty_struct *tty) 800 void stop_tty(struct tty_struct *tty)
801 { 801 {
802 unsigned long flags; 802 unsigned long flags;
803 spin_lock_irqsave(&tty->ctrl_lock, flags); 803 spin_lock_irqsave(&tty->ctrl_lock, flags);
804 if (tty->stopped) { 804 if (tty->stopped) {
805 spin_unlock_irqrestore(&tty->ctrl_lock, flags); 805 spin_unlock_irqrestore(&tty->ctrl_lock, flags);
806 return; 806 return;
807 } 807 }
808 tty->stopped = 1; 808 tty->stopped = 1;
809 if (tty->link && tty->link->packet) { 809 if (tty->link && tty->link->packet) {
810 tty->ctrl_status &= ~TIOCPKT_START; 810 tty->ctrl_status &= ~TIOCPKT_START;
811 tty->ctrl_status |= TIOCPKT_STOP; 811 tty->ctrl_status |= TIOCPKT_STOP;
812 wake_up_interruptible_poll(&tty->link->read_wait, POLLIN); 812 wake_up_interruptible_poll(&tty->link->read_wait, POLLIN);
813 } 813 }
814 spin_unlock_irqrestore(&tty->ctrl_lock, flags); 814 spin_unlock_irqrestore(&tty->ctrl_lock, flags);
815 if (tty->ops->stop) 815 if (tty->ops->stop)
816 (tty->ops->stop)(tty); 816 (tty->ops->stop)(tty);
817 } 817 }
818 818
819 EXPORT_SYMBOL(stop_tty); 819 EXPORT_SYMBOL(stop_tty);
820 820
821 /** 821 /**
822 * start_tty - propagate flow control 822 * start_tty - propagate flow control
823 * @tty: tty to start 823 * @tty: tty to start
824 * 824 *
825 * Start a tty that has been stopped if at all possible. Perform 825 * Start a tty that has been stopped if at all possible. Perform
826 * any necessary wakeups and propagate the TIOCPKT status. If this 826 * any necessary wakeups and propagate the TIOCPKT status. If this
827 * is the tty was previous stopped and is being started then the 827 * is the tty was previous stopped and is being started then the
828 * driver start method is invoked and the line discipline woken. 828 * driver start method is invoked and the line discipline woken.
829 * 829 *
830 * Locking: 830 * Locking:
831 * ctrl_lock 831 * ctrl_lock
832 */ 832 */
833 833
834 void start_tty(struct tty_struct *tty) 834 void start_tty(struct tty_struct *tty)
835 { 835 {
836 unsigned long flags; 836 unsigned long flags;
837 spin_lock_irqsave(&tty->ctrl_lock, flags); 837 spin_lock_irqsave(&tty->ctrl_lock, flags);
838 if (!tty->stopped || tty->flow_stopped) { 838 if (!tty->stopped || tty->flow_stopped) {
839 spin_unlock_irqrestore(&tty->ctrl_lock, flags); 839 spin_unlock_irqrestore(&tty->ctrl_lock, flags);
840 return; 840 return;
841 } 841 }
842 tty->stopped = 0; 842 tty->stopped = 0;
843 if (tty->link && tty->link->packet) { 843 if (tty->link && tty->link->packet) {
844 tty->ctrl_status &= ~TIOCPKT_STOP; 844 tty->ctrl_status &= ~TIOCPKT_STOP;
845 tty->ctrl_status |= TIOCPKT_START; 845 tty->ctrl_status |= TIOCPKT_START;
846 wake_up_interruptible_poll(&tty->link->read_wait, POLLIN); 846 wake_up_interruptible_poll(&tty->link->read_wait, POLLIN);
847 } 847 }
848 spin_unlock_irqrestore(&tty->ctrl_lock, flags); 848 spin_unlock_irqrestore(&tty->ctrl_lock, flags);
849 if (tty->ops->start) 849 if (tty->ops->start)
850 (tty->ops->start)(tty); 850 (tty->ops->start)(tty);
851 /* If we have a running line discipline it may need kicking */ 851 /* If we have a running line discipline it may need kicking */
852 tty_wakeup(tty); 852 tty_wakeup(tty);
853 } 853 }
854 854
855 EXPORT_SYMBOL(start_tty); 855 EXPORT_SYMBOL(start_tty);
856 856
857 /** 857 /**
858 * tty_read - read method for tty device files 858 * tty_read - read method for tty device files
859 * @file: pointer to tty file 859 * @file: pointer to tty file
860 * @buf: user buffer 860 * @buf: user buffer
861 * @count: size of user buffer 861 * @count: size of user buffer
862 * @ppos: unused 862 * @ppos: unused
863 * 863 *
864 * Perform the read system call function on this terminal device. Checks 864 * Perform the read system call function on this terminal device. Checks
865 * for hung up devices before calling the line discipline method. 865 * for hung up devices before calling the line discipline method.
866 * 866 *
867 * Locking: 867 * Locking:
868 * Locks the line discipline internally while needed. Multiple 868 * Locks the line discipline internally while needed. Multiple
869 * read calls may be outstanding in parallel. 869 * read calls may be outstanding in parallel.
870 */ 870 */
871 871
872 static ssize_t tty_read(struct file *file, char __user *buf, size_t count, 872 static ssize_t tty_read(struct file *file, char __user *buf, size_t count,
873 loff_t *ppos) 873 loff_t *ppos)
874 { 874 {
875 int i; 875 int i;
876 struct tty_struct *tty; 876 struct tty_struct *tty;
877 struct inode *inode; 877 struct inode *inode;
878 struct tty_ldisc *ld; 878 struct tty_ldisc *ld;
879 879
880 tty = (struct tty_struct *)file->private_data; 880 tty = (struct tty_struct *)file->private_data;
881 inode = file->f_path.dentry->d_inode; 881 inode = file->f_path.dentry->d_inode;
882 if (tty_paranoia_check(tty, inode, "tty_read")) 882 if (tty_paranoia_check(tty, inode, "tty_read"))
883 return -EIO; 883 return -EIO;
884 if (!tty || (test_bit(TTY_IO_ERROR, &tty->flags))) 884 if (!tty || (test_bit(TTY_IO_ERROR, &tty->flags)))
885 return -EIO; 885 return -EIO;
886 886
887 /* We want to wait for the line discipline to sort out in this 887 /* We want to wait for the line discipline to sort out in this
888 situation */ 888 situation */
889 ld = tty_ldisc_ref_wait(tty); 889 ld = tty_ldisc_ref_wait(tty);
890 if (ld->ops->read) 890 if (ld->ops->read)
891 i = (ld->ops->read)(tty, file, buf, count); 891 i = (ld->ops->read)(tty, file, buf, count);
892 else 892 else
893 i = -EIO; 893 i = -EIO;
894 tty_ldisc_deref(ld); 894 tty_ldisc_deref(ld);
895 if (i > 0) 895 if (i > 0)
896 inode->i_atime = current_fs_time(inode->i_sb); 896 inode->i_atime = current_fs_time(inode->i_sb);
897 return i; 897 return i;
898 } 898 }
899 899
900 void tty_write_unlock(struct tty_struct *tty) 900 void tty_write_unlock(struct tty_struct *tty)
901 { 901 {
902 mutex_unlock(&tty->atomic_write_lock); 902 mutex_unlock(&tty->atomic_write_lock);
903 wake_up_interruptible_poll(&tty->write_wait, POLLOUT); 903 wake_up_interruptible_poll(&tty->write_wait, POLLOUT);
904 } 904 }
905 905
906 int tty_write_lock(struct tty_struct *tty, int ndelay) 906 int tty_write_lock(struct tty_struct *tty, int ndelay)
907 { 907 {
908 if (!mutex_trylock(&tty->atomic_write_lock)) { 908 if (!mutex_trylock(&tty->atomic_write_lock)) {
909 if (ndelay) 909 if (ndelay)
910 return -EAGAIN; 910 return -EAGAIN;
911 if (mutex_lock_interruptible(&tty->atomic_write_lock)) 911 if (mutex_lock_interruptible(&tty->atomic_write_lock))
912 return -ERESTARTSYS; 912 return -ERESTARTSYS;
913 } 913 }
914 return 0; 914 return 0;
915 } 915 }
916 916
917 /* 917 /*
918 * Split writes up in sane blocksizes to avoid 918 * Split writes up in sane blocksizes to avoid
919 * denial-of-service type attacks 919 * denial-of-service type attacks
920 */ 920 */
921 static inline ssize_t do_tty_write( 921 static inline ssize_t do_tty_write(
922 ssize_t (*write)(struct tty_struct *, struct file *, const unsigned char *, size_t), 922 ssize_t (*write)(struct tty_struct *, struct file *, const unsigned char *, size_t),
923 struct tty_struct *tty, 923 struct tty_struct *tty,
924 struct file *file, 924 struct file *file,
925 const char __user *buf, 925 const char __user *buf,
926 size_t count) 926 size_t count)
927 { 927 {
928 ssize_t ret, written = 0; 928 ssize_t ret, written = 0;
929 unsigned int chunk; 929 unsigned int chunk;
930 930
931 ret = tty_write_lock(tty, file->f_flags & O_NDELAY); 931 ret = tty_write_lock(tty, file->f_flags & O_NDELAY);
932 if (ret < 0) 932 if (ret < 0)
933 return ret; 933 return ret;
934 934
935 /* 935 /*
936 * We chunk up writes into a temporary buffer. This 936 * We chunk up writes into a temporary buffer. This
937 * simplifies low-level drivers immensely, since they 937 * simplifies low-level drivers immensely, since they
938 * don't have locking issues and user mode accesses. 938 * don't have locking issues and user mode accesses.
939 * 939 *
940 * But if TTY_NO_WRITE_SPLIT is set, we should use a 940 * But if TTY_NO_WRITE_SPLIT is set, we should use a
941 * big chunk-size.. 941 * big chunk-size..
942 * 942 *
943 * The default chunk-size is 2kB, because the NTTY 943 * The default chunk-size is 2kB, because the NTTY
944 * layer has problems with bigger chunks. It will 944 * layer has problems with bigger chunks. It will
945 * claim to be able to handle more characters than 945 * claim to be able to handle more characters than
946 * it actually does. 946 * it actually does.
947 * 947 *
948 * FIXME: This can probably go away now except that 64K chunks 948 * FIXME: This can probably go away now except that 64K chunks
949 * are too likely to fail unless switched to vmalloc... 949 * are too likely to fail unless switched to vmalloc...
950 */ 950 */
951 chunk = 2048; 951 chunk = 2048;
952 if (test_bit(TTY_NO_WRITE_SPLIT, &tty->flags)) 952 if (test_bit(TTY_NO_WRITE_SPLIT, &tty->flags))
953 chunk = 65536; 953 chunk = 65536;
954 if (count < chunk) 954 if (count < chunk)
955 chunk = count; 955 chunk = count;
956 956
957 /* write_buf/write_cnt is protected by the atomic_write_lock mutex */ 957 /* write_buf/write_cnt is protected by the atomic_write_lock mutex */
958 if (tty->write_cnt < chunk) { 958 if (tty->write_cnt < chunk) {
959 unsigned char *buf_chunk; 959 unsigned char *buf_chunk;
960 960
961 if (chunk < 1024) 961 if (chunk < 1024)
962 chunk = 1024; 962 chunk = 1024;
963 963
964 buf_chunk = kmalloc(chunk, GFP_KERNEL); 964 buf_chunk = kmalloc(chunk, GFP_KERNEL);
965 if (!buf_chunk) { 965 if (!buf_chunk) {
966 ret = -ENOMEM; 966 ret = -ENOMEM;
967 goto out; 967 goto out;
968 } 968 }
969 kfree(tty->write_buf); 969 kfree(tty->write_buf);
970 tty->write_cnt = chunk; 970 tty->write_cnt = chunk;
971 tty->write_buf = buf_chunk; 971 tty->write_buf = buf_chunk;
972 } 972 }
973 973
974 /* Do the write .. */ 974 /* Do the write .. */
975 for (;;) { 975 for (;;) {
976 size_t size = count; 976 size_t size = count;
977 if (size > chunk) 977 if (size > chunk)
978 size = chunk; 978 size = chunk;
979 ret = -EFAULT; 979 ret = -EFAULT;
980 if (copy_from_user(tty->write_buf, buf, size)) 980 if (copy_from_user(tty->write_buf, buf, size))
981 break; 981 break;
982 ret = write(tty, file, tty->write_buf, size); 982 ret = write(tty, file, tty->write_buf, size);
983 if (ret <= 0) 983 if (ret <= 0)
984 break; 984 break;
985 written += ret; 985 written += ret;
986 buf += ret; 986 buf += ret;
987 count -= ret; 987 count -= ret;
988 if (!count) 988 if (!count)
989 break; 989 break;
990 ret = -ERESTARTSYS; 990 ret = -ERESTARTSYS;
991 if (signal_pending(current)) 991 if (signal_pending(current))
992 break; 992 break;
993 cond_resched(); 993 cond_resched();
994 } 994 }
995 if (written) { 995 if (written) {
996 struct inode *inode = file->f_path.dentry->d_inode; 996 struct inode *inode = file->f_path.dentry->d_inode;
997 inode->i_mtime = current_fs_time(inode->i_sb); 997 inode->i_mtime = current_fs_time(inode->i_sb);
998 ret = written; 998 ret = written;
999 } 999 }
1000 out: 1000 out:
1001 tty_write_unlock(tty); 1001 tty_write_unlock(tty);
1002 return ret; 1002 return ret;
1003 } 1003 }
1004 1004
1005 /** 1005 /**
1006 * tty_write_message - write a message to a certain tty, not just the console. 1006 * tty_write_message - write a message to a certain tty, not just the console.
1007 * @tty: the destination tty_struct 1007 * @tty: the destination tty_struct
1008 * @msg: the message to write 1008 * @msg: the message to write
1009 * 1009 *
1010 * This is used for messages that need to be redirected to a specific tty. 1010 * This is used for messages that need to be redirected to a specific tty.
1011 * We don't put it into the syslog queue right now maybe in the future if 1011 * We don't put it into the syslog queue right now maybe in the future if
1012 * really needed. 1012 * really needed.
1013 * 1013 *
1014 * We must still hold the BKL and test the CLOSING flag for the moment. 1014 * We must still hold the BKL and test the CLOSING flag for the moment.
1015 */ 1015 */
1016 1016
1017 void tty_write_message(struct tty_struct *tty, char *msg) 1017 void tty_write_message(struct tty_struct *tty, char *msg)
1018 { 1018 {
1019 if (tty) { 1019 if (tty) {
1020 mutex_lock(&tty->atomic_write_lock); 1020 mutex_lock(&tty->atomic_write_lock);
1021 lock_kernel(); 1021 lock_kernel();
1022 if (tty->ops->write && !test_bit(TTY_CLOSING, &tty->flags)) { 1022 if (tty->ops->write && !test_bit(TTY_CLOSING, &tty->flags)) {
1023 unlock_kernel(); 1023 unlock_kernel();
1024 tty->ops->write(tty, msg, strlen(msg)); 1024 tty->ops->write(tty, msg, strlen(msg));
1025 } else 1025 } else
1026 unlock_kernel(); 1026 unlock_kernel();
1027 tty_write_unlock(tty); 1027 tty_write_unlock(tty);
1028 } 1028 }
1029 return; 1029 return;
1030 } 1030 }
1031 1031
1032 1032
1033 /** 1033 /**
1034 * tty_write - write method for tty device file 1034 * tty_write - write method for tty device file
1035 * @file: tty file pointer 1035 * @file: tty file pointer
1036 * @buf: user data to write 1036 * @buf: user data to write
1037 * @count: bytes to write 1037 * @count: bytes to write
1038 * @ppos: unused 1038 * @ppos: unused
1039 * 1039 *
1040 * Write data to a tty device via the line discipline. 1040 * Write data to a tty device via the line discipline.
1041 * 1041 *
1042 * Locking: 1042 * Locking:
1043 * Locks the line discipline as required 1043 * Locks the line discipline as required
1044 * Writes to the tty driver are serialized by the atomic_write_lock 1044 * Writes to the tty driver are serialized by the atomic_write_lock
1045 * and are then processed in chunks to the device. The line discipline 1045 * and are then processed in chunks to the device. The line discipline
1046 * write method will not be invoked in parallel for each device. 1046 * write method will not be invoked in parallel for each device.
1047 */ 1047 */
1048 1048
1049 static ssize_t tty_write(struct file *file, const char __user *buf, 1049 static ssize_t tty_write(struct file *file, const char __user *buf,
1050 size_t count, loff_t *ppos) 1050 size_t count, loff_t *ppos)
1051 { 1051 {
1052 struct tty_struct *tty; 1052 struct tty_struct *tty;
1053 struct inode *inode = file->f_path.dentry->d_inode; 1053 struct inode *inode = file->f_path.dentry->d_inode;
1054 ssize_t ret; 1054 ssize_t ret;
1055 struct tty_ldisc *ld; 1055 struct tty_ldisc *ld;
1056 1056
1057 tty = (struct tty_struct *)file->private_data; 1057 tty = (struct tty_struct *)file->private_data;
1058 if (tty_paranoia_check(tty, inode, "tty_write")) 1058 if (tty_paranoia_check(tty, inode, "tty_write"))
1059 return -EIO; 1059 return -EIO;
1060 if (!tty || !tty->ops->write || 1060 if (!tty || !tty->ops->write ||
1061 (test_bit(TTY_IO_ERROR, &tty->flags))) 1061 (test_bit(TTY_IO_ERROR, &tty->flags)))
1062 return -EIO; 1062 return -EIO;
1063 /* Short term debug to catch buggy drivers */ 1063 /* Short term debug to catch buggy drivers */
1064 if (tty->ops->write_room == NULL) 1064 if (tty->ops->write_room == NULL)
1065 printk(KERN_ERR "tty driver %s lacks a write_room method.\n", 1065 printk(KERN_ERR "tty driver %s lacks a write_room method.\n",
1066 tty->driver->name); 1066 tty->driver->name);
1067 ld = tty_ldisc_ref_wait(tty); 1067 ld = tty_ldisc_ref_wait(tty);
1068 if (!ld->ops->write) 1068 if (!ld->ops->write)
1069 ret = -EIO; 1069 ret = -EIO;
1070 else 1070 else
1071 ret = do_tty_write(ld->ops->write, tty, file, buf, count); 1071 ret = do_tty_write(ld->ops->write, tty, file, buf, count);
1072 tty_ldisc_deref(ld); 1072 tty_ldisc_deref(ld);
1073 return ret; 1073 return ret;
1074 } 1074 }
1075 1075
1076 ssize_t redirected_tty_write(struct file *file, const char __user *buf, 1076 ssize_t redirected_tty_write(struct file *file, const char __user *buf,
1077 size_t count, loff_t *ppos) 1077 size_t count, loff_t *ppos)
1078 { 1078 {
1079 struct file *p = NULL; 1079 struct file *p = NULL;
1080 1080
1081 spin_lock(&redirect_lock); 1081 spin_lock(&redirect_lock);
1082 if (redirect) { 1082 if (redirect) {
1083 get_file(redirect); 1083 get_file(redirect);
1084 p = redirect; 1084 p = redirect;
1085 } 1085 }
1086 spin_unlock(&redirect_lock); 1086 spin_unlock(&redirect_lock);
1087 1087
1088 if (p) { 1088 if (p) {
1089 ssize_t res; 1089 ssize_t res;
1090 res = vfs_write(p, buf, count, &p->f_pos); 1090 res = vfs_write(p, buf, count, &p->f_pos);
1091 fput(p); 1091 fput(p);
1092 return res; 1092 return res;
1093 } 1093 }
1094 return tty_write(file, buf, count, ppos); 1094 return tty_write(file, buf, count, ppos);
1095 } 1095 }
1096 1096
1097 static char ptychar[] = "pqrstuvwxyzabcde"; 1097 static char ptychar[] = "pqrstuvwxyzabcde";
1098 1098
1099 /** 1099 /**
1100 * pty_line_name - generate name for a pty 1100 * pty_line_name - generate name for a pty
1101 * @driver: the tty driver in use 1101 * @driver: the tty driver in use
1102 * @index: the minor number 1102 * @index: the minor number
1103 * @p: output buffer of at least 6 bytes 1103 * @p: output buffer of at least 6 bytes
1104 * 1104 *
1105 * Generate a name from a driver reference and write it to the output 1105 * Generate a name from a driver reference and write it to the output
1106 * buffer. 1106 * buffer.
1107 * 1107 *
1108 * Locking: None 1108 * Locking: None
1109 */ 1109 */
1110 static void pty_line_name(struct tty_driver *driver, int index, char *p) 1110 static void pty_line_name(struct tty_driver *driver, int index, char *p)
1111 { 1111 {
1112 int i = index + driver->name_base; 1112 int i = index + driver->name_base;
1113 /* ->name is initialized to "ttyp", but "tty" is expected */ 1113 /* ->name is initialized to "ttyp", but "tty" is expected */
1114 sprintf(p, "%s%c%x", 1114 sprintf(p, "%s%c%x",
1115 driver->subtype == PTY_TYPE_SLAVE ? "tty" : driver->name, 1115 driver->subtype == PTY_TYPE_SLAVE ? "tty" : driver->name,
1116 ptychar[i >> 4 & 0xf], i & 0xf); 1116 ptychar[i >> 4 & 0xf], i & 0xf);
1117 } 1117 }
1118 1118
1119 /** 1119 /**
1120 * tty_line_name - generate name for a tty 1120 * tty_line_name - generate name for a tty
1121 * @driver: the tty driver in use 1121 * @driver: the tty driver in use
1122 * @index: the minor number 1122 * @index: the minor number
1123 * @p: output buffer of at least 7 bytes 1123 * @p: output buffer of at least 7 bytes
1124 * 1124 *
1125 * Generate a name from a driver reference and write it to the output 1125 * Generate a name from a driver reference and write it to the output
1126 * buffer. 1126 * buffer.
1127 * 1127 *
1128 * Locking: None 1128 * Locking: None
1129 */ 1129 */
1130 static void tty_line_name(struct tty_driver *driver, int index, char *p) 1130 static void tty_line_name(struct tty_driver *driver, int index, char *p)
1131 { 1131 {
1132 sprintf(p, "%s%d", driver->name, index + driver->name_base); 1132 sprintf(p, "%s%d", driver->name, index + driver->name_base);
1133 } 1133 }
1134 1134
1135 /** 1135 /**
1136 * tty_driver_lookup_tty() - find an existing tty, if any 1136 * tty_driver_lookup_tty() - find an existing tty, if any
1137 * @driver: the driver for the tty 1137 * @driver: the driver for the tty
1138 * @idx: the minor number 1138 * @idx: the minor number
1139 * 1139 *
1140 * Return the tty, if found or ERR_PTR() otherwise. 1140 * Return the tty, if found or ERR_PTR() otherwise.
1141 * 1141 *
1142 * Locking: tty_mutex must be held. If tty is found, the mutex must 1142 * Locking: tty_mutex must be held. If tty is found, the mutex must
1143 * be held until the 'fast-open' is also done. Will change once we 1143 * be held until the 'fast-open' is also done. Will change once we
1144 * have refcounting in the driver and per driver locking 1144 * have refcounting in the driver and per driver locking
1145 */ 1145 */
1146 static struct tty_struct *tty_driver_lookup_tty(struct tty_driver *driver, 1146 static struct tty_struct *tty_driver_lookup_tty(struct tty_driver *driver,
1147 struct inode *inode, int idx) 1147 struct inode *inode, int idx)
1148 { 1148 {
1149 struct tty_struct *tty; 1149 struct tty_struct *tty;
1150 1150
1151 if (driver->ops->lookup) 1151 if (driver->ops->lookup)
1152 return driver->ops->lookup(driver, inode, idx); 1152 return driver->ops->lookup(driver, inode, idx);
1153 1153
1154 tty = driver->ttys[idx]; 1154 tty = driver->ttys[idx];
1155 return tty; 1155 return tty;
1156 } 1156 }
1157 1157
1158 /** 1158 /**
1159 * tty_init_termios - helper for termios setup 1159 * tty_init_termios - helper for termios setup
1160 * @tty: the tty to set up 1160 * @tty: the tty to set up
1161 * 1161 *
1162 * Initialise the termios structures for this tty. Thus runs under 1162 * Initialise the termios structures for this tty. Thus runs under
1163 * the tty_mutex currently so we can be relaxed about ordering. 1163 * the tty_mutex currently so we can be relaxed about ordering.
1164 */ 1164 */
1165 1165
1166 int tty_init_termios(struct tty_struct *tty) 1166 int tty_init_termios(struct tty_struct *tty)
1167 { 1167 {
1168 struct ktermios *tp; 1168 struct ktermios *tp;
1169 int idx = tty->index; 1169 int idx = tty->index;
1170 1170
1171 tp = tty->driver->termios[idx]; 1171 tp = tty->driver->termios[idx];
1172 if (tp == NULL) { 1172 if (tp == NULL) {
1173 tp = kzalloc(sizeof(struct ktermios[2]), GFP_KERNEL); 1173 tp = kzalloc(sizeof(struct ktermios[2]), GFP_KERNEL);
1174 if (tp == NULL) 1174 if (tp == NULL)
1175 return -ENOMEM; 1175 return -ENOMEM;
1176 memcpy(tp, &tty->driver->init_termios, 1176 memcpy(tp, &tty->driver->init_termios,
1177 sizeof(struct ktermios)); 1177 sizeof(struct ktermios));
1178 tty->driver->termios[idx] = tp; 1178 tty->driver->termios[idx] = tp;
1179 } 1179 }
1180 tty->termios = tp; 1180 tty->termios = tp;
1181 tty->termios_locked = tp + 1; 1181 tty->termios_locked = tp + 1;
1182 1182
1183 /* Compatibility until drivers always set this */ 1183 /* Compatibility until drivers always set this */
1184 tty->termios->c_ispeed = tty_termios_input_baud_rate(tty->termios); 1184 tty->termios->c_ispeed = tty_termios_input_baud_rate(tty->termios);
1185 tty->termios->c_ospeed = tty_termios_baud_rate(tty->termios); 1185 tty->termios->c_ospeed = tty_termios_baud_rate(tty->termios);
1186 return 0; 1186 return 0;
1187 } 1187 }
1188 EXPORT_SYMBOL_GPL(tty_init_termios); 1188 EXPORT_SYMBOL_GPL(tty_init_termios);
1189 1189
1190 /** 1190 /**
1191 * tty_driver_install_tty() - install a tty entry in the driver 1191 * tty_driver_install_tty() - install a tty entry in the driver
1192 * @driver: the driver for the tty 1192 * @driver: the driver for the tty
1193 * @tty: the tty 1193 * @tty: the tty
1194 * 1194 *
1195 * Install a tty object into the driver tables. The tty->index field 1195 * Install a tty object into the driver tables. The tty->index field
1196 * will be set by the time this is called. This method is responsible 1196 * will be set by the time this is called. This method is responsible
1197 * for ensuring any need additional structures are allocated and 1197 * for ensuring any need additional structures are allocated and
1198 * configured. 1198 * configured.
1199 * 1199 *
1200 * Locking: tty_mutex for now 1200 * Locking: tty_mutex for now
1201 */ 1201 */
1202 static int tty_driver_install_tty(struct tty_driver *driver, 1202 static int tty_driver_install_tty(struct tty_driver *driver,
1203 struct tty_struct *tty) 1203 struct tty_struct *tty)
1204 { 1204 {
1205 int idx = tty->index; 1205 int idx = tty->index;
1206 int ret; 1206 int ret;
1207 1207
1208 if (driver->ops->install) { 1208 if (driver->ops->install) {
1209 lock_kernel(); 1209 lock_kernel();
1210 ret = driver->ops->install(driver, tty); 1210 ret = driver->ops->install(driver, tty);
1211 unlock_kernel(); 1211 unlock_kernel();
1212 return ret; 1212 return ret;
1213 } 1213 }
1214 1214
1215 if (tty_init_termios(tty) == 0) { 1215 if (tty_init_termios(tty) == 0) {
1216 lock_kernel(); 1216 lock_kernel();
1217 tty_driver_kref_get(driver); 1217 tty_driver_kref_get(driver);
1218 tty->count++; 1218 tty->count++;
1219 driver->ttys[idx] = tty; 1219 driver->ttys[idx] = tty;
1220 unlock_kernel(); 1220 unlock_kernel();
1221 return 0; 1221 return 0;
1222 } 1222 }
1223 return -ENOMEM; 1223 return -ENOMEM;
1224 } 1224 }
1225 1225
1226 /** 1226 /**
1227 * tty_driver_remove_tty() - remove a tty from the driver tables 1227 * tty_driver_remove_tty() - remove a tty from the driver tables
1228 * @driver: the driver for the tty 1228 * @driver: the driver for the tty
1229 * @idx: the minor number 1229 * @idx: the minor number
1230 * 1230 *
1231 * Remvoe a tty object from the driver tables. The tty->index field 1231 * Remvoe a tty object from the driver tables. The tty->index field
1232 * will be set by the time this is called. 1232 * will be set by the time this is called.
1233 * 1233 *
1234 * Locking: tty_mutex for now 1234 * Locking: tty_mutex for now
1235 */ 1235 */
1236 static void tty_driver_remove_tty(struct tty_driver *driver, 1236 static void tty_driver_remove_tty(struct tty_driver *driver,
1237 struct tty_struct *tty) 1237 struct tty_struct *tty)
1238 { 1238 {
1239 if (driver->ops->remove) 1239 if (driver->ops->remove)
1240 driver->ops->remove(driver, tty); 1240 driver->ops->remove(driver, tty);
1241 else 1241 else
1242 driver->ttys[tty->index] = NULL; 1242 driver->ttys[tty->index] = NULL;
1243 } 1243 }
1244 1244
1245 /* 1245 /*
1246 * tty_reopen() - fast re-open of an open tty 1246 * tty_reopen() - fast re-open of an open tty
1247 * @tty - the tty to open 1247 * @tty - the tty to open
1248 * 1248 *
1249 * Return 0 on success, -errno on error. 1249 * Return 0 on success, -errno on error.
1250 * 1250 *
1251 * Locking: tty_mutex must be held from the time the tty was found 1251 * Locking: tty_mutex must be held from the time the tty was found
1252 * till this open completes. 1252 * till this open completes.
1253 */ 1253 */
1254 static int tty_reopen(struct tty_struct *tty) 1254 static int tty_reopen(struct tty_struct *tty)
1255 { 1255 {
1256 struct tty_driver *driver = tty->driver; 1256 struct tty_driver *driver = tty->driver;
1257 1257
1258 if (test_bit(TTY_CLOSING, &tty->flags)) 1258 if (test_bit(TTY_CLOSING, &tty->flags))
1259 return -EIO; 1259 return -EIO;
1260 1260
1261 if (driver->type == TTY_DRIVER_TYPE_PTY && 1261 if (driver->type == TTY_DRIVER_TYPE_PTY &&
1262 driver->subtype == PTY_TYPE_MASTER) { 1262 driver->subtype == PTY_TYPE_MASTER) {
1263 /* 1263 /*
1264 * special case for PTY masters: only one open permitted, 1264 * special case for PTY masters: only one open permitted,
1265 * and the slave side open count is incremented as well. 1265 * and the slave side open count is incremented as well.
1266 */ 1266 */
1267 if (tty->count) 1267 if (tty->count)
1268 return -EIO; 1268 return -EIO;
1269 1269
1270 tty->link->count++; 1270 tty->link->count++;
1271 } 1271 }
1272 tty->count++; 1272 tty->count++;
1273 tty->driver = driver; /* N.B. why do this every time?? */ 1273 tty->driver = driver; /* N.B. why do this every time?? */
1274 1274
1275 mutex_lock(&tty->ldisc_mutex); 1275 mutex_lock(&tty->ldisc_mutex);
1276 WARN_ON(!test_bit(TTY_LDISC, &tty->flags)); 1276 WARN_ON(!test_bit(TTY_LDISC, &tty->flags));
1277 mutex_unlock(&tty->ldisc_mutex); 1277 mutex_unlock(&tty->ldisc_mutex);
1278 1278
1279 return 0; 1279 return 0;
1280 } 1280 }
1281 1281
1282 /** 1282 /**
1283 * tty_init_dev - initialise a tty device 1283 * tty_init_dev - initialise a tty device
1284 * @driver: tty driver we are opening a device on 1284 * @driver: tty driver we are opening a device on
1285 * @idx: device index 1285 * @idx: device index
1286 * @ret_tty: returned tty structure 1286 * @ret_tty: returned tty structure
1287 * @first_ok: ok to open a new device (used by ptmx) 1287 * @first_ok: ok to open a new device (used by ptmx)
1288 * 1288 *
1289 * Prepare a tty device. This may not be a "new" clean device but 1289 * Prepare a tty device. This may not be a "new" clean device but
1290 * could also be an active device. The pty drivers require special 1290 * could also be an active device. The pty drivers require special
1291 * handling because of this. 1291 * handling because of this.
1292 * 1292 *
1293 * Locking: 1293 * Locking:
1294 * The function is called under the tty_mutex, which 1294 * The function is called under the tty_mutex, which
1295 * protects us from the tty struct or driver itself going away. 1295 * protects us from the tty struct or driver itself going away.
1296 * 1296 *
1297 * On exit the tty device has the line discipline attached and 1297 * On exit the tty device has the line discipline attached and
1298 * a reference count of 1. If a pair was created for pty/tty use 1298 * a reference count of 1. If a pair was created for pty/tty use
1299 * and the other was a pty master then it too has a reference count of 1. 1299 * and the other was a pty master then it too has a reference count of 1.
1300 * 1300 *
1301 * WSH 06/09/97: Rewritten to remove races and properly clean up after a 1301 * WSH 06/09/97: Rewritten to remove races and properly clean up after a
1302 * failed open. The new code protects the open with a mutex, so it's 1302 * failed open. The new code protects the open with a mutex, so it's
1303 * really quite straightforward. The mutex locking can probably be 1303 * really quite straightforward. The mutex locking can probably be
1304 * relaxed for the (most common) case of reopening a tty. 1304 * relaxed for the (most common) case of reopening a tty.
1305 */ 1305 */
1306 1306
1307 struct tty_struct *tty_init_dev(struct tty_driver *driver, int idx, 1307 struct tty_struct *tty_init_dev(struct tty_driver *driver, int idx,
1308 int first_ok) 1308 int first_ok)
1309 { 1309 {
1310 struct tty_struct *tty; 1310 struct tty_struct *tty;
1311 int retval; 1311 int retval;
1312 1312
1313 lock_kernel(); 1313 lock_kernel();
1314 /* Check if pty master is being opened multiple times */ 1314 /* Check if pty master is being opened multiple times */
1315 if (driver->subtype == PTY_TYPE_MASTER && 1315 if (driver->subtype == PTY_TYPE_MASTER &&
1316 (driver->flags & TTY_DRIVER_DEVPTS_MEM) && !first_ok) { 1316 (driver->flags & TTY_DRIVER_DEVPTS_MEM) && !first_ok) {
1317 unlock_kernel(); 1317 unlock_kernel();
1318 return ERR_PTR(-EIO); 1318 return ERR_PTR(-EIO);
1319 } 1319 }
1320 unlock_kernel(); 1320 unlock_kernel();
1321 1321
1322 /* 1322 /*
1323 * First time open is complex, especially for PTY devices. 1323 * First time open is complex, especially for PTY devices.
1324 * This code guarantees that either everything succeeds and the 1324 * This code guarantees that either everything succeeds and the
1325 * TTY is ready for operation, or else the table slots are vacated 1325 * TTY is ready for operation, or else the table slots are vacated
1326 * and the allocated memory released. (Except that the termios 1326 * and the allocated memory released. (Except that the termios
1327 * and locked termios may be retained.) 1327 * and locked termios may be retained.)
1328 */ 1328 */
1329 1329
1330 if (!try_module_get(driver->owner)) 1330 if (!try_module_get(driver->owner))
1331 return ERR_PTR(-ENODEV); 1331 return ERR_PTR(-ENODEV);
1332 1332
1333 tty = alloc_tty_struct(); 1333 tty = alloc_tty_struct();
1334 if (!tty) 1334 if (!tty)
1335 goto fail_no_mem; 1335 goto fail_no_mem;
1336 initialize_tty_struct(tty, driver, idx); 1336 initialize_tty_struct(tty, driver, idx);
1337 1337
1338 retval = tty_driver_install_tty(driver, tty); 1338 retval = tty_driver_install_tty(driver, tty);
1339 if (retval < 0) { 1339 if (retval < 0) {
1340 free_tty_struct(tty); 1340 free_tty_struct(tty);
1341 module_put(driver->owner); 1341 module_put(driver->owner);
1342 return ERR_PTR(retval); 1342 return ERR_PTR(retval);
1343 } 1343 }
1344 1344
1345 /* 1345 /*
1346 * Structures all installed ... call the ldisc open routines. 1346 * Structures all installed ... call the ldisc open routines.
1347 * If we fail here just call release_tty to clean up. No need 1347 * If we fail here just call release_tty to clean up. No need
1348 * to decrement the use counts, as release_tty doesn't care. 1348 * to decrement the use counts, as release_tty doesn't care.
1349 */ 1349 */
1350 retval = tty_ldisc_setup(tty, tty->link); 1350 retval = tty_ldisc_setup(tty, tty->link);
1351 if (retval) 1351 if (retval)
1352 goto release_mem_out; 1352 goto release_mem_out;
1353 return tty; 1353 return tty;
1354 1354
1355 fail_no_mem: 1355 fail_no_mem:
1356 module_put(driver->owner); 1356 module_put(driver->owner);
1357 return ERR_PTR(-ENOMEM); 1357 return ERR_PTR(-ENOMEM);
1358 1358
1359 /* call the tty release_tty routine to clean out this slot */ 1359 /* call the tty release_tty routine to clean out this slot */
1360 release_mem_out: 1360 release_mem_out:
1361 if (printk_ratelimit()) 1361 if (printk_ratelimit())
1362 printk(KERN_INFO "tty_init_dev: ldisc open failed, " 1362 printk(KERN_INFO "tty_init_dev: ldisc open failed, "
1363 "clearing slot %d\n", idx); 1363 "clearing slot %d\n", idx);
1364 lock_kernel(); 1364 lock_kernel();
1365 release_tty(tty, idx); 1365 release_tty(tty, idx);
1366 unlock_kernel(); 1366 unlock_kernel();
1367 return ERR_PTR(retval); 1367 return ERR_PTR(retval);
1368 } 1368 }
1369 1369
1370 void tty_free_termios(struct tty_struct *tty) 1370 void tty_free_termios(struct tty_struct *tty)
1371 { 1371 {
1372 struct ktermios *tp; 1372 struct ktermios *tp;
1373 int idx = tty->index; 1373 int idx = tty->index;
1374 /* Kill this flag and push into drivers for locking etc */ 1374 /* Kill this flag and push into drivers for locking etc */
1375 if (tty->driver->flags & TTY_DRIVER_RESET_TERMIOS) { 1375 if (tty->driver->flags & TTY_DRIVER_RESET_TERMIOS) {
1376 /* FIXME: Locking on ->termios array */ 1376 /* FIXME: Locking on ->termios array */
1377 tp = tty->termios; 1377 tp = tty->termios;
1378 tty->driver->termios[idx] = NULL; 1378 tty->driver->termios[idx] = NULL;
1379 kfree(tp); 1379 kfree(tp);
1380 } 1380 }
1381 } 1381 }
1382 EXPORT_SYMBOL(tty_free_termios); 1382 EXPORT_SYMBOL(tty_free_termios);
1383 1383
1384 void tty_shutdown(struct tty_struct *tty) 1384 void tty_shutdown(struct tty_struct *tty)
1385 { 1385 {
1386 tty_driver_remove_tty(tty->driver, tty); 1386 tty_driver_remove_tty(tty->driver, tty);
1387 tty_free_termios(tty); 1387 tty_free_termios(tty);
1388 } 1388 }
1389 EXPORT_SYMBOL(tty_shutdown); 1389 EXPORT_SYMBOL(tty_shutdown);
1390 1390
1391 /** 1391 /**
1392 * release_one_tty - release tty structure memory 1392 * release_one_tty - release tty structure memory
1393 * @kref: kref of tty we are obliterating 1393 * @kref: kref of tty we are obliterating
1394 * 1394 *
1395 * Releases memory associated with a tty structure, and clears out the 1395 * Releases memory associated with a tty structure, and clears out the
1396 * driver table slots. This function is called when a device is no longer 1396 * driver table slots. This function is called when a device is no longer
1397 * in use. It also gets called when setup of a device fails. 1397 * in use. It also gets called when setup of a device fails.
1398 * 1398 *
1399 * Locking: 1399 * Locking:
1400 * tty_mutex - sometimes only 1400 * tty_mutex - sometimes only
1401 * takes the file list lock internally when working on the list 1401 * takes the file list lock internally when working on the list
1402 * of ttys that the driver keeps. 1402 * of ttys that the driver keeps.
1403 * 1403 *
1404 * This method gets called from a work queue so that the driver private 1404 * This method gets called from a work queue so that the driver private
1405 * cleanup ops can sleep (needed for USB at least) 1405 * cleanup ops can sleep (needed for USB at least)
1406 */ 1406 */
1407 static void release_one_tty(struct work_struct *work) 1407 static void release_one_tty(struct work_struct *work)
1408 { 1408 {
1409 struct tty_struct *tty = 1409 struct tty_struct *tty =
1410 container_of(work, struct tty_struct, hangup_work); 1410 container_of(work, struct tty_struct, hangup_work);
1411 struct tty_driver *driver = tty->driver; 1411 struct tty_driver *driver = tty->driver;
1412 1412
1413 if (tty->ops->cleanup) 1413 if (tty->ops->cleanup)
1414 tty->ops->cleanup(tty); 1414 tty->ops->cleanup(tty);
1415 1415
1416 tty->magic = 0; 1416 tty->magic = 0;
1417 tty_driver_kref_put(driver); 1417 tty_driver_kref_put(driver);
1418 module_put(driver->owner); 1418 module_put(driver->owner);
1419 1419
1420 file_list_lock(); 1420 file_list_lock();
1421 list_del_init(&tty->tty_files); 1421 list_del_init(&tty->tty_files);
1422 file_list_unlock(); 1422 file_list_unlock();
1423 1423
1424 free_tty_struct(tty); 1424 free_tty_struct(tty);
1425 } 1425 }
1426 1426
1427 static void queue_release_one_tty(struct kref *kref) 1427 static void queue_release_one_tty(struct kref *kref)
1428 { 1428 {
1429 struct tty_struct *tty = container_of(kref, struct tty_struct, kref); 1429 struct tty_struct *tty = container_of(kref, struct tty_struct, kref);
1430 1430
1431 if (tty->ops->shutdown) 1431 if (tty->ops->shutdown)
1432 tty->ops->shutdown(tty); 1432 tty->ops->shutdown(tty);
1433 else 1433 else
1434 tty_shutdown(tty); 1434 tty_shutdown(tty);
1435 1435
1436 /* The hangup queue is now free so we can reuse it rather than 1436 /* The hangup queue is now free so we can reuse it rather than
1437 waste a chunk of memory for each port */ 1437 waste a chunk of memory for each port */
1438 INIT_WORK(&tty->hangup_work, release_one_tty); 1438 INIT_WORK(&tty->hangup_work, release_one_tty);
1439 schedule_work(&tty->hangup_work); 1439 schedule_work(&tty->hangup_work);
1440 } 1440 }
1441 1441
1442 /** 1442 /**
1443 * tty_kref_put - release a tty kref 1443 * tty_kref_put - release a tty kref
1444 * @tty: tty device 1444 * @tty: tty device
1445 * 1445 *
1446 * Release a reference to a tty device and if need be let the kref 1446 * Release a reference to a tty device and if need be let the kref
1447 * layer destruct the object for us 1447 * layer destruct the object for us
1448 */ 1448 */
1449 1449
1450 void tty_kref_put(struct tty_struct *tty) 1450 void tty_kref_put(struct tty_struct *tty)
1451 { 1451 {
1452 if (tty) 1452 if (tty)
1453 kref_put(&tty->kref, queue_release_one_tty); 1453 kref_put(&tty->kref, queue_release_one_tty);
1454 } 1454 }
1455 EXPORT_SYMBOL(tty_kref_put); 1455 EXPORT_SYMBOL(tty_kref_put);
1456 1456
1457 /** 1457 /**
1458 * release_tty - release tty structure memory 1458 * release_tty - release tty structure memory
1459 * 1459 *
1460 * Release both @tty and a possible linked partner (think pty pair), 1460 * Release both @tty and a possible linked partner (think pty pair),
1461 * and decrement the refcount of the backing module. 1461 * and decrement the refcount of the backing module.
1462 * 1462 *
1463 * Locking: 1463 * Locking:
1464 * tty_mutex - sometimes only 1464 * tty_mutex - sometimes only
1465 * takes the file list lock internally when working on the list 1465 * takes the file list lock internally when working on the list
1466 * of ttys that the driver keeps. 1466 * of ttys that the driver keeps.
1467 * FIXME: should we require tty_mutex is held here ?? 1467 * FIXME: should we require tty_mutex is held here ??
1468 * 1468 *
1469 */ 1469 */
1470 static void release_tty(struct tty_struct *tty, int idx) 1470 static void release_tty(struct tty_struct *tty, int idx)
1471 { 1471 {
1472 /* This should always be true but check for the moment */ 1472 /* This should always be true but check for the moment */
1473 WARN_ON(tty->index != idx); 1473 WARN_ON(tty->index != idx);
1474 1474
1475 if (tty->link) 1475 if (tty->link)
1476 tty_kref_put(tty->link); 1476 tty_kref_put(tty->link);
1477 tty_kref_put(tty); 1477 tty_kref_put(tty);
1478 } 1478 }
1479 1479
1480 /** 1480 /**
1481 * tty_release - vfs callback for close 1481 * tty_release - vfs callback for close
1482 * @inode: inode of tty 1482 * @inode: inode of tty
1483 * @filp: file pointer for handle to tty 1483 * @filp: file pointer for handle to tty
1484 * 1484 *
1485 * Called the last time each file handle is closed that references 1485 * Called the last time each file handle is closed that references
1486 * this tty. There may however be several such references. 1486 * this tty. There may however be several such references.
1487 * 1487 *
1488 * Locking: 1488 * Locking:
1489 * Takes bkl. See tty_release_dev 1489 * Takes bkl. See tty_release_dev
1490 * 1490 *
1491 * Even releasing the tty structures is a tricky business.. We have 1491 * Even releasing the tty structures is a tricky business.. We have
1492 * to be very careful that the structures are all released at the 1492 * to be very careful that the structures are all released at the
1493 * same time, as interrupts might otherwise get the wrong pointers. 1493 * same time, as interrupts might otherwise get the wrong pointers.
1494 * 1494 *
1495 * WSH 09/09/97: rewritten to avoid some nasty race conditions that could 1495 * WSH 09/09/97: rewritten to avoid some nasty race conditions that could
1496 * lead to double frees or releasing memory still in use. 1496 * lead to double frees or releasing memory still in use.
1497 */ 1497 */
1498 1498
1499 int tty_release(struct inode *inode, struct file *filp) 1499 int tty_release(struct inode *inode, struct file *filp)
1500 { 1500 {
1501 struct tty_struct *tty, *o_tty; 1501 struct tty_struct *tty, *o_tty;
1502 int pty_master, tty_closing, o_tty_closing, do_sleep; 1502 int pty_master, tty_closing, o_tty_closing, do_sleep;
1503 int devpts; 1503 int devpts;
1504 int idx; 1504 int idx;
1505 char buf[64]; 1505 char buf[64];
1506 1506
1507 tty = (struct tty_struct *)filp->private_data; 1507 tty = (struct tty_struct *)filp->private_data;
1508 if (tty_paranoia_check(tty, inode, "tty_release_dev")) 1508 if (tty_paranoia_check(tty, inode, "tty_release_dev"))
1509 return 0; 1509 return 0;
1510 1510
1511 lock_kernel(); 1511 lock_kernel();
1512 check_tty_count(tty, "tty_release_dev"); 1512 check_tty_count(tty, "tty_release_dev");
1513 1513
1514 tty_fasync(-1, filp, 0); 1514 tty_fasync(-1, filp, 0);
1515 1515
1516 idx = tty->index; 1516 idx = tty->index;
1517 pty_master = (tty->driver->type == TTY_DRIVER_TYPE_PTY && 1517 pty_master = (tty->driver->type == TTY_DRIVER_TYPE_PTY &&
1518 tty->driver->subtype == PTY_TYPE_MASTER); 1518 tty->driver->subtype == PTY_TYPE_MASTER);
1519 devpts = (tty->driver->flags & TTY_DRIVER_DEVPTS_MEM) != 0; 1519 devpts = (tty->driver->flags & TTY_DRIVER_DEVPTS_MEM) != 0;
1520 o_tty = tty->link; 1520 o_tty = tty->link;
1521 1521
1522 #ifdef TTY_PARANOIA_CHECK 1522 #ifdef TTY_PARANOIA_CHECK
1523 if (idx < 0 || idx >= tty->driver->num) { 1523 if (idx < 0 || idx >= tty->driver->num) {
1524 printk(KERN_DEBUG "tty_release_dev: bad idx when trying to " 1524 printk(KERN_DEBUG "tty_release_dev: bad idx when trying to "
1525 "free (%s)\n", tty->name); 1525 "free (%s)\n", tty->name);
1526 unlock_kernel(); 1526 unlock_kernel();
1527 return 0; 1527 return 0;
1528 } 1528 }
1529 if (!devpts) { 1529 if (!devpts) {
1530 if (tty != tty->driver->ttys[idx]) { 1530 if (tty != tty->driver->ttys[idx]) {
1531 unlock_kernel(); 1531 unlock_kernel();
1532 printk(KERN_DEBUG "tty_release_dev: driver.table[%d] not tty " 1532 printk(KERN_DEBUG "tty_release_dev: driver.table[%d] not tty "
1533 "for (%s)\n", idx, tty->name); 1533 "for (%s)\n", idx, tty->name);
1534 return 0; 1534 return 0;
1535 } 1535 }
1536 if (tty->termios != tty->driver->termios[idx]) { 1536 if (tty->termios != tty->driver->termios[idx]) {
1537 unlock_kernel(); 1537 unlock_kernel();
1538 printk(KERN_DEBUG "tty_release_dev: driver.termios[%d] not termios " 1538 printk(KERN_DEBUG "tty_release_dev: driver.termios[%d] not termios "
1539 "for (%s)\n", 1539 "for (%s)\n",
1540 idx, tty->name); 1540 idx, tty->name);
1541 return 0; 1541 return 0;
1542 } 1542 }
1543 } 1543 }
1544 #endif 1544 #endif
1545 1545
1546 #ifdef TTY_DEBUG_HANGUP 1546 #ifdef TTY_DEBUG_HANGUP
1547 printk(KERN_DEBUG "tty_release_dev of %s (tty count=%d)...", 1547 printk(KERN_DEBUG "tty_release_dev of %s (tty count=%d)...",
1548 tty_name(tty, buf), tty->count); 1548 tty_name(tty, buf), tty->count);
1549 #endif 1549 #endif
1550 1550
1551 #ifdef TTY_PARANOIA_CHECK 1551 #ifdef TTY_PARANOIA_CHECK
1552 if (tty->driver->other && 1552 if (tty->driver->other &&
1553 !(tty->driver->flags & TTY_DRIVER_DEVPTS_MEM)) { 1553 !(tty->driver->flags & TTY_DRIVER_DEVPTS_MEM)) {
1554 if (o_tty != tty->driver->other->ttys[idx]) { 1554 if (o_tty != tty->driver->other->ttys[idx]) {
1555 unlock_kernel(); 1555 unlock_kernel();
1556 printk(KERN_DEBUG "tty_release_dev: other->table[%d] " 1556 printk(KERN_DEBUG "tty_release_dev: other->table[%d] "
1557 "not o_tty for (%s)\n", 1557 "not o_tty for (%s)\n",
1558 idx, tty->name); 1558 idx, tty->name);
1559 return 0 ; 1559 return 0 ;
1560 } 1560 }
1561 if (o_tty->termios != tty->driver->other->termios[idx]) { 1561 if (o_tty->termios != tty->driver->other->termios[idx]) {
1562 unlock_kernel(); 1562 unlock_kernel();
1563 printk(KERN_DEBUG "tty_release_dev: other->termios[%d] " 1563 printk(KERN_DEBUG "tty_release_dev: other->termios[%d] "
1564 "not o_termios for (%s)\n", 1564 "not o_termios for (%s)\n",
1565 idx, tty->name); 1565 idx, tty->name);
1566 return 0; 1566 return 0;
1567 } 1567 }
1568 if (o_tty->link != tty) { 1568 if (o_tty->link != tty) {
1569 unlock_kernel(); 1569 unlock_kernel();
1570 printk(KERN_DEBUG "tty_release_dev: bad pty pointers\n"); 1570 printk(KERN_DEBUG "tty_release_dev: bad pty pointers\n");
1571 return 0; 1571 return 0;
1572 } 1572 }
1573 } 1573 }
1574 #endif 1574 #endif
1575 if (tty->ops->close) 1575 if (tty->ops->close)
1576 tty->ops->close(tty, filp); 1576 tty->ops->close(tty, filp);
1577 1577
1578 unlock_kernel(); 1578 unlock_kernel();
1579 /* 1579 /*
1580 * Sanity check: if tty->count is going to zero, there shouldn't be 1580 * Sanity check: if tty->count is going to zero, there shouldn't be
1581 * any waiters on tty->read_wait or tty->write_wait. We test the 1581 * any waiters on tty->read_wait or tty->write_wait. We test the
1582 * wait queues and kick everyone out _before_ actually starting to 1582 * wait queues and kick everyone out _before_ actually starting to
1583 * close. This ensures that we won't block while releasing the tty 1583 * close. This ensures that we won't block while releasing the tty
1584 * structure. 1584 * structure.
1585 * 1585 *
1586 * The test for the o_tty closing is necessary, since the master and 1586 * The test for the o_tty closing is necessary, since the master and
1587 * slave sides may close in any order. If the slave side closes out 1587 * slave sides may close in any order. If the slave side closes out
1588 * first, its count will be one, since the master side holds an open. 1588 * first, its count will be one, since the master side holds an open.
1589 * Thus this test wouldn't be triggered at the time the slave closes, 1589 * Thus this test wouldn't be triggered at the time the slave closes,
1590 * so we do it now. 1590 * so we do it now.
1591 * 1591 *
1592 * Note that it's possible for the tty to be opened again while we're 1592 * Note that it's possible for the tty to be opened again while we're
1593 * flushing out waiters. By recalculating the closing flags before 1593 * flushing out waiters. By recalculating the closing flags before
1594 * each iteration we avoid any problems. 1594 * each iteration we avoid any problems.
1595 */ 1595 */
1596 while (1) { 1596 while (1) {
1597 /* Guard against races with tty->count changes elsewhere and 1597 /* Guard against races with tty->count changes elsewhere and
1598 opens on /dev/tty */ 1598 opens on /dev/tty */
1599 1599
1600 mutex_lock(&tty_mutex); 1600 mutex_lock(&tty_mutex);
1601 lock_kernel(); 1601 lock_kernel();
1602 tty_closing = tty->count <= 1; 1602 tty_closing = tty->count <= 1;
1603 o_tty_closing = o_tty && 1603 o_tty_closing = o_tty &&
1604 (o_tty->count <= (pty_master ? 1 : 0)); 1604 (o_tty->count <= (pty_master ? 1 : 0));
1605 do_sleep = 0; 1605 do_sleep = 0;
1606 1606
1607 if (tty_closing) { 1607 if (tty_closing) {
1608 if (waitqueue_active(&tty->read_wait)) { 1608 if (waitqueue_active(&tty->read_wait)) {
1609 wake_up_poll(&tty->read_wait, POLLIN); 1609 wake_up_poll(&tty->read_wait, POLLIN);
1610 do_sleep++; 1610 do_sleep++;
1611 } 1611 }
1612 if (waitqueue_active(&tty->write_wait)) { 1612 if (waitqueue_active(&tty->write_wait)) {
1613 wake_up_poll(&tty->write_wait, POLLOUT); 1613 wake_up_poll(&tty->write_wait, POLLOUT);
1614 do_sleep++; 1614 do_sleep++;
1615 } 1615 }
1616 } 1616 }
1617 if (o_tty_closing) { 1617 if (o_tty_closing) {
1618 if (waitqueue_active(&o_tty->read_wait)) { 1618 if (waitqueue_active(&o_tty->read_wait)) {
1619 wake_up_poll(&o_tty->read_wait, POLLIN); 1619 wake_up_poll(&o_tty->read_wait, POLLIN);
1620 do_sleep++; 1620 do_sleep++;
1621 } 1621 }
1622 if (waitqueue_active(&o_tty->write_wait)) { 1622 if (waitqueue_active(&o_tty->write_wait)) {
1623 wake_up_poll(&o_tty->write_wait, POLLOUT); 1623 wake_up_poll(&o_tty->write_wait, POLLOUT);
1624 do_sleep++; 1624 do_sleep++;
1625 } 1625 }
1626 } 1626 }
1627 if (!do_sleep) 1627 if (!do_sleep)
1628 break; 1628 break;
1629 1629
1630 printk(KERN_WARNING "tty_release_dev: %s: read/write wait queue " 1630 printk(KERN_WARNING "tty_release_dev: %s: read/write wait queue "
1631 "active!\n", tty_name(tty, buf)); 1631 "active!\n", tty_name(tty, buf));
1632 unlock_kernel(); 1632 unlock_kernel();
1633 mutex_unlock(&tty_mutex); 1633 mutex_unlock(&tty_mutex);
1634 schedule(); 1634 schedule();
1635 } 1635 }
1636 1636
1637 /* 1637 /*
1638 * The closing flags are now consistent with the open counts on 1638 * The closing flags are now consistent with the open counts on
1639 * both sides, and we've completed the last operation that could 1639 * both sides, and we've completed the last operation that could
1640 * block, so it's safe to proceed with closing. 1640 * block, so it's safe to proceed with closing.
1641 */ 1641 */
1642 if (pty_master) { 1642 if (pty_master) {
1643 if (--o_tty->count < 0) { 1643 if (--o_tty->count < 0) {
1644 printk(KERN_WARNING "tty_release_dev: bad pty slave count " 1644 printk(KERN_WARNING "tty_release_dev: bad pty slave count "
1645 "(%d) for %s\n", 1645 "(%d) for %s\n",
1646 o_tty->count, tty_name(o_tty, buf)); 1646 o_tty->count, tty_name(o_tty, buf));
1647 o_tty->count = 0; 1647 o_tty->count = 0;
1648 } 1648 }
1649 } 1649 }
1650 if (--tty->count < 0) { 1650 if (--tty->count < 0) {
1651 printk(KERN_WARNING "tty_release_dev: bad tty->count (%d) for %s\n", 1651 printk(KERN_WARNING "tty_release_dev: bad tty->count (%d) for %s\n",
1652 tty->count, tty_name(tty, buf)); 1652 tty->count, tty_name(tty, buf));
1653 tty->count = 0; 1653 tty->count = 0;
1654 } 1654 }
1655 1655
1656 /* 1656 /*
1657 * We've decremented tty->count, so we need to remove this file 1657 * We've decremented tty->count, so we need to remove this file
1658 * descriptor off the tty->tty_files list; this serves two 1658 * descriptor off the tty->tty_files list; this serves two
1659 * purposes: 1659 * purposes:
1660 * - check_tty_count sees the correct number of file descriptors 1660 * - check_tty_count sees the correct number of file descriptors
1661 * associated with this tty. 1661 * associated with this tty.
1662 * - do_tty_hangup no longer sees this file descriptor as 1662 * - do_tty_hangup no longer sees this file descriptor as
1663 * something that needs to be handled for hangups. 1663 * something that needs to be handled for hangups.
1664 */ 1664 */
1665 file_kill(filp); 1665 file_kill(filp);
1666 filp->private_data = NULL; 1666 filp->private_data = NULL;
1667 1667
1668 /* 1668 /*
1669 * Perform some housekeeping before deciding whether to return. 1669 * Perform some housekeeping before deciding whether to return.
1670 * 1670 *
1671 * Set the TTY_CLOSING flag if this was the last open. In the 1671 * Set the TTY_CLOSING flag if this was the last open. In the
1672 * case of a pty we may have to wait around for the other side 1672 * case of a pty we may have to wait around for the other side
1673 * to close, and TTY_CLOSING makes sure we can't be reopened. 1673 * to close, and TTY_CLOSING makes sure we can't be reopened.
1674 */ 1674 */
1675 if (tty_closing) 1675 if (tty_closing)
1676 set_bit(TTY_CLOSING, &tty->flags); 1676 set_bit(TTY_CLOSING, &tty->flags);
1677 if (o_tty_closing) 1677 if (o_tty_closing)
1678 set_bit(TTY_CLOSING, &o_tty->flags); 1678 set_bit(TTY_CLOSING, &o_tty->flags);
1679 1679
1680 /* 1680 /*
1681 * If _either_ side is closing, make sure there aren't any 1681 * If _either_ side is closing, make sure there aren't any
1682 * processes that still think tty or o_tty is their controlling 1682 * processes that still think tty or o_tty is their controlling
1683 * tty. 1683 * tty.
1684 */ 1684 */
1685 if (tty_closing || o_tty_closing) { 1685 if (tty_closing || o_tty_closing) {
1686 read_lock(&tasklist_lock); 1686 read_lock(&tasklist_lock);
1687 session_clear_tty(tty->session); 1687 session_clear_tty(tty->session);
1688 if (o_tty) 1688 if (o_tty)
1689 session_clear_tty(o_tty->session); 1689 session_clear_tty(o_tty->session);
1690 read_unlock(&tasklist_lock); 1690 read_unlock(&tasklist_lock);
1691 } 1691 }
1692 1692
1693 mutex_unlock(&tty_mutex); 1693 mutex_unlock(&tty_mutex);
1694 1694
1695 /* check whether both sides are closing ... */ 1695 /* check whether both sides are closing ... */
1696 if (!tty_closing || (o_tty && !o_tty_closing)) { 1696 if (!tty_closing || (o_tty && !o_tty_closing)) {
1697 unlock_kernel(); 1697 unlock_kernel();
1698 return 0; 1698 return 0;
1699 } 1699 }
1700 1700
1701 #ifdef TTY_DEBUG_HANGUP 1701 #ifdef TTY_DEBUG_HANGUP
1702 printk(KERN_DEBUG "freeing tty structure..."); 1702 printk(KERN_DEBUG "freeing tty structure...");
1703 #endif 1703 #endif
1704 /* 1704 /*
1705 * Ask the line discipline code to release its structures 1705 * Ask the line discipline code to release its structures
1706 */ 1706 */
1707 tty_ldisc_release(tty, o_tty); 1707 tty_ldisc_release(tty, o_tty);
1708 /* 1708 /*
1709 * The release_tty function takes care of the details of clearing 1709 * The release_tty function takes care of the details of clearing
1710 * the slots and preserving the termios structure. 1710 * the slots and preserving the termios structure.
1711 */ 1711 */
1712 release_tty(tty, idx); 1712 release_tty(tty, idx);
1713 1713
1714 /* Make this pty number available for reallocation */ 1714 /* Make this pty number available for reallocation */
1715 if (devpts) 1715 if (devpts)
1716 devpts_kill_index(inode, idx); 1716 devpts_kill_index(inode, idx);
1717 unlock_kernel(); 1717 unlock_kernel();
1718 return 0; 1718 return 0;
1719 } 1719 }
1720 1720
1721 /** 1721 /**
1722 * tty_open - open a tty device 1722 * tty_open - open a tty device
1723 * @inode: inode of device file 1723 * @inode: inode of device file
1724 * @filp: file pointer to tty 1724 * @filp: file pointer to tty
1725 * 1725 *
1726 * tty_open and tty_release keep up the tty count that contains the 1726 * tty_open and tty_release keep up the tty count that contains the
1727 * number of opens done on a tty. We cannot use the inode-count, as 1727 * number of opens done on a tty. We cannot use the inode-count, as
1728 * different inodes might point to the same tty. 1728 * different inodes might point to the same tty.
1729 * 1729 *
1730 * Open-counting is needed for pty masters, as well as for keeping 1730 * Open-counting is needed for pty masters, as well as for keeping
1731 * track of serial lines: DTR is dropped when the last close happens. 1731 * track of serial lines: DTR is dropped when the last close happens.
1732 * (This is not done solely through tty->count, now. - Ted 1/27/92) 1732 * (This is not done solely through tty->count, now. - Ted 1/27/92)
1733 * 1733 *
1734 * The termios state of a pty is reset on first open so that 1734 * The termios state of a pty is reset on first open so that
1735 * settings don't persist across reuse. 1735 * settings don't persist across reuse.
1736 * 1736 *
1737 * Locking: tty_mutex protects tty, get_tty_driver and tty_init_dev work. 1737 * Locking: tty_mutex protects tty, get_tty_driver and tty_init_dev work.
1738 * tty->count should protect the rest. 1738 * tty->count should protect the rest.
1739 * ->siglock protects ->signal/->sighand 1739 * ->siglock protects ->signal/->sighand
1740 */ 1740 */
1741 1741
1742 static int tty_open(struct inode *inode, struct file *filp) 1742 static int tty_open(struct inode *inode, struct file *filp)
1743 { 1743 {
1744 struct tty_struct *tty = NULL; 1744 struct tty_struct *tty = NULL;
1745 int noctty, retval; 1745 int noctty, retval;
1746 struct tty_driver *driver; 1746 struct tty_driver *driver;
1747 int index; 1747 int index;
1748 dev_t device = inode->i_rdev; 1748 dev_t device = inode->i_rdev;
1749 unsigned saved_flags = filp->f_flags; 1749 unsigned saved_flags = filp->f_flags;
1750 1750
1751 nonseekable_open(inode, filp); 1751 nonseekable_open(inode, filp);
1752 1752
1753 retry_open: 1753 retry_open:
1754 noctty = filp->f_flags & O_NOCTTY; 1754 noctty = filp->f_flags & O_NOCTTY;
1755 index = -1; 1755 index = -1;
1756 retval = 0; 1756 retval = 0;
1757 1757
1758 mutex_lock(&tty_mutex); 1758 mutex_lock(&tty_mutex);
1759 lock_kernel(); 1759 lock_kernel();
1760 1760
1761 if (device == MKDEV(TTYAUX_MAJOR, 0)) { 1761 if (device == MKDEV(TTYAUX_MAJOR, 0)) {
1762 tty = get_current_tty(); 1762 tty = get_current_tty();
1763 if (!tty) { 1763 if (!tty) {
1764 unlock_kernel(); 1764 unlock_kernel();
1765 mutex_unlock(&tty_mutex); 1765 mutex_unlock(&tty_mutex);
1766 return -ENXIO; 1766 return -ENXIO;
1767 } 1767 }
1768 driver = tty_driver_kref_get(tty->driver); 1768 driver = tty_driver_kref_get(tty->driver);
1769 index = tty->index; 1769 index = tty->index;
1770 filp->f_flags |= O_NONBLOCK; /* Don't let /dev/tty block */ 1770 filp->f_flags |= O_NONBLOCK; /* Don't let /dev/tty block */
1771 /* noctty = 1; */ 1771 /* noctty = 1; */
1772 /* FIXME: Should we take a driver reference ? */ 1772 /* FIXME: Should we take a driver reference ? */
1773 tty_kref_put(tty); 1773 tty_kref_put(tty);
1774 goto got_driver; 1774 goto got_driver;
1775 } 1775 }
1776 #ifdef CONFIG_VT 1776 #ifdef CONFIG_VT
1777 if (device == MKDEV(TTY_MAJOR, 0)) { 1777 if (device == MKDEV(TTY_MAJOR, 0)) {
1778 extern struct tty_driver *console_driver; 1778 extern struct tty_driver *console_driver;
1779 driver = tty_driver_kref_get(console_driver); 1779 driver = tty_driver_kref_get(console_driver);
1780 index = fg_console; 1780 index = fg_console;
1781 noctty = 1; 1781 noctty = 1;
1782 goto got_driver; 1782 goto got_driver;
1783 } 1783 }
1784 #endif 1784 #endif
1785 if (device == MKDEV(TTYAUX_MAJOR, 1)) { 1785 if (device == MKDEV(TTYAUX_MAJOR, 1)) {
1786 struct tty_driver *console_driver = console_device(&index); 1786 struct tty_driver *console_driver = console_device(&index);
1787 if (console_driver) { 1787 if (console_driver) {
1788 driver = tty_driver_kref_get(console_driver); 1788 driver = tty_driver_kref_get(console_driver);
1789 if (driver) { 1789 if (driver) {
1790 /* Don't let /dev/console block */ 1790 /* Don't let /dev/console block */
1791 filp->f_flags |= O_NONBLOCK; 1791 filp->f_flags |= O_NONBLOCK;
1792 noctty = 1; 1792 noctty = 1;
1793 goto got_driver; 1793 goto got_driver;
1794 } 1794 }
1795 } 1795 }
1796 unlock_kernel(); 1796 unlock_kernel();
1797 mutex_unlock(&tty_mutex); 1797 mutex_unlock(&tty_mutex);
1798 return -ENODEV; 1798 return -ENODEV;
1799 } 1799 }
1800 1800
1801 driver = get_tty_driver(device, &index); 1801 driver = get_tty_driver(device, &index);
1802 if (!driver) { 1802 if (!driver) {
1803 unlock_kernel(); 1803 unlock_kernel();
1804 mutex_unlock(&tty_mutex); 1804 mutex_unlock(&tty_mutex);
1805 return -ENODEV; 1805 return -ENODEV;
1806 } 1806 }
1807 got_driver: 1807 got_driver:
1808 if (!tty) { 1808 if (!tty) {
1809 /* check whether we're reopening an existing tty */ 1809 /* check whether we're reopening an existing tty */
1810 tty = tty_driver_lookup_tty(driver, inode, index); 1810 tty = tty_driver_lookup_tty(driver, inode, index);
1811 1811
1812 if (IS_ERR(tty)) { 1812 if (IS_ERR(tty)) {
1813 unlock_kernel(); 1813 unlock_kernel();
1814 mutex_unlock(&tty_mutex); 1814 mutex_unlock(&tty_mutex);
1815 return PTR_ERR(tty); 1815 return PTR_ERR(tty);
1816 } 1816 }
1817 } 1817 }
1818 1818
1819 if (tty) { 1819 if (tty) {
1820 retval = tty_reopen(tty); 1820 retval = tty_reopen(tty);
1821 if (retval) 1821 if (retval)
1822 tty = ERR_PTR(retval); 1822 tty = ERR_PTR(retval);
1823 } else 1823 } else
1824 tty = tty_init_dev(driver, index, 0); 1824 tty = tty_init_dev(driver, index, 0);
1825 1825
1826 mutex_unlock(&tty_mutex); 1826 mutex_unlock(&tty_mutex);
1827 tty_driver_kref_put(driver); 1827 tty_driver_kref_put(driver);
1828 if (IS_ERR(tty)) { 1828 if (IS_ERR(tty)) {
1829 unlock_kernel(); 1829 unlock_kernel();
1830 return PTR_ERR(tty); 1830 return PTR_ERR(tty);
1831 } 1831 }
1832 1832
1833 filp->private_data = tty; 1833 filp->private_data = tty;
1834 file_move(filp, &tty->tty_files); 1834 file_move(filp, &tty->tty_files);
1835 check_tty_count(tty, "tty_open"); 1835 check_tty_count(tty, "tty_open");
1836 if (tty->driver->type == TTY_DRIVER_TYPE_PTY && 1836 if (tty->driver->type == TTY_DRIVER_TYPE_PTY &&
1837 tty->driver->subtype == PTY_TYPE_MASTER) 1837 tty->driver->subtype == PTY_TYPE_MASTER)
1838 noctty = 1; 1838 noctty = 1;
1839 #ifdef TTY_DEBUG_HANGUP 1839 #ifdef TTY_DEBUG_HANGUP
1840 printk(KERN_DEBUG "opening %s...", tty->name); 1840 printk(KERN_DEBUG "opening %s...", tty->name);
1841 #endif 1841 #endif
1842 if (!retval) { 1842 if (!retval) {
1843 if (tty->ops->open) 1843 if (tty->ops->open)
1844 retval = tty->ops->open(tty, filp); 1844 retval = tty->ops->open(tty, filp);
1845 else 1845 else
1846 retval = -ENODEV; 1846 retval = -ENODEV;
1847 } 1847 }
1848 filp->f_flags = saved_flags; 1848 filp->f_flags = saved_flags;
1849 1849
1850 if (!retval && test_bit(TTY_EXCLUSIVE, &tty->flags) && 1850 if (!retval && test_bit(TTY_EXCLUSIVE, &tty->flags) &&
1851 !capable(CAP_SYS_ADMIN)) 1851 !capable(CAP_SYS_ADMIN))
1852 retval = -EBUSY; 1852 retval = -EBUSY;
1853 1853
1854 if (retval) { 1854 if (retval) {
1855 #ifdef TTY_DEBUG_HANGUP 1855 #ifdef TTY_DEBUG_HANGUP
1856 printk(KERN_DEBUG "error %d in opening %s...", retval, 1856 printk(KERN_DEBUG "error %d in opening %s...", retval,
1857 tty->name); 1857 tty->name);
1858 #endif 1858 #endif
1859 tty_release(inode, filp); 1859 tty_release(inode, filp);
1860 if (retval != -ERESTARTSYS) { 1860 if (retval != -ERESTARTSYS) {
1861 unlock_kernel(); 1861 unlock_kernel();
1862 return retval; 1862 return retval;
1863 } 1863 }
1864 if (signal_pending(current)) { 1864 if (signal_pending(current)) {
1865 unlock_kernel(); 1865 unlock_kernel();
1866 return retval; 1866 return retval;
1867 } 1867 }
1868 schedule(); 1868 schedule();
1869 /* 1869 /*
1870 * Need to reset f_op in case a hangup happened. 1870 * Need to reset f_op in case a hangup happened.
1871 */ 1871 */
1872 if (filp->f_op == &hung_up_tty_fops) 1872 if (filp->f_op == &hung_up_tty_fops)
1873 filp->f_op = &tty_fops; 1873 filp->f_op = &tty_fops;
1874 goto retry_open; 1874 goto retry_open;
1875 } 1875 }
1876 unlock_kernel(); 1876 unlock_kernel();
1877 1877
1878 1878
1879 mutex_lock(&tty_mutex); 1879 mutex_lock(&tty_mutex);
1880 lock_kernel(); 1880 lock_kernel();
1881 spin_lock_irq(&current->sighand->siglock); 1881 spin_lock_irq(&current->sighand->siglock);
1882 if (!noctty && 1882 if (!noctty &&
1883 current->signal->leader && 1883 current->signal->leader &&
1884 !current->signal->tty && 1884 !current->signal->tty &&
1885 tty->session == NULL) 1885 tty->session == NULL)
1886 __proc_set_tty(current, tty); 1886 __proc_set_tty(current, tty);
1887 spin_unlock_irq(&current->sighand->siglock); 1887 spin_unlock_irq(&current->sighand->siglock);
1888 unlock_kernel(); 1888 unlock_kernel();
1889 mutex_unlock(&tty_mutex); 1889 mutex_unlock(&tty_mutex);
1890 return 0; 1890 return 0;
1891 } 1891 }
1892 1892
1893 1893
1894 1894
1895 /** 1895 /**
1896 * tty_poll - check tty status 1896 * tty_poll - check tty status
1897 * @filp: file being polled 1897 * @filp: file being polled
1898 * @wait: poll wait structures to update 1898 * @wait: poll wait structures to update
1899 * 1899 *
1900 * Call the line discipline polling method to obtain the poll 1900 * Call the line discipline polling method to obtain the poll
1901 * status of the device. 1901 * status of the device.
1902 * 1902 *
1903 * Locking: locks called line discipline but ldisc poll method 1903 * Locking: locks called line discipline but ldisc poll method
1904 * may be re-entered freely by other callers. 1904 * may be re-entered freely by other callers.
1905 */ 1905 */
1906 1906
1907 static unsigned int tty_poll(struct file *filp, poll_table *wait) 1907 static unsigned int tty_poll(struct file *filp, poll_table *wait)
1908 { 1908 {
1909 struct tty_struct *tty; 1909 struct tty_struct *tty;
1910 struct tty_ldisc *ld; 1910 struct tty_ldisc *ld;
1911 int ret = 0; 1911 int ret = 0;
1912 1912
1913 tty = (struct tty_struct *)filp->private_data; 1913 tty = (struct tty_struct *)filp->private_data;
1914 if (tty_paranoia_check(tty, filp->f_path.dentry->d_inode, "tty_poll")) 1914 if (tty_paranoia_check(tty, filp->f_path.dentry->d_inode, "tty_poll"))
1915 return 0; 1915 return 0;
1916 1916
1917 ld = tty_ldisc_ref_wait(tty); 1917 ld = tty_ldisc_ref_wait(tty);
1918 if (ld->ops->poll) 1918 if (ld->ops->poll)
1919 ret = (ld->ops->poll)(tty, filp, wait); 1919 ret = (ld->ops->poll)(tty, filp, wait);
1920 tty_ldisc_deref(ld); 1920 tty_ldisc_deref(ld);
1921 return ret; 1921 return ret;
1922 } 1922 }
1923 1923
1924 static int tty_fasync(int fd, struct file *filp, int on) 1924 static int tty_fasync(int fd, struct file *filp, int on)
1925 { 1925 {
1926 struct tty_struct *tty; 1926 struct tty_struct *tty;
1927 unsigned long flags; 1927 unsigned long flags;
1928 int retval = 0; 1928 int retval = 0;
1929 1929
1930 lock_kernel(); 1930 lock_kernel();
1931 tty = (struct tty_struct *)filp->private_data; 1931 tty = (struct tty_struct *)filp->private_data;
1932 if (tty_paranoia_check(tty, filp->f_path.dentry->d_inode, "tty_fasync")) 1932 if (tty_paranoia_check(tty, filp->f_path.dentry->d_inode, "tty_fasync"))
1933 goto out; 1933 goto out;
1934 1934
1935 retval = fasync_helper(fd, filp, on, &tty->fasync); 1935 retval = fasync_helper(fd, filp, on, &tty->fasync);
1936 if (retval <= 0) 1936 if (retval <= 0)
1937 goto out; 1937 goto out;
1938 1938
1939 if (on) { 1939 if (on) {
1940 enum pid_type type; 1940 enum pid_type type;
1941 struct pid *pid; 1941 struct pid *pid;
1942 if (!waitqueue_active(&tty->read_wait)) 1942 if (!waitqueue_active(&tty->read_wait))
1943 tty->minimum_to_wake = 1; 1943 tty->minimum_to_wake = 1;
1944 spin_lock_irqsave(&tty->ctrl_lock, flags); 1944 spin_lock_irqsave(&tty->ctrl_lock, flags);
1945 if (tty->pgrp) { 1945 if (tty->pgrp) {
1946 pid = tty->pgrp; 1946 pid = tty->pgrp;
1947 type = PIDTYPE_PGID; 1947 type = PIDTYPE_PGID;
1948 } else { 1948 } else {
1949 pid = task_pid(current); 1949 pid = task_pid(current);
1950 type = PIDTYPE_PID; 1950 type = PIDTYPE_PID;
1951 } 1951 }
1952 spin_unlock_irqrestore(&tty->ctrl_lock, flags); 1952 spin_unlock_irqrestore(&tty->ctrl_lock, flags);
1953 retval = __f_setown(filp, pid, type, 0); 1953 retval = __f_setown(filp, pid, type, 0);
1954 if (retval) 1954 if (retval)
1955 goto out; 1955 goto out;
1956 } else { 1956 } else {
1957 if (!tty->fasync && !waitqueue_active(&tty->read_wait)) 1957 if (!tty->fasync && !waitqueue_active(&tty->read_wait))
1958 tty->minimum_to_wake = N_TTY_BUF_SIZE; 1958 tty->minimum_to_wake = N_TTY_BUF_SIZE;
1959 } 1959 }
1960 retval = 0; 1960 retval = 0;
1961 out: 1961 out:
1962 unlock_kernel(); 1962 unlock_kernel();
1963 return retval; 1963 return retval;
1964 } 1964 }
1965 1965
1966 /** 1966 /**
1967 * tiocsti - fake input character 1967 * tiocsti - fake input character
1968 * @tty: tty to fake input into 1968 * @tty: tty to fake input into
1969 * @p: pointer to character 1969 * @p: pointer to character
1970 * 1970 *
1971 * Fake input to a tty device. Does the necessary locking and 1971 * Fake input to a tty device. Does the necessary locking and
1972 * input management. 1972 * input management.
1973 * 1973 *
1974 * FIXME: does not honour flow control ?? 1974 * FIXME: does not honour flow control ??
1975 * 1975 *
1976 * Locking: 1976 * Locking:
1977 * Called functions take tty_ldisc_lock 1977 * Called functions take tty_ldisc_lock
1978 * current->signal->tty check is safe without locks 1978 * current->signal->tty check is safe without locks
1979 * 1979 *
1980 * FIXME: may race normal receive processing 1980 * FIXME: may race normal receive processing
1981 */ 1981 */
1982 1982
1983 static int tiocsti(struct tty_struct *tty, char __user *p) 1983 static int tiocsti(struct tty_struct *tty, char __user *p)
1984 { 1984 {
1985 char ch, mbz = 0; 1985 char ch, mbz = 0;
1986 struct tty_ldisc *ld; 1986 struct tty_ldisc *ld;
1987 1987
1988 if ((current->signal->tty != tty) && !capable(CAP_SYS_ADMIN)) 1988 if ((current->signal->tty != tty) && !capable(CAP_SYS_ADMIN))
1989 return -EPERM; 1989 return -EPERM;
1990 if (get_user(ch, p)) 1990 if (get_user(ch, p))
1991 return -EFAULT; 1991 return -EFAULT;
1992 tty_audit_tiocsti(tty, ch); 1992 tty_audit_tiocsti(tty, ch);
1993 ld = tty_ldisc_ref_wait(tty); 1993 ld = tty_ldisc_ref_wait(tty);
1994 ld->ops->receive_buf(tty, &ch, &mbz, 1); 1994 ld->ops->receive_buf(tty, &ch, &mbz, 1);
1995 tty_ldisc_deref(ld); 1995 tty_ldisc_deref(ld);
1996 return 0; 1996 return 0;
1997 } 1997 }
1998 1998
1999 /** 1999 /**
2000 * tiocgwinsz - implement window query ioctl 2000 * tiocgwinsz - implement window query ioctl
2001 * @tty; tty 2001 * @tty; tty
2002 * @arg: user buffer for result 2002 * @arg: user buffer for result
2003 * 2003 *
2004 * Copies the kernel idea of the window size into the user buffer. 2004 * Copies the kernel idea of the window size into the user buffer.
2005 * 2005 *
2006 * Locking: tty->termios_mutex is taken to ensure the winsize data 2006 * Locking: tty->termios_mutex is taken to ensure the winsize data
2007 * is consistent. 2007 * is consistent.
2008 */ 2008 */
2009 2009
2010 static int tiocgwinsz(struct tty_struct *tty, struct winsize __user *arg) 2010 static int tiocgwinsz(struct tty_struct *tty, struct winsize __user *arg)
2011 { 2011 {
2012 int err; 2012 int err;
2013 2013
2014 mutex_lock(&tty->termios_mutex); 2014 mutex_lock(&tty->termios_mutex);
2015 err = copy_to_user(arg, &tty->winsize, sizeof(*arg)); 2015 err = copy_to_user(arg, &tty->winsize, sizeof(*arg));
2016 mutex_unlock(&tty->termios_mutex); 2016 mutex_unlock(&tty->termios_mutex);
2017 2017
2018 return err ? -EFAULT: 0; 2018 return err ? -EFAULT: 0;
2019 } 2019 }
2020 2020
2021 /** 2021 /**
2022 * tty_do_resize - resize event 2022 * tty_do_resize - resize event
2023 * @tty: tty being resized 2023 * @tty: tty being resized
2024 * @rows: rows (character) 2024 * @rows: rows (character)
2025 * @cols: cols (character) 2025 * @cols: cols (character)
2026 * 2026 *
2027 * Update the termios variables and send the neccessary signals to 2027 * Update the termios variables and send the neccessary signals to
2028 * peform a terminal resize correctly 2028 * peform a terminal resize correctly
2029 */ 2029 */
2030 2030
2031 int tty_do_resize(struct tty_struct *tty, struct winsize *ws) 2031 int tty_do_resize(struct tty_struct *tty, struct winsize *ws)
2032 { 2032 {
2033 struct pid *pgrp; 2033 struct pid *pgrp;
2034 unsigned long flags; 2034 unsigned long flags;
2035 2035
2036 /* Lock the tty */ 2036 /* Lock the tty */
2037 mutex_lock(&tty->termios_mutex); 2037 mutex_lock(&tty->termios_mutex);
2038 if (!memcmp(ws, &tty->winsize, sizeof(*ws))) 2038 if (!memcmp(ws, &tty->winsize, sizeof(*ws)))
2039 goto done; 2039 goto done;
2040 /* Get the PID values and reference them so we can 2040 /* Get the PID values and reference them so we can
2041 avoid holding the tty ctrl lock while sending signals */ 2041 avoid holding the tty ctrl lock while sending signals */
2042 spin_lock_irqsave(&tty->ctrl_lock, flags); 2042 spin_lock_irqsave(&tty->ctrl_lock, flags);
2043 pgrp = get_pid(tty->pgrp); 2043 pgrp = get_pid(tty->pgrp);
2044 spin_unlock_irqrestore(&tty->ctrl_lock, flags); 2044 spin_unlock_irqrestore(&tty->ctrl_lock, flags);
2045 2045
2046 if (pgrp) 2046 if (pgrp)
2047 kill_pgrp(pgrp, SIGWINCH, 1); 2047 kill_pgrp(pgrp, SIGWINCH, 1);
2048 put_pid(pgrp); 2048 put_pid(pgrp);
2049 2049
2050 tty->winsize = *ws; 2050 tty->winsize = *ws;
2051 done: 2051 done:
2052 mutex_unlock(&tty->termios_mutex); 2052 mutex_unlock(&tty->termios_mutex);
2053 return 0; 2053 return 0;
2054 } 2054 }
2055 2055
2056 /** 2056 /**
2057 * tiocswinsz - implement window size set ioctl 2057 * tiocswinsz - implement window size set ioctl
2058 * @tty; tty side of tty 2058 * @tty; tty side of tty
2059 * @arg: user buffer for result 2059 * @arg: user buffer for result
2060 * 2060 *
2061 * Copies the user idea of the window size to the kernel. Traditionally 2061 * Copies the user idea of the window size to the kernel. Traditionally
2062 * this is just advisory information but for the Linux console it 2062 * this is just advisory information but for the Linux console it
2063 * actually has driver level meaning and triggers a VC resize. 2063 * actually has driver level meaning and triggers a VC resize.
2064 * 2064 *
2065 * Locking: 2065 * Locking:
2066 * Driver dependant. The default do_resize method takes the 2066 * Driver dependant. The default do_resize method takes the
2067 * tty termios mutex and ctrl_lock. The console takes its own lock 2067 * tty termios mutex and ctrl_lock. The console takes its own lock
2068 * then calls into the default method. 2068 * then calls into the default method.
2069 */ 2069 */
2070 2070
2071 static int tiocswinsz(struct tty_struct *tty, struct winsize __user *arg) 2071 static int tiocswinsz(struct tty_struct *tty, struct winsize __user *arg)
2072 { 2072 {
2073 struct winsize tmp_ws; 2073 struct winsize tmp_ws;
2074 if (copy_from_user(&tmp_ws, arg, sizeof(*arg))) 2074 if (copy_from_user(&tmp_ws, arg, sizeof(*arg)))
2075 return -EFAULT; 2075 return -EFAULT;
2076 2076
2077 if (tty->ops->resize) 2077 if (tty->ops->resize)
2078 return tty->ops->resize(tty, &tmp_ws); 2078 return tty->ops->resize(tty, &tmp_ws);
2079 else 2079 else
2080 return tty_do_resize(tty, &tmp_ws); 2080 return tty_do_resize(tty, &tmp_ws);
2081 } 2081 }
2082 2082
2083 /** 2083 /**
2084 * tioccons - allow admin to move logical console 2084 * tioccons - allow admin to move logical console
2085 * @file: the file to become console 2085 * @file: the file to become console
2086 * 2086 *
2087 * Allow the adminstrator to move the redirected console device 2087 * Allow the adminstrator to move the redirected console device
2088 * 2088 *
2089 * Locking: uses redirect_lock to guard the redirect information 2089 * Locking: uses redirect_lock to guard the redirect information
2090 */ 2090 */
2091 2091
2092 static int tioccons(struct file *file) 2092 static int tioccons(struct file *file)
2093 { 2093 {
2094 if (!capable(CAP_SYS_ADMIN)) 2094 if (!capable(CAP_SYS_ADMIN))
2095 return -EPERM; 2095 return -EPERM;
2096 if (file->f_op->write == redirected_tty_write) { 2096 if (file->f_op->write == redirected_tty_write) {
2097 struct file *f; 2097 struct file *f;
2098 spin_lock(&redirect_lock); 2098 spin_lock(&redirect_lock);
2099 f = redirect; 2099 f = redirect;
2100 redirect = NULL; 2100 redirect = NULL;
2101 spin_unlock(&redirect_lock); 2101 spin_unlock(&redirect_lock);
2102 if (f) 2102 if (f)
2103 fput(f); 2103 fput(f);
2104 return 0; 2104 return 0;
2105 } 2105 }
2106 spin_lock(&redirect_lock); 2106 spin_lock(&redirect_lock);
2107 if (redirect) { 2107 if (redirect) {
2108 spin_unlock(&redirect_lock); 2108 spin_unlock(&redirect_lock);
2109 return -EBUSY; 2109 return -EBUSY;
2110 } 2110 }
2111 get_file(file); 2111 get_file(file);
2112 redirect = file; 2112 redirect = file;
2113 spin_unlock(&redirect_lock); 2113 spin_unlock(&redirect_lock);
2114 return 0; 2114 return 0;
2115 } 2115 }
2116 2116
2117 /** 2117 /**
2118 * fionbio - non blocking ioctl 2118 * fionbio - non blocking ioctl
2119 * @file: file to set blocking value 2119 * @file: file to set blocking value
2120 * @p: user parameter 2120 * @p: user parameter
2121 * 2121 *
2122 * Historical tty interfaces had a blocking control ioctl before 2122 * Historical tty interfaces had a blocking control ioctl before
2123 * the generic functionality existed. This piece of history is preserved 2123 * the generic functionality existed. This piece of history is preserved
2124 * in the expected tty API of posix OS's. 2124 * in the expected tty API of posix OS's.
2125 * 2125 *
2126 * Locking: none, the open file handle ensures it won't go away. 2126 * Locking: none, the open file handle ensures it won't go away.
2127 */ 2127 */
2128 2128
2129 static int fionbio(struct file *file, int __user *p) 2129 static int fionbio(struct file *file, int __user *p)
2130 { 2130 {
2131 int nonblock; 2131 int nonblock;
2132 2132
2133 if (get_user(nonblock, p)) 2133 if (get_user(nonblock, p))
2134 return -EFAULT; 2134 return -EFAULT;
2135 2135
2136 spin_lock(&file->f_lock); 2136 spin_lock(&file->f_lock);
2137 if (nonblock) 2137 if (nonblock)
2138 file->f_flags |= O_NONBLOCK; 2138 file->f_flags |= O_NONBLOCK;
2139 else 2139 else
2140 file->f_flags &= ~O_NONBLOCK; 2140 file->f_flags &= ~O_NONBLOCK;
2141 spin_unlock(&file->f_lock); 2141 spin_unlock(&file->f_lock);
2142 return 0; 2142 return 0;
2143 } 2143 }
2144 2144
2145 /** 2145 /**
2146 * tiocsctty - set controlling tty 2146 * tiocsctty - set controlling tty
2147 * @tty: tty structure 2147 * @tty: tty structure
2148 * @arg: user argument 2148 * @arg: user argument
2149 * 2149 *
2150 * This ioctl is used to manage job control. It permits a session 2150 * This ioctl is used to manage job control. It permits a session
2151 * leader to set this tty as the controlling tty for the session. 2151 * leader to set this tty as the controlling tty for the session.
2152 * 2152 *
2153 * Locking: 2153 * Locking:
2154 * Takes tty_mutex() to protect tty instance 2154 * Takes tty_mutex() to protect tty instance
2155 * Takes tasklist_lock internally to walk sessions 2155 * Takes tasklist_lock internally to walk sessions
2156 * Takes ->siglock() when updating signal->tty 2156 * Takes ->siglock() when updating signal->tty
2157 */ 2157 */
2158 2158
2159 static int tiocsctty(struct tty_struct *tty, int arg) 2159 static int tiocsctty(struct tty_struct *tty, int arg)
2160 { 2160 {
2161 int ret = 0; 2161 int ret = 0;
2162 if (current->signal->leader && (task_session(current) == tty->session)) 2162 if (current->signal->leader && (task_session(current) == tty->session))
2163 return ret; 2163 return ret;
2164 2164
2165 mutex_lock(&tty_mutex); 2165 mutex_lock(&tty_mutex);
2166 /* 2166 /*
2167 * The process must be a session leader and 2167 * The process must be a session leader and
2168 * not have a controlling tty already. 2168 * not have a controlling tty already.
2169 */ 2169 */
2170 if (!current->signal->leader || current->signal->tty) { 2170 if (!current->signal->leader || current->signal->tty) {
2171 ret = -EPERM; 2171 ret = -EPERM;
2172 goto unlock; 2172 goto unlock;
2173 } 2173 }
2174 2174
2175 if (tty->session) { 2175 if (tty->session) {
2176 /* 2176 /*
2177 * This tty is already the controlling 2177 * This tty is already the controlling
2178 * tty for another session group! 2178 * tty for another session group!
2179 */ 2179 */
2180 if (arg == 1 && capable(CAP_SYS_ADMIN)) { 2180 if (arg == 1 && capable(CAP_SYS_ADMIN)) {
2181 /* 2181 /*
2182 * Steal it away 2182 * Steal it away
2183 */ 2183 */
2184 read_lock(&tasklist_lock); 2184 read_lock(&tasklist_lock);
2185 session_clear_tty(tty->session); 2185 session_clear_tty(tty->session);
2186 read_unlock(&tasklist_lock); 2186 read_unlock(&tasklist_lock);
2187 } else { 2187 } else {
2188 ret = -EPERM; 2188 ret = -EPERM;
2189 goto unlock; 2189 goto unlock;
2190 } 2190 }
2191 } 2191 }
2192 proc_set_tty(current, tty); 2192 proc_set_tty(current, tty);
2193 unlock: 2193 unlock:
2194 mutex_unlock(&tty_mutex); 2194 mutex_unlock(&tty_mutex);
2195 return ret; 2195 return ret;
2196 } 2196 }
2197 2197
2198 /** 2198 /**
2199 * tty_get_pgrp - return a ref counted pgrp pid 2199 * tty_get_pgrp - return a ref counted pgrp pid
2200 * @tty: tty to read 2200 * @tty: tty to read
2201 * 2201 *
2202 * Returns a refcounted instance of the pid struct for the process 2202 * Returns a refcounted instance of the pid struct for the process
2203 * group controlling the tty. 2203 * group controlling the tty.
2204 */ 2204 */
2205 2205
2206 struct pid *tty_get_pgrp(struct tty_struct *tty) 2206 struct pid *tty_get_pgrp(struct tty_struct *tty)
2207 { 2207 {
2208 unsigned long flags; 2208 unsigned long flags;
2209 struct pid *pgrp; 2209 struct pid *pgrp;
2210 2210
2211 spin_lock_irqsave(&tty->ctrl_lock, flags); 2211 spin_lock_irqsave(&tty->ctrl_lock, flags);
2212 pgrp = get_pid(tty->pgrp); 2212 pgrp = get_pid(tty->pgrp);
2213 spin_unlock_irqrestore(&tty->ctrl_lock, flags); 2213 spin_unlock_irqrestore(&tty->ctrl_lock, flags);
2214 2214
2215 return pgrp; 2215 return pgrp;
2216 } 2216 }
2217 EXPORT_SYMBOL_GPL(tty_get_pgrp); 2217 EXPORT_SYMBOL_GPL(tty_get_pgrp);
2218 2218
2219 /** 2219 /**
2220 * tiocgpgrp - get process group 2220 * tiocgpgrp - get process group
2221 * @tty: tty passed by user 2221 * @tty: tty passed by user
2222 * @real_tty: tty side of the tty pased by the user if a pty else the tty 2222 * @real_tty: tty side of the tty pased by the user if a pty else the tty
2223 * @p: returned pid 2223 * @p: returned pid
2224 * 2224 *
2225 * Obtain the process group of the tty. If there is no process group 2225 * Obtain the process group of the tty. If there is no process group
2226 * return an error. 2226 * return an error.
2227 * 2227 *
2228 * Locking: none. Reference to current->signal->tty is safe. 2228 * Locking: none. Reference to current->signal->tty is safe.
2229 */ 2229 */
2230 2230
2231 static int tiocgpgrp(struct tty_struct *tty, struct tty_struct *real_tty, pid_t __user *p) 2231 static int tiocgpgrp(struct tty_struct *tty, struct tty_struct *real_tty, pid_t __user *p)
2232 { 2232 {
2233 struct pid *pid; 2233 struct pid *pid;
2234 int ret; 2234 int ret;
2235 /* 2235 /*
2236 * (tty == real_tty) is a cheap way of 2236 * (tty == real_tty) is a cheap way of
2237 * testing if the tty is NOT a master pty. 2237 * testing if the tty is NOT a master pty.
2238 */ 2238 */
2239 if (tty == real_tty && current->signal->tty != real_tty) 2239 if (tty == real_tty && current->signal->tty != real_tty)
2240 return -ENOTTY; 2240 return -ENOTTY;
2241 pid = tty_get_pgrp(real_tty); 2241 pid = tty_get_pgrp(real_tty);
2242 ret = put_user(pid_vnr(pid), p); 2242 ret = put_user(pid_vnr(pid), p);
2243 put_pid(pid); 2243 put_pid(pid);
2244 return ret; 2244 return ret;
2245 } 2245 }
2246 2246
2247 /** 2247 /**
2248 * tiocspgrp - attempt to set process group 2248 * tiocspgrp - attempt to set process group
2249 * @tty: tty passed by user 2249 * @tty: tty passed by user
2250 * @real_tty: tty side device matching tty passed by user 2250 * @real_tty: tty side device matching tty passed by user
2251 * @p: pid pointer 2251 * @p: pid pointer
2252 * 2252 *
2253 * Set the process group of the tty to the session passed. Only 2253 * Set the process group of the tty to the session passed. Only
2254 * permitted where the tty session is our session. 2254 * permitted where the tty session is our session.
2255 * 2255 *
2256 * Locking: RCU, ctrl lock 2256 * Locking: RCU, ctrl lock
2257 */ 2257 */
2258 2258
2259 static int tiocspgrp(struct tty_struct *tty, struct tty_struct *real_tty, pid_t __user *p) 2259 static int tiocspgrp(struct tty_struct *tty, struct tty_struct *real_tty, pid_t __user *p)
2260 { 2260 {
2261 struct pid *pgrp; 2261 struct pid *pgrp;
2262 pid_t pgrp_nr; 2262 pid_t pgrp_nr;
2263 int retval = tty_check_change(real_tty); 2263 int retval = tty_check_change(real_tty);
2264 unsigned long flags; 2264 unsigned long flags;
2265 2265
2266 if (retval == -EIO) 2266 if (retval == -EIO)
2267 return -ENOTTY; 2267 return -ENOTTY;
2268 if (retval) 2268 if (retval)
2269 return retval; 2269 return retval;
2270 if (!current->signal->tty || 2270 if (!current->signal->tty ||
2271 (current->signal->tty != real_tty) || 2271 (current->signal->tty != real_tty) ||
2272 (real_tty->session != task_session(current))) 2272 (real_tty->session != task_session(current)))
2273 return -ENOTTY; 2273 return -ENOTTY;
2274 if (get_user(pgrp_nr, p)) 2274 if (get_user(pgrp_nr, p))
2275 return -EFAULT; 2275 return -EFAULT;
2276 if (pgrp_nr < 0) 2276 if (pgrp_nr < 0)
2277 return -EINVAL; 2277 return -EINVAL;
2278 rcu_read_lock(); 2278 rcu_read_lock();
2279 pgrp = find_vpid(pgrp_nr); 2279 pgrp = find_vpid(pgrp_nr);
2280 retval = -ESRCH; 2280 retval = -ESRCH;
2281 if (!pgrp) 2281 if (!pgrp)
2282 goto out_unlock; 2282 goto out_unlock;
2283 retval = -EPERM; 2283 retval = -EPERM;
2284 if (session_of_pgrp(pgrp) != task_session(current)) 2284 if (session_of_pgrp(pgrp) != task_session(current))
2285 goto out_unlock; 2285 goto out_unlock;
2286 retval = 0; 2286 retval = 0;
2287 spin_lock_irqsave(&tty->ctrl_lock, flags); 2287 spin_lock_irqsave(&tty->ctrl_lock, flags);
2288 put_pid(real_tty->pgrp); 2288 put_pid(real_tty->pgrp);
2289 real_tty->pgrp = get_pid(pgrp); 2289 real_tty->pgrp = get_pid(pgrp);
2290 spin_unlock_irqrestore(&tty->ctrl_lock, flags); 2290 spin_unlock_irqrestore(&tty->ctrl_lock, flags);
2291 out_unlock: 2291 out_unlock:
2292 rcu_read_unlock(); 2292 rcu_read_unlock();
2293 return retval; 2293 return retval;
2294 } 2294 }
2295 2295
2296 /** 2296 /**
2297 * tiocgsid - get session id 2297 * tiocgsid - get session id
2298 * @tty: tty passed by user 2298 * @tty: tty passed by user
2299 * @real_tty: tty side of the tty pased by the user if a pty else the tty 2299 * @real_tty: tty side of the tty pased by the user if a pty else the tty
2300 * @p: pointer to returned session id 2300 * @p: pointer to returned session id
2301 * 2301 *
2302 * Obtain the session id of the tty. If there is no session 2302 * Obtain the session id of the tty. If there is no session
2303 * return an error. 2303 * return an error.
2304 * 2304 *
2305 * Locking: none. Reference to current->signal->tty is safe. 2305 * Locking: none. Reference to current->signal->tty is safe.
2306 */ 2306 */
2307 2307
2308 static int tiocgsid(struct tty_struct *tty, struct tty_struct *real_tty, pid_t __user *p) 2308 static int tiocgsid(struct tty_struct *tty, struct tty_struct *real_tty, pid_t __user *p)
2309 { 2309 {
2310 /* 2310 /*
2311 * (tty == real_tty) is a cheap way of 2311 * (tty == real_tty) is a cheap way of
2312 * testing if the tty is NOT a master pty. 2312 * testing if the tty is NOT a master pty.
2313 */ 2313 */
2314 if (tty == real_tty && current->signal->tty != real_tty) 2314 if (tty == real_tty && current->signal->tty != real_tty)
2315 return -ENOTTY; 2315 return -ENOTTY;
2316 if (!real_tty->session) 2316 if (!real_tty->session)
2317 return -ENOTTY; 2317 return -ENOTTY;
2318 return put_user(pid_vnr(real_tty->session), p); 2318 return put_user(pid_vnr(real_tty->session), p);
2319 } 2319 }
2320 2320
2321 /** 2321 /**
2322 * tiocsetd - set line discipline 2322 * tiocsetd - set line discipline
2323 * @tty: tty device 2323 * @tty: tty device
2324 * @p: pointer to user data 2324 * @p: pointer to user data
2325 * 2325 *
2326 * Set the line discipline according to user request. 2326 * Set the line discipline according to user request.
2327 * 2327 *
2328 * Locking: see tty_set_ldisc, this function is just a helper 2328 * Locking: see tty_set_ldisc, this function is just a helper
2329 */ 2329 */
2330 2330
2331 static int tiocsetd(struct tty_struct *tty, int __user *p) 2331 static int tiocsetd(struct tty_struct *tty, int __user *p)
2332 { 2332 {
2333 int ldisc; 2333 int ldisc;
2334 int ret; 2334 int ret;
2335 2335
2336 if (get_user(ldisc, p)) 2336 if (get_user(ldisc, p))
2337 return -EFAULT; 2337 return -EFAULT;
2338 2338
2339 ret = tty_set_ldisc(tty, ldisc); 2339 ret = tty_set_ldisc(tty, ldisc);
2340 2340
2341 return ret; 2341 return ret;
2342 } 2342 }
2343 2343
2344 /** 2344 /**
2345 * send_break - performed time break 2345 * send_break - performed time break
2346 * @tty: device to break on 2346 * @tty: device to break on
2347 * @duration: timeout in mS 2347 * @duration: timeout in mS
2348 * 2348 *
2349 * Perform a timed break on hardware that lacks its own driver level 2349 * Perform a timed break on hardware that lacks its own driver level
2350 * timed break functionality. 2350 * timed break functionality.
2351 * 2351 *
2352 * Locking: 2352 * Locking:
2353 * atomic_write_lock serializes 2353 * atomic_write_lock serializes
2354 * 2354 *
2355 */ 2355 */
2356 2356
2357 static int send_break(struct tty_struct *tty, unsigned int duration) 2357 static int send_break(struct tty_struct *tty, unsigned int duration)
2358 { 2358 {
2359 int retval; 2359 int retval;
2360 2360
2361 if (tty->ops->break_ctl == NULL) 2361 if (tty->ops->break_ctl == NULL)
2362 return 0; 2362 return 0;
2363 2363
2364 if (tty->driver->flags & TTY_DRIVER_HARDWARE_BREAK) 2364 if (tty->driver->flags & TTY_DRIVER_HARDWARE_BREAK)
2365 retval = tty->ops->break_ctl(tty, duration); 2365 retval = tty->ops->break_ctl(tty, duration);
2366 else { 2366 else {
2367 /* Do the work ourselves */ 2367 /* Do the work ourselves */
2368 if (tty_write_lock(tty, 0) < 0) 2368 if (tty_write_lock(tty, 0) < 0)
2369 return -EINTR; 2369 return -EINTR;
2370 retval = tty->ops->break_ctl(tty, -1); 2370 retval = tty->ops->break_ctl(tty, -1);
2371 if (retval) 2371 if (retval)
2372 goto out; 2372 goto out;
2373 if (!signal_pending(current)) 2373 if (!signal_pending(current))
2374 msleep_interruptible(duration); 2374 msleep_interruptible(duration);
2375 retval = tty->ops->break_ctl(tty, 0); 2375 retval = tty->ops->break_ctl(tty, 0);
2376 out: 2376 out:
2377 tty_write_unlock(tty); 2377 tty_write_unlock(tty);
2378 if (signal_pending(current)) 2378 if (signal_pending(current))
2379 retval = -EINTR; 2379 retval = -EINTR;
2380 } 2380 }
2381 return retval; 2381 return retval;
2382 } 2382 }
2383 2383
2384 /** 2384 /**
2385 * tty_tiocmget - get modem status 2385 * tty_tiocmget - get modem status
2386 * @tty: tty device 2386 * @tty: tty device
2387 * @file: user file pointer 2387 * @file: user file pointer
2388 * @p: pointer to result 2388 * @p: pointer to result
2389 * 2389 *
2390 * Obtain the modem status bits from the tty driver if the feature 2390 * Obtain the modem status bits from the tty driver if the feature
2391 * is supported. Return -EINVAL if it is not available. 2391 * is supported. Return -EINVAL if it is not available.
2392 * 2392 *
2393 * Locking: none (up to the driver) 2393 * Locking: none (up to the driver)
2394 */ 2394 */
2395 2395
2396 static int tty_tiocmget(struct tty_struct *tty, struct file *file, int __user *p) 2396 static int tty_tiocmget(struct tty_struct *tty, struct file *file, int __user *p)
2397 { 2397 {
2398 int retval = -EINVAL; 2398 int retval = -EINVAL;
2399 2399
2400 if (tty->ops->tiocmget) { 2400 if (tty->ops->tiocmget) {
2401 retval = tty->ops->tiocmget(tty, file); 2401 retval = tty->ops->tiocmget(tty, file);
2402 2402
2403 if (retval >= 0) 2403 if (retval >= 0)
2404 retval = put_user(retval, p); 2404 retval = put_user(retval, p);
2405 } 2405 }
2406 return retval; 2406 return retval;
2407 } 2407 }
2408 2408
2409 /** 2409 /**
2410 * tty_tiocmset - set modem status 2410 * tty_tiocmset - set modem status
2411 * @tty: tty device 2411 * @tty: tty device
2412 * @file: user file pointer 2412 * @file: user file pointer
2413 * @cmd: command - clear bits, set bits or set all 2413 * @cmd: command - clear bits, set bits or set all
2414 * @p: pointer to desired bits 2414 * @p: pointer to desired bits
2415 * 2415 *
2416 * Set the modem status bits from the tty driver if the feature 2416 * Set the modem status bits from the tty driver if the feature
2417 * is supported. Return -EINVAL if it is not available. 2417 * is supported. Return -EINVAL if it is not available.
2418 * 2418 *
2419 * Locking: none (up to the driver) 2419 * Locking: none (up to the driver)
2420 */ 2420 */
2421 2421
2422 static int tty_tiocmset(struct tty_struct *tty, struct file *file, unsigned int cmd, 2422 static int tty_tiocmset(struct tty_struct *tty, struct file *file, unsigned int cmd,
2423 unsigned __user *p) 2423 unsigned __user *p)
2424 { 2424 {
2425 int retval; 2425 int retval;
2426 unsigned int set, clear, val; 2426 unsigned int set, clear, val;
2427 2427
2428 if (tty->ops->tiocmset == NULL) 2428 if (tty->ops->tiocmset == NULL)
2429 return -EINVAL; 2429 return -EINVAL;
2430 2430
2431 retval = get_user(val, p); 2431 retval = get_user(val, p);
2432 if (retval) 2432 if (retval)
2433 return retval; 2433 return retval;
2434 set = clear = 0; 2434 set = clear = 0;
2435 switch (cmd) { 2435 switch (cmd) {
2436 case TIOCMBIS: 2436 case TIOCMBIS:
2437 set = val; 2437 set = val;
2438 break; 2438 break;
2439 case TIOCMBIC: 2439 case TIOCMBIC:
2440 clear = val; 2440 clear = val;
2441 break; 2441 break;
2442 case TIOCMSET: 2442 case TIOCMSET:
2443 set = val; 2443 set = val;
2444 clear = ~val; 2444 clear = ~val;
2445 break; 2445 break;
2446 } 2446 }
2447 set &= TIOCM_DTR|TIOCM_RTS|TIOCM_OUT1|TIOCM_OUT2|TIOCM_LOOP; 2447 set &= TIOCM_DTR|TIOCM_RTS|TIOCM_OUT1|TIOCM_OUT2|TIOCM_LOOP;
2448 clear &= TIOCM_DTR|TIOCM_RTS|TIOCM_OUT1|TIOCM_OUT2|TIOCM_LOOP; 2448 clear &= TIOCM_DTR|TIOCM_RTS|TIOCM_OUT1|TIOCM_OUT2|TIOCM_LOOP;
2449 return tty->ops->tiocmset(tty, file, set, clear); 2449 return tty->ops->tiocmset(tty, file, set, clear);
2450 } 2450 }
2451 2451
2452 struct tty_struct *tty_pair_get_tty(struct tty_struct *tty) 2452 struct tty_struct *tty_pair_get_tty(struct tty_struct *tty)
2453 { 2453 {
2454 if (tty->driver->type == TTY_DRIVER_TYPE_PTY && 2454 if (tty->driver->type == TTY_DRIVER_TYPE_PTY &&
2455 tty->driver->subtype == PTY_TYPE_MASTER) 2455 tty->driver->subtype == PTY_TYPE_MASTER)
2456 tty = tty->link; 2456 tty = tty->link;
2457 return tty; 2457 return tty;
2458 } 2458 }
2459 EXPORT_SYMBOL(tty_pair_get_tty); 2459 EXPORT_SYMBOL(tty_pair_get_tty);
2460 2460
2461 struct tty_struct *tty_pair_get_pty(struct tty_struct *tty) 2461 struct tty_struct *tty_pair_get_pty(struct tty_struct *tty)
2462 { 2462 {
2463 if (tty->driver->type == TTY_DRIVER_TYPE_PTY && 2463 if (tty->driver->type == TTY_DRIVER_TYPE_PTY &&
2464 tty->driver->subtype == PTY_TYPE_MASTER) 2464 tty->driver->subtype == PTY_TYPE_MASTER)
2465 return tty; 2465 return tty;
2466 return tty->link; 2466 return tty->link;
2467 } 2467 }
2468 EXPORT_SYMBOL(tty_pair_get_pty); 2468 EXPORT_SYMBOL(tty_pair_get_pty);
2469 2469
2470 /* 2470 /*
2471 * Split this up, as gcc can choke on it otherwise.. 2471 * Split this up, as gcc can choke on it otherwise..
2472 */ 2472 */
2473 long tty_ioctl(struct file *file, unsigned int cmd, unsigned long arg) 2473 long tty_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
2474 { 2474 {
2475 struct tty_struct *tty, *real_tty; 2475 struct tty_struct *tty, *real_tty;
2476 void __user *p = (void __user *)arg; 2476 void __user *p = (void __user *)arg;
2477 int retval; 2477 int retval;
2478 struct tty_ldisc *ld; 2478 struct tty_ldisc *ld;
2479 struct inode *inode = file->f_dentry->d_inode; 2479 struct inode *inode = file->f_dentry->d_inode;
2480 2480
2481 tty = (struct tty_struct *)file->private_data; 2481 tty = (struct tty_struct *)file->private_data;
2482 if (tty_paranoia_check(tty, inode, "tty_ioctl")) 2482 if (tty_paranoia_check(tty, inode, "tty_ioctl"))
2483 return -EINVAL; 2483 return -EINVAL;
2484 2484
2485 real_tty = tty_pair_get_tty(tty); 2485 real_tty = tty_pair_get_tty(tty);
2486 2486
2487 /* 2487 /*
2488 * Factor out some common prep work 2488 * Factor out some common prep work
2489 */ 2489 */
2490 switch (cmd) { 2490 switch (cmd) {
2491 case TIOCSETD: 2491 case TIOCSETD:
2492 case TIOCSBRK: 2492 case TIOCSBRK:
2493 case TIOCCBRK: 2493 case TIOCCBRK:
2494 case TCSBRK: 2494 case TCSBRK:
2495 case TCSBRKP: 2495 case TCSBRKP:
2496 retval = tty_check_change(tty); 2496 retval = tty_check_change(tty);
2497 if (retval) 2497 if (retval)
2498 return retval; 2498 return retval;
2499 if (cmd != TIOCCBRK) { 2499 if (cmd != TIOCCBRK) {
2500 tty_wait_until_sent(tty, 0); 2500 tty_wait_until_sent(tty, 0);
2501 if (signal_pending(current)) 2501 if (signal_pending(current))
2502 return -EINTR; 2502 return -EINTR;
2503 } 2503 }
2504 break; 2504 break;
2505 } 2505 }
2506 2506
2507 /* 2507 /*
2508 * Now do the stuff. 2508 * Now do the stuff.
2509 */ 2509 */
2510 switch (cmd) { 2510 switch (cmd) {
2511 case TIOCSTI: 2511 case TIOCSTI:
2512 return tiocsti(tty, p); 2512 return tiocsti(tty, p);
2513 case TIOCGWINSZ: 2513 case TIOCGWINSZ:
2514 return tiocgwinsz(real_tty, p); 2514 return tiocgwinsz(real_tty, p);
2515 case TIOCSWINSZ: 2515 case TIOCSWINSZ:
2516 return tiocswinsz(real_tty, p); 2516 return tiocswinsz(real_tty, p);
2517 case TIOCCONS: 2517 case TIOCCONS:
2518 return real_tty != tty ? -EINVAL : tioccons(file); 2518 return real_tty != tty ? -EINVAL : tioccons(file);
2519 case FIONBIO: 2519 case FIONBIO:
2520 return fionbio(file, p); 2520 return fionbio(file, p);
2521 case TIOCEXCL: 2521 case TIOCEXCL:
2522 set_bit(TTY_EXCLUSIVE, &tty->flags); 2522 set_bit(TTY_EXCLUSIVE, &tty->flags);
2523 return 0; 2523 return 0;
2524 case TIOCNXCL: 2524 case TIOCNXCL:
2525 clear_bit(TTY_EXCLUSIVE, &tty->flags); 2525 clear_bit(TTY_EXCLUSIVE, &tty->flags);
2526 return 0; 2526 return 0;
2527 case TIOCNOTTY: 2527 case TIOCNOTTY:
2528 if (current->signal->tty != tty) 2528 if (current->signal->tty != tty)
2529 return -ENOTTY; 2529 return -ENOTTY;
2530 no_tty(); 2530 no_tty();
2531 return 0; 2531 return 0;
2532 case TIOCSCTTY: 2532 case TIOCSCTTY:
2533 return tiocsctty(tty, arg); 2533 return tiocsctty(tty, arg);
2534 case TIOCGPGRP: 2534 case TIOCGPGRP:
2535 return tiocgpgrp(tty, real_tty, p); 2535 return tiocgpgrp(tty, real_tty, p);
2536 case TIOCSPGRP: 2536 case TIOCSPGRP:
2537 return tiocspgrp(tty, real_tty, p); 2537 return tiocspgrp(tty, real_tty, p);
2538 case TIOCGSID: 2538 case TIOCGSID:
2539 return tiocgsid(tty, real_tty, p); 2539 return tiocgsid(tty, real_tty, p);
2540 case TIOCGETD: 2540 case TIOCGETD:
2541 return put_user(tty->ldisc->ops->num, (int __user *)p); 2541 return put_user(tty->ldisc->ops->num, (int __user *)p);
2542 case TIOCSETD: 2542 case TIOCSETD:
2543 return tiocsetd(tty, p); 2543 return tiocsetd(tty, p);
2544 /* 2544 /*
2545 * Break handling 2545 * Break handling
2546 */ 2546 */
2547 case TIOCSBRK: /* Turn break on, unconditionally */ 2547 case TIOCSBRK: /* Turn break on, unconditionally */
2548 if (tty->ops->break_ctl) 2548 if (tty->ops->break_ctl)
2549 return tty->ops->break_ctl(tty, -1); 2549 return tty->ops->break_ctl(tty, -1);
2550 return 0; 2550 return 0;
2551 case TIOCCBRK: /* Turn break off, unconditionally */ 2551 case TIOCCBRK: /* Turn break off, unconditionally */
2552 if (tty->ops->break_ctl) 2552 if (tty->ops->break_ctl)
2553 return tty->ops->break_ctl(tty, 0); 2553 return tty->ops->break_ctl(tty, 0);
2554 return 0; 2554 return 0;
2555 case TCSBRK: /* SVID version: non-zero arg --> no break */ 2555 case TCSBRK: /* SVID version: non-zero arg --> no break */
2556 /* non-zero arg means wait for all output data 2556 /* non-zero arg means wait for all output data
2557 * to be sent (performed above) but don't send break. 2557 * to be sent (performed above) but don't send break.
2558 * This is used by the tcdrain() termios function. 2558 * This is used by the tcdrain() termios function.
2559 */ 2559 */
2560 if (!arg) 2560 if (!arg)
2561 return send_break(tty, 250); 2561 return send_break(tty, 250);
2562 return 0; 2562 return 0;
2563 case TCSBRKP: /* support for POSIX tcsendbreak() */ 2563 case TCSBRKP: /* support for POSIX tcsendbreak() */
2564 return send_break(tty, arg ? arg*100 : 250); 2564 return send_break(tty, arg ? arg*100 : 250);
2565 2565
2566 case TIOCMGET: 2566 case TIOCMGET:
2567 return tty_tiocmget(tty, file, p); 2567 return tty_tiocmget(tty, file, p);
2568 case TIOCMSET: 2568 case TIOCMSET:
2569 case TIOCMBIC: 2569 case TIOCMBIC:
2570 case TIOCMBIS: 2570 case TIOCMBIS:
2571 return tty_tiocmset(tty, file, cmd, p); 2571 return tty_tiocmset(tty, file, cmd, p);
2572 case TCFLSH: 2572 case TCFLSH:
2573 switch (arg) { 2573 switch (arg) {
2574 case TCIFLUSH: 2574 case TCIFLUSH:
2575 case TCIOFLUSH: 2575 case TCIOFLUSH:
2576 /* flush tty buffer and allow ldisc to process ioctl */ 2576 /* flush tty buffer and allow ldisc to process ioctl */
2577 tty_buffer_flush(tty); 2577 tty_buffer_flush(tty);
2578 break; 2578 break;
2579 } 2579 }
2580 break; 2580 break;
2581 } 2581 }
2582 if (tty->ops->ioctl) { 2582 if (tty->ops->ioctl) {
2583 retval = (tty->ops->ioctl)(tty, file, cmd, arg); 2583 retval = (tty->ops->ioctl)(tty, file, cmd, arg);
2584 if (retval != -ENOIOCTLCMD) 2584 if (retval != -ENOIOCTLCMD)
2585 return retval; 2585 return retval;
2586 } 2586 }
2587 ld = tty_ldisc_ref_wait(tty); 2587 ld = tty_ldisc_ref_wait(tty);
2588 retval = -EINVAL; 2588 retval = -EINVAL;
2589 if (ld->ops->ioctl) { 2589 if (ld->ops->ioctl) {
2590 retval = ld->ops->ioctl(tty, file, cmd, arg); 2590 retval = ld->ops->ioctl(tty, file, cmd, arg);
2591 if (retval == -ENOIOCTLCMD) 2591 if (retval == -ENOIOCTLCMD)
2592 retval = -EINVAL; 2592 retval = -EINVAL;
2593 } 2593 }
2594 tty_ldisc_deref(ld); 2594 tty_ldisc_deref(ld);
2595 return retval; 2595 return retval;
2596 } 2596 }
2597 2597
2598 #ifdef CONFIG_COMPAT 2598 #ifdef CONFIG_COMPAT
2599 static long tty_compat_ioctl(struct file *file, unsigned int cmd, 2599 static long tty_compat_ioctl(struct file *file, unsigned int cmd,
2600 unsigned long arg) 2600 unsigned long arg)
2601 { 2601 {
2602 struct inode *inode = file->f_dentry->d_inode; 2602 struct inode *inode = file->f_dentry->d_inode;
2603 struct tty_struct *tty = file->private_data; 2603 struct tty_struct *tty = file->private_data;
2604 struct tty_ldisc *ld; 2604 struct tty_ldisc *ld;
2605 int retval = -ENOIOCTLCMD; 2605 int retval = -ENOIOCTLCMD;
2606 2606
2607 if (tty_paranoia_check(tty, inode, "tty_ioctl")) 2607 if (tty_paranoia_check(tty, inode, "tty_ioctl"))
2608 return -EINVAL; 2608 return -EINVAL;
2609 2609
2610 if (tty->ops->compat_ioctl) { 2610 if (tty->ops->compat_ioctl) {
2611 retval = (tty->ops->compat_ioctl)(tty, file, cmd, arg); 2611 retval = (tty->ops->compat_ioctl)(tty, file, cmd, arg);
2612 if (retval != -ENOIOCTLCMD) 2612 if (retval != -ENOIOCTLCMD)
2613 return retval; 2613 return retval;
2614 } 2614 }
2615 2615
2616 ld = tty_ldisc_ref_wait(tty); 2616 ld = tty_ldisc_ref_wait(tty);
2617 if (ld->ops->compat_ioctl) 2617 if (ld->ops->compat_ioctl)
2618 retval = ld->ops->compat_ioctl(tty, file, cmd, arg); 2618 retval = ld->ops->compat_ioctl(tty, file, cmd, arg);
2619 tty_ldisc_deref(ld); 2619 tty_ldisc_deref(ld);
2620 2620
2621 return retval; 2621 return retval;
2622 } 2622 }
2623 #endif 2623 #endif
2624 2624
2625 /* 2625 /*
2626 * This implements the "Secure Attention Key" --- the idea is to 2626 * This implements the "Secure Attention Key" --- the idea is to
2627 * prevent trojan horses by killing all processes associated with this 2627 * prevent trojan horses by killing all processes associated with this
2628 * tty when the user hits the "Secure Attention Key". Required for 2628 * tty when the user hits the "Secure Attention Key". Required for
2629 * super-paranoid applications --- see the Orange Book for more details. 2629 * super-paranoid applications --- see the Orange Book for more details.
2630 * 2630 *
2631 * This code could be nicer; ideally it should send a HUP, wait a few 2631 * This code could be nicer; ideally it should send a HUP, wait a few
2632 * seconds, then send a INT, and then a KILL signal. But you then 2632 * seconds, then send a INT, and then a KILL signal. But you then
2633 * have to coordinate with the init process, since all processes associated 2633 * have to coordinate with the init process, since all processes associated
2634 * with the current tty must be dead before the new getty is allowed 2634 * with the current tty must be dead before the new getty is allowed
2635 * to spawn. 2635 * to spawn.
2636 * 2636 *
2637 * Now, if it would be correct ;-/ The current code has a nasty hole - 2637 * Now, if it would be correct ;-/ The current code has a nasty hole -
2638 * it doesn't catch files in flight. We may send the descriptor to ourselves 2638 * it doesn't catch files in flight. We may send the descriptor to ourselves
2639 * via AF_UNIX socket, close it and later fetch from socket. FIXME. 2639 * via AF_UNIX socket, close it and later fetch from socket. FIXME.
2640 * 2640 *
2641 * Nasty bug: do_SAK is being called in interrupt context. This can 2641 * Nasty bug: do_SAK is being called in interrupt context. This can
2642 * deadlock. We punt it up to process context. AKPM - 16Mar2001 2642 * deadlock. We punt it up to process context. AKPM - 16Mar2001
2643 */ 2643 */
2644 void __do_SAK(struct tty_struct *tty) 2644 void __do_SAK(struct tty_struct *tty)
2645 { 2645 {
2646 #ifdef TTY_SOFT_SAK 2646 #ifdef TTY_SOFT_SAK
2647 tty_hangup(tty); 2647 tty_hangup(tty);
2648 #else 2648 #else
2649 struct task_struct *g, *p; 2649 struct task_struct *g, *p;
2650 struct pid *session; 2650 struct pid *session;
2651 int i; 2651 int i;
2652 struct file *filp; 2652 struct file *filp;
2653 struct fdtable *fdt; 2653 struct fdtable *fdt;
2654 2654
2655 if (!tty) 2655 if (!tty)
2656 return; 2656 return;
2657 session = tty->session; 2657 session = tty->session;
2658 2658
2659 tty_ldisc_flush(tty); 2659 tty_ldisc_flush(tty);
2660 2660
2661 tty_driver_flush_buffer(tty); 2661 tty_driver_flush_buffer(tty);
2662 2662
2663 read_lock(&tasklist_lock); 2663 read_lock(&tasklist_lock);
2664 /* Kill the entire session */ 2664 /* Kill the entire session */
2665 do_each_pid_task(session, PIDTYPE_SID, p) { 2665 do_each_pid_task(session, PIDTYPE_SID, p) {
2666 printk(KERN_NOTICE "SAK: killed process %d" 2666 printk(KERN_NOTICE "SAK: killed process %d"
2667 " (%s): task_session(p)==tty->session\n", 2667 " (%s): task_session(p)==tty->session\n",
2668 task_pid_nr(p), p->comm); 2668 task_pid_nr(p), p->comm);
2669 send_sig(SIGKILL, p, 1); 2669 send_sig(SIGKILL, p, 1);
2670 } while_each_pid_task(session, PIDTYPE_SID, p); 2670 } while_each_pid_task(session, PIDTYPE_SID, p);
2671 /* Now kill any processes that happen to have the 2671 /* Now kill any processes that happen to have the
2672 * tty open. 2672 * tty open.
2673 */ 2673 */
2674 do_each_thread(g, p) { 2674 do_each_thread(g, p) {
2675 if (p->signal->tty == tty) { 2675 if (p->signal->tty == tty) {
2676 printk(KERN_NOTICE "SAK: killed process %d" 2676 printk(KERN_NOTICE "SAK: killed process %d"
2677 " (%s): task_session(p)==tty->session\n", 2677 " (%s): task_session(p)==tty->session\n",
2678 task_pid_nr(p), p->comm); 2678 task_pid_nr(p), p->comm);
2679 send_sig(SIGKILL, p, 1); 2679 send_sig(SIGKILL, p, 1);
2680 continue; 2680 continue;
2681 } 2681 }
2682 task_lock(p); 2682 task_lock(p);
2683 if (p->files) { 2683 if (p->files) {
2684 /* 2684 /*
2685 * We don't take a ref to the file, so we must 2685 * We don't take a ref to the file, so we must
2686 * hold ->file_lock instead. 2686 * hold ->file_lock instead.
2687 */ 2687 */
2688 spin_lock(&p->files->file_lock); 2688 spin_lock(&p->files->file_lock);
2689 fdt = files_fdtable(p->files); 2689 fdt = files_fdtable(p->files);
2690 for (i = 0; i < fdt->max_fds; i++) { 2690 for (i = 0; i < fdt->max_fds; i++) {
2691 filp = fcheck_files(p->files, i); 2691 filp = fcheck_files(p->files, i);
2692 if (!filp) 2692 if (!filp)
2693 continue; 2693 continue;
2694 if (filp->f_op->read == tty_read && 2694 if (filp->f_op->read == tty_read &&
2695 filp->private_data == tty) { 2695 filp->private_data == tty) {
2696 printk(KERN_NOTICE "SAK: killed process %d" 2696 printk(KERN_NOTICE "SAK: killed process %d"
2697 " (%s): fd#%d opened to the tty\n", 2697 " (%s): fd#%d opened to the tty\n",
2698 task_pid_nr(p), p->comm, i); 2698 task_pid_nr(p), p->comm, i);
2699 force_sig(SIGKILL, p); 2699 force_sig(SIGKILL, p);
2700 break; 2700 break;
2701 } 2701 }
2702 } 2702 }
2703 spin_unlock(&p->files->file_lock); 2703 spin_unlock(&p->files->file_lock);
2704 } 2704 }
2705 task_unlock(p); 2705 task_unlock(p);
2706 } while_each_thread(g, p); 2706 } while_each_thread(g, p);
2707 read_unlock(&tasklist_lock); 2707 read_unlock(&tasklist_lock);
2708 #endif 2708 #endif
2709 } 2709 }
2710 2710
2711 static void do_SAK_work(struct work_struct *work) 2711 static void do_SAK_work(struct work_struct *work)
2712 { 2712 {
2713 struct tty_struct *tty = 2713 struct tty_struct *tty =
2714 container_of(work, struct tty_struct, SAK_work); 2714 container_of(work, struct tty_struct, SAK_work);
2715 __do_SAK(tty); 2715 __do_SAK(tty);
2716 } 2716 }
2717 2717
2718 /* 2718 /*
2719 * The tq handling here is a little racy - tty->SAK_work may already be queued. 2719 * The tq handling here is a little racy - tty->SAK_work may already be queued.
2720 * Fortunately we don't need to worry, because if ->SAK_work is already queued, 2720 * Fortunately we don't need to worry, because if ->SAK_work is already queued,
2721 * the values which we write to it will be identical to the values which it 2721 * the values which we write to it will be identical to the values which it
2722 * already has. --akpm 2722 * already has. --akpm
2723 */ 2723 */
2724 void do_SAK(struct tty_struct *tty) 2724 void do_SAK(struct tty_struct *tty)
2725 { 2725 {
2726 if (!tty) 2726 if (!tty)
2727 return; 2727 return;
2728 schedule_work(&tty->SAK_work); 2728 schedule_work(&tty->SAK_work);
2729 } 2729 }
2730 2730
2731 EXPORT_SYMBOL(do_SAK); 2731 EXPORT_SYMBOL(do_SAK);
2732 2732
2733 /** 2733 /**
2734 * initialize_tty_struct 2734 * initialize_tty_struct
2735 * @tty: tty to initialize 2735 * @tty: tty to initialize
2736 * 2736 *
2737 * This subroutine initializes a tty structure that has been newly 2737 * This subroutine initializes a tty structure that has been newly
2738 * allocated. 2738 * allocated.
2739 * 2739 *
2740 * Locking: none - tty in question must not be exposed at this point 2740 * Locking: none - tty in question must not be exposed at this point
2741 */ 2741 */
2742 2742
2743 void initialize_tty_struct(struct tty_struct *tty, 2743 void initialize_tty_struct(struct tty_struct *tty,
2744 struct tty_driver *driver, int idx) 2744 struct tty_driver *driver, int idx)
2745 { 2745 {
2746 memset(tty, 0, sizeof(struct tty_struct)); 2746 memset(tty, 0, sizeof(struct tty_struct));
2747 kref_init(&tty->kref); 2747 kref_init(&tty->kref);
2748 tty->magic = TTY_MAGIC; 2748 tty->magic = TTY_MAGIC;
2749 tty_ldisc_init(tty); 2749 tty_ldisc_init(tty);
2750 tty->session = NULL; 2750 tty->session = NULL;
2751 tty->pgrp = NULL; 2751 tty->pgrp = NULL;
2752 tty->overrun_time = jiffies; 2752 tty->overrun_time = jiffies;
2753 tty->buf.head = tty->buf.tail = NULL; 2753 tty->buf.head = tty->buf.tail = NULL;
2754 tty_buffer_init(tty); 2754 tty_buffer_init(tty);
2755 mutex_init(&tty->termios_mutex); 2755 mutex_init(&tty->termios_mutex);
2756 mutex_init(&tty->ldisc_mutex); 2756 mutex_init(&tty->ldisc_mutex);
2757 init_waitqueue_head(&tty->write_wait); 2757 init_waitqueue_head(&tty->write_wait);
2758 init_waitqueue_head(&tty->read_wait); 2758 init_waitqueue_head(&tty->read_wait);
2759 INIT_WORK(&tty->hangup_work, do_tty_hangup); 2759 INIT_WORK(&tty->hangup_work, do_tty_hangup);
2760 mutex_init(&tty->atomic_read_lock); 2760 mutex_init(&tty->atomic_read_lock);
2761 mutex_init(&tty->atomic_write_lock); 2761 mutex_init(&tty->atomic_write_lock);
2762 mutex_init(&tty->output_lock); 2762 mutex_init(&tty->output_lock);
2763 mutex_init(&tty->echo_lock); 2763 mutex_init(&tty->echo_lock);
2764 spin_lock_init(&tty->read_lock); 2764 spin_lock_init(&tty->read_lock);
2765 spin_lock_init(&tty->ctrl_lock); 2765 spin_lock_init(&tty->ctrl_lock);
2766 INIT_LIST_HEAD(&tty->tty_files); 2766 INIT_LIST_HEAD(&tty->tty_files);
2767 INIT_WORK(&tty->SAK_work, do_SAK_work); 2767 INIT_WORK(&tty->SAK_work, do_SAK_work);
2768 2768
2769 tty->driver = driver; 2769 tty->driver = driver;
2770 tty->ops = driver->ops; 2770 tty->ops = driver->ops;
2771 tty->index = idx; 2771 tty->index = idx;
2772 tty_line_name(driver, idx, tty->name); 2772 tty_line_name(driver, idx, tty->name);
2773 } 2773 }
2774 2774
2775 /** 2775 /**
2776 * tty_put_char - write one character to a tty 2776 * tty_put_char - write one character to a tty
2777 * @tty: tty 2777 * @tty: tty
2778 * @ch: character 2778 * @ch: character
2779 * 2779 *
2780 * Write one byte to the tty using the provided put_char method 2780 * Write one byte to the tty using the provided put_char method
2781 * if present. Returns the number of characters successfully output. 2781 * if present. Returns the number of characters successfully output.
2782 * 2782 *
2783 * Note: the specific put_char operation in the driver layer may go 2783 * Note: the specific put_char operation in the driver layer may go
2784 * away soon. Don't call it directly, use this method 2784 * away soon. Don't call it directly, use this method
2785 */ 2785 */
2786 2786
2787 int tty_put_char(struct tty_struct *tty, unsigned char ch) 2787 int tty_put_char(struct tty_struct *tty, unsigned char ch)
2788 { 2788 {
2789 if (tty->ops->put_char) 2789 if (tty->ops->put_char)
2790 return tty->ops->put_char(tty, ch); 2790 return tty->ops->put_char(tty, ch);
2791 return tty->ops->write(tty, &ch, 1); 2791 return tty->ops->write(tty, &ch, 1);
2792 } 2792 }
2793 EXPORT_SYMBOL_GPL(tty_put_char); 2793 EXPORT_SYMBOL_GPL(tty_put_char);
2794 2794
2795 struct class *tty_class; 2795 struct class *tty_class;
2796 2796
2797 /** 2797 /**
2798 * tty_register_device - register a tty device 2798 * tty_register_device - register a tty device
2799 * @driver: the tty driver that describes the tty device 2799 * @driver: the tty driver that describes the tty device
2800 * @index: the index in the tty driver for this tty device 2800 * @index: the index in the tty driver for this tty device
2801 * @device: a struct device that is associated with this tty device. 2801 * @device: a struct device that is associated with this tty device.
2802 * This field is optional, if there is no known struct device 2802 * This field is optional, if there is no known struct device
2803 * for this tty device it can be set to NULL safely. 2803 * for this tty device it can be set to NULL safely.
2804 * 2804 *
2805 * Returns a pointer to the struct device for this tty device 2805 * Returns a pointer to the struct device for this tty device
2806 * (or ERR_PTR(-EFOO) on error). 2806 * (or ERR_PTR(-EFOO) on error).
2807 * 2807 *
2808 * This call is required to be made to register an individual tty device 2808 * This call is required to be made to register an individual tty device
2809 * if the tty driver's flags have the TTY_DRIVER_DYNAMIC_DEV bit set. If 2809 * if the tty driver's flags have the TTY_DRIVER_DYNAMIC_DEV bit set. If
2810 * that bit is not set, this function should not be called by a tty 2810 * that bit is not set, this function should not be called by a tty
2811 * driver. 2811 * driver.
2812 * 2812 *
2813 * Locking: ?? 2813 * Locking: ??
2814 */ 2814 */
2815 2815
2816 struct device *tty_register_device(struct tty_driver *driver, unsigned index, 2816 struct device *tty_register_device(struct tty_driver *driver, unsigned index,
2817 struct device *device) 2817 struct device *device)
2818 { 2818 {
2819 char name[64]; 2819 char name[64];
2820 dev_t dev = MKDEV(driver->major, driver->minor_start) + index; 2820 dev_t dev = MKDEV(driver->major, driver->minor_start) + index;
2821 2821
2822 if (index >= driver->num) { 2822 if (index >= driver->num) {
2823 printk(KERN_ERR "Attempt to register invalid tty line number " 2823 printk(KERN_ERR "Attempt to register invalid tty line number "
2824 " (%d).\n", index); 2824 " (%d).\n", index);
2825 return ERR_PTR(-EINVAL); 2825 return ERR_PTR(-EINVAL);
2826 } 2826 }
2827 2827
2828 if (driver->type == TTY_DRIVER_TYPE_PTY) 2828 if (driver->type == TTY_DRIVER_TYPE_PTY)
2829 pty_line_name(driver, index, name); 2829 pty_line_name(driver, index, name);
2830 else 2830 else
2831 tty_line_name(driver, index, name); 2831 tty_line_name(driver, index, name);
2832 2832
2833 return device_create(tty_class, device, dev, NULL, name); 2833 return device_create(tty_class, device, dev, NULL, name);
2834 } 2834 }
2835 EXPORT_SYMBOL(tty_register_device); 2835 EXPORT_SYMBOL(tty_register_device);
2836 2836
2837 /** 2837 /**
2838 * tty_unregister_device - unregister a tty device 2838 * tty_unregister_device - unregister a tty device
2839 * @driver: the tty driver that describes the tty device 2839 * @driver: the tty driver that describes the tty device
2840 * @index: the index in the tty driver for this tty device 2840 * @index: the index in the tty driver for this tty device
2841 * 2841 *
2842 * If a tty device is registered with a call to tty_register_device() then 2842 * If a tty device is registered with a call to tty_register_device() then
2843 * this function must be called when the tty device is gone. 2843 * this function must be called when the tty device is gone.
2844 * 2844 *
2845 * Locking: ?? 2845 * Locking: ??
2846 */ 2846 */
2847 2847
2848 void tty_unregister_device(struct tty_driver *driver, unsigned index) 2848 void tty_unregister_device(struct tty_driver *driver, unsigned index)
2849 { 2849 {
2850 device_destroy(tty_class, 2850 device_destroy(tty_class,
2851 MKDEV(driver->major, driver->minor_start) + index); 2851 MKDEV(driver->major, driver->minor_start) + index);
2852 } 2852 }
2853 EXPORT_SYMBOL(tty_unregister_device); 2853 EXPORT_SYMBOL(tty_unregister_device);
2854 2854
2855 struct tty_driver *alloc_tty_driver(int lines) 2855 struct tty_driver *alloc_tty_driver(int lines)
2856 { 2856 {
2857 struct tty_driver *driver; 2857 struct tty_driver *driver;
2858 2858
2859 driver = kzalloc(sizeof(struct tty_driver), GFP_KERNEL); 2859 driver = kzalloc(sizeof(struct tty_driver), GFP_KERNEL);
2860 if (driver) { 2860 if (driver) {
2861 kref_init(&driver->kref); 2861 kref_init(&driver->kref);
2862 driver->magic = TTY_DRIVER_MAGIC; 2862 driver->magic = TTY_DRIVER_MAGIC;
2863 driver->num = lines; 2863 driver->num = lines;
2864 /* later we'll move allocation of tables here */ 2864 /* later we'll move allocation of tables here */
2865 } 2865 }
2866 return driver; 2866 return driver;
2867 } 2867 }
2868 EXPORT_SYMBOL(alloc_tty_driver); 2868 EXPORT_SYMBOL(alloc_tty_driver);
2869 2869
2870 static void destruct_tty_driver(struct kref *kref) 2870 static void destruct_tty_driver(struct kref *kref)
2871 { 2871 {
2872 struct tty_driver *driver = container_of(kref, struct tty_driver, kref); 2872 struct tty_driver *driver = container_of(kref, struct tty_driver, kref);
2873 int i; 2873 int i;
2874 struct ktermios *tp; 2874 struct ktermios *tp;
2875 void *p; 2875 void *p;
2876 2876
2877 if (driver->flags & TTY_DRIVER_INSTALLED) { 2877 if (driver->flags & TTY_DRIVER_INSTALLED) {
2878 /* 2878 /*
2879 * Free the termios and termios_locked structures because 2879 * Free the termios and termios_locked structures because
2880 * we don't want to get memory leaks when modular tty 2880 * we don't want to get memory leaks when modular tty
2881 * drivers are removed from the kernel. 2881 * drivers are removed from the kernel.
2882 */ 2882 */
2883 for (i = 0; i < driver->num; i++) { 2883 for (i = 0; i < driver->num; i++) {
2884 tp = driver->termios[i]; 2884 tp = driver->termios[i];
2885 if (tp) { 2885 if (tp) {
2886 driver->termios[i] = NULL; 2886 driver->termios[i] = NULL;
2887 kfree(tp); 2887 kfree(tp);
2888 } 2888 }
2889 if (!(driver->flags & TTY_DRIVER_DYNAMIC_DEV)) 2889 if (!(driver->flags & TTY_DRIVER_DYNAMIC_DEV))
2890 tty_unregister_device(driver, i); 2890 tty_unregister_device(driver, i);
2891 } 2891 }
2892 p = driver->ttys; 2892 p = driver->ttys;
2893 proc_tty_unregister_driver(driver); 2893 proc_tty_unregister_driver(driver);
2894 driver->ttys = NULL; 2894 driver->ttys = NULL;
2895 driver->termios = NULL; 2895 driver->termios = NULL;
2896 kfree(p); 2896 kfree(p);
2897 cdev_del(&driver->cdev); 2897 cdev_del(&driver->cdev);
2898 } 2898 }
2899 kfree(driver); 2899 kfree(driver);
2900 } 2900 }
2901 2901
2902 void tty_driver_kref_put(struct tty_driver *driver) 2902 void tty_driver_kref_put(struct tty_driver *driver)
2903 { 2903 {
2904 kref_put(&driver->kref, destruct_tty_driver); 2904 kref_put(&driver->kref, destruct_tty_driver);
2905 } 2905 }
2906 EXPORT_SYMBOL(tty_driver_kref_put); 2906 EXPORT_SYMBOL(tty_driver_kref_put);
2907 2907
2908 void tty_set_operations(struct tty_driver *driver, 2908 void tty_set_operations(struct tty_driver *driver,
2909 const struct tty_operations *op) 2909 const struct tty_operations *op)
2910 { 2910 {
2911 driver->ops = op; 2911 driver->ops = op;
2912 }; 2912 };
2913 EXPORT_SYMBOL(tty_set_operations); 2913 EXPORT_SYMBOL(tty_set_operations);
2914 2914
2915 void put_tty_driver(struct tty_driver *d) 2915 void put_tty_driver(struct tty_driver *d)
2916 { 2916 {
2917 tty_driver_kref_put(d); 2917 tty_driver_kref_put(d);
2918 } 2918 }
2919 EXPORT_SYMBOL(put_tty_driver); 2919 EXPORT_SYMBOL(put_tty_driver);
2920 2920
2921 /* 2921 /*
2922 * Called by a tty driver to register itself. 2922 * Called by a tty driver to register itself.
2923 */ 2923 */
2924 int tty_register_driver(struct tty_driver *driver) 2924 int tty_register_driver(struct tty_driver *driver)
2925 { 2925 {
2926 int error; 2926 int error;
2927 int i; 2927 int i;
2928 dev_t dev; 2928 dev_t dev;
2929 void **p = NULL; 2929 void **p = NULL;
2930 2930
2931 if (!(driver->flags & TTY_DRIVER_DEVPTS_MEM) && driver->num) { 2931 if (!(driver->flags & TTY_DRIVER_DEVPTS_MEM) && driver->num) {
2932 p = kzalloc(driver->num * 2 * sizeof(void *), GFP_KERNEL); 2932 p = kzalloc(driver->num * 2 * sizeof(void *), GFP_KERNEL);
2933 if (!p) 2933 if (!p)
2934 return -ENOMEM; 2934 return -ENOMEM;
2935 } 2935 }
2936 2936
2937 if (!driver->major) { 2937 if (!driver->major) {
2938 error = alloc_chrdev_region(&dev, driver->minor_start, 2938 error = alloc_chrdev_region(&dev, driver->minor_start,
2939 driver->num, driver->name); 2939 driver->num, driver->name);
2940 if (!error) { 2940 if (!error) {
2941 driver->major = MAJOR(dev); 2941 driver->major = MAJOR(dev);
2942 driver->minor_start = MINOR(dev); 2942 driver->minor_start = MINOR(dev);
2943 } 2943 }
2944 } else { 2944 } else {
2945 dev = MKDEV(driver->major, driver->minor_start); 2945 dev = MKDEV(driver->major, driver->minor_start);
2946 error = register_chrdev_region(dev, driver->num, driver->name); 2946 error = register_chrdev_region(dev, driver->num, driver->name);
2947 } 2947 }
2948 if (error < 0) { 2948 if (error < 0) {
2949 kfree(p); 2949 kfree(p);
2950 return error; 2950 return error;
2951 } 2951 }
2952 2952
2953 if (p) { 2953 if (p) {
2954 driver->ttys = (struct tty_struct **)p; 2954 driver->ttys = (struct tty_struct **)p;
2955 driver->termios = (struct ktermios **)(p + driver->num); 2955 driver->termios = (struct ktermios **)(p + driver->num);
2956 } else { 2956 } else {
2957 driver->ttys = NULL; 2957 driver->ttys = NULL;
2958 driver->termios = NULL; 2958 driver->termios = NULL;
2959 } 2959 }
2960 2960
2961 cdev_init(&driver->cdev, &tty_fops); 2961 cdev_init(&driver->cdev, &tty_fops);
2962 driver->cdev.owner = driver->owner; 2962 driver->cdev.owner = driver->owner;
2963 error = cdev_add(&driver->cdev, dev, driver->num); 2963 error = cdev_add(&driver->cdev, dev, driver->num);
2964 if (error) { 2964 if (error) {
2965 unregister_chrdev_region(dev, driver->num); 2965 unregister_chrdev_region(dev, driver->num);
2966 driver->ttys = NULL; 2966 driver->ttys = NULL;
2967 driver->termios = NULL; 2967 driver->termios = NULL;
2968 kfree(p); 2968 kfree(p);
2969 return error; 2969 return error;
2970 } 2970 }
2971 2971
2972 mutex_lock(&tty_mutex); 2972 mutex_lock(&tty_mutex);
2973 list_add(&driver->tty_drivers, &tty_drivers); 2973 list_add(&driver->tty_drivers, &tty_drivers);
2974 mutex_unlock(&tty_mutex); 2974 mutex_unlock(&tty_mutex);
2975 2975
2976 if (!(driver->flags & TTY_DRIVER_DYNAMIC_DEV)) { 2976 if (!(driver->flags & TTY_DRIVER_DYNAMIC_DEV)) {
2977 for (i = 0; i < driver->num; i++) 2977 for (i = 0; i < driver->num; i++)
2978 tty_register_device(driver, i, NULL); 2978 tty_register_device(driver, i, NULL);
2979 } 2979 }
2980 proc_tty_register_driver(driver); 2980 proc_tty_register_driver(driver);
2981 driver->flags |= TTY_DRIVER_INSTALLED; 2981 driver->flags |= TTY_DRIVER_INSTALLED;
2982 return 0; 2982 return 0;
2983 } 2983 }
2984 2984
2985 EXPORT_SYMBOL(tty_register_driver); 2985 EXPORT_SYMBOL(tty_register_driver);
2986 2986
2987 /* 2987 /*
2988 * Called by a tty driver to unregister itself. 2988 * Called by a tty driver to unregister itself.
2989 */ 2989 */
2990 int tty_unregister_driver(struct tty_driver *driver) 2990 int tty_unregister_driver(struct tty_driver *driver)
2991 { 2991 {
2992 #if 0 2992 #if 0
2993 /* FIXME */ 2993 /* FIXME */
2994 if (driver->refcount) 2994 if (driver->refcount)
2995 return -EBUSY; 2995 return -EBUSY;
2996 #endif 2996 #endif
2997 unregister_chrdev_region(MKDEV(driver->major, driver->minor_start), 2997 unregister_chrdev_region(MKDEV(driver->major, driver->minor_start),
2998 driver->num); 2998 driver->num);
2999 mutex_lock(&tty_mutex); 2999 mutex_lock(&tty_mutex);
3000 list_del(&driver->tty_drivers); 3000 list_del(&driver->tty_drivers);
3001 mutex_unlock(&tty_mutex); 3001 mutex_unlock(&tty_mutex);
3002 return 0; 3002 return 0;
3003 } 3003 }
3004 3004
3005 EXPORT_SYMBOL(tty_unregister_driver); 3005 EXPORT_SYMBOL(tty_unregister_driver);
3006 3006
3007 dev_t tty_devnum(struct tty_struct *tty) 3007 dev_t tty_devnum(struct tty_struct *tty)
3008 { 3008 {
3009 return MKDEV(tty->driver->major, tty->driver->minor_start) + tty->index; 3009 return MKDEV(tty->driver->major, tty->driver->minor_start) + tty->index;
3010 } 3010 }
3011 EXPORT_SYMBOL(tty_devnum); 3011 EXPORT_SYMBOL(tty_devnum);
3012 3012
3013 void proc_clear_tty(struct task_struct *p) 3013 void proc_clear_tty(struct task_struct *p)
3014 { 3014 {
3015 unsigned long flags; 3015 unsigned long flags;
3016 struct tty_struct *tty; 3016 struct tty_struct *tty;
3017 spin_lock_irqsave(&p->sighand->siglock, flags); 3017 spin_lock_irqsave(&p->sighand->siglock, flags);
3018 tty = p->signal->tty; 3018 tty = p->signal->tty;
3019 p->signal->tty = NULL; 3019 p->signal->tty = NULL;
3020 spin_unlock_irqrestore(&p->sighand->siglock, flags); 3020 spin_unlock_irqrestore(&p->sighand->siglock, flags);
3021 tty_kref_put(tty); 3021 tty_kref_put(tty);
3022 } 3022 }
3023 3023
3024 /* Called under the sighand lock */ 3024 /* Called under the sighand lock */
3025 3025
3026 static void __proc_set_tty(struct task_struct *tsk, struct tty_struct *tty) 3026 static void __proc_set_tty(struct task_struct *tsk, struct tty_struct *tty)
3027 { 3027 {
3028 if (tty) { 3028 if (tty) {
3029 unsigned long flags; 3029 unsigned long flags;
3030 /* We should not have a session or pgrp to put here but.... */ 3030 /* We should not have a session or pgrp to put here but.... */
3031 spin_lock_irqsave(&tty->ctrl_lock, flags); 3031 spin_lock_irqsave(&tty->ctrl_lock, flags);
3032 put_pid(tty->session); 3032 put_pid(tty->session);
3033 put_pid(tty->pgrp); 3033 put_pid(tty->pgrp);
3034 tty->pgrp = get_pid(task_pgrp(tsk)); 3034 tty->pgrp = get_pid(task_pgrp(tsk));
3035 spin_unlock_irqrestore(&tty->ctrl_lock, flags); 3035 spin_unlock_irqrestore(&tty->ctrl_lock, flags);
3036 tty->session = get_pid(task_session(tsk)); 3036 tty->session = get_pid(task_session(tsk));
3037 if (tsk->signal->tty) { 3037 if (tsk->signal->tty) {
3038 printk(KERN_DEBUG "tty not NULL!!\n"); 3038 printk(KERN_DEBUG "tty not NULL!!\n");
3039 tty_kref_put(tsk->signal->tty); 3039 tty_kref_put(tsk->signal->tty);
3040 } 3040 }
3041 } 3041 }
3042 put_pid(tsk->signal->tty_old_pgrp); 3042 put_pid(tsk->signal->tty_old_pgrp);
3043 tsk->signal->tty = tty_kref_get(tty); 3043 tsk->signal->tty = tty_kref_get(tty);
3044 tsk->signal->tty_old_pgrp = NULL; 3044 tsk->signal->tty_old_pgrp = NULL;
3045 } 3045 }
3046 3046
3047 static void proc_set_tty(struct task_struct *tsk, struct tty_struct *tty) 3047 static void proc_set_tty(struct task_struct *tsk, struct tty_struct *tty)
3048 { 3048 {
3049 spin_lock_irq(&tsk->sighand->siglock); 3049 spin_lock_irq(&tsk->sighand->siglock);
3050 __proc_set_tty(tsk, tty); 3050 __proc_set_tty(tsk, tty);
3051 spin_unlock_irq(&tsk->sighand->siglock); 3051 spin_unlock_irq(&tsk->sighand->siglock);
3052 } 3052 }
3053 3053
3054 struct tty_struct *get_current_tty(void) 3054 struct tty_struct *get_current_tty(void)
3055 { 3055 {
3056 struct tty_struct *tty; 3056 struct tty_struct *tty;
3057 unsigned long flags; 3057 unsigned long flags;
3058 3058
3059 spin_lock_irqsave(&current->sighand->siglock, flags); 3059 spin_lock_irqsave(&current->sighand->siglock, flags);
3060 tty = tty_kref_get(current->signal->tty); 3060 tty = tty_kref_get(current->signal->tty);
3061 spin_unlock_irqrestore(&current->sighand->siglock, flags); 3061 spin_unlock_irqrestore(&current->sighand->siglock, flags);
3062 return tty; 3062 return tty;
3063 } 3063 }
3064 EXPORT_SYMBOL_GPL(get_current_tty); 3064 EXPORT_SYMBOL_GPL(get_current_tty);
3065 3065
3066 void tty_default_fops(struct file_operations *fops) 3066 void tty_default_fops(struct file_operations *fops)
3067 { 3067 {
3068 *fops = tty_fops; 3068 *fops = tty_fops;
3069 } 3069 }
3070 3070
3071 /* 3071 /*
3072 * Initialize the console device. This is called *early*, so 3072 * Initialize the console device. This is called *early*, so
3073 * we can't necessarily depend on lots of kernel help here. 3073 * we can't necessarily depend on lots of kernel help here.
3074 * Just do some early initializations, and do the complex setup 3074 * Just do some early initializations, and do the complex setup
3075 * later. 3075 * later.
3076 */ 3076 */
3077 void __init console_init(void) 3077 void __init console_init(void)
3078 { 3078 {
3079 initcall_t *call; 3079 initcall_t *call;
3080 3080
3081 /* Setup the default TTY line discipline. */ 3081 /* Setup the default TTY line discipline. */
3082 tty_ldisc_begin(); 3082 tty_ldisc_begin();
3083 3083
3084 /* 3084 /*
3085 * set up the console device so that later boot sequences can 3085 * set up the console device so that later boot sequences can
3086 * inform about problems etc.. 3086 * inform about problems etc..
3087 */ 3087 */
3088 call = __con_initcall_start; 3088 call = __con_initcall_start;
3089 while (call < __con_initcall_end) { 3089 while (call < __con_initcall_end) {
3090 (*call)(); 3090 (*call)();
3091 call++; 3091 call++;
3092 } 3092 }
3093 } 3093 }
3094 3094
3095 static char *tty_devnode(struct device *dev, mode_t *mode) 3095 static char *tty_devnode(struct device *dev, mode_t *mode)
3096 { 3096 {
3097 if (!mode) 3097 if (!mode)
3098 return NULL; 3098 return NULL;
3099 if (dev->devt == MKDEV(TTYAUX_MAJOR, 0) || 3099 if (dev->devt == MKDEV(TTYAUX_MAJOR, 0) ||
3100 dev->devt == MKDEV(TTYAUX_MAJOR, 2)) 3100 dev->devt == MKDEV(TTYAUX_MAJOR, 2))
3101 *mode = 0666; 3101 *mode = 0666;
3102 return NULL; 3102 return NULL;
3103 } 3103 }
3104 3104
3105 static int __init tty_class_init(void) 3105 static int __init tty_class_init(void)
3106 { 3106 {
3107 tty_class = class_create(THIS_MODULE, "tty"); 3107 tty_class = class_create(THIS_MODULE, "tty");
3108 if (IS_ERR(tty_class)) 3108 if (IS_ERR(tty_class))
3109 return PTR_ERR(tty_class); 3109 return PTR_ERR(tty_class);
3110 tty_class->devnode = tty_devnode; 3110 tty_class->devnode = tty_devnode;
3111 return 0; 3111 return 0;
3112 } 3112 }
3113 3113
3114 postcore_initcall(tty_class_init); 3114 postcore_initcall(tty_class_init);
3115 3115
3116 /* 3/2004 jmc: why do these devices exist? */ 3116 /* 3/2004 jmc: why do these devices exist? */
3117 3117
3118 static struct cdev tty_cdev, console_cdev; 3118 static struct cdev tty_cdev, console_cdev;
3119 3119
3120 /* 3120 /*
3121 * Ok, now we can initialize the rest of the tty devices and can count 3121 * Ok, now we can initialize the rest of the tty devices and can count
3122 * on memory allocations, interrupts etc.. 3122 * on memory allocations, interrupts etc..
3123 */ 3123 */
3124 static int __init tty_init(void) 3124 static int __init tty_init(void)
3125 { 3125 {
3126 cdev_init(&tty_cdev, &tty_fops); 3126 cdev_init(&tty_cdev, &tty_fops);
3127 if (cdev_add(&tty_cdev, MKDEV(TTYAUX_MAJOR, 0), 1) || 3127 if (cdev_add(&tty_cdev, MKDEV(TTYAUX_MAJOR, 0), 1) ||
3128 register_chrdev_region(MKDEV(TTYAUX_MAJOR, 0), 1, "/dev/tty") < 0) 3128 register_chrdev_region(MKDEV(TTYAUX_MAJOR, 0), 1, "/dev/tty") < 0)
3129 panic("Couldn't register /dev/tty driver\n"); 3129 panic("Couldn't register /dev/tty driver\n");
3130 device_create(tty_class, NULL, MKDEV(TTYAUX_MAJOR, 0), NULL, 3130 device_create(tty_class, NULL, MKDEV(TTYAUX_MAJOR, 0), NULL,
3131 "tty"); 3131 "tty");
3132 3132
3133 cdev_init(&console_cdev, &console_fops); 3133 cdev_init(&console_cdev, &console_fops);
3134 if (cdev_add(&console_cdev, MKDEV(TTYAUX_MAJOR, 1), 1) || 3134 if (cdev_add(&console_cdev, MKDEV(TTYAUX_MAJOR, 1), 1) ||
3135 register_chrdev_region(MKDEV(TTYAUX_MAJOR, 1), 1, "/dev/console") < 0) 3135 register_chrdev_region(MKDEV(TTYAUX_MAJOR, 1), 1, "/dev/console") < 0)
3136 panic("Couldn't register /dev/console driver\n"); 3136 panic("Couldn't register /dev/console driver\n");
3137 device_create(tty_class, NULL, MKDEV(TTYAUX_MAJOR, 1), NULL, 3137 device_create(tty_class, NULL, MKDEV(TTYAUX_MAJOR, 1), NULL,
3138 "console"); 3138 "console");
3139 3139
3140 #ifdef CONFIG_VT 3140 #ifdef CONFIG_VT
3141 vty_init(&console_fops); 3141 vty_init(&console_fops);
3142 #endif 3142 #endif
3143 return 0; 3143 return 0;
3144 } 3144 }