ASoC: Use card field to indicate whether a component is bound
[linux-2.6-block.git] / drivers / tty / n_tty.c
1 /*
2  * n_tty.c --- implements the N_TTY line discipline.
3  *
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
6  * processing has changed so much that it's hardly recognizable,
7  * anyway...)
8  *
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
11  * to N_TTY if it can not switch to any other line discipline.
12  *
13  * Written by Theodore Ts'o, Copyright 1994.
14  *
15  * This file also contains code originally written by Linus Torvalds,
16  * Copyright 1991, 1992, 1993, and by Julian Cowley, Copyright 1994.
17  *
18  * This file may be redistributed under the terms of the GNU General Public
19  * License.
20  *
21  * Reduced memory usage for older ARM systems  - Russell King.
22  *
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>
25  *              who actually finally proved there really was a race.
26  *
27  * 2002/03/18   Implemented n_tty_wakeup to send SIGIO POLL_OUTs to
28  *              waiting writing processes-Sapan Bhatia <sapan@corewars.org>.
29  *              Also fixed a bug in BLOCKING mode where n_tty_write returns
30  *              EAGAIN
31  */
32
33 #include <linux/types.h>
34 #include <linux/major.h>
35 #include <linux/errno.h>
36 #include <linux/signal.h>
37 #include <linux/fcntl.h>
38 #include <linux/sched.h>
39 #include <linux/interrupt.h>
40 #include <linux/tty.h>
41 #include <linux/timer.h>
42 #include <linux/ctype.h>
43 #include <linux/mm.h>
44 #include <linux/string.h>
45 #include <linux/slab.h>
46 #include <linux/poll.h>
47 #include <linux/bitops.h>
48 #include <linux/audit.h>
49 #include <linux/file.h>
50 #include <linux/uaccess.h>
51 #include <linux/module.h>
52 #include <linux/ratelimit.h>
53 #include <linux/vmalloc.h>
54
55
56 /* number of characters left in xmit buffer before select has we have room */
57 #define WAKEUP_CHARS 256
58
59 /*
60  * This defines the low- and high-watermarks for throttling and
61  * unthrottling the TTY driver.  These watermarks are used for
62  * controlling the space in the read buffer.
63  */
64 #define TTY_THRESHOLD_THROTTLE          128 /* now based on remaining room */
65 #define TTY_THRESHOLD_UNTHROTTLE        128
66
67 /*
68  * Special byte codes used in the echo buffer to represent operations
69  * or special handling of characters.  Bytes in the echo buffer that
70  * are not part of such special blocks are treated as normal character
71  * codes.
72  */
73 #define ECHO_OP_START 0xff
74 #define ECHO_OP_MOVE_BACK_COL 0x80
75 #define ECHO_OP_SET_CANON_COL 0x81
76 #define ECHO_OP_ERASE_TAB 0x82
77
78 #define ECHO_COMMIT_WATERMARK   256
79 #define ECHO_BLOCK              256
80 #define ECHO_DISCARD_WATERMARK  N_TTY_BUF_SIZE - (ECHO_BLOCK + 32)
81
82
83 #undef N_TTY_TRACE
84 #ifdef N_TTY_TRACE
85 # define n_tty_trace(f, args...)        trace_printk(f, ##args)
86 #else
87 # define n_tty_trace(f, args...)
88 #endif
89
90 struct n_tty_data {
91         /* producer-published */
92         size_t read_head;
93         size_t commit_head;
94         size_t canon_head;
95         size_t echo_head;
96         size_t echo_commit;
97         size_t echo_mark;
98         DECLARE_BITMAP(char_map, 256);
99
100         /* private to n_tty_receive_overrun (single-threaded) */
101         unsigned long overrun_time;
102         int num_overrun;
103
104         /* non-atomic */
105         bool no_room;
106
107         /* must hold exclusive termios_rwsem to reset these */
108         unsigned char lnext:1, erasing:1, raw:1, real_raw:1, icanon:1;
109         unsigned char push:1;
110
111         /* shared by producer and consumer */
112         char read_buf[N_TTY_BUF_SIZE];
113         DECLARE_BITMAP(read_flags, N_TTY_BUF_SIZE);
114         unsigned char echo_buf[N_TTY_BUF_SIZE];
115
116         int minimum_to_wake;
117
118         /* consumer-published */
119         size_t read_tail;
120         size_t line_start;
121
122         /* protected by output lock */
123         unsigned int column;
124         unsigned int canon_column;
125         size_t echo_tail;
126
127         struct mutex atomic_read_lock;
128         struct mutex output_lock;
129 };
130
131 static inline size_t read_cnt(struct n_tty_data *ldata)
132 {
133         return ldata->read_head - ldata->read_tail;
134 }
135
136 static inline unsigned char read_buf(struct n_tty_data *ldata, size_t i)
137 {
138         return ldata->read_buf[i & (N_TTY_BUF_SIZE - 1)];
139 }
140
141 static inline unsigned char *read_buf_addr(struct n_tty_data *ldata, size_t i)
142 {
143         return &ldata->read_buf[i & (N_TTY_BUF_SIZE - 1)];
144 }
145
146 static inline unsigned char echo_buf(struct n_tty_data *ldata, size_t i)
147 {
148         return ldata->echo_buf[i & (N_TTY_BUF_SIZE - 1)];
149 }
150
151 static inline unsigned char *echo_buf_addr(struct n_tty_data *ldata, size_t i)
152 {
153         return &ldata->echo_buf[i & (N_TTY_BUF_SIZE - 1)];
154 }
155
156 static inline int tty_put_user(struct tty_struct *tty, unsigned char x,
157                                unsigned char __user *ptr)
158 {
159         struct n_tty_data *ldata = tty->disc_data;
160
161         tty_audit_add_data(tty, &x, 1, ldata->icanon);
162         return put_user(x, ptr);
163 }
164
165 static inline int tty_copy_to_user(struct tty_struct *tty,
166                                         void __user *to,
167                                         const void *from,
168                                         unsigned long n)
169 {
170         struct n_tty_data *ldata = tty->disc_data;
171
172         tty_audit_add_data(tty, to, n, ldata->icanon);
173         return copy_to_user(to, from, n);
174 }
175
176 /**
177  *      n_tty_kick_worker - start input worker (if required)
178  *      @tty: terminal
179  *
180  *      Re-schedules the flip buffer work if it may have stopped
181  *
182  *      Caller holds exclusive termios_rwsem
183  *         or
184  *      n_tty_read()/consumer path:
185  *              holds non-exclusive termios_rwsem
186  */
187
188 static void n_tty_kick_worker(struct tty_struct *tty)
189 {
190         struct n_tty_data *ldata = tty->disc_data;
191
192         /* Did the input worker stop? Restart it */
193         if (unlikely(ldata->no_room)) {
194                 ldata->no_room = 0;
195
196                 WARN_RATELIMIT(tty->port->itty == NULL,
197                                 "scheduling with invalid itty\n");
198                 /* see if ldisc has been killed - if so, this means that
199                  * even though the ldisc has been halted and ->buf.work
200                  * cancelled, ->buf.work is about to be rescheduled
201                  */
202                 WARN_RATELIMIT(test_bit(TTY_LDISC_HALTED, &tty->flags),
203                                "scheduling buffer work for halted ldisc\n");
204                 queue_work(system_unbound_wq, &tty->port->buf.work);
205         }
206 }
207
208 static ssize_t chars_in_buffer(struct tty_struct *tty)
209 {
210         struct n_tty_data *ldata = tty->disc_data;
211         ssize_t n = 0;
212
213         if (!ldata->icanon)
214                 n = ldata->commit_head - ldata->read_tail;
215         else
216                 n = ldata->canon_head - ldata->read_tail;
217         return n;
218 }
219
220 /**
221  *      n_tty_write_wakeup      -       asynchronous I/O notifier
222  *      @tty: tty device
223  *
224  *      Required for the ptys, serial driver etc. since processes
225  *      that attach themselves to the master and rely on ASYNC
226  *      IO must be woken up
227  */
228
229 static void n_tty_write_wakeup(struct tty_struct *tty)
230 {
231         if (tty->fasync && test_and_clear_bit(TTY_DO_WRITE_WAKEUP, &tty->flags))
232                 kill_fasync(&tty->fasync, SIGIO, POLL_OUT);
233 }
234
235 static void n_tty_check_throttle(struct tty_struct *tty)
236 {
237         struct n_tty_data *ldata = tty->disc_data;
238
239         /*
240          * Check the remaining room for the input canonicalization
241          * mode.  We don't want to throttle the driver if we're in
242          * canonical mode and don't have a newline yet!
243          */
244         if (ldata->icanon && ldata->canon_head == ldata->read_tail)
245                 return;
246
247         while (1) {
248                 int throttled;
249                 tty_set_flow_change(tty, TTY_THROTTLE_SAFE);
250                 if (N_TTY_BUF_SIZE - read_cnt(ldata) >= TTY_THRESHOLD_THROTTLE)
251                         break;
252                 throttled = tty_throttle_safe(tty);
253                 if (!throttled)
254                         break;
255         }
256         __tty_set_flow_change(tty, 0);
257 }
258
259 static void n_tty_check_unthrottle(struct tty_struct *tty)
260 {
261         if (tty->driver->type == TTY_DRIVER_TYPE_PTY &&
262             tty->link->ldisc->ops->write_wakeup == n_tty_write_wakeup) {
263                 if (chars_in_buffer(tty) > TTY_THRESHOLD_UNTHROTTLE)
264                         return;
265                 if (!tty->count)
266                         return;
267                 n_tty_kick_worker(tty);
268                 n_tty_write_wakeup(tty->link);
269                 if (waitqueue_active(&tty->link->write_wait))
270                         wake_up_interruptible_poll(&tty->link->write_wait, POLLOUT);
271                 return;
272         }
273
274         /* If there is enough space in the read buffer now, let the
275          * low-level driver know. We use chars_in_buffer() to
276          * check the buffer, as it now knows about canonical mode.
277          * Otherwise, if the driver is throttled and the line is
278          * longer than TTY_THRESHOLD_UNTHROTTLE in canonical mode,
279          * we won't get any more characters.
280          */
281
282         while (1) {
283                 int unthrottled;
284                 tty_set_flow_change(tty, TTY_UNTHROTTLE_SAFE);
285                 if (chars_in_buffer(tty) > TTY_THRESHOLD_UNTHROTTLE)
286                         break;
287                 if (!tty->count)
288                         break;
289                 n_tty_kick_worker(tty);
290                 unthrottled = tty_unthrottle_safe(tty);
291                 if (!unthrottled)
292                         break;
293         }
294         __tty_set_flow_change(tty, 0);
295 }
296
297 /**
298  *      put_tty_queue           -       add character to tty
299  *      @c: character
300  *      @ldata: n_tty data
301  *
302  *      Add a character to the tty read_buf queue.
303  *
304  *      n_tty_receive_buf()/producer path:
305  *              caller holds non-exclusive termios_rwsem
306  */
307
308 static inline void put_tty_queue(unsigned char c, struct n_tty_data *ldata)
309 {
310         *read_buf_addr(ldata, ldata->read_head) = c;
311         ldata->read_head++;
312 }
313
314 /**
315  *      reset_buffer_flags      -       reset buffer state
316  *      @tty: terminal to reset
317  *
318  *      Reset the read buffer counters and clear the flags.
319  *      Called from n_tty_open() and n_tty_flush_buffer().
320  *
321  *      Locking: caller holds exclusive termios_rwsem
322  *               (or locking is not required)
323  */
324
325 static void reset_buffer_flags(struct n_tty_data *ldata)
326 {
327         ldata->read_head = ldata->canon_head = ldata->read_tail = 0;
328         ldata->echo_head = ldata->echo_tail = ldata->echo_commit = 0;
329         ldata->commit_head = 0;
330         ldata->echo_mark = 0;
331         ldata->line_start = 0;
332
333         ldata->erasing = 0;
334         bitmap_zero(ldata->read_flags, N_TTY_BUF_SIZE);
335         ldata->push = 0;
336 }
337
338 static void n_tty_packet_mode_flush(struct tty_struct *tty)
339 {
340         unsigned long flags;
341
342         if (tty->link->packet) {
343                 spin_lock_irqsave(&tty->ctrl_lock, flags);
344                 tty->ctrl_status |= TIOCPKT_FLUSHREAD;
345                 spin_unlock_irqrestore(&tty->ctrl_lock, flags);
346                 if (waitqueue_active(&tty->link->read_wait))
347                         wake_up_interruptible(&tty->link->read_wait);
348         }
349 }
350
351 /**
352  *      n_tty_flush_buffer      -       clean input queue
353  *      @tty:   terminal device
354  *
355  *      Flush the input buffer. Called when the tty layer wants the
356  *      buffer flushed (eg at hangup) or when the N_TTY line discipline
357  *      internally has to clean the pending queue (for example some signals).
358  *
359  *      Holds termios_rwsem to exclude producer/consumer while
360  *      buffer indices are reset.
361  *
362  *      Locking: ctrl_lock, exclusive termios_rwsem
363  */
364
365 static void n_tty_flush_buffer(struct tty_struct *tty)
366 {
367         down_write(&tty->termios_rwsem);
368         reset_buffer_flags(tty->disc_data);
369         n_tty_kick_worker(tty);
370
371         if (tty->link)
372                 n_tty_packet_mode_flush(tty);
373         up_write(&tty->termios_rwsem);
374 }
375
376 /**
377  *      n_tty_chars_in_buffer   -       report available bytes
378  *      @tty: tty device
379  *
380  *      Report the number of characters buffered to be delivered to user
381  *      at this instant in time.
382  *
383  *      Locking: exclusive termios_rwsem
384  */
385
386 static ssize_t n_tty_chars_in_buffer(struct tty_struct *tty)
387 {
388         ssize_t n;
389
390         WARN_ONCE(1, "%s is deprecated and scheduled for removal.", __func__);
391
392         down_write(&tty->termios_rwsem);
393         n = chars_in_buffer(tty);
394         up_write(&tty->termios_rwsem);
395         return n;
396 }
397
398 /**
399  *      is_utf8_continuation    -       utf8 multibyte check
400  *      @c: byte to check
401  *
402  *      Returns true if the utf8 character 'c' is a multibyte continuation
403  *      character. We use this to correctly compute the on screen size
404  *      of the character when printing
405  */
406
407 static inline int is_utf8_continuation(unsigned char c)
408 {
409         return (c & 0xc0) == 0x80;
410 }
411
412 /**
413  *      is_continuation         -       multibyte check
414  *      @c: byte to check
415  *
416  *      Returns true if the utf8 character 'c' is a multibyte continuation
417  *      character and the terminal is in unicode mode.
418  */
419
420 static inline int is_continuation(unsigned char c, struct tty_struct *tty)
421 {
422         return I_IUTF8(tty) && is_utf8_continuation(c);
423 }
424
425 /**
426  *      do_output_char                  -       output one character
427  *      @c: character (or partial unicode symbol)
428  *      @tty: terminal device
429  *      @space: space available in tty driver write buffer
430  *
431  *      This is a helper function that handles one output character
432  *      (including special characters like TAB, CR, LF, etc.),
433  *      doing OPOST processing and putting the results in the
434  *      tty driver's write buffer.
435  *
436  *      Note that Linux currently ignores TABDLY, CRDLY, VTDLY, FFDLY
437  *      and NLDLY.  They simply aren't relevant in the world today.
438  *      If you ever need them, add them here.
439  *
440  *      Returns the number of bytes of buffer space used or -1 if
441  *      no space left.
442  *
443  *      Locking: should be called under the output_lock to protect
444  *               the column state and space left in the buffer
445  */
446
447 static int do_output_char(unsigned char c, struct tty_struct *tty, int space)
448 {
449         struct n_tty_data *ldata = tty->disc_data;
450         int     spaces;
451
452         if (!space)
453                 return -1;
454
455         switch (c) {
456         case '\n':
457                 if (O_ONLRET(tty))
458                         ldata->column = 0;
459                 if (O_ONLCR(tty)) {
460                         if (space < 2)
461                                 return -1;
462                         ldata->canon_column = ldata->column = 0;
463                         tty->ops->write(tty, "\r\n", 2);
464                         return 2;
465                 }
466                 ldata->canon_column = ldata->column;
467                 break;
468         case '\r':
469                 if (O_ONOCR(tty) && ldata->column == 0)
470                         return 0;
471                 if (O_OCRNL(tty)) {
472                         c = '\n';
473                         if (O_ONLRET(tty))
474                                 ldata->canon_column = ldata->column = 0;
475                         break;
476                 }
477                 ldata->canon_column = ldata->column = 0;
478                 break;
479         case '\t':
480                 spaces = 8 - (ldata->column & 7);
481                 if (O_TABDLY(tty) == XTABS) {
482                         if (space < spaces)
483                                 return -1;
484                         ldata->column += spaces;
485                         tty->ops->write(tty, "        ", spaces);
486                         return spaces;
487                 }
488                 ldata->column += spaces;
489                 break;
490         case '\b':
491                 if (ldata->column > 0)
492                         ldata->column--;
493                 break;
494         default:
495                 if (!iscntrl(c)) {
496                         if (O_OLCUC(tty))
497                                 c = toupper(c);
498                         if (!is_continuation(c, tty))
499                                 ldata->column++;
500                 }
501                 break;
502         }
503
504         tty_put_char(tty, c);
505         return 1;
506 }
507
508 /**
509  *      process_output                  -       output post processor
510  *      @c: character (or partial unicode symbol)
511  *      @tty: terminal device
512  *
513  *      Output one character with OPOST processing.
514  *      Returns -1 when the output device is full and the character
515  *      must be retried.
516  *
517  *      Locking: output_lock to protect column state and space left
518  *               (also, this is called from n_tty_write under the
519  *                tty layer write lock)
520  */
521
522 static int process_output(unsigned char c, struct tty_struct *tty)
523 {
524         struct n_tty_data *ldata = tty->disc_data;
525         int     space, retval;
526
527         mutex_lock(&ldata->output_lock);
528
529         space = tty_write_room(tty);
530         retval = do_output_char(c, tty, space);
531
532         mutex_unlock(&ldata->output_lock);
533         if (retval < 0)
534                 return -1;
535         else
536                 return 0;
537 }
538
539 /**
540  *      process_output_block            -       block post processor
541  *      @tty: terminal device
542  *      @buf: character buffer
543  *      @nr: number of bytes to output
544  *
545  *      Output a block of characters with OPOST processing.
546  *      Returns the number of characters output.
547  *
548  *      This path is used to speed up block console writes, among other
549  *      things when processing blocks of output data. It handles only
550  *      the simple cases normally found and helps to generate blocks of
551  *      symbols for the console driver and thus improve performance.
552  *
553  *      Locking: output_lock to protect column state and space left
554  *               (also, this is called from n_tty_write under the
555  *                tty layer write lock)
556  */
557
558 static ssize_t process_output_block(struct tty_struct *tty,
559                                     const unsigned char *buf, unsigned int nr)
560 {
561         struct n_tty_data *ldata = tty->disc_data;
562         int     space;
563         int     i;
564         const unsigned char *cp;
565
566         mutex_lock(&ldata->output_lock);
567
568         space = tty_write_room(tty);
569         if (!space) {
570                 mutex_unlock(&ldata->output_lock);
571                 return 0;
572         }
573         if (nr > space)
574                 nr = space;
575
576         for (i = 0, cp = buf; i < nr; i++, cp++) {
577                 unsigned char c = *cp;
578
579                 switch (c) {
580                 case '\n':
581                         if (O_ONLRET(tty))
582                                 ldata->column = 0;
583                         if (O_ONLCR(tty))
584                                 goto break_out;
585                         ldata->canon_column = ldata->column;
586                         break;
587                 case '\r':
588                         if (O_ONOCR(tty) && ldata->column == 0)
589                                 goto break_out;
590                         if (O_OCRNL(tty))
591                                 goto break_out;
592                         ldata->canon_column = ldata->column = 0;
593                         break;
594                 case '\t':
595                         goto break_out;
596                 case '\b':
597                         if (ldata->column > 0)
598                                 ldata->column--;
599                         break;
600                 default:
601                         if (!iscntrl(c)) {
602                                 if (O_OLCUC(tty))
603                                         goto break_out;
604                                 if (!is_continuation(c, tty))
605                                         ldata->column++;
606                         }
607                         break;
608                 }
609         }
610 break_out:
611         i = tty->ops->write(tty, buf, i);
612
613         mutex_unlock(&ldata->output_lock);
614         return i;
615 }
616
617 /**
618  *      process_echoes  -       write pending echo characters
619  *      @tty: terminal device
620  *
621  *      Write previously buffered echo (and other ldisc-generated)
622  *      characters to the tty.
623  *
624  *      Characters generated by the ldisc (including echoes) need to
625  *      be buffered because the driver's write buffer can fill during
626  *      heavy program output.  Echoing straight to the driver will
627  *      often fail under these conditions, causing lost characters and
628  *      resulting mismatches of ldisc state information.
629  *
630  *      Since the ldisc state must represent the characters actually sent
631  *      to the driver at the time of the write, operations like certain
632  *      changes in column state are also saved in the buffer and executed
633  *      here.
634  *
635  *      A circular fifo buffer is used so that the most recent characters
636  *      are prioritized.  Also, when control characters are echoed with a
637  *      prefixed "^", the pair is treated atomically and thus not separated.
638  *
639  *      Locking: callers must hold output_lock
640  */
641
642 static size_t __process_echoes(struct tty_struct *tty)
643 {
644         struct n_tty_data *ldata = tty->disc_data;
645         int     space, old_space;
646         size_t tail;
647         unsigned char c;
648
649         old_space = space = tty_write_room(tty);
650
651         tail = ldata->echo_tail;
652         while (ldata->echo_commit != tail) {
653                 c = echo_buf(ldata, tail);
654                 if (c == ECHO_OP_START) {
655                         unsigned char op;
656                         int no_space_left = 0;
657
658                         /*
659                          * If the buffer byte is the start of a multi-byte
660                          * operation, get the next byte, which is either the
661                          * op code or a control character value.
662                          */
663                         op = echo_buf(ldata, tail + 1);
664
665                         switch (op) {
666                                 unsigned int num_chars, num_bs;
667
668                         case ECHO_OP_ERASE_TAB:
669                                 num_chars = echo_buf(ldata, tail + 2);
670
671                                 /*
672                                  * Determine how many columns to go back
673                                  * in order to erase the tab.
674                                  * This depends on the number of columns
675                                  * used by other characters within the tab
676                                  * area.  If this (modulo 8) count is from
677                                  * the start of input rather than from a
678                                  * previous tab, we offset by canon column.
679                                  * Otherwise, tab spacing is normal.
680                                  */
681                                 if (!(num_chars & 0x80))
682                                         num_chars += ldata->canon_column;
683                                 num_bs = 8 - (num_chars & 7);
684
685                                 if (num_bs > space) {
686                                         no_space_left = 1;
687                                         break;
688                                 }
689                                 space -= num_bs;
690                                 while (num_bs--) {
691                                         tty_put_char(tty, '\b');
692                                         if (ldata->column > 0)
693                                                 ldata->column--;
694                                 }
695                                 tail += 3;
696                                 break;
697
698                         case ECHO_OP_SET_CANON_COL:
699                                 ldata->canon_column = ldata->column;
700                                 tail += 2;
701                                 break;
702
703                         case ECHO_OP_MOVE_BACK_COL:
704                                 if (ldata->column > 0)
705                                         ldata->column--;
706                                 tail += 2;
707                                 break;
708
709                         case ECHO_OP_START:
710                                 /* This is an escaped echo op start code */
711                                 if (!space) {
712                                         no_space_left = 1;
713                                         break;
714                                 }
715                                 tty_put_char(tty, ECHO_OP_START);
716                                 ldata->column++;
717                                 space--;
718                                 tail += 2;
719                                 break;
720
721                         default:
722                                 /*
723                                  * If the op is not a special byte code,
724                                  * it is a ctrl char tagged to be echoed
725                                  * as "^X" (where X is the letter
726                                  * representing the control char).
727                                  * Note that we must ensure there is
728                                  * enough space for the whole ctrl pair.
729                                  *
730                                  */
731                                 if (space < 2) {
732                                         no_space_left = 1;
733                                         break;
734                                 }
735                                 tty_put_char(tty, '^');
736                                 tty_put_char(tty, op ^ 0100);
737                                 ldata->column += 2;
738                                 space -= 2;
739                                 tail += 2;
740                         }
741
742                         if (no_space_left)
743                                 break;
744                 } else {
745                         if (O_OPOST(tty)) {
746                                 int retval = do_output_char(c, tty, space);
747                                 if (retval < 0)
748                                         break;
749                                 space -= retval;
750                         } else {
751                                 if (!space)
752                                         break;
753                                 tty_put_char(tty, c);
754                                 space -= 1;
755                         }
756                         tail += 1;
757                 }
758         }
759
760         /* If the echo buffer is nearly full (so that the possibility exists
761          * of echo overrun before the next commit), then discard enough
762          * data at the tail to prevent a subsequent overrun */
763         while (ldata->echo_commit - tail >= ECHO_DISCARD_WATERMARK) {
764                 if (echo_buf(ldata, tail) == ECHO_OP_START) {
765                         if (echo_buf(ldata, tail + 1) == ECHO_OP_ERASE_TAB)
766                                 tail += 3;
767                         else
768                                 tail += 2;
769                 } else
770                         tail++;
771         }
772
773         ldata->echo_tail = tail;
774         return old_space - space;
775 }
776
777 static void commit_echoes(struct tty_struct *tty)
778 {
779         struct n_tty_data *ldata = tty->disc_data;
780         size_t nr, old, echoed;
781         size_t head;
782
783         head = ldata->echo_head;
784         ldata->echo_mark = head;
785         old = ldata->echo_commit - ldata->echo_tail;
786
787         /* Process committed echoes if the accumulated # of bytes
788          * is over the threshold (and try again each time another
789          * block is accumulated) */
790         nr = head - ldata->echo_tail;
791         if (nr < ECHO_COMMIT_WATERMARK || (nr % ECHO_BLOCK > old % ECHO_BLOCK))
792                 return;
793
794         mutex_lock(&ldata->output_lock);
795         ldata->echo_commit = head;
796         echoed = __process_echoes(tty);
797         mutex_unlock(&ldata->output_lock);
798
799         if (echoed && tty->ops->flush_chars)
800                 tty->ops->flush_chars(tty);
801 }
802
803 static void process_echoes(struct tty_struct *tty)
804 {
805         struct n_tty_data *ldata = tty->disc_data;
806         size_t echoed;
807
808         if (ldata->echo_mark == ldata->echo_tail)
809                 return;
810
811         mutex_lock(&ldata->output_lock);
812         ldata->echo_commit = ldata->echo_mark;
813         echoed = __process_echoes(tty);
814         mutex_unlock(&ldata->output_lock);
815
816         if (echoed && tty->ops->flush_chars)
817                 tty->ops->flush_chars(tty);
818 }
819
820 /* NB: echo_mark and echo_head should be equivalent here */
821 static void flush_echoes(struct tty_struct *tty)
822 {
823         struct n_tty_data *ldata = tty->disc_data;
824
825         if ((!L_ECHO(tty) && !L_ECHONL(tty)) ||
826             ldata->echo_commit == ldata->echo_head)
827                 return;
828
829         mutex_lock(&ldata->output_lock);
830         ldata->echo_commit = ldata->echo_head;
831         __process_echoes(tty);
832         mutex_unlock(&ldata->output_lock);
833 }
834
835 /**
836  *      add_echo_byte   -       add a byte to the echo buffer
837  *      @c: unicode byte to echo
838  *      @ldata: n_tty data
839  *
840  *      Add a character or operation byte to the echo buffer.
841  */
842
843 static inline void add_echo_byte(unsigned char c, struct n_tty_data *ldata)
844 {
845         *echo_buf_addr(ldata, ldata->echo_head++) = c;
846 }
847
848 /**
849  *      echo_move_back_col      -       add operation to move back a column
850  *      @ldata: n_tty data
851  *
852  *      Add an operation to the echo buffer to move back one column.
853  */
854
855 static void echo_move_back_col(struct n_tty_data *ldata)
856 {
857         add_echo_byte(ECHO_OP_START, ldata);
858         add_echo_byte(ECHO_OP_MOVE_BACK_COL, ldata);
859 }
860
861 /**
862  *      echo_set_canon_col      -       add operation to set the canon column
863  *      @ldata: n_tty data
864  *
865  *      Add an operation to the echo buffer to set the canon column
866  *      to the current column.
867  */
868
869 static void echo_set_canon_col(struct n_tty_data *ldata)
870 {
871         add_echo_byte(ECHO_OP_START, ldata);
872         add_echo_byte(ECHO_OP_SET_CANON_COL, ldata);
873 }
874
875 /**
876  *      echo_erase_tab  -       add operation to erase a tab
877  *      @num_chars: number of character columns already used
878  *      @after_tab: true if num_chars starts after a previous tab
879  *      @ldata: n_tty data
880  *
881  *      Add an operation to the echo buffer to erase a tab.
882  *
883  *      Called by the eraser function, which knows how many character
884  *      columns have been used since either a previous tab or the start
885  *      of input.  This information will be used later, along with
886  *      canon column (if applicable), to go back the correct number
887  *      of columns.
888  */
889
890 static void echo_erase_tab(unsigned int num_chars, int after_tab,
891                            struct n_tty_data *ldata)
892 {
893         add_echo_byte(ECHO_OP_START, ldata);
894         add_echo_byte(ECHO_OP_ERASE_TAB, ldata);
895
896         /* We only need to know this modulo 8 (tab spacing) */
897         num_chars &= 7;
898
899         /* Set the high bit as a flag if num_chars is after a previous tab */
900         if (after_tab)
901                 num_chars |= 0x80;
902
903         add_echo_byte(num_chars, ldata);
904 }
905
906 /**
907  *      echo_char_raw   -       echo a character raw
908  *      @c: unicode byte to echo
909  *      @tty: terminal device
910  *
911  *      Echo user input back onto the screen. This must be called only when
912  *      L_ECHO(tty) is true. Called from the driver receive_buf path.
913  *
914  *      This variant does not treat control characters specially.
915  */
916
917 static void echo_char_raw(unsigned char c, struct n_tty_data *ldata)
918 {
919         if (c == ECHO_OP_START) {
920                 add_echo_byte(ECHO_OP_START, ldata);
921                 add_echo_byte(ECHO_OP_START, ldata);
922         } else {
923                 add_echo_byte(c, ldata);
924         }
925 }
926
927 /**
928  *      echo_char       -       echo a character
929  *      @c: unicode byte to echo
930  *      @tty: terminal device
931  *
932  *      Echo user input back onto the screen. This must be called only when
933  *      L_ECHO(tty) is true. Called from the driver receive_buf path.
934  *
935  *      This variant tags control characters to be echoed as "^X"
936  *      (where X is the letter representing the control char).
937  */
938
939 static void echo_char(unsigned char c, struct tty_struct *tty)
940 {
941         struct n_tty_data *ldata = tty->disc_data;
942
943         if (c == ECHO_OP_START) {
944                 add_echo_byte(ECHO_OP_START, ldata);
945                 add_echo_byte(ECHO_OP_START, ldata);
946         } else {
947                 if (L_ECHOCTL(tty) && iscntrl(c) && c != '\t')
948                         add_echo_byte(ECHO_OP_START, ldata);
949                 add_echo_byte(c, ldata);
950         }
951 }
952
953 /**
954  *      finish_erasing          -       complete erase
955  *      @ldata: n_tty data
956  */
957
958 static inline void finish_erasing(struct n_tty_data *ldata)
959 {
960         if (ldata->erasing) {
961                 echo_char_raw('/', ldata);
962                 ldata->erasing = 0;
963         }
964 }
965
966 /**
967  *      eraser          -       handle erase function
968  *      @c: character input
969  *      @tty: terminal device
970  *
971  *      Perform erase and necessary output when an erase character is
972  *      present in the stream from the driver layer. Handles the complexities
973  *      of UTF-8 multibyte symbols.
974  *
975  *      n_tty_receive_buf()/producer path:
976  *              caller holds non-exclusive termios_rwsem
977  */
978
979 static void eraser(unsigned char c, struct tty_struct *tty)
980 {
981         struct n_tty_data *ldata = tty->disc_data;
982         enum { ERASE, WERASE, KILL } kill_type;
983         size_t head;
984         size_t cnt;
985         int seen_alnums;
986
987         if (ldata->read_head == ldata->canon_head) {
988                 /* process_output('\a', tty); */ /* what do you think? */
989                 return;
990         }
991         if (c == ERASE_CHAR(tty))
992                 kill_type = ERASE;
993         else if (c == WERASE_CHAR(tty))
994                 kill_type = WERASE;
995         else {
996                 if (!L_ECHO(tty)) {
997                         ldata->read_head = ldata->canon_head;
998                         return;
999                 }
1000                 if (!L_ECHOK(tty) || !L_ECHOKE(tty) || !L_ECHOE(tty)) {
1001                         ldata->read_head = ldata->canon_head;
1002                         finish_erasing(ldata);
1003                         echo_char(KILL_CHAR(tty), tty);
1004                         /* Add a newline if ECHOK is on and ECHOKE is off. */
1005                         if (L_ECHOK(tty))
1006                                 echo_char_raw('\n', ldata);
1007                         return;
1008                 }
1009                 kill_type = KILL;
1010         }
1011
1012         seen_alnums = 0;
1013         while (ldata->read_head != ldata->canon_head) {
1014                 head = ldata->read_head;
1015
1016                 /* erase a single possibly multibyte character */
1017                 do {
1018                         head--;
1019                         c = read_buf(ldata, head);
1020                 } while (is_continuation(c, tty) && head != ldata->canon_head);
1021
1022                 /* do not partially erase */
1023                 if (is_continuation(c, tty))
1024                         break;
1025
1026                 if (kill_type == WERASE) {
1027                         /* Equivalent to BSD's ALTWERASE. */
1028                         if (isalnum(c) || c == '_')
1029                                 seen_alnums++;
1030                         else if (seen_alnums)
1031                                 break;
1032                 }
1033                 cnt = ldata->read_head - head;
1034                 ldata->read_head = head;
1035                 if (L_ECHO(tty)) {
1036                         if (L_ECHOPRT(tty)) {
1037                                 if (!ldata->erasing) {
1038                                         echo_char_raw('\\', ldata);
1039                                         ldata->erasing = 1;
1040                                 }
1041                                 /* if cnt > 1, output a multi-byte character */
1042                                 echo_char(c, tty);
1043                                 while (--cnt > 0) {
1044                                         head++;
1045                                         echo_char_raw(read_buf(ldata, head), ldata);
1046                                         echo_move_back_col(ldata);
1047                                 }
1048                         } else if (kill_type == ERASE && !L_ECHOE(tty)) {
1049                                 echo_char(ERASE_CHAR(tty), tty);
1050                         } else if (c == '\t') {
1051                                 unsigned int num_chars = 0;
1052                                 int after_tab = 0;
1053                                 size_t tail = ldata->read_head;
1054
1055                                 /*
1056                                  * Count the columns used for characters
1057                                  * since the start of input or after a
1058                                  * previous tab.
1059                                  * This info is used to go back the correct
1060                                  * number of columns.
1061                                  */
1062                                 while (tail != ldata->canon_head) {
1063                                         tail--;
1064                                         c = read_buf(ldata, tail);
1065                                         if (c == '\t') {
1066                                                 after_tab = 1;
1067                                                 break;
1068                                         } else if (iscntrl(c)) {
1069                                                 if (L_ECHOCTL(tty))
1070                                                         num_chars += 2;
1071                                         } else if (!is_continuation(c, tty)) {
1072                                                 num_chars++;
1073                                         }
1074                                 }
1075                                 echo_erase_tab(num_chars, after_tab, ldata);
1076                         } else {
1077                                 if (iscntrl(c) && L_ECHOCTL(tty)) {
1078                                         echo_char_raw('\b', ldata);
1079                                         echo_char_raw(' ', ldata);
1080                                         echo_char_raw('\b', ldata);
1081                                 }
1082                                 if (!iscntrl(c) || L_ECHOCTL(tty)) {
1083                                         echo_char_raw('\b', ldata);
1084                                         echo_char_raw(' ', ldata);
1085                                         echo_char_raw('\b', ldata);
1086                                 }
1087                         }
1088                 }
1089                 if (kill_type == ERASE)
1090                         break;
1091         }
1092         if (ldata->read_head == ldata->canon_head && L_ECHO(tty))
1093                 finish_erasing(ldata);
1094 }
1095
1096 /**
1097  *      isig            -       handle the ISIG optio
1098  *      @sig: signal
1099  *      @tty: terminal
1100  *
1101  *      Called when a signal is being sent due to terminal input.
1102  *      Called from the driver receive_buf path so serialized.
1103  *
1104  *      Performs input and output flush if !NOFLSH. In this context, the echo
1105  *      buffer is 'output'. The signal is processed first to alert any current
1106  *      readers or writers to discontinue and exit their i/o loops.
1107  *
1108  *      Locking: ctrl_lock
1109  */
1110
1111 static void isig(int sig, struct tty_struct *tty)
1112 {
1113         struct n_tty_data *ldata = tty->disc_data;
1114         struct pid *tty_pgrp = tty_get_pgrp(tty);
1115         if (tty_pgrp) {
1116                 kill_pgrp(tty_pgrp, sig, 1);
1117                 put_pid(tty_pgrp);
1118         }
1119
1120         if (!L_NOFLSH(tty)) {
1121                 up_read(&tty->termios_rwsem);
1122                 down_write(&tty->termios_rwsem);
1123
1124                 /* clear echo buffer */
1125                 mutex_lock(&ldata->output_lock);
1126                 ldata->echo_head = ldata->echo_tail = 0;
1127                 ldata->echo_mark = ldata->echo_commit = 0;
1128                 mutex_unlock(&ldata->output_lock);
1129
1130                 /* clear output buffer */
1131                 tty_driver_flush_buffer(tty);
1132
1133                 /* clear input buffer */
1134                 reset_buffer_flags(tty->disc_data);
1135
1136                 /* notify pty master of flush */
1137                 if (tty->link)
1138                         n_tty_packet_mode_flush(tty);
1139
1140                 up_write(&tty->termios_rwsem);
1141                 down_read(&tty->termios_rwsem);
1142         }
1143 }
1144
1145 /**
1146  *      n_tty_receive_break     -       handle break
1147  *      @tty: terminal
1148  *
1149  *      An RS232 break event has been hit in the incoming bitstream. This
1150  *      can cause a variety of events depending upon the termios settings.
1151  *
1152  *      n_tty_receive_buf()/producer path:
1153  *              caller holds non-exclusive termios_rwsem
1154  *
1155  *      Note: may get exclusive termios_rwsem if flushing input buffer
1156  */
1157
1158 static void n_tty_receive_break(struct tty_struct *tty)
1159 {
1160         struct n_tty_data *ldata = tty->disc_data;
1161
1162         if (I_IGNBRK(tty))
1163                 return;
1164         if (I_BRKINT(tty)) {
1165                 isig(SIGINT, tty);
1166                 return;
1167         }
1168         if (I_PARMRK(tty)) {
1169                 put_tty_queue('\377', ldata);
1170                 put_tty_queue('\0', ldata);
1171         }
1172         put_tty_queue('\0', ldata);
1173         if (waitqueue_active(&tty->read_wait))
1174                 wake_up_interruptible_poll(&tty->read_wait, POLLIN);
1175 }
1176
1177 /**
1178  *      n_tty_receive_overrun   -       handle overrun reporting
1179  *      @tty: terminal
1180  *
1181  *      Data arrived faster than we could process it. While the tty
1182  *      driver has flagged this the bits that were missed are gone
1183  *      forever.
1184  *
1185  *      Called from the receive_buf path so single threaded. Does not
1186  *      need locking as num_overrun and overrun_time are function
1187  *      private.
1188  */
1189
1190 static void n_tty_receive_overrun(struct tty_struct *tty)
1191 {
1192         struct n_tty_data *ldata = tty->disc_data;
1193
1194         ldata->num_overrun++;
1195         if (time_after(jiffies, ldata->overrun_time + HZ) ||
1196                         time_after(ldata->overrun_time, jiffies)) {
1197                 printk(KERN_WARNING "%s: %d input overrun(s)\n",
1198                         tty_name(tty),
1199                         ldata->num_overrun);
1200                 ldata->overrun_time = jiffies;
1201                 ldata->num_overrun = 0;
1202         }
1203 }
1204
1205 /**
1206  *      n_tty_receive_parity_error      -       error notifier
1207  *      @tty: terminal device
1208  *      @c: character
1209  *
1210  *      Process a parity error and queue the right data to indicate
1211  *      the error case if necessary.
1212  *
1213  *      n_tty_receive_buf()/producer path:
1214  *              caller holds non-exclusive termios_rwsem
1215  */
1216 static void n_tty_receive_parity_error(struct tty_struct *tty, unsigned char c)
1217 {
1218         struct n_tty_data *ldata = tty->disc_data;
1219
1220         if (I_INPCK(tty)) {
1221                 if (I_IGNPAR(tty))
1222                         return;
1223                 if (I_PARMRK(tty)) {
1224                         put_tty_queue('\377', ldata);
1225                         put_tty_queue('\0', ldata);
1226                         put_tty_queue(c, ldata);
1227                 } else
1228                         put_tty_queue('\0', ldata);
1229         } else
1230                 put_tty_queue(c, ldata);
1231         if (waitqueue_active(&tty->read_wait))
1232                 wake_up_interruptible_poll(&tty->read_wait, POLLIN);
1233 }
1234
1235 static void
1236 n_tty_receive_signal_char(struct tty_struct *tty, int signal, unsigned char c)
1237 {
1238         isig(signal, tty);
1239         if (I_IXON(tty))
1240                 start_tty(tty);
1241         if (L_ECHO(tty)) {
1242                 echo_char(c, tty);
1243                 commit_echoes(tty);
1244         } else
1245                 process_echoes(tty);
1246         return;
1247 }
1248
1249 /**
1250  *      n_tty_receive_char      -       perform processing
1251  *      @tty: terminal device
1252  *      @c: character
1253  *
1254  *      Process an individual character of input received from the driver.
1255  *      This is serialized with respect to itself by the rules for the
1256  *      driver above.
1257  *
1258  *      n_tty_receive_buf()/producer path:
1259  *              caller holds non-exclusive termios_rwsem
1260  *              publishes canon_head if canonical mode is active
1261  *
1262  *      Returns 1 if LNEXT was received, else returns 0
1263  */
1264
1265 static int
1266 n_tty_receive_char_special(struct tty_struct *tty, unsigned char c)
1267 {
1268         struct n_tty_data *ldata = tty->disc_data;
1269
1270         if (I_IXON(tty)) {
1271                 if (c == START_CHAR(tty)) {
1272                         start_tty(tty);
1273                         process_echoes(tty);
1274                         return 0;
1275                 }
1276                 if (c == STOP_CHAR(tty)) {
1277                         stop_tty(tty);
1278                         return 0;
1279                 }
1280         }
1281
1282         if (L_ISIG(tty)) {
1283                 if (c == INTR_CHAR(tty)) {
1284                         n_tty_receive_signal_char(tty, SIGINT, c);
1285                         return 0;
1286                 } else if (c == QUIT_CHAR(tty)) {
1287                         n_tty_receive_signal_char(tty, SIGQUIT, c);
1288                         return 0;
1289                 } else if (c == SUSP_CHAR(tty)) {
1290                         n_tty_receive_signal_char(tty, SIGTSTP, c);
1291                         return 0;
1292                 }
1293         }
1294
1295         if (tty->stopped && !tty->flow_stopped && I_IXON(tty) && I_IXANY(tty)) {
1296                 start_tty(tty);
1297                 process_echoes(tty);
1298         }
1299
1300         if (c == '\r') {
1301                 if (I_IGNCR(tty))
1302                         return 0;
1303                 if (I_ICRNL(tty))
1304                         c = '\n';
1305         } else if (c == '\n' && I_INLCR(tty))
1306                 c = '\r';
1307
1308         if (ldata->icanon) {
1309                 if (c == ERASE_CHAR(tty) || c == KILL_CHAR(tty) ||
1310                     (c == WERASE_CHAR(tty) && L_IEXTEN(tty))) {
1311                         eraser(c, tty);
1312                         commit_echoes(tty);
1313                         return 0;
1314                 }
1315                 if (c == LNEXT_CHAR(tty) && L_IEXTEN(tty)) {
1316                         ldata->lnext = 1;
1317                         if (L_ECHO(tty)) {
1318                                 finish_erasing(ldata);
1319                                 if (L_ECHOCTL(tty)) {
1320                                         echo_char_raw('^', ldata);
1321                                         echo_char_raw('\b', ldata);
1322                                         commit_echoes(tty);
1323                                 }
1324                         }
1325                         return 1;
1326                 }
1327                 if (c == REPRINT_CHAR(tty) && L_ECHO(tty) && L_IEXTEN(tty)) {
1328                         size_t tail = ldata->canon_head;
1329
1330                         finish_erasing(ldata);
1331                         echo_char(c, tty);
1332                         echo_char_raw('\n', ldata);
1333                         while (tail != ldata->read_head) {
1334                                 echo_char(read_buf(ldata, tail), tty);
1335                                 tail++;
1336                         }
1337                         commit_echoes(tty);
1338                         return 0;
1339                 }
1340                 if (c == '\n') {
1341                         if (L_ECHO(tty) || L_ECHONL(tty)) {
1342                                 echo_char_raw('\n', ldata);
1343                                 commit_echoes(tty);
1344                         }
1345                         goto handle_newline;
1346                 }
1347                 if (c == EOF_CHAR(tty)) {
1348                         c = __DISABLED_CHAR;
1349                         goto handle_newline;
1350                 }
1351                 if ((c == EOL_CHAR(tty)) ||
1352                     (c == EOL2_CHAR(tty) && L_IEXTEN(tty))) {
1353                         /*
1354                          * XXX are EOL_CHAR and EOL2_CHAR echoed?!?
1355                          */
1356                         if (L_ECHO(tty)) {
1357                                 /* Record the column of first canon char. */
1358                                 if (ldata->canon_head == ldata->read_head)
1359                                         echo_set_canon_col(ldata);
1360                                 echo_char(c, tty);
1361                                 commit_echoes(tty);
1362                         }
1363                         /*
1364                          * XXX does PARMRK doubling happen for
1365                          * EOL_CHAR and EOL2_CHAR?
1366                          */
1367                         if (c == (unsigned char) '\377' && I_PARMRK(tty))
1368                                 put_tty_queue(c, ldata);
1369
1370 handle_newline:
1371                         set_bit(ldata->read_head & (N_TTY_BUF_SIZE - 1), ldata->read_flags);
1372                         put_tty_queue(c, ldata);
1373                         smp_store_release(&ldata->canon_head, ldata->read_head);
1374                         kill_fasync(&tty->fasync, SIGIO, POLL_IN);
1375                         if (waitqueue_active(&tty->read_wait))
1376                                 wake_up_interruptible_poll(&tty->read_wait, POLLIN);
1377                         return 0;
1378                 }
1379         }
1380
1381         if (L_ECHO(tty)) {
1382                 finish_erasing(ldata);
1383                 if (c == '\n')
1384                         echo_char_raw('\n', ldata);
1385                 else {
1386                         /* Record the column of first canon char. */
1387                         if (ldata->canon_head == ldata->read_head)
1388                                 echo_set_canon_col(ldata);
1389                         echo_char(c, tty);
1390                 }
1391                 commit_echoes(tty);
1392         }
1393
1394         /* PARMRK doubling check */
1395         if (c == (unsigned char) '\377' && I_PARMRK(tty))
1396                 put_tty_queue(c, ldata);
1397
1398         put_tty_queue(c, ldata);
1399         return 0;
1400 }
1401
1402 static inline void
1403 n_tty_receive_char_inline(struct tty_struct *tty, unsigned char c)
1404 {
1405         struct n_tty_data *ldata = tty->disc_data;
1406
1407         if (tty->stopped && !tty->flow_stopped && I_IXON(tty) && I_IXANY(tty)) {
1408                 start_tty(tty);
1409                 process_echoes(tty);
1410         }
1411         if (L_ECHO(tty)) {
1412                 finish_erasing(ldata);
1413                 /* Record the column of first canon char. */
1414                 if (ldata->canon_head == ldata->read_head)
1415                         echo_set_canon_col(ldata);
1416                 echo_char(c, tty);
1417                 commit_echoes(tty);
1418         }
1419         /* PARMRK doubling check */
1420         if (c == (unsigned char) '\377' && I_PARMRK(tty))
1421                 put_tty_queue(c, ldata);
1422         put_tty_queue(c, ldata);
1423 }
1424
1425 static void n_tty_receive_char(struct tty_struct *tty, unsigned char c)
1426 {
1427         n_tty_receive_char_inline(tty, c);
1428 }
1429
1430 static inline void
1431 n_tty_receive_char_fast(struct tty_struct *tty, unsigned char c)
1432 {
1433         struct n_tty_data *ldata = tty->disc_data;
1434
1435         if (tty->stopped && !tty->flow_stopped && I_IXON(tty) && I_IXANY(tty)) {
1436                 start_tty(tty);
1437                 process_echoes(tty);
1438         }
1439         if (L_ECHO(tty)) {
1440                 finish_erasing(ldata);
1441                 /* Record the column of first canon char. */
1442                 if (ldata->canon_head == ldata->read_head)
1443                         echo_set_canon_col(ldata);
1444                 echo_char(c, tty);
1445                 commit_echoes(tty);
1446         }
1447         put_tty_queue(c, ldata);
1448 }
1449
1450 static void n_tty_receive_char_closing(struct tty_struct *tty, unsigned char c)
1451 {
1452         if (I_ISTRIP(tty))
1453                 c &= 0x7f;
1454         if (I_IUCLC(tty) && L_IEXTEN(tty))
1455                 c = tolower(c);
1456
1457         if (I_IXON(tty)) {
1458                 if (c == STOP_CHAR(tty))
1459                         stop_tty(tty);
1460                 else if (c == START_CHAR(tty) ||
1461                          (tty->stopped && !tty->flow_stopped && I_IXANY(tty) &&
1462                           c != INTR_CHAR(tty) && c != QUIT_CHAR(tty) &&
1463                           c != SUSP_CHAR(tty))) {
1464                         start_tty(tty);
1465                         process_echoes(tty);
1466                 }
1467         }
1468 }
1469
1470 static void
1471 n_tty_receive_char_flagged(struct tty_struct *tty, unsigned char c, char flag)
1472 {
1473         switch (flag) {
1474         case TTY_BREAK:
1475                 n_tty_receive_break(tty);
1476                 break;
1477         case TTY_PARITY:
1478         case TTY_FRAME:
1479                 n_tty_receive_parity_error(tty, c);
1480                 break;
1481         case TTY_OVERRUN:
1482                 n_tty_receive_overrun(tty);
1483                 break;
1484         default:
1485                 printk(KERN_ERR "%s: unknown flag %d\n",
1486                        tty_name(tty), flag);
1487                 break;
1488         }
1489 }
1490
1491 static void
1492 n_tty_receive_char_lnext(struct tty_struct *tty, unsigned char c, char flag)
1493 {
1494         struct n_tty_data *ldata = tty->disc_data;
1495
1496         ldata->lnext = 0;
1497         if (likely(flag == TTY_NORMAL)) {
1498                 if (I_ISTRIP(tty))
1499                         c &= 0x7f;
1500                 if (I_IUCLC(tty) && L_IEXTEN(tty))
1501                         c = tolower(c);
1502                 n_tty_receive_char(tty, c);
1503         } else
1504                 n_tty_receive_char_flagged(tty, c, flag);
1505 }
1506
1507 static void
1508 n_tty_receive_buf_real_raw(struct tty_struct *tty, const unsigned char *cp,
1509                            char *fp, int count)
1510 {
1511         struct n_tty_data *ldata = tty->disc_data;
1512         size_t n, head;
1513
1514         head = ldata->read_head & (N_TTY_BUF_SIZE - 1);
1515         n = min_t(size_t, count, N_TTY_BUF_SIZE - head);
1516         memcpy(read_buf_addr(ldata, head), cp, n);
1517         ldata->read_head += n;
1518         cp += n;
1519         count -= n;
1520
1521         head = ldata->read_head & (N_TTY_BUF_SIZE - 1);
1522         n = min_t(size_t, count, N_TTY_BUF_SIZE - head);
1523         memcpy(read_buf_addr(ldata, head), cp, n);
1524         ldata->read_head += n;
1525 }
1526
1527 static void
1528 n_tty_receive_buf_raw(struct tty_struct *tty, const unsigned char *cp,
1529                       char *fp, int count)
1530 {
1531         struct n_tty_data *ldata = tty->disc_data;
1532         char flag = TTY_NORMAL;
1533
1534         while (count--) {
1535                 if (fp)
1536                         flag = *fp++;
1537                 if (likely(flag == TTY_NORMAL))
1538                         put_tty_queue(*cp++, ldata);
1539                 else
1540                         n_tty_receive_char_flagged(tty, *cp++, flag);
1541         }
1542 }
1543
1544 static void
1545 n_tty_receive_buf_closing(struct tty_struct *tty, const unsigned char *cp,
1546                           char *fp, int count)
1547 {
1548         char flag = TTY_NORMAL;
1549
1550         while (count--) {
1551                 if (fp)
1552                         flag = *fp++;
1553                 if (likely(flag == TTY_NORMAL))
1554                         n_tty_receive_char_closing(tty, *cp++);
1555                 else
1556                         n_tty_receive_char_flagged(tty, *cp++, flag);
1557         }
1558 }
1559
1560 static void
1561 n_tty_receive_buf_standard(struct tty_struct *tty, const unsigned char *cp,
1562                           char *fp, int count)
1563 {
1564         struct n_tty_data *ldata = tty->disc_data;
1565         char flag = TTY_NORMAL;
1566
1567         while (count--) {
1568                 if (fp)
1569                         flag = *fp++;
1570                 if (likely(flag == TTY_NORMAL)) {
1571                         unsigned char c = *cp++;
1572
1573                         if (I_ISTRIP(tty))
1574                                 c &= 0x7f;
1575                         if (I_IUCLC(tty) && L_IEXTEN(tty))
1576                                 c = tolower(c);
1577                         if (L_EXTPROC(tty)) {
1578                                 put_tty_queue(c, ldata);
1579                                 continue;
1580                         }
1581                         if (!test_bit(c, ldata->char_map))
1582                                 n_tty_receive_char_inline(tty, c);
1583                         else if (n_tty_receive_char_special(tty, c) && count) {
1584                                 if (fp)
1585                                         flag = *fp++;
1586                                 n_tty_receive_char_lnext(tty, *cp++, flag);
1587                                 count--;
1588                         }
1589                 } else
1590                         n_tty_receive_char_flagged(tty, *cp++, flag);
1591         }
1592 }
1593
1594 static void
1595 n_tty_receive_buf_fast(struct tty_struct *tty, const unsigned char *cp,
1596                        char *fp, int count)
1597 {
1598         struct n_tty_data *ldata = tty->disc_data;
1599         char flag = TTY_NORMAL;
1600
1601         while (count--) {
1602                 if (fp)
1603                         flag = *fp++;
1604                 if (likely(flag == TTY_NORMAL)) {
1605                         unsigned char c = *cp++;
1606
1607                         if (!test_bit(c, ldata->char_map))
1608                                 n_tty_receive_char_fast(tty, c);
1609                         else if (n_tty_receive_char_special(tty, c) && count) {
1610                                 if (fp)
1611                                         flag = *fp++;
1612                                 n_tty_receive_char_lnext(tty, *cp++, flag);
1613                                 count--;
1614                         }
1615                 } else
1616                         n_tty_receive_char_flagged(tty, *cp++, flag);
1617         }
1618 }
1619
1620 static void __receive_buf(struct tty_struct *tty, const unsigned char *cp,
1621                           char *fp, int count)
1622 {
1623         struct n_tty_data *ldata = tty->disc_data;
1624         bool preops = I_ISTRIP(tty) || (I_IUCLC(tty) && L_IEXTEN(tty));
1625
1626         if (ldata->real_raw)
1627                 n_tty_receive_buf_real_raw(tty, cp, fp, count);
1628         else if (ldata->raw || (L_EXTPROC(tty) && !preops))
1629                 n_tty_receive_buf_raw(tty, cp, fp, count);
1630         else if (tty->closing && !L_EXTPROC(tty))
1631                 n_tty_receive_buf_closing(tty, cp, fp, count);
1632         else {
1633                 if (ldata->lnext) {
1634                         char flag = TTY_NORMAL;
1635
1636                         if (fp)
1637                                 flag = *fp++;
1638                         n_tty_receive_char_lnext(tty, *cp++, flag);
1639                         count--;
1640                 }
1641
1642                 if (!preops && !I_PARMRK(tty))
1643                         n_tty_receive_buf_fast(tty, cp, fp, count);
1644                 else
1645                         n_tty_receive_buf_standard(tty, cp, fp, count);
1646
1647                 flush_echoes(tty);
1648                 if (tty->ops->flush_chars)
1649                         tty->ops->flush_chars(tty);
1650         }
1651
1652         if (ldata->icanon && !L_EXTPROC(tty))
1653                 return;
1654
1655         /* publish read_head to consumer */
1656         smp_store_release(&ldata->commit_head, ldata->read_head);
1657
1658         if ((read_cnt(ldata) >= ldata->minimum_to_wake) || L_EXTPROC(tty)) {
1659                 kill_fasync(&tty->fasync, SIGIO, POLL_IN);
1660                 if (waitqueue_active(&tty->read_wait))
1661                         wake_up_interruptible_poll(&tty->read_wait, POLLIN);
1662         }
1663 }
1664
1665 /**
1666  *      n_tty_receive_buf_common        -       process input
1667  *      @tty: device to receive input
1668  *      @cp: input chars
1669  *      @fp: flags for each char (if NULL, all chars are TTY_NORMAL)
1670  *      @count: number of input chars in @cp
1671  *
1672  *      Called by the terminal driver when a block of characters has
1673  *      been received. This function must be called from soft contexts
1674  *      not from interrupt context. The driver is responsible for making
1675  *      calls one at a time and in order (or using flush_to_ldisc)
1676  *
1677  *      Returns the # of input chars from @cp which were processed.
1678  *
1679  *      In canonical mode, the maximum line length is 4096 chars (including
1680  *      the line termination char); lines longer than 4096 chars are
1681  *      truncated. After 4095 chars, input data is still processed but
1682  *      not stored. Overflow processing ensures the tty can always
1683  *      receive more input until at least one line can be read.
1684  *
1685  *      In non-canonical mode, the read buffer will only accept 4095 chars;
1686  *      this provides the necessary space for a newline char if the input
1687  *      mode is switched to canonical.
1688  *
1689  *      Note it is possible for the read buffer to _contain_ 4096 chars
1690  *      in non-canonical mode: the read buffer could already contain the
1691  *      maximum canon line of 4096 chars when the mode is switched to
1692  *      non-canonical.
1693  *
1694  *      n_tty_receive_buf()/producer path:
1695  *              claims non-exclusive termios_rwsem
1696  *              publishes commit_head or canon_head
1697  */
1698 static int
1699 n_tty_receive_buf_common(struct tty_struct *tty, const unsigned char *cp,
1700                          char *fp, int count, int flow)
1701 {
1702         struct n_tty_data *ldata = tty->disc_data;
1703         int room, n, rcvd = 0, overflow;
1704
1705         down_read(&tty->termios_rwsem);
1706
1707         while (1) {
1708                 /*
1709                  * When PARMRK is set, each input char may take up to 3 chars
1710                  * in the read buf; reduce the buffer space avail by 3x
1711                  *
1712                  * If we are doing input canonicalization, and there are no
1713                  * pending newlines, let characters through without limit, so
1714                  * that erase characters will be handled.  Other excess
1715                  * characters will be beeped.
1716                  *
1717                  * paired with store in *_copy_from_read_buf() -- guarantees
1718                  * the consumer has loaded the data in read_buf up to the new
1719                  * read_tail (so this producer will not overwrite unread data)
1720                  */
1721                 size_t tail = smp_load_acquire(&ldata->read_tail);
1722
1723                 room = N_TTY_BUF_SIZE - (ldata->read_head - tail);
1724                 if (I_PARMRK(tty))
1725                         room = (room + 2) / 3;
1726                 room--;
1727                 if (room <= 0) {
1728                         overflow = ldata->icanon && ldata->canon_head == tail;
1729                         if (overflow && room < 0)
1730                                 ldata->read_head--;
1731                         room = overflow;
1732                         ldata->no_room = flow && !room;
1733                 } else
1734                         overflow = 0;
1735
1736                 n = min(count, room);
1737                 if (!n)
1738                         break;
1739
1740                 /* ignore parity errors if handling overflow */
1741                 if (!overflow || !fp || *fp != TTY_PARITY)
1742                         __receive_buf(tty, cp, fp, n);
1743
1744                 cp += n;
1745                 if (fp)
1746                         fp += n;
1747                 count -= n;
1748                 rcvd += n;
1749         }
1750
1751         tty->receive_room = room;
1752
1753         /* Unthrottle if handling overflow on pty */
1754         if (tty->driver->type == TTY_DRIVER_TYPE_PTY) {
1755                 if (overflow) {
1756                         tty_set_flow_change(tty, TTY_UNTHROTTLE_SAFE);
1757                         tty_unthrottle_safe(tty);
1758                         __tty_set_flow_change(tty, 0);
1759                 }
1760         } else
1761                 n_tty_check_throttle(tty);
1762
1763         up_read(&tty->termios_rwsem);
1764
1765         return rcvd;
1766 }
1767
1768 static void n_tty_receive_buf(struct tty_struct *tty, const unsigned char *cp,
1769                               char *fp, int count)
1770 {
1771         n_tty_receive_buf_common(tty, cp, fp, count, 0);
1772 }
1773
1774 static int n_tty_receive_buf2(struct tty_struct *tty, const unsigned char *cp,
1775                               char *fp, int count)
1776 {
1777         return n_tty_receive_buf_common(tty, cp, fp, count, 1);
1778 }
1779
1780 int is_ignored(int sig)
1781 {
1782         return (sigismember(&current->blocked, sig) ||
1783                 current->sighand->action[sig-1].sa.sa_handler == SIG_IGN);
1784 }
1785
1786 /**
1787  *      n_tty_set_termios       -       termios data changed
1788  *      @tty: terminal
1789  *      @old: previous data
1790  *
1791  *      Called by the tty layer when the user changes termios flags so
1792  *      that the line discipline can plan ahead. This function cannot sleep
1793  *      and is protected from re-entry by the tty layer. The user is
1794  *      guaranteed that this function will not be re-entered or in progress
1795  *      when the ldisc is closed.
1796  *
1797  *      Locking: Caller holds tty->termios_rwsem
1798  */
1799
1800 static void n_tty_set_termios(struct tty_struct *tty, struct ktermios *old)
1801 {
1802         struct n_tty_data *ldata = tty->disc_data;
1803
1804         if (!old || (old->c_lflag ^ tty->termios.c_lflag) & ICANON) {
1805                 bitmap_zero(ldata->read_flags, N_TTY_BUF_SIZE);
1806                 ldata->line_start = ldata->read_tail;
1807                 if (!L_ICANON(tty) || !read_cnt(ldata)) {
1808                         ldata->canon_head = ldata->read_tail;
1809                         ldata->push = 0;
1810                 } else {
1811                         set_bit((ldata->read_head - 1) & (N_TTY_BUF_SIZE - 1),
1812                                 ldata->read_flags);
1813                         ldata->canon_head = ldata->read_head;
1814                         ldata->push = 1;
1815                 }
1816                 ldata->commit_head = ldata->read_head;
1817                 ldata->erasing = 0;
1818                 ldata->lnext = 0;
1819         }
1820
1821         ldata->icanon = (L_ICANON(tty) != 0);
1822
1823         if (I_ISTRIP(tty) || I_IUCLC(tty) || I_IGNCR(tty) ||
1824             I_ICRNL(tty) || I_INLCR(tty) || L_ICANON(tty) ||
1825             I_IXON(tty) || L_ISIG(tty) || L_ECHO(tty) ||
1826             I_PARMRK(tty)) {
1827                 bitmap_zero(ldata->char_map, 256);
1828
1829                 if (I_IGNCR(tty) || I_ICRNL(tty))
1830                         set_bit('\r', ldata->char_map);
1831                 if (I_INLCR(tty))
1832                         set_bit('\n', ldata->char_map);
1833
1834                 if (L_ICANON(tty)) {
1835                         set_bit(ERASE_CHAR(tty), ldata->char_map);
1836                         set_bit(KILL_CHAR(tty), ldata->char_map);
1837                         set_bit(EOF_CHAR(tty), ldata->char_map);
1838                         set_bit('\n', ldata->char_map);
1839                         set_bit(EOL_CHAR(tty), ldata->char_map);
1840                         if (L_IEXTEN(tty)) {
1841                                 set_bit(WERASE_CHAR(tty), ldata->char_map);
1842                                 set_bit(LNEXT_CHAR(tty), ldata->char_map);
1843                                 set_bit(EOL2_CHAR(tty), ldata->char_map);
1844                                 if (L_ECHO(tty))
1845                                         set_bit(REPRINT_CHAR(tty),
1846                                                 ldata->char_map);
1847                         }
1848                 }
1849                 if (I_IXON(tty)) {
1850                         set_bit(START_CHAR(tty), ldata->char_map);
1851                         set_bit(STOP_CHAR(tty), ldata->char_map);
1852                 }
1853                 if (L_ISIG(tty)) {
1854                         set_bit(INTR_CHAR(tty), ldata->char_map);
1855                         set_bit(QUIT_CHAR(tty), ldata->char_map);
1856                         set_bit(SUSP_CHAR(tty), ldata->char_map);
1857                 }
1858                 clear_bit(__DISABLED_CHAR, ldata->char_map);
1859                 ldata->raw = 0;
1860                 ldata->real_raw = 0;
1861         } else {
1862                 ldata->raw = 1;
1863                 if ((I_IGNBRK(tty) || (!I_BRKINT(tty) && !I_PARMRK(tty))) &&
1864                     (I_IGNPAR(tty) || !I_INPCK(tty)) &&
1865                     (tty->driver->flags & TTY_DRIVER_REAL_RAW))
1866                         ldata->real_raw = 1;
1867                 else
1868                         ldata->real_raw = 0;
1869         }
1870         /*
1871          * Fix tty hang when I_IXON(tty) is cleared, but the tty
1872          * been stopped by STOP_CHAR(tty) before it.
1873          */
1874         if (!I_IXON(tty) && old && (old->c_iflag & IXON) && !tty->flow_stopped) {
1875                 start_tty(tty);
1876                 process_echoes(tty);
1877         }
1878
1879         /* The termios change make the tty ready for I/O */
1880         if (waitqueue_active(&tty->write_wait))
1881                 wake_up_interruptible(&tty->write_wait);
1882         if (waitqueue_active(&tty->read_wait))
1883                 wake_up_interruptible(&tty->read_wait);
1884 }
1885
1886 /**
1887  *      n_tty_close             -       close the ldisc for this tty
1888  *      @tty: device
1889  *
1890  *      Called from the terminal layer when this line discipline is
1891  *      being shut down, either because of a close or becsuse of a
1892  *      discipline change. The function will not be called while other
1893  *      ldisc methods are in progress.
1894  */
1895
1896 static void n_tty_close(struct tty_struct *tty)
1897 {
1898         struct n_tty_data *ldata = tty->disc_data;
1899
1900         if (tty->link)
1901                 n_tty_packet_mode_flush(tty);
1902
1903         vfree(ldata);
1904         tty->disc_data = NULL;
1905 }
1906
1907 /**
1908  *      n_tty_open              -       open an ldisc
1909  *      @tty: terminal to open
1910  *
1911  *      Called when this line discipline is being attached to the
1912  *      terminal device. Can sleep. Called serialized so that no
1913  *      other events will occur in parallel. No further open will occur
1914  *      until a close.
1915  */
1916
1917 static int n_tty_open(struct tty_struct *tty)
1918 {
1919         struct n_tty_data *ldata;
1920
1921         /* Currently a malloc failure here can panic */
1922         ldata = vmalloc(sizeof(*ldata));
1923         if (!ldata)
1924                 goto err;
1925
1926         ldata->overrun_time = jiffies;
1927         mutex_init(&ldata->atomic_read_lock);
1928         mutex_init(&ldata->output_lock);
1929
1930         tty->disc_data = ldata;
1931         reset_buffer_flags(tty->disc_data);
1932         ldata->column = 0;
1933         ldata->canon_column = 0;
1934         ldata->minimum_to_wake = 1;
1935         ldata->num_overrun = 0;
1936         ldata->no_room = 0;
1937         ldata->lnext = 0;
1938         tty->closing = 0;
1939         /* indicate buffer work may resume */
1940         clear_bit(TTY_LDISC_HALTED, &tty->flags);
1941         n_tty_set_termios(tty, NULL);
1942         tty_unthrottle(tty);
1943
1944         return 0;
1945 err:
1946         return -ENOMEM;
1947 }
1948
1949 static inline int input_available_p(struct tty_struct *tty, int poll)
1950 {
1951         struct n_tty_data *ldata = tty->disc_data;
1952         int amt = poll && !TIME_CHAR(tty) && MIN_CHAR(tty) ? MIN_CHAR(tty) : 1;
1953
1954         if (ldata->icanon && !L_EXTPROC(tty))
1955                 return ldata->canon_head != ldata->read_tail;
1956         else
1957                 return ldata->commit_head - ldata->read_tail >= amt;
1958 }
1959
1960 static inline int check_other_done(struct tty_struct *tty)
1961 {
1962         int done = test_bit(TTY_OTHER_DONE, &tty->flags);
1963         if (done) {
1964                 /* paired with cmpxchg() in check_other_closed(); ensures
1965                  * read buffer head index is not stale
1966                  */
1967                 smp_mb__after_atomic();
1968         }
1969         return done;
1970 }
1971
1972 /**
1973  *      copy_from_read_buf      -       copy read data directly
1974  *      @tty: terminal device
1975  *      @b: user data
1976  *      @nr: size of data
1977  *
1978  *      Helper function to speed up n_tty_read.  It is only called when
1979  *      ICANON is off; it copies characters straight from the tty queue to
1980  *      user space directly.  It can be profitably called twice; once to
1981  *      drain the space from the tail pointer to the (physical) end of the
1982  *      buffer, and once to drain the space from the (physical) beginning of
1983  *      the buffer to head pointer.
1984  *
1985  *      Called under the ldata->atomic_read_lock sem
1986  *
1987  *      n_tty_read()/consumer path:
1988  *              caller holds non-exclusive termios_rwsem
1989  *              read_tail published
1990  */
1991
1992 static int copy_from_read_buf(struct tty_struct *tty,
1993                                       unsigned char __user **b,
1994                                       size_t *nr)
1995
1996 {
1997         struct n_tty_data *ldata = tty->disc_data;
1998         int retval;
1999         size_t n;
2000         bool is_eof;
2001         size_t head = smp_load_acquire(&ldata->commit_head);
2002         size_t tail = ldata->read_tail & (N_TTY_BUF_SIZE - 1);
2003
2004         retval = 0;
2005         n = min(head - ldata->read_tail, N_TTY_BUF_SIZE - tail);
2006         n = min(*nr, n);
2007         if (n) {
2008                 retval = copy_to_user(*b, read_buf_addr(ldata, tail), n);
2009                 n -= retval;
2010                 is_eof = n == 1 && read_buf(ldata, tail) == EOF_CHAR(tty);
2011                 tty_audit_add_data(tty, read_buf_addr(ldata, tail), n,
2012                                 ldata->icanon);
2013                 smp_store_release(&ldata->read_tail, ldata->read_tail + n);
2014                 /* Turn single EOF into zero-length read */
2015                 if (L_EXTPROC(tty) && ldata->icanon && is_eof &&
2016                     (head == ldata->read_tail))
2017                         n = 0;
2018                 *b += n;
2019                 *nr -= n;
2020         }
2021         return retval;
2022 }
2023
2024 /**
2025  *      canon_copy_from_read_buf        -       copy read data in canonical mode
2026  *      @tty: terminal device
2027  *      @b: user data
2028  *      @nr: size of data
2029  *
2030  *      Helper function for n_tty_read.  It is only called when ICANON is on;
2031  *      it copies one line of input up to and including the line-delimiting
2032  *      character into the user-space buffer.
2033  *
2034  *      NB: When termios is changed from non-canonical to canonical mode and
2035  *      the read buffer contains data, n_tty_set_termios() simulates an EOF
2036  *      push (as if C-d were input) _without_ the DISABLED_CHAR in the buffer.
2037  *      This causes data already processed as input to be immediately available
2038  *      as input although a newline has not been received.
2039  *
2040  *      Called under the atomic_read_lock mutex
2041  *
2042  *      n_tty_read()/consumer path:
2043  *              caller holds non-exclusive termios_rwsem
2044  *              read_tail published
2045  */
2046
2047 static int canon_copy_from_read_buf(struct tty_struct *tty,
2048                                     unsigned char __user **b,
2049                                     size_t *nr)
2050 {
2051         struct n_tty_data *ldata = tty->disc_data;
2052         size_t n, size, more, c;
2053         size_t eol;
2054         size_t tail;
2055         int ret, found = 0;
2056         bool eof_push = 0;
2057
2058         /* N.B. avoid overrun if nr == 0 */
2059         n = min(*nr, smp_load_acquire(&ldata->canon_head) - ldata->read_tail);
2060         if (!n)
2061                 return 0;
2062
2063         tail = ldata->read_tail & (N_TTY_BUF_SIZE - 1);
2064         size = min_t(size_t, tail + n, N_TTY_BUF_SIZE);
2065
2066         n_tty_trace("%s: nr:%zu tail:%zu n:%zu size:%zu\n",
2067                     __func__, *nr, tail, n, size);
2068
2069         eol = find_next_bit(ldata->read_flags, size, tail);
2070         more = n - (size - tail);
2071         if (eol == N_TTY_BUF_SIZE && more) {
2072                 /* scan wrapped without finding set bit */
2073                 eol = find_next_bit(ldata->read_flags, more, 0);
2074                 if (eol != more)
2075                         found = 1;
2076         } else if (eol != size)
2077                 found = 1;
2078
2079         size = N_TTY_BUF_SIZE - tail;
2080         n = eol - tail;
2081         if (n > N_TTY_BUF_SIZE)
2082                 n += N_TTY_BUF_SIZE;
2083         n += found;
2084         c = n;
2085
2086         if (found && !ldata->push && read_buf(ldata, eol) == __DISABLED_CHAR) {
2087                 n--;
2088                 eof_push = !n && ldata->read_tail != ldata->line_start;
2089         }
2090
2091         n_tty_trace("%s: eol:%zu found:%d n:%zu c:%zu size:%zu more:%zu\n",
2092                     __func__, eol, found, n, c, size, more);
2093
2094         if (n > size) {
2095                 ret = tty_copy_to_user(tty, *b, read_buf_addr(ldata, tail), size);
2096                 if (ret)
2097                         return -EFAULT;
2098                 ret = tty_copy_to_user(tty, *b + size, ldata->read_buf, n - size);
2099         } else
2100                 ret = tty_copy_to_user(tty, *b, read_buf_addr(ldata, tail), n);
2101
2102         if (ret)
2103                 return -EFAULT;
2104         *b += n;
2105         *nr -= n;
2106
2107         if (found)
2108                 clear_bit(eol, ldata->read_flags);
2109         smp_store_release(&ldata->read_tail, ldata->read_tail + c);
2110
2111         if (found) {
2112                 if (!ldata->push)
2113                         ldata->line_start = ldata->read_tail;
2114                 else
2115                         ldata->push = 0;
2116                 tty_audit_push(tty);
2117         }
2118         return eof_push ? -EAGAIN : 0;
2119 }
2120
2121 extern ssize_t redirected_tty_write(struct file *, const char __user *,
2122                                                         size_t, loff_t *);
2123
2124 /**
2125  *      job_control             -       check job control
2126  *      @tty: tty
2127  *      @file: file handle
2128  *
2129  *      Perform job control management checks on this file/tty descriptor
2130  *      and if appropriate send any needed signals and return a negative
2131  *      error code if action should be taken.
2132  *
2133  *      Locking: redirected write test is safe
2134  *               current->signal->tty check is safe
2135  *               ctrl_lock to safely reference tty->pgrp
2136  */
2137
2138 static int job_control(struct tty_struct *tty, struct file *file)
2139 {
2140         /* Job control check -- must be done at start and after
2141            every sleep (POSIX.1 7.1.1.4). */
2142         /* NOTE: not yet done after every sleep pending a thorough
2143            check of the logic of this change. -- jlc */
2144         /* don't stop on /dev/console */
2145         if (file->f_op->write == redirected_tty_write ||
2146             current->signal->tty != tty)
2147                 return 0;
2148
2149         spin_lock_irq(&tty->ctrl_lock);
2150         if (!tty->pgrp)
2151                 printk(KERN_ERR "n_tty_read: no tty->pgrp!\n");
2152         else if (task_pgrp(current) != tty->pgrp) {
2153                 spin_unlock_irq(&tty->ctrl_lock);
2154                 if (is_ignored(SIGTTIN) || is_current_pgrp_orphaned())
2155                         return -EIO;
2156                 kill_pgrp(task_pgrp(current), SIGTTIN, 1);
2157                 set_thread_flag(TIF_SIGPENDING);
2158                 return -ERESTARTSYS;
2159         }
2160         spin_unlock_irq(&tty->ctrl_lock);
2161         return 0;
2162 }
2163
2164
2165 /**
2166  *      n_tty_read              -       read function for tty
2167  *      @tty: tty device
2168  *      @file: file object
2169  *      @buf: userspace buffer pointer
2170  *      @nr: size of I/O
2171  *
2172  *      Perform reads for the line discipline. We are guaranteed that the
2173  *      line discipline will not be closed under us but we may get multiple
2174  *      parallel readers and must handle this ourselves. We may also get
2175  *      a hangup. Always called in user context, may sleep.
2176  *
2177  *      This code must be sure never to sleep through a hangup.
2178  *
2179  *      n_tty_read()/consumer path:
2180  *              claims non-exclusive termios_rwsem
2181  *              publishes read_tail
2182  */
2183
2184 static ssize_t n_tty_read(struct tty_struct *tty, struct file *file,
2185                          unsigned char __user *buf, size_t nr)
2186 {
2187         struct n_tty_data *ldata = tty->disc_data;
2188         unsigned char __user *b = buf;
2189         DEFINE_WAIT_FUNC(wait, woken_wake_function);
2190         int c, done;
2191         int minimum, time;
2192         ssize_t retval = 0;
2193         long timeout;
2194         int packet;
2195         size_t tail;
2196
2197         c = job_control(tty, file);
2198         if (c < 0)
2199                 return c;
2200
2201         /*
2202          *      Internal serialization of reads.
2203          */
2204         if (file->f_flags & O_NONBLOCK) {
2205                 if (!mutex_trylock(&ldata->atomic_read_lock))
2206                         return -EAGAIN;
2207         } else {
2208                 if (mutex_lock_interruptible(&ldata->atomic_read_lock))
2209                         return -ERESTARTSYS;
2210         }
2211
2212         down_read(&tty->termios_rwsem);
2213
2214         minimum = time = 0;
2215         timeout = MAX_SCHEDULE_TIMEOUT;
2216         if (!ldata->icanon) {
2217                 minimum = MIN_CHAR(tty);
2218                 if (minimum) {
2219                         time = (HZ / 10) * TIME_CHAR(tty);
2220                         if (time)
2221                                 ldata->minimum_to_wake = 1;
2222                         else if (!waitqueue_active(&tty->read_wait) ||
2223                                  (ldata->minimum_to_wake > minimum))
2224                                 ldata->minimum_to_wake = minimum;
2225                 } else {
2226                         timeout = (HZ / 10) * TIME_CHAR(tty);
2227                         ldata->minimum_to_wake = minimum = 1;
2228                 }
2229         }
2230
2231         packet = tty->packet;
2232         tail = ldata->read_tail;
2233
2234         add_wait_queue(&tty->read_wait, &wait);
2235         while (nr) {
2236                 /* First test for status change. */
2237                 if (packet && tty->link->ctrl_status) {
2238                         unsigned char cs;
2239                         if (b != buf)
2240                                 break;
2241                         spin_lock_irq(&tty->link->ctrl_lock);
2242                         cs = tty->link->ctrl_status;
2243                         tty->link->ctrl_status = 0;
2244                         spin_unlock_irq(&tty->link->ctrl_lock);
2245                         if (tty_put_user(tty, cs, b++)) {
2246                                 retval = -EFAULT;
2247                                 b--;
2248                                 break;
2249                         }
2250                         nr--;
2251                         break;
2252                 }
2253
2254                 if (((minimum - (b - buf)) < ldata->minimum_to_wake) &&
2255                     ((minimum - (b - buf)) >= 1))
2256                         ldata->minimum_to_wake = (minimum - (b - buf));
2257
2258                 done = check_other_done(tty);
2259
2260                 if (!input_available_p(tty, 0)) {
2261                         if (done) {
2262                                 retval = -EIO;
2263                                 break;
2264                         }
2265                         if (tty_hung_up_p(file))
2266                                 break;
2267                         if (!timeout)
2268                                 break;
2269                         if (file->f_flags & O_NONBLOCK) {
2270                                 retval = -EAGAIN;
2271                                 break;
2272                         }
2273                         if (signal_pending(current)) {
2274                                 retval = -ERESTARTSYS;
2275                                 break;
2276                         }
2277                         up_read(&tty->termios_rwsem);
2278
2279                         timeout = wait_woken(&wait, TASK_INTERRUPTIBLE,
2280                                              timeout);
2281
2282                         down_read(&tty->termios_rwsem);
2283                         continue;
2284                 }
2285
2286                 if (ldata->icanon && !L_EXTPROC(tty)) {
2287                         retval = canon_copy_from_read_buf(tty, &b, &nr);
2288                         if (retval == -EAGAIN) {
2289                                 retval = 0;
2290                                 continue;
2291                         } else if (retval)
2292                                 break;
2293                 } else {
2294                         int uncopied;
2295
2296                         /* Deal with packet mode. */
2297                         if (packet && b == buf) {
2298                                 if (tty_put_user(tty, TIOCPKT_DATA, b++)) {
2299                                         retval = -EFAULT;
2300                                         b--;
2301                                         break;
2302                                 }
2303                                 nr--;
2304                         }
2305
2306                         uncopied = copy_from_read_buf(tty, &b, &nr);
2307                         uncopied += copy_from_read_buf(tty, &b, &nr);
2308                         if (uncopied) {
2309                                 retval = -EFAULT;
2310                                 break;
2311                         }
2312                 }
2313
2314                 n_tty_check_unthrottle(tty);
2315
2316                 if (b - buf >= minimum)
2317                         break;
2318                 if (time)
2319                         timeout = time;
2320         }
2321         if (tail != ldata->read_tail)
2322                 n_tty_kick_worker(tty);
2323         up_read(&tty->termios_rwsem);
2324
2325         remove_wait_queue(&tty->read_wait, &wait);
2326         if (!waitqueue_active(&tty->read_wait))
2327                 ldata->minimum_to_wake = minimum;
2328
2329         mutex_unlock(&ldata->atomic_read_lock);
2330
2331         if (b - buf)
2332                 retval = b - buf;
2333
2334         return retval;
2335 }
2336
2337 /**
2338  *      n_tty_write             -       write function for tty
2339  *      @tty: tty device
2340  *      @file: file object
2341  *      @buf: userspace buffer pointer
2342  *      @nr: size of I/O
2343  *
2344  *      Write function of the terminal device.  This is serialized with
2345  *      respect to other write callers but not to termios changes, reads
2346  *      and other such events.  Since the receive code will echo characters,
2347  *      thus calling driver write methods, the output_lock is used in
2348  *      the output processing functions called here as well as in the
2349  *      echo processing function to protect the column state and space
2350  *      left in the buffer.
2351  *
2352  *      This code must be sure never to sleep through a hangup.
2353  *
2354  *      Locking: output_lock to protect column state and space left
2355  *               (note that the process_output*() functions take this
2356  *                lock themselves)
2357  */
2358
2359 static ssize_t n_tty_write(struct tty_struct *tty, struct file *file,
2360                            const unsigned char *buf, size_t nr)
2361 {
2362         const unsigned char *b = buf;
2363         DEFINE_WAIT_FUNC(wait, woken_wake_function);
2364         int c;
2365         ssize_t retval = 0;
2366
2367         /* Job control check -- must be done at start (POSIX.1 7.1.1.4). */
2368         if (L_TOSTOP(tty) && file->f_op->write != redirected_tty_write) {
2369                 retval = tty_check_change(tty);
2370                 if (retval)
2371                         return retval;
2372         }
2373
2374         down_read(&tty->termios_rwsem);
2375
2376         /* Write out any echoed characters that are still pending */
2377         process_echoes(tty);
2378
2379         add_wait_queue(&tty->write_wait, &wait);
2380         while (1) {
2381                 if (signal_pending(current)) {
2382                         retval = -ERESTARTSYS;
2383                         break;
2384                 }
2385                 if (tty_hung_up_p(file) || (tty->link && !tty->link->count)) {
2386                         retval = -EIO;
2387                         break;
2388                 }
2389                 if (O_OPOST(tty)) {
2390                         while (nr > 0) {
2391                                 ssize_t num = process_output_block(tty, b, nr);
2392                                 if (num < 0) {
2393                                         if (num == -EAGAIN)
2394                                                 break;
2395                                         retval = num;
2396                                         goto break_out;
2397                                 }
2398                                 b += num;
2399                                 nr -= num;
2400                                 if (nr == 0)
2401                                         break;
2402                                 c = *b;
2403                                 if (process_output(c, tty) < 0)
2404                                         break;
2405                                 b++; nr--;
2406                         }
2407                         if (tty->ops->flush_chars)
2408                                 tty->ops->flush_chars(tty);
2409                 } else {
2410                         struct n_tty_data *ldata = tty->disc_data;
2411
2412                         while (nr > 0) {
2413                                 mutex_lock(&ldata->output_lock);
2414                                 c = tty->ops->write(tty, b, nr);
2415                                 mutex_unlock(&ldata->output_lock);
2416                                 if (c < 0) {
2417                                         retval = c;
2418                                         goto break_out;
2419                                 }
2420                                 if (!c)
2421                                         break;
2422                                 b += c;
2423                                 nr -= c;
2424                         }
2425                 }
2426                 if (!nr)
2427                         break;
2428                 if (file->f_flags & O_NONBLOCK) {
2429                         retval = -EAGAIN;
2430                         break;
2431                 }
2432                 up_read(&tty->termios_rwsem);
2433
2434                 wait_woken(&wait, TASK_INTERRUPTIBLE, MAX_SCHEDULE_TIMEOUT);
2435
2436                 down_read(&tty->termios_rwsem);
2437         }
2438 break_out:
2439         remove_wait_queue(&tty->write_wait, &wait);
2440         if (b - buf != nr && tty->fasync)
2441                 set_bit(TTY_DO_WRITE_WAKEUP, &tty->flags);
2442         up_read(&tty->termios_rwsem);
2443         return (b - buf) ? b - buf : retval;
2444 }
2445
2446 /**
2447  *      n_tty_poll              -       poll method for N_TTY
2448  *      @tty: terminal device
2449  *      @file: file accessing it
2450  *      @wait: poll table
2451  *
2452  *      Called when the line discipline is asked to poll() for data or
2453  *      for special events. This code is not serialized with respect to
2454  *      other events save open/close.
2455  *
2456  *      This code must be sure never to sleep through a hangup.
2457  *      Called without the kernel lock held - fine
2458  */
2459
2460 static unsigned int n_tty_poll(struct tty_struct *tty, struct file *file,
2461                                                         poll_table *wait)
2462 {
2463         struct n_tty_data *ldata = tty->disc_data;
2464         unsigned int mask = 0;
2465
2466         poll_wait(file, &tty->read_wait, wait);
2467         poll_wait(file, &tty->write_wait, wait);
2468         if (check_other_done(tty))
2469                 mask |= POLLHUP;
2470         if (input_available_p(tty, 1))
2471                 mask |= POLLIN | POLLRDNORM;
2472         if (tty->packet && tty->link->ctrl_status)
2473                 mask |= POLLPRI | POLLIN | POLLRDNORM;
2474         if (tty_hung_up_p(file))
2475                 mask |= POLLHUP;
2476         if (!(mask & (POLLHUP | POLLIN | POLLRDNORM))) {
2477                 if (MIN_CHAR(tty) && !TIME_CHAR(tty))
2478                         ldata->minimum_to_wake = MIN_CHAR(tty);
2479                 else
2480                         ldata->minimum_to_wake = 1;
2481         }
2482         if (tty->ops->write && !tty_is_writelocked(tty) &&
2483                         tty_chars_in_buffer(tty) < WAKEUP_CHARS &&
2484                         tty_write_room(tty) > 0)
2485                 mask |= POLLOUT | POLLWRNORM;
2486         return mask;
2487 }
2488
2489 static unsigned long inq_canon(struct n_tty_data *ldata)
2490 {
2491         size_t nr, head, tail;
2492
2493         if (ldata->canon_head == ldata->read_tail)
2494                 return 0;
2495         head = ldata->canon_head;
2496         tail = ldata->read_tail;
2497         nr = head - tail;
2498         /* Skip EOF-chars.. */
2499         while (head != tail) {
2500                 if (test_bit(tail & (N_TTY_BUF_SIZE - 1), ldata->read_flags) &&
2501                     read_buf(ldata, tail) == __DISABLED_CHAR)
2502                         nr--;
2503                 tail++;
2504         }
2505         return nr;
2506 }
2507
2508 static int n_tty_ioctl(struct tty_struct *tty, struct file *file,
2509                        unsigned int cmd, unsigned long arg)
2510 {
2511         struct n_tty_data *ldata = tty->disc_data;
2512         int retval;
2513
2514         switch (cmd) {
2515         case TIOCOUTQ:
2516                 return put_user(tty_chars_in_buffer(tty), (int __user *) arg);
2517         case TIOCINQ:
2518                 down_write(&tty->termios_rwsem);
2519                 if (L_ICANON(tty))
2520                         retval = inq_canon(ldata);
2521                 else
2522                         retval = read_cnt(ldata);
2523                 up_write(&tty->termios_rwsem);
2524                 return put_user(retval, (unsigned int __user *) arg);
2525         default:
2526                 return n_tty_ioctl_helper(tty, file, cmd, arg);
2527         }
2528 }
2529
2530 static void n_tty_fasync(struct tty_struct *tty, int on)
2531 {
2532         struct n_tty_data *ldata = tty->disc_data;
2533
2534         if (!waitqueue_active(&tty->read_wait)) {
2535                 if (on)
2536                         ldata->minimum_to_wake = 1;
2537                 else if (!tty->fasync)
2538                         ldata->minimum_to_wake = N_TTY_BUF_SIZE;
2539         }
2540 }
2541
2542 struct tty_ldisc_ops tty_ldisc_N_TTY = {
2543         .magic           = TTY_LDISC_MAGIC,
2544         .name            = "n_tty",
2545         .open            = n_tty_open,
2546         .close           = n_tty_close,
2547         .flush_buffer    = n_tty_flush_buffer,
2548         .chars_in_buffer = n_tty_chars_in_buffer,
2549         .read            = n_tty_read,
2550         .write           = n_tty_write,
2551         .ioctl           = n_tty_ioctl,
2552         .set_termios     = n_tty_set_termios,
2553         .poll            = n_tty_poll,
2554         .receive_buf     = n_tty_receive_buf,
2555         .write_wakeup    = n_tty_write_wakeup,
2556         .fasync          = n_tty_fasync,
2557         .receive_buf2    = n_tty_receive_buf2,
2558 };
2559
2560 /**
2561  *      n_tty_inherit_ops       -       inherit N_TTY methods
2562  *      @ops: struct tty_ldisc_ops where to save N_TTY methods
2563  *
2564  *      Enables a 'subclass' line discipline to 'inherit' N_TTY
2565  *      methods.
2566  */
2567
2568 void n_tty_inherit_ops(struct tty_ldisc_ops *ops)
2569 {
2570         *ops = tty_ldisc_N_TTY;
2571         ops->owner = NULL;
2572         ops->refcount = ops->flags = 0;
2573 }
2574 EXPORT_SYMBOL_GPL(n_tty_inherit_ops);