blob: 20932cc9c8f71681038bf5e505fec87d9c402280 [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
Laura Abbott72586c62015-05-14 11:42:17 -0700165static inline int tty_copy_to_user(struct tty_struct *tty,
166 void __user *to,
167 const void *from,
168 unsigned long n)
169{
170 struct n_tty_data *ldata = tty->disc_data;
171
172 tty_audit_add_data(tty, to, n, ldata->icanon);
173 return copy_to_user(to, from, n);
174}
175
Peter Hurley24a89d12013-06-15 09:14:15 -0400176/**
Peter Hurley2c5dc462015-01-16 15:05:34 -0500177 * n_tty_kick_worker - start input worker (if required)
Peter Hurley24a89d12013-06-15 09:14:15 -0400178 * @tty: terminal
179 *
Peter Hurley2c5dc462015-01-16 15:05:34 -0500180 * Re-schedules the flip buffer work if it may have stopped
Peter Hurley24a89d12013-06-15 09:14:15 -0400181 *
Peter Hurley6d76bd22013-06-15 09:14:26 -0400182 * Caller holds exclusive termios_rwsem
183 * or
184 * n_tty_read()/consumer path:
185 * holds non-exclusive termios_rwsem
Peter Hurley24a89d12013-06-15 09:14:15 -0400186 */
187
Peter Hurley2c5dc462015-01-16 15:05:34 -0500188static void n_tty_kick_worker(struct tty_struct *tty)
Peter Hurley7879a9f2013-06-15 07:28:31 -0400189{
Peter Hurley24a89d12013-06-15 09:14:15 -0400190 struct n_tty_data *ldata = tty->disc_data;
191
Peter Hurley2c5dc462015-01-16 15:05:34 -0500192 /* Did the input worker stop? Restart it */
193 if (unlikely(ldata->no_room)) {
Peter Hurley24a89d12013-06-15 09:14:15 -0400194 ldata->no_room = 0;
195
Jiri Slabyecbbfd42012-10-18 22:26:47 +0200196 WARN_RATELIMIT(tty->port->itty == NULL,
Sasha Levincadf7482012-10-25 14:26:35 -0400197 "scheduling with invalid itty\n");
Peter Hurley21622932013-03-11 16:44:21 -0400198 /* see if ldisc has been killed - if so, this means that
199 * even though the ldisc has been halted and ->buf.work
200 * cancelled, ->buf.work is about to be rescheduled
201 */
202 WARN_RATELIMIT(test_bit(TTY_LDISC_HALTED, &tty->flags),
203 "scheduling buffer work for halted ldisc\n");
Peter Hurleyf0f947c2013-06-15 09:14:36 -0400204 queue_work(system_unbound_wq, &tty->port->buf.work);
Jiri Slabyecbbfd42012-10-18 22:26:47 +0200205 }
Linus Torvalds55db4c62011-06-04 06:33:24 +0900206}
207
Peter Hurley9a4aec22013-06-15 09:14:32 -0400208static ssize_t chars_in_buffer(struct tty_struct *tty)
209{
210 struct n_tty_data *ldata = tty->disc_data;
211 ssize_t n = 0;
212
213 if (!ldata->icanon)
Peter Hurley70aca712015-01-16 15:05:37 -0500214 n = ldata->commit_head - ldata->read_tail;
Peter Hurley9a4aec22013-06-15 09:14:32 -0400215 else
216 n = ldata->canon_head - ldata->read_tail;
217 return n;
218}
219
Peter Hurleyee0bab82013-06-15 09:14:34 -0400220/**
221 * n_tty_write_wakeup - asynchronous I/O notifier
222 * @tty: tty device
223 *
224 * Required for the ptys, serial driver etc. since processes
225 * that attach themselves to the master and rely on ASYNC
226 * IO must be woken up
227 */
228
229static void n_tty_write_wakeup(struct tty_struct *tty)
230{
231 if (tty->fasync && test_and_clear_bit(TTY_DO_WRITE_WAKEUP, &tty->flags))
232 kill_fasync(&tty->fasync, SIGIO, POLL_OUT);
233}
234
Peter Hurley4a23a4d2013-06-15 10:21:22 -0400235static void n_tty_check_throttle(struct tty_struct *tty)
Peter Hurley6367ca72013-06-15 09:14:33 -0400236{
Peter Hurleya3428462015-01-16 15:05:35 -0500237 struct n_tty_data *ldata = tty->disc_data;
238
Peter Hurley6367ca72013-06-15 09:14:33 -0400239 /*
240 * Check the remaining room for the input canonicalization
241 * mode. We don't want to throttle the driver if we're in
242 * canonical mode and don't have a newline yet!
243 */
Peter Hurleya3428462015-01-16 15:05:35 -0500244 if (ldata->icanon && ldata->canon_head == ldata->read_tail)
245 return;
246
Peter Hurley6367ca72013-06-15 09:14:33 -0400247 while (1) {
248 int throttled;
249 tty_set_flow_change(tty, TTY_THROTTLE_SAFE);
Peter Hurley5e28cca2015-01-16 15:05:36 -0500250 if (N_TTY_BUF_SIZE - read_cnt(ldata) >= TTY_THRESHOLD_THROTTLE)
Peter Hurley6367ca72013-06-15 09:14:33 -0400251 break;
252 throttled = tty_throttle_safe(tty);
253 if (!throttled)
254 break;
255 }
256 __tty_set_flow_change(tty, 0);
257}
258
Peter Hurley4b293492013-07-24 08:29:55 -0400259static void n_tty_check_unthrottle(struct tty_struct *tty)
Peter Hurley6367ca72013-06-15 09:14:33 -0400260{
Peter Hurley3afb1b392013-07-23 08:47:30 -0400261 if (tty->driver->type == TTY_DRIVER_TYPE_PTY &&
262 tty->link->ldisc->ops->write_wakeup == n_tty_write_wakeup) {
263 if (chars_in_buffer(tty) > TTY_THRESHOLD_UNTHROTTLE)
264 return;
265 if (!tty->count)
266 return;
Peter Hurley2c5dc462015-01-16 15:05:34 -0500267 n_tty_kick_worker(tty);
Peter Hurley3afb1b392013-07-23 08:47:30 -0400268 n_tty_write_wakeup(tty->link);
Peter Hurley6c677162013-12-02 14:24:46 -0500269 if (waitqueue_active(&tty->link->write_wait))
270 wake_up_interruptible_poll(&tty->link->write_wait, POLLOUT);
Peter Hurley3afb1b392013-07-23 08:47:30 -0400271 return;
272 }
273
Peter Hurley6367ca72013-06-15 09:14:33 -0400274 /* If there is enough space in the read buffer now, let the
275 * low-level driver know. We use chars_in_buffer() to
276 * check the buffer, as it now knows about canonical mode.
277 * Otherwise, if the driver is throttled and the line is
278 * longer than TTY_THRESHOLD_UNTHROTTLE in canonical mode,
279 * we won't get any more characters.
280 */
281
282 while (1) {
283 int unthrottled;
284 tty_set_flow_change(tty, TTY_UNTHROTTLE_SAFE);
285 if (chars_in_buffer(tty) > TTY_THRESHOLD_UNTHROTTLE)
286 break;
287 if (!tty->count)
288 break;
Peter Hurley2c5dc462015-01-16 15:05:34 -0500289 n_tty_kick_worker(tty);
Peter Hurley6367ca72013-06-15 09:14:33 -0400290 unthrottled = tty_unthrottle_safe(tty);
291 if (!unthrottled)
292 break;
293 }
294 __tty_set_flow_change(tty, 0);
295}
296
Alan Cox17b82062008-10-13 10:45:06 +0100297/**
298 * put_tty_queue - add character to tty
299 * @c: character
Jiri Slaby57c94122012-10-18 22:26:43 +0200300 * @ldata: n_tty data
Alan Cox17b82062008-10-13 10:45:06 +0100301 *
Peter Hurley6d76bd22013-06-15 09:14:26 -0400302 * Add a character to the tty read_buf queue.
303 *
304 * n_tty_receive_buf()/producer path:
305 * caller holds non-exclusive termios_rwsem
Alan Cox17b82062008-10-13 10:45:06 +0100306 */
307
Peter Hurley19e2ad62013-07-24 08:29:54 -0400308static inline void put_tty_queue(unsigned char c, struct n_tty_data *ldata)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700309{
Christian Riesch8bfbe2d2014-11-13 05:53:26 +0100310 *read_buf_addr(ldata, ldata->read_head) = c;
311 ldata->read_head++;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700312}
313
314/**
Linus Torvalds1da177e2005-04-16 15:20:36 -0700315 * reset_buffer_flags - reset buffer state
316 * @tty: terminal to reset
317 *
Peter Hurley25518c62013-03-11 16:44:31 -0400318 * Reset the read buffer counters and clear the flags.
319 * Called from n_tty_open() and n_tty_flush_buffer().
Alan Cox17b82062008-10-13 10:45:06 +0100320 *
Peter Hurley6d76bd22013-06-15 09:14:26 -0400321 * Locking: caller holds exclusive termios_rwsem
322 * (or locking is not required)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700323 */
Joe Petersona88a69c2009-01-02 13:40:53 +0000324
Peter Hurleyb66f4fa2013-03-11 16:44:32 -0400325static void reset_buffer_flags(struct n_tty_data *ldata)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700326{
Peter Hurleya73d3d62013-06-15 09:14:25 -0400327 ldata->read_head = ldata->canon_head = ldata->read_tail = 0;
Peter Hurley17bd7902013-06-15 10:04:24 -0400328 ldata->echo_head = ldata->echo_tail = ldata->echo_commit = 0;
Peter Hurley70aca712015-01-16 15:05:37 -0500329 ldata->commit_head = 0;
Peter Hurley1075a6e2013-12-09 18:06:07 -0500330 ldata->echo_mark = 0;
Peter Hurley40d5e092013-06-15 10:21:17 -0400331 ldata->line_start = 0;
Joe Petersona88a69c2009-01-02 13:40:53 +0000332
Peter Hurleya73d3d62013-06-15 09:14:25 -0400333 ldata->erasing = 0;
Jiri Slaby3fe780b2012-10-18 22:26:40 +0200334 bitmap_zero(ldata->read_flags, N_TTY_BUF_SIZE);
Peter Hurley4d0ed182013-12-10 17:12:02 -0500335 ldata->push = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700336}
337
Peter Hurleya30737a2013-03-11 16:44:22 -0400338static void n_tty_packet_mode_flush(struct tty_struct *tty)
339{
340 unsigned long flags;
341
Peter Hurleya30737a2013-03-11 16:44:22 -0400342 if (tty->link->packet) {
Peter Hurley54e8e5f2014-10-16 15:33:26 -0400343 spin_lock_irqsave(&tty->ctrl_lock, flags);
Peter Hurleya30737a2013-03-11 16:44:22 -0400344 tty->ctrl_status |= TIOCPKT_FLUSHREAD;
Peter Hurley54e8e5f2014-10-16 15:33:26 -0400345 spin_unlock_irqrestore(&tty->ctrl_lock, flags);
Peter Hurley6c677162013-12-02 14:24:46 -0500346 if (waitqueue_active(&tty->link->read_wait))
347 wake_up_interruptible(&tty->link->read_wait);
Peter Hurleya30737a2013-03-11 16:44:22 -0400348 }
Peter Hurleya30737a2013-03-11 16:44:22 -0400349}
350
Linus Torvalds1da177e2005-04-16 15:20:36 -0700351/**
352 * n_tty_flush_buffer - clean input queue
353 * @tty: terminal device
354 *
Peter Hurley25518c62013-03-11 16:44:31 -0400355 * Flush the input buffer. Called when the tty layer wants the
356 * buffer flushed (eg at hangup) or when the N_TTY line discipline
357 * internally has to clean the pending queue (for example some signals).
Linus Torvalds1da177e2005-04-16 15:20:36 -0700358 *
Peter Hurley6d76bd22013-06-15 09:14:26 -0400359 * Holds termios_rwsem to exclude producer/consumer while
360 * buffer indices are reset.
361 *
362 * Locking: ctrl_lock, exclusive termios_rwsem
Linus Torvalds1da177e2005-04-16 15:20:36 -0700363 */
Alan Cox4edf1822008-02-08 04:18:44 -0800364
365static void n_tty_flush_buffer(struct tty_struct *tty)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700366{
Peter Hurley6d76bd22013-06-15 09:14:26 -0400367 down_write(&tty->termios_rwsem);
Peter Hurleyb66f4fa2013-03-11 16:44:32 -0400368 reset_buffer_flags(tty->disc_data);
Peter Hurley2c5dc462015-01-16 15:05:34 -0500369 n_tty_kick_worker(tty);
Alan Cox4edf1822008-02-08 04:18:44 -0800370
Peter Hurleya30737a2013-03-11 16:44:22 -0400371 if (tty->link)
372 n_tty_packet_mode_flush(tty);
Peter Hurley6d76bd22013-06-15 09:14:26 -0400373 up_write(&tty->termios_rwsem);
374}
375
Linus Torvalds1da177e2005-04-16 15:20:36 -0700376/**
377 * n_tty_chars_in_buffer - report available bytes
378 * @tty: tty device
379 *
380 * Report the number of characters buffered to be delivered to user
Alan Cox4edf1822008-02-08 04:18:44 -0800381 * at this instant in time.
Alan Cox17b82062008-10-13 10:45:06 +0100382 *
Peter Hurley6d76bd22013-06-15 09:14:26 -0400383 * Locking: exclusive termios_rwsem
Linus Torvalds1da177e2005-04-16 15:20:36 -0700384 */
Alan Cox4edf1822008-02-08 04:18:44 -0800385
Peter Hurleya19d0c62013-06-15 09:14:18 -0400386static ssize_t n_tty_chars_in_buffer(struct tty_struct *tty)
387{
Peter Hurley6d76bd22013-06-15 09:14:26 -0400388 ssize_t n;
389
Peter Hurley47534082013-06-15 09:14:19 -0400390 WARN_ONCE(1, "%s is deprecated and scheduled for removal.", __func__);
Peter Hurley6d76bd22013-06-15 09:14:26 -0400391
392 down_write(&tty->termios_rwsem);
393 n = chars_in_buffer(tty);
394 up_write(&tty->termios_rwsem);
395 return n;
Peter Hurleya19d0c62013-06-15 09:14:18 -0400396}
397
Linus Torvalds1da177e2005-04-16 15:20:36 -0700398/**
399 * is_utf8_continuation - utf8 multibyte check
400 * @c: byte to check
401 *
402 * Returns true if the utf8 character 'c' is a multibyte continuation
403 * character. We use this to correctly compute the on screen size
404 * of the character when printing
405 */
Alan Cox4edf1822008-02-08 04:18:44 -0800406
Linus Torvalds1da177e2005-04-16 15:20:36 -0700407static inline int is_utf8_continuation(unsigned char c)
408{
409 return (c & 0xc0) == 0x80;
410}
411
412/**
413 * is_continuation - multibyte check
414 * @c: byte to check
415 *
416 * Returns true if the utf8 character 'c' is a multibyte continuation
417 * character and the terminal is in unicode mode.
418 */
Alan Cox4edf1822008-02-08 04:18:44 -0800419
Linus Torvalds1da177e2005-04-16 15:20:36 -0700420static inline int is_continuation(unsigned char c, struct tty_struct *tty)
421{
422 return I_IUTF8(tty) && is_utf8_continuation(c);
423}
424
425/**
Joe Petersona88a69c2009-01-02 13:40:53 +0000426 * do_output_char - output one character
427 * @c: character (or partial unicode symbol)
428 * @tty: terminal device
429 * @space: space available in tty driver write buffer
430 *
431 * This is a helper function that handles one output character
432 * (including special characters like TAB, CR, LF, etc.),
Joe Petersonee5aa7b2009-09-09 15:03:13 -0600433 * doing OPOST processing and putting the results in the
434 * tty driver's write buffer.
Joe Petersona88a69c2009-01-02 13:40:53 +0000435 *
436 * Note that Linux currently ignores TABDLY, CRDLY, VTDLY, FFDLY
437 * and NLDLY. They simply aren't relevant in the world today.
438 * If you ever need them, add them here.
439 *
440 * Returns the number of bytes of buffer space used or -1 if
441 * no space left.
442 *
443 * Locking: should be called under the output_lock to protect
444 * the column state and space left in the buffer
445 */
446
447static int do_output_char(unsigned char c, struct tty_struct *tty, int space)
448{
Jiri Slaby53c5ee22012-10-18 22:26:39 +0200449 struct n_tty_data *ldata = tty->disc_data;
Joe Petersona88a69c2009-01-02 13:40:53 +0000450 int spaces;
451
452 if (!space)
453 return -1;
Alan Cox300a6202009-01-02 13:41:04 +0000454
Joe Petersona88a69c2009-01-02 13:40:53 +0000455 switch (c) {
456 case '\n':
457 if (O_ONLRET(tty))
Jiri Slaby53c5ee22012-10-18 22:26:39 +0200458 ldata->column = 0;
Joe Petersona88a69c2009-01-02 13:40:53 +0000459 if (O_ONLCR(tty)) {
460 if (space < 2)
461 return -1;
Jiri Slabyba2e68a2012-10-18 22:26:41 +0200462 ldata->canon_column = ldata->column = 0;
Linus Torvalds37f81fa2009-09-05 12:46:07 -0700463 tty->ops->write(tty, "\r\n", 2);
Joe Petersona88a69c2009-01-02 13:40:53 +0000464 return 2;
465 }
Jiri Slabyba2e68a2012-10-18 22:26:41 +0200466 ldata->canon_column = ldata->column;
Joe Petersona88a69c2009-01-02 13:40:53 +0000467 break;
468 case '\r':
Jiri Slaby53c5ee22012-10-18 22:26:39 +0200469 if (O_ONOCR(tty) && ldata->column == 0)
Joe Petersona88a69c2009-01-02 13:40:53 +0000470 return 0;
471 if (O_OCRNL(tty)) {
472 c = '\n';
473 if (O_ONLRET(tty))
Jiri Slabyba2e68a2012-10-18 22:26:41 +0200474 ldata->canon_column = ldata->column = 0;
Joe Petersona88a69c2009-01-02 13:40:53 +0000475 break;
476 }
Jiri Slabyba2e68a2012-10-18 22:26:41 +0200477 ldata->canon_column = ldata->column = 0;
Joe Petersona88a69c2009-01-02 13:40:53 +0000478 break;
479 case '\t':
Jiri Slaby53c5ee22012-10-18 22:26:39 +0200480 spaces = 8 - (ldata->column & 7);
Joe Petersona88a69c2009-01-02 13:40:53 +0000481 if (O_TABDLY(tty) == XTABS) {
482 if (space < spaces)
483 return -1;
Jiri Slaby53c5ee22012-10-18 22:26:39 +0200484 ldata->column += spaces;
Joe Petersona88a69c2009-01-02 13:40:53 +0000485 tty->ops->write(tty, " ", spaces);
486 return spaces;
487 }
Jiri Slaby53c5ee22012-10-18 22:26:39 +0200488 ldata->column += spaces;
Joe Petersona88a69c2009-01-02 13:40:53 +0000489 break;
490 case '\b':
Jiri Slaby53c5ee22012-10-18 22:26:39 +0200491 if (ldata->column > 0)
492 ldata->column--;
Joe Petersona88a69c2009-01-02 13:40:53 +0000493 break;
494 default:
Joe Petersona59c0d62009-01-02 13:43:25 +0000495 if (!iscntrl(c)) {
496 if (O_OLCUC(tty))
497 c = toupper(c);
498 if (!is_continuation(c, tty))
Jiri Slaby53c5ee22012-10-18 22:26:39 +0200499 ldata->column++;
Joe Petersona59c0d62009-01-02 13:43:25 +0000500 }
Joe Petersona88a69c2009-01-02 13:40:53 +0000501 break;
502 }
503
504 tty_put_char(tty, c);
505 return 1;
506}
507
508/**
509 * process_output - output post processor
Linus Torvalds1da177e2005-04-16 15:20:36 -0700510 * @c: character (or partial unicode symbol)
511 * @tty: terminal device
512 *
Joe Petersonee5aa7b2009-09-09 15:03:13 -0600513 * Output one character with OPOST processing.
514 * Returns -1 when the output device is full and the character
515 * must be retried.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700516 *
Joe Petersona88a69c2009-01-02 13:40:53 +0000517 * Locking: output_lock to protect column state and space left
518 * (also, this is called from n_tty_write under the
519 * tty layer write lock)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700520 */
Alan Cox4edf1822008-02-08 04:18:44 -0800521
Joe Petersona88a69c2009-01-02 13:40:53 +0000522static int process_output(unsigned char c, struct tty_struct *tty)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700523{
Jiri Slabybddc7152012-10-18 22:26:42 +0200524 struct n_tty_data *ldata = tty->disc_data;
Joe Petersona88a69c2009-01-02 13:40:53 +0000525 int space, retval;
526
Jiri Slabybddc7152012-10-18 22:26:42 +0200527 mutex_lock(&ldata->output_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700528
Alan Coxf34d7a52008-04-30 00:54:13 -0700529 space = tty_write_room(tty);
Joe Petersona88a69c2009-01-02 13:40:53 +0000530 retval = do_output_char(c, tty, space);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700531
Jiri Slabybddc7152012-10-18 22:26:42 +0200532 mutex_unlock(&ldata->output_lock);
Joe Petersona88a69c2009-01-02 13:40:53 +0000533 if (retval < 0)
534 return -1;
535 else
536 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700537}
538
539/**
Joe Petersona88a69c2009-01-02 13:40:53 +0000540 * process_output_block - block post processor
Linus Torvalds1da177e2005-04-16 15:20:36 -0700541 * @tty: terminal device
Joe Petersonee5aa7b2009-09-09 15:03:13 -0600542 * @buf: character buffer
543 * @nr: number of bytes to output
544 *
545 * Output a block of characters with OPOST processing.
546 * Returns the number of characters output.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700547 *
548 * This path is used to speed up block console writes, among other
549 * things when processing blocks of output data. It handles only
550 * the simple cases normally found and helps to generate blocks of
551 * symbols for the console driver and thus improve performance.
552 *
Joe Petersona88a69c2009-01-02 13:40:53 +0000553 * Locking: output_lock to protect column state and space left
554 * (also, this is called from n_tty_write under the
555 * tty layer write lock)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700556 */
Alan Cox4edf1822008-02-08 04:18:44 -0800557
Joe Petersona88a69c2009-01-02 13:40:53 +0000558static ssize_t process_output_block(struct tty_struct *tty,
559 const unsigned char *buf, unsigned int nr)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700560{
Jiri Slaby53c5ee22012-10-18 22:26:39 +0200561 struct n_tty_data *ldata = tty->disc_data;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700562 int space;
Thorsten Wißmannbbd20752011-12-08 17:47:33 +0100563 int i;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700564 const unsigned char *cp;
565
Jiri Slabybddc7152012-10-18 22:26:42 +0200566 mutex_lock(&ldata->output_lock);
Joe Petersona88a69c2009-01-02 13:40:53 +0000567
Alan Coxf34d7a52008-04-30 00:54:13 -0700568 space = tty_write_room(tty);
Alan Cox300a6202009-01-02 13:41:04 +0000569 if (!space) {
Jiri Slabybddc7152012-10-18 22:26:42 +0200570 mutex_unlock(&ldata->output_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700571 return 0;
Joe Petersona88a69c2009-01-02 13:40:53 +0000572 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700573 if (nr > space)
574 nr = space;
575
576 for (i = 0, cp = buf; i < nr; i++, cp++) {
Joe Petersona59c0d62009-01-02 13:43:25 +0000577 unsigned char c = *cp;
578
579 switch (c) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700580 case '\n':
581 if (O_ONLRET(tty))
Jiri Slaby53c5ee22012-10-18 22:26:39 +0200582 ldata->column = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700583 if (O_ONLCR(tty))
584 goto break_out;
Jiri Slabyba2e68a2012-10-18 22:26:41 +0200585 ldata->canon_column = ldata->column;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700586 break;
587 case '\r':
Jiri Slaby53c5ee22012-10-18 22:26:39 +0200588 if (O_ONOCR(tty) && ldata->column == 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700589 goto break_out;
590 if (O_OCRNL(tty))
591 goto break_out;
Jiri Slabyba2e68a2012-10-18 22:26:41 +0200592 ldata->canon_column = ldata->column = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700593 break;
594 case '\t':
595 goto break_out;
596 case '\b':
Jiri Slaby53c5ee22012-10-18 22:26:39 +0200597 if (ldata->column > 0)
598 ldata->column--;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700599 break;
600 default:
Joe Petersona59c0d62009-01-02 13:43:25 +0000601 if (!iscntrl(c)) {
602 if (O_OLCUC(tty))
603 goto break_out;
604 if (!is_continuation(c, tty))
Jiri Slaby53c5ee22012-10-18 22:26:39 +0200605 ldata->column++;
Joe Petersona59c0d62009-01-02 13:43:25 +0000606 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700607 break;
608 }
609 }
610break_out:
Alan Coxf34d7a52008-04-30 00:54:13 -0700611 i = tty->ops->write(tty, buf, i);
Joe Petersona88a69c2009-01-02 13:40:53 +0000612
Jiri Slabybddc7152012-10-18 22:26:42 +0200613 mutex_unlock(&ldata->output_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700614 return i;
615}
616
Joe Petersona88a69c2009-01-02 13:40:53 +0000617/**
618 * process_echoes - write pending echo characters
619 * @tty: terminal device
620 *
621 * Write previously buffered echo (and other ldisc-generated)
622 * characters to the tty.
623 *
624 * Characters generated by the ldisc (including echoes) need to
625 * be buffered because the driver's write buffer can fill during
626 * heavy program output. Echoing straight to the driver will
627 * often fail under these conditions, causing lost characters and
628 * resulting mismatches of ldisc state information.
629 *
630 * Since the ldisc state must represent the characters actually sent
631 * to the driver at the time of the write, operations like certain
632 * changes in column state are also saved in the buffer and executed
633 * here.
634 *
635 * A circular fifo buffer is used so that the most recent characters
636 * are prioritized. Also, when control characters are echoed with a
637 * prefixed "^", the pair is treated atomically and thus not separated.
638 *
Peter Hurley019ebdf2013-06-15 10:04:25 -0400639 * Locking: callers must hold output_lock
Joe Petersona88a69c2009-01-02 13:40:53 +0000640 */
641
Peter Hurleybc5b1ec2013-06-15 10:04:27 -0400642static size_t __process_echoes(struct tty_struct *tty)
Joe Petersona88a69c2009-01-02 13:40:53 +0000643{
Jiri Slaby53c5ee22012-10-18 22:26:39 +0200644 struct n_tty_data *ldata = tty->disc_data;
Peter Hurleybc5b1ec2013-06-15 10:04:27 -0400645 int space, old_space;
Peter Hurleyaddaebc2013-06-15 10:04:22 -0400646 size_t tail;
Joe Petersona88a69c2009-01-02 13:40:53 +0000647 unsigned char c;
Joe Petersona88a69c2009-01-02 13:40:53 +0000648
Peter Hurleybc5b1ec2013-06-15 10:04:27 -0400649 old_space = space = tty_write_room(tty);
Joe Petersona88a69c2009-01-02 13:40:53 +0000650
Peter Hurleyaddaebc2013-06-15 10:04:22 -0400651 tail = ldata->echo_tail;
Peter Hurley29c7c5c2013-06-15 10:04:28 -0400652 while (ldata->echo_commit != tail) {
Peter Hurleyaddaebc2013-06-15 10:04:22 -0400653 c = echo_buf(ldata, tail);
Joe Petersona88a69c2009-01-02 13:40:53 +0000654 if (c == ECHO_OP_START) {
655 unsigned char op;
Joe Petersona88a69c2009-01-02 13:40:53 +0000656 int no_space_left = 0;
657
658 /*
659 * If the buffer byte is the start of a multi-byte
660 * operation, get the next byte, which is either the
661 * op code or a control character value.
662 */
Peter Hurleyaddaebc2013-06-15 10:04:22 -0400663 op = echo_buf(ldata, tail + 1);
Alan Cox300a6202009-01-02 13:41:04 +0000664
Joe Petersona88a69c2009-01-02 13:40:53 +0000665 switch (op) {
666 unsigned int num_chars, num_bs;
667
668 case ECHO_OP_ERASE_TAB:
Peter Hurleyaddaebc2013-06-15 10:04:22 -0400669 num_chars = echo_buf(ldata, tail + 2);
Joe Petersona88a69c2009-01-02 13:40:53 +0000670
671 /*
672 * Determine how many columns to go back
673 * in order to erase the tab.
674 * This depends on the number of columns
675 * used by other characters within the tab
676 * area. If this (modulo 8) count is from
677 * the start of input rather than from a
678 * previous tab, we offset by canon column.
679 * Otherwise, tab spacing is normal.
680 */
681 if (!(num_chars & 0x80))
Jiri Slabyba2e68a2012-10-18 22:26:41 +0200682 num_chars += ldata->canon_column;
Joe Petersona88a69c2009-01-02 13:40:53 +0000683 num_bs = 8 - (num_chars & 7);
684
685 if (num_bs > space) {
686 no_space_left = 1;
687 break;
688 }
689 space -= num_bs;
690 while (num_bs--) {
691 tty_put_char(tty, '\b');
Jiri Slaby53c5ee22012-10-18 22:26:39 +0200692 if (ldata->column > 0)
693 ldata->column--;
Joe Petersona88a69c2009-01-02 13:40:53 +0000694 }
Peter Hurleyaddaebc2013-06-15 10:04:22 -0400695 tail += 3;
Joe Petersona88a69c2009-01-02 13:40:53 +0000696 break;
697
698 case ECHO_OP_SET_CANON_COL:
Jiri Slabyba2e68a2012-10-18 22:26:41 +0200699 ldata->canon_column = ldata->column;
Peter Hurleyaddaebc2013-06-15 10:04:22 -0400700 tail += 2;
Joe Petersona88a69c2009-01-02 13:40:53 +0000701 break;
702
703 case ECHO_OP_MOVE_BACK_COL:
Jiri Slaby53c5ee22012-10-18 22:26:39 +0200704 if (ldata->column > 0)
705 ldata->column--;
Peter Hurleyaddaebc2013-06-15 10:04:22 -0400706 tail += 2;
Joe Petersona88a69c2009-01-02 13:40:53 +0000707 break;
708
709 case ECHO_OP_START:
710 /* This is an escaped echo op start code */
711 if (!space) {
712 no_space_left = 1;
713 break;
714 }
715 tty_put_char(tty, ECHO_OP_START);
Jiri Slaby53c5ee22012-10-18 22:26:39 +0200716 ldata->column++;
Joe Petersona88a69c2009-01-02 13:40:53 +0000717 space--;
Peter Hurleyaddaebc2013-06-15 10:04:22 -0400718 tail += 2;
Joe Petersona88a69c2009-01-02 13:40:53 +0000719 break;
720
721 default:
Joe Petersona88a69c2009-01-02 13:40:53 +0000722 /*
Joe Peterson62b26352009-09-09 15:03:47 -0600723 * If the op is not a special byte code,
724 * it is a ctrl char tagged to be echoed
725 * as "^X" (where X is the letter
726 * representing the control char).
727 * Note that we must ensure there is
728 * enough space for the whole ctrl pair.
729 *
Joe Petersona88a69c2009-01-02 13:40:53 +0000730 */
Joe Peterson62b26352009-09-09 15:03:47 -0600731 if (space < 2) {
732 no_space_left = 1;
733 break;
734 }
735 tty_put_char(tty, '^');
736 tty_put_char(tty, op ^ 0100);
Jiri Slaby53c5ee22012-10-18 22:26:39 +0200737 ldata->column += 2;
Joe Peterson62b26352009-09-09 15:03:47 -0600738 space -= 2;
Peter Hurleyaddaebc2013-06-15 10:04:22 -0400739 tail += 2;
Joe Petersona88a69c2009-01-02 13:40:53 +0000740 }
741
742 if (no_space_left)
743 break;
744 } else {
Peter Hurley582f5592013-05-17 12:49:48 -0400745 if (O_OPOST(tty)) {
Joe Petersonee5aa7b2009-09-09 15:03:13 -0600746 int retval = do_output_char(c, tty, space);
747 if (retval < 0)
748 break;
749 space -= retval;
750 } else {
751 if (!space)
752 break;
753 tty_put_char(tty, c);
754 space -= 1;
755 }
Peter Hurleyaddaebc2013-06-15 10:04:22 -0400756 tail += 1;
Joe Petersona88a69c2009-01-02 13:40:53 +0000757 }
Joe Petersona88a69c2009-01-02 13:40:53 +0000758 }
759
Peter Hurleycbfd0342013-06-15 10:04:26 -0400760 /* If the echo buffer is nearly full (so that the possibility exists
761 * of echo overrun before the next commit), then discard enough
762 * data at the tail to prevent a subsequent overrun */
763 while (ldata->echo_commit - tail >= ECHO_DISCARD_WATERMARK) {
Roel Kluinc476f652013-10-11 22:08:49 +0200764 if (echo_buf(ldata, tail) == ECHO_OP_START) {
Peter Hurley6f222532013-11-08 09:42:18 -0500765 if (echo_buf(ldata, tail + 1) == ECHO_OP_ERASE_TAB)
Peter Hurleycbfd0342013-06-15 10:04:26 -0400766 tail += 3;
767 else
768 tail += 2;
769 } else
770 tail++;
771 }
772
Peter Hurleyaddaebc2013-06-15 10:04:22 -0400773 ldata->echo_tail = tail;
Peter Hurleybc5b1ec2013-06-15 10:04:27 -0400774 return old_space - space;
Joe Petersona88a69c2009-01-02 13:40:53 +0000775}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700776
Peter Hurley17bd7902013-06-15 10:04:24 -0400777static void commit_echoes(struct tty_struct *tty)
778{
779 struct n_tty_data *ldata = tty->disc_data;
Peter Hurleybc5b1ec2013-06-15 10:04:27 -0400780 size_t nr, old, echoed;
Peter Hurleycbfd0342013-06-15 10:04:26 -0400781 size_t head;
782
783 head = ldata->echo_head;
Peter Hurley1075a6e2013-12-09 18:06:07 -0500784 ldata->echo_mark = head;
Peter Hurleycbfd0342013-06-15 10:04:26 -0400785 old = ldata->echo_commit - ldata->echo_tail;
786
787 /* Process committed echoes if the accumulated # of bytes
788 * is over the threshold (and try again each time another
789 * block is accumulated) */
790 nr = head - ldata->echo_tail;
791 if (nr < ECHO_COMMIT_WATERMARK || (nr % ECHO_BLOCK > old % ECHO_BLOCK))
792 return;
Peter Hurley17bd7902013-06-15 10:04:24 -0400793
Peter Hurley019ebdf2013-06-15 10:04:25 -0400794 mutex_lock(&ldata->output_lock);
Peter Hurleycbfd0342013-06-15 10:04:26 -0400795 ldata->echo_commit = head;
Peter Hurleybc5b1ec2013-06-15 10:04:27 -0400796 echoed = __process_echoes(tty);
Peter Hurley019ebdf2013-06-15 10:04:25 -0400797 mutex_unlock(&ldata->output_lock);
798
Peter Hurleybc5b1ec2013-06-15 10:04:27 -0400799 if (echoed && tty->ops->flush_chars)
Peter Hurley019ebdf2013-06-15 10:04:25 -0400800 tty->ops->flush_chars(tty);
801}
802
803static void process_echoes(struct tty_struct *tty)
804{
805 struct n_tty_data *ldata = tty->disc_data;
Peter Hurleybc5b1ec2013-06-15 10:04:27 -0400806 size_t echoed;
Peter Hurley019ebdf2013-06-15 10:04:25 -0400807
Peter Hurleye2613be2014-02-11 16:34:55 -0500808 if (ldata->echo_mark == ldata->echo_tail)
Peter Hurley019ebdf2013-06-15 10:04:25 -0400809 return;
810
811 mutex_lock(&ldata->output_lock);
Peter Hurley1075a6e2013-12-09 18:06:07 -0500812 ldata->echo_commit = ldata->echo_mark;
Peter Hurleybc5b1ec2013-06-15 10:04:27 -0400813 echoed = __process_echoes(tty);
Peter Hurley019ebdf2013-06-15 10:04:25 -0400814 mutex_unlock(&ldata->output_lock);
815
Peter Hurleybc5b1ec2013-06-15 10:04:27 -0400816 if (echoed && tty->ops->flush_chars)
Peter Hurley019ebdf2013-06-15 10:04:25 -0400817 tty->ops->flush_chars(tty);
Peter Hurley17bd7902013-06-15 10:04:24 -0400818}
819
Peter Hurley1075a6e2013-12-09 18:06:07 -0500820/* NB: echo_mark and echo_head should be equivalent here */
Peter Hurleycbfd0342013-06-15 10:04:26 -0400821static void flush_echoes(struct tty_struct *tty)
822{
823 struct n_tty_data *ldata = tty->disc_data;
824
Peter Hurley39434ab2013-11-29 12:56:10 -0500825 if ((!L_ECHO(tty) && !L_ECHONL(tty)) ||
826 ldata->echo_commit == ldata->echo_head)
Peter Hurleycbfd0342013-06-15 10:04:26 -0400827 return;
828
829 mutex_lock(&ldata->output_lock);
830 ldata->echo_commit = ldata->echo_head;
831 __process_echoes(tty);
832 mutex_unlock(&ldata->output_lock);
833}
834
Linus Torvalds1da177e2005-04-16 15:20:36 -0700835/**
Joe Petersona88a69c2009-01-02 13:40:53 +0000836 * add_echo_byte - add a byte to the echo buffer
837 * @c: unicode byte to echo
Jiri Slaby57c94122012-10-18 22:26:43 +0200838 * @ldata: n_tty data
Joe Petersona88a69c2009-01-02 13:40:53 +0000839 *
840 * Add a character or operation byte to the echo buffer.
Joe Petersona88a69c2009-01-02 13:40:53 +0000841 */
842
Peter Hurleycbfd0342013-06-15 10:04:26 -0400843static inline void add_echo_byte(unsigned char c, struct n_tty_data *ldata)
Joe Petersona88a69c2009-01-02 13:40:53 +0000844{
Peter Hurleyaddaebc2013-06-15 10:04:22 -0400845 *echo_buf_addr(ldata, ldata->echo_head++) = c;
Joe Petersona88a69c2009-01-02 13:40:53 +0000846}
847
848/**
849 * echo_move_back_col - add operation to move back a column
Jiri Slaby57c94122012-10-18 22:26:43 +0200850 * @ldata: n_tty data
Joe Petersona88a69c2009-01-02 13:40:53 +0000851 *
852 * Add an operation to the echo buffer to move back one column.
Joe Petersona88a69c2009-01-02 13:40:53 +0000853 */
854
Jiri Slaby57c94122012-10-18 22:26:43 +0200855static void echo_move_back_col(struct n_tty_data *ldata)
Joe Petersona88a69c2009-01-02 13:40:53 +0000856{
Jiri Slaby57c94122012-10-18 22:26:43 +0200857 add_echo_byte(ECHO_OP_START, ldata);
858 add_echo_byte(ECHO_OP_MOVE_BACK_COL, ldata);
Joe Petersona88a69c2009-01-02 13:40:53 +0000859}
860
861/**
862 * echo_set_canon_col - add operation to set the canon column
Jiri Slaby57c94122012-10-18 22:26:43 +0200863 * @ldata: n_tty data
Joe Petersona88a69c2009-01-02 13:40:53 +0000864 *
865 * Add an operation to the echo buffer to set the canon column
866 * to the current column.
Joe Petersona88a69c2009-01-02 13:40:53 +0000867 */
868
Jiri Slaby57c94122012-10-18 22:26:43 +0200869static void echo_set_canon_col(struct n_tty_data *ldata)
Joe Petersona88a69c2009-01-02 13:40:53 +0000870{
Jiri Slaby57c94122012-10-18 22:26:43 +0200871 add_echo_byte(ECHO_OP_START, ldata);
872 add_echo_byte(ECHO_OP_SET_CANON_COL, ldata);
Joe Petersona88a69c2009-01-02 13:40:53 +0000873}
874
875/**
876 * echo_erase_tab - add operation to erase a tab
877 * @num_chars: number of character columns already used
878 * @after_tab: true if num_chars starts after a previous tab
Jiri Slaby57c94122012-10-18 22:26:43 +0200879 * @ldata: n_tty data
Joe Petersona88a69c2009-01-02 13:40:53 +0000880 *
881 * Add an operation to the echo buffer to erase a tab.
882 *
883 * Called by the eraser function, which knows how many character
884 * columns have been used since either a previous tab or the start
885 * of input. This information will be used later, along with
886 * canon column (if applicable), to go back the correct number
887 * of columns.
Joe Petersona88a69c2009-01-02 13:40:53 +0000888 */
889
890static void echo_erase_tab(unsigned int num_chars, int after_tab,
Jiri Slaby57c94122012-10-18 22:26:43 +0200891 struct n_tty_data *ldata)
Joe Petersona88a69c2009-01-02 13:40:53 +0000892{
Jiri Slaby57c94122012-10-18 22:26:43 +0200893 add_echo_byte(ECHO_OP_START, ldata);
894 add_echo_byte(ECHO_OP_ERASE_TAB, ldata);
Joe Petersona88a69c2009-01-02 13:40:53 +0000895
896 /* We only need to know this modulo 8 (tab spacing) */
897 num_chars &= 7;
898
899 /* Set the high bit as a flag if num_chars is after a previous tab */
900 if (after_tab)
901 num_chars |= 0x80;
Alan Cox300a6202009-01-02 13:41:04 +0000902
Jiri Slaby57c94122012-10-18 22:26:43 +0200903 add_echo_byte(num_chars, ldata);
Joe Petersona88a69c2009-01-02 13:40:53 +0000904}
905
906/**
907 * echo_char_raw - echo a character raw
Linus Torvalds1da177e2005-04-16 15:20:36 -0700908 * @c: unicode byte to echo
909 * @tty: terminal device
910 *
Alan Cox4edf1822008-02-08 04:18:44 -0800911 * Echo user input back onto the screen. This must be called only when
Linus Torvalds1da177e2005-04-16 15:20:36 -0700912 * L_ECHO(tty) is true. Called from the driver receive_buf path.
Alan Cox17b82062008-10-13 10:45:06 +0100913 *
Joe Petersona88a69c2009-01-02 13:40:53 +0000914 * This variant does not treat control characters specially.
Joe Petersona88a69c2009-01-02 13:40:53 +0000915 */
916
Jiri Slaby57c94122012-10-18 22:26:43 +0200917static void echo_char_raw(unsigned char c, struct n_tty_data *ldata)
Joe Petersona88a69c2009-01-02 13:40:53 +0000918{
Joe Petersona88a69c2009-01-02 13:40:53 +0000919 if (c == ECHO_OP_START) {
Jiri Slaby57c94122012-10-18 22:26:43 +0200920 add_echo_byte(ECHO_OP_START, ldata);
921 add_echo_byte(ECHO_OP_START, ldata);
Joe Petersona88a69c2009-01-02 13:40:53 +0000922 } else {
Jiri Slaby57c94122012-10-18 22:26:43 +0200923 add_echo_byte(c, ldata);
Joe Petersona88a69c2009-01-02 13:40:53 +0000924 }
Joe Petersona88a69c2009-01-02 13:40:53 +0000925}
926
927/**
928 * echo_char - echo a character
929 * @c: unicode byte to echo
930 * @tty: terminal device
931 *
932 * Echo user input back onto the screen. This must be called only when
933 * L_ECHO(tty) is true. Called from the driver receive_buf path.
934 *
Joe Peterson62b26352009-09-09 15:03:47 -0600935 * This variant tags control characters to be echoed as "^X"
936 * (where X is the letter representing the control char).
Linus Torvalds1da177e2005-04-16 15:20:36 -0700937 */
938
939static void echo_char(unsigned char c, struct tty_struct *tty)
940{
Jiri Slabybddc7152012-10-18 22:26:42 +0200941 struct n_tty_data *ldata = tty->disc_data;
942
Joe Petersona88a69c2009-01-02 13:40:53 +0000943 if (c == ECHO_OP_START) {
Jiri Slaby57c94122012-10-18 22:26:43 +0200944 add_echo_byte(ECHO_OP_START, ldata);
945 add_echo_byte(ECHO_OP_START, ldata);
Joe Petersona88a69c2009-01-02 13:40:53 +0000946 } else {
Joe Peterson62b26352009-09-09 15:03:47 -0600947 if (L_ECHOCTL(tty) && iscntrl(c) && c != '\t')
Jiri Slaby57c94122012-10-18 22:26:43 +0200948 add_echo_byte(ECHO_OP_START, ldata);
949 add_echo_byte(c, ldata);
Joe Petersona88a69c2009-01-02 13:40:53 +0000950 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700951}
952
Alan Cox17b82062008-10-13 10:45:06 +0100953/**
Joe Petersona88a69c2009-01-02 13:40:53 +0000954 * finish_erasing - complete erase
Jiri Slaby57c94122012-10-18 22:26:43 +0200955 * @ldata: n_tty data
Alan Cox17b82062008-10-13 10:45:06 +0100956 */
Joe Petersona88a69c2009-01-02 13:40:53 +0000957
Jiri Slaby57c94122012-10-18 22:26:43 +0200958static inline void finish_erasing(struct n_tty_data *ldata)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700959{
Jiri Slaby53c5ee22012-10-18 22:26:39 +0200960 if (ldata->erasing) {
Jiri Slaby57c94122012-10-18 22:26:43 +0200961 echo_char_raw('/', ldata);
Jiri Slaby53c5ee22012-10-18 22:26:39 +0200962 ldata->erasing = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700963 }
964}
965
966/**
967 * eraser - handle erase function
968 * @c: character input
969 * @tty: terminal device
970 *
Robert P. J. Day3a4fa0a2007-10-19 23:10:43 +0200971 * Perform erase and necessary output when an erase character is
Linus Torvalds1da177e2005-04-16 15:20:36 -0700972 * present in the stream from the driver layer. Handles the complexities
973 * of UTF-8 multibyte symbols.
Alan Cox17b82062008-10-13 10:45:06 +0100974 *
Peter Hurley6d76bd22013-06-15 09:14:26 -0400975 * n_tty_receive_buf()/producer path:
976 * caller holds non-exclusive termios_rwsem
Linus Torvalds1da177e2005-04-16 15:20:36 -0700977 */
Alan Cox4edf1822008-02-08 04:18:44 -0800978
Linus Torvalds1da177e2005-04-16 15:20:36 -0700979static void eraser(unsigned char c, struct tty_struct *tty)
980{
Jiri Slaby53c5ee22012-10-18 22:26:39 +0200981 struct n_tty_data *ldata = tty->disc_data;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700982 enum { ERASE, WERASE, KILL } kill_type;
Peter Hurleybc5a5e32013-06-15 09:14:21 -0400983 size_t head;
984 size_t cnt;
985 int seen_alnums;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700986
Jiri Slabyba2e68a2012-10-18 22:26:41 +0200987 if (ldata->read_head == ldata->canon_head) {
Joe Peterson7e94b1d2009-01-02 13:43:40 +0000988 /* process_output('\a', tty); */ /* what do you think? */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700989 return;
990 }
991 if (c == ERASE_CHAR(tty))
992 kill_type = ERASE;
993 else if (c == WERASE_CHAR(tty))
994 kill_type = WERASE;
995 else {
996 if (!L_ECHO(tty)) {
Jiri Slabyba2e68a2012-10-18 22:26:41 +0200997 ldata->read_head = ldata->canon_head;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700998 return;
999 }
1000 if (!L_ECHOK(tty) || !L_ECHOKE(tty) || !L_ECHOE(tty)) {
Jiri Slabyba2e68a2012-10-18 22:26:41 +02001001 ldata->read_head = ldata->canon_head;
Jiri Slaby57c94122012-10-18 22:26:43 +02001002 finish_erasing(ldata);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001003 echo_char(KILL_CHAR(tty), tty);
1004 /* Add a newline if ECHOK is on and ECHOKE is off. */
1005 if (L_ECHOK(tty))
Jiri Slaby57c94122012-10-18 22:26:43 +02001006 echo_char_raw('\n', ldata);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001007 return;
1008 }
1009 kill_type = KILL;
1010 }
1011
1012 seen_alnums = 0;
Jiri Slabyba2e68a2012-10-18 22:26:41 +02001013 while (ldata->read_head != ldata->canon_head) {
1014 head = ldata->read_head;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001015
1016 /* erase a single possibly multibyte character */
1017 do {
Peter Hurleybc5a5e32013-06-15 09:14:21 -04001018 head--;
1019 c = read_buf(ldata, head);
Jiri Slabyba2e68a2012-10-18 22:26:41 +02001020 } while (is_continuation(c, tty) && head != ldata->canon_head);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001021
1022 /* do not partially erase */
1023 if (is_continuation(c, tty))
1024 break;
1025
1026 if (kill_type == WERASE) {
1027 /* Equivalent to BSD's ALTWERASE. */
1028 if (isalnum(c) || c == '_')
1029 seen_alnums++;
1030 else if (seen_alnums)
1031 break;
1032 }
Peter Hurleybc5a5e32013-06-15 09:14:21 -04001033 cnt = ldata->read_head - head;
Jiri Slabyba2e68a2012-10-18 22:26:41 +02001034 ldata->read_head = head;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001035 if (L_ECHO(tty)) {
1036 if (L_ECHOPRT(tty)) {
Jiri Slaby53c5ee22012-10-18 22:26:39 +02001037 if (!ldata->erasing) {
Jiri Slaby57c94122012-10-18 22:26:43 +02001038 echo_char_raw('\\', ldata);
Jiri Slaby53c5ee22012-10-18 22:26:39 +02001039 ldata->erasing = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001040 }
1041 /* if cnt > 1, output a multi-byte character */
1042 echo_char(c, tty);
1043 while (--cnt > 0) {
Peter Hurleybc5a5e32013-06-15 09:14:21 -04001044 head++;
1045 echo_char_raw(read_buf(ldata, head), ldata);
Jiri Slaby57c94122012-10-18 22:26:43 +02001046 echo_move_back_col(ldata);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001047 }
1048 } else if (kill_type == ERASE && !L_ECHOE(tty)) {
1049 echo_char(ERASE_CHAR(tty), tty);
1050 } else if (c == '\t') {
Joe Petersona88a69c2009-01-02 13:40:53 +00001051 unsigned int num_chars = 0;
1052 int after_tab = 0;
Peter Hurleybc5a5e32013-06-15 09:14:21 -04001053 size_t tail = ldata->read_head;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001054
Joe Petersona88a69c2009-01-02 13:40:53 +00001055 /*
1056 * Count the columns used for characters
1057 * since the start of input or after a
1058 * previous tab.
1059 * This info is used to go back the correct
1060 * number of columns.
1061 */
Jiri Slabyba2e68a2012-10-18 22:26:41 +02001062 while (tail != ldata->canon_head) {
Peter Hurleybc5a5e32013-06-15 09:14:21 -04001063 tail--;
1064 c = read_buf(ldata, tail);
Joe Petersona88a69c2009-01-02 13:40:53 +00001065 if (c == '\t') {
1066 after_tab = 1;
1067 break;
Alan Cox300a6202009-01-02 13:41:04 +00001068 } else if (iscntrl(c)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001069 if (L_ECHOCTL(tty))
Joe Petersona88a69c2009-01-02 13:40:53 +00001070 num_chars += 2;
1071 } else if (!is_continuation(c, tty)) {
1072 num_chars++;
1073 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001074 }
Jiri Slaby57c94122012-10-18 22:26:43 +02001075 echo_erase_tab(num_chars, after_tab, ldata);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001076 } else {
1077 if (iscntrl(c) && L_ECHOCTL(tty)) {
Jiri Slaby57c94122012-10-18 22:26:43 +02001078 echo_char_raw('\b', ldata);
1079 echo_char_raw(' ', ldata);
1080 echo_char_raw('\b', ldata);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001081 }
1082 if (!iscntrl(c) || L_ECHOCTL(tty)) {
Jiri Slaby57c94122012-10-18 22:26:43 +02001083 echo_char_raw('\b', ldata);
1084 echo_char_raw(' ', ldata);
1085 echo_char_raw('\b', ldata);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001086 }
1087 }
1088 }
1089 if (kill_type == ERASE)
1090 break;
1091 }
Jiri Slabyba2e68a2012-10-18 22:26:41 +02001092 if (ldata->read_head == ldata->canon_head && L_ECHO(tty))
Jiri Slaby57c94122012-10-18 22:26:43 +02001093 finish_erasing(ldata);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001094}
1095
1096/**
1097 * isig - handle the ISIG optio
1098 * @sig: signal
1099 * @tty: terminal
Linus Torvalds1da177e2005-04-16 15:20:36 -07001100 *
Peter Hurley8c985d12013-03-06 08:38:19 -05001101 * Called when a signal is being sent due to terminal input.
1102 * Called from the driver receive_buf path so serialized.
Alan Cox17b82062008-10-13 10:45:06 +01001103 *
Peter Hurleyd2b6f442015-01-17 15:42:06 -05001104 * Performs input and output flush if !NOFLSH. In this context, the echo
1105 * buffer is 'output'. The signal is processed first to alert any current
1106 * readers or writers to discontinue and exit their i/o loops.
1107 *
Peter Hurley8c985d12013-03-06 08:38:19 -05001108 * Locking: ctrl_lock
Linus Torvalds1da177e2005-04-16 15:20:36 -07001109 */
Alan Cox4edf1822008-02-08 04:18:44 -08001110
Peter Hurley3b19e032015-06-27 09:21:32 -04001111static void __isig(int sig, struct tty_struct *tty)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001112{
Peter Hurley8c985d12013-03-06 08:38:19 -05001113 struct pid *tty_pgrp = tty_get_pgrp(tty);
1114 if (tty_pgrp) {
1115 kill_pgrp(tty_pgrp, sig, 1);
1116 put_pid(tty_pgrp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001117 }
Peter Hurley3b19e032015-06-27 09:21:32 -04001118}
Peter Hurleyd2b6f442015-01-17 15:42:06 -05001119
Peter Hurley3b19e032015-06-27 09:21:32 -04001120static void isig(int sig, struct tty_struct *tty)
1121{
1122 struct n_tty_data *ldata = tty->disc_data;
1123
1124 if (L_NOFLSH(tty)) {
1125 /* signal only */
1126 __isig(sig, tty);
1127
1128 } else { /* signal and flush */
Peter Hurleyd2b6f442015-01-17 15:42:06 -05001129 up_read(&tty->termios_rwsem);
1130 down_write(&tty->termios_rwsem);
1131
Peter Hurley3b19e032015-06-27 09:21:32 -04001132 __isig(sig, tty);
1133
Peter Hurleyd2b6f442015-01-17 15:42:06 -05001134 /* clear echo buffer */
1135 mutex_lock(&ldata->output_lock);
1136 ldata->echo_head = ldata->echo_tail = 0;
1137 ldata->echo_mark = ldata->echo_commit = 0;
1138 mutex_unlock(&ldata->output_lock);
1139
1140 /* clear output buffer */
1141 tty_driver_flush_buffer(tty);
1142
1143 /* clear input buffer */
1144 reset_buffer_flags(tty->disc_data);
1145
1146 /* notify pty master of flush */
1147 if (tty->link)
1148 n_tty_packet_mode_flush(tty);
1149
1150 up_write(&tty->termios_rwsem);
1151 down_read(&tty->termios_rwsem);
1152 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001153}
1154
1155/**
1156 * n_tty_receive_break - handle break
1157 * @tty: terminal
1158 *
1159 * An RS232 break event has been hit in the incoming bitstream. This
1160 * can cause a variety of events depending upon the termios settings.
1161 *
Peter Hurley6d76bd22013-06-15 09:14:26 -04001162 * n_tty_receive_buf()/producer path:
1163 * caller holds non-exclusive termios_rwsem
Peter Hurley6d76bd22013-06-15 09:14:26 -04001164 *
1165 * Note: may get exclusive termios_rwsem if flushing input buffer
Linus Torvalds1da177e2005-04-16 15:20:36 -07001166 */
Alan Cox4edf1822008-02-08 04:18:44 -08001167
Peter Hurley4b293492013-07-24 08:29:55 -04001168static void n_tty_receive_break(struct tty_struct *tty)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001169{
Jiri Slaby57c94122012-10-18 22:26:43 +02001170 struct n_tty_data *ldata = tty->disc_data;
1171
Linus Torvalds1da177e2005-04-16 15:20:36 -07001172 if (I_IGNBRK(tty))
1173 return;
1174 if (I_BRKINT(tty)) {
Peter Hurley8c985d12013-03-06 08:38:19 -05001175 isig(SIGINT, tty);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001176 return;
1177 }
1178 if (I_PARMRK(tty)) {
Jiri Slaby57c94122012-10-18 22:26:43 +02001179 put_tty_queue('\377', ldata);
1180 put_tty_queue('\0', ldata);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001181 }
Jiri Slaby57c94122012-10-18 22:26:43 +02001182 put_tty_queue('\0', ldata);
Peter Hurley6c677162013-12-02 14:24:46 -05001183 if (waitqueue_active(&tty->read_wait))
Peter Hurley57087d52014-08-07 07:14:10 -04001184 wake_up_interruptible_poll(&tty->read_wait, POLLIN);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001185}
1186
1187/**
1188 * n_tty_receive_overrun - handle overrun reporting
1189 * @tty: terminal
1190 *
1191 * Data arrived faster than we could process it. While the tty
1192 * driver has flagged this the bits that were missed are gone
1193 * forever.
1194 *
1195 * Called from the receive_buf path so single threaded. Does not
1196 * need locking as num_overrun and overrun_time are function
1197 * private.
1198 */
Alan Cox4edf1822008-02-08 04:18:44 -08001199
Peter Hurley4b293492013-07-24 08:29:55 -04001200static void n_tty_receive_overrun(struct tty_struct *tty)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001201{
Jiri Slaby53c5ee22012-10-18 22:26:39 +02001202 struct n_tty_data *ldata = tty->disc_data;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001203
Jiri Slaby53c5ee22012-10-18 22:26:39 +02001204 ldata->num_overrun++;
1205 if (time_after(jiffies, ldata->overrun_time + HZ) ||
1206 time_after(ldata->overrun_time, jiffies)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001207 printk(KERN_WARNING "%s: %d input overrun(s)\n",
Rasmus Villemoes429b4742015-03-31 15:55:59 +02001208 tty_name(tty),
Jiri Slaby53c5ee22012-10-18 22:26:39 +02001209 ldata->num_overrun);
1210 ldata->overrun_time = jiffies;
1211 ldata->num_overrun = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001212 }
1213}
1214
1215/**
1216 * n_tty_receive_parity_error - error notifier
1217 * @tty: terminal device
1218 * @c: character
1219 *
1220 * Process a parity error and queue the right data to indicate
Peter Hurley6d76bd22013-06-15 09:14:26 -04001221 * the error case if necessary.
1222 *
1223 * n_tty_receive_buf()/producer path:
1224 * caller holds non-exclusive termios_rwsem
Linus Torvalds1da177e2005-04-16 15:20:36 -07001225 */
Peter Hurley4b293492013-07-24 08:29:55 -04001226static void n_tty_receive_parity_error(struct tty_struct *tty, unsigned char c)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001227{
Jiri Slaby57c94122012-10-18 22:26:43 +02001228 struct n_tty_data *ldata = tty->disc_data;
1229
Peter Hurley66528f92014-06-16 08:10:42 -04001230 if (I_INPCK(tty)) {
1231 if (I_IGNPAR(tty))
1232 return;
1233 if (I_PARMRK(tty)) {
1234 put_tty_queue('\377', ldata);
1235 put_tty_queue('\0', ldata);
1236 put_tty_queue(c, ldata);
1237 } else
1238 put_tty_queue('\0', ldata);
1239 } else
Jiri Slaby57c94122012-10-18 22:26:43 +02001240 put_tty_queue(c, ldata);
Peter Hurley6c677162013-12-02 14:24:46 -05001241 if (waitqueue_active(&tty->read_wait))
Peter Hurley57087d52014-08-07 07:14:10 -04001242 wake_up_interruptible_poll(&tty->read_wait, POLLIN);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001243}
1244
Peter Hurleyb0ac50b2013-06-15 10:21:23 -04001245static void
1246n_tty_receive_signal_char(struct tty_struct *tty, int signal, unsigned char c)
1247{
Peter Hurleyd2b6f442015-01-17 15:42:06 -05001248 isig(signal, tty);
Peter Hurleyb0ac50b2013-06-15 10:21:23 -04001249 if (I_IXON(tty))
1250 start_tty(tty);
1251 if (L_ECHO(tty)) {
1252 echo_char(c, tty);
1253 commit_echoes(tty);
Peter Hurleye2613be2014-02-11 16:34:55 -05001254 } else
1255 process_echoes(tty);
Peter Hurleyb0ac50b2013-06-15 10:21:23 -04001256 return;
1257}
1258
Linus Torvalds1da177e2005-04-16 15:20:36 -07001259/**
1260 * n_tty_receive_char - perform processing
1261 * @tty: terminal device
1262 * @c: character
1263 *
1264 * Process an individual character of input received from the driver.
Alan Cox4edf1822008-02-08 04:18:44 -08001265 * This is serialized with respect to itself by the rules for the
Linus Torvalds1da177e2005-04-16 15:20:36 -07001266 * driver above.
Peter Hurley6d76bd22013-06-15 09:14:26 -04001267 *
1268 * n_tty_receive_buf()/producer path:
1269 * caller holds non-exclusive termios_rwsem
1270 * publishes canon_head if canonical mode is active
Peter Hurleye60d27c2013-07-24 08:29:56 -04001271 *
1272 * Returns 1 if LNEXT was received, else returns 0
Linus Torvalds1da177e2005-04-16 15:20:36 -07001273 */
1274
Peter Hurleye60d27c2013-07-24 08:29:56 -04001275static int
Peter Hurley4b1f79c2013-07-24 08:29:51 -04001276n_tty_receive_char_special(struct tty_struct *tty, unsigned char c)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001277{
Jiri Slaby53c5ee22012-10-18 22:26:39 +02001278 struct n_tty_data *ldata = tty->disc_data;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001279
Linus Torvalds1da177e2005-04-16 15:20:36 -07001280 if (I_IXON(tty)) {
1281 if (c == START_CHAR(tty)) {
1282 start_tty(tty);
Peter Hurleye2613be2014-02-11 16:34:55 -05001283 process_echoes(tty);
Peter Hurleye60d27c2013-07-24 08:29:56 -04001284 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001285 }
1286 if (c == STOP_CHAR(tty)) {
1287 stop_tty(tty);
Peter Hurleye60d27c2013-07-24 08:29:56 -04001288 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001289 }
1290 }
Joe Peterson575537b32008-04-30 00:53:30 -07001291
Linus Torvalds1da177e2005-04-16 15:20:36 -07001292 if (L_ISIG(tty)) {
Peter Hurleyb0ac50b2013-06-15 10:21:23 -04001293 if (c == INTR_CHAR(tty)) {
1294 n_tty_receive_signal_char(tty, SIGINT, c);
Peter Hurleye60d27c2013-07-24 08:29:56 -04001295 return 0;
Peter Hurleyb0ac50b2013-06-15 10:21:23 -04001296 } else if (c == QUIT_CHAR(tty)) {
1297 n_tty_receive_signal_char(tty, SIGQUIT, c);
Peter Hurleye60d27c2013-07-24 08:29:56 -04001298 return 0;
Peter Hurleyb0ac50b2013-06-15 10:21:23 -04001299 } else if (c == SUSP_CHAR(tty)) {
1300 n_tty_receive_signal_char(tty, SIGTSTP, c);
Peter Hurleye60d27c2013-07-24 08:29:56 -04001301 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001302 }
1303 }
Joe Peterson575537b32008-04-30 00:53:30 -07001304
Peter Hurley855df3c2013-07-24 08:29:50 -04001305 if (tty->stopped && !tty->flow_stopped && I_IXON(tty) && I_IXANY(tty)) {
1306 start_tty(tty);
1307 process_echoes(tty);
1308 }
1309
Joe Peterson575537b32008-04-30 00:53:30 -07001310 if (c == '\r') {
1311 if (I_IGNCR(tty))
Peter Hurleye60d27c2013-07-24 08:29:56 -04001312 return 0;
Joe Peterson575537b32008-04-30 00:53:30 -07001313 if (I_ICRNL(tty))
1314 c = '\n';
1315 } else if (c == '\n' && I_INLCR(tty))
1316 c = '\r';
1317
Jiri Slaby53c5ee22012-10-18 22:26:39 +02001318 if (ldata->icanon) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001319 if (c == ERASE_CHAR(tty) || c == KILL_CHAR(tty) ||
1320 (c == WERASE_CHAR(tty) && L_IEXTEN(tty))) {
1321 eraser(c, tty);
Peter Hurley17bd7902013-06-15 10:04:24 -04001322 commit_echoes(tty);
Peter Hurleye60d27c2013-07-24 08:29:56 -04001323 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001324 }
1325 if (c == LNEXT_CHAR(tty) && L_IEXTEN(tty)) {
Jiri Slaby53c5ee22012-10-18 22:26:39 +02001326 ldata->lnext = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001327 if (L_ECHO(tty)) {
Jiri Slaby57c94122012-10-18 22:26:43 +02001328 finish_erasing(ldata);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001329 if (L_ECHOCTL(tty)) {
Jiri Slaby57c94122012-10-18 22:26:43 +02001330 echo_char_raw('^', ldata);
1331 echo_char_raw('\b', ldata);
Peter Hurley17bd7902013-06-15 10:04:24 -04001332 commit_echoes(tty);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001333 }
1334 }
Peter Hurleye60d27c2013-07-24 08:29:56 -04001335 return 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001336 }
Peter Hurleye60d27c2013-07-24 08:29:56 -04001337 if (c == REPRINT_CHAR(tty) && L_ECHO(tty) && L_IEXTEN(tty)) {
Peter Hurleybc5a5e32013-06-15 09:14:21 -04001338 size_t tail = ldata->canon_head;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001339
Jiri Slaby57c94122012-10-18 22:26:43 +02001340 finish_erasing(ldata);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001341 echo_char(c, tty);
Jiri Slaby57c94122012-10-18 22:26:43 +02001342 echo_char_raw('\n', ldata);
Jiri Slabyba2e68a2012-10-18 22:26:41 +02001343 while (tail != ldata->read_head) {
Peter Hurleybc5a5e32013-06-15 09:14:21 -04001344 echo_char(read_buf(ldata, tail), tty);
1345 tail++;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001346 }
Peter Hurley17bd7902013-06-15 10:04:24 -04001347 commit_echoes(tty);
Peter Hurleye60d27c2013-07-24 08:29:56 -04001348 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001349 }
1350 if (c == '\n') {
Joe Petersonacc71bb2009-01-02 13:43:32 +00001351 if (L_ECHO(tty) || L_ECHONL(tty)) {
Jiri Slaby57c94122012-10-18 22:26:43 +02001352 echo_char_raw('\n', ldata);
Peter Hurley17bd7902013-06-15 10:04:24 -04001353 commit_echoes(tty);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001354 }
1355 goto handle_newline;
1356 }
1357 if (c == EOF_CHAR(tty)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001358 c = __DISABLED_CHAR;
1359 goto handle_newline;
1360 }
1361 if ((c == EOL_CHAR(tty)) ||
1362 (c == EOL2_CHAR(tty) && L_IEXTEN(tty))) {
1363 /*
1364 * XXX are EOL_CHAR and EOL2_CHAR echoed?!?
1365 */
1366 if (L_ECHO(tty)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001367 /* Record the column of first canon char. */
Jiri Slabyba2e68a2012-10-18 22:26:41 +02001368 if (ldata->canon_head == ldata->read_head)
Jiri Slaby57c94122012-10-18 22:26:43 +02001369 echo_set_canon_col(ldata);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001370 echo_char(c, tty);
Peter Hurley17bd7902013-06-15 10:04:24 -04001371 commit_echoes(tty);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001372 }
1373 /*
1374 * XXX does PARMRK doubling happen for
1375 * EOL_CHAR and EOL2_CHAR?
1376 */
Peter Hurley001ba922013-12-02 14:24:44 -05001377 if (c == (unsigned char) '\377' && I_PARMRK(tty))
Jiri Slaby57c94122012-10-18 22:26:43 +02001378 put_tty_queue(c, ldata);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001379
Alan Cox4edf1822008-02-08 04:18:44 -08001380handle_newline:
Peter Hurleybc5a5e32013-06-15 09:14:21 -04001381 set_bit(ldata->read_head & (N_TTY_BUF_SIZE - 1), ldata->read_flags);
Peter Hurley6d76bd22013-06-15 09:14:26 -04001382 put_tty_queue(c, ldata);
Peter Hurley70aca712015-01-16 15:05:37 -05001383 smp_store_release(&ldata->canon_head, ldata->read_head);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001384 kill_fasync(&tty->fasync, SIGIO, POLL_IN);
1385 if (waitqueue_active(&tty->read_wait))
Peter Hurley57087d52014-08-07 07:14:10 -04001386 wake_up_interruptible_poll(&tty->read_wait, POLLIN);
Peter Hurleye60d27c2013-07-24 08:29:56 -04001387 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001388 }
1389 }
Alan Cox4edf1822008-02-08 04:18:44 -08001390
Joe Petersonacc71bb2009-01-02 13:43:32 +00001391 if (L_ECHO(tty)) {
Jiri Slaby57c94122012-10-18 22:26:43 +02001392 finish_erasing(ldata);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001393 if (c == '\n')
Jiri Slaby57c94122012-10-18 22:26:43 +02001394 echo_char_raw('\n', ldata);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001395 else {
1396 /* Record the column of first canon char. */
Jiri Slabyba2e68a2012-10-18 22:26:41 +02001397 if (ldata->canon_head == ldata->read_head)
Jiri Slaby57c94122012-10-18 22:26:43 +02001398 echo_set_canon_col(ldata);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001399 echo_char(c, tty);
1400 }
Peter Hurley17bd7902013-06-15 10:04:24 -04001401 commit_echoes(tty);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001402 }
1403
Peter Hurley001ba922013-12-02 14:24:44 -05001404 /* PARMRK doubling check */
1405 if (c == (unsigned char) '\377' && I_PARMRK(tty))
Jiri Slaby57c94122012-10-18 22:26:43 +02001406 put_tty_queue(c, ldata);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001407
Jiri Slaby57c94122012-10-18 22:26:43 +02001408 put_tty_queue(c, ldata);
Peter Hurleye60d27c2013-07-24 08:29:56 -04001409 return 0;
Alan Cox4edf1822008-02-08 04:18:44 -08001410}
Linus Torvalds1da177e2005-04-16 15:20:36 -07001411
Peter Hurleye60d27c2013-07-24 08:29:56 -04001412static inline void
1413n_tty_receive_char_inline(struct tty_struct *tty, unsigned char c)
Peter Hurley4b1f79c2013-07-24 08:29:51 -04001414{
1415 struct n_tty_data *ldata = tty->disc_data;
Peter Hurley4b1f79c2013-07-24 08:29:51 -04001416
Peter Hurleye60d27c2013-07-24 08:29:56 -04001417 if (tty->stopped && !tty->flow_stopped && I_IXON(tty) && I_IXANY(tty)) {
1418 start_tty(tty);
1419 process_echoes(tty);
Peter Hurley4b1f79c2013-07-24 08:29:51 -04001420 }
Peter Hurleye60d27c2013-07-24 08:29:56 -04001421 if (L_ECHO(tty)) {
1422 finish_erasing(ldata);
1423 /* Record the column of first canon char. */
1424 if (ldata->canon_head == ldata->read_head)
1425 echo_set_canon_col(ldata);
1426 echo_char(c, tty);
1427 commit_echoes(tty);
1428 }
Peter Hurley001ba922013-12-02 14:24:44 -05001429 /* PARMRK doubling check */
1430 if (c == (unsigned char) '\377' && I_PARMRK(tty))
Peter Hurleye60d27c2013-07-24 08:29:56 -04001431 put_tty_queue(c, ldata);
1432 put_tty_queue(c, ldata);
1433}
Peter Hurley4b1f79c2013-07-24 08:29:51 -04001434
Peter Hurleyeb3e4662013-12-02 14:24:42 -05001435static void n_tty_receive_char(struct tty_struct *tty, unsigned char c)
Peter Hurleye60d27c2013-07-24 08:29:56 -04001436{
1437 n_tty_receive_char_inline(tty, c);
Peter Hurley4b1f79c2013-07-24 08:29:51 -04001438}
1439
Peter Hurleyad0cc7b2013-06-15 10:21:27 -04001440static inline void
Peter Hurley7de971b2013-07-24 08:29:53 -04001441n_tty_receive_char_fast(struct tty_struct *tty, unsigned char c)
1442{
1443 struct n_tty_data *ldata = tty->disc_data;
1444
Peter Hurleye60d27c2013-07-24 08:29:56 -04001445 if (tty->stopped && !tty->flow_stopped && I_IXON(tty) && I_IXANY(tty)) {
1446 start_tty(tty);
1447 process_echoes(tty);
Peter Hurley7de971b2013-07-24 08:29:53 -04001448 }
Peter Hurleye60d27c2013-07-24 08:29:56 -04001449 if (L_ECHO(tty)) {
1450 finish_erasing(ldata);
1451 /* Record the column of first canon char. */
1452 if (ldata->canon_head == ldata->read_head)
1453 echo_set_canon_col(ldata);
1454 echo_char(c, tty);
1455 commit_echoes(tty);
1456 }
1457 put_tty_queue(c, ldata);
Peter Hurley7de971b2013-07-24 08:29:53 -04001458}
1459
Peter Hurley8dc4b252013-12-02 14:24:43 -05001460static void n_tty_receive_char_closing(struct tty_struct *tty, unsigned char c)
Peter Hurleyad0cc7b2013-06-15 10:21:27 -04001461{
1462 if (I_ISTRIP(tty))
1463 c &= 0x7f;
1464 if (I_IUCLC(tty) && L_IEXTEN(tty))
1465 c = tolower(c);
1466
1467 if (I_IXON(tty)) {
1468 if (c == STOP_CHAR(tty))
1469 stop_tty(tty);
1470 else if (c == START_CHAR(tty) ||
1471 (tty->stopped && !tty->flow_stopped && I_IXANY(tty) &&
1472 c != INTR_CHAR(tty) && c != QUIT_CHAR(tty) &&
1473 c != SUSP_CHAR(tty))) {
1474 start_tty(tty);
1475 process_echoes(tty);
1476 }
1477 }
1478}
1479
Peter Hurleyd2f8d7a2013-06-15 10:21:24 -04001480static void
1481n_tty_receive_char_flagged(struct tty_struct *tty, unsigned char c, char flag)
1482{
Peter Hurleyd2f8d7a2013-06-15 10:21:24 -04001483 switch (flag) {
1484 case TTY_BREAK:
1485 n_tty_receive_break(tty);
1486 break;
1487 case TTY_PARITY:
1488 case TTY_FRAME:
1489 n_tty_receive_parity_error(tty, c);
1490 break;
1491 case TTY_OVERRUN:
1492 n_tty_receive_overrun(tty);
1493 break;
1494 default:
1495 printk(KERN_ERR "%s: unknown flag %d\n",
Rasmus Villemoes429b4742015-03-31 15:55:59 +02001496 tty_name(tty), flag);
Peter Hurleyd2f8d7a2013-06-15 10:21:24 -04001497 break;
1498 }
1499}
1500
Peter Hurleye60d27c2013-07-24 08:29:56 -04001501static void
1502n_tty_receive_char_lnext(struct tty_struct *tty, unsigned char c, char flag)
1503{
1504 struct n_tty_data *ldata = tty->disc_data;
1505
1506 ldata->lnext = 0;
1507 if (likely(flag == TTY_NORMAL)) {
1508 if (I_ISTRIP(tty))
1509 c &= 0x7f;
1510 if (I_IUCLC(tty) && L_IEXTEN(tty))
1511 c = tolower(c);
1512 n_tty_receive_char(tty, c);
1513 } else
1514 n_tty_receive_char_flagged(tty, c, flag);
1515}
1516
Peter Hurley4a23a4d2013-06-15 10:21:22 -04001517static void
1518n_tty_receive_buf_real_raw(struct tty_struct *tty, const unsigned char *cp,
1519 char *fp, int count)
1520{
1521 struct n_tty_data *ldata = tty->disc_data;
1522 size_t n, head;
1523
1524 head = ldata->read_head & (N_TTY_BUF_SIZE - 1);
Peter Hurley70aca712015-01-16 15:05:37 -05001525 n = min_t(size_t, count, N_TTY_BUF_SIZE - head);
Peter Hurley4a23a4d2013-06-15 10:21:22 -04001526 memcpy(read_buf_addr(ldata, head), cp, n);
1527 ldata->read_head += n;
1528 cp += n;
1529 count -= n;
1530
1531 head = ldata->read_head & (N_TTY_BUF_SIZE - 1);
Peter Hurley70aca712015-01-16 15:05:37 -05001532 n = min_t(size_t, count, N_TTY_BUF_SIZE - head);
Peter Hurley4a23a4d2013-06-15 10:21:22 -04001533 memcpy(read_buf_addr(ldata, head), cp, n);
1534 ldata->read_head += n;
1535}
1536
Peter Hurley554117b2013-06-15 10:21:25 -04001537static void
1538n_tty_receive_buf_raw(struct tty_struct *tty, const unsigned char *cp,
1539 char *fp, int count)
1540{
1541 struct n_tty_data *ldata = tty->disc_data;
1542 char flag = TTY_NORMAL;
1543
1544 while (count--) {
1545 if (fp)
1546 flag = *fp++;
1547 if (likely(flag == TTY_NORMAL))
1548 put_tty_queue(*cp++, ldata);
1549 else
1550 n_tty_receive_char_flagged(tty, *cp++, flag);
1551 }
1552}
1553
Peter Hurleyad0cc7b2013-06-15 10:21:27 -04001554static void
1555n_tty_receive_buf_closing(struct tty_struct *tty, const unsigned char *cp,
1556 char *fp, int count)
1557{
1558 char flag = TTY_NORMAL;
1559
1560 while (count--) {
1561 if (fp)
1562 flag = *fp++;
1563 if (likely(flag == TTY_NORMAL))
1564 n_tty_receive_char_closing(tty, *cp++);
1565 else
1566 n_tty_receive_char_flagged(tty, *cp++, flag);
1567 }
1568}
1569
Peter Hurley7d88d632013-07-24 08:29:49 -04001570static void
1571n_tty_receive_buf_standard(struct tty_struct *tty, const unsigned char *cp,
Peter Hurley6baad002013-07-24 08:29:52 -04001572 char *fp, int count)
1573{
1574 struct n_tty_data *ldata = tty->disc_data;
1575 char flag = TTY_NORMAL;
1576
1577 while (count--) {
1578 if (fp)
1579 flag = *fp++;
1580 if (likely(flag == TTY_NORMAL)) {
1581 unsigned char c = *cp++;
1582
1583 if (I_ISTRIP(tty))
1584 c &= 0x7f;
1585 if (I_IUCLC(tty) && L_IEXTEN(tty))
1586 c = tolower(c);
1587 if (L_EXTPROC(tty)) {
1588 put_tty_queue(c, ldata);
1589 continue;
1590 }
Peter Hurleye60d27c2013-07-24 08:29:56 -04001591 if (!test_bit(c, ldata->char_map))
1592 n_tty_receive_char_inline(tty, c);
1593 else if (n_tty_receive_char_special(tty, c) && count) {
1594 if (fp)
1595 flag = *fp++;
1596 n_tty_receive_char_lnext(tty, *cp++, flag);
1597 count--;
1598 }
Peter Hurley6baad002013-07-24 08:29:52 -04001599 } else
1600 n_tty_receive_char_flagged(tty, *cp++, flag);
1601 }
1602}
1603
1604static void
1605n_tty_receive_buf_fast(struct tty_struct *tty, const unsigned char *cp,
1606 char *fp, int count)
Peter Hurley7d88d632013-07-24 08:29:49 -04001607{
Peter Hurleye60d27c2013-07-24 08:29:56 -04001608 struct n_tty_data *ldata = tty->disc_data;
Peter Hurley7d88d632013-07-24 08:29:49 -04001609 char flag = TTY_NORMAL;
1610
1611 while (count--) {
1612 if (fp)
1613 flag = *fp++;
Peter Hurleye60d27c2013-07-24 08:29:56 -04001614 if (likely(flag == TTY_NORMAL)) {
1615 unsigned char c = *cp++;
1616
1617 if (!test_bit(c, ldata->char_map))
1618 n_tty_receive_char_fast(tty, c);
1619 else if (n_tty_receive_char_special(tty, c) && count) {
1620 if (fp)
1621 flag = *fp++;
1622 n_tty_receive_char_lnext(tty, *cp++, flag);
1623 count--;
1624 }
1625 } else
Peter Hurley7d88d632013-07-24 08:29:49 -04001626 n_tty_receive_char_flagged(tty, *cp++, flag);
1627 }
1628}
1629
Peter Hurley24a89d12013-06-15 09:14:15 -04001630static void __receive_buf(struct tty_struct *tty, const unsigned char *cp,
1631 char *fp, int count)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001632{
Jiri Slaby53c5ee22012-10-18 22:26:39 +02001633 struct n_tty_data *ldata = tty->disc_data;
Peter Hurleya1dd30e2013-06-15 10:21:26 -04001634 bool preops = I_ISTRIP(tty) || (I_IUCLC(tty) && L_IEXTEN(tty));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001635
Peter Hurley4a23a4d2013-06-15 10:21:22 -04001636 if (ldata->real_raw)
1637 n_tty_receive_buf_real_raw(tty, cp, fp, count);
Peter Hurleya1dd30e2013-06-15 10:21:26 -04001638 else if (ldata->raw || (L_EXTPROC(tty) && !preops))
Peter Hurley554117b2013-06-15 10:21:25 -04001639 n_tty_receive_buf_raw(tty, cp, fp, count);
Peter Hurleyad0cc7b2013-06-15 10:21:27 -04001640 else if (tty->closing && !L_EXTPROC(tty))
1641 n_tty_receive_buf_closing(tty, cp, fp, count);
Peter Hurley4a23a4d2013-06-15 10:21:22 -04001642 else {
Peter Hurleye60d27c2013-07-24 08:29:56 -04001643 if (ldata->lnext) {
1644 char flag = TTY_NORMAL;
1645
1646 if (fp)
1647 flag = *fp++;
1648 n_tty_receive_char_lnext(tty, *cp++, flag);
1649 count--;
1650 }
1651
Peter Hurley7de971b2013-07-24 08:29:53 -04001652 if (!preops && !I_PARMRK(tty))
Peter Hurley6baad002013-07-24 08:29:52 -04001653 n_tty_receive_buf_fast(tty, cp, fp, count);
1654 else
1655 n_tty_receive_buf_standard(tty, cp, fp, count);
Peter Hurleycbfd0342013-06-15 10:04:26 -04001656
1657 flush_echoes(tty);
Alan Coxf34d7a52008-04-30 00:54:13 -07001658 if (tty->ops->flush_chars)
1659 tty->ops->flush_chars(tty);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001660 }
1661
Peter Hurley70aca712015-01-16 15:05:37 -05001662 if (ldata->icanon && !L_EXTPROC(tty))
1663 return;
1664
1665 /* publish read_head to consumer */
1666 smp_store_release(&ldata->commit_head, ldata->read_head);
1667
1668 if ((read_cnt(ldata) >= ldata->minimum_to_wake) || L_EXTPROC(tty)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001669 kill_fasync(&tty->fasync, SIGIO, POLL_IN);
1670 if (waitqueue_active(&tty->read_wait))
Peter Hurley57087d52014-08-07 07:14:10 -04001671 wake_up_interruptible_poll(&tty->read_wait, POLLIN);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001672 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001673}
1674
Peter Hurleyfb5ef9e2015-01-16 15:05:39 -05001675/**
1676 * n_tty_receive_buf_common - process input
1677 * @tty: device to receive input
1678 * @cp: input chars
1679 * @fp: flags for each char (if NULL, all chars are TTY_NORMAL)
1680 * @count: number of input chars in @cp
1681 *
1682 * Called by the terminal driver when a block of characters has
1683 * been received. This function must be called from soft contexts
1684 * not from interrupt context. The driver is responsible for making
1685 * calls one at a time and in order (or using flush_to_ldisc)
1686 *
1687 * Returns the # of input chars from @cp which were processed.
1688 *
1689 * In canonical mode, the maximum line length is 4096 chars (including
1690 * the line termination char); lines longer than 4096 chars are
1691 * truncated. After 4095 chars, input data is still processed but
1692 * not stored. Overflow processing ensures the tty can always
1693 * receive more input until at least one line can be read.
1694 *
1695 * In non-canonical mode, the read buffer will only accept 4095 chars;
1696 * this provides the necessary space for a newline char if the input
1697 * mode is switched to canonical.
1698 *
1699 * Note it is possible for the read buffer to _contain_ 4096 chars
1700 * in non-canonical mode: the read buffer could already contain the
1701 * maximum canon line of 4096 chars when the mode is switched to
1702 * non-canonical.
1703 *
1704 * n_tty_receive_buf()/producer path:
1705 * claims non-exclusive termios_rwsem
1706 * publishes commit_head or canon_head
1707 */
Peter Hurley5c32d122013-12-02 14:24:41 -05001708static int
1709n_tty_receive_buf_common(struct tty_struct *tty, const unsigned char *cp,
1710 char *fp, int count, int flow)
Peter Hurley24a89d12013-06-15 09:14:15 -04001711{
1712 struct n_tty_data *ldata = tty->disc_data;
Peter Hurleyfb5ef9e2015-01-16 15:05:39 -05001713 int room, n, rcvd = 0, overflow;
Peter Hurley24a89d12013-06-15 09:14:15 -04001714
Peter Hurley9356b532013-06-15 09:14:24 -04001715 down_read(&tty->termios_rwsem);
1716
Peter Hurley19e2ad62013-07-24 08:29:54 -04001717 while (1) {
Peter Hurley70aca712015-01-16 15:05:37 -05001718 /*
Peter Hurley06c49f92015-01-16 15:05:38 -05001719 * When PARMRK is set, each input char may take up to 3 chars
1720 * in the read buf; reduce the buffer space avail by 3x
Peter Hurley70aca712015-01-16 15:05:37 -05001721 *
1722 * If we are doing input canonicalization, and there are no
1723 * pending newlines, let characters through without limit, so
1724 * that erase characters will be handled. Other excess
1725 * characters will be beeped.
1726 *
1727 * paired with store in *_copy_from_read_buf() -- guarantees
1728 * the consumer has loaded the data in read_buf up to the new
1729 * read_tail (so this producer will not overwrite unread data)
1730 */
1731 size_t tail = smp_load_acquire(&ldata->read_tail);
Peter Hurley70aca712015-01-16 15:05:37 -05001732
Peter Hurleyfb5ef9e2015-01-16 15:05:39 -05001733 room = N_TTY_BUF_SIZE - (ldata->read_head - tail);
Peter Hurley70aca712015-01-16 15:05:37 -05001734 if (I_PARMRK(tty))
Peter Hurleyfb5ef9e2015-01-16 15:05:39 -05001735 room = (room + 2) / 3;
1736 room--;
1737 if (room <= 0) {
1738 overflow = ldata->icanon && ldata->canon_head == tail;
1739 if (overflow && room < 0)
1740 ldata->read_head--;
1741 room = overflow;
1742 ldata->no_room = flow && !room;
1743 } else
1744 overflow = 0;
Peter Hurley70aca712015-01-16 15:05:37 -05001745
Peter Hurley19e2ad62013-07-24 08:29:54 -04001746 n = min(count, room);
Peter Hurleyfb5ef9e2015-01-16 15:05:39 -05001747 if (!n)
Peter Hurley19e2ad62013-07-24 08:29:54 -04001748 break;
Peter Hurleyfb5ef9e2015-01-16 15:05:39 -05001749
1750 /* ignore parity errors if handling overflow */
1751 if (!overflow || !fp || *fp != TTY_PARITY)
1752 __receive_buf(tty, cp, fp, n);
1753
Peter Hurley19e2ad62013-07-24 08:29:54 -04001754 cp += n;
1755 if (fp)
1756 fp += n;
1757 count -= n;
1758 rcvd += n;
Peter Hurley4a23a4d2013-06-15 10:21:22 -04001759 }
Peter Hurley24a89d12013-06-15 09:14:15 -04001760
Peter Hurley19e2ad62013-07-24 08:29:54 -04001761 tty->receive_room = room;
Peter Hurleyfb5ef9e2015-01-16 15:05:39 -05001762
1763 /* Unthrottle if handling overflow on pty */
1764 if (tty->driver->type == TTY_DRIVER_TYPE_PTY) {
1765 if (overflow) {
1766 tty_set_flow_change(tty, TTY_UNTHROTTLE_SAFE);
1767 tty_unthrottle_safe(tty);
1768 __tty_set_flow_change(tty, 0);
1769 }
1770 } else
1771 n_tty_check_throttle(tty);
1772
Peter Hurley9356b532013-06-15 09:14:24 -04001773 up_read(&tty->termios_rwsem);
1774
Peter Hurley19e2ad62013-07-24 08:29:54 -04001775 return rcvd;
Peter Hurley24a89d12013-06-15 09:14:15 -04001776}
1777
Peter Hurley5c32d122013-12-02 14:24:41 -05001778static void n_tty_receive_buf(struct tty_struct *tty, const unsigned char *cp,
1779 char *fp, int count)
1780{
1781 n_tty_receive_buf_common(tty, cp, fp, count, 0);
1782}
1783
1784static int n_tty_receive_buf2(struct tty_struct *tty, const unsigned char *cp,
1785 char *fp, int count)
1786{
1787 return n_tty_receive_buf_common(tty, cp, fp, count, 1);
1788}
1789
Linus Torvalds1da177e2005-04-16 15:20:36 -07001790int is_ignored(int sig)
1791{
1792 return (sigismember(&current->blocked, sig) ||
Alan Cox4edf1822008-02-08 04:18:44 -08001793 current->sighand->action[sig-1].sa.sa_handler == SIG_IGN);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001794}
1795
1796/**
1797 * n_tty_set_termios - termios data changed
1798 * @tty: terminal
1799 * @old: previous data
1800 *
1801 * Called by the tty layer when the user changes termios flags so
1802 * that the line discipline can plan ahead. This function cannot sleep
Alan Cox4edf1822008-02-08 04:18:44 -08001803 * and is protected from re-entry by the tty layer. The user is
Linus Torvalds1da177e2005-04-16 15:20:36 -07001804 * guaranteed that this function will not be re-entered or in progress
1805 * when the ldisc is closed.
Alan Cox17b82062008-10-13 10:45:06 +01001806 *
Peter Hurley6a1c0682013-06-15 09:14:23 -04001807 * Locking: Caller holds tty->termios_rwsem
Linus Torvalds1da177e2005-04-16 15:20:36 -07001808 */
Alan Cox4edf1822008-02-08 04:18:44 -08001809
1810static void n_tty_set_termios(struct tty_struct *tty, struct ktermios *old)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001811{
Jiri Slaby53c5ee22012-10-18 22:26:39 +02001812 struct n_tty_data *ldata = tty->disc_data;
Alan Cox47afa7a2008-10-13 10:44:17 +01001813
Peter Hurleyc786f742013-09-17 12:53:35 -04001814 if (!old || (old->c_lflag ^ tty->termios.c_lflag) & ICANON) {
Jiri Slaby3fe780b2012-10-18 22:26:40 +02001815 bitmap_zero(ldata->read_flags, N_TTY_BUF_SIZE);
Peter Hurley4d0ed182013-12-10 17:12:02 -05001816 ldata->line_start = ldata->read_tail;
1817 if (!L_ICANON(tty) || !read_cnt(ldata)) {
1818 ldata->canon_head = ldata->read_tail;
1819 ldata->push = 0;
1820 } else {
1821 set_bit((ldata->read_head - 1) & (N_TTY_BUF_SIZE - 1),
1822 ldata->read_flags);
1823 ldata->canon_head = ldata->read_head;
1824 ldata->push = 1;
1825 }
Peter Hurley70aca712015-01-16 15:05:37 -05001826 ldata->commit_head = ldata->read_head;
Jiri Slaby53c5ee22012-10-18 22:26:39 +02001827 ldata->erasing = 0;
Peter Hurley6f9b0282013-06-15 09:14:27 -04001828 ldata->lnext = 0;
Alan Cox47afa7a2008-10-13 10:44:17 +01001829 }
1830
Jiri Slaby53c5ee22012-10-18 22:26:39 +02001831 ldata->icanon = (L_ICANON(tty) != 0);
Peter Hurley582f5592013-05-17 12:49:48 -04001832
Linus Torvalds1da177e2005-04-16 15:20:36 -07001833 if (I_ISTRIP(tty) || I_IUCLC(tty) || I_IGNCR(tty) ||
1834 I_ICRNL(tty) || I_INLCR(tty) || L_ICANON(tty) ||
1835 I_IXON(tty) || L_ISIG(tty) || L_ECHO(tty) ||
1836 I_PARMRK(tty)) {
Peter Hurley1bb9d562013-06-15 10:21:20 -04001837 bitmap_zero(ldata->char_map, 256);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001838
1839 if (I_IGNCR(tty) || I_ICRNL(tty))
Peter Hurley1bb9d562013-06-15 10:21:20 -04001840 set_bit('\r', ldata->char_map);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001841 if (I_INLCR(tty))
Peter Hurley1bb9d562013-06-15 10:21:20 -04001842 set_bit('\n', ldata->char_map);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001843
1844 if (L_ICANON(tty)) {
Peter Hurley1bb9d562013-06-15 10:21:20 -04001845 set_bit(ERASE_CHAR(tty), ldata->char_map);
1846 set_bit(KILL_CHAR(tty), ldata->char_map);
1847 set_bit(EOF_CHAR(tty), ldata->char_map);
1848 set_bit('\n', ldata->char_map);
1849 set_bit(EOL_CHAR(tty), ldata->char_map);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001850 if (L_IEXTEN(tty)) {
Peter Hurley1bb9d562013-06-15 10:21:20 -04001851 set_bit(WERASE_CHAR(tty), ldata->char_map);
1852 set_bit(LNEXT_CHAR(tty), ldata->char_map);
1853 set_bit(EOL2_CHAR(tty), ldata->char_map);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001854 if (L_ECHO(tty))
1855 set_bit(REPRINT_CHAR(tty),
Peter Hurley1bb9d562013-06-15 10:21:20 -04001856 ldata->char_map);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001857 }
1858 }
1859 if (I_IXON(tty)) {
Peter Hurley1bb9d562013-06-15 10:21:20 -04001860 set_bit(START_CHAR(tty), ldata->char_map);
1861 set_bit(STOP_CHAR(tty), ldata->char_map);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001862 }
1863 if (L_ISIG(tty)) {
Peter Hurley1bb9d562013-06-15 10:21:20 -04001864 set_bit(INTR_CHAR(tty), ldata->char_map);
1865 set_bit(QUIT_CHAR(tty), ldata->char_map);
1866 set_bit(SUSP_CHAR(tty), ldata->char_map);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001867 }
Peter Hurley1bb9d562013-06-15 10:21:20 -04001868 clear_bit(__DISABLED_CHAR, ldata->char_map);
Jiri Slaby53c5ee22012-10-18 22:26:39 +02001869 ldata->raw = 0;
1870 ldata->real_raw = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001871 } else {
Jiri Slaby53c5ee22012-10-18 22:26:39 +02001872 ldata->raw = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001873 if ((I_IGNBRK(tty) || (!I_BRKINT(tty) && !I_PARMRK(tty))) &&
1874 (I_IGNPAR(tty) || !I_INPCK(tty)) &&
1875 (tty->driver->flags & TTY_DRIVER_REAL_RAW))
Jiri Slaby53c5ee22012-10-18 22:26:39 +02001876 ldata->real_raw = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001877 else
Jiri Slaby53c5ee22012-10-18 22:26:39 +02001878 ldata->real_raw = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001879 }
Wang YanQingdab73b42013-05-09 14:16:47 +08001880 /*
1881 * Fix tty hang when I_IXON(tty) is cleared, but the tty
1882 * been stopped by STOP_CHAR(tty) before it.
1883 */
Peter Hurleye2613be2014-02-11 16:34:55 -05001884 if (!I_IXON(tty) && old && (old->c_iflag & IXON) && !tty->flow_stopped) {
Wang YanQingdab73b42013-05-09 14:16:47 +08001885 start_tty(tty);
Peter Hurleye2613be2014-02-11 16:34:55 -05001886 process_echoes(tty);
1887 }
Wang YanQingdab73b42013-05-09 14:16:47 +08001888
Alan Coxf34d7a52008-04-30 00:54:13 -07001889 /* The termios change make the tty ready for I/O */
Peter Hurley6c677162013-12-02 14:24:46 -05001890 if (waitqueue_active(&tty->write_wait))
1891 wake_up_interruptible(&tty->write_wait);
1892 if (waitqueue_active(&tty->read_wait))
1893 wake_up_interruptible(&tty->read_wait);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001894}
1895
1896/**
1897 * n_tty_close - close the ldisc for this tty
1898 * @tty: device
1899 *
Alan Cox4edf1822008-02-08 04:18:44 -08001900 * Called from the terminal layer when this line discipline is
1901 * being shut down, either because of a close or becsuse of a
Linus Torvalds1da177e2005-04-16 15:20:36 -07001902 * discipline change. The function will not be called while other
1903 * ldisc methods are in progress.
1904 */
Alan Cox4edf1822008-02-08 04:18:44 -08001905
Linus Torvalds1da177e2005-04-16 15:20:36 -07001906static void n_tty_close(struct tty_struct *tty)
1907{
Jiri Slaby70ece7a2012-10-18 22:26:38 +02001908 struct n_tty_data *ldata = tty->disc_data;
1909
Peter Hurley79901312013-03-11 16:44:23 -04001910 if (tty->link)
1911 n_tty_packet_mode_flush(tty);
1912
Peter Hurley20bafb32013-06-15 10:21:19 -04001913 vfree(ldata);
Jiri Slaby70ece7a2012-10-18 22:26:38 +02001914 tty->disc_data = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001915}
1916
1917/**
1918 * n_tty_open - open an ldisc
1919 * @tty: terminal to open
1920 *
Alan Cox4edf1822008-02-08 04:18:44 -08001921 * Called when this line discipline is being attached to the
Linus Torvalds1da177e2005-04-16 15:20:36 -07001922 * terminal device. Can sleep. Called serialized so that no
1923 * other events will occur in parallel. No further open will occur
1924 * until a close.
1925 */
1926
1927static int n_tty_open(struct tty_struct *tty)
1928{
Jiri Slaby70ece7a2012-10-18 22:26:38 +02001929 struct n_tty_data *ldata;
1930
Peter Hurley20bafb32013-06-15 10:21:19 -04001931 /* Currently a malloc failure here can panic */
1932 ldata = vmalloc(sizeof(*ldata));
Jiri Slaby70ece7a2012-10-18 22:26:38 +02001933 if (!ldata)
1934 goto err;
1935
Jiri Slaby53c5ee22012-10-18 22:26:39 +02001936 ldata->overrun_time = jiffies;
Jiri Slabybddc7152012-10-18 22:26:42 +02001937 mutex_init(&ldata->atomic_read_lock);
1938 mutex_init(&ldata->output_lock);
Jiri Slaby53c5ee22012-10-18 22:26:39 +02001939
Jiri Slaby70ece7a2012-10-18 22:26:38 +02001940 tty->disc_data = ldata;
Peter Hurleyb66f4fa2013-03-11 16:44:32 -04001941 reset_buffer_flags(tty->disc_data);
Jiri Slaby53c5ee22012-10-18 22:26:39 +02001942 ldata->column = 0;
Peter Hurley20bafb32013-06-15 10:21:19 -04001943 ldata->canon_column = 0;
Peter Hurleyf6c8dbe2013-06-15 07:28:28 -04001944 ldata->minimum_to_wake = 1;
Peter Hurley20bafb32013-06-15 10:21:19 -04001945 ldata->num_overrun = 0;
1946 ldata->no_room = 0;
1947 ldata->lnext = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001948 tty->closing = 0;
Peter Hurleyb66f4fa2013-03-11 16:44:32 -04001949 /* indicate buffer work may resume */
1950 clear_bit(TTY_LDISC_HALTED, &tty->flags);
1951 n_tty_set_termios(tty, NULL);
1952 tty_unthrottle(tty);
Jiri Slaby70ece7a2012-10-18 22:26:38 +02001953
Linus Torvalds1da177e2005-04-16 15:20:36 -07001954 return 0;
Jiri Slaby70ece7a2012-10-18 22:26:38 +02001955err:
Jiri Slabyb91939f2012-10-18 22:26:35 +02001956 return -ENOMEM;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001957}
1958
Peter Hurleyeafbe672013-12-02 14:24:45 -05001959static inline int input_available_p(struct tty_struct *tty, int poll)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001960{
Jiri Slaby53c5ee22012-10-18 22:26:39 +02001961 struct n_tty_data *ldata = tty->disc_data;
Peter Hurleya5934802014-02-11 11:49:58 -05001962 int amt = poll && !TIME_CHAR(tty) && MIN_CHAR(tty) ? MIN_CHAR(tty) : 1;
Jiri Slaby53c5ee22012-10-18 22:26:39 +02001963
Peter Hurley25e8d0e2014-02-11 18:55:30 -05001964 if (ldata->icanon && !L_EXTPROC(tty))
1965 return ldata->canon_head != ldata->read_tail;
1966 else
Peter Hurley70aca712015-01-16 15:05:37 -05001967 return ldata->commit_head - ldata->read_tail >= amt;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001968}
1969
Peter Hurley1a486322015-04-13 13:24:34 -04001970static inline int check_other_done(struct tty_struct *tty)
1971{
1972 int done = test_bit(TTY_OTHER_DONE, &tty->flags);
1973 if (done) {
1974 /* paired with cmpxchg() in check_other_closed(); ensures
1975 * read buffer head index is not stale
1976 */
1977 smp_mb__after_atomic();
1978 }
1979 return done;
1980}
1981
Linus Torvalds1da177e2005-04-16 15:20:36 -07001982/**
Thorsten Wißmannbbd20752011-12-08 17:47:33 +01001983 * copy_from_read_buf - copy read data directly
Linus Torvalds1da177e2005-04-16 15:20:36 -07001984 * @tty: terminal device
1985 * @b: user data
1986 * @nr: size of data
1987 *
Alan Cox11a96d12008-10-13 10:46:24 +01001988 * Helper function to speed up n_tty_read. It is only called when
Linus Torvalds1da177e2005-04-16 15:20:36 -07001989 * ICANON is off; it copies characters straight from the tty queue to
1990 * user space directly. It can be profitably called twice; once to
1991 * drain the space from the tail pointer to the (physical) end of the
1992 * buffer, and once to drain the space from the (physical) beginning of
1993 * the buffer to head pointer.
1994 *
Jiri Slabybddc7152012-10-18 22:26:42 +02001995 * Called under the ldata->atomic_read_lock sem
Linus Torvalds1da177e2005-04-16 15:20:36 -07001996 *
Peter Hurley6d76bd22013-06-15 09:14:26 -04001997 * n_tty_read()/consumer path:
1998 * caller holds non-exclusive termios_rwsem
1999 * read_tail published
Linus Torvalds1da177e2005-04-16 15:20:36 -07002000 */
Alan Cox4edf1822008-02-08 04:18:44 -08002001
Alan Cox33f0f882006-01-09 20:54:13 -08002002static int copy_from_read_buf(struct tty_struct *tty,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002003 unsigned char __user **b,
2004 size_t *nr)
2005
2006{
Jiri Slaby53c5ee22012-10-18 22:26:39 +02002007 struct n_tty_data *ldata = tty->disc_data;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002008 int retval;
2009 size_t n;
Jiri Slaby3fa10cc2012-04-26 20:13:00 +02002010 bool is_eof;
Peter Hurley70aca712015-01-16 15:05:37 -05002011 size_t head = smp_load_acquire(&ldata->commit_head);
Peter Hurleybc5a5e32013-06-15 09:14:21 -04002012 size_t tail = ldata->read_tail & (N_TTY_BUF_SIZE - 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002013
2014 retval = 0;
Peter Hurley70aca712015-01-16 15:05:37 -05002015 n = min(head - ldata->read_tail, N_TTY_BUF_SIZE - tail);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002016 n = min(*nr, n);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002017 if (n) {
Peter Hurleybc5a5e32013-06-15 09:14:21 -04002018 retval = copy_to_user(*b, read_buf_addr(ldata, tail), n);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002019 n -= retval;
Peter Hurleybc5a5e32013-06-15 09:14:21 -04002020 is_eof = n == 1 && read_buf(ldata, tail) == EOF_CHAR(tty);
2021 tty_audit_add_data(tty, read_buf_addr(ldata, tail), n,
Jiri Slaby53c5ee22012-10-18 22:26:39 +02002022 ldata->icanon);
Peter Hurley70aca712015-01-16 15:05:37 -05002023 smp_store_release(&ldata->read_tail, ldata->read_tail + n);
hyc@symas.com26df6d12010-06-22 10:14:49 -07002024 /* Turn single EOF into zero-length read */
Peter Hurley70aca712015-01-16 15:05:37 -05002025 if (L_EXTPROC(tty) && ldata->icanon && is_eof &&
2026 (head == ldata->read_tail))
Jiri Slaby3fa10cc2012-04-26 20:13:00 +02002027 n = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002028 *b += n;
2029 *nr -= n;
2030 }
2031 return retval;
2032}
2033
Peter Hurley88bb0de2013-06-15 09:14:16 -04002034/**
Peter Hurley32f13522013-06-15 09:14:17 -04002035 * canon_copy_from_read_buf - copy read data in canonical mode
Peter Hurley88bb0de2013-06-15 09:14:16 -04002036 * @tty: terminal device
2037 * @b: user data
2038 * @nr: size of data
2039 *
2040 * Helper function for n_tty_read. It is only called when ICANON is on;
Peter Hurley32f13522013-06-15 09:14:17 -04002041 * it copies one line of input up to and including the line-delimiting
2042 * character into the user-space buffer.
Peter Hurley88bb0de2013-06-15 09:14:16 -04002043 *
Peter Hurley4d0ed182013-12-10 17:12:02 -05002044 * NB: When termios is changed from non-canonical to canonical mode and
2045 * the read buffer contains data, n_tty_set_termios() simulates an EOF
2046 * push (as if C-d were input) _without_ the DISABLED_CHAR in the buffer.
2047 * This causes data already processed as input to be immediately available
2048 * as input although a newline has not been received.
2049 *
Peter Hurley88bb0de2013-06-15 09:14:16 -04002050 * Called under the atomic_read_lock mutex
Peter Hurley6d76bd22013-06-15 09:14:26 -04002051 *
2052 * n_tty_read()/consumer path:
2053 * caller holds non-exclusive termios_rwsem
2054 * read_tail published
Peter Hurley88bb0de2013-06-15 09:14:16 -04002055 */
2056
Peter Hurley32f13522013-06-15 09:14:17 -04002057static int canon_copy_from_read_buf(struct tty_struct *tty,
2058 unsigned char __user **b,
2059 size_t *nr)
Peter Hurley88bb0de2013-06-15 09:14:16 -04002060{
2061 struct n_tty_data *ldata = tty->disc_data;
Peter Hurley32f13522013-06-15 09:14:17 -04002062 size_t n, size, more, c;
Peter Hurleybc5a5e32013-06-15 09:14:21 -04002063 size_t eol;
2064 size_t tail;
2065 int ret, found = 0;
Peter Hurley40d5e092013-06-15 10:21:17 -04002066 bool eof_push = 0;
Peter Hurley88bb0de2013-06-15 09:14:16 -04002067
2068 /* N.B. avoid overrun if nr == 0 */
Peter Hurley70aca712015-01-16 15:05:37 -05002069 n = min(*nr, smp_load_acquire(&ldata->canon_head) - ldata->read_tail);
Peter Hurley6d76bd22013-06-15 09:14:26 -04002070 if (!n)
Peter Hurley32f13522013-06-15 09:14:17 -04002071 return 0;
Peter Hurley88bb0de2013-06-15 09:14:16 -04002072
Peter Hurleybc5a5e32013-06-15 09:14:21 -04002073 tail = ldata->read_tail & (N_TTY_BUF_SIZE - 1);
Peter Hurley32f13522013-06-15 09:14:17 -04002074 size = min_t(size_t, tail + n, N_TTY_BUF_SIZE);
2075
Peter Hurleybc5a5e32013-06-15 09:14:21 -04002076 n_tty_trace("%s: nr:%zu tail:%zu n:%zu size:%zu\n",
Peter Hurley32f13522013-06-15 09:14:17 -04002077 __func__, *nr, tail, n, size);
2078
2079 eol = find_next_bit(ldata->read_flags, size, tail);
2080 more = n - (size - tail);
2081 if (eol == N_TTY_BUF_SIZE && more) {
2082 /* scan wrapped without finding set bit */
2083 eol = find_next_bit(ldata->read_flags, more, 0);
2084 if (eol != more)
2085 found = 1;
2086 } else if (eol != size)
2087 found = 1;
2088
2089 size = N_TTY_BUF_SIZE - tail;
Peter Hurleyc77569d2013-11-22 07:16:25 -05002090 n = eol - tail;
Mark Tomlinsonda555db2015-05-18 12:01:48 +12002091 if (n > N_TTY_BUF_SIZE)
2092 n += N_TTY_BUF_SIZE;
Peter Hurleyc77569d2013-11-22 07:16:25 -05002093 n += found;
Peter Hurley32f13522013-06-15 09:14:17 -04002094 c = n;
2095
Peter Hurley4d0ed182013-12-10 17:12:02 -05002096 if (found && !ldata->push && read_buf(ldata, eol) == __DISABLED_CHAR) {
Peter Hurley32f13522013-06-15 09:14:17 -04002097 n--;
Peter Hurley40d5e092013-06-15 10:21:17 -04002098 eof_push = !n && ldata->read_tail != ldata->line_start;
2099 }
Peter Hurley32f13522013-06-15 09:14:17 -04002100
Peter Hurleybc5a5e32013-06-15 09:14:21 -04002101 n_tty_trace("%s: eol:%zu found:%d n:%zu c:%zu size:%zu more:%zu\n",
Peter Hurley32f13522013-06-15 09:14:17 -04002102 __func__, eol, found, n, c, size, more);
2103
Peter Hurley32f13522013-06-15 09:14:17 -04002104 if (n > size) {
Laura Abbott72586c62015-05-14 11:42:17 -07002105 ret = tty_copy_to_user(tty, *b, read_buf_addr(ldata, tail), size);
Peter Hurley32f13522013-06-15 09:14:17 -04002106 if (ret)
2107 return -EFAULT;
Laura Abbott72586c62015-05-14 11:42:17 -07002108 ret = tty_copy_to_user(tty, *b + size, ldata->read_buf, n - size);
Peter Hurley32f13522013-06-15 09:14:17 -04002109 } else
Laura Abbott72586c62015-05-14 11:42:17 -07002110 ret = tty_copy_to_user(tty, *b, read_buf_addr(ldata, tail), n);
Peter Hurley32f13522013-06-15 09:14:17 -04002111
2112 if (ret)
2113 return -EFAULT;
2114 *b += n;
2115 *nr -= n;
2116
Peter Hurleya73d3d62013-06-15 09:14:25 -04002117 if (found)
Peter Hurley6d76bd22013-06-15 09:14:26 -04002118 clear_bit(eol, ldata->read_flags);
Peter Hurley70aca712015-01-16 15:05:37 -05002119 smp_store_release(&ldata->read_tail, ldata->read_tail + c);
Peter Hurley88bb0de2013-06-15 09:14:16 -04002120
Peter Hurley40d5e092013-06-15 10:21:17 -04002121 if (found) {
Peter Hurley4d0ed182013-12-10 17:12:02 -05002122 if (!ldata->push)
2123 ldata->line_start = ldata->read_tail;
2124 else
2125 ldata->push = 0;
Peter Hurley32f13522013-06-15 09:14:17 -04002126 tty_audit_push(tty);
Peter Hurley40d5e092013-06-15 10:21:17 -04002127 }
2128 return eof_push ? -EAGAIN : 0;
Peter Hurley88bb0de2013-06-15 09:14:16 -04002129}
2130
Al Virocc4191d2008-03-29 03:08:48 +00002131extern ssize_t redirected_tty_write(struct file *, const char __user *,
Alan Cox4edf1822008-02-08 04:18:44 -08002132 size_t, loff_t *);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002133
2134/**
2135 * job_control - check job control
2136 * @tty: tty
2137 * @file: file handle
2138 *
2139 * Perform job control management checks on this file/tty descriptor
Alan Cox4edf1822008-02-08 04:18:44 -08002140 * and if appropriate send any needed signals and return a negative
Linus Torvalds1da177e2005-04-16 15:20:36 -07002141 * error code if action should be taken.
Alan Cox04f378b2008-04-30 00:53:29 -07002142 *
Peter Hurley01a5e442013-03-06 08:38:20 -05002143 * Locking: redirected write test is safe
2144 * current->signal->tty check is safe
2145 * ctrl_lock to safely reference tty->pgrp
Linus Torvalds1da177e2005-04-16 15:20:36 -07002146 */
Alan Cox4edf1822008-02-08 04:18:44 -08002147
Linus Torvalds1da177e2005-04-16 15:20:36 -07002148static int job_control(struct tty_struct *tty, struct file *file)
2149{
Patrick Donnelly67196932015-07-12 18:51:52 -04002150 struct pid *pgrp;
2151
Linus Torvalds1da177e2005-04-16 15:20:36 -07002152 /* Job control check -- must be done at start and after
2153 every sleep (POSIX.1 7.1.1.4). */
2154 /* NOTE: not yet done after every sleep pending a thorough
2155 check of the logic of this change. -- jlc */
2156 /* don't stop on /dev/console */
Peter Hurley01a5e442013-03-06 08:38:20 -05002157 if (file->f_op->write == redirected_tty_write ||
2158 current->signal->tty != tty)
2159 return 0;
2160
Patrick Donnelly67196932015-07-12 18:51:52 -04002161 rcu_read_lock();
2162 pgrp = task_pgrp(current);
2163
Peter Hurley01a5e442013-03-06 08:38:20 -05002164 spin_lock_irq(&tty->ctrl_lock);
2165 if (!tty->pgrp)
2166 printk(KERN_ERR "n_tty_read: no tty->pgrp!\n");
Patrick Donnelly67196932015-07-12 18:51:52 -04002167 else if (pgrp != tty->pgrp) {
Peter Hurley01a5e442013-03-06 08:38:20 -05002168 spin_unlock_irq(&tty->ctrl_lock);
Patrick Donnelly67196932015-07-12 18:51:52 -04002169 if (is_ignored(SIGTTIN) || is_current_pgrp_orphaned()) {
2170 rcu_read_unlock();
Peter Hurley01a5e442013-03-06 08:38:20 -05002171 return -EIO;
Patrick Donnelly67196932015-07-12 18:51:52 -04002172 }
2173 kill_pgrp(pgrp, SIGTTIN, 1);
2174 rcu_read_unlock();
Peter Hurley01a5e442013-03-06 08:38:20 -05002175 set_thread_flag(TIF_SIGPENDING);
2176 return -ERESTARTSYS;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002177 }
Peter Hurley01a5e442013-03-06 08:38:20 -05002178 spin_unlock_irq(&tty->ctrl_lock);
Patrick Donnelly67196932015-07-12 18:51:52 -04002179 rcu_read_unlock();
Linus Torvalds1da177e2005-04-16 15:20:36 -07002180 return 0;
2181}
Alan Cox4edf1822008-02-08 04:18:44 -08002182
Linus Torvalds1da177e2005-04-16 15:20:36 -07002183
2184/**
Alan Cox11a96d12008-10-13 10:46:24 +01002185 * n_tty_read - read function for tty
Linus Torvalds1da177e2005-04-16 15:20:36 -07002186 * @tty: tty device
2187 * @file: file object
2188 * @buf: userspace buffer pointer
2189 * @nr: size of I/O
2190 *
2191 * Perform reads for the line discipline. We are guaranteed that the
2192 * line discipline will not be closed under us but we may get multiple
2193 * parallel readers and must handle this ourselves. We may also get
2194 * a hangup. Always called in user context, may sleep.
2195 *
2196 * This code must be sure never to sleep through a hangup.
Peter Hurley6d76bd22013-06-15 09:14:26 -04002197 *
2198 * n_tty_read()/consumer path:
2199 * claims non-exclusive termios_rwsem
2200 * publishes read_tail
Linus Torvalds1da177e2005-04-16 15:20:36 -07002201 */
Alan Cox4edf1822008-02-08 04:18:44 -08002202
Alan Cox11a96d12008-10-13 10:46:24 +01002203static ssize_t n_tty_read(struct tty_struct *tty, struct file *file,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002204 unsigned char __user *buf, size_t nr)
2205{
Jiri Slaby53c5ee22012-10-18 22:26:39 +02002206 struct n_tty_data *ldata = tty->disc_data;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002207 unsigned char __user *b = buf;
Peter Zijlstra97d9e282014-09-24 10:18:51 +02002208 DEFINE_WAIT_FUNC(wait, woken_wake_function);
Peter Hurley1a486322015-04-13 13:24:34 -04002209 int c, done;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002210 int minimum, time;
2211 ssize_t retval = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002212 long timeout;
Alan Cox04f378b2008-04-30 00:53:29 -07002213 int packet;
Peter Hurley2c5dc462015-01-16 15:05:34 -05002214 size_t tail;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002215
Linus Torvalds1da177e2005-04-16 15:20:36 -07002216 c = job_control(tty, file);
Alan Cox4edf1822008-02-08 04:18:44 -08002217 if (c < 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002218 return c;
Alan Cox4edf1822008-02-08 04:18:44 -08002219
Peter Hurleyaefceaf2013-08-11 08:04:23 -04002220 /*
2221 * Internal serialization of reads.
2222 */
2223 if (file->f_flags & O_NONBLOCK) {
2224 if (!mutex_trylock(&ldata->atomic_read_lock))
2225 return -EAGAIN;
2226 } else {
2227 if (mutex_lock_interruptible(&ldata->atomic_read_lock))
2228 return -ERESTARTSYS;
2229 }
2230
Peter Hurley9356b532013-06-15 09:14:24 -04002231 down_read(&tty->termios_rwsem);
2232
Linus Torvalds1da177e2005-04-16 15:20:36 -07002233 minimum = time = 0;
2234 timeout = MAX_SCHEDULE_TIMEOUT;
Jiri Slaby53c5ee22012-10-18 22:26:39 +02002235 if (!ldata->icanon) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002236 minimum = MIN_CHAR(tty);
2237 if (minimum) {
Peter Hurleya6e54312013-06-15 07:28:29 -04002238 time = (HZ / 10) * TIME_CHAR(tty);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002239 if (time)
Peter Hurleyf6c8dbe2013-06-15 07:28:28 -04002240 ldata->minimum_to_wake = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002241 else if (!waitqueue_active(&tty->read_wait) ||
Peter Hurleyf6c8dbe2013-06-15 07:28:28 -04002242 (ldata->minimum_to_wake > minimum))
2243 ldata->minimum_to_wake = minimum;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002244 } else {
Peter Hurleya6e54312013-06-15 07:28:29 -04002245 timeout = (HZ / 10) * TIME_CHAR(tty);
Peter Hurleyf6c8dbe2013-06-15 07:28:28 -04002246 ldata->minimum_to_wake = minimum = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002247 }
2248 }
2249
Alan Cox04f378b2008-04-30 00:53:29 -07002250 packet = tty->packet;
Peter Hurley2c5dc462015-01-16 15:05:34 -05002251 tail = ldata->read_tail;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002252
2253 add_wait_queue(&tty->read_wait, &wait);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002254 while (nr) {
2255 /* First test for status change. */
Alan Cox04f378b2008-04-30 00:53:29 -07002256 if (packet && tty->link->ctrl_status) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002257 unsigned char cs;
2258 if (b != buf)
2259 break;
Peter Hurley6054c16e2014-10-16 15:33:25 -04002260 spin_lock_irq(&tty->link->ctrl_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002261 cs = tty->link->ctrl_status;
2262 tty->link->ctrl_status = 0;
Peter Hurley6054c16e2014-10-16 15:33:25 -04002263 spin_unlock_irq(&tty->link->ctrl_lock);
Miloslav Trmac522ed772007-07-15 23:40:56 -07002264 if (tty_put_user(tty, cs, b++)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002265 retval = -EFAULT;
2266 b--;
2267 break;
2268 }
2269 nr--;
2270 break;
2271 }
Alan Cox4edf1822008-02-08 04:18:44 -08002272
Peter Hurleyf6c8dbe2013-06-15 07:28:28 -04002273 if (((minimum - (b - buf)) < ldata->minimum_to_wake) &&
Linus Torvalds1da177e2005-04-16 15:20:36 -07002274 ((minimum - (b - buf)) >= 1))
Peter Hurleyf6c8dbe2013-06-15 07:28:28 -04002275 ldata->minimum_to_wake = (minimum - (b - buf));
Alan Cox4edf1822008-02-08 04:18:44 -08002276
Peter Hurley1a486322015-04-13 13:24:34 -04002277 done = check_other_done(tty);
2278
Linus Torvalds1da177e2005-04-16 15:20:36 -07002279 if (!input_available_p(tty, 0)) {
Peter Hurley1a486322015-04-13 13:24:34 -04002280 if (done) {
Peter Hurley52bce7f2014-11-05 12:13:05 -05002281 retval = -EIO;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002282 break;
2283 }
Peter Hurley52bce7f2014-11-05 12:13:05 -05002284 if (tty_hung_up_p(file))
2285 break;
2286 if (!timeout)
2287 break;
2288 if (file->f_flags & O_NONBLOCK) {
2289 retval = -EAGAIN;
2290 break;
2291 }
2292 if (signal_pending(current)) {
2293 retval = -ERESTARTSYS;
2294 break;
2295 }
Peter Hurley52bce7f2014-11-05 12:13:05 -05002296 up_read(&tty->termios_rwsem);
2297
Linus Torvalds37da7bb2014-12-14 15:23:32 -08002298 timeout = wait_woken(&wait, TASK_INTERRUPTIBLE,
2299 timeout);
Peter Hurley52bce7f2014-11-05 12:13:05 -05002300
2301 down_read(&tty->termios_rwsem);
2302 continue;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002303 }
2304
Jiri Slaby53c5ee22012-10-18 22:26:39 +02002305 if (ldata->icanon && !L_EXTPROC(tty)) {
Peter Hurley32f13522013-06-15 09:14:17 -04002306 retval = canon_copy_from_read_buf(tty, &b, &nr);
Peter Hurley40d5e092013-06-15 10:21:17 -04002307 if (retval == -EAGAIN) {
2308 retval = 0;
2309 continue;
2310 } else if (retval)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002311 break;
2312 } else {
2313 int uncopied;
Peter Hurley95ea90d2014-10-16 15:33:30 -04002314
2315 /* Deal with packet mode. */
2316 if (packet && b == buf) {
2317 if (tty_put_user(tty, TIOCPKT_DATA, b++)) {
2318 retval = -EFAULT;
2319 b--;
2320 break;
2321 }
2322 nr--;
2323 }
2324
Linus Torvalds1da177e2005-04-16 15:20:36 -07002325 uncopied = copy_from_read_buf(tty, &b, &nr);
2326 uncopied += copy_from_read_buf(tty, &b, &nr);
2327 if (uncopied) {
2328 retval = -EFAULT;
2329 break;
2330 }
2331 }
2332
Peter Hurley6367ca72013-06-15 09:14:33 -04002333 n_tty_check_unthrottle(tty);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002334
2335 if (b - buf >= minimum)
2336 break;
2337 if (time)
2338 timeout = time;
2339 }
Peter Hurley2c5dc462015-01-16 15:05:34 -05002340 if (tail != ldata->read_tail)
2341 n_tty_kick_worker(tty);
Peter Hurley42458f42013-11-07 13:59:46 -05002342 up_read(&tty->termios_rwsem);
2343
Linus Torvalds1da177e2005-04-16 15:20:36 -07002344 remove_wait_queue(&tty->read_wait, &wait);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002345 if (!waitqueue_active(&tty->read_wait))
Peter Hurleyf6c8dbe2013-06-15 07:28:28 -04002346 ldata->minimum_to_wake = minimum;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002347
Peter Hurleyaebf04532013-11-07 14:01:57 -05002348 mutex_unlock(&ldata->atomic_read_lock);
2349
Peter Hurley40d5e092013-06-15 10:21:17 -04002350 if (b - buf)
2351 retval = b - buf;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002352
2353 return retval;
2354}
2355
2356/**
Alan Cox11a96d12008-10-13 10:46:24 +01002357 * n_tty_write - write function for tty
Linus Torvalds1da177e2005-04-16 15:20:36 -07002358 * @tty: tty device
2359 * @file: file object
2360 * @buf: userspace buffer pointer
2361 * @nr: size of I/O
2362 *
Joe Petersona88a69c2009-01-02 13:40:53 +00002363 * Write function of the terminal device. This is serialized with
Linus Torvalds1da177e2005-04-16 15:20:36 -07002364 * respect to other write callers but not to termios changes, reads
Joe Petersona88a69c2009-01-02 13:40:53 +00002365 * and other such events. Since the receive code will echo characters,
2366 * thus calling driver write methods, the output_lock is used in
2367 * the output processing functions called here as well as in the
2368 * echo processing function to protect the column state and space
2369 * left in the buffer.
Linus Torvalds1da177e2005-04-16 15:20:36 -07002370 *
2371 * This code must be sure never to sleep through a hangup.
Joe Petersona88a69c2009-01-02 13:40:53 +00002372 *
2373 * Locking: output_lock to protect column state and space left
2374 * (note that the process_output*() functions take this
2375 * lock themselves)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002376 */
Alan Cox4edf1822008-02-08 04:18:44 -08002377
Alan Cox11a96d12008-10-13 10:46:24 +01002378static ssize_t n_tty_write(struct tty_struct *tty, struct file *file,
Joe Petersona88a69c2009-01-02 13:40:53 +00002379 const unsigned char *buf, size_t nr)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002380{
2381 const unsigned char *b = buf;
Peter Zijlstra97d9e282014-09-24 10:18:51 +02002382 DEFINE_WAIT_FUNC(wait, woken_wake_function);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002383 int c;
2384 ssize_t retval = 0;
2385
2386 /* Job control check -- must be done at start (POSIX.1 7.1.1.4). */
2387 if (L_TOSTOP(tty) && file->f_op->write != redirected_tty_write) {
2388 retval = tty_check_change(tty);
2389 if (retval)
2390 return retval;
2391 }
2392
Peter Hurley9356b532013-06-15 09:14:24 -04002393 down_read(&tty->termios_rwsem);
2394
Joe Petersona88a69c2009-01-02 13:40:53 +00002395 /* Write out any echoed characters that are still pending */
2396 process_echoes(tty);
Alan Cox300a6202009-01-02 13:41:04 +00002397
Linus Torvalds1da177e2005-04-16 15:20:36 -07002398 add_wait_queue(&tty->write_wait, &wait);
2399 while (1) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002400 if (signal_pending(current)) {
2401 retval = -ERESTARTSYS;
2402 break;
2403 }
2404 if (tty_hung_up_p(file) || (tty->link && !tty->link->count)) {
2405 retval = -EIO;
2406 break;
2407 }
Peter Hurley582f5592013-05-17 12:49:48 -04002408 if (O_OPOST(tty)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002409 while (nr > 0) {
Joe Petersona88a69c2009-01-02 13:40:53 +00002410 ssize_t num = process_output_block(tty, b, nr);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002411 if (num < 0) {
2412 if (num == -EAGAIN)
2413 break;
2414 retval = num;
2415 goto break_out;
2416 }
2417 b += num;
2418 nr -= num;
2419 if (nr == 0)
2420 break;
2421 c = *b;
Joe Petersona88a69c2009-01-02 13:40:53 +00002422 if (process_output(c, tty) < 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002423 break;
2424 b++; nr--;
2425 }
Alan Coxf34d7a52008-04-30 00:54:13 -07002426 if (tty->ops->flush_chars)
2427 tty->ops->flush_chars(tty);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002428 } else {
Peter Hurley42910862014-05-03 14:04:59 +02002429 struct n_tty_data *ldata = tty->disc_data;
2430
Roman Zippeld6afe272005-07-07 17:56:55 -07002431 while (nr > 0) {
Peter Hurley42910862014-05-03 14:04:59 +02002432 mutex_lock(&ldata->output_lock);
Alan Coxf34d7a52008-04-30 00:54:13 -07002433 c = tty->ops->write(tty, b, nr);
Peter Hurley42910862014-05-03 14:04:59 +02002434 mutex_unlock(&ldata->output_lock);
Roman Zippeld6afe272005-07-07 17:56:55 -07002435 if (c < 0) {
2436 retval = c;
2437 goto break_out;
2438 }
2439 if (!c)
2440 break;
2441 b += c;
2442 nr -= c;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002443 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002444 }
2445 if (!nr)
2446 break;
2447 if (file->f_flags & O_NONBLOCK) {
2448 retval = -EAGAIN;
2449 break;
2450 }
Peter Hurley9356b532013-06-15 09:14:24 -04002451 up_read(&tty->termios_rwsem);
2452
Peter Zijlstra97d9e282014-09-24 10:18:51 +02002453 wait_woken(&wait, TASK_INTERRUPTIBLE, MAX_SCHEDULE_TIMEOUT);
Peter Hurley9356b532013-06-15 09:14:24 -04002454
2455 down_read(&tty->termios_rwsem);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002456 }
2457break_out:
Linus Torvalds1da177e2005-04-16 15:20:36 -07002458 remove_wait_queue(&tty->write_wait, &wait);
Thomas Pfaffff8cb0f2009-01-02 13:47:13 +00002459 if (b - buf != nr && tty->fasync)
2460 set_bit(TTY_DO_WRITE_WAKEUP, &tty->flags);
Peter Hurley9356b532013-06-15 09:14:24 -04002461 up_read(&tty->termios_rwsem);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002462 return (b - buf) ? b - buf : retval;
2463}
2464
2465/**
Alan Cox11a96d12008-10-13 10:46:24 +01002466 * n_tty_poll - poll method for N_TTY
Linus Torvalds1da177e2005-04-16 15:20:36 -07002467 * @tty: terminal device
2468 * @file: file accessing it
2469 * @wait: poll table
2470 *
2471 * Called when the line discipline is asked to poll() for data or
2472 * for special events. This code is not serialized with respect to
2473 * other events save open/close.
2474 *
2475 * This code must be sure never to sleep through a hangup.
2476 * Called without the kernel lock held - fine
Linus Torvalds1da177e2005-04-16 15:20:36 -07002477 */
Alan Cox4edf1822008-02-08 04:18:44 -08002478
Alan Cox11a96d12008-10-13 10:46:24 +01002479static unsigned int n_tty_poll(struct tty_struct *tty, struct file *file,
Alan Cox4edf1822008-02-08 04:18:44 -08002480 poll_table *wait)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002481{
Peter Hurleyf6c8dbe2013-06-15 07:28:28 -04002482 struct n_tty_data *ldata = tty->disc_data;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002483 unsigned int mask = 0;
2484
2485 poll_wait(file, &tty->read_wait, wait);
2486 poll_wait(file, &tty->write_wait, wait);
Peter Hurley1a486322015-04-13 13:24:34 -04002487 if (check_other_done(tty))
2488 mask |= POLLHUP;
Francesco Ruggeric4dc3042014-10-10 13:09:53 -07002489 if (input_available_p(tty, 1))
2490 mask |= POLLIN | POLLRDNORM;
Francesco Ruggeric4dc3042014-10-10 13:09:53 -07002491 if (tty->packet && tty->link->ctrl_status)
2492 mask |= POLLPRI | POLLIN | POLLRDNORM;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002493 if (tty_hung_up_p(file))
2494 mask |= POLLHUP;
2495 if (!(mask & (POLLHUP | POLLIN | POLLRDNORM))) {
2496 if (MIN_CHAR(tty) && !TIME_CHAR(tty))
Peter Hurleyf6c8dbe2013-06-15 07:28:28 -04002497 ldata->minimum_to_wake = MIN_CHAR(tty);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002498 else
Peter Hurleyf6c8dbe2013-06-15 07:28:28 -04002499 ldata->minimum_to_wake = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002500 }
Alan Coxf34d7a52008-04-30 00:54:13 -07002501 if (tty->ops->write && !tty_is_writelocked(tty) &&
2502 tty_chars_in_buffer(tty) < WAKEUP_CHARS &&
2503 tty_write_room(tty) > 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002504 mask |= POLLOUT | POLLWRNORM;
2505 return mask;
2506}
2507
Jiri Slaby57c94122012-10-18 22:26:43 +02002508static unsigned long inq_canon(struct n_tty_data *ldata)
Alan Cox47afa7a2008-10-13 10:44:17 +01002509{
Peter Hurleybc5a5e32013-06-15 09:14:21 -04002510 size_t nr, head, tail;
Alan Cox47afa7a2008-10-13 10:44:17 +01002511
Peter Hurleya73d3d62013-06-15 09:14:25 -04002512 if (ldata->canon_head == ldata->read_tail)
Alan Cox47afa7a2008-10-13 10:44:17 +01002513 return 0;
Jiri Slabyba2e68a2012-10-18 22:26:41 +02002514 head = ldata->canon_head;
2515 tail = ldata->read_tail;
Peter Hurleybc5a5e32013-06-15 09:14:21 -04002516 nr = head - tail;
Alan Cox47afa7a2008-10-13 10:44:17 +01002517 /* Skip EOF-chars.. */
2518 while (head != tail) {
Peter Hurleybc5a5e32013-06-15 09:14:21 -04002519 if (test_bit(tail & (N_TTY_BUF_SIZE - 1), ldata->read_flags) &&
2520 read_buf(ldata, tail) == __DISABLED_CHAR)
Alan Cox47afa7a2008-10-13 10:44:17 +01002521 nr--;
Peter Hurleybc5a5e32013-06-15 09:14:21 -04002522 tail++;
Alan Cox47afa7a2008-10-13 10:44:17 +01002523 }
2524 return nr;
2525}
2526
2527static int n_tty_ioctl(struct tty_struct *tty, struct file *file,
2528 unsigned int cmd, unsigned long arg)
2529{
Jiri Slabyba2e68a2012-10-18 22:26:41 +02002530 struct n_tty_data *ldata = tty->disc_data;
Alan Cox47afa7a2008-10-13 10:44:17 +01002531 int retval;
2532
2533 switch (cmd) {
2534 case TIOCOUTQ:
2535 return put_user(tty_chars_in_buffer(tty), (int __user *) arg);
2536 case TIOCINQ:
Peter Hurley6d76bd22013-06-15 09:14:26 -04002537 down_write(&tty->termios_rwsem);
Alan Cox47afa7a2008-10-13 10:44:17 +01002538 if (L_ICANON(tty))
Jiri Slaby57c94122012-10-18 22:26:43 +02002539 retval = inq_canon(ldata);
Peter Hurley6d76bd22013-06-15 09:14:26 -04002540 else
2541 retval = read_cnt(ldata);
2542 up_write(&tty->termios_rwsem);
Alan Cox47afa7a2008-10-13 10:44:17 +01002543 return put_user(retval, (unsigned int __user *) arg);
2544 default:
2545 return n_tty_ioctl_helper(tty, file, cmd, arg);
2546 }
2547}
2548
Peter Hurleyf6c8dbe2013-06-15 07:28:28 -04002549static void n_tty_fasync(struct tty_struct *tty, int on)
2550{
2551 struct n_tty_data *ldata = tty->disc_data;
2552
2553 if (!waitqueue_active(&tty->read_wait)) {
2554 if (on)
2555 ldata->minimum_to_wake = 1;
2556 else if (!tty->fasync)
2557 ldata->minimum_to_wake = N_TTY_BUF_SIZE;
2558 }
2559}
2560
Alan Coxa352def2008-07-16 21:53:12 +01002561struct tty_ldisc_ops tty_ldisc_N_TTY = {
Paul Fulghume10cc1d2007-05-10 22:22:50 -07002562 .magic = TTY_LDISC_MAGIC,
2563 .name = "n_tty",
2564 .open = n_tty_open,
2565 .close = n_tty_close,
2566 .flush_buffer = n_tty_flush_buffer,
2567 .chars_in_buffer = n_tty_chars_in_buffer,
Alan Cox11a96d12008-10-13 10:46:24 +01002568 .read = n_tty_read,
2569 .write = n_tty_write,
Paul Fulghume10cc1d2007-05-10 22:22:50 -07002570 .ioctl = n_tty_ioctl,
2571 .set_termios = n_tty_set_termios,
Alan Cox11a96d12008-10-13 10:46:24 +01002572 .poll = n_tty_poll,
Paul Fulghume10cc1d2007-05-10 22:22:50 -07002573 .receive_buf = n_tty_receive_buf,
Peter Hurleyf6c8dbe2013-06-15 07:28:28 -04002574 .write_wakeup = n_tty_write_wakeup,
2575 .fasync = n_tty_fasync,
Peter Hurley24a89d12013-06-15 09:14:15 -04002576 .receive_buf2 = n_tty_receive_buf2,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002577};
Rodolfo Giometti572b9ad2010-03-10 15:23:46 -08002578
2579/**
2580 * n_tty_inherit_ops - inherit N_TTY methods
2581 * @ops: struct tty_ldisc_ops where to save N_TTY methods
2582 *
George Spelvin593fb1ae42013-02-12 02:00:43 -05002583 * Enables a 'subclass' line discipline to 'inherit' N_TTY
Rodolfo Giometti572b9ad2010-03-10 15:23:46 -08002584 * methods.
2585 */
2586
2587void n_tty_inherit_ops(struct tty_ldisc_ops *ops)
2588{
2589 *ops = tty_ldisc_N_TTY;
2590 ops->owner = NULL;
2591 ops->refcount = ops->flags = 0;
2592}
2593EXPORT_SYMBOL_GPL(n_tty_inherit_ops);