blob: 9ec0c68aa7396c4a46be620ffadbc5f27b1b998a [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
2 * n_tty.c --- implements the N_TTY line discipline.
Alan Cox4edf1822008-02-08 04:18:44 -08003 *
Linus Torvalds1da177e2005-04-16 15:20:36 -07004 * 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
Alan Cox4edf1822008-02-08 04:18:44 -080011 * to N_TTY if it can not switch to any other line discipline.
Linus Torvalds1da177e2005-04-16 15:20:36 -070012 *
13 * Written by Theodore Ts'o, Copyright 1994.
Alan Cox4edf1822008-02-08 04:18:44 -080014 *
Linus Torvalds1da177e2005-04-16 15:20:36 -070015 * This file also contains code originally written by Linus Torvalds,
16 * Copyright 1991, 1992, 1993, and by Julian Cowley, Copyright 1994.
Alan Cox4edf1822008-02-08 04:18:44 -080017 *
Linus Torvalds1da177e2005-04-16 15:20:36 -070018 * 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 *
Alan Cox4edf1822008-02-08 04:18:44 -080023 * 2000/01/20 Fixed SMP locking on put_tty_queue using bits of
Linus Torvalds1da177e2005-04-16 15:20:36 -070024 * 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>.
Alan Cox11a96d12008-10-13 10:46:24 +010029 * Also fixed a bug in BLOCKING mode where n_tty_write returns
Linus Torvalds1da177e2005-04-16 15:20:36 -070030 * 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>
Miloslav Trmac522ed772007-07-15 23:40:56 -070048#include <linux/audit.h>
49#include <linux/file.h>
Alan Cox300a6202009-01-02 13:41:04 +000050#include <linux/uaccess.h>
Rodolfo Giometti572b9ad2010-03-10 15:23:46 -080051#include <linux/module.h>
George Spelvin593fb1ae42013-02-12 02:00:43 -050052#include <linux/ratelimit.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070053
Linus Torvalds1da177e2005-04-16 15:20:36 -070054
55/* number of characters left in xmit buffer before select has we have room */
56#define WAKEUP_CHARS 256
57
58/*
59 * This defines the low- and high-watermarks for throttling and
60 * unthrottling the TTY driver. These watermarks are used for
61 * controlling the space in the read buffer.
62 */
63#define TTY_THRESHOLD_THROTTLE 128 /* now based on remaining room */
Thorsten Wißmannbbd20752011-12-08 17:47:33 +010064#define TTY_THRESHOLD_UNTHROTTLE 128
Linus Torvalds1da177e2005-04-16 15:20:36 -070065
Joe Petersona88a69c2009-01-02 13:40:53 +000066/*
67 * Special byte codes used in the echo buffer to represent operations
68 * or special handling of characters. Bytes in the echo buffer that
69 * are not part of such special blocks are treated as normal character
70 * codes.
71 */
72#define ECHO_OP_START 0xff
73#define ECHO_OP_MOVE_BACK_COL 0x80
74#define ECHO_OP_SET_CANON_COL 0x81
75#define ECHO_OP_ERASE_TAB 0x82
76
Peter Hurley32f13522013-06-15 09:14:17 -040077#undef N_TTY_TRACE
78#ifdef N_TTY_TRACE
79# define n_tty_trace(f, args...) trace_printk(f, ##args)
80#else
81# define n_tty_trace(f, args...)
82#endif
83
Jiri Slaby70ece7a2012-10-18 22:26:38 +020084struct n_tty_data {
Peter Hurleyfb7aa032013-06-15 09:14:30 -040085 /* producer-published */
86 size_t read_head;
87 size_t canon_head;
88 DECLARE_BITMAP(process_char_map, 256);
89
90 /* private to n_tty_receive_overrun (single-threaded) */
Jiri Slaby53c5ee22012-10-18 22:26:39 +020091 unsigned long overrun_time;
92 int num_overrun;
93
Peter Hurley24a89d12013-06-15 09:14:15 -040094 /* non-atomic */
95 bool no_room;
96
Peter Hurleyfb7aa032013-06-15 09:14:30 -040097 /* must hold exclusive termios_rwsem to reset these */
Jiri Slaby53c5ee22012-10-18 22:26:39 +020098 unsigned char lnext:1, erasing:1, raw:1, real_raw:1, icanon:1;
99 unsigned char echo_overrun:1;
Jiri Slaby3fe780b2012-10-18 22:26:40 +0200100
Peter Hurleyfb7aa032013-06-15 09:14:30 -0400101 /* shared by producer and consumer */
102 char *read_buf;
Jiri Slaby3fe780b2012-10-18 22:26:40 +0200103 DECLARE_BITMAP(read_flags, N_TTY_BUF_SIZE);
Jiri Slabyba2e68a2012-10-18 22:26:41 +0200104
Peter Hurleyf6c8dbe2013-06-15 07:28:28 -0400105 int minimum_to_wake;
Jiri Slabyba2e68a2012-10-18 22:26:41 +0200106
Peter Hurleyfb7aa032013-06-15 09:14:30 -0400107 /* consumer-published */
108 size_t read_tail;
109
110 /* protected by echo_lock */
Jiri Slabyba2e68a2012-10-18 22:26:41 +0200111 unsigned char *echo_buf;
112 unsigned int echo_pos;
113 unsigned int echo_cnt;
114
Peter Hurleyfb7aa032013-06-15 09:14:30 -0400115 /* protected by output lock */
116 unsigned int column;
Jiri Slabyba2e68a2012-10-18 22:26:41 +0200117 unsigned int canon_column;
Jiri Slabybddc7152012-10-18 22:26:42 +0200118
119 struct mutex atomic_read_lock;
120 struct mutex output_lock;
121 struct mutex echo_lock;
Jiri Slaby70ece7a2012-10-18 22:26:38 +0200122};
123
Peter Hurleyce741172013-06-15 09:14:20 -0400124static inline size_t read_cnt(struct n_tty_data *ldata)
125{
Peter Hurleya2f73be2013-06-15 09:14:22 -0400126 return ldata->read_head - ldata->read_tail;
Peter Hurleyce741172013-06-15 09:14:20 -0400127}
128
Peter Hurleybc5a5e32013-06-15 09:14:21 -0400129static inline unsigned char read_buf(struct n_tty_data *ldata, size_t i)
130{
131 return ldata->read_buf[i & (N_TTY_BUF_SIZE - 1)];
132}
133
134static inline unsigned char *read_buf_addr(struct n_tty_data *ldata, size_t i)
135{
136 return &ldata->read_buf[i & (N_TTY_BUF_SIZE - 1)];
137}
138
Miloslav Trmac522ed772007-07-15 23:40:56 -0700139static inline int tty_put_user(struct tty_struct *tty, unsigned char x,
140 unsigned char __user *ptr)
141{
Jiri Slaby53c5ee22012-10-18 22:26:39 +0200142 struct n_tty_data *ldata = tty->disc_data;
143
144 tty_audit_add_data(tty, &x, 1, ldata->icanon);
Miloslav Trmac522ed772007-07-15 23:40:56 -0700145 return put_user(x, ptr);
146}
147
Peter Hurley24a89d12013-06-15 09:14:15 -0400148static int receive_room(struct tty_struct *tty)
Linus Torvalds55db4c62011-06-04 06:33:24 +0900149{
Jiri Slaby53c5ee22012-10-18 22:26:39 +0200150 struct n_tty_data *ldata = tty->disc_data;
Jaeden Amero090abf72012-07-27 08:43:11 -0500151 int left;
Peter Hurleyb8483052013-06-15 07:28:30 -0400152
Jaeden Amero090abf72012-07-27 08:43:11 -0500153 if (I_PARMRK(tty)) {
154 /* Multiply read_cnt by 3, since each byte might take up to
155 * three times as many spaces when PARMRK is set (depending on
156 * its flags, e.g. parity error). */
Peter Hurleyce741172013-06-15 09:14:20 -0400157 left = N_TTY_BUF_SIZE - read_cnt(ldata) * 3 - 1;
Jaeden Amero090abf72012-07-27 08:43:11 -0500158 } else
Peter Hurleyce741172013-06-15 09:14:20 -0400159 left = N_TTY_BUF_SIZE - read_cnt(ldata) - 1;
Jaeden Amero090abf72012-07-27 08:43:11 -0500160
Linus Torvalds55db4c62011-06-04 06:33:24 +0900161 /*
162 * If we are doing input canonicalization, and there are no
163 * pending newlines, let characters through without limit, so
164 * that erase characters will be handled. Other excess
165 * characters will be beeped.
166 */
167 if (left <= 0)
Peter Hurleya73d3d62013-06-15 09:14:25 -0400168 left = ldata->icanon && ldata->canon_head == ldata->read_tail;
Linus Torvalds55db4c62011-06-04 06:33:24 +0900169
Peter Hurley24a89d12013-06-15 09:14:15 -0400170 return left;
Peter Hurley7879a9f2013-06-15 07:28:31 -0400171}
172
Peter Hurley24a89d12013-06-15 09:14:15 -0400173/**
174 * n_tty_set_room - receive space
175 * @tty: terminal
176 *
177 * Re-schedules the flip buffer work if space just became available.
178 *
Peter Hurley6d76bd22013-06-15 09:14:26 -0400179 * Caller holds exclusive termios_rwsem
180 * or
181 * n_tty_read()/consumer path:
182 * holds non-exclusive termios_rwsem
Peter Hurley24a89d12013-06-15 09:14:15 -0400183 */
184
Peter Hurley7879a9f2013-06-15 07:28:31 -0400185static void n_tty_set_room(struct tty_struct *tty)
186{
Peter Hurley24a89d12013-06-15 09:14:15 -0400187 struct n_tty_data *ldata = tty->disc_data;
188
Linus Torvalds55db4c62011-06-04 06:33:24 +0900189 /* Did this open up the receive buffer? We may need to flip */
Peter Hurley24a89d12013-06-15 09:14:15 -0400190 if (unlikely(ldata->no_room) && receive_room(tty)) {
191 ldata->no_room = 0;
192
Jiri Slabyecbbfd42012-10-18 22:26:47 +0200193 WARN_RATELIMIT(tty->port->itty == NULL,
Sasha Levincadf7482012-10-25 14:26:35 -0400194 "scheduling with invalid itty\n");
Peter Hurley21622932013-03-11 16:44:21 -0400195 /* see if ldisc has been killed - if so, this means that
196 * even though the ldisc has been halted and ->buf.work
197 * cancelled, ->buf.work is about to be rescheduled
198 */
199 WARN_RATELIMIT(test_bit(TTY_LDISC_HALTED, &tty->flags),
200 "scheduling buffer work for halted ldisc\n");
Jiri Slabyecbbfd42012-10-18 22:26:47 +0200201 schedule_work(&tty->port->buf.work);
202 }
Linus Torvalds55db4c62011-06-04 06:33:24 +0900203}
204
Peter Hurley9a4aec22013-06-15 09:14:32 -0400205static ssize_t chars_in_buffer(struct tty_struct *tty)
206{
207 struct n_tty_data *ldata = tty->disc_data;
208 ssize_t n = 0;
209
210 if (!ldata->icanon)
211 n = read_cnt(ldata);
212 else
213 n = ldata->canon_head - ldata->read_tail;
214 return n;
215}
216
Alan Cox17b82062008-10-13 10:45:06 +0100217/**
218 * put_tty_queue - add character to tty
219 * @c: character
Jiri Slaby57c94122012-10-18 22:26:43 +0200220 * @ldata: n_tty data
Alan Cox17b82062008-10-13 10:45:06 +0100221 *
Peter Hurley6d76bd22013-06-15 09:14:26 -0400222 * Add a character to the tty read_buf queue.
223 *
224 * n_tty_receive_buf()/producer path:
225 * caller holds non-exclusive termios_rwsem
226 * modifies read_head
227 *
228 * read_head is only considered 'published' if canonical mode is
229 * not active.
Alan Cox17b82062008-10-13 10:45:06 +0100230 */
231
Jiri Slaby57c94122012-10-18 22:26:43 +0200232static void put_tty_queue(unsigned char c, struct n_tty_data *ldata)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700233{
Peter Hurley6d76bd22013-06-15 09:14:26 -0400234 if (read_cnt(ldata) < N_TTY_BUF_SIZE) {
235 *read_buf_addr(ldata, ldata->read_head) = c;
236 ldata->read_head++;
237 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700238}
239
240/**
Linus Torvalds1da177e2005-04-16 15:20:36 -0700241 * reset_buffer_flags - reset buffer state
242 * @tty: terminal to reset
243 *
Peter Hurley25518c62013-03-11 16:44:31 -0400244 * Reset the read buffer counters and clear the flags.
245 * Called from n_tty_open() and n_tty_flush_buffer().
Alan Cox17b82062008-10-13 10:45:06 +0100246 *
Peter Hurley6d76bd22013-06-15 09:14:26 -0400247 * Locking: caller holds exclusive termios_rwsem
248 * (or locking is not required)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700249 */
Joe Petersona88a69c2009-01-02 13:40:53 +0000250
Peter Hurleyb66f4fa2013-03-11 16:44:32 -0400251static void reset_buffer_flags(struct n_tty_data *ldata)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700252{
Peter Hurleya73d3d62013-06-15 09:14:25 -0400253 ldata->read_head = ldata->canon_head = ldata->read_tail = 0;
Joe Petersona88a69c2009-01-02 13:40:53 +0000254
Jiri Slabybddc7152012-10-18 22:26:42 +0200255 mutex_lock(&ldata->echo_lock);
Jiri Slabyba2e68a2012-10-18 22:26:41 +0200256 ldata->echo_pos = ldata->echo_cnt = ldata->echo_overrun = 0;
Jiri Slabybddc7152012-10-18 22:26:42 +0200257 mutex_unlock(&ldata->echo_lock);
Joe Petersona88a69c2009-01-02 13:40:53 +0000258
Peter Hurleya73d3d62013-06-15 09:14:25 -0400259 ldata->erasing = 0;
Jiri Slaby3fe780b2012-10-18 22:26:40 +0200260 bitmap_zero(ldata->read_flags, N_TTY_BUF_SIZE);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700261}
262
Peter Hurleya30737a2013-03-11 16:44:22 -0400263static void n_tty_packet_mode_flush(struct tty_struct *tty)
264{
265 unsigned long flags;
266
267 spin_lock_irqsave(&tty->ctrl_lock, flags);
268 if (tty->link->packet) {
269 tty->ctrl_status |= TIOCPKT_FLUSHREAD;
270 wake_up_interruptible(&tty->link->read_wait);
271 }
272 spin_unlock_irqrestore(&tty->ctrl_lock, flags);
273}
274
Linus Torvalds1da177e2005-04-16 15:20:36 -0700275/**
276 * n_tty_flush_buffer - clean input queue
277 * @tty: terminal device
278 *
Peter Hurley25518c62013-03-11 16:44:31 -0400279 * Flush the input buffer. Called when the tty layer wants the
280 * buffer flushed (eg at hangup) or when the N_TTY line discipline
281 * internally has to clean the pending queue (for example some signals).
Linus Torvalds1da177e2005-04-16 15:20:36 -0700282 *
Peter Hurley6d76bd22013-06-15 09:14:26 -0400283 * Holds termios_rwsem to exclude producer/consumer while
284 * buffer indices are reset.
285 *
286 * Locking: ctrl_lock, exclusive termios_rwsem
Linus Torvalds1da177e2005-04-16 15:20:36 -0700287 */
Alan Cox4edf1822008-02-08 04:18:44 -0800288
289static void n_tty_flush_buffer(struct tty_struct *tty)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700290{
Peter Hurley6d76bd22013-06-15 09:14:26 -0400291 down_write(&tty->termios_rwsem);
Peter Hurleyb66f4fa2013-03-11 16:44:32 -0400292 reset_buffer_flags(tty->disc_data);
293 n_tty_set_room(tty);
Alan Cox4edf1822008-02-08 04:18:44 -0800294
Peter Hurleya30737a2013-03-11 16:44:22 -0400295 if (tty->link)
296 n_tty_packet_mode_flush(tty);
Peter Hurley6d76bd22013-06-15 09:14:26 -0400297 up_write(&tty->termios_rwsem);
298}
299
Linus Torvalds1da177e2005-04-16 15:20:36 -0700300/**
301 * n_tty_chars_in_buffer - report available bytes
302 * @tty: tty device
303 *
304 * Report the number of characters buffered to be delivered to user
Alan Cox4edf1822008-02-08 04:18:44 -0800305 * at this instant in time.
Alan Cox17b82062008-10-13 10:45:06 +0100306 *
Peter Hurley6d76bd22013-06-15 09:14:26 -0400307 * Locking: exclusive termios_rwsem
Linus Torvalds1da177e2005-04-16 15:20:36 -0700308 */
Alan Cox4edf1822008-02-08 04:18:44 -0800309
Peter Hurleya19d0c62013-06-15 09:14:18 -0400310static ssize_t n_tty_chars_in_buffer(struct tty_struct *tty)
311{
Peter Hurley6d76bd22013-06-15 09:14:26 -0400312 ssize_t n;
313
Peter Hurley47534082013-06-15 09:14:19 -0400314 WARN_ONCE(1, "%s is deprecated and scheduled for removal.", __func__);
Peter Hurley6d76bd22013-06-15 09:14:26 -0400315
316 down_write(&tty->termios_rwsem);
317 n = chars_in_buffer(tty);
318 up_write(&tty->termios_rwsem);
319 return n;
Peter Hurleya19d0c62013-06-15 09:14:18 -0400320}
321
Linus Torvalds1da177e2005-04-16 15:20:36 -0700322/**
323 * is_utf8_continuation - utf8 multibyte check
324 * @c: byte to check
325 *
326 * Returns true if the utf8 character 'c' is a multibyte continuation
327 * character. We use this to correctly compute the on screen size
328 * of the character when printing
329 */
Alan Cox4edf1822008-02-08 04:18:44 -0800330
Linus Torvalds1da177e2005-04-16 15:20:36 -0700331static inline int is_utf8_continuation(unsigned char c)
332{
333 return (c & 0xc0) == 0x80;
334}
335
336/**
337 * is_continuation - multibyte check
338 * @c: byte to check
339 *
340 * Returns true if the utf8 character 'c' is a multibyte continuation
341 * character and the terminal is in unicode mode.
342 */
Alan Cox4edf1822008-02-08 04:18:44 -0800343
Linus Torvalds1da177e2005-04-16 15:20:36 -0700344static inline int is_continuation(unsigned char c, struct tty_struct *tty)
345{
346 return I_IUTF8(tty) && is_utf8_continuation(c);
347}
348
349/**
Joe Petersona88a69c2009-01-02 13:40:53 +0000350 * do_output_char - output one character
351 * @c: character (or partial unicode symbol)
352 * @tty: terminal device
353 * @space: space available in tty driver write buffer
354 *
355 * This is a helper function that handles one output character
356 * (including special characters like TAB, CR, LF, etc.),
Joe Petersonee5aa7b2009-09-09 15:03:13 -0600357 * doing OPOST processing and putting the results in the
358 * tty driver's write buffer.
Joe Petersona88a69c2009-01-02 13:40:53 +0000359 *
360 * Note that Linux currently ignores TABDLY, CRDLY, VTDLY, FFDLY
361 * and NLDLY. They simply aren't relevant in the world today.
362 * If you ever need them, add them here.
363 *
364 * Returns the number of bytes of buffer space used or -1 if
365 * no space left.
366 *
367 * Locking: should be called under the output_lock to protect
368 * the column state and space left in the buffer
369 */
370
371static int do_output_char(unsigned char c, struct tty_struct *tty, int space)
372{
Jiri Slaby53c5ee22012-10-18 22:26:39 +0200373 struct n_tty_data *ldata = tty->disc_data;
Joe Petersona88a69c2009-01-02 13:40:53 +0000374 int spaces;
375
376 if (!space)
377 return -1;
Alan Cox300a6202009-01-02 13:41:04 +0000378
Joe Petersona88a69c2009-01-02 13:40:53 +0000379 switch (c) {
380 case '\n':
381 if (O_ONLRET(tty))
Jiri Slaby53c5ee22012-10-18 22:26:39 +0200382 ldata->column = 0;
Joe Petersona88a69c2009-01-02 13:40:53 +0000383 if (O_ONLCR(tty)) {
384 if (space < 2)
385 return -1;
Jiri Slabyba2e68a2012-10-18 22:26:41 +0200386 ldata->canon_column = ldata->column = 0;
Linus Torvalds37f81fa2009-09-05 12:46:07 -0700387 tty->ops->write(tty, "\r\n", 2);
Joe Petersona88a69c2009-01-02 13:40:53 +0000388 return 2;
389 }
Jiri Slabyba2e68a2012-10-18 22:26:41 +0200390 ldata->canon_column = ldata->column;
Joe Petersona88a69c2009-01-02 13:40:53 +0000391 break;
392 case '\r':
Jiri Slaby53c5ee22012-10-18 22:26:39 +0200393 if (O_ONOCR(tty) && ldata->column == 0)
Joe Petersona88a69c2009-01-02 13:40:53 +0000394 return 0;
395 if (O_OCRNL(tty)) {
396 c = '\n';
397 if (O_ONLRET(tty))
Jiri Slabyba2e68a2012-10-18 22:26:41 +0200398 ldata->canon_column = ldata->column = 0;
Joe Petersona88a69c2009-01-02 13:40:53 +0000399 break;
400 }
Jiri Slabyba2e68a2012-10-18 22:26:41 +0200401 ldata->canon_column = ldata->column = 0;
Joe Petersona88a69c2009-01-02 13:40:53 +0000402 break;
403 case '\t':
Jiri Slaby53c5ee22012-10-18 22:26:39 +0200404 spaces = 8 - (ldata->column & 7);
Joe Petersona88a69c2009-01-02 13:40:53 +0000405 if (O_TABDLY(tty) == XTABS) {
406 if (space < spaces)
407 return -1;
Jiri Slaby53c5ee22012-10-18 22:26:39 +0200408 ldata->column += spaces;
Joe Petersona88a69c2009-01-02 13:40:53 +0000409 tty->ops->write(tty, " ", spaces);
410 return spaces;
411 }
Jiri Slaby53c5ee22012-10-18 22:26:39 +0200412 ldata->column += spaces;
Joe Petersona88a69c2009-01-02 13:40:53 +0000413 break;
414 case '\b':
Jiri Slaby53c5ee22012-10-18 22:26:39 +0200415 if (ldata->column > 0)
416 ldata->column--;
Joe Petersona88a69c2009-01-02 13:40:53 +0000417 break;
418 default:
Joe Petersona59c0d62009-01-02 13:43:25 +0000419 if (!iscntrl(c)) {
420 if (O_OLCUC(tty))
421 c = toupper(c);
422 if (!is_continuation(c, tty))
Jiri Slaby53c5ee22012-10-18 22:26:39 +0200423 ldata->column++;
Joe Petersona59c0d62009-01-02 13:43:25 +0000424 }
Joe Petersona88a69c2009-01-02 13:40:53 +0000425 break;
426 }
427
428 tty_put_char(tty, c);
429 return 1;
430}
431
432/**
433 * process_output - output post processor
Linus Torvalds1da177e2005-04-16 15:20:36 -0700434 * @c: character (or partial unicode symbol)
435 * @tty: terminal device
436 *
Joe Petersonee5aa7b2009-09-09 15:03:13 -0600437 * Output one character with OPOST processing.
438 * Returns -1 when the output device is full and the character
439 * must be retried.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700440 *
Joe Petersona88a69c2009-01-02 13:40:53 +0000441 * Locking: output_lock to protect column state and space left
442 * (also, this is called from n_tty_write under the
443 * tty layer write lock)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700444 */
Alan Cox4edf1822008-02-08 04:18:44 -0800445
Joe Petersona88a69c2009-01-02 13:40:53 +0000446static int process_output(unsigned char c, struct tty_struct *tty)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700447{
Jiri Slabybddc7152012-10-18 22:26:42 +0200448 struct n_tty_data *ldata = tty->disc_data;
Joe Petersona88a69c2009-01-02 13:40:53 +0000449 int space, retval;
450
Jiri Slabybddc7152012-10-18 22:26:42 +0200451 mutex_lock(&ldata->output_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700452
Alan Coxf34d7a52008-04-30 00:54:13 -0700453 space = tty_write_room(tty);
Joe Petersona88a69c2009-01-02 13:40:53 +0000454 retval = do_output_char(c, tty, space);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700455
Jiri Slabybddc7152012-10-18 22:26:42 +0200456 mutex_unlock(&ldata->output_lock);
Joe Petersona88a69c2009-01-02 13:40:53 +0000457 if (retval < 0)
458 return -1;
459 else
460 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700461}
462
463/**
Joe Petersona88a69c2009-01-02 13:40:53 +0000464 * process_output_block - block post processor
Linus Torvalds1da177e2005-04-16 15:20:36 -0700465 * @tty: terminal device
Joe Petersonee5aa7b2009-09-09 15:03:13 -0600466 * @buf: character buffer
467 * @nr: number of bytes to output
468 *
469 * Output a block of characters with OPOST processing.
470 * Returns the number of characters output.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700471 *
472 * This path is used to speed up block console writes, among other
473 * things when processing blocks of output data. It handles only
474 * the simple cases normally found and helps to generate blocks of
475 * symbols for the console driver and thus improve performance.
476 *
Joe Petersona88a69c2009-01-02 13:40:53 +0000477 * Locking: output_lock to protect column state and space left
478 * (also, this is called from n_tty_write under the
479 * tty layer write lock)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700480 */
Alan Cox4edf1822008-02-08 04:18:44 -0800481
Joe Petersona88a69c2009-01-02 13:40:53 +0000482static ssize_t process_output_block(struct tty_struct *tty,
483 const unsigned char *buf, unsigned int nr)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700484{
Jiri Slaby53c5ee22012-10-18 22:26:39 +0200485 struct n_tty_data *ldata = tty->disc_data;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700486 int space;
Thorsten Wißmannbbd20752011-12-08 17:47:33 +0100487 int i;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700488 const unsigned char *cp;
489
Jiri Slabybddc7152012-10-18 22:26:42 +0200490 mutex_lock(&ldata->output_lock);
Joe Petersona88a69c2009-01-02 13:40:53 +0000491
Alan Coxf34d7a52008-04-30 00:54:13 -0700492 space = tty_write_room(tty);
Alan Cox300a6202009-01-02 13:41:04 +0000493 if (!space) {
Jiri Slabybddc7152012-10-18 22:26:42 +0200494 mutex_unlock(&ldata->output_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700495 return 0;
Joe Petersona88a69c2009-01-02 13:40:53 +0000496 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700497 if (nr > space)
498 nr = space;
499
500 for (i = 0, cp = buf; i < nr; i++, cp++) {
Joe Petersona59c0d62009-01-02 13:43:25 +0000501 unsigned char c = *cp;
502
503 switch (c) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700504 case '\n':
505 if (O_ONLRET(tty))
Jiri Slaby53c5ee22012-10-18 22:26:39 +0200506 ldata->column = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700507 if (O_ONLCR(tty))
508 goto break_out;
Jiri Slabyba2e68a2012-10-18 22:26:41 +0200509 ldata->canon_column = ldata->column;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700510 break;
511 case '\r':
Jiri Slaby53c5ee22012-10-18 22:26:39 +0200512 if (O_ONOCR(tty) && ldata->column == 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700513 goto break_out;
514 if (O_OCRNL(tty))
515 goto break_out;
Jiri Slabyba2e68a2012-10-18 22:26:41 +0200516 ldata->canon_column = ldata->column = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700517 break;
518 case '\t':
519 goto break_out;
520 case '\b':
Jiri Slaby53c5ee22012-10-18 22:26:39 +0200521 if (ldata->column > 0)
522 ldata->column--;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700523 break;
524 default:
Joe Petersona59c0d62009-01-02 13:43:25 +0000525 if (!iscntrl(c)) {
526 if (O_OLCUC(tty))
527 goto break_out;
528 if (!is_continuation(c, tty))
Jiri Slaby53c5ee22012-10-18 22:26:39 +0200529 ldata->column++;
Joe Petersona59c0d62009-01-02 13:43:25 +0000530 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700531 break;
532 }
533 }
534break_out:
Alan Coxf34d7a52008-04-30 00:54:13 -0700535 i = tty->ops->write(tty, buf, i);
Joe Petersona88a69c2009-01-02 13:40:53 +0000536
Jiri Slabybddc7152012-10-18 22:26:42 +0200537 mutex_unlock(&ldata->output_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700538 return i;
539}
540
Joe Petersona88a69c2009-01-02 13:40:53 +0000541/**
542 * process_echoes - write pending echo characters
543 * @tty: terminal device
544 *
545 * Write previously buffered echo (and other ldisc-generated)
546 * characters to the tty.
547 *
548 * Characters generated by the ldisc (including echoes) need to
549 * be buffered because the driver's write buffer can fill during
550 * heavy program output. Echoing straight to the driver will
551 * often fail under these conditions, causing lost characters and
552 * resulting mismatches of ldisc state information.
553 *
554 * Since the ldisc state must represent the characters actually sent
555 * to the driver at the time of the write, operations like certain
556 * changes in column state are also saved in the buffer and executed
557 * here.
558 *
559 * A circular fifo buffer is used so that the most recent characters
560 * are prioritized. Also, when control characters are echoed with a
561 * prefixed "^", the pair is treated atomically and thus not separated.
562 *
563 * Locking: output_lock to protect column state and space left,
564 * echo_lock to protect the echo buffer
565 */
566
567static void process_echoes(struct tty_struct *tty)
568{
Jiri Slaby53c5ee22012-10-18 22:26:39 +0200569 struct n_tty_data *ldata = tty->disc_data;
Joe Petersona88a69c2009-01-02 13:40:53 +0000570 int space, nr;
571 unsigned char c;
572 unsigned char *cp, *buf_end;
573
Jiri Slabyba2e68a2012-10-18 22:26:41 +0200574 if (!ldata->echo_cnt)
Joe Petersona88a69c2009-01-02 13:40:53 +0000575 return;
576
Jiri Slabybddc7152012-10-18 22:26:42 +0200577 mutex_lock(&ldata->output_lock);
578 mutex_lock(&ldata->echo_lock);
Joe Petersona88a69c2009-01-02 13:40:53 +0000579
580 space = tty_write_room(tty);
581
Jiri Slabyba2e68a2012-10-18 22:26:41 +0200582 buf_end = ldata->echo_buf + N_TTY_BUF_SIZE;
583 cp = ldata->echo_buf + ldata->echo_pos;
584 nr = ldata->echo_cnt;
Joe Petersona88a69c2009-01-02 13:40:53 +0000585 while (nr > 0) {
586 c = *cp;
587 if (c == ECHO_OP_START) {
588 unsigned char op;
589 unsigned char *opp;
590 int no_space_left = 0;
591
592 /*
593 * If the buffer byte is the start of a multi-byte
594 * operation, get the next byte, which is either the
595 * op code or a control character value.
596 */
597 opp = cp + 1;
598 if (opp == buf_end)
599 opp -= N_TTY_BUF_SIZE;
600 op = *opp;
Alan Cox300a6202009-01-02 13:41:04 +0000601
Joe Petersona88a69c2009-01-02 13:40:53 +0000602 switch (op) {
603 unsigned int num_chars, num_bs;
604
605 case ECHO_OP_ERASE_TAB:
606 if (++opp == buf_end)
607 opp -= N_TTY_BUF_SIZE;
608 num_chars = *opp;
609
610 /*
611 * Determine how many columns to go back
612 * in order to erase the tab.
613 * This depends on the number of columns
614 * used by other characters within the tab
615 * area. If this (modulo 8) count is from
616 * the start of input rather than from a
617 * previous tab, we offset by canon column.
618 * Otherwise, tab spacing is normal.
619 */
620 if (!(num_chars & 0x80))
Jiri Slabyba2e68a2012-10-18 22:26:41 +0200621 num_chars += ldata->canon_column;
Joe Petersona88a69c2009-01-02 13:40:53 +0000622 num_bs = 8 - (num_chars & 7);
623
624 if (num_bs > space) {
625 no_space_left = 1;
626 break;
627 }
628 space -= num_bs;
629 while (num_bs--) {
630 tty_put_char(tty, '\b');
Jiri Slaby53c5ee22012-10-18 22:26:39 +0200631 if (ldata->column > 0)
632 ldata->column--;
Joe Petersona88a69c2009-01-02 13:40:53 +0000633 }
634 cp += 3;
635 nr -= 3;
636 break;
637
638 case ECHO_OP_SET_CANON_COL:
Jiri Slabyba2e68a2012-10-18 22:26:41 +0200639 ldata->canon_column = ldata->column;
Joe Petersona88a69c2009-01-02 13:40:53 +0000640 cp += 2;
641 nr -= 2;
642 break;
643
644 case ECHO_OP_MOVE_BACK_COL:
Jiri Slaby53c5ee22012-10-18 22:26:39 +0200645 if (ldata->column > 0)
646 ldata->column--;
Joe Petersona88a69c2009-01-02 13:40:53 +0000647 cp += 2;
648 nr -= 2;
649 break;
650
651 case ECHO_OP_START:
652 /* This is an escaped echo op start code */
653 if (!space) {
654 no_space_left = 1;
655 break;
656 }
657 tty_put_char(tty, ECHO_OP_START);
Jiri Slaby53c5ee22012-10-18 22:26:39 +0200658 ldata->column++;
Joe Petersona88a69c2009-01-02 13:40:53 +0000659 space--;
660 cp += 2;
661 nr -= 2;
662 break;
663
664 default:
Joe Petersona88a69c2009-01-02 13:40:53 +0000665 /*
Joe Peterson62b26352009-09-09 15:03:47 -0600666 * If the op is not a special byte code,
667 * it is a ctrl char tagged to be echoed
668 * as "^X" (where X is the letter
669 * representing the control char).
670 * Note that we must ensure there is
671 * enough space for the whole ctrl pair.
672 *
Joe Petersona88a69c2009-01-02 13:40:53 +0000673 */
Joe Peterson62b26352009-09-09 15:03:47 -0600674 if (space < 2) {
675 no_space_left = 1;
676 break;
677 }
678 tty_put_char(tty, '^');
679 tty_put_char(tty, op ^ 0100);
Jiri Slaby53c5ee22012-10-18 22:26:39 +0200680 ldata->column += 2;
Joe Peterson62b26352009-09-09 15:03:47 -0600681 space -= 2;
Joe Petersona88a69c2009-01-02 13:40:53 +0000682 cp += 2;
683 nr -= 2;
684 }
685
686 if (no_space_left)
687 break;
688 } else {
Peter Hurley582f5592013-05-17 12:49:48 -0400689 if (O_OPOST(tty)) {
Joe Petersonee5aa7b2009-09-09 15:03:13 -0600690 int retval = do_output_char(c, tty, space);
691 if (retval < 0)
692 break;
693 space -= retval;
694 } else {
695 if (!space)
696 break;
697 tty_put_char(tty, c);
698 space -= 1;
699 }
Joe Petersona88a69c2009-01-02 13:40:53 +0000700 cp += 1;
701 nr -= 1;
702 }
703
704 /* When end of circular buffer reached, wrap around */
705 if (cp >= buf_end)
706 cp -= N_TTY_BUF_SIZE;
707 }
708
709 if (nr == 0) {
Jiri Slabyba2e68a2012-10-18 22:26:41 +0200710 ldata->echo_pos = 0;
711 ldata->echo_cnt = 0;
Jiri Slaby53c5ee22012-10-18 22:26:39 +0200712 ldata->echo_overrun = 0;
Joe Petersona88a69c2009-01-02 13:40:53 +0000713 } else {
Jiri Slabyba2e68a2012-10-18 22:26:41 +0200714 int num_processed = ldata->echo_cnt - nr;
715 ldata->echo_pos += num_processed;
716 ldata->echo_pos &= N_TTY_BUF_SIZE - 1;
717 ldata->echo_cnt = nr;
Joe Petersona88a69c2009-01-02 13:40:53 +0000718 if (num_processed > 0)
Jiri Slaby53c5ee22012-10-18 22:26:39 +0200719 ldata->echo_overrun = 0;
Joe Petersona88a69c2009-01-02 13:40:53 +0000720 }
721
Jiri Slabybddc7152012-10-18 22:26:42 +0200722 mutex_unlock(&ldata->echo_lock);
723 mutex_unlock(&ldata->output_lock);
Joe Petersona88a69c2009-01-02 13:40:53 +0000724
725 if (tty->ops->flush_chars)
726 tty->ops->flush_chars(tty);
727}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700728
729/**
Joe Petersona88a69c2009-01-02 13:40:53 +0000730 * add_echo_byte - add a byte to the echo buffer
731 * @c: unicode byte to echo
Jiri Slaby57c94122012-10-18 22:26:43 +0200732 * @ldata: n_tty data
Joe Petersona88a69c2009-01-02 13:40:53 +0000733 *
734 * Add a character or operation byte to the echo buffer.
735 *
736 * Should be called under the echo lock to protect the echo buffer.
737 */
738
Jiri Slaby57c94122012-10-18 22:26:43 +0200739static void add_echo_byte(unsigned char c, struct n_tty_data *ldata)
Joe Petersona88a69c2009-01-02 13:40:53 +0000740{
741 int new_byte_pos;
742
Jiri Slabyba2e68a2012-10-18 22:26:41 +0200743 if (ldata->echo_cnt == N_TTY_BUF_SIZE) {
Joe Petersona88a69c2009-01-02 13:40:53 +0000744 /* Circular buffer is already at capacity */
Jiri Slabyba2e68a2012-10-18 22:26:41 +0200745 new_byte_pos = ldata->echo_pos;
Joe Petersona88a69c2009-01-02 13:40:53 +0000746
747 /*
748 * Since the buffer start position needs to be advanced,
749 * be sure to step by a whole operation byte group.
750 */
Jiri Slabyba2e68a2012-10-18 22:26:41 +0200751 if (ldata->echo_buf[ldata->echo_pos] == ECHO_OP_START) {
752 if (ldata->echo_buf[(ldata->echo_pos + 1) &
Joe Petersona88a69c2009-01-02 13:40:53 +0000753 (N_TTY_BUF_SIZE - 1)] ==
754 ECHO_OP_ERASE_TAB) {
Jiri Slabyba2e68a2012-10-18 22:26:41 +0200755 ldata->echo_pos += 3;
756 ldata->echo_cnt -= 2;
Joe Petersona88a69c2009-01-02 13:40:53 +0000757 } else {
Jiri Slabyba2e68a2012-10-18 22:26:41 +0200758 ldata->echo_pos += 2;
759 ldata->echo_cnt -= 1;
Joe Petersona88a69c2009-01-02 13:40:53 +0000760 }
761 } else {
Jiri Slabyba2e68a2012-10-18 22:26:41 +0200762 ldata->echo_pos++;
Joe Petersona88a69c2009-01-02 13:40:53 +0000763 }
Jiri Slabyba2e68a2012-10-18 22:26:41 +0200764 ldata->echo_pos &= N_TTY_BUF_SIZE - 1;
Joe Petersona88a69c2009-01-02 13:40:53 +0000765
Jiri Slaby53c5ee22012-10-18 22:26:39 +0200766 ldata->echo_overrun = 1;
Joe Petersona88a69c2009-01-02 13:40:53 +0000767 } else {
Jiri Slabyba2e68a2012-10-18 22:26:41 +0200768 new_byte_pos = ldata->echo_pos + ldata->echo_cnt;
Joe Petersona88a69c2009-01-02 13:40:53 +0000769 new_byte_pos &= N_TTY_BUF_SIZE - 1;
Jiri Slabyba2e68a2012-10-18 22:26:41 +0200770 ldata->echo_cnt++;
Joe Petersona88a69c2009-01-02 13:40:53 +0000771 }
772
Jiri Slabyba2e68a2012-10-18 22:26:41 +0200773 ldata->echo_buf[new_byte_pos] = c;
Joe Petersona88a69c2009-01-02 13:40:53 +0000774}
775
776/**
777 * echo_move_back_col - add operation to move back a column
Jiri Slaby57c94122012-10-18 22:26:43 +0200778 * @ldata: n_tty data
Joe Petersona88a69c2009-01-02 13:40:53 +0000779 *
780 * Add an operation to the echo buffer to move back one column.
781 *
782 * Locking: echo_lock to protect the echo buffer
783 */
784
Jiri Slaby57c94122012-10-18 22:26:43 +0200785static void echo_move_back_col(struct n_tty_data *ldata)
Joe Petersona88a69c2009-01-02 13:40:53 +0000786{
Jiri Slabybddc7152012-10-18 22:26:42 +0200787 mutex_lock(&ldata->echo_lock);
Jiri Slaby57c94122012-10-18 22:26:43 +0200788 add_echo_byte(ECHO_OP_START, ldata);
789 add_echo_byte(ECHO_OP_MOVE_BACK_COL, ldata);
Jiri Slabybddc7152012-10-18 22:26:42 +0200790 mutex_unlock(&ldata->echo_lock);
Joe Petersona88a69c2009-01-02 13:40:53 +0000791}
792
793/**
794 * echo_set_canon_col - add operation to set the canon column
Jiri Slaby57c94122012-10-18 22:26:43 +0200795 * @ldata: n_tty data
Joe Petersona88a69c2009-01-02 13:40:53 +0000796 *
797 * Add an operation to the echo buffer to set the canon column
798 * to the current column.
799 *
800 * Locking: echo_lock to protect the echo buffer
801 */
802
Jiri Slaby57c94122012-10-18 22:26:43 +0200803static void echo_set_canon_col(struct n_tty_data *ldata)
Joe Petersona88a69c2009-01-02 13:40:53 +0000804{
Jiri Slabybddc7152012-10-18 22:26:42 +0200805 mutex_lock(&ldata->echo_lock);
Jiri Slaby57c94122012-10-18 22:26:43 +0200806 add_echo_byte(ECHO_OP_START, ldata);
807 add_echo_byte(ECHO_OP_SET_CANON_COL, ldata);
Jiri Slabybddc7152012-10-18 22:26:42 +0200808 mutex_unlock(&ldata->echo_lock);
Joe Petersona88a69c2009-01-02 13:40:53 +0000809}
810
811/**
812 * echo_erase_tab - add operation to erase a tab
813 * @num_chars: number of character columns already used
814 * @after_tab: true if num_chars starts after a previous tab
Jiri Slaby57c94122012-10-18 22:26:43 +0200815 * @ldata: n_tty data
Joe Petersona88a69c2009-01-02 13:40:53 +0000816 *
817 * Add an operation to the echo buffer to erase a tab.
818 *
819 * Called by the eraser function, which knows how many character
820 * columns have been used since either a previous tab or the start
821 * of input. This information will be used later, along with
822 * canon column (if applicable), to go back the correct number
823 * of columns.
824 *
825 * Locking: echo_lock to protect the echo buffer
826 */
827
828static void echo_erase_tab(unsigned int num_chars, int after_tab,
Jiri Slaby57c94122012-10-18 22:26:43 +0200829 struct n_tty_data *ldata)
Joe Petersona88a69c2009-01-02 13:40:53 +0000830{
Jiri Slabybddc7152012-10-18 22:26:42 +0200831 mutex_lock(&ldata->echo_lock);
Joe Petersona88a69c2009-01-02 13:40:53 +0000832
Jiri Slaby57c94122012-10-18 22:26:43 +0200833 add_echo_byte(ECHO_OP_START, ldata);
834 add_echo_byte(ECHO_OP_ERASE_TAB, ldata);
Joe Petersona88a69c2009-01-02 13:40:53 +0000835
836 /* We only need to know this modulo 8 (tab spacing) */
837 num_chars &= 7;
838
839 /* Set the high bit as a flag if num_chars is after a previous tab */
840 if (after_tab)
841 num_chars |= 0x80;
Alan Cox300a6202009-01-02 13:41:04 +0000842
Jiri Slaby57c94122012-10-18 22:26:43 +0200843 add_echo_byte(num_chars, ldata);
Joe Petersona88a69c2009-01-02 13:40:53 +0000844
Jiri Slabybddc7152012-10-18 22:26:42 +0200845 mutex_unlock(&ldata->echo_lock);
Joe Petersona88a69c2009-01-02 13:40:53 +0000846}
847
848/**
849 * echo_char_raw - echo a character raw
Linus Torvalds1da177e2005-04-16 15:20:36 -0700850 * @c: unicode byte to echo
851 * @tty: terminal device
852 *
Alan Cox4edf1822008-02-08 04:18:44 -0800853 * Echo user input back onto the screen. This must be called only when
Linus Torvalds1da177e2005-04-16 15:20:36 -0700854 * L_ECHO(tty) is true. Called from the driver receive_buf path.
Alan Cox17b82062008-10-13 10:45:06 +0100855 *
Joe Petersona88a69c2009-01-02 13:40:53 +0000856 * This variant does not treat control characters specially.
857 *
858 * Locking: echo_lock to protect the echo buffer
859 */
860
Jiri Slaby57c94122012-10-18 22:26:43 +0200861static void echo_char_raw(unsigned char c, struct n_tty_data *ldata)
Joe Petersona88a69c2009-01-02 13:40:53 +0000862{
Jiri Slabybddc7152012-10-18 22:26:42 +0200863 mutex_lock(&ldata->echo_lock);
Joe Petersona88a69c2009-01-02 13:40:53 +0000864 if (c == ECHO_OP_START) {
Jiri Slaby57c94122012-10-18 22:26:43 +0200865 add_echo_byte(ECHO_OP_START, ldata);
866 add_echo_byte(ECHO_OP_START, ldata);
Joe Petersona88a69c2009-01-02 13:40:53 +0000867 } else {
Jiri Slaby57c94122012-10-18 22:26:43 +0200868 add_echo_byte(c, ldata);
Joe Petersona88a69c2009-01-02 13:40:53 +0000869 }
Jiri Slabybddc7152012-10-18 22:26:42 +0200870 mutex_unlock(&ldata->echo_lock);
Joe Petersona88a69c2009-01-02 13:40:53 +0000871}
872
873/**
874 * echo_char - echo a character
875 * @c: unicode byte to echo
876 * @tty: terminal device
877 *
878 * Echo user input back onto the screen. This must be called only when
879 * L_ECHO(tty) is true. Called from the driver receive_buf path.
880 *
Joe Peterson62b26352009-09-09 15:03:47 -0600881 * This variant tags control characters to be echoed as "^X"
882 * (where X is the letter representing the control char).
Joe Petersona88a69c2009-01-02 13:40:53 +0000883 *
884 * Locking: echo_lock to protect the echo buffer
Linus Torvalds1da177e2005-04-16 15:20:36 -0700885 */
886
887static void echo_char(unsigned char c, struct tty_struct *tty)
888{
Jiri Slabybddc7152012-10-18 22:26:42 +0200889 struct n_tty_data *ldata = tty->disc_data;
890
891 mutex_lock(&ldata->echo_lock);
Joe Petersona88a69c2009-01-02 13:40:53 +0000892
893 if (c == ECHO_OP_START) {
Jiri Slaby57c94122012-10-18 22:26:43 +0200894 add_echo_byte(ECHO_OP_START, ldata);
895 add_echo_byte(ECHO_OP_START, ldata);
Joe Petersona88a69c2009-01-02 13:40:53 +0000896 } else {
Joe Peterson62b26352009-09-09 15:03:47 -0600897 if (L_ECHOCTL(tty) && iscntrl(c) && c != '\t')
Jiri Slaby57c94122012-10-18 22:26:43 +0200898 add_echo_byte(ECHO_OP_START, ldata);
899 add_echo_byte(c, ldata);
Joe Petersona88a69c2009-01-02 13:40:53 +0000900 }
901
Jiri Slabybddc7152012-10-18 22:26:42 +0200902 mutex_unlock(&ldata->echo_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700903}
904
Alan Cox17b82062008-10-13 10:45:06 +0100905/**
Joe Petersona88a69c2009-01-02 13:40:53 +0000906 * finish_erasing - complete erase
Jiri Slaby57c94122012-10-18 22:26:43 +0200907 * @ldata: n_tty data
Alan Cox17b82062008-10-13 10:45:06 +0100908 */
Joe Petersona88a69c2009-01-02 13:40:53 +0000909
Jiri Slaby57c94122012-10-18 22:26:43 +0200910static inline void finish_erasing(struct n_tty_data *ldata)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700911{
Jiri Slaby53c5ee22012-10-18 22:26:39 +0200912 if (ldata->erasing) {
Jiri Slaby57c94122012-10-18 22:26:43 +0200913 echo_char_raw('/', ldata);
Jiri Slaby53c5ee22012-10-18 22:26:39 +0200914 ldata->erasing = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700915 }
916}
917
918/**
919 * eraser - handle erase function
920 * @c: character input
921 * @tty: terminal device
922 *
Robert P. J. Day3a4fa0a2007-10-19 23:10:43 +0200923 * Perform erase and necessary output when an erase character is
Linus Torvalds1da177e2005-04-16 15:20:36 -0700924 * present in the stream from the driver layer. Handles the complexities
925 * of UTF-8 multibyte symbols.
Alan Cox17b82062008-10-13 10:45:06 +0100926 *
Peter Hurley6d76bd22013-06-15 09:14:26 -0400927 * n_tty_receive_buf()/producer path:
928 * caller holds non-exclusive termios_rwsem
929 * modifies read_head
930 *
931 * Modifying the read_head is not considered a publish in this context
932 * because canonical mode is active -- only canon_head publishes
Linus Torvalds1da177e2005-04-16 15:20:36 -0700933 */
Alan Cox4edf1822008-02-08 04:18:44 -0800934
Linus Torvalds1da177e2005-04-16 15:20:36 -0700935static void eraser(unsigned char c, struct tty_struct *tty)
936{
Jiri Slaby53c5ee22012-10-18 22:26:39 +0200937 struct n_tty_data *ldata = tty->disc_data;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700938 enum { ERASE, WERASE, KILL } kill_type;
Peter Hurleybc5a5e32013-06-15 09:14:21 -0400939 size_t head;
940 size_t cnt;
941 int seen_alnums;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700942
Jiri Slabyba2e68a2012-10-18 22:26:41 +0200943 if (ldata->read_head == ldata->canon_head) {
Joe Peterson7e94b1d2009-01-02 13:43:40 +0000944 /* process_output('\a', tty); */ /* what do you think? */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700945 return;
946 }
947 if (c == ERASE_CHAR(tty))
948 kill_type = ERASE;
949 else if (c == WERASE_CHAR(tty))
950 kill_type = WERASE;
951 else {
952 if (!L_ECHO(tty)) {
Jiri Slabyba2e68a2012-10-18 22:26:41 +0200953 ldata->read_head = ldata->canon_head;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700954 return;
955 }
956 if (!L_ECHOK(tty) || !L_ECHOKE(tty) || !L_ECHOE(tty)) {
Jiri Slabyba2e68a2012-10-18 22:26:41 +0200957 ldata->read_head = ldata->canon_head;
Jiri Slaby57c94122012-10-18 22:26:43 +0200958 finish_erasing(ldata);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700959 echo_char(KILL_CHAR(tty), tty);
960 /* Add a newline if ECHOK is on and ECHOKE is off. */
961 if (L_ECHOK(tty))
Jiri Slaby57c94122012-10-18 22:26:43 +0200962 echo_char_raw('\n', ldata);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700963 return;
964 }
965 kill_type = KILL;
966 }
967
968 seen_alnums = 0;
Jiri Slabyba2e68a2012-10-18 22:26:41 +0200969 while (ldata->read_head != ldata->canon_head) {
970 head = ldata->read_head;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700971
972 /* erase a single possibly multibyte character */
973 do {
Peter Hurleybc5a5e32013-06-15 09:14:21 -0400974 head--;
975 c = read_buf(ldata, head);
Jiri Slabyba2e68a2012-10-18 22:26:41 +0200976 } while (is_continuation(c, tty) && head != ldata->canon_head);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700977
978 /* do not partially erase */
979 if (is_continuation(c, tty))
980 break;
981
982 if (kill_type == WERASE) {
983 /* Equivalent to BSD's ALTWERASE. */
984 if (isalnum(c) || c == '_')
985 seen_alnums++;
986 else if (seen_alnums)
987 break;
988 }
Peter Hurleybc5a5e32013-06-15 09:14:21 -0400989 cnt = ldata->read_head - head;
Jiri Slabyba2e68a2012-10-18 22:26:41 +0200990 ldata->read_head = head;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700991 if (L_ECHO(tty)) {
992 if (L_ECHOPRT(tty)) {
Jiri Slaby53c5ee22012-10-18 22:26:39 +0200993 if (!ldata->erasing) {
Jiri Slaby57c94122012-10-18 22:26:43 +0200994 echo_char_raw('\\', ldata);
Jiri Slaby53c5ee22012-10-18 22:26:39 +0200995 ldata->erasing = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700996 }
997 /* if cnt > 1, output a multi-byte character */
998 echo_char(c, tty);
999 while (--cnt > 0) {
Peter Hurleybc5a5e32013-06-15 09:14:21 -04001000 head++;
1001 echo_char_raw(read_buf(ldata, head), ldata);
Jiri Slaby57c94122012-10-18 22:26:43 +02001002 echo_move_back_col(ldata);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001003 }
1004 } else if (kill_type == ERASE && !L_ECHOE(tty)) {
1005 echo_char(ERASE_CHAR(tty), tty);
1006 } else if (c == '\t') {
Joe Petersona88a69c2009-01-02 13:40:53 +00001007 unsigned int num_chars = 0;
1008 int after_tab = 0;
Peter Hurleybc5a5e32013-06-15 09:14:21 -04001009 size_t tail = ldata->read_head;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001010
Joe Petersona88a69c2009-01-02 13:40:53 +00001011 /*
1012 * Count the columns used for characters
1013 * since the start of input or after a
1014 * previous tab.
1015 * This info is used to go back the correct
1016 * number of columns.
1017 */
Jiri Slabyba2e68a2012-10-18 22:26:41 +02001018 while (tail != ldata->canon_head) {
Peter Hurleybc5a5e32013-06-15 09:14:21 -04001019 tail--;
1020 c = read_buf(ldata, tail);
Joe Petersona88a69c2009-01-02 13:40:53 +00001021 if (c == '\t') {
1022 after_tab = 1;
1023 break;
Alan Cox300a6202009-01-02 13:41:04 +00001024 } else if (iscntrl(c)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001025 if (L_ECHOCTL(tty))
Joe Petersona88a69c2009-01-02 13:40:53 +00001026 num_chars += 2;
1027 } else if (!is_continuation(c, tty)) {
1028 num_chars++;
1029 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001030 }
Jiri Slaby57c94122012-10-18 22:26:43 +02001031 echo_erase_tab(num_chars, after_tab, ldata);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001032 } else {
1033 if (iscntrl(c) && L_ECHOCTL(tty)) {
Jiri Slaby57c94122012-10-18 22:26:43 +02001034 echo_char_raw('\b', ldata);
1035 echo_char_raw(' ', ldata);
1036 echo_char_raw('\b', ldata);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001037 }
1038 if (!iscntrl(c) || L_ECHOCTL(tty)) {
Jiri Slaby57c94122012-10-18 22:26:43 +02001039 echo_char_raw('\b', ldata);
1040 echo_char_raw(' ', ldata);
1041 echo_char_raw('\b', ldata);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001042 }
1043 }
1044 }
1045 if (kill_type == ERASE)
1046 break;
1047 }
Jiri Slabyba2e68a2012-10-18 22:26:41 +02001048 if (ldata->read_head == ldata->canon_head && L_ECHO(tty))
Jiri Slaby57c94122012-10-18 22:26:43 +02001049 finish_erasing(ldata);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001050}
1051
1052/**
1053 * isig - handle the ISIG optio
1054 * @sig: signal
1055 * @tty: terminal
Linus Torvalds1da177e2005-04-16 15:20:36 -07001056 *
Peter Hurley8c985d12013-03-06 08:38:19 -05001057 * Called when a signal is being sent due to terminal input.
1058 * Called from the driver receive_buf path so serialized.
Alan Cox17b82062008-10-13 10:45:06 +01001059 *
Peter Hurley8c985d12013-03-06 08:38:19 -05001060 * Locking: ctrl_lock
Linus Torvalds1da177e2005-04-16 15:20:36 -07001061 */
Alan Cox4edf1822008-02-08 04:18:44 -08001062
Peter Hurley8c985d12013-03-06 08:38:19 -05001063static inline void isig(int sig, struct tty_struct *tty)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001064{
Peter Hurley8c985d12013-03-06 08:38:19 -05001065 struct pid *tty_pgrp = tty_get_pgrp(tty);
1066 if (tty_pgrp) {
1067 kill_pgrp(tty_pgrp, sig, 1);
1068 put_pid(tty_pgrp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001069 }
1070}
1071
1072/**
1073 * n_tty_receive_break - handle break
1074 * @tty: terminal
1075 *
1076 * An RS232 break event has been hit in the incoming bitstream. This
1077 * can cause a variety of events depending upon the termios settings.
1078 *
Peter Hurley6d76bd22013-06-15 09:14:26 -04001079 * n_tty_receive_buf()/producer path:
1080 * caller holds non-exclusive termios_rwsem
1081 * publishes read_head via put_tty_queue()
1082 *
1083 * Note: may get exclusive termios_rwsem if flushing input buffer
Linus Torvalds1da177e2005-04-16 15:20:36 -07001084 */
Alan Cox4edf1822008-02-08 04:18:44 -08001085
Linus Torvalds1da177e2005-04-16 15:20:36 -07001086static inline void n_tty_receive_break(struct tty_struct *tty)
1087{
Jiri Slaby57c94122012-10-18 22:26:43 +02001088 struct n_tty_data *ldata = tty->disc_data;
1089
Linus Torvalds1da177e2005-04-16 15:20:36 -07001090 if (I_IGNBRK(tty))
1091 return;
1092 if (I_BRKINT(tty)) {
Peter Hurley8c985d12013-03-06 08:38:19 -05001093 isig(SIGINT, tty);
1094 if (!L_NOFLSH(tty)) {
Peter Hurley6d76bd22013-06-15 09:14:26 -04001095 /* flushing needs exclusive termios_rwsem */
1096 up_read(&tty->termios_rwsem);
Peter Hurley8c985d12013-03-06 08:38:19 -05001097 n_tty_flush_buffer(tty);
1098 tty_driver_flush_buffer(tty);
Peter Hurley6d76bd22013-06-15 09:14:26 -04001099 down_read(&tty->termios_rwsem);
Peter Hurley8c985d12013-03-06 08:38:19 -05001100 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001101 return;
1102 }
1103 if (I_PARMRK(tty)) {
Jiri Slaby57c94122012-10-18 22:26:43 +02001104 put_tty_queue('\377', ldata);
1105 put_tty_queue('\0', ldata);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001106 }
Jiri Slaby57c94122012-10-18 22:26:43 +02001107 put_tty_queue('\0', ldata);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001108 wake_up_interruptible(&tty->read_wait);
1109}
1110
1111/**
1112 * n_tty_receive_overrun - handle overrun reporting
1113 * @tty: terminal
1114 *
1115 * Data arrived faster than we could process it. While the tty
1116 * driver has flagged this the bits that were missed are gone
1117 * forever.
1118 *
1119 * Called from the receive_buf path so single threaded. Does not
1120 * need locking as num_overrun and overrun_time are function
1121 * private.
1122 */
Alan Cox4edf1822008-02-08 04:18:44 -08001123
Linus Torvalds1da177e2005-04-16 15:20:36 -07001124static inline void n_tty_receive_overrun(struct tty_struct *tty)
1125{
Jiri Slaby53c5ee22012-10-18 22:26:39 +02001126 struct n_tty_data *ldata = tty->disc_data;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001127 char buf[64];
1128
Jiri Slaby53c5ee22012-10-18 22:26:39 +02001129 ldata->num_overrun++;
1130 if (time_after(jiffies, ldata->overrun_time + HZ) ||
1131 time_after(ldata->overrun_time, jiffies)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001132 printk(KERN_WARNING "%s: %d input overrun(s)\n",
1133 tty_name(tty, buf),
Jiri Slaby53c5ee22012-10-18 22:26:39 +02001134 ldata->num_overrun);
1135 ldata->overrun_time = jiffies;
1136 ldata->num_overrun = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001137 }
1138}
1139
1140/**
1141 * n_tty_receive_parity_error - error notifier
1142 * @tty: terminal device
1143 * @c: character
1144 *
1145 * Process a parity error and queue the right data to indicate
Peter Hurley6d76bd22013-06-15 09:14:26 -04001146 * the error case if necessary.
1147 *
1148 * n_tty_receive_buf()/producer path:
1149 * caller holds non-exclusive termios_rwsem
1150 * publishes read_head via put_tty_queue()
Linus Torvalds1da177e2005-04-16 15:20:36 -07001151 */
1152static inline void n_tty_receive_parity_error(struct tty_struct *tty,
1153 unsigned char c)
1154{
Jiri Slaby57c94122012-10-18 22:26:43 +02001155 struct n_tty_data *ldata = tty->disc_data;
1156
Alan Cox4edf1822008-02-08 04:18:44 -08001157 if (I_IGNPAR(tty))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001158 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001159 if (I_PARMRK(tty)) {
Jiri Slaby57c94122012-10-18 22:26:43 +02001160 put_tty_queue('\377', ldata);
1161 put_tty_queue('\0', ldata);
1162 put_tty_queue(c, ldata);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001163 } else if (I_INPCK(tty))
Jiri Slaby57c94122012-10-18 22:26:43 +02001164 put_tty_queue('\0', ldata);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001165 else
Jiri Slaby57c94122012-10-18 22:26:43 +02001166 put_tty_queue(c, ldata);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001167 wake_up_interruptible(&tty->read_wait);
1168}
1169
1170/**
1171 * n_tty_receive_char - perform processing
1172 * @tty: terminal device
1173 * @c: character
1174 *
1175 * Process an individual character of input received from the driver.
Alan Cox4edf1822008-02-08 04:18:44 -08001176 * This is serialized with respect to itself by the rules for the
Linus Torvalds1da177e2005-04-16 15:20:36 -07001177 * driver above.
Peter Hurley6d76bd22013-06-15 09:14:26 -04001178 *
1179 * n_tty_receive_buf()/producer path:
1180 * caller holds non-exclusive termios_rwsem
1181 * publishes canon_head if canonical mode is active
1182 * otherwise, publishes read_head via put_tty_queue()
Linus Torvalds1da177e2005-04-16 15:20:36 -07001183 */
1184
1185static inline void n_tty_receive_char(struct tty_struct *tty, unsigned char c)
1186{
Jiri Slaby53c5ee22012-10-18 22:26:39 +02001187 struct n_tty_data *ldata = tty->disc_data;
Joe Petersonacc71bb2009-01-02 13:43:32 +00001188 int parmrk;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001189
Jiri Slaby53c5ee22012-10-18 22:26:39 +02001190 if (ldata->raw) {
Jiri Slaby57c94122012-10-18 22:26:43 +02001191 put_tty_queue(c, ldata);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001192 return;
1193 }
Alan Cox4edf1822008-02-08 04:18:44 -08001194
Linus Torvalds1da177e2005-04-16 15:20:36 -07001195 if (I_ISTRIP(tty))
1196 c &= 0x7f;
1197 if (I_IUCLC(tty) && L_IEXTEN(tty))
Alan Cox300a6202009-01-02 13:41:04 +00001198 c = tolower(c);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001199
hyc@symas.com26df6d12010-06-22 10:14:49 -07001200 if (L_EXTPROC(tty)) {
Jiri Slaby57c94122012-10-18 22:26:43 +02001201 put_tty_queue(c, ldata);
hyc@symas.com26df6d12010-06-22 10:14:49 -07001202 return;
1203 }
1204
Joe Peterson54d2a372008-02-06 01:37:59 -08001205 if (tty->stopped && !tty->flow_stopped && I_IXON(tty) &&
Joe Petersona88a69c2009-01-02 13:40:53 +00001206 I_IXANY(tty) && c != START_CHAR(tty) && c != STOP_CHAR(tty) &&
1207 c != INTR_CHAR(tty) && c != QUIT_CHAR(tty) && c != SUSP_CHAR(tty)) {
Joe Peterson54d2a372008-02-06 01:37:59 -08001208 start_tty(tty);
Joe Petersona88a69c2009-01-02 13:40:53 +00001209 process_echoes(tty);
1210 }
Joe Peterson54d2a372008-02-06 01:37:59 -08001211
Linus Torvalds1da177e2005-04-16 15:20:36 -07001212 if (tty->closing) {
1213 if (I_IXON(tty)) {
Joe Petersona88a69c2009-01-02 13:40:53 +00001214 if (c == START_CHAR(tty)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001215 start_tty(tty);
Joe Petersona88a69c2009-01-02 13:40:53 +00001216 process_echoes(tty);
Alan Cox300a6202009-01-02 13:41:04 +00001217 } else if (c == STOP_CHAR(tty))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001218 stop_tty(tty);
1219 }
1220 return;
1221 }
1222
1223 /*
1224 * If the previous character was LNEXT, or we know that this
1225 * character is not one of the characters that we'll have to
1226 * handle specially, do shortcut processing to speed things
1227 * up.
1228 */
Jiri Slaby3fe780b2012-10-18 22:26:40 +02001229 if (!test_bit(c, ldata->process_char_map) || ldata->lnext) {
Jiri Slaby53c5ee22012-10-18 22:26:39 +02001230 ldata->lnext = 0;
Joe Petersonacc71bb2009-01-02 13:43:32 +00001231 parmrk = (c == (unsigned char) '\377' && I_PARMRK(tty)) ? 1 : 0;
Peter Hurleyce741172013-06-15 09:14:20 -04001232 if (read_cnt(ldata) >= (N_TTY_BUF_SIZE - parmrk - 1)) {
Joe Petersonacc71bb2009-01-02 13:43:32 +00001233 /* beep if no space */
Joe Peterson7e94b1d2009-01-02 13:43:40 +00001234 if (L_ECHO(tty))
1235 process_output('\a', tty);
Joe Petersonacc71bb2009-01-02 13:43:32 +00001236 return;
1237 }
1238 if (L_ECHO(tty)) {
Jiri Slaby57c94122012-10-18 22:26:43 +02001239 finish_erasing(ldata);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001240 /* Record the column of first canon char. */
Jiri Slabyba2e68a2012-10-18 22:26:41 +02001241 if (ldata->canon_head == ldata->read_head)
Jiri Slaby57c94122012-10-18 22:26:43 +02001242 echo_set_canon_col(ldata);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001243 echo_char(c, tty);
Joe Petersona88a69c2009-01-02 13:40:53 +00001244 process_echoes(tty);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001245 }
Joe Petersonacc71bb2009-01-02 13:43:32 +00001246 if (parmrk)
Jiri Slaby57c94122012-10-18 22:26:43 +02001247 put_tty_queue(c, ldata);
1248 put_tty_queue(c, ldata);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001249 return;
1250 }
Alan Cox4edf1822008-02-08 04:18:44 -08001251
Linus Torvalds1da177e2005-04-16 15:20:36 -07001252 if (I_IXON(tty)) {
1253 if (c == START_CHAR(tty)) {
1254 start_tty(tty);
Joe Petersona88a69c2009-01-02 13:40:53 +00001255 process_echoes(tty);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001256 return;
1257 }
1258 if (c == STOP_CHAR(tty)) {
1259 stop_tty(tty);
1260 return;
1261 }
1262 }
Joe Peterson575537b32008-04-30 00:53:30 -07001263
Linus Torvalds1da177e2005-04-16 15:20:36 -07001264 if (L_ISIG(tty)) {
1265 int signal;
1266 signal = SIGINT;
1267 if (c == INTR_CHAR(tty))
1268 goto send_signal;
1269 signal = SIGQUIT;
1270 if (c == QUIT_CHAR(tty))
1271 goto send_signal;
1272 signal = SIGTSTP;
1273 if (c == SUSP_CHAR(tty)) {
1274send_signal:
Joe Petersonec5b1152008-02-06 01:37:38 -08001275 if (!L_NOFLSH(tty)) {
Peter Hurley6d76bd22013-06-15 09:14:26 -04001276 /* flushing needs exclusive termios_rwsem */
1277 up_read(&tty->termios_rwsem);
Joe Petersonec5b1152008-02-06 01:37:38 -08001278 n_tty_flush_buffer(tty);
Alan Coxf34d7a52008-04-30 00:54:13 -07001279 tty_driver_flush_buffer(tty);
Peter Hurley6d76bd22013-06-15 09:14:26 -04001280 down_read(&tty->termios_rwsem);
Joe Petersonec5b1152008-02-06 01:37:38 -08001281 }
Joe Petersona88a69c2009-01-02 13:40:53 +00001282 if (I_IXON(tty))
1283 start_tty(tty);
1284 if (L_ECHO(tty)) {
Joe Petersonec5b1152008-02-06 01:37:38 -08001285 echo_char(c, tty);
Joe Petersona88a69c2009-01-02 13:40:53 +00001286 process_echoes(tty);
1287 }
Peter Hurley8c985d12013-03-06 08:38:19 -05001288 isig(signal, tty);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001289 return;
1290 }
1291 }
Joe Peterson575537b32008-04-30 00:53:30 -07001292
1293 if (c == '\r') {
1294 if (I_IGNCR(tty))
1295 return;
1296 if (I_ICRNL(tty))
1297 c = '\n';
1298 } else if (c == '\n' && I_INLCR(tty))
1299 c = '\r';
1300
Jiri Slaby53c5ee22012-10-18 22:26:39 +02001301 if (ldata->icanon) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001302 if (c == ERASE_CHAR(tty) || c == KILL_CHAR(tty) ||
1303 (c == WERASE_CHAR(tty) && L_IEXTEN(tty))) {
1304 eraser(c, tty);
Joe Petersona88a69c2009-01-02 13:40:53 +00001305 process_echoes(tty);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001306 return;
1307 }
1308 if (c == LNEXT_CHAR(tty) && L_IEXTEN(tty)) {
Jiri Slaby53c5ee22012-10-18 22:26:39 +02001309 ldata->lnext = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001310 if (L_ECHO(tty)) {
Jiri Slaby57c94122012-10-18 22:26:43 +02001311 finish_erasing(ldata);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001312 if (L_ECHOCTL(tty)) {
Jiri Slaby57c94122012-10-18 22:26:43 +02001313 echo_char_raw('^', ldata);
1314 echo_char_raw('\b', ldata);
Joe Petersona88a69c2009-01-02 13:40:53 +00001315 process_echoes(tty);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001316 }
1317 }
1318 return;
1319 }
1320 if (c == REPRINT_CHAR(tty) && L_ECHO(tty) &&
1321 L_IEXTEN(tty)) {
Peter Hurleybc5a5e32013-06-15 09:14:21 -04001322 size_t tail = ldata->canon_head;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001323
Jiri Slaby57c94122012-10-18 22:26:43 +02001324 finish_erasing(ldata);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001325 echo_char(c, tty);
Jiri Slaby57c94122012-10-18 22:26:43 +02001326 echo_char_raw('\n', ldata);
Jiri Slabyba2e68a2012-10-18 22:26:41 +02001327 while (tail != ldata->read_head) {
Peter Hurleybc5a5e32013-06-15 09:14:21 -04001328 echo_char(read_buf(ldata, tail), tty);
1329 tail++;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001330 }
Joe Petersona88a69c2009-01-02 13:40:53 +00001331 process_echoes(tty);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001332 return;
1333 }
1334 if (c == '\n') {
Peter Hurleyce741172013-06-15 09:14:20 -04001335 if (read_cnt(ldata) >= N_TTY_BUF_SIZE) {
Joe Peterson7e94b1d2009-01-02 13:43:40 +00001336 if (L_ECHO(tty))
1337 process_output('\a', tty);
Joe Petersonacc71bb2009-01-02 13:43:32 +00001338 return;
1339 }
1340 if (L_ECHO(tty) || L_ECHONL(tty)) {
Jiri Slaby57c94122012-10-18 22:26:43 +02001341 echo_char_raw('\n', ldata);
Joe Petersona88a69c2009-01-02 13:40:53 +00001342 process_echoes(tty);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001343 }
1344 goto handle_newline;
1345 }
1346 if (c == EOF_CHAR(tty)) {
Peter Hurleyce741172013-06-15 09:14:20 -04001347 if (read_cnt(ldata) >= N_TTY_BUF_SIZE)
Joe Petersonacc71bb2009-01-02 13:43:32 +00001348 return;
Jiri Slabyba2e68a2012-10-18 22:26:41 +02001349 if (ldata->canon_head != ldata->read_head)
Alan Cox4edf1822008-02-08 04:18:44 -08001350 set_bit(TTY_PUSH, &tty->flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001351 c = __DISABLED_CHAR;
1352 goto handle_newline;
1353 }
1354 if ((c == EOL_CHAR(tty)) ||
1355 (c == EOL2_CHAR(tty) && L_IEXTEN(tty))) {
Joe Petersonacc71bb2009-01-02 13:43:32 +00001356 parmrk = (c == (unsigned char) '\377' && I_PARMRK(tty))
1357 ? 1 : 0;
Peter Hurleyce741172013-06-15 09:14:20 -04001358 if (read_cnt(ldata) >= (N_TTY_BUF_SIZE - parmrk)) {
Joe Peterson7e94b1d2009-01-02 13:43:40 +00001359 if (L_ECHO(tty))
1360 process_output('\a', tty);
Joe Petersonacc71bb2009-01-02 13:43:32 +00001361 return;
1362 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001363 /*
1364 * XXX are EOL_CHAR and EOL2_CHAR echoed?!?
1365 */
1366 if (L_ECHO(tty)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001367 /* Record the column of first canon char. */
Jiri Slabyba2e68a2012-10-18 22:26:41 +02001368 if (ldata->canon_head == ldata->read_head)
Jiri Slaby57c94122012-10-18 22:26:43 +02001369 echo_set_canon_col(ldata);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001370 echo_char(c, tty);
Joe Petersona88a69c2009-01-02 13:40:53 +00001371 process_echoes(tty);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001372 }
1373 /*
1374 * XXX does PARMRK doubling happen for
1375 * EOL_CHAR and EOL2_CHAR?
1376 */
Joe Petersonacc71bb2009-01-02 13:43:32 +00001377 if (parmrk)
Jiri Slaby57c94122012-10-18 22:26:43 +02001378 put_tty_queue(c, ldata);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001379
Alan Cox4edf1822008-02-08 04:18:44 -08001380handle_newline:
Peter Hurleybc5a5e32013-06-15 09:14:21 -04001381 set_bit(ldata->read_head & (N_TTY_BUF_SIZE - 1), ldata->read_flags);
Peter Hurley6d76bd22013-06-15 09:14:26 -04001382 put_tty_queue(c, ldata);
Jiri Slabyba2e68a2012-10-18 22:26:41 +02001383 ldata->canon_head = ldata->read_head;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001384 kill_fasync(&tty->fasync, SIGIO, POLL_IN);
1385 if (waitqueue_active(&tty->read_wait))
1386 wake_up_interruptible(&tty->read_wait);
1387 return;
1388 }
1389 }
Alan Cox4edf1822008-02-08 04:18:44 -08001390
Joe Petersonacc71bb2009-01-02 13:43:32 +00001391 parmrk = (c == (unsigned char) '\377' && I_PARMRK(tty)) ? 1 : 0;
Peter Hurleyce741172013-06-15 09:14:20 -04001392 if (read_cnt(ldata) >= (N_TTY_BUF_SIZE - parmrk - 1)) {
Joe Petersonacc71bb2009-01-02 13:43:32 +00001393 /* beep if no space */
Joe Peterson7e94b1d2009-01-02 13:43:40 +00001394 if (L_ECHO(tty))
1395 process_output('\a', tty);
Joe Petersonacc71bb2009-01-02 13:43:32 +00001396 return;
1397 }
1398 if (L_ECHO(tty)) {
Jiri Slaby57c94122012-10-18 22:26:43 +02001399 finish_erasing(ldata);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001400 if (c == '\n')
Jiri Slaby57c94122012-10-18 22:26:43 +02001401 echo_char_raw('\n', ldata);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001402 else {
1403 /* Record the column of first canon char. */
Jiri Slabyba2e68a2012-10-18 22:26:41 +02001404 if (ldata->canon_head == ldata->read_head)
Jiri Slaby57c94122012-10-18 22:26:43 +02001405 echo_set_canon_col(ldata);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001406 echo_char(c, tty);
1407 }
Joe Petersona88a69c2009-01-02 13:40:53 +00001408 process_echoes(tty);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001409 }
1410
Joe Petersonacc71bb2009-01-02 13:43:32 +00001411 if (parmrk)
Jiri Slaby57c94122012-10-18 22:26:43 +02001412 put_tty_queue(c, ldata);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001413
Jiri Slaby57c94122012-10-18 22:26:43 +02001414 put_tty_queue(c, ldata);
Alan Cox4edf1822008-02-08 04:18:44 -08001415}
Linus Torvalds1da177e2005-04-16 15:20:36 -07001416
Linus Torvalds1da177e2005-04-16 15:20:36 -07001417
1418/**
1419 * n_tty_write_wakeup - asynchronous I/O notifier
1420 * @tty: tty device
1421 *
1422 * Required for the ptys, serial driver etc. since processes
1423 * that attach themselves to the master and rely on ASYNC
1424 * IO must be woken up
1425 */
1426
1427static void n_tty_write_wakeup(struct tty_struct *tty)
1428{
Thomas Pfaffff8cb0f2009-01-02 13:47:13 +00001429 if (tty->fasync && test_and_clear_bit(TTY_DO_WRITE_WAKEUP, &tty->flags))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001430 kill_fasync(&tty->fasync, SIGIO, POLL_OUT);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001431}
1432
1433/**
1434 * n_tty_receive_buf - data receive
1435 * @tty: terminal device
1436 * @cp: buffer
1437 * @fp: flag buffer
1438 * @count: characters
1439 *
1440 * Called by the terminal driver when a block of characters has
1441 * been received. This function must be called from soft contexts
1442 * not from interrupt context. The driver is responsible for making
1443 * calls one at a time and in order (or using flush_to_ldisc)
Peter Hurley6d76bd22013-06-15 09:14:26 -04001444 *
1445 * n_tty_receive_buf()/producer path:
1446 * claims non-exclusive termios_rwsem
1447 * publishes read_head and canon_head
Linus Torvalds1da177e2005-04-16 15:20:36 -07001448 */
Alan Cox4edf1822008-02-08 04:18:44 -08001449
Peter Hurley24a89d12013-06-15 09:14:15 -04001450static void __receive_buf(struct tty_struct *tty, const unsigned char *cp,
1451 char *fp, int count)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001452{
Jiri Slaby53c5ee22012-10-18 22:26:39 +02001453 struct n_tty_data *ldata = tty->disc_data;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001454 const unsigned char *p;
1455 char *f, flags = TTY_NORMAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001456 char buf[64];
Linus Torvalds1da177e2005-04-16 15:20:36 -07001457
Jiri Slaby53c5ee22012-10-18 22:26:39 +02001458 if (ldata->real_raw) {
Peter Hurleyd1913e32013-06-15 09:14:28 -04001459 size_t n, head;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001460
Peter Hurleyd1913e32013-06-15 09:14:28 -04001461 head = ldata->read_head & (N_TTY_BUF_SIZE - 1);
1462 n = N_TTY_BUF_SIZE - max(read_cnt(ldata), head);
1463 n = min_t(size_t, count, n);
1464 memcpy(read_buf_addr(ldata, head), cp, n);
1465 ldata->read_head += n;
1466 cp += n;
1467 count -= n;
1468
1469 head = ldata->read_head & (N_TTY_BUF_SIZE - 1);
1470 n = N_TTY_BUF_SIZE - max(read_cnt(ldata), head);
1471 n = min_t(size_t, count, n);
1472 memcpy(read_buf_addr(ldata, head), cp, n);
1473 ldata->read_head += n;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001474 } else {
Peter Hurleyd1913e32013-06-15 09:14:28 -04001475 int i;
1476
Alan Cox4edf1822008-02-08 04:18:44 -08001477 for (i = count, p = cp, f = fp; i; i--, p++) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001478 if (f)
1479 flags = *f++;
1480 switch (flags) {
1481 case TTY_NORMAL:
1482 n_tty_receive_char(tty, *p);
1483 break;
1484 case TTY_BREAK:
1485 n_tty_receive_break(tty);
1486 break;
1487 case TTY_PARITY:
1488 case TTY_FRAME:
1489 n_tty_receive_parity_error(tty, *p);
1490 break;
1491 case TTY_OVERRUN:
1492 n_tty_receive_overrun(tty);
1493 break;
1494 default:
Alan Cox4edf1822008-02-08 04:18:44 -08001495 printk(KERN_ERR "%s: unknown flag %d\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -07001496 tty_name(tty, buf), flags);
1497 break;
1498 }
1499 }
Alan Coxf34d7a52008-04-30 00:54:13 -07001500 if (tty->ops->flush_chars)
1501 tty->ops->flush_chars(tty);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001502 }
1503
Peter Hurleyce741172013-06-15 09:14:20 -04001504 if ((!ldata->icanon && (read_cnt(ldata) >= ldata->minimum_to_wake)) ||
hyc@symas.com26df6d12010-06-22 10:14:49 -07001505 L_EXTPROC(tty)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001506 kill_fasync(&tty->fasync, SIGIO, POLL_IN);
1507 if (waitqueue_active(&tty->read_wait))
1508 wake_up_interruptible(&tty->read_wait);
1509 }
1510
1511 /*
1512 * Check the remaining room for the input canonicalization
1513 * mode. We don't want to throttle the driver if we're in
1514 * canonical mode and don't have a newline yet!
1515 */
Peter Hurleye91e52e2013-03-06 08:20:53 -05001516 while (1) {
Peter Hurley9356b532013-06-15 09:14:24 -04001517 int throttled;
Peter Hurleye91e52e2013-03-06 08:20:53 -05001518 tty_set_flow_change(tty, TTY_THROTTLE_SAFE);
Peter Hurley24a89d12013-06-15 09:14:15 -04001519 if (receive_room(tty) >= TTY_THRESHOLD_THROTTLE)
Peter Hurleye91e52e2013-03-06 08:20:53 -05001520 break;
Peter Hurley9356b532013-06-15 09:14:24 -04001521 throttled = tty_throttle_safe(tty);
Peter Hurley9356b532013-06-15 09:14:24 -04001522 if (!throttled)
Peter Hurleye91e52e2013-03-06 08:20:53 -05001523 break;
1524 }
1525 __tty_set_flow_change(tty, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001526}
1527
Peter Hurley24a89d12013-06-15 09:14:15 -04001528static void n_tty_receive_buf(struct tty_struct *tty, const unsigned char *cp,
1529 char *fp, int count)
1530{
Peter Hurley9356b532013-06-15 09:14:24 -04001531 down_read(&tty->termios_rwsem);
Peter Hurley24a89d12013-06-15 09:14:15 -04001532 __receive_buf(tty, cp, fp, count);
Peter Hurley9356b532013-06-15 09:14:24 -04001533 up_read(&tty->termios_rwsem);
Peter Hurley24a89d12013-06-15 09:14:15 -04001534}
1535
1536static int n_tty_receive_buf2(struct tty_struct *tty, const unsigned char *cp,
1537 char *fp, int count)
1538{
1539 struct n_tty_data *ldata = tty->disc_data;
1540 int room;
1541
Peter Hurley9356b532013-06-15 09:14:24 -04001542 down_read(&tty->termios_rwsem);
1543
Peter Hurley24a89d12013-06-15 09:14:15 -04001544 tty->receive_room = room = receive_room(tty);
1545 if (!room)
1546 ldata->no_room = 1;
1547 count = min(count, room);
1548 if (count)
1549 __receive_buf(tty, cp, fp, count);
1550
Peter Hurley9356b532013-06-15 09:14:24 -04001551 up_read(&tty->termios_rwsem);
1552
Peter Hurley24a89d12013-06-15 09:14:15 -04001553 return count;
1554}
1555
Linus Torvalds1da177e2005-04-16 15:20:36 -07001556int is_ignored(int sig)
1557{
1558 return (sigismember(&current->blocked, sig) ||
Alan Cox4edf1822008-02-08 04:18:44 -08001559 current->sighand->action[sig-1].sa.sa_handler == SIG_IGN);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001560}
1561
1562/**
1563 * n_tty_set_termios - termios data changed
1564 * @tty: terminal
1565 * @old: previous data
1566 *
1567 * Called by the tty layer when the user changes termios flags so
1568 * that the line discipline can plan ahead. This function cannot sleep
Alan Cox4edf1822008-02-08 04:18:44 -08001569 * and is protected from re-entry by the tty layer. The user is
Linus Torvalds1da177e2005-04-16 15:20:36 -07001570 * guaranteed that this function will not be re-entered or in progress
1571 * when the ldisc is closed.
Alan Cox17b82062008-10-13 10:45:06 +01001572 *
Peter Hurley6a1c0682013-06-15 09:14:23 -04001573 * Locking: Caller holds tty->termios_rwsem
Linus Torvalds1da177e2005-04-16 15:20:36 -07001574 */
Alan Cox4edf1822008-02-08 04:18:44 -08001575
1576static void n_tty_set_termios(struct tty_struct *tty, struct ktermios *old)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001577{
Jiri Slaby53c5ee22012-10-18 22:26:39 +02001578 struct n_tty_data *ldata = tty->disc_data;
Alan Cox47afa7a2008-10-13 10:44:17 +01001579 int canon_change = 1;
Alan Cox47afa7a2008-10-13 10:44:17 +01001580
1581 if (old)
Alan Coxadc8d742012-07-14 15:31:47 +01001582 canon_change = (old->c_lflag ^ tty->termios.c_lflag) & ICANON;
Alan Cox47afa7a2008-10-13 10:44:17 +01001583 if (canon_change) {
Jiri Slaby3fe780b2012-10-18 22:26:40 +02001584 bitmap_zero(ldata->read_flags, N_TTY_BUF_SIZE);
Jiri Slabyba2e68a2012-10-18 22:26:41 +02001585 ldata->canon_head = ldata->read_tail;
Jiri Slaby53c5ee22012-10-18 22:26:39 +02001586 ldata->erasing = 0;
Peter Hurley6f9b0282013-06-15 09:14:27 -04001587 ldata->lnext = 0;
Alan Cox47afa7a2008-10-13 10:44:17 +01001588 }
1589
Peter Hurleyce741172013-06-15 09:14:20 -04001590 if (canon_change && !L_ICANON(tty) && read_cnt(ldata))
Alan Cox47afa7a2008-10-13 10:44:17 +01001591 wake_up_interruptible(&tty->read_wait);
Alan Cox4edf1822008-02-08 04:18:44 -08001592
Jiri Slaby53c5ee22012-10-18 22:26:39 +02001593 ldata->icanon = (L_ICANON(tty) != 0);
Peter Hurley582f5592013-05-17 12:49:48 -04001594
Linus Torvalds1da177e2005-04-16 15:20:36 -07001595 if (I_ISTRIP(tty) || I_IUCLC(tty) || I_IGNCR(tty) ||
1596 I_ICRNL(tty) || I_INLCR(tty) || L_ICANON(tty) ||
1597 I_IXON(tty) || L_ISIG(tty) || L_ECHO(tty) ||
1598 I_PARMRK(tty)) {
Jiri Slaby3fe780b2012-10-18 22:26:40 +02001599 bitmap_zero(ldata->process_char_map, 256);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001600
1601 if (I_IGNCR(tty) || I_ICRNL(tty))
Jiri Slaby3fe780b2012-10-18 22:26:40 +02001602 set_bit('\r', ldata->process_char_map);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001603 if (I_INLCR(tty))
Jiri Slaby3fe780b2012-10-18 22:26:40 +02001604 set_bit('\n', ldata->process_char_map);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001605
1606 if (L_ICANON(tty)) {
Jiri Slaby3fe780b2012-10-18 22:26:40 +02001607 set_bit(ERASE_CHAR(tty), ldata->process_char_map);
1608 set_bit(KILL_CHAR(tty), ldata->process_char_map);
1609 set_bit(EOF_CHAR(tty), ldata->process_char_map);
1610 set_bit('\n', ldata->process_char_map);
1611 set_bit(EOL_CHAR(tty), ldata->process_char_map);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001612 if (L_IEXTEN(tty)) {
1613 set_bit(WERASE_CHAR(tty),
Jiri Slaby3fe780b2012-10-18 22:26:40 +02001614 ldata->process_char_map);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001615 set_bit(LNEXT_CHAR(tty),
Jiri Slaby3fe780b2012-10-18 22:26:40 +02001616 ldata->process_char_map);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001617 set_bit(EOL2_CHAR(tty),
Jiri Slaby3fe780b2012-10-18 22:26:40 +02001618 ldata->process_char_map);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001619 if (L_ECHO(tty))
1620 set_bit(REPRINT_CHAR(tty),
Jiri Slaby3fe780b2012-10-18 22:26:40 +02001621 ldata->process_char_map);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001622 }
1623 }
1624 if (I_IXON(tty)) {
Jiri Slaby3fe780b2012-10-18 22:26:40 +02001625 set_bit(START_CHAR(tty), ldata->process_char_map);
1626 set_bit(STOP_CHAR(tty), ldata->process_char_map);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001627 }
1628 if (L_ISIG(tty)) {
Jiri Slaby3fe780b2012-10-18 22:26:40 +02001629 set_bit(INTR_CHAR(tty), ldata->process_char_map);
1630 set_bit(QUIT_CHAR(tty), ldata->process_char_map);
1631 set_bit(SUSP_CHAR(tty), ldata->process_char_map);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001632 }
Jiri Slaby3fe780b2012-10-18 22:26:40 +02001633 clear_bit(__DISABLED_CHAR, ldata->process_char_map);
Jiri Slaby53c5ee22012-10-18 22:26:39 +02001634 ldata->raw = 0;
1635 ldata->real_raw = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001636 } else {
Jiri Slaby53c5ee22012-10-18 22:26:39 +02001637 ldata->raw = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001638 if ((I_IGNBRK(tty) || (!I_BRKINT(tty) && !I_PARMRK(tty))) &&
1639 (I_IGNPAR(tty) || !I_INPCK(tty)) &&
1640 (tty->driver->flags & TTY_DRIVER_REAL_RAW))
Jiri Slaby53c5ee22012-10-18 22:26:39 +02001641 ldata->real_raw = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001642 else
Jiri Slaby53c5ee22012-10-18 22:26:39 +02001643 ldata->real_raw = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001644 }
Linus Torvalds55db4c62011-06-04 06:33:24 +09001645 n_tty_set_room(tty);
Wang YanQingdab73b42013-05-09 14:16:47 +08001646 /*
1647 * Fix tty hang when I_IXON(tty) is cleared, but the tty
1648 * been stopped by STOP_CHAR(tty) before it.
1649 */
1650 if (!I_IXON(tty) && old && (old->c_iflag & IXON) && !tty->flow_stopped) {
1651 start_tty(tty);
1652 }
1653
Alan Coxf34d7a52008-04-30 00:54:13 -07001654 /* The termios change make the tty ready for I/O */
1655 wake_up_interruptible(&tty->write_wait);
1656 wake_up_interruptible(&tty->read_wait);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001657}
1658
1659/**
1660 * n_tty_close - close the ldisc for this tty
1661 * @tty: device
1662 *
Alan Cox4edf1822008-02-08 04:18:44 -08001663 * Called from the terminal layer when this line discipline is
1664 * being shut down, either because of a close or becsuse of a
Linus Torvalds1da177e2005-04-16 15:20:36 -07001665 * discipline change. The function will not be called while other
1666 * ldisc methods are in progress.
1667 */
Alan Cox4edf1822008-02-08 04:18:44 -08001668
Linus Torvalds1da177e2005-04-16 15:20:36 -07001669static void n_tty_close(struct tty_struct *tty)
1670{
Jiri Slaby70ece7a2012-10-18 22:26:38 +02001671 struct n_tty_data *ldata = tty->disc_data;
1672
Peter Hurley79901312013-03-11 16:44:23 -04001673 if (tty->link)
1674 n_tty_packet_mode_flush(tty);
1675
Jiri Slabyba2e68a2012-10-18 22:26:41 +02001676 kfree(ldata->read_buf);
1677 kfree(ldata->echo_buf);
Jiri Slaby70ece7a2012-10-18 22:26:38 +02001678 kfree(ldata);
Jiri Slaby70ece7a2012-10-18 22:26:38 +02001679 tty->disc_data = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001680}
1681
1682/**
1683 * n_tty_open - open an ldisc
1684 * @tty: terminal to open
1685 *
Alan Cox4edf1822008-02-08 04:18:44 -08001686 * Called when this line discipline is being attached to the
Linus Torvalds1da177e2005-04-16 15:20:36 -07001687 * terminal device. Can sleep. Called serialized so that no
1688 * other events will occur in parallel. No further open will occur
1689 * until a close.
1690 */
1691
1692static int n_tty_open(struct tty_struct *tty)
1693{
Jiri Slaby70ece7a2012-10-18 22:26:38 +02001694 struct n_tty_data *ldata;
1695
1696 ldata = kzalloc(sizeof(*ldata), GFP_KERNEL);
1697 if (!ldata)
1698 goto err;
1699
Jiri Slaby53c5ee22012-10-18 22:26:39 +02001700 ldata->overrun_time = jiffies;
Jiri Slabybddc7152012-10-18 22:26:42 +02001701 mutex_init(&ldata->atomic_read_lock);
1702 mutex_init(&ldata->output_lock);
1703 mutex_init(&ldata->echo_lock);
Jiri Slaby53c5ee22012-10-18 22:26:39 +02001704
Joe Petersona88a69c2009-01-02 13:40:53 +00001705 /* These are ugly. Currently a malloc failure here can panic */
Jiri Slabyba2e68a2012-10-18 22:26:41 +02001706 ldata->read_buf = kzalloc(N_TTY_BUF_SIZE, GFP_KERNEL);
1707 ldata->echo_buf = kzalloc(N_TTY_BUF_SIZE, GFP_KERNEL);
1708 if (!ldata->read_buf || !ldata->echo_buf)
Jiri Slabyb91939f2012-10-18 22:26:35 +02001709 goto err_free_bufs;
Alan Cox0b4068a2009-06-11 13:05:49 +01001710
Jiri Slaby70ece7a2012-10-18 22:26:38 +02001711 tty->disc_data = ldata;
Peter Hurleyb66f4fa2013-03-11 16:44:32 -04001712 reset_buffer_flags(tty->disc_data);
Jiri Slaby53c5ee22012-10-18 22:26:39 +02001713 ldata->column = 0;
Peter Hurleyf6c8dbe2013-06-15 07:28:28 -04001714 ldata->minimum_to_wake = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001715 tty->closing = 0;
Peter Hurleyb66f4fa2013-03-11 16:44:32 -04001716 /* indicate buffer work may resume */
1717 clear_bit(TTY_LDISC_HALTED, &tty->flags);
1718 n_tty_set_termios(tty, NULL);
1719 tty_unthrottle(tty);
Jiri Slaby70ece7a2012-10-18 22:26:38 +02001720
Linus Torvalds1da177e2005-04-16 15:20:36 -07001721 return 0;
Jiri Slabyb91939f2012-10-18 22:26:35 +02001722err_free_bufs:
Jiri Slabyba2e68a2012-10-18 22:26:41 +02001723 kfree(ldata->read_buf);
1724 kfree(ldata->echo_buf);
Jiri Slaby70ece7a2012-10-18 22:26:38 +02001725 kfree(ldata);
1726err:
Jiri Slabyb91939f2012-10-18 22:26:35 +02001727 return -ENOMEM;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001728}
1729
1730static inline int input_available_p(struct tty_struct *tty, int amt)
1731{
Jiri Slaby53c5ee22012-10-18 22:26:39 +02001732 struct n_tty_data *ldata = tty->disc_data;
1733
Jiri Slaby53c5ee22012-10-18 22:26:39 +02001734 if (ldata->icanon && !L_EXTPROC(tty)) {
Peter Hurleya73d3d62013-06-15 09:14:25 -04001735 if (ldata->canon_head != ldata->read_tail)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001736 return 1;
Peter Hurleyce741172013-06-15 09:14:20 -04001737 } else if (read_cnt(ldata) >= (amt ? amt : 1))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001738 return 1;
1739
1740 return 0;
1741}
1742
1743/**
Thorsten Wißmannbbd20752011-12-08 17:47:33 +01001744 * copy_from_read_buf - copy read data directly
Linus Torvalds1da177e2005-04-16 15:20:36 -07001745 * @tty: terminal device
1746 * @b: user data
1747 * @nr: size of data
1748 *
Alan Cox11a96d12008-10-13 10:46:24 +01001749 * Helper function to speed up n_tty_read. It is only called when
Linus Torvalds1da177e2005-04-16 15:20:36 -07001750 * ICANON is off; it copies characters straight from the tty queue to
1751 * user space directly. It can be profitably called twice; once to
1752 * drain the space from the tail pointer to the (physical) end of the
1753 * buffer, and once to drain the space from the (physical) beginning of
1754 * the buffer to head pointer.
1755 *
Jiri Slabybddc7152012-10-18 22:26:42 +02001756 * Called under the ldata->atomic_read_lock sem
Linus Torvalds1da177e2005-04-16 15:20:36 -07001757 *
Peter Hurley6d76bd22013-06-15 09:14:26 -04001758 * n_tty_read()/consumer path:
1759 * caller holds non-exclusive termios_rwsem
1760 * read_tail published
Linus Torvalds1da177e2005-04-16 15:20:36 -07001761 */
Alan Cox4edf1822008-02-08 04:18:44 -08001762
Alan Cox33f0f882006-01-09 20:54:13 -08001763static int copy_from_read_buf(struct tty_struct *tty,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001764 unsigned char __user **b,
1765 size_t *nr)
1766
1767{
Jiri Slaby53c5ee22012-10-18 22:26:39 +02001768 struct n_tty_data *ldata = tty->disc_data;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001769 int retval;
1770 size_t n;
Jiri Slaby3fa10cc2012-04-26 20:13:00 +02001771 bool is_eof;
Peter Hurleybc5a5e32013-06-15 09:14:21 -04001772 size_t tail = ldata->read_tail & (N_TTY_BUF_SIZE - 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001773
1774 retval = 0;
Peter Hurleybc5a5e32013-06-15 09:14:21 -04001775 n = min(read_cnt(ldata), N_TTY_BUF_SIZE - tail);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001776 n = min(*nr, n);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001777 if (n) {
Peter Hurleybc5a5e32013-06-15 09:14:21 -04001778 retval = copy_to_user(*b, read_buf_addr(ldata, tail), n);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001779 n -= retval;
Peter Hurleybc5a5e32013-06-15 09:14:21 -04001780 is_eof = n == 1 && read_buf(ldata, tail) == EOF_CHAR(tty);
1781 tty_audit_add_data(tty, read_buf_addr(ldata, tail), n,
Jiri Slaby53c5ee22012-10-18 22:26:39 +02001782 ldata->icanon);
Peter Hurleybc5a5e32013-06-15 09:14:21 -04001783 ldata->read_tail += n;
hyc@symas.com26df6d12010-06-22 10:14:49 -07001784 /* Turn single EOF into zero-length read */
Peter Hurleyce741172013-06-15 09:14:20 -04001785 if (L_EXTPROC(tty) && ldata->icanon && is_eof && !read_cnt(ldata))
Jiri Slaby3fa10cc2012-04-26 20:13:00 +02001786 n = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001787 *b += n;
1788 *nr -= n;
1789 }
1790 return retval;
1791}
1792
Peter Hurley88bb0de2013-06-15 09:14:16 -04001793/**
Peter Hurley32f13522013-06-15 09:14:17 -04001794 * canon_copy_from_read_buf - copy read data in canonical mode
Peter Hurley88bb0de2013-06-15 09:14:16 -04001795 * @tty: terminal device
1796 * @b: user data
1797 * @nr: size of data
1798 *
1799 * Helper function for n_tty_read. It is only called when ICANON is on;
Peter Hurley32f13522013-06-15 09:14:17 -04001800 * it copies one line of input up to and including the line-delimiting
1801 * character into the user-space buffer.
Peter Hurley88bb0de2013-06-15 09:14:16 -04001802 *
1803 * Called under the atomic_read_lock mutex
Peter Hurley6d76bd22013-06-15 09:14:26 -04001804 *
1805 * n_tty_read()/consumer path:
1806 * caller holds non-exclusive termios_rwsem
1807 * read_tail published
Peter Hurley88bb0de2013-06-15 09:14:16 -04001808 */
1809
Peter Hurley32f13522013-06-15 09:14:17 -04001810static int canon_copy_from_read_buf(struct tty_struct *tty,
1811 unsigned char __user **b,
1812 size_t *nr)
Peter Hurley88bb0de2013-06-15 09:14:16 -04001813{
1814 struct n_tty_data *ldata = tty->disc_data;
Peter Hurley32f13522013-06-15 09:14:17 -04001815 size_t n, size, more, c;
Peter Hurleybc5a5e32013-06-15 09:14:21 -04001816 size_t eol;
1817 size_t tail;
1818 int ret, found = 0;
Peter Hurley88bb0de2013-06-15 09:14:16 -04001819
1820 /* N.B. avoid overrun if nr == 0 */
Peter Hurleyce741172013-06-15 09:14:20 -04001821 n = min(*nr, read_cnt(ldata));
Peter Hurley6d76bd22013-06-15 09:14:26 -04001822 if (!n)
Peter Hurley32f13522013-06-15 09:14:17 -04001823 return 0;
Peter Hurley88bb0de2013-06-15 09:14:16 -04001824
Peter Hurleybc5a5e32013-06-15 09:14:21 -04001825 tail = ldata->read_tail & (N_TTY_BUF_SIZE - 1);
Peter Hurley32f13522013-06-15 09:14:17 -04001826 size = min_t(size_t, tail + n, N_TTY_BUF_SIZE);
1827
Peter Hurleybc5a5e32013-06-15 09:14:21 -04001828 n_tty_trace("%s: nr:%zu tail:%zu n:%zu size:%zu\n",
Peter Hurley32f13522013-06-15 09:14:17 -04001829 __func__, *nr, tail, n, size);
1830
1831 eol = find_next_bit(ldata->read_flags, size, tail);
1832 more = n - (size - tail);
1833 if (eol == N_TTY_BUF_SIZE && more) {
1834 /* scan wrapped without finding set bit */
1835 eol = find_next_bit(ldata->read_flags, more, 0);
1836 if (eol != more)
1837 found = 1;
1838 } else if (eol != size)
1839 found = 1;
1840
1841 size = N_TTY_BUF_SIZE - tail;
1842 n = (found + eol + size) & (N_TTY_BUF_SIZE - 1);
1843 c = n;
1844
Peter Hurleybc5a5e32013-06-15 09:14:21 -04001845 if (found && read_buf(ldata, eol) == __DISABLED_CHAR)
Peter Hurley32f13522013-06-15 09:14:17 -04001846 n--;
1847
Peter Hurleybc5a5e32013-06-15 09:14:21 -04001848 n_tty_trace("%s: eol:%zu found:%d n:%zu c:%zu size:%zu more:%zu\n",
Peter Hurley32f13522013-06-15 09:14:17 -04001849 __func__, eol, found, n, c, size, more);
1850
Peter Hurley32f13522013-06-15 09:14:17 -04001851 if (n > size) {
Peter Hurleybc5a5e32013-06-15 09:14:21 -04001852 ret = copy_to_user(*b, read_buf_addr(ldata, tail), size);
Peter Hurley32f13522013-06-15 09:14:17 -04001853 if (ret)
1854 return -EFAULT;
1855 ret = copy_to_user(*b + size, ldata->read_buf, n - size);
1856 } else
Peter Hurleybc5a5e32013-06-15 09:14:21 -04001857 ret = copy_to_user(*b, read_buf_addr(ldata, tail), n);
Peter Hurley32f13522013-06-15 09:14:17 -04001858
1859 if (ret)
1860 return -EFAULT;
1861 *b += n;
1862 *nr -= n;
1863
Peter Hurleya73d3d62013-06-15 09:14:25 -04001864 if (found)
Peter Hurley6d76bd22013-06-15 09:14:26 -04001865 clear_bit(eol, ldata->read_flags);
1866 smp_mb__after_clear_bit();
1867 ldata->read_tail += c;
Peter Hurley88bb0de2013-06-15 09:14:16 -04001868
Peter Hurley32f13522013-06-15 09:14:17 -04001869 if (found)
1870 tty_audit_push(tty);
Peter Hurley88bb0de2013-06-15 09:14:16 -04001871 return 0;
1872}
1873
Al Virocc4191d2008-03-29 03:08:48 +00001874extern ssize_t redirected_tty_write(struct file *, const char __user *,
Alan Cox4edf1822008-02-08 04:18:44 -08001875 size_t, loff_t *);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001876
1877/**
1878 * job_control - check job control
1879 * @tty: tty
1880 * @file: file handle
1881 *
1882 * Perform job control management checks on this file/tty descriptor
Alan Cox4edf1822008-02-08 04:18:44 -08001883 * and if appropriate send any needed signals and return a negative
Linus Torvalds1da177e2005-04-16 15:20:36 -07001884 * error code if action should be taken.
Alan Cox04f378b2008-04-30 00:53:29 -07001885 *
Peter Hurley01a5e442013-03-06 08:38:20 -05001886 * Locking: redirected write test is safe
1887 * current->signal->tty check is safe
1888 * ctrl_lock to safely reference tty->pgrp
Linus Torvalds1da177e2005-04-16 15:20:36 -07001889 */
Alan Cox4edf1822008-02-08 04:18:44 -08001890
Linus Torvalds1da177e2005-04-16 15:20:36 -07001891static int job_control(struct tty_struct *tty, struct file *file)
1892{
1893 /* Job control check -- must be done at start and after
1894 every sleep (POSIX.1 7.1.1.4). */
1895 /* NOTE: not yet done after every sleep pending a thorough
1896 check of the logic of this change. -- jlc */
1897 /* don't stop on /dev/console */
Peter Hurley01a5e442013-03-06 08:38:20 -05001898 if (file->f_op->write == redirected_tty_write ||
1899 current->signal->tty != tty)
1900 return 0;
1901
1902 spin_lock_irq(&tty->ctrl_lock);
1903 if (!tty->pgrp)
1904 printk(KERN_ERR "n_tty_read: no tty->pgrp!\n");
1905 else if (task_pgrp(current) != tty->pgrp) {
1906 spin_unlock_irq(&tty->ctrl_lock);
1907 if (is_ignored(SIGTTIN) || is_current_pgrp_orphaned())
1908 return -EIO;
1909 kill_pgrp(task_pgrp(current), SIGTTIN, 1);
1910 set_thread_flag(TIF_SIGPENDING);
1911 return -ERESTARTSYS;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001912 }
Peter Hurley01a5e442013-03-06 08:38:20 -05001913 spin_unlock_irq(&tty->ctrl_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001914 return 0;
1915}
Alan Cox4edf1822008-02-08 04:18:44 -08001916
Linus Torvalds1da177e2005-04-16 15:20:36 -07001917
1918/**
Alan Cox11a96d12008-10-13 10:46:24 +01001919 * n_tty_read - read function for tty
Linus Torvalds1da177e2005-04-16 15:20:36 -07001920 * @tty: tty device
1921 * @file: file object
1922 * @buf: userspace buffer pointer
1923 * @nr: size of I/O
1924 *
1925 * Perform reads for the line discipline. We are guaranteed that the
1926 * line discipline will not be closed under us but we may get multiple
1927 * parallel readers and must handle this ourselves. We may also get
1928 * a hangup. Always called in user context, may sleep.
1929 *
1930 * This code must be sure never to sleep through a hangup.
Peter Hurley6d76bd22013-06-15 09:14:26 -04001931 *
1932 * n_tty_read()/consumer path:
1933 * claims non-exclusive termios_rwsem
1934 * publishes read_tail
Linus Torvalds1da177e2005-04-16 15:20:36 -07001935 */
Alan Cox4edf1822008-02-08 04:18:44 -08001936
Alan Cox11a96d12008-10-13 10:46:24 +01001937static ssize_t n_tty_read(struct tty_struct *tty, struct file *file,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001938 unsigned char __user *buf, size_t nr)
1939{
Jiri Slaby53c5ee22012-10-18 22:26:39 +02001940 struct n_tty_data *ldata = tty->disc_data;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001941 unsigned char __user *b = buf;
1942 DECLARE_WAITQUEUE(wait, current);
1943 int c;
1944 int minimum, time;
1945 ssize_t retval = 0;
1946 ssize_t size;
1947 long timeout;
1948 unsigned long flags;
Alan Cox04f378b2008-04-30 00:53:29 -07001949 int packet;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001950
1951do_it_again:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001952 c = job_control(tty, file);
Alan Cox4edf1822008-02-08 04:18:44 -08001953 if (c < 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001954 return c;
Alan Cox4edf1822008-02-08 04:18:44 -08001955
Peter Hurley9356b532013-06-15 09:14:24 -04001956 down_read(&tty->termios_rwsem);
1957
Linus Torvalds1da177e2005-04-16 15:20:36 -07001958 minimum = time = 0;
1959 timeout = MAX_SCHEDULE_TIMEOUT;
Jiri Slaby53c5ee22012-10-18 22:26:39 +02001960 if (!ldata->icanon) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001961 minimum = MIN_CHAR(tty);
1962 if (minimum) {
Peter Hurleya6e54312013-06-15 07:28:29 -04001963 time = (HZ / 10) * TIME_CHAR(tty);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001964 if (time)
Peter Hurleyf6c8dbe2013-06-15 07:28:28 -04001965 ldata->minimum_to_wake = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001966 else if (!waitqueue_active(&tty->read_wait) ||
Peter Hurleyf6c8dbe2013-06-15 07:28:28 -04001967 (ldata->minimum_to_wake > minimum))
1968 ldata->minimum_to_wake = minimum;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001969 } else {
Peter Hurleya6e54312013-06-15 07:28:29 -04001970 timeout = (HZ / 10) * TIME_CHAR(tty);
Peter Hurleyf6c8dbe2013-06-15 07:28:28 -04001971 ldata->minimum_to_wake = minimum = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001972 }
1973 }
1974
1975 /*
1976 * Internal serialization of reads.
1977 */
1978 if (file->f_flags & O_NONBLOCK) {
Peter Hurley9356b532013-06-15 09:14:24 -04001979 if (!mutex_trylock(&ldata->atomic_read_lock)) {
1980 up_read(&tty->termios_rwsem);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001981 return -EAGAIN;
Peter Hurley9356b532013-06-15 09:14:24 -04001982 }
Alan Cox4edf1822008-02-08 04:18:44 -08001983 } else {
Peter Hurley9356b532013-06-15 09:14:24 -04001984 if (mutex_lock_interruptible(&ldata->atomic_read_lock)) {
1985 up_read(&tty->termios_rwsem);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001986 return -ERESTARTSYS;
Peter Hurley9356b532013-06-15 09:14:24 -04001987 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001988 }
Alan Cox04f378b2008-04-30 00:53:29 -07001989 packet = tty->packet;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001990
1991 add_wait_queue(&tty->read_wait, &wait);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001992 while (nr) {
1993 /* First test for status change. */
Alan Cox04f378b2008-04-30 00:53:29 -07001994 if (packet && tty->link->ctrl_status) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001995 unsigned char cs;
1996 if (b != buf)
1997 break;
Alan Cox04f378b2008-04-30 00:53:29 -07001998 spin_lock_irqsave(&tty->link->ctrl_lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001999 cs = tty->link->ctrl_status;
2000 tty->link->ctrl_status = 0;
Alan Cox04f378b2008-04-30 00:53:29 -07002001 spin_unlock_irqrestore(&tty->link->ctrl_lock, flags);
Miloslav Trmac522ed772007-07-15 23:40:56 -07002002 if (tty_put_user(tty, cs, b++)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002003 retval = -EFAULT;
2004 b--;
2005 break;
2006 }
2007 nr--;
2008 break;
2009 }
2010 /* This statement must be first before checking for input
2011 so that any interrupt will set the state back to
2012 TASK_RUNNING. */
2013 set_current_state(TASK_INTERRUPTIBLE);
Alan Cox4edf1822008-02-08 04:18:44 -08002014
Peter Hurleyf6c8dbe2013-06-15 07:28:28 -04002015 if (((minimum - (b - buf)) < ldata->minimum_to_wake) &&
Linus Torvalds1da177e2005-04-16 15:20:36 -07002016 ((minimum - (b - buf)) >= 1))
Peter Hurleyf6c8dbe2013-06-15 07:28:28 -04002017 ldata->minimum_to_wake = (minimum - (b - buf));
Alan Cox4edf1822008-02-08 04:18:44 -08002018
Linus Torvalds1da177e2005-04-16 15:20:36 -07002019 if (!input_available_p(tty, 0)) {
2020 if (test_bit(TTY_OTHER_CLOSED, &tty->flags)) {
2021 retval = -EIO;
2022 break;
2023 }
2024 if (tty_hung_up_p(file))
2025 break;
2026 if (!timeout)
2027 break;
2028 if (file->f_flags & O_NONBLOCK) {
2029 retval = -EAGAIN;
2030 break;
2031 }
2032 if (signal_pending(current)) {
2033 retval = -ERESTARTSYS;
2034 break;
2035 }
Linus Torvalds55db4c62011-06-04 06:33:24 +09002036 n_tty_set_room(tty);
Peter Hurley9356b532013-06-15 09:14:24 -04002037 up_read(&tty->termios_rwsem);
2038
Linus Torvalds1da177e2005-04-16 15:20:36 -07002039 timeout = schedule_timeout(timeout);
Peter Hurley9356b532013-06-15 09:14:24 -04002040
2041 down_read(&tty->termios_rwsem);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002042 continue;
2043 }
2044 __set_current_state(TASK_RUNNING);
2045
2046 /* Deal with packet mode. */
Alan Cox04f378b2008-04-30 00:53:29 -07002047 if (packet && b == buf) {
Miloslav Trmac522ed772007-07-15 23:40:56 -07002048 if (tty_put_user(tty, TIOCPKT_DATA, b++)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002049 retval = -EFAULT;
2050 b--;
2051 break;
2052 }
2053 nr--;
2054 }
2055
Jiri Slaby53c5ee22012-10-18 22:26:39 +02002056 if (ldata->icanon && !L_EXTPROC(tty)) {
Peter Hurley32f13522013-06-15 09:14:17 -04002057 retval = canon_copy_from_read_buf(tty, &b, &nr);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002058 if (retval)
2059 break;
2060 } else {
2061 int uncopied;
Alan Cox04f378b2008-04-30 00:53:29 -07002062 /* The copy function takes the read lock and handles
2063 locking internally for this case */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002064 uncopied = copy_from_read_buf(tty, &b, &nr);
2065 uncopied += copy_from_read_buf(tty, &b, &nr);
2066 if (uncopied) {
2067 retval = -EFAULT;
2068 break;
2069 }
2070 }
2071
2072 /* If there is enough space in the read buffer now, let the
Peter Hurleya19d0c62013-06-15 09:14:18 -04002073 * low-level driver know. We use chars_in_buffer() to
Linus Torvalds1da177e2005-04-16 15:20:36 -07002074 * check the buffer, as it now knows about canonical mode.
2075 * Otherwise, if the driver is throttled and the line is
2076 * longer than TTY_THRESHOLD_UNTHROTTLE in canonical mode,
2077 * we won't get any more characters.
2078 */
Peter Hurleye91e52e2013-03-06 08:20:53 -05002079 while (1) {
Peter Hurley9356b532013-06-15 09:14:24 -04002080 int unthrottled;
Peter Hurleye91e52e2013-03-06 08:20:53 -05002081 tty_set_flow_change(tty, TTY_UNTHROTTLE_SAFE);
Peter Hurleya19d0c62013-06-15 09:14:18 -04002082 if (chars_in_buffer(tty) > TTY_THRESHOLD_UNTHROTTLE)
Peter Hurleye91e52e2013-03-06 08:20:53 -05002083 break;
2084 if (!tty->count)
2085 break;
Linus Torvalds55db4c62011-06-04 06:33:24 +09002086 n_tty_set_room(tty);
Peter Hurley9356b532013-06-15 09:14:24 -04002087 unthrottled = tty_unthrottle_safe(tty);
Peter Hurley9356b532013-06-15 09:14:24 -04002088 if (!unthrottled)
Peter Hurleye91e52e2013-03-06 08:20:53 -05002089 break;
Linus Torvalds55db4c62011-06-04 06:33:24 +09002090 }
Peter Hurleye91e52e2013-03-06 08:20:53 -05002091 __tty_set_flow_change(tty, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002092
2093 if (b - buf >= minimum)
2094 break;
2095 if (time)
2096 timeout = time;
2097 }
Jiri Slabybddc7152012-10-18 22:26:42 +02002098 mutex_unlock(&ldata->atomic_read_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002099 remove_wait_queue(&tty->read_wait, &wait);
2100
2101 if (!waitqueue_active(&tty->read_wait))
Peter Hurleyf6c8dbe2013-06-15 07:28:28 -04002102 ldata->minimum_to_wake = minimum;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002103
2104 __set_current_state(TASK_RUNNING);
2105 size = b - buf;
2106 if (size) {
2107 retval = size;
2108 if (nr)
Alan Cox4edf1822008-02-08 04:18:44 -08002109 clear_bit(TTY_PUSH, &tty->flags);
Peter Hurley9356b532013-06-15 09:14:24 -04002110 } else if (test_and_clear_bit(TTY_PUSH, &tty->flags)) {
2111 up_read(&tty->termios_rwsem);
Thorsten Wißmannbbd20752011-12-08 17:47:33 +01002112 goto do_it_again;
Peter Hurley9356b532013-06-15 09:14:24 -04002113 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002114
Linus Torvalds55db4c62011-06-04 06:33:24 +09002115 n_tty_set_room(tty);
Peter Hurley9356b532013-06-15 09:14:24 -04002116 up_read(&tty->termios_rwsem);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002117 return retval;
2118}
2119
2120/**
Alan Cox11a96d12008-10-13 10:46:24 +01002121 * n_tty_write - write function for tty
Linus Torvalds1da177e2005-04-16 15:20:36 -07002122 * @tty: tty device
2123 * @file: file object
2124 * @buf: userspace buffer pointer
2125 * @nr: size of I/O
2126 *
Joe Petersona88a69c2009-01-02 13:40:53 +00002127 * Write function of the terminal device. This is serialized with
Linus Torvalds1da177e2005-04-16 15:20:36 -07002128 * respect to other write callers but not to termios changes, reads
Joe Petersona88a69c2009-01-02 13:40:53 +00002129 * and other such events. Since the receive code will echo characters,
2130 * thus calling driver write methods, the output_lock is used in
2131 * the output processing functions called here as well as in the
2132 * echo processing function to protect the column state and space
2133 * left in the buffer.
Linus Torvalds1da177e2005-04-16 15:20:36 -07002134 *
2135 * This code must be sure never to sleep through a hangup.
Joe Petersona88a69c2009-01-02 13:40:53 +00002136 *
2137 * Locking: output_lock to protect column state and space left
2138 * (note that the process_output*() functions take this
2139 * lock themselves)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002140 */
Alan Cox4edf1822008-02-08 04:18:44 -08002141
Alan Cox11a96d12008-10-13 10:46:24 +01002142static ssize_t n_tty_write(struct tty_struct *tty, struct file *file,
Joe Petersona88a69c2009-01-02 13:40:53 +00002143 const unsigned char *buf, size_t nr)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002144{
2145 const unsigned char *b = buf;
2146 DECLARE_WAITQUEUE(wait, current);
2147 int c;
2148 ssize_t retval = 0;
2149
2150 /* Job control check -- must be done at start (POSIX.1 7.1.1.4). */
2151 if (L_TOSTOP(tty) && file->f_op->write != redirected_tty_write) {
2152 retval = tty_check_change(tty);
2153 if (retval)
2154 return retval;
2155 }
2156
Peter Hurley9356b532013-06-15 09:14:24 -04002157 down_read(&tty->termios_rwsem);
2158
Joe Petersona88a69c2009-01-02 13:40:53 +00002159 /* Write out any echoed characters that are still pending */
2160 process_echoes(tty);
Alan Cox300a6202009-01-02 13:41:04 +00002161
Linus Torvalds1da177e2005-04-16 15:20:36 -07002162 add_wait_queue(&tty->write_wait, &wait);
2163 while (1) {
2164 set_current_state(TASK_INTERRUPTIBLE);
2165 if (signal_pending(current)) {
2166 retval = -ERESTARTSYS;
2167 break;
2168 }
2169 if (tty_hung_up_p(file) || (tty->link && !tty->link->count)) {
2170 retval = -EIO;
2171 break;
2172 }
Peter Hurley582f5592013-05-17 12:49:48 -04002173 if (O_OPOST(tty)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002174 while (nr > 0) {
Joe Petersona88a69c2009-01-02 13:40:53 +00002175 ssize_t num = process_output_block(tty, b, nr);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002176 if (num < 0) {
2177 if (num == -EAGAIN)
2178 break;
2179 retval = num;
2180 goto break_out;
2181 }
2182 b += num;
2183 nr -= num;
2184 if (nr == 0)
2185 break;
2186 c = *b;
Joe Petersona88a69c2009-01-02 13:40:53 +00002187 if (process_output(c, tty) < 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002188 break;
2189 b++; nr--;
2190 }
Alan Coxf34d7a52008-04-30 00:54:13 -07002191 if (tty->ops->flush_chars)
2192 tty->ops->flush_chars(tty);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002193 } else {
Roman Zippeld6afe272005-07-07 17:56:55 -07002194 while (nr > 0) {
Alan Coxf34d7a52008-04-30 00:54:13 -07002195 c = tty->ops->write(tty, b, nr);
Roman Zippeld6afe272005-07-07 17:56:55 -07002196 if (c < 0) {
2197 retval = c;
2198 goto break_out;
2199 }
2200 if (!c)
2201 break;
2202 b += c;
2203 nr -= c;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002204 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002205 }
2206 if (!nr)
2207 break;
2208 if (file->f_flags & O_NONBLOCK) {
2209 retval = -EAGAIN;
2210 break;
2211 }
Peter Hurley9356b532013-06-15 09:14:24 -04002212 up_read(&tty->termios_rwsem);
2213
Linus Torvalds1da177e2005-04-16 15:20:36 -07002214 schedule();
Peter Hurley9356b532013-06-15 09:14:24 -04002215
2216 down_read(&tty->termios_rwsem);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002217 }
2218break_out:
2219 __set_current_state(TASK_RUNNING);
2220 remove_wait_queue(&tty->write_wait, &wait);
Thomas Pfaffff8cb0f2009-01-02 13:47:13 +00002221 if (b - buf != nr && tty->fasync)
2222 set_bit(TTY_DO_WRITE_WAKEUP, &tty->flags);
Peter Hurley9356b532013-06-15 09:14:24 -04002223 up_read(&tty->termios_rwsem);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002224 return (b - buf) ? b - buf : retval;
2225}
2226
2227/**
Alan Cox11a96d12008-10-13 10:46:24 +01002228 * n_tty_poll - poll method for N_TTY
Linus Torvalds1da177e2005-04-16 15:20:36 -07002229 * @tty: terminal device
2230 * @file: file accessing it
2231 * @wait: poll table
2232 *
2233 * Called when the line discipline is asked to poll() for data or
2234 * for special events. This code is not serialized with respect to
2235 * other events save open/close.
2236 *
2237 * This code must be sure never to sleep through a hangup.
2238 * Called without the kernel lock held - fine
Linus Torvalds1da177e2005-04-16 15:20:36 -07002239 */
Alan Cox4edf1822008-02-08 04:18:44 -08002240
Alan Cox11a96d12008-10-13 10:46:24 +01002241static unsigned int n_tty_poll(struct tty_struct *tty, struct file *file,
Alan Cox4edf1822008-02-08 04:18:44 -08002242 poll_table *wait)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002243{
Peter Hurleyf6c8dbe2013-06-15 07:28:28 -04002244 struct n_tty_data *ldata = tty->disc_data;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002245 unsigned int mask = 0;
2246
2247 poll_wait(file, &tty->read_wait, wait);
2248 poll_wait(file, &tty->write_wait, wait);
2249 if (input_available_p(tty, TIME_CHAR(tty) ? 0 : MIN_CHAR(tty)))
2250 mask |= POLLIN | POLLRDNORM;
2251 if (tty->packet && tty->link->ctrl_status)
2252 mask |= POLLPRI | POLLIN | POLLRDNORM;
2253 if (test_bit(TTY_OTHER_CLOSED, &tty->flags))
2254 mask |= POLLHUP;
2255 if (tty_hung_up_p(file))
2256 mask |= POLLHUP;
2257 if (!(mask & (POLLHUP | POLLIN | POLLRDNORM))) {
2258 if (MIN_CHAR(tty) && !TIME_CHAR(tty))
Peter Hurleyf6c8dbe2013-06-15 07:28:28 -04002259 ldata->minimum_to_wake = MIN_CHAR(tty);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002260 else
Peter Hurleyf6c8dbe2013-06-15 07:28:28 -04002261 ldata->minimum_to_wake = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002262 }
Alan Coxf34d7a52008-04-30 00:54:13 -07002263 if (tty->ops->write && !tty_is_writelocked(tty) &&
2264 tty_chars_in_buffer(tty) < WAKEUP_CHARS &&
2265 tty_write_room(tty) > 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002266 mask |= POLLOUT | POLLWRNORM;
2267 return mask;
2268}
2269
Jiri Slaby57c94122012-10-18 22:26:43 +02002270static unsigned long inq_canon(struct n_tty_data *ldata)
Alan Cox47afa7a2008-10-13 10:44:17 +01002271{
Peter Hurleybc5a5e32013-06-15 09:14:21 -04002272 size_t nr, head, tail;
Alan Cox47afa7a2008-10-13 10:44:17 +01002273
Peter Hurleya73d3d62013-06-15 09:14:25 -04002274 if (ldata->canon_head == ldata->read_tail)
Alan Cox47afa7a2008-10-13 10:44:17 +01002275 return 0;
Jiri Slabyba2e68a2012-10-18 22:26:41 +02002276 head = ldata->canon_head;
2277 tail = ldata->read_tail;
Peter Hurleybc5a5e32013-06-15 09:14:21 -04002278 nr = head - tail;
Alan Cox47afa7a2008-10-13 10:44:17 +01002279 /* Skip EOF-chars.. */
2280 while (head != tail) {
Peter Hurleybc5a5e32013-06-15 09:14:21 -04002281 if (test_bit(tail & (N_TTY_BUF_SIZE - 1), ldata->read_flags) &&
2282 read_buf(ldata, tail) == __DISABLED_CHAR)
Alan Cox47afa7a2008-10-13 10:44:17 +01002283 nr--;
Peter Hurleybc5a5e32013-06-15 09:14:21 -04002284 tail++;
Alan Cox47afa7a2008-10-13 10:44:17 +01002285 }
2286 return nr;
2287}
2288
2289static int n_tty_ioctl(struct tty_struct *tty, struct file *file,
2290 unsigned int cmd, unsigned long arg)
2291{
Jiri Slabyba2e68a2012-10-18 22:26:41 +02002292 struct n_tty_data *ldata = tty->disc_data;
Alan Cox47afa7a2008-10-13 10:44:17 +01002293 int retval;
2294
2295 switch (cmd) {
2296 case TIOCOUTQ:
2297 return put_user(tty_chars_in_buffer(tty), (int __user *) arg);
2298 case TIOCINQ:
Peter Hurley6d76bd22013-06-15 09:14:26 -04002299 down_write(&tty->termios_rwsem);
Alan Cox47afa7a2008-10-13 10:44:17 +01002300 if (L_ICANON(tty))
Jiri Slaby57c94122012-10-18 22:26:43 +02002301 retval = inq_canon(ldata);
Peter Hurley6d76bd22013-06-15 09:14:26 -04002302 else
2303 retval = read_cnt(ldata);
2304 up_write(&tty->termios_rwsem);
Alan Cox47afa7a2008-10-13 10:44:17 +01002305 return put_user(retval, (unsigned int __user *) arg);
2306 default:
2307 return n_tty_ioctl_helper(tty, file, cmd, arg);
2308 }
2309}
2310
Peter Hurleyf6c8dbe2013-06-15 07:28:28 -04002311static void n_tty_fasync(struct tty_struct *tty, int on)
2312{
2313 struct n_tty_data *ldata = tty->disc_data;
2314
2315 if (!waitqueue_active(&tty->read_wait)) {
2316 if (on)
2317 ldata->minimum_to_wake = 1;
2318 else if (!tty->fasync)
2319 ldata->minimum_to_wake = N_TTY_BUF_SIZE;
2320 }
2321}
2322
Alan Coxa352def2008-07-16 21:53:12 +01002323struct tty_ldisc_ops tty_ldisc_N_TTY = {
Paul Fulghume10cc1d2007-05-10 22:22:50 -07002324 .magic = TTY_LDISC_MAGIC,
2325 .name = "n_tty",
2326 .open = n_tty_open,
2327 .close = n_tty_close,
2328 .flush_buffer = n_tty_flush_buffer,
2329 .chars_in_buffer = n_tty_chars_in_buffer,
Alan Cox11a96d12008-10-13 10:46:24 +01002330 .read = n_tty_read,
2331 .write = n_tty_write,
Paul Fulghume10cc1d2007-05-10 22:22:50 -07002332 .ioctl = n_tty_ioctl,
2333 .set_termios = n_tty_set_termios,
Alan Cox11a96d12008-10-13 10:46:24 +01002334 .poll = n_tty_poll,
Paul Fulghume10cc1d2007-05-10 22:22:50 -07002335 .receive_buf = n_tty_receive_buf,
Peter Hurleyf6c8dbe2013-06-15 07:28:28 -04002336 .write_wakeup = n_tty_write_wakeup,
2337 .fasync = n_tty_fasync,
Peter Hurley24a89d12013-06-15 09:14:15 -04002338 .receive_buf2 = n_tty_receive_buf2,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002339};
Rodolfo Giometti572b9ad2010-03-10 15:23:46 -08002340
2341/**
2342 * n_tty_inherit_ops - inherit N_TTY methods
2343 * @ops: struct tty_ldisc_ops where to save N_TTY methods
2344 *
George Spelvin593fb1ae42013-02-12 02:00:43 -05002345 * Enables a 'subclass' line discipline to 'inherit' N_TTY
Rodolfo Giometti572b9ad2010-03-10 15:23:46 -08002346 * methods.
2347 */
2348
2349void n_tty_inherit_ops(struct tty_ldisc_ops *ops)
2350{
2351 *ops = tty_ldisc_N_TTY;
2352 ops->owner = NULL;
2353 ops->refcount = ops->flags = 0;
2354}
2355EXPORT_SYMBOL_GPL(n_tty_inherit_ops);