blob: d2b496750d590c1e06d755b0b563f40c30f8d165 [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>
Peter Hurley86e35ae2013-07-24 09:30:05 -040053#include <linux/vmalloc.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070054
Linus Torvalds1da177e2005-04-16 15:20:36 -070055
56/* number of characters left in xmit buffer before select has we have room */
57#define WAKEUP_CHARS 256
58
59/*
60 * This defines the low- and high-watermarks for throttling and
61 * unthrottling the TTY driver. These watermarks are used for
62 * controlling the space in the read buffer.
63 */
64#define TTY_THRESHOLD_THROTTLE 128 /* now based on remaining room */
Thorsten Wißmannbbd20752011-12-08 17:47:33 +010065#define TTY_THRESHOLD_UNTHROTTLE 128
Linus Torvalds1da177e2005-04-16 15:20:36 -070066
Joe Petersona88a69c2009-01-02 13:40:53 +000067/*
68 * Special byte codes used in the echo buffer to represent operations
69 * or special handling of characters. Bytes in the echo buffer that
70 * are not part of such special blocks are treated as normal character
71 * codes.
72 */
73#define ECHO_OP_START 0xff
74#define ECHO_OP_MOVE_BACK_COL 0x80
75#define ECHO_OP_SET_CANON_COL 0x81
76#define ECHO_OP_ERASE_TAB 0x82
77
Peter Hurleycbfd0342013-06-15 10:04:26 -040078#define ECHO_COMMIT_WATERMARK 256
79#define ECHO_BLOCK 256
80#define ECHO_DISCARD_WATERMARK N_TTY_BUF_SIZE - (ECHO_BLOCK + 32)
81
82
Peter Hurley32f13522013-06-15 09:14:17 -040083#undef N_TTY_TRACE
84#ifdef N_TTY_TRACE
85# define n_tty_trace(f, args...) trace_printk(f, ##args)
86#else
87# define n_tty_trace(f, args...)
88#endif
89
Jiri Slaby70ece7a2012-10-18 22:26:38 +020090struct n_tty_data {
Peter Hurleyfb7aa032013-06-15 09:14:30 -040091 /* producer-published */
92 size_t read_head;
93 size_t canon_head;
Peter Hurley9dfd16d2013-06-15 10:04:29 -040094 size_t echo_head;
95 size_t echo_commit;
Peter Hurley1075a6e2013-12-09 18:06:07 -050096 size_t echo_mark;
Peter Hurley1bb9d562013-06-15 10:21:20 -040097 DECLARE_BITMAP(char_map, 256);
Peter Hurleyfb7aa032013-06-15 09:14:30 -040098
99 /* private to n_tty_receive_overrun (single-threaded) */
Jiri Slaby53c5ee22012-10-18 22:26:39 +0200100 unsigned long overrun_time;
101 int num_overrun;
102
Peter Hurley24a89d12013-06-15 09:14:15 -0400103 /* non-atomic */
104 bool no_room;
105
Peter Hurleyfb7aa032013-06-15 09:14:30 -0400106 /* must hold exclusive termios_rwsem to reset these */
Jiri Slaby53c5ee22012-10-18 22:26:39 +0200107 unsigned char lnext:1, erasing:1, raw:1, real_raw:1, icanon:1;
Peter Hurley4d0ed182013-12-10 17:12:02 -0500108 unsigned char push:1;
Jiri Slaby3fe780b2012-10-18 22:26:40 +0200109
Peter Hurleyfb7aa032013-06-15 09:14:30 -0400110 /* shared by producer and consumer */
Peter Hurley20bafb32013-06-15 10:21:19 -0400111 char read_buf[N_TTY_BUF_SIZE];
Jiri Slaby3fe780b2012-10-18 22:26:40 +0200112 DECLARE_BITMAP(read_flags, N_TTY_BUF_SIZE);
Peter Hurley20bafb32013-06-15 10:21:19 -0400113 unsigned char echo_buf[N_TTY_BUF_SIZE];
Jiri Slabyba2e68a2012-10-18 22:26:41 +0200114
Peter Hurleyf6c8dbe2013-06-15 07:28:28 -0400115 int minimum_to_wake;
Jiri Slabyba2e68a2012-10-18 22:26:41 +0200116
Peter Hurleyfb7aa032013-06-15 09:14:30 -0400117 /* consumer-published */
118 size_t read_tail;
Peter Hurley40d5e092013-06-15 10:21:17 -0400119 size_t line_start;
Peter Hurleyfb7aa032013-06-15 09:14:30 -0400120
Peter Hurleyfb7aa032013-06-15 09:14:30 -0400121 /* protected by output lock */
122 unsigned int column;
Jiri Slabyba2e68a2012-10-18 22:26:41 +0200123 unsigned int canon_column;
Peter Hurley9dfd16d2013-06-15 10:04:29 -0400124 size_t echo_tail;
Jiri Slabybddc7152012-10-18 22:26:42 +0200125
126 struct mutex atomic_read_lock;
127 struct mutex output_lock;
Jiri Slaby70ece7a2012-10-18 22:26:38 +0200128};
129
Peter Hurleyce741172013-06-15 09:14:20 -0400130static inline size_t read_cnt(struct n_tty_data *ldata)
131{
Peter Hurleya2f73be2013-06-15 09:14:22 -0400132 return ldata->read_head - ldata->read_tail;
Peter Hurleyce741172013-06-15 09:14:20 -0400133}
134
Peter Hurleybc5a5e32013-06-15 09:14:21 -0400135static inline unsigned char read_buf(struct n_tty_data *ldata, size_t i)
136{
137 return ldata->read_buf[i & (N_TTY_BUF_SIZE - 1)];
138}
139
140static inline unsigned char *read_buf_addr(struct n_tty_data *ldata, size_t i)
141{
142 return &ldata->read_buf[i & (N_TTY_BUF_SIZE - 1)];
143}
144
Peter Hurleyaddaebc2013-06-15 10:04:22 -0400145static inline unsigned char echo_buf(struct n_tty_data *ldata, size_t i)
146{
147 return ldata->echo_buf[i & (N_TTY_BUF_SIZE - 1)];
148}
149
150static inline unsigned char *echo_buf_addr(struct n_tty_data *ldata, size_t i)
151{
152 return &ldata->echo_buf[i & (N_TTY_BUF_SIZE - 1)];
153}
154
Miloslav Trmac522ed772007-07-15 23:40:56 -0700155static inline int tty_put_user(struct tty_struct *tty, unsigned char x,
156 unsigned char __user *ptr)
157{
Jiri Slaby53c5ee22012-10-18 22:26:39 +0200158 struct n_tty_data *ldata = tty->disc_data;
159
160 tty_audit_add_data(tty, &x, 1, ldata->icanon);
Miloslav Trmac522ed772007-07-15 23:40:56 -0700161 return put_user(x, ptr);
162}
163
Peter Hurley24a89d12013-06-15 09:14:15 -0400164static int receive_room(struct tty_struct *tty)
Linus Torvalds55db4c62011-06-04 06:33:24 +0900165{
Jiri Slaby53c5ee22012-10-18 22:26:39 +0200166 struct n_tty_data *ldata = tty->disc_data;
Jaeden Amero090abf72012-07-27 08:43:11 -0500167 int left;
Peter Hurleyb8483052013-06-15 07:28:30 -0400168
Jaeden Amero090abf72012-07-27 08:43:11 -0500169 if (I_PARMRK(tty)) {
170 /* Multiply read_cnt by 3, since each byte might take up to
171 * three times as many spaces when PARMRK is set (depending on
172 * its flags, e.g. parity error). */
Peter Hurleyce741172013-06-15 09:14:20 -0400173 left = N_TTY_BUF_SIZE - read_cnt(ldata) * 3 - 1;
Jaeden Amero090abf72012-07-27 08:43:11 -0500174 } else
Peter Hurleyce741172013-06-15 09:14:20 -0400175 left = N_TTY_BUF_SIZE - read_cnt(ldata) - 1;
Jaeden Amero090abf72012-07-27 08:43:11 -0500176
Linus Torvalds55db4c62011-06-04 06:33:24 +0900177 /*
178 * If we are doing input canonicalization, and there are no
179 * pending newlines, let characters through without limit, so
180 * that erase characters will be handled. Other excess
181 * characters will be beeped.
182 */
183 if (left <= 0)
Peter Hurleya73d3d62013-06-15 09:14:25 -0400184 left = ldata->icanon && ldata->canon_head == ldata->read_tail;
Linus Torvalds55db4c62011-06-04 06:33:24 +0900185
Peter Hurley24a89d12013-06-15 09:14:15 -0400186 return left;
Peter Hurley7879a9f2013-06-15 07:28:31 -0400187}
188
Peter Hurley24a89d12013-06-15 09:14:15 -0400189/**
190 * n_tty_set_room - receive space
191 * @tty: terminal
192 *
193 * Re-schedules the flip buffer work if space just became available.
194 *
Peter Hurley6d76bd22013-06-15 09:14:26 -0400195 * Caller holds exclusive termios_rwsem
196 * or
197 * n_tty_read()/consumer path:
198 * holds non-exclusive termios_rwsem
Peter Hurley24a89d12013-06-15 09:14:15 -0400199 */
200
Peter Hurley7879a9f2013-06-15 07:28:31 -0400201static void n_tty_set_room(struct tty_struct *tty)
202{
Peter Hurley24a89d12013-06-15 09:14:15 -0400203 struct n_tty_data *ldata = tty->disc_data;
204
Linus Torvalds55db4c62011-06-04 06:33:24 +0900205 /* Did this open up the receive buffer? We may need to flip */
Peter Hurley24a89d12013-06-15 09:14:15 -0400206 if (unlikely(ldata->no_room) && receive_room(tty)) {
207 ldata->no_room = 0;
208
Jiri Slabyecbbfd42012-10-18 22:26:47 +0200209 WARN_RATELIMIT(tty->port->itty == NULL,
Sasha Levincadf7482012-10-25 14:26:35 -0400210 "scheduling with invalid itty\n");
Peter Hurley21622932013-03-11 16:44:21 -0400211 /* see if ldisc has been killed - if so, this means that
212 * even though the ldisc has been halted and ->buf.work
213 * cancelled, ->buf.work is about to be rescheduled
214 */
215 WARN_RATELIMIT(test_bit(TTY_LDISC_HALTED, &tty->flags),
216 "scheduling buffer work for halted ldisc\n");
Peter Hurleyf0f947c2013-06-15 09:14:36 -0400217 queue_work(system_unbound_wq, &tty->port->buf.work);
Jiri Slabyecbbfd42012-10-18 22:26:47 +0200218 }
Linus Torvalds55db4c62011-06-04 06:33:24 +0900219}
220
Peter Hurley9a4aec22013-06-15 09:14:32 -0400221static ssize_t chars_in_buffer(struct tty_struct *tty)
222{
223 struct n_tty_data *ldata = tty->disc_data;
224 ssize_t n = 0;
225
226 if (!ldata->icanon)
227 n = read_cnt(ldata);
228 else
229 n = ldata->canon_head - ldata->read_tail;
230 return n;
231}
232
Peter Hurleyee0bab82013-06-15 09:14:34 -0400233/**
234 * n_tty_write_wakeup - asynchronous I/O notifier
235 * @tty: tty device
236 *
237 * Required for the ptys, serial driver etc. since processes
238 * that attach themselves to the master and rely on ASYNC
239 * IO must be woken up
240 */
241
242static void n_tty_write_wakeup(struct tty_struct *tty)
243{
244 if (tty->fasync && test_and_clear_bit(TTY_DO_WRITE_WAKEUP, &tty->flags))
245 kill_fasync(&tty->fasync, SIGIO, POLL_OUT);
246}
247
Peter Hurley4a23a4d2013-06-15 10:21:22 -0400248static void n_tty_check_throttle(struct tty_struct *tty)
Peter Hurley6367ca72013-06-15 09:14:33 -0400249{
Peter Hurley3afb1b392013-07-23 08:47:30 -0400250 if (tty->driver->type == TTY_DRIVER_TYPE_PTY)
251 return;
Peter Hurley6367ca72013-06-15 09:14:33 -0400252 /*
253 * Check the remaining room for the input canonicalization
254 * mode. We don't want to throttle the driver if we're in
255 * canonical mode and don't have a newline yet!
256 */
257 while (1) {
258 int throttled;
259 tty_set_flow_change(tty, TTY_THROTTLE_SAFE);
260 if (receive_room(tty) >= TTY_THRESHOLD_THROTTLE)
261 break;
262 throttled = tty_throttle_safe(tty);
263 if (!throttled)
264 break;
265 }
266 __tty_set_flow_change(tty, 0);
267}
268
Peter Hurley4b293492013-07-24 08:29:55 -0400269static void n_tty_check_unthrottle(struct tty_struct *tty)
Peter Hurley6367ca72013-06-15 09:14:33 -0400270{
Peter Hurley3afb1b392013-07-23 08:47:30 -0400271 if (tty->driver->type == TTY_DRIVER_TYPE_PTY &&
272 tty->link->ldisc->ops->write_wakeup == n_tty_write_wakeup) {
273 if (chars_in_buffer(tty) > TTY_THRESHOLD_UNTHROTTLE)
274 return;
275 if (!tty->count)
276 return;
277 n_tty_set_room(tty);
278 n_tty_write_wakeup(tty->link);
Peter Hurley6c677162013-12-02 14:24:46 -0500279 if (waitqueue_active(&tty->link->write_wait))
280 wake_up_interruptible_poll(&tty->link->write_wait, POLLOUT);
Peter Hurley3afb1b392013-07-23 08:47:30 -0400281 return;
282 }
283
Peter Hurley6367ca72013-06-15 09:14:33 -0400284 /* If there is enough space in the read buffer now, let the
285 * low-level driver know. We use chars_in_buffer() to
286 * check the buffer, as it now knows about canonical mode.
287 * Otherwise, if the driver is throttled and the line is
288 * longer than TTY_THRESHOLD_UNTHROTTLE in canonical mode,
289 * we won't get any more characters.
290 */
291
292 while (1) {
293 int unthrottled;
294 tty_set_flow_change(tty, TTY_UNTHROTTLE_SAFE);
295 if (chars_in_buffer(tty) > TTY_THRESHOLD_UNTHROTTLE)
296 break;
297 if (!tty->count)
298 break;
299 n_tty_set_room(tty);
300 unthrottled = tty_unthrottle_safe(tty);
301 if (!unthrottled)
302 break;
303 }
304 __tty_set_flow_change(tty, 0);
305}
306
Alan Cox17b82062008-10-13 10:45:06 +0100307/**
308 * put_tty_queue - add character to tty
309 * @c: character
Jiri Slaby57c94122012-10-18 22:26:43 +0200310 * @ldata: n_tty data
Alan Cox17b82062008-10-13 10:45:06 +0100311 *
Peter Hurley6d76bd22013-06-15 09:14:26 -0400312 * Add a character to the tty read_buf queue.
313 *
314 * n_tty_receive_buf()/producer path:
315 * caller holds non-exclusive termios_rwsem
316 * modifies read_head
317 *
318 * read_head is only considered 'published' if canonical mode is
319 * not active.
Alan Cox17b82062008-10-13 10:45:06 +0100320 */
321
Peter Hurley19e2ad62013-07-24 08:29:54 -0400322static inline void put_tty_queue(unsigned char c, struct n_tty_data *ldata)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700323{
Christian Riesch8bfbe2d2014-11-13 05:53:26 +0100324 *read_buf_addr(ldata, ldata->read_head) = c;
325 ldata->read_head++;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700326}
327
328/**
Linus Torvalds1da177e2005-04-16 15:20:36 -0700329 * reset_buffer_flags - reset buffer state
330 * @tty: terminal to reset
331 *
Peter Hurley25518c62013-03-11 16:44:31 -0400332 * Reset the read buffer counters and clear the flags.
333 * Called from n_tty_open() and n_tty_flush_buffer().
Alan Cox17b82062008-10-13 10:45:06 +0100334 *
Peter Hurley6d76bd22013-06-15 09:14:26 -0400335 * Locking: caller holds exclusive termios_rwsem
336 * (or locking is not required)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700337 */
Joe Petersona88a69c2009-01-02 13:40:53 +0000338
Peter Hurleyb66f4fa2013-03-11 16:44:32 -0400339static void reset_buffer_flags(struct n_tty_data *ldata)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700340{
Peter Hurleya73d3d62013-06-15 09:14:25 -0400341 ldata->read_head = ldata->canon_head = ldata->read_tail = 0;
Peter Hurley17bd7902013-06-15 10:04:24 -0400342 ldata->echo_head = ldata->echo_tail = ldata->echo_commit = 0;
Peter Hurley1075a6e2013-12-09 18:06:07 -0500343 ldata->echo_mark = 0;
Peter Hurley40d5e092013-06-15 10:21:17 -0400344 ldata->line_start = 0;
Joe Petersona88a69c2009-01-02 13:40:53 +0000345
Peter Hurleya73d3d62013-06-15 09:14:25 -0400346 ldata->erasing = 0;
Jiri Slaby3fe780b2012-10-18 22:26:40 +0200347 bitmap_zero(ldata->read_flags, N_TTY_BUF_SIZE);
Peter Hurley4d0ed182013-12-10 17:12:02 -0500348 ldata->push = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700349}
350
Peter Hurleya30737a2013-03-11 16:44:22 -0400351static void n_tty_packet_mode_flush(struct tty_struct *tty)
352{
353 unsigned long flags;
354
Peter Hurleya30737a2013-03-11 16:44:22 -0400355 if (tty->link->packet) {
Peter Hurley54e8e5f2014-10-16 15:33:26 -0400356 spin_lock_irqsave(&tty->ctrl_lock, flags);
Peter Hurleya30737a2013-03-11 16:44:22 -0400357 tty->ctrl_status |= TIOCPKT_FLUSHREAD;
Peter Hurley54e8e5f2014-10-16 15:33:26 -0400358 spin_unlock_irqrestore(&tty->ctrl_lock, flags);
Peter Hurley6c677162013-12-02 14:24:46 -0500359 if (waitqueue_active(&tty->link->read_wait))
360 wake_up_interruptible(&tty->link->read_wait);
Peter Hurleya30737a2013-03-11 16:44:22 -0400361 }
Peter Hurleya30737a2013-03-11 16:44:22 -0400362}
363
Linus Torvalds1da177e2005-04-16 15:20:36 -0700364/**
365 * n_tty_flush_buffer - clean input queue
366 * @tty: terminal device
367 *
Peter Hurley25518c62013-03-11 16:44:31 -0400368 * Flush the input buffer. Called when the tty layer wants the
369 * buffer flushed (eg at hangup) or when the N_TTY line discipline
370 * internally has to clean the pending queue (for example some signals).
Linus Torvalds1da177e2005-04-16 15:20:36 -0700371 *
Peter Hurley6d76bd22013-06-15 09:14:26 -0400372 * Holds termios_rwsem to exclude producer/consumer while
373 * buffer indices are reset.
374 *
375 * Locking: ctrl_lock, exclusive termios_rwsem
Linus Torvalds1da177e2005-04-16 15:20:36 -0700376 */
Alan Cox4edf1822008-02-08 04:18:44 -0800377
378static void n_tty_flush_buffer(struct tty_struct *tty)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700379{
Peter Hurley6d76bd22013-06-15 09:14:26 -0400380 down_write(&tty->termios_rwsem);
Peter Hurleyb66f4fa2013-03-11 16:44:32 -0400381 reset_buffer_flags(tty->disc_data);
382 n_tty_set_room(tty);
Alan Cox4edf1822008-02-08 04:18:44 -0800383
Peter Hurleya30737a2013-03-11 16:44:22 -0400384 if (tty->link)
385 n_tty_packet_mode_flush(tty);
Peter Hurley6d76bd22013-06-15 09:14:26 -0400386 up_write(&tty->termios_rwsem);
387}
388
Linus Torvalds1da177e2005-04-16 15:20:36 -0700389/**
390 * n_tty_chars_in_buffer - report available bytes
391 * @tty: tty device
392 *
393 * Report the number of characters buffered to be delivered to user
Alan Cox4edf1822008-02-08 04:18:44 -0800394 * at this instant in time.
Alan Cox17b82062008-10-13 10:45:06 +0100395 *
Peter Hurley6d76bd22013-06-15 09:14:26 -0400396 * Locking: exclusive termios_rwsem
Linus Torvalds1da177e2005-04-16 15:20:36 -0700397 */
Alan Cox4edf1822008-02-08 04:18:44 -0800398
Peter Hurleya19d0c62013-06-15 09:14:18 -0400399static ssize_t n_tty_chars_in_buffer(struct tty_struct *tty)
400{
Peter Hurley6d76bd22013-06-15 09:14:26 -0400401 ssize_t n;
402
Peter Hurley47534082013-06-15 09:14:19 -0400403 WARN_ONCE(1, "%s is deprecated and scheduled for removal.", __func__);
Peter Hurley6d76bd22013-06-15 09:14:26 -0400404
405 down_write(&tty->termios_rwsem);
406 n = chars_in_buffer(tty);
407 up_write(&tty->termios_rwsem);
408 return n;
Peter Hurleya19d0c62013-06-15 09:14:18 -0400409}
410
Linus Torvalds1da177e2005-04-16 15:20:36 -0700411/**
412 * is_utf8_continuation - utf8 multibyte check
413 * @c: byte to check
414 *
415 * Returns true if the utf8 character 'c' is a multibyte continuation
416 * character. We use this to correctly compute the on screen size
417 * of the character when printing
418 */
Alan Cox4edf1822008-02-08 04:18:44 -0800419
Linus Torvalds1da177e2005-04-16 15:20:36 -0700420static inline int is_utf8_continuation(unsigned char c)
421{
422 return (c & 0xc0) == 0x80;
423}
424
425/**
426 * is_continuation - multibyte check
427 * @c: byte to check
428 *
429 * Returns true if the utf8 character 'c' is a multibyte continuation
430 * character and the terminal is in unicode mode.
431 */
Alan Cox4edf1822008-02-08 04:18:44 -0800432
Linus Torvalds1da177e2005-04-16 15:20:36 -0700433static inline int is_continuation(unsigned char c, struct tty_struct *tty)
434{
435 return I_IUTF8(tty) && is_utf8_continuation(c);
436}
437
438/**
Joe Petersona88a69c2009-01-02 13:40:53 +0000439 * do_output_char - output one character
440 * @c: character (or partial unicode symbol)
441 * @tty: terminal device
442 * @space: space available in tty driver write buffer
443 *
444 * This is a helper function that handles one output character
445 * (including special characters like TAB, CR, LF, etc.),
Joe Petersonee5aa7b2009-09-09 15:03:13 -0600446 * doing OPOST processing and putting the results in the
447 * tty driver's write buffer.
Joe Petersona88a69c2009-01-02 13:40:53 +0000448 *
449 * Note that Linux currently ignores TABDLY, CRDLY, VTDLY, FFDLY
450 * and NLDLY. They simply aren't relevant in the world today.
451 * If you ever need them, add them here.
452 *
453 * Returns the number of bytes of buffer space used or -1 if
454 * no space left.
455 *
456 * Locking: should be called under the output_lock to protect
457 * the column state and space left in the buffer
458 */
459
460static int do_output_char(unsigned char c, struct tty_struct *tty, int space)
461{
Jiri Slaby53c5ee22012-10-18 22:26:39 +0200462 struct n_tty_data *ldata = tty->disc_data;
Joe Petersona88a69c2009-01-02 13:40:53 +0000463 int spaces;
464
465 if (!space)
466 return -1;
Alan Cox300a6202009-01-02 13:41:04 +0000467
Joe Petersona88a69c2009-01-02 13:40:53 +0000468 switch (c) {
469 case '\n':
470 if (O_ONLRET(tty))
Jiri Slaby53c5ee22012-10-18 22:26:39 +0200471 ldata->column = 0;
Joe Petersona88a69c2009-01-02 13:40:53 +0000472 if (O_ONLCR(tty)) {
473 if (space < 2)
474 return -1;
Jiri Slabyba2e68a2012-10-18 22:26:41 +0200475 ldata->canon_column = ldata->column = 0;
Linus Torvalds37f81fa2009-09-05 12:46:07 -0700476 tty->ops->write(tty, "\r\n", 2);
Joe Petersona88a69c2009-01-02 13:40:53 +0000477 return 2;
478 }
Jiri Slabyba2e68a2012-10-18 22:26:41 +0200479 ldata->canon_column = ldata->column;
Joe Petersona88a69c2009-01-02 13:40:53 +0000480 break;
481 case '\r':
Jiri Slaby53c5ee22012-10-18 22:26:39 +0200482 if (O_ONOCR(tty) && ldata->column == 0)
Joe Petersona88a69c2009-01-02 13:40:53 +0000483 return 0;
484 if (O_OCRNL(tty)) {
485 c = '\n';
486 if (O_ONLRET(tty))
Jiri Slabyba2e68a2012-10-18 22:26:41 +0200487 ldata->canon_column = ldata->column = 0;
Joe Petersona88a69c2009-01-02 13:40:53 +0000488 break;
489 }
Jiri Slabyba2e68a2012-10-18 22:26:41 +0200490 ldata->canon_column = ldata->column = 0;
Joe Petersona88a69c2009-01-02 13:40:53 +0000491 break;
492 case '\t':
Jiri Slaby53c5ee22012-10-18 22:26:39 +0200493 spaces = 8 - (ldata->column & 7);
Joe Petersona88a69c2009-01-02 13:40:53 +0000494 if (O_TABDLY(tty) == XTABS) {
495 if (space < spaces)
496 return -1;
Jiri Slaby53c5ee22012-10-18 22:26:39 +0200497 ldata->column += spaces;
Joe Petersona88a69c2009-01-02 13:40:53 +0000498 tty->ops->write(tty, " ", spaces);
499 return spaces;
500 }
Jiri Slaby53c5ee22012-10-18 22:26:39 +0200501 ldata->column += spaces;
Joe Petersona88a69c2009-01-02 13:40:53 +0000502 break;
503 case '\b':
Jiri Slaby53c5ee22012-10-18 22:26:39 +0200504 if (ldata->column > 0)
505 ldata->column--;
Joe Petersona88a69c2009-01-02 13:40:53 +0000506 break;
507 default:
Joe Petersona59c0d62009-01-02 13:43:25 +0000508 if (!iscntrl(c)) {
509 if (O_OLCUC(tty))
510 c = toupper(c);
511 if (!is_continuation(c, tty))
Jiri Slaby53c5ee22012-10-18 22:26:39 +0200512 ldata->column++;
Joe Petersona59c0d62009-01-02 13:43:25 +0000513 }
Joe Petersona88a69c2009-01-02 13:40:53 +0000514 break;
515 }
516
517 tty_put_char(tty, c);
518 return 1;
519}
520
521/**
522 * process_output - output post processor
Linus Torvalds1da177e2005-04-16 15:20:36 -0700523 * @c: character (or partial unicode symbol)
524 * @tty: terminal device
525 *
Joe Petersonee5aa7b2009-09-09 15:03:13 -0600526 * Output one character with OPOST processing.
527 * Returns -1 when the output device is full and the character
528 * must be retried.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700529 *
Joe Petersona88a69c2009-01-02 13:40:53 +0000530 * Locking: output_lock to protect column state and space left
531 * (also, this is called from n_tty_write under the
532 * tty layer write lock)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700533 */
Alan Cox4edf1822008-02-08 04:18:44 -0800534
Joe Petersona88a69c2009-01-02 13:40:53 +0000535static int process_output(unsigned char c, struct tty_struct *tty)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700536{
Jiri Slabybddc7152012-10-18 22:26:42 +0200537 struct n_tty_data *ldata = tty->disc_data;
Joe Petersona88a69c2009-01-02 13:40:53 +0000538 int space, retval;
539
Jiri Slabybddc7152012-10-18 22:26:42 +0200540 mutex_lock(&ldata->output_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700541
Alan Coxf34d7a52008-04-30 00:54:13 -0700542 space = tty_write_room(tty);
Joe Petersona88a69c2009-01-02 13:40:53 +0000543 retval = do_output_char(c, tty, space);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700544
Jiri Slabybddc7152012-10-18 22:26:42 +0200545 mutex_unlock(&ldata->output_lock);
Joe Petersona88a69c2009-01-02 13:40:53 +0000546 if (retval < 0)
547 return -1;
548 else
549 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700550}
551
552/**
Joe Petersona88a69c2009-01-02 13:40:53 +0000553 * process_output_block - block post processor
Linus Torvalds1da177e2005-04-16 15:20:36 -0700554 * @tty: terminal device
Joe Petersonee5aa7b2009-09-09 15:03:13 -0600555 * @buf: character buffer
556 * @nr: number of bytes to output
557 *
558 * Output a block of characters with OPOST processing.
559 * Returns the number of characters output.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700560 *
561 * This path is used to speed up block console writes, among other
562 * things when processing blocks of output data. It handles only
563 * the simple cases normally found and helps to generate blocks of
564 * symbols for the console driver and thus improve performance.
565 *
Joe Petersona88a69c2009-01-02 13:40:53 +0000566 * Locking: output_lock to protect column state and space left
567 * (also, this is called from n_tty_write under the
568 * tty layer write lock)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700569 */
Alan Cox4edf1822008-02-08 04:18:44 -0800570
Joe Petersona88a69c2009-01-02 13:40:53 +0000571static ssize_t process_output_block(struct tty_struct *tty,
572 const unsigned char *buf, unsigned int nr)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700573{
Jiri Slaby53c5ee22012-10-18 22:26:39 +0200574 struct n_tty_data *ldata = tty->disc_data;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700575 int space;
Thorsten Wißmannbbd20752011-12-08 17:47:33 +0100576 int i;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700577 const unsigned char *cp;
578
Jiri Slabybddc7152012-10-18 22:26:42 +0200579 mutex_lock(&ldata->output_lock);
Joe Petersona88a69c2009-01-02 13:40:53 +0000580
Alan Coxf34d7a52008-04-30 00:54:13 -0700581 space = tty_write_room(tty);
Alan Cox300a6202009-01-02 13:41:04 +0000582 if (!space) {
Jiri Slabybddc7152012-10-18 22:26:42 +0200583 mutex_unlock(&ldata->output_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700584 return 0;
Joe Petersona88a69c2009-01-02 13:40:53 +0000585 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700586 if (nr > space)
587 nr = space;
588
589 for (i = 0, cp = buf; i < nr; i++, cp++) {
Joe Petersona59c0d62009-01-02 13:43:25 +0000590 unsigned char c = *cp;
591
592 switch (c) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700593 case '\n':
594 if (O_ONLRET(tty))
Jiri Slaby53c5ee22012-10-18 22:26:39 +0200595 ldata->column = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700596 if (O_ONLCR(tty))
597 goto break_out;
Jiri Slabyba2e68a2012-10-18 22:26:41 +0200598 ldata->canon_column = ldata->column;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700599 break;
600 case '\r':
Jiri Slaby53c5ee22012-10-18 22:26:39 +0200601 if (O_ONOCR(tty) && ldata->column == 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700602 goto break_out;
603 if (O_OCRNL(tty))
604 goto break_out;
Jiri Slabyba2e68a2012-10-18 22:26:41 +0200605 ldata->canon_column = ldata->column = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700606 break;
607 case '\t':
608 goto break_out;
609 case '\b':
Jiri Slaby53c5ee22012-10-18 22:26:39 +0200610 if (ldata->column > 0)
611 ldata->column--;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700612 break;
613 default:
Joe Petersona59c0d62009-01-02 13:43:25 +0000614 if (!iscntrl(c)) {
615 if (O_OLCUC(tty))
616 goto break_out;
617 if (!is_continuation(c, tty))
Jiri Slaby53c5ee22012-10-18 22:26:39 +0200618 ldata->column++;
Joe Petersona59c0d62009-01-02 13:43:25 +0000619 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700620 break;
621 }
622 }
623break_out:
Alan Coxf34d7a52008-04-30 00:54:13 -0700624 i = tty->ops->write(tty, buf, i);
Joe Petersona88a69c2009-01-02 13:40:53 +0000625
Jiri Slabybddc7152012-10-18 22:26:42 +0200626 mutex_unlock(&ldata->output_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700627 return i;
628}
629
Joe Petersona88a69c2009-01-02 13:40:53 +0000630/**
631 * process_echoes - write pending echo characters
632 * @tty: terminal device
633 *
634 * Write previously buffered echo (and other ldisc-generated)
635 * characters to the tty.
636 *
637 * Characters generated by the ldisc (including echoes) need to
638 * be buffered because the driver's write buffer can fill during
639 * heavy program output. Echoing straight to the driver will
640 * often fail under these conditions, causing lost characters and
641 * resulting mismatches of ldisc state information.
642 *
643 * Since the ldisc state must represent the characters actually sent
644 * to the driver at the time of the write, operations like certain
645 * changes in column state are also saved in the buffer and executed
646 * here.
647 *
648 * A circular fifo buffer is used so that the most recent characters
649 * are prioritized. Also, when control characters are echoed with a
650 * prefixed "^", the pair is treated atomically and thus not separated.
651 *
Peter Hurley019ebdf2013-06-15 10:04:25 -0400652 * Locking: callers must hold output_lock
Joe Petersona88a69c2009-01-02 13:40:53 +0000653 */
654
Peter Hurleybc5b1ec2013-06-15 10:04:27 -0400655static size_t __process_echoes(struct tty_struct *tty)
Joe Petersona88a69c2009-01-02 13:40:53 +0000656{
Jiri Slaby53c5ee22012-10-18 22:26:39 +0200657 struct n_tty_data *ldata = tty->disc_data;
Peter Hurleybc5b1ec2013-06-15 10:04:27 -0400658 int space, old_space;
Peter Hurleyaddaebc2013-06-15 10:04:22 -0400659 size_t tail;
Joe Petersona88a69c2009-01-02 13:40:53 +0000660 unsigned char c;
Joe Petersona88a69c2009-01-02 13:40:53 +0000661
Peter Hurleybc5b1ec2013-06-15 10:04:27 -0400662 old_space = space = tty_write_room(tty);
Joe Petersona88a69c2009-01-02 13:40:53 +0000663
Peter Hurleyaddaebc2013-06-15 10:04:22 -0400664 tail = ldata->echo_tail;
Peter Hurley29c7c5c2013-06-15 10:04:28 -0400665 while (ldata->echo_commit != tail) {
Peter Hurleyaddaebc2013-06-15 10:04:22 -0400666 c = echo_buf(ldata, tail);
Joe Petersona88a69c2009-01-02 13:40:53 +0000667 if (c == ECHO_OP_START) {
668 unsigned char op;
Joe Petersona88a69c2009-01-02 13:40:53 +0000669 int no_space_left = 0;
670
671 /*
672 * If the buffer byte is the start of a multi-byte
673 * operation, get the next byte, which is either the
674 * op code or a control character value.
675 */
Peter Hurleyaddaebc2013-06-15 10:04:22 -0400676 op = echo_buf(ldata, tail + 1);
Alan Cox300a6202009-01-02 13:41:04 +0000677
Joe Petersona88a69c2009-01-02 13:40:53 +0000678 switch (op) {
679 unsigned int num_chars, num_bs;
680
681 case ECHO_OP_ERASE_TAB:
Peter Hurleyaddaebc2013-06-15 10:04:22 -0400682 num_chars = echo_buf(ldata, tail + 2);
Joe Petersona88a69c2009-01-02 13:40:53 +0000683
684 /*
685 * Determine how many columns to go back
686 * in order to erase the tab.
687 * This depends on the number of columns
688 * used by other characters within the tab
689 * area. If this (modulo 8) count is from
690 * the start of input rather than from a
691 * previous tab, we offset by canon column.
692 * Otherwise, tab spacing is normal.
693 */
694 if (!(num_chars & 0x80))
Jiri Slabyba2e68a2012-10-18 22:26:41 +0200695 num_chars += ldata->canon_column;
Joe Petersona88a69c2009-01-02 13:40:53 +0000696 num_bs = 8 - (num_chars & 7);
697
698 if (num_bs > space) {
699 no_space_left = 1;
700 break;
701 }
702 space -= num_bs;
703 while (num_bs--) {
704 tty_put_char(tty, '\b');
Jiri Slaby53c5ee22012-10-18 22:26:39 +0200705 if (ldata->column > 0)
706 ldata->column--;
Joe Petersona88a69c2009-01-02 13:40:53 +0000707 }
Peter Hurleyaddaebc2013-06-15 10:04:22 -0400708 tail += 3;
Joe Petersona88a69c2009-01-02 13:40:53 +0000709 break;
710
711 case ECHO_OP_SET_CANON_COL:
Jiri Slabyba2e68a2012-10-18 22:26:41 +0200712 ldata->canon_column = ldata->column;
Peter Hurleyaddaebc2013-06-15 10:04:22 -0400713 tail += 2;
Joe Petersona88a69c2009-01-02 13:40:53 +0000714 break;
715
716 case ECHO_OP_MOVE_BACK_COL:
Jiri Slaby53c5ee22012-10-18 22:26:39 +0200717 if (ldata->column > 0)
718 ldata->column--;
Peter Hurleyaddaebc2013-06-15 10:04:22 -0400719 tail += 2;
Joe Petersona88a69c2009-01-02 13:40:53 +0000720 break;
721
722 case ECHO_OP_START:
723 /* This is an escaped echo op start code */
724 if (!space) {
725 no_space_left = 1;
726 break;
727 }
728 tty_put_char(tty, ECHO_OP_START);
Jiri Slaby53c5ee22012-10-18 22:26:39 +0200729 ldata->column++;
Joe Petersona88a69c2009-01-02 13:40:53 +0000730 space--;
Peter Hurleyaddaebc2013-06-15 10:04:22 -0400731 tail += 2;
Joe Petersona88a69c2009-01-02 13:40:53 +0000732 break;
733
734 default:
Joe Petersona88a69c2009-01-02 13:40:53 +0000735 /*
Joe Peterson62b26352009-09-09 15:03:47 -0600736 * If the op is not a special byte code,
737 * it is a ctrl char tagged to be echoed
738 * as "^X" (where X is the letter
739 * representing the control char).
740 * Note that we must ensure there is
741 * enough space for the whole ctrl pair.
742 *
Joe Petersona88a69c2009-01-02 13:40:53 +0000743 */
Joe Peterson62b26352009-09-09 15:03:47 -0600744 if (space < 2) {
745 no_space_left = 1;
746 break;
747 }
748 tty_put_char(tty, '^');
749 tty_put_char(tty, op ^ 0100);
Jiri Slaby53c5ee22012-10-18 22:26:39 +0200750 ldata->column += 2;
Joe Peterson62b26352009-09-09 15:03:47 -0600751 space -= 2;
Peter Hurleyaddaebc2013-06-15 10:04:22 -0400752 tail += 2;
Joe Petersona88a69c2009-01-02 13:40:53 +0000753 }
754
755 if (no_space_left)
756 break;
757 } else {
Peter Hurley582f5592013-05-17 12:49:48 -0400758 if (O_OPOST(tty)) {
Joe Petersonee5aa7b2009-09-09 15:03:13 -0600759 int retval = do_output_char(c, tty, space);
760 if (retval < 0)
761 break;
762 space -= retval;
763 } else {
764 if (!space)
765 break;
766 tty_put_char(tty, c);
767 space -= 1;
768 }
Peter Hurleyaddaebc2013-06-15 10:04:22 -0400769 tail += 1;
Joe Petersona88a69c2009-01-02 13:40:53 +0000770 }
Joe Petersona88a69c2009-01-02 13:40:53 +0000771 }
772
Peter Hurleycbfd0342013-06-15 10:04:26 -0400773 /* If the echo buffer is nearly full (so that the possibility exists
774 * of echo overrun before the next commit), then discard enough
775 * data at the tail to prevent a subsequent overrun */
776 while (ldata->echo_commit - tail >= ECHO_DISCARD_WATERMARK) {
Roel Kluinc476f652013-10-11 22:08:49 +0200777 if (echo_buf(ldata, tail) == ECHO_OP_START) {
Peter Hurley6f222532013-11-08 09:42:18 -0500778 if (echo_buf(ldata, tail + 1) == ECHO_OP_ERASE_TAB)
Peter Hurleycbfd0342013-06-15 10:04:26 -0400779 tail += 3;
780 else
781 tail += 2;
782 } else
783 tail++;
784 }
785
Peter Hurleyaddaebc2013-06-15 10:04:22 -0400786 ldata->echo_tail = tail;
Peter Hurleybc5b1ec2013-06-15 10:04:27 -0400787 return old_space - space;
Joe Petersona88a69c2009-01-02 13:40:53 +0000788}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700789
Peter Hurley17bd7902013-06-15 10:04:24 -0400790static void commit_echoes(struct tty_struct *tty)
791{
792 struct n_tty_data *ldata = tty->disc_data;
Peter Hurleybc5b1ec2013-06-15 10:04:27 -0400793 size_t nr, old, echoed;
Peter Hurleycbfd0342013-06-15 10:04:26 -0400794 size_t head;
795
796 head = ldata->echo_head;
Peter Hurley1075a6e2013-12-09 18:06:07 -0500797 ldata->echo_mark = head;
Peter Hurleycbfd0342013-06-15 10:04:26 -0400798 old = ldata->echo_commit - ldata->echo_tail;
799
800 /* Process committed echoes if the accumulated # of bytes
801 * is over the threshold (and try again each time another
802 * block is accumulated) */
803 nr = head - ldata->echo_tail;
804 if (nr < ECHO_COMMIT_WATERMARK || (nr % ECHO_BLOCK > old % ECHO_BLOCK))
805 return;
Peter Hurley17bd7902013-06-15 10:04:24 -0400806
Peter Hurley019ebdf2013-06-15 10:04:25 -0400807 mutex_lock(&ldata->output_lock);
Peter Hurleycbfd0342013-06-15 10:04:26 -0400808 ldata->echo_commit = head;
Peter Hurleybc5b1ec2013-06-15 10:04:27 -0400809 echoed = __process_echoes(tty);
Peter Hurley019ebdf2013-06-15 10:04:25 -0400810 mutex_unlock(&ldata->output_lock);
811
Peter Hurleybc5b1ec2013-06-15 10:04:27 -0400812 if (echoed && tty->ops->flush_chars)
Peter Hurley019ebdf2013-06-15 10:04:25 -0400813 tty->ops->flush_chars(tty);
814}
815
816static void process_echoes(struct tty_struct *tty)
817{
818 struct n_tty_data *ldata = tty->disc_data;
Peter Hurleybc5b1ec2013-06-15 10:04:27 -0400819 size_t echoed;
Peter Hurley019ebdf2013-06-15 10:04:25 -0400820
Peter Hurleye2613be2014-02-11 16:34:55 -0500821 if (ldata->echo_mark == ldata->echo_tail)
Peter Hurley019ebdf2013-06-15 10:04:25 -0400822 return;
823
824 mutex_lock(&ldata->output_lock);
Peter Hurley1075a6e2013-12-09 18:06:07 -0500825 ldata->echo_commit = ldata->echo_mark;
Peter Hurleybc5b1ec2013-06-15 10:04:27 -0400826 echoed = __process_echoes(tty);
Peter Hurley019ebdf2013-06-15 10:04:25 -0400827 mutex_unlock(&ldata->output_lock);
828
Peter Hurleybc5b1ec2013-06-15 10:04:27 -0400829 if (echoed && tty->ops->flush_chars)
Peter Hurley019ebdf2013-06-15 10:04:25 -0400830 tty->ops->flush_chars(tty);
Peter Hurley17bd7902013-06-15 10:04:24 -0400831}
832
Peter Hurley1075a6e2013-12-09 18:06:07 -0500833/* NB: echo_mark and echo_head should be equivalent here */
Peter Hurleycbfd0342013-06-15 10:04:26 -0400834static void flush_echoes(struct tty_struct *tty)
835{
836 struct n_tty_data *ldata = tty->disc_data;
837
Peter Hurley39434ab2013-11-29 12:56:10 -0500838 if ((!L_ECHO(tty) && !L_ECHONL(tty)) ||
839 ldata->echo_commit == ldata->echo_head)
Peter Hurleycbfd0342013-06-15 10:04:26 -0400840 return;
841
842 mutex_lock(&ldata->output_lock);
843 ldata->echo_commit = ldata->echo_head;
844 __process_echoes(tty);
845 mutex_unlock(&ldata->output_lock);
846}
847
Linus Torvalds1da177e2005-04-16 15:20:36 -0700848/**
Joe Petersona88a69c2009-01-02 13:40:53 +0000849 * add_echo_byte - add a byte to the echo buffer
850 * @c: unicode byte to echo
Jiri Slaby57c94122012-10-18 22:26:43 +0200851 * @ldata: n_tty data
Joe Petersona88a69c2009-01-02 13:40:53 +0000852 *
853 * Add a character or operation byte to the echo buffer.
Joe Petersona88a69c2009-01-02 13:40:53 +0000854 */
855
Peter Hurleycbfd0342013-06-15 10:04:26 -0400856static inline void add_echo_byte(unsigned char c, struct n_tty_data *ldata)
Joe Petersona88a69c2009-01-02 13:40:53 +0000857{
Peter Hurleyaddaebc2013-06-15 10:04:22 -0400858 *echo_buf_addr(ldata, ldata->echo_head++) = c;
Joe Petersona88a69c2009-01-02 13:40:53 +0000859}
860
861/**
862 * echo_move_back_col - add operation to move back a column
Jiri Slaby57c94122012-10-18 22:26:43 +0200863 * @ldata: n_tty data
Joe Petersona88a69c2009-01-02 13:40:53 +0000864 *
865 * Add an operation to the echo buffer to move back one column.
Joe Petersona88a69c2009-01-02 13:40:53 +0000866 */
867
Jiri Slaby57c94122012-10-18 22:26:43 +0200868static void echo_move_back_col(struct n_tty_data *ldata)
Joe Petersona88a69c2009-01-02 13:40:53 +0000869{
Jiri Slaby57c94122012-10-18 22:26:43 +0200870 add_echo_byte(ECHO_OP_START, ldata);
871 add_echo_byte(ECHO_OP_MOVE_BACK_COL, ldata);
Joe Petersona88a69c2009-01-02 13:40:53 +0000872}
873
874/**
875 * echo_set_canon_col - add operation to set the canon column
Jiri Slaby57c94122012-10-18 22:26:43 +0200876 * @ldata: n_tty data
Joe Petersona88a69c2009-01-02 13:40:53 +0000877 *
878 * Add an operation to the echo buffer to set the canon column
879 * to the current column.
Joe Petersona88a69c2009-01-02 13:40:53 +0000880 */
881
Jiri Slaby57c94122012-10-18 22:26:43 +0200882static void echo_set_canon_col(struct n_tty_data *ldata)
Joe Petersona88a69c2009-01-02 13:40:53 +0000883{
Jiri Slaby57c94122012-10-18 22:26:43 +0200884 add_echo_byte(ECHO_OP_START, ldata);
885 add_echo_byte(ECHO_OP_SET_CANON_COL, ldata);
Joe Petersona88a69c2009-01-02 13:40:53 +0000886}
887
888/**
889 * echo_erase_tab - add operation to erase a tab
890 * @num_chars: number of character columns already used
891 * @after_tab: true if num_chars starts after a previous tab
Jiri Slaby57c94122012-10-18 22:26:43 +0200892 * @ldata: n_tty data
Joe Petersona88a69c2009-01-02 13:40:53 +0000893 *
894 * Add an operation to the echo buffer to erase a tab.
895 *
896 * Called by the eraser function, which knows how many character
897 * columns have been used since either a previous tab or the start
898 * of input. This information will be used later, along with
899 * canon column (if applicable), to go back the correct number
900 * of columns.
Joe Petersona88a69c2009-01-02 13:40:53 +0000901 */
902
903static void echo_erase_tab(unsigned int num_chars, int after_tab,
Jiri Slaby57c94122012-10-18 22:26:43 +0200904 struct n_tty_data *ldata)
Joe Petersona88a69c2009-01-02 13:40:53 +0000905{
Jiri Slaby57c94122012-10-18 22:26:43 +0200906 add_echo_byte(ECHO_OP_START, ldata);
907 add_echo_byte(ECHO_OP_ERASE_TAB, ldata);
Joe Petersona88a69c2009-01-02 13:40:53 +0000908
909 /* We only need to know this modulo 8 (tab spacing) */
910 num_chars &= 7;
911
912 /* Set the high bit as a flag if num_chars is after a previous tab */
913 if (after_tab)
914 num_chars |= 0x80;
Alan Cox300a6202009-01-02 13:41:04 +0000915
Jiri Slaby57c94122012-10-18 22:26:43 +0200916 add_echo_byte(num_chars, ldata);
Joe Petersona88a69c2009-01-02 13:40:53 +0000917}
918
919/**
920 * echo_char_raw - echo a character raw
Linus Torvalds1da177e2005-04-16 15:20:36 -0700921 * @c: unicode byte to echo
922 * @tty: terminal device
923 *
Alan Cox4edf1822008-02-08 04:18:44 -0800924 * Echo user input back onto the screen. This must be called only when
Linus Torvalds1da177e2005-04-16 15:20:36 -0700925 * L_ECHO(tty) is true. Called from the driver receive_buf path.
Alan Cox17b82062008-10-13 10:45:06 +0100926 *
Joe Petersona88a69c2009-01-02 13:40:53 +0000927 * This variant does not treat control characters specially.
Joe Petersona88a69c2009-01-02 13:40:53 +0000928 */
929
Jiri Slaby57c94122012-10-18 22:26:43 +0200930static void echo_char_raw(unsigned char c, struct n_tty_data *ldata)
Joe Petersona88a69c2009-01-02 13:40:53 +0000931{
Joe Petersona88a69c2009-01-02 13:40:53 +0000932 if (c == ECHO_OP_START) {
Jiri Slaby57c94122012-10-18 22:26:43 +0200933 add_echo_byte(ECHO_OP_START, ldata);
934 add_echo_byte(ECHO_OP_START, ldata);
Joe Petersona88a69c2009-01-02 13:40:53 +0000935 } else {
Jiri Slaby57c94122012-10-18 22:26:43 +0200936 add_echo_byte(c, ldata);
Joe Petersona88a69c2009-01-02 13:40:53 +0000937 }
Joe Petersona88a69c2009-01-02 13:40:53 +0000938}
939
940/**
941 * echo_char - echo a character
942 * @c: unicode byte to echo
943 * @tty: terminal device
944 *
945 * Echo user input back onto the screen. This must be called only when
946 * L_ECHO(tty) is true. Called from the driver receive_buf path.
947 *
Joe Peterson62b26352009-09-09 15:03:47 -0600948 * This variant tags control characters to be echoed as "^X"
949 * (where X is the letter representing the control char).
Linus Torvalds1da177e2005-04-16 15:20:36 -0700950 */
951
952static void echo_char(unsigned char c, struct tty_struct *tty)
953{
Jiri Slabybddc7152012-10-18 22:26:42 +0200954 struct n_tty_data *ldata = tty->disc_data;
955
Joe Petersona88a69c2009-01-02 13:40:53 +0000956 if (c == ECHO_OP_START) {
Jiri Slaby57c94122012-10-18 22:26:43 +0200957 add_echo_byte(ECHO_OP_START, ldata);
958 add_echo_byte(ECHO_OP_START, ldata);
Joe Petersona88a69c2009-01-02 13:40:53 +0000959 } else {
Joe Peterson62b26352009-09-09 15:03:47 -0600960 if (L_ECHOCTL(tty) && iscntrl(c) && c != '\t')
Jiri Slaby57c94122012-10-18 22:26:43 +0200961 add_echo_byte(ECHO_OP_START, ldata);
962 add_echo_byte(c, ldata);
Joe Petersona88a69c2009-01-02 13:40:53 +0000963 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700964}
965
Alan Cox17b82062008-10-13 10:45:06 +0100966/**
Joe Petersona88a69c2009-01-02 13:40:53 +0000967 * finish_erasing - complete erase
Jiri Slaby57c94122012-10-18 22:26:43 +0200968 * @ldata: n_tty data
Alan Cox17b82062008-10-13 10:45:06 +0100969 */
Joe Petersona88a69c2009-01-02 13:40:53 +0000970
Jiri Slaby57c94122012-10-18 22:26:43 +0200971static inline void finish_erasing(struct n_tty_data *ldata)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700972{
Jiri Slaby53c5ee22012-10-18 22:26:39 +0200973 if (ldata->erasing) {
Jiri Slaby57c94122012-10-18 22:26:43 +0200974 echo_char_raw('/', ldata);
Jiri Slaby53c5ee22012-10-18 22:26:39 +0200975 ldata->erasing = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700976 }
977}
978
979/**
980 * eraser - handle erase function
981 * @c: character input
982 * @tty: terminal device
983 *
Robert P. J. Day3a4fa0a2007-10-19 23:10:43 +0200984 * Perform erase and necessary output when an erase character is
Linus Torvalds1da177e2005-04-16 15:20:36 -0700985 * present in the stream from the driver layer. Handles the complexities
986 * of UTF-8 multibyte symbols.
Alan Cox17b82062008-10-13 10:45:06 +0100987 *
Peter Hurley6d76bd22013-06-15 09:14:26 -0400988 * n_tty_receive_buf()/producer path:
989 * caller holds non-exclusive termios_rwsem
990 * modifies read_head
991 *
992 * Modifying the read_head is not considered a publish in this context
993 * because canonical mode is active -- only canon_head publishes
Linus Torvalds1da177e2005-04-16 15:20:36 -0700994 */
Alan Cox4edf1822008-02-08 04:18:44 -0800995
Linus Torvalds1da177e2005-04-16 15:20:36 -0700996static void eraser(unsigned char c, struct tty_struct *tty)
997{
Jiri Slaby53c5ee22012-10-18 22:26:39 +0200998 struct n_tty_data *ldata = tty->disc_data;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700999 enum { ERASE, WERASE, KILL } kill_type;
Peter Hurleybc5a5e32013-06-15 09:14:21 -04001000 size_t head;
1001 size_t cnt;
1002 int seen_alnums;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001003
Jiri Slabyba2e68a2012-10-18 22:26:41 +02001004 if (ldata->read_head == ldata->canon_head) {
Joe Peterson7e94b1d2009-01-02 13:43:40 +00001005 /* process_output('\a', tty); */ /* what do you think? */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001006 return;
1007 }
1008 if (c == ERASE_CHAR(tty))
1009 kill_type = ERASE;
1010 else if (c == WERASE_CHAR(tty))
1011 kill_type = WERASE;
1012 else {
1013 if (!L_ECHO(tty)) {
Jiri Slabyba2e68a2012-10-18 22:26:41 +02001014 ldata->read_head = ldata->canon_head;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001015 return;
1016 }
1017 if (!L_ECHOK(tty) || !L_ECHOKE(tty) || !L_ECHOE(tty)) {
Jiri Slabyba2e68a2012-10-18 22:26:41 +02001018 ldata->read_head = ldata->canon_head;
Jiri Slaby57c94122012-10-18 22:26:43 +02001019 finish_erasing(ldata);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001020 echo_char(KILL_CHAR(tty), tty);
1021 /* Add a newline if ECHOK is on and ECHOKE is off. */
1022 if (L_ECHOK(tty))
Jiri Slaby57c94122012-10-18 22:26:43 +02001023 echo_char_raw('\n', ldata);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001024 return;
1025 }
1026 kill_type = KILL;
1027 }
1028
1029 seen_alnums = 0;
Jiri Slabyba2e68a2012-10-18 22:26:41 +02001030 while (ldata->read_head != ldata->canon_head) {
1031 head = ldata->read_head;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001032
1033 /* erase a single possibly multibyte character */
1034 do {
Peter Hurleybc5a5e32013-06-15 09:14:21 -04001035 head--;
1036 c = read_buf(ldata, head);
Jiri Slabyba2e68a2012-10-18 22:26:41 +02001037 } while (is_continuation(c, tty) && head != ldata->canon_head);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001038
1039 /* do not partially erase */
1040 if (is_continuation(c, tty))
1041 break;
1042
1043 if (kill_type == WERASE) {
1044 /* Equivalent to BSD's ALTWERASE. */
1045 if (isalnum(c) || c == '_')
1046 seen_alnums++;
1047 else if (seen_alnums)
1048 break;
1049 }
Peter Hurleybc5a5e32013-06-15 09:14:21 -04001050 cnt = ldata->read_head - head;
Jiri Slabyba2e68a2012-10-18 22:26:41 +02001051 ldata->read_head = head;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001052 if (L_ECHO(tty)) {
1053 if (L_ECHOPRT(tty)) {
Jiri Slaby53c5ee22012-10-18 22:26:39 +02001054 if (!ldata->erasing) {
Jiri Slaby57c94122012-10-18 22:26:43 +02001055 echo_char_raw('\\', ldata);
Jiri Slaby53c5ee22012-10-18 22:26:39 +02001056 ldata->erasing = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001057 }
1058 /* if cnt > 1, output a multi-byte character */
1059 echo_char(c, tty);
1060 while (--cnt > 0) {
Peter Hurleybc5a5e32013-06-15 09:14:21 -04001061 head++;
1062 echo_char_raw(read_buf(ldata, head), ldata);
Jiri Slaby57c94122012-10-18 22:26:43 +02001063 echo_move_back_col(ldata);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001064 }
1065 } else if (kill_type == ERASE && !L_ECHOE(tty)) {
1066 echo_char(ERASE_CHAR(tty), tty);
1067 } else if (c == '\t') {
Joe Petersona88a69c2009-01-02 13:40:53 +00001068 unsigned int num_chars = 0;
1069 int after_tab = 0;
Peter Hurleybc5a5e32013-06-15 09:14:21 -04001070 size_t tail = ldata->read_head;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001071
Joe Petersona88a69c2009-01-02 13:40:53 +00001072 /*
1073 * Count the columns used for characters
1074 * since the start of input or after a
1075 * previous tab.
1076 * This info is used to go back the correct
1077 * number of columns.
1078 */
Jiri Slabyba2e68a2012-10-18 22:26:41 +02001079 while (tail != ldata->canon_head) {
Peter Hurleybc5a5e32013-06-15 09:14:21 -04001080 tail--;
1081 c = read_buf(ldata, tail);
Joe Petersona88a69c2009-01-02 13:40:53 +00001082 if (c == '\t') {
1083 after_tab = 1;
1084 break;
Alan Cox300a6202009-01-02 13:41:04 +00001085 } else if (iscntrl(c)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001086 if (L_ECHOCTL(tty))
Joe Petersona88a69c2009-01-02 13:40:53 +00001087 num_chars += 2;
1088 } else if (!is_continuation(c, tty)) {
1089 num_chars++;
1090 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001091 }
Jiri Slaby57c94122012-10-18 22:26:43 +02001092 echo_erase_tab(num_chars, after_tab, ldata);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001093 } else {
1094 if (iscntrl(c) && L_ECHOCTL(tty)) {
Jiri Slaby57c94122012-10-18 22:26:43 +02001095 echo_char_raw('\b', ldata);
1096 echo_char_raw(' ', ldata);
1097 echo_char_raw('\b', ldata);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001098 }
1099 if (!iscntrl(c) || L_ECHOCTL(tty)) {
Jiri Slaby57c94122012-10-18 22:26:43 +02001100 echo_char_raw('\b', ldata);
1101 echo_char_raw(' ', ldata);
1102 echo_char_raw('\b', ldata);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001103 }
1104 }
1105 }
1106 if (kill_type == ERASE)
1107 break;
1108 }
Jiri Slabyba2e68a2012-10-18 22:26:41 +02001109 if (ldata->read_head == ldata->canon_head && L_ECHO(tty))
Jiri Slaby57c94122012-10-18 22:26:43 +02001110 finish_erasing(ldata);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001111}
1112
1113/**
1114 * isig - handle the ISIG optio
1115 * @sig: signal
1116 * @tty: terminal
Linus Torvalds1da177e2005-04-16 15:20:36 -07001117 *
Peter Hurley8c985d12013-03-06 08:38:19 -05001118 * Called when a signal is being sent due to terminal input.
1119 * Called from the driver receive_buf path so serialized.
Alan Cox17b82062008-10-13 10:45:06 +01001120 *
Peter Hurley8c985d12013-03-06 08:38:19 -05001121 * Locking: ctrl_lock
Linus Torvalds1da177e2005-04-16 15:20:36 -07001122 */
Alan Cox4edf1822008-02-08 04:18:44 -08001123
Peter Hurley4b293492013-07-24 08:29:55 -04001124static void isig(int sig, struct tty_struct *tty)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001125{
Peter Hurley8c985d12013-03-06 08:38:19 -05001126 struct pid *tty_pgrp = tty_get_pgrp(tty);
1127 if (tty_pgrp) {
1128 kill_pgrp(tty_pgrp, sig, 1);
1129 put_pid(tty_pgrp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001130 }
1131}
1132
1133/**
1134 * n_tty_receive_break - handle break
1135 * @tty: terminal
1136 *
1137 * An RS232 break event has been hit in the incoming bitstream. This
1138 * can cause a variety of events depending upon the termios settings.
1139 *
Peter Hurley6d76bd22013-06-15 09:14:26 -04001140 * n_tty_receive_buf()/producer path:
1141 * caller holds non-exclusive termios_rwsem
1142 * publishes read_head via put_tty_queue()
1143 *
1144 * Note: may get exclusive termios_rwsem if flushing input buffer
Linus Torvalds1da177e2005-04-16 15:20:36 -07001145 */
Alan Cox4edf1822008-02-08 04:18:44 -08001146
Peter Hurley4b293492013-07-24 08:29:55 -04001147static void n_tty_receive_break(struct tty_struct *tty)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001148{
Jiri Slaby57c94122012-10-18 22:26:43 +02001149 struct n_tty_data *ldata = tty->disc_data;
1150
Linus Torvalds1da177e2005-04-16 15:20:36 -07001151 if (I_IGNBRK(tty))
1152 return;
1153 if (I_BRKINT(tty)) {
Peter Hurley8c985d12013-03-06 08:38:19 -05001154 isig(SIGINT, tty);
1155 if (!L_NOFLSH(tty)) {
Peter Hurley6d76bd22013-06-15 09:14:26 -04001156 /* flushing needs exclusive termios_rwsem */
1157 up_read(&tty->termios_rwsem);
Peter Hurley8c985d12013-03-06 08:38:19 -05001158 n_tty_flush_buffer(tty);
1159 tty_driver_flush_buffer(tty);
Peter Hurley6d76bd22013-06-15 09:14:26 -04001160 down_read(&tty->termios_rwsem);
Peter Hurley8c985d12013-03-06 08:38:19 -05001161 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001162 return;
1163 }
1164 if (I_PARMRK(tty)) {
Jiri Slaby57c94122012-10-18 22:26:43 +02001165 put_tty_queue('\377', ldata);
1166 put_tty_queue('\0', ldata);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001167 }
Jiri Slaby57c94122012-10-18 22:26:43 +02001168 put_tty_queue('\0', ldata);
Peter Hurley6c677162013-12-02 14:24:46 -05001169 if (waitqueue_active(&tty->read_wait))
Peter Hurley57087d52014-08-07 07:14:10 -04001170 wake_up_interruptible_poll(&tty->read_wait, POLLIN);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001171}
1172
1173/**
1174 * n_tty_receive_overrun - handle overrun reporting
1175 * @tty: terminal
1176 *
1177 * Data arrived faster than we could process it. While the tty
1178 * driver has flagged this the bits that were missed are gone
1179 * forever.
1180 *
1181 * Called from the receive_buf path so single threaded. Does not
1182 * need locking as num_overrun and overrun_time are function
1183 * private.
1184 */
Alan Cox4edf1822008-02-08 04:18:44 -08001185
Peter Hurley4b293492013-07-24 08:29:55 -04001186static void n_tty_receive_overrun(struct tty_struct *tty)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001187{
Jiri Slaby53c5ee22012-10-18 22:26:39 +02001188 struct n_tty_data *ldata = tty->disc_data;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001189 char buf[64];
1190
Jiri Slaby53c5ee22012-10-18 22:26:39 +02001191 ldata->num_overrun++;
1192 if (time_after(jiffies, ldata->overrun_time + HZ) ||
1193 time_after(ldata->overrun_time, jiffies)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001194 printk(KERN_WARNING "%s: %d input overrun(s)\n",
1195 tty_name(tty, buf),
Jiri Slaby53c5ee22012-10-18 22:26:39 +02001196 ldata->num_overrun);
1197 ldata->overrun_time = jiffies;
1198 ldata->num_overrun = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001199 }
1200}
1201
1202/**
1203 * n_tty_receive_parity_error - error notifier
1204 * @tty: terminal device
1205 * @c: character
1206 *
1207 * Process a parity error and queue the right data to indicate
Peter Hurley6d76bd22013-06-15 09:14:26 -04001208 * the error case if necessary.
1209 *
1210 * n_tty_receive_buf()/producer path:
1211 * caller holds non-exclusive termios_rwsem
1212 * publishes read_head via put_tty_queue()
Linus Torvalds1da177e2005-04-16 15:20:36 -07001213 */
Peter Hurley4b293492013-07-24 08:29:55 -04001214static void n_tty_receive_parity_error(struct tty_struct *tty, unsigned char c)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001215{
Jiri Slaby57c94122012-10-18 22:26:43 +02001216 struct n_tty_data *ldata = tty->disc_data;
1217
Peter Hurley66528f92014-06-16 08:10:42 -04001218 if (I_INPCK(tty)) {
1219 if (I_IGNPAR(tty))
1220 return;
1221 if (I_PARMRK(tty)) {
1222 put_tty_queue('\377', ldata);
1223 put_tty_queue('\0', ldata);
1224 put_tty_queue(c, ldata);
1225 } else
1226 put_tty_queue('\0', ldata);
1227 } else
Jiri Slaby57c94122012-10-18 22:26:43 +02001228 put_tty_queue(c, ldata);
Peter Hurley6c677162013-12-02 14:24:46 -05001229 if (waitqueue_active(&tty->read_wait))
Peter Hurley57087d52014-08-07 07:14:10 -04001230 wake_up_interruptible_poll(&tty->read_wait, POLLIN);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001231}
1232
Peter Hurleyb0ac50b2013-06-15 10:21:23 -04001233static void
1234n_tty_receive_signal_char(struct tty_struct *tty, int signal, unsigned char c)
1235{
1236 if (!L_NOFLSH(tty)) {
1237 /* flushing needs exclusive termios_rwsem */
1238 up_read(&tty->termios_rwsem);
1239 n_tty_flush_buffer(tty);
1240 tty_driver_flush_buffer(tty);
1241 down_read(&tty->termios_rwsem);
1242 }
1243 if (I_IXON(tty))
1244 start_tty(tty);
1245 if (L_ECHO(tty)) {
1246 echo_char(c, tty);
1247 commit_echoes(tty);
Peter Hurleye2613be2014-02-11 16:34:55 -05001248 } else
1249 process_echoes(tty);
Peter Hurleyb0ac50b2013-06-15 10:21:23 -04001250 isig(signal, tty);
1251 return;
1252}
1253
Linus Torvalds1da177e2005-04-16 15:20:36 -07001254/**
1255 * n_tty_receive_char - perform processing
1256 * @tty: terminal device
1257 * @c: character
1258 *
1259 * Process an individual character of input received from the driver.
Alan Cox4edf1822008-02-08 04:18:44 -08001260 * This is serialized with respect to itself by the rules for the
Linus Torvalds1da177e2005-04-16 15:20:36 -07001261 * driver above.
Peter Hurley6d76bd22013-06-15 09:14:26 -04001262 *
1263 * n_tty_receive_buf()/producer path:
1264 * caller holds non-exclusive termios_rwsem
1265 * publishes canon_head if canonical mode is active
1266 * otherwise, publishes read_head via put_tty_queue()
Peter Hurleye60d27c2013-07-24 08:29:56 -04001267 *
1268 * Returns 1 if LNEXT was received, else returns 0
Linus Torvalds1da177e2005-04-16 15:20:36 -07001269 */
1270
Peter Hurleye60d27c2013-07-24 08:29:56 -04001271static int
Peter Hurley4b1f79c2013-07-24 08:29:51 -04001272n_tty_receive_char_special(struct tty_struct *tty, unsigned char c)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001273{
Jiri Slaby53c5ee22012-10-18 22:26:39 +02001274 struct n_tty_data *ldata = tty->disc_data;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001275
Linus Torvalds1da177e2005-04-16 15:20:36 -07001276 if (I_IXON(tty)) {
1277 if (c == START_CHAR(tty)) {
1278 start_tty(tty);
Peter Hurleye2613be2014-02-11 16:34:55 -05001279 process_echoes(tty);
Peter Hurleye60d27c2013-07-24 08:29:56 -04001280 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001281 }
1282 if (c == STOP_CHAR(tty)) {
1283 stop_tty(tty);
Peter Hurleye60d27c2013-07-24 08:29:56 -04001284 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001285 }
1286 }
Joe Peterson575537b32008-04-30 00:53:30 -07001287
Linus Torvalds1da177e2005-04-16 15:20:36 -07001288 if (L_ISIG(tty)) {
Peter Hurleyb0ac50b2013-06-15 10:21:23 -04001289 if (c == INTR_CHAR(tty)) {
1290 n_tty_receive_signal_char(tty, SIGINT, c);
Peter Hurleye60d27c2013-07-24 08:29:56 -04001291 return 0;
Peter Hurleyb0ac50b2013-06-15 10:21:23 -04001292 } else if (c == QUIT_CHAR(tty)) {
1293 n_tty_receive_signal_char(tty, SIGQUIT, c);
Peter Hurleye60d27c2013-07-24 08:29:56 -04001294 return 0;
Peter Hurleyb0ac50b2013-06-15 10:21:23 -04001295 } else if (c == SUSP_CHAR(tty)) {
1296 n_tty_receive_signal_char(tty, SIGTSTP, c);
Peter Hurleye60d27c2013-07-24 08:29:56 -04001297 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001298 }
1299 }
Joe Peterson575537b32008-04-30 00:53:30 -07001300
Peter Hurley855df3c2013-07-24 08:29:50 -04001301 if (tty->stopped && !tty->flow_stopped && I_IXON(tty) && I_IXANY(tty)) {
1302 start_tty(tty);
1303 process_echoes(tty);
1304 }
1305
Joe Peterson575537b32008-04-30 00:53:30 -07001306 if (c == '\r') {
1307 if (I_IGNCR(tty))
Peter Hurleye60d27c2013-07-24 08:29:56 -04001308 return 0;
Joe Peterson575537b32008-04-30 00:53:30 -07001309 if (I_ICRNL(tty))
1310 c = '\n';
1311 } else if (c == '\n' && I_INLCR(tty))
1312 c = '\r';
1313
Jiri Slaby53c5ee22012-10-18 22:26:39 +02001314 if (ldata->icanon) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001315 if (c == ERASE_CHAR(tty) || c == KILL_CHAR(tty) ||
1316 (c == WERASE_CHAR(tty) && L_IEXTEN(tty))) {
1317 eraser(c, tty);
Peter Hurley17bd7902013-06-15 10:04:24 -04001318 commit_echoes(tty);
Peter Hurleye60d27c2013-07-24 08:29:56 -04001319 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001320 }
1321 if (c == LNEXT_CHAR(tty) && L_IEXTEN(tty)) {
Jiri Slaby53c5ee22012-10-18 22:26:39 +02001322 ldata->lnext = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001323 if (L_ECHO(tty)) {
Jiri Slaby57c94122012-10-18 22:26:43 +02001324 finish_erasing(ldata);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001325 if (L_ECHOCTL(tty)) {
Jiri Slaby57c94122012-10-18 22:26:43 +02001326 echo_char_raw('^', ldata);
1327 echo_char_raw('\b', ldata);
Peter Hurley17bd7902013-06-15 10:04:24 -04001328 commit_echoes(tty);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001329 }
1330 }
Peter Hurleye60d27c2013-07-24 08:29:56 -04001331 return 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001332 }
Peter Hurleye60d27c2013-07-24 08:29:56 -04001333 if (c == REPRINT_CHAR(tty) && L_ECHO(tty) && L_IEXTEN(tty)) {
Peter Hurleybc5a5e32013-06-15 09:14:21 -04001334 size_t tail = ldata->canon_head;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001335
Jiri Slaby57c94122012-10-18 22:26:43 +02001336 finish_erasing(ldata);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001337 echo_char(c, tty);
Jiri Slaby57c94122012-10-18 22:26:43 +02001338 echo_char_raw('\n', ldata);
Jiri Slabyba2e68a2012-10-18 22:26:41 +02001339 while (tail != ldata->read_head) {
Peter Hurleybc5a5e32013-06-15 09:14:21 -04001340 echo_char(read_buf(ldata, tail), tty);
1341 tail++;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001342 }
Peter Hurley17bd7902013-06-15 10:04:24 -04001343 commit_echoes(tty);
Peter Hurleye60d27c2013-07-24 08:29:56 -04001344 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001345 }
1346 if (c == '\n') {
Joe Petersonacc71bb2009-01-02 13:43:32 +00001347 if (L_ECHO(tty) || L_ECHONL(tty)) {
Jiri Slaby57c94122012-10-18 22:26:43 +02001348 echo_char_raw('\n', ldata);
Peter Hurley17bd7902013-06-15 10:04:24 -04001349 commit_echoes(tty);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001350 }
1351 goto handle_newline;
1352 }
1353 if (c == EOF_CHAR(tty)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001354 c = __DISABLED_CHAR;
1355 goto handle_newline;
1356 }
1357 if ((c == EOL_CHAR(tty)) ||
1358 (c == EOL2_CHAR(tty) && L_IEXTEN(tty))) {
1359 /*
1360 * XXX are EOL_CHAR and EOL2_CHAR echoed?!?
1361 */
1362 if (L_ECHO(tty)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001363 /* Record the column of first canon char. */
Jiri Slabyba2e68a2012-10-18 22:26:41 +02001364 if (ldata->canon_head == ldata->read_head)
Jiri Slaby57c94122012-10-18 22:26:43 +02001365 echo_set_canon_col(ldata);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001366 echo_char(c, tty);
Peter Hurley17bd7902013-06-15 10:04:24 -04001367 commit_echoes(tty);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001368 }
1369 /*
1370 * XXX does PARMRK doubling happen for
1371 * EOL_CHAR and EOL2_CHAR?
1372 */
Peter Hurley001ba922013-12-02 14:24:44 -05001373 if (c == (unsigned char) '\377' && I_PARMRK(tty))
Jiri Slaby57c94122012-10-18 22:26:43 +02001374 put_tty_queue(c, ldata);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001375
Alan Cox4edf1822008-02-08 04:18:44 -08001376handle_newline:
Peter Hurleybc5a5e32013-06-15 09:14:21 -04001377 set_bit(ldata->read_head & (N_TTY_BUF_SIZE - 1), ldata->read_flags);
Peter Hurley6d76bd22013-06-15 09:14:26 -04001378 put_tty_queue(c, ldata);
Jiri Slabyba2e68a2012-10-18 22:26:41 +02001379 ldata->canon_head = ldata->read_head;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001380 kill_fasync(&tty->fasync, SIGIO, POLL_IN);
1381 if (waitqueue_active(&tty->read_wait))
Peter Hurley57087d52014-08-07 07:14:10 -04001382 wake_up_interruptible_poll(&tty->read_wait, POLLIN);
Peter Hurleye60d27c2013-07-24 08:29:56 -04001383 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001384 }
1385 }
Alan Cox4edf1822008-02-08 04:18:44 -08001386
Joe Petersonacc71bb2009-01-02 13:43:32 +00001387 if (L_ECHO(tty)) {
Jiri Slaby57c94122012-10-18 22:26:43 +02001388 finish_erasing(ldata);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001389 if (c == '\n')
Jiri Slaby57c94122012-10-18 22:26:43 +02001390 echo_char_raw('\n', ldata);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001391 else {
1392 /* Record the column of first canon char. */
Jiri Slabyba2e68a2012-10-18 22:26:41 +02001393 if (ldata->canon_head == ldata->read_head)
Jiri Slaby57c94122012-10-18 22:26:43 +02001394 echo_set_canon_col(ldata);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001395 echo_char(c, tty);
1396 }
Peter Hurley17bd7902013-06-15 10:04:24 -04001397 commit_echoes(tty);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001398 }
1399
Peter Hurley001ba922013-12-02 14:24:44 -05001400 /* PARMRK doubling check */
1401 if (c == (unsigned char) '\377' && I_PARMRK(tty))
Jiri Slaby57c94122012-10-18 22:26:43 +02001402 put_tty_queue(c, ldata);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001403
Jiri Slaby57c94122012-10-18 22:26:43 +02001404 put_tty_queue(c, ldata);
Peter Hurleye60d27c2013-07-24 08:29:56 -04001405 return 0;
Alan Cox4edf1822008-02-08 04:18:44 -08001406}
Linus Torvalds1da177e2005-04-16 15:20:36 -07001407
Peter Hurleye60d27c2013-07-24 08:29:56 -04001408static inline void
1409n_tty_receive_char_inline(struct tty_struct *tty, unsigned char c)
Peter Hurley4b1f79c2013-07-24 08:29:51 -04001410{
1411 struct n_tty_data *ldata = tty->disc_data;
Peter Hurley4b1f79c2013-07-24 08:29:51 -04001412
Peter Hurleye60d27c2013-07-24 08:29:56 -04001413 if (tty->stopped && !tty->flow_stopped && I_IXON(tty) && I_IXANY(tty)) {
1414 start_tty(tty);
1415 process_echoes(tty);
Peter Hurley4b1f79c2013-07-24 08:29:51 -04001416 }
Peter Hurleye60d27c2013-07-24 08:29:56 -04001417 if (L_ECHO(tty)) {
1418 finish_erasing(ldata);
1419 /* Record the column of first canon char. */
1420 if (ldata->canon_head == ldata->read_head)
1421 echo_set_canon_col(ldata);
1422 echo_char(c, tty);
1423 commit_echoes(tty);
1424 }
Peter Hurley001ba922013-12-02 14:24:44 -05001425 /* PARMRK doubling check */
1426 if (c == (unsigned char) '\377' && I_PARMRK(tty))
Peter Hurleye60d27c2013-07-24 08:29:56 -04001427 put_tty_queue(c, ldata);
1428 put_tty_queue(c, ldata);
1429}
Peter Hurley4b1f79c2013-07-24 08:29:51 -04001430
Peter Hurleyeb3e4662013-12-02 14:24:42 -05001431static void n_tty_receive_char(struct tty_struct *tty, unsigned char c)
Peter Hurleye60d27c2013-07-24 08:29:56 -04001432{
1433 n_tty_receive_char_inline(tty, c);
Peter Hurley4b1f79c2013-07-24 08:29:51 -04001434}
1435
Peter Hurleyad0cc7b2013-06-15 10:21:27 -04001436static inline void
Peter Hurley7de971b2013-07-24 08:29:53 -04001437n_tty_receive_char_fast(struct tty_struct *tty, unsigned char c)
1438{
1439 struct n_tty_data *ldata = tty->disc_data;
1440
Peter Hurleye60d27c2013-07-24 08:29:56 -04001441 if (tty->stopped && !tty->flow_stopped && I_IXON(tty) && I_IXANY(tty)) {
1442 start_tty(tty);
1443 process_echoes(tty);
Peter Hurley7de971b2013-07-24 08:29:53 -04001444 }
Peter Hurleye60d27c2013-07-24 08:29:56 -04001445 if (L_ECHO(tty)) {
1446 finish_erasing(ldata);
1447 /* Record the column of first canon char. */
1448 if (ldata->canon_head == ldata->read_head)
1449 echo_set_canon_col(ldata);
1450 echo_char(c, tty);
1451 commit_echoes(tty);
1452 }
1453 put_tty_queue(c, ldata);
Peter Hurley7de971b2013-07-24 08:29:53 -04001454}
1455
Peter Hurley8dc4b252013-12-02 14:24:43 -05001456static void n_tty_receive_char_closing(struct tty_struct *tty, unsigned char c)
Peter Hurleyad0cc7b2013-06-15 10:21:27 -04001457{
1458 if (I_ISTRIP(tty))
1459 c &= 0x7f;
1460 if (I_IUCLC(tty) && L_IEXTEN(tty))
1461 c = tolower(c);
1462
1463 if (I_IXON(tty)) {
1464 if (c == STOP_CHAR(tty))
1465 stop_tty(tty);
1466 else if (c == START_CHAR(tty) ||
1467 (tty->stopped && !tty->flow_stopped && I_IXANY(tty) &&
1468 c != INTR_CHAR(tty) && c != QUIT_CHAR(tty) &&
1469 c != SUSP_CHAR(tty))) {
1470 start_tty(tty);
1471 process_echoes(tty);
1472 }
1473 }
1474}
1475
Peter Hurleyd2f8d7a2013-06-15 10:21:24 -04001476static void
1477n_tty_receive_char_flagged(struct tty_struct *tty, unsigned char c, char flag)
1478{
1479 char buf[64];
1480
1481 switch (flag) {
1482 case TTY_BREAK:
1483 n_tty_receive_break(tty);
1484 break;
1485 case TTY_PARITY:
1486 case TTY_FRAME:
1487 n_tty_receive_parity_error(tty, c);
1488 break;
1489 case TTY_OVERRUN:
1490 n_tty_receive_overrun(tty);
1491 break;
1492 default:
1493 printk(KERN_ERR "%s: unknown flag %d\n",
1494 tty_name(tty, buf), flag);
1495 break;
1496 }
1497}
1498
Peter Hurleye60d27c2013-07-24 08:29:56 -04001499static void
1500n_tty_receive_char_lnext(struct tty_struct *tty, unsigned char c, char flag)
1501{
1502 struct n_tty_data *ldata = tty->disc_data;
1503
1504 ldata->lnext = 0;
1505 if (likely(flag == TTY_NORMAL)) {
1506 if (I_ISTRIP(tty))
1507 c &= 0x7f;
1508 if (I_IUCLC(tty) && L_IEXTEN(tty))
1509 c = tolower(c);
1510 n_tty_receive_char(tty, c);
1511 } else
1512 n_tty_receive_char_flagged(tty, c, flag);
1513}
1514
Linus Torvalds1da177e2005-04-16 15:20:36 -07001515/**
1516 * n_tty_receive_buf - data receive
1517 * @tty: terminal device
1518 * @cp: buffer
1519 * @fp: flag buffer
1520 * @count: characters
1521 *
1522 * Called by the terminal driver when a block of characters has
1523 * been received. This function must be called from soft contexts
1524 * not from interrupt context. The driver is responsible for making
1525 * calls one at a time and in order (or using flush_to_ldisc)
Peter Hurley6d76bd22013-06-15 09:14:26 -04001526 *
1527 * n_tty_receive_buf()/producer path:
1528 * claims non-exclusive termios_rwsem
1529 * publishes read_head and canon_head
Linus Torvalds1da177e2005-04-16 15:20:36 -07001530 */
Alan Cox4edf1822008-02-08 04:18:44 -08001531
Peter Hurley4a23a4d2013-06-15 10:21:22 -04001532static void
1533n_tty_receive_buf_real_raw(struct tty_struct *tty, const unsigned char *cp,
1534 char *fp, int count)
1535{
1536 struct n_tty_data *ldata = tty->disc_data;
1537 size_t n, head;
1538
1539 head = ldata->read_head & (N_TTY_BUF_SIZE - 1);
1540 n = N_TTY_BUF_SIZE - max(read_cnt(ldata), head);
1541 n = min_t(size_t, count, n);
1542 memcpy(read_buf_addr(ldata, head), cp, n);
1543 ldata->read_head += n;
1544 cp += n;
1545 count -= n;
1546
1547 head = ldata->read_head & (N_TTY_BUF_SIZE - 1);
1548 n = N_TTY_BUF_SIZE - max(read_cnt(ldata), head);
1549 n = min_t(size_t, count, n);
1550 memcpy(read_buf_addr(ldata, head), cp, n);
1551 ldata->read_head += n;
1552}
1553
Peter Hurley554117b2013-06-15 10:21:25 -04001554static void
1555n_tty_receive_buf_raw(struct tty_struct *tty, const unsigned char *cp,
1556 char *fp, int count)
1557{
1558 struct n_tty_data *ldata = tty->disc_data;
1559 char flag = TTY_NORMAL;
1560
1561 while (count--) {
1562 if (fp)
1563 flag = *fp++;
1564 if (likely(flag == TTY_NORMAL))
1565 put_tty_queue(*cp++, ldata);
1566 else
1567 n_tty_receive_char_flagged(tty, *cp++, flag);
1568 }
1569}
1570
Peter Hurleyad0cc7b2013-06-15 10:21:27 -04001571static void
1572n_tty_receive_buf_closing(struct tty_struct *tty, const unsigned char *cp,
1573 char *fp, int count)
1574{
1575 char flag = TTY_NORMAL;
1576
1577 while (count--) {
1578 if (fp)
1579 flag = *fp++;
1580 if (likely(flag == TTY_NORMAL))
1581 n_tty_receive_char_closing(tty, *cp++);
1582 else
1583 n_tty_receive_char_flagged(tty, *cp++, flag);
1584 }
1585}
1586
Peter Hurley7d88d632013-07-24 08:29:49 -04001587static void
1588n_tty_receive_buf_standard(struct tty_struct *tty, const unsigned char *cp,
Peter Hurley6baad002013-07-24 08:29:52 -04001589 char *fp, int count)
1590{
1591 struct n_tty_data *ldata = tty->disc_data;
1592 char flag = TTY_NORMAL;
1593
1594 while (count--) {
1595 if (fp)
1596 flag = *fp++;
1597 if (likely(flag == TTY_NORMAL)) {
1598 unsigned char c = *cp++;
1599
1600 if (I_ISTRIP(tty))
1601 c &= 0x7f;
1602 if (I_IUCLC(tty) && L_IEXTEN(tty))
1603 c = tolower(c);
1604 if (L_EXTPROC(tty)) {
1605 put_tty_queue(c, ldata);
1606 continue;
1607 }
Peter Hurleye60d27c2013-07-24 08:29:56 -04001608 if (!test_bit(c, ldata->char_map))
1609 n_tty_receive_char_inline(tty, c);
1610 else if (n_tty_receive_char_special(tty, c) && count) {
1611 if (fp)
1612 flag = *fp++;
1613 n_tty_receive_char_lnext(tty, *cp++, flag);
1614 count--;
1615 }
Peter Hurley6baad002013-07-24 08:29:52 -04001616 } else
1617 n_tty_receive_char_flagged(tty, *cp++, flag);
1618 }
1619}
1620
1621static void
1622n_tty_receive_buf_fast(struct tty_struct *tty, const unsigned char *cp,
1623 char *fp, int count)
Peter Hurley7d88d632013-07-24 08:29:49 -04001624{
Peter Hurleye60d27c2013-07-24 08:29:56 -04001625 struct n_tty_data *ldata = tty->disc_data;
Peter Hurley7d88d632013-07-24 08:29:49 -04001626 char flag = TTY_NORMAL;
1627
1628 while (count--) {
1629 if (fp)
1630 flag = *fp++;
Peter Hurleye60d27c2013-07-24 08:29:56 -04001631 if (likely(flag == TTY_NORMAL)) {
1632 unsigned char c = *cp++;
1633
1634 if (!test_bit(c, ldata->char_map))
1635 n_tty_receive_char_fast(tty, c);
1636 else if (n_tty_receive_char_special(tty, c) && count) {
1637 if (fp)
1638 flag = *fp++;
1639 n_tty_receive_char_lnext(tty, *cp++, flag);
1640 count--;
1641 }
1642 } else
Peter Hurley7d88d632013-07-24 08:29:49 -04001643 n_tty_receive_char_flagged(tty, *cp++, flag);
1644 }
1645}
1646
Peter Hurley24a89d12013-06-15 09:14:15 -04001647static void __receive_buf(struct tty_struct *tty, const unsigned char *cp,
1648 char *fp, int count)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001649{
Jiri Slaby53c5ee22012-10-18 22:26:39 +02001650 struct n_tty_data *ldata = tty->disc_data;
Peter Hurleya1dd30e2013-06-15 10:21:26 -04001651 bool preops = I_ISTRIP(tty) || (I_IUCLC(tty) && L_IEXTEN(tty));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001652
Peter Hurley4a23a4d2013-06-15 10:21:22 -04001653 if (ldata->real_raw)
1654 n_tty_receive_buf_real_raw(tty, cp, fp, count);
Peter Hurleya1dd30e2013-06-15 10:21:26 -04001655 else if (ldata->raw || (L_EXTPROC(tty) && !preops))
Peter Hurley554117b2013-06-15 10:21:25 -04001656 n_tty_receive_buf_raw(tty, cp, fp, count);
Peter Hurleyad0cc7b2013-06-15 10:21:27 -04001657 else if (tty->closing && !L_EXTPROC(tty))
1658 n_tty_receive_buf_closing(tty, cp, fp, count);
Peter Hurley4a23a4d2013-06-15 10:21:22 -04001659 else {
Peter Hurleye60d27c2013-07-24 08:29:56 -04001660 if (ldata->lnext) {
1661 char flag = TTY_NORMAL;
1662
1663 if (fp)
1664 flag = *fp++;
1665 n_tty_receive_char_lnext(tty, *cp++, flag);
1666 count--;
1667 }
1668
Peter Hurley7de971b2013-07-24 08:29:53 -04001669 if (!preops && !I_PARMRK(tty))
Peter Hurley6baad002013-07-24 08:29:52 -04001670 n_tty_receive_buf_fast(tty, cp, fp, count);
1671 else
1672 n_tty_receive_buf_standard(tty, cp, fp, count);
Peter Hurleycbfd0342013-06-15 10:04:26 -04001673
1674 flush_echoes(tty);
Alan Coxf34d7a52008-04-30 00:54:13 -07001675 if (tty->ops->flush_chars)
1676 tty->ops->flush_chars(tty);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001677 }
1678
Peter Hurleyce741172013-06-15 09:14:20 -04001679 if ((!ldata->icanon && (read_cnt(ldata) >= ldata->minimum_to_wake)) ||
hyc@symas.com26df6d12010-06-22 10:14:49 -07001680 L_EXTPROC(tty)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001681 kill_fasync(&tty->fasync, SIGIO, POLL_IN);
1682 if (waitqueue_active(&tty->read_wait))
Peter Hurley57087d52014-08-07 07:14:10 -04001683 wake_up_interruptible_poll(&tty->read_wait, POLLIN);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001684 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001685}
1686
Peter Hurley5c32d122013-12-02 14:24:41 -05001687static int
1688n_tty_receive_buf_common(struct tty_struct *tty, const unsigned char *cp,
1689 char *fp, int count, int flow)
Peter Hurley24a89d12013-06-15 09:14:15 -04001690{
1691 struct n_tty_data *ldata = tty->disc_data;
Peter Hurley19e2ad62013-07-24 08:29:54 -04001692 int room, n, rcvd = 0;
Peter Hurley24a89d12013-06-15 09:14:15 -04001693
Peter Hurley9356b532013-06-15 09:14:24 -04001694 down_read(&tty->termios_rwsem);
1695
Peter Hurley19e2ad62013-07-24 08:29:54 -04001696 while (1) {
1697 room = receive_room(tty);
1698 n = min(count, room);
1699 if (!n) {
Peter Hurley5c32d122013-12-02 14:24:41 -05001700 if (flow && !room)
Peter Hurley19e2ad62013-07-24 08:29:54 -04001701 ldata->no_room = 1;
1702 break;
1703 }
1704 __receive_buf(tty, cp, fp, n);
1705 cp += n;
1706 if (fp)
1707 fp += n;
1708 count -= n;
1709 rcvd += n;
Peter Hurley4a23a4d2013-06-15 10:21:22 -04001710 }
Peter Hurley24a89d12013-06-15 09:14:15 -04001711
Peter Hurley19e2ad62013-07-24 08:29:54 -04001712 tty->receive_room = room;
1713 n_tty_check_throttle(tty);
Peter Hurley9356b532013-06-15 09:14:24 -04001714 up_read(&tty->termios_rwsem);
1715
Peter Hurley19e2ad62013-07-24 08:29:54 -04001716 return rcvd;
Peter Hurley24a89d12013-06-15 09:14:15 -04001717}
1718
Peter Hurley5c32d122013-12-02 14:24:41 -05001719static void n_tty_receive_buf(struct tty_struct *tty, const unsigned char *cp,
1720 char *fp, int count)
1721{
1722 n_tty_receive_buf_common(tty, cp, fp, count, 0);
1723}
1724
1725static int n_tty_receive_buf2(struct tty_struct *tty, const unsigned char *cp,
1726 char *fp, int count)
1727{
1728 return n_tty_receive_buf_common(tty, cp, fp, count, 1);
1729}
1730
Linus Torvalds1da177e2005-04-16 15:20:36 -07001731int is_ignored(int sig)
1732{
1733 return (sigismember(&current->blocked, sig) ||
Alan Cox4edf1822008-02-08 04:18:44 -08001734 current->sighand->action[sig-1].sa.sa_handler == SIG_IGN);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001735}
1736
1737/**
1738 * n_tty_set_termios - termios data changed
1739 * @tty: terminal
1740 * @old: previous data
1741 *
1742 * Called by the tty layer when the user changes termios flags so
1743 * that the line discipline can plan ahead. This function cannot sleep
Alan Cox4edf1822008-02-08 04:18:44 -08001744 * and is protected from re-entry by the tty layer. The user is
Linus Torvalds1da177e2005-04-16 15:20:36 -07001745 * guaranteed that this function will not be re-entered or in progress
1746 * when the ldisc is closed.
Alan Cox17b82062008-10-13 10:45:06 +01001747 *
Peter Hurley6a1c0682013-06-15 09:14:23 -04001748 * Locking: Caller holds tty->termios_rwsem
Linus Torvalds1da177e2005-04-16 15:20:36 -07001749 */
Alan Cox4edf1822008-02-08 04:18:44 -08001750
1751static void n_tty_set_termios(struct tty_struct *tty, struct ktermios *old)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001752{
Jiri Slaby53c5ee22012-10-18 22:26:39 +02001753 struct n_tty_data *ldata = tty->disc_data;
Alan Cox47afa7a2008-10-13 10:44:17 +01001754
Peter Hurleyc786f742013-09-17 12:53:35 -04001755 if (!old || (old->c_lflag ^ tty->termios.c_lflag) & ICANON) {
Jiri Slaby3fe780b2012-10-18 22:26:40 +02001756 bitmap_zero(ldata->read_flags, N_TTY_BUF_SIZE);
Peter Hurley4d0ed182013-12-10 17:12:02 -05001757 ldata->line_start = ldata->read_tail;
1758 if (!L_ICANON(tty) || !read_cnt(ldata)) {
1759 ldata->canon_head = ldata->read_tail;
1760 ldata->push = 0;
1761 } else {
1762 set_bit((ldata->read_head - 1) & (N_TTY_BUF_SIZE - 1),
1763 ldata->read_flags);
1764 ldata->canon_head = ldata->read_head;
1765 ldata->push = 1;
1766 }
Jiri Slaby53c5ee22012-10-18 22:26:39 +02001767 ldata->erasing = 0;
Peter Hurley6f9b0282013-06-15 09:14:27 -04001768 ldata->lnext = 0;
Alan Cox47afa7a2008-10-13 10:44:17 +01001769 }
1770
Jiri Slaby53c5ee22012-10-18 22:26:39 +02001771 ldata->icanon = (L_ICANON(tty) != 0);
Peter Hurley582f5592013-05-17 12:49:48 -04001772
Linus Torvalds1da177e2005-04-16 15:20:36 -07001773 if (I_ISTRIP(tty) || I_IUCLC(tty) || I_IGNCR(tty) ||
1774 I_ICRNL(tty) || I_INLCR(tty) || L_ICANON(tty) ||
1775 I_IXON(tty) || L_ISIG(tty) || L_ECHO(tty) ||
1776 I_PARMRK(tty)) {
Peter Hurley1bb9d562013-06-15 10:21:20 -04001777 bitmap_zero(ldata->char_map, 256);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001778
1779 if (I_IGNCR(tty) || I_ICRNL(tty))
Peter Hurley1bb9d562013-06-15 10:21:20 -04001780 set_bit('\r', ldata->char_map);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001781 if (I_INLCR(tty))
Peter Hurley1bb9d562013-06-15 10:21:20 -04001782 set_bit('\n', ldata->char_map);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001783
1784 if (L_ICANON(tty)) {
Peter Hurley1bb9d562013-06-15 10:21:20 -04001785 set_bit(ERASE_CHAR(tty), ldata->char_map);
1786 set_bit(KILL_CHAR(tty), ldata->char_map);
1787 set_bit(EOF_CHAR(tty), ldata->char_map);
1788 set_bit('\n', ldata->char_map);
1789 set_bit(EOL_CHAR(tty), ldata->char_map);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001790 if (L_IEXTEN(tty)) {
Peter Hurley1bb9d562013-06-15 10:21:20 -04001791 set_bit(WERASE_CHAR(tty), ldata->char_map);
1792 set_bit(LNEXT_CHAR(tty), ldata->char_map);
1793 set_bit(EOL2_CHAR(tty), ldata->char_map);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001794 if (L_ECHO(tty))
1795 set_bit(REPRINT_CHAR(tty),
Peter Hurley1bb9d562013-06-15 10:21:20 -04001796 ldata->char_map);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001797 }
1798 }
1799 if (I_IXON(tty)) {
Peter Hurley1bb9d562013-06-15 10:21:20 -04001800 set_bit(START_CHAR(tty), ldata->char_map);
1801 set_bit(STOP_CHAR(tty), ldata->char_map);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001802 }
1803 if (L_ISIG(tty)) {
Peter Hurley1bb9d562013-06-15 10:21:20 -04001804 set_bit(INTR_CHAR(tty), ldata->char_map);
1805 set_bit(QUIT_CHAR(tty), ldata->char_map);
1806 set_bit(SUSP_CHAR(tty), ldata->char_map);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001807 }
Peter Hurley1bb9d562013-06-15 10:21:20 -04001808 clear_bit(__DISABLED_CHAR, ldata->char_map);
Jiri Slaby53c5ee22012-10-18 22:26:39 +02001809 ldata->raw = 0;
1810 ldata->real_raw = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001811 } else {
Jiri Slaby53c5ee22012-10-18 22:26:39 +02001812 ldata->raw = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001813 if ((I_IGNBRK(tty) || (!I_BRKINT(tty) && !I_PARMRK(tty))) &&
1814 (I_IGNPAR(tty) || !I_INPCK(tty)) &&
1815 (tty->driver->flags & TTY_DRIVER_REAL_RAW))
Jiri Slaby53c5ee22012-10-18 22:26:39 +02001816 ldata->real_raw = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001817 else
Jiri Slaby53c5ee22012-10-18 22:26:39 +02001818 ldata->real_raw = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001819 }
Linus Torvalds55db4c62011-06-04 06:33:24 +09001820 n_tty_set_room(tty);
Wang YanQingdab73b42013-05-09 14:16:47 +08001821 /*
1822 * Fix tty hang when I_IXON(tty) is cleared, but the tty
1823 * been stopped by STOP_CHAR(tty) before it.
1824 */
Peter Hurleye2613be2014-02-11 16:34:55 -05001825 if (!I_IXON(tty) && old && (old->c_iflag & IXON) && !tty->flow_stopped) {
Wang YanQingdab73b42013-05-09 14:16:47 +08001826 start_tty(tty);
Peter Hurleye2613be2014-02-11 16:34:55 -05001827 process_echoes(tty);
1828 }
Wang YanQingdab73b42013-05-09 14:16:47 +08001829
Alan Coxf34d7a52008-04-30 00:54:13 -07001830 /* The termios change make the tty ready for I/O */
Peter Hurley6c677162013-12-02 14:24:46 -05001831 if (waitqueue_active(&tty->write_wait))
1832 wake_up_interruptible(&tty->write_wait);
1833 if (waitqueue_active(&tty->read_wait))
1834 wake_up_interruptible(&tty->read_wait);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001835}
1836
1837/**
1838 * n_tty_close - close the ldisc for this tty
1839 * @tty: device
1840 *
Alan Cox4edf1822008-02-08 04:18:44 -08001841 * Called from the terminal layer when this line discipline is
1842 * being shut down, either because of a close or becsuse of a
Linus Torvalds1da177e2005-04-16 15:20:36 -07001843 * discipline change. The function will not be called while other
1844 * ldisc methods are in progress.
1845 */
Alan Cox4edf1822008-02-08 04:18:44 -08001846
Linus Torvalds1da177e2005-04-16 15:20:36 -07001847static void n_tty_close(struct tty_struct *tty)
1848{
Jiri Slaby70ece7a2012-10-18 22:26:38 +02001849 struct n_tty_data *ldata = tty->disc_data;
1850
Peter Hurley79901312013-03-11 16:44:23 -04001851 if (tty->link)
1852 n_tty_packet_mode_flush(tty);
1853
Peter Hurley20bafb32013-06-15 10:21:19 -04001854 vfree(ldata);
Jiri Slaby70ece7a2012-10-18 22:26:38 +02001855 tty->disc_data = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001856}
1857
1858/**
1859 * n_tty_open - open an ldisc
1860 * @tty: terminal to open
1861 *
Alan Cox4edf1822008-02-08 04:18:44 -08001862 * Called when this line discipline is being attached to the
Linus Torvalds1da177e2005-04-16 15:20:36 -07001863 * terminal device. Can sleep. Called serialized so that no
1864 * other events will occur in parallel. No further open will occur
1865 * until a close.
1866 */
1867
1868static int n_tty_open(struct tty_struct *tty)
1869{
Jiri Slaby70ece7a2012-10-18 22:26:38 +02001870 struct n_tty_data *ldata;
1871
Peter Hurley20bafb32013-06-15 10:21:19 -04001872 /* Currently a malloc failure here can panic */
1873 ldata = vmalloc(sizeof(*ldata));
Jiri Slaby70ece7a2012-10-18 22:26:38 +02001874 if (!ldata)
1875 goto err;
1876
Jiri Slaby53c5ee22012-10-18 22:26:39 +02001877 ldata->overrun_time = jiffies;
Jiri Slabybddc7152012-10-18 22:26:42 +02001878 mutex_init(&ldata->atomic_read_lock);
1879 mutex_init(&ldata->output_lock);
Jiri Slaby53c5ee22012-10-18 22:26:39 +02001880
Jiri Slaby70ece7a2012-10-18 22:26:38 +02001881 tty->disc_data = ldata;
Peter Hurleyb66f4fa2013-03-11 16:44:32 -04001882 reset_buffer_flags(tty->disc_data);
Jiri Slaby53c5ee22012-10-18 22:26:39 +02001883 ldata->column = 0;
Peter Hurley20bafb32013-06-15 10:21:19 -04001884 ldata->canon_column = 0;
Peter Hurleyf6c8dbe2013-06-15 07:28:28 -04001885 ldata->minimum_to_wake = 1;
Peter Hurley20bafb32013-06-15 10:21:19 -04001886 ldata->num_overrun = 0;
1887 ldata->no_room = 0;
1888 ldata->lnext = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001889 tty->closing = 0;
Peter Hurleyb66f4fa2013-03-11 16:44:32 -04001890 /* indicate buffer work may resume */
1891 clear_bit(TTY_LDISC_HALTED, &tty->flags);
1892 n_tty_set_termios(tty, NULL);
1893 tty_unthrottle(tty);
Jiri Slaby70ece7a2012-10-18 22:26:38 +02001894
Linus Torvalds1da177e2005-04-16 15:20:36 -07001895 return 0;
Jiri Slaby70ece7a2012-10-18 22:26:38 +02001896err:
Jiri Slabyb91939f2012-10-18 22:26:35 +02001897 return -ENOMEM;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001898}
1899
Peter Hurleyeafbe672013-12-02 14:24:45 -05001900static inline int input_available_p(struct tty_struct *tty, int poll)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001901{
Jiri Slaby53c5ee22012-10-18 22:26:39 +02001902 struct n_tty_data *ldata = tty->disc_data;
Peter Hurleya5934802014-02-11 11:49:58 -05001903 int amt = poll && !TIME_CHAR(tty) && MIN_CHAR(tty) ? MIN_CHAR(tty) : 1;
Jiri Slaby53c5ee22012-10-18 22:26:39 +02001904
Peter Hurley25e8d0e2014-02-11 18:55:30 -05001905 if (ldata->icanon && !L_EXTPROC(tty))
1906 return ldata->canon_head != ldata->read_tail;
1907 else
1908 return read_cnt(ldata) >= amt;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001909}
1910
1911/**
Thorsten Wißmannbbd20752011-12-08 17:47:33 +01001912 * copy_from_read_buf - copy read data directly
Linus Torvalds1da177e2005-04-16 15:20:36 -07001913 * @tty: terminal device
1914 * @b: user data
1915 * @nr: size of data
1916 *
Alan Cox11a96d12008-10-13 10:46:24 +01001917 * Helper function to speed up n_tty_read. It is only called when
Linus Torvalds1da177e2005-04-16 15:20:36 -07001918 * ICANON is off; it copies characters straight from the tty queue to
1919 * user space directly. It can be profitably called twice; once to
1920 * drain the space from the tail pointer to the (physical) end of the
1921 * buffer, and once to drain the space from the (physical) beginning of
1922 * the buffer to head pointer.
1923 *
Jiri Slabybddc7152012-10-18 22:26:42 +02001924 * Called under the ldata->atomic_read_lock sem
Linus Torvalds1da177e2005-04-16 15:20:36 -07001925 *
Peter Hurley6d76bd22013-06-15 09:14:26 -04001926 * n_tty_read()/consumer path:
1927 * caller holds non-exclusive termios_rwsem
1928 * read_tail published
Linus Torvalds1da177e2005-04-16 15:20:36 -07001929 */
Alan Cox4edf1822008-02-08 04:18:44 -08001930
Alan Cox33f0f882006-01-09 20:54:13 -08001931static int copy_from_read_buf(struct tty_struct *tty,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001932 unsigned char __user **b,
1933 size_t *nr)
1934
1935{
Jiri Slaby53c5ee22012-10-18 22:26:39 +02001936 struct n_tty_data *ldata = tty->disc_data;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001937 int retval;
1938 size_t n;
Jiri Slaby3fa10cc2012-04-26 20:13:00 +02001939 bool is_eof;
Peter Hurleybc5a5e32013-06-15 09:14:21 -04001940 size_t tail = ldata->read_tail & (N_TTY_BUF_SIZE - 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001941
1942 retval = 0;
Peter Hurleybc5a5e32013-06-15 09:14:21 -04001943 n = min(read_cnt(ldata), N_TTY_BUF_SIZE - tail);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001944 n = min(*nr, n);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001945 if (n) {
Peter Hurleybc5a5e32013-06-15 09:14:21 -04001946 retval = copy_to_user(*b, read_buf_addr(ldata, tail), n);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001947 n -= retval;
Peter Hurleybc5a5e32013-06-15 09:14:21 -04001948 is_eof = n == 1 && read_buf(ldata, tail) == EOF_CHAR(tty);
1949 tty_audit_add_data(tty, read_buf_addr(ldata, tail), n,
Jiri Slaby53c5ee22012-10-18 22:26:39 +02001950 ldata->icanon);
Peter Hurleybc5a5e32013-06-15 09:14:21 -04001951 ldata->read_tail += n;
hyc@symas.com26df6d12010-06-22 10:14:49 -07001952 /* Turn single EOF into zero-length read */
Peter Hurleyce741172013-06-15 09:14:20 -04001953 if (L_EXTPROC(tty) && ldata->icanon && is_eof && !read_cnt(ldata))
Jiri Slaby3fa10cc2012-04-26 20:13:00 +02001954 n = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001955 *b += n;
1956 *nr -= n;
1957 }
1958 return retval;
1959}
1960
Peter Hurley88bb0de2013-06-15 09:14:16 -04001961/**
Peter Hurley32f13522013-06-15 09:14:17 -04001962 * canon_copy_from_read_buf - copy read data in canonical mode
Peter Hurley88bb0de2013-06-15 09:14:16 -04001963 * @tty: terminal device
1964 * @b: user data
1965 * @nr: size of data
1966 *
1967 * Helper function for n_tty_read. It is only called when ICANON is on;
Peter Hurley32f13522013-06-15 09:14:17 -04001968 * it copies one line of input up to and including the line-delimiting
1969 * character into the user-space buffer.
Peter Hurley88bb0de2013-06-15 09:14:16 -04001970 *
Peter Hurley4d0ed182013-12-10 17:12:02 -05001971 * NB: When termios is changed from non-canonical to canonical mode and
1972 * the read buffer contains data, n_tty_set_termios() simulates an EOF
1973 * push (as if C-d were input) _without_ the DISABLED_CHAR in the buffer.
1974 * This causes data already processed as input to be immediately available
1975 * as input although a newline has not been received.
1976 *
Peter Hurley88bb0de2013-06-15 09:14:16 -04001977 * Called under the atomic_read_lock mutex
Peter Hurley6d76bd22013-06-15 09:14:26 -04001978 *
1979 * n_tty_read()/consumer path:
1980 * caller holds non-exclusive termios_rwsem
1981 * read_tail published
Peter Hurley88bb0de2013-06-15 09:14:16 -04001982 */
1983
Peter Hurley32f13522013-06-15 09:14:17 -04001984static int canon_copy_from_read_buf(struct tty_struct *tty,
1985 unsigned char __user **b,
1986 size_t *nr)
Peter Hurley88bb0de2013-06-15 09:14:16 -04001987{
1988 struct n_tty_data *ldata = tty->disc_data;
Peter Hurley32f13522013-06-15 09:14:17 -04001989 size_t n, size, more, c;
Peter Hurleybc5a5e32013-06-15 09:14:21 -04001990 size_t eol;
1991 size_t tail;
1992 int ret, found = 0;
Peter Hurley40d5e092013-06-15 10:21:17 -04001993 bool eof_push = 0;
Peter Hurley88bb0de2013-06-15 09:14:16 -04001994
1995 /* N.B. avoid overrun if nr == 0 */
Peter Hurleyce741172013-06-15 09:14:20 -04001996 n = min(*nr, read_cnt(ldata));
Peter Hurley6d76bd22013-06-15 09:14:26 -04001997 if (!n)
Peter Hurley32f13522013-06-15 09:14:17 -04001998 return 0;
Peter Hurley88bb0de2013-06-15 09:14:16 -04001999
Peter Hurleybc5a5e32013-06-15 09:14:21 -04002000 tail = ldata->read_tail & (N_TTY_BUF_SIZE - 1);
Peter Hurley32f13522013-06-15 09:14:17 -04002001 size = min_t(size_t, tail + n, N_TTY_BUF_SIZE);
2002
Peter Hurleybc5a5e32013-06-15 09:14:21 -04002003 n_tty_trace("%s: nr:%zu tail:%zu n:%zu size:%zu\n",
Peter Hurley32f13522013-06-15 09:14:17 -04002004 __func__, *nr, tail, n, size);
2005
2006 eol = find_next_bit(ldata->read_flags, size, tail);
2007 more = n - (size - tail);
2008 if (eol == N_TTY_BUF_SIZE && more) {
2009 /* scan wrapped without finding set bit */
2010 eol = find_next_bit(ldata->read_flags, more, 0);
2011 if (eol != more)
2012 found = 1;
2013 } else if (eol != size)
2014 found = 1;
2015
2016 size = N_TTY_BUF_SIZE - tail;
Peter Hurleyc77569d2013-11-22 07:16:25 -05002017 n = eol - tail;
2018 if (n > 4096)
2019 n += 4096;
2020 n += found;
Peter Hurley32f13522013-06-15 09:14:17 -04002021 c = n;
2022
Peter Hurley4d0ed182013-12-10 17:12:02 -05002023 if (found && !ldata->push && read_buf(ldata, eol) == __DISABLED_CHAR) {
Peter Hurley32f13522013-06-15 09:14:17 -04002024 n--;
Peter Hurley40d5e092013-06-15 10:21:17 -04002025 eof_push = !n && ldata->read_tail != ldata->line_start;
2026 }
Peter Hurley32f13522013-06-15 09:14:17 -04002027
Peter Hurleybc5a5e32013-06-15 09:14:21 -04002028 n_tty_trace("%s: eol:%zu found:%d n:%zu c:%zu size:%zu more:%zu\n",
Peter Hurley32f13522013-06-15 09:14:17 -04002029 __func__, eol, found, n, c, size, more);
2030
Peter Hurley32f13522013-06-15 09:14:17 -04002031 if (n > size) {
Peter Hurleybc5a5e32013-06-15 09:14:21 -04002032 ret = copy_to_user(*b, read_buf_addr(ldata, tail), size);
Peter Hurley32f13522013-06-15 09:14:17 -04002033 if (ret)
2034 return -EFAULT;
2035 ret = copy_to_user(*b + size, ldata->read_buf, n - size);
2036 } else
Peter Hurleybc5a5e32013-06-15 09:14:21 -04002037 ret = copy_to_user(*b, read_buf_addr(ldata, tail), n);
Peter Hurley32f13522013-06-15 09:14:17 -04002038
2039 if (ret)
2040 return -EFAULT;
2041 *b += n;
2042 *nr -= n;
2043
Peter Hurleya73d3d62013-06-15 09:14:25 -04002044 if (found)
Peter Hurley6d76bd22013-06-15 09:14:26 -04002045 clear_bit(eol, ldata->read_flags);
Peter Zijlstra4e857c52014-03-17 18:06:10 +01002046 smp_mb__after_atomic();
Peter Hurley6d76bd22013-06-15 09:14:26 -04002047 ldata->read_tail += c;
Peter Hurley88bb0de2013-06-15 09:14:16 -04002048
Peter Hurley40d5e092013-06-15 10:21:17 -04002049 if (found) {
Peter Hurley4d0ed182013-12-10 17:12:02 -05002050 if (!ldata->push)
2051 ldata->line_start = ldata->read_tail;
2052 else
2053 ldata->push = 0;
Peter Hurley32f13522013-06-15 09:14:17 -04002054 tty_audit_push(tty);
Peter Hurley40d5e092013-06-15 10:21:17 -04002055 }
2056 return eof_push ? -EAGAIN : 0;
Peter Hurley88bb0de2013-06-15 09:14:16 -04002057}
2058
Al Virocc4191d2008-03-29 03:08:48 +00002059extern ssize_t redirected_tty_write(struct file *, const char __user *,
Alan Cox4edf1822008-02-08 04:18:44 -08002060 size_t, loff_t *);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002061
2062/**
2063 * job_control - check job control
2064 * @tty: tty
2065 * @file: file handle
2066 *
2067 * Perform job control management checks on this file/tty descriptor
Alan Cox4edf1822008-02-08 04:18:44 -08002068 * and if appropriate send any needed signals and return a negative
Linus Torvalds1da177e2005-04-16 15:20:36 -07002069 * error code if action should be taken.
Alan Cox04f378b2008-04-30 00:53:29 -07002070 *
Peter Hurley01a5e442013-03-06 08:38:20 -05002071 * Locking: redirected write test is safe
2072 * current->signal->tty check is safe
2073 * ctrl_lock to safely reference tty->pgrp
Linus Torvalds1da177e2005-04-16 15:20:36 -07002074 */
Alan Cox4edf1822008-02-08 04:18:44 -08002075
Linus Torvalds1da177e2005-04-16 15:20:36 -07002076static int job_control(struct tty_struct *tty, struct file *file)
2077{
2078 /* Job control check -- must be done at start and after
2079 every sleep (POSIX.1 7.1.1.4). */
2080 /* NOTE: not yet done after every sleep pending a thorough
2081 check of the logic of this change. -- jlc */
2082 /* don't stop on /dev/console */
Peter Hurley01a5e442013-03-06 08:38:20 -05002083 if (file->f_op->write == redirected_tty_write ||
2084 current->signal->tty != tty)
2085 return 0;
2086
2087 spin_lock_irq(&tty->ctrl_lock);
2088 if (!tty->pgrp)
2089 printk(KERN_ERR "n_tty_read: no tty->pgrp!\n");
2090 else if (task_pgrp(current) != tty->pgrp) {
2091 spin_unlock_irq(&tty->ctrl_lock);
2092 if (is_ignored(SIGTTIN) || is_current_pgrp_orphaned())
2093 return -EIO;
2094 kill_pgrp(task_pgrp(current), SIGTTIN, 1);
2095 set_thread_flag(TIF_SIGPENDING);
2096 return -ERESTARTSYS;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002097 }
Peter Hurley01a5e442013-03-06 08:38:20 -05002098 spin_unlock_irq(&tty->ctrl_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002099 return 0;
2100}
Alan Cox4edf1822008-02-08 04:18:44 -08002101
Linus Torvalds1da177e2005-04-16 15:20:36 -07002102
2103/**
Alan Cox11a96d12008-10-13 10:46:24 +01002104 * n_tty_read - read function for tty
Linus Torvalds1da177e2005-04-16 15:20:36 -07002105 * @tty: tty device
2106 * @file: file object
2107 * @buf: userspace buffer pointer
2108 * @nr: size of I/O
2109 *
2110 * Perform reads for the line discipline. We are guaranteed that the
2111 * line discipline will not be closed under us but we may get multiple
2112 * parallel readers and must handle this ourselves. We may also get
2113 * a hangup. Always called in user context, may sleep.
2114 *
2115 * This code must be sure never to sleep through a hangup.
Peter Hurley6d76bd22013-06-15 09:14:26 -04002116 *
2117 * n_tty_read()/consumer path:
2118 * claims non-exclusive termios_rwsem
2119 * publishes read_tail
Linus Torvalds1da177e2005-04-16 15:20:36 -07002120 */
Alan Cox4edf1822008-02-08 04:18:44 -08002121
Alan Cox11a96d12008-10-13 10:46:24 +01002122static ssize_t n_tty_read(struct tty_struct *tty, struct file *file,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002123 unsigned char __user *buf, size_t nr)
2124{
Jiri Slaby53c5ee22012-10-18 22:26:39 +02002125 struct n_tty_data *ldata = tty->disc_data;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002126 unsigned char __user *b = buf;
Peter Zijlstra97d9e282014-09-24 10:18:51 +02002127 DEFINE_WAIT_FUNC(wait, woken_wake_function);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002128 int c;
2129 int minimum, time;
2130 ssize_t retval = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002131 long timeout;
Alan Cox04f378b2008-04-30 00:53:29 -07002132 int packet;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002133
Linus Torvalds1da177e2005-04-16 15:20:36 -07002134 c = job_control(tty, file);
Alan Cox4edf1822008-02-08 04:18:44 -08002135 if (c < 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002136 return c;
Alan Cox4edf1822008-02-08 04:18:44 -08002137
Peter Hurleyaefceaf2013-08-11 08:04:23 -04002138 /*
2139 * Internal serialization of reads.
2140 */
2141 if (file->f_flags & O_NONBLOCK) {
2142 if (!mutex_trylock(&ldata->atomic_read_lock))
2143 return -EAGAIN;
2144 } else {
2145 if (mutex_lock_interruptible(&ldata->atomic_read_lock))
2146 return -ERESTARTSYS;
2147 }
2148
Peter Hurley9356b532013-06-15 09:14:24 -04002149 down_read(&tty->termios_rwsem);
2150
Linus Torvalds1da177e2005-04-16 15:20:36 -07002151 minimum = time = 0;
2152 timeout = MAX_SCHEDULE_TIMEOUT;
Jiri Slaby53c5ee22012-10-18 22:26:39 +02002153 if (!ldata->icanon) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002154 minimum = MIN_CHAR(tty);
2155 if (minimum) {
Peter Hurleya6e54312013-06-15 07:28:29 -04002156 time = (HZ / 10) * TIME_CHAR(tty);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002157 if (time)
Peter Hurleyf6c8dbe2013-06-15 07:28:28 -04002158 ldata->minimum_to_wake = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002159 else if (!waitqueue_active(&tty->read_wait) ||
Peter Hurleyf6c8dbe2013-06-15 07:28:28 -04002160 (ldata->minimum_to_wake > minimum))
2161 ldata->minimum_to_wake = minimum;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002162 } else {
Peter Hurleya6e54312013-06-15 07:28:29 -04002163 timeout = (HZ / 10) * TIME_CHAR(tty);
Peter Hurleyf6c8dbe2013-06-15 07:28:28 -04002164 ldata->minimum_to_wake = minimum = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002165 }
2166 }
2167
Alan Cox04f378b2008-04-30 00:53:29 -07002168 packet = tty->packet;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002169
2170 add_wait_queue(&tty->read_wait, &wait);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002171 while (nr) {
2172 /* First test for status change. */
Alan Cox04f378b2008-04-30 00:53:29 -07002173 if (packet && tty->link->ctrl_status) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002174 unsigned char cs;
2175 if (b != buf)
2176 break;
Peter Hurley6054c16e2014-10-16 15:33:25 -04002177 spin_lock_irq(&tty->link->ctrl_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002178 cs = tty->link->ctrl_status;
2179 tty->link->ctrl_status = 0;
Peter Hurley6054c16e2014-10-16 15:33:25 -04002180 spin_unlock_irq(&tty->link->ctrl_lock);
Miloslav Trmac522ed772007-07-15 23:40:56 -07002181 if (tty_put_user(tty, cs, b++)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002182 retval = -EFAULT;
2183 b--;
2184 break;
2185 }
2186 nr--;
2187 break;
2188 }
Alan Cox4edf1822008-02-08 04:18:44 -08002189
Peter Hurleyf6c8dbe2013-06-15 07:28:28 -04002190 if (((minimum - (b - buf)) < ldata->minimum_to_wake) &&
Linus Torvalds1da177e2005-04-16 15:20:36 -07002191 ((minimum - (b - buf)) >= 1))
Peter Hurleyf6c8dbe2013-06-15 07:28:28 -04002192 ldata->minimum_to_wake = (minimum - (b - buf));
Alan Cox4edf1822008-02-08 04:18:44 -08002193
Linus Torvalds1da177e2005-04-16 15:20:36 -07002194 if (!input_available_p(tty, 0)) {
2195 if (test_bit(TTY_OTHER_CLOSED, &tty->flags)) {
Peter Hurley52bce7f2014-11-05 12:13:05 -05002196 retval = -EIO;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002197 break;
2198 }
Peter Hurley52bce7f2014-11-05 12:13:05 -05002199 if (tty_hung_up_p(file))
2200 break;
2201 if (!timeout)
2202 break;
2203 if (file->f_flags & O_NONBLOCK) {
2204 retval = -EAGAIN;
2205 break;
2206 }
2207 if (signal_pending(current)) {
2208 retval = -ERESTARTSYS;
2209 break;
2210 }
2211 n_tty_set_room(tty);
2212 up_read(&tty->termios_rwsem);
2213
Linus Torvalds37da7bb2014-12-14 15:23:32 -08002214 timeout = wait_woken(&wait, TASK_INTERRUPTIBLE,
2215 timeout);
Peter Hurley52bce7f2014-11-05 12:13:05 -05002216
2217 down_read(&tty->termios_rwsem);
2218 continue;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002219 }
2220
Jiri Slaby53c5ee22012-10-18 22:26:39 +02002221 if (ldata->icanon && !L_EXTPROC(tty)) {
Peter Hurley32f13522013-06-15 09:14:17 -04002222 retval = canon_copy_from_read_buf(tty, &b, &nr);
Peter Hurley40d5e092013-06-15 10:21:17 -04002223 if (retval == -EAGAIN) {
2224 retval = 0;
2225 continue;
2226 } else if (retval)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002227 break;
2228 } else {
2229 int uncopied;
Peter Hurley95ea90d2014-10-16 15:33:30 -04002230
2231 /* Deal with packet mode. */
2232 if (packet && b == buf) {
2233 if (tty_put_user(tty, TIOCPKT_DATA, b++)) {
2234 retval = -EFAULT;
2235 b--;
2236 break;
2237 }
2238 nr--;
2239 }
2240
Linus Torvalds1da177e2005-04-16 15:20:36 -07002241 uncopied = copy_from_read_buf(tty, &b, &nr);
2242 uncopied += copy_from_read_buf(tty, &b, &nr);
2243 if (uncopied) {
2244 retval = -EFAULT;
2245 break;
2246 }
2247 }
2248
Peter Hurley6367ca72013-06-15 09:14:33 -04002249 n_tty_check_unthrottle(tty);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002250
2251 if (b - buf >= minimum)
2252 break;
2253 if (time)
2254 timeout = time;
2255 }
Peter Hurley42458f42013-11-07 13:59:46 -05002256 n_tty_set_room(tty);
2257 up_read(&tty->termios_rwsem);
2258
Linus Torvalds1da177e2005-04-16 15:20:36 -07002259 remove_wait_queue(&tty->read_wait, &wait);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002260 if (!waitqueue_active(&tty->read_wait))
Peter Hurleyf6c8dbe2013-06-15 07:28:28 -04002261 ldata->minimum_to_wake = minimum;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002262
Peter Hurleyaebf04532013-11-07 14:01:57 -05002263 mutex_unlock(&ldata->atomic_read_lock);
2264
Peter Hurley40d5e092013-06-15 10:21:17 -04002265 if (b - buf)
2266 retval = b - buf;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002267
2268 return retval;
2269}
2270
2271/**
Alan Cox11a96d12008-10-13 10:46:24 +01002272 * n_tty_write - write function for tty
Linus Torvalds1da177e2005-04-16 15:20:36 -07002273 * @tty: tty device
2274 * @file: file object
2275 * @buf: userspace buffer pointer
2276 * @nr: size of I/O
2277 *
Joe Petersona88a69c2009-01-02 13:40:53 +00002278 * Write function of the terminal device. This is serialized with
Linus Torvalds1da177e2005-04-16 15:20:36 -07002279 * respect to other write callers but not to termios changes, reads
Joe Petersona88a69c2009-01-02 13:40:53 +00002280 * and other such events. Since the receive code will echo characters,
2281 * thus calling driver write methods, the output_lock is used in
2282 * the output processing functions called here as well as in the
2283 * echo processing function to protect the column state and space
2284 * left in the buffer.
Linus Torvalds1da177e2005-04-16 15:20:36 -07002285 *
2286 * This code must be sure never to sleep through a hangup.
Joe Petersona88a69c2009-01-02 13:40:53 +00002287 *
2288 * Locking: output_lock to protect column state and space left
2289 * (note that the process_output*() functions take this
2290 * lock themselves)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002291 */
Alan Cox4edf1822008-02-08 04:18:44 -08002292
Alan Cox11a96d12008-10-13 10:46:24 +01002293static ssize_t n_tty_write(struct tty_struct *tty, struct file *file,
Joe Petersona88a69c2009-01-02 13:40:53 +00002294 const unsigned char *buf, size_t nr)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002295{
2296 const unsigned char *b = buf;
Peter Zijlstra97d9e282014-09-24 10:18:51 +02002297 DEFINE_WAIT_FUNC(wait, woken_wake_function);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002298 int c;
2299 ssize_t retval = 0;
2300
2301 /* Job control check -- must be done at start (POSIX.1 7.1.1.4). */
2302 if (L_TOSTOP(tty) && file->f_op->write != redirected_tty_write) {
2303 retval = tty_check_change(tty);
2304 if (retval)
2305 return retval;
2306 }
2307
Peter Hurley9356b532013-06-15 09:14:24 -04002308 down_read(&tty->termios_rwsem);
2309
Joe Petersona88a69c2009-01-02 13:40:53 +00002310 /* Write out any echoed characters that are still pending */
2311 process_echoes(tty);
Alan Cox300a6202009-01-02 13:41:04 +00002312
Linus Torvalds1da177e2005-04-16 15:20:36 -07002313 add_wait_queue(&tty->write_wait, &wait);
2314 while (1) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002315 if (signal_pending(current)) {
2316 retval = -ERESTARTSYS;
2317 break;
2318 }
2319 if (tty_hung_up_p(file) || (tty->link && !tty->link->count)) {
2320 retval = -EIO;
2321 break;
2322 }
Peter Hurley582f5592013-05-17 12:49:48 -04002323 if (O_OPOST(tty)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002324 while (nr > 0) {
Joe Petersona88a69c2009-01-02 13:40:53 +00002325 ssize_t num = process_output_block(tty, b, nr);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002326 if (num < 0) {
2327 if (num == -EAGAIN)
2328 break;
2329 retval = num;
2330 goto break_out;
2331 }
2332 b += num;
2333 nr -= num;
2334 if (nr == 0)
2335 break;
2336 c = *b;
Joe Petersona88a69c2009-01-02 13:40:53 +00002337 if (process_output(c, tty) < 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002338 break;
2339 b++; nr--;
2340 }
Alan Coxf34d7a52008-04-30 00:54:13 -07002341 if (tty->ops->flush_chars)
2342 tty->ops->flush_chars(tty);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002343 } else {
Peter Hurley42910862014-05-03 14:04:59 +02002344 struct n_tty_data *ldata = tty->disc_data;
2345
Roman Zippeld6afe272005-07-07 17:56:55 -07002346 while (nr > 0) {
Peter Hurley42910862014-05-03 14:04:59 +02002347 mutex_lock(&ldata->output_lock);
Alan Coxf34d7a52008-04-30 00:54:13 -07002348 c = tty->ops->write(tty, b, nr);
Peter Hurley42910862014-05-03 14:04:59 +02002349 mutex_unlock(&ldata->output_lock);
Roman Zippeld6afe272005-07-07 17:56:55 -07002350 if (c < 0) {
2351 retval = c;
2352 goto break_out;
2353 }
2354 if (!c)
2355 break;
2356 b += c;
2357 nr -= c;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002358 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002359 }
2360 if (!nr)
2361 break;
2362 if (file->f_flags & O_NONBLOCK) {
2363 retval = -EAGAIN;
2364 break;
2365 }
Peter Hurley9356b532013-06-15 09:14:24 -04002366 up_read(&tty->termios_rwsem);
2367
Peter Zijlstra97d9e282014-09-24 10:18:51 +02002368 wait_woken(&wait, TASK_INTERRUPTIBLE, MAX_SCHEDULE_TIMEOUT);
Peter Hurley9356b532013-06-15 09:14:24 -04002369
2370 down_read(&tty->termios_rwsem);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002371 }
2372break_out:
Linus Torvalds1da177e2005-04-16 15:20:36 -07002373 remove_wait_queue(&tty->write_wait, &wait);
Thomas Pfaffff8cb0f2009-01-02 13:47:13 +00002374 if (b - buf != nr && tty->fasync)
2375 set_bit(TTY_DO_WRITE_WAKEUP, &tty->flags);
Peter Hurley9356b532013-06-15 09:14:24 -04002376 up_read(&tty->termios_rwsem);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002377 return (b - buf) ? b - buf : retval;
2378}
2379
2380/**
Alan Cox11a96d12008-10-13 10:46:24 +01002381 * n_tty_poll - poll method for N_TTY
Linus Torvalds1da177e2005-04-16 15:20:36 -07002382 * @tty: terminal device
2383 * @file: file accessing it
2384 * @wait: poll table
2385 *
2386 * Called when the line discipline is asked to poll() for data or
2387 * for special events. This code is not serialized with respect to
2388 * other events save open/close.
2389 *
2390 * This code must be sure never to sleep through a hangup.
2391 * Called without the kernel lock held - fine
Linus Torvalds1da177e2005-04-16 15:20:36 -07002392 */
Alan Cox4edf1822008-02-08 04:18:44 -08002393
Alan Cox11a96d12008-10-13 10:46:24 +01002394static unsigned int n_tty_poll(struct tty_struct *tty, struct file *file,
Alan Cox4edf1822008-02-08 04:18:44 -08002395 poll_table *wait)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002396{
Peter Hurleyf6c8dbe2013-06-15 07:28:28 -04002397 struct n_tty_data *ldata = tty->disc_data;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002398 unsigned int mask = 0;
2399
2400 poll_wait(file, &tty->read_wait, wait);
2401 poll_wait(file, &tty->write_wait, wait);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002402 if (test_bit(TTY_OTHER_CLOSED, &tty->flags))
2403 mask |= POLLHUP;
Francesco Ruggeric4dc3042014-10-10 13:09:53 -07002404 if (input_available_p(tty, 1))
2405 mask |= POLLIN | POLLRDNORM;
2406 else if (mask & POLLHUP) {
2407 tty_flush_to_ldisc(tty);
2408 if (input_available_p(tty, 1))
2409 mask |= POLLIN | POLLRDNORM;
2410 }
2411 if (tty->packet && tty->link->ctrl_status)
2412 mask |= POLLPRI | POLLIN | POLLRDNORM;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002413 if (tty_hung_up_p(file))
2414 mask |= POLLHUP;
2415 if (!(mask & (POLLHUP | POLLIN | POLLRDNORM))) {
2416 if (MIN_CHAR(tty) && !TIME_CHAR(tty))
Peter Hurleyf6c8dbe2013-06-15 07:28:28 -04002417 ldata->minimum_to_wake = MIN_CHAR(tty);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002418 else
Peter Hurleyf6c8dbe2013-06-15 07:28:28 -04002419 ldata->minimum_to_wake = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002420 }
Alan Coxf34d7a52008-04-30 00:54:13 -07002421 if (tty->ops->write && !tty_is_writelocked(tty) &&
2422 tty_chars_in_buffer(tty) < WAKEUP_CHARS &&
2423 tty_write_room(tty) > 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002424 mask |= POLLOUT | POLLWRNORM;
2425 return mask;
2426}
2427
Jiri Slaby57c94122012-10-18 22:26:43 +02002428static unsigned long inq_canon(struct n_tty_data *ldata)
Alan Cox47afa7a2008-10-13 10:44:17 +01002429{
Peter Hurleybc5a5e32013-06-15 09:14:21 -04002430 size_t nr, head, tail;
Alan Cox47afa7a2008-10-13 10:44:17 +01002431
Peter Hurleya73d3d62013-06-15 09:14:25 -04002432 if (ldata->canon_head == ldata->read_tail)
Alan Cox47afa7a2008-10-13 10:44:17 +01002433 return 0;
Jiri Slabyba2e68a2012-10-18 22:26:41 +02002434 head = ldata->canon_head;
2435 tail = ldata->read_tail;
Peter Hurleybc5a5e32013-06-15 09:14:21 -04002436 nr = head - tail;
Alan Cox47afa7a2008-10-13 10:44:17 +01002437 /* Skip EOF-chars.. */
2438 while (head != tail) {
Peter Hurleybc5a5e32013-06-15 09:14:21 -04002439 if (test_bit(tail & (N_TTY_BUF_SIZE - 1), ldata->read_flags) &&
2440 read_buf(ldata, tail) == __DISABLED_CHAR)
Alan Cox47afa7a2008-10-13 10:44:17 +01002441 nr--;
Peter Hurleybc5a5e32013-06-15 09:14:21 -04002442 tail++;
Alan Cox47afa7a2008-10-13 10:44:17 +01002443 }
2444 return nr;
2445}
2446
2447static int n_tty_ioctl(struct tty_struct *tty, struct file *file,
2448 unsigned int cmd, unsigned long arg)
2449{
Jiri Slabyba2e68a2012-10-18 22:26:41 +02002450 struct n_tty_data *ldata = tty->disc_data;
Alan Cox47afa7a2008-10-13 10:44:17 +01002451 int retval;
2452
2453 switch (cmd) {
2454 case TIOCOUTQ:
2455 return put_user(tty_chars_in_buffer(tty), (int __user *) arg);
2456 case TIOCINQ:
Peter Hurley6d76bd22013-06-15 09:14:26 -04002457 down_write(&tty->termios_rwsem);
Alan Cox47afa7a2008-10-13 10:44:17 +01002458 if (L_ICANON(tty))
Jiri Slaby57c94122012-10-18 22:26:43 +02002459 retval = inq_canon(ldata);
Peter Hurley6d76bd22013-06-15 09:14:26 -04002460 else
2461 retval = read_cnt(ldata);
2462 up_write(&tty->termios_rwsem);
Alan Cox47afa7a2008-10-13 10:44:17 +01002463 return put_user(retval, (unsigned int __user *) arg);
2464 default:
2465 return n_tty_ioctl_helper(tty, file, cmd, arg);
2466 }
2467}
2468
Peter Hurleyf6c8dbe2013-06-15 07:28:28 -04002469static void n_tty_fasync(struct tty_struct *tty, int on)
2470{
2471 struct n_tty_data *ldata = tty->disc_data;
2472
2473 if (!waitqueue_active(&tty->read_wait)) {
2474 if (on)
2475 ldata->minimum_to_wake = 1;
2476 else if (!tty->fasync)
2477 ldata->minimum_to_wake = N_TTY_BUF_SIZE;
2478 }
2479}
2480
Alan Coxa352def2008-07-16 21:53:12 +01002481struct tty_ldisc_ops tty_ldisc_N_TTY = {
Paul Fulghume10cc1d2007-05-10 22:22:50 -07002482 .magic = TTY_LDISC_MAGIC,
2483 .name = "n_tty",
2484 .open = n_tty_open,
2485 .close = n_tty_close,
2486 .flush_buffer = n_tty_flush_buffer,
2487 .chars_in_buffer = n_tty_chars_in_buffer,
Alan Cox11a96d12008-10-13 10:46:24 +01002488 .read = n_tty_read,
2489 .write = n_tty_write,
Paul Fulghume10cc1d2007-05-10 22:22:50 -07002490 .ioctl = n_tty_ioctl,
2491 .set_termios = n_tty_set_termios,
Alan Cox11a96d12008-10-13 10:46:24 +01002492 .poll = n_tty_poll,
Paul Fulghume10cc1d2007-05-10 22:22:50 -07002493 .receive_buf = n_tty_receive_buf,
Peter Hurleyf6c8dbe2013-06-15 07:28:28 -04002494 .write_wakeup = n_tty_write_wakeup,
2495 .fasync = n_tty_fasync,
Peter Hurley24a89d12013-06-15 09:14:15 -04002496 .receive_buf2 = n_tty_receive_buf2,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002497};
Rodolfo Giometti572b9ad2010-03-10 15:23:46 -08002498
2499/**
2500 * n_tty_inherit_ops - inherit N_TTY methods
2501 * @ops: struct tty_ldisc_ops where to save N_TTY methods
2502 *
George Spelvin593fb1ae42013-02-12 02:00:43 -05002503 * Enables a 'subclass' line discipline to 'inherit' N_TTY
Rodolfo Giometti572b9ad2010-03-10 15:23:46 -08002504 * methods.
2505 */
2506
2507void n_tty_inherit_ops(struct tty_ldisc_ops *ops)
2508{
2509 *ops = tty_ldisc_N_TTY;
2510 ops->owner = NULL;
2511 ops->refcount = ops->flags = 0;
2512}
2513EXPORT_SYMBOL_GPL(n_tty_inherit_ops);