Doug / smarc-fsl-linux-kernel

Download as
Browse Code ยป

Commit 300420722e0734a4254f3b634e0f82664495d210

Authored by Jiri Slaby
Committed by Greg Kroah-Hartman
1 parent df92d0561d
Exists in master and in 6 other branches 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: ldisc, move wait idle to caller 

It is the only place where reinit is called from. And we really need
to wait for the old ldisc to go once. Actually this is the place where
the waiting originally was (before removed and re-added later).

This will make the fix in the following patch easier to implement.

Signed-off-by: Jiri Slaby <jslaby@suse.cz>
Cc: Dave Young <hidave.darkstar@gmail.com>
Cc: Dave Jones <davej@redhat.com>
Cc: Ben Hutchings <ben@decadent.org.uk>
Cc: Dmitriy Matrosov <sgf.dma@gmail.com>
Cc: Alan Cox <alan@lxorguk.ukuu.org.uk>
Cc: stable <stable@vger.kernel.org>
Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de>

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

drivers/tty/tty_ldisc.c
Diff comments   View file @ 3004207
1 #include <linux/types.h> 1 #include <linux/types.h>
2 #include <linux/major.h> 2 #include <linux/major.h>
3 #include <linux/errno.h> 3 #include <linux/errno.h>
4 #include <linux/signal.h> 4 #include <linux/signal.h>
5 #include <linux/fcntl.h> 5 #include <linux/fcntl.h>
6 #include <linux/sched.h> 6 #include <linux/sched.h>
7 #include <linux/interrupt.h> 7 #include <linux/interrupt.h>
8 #include <linux/tty.h> 8 #include <linux/tty.h>
9 #include <linux/tty_driver.h> 9 #include <linux/tty_driver.h>
10 #include <linux/tty_flip.h> 10 #include <linux/tty_flip.h>
11 #include <linux/devpts_fs.h> 11 #include <linux/devpts_fs.h>
12 #include <linux/file.h> 12 #include <linux/file.h>
13 #include <linux/console.h> 13 #include <linux/console.h>
14 #include <linux/timer.h> 14 #include <linux/timer.h>
15 #include <linux/ctype.h> 15 #include <linux/ctype.h>
16 #include <linux/kd.h> 16 #include <linux/kd.h>
17 #include <linux/mm.h> 17 #include <linux/mm.h>
18 #include <linux/string.h> 18 #include <linux/string.h>
19 #include <linux/slab.h> 19 #include <linux/slab.h>
20 #include <linux/poll.h> 20 #include <linux/poll.h>
21 #include <linux/proc_fs.h> 21 #include <linux/proc_fs.h>
22 #include <linux/init.h> 22 #include <linux/init.h>
23 #include <linux/module.h> 23 #include <linux/module.h>
24 #include <linux/device.h> 24 #include <linux/device.h>
25 #include <linux/wait.h> 25 #include <linux/wait.h>
26 #include <linux/bitops.h> 26 #include <linux/bitops.h>
27 #include <linux/delay.h> 27 #include <linux/delay.h>
28 #include <linux/seq_file.h> 28 #include <linux/seq_file.h>
29 29
30 #include <linux/uaccess.h> 30 #include <linux/uaccess.h>
31 #include <asm/system.h> 31 #include <asm/system.h>
32 32
33 #include <linux/kbd_kern.h> 33 #include <linux/kbd_kern.h>
34 #include <linux/vt_kern.h> 34 #include <linux/vt_kern.h>
35 #include <linux/selection.h> 35 #include <linux/selection.h>
36 36
37 #include <linux/kmod.h> 37 #include <linux/kmod.h>
38 #include <linux/nsproxy.h> 38 #include <linux/nsproxy.h>
39 39
40 /* 40 /*
41 * This guards the refcounted line discipline lists. The lock 41 * This guards the refcounted line discipline lists. The lock
42 * must be taken with irqs off because there are hangup path 42 * must be taken with irqs off because there are hangup path
43 * callers who will do ldisc lookups and cannot sleep. 43 * callers who will do ldisc lookups and cannot sleep.
44 */ 44 */
45 45
46 static DEFINE_SPINLOCK(tty_ldisc_lock); 46 static DEFINE_SPINLOCK(tty_ldisc_lock);
47 static DECLARE_WAIT_QUEUE_HEAD(tty_ldisc_wait); 47 static DECLARE_WAIT_QUEUE_HEAD(tty_ldisc_wait);
48 static DECLARE_WAIT_QUEUE_HEAD(tty_ldisc_idle); 48 static DECLARE_WAIT_QUEUE_HEAD(tty_ldisc_idle);
49 /* Line disc dispatch table */ 49 /* Line disc dispatch table */
50 static struct tty_ldisc_ops *tty_ldiscs[NR_LDISCS]; 50 static struct tty_ldisc_ops *tty_ldiscs[NR_LDISCS];
51 51
52 static inline struct tty_ldisc *get_ldisc(struct tty_ldisc *ld) 52 static inline struct tty_ldisc *get_ldisc(struct tty_ldisc *ld)
53 { 53 {
54 if (ld) 54 if (ld)
55 atomic_inc(&ld->users); 55 atomic_inc(&ld->users);
56 return ld; 56 return ld;
57 } 57 }
58 58
59 static void put_ldisc(struct tty_ldisc *ld) 59 static void put_ldisc(struct tty_ldisc *ld)
60 { 60 {
61 unsigned long flags; 61 unsigned long flags;
62 62
63 if (WARN_ON_ONCE(!ld)) 63 if (WARN_ON_ONCE(!ld))
64 return; 64 return;
65 65
66 /* 66 /*
67 * If this is the last user, free the ldisc, and 67 * If this is the last user, free the ldisc, and
68 * release the ldisc ops. 68 * release the ldisc ops.
69 * 69 *
70 * We really want an "atomic_dec_and_lock_irqsave()", 70 * We really want an "atomic_dec_and_lock_irqsave()",
71 * but we don't have it, so this does it by hand. 71 * but we don't have it, so this does it by hand.
72 */ 72 */
73 local_irq_save(flags); 73 local_irq_save(flags);
74 if (atomic_dec_and_lock(&ld->users, &tty_ldisc_lock)) { 74 if (atomic_dec_and_lock(&ld->users, &tty_ldisc_lock)) {
75 struct tty_ldisc_ops *ldo = ld->ops; 75 struct tty_ldisc_ops *ldo = ld->ops;
76 76
77 ldo->refcount--; 77 ldo->refcount--;
78 module_put(ldo->owner); 78 module_put(ldo->owner);
79 spin_unlock_irqrestore(&tty_ldisc_lock, flags); 79 spin_unlock_irqrestore(&tty_ldisc_lock, flags);
80 80
81 kfree(ld); 81 kfree(ld);
82 return; 82 return;
83 } 83 }
84 local_irq_restore(flags); 84 local_irq_restore(flags);
85 wake_up(&tty_ldisc_idle); 85 wake_up(&tty_ldisc_idle);
86 } 86 }
87 87
88 /** 88 /**
89 * tty_register_ldisc - install a line discipline 89 * tty_register_ldisc - install a line discipline
90 * @disc: ldisc number 90 * @disc: ldisc number
91 * @new_ldisc: pointer to the ldisc object 91 * @new_ldisc: pointer to the ldisc object
92 * 92 *
93 * Installs a new line discipline into the kernel. The discipline 93 * Installs a new line discipline into the kernel. The discipline
94 * is set up as unreferenced and then made available to the kernel 94 * is set up as unreferenced and then made available to the kernel
95 * from this point onwards. 95 * from this point onwards.
96 * 96 *
97 * Locking: 97 * Locking:
98 * takes tty_ldisc_lock to guard against ldisc races 98 * takes tty_ldisc_lock to guard against ldisc races
99 */ 99 */
100 100
101 int tty_register_ldisc(int disc, struct tty_ldisc_ops *new_ldisc) 101 int tty_register_ldisc(int disc, struct tty_ldisc_ops *new_ldisc)
102 { 102 {
103 unsigned long flags; 103 unsigned long flags;
104 int ret = 0; 104 int ret = 0;
105 105
106 if (disc < N_TTY || disc >= NR_LDISCS) 106 if (disc < N_TTY || disc >= NR_LDISCS)
107 return -EINVAL; 107 return -EINVAL;
108 108
109 spin_lock_irqsave(&tty_ldisc_lock, flags); 109 spin_lock_irqsave(&tty_ldisc_lock, flags);
110 tty_ldiscs[disc] = new_ldisc; 110 tty_ldiscs[disc] = new_ldisc;
111 new_ldisc->num = disc; 111 new_ldisc->num = disc;
112 new_ldisc->refcount = 0; 112 new_ldisc->refcount = 0;
113 spin_unlock_irqrestore(&tty_ldisc_lock, flags); 113 spin_unlock_irqrestore(&tty_ldisc_lock, flags);
114 114
115 return ret; 115 return ret;
116 } 116 }
117 EXPORT_SYMBOL(tty_register_ldisc); 117 EXPORT_SYMBOL(tty_register_ldisc);
118 118
119 /** 119 /**
120 * tty_unregister_ldisc - unload a line discipline 120 * tty_unregister_ldisc - unload a line discipline
121 * @disc: ldisc number 121 * @disc: ldisc number
122 * @new_ldisc: pointer to the ldisc object 122 * @new_ldisc: pointer to the ldisc object
123 * 123 *
124 * Remove a line discipline from the kernel providing it is not 124 * Remove a line discipline from the kernel providing it is not
125 * currently in use. 125 * currently in use.
126 * 126 *
127 * Locking: 127 * Locking:
128 * takes tty_ldisc_lock to guard against ldisc races 128 * takes tty_ldisc_lock to guard against ldisc races
129 */ 129 */
130 130
131 int tty_unregister_ldisc(int disc) 131 int tty_unregister_ldisc(int disc)
132 { 132 {
133 unsigned long flags; 133 unsigned long flags;
134 int ret = 0; 134 int ret = 0;
135 135
136 if (disc < N_TTY || disc >= NR_LDISCS) 136 if (disc < N_TTY || disc >= NR_LDISCS)
137 return -EINVAL; 137 return -EINVAL;
138 138
139 spin_lock_irqsave(&tty_ldisc_lock, flags); 139 spin_lock_irqsave(&tty_ldisc_lock, flags);
140 if (tty_ldiscs[disc]->refcount) 140 if (tty_ldiscs[disc]->refcount)
141 ret = -EBUSY; 141 ret = -EBUSY;
142 else 142 else
143 tty_ldiscs[disc] = NULL; 143 tty_ldiscs[disc] = NULL;
144 spin_unlock_irqrestore(&tty_ldisc_lock, flags); 144 spin_unlock_irqrestore(&tty_ldisc_lock, flags);
145 145
146 return ret; 146 return ret;
147 } 147 }
148 EXPORT_SYMBOL(tty_unregister_ldisc); 148 EXPORT_SYMBOL(tty_unregister_ldisc);
149 149
150 static struct tty_ldisc_ops *get_ldops(int disc) 150 static struct tty_ldisc_ops *get_ldops(int disc)
151 { 151 {
152 unsigned long flags; 152 unsigned long flags;
153 struct tty_ldisc_ops *ldops, *ret; 153 struct tty_ldisc_ops *ldops, *ret;
154 154
155 spin_lock_irqsave(&tty_ldisc_lock, flags); 155 spin_lock_irqsave(&tty_ldisc_lock, flags);
156 ret = ERR_PTR(-EINVAL); 156 ret = ERR_PTR(-EINVAL);
157 ldops = tty_ldiscs[disc]; 157 ldops = tty_ldiscs[disc];
158 if (ldops) { 158 if (ldops) {
159 ret = ERR_PTR(-EAGAIN); 159 ret = ERR_PTR(-EAGAIN);
160 if (try_module_get(ldops->owner)) { 160 if (try_module_get(ldops->owner)) {
161 ldops->refcount++; 161 ldops->refcount++;
162 ret = ldops; 162 ret = ldops;
163 } 163 }
164 } 164 }
165 spin_unlock_irqrestore(&tty_ldisc_lock, flags); 165 spin_unlock_irqrestore(&tty_ldisc_lock, flags);
166 return ret; 166 return ret;
167 } 167 }
168 168
169 static void put_ldops(struct tty_ldisc_ops *ldops) 169 static void put_ldops(struct tty_ldisc_ops *ldops)
170 { 170 {
171 unsigned long flags; 171 unsigned long flags;
172 172
173 spin_lock_irqsave(&tty_ldisc_lock, flags); 173 spin_lock_irqsave(&tty_ldisc_lock, flags);
174 ldops->refcount--; 174 ldops->refcount--;
175 module_put(ldops->owner); 175 module_put(ldops->owner);
176 spin_unlock_irqrestore(&tty_ldisc_lock, flags); 176 spin_unlock_irqrestore(&tty_ldisc_lock, flags);
177 } 177 }
178 178
179 /** 179 /**
180 * tty_ldisc_get - take a reference to an ldisc 180 * tty_ldisc_get - take a reference to an ldisc
181 * @disc: ldisc number 181 * @disc: ldisc number
182 * 182 *
183 * Takes a reference to a line discipline. Deals with refcounts and 183 * Takes a reference to a line discipline. Deals with refcounts and
184 * module locking counts. Returns NULL if the discipline is not available. 184 * module locking counts. Returns NULL if the discipline is not available.
185 * Returns a pointer to the discipline and bumps the ref count if it is 185 * Returns a pointer to the discipline and bumps the ref count if it is
186 * available 186 * available
187 * 187 *
188 * Locking: 188 * Locking:
189 * takes tty_ldisc_lock to guard against ldisc races 189 * takes tty_ldisc_lock to guard against ldisc races
190 */ 190 */
191 191
192 static struct tty_ldisc *tty_ldisc_get(int disc) 192 static struct tty_ldisc *tty_ldisc_get(int disc)
193 { 193 {
194 struct tty_ldisc *ld; 194 struct tty_ldisc *ld;
195 struct tty_ldisc_ops *ldops; 195 struct tty_ldisc_ops *ldops;
196 196
197 if (disc < N_TTY || disc >= NR_LDISCS) 197 if (disc < N_TTY || disc >= NR_LDISCS)
198 return ERR_PTR(-EINVAL); 198 return ERR_PTR(-EINVAL);
199 199
200 /* 200 /*
201 * Get the ldisc ops - we may need to request them to be loaded 201 * Get the ldisc ops - we may need to request them to be loaded
202 * dynamically and try again. 202 * dynamically and try again.
203 */ 203 */
204 ldops = get_ldops(disc); 204 ldops = get_ldops(disc);
205 if (IS_ERR(ldops)) { 205 if (IS_ERR(ldops)) {
206 request_module("tty-ldisc-%d", disc); 206 request_module("tty-ldisc-%d", disc);
207 ldops = get_ldops(disc); 207 ldops = get_ldops(disc);
208 if (IS_ERR(ldops)) 208 if (IS_ERR(ldops))
209 return ERR_CAST(ldops); 209 return ERR_CAST(ldops);
210 } 210 }
211 211
212 ld = kmalloc(sizeof(struct tty_ldisc), GFP_KERNEL); 212 ld = kmalloc(sizeof(struct tty_ldisc), GFP_KERNEL);
213 if (ld == NULL) { 213 if (ld == NULL) {
214 put_ldops(ldops); 214 put_ldops(ldops);
215 return ERR_PTR(-ENOMEM); 215 return ERR_PTR(-ENOMEM);
216 } 216 }
217 217
218 ld->ops = ldops; 218 ld->ops = ldops;
219 atomic_set(&ld->users, 1); 219 atomic_set(&ld->users, 1);
220 return ld; 220 return ld;
221 } 221 }
222 222
223 static void *tty_ldiscs_seq_start(struct seq_file *m, loff_t *pos) 223 static void *tty_ldiscs_seq_start(struct seq_file *m, loff_t *pos)
224 { 224 {
225 return (*pos < NR_LDISCS) ? pos : NULL; 225 return (*pos < NR_LDISCS) ? pos : NULL;
226 } 226 }
227 227
228 static void *tty_ldiscs_seq_next(struct seq_file *m, void *v, loff_t *pos) 228 static void *tty_ldiscs_seq_next(struct seq_file *m, void *v, loff_t *pos)
229 { 229 {
230 (*pos)++; 230 (*pos)++;
231 return (*pos < NR_LDISCS) ? pos : NULL; 231 return (*pos < NR_LDISCS) ? pos : NULL;
232 } 232 }
233 233
234 static void tty_ldiscs_seq_stop(struct seq_file *m, void *v) 234 static void tty_ldiscs_seq_stop(struct seq_file *m, void *v)
235 { 235 {
236 } 236 }
237 237
238 static int tty_ldiscs_seq_show(struct seq_file *m, void *v) 238 static int tty_ldiscs_seq_show(struct seq_file *m, void *v)
239 { 239 {
240 int i = *(loff_t *)v; 240 int i = *(loff_t *)v;
241 struct tty_ldisc_ops *ldops; 241 struct tty_ldisc_ops *ldops;
242 242
243 ldops = get_ldops(i); 243 ldops = get_ldops(i);
244 if (IS_ERR(ldops)) 244 if (IS_ERR(ldops))
245 return 0; 245 return 0;
246 seq_printf(m, "%-10s %2d\n", ldops->name ? ldops->name : "???", i); 246 seq_printf(m, "%-10s %2d\n", ldops->name ? ldops->name : "???", i);
247 put_ldops(ldops); 247 put_ldops(ldops);
248 return 0; 248 return 0;
249 } 249 }
250 250
251 static const struct seq_operations tty_ldiscs_seq_ops = { 251 static const struct seq_operations tty_ldiscs_seq_ops = {
252 .start = tty_ldiscs_seq_start, 252 .start = tty_ldiscs_seq_start,
253 .next = tty_ldiscs_seq_next, 253 .next = tty_ldiscs_seq_next,
254 .stop = tty_ldiscs_seq_stop, 254 .stop = tty_ldiscs_seq_stop,
255 .show = tty_ldiscs_seq_show, 255 .show = tty_ldiscs_seq_show,
256 }; 256 };
257 257
258 static int proc_tty_ldiscs_open(struct inode *inode, struct file *file) 258 static int proc_tty_ldiscs_open(struct inode *inode, struct file *file)
259 { 259 {
260 return seq_open(file, &tty_ldiscs_seq_ops); 260 return seq_open(file, &tty_ldiscs_seq_ops);
261 } 261 }
262 262
263 const struct file_operations tty_ldiscs_proc_fops = { 263 const struct file_operations tty_ldiscs_proc_fops = {
264 .owner = THIS_MODULE, 264 .owner = THIS_MODULE,
265 .open = proc_tty_ldiscs_open, 265 .open = proc_tty_ldiscs_open,
266 .read = seq_read, 266 .read = seq_read,
267 .llseek = seq_lseek, 267 .llseek = seq_lseek,
268 .release = seq_release, 268 .release = seq_release,
269 }; 269 };
270 270
271 /** 271 /**
272 * tty_ldisc_assign - set ldisc on a tty 272 * tty_ldisc_assign - set ldisc on a tty
273 * @tty: tty to assign 273 * @tty: tty to assign
274 * @ld: line discipline 274 * @ld: line discipline
275 * 275 *
276 * Install an instance of a line discipline into a tty structure. The 276 * Install an instance of a line discipline into a tty structure. The
277 * ldisc must have a reference count above zero to ensure it remains. 277 * ldisc must have a reference count above zero to ensure it remains.
278 * The tty instance refcount starts at zero. 278 * The tty instance refcount starts at zero.
279 * 279 *
280 * Locking: 280 * Locking:
281 * Caller must hold references 281 * Caller must hold references
282 */ 282 */
283 283
284 static void tty_ldisc_assign(struct tty_struct *tty, struct tty_ldisc *ld) 284 static void tty_ldisc_assign(struct tty_struct *tty, struct tty_ldisc *ld)
285 { 285 {
286 tty->ldisc = ld; 286 tty->ldisc = ld;
287 } 287 }
288 288
289 /** 289 /**
290 * tty_ldisc_try - internal helper 290 * tty_ldisc_try - internal helper
291 * @tty: the tty 291 * @tty: the tty
292 * 292 *
293 * Make a single attempt to grab and bump the refcount on 293 * Make a single attempt to grab and bump the refcount on
294 * the tty ldisc. Return 0 on failure or 1 on success. This is 294 * the tty ldisc. Return 0 on failure or 1 on success. This is
295 * used to implement both the waiting and non waiting versions 295 * used to implement both the waiting and non waiting versions
296 * of tty_ldisc_ref 296 * of tty_ldisc_ref
297 * 297 *
298 * Locking: takes tty_ldisc_lock 298 * Locking: takes tty_ldisc_lock
299 */ 299 */
300 300
301 static struct tty_ldisc *tty_ldisc_try(struct tty_struct *tty) 301 static struct tty_ldisc *tty_ldisc_try(struct tty_struct *tty)
302 { 302 {
303 unsigned long flags; 303 unsigned long flags;
304 struct tty_ldisc *ld; 304 struct tty_ldisc *ld;
305 305
306 spin_lock_irqsave(&tty_ldisc_lock, flags); 306 spin_lock_irqsave(&tty_ldisc_lock, flags);
307 ld = NULL; 307 ld = NULL;
308 if (test_bit(TTY_LDISC, &tty->flags)) 308 if (test_bit(TTY_LDISC, &tty->flags))
309 ld = get_ldisc(tty->ldisc); 309 ld = get_ldisc(tty->ldisc);
310 spin_unlock_irqrestore(&tty_ldisc_lock, flags); 310 spin_unlock_irqrestore(&tty_ldisc_lock, flags);
311 return ld; 311 return ld;
312 } 312 }
313 313
314 /** 314 /**
315 * tty_ldisc_ref_wait - wait for the tty ldisc 315 * tty_ldisc_ref_wait - wait for the tty ldisc
316 * @tty: tty device 316 * @tty: tty device
317 * 317 *
318 * Dereference the line discipline for the terminal and take a 318 * Dereference the line discipline for the terminal and take a
319 * reference to it. If the line discipline is in flux then 319 * reference to it. If the line discipline is in flux then
320 * wait patiently until it changes. 320 * wait patiently until it changes.
321 * 321 *
322 * Note: Must not be called from an IRQ/timer context. The caller 322 * Note: Must not be called from an IRQ/timer context. The caller
323 * must also be careful not to hold other locks that will deadlock 323 * must also be careful not to hold other locks that will deadlock
324 * against a discipline change, such as an existing ldisc reference 324 * against a discipline change, such as an existing ldisc reference
325 * (which we check for) 325 * (which we check for)
326 * 326 *
327 * Locking: call functions take tty_ldisc_lock 327 * Locking: call functions take tty_ldisc_lock
328 */ 328 */
329 329
330 struct tty_ldisc *tty_ldisc_ref_wait(struct tty_struct *tty) 330 struct tty_ldisc *tty_ldisc_ref_wait(struct tty_struct *tty)
331 { 331 {
332 struct tty_ldisc *ld; 332 struct tty_ldisc *ld;
333 333
334 /* wait_event is a macro */ 334 /* wait_event is a macro */
335 wait_event(tty_ldisc_wait, (ld = tty_ldisc_try(tty)) != NULL); 335 wait_event(tty_ldisc_wait, (ld = tty_ldisc_try(tty)) != NULL);
336 return ld; 336 return ld;
337 } 337 }
338 EXPORT_SYMBOL_GPL(tty_ldisc_ref_wait); 338 EXPORT_SYMBOL_GPL(tty_ldisc_ref_wait);
339 339
340 /** 340 /**
341 * tty_ldisc_ref - get the tty ldisc 341 * tty_ldisc_ref - get the tty ldisc
342 * @tty: tty device 342 * @tty: tty device
343 * 343 *
344 * Dereference the line discipline for the terminal and take a 344 * Dereference the line discipline for the terminal and take a
345 * reference to it. If the line discipline is in flux then 345 * reference to it. If the line discipline is in flux then
346 * return NULL. Can be called from IRQ and timer functions. 346 * return NULL. Can be called from IRQ and timer functions.
347 * 347 *
348 * Locking: called functions take tty_ldisc_lock 348 * Locking: called functions take tty_ldisc_lock
349 */ 349 */
350 350
351 struct tty_ldisc *tty_ldisc_ref(struct tty_struct *tty) 351 struct tty_ldisc *tty_ldisc_ref(struct tty_struct *tty)
352 { 352 {
353 return tty_ldisc_try(tty); 353 return tty_ldisc_try(tty);
354 } 354 }
355 EXPORT_SYMBOL_GPL(tty_ldisc_ref); 355 EXPORT_SYMBOL_GPL(tty_ldisc_ref);
356 356
357 /** 357 /**
358 * tty_ldisc_deref - free a tty ldisc reference 358 * tty_ldisc_deref - free a tty ldisc reference
359 * @ld: reference to free up 359 * @ld: reference to free up
360 * 360 *
361 * Undoes the effect of tty_ldisc_ref or tty_ldisc_ref_wait. May 361 * Undoes the effect of tty_ldisc_ref or tty_ldisc_ref_wait. May
362 * be called in IRQ context. 362 * be called in IRQ context.
363 * 363 *
364 * Locking: takes tty_ldisc_lock 364 * Locking: takes tty_ldisc_lock
365 */ 365 */
366 366
367 void tty_ldisc_deref(struct tty_ldisc *ld) 367 void tty_ldisc_deref(struct tty_ldisc *ld)
368 { 368 {
369 put_ldisc(ld); 369 put_ldisc(ld);
370 } 370 }
371 EXPORT_SYMBOL_GPL(tty_ldisc_deref); 371 EXPORT_SYMBOL_GPL(tty_ldisc_deref);
372 372
373 static inline void tty_ldisc_put(struct tty_ldisc *ld) 373 static inline void tty_ldisc_put(struct tty_ldisc *ld)
374 { 374 {
375 put_ldisc(ld); 375 put_ldisc(ld);
376 } 376 }
377 377
378 /** 378 /**
379 * tty_ldisc_enable - allow ldisc use 379 * tty_ldisc_enable - allow ldisc use
380 * @tty: terminal to activate ldisc on 380 * @tty: terminal to activate ldisc on
381 * 381 *
382 * Set the TTY_LDISC flag when the line discipline can be called 382 * Set the TTY_LDISC flag when the line discipline can be called
383 * again. Do necessary wakeups for existing sleepers. Clear the LDISC 383 * again. Do necessary wakeups for existing sleepers. Clear the LDISC
384 * changing flag to indicate any ldisc change is now over. 384 * changing flag to indicate any ldisc change is now over.
385 * 385 *
386 * Note: nobody should set the TTY_LDISC bit except via this function. 386 * Note: nobody should set the TTY_LDISC bit except via this function.
387 * Clearing directly is allowed. 387 * Clearing directly is allowed.
388 */ 388 */
389 389
390 void tty_ldisc_enable(struct tty_struct *tty) 390 void tty_ldisc_enable(struct tty_struct *tty)
391 { 391 {
392 set_bit(TTY_LDISC, &tty->flags); 392 set_bit(TTY_LDISC, &tty->flags);
393 clear_bit(TTY_LDISC_CHANGING, &tty->flags); 393 clear_bit(TTY_LDISC_CHANGING, &tty->flags);
394 wake_up(&tty_ldisc_wait); 394 wake_up(&tty_ldisc_wait);
395 } 395 }
396 396
397 /** 397 /**
398 * tty_ldisc_flush - flush line discipline queue 398 * tty_ldisc_flush - flush line discipline queue
399 * @tty: tty 399 * @tty: tty
400 * 400 *
401 * Flush the line discipline queue (if any) for this tty. If there 401 * Flush the line discipline queue (if any) for this tty. If there
402 * is no line discipline active this is a no-op. 402 * is no line discipline active this is a no-op.
403 */ 403 */
404 404
405 void tty_ldisc_flush(struct tty_struct *tty) 405 void tty_ldisc_flush(struct tty_struct *tty)
406 { 406 {
407 struct tty_ldisc *ld = tty_ldisc_ref(tty); 407 struct tty_ldisc *ld = tty_ldisc_ref(tty);
408 if (ld) { 408 if (ld) {
409 if (ld->ops->flush_buffer) 409 if (ld->ops->flush_buffer)
410 ld->ops->flush_buffer(tty); 410 ld->ops->flush_buffer(tty);
411 tty_ldisc_deref(ld); 411 tty_ldisc_deref(ld);
412 } 412 }
413 tty_buffer_flush(tty); 413 tty_buffer_flush(tty);
414 } 414 }
415 EXPORT_SYMBOL_GPL(tty_ldisc_flush); 415 EXPORT_SYMBOL_GPL(tty_ldisc_flush);
416 416
417 /** 417 /**
418 * tty_set_termios_ldisc - set ldisc field 418 * tty_set_termios_ldisc - set ldisc field
419 * @tty: tty structure 419 * @tty: tty structure
420 * @num: line discipline number 420 * @num: line discipline number
421 * 421 *
422 * This is probably overkill for real world processors but 422 * This is probably overkill for real world processors but
423 * they are not on hot paths so a little discipline won't do 423 * they are not on hot paths so a little discipline won't do
424 * any harm. 424 * any harm.
425 * 425 *
426 * Locking: takes termios_mutex 426 * Locking: takes termios_mutex
427 */ 427 */
428 428
429 static void tty_set_termios_ldisc(struct tty_struct *tty, int num) 429 static void tty_set_termios_ldisc(struct tty_struct *tty, int num)
430 { 430 {
431 mutex_lock(&tty->termios_mutex); 431 mutex_lock(&tty->termios_mutex);
432 tty->termios->c_line = num; 432 tty->termios->c_line = num;
433 mutex_unlock(&tty->termios_mutex); 433 mutex_unlock(&tty->termios_mutex);
434 } 434 }
435 435
436 /** 436 /**
437 * tty_ldisc_open - open a line discipline 437 * tty_ldisc_open - open a line discipline
438 * @tty: tty we are opening the ldisc on 438 * @tty: tty we are opening the ldisc on
439 * @ld: discipline to open 439 * @ld: discipline to open
440 * 440 *
441 * A helper opening method. Also a convenient debugging and check 441 * A helper opening method. Also a convenient debugging and check
442 * point. 442 * point.
443 * 443 *
444 * Locking: always called with BTM already held. 444 * Locking: always called with BTM already held.
445 */ 445 */
446 446
447 static int tty_ldisc_open(struct tty_struct *tty, struct tty_ldisc *ld) 447 static int tty_ldisc_open(struct tty_struct *tty, struct tty_ldisc *ld)
448 { 448 {
449 WARN_ON(test_and_set_bit(TTY_LDISC_OPEN, &tty->flags)); 449 WARN_ON(test_and_set_bit(TTY_LDISC_OPEN, &tty->flags));
450 if (ld->ops->open) { 450 if (ld->ops->open) {
451 int ret; 451 int ret;
452 /* BTM here locks versus a hangup event */ 452 /* BTM here locks versus a hangup event */
453 ret = ld->ops->open(tty); 453 ret = ld->ops->open(tty);
454 if (ret) 454 if (ret)
455 clear_bit(TTY_LDISC_OPEN, &tty->flags); 455 clear_bit(TTY_LDISC_OPEN, &tty->flags);
456 return ret; 456 return ret;
457 } 457 }
458 return 0; 458 return 0;
459 } 459 }
460 460
461 /** 461 /**
462 * tty_ldisc_close - close a line discipline 462 * tty_ldisc_close - close a line discipline
463 * @tty: tty we are opening the ldisc on 463 * @tty: tty we are opening the ldisc on
464 * @ld: discipline to close 464 * @ld: discipline to close
465 * 465 *
466 * A helper close method. Also a convenient debugging and check 466 * A helper close method. Also a convenient debugging and check
467 * point. 467 * point.
468 */ 468 */
469 469
470 static void tty_ldisc_close(struct tty_struct *tty, struct tty_ldisc *ld) 470 static void tty_ldisc_close(struct tty_struct *tty, struct tty_ldisc *ld)
471 { 471 {
472 WARN_ON(!test_bit(TTY_LDISC_OPEN, &tty->flags)); 472 WARN_ON(!test_bit(TTY_LDISC_OPEN, &tty->flags));
473 clear_bit(TTY_LDISC_OPEN, &tty->flags); 473 clear_bit(TTY_LDISC_OPEN, &tty->flags);
474 if (ld->ops->close) 474 if (ld->ops->close)
475 ld->ops->close(tty); 475 ld->ops->close(tty);
476 } 476 }
477 477
478 /** 478 /**
479 * tty_ldisc_restore - helper for tty ldisc change 479 * tty_ldisc_restore - helper for tty ldisc change
480 * @tty: tty to recover 480 * @tty: tty to recover
481 * @old: previous ldisc 481 * @old: previous ldisc
482 * 482 *
483 * Restore the previous line discipline or N_TTY when a line discipline 483 * Restore the previous line discipline or N_TTY when a line discipline
484 * change fails due to an open error 484 * change fails due to an open error
485 */ 485 */
486 486
487 static void tty_ldisc_restore(struct tty_struct *tty, struct tty_ldisc *old) 487 static void tty_ldisc_restore(struct tty_struct *tty, struct tty_ldisc *old)
488 { 488 {
489 char buf[64]; 489 char buf[64];
490 struct tty_ldisc *new_ldisc; 490 struct tty_ldisc *new_ldisc;
491 int r; 491 int r;
492 492
493 /* There is an outstanding reference here so this is safe */ 493 /* There is an outstanding reference here so this is safe */
494 old = tty_ldisc_get(old->ops->num); 494 old = tty_ldisc_get(old->ops->num);
495 WARN_ON(IS_ERR(old)); 495 WARN_ON(IS_ERR(old));
496 tty_ldisc_assign(tty, old); 496 tty_ldisc_assign(tty, old);
497 tty_set_termios_ldisc(tty, old->ops->num); 497 tty_set_termios_ldisc(tty, old->ops->num);
498 if (tty_ldisc_open(tty, old) < 0) { 498 if (tty_ldisc_open(tty, old) < 0) {
499 tty_ldisc_put(old); 499 tty_ldisc_put(old);
500 /* This driver is always present */ 500 /* This driver is always present */
501 new_ldisc = tty_ldisc_get(N_TTY); 501 new_ldisc = tty_ldisc_get(N_TTY);
502 if (IS_ERR(new_ldisc)) 502 if (IS_ERR(new_ldisc))
503 panic("n_tty: get"); 503 panic("n_tty: get");
504 tty_ldisc_assign(tty, new_ldisc); 504 tty_ldisc_assign(tty, new_ldisc);
505 tty_set_termios_ldisc(tty, N_TTY); 505 tty_set_termios_ldisc(tty, N_TTY);
506 r = tty_ldisc_open(tty, new_ldisc); 506 r = tty_ldisc_open(tty, new_ldisc);
507 if (r < 0) 507 if (r < 0)
508 panic("Couldn't open N_TTY ldisc for " 508 panic("Couldn't open N_TTY ldisc for "
509 "%s --- error %d.", 509 "%s --- error %d.",
510 tty_name(tty, buf), r); 510 tty_name(tty, buf), r);
511 } 511 }
512 } 512 }
513 513
514 /** 514 /**
515 * tty_ldisc_halt - shut down the line discipline 515 * tty_ldisc_halt - shut down the line discipline
516 * @tty: tty device 516 * @tty: tty device
517 * 517 *
518 * Shut down the line discipline and work queue for this tty device. 518 * Shut down the line discipline and work queue for this tty device.
519 * The TTY_LDISC flag being cleared ensures no further references can 519 * The TTY_LDISC flag being cleared ensures no further references can
520 * be obtained while the delayed work queue halt ensures that no more 520 * be obtained while the delayed work queue halt ensures that no more
521 * data is fed to the ldisc. 521 * data is fed to the ldisc.
522 * 522 *
523 * You need to do a 'flush_scheduled_work()' (outside the ldisc_mutex) 523 * You need to do a 'flush_scheduled_work()' (outside the ldisc_mutex)
524 * in order to make sure any currently executing ldisc work is also 524 * in order to make sure any currently executing ldisc work is also
525 * flushed. 525 * flushed.
526 */ 526 */
527 527
528 static int tty_ldisc_halt(struct tty_struct *tty) 528 static int tty_ldisc_halt(struct tty_struct *tty)
529 { 529 {
530 clear_bit(TTY_LDISC, &tty->flags); 530 clear_bit(TTY_LDISC, &tty->flags);
531 return cancel_work_sync(&tty->buf.work); 531 return cancel_work_sync(&tty->buf.work);
532 } 532 }
533 533
534 /** 534 /**
535 * tty_ldisc_flush_works - flush all works of a tty 535 * tty_ldisc_flush_works - flush all works of a tty
536 * @tty: tty device to flush works for 536 * @tty: tty device to flush works for
537 * 537 *
538 * Sync flush all works belonging to @tty. 538 * Sync flush all works belonging to @tty.
539 */ 539 */
540 static void tty_ldisc_flush_works(struct tty_struct *tty) 540 static void tty_ldisc_flush_works(struct tty_struct *tty)
541 { 541 {
542 flush_work_sync(&tty->hangup_work); 542 flush_work_sync(&tty->hangup_work);
543 flush_work_sync(&tty->SAK_work); 543 flush_work_sync(&tty->SAK_work);
544 flush_work_sync(&tty->buf.work); 544 flush_work_sync(&tty->buf.work);
545 } 545 }
546 546
547 /** 547 /**
548 * tty_ldisc_wait_idle - wait for the ldisc to become idle 548 * tty_ldisc_wait_idle - wait for the ldisc to become idle
549 * @tty: tty to wait for 549 * @tty: tty to wait for
550 * @timeout: for how long to wait at most 550 * @timeout: for how long to wait at most
551 * 551 *
552 * Wait for the line discipline to become idle. The discipline must 552 * Wait for the line discipline to become idle. The discipline must
553 * have been halted for this to guarantee it remains idle. 553 * have been halted for this to guarantee it remains idle.
554 */ 554 */
555 static int tty_ldisc_wait_idle(struct tty_struct *tty, long timeout) 555 static int tty_ldisc_wait_idle(struct tty_struct *tty, long timeout)
556 { 556 {
557 long ret; 557 long ret;
558 ret = wait_event_timeout(tty_ldisc_idle, 558 ret = wait_event_timeout(tty_ldisc_idle,
559 atomic_read(&tty->ldisc->users) == 1, timeout); 559 atomic_read(&tty->ldisc->users) == 1, timeout);
560 if (ret < 0) 560 if (ret < 0)
561 return ret; 561 return ret;
562 return ret > 0 ? 0 : -EBUSY; 562 return ret > 0 ? 0 : -EBUSY;
563 } 563 }
564 564
565 /** 565 /**
566 * tty_set_ldisc - set line discipline 566 * tty_set_ldisc - set line discipline
567 * @tty: the terminal to set 567 * @tty: the terminal to set
568 * @ldisc: the line discipline 568 * @ldisc: the line discipline
569 * 569 *
570 * Set the discipline of a tty line. Must be called from a process 570 * Set the discipline of a tty line. Must be called from a process
571 * context. The ldisc change logic has to protect itself against any 571 * context. The ldisc change logic has to protect itself against any
572 * overlapping ldisc change (including on the other end of pty pairs), 572 * overlapping ldisc change (including on the other end of pty pairs),
573 * the close of one side of a tty/pty pair, and eventually hangup. 573 * the close of one side of a tty/pty pair, and eventually hangup.
574 * 574 *
575 * Locking: takes tty_ldisc_lock, termios_mutex 575 * Locking: takes tty_ldisc_lock, termios_mutex
576 */ 576 */
577 577
578 int tty_set_ldisc(struct tty_struct *tty, int ldisc) 578 int tty_set_ldisc(struct tty_struct *tty, int ldisc)
579 { 579 {
580 int retval; 580 int retval;
581 struct tty_ldisc *o_ldisc, *new_ldisc; 581 struct tty_ldisc *o_ldisc, *new_ldisc;
582 int work, o_work = 0; 582 int work, o_work = 0;
583 struct tty_struct *o_tty; 583 struct tty_struct *o_tty;
584 584
585 new_ldisc = tty_ldisc_get(ldisc); 585 new_ldisc = tty_ldisc_get(ldisc);
586 if (IS_ERR(new_ldisc)) 586 if (IS_ERR(new_ldisc))
587 return PTR_ERR(new_ldisc); 587 return PTR_ERR(new_ldisc);
588 588
589 tty_lock(); 589 tty_lock();
590 /* 590 /*
591 * We need to look at the tty locking here for pty/tty pairs 591 * We need to look at the tty locking here for pty/tty pairs
592 * when both sides try to change in parallel. 592 * when both sides try to change in parallel.
593 */ 593 */
594 594
595 o_tty = tty->link; /* o_tty is the pty side or NULL */ 595 o_tty = tty->link; /* o_tty is the pty side or NULL */
596 596
597 597
598 /* 598 /*
599 * Check the no-op case 599 * Check the no-op case
600 */ 600 */
601 601
602 if (tty->ldisc->ops->num == ldisc) { 602 if (tty->ldisc->ops->num == ldisc) {
603 tty_unlock(); 603 tty_unlock();
604 tty_ldisc_put(new_ldisc); 604 tty_ldisc_put(new_ldisc);
605 return 0; 605 return 0;
606 } 606 }
607 607
608 tty_unlock(); 608 tty_unlock();
609 /* 609 /*
610 * Problem: What do we do if this blocks ? 610 * Problem: What do we do if this blocks ?
611 * We could deadlock here 611 * We could deadlock here
612 */ 612 */
613 613
614 tty_wait_until_sent(tty, 0); 614 tty_wait_until_sent(tty, 0);
615 615
616 tty_lock(); 616 tty_lock();
617 mutex_lock(&tty->ldisc_mutex); 617 mutex_lock(&tty->ldisc_mutex);
618 618
619 /* 619 /*
620 * We could be midstream of another ldisc change which has 620 * We could be midstream of another ldisc change which has
621 * dropped the lock during processing. If so we need to wait. 621 * dropped the lock during processing. If so we need to wait.
622 */ 622 */
623 623
624 while (test_bit(TTY_LDISC_CHANGING, &tty->flags)) { 624 while (test_bit(TTY_LDISC_CHANGING, &tty->flags)) {
625 mutex_unlock(&tty->ldisc_mutex); 625 mutex_unlock(&tty->ldisc_mutex);
626 tty_unlock(); 626 tty_unlock();
627 wait_event(tty_ldisc_wait, 627 wait_event(tty_ldisc_wait,
628 test_bit(TTY_LDISC_CHANGING, &tty->flags) == 0); 628 test_bit(TTY_LDISC_CHANGING, &tty->flags) == 0);
629 tty_lock(); 629 tty_lock();
630 mutex_lock(&tty->ldisc_mutex); 630 mutex_lock(&tty->ldisc_mutex);
631 } 631 }
632 632
633 set_bit(TTY_LDISC_CHANGING, &tty->flags); 633 set_bit(TTY_LDISC_CHANGING, &tty->flags);
634 634
635 /* 635 /*
636 * No more input please, we are switching. The new ldisc 636 * No more input please, we are switching. The new ldisc
637 * will update this value in the ldisc open function 637 * will update this value in the ldisc open function
638 */ 638 */
639 639
640 tty->receive_room = 0; 640 tty->receive_room = 0;
641 641
642 o_ldisc = tty->ldisc; 642 o_ldisc = tty->ldisc;
643 643
644 tty_unlock(); 644 tty_unlock();
645 /* 645 /*
646 * Make sure we don't change while someone holds a 646 * Make sure we don't change while someone holds a
647 * reference to the line discipline. The TTY_LDISC bit 647 * reference to the line discipline. The TTY_LDISC bit
648 * prevents anyone taking a reference once it is clear. 648 * prevents anyone taking a reference once it is clear.
649 * We need the lock to avoid racing reference takers. 649 * We need the lock to avoid racing reference takers.
650 * 650 *
651 * We must clear the TTY_LDISC bit here to avoid a livelock 651 * We must clear the TTY_LDISC bit here to avoid a livelock
652 * with a userspace app continually trying to use the tty in 652 * with a userspace app continually trying to use the tty in
653 * parallel to the change and re-referencing the tty. 653 * parallel to the change and re-referencing the tty.
654 */ 654 */
655 655
656 work = tty_ldisc_halt(tty); 656 work = tty_ldisc_halt(tty);
657 if (o_tty) 657 if (o_tty)
658 o_work = tty_ldisc_halt(o_tty); 658 o_work = tty_ldisc_halt(o_tty);
659 659
660 /* 660 /*
661 * Wait for ->hangup_work and ->buf.work handlers to terminate. 661 * Wait for ->hangup_work and ->buf.work handlers to terminate.
662 * We must drop the mutex here in case a hangup is also in process. 662 * We must drop the mutex here in case a hangup is also in process.
663 */ 663 */
664 664
665 mutex_unlock(&tty->ldisc_mutex); 665 mutex_unlock(&tty->ldisc_mutex);
666 666
667 tty_ldisc_flush_works(tty); 667 tty_ldisc_flush_works(tty);
668 668
669 retval = tty_ldisc_wait_idle(tty, 5 * HZ); 669 retval = tty_ldisc_wait_idle(tty, 5 * HZ);
670 670
671 tty_lock(); 671 tty_lock();
672 mutex_lock(&tty->ldisc_mutex); 672 mutex_lock(&tty->ldisc_mutex);
673 673
674 /* handle wait idle failure locked */ 674 /* handle wait idle failure locked */
675 if (retval) { 675 if (retval) {
676 tty_ldisc_put(new_ldisc); 676 tty_ldisc_put(new_ldisc);
677 goto enable; 677 goto enable;
678 } 678 }
679 679
680 if (test_bit(TTY_HUPPED, &tty->flags)) { 680 if (test_bit(TTY_HUPPED, &tty->flags)) {
681 /* We were raced by the hangup method. It will have stomped 681 /* We were raced by the hangup method. It will have stomped
682 the ldisc data and closed the ldisc down */ 682 the ldisc data and closed the ldisc down */
683 clear_bit(TTY_LDISC_CHANGING, &tty->flags); 683 clear_bit(TTY_LDISC_CHANGING, &tty->flags);
684 mutex_unlock(&tty->ldisc_mutex); 684 mutex_unlock(&tty->ldisc_mutex);
685 tty_ldisc_put(new_ldisc); 685 tty_ldisc_put(new_ldisc);
686 tty_unlock(); 686 tty_unlock();
687 return -EIO; 687 return -EIO;
688 } 688 }
689 689
690 /* Shutdown the current discipline. */ 690 /* Shutdown the current discipline. */
691 tty_ldisc_close(tty, o_ldisc); 691 tty_ldisc_close(tty, o_ldisc);
692 692
693 /* Now set up the new line discipline. */ 693 /* Now set up the new line discipline. */
694 tty_ldisc_assign(tty, new_ldisc); 694 tty_ldisc_assign(tty, new_ldisc);
695 tty_set_termios_ldisc(tty, ldisc); 695 tty_set_termios_ldisc(tty, ldisc);
696 696
697 retval = tty_ldisc_open(tty, new_ldisc); 697 retval = tty_ldisc_open(tty, new_ldisc);
698 if (retval < 0) { 698 if (retval < 0) {
699 /* Back to the old one or N_TTY if we can't */ 699 /* Back to the old one or N_TTY if we can't */
700 tty_ldisc_put(new_ldisc); 700 tty_ldisc_put(new_ldisc);
701 tty_ldisc_restore(tty, o_ldisc); 701 tty_ldisc_restore(tty, o_ldisc);
702 } 702 }
703 703
704 /* At this point we hold a reference to the new ldisc and a 704 /* At this point we hold a reference to the new ldisc and a
705 a reference to the old ldisc. If we ended up flipping back 705 a reference to the old ldisc. If we ended up flipping back
706 to the existing ldisc we have two references to it */ 706 to the existing ldisc we have two references to it */
707 707
708 if (tty->ldisc->ops->num != o_ldisc->ops->num && tty->ops->set_ldisc) 708 if (tty->ldisc->ops->num != o_ldisc->ops->num && tty->ops->set_ldisc)
709 tty->ops->set_ldisc(tty); 709 tty->ops->set_ldisc(tty);
710 710
711 tty_ldisc_put(o_ldisc); 711 tty_ldisc_put(o_ldisc);
712 712
713 enable: 713 enable:
714 /* 714 /*
715 * Allow ldisc referencing to occur again 715 * Allow ldisc referencing to occur again
716 */ 716 */
717 717
718 tty_ldisc_enable(tty); 718 tty_ldisc_enable(tty);
719 if (o_tty) 719 if (o_tty)
720 tty_ldisc_enable(o_tty); 720 tty_ldisc_enable(o_tty);
721 721
722 /* Restart the work queue in case no characters kick it off. Safe if 722 /* Restart the work queue in case no characters kick it off. Safe if
723 already running */ 723 already running */
724 if (work) 724 if (work)
725 schedule_work(&tty->buf.work); 725 schedule_work(&tty->buf.work);
726 if (o_work) 726 if (o_work)
727 schedule_work(&o_tty->buf.work); 727 schedule_work(&o_tty->buf.work);
728 mutex_unlock(&tty->ldisc_mutex); 728 mutex_unlock(&tty->ldisc_mutex);
729 tty_unlock(); 729 tty_unlock();
730 return retval; 730 return retval;
731 } 731 }
732 732
733 /** 733 /**
734 * tty_reset_termios - reset terminal state 734 * tty_reset_termios - reset terminal state
735 * @tty: tty to reset 735 * @tty: tty to reset
736 * 736 *
737 * Restore a terminal to the driver default state. 737 * Restore a terminal to the driver default state.
738 */ 738 */
739 739
740 static void tty_reset_termios(struct tty_struct *tty) 740 static void tty_reset_termios(struct tty_struct *tty)
741 { 741 {
742 mutex_lock(&tty->termios_mutex); 742 mutex_lock(&tty->termios_mutex);
743 *tty->termios = tty->driver->init_termios; 743 *tty->termios = tty->driver->init_termios;
744 tty->termios->c_ispeed = tty_termios_input_baud_rate(tty->termios); 744 tty->termios->c_ispeed = tty_termios_input_baud_rate(tty->termios);
745 tty->termios->c_ospeed = tty_termios_baud_rate(tty->termios); 745 tty->termios->c_ospeed = tty_termios_baud_rate(tty->termios);
746 mutex_unlock(&tty->termios_mutex); 746 mutex_unlock(&tty->termios_mutex);
747 } 747 }
748 748
749 749
750 /** 750 /**
751 * tty_ldisc_reinit - reinitialise the tty ldisc 751 * tty_ldisc_reinit - reinitialise the tty ldisc
752 * @tty: tty to reinit 752 * @tty: tty to reinit
753 * @ldisc: line discipline to reinitialize 753 * @ldisc: line discipline to reinitialize
754 * 754 *
755 * Switch the tty to a line discipline and leave the ldisc 755 * Switch the tty to a line discipline and leave the ldisc
756 * state closed 756 * state closed
757 */ 757 */
758 758
759 static int tty_ldisc_reinit(struct tty_struct *tty, int ldisc) 759 static int tty_ldisc_reinit(struct tty_struct *tty, int ldisc)
760 { 760 {
761 struct tty_ldisc *ld = tty_ldisc_get(ldisc); 761 struct tty_ldisc *ld = tty_ldisc_get(ldisc);
762 762
763 if (IS_ERR(ld)) 763 if (IS_ERR(ld))
764 return -1; 764 return -1;
765 765
766 WARN_ON_ONCE(tty_ldisc_wait_idle(tty, 5 * HZ));
767
768 tty_ldisc_close(tty, tty->ldisc); 766 tty_ldisc_close(tty, tty->ldisc);
769 tty_ldisc_put(tty->ldisc); 767 tty_ldisc_put(tty->ldisc);
770 tty->ldisc = NULL; 768 tty->ldisc = NULL;
771 /* 769 /*
772 * Switch the line discipline back 770 * Switch the line discipline back
773 */ 771 */
774 tty_ldisc_assign(tty, ld); 772 tty_ldisc_assign(tty, ld);
775 tty_set_termios_ldisc(tty, ldisc); 773 tty_set_termios_ldisc(tty, ldisc);
776 774
777 return 0; 775 return 0;
778 } 776 }
779 777
780 /** 778 /**
781 * tty_ldisc_hangup - hangup ldisc reset 779 * tty_ldisc_hangup - hangup ldisc reset
782 * @tty: tty being hung up 780 * @tty: tty being hung up
783 * 781 *
784 * Some tty devices reset their termios when they receive a hangup 782 * Some tty devices reset their termios when they receive a hangup
785 * event. In that situation we must also switch back to N_TTY properly 783 * event. In that situation we must also switch back to N_TTY properly
786 * before we reset the termios data. 784 * before we reset the termios data.
787 * 785 *
788 * Locking: We can take the ldisc mutex as the rest of the code is 786 * Locking: We can take the ldisc mutex as the rest of the code is
789 * careful to allow for this. 787 * careful to allow for this.
790 * 788 *
791 * In the pty pair case this occurs in the close() path of the 789 * In the pty pair case this occurs in the close() path of the
792 * tty itself so we must be careful about locking rules. 790 * tty itself so we must be careful about locking rules.
793 */ 791 */
794 792
795 void tty_ldisc_hangup(struct tty_struct *tty) 793 void tty_ldisc_hangup(struct tty_struct *tty)
796 { 794 {
797 struct tty_ldisc *ld; 795 struct tty_ldisc *ld;
798 int reset = tty->driver->flags & TTY_DRIVER_RESET_TERMIOS; 796 int reset = tty->driver->flags & TTY_DRIVER_RESET_TERMIOS;
799 int err = 0; 797 int err = 0;
800 798
801 /* 799 /*
802 * FIXME! What are the locking issues here? This may me overdoing 800 * FIXME! What are the locking issues here? This may me overdoing
803 * things... This question is especially important now that we've 801 * things... This question is especially important now that we've
804 * removed the irqlock. 802 * removed the irqlock.
805 */ 803 */
806 ld = tty_ldisc_ref(tty); 804 ld = tty_ldisc_ref(tty);
807 if (ld != NULL) { 805 if (ld != NULL) {
808 /* We may have no line discipline at this point */ 806 /* We may have no line discipline at this point */
809 if (ld->ops->flush_buffer) 807 if (ld->ops->flush_buffer)
810 ld->ops->flush_buffer(tty); 808 ld->ops->flush_buffer(tty);
811 tty_driver_flush_buffer(tty); 809 tty_driver_flush_buffer(tty);
812 if ((test_bit(TTY_DO_WRITE_WAKEUP, &tty->flags)) && 810 if ((test_bit(TTY_DO_WRITE_WAKEUP, &tty->flags)) &&
813 ld->ops->write_wakeup) 811 ld->ops->write_wakeup)
814 ld->ops->write_wakeup(tty); 812 ld->ops->write_wakeup(tty);
815 if (ld->ops->hangup) 813 if (ld->ops->hangup)
816 ld->ops->hangup(tty); 814 ld->ops->hangup(tty);
817 tty_ldisc_deref(ld); 815 tty_ldisc_deref(ld);
818 } 816 }
819 /* 817 /*
820 * FIXME: Once we trust the LDISC code better we can wait here for 818 * FIXME: Once we trust the LDISC code better we can wait here for
821 * ldisc completion and fix the driver call race 819 * ldisc completion and fix the driver call race
822 */ 820 */
823 wake_up_interruptible_poll(&tty->write_wait, POLLOUT); 821 wake_up_interruptible_poll(&tty->write_wait, POLLOUT);
824 wake_up_interruptible_poll(&tty->read_wait, POLLIN); 822 wake_up_interruptible_poll(&tty->read_wait, POLLIN);
825 /* 823 /*
826 * Shutdown the current line discipline, and reset it to 824 * Shutdown the current line discipline, and reset it to
827 * N_TTY if need be. 825 * N_TTY if need be.
828 * 826 *
829 * Avoid racing set_ldisc or tty_ldisc_release 827 * Avoid racing set_ldisc or tty_ldisc_release
830 */ 828 */
831 mutex_lock(&tty->ldisc_mutex); 829 mutex_lock(&tty->ldisc_mutex);
832 830
833 /* 831 /*
834 * this is like tty_ldisc_halt, but we need to give up 832 * this is like tty_ldisc_halt, but we need to give up
835 * the BTM before calling cancel_work_sync, which may 833 * the BTM before calling cancel_work_sync, which may
836 * need to wait for another function taking the BTM 834 * need to wait for another function taking the BTM
837 */ 835 */
838 clear_bit(TTY_LDISC, &tty->flags); 836 clear_bit(TTY_LDISC, &tty->flags);
839 tty_unlock(); 837 tty_unlock();
840 cancel_work_sync(&tty->buf.work); 838 cancel_work_sync(&tty->buf.work);
841 mutex_unlock(&tty->ldisc_mutex); 839 mutex_unlock(&tty->ldisc_mutex);
842 840
843 tty_lock(); 841 tty_lock();
844 mutex_lock(&tty->ldisc_mutex); 842 mutex_lock(&tty->ldisc_mutex);
845 843
846 /* At this point we have a closed ldisc and we want to 844 /* At this point we have a closed ldisc and we want to
847 reopen it. We could defer this to the next open but 845 reopen it. We could defer this to the next open but
848 it means auditing a lot of other paths so this is 846 it means auditing a lot of other paths so this is
849 a FIXME */ 847 a FIXME */
850 if (tty->ldisc) { /* Not yet closed */ 848 if (tty->ldisc) { /* Not yet closed */
849 WARN_ON_ONCE(tty_ldisc_wait_idle(tty, 5 * HZ));
850
851 if (reset == 0) { 851 if (reset == 0) {
852 852
853 if (!tty_ldisc_reinit(tty, tty->termios->c_line)) 853 if (!tty_ldisc_reinit(tty, tty->termios->c_line))
854 err = tty_ldisc_open(tty, tty->ldisc); 854 err = tty_ldisc_open(tty, tty->ldisc);
855 else 855 else
856 err = 1; 856 err = 1;
857 } 857 }
858 /* If the re-open fails or we reset then go to N_TTY. The 858 /* If the re-open fails or we reset then go to N_TTY. The
859 N_TTY open cannot fail */ 859 N_TTY open cannot fail */
860 if (reset || err) { 860 if (reset || err) {
861 BUG_ON(tty_ldisc_reinit(tty, N_TTY)); 861 BUG_ON(tty_ldisc_reinit(tty, N_TTY));
862 WARN_ON(tty_ldisc_open(tty, tty->ldisc)); 862 WARN_ON(tty_ldisc_open(tty, tty->ldisc));
863 } 863 }
864 tty_ldisc_enable(tty); 864 tty_ldisc_enable(tty);
865 } 865 }
866 mutex_unlock(&tty->ldisc_mutex); 866 mutex_unlock(&tty->ldisc_mutex);
867 if (reset) 867 if (reset)
868 tty_reset_termios(tty); 868 tty_reset_termios(tty);
869 } 869 }
870 870
871 /** 871 /**
872 * tty_ldisc_setup - open line discipline 872 * tty_ldisc_setup - open line discipline
873 * @tty: tty being shut down 873 * @tty: tty being shut down
874 * @o_tty: pair tty for pty/tty pairs 874 * @o_tty: pair tty for pty/tty pairs
875 * 875 *
876 * Called during the initial open of a tty/pty pair in order to set up the 876 * Called during the initial open of a tty/pty pair in order to set up the
877 * line disciplines and bind them to the tty. This has no locking issues 877 * line disciplines and bind them to the tty. This has no locking issues
878 * as the device isn't yet active. 878 * as the device isn't yet active.
879 */ 879 */
880 880
881 int tty_ldisc_setup(struct tty_struct *tty, struct tty_struct *o_tty) 881 int tty_ldisc_setup(struct tty_struct *tty, struct tty_struct *o_tty)
882 { 882 {
883 struct tty_ldisc *ld = tty->ldisc; 883 struct tty_ldisc *ld = tty->ldisc;
884 int retval; 884 int retval;
885 885
886 retval = tty_ldisc_open(tty, ld); 886 retval = tty_ldisc_open(tty, ld);
887 if (retval) 887 if (retval)
888 return retval; 888 return retval;
889 889
890 if (o_tty) { 890 if (o_tty) {
891 retval = tty_ldisc_open(o_tty, o_tty->ldisc); 891 retval = tty_ldisc_open(o_tty, o_tty->ldisc);
892 if (retval) { 892 if (retval) {
893 tty_ldisc_close(tty, ld); 893 tty_ldisc_close(tty, ld);
894 return retval; 894 return retval;
895 } 895 }
896 tty_ldisc_enable(o_tty); 896 tty_ldisc_enable(o_tty);
897 } 897 }
898 tty_ldisc_enable(tty); 898 tty_ldisc_enable(tty);
899 return 0; 899 return 0;
900 } 900 }
901 /** 901 /**
902 * tty_ldisc_release - release line discipline 902 * tty_ldisc_release - release line discipline
903 * @tty: tty being shut down 903 * @tty: tty being shut down
904 * @o_tty: pair tty for pty/tty pairs 904 * @o_tty: pair tty for pty/tty pairs
905 * 905 *
906 * Called during the final close of a tty/pty pair in order to shut down 906 * Called during the final close of a tty/pty pair in order to shut down
907 * the line discpline layer. On exit the ldisc assigned is N_TTY and the 907 * the line discpline layer. On exit the ldisc assigned is N_TTY and the
908 * ldisc has not been opened. 908 * ldisc has not been opened.
909 */ 909 */
910 910
911 void tty_ldisc_release(struct tty_struct *tty, struct tty_struct *o_tty) 911 void tty_ldisc_release(struct tty_struct *tty, struct tty_struct *o_tty)
912 { 912 {
913 /* 913 /*
914 * Prevent flush_to_ldisc() from rescheduling the work for later. Then 914 * Prevent flush_to_ldisc() from rescheduling the work for later. Then
915 * kill any delayed work. As this is the final close it does not 915 * kill any delayed work. As this is the final close it does not
916 * race with the set_ldisc code path. 916 * race with the set_ldisc code path.
917 */ 917 */
918 918
919 tty_unlock(); 919 tty_unlock();
920 tty_ldisc_halt(tty); 920 tty_ldisc_halt(tty);
921 tty_ldisc_flush_works(tty); 921 tty_ldisc_flush_works(tty);
922 tty_lock(); 922 tty_lock();
923 923
924 mutex_lock(&tty->ldisc_mutex); 924 mutex_lock(&tty->ldisc_mutex);
925 /* 925 /*
926 * Now kill off the ldisc 926 * Now kill off the ldisc
927 */ 927 */
928 tty_ldisc_close(tty, tty->ldisc); 928 tty_ldisc_close(tty, tty->ldisc);
929 tty_ldisc_put(tty->ldisc); 929 tty_ldisc_put(tty->ldisc);
930 /* Force an oops if we mess this up */ 930 /* Force an oops if we mess this up */
931 tty->ldisc = NULL; 931 tty->ldisc = NULL;
932 932
933 /* Ensure the next open requests the N_TTY ldisc */ 933 /* Ensure the next open requests the N_TTY ldisc */
934 tty_set_termios_ldisc(tty, N_TTY); 934 tty_set_termios_ldisc(tty, N_TTY);
935 mutex_unlock(&tty->ldisc_mutex); 935 mutex_unlock(&tty->ldisc_mutex);
936 936
937 /* This will need doing differently if we need to lock */ 937 /* This will need doing differently if we need to lock */
938 if (o_tty) 938 if (o_tty)
939 tty_ldisc_release(o_tty, NULL); 939 tty_ldisc_release(o_tty, NULL);
940 940
941 /* And the memory resources remaining (buffers, termios) will be 941 /* And the memory resources remaining (buffers, termios) will be
942 disposed of when the kref hits zero */ 942 disposed of when the kref hits zero */
943 } 943 }
944 944
945 /** 945 /**
946 * tty_ldisc_init - ldisc setup for new tty 946 * tty_ldisc_init - ldisc setup for new tty
947 * @tty: tty being allocated 947 * @tty: tty being allocated
948 * 948 *
949 * Set up the line discipline objects for a newly allocated tty. Note that 949 * Set up the line discipline objects for a newly allocated tty. Note that
950 * the tty structure is not completely set up when this call is made. 950 * the tty structure is not completely set up when this call is made.
951 */ 951 */
952 952
953 void tty_ldisc_init(struct tty_struct *tty) 953 void tty_ldisc_init(struct tty_struct *tty)
954 { 954 {
955 struct tty_ldisc *ld = tty_ldisc_get(N_TTY); 955 struct tty_ldisc *ld = tty_ldisc_get(N_TTY);
956 if (IS_ERR(ld)) 956 if (IS_ERR(ld))
957 panic("n_tty: init_tty"); 957 panic("n_tty: init_tty");
958 tty_ldisc_assign(tty, ld); 958 tty_ldisc_assign(tty, ld);
959 } 959 }
960 960
961 /** 961 /**
962 * tty_ldisc_init - ldisc cleanup for new tty 962 * tty_ldisc_init - ldisc cleanup for new tty
963 * @tty: tty that was allocated recently 963 * @tty: tty that was allocated recently
964 * 964 *
965 * The tty structure must not becompletely set up (tty_ldisc_setup) when 965 * The tty structure must not becompletely set up (tty_ldisc_setup) when
966 * this call is made. 966 * this call is made.
967 */ 967 */
968 void tty_ldisc_deinit(struct tty_struct *tty) 968 void tty_ldisc_deinit(struct tty_struct *tty)
969 { 969 {
970 put_ldisc(tty->ldisc); 970 put_ldisc(tty->ldisc);
971 tty_ldisc_assign(tty, NULL); 971 tty_ldisc_assign(tty, NULL);
972 } 972 }
973 973
974 void tty_ldisc_begin(void) 974 void tty_ldisc_begin(void)
975 { 975 {
976 /* Setup the default TTY line discipline. */ 976 /* Setup the default TTY line discipline. */
977 (void) tty_register_ldisc(N_TTY, &tty_ldisc_N_TTY); 977 (void) tty_register_ldisc(N_TTY, &tty_ldisc_N_TTY);