Pileus Git - ~andy/linux/blob - drivers/tty/n_tty.c

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