LCOV - code coverage report
Current view: top level - drivers/tty - n_tty.c (source / functions) Hit Total Coverage
Test: landlock.info Lines: 204 1123 18.2 %
Date: 2021-04-22 12:43:58 Functions: 15 59 25.4 %

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

Generated by: LCOV version 1.14