blob: 4f20bec011fb671aa3bbd0874d30a86129814552 [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 Hurleycbfd0342013-06-15 10:04:26 -040077#define ECHO_COMMIT_WATERMARK 256
78#define ECHO_BLOCK 256
79#define ECHO_DISCARD_WATERMARK N_TTY_BUF_SIZE - (ECHO_BLOCK + 32)
80
81
Peter Hurley32f13522013-06-15 09:14:17 -040082#undef N_TTY_TRACE
83#ifdef N_TTY_TRACE
84# define n_tty_trace(f, args...) trace_printk(f, ##args)
85#else
86# define n_tty_trace(f, args...)
87#endif
88
Jiri Slaby70ece7a2012-10-18 22:26:38 +020089struct n_tty_data {
Peter Hurleyfb7aa032013-06-15 09:14:30 -040090 /* producer-published */
91 size_t read_head;
92 size_t canon_head;
Peter Hurley9dfd16d2013-06-15 10:04:29 -040093 size_t echo_head;
94 size_t echo_commit;
Peter Hurley1bb9d562013-06-15 10:21:20 -040095 DECLARE_BITMAP(char_map, 256);
Peter Hurleyfb7aa032013-06-15 09:14:30 -040096
97 /* private to n_tty_receive_overrun (single-threaded) */
Jiri Slaby53c5ee22012-10-18 22:26:39 +020098 unsigned long overrun_time;
99 int num_overrun;
100
Peter Hurley24a89d12013-06-15 09:14:15 -0400101 /* non-atomic */
102 bool no_room;
103
Peter Hurleyfb7aa032013-06-15 09:14:30 -0400104 /* must hold exclusive termios_rwsem to reset these */
Jiri Slaby53c5ee22012-10-18 22:26:39 +0200105 unsigned char lnext:1, erasing:1, raw:1, real_raw:1, icanon:1;
Jiri Slaby3fe780b2012-10-18 22:26:40 +0200106
Peter Hurleyfb7aa032013-06-15 09:14:30 -0400107 /* shared by producer and consumer */
Peter Hurley20bafb32013-06-15 10:21:19 -0400108 char read_buf[N_TTY_BUF_SIZE];
Jiri Slaby3fe780b2012-10-18 22:26:40 +0200109 DECLARE_BITMAP(read_flags, N_TTY_BUF_SIZE);
Peter Hurley20bafb32013-06-15 10:21:19 -0400110 unsigned char echo_buf[N_TTY_BUF_SIZE];
Jiri Slabyba2e68a2012-10-18 22:26:41 +0200111
Peter Hurleyf6c8dbe2013-06-15 07:28:28 -0400112 int minimum_to_wake;
Jiri Slabyba2e68a2012-10-18 22:26:41 +0200113
Peter Hurleyfb7aa032013-06-15 09:14:30 -0400114 /* consumer-published */
115 size_t read_tail;
Peter Hurley40d5e092013-06-15 10:21:17 -0400116 size_t line_start;
Peter Hurleyfb7aa032013-06-15 09:14:30 -0400117
Peter Hurleyfb7aa032013-06-15 09:14:30 -0400118 /* protected by output lock */
119 unsigned int column;
Jiri Slabyba2e68a2012-10-18 22:26:41 +0200120 unsigned int canon_column;
Peter Hurley9dfd16d2013-06-15 10:04:29 -0400121 size_t echo_tail;
Jiri Slabybddc7152012-10-18 22:26:42 +0200122
123 struct mutex atomic_read_lock;
124 struct mutex output_lock;
Jiri Slaby70ece7a2012-10-18 22:26:38 +0200125};
126
Peter Hurleyce741172013-06-15 09:14:20 -0400127static inline size_t read_cnt(struct n_tty_data *ldata)
128{
Peter Hurleya2f73be2013-06-15 09:14:22 -0400129 return ldata->read_head - ldata->read_tail;
Peter Hurleyce741172013-06-15 09:14:20 -0400130}
131
Peter Hurleybc5a5e32013-06-15 09:14:21 -0400132static inline unsigned char read_buf(struct n_tty_data *ldata, size_t i)
133{
134 return ldata->read_buf[i & (N_TTY_BUF_SIZE - 1)];
135}
136
137static inline unsigned char *read_buf_addr(struct n_tty_data *ldata, size_t i)
138{
139 return &ldata->read_buf[i & (N_TTY_BUF_SIZE - 1)];
140}
141
Peter Hurleyaddaebc2013-06-15 10:04:22 -0400142static inline unsigned char echo_buf(struct n_tty_data *ldata, size_t i)
143{
144 return ldata->echo_buf[i & (N_TTY_BUF_SIZE - 1)];
145}
146
147static inline unsigned char *echo_buf_addr(struct n_tty_data *ldata, size_t i)
148{
149 return &ldata->echo_buf[i & (N_TTY_BUF_SIZE - 1)];
150}
151
Miloslav Trmac522ed772007-07-15 23:40:56 -0700152static inline int tty_put_user(struct tty_struct *tty, unsigned char x,
153 unsigned char __user *ptr)
154{
Jiri Slaby53c5ee22012-10-18 22:26:39 +0200155 struct n_tty_data *ldata = tty->disc_data;
156
157 tty_audit_add_data(tty, &x, 1, ldata->icanon);
Miloslav Trmac522ed772007-07-15 23:40:56 -0700158 return put_user(x, ptr);
159}
160
Peter Hurley24a89d12013-06-15 09:14:15 -0400161static int receive_room(struct tty_struct *tty)
Linus Torvalds55db4c62011-06-04 06:33:24 +0900162{
Jiri Slaby53c5ee22012-10-18 22:26:39 +0200163 struct n_tty_data *ldata = tty->disc_data;
Jaeden Amero090abf72012-07-27 08:43:11 -0500164 int left;
Peter Hurleyb8483052013-06-15 07:28:30 -0400165
Jaeden Amero090abf72012-07-27 08:43:11 -0500166 if (I_PARMRK(tty)) {
167 /* Multiply read_cnt by 3, since each byte might take up to
168 * three times as many spaces when PARMRK is set (depending on
169 * its flags, e.g. parity error). */
Peter Hurleyce741172013-06-15 09:14:20 -0400170 left = N_TTY_BUF_SIZE - read_cnt(ldata) * 3 - 1;
Jaeden Amero090abf72012-07-27 08:43:11 -0500171 } else
Peter Hurleyce741172013-06-15 09:14:20 -0400172 left = N_TTY_BUF_SIZE - read_cnt(ldata) - 1;
Jaeden Amero090abf72012-07-27 08:43:11 -0500173
Linus Torvalds55db4c62011-06-04 06:33:24 +0900174 /*
175 * If we are doing input canonicalization, and there are no
176 * pending newlines, let characters through without limit, so
177 * that erase characters will be handled. Other excess
178 * characters will be beeped.
179 */
180 if (left <= 0)
Peter Hurleya73d3d62013-06-15 09:14:25 -0400181 left = ldata->icanon && ldata->canon_head == ldata->read_tail;
Linus Torvalds55db4c62011-06-04 06:33:24 +0900182
Peter Hurley24a89d12013-06-15 09:14:15 -0400183 return left;
Peter Hurley7879a9f2013-06-15 07:28:31 -0400184}
185
Peter Hurley24a89d12013-06-15 09:14:15 -0400186/**
187 * n_tty_set_room - receive space
188 * @tty: terminal
189 *
190 * Re-schedules the flip buffer work if space just became available.
191 *
Peter Hurley6d76bd22013-06-15 09:14:26 -0400192 * Caller holds exclusive termios_rwsem
193 * or
194 * n_tty_read()/consumer path:
195 * holds non-exclusive termios_rwsem
Peter Hurley24a89d12013-06-15 09:14:15 -0400196 */
197
Peter Hurley7879a9f2013-06-15 07:28:31 -0400198static void n_tty_set_room(struct tty_struct *tty)
199{
Peter Hurley24a89d12013-06-15 09:14:15 -0400200 struct n_tty_data *ldata = tty->disc_data;
201
Linus Torvalds55db4c62011-06-04 06:33:24 +0900202 /* Did this open up the receive buffer? We may need to flip */
Peter Hurley24a89d12013-06-15 09:14:15 -0400203 if (unlikely(ldata->no_room) && receive_room(tty)) {
204 ldata->no_room = 0;
205
Jiri Slabyecbbfd42012-10-18 22:26:47 +0200206 WARN_RATELIMIT(tty->port->itty == NULL,
Sasha Levincadf7482012-10-25 14:26:35 -0400207 "scheduling with invalid itty\n");
Peter Hurley21622932013-03-11 16:44:21 -0400208 /* see if ldisc has been killed - if so, this means that
209 * even though the ldisc has been halted and ->buf.work
210 * cancelled, ->buf.work is about to be rescheduled
211 */
212 WARN_RATELIMIT(test_bit(TTY_LDISC_HALTED, &tty->flags),
213 "scheduling buffer work for halted ldisc\n");
Peter Hurleyf0f947c2013-06-15 09:14:36 -0400214 queue_work(system_unbound_wq, &tty->port->buf.work);
Jiri Slabyecbbfd42012-10-18 22:26:47 +0200215 }
Linus Torvalds55db4c62011-06-04 06:33:24 +0900216}
217
Peter Hurley9a4aec22013-06-15 09:14:32 -0400218static ssize_t chars_in_buffer(struct tty_struct *tty)
219{
220 struct n_tty_data *ldata = tty->disc_data;
221 ssize_t n = 0;
222
223 if (!ldata->icanon)
224 n = read_cnt(ldata);
225 else
226 n = ldata->canon_head - ldata->read_tail;
227 return n;
228}
229
Peter Hurleyee0bab82013-06-15 09:14:34 -0400230/**
231 * n_tty_write_wakeup - asynchronous I/O notifier
232 * @tty: tty device
233 *
234 * Required for the ptys, serial driver etc. since processes
235 * that attach themselves to the master and rely on ASYNC
236 * IO must be woken up
237 */
238
239static void n_tty_write_wakeup(struct tty_struct *tty)
240{
241 if (tty->fasync && test_and_clear_bit(TTY_DO_WRITE_WAKEUP, &tty->flags))
242 kill_fasync(&tty->fasync, SIGIO, POLL_OUT);
243}
244
Peter Hurley6367ca72013-06-15 09:14:33 -0400245static inline void n_tty_check_throttle(struct tty_struct *tty)
246{
Peter Hurley3afb1b392013-07-23 08:47:30 -0400247 if (tty->driver->type == TTY_DRIVER_TYPE_PTY)
248 return;
Peter Hurley6367ca72013-06-15 09:14:33 -0400249 /*
250 * Check the remaining room for the input canonicalization
251 * mode. We don't want to throttle the driver if we're in
252 * canonical mode and don't have a newline yet!
253 */
254 while (1) {
255 int throttled;
256 tty_set_flow_change(tty, TTY_THROTTLE_SAFE);
257 if (receive_room(tty) >= TTY_THRESHOLD_THROTTLE)
258 break;
259 throttled = tty_throttle_safe(tty);
260 if (!throttled)
261 break;
262 }
263 __tty_set_flow_change(tty, 0);
264}
265
266static inline void n_tty_check_unthrottle(struct tty_struct *tty)
267{
Peter Hurley3afb1b392013-07-23 08:47:30 -0400268 if (tty->driver->type == TTY_DRIVER_TYPE_PTY &&
269 tty->link->ldisc->ops->write_wakeup == n_tty_write_wakeup) {
270 if (chars_in_buffer(tty) > TTY_THRESHOLD_UNTHROTTLE)
271 return;
272 if (!tty->count)
273 return;
274 n_tty_set_room(tty);
275 n_tty_write_wakeup(tty->link);
276 wake_up_interruptible_poll(&tty->link->write_wait, POLLOUT);
277 return;
278 }
279
Peter Hurley6367ca72013-06-15 09:14:33 -0400280 /* If there is enough space in the read buffer now, let the
281 * low-level driver know. We use chars_in_buffer() to
282 * check the buffer, as it now knows about canonical mode.
283 * Otherwise, if the driver is throttled and the line is
284 * longer than TTY_THRESHOLD_UNTHROTTLE in canonical mode,
285 * we won't get any more characters.
286 */
287
288 while (1) {
289 int unthrottled;
290 tty_set_flow_change(tty, TTY_UNTHROTTLE_SAFE);
291 if (chars_in_buffer(tty) > TTY_THRESHOLD_UNTHROTTLE)
292 break;
293 if (!tty->count)
294 break;
295 n_tty_set_room(tty);
296 unthrottled = tty_unthrottle_safe(tty);
297 if (!unthrottled)
298 break;
299 }
300 __tty_set_flow_change(tty, 0);
301}
302
Alan Cox17b82062008-10-13 10:45:06 +0100303/**
304 * put_tty_queue - add character to tty
305 * @c: character
Jiri Slaby57c94122012-10-18 22:26:43 +0200306 * @ldata: n_tty data
Alan Cox17b82062008-10-13 10:45:06 +0100307 *
Peter Hurley6d76bd22013-06-15 09:14:26 -0400308 * Add a character to the tty read_buf queue.
309 *
310 * n_tty_receive_buf()/producer path:
311 * caller holds non-exclusive termios_rwsem
312 * modifies read_head
313 *
314 * read_head is only considered 'published' if canonical mode is
315 * not active.
Alan Cox17b82062008-10-13 10:45:06 +0100316 */
317
Jiri Slaby57c94122012-10-18 22:26:43 +0200318static void put_tty_queue(unsigned char c, struct n_tty_data *ldata)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700319{
Peter Hurley6d76bd22013-06-15 09:14:26 -0400320 if (read_cnt(ldata) < N_TTY_BUF_SIZE) {
321 *read_buf_addr(ldata, ldata->read_head) = c;
322 ldata->read_head++;
323 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700324}
325
326/**
Linus Torvalds1da177e2005-04-16 15:20:36 -0700327 * reset_buffer_flags - reset buffer state
328 * @tty: terminal to reset
329 *
Peter Hurley25518c62013-03-11 16:44:31 -0400330 * Reset the read buffer counters and clear the flags.
331 * Called from n_tty_open() and n_tty_flush_buffer().
Alan Cox17b82062008-10-13 10:45:06 +0100332 *
Peter Hurley6d76bd22013-06-15 09:14:26 -0400333 * Locking: caller holds exclusive termios_rwsem
334 * (or locking is not required)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700335 */
Joe Petersona88a69c2009-01-02 13:40:53 +0000336
Peter Hurleyb66f4fa2013-03-11 16:44:32 -0400337static void reset_buffer_flags(struct n_tty_data *ldata)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700338{
Peter Hurleya73d3d62013-06-15 09:14:25 -0400339 ldata->read_head = ldata->canon_head = ldata->read_tail = 0;
Peter Hurley17bd7902013-06-15 10:04:24 -0400340 ldata->echo_head = ldata->echo_tail = ldata->echo_commit = 0;
Peter Hurley40d5e092013-06-15 10:21:17 -0400341 ldata->line_start = 0;
Joe Petersona88a69c2009-01-02 13:40:53 +0000342
Peter Hurleya73d3d62013-06-15 09:14:25 -0400343 ldata->erasing = 0;
Jiri Slaby3fe780b2012-10-18 22:26:40 +0200344 bitmap_zero(ldata->read_flags, N_TTY_BUF_SIZE);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700345}
346
Peter Hurleya30737a2013-03-11 16:44:22 -0400347static void n_tty_packet_mode_flush(struct tty_struct *tty)
348{
349 unsigned long flags;
350
351 spin_lock_irqsave(&tty->ctrl_lock, flags);
352 if (tty->link->packet) {
353 tty->ctrl_status |= TIOCPKT_FLUSHREAD;
354 wake_up_interruptible(&tty->link->read_wait);
355 }
356 spin_unlock_irqrestore(&tty->ctrl_lock, flags);
357}
358
Linus Torvalds1da177e2005-04-16 15:20:36 -0700359/**
360 * n_tty_flush_buffer - clean input queue
361 * @tty: terminal device
362 *
Peter Hurley25518c62013-03-11 16:44:31 -0400363 * Flush the input buffer. Called when the tty layer wants the
364 * buffer flushed (eg at hangup) or when the N_TTY line discipline
365 * internally has to clean the pending queue (for example some signals).
Linus Torvalds1da177e2005-04-16 15:20:36 -0700366 *
Peter Hurley6d76bd22013-06-15 09:14:26 -0400367 * Holds termios_rwsem to exclude producer/consumer while
368 * buffer indices are reset.
369 *
370 * Locking: ctrl_lock, exclusive termios_rwsem
Linus Torvalds1da177e2005-04-16 15:20:36 -0700371 */
Alan Cox4edf1822008-02-08 04:18:44 -0800372
373static void n_tty_flush_buffer(struct tty_struct *tty)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700374{
Peter Hurley6d76bd22013-06-15 09:14:26 -0400375 down_write(&tty->termios_rwsem);
Peter Hurleyb66f4fa2013-03-11 16:44:32 -0400376 reset_buffer_flags(tty->disc_data);
377 n_tty_set_room(tty);
Alan Cox4edf1822008-02-08 04:18:44 -0800378
Peter Hurleya30737a2013-03-11 16:44:22 -0400379 if (tty->link)
380 n_tty_packet_mode_flush(tty);
Peter Hurley6d76bd22013-06-15 09:14:26 -0400381 up_write(&tty->termios_rwsem);
382}
383
Linus Torvalds1da177e2005-04-16 15:20:36 -0700384/**
385 * n_tty_chars_in_buffer - report available bytes
386 * @tty: tty device
387 *
388 * Report the number of characters buffered to be delivered to user
Alan Cox4edf1822008-02-08 04:18:44 -0800389 * at this instant in time.
Alan Cox17b82062008-10-13 10:45:06 +0100390 *
Peter Hurley6d76bd22013-06-15 09:14:26 -0400391 * Locking: exclusive termios_rwsem
Linus Torvalds1da177e2005-04-16 15:20:36 -0700392 */
Alan Cox4edf1822008-02-08 04:18:44 -0800393
Peter Hurleya19d0c62013-06-15 09:14:18 -0400394static ssize_t n_tty_chars_in_buffer(struct tty_struct *tty)
395{
Peter Hurley6d76bd22013-06-15 09:14:26 -0400396 ssize_t n;
397
Peter Hurley47534082013-06-15 09:14:19 -0400398 WARN_ONCE(1, "%s is deprecated and scheduled for removal.", __func__);
Peter Hurley6d76bd22013-06-15 09:14:26 -0400399
400 down_write(&tty->termios_rwsem);
401 n = chars_in_buffer(tty);
402 up_write(&tty->termios_rwsem);
403 return n;
Peter Hurleya19d0c62013-06-15 09:14:18 -0400404}
405
Linus Torvalds1da177e2005-04-16 15:20:36 -0700406/**
407 * is_utf8_continuation - utf8 multibyte check
408 * @c: byte to check
409 *
410 * Returns true if the utf8 character 'c' is a multibyte continuation
411 * character. We use this to correctly compute the on screen size
412 * of the character when printing
413 */
Alan Cox4edf1822008-02-08 04:18:44 -0800414
Linus Torvalds1da177e2005-04-16 15:20:36 -0700415static inline int is_utf8_continuation(unsigned char c)
416{
417 return (c & 0xc0) == 0x80;
418}
419
420/**
421 * is_continuation - multibyte check
422 * @c: byte to check
423 *
424 * Returns true if the utf8 character 'c' is a multibyte continuation
425 * character and the terminal is in unicode mode.
426 */
Alan Cox4edf1822008-02-08 04:18:44 -0800427
Linus Torvalds1da177e2005-04-16 15:20:36 -0700428static inline int is_continuation(unsigned char c, struct tty_struct *tty)
429{
430 return I_IUTF8(tty) && is_utf8_continuation(c);
431}
432
433/**
Joe Petersona88a69c2009-01-02 13:40:53 +0000434 * do_output_char - output one character
435 * @c: character (or partial unicode symbol)
436 * @tty: terminal device
437 * @space: space available in tty driver write buffer
438 *
439 * This is a helper function that handles one output character
440 * (including special characters like TAB, CR, LF, etc.),
Joe Petersonee5aa7b2009-09-09 15:03:13 -0600441 * doing OPOST processing and putting the results in the
442 * tty driver's write buffer.
Joe Petersona88a69c2009-01-02 13:40:53 +0000443 *
444 * Note that Linux currently ignores TABDLY, CRDLY, VTDLY, FFDLY
445 * and NLDLY. They simply aren't relevant in the world today.
446 * If you ever need them, add them here.
447 *
448 * Returns the number of bytes of buffer space used or -1 if
449 * no space left.
450 *
451 * Locking: should be called under the output_lock to protect
452 * the column state and space left in the buffer
453 */
454
455static int do_output_char(unsigned char c, struct tty_struct *tty, int space)
456{
Jiri Slaby53c5ee22012-10-18 22:26:39 +0200457 struct n_tty_data *ldata = tty->disc_data;
Joe Petersona88a69c2009-01-02 13:40:53 +0000458 int spaces;
459
460 if (!space)
461 return -1;
Alan Cox300a6202009-01-02 13:41:04 +0000462
Joe Petersona88a69c2009-01-02 13:40:53 +0000463 switch (c) {
464 case '\n':
465 if (O_ONLRET(tty))
Jiri Slaby53c5ee22012-10-18 22:26:39 +0200466 ldata->column = 0;
Joe Petersona88a69c2009-01-02 13:40:53 +0000467 if (O_ONLCR(tty)) {
468 if (space < 2)
469 return -1;
Jiri Slabyba2e68a2012-10-18 22:26:41 +0200470 ldata->canon_column = ldata->column = 0;
Linus Torvalds37f81fa2009-09-05 12:46:07 -0700471 tty->ops->write(tty, "\r\n", 2);
Joe Petersona88a69c2009-01-02 13:40:53 +0000472 return 2;
473 }
Jiri Slabyba2e68a2012-10-18 22:26:41 +0200474 ldata->canon_column = ldata->column;
Joe Petersona88a69c2009-01-02 13:40:53 +0000475 break;
476 case '\r':
Jiri Slaby53c5ee22012-10-18 22:26:39 +0200477 if (O_ONOCR(tty) && ldata->column == 0)
Joe Petersona88a69c2009-01-02 13:40:53 +0000478 return 0;
479 if (O_OCRNL(tty)) {
480 c = '\n';
481 if (O_ONLRET(tty))
Jiri Slabyba2e68a2012-10-18 22:26:41 +0200482 ldata->canon_column = ldata->column = 0;
Joe Petersona88a69c2009-01-02 13:40:53 +0000483 break;
484 }
Jiri Slabyba2e68a2012-10-18 22:26:41 +0200485 ldata->canon_column = ldata->column = 0;
Joe Petersona88a69c2009-01-02 13:40:53 +0000486 break;
487 case '\t':
Jiri Slaby53c5ee22012-10-18 22:26:39 +0200488 spaces = 8 - (ldata->column & 7);
Joe Petersona88a69c2009-01-02 13:40:53 +0000489 if (O_TABDLY(tty) == XTABS) {
490 if (space < spaces)
491 return -1;
Jiri Slaby53c5ee22012-10-18 22:26:39 +0200492 ldata->column += spaces;
Joe Petersona88a69c2009-01-02 13:40:53 +0000493 tty->ops->write(tty, " ", spaces);
494 return spaces;
495 }
Jiri Slaby53c5ee22012-10-18 22:26:39 +0200496 ldata->column += spaces;
Joe Petersona88a69c2009-01-02 13:40:53 +0000497 break;
498 case '\b':
Jiri Slaby53c5ee22012-10-18 22:26:39 +0200499 if (ldata->column > 0)
500 ldata->column--;
Joe Petersona88a69c2009-01-02 13:40:53 +0000501 break;
502 default:
Joe Petersona59c0d62009-01-02 13:43:25 +0000503 if (!iscntrl(c)) {
504 if (O_OLCUC(tty))
505 c = toupper(c);
506 if (!is_continuation(c, tty))
Jiri Slaby53c5ee22012-10-18 22:26:39 +0200507 ldata->column++;
Joe Petersona59c0d62009-01-02 13:43:25 +0000508 }
Joe Petersona88a69c2009-01-02 13:40:53 +0000509 break;
510 }
511
512 tty_put_char(tty, c);
513 return 1;
514}
515
516/**
517 * process_output - output post processor
Linus Torvalds1da177e2005-04-16 15:20:36 -0700518 * @c: character (or partial unicode symbol)
519 * @tty: terminal device
520 *
Joe Petersonee5aa7b2009-09-09 15:03:13 -0600521 * Output one character with OPOST processing.
522 * Returns -1 when the output device is full and the character
523 * must be retried.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700524 *
Joe Petersona88a69c2009-01-02 13:40:53 +0000525 * Locking: output_lock to protect column state and space left
526 * (also, this is called from n_tty_write under the
527 * tty layer write lock)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700528 */
Alan Cox4edf1822008-02-08 04:18:44 -0800529
Joe Petersona88a69c2009-01-02 13:40:53 +0000530static int process_output(unsigned char c, struct tty_struct *tty)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700531{
Jiri Slabybddc7152012-10-18 22:26:42 +0200532 struct n_tty_data *ldata = tty->disc_data;
Joe Petersona88a69c2009-01-02 13:40:53 +0000533 int space, retval;
534
Jiri Slabybddc7152012-10-18 22:26:42 +0200535 mutex_lock(&ldata->output_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700536
Alan Coxf34d7a52008-04-30 00:54:13 -0700537 space = tty_write_room(tty);
Joe Petersona88a69c2009-01-02 13:40:53 +0000538 retval = do_output_char(c, tty, space);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700539
Jiri Slabybddc7152012-10-18 22:26:42 +0200540 mutex_unlock(&ldata->output_lock);
Joe Petersona88a69c2009-01-02 13:40:53 +0000541 if (retval < 0)
542 return -1;
543 else
544 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700545}
546
547/**
Joe Petersona88a69c2009-01-02 13:40:53 +0000548 * process_output_block - block post processor
Linus Torvalds1da177e2005-04-16 15:20:36 -0700549 * @tty: terminal device
Joe Petersonee5aa7b2009-09-09 15:03:13 -0600550 * @buf: character buffer
551 * @nr: number of bytes to output
552 *
553 * Output a block of characters with OPOST processing.
554 * Returns the number of characters output.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700555 *
556 * This path is used to speed up block console writes, among other
557 * things when processing blocks of output data. It handles only
558 * the simple cases normally found and helps to generate blocks of
559 * symbols for the console driver and thus improve performance.
560 *
Joe Petersona88a69c2009-01-02 13:40:53 +0000561 * Locking: output_lock to protect column state and space left
562 * (also, this is called from n_tty_write under the
563 * tty layer write lock)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700564 */
Alan Cox4edf1822008-02-08 04:18:44 -0800565
Joe Petersona88a69c2009-01-02 13:40:53 +0000566static ssize_t process_output_block(struct tty_struct *tty,
567 const unsigned char *buf, unsigned int nr)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700568{
Jiri Slaby53c5ee22012-10-18 22:26:39 +0200569 struct n_tty_data *ldata = tty->disc_data;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700570 int space;
Thorsten Wißmannbbd20752011-12-08 17:47:33 +0100571 int i;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700572 const unsigned char *cp;
573
Jiri Slabybddc7152012-10-18 22:26:42 +0200574 mutex_lock(&ldata->output_lock);
Joe Petersona88a69c2009-01-02 13:40:53 +0000575
Alan Coxf34d7a52008-04-30 00:54:13 -0700576 space = tty_write_room(tty);
Alan Cox300a6202009-01-02 13:41:04 +0000577 if (!space) {
Jiri Slabybddc7152012-10-18 22:26:42 +0200578 mutex_unlock(&ldata->output_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700579 return 0;
Joe Petersona88a69c2009-01-02 13:40:53 +0000580 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700581 if (nr > space)
582 nr = space;
583
584 for (i = 0, cp = buf; i < nr; i++, cp++) {
Joe Petersona59c0d62009-01-02 13:43:25 +0000585 unsigned char c = *cp;
586
587 switch (c) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700588 case '\n':
589 if (O_ONLRET(tty))
Jiri Slaby53c5ee22012-10-18 22:26:39 +0200590 ldata->column = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700591 if (O_ONLCR(tty))
592 goto break_out;
Jiri Slabyba2e68a2012-10-18 22:26:41 +0200593 ldata->canon_column = ldata->column;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700594 break;
595 case '\r':
Jiri Slaby53c5ee22012-10-18 22:26:39 +0200596 if (O_ONOCR(tty) && ldata->column == 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700597 goto break_out;
598 if (O_OCRNL(tty))
599 goto break_out;
Jiri Slabyba2e68a2012-10-18 22:26:41 +0200600 ldata->canon_column = ldata->column = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700601 break;
602 case '\t':
603 goto break_out;
604 case '\b':
Jiri Slaby53c5ee22012-10-18 22:26:39 +0200605 if (ldata->column > 0)
606 ldata->column--;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700607 break;
608 default:
Joe Petersona59c0d62009-01-02 13:43:25 +0000609 if (!iscntrl(c)) {
610 if (O_OLCUC(tty))
611 goto break_out;
612 if (!is_continuation(c, tty))
Jiri Slaby53c5ee22012-10-18 22:26:39 +0200613 ldata->column++;
Joe Petersona59c0d62009-01-02 13:43:25 +0000614 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700615 break;
616 }
617 }
618break_out:
Alan Coxf34d7a52008-04-30 00:54:13 -0700619 i = tty->ops->write(tty, buf, i);
Joe Petersona88a69c2009-01-02 13:40:53 +0000620
Jiri Slabybddc7152012-10-18 22:26:42 +0200621 mutex_unlock(&ldata->output_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700622 return i;
623}
624
Joe Petersona88a69c2009-01-02 13:40:53 +0000625/**
626 * process_echoes - write pending echo characters
627 * @tty: terminal device
628 *
629 * Write previously buffered echo (and other ldisc-generated)
630 * characters to the tty.
631 *
632 * Characters generated by the ldisc (including echoes) need to
633 * be buffered because the driver's write buffer can fill during
634 * heavy program output. Echoing straight to the driver will
635 * often fail under these conditions, causing lost characters and
636 * resulting mismatches of ldisc state information.
637 *
638 * Since the ldisc state must represent the characters actually sent
639 * to the driver at the time of the write, operations like certain
640 * changes in column state are also saved in the buffer and executed
641 * here.
642 *
643 * A circular fifo buffer is used so that the most recent characters
644 * are prioritized. Also, when control characters are echoed with a
645 * prefixed "^", the pair is treated atomically and thus not separated.
646 *
Peter Hurley019ebdf2013-06-15 10:04:25 -0400647 * Locking: callers must hold output_lock
Joe Petersona88a69c2009-01-02 13:40:53 +0000648 */
649
Peter Hurleybc5b1ec2013-06-15 10:04:27 -0400650static size_t __process_echoes(struct tty_struct *tty)
Joe Petersona88a69c2009-01-02 13:40:53 +0000651{
Jiri Slaby53c5ee22012-10-18 22:26:39 +0200652 struct n_tty_data *ldata = tty->disc_data;
Peter Hurleybc5b1ec2013-06-15 10:04:27 -0400653 int space, old_space;
Peter Hurleyaddaebc2013-06-15 10:04:22 -0400654 size_t tail;
Joe Petersona88a69c2009-01-02 13:40:53 +0000655 unsigned char c;
Joe Petersona88a69c2009-01-02 13:40:53 +0000656
Peter Hurleybc5b1ec2013-06-15 10:04:27 -0400657 old_space = space = tty_write_room(tty);
Joe Petersona88a69c2009-01-02 13:40:53 +0000658
Peter Hurleyaddaebc2013-06-15 10:04:22 -0400659 tail = ldata->echo_tail;
Peter Hurley29c7c5c2013-06-15 10:04:28 -0400660 while (ldata->echo_commit != tail) {
Peter Hurleyaddaebc2013-06-15 10:04:22 -0400661 c = echo_buf(ldata, tail);
Joe Petersona88a69c2009-01-02 13:40:53 +0000662 if (c == ECHO_OP_START) {
663 unsigned char op;
Joe Petersona88a69c2009-01-02 13:40:53 +0000664 int no_space_left = 0;
665
666 /*
667 * If the buffer byte is the start of a multi-byte
668 * operation, get the next byte, which is either the
669 * op code or a control character value.
670 */
Peter Hurleyaddaebc2013-06-15 10:04:22 -0400671 op = echo_buf(ldata, tail + 1);
Alan Cox300a6202009-01-02 13:41:04 +0000672
Joe Petersona88a69c2009-01-02 13:40:53 +0000673 switch (op) {
674 unsigned int num_chars, num_bs;
675
676 case ECHO_OP_ERASE_TAB:
Peter Hurleyaddaebc2013-06-15 10:04:22 -0400677 num_chars = echo_buf(ldata, tail + 2);
Joe Petersona88a69c2009-01-02 13:40:53 +0000678
679 /*
680 * Determine how many columns to go back
681 * in order to erase the tab.
682 * This depends on the number of columns
683 * used by other characters within the tab
684 * area. If this (modulo 8) count is from
685 * the start of input rather than from a
686 * previous tab, we offset by canon column.
687 * Otherwise, tab spacing is normal.
688 */
689 if (!(num_chars & 0x80))
Jiri Slabyba2e68a2012-10-18 22:26:41 +0200690 num_chars += ldata->canon_column;
Joe Petersona88a69c2009-01-02 13:40:53 +0000691 num_bs = 8 - (num_chars & 7);
692
693 if (num_bs > space) {
694 no_space_left = 1;
695 break;
696 }
697 space -= num_bs;
698 while (num_bs--) {
699 tty_put_char(tty, '\b');
Jiri Slaby53c5ee22012-10-18 22:26:39 +0200700 if (ldata->column > 0)
701 ldata->column--;
Joe Petersona88a69c2009-01-02 13:40:53 +0000702 }
Peter Hurleyaddaebc2013-06-15 10:04:22 -0400703 tail += 3;
Joe Petersona88a69c2009-01-02 13:40:53 +0000704 break;
705
706 case ECHO_OP_SET_CANON_COL:
Jiri Slabyba2e68a2012-10-18 22:26:41 +0200707 ldata->canon_column = ldata->column;
Peter Hurleyaddaebc2013-06-15 10:04:22 -0400708 tail += 2;
Joe Petersona88a69c2009-01-02 13:40:53 +0000709 break;
710
711 case ECHO_OP_MOVE_BACK_COL:
Jiri Slaby53c5ee22012-10-18 22:26:39 +0200712 if (ldata->column > 0)
713 ldata->column--;
Peter Hurleyaddaebc2013-06-15 10:04:22 -0400714 tail += 2;
Joe Petersona88a69c2009-01-02 13:40:53 +0000715 break;
716
717 case ECHO_OP_START:
718 /* This is an escaped echo op start code */
719 if (!space) {
720 no_space_left = 1;
721 break;
722 }
723 tty_put_char(tty, ECHO_OP_START);
Jiri Slaby53c5ee22012-10-18 22:26:39 +0200724 ldata->column++;
Joe Petersona88a69c2009-01-02 13:40:53 +0000725 space--;
Peter Hurleyaddaebc2013-06-15 10:04:22 -0400726 tail += 2;
Joe Petersona88a69c2009-01-02 13:40:53 +0000727 break;
728
729 default:
Joe Petersona88a69c2009-01-02 13:40:53 +0000730 /*
Joe Peterson62b26352009-09-09 15:03:47 -0600731 * If the op is not a special byte code,
732 * it is a ctrl char tagged to be echoed
733 * as "^X" (where X is the letter
734 * representing the control char).
735 * Note that we must ensure there is
736 * enough space for the whole ctrl pair.
737 *
Joe Petersona88a69c2009-01-02 13:40:53 +0000738 */
Joe Peterson62b26352009-09-09 15:03:47 -0600739 if (space < 2) {
740 no_space_left = 1;
741 break;
742 }
743 tty_put_char(tty, '^');
744 tty_put_char(tty, op ^ 0100);
Jiri Slaby53c5ee22012-10-18 22:26:39 +0200745 ldata->column += 2;
Joe Peterson62b26352009-09-09 15:03:47 -0600746 space -= 2;
Peter Hurleyaddaebc2013-06-15 10:04:22 -0400747 tail += 2;
Joe Petersona88a69c2009-01-02 13:40:53 +0000748 }
749
750 if (no_space_left)
751 break;
752 } else {
Peter Hurley582f5592013-05-17 12:49:48 -0400753 if (O_OPOST(tty)) {
Joe Petersonee5aa7b2009-09-09 15:03:13 -0600754 int retval = do_output_char(c, tty, space);
755 if (retval < 0)
756 break;
757 space -= retval;
758 } else {
759 if (!space)
760 break;
761 tty_put_char(tty, c);
762 space -= 1;
763 }
Peter Hurleyaddaebc2013-06-15 10:04:22 -0400764 tail += 1;
Joe Petersona88a69c2009-01-02 13:40:53 +0000765 }
Joe Petersona88a69c2009-01-02 13:40:53 +0000766 }
767
Peter Hurleycbfd0342013-06-15 10:04:26 -0400768 /* If the echo buffer is nearly full (so that the possibility exists
769 * of echo overrun before the next commit), then discard enough
770 * data at the tail to prevent a subsequent overrun */
771 while (ldata->echo_commit - tail >= ECHO_DISCARD_WATERMARK) {
772 if (echo_buf(ldata, tail == ECHO_OP_START)) {
773 if (echo_buf(ldata, tail) == ECHO_OP_ERASE_TAB)
774 tail += 3;
775 else
776 tail += 2;
777 } else
778 tail++;
779 }
780
Peter Hurleyaddaebc2013-06-15 10:04:22 -0400781 ldata->echo_tail = tail;
Peter Hurleybc5b1ec2013-06-15 10:04:27 -0400782 return old_space - space;
Joe Petersona88a69c2009-01-02 13:40:53 +0000783}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700784
Peter Hurley17bd7902013-06-15 10:04:24 -0400785static void commit_echoes(struct tty_struct *tty)
786{
787 struct n_tty_data *ldata = tty->disc_data;
Peter Hurleybc5b1ec2013-06-15 10:04:27 -0400788 size_t nr, old, echoed;
Peter Hurleycbfd0342013-06-15 10:04:26 -0400789 size_t head;
790
791 head = ldata->echo_head;
792 old = ldata->echo_commit - ldata->echo_tail;
793
794 /* Process committed echoes if the accumulated # of bytes
795 * is over the threshold (and try again each time another
796 * block is accumulated) */
797 nr = head - ldata->echo_tail;
798 if (nr < ECHO_COMMIT_WATERMARK || (nr % ECHO_BLOCK > old % ECHO_BLOCK))
799 return;
Peter Hurley17bd7902013-06-15 10:04:24 -0400800
Peter Hurley019ebdf2013-06-15 10:04:25 -0400801 mutex_lock(&ldata->output_lock);
Peter Hurleycbfd0342013-06-15 10:04:26 -0400802 ldata->echo_commit = head;
Peter Hurleybc5b1ec2013-06-15 10:04:27 -0400803 echoed = __process_echoes(tty);
Peter Hurley019ebdf2013-06-15 10:04:25 -0400804 mutex_unlock(&ldata->output_lock);
805
Peter Hurleybc5b1ec2013-06-15 10:04:27 -0400806 if (echoed && tty->ops->flush_chars)
Peter Hurley019ebdf2013-06-15 10:04:25 -0400807 tty->ops->flush_chars(tty);
808}
809
810static void process_echoes(struct tty_struct *tty)
811{
812 struct n_tty_data *ldata = tty->disc_data;
Peter Hurleybc5b1ec2013-06-15 10:04:27 -0400813 size_t echoed;
Peter Hurley019ebdf2013-06-15 10:04:25 -0400814
815 if (!L_ECHO(tty) || ldata->echo_commit == ldata->echo_tail)
816 return;
817
818 mutex_lock(&ldata->output_lock);
Peter Hurleybc5b1ec2013-06-15 10:04:27 -0400819 echoed = __process_echoes(tty);
Peter Hurley019ebdf2013-06-15 10:04:25 -0400820 mutex_unlock(&ldata->output_lock);
821
Peter Hurleybc5b1ec2013-06-15 10:04:27 -0400822 if (echoed && tty->ops->flush_chars)
Peter Hurley019ebdf2013-06-15 10:04:25 -0400823 tty->ops->flush_chars(tty);
Peter Hurley17bd7902013-06-15 10:04:24 -0400824}
825
Peter Hurleycbfd0342013-06-15 10:04:26 -0400826static void flush_echoes(struct tty_struct *tty)
827{
828 struct n_tty_data *ldata = tty->disc_data;
829
830 if (!L_ECHO(tty) || ldata->echo_commit == ldata->echo_head)
831 return;
832
833 mutex_lock(&ldata->output_lock);
834 ldata->echo_commit = ldata->echo_head;
835 __process_echoes(tty);
836 mutex_unlock(&ldata->output_lock);
837}
838
Linus Torvalds1da177e2005-04-16 15:20:36 -0700839/**
Joe Petersona88a69c2009-01-02 13:40:53 +0000840 * add_echo_byte - add a byte to the echo buffer
841 * @c: unicode byte to echo
Jiri Slaby57c94122012-10-18 22:26:43 +0200842 * @ldata: n_tty data
Joe Petersona88a69c2009-01-02 13:40:53 +0000843 *
844 * Add a character or operation byte to the echo buffer.
Joe Petersona88a69c2009-01-02 13:40:53 +0000845 */
846
Peter Hurleycbfd0342013-06-15 10:04:26 -0400847static inline void add_echo_byte(unsigned char c, struct n_tty_data *ldata)
Joe Petersona88a69c2009-01-02 13:40:53 +0000848{
Peter Hurleyaddaebc2013-06-15 10:04:22 -0400849 *echo_buf_addr(ldata, ldata->echo_head++) = c;
Joe Petersona88a69c2009-01-02 13:40:53 +0000850}
851
852/**
853 * echo_move_back_col - add operation to move back a column
Jiri Slaby57c94122012-10-18 22:26:43 +0200854 * @ldata: n_tty data
Joe Petersona88a69c2009-01-02 13:40:53 +0000855 *
856 * Add an operation to the echo buffer to move back one column.
Joe Petersona88a69c2009-01-02 13:40:53 +0000857 */
858
Jiri Slaby57c94122012-10-18 22:26:43 +0200859static void echo_move_back_col(struct n_tty_data *ldata)
Joe Petersona88a69c2009-01-02 13:40:53 +0000860{
Jiri Slaby57c94122012-10-18 22:26:43 +0200861 add_echo_byte(ECHO_OP_START, ldata);
862 add_echo_byte(ECHO_OP_MOVE_BACK_COL, ldata);
Joe Petersona88a69c2009-01-02 13:40:53 +0000863}
864
865/**
866 * echo_set_canon_col - add operation to set the canon column
Jiri Slaby57c94122012-10-18 22:26:43 +0200867 * @ldata: n_tty data
Joe Petersona88a69c2009-01-02 13:40:53 +0000868 *
869 * Add an operation to the echo buffer to set the canon column
870 * to the current column.
Joe Petersona88a69c2009-01-02 13:40:53 +0000871 */
872
Jiri Slaby57c94122012-10-18 22:26:43 +0200873static void echo_set_canon_col(struct n_tty_data *ldata)
Joe Petersona88a69c2009-01-02 13:40:53 +0000874{
Jiri Slaby57c94122012-10-18 22:26:43 +0200875 add_echo_byte(ECHO_OP_START, ldata);
876 add_echo_byte(ECHO_OP_SET_CANON_COL, ldata);
Joe Petersona88a69c2009-01-02 13:40:53 +0000877}
878
879/**
880 * echo_erase_tab - add operation to erase a tab
881 * @num_chars: number of character columns already used
882 * @after_tab: true if num_chars starts after a previous tab
Jiri Slaby57c94122012-10-18 22:26:43 +0200883 * @ldata: n_tty data
Joe Petersona88a69c2009-01-02 13:40:53 +0000884 *
885 * Add an operation to the echo buffer to erase a tab.
886 *
887 * Called by the eraser function, which knows how many character
888 * columns have been used since either a previous tab or the start
889 * of input. This information will be used later, along with
890 * canon column (if applicable), to go back the correct number
891 * of columns.
Joe Petersona88a69c2009-01-02 13:40:53 +0000892 */
893
894static void echo_erase_tab(unsigned int num_chars, int after_tab,
Jiri Slaby57c94122012-10-18 22:26:43 +0200895 struct n_tty_data *ldata)
Joe Petersona88a69c2009-01-02 13:40:53 +0000896{
Jiri Slaby57c94122012-10-18 22:26:43 +0200897 add_echo_byte(ECHO_OP_START, ldata);
898 add_echo_byte(ECHO_OP_ERASE_TAB, ldata);
Joe Petersona88a69c2009-01-02 13:40:53 +0000899
900 /* We only need to know this modulo 8 (tab spacing) */
901 num_chars &= 7;
902
903 /* Set the high bit as a flag if num_chars is after a previous tab */
904 if (after_tab)
905 num_chars |= 0x80;
Alan Cox300a6202009-01-02 13:41:04 +0000906
Jiri Slaby57c94122012-10-18 22:26:43 +0200907 add_echo_byte(num_chars, ldata);
Joe Petersona88a69c2009-01-02 13:40:53 +0000908}
909
910/**
911 * echo_char_raw - echo a character raw
Linus Torvalds1da177e2005-04-16 15:20:36 -0700912 * @c: unicode byte to echo
913 * @tty: terminal device
914 *
Alan Cox4edf1822008-02-08 04:18:44 -0800915 * Echo user input back onto the screen. This must be called only when
Linus Torvalds1da177e2005-04-16 15:20:36 -0700916 * L_ECHO(tty) is true. Called from the driver receive_buf path.
Alan Cox17b82062008-10-13 10:45:06 +0100917 *
Joe Petersona88a69c2009-01-02 13:40:53 +0000918 * This variant does not treat control characters specially.
Joe Petersona88a69c2009-01-02 13:40:53 +0000919 */
920
Jiri Slaby57c94122012-10-18 22:26:43 +0200921static void echo_char_raw(unsigned char c, struct n_tty_data *ldata)
Joe Petersona88a69c2009-01-02 13:40:53 +0000922{
Joe Petersona88a69c2009-01-02 13:40:53 +0000923 if (c == ECHO_OP_START) {
Jiri Slaby57c94122012-10-18 22:26:43 +0200924 add_echo_byte(ECHO_OP_START, ldata);
925 add_echo_byte(ECHO_OP_START, ldata);
Joe Petersona88a69c2009-01-02 13:40:53 +0000926 } else {
Jiri Slaby57c94122012-10-18 22:26:43 +0200927 add_echo_byte(c, ldata);
Joe Petersona88a69c2009-01-02 13:40:53 +0000928 }
Joe Petersona88a69c2009-01-02 13:40:53 +0000929}
930
931/**
932 * echo_char - echo a character
933 * @c: unicode byte to echo
934 * @tty: terminal device
935 *
936 * Echo user input back onto the screen. This must be called only when
937 * L_ECHO(tty) is true. Called from the driver receive_buf path.
938 *
Joe Peterson62b26352009-09-09 15:03:47 -0600939 * This variant tags control characters to be echoed as "^X"
940 * (where X is the letter representing the control char).
Linus Torvalds1da177e2005-04-16 15:20:36 -0700941 */
942
943static void echo_char(unsigned char c, struct tty_struct *tty)
944{
Jiri Slabybddc7152012-10-18 22:26:42 +0200945 struct n_tty_data *ldata = tty->disc_data;
946
Joe Petersona88a69c2009-01-02 13:40:53 +0000947 if (c == ECHO_OP_START) {
Jiri Slaby57c94122012-10-18 22:26:43 +0200948 add_echo_byte(ECHO_OP_START, ldata);
949 add_echo_byte(ECHO_OP_START, ldata);
Joe Petersona88a69c2009-01-02 13:40:53 +0000950 } else {
Joe Peterson62b26352009-09-09 15:03:47 -0600951 if (L_ECHOCTL(tty) && iscntrl(c) && c != '\t')
Jiri Slaby57c94122012-10-18 22:26:43 +0200952 add_echo_byte(ECHO_OP_START, ldata);
953 add_echo_byte(c, ldata);
Joe Petersona88a69c2009-01-02 13:40:53 +0000954 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700955}
956
Alan Cox17b82062008-10-13 10:45:06 +0100957/**
Joe Petersona88a69c2009-01-02 13:40:53 +0000958 * finish_erasing - complete erase
Jiri Slaby57c94122012-10-18 22:26:43 +0200959 * @ldata: n_tty data
Alan Cox17b82062008-10-13 10:45:06 +0100960 */
Joe Petersona88a69c2009-01-02 13:40:53 +0000961
Jiri Slaby57c94122012-10-18 22:26:43 +0200962static inline void finish_erasing(struct n_tty_data *ldata)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700963{
Jiri Slaby53c5ee22012-10-18 22:26:39 +0200964 if (ldata->erasing) {
Jiri Slaby57c94122012-10-18 22:26:43 +0200965 echo_char_raw('/', ldata);
Jiri Slaby53c5ee22012-10-18 22:26:39 +0200966 ldata->erasing = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700967 }
968}
969
970/**
971 * eraser - handle erase function
972 * @c: character input
973 * @tty: terminal device
974 *
Robert P. J. Day3a4fa0a2007-10-19 23:10:43 +0200975 * Perform erase and necessary output when an erase character is
Linus Torvalds1da177e2005-04-16 15:20:36 -0700976 * present in the stream from the driver layer. Handles the complexities
977 * of UTF-8 multibyte symbols.
Alan Cox17b82062008-10-13 10:45:06 +0100978 *
Peter Hurley6d76bd22013-06-15 09:14:26 -0400979 * n_tty_receive_buf()/producer path:
980 * caller holds non-exclusive termios_rwsem
981 * modifies read_head
982 *
983 * Modifying the read_head is not considered a publish in this context
984 * because canonical mode is active -- only canon_head publishes
Linus Torvalds1da177e2005-04-16 15:20:36 -0700985 */
Alan Cox4edf1822008-02-08 04:18:44 -0800986
Linus Torvalds1da177e2005-04-16 15:20:36 -0700987static void eraser(unsigned char c, struct tty_struct *tty)
988{
Jiri Slaby53c5ee22012-10-18 22:26:39 +0200989 struct n_tty_data *ldata = tty->disc_data;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700990 enum { ERASE, WERASE, KILL } kill_type;
Peter Hurleybc5a5e32013-06-15 09:14:21 -0400991 size_t head;
992 size_t cnt;
993 int seen_alnums;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700994
Jiri Slabyba2e68a2012-10-18 22:26:41 +0200995 if (ldata->read_head == ldata->canon_head) {
Joe Peterson7e94b1d2009-01-02 13:43:40 +0000996 /* process_output('\a', tty); */ /* what do you think? */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700997 return;
998 }
999 if (c == ERASE_CHAR(tty))
1000 kill_type = ERASE;
1001 else if (c == WERASE_CHAR(tty))
1002 kill_type = WERASE;
1003 else {
1004 if (!L_ECHO(tty)) {
Jiri Slabyba2e68a2012-10-18 22:26:41 +02001005 ldata->read_head = ldata->canon_head;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001006 return;
1007 }
1008 if (!L_ECHOK(tty) || !L_ECHOKE(tty) || !L_ECHOE(tty)) {
Jiri Slabyba2e68a2012-10-18 22:26:41 +02001009 ldata->read_head = ldata->canon_head;
Jiri Slaby57c94122012-10-18 22:26:43 +02001010 finish_erasing(ldata);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001011 echo_char(KILL_CHAR(tty), tty);
1012 /* Add a newline if ECHOK is on and ECHOKE is off. */
1013 if (L_ECHOK(tty))
Jiri Slaby57c94122012-10-18 22:26:43 +02001014 echo_char_raw('\n', ldata);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001015 return;
1016 }
1017 kill_type = KILL;
1018 }
1019
1020 seen_alnums = 0;
Jiri Slabyba2e68a2012-10-18 22:26:41 +02001021 while (ldata->read_head != ldata->canon_head) {
1022 head = ldata->read_head;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001023
1024 /* erase a single possibly multibyte character */
1025 do {
Peter Hurleybc5a5e32013-06-15 09:14:21 -04001026 head--;
1027 c = read_buf(ldata, head);
Jiri Slabyba2e68a2012-10-18 22:26:41 +02001028 } while (is_continuation(c, tty) && head != ldata->canon_head);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001029
1030 /* do not partially erase */
1031 if (is_continuation(c, tty))
1032 break;
1033
1034 if (kill_type == WERASE) {
1035 /* Equivalent to BSD's ALTWERASE. */
1036 if (isalnum(c) || c == '_')
1037 seen_alnums++;
1038 else if (seen_alnums)
1039 break;
1040 }
Peter Hurleybc5a5e32013-06-15 09:14:21 -04001041 cnt = ldata->read_head - head;
Jiri Slabyba2e68a2012-10-18 22:26:41 +02001042 ldata->read_head = head;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001043 if (L_ECHO(tty)) {
1044 if (L_ECHOPRT(tty)) {
Jiri Slaby53c5ee22012-10-18 22:26:39 +02001045 if (!ldata->erasing) {
Jiri Slaby57c94122012-10-18 22:26:43 +02001046 echo_char_raw('\\', ldata);
Jiri Slaby53c5ee22012-10-18 22:26:39 +02001047 ldata->erasing = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001048 }
1049 /* if cnt > 1, output a multi-byte character */
1050 echo_char(c, tty);
1051 while (--cnt > 0) {
Peter Hurleybc5a5e32013-06-15 09:14:21 -04001052 head++;
1053 echo_char_raw(read_buf(ldata, head), ldata);
Jiri Slaby57c94122012-10-18 22:26:43 +02001054 echo_move_back_col(ldata);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001055 }
1056 } else if (kill_type == ERASE && !L_ECHOE(tty)) {
1057 echo_char(ERASE_CHAR(tty), tty);
1058 } else if (c == '\t') {
Joe Petersona88a69c2009-01-02 13:40:53 +00001059 unsigned int num_chars = 0;
1060 int after_tab = 0;
Peter Hurleybc5a5e32013-06-15 09:14:21 -04001061 size_t tail = ldata->read_head;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001062
Joe Petersona88a69c2009-01-02 13:40:53 +00001063 /*
1064 * Count the columns used for characters
1065 * since the start of input or after a
1066 * previous tab.
1067 * This info is used to go back the correct
1068 * number of columns.
1069 */
Jiri Slabyba2e68a2012-10-18 22:26:41 +02001070 while (tail != ldata->canon_head) {
Peter Hurleybc5a5e32013-06-15 09:14:21 -04001071 tail--;
1072 c = read_buf(ldata, tail);
Joe Petersona88a69c2009-01-02 13:40:53 +00001073 if (c == '\t') {
1074 after_tab = 1;
1075 break;
Alan Cox300a6202009-01-02 13:41:04 +00001076 } else if (iscntrl(c)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001077 if (L_ECHOCTL(tty))
Joe Petersona88a69c2009-01-02 13:40:53 +00001078 num_chars += 2;
1079 } else if (!is_continuation(c, tty)) {
1080 num_chars++;
1081 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001082 }
Jiri Slaby57c94122012-10-18 22:26:43 +02001083 echo_erase_tab(num_chars, after_tab, ldata);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001084 } else {
1085 if (iscntrl(c) && L_ECHOCTL(tty)) {
Jiri Slaby57c94122012-10-18 22:26:43 +02001086 echo_char_raw('\b', ldata);
1087 echo_char_raw(' ', ldata);
1088 echo_char_raw('\b', ldata);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001089 }
1090 if (!iscntrl(c) || L_ECHOCTL(tty)) {
Jiri Slaby57c94122012-10-18 22:26:43 +02001091 echo_char_raw('\b', ldata);
1092 echo_char_raw(' ', ldata);
1093 echo_char_raw('\b', ldata);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001094 }
1095 }
1096 }
1097 if (kill_type == ERASE)
1098 break;
1099 }
Jiri Slabyba2e68a2012-10-18 22:26:41 +02001100 if (ldata->read_head == ldata->canon_head && L_ECHO(tty))
Jiri Slaby57c94122012-10-18 22:26:43 +02001101 finish_erasing(ldata);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001102}
1103
1104/**
1105 * isig - handle the ISIG optio
1106 * @sig: signal
1107 * @tty: terminal
Linus Torvalds1da177e2005-04-16 15:20:36 -07001108 *
Peter Hurley8c985d12013-03-06 08:38:19 -05001109 * Called when a signal is being sent due to terminal input.
1110 * Called from the driver receive_buf path so serialized.
Alan Cox17b82062008-10-13 10:45:06 +01001111 *
Peter Hurley8c985d12013-03-06 08:38:19 -05001112 * Locking: ctrl_lock
Linus Torvalds1da177e2005-04-16 15:20:36 -07001113 */
Alan Cox4edf1822008-02-08 04:18:44 -08001114
Peter Hurley8c985d12013-03-06 08:38:19 -05001115static inline void isig(int sig, struct tty_struct *tty)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001116{
Peter Hurley8c985d12013-03-06 08:38:19 -05001117 struct pid *tty_pgrp = tty_get_pgrp(tty);
1118 if (tty_pgrp) {
1119 kill_pgrp(tty_pgrp, sig, 1);
1120 put_pid(tty_pgrp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001121 }
1122}
1123
1124/**
1125 * n_tty_receive_break - handle break
1126 * @tty: terminal
1127 *
1128 * An RS232 break event has been hit in the incoming bitstream. This
1129 * can cause a variety of events depending upon the termios settings.
1130 *
Peter Hurley6d76bd22013-06-15 09:14:26 -04001131 * n_tty_receive_buf()/producer path:
1132 * caller holds non-exclusive termios_rwsem
1133 * publishes read_head via put_tty_queue()
1134 *
1135 * Note: may get exclusive termios_rwsem if flushing input buffer
Linus Torvalds1da177e2005-04-16 15:20:36 -07001136 */
Alan Cox4edf1822008-02-08 04:18:44 -08001137
Linus Torvalds1da177e2005-04-16 15:20:36 -07001138static inline void n_tty_receive_break(struct tty_struct *tty)
1139{
Jiri Slaby57c94122012-10-18 22:26:43 +02001140 struct n_tty_data *ldata = tty->disc_data;
1141
Linus Torvalds1da177e2005-04-16 15:20:36 -07001142 if (I_IGNBRK(tty))
1143 return;
1144 if (I_BRKINT(tty)) {
Peter Hurley8c985d12013-03-06 08:38:19 -05001145 isig(SIGINT, tty);
1146 if (!L_NOFLSH(tty)) {
Peter Hurley6d76bd22013-06-15 09:14:26 -04001147 /* flushing needs exclusive termios_rwsem */
1148 up_read(&tty->termios_rwsem);
Peter Hurley8c985d12013-03-06 08:38:19 -05001149 n_tty_flush_buffer(tty);
1150 tty_driver_flush_buffer(tty);
Peter Hurley6d76bd22013-06-15 09:14:26 -04001151 down_read(&tty->termios_rwsem);
Peter Hurley8c985d12013-03-06 08:38:19 -05001152 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001153 return;
1154 }
1155 if (I_PARMRK(tty)) {
Jiri Slaby57c94122012-10-18 22:26:43 +02001156 put_tty_queue('\377', ldata);
1157 put_tty_queue('\0', ldata);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001158 }
Jiri Slaby57c94122012-10-18 22:26:43 +02001159 put_tty_queue('\0', ldata);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001160 wake_up_interruptible(&tty->read_wait);
1161}
1162
1163/**
1164 * n_tty_receive_overrun - handle overrun reporting
1165 * @tty: terminal
1166 *
1167 * Data arrived faster than we could process it. While the tty
1168 * driver has flagged this the bits that were missed are gone
1169 * forever.
1170 *
1171 * Called from the receive_buf path so single threaded. Does not
1172 * need locking as num_overrun and overrun_time are function
1173 * private.
1174 */
Alan Cox4edf1822008-02-08 04:18:44 -08001175
Linus Torvalds1da177e2005-04-16 15:20:36 -07001176static inline void n_tty_receive_overrun(struct tty_struct *tty)
1177{
Jiri Slaby53c5ee22012-10-18 22:26:39 +02001178 struct n_tty_data *ldata = tty->disc_data;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001179 char buf[64];
1180
Jiri Slaby53c5ee22012-10-18 22:26:39 +02001181 ldata->num_overrun++;
1182 if (time_after(jiffies, ldata->overrun_time + HZ) ||
1183 time_after(ldata->overrun_time, jiffies)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001184 printk(KERN_WARNING "%s: %d input overrun(s)\n",
1185 tty_name(tty, buf),
Jiri Slaby53c5ee22012-10-18 22:26:39 +02001186 ldata->num_overrun);
1187 ldata->overrun_time = jiffies;
1188 ldata->num_overrun = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001189 }
1190}
1191
1192/**
1193 * n_tty_receive_parity_error - error notifier
1194 * @tty: terminal device
1195 * @c: character
1196 *
1197 * Process a parity error and queue the right data to indicate
Peter Hurley6d76bd22013-06-15 09:14:26 -04001198 * the error case if necessary.
1199 *
1200 * n_tty_receive_buf()/producer path:
1201 * caller holds non-exclusive termios_rwsem
1202 * publishes read_head via put_tty_queue()
Linus Torvalds1da177e2005-04-16 15:20:36 -07001203 */
1204static inline void n_tty_receive_parity_error(struct tty_struct *tty,
1205 unsigned char c)
1206{
Jiri Slaby57c94122012-10-18 22:26:43 +02001207 struct n_tty_data *ldata = tty->disc_data;
1208
Alan Cox4edf1822008-02-08 04:18:44 -08001209 if (I_IGNPAR(tty))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001210 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001211 if (I_PARMRK(tty)) {
Jiri Slaby57c94122012-10-18 22:26:43 +02001212 put_tty_queue('\377', ldata);
1213 put_tty_queue('\0', ldata);
1214 put_tty_queue(c, ldata);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001215 } else if (I_INPCK(tty))
Jiri Slaby57c94122012-10-18 22:26:43 +02001216 put_tty_queue('\0', ldata);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001217 else
Jiri Slaby57c94122012-10-18 22:26:43 +02001218 put_tty_queue(c, ldata);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001219 wake_up_interruptible(&tty->read_wait);
1220}
1221
1222/**
1223 * n_tty_receive_char - perform processing
1224 * @tty: terminal device
1225 * @c: character
1226 *
1227 * Process an individual character of input received from the driver.
Alan Cox4edf1822008-02-08 04:18:44 -08001228 * This is serialized with respect to itself by the rules for the
Linus Torvalds1da177e2005-04-16 15:20:36 -07001229 * driver above.
Peter Hurley6d76bd22013-06-15 09:14:26 -04001230 *
1231 * n_tty_receive_buf()/producer path:
1232 * caller holds non-exclusive termios_rwsem
1233 * publishes canon_head if canonical mode is active
1234 * otherwise, publishes read_head via put_tty_queue()
Linus Torvalds1da177e2005-04-16 15:20:36 -07001235 */
1236
1237static inline void n_tty_receive_char(struct tty_struct *tty, unsigned char c)
1238{
Jiri Slaby53c5ee22012-10-18 22:26:39 +02001239 struct n_tty_data *ldata = tty->disc_data;
Joe Petersonacc71bb2009-01-02 13:43:32 +00001240 int parmrk;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001241
Jiri Slaby53c5ee22012-10-18 22:26:39 +02001242 if (ldata->raw) {
Jiri Slaby57c94122012-10-18 22:26:43 +02001243 put_tty_queue(c, ldata);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001244 return;
1245 }
Alan Cox4edf1822008-02-08 04:18:44 -08001246
Linus Torvalds1da177e2005-04-16 15:20:36 -07001247 if (I_ISTRIP(tty))
1248 c &= 0x7f;
1249 if (I_IUCLC(tty) && L_IEXTEN(tty))
Alan Cox300a6202009-01-02 13:41:04 +00001250 c = tolower(c);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001251
hyc@symas.com26df6d12010-06-22 10:14:49 -07001252 if (L_EXTPROC(tty)) {
Jiri Slaby57c94122012-10-18 22:26:43 +02001253 put_tty_queue(c, ldata);
hyc@symas.com26df6d12010-06-22 10:14:49 -07001254 return;
1255 }
1256
Joe Peterson54d2a372008-02-06 01:37:59 -08001257 if (tty->stopped && !tty->flow_stopped && I_IXON(tty) &&
Joe Petersona88a69c2009-01-02 13:40:53 +00001258 I_IXANY(tty) && c != START_CHAR(tty) && c != STOP_CHAR(tty) &&
1259 c != INTR_CHAR(tty) && c != QUIT_CHAR(tty) && c != SUSP_CHAR(tty)) {
Joe Peterson54d2a372008-02-06 01:37:59 -08001260 start_tty(tty);
Joe Petersona88a69c2009-01-02 13:40:53 +00001261 process_echoes(tty);
1262 }
Joe Peterson54d2a372008-02-06 01:37:59 -08001263
Linus Torvalds1da177e2005-04-16 15:20:36 -07001264 if (tty->closing) {
1265 if (I_IXON(tty)) {
Joe Petersona88a69c2009-01-02 13:40:53 +00001266 if (c == START_CHAR(tty)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001267 start_tty(tty);
Joe Petersona88a69c2009-01-02 13:40:53 +00001268 process_echoes(tty);
Alan Cox300a6202009-01-02 13:41:04 +00001269 } else if (c == STOP_CHAR(tty))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001270 stop_tty(tty);
1271 }
1272 return;
1273 }
1274
1275 /*
1276 * If the previous character was LNEXT, or we know that this
1277 * character is not one of the characters that we'll have to
1278 * handle specially, do shortcut processing to speed things
1279 * up.
1280 */
Peter Hurley1bb9d562013-06-15 10:21:20 -04001281 if (!test_bit(c, ldata->char_map) || ldata->lnext) {
Jiri Slaby53c5ee22012-10-18 22:26:39 +02001282 ldata->lnext = 0;
Joe Petersonacc71bb2009-01-02 13:43:32 +00001283 parmrk = (c == (unsigned char) '\377' && I_PARMRK(tty)) ? 1 : 0;
Peter Hurleyce741172013-06-15 09:14:20 -04001284 if (read_cnt(ldata) >= (N_TTY_BUF_SIZE - parmrk - 1)) {
Joe Petersonacc71bb2009-01-02 13:43:32 +00001285 /* beep if no space */
Joe Peterson7e94b1d2009-01-02 13:43:40 +00001286 if (L_ECHO(tty))
1287 process_output('\a', tty);
Joe Petersonacc71bb2009-01-02 13:43:32 +00001288 return;
1289 }
1290 if (L_ECHO(tty)) {
Jiri Slaby57c94122012-10-18 22:26:43 +02001291 finish_erasing(ldata);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001292 /* Record the column of first canon char. */
Jiri Slabyba2e68a2012-10-18 22:26:41 +02001293 if (ldata->canon_head == ldata->read_head)
Jiri Slaby57c94122012-10-18 22:26:43 +02001294 echo_set_canon_col(ldata);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001295 echo_char(c, tty);
Peter Hurley17bd7902013-06-15 10:04:24 -04001296 commit_echoes(tty);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001297 }
Joe Petersonacc71bb2009-01-02 13:43:32 +00001298 if (parmrk)
Jiri Slaby57c94122012-10-18 22:26:43 +02001299 put_tty_queue(c, ldata);
1300 put_tty_queue(c, ldata);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001301 return;
1302 }
Alan Cox4edf1822008-02-08 04:18:44 -08001303
Linus Torvalds1da177e2005-04-16 15:20:36 -07001304 if (I_IXON(tty)) {
1305 if (c == START_CHAR(tty)) {
1306 start_tty(tty);
Peter Hurley17bd7902013-06-15 10:04:24 -04001307 commit_echoes(tty);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001308 return;
1309 }
1310 if (c == STOP_CHAR(tty)) {
1311 stop_tty(tty);
1312 return;
1313 }
1314 }
Joe Peterson575537b32008-04-30 00:53:30 -07001315
Linus Torvalds1da177e2005-04-16 15:20:36 -07001316 if (L_ISIG(tty)) {
1317 int signal;
1318 signal = SIGINT;
1319 if (c == INTR_CHAR(tty))
1320 goto send_signal;
1321 signal = SIGQUIT;
1322 if (c == QUIT_CHAR(tty))
1323 goto send_signal;
1324 signal = SIGTSTP;
1325 if (c == SUSP_CHAR(tty)) {
1326send_signal:
Joe Petersonec5b1152008-02-06 01:37:38 -08001327 if (!L_NOFLSH(tty)) {
Peter Hurley6d76bd22013-06-15 09:14:26 -04001328 /* flushing needs exclusive termios_rwsem */
1329 up_read(&tty->termios_rwsem);
Joe Petersonec5b1152008-02-06 01:37:38 -08001330 n_tty_flush_buffer(tty);
Alan Coxf34d7a52008-04-30 00:54:13 -07001331 tty_driver_flush_buffer(tty);
Peter Hurley6d76bd22013-06-15 09:14:26 -04001332 down_read(&tty->termios_rwsem);
Joe Petersonec5b1152008-02-06 01:37:38 -08001333 }
Joe Petersona88a69c2009-01-02 13:40:53 +00001334 if (I_IXON(tty))
1335 start_tty(tty);
1336 if (L_ECHO(tty)) {
Joe Petersonec5b1152008-02-06 01:37:38 -08001337 echo_char(c, tty);
Peter Hurley17bd7902013-06-15 10:04:24 -04001338 commit_echoes(tty);
Joe Petersona88a69c2009-01-02 13:40:53 +00001339 }
Peter Hurley8c985d12013-03-06 08:38:19 -05001340 isig(signal, tty);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001341 return;
1342 }
1343 }
Joe Peterson575537b32008-04-30 00:53:30 -07001344
1345 if (c == '\r') {
1346 if (I_IGNCR(tty))
1347 return;
1348 if (I_ICRNL(tty))
1349 c = '\n';
1350 } else if (c == '\n' && I_INLCR(tty))
1351 c = '\r';
1352
Jiri Slaby53c5ee22012-10-18 22:26:39 +02001353 if (ldata->icanon) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001354 if (c == ERASE_CHAR(tty) || c == KILL_CHAR(tty) ||
1355 (c == WERASE_CHAR(tty) && L_IEXTEN(tty))) {
1356 eraser(c, tty);
Peter Hurley17bd7902013-06-15 10:04:24 -04001357 commit_echoes(tty);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001358 return;
1359 }
1360 if (c == LNEXT_CHAR(tty) && L_IEXTEN(tty)) {
Jiri Slaby53c5ee22012-10-18 22:26:39 +02001361 ldata->lnext = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001362 if (L_ECHO(tty)) {
Jiri Slaby57c94122012-10-18 22:26:43 +02001363 finish_erasing(ldata);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001364 if (L_ECHOCTL(tty)) {
Jiri Slaby57c94122012-10-18 22:26:43 +02001365 echo_char_raw('^', ldata);
1366 echo_char_raw('\b', ldata);
Peter Hurley17bd7902013-06-15 10:04:24 -04001367 commit_echoes(tty);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001368 }
1369 }
1370 return;
1371 }
1372 if (c == REPRINT_CHAR(tty) && L_ECHO(tty) &&
1373 L_IEXTEN(tty)) {
Peter Hurleybc5a5e32013-06-15 09:14:21 -04001374 size_t tail = ldata->canon_head;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001375
Jiri Slaby57c94122012-10-18 22:26:43 +02001376 finish_erasing(ldata);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001377 echo_char(c, tty);
Jiri Slaby57c94122012-10-18 22:26:43 +02001378 echo_char_raw('\n', ldata);
Jiri Slabyba2e68a2012-10-18 22:26:41 +02001379 while (tail != ldata->read_head) {
Peter Hurleybc5a5e32013-06-15 09:14:21 -04001380 echo_char(read_buf(ldata, tail), tty);
1381 tail++;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001382 }
Peter Hurley17bd7902013-06-15 10:04:24 -04001383 commit_echoes(tty);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001384 return;
1385 }
1386 if (c == '\n') {
Peter Hurleyce741172013-06-15 09:14:20 -04001387 if (read_cnt(ldata) >= N_TTY_BUF_SIZE) {
Joe Peterson7e94b1d2009-01-02 13:43:40 +00001388 if (L_ECHO(tty))
1389 process_output('\a', tty);
Joe Petersonacc71bb2009-01-02 13:43:32 +00001390 return;
1391 }
1392 if (L_ECHO(tty) || L_ECHONL(tty)) {
Jiri Slaby57c94122012-10-18 22:26:43 +02001393 echo_char_raw('\n', ldata);
Peter Hurley17bd7902013-06-15 10:04:24 -04001394 commit_echoes(tty);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001395 }
1396 goto handle_newline;
1397 }
1398 if (c == EOF_CHAR(tty)) {
Peter Hurleyce741172013-06-15 09:14:20 -04001399 if (read_cnt(ldata) >= N_TTY_BUF_SIZE)
Joe Petersonacc71bb2009-01-02 13:43:32 +00001400 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001401 c = __DISABLED_CHAR;
1402 goto handle_newline;
1403 }
1404 if ((c == EOL_CHAR(tty)) ||
1405 (c == EOL2_CHAR(tty) && L_IEXTEN(tty))) {
Joe Petersonacc71bb2009-01-02 13:43:32 +00001406 parmrk = (c == (unsigned char) '\377' && I_PARMRK(tty))
1407 ? 1 : 0;
Peter Hurleyce741172013-06-15 09:14:20 -04001408 if (read_cnt(ldata) >= (N_TTY_BUF_SIZE - parmrk)) {
Joe Peterson7e94b1d2009-01-02 13:43:40 +00001409 if (L_ECHO(tty))
1410 process_output('\a', tty);
Joe Petersonacc71bb2009-01-02 13:43:32 +00001411 return;
1412 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001413 /*
1414 * XXX are EOL_CHAR and EOL2_CHAR echoed?!?
1415 */
1416 if (L_ECHO(tty)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001417 /* Record the column of first canon char. */
Jiri Slabyba2e68a2012-10-18 22:26:41 +02001418 if (ldata->canon_head == ldata->read_head)
Jiri Slaby57c94122012-10-18 22:26:43 +02001419 echo_set_canon_col(ldata);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001420 echo_char(c, tty);
Peter Hurley17bd7902013-06-15 10:04:24 -04001421 commit_echoes(tty);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001422 }
1423 /*
1424 * XXX does PARMRK doubling happen for
1425 * EOL_CHAR and EOL2_CHAR?
1426 */
Joe Petersonacc71bb2009-01-02 13:43:32 +00001427 if (parmrk)
Jiri Slaby57c94122012-10-18 22:26:43 +02001428 put_tty_queue(c, ldata);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001429
Alan Cox4edf1822008-02-08 04:18:44 -08001430handle_newline:
Peter Hurleybc5a5e32013-06-15 09:14:21 -04001431 set_bit(ldata->read_head & (N_TTY_BUF_SIZE - 1), ldata->read_flags);
Peter Hurley6d76bd22013-06-15 09:14:26 -04001432 put_tty_queue(c, ldata);
Jiri Slabyba2e68a2012-10-18 22:26:41 +02001433 ldata->canon_head = ldata->read_head;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001434 kill_fasync(&tty->fasync, SIGIO, POLL_IN);
1435 if (waitqueue_active(&tty->read_wait))
1436 wake_up_interruptible(&tty->read_wait);
1437 return;
1438 }
1439 }
Alan Cox4edf1822008-02-08 04:18:44 -08001440
Joe Petersonacc71bb2009-01-02 13:43:32 +00001441 parmrk = (c == (unsigned char) '\377' && I_PARMRK(tty)) ? 1 : 0;
Peter Hurleyce741172013-06-15 09:14:20 -04001442 if (read_cnt(ldata) >= (N_TTY_BUF_SIZE - parmrk - 1)) {
Joe Petersonacc71bb2009-01-02 13:43:32 +00001443 /* beep if no space */
Joe Peterson7e94b1d2009-01-02 13:43:40 +00001444 if (L_ECHO(tty))
1445 process_output('\a', tty);
Joe Petersonacc71bb2009-01-02 13:43:32 +00001446 return;
1447 }
1448 if (L_ECHO(tty)) {
Jiri Slaby57c94122012-10-18 22:26:43 +02001449 finish_erasing(ldata);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001450 if (c == '\n')
Jiri Slaby57c94122012-10-18 22:26:43 +02001451 echo_char_raw('\n', ldata);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001452 else {
1453 /* Record the column of first canon char. */
Jiri Slabyba2e68a2012-10-18 22:26:41 +02001454 if (ldata->canon_head == ldata->read_head)
Jiri Slaby57c94122012-10-18 22:26:43 +02001455 echo_set_canon_col(ldata);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001456 echo_char(c, tty);
1457 }
Peter Hurley17bd7902013-06-15 10:04:24 -04001458 commit_echoes(tty);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001459 }
1460
Joe Petersonacc71bb2009-01-02 13:43:32 +00001461 if (parmrk)
Jiri Slaby57c94122012-10-18 22:26:43 +02001462 put_tty_queue(c, ldata);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001463
Jiri Slaby57c94122012-10-18 22:26:43 +02001464 put_tty_queue(c, ldata);
Alan Cox4edf1822008-02-08 04:18:44 -08001465}
Linus Torvalds1da177e2005-04-16 15:20:36 -07001466
Linus Torvalds1da177e2005-04-16 15:20:36 -07001467/**
1468 * n_tty_receive_buf - data receive
1469 * @tty: terminal device
1470 * @cp: buffer
1471 * @fp: flag buffer
1472 * @count: characters
1473 *
1474 * Called by the terminal driver when a block of characters has
1475 * been received. This function must be called from soft contexts
1476 * not from interrupt context. The driver is responsible for making
1477 * calls one at a time and in order (or using flush_to_ldisc)
Peter Hurley6d76bd22013-06-15 09:14:26 -04001478 *
1479 * n_tty_receive_buf()/producer path:
1480 * claims non-exclusive termios_rwsem
1481 * publishes read_head and canon_head
Linus Torvalds1da177e2005-04-16 15:20:36 -07001482 */
Alan Cox4edf1822008-02-08 04:18:44 -08001483
Peter Hurley24a89d12013-06-15 09:14:15 -04001484static void __receive_buf(struct tty_struct *tty, const unsigned char *cp,
1485 char *fp, int count)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001486{
Jiri Slaby53c5ee22012-10-18 22:26:39 +02001487 struct n_tty_data *ldata = tty->disc_data;
Peter Hurley8cb06c92013-06-15 10:21:18 -04001488 char flags = TTY_NORMAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001489 char buf[64];
Linus Torvalds1da177e2005-04-16 15:20:36 -07001490
Jiri Slaby53c5ee22012-10-18 22:26:39 +02001491 if (ldata->real_raw) {
Peter Hurleyd1913e32013-06-15 09:14:28 -04001492 size_t n, head;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001493
Peter Hurleyd1913e32013-06-15 09:14:28 -04001494 head = ldata->read_head & (N_TTY_BUF_SIZE - 1);
1495 n = N_TTY_BUF_SIZE - max(read_cnt(ldata), head);
1496 n = min_t(size_t, count, n);
1497 memcpy(read_buf_addr(ldata, head), cp, n);
1498 ldata->read_head += n;
1499 cp += n;
1500 count -= n;
1501
1502 head = ldata->read_head & (N_TTY_BUF_SIZE - 1);
1503 n = N_TTY_BUF_SIZE - max(read_cnt(ldata), head);
1504 n = min_t(size_t, count, n);
1505 memcpy(read_buf_addr(ldata, head), cp, n);
1506 ldata->read_head += n;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001507 } else {
Peter Hurley781ad1c2013-06-15 10:21:21 -04001508 while (count--) {
Peter Hurley8cb06c92013-06-15 10:21:18 -04001509 if (fp)
1510 flags = *fp++;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001511 switch (flags) {
1512 case TTY_NORMAL:
Peter Hurley781ad1c2013-06-15 10:21:21 -04001513 n_tty_receive_char(tty, *cp++);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001514 break;
1515 case TTY_BREAK:
1516 n_tty_receive_break(tty);
1517 break;
1518 case TTY_PARITY:
1519 case TTY_FRAME:
Peter Hurley781ad1c2013-06-15 10:21:21 -04001520 n_tty_receive_parity_error(tty, *cp++);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001521 break;
1522 case TTY_OVERRUN:
1523 n_tty_receive_overrun(tty);
1524 break;
1525 default:
Alan Cox4edf1822008-02-08 04:18:44 -08001526 printk(KERN_ERR "%s: unknown flag %d\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -07001527 tty_name(tty, buf), flags);
1528 break;
1529 }
1530 }
Peter Hurleycbfd0342013-06-15 10:04:26 -04001531
1532 flush_echoes(tty);
Alan Coxf34d7a52008-04-30 00:54:13 -07001533 if (tty->ops->flush_chars)
1534 tty->ops->flush_chars(tty);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001535 }
1536
Peter Hurleyce741172013-06-15 09:14:20 -04001537 if ((!ldata->icanon && (read_cnt(ldata) >= ldata->minimum_to_wake)) ||
hyc@symas.com26df6d12010-06-22 10:14:49 -07001538 L_EXTPROC(tty)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001539 kill_fasync(&tty->fasync, SIGIO, POLL_IN);
1540 if (waitqueue_active(&tty->read_wait))
1541 wake_up_interruptible(&tty->read_wait);
1542 }
1543
Peter Hurley6367ca72013-06-15 09:14:33 -04001544 n_tty_check_throttle(tty);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001545}
1546
Peter Hurley24a89d12013-06-15 09:14:15 -04001547static void n_tty_receive_buf(struct tty_struct *tty, const unsigned char *cp,
1548 char *fp, int count)
1549{
Peter Hurley9356b532013-06-15 09:14:24 -04001550 down_read(&tty->termios_rwsem);
Peter Hurley24a89d12013-06-15 09:14:15 -04001551 __receive_buf(tty, cp, fp, count);
Peter Hurley9356b532013-06-15 09:14:24 -04001552 up_read(&tty->termios_rwsem);
Peter Hurley24a89d12013-06-15 09:14:15 -04001553}
1554
1555static int n_tty_receive_buf2(struct tty_struct *tty, const unsigned char *cp,
1556 char *fp, int count)
1557{
1558 struct n_tty_data *ldata = tty->disc_data;
1559 int room;
1560
Peter Hurley9356b532013-06-15 09:14:24 -04001561 down_read(&tty->termios_rwsem);
1562
Peter Hurley24a89d12013-06-15 09:14:15 -04001563 tty->receive_room = room = receive_room(tty);
1564 if (!room)
1565 ldata->no_room = 1;
1566 count = min(count, room);
1567 if (count)
1568 __receive_buf(tty, cp, fp, count);
1569
Peter Hurley9356b532013-06-15 09:14:24 -04001570 up_read(&tty->termios_rwsem);
1571
Peter Hurley24a89d12013-06-15 09:14:15 -04001572 return count;
1573}
1574
Linus Torvalds1da177e2005-04-16 15:20:36 -07001575int is_ignored(int sig)
1576{
1577 return (sigismember(&current->blocked, sig) ||
Alan Cox4edf1822008-02-08 04:18:44 -08001578 current->sighand->action[sig-1].sa.sa_handler == SIG_IGN);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001579}
1580
1581/**
1582 * n_tty_set_termios - termios data changed
1583 * @tty: terminal
1584 * @old: previous data
1585 *
1586 * Called by the tty layer when the user changes termios flags so
1587 * that the line discipline can plan ahead. This function cannot sleep
Alan Cox4edf1822008-02-08 04:18:44 -08001588 * and is protected from re-entry by the tty layer. The user is
Linus Torvalds1da177e2005-04-16 15:20:36 -07001589 * guaranteed that this function will not be re-entered or in progress
1590 * when the ldisc is closed.
Alan Cox17b82062008-10-13 10:45:06 +01001591 *
Peter Hurley6a1c0682013-06-15 09:14:23 -04001592 * Locking: Caller holds tty->termios_rwsem
Linus Torvalds1da177e2005-04-16 15:20:36 -07001593 */
Alan Cox4edf1822008-02-08 04:18:44 -08001594
1595static void n_tty_set_termios(struct tty_struct *tty, struct ktermios *old)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001596{
Jiri Slaby53c5ee22012-10-18 22:26:39 +02001597 struct n_tty_data *ldata = tty->disc_data;
Alan Cox47afa7a2008-10-13 10:44:17 +01001598 int canon_change = 1;
Alan Cox47afa7a2008-10-13 10:44:17 +01001599
1600 if (old)
Alan Coxadc8d742012-07-14 15:31:47 +01001601 canon_change = (old->c_lflag ^ tty->termios.c_lflag) & ICANON;
Alan Cox47afa7a2008-10-13 10:44:17 +01001602 if (canon_change) {
Jiri Slaby3fe780b2012-10-18 22:26:40 +02001603 bitmap_zero(ldata->read_flags, N_TTY_BUF_SIZE);
Peter Hurley40d5e092013-06-15 10:21:17 -04001604 ldata->line_start = 0;
Jiri Slabyba2e68a2012-10-18 22:26:41 +02001605 ldata->canon_head = ldata->read_tail;
Jiri Slaby53c5ee22012-10-18 22:26:39 +02001606 ldata->erasing = 0;
Peter Hurley6f9b0282013-06-15 09:14:27 -04001607 ldata->lnext = 0;
Alan Cox47afa7a2008-10-13 10:44:17 +01001608 }
1609
Peter Hurleyce741172013-06-15 09:14:20 -04001610 if (canon_change && !L_ICANON(tty) && read_cnt(ldata))
Alan Cox47afa7a2008-10-13 10:44:17 +01001611 wake_up_interruptible(&tty->read_wait);
Alan Cox4edf1822008-02-08 04:18:44 -08001612
Jiri Slaby53c5ee22012-10-18 22:26:39 +02001613 ldata->icanon = (L_ICANON(tty) != 0);
Peter Hurley582f5592013-05-17 12:49:48 -04001614
Linus Torvalds1da177e2005-04-16 15:20:36 -07001615 if (I_ISTRIP(tty) || I_IUCLC(tty) || I_IGNCR(tty) ||
1616 I_ICRNL(tty) || I_INLCR(tty) || L_ICANON(tty) ||
1617 I_IXON(tty) || L_ISIG(tty) || L_ECHO(tty) ||
1618 I_PARMRK(tty)) {
Peter Hurley1bb9d562013-06-15 10:21:20 -04001619 bitmap_zero(ldata->char_map, 256);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001620
1621 if (I_IGNCR(tty) || I_ICRNL(tty))
Peter Hurley1bb9d562013-06-15 10:21:20 -04001622 set_bit('\r', ldata->char_map);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001623 if (I_INLCR(tty))
Peter Hurley1bb9d562013-06-15 10:21:20 -04001624 set_bit('\n', ldata->char_map);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001625
1626 if (L_ICANON(tty)) {
Peter Hurley1bb9d562013-06-15 10:21:20 -04001627 set_bit(ERASE_CHAR(tty), ldata->char_map);
1628 set_bit(KILL_CHAR(tty), ldata->char_map);
1629 set_bit(EOF_CHAR(tty), ldata->char_map);
1630 set_bit('\n', ldata->char_map);
1631 set_bit(EOL_CHAR(tty), ldata->char_map);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001632 if (L_IEXTEN(tty)) {
Peter Hurley1bb9d562013-06-15 10:21:20 -04001633 set_bit(WERASE_CHAR(tty), ldata->char_map);
1634 set_bit(LNEXT_CHAR(tty), ldata->char_map);
1635 set_bit(EOL2_CHAR(tty), ldata->char_map);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001636 if (L_ECHO(tty))
1637 set_bit(REPRINT_CHAR(tty),
Peter Hurley1bb9d562013-06-15 10:21:20 -04001638 ldata->char_map);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001639 }
1640 }
1641 if (I_IXON(tty)) {
Peter Hurley1bb9d562013-06-15 10:21:20 -04001642 set_bit(START_CHAR(tty), ldata->char_map);
1643 set_bit(STOP_CHAR(tty), ldata->char_map);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001644 }
1645 if (L_ISIG(tty)) {
Peter Hurley1bb9d562013-06-15 10:21:20 -04001646 set_bit(INTR_CHAR(tty), ldata->char_map);
1647 set_bit(QUIT_CHAR(tty), ldata->char_map);
1648 set_bit(SUSP_CHAR(tty), ldata->char_map);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001649 }
Peter Hurley1bb9d562013-06-15 10:21:20 -04001650 clear_bit(__DISABLED_CHAR, ldata->char_map);
Jiri Slaby53c5ee22012-10-18 22:26:39 +02001651 ldata->raw = 0;
1652 ldata->real_raw = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001653 } else {
Jiri Slaby53c5ee22012-10-18 22:26:39 +02001654 ldata->raw = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001655 if ((I_IGNBRK(tty) || (!I_BRKINT(tty) && !I_PARMRK(tty))) &&
1656 (I_IGNPAR(tty) || !I_INPCK(tty)) &&
1657 (tty->driver->flags & TTY_DRIVER_REAL_RAW))
Jiri Slaby53c5ee22012-10-18 22:26:39 +02001658 ldata->real_raw = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001659 else
Jiri Slaby53c5ee22012-10-18 22:26:39 +02001660 ldata->real_raw = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001661 }
Linus Torvalds55db4c62011-06-04 06:33:24 +09001662 n_tty_set_room(tty);
Wang YanQingdab73b42013-05-09 14:16:47 +08001663 /*
1664 * Fix tty hang when I_IXON(tty) is cleared, but the tty
1665 * been stopped by STOP_CHAR(tty) before it.
1666 */
1667 if (!I_IXON(tty) && old && (old->c_iflag & IXON) && !tty->flow_stopped) {
1668 start_tty(tty);
1669 }
1670
Alan Coxf34d7a52008-04-30 00:54:13 -07001671 /* The termios change make the tty ready for I/O */
1672 wake_up_interruptible(&tty->write_wait);
1673 wake_up_interruptible(&tty->read_wait);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001674}
1675
1676/**
1677 * n_tty_close - close the ldisc for this tty
1678 * @tty: device
1679 *
Alan Cox4edf1822008-02-08 04:18:44 -08001680 * Called from the terminal layer when this line discipline is
1681 * being shut down, either because of a close or becsuse of a
Linus Torvalds1da177e2005-04-16 15:20:36 -07001682 * discipline change. The function will not be called while other
1683 * ldisc methods are in progress.
1684 */
Alan Cox4edf1822008-02-08 04:18:44 -08001685
Linus Torvalds1da177e2005-04-16 15:20:36 -07001686static void n_tty_close(struct tty_struct *tty)
1687{
Jiri Slaby70ece7a2012-10-18 22:26:38 +02001688 struct n_tty_data *ldata = tty->disc_data;
1689
Peter Hurley79901312013-03-11 16:44:23 -04001690 if (tty->link)
1691 n_tty_packet_mode_flush(tty);
1692
Peter Hurley20bafb32013-06-15 10:21:19 -04001693 vfree(ldata);
Jiri Slaby70ece7a2012-10-18 22:26:38 +02001694 tty->disc_data = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001695}
1696
1697/**
1698 * n_tty_open - open an ldisc
1699 * @tty: terminal to open
1700 *
Alan Cox4edf1822008-02-08 04:18:44 -08001701 * Called when this line discipline is being attached to the
Linus Torvalds1da177e2005-04-16 15:20:36 -07001702 * terminal device. Can sleep. Called serialized so that no
1703 * other events will occur in parallel. No further open will occur
1704 * until a close.
1705 */
1706
1707static int n_tty_open(struct tty_struct *tty)
1708{
Jiri Slaby70ece7a2012-10-18 22:26:38 +02001709 struct n_tty_data *ldata;
1710
Peter Hurley20bafb32013-06-15 10:21:19 -04001711 /* Currently a malloc failure here can panic */
1712 ldata = vmalloc(sizeof(*ldata));
Jiri Slaby70ece7a2012-10-18 22:26:38 +02001713 if (!ldata)
1714 goto err;
1715
Jiri Slaby53c5ee22012-10-18 22:26:39 +02001716 ldata->overrun_time = jiffies;
Jiri Slabybddc7152012-10-18 22:26:42 +02001717 mutex_init(&ldata->atomic_read_lock);
1718 mutex_init(&ldata->output_lock);
Jiri Slaby53c5ee22012-10-18 22:26:39 +02001719
Jiri Slaby70ece7a2012-10-18 22:26:38 +02001720 tty->disc_data = ldata;
Peter Hurleyb66f4fa2013-03-11 16:44:32 -04001721 reset_buffer_flags(tty->disc_data);
Jiri Slaby53c5ee22012-10-18 22:26:39 +02001722 ldata->column = 0;
Peter Hurley20bafb32013-06-15 10:21:19 -04001723 ldata->canon_column = 0;
Peter Hurleyf6c8dbe2013-06-15 07:28:28 -04001724 ldata->minimum_to_wake = 1;
Peter Hurley20bafb32013-06-15 10:21:19 -04001725 ldata->num_overrun = 0;
1726 ldata->no_room = 0;
1727 ldata->lnext = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001728 tty->closing = 0;
Peter Hurleyb66f4fa2013-03-11 16:44:32 -04001729 /* indicate buffer work may resume */
1730 clear_bit(TTY_LDISC_HALTED, &tty->flags);
1731 n_tty_set_termios(tty, NULL);
1732 tty_unthrottle(tty);
Jiri Slaby70ece7a2012-10-18 22:26:38 +02001733
Linus Torvalds1da177e2005-04-16 15:20:36 -07001734 return 0;
Jiri Slaby70ece7a2012-10-18 22:26:38 +02001735err:
Jiri Slabyb91939f2012-10-18 22:26:35 +02001736 return -ENOMEM;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001737}
1738
1739static inline int input_available_p(struct tty_struct *tty, int amt)
1740{
Jiri Slaby53c5ee22012-10-18 22:26:39 +02001741 struct n_tty_data *ldata = tty->disc_data;
1742
Jiri Slaby53c5ee22012-10-18 22:26:39 +02001743 if (ldata->icanon && !L_EXTPROC(tty)) {
Peter Hurleya73d3d62013-06-15 09:14:25 -04001744 if (ldata->canon_head != ldata->read_tail)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001745 return 1;
Peter Hurleyce741172013-06-15 09:14:20 -04001746 } else if (read_cnt(ldata) >= (amt ? amt : 1))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001747 return 1;
1748
1749 return 0;
1750}
1751
1752/**
Thorsten Wißmannbbd20752011-12-08 17:47:33 +01001753 * copy_from_read_buf - copy read data directly
Linus Torvalds1da177e2005-04-16 15:20:36 -07001754 * @tty: terminal device
1755 * @b: user data
1756 * @nr: size of data
1757 *
Alan Cox11a96d12008-10-13 10:46:24 +01001758 * Helper function to speed up n_tty_read. It is only called when
Linus Torvalds1da177e2005-04-16 15:20:36 -07001759 * ICANON is off; it copies characters straight from the tty queue to
1760 * user space directly. It can be profitably called twice; once to
1761 * drain the space from the tail pointer to the (physical) end of the
1762 * buffer, and once to drain the space from the (physical) beginning of
1763 * the buffer to head pointer.
1764 *
Jiri Slabybddc7152012-10-18 22:26:42 +02001765 * Called under the ldata->atomic_read_lock sem
Linus Torvalds1da177e2005-04-16 15:20:36 -07001766 *
Peter Hurley6d76bd22013-06-15 09:14:26 -04001767 * n_tty_read()/consumer path:
1768 * caller holds non-exclusive termios_rwsem
1769 * read_tail published
Linus Torvalds1da177e2005-04-16 15:20:36 -07001770 */
Alan Cox4edf1822008-02-08 04:18:44 -08001771
Alan Cox33f0f882006-01-09 20:54:13 -08001772static int copy_from_read_buf(struct tty_struct *tty,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001773 unsigned char __user **b,
1774 size_t *nr)
1775
1776{
Jiri Slaby53c5ee22012-10-18 22:26:39 +02001777 struct n_tty_data *ldata = tty->disc_data;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001778 int retval;
1779 size_t n;
Jiri Slaby3fa10cc2012-04-26 20:13:00 +02001780 bool is_eof;
Peter Hurleybc5a5e32013-06-15 09:14:21 -04001781 size_t tail = ldata->read_tail & (N_TTY_BUF_SIZE - 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001782
1783 retval = 0;
Peter Hurleybc5a5e32013-06-15 09:14:21 -04001784 n = min(read_cnt(ldata), N_TTY_BUF_SIZE - tail);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001785 n = min(*nr, n);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001786 if (n) {
Peter Hurleybc5a5e32013-06-15 09:14:21 -04001787 retval = copy_to_user(*b, read_buf_addr(ldata, tail), n);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001788 n -= retval;
Peter Hurleybc5a5e32013-06-15 09:14:21 -04001789 is_eof = n == 1 && read_buf(ldata, tail) == EOF_CHAR(tty);
1790 tty_audit_add_data(tty, read_buf_addr(ldata, tail), n,
Jiri Slaby53c5ee22012-10-18 22:26:39 +02001791 ldata->icanon);
Peter Hurleybc5a5e32013-06-15 09:14:21 -04001792 ldata->read_tail += n;
hyc@symas.com26df6d12010-06-22 10:14:49 -07001793 /* Turn single EOF into zero-length read */
Peter Hurleyce741172013-06-15 09:14:20 -04001794 if (L_EXTPROC(tty) && ldata->icanon && is_eof && !read_cnt(ldata))
Jiri Slaby3fa10cc2012-04-26 20:13:00 +02001795 n = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001796 *b += n;
1797 *nr -= n;
1798 }
1799 return retval;
1800}
1801
Peter Hurley88bb0de2013-06-15 09:14:16 -04001802/**
Peter Hurley32f13522013-06-15 09:14:17 -04001803 * canon_copy_from_read_buf - copy read data in canonical mode
Peter Hurley88bb0de2013-06-15 09:14:16 -04001804 * @tty: terminal device
1805 * @b: user data
1806 * @nr: size of data
1807 *
1808 * Helper function for n_tty_read. It is only called when ICANON is on;
Peter Hurley32f13522013-06-15 09:14:17 -04001809 * it copies one line of input up to and including the line-delimiting
1810 * character into the user-space buffer.
Peter Hurley88bb0de2013-06-15 09:14:16 -04001811 *
1812 * Called under the atomic_read_lock mutex
Peter Hurley6d76bd22013-06-15 09:14:26 -04001813 *
1814 * n_tty_read()/consumer path:
1815 * caller holds non-exclusive termios_rwsem
1816 * read_tail published
Peter Hurley88bb0de2013-06-15 09:14:16 -04001817 */
1818
Peter Hurley32f13522013-06-15 09:14:17 -04001819static int canon_copy_from_read_buf(struct tty_struct *tty,
1820 unsigned char __user **b,
1821 size_t *nr)
Peter Hurley88bb0de2013-06-15 09:14:16 -04001822{
1823 struct n_tty_data *ldata = tty->disc_data;
Peter Hurley32f13522013-06-15 09:14:17 -04001824 size_t n, size, more, c;
Peter Hurleybc5a5e32013-06-15 09:14:21 -04001825 size_t eol;
1826 size_t tail;
1827 int ret, found = 0;
Peter Hurley40d5e092013-06-15 10:21:17 -04001828 bool eof_push = 0;
Peter Hurley88bb0de2013-06-15 09:14:16 -04001829
1830 /* N.B. avoid overrun if nr == 0 */
Peter Hurleyce741172013-06-15 09:14:20 -04001831 n = min(*nr, read_cnt(ldata));
Peter Hurley6d76bd22013-06-15 09:14:26 -04001832 if (!n)
Peter Hurley32f13522013-06-15 09:14:17 -04001833 return 0;
Peter Hurley88bb0de2013-06-15 09:14:16 -04001834
Peter Hurleybc5a5e32013-06-15 09:14:21 -04001835 tail = ldata->read_tail & (N_TTY_BUF_SIZE - 1);
Peter Hurley32f13522013-06-15 09:14:17 -04001836 size = min_t(size_t, tail + n, N_TTY_BUF_SIZE);
1837
Peter Hurleybc5a5e32013-06-15 09:14:21 -04001838 n_tty_trace("%s: nr:%zu tail:%zu n:%zu size:%zu\n",
Peter Hurley32f13522013-06-15 09:14:17 -04001839 __func__, *nr, tail, n, size);
1840
1841 eol = find_next_bit(ldata->read_flags, size, tail);
1842 more = n - (size - tail);
1843 if (eol == N_TTY_BUF_SIZE && more) {
1844 /* scan wrapped without finding set bit */
1845 eol = find_next_bit(ldata->read_flags, more, 0);
1846 if (eol != more)
1847 found = 1;
1848 } else if (eol != size)
1849 found = 1;
1850
1851 size = N_TTY_BUF_SIZE - tail;
1852 n = (found + eol + size) & (N_TTY_BUF_SIZE - 1);
1853 c = n;
1854
Peter Hurley40d5e092013-06-15 10:21:17 -04001855 if (found && read_buf(ldata, eol) == __DISABLED_CHAR) {
Peter Hurley32f13522013-06-15 09:14:17 -04001856 n--;
Peter Hurley40d5e092013-06-15 10:21:17 -04001857 eof_push = !n && ldata->read_tail != ldata->line_start;
1858 }
Peter Hurley32f13522013-06-15 09:14:17 -04001859
Peter Hurleybc5a5e32013-06-15 09:14:21 -04001860 n_tty_trace("%s: eol:%zu found:%d n:%zu c:%zu size:%zu more:%zu\n",
Peter Hurley32f13522013-06-15 09:14:17 -04001861 __func__, eol, found, n, c, size, more);
1862
Peter Hurley32f13522013-06-15 09:14:17 -04001863 if (n > size) {
Peter Hurleybc5a5e32013-06-15 09:14:21 -04001864 ret = copy_to_user(*b, read_buf_addr(ldata, tail), size);
Peter Hurley32f13522013-06-15 09:14:17 -04001865 if (ret)
1866 return -EFAULT;
1867 ret = copy_to_user(*b + size, ldata->read_buf, n - size);
1868 } else
Peter Hurleybc5a5e32013-06-15 09:14:21 -04001869 ret = copy_to_user(*b, read_buf_addr(ldata, tail), n);
Peter Hurley32f13522013-06-15 09:14:17 -04001870
1871 if (ret)
1872 return -EFAULT;
1873 *b += n;
1874 *nr -= n;
1875
Peter Hurleya73d3d62013-06-15 09:14:25 -04001876 if (found)
Peter Hurley6d76bd22013-06-15 09:14:26 -04001877 clear_bit(eol, ldata->read_flags);
1878 smp_mb__after_clear_bit();
1879 ldata->read_tail += c;
Peter Hurley88bb0de2013-06-15 09:14:16 -04001880
Peter Hurley40d5e092013-06-15 10:21:17 -04001881 if (found) {
1882 ldata->line_start = ldata->read_tail;
Peter Hurley32f13522013-06-15 09:14:17 -04001883 tty_audit_push(tty);
Peter Hurley40d5e092013-06-15 10:21:17 -04001884 }
1885 return eof_push ? -EAGAIN : 0;
Peter Hurley88bb0de2013-06-15 09:14:16 -04001886}
1887
Al Virocc4191d2008-03-29 03:08:48 +00001888extern ssize_t redirected_tty_write(struct file *, const char __user *,
Alan Cox4edf1822008-02-08 04:18:44 -08001889 size_t, loff_t *);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001890
1891/**
1892 * job_control - check job control
1893 * @tty: tty
1894 * @file: file handle
1895 *
1896 * Perform job control management checks on this file/tty descriptor
Alan Cox4edf1822008-02-08 04:18:44 -08001897 * and if appropriate send any needed signals and return a negative
Linus Torvalds1da177e2005-04-16 15:20:36 -07001898 * error code if action should be taken.
Alan Cox04f378b2008-04-30 00:53:29 -07001899 *
Peter Hurley01a5e442013-03-06 08:38:20 -05001900 * Locking: redirected write test is safe
1901 * current->signal->tty check is safe
1902 * ctrl_lock to safely reference tty->pgrp
Linus Torvalds1da177e2005-04-16 15:20:36 -07001903 */
Alan Cox4edf1822008-02-08 04:18:44 -08001904
Linus Torvalds1da177e2005-04-16 15:20:36 -07001905static int job_control(struct tty_struct *tty, struct file *file)
1906{
1907 /* Job control check -- must be done at start and after
1908 every sleep (POSIX.1 7.1.1.4). */
1909 /* NOTE: not yet done after every sleep pending a thorough
1910 check of the logic of this change. -- jlc */
1911 /* don't stop on /dev/console */
Peter Hurley01a5e442013-03-06 08:38:20 -05001912 if (file->f_op->write == redirected_tty_write ||
1913 current->signal->tty != tty)
1914 return 0;
1915
1916 spin_lock_irq(&tty->ctrl_lock);
1917 if (!tty->pgrp)
1918 printk(KERN_ERR "n_tty_read: no tty->pgrp!\n");
1919 else if (task_pgrp(current) != tty->pgrp) {
1920 spin_unlock_irq(&tty->ctrl_lock);
1921 if (is_ignored(SIGTTIN) || is_current_pgrp_orphaned())
1922 return -EIO;
1923 kill_pgrp(task_pgrp(current), SIGTTIN, 1);
1924 set_thread_flag(TIF_SIGPENDING);
1925 return -ERESTARTSYS;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001926 }
Peter Hurley01a5e442013-03-06 08:38:20 -05001927 spin_unlock_irq(&tty->ctrl_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001928 return 0;
1929}
Alan Cox4edf1822008-02-08 04:18:44 -08001930
Linus Torvalds1da177e2005-04-16 15:20:36 -07001931
1932/**
Alan Cox11a96d12008-10-13 10:46:24 +01001933 * n_tty_read - read function for tty
Linus Torvalds1da177e2005-04-16 15:20:36 -07001934 * @tty: tty device
1935 * @file: file object
1936 * @buf: userspace buffer pointer
1937 * @nr: size of I/O
1938 *
1939 * Perform reads for the line discipline. We are guaranteed that the
1940 * line discipline will not be closed under us but we may get multiple
1941 * parallel readers and must handle this ourselves. We may also get
1942 * a hangup. Always called in user context, may sleep.
1943 *
1944 * This code must be sure never to sleep through a hangup.
Peter Hurley6d76bd22013-06-15 09:14:26 -04001945 *
1946 * n_tty_read()/consumer path:
1947 * claims non-exclusive termios_rwsem
1948 * publishes read_tail
Linus Torvalds1da177e2005-04-16 15:20:36 -07001949 */
Alan Cox4edf1822008-02-08 04:18:44 -08001950
Alan Cox11a96d12008-10-13 10:46:24 +01001951static ssize_t n_tty_read(struct tty_struct *tty, struct file *file,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001952 unsigned char __user *buf, size_t nr)
1953{
Jiri Slaby53c5ee22012-10-18 22:26:39 +02001954 struct n_tty_data *ldata = tty->disc_data;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001955 unsigned char __user *b = buf;
1956 DECLARE_WAITQUEUE(wait, current);
1957 int c;
1958 int minimum, time;
1959 ssize_t retval = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001960 long timeout;
1961 unsigned long flags;
Alan Cox04f378b2008-04-30 00:53:29 -07001962 int packet;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001963
Linus Torvalds1da177e2005-04-16 15:20:36 -07001964 c = job_control(tty, file);
Alan Cox4edf1822008-02-08 04:18:44 -08001965 if (c < 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001966 return c;
Alan Cox4edf1822008-02-08 04:18:44 -08001967
Peter Hurley9356b532013-06-15 09:14:24 -04001968 down_read(&tty->termios_rwsem);
1969
Linus Torvalds1da177e2005-04-16 15:20:36 -07001970 minimum = time = 0;
1971 timeout = MAX_SCHEDULE_TIMEOUT;
Jiri Slaby53c5ee22012-10-18 22:26:39 +02001972 if (!ldata->icanon) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001973 minimum = MIN_CHAR(tty);
1974 if (minimum) {
Peter Hurleya6e54312013-06-15 07:28:29 -04001975 time = (HZ / 10) * TIME_CHAR(tty);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001976 if (time)
Peter Hurleyf6c8dbe2013-06-15 07:28:28 -04001977 ldata->minimum_to_wake = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001978 else if (!waitqueue_active(&tty->read_wait) ||
Peter Hurleyf6c8dbe2013-06-15 07:28:28 -04001979 (ldata->minimum_to_wake > minimum))
1980 ldata->minimum_to_wake = minimum;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001981 } else {
Peter Hurleya6e54312013-06-15 07:28:29 -04001982 timeout = (HZ / 10) * TIME_CHAR(tty);
Peter Hurleyf6c8dbe2013-06-15 07:28:28 -04001983 ldata->minimum_to_wake = minimum = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001984 }
1985 }
1986
1987 /*
1988 * Internal serialization of reads.
1989 */
1990 if (file->f_flags & O_NONBLOCK) {
Peter Hurley9356b532013-06-15 09:14:24 -04001991 if (!mutex_trylock(&ldata->atomic_read_lock)) {
1992 up_read(&tty->termios_rwsem);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001993 return -EAGAIN;
Peter Hurley9356b532013-06-15 09:14:24 -04001994 }
Alan Cox4edf1822008-02-08 04:18:44 -08001995 } else {
Peter Hurley9356b532013-06-15 09:14:24 -04001996 if (mutex_lock_interruptible(&ldata->atomic_read_lock)) {
1997 up_read(&tty->termios_rwsem);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001998 return -ERESTARTSYS;
Peter Hurley9356b532013-06-15 09:14:24 -04001999 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002000 }
Alan Cox04f378b2008-04-30 00:53:29 -07002001 packet = tty->packet;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002002
2003 add_wait_queue(&tty->read_wait, &wait);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002004 while (nr) {
2005 /* First test for status change. */
Alan Cox04f378b2008-04-30 00:53:29 -07002006 if (packet && tty->link->ctrl_status) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002007 unsigned char cs;
2008 if (b != buf)
2009 break;
Alan Cox04f378b2008-04-30 00:53:29 -07002010 spin_lock_irqsave(&tty->link->ctrl_lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002011 cs = tty->link->ctrl_status;
2012 tty->link->ctrl_status = 0;
Alan Cox04f378b2008-04-30 00:53:29 -07002013 spin_unlock_irqrestore(&tty->link->ctrl_lock, flags);
Miloslav Trmac522ed772007-07-15 23:40:56 -07002014 if (tty_put_user(tty, cs, b++)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002015 retval = -EFAULT;
2016 b--;
2017 break;
2018 }
2019 nr--;
2020 break;
2021 }
2022 /* This statement must be first before checking for input
2023 so that any interrupt will set the state back to
2024 TASK_RUNNING. */
2025 set_current_state(TASK_INTERRUPTIBLE);
Alan Cox4edf1822008-02-08 04:18:44 -08002026
Peter Hurleyf6c8dbe2013-06-15 07:28:28 -04002027 if (((minimum - (b - buf)) < ldata->minimum_to_wake) &&
Linus Torvalds1da177e2005-04-16 15:20:36 -07002028 ((minimum - (b - buf)) >= 1))
Peter Hurleyf6c8dbe2013-06-15 07:28:28 -04002029 ldata->minimum_to_wake = (minimum - (b - buf));
Alan Cox4edf1822008-02-08 04:18:44 -08002030
Linus Torvalds1da177e2005-04-16 15:20:36 -07002031 if (!input_available_p(tty, 0)) {
2032 if (test_bit(TTY_OTHER_CLOSED, &tty->flags)) {
2033 retval = -EIO;
2034 break;
2035 }
2036 if (tty_hung_up_p(file))
2037 break;
2038 if (!timeout)
2039 break;
2040 if (file->f_flags & O_NONBLOCK) {
2041 retval = -EAGAIN;
2042 break;
2043 }
2044 if (signal_pending(current)) {
2045 retval = -ERESTARTSYS;
2046 break;
2047 }
Linus Torvalds55db4c62011-06-04 06:33:24 +09002048 n_tty_set_room(tty);
Peter Hurley9356b532013-06-15 09:14:24 -04002049 up_read(&tty->termios_rwsem);
2050
Linus Torvalds1da177e2005-04-16 15:20:36 -07002051 timeout = schedule_timeout(timeout);
Peter Hurley9356b532013-06-15 09:14:24 -04002052
2053 down_read(&tty->termios_rwsem);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002054 continue;
2055 }
2056 __set_current_state(TASK_RUNNING);
2057
2058 /* Deal with packet mode. */
Alan Cox04f378b2008-04-30 00:53:29 -07002059 if (packet && b == buf) {
Miloslav Trmac522ed772007-07-15 23:40:56 -07002060 if (tty_put_user(tty, TIOCPKT_DATA, b++)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002061 retval = -EFAULT;
2062 b--;
2063 break;
2064 }
2065 nr--;
2066 }
2067
Jiri Slaby53c5ee22012-10-18 22:26:39 +02002068 if (ldata->icanon && !L_EXTPROC(tty)) {
Peter Hurley32f13522013-06-15 09:14:17 -04002069 retval = canon_copy_from_read_buf(tty, &b, &nr);
Peter Hurley40d5e092013-06-15 10:21:17 -04002070 if (retval == -EAGAIN) {
2071 retval = 0;
2072 continue;
2073 } else if (retval)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002074 break;
2075 } else {
2076 int uncopied;
Alan Cox04f378b2008-04-30 00:53:29 -07002077 /* The copy function takes the read lock and handles
2078 locking internally for this case */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002079 uncopied = copy_from_read_buf(tty, &b, &nr);
2080 uncopied += copy_from_read_buf(tty, &b, &nr);
2081 if (uncopied) {
2082 retval = -EFAULT;
2083 break;
2084 }
2085 }
2086
Peter Hurley6367ca72013-06-15 09:14:33 -04002087 n_tty_check_unthrottle(tty);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002088
2089 if (b - buf >= minimum)
2090 break;
2091 if (time)
2092 timeout = time;
2093 }
Jiri Slabybddc7152012-10-18 22:26:42 +02002094 mutex_unlock(&ldata->atomic_read_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002095 remove_wait_queue(&tty->read_wait, &wait);
2096
2097 if (!waitqueue_active(&tty->read_wait))
Peter Hurleyf6c8dbe2013-06-15 07:28:28 -04002098 ldata->minimum_to_wake = minimum;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002099
2100 __set_current_state(TASK_RUNNING);
Peter Hurley40d5e092013-06-15 10:21:17 -04002101 if (b - buf)
2102 retval = b - buf;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002103
Linus Torvalds55db4c62011-06-04 06:33:24 +09002104 n_tty_set_room(tty);
Peter Hurley9356b532013-06-15 09:14:24 -04002105 up_read(&tty->termios_rwsem);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002106 return retval;
2107}
2108
2109/**
Alan Cox11a96d12008-10-13 10:46:24 +01002110 * n_tty_write - write function for tty
Linus Torvalds1da177e2005-04-16 15:20:36 -07002111 * @tty: tty device
2112 * @file: file object
2113 * @buf: userspace buffer pointer
2114 * @nr: size of I/O
2115 *
Joe Petersona88a69c2009-01-02 13:40:53 +00002116 * Write function of the terminal device. This is serialized with
Linus Torvalds1da177e2005-04-16 15:20:36 -07002117 * respect to other write callers but not to termios changes, reads
Joe Petersona88a69c2009-01-02 13:40:53 +00002118 * and other such events. Since the receive code will echo characters,
2119 * thus calling driver write methods, the output_lock is used in
2120 * the output processing functions called here as well as in the
2121 * echo processing function to protect the column state and space
2122 * left in the buffer.
Linus Torvalds1da177e2005-04-16 15:20:36 -07002123 *
2124 * This code must be sure never to sleep through a hangup.
Joe Petersona88a69c2009-01-02 13:40:53 +00002125 *
2126 * Locking: output_lock to protect column state and space left
2127 * (note that the process_output*() functions take this
2128 * lock themselves)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002129 */
Alan Cox4edf1822008-02-08 04:18:44 -08002130
Alan Cox11a96d12008-10-13 10:46:24 +01002131static ssize_t n_tty_write(struct tty_struct *tty, struct file *file,
Joe Petersona88a69c2009-01-02 13:40:53 +00002132 const unsigned char *buf, size_t nr)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002133{
2134 const unsigned char *b = buf;
2135 DECLARE_WAITQUEUE(wait, current);
2136 int c;
2137 ssize_t retval = 0;
2138
2139 /* Job control check -- must be done at start (POSIX.1 7.1.1.4). */
2140 if (L_TOSTOP(tty) && file->f_op->write != redirected_tty_write) {
2141 retval = tty_check_change(tty);
2142 if (retval)
2143 return retval;
2144 }
2145
Peter Hurley9356b532013-06-15 09:14:24 -04002146 down_read(&tty->termios_rwsem);
2147
Joe Petersona88a69c2009-01-02 13:40:53 +00002148 /* Write out any echoed characters that are still pending */
2149 process_echoes(tty);
Alan Cox300a6202009-01-02 13:41:04 +00002150
Linus Torvalds1da177e2005-04-16 15:20:36 -07002151 add_wait_queue(&tty->write_wait, &wait);
2152 while (1) {
2153 set_current_state(TASK_INTERRUPTIBLE);
2154 if (signal_pending(current)) {
2155 retval = -ERESTARTSYS;
2156 break;
2157 }
2158 if (tty_hung_up_p(file) || (tty->link && !tty->link->count)) {
2159 retval = -EIO;
2160 break;
2161 }
Peter Hurley582f5592013-05-17 12:49:48 -04002162 if (O_OPOST(tty)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002163 while (nr > 0) {
Joe Petersona88a69c2009-01-02 13:40:53 +00002164 ssize_t num = process_output_block(tty, b, nr);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002165 if (num < 0) {
2166 if (num == -EAGAIN)
2167 break;
2168 retval = num;
2169 goto break_out;
2170 }
2171 b += num;
2172 nr -= num;
2173 if (nr == 0)
2174 break;
2175 c = *b;
Joe Petersona88a69c2009-01-02 13:40:53 +00002176 if (process_output(c, tty) < 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002177 break;
2178 b++; nr--;
2179 }
Alan Coxf34d7a52008-04-30 00:54:13 -07002180 if (tty->ops->flush_chars)
2181 tty->ops->flush_chars(tty);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002182 } else {
Roman Zippeld6afe272005-07-07 17:56:55 -07002183 while (nr > 0) {
Alan Coxf34d7a52008-04-30 00:54:13 -07002184 c = tty->ops->write(tty, b, nr);
Roman Zippeld6afe272005-07-07 17:56:55 -07002185 if (c < 0) {
2186 retval = c;
2187 goto break_out;
2188 }
2189 if (!c)
2190 break;
2191 b += c;
2192 nr -= c;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002193 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002194 }
2195 if (!nr)
2196 break;
2197 if (file->f_flags & O_NONBLOCK) {
2198 retval = -EAGAIN;
2199 break;
2200 }
Peter Hurley9356b532013-06-15 09:14:24 -04002201 up_read(&tty->termios_rwsem);
2202
Linus Torvalds1da177e2005-04-16 15:20:36 -07002203 schedule();
Peter Hurley9356b532013-06-15 09:14:24 -04002204
2205 down_read(&tty->termios_rwsem);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002206 }
2207break_out:
2208 __set_current_state(TASK_RUNNING);
2209 remove_wait_queue(&tty->write_wait, &wait);
Thomas Pfaffff8cb0f2009-01-02 13:47:13 +00002210 if (b - buf != nr && tty->fasync)
2211 set_bit(TTY_DO_WRITE_WAKEUP, &tty->flags);
Peter Hurley9356b532013-06-15 09:14:24 -04002212 up_read(&tty->termios_rwsem);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002213 return (b - buf) ? b - buf : retval;
2214}
2215
2216/**
Alan Cox11a96d12008-10-13 10:46:24 +01002217 * n_tty_poll - poll method for N_TTY
Linus Torvalds1da177e2005-04-16 15:20:36 -07002218 * @tty: terminal device
2219 * @file: file accessing it
2220 * @wait: poll table
2221 *
2222 * Called when the line discipline is asked to poll() for data or
2223 * for special events. This code is not serialized with respect to
2224 * other events save open/close.
2225 *
2226 * This code must be sure never to sleep through a hangup.
2227 * Called without the kernel lock held - fine
Linus Torvalds1da177e2005-04-16 15:20:36 -07002228 */
Alan Cox4edf1822008-02-08 04:18:44 -08002229
Alan Cox11a96d12008-10-13 10:46:24 +01002230static unsigned int n_tty_poll(struct tty_struct *tty, struct file *file,
Alan Cox4edf1822008-02-08 04:18:44 -08002231 poll_table *wait)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002232{
Peter Hurleyf6c8dbe2013-06-15 07:28:28 -04002233 struct n_tty_data *ldata = tty->disc_data;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002234 unsigned int mask = 0;
2235
2236 poll_wait(file, &tty->read_wait, wait);
2237 poll_wait(file, &tty->write_wait, wait);
2238 if (input_available_p(tty, TIME_CHAR(tty) ? 0 : MIN_CHAR(tty)))
2239 mask |= POLLIN | POLLRDNORM;
2240 if (tty->packet && tty->link->ctrl_status)
2241 mask |= POLLPRI | POLLIN | POLLRDNORM;
2242 if (test_bit(TTY_OTHER_CLOSED, &tty->flags))
2243 mask |= POLLHUP;
2244 if (tty_hung_up_p(file))
2245 mask |= POLLHUP;
2246 if (!(mask & (POLLHUP | POLLIN | POLLRDNORM))) {
2247 if (MIN_CHAR(tty) && !TIME_CHAR(tty))
Peter Hurleyf6c8dbe2013-06-15 07:28:28 -04002248 ldata->minimum_to_wake = MIN_CHAR(tty);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002249 else
Peter Hurleyf6c8dbe2013-06-15 07:28:28 -04002250 ldata->minimum_to_wake = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002251 }
Alan Coxf34d7a52008-04-30 00:54:13 -07002252 if (tty->ops->write && !tty_is_writelocked(tty) &&
2253 tty_chars_in_buffer(tty) < WAKEUP_CHARS &&
2254 tty_write_room(tty) > 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002255 mask |= POLLOUT | POLLWRNORM;
2256 return mask;
2257}
2258
Jiri Slaby57c94122012-10-18 22:26:43 +02002259static unsigned long inq_canon(struct n_tty_data *ldata)
Alan Cox47afa7a2008-10-13 10:44:17 +01002260{
Peter Hurleybc5a5e32013-06-15 09:14:21 -04002261 size_t nr, head, tail;
Alan Cox47afa7a2008-10-13 10:44:17 +01002262
Peter Hurleya73d3d62013-06-15 09:14:25 -04002263 if (ldata->canon_head == ldata->read_tail)
Alan Cox47afa7a2008-10-13 10:44:17 +01002264 return 0;
Jiri Slabyba2e68a2012-10-18 22:26:41 +02002265 head = ldata->canon_head;
2266 tail = ldata->read_tail;
Peter Hurleybc5a5e32013-06-15 09:14:21 -04002267 nr = head - tail;
Alan Cox47afa7a2008-10-13 10:44:17 +01002268 /* Skip EOF-chars.. */
2269 while (head != tail) {
Peter Hurleybc5a5e32013-06-15 09:14:21 -04002270 if (test_bit(tail & (N_TTY_BUF_SIZE - 1), ldata->read_flags) &&
2271 read_buf(ldata, tail) == __DISABLED_CHAR)
Alan Cox47afa7a2008-10-13 10:44:17 +01002272 nr--;
Peter Hurleybc5a5e32013-06-15 09:14:21 -04002273 tail++;
Alan Cox47afa7a2008-10-13 10:44:17 +01002274 }
2275 return nr;
2276}
2277
2278static int n_tty_ioctl(struct tty_struct *tty, struct file *file,
2279 unsigned int cmd, unsigned long arg)
2280{
Jiri Slabyba2e68a2012-10-18 22:26:41 +02002281 struct n_tty_data *ldata = tty->disc_data;
Alan Cox47afa7a2008-10-13 10:44:17 +01002282 int retval;
2283
2284 switch (cmd) {
2285 case TIOCOUTQ:
2286 return put_user(tty_chars_in_buffer(tty), (int __user *) arg);
2287 case TIOCINQ:
Peter Hurley6d76bd22013-06-15 09:14:26 -04002288 down_write(&tty->termios_rwsem);
Alan Cox47afa7a2008-10-13 10:44:17 +01002289 if (L_ICANON(tty))
Jiri Slaby57c94122012-10-18 22:26:43 +02002290 retval = inq_canon(ldata);
Peter Hurley6d76bd22013-06-15 09:14:26 -04002291 else
2292 retval = read_cnt(ldata);
2293 up_write(&tty->termios_rwsem);
Alan Cox47afa7a2008-10-13 10:44:17 +01002294 return put_user(retval, (unsigned int __user *) arg);
2295 default:
2296 return n_tty_ioctl_helper(tty, file, cmd, arg);
2297 }
2298}
2299
Peter Hurleyf6c8dbe2013-06-15 07:28:28 -04002300static void n_tty_fasync(struct tty_struct *tty, int on)
2301{
2302 struct n_tty_data *ldata = tty->disc_data;
2303
2304 if (!waitqueue_active(&tty->read_wait)) {
2305 if (on)
2306 ldata->minimum_to_wake = 1;
2307 else if (!tty->fasync)
2308 ldata->minimum_to_wake = N_TTY_BUF_SIZE;
2309 }
2310}
2311
Alan Coxa352def2008-07-16 21:53:12 +01002312struct tty_ldisc_ops tty_ldisc_N_TTY = {
Paul Fulghume10cc1d2007-05-10 22:22:50 -07002313 .magic = TTY_LDISC_MAGIC,
2314 .name = "n_tty",
2315 .open = n_tty_open,
2316 .close = n_tty_close,
2317 .flush_buffer = n_tty_flush_buffer,
2318 .chars_in_buffer = n_tty_chars_in_buffer,
Alan Cox11a96d12008-10-13 10:46:24 +01002319 .read = n_tty_read,
2320 .write = n_tty_write,
Paul Fulghume10cc1d2007-05-10 22:22:50 -07002321 .ioctl = n_tty_ioctl,
2322 .set_termios = n_tty_set_termios,
Alan Cox11a96d12008-10-13 10:46:24 +01002323 .poll = n_tty_poll,
Paul Fulghume10cc1d2007-05-10 22:22:50 -07002324 .receive_buf = n_tty_receive_buf,
Peter Hurleyf6c8dbe2013-06-15 07:28:28 -04002325 .write_wakeup = n_tty_write_wakeup,
2326 .fasync = n_tty_fasync,
Peter Hurley24a89d12013-06-15 09:14:15 -04002327 .receive_buf2 = n_tty_receive_buf2,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002328};
Rodolfo Giometti572b9ad2010-03-10 15:23:46 -08002329
2330/**
2331 * n_tty_inherit_ops - inherit N_TTY methods
2332 * @ops: struct tty_ldisc_ops where to save N_TTY methods
2333 *
George Spelvin593fb1ae42013-02-12 02:00:43 -05002334 * Enables a 'subclass' line discipline to 'inherit' N_TTY
Rodolfo Giometti572b9ad2010-03-10 15:23:46 -08002335 * methods.
2336 */
2337
2338void n_tty_inherit_ops(struct tty_ldisc_ops *ops)
2339{
2340 *ops = tty_ldisc_N_TTY;
2341 ops->owner = NULL;
2342 ops->refcount = ops->flags = 0;
2343}
2344EXPORT_SYMBOL_GPL(n_tty_inherit_ops);