Kernel

Kernel Git Source Tree

Root/drivers/tty/n_tty.c

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

Download this file

Branches:
ben-wpan
ben-wpan-stefan
javiroman/ks7010
jz-2.6.34
jz-2.6.34-rc5
jz-2.6.34-rc6
jz-2.6.34-rc7
jz-2.6.35
jz-2.6.36
jz-2.6.37
jz-2.6.38
jz-2.6.39
jz-3.0
jz-3.1
jz-3.11
jz-3.12
jz-3.13
jz-3.15
jz-3.16
jz-3.18-dt
jz-3.2
jz-3.3
jz-3.4
jz-3.5
jz-3.6
jz-3.6-rc2-pwm
jz-3.9
jz-3.9-clk
jz-3.9-rc8
jz47xx
jz47xx-2.6.38
master

Tags:
od-2011-09-04
od-2011-09-18
v2.6.34-rc5
v2.6.34-rc6
v2.6.34-rc7
v3.9

Kernel

Kernel Git Source Tree

Root/drivers/tty/n_tty.c

interactive