blob: 2e900a98c3e34e9d732deee15cb009db2372d3c9 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
2 * n_tty.c --- implements the N_TTY line discipline.
Alan Cox4edf1822008-02-08 04:18:44 -08003 *
Linus Torvalds1da177e2005-04-16 15:20:36 -07004 * This code used to be in tty_io.c, but things are getting hairy
5 * enough that it made sense to split things off. (The N_TTY
6 * processing has changed so much that it's hardly recognizable,
7 * anyway...)
8 *
9 * Note that the open routine for N_TTY is guaranteed never to return
10 * an error. This is because Linux will fall back to setting a line
Alan Cox4edf1822008-02-08 04:18:44 -080011 * to N_TTY if it can not switch to any other line discipline.
Linus Torvalds1da177e2005-04-16 15:20:36 -070012 *
13 * Written by Theodore Ts'o, Copyright 1994.
Alan Cox4edf1822008-02-08 04:18:44 -080014 *
Linus Torvalds1da177e2005-04-16 15:20:36 -070015 * This file also contains code originally written by Linus Torvalds,
16 * Copyright 1991, 1992, 1993, and by Julian Cowley, Copyright 1994.
Alan Cox4edf1822008-02-08 04:18:44 -080017 *
Linus Torvalds1da177e2005-04-16 15:20:36 -070018 * This file may be redistributed under the terms of the GNU General Public
19 * License.
20 *
21 * Reduced memory usage for older ARM systems - Russell King.
22 *
Alan Cox4edf1822008-02-08 04:18:44 -080023 * 2000/01/20 Fixed SMP locking on put_tty_queue using bits of
Linus Torvalds1da177e2005-04-16 15:20:36 -070024 * the patch by Andrew J. Kroll <ag784@freenet.buffalo.edu>
25 * who actually finally proved there really was a race.
26 *
27 * 2002/03/18 Implemented n_tty_wakeup to send SIGIO POLL_OUTs to
28 * waiting writing processes-Sapan Bhatia <sapan@corewars.org>.
Alan Cox11a96d12008-10-13 10:46:24 +010029 * Also fixed a bug in BLOCKING mode where n_tty_write returns
Linus Torvalds1da177e2005-04-16 15:20:36 -070030 * EAGAIN
31 */
32
33#include <linux/types.h>
34#include <linux/major.h>
35#include <linux/errno.h>
36#include <linux/signal.h>
37#include <linux/fcntl.h>
38#include <linux/sched.h>
39#include <linux/interrupt.h>
40#include <linux/tty.h>
41#include <linux/timer.h>
42#include <linux/ctype.h>
43#include <linux/mm.h>
44#include <linux/string.h>
45#include <linux/slab.h>
46#include <linux/poll.h>
47#include <linux/bitops.h>
Miloslav Trmac522ed772007-07-15 23:40:56 -070048#include <linux/audit.h>
49#include <linux/file.h>
Alan Cox300a6202009-01-02 13:41:04 +000050#include <linux/uaccess.h>
Rodolfo Giometti572b9ad2010-03-10 15:23:46 -080051#include <linux/module.h>
George Spelvin593fb1ae42013-02-12 02:00:43 -050052#include <linux/ratelimit.h>
Peter Hurley86e35ae2013-07-24 09:30:05 -040053#include <linux/vmalloc.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070054
Linus Torvalds1da177e2005-04-16 15:20:36 -070055
56/* number of characters left in xmit buffer before select has we have room */
57#define WAKEUP_CHARS 256
58
59/*
60 * This defines the low- and high-watermarks for throttling and
61 * unthrottling the TTY driver. These watermarks are used for
62 * controlling the space in the read buffer.
63 */
64#define TTY_THRESHOLD_THROTTLE 128 /* now based on remaining room */
Thorsten Wißmannbbd20752011-12-08 17:47:33 +010065#define TTY_THRESHOLD_UNTHROTTLE 128
Linus Torvalds1da177e2005-04-16 15:20:36 -070066
Joe Petersona88a69c2009-01-02 13:40:53 +000067/*
68 * Special byte codes used in the echo buffer to represent operations
69 * or special handling of characters. Bytes in the echo buffer that
70 * are not part of such special blocks are treated as normal character
71 * codes.
72 */
73#define ECHO_OP_START 0xff
74#define ECHO_OP_MOVE_BACK_COL 0x80
75#define ECHO_OP_SET_CANON_COL 0x81
76#define ECHO_OP_ERASE_TAB 0x82
77
Peter Hurleycbfd0342013-06-15 10:04:26 -040078#define ECHO_COMMIT_WATERMARK 256
79#define ECHO_BLOCK 256
80#define ECHO_DISCARD_WATERMARK N_TTY_BUF_SIZE - (ECHO_BLOCK + 32)
81
82
Peter Hurley32f13522013-06-15 09:14:17 -040083#undef N_TTY_TRACE
84#ifdef N_TTY_TRACE
85# define n_tty_trace(f, args...) trace_printk(f, ##args)
86#else
87# define n_tty_trace(f, args...)
88#endif
89
Jiri Slaby70ece7a2012-10-18 22:26:38 +020090struct n_tty_data {
Peter Hurleyfb7aa032013-06-15 09:14:30 -040091 /* producer-published */
92 size_t read_head;
93 size_t canon_head;
Peter Hurley9dfd16d2013-06-15 10:04:29 -040094 size_t echo_head;
95 size_t echo_commit;
Peter Hurley1075a6e2013-12-09 18:06:07 -050096 size_t echo_mark;
Peter Hurley1bb9d562013-06-15 10:21:20 -040097 DECLARE_BITMAP(char_map, 256);
Peter Hurleyfb7aa032013-06-15 09:14:30 -040098
99 /* private to n_tty_receive_overrun (single-threaded) */
Jiri Slaby53c5ee22012-10-18 22:26:39 +0200100 unsigned long overrun_time;
101 int num_overrun;
102
Peter Hurley24a89d12013-06-15 09:14:15 -0400103 /* non-atomic */
104 bool no_room;
105
Peter Hurleyfb7aa032013-06-15 09:14:30 -0400106 /* must hold exclusive termios_rwsem to reset these */
Jiri Slaby53c5ee22012-10-18 22:26:39 +0200107 unsigned char lnext:1, erasing:1, raw:1, real_raw:1, icanon:1;
Peter Hurley4d0ed182013-12-10 17:12:02 -0500108 unsigned char push:1;
Jiri Slaby3fe780b2012-10-18 22:26:40 +0200109
Peter Hurleyfb7aa032013-06-15 09:14:30 -0400110 /* shared by producer and consumer */
Peter Hurley20bafb32013-06-15 10:21:19 -0400111 char read_buf[N_TTY_BUF_SIZE];
Jiri Slaby3fe780b2012-10-18 22:26:40 +0200112 DECLARE_BITMAP(read_flags, N_TTY_BUF_SIZE);
Peter Hurley20bafb32013-06-15 10:21:19 -0400113 unsigned char echo_buf[N_TTY_BUF_SIZE];
Jiri Slabyba2e68a2012-10-18 22:26:41 +0200114
Peter Hurleyf6c8dbe2013-06-15 07:28:28 -0400115 int minimum_to_wake;
Jiri Slabyba2e68a2012-10-18 22:26:41 +0200116
Peter Hurleyfb7aa032013-06-15 09:14:30 -0400117 /* consumer-published */
118 size_t read_tail;
Peter Hurley40d5e092013-06-15 10:21:17 -0400119 size_t line_start;
Peter Hurleyfb7aa032013-06-15 09:14:30 -0400120
Peter Hurleyfb7aa032013-06-15 09:14:30 -0400121 /* protected by output lock */
122 unsigned int column;
Jiri Slabyba2e68a2012-10-18 22:26:41 +0200123 unsigned int canon_column;
Peter Hurley9dfd16d2013-06-15 10:04:29 -0400124 size_t echo_tail;
Jiri Slabybddc7152012-10-18 22:26:42 +0200125
126 struct mutex atomic_read_lock;
127 struct mutex output_lock;
Jiri Slaby70ece7a2012-10-18 22:26:38 +0200128};
129
Peter Hurleyce741172013-06-15 09:14:20 -0400130static inline size_t read_cnt(struct n_tty_data *ldata)
131{
Peter Hurleya2f73be2013-06-15 09:14:22 -0400132 return ldata->read_head - ldata->read_tail;
Peter Hurleyce741172013-06-15 09:14:20 -0400133}
134
Peter Hurleybc5a5e32013-06-15 09:14:21 -0400135static inline unsigned char read_buf(struct n_tty_data *ldata, size_t i)
136{
137 return ldata->read_buf[i & (N_TTY_BUF_SIZE - 1)];
138}
139
140static inline unsigned char *read_buf_addr(struct n_tty_data *ldata, size_t i)
141{
142 return &ldata->read_buf[i & (N_TTY_BUF_SIZE - 1)];
143}
144
Peter Hurleyaddaebc2013-06-15 10:04:22 -0400145static inline unsigned char echo_buf(struct n_tty_data *ldata, size_t i)
146{
147 return ldata->echo_buf[i & (N_TTY_BUF_SIZE - 1)];
148}
149
150static inline unsigned char *echo_buf_addr(struct n_tty_data *ldata, size_t i)
151{
152 return &ldata->echo_buf[i & (N_TTY_BUF_SIZE - 1)];
153}
154
Miloslav Trmac522ed772007-07-15 23:40:56 -0700155static inline int tty_put_user(struct tty_struct *tty, unsigned char x,
156 unsigned char __user *ptr)
157{
Jiri Slaby53c5ee22012-10-18 22:26:39 +0200158 struct n_tty_data *ldata = tty->disc_data;
159
160 tty_audit_add_data(tty, &x, 1, ldata->icanon);
Miloslav Trmac522ed772007-07-15 23:40:56 -0700161 return put_user(x, ptr);
162}
163
Peter Hurley24a89d12013-06-15 09:14:15 -0400164static int receive_room(struct tty_struct *tty)
Linus Torvalds55db4c62011-06-04 06:33:24 +0900165{
Jiri Slaby53c5ee22012-10-18 22:26:39 +0200166 struct n_tty_data *ldata = tty->disc_data;
Jaeden Amero090abf72012-07-27 08:43:11 -0500167 int left;
Peter Hurleyb8483052013-06-15 07:28:30 -0400168
Jaeden Amero090abf72012-07-27 08:43:11 -0500169 if (I_PARMRK(tty)) {
170 /* Multiply read_cnt by 3, since each byte might take up to
171 * three times as many spaces when PARMRK is set (depending on
172 * its flags, e.g. parity error). */
Peter Hurleyce741172013-06-15 09:14:20 -0400173 left = N_TTY_BUF_SIZE - read_cnt(ldata) * 3 - 1;
Jaeden Amero090abf72012-07-27 08:43:11 -0500174 } else
Peter Hurleyce741172013-06-15 09:14:20 -0400175 left = N_TTY_BUF_SIZE - read_cnt(ldata) - 1;
Jaeden Amero090abf72012-07-27 08:43:11 -0500176
Linus Torvalds55db4c62011-06-04 06:33:24 +0900177 /*
178 * If we are doing input canonicalization, and there are no
179 * pending newlines, let characters through without limit, so
180 * that erase characters will be handled. Other excess
181 * characters will be beeped.
182 */
183 if (left <= 0)
Peter Hurleya73d3d62013-06-15 09:14:25 -0400184 left = ldata->icanon && ldata->canon_head == ldata->read_tail;
Linus Torvalds55db4c62011-06-04 06:33:24 +0900185
Peter Hurley24a89d12013-06-15 09:14:15 -0400186 return left;
Peter Hurley7879a9f2013-06-15 07:28:31 -0400187}
188
Peter Hurley24a89d12013-06-15 09:14:15 -0400189/**
190 * n_tty_set_room - receive space
191 * @tty: terminal
192 *
193 * Re-schedules the flip buffer work if space just became available.
194 *
Peter Hurley6d76bd22013-06-15 09:14:26 -0400195 * Caller holds exclusive termios_rwsem
196 * or
197 * n_tty_read()/consumer path:
198 * holds non-exclusive termios_rwsem
Peter Hurley24a89d12013-06-15 09:14:15 -0400199 */
200
Peter Hurley7879a9f2013-06-15 07:28:31 -0400201static void n_tty_set_room(struct tty_struct *tty)
202{
Peter Hurley24a89d12013-06-15 09:14:15 -0400203 struct n_tty_data *ldata = tty->disc_data;
204
Linus Torvalds55db4c62011-06-04 06:33:24 +0900205 /* Did this open up the receive buffer? We may need to flip */
Peter Hurley24a89d12013-06-15 09:14:15 -0400206 if (unlikely(ldata->no_room) && receive_room(tty)) {
207 ldata->no_room = 0;
208
Jiri Slabyecbbfd42012-10-18 22:26:47 +0200209 WARN_RATELIMIT(tty->port->itty == NULL,
Sasha Levincadf7482012-10-25 14:26:35 -0400210 "scheduling with invalid itty\n");
Peter Hurley21622932013-03-11 16:44:21 -0400211 /* see if ldisc has been killed - if so, this means that
212 * even though the ldisc has been halted and ->buf.work
213 * cancelled, ->buf.work is about to be rescheduled
214 */
215 WARN_RATELIMIT(test_bit(TTY_LDISC_HALTED, &tty->flags),
216 "scheduling buffer work for halted ldisc\n");
Peter Hurleyf0f947c2013-06-15 09:14:36 -0400217 queue_work(system_unbound_wq, &tty->port->buf.work);
Jiri Slabyecbbfd42012-10-18 22:26:47 +0200218 }
Linus Torvalds55db4c62011-06-04 06:33:24 +0900219}
220
Peter Hurley9a4aec22013-06-15 09:14:32 -0400221static ssize_t chars_in_buffer(struct tty_struct *tty)
222{
223 struct n_tty_data *ldata = tty->disc_data;
224 ssize_t n = 0;
225
226 if (!ldata->icanon)
227 n = read_cnt(ldata);
228 else
229 n = ldata->canon_head - ldata->read_tail;
230 return n;
231}
232
Peter Hurleyee0bab82013-06-15 09:14:34 -0400233/**
234 * n_tty_write_wakeup - asynchronous I/O notifier
235 * @tty: tty device
236 *
237 * Required for the ptys, serial driver etc. since processes
238 * that attach themselves to the master and rely on ASYNC
239 * IO must be woken up
240 */
241
242static void n_tty_write_wakeup(struct tty_struct *tty)
243{
244 if (tty->fasync && test_and_clear_bit(TTY_DO_WRITE_WAKEUP, &tty->flags))
245 kill_fasync(&tty->fasync, SIGIO, POLL_OUT);
246}
247
Peter Hurley4a23a4d2013-06-15 10:21:22 -0400248static void n_tty_check_throttle(struct tty_struct *tty)
Peter Hurley6367ca72013-06-15 09:14:33 -0400249{
Peter Hurley3afb1b392013-07-23 08:47:30 -0400250 if (tty->driver->type == TTY_DRIVER_TYPE_PTY)
251 return;
Peter Hurley6367ca72013-06-15 09:14:33 -0400252 /*
253 * Check the remaining room for the input canonicalization
254 * mode. We don't want to throttle the driver if we're in
255 * canonical mode and don't have a newline yet!
256 */
257 while (1) {
258 int throttled;
259 tty_set_flow_change(tty, TTY_THROTTLE_SAFE);
260 if (receive_room(tty) >= TTY_THRESHOLD_THROTTLE)
261 break;
262 throttled = tty_throttle_safe(tty);
263 if (!throttled)
264 break;
265 }
266 __tty_set_flow_change(tty, 0);
267}
268
Peter Hurley4b293492013-07-24 08:29:55 -0400269static void n_tty_check_unthrottle(struct tty_struct *tty)
Peter Hurley6367ca72013-06-15 09:14:33 -0400270{
Peter Hurley3afb1b392013-07-23 08:47:30 -0400271 if (tty->driver->type == TTY_DRIVER_TYPE_PTY &&
272 tty->link->ldisc->ops->write_wakeup == n_tty_write_wakeup) {
273 if (chars_in_buffer(tty) > TTY_THRESHOLD_UNTHROTTLE)
274 return;
275 if (!tty->count)
276 return;
277 n_tty_set_room(tty);
278 n_tty_write_wakeup(tty->link);
Peter Hurley6c677162013-12-02 14:24:46 -0500279 if (waitqueue_active(&tty->link->write_wait))
280 wake_up_interruptible_poll(&tty->link->write_wait, POLLOUT);
Peter Hurley3afb1b392013-07-23 08:47:30 -0400281 return;
282 }
283
Peter Hurley6367ca72013-06-15 09:14:33 -0400284 /* If there is enough space in the read buffer now, let the
285 * low-level driver know. We use chars_in_buffer() to
286 * check the buffer, as it now knows about canonical mode.
287 * Otherwise, if the driver is throttled and the line is
288 * longer than TTY_THRESHOLD_UNTHROTTLE in canonical mode,
289 * we won't get any more characters.
290 */
291
292 while (1) {
293 int unthrottled;
294 tty_set_flow_change(tty, TTY_UNTHROTTLE_SAFE);
295 if (chars_in_buffer(tty) > TTY_THRESHOLD_UNTHROTTLE)
296 break;
297 if (!tty->count)
298 break;
299 n_tty_set_room(tty);
300 unthrottled = tty_unthrottle_safe(tty);
301 if (!unthrottled)
302 break;
303 }
304 __tty_set_flow_change(tty, 0);
305}
306
Alan Cox17b82062008-10-13 10:45:06 +0100307/**
308 * put_tty_queue - add character to tty
309 * @c: character
Jiri Slaby57c94122012-10-18 22:26:43 +0200310 * @ldata: n_tty data
Alan Cox17b82062008-10-13 10:45:06 +0100311 *
Peter Hurley6d76bd22013-06-15 09:14:26 -0400312 * Add a character to the tty read_buf queue.
313 *
314 * n_tty_receive_buf()/producer path:
315 * caller holds non-exclusive termios_rwsem
316 * modifies read_head
317 *
318 * read_head is only considered 'published' if canonical mode is
319 * not active.
Alan Cox17b82062008-10-13 10:45:06 +0100320 */
321
Peter Hurley19e2ad62013-07-24 08:29:54 -0400322static inline void put_tty_queue(unsigned char c, struct n_tty_data *ldata)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700323{
Peter Hurley19e2ad62013-07-24 08:29:54 -0400324 *read_buf_addr(ldata, ldata->read_head++) = c;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700325}
326
327/**
Linus Torvalds1da177e2005-04-16 15:20:36 -0700328 * reset_buffer_flags - reset buffer state
329 * @tty: terminal to reset
330 *
Peter Hurley25518c62013-03-11 16:44:31 -0400331 * Reset the read buffer counters and clear the flags.
332 * Called from n_tty_open() and n_tty_flush_buffer().
Alan Cox17b82062008-10-13 10:45:06 +0100333 *
Peter Hurley6d76bd22013-06-15 09:14:26 -0400334 * Locking: caller holds exclusive termios_rwsem
335 * (or locking is not required)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700336 */
Joe Petersona88a69c2009-01-02 13:40:53 +0000337
Peter Hurleyb66f4fa2013-03-11 16:44:32 -0400338static void reset_buffer_flags(struct n_tty_data *ldata)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700339{
Peter Hurleya73d3d62013-06-15 09:14:25 -0400340 ldata->read_head = ldata->canon_head = ldata->read_tail = 0;
Peter Hurley17bd7902013-06-15 10:04:24 -0400341 ldata->echo_head = ldata->echo_tail = ldata->echo_commit = 0;
Peter Hurley1075a6e2013-12-09 18:06:07 -0500342 ldata->echo_mark = 0;
Peter Hurley40d5e092013-06-15 10:21:17 -0400343 ldata->line_start = 0;
Joe Petersona88a69c2009-01-02 13:40:53 +0000344
Peter Hurleya73d3d62013-06-15 09:14:25 -0400345 ldata->erasing = 0;
Jiri Slaby3fe780b2012-10-18 22:26:40 +0200346 bitmap_zero(ldata->read_flags, N_TTY_BUF_SIZE);
Peter Hurley4d0ed182013-12-10 17:12:02 -0500347 ldata->push = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700348}
349
Peter Hurleya30737a2013-03-11 16:44:22 -0400350static void n_tty_packet_mode_flush(struct tty_struct *tty)
351{
352 unsigned long flags;
353
354 spin_lock_irqsave(&tty->ctrl_lock, flags);
355 if (tty->link->packet) {
356 tty->ctrl_status |= TIOCPKT_FLUSHREAD;
Peter Hurley6c677162013-12-02 14:24:46 -0500357 if (waitqueue_active(&tty->link->read_wait))
358 wake_up_interruptible(&tty->link->read_wait);
Peter Hurleya30737a2013-03-11 16:44:22 -0400359 }
360 spin_unlock_irqrestore(&tty->ctrl_lock, flags);
361}
362
Linus Torvalds1da177e2005-04-16 15:20:36 -0700363/**
364 * n_tty_flush_buffer - clean input queue
365 * @tty: terminal device
366 *
Peter Hurley25518c62013-03-11 16:44:31 -0400367 * Flush the input buffer. Called when the tty layer wants the
368 * buffer flushed (eg at hangup) or when the N_TTY line discipline
369 * internally has to clean the pending queue (for example some signals).
Linus Torvalds1da177e2005-04-16 15:20:36 -0700370 *
Peter Hurley6d76bd22013-06-15 09:14:26 -0400371 * Holds termios_rwsem to exclude producer/consumer while
372 * buffer indices are reset.
373 *
374 * Locking: ctrl_lock, exclusive termios_rwsem
Linus Torvalds1da177e2005-04-16 15:20:36 -0700375 */
Alan Cox4edf1822008-02-08 04:18:44 -0800376
377static void n_tty_flush_buffer(struct tty_struct *tty)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700378{
Peter Hurley6d76bd22013-06-15 09:14:26 -0400379 down_write(&tty->termios_rwsem);
Peter Hurleyb66f4fa2013-03-11 16:44:32 -0400380 reset_buffer_flags(tty->disc_data);
381 n_tty_set_room(tty);
Alan Cox4edf1822008-02-08 04:18:44 -0800382
Peter Hurleya30737a2013-03-11 16:44:22 -0400383 if (tty->link)
384 n_tty_packet_mode_flush(tty);
Peter Hurley6d76bd22013-06-15 09:14:26 -0400385 up_write(&tty->termios_rwsem);
386}
387
Linus Torvalds1da177e2005-04-16 15:20:36 -0700388/**
389 * n_tty_chars_in_buffer - report available bytes
390 * @tty: tty device
391 *
392 * Report the number of characters buffered to be delivered to user
Alan Cox4edf1822008-02-08 04:18:44 -0800393 * at this instant in time.
Alan Cox17b82062008-10-13 10:45:06 +0100394 *
Peter Hurley6d76bd22013-06-15 09:14:26 -0400395 * Locking: exclusive termios_rwsem
Linus Torvalds1da177e2005-04-16 15:20:36 -0700396 */
Alan Cox4edf1822008-02-08 04:18:44 -0800397
Peter Hurleya19d0c62013-06-15 09:14:18 -0400398static ssize_t n_tty_chars_in_buffer(struct tty_struct *tty)
399{
Peter Hurley6d76bd22013-06-15 09:14:26 -0400400 ssize_t n;
401
Peter Hurley47534082013-06-15 09:14:19 -0400402 WARN_ONCE(1, "%s is deprecated and scheduled for removal.", __func__);
Peter Hurley6d76bd22013-06-15 09:14:26 -0400403
404 down_write(&tty->termios_rwsem);
405 n = chars_in_buffer(tty);
406 up_write(&tty->termios_rwsem);
407 return n;
Peter Hurleya19d0c62013-06-15 09:14:18 -0400408}
409
Linus Torvalds1da177e2005-04-16 15:20:36 -0700410/**
411 * is_utf8_continuation - utf8 multibyte check
412 * @c: byte to check
413 *
414 * Returns true if the utf8 character 'c' is a multibyte continuation
415 * character. We use this to correctly compute the on screen size
416 * of the character when printing
417 */
Alan Cox4edf1822008-02-08 04:18:44 -0800418
Linus Torvalds1da177e2005-04-16 15:20:36 -0700419static inline int is_utf8_continuation(unsigned char c)
420{
421 return (c & 0xc0) == 0x80;
422}
423
424/**
425 * is_continuation - multibyte check
426 * @c: byte to check
427 *
428 * Returns true if the utf8 character 'c' is a multibyte continuation
429 * character and the terminal is in unicode mode.
430 */
Alan Cox4edf1822008-02-08 04:18:44 -0800431
Linus Torvalds1da177e2005-04-16 15:20:36 -0700432static inline int is_continuation(unsigned char c, struct tty_struct *tty)
433{
434 return I_IUTF8(tty) && is_utf8_continuation(c);
435}
436
437/**
Joe Petersona88a69c2009-01-02 13:40:53 +0000438 * do_output_char - output one character
439 * @c: character (or partial unicode symbol)
440 * @tty: terminal device
441 * @space: space available in tty driver write buffer
442 *
443 * This is a helper function that handles one output character
444 * (including special characters like TAB, CR, LF, etc.),
Joe Petersonee5aa7b2009-09-09 15:03:13 -0600445 * doing OPOST processing and putting the results in the
446 * tty driver's write buffer.
Joe Petersona88a69c2009-01-02 13:40:53 +0000447 *
448 * Note that Linux currently ignores TABDLY, CRDLY, VTDLY, FFDLY
449 * and NLDLY. They simply aren't relevant in the world today.
450 * If you ever need them, add them here.
451 *
452 * Returns the number of bytes of buffer space used or -1 if
453 * no space left.
454 *
455 * Locking: should be called under the output_lock to protect
456 * the column state and space left in the buffer
457 */
458
459static int do_output_char(unsigned char c, struct tty_struct *tty, int space)
460{
Jiri Slaby53c5ee22012-10-18 22:26:39 +0200461 struct n_tty_data *ldata = tty->disc_data;
Joe Petersona88a69c2009-01-02 13:40:53 +0000462 int spaces;
463
464 if (!space)
465 return -1;
Alan Cox300a6202009-01-02 13:41:04 +0000466
Joe Petersona88a69c2009-01-02 13:40:53 +0000467 switch (c) {
468 case '\n':
469 if (O_ONLRET(tty))
Jiri Slaby53c5ee22012-10-18 22:26:39 +0200470 ldata->column = 0;
Joe Petersona88a69c2009-01-02 13:40:53 +0000471 if (O_ONLCR(tty)) {
472 if (space < 2)
473 return -1;
Jiri Slabyba2e68a2012-10-18 22:26:41 +0200474 ldata->canon_column = ldata->column = 0;
Linus Torvalds37f81fa2009-09-05 12:46:07 -0700475 tty->ops->write(tty, "\r\n", 2);
Joe Petersona88a69c2009-01-02 13:40:53 +0000476 return 2;
477 }
Jiri Slabyba2e68a2012-10-18 22:26:41 +0200478 ldata->canon_column = ldata->column;
Joe Petersona88a69c2009-01-02 13:40:53 +0000479 break;
480 case '\r':
Jiri Slaby53c5ee22012-10-18 22:26:39 +0200481 if (O_ONOCR(tty) && ldata->column == 0)
Joe Petersona88a69c2009-01-02 13:40:53 +0000482 return 0;
483 if (O_OCRNL(tty)) {
484 c = '\n';
485 if (O_ONLRET(tty))
Jiri Slabyba2e68a2012-10-18 22:26:41 +0200486 ldata->canon_column = ldata->column = 0;
Joe Petersona88a69c2009-01-02 13:40:53 +0000487 break;
488 }
Jiri Slabyba2e68a2012-10-18 22:26:41 +0200489 ldata->canon_column = ldata->column = 0;
Joe Petersona88a69c2009-01-02 13:40:53 +0000490 break;
491 case '\t':
Jiri Slaby53c5ee22012-10-18 22:26:39 +0200492 spaces = 8 - (ldata->column & 7);
Joe Petersona88a69c2009-01-02 13:40:53 +0000493 if (O_TABDLY(tty) == XTABS) {
494 if (space < spaces)
495 return -1;
Jiri Slaby53c5ee22012-10-18 22:26:39 +0200496 ldata->column += spaces;
Joe Petersona88a69c2009-01-02 13:40:53 +0000497 tty->ops->write(tty, " ", spaces);
498 return spaces;
499 }
Jiri Slaby53c5ee22012-10-18 22:26:39 +0200500 ldata->column += spaces;
Joe Petersona88a69c2009-01-02 13:40:53 +0000501 break;
502 case '\b':
Jiri Slaby53c5ee22012-10-18 22:26:39 +0200503 if (ldata->column > 0)
504 ldata->column--;
Joe Petersona88a69c2009-01-02 13:40:53 +0000505 break;
506 default:
Joe Petersona59c0d62009-01-02 13:43:25 +0000507 if (!iscntrl(c)) {
508 if (O_OLCUC(tty))
509 c = toupper(c);
510 if (!is_continuation(c, tty))
Jiri Slaby53c5ee22012-10-18 22:26:39 +0200511 ldata->column++;
Joe Petersona59c0d62009-01-02 13:43:25 +0000512 }
Joe Petersona88a69c2009-01-02 13:40:53 +0000513 break;
514 }
515
516 tty_put_char(tty, c);
517 return 1;
518}
519
520/**
521 * process_output - output post processor
Linus Torvalds1da177e2005-04-16 15:20:36 -0700522 * @c: character (or partial unicode symbol)
523 * @tty: terminal device
524 *
Joe Petersonee5aa7b2009-09-09 15:03:13 -0600525 * Output one character with OPOST processing.
526 * Returns -1 when the output device is full and the character
527 * must be retried.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700528 *
Joe Petersona88a69c2009-01-02 13:40:53 +0000529 * Locking: output_lock to protect column state and space left
530 * (also, this is called from n_tty_write under the
531 * tty layer write lock)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700532 */
Alan Cox4edf1822008-02-08 04:18:44 -0800533
Joe Petersona88a69c2009-01-02 13:40:53 +0000534static int process_output(unsigned char c, struct tty_struct *tty)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700535{
Jiri Slabybddc7152012-10-18 22:26:42 +0200536 struct n_tty_data *ldata = tty->disc_data;
Joe Petersona88a69c2009-01-02 13:40:53 +0000537 int space, retval;
538
Jiri Slabybddc7152012-10-18 22:26:42 +0200539 mutex_lock(&ldata->output_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700540
Alan Coxf34d7a52008-04-30 00:54:13 -0700541 space = tty_write_room(tty);
Joe Petersona88a69c2009-01-02 13:40:53 +0000542 retval = do_output_char(c, tty, space);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700543
Jiri Slabybddc7152012-10-18 22:26:42 +0200544 mutex_unlock(&ldata->output_lock);
Joe Petersona88a69c2009-01-02 13:40:53 +0000545 if (retval < 0)
546 return -1;
547 else
548 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700549}
550
551/**
Joe Petersona88a69c2009-01-02 13:40:53 +0000552 * process_output_block - block post processor
Linus Torvalds1da177e2005-04-16 15:20:36 -0700553 * @tty: terminal device
Joe Petersonee5aa7b2009-09-09 15:03:13 -0600554 * @buf: character buffer
555 * @nr: number of bytes to output
556 *
557 * Output a block of characters with OPOST processing.
558 * Returns the number of characters output.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700559 *
560 * This path is used to speed up block console writes, among other
561 * things when processing blocks of output data. It handles only
562 * the simple cases normally found and helps to generate blocks of
563 * symbols for the console driver and thus improve performance.
564 *
Joe Petersona88a69c2009-01-02 13:40:53 +0000565 * Locking: output_lock to protect column state and space left
566 * (also, this is called from n_tty_write under the
567 * tty layer write lock)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700568 */
Alan Cox4edf1822008-02-08 04:18:44 -0800569
Joe Petersona88a69c2009-01-02 13:40:53 +0000570static ssize_t process_output_block(struct tty_struct *tty,
571 const unsigned char *buf, unsigned int nr)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700572{
Jiri Slaby53c5ee22012-10-18 22:26:39 +0200573 struct n_tty_data *ldata = tty->disc_data;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700574 int space;
Thorsten Wißmannbbd20752011-12-08 17:47:33 +0100575 int i;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700576 const unsigned char *cp;
577
Jiri Slabybddc7152012-10-18 22:26:42 +0200578 mutex_lock(&ldata->output_lock);
Joe Petersona88a69c2009-01-02 13:40:53 +0000579
Alan Coxf34d7a52008-04-30 00:54:13 -0700580 space = tty_write_room(tty);
Alan Cox300a6202009-01-02 13:41:04 +0000581 if (!space) {
Jiri Slabybddc7152012-10-18 22:26:42 +0200582 mutex_unlock(&ldata->output_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700583 return 0;
Joe Petersona88a69c2009-01-02 13:40:53 +0000584 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700585 if (nr > space)
586 nr = space;
587
588 for (i = 0, cp = buf; i < nr; i++, cp++) {
Joe Petersona59c0d62009-01-02 13:43:25 +0000589 unsigned char c = *cp;
590
591 switch (c) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700592 case '\n':
593 if (O_ONLRET(tty))
Jiri Slaby53c5ee22012-10-18 22:26:39 +0200594 ldata->column = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700595 if (O_ONLCR(tty))
596 goto break_out;
Jiri Slabyba2e68a2012-10-18 22:26:41 +0200597 ldata->canon_column = ldata->column;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700598 break;
599 case '\r':
Jiri Slaby53c5ee22012-10-18 22:26:39 +0200600 if (O_ONOCR(tty) && ldata->column == 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700601 goto break_out;
602 if (O_OCRNL(tty))
603 goto break_out;
Jiri Slabyba2e68a2012-10-18 22:26:41 +0200604 ldata->canon_column = ldata->column = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700605 break;
606 case '\t':
607 goto break_out;
608 case '\b':
Jiri Slaby53c5ee22012-10-18 22:26:39 +0200609 if (ldata->column > 0)
610 ldata->column--;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700611 break;
612 default:
Joe Petersona59c0d62009-01-02 13:43:25 +0000613 if (!iscntrl(c)) {
614 if (O_OLCUC(tty))
615 goto break_out;
616 if (!is_continuation(c, tty))
Jiri Slaby53c5ee22012-10-18 22:26:39 +0200617 ldata->column++;
Joe Petersona59c0d62009-01-02 13:43:25 +0000618 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700619 break;
620 }
621 }
622break_out:
Alan Coxf34d7a52008-04-30 00:54:13 -0700623 i = tty->ops->write(tty, buf, i);
Joe Petersona88a69c2009-01-02 13:40:53 +0000624
Jiri Slabybddc7152012-10-18 22:26:42 +0200625 mutex_unlock(&ldata->output_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700626 return i;
627}
628
Joe Petersona88a69c2009-01-02 13:40:53 +0000629/**
630 * process_echoes - write pending echo characters
631 * @tty: terminal device
632 *
633 * Write previously buffered echo (and other ldisc-generated)
634 * characters to the tty.
635 *
636 * Characters generated by the ldisc (including echoes) need to
637 * be buffered because the driver's write buffer can fill during
638 * heavy program output. Echoing straight to the driver will
639 * often fail under these conditions, causing lost characters and
640 * resulting mismatches of ldisc state information.
641 *
642 * Since the ldisc state must represent the characters actually sent
643 * to the driver at the time of the write, operations like certain
644 * changes in column state are also saved in the buffer and executed
645 * here.
646 *
647 * A circular fifo buffer is used so that the most recent characters
648 * are prioritized. Also, when control characters are echoed with a
649 * prefixed "^", the pair is treated atomically and thus not separated.
650 *
Peter Hurley019ebdf2013-06-15 10:04:25 -0400651 * Locking: callers must hold output_lock
Joe Petersona88a69c2009-01-02 13:40:53 +0000652 */
653
Peter Hurleybc5b1ec2013-06-15 10:04:27 -0400654static size_t __process_echoes(struct tty_struct *tty)
Joe Petersona88a69c2009-01-02 13:40:53 +0000655{
Jiri Slaby53c5ee22012-10-18 22:26:39 +0200656 struct n_tty_data *ldata = tty->disc_data;
Peter Hurleybc5b1ec2013-06-15 10:04:27 -0400657 int space, old_space;
Peter Hurleyaddaebc2013-06-15 10:04:22 -0400658 size_t tail;
Joe Petersona88a69c2009-01-02 13:40:53 +0000659 unsigned char c;
Joe Petersona88a69c2009-01-02 13:40:53 +0000660
Peter Hurleybc5b1ec2013-06-15 10:04:27 -0400661 old_space = space = tty_write_room(tty);
Joe Petersona88a69c2009-01-02 13:40:53 +0000662
Peter Hurleyaddaebc2013-06-15 10:04:22 -0400663 tail = ldata->echo_tail;
Peter Hurley29c7c5c2013-06-15 10:04:28 -0400664 while (ldata->echo_commit != tail) {
Peter Hurleyaddaebc2013-06-15 10:04:22 -0400665 c = echo_buf(ldata, tail);
Joe Petersona88a69c2009-01-02 13:40:53 +0000666 if (c == ECHO_OP_START) {
667 unsigned char op;
Joe Petersona88a69c2009-01-02 13:40:53 +0000668 int no_space_left = 0;
669
670 /*
671 * If the buffer byte is the start of a multi-byte
672 * operation, get the next byte, which is either the
673 * op code or a control character value.
674 */
Peter Hurleyaddaebc2013-06-15 10:04:22 -0400675 op = echo_buf(ldata, tail + 1);
Alan Cox300a6202009-01-02 13:41:04 +0000676
Joe Petersona88a69c2009-01-02 13:40:53 +0000677 switch (op) {
678 unsigned int num_chars, num_bs;
679
680 case ECHO_OP_ERASE_TAB:
Peter Hurleyaddaebc2013-06-15 10:04:22 -0400681 num_chars = echo_buf(ldata, tail + 2);
Joe Petersona88a69c2009-01-02 13:40:53 +0000682
683 /*
684 * Determine how many columns to go back
685 * in order to erase the tab.
686 * This depends on the number of columns
687 * used by other characters within the tab
688 * area. If this (modulo 8) count is from
689 * the start of input rather than from a
690 * previous tab, we offset by canon column.
691 * Otherwise, tab spacing is normal.
692 */
693 if (!(num_chars & 0x80))
Jiri Slabyba2e68a2012-10-18 22:26:41 +0200694 num_chars += ldata->canon_column;
Joe Petersona88a69c2009-01-02 13:40:53 +0000695 num_bs = 8 - (num_chars & 7);
696
697 if (num_bs > space) {
698 no_space_left = 1;
699 break;
700 }
701 space -= num_bs;
702 while (num_bs--) {
703 tty_put_char(tty, '\b');
Jiri Slaby53c5ee22012-10-18 22:26:39 +0200704 if (ldata->column > 0)
705 ldata->column--;
Joe Petersona88a69c2009-01-02 13:40:53 +0000706 }
Peter Hurleyaddaebc2013-06-15 10:04:22 -0400707 tail += 3;
Joe Petersona88a69c2009-01-02 13:40:53 +0000708 break;
709
710 case ECHO_OP_SET_CANON_COL:
Jiri Slabyba2e68a2012-10-18 22:26:41 +0200711 ldata->canon_column = ldata->column;
Peter Hurleyaddaebc2013-06-15 10:04:22 -0400712 tail += 2;
Joe Petersona88a69c2009-01-02 13:40:53 +0000713 break;
714
715 case ECHO_OP_MOVE_BACK_COL:
Jiri Slaby53c5ee22012-10-18 22:26:39 +0200716 if (ldata->column > 0)
717 ldata->column--;
Peter Hurleyaddaebc2013-06-15 10:04:22 -0400718 tail += 2;
Joe Petersona88a69c2009-01-02 13:40:53 +0000719 break;
720
721 case ECHO_OP_START:
722 /* This is an escaped echo op start code */
723 if (!space) {
724 no_space_left = 1;
725 break;
726 }
727 tty_put_char(tty, ECHO_OP_START);
Jiri Slaby53c5ee22012-10-18 22:26:39 +0200728 ldata->column++;
Joe Petersona88a69c2009-01-02 13:40:53 +0000729 space--;
Peter Hurleyaddaebc2013-06-15 10:04:22 -0400730 tail += 2;
Joe Petersona88a69c2009-01-02 13:40:53 +0000731 break;
732
733 default:
Joe Petersona88a69c2009-01-02 13:40:53 +0000734 /*
Joe Peterson62b26352009-09-09 15:03:47 -0600735 * If the op is not a special byte code,
736 * it is a ctrl char tagged to be echoed
737 * as "^X" (where X is the letter
738 * representing the control char).
739 * Note that we must ensure there is
740 * enough space for the whole ctrl pair.
741 *
Joe Petersona88a69c2009-01-02 13:40:53 +0000742 */
Joe Peterson62b26352009-09-09 15:03:47 -0600743 if (space < 2) {
744 no_space_left = 1;
745 break;
746 }
747 tty_put_char(tty, '^');
748 tty_put_char(tty, op ^ 0100);
Jiri Slaby53c5ee22012-10-18 22:26:39 +0200749 ldata->column += 2;
Joe Peterson62b26352009-09-09 15:03:47 -0600750 space -= 2;
Peter Hurleyaddaebc2013-06-15 10:04:22 -0400751 tail += 2;
Joe Petersona88a69c2009-01-02 13:40:53 +0000752 }
753
754 if (no_space_left)
755 break;
756 } else {
Peter Hurley582f5592013-05-17 12:49:48 -0400757 if (O_OPOST(tty)) {
Joe Petersonee5aa7b2009-09-09 15:03:13 -0600758 int retval = do_output_char(c, tty, space);
759 if (retval < 0)
760 break;
761 space -= retval;
762 } else {
763 if (!space)
764 break;
765 tty_put_char(tty, c);
766 space -= 1;
767 }
Peter Hurleyaddaebc2013-06-15 10:04:22 -0400768 tail += 1;
Joe Petersona88a69c2009-01-02 13:40:53 +0000769 }
Joe Petersona88a69c2009-01-02 13:40:53 +0000770 }
771
Peter Hurleycbfd0342013-06-15 10:04:26 -0400772 /* If the echo buffer is nearly full (so that the possibility exists
773 * of echo overrun before the next commit), then discard enough
774 * data at the tail to prevent a subsequent overrun */
775 while (ldata->echo_commit - tail >= ECHO_DISCARD_WATERMARK) {
Roel Kluinc476f652013-10-11 22:08:49 +0200776 if (echo_buf(ldata, tail) == ECHO_OP_START) {
Peter Hurley6f222532013-11-08 09:42:18 -0500777 if (echo_buf(ldata, tail + 1) == ECHO_OP_ERASE_TAB)
Peter Hurleycbfd0342013-06-15 10:04:26 -0400778 tail += 3;
779 else
780 tail += 2;
781 } else
782 tail++;
783 }
784
Peter Hurleyaddaebc2013-06-15 10:04:22 -0400785 ldata->echo_tail = tail;
Peter Hurleybc5b1ec2013-06-15 10:04:27 -0400786 return old_space - space;
Joe Petersona88a69c2009-01-02 13:40:53 +0000787}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700788
Peter Hurley17bd7902013-06-15 10:04:24 -0400789static void commit_echoes(struct tty_struct *tty)
790{
791 struct n_tty_data *ldata = tty->disc_data;
Peter Hurleybc5b1ec2013-06-15 10:04:27 -0400792 size_t nr, old, echoed;
Peter Hurleycbfd0342013-06-15 10:04:26 -0400793 size_t head;
794
795 head = ldata->echo_head;
Peter Hurley1075a6e2013-12-09 18:06:07 -0500796 ldata->echo_mark = head;
Peter Hurleycbfd0342013-06-15 10:04:26 -0400797 old = ldata->echo_commit - ldata->echo_tail;
798
799 /* Process committed echoes if the accumulated # of bytes
800 * is over the threshold (and try again each time another
801 * block is accumulated) */
802 nr = head - ldata->echo_tail;
803 if (nr < ECHO_COMMIT_WATERMARK || (nr % ECHO_BLOCK > old % ECHO_BLOCK))
804 return;
Peter Hurley17bd7902013-06-15 10:04:24 -0400805
Peter Hurley019ebdf2013-06-15 10:04:25 -0400806 mutex_lock(&ldata->output_lock);
Peter Hurleycbfd0342013-06-15 10:04:26 -0400807 ldata->echo_commit = head;
Peter Hurleybc5b1ec2013-06-15 10:04:27 -0400808 echoed = __process_echoes(tty);
Peter Hurley019ebdf2013-06-15 10:04:25 -0400809 mutex_unlock(&ldata->output_lock);
810
Peter Hurleybc5b1ec2013-06-15 10:04:27 -0400811 if (echoed && tty->ops->flush_chars)
Peter Hurley019ebdf2013-06-15 10:04:25 -0400812 tty->ops->flush_chars(tty);
813}
814
815static void process_echoes(struct tty_struct *tty)
816{
817 struct n_tty_data *ldata = tty->disc_data;
Peter Hurleybc5b1ec2013-06-15 10:04:27 -0400818 size_t echoed;
Peter Hurley019ebdf2013-06-15 10:04:25 -0400819
Peter Hurleye2613be2014-02-11 16:34:55 -0500820 if (ldata->echo_mark == ldata->echo_tail)
Peter Hurley019ebdf2013-06-15 10:04:25 -0400821 return;
822
823 mutex_lock(&ldata->output_lock);
Peter Hurley1075a6e2013-12-09 18:06:07 -0500824 ldata->echo_commit = ldata->echo_mark;
Peter Hurleybc5b1ec2013-06-15 10:04:27 -0400825 echoed = __process_echoes(tty);
Peter Hurley019ebdf2013-06-15 10:04:25 -0400826 mutex_unlock(&ldata->output_lock);
827
Peter Hurleybc5b1ec2013-06-15 10:04:27 -0400828 if (echoed && tty->ops->flush_chars)
Peter Hurley019ebdf2013-06-15 10:04:25 -0400829 tty->ops->flush_chars(tty);
Peter Hurley17bd7902013-06-15 10:04:24 -0400830}
831
Peter Hurley1075a6e2013-12-09 18:06:07 -0500832/* NB: echo_mark and echo_head should be equivalent here */
Peter Hurleycbfd0342013-06-15 10:04:26 -0400833static void flush_echoes(struct tty_struct *tty)
834{
835 struct n_tty_data *ldata = tty->disc_data;
836
Peter Hurley39434ab2013-11-29 12:56:10 -0500837 if ((!L_ECHO(tty) && !L_ECHONL(tty)) ||
838 ldata->echo_commit == ldata->echo_head)
Peter Hurleycbfd0342013-06-15 10:04:26 -0400839 return;
840
841 mutex_lock(&ldata->output_lock);
842 ldata->echo_commit = ldata->echo_head;
843 __process_echoes(tty);
844 mutex_unlock(&ldata->output_lock);
845}
846
Linus Torvalds1da177e2005-04-16 15:20:36 -0700847/**
Joe Petersona88a69c2009-01-02 13:40:53 +0000848 * add_echo_byte - add a byte to the echo buffer
849 * @c: unicode byte to echo
Jiri Slaby57c94122012-10-18 22:26:43 +0200850 * @ldata: n_tty data
Joe Petersona88a69c2009-01-02 13:40:53 +0000851 *
852 * Add a character or operation byte to the echo buffer.
Joe Petersona88a69c2009-01-02 13:40:53 +0000853 */
854
Peter Hurleycbfd0342013-06-15 10:04:26 -0400855static inline void add_echo_byte(unsigned char c, struct n_tty_data *ldata)
Joe Petersona88a69c2009-01-02 13:40:53 +0000856{
Peter Hurleyaddaebc2013-06-15 10:04:22 -0400857 *echo_buf_addr(ldata, ldata->echo_head++) = c;
Joe Petersona88a69c2009-01-02 13:40:53 +0000858}
859
860/**
861 * echo_move_back_col - add operation to move back a column
Jiri Slaby57c94122012-10-18 22:26:43 +0200862 * @ldata: n_tty data
Joe Petersona88a69c2009-01-02 13:40:53 +0000863 *
864 * Add an operation to the echo buffer to move back one column.
Joe Petersona88a69c2009-01-02 13:40:53 +0000865 */
866
Jiri Slaby57c94122012-10-18 22:26:43 +0200867static void echo_move_back_col(struct n_tty_data *ldata)
Joe Petersona88a69c2009-01-02 13:40:53 +0000868{
Jiri Slaby57c94122012-10-18 22:26:43 +0200869 add_echo_byte(ECHO_OP_START, ldata);
870 add_echo_byte(ECHO_OP_MOVE_BACK_COL, ldata);
Joe Petersona88a69c2009-01-02 13:40:53 +0000871}
872
873/**
874 * echo_set_canon_col - add operation to set the canon column
Jiri Slaby57c94122012-10-18 22:26:43 +0200875 * @ldata: n_tty data
Joe Petersona88a69c2009-01-02 13:40:53 +0000876 *
877 * Add an operation to the echo buffer to set the canon column
878 * to the current column.
Joe Petersona88a69c2009-01-02 13:40:53 +0000879 */
880
Jiri Slaby57c94122012-10-18 22:26:43 +0200881static void echo_set_canon_col(struct n_tty_data *ldata)
Joe Petersona88a69c2009-01-02 13:40:53 +0000882{
Jiri Slaby57c94122012-10-18 22:26:43 +0200883 add_echo_byte(ECHO_OP_START, ldata);
884 add_echo_byte(ECHO_OP_SET_CANON_COL, ldata);
Joe Petersona88a69c2009-01-02 13:40:53 +0000885}
886
887/**
888 * echo_erase_tab - add operation to erase a tab
889 * @num_chars: number of character columns already used
890 * @after_tab: true if num_chars starts after a previous tab
Jiri Slaby57c94122012-10-18 22:26:43 +0200891 * @ldata: n_tty data
Joe Petersona88a69c2009-01-02 13:40:53 +0000892 *
893 * Add an operation to the echo buffer to erase a tab.
894 *
895 * Called by the eraser function, which knows how many character
896 * columns have been used since either a previous tab or the start
897 * of input. This information will be used later, along with
898 * canon column (if applicable), to go back the correct number
899 * of columns.
Joe Petersona88a69c2009-01-02 13:40:53 +0000900 */
901
902static void echo_erase_tab(unsigned int num_chars, int after_tab,
Jiri Slaby57c94122012-10-18 22:26:43 +0200903 struct n_tty_data *ldata)
Joe Petersona88a69c2009-01-02 13:40:53 +0000904{
Jiri Slaby57c94122012-10-18 22:26:43 +0200905 add_echo_byte(ECHO_OP_START, ldata);
906 add_echo_byte(ECHO_OP_ERASE_TAB, ldata);
Joe Petersona88a69c2009-01-02 13:40:53 +0000907
908 /* We only need to know this modulo 8 (tab spacing) */
909 num_chars &= 7;
910
911 /* Set the high bit as a flag if num_chars is after a previous tab */
912 if (after_tab)
913 num_chars |= 0x80;
Alan Cox300a6202009-01-02 13:41:04 +0000914
Jiri Slaby57c94122012-10-18 22:26:43 +0200915 add_echo_byte(num_chars, ldata);
Joe Petersona88a69c2009-01-02 13:40:53 +0000916}
917
918/**
919 * echo_char_raw - echo a character raw
Linus Torvalds1da177e2005-04-16 15:20:36 -0700920 * @c: unicode byte to echo
921 * @tty: terminal device
922 *
Alan Cox4edf1822008-02-08 04:18:44 -0800923 * Echo user input back onto the screen. This must be called only when
Linus Torvalds1da177e2005-04-16 15:20:36 -0700924 * L_ECHO(tty) is true. Called from the driver receive_buf path.
Alan Cox17b82062008-10-13 10:45:06 +0100925 *
Joe Petersona88a69c2009-01-02 13:40:53 +0000926 * This variant does not treat control characters specially.
Joe Petersona88a69c2009-01-02 13:40:53 +0000927 */
928
Jiri Slaby57c94122012-10-18 22:26:43 +0200929static void echo_char_raw(unsigned char c, struct n_tty_data *ldata)
Joe Petersona88a69c2009-01-02 13:40:53 +0000930{
Joe Petersona88a69c2009-01-02 13:40:53 +0000931 if (c == ECHO_OP_START) {
Jiri Slaby57c94122012-10-18 22:26:43 +0200932 add_echo_byte(ECHO_OP_START, ldata);
933 add_echo_byte(ECHO_OP_START, ldata);
Joe Petersona88a69c2009-01-02 13:40:53 +0000934 } else {
Jiri Slaby57c94122012-10-18 22:26:43 +0200935 add_echo_byte(c, ldata);
Joe Petersona88a69c2009-01-02 13:40:53 +0000936 }
Joe Petersona88a69c2009-01-02 13:40:53 +0000937}
938
939/**
940 * echo_char - echo a character
941 * @c: unicode byte to echo
942 * @tty: terminal device
943 *
944 * Echo user input back onto the screen. This must be called only when
945 * L_ECHO(tty) is true. Called from the driver receive_buf path.
946 *
Joe Peterson62b26352009-09-09 15:03:47 -0600947 * This variant tags control characters to be echoed as "^X"
948 * (where X is the letter representing the control char).
Linus Torvalds1da177e2005-04-16 15:20:36 -0700949 */
950
951static void echo_char(unsigned char c, struct tty_struct *tty)
952{
Jiri Slabybddc7152012-10-18 22:26:42 +0200953 struct n_tty_data *ldata = tty->disc_data;
954
Joe Petersona88a69c2009-01-02 13:40:53 +0000955 if (c == ECHO_OP_START) {
Jiri Slaby57c94122012-10-18 22:26:43 +0200956 add_echo_byte(ECHO_OP_START, ldata);
957 add_echo_byte(ECHO_OP_START, ldata);
Joe Petersona88a69c2009-01-02 13:40:53 +0000958 } else {
Joe Peterson62b26352009-09-09 15:03:47 -0600959 if (L_ECHOCTL(tty) && iscntrl(c) && c != '\t')
Jiri Slaby57c94122012-10-18 22:26:43 +0200960 add_echo_byte(ECHO_OP_START, ldata);
961 add_echo_byte(c, ldata);
Joe Petersona88a69c2009-01-02 13:40:53 +0000962 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700963}
964
Alan Cox17b82062008-10-13 10:45:06 +0100965/**
Joe Petersona88a69c2009-01-02 13:40:53 +0000966 * finish_erasing - complete erase
Jiri Slaby57c94122012-10-18 22:26:43 +0200967 * @ldata: n_tty data
Alan Cox17b82062008-10-13 10:45:06 +0100968 */
Joe Petersona88a69c2009-01-02 13:40:53 +0000969
Jiri Slaby57c94122012-10-18 22:26:43 +0200970static inline void finish_erasing(struct n_tty_data *ldata)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700971{
Jiri Slaby53c5ee22012-10-18 22:26:39 +0200972 if (ldata->erasing) {
Jiri Slaby57c94122012-10-18 22:26:43 +0200973 echo_char_raw('/', ldata);
Jiri Slaby53c5ee22012-10-18 22:26:39 +0200974 ldata->erasing = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700975 }
976}
977
978/**
979 * eraser - handle erase function
980 * @c: character input
981 * @tty: terminal device
982 *
Robert P. J. Day3a4fa0a2007-10-19 23:10:43 +0200983 * Perform erase and necessary output when an erase character is
Linus Torvalds1da177e2005-04-16 15:20:36 -0700984 * present in the stream from the driver layer. Handles the complexities
985 * of UTF-8 multibyte symbols.
Alan Cox17b82062008-10-13 10:45:06 +0100986 *
Peter Hurley6d76bd22013-06-15 09:14:26 -0400987 * n_tty_receive_buf()/producer path:
988 * caller holds non-exclusive termios_rwsem
989 * modifies read_head
990 *
991 * Modifying the read_head is not considered a publish in this context
992 * because canonical mode is active -- only canon_head publishes
Linus Torvalds1da177e2005-04-16 15:20:36 -0700993 */
Alan Cox4edf1822008-02-08 04:18:44 -0800994
Linus Torvalds1da177e2005-04-16 15:20:36 -0700995static void eraser(unsigned char c, struct tty_struct *tty)
996{
Jiri Slaby53c5ee22012-10-18 22:26:39 +0200997 struct n_tty_data *ldata = tty->disc_data;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700998 enum { ERASE, WERASE, KILL } kill_type;
Peter Hurleybc5a5e32013-06-15 09:14:21 -0400999 size_t head;
1000 size_t cnt;
1001 int seen_alnums;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001002
Jiri Slabyba2e68a2012-10-18 22:26:41 +02001003 if (ldata->read_head == ldata->canon_head) {
Joe Peterson7e94b1d2009-01-02 13:43:40 +00001004 /* process_output('\a', tty); */ /* what do you think? */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001005 return;
1006 }
1007 if (c == ERASE_CHAR(tty))
1008 kill_type = ERASE;
1009 else if (c == WERASE_CHAR(tty))
1010 kill_type = WERASE;
1011 else {
1012 if (!L_ECHO(tty)) {
Jiri Slabyba2e68a2012-10-18 22:26:41 +02001013 ldata->read_head = ldata->canon_head;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001014 return;
1015 }
1016 if (!L_ECHOK(tty) || !L_ECHOKE(tty) || !L_ECHOE(tty)) {
Jiri Slabyba2e68a2012-10-18 22:26:41 +02001017 ldata->read_head = ldata->canon_head;
Jiri Slaby57c94122012-10-18 22:26:43 +02001018 finish_erasing(ldata);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001019 echo_char(KILL_CHAR(tty), tty);
1020 /* Add a newline if ECHOK is on and ECHOKE is off. */
1021 if (L_ECHOK(tty))
Jiri Slaby57c94122012-10-18 22:26:43 +02001022 echo_char_raw('\n', ldata);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001023 return;
1024 }
1025 kill_type = KILL;
1026 }
1027
1028 seen_alnums = 0;
Jiri Slabyba2e68a2012-10-18 22:26:41 +02001029 while (ldata->read_head != ldata->canon_head) {
1030 head = ldata->read_head;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001031
1032 /* erase a single possibly multibyte character */
1033 do {
Peter Hurleybc5a5e32013-06-15 09:14:21 -04001034 head--;
1035 c = read_buf(ldata, head);
Jiri Slabyba2e68a2012-10-18 22:26:41 +02001036 } while (is_continuation(c, tty) && head != ldata->canon_head);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001037
1038 /* do not partially erase */
1039 if (is_continuation(c, tty))
1040 break;
1041
1042 if (kill_type == WERASE) {
1043 /* Equivalent to BSD's ALTWERASE. */
1044 if (isalnum(c) || c == '_')
1045 seen_alnums++;
1046 else if (seen_alnums)
1047 break;
1048 }
Peter Hurleybc5a5e32013-06-15 09:14:21 -04001049 cnt = ldata->read_head - head;
Jiri Slabyba2e68a2012-10-18 22:26:41 +02001050 ldata->read_head = head;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001051 if (L_ECHO(tty)) {
1052 if (L_ECHOPRT(tty)) {
Jiri Slaby53c5ee22012-10-18 22:26:39 +02001053 if (!ldata->erasing) {
Jiri Slaby57c94122012-10-18 22:26:43 +02001054 echo_char_raw('\\', ldata);
Jiri Slaby53c5ee22012-10-18 22:26:39 +02001055 ldata->erasing = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001056 }
1057 /* if cnt > 1, output a multi-byte character */
1058 echo_char(c, tty);
1059 while (--cnt > 0) {
Peter Hurleybc5a5e32013-06-15 09:14:21 -04001060 head++;
1061 echo_char_raw(read_buf(ldata, head), ldata);
Jiri Slaby57c94122012-10-18 22:26:43 +02001062 echo_move_back_col(ldata);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001063 }
1064 } else if (kill_type == ERASE && !L_ECHOE(tty)) {
1065 echo_char(ERASE_CHAR(tty), tty);
1066 } else if (c == '\t') {
Joe Petersona88a69c2009-01-02 13:40:53 +00001067 unsigned int num_chars = 0;
1068 int after_tab = 0;
Peter Hurleybc5a5e32013-06-15 09:14:21 -04001069 size_t tail = ldata->read_head;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001070
Joe Petersona88a69c2009-01-02 13:40:53 +00001071 /*
1072 * Count the columns used for characters
1073 * since the start of input or after a
1074 * previous tab.
1075 * This info is used to go back the correct
1076 * number of columns.
1077 */
Jiri Slabyba2e68a2012-10-18 22:26:41 +02001078 while (tail != ldata->canon_head) {
Peter Hurleybc5a5e32013-06-15 09:14:21 -04001079 tail--;
1080 c = read_buf(ldata, tail);
Joe Petersona88a69c2009-01-02 13:40:53 +00001081 if (c == '\t') {
1082 after_tab = 1;
1083 break;
Alan Cox300a6202009-01-02 13:41:04 +00001084 } else if (iscntrl(c)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001085 if (L_ECHOCTL(tty))
Joe Petersona88a69c2009-01-02 13:40:53 +00001086 num_chars += 2;
1087 } else if (!is_continuation(c, tty)) {
1088 num_chars++;
1089 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001090 }
Jiri Slaby57c94122012-10-18 22:26:43 +02001091 echo_erase_tab(num_chars, after_tab, ldata);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001092 } else {
1093 if (iscntrl(c) && L_ECHOCTL(tty)) {
Jiri Slaby57c94122012-10-18 22:26:43 +02001094 echo_char_raw('\b', ldata);
1095 echo_char_raw(' ', ldata);
1096 echo_char_raw('\b', ldata);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001097 }
1098 if (!iscntrl(c) || L_ECHOCTL(tty)) {
Jiri Slaby57c94122012-10-18 22:26:43 +02001099 echo_char_raw('\b', ldata);
1100 echo_char_raw(' ', ldata);
1101 echo_char_raw('\b', ldata);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001102 }
1103 }
1104 }
1105 if (kill_type == ERASE)
1106 break;
1107 }
Jiri Slabyba2e68a2012-10-18 22:26:41 +02001108 if (ldata->read_head == ldata->canon_head && L_ECHO(tty))
Jiri Slaby57c94122012-10-18 22:26:43 +02001109 finish_erasing(ldata);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001110}
1111
1112/**
1113 * isig - handle the ISIG optio
1114 * @sig: signal
1115 * @tty: terminal
Linus Torvalds1da177e2005-04-16 15:20:36 -07001116 *
Peter Hurley8c985d12013-03-06 08:38:19 -05001117 * Called when a signal is being sent due to terminal input.
1118 * Called from the driver receive_buf path so serialized.
Alan Cox17b82062008-10-13 10:45:06 +01001119 *
Peter Hurley8c985d12013-03-06 08:38:19 -05001120 * Locking: ctrl_lock
Linus Torvalds1da177e2005-04-16 15:20:36 -07001121 */
Alan Cox4edf1822008-02-08 04:18:44 -08001122
Peter Hurley4b293492013-07-24 08:29:55 -04001123static void isig(int sig, struct tty_struct *tty)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001124{
Peter Hurley8c985d12013-03-06 08:38:19 -05001125 struct pid *tty_pgrp = tty_get_pgrp(tty);
1126 if (tty_pgrp) {
1127 kill_pgrp(tty_pgrp, sig, 1);
1128 put_pid(tty_pgrp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001129 }
1130}
1131
1132/**
1133 * n_tty_receive_break - handle break
1134 * @tty: terminal
1135 *
1136 * An RS232 break event has been hit in the incoming bitstream. This
1137 * can cause a variety of events depending upon the termios settings.
1138 *
Peter Hurley6d76bd22013-06-15 09:14:26 -04001139 * n_tty_receive_buf()/producer path:
1140 * caller holds non-exclusive termios_rwsem
1141 * publishes read_head via put_tty_queue()
1142 *
1143 * Note: may get exclusive termios_rwsem if flushing input buffer
Linus Torvalds1da177e2005-04-16 15:20:36 -07001144 */
Alan Cox4edf1822008-02-08 04:18:44 -08001145
Peter Hurley4b293492013-07-24 08:29:55 -04001146static void n_tty_receive_break(struct tty_struct *tty)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001147{
Jiri Slaby57c94122012-10-18 22:26:43 +02001148 struct n_tty_data *ldata = tty->disc_data;
1149
Linus Torvalds1da177e2005-04-16 15:20:36 -07001150 if (I_IGNBRK(tty))
1151 return;
1152 if (I_BRKINT(tty)) {
Peter Hurley8c985d12013-03-06 08:38:19 -05001153 isig(SIGINT, tty);
1154 if (!L_NOFLSH(tty)) {
Peter Hurley6d76bd22013-06-15 09:14:26 -04001155 /* flushing needs exclusive termios_rwsem */
1156 up_read(&tty->termios_rwsem);
Peter Hurley8c985d12013-03-06 08:38:19 -05001157 n_tty_flush_buffer(tty);
1158 tty_driver_flush_buffer(tty);
Peter Hurley6d76bd22013-06-15 09:14:26 -04001159 down_read(&tty->termios_rwsem);
Peter Hurley8c985d12013-03-06 08:38:19 -05001160 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001161 return;
1162 }
1163 if (I_PARMRK(tty)) {
Jiri Slaby57c94122012-10-18 22:26:43 +02001164 put_tty_queue('\377', ldata);
1165 put_tty_queue('\0', ldata);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001166 }
Jiri Slaby57c94122012-10-18 22:26:43 +02001167 put_tty_queue('\0', ldata);
Peter Hurley6c677162013-12-02 14:24:46 -05001168 if (waitqueue_active(&tty->read_wait))
Peter Hurley57087d52014-08-07 07:14:10 -04001169 wake_up_interruptible_poll(&tty->read_wait, POLLIN);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001170}
1171
1172/**
1173 * n_tty_receive_overrun - handle overrun reporting
1174 * @tty: terminal
1175 *
1176 * Data arrived faster than we could process it. While the tty
1177 * driver has flagged this the bits that were missed are gone
1178 * forever.
1179 *
1180 * Called from the receive_buf path so single threaded. Does not
1181 * need locking as num_overrun and overrun_time are function
1182 * private.
1183 */
Alan Cox4edf1822008-02-08 04:18:44 -08001184
Peter Hurley4b293492013-07-24 08:29:55 -04001185static void n_tty_receive_overrun(struct tty_struct *tty)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001186{
Jiri Slaby53c5ee22012-10-18 22:26:39 +02001187 struct n_tty_data *ldata = tty->disc_data;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001188 char buf[64];
1189
Jiri Slaby53c5ee22012-10-18 22:26:39 +02001190 ldata->num_overrun++;
1191 if (time_after(jiffies, ldata->overrun_time + HZ) ||
1192 time_after(ldata->overrun_time, jiffies)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001193 printk(KERN_WARNING "%s: %d input overrun(s)\n",
1194 tty_name(tty, buf),
Jiri Slaby53c5ee22012-10-18 22:26:39 +02001195 ldata->num_overrun);
1196 ldata->overrun_time = jiffies;
1197 ldata->num_overrun = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001198 }
1199}
1200
1201/**
1202 * n_tty_receive_parity_error - error notifier
1203 * @tty: terminal device
1204 * @c: character
1205 *
1206 * Process a parity error and queue the right data to indicate
Peter Hurley6d76bd22013-06-15 09:14:26 -04001207 * the error case if necessary.
1208 *
1209 * n_tty_receive_buf()/producer path:
1210 * caller holds non-exclusive termios_rwsem
1211 * publishes read_head via put_tty_queue()
Linus Torvalds1da177e2005-04-16 15:20:36 -07001212 */
Peter Hurley4b293492013-07-24 08:29:55 -04001213static void n_tty_receive_parity_error(struct tty_struct *tty, unsigned char c)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001214{
Jiri Slaby57c94122012-10-18 22:26:43 +02001215 struct n_tty_data *ldata = tty->disc_data;
1216
Peter Hurley66528f92014-06-16 08:10:42 -04001217 if (I_INPCK(tty)) {
1218 if (I_IGNPAR(tty))
1219 return;
1220 if (I_PARMRK(tty)) {
1221 put_tty_queue('\377', ldata);
1222 put_tty_queue('\0', ldata);
1223 put_tty_queue(c, ldata);
1224 } else
1225 put_tty_queue('\0', ldata);
1226 } else
Jiri Slaby57c94122012-10-18 22:26:43 +02001227 put_tty_queue(c, ldata);
Peter Hurley6c677162013-12-02 14:24:46 -05001228 if (waitqueue_active(&tty->read_wait))
Peter Hurley57087d52014-08-07 07:14:10 -04001229 wake_up_interruptible_poll(&tty->read_wait, POLLIN);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001230}
1231
Peter Hurleyb0ac50b2013-06-15 10:21:23 -04001232static void
1233n_tty_receive_signal_char(struct tty_struct *tty, int signal, unsigned char c)
1234{
1235 if (!L_NOFLSH(tty)) {
1236 /* flushing needs exclusive termios_rwsem */
1237 up_read(&tty->termios_rwsem);
1238 n_tty_flush_buffer(tty);
1239 tty_driver_flush_buffer(tty);
1240 down_read(&tty->termios_rwsem);
1241 }
1242 if (I_IXON(tty))
1243 start_tty(tty);
1244 if (L_ECHO(tty)) {
1245 echo_char(c, tty);
1246 commit_echoes(tty);
Peter Hurleye2613be2014-02-11 16:34:55 -05001247 } else
1248 process_echoes(tty);
Peter Hurleyb0ac50b2013-06-15 10:21:23 -04001249 isig(signal, tty);
1250 return;
1251}
1252
Linus Torvalds1da177e2005-04-16 15:20:36 -07001253/**
1254 * n_tty_receive_char - perform processing
1255 * @tty: terminal device
1256 * @c: character
1257 *
1258 * Process an individual character of input received from the driver.
Alan Cox4edf1822008-02-08 04:18:44 -08001259 * This is serialized with respect to itself by the rules for the
Linus Torvalds1da177e2005-04-16 15:20:36 -07001260 * driver above.
Peter Hurley6d76bd22013-06-15 09:14:26 -04001261 *
1262 * n_tty_receive_buf()/producer path:
1263 * caller holds non-exclusive termios_rwsem
1264 * publishes canon_head if canonical mode is active
1265 * otherwise, publishes read_head via put_tty_queue()
Peter Hurleye60d27c2013-07-24 08:29:56 -04001266 *
1267 * Returns 1 if LNEXT was received, else returns 0
Linus Torvalds1da177e2005-04-16 15:20:36 -07001268 */
1269
Peter Hurleye60d27c2013-07-24 08:29:56 -04001270static int
Peter Hurley4b1f79c2013-07-24 08:29:51 -04001271n_tty_receive_char_special(struct tty_struct *tty, unsigned char c)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001272{
Jiri Slaby53c5ee22012-10-18 22:26:39 +02001273 struct n_tty_data *ldata = tty->disc_data;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001274
Linus Torvalds1da177e2005-04-16 15:20:36 -07001275 if (I_IXON(tty)) {
1276 if (c == START_CHAR(tty)) {
1277 start_tty(tty);
Peter Hurleye2613be2014-02-11 16:34:55 -05001278 process_echoes(tty);
Peter Hurleye60d27c2013-07-24 08:29:56 -04001279 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001280 }
1281 if (c == STOP_CHAR(tty)) {
1282 stop_tty(tty);
Peter Hurleye60d27c2013-07-24 08:29:56 -04001283 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001284 }
1285 }
Joe Peterson575537b32008-04-30 00:53:30 -07001286
Linus Torvalds1da177e2005-04-16 15:20:36 -07001287 if (L_ISIG(tty)) {
Peter Hurleyb0ac50b2013-06-15 10:21:23 -04001288 if (c == INTR_CHAR(tty)) {
1289 n_tty_receive_signal_char(tty, SIGINT, c);
Peter Hurleye60d27c2013-07-24 08:29:56 -04001290 return 0;
Peter Hurleyb0ac50b2013-06-15 10:21:23 -04001291 } else if (c == QUIT_CHAR(tty)) {
1292 n_tty_receive_signal_char(tty, SIGQUIT, c);
Peter Hurleye60d27c2013-07-24 08:29:56 -04001293 return 0;
Peter Hurleyb0ac50b2013-06-15 10:21:23 -04001294 } else if (c == SUSP_CHAR(tty)) {
1295 n_tty_receive_signal_char(tty, SIGTSTP, c);
Peter Hurleye60d27c2013-07-24 08:29:56 -04001296 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001297 }
1298 }
Joe Peterson575537b32008-04-30 00:53:30 -07001299
Peter Hurley855df3c2013-07-24 08:29:50 -04001300 if (tty->stopped && !tty->flow_stopped && I_IXON(tty) && I_IXANY(tty)) {
1301 start_tty(tty);
1302 process_echoes(tty);
1303 }
1304
Joe Peterson575537b32008-04-30 00:53:30 -07001305 if (c == '\r') {
1306 if (I_IGNCR(tty))
Peter Hurleye60d27c2013-07-24 08:29:56 -04001307 return 0;
Joe Peterson575537b32008-04-30 00:53:30 -07001308 if (I_ICRNL(tty))
1309 c = '\n';
1310 } else if (c == '\n' && I_INLCR(tty))
1311 c = '\r';
1312
Jiri Slaby53c5ee22012-10-18 22:26:39 +02001313 if (ldata->icanon) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001314 if (c == ERASE_CHAR(tty) || c == KILL_CHAR(tty) ||
1315 (c == WERASE_CHAR(tty) && L_IEXTEN(tty))) {
1316 eraser(c, tty);
Peter Hurley17bd7902013-06-15 10:04:24 -04001317 commit_echoes(tty);
Peter Hurleye60d27c2013-07-24 08:29:56 -04001318 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001319 }
1320 if (c == LNEXT_CHAR(tty) && L_IEXTEN(tty)) {
Jiri Slaby53c5ee22012-10-18 22:26:39 +02001321 ldata->lnext = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001322 if (L_ECHO(tty)) {
Jiri Slaby57c94122012-10-18 22:26:43 +02001323 finish_erasing(ldata);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001324 if (L_ECHOCTL(tty)) {
Jiri Slaby57c94122012-10-18 22:26:43 +02001325 echo_char_raw('^', ldata);
1326 echo_char_raw('\b', ldata);
Peter Hurley17bd7902013-06-15 10:04:24 -04001327 commit_echoes(tty);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001328 }
1329 }
Peter Hurleye60d27c2013-07-24 08:29:56 -04001330 return 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001331 }
Peter Hurleye60d27c2013-07-24 08:29:56 -04001332 if (c == REPRINT_CHAR(tty) && L_ECHO(tty) && L_IEXTEN(tty)) {
Peter Hurleybc5a5e32013-06-15 09:14:21 -04001333 size_t tail = ldata->canon_head;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001334
Jiri Slaby57c94122012-10-18 22:26:43 +02001335 finish_erasing(ldata);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001336 echo_char(c, tty);
Jiri Slaby57c94122012-10-18 22:26:43 +02001337 echo_char_raw('\n', ldata);
Jiri Slabyba2e68a2012-10-18 22:26:41 +02001338 while (tail != ldata->read_head) {
Peter Hurleybc5a5e32013-06-15 09:14:21 -04001339 echo_char(read_buf(ldata, tail), tty);
1340 tail++;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001341 }
Peter Hurley17bd7902013-06-15 10:04:24 -04001342 commit_echoes(tty);
Peter Hurleye60d27c2013-07-24 08:29:56 -04001343 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001344 }
1345 if (c == '\n') {
Joe Petersonacc71bb2009-01-02 13:43:32 +00001346 if (L_ECHO(tty) || L_ECHONL(tty)) {
Jiri Slaby57c94122012-10-18 22:26:43 +02001347 echo_char_raw('\n', ldata);
Peter Hurley17bd7902013-06-15 10:04:24 -04001348 commit_echoes(tty);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001349 }
1350 goto handle_newline;
1351 }
1352 if (c == EOF_CHAR(tty)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001353 c = __DISABLED_CHAR;
1354 goto handle_newline;
1355 }
1356 if ((c == EOL_CHAR(tty)) ||
1357 (c == EOL2_CHAR(tty) && L_IEXTEN(tty))) {
1358 /*
1359 * XXX are EOL_CHAR and EOL2_CHAR echoed?!?
1360 */
1361 if (L_ECHO(tty)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001362 /* Record the column of first canon char. */
Jiri Slabyba2e68a2012-10-18 22:26:41 +02001363 if (ldata->canon_head == ldata->read_head)
Jiri Slaby57c94122012-10-18 22:26:43 +02001364 echo_set_canon_col(ldata);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001365 echo_char(c, tty);
Peter Hurley17bd7902013-06-15 10:04:24 -04001366 commit_echoes(tty);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001367 }
1368 /*
1369 * XXX does PARMRK doubling happen for
1370 * EOL_CHAR and EOL2_CHAR?
1371 */
Peter Hurley001ba922013-12-02 14:24:44 -05001372 if (c == (unsigned char) '\377' && I_PARMRK(tty))
Jiri Slaby57c94122012-10-18 22:26:43 +02001373 put_tty_queue(c, ldata);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001374
Alan Cox4edf1822008-02-08 04:18:44 -08001375handle_newline:
Peter Hurleybc5a5e32013-06-15 09:14:21 -04001376 set_bit(ldata->read_head & (N_TTY_BUF_SIZE - 1), ldata->read_flags);
Peter Hurley6d76bd22013-06-15 09:14:26 -04001377 put_tty_queue(c, ldata);
Jiri Slabyba2e68a2012-10-18 22:26:41 +02001378 ldata->canon_head = ldata->read_head;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001379 kill_fasync(&tty->fasync, SIGIO, POLL_IN);
1380 if (waitqueue_active(&tty->read_wait))
Peter Hurley57087d52014-08-07 07:14:10 -04001381 wake_up_interruptible_poll(&tty->read_wait, POLLIN);
Peter Hurleye60d27c2013-07-24 08:29:56 -04001382 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001383 }
1384 }
Alan Cox4edf1822008-02-08 04:18:44 -08001385
Joe Petersonacc71bb2009-01-02 13:43:32 +00001386 if (L_ECHO(tty)) {
Jiri Slaby57c94122012-10-18 22:26:43 +02001387 finish_erasing(ldata);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001388 if (c == '\n')
Jiri Slaby57c94122012-10-18 22:26:43 +02001389 echo_char_raw('\n', ldata);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001390 else {
1391 /* Record the column of first canon char. */
Jiri Slabyba2e68a2012-10-18 22:26:41 +02001392 if (ldata->canon_head == ldata->read_head)
Jiri Slaby57c94122012-10-18 22:26:43 +02001393 echo_set_canon_col(ldata);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001394 echo_char(c, tty);
1395 }
Peter Hurley17bd7902013-06-15 10:04:24 -04001396 commit_echoes(tty);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001397 }
1398
Peter Hurley001ba922013-12-02 14:24:44 -05001399 /* PARMRK doubling check */
1400 if (c == (unsigned char) '\377' && I_PARMRK(tty))
Jiri Slaby57c94122012-10-18 22:26:43 +02001401 put_tty_queue(c, ldata);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001402
Jiri Slaby57c94122012-10-18 22:26:43 +02001403 put_tty_queue(c, ldata);
Peter Hurleye60d27c2013-07-24 08:29:56 -04001404 return 0;
Alan Cox4edf1822008-02-08 04:18:44 -08001405}
Linus Torvalds1da177e2005-04-16 15:20:36 -07001406
Peter Hurleye60d27c2013-07-24 08:29:56 -04001407static inline void
1408n_tty_receive_char_inline(struct tty_struct *tty, unsigned char c)
Peter Hurley4b1f79c2013-07-24 08:29:51 -04001409{
1410 struct n_tty_data *ldata = tty->disc_data;
Peter Hurley4b1f79c2013-07-24 08:29:51 -04001411
Peter Hurleye60d27c2013-07-24 08:29:56 -04001412 if (tty->stopped && !tty->flow_stopped && I_IXON(tty) && I_IXANY(tty)) {
1413 start_tty(tty);
1414 process_echoes(tty);
Peter Hurley4b1f79c2013-07-24 08:29:51 -04001415 }
Peter Hurleye60d27c2013-07-24 08:29:56 -04001416 if (L_ECHO(tty)) {
1417 finish_erasing(ldata);
1418 /* Record the column of first canon char. */
1419 if (ldata->canon_head == ldata->read_head)
1420 echo_set_canon_col(ldata);
1421 echo_char(c, tty);
1422 commit_echoes(tty);
1423 }
Peter Hurley001ba922013-12-02 14:24:44 -05001424 /* PARMRK doubling check */
1425 if (c == (unsigned char) '\377' && I_PARMRK(tty))
Peter Hurleye60d27c2013-07-24 08:29:56 -04001426 put_tty_queue(c, ldata);
1427 put_tty_queue(c, ldata);
1428}
Peter Hurley4b1f79c2013-07-24 08:29:51 -04001429
Peter Hurleyeb3e4662013-12-02 14:24:42 -05001430static void n_tty_receive_char(struct tty_struct *tty, unsigned char c)
Peter Hurleye60d27c2013-07-24 08:29:56 -04001431{
1432 n_tty_receive_char_inline(tty, c);
Peter Hurley4b1f79c2013-07-24 08:29:51 -04001433}
1434
Peter Hurleyad0cc7b2013-06-15 10:21:27 -04001435static inline void
Peter Hurley7de971b2013-07-24 08:29:53 -04001436n_tty_receive_char_fast(struct tty_struct *tty, unsigned char c)
1437{
1438 struct n_tty_data *ldata = tty->disc_data;
1439
Peter Hurleye60d27c2013-07-24 08:29:56 -04001440 if (tty->stopped && !tty->flow_stopped && I_IXON(tty) && I_IXANY(tty)) {
1441 start_tty(tty);
1442 process_echoes(tty);
Peter Hurley7de971b2013-07-24 08:29:53 -04001443 }
Peter Hurleye60d27c2013-07-24 08:29:56 -04001444 if (L_ECHO(tty)) {
1445 finish_erasing(ldata);
1446 /* Record the column of first canon char. */
1447 if (ldata->canon_head == ldata->read_head)
1448 echo_set_canon_col(ldata);
1449 echo_char(c, tty);
1450 commit_echoes(tty);
1451 }
1452 put_tty_queue(c, ldata);
Peter Hurley7de971b2013-07-24 08:29:53 -04001453}
1454
Peter Hurley8dc4b252013-12-02 14:24:43 -05001455static void n_tty_receive_char_closing(struct tty_struct *tty, unsigned char c)
Peter Hurleyad0cc7b2013-06-15 10:21:27 -04001456{
1457 if (I_ISTRIP(tty))
1458 c &= 0x7f;
1459 if (I_IUCLC(tty) && L_IEXTEN(tty))
1460 c = tolower(c);
1461
1462 if (I_IXON(tty)) {
1463 if (c == STOP_CHAR(tty))
1464 stop_tty(tty);
1465 else if (c == START_CHAR(tty) ||
1466 (tty->stopped && !tty->flow_stopped && I_IXANY(tty) &&
1467 c != INTR_CHAR(tty) && c != QUIT_CHAR(tty) &&
1468 c != SUSP_CHAR(tty))) {
1469 start_tty(tty);
1470 process_echoes(tty);
1471 }
1472 }
1473}
1474
Peter Hurleyd2f8d7a2013-06-15 10:21:24 -04001475static void
1476n_tty_receive_char_flagged(struct tty_struct *tty, unsigned char c, char flag)
1477{
1478 char buf[64];
1479
1480 switch (flag) {
1481 case TTY_BREAK:
1482 n_tty_receive_break(tty);
1483 break;
1484 case TTY_PARITY:
1485 case TTY_FRAME:
1486 n_tty_receive_parity_error(tty, c);
1487 break;
1488 case TTY_OVERRUN:
1489 n_tty_receive_overrun(tty);
1490 break;
1491 default:
1492 printk(KERN_ERR "%s: unknown flag %d\n",
1493 tty_name(tty, buf), flag);
1494 break;
1495 }
1496}
1497
Peter Hurleye60d27c2013-07-24 08:29:56 -04001498static void
1499n_tty_receive_char_lnext(struct tty_struct *tty, unsigned char c, char flag)
1500{
1501 struct n_tty_data *ldata = tty->disc_data;
1502
1503 ldata->lnext = 0;
1504 if (likely(flag == TTY_NORMAL)) {
1505 if (I_ISTRIP(tty))
1506 c &= 0x7f;
1507 if (I_IUCLC(tty) && L_IEXTEN(tty))
1508 c = tolower(c);
1509 n_tty_receive_char(tty, c);
1510 } else
1511 n_tty_receive_char_flagged(tty, c, flag);
1512}
1513
Linus Torvalds1da177e2005-04-16 15:20:36 -07001514/**
1515 * n_tty_receive_buf - data receive
1516 * @tty: terminal device
1517 * @cp: buffer
1518 * @fp: flag buffer
1519 * @count: characters
1520 *
1521 * Called by the terminal driver when a block of characters has
1522 * been received. This function must be called from soft contexts
1523 * not from interrupt context. The driver is responsible for making
1524 * calls one at a time and in order (or using flush_to_ldisc)
Peter Hurley6d76bd22013-06-15 09:14:26 -04001525 *
1526 * n_tty_receive_buf()/producer path:
1527 * claims non-exclusive termios_rwsem
1528 * publishes read_head and canon_head
Linus Torvalds1da177e2005-04-16 15:20:36 -07001529 */
Alan Cox4edf1822008-02-08 04:18:44 -08001530
Peter Hurley4a23a4d2013-06-15 10:21:22 -04001531static void
1532n_tty_receive_buf_real_raw(struct tty_struct *tty, const unsigned char *cp,
1533 char *fp, int count)
1534{
1535 struct n_tty_data *ldata = tty->disc_data;
1536 size_t n, head;
1537
1538 head = ldata->read_head & (N_TTY_BUF_SIZE - 1);
1539 n = N_TTY_BUF_SIZE - max(read_cnt(ldata), head);
1540 n = min_t(size_t, count, n);
1541 memcpy(read_buf_addr(ldata, head), cp, n);
1542 ldata->read_head += n;
1543 cp += n;
1544 count -= n;
1545
1546 head = ldata->read_head & (N_TTY_BUF_SIZE - 1);
1547 n = N_TTY_BUF_SIZE - max(read_cnt(ldata), head);
1548 n = min_t(size_t, count, n);
1549 memcpy(read_buf_addr(ldata, head), cp, n);
1550 ldata->read_head += n;
1551}
1552
Peter Hurley554117b2013-06-15 10:21:25 -04001553static void
1554n_tty_receive_buf_raw(struct tty_struct *tty, const unsigned char *cp,
1555 char *fp, int count)
1556{
1557 struct n_tty_data *ldata = tty->disc_data;
1558 char flag = TTY_NORMAL;
1559
1560 while (count--) {
1561 if (fp)
1562 flag = *fp++;
1563 if (likely(flag == TTY_NORMAL))
1564 put_tty_queue(*cp++, ldata);
1565 else
1566 n_tty_receive_char_flagged(tty, *cp++, flag);
1567 }
1568}
1569
Peter Hurleyad0cc7b2013-06-15 10:21:27 -04001570static void
1571n_tty_receive_buf_closing(struct tty_struct *tty, const unsigned char *cp,
1572 char *fp, int count)
1573{
1574 char flag = TTY_NORMAL;
1575
1576 while (count--) {
1577 if (fp)
1578 flag = *fp++;
1579 if (likely(flag == TTY_NORMAL))
1580 n_tty_receive_char_closing(tty, *cp++);
1581 else
1582 n_tty_receive_char_flagged(tty, *cp++, flag);
1583 }
1584}
1585
Peter Hurley7d88d632013-07-24 08:29:49 -04001586static void
1587n_tty_receive_buf_standard(struct tty_struct *tty, const unsigned char *cp,
Peter Hurley6baad002013-07-24 08:29:52 -04001588 char *fp, int count)
1589{
1590 struct n_tty_data *ldata = tty->disc_data;
1591 char flag = TTY_NORMAL;
1592
1593 while (count--) {
1594 if (fp)
1595 flag = *fp++;
1596 if (likely(flag == TTY_NORMAL)) {
1597 unsigned char c = *cp++;
1598
1599 if (I_ISTRIP(tty))
1600 c &= 0x7f;
1601 if (I_IUCLC(tty) && L_IEXTEN(tty))
1602 c = tolower(c);
1603 if (L_EXTPROC(tty)) {
1604 put_tty_queue(c, ldata);
1605 continue;
1606 }
Peter Hurleye60d27c2013-07-24 08:29:56 -04001607 if (!test_bit(c, ldata->char_map))
1608 n_tty_receive_char_inline(tty, c);
1609 else if (n_tty_receive_char_special(tty, c) && count) {
1610 if (fp)
1611 flag = *fp++;
1612 n_tty_receive_char_lnext(tty, *cp++, flag);
1613 count--;
1614 }
Peter Hurley6baad002013-07-24 08:29:52 -04001615 } else
1616 n_tty_receive_char_flagged(tty, *cp++, flag);
1617 }
1618}
1619
1620static void
1621n_tty_receive_buf_fast(struct tty_struct *tty, const unsigned char *cp,
1622 char *fp, int count)
Peter Hurley7d88d632013-07-24 08:29:49 -04001623{
Peter Hurleye60d27c2013-07-24 08:29:56 -04001624 struct n_tty_data *ldata = tty->disc_data;
Peter Hurley7d88d632013-07-24 08:29:49 -04001625 char flag = TTY_NORMAL;
1626
1627 while (count--) {
1628 if (fp)
1629 flag = *fp++;
Peter Hurleye60d27c2013-07-24 08:29:56 -04001630 if (likely(flag == TTY_NORMAL)) {
1631 unsigned char c = *cp++;
1632
1633 if (!test_bit(c, ldata->char_map))
1634 n_tty_receive_char_fast(tty, c);
1635 else if (n_tty_receive_char_special(tty, c) && count) {
1636 if (fp)
1637 flag = *fp++;
1638 n_tty_receive_char_lnext(tty, *cp++, flag);
1639 count--;
1640 }
1641 } else
Peter Hurley7d88d632013-07-24 08:29:49 -04001642 n_tty_receive_char_flagged(tty, *cp++, flag);
1643 }
1644}
1645
Peter Hurley24a89d12013-06-15 09:14:15 -04001646static void __receive_buf(struct tty_struct *tty, const unsigned char *cp,
1647 char *fp, int count)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001648{
Jiri Slaby53c5ee22012-10-18 22:26:39 +02001649 struct n_tty_data *ldata = tty->disc_data;
Peter Hurleya1dd30e2013-06-15 10:21:26 -04001650 bool preops = I_ISTRIP(tty) || (I_IUCLC(tty) && L_IEXTEN(tty));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001651
Peter Hurley4a23a4d2013-06-15 10:21:22 -04001652 if (ldata->real_raw)
1653 n_tty_receive_buf_real_raw(tty, cp, fp, count);
Peter Hurleya1dd30e2013-06-15 10:21:26 -04001654 else if (ldata->raw || (L_EXTPROC(tty) && !preops))
Peter Hurley554117b2013-06-15 10:21:25 -04001655 n_tty_receive_buf_raw(tty, cp, fp, count);
Peter Hurleyad0cc7b2013-06-15 10:21:27 -04001656 else if (tty->closing && !L_EXTPROC(tty))
1657 n_tty_receive_buf_closing(tty, cp, fp, count);
Peter Hurley4a23a4d2013-06-15 10:21:22 -04001658 else {
Peter Hurleye60d27c2013-07-24 08:29:56 -04001659 if (ldata->lnext) {
1660 char flag = TTY_NORMAL;
1661
1662 if (fp)
1663 flag = *fp++;
1664 n_tty_receive_char_lnext(tty, *cp++, flag);
1665 count--;
1666 }
1667
Peter Hurley7de971b2013-07-24 08:29:53 -04001668 if (!preops && !I_PARMRK(tty))
Peter Hurley6baad002013-07-24 08:29:52 -04001669 n_tty_receive_buf_fast(tty, cp, fp, count);
1670 else
1671 n_tty_receive_buf_standard(tty, cp, fp, count);
Peter Hurleycbfd0342013-06-15 10:04:26 -04001672
1673 flush_echoes(tty);
Alan Coxf34d7a52008-04-30 00:54:13 -07001674 if (tty->ops->flush_chars)
1675 tty->ops->flush_chars(tty);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001676 }
1677
Peter Hurleyce741172013-06-15 09:14:20 -04001678 if ((!ldata->icanon && (read_cnt(ldata) >= ldata->minimum_to_wake)) ||
hyc@symas.com26df6d12010-06-22 10:14:49 -07001679 L_EXTPROC(tty)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001680 kill_fasync(&tty->fasync, SIGIO, POLL_IN);
1681 if (waitqueue_active(&tty->read_wait))
Peter Hurley57087d52014-08-07 07:14:10 -04001682 wake_up_interruptible_poll(&tty->read_wait, POLLIN);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001683 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001684}
1685
Peter Hurley5c32d122013-12-02 14:24:41 -05001686static int
1687n_tty_receive_buf_common(struct tty_struct *tty, const unsigned char *cp,
1688 char *fp, int count, int flow)
Peter Hurley24a89d12013-06-15 09:14:15 -04001689{
1690 struct n_tty_data *ldata = tty->disc_data;
Peter Hurley19e2ad62013-07-24 08:29:54 -04001691 int room, n, rcvd = 0;
Peter Hurley24a89d12013-06-15 09:14:15 -04001692
Peter Hurley9356b532013-06-15 09:14:24 -04001693 down_read(&tty->termios_rwsem);
1694
Peter Hurley19e2ad62013-07-24 08:29:54 -04001695 while (1) {
1696 room = receive_room(tty);
1697 n = min(count, room);
1698 if (!n) {
Peter Hurley5c32d122013-12-02 14:24:41 -05001699 if (flow && !room)
Peter Hurley19e2ad62013-07-24 08:29:54 -04001700 ldata->no_room = 1;
1701 break;
1702 }
1703 __receive_buf(tty, cp, fp, n);
1704 cp += n;
1705 if (fp)
1706 fp += n;
1707 count -= n;
1708 rcvd += n;
Peter Hurley4a23a4d2013-06-15 10:21:22 -04001709 }
Peter Hurley24a89d12013-06-15 09:14:15 -04001710
Peter Hurley19e2ad62013-07-24 08:29:54 -04001711 tty->receive_room = room;
1712 n_tty_check_throttle(tty);
Peter Hurley9356b532013-06-15 09:14:24 -04001713 up_read(&tty->termios_rwsem);
1714
Peter Hurley19e2ad62013-07-24 08:29:54 -04001715 return rcvd;
Peter Hurley24a89d12013-06-15 09:14:15 -04001716}
1717
Peter Hurley5c32d122013-12-02 14:24:41 -05001718static void n_tty_receive_buf(struct tty_struct *tty, const unsigned char *cp,
1719 char *fp, int count)
1720{
1721 n_tty_receive_buf_common(tty, cp, fp, count, 0);
1722}
1723
1724static int n_tty_receive_buf2(struct tty_struct *tty, const unsigned char *cp,
1725 char *fp, int count)
1726{
1727 return n_tty_receive_buf_common(tty, cp, fp, count, 1);
1728}
1729
Linus Torvalds1da177e2005-04-16 15:20:36 -07001730int is_ignored(int sig)
1731{
1732 return (sigismember(&current->blocked, sig) ||
Alan Cox4edf1822008-02-08 04:18:44 -08001733 current->sighand->action[sig-1].sa.sa_handler == SIG_IGN);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001734}
1735
1736/**
1737 * n_tty_set_termios - termios data changed
1738 * @tty: terminal
1739 * @old: previous data
1740 *
1741 * Called by the tty layer when the user changes termios flags so
1742 * that the line discipline can plan ahead. This function cannot sleep
Alan Cox4edf1822008-02-08 04:18:44 -08001743 * and is protected from re-entry by the tty layer. The user is
Linus Torvalds1da177e2005-04-16 15:20:36 -07001744 * guaranteed that this function will not be re-entered or in progress
1745 * when the ldisc is closed.
Alan Cox17b82062008-10-13 10:45:06 +01001746 *
Peter Hurley6a1c0682013-06-15 09:14:23 -04001747 * Locking: Caller holds tty->termios_rwsem
Linus Torvalds1da177e2005-04-16 15:20:36 -07001748 */
Alan Cox4edf1822008-02-08 04:18:44 -08001749
1750static void n_tty_set_termios(struct tty_struct *tty, struct ktermios *old)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001751{
Jiri Slaby53c5ee22012-10-18 22:26:39 +02001752 struct n_tty_data *ldata = tty->disc_data;
Alan Cox47afa7a2008-10-13 10:44:17 +01001753
Peter Hurleyc786f742013-09-17 12:53:35 -04001754 if (!old || (old->c_lflag ^ tty->termios.c_lflag) & ICANON) {
Jiri Slaby3fe780b2012-10-18 22:26:40 +02001755 bitmap_zero(ldata->read_flags, N_TTY_BUF_SIZE);
Peter Hurley4d0ed182013-12-10 17:12:02 -05001756 ldata->line_start = ldata->read_tail;
1757 if (!L_ICANON(tty) || !read_cnt(ldata)) {
1758 ldata->canon_head = ldata->read_tail;
1759 ldata->push = 0;
1760 } else {
1761 set_bit((ldata->read_head - 1) & (N_TTY_BUF_SIZE - 1),
1762 ldata->read_flags);
1763 ldata->canon_head = ldata->read_head;
1764 ldata->push = 1;
1765 }
Jiri Slaby53c5ee22012-10-18 22:26:39 +02001766 ldata->erasing = 0;
Peter Hurley6f9b0282013-06-15 09:14:27 -04001767 ldata->lnext = 0;
Alan Cox47afa7a2008-10-13 10:44:17 +01001768 }
1769
Jiri Slaby53c5ee22012-10-18 22:26:39 +02001770 ldata->icanon = (L_ICANON(tty) != 0);
Peter Hurley582f5592013-05-17 12:49:48 -04001771
Linus Torvalds1da177e2005-04-16 15:20:36 -07001772 if (I_ISTRIP(tty) || I_IUCLC(tty) || I_IGNCR(tty) ||
1773 I_ICRNL(tty) || I_INLCR(tty) || L_ICANON(tty) ||
1774 I_IXON(tty) || L_ISIG(tty) || L_ECHO(tty) ||
1775 I_PARMRK(tty)) {
Peter Hurley1bb9d562013-06-15 10:21:20 -04001776 bitmap_zero(ldata->char_map, 256);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001777
1778 if (I_IGNCR(tty) || I_ICRNL(tty))
Peter Hurley1bb9d562013-06-15 10:21:20 -04001779 set_bit('\r', ldata->char_map);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001780 if (I_INLCR(tty))
Peter Hurley1bb9d562013-06-15 10:21:20 -04001781 set_bit('\n', ldata->char_map);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001782
1783 if (L_ICANON(tty)) {
Peter Hurley1bb9d562013-06-15 10:21:20 -04001784 set_bit(ERASE_CHAR(tty), ldata->char_map);
1785 set_bit(KILL_CHAR(tty), ldata->char_map);
1786 set_bit(EOF_CHAR(tty), ldata->char_map);
1787 set_bit('\n', ldata->char_map);
1788 set_bit(EOL_CHAR(tty), ldata->char_map);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001789 if (L_IEXTEN(tty)) {
Peter Hurley1bb9d562013-06-15 10:21:20 -04001790 set_bit(WERASE_CHAR(tty), ldata->char_map);
1791 set_bit(LNEXT_CHAR(tty), ldata->char_map);
1792 set_bit(EOL2_CHAR(tty), ldata->char_map);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001793 if (L_ECHO(tty))
1794 set_bit(REPRINT_CHAR(tty),
Peter Hurley1bb9d562013-06-15 10:21:20 -04001795 ldata->char_map);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001796 }
1797 }
1798 if (I_IXON(tty)) {
Peter Hurley1bb9d562013-06-15 10:21:20 -04001799 set_bit(START_CHAR(tty), ldata->char_map);
1800 set_bit(STOP_CHAR(tty), ldata->char_map);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001801 }
1802 if (L_ISIG(tty)) {
Peter Hurley1bb9d562013-06-15 10:21:20 -04001803 set_bit(INTR_CHAR(tty), ldata->char_map);
1804 set_bit(QUIT_CHAR(tty), ldata->char_map);
1805 set_bit(SUSP_CHAR(tty), ldata->char_map);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001806 }
Peter Hurley1bb9d562013-06-15 10:21:20 -04001807 clear_bit(__DISABLED_CHAR, ldata->char_map);
Jiri Slaby53c5ee22012-10-18 22:26:39 +02001808 ldata->raw = 0;
1809 ldata->real_raw = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001810 } else {
Jiri Slaby53c5ee22012-10-18 22:26:39 +02001811 ldata->raw = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001812 if ((I_IGNBRK(tty) || (!I_BRKINT(tty) && !I_PARMRK(tty))) &&
1813 (I_IGNPAR(tty) || !I_INPCK(tty)) &&
1814 (tty->driver->flags & TTY_DRIVER_REAL_RAW))
Jiri Slaby53c5ee22012-10-18 22:26:39 +02001815 ldata->real_raw = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001816 else
Jiri Slaby53c5ee22012-10-18 22:26:39 +02001817 ldata->real_raw = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001818 }
Linus Torvalds55db4c62011-06-04 06:33:24 +09001819 n_tty_set_room(tty);
Wang YanQingdab73b42013-05-09 14:16:47 +08001820 /*
1821 * Fix tty hang when I_IXON(tty) is cleared, but the tty
1822 * been stopped by STOP_CHAR(tty) before it.
1823 */
Peter Hurleye2613be2014-02-11 16:34:55 -05001824 if (!I_IXON(tty) && old && (old->c_iflag & IXON) && !tty->flow_stopped) {
Wang YanQingdab73b42013-05-09 14:16:47 +08001825 start_tty(tty);
Peter Hurleye2613be2014-02-11 16:34:55 -05001826 process_echoes(tty);
1827 }
Wang YanQingdab73b42013-05-09 14:16:47 +08001828
Alan Coxf34d7a52008-04-30 00:54:13 -07001829 /* The termios change make the tty ready for I/O */
Peter Hurley6c677162013-12-02 14:24:46 -05001830 if (waitqueue_active(&tty->write_wait))
1831 wake_up_interruptible(&tty->write_wait);
1832 if (waitqueue_active(&tty->read_wait))
1833 wake_up_interruptible(&tty->read_wait);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001834}
1835
1836/**
1837 * n_tty_close - close the ldisc for this tty
1838 * @tty: device
1839 *
Alan Cox4edf1822008-02-08 04:18:44 -08001840 * Called from the terminal layer when this line discipline is
1841 * being shut down, either because of a close or becsuse of a
Linus Torvalds1da177e2005-04-16 15:20:36 -07001842 * discipline change. The function will not be called while other
1843 * ldisc methods are in progress.
1844 */
Alan Cox4edf1822008-02-08 04:18:44 -08001845
Linus Torvalds1da177e2005-04-16 15:20:36 -07001846static void n_tty_close(struct tty_struct *tty)
1847{
Jiri Slaby70ece7a2012-10-18 22:26:38 +02001848 struct n_tty_data *ldata = tty->disc_data;
1849
Peter Hurley79901312013-03-11 16:44:23 -04001850 if (tty->link)
1851 n_tty_packet_mode_flush(tty);
1852
Peter Hurley20bafb32013-06-15 10:21:19 -04001853 vfree(ldata);
Jiri Slaby70ece7a2012-10-18 22:26:38 +02001854 tty->disc_data = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001855}
1856
1857/**
1858 * n_tty_open - open an ldisc
1859 * @tty: terminal to open
1860 *
Alan Cox4edf1822008-02-08 04:18:44 -08001861 * Called when this line discipline is being attached to the
Linus Torvalds1da177e2005-04-16 15:20:36 -07001862 * terminal device. Can sleep. Called serialized so that no
1863 * other events will occur in parallel. No further open will occur
1864 * until a close.
1865 */
1866
1867static int n_tty_open(struct tty_struct *tty)
1868{
Jiri Slaby70ece7a2012-10-18 22:26:38 +02001869 struct n_tty_data *ldata;
1870
Peter Hurley20bafb32013-06-15 10:21:19 -04001871 /* Currently a malloc failure here can panic */
1872 ldata = vmalloc(sizeof(*ldata));
Jiri Slaby70ece7a2012-10-18 22:26:38 +02001873 if (!ldata)
1874 goto err;
1875
Jiri Slaby53c5ee22012-10-18 22:26:39 +02001876 ldata->overrun_time = jiffies;
Jiri Slabybddc7152012-10-18 22:26:42 +02001877 mutex_init(&ldata->atomic_read_lock);
1878 mutex_init(&ldata->output_lock);
Jiri Slaby53c5ee22012-10-18 22:26:39 +02001879
Jiri Slaby70ece7a2012-10-18 22:26:38 +02001880 tty->disc_data = ldata;
Peter Hurleyb66f4fa2013-03-11 16:44:32 -04001881 reset_buffer_flags(tty->disc_data);
Jiri Slaby53c5ee22012-10-18 22:26:39 +02001882 ldata->column = 0;
Peter Hurley20bafb32013-06-15 10:21:19 -04001883 ldata->canon_column = 0;
Peter Hurleyf6c8dbe2013-06-15 07:28:28 -04001884 ldata->minimum_to_wake = 1;
Peter Hurley20bafb32013-06-15 10:21:19 -04001885 ldata->num_overrun = 0;
1886 ldata->no_room = 0;
1887 ldata->lnext = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001888 tty->closing = 0;
Peter Hurleyb66f4fa2013-03-11 16:44:32 -04001889 /* indicate buffer work may resume */
1890 clear_bit(TTY_LDISC_HALTED, &tty->flags);
1891 n_tty_set_termios(tty, NULL);
1892 tty_unthrottle(tty);
Jiri Slaby70ece7a2012-10-18 22:26:38 +02001893
Linus Torvalds1da177e2005-04-16 15:20:36 -07001894 return 0;
Jiri Slaby70ece7a2012-10-18 22:26:38 +02001895err:
Jiri Slabyb91939f2012-10-18 22:26:35 +02001896 return -ENOMEM;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001897}
1898
Peter Hurleyeafbe672013-12-02 14:24:45 -05001899static inline int input_available_p(struct tty_struct *tty, int poll)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001900{
Jiri Slaby53c5ee22012-10-18 22:26:39 +02001901 struct n_tty_data *ldata = tty->disc_data;
Peter Hurleya5934802014-02-11 11:49:58 -05001902 int amt = poll && !TIME_CHAR(tty) && MIN_CHAR(tty) ? MIN_CHAR(tty) : 1;
Jiri Slaby53c5ee22012-10-18 22:26:39 +02001903
Peter Hurley25e8d0e2014-02-11 18:55:30 -05001904 if (ldata->icanon && !L_EXTPROC(tty))
1905 return ldata->canon_head != ldata->read_tail;
1906 else
1907 return read_cnt(ldata) >= amt;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001908}
1909
1910/**
Thorsten Wißmannbbd20752011-12-08 17:47:33 +01001911 * copy_from_read_buf - copy read data directly
Linus Torvalds1da177e2005-04-16 15:20:36 -07001912 * @tty: terminal device
1913 * @b: user data
1914 * @nr: size of data
1915 *
Alan Cox11a96d12008-10-13 10:46:24 +01001916 * Helper function to speed up n_tty_read. It is only called when
Linus Torvalds1da177e2005-04-16 15:20:36 -07001917 * ICANON is off; it copies characters straight from the tty queue to
1918 * user space directly. It can be profitably called twice; once to
1919 * drain the space from the tail pointer to the (physical) end of the
1920 * buffer, and once to drain the space from the (physical) beginning of
1921 * the buffer to head pointer.
1922 *
Jiri Slabybddc7152012-10-18 22:26:42 +02001923 * Called under the ldata->atomic_read_lock sem
Linus Torvalds1da177e2005-04-16 15:20:36 -07001924 *
Peter Hurley6d76bd22013-06-15 09:14:26 -04001925 * n_tty_read()/consumer path:
1926 * caller holds non-exclusive termios_rwsem
1927 * read_tail published
Linus Torvalds1da177e2005-04-16 15:20:36 -07001928 */
Alan Cox4edf1822008-02-08 04:18:44 -08001929
Alan Cox33f0f882006-01-09 20:54:13 -08001930static int copy_from_read_buf(struct tty_struct *tty,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001931 unsigned char __user **b,
1932 size_t *nr)
1933
1934{
Jiri Slaby53c5ee22012-10-18 22:26:39 +02001935 struct n_tty_data *ldata = tty->disc_data;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001936 int retval;
1937 size_t n;
Jiri Slaby3fa10cc2012-04-26 20:13:00 +02001938 bool is_eof;
Peter Hurleybc5a5e32013-06-15 09:14:21 -04001939 size_t tail = ldata->read_tail & (N_TTY_BUF_SIZE - 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001940
1941 retval = 0;
Peter Hurleybc5a5e32013-06-15 09:14:21 -04001942 n = min(read_cnt(ldata), N_TTY_BUF_SIZE - tail);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001943 n = min(*nr, n);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001944 if (n) {
Peter Hurleybc5a5e32013-06-15 09:14:21 -04001945 retval = copy_to_user(*b, read_buf_addr(ldata, tail), n);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001946 n -= retval;
Peter Hurleybc5a5e32013-06-15 09:14:21 -04001947 is_eof = n == 1 && read_buf(ldata, tail) == EOF_CHAR(tty);
1948 tty_audit_add_data(tty, read_buf_addr(ldata, tail), n,
Jiri Slaby53c5ee22012-10-18 22:26:39 +02001949 ldata->icanon);
Peter Hurleybc5a5e32013-06-15 09:14:21 -04001950 ldata->read_tail += n;
hyc@symas.com26df6d12010-06-22 10:14:49 -07001951 /* Turn single EOF into zero-length read */
Peter Hurleyce741172013-06-15 09:14:20 -04001952 if (L_EXTPROC(tty) && ldata->icanon && is_eof && !read_cnt(ldata))
Jiri Slaby3fa10cc2012-04-26 20:13:00 +02001953 n = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001954 *b += n;
1955 *nr -= n;
1956 }
1957 return retval;
1958}
1959
Peter Hurley88bb0de2013-06-15 09:14:16 -04001960/**
Peter Hurley32f13522013-06-15 09:14:17 -04001961 * canon_copy_from_read_buf - copy read data in canonical mode
Peter Hurley88bb0de2013-06-15 09:14:16 -04001962 * @tty: terminal device
1963 * @b: user data
1964 * @nr: size of data
1965 *
1966 * Helper function for n_tty_read. It is only called when ICANON is on;
Peter Hurley32f13522013-06-15 09:14:17 -04001967 * it copies one line of input up to and including the line-delimiting
1968 * character into the user-space buffer.
Peter Hurley88bb0de2013-06-15 09:14:16 -04001969 *
Peter Hurley4d0ed182013-12-10 17:12:02 -05001970 * NB: When termios is changed from non-canonical to canonical mode and
1971 * the read buffer contains data, n_tty_set_termios() simulates an EOF
1972 * push (as if C-d were input) _without_ the DISABLED_CHAR in the buffer.
1973 * This causes data already processed as input to be immediately available
1974 * as input although a newline has not been received.
1975 *
Peter Hurley88bb0de2013-06-15 09:14:16 -04001976 * Called under the atomic_read_lock mutex
Peter Hurley6d76bd22013-06-15 09:14:26 -04001977 *
1978 * n_tty_read()/consumer path:
1979 * caller holds non-exclusive termios_rwsem
1980 * read_tail published
Peter Hurley88bb0de2013-06-15 09:14:16 -04001981 */
1982
Peter Hurley32f13522013-06-15 09:14:17 -04001983static int canon_copy_from_read_buf(struct tty_struct *tty,
1984 unsigned char __user **b,
1985 size_t *nr)
Peter Hurley88bb0de2013-06-15 09:14:16 -04001986{
1987 struct n_tty_data *ldata = tty->disc_data;
Peter Hurley32f13522013-06-15 09:14:17 -04001988 size_t n, size, more, c;
Peter Hurleybc5a5e32013-06-15 09:14:21 -04001989 size_t eol;
1990 size_t tail;
1991 int ret, found = 0;
Peter Hurley40d5e092013-06-15 10:21:17 -04001992 bool eof_push = 0;
Peter Hurley88bb0de2013-06-15 09:14:16 -04001993
1994 /* N.B. avoid overrun if nr == 0 */
Peter Hurleyce741172013-06-15 09:14:20 -04001995 n = min(*nr, read_cnt(ldata));
Peter Hurley6d76bd22013-06-15 09:14:26 -04001996 if (!n)
Peter Hurley32f13522013-06-15 09:14:17 -04001997 return 0;
Peter Hurley88bb0de2013-06-15 09:14:16 -04001998
Peter Hurleybc5a5e32013-06-15 09:14:21 -04001999 tail = ldata->read_tail & (N_TTY_BUF_SIZE - 1);
Peter Hurley32f13522013-06-15 09:14:17 -04002000 size = min_t(size_t, tail + n, N_TTY_BUF_SIZE);
2001
Peter Hurleybc5a5e32013-06-15 09:14:21 -04002002 n_tty_trace("%s: nr:%zu tail:%zu n:%zu size:%zu\n",
Peter Hurley32f13522013-06-15 09:14:17 -04002003 __func__, *nr, tail, n, size);
2004
2005 eol = find_next_bit(ldata->read_flags, size, tail);
2006 more = n - (size - tail);
2007 if (eol == N_TTY_BUF_SIZE && more) {
2008 /* scan wrapped without finding set bit */
2009 eol = find_next_bit(ldata->read_flags, more, 0);
2010 if (eol != more)
2011 found = 1;
2012 } else if (eol != size)
2013 found = 1;
2014
2015 size = N_TTY_BUF_SIZE - tail;
Peter Hurleyc77569d2013-11-22 07:16:25 -05002016 n = eol - tail;
2017 if (n > 4096)
2018 n += 4096;
2019 n += found;
Peter Hurley32f13522013-06-15 09:14:17 -04002020 c = n;
2021
Peter Hurley4d0ed182013-12-10 17:12:02 -05002022 if (found && !ldata->push && read_buf(ldata, eol) == __DISABLED_CHAR) {
Peter Hurley32f13522013-06-15 09:14:17 -04002023 n--;
Peter Hurley40d5e092013-06-15 10:21:17 -04002024 eof_push = !n && ldata->read_tail != ldata->line_start;
2025 }
Peter Hurley32f13522013-06-15 09:14:17 -04002026
Peter Hurleybc5a5e32013-06-15 09:14:21 -04002027 n_tty_trace("%s: eol:%zu found:%d n:%zu c:%zu size:%zu more:%zu\n",
Peter Hurley32f13522013-06-15 09:14:17 -04002028 __func__, eol, found, n, c, size, more);
2029
Peter Hurley32f13522013-06-15 09:14:17 -04002030 if (n > size) {
Peter Hurleybc5a5e32013-06-15 09:14:21 -04002031 ret = copy_to_user(*b, read_buf_addr(ldata, tail), size);
Peter Hurley32f13522013-06-15 09:14:17 -04002032 if (ret)
2033 return -EFAULT;
2034 ret = copy_to_user(*b + size, ldata->read_buf, n - size);
2035 } else
Peter Hurleybc5a5e32013-06-15 09:14:21 -04002036 ret = copy_to_user(*b, read_buf_addr(ldata, tail), n);
Peter Hurley32f13522013-06-15 09:14:17 -04002037
2038 if (ret)
2039 return -EFAULT;
2040 *b += n;
2041 *nr -= n;
2042
Peter Hurleya73d3d62013-06-15 09:14:25 -04002043 if (found)
Peter Hurley6d76bd22013-06-15 09:14:26 -04002044 clear_bit(eol, ldata->read_flags);
Peter Zijlstra4e857c52014-03-17 18:06:10 +01002045 smp_mb__after_atomic();
Peter Hurley6d76bd22013-06-15 09:14:26 -04002046 ldata->read_tail += c;
Peter Hurley88bb0de2013-06-15 09:14:16 -04002047
Peter Hurley40d5e092013-06-15 10:21:17 -04002048 if (found) {
Peter Hurley4d0ed182013-12-10 17:12:02 -05002049 if (!ldata->push)
2050 ldata->line_start = ldata->read_tail;
2051 else
2052 ldata->push = 0;
Peter Hurley32f13522013-06-15 09:14:17 -04002053 tty_audit_push(tty);
Peter Hurley40d5e092013-06-15 10:21:17 -04002054 }
2055 return eof_push ? -EAGAIN : 0;
Peter Hurley88bb0de2013-06-15 09:14:16 -04002056}
2057
Al Virocc4191d2008-03-29 03:08:48 +00002058extern ssize_t redirected_tty_write(struct file *, const char __user *,
Alan Cox4edf1822008-02-08 04:18:44 -08002059 size_t, loff_t *);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002060
2061/**
2062 * job_control - check job control
2063 * @tty: tty
2064 * @file: file handle
2065 *
2066 * Perform job control management checks on this file/tty descriptor
Alan Cox4edf1822008-02-08 04:18:44 -08002067 * and if appropriate send any needed signals and return a negative
Linus Torvalds1da177e2005-04-16 15:20:36 -07002068 * error code if action should be taken.
Alan Cox04f378b2008-04-30 00:53:29 -07002069 *
Peter Hurley01a5e442013-03-06 08:38:20 -05002070 * Locking: redirected write test is safe
2071 * current->signal->tty check is safe
2072 * ctrl_lock to safely reference tty->pgrp
Linus Torvalds1da177e2005-04-16 15:20:36 -07002073 */
Alan Cox4edf1822008-02-08 04:18:44 -08002074
Linus Torvalds1da177e2005-04-16 15:20:36 -07002075static int job_control(struct tty_struct *tty, struct file *file)
2076{
2077 /* Job control check -- must be done at start and after
2078 every sleep (POSIX.1 7.1.1.4). */
2079 /* NOTE: not yet done after every sleep pending a thorough
2080 check of the logic of this change. -- jlc */
2081 /* don't stop on /dev/console */
Peter Hurley01a5e442013-03-06 08:38:20 -05002082 if (file->f_op->write == redirected_tty_write ||
2083 current->signal->tty != tty)
2084 return 0;
2085
2086 spin_lock_irq(&tty->ctrl_lock);
2087 if (!tty->pgrp)
2088 printk(KERN_ERR "n_tty_read: no tty->pgrp!\n");
2089 else if (task_pgrp(current) != tty->pgrp) {
2090 spin_unlock_irq(&tty->ctrl_lock);
2091 if (is_ignored(SIGTTIN) || is_current_pgrp_orphaned())
2092 return -EIO;
2093 kill_pgrp(task_pgrp(current), SIGTTIN, 1);
2094 set_thread_flag(TIF_SIGPENDING);
2095 return -ERESTARTSYS;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002096 }
Peter Hurley01a5e442013-03-06 08:38:20 -05002097 spin_unlock_irq(&tty->ctrl_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002098 return 0;
2099}
Alan Cox4edf1822008-02-08 04:18:44 -08002100
Linus Torvalds1da177e2005-04-16 15:20:36 -07002101
2102/**
Alan Cox11a96d12008-10-13 10:46:24 +01002103 * n_tty_read - read function for tty
Linus Torvalds1da177e2005-04-16 15:20:36 -07002104 * @tty: tty device
2105 * @file: file object
2106 * @buf: userspace buffer pointer
2107 * @nr: size of I/O
2108 *
2109 * Perform reads for the line discipline. We are guaranteed that the
2110 * line discipline will not be closed under us but we may get multiple
2111 * parallel readers and must handle this ourselves. We may also get
2112 * a hangup. Always called in user context, may sleep.
2113 *
2114 * This code must be sure never to sleep through a hangup.
Peter Hurley6d76bd22013-06-15 09:14:26 -04002115 *
2116 * n_tty_read()/consumer path:
2117 * claims non-exclusive termios_rwsem
2118 * publishes read_tail
Linus Torvalds1da177e2005-04-16 15:20:36 -07002119 */
Alan Cox4edf1822008-02-08 04:18:44 -08002120
Alan Cox11a96d12008-10-13 10:46:24 +01002121static ssize_t n_tty_read(struct tty_struct *tty, struct file *file,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002122 unsigned char __user *buf, size_t nr)
2123{
Jiri Slaby53c5ee22012-10-18 22:26:39 +02002124 struct n_tty_data *ldata = tty->disc_data;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002125 unsigned char __user *b = buf;
2126 DECLARE_WAITQUEUE(wait, current);
2127 int c;
2128 int minimum, time;
2129 ssize_t retval = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002130 long timeout;
2131 unsigned long flags;
Alan Cox04f378b2008-04-30 00:53:29 -07002132 int packet;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002133
Linus Torvalds1da177e2005-04-16 15:20:36 -07002134 c = job_control(tty, file);
Alan Cox4edf1822008-02-08 04:18:44 -08002135 if (c < 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002136 return c;
Alan Cox4edf1822008-02-08 04:18:44 -08002137
Peter Hurleyaefceaf2013-08-11 08:04:23 -04002138 /*
2139 * Internal serialization of reads.
2140 */
2141 if (file->f_flags & O_NONBLOCK) {
2142 if (!mutex_trylock(&ldata->atomic_read_lock))
2143 return -EAGAIN;
2144 } else {
2145 if (mutex_lock_interruptible(&ldata->atomic_read_lock))
2146 return -ERESTARTSYS;
2147 }
2148
Peter Hurley9356b532013-06-15 09:14:24 -04002149 down_read(&tty->termios_rwsem);
2150
Linus Torvalds1da177e2005-04-16 15:20:36 -07002151 minimum = time = 0;
2152 timeout = MAX_SCHEDULE_TIMEOUT;
Jiri Slaby53c5ee22012-10-18 22:26:39 +02002153 if (!ldata->icanon) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002154 minimum = MIN_CHAR(tty);
2155 if (minimum) {
Peter Hurleya6e54312013-06-15 07:28:29 -04002156 time = (HZ / 10) * TIME_CHAR(tty);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002157 if (time)
Peter Hurleyf6c8dbe2013-06-15 07:28:28 -04002158 ldata->minimum_to_wake = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002159 else if (!waitqueue_active(&tty->read_wait) ||
Peter Hurleyf6c8dbe2013-06-15 07:28:28 -04002160 (ldata->minimum_to_wake > minimum))
2161 ldata->minimum_to_wake = minimum;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002162 } else {
Peter Hurleya6e54312013-06-15 07:28:29 -04002163 timeout = (HZ / 10) * TIME_CHAR(tty);
Peter Hurleyf6c8dbe2013-06-15 07:28:28 -04002164 ldata->minimum_to_wake = minimum = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002165 }
2166 }
2167
Alan Cox04f378b2008-04-30 00:53:29 -07002168 packet = tty->packet;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002169
2170 add_wait_queue(&tty->read_wait, &wait);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002171 while (nr) {
2172 /* First test for status change. */
Alan Cox04f378b2008-04-30 00:53:29 -07002173 if (packet && tty->link->ctrl_status) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002174 unsigned char cs;
2175 if (b != buf)
2176 break;
Alan Cox04f378b2008-04-30 00:53:29 -07002177 spin_lock_irqsave(&tty->link->ctrl_lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002178 cs = tty->link->ctrl_status;
2179 tty->link->ctrl_status = 0;
Alan Cox04f378b2008-04-30 00:53:29 -07002180 spin_unlock_irqrestore(&tty->link->ctrl_lock, flags);
Miloslav Trmac522ed772007-07-15 23:40:56 -07002181 if (tty_put_user(tty, cs, b++)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002182 retval = -EFAULT;
2183 b--;
2184 break;
2185 }
2186 nr--;
2187 break;
2188 }
2189 /* This statement must be first before checking for input
2190 so that any interrupt will set the state back to
2191 TASK_RUNNING. */
2192 set_current_state(TASK_INTERRUPTIBLE);
Alan Cox4edf1822008-02-08 04:18:44 -08002193
Peter Hurleyf6c8dbe2013-06-15 07:28:28 -04002194 if (((minimum - (b - buf)) < ldata->minimum_to_wake) &&
Linus Torvalds1da177e2005-04-16 15:20:36 -07002195 ((minimum - (b - buf)) >= 1))
Peter Hurleyf6c8dbe2013-06-15 07:28:28 -04002196 ldata->minimum_to_wake = (minimum - (b - buf));
Alan Cox4edf1822008-02-08 04:18:44 -08002197
Linus Torvalds1da177e2005-04-16 15:20:36 -07002198 if (!input_available_p(tty, 0)) {
2199 if (test_bit(TTY_OTHER_CLOSED, &tty->flags)) {
Peter Hurleyf8747d42013-09-27 13:27:05 -04002200 up_read(&tty->termios_rwsem);
2201 tty_flush_to_ldisc(tty);
2202 down_read(&tty->termios_rwsem);
2203 if (!input_available_p(tty, 0)) {
2204 retval = -EIO;
2205 break;
2206 }
2207 } else {
2208 if (tty_hung_up_p(file))
2209 break;
2210 if (!timeout)
2211 break;
2212 if (file->f_flags & O_NONBLOCK) {
2213 retval = -EAGAIN;
2214 break;
2215 }
2216 if (signal_pending(current)) {
2217 retval = -ERESTARTSYS;
2218 break;
2219 }
2220 n_tty_set_room(tty);
2221 up_read(&tty->termios_rwsem);
Peter Hurley9356b532013-06-15 09:14:24 -04002222
Peter Hurleyf8747d42013-09-27 13:27:05 -04002223 timeout = schedule_timeout(timeout);
Peter Hurley9356b532013-06-15 09:14:24 -04002224
Peter Hurleyf8747d42013-09-27 13:27:05 -04002225 down_read(&tty->termios_rwsem);
2226 continue;
2227 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002228 }
2229 __set_current_state(TASK_RUNNING);
2230
2231 /* Deal with packet mode. */
Alan Cox04f378b2008-04-30 00:53:29 -07002232 if (packet && b == buf) {
Miloslav Trmac522ed772007-07-15 23:40:56 -07002233 if (tty_put_user(tty, TIOCPKT_DATA, b++)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002234 retval = -EFAULT;
2235 b--;
2236 break;
2237 }
2238 nr--;
2239 }
2240
Jiri Slaby53c5ee22012-10-18 22:26:39 +02002241 if (ldata->icanon && !L_EXTPROC(tty)) {
Peter Hurley32f13522013-06-15 09:14:17 -04002242 retval = canon_copy_from_read_buf(tty, &b, &nr);
Peter Hurley40d5e092013-06-15 10:21:17 -04002243 if (retval == -EAGAIN) {
2244 retval = 0;
2245 continue;
2246 } else if (retval)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002247 break;
2248 } else {
2249 int uncopied;
Alan Cox04f378b2008-04-30 00:53:29 -07002250 /* The copy function takes the read lock and handles
2251 locking internally for this case */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002252 uncopied = copy_from_read_buf(tty, &b, &nr);
2253 uncopied += copy_from_read_buf(tty, &b, &nr);
2254 if (uncopied) {
2255 retval = -EFAULT;
2256 break;
2257 }
2258 }
2259
Peter Hurley6367ca72013-06-15 09:14:33 -04002260 n_tty_check_unthrottle(tty);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002261
2262 if (b - buf >= minimum)
2263 break;
2264 if (time)
2265 timeout = time;
2266 }
Peter Hurley42458f42013-11-07 13:59:46 -05002267 n_tty_set_room(tty);
2268 up_read(&tty->termios_rwsem);
2269
Linus Torvalds1da177e2005-04-16 15:20:36 -07002270 remove_wait_queue(&tty->read_wait, &wait);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002271 if (!waitqueue_active(&tty->read_wait))
Peter Hurleyf6c8dbe2013-06-15 07:28:28 -04002272 ldata->minimum_to_wake = minimum;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002273
Peter Hurleyaebf04532013-11-07 14:01:57 -05002274 mutex_unlock(&ldata->atomic_read_lock);
2275
Linus Torvalds1da177e2005-04-16 15:20:36 -07002276 __set_current_state(TASK_RUNNING);
Peter Hurley40d5e092013-06-15 10:21:17 -04002277 if (b - buf)
2278 retval = b - buf;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002279
2280 return retval;
2281}
2282
2283/**
Alan Cox11a96d12008-10-13 10:46:24 +01002284 * n_tty_write - write function for tty
Linus Torvalds1da177e2005-04-16 15:20:36 -07002285 * @tty: tty device
2286 * @file: file object
2287 * @buf: userspace buffer pointer
2288 * @nr: size of I/O
2289 *
Joe Petersona88a69c2009-01-02 13:40:53 +00002290 * Write function of the terminal device. This is serialized with
Linus Torvalds1da177e2005-04-16 15:20:36 -07002291 * respect to other write callers but not to termios changes, reads
Joe Petersona88a69c2009-01-02 13:40:53 +00002292 * and other such events. Since the receive code will echo characters,
2293 * thus calling driver write methods, the output_lock is used in
2294 * the output processing functions called here as well as in the
2295 * echo processing function to protect the column state and space
2296 * left in the buffer.
Linus Torvalds1da177e2005-04-16 15:20:36 -07002297 *
2298 * This code must be sure never to sleep through a hangup.
Joe Petersona88a69c2009-01-02 13:40:53 +00002299 *
2300 * Locking: output_lock to protect column state and space left
2301 * (note that the process_output*() functions take this
2302 * lock themselves)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002303 */
Alan Cox4edf1822008-02-08 04:18:44 -08002304
Alan Cox11a96d12008-10-13 10:46:24 +01002305static ssize_t n_tty_write(struct tty_struct *tty, struct file *file,
Joe Petersona88a69c2009-01-02 13:40:53 +00002306 const unsigned char *buf, size_t nr)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002307{
2308 const unsigned char *b = buf;
2309 DECLARE_WAITQUEUE(wait, current);
2310 int c;
2311 ssize_t retval = 0;
2312
2313 /* Job control check -- must be done at start (POSIX.1 7.1.1.4). */
2314 if (L_TOSTOP(tty) && file->f_op->write != redirected_tty_write) {
2315 retval = tty_check_change(tty);
2316 if (retval)
2317 return retval;
2318 }
2319
Peter Hurley9356b532013-06-15 09:14:24 -04002320 down_read(&tty->termios_rwsem);
2321
Joe Petersona88a69c2009-01-02 13:40:53 +00002322 /* Write out any echoed characters that are still pending */
2323 process_echoes(tty);
Alan Cox300a6202009-01-02 13:41:04 +00002324
Linus Torvalds1da177e2005-04-16 15:20:36 -07002325 add_wait_queue(&tty->write_wait, &wait);
2326 while (1) {
2327 set_current_state(TASK_INTERRUPTIBLE);
2328 if (signal_pending(current)) {
2329 retval = -ERESTARTSYS;
2330 break;
2331 }
2332 if (tty_hung_up_p(file) || (tty->link && !tty->link->count)) {
2333 retval = -EIO;
2334 break;
2335 }
Peter Hurley582f5592013-05-17 12:49:48 -04002336 if (O_OPOST(tty)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002337 while (nr > 0) {
Joe Petersona88a69c2009-01-02 13:40:53 +00002338 ssize_t num = process_output_block(tty, b, nr);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002339 if (num < 0) {
2340 if (num == -EAGAIN)
2341 break;
2342 retval = num;
2343 goto break_out;
2344 }
2345 b += num;
2346 nr -= num;
2347 if (nr == 0)
2348 break;
2349 c = *b;
Joe Petersona88a69c2009-01-02 13:40:53 +00002350 if (process_output(c, tty) < 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002351 break;
2352 b++; nr--;
2353 }
Alan Coxf34d7a52008-04-30 00:54:13 -07002354 if (tty->ops->flush_chars)
2355 tty->ops->flush_chars(tty);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002356 } else {
Peter Hurley42910862014-05-03 14:04:59 +02002357 struct n_tty_data *ldata = tty->disc_data;
2358
Roman Zippeld6afe272005-07-07 17:56:55 -07002359 while (nr > 0) {
Peter Hurley42910862014-05-03 14:04:59 +02002360 mutex_lock(&ldata->output_lock);
Alan Coxf34d7a52008-04-30 00:54:13 -07002361 c = tty->ops->write(tty, b, nr);
Peter Hurley42910862014-05-03 14:04:59 +02002362 mutex_unlock(&ldata->output_lock);
Roman Zippeld6afe272005-07-07 17:56:55 -07002363 if (c < 0) {
2364 retval = c;
2365 goto break_out;
2366 }
2367 if (!c)
2368 break;
2369 b += c;
2370 nr -= c;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002371 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002372 }
2373 if (!nr)
2374 break;
2375 if (file->f_flags & O_NONBLOCK) {
2376 retval = -EAGAIN;
2377 break;
2378 }
Peter Hurley9356b532013-06-15 09:14:24 -04002379 up_read(&tty->termios_rwsem);
2380
Linus Torvalds1da177e2005-04-16 15:20:36 -07002381 schedule();
Peter Hurley9356b532013-06-15 09:14:24 -04002382
2383 down_read(&tty->termios_rwsem);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002384 }
2385break_out:
2386 __set_current_state(TASK_RUNNING);
2387 remove_wait_queue(&tty->write_wait, &wait);
Thomas Pfaffff8cb0f2009-01-02 13:47:13 +00002388 if (b - buf != nr && tty->fasync)
2389 set_bit(TTY_DO_WRITE_WAKEUP, &tty->flags);
Peter Hurley9356b532013-06-15 09:14:24 -04002390 up_read(&tty->termios_rwsem);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002391 return (b - buf) ? b - buf : retval;
2392}
2393
2394/**
Alan Cox11a96d12008-10-13 10:46:24 +01002395 * n_tty_poll - poll method for N_TTY
Linus Torvalds1da177e2005-04-16 15:20:36 -07002396 * @tty: terminal device
2397 * @file: file accessing it
2398 * @wait: poll table
2399 *
2400 * Called when the line discipline is asked to poll() for data or
2401 * for special events. This code is not serialized with respect to
2402 * other events save open/close.
2403 *
2404 * This code must be sure never to sleep through a hangup.
2405 * Called without the kernel lock held - fine
Linus Torvalds1da177e2005-04-16 15:20:36 -07002406 */
Alan Cox4edf1822008-02-08 04:18:44 -08002407
Alan Cox11a96d12008-10-13 10:46:24 +01002408static unsigned int n_tty_poll(struct tty_struct *tty, struct file *file,
Alan Cox4edf1822008-02-08 04:18:44 -08002409 poll_table *wait)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002410{
Peter Hurleyf6c8dbe2013-06-15 07:28:28 -04002411 struct n_tty_data *ldata = tty->disc_data;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002412 unsigned int mask = 0;
2413
2414 poll_wait(file, &tty->read_wait, wait);
2415 poll_wait(file, &tty->write_wait, wait);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002416 if (test_bit(TTY_OTHER_CLOSED, &tty->flags))
2417 mask |= POLLHUP;
Francesco Ruggeric4dc3042014-10-10 13:09:53 -07002418 if (input_available_p(tty, 1))
2419 mask |= POLLIN | POLLRDNORM;
2420 else if (mask & POLLHUP) {
2421 tty_flush_to_ldisc(tty);
2422 if (input_available_p(tty, 1))
2423 mask |= POLLIN | POLLRDNORM;
2424 }
2425 if (tty->packet && tty->link->ctrl_status)
2426 mask |= POLLPRI | POLLIN | POLLRDNORM;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002427 if (tty_hung_up_p(file))
2428 mask |= POLLHUP;
2429 if (!(mask & (POLLHUP | POLLIN | POLLRDNORM))) {
2430 if (MIN_CHAR(tty) && !TIME_CHAR(tty))
Peter Hurleyf6c8dbe2013-06-15 07:28:28 -04002431 ldata->minimum_to_wake = MIN_CHAR(tty);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002432 else
Peter Hurleyf6c8dbe2013-06-15 07:28:28 -04002433 ldata->minimum_to_wake = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002434 }
Alan Coxf34d7a52008-04-30 00:54:13 -07002435 if (tty->ops->write && !tty_is_writelocked(tty) &&
2436 tty_chars_in_buffer(tty) < WAKEUP_CHARS &&
2437 tty_write_room(tty) > 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002438 mask |= POLLOUT | POLLWRNORM;
2439 return mask;
2440}
2441
Jiri Slaby57c94122012-10-18 22:26:43 +02002442static unsigned long inq_canon(struct n_tty_data *ldata)
Alan Cox47afa7a2008-10-13 10:44:17 +01002443{
Peter Hurleybc5a5e32013-06-15 09:14:21 -04002444 size_t nr, head, tail;
Alan Cox47afa7a2008-10-13 10:44:17 +01002445
Peter Hurleya73d3d62013-06-15 09:14:25 -04002446 if (ldata->canon_head == ldata->read_tail)
Alan Cox47afa7a2008-10-13 10:44:17 +01002447 return 0;
Jiri Slabyba2e68a2012-10-18 22:26:41 +02002448 head = ldata->canon_head;
2449 tail = ldata->read_tail;
Peter Hurleybc5a5e32013-06-15 09:14:21 -04002450 nr = head - tail;
Alan Cox47afa7a2008-10-13 10:44:17 +01002451 /* Skip EOF-chars.. */
2452 while (head != tail) {
Peter Hurleybc5a5e32013-06-15 09:14:21 -04002453 if (test_bit(tail & (N_TTY_BUF_SIZE - 1), ldata->read_flags) &&
2454 read_buf(ldata, tail) == __DISABLED_CHAR)
Alan Cox47afa7a2008-10-13 10:44:17 +01002455 nr--;
Peter Hurleybc5a5e32013-06-15 09:14:21 -04002456 tail++;
Alan Cox47afa7a2008-10-13 10:44:17 +01002457 }
2458 return nr;
2459}
2460
2461static int n_tty_ioctl(struct tty_struct *tty, struct file *file,
2462 unsigned int cmd, unsigned long arg)
2463{
Jiri Slabyba2e68a2012-10-18 22:26:41 +02002464 struct n_tty_data *ldata = tty->disc_data;
Alan Cox47afa7a2008-10-13 10:44:17 +01002465 int retval;
2466
2467 switch (cmd) {
2468 case TIOCOUTQ:
2469 return put_user(tty_chars_in_buffer(tty), (int __user *) arg);
2470 case TIOCINQ:
Peter Hurley6d76bd22013-06-15 09:14:26 -04002471 down_write(&tty->termios_rwsem);
Alan Cox47afa7a2008-10-13 10:44:17 +01002472 if (L_ICANON(tty))
Jiri Slaby57c94122012-10-18 22:26:43 +02002473 retval = inq_canon(ldata);
Peter Hurley6d76bd22013-06-15 09:14:26 -04002474 else
2475 retval = read_cnt(ldata);
2476 up_write(&tty->termios_rwsem);
Alan Cox47afa7a2008-10-13 10:44:17 +01002477 return put_user(retval, (unsigned int __user *) arg);
2478 default:
2479 return n_tty_ioctl_helper(tty, file, cmd, arg);
2480 }
2481}
2482
Peter Hurleyf6c8dbe2013-06-15 07:28:28 -04002483static void n_tty_fasync(struct tty_struct *tty, int on)
2484{
2485 struct n_tty_data *ldata = tty->disc_data;
2486
2487 if (!waitqueue_active(&tty->read_wait)) {
2488 if (on)
2489 ldata->minimum_to_wake = 1;
2490 else if (!tty->fasync)
2491 ldata->minimum_to_wake = N_TTY_BUF_SIZE;
2492 }
2493}
2494
Alan Coxa352def2008-07-16 21:53:12 +01002495struct tty_ldisc_ops tty_ldisc_N_TTY = {
Paul Fulghume10cc1d2007-05-10 22:22:50 -07002496 .magic = TTY_LDISC_MAGIC,
2497 .name = "n_tty",
2498 .open = n_tty_open,
2499 .close = n_tty_close,
2500 .flush_buffer = n_tty_flush_buffer,
2501 .chars_in_buffer = n_tty_chars_in_buffer,
Alan Cox11a96d12008-10-13 10:46:24 +01002502 .read = n_tty_read,
2503 .write = n_tty_write,
Paul Fulghume10cc1d2007-05-10 22:22:50 -07002504 .ioctl = n_tty_ioctl,
2505 .set_termios = n_tty_set_termios,
Alan Cox11a96d12008-10-13 10:46:24 +01002506 .poll = n_tty_poll,
Paul Fulghume10cc1d2007-05-10 22:22:50 -07002507 .receive_buf = n_tty_receive_buf,
Peter Hurleyf6c8dbe2013-06-15 07:28:28 -04002508 .write_wakeup = n_tty_write_wakeup,
2509 .fasync = n_tty_fasync,
Peter Hurley24a89d12013-06-15 09:14:15 -04002510 .receive_buf2 = n_tty_receive_buf2,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002511};
Rodolfo Giometti572b9ad2010-03-10 15:23:46 -08002512
2513/**
2514 * n_tty_inherit_ops - inherit N_TTY methods
2515 * @ops: struct tty_ldisc_ops where to save N_TTY methods
2516 *
George Spelvin593fb1ae42013-02-12 02:00:43 -05002517 * Enables a 'subclass' line discipline to 'inherit' N_TTY
Rodolfo Giometti572b9ad2010-03-10 15:23:46 -08002518 * methods.
2519 */
2520
2521void n_tty_inherit_ops(struct tty_ldisc_ops *ops)
2522{
2523 *ops = tty_ldisc_N_TTY;
2524 ops->owner = NULL;
2525 ops->refcount = ops->flags = 0;
2526}
2527EXPORT_SYMBOL_GPL(n_tty_inherit_ops);