n_tty.c 52.2 KB
Newer Older
Linus Torvalds's avatar
Linus Torvalds committed
1 2
/*
 * n_tty.c --- implements the N_TTY line discipline.
3
 *
Linus Torvalds's avatar
Linus Torvalds committed
4 5 6 7 8 9 10
 * This code used to be in tty_io.c, but things are getting hairy
 * enough that it made sense to split things off.  (The N_TTY
 * processing has changed so much that it's hardly recognizable,
 * anyway...)
 *
 * Note that the open routine for N_TTY is guaranteed never to return
 * 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.
Linus Torvalds's avatar
Linus Torvalds committed
12 13
 *
 * Written by Theodore Ts'o, Copyright 1994.
14
 *
Linus Torvalds's avatar
Linus Torvalds committed
15 16
 * This file also contains code originally written by Linus Torvalds,
 * Copyright 1991, 1992, 1993, and by Julian Cowley, Copyright 1994.
17
 *
Linus Torvalds's avatar
Linus Torvalds committed
18 19 20 21 22
 * This file may be redistributed under the terms of the GNU General Public
 * License.
 *
 * Reduced memory usage for older ARM systems  - Russell King.
 *
23
 * 2000/01/20   Fixed SMP locking on put_tty_queue using bits of
Linus Torvalds's avatar
Linus Torvalds committed
24 25 26 27 28
 *		the patch by Andrew J. Kroll <ag784@freenet.buffalo.edu>
 *		who actually finally proved there really was a race.
 *
 * 2002/03/18   Implemented n_tty_wakeup to send SIGIO POLL_OUTs to
 *		waiting writing processes-Sapan Bhatia <sapan@corewars.org>.
29
 *		Also fixed a bug in BLOCKING mode where n_tty_write returns
Linus Torvalds's avatar
Linus Torvalds committed
30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47
 *		EAGAIN
 */

#include <linux/types.h>
#include <linux/major.h>
#include <linux/errno.h>
#include <linux/signal.h>
#include <linux/fcntl.h>
#include <linux/sched.h>
#include <linux/interrupt.h>
#include <linux/tty.h>
#include <linux/timer.h>
#include <linux/ctype.h>
#include <linux/mm.h>
#include <linux/string.h>
#include <linux/slab.h>
#include <linux/poll.h>
#include <linux/bitops.h>
48 49
#include <linux/audit.h>
#include <linux/file.h>
Alan Cox's avatar
Alan Cox committed
50
#include <linux/uaccess.h>
51
#include <linux/module.h>
Linus Torvalds's avatar
Linus Torvalds committed
52 53 54 55 56 57 58 59 60 61 62


/* number of characters left in xmit buffer before select has we have room */
#define WAKEUP_CHARS 256

/*
 * This defines the low- and high-watermarks for throttling and
 * unthrottling the TTY driver.  These watermarks are used for
 * controlling the space in the read buffer.
 */
#define TTY_THRESHOLD_THROTTLE		128 /* now based on remaining room */
63
#define TTY_THRESHOLD_UNTHROTTLE	128
Linus Torvalds's avatar
Linus Torvalds committed
64

65 66 67 68 69 70 71 72 73 74 75
/*
 * Special byte codes used in the echo buffer to represent operations
 * or special handling of characters.  Bytes in the echo buffer that
 * are not part of such special blocks are treated as normal character
 * codes.
 */
#define ECHO_OP_START 0xff
#define ECHO_OP_MOVE_BACK_COL 0x80
#define ECHO_OP_SET_CANON_COL 0x81
#define ECHO_OP_ERASE_TAB 0x82

76 77 78 79 80 81 82
static inline int tty_put_user(struct tty_struct *tty, unsigned char x,
			       unsigned char __user *ptr)
{
	tty_audit_add_data(tty, &x, 1);
	return put_user(x, ptr);
}

83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114
/**
 *	n_tty_set__room	-	receive space
 *	@tty: terminal
 *
 *	Called by the driver to find out how much data it is
 *	permitted to feed to the line discipline without any being lost
 *	and thus to manage flow control. Not serialized. Answers for the
 *	"instant".
 */

static void n_tty_set_room(struct tty_struct *tty)
{
	/* tty->read_cnt is not read locked ? */
	int	left = N_TTY_BUF_SIZE - tty->read_cnt - 1;
	int old_left;

	/*
	 * If we are doing input canonicalization, and there are no
	 * pending newlines, let characters through without limit, so
	 * that erase characters will be handled.  Other excess
	 * characters will be beeped.
	 */
	if (left <= 0)
		left = tty->icanon && !tty->canon_data;
	old_left = tty->receive_room;
	tty->receive_room = left;

	/* Did this open up the receive buffer? We may need to flip */
	if (left && !old_left)
		schedule_work(&tty->buf.work);
}

115
static void put_tty_queue_nolock(unsigned char c, struct tty_struct *tty)
Linus Torvalds's avatar
Linus Torvalds committed
116 117 118 119 120 121 122 123
{
	if (tty->read_cnt < N_TTY_BUF_SIZE) {
		tty->read_buf[tty->read_head] = c;
		tty->read_head = (tty->read_head + 1) & (N_TTY_BUF_SIZE-1);
		tty->read_cnt++;
	}
}

124 125 126 127 128 129 130 131 132 133
/**
 *	put_tty_queue		-	add character to tty
 *	@c: character
 *	@tty: tty device
 *
 *	Add a character to the tty read_buf queue. This is done under the
 *	read_lock to serialize character addition and also to protect us
 *	against parallel reads or flushes
 */

134
static void put_tty_queue(unsigned char c, struct tty_struct *tty)
Linus Torvalds's avatar
Linus Torvalds committed
135 136 137 138 139 140 141 142 143 144 145 146 147 148 149
{
	unsigned long flags;
	/*
	 *	The problem of stomping on the buffers ends here.
	 *	Why didn't anyone see this one coming? --AJK
	*/
	spin_lock_irqsave(&tty->read_lock, flags);
	put_tty_queue_nolock(c, tty);
	spin_unlock_irqrestore(&tty->read_lock, flags);
}

/**
 *	check_unthrottle	-	allow new receive data
 *	@tty; tty device
 *
150 151
 *	Check whether to call the driver unthrottle functions
 *
Ingo Molnar's avatar
Ingo Molnar committed
152
 *	Can sleep, may be called under the atomic_read_lock mutex but
Linus Torvalds's avatar
Linus Torvalds committed
153 154
 *	this is not guaranteed.
 */
155
static void check_unthrottle(struct tty_struct *tty)
Linus Torvalds's avatar
Linus Torvalds committed
156
{
157 158
	if (tty->count)
		tty_unthrottle(tty);
Linus Torvalds's avatar
Linus Torvalds committed
159 160 161 162 163 164
}

/**
 *	reset_buffer_flags	-	reset buffer state
 *	@tty: terminal to reset
 *
165
 *	Reset the read buffer counters, clear the flags,
Linus Torvalds's avatar
Linus Torvalds committed
166 167
 *	and make sure the driver is unthrottled. Called
 *	from n_tty_open() and n_tty_flush_buffer().
168 169
 *
 *	Locking: tty_read_lock for read fields.
Linus Torvalds's avatar
Linus Torvalds committed
170
 */
171

Linus Torvalds's avatar
Linus Torvalds committed
172 173 174 175 176 177 178
static void reset_buffer_flags(struct tty_struct *tty)
{
	unsigned long flags;

	spin_lock_irqsave(&tty->read_lock, flags);
	tty->read_head = tty->read_tail = tty->read_cnt = 0;
	spin_unlock_irqrestore(&tty->read_lock, flags);
179 180 181 182 183

	mutex_lock(&tty->echo_lock);
	tty->echo_pos = tty->echo_cnt = tty->echo_overrun = 0;
	mutex_unlock(&tty->echo_lock);

Linus Torvalds's avatar
Linus Torvalds committed
184 185
	tty->canon_head = tty->canon_data = tty->erasing = 0;
	memset(&tty->read_flags, 0, sizeof tty->read_flags);
186
	n_tty_set_room(tty);
Linus Torvalds's avatar
Linus Torvalds committed
187 188 189 190 191 192 193 194 195 196 197
}

/**
 *	n_tty_flush_buffer	-	clean input queue
 *	@tty:	terminal device
 *
 *	Flush the input buffer. Called when the line discipline is
 *	being closed, when the tty layer wants the buffer flushed (eg
 *	at hangup) or when the N_TTY line discipline internally has to
 *	clean the pending queue (for example some signals).
 *
198
 *	Locking: ctrl_lock, read_lock.
Linus Torvalds's avatar
Linus Torvalds committed
199
 */
200 201

static void n_tty_flush_buffer(struct tty_struct *tty)
Linus Torvalds's avatar
Linus Torvalds committed
202
{
Alan Cox's avatar
Alan Cox committed
203
	unsigned long flags;
Linus Torvalds's avatar
Linus Torvalds committed
204 205
	/* clear everything and unthrottle the driver */
	reset_buffer_flags(tty);
206

Linus Torvalds's avatar
Linus Torvalds committed
207 208 209
	if (!tty->link)
		return;

Alan Cox's avatar
Alan Cox committed
210
	spin_lock_irqsave(&tty->ctrl_lock, flags);
Linus Torvalds's avatar
Linus Torvalds committed
211 212 213 214
	if (tty->link->packet) {
		tty->ctrl_status |= TIOCPKT_FLUSHREAD;
		wake_up_interruptible(&tty->link->read_wait);
	}
Alan Cox's avatar
Alan Cox committed
215
	spin_unlock_irqrestore(&tty->ctrl_lock, flags);
Linus Torvalds's avatar
Linus Torvalds committed
216 217 218 219 220 221 222
}

/**
 *	n_tty_chars_in_buffer	-	report available bytes
 *	@tty: tty device
 *
 *	Report the number of characters buffered to be delivered to user
223
 *	at this instant in time.
224 225
 *
 *	Locking: read_lock
Linus Torvalds's avatar
Linus Torvalds committed
226
 */
227

Linus Torvalds's avatar
Linus Torvalds committed
228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252
static ssize_t n_tty_chars_in_buffer(struct tty_struct *tty)
{
	unsigned long flags;
	ssize_t n = 0;

	spin_lock_irqsave(&tty->read_lock, flags);
	if (!tty->icanon) {
		n = tty->read_cnt;
	} else if (tty->canon_data) {
		n = (tty->canon_head > tty->read_tail) ?
			tty->canon_head - tty->read_tail :
			tty->canon_head + (N_TTY_BUF_SIZE - tty->read_tail);
	}
	spin_unlock_irqrestore(&tty->read_lock, flags);
	return n;
}

/**
 *	is_utf8_continuation	-	utf8 multibyte check
 *	@c: byte to check
 *
 *	Returns true if the utf8 character 'c' is a multibyte continuation
 *	character. We use this to correctly compute the on screen size
 *	of the character when printing
 */
253

Linus Torvalds's avatar
Linus Torvalds committed
254 255 256 257 258 259 260 261 262 263 264 265
static inline int is_utf8_continuation(unsigned char c)
{
	return (c & 0xc0) == 0x80;
}

/**
 *	is_continuation		-	multibyte check
 *	@c: byte to check
 *
 *	Returns true if the utf8 character 'c' is a multibyte continuation
 *	character and the terminal is in unicode mode.
 */
266

Linus Torvalds's avatar
Linus Torvalds committed
267 268 269 270 271 272
static inline int is_continuation(unsigned char c, struct tty_struct *tty)
{
	return I_IUTF8(tty) && is_utf8_continuation(c);
}

/**
273
 *	do_output_char			-	output one character
Linus Torvalds's avatar
Linus Torvalds committed
274 275
 *	@c: character (or partial unicode symbol)
 *	@tty: terminal device
276
 *	@space: space available in tty driver write buffer
Linus Torvalds's avatar
Linus Torvalds committed
277
 *
278 279
 *	This is a helper function that handles one output character
 *	(including special characters like TAB, CR, LF, etc.),
280 281
 *	doing OPOST processing and putting the results in the
 *	tty driver's write buffer.
282 283 284 285
 *
 *	Note that Linux currently ignores TABDLY, CRDLY, VTDLY, FFDLY
 *	and NLDLY.  They simply aren't relevant in the world today.
 *	If you ever need them, add them here.
Linus Torvalds's avatar
Linus Torvalds committed
286
 *
287 288 289 290 291
 *	Returns the number of bytes of buffer space used or -1 if
 *	no space left.
 *
 *	Locking: should be called under the output_lock to protect
 *		 the column state and space left in the buffer
Linus Torvalds's avatar
Linus Torvalds committed
292
 */
293

294
static int do_output_char(unsigned char c, struct tty_struct *tty, int space)
Linus Torvalds's avatar
Linus Torvalds committed
295
{
296
	int	spaces;
Linus Torvalds's avatar
Linus Torvalds committed
297 298 299

	if (!space)
		return -1;
Alan Cox's avatar
Alan Cox committed
300

301 302 303 304 305 306 307
	switch (c) {
	case '\n':
		if (O_ONLRET(tty))
			tty->column = 0;
		if (O_ONLCR(tty)) {
			if (space < 2)
				return -1;
Linus Torvalds's avatar
Linus Torvalds committed
308
			tty->canon_column = tty->column = 0;
309
			tty->ops->write(tty, "\r\n", 2);
310 311 312 313 314 315 316 317 318 319 320
			return 2;
		}
		tty->canon_column = tty->column;
		break;
	case '\r':
		if (O_ONOCR(tty) && tty->column == 0)
			return 0;
		if (O_OCRNL(tty)) {
			c = '\n';
			if (O_ONLRET(tty))
				tty->canon_column = tty->column = 0;
Linus Torvalds's avatar
Linus Torvalds committed
321
			break;
322 323 324 325 326 327 328 329
		}
		tty->canon_column = tty->column = 0;
		break;
	case '\t':
		spaces = 8 - (tty->column & 7);
		if (O_TABDLY(tty) == XTABS) {
			if (space < spaces)
				return -1;
Linus Torvalds's avatar
Linus Torvalds committed
330
			tty->column += spaces;
331 332
			tty->ops->write(tty, "        ", spaces);
			return spaces;
Linus Torvalds's avatar
Linus Torvalds committed
333
		}
334 335 336 337 338 339 340
		tty->column += spaces;
		break;
	case '\b':
		if (tty->column > 0)
			tty->column--;
		break;
	default:
341 342 343 344 345 346
		if (!iscntrl(c)) {
			if (O_OLCUC(tty))
				c = toupper(c);
			if (!is_continuation(c, tty))
				tty->column++;
		}
347
		break;
Linus Torvalds's avatar
Linus Torvalds committed
348
	}
349

Alan Cox's avatar
Alan Cox committed
350
	tty_put_char(tty, c);
351 352 353 354 355 356 357 358
	return 1;
}

/**
 *	process_output			-	output post processor
 *	@c: character (or partial unicode symbol)
 *	@tty: terminal device
 *
359 360 361
 *	Output one character with OPOST processing.
 *	Returns -1 when the output device is full and the character
 *	must be retried.
362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381
 *
 *	Locking: output_lock to protect column state and space left
 *		 (also, this is called from n_tty_write under the
 *		  tty layer write lock)
 */

static int process_output(unsigned char c, struct tty_struct *tty)
{
	int	space, retval;

	mutex_lock(&tty->output_lock);

	space = tty_write_room(tty);
	retval = do_output_char(c, tty, space);

	mutex_unlock(&tty->output_lock);
	if (retval < 0)
		return -1;
	else
		return 0;
Linus Torvalds's avatar
Linus Torvalds committed
382 383 384
}

/**
385
 *	process_output_block		-	block post processor
Linus Torvalds's avatar
Linus Torvalds committed
386
 *	@tty: terminal device
387 388 389 390 391
 *	@buf: character buffer
 *	@nr: number of bytes to output
 *
 *	Output a block of characters with OPOST processing.
 *	Returns the number of characters output.
Linus Torvalds's avatar
Linus Torvalds committed
392 393 394 395 396 397
 *
 *	This path is used to speed up block console writes, among other
 *	things when processing blocks of output data. It handles only
 *	the simple cases normally found and helps to generate blocks of
 *	symbols for the console driver and thus improve performance.
 *
398 399 400
 *	Locking: output_lock to protect column state and space left
 *		 (also, this is called from n_tty_write under the
 *		  tty layer write lock)
Linus Torvalds's avatar
Linus Torvalds committed
401
 */
402

403 404
static ssize_t process_output_block(struct tty_struct *tty,
				    const unsigned char *buf, unsigned int nr)
Linus Torvalds's avatar
Linus Torvalds committed
405 406
{
	int	space;
407
	int	i;
Linus Torvalds's avatar
Linus Torvalds committed
408 409
	const unsigned char *cp;

410 411
	mutex_lock(&tty->output_lock);

Alan Cox's avatar
Alan Cox committed
412
	space = tty_write_room(tty);
Alan Cox's avatar
Alan Cox committed
413
	if (!space) {
414
		mutex_unlock(&tty->output_lock);
Linus Torvalds's avatar
Linus Torvalds committed
415
		return 0;
416
	}
Linus Torvalds's avatar
Linus Torvalds committed
417 418 419 420
	if (nr > space)
		nr = space;

	for (i = 0, cp = buf; i < nr; i++, cp++) {
421 422 423
		unsigned char c = *cp;

		switch (c) {
Linus Torvalds's avatar
Linus Torvalds committed
424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444
		case '\n':
			if (O_ONLRET(tty))
				tty->column = 0;
			if (O_ONLCR(tty))
				goto break_out;
			tty->canon_column = tty->column;
			break;
		case '\r':
			if (O_ONOCR(tty) && tty->column == 0)
				goto break_out;
			if (O_OCRNL(tty))
				goto break_out;
			tty->canon_column = tty->column = 0;
			break;
		case '\t':
			goto break_out;
		case '\b':
			if (tty->column > 0)
				tty->column--;
			break;
		default:
445 446 447 448 449 450
			if (!iscntrl(c)) {
				if (O_OLCUC(tty))
					goto break_out;
				if (!is_continuation(c, tty))
					tty->column++;
			}
Linus Torvalds's avatar
Linus Torvalds committed
451 452 453 454
			break;
		}
	}
break_out:
Alan Cox's avatar
Alan Cox committed
455
	i = tty->ops->write(tty, buf, i);
456 457

	mutex_unlock(&tty->output_lock);
Linus Torvalds's avatar
Linus Torvalds committed
458 459 460
	return i;
}

461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519
/**
 *	process_echoes	-	write pending echo characters
 *	@tty: terminal device
 *
 *	Write previously buffered echo (and other ldisc-generated)
 *	characters to the tty.
 *
 *	Characters generated by the ldisc (including echoes) need to
 *	be buffered because the driver's write buffer can fill during
 *	heavy program output.  Echoing straight to the driver will
 *	often fail under these conditions, causing lost characters and
 *	resulting mismatches of ldisc state information.
 *
 *	Since the ldisc state must represent the characters actually sent
 *	to the driver at the time of the write, operations like certain
 *	changes in column state are also saved in the buffer and executed
 *	here.
 *
 *	A circular fifo buffer is used so that the most recent characters
 *	are prioritized.  Also, when control characters are echoed with a
 *	prefixed "^", the pair is treated atomically and thus not separated.
 *
 *	Locking: output_lock to protect column state and space left,
 *		 echo_lock to protect the echo buffer
 */

static void process_echoes(struct tty_struct *tty)
{
	int	space, nr;
	unsigned char c;
	unsigned char *cp, *buf_end;

	if (!tty->echo_cnt)
		return;

	mutex_lock(&tty->output_lock);
	mutex_lock(&tty->echo_lock);

	space = tty_write_room(tty);

	buf_end = tty->echo_buf + N_TTY_BUF_SIZE;
	cp = tty->echo_buf + tty->echo_pos;
	nr = tty->echo_cnt;
	while (nr > 0) {
		c = *cp;
		if (c == ECHO_OP_START) {
			unsigned char op;
			unsigned char *opp;
			int no_space_left = 0;

			/*
			 * If the buffer byte is the start of a multi-byte
			 * operation, get the next byte, which is either the
			 * op code or a control character value.
			 */
			opp = cp + 1;
			if (opp == buf_end)
				opp -= N_TTY_BUF_SIZE;
			op = *opp;
Alan Cox's avatar
Alan Cox committed
520

521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584
			switch (op) {
				unsigned int num_chars, num_bs;

			case ECHO_OP_ERASE_TAB:
				if (++opp == buf_end)
					opp -= N_TTY_BUF_SIZE;
				num_chars = *opp;

				/*
				 * Determine how many columns to go back
				 * in order to erase the tab.
				 * This depends on the number of columns
				 * used by other characters within the tab
				 * area.  If this (modulo 8) count is from
				 * the start of input rather than from a
				 * previous tab, we offset by canon column.
				 * Otherwise, tab spacing is normal.
				 */
				if (!(num_chars & 0x80))
					num_chars += tty->canon_column;
				num_bs = 8 - (num_chars & 7);

				if (num_bs > space) {
					no_space_left = 1;
					break;
				}
				space -= num_bs;
				while (num_bs--) {
					tty_put_char(tty, '\b');
					if (tty->column > 0)
						tty->column--;
				}
				cp += 3;
				nr -= 3;
				break;

			case ECHO_OP_SET_CANON_COL:
				tty->canon_column = tty->column;
				cp += 2;
				nr -= 2;
				break;

			case ECHO_OP_MOVE_BACK_COL:
				if (tty->column > 0)
					tty->column--;
				cp += 2;
				nr -= 2;
				break;

			case ECHO_OP_START:
				/* This is an escaped echo op start code */
				if (!space) {
					no_space_left = 1;
					break;
				}
				tty_put_char(tty, ECHO_OP_START);
				tty->column++;
				space--;
				cp += 2;
				nr -= 2;
				break;

			default:
				/*
585 586 587 588 589 590 591
				 * If the op is not a special byte code,
				 * it is a ctrl char tagged to be echoed
				 * as "^X" (where X is the letter
				 * representing the control char).
				 * Note that we must ensure there is
				 * enough space for the whole ctrl pair.
				 *
592
				 */
593 594 595 596 597 598 599 600
				if (space < 2) {
					no_space_left = 1;
					break;
				}
				tty_put_char(tty, '^');
				tty_put_char(tty, op ^ 0100);
				tty->column += 2;
				space -= 2;
601 602 603 604 605 606 607
				cp += 2;
				nr -= 2;
			}

			if (no_space_left)
				break;
		} else {
608 609 610 611 612 613 614 615 616 617 618 619
			if (O_OPOST(tty) &&
			    !(test_bit(TTY_HW_COOK_OUT, &tty->flags))) {
				int retval = do_output_char(c, tty, space);
				if (retval < 0)
					break;
				space -= retval;
			} else {
				if (!space)
					break;
				tty_put_char(tty, c);
				space -= 1;
			}
620 621 622 623 624 625 626 627 628 629 630 631 632 633 634 635 636 637 638 639 640 641 642 643 644 645 646 647 648 649 650 651 652 653 654 655 656 657 658 659 660 661 662 663 664 665 666 667 668 669 670
			cp += 1;
			nr -= 1;
		}

		/* When end of circular buffer reached, wrap around */
		if (cp >= buf_end)
			cp -= N_TTY_BUF_SIZE;
	}

	if (nr == 0) {
		tty->echo_pos = 0;
		tty->echo_cnt = 0;
		tty->echo_overrun = 0;
	} else {
		int num_processed = tty->echo_cnt - nr;
		tty->echo_pos += num_processed;
		tty->echo_pos &= N_TTY_BUF_SIZE - 1;
		tty->echo_cnt = nr;
		if (num_processed > 0)
			tty->echo_overrun = 0;
	}

	mutex_unlock(&tty->echo_lock);
	mutex_unlock(&tty->output_lock);

	if (tty->ops->flush_chars)
		tty->ops->flush_chars(tty);
}

/**
 *	add_echo_byte	-	add a byte to the echo buffer
 *	@c: unicode byte to echo
 *	@tty: terminal device
 *
 *	Add a character or operation byte to the echo buffer.
 *
 *	Should be called under the echo lock to protect the echo buffer.
 */

static void add_echo_byte(unsigned char c, struct tty_struct *tty)
{
	int	new_byte_pos;

	if (tty->echo_cnt == N_TTY_BUF_SIZE) {
		/* Circular buffer is already at capacity */
		new_byte_pos = tty->echo_pos;

		/*
		 * Since the buffer start position needs to be advanced,
		 * be sure to step by a whole operation byte group.
		 */
Alan Cox's avatar
Alan Cox committed
671
		if (tty->echo_buf[tty->echo_pos] == ECHO_OP_START) {
672 673 674 675 676 677 678 679 680 681 682 683 684 685 686 687 688 689 690 691 692 693 694 695 696 697 698 699 700 701 702 703 704 705 706 707 708 709 710 711 712 713 714 715 716 717 718 719 720 721 722 723 724 725 726 727 728 729 730 731 732 733 734 735 736 737 738 739 740 741 742 743 744 745 746 747 748 749 750 751 752 753 754 755 756 757 758 759 760 761 762 763 764 765
			if (tty->echo_buf[(tty->echo_pos + 1) &
					  (N_TTY_BUF_SIZE - 1)] ==
						ECHO_OP_ERASE_TAB) {
				tty->echo_pos += 3;
				tty->echo_cnt -= 2;
			} else {
				tty->echo_pos += 2;
				tty->echo_cnt -= 1;
			}
		} else {
			tty->echo_pos++;
		}
		tty->echo_pos &= N_TTY_BUF_SIZE - 1;

		tty->echo_overrun = 1;
	} else {
		new_byte_pos = tty->echo_pos + tty->echo_cnt;
		new_byte_pos &= N_TTY_BUF_SIZE - 1;
		tty->echo_cnt++;
	}

	tty->echo_buf[new_byte_pos] = c;
}

/**
 *	echo_move_back_col	-	add operation to move back a column
 *	@tty: terminal device
 *
 *	Add an operation to the echo buffer to move back one column.
 *
 *	Locking: echo_lock to protect the echo buffer
 */

static void echo_move_back_col(struct tty_struct *tty)
{
	mutex_lock(&tty->echo_lock);

	add_echo_byte(ECHO_OP_START, tty);
	add_echo_byte(ECHO_OP_MOVE_BACK_COL, tty);

	mutex_unlock(&tty->echo_lock);
}

/**
 *	echo_set_canon_col	-	add operation to set the canon column
 *	@tty: terminal device
 *
 *	Add an operation to the echo buffer to set the canon column
 *	to the current column.
 *
 *	Locking: echo_lock to protect the echo buffer
 */

static void echo_set_canon_col(struct tty_struct *tty)
{
	mutex_lock(&tty->echo_lock);

	add_echo_byte(ECHO_OP_START, tty);
	add_echo_byte(ECHO_OP_SET_CANON_COL, tty);

	mutex_unlock(&tty->echo_lock);
}

/**
 *	echo_erase_tab	-	add operation to erase a tab
 *	@num_chars: number of character columns already used
 *	@after_tab: true if num_chars starts after a previous tab
 *	@tty: terminal device
 *
 *	Add an operation to the echo buffer to erase a tab.
 *
 *	Called by the eraser function, which knows how many character
 *	columns have been used since either a previous tab or the start
 *	of input.  This information will be used later, along with
 *	canon column (if applicable), to go back the correct number
 *	of columns.
 *
 *	Locking: echo_lock to protect the echo buffer
 */

static void echo_erase_tab(unsigned int num_chars, int after_tab,
			   struct tty_struct *tty)
{
	mutex_lock(&tty->echo_lock);

	add_echo_byte(ECHO_OP_START, tty);
	add_echo_byte(ECHO_OP_ERASE_TAB, tty);

	/* We only need to know this modulo 8 (tab spacing) */
	num_chars &= 7;

	/* Set the high bit as a flag if num_chars is after a previous tab */
	if (after_tab)
		num_chars |= 0x80;
Alan Cox's avatar
Alan Cox committed
766

767 768 769 770 771 772 773 774 775 776 777 778 779 780 781 782 783 784 785 786 787 788 789 790 791 792 793 794 795 796 797
	add_echo_byte(num_chars, tty);

	mutex_unlock(&tty->echo_lock);
}

/**
 *	echo_char_raw	-	echo a character raw
 *	@c: unicode byte to echo
 *	@tty: terminal device
 *
 *	Echo user input back onto the screen. This must be called only when
 *	L_ECHO(tty) is true. Called from the driver receive_buf path.
 *
 *	This variant does not treat control characters specially.
 *
 *	Locking: echo_lock to protect the echo buffer
 */

static void echo_char_raw(unsigned char c, struct tty_struct *tty)
{
	mutex_lock(&tty->echo_lock);

	if (c == ECHO_OP_START) {
		add_echo_byte(ECHO_OP_START, tty);
		add_echo_byte(ECHO_OP_START, tty);
	} else {
		add_echo_byte(c, tty);
	}

	mutex_unlock(&tty->echo_lock);
}
Linus Torvalds's avatar
Linus Torvalds committed
798 799

/**
800
 *	echo_char	-	echo a character
Linus Torvalds's avatar
Linus Torvalds committed
801 802 803
 *	@c: unicode byte to echo
 *	@tty: terminal device
 *
804
 *	Echo user input back onto the screen. This must be called only when
Linus Torvalds's avatar
Linus Torvalds committed
805
 *	L_ECHO(tty) is true. Called from the driver receive_buf path.
806
 *
807 808
 *	This variant tags control characters to be echoed as "^X"
 *	(where X is the letter representing the control char).
809 810
 *
 *	Locking: echo_lock to protect the echo buffer
Linus Torvalds's avatar
Linus Torvalds committed
811 812 813 814
 */

static void echo_char(unsigned char c, struct tty_struct *tty)
{
815 816 817 818 819 820
	mutex_lock(&tty->echo_lock);

	if (c == ECHO_OP_START) {
		add_echo_byte(ECHO_OP_START, tty);
		add_echo_byte(ECHO_OP_START, tty);
	} else {
821
		if (L_ECHOCTL(tty) && iscntrl(c) && c != '\t')
822 823 824 825 826
			add_echo_byte(ECHO_OP_START, tty);
		add_echo_byte(c, tty);
	}

	mutex_unlock(&tty->echo_lock);
Linus Torvalds's avatar
Linus Torvalds committed
827 828
}

829
/**
830
 *	finish_erasing		-	complete erase
831 832
 *	@tty: tty doing the erase
 */
833

Linus Torvalds's avatar
Linus Torvalds committed
834 835 836
static inline void finish_erasing(struct tty_struct *tty)
{
	if (tty->erasing) {
837
		echo_char_raw('/', tty);
Linus Torvalds's avatar
Linus Torvalds committed
838 839 840 841 842 843 844 845 846
		tty->erasing = 0;
	}
}

/**
 *	eraser		-	handle erase function
 *	@c: character input
 *	@tty: terminal device
 *
847
 *	Perform erase and necessary output when an erase character is
Linus Torvalds's avatar
Linus Torvalds committed
848 849
 *	present in the stream from the driver layer. Handles the complexities
 *	of UTF-8 multibyte symbols.
850
 *
851
 *	Locking: read_lock for tty buffers
Linus Torvalds's avatar
Linus Torvalds committed
852
 */
853

Linus Torvalds's avatar
Linus Torvalds committed
854 855 856 857 858 859
static void eraser(unsigned char c, struct tty_struct *tty)
{
	enum { ERASE, WERASE, KILL } kill_type;
	int head, seen_alnums, cnt;
	unsigned long flags;

860
	/* FIXME: locking needed ? */
Linus Torvalds's avatar
Linus Torvalds committed
861
	if (tty->read_head == tty->canon_head) {
862
		/* process_output('\a', tty); */ /* what do you think? */
Linus Torvalds's avatar
Linus Torvalds committed
863 864 865 866 867 868 869 870 871 872 873 874 875 876 877 878 879 880 881 882 883 884 885 886 887
		return;
	}
	if (c == ERASE_CHAR(tty))
		kill_type = ERASE;
	else if (c == WERASE_CHAR(tty))
		kill_type = WERASE;
	else {
		if (!L_ECHO(tty)) {
			spin_lock_irqsave(&tty->read_lock, flags);
			tty->read_cnt -= ((tty->read_head - tty->canon_head) &
					  (N_TTY_BUF_SIZE - 1));
			tty->read_head = tty->canon_head;
			spin_unlock_irqrestore(&tty->read_lock, flags);
			return;
		}
		if (!L_ECHOK(tty) || !L_ECHOKE(tty) || !L_ECHOE(tty)) {
			spin_lock_irqsave(&tty->read_lock, flags);
			tty->read_cnt -= ((tty->read_head - tty->canon_head) &
					  (N_TTY_BUF_SIZE - 1));
			tty->read_head = tty->canon_head;
			spin_unlock_irqrestore(&tty->read_lock, flags);
			finish_erasing(tty);
			echo_char(KILL_CHAR(tty), tty);
			/* Add a newline if ECHOK is on and ECHOKE is off. */
			if (L_ECHOK(tty))
888
				echo_char_raw('\n', tty);
Linus Torvalds's avatar
Linus Torvalds committed
889 890 891 892 893 894
			return;
		}
		kill_type = KILL;
	}

	seen_alnums = 0;
895
	/* FIXME: Locking ?? */
Linus Torvalds's avatar
Linus Torvalds committed
896 897 898 899 900 901 902 903 904 905 906 907 908 909 910 911 912 913 914 915 916 917 918 919 920 921 922 923
	while (tty->read_head != tty->canon_head) {
		head = tty->read_head;

		/* erase a single possibly multibyte character */
		do {
			head = (head - 1) & (N_TTY_BUF_SIZE-1);
			c = tty->read_buf[head];
		} while (is_continuation(c, tty) && head != tty->canon_head);

		/* do not partially erase */
		if (is_continuation(c, tty))
			break;

		if (kill_type == WERASE) {
			/* Equivalent to BSD's ALTWERASE. */
			if (isalnum(c) || c == '_')
				seen_alnums++;
			else if (seen_alnums)
				break;
		}
		cnt = (tty->read_head - head) & (N_TTY_BUF_SIZE-1);
		spin_lock_irqsave(&tty->read_lock, flags);
		tty->read_head = head;
		tty->read_cnt -= cnt;
		spin_unlock_irqrestore(&tty->read_lock, flags);
		if (L_ECHO(tty)) {
			if (L_ECHOPRT(tty)) {
				if (!tty->erasing) {
924
					echo_char_raw('\\', tty);
Linus Torvalds's avatar
Linus Torvalds committed
925 926 927 928 929 930
					tty->erasing = 1;
				}
				/* if cnt > 1, output a multi-byte character */
				echo_char(c, tty);
				while (--cnt > 0) {
					head = (head+1) & (N_TTY_BUF_SIZE-1);
931 932
					echo_char_raw(tty->read_buf[head], tty);
					echo_move_back_col(tty);
Linus Torvalds's avatar
Linus Torvalds committed
933 934 935 936
				}
			} else if (kill_type == ERASE && !L_ECHOE(tty)) {
				echo_char(ERASE_CHAR(tty), tty);
			} else if (c == '\t') {
937 938 939 940 941 942 943 944 945 946 947 948 949
				unsigned int num_chars = 0;
				int after_tab = 0;
				unsigned long tail = tty->read_head;

				/*
				 * Count the columns used for characters
				 * since the start of input or after a
				 * previous tab.
				 * This info is used to go back the correct
				 * number of columns.
				 */
				while (tail != tty->canon_head) {
					tail = (tail-1) & (N_TTY_BUF_SIZE-1);
Linus Torvalds's avatar
Linus Torvalds committed
950
					c = tty->read_buf[tail];
951 952 953
					if (c == '\t') {
						after_tab = 1;
						break;
Alan Cox's avatar
Alan Cox committed
954
					} else if (iscntrl(c)) {
Linus Torvalds's avatar
Linus Torvalds committed
955
						if (L_ECHOCTL(tty))
956 957 958 959
							num_chars += 2;
					} else if (!is_continuation(c, tty)) {
						num_chars++;
					}
Linus Torvalds's avatar
Linus Torvalds committed
960
				}
961
				echo_erase_tab(num_chars, after_tab, tty);
Linus Torvalds's avatar
Linus Torvalds committed
962 963
			} else {
				if (iscntrl(c) && L_ECHOCTL(tty)) {
964 965 966
					echo_char_raw('\b', tty);
					echo_char_raw(' ', tty);
					echo_char_raw('\b', tty);
Linus Torvalds's avatar
Linus Torvalds committed
967 968
				}
				if (!iscntrl(c) || L_ECHOCTL(tty)) {
969 970 971
					echo_char_raw('\b', tty);
					echo_char_raw(' ', tty);
					echo_char_raw('\b', tty);
Linus Torvalds's avatar
Linus Torvalds committed
972 973 974 975 976 977
				}
			}
		}
		if (kill_type == ERASE)
			break;
	}
978
	if (tty->read_head == tty->canon_head && L_ECHO(tty))
Linus Torvalds's avatar
Linus Torvalds committed
979 980 981 982 983 984 985 986 987 988 989 990 991
		finish_erasing(tty);
}

/**
 *	isig		-	handle the ISIG optio
 *	@sig: signal
 *	@tty: terminal
 *	@flush: force flush
 *
 *	Called when a signal is being sent due to terminal input. This
 *	may caus terminal flushing to take place according to the termios
 *	settings and character used. Called from the driver receive_buf
 *	path so serialized.
992 993
 *
 *	Locking: ctrl_lock, read_lock (both via flush buffer)
Linus Torvalds's avatar
Linus Torvalds committed
994
 */
995

Linus Torvalds's avatar
Linus Torvalds committed
996 997
static inline void isig(int sig, struct tty_struct *tty, int flush)
{
998 999
	if (tty->pgrp)
		kill_pgrp(tty->pgrp, sig, 1);
Linus Torvalds's avatar
Linus Torvalds committed
1000 1001
	if (flush || !L_NOFLSH(tty)) {
		n_tty_flush_buffer(tty);
Alan Cox's avatar
Alan Cox committed
1002
		tty_driver_flush_buffer(tty);
Linus Torvalds's avatar
Linus Torvalds committed
1003 1004 1005 1006 1007 1008 1009 1010 1011 1012 1013 1014
	}
}

/**
 *	n_tty_receive_break	-	handle break
 *	@tty: terminal
 *
 *	An RS232 break event has been hit in the incoming bitstream. This
 *	can cause a variety of events depending upon the termios settings.
 *
 *	Called from the receive_buf path so single threaded.
 */
1015

Linus Torvalds's avatar
Linus Torvalds committed
1016 1017 1018 1019 1020 1021 1022 1023 1024 1025 1026 1027 1028 1029 1030 1031 1032 1033 1034 1035 1036 1037 1038 1039 1040 1041 1042 1043
static inline void n_tty_receive_break(struct tty_struct *tty)
{
	if (I_IGNBRK(tty))
		return;
	if (I_BRKINT(tty)) {
		isig(SIGINT, tty, 1);
		return;
	}
	if (I_PARMRK(tty)) {
		put_tty_queue('\377', tty);
		put_tty_queue('\0', tty);
	}
	put_tty_queue('\0', tty);
	wake_up_interruptible(&tty->read_wait);
}

/**
 *	n_tty_receive_overrun	-	handle overrun reporting
 *	@tty: terminal
 *
 *	Data arrived faster than we could process it. While the tty
 *	driver has flagged this the bits that were missed are gone
 *	forever.
 *
 *	Called from the receive_buf path so single threaded. Does not
 *	need locking as num_overrun and overrun_time are function
 *	private.
 */
1044

Linus Torvalds's avatar
Linus Torvalds committed
1045 1046 1047 1048 1049 1050 1051 1052 1053 1054 1055 1056 1057 1058 1059 1060 1061 1062 1063 1064 1065
static inline void n_tty_receive_overrun(struct tty_struct *tty)
{
	char buf[64];

	tty->num_overrun++;
	if (time_before(tty->overrun_time, jiffies - HZ) ||
			time_after(tty->overrun_time, jiffies)) {
		printk(KERN_WARNING "%s: %d input overrun(s)\n",
			tty_name(tty, buf),
			tty->num_overrun);
		tty->overrun_time = jiffies;
		tty->num_overrun = 0;
	}
}

/**
 *	n_tty_receive_parity_error	-	error notifier
 *	@tty: terminal device
 *	@c: character
 *
 *	Process a parity error and queue the right data to indicate
1066
 *	the error case if necessary. Locking as per n_tty_receive_buf.
Linus Torvalds's avatar
Linus Torvalds committed
1067 1068 1069 1070
 */
static inline void n_tty_receive_parity_error(struct tty_struct *tty,
					      unsigned char c)
{
1071
	if (I_IGNPAR(tty))
Linus Torvalds's avatar
Linus Torvalds committed
1072 1073 1074 1075 1076 1077 1078 1079 1080 1081 1082 1083 1084 1085 1086 1087 1088 1089
		return;
	if (I_PARMRK(tty)) {
		put_tty_queue('\377', tty);
		put_tty_queue('\0', tty);
		put_tty_queue(c, tty);
	} else	if (I_INPCK(tty))
		put_tty_queue('\0', tty);
	else
		put_tty_queue(c, tty);
	wake_up_interruptible(&tty->read_wait);
}

/**
 *	n_tty_receive_char	-	perform processing
 *	@tty: terminal device
 *	@c: character
 *
 *	Process an individual character of input received from the driver.
1090
 *	This is serialized with respect to itself by the rules for the
Linus Torvalds's avatar
Linus Torvalds committed
1091 1092 1093 1094 1095 1096
 *	driver above.
 */

static inline void n_tty_receive_char(struct tty_struct *tty, unsigned char c)
{
	unsigned long flags;
1097
	int parmrk;
Linus Torvalds's avatar
Linus Torvalds committed
1098 1099 1100 1101 1102

	if (tty->raw) {
		put_tty_queue(c, tty);
		return;
	}
1103

Linus Torvalds's avatar
Linus Torvalds committed
1104 1105 1106
	if (I_ISTRIP(tty))
		c &= 0x7f;
	if (I_IUCLC(tty) && L_IEXTEN(tty))
Alan Cox's avatar
Alan Cox committed
1107
		c = tolower(c);
Linus Torvalds's avatar
Linus Torvalds committed
1108

1109 1110 1111 1112 1113
	if (L_EXTPROC(tty)) {
		put_tty_queue(c, tty);
		return;
	}

1114
	if (tty->stopped && !tty->flow_stopped && I_IXON(tty) &&
1115 1116
	    I_IXANY(tty) && c != START_CHAR(tty) && c != STOP_CHAR(tty) &&
	    c != INTR_CHAR(tty) && c != QUIT_CHAR(tty) && c != SUSP_CHAR(tty)) {
1117
		start_tty(tty);
1118 1119
		process_echoes(tty);
	}
1120

Linus Torvalds's avatar
Linus Torvalds committed
1121 1122
	if (tty->closing) {
		if (I_IXON(tty)) {
1123
			if (c == START_CHAR(tty)) {
Linus Torvalds's avatar
Linus Torvalds committed
1124
				start_tty(tty);
1125
				process_echoes(tty);
Alan Cox's avatar
Alan Cox committed
1126
			} else if (c == STOP_CHAR(tty))
Linus Torvalds's avatar
Linus Torvalds committed
1127 1128 1129 1130 1131 1132 1133 1134 1135 1136 1137 1138 1139
				stop_tty(tty);
		}
		return;
	}

	/*
	 * If the previous character was LNEXT, or we know that this
	 * character is not one of the characters that we'll have to
	 * handle specially, do shortcut processing to speed things
	 * up.
	 */
	if (!test_bit(c, tty->process_char_map) || tty->lnext) {
		tty->lnext = 0;
1140 1141 1142
		parmrk = (c == (unsigned char) '\377' && I_PARMRK(tty)) ? 1 : 0;
		if (tty->read_cnt >= (N_TTY_BUF_SIZE - parmrk - 1)) {
			/* beep if no space */
1143 1144
			if (L_ECHO(tty))
				process_output('\a', tty);
1145 1146 1147 1148
			return;
		}
		if (L_ECHO(tty)) {
			finish_erasing(tty);
Linus Torvalds's avatar
Linus Torvalds committed
1149 1150
			/* Record the column of first canon char. */
			if (tty->canon_head == tty->read_head)
1151
				echo_set_canon_col(tty);
Linus Torvalds's avatar
Linus Torvalds committed
1152
			echo_char(c, tty);
1153
			process_echoes(tty);
Linus Torvalds's avatar
Linus Torvalds committed
1154
		}
1155
		if (parmrk)
Linus Torvalds's avatar
Linus Torvalds committed
1156 1157 1158 1159
			put_tty_queue(c, tty);
		put_tty_queue(c, tty);
		return;
	}
1160

Linus Torvalds's avatar
Linus Torvalds committed
1161 1162 1163
	if (I_IXON(tty)) {
		if (c == START_CHAR(tty)) {
			start_tty(tty);
1164
			process_echoes(tty);
Linus Torvalds's avatar
Linus Torvalds committed
1165 1166 1167 1168 1169 1170 1171
			return;
		}
		if (c == STOP_CHAR(tty)) {
			stop_tty(tty);
			return;
		}
	}
1172

Linus Torvalds's avatar
Linus Torvalds committed
1173 1174 1175 1176 1177 1178 1179 1180 1181 1182 1183
	if (L_ISIG(tty)) {
		int signal;
		signal = SIGINT;
		if (c == INTR_CHAR(tty))
			goto send_signal;
		signal = SIGQUIT;
		if (c == QUIT_CHAR(tty))
			goto send_signal;
		signal = SIGTSTP;
		if (c == SUSP_CHAR(tty)) {
send_signal:
1184 1185 1186 1187 1188 1189 1190
			/*
			 * Note that we do not use isig() here because we want
			 * the order to be:
			 * 1) flush, 2) echo, 3) signal
			 */
			if (!L_NOFLSH(tty)) {
				n_tty_flush_buffer(tty);
Alan Cox's avatar
Alan Cox committed
1191
				tty_driver_flush_buffer(tty);
1192
			}
1193 1194 1195
			if (I_IXON(tty))
				start_tty(tty);
			if (L_ECHO(tty)) {
1196
				echo_char(c, tty);
1197 1198
				process_echoes(tty);
			}
1199 1200
			if (tty->pgrp)
				kill_pgrp(tty->pgrp, signal, 1);
Linus Torvalds's avatar
Linus Torvalds committed
1201 1202 1203
			return;
		}
	}
1204 1205 1206 1207 1208 1209 1210 1211 1212

	if (c == '\r') {
		if (I_IGNCR(tty))
			return;
		if (I_ICRNL(tty))
			c = '\n';
	} else if (c == '\n' && I_INLCR(tty))
		c = '\r';

Linus Torvalds's avatar
Linus Torvalds committed
1213 1214 1215 1216
	if (tty->icanon) {
		if (c == ERASE_CHAR(tty) || c == KILL_CHAR(tty) ||
		    (c == WERASE_CHAR(tty) && L_IEXTEN(tty))) {
			eraser(c, tty);
1217
			process_echoes(tty);
Linus Torvalds's avatar
Linus Torvalds committed
1218 1219 1220 1221 1222 1223 1224
			return;
		}
		if (c == LNEXT_CHAR(tty) && L_IEXTEN(tty)) {
			tty->lnext = 1;
			if (L_ECHO(tty)) {
				finish_erasing(tty);
				if (L_ECHOCTL(tty)) {
1225 1226 1227
					echo_char_raw('^', tty);
					echo_char_raw('\b', tty);
					process_echoes(tty);
Linus Torvalds's avatar
Linus Torvalds committed
1228 1229 1230 1231 1232 1233 1234 1235 1236 1237
				}
			}
			return;
		}
		if (c == REPRINT_CHAR(tty) && L_ECHO(tty) &&
		    L_IEXTEN(tty)) {
			unsigned long tail = tty->canon_head;

			finish_erasing(tty);
			echo_char(c, tty);
1238
			echo_char_raw('\n', tty);
Linus Torvalds's avatar
Linus Torvalds committed
1239 1240 1241 1242
			while (tail != tty->read_head) {
				echo_char(tty->read_buf[tail], tty);
				tail = (tail+1) & (N_TTY_BUF_SIZE-1);
			}
1243
			process_echoes(tty);
Linus Torvalds's avatar
Linus Torvalds committed
1244 1245 1246
			return;
		}
		if (c == '\n') {
1247
			if (tty->read_cnt >= N_TTY_BUF_SIZE) {
1248 1249
				if (L_ECHO(tty))
					process_output('\a', tty);
1250 1251 1252
				return;
			}
			if (L_ECHO(tty) || L_ECHONL(tty)) {
1253 1254
				echo_char_raw('\n', tty);
				process_echoes(tty);
Linus Torvalds's avatar
Linus Torvalds committed
1255 1256 1257 1258
			}
			goto handle_newline;
		}
		if (c == EOF_CHAR(tty)) {
1259 1260
			if (tty->read_cnt >= N_TTY_BUF_SIZE)
				return;
1261 1262
			if (tty->canon_head != tty->read_head)
				set_bit(TTY_PUSH, &tty->flags);
Linus Torvalds's avatar
Linus Torvalds committed
1263 1264 1265 1266 1267
			c = __DISABLED_CHAR;
			goto handle_newline;
		}
		if ((c == EOL_CHAR(tty)) ||
		    (c == EOL2_CHAR(tty) && L_IEXTEN(tty))) {
1268 1269 1270
			parmrk = (c == (unsigned char) '\377' && I_PARMRK(tty))
				 ? 1 : 0;
			if (tty->read_cnt >= (N_TTY_BUF_SIZE - parmrk)) {
1271 1272
				if (L_ECHO(tty))
					process_output('\a', tty);
1273 1274
				return;
			}
Linus Torvalds's avatar
Linus Torvalds committed
1275 1276 1277 1278 1279 1280
			/*
			 * XXX are EOL_CHAR and EOL2_CHAR echoed?!?
			 */
			if (L_ECHO(tty)) {
				/* Record the column of first canon char. */
				if (tty->canon_head == tty->read_head)
1281
					echo_set_canon_col(tty);
Linus Torvalds's avatar
Linus Torvalds committed
1282
				echo_char(c, tty);
1283
				process_echoes(tty);
Linus Torvalds's avatar
Linus Torvalds committed
1284 1285 1286 1287 1288
			}
			/*
			 * XXX does PARMRK doubling happen for
			 * EOL_CHAR and EOL2_CHAR?
			 */
1289
			if (parmrk)
Linus Torvalds's avatar
Linus Torvalds committed
1290 1291
				put_tty_queue(c, tty);

1292
handle_newline:
Linus Torvalds's avatar
Linus Torvalds committed
1293 1294 1295 1296 1297 1298 1299 1300 1301 1302 1303 1304
			spin_lock_irqsave(&tty->read_lock, flags);
			set_bit(tty->read_head, tty->read_flags);
			put_tty_queue_nolock(c, tty);
			tty->canon_head = tty->read_head;
			tty->canon_data++;
			spin_unlock_irqrestore(&tty->read_lock, flags);
			kill_fasync(&tty->fasync, SIGIO, POLL_IN);
			if (waitqueue_active(&tty->read_wait))
				wake_up_interruptible(&tty->read_wait);
			return;
		}
	}
1305

1306 1307 1308
	parmrk = (c == (unsigned char) '\377' && I_PARMRK(tty)) ? 1 : 0;
	if (tty->read_cnt >= (N_TTY_BUF_SIZE - parmrk - 1)) {
		/* beep if no space */
1309 1310
		if (L_ECHO(tty))
			process_output('\a', tty);
1311 1312 1313 1314
		return;
	}
	if (L_ECHO(tty)) {
		finish_erasing(tty);
Linus Torvalds's avatar
Linus Torvalds committed
1315
		if (c == '\n')
1316
			echo_char_raw('\n', tty);
Linus Torvalds's avatar
Linus Torvalds committed
1317 1318 1319
		else {
			/* Record the column of first canon char. */
			if (tty->canon_head == tty->read_head)
1320
				echo_set_canon_col(tty);
Linus Torvalds's avatar
Linus Torvalds committed
1321 1322
			echo_char(c, tty);
		}
1323
		process_echoes(tty);
Linus Torvalds's avatar
Linus Torvalds committed
1324 1325
	}

1326
	if (parmrk)
Linus Torvalds's avatar
Linus Torvalds committed
1327 1328 1329
		put_tty_queue(c, tty);

	put_tty_queue(c, tty);
1330
}
Linus Torvalds's avatar
Linus Torvalds committed
1331 1332 1333 1334 1335 1336 1337 1338 1339 1340 1341 1342 1343


/**
 *	n_tty_write_wakeup	-	asynchronous I/O notifier
 *	@tty: tty device
 *
 *	Required for the ptys, serial driver etc. since processes
 *	that attach themselves to the master and rely on ASYNC
 *	IO must be woken up
 */

static void n_tty_write_wakeup(struct tty_struct *tty)
{
1344
	if (tty->fasync && test_and_clear_bit(TTY_DO_WRITE_WAKEUP, &tty->flags))
Linus Torvalds's avatar
Linus Torvalds committed
1345 1346 1347 1348 1349 1350 1351 1352 1353 1354 1355 1356 1357 1358 1359
		kill_fasync(&tty->fasync, SIGIO, POLL_OUT);
}

/**
 *	n_tty_receive_buf	-	data receive
 *	@tty: terminal device
 *	@cp: buffer
 *	@fp: flag buffer
 *	@count: characters
 *
 *	Called by the terminal driver when a block of characters has
 *	been received. This function must be called from soft contexts
 *	not from interrupt context. The driver is responsible for making
 *	calls one at a time and in order (or using flush_to_ldisc)
 */
1360

1361 1362
static void n_tty_receive_buf(struct tty_struct *tty, const unsigned char *cp,
			      char *fp, int count)
Linus Torvalds's avatar
Linus Torvalds committed
1363 1364 1365 1366 1367 1368 1369 1370
{
	const unsigned char *p;
	char *f, flags = TTY_NORMAL;
	int	i;
	char	buf[64];
	unsigned long cpuflags;

	if (!tty->read_buf)
1371
		return;
Linus Torvalds's avatar
Linus Torvalds committed
1372 1373 1374 1375 1376 1377 1378 1379 1380 1381 1382 1383 1384 1385 1386 1387 1388 1389 1390 1391

	if (tty->real_raw) {
		spin_lock_irqsave(&tty->read_lock, cpuflags);
		i = min(N_TTY_BUF_SIZE - tty->read_cnt,
			N_TTY_BUF_SIZE - tty->read_head);
		i = min(count, i);
		memcpy(tty->read_buf + tty->read_head, cp, i);
		tty->read_head = (tty->read_head + i) & (N_TTY_BUF_SIZE-1);
		tty->read_cnt += i;
		cp += i;
		count -= i;

		i = min(N_TTY_BUF_SIZE - tty->read_cnt,
			N_TTY_BUF_SIZE - tty->read_head);
		i = min(count, i);
		memcpy(tty->read_buf + tty->read_head, cp, i);
		tty->read_head = (tty->read_head + i) & (N_TTY_BUF_SIZE-1);
		tty->read_cnt += i;
		spin_unlock_irqrestore(&tty->read_lock, cpuflags);
	} else {
1392
		for (i = count, p = cp, f = fp; i; i--, p++) {
Linus Torvalds's avatar
Linus Torvalds committed
1393 1394 1395 1396 1397 1398 1399 1400 1401 1402 1403 1404 1405 1406 1407 1408 1409
			if (f)
				flags = *f++;
			switch (flags) {
			case TTY_NORMAL:
				n_tty_receive_char(tty, *p);
				break;
			case TTY_BREAK:
				n_tty_receive_break(tty);
				break;
			case TTY_PARITY:
			case TTY_FRAME:
				n_tty_receive_parity_error(tty, *p);
				break;
			case TTY_OVERRUN:
				n_tty_receive_overrun(tty);
				break;
			default:
1410
				printk(KERN_ERR "%s: unknown flag %d\n",
Linus Torvalds's avatar
Linus Torvalds committed
1411 1412 1413 1414
				       tty_name(tty, buf), flags);
				break;
			}
		}
Alan Cox's avatar
Alan Cox committed
1415 1416
		if (tty->ops->flush_chars)
			tty->ops->flush_chars(tty);
Linus Torvalds's avatar
Linus Torvalds committed
1417 1418
	}

1419 1420
	n_tty_set_room(tty);

1421 1422
	if ((!tty->icanon && (tty->read_cnt >= tty->minimum_to_wake)) ||
		L_EXTPROC(tty)) {
Linus Torvalds's avatar
Linus Torvalds committed
1423 1424 1425 1426 1427 1428 1429 1430 1431 1432
		kill_fasync(&tty->fasync, SIGIO, POLL_IN);
		if (waitqueue_active(&tty->read_wait))
			wake_up_interruptible(&tty->read_wait);
	}

	/*
	 * Check the remaining room for the input canonicalization
	 * mode.  We don't want to throttle the driver if we're in
	 * canonical mode and don't have a newline yet!
	 */
1433
	if (tty->receive_room < TTY_THRESHOLD_THROTTLE)
1434
		tty_throttle(tty);
Alan Cox's avatar
Alan Cox committed
1435 1436 1437 1438 1439 1440

        /* FIXME: there is a tiny race here if the receive room check runs
           before the other work executes and empties the buffer (upping
           the receiving room and unthrottling. We then throttle and get
           stuck. This has been observed and traced down by Vincent Pillet/
           We need to address this when we sort out out the rx path locking */
Linus Torvalds's avatar
Linus Torvalds committed
1441 1442 1443 1444 1445
}

int is_ignored(int sig)
{
	return (sigismember(&current->blocked, sig) ||
1446
		current->sighand->action[sig-1].sa.sa_handler == SIG_IGN);
Linus Torvalds's avatar
Linus Torvalds committed
1447 1448 1449 1450 1451 1452 1453 1454 1455
}

/**
 *	n_tty_set_termios	-	termios data changed
 *	@tty: terminal
 *	@old: previous data
 *
 *	Called by the tty layer when the user changes termios flags so
 *	that the line discipline can plan ahead. This function cannot sleep
1456
 *	and is protected from re-entry by the tty layer. The user is
Linus Torvalds's avatar
Linus Torvalds committed
1457 1458
 *	guaranteed that this function will not be re-entered or in progress
 *	when the ldisc is closed.
1459 1460
 *
 *	Locking: Caller holds tty->termios_mutex
Linus Torvalds's avatar
Linus Torvalds committed
1461
 */
1462 1463

static void n_tty_set_termios(struct tty_struct *tty, struct ktermios *old)
Linus Torvalds's avatar
Linus Torvalds committed
1464
{
1465 1466 1467 1468
	int canon_change = 1;
	BUG_ON(!tty);

	if (old)
1469
		canon_change = (old->c_lflag ^ tty->termios.c_lflag) & ICANON;
1470 1471 1472 1473 1474 1475 1476 1477 1478
	if (canon_change) {
		memset(&tty->read_flags, 0, sizeof tty->read_flags);
		tty->canon_head = tty->read_tail;
		tty->canon_data = 0;
		tty->erasing = 0;
	}

	if (canon_change && !L_ICANON(tty) && tty->read_cnt)
		wake_up_interruptible(&tty->read_wait);
1479

Linus Torvalds's avatar
Linus Torvalds committed
1480 1481 1482 1483
	tty->icanon = (L_ICANON(tty) != 0);
	if (test_bit(TTY_HW_COOK_IN, &tty->flags)) {
		tty->raw = 1;
		tty->real_raw = 1;
1484
		n_tty_set_room(tty);
Linus Torvalds's avatar
Linus Torvalds committed
1485 1486 1487 1488 1489 1490 1491 1492 1493 1494 1495 1496 1497 1498 1499 1500 1501 1502 1503 1504 1505 1506 1507 1508 1509 1510 1511 1512 1513 1514 1515 1516 1517 1518 1519 1520 1521 1522 1523 1524 1525 1526 1527 1528 1529 1530 1531 1532 1533 1534 1535 1536
		return;
	}
	if (I_ISTRIP(tty) || I_IUCLC(tty) || I_IGNCR(tty) ||
	    I_ICRNL(tty) || I_INLCR(tty) || L_ICANON(tty) ||
	    I_IXON(tty) || L_ISIG(tty) || L_ECHO(tty) ||
	    I_PARMRK(tty)) {
		memset(tty->process_char_map, 0, 256/8);

		if (I_IGNCR(tty) || I_ICRNL(tty))
			set_bit('\r', tty->process_char_map);
		if (I_INLCR(tty))
			set_bit('\n', tty->process_char_map);

		if (L_ICANON(tty)) {
			set_bit(ERASE_CHAR(tty), tty->process_char_map);
			set_bit(KILL_CHAR(tty), tty->process_char_map);
			set_bit(EOF_CHAR(tty), tty->process_char_map);
			set_bit('\n', tty->process_char_map);
			set_bit(EOL_CHAR(tty), tty->process_char_map);
			if (L_IEXTEN(tty)) {
				set_bit(WERASE_CHAR(tty),
					tty->process_char_map);
				set_bit(LNEXT_CHAR(tty),
					tty->process_char_map);
				set_bit(EOL2_CHAR(tty),
					tty->process_char_map);
				if (L_ECHO(tty))
					set_bit(REPRINT_CHAR(tty),
						tty->process_char_map);
			}
		}
		if (I_IXON(tty)) {
			set_bit(START_CHAR(tty), tty->process_char_map);
			set_bit(STOP_CHAR(tty), tty->process_char_map);
		}
		if (L_ISIG(tty)) {
			set_bit(INTR_CHAR(tty), tty->process_char_map);
			set_bit(QUIT_CHAR(tty), tty->process_char_map);
			set_bit(SUSP_CHAR(tty), tty->process_char_map);
		}
		clear_bit(__DISABLED_CHAR, tty->process_char_map);
		tty->raw = 0;
		tty->real_raw = 0;
	} else {
		tty->raw = 1;
		if ((I_IGNBRK(tty) || (!I_BRKINT(tty) && !I_PARMRK(tty))) &&
		    (I_IGNPAR(tty) || !I_INPCK(tty)) &&
		    (tty->driver->flags & TTY_DRIVER_REAL_RAW))
			tty->real_raw = 1;
		else
			tty->real_raw = 0;
	}
1537
	n_tty_set_room(tty);
Alan Cox's avatar
Alan Cox committed
1538 1539 1540
	/* The termios change make the tty ready for I/O */
	wake_up_interruptible(&tty->write_wait);
	wake_up_interruptible(&tty->read_wait);
Linus Torvalds's avatar
Linus Torvalds committed
1541 1542 1543 1544 1545 1546
}

/**
 *	n_tty_close		-	close the ldisc for this tty
 *	@tty: device
 *
1547 1548
 *	Called from the terminal layer when this line discipline is
 *	being shut down, either because of a close or becsuse of a
Linus Torvalds's avatar
Linus Torvalds committed
1549 1550 1551
 *	discipline change. The function will not be called while other
 *	ldisc methods are in progress.
 */
1552

Linus Torvalds's avatar
Linus Torvalds committed
1553 1554 1555 1556
static void n_tty_close(struct tty_struct *tty)
{
	n_tty_flush_buffer(tty);
	if (tty->read_buf) {
1557
		kfree(tty->read_buf);
Linus Torvalds's avatar
Linus Torvalds committed
1558 1559
		tty->read_buf = NULL;
	}
1560
	if (tty->echo_buf) {
1561
		kfree(tty->echo_buf);
1562 1563
		tty->echo_buf = NULL;
	}
Linus Torvalds's avatar
Linus Torvalds committed
1564 1565 1566 1567 1568 1569
}

/**
 *	n_tty_open		-	open an ldisc
 *	@tty: terminal to open
 *
1570
 *	Called when this line discipline is being attached to the
Linus Torvalds's avatar
Linus Torvalds committed
1571 1572 1573 1574 1575 1576 1577 1578 1579 1580
 *	terminal device. Can sleep. Called serialized so that no
 *	other events will occur in parallel. No further open will occur
 *	until a close.
 */

static int n_tty_open(struct tty_struct *tty)
{
	if (!tty)
		return -EINVAL;

1581
	/* These are ugly. Currently a malloc failure here can panic */
Linus Torvalds's avatar
Linus Torvalds committed
1582
	if (!tty->read_buf) {
1583
		tty->read_buf = kzalloc(N_TTY_BUF_SIZE, GFP_KERNEL);
Linus Torvalds's avatar
Linus Torvalds committed
1584 1585 1586
		if (!tty->read_buf)
			return -ENOMEM;
	}
1587
	if (!tty->echo_buf) {
1588 1589
		tty->echo_buf = kzalloc(N_TTY_BUF_SIZE, GFP_KERNEL);

1590 1591 1592
		if (!tty->echo_buf)
			return -ENOMEM;
	}
Linus Torvalds's avatar
Linus Torvalds committed
1593
	reset_buffer_flags(tty);
1594
	tty_unthrottle(tty);
Linus Torvalds's avatar
Linus Torvalds committed
1595 1596 1597 1598 1599 1600 1601 1602 1603
	tty->column = 0;
	n_tty_set_termios(tty, NULL);
	tty->minimum_to_wake = 1;
	tty->closing = 0;
	return 0;
}

static inline int input_available_p(struct tty_struct *tty, int amt)
{
1604
	tty_flush_to_ldisc(tty);
1605
	if (tty->icanon && !L_EXTPROC(tty)) {
Linus Torvalds's avatar
Linus Torvalds committed
1606 1607 1608 1609 1610 1611 1612 1613 1614
		if (tty->canon_data)
			return 1;
	} else if (tty->read_cnt >= (amt ? amt : 1))
		return 1;

	return 0;
}

/**
1615
 *	copy_from_read_buf	-	copy read data directly
Linus Torvalds's avatar
Linus Torvalds committed
1616 1617 1618 1619
 *	@tty: terminal device
 *	@b: user data
 *	@nr: size of data
 *
1620
 *	Helper function to speed up n_tty_read.  It is only called when
Linus Torvalds's avatar
Linus Torvalds committed
1621 1622 1623 1624 1625 1626
 *	ICANON is off; it copies characters straight from the tty queue to
 *	user space directly.  It can be profitably called twice; once to
 *	drain the space from the tail pointer to the (physical) end of the
 *	buffer, and once to drain the space from the (physical) beginning of
 *	the buffer to head pointer.
 *
Paul Fulghum's avatar
Paul Fulghum committed
1627
 *	Called under the tty->atomic_read_lock sem
Linus Torvalds's avatar
Linus Torvalds committed
1628 1629
 *
 */
1630

1631
static int copy_from_read_buf(struct tty_struct *tty,
Linus Torvalds's avatar
Linus Torvalds committed
1632 1633 1634 1635 1636 1637 1638
				      unsigned char __user **b,
				      size_t *nr)

{
	int retval;
	size_t n;
	unsigned long flags;
1639
	bool is_eof;
Linus Torvalds's avatar
Linus Torvalds committed
1640 1641 1642 1643 1644 1645 1646 1647 1648

	retval = 0;
	spin_lock_irqsave(&tty->read_lock, flags);
	n = min(tty->read_cnt, N_TTY_BUF_SIZE - tty->read_tail);
	n = min(*nr, n);
	spin_unlock_irqrestore(&tty->read_lock, flags);
	if (n) {
		retval = copy_to_user(*b, &tty->read_buf[tty->read_tail], n);
		n -= retval;
1649 1650
		is_eof = n == 1 &&
			tty->read_buf[tty->read_tail] == EOF_CHAR(tty);
1651
		tty_audit_add_data(tty, &tty->read_buf[tty->read_tail], n);
Linus Torvalds's avatar
Linus Torvalds committed
1652 1653 1654
		spin_lock_irqsave(&tty->read_lock, flags);
		tty->read_tail = (tty->read_tail + n) & (N_TTY_BUF_SIZE-1);
		tty->read_cnt -= n;
1655
		/* Turn single EOF into zero-length read */
1656 1657
		if (L_EXTPROC(tty) && tty->icanon && is_eof && !tty->read_cnt)
			n = 0;
Linus Torvalds's avatar
Linus Torvalds committed
1658 1659 1660 1661 1662 1663 1664
		spin_unlock_irqrestore(&tty->read_lock, flags);
		*b += n;
		*nr -= n;
	}
	return retval;
}

1665
extern ssize_t redirected_tty_write(struct file *, const char __user *,
1666
							size_t, loff_t *);
Linus Torvalds's avatar
Linus Torvalds committed
1667 1668 1669 1670 1671 1672 1673

/**
 *	job_control		-	check job control
 *	@tty: tty
 *	@file: file handle
 *
 *	Perform job control management checks on this file/tty descriptor
1674
 *	and if appropriate send any needed signals and return a negative
Linus Torvalds's avatar
Linus Torvalds committed
1675
 *	error code if action should be taken.
Alan Cox's avatar
Alan Cox committed
1676 1677 1678 1679 1680
 *
 *	FIXME:
 *	Locking: None - redirected write test is safe, testing
 *	current->signal should possibly lock current->sighand
 *	pgrp locking ?
Linus Torvalds's avatar
Linus Torvalds committed
1681
 */
1682