blob: cc57a3a6b02b348df95c827fd2c770e59ffca155 [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;
Peter Hurley70aca712015-01-16 15:05:37 -050093 size_t commit_head;
Peter Hurleyfb7aa032013-06-15 09:14:30 -040094 size_t canon_head;
Peter Hurley9dfd16d2013-06-15 10:04:29 -040095 size_t echo_head;
96 size_t echo_commit;
Peter Hurley1075a6e2013-12-09 18:06:07 -050097 size_t echo_mark;
Peter Hurley1bb9d562013-06-15 10:21:20 -040098 DECLARE_BITMAP(char_map, 256);
Peter Hurleyfb7aa032013-06-15 09:14:30 -040099
100 /* private to n_tty_receive_overrun (single-threaded) */
Jiri Slaby53c5ee22012-10-18 22:26:39 +0200101 unsigned long overrun_time;
102 int num_overrun;
103
Peter Hurley24a89d12013-06-15 09:14:15 -0400104 /* non-atomic */
105 bool no_room;
106
Peter Hurleyfb7aa032013-06-15 09:14:30 -0400107 /* must hold exclusive termios_rwsem to reset these */
Jiri Slaby53c5ee22012-10-18 22:26:39 +0200108 unsigned char lnext:1, erasing:1, raw:1, real_raw:1, icanon:1;
Peter Hurley4d0ed182013-12-10 17:12:02 -0500109 unsigned char push:1;
Jiri Slaby3fe780b2012-10-18 22:26:40 +0200110
Peter Hurleyfb7aa032013-06-15 09:14:30 -0400111 /* shared by producer and consumer */
Peter Hurley20bafb32013-06-15 10:21:19 -0400112 char read_buf[N_TTY_BUF_SIZE];
Jiri Slaby3fe780b2012-10-18 22:26:40 +0200113 DECLARE_BITMAP(read_flags, N_TTY_BUF_SIZE);
Peter Hurley20bafb32013-06-15 10:21:19 -0400114 unsigned char echo_buf[N_TTY_BUF_SIZE];
Jiri Slabyba2e68a2012-10-18 22:26:41 +0200115
Peter Hurleyf6c8dbe2013-06-15 07:28:28 -0400116 int minimum_to_wake;
Jiri Slabyba2e68a2012-10-18 22:26:41 +0200117
Peter Hurleyfb7aa032013-06-15 09:14:30 -0400118 /* consumer-published */
119 size_t read_tail;
Peter Hurley40d5e092013-06-15 10:21:17 -0400120 size_t line_start;
Peter Hurleyfb7aa032013-06-15 09:14:30 -0400121
Peter Hurleyfb7aa032013-06-15 09:14:30 -0400122 /* protected by output lock */
123 unsigned int column;
Jiri Slabyba2e68a2012-10-18 22:26:41 +0200124 unsigned int canon_column;
Peter Hurley9dfd16d2013-06-15 10:04:29 -0400125 size_t echo_tail;
Jiri Slabybddc7152012-10-18 22:26:42 +0200126
127 struct mutex atomic_read_lock;
128 struct mutex output_lock;
Jiri Slaby70ece7a2012-10-18 22:26:38 +0200129};
130
Peter Hurleyce741172013-06-15 09:14:20 -0400131static inline size_t read_cnt(struct n_tty_data *ldata)
132{
Peter Hurleya2f73be2013-06-15 09:14:22 -0400133 return ldata->read_head - ldata->read_tail;
Peter Hurleyce741172013-06-15 09:14:20 -0400134}
135
Peter Hurleybc5a5e32013-06-15 09:14:21 -0400136static inline unsigned char read_buf(struct n_tty_data *ldata, size_t i)
137{
138 return ldata->read_buf[i & (N_TTY_BUF_SIZE - 1)];
139}
140
141static inline unsigned char *read_buf_addr(struct n_tty_data *ldata, size_t i)
142{
143 return &ldata->read_buf[i & (N_TTY_BUF_SIZE - 1)];
144}
145
Peter Hurleyaddaebc2013-06-15 10:04:22 -0400146static inline unsigned char echo_buf(struct n_tty_data *ldata, size_t i)
147{
148 return ldata->echo_buf[i & (N_TTY_BUF_SIZE - 1)];
149}
150
151static inline unsigned char *echo_buf_addr(struct n_tty_data *ldata, size_t i)
152{
153 return &ldata->echo_buf[i & (N_TTY_BUF_SIZE - 1)];
154}
155
Miloslav Trmac522ed772007-07-15 23:40:56 -0700156static inline int tty_put_user(struct tty_struct *tty, unsigned char x,
157 unsigned char __user *ptr)
158{
Jiri Slaby53c5ee22012-10-18 22:26:39 +0200159 struct n_tty_data *ldata = tty->disc_data;
160
161 tty_audit_add_data(tty, &x, 1, ldata->icanon);
Miloslav Trmac522ed772007-07-15 23:40:56 -0700162 return put_user(x, ptr);
163}
164
Peter Hurley24a89d12013-06-15 09:14:15 -0400165/**
Peter Hurley2c5dc462015-01-16 15:05:34 -0500166 * n_tty_kick_worker - start input worker (if required)
Peter Hurley24a89d12013-06-15 09:14:15 -0400167 * @tty: terminal
168 *
Peter Hurley2c5dc462015-01-16 15:05:34 -0500169 * Re-schedules the flip buffer work if it may have stopped
Peter Hurley24a89d12013-06-15 09:14:15 -0400170 *
Peter Hurley6d76bd22013-06-15 09:14:26 -0400171 * Caller holds exclusive termios_rwsem
172 * or
173 * n_tty_read()/consumer path:
174 * holds non-exclusive termios_rwsem
Peter Hurley24a89d12013-06-15 09:14:15 -0400175 */
176
Peter Hurley2c5dc462015-01-16 15:05:34 -0500177static void n_tty_kick_worker(struct tty_struct *tty)
Peter Hurley7879a9f2013-06-15 07:28:31 -0400178{
Peter Hurley24a89d12013-06-15 09:14:15 -0400179 struct n_tty_data *ldata = tty->disc_data;
180
Peter Hurley2c5dc462015-01-16 15:05:34 -0500181 /* Did the input worker stop? Restart it */
182 if (unlikely(ldata->no_room)) {
Peter Hurley24a89d12013-06-15 09:14:15 -0400183 ldata->no_room = 0;
184
Jiri Slabyecbbfd42012-10-18 22:26:47 +0200185 WARN_RATELIMIT(tty->port->itty == NULL,
Sasha Levincadf7482012-10-25 14:26:35 -0400186 "scheduling with invalid itty\n");
Peter Hurley21622932013-03-11 16:44:21 -0400187 /* see if ldisc has been killed - if so, this means that
188 * even though the ldisc has been halted and ->buf.work
189 * cancelled, ->buf.work is about to be rescheduled
190 */
191 WARN_RATELIMIT(test_bit(TTY_LDISC_HALTED, &tty->flags),
192 "scheduling buffer work for halted ldisc\n");
Peter Hurleyf0f947c2013-06-15 09:14:36 -0400193 queue_work(system_unbound_wq, &tty->port->buf.work);
Jiri Slabyecbbfd42012-10-18 22:26:47 +0200194 }
Linus Torvalds55db4c62011-06-04 06:33:24 +0900195}
196
Peter Hurley9a4aec22013-06-15 09:14:32 -0400197static ssize_t chars_in_buffer(struct tty_struct *tty)
198{
199 struct n_tty_data *ldata = tty->disc_data;
200 ssize_t n = 0;
201
202 if (!ldata->icanon)
Peter Hurley70aca712015-01-16 15:05:37 -0500203 n = ldata->commit_head - ldata->read_tail;
Peter Hurley9a4aec22013-06-15 09:14:32 -0400204 else
205 n = ldata->canon_head - ldata->read_tail;
206 return n;
207}
208
Peter Hurleyee0bab82013-06-15 09:14:34 -0400209/**
210 * n_tty_write_wakeup - asynchronous I/O notifier
211 * @tty: tty device
212 *
213 * Required for the ptys, serial driver etc. since processes
214 * that attach themselves to the master and rely on ASYNC
215 * IO must be woken up
216 */
217
218static void n_tty_write_wakeup(struct tty_struct *tty)
219{
220 if (tty->fasync && test_and_clear_bit(TTY_DO_WRITE_WAKEUP, &tty->flags))
221 kill_fasync(&tty->fasync, SIGIO, POLL_OUT);
222}
223
Peter Hurley4a23a4d2013-06-15 10:21:22 -0400224static void n_tty_check_throttle(struct tty_struct *tty)
Peter Hurley6367ca72013-06-15 09:14:33 -0400225{
Peter Hurleya3428462015-01-16 15:05:35 -0500226 struct n_tty_data *ldata = tty->disc_data;
227
Peter Hurley6367ca72013-06-15 09:14:33 -0400228 /*
229 * Check the remaining room for the input canonicalization
230 * mode. We don't want to throttle the driver if we're in
231 * canonical mode and don't have a newline yet!
232 */
Peter Hurleya3428462015-01-16 15:05:35 -0500233 if (ldata->icanon && ldata->canon_head == ldata->read_tail)
234 return;
235
Peter Hurley6367ca72013-06-15 09:14:33 -0400236 while (1) {
237 int throttled;
238 tty_set_flow_change(tty, TTY_THROTTLE_SAFE);
Peter Hurley5e28cca2015-01-16 15:05:36 -0500239 if (N_TTY_BUF_SIZE - read_cnt(ldata) >= TTY_THRESHOLD_THROTTLE)
Peter Hurley6367ca72013-06-15 09:14:33 -0400240 break;
241 throttled = tty_throttle_safe(tty);
242 if (!throttled)
243 break;
244 }
245 __tty_set_flow_change(tty, 0);
246}
247
Peter Hurley4b293492013-07-24 08:29:55 -0400248static void n_tty_check_unthrottle(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 tty->link->ldisc->ops->write_wakeup == n_tty_write_wakeup) {
252 if (chars_in_buffer(tty) > TTY_THRESHOLD_UNTHROTTLE)
253 return;
254 if (!tty->count)
255 return;
Peter Hurley2c5dc462015-01-16 15:05:34 -0500256 n_tty_kick_worker(tty);
Peter Hurley3afb1b392013-07-23 08:47:30 -0400257 n_tty_write_wakeup(tty->link);
Peter Hurley6c677162013-12-02 14:24:46 -0500258 if (waitqueue_active(&tty->link->write_wait))
259 wake_up_interruptible_poll(&tty->link->write_wait, POLLOUT);
Peter Hurley3afb1b392013-07-23 08:47:30 -0400260 return;
261 }
262
Peter Hurley6367ca72013-06-15 09:14:33 -0400263 /* If there is enough space in the read buffer now, let the
264 * low-level driver know. We use chars_in_buffer() to
265 * check the buffer, as it now knows about canonical mode.
266 * Otherwise, if the driver is throttled and the line is
267 * longer than TTY_THRESHOLD_UNTHROTTLE in canonical mode,
268 * we won't get any more characters.
269 */
270
271 while (1) {
272 int unthrottled;
273 tty_set_flow_change(tty, TTY_UNTHROTTLE_SAFE);
274 if (chars_in_buffer(tty) > TTY_THRESHOLD_UNTHROTTLE)
275 break;
276 if (!tty->count)
277 break;
Peter Hurley2c5dc462015-01-16 15:05:34 -0500278 n_tty_kick_worker(tty);
Peter Hurley6367ca72013-06-15 09:14:33 -0400279 unthrottled = tty_unthrottle_safe(tty);
280 if (!unthrottled)
281 break;
282 }
283 __tty_set_flow_change(tty, 0);
284}
285
Alan Cox17b82062008-10-13 10:45:06 +0100286/**
287 * put_tty_queue - add character to tty
288 * @c: character
Jiri Slaby57c94122012-10-18 22:26:43 +0200289 * @ldata: n_tty data
Alan Cox17b82062008-10-13 10:45:06 +0100290 *
Peter Hurley6d76bd22013-06-15 09:14:26 -0400291 * Add a character to the tty read_buf queue.
292 *
293 * n_tty_receive_buf()/producer path:
294 * caller holds non-exclusive termios_rwsem
Alan Cox17b82062008-10-13 10:45:06 +0100295 */
296
Peter Hurley19e2ad62013-07-24 08:29:54 -0400297static inline void put_tty_queue(unsigned char c, struct n_tty_data *ldata)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700298{
Christian Riesch8bfbe2d2014-11-13 05:53:26 +0100299 *read_buf_addr(ldata, ldata->read_head) = c;
300 ldata->read_head++;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700301}
302
303/**
Linus Torvalds1da177e2005-04-16 15:20:36 -0700304 * reset_buffer_flags - reset buffer state
305 * @tty: terminal to reset
306 *
Peter Hurley25518c62013-03-11 16:44:31 -0400307 * Reset the read buffer counters and clear the flags.
308 * Called from n_tty_open() and n_tty_flush_buffer().
Alan Cox17b82062008-10-13 10:45:06 +0100309 *
Peter Hurley6d76bd22013-06-15 09:14:26 -0400310 * Locking: caller holds exclusive termios_rwsem
311 * (or locking is not required)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700312 */
Joe Petersona88a69c2009-01-02 13:40:53 +0000313
Peter Hurleyb66f4fa2013-03-11 16:44:32 -0400314static void reset_buffer_flags(struct n_tty_data *ldata)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700315{
Peter Hurleya73d3d62013-06-15 09:14:25 -0400316 ldata->read_head = ldata->canon_head = ldata->read_tail = 0;
Peter Hurley17bd7902013-06-15 10:04:24 -0400317 ldata->echo_head = ldata->echo_tail = ldata->echo_commit = 0;
Peter Hurley70aca712015-01-16 15:05:37 -0500318 ldata->commit_head = 0;
Peter Hurley1075a6e2013-12-09 18:06:07 -0500319 ldata->echo_mark = 0;
Peter Hurley40d5e092013-06-15 10:21:17 -0400320 ldata->line_start = 0;
Joe Petersona88a69c2009-01-02 13:40:53 +0000321
Peter Hurleya73d3d62013-06-15 09:14:25 -0400322 ldata->erasing = 0;
Jiri Slaby3fe780b2012-10-18 22:26:40 +0200323 bitmap_zero(ldata->read_flags, N_TTY_BUF_SIZE);
Peter Hurley4d0ed182013-12-10 17:12:02 -0500324 ldata->push = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700325}
326
Peter Hurleya30737a2013-03-11 16:44:22 -0400327static void n_tty_packet_mode_flush(struct tty_struct *tty)
328{
329 unsigned long flags;
330
Peter Hurleya30737a2013-03-11 16:44:22 -0400331 if (tty->link->packet) {
Peter Hurley54e8e5f2014-10-16 15:33:26 -0400332 spin_lock_irqsave(&tty->ctrl_lock, flags);
Peter Hurleya30737a2013-03-11 16:44:22 -0400333 tty->ctrl_status |= TIOCPKT_FLUSHREAD;
Peter Hurley54e8e5f2014-10-16 15:33:26 -0400334 spin_unlock_irqrestore(&tty->ctrl_lock, flags);
Peter Hurley6c677162013-12-02 14:24:46 -0500335 if (waitqueue_active(&tty->link->read_wait))
336 wake_up_interruptible(&tty->link->read_wait);
Peter Hurleya30737a2013-03-11 16:44:22 -0400337 }
Peter Hurleya30737a2013-03-11 16:44:22 -0400338}
339
Linus Torvalds1da177e2005-04-16 15:20:36 -0700340/**
341 * n_tty_flush_buffer - clean input queue
342 * @tty: terminal device
343 *
Peter Hurley25518c62013-03-11 16:44:31 -0400344 * Flush the input buffer. Called when the tty layer wants the
345 * buffer flushed (eg at hangup) or when the N_TTY line discipline
346 * internally has to clean the pending queue (for example some signals).
Linus Torvalds1da177e2005-04-16 15:20:36 -0700347 *
Peter Hurley6d76bd22013-06-15 09:14:26 -0400348 * Holds termios_rwsem to exclude producer/consumer while
349 * buffer indices are reset.
350 *
351 * Locking: ctrl_lock, exclusive termios_rwsem
Linus Torvalds1da177e2005-04-16 15:20:36 -0700352 */
Alan Cox4edf1822008-02-08 04:18:44 -0800353
354static void n_tty_flush_buffer(struct tty_struct *tty)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700355{
Peter Hurley6d76bd22013-06-15 09:14:26 -0400356 down_write(&tty->termios_rwsem);
Peter Hurleyb66f4fa2013-03-11 16:44:32 -0400357 reset_buffer_flags(tty->disc_data);
Peter Hurley2c5dc462015-01-16 15:05:34 -0500358 n_tty_kick_worker(tty);
Alan Cox4edf1822008-02-08 04:18:44 -0800359
Peter Hurleya30737a2013-03-11 16:44:22 -0400360 if (tty->link)
361 n_tty_packet_mode_flush(tty);
Peter Hurley6d76bd22013-06-15 09:14:26 -0400362 up_write(&tty->termios_rwsem);
363}
364
Linus Torvalds1da177e2005-04-16 15:20:36 -0700365/**
366 * n_tty_chars_in_buffer - report available bytes
367 * @tty: tty device
368 *
369 * Report the number of characters buffered to be delivered to user
Alan Cox4edf1822008-02-08 04:18:44 -0800370 * at this instant in time.
Alan Cox17b82062008-10-13 10:45:06 +0100371 *
Peter Hurley6d76bd22013-06-15 09:14:26 -0400372 * Locking: exclusive termios_rwsem
Linus Torvalds1da177e2005-04-16 15:20:36 -0700373 */
Alan Cox4edf1822008-02-08 04:18:44 -0800374
Peter Hurleya19d0c62013-06-15 09:14:18 -0400375static ssize_t n_tty_chars_in_buffer(struct tty_struct *tty)
376{
Peter Hurley6d76bd22013-06-15 09:14:26 -0400377 ssize_t n;
378
Peter Hurley47534082013-06-15 09:14:19 -0400379 WARN_ONCE(1, "%s is deprecated and scheduled for removal.", __func__);
Peter Hurley6d76bd22013-06-15 09:14:26 -0400380
381 down_write(&tty->termios_rwsem);
382 n = chars_in_buffer(tty);
383 up_write(&tty->termios_rwsem);
384 return n;
Peter Hurleya19d0c62013-06-15 09:14:18 -0400385}
386
Linus Torvalds1da177e2005-04-16 15:20:36 -0700387/**
388 * is_utf8_continuation - utf8 multibyte check
389 * @c: byte to check
390 *
391 * Returns true if the utf8 character 'c' is a multibyte continuation
392 * character. We use this to correctly compute the on screen size
393 * of the character when printing
394 */
Alan Cox4edf1822008-02-08 04:18:44 -0800395
Linus Torvalds1da177e2005-04-16 15:20:36 -0700396static inline int is_utf8_continuation(unsigned char c)
397{
398 return (c & 0xc0) == 0x80;
399}
400
401/**
402 * is_continuation - multibyte check
403 * @c: byte to check
404 *
405 * Returns true if the utf8 character 'c' is a multibyte continuation
406 * character and the terminal is in unicode mode.
407 */
Alan Cox4edf1822008-02-08 04:18:44 -0800408
Linus Torvalds1da177e2005-04-16 15:20:36 -0700409static inline int is_continuation(unsigned char c, struct tty_struct *tty)
410{
411 return I_IUTF8(tty) && is_utf8_continuation(c);
412}
413
414/**
Joe Petersona88a69c2009-01-02 13:40:53 +0000415 * do_output_char - output one character
416 * @c: character (or partial unicode symbol)
417 * @tty: terminal device
418 * @space: space available in tty driver write buffer
419 *
420 * This is a helper function that handles one output character
421 * (including special characters like TAB, CR, LF, etc.),
Joe Petersonee5aa7b2009-09-09 15:03:13 -0600422 * doing OPOST processing and putting the results in the
423 * tty driver's write buffer.
Joe Petersona88a69c2009-01-02 13:40:53 +0000424 *
425 * Note that Linux currently ignores TABDLY, CRDLY, VTDLY, FFDLY
426 * and NLDLY. They simply aren't relevant in the world today.
427 * If you ever need them, add them here.
428 *
429 * Returns the number of bytes of buffer space used or -1 if
430 * no space left.
431 *
432 * Locking: should be called under the output_lock to protect
433 * the column state and space left in the buffer
434 */
435
436static int do_output_char(unsigned char c, struct tty_struct *tty, int space)
437{
Jiri Slaby53c5ee22012-10-18 22:26:39 +0200438 struct n_tty_data *ldata = tty->disc_data;
Joe Petersona88a69c2009-01-02 13:40:53 +0000439 int spaces;
440
441 if (!space)
442 return -1;
Alan Cox300a6202009-01-02 13:41:04 +0000443
Joe Petersona88a69c2009-01-02 13:40:53 +0000444 switch (c) {
445 case '\n':
446 if (O_ONLRET(tty))
Jiri Slaby53c5ee22012-10-18 22:26:39 +0200447 ldata->column = 0;
Joe Petersona88a69c2009-01-02 13:40:53 +0000448 if (O_ONLCR(tty)) {
449 if (space < 2)
450 return -1;
Jiri Slabyba2e68a2012-10-18 22:26:41 +0200451 ldata->canon_column = ldata->column = 0;
Linus Torvalds37f81fa2009-09-05 12:46:07 -0700452 tty->ops->write(tty, "\r\n", 2);
Joe Petersona88a69c2009-01-02 13:40:53 +0000453 return 2;
454 }
Jiri Slabyba2e68a2012-10-18 22:26:41 +0200455 ldata->canon_column = ldata->column;
Joe Petersona88a69c2009-01-02 13:40:53 +0000456 break;
457 case '\r':
Jiri Slaby53c5ee22012-10-18 22:26:39 +0200458 if (O_ONOCR(tty) && ldata->column == 0)
Joe Petersona88a69c2009-01-02 13:40:53 +0000459 return 0;
460 if (O_OCRNL(tty)) {
461 c = '\n';
462 if (O_ONLRET(tty))
Jiri Slabyba2e68a2012-10-18 22:26:41 +0200463 ldata->canon_column = ldata->column = 0;
Joe Petersona88a69c2009-01-02 13:40:53 +0000464 break;
465 }
Jiri Slabyba2e68a2012-10-18 22:26:41 +0200466 ldata->canon_column = ldata->column = 0;
Joe Petersona88a69c2009-01-02 13:40:53 +0000467 break;
468 case '\t':
Jiri Slaby53c5ee22012-10-18 22:26:39 +0200469 spaces = 8 - (ldata->column & 7);
Joe Petersona88a69c2009-01-02 13:40:53 +0000470 if (O_TABDLY(tty) == XTABS) {
471 if (space < spaces)
472 return -1;
Jiri Slaby53c5ee22012-10-18 22:26:39 +0200473 ldata->column += spaces;
Joe Petersona88a69c2009-01-02 13:40:53 +0000474 tty->ops->write(tty, " ", spaces);
475 return spaces;
476 }
Jiri Slaby53c5ee22012-10-18 22:26:39 +0200477 ldata->column += spaces;
Joe Petersona88a69c2009-01-02 13:40:53 +0000478 break;
479 case '\b':
Jiri Slaby53c5ee22012-10-18 22:26:39 +0200480 if (ldata->column > 0)
481 ldata->column--;
Joe Petersona88a69c2009-01-02 13:40:53 +0000482 break;
483 default:
Joe Petersona59c0d62009-01-02 13:43:25 +0000484 if (!iscntrl(c)) {
485 if (O_OLCUC(tty))
486 c = toupper(c);
487 if (!is_continuation(c, tty))
Jiri Slaby53c5ee22012-10-18 22:26:39 +0200488 ldata->column++;
Joe Petersona59c0d62009-01-02 13:43:25 +0000489 }
Joe Petersona88a69c2009-01-02 13:40:53 +0000490 break;
491 }
492
493 tty_put_char(tty, c);
494 return 1;
495}
496
497/**
498 * process_output - output post processor
Linus Torvalds1da177e2005-04-16 15:20:36 -0700499 * @c: character (or partial unicode symbol)
500 * @tty: terminal device
501 *
Joe Petersonee5aa7b2009-09-09 15:03:13 -0600502 * Output one character with OPOST processing.
503 * Returns -1 when the output device is full and the character
504 * must be retried.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700505 *
Joe Petersona88a69c2009-01-02 13:40:53 +0000506 * Locking: output_lock to protect column state and space left
507 * (also, this is called from n_tty_write under the
508 * tty layer write lock)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700509 */
Alan Cox4edf1822008-02-08 04:18:44 -0800510
Joe Petersona88a69c2009-01-02 13:40:53 +0000511static int process_output(unsigned char c, struct tty_struct *tty)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700512{
Jiri Slabybddc7152012-10-18 22:26:42 +0200513 struct n_tty_data *ldata = tty->disc_data;
Joe Petersona88a69c2009-01-02 13:40:53 +0000514 int space, retval;
515
Jiri Slabybddc7152012-10-18 22:26:42 +0200516 mutex_lock(&ldata->output_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700517
Alan Coxf34d7a52008-04-30 00:54:13 -0700518 space = tty_write_room(tty);
Joe Petersona88a69c2009-01-02 13:40:53 +0000519 retval = do_output_char(c, tty, space);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700520
Jiri Slabybddc7152012-10-18 22:26:42 +0200521 mutex_unlock(&ldata->output_lock);
Joe Petersona88a69c2009-01-02 13:40:53 +0000522 if (retval < 0)
523 return -1;
524 else
525 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700526}
527
528/**
Joe Petersona88a69c2009-01-02 13:40:53 +0000529 * process_output_block - block post processor
Linus Torvalds1da177e2005-04-16 15:20:36 -0700530 * @tty: terminal device
Joe Petersonee5aa7b2009-09-09 15:03:13 -0600531 * @buf: character buffer
532 * @nr: number of bytes to output
533 *
534 * Output a block of characters with OPOST processing.
535 * Returns the number of characters output.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700536 *
537 * This path is used to speed up block console writes, among other
538 * things when processing blocks of output data. It handles only
539 * the simple cases normally found and helps to generate blocks of
540 * symbols for the console driver and thus improve performance.
541 *
Joe Petersona88a69c2009-01-02 13:40:53 +0000542 * Locking: output_lock to protect column state and space left
543 * (also, this is called from n_tty_write under the
544 * tty layer write lock)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700545 */
Alan Cox4edf1822008-02-08 04:18:44 -0800546
Joe Petersona88a69c2009-01-02 13:40:53 +0000547static ssize_t process_output_block(struct tty_struct *tty,
548 const unsigned char *buf, unsigned int nr)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700549{
Jiri Slaby53c5ee22012-10-18 22:26:39 +0200550 struct n_tty_data *ldata = tty->disc_data;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700551 int space;
Thorsten Wißmannbbd20752011-12-08 17:47:33 +0100552 int i;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700553 const unsigned char *cp;
554
Jiri Slabybddc7152012-10-18 22:26:42 +0200555 mutex_lock(&ldata->output_lock);
Joe Petersona88a69c2009-01-02 13:40:53 +0000556
Alan Coxf34d7a52008-04-30 00:54:13 -0700557 space = tty_write_room(tty);
Alan Cox300a6202009-01-02 13:41:04 +0000558 if (!space) {
Jiri Slabybddc7152012-10-18 22:26:42 +0200559 mutex_unlock(&ldata->output_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700560 return 0;
Joe Petersona88a69c2009-01-02 13:40:53 +0000561 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700562 if (nr > space)
563 nr = space;
564
565 for (i = 0, cp = buf; i < nr; i++, cp++) {
Joe Petersona59c0d62009-01-02 13:43:25 +0000566 unsigned char c = *cp;
567
568 switch (c) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700569 case '\n':
570 if (O_ONLRET(tty))
Jiri Slaby53c5ee22012-10-18 22:26:39 +0200571 ldata->column = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700572 if (O_ONLCR(tty))
573 goto break_out;
Jiri Slabyba2e68a2012-10-18 22:26:41 +0200574 ldata->canon_column = ldata->column;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700575 break;
576 case '\r':
Jiri Slaby53c5ee22012-10-18 22:26:39 +0200577 if (O_ONOCR(tty) && ldata->column == 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700578 goto break_out;
579 if (O_OCRNL(tty))
580 goto break_out;
Jiri Slabyba2e68a2012-10-18 22:26:41 +0200581 ldata->canon_column = ldata->column = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700582 break;
583 case '\t':
584 goto break_out;
585 case '\b':
Jiri Slaby53c5ee22012-10-18 22:26:39 +0200586 if (ldata->column > 0)
587 ldata->column--;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700588 break;
589 default:
Joe Petersona59c0d62009-01-02 13:43:25 +0000590 if (!iscntrl(c)) {
591 if (O_OLCUC(tty))
592 goto break_out;
593 if (!is_continuation(c, tty))
Jiri Slaby53c5ee22012-10-18 22:26:39 +0200594 ldata->column++;
Joe Petersona59c0d62009-01-02 13:43:25 +0000595 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700596 break;
597 }
598 }
599break_out:
Alan Coxf34d7a52008-04-30 00:54:13 -0700600 i = tty->ops->write(tty, buf, i);
Joe Petersona88a69c2009-01-02 13:40:53 +0000601
Jiri Slabybddc7152012-10-18 22:26:42 +0200602 mutex_unlock(&ldata->output_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700603 return i;
604}
605
Joe Petersona88a69c2009-01-02 13:40:53 +0000606/**
607 * process_echoes - write pending echo characters
608 * @tty: terminal device
609 *
610 * Write previously buffered echo (and other ldisc-generated)
611 * characters to the tty.
612 *
613 * Characters generated by the ldisc (including echoes) need to
614 * be buffered because the driver's write buffer can fill during
615 * heavy program output. Echoing straight to the driver will
616 * often fail under these conditions, causing lost characters and
617 * resulting mismatches of ldisc state information.
618 *
619 * Since the ldisc state must represent the characters actually sent
620 * to the driver at the time of the write, operations like certain
621 * changes in column state are also saved in the buffer and executed
622 * here.
623 *
624 * A circular fifo buffer is used so that the most recent characters
625 * are prioritized. Also, when control characters are echoed with a
626 * prefixed "^", the pair is treated atomically and thus not separated.
627 *
Peter Hurley019ebdf2013-06-15 10:04:25 -0400628 * Locking: callers must hold output_lock
Joe Petersona88a69c2009-01-02 13:40:53 +0000629 */
630
Peter Hurleybc5b1ec2013-06-15 10:04:27 -0400631static size_t __process_echoes(struct tty_struct *tty)
Joe Petersona88a69c2009-01-02 13:40:53 +0000632{
Jiri Slaby53c5ee22012-10-18 22:26:39 +0200633 struct n_tty_data *ldata = tty->disc_data;
Peter Hurleybc5b1ec2013-06-15 10:04:27 -0400634 int space, old_space;
Peter Hurleyaddaebc2013-06-15 10:04:22 -0400635 size_t tail;
Joe Petersona88a69c2009-01-02 13:40:53 +0000636 unsigned char c;
Joe Petersona88a69c2009-01-02 13:40:53 +0000637
Peter Hurleybc5b1ec2013-06-15 10:04:27 -0400638 old_space = space = tty_write_room(tty);
Joe Petersona88a69c2009-01-02 13:40:53 +0000639
Peter Hurleyaddaebc2013-06-15 10:04:22 -0400640 tail = ldata->echo_tail;
Peter Hurley29c7c5c2013-06-15 10:04:28 -0400641 while (ldata->echo_commit != tail) {
Peter Hurleyaddaebc2013-06-15 10:04:22 -0400642 c = echo_buf(ldata, tail);
Joe Petersona88a69c2009-01-02 13:40:53 +0000643 if (c == ECHO_OP_START) {
644 unsigned char op;
Joe Petersona88a69c2009-01-02 13:40:53 +0000645 int no_space_left = 0;
646
647 /*
648 * If the buffer byte is the start of a multi-byte
649 * operation, get the next byte, which is either the
650 * op code or a control character value.
651 */
Peter Hurleyaddaebc2013-06-15 10:04:22 -0400652 op = echo_buf(ldata, tail + 1);
Alan Cox300a6202009-01-02 13:41:04 +0000653
Joe Petersona88a69c2009-01-02 13:40:53 +0000654 switch (op) {
655 unsigned int num_chars, num_bs;
656
657 case ECHO_OP_ERASE_TAB:
Peter Hurleyaddaebc2013-06-15 10:04:22 -0400658 num_chars = echo_buf(ldata, tail + 2);
Joe Petersona88a69c2009-01-02 13:40:53 +0000659
660 /*
661 * Determine how many columns to go back
662 * in order to erase the tab.
663 * This depends on the number of columns
664 * used by other characters within the tab
665 * area. If this (modulo 8) count is from
666 * the start of input rather than from a
667 * previous tab, we offset by canon column.
668 * Otherwise, tab spacing is normal.
669 */
670 if (!(num_chars & 0x80))
Jiri Slabyba2e68a2012-10-18 22:26:41 +0200671 num_chars += ldata->canon_column;
Joe Petersona88a69c2009-01-02 13:40:53 +0000672 num_bs = 8 - (num_chars & 7);
673
674 if (num_bs > space) {
675 no_space_left = 1;
676 break;
677 }
678 space -= num_bs;
679 while (num_bs--) {
680 tty_put_char(tty, '\b');
Jiri Slaby53c5ee22012-10-18 22:26:39 +0200681 if (ldata->column > 0)
682 ldata->column--;
Joe Petersona88a69c2009-01-02 13:40:53 +0000683 }
Peter Hurleyaddaebc2013-06-15 10:04:22 -0400684 tail += 3;
Joe Petersona88a69c2009-01-02 13:40:53 +0000685 break;
686
687 case ECHO_OP_SET_CANON_COL:
Jiri Slabyba2e68a2012-10-18 22:26:41 +0200688 ldata->canon_column = ldata->column;
Peter Hurleyaddaebc2013-06-15 10:04:22 -0400689 tail += 2;
Joe Petersona88a69c2009-01-02 13:40:53 +0000690 break;
691
692 case ECHO_OP_MOVE_BACK_COL:
Jiri Slaby53c5ee22012-10-18 22:26:39 +0200693 if (ldata->column > 0)
694 ldata->column--;
Peter Hurleyaddaebc2013-06-15 10:04:22 -0400695 tail += 2;
Joe Petersona88a69c2009-01-02 13:40:53 +0000696 break;
697
698 case ECHO_OP_START:
699 /* This is an escaped echo op start code */
700 if (!space) {
701 no_space_left = 1;
702 break;
703 }
704 tty_put_char(tty, ECHO_OP_START);
Jiri Slaby53c5ee22012-10-18 22:26:39 +0200705 ldata->column++;
Joe Petersona88a69c2009-01-02 13:40:53 +0000706 space--;
Peter Hurleyaddaebc2013-06-15 10:04:22 -0400707 tail += 2;
Joe Petersona88a69c2009-01-02 13:40:53 +0000708 break;
709
710 default:
Joe Petersona88a69c2009-01-02 13:40:53 +0000711 /*
Joe Peterson62b26352009-09-09 15:03:47 -0600712 * If the op is not a special byte code,
713 * it is a ctrl char tagged to be echoed
714 * as "^X" (where X is the letter
715 * representing the control char).
716 * Note that we must ensure there is
717 * enough space for the whole ctrl pair.
718 *
Joe Petersona88a69c2009-01-02 13:40:53 +0000719 */
Joe Peterson62b26352009-09-09 15:03:47 -0600720 if (space < 2) {
721 no_space_left = 1;
722 break;
723 }
724 tty_put_char(tty, '^');
725 tty_put_char(tty, op ^ 0100);
Jiri Slaby53c5ee22012-10-18 22:26:39 +0200726 ldata->column += 2;
Joe Peterson62b26352009-09-09 15:03:47 -0600727 space -= 2;
Peter Hurleyaddaebc2013-06-15 10:04:22 -0400728 tail += 2;
Joe Petersona88a69c2009-01-02 13:40:53 +0000729 }
730
731 if (no_space_left)
732 break;
733 } else {
Peter Hurley582f5592013-05-17 12:49:48 -0400734 if (O_OPOST(tty)) {
Joe Petersonee5aa7b2009-09-09 15:03:13 -0600735 int retval = do_output_char(c, tty, space);
736 if (retval < 0)
737 break;
738 space -= retval;
739 } else {
740 if (!space)
741 break;
742 tty_put_char(tty, c);
743 space -= 1;
744 }
Peter Hurleyaddaebc2013-06-15 10:04:22 -0400745 tail += 1;
Joe Petersona88a69c2009-01-02 13:40:53 +0000746 }
Joe Petersona88a69c2009-01-02 13:40:53 +0000747 }
748
Peter Hurleycbfd0342013-06-15 10:04:26 -0400749 /* If the echo buffer is nearly full (so that the possibility exists
750 * of echo overrun before the next commit), then discard enough
751 * data at the tail to prevent a subsequent overrun */
752 while (ldata->echo_commit - tail >= ECHO_DISCARD_WATERMARK) {
Roel Kluinc476f652013-10-11 22:08:49 +0200753 if (echo_buf(ldata, tail) == ECHO_OP_START) {
Peter Hurley6f222532013-11-08 09:42:18 -0500754 if (echo_buf(ldata, tail + 1) == ECHO_OP_ERASE_TAB)
Peter Hurleycbfd0342013-06-15 10:04:26 -0400755 tail += 3;
756 else
757 tail += 2;
758 } else
759 tail++;
760 }
761
Peter Hurleyaddaebc2013-06-15 10:04:22 -0400762 ldata->echo_tail = tail;
Peter Hurleybc5b1ec2013-06-15 10:04:27 -0400763 return old_space - space;
Joe Petersona88a69c2009-01-02 13:40:53 +0000764}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700765
Peter Hurley17bd7902013-06-15 10:04:24 -0400766static void commit_echoes(struct tty_struct *tty)
767{
768 struct n_tty_data *ldata = tty->disc_data;
Peter Hurleybc5b1ec2013-06-15 10:04:27 -0400769 size_t nr, old, echoed;
Peter Hurleycbfd0342013-06-15 10:04:26 -0400770 size_t head;
771
772 head = ldata->echo_head;
Peter Hurley1075a6e2013-12-09 18:06:07 -0500773 ldata->echo_mark = head;
Peter Hurleycbfd0342013-06-15 10:04:26 -0400774 old = ldata->echo_commit - ldata->echo_tail;
775
776 /* Process committed echoes if the accumulated # of bytes
777 * is over the threshold (and try again each time another
778 * block is accumulated) */
779 nr = head - ldata->echo_tail;
780 if (nr < ECHO_COMMIT_WATERMARK || (nr % ECHO_BLOCK > old % ECHO_BLOCK))
781 return;
Peter Hurley17bd7902013-06-15 10:04:24 -0400782
Peter Hurley019ebdf2013-06-15 10:04:25 -0400783 mutex_lock(&ldata->output_lock);
Peter Hurleycbfd0342013-06-15 10:04:26 -0400784 ldata->echo_commit = head;
Peter Hurleybc5b1ec2013-06-15 10:04:27 -0400785 echoed = __process_echoes(tty);
Peter Hurley019ebdf2013-06-15 10:04:25 -0400786 mutex_unlock(&ldata->output_lock);
787
Peter Hurleybc5b1ec2013-06-15 10:04:27 -0400788 if (echoed && tty->ops->flush_chars)
Peter Hurley019ebdf2013-06-15 10:04:25 -0400789 tty->ops->flush_chars(tty);
790}
791
792static void process_echoes(struct tty_struct *tty)
793{
794 struct n_tty_data *ldata = tty->disc_data;
Peter Hurleybc5b1ec2013-06-15 10:04:27 -0400795 size_t echoed;
Peter Hurley019ebdf2013-06-15 10:04:25 -0400796
Peter Hurleye2613be2014-02-11 16:34:55 -0500797 if (ldata->echo_mark == ldata->echo_tail)
Peter Hurley019ebdf2013-06-15 10:04:25 -0400798 return;
799
800 mutex_lock(&ldata->output_lock);
Peter Hurley1075a6e2013-12-09 18:06:07 -0500801 ldata->echo_commit = ldata->echo_mark;
Peter Hurleybc5b1ec2013-06-15 10:04:27 -0400802 echoed = __process_echoes(tty);
Peter Hurley019ebdf2013-06-15 10:04:25 -0400803 mutex_unlock(&ldata->output_lock);
804
Peter Hurleybc5b1ec2013-06-15 10:04:27 -0400805 if (echoed && tty->ops->flush_chars)
Peter Hurley019ebdf2013-06-15 10:04:25 -0400806 tty->ops->flush_chars(tty);
Peter Hurley17bd7902013-06-15 10:04:24 -0400807}
808
Peter Hurley1075a6e2013-12-09 18:06:07 -0500809/* NB: echo_mark and echo_head should be equivalent here */
Peter Hurleycbfd0342013-06-15 10:04:26 -0400810static void flush_echoes(struct tty_struct *tty)
811{
812 struct n_tty_data *ldata = tty->disc_data;
813
Peter Hurley39434ab2013-11-29 12:56:10 -0500814 if ((!L_ECHO(tty) && !L_ECHONL(tty)) ||
815 ldata->echo_commit == ldata->echo_head)
Peter Hurleycbfd0342013-06-15 10:04:26 -0400816 return;
817
818 mutex_lock(&ldata->output_lock);
819 ldata->echo_commit = ldata->echo_head;
820 __process_echoes(tty);
821 mutex_unlock(&ldata->output_lock);
822}
823
Linus Torvalds1da177e2005-04-16 15:20:36 -0700824/**
Joe Petersona88a69c2009-01-02 13:40:53 +0000825 * add_echo_byte - add a byte to the echo buffer
826 * @c: unicode byte to echo
Jiri Slaby57c94122012-10-18 22:26:43 +0200827 * @ldata: n_tty data
Joe Petersona88a69c2009-01-02 13:40:53 +0000828 *
829 * Add a character or operation byte to the echo buffer.
Joe Petersona88a69c2009-01-02 13:40:53 +0000830 */
831
Peter Hurleycbfd0342013-06-15 10:04:26 -0400832static inline void add_echo_byte(unsigned char c, struct n_tty_data *ldata)
Joe Petersona88a69c2009-01-02 13:40:53 +0000833{
Peter Hurleyaddaebc2013-06-15 10:04:22 -0400834 *echo_buf_addr(ldata, ldata->echo_head++) = c;
Joe Petersona88a69c2009-01-02 13:40:53 +0000835}
836
837/**
838 * echo_move_back_col - add operation to move back a column
Jiri Slaby57c94122012-10-18 22:26:43 +0200839 * @ldata: n_tty data
Joe Petersona88a69c2009-01-02 13:40:53 +0000840 *
841 * Add an operation to the echo buffer to move back one column.
Joe Petersona88a69c2009-01-02 13:40:53 +0000842 */
843
Jiri Slaby57c94122012-10-18 22:26:43 +0200844static void echo_move_back_col(struct n_tty_data *ldata)
Joe Petersona88a69c2009-01-02 13:40:53 +0000845{
Jiri Slaby57c94122012-10-18 22:26:43 +0200846 add_echo_byte(ECHO_OP_START, ldata);
847 add_echo_byte(ECHO_OP_MOVE_BACK_COL, ldata);
Joe Petersona88a69c2009-01-02 13:40:53 +0000848}
849
850/**
851 * echo_set_canon_col - add operation to set the canon column
Jiri Slaby57c94122012-10-18 22:26:43 +0200852 * @ldata: n_tty data
Joe Petersona88a69c2009-01-02 13:40:53 +0000853 *
854 * Add an operation to the echo buffer to set the canon column
855 * to the current column.
Joe Petersona88a69c2009-01-02 13:40:53 +0000856 */
857
Jiri Slaby57c94122012-10-18 22:26:43 +0200858static void echo_set_canon_col(struct n_tty_data *ldata)
Joe Petersona88a69c2009-01-02 13:40:53 +0000859{
Jiri Slaby57c94122012-10-18 22:26:43 +0200860 add_echo_byte(ECHO_OP_START, ldata);
861 add_echo_byte(ECHO_OP_SET_CANON_COL, ldata);
Joe Petersona88a69c2009-01-02 13:40:53 +0000862}
863
864/**
865 * echo_erase_tab - add operation to erase a tab
866 * @num_chars: number of character columns already used
867 * @after_tab: true if num_chars starts after a previous tab
Jiri Slaby57c94122012-10-18 22:26:43 +0200868 * @ldata: n_tty data
Joe Petersona88a69c2009-01-02 13:40:53 +0000869 *
870 * Add an operation to the echo buffer to erase a tab.
871 *
872 * Called by the eraser function, which knows how many character
873 * columns have been used since either a previous tab or the start
874 * of input. This information will be used later, along with
875 * canon column (if applicable), to go back the correct number
876 * of columns.
Joe Petersona88a69c2009-01-02 13:40:53 +0000877 */
878
879static void echo_erase_tab(unsigned int num_chars, int after_tab,
Jiri Slaby57c94122012-10-18 22:26:43 +0200880 struct n_tty_data *ldata)
Joe Petersona88a69c2009-01-02 13:40:53 +0000881{
Jiri Slaby57c94122012-10-18 22:26:43 +0200882 add_echo_byte(ECHO_OP_START, ldata);
883 add_echo_byte(ECHO_OP_ERASE_TAB, ldata);
Joe Petersona88a69c2009-01-02 13:40:53 +0000884
885 /* We only need to know this modulo 8 (tab spacing) */
886 num_chars &= 7;
887
888 /* Set the high bit as a flag if num_chars is after a previous tab */
889 if (after_tab)
890 num_chars |= 0x80;
Alan Cox300a6202009-01-02 13:41:04 +0000891
Jiri Slaby57c94122012-10-18 22:26:43 +0200892 add_echo_byte(num_chars, ldata);
Joe Petersona88a69c2009-01-02 13:40:53 +0000893}
894
895/**
896 * echo_char_raw - echo a character raw
Linus Torvalds1da177e2005-04-16 15:20:36 -0700897 * @c: unicode byte to echo
898 * @tty: terminal device
899 *
Alan Cox4edf1822008-02-08 04:18:44 -0800900 * Echo user input back onto the screen. This must be called only when
Linus Torvalds1da177e2005-04-16 15:20:36 -0700901 * L_ECHO(tty) is true. Called from the driver receive_buf path.
Alan Cox17b82062008-10-13 10:45:06 +0100902 *
Joe Petersona88a69c2009-01-02 13:40:53 +0000903 * This variant does not treat control characters specially.
Joe Petersona88a69c2009-01-02 13:40:53 +0000904 */
905
Jiri Slaby57c94122012-10-18 22:26:43 +0200906static void echo_char_raw(unsigned char c, struct n_tty_data *ldata)
Joe Petersona88a69c2009-01-02 13:40:53 +0000907{
Joe Petersona88a69c2009-01-02 13:40:53 +0000908 if (c == ECHO_OP_START) {
Jiri Slaby57c94122012-10-18 22:26:43 +0200909 add_echo_byte(ECHO_OP_START, ldata);
910 add_echo_byte(ECHO_OP_START, ldata);
Joe Petersona88a69c2009-01-02 13:40:53 +0000911 } else {
Jiri Slaby57c94122012-10-18 22:26:43 +0200912 add_echo_byte(c, ldata);
Joe Petersona88a69c2009-01-02 13:40:53 +0000913 }
Joe Petersona88a69c2009-01-02 13:40:53 +0000914}
915
916/**
917 * echo_char - echo a character
918 * @c: unicode byte to echo
919 * @tty: terminal device
920 *
921 * Echo user input back onto the screen. This must be called only when
922 * L_ECHO(tty) is true. Called from the driver receive_buf path.
923 *
Joe Peterson62b26352009-09-09 15:03:47 -0600924 * This variant tags control characters to be echoed as "^X"
925 * (where X is the letter representing the control char).
Linus Torvalds1da177e2005-04-16 15:20:36 -0700926 */
927
928static void echo_char(unsigned char c, struct tty_struct *tty)
929{
Jiri Slabybddc7152012-10-18 22:26:42 +0200930 struct n_tty_data *ldata = tty->disc_data;
931
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 {
Joe Peterson62b26352009-09-09 15:03:47 -0600936 if (L_ECHOCTL(tty) && iscntrl(c) && c != '\t')
Jiri Slaby57c94122012-10-18 22:26:43 +0200937 add_echo_byte(ECHO_OP_START, ldata);
938 add_echo_byte(c, ldata);
Joe Petersona88a69c2009-01-02 13:40:53 +0000939 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700940}
941
Alan Cox17b82062008-10-13 10:45:06 +0100942/**
Joe Petersona88a69c2009-01-02 13:40:53 +0000943 * finish_erasing - complete erase
Jiri Slaby57c94122012-10-18 22:26:43 +0200944 * @ldata: n_tty data
Alan Cox17b82062008-10-13 10:45:06 +0100945 */
Joe Petersona88a69c2009-01-02 13:40:53 +0000946
Jiri Slaby57c94122012-10-18 22:26:43 +0200947static inline void finish_erasing(struct n_tty_data *ldata)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700948{
Jiri Slaby53c5ee22012-10-18 22:26:39 +0200949 if (ldata->erasing) {
Jiri Slaby57c94122012-10-18 22:26:43 +0200950 echo_char_raw('/', ldata);
Jiri Slaby53c5ee22012-10-18 22:26:39 +0200951 ldata->erasing = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700952 }
953}
954
955/**
956 * eraser - handle erase function
957 * @c: character input
958 * @tty: terminal device
959 *
Robert P. J. Day3a4fa0a2007-10-19 23:10:43 +0200960 * Perform erase and necessary output when an erase character is
Linus Torvalds1da177e2005-04-16 15:20:36 -0700961 * present in the stream from the driver layer. Handles the complexities
962 * of UTF-8 multibyte symbols.
Alan Cox17b82062008-10-13 10:45:06 +0100963 *
Peter Hurley6d76bd22013-06-15 09:14:26 -0400964 * n_tty_receive_buf()/producer path:
965 * caller holds non-exclusive termios_rwsem
Linus Torvalds1da177e2005-04-16 15:20:36 -0700966 */
Alan Cox4edf1822008-02-08 04:18:44 -0800967
Linus Torvalds1da177e2005-04-16 15:20:36 -0700968static void eraser(unsigned char c, struct tty_struct *tty)
969{
Jiri Slaby53c5ee22012-10-18 22:26:39 +0200970 struct n_tty_data *ldata = tty->disc_data;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700971 enum { ERASE, WERASE, KILL } kill_type;
Peter Hurleybc5a5e32013-06-15 09:14:21 -0400972 size_t head;
973 size_t cnt;
974 int seen_alnums;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700975
Jiri Slabyba2e68a2012-10-18 22:26:41 +0200976 if (ldata->read_head == ldata->canon_head) {
Joe Peterson7e94b1d2009-01-02 13:43:40 +0000977 /* process_output('\a', tty); */ /* what do you think? */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700978 return;
979 }
980 if (c == ERASE_CHAR(tty))
981 kill_type = ERASE;
982 else if (c == WERASE_CHAR(tty))
983 kill_type = WERASE;
984 else {
985 if (!L_ECHO(tty)) {
Jiri Slabyba2e68a2012-10-18 22:26:41 +0200986 ldata->read_head = ldata->canon_head;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700987 return;
988 }
989 if (!L_ECHOK(tty) || !L_ECHOKE(tty) || !L_ECHOE(tty)) {
Jiri Slabyba2e68a2012-10-18 22:26:41 +0200990 ldata->read_head = ldata->canon_head;
Jiri Slaby57c94122012-10-18 22:26:43 +0200991 finish_erasing(ldata);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700992 echo_char(KILL_CHAR(tty), tty);
993 /* Add a newline if ECHOK is on and ECHOKE is off. */
994 if (L_ECHOK(tty))
Jiri Slaby57c94122012-10-18 22:26:43 +0200995 echo_char_raw('\n', ldata);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700996 return;
997 }
998 kill_type = KILL;
999 }
1000
1001 seen_alnums = 0;
Jiri Slabyba2e68a2012-10-18 22:26:41 +02001002 while (ldata->read_head != ldata->canon_head) {
1003 head = ldata->read_head;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001004
1005 /* erase a single possibly multibyte character */
1006 do {
Peter Hurleybc5a5e32013-06-15 09:14:21 -04001007 head--;
1008 c = read_buf(ldata, head);
Jiri Slabyba2e68a2012-10-18 22:26:41 +02001009 } while (is_continuation(c, tty) && head != ldata->canon_head);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001010
1011 /* do not partially erase */
1012 if (is_continuation(c, tty))
1013 break;
1014
1015 if (kill_type == WERASE) {
1016 /* Equivalent to BSD's ALTWERASE. */
1017 if (isalnum(c) || c == '_')
1018 seen_alnums++;
1019 else if (seen_alnums)
1020 break;
1021 }
Peter Hurleybc5a5e32013-06-15 09:14:21 -04001022 cnt = ldata->read_head - head;
Jiri Slabyba2e68a2012-10-18 22:26:41 +02001023 ldata->read_head = head;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001024 if (L_ECHO(tty)) {
1025 if (L_ECHOPRT(tty)) {
Jiri Slaby53c5ee22012-10-18 22:26:39 +02001026 if (!ldata->erasing) {
Jiri Slaby57c94122012-10-18 22:26:43 +02001027 echo_char_raw('\\', ldata);
Jiri Slaby53c5ee22012-10-18 22:26:39 +02001028 ldata->erasing = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001029 }
1030 /* if cnt > 1, output a multi-byte character */
1031 echo_char(c, tty);
1032 while (--cnt > 0) {
Peter Hurleybc5a5e32013-06-15 09:14:21 -04001033 head++;
1034 echo_char_raw(read_buf(ldata, head), ldata);
Jiri Slaby57c94122012-10-18 22:26:43 +02001035 echo_move_back_col(ldata);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001036 }
1037 } else if (kill_type == ERASE && !L_ECHOE(tty)) {
1038 echo_char(ERASE_CHAR(tty), tty);
1039 } else if (c == '\t') {
Joe Petersona88a69c2009-01-02 13:40:53 +00001040 unsigned int num_chars = 0;
1041 int after_tab = 0;
Peter Hurleybc5a5e32013-06-15 09:14:21 -04001042 size_t tail = ldata->read_head;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001043
Joe Petersona88a69c2009-01-02 13:40:53 +00001044 /*
1045 * Count the columns used for characters
1046 * since the start of input or after a
1047 * previous tab.
1048 * This info is used to go back the correct
1049 * number of columns.
1050 */
Jiri Slabyba2e68a2012-10-18 22:26:41 +02001051 while (tail != ldata->canon_head) {
Peter Hurleybc5a5e32013-06-15 09:14:21 -04001052 tail--;
1053 c = read_buf(ldata, tail);
Joe Petersona88a69c2009-01-02 13:40:53 +00001054 if (c == '\t') {
1055 after_tab = 1;
1056 break;
Alan Cox300a6202009-01-02 13:41:04 +00001057 } else if (iscntrl(c)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001058 if (L_ECHOCTL(tty))
Joe Petersona88a69c2009-01-02 13:40:53 +00001059 num_chars += 2;
1060 } else if (!is_continuation(c, tty)) {
1061 num_chars++;
1062 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001063 }
Jiri Slaby57c94122012-10-18 22:26:43 +02001064 echo_erase_tab(num_chars, after_tab, ldata);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001065 } else {
1066 if (iscntrl(c) && L_ECHOCTL(tty)) {
Jiri Slaby57c94122012-10-18 22:26:43 +02001067 echo_char_raw('\b', ldata);
1068 echo_char_raw(' ', ldata);
1069 echo_char_raw('\b', ldata);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001070 }
1071 if (!iscntrl(c) || L_ECHOCTL(tty)) {
Jiri Slaby57c94122012-10-18 22:26:43 +02001072 echo_char_raw('\b', ldata);
1073 echo_char_raw(' ', ldata);
1074 echo_char_raw('\b', ldata);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001075 }
1076 }
1077 }
1078 if (kill_type == ERASE)
1079 break;
1080 }
Jiri Slabyba2e68a2012-10-18 22:26:41 +02001081 if (ldata->read_head == ldata->canon_head && L_ECHO(tty))
Jiri Slaby57c94122012-10-18 22:26:43 +02001082 finish_erasing(ldata);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001083}
1084
1085/**
1086 * isig - handle the ISIG optio
1087 * @sig: signal
1088 * @tty: terminal
Linus Torvalds1da177e2005-04-16 15:20:36 -07001089 *
Peter Hurley8c985d12013-03-06 08:38:19 -05001090 * Called when a signal is being sent due to terminal input.
1091 * Called from the driver receive_buf path so serialized.
Alan Cox17b82062008-10-13 10:45:06 +01001092 *
Peter Hurleyd2b6f442015-01-17 15:42:06 -05001093 * Performs input and output flush if !NOFLSH. In this context, the echo
1094 * buffer is 'output'. The signal is processed first to alert any current
1095 * readers or writers to discontinue and exit their i/o loops.
1096 *
Peter Hurley8c985d12013-03-06 08:38:19 -05001097 * Locking: ctrl_lock
Linus Torvalds1da177e2005-04-16 15:20:36 -07001098 */
Alan Cox4edf1822008-02-08 04:18:44 -08001099
Peter Hurley4b293492013-07-24 08:29:55 -04001100static void isig(int sig, struct tty_struct *tty)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001101{
Peter Hurleyd2b6f442015-01-17 15:42:06 -05001102 struct n_tty_data *ldata = tty->disc_data;
Peter Hurley8c985d12013-03-06 08:38:19 -05001103 struct pid *tty_pgrp = tty_get_pgrp(tty);
1104 if (tty_pgrp) {
1105 kill_pgrp(tty_pgrp, sig, 1);
1106 put_pid(tty_pgrp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001107 }
Peter Hurleyd2b6f442015-01-17 15:42:06 -05001108
1109 if (!L_NOFLSH(tty)) {
1110 up_read(&tty->termios_rwsem);
1111 down_write(&tty->termios_rwsem);
1112
1113 /* clear echo buffer */
1114 mutex_lock(&ldata->output_lock);
1115 ldata->echo_head = ldata->echo_tail = 0;
1116 ldata->echo_mark = ldata->echo_commit = 0;
1117 mutex_unlock(&ldata->output_lock);
1118
1119 /* clear output buffer */
1120 tty_driver_flush_buffer(tty);
1121
1122 /* clear input buffer */
1123 reset_buffer_flags(tty->disc_data);
1124
1125 /* notify pty master of flush */
1126 if (tty->link)
1127 n_tty_packet_mode_flush(tty);
1128
1129 up_write(&tty->termios_rwsem);
1130 down_read(&tty->termios_rwsem);
1131 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001132}
1133
1134/**
1135 * n_tty_receive_break - handle break
1136 * @tty: terminal
1137 *
1138 * An RS232 break event has been hit in the incoming bitstream. This
1139 * can cause a variety of events depending upon the termios settings.
1140 *
Peter Hurley6d76bd22013-06-15 09:14:26 -04001141 * n_tty_receive_buf()/producer path:
1142 * caller holds non-exclusive termios_rwsem
Peter Hurley6d76bd22013-06-15 09:14:26 -04001143 *
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);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001155 return;
1156 }
1157 if (I_PARMRK(tty)) {
Jiri Slaby57c94122012-10-18 22:26:43 +02001158 put_tty_queue('\377', ldata);
1159 put_tty_queue('\0', ldata);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001160 }
Jiri Slaby57c94122012-10-18 22:26:43 +02001161 put_tty_queue('\0', ldata);
Peter Hurley6c677162013-12-02 14:24:46 -05001162 if (waitqueue_active(&tty->read_wait))
Peter Hurley57087d52014-08-07 07:14:10 -04001163 wake_up_interruptible_poll(&tty->read_wait, POLLIN);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001164}
1165
1166/**
1167 * n_tty_receive_overrun - handle overrun reporting
1168 * @tty: terminal
1169 *
1170 * Data arrived faster than we could process it. While the tty
1171 * driver has flagged this the bits that were missed are gone
1172 * forever.
1173 *
1174 * Called from the receive_buf path so single threaded. Does not
1175 * need locking as num_overrun and overrun_time are function
1176 * private.
1177 */
Alan Cox4edf1822008-02-08 04:18:44 -08001178
Peter Hurley4b293492013-07-24 08:29:55 -04001179static void n_tty_receive_overrun(struct tty_struct *tty)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001180{
Jiri Slaby53c5ee22012-10-18 22:26:39 +02001181 struct n_tty_data *ldata = tty->disc_data;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001182 char buf[64];
1183
Jiri Slaby53c5ee22012-10-18 22:26:39 +02001184 ldata->num_overrun++;
1185 if (time_after(jiffies, ldata->overrun_time + HZ) ||
1186 time_after(ldata->overrun_time, jiffies)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001187 printk(KERN_WARNING "%s: %d input overrun(s)\n",
1188 tty_name(tty, buf),
Jiri Slaby53c5ee22012-10-18 22:26:39 +02001189 ldata->num_overrun);
1190 ldata->overrun_time = jiffies;
1191 ldata->num_overrun = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001192 }
1193}
1194
1195/**
1196 * n_tty_receive_parity_error - error notifier
1197 * @tty: terminal device
1198 * @c: character
1199 *
1200 * Process a parity error and queue the right data to indicate
Peter Hurley6d76bd22013-06-15 09:14:26 -04001201 * the error case if necessary.
1202 *
1203 * n_tty_receive_buf()/producer path:
1204 * caller holds non-exclusive termios_rwsem
Linus Torvalds1da177e2005-04-16 15:20:36 -07001205 */
Peter Hurley4b293492013-07-24 08:29:55 -04001206static void n_tty_receive_parity_error(struct tty_struct *tty, unsigned char c)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001207{
Jiri Slaby57c94122012-10-18 22:26:43 +02001208 struct n_tty_data *ldata = tty->disc_data;
1209
Peter Hurley66528f92014-06-16 08:10:42 -04001210 if (I_INPCK(tty)) {
1211 if (I_IGNPAR(tty))
1212 return;
1213 if (I_PARMRK(tty)) {
1214 put_tty_queue('\377', ldata);
1215 put_tty_queue('\0', ldata);
1216 put_tty_queue(c, ldata);
1217 } else
1218 put_tty_queue('\0', ldata);
1219 } else
Jiri Slaby57c94122012-10-18 22:26:43 +02001220 put_tty_queue(c, ldata);
Peter Hurley6c677162013-12-02 14:24:46 -05001221 if (waitqueue_active(&tty->read_wait))
Peter Hurley57087d52014-08-07 07:14:10 -04001222 wake_up_interruptible_poll(&tty->read_wait, POLLIN);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001223}
1224
Peter Hurleyb0ac50b2013-06-15 10:21:23 -04001225static void
1226n_tty_receive_signal_char(struct tty_struct *tty, int signal, unsigned char c)
1227{
Peter Hurleyd2b6f442015-01-17 15:42:06 -05001228 isig(signal, tty);
Peter Hurleyb0ac50b2013-06-15 10:21:23 -04001229 if (I_IXON(tty))
1230 start_tty(tty);
1231 if (L_ECHO(tty)) {
1232 echo_char(c, tty);
1233 commit_echoes(tty);
Peter Hurleye2613be2014-02-11 16:34:55 -05001234 } else
1235 process_echoes(tty);
Peter Hurleyb0ac50b2013-06-15 10:21:23 -04001236 return;
1237}
1238
Linus Torvalds1da177e2005-04-16 15:20:36 -07001239/**
1240 * n_tty_receive_char - perform processing
1241 * @tty: terminal device
1242 * @c: character
1243 *
1244 * Process an individual character of input received from the driver.
Alan Cox4edf1822008-02-08 04:18:44 -08001245 * This is serialized with respect to itself by the rules for the
Linus Torvalds1da177e2005-04-16 15:20:36 -07001246 * driver above.
Peter Hurley6d76bd22013-06-15 09:14:26 -04001247 *
1248 * n_tty_receive_buf()/producer path:
1249 * caller holds non-exclusive termios_rwsem
1250 * publishes canon_head if canonical mode is active
Peter Hurleye60d27c2013-07-24 08:29:56 -04001251 *
1252 * Returns 1 if LNEXT was received, else returns 0
Linus Torvalds1da177e2005-04-16 15:20:36 -07001253 */
1254
Peter Hurleye60d27c2013-07-24 08:29:56 -04001255static int
Peter Hurley4b1f79c2013-07-24 08:29:51 -04001256n_tty_receive_char_special(struct tty_struct *tty, unsigned char c)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001257{
Jiri Slaby53c5ee22012-10-18 22:26:39 +02001258 struct n_tty_data *ldata = tty->disc_data;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001259
Linus Torvalds1da177e2005-04-16 15:20:36 -07001260 if (I_IXON(tty)) {
1261 if (c == START_CHAR(tty)) {
1262 start_tty(tty);
Peter Hurleye2613be2014-02-11 16:34:55 -05001263 process_echoes(tty);
Peter Hurleye60d27c2013-07-24 08:29:56 -04001264 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001265 }
1266 if (c == STOP_CHAR(tty)) {
1267 stop_tty(tty);
Peter Hurleye60d27c2013-07-24 08:29:56 -04001268 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001269 }
1270 }
Joe Peterson575537b32008-04-30 00:53:30 -07001271
Linus Torvalds1da177e2005-04-16 15:20:36 -07001272 if (L_ISIG(tty)) {
Peter Hurleyb0ac50b2013-06-15 10:21:23 -04001273 if (c == INTR_CHAR(tty)) {
1274 n_tty_receive_signal_char(tty, SIGINT, c);
Peter Hurleye60d27c2013-07-24 08:29:56 -04001275 return 0;
Peter Hurleyb0ac50b2013-06-15 10:21:23 -04001276 } else if (c == QUIT_CHAR(tty)) {
1277 n_tty_receive_signal_char(tty, SIGQUIT, c);
Peter Hurleye60d27c2013-07-24 08:29:56 -04001278 return 0;
Peter Hurleyb0ac50b2013-06-15 10:21:23 -04001279 } else if (c == SUSP_CHAR(tty)) {
1280 n_tty_receive_signal_char(tty, SIGTSTP, c);
Peter Hurleye60d27c2013-07-24 08:29:56 -04001281 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001282 }
1283 }
Joe Peterson575537b32008-04-30 00:53:30 -07001284
Peter Hurley855df3c2013-07-24 08:29:50 -04001285 if (tty->stopped && !tty->flow_stopped && I_IXON(tty) && I_IXANY(tty)) {
1286 start_tty(tty);
1287 process_echoes(tty);
1288 }
1289
Joe Peterson575537b32008-04-30 00:53:30 -07001290 if (c == '\r') {
1291 if (I_IGNCR(tty))
Peter Hurleye60d27c2013-07-24 08:29:56 -04001292 return 0;
Joe Peterson575537b32008-04-30 00:53:30 -07001293 if (I_ICRNL(tty))
1294 c = '\n';
1295 } else if (c == '\n' && I_INLCR(tty))
1296 c = '\r';
1297
Jiri Slaby53c5ee22012-10-18 22:26:39 +02001298 if (ldata->icanon) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001299 if (c == ERASE_CHAR(tty) || c == KILL_CHAR(tty) ||
1300 (c == WERASE_CHAR(tty) && L_IEXTEN(tty))) {
1301 eraser(c, tty);
Peter Hurley17bd7902013-06-15 10:04:24 -04001302 commit_echoes(tty);
Peter Hurleye60d27c2013-07-24 08:29:56 -04001303 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001304 }
1305 if (c == LNEXT_CHAR(tty) && L_IEXTEN(tty)) {
Jiri Slaby53c5ee22012-10-18 22:26:39 +02001306 ldata->lnext = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001307 if (L_ECHO(tty)) {
Jiri Slaby57c94122012-10-18 22:26:43 +02001308 finish_erasing(ldata);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001309 if (L_ECHOCTL(tty)) {
Jiri Slaby57c94122012-10-18 22:26:43 +02001310 echo_char_raw('^', ldata);
1311 echo_char_raw('\b', ldata);
Peter Hurley17bd7902013-06-15 10:04:24 -04001312 commit_echoes(tty);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001313 }
1314 }
Peter Hurleye60d27c2013-07-24 08:29:56 -04001315 return 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001316 }
Peter Hurleye60d27c2013-07-24 08:29:56 -04001317 if (c == REPRINT_CHAR(tty) && L_ECHO(tty) && L_IEXTEN(tty)) {
Peter Hurleybc5a5e32013-06-15 09:14:21 -04001318 size_t tail = ldata->canon_head;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001319
Jiri Slaby57c94122012-10-18 22:26:43 +02001320 finish_erasing(ldata);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001321 echo_char(c, tty);
Jiri Slaby57c94122012-10-18 22:26:43 +02001322 echo_char_raw('\n', ldata);
Jiri Slabyba2e68a2012-10-18 22:26:41 +02001323 while (tail != ldata->read_head) {
Peter Hurleybc5a5e32013-06-15 09:14:21 -04001324 echo_char(read_buf(ldata, tail), tty);
1325 tail++;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001326 }
Peter Hurley17bd7902013-06-15 10:04:24 -04001327 commit_echoes(tty);
Peter Hurleye60d27c2013-07-24 08:29:56 -04001328 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001329 }
1330 if (c == '\n') {
Joe Petersonacc71bb2009-01-02 13:43:32 +00001331 if (L_ECHO(tty) || L_ECHONL(tty)) {
Jiri Slaby57c94122012-10-18 22:26:43 +02001332 echo_char_raw('\n', ldata);
Peter Hurley17bd7902013-06-15 10:04:24 -04001333 commit_echoes(tty);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001334 }
1335 goto handle_newline;
1336 }
1337 if (c == EOF_CHAR(tty)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001338 c = __DISABLED_CHAR;
1339 goto handle_newline;
1340 }
1341 if ((c == EOL_CHAR(tty)) ||
1342 (c == EOL2_CHAR(tty) && L_IEXTEN(tty))) {
1343 /*
1344 * XXX are EOL_CHAR and EOL2_CHAR echoed?!?
1345 */
1346 if (L_ECHO(tty)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001347 /* Record the column of first canon char. */
Jiri Slabyba2e68a2012-10-18 22:26:41 +02001348 if (ldata->canon_head == ldata->read_head)
Jiri Slaby57c94122012-10-18 22:26:43 +02001349 echo_set_canon_col(ldata);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001350 echo_char(c, tty);
Peter Hurley17bd7902013-06-15 10:04:24 -04001351 commit_echoes(tty);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001352 }
1353 /*
1354 * XXX does PARMRK doubling happen for
1355 * EOL_CHAR and EOL2_CHAR?
1356 */
Peter Hurley001ba922013-12-02 14:24:44 -05001357 if (c == (unsigned char) '\377' && I_PARMRK(tty))
Jiri Slaby57c94122012-10-18 22:26:43 +02001358 put_tty_queue(c, ldata);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001359
Alan Cox4edf1822008-02-08 04:18:44 -08001360handle_newline:
Peter Hurleybc5a5e32013-06-15 09:14:21 -04001361 set_bit(ldata->read_head & (N_TTY_BUF_SIZE - 1), ldata->read_flags);
Peter Hurley6d76bd22013-06-15 09:14:26 -04001362 put_tty_queue(c, ldata);
Peter Hurley70aca712015-01-16 15:05:37 -05001363 smp_store_release(&ldata->canon_head, ldata->read_head);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001364 kill_fasync(&tty->fasync, SIGIO, POLL_IN);
1365 if (waitqueue_active(&tty->read_wait))
Peter Hurley57087d52014-08-07 07:14:10 -04001366 wake_up_interruptible_poll(&tty->read_wait, POLLIN);
Peter Hurleye60d27c2013-07-24 08:29:56 -04001367 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001368 }
1369 }
Alan Cox4edf1822008-02-08 04:18:44 -08001370
Joe Petersonacc71bb2009-01-02 13:43:32 +00001371 if (L_ECHO(tty)) {
Jiri Slaby57c94122012-10-18 22:26:43 +02001372 finish_erasing(ldata);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001373 if (c == '\n')
Jiri Slaby57c94122012-10-18 22:26:43 +02001374 echo_char_raw('\n', ldata);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001375 else {
1376 /* Record the column of first canon char. */
Jiri Slabyba2e68a2012-10-18 22:26:41 +02001377 if (ldata->canon_head == ldata->read_head)
Jiri Slaby57c94122012-10-18 22:26:43 +02001378 echo_set_canon_col(ldata);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001379 echo_char(c, tty);
1380 }
Peter Hurley17bd7902013-06-15 10:04:24 -04001381 commit_echoes(tty);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001382 }
1383
Peter Hurley001ba922013-12-02 14:24:44 -05001384 /* PARMRK doubling check */
1385 if (c == (unsigned char) '\377' && I_PARMRK(tty))
Jiri Slaby57c94122012-10-18 22:26:43 +02001386 put_tty_queue(c, ldata);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001387
Jiri Slaby57c94122012-10-18 22:26:43 +02001388 put_tty_queue(c, ldata);
Peter Hurleye60d27c2013-07-24 08:29:56 -04001389 return 0;
Alan Cox4edf1822008-02-08 04:18:44 -08001390}
Linus Torvalds1da177e2005-04-16 15:20:36 -07001391
Peter Hurleye60d27c2013-07-24 08:29:56 -04001392static inline void
1393n_tty_receive_char_inline(struct tty_struct *tty, unsigned char c)
Peter Hurley4b1f79c2013-07-24 08:29:51 -04001394{
1395 struct n_tty_data *ldata = tty->disc_data;
Peter Hurley4b1f79c2013-07-24 08:29:51 -04001396
Peter Hurleye60d27c2013-07-24 08:29:56 -04001397 if (tty->stopped && !tty->flow_stopped && I_IXON(tty) && I_IXANY(tty)) {
1398 start_tty(tty);
1399 process_echoes(tty);
Peter Hurley4b1f79c2013-07-24 08:29:51 -04001400 }
Peter Hurleye60d27c2013-07-24 08:29:56 -04001401 if (L_ECHO(tty)) {
1402 finish_erasing(ldata);
1403 /* Record the column of first canon char. */
1404 if (ldata->canon_head == ldata->read_head)
1405 echo_set_canon_col(ldata);
1406 echo_char(c, tty);
1407 commit_echoes(tty);
1408 }
Peter Hurley001ba922013-12-02 14:24:44 -05001409 /* PARMRK doubling check */
1410 if (c == (unsigned char) '\377' && I_PARMRK(tty))
Peter Hurleye60d27c2013-07-24 08:29:56 -04001411 put_tty_queue(c, ldata);
1412 put_tty_queue(c, ldata);
1413}
Peter Hurley4b1f79c2013-07-24 08:29:51 -04001414
Peter Hurleyeb3e4662013-12-02 14:24:42 -05001415static void n_tty_receive_char(struct tty_struct *tty, unsigned char c)
Peter Hurleye60d27c2013-07-24 08:29:56 -04001416{
1417 n_tty_receive_char_inline(tty, c);
Peter Hurley4b1f79c2013-07-24 08:29:51 -04001418}
1419
Peter Hurleyad0cc7b2013-06-15 10:21:27 -04001420static inline void
Peter Hurley7de971b2013-07-24 08:29:53 -04001421n_tty_receive_char_fast(struct tty_struct *tty, unsigned char c)
1422{
1423 struct n_tty_data *ldata = tty->disc_data;
1424
Peter Hurleye60d27c2013-07-24 08:29:56 -04001425 if (tty->stopped && !tty->flow_stopped && I_IXON(tty) && I_IXANY(tty)) {
1426 start_tty(tty);
1427 process_echoes(tty);
Peter Hurley7de971b2013-07-24 08:29:53 -04001428 }
Peter Hurleye60d27c2013-07-24 08:29:56 -04001429 if (L_ECHO(tty)) {
1430 finish_erasing(ldata);
1431 /* Record the column of first canon char. */
1432 if (ldata->canon_head == ldata->read_head)
1433 echo_set_canon_col(ldata);
1434 echo_char(c, tty);
1435 commit_echoes(tty);
1436 }
1437 put_tty_queue(c, ldata);
Peter Hurley7de971b2013-07-24 08:29:53 -04001438}
1439
Peter Hurley8dc4b252013-12-02 14:24:43 -05001440static void n_tty_receive_char_closing(struct tty_struct *tty, unsigned char c)
Peter Hurleyad0cc7b2013-06-15 10:21:27 -04001441{
1442 if (I_ISTRIP(tty))
1443 c &= 0x7f;
1444 if (I_IUCLC(tty) && L_IEXTEN(tty))
1445 c = tolower(c);
1446
1447 if (I_IXON(tty)) {
1448 if (c == STOP_CHAR(tty))
1449 stop_tty(tty);
1450 else if (c == START_CHAR(tty) ||
1451 (tty->stopped && !tty->flow_stopped && I_IXANY(tty) &&
1452 c != INTR_CHAR(tty) && c != QUIT_CHAR(tty) &&
1453 c != SUSP_CHAR(tty))) {
1454 start_tty(tty);
1455 process_echoes(tty);
1456 }
1457 }
1458}
1459
Peter Hurleyd2f8d7a2013-06-15 10:21:24 -04001460static void
1461n_tty_receive_char_flagged(struct tty_struct *tty, unsigned char c, char flag)
1462{
1463 char buf[64];
1464
1465 switch (flag) {
1466 case TTY_BREAK:
1467 n_tty_receive_break(tty);
1468 break;
1469 case TTY_PARITY:
1470 case TTY_FRAME:
1471 n_tty_receive_parity_error(tty, c);
1472 break;
1473 case TTY_OVERRUN:
1474 n_tty_receive_overrun(tty);
1475 break;
1476 default:
1477 printk(KERN_ERR "%s: unknown flag %d\n",
1478 tty_name(tty, buf), flag);
1479 break;
1480 }
1481}
1482
Peter Hurleye60d27c2013-07-24 08:29:56 -04001483static void
1484n_tty_receive_char_lnext(struct tty_struct *tty, unsigned char c, char flag)
1485{
1486 struct n_tty_data *ldata = tty->disc_data;
1487
1488 ldata->lnext = 0;
1489 if (likely(flag == TTY_NORMAL)) {
1490 if (I_ISTRIP(tty))
1491 c &= 0x7f;
1492 if (I_IUCLC(tty) && L_IEXTEN(tty))
1493 c = tolower(c);
1494 n_tty_receive_char(tty, c);
1495 } else
1496 n_tty_receive_char_flagged(tty, c, flag);
1497}
1498
Peter Hurley4a23a4d2013-06-15 10:21:22 -04001499static void
1500n_tty_receive_buf_real_raw(struct tty_struct *tty, const unsigned char *cp,
1501 char *fp, int count)
1502{
1503 struct n_tty_data *ldata = tty->disc_data;
1504 size_t n, head;
1505
1506 head = ldata->read_head & (N_TTY_BUF_SIZE - 1);
Peter Hurley70aca712015-01-16 15:05:37 -05001507 n = min_t(size_t, count, N_TTY_BUF_SIZE - head);
Peter Hurley4a23a4d2013-06-15 10:21:22 -04001508 memcpy(read_buf_addr(ldata, head), cp, n);
1509 ldata->read_head += n;
1510 cp += n;
1511 count -= n;
1512
1513 head = ldata->read_head & (N_TTY_BUF_SIZE - 1);
Peter Hurley70aca712015-01-16 15:05:37 -05001514 n = min_t(size_t, count, N_TTY_BUF_SIZE - head);
Peter Hurley4a23a4d2013-06-15 10:21:22 -04001515 memcpy(read_buf_addr(ldata, head), cp, n);
1516 ldata->read_head += n;
1517}
1518
Peter Hurley554117b2013-06-15 10:21:25 -04001519static void
1520n_tty_receive_buf_raw(struct tty_struct *tty, const unsigned char *cp,
1521 char *fp, int count)
1522{
1523 struct n_tty_data *ldata = tty->disc_data;
1524 char flag = TTY_NORMAL;
1525
1526 while (count--) {
1527 if (fp)
1528 flag = *fp++;
1529 if (likely(flag == TTY_NORMAL))
1530 put_tty_queue(*cp++, ldata);
1531 else
1532 n_tty_receive_char_flagged(tty, *cp++, flag);
1533 }
1534}
1535
Peter Hurleyad0cc7b2013-06-15 10:21:27 -04001536static void
1537n_tty_receive_buf_closing(struct tty_struct *tty, const unsigned char *cp,
1538 char *fp, int count)
1539{
1540 char flag = TTY_NORMAL;
1541
1542 while (count--) {
1543 if (fp)
1544 flag = *fp++;
1545 if (likely(flag == TTY_NORMAL))
1546 n_tty_receive_char_closing(tty, *cp++);
1547 else
1548 n_tty_receive_char_flagged(tty, *cp++, flag);
1549 }
1550}
1551
Peter Hurley7d88d632013-07-24 08:29:49 -04001552static void
1553n_tty_receive_buf_standard(struct tty_struct *tty, const unsigned char *cp,
Peter Hurley6baad002013-07-24 08:29:52 -04001554 char *fp, int count)
1555{
1556 struct n_tty_data *ldata = tty->disc_data;
1557 char flag = TTY_NORMAL;
1558
1559 while (count--) {
1560 if (fp)
1561 flag = *fp++;
1562 if (likely(flag == TTY_NORMAL)) {
1563 unsigned char c = *cp++;
1564
1565 if (I_ISTRIP(tty))
1566 c &= 0x7f;
1567 if (I_IUCLC(tty) && L_IEXTEN(tty))
1568 c = tolower(c);
1569 if (L_EXTPROC(tty)) {
1570 put_tty_queue(c, ldata);
1571 continue;
1572 }
Peter Hurleye60d27c2013-07-24 08:29:56 -04001573 if (!test_bit(c, ldata->char_map))
1574 n_tty_receive_char_inline(tty, c);
1575 else if (n_tty_receive_char_special(tty, c) && count) {
1576 if (fp)
1577 flag = *fp++;
1578 n_tty_receive_char_lnext(tty, *cp++, flag);
1579 count--;
1580 }
Peter Hurley6baad002013-07-24 08:29:52 -04001581 } else
1582 n_tty_receive_char_flagged(tty, *cp++, flag);
1583 }
1584}
1585
1586static void
1587n_tty_receive_buf_fast(struct tty_struct *tty, const unsigned char *cp,
1588 char *fp, int count)
Peter Hurley7d88d632013-07-24 08:29:49 -04001589{
Peter Hurleye60d27c2013-07-24 08:29:56 -04001590 struct n_tty_data *ldata = tty->disc_data;
Peter Hurley7d88d632013-07-24 08:29:49 -04001591 char flag = TTY_NORMAL;
1592
1593 while (count--) {
1594 if (fp)
1595 flag = *fp++;
Peter Hurleye60d27c2013-07-24 08:29:56 -04001596 if (likely(flag == TTY_NORMAL)) {
1597 unsigned char c = *cp++;
1598
1599 if (!test_bit(c, ldata->char_map))
1600 n_tty_receive_char_fast(tty, c);
1601 else if (n_tty_receive_char_special(tty, c) && count) {
1602 if (fp)
1603 flag = *fp++;
1604 n_tty_receive_char_lnext(tty, *cp++, flag);
1605 count--;
1606 }
1607 } else
Peter Hurley7d88d632013-07-24 08:29:49 -04001608 n_tty_receive_char_flagged(tty, *cp++, flag);
1609 }
1610}
1611
Peter Hurley24a89d12013-06-15 09:14:15 -04001612static void __receive_buf(struct tty_struct *tty, const unsigned char *cp,
1613 char *fp, int count)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001614{
Jiri Slaby53c5ee22012-10-18 22:26:39 +02001615 struct n_tty_data *ldata = tty->disc_data;
Peter Hurleya1dd30e2013-06-15 10:21:26 -04001616 bool preops = I_ISTRIP(tty) || (I_IUCLC(tty) && L_IEXTEN(tty));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001617
Peter Hurley4a23a4d2013-06-15 10:21:22 -04001618 if (ldata->real_raw)
1619 n_tty_receive_buf_real_raw(tty, cp, fp, count);
Peter Hurleya1dd30e2013-06-15 10:21:26 -04001620 else if (ldata->raw || (L_EXTPROC(tty) && !preops))
Peter Hurley554117b2013-06-15 10:21:25 -04001621 n_tty_receive_buf_raw(tty, cp, fp, count);
Peter Hurleyad0cc7b2013-06-15 10:21:27 -04001622 else if (tty->closing && !L_EXTPROC(tty))
1623 n_tty_receive_buf_closing(tty, cp, fp, count);
Peter Hurley4a23a4d2013-06-15 10:21:22 -04001624 else {
Peter Hurleye60d27c2013-07-24 08:29:56 -04001625 if (ldata->lnext) {
1626 char flag = TTY_NORMAL;
1627
1628 if (fp)
1629 flag = *fp++;
1630 n_tty_receive_char_lnext(tty, *cp++, flag);
1631 count--;
1632 }
1633
Peter Hurley7de971b2013-07-24 08:29:53 -04001634 if (!preops && !I_PARMRK(tty))
Peter Hurley6baad002013-07-24 08:29:52 -04001635 n_tty_receive_buf_fast(tty, cp, fp, count);
1636 else
1637 n_tty_receive_buf_standard(tty, cp, fp, count);
Peter Hurleycbfd0342013-06-15 10:04:26 -04001638
1639 flush_echoes(tty);
Alan Coxf34d7a52008-04-30 00:54:13 -07001640 if (tty->ops->flush_chars)
1641 tty->ops->flush_chars(tty);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001642 }
1643
Peter Hurley70aca712015-01-16 15:05:37 -05001644 if (ldata->icanon && !L_EXTPROC(tty))
1645 return;
1646
1647 /* publish read_head to consumer */
1648 smp_store_release(&ldata->commit_head, ldata->read_head);
1649
1650 if ((read_cnt(ldata) >= ldata->minimum_to_wake) || L_EXTPROC(tty)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001651 kill_fasync(&tty->fasync, SIGIO, POLL_IN);
1652 if (waitqueue_active(&tty->read_wait))
Peter Hurley57087d52014-08-07 07:14:10 -04001653 wake_up_interruptible_poll(&tty->read_wait, POLLIN);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001654 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001655}
1656
Peter Hurleyfb5ef9e2015-01-16 15:05:39 -05001657/**
1658 * n_tty_receive_buf_common - process input
1659 * @tty: device to receive input
1660 * @cp: input chars
1661 * @fp: flags for each char (if NULL, all chars are TTY_NORMAL)
1662 * @count: number of input chars in @cp
1663 *
1664 * Called by the terminal driver when a block of characters has
1665 * been received. This function must be called from soft contexts
1666 * not from interrupt context. The driver is responsible for making
1667 * calls one at a time and in order (or using flush_to_ldisc)
1668 *
1669 * Returns the # of input chars from @cp which were processed.
1670 *
1671 * In canonical mode, the maximum line length is 4096 chars (including
1672 * the line termination char); lines longer than 4096 chars are
1673 * truncated. After 4095 chars, input data is still processed but
1674 * not stored. Overflow processing ensures the tty can always
1675 * receive more input until at least one line can be read.
1676 *
1677 * In non-canonical mode, the read buffer will only accept 4095 chars;
1678 * this provides the necessary space for a newline char if the input
1679 * mode is switched to canonical.
1680 *
1681 * Note it is possible for the read buffer to _contain_ 4096 chars
1682 * in non-canonical mode: the read buffer could already contain the
1683 * maximum canon line of 4096 chars when the mode is switched to
1684 * non-canonical.
1685 *
1686 * n_tty_receive_buf()/producer path:
1687 * claims non-exclusive termios_rwsem
1688 * publishes commit_head or canon_head
1689 */
Peter Hurley5c32d122013-12-02 14:24:41 -05001690static int
1691n_tty_receive_buf_common(struct tty_struct *tty, const unsigned char *cp,
1692 char *fp, int count, int flow)
Peter Hurley24a89d12013-06-15 09:14:15 -04001693{
1694 struct n_tty_data *ldata = tty->disc_data;
Peter Hurleyfb5ef9e2015-01-16 15:05:39 -05001695 int room, n, rcvd = 0, overflow;
Peter Hurley24a89d12013-06-15 09:14:15 -04001696
Peter Hurley9356b532013-06-15 09:14:24 -04001697 down_read(&tty->termios_rwsem);
1698
Peter Hurley19e2ad62013-07-24 08:29:54 -04001699 while (1) {
Peter Hurley70aca712015-01-16 15:05:37 -05001700 /*
Peter Hurley06c49f92015-01-16 15:05:38 -05001701 * When PARMRK is set, each input char may take up to 3 chars
1702 * in the read buf; reduce the buffer space avail by 3x
Peter Hurley70aca712015-01-16 15:05:37 -05001703 *
1704 * If we are doing input canonicalization, and there are no
1705 * pending newlines, let characters through without limit, so
1706 * that erase characters will be handled. Other excess
1707 * characters will be beeped.
1708 *
1709 * paired with store in *_copy_from_read_buf() -- guarantees
1710 * the consumer has loaded the data in read_buf up to the new
1711 * read_tail (so this producer will not overwrite unread data)
1712 */
1713 size_t tail = smp_load_acquire(&ldata->read_tail);
Peter Hurley70aca712015-01-16 15:05:37 -05001714
Peter Hurleyfb5ef9e2015-01-16 15:05:39 -05001715 room = N_TTY_BUF_SIZE - (ldata->read_head - tail);
Peter Hurley70aca712015-01-16 15:05:37 -05001716 if (I_PARMRK(tty))
Peter Hurleyfb5ef9e2015-01-16 15:05:39 -05001717 room = (room + 2) / 3;
1718 room--;
1719 if (room <= 0) {
1720 overflow = ldata->icanon && ldata->canon_head == tail;
1721 if (overflow && room < 0)
1722 ldata->read_head--;
1723 room = overflow;
1724 ldata->no_room = flow && !room;
1725 } else
1726 overflow = 0;
Peter Hurley70aca712015-01-16 15:05:37 -05001727
Peter Hurley19e2ad62013-07-24 08:29:54 -04001728 n = min(count, room);
Peter Hurleyfb5ef9e2015-01-16 15:05:39 -05001729 if (!n)
Peter Hurley19e2ad62013-07-24 08:29:54 -04001730 break;
Peter Hurleyfb5ef9e2015-01-16 15:05:39 -05001731
1732 /* ignore parity errors if handling overflow */
1733 if (!overflow || !fp || *fp != TTY_PARITY)
1734 __receive_buf(tty, cp, fp, n);
1735
Peter Hurley19e2ad62013-07-24 08:29:54 -04001736 cp += n;
1737 if (fp)
1738 fp += n;
1739 count -= n;
1740 rcvd += n;
Peter Hurley4a23a4d2013-06-15 10:21:22 -04001741 }
Peter Hurley24a89d12013-06-15 09:14:15 -04001742
Peter Hurley19e2ad62013-07-24 08:29:54 -04001743 tty->receive_room = room;
Peter Hurleyfb5ef9e2015-01-16 15:05:39 -05001744
1745 /* Unthrottle if handling overflow on pty */
1746 if (tty->driver->type == TTY_DRIVER_TYPE_PTY) {
1747 if (overflow) {
1748 tty_set_flow_change(tty, TTY_UNTHROTTLE_SAFE);
1749 tty_unthrottle_safe(tty);
1750 __tty_set_flow_change(tty, 0);
1751 }
1752 } else
1753 n_tty_check_throttle(tty);
1754
Peter Hurley9356b532013-06-15 09:14:24 -04001755 up_read(&tty->termios_rwsem);
1756
Peter Hurley19e2ad62013-07-24 08:29:54 -04001757 return rcvd;
Peter Hurley24a89d12013-06-15 09:14:15 -04001758}
1759
Peter Hurley5c32d122013-12-02 14:24:41 -05001760static void n_tty_receive_buf(struct tty_struct *tty, const unsigned char *cp,
1761 char *fp, int count)
1762{
1763 n_tty_receive_buf_common(tty, cp, fp, count, 0);
1764}
1765
1766static int n_tty_receive_buf2(struct tty_struct *tty, const unsigned char *cp,
1767 char *fp, int count)
1768{
1769 return n_tty_receive_buf_common(tty, cp, fp, count, 1);
1770}
1771
Linus Torvalds1da177e2005-04-16 15:20:36 -07001772int is_ignored(int sig)
1773{
1774 return (sigismember(&current->blocked, sig) ||
Alan Cox4edf1822008-02-08 04:18:44 -08001775 current->sighand->action[sig-1].sa.sa_handler == SIG_IGN);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001776}
1777
1778/**
1779 * n_tty_set_termios - termios data changed
1780 * @tty: terminal
1781 * @old: previous data
1782 *
1783 * Called by the tty layer when the user changes termios flags so
1784 * that the line discipline can plan ahead. This function cannot sleep
Alan Cox4edf1822008-02-08 04:18:44 -08001785 * and is protected from re-entry by the tty layer. The user is
Linus Torvalds1da177e2005-04-16 15:20:36 -07001786 * guaranteed that this function will not be re-entered or in progress
1787 * when the ldisc is closed.
Alan Cox17b82062008-10-13 10:45:06 +01001788 *
Peter Hurley6a1c0682013-06-15 09:14:23 -04001789 * Locking: Caller holds tty->termios_rwsem
Linus Torvalds1da177e2005-04-16 15:20:36 -07001790 */
Alan Cox4edf1822008-02-08 04:18:44 -08001791
1792static void n_tty_set_termios(struct tty_struct *tty, struct ktermios *old)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001793{
Jiri Slaby53c5ee22012-10-18 22:26:39 +02001794 struct n_tty_data *ldata = tty->disc_data;
Alan Cox47afa7a2008-10-13 10:44:17 +01001795
Peter Hurleyc786f742013-09-17 12:53:35 -04001796 if (!old || (old->c_lflag ^ tty->termios.c_lflag) & ICANON) {
Jiri Slaby3fe780b2012-10-18 22:26:40 +02001797 bitmap_zero(ldata->read_flags, N_TTY_BUF_SIZE);
Peter Hurley4d0ed182013-12-10 17:12:02 -05001798 ldata->line_start = ldata->read_tail;
1799 if (!L_ICANON(tty) || !read_cnt(ldata)) {
1800 ldata->canon_head = ldata->read_tail;
1801 ldata->push = 0;
1802 } else {
1803 set_bit((ldata->read_head - 1) & (N_TTY_BUF_SIZE - 1),
1804 ldata->read_flags);
1805 ldata->canon_head = ldata->read_head;
1806 ldata->push = 1;
1807 }
Peter Hurley70aca712015-01-16 15:05:37 -05001808 ldata->commit_head = ldata->read_head;
Jiri Slaby53c5ee22012-10-18 22:26:39 +02001809 ldata->erasing = 0;
Peter Hurley6f9b0282013-06-15 09:14:27 -04001810 ldata->lnext = 0;
Alan Cox47afa7a2008-10-13 10:44:17 +01001811 }
1812
Jiri Slaby53c5ee22012-10-18 22:26:39 +02001813 ldata->icanon = (L_ICANON(tty) != 0);
Peter Hurley582f5592013-05-17 12:49:48 -04001814
Linus Torvalds1da177e2005-04-16 15:20:36 -07001815 if (I_ISTRIP(tty) || I_IUCLC(tty) || I_IGNCR(tty) ||
1816 I_ICRNL(tty) || I_INLCR(tty) || L_ICANON(tty) ||
1817 I_IXON(tty) || L_ISIG(tty) || L_ECHO(tty) ||
1818 I_PARMRK(tty)) {
Peter Hurley1bb9d562013-06-15 10:21:20 -04001819 bitmap_zero(ldata->char_map, 256);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001820
1821 if (I_IGNCR(tty) || I_ICRNL(tty))
Peter Hurley1bb9d562013-06-15 10:21:20 -04001822 set_bit('\r', ldata->char_map);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001823 if (I_INLCR(tty))
Peter Hurley1bb9d562013-06-15 10:21:20 -04001824 set_bit('\n', ldata->char_map);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001825
1826 if (L_ICANON(tty)) {
Peter Hurley1bb9d562013-06-15 10:21:20 -04001827 set_bit(ERASE_CHAR(tty), ldata->char_map);
1828 set_bit(KILL_CHAR(tty), ldata->char_map);
1829 set_bit(EOF_CHAR(tty), ldata->char_map);
1830 set_bit('\n', ldata->char_map);
1831 set_bit(EOL_CHAR(tty), ldata->char_map);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001832 if (L_IEXTEN(tty)) {
Peter Hurley1bb9d562013-06-15 10:21:20 -04001833 set_bit(WERASE_CHAR(tty), ldata->char_map);
1834 set_bit(LNEXT_CHAR(tty), ldata->char_map);
1835 set_bit(EOL2_CHAR(tty), ldata->char_map);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001836 if (L_ECHO(tty))
1837 set_bit(REPRINT_CHAR(tty),
Peter Hurley1bb9d562013-06-15 10:21:20 -04001838 ldata->char_map);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001839 }
1840 }
1841 if (I_IXON(tty)) {
Peter Hurley1bb9d562013-06-15 10:21:20 -04001842 set_bit(START_CHAR(tty), ldata->char_map);
1843 set_bit(STOP_CHAR(tty), ldata->char_map);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001844 }
1845 if (L_ISIG(tty)) {
Peter Hurley1bb9d562013-06-15 10:21:20 -04001846 set_bit(INTR_CHAR(tty), ldata->char_map);
1847 set_bit(QUIT_CHAR(tty), ldata->char_map);
1848 set_bit(SUSP_CHAR(tty), ldata->char_map);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001849 }
Peter Hurley1bb9d562013-06-15 10:21:20 -04001850 clear_bit(__DISABLED_CHAR, ldata->char_map);
Jiri Slaby53c5ee22012-10-18 22:26:39 +02001851 ldata->raw = 0;
1852 ldata->real_raw = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001853 } else {
Jiri Slaby53c5ee22012-10-18 22:26:39 +02001854 ldata->raw = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001855 if ((I_IGNBRK(tty) || (!I_BRKINT(tty) && !I_PARMRK(tty))) &&
1856 (I_IGNPAR(tty) || !I_INPCK(tty)) &&
1857 (tty->driver->flags & TTY_DRIVER_REAL_RAW))
Jiri Slaby53c5ee22012-10-18 22:26:39 +02001858 ldata->real_raw = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001859 else
Jiri Slaby53c5ee22012-10-18 22:26:39 +02001860 ldata->real_raw = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001861 }
Wang YanQingdab73b42013-05-09 14:16:47 +08001862 /*
1863 * Fix tty hang when I_IXON(tty) is cleared, but the tty
1864 * been stopped by STOP_CHAR(tty) before it.
1865 */
Peter Hurleye2613be2014-02-11 16:34:55 -05001866 if (!I_IXON(tty) && old && (old->c_iflag & IXON) && !tty->flow_stopped) {
Wang YanQingdab73b42013-05-09 14:16:47 +08001867 start_tty(tty);
Peter Hurleye2613be2014-02-11 16:34:55 -05001868 process_echoes(tty);
1869 }
Wang YanQingdab73b42013-05-09 14:16:47 +08001870
Alan Coxf34d7a52008-04-30 00:54:13 -07001871 /* The termios change make the tty ready for I/O */
Peter Hurley6c677162013-12-02 14:24:46 -05001872 if (waitqueue_active(&tty->write_wait))
1873 wake_up_interruptible(&tty->write_wait);
1874 if (waitqueue_active(&tty->read_wait))
1875 wake_up_interruptible(&tty->read_wait);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001876}
1877
1878/**
1879 * n_tty_close - close the ldisc for this tty
1880 * @tty: device
1881 *
Alan Cox4edf1822008-02-08 04:18:44 -08001882 * Called from the terminal layer when this line discipline is
1883 * being shut down, either because of a close or becsuse of a
Linus Torvalds1da177e2005-04-16 15:20:36 -07001884 * discipline change. The function will not be called while other
1885 * ldisc methods are in progress.
1886 */
Alan Cox4edf1822008-02-08 04:18:44 -08001887
Linus Torvalds1da177e2005-04-16 15:20:36 -07001888static void n_tty_close(struct tty_struct *tty)
1889{
Jiri Slaby70ece7a2012-10-18 22:26:38 +02001890 struct n_tty_data *ldata = tty->disc_data;
1891
Peter Hurley79901312013-03-11 16:44:23 -04001892 if (tty->link)
1893 n_tty_packet_mode_flush(tty);
1894
Peter Hurley20bafb32013-06-15 10:21:19 -04001895 vfree(ldata);
Jiri Slaby70ece7a2012-10-18 22:26:38 +02001896 tty->disc_data = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001897}
1898
1899/**
1900 * n_tty_open - open an ldisc
1901 * @tty: terminal to open
1902 *
Alan Cox4edf1822008-02-08 04:18:44 -08001903 * Called when this line discipline is being attached to the
Linus Torvalds1da177e2005-04-16 15:20:36 -07001904 * terminal device. Can sleep. Called serialized so that no
1905 * other events will occur in parallel. No further open will occur
1906 * until a close.
1907 */
1908
1909static int n_tty_open(struct tty_struct *tty)
1910{
Jiri Slaby70ece7a2012-10-18 22:26:38 +02001911 struct n_tty_data *ldata;
1912
Peter Hurley20bafb32013-06-15 10:21:19 -04001913 /* Currently a malloc failure here can panic */
1914 ldata = vmalloc(sizeof(*ldata));
Jiri Slaby70ece7a2012-10-18 22:26:38 +02001915 if (!ldata)
1916 goto err;
1917
Jiri Slaby53c5ee22012-10-18 22:26:39 +02001918 ldata->overrun_time = jiffies;
Jiri Slabybddc7152012-10-18 22:26:42 +02001919 mutex_init(&ldata->atomic_read_lock);
1920 mutex_init(&ldata->output_lock);
Jiri Slaby53c5ee22012-10-18 22:26:39 +02001921
Jiri Slaby70ece7a2012-10-18 22:26:38 +02001922 tty->disc_data = ldata;
Peter Hurleyb66f4fa2013-03-11 16:44:32 -04001923 reset_buffer_flags(tty->disc_data);
Jiri Slaby53c5ee22012-10-18 22:26:39 +02001924 ldata->column = 0;
Peter Hurley20bafb32013-06-15 10:21:19 -04001925 ldata->canon_column = 0;
Peter Hurleyf6c8dbe2013-06-15 07:28:28 -04001926 ldata->minimum_to_wake = 1;
Peter Hurley20bafb32013-06-15 10:21:19 -04001927 ldata->num_overrun = 0;
1928 ldata->no_room = 0;
1929 ldata->lnext = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001930 tty->closing = 0;
Peter Hurleyb66f4fa2013-03-11 16:44:32 -04001931 /* indicate buffer work may resume */
1932 clear_bit(TTY_LDISC_HALTED, &tty->flags);
1933 n_tty_set_termios(tty, NULL);
1934 tty_unthrottle(tty);
Jiri Slaby70ece7a2012-10-18 22:26:38 +02001935
Linus Torvalds1da177e2005-04-16 15:20:36 -07001936 return 0;
Jiri Slaby70ece7a2012-10-18 22:26:38 +02001937err:
Jiri Slabyb91939f2012-10-18 22:26:35 +02001938 return -ENOMEM;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001939}
1940
Peter Hurleyeafbe672013-12-02 14:24:45 -05001941static inline int input_available_p(struct tty_struct *tty, int poll)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001942{
Jiri Slaby53c5ee22012-10-18 22:26:39 +02001943 struct n_tty_data *ldata = tty->disc_data;
Peter Hurleya5934802014-02-11 11:49:58 -05001944 int amt = poll && !TIME_CHAR(tty) && MIN_CHAR(tty) ? MIN_CHAR(tty) : 1;
Jiri Slaby53c5ee22012-10-18 22:26:39 +02001945
Peter Hurley25e8d0e2014-02-11 18:55:30 -05001946 if (ldata->icanon && !L_EXTPROC(tty))
1947 return ldata->canon_head != ldata->read_tail;
1948 else
Peter Hurley70aca712015-01-16 15:05:37 -05001949 return ldata->commit_head - ldata->read_tail >= amt;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001950}
1951
Peter Hurley1a486322015-04-13 13:24:34 -04001952static inline int check_other_done(struct tty_struct *tty)
1953{
1954 int done = test_bit(TTY_OTHER_DONE, &tty->flags);
1955 if (done) {
1956 /* paired with cmpxchg() in check_other_closed(); ensures
1957 * read buffer head index is not stale
1958 */
1959 smp_mb__after_atomic();
1960 }
1961 return done;
1962}
1963
Linus Torvalds1da177e2005-04-16 15:20:36 -07001964/**
Thorsten Wißmannbbd20752011-12-08 17:47:33 +01001965 * copy_from_read_buf - copy read data directly
Linus Torvalds1da177e2005-04-16 15:20:36 -07001966 * @tty: terminal device
1967 * @b: user data
1968 * @nr: size of data
1969 *
Alan Cox11a96d12008-10-13 10:46:24 +01001970 * Helper function to speed up n_tty_read. It is only called when
Linus Torvalds1da177e2005-04-16 15:20:36 -07001971 * ICANON is off; it copies characters straight from the tty queue to
1972 * user space directly. It can be profitably called twice; once to
1973 * drain the space from the tail pointer to the (physical) end of the
1974 * buffer, and once to drain the space from the (physical) beginning of
1975 * the buffer to head pointer.
1976 *
Jiri Slabybddc7152012-10-18 22:26:42 +02001977 * Called under the ldata->atomic_read_lock sem
Linus Torvalds1da177e2005-04-16 15:20:36 -07001978 *
Peter Hurley6d76bd22013-06-15 09:14:26 -04001979 * n_tty_read()/consumer path:
1980 * caller holds non-exclusive termios_rwsem
1981 * read_tail published
Linus Torvalds1da177e2005-04-16 15:20:36 -07001982 */
Alan Cox4edf1822008-02-08 04:18:44 -08001983
Alan Cox33f0f882006-01-09 20:54:13 -08001984static int copy_from_read_buf(struct tty_struct *tty,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001985 unsigned char __user **b,
1986 size_t *nr)
1987
1988{
Jiri Slaby53c5ee22012-10-18 22:26:39 +02001989 struct n_tty_data *ldata = tty->disc_data;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001990 int retval;
1991 size_t n;
Jiri Slaby3fa10cc2012-04-26 20:13:00 +02001992 bool is_eof;
Peter Hurley70aca712015-01-16 15:05:37 -05001993 size_t head = smp_load_acquire(&ldata->commit_head);
Peter Hurleybc5a5e32013-06-15 09:14:21 -04001994 size_t tail = ldata->read_tail & (N_TTY_BUF_SIZE - 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001995
1996 retval = 0;
Peter Hurley70aca712015-01-16 15:05:37 -05001997 n = min(head - ldata->read_tail, N_TTY_BUF_SIZE - tail);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001998 n = min(*nr, n);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001999 if (n) {
Peter Hurleybc5a5e32013-06-15 09:14:21 -04002000 retval = copy_to_user(*b, read_buf_addr(ldata, tail), n);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002001 n -= retval;
Peter Hurleybc5a5e32013-06-15 09:14:21 -04002002 is_eof = n == 1 && read_buf(ldata, tail) == EOF_CHAR(tty);
2003 tty_audit_add_data(tty, read_buf_addr(ldata, tail), n,
Jiri Slaby53c5ee22012-10-18 22:26:39 +02002004 ldata->icanon);
Peter Hurley70aca712015-01-16 15:05:37 -05002005 smp_store_release(&ldata->read_tail, ldata->read_tail + n);
hyc@symas.com26df6d12010-06-22 10:14:49 -07002006 /* Turn single EOF into zero-length read */
Peter Hurley70aca712015-01-16 15:05:37 -05002007 if (L_EXTPROC(tty) && ldata->icanon && is_eof &&
2008 (head == ldata->read_tail))
Jiri Slaby3fa10cc2012-04-26 20:13:00 +02002009 n = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002010 *b += n;
2011 *nr -= n;
2012 }
2013 return retval;
2014}
2015
Peter Hurley88bb0de2013-06-15 09:14:16 -04002016/**
Peter Hurley32f13522013-06-15 09:14:17 -04002017 * canon_copy_from_read_buf - copy read data in canonical mode
Peter Hurley88bb0de2013-06-15 09:14:16 -04002018 * @tty: terminal device
2019 * @b: user data
2020 * @nr: size of data
2021 *
2022 * Helper function for n_tty_read. It is only called when ICANON is on;
Peter Hurley32f13522013-06-15 09:14:17 -04002023 * it copies one line of input up to and including the line-delimiting
2024 * character into the user-space buffer.
Peter Hurley88bb0de2013-06-15 09:14:16 -04002025 *
Peter Hurley4d0ed182013-12-10 17:12:02 -05002026 * NB: When termios is changed from non-canonical to canonical mode and
2027 * the read buffer contains data, n_tty_set_termios() simulates an EOF
2028 * push (as if C-d were input) _without_ the DISABLED_CHAR in the buffer.
2029 * This causes data already processed as input to be immediately available
2030 * as input although a newline has not been received.
2031 *
Peter Hurley88bb0de2013-06-15 09:14:16 -04002032 * Called under the atomic_read_lock mutex
Peter Hurley6d76bd22013-06-15 09:14:26 -04002033 *
2034 * n_tty_read()/consumer path:
2035 * caller holds non-exclusive termios_rwsem
2036 * read_tail published
Peter Hurley88bb0de2013-06-15 09:14:16 -04002037 */
2038
Peter Hurley32f13522013-06-15 09:14:17 -04002039static int canon_copy_from_read_buf(struct tty_struct *tty,
2040 unsigned char __user **b,
2041 size_t *nr)
Peter Hurley88bb0de2013-06-15 09:14:16 -04002042{
2043 struct n_tty_data *ldata = tty->disc_data;
Peter Hurley32f13522013-06-15 09:14:17 -04002044 size_t n, size, more, c;
Peter Hurleybc5a5e32013-06-15 09:14:21 -04002045 size_t eol;
2046 size_t tail;
2047 int ret, found = 0;
Peter Hurley40d5e092013-06-15 10:21:17 -04002048 bool eof_push = 0;
Peter Hurley88bb0de2013-06-15 09:14:16 -04002049
2050 /* N.B. avoid overrun if nr == 0 */
Peter Hurley70aca712015-01-16 15:05:37 -05002051 n = min(*nr, smp_load_acquire(&ldata->canon_head) - ldata->read_tail);
Peter Hurley6d76bd22013-06-15 09:14:26 -04002052 if (!n)
Peter Hurley32f13522013-06-15 09:14:17 -04002053 return 0;
Peter Hurley88bb0de2013-06-15 09:14:16 -04002054
Peter Hurleybc5a5e32013-06-15 09:14:21 -04002055 tail = ldata->read_tail & (N_TTY_BUF_SIZE - 1);
Peter Hurley32f13522013-06-15 09:14:17 -04002056 size = min_t(size_t, tail + n, N_TTY_BUF_SIZE);
2057
Peter Hurleybc5a5e32013-06-15 09:14:21 -04002058 n_tty_trace("%s: nr:%zu tail:%zu n:%zu size:%zu\n",
Peter Hurley32f13522013-06-15 09:14:17 -04002059 __func__, *nr, tail, n, size);
2060
2061 eol = find_next_bit(ldata->read_flags, size, tail);
2062 more = n - (size - tail);
2063 if (eol == N_TTY_BUF_SIZE && more) {
2064 /* scan wrapped without finding set bit */
2065 eol = find_next_bit(ldata->read_flags, more, 0);
2066 if (eol != more)
2067 found = 1;
2068 } else if (eol != size)
2069 found = 1;
2070
2071 size = N_TTY_BUF_SIZE - tail;
Peter Hurleyc77569d2013-11-22 07:16:25 -05002072 n = eol - tail;
2073 if (n > 4096)
2074 n += 4096;
2075 n += found;
Peter Hurley32f13522013-06-15 09:14:17 -04002076 c = n;
2077
Peter Hurley4d0ed182013-12-10 17:12:02 -05002078 if (found && !ldata->push && read_buf(ldata, eol) == __DISABLED_CHAR) {
Peter Hurley32f13522013-06-15 09:14:17 -04002079 n--;
Peter Hurley40d5e092013-06-15 10:21:17 -04002080 eof_push = !n && ldata->read_tail != ldata->line_start;
2081 }
Peter Hurley32f13522013-06-15 09:14:17 -04002082
Peter Hurleybc5a5e32013-06-15 09:14:21 -04002083 n_tty_trace("%s: eol:%zu found:%d n:%zu c:%zu size:%zu more:%zu\n",
Peter Hurley32f13522013-06-15 09:14:17 -04002084 __func__, eol, found, n, c, size, more);
2085
Peter Hurley32f13522013-06-15 09:14:17 -04002086 if (n > size) {
Peter Hurleybc5a5e32013-06-15 09:14:21 -04002087 ret = copy_to_user(*b, read_buf_addr(ldata, tail), size);
Peter Hurley32f13522013-06-15 09:14:17 -04002088 if (ret)
2089 return -EFAULT;
2090 ret = copy_to_user(*b + size, ldata->read_buf, n - size);
2091 } else
Peter Hurleybc5a5e32013-06-15 09:14:21 -04002092 ret = copy_to_user(*b, read_buf_addr(ldata, tail), n);
Peter Hurley32f13522013-06-15 09:14:17 -04002093
2094 if (ret)
2095 return -EFAULT;
2096 *b += n;
2097 *nr -= n;
2098
Peter Hurleya73d3d62013-06-15 09:14:25 -04002099 if (found)
Peter Hurley6d76bd22013-06-15 09:14:26 -04002100 clear_bit(eol, ldata->read_flags);
Peter Hurley70aca712015-01-16 15:05:37 -05002101 smp_store_release(&ldata->read_tail, ldata->read_tail + c);
Peter Hurley88bb0de2013-06-15 09:14:16 -04002102
Peter Hurley40d5e092013-06-15 10:21:17 -04002103 if (found) {
Peter Hurley4d0ed182013-12-10 17:12:02 -05002104 if (!ldata->push)
2105 ldata->line_start = ldata->read_tail;
2106 else
2107 ldata->push = 0;
Peter Hurley32f13522013-06-15 09:14:17 -04002108 tty_audit_push(tty);
Peter Hurley40d5e092013-06-15 10:21:17 -04002109 }
2110 return eof_push ? -EAGAIN : 0;
Peter Hurley88bb0de2013-06-15 09:14:16 -04002111}
2112
Al Virocc4191d2008-03-29 03:08:48 +00002113extern ssize_t redirected_tty_write(struct file *, const char __user *,
Alan Cox4edf1822008-02-08 04:18:44 -08002114 size_t, loff_t *);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002115
2116/**
2117 * job_control - check job control
2118 * @tty: tty
2119 * @file: file handle
2120 *
2121 * Perform job control management checks on this file/tty descriptor
Alan Cox4edf1822008-02-08 04:18:44 -08002122 * and if appropriate send any needed signals and return a negative
Linus Torvalds1da177e2005-04-16 15:20:36 -07002123 * error code if action should be taken.
Alan Cox04f378b2008-04-30 00:53:29 -07002124 *
Peter Hurley01a5e442013-03-06 08:38:20 -05002125 * Locking: redirected write test is safe
2126 * current->signal->tty check is safe
2127 * ctrl_lock to safely reference tty->pgrp
Linus Torvalds1da177e2005-04-16 15:20:36 -07002128 */
Alan Cox4edf1822008-02-08 04:18:44 -08002129
Linus Torvalds1da177e2005-04-16 15:20:36 -07002130static int job_control(struct tty_struct *tty, struct file *file)
2131{
2132 /* Job control check -- must be done at start and after
2133 every sleep (POSIX.1 7.1.1.4). */
2134 /* NOTE: not yet done after every sleep pending a thorough
2135 check of the logic of this change. -- jlc */
2136 /* don't stop on /dev/console */
Peter Hurley01a5e442013-03-06 08:38:20 -05002137 if (file->f_op->write == redirected_tty_write ||
2138 current->signal->tty != tty)
2139 return 0;
2140
2141 spin_lock_irq(&tty->ctrl_lock);
2142 if (!tty->pgrp)
2143 printk(KERN_ERR "n_tty_read: no tty->pgrp!\n");
2144 else if (task_pgrp(current) != tty->pgrp) {
2145 spin_unlock_irq(&tty->ctrl_lock);
2146 if (is_ignored(SIGTTIN) || is_current_pgrp_orphaned())
2147 return -EIO;
2148 kill_pgrp(task_pgrp(current), SIGTTIN, 1);
2149 set_thread_flag(TIF_SIGPENDING);
2150 return -ERESTARTSYS;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002151 }
Peter Hurley01a5e442013-03-06 08:38:20 -05002152 spin_unlock_irq(&tty->ctrl_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002153 return 0;
2154}
Alan Cox4edf1822008-02-08 04:18:44 -08002155
Linus Torvalds1da177e2005-04-16 15:20:36 -07002156
2157/**
Alan Cox11a96d12008-10-13 10:46:24 +01002158 * n_tty_read - read function for tty
Linus Torvalds1da177e2005-04-16 15:20:36 -07002159 * @tty: tty device
2160 * @file: file object
2161 * @buf: userspace buffer pointer
2162 * @nr: size of I/O
2163 *
2164 * Perform reads for the line discipline. We are guaranteed that the
2165 * line discipline will not be closed under us but we may get multiple
2166 * parallel readers and must handle this ourselves. We may also get
2167 * a hangup. Always called in user context, may sleep.
2168 *
2169 * This code must be sure never to sleep through a hangup.
Peter Hurley6d76bd22013-06-15 09:14:26 -04002170 *
2171 * n_tty_read()/consumer path:
2172 * claims non-exclusive termios_rwsem
2173 * publishes read_tail
Linus Torvalds1da177e2005-04-16 15:20:36 -07002174 */
Alan Cox4edf1822008-02-08 04:18:44 -08002175
Alan Cox11a96d12008-10-13 10:46:24 +01002176static ssize_t n_tty_read(struct tty_struct *tty, struct file *file,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002177 unsigned char __user *buf, size_t nr)
2178{
Jiri Slaby53c5ee22012-10-18 22:26:39 +02002179 struct n_tty_data *ldata = tty->disc_data;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002180 unsigned char __user *b = buf;
Peter Zijlstra97d9e282014-09-24 10:18:51 +02002181 DEFINE_WAIT_FUNC(wait, woken_wake_function);
Peter Hurley1a486322015-04-13 13:24:34 -04002182 int c, done;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002183 int minimum, time;
2184 ssize_t retval = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002185 long timeout;
Alan Cox04f378b2008-04-30 00:53:29 -07002186 int packet;
Peter Hurley2c5dc462015-01-16 15:05:34 -05002187 size_t tail;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002188
Linus Torvalds1da177e2005-04-16 15:20:36 -07002189 c = job_control(tty, file);
Alan Cox4edf1822008-02-08 04:18:44 -08002190 if (c < 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002191 return c;
Alan Cox4edf1822008-02-08 04:18:44 -08002192
Peter Hurleyaefceaf2013-08-11 08:04:23 -04002193 /*
2194 * Internal serialization of reads.
2195 */
2196 if (file->f_flags & O_NONBLOCK) {
2197 if (!mutex_trylock(&ldata->atomic_read_lock))
2198 return -EAGAIN;
2199 } else {
2200 if (mutex_lock_interruptible(&ldata->atomic_read_lock))
2201 return -ERESTARTSYS;
2202 }
2203
Peter Hurley9356b532013-06-15 09:14:24 -04002204 down_read(&tty->termios_rwsem);
2205
Linus Torvalds1da177e2005-04-16 15:20:36 -07002206 minimum = time = 0;
2207 timeout = MAX_SCHEDULE_TIMEOUT;
Jiri Slaby53c5ee22012-10-18 22:26:39 +02002208 if (!ldata->icanon) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002209 minimum = MIN_CHAR(tty);
2210 if (minimum) {
Peter Hurleya6e54312013-06-15 07:28:29 -04002211 time = (HZ / 10) * TIME_CHAR(tty);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002212 if (time)
Peter Hurleyf6c8dbe2013-06-15 07:28:28 -04002213 ldata->minimum_to_wake = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002214 else if (!waitqueue_active(&tty->read_wait) ||
Peter Hurleyf6c8dbe2013-06-15 07:28:28 -04002215 (ldata->minimum_to_wake > minimum))
2216 ldata->minimum_to_wake = minimum;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002217 } else {
Peter Hurleya6e54312013-06-15 07:28:29 -04002218 timeout = (HZ / 10) * TIME_CHAR(tty);
Peter Hurleyf6c8dbe2013-06-15 07:28:28 -04002219 ldata->minimum_to_wake = minimum = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002220 }
2221 }
2222
Alan Cox04f378b2008-04-30 00:53:29 -07002223 packet = tty->packet;
Peter Hurley2c5dc462015-01-16 15:05:34 -05002224 tail = ldata->read_tail;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002225
2226 add_wait_queue(&tty->read_wait, &wait);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002227 while (nr) {
2228 /* First test for status change. */
Alan Cox04f378b2008-04-30 00:53:29 -07002229 if (packet && tty->link->ctrl_status) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002230 unsigned char cs;
2231 if (b != buf)
2232 break;
Peter Hurley6054c16e2014-10-16 15:33:25 -04002233 spin_lock_irq(&tty->link->ctrl_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002234 cs = tty->link->ctrl_status;
2235 tty->link->ctrl_status = 0;
Peter Hurley6054c16e2014-10-16 15:33:25 -04002236 spin_unlock_irq(&tty->link->ctrl_lock);
Miloslav Trmac522ed772007-07-15 23:40:56 -07002237 if (tty_put_user(tty, cs, b++)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002238 retval = -EFAULT;
2239 b--;
2240 break;
2241 }
2242 nr--;
2243 break;
2244 }
Alan Cox4edf1822008-02-08 04:18:44 -08002245
Peter Hurleyf6c8dbe2013-06-15 07:28:28 -04002246 if (((minimum - (b - buf)) < ldata->minimum_to_wake) &&
Linus Torvalds1da177e2005-04-16 15:20:36 -07002247 ((minimum - (b - buf)) >= 1))
Peter Hurleyf6c8dbe2013-06-15 07:28:28 -04002248 ldata->minimum_to_wake = (minimum - (b - buf));
Alan Cox4edf1822008-02-08 04:18:44 -08002249
Peter Hurley1a486322015-04-13 13:24:34 -04002250 done = check_other_done(tty);
2251
Linus Torvalds1da177e2005-04-16 15:20:36 -07002252 if (!input_available_p(tty, 0)) {
Peter Hurley1a486322015-04-13 13:24:34 -04002253 if (done) {
Peter Hurley52bce7f2014-11-05 12:13:05 -05002254 retval = -EIO;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002255 break;
2256 }
Peter Hurley52bce7f2014-11-05 12:13:05 -05002257 if (tty_hung_up_p(file))
2258 break;
2259 if (!timeout)
2260 break;
2261 if (file->f_flags & O_NONBLOCK) {
2262 retval = -EAGAIN;
2263 break;
2264 }
2265 if (signal_pending(current)) {
2266 retval = -ERESTARTSYS;
2267 break;
2268 }
Peter Hurley52bce7f2014-11-05 12:13:05 -05002269 up_read(&tty->termios_rwsem);
2270
Linus Torvalds37da7bb2014-12-14 15:23:32 -08002271 timeout = wait_woken(&wait, TASK_INTERRUPTIBLE,
2272 timeout);
Peter Hurley52bce7f2014-11-05 12:13:05 -05002273
2274 down_read(&tty->termios_rwsem);
2275 continue;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002276 }
2277
Jiri Slaby53c5ee22012-10-18 22:26:39 +02002278 if (ldata->icanon && !L_EXTPROC(tty)) {
Peter Hurley32f13522013-06-15 09:14:17 -04002279 retval = canon_copy_from_read_buf(tty, &b, &nr);
Peter Hurley40d5e092013-06-15 10:21:17 -04002280 if (retval == -EAGAIN) {
2281 retval = 0;
2282 continue;
2283 } else if (retval)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002284 break;
2285 } else {
2286 int uncopied;
Peter Hurley95ea90d2014-10-16 15:33:30 -04002287
2288 /* Deal with packet mode. */
2289 if (packet && b == buf) {
2290 if (tty_put_user(tty, TIOCPKT_DATA, b++)) {
2291 retval = -EFAULT;
2292 b--;
2293 break;
2294 }
2295 nr--;
2296 }
2297
Linus Torvalds1da177e2005-04-16 15:20:36 -07002298 uncopied = copy_from_read_buf(tty, &b, &nr);
2299 uncopied += copy_from_read_buf(tty, &b, &nr);
2300 if (uncopied) {
2301 retval = -EFAULT;
2302 break;
2303 }
2304 }
2305
Peter Hurley6367ca72013-06-15 09:14:33 -04002306 n_tty_check_unthrottle(tty);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002307
2308 if (b - buf >= minimum)
2309 break;
2310 if (time)
2311 timeout = time;
2312 }
Peter Hurley2c5dc462015-01-16 15:05:34 -05002313 if (tail != ldata->read_tail)
2314 n_tty_kick_worker(tty);
Peter Hurley42458f42013-11-07 13:59:46 -05002315 up_read(&tty->termios_rwsem);
2316
Linus Torvalds1da177e2005-04-16 15:20:36 -07002317 remove_wait_queue(&tty->read_wait, &wait);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002318 if (!waitqueue_active(&tty->read_wait))
Peter Hurleyf6c8dbe2013-06-15 07:28:28 -04002319 ldata->minimum_to_wake = minimum;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002320
Peter Hurleyaebf04532013-11-07 14:01:57 -05002321 mutex_unlock(&ldata->atomic_read_lock);
2322
Peter Hurley40d5e092013-06-15 10:21:17 -04002323 if (b - buf)
2324 retval = b - buf;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002325
2326 return retval;
2327}
2328
2329/**
Alan Cox11a96d12008-10-13 10:46:24 +01002330 * n_tty_write - write function for tty
Linus Torvalds1da177e2005-04-16 15:20:36 -07002331 * @tty: tty device
2332 * @file: file object
2333 * @buf: userspace buffer pointer
2334 * @nr: size of I/O
2335 *
Joe Petersona88a69c2009-01-02 13:40:53 +00002336 * Write function of the terminal device. This is serialized with
Linus Torvalds1da177e2005-04-16 15:20:36 -07002337 * respect to other write callers but not to termios changes, reads
Joe Petersona88a69c2009-01-02 13:40:53 +00002338 * and other such events. Since the receive code will echo characters,
2339 * thus calling driver write methods, the output_lock is used in
2340 * the output processing functions called here as well as in the
2341 * echo processing function to protect the column state and space
2342 * left in the buffer.
Linus Torvalds1da177e2005-04-16 15:20:36 -07002343 *
2344 * This code must be sure never to sleep through a hangup.
Joe Petersona88a69c2009-01-02 13:40:53 +00002345 *
2346 * Locking: output_lock to protect column state and space left
2347 * (note that the process_output*() functions take this
2348 * lock themselves)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002349 */
Alan Cox4edf1822008-02-08 04:18:44 -08002350
Alan Cox11a96d12008-10-13 10:46:24 +01002351static ssize_t n_tty_write(struct tty_struct *tty, struct file *file,
Joe Petersona88a69c2009-01-02 13:40:53 +00002352 const unsigned char *buf, size_t nr)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002353{
2354 const unsigned char *b = buf;
Peter Zijlstra97d9e282014-09-24 10:18:51 +02002355 DEFINE_WAIT_FUNC(wait, woken_wake_function);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002356 int c;
2357 ssize_t retval = 0;
2358
2359 /* Job control check -- must be done at start (POSIX.1 7.1.1.4). */
2360 if (L_TOSTOP(tty) && file->f_op->write != redirected_tty_write) {
2361 retval = tty_check_change(tty);
2362 if (retval)
2363 return retval;
2364 }
2365
Peter Hurley9356b532013-06-15 09:14:24 -04002366 down_read(&tty->termios_rwsem);
2367
Joe Petersona88a69c2009-01-02 13:40:53 +00002368 /* Write out any echoed characters that are still pending */
2369 process_echoes(tty);
Alan Cox300a6202009-01-02 13:41:04 +00002370
Linus Torvalds1da177e2005-04-16 15:20:36 -07002371 add_wait_queue(&tty->write_wait, &wait);
2372 while (1) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002373 if (signal_pending(current)) {
2374 retval = -ERESTARTSYS;
2375 break;
2376 }
2377 if (tty_hung_up_p(file) || (tty->link && !tty->link->count)) {
2378 retval = -EIO;
2379 break;
2380 }
Peter Hurley582f5592013-05-17 12:49:48 -04002381 if (O_OPOST(tty)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002382 while (nr > 0) {
Joe Petersona88a69c2009-01-02 13:40:53 +00002383 ssize_t num = process_output_block(tty, b, nr);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002384 if (num < 0) {
2385 if (num == -EAGAIN)
2386 break;
2387 retval = num;
2388 goto break_out;
2389 }
2390 b += num;
2391 nr -= num;
2392 if (nr == 0)
2393 break;
2394 c = *b;
Joe Petersona88a69c2009-01-02 13:40:53 +00002395 if (process_output(c, tty) < 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002396 break;
2397 b++; nr--;
2398 }
Alan Coxf34d7a52008-04-30 00:54:13 -07002399 if (tty->ops->flush_chars)
2400 tty->ops->flush_chars(tty);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002401 } else {
Peter Hurley42910862014-05-03 14:04:59 +02002402 struct n_tty_data *ldata = tty->disc_data;
2403
Roman Zippeld6afe272005-07-07 17:56:55 -07002404 while (nr > 0) {
Peter Hurley42910862014-05-03 14:04:59 +02002405 mutex_lock(&ldata->output_lock);
Alan Coxf34d7a52008-04-30 00:54:13 -07002406 c = tty->ops->write(tty, b, nr);
Peter Hurley42910862014-05-03 14:04:59 +02002407 mutex_unlock(&ldata->output_lock);
Roman Zippeld6afe272005-07-07 17:56:55 -07002408 if (c < 0) {
2409 retval = c;
2410 goto break_out;
2411 }
2412 if (!c)
2413 break;
2414 b += c;
2415 nr -= c;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002416 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002417 }
2418 if (!nr)
2419 break;
2420 if (file->f_flags & O_NONBLOCK) {
2421 retval = -EAGAIN;
2422 break;
2423 }
Peter Hurley9356b532013-06-15 09:14:24 -04002424 up_read(&tty->termios_rwsem);
2425
Peter Zijlstra97d9e282014-09-24 10:18:51 +02002426 wait_woken(&wait, TASK_INTERRUPTIBLE, MAX_SCHEDULE_TIMEOUT);
Peter Hurley9356b532013-06-15 09:14:24 -04002427
2428 down_read(&tty->termios_rwsem);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002429 }
2430break_out:
Linus Torvalds1da177e2005-04-16 15:20:36 -07002431 remove_wait_queue(&tty->write_wait, &wait);
Thomas Pfaffff8cb0f2009-01-02 13:47:13 +00002432 if (b - buf != nr && tty->fasync)
2433 set_bit(TTY_DO_WRITE_WAKEUP, &tty->flags);
Peter Hurley9356b532013-06-15 09:14:24 -04002434 up_read(&tty->termios_rwsem);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002435 return (b - buf) ? b - buf : retval;
2436}
2437
2438/**
Alan Cox11a96d12008-10-13 10:46:24 +01002439 * n_tty_poll - poll method for N_TTY
Linus Torvalds1da177e2005-04-16 15:20:36 -07002440 * @tty: terminal device
2441 * @file: file accessing it
2442 * @wait: poll table
2443 *
2444 * Called when the line discipline is asked to poll() for data or
2445 * for special events. This code is not serialized with respect to
2446 * other events save open/close.
2447 *
2448 * This code must be sure never to sleep through a hangup.
2449 * Called without the kernel lock held - fine
Linus Torvalds1da177e2005-04-16 15:20:36 -07002450 */
Alan Cox4edf1822008-02-08 04:18:44 -08002451
Alan Cox11a96d12008-10-13 10:46:24 +01002452static unsigned int n_tty_poll(struct tty_struct *tty, struct file *file,
Alan Cox4edf1822008-02-08 04:18:44 -08002453 poll_table *wait)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002454{
Peter Hurleyf6c8dbe2013-06-15 07:28:28 -04002455 struct n_tty_data *ldata = tty->disc_data;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002456 unsigned int mask = 0;
2457
2458 poll_wait(file, &tty->read_wait, wait);
2459 poll_wait(file, &tty->write_wait, wait);
Peter Hurley1a486322015-04-13 13:24:34 -04002460 if (check_other_done(tty))
2461 mask |= POLLHUP;
Francesco Ruggeric4dc3042014-10-10 13:09:53 -07002462 if (input_available_p(tty, 1))
2463 mask |= POLLIN | POLLRDNORM;
Francesco Ruggeric4dc3042014-10-10 13:09:53 -07002464 if (tty->packet && tty->link->ctrl_status)
2465 mask |= POLLPRI | POLLIN | POLLRDNORM;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002466 if (tty_hung_up_p(file))
2467 mask |= POLLHUP;
2468 if (!(mask & (POLLHUP | POLLIN | POLLRDNORM))) {
2469 if (MIN_CHAR(tty) && !TIME_CHAR(tty))
Peter Hurleyf6c8dbe2013-06-15 07:28:28 -04002470 ldata->minimum_to_wake = MIN_CHAR(tty);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002471 else
Peter Hurleyf6c8dbe2013-06-15 07:28:28 -04002472 ldata->minimum_to_wake = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002473 }
Alan Coxf34d7a52008-04-30 00:54:13 -07002474 if (tty->ops->write && !tty_is_writelocked(tty) &&
2475 tty_chars_in_buffer(tty) < WAKEUP_CHARS &&
2476 tty_write_room(tty) > 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002477 mask |= POLLOUT | POLLWRNORM;
2478 return mask;
2479}
2480
Jiri Slaby57c94122012-10-18 22:26:43 +02002481static unsigned long inq_canon(struct n_tty_data *ldata)
Alan Cox47afa7a2008-10-13 10:44:17 +01002482{
Peter Hurleybc5a5e32013-06-15 09:14:21 -04002483 size_t nr, head, tail;
Alan Cox47afa7a2008-10-13 10:44:17 +01002484
Peter Hurleya73d3d62013-06-15 09:14:25 -04002485 if (ldata->canon_head == ldata->read_tail)
Alan Cox47afa7a2008-10-13 10:44:17 +01002486 return 0;
Jiri Slabyba2e68a2012-10-18 22:26:41 +02002487 head = ldata->canon_head;
2488 tail = ldata->read_tail;
Peter Hurleybc5a5e32013-06-15 09:14:21 -04002489 nr = head - tail;
Alan Cox47afa7a2008-10-13 10:44:17 +01002490 /* Skip EOF-chars.. */
2491 while (head != tail) {
Peter Hurleybc5a5e32013-06-15 09:14:21 -04002492 if (test_bit(tail & (N_TTY_BUF_SIZE - 1), ldata->read_flags) &&
2493 read_buf(ldata, tail) == __DISABLED_CHAR)
Alan Cox47afa7a2008-10-13 10:44:17 +01002494 nr--;
Peter Hurleybc5a5e32013-06-15 09:14:21 -04002495 tail++;
Alan Cox47afa7a2008-10-13 10:44:17 +01002496 }
2497 return nr;
2498}
2499
2500static int n_tty_ioctl(struct tty_struct *tty, struct file *file,
2501 unsigned int cmd, unsigned long arg)
2502{
Jiri Slabyba2e68a2012-10-18 22:26:41 +02002503 struct n_tty_data *ldata = tty->disc_data;
Alan Cox47afa7a2008-10-13 10:44:17 +01002504 int retval;
2505
2506 switch (cmd) {
2507 case TIOCOUTQ:
2508 return put_user(tty_chars_in_buffer(tty), (int __user *) arg);
2509 case TIOCINQ:
Peter Hurley6d76bd22013-06-15 09:14:26 -04002510 down_write(&tty->termios_rwsem);
Alan Cox47afa7a2008-10-13 10:44:17 +01002511 if (L_ICANON(tty))
Jiri Slaby57c94122012-10-18 22:26:43 +02002512 retval = inq_canon(ldata);
Peter Hurley6d76bd22013-06-15 09:14:26 -04002513 else
2514 retval = read_cnt(ldata);
2515 up_write(&tty->termios_rwsem);
Alan Cox47afa7a2008-10-13 10:44:17 +01002516 return put_user(retval, (unsigned int __user *) arg);
2517 default:
2518 return n_tty_ioctl_helper(tty, file, cmd, arg);
2519 }
2520}
2521
Peter Hurleyf6c8dbe2013-06-15 07:28:28 -04002522static void n_tty_fasync(struct tty_struct *tty, int on)
2523{
2524 struct n_tty_data *ldata = tty->disc_data;
2525
2526 if (!waitqueue_active(&tty->read_wait)) {
2527 if (on)
2528 ldata->minimum_to_wake = 1;
2529 else if (!tty->fasync)
2530 ldata->minimum_to_wake = N_TTY_BUF_SIZE;
2531 }
2532}
2533
Alan Coxa352def2008-07-16 21:53:12 +01002534struct tty_ldisc_ops tty_ldisc_N_TTY = {
Paul Fulghume10cc1d2007-05-10 22:22:50 -07002535 .magic = TTY_LDISC_MAGIC,
2536 .name = "n_tty",
2537 .open = n_tty_open,
2538 .close = n_tty_close,
2539 .flush_buffer = n_tty_flush_buffer,
2540 .chars_in_buffer = n_tty_chars_in_buffer,
Alan Cox11a96d12008-10-13 10:46:24 +01002541 .read = n_tty_read,
2542 .write = n_tty_write,
Paul Fulghume10cc1d2007-05-10 22:22:50 -07002543 .ioctl = n_tty_ioctl,
2544 .set_termios = n_tty_set_termios,
Alan Cox11a96d12008-10-13 10:46:24 +01002545 .poll = n_tty_poll,
Paul Fulghume10cc1d2007-05-10 22:22:50 -07002546 .receive_buf = n_tty_receive_buf,
Peter Hurleyf6c8dbe2013-06-15 07:28:28 -04002547 .write_wakeup = n_tty_write_wakeup,
2548 .fasync = n_tty_fasync,
Peter Hurley24a89d12013-06-15 09:14:15 -04002549 .receive_buf2 = n_tty_receive_buf2,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002550};
Rodolfo Giometti572b9ad2010-03-10 15:23:46 -08002551
2552/**
2553 * n_tty_inherit_ops - inherit N_TTY methods
2554 * @ops: struct tty_ldisc_ops where to save N_TTY methods
2555 *
George Spelvin593fb1ae42013-02-12 02:00:43 -05002556 * Enables a 'subclass' line discipline to 'inherit' N_TTY
Rodolfo Giometti572b9ad2010-03-10 15:23:46 -08002557 * methods.
2558 */
2559
2560void n_tty_inherit_ops(struct tty_ldisc_ops *ops)
2561{
2562 *ops = tty_ldisc_N_TTY;
2563 ops->owner = NULL;
2564 ops->refcount = ops->flags = 0;
2565}
2566EXPORT_SYMBOL_GPL(n_tty_inherit_ops);