Eric Lee / linux-smarc-t335x-v3.2

Download as
Browse Code ยป

Commit ff8cb0fd6f195389aefe55d5dac9927d09a9de54

Authored by Thomas Pfaff
Committed by Linus Torvalds
1 parent eff6937a46
Exists in master and in 4 other branches v3.2_AM335xPSP_04.06.00.11, v3.2_NEWT335xPSP_04.06.00.11, v3.2_SBC_SMARTMEN, v3.2_SMARCT335xPSP_04.06.00.11

tty: N_TTY SIGIO only works for read 

The N_TTY ldisc layer does not send SIGIO POLL_OUTs correctly when output is
possible due to flawed handling of the TTY_DO_WRITE_WAKEUP bit. It will
either send no SIGIOs at all or on every tty wakeup.

The fix is to set the bit when the tty driver write would block and test
and clear it on write wakeup.

[Merged with existing N_TTY patches and a small buglet fixed -- Alan]

Signed-off-by: Thomas Pfaff <tpfaff@pcs.com>
Signed-off-by: Alan Cox <alan@redhat.com>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>

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

drivers/char/n_tty.c
Diff comments   View file @ ff8cb0f
1 /* 1 /*
2 * n_tty.c --- implements the N_TTY line discipline. 2 * n_tty.c --- implements the N_TTY line discipline.
3 * 3 *
4 * This code used to be in tty_io.c, but things are getting hairy 4 * This code used to be in tty_io.c, but things are getting hairy
5 * enough that it made sense to split things off. (The N_TTY 5 * enough that it made sense to split things off. (The N_TTY
6 * processing has changed so much that it's hardly recognizable, 6 * processing has changed so much that it's hardly recognizable,
7 * anyway...) 7 * anyway...)
8 * 8 *
9 * Note that the open routine for N_TTY is guaranteed never to return 9 * Note that the open routine for N_TTY is guaranteed never to return
10 * an error. This is because Linux will fall back to setting a line 10 * an error. This is because Linux will fall back to setting a line
11 * to N_TTY if it can not switch to any other line discipline. 11 * to N_TTY if it can not switch to any other line discipline.
12 * 12 *
13 * Written by Theodore Ts'o, Copyright 1994. 13 * Written by Theodore Ts'o, Copyright 1994.
14 * 14 *
15 * This file also contains code originally written by Linus Torvalds, 15 * This file also contains code originally written by Linus Torvalds,
16 * Copyright 1991, 1992, 1993, and by Julian Cowley, Copyright 1994. 16 * Copyright 1991, 1992, 1993, and by Julian Cowley, Copyright 1994.
17 * 17 *
18 * This file may be redistributed under the terms of the GNU General Public 18 * This file may be redistributed under the terms of the GNU General Public
19 * License. 19 * License.
20 * 20 *
21 * Reduced memory usage for older ARM systems - Russell King. 21 * Reduced memory usage for older ARM systems - Russell King.
22 * 22 *
23 * 2000/01/20 Fixed SMP locking on put_tty_queue using bits of 23 * 2000/01/20 Fixed SMP locking on put_tty_queue using bits of
24 * the patch by Andrew J. Kroll <ag784@freenet.buffalo.edu> 24 * the patch by Andrew J. Kroll <ag784@freenet.buffalo.edu>
25 * who actually finally proved there really was a race. 25 * who actually finally proved there really was a race.
26 * 26 *
27 * 2002/03/18 Implemented n_tty_wakeup to send SIGIO POLL_OUTs to 27 * 2002/03/18 Implemented n_tty_wakeup to send SIGIO POLL_OUTs to
28 * waiting writing processes-Sapan Bhatia <sapan@corewars.org>. 28 * waiting writing processes-Sapan Bhatia <sapan@corewars.org>.
29 * Also fixed a bug in BLOCKING mode where n_tty_write returns 29 * Also fixed a bug in BLOCKING mode where n_tty_write returns
30 * EAGAIN 30 * EAGAIN
31 */ 31 */
32 32
33 #include <linux/types.h> 33 #include <linux/types.h>
34 #include <linux/major.h> 34 #include <linux/major.h>
35 #include <linux/errno.h> 35 #include <linux/errno.h>
36 #include <linux/signal.h> 36 #include <linux/signal.h>
37 #include <linux/fcntl.h> 37 #include <linux/fcntl.h>
38 #include <linux/sched.h> 38 #include <linux/sched.h>
39 #include <linux/interrupt.h> 39 #include <linux/interrupt.h>
40 #include <linux/tty.h> 40 #include <linux/tty.h>
41 #include <linux/timer.h> 41 #include <linux/timer.h>
42 #include <linux/ctype.h> 42 #include <linux/ctype.h>
43 #include <linux/mm.h> 43 #include <linux/mm.h>
44 #include <linux/string.h> 44 #include <linux/string.h>
45 #include <linux/slab.h> 45 #include <linux/slab.h>
46 #include <linux/poll.h> 46 #include <linux/poll.h>
47 #include <linux/bitops.h> 47 #include <linux/bitops.h>
48 #include <linux/audit.h> 48 #include <linux/audit.h>
49 #include <linux/file.h> 49 #include <linux/file.h>
50 #include <linux/uaccess.h> 50 #include <linux/uaccess.h>
51 51
52 #include <asm/system.h> 52 #include <asm/system.h>
53 53
54 /* number of characters left in xmit buffer before select has we have room */ 54 /* number of characters left in xmit buffer before select has we have room */
55 #define WAKEUP_CHARS 256 55 #define WAKEUP_CHARS 256
56 56
57 /* 57 /*
58 * This defines the low- and high-watermarks for throttling and 58 * This defines the low- and high-watermarks for throttling and
59 * unthrottling the TTY driver. These watermarks are used for 59 * unthrottling the TTY driver. These watermarks are used for
60 * controlling the space in the read buffer. 60 * controlling the space in the read buffer.
61 */ 61 */
62 #define TTY_THRESHOLD_THROTTLE 128 /* now based on remaining room */ 62 #define TTY_THRESHOLD_THROTTLE 128 /* now based on remaining room */
63 #define TTY_THRESHOLD_UNTHROTTLE 128 63 #define TTY_THRESHOLD_UNTHROTTLE 128
64 64
65 /* 65 /*
66 * Special byte codes used in the echo buffer to represent operations 66 * Special byte codes used in the echo buffer to represent operations
67 * or special handling of characters. Bytes in the echo buffer that 67 * or special handling of characters. Bytes in the echo buffer that
68 * are not part of such special blocks are treated as normal character 68 * are not part of such special blocks are treated as normal character
69 * codes. 69 * codes.
70 */ 70 */
71 #define ECHO_OP_START 0xff 71 #define ECHO_OP_START 0xff
72 #define ECHO_OP_MOVE_BACK_COL 0x80 72 #define ECHO_OP_MOVE_BACK_COL 0x80
73 #define ECHO_OP_SET_CANON_COL 0x81 73 #define ECHO_OP_SET_CANON_COL 0x81
74 #define ECHO_OP_ERASE_TAB 0x82 74 #define ECHO_OP_ERASE_TAB 0x82
75 75
76 static inline unsigned char *alloc_buf(void) 76 static inline unsigned char *alloc_buf(void)
77 { 77 {
78 gfp_t prio = in_interrupt() ? GFP_ATOMIC : GFP_KERNEL; 78 gfp_t prio = in_interrupt() ? GFP_ATOMIC : GFP_KERNEL;
79 79
80 if (PAGE_SIZE != N_TTY_BUF_SIZE) 80 if (PAGE_SIZE != N_TTY_BUF_SIZE)
81 return kmalloc(N_TTY_BUF_SIZE, prio); 81 return kmalloc(N_TTY_BUF_SIZE, prio);
82 else 82 else
83 return (unsigned char *)__get_free_page(prio); 83 return (unsigned char *)__get_free_page(prio);
84 } 84 }
85 85
86 static inline void free_buf(unsigned char *buf) 86 static inline void free_buf(unsigned char *buf)
87 { 87 {
88 if (PAGE_SIZE != N_TTY_BUF_SIZE) 88 if (PAGE_SIZE != N_TTY_BUF_SIZE)
89 kfree(buf); 89 kfree(buf);
90 else 90 else
91 free_page((unsigned long) buf); 91 free_page((unsigned long) buf);
92 } 92 }
93 93
94 static inline int tty_put_user(struct tty_struct *tty, unsigned char x, 94 static inline int tty_put_user(struct tty_struct *tty, unsigned char x,
95 unsigned char __user *ptr) 95 unsigned char __user *ptr)
96 { 96 {
97 tty_audit_add_data(tty, &x, 1); 97 tty_audit_add_data(tty, &x, 1);
98 return put_user(x, ptr); 98 return put_user(x, ptr);
99 } 99 }
100 100
101 /** 101 /**
102 * n_tty_set__room - receive space 102 * n_tty_set__room - receive space
103 * @tty: terminal 103 * @tty: terminal
104 * 104 *
105 * Called by the driver to find out how much data it is 105 * Called by the driver to find out how much data it is
106 * permitted to feed to the line discipline without any being lost 106 * permitted to feed to the line discipline without any being lost
107 * and thus to manage flow control. Not serialized. Answers for the 107 * and thus to manage flow control. Not serialized. Answers for the
108 * "instant". 108 * "instant".
109 */ 109 */
110 110
111 static void n_tty_set_room(struct tty_struct *tty) 111 static void n_tty_set_room(struct tty_struct *tty)
112 { 112 {
113 /* tty->read_cnt is not read locked ? */ 113 /* tty->read_cnt is not read locked ? */
114 int left = N_TTY_BUF_SIZE - tty->read_cnt - 1; 114 int left = N_TTY_BUF_SIZE - tty->read_cnt - 1;
115 115
116 /* 116 /*
117 * If we are doing input canonicalization, and there are no 117 * If we are doing input canonicalization, and there are no
118 * pending newlines, let characters through without limit, so 118 * pending newlines, let characters through without limit, so
119 * that erase characters will be handled. Other excess 119 * that erase characters will be handled. Other excess
120 * characters will be beeped. 120 * characters will be beeped.
121 */ 121 */
122 if (left <= 0) 122 if (left <= 0)
123 left = tty->icanon && !tty->canon_data; 123 left = tty->icanon && !tty->canon_data;
124 tty->receive_room = left; 124 tty->receive_room = left;
125 } 125 }
126 126
127 static void put_tty_queue_nolock(unsigned char c, struct tty_struct *tty) 127 static void put_tty_queue_nolock(unsigned char c, struct tty_struct *tty)
128 { 128 {
129 if (tty->read_cnt < N_TTY_BUF_SIZE) { 129 if (tty->read_cnt < N_TTY_BUF_SIZE) {
130 tty->read_buf[tty->read_head] = c; 130 tty->read_buf[tty->read_head] = c;
131 tty->read_head = (tty->read_head + 1) & (N_TTY_BUF_SIZE-1); 131 tty->read_head = (tty->read_head + 1) & (N_TTY_BUF_SIZE-1);
132 tty->read_cnt++; 132 tty->read_cnt++;
133 } 133 }
134 } 134 }
135 135
136 /** 136 /**
137 * put_tty_queue - add character to tty 137 * put_tty_queue - add character to tty
138 * @c: character 138 * @c: character
139 * @tty: tty device 139 * @tty: tty device
140 * 140 *
141 * Add a character to the tty read_buf queue. This is done under the 141 * Add a character to the tty read_buf queue. This is done under the
142 * read_lock to serialize character addition and also to protect us 142 * read_lock to serialize character addition and also to protect us
143 * against parallel reads or flushes 143 * against parallel reads or flushes
144 */ 144 */
145 145
146 static void put_tty_queue(unsigned char c, struct tty_struct *tty) 146 static void put_tty_queue(unsigned char c, struct tty_struct *tty)
147 { 147 {
148 unsigned long flags; 148 unsigned long flags;
149 /* 149 /*
150 * The problem of stomping on the buffers ends here. 150 * The problem of stomping on the buffers ends here.
151 * Why didn't anyone see this one coming? --AJK 151 * Why didn't anyone see this one coming? --AJK
152 */ 152 */
153 spin_lock_irqsave(&tty->read_lock, flags); 153 spin_lock_irqsave(&tty->read_lock, flags);
154 put_tty_queue_nolock(c, tty); 154 put_tty_queue_nolock(c, tty);
155 spin_unlock_irqrestore(&tty->read_lock, flags); 155 spin_unlock_irqrestore(&tty->read_lock, flags);
156 } 156 }
157 157
158 /** 158 /**
159 * check_unthrottle - allow new receive data 159 * check_unthrottle - allow new receive data
160 * @tty; tty device 160 * @tty; tty device
161 * 161 *
162 * Check whether to call the driver unthrottle functions 162 * Check whether to call the driver unthrottle functions
163 * 163 *
164 * Can sleep, may be called under the atomic_read_lock mutex but 164 * Can sleep, may be called under the atomic_read_lock mutex but
165 * this is not guaranteed. 165 * this is not guaranteed.
166 */ 166 */
167 static void check_unthrottle(struct tty_struct *tty) 167 static void check_unthrottle(struct tty_struct *tty)
168 { 168 {
169 if (tty->count) 169 if (tty->count)
170 tty_unthrottle(tty); 170 tty_unthrottle(tty);
171 } 171 }
172 172
173 /** 173 /**
174 * reset_buffer_flags - reset buffer state 174 * reset_buffer_flags - reset buffer state
175 * @tty: terminal to reset 175 * @tty: terminal to reset
176 * 176 *
177 * Reset the read buffer counters, clear the flags, 177 * Reset the read buffer counters, clear the flags,
178 * and make sure the driver is unthrottled. Called 178 * and make sure the driver is unthrottled. Called
179 * from n_tty_open() and n_tty_flush_buffer(). 179 * from n_tty_open() and n_tty_flush_buffer().
180 * 180 *
181 * Locking: tty_read_lock for read fields. 181 * Locking: tty_read_lock for read fields.
182 */ 182 */
183 183
184 static void reset_buffer_flags(struct tty_struct *tty) 184 static void reset_buffer_flags(struct tty_struct *tty)
185 { 185 {
186 unsigned long flags; 186 unsigned long flags;
187 187
188 spin_lock_irqsave(&tty->read_lock, flags); 188 spin_lock_irqsave(&tty->read_lock, flags);
189 tty->read_head = tty->read_tail = tty->read_cnt = 0; 189 tty->read_head = tty->read_tail = tty->read_cnt = 0;
190 spin_unlock_irqrestore(&tty->read_lock, flags); 190 spin_unlock_irqrestore(&tty->read_lock, flags);
191 191
192 mutex_lock(&tty->echo_lock); 192 mutex_lock(&tty->echo_lock);
193 tty->echo_pos = tty->echo_cnt = tty->echo_overrun = 0; 193 tty->echo_pos = tty->echo_cnt = tty->echo_overrun = 0;
194 mutex_unlock(&tty->echo_lock); 194 mutex_unlock(&tty->echo_lock);
195 195
196 tty->canon_head = tty->canon_data = tty->erasing = 0; 196 tty->canon_head = tty->canon_data = tty->erasing = 0;
197 memset(&tty->read_flags, 0, sizeof tty->read_flags); 197 memset(&tty->read_flags, 0, sizeof tty->read_flags);
198 n_tty_set_room(tty); 198 n_tty_set_room(tty);
199 check_unthrottle(tty); 199 check_unthrottle(tty);
200 } 200 }
201 201
202 /** 202 /**
203 * n_tty_flush_buffer - clean input queue 203 * n_tty_flush_buffer - clean input queue
204 * @tty: terminal device 204 * @tty: terminal device
205 * 205 *
206 * Flush the input buffer. Called when the line discipline is 206 * Flush the input buffer. Called when the line discipline is
207 * being closed, when the tty layer wants the buffer flushed (eg 207 * being closed, when the tty layer wants the buffer flushed (eg
208 * at hangup) or when the N_TTY line discipline internally has to 208 * at hangup) or when the N_TTY line discipline internally has to
209 * clean the pending queue (for example some signals). 209 * clean the pending queue (for example some signals).
210 * 210 *
211 * Locking: ctrl_lock, read_lock. 211 * Locking: ctrl_lock, read_lock.
212 */ 212 */
213 213
214 static void n_tty_flush_buffer(struct tty_struct *tty) 214 static void n_tty_flush_buffer(struct tty_struct *tty)
215 { 215 {
216 unsigned long flags; 216 unsigned long flags;
217 /* clear everything and unthrottle the driver */ 217 /* clear everything and unthrottle the driver */
218 reset_buffer_flags(tty); 218 reset_buffer_flags(tty);
219 219
220 if (!tty->link) 220 if (!tty->link)
221 return; 221 return;
222 222
223 spin_lock_irqsave(&tty->ctrl_lock, flags); 223 spin_lock_irqsave(&tty->ctrl_lock, flags);
224 if (tty->link->packet) { 224 if (tty->link->packet) {
225 tty->ctrl_status |= TIOCPKT_FLUSHREAD; 225 tty->ctrl_status |= TIOCPKT_FLUSHREAD;
226 wake_up_interruptible(&tty->link->read_wait); 226 wake_up_interruptible(&tty->link->read_wait);
227 } 227 }
228 spin_unlock_irqrestore(&tty->ctrl_lock, flags); 228 spin_unlock_irqrestore(&tty->ctrl_lock, flags);
229 } 229 }
230 230
231 /** 231 /**
232 * n_tty_chars_in_buffer - report available bytes 232 * n_tty_chars_in_buffer - report available bytes
233 * @tty: tty device 233 * @tty: tty device
234 * 234 *
235 * Report the number of characters buffered to be delivered to user 235 * Report the number of characters buffered to be delivered to user
236 * at this instant in time. 236 * at this instant in time.
237 * 237 *
238 * Locking: read_lock 238 * Locking: read_lock
239 */ 239 */
240 240
241 static ssize_t n_tty_chars_in_buffer(struct tty_struct *tty) 241 static ssize_t n_tty_chars_in_buffer(struct tty_struct *tty)
242 { 242 {
243 unsigned long flags; 243 unsigned long flags;
244 ssize_t n = 0; 244 ssize_t n = 0;
245 245
246 spin_lock_irqsave(&tty->read_lock, flags); 246 spin_lock_irqsave(&tty->read_lock, flags);
247 if (!tty->icanon) { 247 if (!tty->icanon) {
248 n = tty->read_cnt; 248 n = tty->read_cnt;
249 } else if (tty->canon_data) { 249 } else if (tty->canon_data) {
250 n = (tty->canon_head > tty->read_tail) ? 250 n = (tty->canon_head > tty->read_tail) ?
251 tty->canon_head - tty->read_tail : 251 tty->canon_head - tty->read_tail :
252 tty->canon_head + (N_TTY_BUF_SIZE - tty->read_tail); 252 tty->canon_head + (N_TTY_BUF_SIZE - tty->read_tail);
253 } 253 }
254 spin_unlock_irqrestore(&tty->read_lock, flags); 254 spin_unlock_irqrestore(&tty->read_lock, flags);
255 return n; 255 return n;
256 } 256 }
257 257
258 /** 258 /**
259 * is_utf8_continuation - utf8 multibyte check 259 * is_utf8_continuation - utf8 multibyte check
260 * @c: byte to check 260 * @c: byte to check
261 * 261 *
262 * Returns true if the utf8 character 'c' is a multibyte continuation 262 * Returns true if the utf8 character 'c' is a multibyte continuation
263 * character. We use this to correctly compute the on screen size 263 * character. We use this to correctly compute the on screen size
264 * of the character when printing 264 * of the character when printing
265 */ 265 */
266 266
267 static inline int is_utf8_continuation(unsigned char c) 267 static inline int is_utf8_continuation(unsigned char c)
268 { 268 {
269 return (c & 0xc0) == 0x80; 269 return (c & 0xc0) == 0x80;
270 } 270 }
271 271
272 /** 272 /**
273 * is_continuation - multibyte check 273 * is_continuation - multibyte check
274 * @c: byte to check 274 * @c: byte to check
275 * 275 *
276 * Returns true if the utf8 character 'c' is a multibyte continuation 276 * Returns true if the utf8 character 'c' is a multibyte continuation
277 * character and the terminal is in unicode mode. 277 * character and the terminal is in unicode mode.
278 */ 278 */
279 279
280 static inline int is_continuation(unsigned char c, struct tty_struct *tty) 280 static inline int is_continuation(unsigned char c, struct tty_struct *tty)
281 { 281 {
282 return I_IUTF8(tty) && is_utf8_continuation(c); 282 return I_IUTF8(tty) && is_utf8_continuation(c);
283 } 283 }
284 284
285 /** 285 /**
286 * do_output_char - output one character 286 * do_output_char - output one character
287 * @c: character (or partial unicode symbol) 287 * @c: character (or partial unicode symbol)
288 * @tty: terminal device 288 * @tty: terminal device
289 * @space: space available in tty driver write buffer 289 * @space: space available in tty driver write buffer
290 * 290 *
291 * This is a helper function that handles one output character 291 * This is a helper function that handles one output character
292 * (including special characters like TAB, CR, LF, etc.), 292 * (including special characters like TAB, CR, LF, etc.),
293 * putting the results in the tty driver's write buffer. 293 * putting the results in the tty driver's write buffer.
294 * 294 *
295 * Note that Linux currently ignores TABDLY, CRDLY, VTDLY, FFDLY 295 * Note that Linux currently ignores TABDLY, CRDLY, VTDLY, FFDLY
296 * and NLDLY. They simply aren't relevant in the world today. 296 * and NLDLY. They simply aren't relevant in the world today.
297 * If you ever need them, add them here. 297 * If you ever need them, add them here.
298 * 298 *
299 * Returns the number of bytes of buffer space used or -1 if 299 * Returns the number of bytes of buffer space used or -1 if
300 * no space left. 300 * no space left.
301 * 301 *
302 * Locking: should be called under the output_lock to protect 302 * Locking: should be called under the output_lock to protect
303 * the column state and space left in the buffer 303 * the column state and space left in the buffer
304 */ 304 */
305 305
306 static int do_output_char(unsigned char c, struct tty_struct *tty, int space) 306 static int do_output_char(unsigned char c, struct tty_struct *tty, int space)
307 { 307 {
308 int spaces; 308 int spaces;
309 309
310 if (!space) 310 if (!space)
311 return -1; 311 return -1;
312 312
313 switch (c) { 313 switch (c) {
314 case '\n': 314 case '\n':
315 if (O_ONLRET(tty)) 315 if (O_ONLRET(tty))
316 tty->column = 0; 316 tty->column = 0;
317 if (O_ONLCR(tty)) { 317 if (O_ONLCR(tty)) {
318 if (space < 2) 318 if (space < 2)
319 return -1; 319 return -1;
320 tty->canon_column = tty->column = 0; 320 tty->canon_column = tty->column = 0;
321 tty_put_char(tty, '\r'); 321 tty_put_char(tty, '\r');
322 tty_put_char(tty, c); 322 tty_put_char(tty, c);
323 return 2; 323 return 2;
324 } 324 }
325 tty->canon_column = tty->column; 325 tty->canon_column = tty->column;
326 break; 326 break;
327 case '\r': 327 case '\r':
328 if (O_ONOCR(tty) && tty->column == 0) 328 if (O_ONOCR(tty) && tty->column == 0)
329 return 0; 329 return 0;
330 if (O_OCRNL(tty)) { 330 if (O_OCRNL(tty)) {
331 c = '\n'; 331 c = '\n';
332 if (O_ONLRET(tty)) 332 if (O_ONLRET(tty))
333 tty->canon_column = tty->column = 0; 333 tty->canon_column = tty->column = 0;
334 break; 334 break;
335 } 335 }
336 tty->canon_column = tty->column = 0; 336 tty->canon_column = tty->column = 0;
337 break; 337 break;
338 case '\t': 338 case '\t':
339 spaces = 8 - (tty->column & 7); 339 spaces = 8 - (tty->column & 7);
340 if (O_TABDLY(tty) == XTABS) { 340 if (O_TABDLY(tty) == XTABS) {
341 if (space < spaces) 341 if (space < spaces)
342 return -1; 342 return -1;
343 tty->column += spaces; 343 tty->column += spaces;
344 tty->ops->write(tty, " ", spaces); 344 tty->ops->write(tty, " ", spaces);
345 return spaces; 345 return spaces;
346 } 346 }
347 tty->column += spaces; 347 tty->column += spaces;
348 break; 348 break;
349 case '\b': 349 case '\b':
350 if (tty->column > 0) 350 if (tty->column > 0)
351 tty->column--; 351 tty->column--;
352 break; 352 break;
353 default: 353 default:
354 if (!iscntrl(c)) { 354 if (!iscntrl(c)) {
355 if (O_OLCUC(tty)) 355 if (O_OLCUC(tty))
356 c = toupper(c); 356 c = toupper(c);
357 if (!is_continuation(c, tty)) 357 if (!is_continuation(c, tty))
358 tty->column++; 358 tty->column++;
359 } 359 }
360 break; 360 break;
361 } 361 }
362 362
363 tty_put_char(tty, c); 363 tty_put_char(tty, c);
364 return 1; 364 return 1;
365 } 365 }
366 366
367 /** 367 /**
368 * process_output - output post processor 368 * process_output - output post processor
369 * @c: character (or partial unicode symbol) 369 * @c: character (or partial unicode symbol)
370 * @tty: terminal device 370 * @tty: terminal device
371 * 371 *
372 * Perform OPOST processing. Returns -1 when the output device is 372 * Perform OPOST processing. Returns -1 when the output device is
373 * full and the character must be retried. 373 * full and the character must be retried.
374 * 374 *
375 * Locking: output_lock to protect column state and space left 375 * Locking: output_lock to protect column state and space left
376 * (also, this is called from n_tty_write under the 376 * (also, this is called from n_tty_write under the
377 * tty layer write lock) 377 * tty layer write lock)
378 */ 378 */
379 379
380 static int process_output(unsigned char c, struct tty_struct *tty) 380 static int process_output(unsigned char c, struct tty_struct *tty)
381 { 381 {
382 int space, retval; 382 int space, retval;
383 383
384 mutex_lock(&tty->output_lock); 384 mutex_lock(&tty->output_lock);
385 385
386 space = tty_write_room(tty); 386 space = tty_write_room(tty);
387 retval = do_output_char(c, tty, space); 387 retval = do_output_char(c, tty, space);
388 388
389 mutex_unlock(&tty->output_lock); 389 mutex_unlock(&tty->output_lock);
390 if (retval < 0) 390 if (retval < 0)
391 return -1; 391 return -1;
392 else 392 else
393 return 0; 393 return 0;
394 } 394 }
395 395
396 /** 396 /**
397 * process_output_block - block post processor 397 * process_output_block - block post processor
398 * @tty: terminal device 398 * @tty: terminal device
399 * @inbuf: user buffer 399 * @inbuf: user buffer
400 * @nr: number of bytes 400 * @nr: number of bytes
401 * 401 *
402 * This path is used to speed up block console writes, among other 402 * This path is used to speed up block console writes, among other
403 * things when processing blocks of output data. It handles only 403 * things when processing blocks of output data. It handles only
404 * the simple cases normally found and helps to generate blocks of 404 * the simple cases normally found and helps to generate blocks of
405 * symbols for the console driver and thus improve performance. 405 * symbols for the console driver and thus improve performance.
406 * 406 *
407 * Locking: output_lock to protect column state and space left 407 * Locking: output_lock to protect column state and space left
408 * (also, this is called from n_tty_write under the 408 * (also, this is called from n_tty_write under the
409 * tty layer write lock) 409 * tty layer write lock)
410 */ 410 */
411 411
412 static ssize_t process_output_block(struct tty_struct *tty, 412 static ssize_t process_output_block(struct tty_struct *tty,
413 const unsigned char *buf, unsigned int nr) 413 const unsigned char *buf, unsigned int nr)
414 { 414 {
415 int space; 415 int space;
416 int i; 416 int i;
417 const unsigned char *cp; 417 const unsigned char *cp;
418 418
419 mutex_lock(&tty->output_lock); 419 mutex_lock(&tty->output_lock);
420 420
421 space = tty_write_room(tty); 421 space = tty_write_room(tty);
422 if (!space) { 422 if (!space) {
423 mutex_unlock(&tty->output_lock); 423 mutex_unlock(&tty->output_lock);
424 return 0; 424 return 0;
425 } 425 }
426 if (nr > space) 426 if (nr > space)
427 nr = space; 427 nr = space;
428 428
429 for (i = 0, cp = buf; i < nr; i++, cp++) { 429 for (i = 0, cp = buf; i < nr; i++, cp++) {
430 unsigned char c = *cp; 430 unsigned char c = *cp;
431 431
432 switch (c) { 432 switch (c) {
433 case '\n': 433 case '\n':
434 if (O_ONLRET(tty)) 434 if (O_ONLRET(tty))
435 tty->column = 0; 435 tty->column = 0;
436 if (O_ONLCR(tty)) 436 if (O_ONLCR(tty))
437 goto break_out; 437 goto break_out;
438 tty->canon_column = tty->column; 438 tty->canon_column = tty->column;
439 break; 439 break;
440 case '\r': 440 case '\r':
441 if (O_ONOCR(tty) && tty->column == 0) 441 if (O_ONOCR(tty) && tty->column == 0)
442 goto break_out; 442 goto break_out;
443 if (O_OCRNL(tty)) 443 if (O_OCRNL(tty))
444 goto break_out; 444 goto break_out;
445 tty->canon_column = tty->column = 0; 445 tty->canon_column = tty->column = 0;
446 break; 446 break;
447 case '\t': 447 case '\t':
448 goto break_out; 448 goto break_out;
449 case '\b': 449 case '\b':
450 if (tty->column > 0) 450 if (tty->column > 0)
451 tty->column--; 451 tty->column--;
452 break; 452 break;
453 default: 453 default:
454 if (!iscntrl(c)) { 454 if (!iscntrl(c)) {
455 if (O_OLCUC(tty)) 455 if (O_OLCUC(tty))
456 goto break_out; 456 goto break_out;
457 if (!is_continuation(c, tty)) 457 if (!is_continuation(c, tty))
458 tty->column++; 458 tty->column++;
459 } 459 }
460 break; 460 break;
461 } 461 }
462 } 462 }
463 break_out: 463 break_out:
464 i = tty->ops->write(tty, buf, i); 464 i = tty->ops->write(tty, buf, i);
465 465
466 mutex_unlock(&tty->output_lock); 466 mutex_unlock(&tty->output_lock);
467 return i; 467 return i;
468 } 468 }
469 469
470 /** 470 /**
471 * process_echoes - write pending echo characters 471 * process_echoes - write pending echo characters
472 * @tty: terminal device 472 * @tty: terminal device
473 * 473 *
474 * Write previously buffered echo (and other ldisc-generated) 474 * Write previously buffered echo (and other ldisc-generated)
475 * characters to the tty. 475 * characters to the tty.
476 * 476 *
477 * Characters generated by the ldisc (including echoes) need to 477 * Characters generated by the ldisc (including echoes) need to
478 * be buffered because the driver's write buffer can fill during 478 * be buffered because the driver's write buffer can fill during
479 * heavy program output. Echoing straight to the driver will 479 * heavy program output. Echoing straight to the driver will
480 * often fail under these conditions, causing lost characters and 480 * often fail under these conditions, causing lost characters and
481 * resulting mismatches of ldisc state information. 481 * resulting mismatches of ldisc state information.
482 * 482 *
483 * Since the ldisc state must represent the characters actually sent 483 * Since the ldisc state must represent the characters actually sent
484 * to the driver at the time of the write, operations like certain 484 * to the driver at the time of the write, operations like certain
485 * changes in column state are also saved in the buffer and executed 485 * changes in column state are also saved in the buffer and executed
486 * here. 486 * here.
487 * 487 *
488 * A circular fifo buffer is used so that the most recent characters 488 * A circular fifo buffer is used so that the most recent characters
489 * are prioritized. Also, when control characters are echoed with a 489 * are prioritized. Also, when control characters are echoed with a
490 * prefixed "^", the pair is treated atomically and thus not separated. 490 * prefixed "^", the pair is treated atomically and thus not separated.
491 * 491 *
492 * Locking: output_lock to protect column state and space left, 492 * Locking: output_lock to protect column state and space left,
493 * echo_lock to protect the echo buffer 493 * echo_lock to protect the echo buffer
494 */ 494 */
495 495
496 static void process_echoes(struct tty_struct *tty) 496 static void process_echoes(struct tty_struct *tty)
497 { 497 {
498 int space, nr; 498 int space, nr;
499 unsigned char c; 499 unsigned char c;
500 unsigned char *cp, *buf_end; 500 unsigned char *cp, *buf_end;
501 501
502 if (!tty->echo_cnt) 502 if (!tty->echo_cnt)
503 return; 503 return;
504 504
505 mutex_lock(&tty->output_lock); 505 mutex_lock(&tty->output_lock);
506 mutex_lock(&tty->echo_lock); 506 mutex_lock(&tty->echo_lock);
507 507
508 space = tty_write_room(tty); 508 space = tty_write_room(tty);
509 509
510 buf_end = tty->echo_buf + N_TTY_BUF_SIZE; 510 buf_end = tty->echo_buf + N_TTY_BUF_SIZE;
511 cp = tty->echo_buf + tty->echo_pos; 511 cp = tty->echo_buf + tty->echo_pos;
512 nr = tty->echo_cnt; 512 nr = tty->echo_cnt;
513 while (nr > 0) { 513 while (nr > 0) {
514 c = *cp; 514 c = *cp;
515 if (c == ECHO_OP_START) { 515 if (c == ECHO_OP_START) {
516 unsigned char op; 516 unsigned char op;
517 unsigned char *opp; 517 unsigned char *opp;
518 int no_space_left = 0; 518 int no_space_left = 0;
519 519
520 /* 520 /*
521 * If the buffer byte is the start of a multi-byte 521 * If the buffer byte is the start of a multi-byte
522 * operation, get the next byte, which is either the 522 * operation, get the next byte, which is either the
523 * op code or a control character value. 523 * op code or a control character value.
524 */ 524 */
525 opp = cp + 1; 525 opp = cp + 1;
526 if (opp == buf_end) 526 if (opp == buf_end)
527 opp -= N_TTY_BUF_SIZE; 527 opp -= N_TTY_BUF_SIZE;
528 op = *opp; 528 op = *opp;
529 529
530 switch (op) { 530 switch (op) {
531 unsigned int num_chars, num_bs; 531 unsigned int num_chars, num_bs;
532 532
533 case ECHO_OP_ERASE_TAB: 533 case ECHO_OP_ERASE_TAB:
534 if (++opp == buf_end) 534 if (++opp == buf_end)
535 opp -= N_TTY_BUF_SIZE; 535 opp -= N_TTY_BUF_SIZE;
536 num_chars = *opp; 536 num_chars = *opp;
537 537
538 /* 538 /*
539 * Determine how many columns to go back 539 * Determine how many columns to go back
540 * in order to erase the tab. 540 * in order to erase the tab.
541 * This depends on the number of columns 541 * This depends on the number of columns
542 * used by other characters within the tab 542 * used by other characters within the tab
543 * area. If this (modulo 8) count is from 543 * area. If this (modulo 8) count is from
544 * the start of input rather than from a 544 * the start of input rather than from a
545 * previous tab, we offset by canon column. 545 * previous tab, we offset by canon column.
546 * Otherwise, tab spacing is normal. 546 * Otherwise, tab spacing is normal.
547 */ 547 */
548 if (!(num_chars & 0x80)) 548 if (!(num_chars & 0x80))
549 num_chars += tty->canon_column; 549 num_chars += tty->canon_column;
550 num_bs = 8 - (num_chars & 7); 550 num_bs = 8 - (num_chars & 7);
551 551
552 if (num_bs > space) { 552 if (num_bs > space) {
553 no_space_left = 1; 553 no_space_left = 1;
554 break; 554 break;
555 } 555 }
556 space -= num_bs; 556 space -= num_bs;
557 while (num_bs--) { 557 while (num_bs--) {
558 tty_put_char(tty, '\b'); 558 tty_put_char(tty, '\b');
559 if (tty->column > 0) 559 if (tty->column > 0)
560 tty->column--; 560 tty->column--;
561 } 561 }
562 cp += 3; 562 cp += 3;
563 nr -= 3; 563 nr -= 3;
564 break; 564 break;
565 565
566 case ECHO_OP_SET_CANON_COL: 566 case ECHO_OP_SET_CANON_COL:
567 tty->canon_column = tty->column; 567 tty->canon_column = tty->column;
568 cp += 2; 568 cp += 2;
569 nr -= 2; 569 nr -= 2;
570 break; 570 break;
571 571
572 case ECHO_OP_MOVE_BACK_COL: 572 case ECHO_OP_MOVE_BACK_COL:
573 if (tty->column > 0) 573 if (tty->column > 0)
574 tty->column--; 574 tty->column--;
575 cp += 2; 575 cp += 2;
576 nr -= 2; 576 nr -= 2;
577 break; 577 break;
578 578
579 case ECHO_OP_START: 579 case ECHO_OP_START:
580 /* This is an escaped echo op start code */ 580 /* This is an escaped echo op start code */
581 if (!space) { 581 if (!space) {
582 no_space_left = 1; 582 no_space_left = 1;
583 break; 583 break;
584 } 584 }
585 tty_put_char(tty, ECHO_OP_START); 585 tty_put_char(tty, ECHO_OP_START);
586 tty->column++; 586 tty->column++;
587 space--; 587 space--;
588 cp += 2; 588 cp += 2;
589 nr -= 2; 589 nr -= 2;
590 break; 590 break;
591 591
592 default: 592 default:
593 if (iscntrl(op)) { 593 if (iscntrl(op)) {
594 if (L_ECHOCTL(tty)) { 594 if (L_ECHOCTL(tty)) {
595 /* 595 /*
596 * Ensure there is enough space 596 * Ensure there is enough space
597 * for the whole ctrl pair. 597 * for the whole ctrl pair.
598 */ 598 */
599 if (space < 2) { 599 if (space < 2) {
600 no_space_left = 1; 600 no_space_left = 1;
601 break; 601 break;
602 } 602 }
603 tty_put_char(tty, '^'); 603 tty_put_char(tty, '^');
604 tty_put_char(tty, op ^ 0100); 604 tty_put_char(tty, op ^ 0100);
605 tty->column += 2; 605 tty->column += 2;
606 space -= 2; 606 space -= 2;
607 } else { 607 } else {
608 if (!space) { 608 if (!space) {
609 no_space_left = 1; 609 no_space_left = 1;
610 break; 610 break;
611 } 611 }
612 tty_put_char(tty, op); 612 tty_put_char(tty, op);
613 space--; 613 space--;
614 } 614 }
615 } 615 }
616 /* 616 /*
617 * If above falls through, this was an 617 * If above falls through, this was an
618 * undefined op. 618 * undefined op.
619 */ 619 */
620 cp += 2; 620 cp += 2;
621 nr -= 2; 621 nr -= 2;
622 } 622 }
623 623
624 if (no_space_left) 624 if (no_space_left)
625 break; 625 break;
626 } else { 626 } else {
627 int retval; 627 int retval;
628 628
629 retval = do_output_char(c, tty, space); 629 retval = do_output_char(c, tty, space);
630 if (retval < 0) 630 if (retval < 0)
631 break; 631 break;
632 space -= retval; 632 space -= retval;
633 cp += 1; 633 cp += 1;
634 nr -= 1; 634 nr -= 1;
635 } 635 }
636 636
637 /* When end of circular buffer reached, wrap around */ 637 /* When end of circular buffer reached, wrap around */
638 if (cp >= buf_end) 638 if (cp >= buf_end)
639 cp -= N_TTY_BUF_SIZE; 639 cp -= N_TTY_BUF_SIZE;
640 } 640 }
641 641
642 if (nr == 0) { 642 if (nr == 0) {
643 tty->echo_pos = 0; 643 tty->echo_pos = 0;
644 tty->echo_cnt = 0; 644 tty->echo_cnt = 0;
645 tty->echo_overrun = 0; 645 tty->echo_overrun = 0;
646 } else { 646 } else {
647 int num_processed = tty->echo_cnt - nr; 647 int num_processed = tty->echo_cnt - nr;
648 tty->echo_pos += num_processed; 648 tty->echo_pos += num_processed;
649 tty->echo_pos &= N_TTY_BUF_SIZE - 1; 649 tty->echo_pos &= N_TTY_BUF_SIZE - 1;
650 tty->echo_cnt = nr; 650 tty->echo_cnt = nr;
651 if (num_processed > 0) 651 if (num_processed > 0)
652 tty->echo_overrun = 0; 652 tty->echo_overrun = 0;
653 } 653 }
654 654
655 mutex_unlock(&tty->echo_lock); 655 mutex_unlock(&tty->echo_lock);
656 mutex_unlock(&tty->output_lock); 656 mutex_unlock(&tty->output_lock);
657 657
658 if (tty->ops->flush_chars) 658 if (tty->ops->flush_chars)
659 tty->ops->flush_chars(tty); 659 tty->ops->flush_chars(tty);
660 } 660 }
661 661
662 /** 662 /**
663 * add_echo_byte - add a byte to the echo buffer 663 * add_echo_byte - add a byte to the echo buffer
664 * @c: unicode byte to echo 664 * @c: unicode byte to echo
665 * @tty: terminal device 665 * @tty: terminal device
666 * 666 *
667 * Add a character or operation byte to the echo buffer. 667 * Add a character or operation byte to the echo buffer.
668 * 668 *
669 * Should be called under the echo lock to protect the echo buffer. 669 * Should be called under the echo lock to protect the echo buffer.
670 */ 670 */
671 671
672 static void add_echo_byte(unsigned char c, struct tty_struct *tty) 672 static void add_echo_byte(unsigned char c, struct tty_struct *tty)
673 { 673 {
674 int new_byte_pos; 674 int new_byte_pos;
675 675
676 if (tty->echo_cnt == N_TTY_BUF_SIZE) { 676 if (tty->echo_cnt == N_TTY_BUF_SIZE) {
677 /* Circular buffer is already at capacity */ 677 /* Circular buffer is already at capacity */
678 new_byte_pos = tty->echo_pos; 678 new_byte_pos = tty->echo_pos;
679 679
680 /* 680 /*
681 * Since the buffer start position needs to be advanced, 681 * Since the buffer start position needs to be advanced,
682 * be sure to step by a whole operation byte group. 682 * be sure to step by a whole operation byte group.
683 */ 683 */
684 if (tty->echo_buf[tty->echo_pos] == ECHO_OP_START) { 684 if (tty->echo_buf[tty->echo_pos] == ECHO_OP_START) {
685 if (tty->echo_buf[(tty->echo_pos + 1) & 685 if (tty->echo_buf[(tty->echo_pos + 1) &
686 (N_TTY_BUF_SIZE - 1)] == 686 (N_TTY_BUF_SIZE - 1)] ==
687 ECHO_OP_ERASE_TAB) { 687 ECHO_OP_ERASE_TAB) {
688 tty->echo_pos += 3; 688 tty->echo_pos += 3;
689 tty->echo_cnt -= 2; 689 tty->echo_cnt -= 2;
690 } else { 690 } else {
691 tty->echo_pos += 2; 691 tty->echo_pos += 2;
692 tty->echo_cnt -= 1; 692 tty->echo_cnt -= 1;
693 } 693 }
694 } else { 694 } else {
695 tty->echo_pos++; 695 tty->echo_pos++;
696 } 696 }
697 tty->echo_pos &= N_TTY_BUF_SIZE - 1; 697 tty->echo_pos &= N_TTY_BUF_SIZE - 1;
698 698
699 tty->echo_overrun = 1; 699 tty->echo_overrun = 1;
700 } else { 700 } else {
701 new_byte_pos = tty->echo_pos + tty->echo_cnt; 701 new_byte_pos = tty->echo_pos + tty->echo_cnt;
702 new_byte_pos &= N_TTY_BUF_SIZE - 1; 702 new_byte_pos &= N_TTY_BUF_SIZE - 1;
703 tty->echo_cnt++; 703 tty->echo_cnt++;
704 } 704 }
705 705
706 tty->echo_buf[new_byte_pos] = c; 706 tty->echo_buf[new_byte_pos] = c;
707 } 707 }
708 708
709 /** 709 /**
710 * echo_move_back_col - add operation to move back a column 710 * echo_move_back_col - add operation to move back a column
711 * @tty: terminal device 711 * @tty: terminal device
712 * 712 *
713 * Add an operation to the echo buffer to move back one column. 713 * Add an operation to the echo buffer to move back one column.
714 * 714 *
715 * Locking: echo_lock to protect the echo buffer 715 * Locking: echo_lock to protect the echo buffer
716 */ 716 */
717 717
718 static void echo_move_back_col(struct tty_struct *tty) 718 static void echo_move_back_col(struct tty_struct *tty)
719 { 719 {
720 mutex_lock(&tty->echo_lock); 720 mutex_lock(&tty->echo_lock);
721 721
722 add_echo_byte(ECHO_OP_START, tty); 722 add_echo_byte(ECHO_OP_START, tty);
723 add_echo_byte(ECHO_OP_MOVE_BACK_COL, tty); 723 add_echo_byte(ECHO_OP_MOVE_BACK_COL, tty);
724 724
725 mutex_unlock(&tty->echo_lock); 725 mutex_unlock(&tty->echo_lock);
726 } 726 }
727 727
728 /** 728 /**
729 * echo_set_canon_col - add operation to set the canon column 729 * echo_set_canon_col - add operation to set the canon column
730 * @tty: terminal device 730 * @tty: terminal device
731 * 731 *
732 * Add an operation to the echo buffer to set the canon column 732 * Add an operation to the echo buffer to set the canon column
733 * to the current column. 733 * to the current column.
734 * 734 *
735 * Locking: echo_lock to protect the echo buffer 735 * Locking: echo_lock to protect the echo buffer
736 */ 736 */
737 737
738 static void echo_set_canon_col(struct tty_struct *tty) 738 static void echo_set_canon_col(struct tty_struct *tty)
739 { 739 {
740 mutex_lock(&tty->echo_lock); 740 mutex_lock(&tty->echo_lock);
741 741
742 add_echo_byte(ECHO_OP_START, tty); 742 add_echo_byte(ECHO_OP_START, tty);
743 add_echo_byte(ECHO_OP_SET_CANON_COL, tty); 743 add_echo_byte(ECHO_OP_SET_CANON_COL, tty);
744 744
745 mutex_unlock(&tty->echo_lock); 745 mutex_unlock(&tty->echo_lock);
746 } 746 }
747 747
748 /** 748 /**
749 * echo_erase_tab - add operation to erase a tab 749 * echo_erase_tab - add operation to erase a tab
750 * @num_chars: number of character columns already used 750 * @num_chars: number of character columns already used
751 * @after_tab: true if num_chars starts after a previous tab 751 * @after_tab: true if num_chars starts after a previous tab
752 * @tty: terminal device 752 * @tty: terminal device
753 * 753 *
754 * Add an operation to the echo buffer to erase a tab. 754 * Add an operation to the echo buffer to erase a tab.
755 * 755 *
756 * Called by the eraser function, which knows how many character 756 * Called by the eraser function, which knows how many character
757 * columns have been used since either a previous tab or the start 757 * columns have been used since either a previous tab or the start
758 * of input. This information will be used later, along with 758 * of input. This information will be used later, along with
759 * canon column (if applicable), to go back the correct number 759 * canon column (if applicable), to go back the correct number
760 * of columns. 760 * of columns.
761 * 761 *
762 * Locking: echo_lock to protect the echo buffer 762 * Locking: echo_lock to protect the echo buffer
763 */ 763 */
764 764
765 static void echo_erase_tab(unsigned int num_chars, int after_tab, 765 static void echo_erase_tab(unsigned int num_chars, int after_tab,
766 struct tty_struct *tty) 766 struct tty_struct *tty)
767 { 767 {
768 mutex_lock(&tty->echo_lock); 768 mutex_lock(&tty->echo_lock);
769 769
770 add_echo_byte(ECHO_OP_START, tty); 770 add_echo_byte(ECHO_OP_START, tty);
771 add_echo_byte(ECHO_OP_ERASE_TAB, tty); 771 add_echo_byte(ECHO_OP_ERASE_TAB, tty);
772 772
773 /* We only need to know this modulo 8 (tab spacing) */ 773 /* We only need to know this modulo 8 (tab spacing) */
774 num_chars &= 7; 774 num_chars &= 7;
775 775
776 /* Set the high bit as a flag if num_chars is after a previous tab */ 776 /* Set the high bit as a flag if num_chars is after a previous tab */
777 if (after_tab) 777 if (after_tab)
778 num_chars |= 0x80; 778 num_chars |= 0x80;
779 779
780 add_echo_byte(num_chars, tty); 780 add_echo_byte(num_chars, tty);
781 781
782 mutex_unlock(&tty->echo_lock); 782 mutex_unlock(&tty->echo_lock);
783 } 783 }
784 784
785 /** 785 /**
786 * echo_char_raw - echo a character raw 786 * echo_char_raw - echo a character raw
787 * @c: unicode byte to echo 787 * @c: unicode byte to echo
788 * @tty: terminal device 788 * @tty: terminal device
789 * 789 *
790 * Echo user input back onto the screen. This must be called only when 790 * Echo user input back onto the screen. This must be called only when
791 * L_ECHO(tty) is true. Called from the driver receive_buf path. 791 * L_ECHO(tty) is true. Called from the driver receive_buf path.
792 * 792 *
793 * This variant does not treat control characters specially. 793 * This variant does not treat control characters specially.
794 * 794 *
795 * Locking: echo_lock to protect the echo buffer 795 * Locking: echo_lock to protect the echo buffer
796 */ 796 */
797 797
798 static void echo_char_raw(unsigned char c, struct tty_struct *tty) 798 static void echo_char_raw(unsigned char c, struct tty_struct *tty)
799 { 799 {
800 mutex_lock(&tty->echo_lock); 800 mutex_lock(&tty->echo_lock);
801 801
802 if (c == ECHO_OP_START) { 802 if (c == ECHO_OP_START) {
803 add_echo_byte(ECHO_OP_START, tty); 803 add_echo_byte(ECHO_OP_START, tty);
804 add_echo_byte(ECHO_OP_START, tty); 804 add_echo_byte(ECHO_OP_START, tty);
805 } else { 805 } else {
806 add_echo_byte(c, tty); 806 add_echo_byte(c, tty);
807 } 807 }
808 808
809 mutex_unlock(&tty->echo_lock); 809 mutex_unlock(&tty->echo_lock);
810 } 810 }
811 811
812 /** 812 /**
813 * echo_char - echo a character 813 * echo_char - echo a character
814 * @c: unicode byte to echo 814 * @c: unicode byte to echo
815 * @tty: terminal device 815 * @tty: terminal device
816 * 816 *
817 * Echo user input back onto the screen. This must be called only when 817 * Echo user input back onto the screen. This must be called only when
818 * L_ECHO(tty) is true. Called from the driver receive_buf path. 818 * L_ECHO(tty) is true. Called from the driver receive_buf path.
819 * 819 *
820 * This variant tags control characters to be possibly echoed as 820 * This variant tags control characters to be possibly echoed as
821 * as "^X" (where X is the letter representing the control char). 821 * as "^X" (where X is the letter representing the control char).
822 * 822 *
823 * Locking: echo_lock to protect the echo buffer 823 * Locking: echo_lock to protect the echo buffer
824 */ 824 */
825 825
826 static void echo_char(unsigned char c, struct tty_struct *tty) 826 static void echo_char(unsigned char c, struct tty_struct *tty)
827 { 827 {
828 mutex_lock(&tty->echo_lock); 828 mutex_lock(&tty->echo_lock);
829 829
830 if (c == ECHO_OP_START) { 830 if (c == ECHO_OP_START) {
831 add_echo_byte(ECHO_OP_START, tty); 831 add_echo_byte(ECHO_OP_START, tty);
832 add_echo_byte(ECHO_OP_START, tty); 832 add_echo_byte(ECHO_OP_START, tty);
833 } else { 833 } else {
834 if (iscntrl(c) && c != '\t') 834 if (iscntrl(c) && c != '\t')
835 add_echo_byte(ECHO_OP_START, tty); 835 add_echo_byte(ECHO_OP_START, tty);
836 add_echo_byte(c, tty); 836 add_echo_byte(c, tty);
837 } 837 }
838 838
839 mutex_unlock(&tty->echo_lock); 839 mutex_unlock(&tty->echo_lock);
840 } 840 }
841 841
842 /** 842 /**
843 * finish_erasing - complete erase 843 * finish_erasing - complete erase
844 * @tty: tty doing the erase 844 * @tty: tty doing the erase
845 */ 845 */
846 846
847 static inline void finish_erasing(struct tty_struct *tty) 847 static inline void finish_erasing(struct tty_struct *tty)
848 { 848 {
849 if (tty->erasing) { 849 if (tty->erasing) {
850 echo_char_raw('/', tty); 850 echo_char_raw('/', tty);
851 tty->erasing = 0; 851 tty->erasing = 0;
852 } 852 }
853 } 853 }
854 854
855 /** 855 /**
856 * eraser - handle erase function 856 * eraser - handle erase function
857 * @c: character input 857 * @c: character input
858 * @tty: terminal device 858 * @tty: terminal device
859 * 859 *
860 * Perform erase and necessary output when an erase character is 860 * Perform erase and necessary output when an erase character is
861 * present in the stream from the driver layer. Handles the complexities 861 * present in the stream from the driver layer. Handles the complexities
862 * of UTF-8 multibyte symbols. 862 * of UTF-8 multibyte symbols.
863 * 863 *
864 * Locking: read_lock for tty buffers 864 * Locking: read_lock for tty buffers
865 */ 865 */
866 866
867 static void eraser(unsigned char c, struct tty_struct *tty) 867 static void eraser(unsigned char c, struct tty_struct *tty)
868 { 868 {
869 enum { ERASE, WERASE, KILL } kill_type; 869 enum { ERASE, WERASE, KILL } kill_type;
870 int head, seen_alnums, cnt; 870 int head, seen_alnums, cnt;
871 unsigned long flags; 871 unsigned long flags;
872 872
873 /* FIXME: locking needed ? */ 873 /* FIXME: locking needed ? */
874 if (tty->read_head == tty->canon_head) { 874 if (tty->read_head == tty->canon_head) {
875 /* process_output('\a', tty); */ /* what do you think? */ 875 /* process_output('\a', tty); */ /* what do you think? */
876 return; 876 return;
877 } 877 }
878 if (c == ERASE_CHAR(tty)) 878 if (c == ERASE_CHAR(tty))
879 kill_type = ERASE; 879 kill_type = ERASE;
880 else if (c == WERASE_CHAR(tty)) 880 else if (c == WERASE_CHAR(tty))
881 kill_type = WERASE; 881 kill_type = WERASE;
882 else { 882 else {
883 if (!L_ECHO(tty)) { 883 if (!L_ECHO(tty)) {
884 spin_lock_irqsave(&tty->read_lock, flags); 884 spin_lock_irqsave(&tty->read_lock, flags);
885 tty->read_cnt -= ((tty->read_head - tty->canon_head) & 885 tty->read_cnt -= ((tty->read_head - tty->canon_head) &
886 (N_TTY_BUF_SIZE - 1)); 886 (N_TTY_BUF_SIZE - 1));
887 tty->read_head = tty->canon_head; 887 tty->read_head = tty->canon_head;
888 spin_unlock_irqrestore(&tty->read_lock, flags); 888 spin_unlock_irqrestore(&tty->read_lock, flags);
889 return; 889 return;
890 } 890 }
891 if (!L_ECHOK(tty) || !L_ECHOKE(tty) || !L_ECHOE(tty)) { 891 if (!L_ECHOK(tty) || !L_ECHOKE(tty) || !L_ECHOE(tty)) {
892 spin_lock_irqsave(&tty->read_lock, flags); 892 spin_lock_irqsave(&tty->read_lock, flags);
893 tty->read_cnt -= ((tty->read_head - tty->canon_head) & 893 tty->read_cnt -= ((tty->read_head - tty->canon_head) &
894 (N_TTY_BUF_SIZE - 1)); 894 (N_TTY_BUF_SIZE - 1));
895 tty->read_head = tty->canon_head; 895 tty->read_head = tty->canon_head;
896 spin_unlock_irqrestore(&tty->read_lock, flags); 896 spin_unlock_irqrestore(&tty->read_lock, flags);
897 finish_erasing(tty); 897 finish_erasing(tty);
898 echo_char(KILL_CHAR(tty), tty); 898 echo_char(KILL_CHAR(tty), tty);
899 /* Add a newline if ECHOK is on and ECHOKE is off. */ 899 /* Add a newline if ECHOK is on and ECHOKE is off. */
900 if (L_ECHOK(tty)) 900 if (L_ECHOK(tty))
901 echo_char_raw('\n', tty); 901 echo_char_raw('\n', tty);
902 return; 902 return;
903 } 903 }
904 kill_type = KILL; 904 kill_type = KILL;
905 } 905 }
906 906
907 seen_alnums = 0; 907 seen_alnums = 0;
908 /* FIXME: Locking ?? */ 908 /* FIXME: Locking ?? */
909 while (tty->read_head != tty->canon_head) { 909 while (tty->read_head != tty->canon_head) {
910 head = tty->read_head; 910 head = tty->read_head;
911 911
912 /* erase a single possibly multibyte character */ 912 /* erase a single possibly multibyte character */
913 do { 913 do {
914 head = (head - 1) & (N_TTY_BUF_SIZE-1); 914 head = (head - 1) & (N_TTY_BUF_SIZE-1);
915 c = tty->read_buf[head]; 915 c = tty->read_buf[head];
916 } while (is_continuation(c, tty) && head != tty->canon_head); 916 } while (is_continuation(c, tty) && head != tty->canon_head);
917 917
918 /* do not partially erase */ 918 /* do not partially erase */
919 if (is_continuation(c, tty)) 919 if (is_continuation(c, tty))
920 break; 920 break;
921 921
922 if (kill_type == WERASE) { 922 if (kill_type == WERASE) {
923 /* Equivalent to BSD's ALTWERASE. */ 923 /* Equivalent to BSD's ALTWERASE. */
924 if (isalnum(c) || c == '_') 924 if (isalnum(c) || c == '_')
925 seen_alnums++; 925 seen_alnums++;
926 else if (seen_alnums) 926 else if (seen_alnums)
927 break; 927 break;
928 } 928 }
929 cnt = (tty->read_head - head) & (N_TTY_BUF_SIZE-1); 929 cnt = (tty->read_head - head) & (N_TTY_BUF_SIZE-1);
930 spin_lock_irqsave(&tty->read_lock, flags); 930 spin_lock_irqsave(&tty->read_lock, flags);
931 tty->read_head = head; 931 tty->read_head = head;
932 tty->read_cnt -= cnt; 932 tty->read_cnt -= cnt;
933 spin_unlock_irqrestore(&tty->read_lock, flags); 933 spin_unlock_irqrestore(&tty->read_lock, flags);
934 if (L_ECHO(tty)) { 934 if (L_ECHO(tty)) {
935 if (L_ECHOPRT(tty)) { 935 if (L_ECHOPRT(tty)) {
936 if (!tty->erasing) { 936 if (!tty->erasing) {
937 echo_char_raw('\\', tty); 937 echo_char_raw('\\', tty);
938 tty->erasing = 1; 938 tty->erasing = 1;
939 } 939 }
940 /* if cnt > 1, output a multi-byte character */ 940 /* if cnt > 1, output a multi-byte character */
941 echo_char(c, tty); 941 echo_char(c, tty);
942 while (--cnt > 0) { 942 while (--cnt > 0) {
943 head = (head+1) & (N_TTY_BUF_SIZE-1); 943 head = (head+1) & (N_TTY_BUF_SIZE-1);
944 echo_char_raw(tty->read_buf[head], tty); 944 echo_char_raw(tty->read_buf[head], tty);
945 echo_move_back_col(tty); 945 echo_move_back_col(tty);
946 } 946 }
947 } else if (kill_type == ERASE && !L_ECHOE(tty)) { 947 } else if (kill_type == ERASE && !L_ECHOE(tty)) {
948 echo_char(ERASE_CHAR(tty), tty); 948 echo_char(ERASE_CHAR(tty), tty);
949 } else if (c == '\t') { 949 } else if (c == '\t') {
950 unsigned int num_chars = 0; 950 unsigned int num_chars = 0;
951 int after_tab = 0; 951 int after_tab = 0;
952 unsigned long tail = tty->read_head; 952 unsigned long tail = tty->read_head;
953 953
954 /* 954 /*
955 * Count the columns used for characters 955 * Count the columns used for characters
956 * since the start of input or after a 956 * since the start of input or after a
957 * previous tab. 957 * previous tab.
958 * This info is used to go back the correct 958 * This info is used to go back the correct
959 * number of columns. 959 * number of columns.
960 */ 960 */
961 while (tail != tty->canon_head) { 961 while (tail != tty->canon_head) {
962 tail = (tail-1) & (N_TTY_BUF_SIZE-1); 962 tail = (tail-1) & (N_TTY_BUF_SIZE-1);
963 c = tty->read_buf[tail]; 963 c = tty->read_buf[tail];
964 if (c == '\t') { 964 if (c == '\t') {
965 after_tab = 1; 965 after_tab = 1;
966 break; 966 break;
967 } else if (iscntrl(c)) { 967 } else if (iscntrl(c)) {
968 if (L_ECHOCTL(tty)) 968 if (L_ECHOCTL(tty))
969 num_chars += 2; 969 num_chars += 2;
970 } else if (!is_continuation(c, tty)) { 970 } else if (!is_continuation(c, tty)) {
971 num_chars++; 971 num_chars++;
972 } 972 }
973 } 973 }
974 echo_erase_tab(num_chars, after_tab, tty); 974 echo_erase_tab(num_chars, after_tab, tty);
975 } else { 975 } else {
976 if (iscntrl(c) && L_ECHOCTL(tty)) { 976 if (iscntrl(c) && L_ECHOCTL(tty)) {
977 echo_char_raw('\b', tty); 977 echo_char_raw('\b', tty);
978 echo_char_raw(' ', tty); 978 echo_char_raw(' ', tty);
979 echo_char_raw('\b', tty); 979 echo_char_raw('\b', tty);
980 } 980 }
981 if (!iscntrl(c) || L_ECHOCTL(tty)) { 981 if (!iscntrl(c) || L_ECHOCTL(tty)) {
982 echo_char_raw('\b', tty); 982 echo_char_raw('\b', tty);
983 echo_char_raw(' ', tty); 983 echo_char_raw(' ', tty);
984 echo_char_raw('\b', tty); 984 echo_char_raw('\b', tty);
985 } 985 }
986 } 986 }
987 } 987 }
988 if (kill_type == ERASE) 988 if (kill_type == ERASE)
989 break; 989 break;
990 } 990 }
991 if (tty->read_head == tty->canon_head && L_ECHO(tty)) 991 if (tty->read_head == tty->canon_head && L_ECHO(tty))
992 finish_erasing(tty); 992 finish_erasing(tty);
993 } 993 }
994 994
995 /** 995 /**
996 * isig - handle the ISIG optio 996 * isig - handle the ISIG optio
997 * @sig: signal 997 * @sig: signal
998 * @tty: terminal 998 * @tty: terminal
999 * @flush: force flush 999 * @flush: force flush
1000 * 1000 *
1001 * Called when a signal is being sent due to terminal input. This 1001 * Called when a signal is being sent due to terminal input. This
1002 * may caus terminal flushing to take place according to the termios 1002 * may caus terminal flushing to take place according to the termios
1003 * settings and character used. Called from the driver receive_buf 1003 * settings and character used. Called from the driver receive_buf
1004 * path so serialized. 1004 * path so serialized.
1005 * 1005 *
1006 * Locking: ctrl_lock, read_lock (both via flush buffer) 1006 * Locking: ctrl_lock, read_lock (both via flush buffer)
1007 */ 1007 */
1008 1008
1009 static inline void isig(int sig, struct tty_struct *tty, int flush) 1009 static inline void isig(int sig, struct tty_struct *tty, int flush)
1010 { 1010 {
1011 if (tty->pgrp) 1011 if (tty->pgrp)
1012 kill_pgrp(tty->pgrp, sig, 1); 1012 kill_pgrp(tty->pgrp, sig, 1);
1013 if (flush || !L_NOFLSH(tty)) { 1013 if (flush || !L_NOFLSH(tty)) {
1014 n_tty_flush_buffer(tty); 1014 n_tty_flush_buffer(tty);
1015 tty_driver_flush_buffer(tty); 1015 tty_driver_flush_buffer(tty);
1016 } 1016 }
1017 } 1017 }
1018 1018
1019 /** 1019 /**
1020 * n_tty_receive_break - handle break 1020 * n_tty_receive_break - handle break
1021 * @tty: terminal 1021 * @tty: terminal
1022 * 1022 *
1023 * An RS232 break event has been hit in the incoming bitstream. This 1023 * An RS232 break event has been hit in the incoming bitstream. This
1024 * can cause a variety of events depending upon the termios settings. 1024 * can cause a variety of events depending upon the termios settings.
1025 * 1025 *
1026 * Called from the receive_buf path so single threaded. 1026 * Called from the receive_buf path so single threaded.
1027 */ 1027 */
1028 1028
1029 static inline void n_tty_receive_break(struct tty_struct *tty) 1029 static inline void n_tty_receive_break(struct tty_struct *tty)
1030 { 1030 {
1031 if (I_IGNBRK(tty)) 1031 if (I_IGNBRK(tty))
1032 return; 1032 return;
1033 if (I_BRKINT(tty)) { 1033 if (I_BRKINT(tty)) {
1034 isig(SIGINT, tty, 1); 1034 isig(SIGINT, tty, 1);
1035 return; 1035 return;
1036 } 1036 }
1037 if (I_PARMRK(tty)) { 1037 if (I_PARMRK(tty)) {
1038 put_tty_queue('\377', tty); 1038 put_tty_queue('\377', tty);
1039 put_tty_queue('\0', tty); 1039 put_tty_queue('\0', tty);
1040 } 1040 }
1041 put_tty_queue('\0', tty); 1041 put_tty_queue('\0', tty);
1042 wake_up_interruptible(&tty->read_wait); 1042 wake_up_interruptible(&tty->read_wait);
1043 } 1043 }
1044 1044
1045 /** 1045 /**
1046 * n_tty_receive_overrun - handle overrun reporting 1046 * n_tty_receive_overrun - handle overrun reporting
1047 * @tty: terminal 1047 * @tty: terminal
1048 * 1048 *
1049 * Data arrived faster than we could process it. While the tty 1049 * Data arrived faster than we could process it. While the tty
1050 * driver has flagged this the bits that were missed are gone 1050 * driver has flagged this the bits that were missed are gone
1051 * forever. 1051 * forever.
1052 * 1052 *
1053 * Called from the receive_buf path so single threaded. Does not 1053 * Called from the receive_buf path so single threaded. Does not
1054 * need locking as num_overrun and overrun_time are function 1054 * need locking as num_overrun and overrun_time are function
1055 * private. 1055 * private.
1056 */ 1056 */
1057 1057
1058 static inline void n_tty_receive_overrun(struct tty_struct *tty) 1058 static inline void n_tty_receive_overrun(struct tty_struct *tty)
1059 { 1059 {
1060 char buf[64]; 1060 char buf[64];
1061 1061
1062 tty->num_overrun++; 1062 tty->num_overrun++;
1063 if (time_before(tty->overrun_time, jiffies - HZ) || 1063 if (time_before(tty->overrun_time, jiffies - HZ) ||
1064 time_after(tty->overrun_time, jiffies)) { 1064 time_after(tty->overrun_time, jiffies)) {
1065 printk(KERN_WARNING "%s: %d input overrun(s)\n", 1065 printk(KERN_WARNING "%s: %d input overrun(s)\n",
1066 tty_name(tty, buf), 1066 tty_name(tty, buf),
1067 tty->num_overrun); 1067 tty->num_overrun);
1068 tty->overrun_time = jiffies; 1068 tty->overrun_time = jiffies;
1069 tty->num_overrun = 0; 1069 tty->num_overrun = 0;
1070 } 1070 }
1071 } 1071 }
1072 1072
1073 /** 1073 /**
1074 * n_tty_receive_parity_error - error notifier 1074 * n_tty_receive_parity_error - error notifier
1075 * @tty: terminal device 1075 * @tty: terminal device
1076 * @c: character 1076 * @c: character
1077 * 1077 *
1078 * Process a parity error and queue the right data to indicate 1078 * Process a parity error and queue the right data to indicate
1079 * the error case if necessary. Locking as per n_tty_receive_buf. 1079 * the error case if necessary. Locking as per n_tty_receive_buf.
1080 */ 1080 */
1081 static inline void n_tty_receive_parity_error(struct tty_struct *tty, 1081 static inline void n_tty_receive_parity_error(struct tty_struct *tty,
1082 unsigned char c) 1082 unsigned char c)
1083 { 1083 {
1084 if (I_IGNPAR(tty)) 1084 if (I_IGNPAR(tty))
1085 return; 1085 return;
1086 if (I_PARMRK(tty)) { 1086 if (I_PARMRK(tty)) {
1087 put_tty_queue('\377', tty); 1087 put_tty_queue('\377', tty);
1088 put_tty_queue('\0', tty); 1088 put_tty_queue('\0', tty);
1089 put_tty_queue(c, tty); 1089 put_tty_queue(c, tty);
1090 } else if (I_INPCK(tty)) 1090 } else if (I_INPCK(tty))
1091 put_tty_queue('\0', tty); 1091 put_tty_queue('\0', tty);
1092 else 1092 else
1093 put_tty_queue(c, tty); 1093 put_tty_queue(c, tty);
1094 wake_up_interruptible(&tty->read_wait); 1094 wake_up_interruptible(&tty->read_wait);
1095 } 1095 }
1096 1096
1097 /** 1097 /**
1098 * n_tty_receive_char - perform processing 1098 * n_tty_receive_char - perform processing
1099 * @tty: terminal device 1099 * @tty: terminal device
1100 * @c: character 1100 * @c: character
1101 * 1101 *
1102 * Process an individual character of input received from the driver. 1102 * Process an individual character of input received from the driver.
1103 * This is serialized with respect to itself by the rules for the 1103 * This is serialized with respect to itself by the rules for the
1104 * driver above. 1104 * driver above.
1105 */ 1105 */
1106 1106
1107 static inline void n_tty_receive_char(struct tty_struct *tty, unsigned char c) 1107 static inline void n_tty_receive_char(struct tty_struct *tty, unsigned char c)
1108 { 1108 {
1109 unsigned long flags; 1109 unsigned long flags;
1110 int parmrk; 1110 int parmrk;
1111 1111
1112 if (tty->raw) { 1112 if (tty->raw) {
1113 put_tty_queue(c, tty); 1113 put_tty_queue(c, tty);
1114 return; 1114 return;
1115 } 1115 }
1116 1116
1117 if (I_ISTRIP(tty)) 1117 if (I_ISTRIP(tty))
1118 c &= 0x7f; 1118 c &= 0x7f;
1119 if (I_IUCLC(tty) && L_IEXTEN(tty)) 1119 if (I_IUCLC(tty) && L_IEXTEN(tty))
1120 c = tolower(c); 1120 c = tolower(c);
1121 1121
1122 if (tty->stopped && !tty->flow_stopped && I_IXON(tty) && 1122 if (tty->stopped && !tty->flow_stopped && I_IXON(tty) &&
1123 I_IXANY(tty) && c != START_CHAR(tty) && c != STOP_CHAR(tty) && 1123 I_IXANY(tty) && c != START_CHAR(tty) && c != STOP_CHAR(tty) &&
1124 c != INTR_CHAR(tty) && c != QUIT_CHAR(tty) && c != SUSP_CHAR(tty)) { 1124 c != INTR_CHAR(tty) && c != QUIT_CHAR(tty) && c != SUSP_CHAR(tty)) {
1125 start_tty(tty); 1125 start_tty(tty);
1126 process_echoes(tty); 1126 process_echoes(tty);
1127 } 1127 }
1128 1128
1129 if (tty->closing) { 1129 if (tty->closing) {
1130 if (I_IXON(tty)) { 1130 if (I_IXON(tty)) {
1131 if (c == START_CHAR(tty)) { 1131 if (c == START_CHAR(tty)) {
1132 start_tty(tty); 1132 start_tty(tty);
1133 process_echoes(tty); 1133 process_echoes(tty);
1134 } else if (c == STOP_CHAR(tty)) 1134 } else if (c == STOP_CHAR(tty))
1135 stop_tty(tty); 1135 stop_tty(tty);
1136 } 1136 }
1137 return; 1137 return;
1138 } 1138 }
1139 1139
1140 /* 1140 /*
1141 * If the previous character was LNEXT, or we know that this 1141 * If the previous character was LNEXT, or we know that this
1142 * character is not one of the characters that we'll have to 1142 * character is not one of the characters that we'll have to
1143 * handle specially, do shortcut processing to speed things 1143 * handle specially, do shortcut processing to speed things
1144 * up. 1144 * up.
1145 */ 1145 */
1146 if (!test_bit(c, tty->process_char_map) || tty->lnext) { 1146 if (!test_bit(c, tty->process_char_map) || tty->lnext) {
1147 tty->lnext = 0; 1147 tty->lnext = 0;
1148 parmrk = (c == (unsigned char) '\377' && I_PARMRK(tty)) ? 1 : 0; 1148 parmrk = (c == (unsigned char) '\377' && I_PARMRK(tty)) ? 1 : 0;
1149 if (tty->read_cnt >= (N_TTY_BUF_SIZE - parmrk - 1)) { 1149 if (tty->read_cnt >= (N_TTY_BUF_SIZE - parmrk - 1)) {
1150 /* beep if no space */ 1150 /* beep if no space */
1151 if (L_ECHO(tty)) 1151 if (L_ECHO(tty))
1152 process_output('\a', tty); 1152 process_output('\a', tty);
1153 return; 1153 return;
1154 } 1154 }
1155 if (L_ECHO(tty)) { 1155 if (L_ECHO(tty)) {
1156 finish_erasing(tty); 1156 finish_erasing(tty);
1157 /* Record the column of first canon char. */ 1157 /* Record the column of first canon char. */
1158 if (tty->canon_head == tty->read_head) 1158 if (tty->canon_head == tty->read_head)
1159 echo_set_canon_col(tty); 1159 echo_set_canon_col(tty);
1160 echo_char(c, tty); 1160 echo_char(c, tty);
1161 process_echoes(tty); 1161 process_echoes(tty);
1162 } 1162 }
1163 if (parmrk) 1163 if (parmrk)
1164 put_tty_queue(c, tty); 1164 put_tty_queue(c, tty);
1165 put_tty_queue(c, tty); 1165 put_tty_queue(c, tty);
1166 return; 1166 return;
1167 } 1167 }
1168 1168
1169 if (I_IXON(tty)) { 1169 if (I_IXON(tty)) {
1170 if (c == START_CHAR(tty)) { 1170 if (c == START_CHAR(tty)) {
1171 start_tty(tty); 1171 start_tty(tty);
1172 process_echoes(tty); 1172 process_echoes(tty);
1173 return; 1173 return;
1174 } 1174 }
1175 if (c == STOP_CHAR(tty)) { 1175 if (c == STOP_CHAR(tty)) {
1176 stop_tty(tty); 1176 stop_tty(tty);
1177 return; 1177 return;
1178 } 1178 }
1179 } 1179 }
1180 1180
1181 if (L_ISIG(tty)) { 1181 if (L_ISIG(tty)) {
1182 int signal; 1182 int signal;
1183 signal = SIGINT; 1183 signal = SIGINT;
1184 if (c == INTR_CHAR(tty)) 1184 if (c == INTR_CHAR(tty))
1185 goto send_signal; 1185 goto send_signal;
1186 signal = SIGQUIT; 1186 signal = SIGQUIT;
1187 if (c == QUIT_CHAR(tty)) 1187 if (c == QUIT_CHAR(tty))
1188 goto send_signal; 1188 goto send_signal;
1189 signal = SIGTSTP; 1189 signal = SIGTSTP;
1190 if (c == SUSP_CHAR(tty)) { 1190 if (c == SUSP_CHAR(tty)) {
1191 send_signal: 1191 send_signal:
1192 /* 1192 /*
1193 * Note that we do not use isig() here because we want 1193 * Note that we do not use isig() here because we want
1194 * the order to be: 1194 * the order to be:
1195 * 1) flush, 2) echo, 3) signal 1195 * 1) flush, 2) echo, 3) signal
1196 */ 1196 */
1197 if (!L_NOFLSH(tty)) { 1197 if (!L_NOFLSH(tty)) {
1198 n_tty_flush_buffer(tty); 1198 n_tty_flush_buffer(tty);
1199 tty_driver_flush_buffer(tty); 1199 tty_driver_flush_buffer(tty);
1200 } 1200 }
1201 if (I_IXON(tty)) 1201 if (I_IXON(tty))
1202 start_tty(tty); 1202 start_tty(tty);
1203 if (L_ECHO(tty)) { 1203 if (L_ECHO(tty)) {
1204 echo_char(c, tty); 1204 echo_char(c, tty);
1205 process_echoes(tty); 1205 process_echoes(tty);
1206 } 1206 }
1207 if (tty->pgrp) 1207 if (tty->pgrp)
1208 kill_pgrp(tty->pgrp, signal, 1); 1208 kill_pgrp(tty->pgrp, signal, 1);
1209 return; 1209 return;
1210 } 1210 }
1211 } 1211 }
1212 1212
1213 if (c == '\r') { 1213 if (c == '\r') {
1214 if (I_IGNCR(tty)) 1214 if (I_IGNCR(tty))
1215 return; 1215 return;
1216 if (I_ICRNL(tty)) 1216 if (I_ICRNL(tty))
1217 c = '\n'; 1217 c = '\n';
1218 } else if (c == '\n' && I_INLCR(tty)) 1218 } else if (c == '\n' && I_INLCR(tty))
1219 c = '\r'; 1219 c = '\r';
1220 1220
1221 if (tty->icanon) { 1221 if (tty->icanon) {
1222 if (c == ERASE_CHAR(tty) || c == KILL_CHAR(tty) || 1222 if (c == ERASE_CHAR(tty) || c == KILL_CHAR(tty) ||
1223 (c == WERASE_CHAR(tty) && L_IEXTEN(tty))) { 1223 (c == WERASE_CHAR(tty) && L_IEXTEN(tty))) {
1224 eraser(c, tty); 1224 eraser(c, tty);
1225 process_echoes(tty); 1225 process_echoes(tty);
1226 return; 1226 return;
1227 } 1227 }
1228 if (c == LNEXT_CHAR(tty) && L_IEXTEN(tty)) { 1228 if (c == LNEXT_CHAR(tty) && L_IEXTEN(tty)) {
1229 tty->lnext = 1; 1229 tty->lnext = 1;
1230 if (L_ECHO(tty)) { 1230 if (L_ECHO(tty)) {
1231 finish_erasing(tty); 1231 finish_erasing(tty);
1232 if (L_ECHOCTL(tty)) { 1232 if (L_ECHOCTL(tty)) {
1233 echo_char_raw('^', tty); 1233 echo_char_raw('^', tty);
1234 echo_char_raw('\b', tty); 1234 echo_char_raw('\b', tty);
1235 process_echoes(tty); 1235 process_echoes(tty);
1236 } 1236 }
1237 } 1237 }
1238 return; 1238 return;
1239 } 1239 }
1240 if (c == REPRINT_CHAR(tty) && L_ECHO(tty) && 1240 if (c == REPRINT_CHAR(tty) && L_ECHO(tty) &&
1241 L_IEXTEN(tty)) { 1241 L_IEXTEN(tty)) {
1242 unsigned long tail = tty->canon_head; 1242 unsigned long tail = tty->canon_head;
1243 1243
1244 finish_erasing(tty); 1244 finish_erasing(tty);
1245 echo_char(c, tty); 1245 echo_char(c, tty);
1246 echo_char_raw('\n', tty); 1246 echo_char_raw('\n', tty);
1247 while (tail != tty->read_head) { 1247 while (tail != tty->read_head) {
1248 echo_char(tty->read_buf[tail], tty); 1248 echo_char(tty->read_buf[tail], tty);
1249 tail = (tail+1) & (N_TTY_BUF_SIZE-1); 1249 tail = (tail+1) & (N_TTY_BUF_SIZE-1);
1250 } 1250 }
1251 process_echoes(tty); 1251 process_echoes(tty);
1252 return; 1252 return;
1253 } 1253 }
1254 if (c == '\n') { 1254 if (c == '\n') {
1255 if (tty->read_cnt >= N_TTY_BUF_SIZE) { 1255 if (tty->read_cnt >= N_TTY_BUF_SIZE) {
1256 if (L_ECHO(tty)) 1256 if (L_ECHO(tty))
1257 process_output('\a', tty); 1257 process_output('\a', tty);
1258 return; 1258 return;
1259 } 1259 }
1260 if (L_ECHO(tty) || L_ECHONL(tty)) { 1260 if (L_ECHO(tty) || L_ECHONL(tty)) {
1261 echo_char_raw('\n', tty); 1261 echo_char_raw('\n', tty);
1262 process_echoes(tty); 1262 process_echoes(tty);
1263 } 1263 }
1264 goto handle_newline; 1264 goto handle_newline;
1265 } 1265 }
1266 if (c == EOF_CHAR(tty)) { 1266 if (c == EOF_CHAR(tty)) {
1267 if (tty->read_cnt >= N_TTY_BUF_SIZE) 1267 if (tty->read_cnt >= N_TTY_BUF_SIZE)
1268 return; 1268 return;
1269 if (tty->canon_head != tty->read_head) 1269 if (tty->canon_head != tty->read_head)
1270 set_bit(TTY_PUSH, &tty->flags); 1270 set_bit(TTY_PUSH, &tty->flags);
1271 c = __DISABLED_CHAR; 1271 c = __DISABLED_CHAR;
1272 goto handle_newline; 1272 goto handle_newline;
1273 } 1273 }
1274 if ((c == EOL_CHAR(tty)) || 1274 if ((c == EOL_CHAR(tty)) ||
1275 (c == EOL2_CHAR(tty) && L_IEXTEN(tty))) { 1275 (c == EOL2_CHAR(tty) && L_IEXTEN(tty))) {
1276 parmrk = (c == (unsigned char) '\377' && I_PARMRK(tty)) 1276 parmrk = (c == (unsigned char) '\377' && I_PARMRK(tty))
1277 ? 1 : 0; 1277 ? 1 : 0;
1278 if (tty->read_cnt >= (N_TTY_BUF_SIZE - parmrk)) { 1278 if (tty->read_cnt >= (N_TTY_BUF_SIZE - parmrk)) {
1279 if (L_ECHO(tty)) 1279 if (L_ECHO(tty))
1280 process_output('\a', tty); 1280 process_output('\a', tty);
1281 return; 1281 return;
1282 } 1282 }
1283 /* 1283 /*
1284 * XXX are EOL_CHAR and EOL2_CHAR echoed?!? 1284 * XXX are EOL_CHAR and EOL2_CHAR echoed?!?
1285 */ 1285 */
1286 if (L_ECHO(tty)) { 1286 if (L_ECHO(tty)) {
1287 /* Record the column of first canon char. */ 1287 /* Record the column of first canon char. */
1288 if (tty->canon_head == tty->read_head) 1288 if (tty->canon_head == tty->read_head)
1289 echo_set_canon_col(tty); 1289 echo_set_canon_col(tty);
1290 echo_char(c, tty); 1290 echo_char(c, tty);
1291 process_echoes(tty); 1291 process_echoes(tty);
1292 } 1292 }
1293 /* 1293 /*
1294 * XXX does PARMRK doubling happen for 1294 * XXX does PARMRK doubling happen for
1295 * EOL_CHAR and EOL2_CHAR? 1295 * EOL_CHAR and EOL2_CHAR?
1296 */ 1296 */
1297 if (parmrk) 1297 if (parmrk)
1298 put_tty_queue(c, tty); 1298 put_tty_queue(c, tty);
1299 1299
1300 handle_newline: 1300 handle_newline:
1301 spin_lock_irqsave(&tty->read_lock, flags); 1301 spin_lock_irqsave(&tty->read_lock, flags);
1302 set_bit(tty->read_head, tty->read_flags); 1302 set_bit(tty->read_head, tty->read_flags);
1303 put_tty_queue_nolock(c, tty); 1303 put_tty_queue_nolock(c, tty);
1304 tty->canon_head = tty->read_head; 1304 tty->canon_head = tty->read_head;
1305 tty->canon_data++; 1305 tty->canon_data++;
1306 spin_unlock_irqrestore(&tty->read_lock, flags); 1306 spin_unlock_irqrestore(&tty->read_lock, flags);
1307 kill_fasync(&tty->fasync, SIGIO, POLL_IN); 1307 kill_fasync(&tty->fasync, SIGIO, POLL_IN);
1308 if (waitqueue_active(&tty->read_wait)) 1308 if (waitqueue_active(&tty->read_wait))
1309 wake_up_interruptible(&tty->read_wait); 1309 wake_up_interruptible(&tty->read_wait);
1310 return; 1310 return;
1311 } 1311 }
1312 } 1312 }
1313 1313
1314 parmrk = (c == (unsigned char) '\377' && I_PARMRK(tty)) ? 1 : 0; 1314 parmrk = (c == (unsigned char) '\377' && I_PARMRK(tty)) ? 1 : 0;
1315 if (tty->read_cnt >= (N_TTY_BUF_SIZE - parmrk - 1)) { 1315 if (tty->read_cnt >= (N_TTY_BUF_SIZE - parmrk - 1)) {
1316 /* beep if no space */ 1316 /* beep if no space */
1317 if (L_ECHO(tty)) 1317 if (L_ECHO(tty))
1318 process_output('\a', tty); 1318 process_output('\a', tty);
1319 return; 1319 return;
1320 } 1320 }
1321 if (L_ECHO(tty)) { 1321 if (L_ECHO(tty)) {
1322 finish_erasing(tty); 1322 finish_erasing(tty);
1323 if (c == '\n') 1323 if (c == '\n')
1324 echo_char_raw('\n', tty); 1324 echo_char_raw('\n', tty);
1325 else { 1325 else {
1326 /* Record the column of first canon char. */ 1326 /* Record the column of first canon char. */
1327 if (tty->canon_head == tty->read_head) 1327 if (tty->canon_head == tty->read_head)
1328 echo_set_canon_col(tty); 1328 echo_set_canon_col(tty);
1329 echo_char(c, tty); 1329 echo_char(c, tty);
1330 } 1330 }
1331 process_echoes(tty); 1331 process_echoes(tty);
1332 } 1332 }
1333 1333
1334 if (parmrk) 1334 if (parmrk)
1335 put_tty_queue(c, tty); 1335 put_tty_queue(c, tty);
1336 1336
1337 put_tty_queue(c, tty); 1337 put_tty_queue(c, tty);
1338 } 1338 }
1339 1339
1340 1340
1341 /** 1341 /**
1342 * n_tty_write_wakeup - asynchronous I/O notifier 1342 * n_tty_write_wakeup - asynchronous I/O notifier
1343 * @tty: tty device 1343 * @tty: tty device
1344 * 1344 *
1345 * Required for the ptys, serial driver etc. since processes 1345 * Required for the ptys, serial driver etc. since processes
1346 * that attach themselves to the master and rely on ASYNC 1346 * that attach themselves to the master and rely on ASYNC
1347 * IO must be woken up 1347 * IO must be woken up
1348 */ 1348 */
1349 1349
1350 static void n_tty_write_wakeup(struct tty_struct *tty) 1350 static void n_tty_write_wakeup(struct tty_struct *tty)
1351 { 1351 {
1352 /* Write out any echoed characters that are still pending */ 1352 /* Write out any echoed characters that are still pending */
1353 process_echoes(tty); 1353 process_echoes(tty);
1354 1354
1355 if (tty->fasync) { 1355 if (tty->fasync && test_and_clear_bit(TTY_DO_WRITE_WAKEUP, &tty->flags))
1356 set_bit(TTY_DO_WRITE_WAKEUP, &tty->flags);
1357 kill_fasync(&tty->fasync, SIGIO, POLL_OUT); 1356 kill_fasync(&tty->fasync, SIGIO, POLL_OUT);
1358 }
1359 } 1357 }
1360 1358
1361 /** 1359 /**
1362 * n_tty_receive_buf - data receive 1360 * n_tty_receive_buf - data receive
1363 * @tty: terminal device 1361 * @tty: terminal device
1364 * @cp: buffer 1362 * @cp: buffer
1365 * @fp: flag buffer 1363 * @fp: flag buffer
1366 * @count: characters 1364 * @count: characters
1367 * 1365 *
1368 * Called by the terminal driver when a block of characters has 1366 * Called by the terminal driver when a block of characters has
1369 * been received. This function must be called from soft contexts 1367 * been received. This function must be called from soft contexts
1370 * not from interrupt context. The driver is responsible for making 1368 * not from interrupt context. The driver is responsible for making
1371 * calls one at a time and in order (or using flush_to_ldisc) 1369 * calls one at a time and in order (or using flush_to_ldisc)
1372 */ 1370 */
1373 1371
1374 static void n_tty_receive_buf(struct tty_struct *tty, const unsigned char *cp, 1372 static void n_tty_receive_buf(struct tty_struct *tty, const unsigned char *cp,
1375 char *fp, int count) 1373 char *fp, int count)
1376 { 1374 {
1377 const unsigned char *p; 1375 const unsigned char *p;
1378 char *f, flags = TTY_NORMAL; 1376 char *f, flags = TTY_NORMAL;
1379 int i; 1377 int i;
1380 char buf[64]; 1378 char buf[64];
1381 unsigned long cpuflags; 1379 unsigned long cpuflags;
1382 1380
1383 if (!tty->read_buf) 1381 if (!tty->read_buf)
1384 return; 1382 return;
1385 1383
1386 if (tty->real_raw) { 1384 if (tty->real_raw) {
1387 spin_lock_irqsave(&tty->read_lock, cpuflags); 1385 spin_lock_irqsave(&tty->read_lock, cpuflags);
1388 i = min(N_TTY_BUF_SIZE - tty->read_cnt, 1386 i = min(N_TTY_BUF_SIZE - tty->read_cnt,
1389 N_TTY_BUF_SIZE - tty->read_head); 1387 N_TTY_BUF_SIZE - tty->read_head);
1390 i = min(count, i); 1388 i = min(count, i);
1391 memcpy(tty->read_buf + tty->read_head, cp, i); 1389 memcpy(tty->read_buf + tty->read_head, cp, i);
1392 tty->read_head = (tty->read_head + i) & (N_TTY_BUF_SIZE-1); 1390 tty->read_head = (tty->read_head + i) & (N_TTY_BUF_SIZE-1);
1393 tty->read_cnt += i; 1391 tty->read_cnt += i;
1394 cp += i; 1392 cp += i;
1395 count -= i; 1393 count -= i;
1396 1394
1397 i = min(N_TTY_BUF_SIZE - tty->read_cnt, 1395 i = min(N_TTY_BUF_SIZE - tty->read_cnt,
1398 N_TTY_BUF_SIZE - tty->read_head); 1396 N_TTY_BUF_SIZE - tty->read_head);
1399 i = min(count, i); 1397 i = min(count, i);
1400 memcpy(tty->read_buf + tty->read_head, cp, i); 1398 memcpy(tty->read_buf + tty->read_head, cp, i);
1401 tty->read_head = (tty->read_head + i) & (N_TTY_BUF_SIZE-1); 1399 tty->read_head = (tty->read_head + i) & (N_TTY_BUF_SIZE-1);
1402 tty->read_cnt += i; 1400 tty->read_cnt += i;
1403 spin_unlock_irqrestore(&tty->read_lock, cpuflags); 1401 spin_unlock_irqrestore(&tty->read_lock, cpuflags);
1404 } else { 1402 } else {
1405 for (i = count, p = cp, f = fp; i; i--, p++) { 1403 for (i = count, p = cp, f = fp; i; i--, p++) {
1406 if (f) 1404 if (f)
1407 flags = *f++; 1405 flags = *f++;
1408 switch (flags) { 1406 switch (flags) {
1409 case TTY_NORMAL: 1407 case TTY_NORMAL:
1410 n_tty_receive_char(tty, *p); 1408 n_tty_receive_char(tty, *p);
1411 break; 1409 break;
1412 case TTY_BREAK: 1410 case TTY_BREAK:
1413 n_tty_receive_break(tty); 1411 n_tty_receive_break(tty);
1414 break; 1412 break;
1415 case TTY_PARITY: 1413 case TTY_PARITY:
1416 case TTY_FRAME: 1414 case TTY_FRAME:
1417 n_tty_receive_parity_error(tty, *p); 1415 n_tty_receive_parity_error(tty, *p);
1418 break; 1416 break;
1419 case TTY_OVERRUN: 1417 case TTY_OVERRUN:
1420 n_tty_receive_overrun(tty); 1418 n_tty_receive_overrun(tty);
1421 break; 1419 break;
1422 default: 1420 default:
1423 printk(KERN_ERR "%s: unknown flag %d\n", 1421 printk(KERN_ERR "%s: unknown flag %d\n",
1424 tty_name(tty, buf), flags); 1422 tty_name(tty, buf), flags);
1425 break; 1423 break;
1426 } 1424 }
1427 } 1425 }
1428 if (tty->ops->flush_chars) 1426 if (tty->ops->flush_chars)
1429 tty->ops->flush_chars(tty); 1427 tty->ops->flush_chars(tty);
1430 } 1428 }
1431 1429
1432 n_tty_set_room(tty); 1430 n_tty_set_room(tty);
1433 1431
1434 if (!tty->icanon && (tty->read_cnt >= tty->minimum_to_wake)) { 1432 if (!tty->icanon && (tty->read_cnt >= tty->minimum_to_wake)) {
1435 kill_fasync(&tty->fasync, SIGIO, POLL_IN); 1433 kill_fasync(&tty->fasync, SIGIO, POLL_IN);
1436 if (waitqueue_active(&tty->read_wait)) 1434 if (waitqueue_active(&tty->read_wait))
1437 wake_up_interruptible(&tty->read_wait); 1435 wake_up_interruptible(&tty->read_wait);
1438 } 1436 }
1439 1437
1440 /* 1438 /*
1441 * Check the remaining room for the input canonicalization 1439 * Check the remaining room for the input canonicalization
1442 * mode. We don't want to throttle the driver if we're in 1440 * mode. We don't want to throttle the driver if we're in
1443 * canonical mode and don't have a newline yet! 1441 * canonical mode and don't have a newline yet!
1444 */ 1442 */
1445 if (tty->receive_room < TTY_THRESHOLD_THROTTLE) 1443 if (tty->receive_room < TTY_THRESHOLD_THROTTLE)
1446 tty_throttle(tty); 1444 tty_throttle(tty);
1447 } 1445 }
1448 1446
1449 int is_ignored(int sig) 1447 int is_ignored(int sig)
1450 { 1448 {
1451 return (sigismember(&current->blocked, sig) || 1449 return (sigismember(&current->blocked, sig) ||
1452 current->sighand->action[sig-1].sa.sa_handler == SIG_IGN); 1450 current->sighand->action[sig-1].sa.sa_handler == SIG_IGN);
1453 } 1451 }
1454 1452
1455 /** 1453 /**
1456 * n_tty_set_termios - termios data changed 1454 * n_tty_set_termios - termios data changed
1457 * @tty: terminal 1455 * @tty: terminal
1458 * @old: previous data 1456 * @old: previous data
1459 * 1457 *
1460 * Called by the tty layer when the user changes termios flags so 1458 * Called by the tty layer when the user changes termios flags so
1461 * that the line discipline can plan ahead. This function cannot sleep 1459 * that the line discipline can plan ahead. This function cannot sleep
1462 * and is protected from re-entry by the tty layer. The user is 1460 * and is protected from re-entry by the tty layer. The user is
1463 * guaranteed that this function will not be re-entered or in progress 1461 * guaranteed that this function will not be re-entered or in progress
1464 * when the ldisc is closed. 1462 * when the ldisc is closed.
1465 * 1463 *
1466 * Locking: Caller holds tty->termios_mutex 1464 * Locking: Caller holds tty->termios_mutex
1467 */ 1465 */
1468 1466
1469 static void n_tty_set_termios(struct tty_struct *tty, struct ktermios *old) 1467 static void n_tty_set_termios(struct tty_struct *tty, struct ktermios *old)
1470 { 1468 {
1471 int canon_change = 1; 1469 int canon_change = 1;
1472 BUG_ON(!tty); 1470 BUG_ON(!tty);
1473 1471
1474 if (old) 1472 if (old)
1475 canon_change = (old->c_lflag ^ tty->termios->c_lflag) & ICANON; 1473 canon_change = (old->c_lflag ^ tty->termios->c_lflag) & ICANON;
1476 if (canon_change) { 1474 if (canon_change) {
1477 memset(&tty->read_flags, 0, sizeof tty->read_flags); 1475 memset(&tty->read_flags, 0, sizeof tty->read_flags);
1478 tty->canon_head = tty->read_tail; 1476 tty->canon_head = tty->read_tail;
1479 tty->canon_data = 0; 1477 tty->canon_data = 0;
1480 tty->erasing = 0; 1478 tty->erasing = 0;
1481 } 1479 }
1482 1480
1483 if (canon_change && !L_ICANON(tty) && tty->read_cnt) 1481 if (canon_change && !L_ICANON(tty) && tty->read_cnt)
1484 wake_up_interruptible(&tty->read_wait); 1482 wake_up_interruptible(&tty->read_wait);
1485 1483
1486 tty->icanon = (L_ICANON(tty) != 0); 1484 tty->icanon = (L_ICANON(tty) != 0);
1487 if (test_bit(TTY_HW_COOK_IN, &tty->flags)) { 1485 if (test_bit(TTY_HW_COOK_IN, &tty->flags)) {
1488 tty->raw = 1; 1486 tty->raw = 1;
1489 tty->real_raw = 1; 1487 tty->real_raw = 1;
1490 n_tty_set_room(tty); 1488 n_tty_set_room(tty);
1491 return; 1489 return;
1492 } 1490 }
1493 if (I_ISTRIP(tty) || I_IUCLC(tty) || I_IGNCR(tty) || 1491 if (I_ISTRIP(tty) || I_IUCLC(tty) || I_IGNCR(tty) ||
1494 I_ICRNL(tty) || I_INLCR(tty) || L_ICANON(tty) || 1492 I_ICRNL(tty) || I_INLCR(tty) || L_ICANON(tty) ||
1495 I_IXON(tty) || L_ISIG(tty) || L_ECHO(tty) || 1493 I_IXON(tty) || L_ISIG(tty) || L_ECHO(tty) ||
1496 I_PARMRK(tty)) { 1494 I_PARMRK(tty)) {
1497 memset(tty->process_char_map, 0, 256/8); 1495 memset(tty->process_char_map, 0, 256/8);
1498 1496
1499 if (I_IGNCR(tty) || I_ICRNL(tty)) 1497 if (I_IGNCR(tty) || I_ICRNL(tty))
1500 set_bit('\r', tty->process_char_map); 1498 set_bit('\r', tty->process_char_map);
1501 if (I_INLCR(tty)) 1499 if (I_INLCR(tty))
1502 set_bit('\n', tty->process_char_map); 1500 set_bit('\n', tty->process_char_map);
1503 1501
1504 if (L_ICANON(tty)) { 1502 if (L_ICANON(tty)) {
1505 set_bit(ERASE_CHAR(tty), tty->process_char_map); 1503 set_bit(ERASE_CHAR(tty), tty->process_char_map);
1506 set_bit(KILL_CHAR(tty), tty->process_char_map); 1504 set_bit(KILL_CHAR(tty), tty->process_char_map);
1507 set_bit(EOF_CHAR(tty), tty->process_char_map); 1505 set_bit(EOF_CHAR(tty), tty->process_char_map);
1508 set_bit('\n', tty->process_char_map); 1506 set_bit('\n', tty->process_char_map);
1509 set_bit(EOL_CHAR(tty), tty->process_char_map); 1507 set_bit(EOL_CHAR(tty), tty->process_char_map);
1510 if (L_IEXTEN(tty)) { 1508 if (L_IEXTEN(tty)) {
1511 set_bit(WERASE_CHAR(tty), 1509 set_bit(WERASE_CHAR(tty),
1512 tty->process_char_map); 1510 tty->process_char_map);
1513 set_bit(LNEXT_CHAR(tty), 1511 set_bit(LNEXT_CHAR(tty),
1514 tty->process_char_map); 1512 tty->process_char_map);
1515 set_bit(EOL2_CHAR(tty), 1513 set_bit(EOL2_CHAR(tty),
1516 tty->process_char_map); 1514 tty->process_char_map);
1517 if (L_ECHO(tty)) 1515 if (L_ECHO(tty))
1518 set_bit(REPRINT_CHAR(tty), 1516 set_bit(REPRINT_CHAR(tty),
1519 tty->process_char_map); 1517 tty->process_char_map);
1520 } 1518 }
1521 } 1519 }
1522 if (I_IXON(tty)) { 1520 if (I_IXON(tty)) {
1523 set_bit(START_CHAR(tty), tty->process_char_map); 1521 set_bit(START_CHAR(tty), tty->process_char_map);
1524 set_bit(STOP_CHAR(tty), tty->process_char_map); 1522 set_bit(STOP_CHAR(tty), tty->process_char_map);
1525 } 1523 }
1526 if (L_ISIG(tty)) { 1524 if (L_ISIG(tty)) {
1527 set_bit(INTR_CHAR(tty), tty->process_char_map); 1525 set_bit(INTR_CHAR(tty), tty->process_char_map);
1528 set_bit(QUIT_CHAR(tty), tty->process_char_map); 1526 set_bit(QUIT_CHAR(tty), tty->process_char_map);
1529 set_bit(SUSP_CHAR(tty), tty->process_char_map); 1527 set_bit(SUSP_CHAR(tty), tty->process_char_map);
1530 } 1528 }
1531 clear_bit(__DISABLED_CHAR, tty->process_char_map); 1529 clear_bit(__DISABLED_CHAR, tty->process_char_map);
1532 tty->raw = 0; 1530 tty->raw = 0;
1533 tty->real_raw = 0; 1531 tty->real_raw = 0;
1534 } else { 1532 } else {
1535 tty->raw = 1; 1533 tty->raw = 1;
1536 if ((I_IGNBRK(tty) || (!I_BRKINT(tty) && !I_PARMRK(tty))) && 1534 if ((I_IGNBRK(tty) || (!I_BRKINT(tty) && !I_PARMRK(tty))) &&
1537 (I_IGNPAR(tty) || !I_INPCK(tty)) && 1535 (I_IGNPAR(tty) || !I_INPCK(tty)) &&
1538 (tty->driver->flags & TTY_DRIVER_REAL_RAW)) 1536 (tty->driver->flags & TTY_DRIVER_REAL_RAW))
1539 tty->real_raw = 1; 1537 tty->real_raw = 1;
1540 else 1538 else
1541 tty->real_raw = 0; 1539 tty->real_raw = 0;
1542 } 1540 }
1543 n_tty_set_room(tty); 1541 n_tty_set_room(tty);
1544 /* The termios change make the tty ready for I/O */ 1542 /* The termios change make the tty ready for I/O */
1545 wake_up_interruptible(&tty->write_wait); 1543 wake_up_interruptible(&tty->write_wait);
1546 wake_up_interruptible(&tty->read_wait); 1544 wake_up_interruptible(&tty->read_wait);
1547 } 1545 }
1548 1546
1549 /** 1547 /**
1550 * n_tty_close - close the ldisc for this tty 1548 * n_tty_close - close the ldisc for this tty
1551 * @tty: device 1549 * @tty: device
1552 * 1550 *
1553 * Called from the terminal layer when this line discipline is 1551 * Called from the terminal layer when this line discipline is
1554 * being shut down, either because of a close or becsuse of a 1552 * being shut down, either because of a close or becsuse of a
1555 * discipline change. The function will not be called while other 1553 * discipline change. The function will not be called while other
1556 * ldisc methods are in progress. 1554 * ldisc methods are in progress.
1557 */ 1555 */
1558 1556
1559 static void n_tty_close(struct tty_struct *tty) 1557 static void n_tty_close(struct tty_struct *tty)
1560 { 1558 {
1561 n_tty_flush_buffer(tty); 1559 n_tty_flush_buffer(tty);
1562 if (tty->read_buf) { 1560 if (tty->read_buf) {
1563 free_buf(tty->read_buf); 1561 free_buf(tty->read_buf);
1564 tty->read_buf = NULL; 1562 tty->read_buf = NULL;
1565 } 1563 }
1566 if (tty->echo_buf) { 1564 if (tty->echo_buf) {
1567 free_buf(tty->echo_buf); 1565 free_buf(tty->echo_buf);
1568 tty->echo_buf = NULL; 1566 tty->echo_buf = NULL;
1569 } 1567 }
1570 } 1568 }
1571 1569
1572 /** 1570 /**
1573 * n_tty_open - open an ldisc 1571 * n_tty_open - open an ldisc
1574 * @tty: terminal to open 1572 * @tty: terminal to open
1575 * 1573 *
1576 * Called when this line discipline is being attached to the 1574 * Called when this line discipline is being attached to the
1577 * terminal device. Can sleep. Called serialized so that no 1575 * terminal device. Can sleep. Called serialized so that no
1578 * other events will occur in parallel. No further open will occur 1576 * other events will occur in parallel. No further open will occur
1579 * until a close. 1577 * until a close.
1580 */ 1578 */
1581 1579
1582 static int n_tty_open(struct tty_struct *tty) 1580 static int n_tty_open(struct tty_struct *tty)
1583 { 1581 {
1584 if (!tty) 1582 if (!tty)
1585 return -EINVAL; 1583 return -EINVAL;
1586 1584
1587 /* These are ugly. Currently a malloc failure here can panic */ 1585 /* These are ugly. Currently a malloc failure here can panic */
1588 if (!tty->read_buf) { 1586 if (!tty->read_buf) {
1589 tty->read_buf = alloc_buf(); 1587 tty->read_buf = alloc_buf();
1590 if (!tty->read_buf) 1588 if (!tty->read_buf)
1591 return -ENOMEM; 1589 return -ENOMEM;
1592 } 1590 }
1593 if (!tty->echo_buf) { 1591 if (!tty->echo_buf) {
1594 tty->echo_buf = alloc_buf(); 1592 tty->echo_buf = alloc_buf();
1595 if (!tty->echo_buf) 1593 if (!tty->echo_buf)
1596 return -ENOMEM; 1594 return -ENOMEM;
1597 } 1595 }
1598 memset(tty->read_buf, 0, N_TTY_BUF_SIZE); 1596 memset(tty->read_buf, 0, N_TTY_BUF_SIZE);
1599 memset(tty->echo_buf, 0, N_TTY_BUF_SIZE); 1597 memset(tty->echo_buf, 0, N_TTY_BUF_SIZE);
1600 reset_buffer_flags(tty); 1598 reset_buffer_flags(tty);
1601 tty->column = 0; 1599 tty->column = 0;
1602 n_tty_set_termios(tty, NULL); 1600 n_tty_set_termios(tty, NULL);
1603 tty->minimum_to_wake = 1; 1601 tty->minimum_to_wake = 1;
1604 tty->closing = 0; 1602 tty->closing = 0;
1605 return 0; 1603 return 0;
1606 } 1604 }
1607 1605
1608 static inline int input_available_p(struct tty_struct *tty, int amt) 1606 static inline int input_available_p(struct tty_struct *tty, int amt)
1609 { 1607 {
1610 if (tty->icanon) { 1608 if (tty->icanon) {
1611 if (tty->canon_data) 1609 if (tty->canon_data)
1612 return 1; 1610 return 1;
1613 } else if (tty->read_cnt >= (amt ? amt : 1)) 1611 } else if (tty->read_cnt >= (amt ? amt : 1))
1614 return 1; 1612 return 1;
1615 1613
1616 return 0; 1614 return 0;
1617 } 1615 }
1618 1616
1619 /** 1617 /**
1620 * copy_from_read_buf - copy read data directly 1618 * copy_from_read_buf - copy read data directly
1621 * @tty: terminal device 1619 * @tty: terminal device
1622 * @b: user data 1620 * @b: user data
1623 * @nr: size of data 1621 * @nr: size of data
1624 * 1622 *
1625 * Helper function to speed up n_tty_read. It is only called when 1623 * Helper function to speed up n_tty_read. It is only called when
1626 * ICANON is off; it copies characters straight from the tty queue to 1624 * ICANON is off; it copies characters straight from the tty queue to
1627 * user space directly. It can be profitably called twice; once to 1625 * user space directly. It can be profitably called twice; once to
1628 * drain the space from the tail pointer to the (physical) end of the 1626 * drain the space from the tail pointer to the (physical) end of the
1629 * buffer, and once to drain the space from the (physical) beginning of 1627 * buffer, and once to drain the space from the (physical) beginning of
1630 * the buffer to head pointer. 1628 * the buffer to head pointer.
1631 * 1629 *
1632 * Called under the tty->atomic_read_lock sem 1630 * Called under the tty->atomic_read_lock sem
1633 * 1631 *
1634 */ 1632 */
1635 1633
1636 static int copy_from_read_buf(struct tty_struct *tty, 1634 static int copy_from_read_buf(struct tty_struct *tty,
1637 unsigned char __user **b, 1635 unsigned char __user **b,
1638 size_t *nr) 1636 size_t *nr)
1639 1637
1640 { 1638 {
1641 int retval; 1639 int retval;
1642 size_t n; 1640 size_t n;
1643 unsigned long flags; 1641 unsigned long flags;
1644 1642
1645 retval = 0; 1643 retval = 0;
1646 spin_lock_irqsave(&tty->read_lock, flags); 1644 spin_lock_irqsave(&tty->read_lock, flags);
1647 n = min(tty->read_cnt, N_TTY_BUF_SIZE - tty->read_tail); 1645 n = min(tty->read_cnt, N_TTY_BUF_SIZE - tty->read_tail);
1648 n = min(*nr, n); 1646 n = min(*nr, n);
1649 spin_unlock_irqrestore(&tty->read_lock, flags); 1647 spin_unlock_irqrestore(&tty->read_lock, flags);
1650 if (n) { 1648 if (n) {
1651 retval = copy_to_user(*b, &tty->read_buf[tty->read_tail], n); 1649 retval = copy_to_user(*b, &tty->read_buf[tty->read_tail], n);
1652 n -= retval; 1650 n -= retval;
1653 tty_audit_add_data(tty, &tty->read_buf[tty->read_tail], n); 1651 tty_audit_add_data(tty, &tty->read_buf[tty->read_tail], n);
1654 spin_lock_irqsave(&tty->read_lock, flags); 1652 spin_lock_irqsave(&tty->read_lock, flags);
1655 tty->read_tail = (tty->read_tail + n) & (N_TTY_BUF_SIZE-1); 1653 tty->read_tail = (tty->read_tail + n) & (N_TTY_BUF_SIZE-1);
1656 tty->read_cnt -= n; 1654 tty->read_cnt -= n;
1657 spin_unlock_irqrestore(&tty->read_lock, flags); 1655 spin_unlock_irqrestore(&tty->read_lock, flags);
1658 *b += n; 1656 *b += n;
1659 *nr -= n; 1657 *nr -= n;
1660 } 1658 }
1661 return retval; 1659 return retval;
1662 } 1660 }
1663 1661
1664 extern ssize_t redirected_tty_write(struct file *, const char __user *, 1662 extern ssize_t redirected_tty_write(struct file *, const char __user *,
1665 size_t, loff_t *); 1663 size_t, loff_t *);
1666 1664
1667 /** 1665 /**
1668 * job_control - check job control 1666 * job_control - check job control
1669 * @tty: tty 1667 * @tty: tty
1670 * @file: file handle 1668 * @file: file handle
1671 * 1669 *
1672 * Perform job control management checks on this file/tty descriptor 1670 * Perform job control management checks on this file/tty descriptor
1673 * and if appropriate send any needed signals and return a negative 1671 * and if appropriate send any needed signals and return a negative
1674 * error code if action should be taken. 1672 * error code if action should be taken.
1675 * 1673 *
1676 * FIXME: 1674 * FIXME:
1677 * Locking: None - redirected write test is safe, testing 1675 * Locking: None - redirected write test is safe, testing
1678 * current->signal should possibly lock current->sighand 1676 * current->signal should possibly lock current->sighand
1679 * pgrp locking ? 1677 * pgrp locking ?
1680 */ 1678 */
1681 1679
1682 static int job_control(struct tty_struct *tty, struct file *file) 1680 static int job_control(struct tty_struct *tty, struct file *file)
1683 { 1681 {
1684 /* Job control check -- must be done at start and after 1682 /* Job control check -- must be done at start and after
1685 every sleep (POSIX.1 7.1.1.4). */ 1683 every sleep (POSIX.1 7.1.1.4). */
1686 /* NOTE: not yet done after every sleep pending a thorough 1684 /* NOTE: not yet done after every sleep pending a thorough
1687 check of the logic of this change. -- jlc */ 1685 check of the logic of this change. -- jlc */
1688 /* don't stop on /dev/console */ 1686 /* don't stop on /dev/console */
1689 if (file->f_op->write != redirected_tty_write && 1687 if (file->f_op->write != redirected_tty_write &&
1690 current->signal->tty == tty) { 1688 current->signal->tty == tty) {
1691 if (!tty->pgrp) 1689 if (!tty->pgrp)
1692 printk(KERN_ERR "n_tty_read: no tty->pgrp!\n"); 1690 printk(KERN_ERR "n_tty_read: no tty->pgrp!\n");
1693 else if (task_pgrp(current) != tty->pgrp) { 1691 else if (task_pgrp(current) != tty->pgrp) {
1694 if (is_ignored(SIGTTIN) || 1692 if (is_ignored(SIGTTIN) ||
1695 is_current_pgrp_orphaned()) 1693 is_current_pgrp_orphaned())
1696 return -EIO; 1694 return -EIO;
1697 kill_pgrp(task_pgrp(current), SIGTTIN, 1); 1695 kill_pgrp(task_pgrp(current), SIGTTIN, 1);
1698 set_thread_flag(TIF_SIGPENDING); 1696 set_thread_flag(TIF_SIGPENDING);
1699 return -ERESTARTSYS; 1697 return -ERESTARTSYS;
1700 } 1698 }
1701 } 1699 }
1702 return 0; 1700 return 0;
1703 } 1701 }
1704 1702
1705 1703
1706 /** 1704 /**
1707 * n_tty_read - read function for tty 1705 * n_tty_read - read function for tty
1708 * @tty: tty device 1706 * @tty: tty device
1709 * @file: file object 1707 * @file: file object
1710 * @buf: userspace buffer pointer 1708 * @buf: userspace buffer pointer
1711 * @nr: size of I/O 1709 * @nr: size of I/O
1712 * 1710 *
1713 * Perform reads for the line discipline. We are guaranteed that the 1711 * Perform reads for the line discipline. We are guaranteed that the
1714 * line discipline will not be closed under us but we may get multiple 1712 * line discipline will not be closed under us but we may get multiple
1715 * parallel readers and must handle this ourselves. We may also get 1713 * parallel readers and must handle this ourselves. We may also get
1716 * a hangup. Always called in user context, may sleep. 1714 * a hangup. Always called in user context, may sleep.
1717 * 1715 *
1718 * This code must be sure never to sleep through a hangup. 1716 * This code must be sure never to sleep through a hangup.
1719 */ 1717 */
1720 1718
1721 static ssize_t n_tty_read(struct tty_struct *tty, struct file *file, 1719 static ssize_t n_tty_read(struct tty_struct *tty, struct file *file,
1722 unsigned char __user *buf, size_t nr) 1720 unsigned char __user *buf, size_t nr)
1723 { 1721 {
1724 unsigned char __user *b = buf; 1722 unsigned char __user *b = buf;
1725 DECLARE_WAITQUEUE(wait, current); 1723 DECLARE_WAITQUEUE(wait, current);
1726 int c; 1724 int c;
1727 int minimum, time; 1725 int minimum, time;
1728 ssize_t retval = 0; 1726 ssize_t retval = 0;
1729 ssize_t size; 1727 ssize_t size;
1730 long timeout; 1728 long timeout;
1731 unsigned long flags; 1729 unsigned long flags;
1732 int packet; 1730 int packet;
1733 1731
1734 do_it_again: 1732 do_it_again:
1735 1733
1736 BUG_ON(!tty->read_buf); 1734 BUG_ON(!tty->read_buf);
1737 1735
1738 c = job_control(tty, file); 1736 c = job_control(tty, file);
1739 if (c < 0) 1737 if (c < 0)
1740 return c; 1738 return c;
1741 1739
1742 minimum = time = 0; 1740 minimum = time = 0;
1743 timeout = MAX_SCHEDULE_TIMEOUT; 1741 timeout = MAX_SCHEDULE_TIMEOUT;
1744 if (!tty->icanon) { 1742 if (!tty->icanon) {
1745 time = (HZ / 10) * TIME_CHAR(tty); 1743 time = (HZ / 10) * TIME_CHAR(tty);
1746 minimum = MIN_CHAR(tty); 1744 minimum = MIN_CHAR(tty);
1747 if (minimum) { 1745 if (minimum) {
1748 if (time) 1746 if (time)
1749 tty->minimum_to_wake = 1; 1747 tty->minimum_to_wake = 1;
1750 else if (!waitqueue_active(&tty->read_wait) || 1748 else if (!waitqueue_active(&tty->read_wait) ||
1751 (tty->minimum_to_wake > minimum)) 1749 (tty->minimum_to_wake > minimum))
1752 tty->minimum_to_wake = minimum; 1750 tty->minimum_to_wake = minimum;
1753 } else { 1751 } else {
1754 timeout = 0; 1752 timeout = 0;
1755 if (time) { 1753 if (time) {
1756 timeout = time; 1754 timeout = time;
1757 time = 0; 1755 time = 0;
1758 } 1756 }
1759 tty->minimum_to_wake = minimum = 1; 1757 tty->minimum_to_wake = minimum = 1;
1760 } 1758 }
1761 } 1759 }
1762 1760
1763 /* 1761 /*
1764 * Internal serialization of reads. 1762 * Internal serialization of reads.
1765 */ 1763 */
1766 if (file->f_flags & O_NONBLOCK) { 1764 if (file->f_flags & O_NONBLOCK) {
1767 if (!mutex_trylock(&tty->atomic_read_lock)) 1765 if (!mutex_trylock(&tty->atomic_read_lock))
1768 return -EAGAIN; 1766 return -EAGAIN;
1769 } else { 1767 } else {
1770 if (mutex_lock_interruptible(&tty->atomic_read_lock)) 1768 if (mutex_lock_interruptible(&tty->atomic_read_lock))
1771 return -ERESTARTSYS; 1769 return -ERESTARTSYS;
1772 } 1770 }
1773 packet = tty->packet; 1771 packet = tty->packet;
1774 1772
1775 add_wait_queue(&tty->read_wait, &wait); 1773 add_wait_queue(&tty->read_wait, &wait);
1776 while (nr) { 1774 while (nr) {
1777 /* First test for status change. */ 1775 /* First test for status change. */
1778 if (packet && tty->link->ctrl_status) { 1776 if (packet && tty->link->ctrl_status) {
1779 unsigned char cs; 1777 unsigned char cs;
1780 if (b != buf) 1778 if (b != buf)
1781 break; 1779 break;
1782 spin_lock_irqsave(&tty->link->ctrl_lock, flags); 1780 spin_lock_irqsave(&tty->link->ctrl_lock, flags);
1783 cs = tty->link->ctrl_status; 1781 cs = tty->link->ctrl_status;
1784 tty->link->ctrl_status = 0; 1782 tty->link->ctrl_status = 0;
1785 spin_unlock_irqrestore(&tty->link->ctrl_lock, flags); 1783 spin_unlock_irqrestore(&tty->link->ctrl_lock, flags);
1786 if (tty_put_user(tty, cs, b++)) { 1784 if (tty_put_user(tty, cs, b++)) {
1787 retval = -EFAULT; 1785 retval = -EFAULT;
1788 b--; 1786 b--;
1789 break; 1787 break;
1790 } 1788 }
1791 nr--; 1789 nr--;
1792 break; 1790 break;
1793 } 1791 }
1794 /* This statement must be first before checking for input 1792 /* This statement must be first before checking for input
1795 so that any interrupt will set the state back to 1793 so that any interrupt will set the state back to
1796 TASK_RUNNING. */ 1794 TASK_RUNNING. */
1797 set_current_state(TASK_INTERRUPTIBLE); 1795 set_current_state(TASK_INTERRUPTIBLE);
1798 1796
1799 if (((minimum - (b - buf)) < tty->minimum_to_wake) && 1797 if (((minimum - (b - buf)) < tty->minimum_to_wake) &&
1800 ((minimum - (b - buf)) >= 1)) 1798 ((minimum - (b - buf)) >= 1))
1801 tty->minimum_to_wake = (minimum - (b - buf)); 1799 tty->minimum_to_wake = (minimum - (b - buf));
1802 1800
1803 if (!input_available_p(tty, 0)) { 1801 if (!input_available_p(tty, 0)) {
1804 if (test_bit(TTY_OTHER_CLOSED, &tty->flags)) { 1802 if (test_bit(TTY_OTHER_CLOSED, &tty->flags)) {
1805 retval = -EIO; 1803 retval = -EIO;
1806 break; 1804 break;
1807 } 1805 }
1808 if (tty_hung_up_p(file)) 1806 if (tty_hung_up_p(file))
1809 break; 1807 break;
1810 if (!timeout) 1808 if (!timeout)
1811 break; 1809 break;
1812 if (file->f_flags & O_NONBLOCK) { 1810 if (file->f_flags & O_NONBLOCK) {
1813 retval = -EAGAIN; 1811 retval = -EAGAIN;
1814 break; 1812 break;
1815 } 1813 }
1816 if (signal_pending(current)) { 1814 if (signal_pending(current)) {
1817 retval = -ERESTARTSYS; 1815 retval = -ERESTARTSYS;
1818 break; 1816 break;
1819 } 1817 }
1820 /* FIXME: does n_tty_set_room need locking ? */ 1818 /* FIXME: does n_tty_set_room need locking ? */
1821 n_tty_set_room(tty); 1819 n_tty_set_room(tty);
1822 timeout = schedule_timeout(timeout); 1820 timeout = schedule_timeout(timeout);
1823 continue; 1821 continue;
1824 } 1822 }
1825 __set_current_state(TASK_RUNNING); 1823 __set_current_state(TASK_RUNNING);
1826 1824
1827 /* Deal with packet mode. */ 1825 /* Deal with packet mode. */
1828 if (packet && b == buf) { 1826 if (packet && b == buf) {
1829 if (tty_put_user(tty, TIOCPKT_DATA, b++)) { 1827 if (tty_put_user(tty, TIOCPKT_DATA, b++)) {
1830 retval = -EFAULT; 1828 retval = -EFAULT;
1831 b--; 1829 b--;
1832 break; 1830 break;
1833 } 1831 }
1834 nr--; 1832 nr--;
1835 } 1833 }
1836 1834
1837 if (tty->icanon) { 1835 if (tty->icanon) {
1838 /* N.B. avoid overrun if nr == 0 */ 1836 /* N.B. avoid overrun if nr == 0 */
1839 while (nr && tty->read_cnt) { 1837 while (nr && tty->read_cnt) {
1840 int eol; 1838 int eol;
1841 1839
1842 eol = test_and_clear_bit(tty->read_tail, 1840 eol = test_and_clear_bit(tty->read_tail,
1843 tty->read_flags); 1841 tty->read_flags);
1844 c = tty->read_buf[tty->read_tail]; 1842 c = tty->read_buf[tty->read_tail];
1845 spin_lock_irqsave(&tty->read_lock, flags); 1843 spin_lock_irqsave(&tty->read_lock, flags);
1846 tty->read_tail = ((tty->read_tail+1) & 1844 tty->read_tail = ((tty->read_tail+1) &
1847 (N_TTY_BUF_SIZE-1)); 1845 (N_TTY_BUF_SIZE-1));
1848 tty->read_cnt--; 1846 tty->read_cnt--;
1849 if (eol) { 1847 if (eol) {
1850 /* this test should be redundant: 1848 /* this test should be redundant:
1851 * we shouldn't be reading data if 1849 * we shouldn't be reading data if
1852 * canon_data is 0 1850 * canon_data is 0
1853 */ 1851 */
1854 if (--tty->canon_data < 0) 1852 if (--tty->canon_data < 0)
1855 tty->canon_data = 0; 1853 tty->canon_data = 0;
1856 } 1854 }
1857 spin_unlock_irqrestore(&tty->read_lock, flags); 1855 spin_unlock_irqrestore(&tty->read_lock, flags);
1858 1856
1859 if (!eol || (c != __DISABLED_CHAR)) { 1857 if (!eol || (c != __DISABLED_CHAR)) {
1860 if (tty_put_user(tty, c, b++)) { 1858 if (tty_put_user(tty, c, b++)) {
1861 retval = -EFAULT; 1859 retval = -EFAULT;
1862 b--; 1860 b--;
1863 break; 1861 break;
1864 } 1862 }
1865 nr--; 1863 nr--;
1866 } 1864 }
1867 if (eol) { 1865 if (eol) {
1868 tty_audit_push(tty); 1866 tty_audit_push(tty);
1869 break; 1867 break;
1870 } 1868 }
1871 } 1869 }
1872 if (retval) 1870 if (retval)
1873 break; 1871 break;
1874 } else { 1872 } else {
1875 int uncopied; 1873 int uncopied;
1876 /* The copy function takes the read lock and handles 1874 /* The copy function takes the read lock and handles
1877 locking internally for this case */ 1875 locking internally for this case */
1878 uncopied = copy_from_read_buf(tty, &b, &nr); 1876 uncopied = copy_from_read_buf(tty, &b, &nr);
1879 uncopied += copy_from_read_buf(tty, &b, &nr); 1877 uncopied += copy_from_read_buf(tty, &b, &nr);
1880 if (uncopied) { 1878 if (uncopied) {
1881 retval = -EFAULT; 1879 retval = -EFAULT;
1882 break; 1880 break;
1883 } 1881 }
1884 } 1882 }
1885 1883
1886 /* If there is enough space in the read buffer now, let the 1884 /* If there is enough space in the read buffer now, let the
1887 * low-level driver know. We use n_tty_chars_in_buffer() to 1885 * low-level driver know. We use n_tty_chars_in_buffer() to
1888 * check the buffer, as it now knows about canonical mode. 1886 * check the buffer, as it now knows about canonical mode.
1889 * Otherwise, if the driver is throttled and the line is 1887 * Otherwise, if the driver is throttled and the line is
1890 * longer than TTY_THRESHOLD_UNTHROTTLE in canonical mode, 1888 * longer than TTY_THRESHOLD_UNTHROTTLE in canonical mode,
1891 * we won't get any more characters. 1889 * we won't get any more characters.
1892 */ 1890 */
1893 if (n_tty_chars_in_buffer(tty) <= TTY_THRESHOLD_UNTHROTTLE) { 1891 if (n_tty_chars_in_buffer(tty) <= TTY_THRESHOLD_UNTHROTTLE) {
1894 n_tty_set_room(tty); 1892 n_tty_set_room(tty);
1895 check_unthrottle(tty); 1893 check_unthrottle(tty);
1896 } 1894 }
1897 1895
1898 if (b - buf >= minimum) 1896 if (b - buf >= minimum)
1899 break; 1897 break;
1900 if (time) 1898 if (time)
1901 timeout = time; 1899 timeout = time;
1902 } 1900 }
1903 mutex_unlock(&tty->atomic_read_lock); 1901 mutex_unlock(&tty->atomic_read_lock);
1904 remove_wait_queue(&tty->read_wait, &wait); 1902 remove_wait_queue(&tty->read_wait, &wait);
1905 1903
1906 if (!waitqueue_active(&tty->read_wait)) 1904 if (!waitqueue_active(&tty->read_wait))
1907 tty->minimum_to_wake = minimum; 1905 tty->minimum_to_wake = minimum;
1908 1906
1909 __set_current_state(TASK_RUNNING); 1907 __set_current_state(TASK_RUNNING);
1910 size = b - buf; 1908 size = b - buf;
1911 if (size) { 1909 if (size) {
1912 retval = size; 1910 retval = size;
1913 if (nr) 1911 if (nr)
1914 clear_bit(TTY_PUSH, &tty->flags); 1912 clear_bit(TTY_PUSH, &tty->flags);
1915 } else if (test_and_clear_bit(TTY_PUSH, &tty->flags)) 1913 } else if (test_and_clear_bit(TTY_PUSH, &tty->flags))
1916 goto do_it_again; 1914 goto do_it_again;
1917 1915
1918 n_tty_set_room(tty); 1916 n_tty_set_room(tty);
1919 return retval; 1917 return retval;
1920 } 1918 }
1921 1919
1922 /** 1920 /**
1923 * n_tty_write - write function for tty 1921 * n_tty_write - write function for tty
1924 * @tty: tty device 1922 * @tty: tty device
1925 * @file: file object 1923 * @file: file object
1926 * @buf: userspace buffer pointer 1924 * @buf: userspace buffer pointer
1927 * @nr: size of I/O 1925 * @nr: size of I/O
1928 * 1926 *
1929 * Write function of the terminal device. This is serialized with 1927 * Write function of the terminal device. This is serialized with
1930 * respect to other write callers but not to termios changes, reads 1928 * respect to other write callers but not to termios changes, reads
1931 * and other such events. Since the receive code will echo characters, 1929 * and other such events. Since the receive code will echo characters,
1932 * thus calling driver write methods, the output_lock is used in 1930 * thus calling driver write methods, the output_lock is used in
1933 * the output processing functions called here as well as in the 1931 * the output processing functions called here as well as in the
1934 * echo processing function to protect the column state and space 1932 * echo processing function to protect the column state and space
1935 * left in the buffer. 1933 * left in the buffer.
1936 * 1934 *
1937 * This code must be sure never to sleep through a hangup. 1935 * This code must be sure never to sleep through a hangup.
1938 * 1936 *
1939 * Locking: output_lock to protect column state and space left 1937 * Locking: output_lock to protect column state and space left
1940 * (note that the process_output*() functions take this 1938 * (note that the process_output*() functions take this
1941 * lock themselves) 1939 * lock themselves)
1942 */ 1940 */
1943 1941
1944 static ssize_t n_tty_write(struct tty_struct *tty, struct file *file, 1942 static ssize_t n_tty_write(struct tty_struct *tty, struct file *file,
1945 const unsigned char *buf, size_t nr) 1943 const unsigned char *buf, size_t nr)
1946 { 1944 {
1947 const unsigned char *b = buf; 1945 const unsigned char *b = buf;
1948 DECLARE_WAITQUEUE(wait, current); 1946 DECLARE_WAITQUEUE(wait, current);
1949 int c; 1947 int c;
1950 ssize_t retval = 0; 1948 ssize_t retval = 0;
1951 1949
1952 /* Job control check -- must be done at start (POSIX.1 7.1.1.4). */ 1950 /* Job control check -- must be done at start (POSIX.1 7.1.1.4). */
1953 if (L_TOSTOP(tty) && file->f_op->write != redirected_tty_write) { 1951 if (L_TOSTOP(tty) && file->f_op->write != redirected_tty_write) {
1954 retval = tty_check_change(tty); 1952 retval = tty_check_change(tty);
1955 if (retval) 1953 if (retval)
1956 return retval; 1954 return retval;
1957 } 1955 }
1958 1956
1959 /* Write out any echoed characters that are still pending */ 1957 /* Write out any echoed characters that are still pending */
1960 process_echoes(tty); 1958 process_echoes(tty);
1961 1959
1962 add_wait_queue(&tty->write_wait, &wait); 1960 add_wait_queue(&tty->write_wait, &wait);
1963 while (1) { 1961 while (1) {
1964 set_current_state(TASK_INTERRUPTIBLE); 1962 set_current_state(TASK_INTERRUPTIBLE);
1965 if (signal_pending(current)) { 1963 if (signal_pending(current)) {
1966 retval = -ERESTARTSYS; 1964 retval = -ERESTARTSYS;
1967 break; 1965 break;
1968 } 1966 }
1969 if (tty_hung_up_p(file) || (tty->link && !tty->link->count)) { 1967 if (tty_hung_up_p(file) || (tty->link && !tty->link->count)) {
1970 retval = -EIO; 1968 retval = -EIO;
1971 break; 1969 break;
1972 } 1970 }
1973 if (O_OPOST(tty) && !(test_bit(TTY_HW_COOK_OUT, &tty->flags))) { 1971 if (O_OPOST(tty) && !(test_bit(TTY_HW_COOK_OUT, &tty->flags))) {
1974 while (nr > 0) { 1972 while (nr > 0) {
1975 ssize_t num = process_output_block(tty, b, nr); 1973 ssize_t num = process_output_block(tty, b, nr);
1976 if (num < 0) { 1974 if (num < 0) {
1977 if (num == -EAGAIN) 1975 if (num == -EAGAIN)
1978 break; 1976 break;
1979 retval = num; 1977 retval = num;
1980 goto break_out; 1978 goto break_out;
1981 } 1979 }
1982 b += num; 1980 b += num;
1983 nr -= num; 1981 nr -= num;
1984 if (nr == 0) 1982 if (nr == 0)
1985 break; 1983 break;
1986 c = *b; 1984 c = *b;
1987 if (process_output(c, tty) < 0) 1985 if (process_output(c, tty) < 0)
1988 break; 1986 break;
1989 b++; nr--; 1987 b++; nr--;
1990 } 1988 }
1991 if (tty->ops->flush_chars) 1989 if (tty->ops->flush_chars)
1992 tty->ops->flush_chars(tty); 1990 tty->ops->flush_chars(tty);
1993 } else { 1991 } else {
1994 while (nr > 0) { 1992 while (nr > 0) {
1995 c = tty->ops->write(tty, b, nr); 1993 c = tty->ops->write(tty, b, nr);
1996 if (c < 0) { 1994 if (c < 0) {
1997 retval = c; 1995 retval = c;
1998 goto break_out; 1996 goto break_out;
1999 } 1997 }
2000 if (!c) 1998 if (!c)
2001 break; 1999 break;
2002 b += c; 2000 b += c;
2003 nr -= c; 2001 nr -= c;
2004 } 2002 }
2005 } 2003 }
2006 if (!nr) 2004 if (!nr)
2007 break; 2005 break;
2008 if (file->f_flags & O_NONBLOCK) { 2006 if (file->f_flags & O_NONBLOCK) {
2009 retval = -EAGAIN; 2007 retval = -EAGAIN;
2010 break; 2008 break;
2011 } 2009 }
2012 schedule(); 2010 schedule();
2013 } 2011 }
2014 break_out: 2012 break_out:
2015 __set_current_state(TASK_RUNNING); 2013 __set_current_state(TASK_RUNNING);
2016 remove_wait_queue(&tty->write_wait, &wait); 2014 remove_wait_queue(&tty->write_wait, &wait);
2015 if (b - buf != nr && tty->fasync)
2016 set_bit(TTY_DO_WRITE_WAKEUP, &tty->flags);
2017 return (b - buf) ? b - buf : retval; 2017 return (b - buf) ? b - buf : retval;
2018 } 2018 }
2019 2019
2020 /** 2020 /**
2021 * n_tty_poll - poll method for N_TTY 2021 * n_tty_poll - poll method for N_TTY
2022 * @tty: terminal device 2022 * @tty: terminal device
2023 * @file: file accessing it 2023 * @file: file accessing it
2024 * @wait: poll table 2024 * @wait: poll table
2025 * 2025 *
2026 * Called when the line discipline is asked to poll() for data or 2026 * Called when the line discipline is asked to poll() for data or
2027 * for special events. This code is not serialized with respect to 2027 * for special events. This code is not serialized with respect to
2028 * other events save open/close. 2028 * other events save open/close.
2029 * 2029 *
2030 * This code must be sure never to sleep through a hangup. 2030 * This code must be sure never to sleep through a hangup.
2031 * Called without the kernel lock held - fine 2031 * Called without the kernel lock held - fine
2032 */ 2032 */
2033 2033
2034 static unsigned int n_tty_poll(struct tty_struct *tty, struct file *file, 2034 static unsigned int n_tty_poll(struct tty_struct *tty, struct file *file,
2035 poll_table *wait) 2035 poll_table *wait)
2036 { 2036 {
2037 unsigned int mask = 0; 2037 unsigned int mask = 0;
2038 2038
2039 poll_wait(file, &tty->read_wait, wait); 2039 poll_wait(file, &tty->read_wait, wait);
2040 poll_wait(file, &tty->write_wait, wait); 2040 poll_wait(file, &tty->write_wait, wait);
2041 if (input_available_p(tty, TIME_CHAR(tty) ? 0 : MIN_CHAR(tty))) 2041 if (input_available_p(tty, TIME_CHAR(tty) ? 0 : MIN_CHAR(tty)))
2042 mask |= POLLIN | POLLRDNORM; 2042 mask |= POLLIN | POLLRDNORM;
2043 if (tty->packet && tty->link->ctrl_status) 2043 if (tty->packet && tty->link->ctrl_status)
2044 mask |= POLLPRI | POLLIN | POLLRDNORM; 2044 mask |= POLLPRI | POLLIN | POLLRDNORM;
2045 if (test_bit(TTY_OTHER_CLOSED, &tty->flags)) 2045 if (test_bit(TTY_OTHER_CLOSED, &tty->flags))
2046 mask |= POLLHUP; 2046 mask |= POLLHUP;
2047 if (tty_hung_up_p(file)) 2047 if (tty_hung_up_p(file))
2048 mask |= POLLHUP; 2048 mask |= POLLHUP;
2049 if (!(mask & (POLLHUP | POLLIN | POLLRDNORM))) { 2049 if (!(mask & (POLLHUP | POLLIN | POLLRDNORM))) {
2050 if (MIN_CHAR(tty) && !TIME_CHAR(tty)) 2050 if (MIN_CHAR(tty) && !TIME_CHAR(tty))
2051 tty->minimum_to_wake = MIN_CHAR(tty); 2051 tty->minimum_to_wake = MIN_CHAR(tty);
2052 else 2052 else
2053 tty->minimum_to_wake = 1; 2053 tty->minimum_to_wake = 1;
2054 } 2054 }
2055 if (tty->ops->write && !tty_is_writelocked(tty) && 2055 if (tty->ops->write && !tty_is_writelocked(tty) &&
2056 tty_chars_in_buffer(tty) < WAKEUP_CHARS && 2056 tty_chars_in_buffer(tty) < WAKEUP_CHARS &&
2057 tty_write_room(tty) > 0) 2057 tty_write_room(tty) > 0)
2058 mask |= POLLOUT | POLLWRNORM; 2058 mask |= POLLOUT | POLLWRNORM;
2059 return mask; 2059 return mask;
2060 } 2060 }
2061 2061
2062 static unsigned long inq_canon(struct tty_struct *tty) 2062 static unsigned long inq_canon(struct tty_struct *tty)
2063 { 2063 {
2064 int nr, head, tail; 2064 int nr, head, tail;
2065 2065
2066 if (!tty->canon_data) 2066 if (!tty->canon_data)
2067 return 0; 2067 return 0;
2068 head = tty->canon_head; 2068 head = tty->canon_head;
2069 tail = tty->read_tail; 2069 tail = tty->read_tail;
2070 nr = (head - tail) & (N_TTY_BUF_SIZE-1); 2070 nr = (head - tail) & (N_TTY_BUF_SIZE-1);
2071 /* Skip EOF-chars.. */ 2071 /* Skip EOF-chars.. */
2072 while (head != tail) { 2072 while (head != tail) {
2073 if (test_bit(tail, tty->read_flags) && 2073 if (test_bit(tail, tty->read_flags) &&
2074 tty->read_buf[tail] == __DISABLED_CHAR) 2074 tty->read_buf[tail] == __DISABLED_CHAR)
2075 nr--; 2075 nr--;
2076 tail = (tail+1) & (N_TTY_BUF_SIZE-1); 2076 tail = (tail+1) & (N_TTY_BUF_SIZE-1);
2077 } 2077 }
2078 return nr; 2078 return nr;
2079 } 2079 }
2080 2080
2081 static int n_tty_ioctl(struct tty_struct *tty, struct file *file, 2081 static int n_tty_ioctl(struct tty_struct *tty, struct file *file,
2082 unsigned int cmd, unsigned long arg) 2082 unsigned int cmd, unsigned long arg)
2083 { 2083 {
2084 int retval; 2084 int retval;
2085 2085
2086 switch (cmd) { 2086 switch (cmd) {
2087 case TIOCOUTQ: 2087 case TIOCOUTQ:
2088 return put_user(tty_chars_in_buffer(tty), (int __user *) arg); 2088 return put_user(tty_chars_in_buffer(tty), (int __user *) arg);
2089 case TIOCINQ: 2089 case TIOCINQ:
2090 /* FIXME: Locking */ 2090 /* FIXME: Locking */
2091 retval = tty->read_cnt; 2091 retval = tty->read_cnt;
2092 if (L_ICANON(tty)) 2092 if (L_ICANON(tty))
2093 retval = inq_canon(tty); 2093 retval = inq_canon(tty);
2094 return put_user(retval, (unsigned int __user *) arg); 2094 return put_user(retval, (unsigned int __user *) arg);
2095 default: 2095 default:
2096 return n_tty_ioctl_helper(tty, file, cmd, arg); 2096 return n_tty_ioctl_helper(tty, file, cmd, arg);
2097 } 2097 }
2098 } 2098 }
2099 2099
2100 struct tty_ldisc_ops tty_ldisc_N_TTY = { 2100 struct tty_ldisc_ops tty_ldisc_N_TTY = {
2101 .magic = TTY_LDISC_MAGIC, 2101 .magic = TTY_LDISC_MAGIC,
2102 .name = "n_tty", 2102 .name = "n_tty",
2103 .open = n_tty_open, 2103 .open = n_tty_open,
2104 .close = n_tty_close, 2104 .close = n_tty_close,
2105 .flush_buffer = n_tty_flush_buffer, 2105 .flush_buffer = n_tty_flush_buffer,
2106 .chars_in_buffer = n_tty_chars_in_buffer, 2106 .chars_in_buffer = n_tty_chars_in_buffer,
2107 .read = n_tty_read, 2107 .read = n_tty_read,
2108 .write = n_tty_write, 2108 .write = n_tty_write,
2109 .ioctl = n_tty_ioctl, 2109 .ioctl = n_tty_ioctl,
2110 .set_termios = n_tty_set_termios, 2110 .set_termios = n_tty_set_termios,
2111 .poll = n_tty_poll, 2111 .poll = n_tty_poll,
2112 .receive_buf = n_tty_receive_buf, 2112 .receive_buf = n_tty_receive_buf,
2113 .write_wakeup = n_tty_write_wakeup 2113 .write_wakeup = n_tty_write_wakeup