n_tty.c 60.3 KB
Newer Older
L
Linus Torvalds 已提交
1 2
/*
 * n_tty.c --- implements the N_TTY line discipline.
3
 *
L
Linus Torvalds 已提交
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.
L
Linus Torvalds 已提交
12 13
 *
 * Written by Theodore Ts'o, Copyright 1994.
14
 *
L
Linus Torvalds 已提交
15 16
 * This file also contains code originally written by Linus Torvalds,
 * Copyright 1991, 1992, 1993, and by Julian Cowley, Copyright 1994.
17
 *
L
Linus Torvalds 已提交
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
L
Linus Torvalds 已提交
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
L
Linus Torvalds 已提交
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>
M
Miloslav Trmac 已提交
48 49
#include <linux/audit.h>
#include <linux/file.h>
A
Alan Cox 已提交
50
#include <linux/uaccess.h>
51
#include <linux/module.h>
52
#include <linux/ratelimit.h>
53
#include <linux/vmalloc.h>
L
Linus Torvalds 已提交
54 55 56 57 58 59 60 61 62 63 64


/* 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 */
65
#define TTY_THRESHOLD_UNTHROTTLE	128
L
Linus Torvalds 已提交
66

67 68 69 70 71 72 73 74 75 76 77
/*
 * 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

P
Peter Hurley 已提交
78 79 80 81 82
#define ECHO_COMMIT_WATERMARK	256
#define ECHO_BLOCK		256
#define ECHO_DISCARD_WATERMARK	N_TTY_BUF_SIZE - (ECHO_BLOCK + 32)


83 84 85 86 87 88 89
#undef N_TTY_TRACE
#ifdef N_TTY_TRACE
# define n_tty_trace(f, args...)	trace_printk(f, ##args)
#else
# define n_tty_trace(f, args...)
#endif

J
Jiri Slaby 已提交
90
struct n_tty_data {
91 92 93
	/* producer-published */
	size_t read_head;
	size_t canon_head;
94 95
	size_t echo_head;
	size_t echo_commit;
96
	DECLARE_BITMAP(char_map, 256);
97 98

	/* private to n_tty_receive_overrun (single-threaded) */
99 100 101
	unsigned long overrun_time;
	int num_overrun;

102 103 104
	/* non-atomic */
	bool no_room;

105
	/* must hold exclusive termios_rwsem to reset these */
106
	unsigned char lnext:1, erasing:1, raw:1, real_raw:1, icanon:1;
107

108
	/* shared by producer and consumer */
109
	char read_buf[N_TTY_BUF_SIZE];
110
	DECLARE_BITMAP(read_flags, N_TTY_BUF_SIZE);
111
	unsigned char echo_buf[N_TTY_BUF_SIZE];
112

113
	int minimum_to_wake;
114

115 116
	/* consumer-published */
	size_t read_tail;
P
Peter Hurley 已提交
117
	size_t line_start;
118 119 120

	/* protected by output lock */
	unsigned int column;
121
	unsigned int canon_column;
122
	size_t echo_tail;
123 124 125

	struct mutex atomic_read_lock;
	struct mutex output_lock;
J
Jiri Slaby 已提交
126 127
};

128 129
static inline size_t read_cnt(struct n_tty_data *ldata)
{
P
Peter Hurley 已提交
130
	return ldata->read_head - ldata->read_tail;
131 132
}

133 134 135 136 137 138 139 140 141 142
static inline unsigned char read_buf(struct n_tty_data *ldata, size_t i)
{
	return ldata->read_buf[i & (N_TTY_BUF_SIZE - 1)];
}

static inline unsigned char *read_buf_addr(struct n_tty_data *ldata, size_t i)
{
	return &ldata->read_buf[i & (N_TTY_BUF_SIZE - 1)];
}

143 144 145 146 147 148 149 150 151 152
static inline unsigned char echo_buf(struct n_tty_data *ldata, size_t i)
{
	return ldata->echo_buf[i & (N_TTY_BUF_SIZE - 1)];
}

static inline unsigned char *echo_buf_addr(struct n_tty_data *ldata, size_t i)
{
	return &ldata->echo_buf[i & (N_TTY_BUF_SIZE - 1)];
}

M
Miloslav Trmac 已提交
153 154 155
static inline int tty_put_user(struct tty_struct *tty, unsigned char x,
			       unsigned char __user *ptr)
{
156 157 158
	struct n_tty_data *ldata = tty->disc_data;

	tty_audit_add_data(tty, &x, 1, ldata->icanon);
M
Miloslav Trmac 已提交
159 160 161
	return put_user(x, ptr);
}

162
static int receive_room(struct tty_struct *tty)
163
{
164
	struct n_tty_data *ldata = tty->disc_data;
165
	int left;
166

167 168 169 170
	if (I_PARMRK(tty)) {
		/* Multiply read_cnt by 3, since each byte might take up to
		 * three times as many spaces when PARMRK is set (depending on
		 * its flags, e.g. parity error). */
171
		left = N_TTY_BUF_SIZE - read_cnt(ldata) * 3 - 1;
172
	} else
173
		left = N_TTY_BUF_SIZE - read_cnt(ldata) - 1;
174

175 176 177 178 179 180 181
	/*
	 * 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)
182
		left = ldata->icanon && ldata->canon_head == ldata->read_tail;
183

184
	return left;
185 186
}

187 188 189 190 191 192
/**
 *	n_tty_set_room	-	receive space
 *	@tty: terminal
 *
 *	Re-schedules the flip buffer work if space just became available.
 *
193 194 195 196
 *	Caller holds exclusive termios_rwsem
 *	   or
 *	n_tty_read()/consumer path:
 *		holds non-exclusive termios_rwsem
197 198
 */

199 200
static void n_tty_set_room(struct tty_struct *tty)
{
201 202
	struct n_tty_data *ldata = tty->disc_data;

203
	/* Did this open up the receive buffer? We may need to flip */
204 205 206
	if (unlikely(ldata->no_room) && receive_room(tty)) {
		ldata->no_room = 0;

J
Jiri Slaby 已提交
207
		WARN_RATELIMIT(tty->port->itty == NULL,
208
				"scheduling with invalid itty\n");
209 210 211 212 213 214
		/* see if ldisc has been killed - if so, this means that
		 * even though the ldisc has been halted and ->buf.work
		 * cancelled, ->buf.work is about to be rescheduled
		 */
		WARN_RATELIMIT(test_bit(TTY_LDISC_HALTED, &tty->flags),
			       "scheduling buffer work for halted ldisc\n");
215
		queue_work(system_unbound_wq, &tty->port->buf.work);
J
Jiri Slaby 已提交
216
	}
217 218
}

219 220 221 222 223 224 225 226 227 228 229 230
static ssize_t chars_in_buffer(struct tty_struct *tty)
{
	struct n_tty_data *ldata = tty->disc_data;
	ssize_t n = 0;

	if (!ldata->icanon)
		n = read_cnt(ldata);
	else
		n = ldata->canon_head - ldata->read_tail;
	return n;
}

231 232 233 234 235 236 237 238 239 240 241 242 243 244 245
/**
 *	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)
{
	if (tty->fasync && test_and_clear_bit(TTY_DO_WRITE_WAKEUP, &tty->flags))
		kill_fasync(&tty->fasync, SIGIO, POLL_OUT);
}

246
static void n_tty_check_throttle(struct tty_struct *tty)
247
{
248 249
	if (tty->driver->type == TTY_DRIVER_TYPE_PTY)
		return;
250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268
	/*
	 * 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!
	 */
	while (1) {
		int throttled;
		tty_set_flow_change(tty, TTY_THROTTLE_SAFE);
		if (receive_room(tty) >= TTY_THRESHOLD_THROTTLE)
			break;
		throttled = tty_throttle_safe(tty);
		if (!throttled)
			break;
	}
	__tty_set_flow_change(tty, 0);
}

static inline void n_tty_check_unthrottle(struct tty_struct *tty)
{
269 270 271 272 273 274 275 276 277 278 279 280
	if (tty->driver->type == TTY_DRIVER_TYPE_PTY &&
	    tty->link->ldisc->ops->write_wakeup == n_tty_write_wakeup) {
		if (chars_in_buffer(tty) > TTY_THRESHOLD_UNTHROTTLE)
			return;
		if (!tty->count)
			return;
		n_tty_set_room(tty);
		n_tty_write_wakeup(tty->link);
		wake_up_interruptible_poll(&tty->link->write_wait, POLLOUT);
		return;
	}

281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303
	/* If there is enough space in the read buffer now, let the
	 * low-level driver know. We use chars_in_buffer() to
	 * check the buffer, as it now knows about canonical mode.
	 * Otherwise, if the driver is throttled and the line is
	 * longer than TTY_THRESHOLD_UNTHROTTLE in canonical mode,
	 * we won't get any more characters.
	 */

	while (1) {
		int unthrottled;
		tty_set_flow_change(tty, TTY_UNTHROTTLE_SAFE);
		if (chars_in_buffer(tty) > TTY_THRESHOLD_UNTHROTTLE)
			break;
		if (!tty->count)
			break;
		n_tty_set_room(tty);
		unthrottled = tty_unthrottle_safe(tty);
		if (!unthrottled)
			break;
	}
	__tty_set_flow_change(tty, 0);
}

304 305 306
/**
 *	put_tty_queue		-	add character to tty
 *	@c: character
J
Jiri Slaby 已提交
307
 *	@ldata: n_tty data
308
 *
309 310 311 312 313 314 315 316
 *	Add a character to the tty read_buf queue.
 *
 *	n_tty_receive_buf()/producer path:
 *		caller holds non-exclusive termios_rwsem
 *		modifies read_head
 *
 *	read_head is only considered 'published' if canonical mode is
 *	not active.
317 318
 */

319
static inline void put_tty_queue(unsigned char c, struct n_tty_data *ldata)
L
Linus Torvalds 已提交
320
{
321
	*read_buf_addr(ldata, ldata->read_head++) = c;
L
Linus Torvalds 已提交
322 323 324 325 326 327
}

/**
 *	reset_buffer_flags	-	reset buffer state
 *	@tty: terminal to reset
 *
328 329
 *	Reset the read buffer counters and clear the flags.
 *	Called from n_tty_open() and n_tty_flush_buffer().
330
 *
331 332
 *	Locking: caller holds exclusive termios_rwsem
 *		 (or locking is not required)
L
Linus Torvalds 已提交
333
 */
334

335
static void reset_buffer_flags(struct n_tty_data *ldata)
L
Linus Torvalds 已提交
336
{
337
	ldata->read_head = ldata->canon_head = ldata->read_tail = 0;
P
Peter Hurley 已提交
338
	ldata->echo_head = ldata->echo_tail = ldata->echo_commit = 0;
P
Peter Hurley 已提交
339
	ldata->line_start = 0;
340

341
	ldata->erasing = 0;
342
	bitmap_zero(ldata->read_flags, N_TTY_BUF_SIZE);
L
Linus Torvalds 已提交
343 344
}

345 346 347 348 349 350 351 352 353 354 355 356
static void n_tty_packet_mode_flush(struct tty_struct *tty)
{
	unsigned long flags;

	spin_lock_irqsave(&tty->ctrl_lock, flags);
	if (tty->link->packet) {
		tty->ctrl_status |= TIOCPKT_FLUSHREAD;
		wake_up_interruptible(&tty->link->read_wait);
	}
	spin_unlock_irqrestore(&tty->ctrl_lock, flags);
}

L
Linus Torvalds 已提交
357 358 359 360
/**
 *	n_tty_flush_buffer	-	clean input queue
 *	@tty:	terminal device
 *
361 362 363
 *	Flush the input buffer. Called 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).
L
Linus Torvalds 已提交
364
 *
365 366 367 368
 *	Holds termios_rwsem to exclude producer/consumer while
 *	buffer indices are reset.
 *
 *	Locking: ctrl_lock, exclusive termios_rwsem
L
Linus Torvalds 已提交
369
 */
370 371

static void n_tty_flush_buffer(struct tty_struct *tty)
L
Linus Torvalds 已提交
372
{
373
	down_write(&tty->termios_rwsem);
374 375
	reset_buffer_flags(tty->disc_data);
	n_tty_set_room(tty);
376

377 378
	if (tty->link)
		n_tty_packet_mode_flush(tty);
379
	up_write(&tty->termios_rwsem);
L
Linus Torvalds 已提交
380 381
}

382 383 384 385 386 387 388 389 390 391
/**
 *	n_tty_chars_in_buffer	-	report available bytes
 *	@tty: tty device
 *
 *	Report the number of characters buffered to be delivered to user
 *	at this instant in time.
 *
 *	Locking: exclusive termios_rwsem
 */

392 393
static ssize_t n_tty_chars_in_buffer(struct tty_struct *tty)
{
394 395
	ssize_t n;

396
	WARN_ONCE(1, "%s is deprecated and scheduled for removal.", __func__);
397 398 399 400 401

	down_write(&tty->termios_rwsem);
	n = chars_in_buffer(tty);
	up_write(&tty->termios_rwsem);
	return n;
402 403
}

L
Linus Torvalds 已提交
404 405 406 407 408 409 410 411
/**
 *	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
 */
412

L
Linus Torvalds 已提交
413 414 415 416 417 418 419 420 421 422 423 424
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.
 */
425

L
Linus Torvalds 已提交
426 427 428 429 430 431
static inline int is_continuation(unsigned char c, struct tty_struct *tty)
{
	return I_IUTF8(tty) && is_utf8_continuation(c);
}

/**
432
 *	do_output_char			-	output one character
L
Linus Torvalds 已提交
433 434
 *	@c: character (or partial unicode symbol)
 *	@tty: terminal device
435
 *	@space: space available in tty driver write buffer
L
Linus Torvalds 已提交
436
 *
437 438
 *	This is a helper function that handles one output character
 *	(including special characters like TAB, CR, LF, etc.),
439 440
 *	doing OPOST processing and putting the results in the
 *	tty driver's write buffer.
441 442 443 444
 *
 *	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.
L
Linus Torvalds 已提交
445
 *
446 447 448 449 450
 *	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
L
Linus Torvalds 已提交
451
 */
452

453
static int do_output_char(unsigned char c, struct tty_struct *tty, int space)
L
Linus Torvalds 已提交
454
{
455
	struct n_tty_data *ldata = tty->disc_data;
456
	int	spaces;
L
Linus Torvalds 已提交
457 458 459

	if (!space)
		return -1;
A
Alan Cox 已提交
460

461 462 463
	switch (c) {
	case '\n':
		if (O_ONLRET(tty))
464
			ldata->column = 0;
465 466 467
		if (O_ONLCR(tty)) {
			if (space < 2)
				return -1;
468
			ldata->canon_column = ldata->column = 0;
469
			tty->ops->write(tty, "\r\n", 2);
470 471
			return 2;
		}
472
		ldata->canon_column = ldata->column;
473 474
		break;
	case '\r':
475
		if (O_ONOCR(tty) && ldata->column == 0)
476 477 478 479
			return 0;
		if (O_OCRNL(tty)) {
			c = '\n';
			if (O_ONLRET(tty))
480
				ldata->canon_column = ldata->column = 0;
L
Linus Torvalds 已提交
481
			break;
482
		}
483
		ldata->canon_column = ldata->column = 0;
484 485
		break;
	case '\t':
486
		spaces = 8 - (ldata->column & 7);
487 488 489
		if (O_TABDLY(tty) == XTABS) {
			if (space < spaces)
				return -1;
490
			ldata->column += spaces;
491 492
			tty->ops->write(tty, "        ", spaces);
			return spaces;
L
Linus Torvalds 已提交
493
		}
494
		ldata->column += spaces;
495 496
		break;
	case '\b':
497 498
		if (ldata->column > 0)
			ldata->column--;
499 500
		break;
	default:
501 502 503 504
		if (!iscntrl(c)) {
			if (O_OLCUC(tty))
				c = toupper(c);
			if (!is_continuation(c, tty))
505
				ldata->column++;
506
		}
507
		break;
L
Linus Torvalds 已提交
508
	}
509

A
Alan Cox 已提交
510
	tty_put_char(tty, c);
511 512 513 514 515 516 517 518
	return 1;
}

/**
 *	process_output			-	output post processor
 *	@c: character (or partial unicode symbol)
 *	@tty: terminal device
 *
519 520 521
 *	Output one character with OPOST processing.
 *	Returns -1 when the output device is full and the character
 *	must be retried.
522 523 524 525 526 527 528 529
 *
 *	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)
{
530
	struct n_tty_data *ldata = tty->disc_data;
531 532
	int	space, retval;

533
	mutex_lock(&ldata->output_lock);
534 535 536 537

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

538
	mutex_unlock(&ldata->output_lock);
539 540 541 542
	if (retval < 0)
		return -1;
	else
		return 0;
L
Linus Torvalds 已提交
543 544 545
}

/**
546
 *	process_output_block		-	block post processor
L
Linus Torvalds 已提交
547
 *	@tty: terminal device
548 549 550 551 552
 *	@buf: character buffer
 *	@nr: number of bytes to output
 *
 *	Output a block of characters with OPOST processing.
 *	Returns the number of characters output.
L
Linus Torvalds 已提交
553 554 555 556 557 558
 *
 *	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.
 *
559 560 561
 *	Locking: output_lock to protect column state and space left
 *		 (also, this is called from n_tty_write under the
 *		  tty layer write lock)
L
Linus Torvalds 已提交
562
 */
563

564 565
static ssize_t process_output_block(struct tty_struct *tty,
				    const unsigned char *buf, unsigned int nr)
L
Linus Torvalds 已提交
566
{
567
	struct n_tty_data *ldata = tty->disc_data;
L
Linus Torvalds 已提交
568
	int	space;
569
	int	i;
L
Linus Torvalds 已提交
570 571
	const unsigned char *cp;

572
	mutex_lock(&ldata->output_lock);
573

A
Alan Cox 已提交
574
	space = tty_write_room(tty);
A
Alan Cox 已提交
575
	if (!space) {
576
		mutex_unlock(&ldata->output_lock);
L
Linus Torvalds 已提交
577
		return 0;
578
	}
L
Linus Torvalds 已提交
579 580 581 582
	if (nr > space)
		nr = space;

	for (i = 0, cp = buf; i < nr; i++, cp++) {
583 584 585
		unsigned char c = *cp;

		switch (c) {
L
Linus Torvalds 已提交
586 587
		case '\n':
			if (O_ONLRET(tty))
588
				ldata->column = 0;
L
Linus Torvalds 已提交
589 590
			if (O_ONLCR(tty))
				goto break_out;
591
			ldata->canon_column = ldata->column;
L
Linus Torvalds 已提交
592 593
			break;
		case '\r':
594
			if (O_ONOCR(tty) && ldata->column == 0)
L
Linus Torvalds 已提交
595 596 597
				goto break_out;
			if (O_OCRNL(tty))
				goto break_out;
598
			ldata->canon_column = ldata->column = 0;
L
Linus Torvalds 已提交
599 600 601 602
			break;
		case '\t':
			goto break_out;
		case '\b':
603 604
			if (ldata->column > 0)
				ldata->column--;
L
Linus Torvalds 已提交
605 606
			break;
		default:
607 608 609 610
			if (!iscntrl(c)) {
				if (O_OLCUC(tty))
					goto break_out;
				if (!is_continuation(c, tty))
611
					ldata->column++;
612
			}
L
Linus Torvalds 已提交
613 614 615 616
			break;
		}
	}
break_out:
A
Alan Cox 已提交
617
	i = tty->ops->write(tty, buf, i);
618

619
	mutex_unlock(&ldata->output_lock);
L
Linus Torvalds 已提交
620 621 622
	return i;
}

623 624 625 626 627 628 629 630 631 632 633 634 635 636 637 638 639 640 641 642 643 644
/**
 *	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.
 *
645
 *	Locking: callers must hold output_lock
646 647
 */

648
static size_t __process_echoes(struct tty_struct *tty)
649
{
650
	struct n_tty_data *ldata = tty->disc_data;
651
	int	space, old_space;
652
	size_t tail;
653 654
	unsigned char c;

655
	old_space = space = tty_write_room(tty);
656

657
	tail = ldata->echo_tail;
658
	while (ldata->echo_commit != tail) {
659
		c = echo_buf(ldata, tail);
660 661 662 663 664 665 666 667 668
		if (c == ECHO_OP_START) {
			unsigned char op;
			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.
			 */
669
			op = echo_buf(ldata, tail + 1);
A
Alan Cox 已提交
670

671 672 673 674
			switch (op) {
				unsigned int num_chars, num_bs;

			case ECHO_OP_ERASE_TAB:
675
				num_chars = echo_buf(ldata, tail + 2);
676 677 678 679 680 681 682 683 684 685 686 687

				/*
				 * 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))
688
					num_chars += ldata->canon_column;
689 690 691 692 693 694 695 696 697
				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');
698 699
					if (ldata->column > 0)
						ldata->column--;
700
				}
701
				tail += 3;
702 703 704
				break;

			case ECHO_OP_SET_CANON_COL:
705
				ldata->canon_column = ldata->column;
706
				tail += 2;
707 708 709
				break;

			case ECHO_OP_MOVE_BACK_COL:
710 711
				if (ldata->column > 0)
					ldata->column--;
712
				tail += 2;
713 714 715 716 717 718 719 720 721
				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);
722
				ldata->column++;
723
				space--;
724
				tail += 2;
725 726 727 728
				break;

			default:
				/*
729 730 731 732 733 734 735
				 * 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.
				 *
736
				 */
737 738 739 740 741 742
				if (space < 2) {
					no_space_left = 1;
					break;
				}
				tty_put_char(tty, '^');
				tty_put_char(tty, op ^ 0100);
743
				ldata->column += 2;
744
				space -= 2;
745
				tail += 2;
746 747 748 749 750
			}

			if (no_space_left)
				break;
		} else {
P
Peter Hurley 已提交
751
			if (O_OPOST(tty)) {
752 753 754 755 756 757 758 759 760 761
				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;
			}
762
			tail += 1;
763 764 765
		}
	}

P
Peter Hurley 已提交
766 767 768 769 770 771 772 773 774 775 776 777 778
	/* If the echo buffer is nearly full (so that the possibility exists
	 * of echo overrun before the next commit), then discard enough
	 * data at the tail to prevent a subsequent overrun */
	while (ldata->echo_commit - tail >= ECHO_DISCARD_WATERMARK) {
		if (echo_buf(ldata, tail == ECHO_OP_START)) {
			if (echo_buf(ldata, tail) == ECHO_OP_ERASE_TAB)
				tail += 3;
			else
				tail += 2;
		} else
			tail++;
	}

779
	ldata->echo_tail = tail;
780
	return old_space - space;
781 782 783 784 785
}

static void commit_echoes(struct tty_struct *tty)
{
	struct n_tty_data *ldata = tty->disc_data;
786
	size_t nr, old, echoed;
P
Peter Hurley 已提交
787 788 789 790 791 792 793 794 795 796 797
	size_t head;

	head = ldata->echo_head;
	old = ldata->echo_commit - ldata->echo_tail;

	/* Process committed echoes if the accumulated # of bytes
	 * is over the threshold (and try again each time another
	 * block is accumulated) */
	nr = head - ldata->echo_tail;
	if (nr < ECHO_COMMIT_WATERMARK || (nr % ECHO_BLOCK > old % ECHO_BLOCK))
		return;
798

799
	mutex_lock(&ldata->output_lock);
P
Peter Hurley 已提交
800
	ldata->echo_commit = head;
801
	echoed = __process_echoes(tty);
802
	mutex_unlock(&ldata->output_lock);
803

804
	if (echoed && tty->ops->flush_chars)
805 806 807
		tty->ops->flush_chars(tty);
}

808
static void process_echoes(struct tty_struct *tty)
P
Peter Hurley 已提交
809 810
{
	struct n_tty_data *ldata = tty->disc_data;
811
	size_t echoed;
P
Peter Hurley 已提交
812

813 814 815 816
	if (!L_ECHO(tty) || ldata->echo_commit == ldata->echo_tail)
		return;

	mutex_lock(&ldata->output_lock);
817
	echoed = __process_echoes(tty);
818 819
	mutex_unlock(&ldata->output_lock);

820
	if (echoed && tty->ops->flush_chars)
821
		tty->ops->flush_chars(tty);
P
Peter Hurley 已提交
822 823
}

P
Peter Hurley 已提交
824 825 826 827 828 829 830 831 832 833 834 835 836
static void flush_echoes(struct tty_struct *tty)
{
	struct n_tty_data *ldata = tty->disc_data;

	if (!L_ECHO(tty) || ldata->echo_commit == ldata->echo_head)
		return;

	mutex_lock(&ldata->output_lock);
	ldata->echo_commit = ldata->echo_head;
	__process_echoes(tty);
	mutex_unlock(&ldata->output_lock);
}

837 838 839
/**
 *	add_echo_byte	-	add a byte to the echo buffer
 *	@c: unicode byte to echo
J
Jiri Slaby 已提交
840
 *	@ldata: n_tty data
841 842 843 844
 *
 *	Add a character or operation byte to the echo buffer.
 */

P
Peter Hurley 已提交
845
static inline void add_echo_byte(unsigned char c, struct n_tty_data *ldata)
846
{
847
	*echo_buf_addr(ldata, ldata->echo_head++) = c;
848 849 850 851
}

/**
 *	echo_move_back_col	-	add operation to move back a column
J
Jiri Slaby 已提交
852
 *	@ldata: n_tty data
853 854 855 856
 *
 *	Add an operation to the echo buffer to move back one column.
 */

J
Jiri Slaby 已提交
857
static void echo_move_back_col(struct n_tty_data *ldata)
858
{
J
Jiri Slaby 已提交
859 860
	add_echo_byte(ECHO_OP_START, ldata);
	add_echo_byte(ECHO_OP_MOVE_BACK_COL, ldata);
861 862 863 864
}

/**
 *	echo_set_canon_col	-	add operation to set the canon column
J
Jiri Slaby 已提交
865
 *	@ldata: n_tty data
866 867 868 869 870
 *
 *	Add an operation to the echo buffer to set the canon column
 *	to the current column.
 */

J
Jiri Slaby 已提交
871
static void echo_set_canon_col(struct n_tty_data *ldata)
872
{
J
Jiri Slaby 已提交
873 874
	add_echo_byte(ECHO_OP_START, ldata);
	add_echo_byte(ECHO_OP_SET_CANON_COL, ldata);
875 876 877 878 879 880
}

/**
 *	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
J
Jiri Slaby 已提交
881
 *	@ldata: n_tty data
882 883 884 885 886 887 888 889 890 891 892
 *
 *	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.
 */

static void echo_erase_tab(unsigned int num_chars, int after_tab,
J
Jiri Slaby 已提交
893
			   struct n_tty_data *ldata)
894
{
J
Jiri Slaby 已提交
895 896
	add_echo_byte(ECHO_OP_START, ldata);
	add_echo_byte(ECHO_OP_ERASE_TAB, ldata);
897 898 899 900 901 902 903

	/* 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;
A
Alan Cox 已提交
904

J
Jiri Slaby 已提交
905
	add_echo_byte(num_chars, ldata);
906 907 908 909 910 911 912 913 914 915 916 917 918
}

/**
 *	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.
 */

J
Jiri Slaby 已提交
919
static void echo_char_raw(unsigned char c, struct n_tty_data *ldata)
920 921
{
	if (c == ECHO_OP_START) {
J
Jiri Slaby 已提交
922 923
		add_echo_byte(ECHO_OP_START, ldata);
		add_echo_byte(ECHO_OP_START, ldata);
924
	} else {
J
Jiri Slaby 已提交
925
		add_echo_byte(c, ldata);
926 927
	}
}
L
Linus Torvalds 已提交
928 929

/**
930
 *	echo_char	-	echo a character
L
Linus Torvalds 已提交
931 932 933
 *	@c: unicode byte to echo
 *	@tty: terminal device
 *
934
 *	Echo user input back onto the screen. This must be called only when
L
Linus Torvalds 已提交
935
 *	L_ECHO(tty) is true. Called from the driver receive_buf path.
936
 *
937 938
 *	This variant tags control characters to be echoed as "^X"
 *	(where X is the letter representing the control char).
L
Linus Torvalds 已提交
939 940 941 942
 */

static void echo_char(unsigned char c, struct tty_struct *tty)
{
943 944
	struct n_tty_data *ldata = tty->disc_data;

945
	if (c == ECHO_OP_START) {
J
Jiri Slaby 已提交
946 947
		add_echo_byte(ECHO_OP_START, ldata);
		add_echo_byte(ECHO_OP_START, ldata);
948
	} else {
949
		if (L_ECHOCTL(tty) && iscntrl(c) && c != '\t')
J
Jiri Slaby 已提交
950 951
			add_echo_byte(ECHO_OP_START, ldata);
		add_echo_byte(c, ldata);
952
	}
L
Linus Torvalds 已提交
953 954
}

955
/**
956
 *	finish_erasing		-	complete erase
J
Jiri Slaby 已提交
957
 *	@ldata: n_tty data
958
 */
959

J
Jiri Slaby 已提交
960
static inline void finish_erasing(struct n_tty_data *ldata)
L
Linus Torvalds 已提交
961
{
962
	if (ldata->erasing) {
J
Jiri Slaby 已提交
963
		echo_char_raw('/', ldata);
964
		ldata->erasing = 0;
L
Linus Torvalds 已提交
965 966 967 968 969 970 971 972
	}
}

/**
 *	eraser		-	handle erase function
 *	@c: character input
 *	@tty: terminal device
 *
973
 *	Perform erase and necessary output when an erase character is
L
Linus Torvalds 已提交
974 975
 *	present in the stream from the driver layer. Handles the complexities
 *	of UTF-8 multibyte symbols.
976
 *
977 978 979 980 981 982
 *	n_tty_receive_buf()/producer path:
 *		caller holds non-exclusive termios_rwsem
 *		modifies read_head
 *
 *	Modifying the read_head is not considered a publish in this context
 *	because canonical mode is active -- only canon_head publishes
L
Linus Torvalds 已提交
983
 */
984

L
Linus Torvalds 已提交
985 986
static void eraser(unsigned char c, struct tty_struct *tty)
{
987
	struct n_tty_data *ldata = tty->disc_data;
L
Linus Torvalds 已提交
988
	enum { ERASE, WERASE, KILL } kill_type;
989 990 991
	size_t head;
	size_t cnt;
	int seen_alnums;
L
Linus Torvalds 已提交
992

993
	if (ldata->read_head == ldata->canon_head) {
994
		/* process_output('\a', tty); */ /* what do you think? */
L
Linus Torvalds 已提交
995 996 997 998 999 1000 1001 1002
		return;
	}
	if (c == ERASE_CHAR(tty))
		kill_type = ERASE;
	else if (c == WERASE_CHAR(tty))
		kill_type = WERASE;
	else {
		if (!L_ECHO(tty)) {
1003
			ldata->read_head = ldata->canon_head;
L
Linus Torvalds 已提交
1004 1005 1006
			return;
		}
		if (!L_ECHOK(tty) || !L_ECHOKE(tty) || !L_ECHOE(tty)) {
1007
			ldata->read_head = ldata->canon_head;
J
Jiri Slaby 已提交
1008
			finish_erasing(ldata);
L
Linus Torvalds 已提交
1009 1010 1011
			echo_char(KILL_CHAR(tty), tty);
			/* Add a newline if ECHOK is on and ECHOKE is off. */
			if (L_ECHOK(tty))
J
Jiri Slaby 已提交
1012
				echo_char_raw('\n', ldata);
L
Linus Torvalds 已提交
1013 1014 1015 1016 1017 1018
			return;
		}
		kill_type = KILL;
	}

	seen_alnums = 0;
1019 1020
	while (ldata->read_head != ldata->canon_head) {
		head = ldata->read_head;
L
Linus Torvalds 已提交
1021 1022 1023

		/* erase a single possibly multibyte character */
		do {
1024 1025
			head--;
			c = read_buf(ldata, head);
1026
		} while (is_continuation(c, tty) && head != ldata->canon_head);
L
Linus Torvalds 已提交
1027 1028 1029 1030 1031 1032 1033 1034 1035 1036 1037 1038

		/* 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;
		}
1039
		cnt = ldata->read_head - head;
1040
		ldata->read_head = head;
L
Linus Torvalds 已提交
1041 1042
		if (L_ECHO(tty)) {
			if (L_ECHOPRT(tty)) {
1043
				if (!ldata->erasing) {
J
Jiri Slaby 已提交
1044
					echo_char_raw('\\', ldata);
1045
					ldata->erasing = 1;
L
Linus Torvalds 已提交
1046 1047 1048 1049
				}
				/* if cnt > 1, output a multi-byte character */
				echo_char(c, tty);
				while (--cnt > 0) {
1050 1051
					head++;
					echo_char_raw(read_buf(ldata, head), ldata);
J
Jiri Slaby 已提交
1052
					echo_move_back_col(ldata);
L
Linus Torvalds 已提交
1053 1054 1055 1056
				}
			} else if (kill_type == ERASE && !L_ECHOE(tty)) {
				echo_char(ERASE_CHAR(tty), tty);
			} else if (c == '\t') {
1057 1058
				unsigned int num_chars = 0;
				int after_tab = 0;
1059
				size_t tail = ldata->read_head;
1060 1061 1062 1063 1064 1065 1066 1067

				/*
				 * 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.
				 */
1068
				while (tail != ldata->canon_head) {
1069 1070
					tail--;
					c = read_buf(ldata, tail);
1071 1072 1073
					if (c == '\t') {
						after_tab = 1;
						break;
A
Alan Cox 已提交
1074
					} else if (iscntrl(c)) {
L
Linus Torvalds 已提交
1075
						if (L_ECHOCTL(tty))
1076 1077 1078 1079
							num_chars += 2;
					} else if (!is_continuation(c, tty)) {
						num_chars++;
					}
L
Linus Torvalds 已提交
1080
				}
J
Jiri Slaby 已提交
1081
				echo_erase_tab(num_chars, after_tab, ldata);
L
Linus Torvalds 已提交
1082 1083
			} else {
				if (iscntrl(c) && L_ECHOCTL(tty)) {
J
Jiri Slaby 已提交
1084 1085 1086
					echo_char_raw('\b', ldata);
					echo_char_raw(' ', ldata);
					echo_char_raw('\b', ldata);
L
Linus Torvalds 已提交
1087 1088
				}
				if (!iscntrl(c) || L_ECHOCTL(tty)) {
J
Jiri Slaby 已提交
1089 1090 1091
					echo_char_raw('\b', ldata);
					echo_char_raw(' ', ldata);
					echo_char_raw('\b', ldata);
L
Linus Torvalds 已提交
1092 1093 1094 1095 1096 1097
				}
			}
		}
		if (kill_type == ERASE)
			break;
	}
1098
	if (ldata->read_head == ldata->canon_head && L_ECHO(tty))
J
Jiri Slaby 已提交
1099
		finish_erasing(ldata);
L
Linus Torvalds 已提交
1100 1101 1102 1103 1104 1105 1106
}

/**
 *	isig		-	handle the ISIG optio
 *	@sig: signal
 *	@tty: terminal
 *
1107 1108
 *	Called when a signal is being sent due to terminal input.
 *	Called from the driver receive_buf path so serialized.
1109
 *
1110
 *	Locking: ctrl_lock
L
Linus Torvalds 已提交
1111
 */
1112

1113
static inline void isig(int sig, struct tty_struct *tty)
L
Linus Torvalds 已提交
1114
{
1115 1116 1117 1118
	struct pid *tty_pgrp = tty_get_pgrp(tty);
	if (tty_pgrp) {
		kill_pgrp(tty_pgrp, sig, 1);
		put_pid(tty_pgrp);
L
Linus Torvalds 已提交
1119 1120 1121 1122 1123 1124 1125 1126 1127 1128
	}
}

/**
 *	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.
 *
1129 1130 1131 1132 1133
 *	n_tty_receive_buf()/producer path:
 *		caller holds non-exclusive termios_rwsem
 *		publishes read_head via put_tty_queue()
 *
 *	Note: may get exclusive termios_rwsem if flushing input buffer
L
Linus Torvalds 已提交
1134
 */
1135

L
Linus Torvalds 已提交
1136 1137
static inline void n_tty_receive_break(struct tty_struct *tty)
{
J
Jiri Slaby 已提交
1138 1139
	struct n_tty_data *ldata = tty->disc_data;

L
Linus Torvalds 已提交
1140 1141 1142
	if (I_IGNBRK(tty))
		return;
	if (I_BRKINT(tty)) {
1143 1144
		isig(SIGINT, tty);
		if (!L_NOFLSH(tty)) {
1145 1146
			/* flushing needs exclusive termios_rwsem */
			up_read(&tty->termios_rwsem);
1147 1148
			n_tty_flush_buffer(tty);
			tty_driver_flush_buffer(tty);
1149
			down_read(&tty->termios_rwsem);
1150
		}
L
Linus Torvalds 已提交
1151 1152 1153
		return;
	}
	if (I_PARMRK(tty)) {
J
Jiri Slaby 已提交
1154 1155
		put_tty_queue('\377', ldata);
		put_tty_queue('\0', ldata);
L
Linus Torvalds 已提交
1156
	}
J
Jiri Slaby 已提交
1157
	put_tty_queue('\0', ldata);
L
Linus Torvalds 已提交
1158 1159 1160 1161 1162 1163 1164 1165 1166 1167 1168 1169 1170 1171 1172
	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.
 */
1173

L
Linus Torvalds 已提交
1174 1175
static inline void n_tty_receive_overrun(struct tty_struct *tty)
{
1176
	struct n_tty_data *ldata = tty->disc_data;
L
Linus Torvalds 已提交
1177 1178
	char buf[64];

1179 1180 1181
	ldata->num_overrun++;
	if (time_after(jiffies, ldata->overrun_time + HZ) ||
			time_after(ldata->overrun_time, jiffies)) {
L
Linus Torvalds 已提交
1182 1183
		printk(KERN_WARNING "%s: %d input overrun(s)\n",
			tty_name(tty, buf),
1184 1185 1186
			ldata->num_overrun);
		ldata->overrun_time = jiffies;
		ldata->num_overrun = 0;
L
Linus Torvalds 已提交
1187 1188 1189 1190 1191 1192 1193 1194 1195
	}
}

/**
 *	n_tty_receive_parity_error	-	error notifier
 *	@tty: terminal device
 *	@c: character
 *
 *	Process a parity error and queue the right data to indicate
1196 1197 1198 1199 1200
 *	the error case if necessary.
 *
 *	n_tty_receive_buf()/producer path:
 *		caller holds non-exclusive termios_rwsem
 *		publishes read_head via put_tty_queue()
L
Linus Torvalds 已提交
1201 1202 1203 1204
 */
static inline void n_tty_receive_parity_error(struct tty_struct *tty,
					      unsigned char c)
{
J
Jiri Slaby 已提交
1205 1206
	struct n_tty_data *ldata = tty->disc_data;

1207
	if (I_IGNPAR(tty))
L
Linus Torvalds 已提交
1208 1209
		return;
	if (I_PARMRK(tty)) {
J
Jiri Slaby 已提交
1210 1211 1212
		put_tty_queue('\377', ldata);
		put_tty_queue('\0', ldata);
		put_tty_queue(c, ldata);
L
Linus Torvalds 已提交
1213
	} else	if (I_INPCK(tty))
J
Jiri Slaby 已提交
1214
		put_tty_queue('\0', ldata);
L
Linus Torvalds 已提交
1215
	else
J
Jiri Slaby 已提交
1216
		put_tty_queue(c, ldata);
L
Linus Torvalds 已提交
1217 1218 1219
	wake_up_interruptible(&tty->read_wait);
}

1220 1221 1222 1223 1224 1225 1226 1227 1228 1229 1230 1231 1232 1233 1234 1235 1236 1237 1238 1239
static void
n_tty_receive_signal_char(struct tty_struct *tty, int signal, unsigned char c)
{
	if (!L_NOFLSH(tty)) {
		/* flushing needs exclusive termios_rwsem */
		up_read(&tty->termios_rwsem);
		n_tty_flush_buffer(tty);
		tty_driver_flush_buffer(tty);
		down_read(&tty->termios_rwsem);
	}
	if (I_IXON(tty))
		start_tty(tty);
	if (L_ECHO(tty)) {
		echo_char(c, tty);
		commit_echoes(tty);
	}
	isig(signal, tty);
	return;
}

L
Linus Torvalds 已提交
1240 1241 1242 1243 1244 1245
/**
 *	n_tty_receive_char	-	perform processing
 *	@tty: terminal device
 *	@c: character
 *
 *	Process an individual character of input received from the driver.
1246
 *	This is serialized with respect to itself by the rules for the
L
Linus Torvalds 已提交
1247
 *	driver above.
1248 1249 1250 1251 1252
 *
 *	n_tty_receive_buf()/producer path:
 *		caller holds non-exclusive termios_rwsem
 *		publishes canon_head if canonical mode is active
 *		otherwise, publishes read_head via put_tty_queue()
L
Linus Torvalds 已提交
1253 1254
 */

P
Peter Hurley 已提交
1255 1256
static void
n_tty_receive_char_special(struct tty_struct *tty, unsigned char c)
L
Linus Torvalds 已提交
1257
{
1258
	struct n_tty_data *ldata = tty->disc_data;
1259
	int parmrk;
L
Linus Torvalds 已提交
1260 1261 1262 1263

	if (I_IXON(tty)) {
		if (c == START_CHAR(tty)) {
			start_tty(tty);
P
Peter Hurley 已提交
1264
			commit_echoes(tty);
L
Linus Torvalds 已提交
1265 1266 1267 1268 1269 1270 1271
			return;
		}
		if (c == STOP_CHAR(tty)) {
			stop_tty(tty);
			return;
		}
	}
1272

L
Linus Torvalds 已提交
1273
	if (L_ISIG(tty)) {
1274 1275 1276 1277 1278 1279 1280 1281
		if (c == INTR_CHAR(tty)) {
			n_tty_receive_signal_char(tty, SIGINT, c);
			return;
		} else if (c == QUIT_CHAR(tty)) {
			n_tty_receive_signal_char(tty, SIGQUIT, c);
			return;
		} else if (c == SUSP_CHAR(tty)) {
			n_tty_receive_signal_char(tty, SIGTSTP, c);
L
Linus Torvalds 已提交
1282 1283 1284
			return;
		}
	}
1285

1286 1287 1288 1289 1290
	if (tty->stopped && !tty->flow_stopped && I_IXON(tty) && I_IXANY(tty)) {
		start_tty(tty);
		process_echoes(tty);
	}

1291 1292 1293 1294 1295 1296 1297 1298
	if (c == '\r') {
		if (I_IGNCR(tty))
			return;
		if (I_ICRNL(tty))
			c = '\n';
	} else if (c == '\n' && I_INLCR(tty))
		c = '\r';

1299
	if (ldata->icanon) {
L
Linus Torvalds 已提交
1300 1301 1302
		if (c == ERASE_CHAR(tty) || c == KILL_CHAR(tty) ||
		    (c == WERASE_CHAR(tty) && L_IEXTEN(tty))) {
			eraser(c, tty);
P
Peter Hurley 已提交
1303
			commit_echoes(tty);
L
Linus Torvalds 已提交
1304 1305 1306
			return;
		}
		if (c == LNEXT_CHAR(tty) && L_IEXTEN(tty)) {
1307
			ldata->lnext = 1;
L
Linus Torvalds 已提交
1308
			if (L_ECHO(tty)) {
J
Jiri Slaby 已提交
1309
				finish_erasing(ldata);
L
Linus Torvalds 已提交
1310
				if (L_ECHOCTL(tty)) {
J
Jiri Slaby 已提交
1311 1312
					echo_char_raw('^', ldata);
					echo_char_raw('\b', ldata);
P
Peter Hurley 已提交
1313
					commit_echoes(tty);
L
Linus Torvalds 已提交
1314 1315 1316 1317 1318 1319
				}
			}
			return;
		}
		if (c == REPRINT_CHAR(tty) && L_ECHO(tty) &&
		    L_IEXTEN(tty)) {
1320
			size_t tail = ldata->canon_head;
L
Linus Torvalds 已提交
1321

J
Jiri Slaby 已提交
1322
			finish_erasing(ldata);
L
Linus Torvalds 已提交
1323
			echo_char(c, tty);
J
Jiri Slaby 已提交
1324
			echo_char_raw('\n', ldata);
1325
			while (tail != ldata->read_head) {
1326 1327
				echo_char(read_buf(ldata, tail), tty);
				tail++;
L
Linus Torvalds 已提交
1328
			}
P
Peter Hurley 已提交
1329
			commit_echoes(tty);
L
Linus Torvalds 已提交
1330 1331 1332
			return;
		}
		if (c == '\n') {
1333
			if (L_ECHO(tty) || L_ECHONL(tty)) {
J
Jiri Slaby 已提交
1334
				echo_char_raw('\n', ldata);
P
Peter Hurley 已提交
1335
				commit_echoes(tty);
L
Linus Torvalds 已提交
1336 1337 1338 1339 1340 1341 1342 1343 1344
			}
			goto handle_newline;
		}
		if (c == EOF_CHAR(tty)) {
			c = __DISABLED_CHAR;
			goto handle_newline;
		}
		if ((c == EOL_CHAR(tty)) ||
		    (c == EOL2_CHAR(tty) && L_IEXTEN(tty))) {
1345 1346
			parmrk = (c == (unsigned char) '\377' && I_PARMRK(tty))
				 ? 1 : 0;
L
Linus Torvalds 已提交
1347 1348 1349 1350 1351
			/*
			 * XXX are EOL_CHAR and EOL2_CHAR echoed?!?
			 */
			if (L_ECHO(tty)) {
				/* Record the column of first canon char. */
1352
				if (ldata->canon_head == ldata->read_head)
J
Jiri Slaby 已提交
1353
					echo_set_canon_col(ldata);
L
Linus Torvalds 已提交
1354
				echo_char(c, tty);
P
Peter Hurley 已提交
1355
				commit_echoes(tty);
L
Linus Torvalds 已提交
1356 1357 1358 1359 1360
			}
			/*
			 * XXX does PARMRK doubling happen for
			 * EOL_CHAR and EOL2_CHAR?
			 */
1361
			if (parmrk)
J
Jiri Slaby 已提交
1362
				put_tty_queue(c, ldata);
L
Linus Torvalds 已提交
1363

1364
handle_newline:
1365
			set_bit(ldata->read_head & (N_TTY_BUF_SIZE - 1), ldata->read_flags);
1366
			put_tty_queue(c, ldata);
1367
			ldata->canon_head = ldata->read_head;
L
Linus Torvalds 已提交
1368 1369 1370 1371 1372 1373
			kill_fasync(&tty->fasync, SIGIO, POLL_IN);
			if (waitqueue_active(&tty->read_wait))
				wake_up_interruptible(&tty->read_wait);
			return;
		}
	}
1374

1375 1376
	parmrk = (c == (unsigned char) '\377' && I_PARMRK(tty)) ? 1 : 0;
	if (L_ECHO(tty)) {
J
Jiri Slaby 已提交
1377
		finish_erasing(ldata);
L
Linus Torvalds 已提交
1378
		if (c == '\n')
J
Jiri Slaby 已提交
1379
			echo_char_raw('\n', ldata);
L
Linus Torvalds 已提交
1380 1381
		else {
			/* Record the column of first canon char. */
1382
			if (ldata->canon_head == ldata->read_head)
J
Jiri Slaby 已提交
1383
				echo_set_canon_col(ldata);
L
Linus Torvalds 已提交
1384 1385
			echo_char(c, tty);
		}
P
Peter Hurley 已提交
1386
		commit_echoes(tty);
L
Linus Torvalds 已提交
1387 1388
	}

1389
	if (parmrk)
J
Jiri Slaby 已提交
1390
		put_tty_queue(c, ldata);
L
Linus Torvalds 已提交
1391

J
Jiri Slaby 已提交
1392
	put_tty_queue(c, ldata);
1393
}
L
Linus Torvalds 已提交
1394

P
Peter Hurley 已提交
1395 1396 1397 1398 1399 1400 1401 1402 1403 1404 1405 1406 1407 1408 1409 1410 1411 1412 1413 1414 1415 1416 1417 1418 1419 1420 1421
static inline void n_tty_receive_char(struct tty_struct *tty, unsigned char c)
{
	struct n_tty_data *ldata = tty->disc_data;
	int parmrk;

	/*
	 * 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, ldata->char_map) || ldata->lnext) {
		ldata->lnext = 0;

		if (tty->stopped && !tty->flow_stopped && I_IXON(tty) &&
		    I_IXANY(tty)) {
			start_tty(tty);
			process_echoes(tty);
		}
		if (L_ECHO(tty)) {
			finish_erasing(ldata);
			/* Record the column of first canon char. */
			if (ldata->canon_head == ldata->read_head)
				echo_set_canon_col(ldata);
			echo_char(c, tty);
			commit_echoes(tty);
		}
1422
		parmrk = (c == (unsigned char) '\377' && I_PARMRK(tty)) ? 1 : 0;
P
Peter Hurley 已提交
1423 1424 1425 1426 1427 1428 1429 1430 1431
		if (parmrk)
			put_tty_queue(c, ldata);
		put_tty_queue(c, ldata);
		return;
	}

	n_tty_receive_char_special(tty, c);
}

1432 1433 1434 1435 1436 1437 1438 1439 1440 1441 1442 1443 1444 1445 1446 1447 1448 1449 1450 1451 1452 1453 1454 1455 1456 1457 1458 1459 1460 1461 1462 1463 1464 1465
static inline void
n_tty_receive_char_fast(struct tty_struct *tty, unsigned char c)
{
	struct n_tty_data *ldata = tty->disc_data;

	/*
	 * 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, ldata->char_map) || ldata->lnext) {
		ldata->lnext = 0;

		if (tty->stopped && !tty->flow_stopped && I_IXON(tty) &&
		    I_IXANY(tty)) {
			start_tty(tty);
			process_echoes(tty);
		}
		if (L_ECHO(tty)) {
			finish_erasing(ldata);
			/* Record the column of first canon char. */
			if (ldata->canon_head == ldata->read_head)
				echo_set_canon_col(ldata);
			echo_char(c, tty);
			commit_echoes(tty);
		}
		put_tty_queue(c, ldata);
		return;
	}

	n_tty_receive_char_special(tty, c);
}

1466 1467 1468 1469 1470 1471 1472 1473 1474 1475 1476 1477 1478 1479 1480 1481 1482 1483 1484 1485 1486
static inline void
n_tty_receive_char_closing(struct tty_struct *tty, unsigned char c)
{
	if (I_ISTRIP(tty))
		c &= 0x7f;
	if (I_IUCLC(tty) && L_IEXTEN(tty))
		c = tolower(c);

	if (I_IXON(tty)) {
		if (c == STOP_CHAR(tty))
			stop_tty(tty);
		else if (c == START_CHAR(tty) ||
			 (tty->stopped && !tty->flow_stopped && I_IXANY(tty) &&
			  c != INTR_CHAR(tty) && c != QUIT_CHAR(tty) &&
			  c != SUSP_CHAR(tty))) {
			start_tty(tty);
			process_echoes(tty);
		}
	}
}

1487 1488 1489 1490 1491 1492 1493 1494 1495 1496 1497 1498 1499 1500 1501 1502 1503 1504 1505 1506 1507 1508 1509
static void
n_tty_receive_char_flagged(struct tty_struct *tty, unsigned char c, char flag)
{
	char buf[64];

	switch (flag) {
	case TTY_BREAK:
		n_tty_receive_break(tty);
		break;
	case TTY_PARITY:
	case TTY_FRAME:
		n_tty_receive_parity_error(tty, c);
		break;
	case TTY_OVERRUN:
		n_tty_receive_overrun(tty);
		break;
	default:
		printk(KERN_ERR "%s: unknown flag %d\n",
		       tty_name(tty, buf), flag);
		break;
	}
}

L
Linus Torvalds 已提交
1510 1511 1512 1513 1514 1515 1516 1517 1518 1519 1520
/**
 *	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)
1521 1522 1523 1524
 *
 *	n_tty_receive_buf()/producer path:
 *		claims non-exclusive termios_rwsem
 *		publishes read_head and canon_head
L
Linus Torvalds 已提交
1525
 */
1526

1527 1528 1529 1530 1531 1532 1533 1534 1535 1536 1537 1538 1539 1540 1541 1542 1543 1544 1545 1546 1547 1548
static void
n_tty_receive_buf_real_raw(struct tty_struct *tty, const unsigned char *cp,
			   char *fp, int count)
{
	struct n_tty_data *ldata = tty->disc_data;
	size_t n, head;

	head = ldata->read_head & (N_TTY_BUF_SIZE - 1);
	n = N_TTY_BUF_SIZE - max(read_cnt(ldata), head);
	n = min_t(size_t, count, n);
	memcpy(read_buf_addr(ldata, head), cp, n);
	ldata->read_head += n;
	cp += n;
	count -= n;

	head = ldata->read_head & (N_TTY_BUF_SIZE - 1);
	n = N_TTY_BUF_SIZE - max(read_cnt(ldata), head);
	n = min_t(size_t, count, n);
	memcpy(read_buf_addr(ldata, head), cp, n);
	ldata->read_head += n;
}

1549 1550 1551 1552 1553 1554 1555 1556 1557 1558 1559 1560 1561 1562 1563 1564 1565
static void
n_tty_receive_buf_raw(struct tty_struct *tty, const unsigned char *cp,
		      char *fp, int count)
{
	struct n_tty_data *ldata = tty->disc_data;
	char flag = TTY_NORMAL;

	while (count--) {
		if (fp)
			flag = *fp++;
		if (likely(flag == TTY_NORMAL))
			put_tty_queue(*cp++, ldata);
		else
			n_tty_receive_char_flagged(tty, *cp++, flag);
	}
}

1566 1567 1568 1569 1570 1571 1572 1573 1574 1575 1576 1577 1578 1579 1580 1581
static void
n_tty_receive_buf_closing(struct tty_struct *tty, const unsigned char *cp,
			  char *fp, int count)
{
	char flag = TTY_NORMAL;

	while (count--) {
		if (fp)
			flag = *fp++;
		if (likely(flag == TTY_NORMAL))
			n_tty_receive_char_closing(tty, *cp++);
		else
			n_tty_receive_char_flagged(tty, *cp++, flag);
	}
}

1582 1583
static void
n_tty_receive_buf_standard(struct tty_struct *tty, const unsigned char *cp,
1584 1585 1586 1587 1588 1589 1590 1591 1592 1593 1594 1595 1596 1597 1598 1599 1600 1601 1602 1603 1604 1605 1606 1607 1608 1609 1610 1611
			  char *fp, int count)
{
	struct n_tty_data *ldata = tty->disc_data;
	char flag = TTY_NORMAL;

	while (count--) {
		if (fp)
			flag = *fp++;
		if (likely(flag == TTY_NORMAL)) {
			unsigned char c = *cp++;

			if (I_ISTRIP(tty))
				c &= 0x7f;
			if (I_IUCLC(tty) && L_IEXTEN(tty))
				c = tolower(c);
			if (L_EXTPROC(tty)) {
				put_tty_queue(c, ldata);
				continue;
			}
			n_tty_receive_char(tty, c);
		} else
			n_tty_receive_char_flagged(tty, *cp++, flag);
	}
}

static void
n_tty_receive_buf_fast(struct tty_struct *tty, const unsigned char *cp,
		       char *fp, int count)
1612 1613 1614 1615 1616 1617 1618
{
	char flag = TTY_NORMAL;

	while (count--) {
		if (fp)
			flag = *fp++;
		if (likely(flag == TTY_NORMAL))
1619
			n_tty_receive_char_fast(tty, *cp++);
1620 1621 1622 1623 1624
		else
			n_tty_receive_char_flagged(tty, *cp++, flag);
	}
}

1625 1626
static void __receive_buf(struct tty_struct *tty, const unsigned char *cp,
			  char *fp, int count)
L
Linus Torvalds 已提交
1627
{
1628
	struct n_tty_data *ldata = tty->disc_data;
1629
	bool preops = I_ISTRIP(tty) || (I_IUCLC(tty) && L_IEXTEN(tty));
L
Linus Torvalds 已提交
1630

1631 1632
	if (ldata->real_raw)
		n_tty_receive_buf_real_raw(tty, cp, fp, count);
1633
	else if (ldata->raw || (L_EXTPROC(tty) && !preops))
1634
		n_tty_receive_buf_raw(tty, cp, fp, count);
1635 1636
	else if (tty->closing && !L_EXTPROC(tty))
		n_tty_receive_buf_closing(tty, cp, fp, count);
1637
	else {
1638
		if (!preops && !I_PARMRK(tty))
1639 1640 1641
			n_tty_receive_buf_fast(tty, cp, fp, count);
		else
			n_tty_receive_buf_standard(tty, cp, fp, count);
P
Peter Hurley 已提交
1642 1643

		flush_echoes(tty);
A
Alan Cox 已提交
1644 1645
		if (tty->ops->flush_chars)
			tty->ops->flush_chars(tty);
L
Linus Torvalds 已提交
1646 1647
	}

1648
	if ((!ldata->icanon && (read_cnt(ldata) >= ldata->minimum_to_wake)) ||
1649
		L_EXTPROC(tty)) {
L
Linus Torvalds 已提交
1650 1651 1652 1653 1654 1655
		kill_fasync(&tty->fasync, SIGIO, POLL_IN);
		if (waitqueue_active(&tty->read_wait))
			wake_up_interruptible(&tty->read_wait);
	}
}

1656 1657 1658
static void n_tty_receive_buf(struct tty_struct *tty, const unsigned char *cp,
			      char *fp, int count)
{
1659 1660
	int room, n;

1661
	down_read(&tty->termios_rwsem);
1662 1663 1664 1665 1666 1667 1668 1669 1670 1671 1672 1673 1674 1675

	while (1) {
		room = receive_room(tty);
		n = min(count, room);
		if (!n)
			break;
		__receive_buf(tty, cp, fp, n);
		cp += n;
		if (fp)
			fp += n;
		count -= n;
	}

	tty->receive_room = room;
1676
	n_tty_check_throttle(tty);
1677
	up_read(&tty->termios_rwsem);
1678 1679 1680 1681 1682 1683
}

static int n_tty_receive_buf2(struct tty_struct *tty, const unsigned char *cp,
			      char *fp, int count)
{
	struct n_tty_data *ldata = tty->disc_data;
1684
	int room, n, rcvd = 0;
1685

1686 1687
	down_read(&tty->termios_rwsem);

1688 1689 1690 1691 1692 1693 1694 1695 1696 1697 1698 1699 1700 1701
	while (1) {
		room = receive_room(tty);
		n = min(count, room);
		if (!n) {
			if (!room)
				ldata->no_room = 1;
			break;
		}
		__receive_buf(tty, cp, fp, n);
		cp += n;
		if (fp)
			fp += n;
		count -= n;
		rcvd += n;
1702
	}
1703

1704 1705
	tty->receive_room = room;
	n_tty_check_throttle(tty);
1706 1707
	up_read(&tty->termios_rwsem);

1708
	return rcvd;
1709 1710
}

L
Linus Torvalds 已提交
1711 1712 1713
int is_ignored(int sig)
{
	return (sigismember(&current->blocked, sig) ||
1714
		current->sighand->action[sig-1].sa.sa_handler == SIG_IGN);
L
Linus Torvalds 已提交
1715 1716 1717 1718 1719 1720 1721 1722 1723
}

/**
 *	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
1724
 *	and is protected from re-entry by the tty layer. The user is
L
Linus Torvalds 已提交
1725 1726
 *	guaranteed that this function will not be re-entered or in progress
 *	when the ldisc is closed.
1727
 *
1728
 *	Locking: Caller holds tty->termios_rwsem
L
Linus Torvalds 已提交
1729
 */
1730 1731

static void n_tty_set_termios(struct tty_struct *tty, struct ktermios *old)
L
Linus Torvalds 已提交
1732
{
1733
	struct n_tty_data *ldata = tty->disc_data;
1734 1735 1736
	int canon_change = 1;

	if (old)
1737
		canon_change = (old->c_lflag ^ tty->termios.c_lflag) & ICANON;
1738
	if (canon_change) {
1739
		bitmap_zero(ldata->read_flags, N_TTY_BUF_SIZE);
P
Peter Hurley 已提交
1740
		ldata->line_start = 0;
1741
		ldata->canon_head = ldata->read_tail;
1742
		ldata->erasing = 0;
1743
		ldata->lnext = 0;
1744 1745
	}

1746
	if (canon_change && !L_ICANON(tty) && read_cnt(ldata))
1747
		wake_up_interruptible(&tty->read_wait);
1748

1749
	ldata->icanon = (L_ICANON(tty) != 0);
P
Peter Hurley 已提交
1750

L
Linus Torvalds 已提交
1751 1752 1753 1754
	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)) {
1755
		bitmap_zero(ldata->char_map, 256);
L
Linus Torvalds 已提交
1756 1757

		if (I_IGNCR(tty) || I_ICRNL(tty))
1758
			set_bit('\r', ldata->char_map);
L
Linus Torvalds 已提交
1759
		if (I_INLCR(tty))
1760
			set_bit('\n', ldata->char_map);
L
Linus Torvalds 已提交
1761 1762

		if (L_ICANON(tty)) {
1763 1764 1765 1766 1767
			set_bit(ERASE_CHAR(tty), ldata->char_map);
			set_bit(KILL_CHAR(tty), ldata->char_map);
			set_bit(EOF_CHAR(tty), ldata->char_map);
			set_bit('\n', ldata->char_map);
			set_bit(EOL_CHAR(tty), ldata->char_map);
L
Linus Torvalds 已提交
1768
			if (L_IEXTEN(tty)) {
1769 1770 1771
				set_bit(WERASE_CHAR(tty), ldata->char_map);
				set_bit(LNEXT_CHAR(tty), ldata->char_map);
				set_bit(EOL2_CHAR(tty), ldata->char_map);
L
Linus Torvalds 已提交
1772 1773
				if (L_ECHO(tty))
					set_bit(REPRINT_CHAR(tty),
1774
						ldata->char_map);
L
Linus Torvalds 已提交
1775 1776 1777
			}
		}
		if (I_IXON(tty)) {
1778 1779
			set_bit(START_CHAR(tty), ldata->char_map);
			set_bit(STOP_CHAR(tty), ldata->char_map);
L
Linus Torvalds 已提交
1780 1781
		}
		if (L_ISIG(tty)) {
1782 1783 1784
			set_bit(INTR_CHAR(tty), ldata->char_map);
			set_bit(QUIT_CHAR(tty), ldata->char_map);
			set_bit(SUSP_CHAR(tty), ldata->char_map);
L
Linus Torvalds 已提交
1785
		}
1786
		clear_bit(__DISABLED_CHAR, ldata->char_map);
1787 1788
		ldata->raw = 0;
		ldata->real_raw = 0;
L
Linus Torvalds 已提交
1789
	} else {
1790
		ldata->raw = 1;
L
Linus Torvalds 已提交
1791 1792 1793
		if ((I_IGNBRK(tty) || (!I_BRKINT(tty) && !I_PARMRK(tty))) &&
		    (I_IGNPAR(tty) || !I_INPCK(tty)) &&
		    (tty->driver->flags & TTY_DRIVER_REAL_RAW))
1794
			ldata->real_raw = 1;
L
Linus Torvalds 已提交
1795
		else
1796
			ldata->real_raw = 0;
L
Linus Torvalds 已提交
1797
	}
1798
	n_tty_set_room(tty);
1799 1800 1801 1802 1803 1804 1805 1806
	/*
	 * Fix tty hang when I_IXON(tty) is cleared, but the tty
	 * been stopped by STOP_CHAR(tty) before it.
	 */
	if (!I_IXON(tty) && old && (old->c_iflag & IXON) && !tty->flow_stopped) {
		start_tty(tty);
	}

A
Alan Cox 已提交
1807 1808 1809
	/* The termios change make the tty ready for I/O */
	wake_up_interruptible(&tty->write_wait);
	wake_up_interruptible(&tty->read_wait);
L
Linus Torvalds 已提交
1810 1811 1812 1813 1814 1815
}

/**
 *	n_tty_close		-	close the ldisc for this tty
 *	@tty: device
 *
1816 1817
 *	Called from the terminal layer when this line discipline is
 *	being shut down, either because of a close or becsuse of a
L
Linus Torvalds 已提交
1818 1819 1820
 *	discipline change. The function will not be called while other
 *	ldisc methods are in progress.
 */
1821

L
Linus Torvalds 已提交
1822 1823
static void n_tty_close(struct tty_struct *tty)
{
J
Jiri Slaby 已提交
1824 1825
	struct n_tty_data *ldata = tty->disc_data;

1826 1827 1828
	if (tty->link)
		n_tty_packet_mode_flush(tty);

1829
	vfree(ldata);
J
Jiri Slaby 已提交
1830
	tty->disc_data = NULL;
L
Linus Torvalds 已提交
1831 1832 1833 1834 1835 1836
}

/**
 *	n_tty_open		-	open an ldisc
 *	@tty: terminal to open
 *
1837
 *	Called when this line discipline is being attached to the
L
Linus Torvalds 已提交
1838 1839 1840 1841 1842 1843 1844
 *	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)
{
J
Jiri Slaby 已提交
1845 1846
	struct n_tty_data *ldata;

1847 1848
	/* Currently a malloc failure here can panic */
	ldata = vmalloc(sizeof(*ldata));
J
Jiri Slaby 已提交
1849 1850 1851
	if (!ldata)
		goto err;

1852
	ldata->overrun_time = jiffies;
1853 1854
	mutex_init(&ldata->atomic_read_lock);
	mutex_init(&ldata->output_lock);
1855

J
Jiri Slaby 已提交
1856
	tty->disc_data = ldata;
1857
	reset_buffer_flags(tty->disc_data);
1858
	ldata->column = 0;
1859
	ldata->canon_column = 0;
1860
	ldata->minimum_to_wake = 1;
1861 1862 1863
	ldata->num_overrun = 0;
	ldata->no_room = 0;
	ldata->lnext = 0;
L
Linus Torvalds 已提交
1864
	tty->closing = 0;
1865 1866 1867 1868
	/* indicate buffer work may resume */
	clear_bit(TTY_LDISC_HALTED, &tty->flags);
	n_tty_set_termios(tty, NULL);
	tty_unthrottle(tty);
J
Jiri Slaby 已提交
1869

L
Linus Torvalds 已提交
1870
	return 0;
J
Jiri Slaby 已提交
1871
err:
1872
	return -ENOMEM;
L
Linus Torvalds 已提交
1873 1874 1875 1876
}

static inline int input_available_p(struct tty_struct *tty, int amt)
{
1877 1878 1879
	struct n_tty_data *ldata = tty->disc_data;

	if (ldata->icanon && !L_EXTPROC(tty)) {
1880
		if (ldata->canon_head != ldata->read_tail)
L
Linus Torvalds 已提交
1881
			return 1;
1882
	} else if (read_cnt(ldata) >= (amt ? amt : 1))
L
Linus Torvalds 已提交
1883 1884 1885 1886 1887 1888
		return 1;

	return 0;
}

/**
1889
 *	copy_from_read_buf	-	copy read data directly
L
Linus Torvalds 已提交
1890 1891 1892 1893
 *	@tty: terminal device
 *	@b: user data
 *	@nr: size of data
 *
1894
 *	Helper function to speed up n_tty_read.  It is only called when
L
Linus Torvalds 已提交
1895 1896 1897 1898 1899 1900
 *	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.
 *
1901
 *	Called under the ldata->atomic_read_lock sem
L
Linus Torvalds 已提交
1902
 *
1903 1904 1905
 *	n_tty_read()/consumer path:
 *		caller holds non-exclusive termios_rwsem
 *		read_tail published
L
Linus Torvalds 已提交
1906
 */
1907

A
Alan Cox 已提交
1908
static int copy_from_read_buf(struct tty_struct *tty,
L
Linus Torvalds 已提交
1909 1910 1911 1912
				      unsigned char __user **b,
				      size_t *nr)

{
1913
	struct n_tty_data *ldata = tty->disc_data;
L
Linus Torvalds 已提交
1914 1915
	int retval;
	size_t n;
1916
	bool is_eof;
1917
	size_t tail = ldata->read_tail & (N_TTY_BUF_SIZE - 1);
L
Linus Torvalds 已提交
1918 1919

	retval = 0;
1920
	n = min(read_cnt(ldata), N_TTY_BUF_SIZE - tail);
L
Linus Torvalds 已提交
1921 1922
	n = min(*nr, n);
	if (n) {
1923
		retval = copy_to_user(*b, read_buf_addr(ldata, tail), n);
L
Linus Torvalds 已提交
1924
		n -= retval;
1925 1926
		is_eof = n == 1 && read_buf(ldata, tail) == EOF_CHAR(tty);
		tty_audit_add_data(tty, read_buf_addr(ldata, tail), n,
1927
				ldata->icanon);
1928
		ldata->read_tail += n;
1929
		/* Turn single EOF into zero-length read */
1930
		if (L_EXTPROC(tty) && ldata->icanon && is_eof && !read_cnt(ldata))
1931
			n = 0;
L
Linus Torvalds 已提交
1932 1933 1934 1935 1936 1937
		*b += n;
		*nr -= n;
	}
	return retval;
}

1938
/**
1939
 *	canon_copy_from_read_buf	-	copy read data in canonical mode
1940 1941 1942 1943 1944
 *	@tty: terminal device
 *	@b: user data
 *	@nr: size of data
 *
 *	Helper function for n_tty_read.  It is only called when ICANON is on;
1945 1946
 *	it copies one line of input up to and including the line-delimiting
 *	character into the user-space buffer.
1947 1948
 *
 *	Called under the atomic_read_lock mutex
1949 1950 1951 1952
 *
 *	n_tty_read()/consumer path:
 *		caller holds non-exclusive termios_rwsem
 *		read_tail published
1953 1954
 */

1955 1956 1957
static int canon_copy_from_read_buf(struct tty_struct *tty,
				    unsigned char __user **b,
				    size_t *nr)
1958 1959
{
	struct n_tty_data *ldata = tty->disc_data;
1960
	size_t n, size, more, c;
1961 1962 1963
	size_t eol;
	size_t tail;
	int ret, found = 0;
P
Peter Hurley 已提交
1964
	bool eof_push = 0;
1965 1966

	/* N.B. avoid overrun if nr == 0 */
1967
	n = min(*nr, read_cnt(ldata));
1968
	if (!n)
1969
		return 0;
1970

1971
	tail = ldata->read_tail & (N_TTY_BUF_SIZE - 1);
1972 1973
	size = min_t(size_t, tail + n, N_TTY_BUF_SIZE);

1974
	n_tty_trace("%s: nr:%zu tail:%zu n:%zu size:%zu\n",
1975 1976 1977 1978 1979 1980 1981 1982 1983 1984 1985 1986 1987 1988 1989 1990
		    __func__, *nr, tail, n, size);

	eol = find_next_bit(ldata->read_flags, size, tail);
	more = n - (size - tail);
	if (eol == N_TTY_BUF_SIZE && more) {
		/* scan wrapped without finding set bit */
		eol = find_next_bit(ldata->read_flags, more, 0);
		if (eol != more)
			found = 1;
	} else if (eol != size)
		found = 1;

	size = N_TTY_BUF_SIZE - tail;
	n = (found + eol + size) & (N_TTY_BUF_SIZE - 1);
	c = n;

P
Peter Hurley 已提交
1991
	if (found && read_buf(ldata, eol) == __DISABLED_CHAR) {
1992
		n--;
P
Peter Hurley 已提交
1993 1994
		eof_push = !n && ldata->read_tail != ldata->line_start;
	}
1995

1996
	n_tty_trace("%s: eol:%zu found:%d n:%zu c:%zu size:%zu more:%zu\n",
1997 1998 1999
		    __func__, eol, found, n, c, size, more);

	if (n > size) {
2000
		ret = copy_to_user(*b, read_buf_addr(ldata, tail), size);
2001 2002 2003 2004
		if (ret)
			return -EFAULT;
		ret = copy_to_user(*b + size, ldata->read_buf, n - size);
	} else
2005
		ret = copy_to_user(*b, read_buf_addr(ldata, tail), n);
2006 2007 2008 2009 2010 2011

	if (ret)
		return -EFAULT;
	*b += n;
	*nr -= n;

2012
	if (found)
2013 2014 2015
		clear_bit(eol, ldata->read_flags);
	smp_mb__after_clear_bit();
	ldata->read_tail += c;
2016

P
Peter Hurley 已提交
2017 2018
	if (found) {
		ldata->line_start = ldata->read_tail;
2019
		tty_audit_push(tty);
P
Peter Hurley 已提交
2020 2021
	}
	return eof_push ? -EAGAIN : 0;
2022 2023
}

2024
extern ssize_t redirected_tty_write(struct file *, const char __user *,
2025
							size_t, loff_t *);
L
Linus Torvalds 已提交
2026 2027 2028 2029 2030 2031 2032

/**
 *	job_control		-	check job control
 *	@tty: tty
 *	@file: file handle
 *
 *	Perform job control management checks on this file/tty descriptor
2033
 *	and if appropriate send any needed signals and return a negative
L
Linus Torvalds 已提交
2034
 *	error code if action should be taken.
A
Alan Cox 已提交
2035
 *
2036 2037 2038
 *	Locking: redirected write test is safe
 *		 current->signal->tty check is safe
 *		 ctrl_lock to safely reference tty->pgrp
L
Linus Torvalds 已提交
2039
 */
2040

L
Linus Torvalds 已提交
2041 2042 2043 2044 2045 2046 2047
static int job_control(struct tty_struct *tty, struct file *file)
{
	/* Job control check -- must be done at start and after
	   every sleep (POSIX.1 7.1.1.4). */
	/* NOTE: not yet done after every sleep pending a thorough
	   check of the logic of this change. -- jlc */
	/* don't stop on /dev/console */
2048 2049 2050 2051 2052 2053 2054 2055 2056 2057 2058 2059 2060 2061
	if (file->f_op->write == redirected_tty_write ||
	    current->signal->tty != tty)
		return 0;

	spin_lock_irq(&tty->ctrl_lock);
	if (!tty->pgrp)
		printk(KERN_ERR "n_tty_read: no tty->pgrp!\n");
	else if (task_pgrp(current) != tty->pgrp) {
		spin_unlock_irq(&tty->ctrl_lock);
		if (is_ignored(SIGTTIN) || is_current_pgrp_orphaned())
			return -EIO;
		kill_pgrp(task_pgrp(current), SIGTTIN, 1);
		set_thread_flag(TIF_SIGPENDING);
		return -ERESTARTSYS;
L
Linus Torvalds 已提交
2062
	}
2063
	spin_unlock_irq(&tty->ctrl_lock);
L
Linus Torvalds 已提交
2064 2065
	return 0;
}
2066

L
Linus Torvalds 已提交
2067 2068

/**
2069
 *	n_tty_read		-	read function for tty
L
Linus Torvalds 已提交
2070 2071 2072 2073 2074 2075 2076 2077 2078 2079 2080
 *	@tty: tty device
 *	@file: file object
 *	@buf: userspace buffer pointer
 *	@nr: size of I/O
 *
 *	Perform reads for the line discipline. We are guaranteed that the
 *	line discipline will not be closed under us but we may get multiple
 *	parallel readers and must handle this ourselves. We may also get
 *	a hangup. Always called in user context, may sleep.
 *
 *	This code must be sure never to sleep through a hangup.
2081 2082 2083 2084
 *
 *	n_tty_read()/consumer path:
 *		claims non-exclusive termios_rwsem
 *		publishes read_tail
L
Linus Torvalds 已提交
2085
 */
2086

2087
static ssize_t n_tty_read(struct tty_struct *tty, struct file *file,
L
Linus Torvalds 已提交
2088 2089
			 unsigned char __user *buf, size_t nr)
{
2090
	struct n_tty_data *ldata = tty->disc_data;
L
Linus Torvalds 已提交
2091 2092 2093 2094 2095 2096 2097
	unsigned char __user *b = buf;
	DECLARE_WAITQUEUE(wait, current);
	int c;
	int minimum, time;
	ssize_t retval = 0;
	long timeout;
	unsigned long flags;
A
Alan Cox 已提交
2098
	int packet;
L
Linus Torvalds 已提交
2099 2100

	c = job_control(tty, file);
2101
	if (c < 0)
L
Linus Torvalds 已提交
2102
		return c;
2103

2104 2105
	down_read(&tty->termios_rwsem);

L
Linus Torvalds 已提交
2106 2107
	minimum = time = 0;
	timeout = MAX_SCHEDULE_TIMEOUT;
2108
	if (!ldata->icanon) {
L
Linus Torvalds 已提交
2109 2110
		minimum = MIN_CHAR(tty);
		if (minimum) {
2111
			time = (HZ / 10) * TIME_CHAR(tty);
L
Linus Torvalds 已提交
2112
			if (time)
2113
				ldata->minimum_to_wake = 1;
L
Linus Torvalds 已提交
2114
			else if (!waitqueue_active(&tty->read_wait) ||
2115 2116
				 (ldata->minimum_to_wake > minimum))
				ldata->minimum_to_wake = minimum;
L
Linus Torvalds 已提交
2117
		} else {
2118
			timeout = (HZ / 10) * TIME_CHAR(tty);
2119
			ldata->minimum_to_wake = minimum = 1;
L
Linus Torvalds 已提交
2120 2121 2122 2123 2124 2125 2126
		}
	}

	/*
	 *	Internal serialization of reads.
	 */
	if (file->f_flags & O_NONBLOCK) {
2127 2128
		if (!mutex_trylock(&ldata->atomic_read_lock)) {
			up_read(&tty->termios_rwsem);
L
Linus Torvalds 已提交
2129
			return -EAGAIN;
2130
		}
2131
	} else {
2132 2133
		if (mutex_lock_interruptible(&ldata->atomic_read_lock)) {
			up_read(&tty->termios_rwsem);
L
Linus Torvalds 已提交
2134
			return -ERESTARTSYS;
2135
		}
L
Linus Torvalds 已提交
2136
	}
A
Alan Cox 已提交
2137
	packet = tty->packet;
L
Linus Torvalds 已提交
2138 2139 2140 2141

	add_wait_queue(&tty->read_wait, &wait);
	while (nr) {
		/* First test for status change. */
A
Alan Cox 已提交
2142
		if (packet && tty->link->ctrl_status) {
L
Linus Torvalds 已提交
2143 2144 2145
			unsigned char cs;
			if (b != buf)
				break;
A
Alan Cox 已提交
2146
			spin_lock_irqsave(&tty->link->ctrl_lock, flags);
L
Linus Torvalds 已提交
2147 2148
			cs = tty->link->ctrl_status;
			tty->link->ctrl_status = 0;
A
Alan Cox 已提交
2149
			spin_unlock_irqrestore(&tty->link->ctrl_lock, flags);
M
Miloslav Trmac 已提交
2150
			if (tty_put_user(tty, cs, b++)) {
L
Linus Torvalds 已提交
2151 2152 2153 2154 2155 2156 2157 2158 2159 2160 2161
				retval = -EFAULT;
				b--;
				break;
			}
			nr--;
			break;
		}
		/* This statement must be first before checking for input
		   so that any interrupt will set the state back to
		   TASK_RUNNING. */
		set_current_state(TASK_INTERRUPTIBLE);
2162

2163
		if (((minimum - (b - buf)) < ldata->minimum_to_wake) &&
L
Linus Torvalds 已提交
2164
		    ((minimum - (b - buf)) >= 1))
2165
			ldata->minimum_to_wake = (minimum - (b - buf));
2166

L
Linus Torvalds 已提交
2167 2168 2169 2170 2171 2172 2173 2174 2175 2176 2177 2178 2179 2180 2181 2182 2183
		if (!input_available_p(tty, 0)) {
			if (test_bit(TTY_OTHER_CLOSED, &tty->flags)) {
				retval = -EIO;
				break;
			}
			if (tty_hung_up_p(file))
				break;
			if (!timeout)
				break;
			if (file->f_flags & O_NONBLOCK) {
				retval = -EAGAIN;
				break;
			}
			if (signal_pending(current)) {
				retval = -ERESTARTSYS;
				break;
			}
2184
			n_tty_set_room(tty);
2185 2186
			up_read(&tty->termios_rwsem);

L
Linus Torvalds 已提交
2187
			timeout = schedule_timeout(timeout);
2188 2189

			down_read(&tty->termios_rwsem);
L
Linus Torvalds 已提交
2190 2191 2192 2193 2194
			continue;
		}
		__set_current_state(TASK_RUNNING);

		/* Deal with packet mode. */
A
Alan Cox 已提交
2195
		if (packet && b == buf) {
M
Miloslav Trmac 已提交
2196
			if (tty_put_user(tty, TIOCPKT_DATA, b++)) {
L
Linus Torvalds 已提交
2197 2198 2199 2200 2201 2202 2203
				retval = -EFAULT;
				b--;
				break;
			}
			nr--;
		}

2204
		if (ldata->icanon && !L_EXTPROC(tty)) {
2205
			retval = canon_copy_from_read_buf(tty, &b, &nr);
P
Peter Hurley 已提交
2206 2207 2208 2209
			if (retval == -EAGAIN) {
				retval = 0;
				continue;
			} else if (retval)
L
Linus Torvalds 已提交
2210 2211 2212
				break;
		} else {
			int uncopied;
A
Alan Cox 已提交
2213 2214
			/* The copy function takes the read lock and handles
			   locking internally for this case */
L
Linus Torvalds 已提交
2215 2216 2217 2218 2219 2220 2221 2222
			uncopied = copy_from_read_buf(tty, &b, &nr);
			uncopied += copy_from_read_buf(tty, &b, &nr);
			if (uncopied) {
				retval = -EFAULT;
				break;
			}
		}

2223
		n_tty_check_unthrottle(tty);
L
Linus Torvalds 已提交
2224 2225 2226 2227 2228 2229

		if (b - buf >= minimum)
			break;
		if (time)
			timeout = time;
	}
2230
	mutex_unlock(&ldata->atomic_read_lock);
L
Linus Torvalds 已提交
2231 2232 2233
	remove_wait_queue(&tty->read_wait, &wait);

	if (!waitqueue_active(&tty->read_wait))
2234
		ldata->minimum_to_wake = minimum;
L
Linus Torvalds 已提交
2235 2236

	__set_current_state(TASK_RUNNING);
P
Peter Hurley 已提交
2237 2238
	if (b - buf)
		retval = b - buf;
L
Linus Torvalds 已提交
2239

2240
	n_tty_set_room(tty);
2241
	up_read(&tty->termios_rwsem);
L
Linus Torvalds 已提交
2242 2243 2244 2245
	return retval;
}

/**
2246
 *	n_tty_write		-	write function for tty
L
Linus Torvalds 已提交
2247 2248 2249 2250 2251
 *	@tty: tty device
 *	@file: file object
 *	@buf: userspace buffer pointer
 *	@nr: size of I/O
 *
2252
 *	Write function of the terminal device.  This is serialized with
L
Linus Torvalds 已提交
2253
 *	respect to other write callers but not to termios changes, reads
2254 2255 2256 2257 2258
 *	and other such events.  Since the receive code will echo characters,
 *	thus calling driver write methods, the output_lock is used in
 *	the output processing functions called here as well as in the
 *	echo processing function to protect the column state and space
 *	left in the buffer.
L
Linus Torvalds 已提交
2259 2260
 *
 *	This code must be sure never to sleep through a hangup.
2261 2262 2263 2264
 *
 *	Locking: output_lock to protect column state and space left
 *		 (note that the process_output*() functions take this
 *		  lock themselves)
L
Linus Torvalds 已提交
2265
 */
2266

2267
static ssize_t n_tty_write(struct tty_struct *tty, struct file *file,
2268
			   const unsigned char *buf, size_t nr)
L
Linus Torvalds 已提交
2269 2270 2271 2272 2273 2274 2275 2276 2277 2278 2279 2280 2281
{
	const unsigned char *b = buf;
	DECLARE_WAITQUEUE(wait, current);
	int c;
	ssize_t retval = 0;

	/* Job control check -- must be done at start (POSIX.1 7.1.1.4). */
	if (L_TOSTOP(tty) && file->f_op->write != redirected_tty_write) {
		retval = tty_check_change(tty);
		if (retval)
			return retval;
	}

2282 2283
	down_read(&tty->termios_rwsem);

2284 2285
	/* Write out any echoed characters that are still pending */
	process_echoes(tty);
A
Alan Cox 已提交
2286

L
Linus Torvalds 已提交
2287 2288 2289 2290 2291 2292 2293 2294 2295 2296 2297
	add_wait_queue(&tty->write_wait, &wait);
	while (1) {
		set_current_state(TASK_INTERRUPTIBLE);
		if (signal_pending(current)) {
			retval = -ERESTARTSYS;
			break;
		}
		if (tty_hung_up_p(file) || (tty->link && !tty->link->count)) {
			retval = -EIO;
			break;
		}
P
Peter Hurley 已提交
2298
		if (O_OPOST(tty)) {
L
Linus Torvalds 已提交
2299
			while (nr > 0) {
2300
				ssize_t num = process_output_block(tty, b, nr);
L
Linus Torvalds 已提交
2301 2302 2303 2304 2305 2306 2307 2308 2309 2310 2311
				if (num < 0) {
					if (num == -EAGAIN)
						break;
					retval = num;
					goto break_out;
				}
				b += num;
				nr -= num;
				if (nr == 0)
					break;
				c = *b;
2312
				if (process_output(c, tty) < 0)
L
Linus Torvalds 已提交
2313 2314 2315
					break;
				b++; nr--;
			}
A
Alan Cox 已提交
2316 2317
			if (tty->ops->flush_chars)
				tty->ops->flush_chars(tty);
L
Linus Torvalds 已提交
2318
		} else {
R
Roman Zippel 已提交
2319
			while (nr > 0) {
A
Alan Cox 已提交
2320
				c = tty->ops->write(tty, b, nr);
R
Roman Zippel 已提交
2321 2322 2323 2324 2325 2326 2327 2328
				if (c < 0) {
					retval = c;
					goto break_out;
				}
				if (!c)
					break;
				b += c;
				nr -= c;
L
Linus Torvalds 已提交
2329 2330 2331 2332 2333 2334 2335 2336
			}
		}
		if (!nr)
			break;
		if (file->f_flags & O_NONBLOCK) {
			retval = -EAGAIN;
			break;
		}
2337 2338
		up_read(&tty->termios_rwsem);

L
Linus Torvalds 已提交
2339
		schedule();
2340 2341

		down_read(&tty->termios_rwsem);
L
Linus Torvalds 已提交
2342 2343 2344 2345
	}
break_out:
	__set_current_state(TASK_RUNNING);
	remove_wait_queue(&tty->write_wait, &wait);
2346 2347
	if (b - buf != nr && tty->fasync)
		set_bit(TTY_DO_WRITE_WAKEUP, &tty->flags);
2348
	up_read(&tty->termios_rwsem);
L
Linus Torvalds 已提交
2349 2350 2351 2352
	return (b - buf) ? b - buf : retval;
}

/**
2353
 *	n_tty_poll		-	poll method for N_TTY
L
Linus Torvalds 已提交
2354 2355 2356 2357 2358 2359 2360 2361 2362 2363 2364
 *	@tty: terminal device
 *	@file: file accessing it
 *	@wait: poll table
 *
 *	Called when the line discipline is asked to poll() for data or
 *	for special events. This code is not serialized with respect to
 *	other events save open/close.
 *
 *	This code must be sure never to sleep through a hangup.
 *	Called without the kernel lock held - fine
 */
2365

2366
static unsigned int n_tty_poll(struct tty_struct *tty, struct file *file,
2367
							poll_table *wait)
L
Linus Torvalds 已提交
2368
{
2369
	struct n_tty_data *ldata = tty->disc_data;
L
Linus Torvalds 已提交
2370 2371 2372 2373 2374 2375 2376 2377 2378 2379 2380 2381 2382 2383
	unsigned int mask = 0;

	poll_wait(file, &tty->read_wait, wait);
	poll_wait(file, &tty->write_wait, wait);
	if (input_available_p(tty, TIME_CHAR(tty) ? 0 : MIN_CHAR(tty)))
		mask |= POLLIN | POLLRDNORM;
	if (tty->packet && tty->link->ctrl_status)
		mask |= POLLPRI | POLLIN | POLLRDNORM;
	if (test_bit(TTY_OTHER_CLOSED, &tty->flags))
		mask |= POLLHUP;
	if (tty_hung_up_p(file))
		mask |= POLLHUP;
	if (!(mask & (POLLHUP | POLLIN | POLLRDNORM))) {
		if (MIN_CHAR(tty) && !TIME_CHAR(tty))
2384
			ldata->minimum_to_wake = MIN_CHAR(tty);
L
Linus Torvalds 已提交
2385
		else
2386
			ldata->minimum_to_wake = 1;
L
Linus Torvalds 已提交
2387
	}
A
Alan Cox 已提交
2388 2389 2390
	if (tty->ops->write && !tty_is_writelocked(tty) &&
			tty_chars_in_buffer(tty) < WAKEUP_CHARS &&
			tty_write_room(tty) > 0)
L
Linus Torvalds 已提交
2391 2392 2393 2394
		mask |= POLLOUT | POLLWRNORM;
	return mask;
}

J
Jiri Slaby 已提交
2395
static unsigned long inq_canon(struct n_tty_data *ldata)
2396
{
2397
	size_t nr, head, tail;
2398

2399
	if (ldata->canon_head == ldata->read_tail)
2400
		return 0;
2401 2402
	head = ldata->canon_head;
	tail = ldata->read_tail;
2403
	nr = head - tail;
2404 2405
	/* Skip EOF-chars.. */
	while (head != tail) {
2406 2407
		if (test_bit(tail & (N_TTY_BUF_SIZE - 1), ldata->read_flags) &&
		    read_buf(ldata, tail) == __DISABLED_CHAR)
2408
			nr--;
2409
		tail++;
2410 2411 2412 2413 2414 2415 2416
	}
	return nr;
}

static int n_tty_ioctl(struct tty_struct *tty, struct file *file,
		       unsigned int cmd, unsigned long arg)
{
2417
	struct n_tty_data *ldata = tty->disc_data;
2418 2419 2420 2421 2422 2423
	int retval;

	switch (cmd) {
	case TIOCOUTQ:
		return put_user(tty_chars_in_buffer(tty), (int __user *) arg);
	case TIOCINQ:
2424
		down_write(&tty->termios_rwsem);
2425
		if (L_ICANON(tty))
J
Jiri Slaby 已提交
2426
			retval = inq_canon(ldata);
2427 2428 2429
		else
			retval = read_cnt(ldata);
		up_write(&tty->termios_rwsem);
2430 2431 2432 2433 2434 2435
		return put_user(retval, (unsigned int __user *) arg);
	default:
		return n_tty_ioctl_helper(tty, file, cmd, arg);
	}
}

2436 2437 2438 2439 2440 2441 2442 2443 2444 2445 2446 2447
static void n_tty_fasync(struct tty_struct *tty, int on)
{
	struct n_tty_data *ldata = tty->disc_data;

	if (!waitqueue_active(&tty->read_wait)) {
		if (on)
			ldata->minimum_to_wake = 1;
		else if (!tty->fasync)
			ldata->minimum_to_wake = N_TTY_BUF_SIZE;
	}
}

A
Alan Cox 已提交
2448
struct tty_ldisc_ops tty_ldisc_N_TTY = {
P
Paul Fulghum 已提交
2449 2450 2451 2452 2453 2454
	.magic           = TTY_LDISC_MAGIC,
	.name            = "n_tty",
	.open            = n_tty_open,
	.close           = n_tty_close,
	.flush_buffer    = n_tty_flush_buffer,
	.chars_in_buffer = n_tty_chars_in_buffer,
2455 2456
	.read            = n_tty_read,
	.write           = n_tty_write,
P
Paul Fulghum 已提交
2457 2458
	.ioctl           = n_tty_ioctl,
	.set_termios     = n_tty_set_termios,
2459
	.poll            = n_tty_poll,
P
Paul Fulghum 已提交
2460
	.receive_buf     = n_tty_receive_buf,
2461 2462
	.write_wakeup    = n_tty_write_wakeup,
	.fasync		 = n_tty_fasync,
2463
	.receive_buf2	 = n_tty_receive_buf2,
L
Linus Torvalds 已提交
2464
};
2465 2466 2467 2468 2469

/**
 *	n_tty_inherit_ops	-	inherit N_TTY methods
 *	@ops: struct tty_ldisc_ops where to save N_TTY methods
 *
2470
 *	Enables a 'subclass' line discipline to 'inherit' N_TTY
2471 2472 2473 2474 2475 2476 2477 2478 2479 2480
 *	methods.
 */

void n_tty_inherit_ops(struct tty_ldisc_ops *ops)
{
	*ops = tty_ldisc_N_TTY;
	ops->owner = NULL;
	ops->refcount = ops->flags = 0;
}
EXPORT_SYMBOL_GPL(n_tty_inherit_ops);