blob: 3cd31e0d4bd9545b5357cda0ffa14373d181e670 [file] [log] [blame]
Alan Coxe0495732008-10-13 10:36:58 +01001/*
2 * Tty buffer allocation management
3 */
4
5#include <linux/types.h>
6#include <linux/errno.h>
7#include <linux/tty.h>
8#include <linux/tty_driver.h>
9#include <linux/tty_flip.h>
10#include <linux/timer.h>
11#include <linux/string.h>
12#include <linux/slab.h>
13#include <linux/sched.h>
Alan Coxe0495732008-10-13 10:36:58 +010014#include <linux/wait.h>
15#include <linux/bitops.h>
16#include <linux/delay.h>
17#include <linux/module.h>
George Spelvin593fb1ae42013-02-12 02:00:43 -050018#include <linux/ratelimit.h>
Alan Coxe0495732008-10-13 10:36:58 +010019
Peter Hurley1cef50e2013-06-15 09:36:02 -040020
21#define MIN_TTYB_SIZE 256
22#define TTYB_ALIGN_MASK 255
23
Peter Hurley7bfe0b72013-06-15 09:36:08 -040024/*
25 * Byte threshold to limit memory consumption for flip buffers.
26 * The actual memory limit is > 2x this amount.
27 */
Peter Hurley4d18e6ef2013-11-22 12:09:55 -050028#define TTYB_DEFAULT_MEM_LIMIT 65536
Peter Hurley7bfe0b72013-06-15 09:36:08 -040029
Peter Hurley9114fe82013-06-15 09:36:16 -040030/*
31 * We default to dicing tty buffer allocations to this many characters
32 * in order to avoid multiple page allocations. We know the size of
33 * tty_buffer itself but it must also be taken into account that the
34 * the buffer is 256 byte aligned. See tty_buffer_find for the allocation
35 * logic this must match
36 */
37
38#define TTY_BUFFER_PAGE (((PAGE_SIZE - sizeof(struct tty_buffer)) / 2) & ~0xFF)
39
Peter Hurley1a486322015-04-13 13:24:34 -040040/*
41 * If all tty flip buffers have been processed by flush_to_ldisc() or
42 * dropped by tty_buffer_flush(), check if the linked pty has been closed.
43 * If so, wake the reader/poll to process
44 */
45static inline void check_other_closed(struct tty_struct *tty)
46{
47 unsigned long flags, old;
48
49 /* transition from TTY_OTHER_CLOSED => TTY_OTHER_DONE must be atomic */
50 for (flags = ACCESS_ONCE(tty->flags);
51 test_bit(TTY_OTHER_CLOSED, &flags);
52 ) {
53 old = flags;
54 __set_bit(TTY_OTHER_DONE, &flags);
55 flags = cmpxchg(&tty->flags, old, flags);
56 if (old == flags) {
57 wake_up_interruptible(&tty->read_wait);
58 break;
59 }
60 }
61}
Peter Hurley7bfe0b72013-06-15 09:36:08 -040062
63/**
Peter Hurleya7c8d582013-06-15 09:36:15 -040064 * tty_buffer_lock_exclusive - gain exclusive access to buffer
65 * tty_buffer_unlock_exclusive - release exclusive access
66 *
67 * @port - tty_port owning the flip buffer
68 *
69 * Guarantees safe use of the line discipline's receive_buf() method by
70 * excluding the buffer work and any pending flush from using the flip
71 * buffer. Data can continue to be added concurrently to the flip buffer
72 * from the driver side.
73 *
74 * On release, the buffer work is restarted if there is data in the
75 * flip buffer
76 */
77
78void tty_buffer_lock_exclusive(struct tty_port *port)
79{
80 struct tty_bufhead *buf = &port->buf;
81
82 atomic_inc(&buf->priority);
83 mutex_lock(&buf->lock);
84}
Ben Hutchings28a821c2014-05-19 01:03:06 +010085EXPORT_SYMBOL_GPL(tty_buffer_lock_exclusive);
Peter Hurleya7c8d582013-06-15 09:36:15 -040086
87void tty_buffer_unlock_exclusive(struct tty_port *port)
88{
89 struct tty_bufhead *buf = &port->buf;
90 int restart;
91
92 restart = buf->head->commit != buf->head->read;
93
94 atomic_dec(&buf->priority);
95 mutex_unlock(&buf->lock);
96 if (restart)
97 queue_work(system_unbound_wq, &buf->work);
98}
Ben Hutchings28a821c2014-05-19 01:03:06 +010099EXPORT_SYMBOL_GPL(tty_buffer_unlock_exclusive);
Peter Hurleya7c8d582013-06-15 09:36:15 -0400100
101/**
Peter Hurley7bfe0b72013-06-15 09:36:08 -0400102 * tty_buffer_space_avail - return unused buffer space
103 * @port - tty_port owning the flip buffer
104 *
105 * Returns the # of bytes which can be written by the driver without
106 * reaching the buffer limit.
107 *
108 * Note: this does not guarantee that memory is available to write
109 * the returned # of bytes (use tty_prepare_flip_string_xxx() to
110 * pre-allocate if memory guarantee is required).
111 */
112
113int tty_buffer_space_avail(struct tty_port *port)
114{
Peter Hurley5dda4ca2013-11-22 12:09:56 -0500115 int space = port->buf.mem_limit - atomic_read(&port->buf.mem_used);
Peter Hurley7bfe0b72013-06-15 09:36:08 -0400116 return max(space, 0);
117}
Peter Hurleyc4a8dab2013-11-22 13:06:08 -0500118EXPORT_SYMBOL_GPL(tty_buffer_space_avail);
Peter Hurley7bfe0b72013-06-15 09:36:08 -0400119
Peter Hurley9dd51392013-06-15 09:36:03 -0400120static void tty_buffer_reset(struct tty_buffer *p, size_t size)
121{
122 p->used = 0;
123 p->size = size;
124 p->next = NULL;
125 p->commit = 0;
126 p->read = 0;
Peter Hurleyacc0f672013-12-09 09:23:52 -0500127 p->flags = 0;
Peter Hurley9dd51392013-06-15 09:36:03 -0400128}
129
Alan Coxe0495732008-10-13 10:36:58 +0100130/**
131 * tty_buffer_free_all - free buffers used by a tty
132 * @tty: tty to free from
133 *
134 * Remove all the buffers pending on a tty whether queued with data
135 * or in the free ring. Must be called when the tty is no longer in use
Alan Coxe0495732008-10-13 10:36:58 +0100136 */
137
Jiri Slabyecbbfd42012-10-18 22:26:47 +0200138void tty_buffer_free_all(struct tty_port *port)
Alan Coxe0495732008-10-13 10:36:58 +0100139{
Jiri Slabyecbbfd42012-10-18 22:26:47 +0200140 struct tty_bufhead *buf = &port->buf;
Peter Hurley809850b2013-06-15 09:36:06 -0400141 struct tty_buffer *p, *next;
142 struct llist_node *llist;
Jiri Slaby5cff39c2012-10-18 22:26:45 +0200143
Peter Hurley2cf7b672013-06-15 09:36:05 -0400144 while ((p = buf->head) != NULL) {
145 buf->head = p->next;
Peter Hurley7391ee12013-06-15 09:36:07 -0400146 if (p->size > 0)
147 kfree(p);
Alan Coxe0495732008-10-13 10:36:58 +0100148 }
Peter Hurley809850b2013-06-15 09:36:06 -0400149 llist = llist_del_all(&buf->free);
150 llist_for_each_entry_safe(p, next, llist, free)
Peter Hurley2cf7b672013-06-15 09:36:05 -0400151 kfree(p);
Peter Hurley809850b2013-06-15 09:36:06 -0400152
Peter Hurley7391ee12013-06-15 09:36:07 -0400153 tty_buffer_reset(&buf->sentinel, 0);
154 buf->head = &buf->sentinel;
155 buf->tail = &buf->sentinel;
Peter Hurley7bfe0b72013-06-15 09:36:08 -0400156
Peter Hurley5dda4ca2013-11-22 12:09:56 -0500157 atomic_set(&buf->mem_used, 0);
Alan Coxe0495732008-10-13 10:36:58 +0100158}
159
160/**
161 * tty_buffer_alloc - allocate a tty buffer
162 * @tty: tty device
163 * @size: desired size (characters)
164 *
165 * Allocate a new tty buffer to hold the desired number of characters.
Peter Hurley11b9faa2013-06-15 09:36:04 -0400166 * We round our buffers off in 256 character chunks to get better
167 * allocation behaviour.
Alan Coxe0495732008-10-13 10:36:58 +0100168 * Return NULL if out of memory or the allocation would exceed the
169 * per device queue
Alan Coxe0495732008-10-13 10:36:58 +0100170 */
171
Jiri Slabyecbbfd42012-10-18 22:26:47 +0200172static struct tty_buffer *tty_buffer_alloc(struct tty_port *port, size_t size)
Alan Coxe0495732008-10-13 10:36:58 +0100173{
Peter Hurley809850b2013-06-15 09:36:06 -0400174 struct llist_node *free;
Alan Coxe0495732008-10-13 10:36:58 +0100175 struct tty_buffer *p;
176
Peter Hurley11b9faa2013-06-15 09:36:04 -0400177 /* Round the buffer size out */
178 size = __ALIGN_MASK(size, TTYB_ALIGN_MASK);
179
180 if (size <= MIN_TTYB_SIZE) {
Peter Hurley809850b2013-06-15 09:36:06 -0400181 free = llist_del_first(&port->buf.free);
182 if (free) {
183 p = llist_entry(free, struct tty_buffer, free);
Peter Hurley11b9faa2013-06-15 09:36:04 -0400184 goto found;
185 }
186 }
187
188 /* Should possibly check if this fails for the largest buffer we
189 have queued and recycle that ? */
Peter Hurley5dda4ca2013-11-22 12:09:56 -0500190 if (atomic_read(&port->buf.mem_used) > port->buf.mem_limit)
Alan Coxe0495732008-10-13 10:36:58 +0100191 return NULL;
192 p = kmalloc(sizeof(struct tty_buffer) + 2 * size, GFP_ATOMIC);
193 if (p == NULL)
194 return NULL;
Peter Hurley9dd51392013-06-15 09:36:03 -0400195
Peter Hurley11b9faa2013-06-15 09:36:04 -0400196found:
Peter Hurley9dd51392013-06-15 09:36:03 -0400197 tty_buffer_reset(p, size);
Peter Hurley5dda4ca2013-11-22 12:09:56 -0500198 atomic_add(size, &port->buf.mem_used);
Alan Coxe0495732008-10-13 10:36:58 +0100199 return p;
200}
201
202/**
203 * tty_buffer_free - free a tty buffer
204 * @tty: tty owning the buffer
205 * @b: the buffer to free
206 *
207 * Free a tty buffer, or add it to the free list according to our
208 * internal strategy
Alan Coxe0495732008-10-13 10:36:58 +0100209 */
210
Jiri Slabyecbbfd42012-10-18 22:26:47 +0200211static void tty_buffer_free(struct tty_port *port, struct tty_buffer *b)
Alan Coxe0495732008-10-13 10:36:58 +0100212{
Jiri Slabyecbbfd42012-10-18 22:26:47 +0200213 struct tty_bufhead *buf = &port->buf;
Jiri Slaby5cff39c2012-10-18 22:26:45 +0200214
Alan Coxe0495732008-10-13 10:36:58 +0100215 /* Dumb strategy for now - should keep some stats */
Peter Hurley5dda4ca2013-11-22 12:09:56 -0500216 WARN_ON(atomic_sub_return(b->size, &buf->mem_used) < 0);
Alan Coxe0495732008-10-13 10:36:58 +0100217
Peter Hurley1cef50e2013-06-15 09:36:02 -0400218 if (b->size > MIN_TTYB_SIZE)
Alan Coxe0495732008-10-13 10:36:58 +0100219 kfree(b);
Peter Hurley7391ee12013-06-15 09:36:07 -0400220 else if (b->size > 0)
Peter Hurley809850b2013-06-15 09:36:06 -0400221 llist_add(&b->free, &buf->free);
Alan Coxe0495732008-10-13 10:36:58 +0100222}
223
224/**
Alan Coxe0495732008-10-13 10:36:58 +0100225 * tty_buffer_flush - flush full tty buffers
226 * @tty: tty to flush
Peter Hurley86c80a82014-11-05 12:13:09 -0500227 * @ld: optional ldisc ptr (must be referenced)
Alan Coxe0495732008-10-13 10:36:58 +0100228 *
Peter Hurley86c80a82014-11-05 12:13:09 -0500229 * flush all the buffers containing receive data. If ld != NULL,
230 * flush the ldisc input buffer.
Alan Coxe0495732008-10-13 10:36:58 +0100231 *
Peter Hurleya7c8d582013-06-15 09:36:15 -0400232 * Locking: takes buffer lock to ensure single-threaded flip buffer
Peter Hurleye9975fd2013-06-15 09:36:10 -0400233 * 'consumer'
Alan Coxe0495732008-10-13 10:36:58 +0100234 */
235
Peter Hurley86c80a82014-11-05 12:13:09 -0500236void tty_buffer_flush(struct tty_struct *tty, struct tty_ldisc *ld)
Alan Coxe0495732008-10-13 10:36:58 +0100237{
Jiri Slaby2fc20662012-10-18 22:26:44 +0200238 struct tty_port *port = tty->port;
Jiri Slabyecbbfd42012-10-18 22:26:47 +0200239 struct tty_bufhead *buf = &port->buf;
Peter Hurley47aa6582013-06-15 09:36:14 -0400240 struct tty_buffer *next;
Jiri Slaby5cff39c2012-10-18 22:26:45 +0200241
Peter Hurleya7c8d582013-06-15 09:36:15 -0400242 atomic_inc(&buf->priority);
Peter Hurleye9975fd2013-06-15 09:36:10 -0400243
Peter Hurleya7c8d582013-06-15 09:36:15 -0400244 mutex_lock(&buf->lock);
Dmitry Vyukov9e6b7cd2015-09-17 17:17:09 +0200245 /* paired w/ release in __tty_buffer_request_room; ensures there are
246 * no pending memory accesses to the freed buffer
247 */
248 while ((next = smp_load_acquire(&buf->head->next)) != NULL) {
Peter Hurley47aa6582013-06-15 09:36:14 -0400249 tty_buffer_free(port, buf->head);
250 buf->head = next;
251 }
252 buf->head->read = buf->head->commit;
Peter Hurley86c80a82014-11-05 12:13:09 -0500253
254 if (ld && ld->ops->flush_buffer)
255 ld->ops->flush_buffer(tty);
256
Peter Hurley1a486322015-04-13 13:24:34 -0400257 check_other_closed(tty);
258
Peter Hurleya7c8d582013-06-15 09:36:15 -0400259 atomic_dec(&buf->priority);
260 mutex_unlock(&buf->lock);
Alan Coxe0495732008-10-13 10:36:58 +0100261}
262
263/**
Ilya Zykov64325a32013-01-19 18:16:20 +0400264 * tty_buffer_request_room - grow tty buffer if needed
Alan Coxe0495732008-10-13 10:36:58 +0100265 * @tty: tty structure
266 * @size: size desired
Peter Hurleyacc0f672013-12-09 09:23:52 -0500267 * @flags: buffer flags if new buffer allocated (default = 0)
Alan Coxe0495732008-10-13 10:36:58 +0100268 *
269 * Make at least size bytes of linear space available for the tty
270 * buffer. If we fail return the size we managed to find.
Peter Hurleyacc0f672013-12-09 09:23:52 -0500271 *
272 * Will change over to a new buffer if the current buffer is encoded as
273 * TTY_NORMAL (so has no flags buffer) and the new buffer requires
274 * a flags buffer.
Alan Coxe0495732008-10-13 10:36:58 +0100275 */
Peter Hurleyacc0f672013-12-09 09:23:52 -0500276static int __tty_buffer_request_room(struct tty_port *port, size_t size,
277 int flags)
Alan Coxe0495732008-10-13 10:36:58 +0100278{
Jiri Slabyecbbfd42012-10-18 22:26:47 +0200279 struct tty_bufhead *buf = &port->buf;
Alan Coxe0495732008-10-13 10:36:58 +0100280 struct tty_buffer *b, *n;
Peter Hurleyacc0f672013-12-09 09:23:52 -0500281 int left, change;
Peter Hurleye8437d72013-06-15 09:36:09 -0400282
Jiri Slaby5cff39c2012-10-18 22:26:45 +0200283 b = buf->tail;
Peter Hurleyacc0f672013-12-09 09:23:52 -0500284 if (b->flags & TTYB_NORMAL)
285 left = 2 * b->size - b->used;
286 else
287 left = b->size - b->used;
Alan Coxe0495732008-10-13 10:36:58 +0100288
Peter Hurleyacc0f672013-12-09 09:23:52 -0500289 change = (b->flags & TTYB_NORMAL) && (~flags & TTYB_NORMAL);
290 if (change || left < size) {
Alan Coxe0495732008-10-13 10:36:58 +0100291 /* This is the slow path - looking for new buffers to use */
Greg Kroah-Hartmane16cb0a2015-04-30 11:22:17 +0200292 n = tty_buffer_alloc(port, size);
293 if (n != NULL) {
Peter Hurleyacc0f672013-12-09 09:23:52 -0500294 n->flags = flags;
Jiri Slaby5cff39c2012-10-18 22:26:45 +0200295 buf->tail = n;
Dmitry Vyukovfacd8852015-09-17 17:17:10 +0200296 /* paired w/ acquire in flush_to_ldisc(); ensures
297 * flush_to_ldisc() sees buffer data.
298 */
299 smp_store_release(&b->commit, b->used);
Peter Hurley069f38b2015-07-12 20:50:49 -0400300 /* paired w/ acquire in flush_to_ldisc(); ensures the
Peter Hurley62a0d8d2014-05-02 10:56:12 -0400301 * latest commit value can be read before the head is
302 * advanced to the next buffer
303 */
Peter Hurley069f38b2015-07-12 20:50:49 -0400304 smp_store_release(&b->next, n);
Peter Hurleyacc0f672013-12-09 09:23:52 -0500305 } else if (change)
306 size = 0;
307 else
Alan Coxe0495732008-10-13 10:36:58 +0100308 size = left;
309 }
Alan Coxe0495732008-10-13 10:36:58 +0100310 return size;
311}
Peter Hurleyacc0f672013-12-09 09:23:52 -0500312
313int tty_buffer_request_room(struct tty_port *port, size_t size)
314{
315 return __tty_buffer_request_room(port, size, 0);
316}
Alan Coxe0495732008-10-13 10:36:58 +0100317EXPORT_SYMBOL_GPL(tty_buffer_request_room);
318
319/**
Alan Cox2832fc12010-02-18 16:43:54 +0000320 * tty_insert_flip_string_fixed_flag - Add characters to the tty buffer
Jiri Slaby2f693352013-01-03 15:53:02 +0100321 * @port: tty port
Alan Coxe0495732008-10-13 10:36:58 +0100322 * @chars: characters
Alan Cox2832fc12010-02-18 16:43:54 +0000323 * @flag: flag value for each character
Alan Coxe0495732008-10-13 10:36:58 +0100324 * @size: size
325 *
326 * Queue a series of bytes to the tty buffering. All the characters
Johan Hovoldccc5ca82010-05-07 19:58:32 +0200327 * passed are marked with the supplied flag. Returns the number added.
Alan Coxe0495732008-10-13 10:36:58 +0100328 */
329
Jiri Slaby2f693352013-01-03 15:53:02 +0100330int tty_insert_flip_string_fixed_flag(struct tty_port *port,
Alan Cox2832fc12010-02-18 16:43:54 +0000331 const unsigned char *chars, char flag, size_t size)
Alan Coxe0495732008-10-13 10:36:58 +0100332{
333 int copied = 0;
334 do {
Fang Wenqid4bee0a2010-03-09 18:54:28 +0800335 int goal = min_t(size_t, size - copied, TTY_BUFFER_PAGE);
Peter Hurleyacc0f672013-12-09 09:23:52 -0500336 int flags = (flag == TTY_NORMAL) ? TTYB_NORMAL : 0;
337 int space = __tty_buffer_request_room(port, goal, flags);
Ilya Zykov64325a32013-01-19 18:16:20 +0400338 struct tty_buffer *tb = port->buf.tail;
Peter Hurley7391ee12013-06-15 09:36:07 -0400339 if (unlikely(space == 0))
Alan Coxe0495732008-10-13 10:36:58 +0100340 break;
Peter Hurley1fc359f2013-06-15 09:36:01 -0400341 memcpy(char_buf_ptr(tb, tb->used), chars, space);
Peter Hurleyacc0f672013-12-09 09:23:52 -0500342 if (~tb->flags & TTYB_NORMAL)
343 memset(flag_buf_ptr(tb, tb->used), flag, space);
Alan Coxe0495732008-10-13 10:36:58 +0100344 tb->used += space;
345 copied += space;
346 chars += space;
347 /* There is a small chance that we need to split the data over
348 several buffers. If this is the case we must loop */
349 } while (unlikely(size > copied));
350 return copied;
351}
Alan Cox2832fc12010-02-18 16:43:54 +0000352EXPORT_SYMBOL(tty_insert_flip_string_fixed_flag);
Alan Coxe0495732008-10-13 10:36:58 +0100353
354/**
355 * tty_insert_flip_string_flags - Add characters to the tty buffer
Jiri Slaby2f693352013-01-03 15:53:02 +0100356 * @port: tty port
Alan Coxe0495732008-10-13 10:36:58 +0100357 * @chars: characters
358 * @flags: flag bytes
359 * @size: size
360 *
361 * Queue a series of bytes to the tty buffering. For each character
362 * the flags array indicates the status of the character. Returns the
363 * number added.
Alan Coxe0495732008-10-13 10:36:58 +0100364 */
365
Jiri Slaby2f693352013-01-03 15:53:02 +0100366int tty_insert_flip_string_flags(struct tty_port *port,
Alan Coxe0495732008-10-13 10:36:58 +0100367 const unsigned char *chars, const char *flags, size_t size)
368{
369 int copied = 0;
370 do {
Fang Wenqid4bee0a2010-03-09 18:54:28 +0800371 int goal = min_t(size_t, size - copied, TTY_BUFFER_PAGE);
Ilya Zykov64325a32013-01-19 18:16:20 +0400372 int space = tty_buffer_request_room(port, goal);
373 struct tty_buffer *tb = port->buf.tail;
Peter Hurley7391ee12013-06-15 09:36:07 -0400374 if (unlikely(space == 0))
Alan Coxe0495732008-10-13 10:36:58 +0100375 break;
Peter Hurley1fc359f2013-06-15 09:36:01 -0400376 memcpy(char_buf_ptr(tb, tb->used), chars, space);
377 memcpy(flag_buf_ptr(tb, tb->used), flags, space);
Alan Coxe0495732008-10-13 10:36:58 +0100378 tb->used += space;
379 copied += space;
380 chars += space;
381 flags += space;
382 /* There is a small chance that we need to split the data over
383 several buffers. If this is the case we must loop */
384 } while (unlikely(size > copied));
385 return copied;
386}
387EXPORT_SYMBOL(tty_insert_flip_string_flags);
388
389/**
390 * tty_schedule_flip - push characters to ldisc
Jiri Slaby6732c8b2013-01-03 15:53:07 +0100391 * @port: tty port to push from
Alan Coxe0495732008-10-13 10:36:58 +0100392 *
393 * Takes any pending buffers and transfers their ownership to the
394 * ldisc side of the queue. It then schedules those characters for
395 * processing by the line discipline.
Alan Coxe0495732008-10-13 10:36:58 +0100396 */
397
Jiri Slaby6732c8b2013-01-03 15:53:07 +0100398void tty_schedule_flip(struct tty_port *port)
Alan Coxe0495732008-10-13 10:36:58 +0100399{
Jiri Slaby6732c8b2013-01-03 15:53:07 +0100400 struct tty_bufhead *buf = &port->buf;
Jiri Slaby5cff39c2012-10-18 22:26:45 +0200401
Dmitry Vyukovfacd8852015-09-17 17:17:10 +0200402 /* paired w/ acquire in flush_to_ldisc(); ensures
403 * flush_to_ldisc() sees buffer data.
404 */
405 smp_store_release(&buf->tail->commit, buf->tail->used);
Peter Hurleye052c6d2015-10-17 16:36:24 -0400406 queue_work(system_unbound_wq, &buf->work);
Alan Coxe0495732008-10-13 10:36:58 +0100407}
408EXPORT_SYMBOL(tty_schedule_flip);
409
410/**
411 * tty_prepare_flip_string - make room for characters
Jiri Slaby2f693352013-01-03 15:53:02 +0100412 * @port: tty port
Alan Coxe0495732008-10-13 10:36:58 +0100413 * @chars: return pointer for character write area
414 * @size: desired size
415 *
416 * Prepare a block of space in the buffer for data. Returns the length
417 * available and buffer pointer to the space which is now allocated and
418 * accounted for as ready for normal characters. This is used for drivers
419 * that need their own block copy routines into the buffer. There is no
420 * guarantee the buffer is a DMA target!
Alan Coxe0495732008-10-13 10:36:58 +0100421 */
422
Jiri Slaby2f693352013-01-03 15:53:02 +0100423int tty_prepare_flip_string(struct tty_port *port, unsigned char **chars,
Jiri Slabyecbbfd42012-10-18 22:26:47 +0200424 size_t size)
Alan Coxe0495732008-10-13 10:36:58 +0100425{
Peter Hurleyacc0f672013-12-09 09:23:52 -0500426 int space = __tty_buffer_request_room(port, size, TTYB_NORMAL);
Alan Coxe0495732008-10-13 10:36:58 +0100427 if (likely(space)) {
Ilya Zykov64325a32013-01-19 18:16:20 +0400428 struct tty_buffer *tb = port->buf.tail;
Peter Hurley1fc359f2013-06-15 09:36:01 -0400429 *chars = char_buf_ptr(tb, tb->used);
Peter Hurleyacc0f672013-12-09 09:23:52 -0500430 if (~tb->flags & TTYB_NORMAL)
431 memset(flag_buf_ptr(tb, tb->used), TTY_NORMAL, space);
Alan Coxe0495732008-10-13 10:36:58 +0100432 tb->used += space;
433 }
434 return space;
435}
436EXPORT_SYMBOL_GPL(tty_prepare_flip_string);
437
Alan Coxe0495732008-10-13 10:36:58 +0100438
Peter Hurleyda261e72013-06-15 09:14:14 -0400439static int
440receive_buf(struct tty_struct *tty, struct tty_buffer *head, int count)
441{
442 struct tty_ldisc *disc = tty->ldisc;
Peter Hurley1fc359f2013-06-15 09:36:01 -0400443 unsigned char *p = char_buf_ptr(head, head->read);
Peter Hurleyacc0f672013-12-09 09:23:52 -0500444 char *f = NULL;
445
446 if (~head->flags & TTYB_NORMAL)
447 f = flag_buf_ptr(head, head->read);
Peter Hurleyda261e72013-06-15 09:14:14 -0400448
Peter Hurley24a89d12013-06-15 09:14:15 -0400449 if (disc->ops->receive_buf2)
450 count = disc->ops->receive_buf2(tty, p, f, count);
451 else {
452 count = min_t(int, count, tty->receive_room);
Peter Hurley9ce119f2015-11-27 14:25:08 -0500453 if (count && disc->ops->receive_buf)
Peter Hurley24a89d12013-06-15 09:14:15 -0400454 disc->ops->receive_buf(tty, p, f, count);
455 }
Peter Hurleyda261e72013-06-15 09:14:14 -0400456 return count;
457}
Alan Coxe0495732008-10-13 10:36:58 +0100458
459/**
460 * flush_to_ldisc
461 * @work: tty structure passed from work queue.
462 *
463 * This routine is called out of the software interrupt to flush data
464 * from the buffer chain to the line discipline.
465 *
Peter Hurleye9975fd2013-06-15 09:36:10 -0400466 * The receive_buf method is single threaded for each tty instance.
467 *
Peter Hurleya7c8d582013-06-15 09:36:15 -0400468 * Locking: takes buffer lock to ensure single-threaded flip buffer
Peter Hurleye9975fd2013-06-15 09:36:10 -0400469 * 'consumer'
Alan Coxe0495732008-10-13 10:36:58 +0100470 */
471
472static void flush_to_ldisc(struct work_struct *work)
473{
Jiri Slabyecbbfd42012-10-18 22:26:47 +0200474 struct tty_port *port = container_of(work, struct tty_port, buf.work);
475 struct tty_bufhead *buf = &port->buf;
476 struct tty_struct *tty;
Alan Coxe0495732008-10-13 10:36:58 +0100477 struct tty_ldisc *disc;
Alan Coxe0495732008-10-13 10:36:58 +0100478
Dmitry Vyukov70982962015-09-17 17:17:08 +0200479 tty = READ_ONCE(port->itty);
Jiri Slaby34dcfb82013-02-27 22:30:24 +0100480 if (tty == NULL)
Jiri Slabyecbbfd42012-10-18 22:26:47 +0200481 return;
482
Alan Coxe0495732008-10-13 10:36:58 +0100483 disc = tty_ldisc_ref(tty);
Peter Hurley36697522013-06-15 07:04:48 -0400484 if (disc == NULL)
Alan Coxe0495732008-10-13 10:36:58 +0100485 return;
486
Peter Hurleya7c8d582013-06-15 09:36:15 -0400487 mutex_lock(&buf->lock);
Linus Torvalds45242002009-10-14 08:59:49 -0700488
Peter Hurleyd7a68be2013-06-15 09:36:11 -0400489 while (1) {
490 struct tty_buffer *head = buf->head;
Peter Hurley62a0d8d2014-05-02 10:56:12 -0400491 struct tty_buffer *next;
Peter Hurleyd7a68be2013-06-15 09:36:11 -0400492 int count;
Linus Torvalds45242002009-10-14 08:59:49 -0700493
Peter Hurleya7c8d582013-06-15 09:36:15 -0400494 /* Ldisc or user is trying to gain exclusive access */
495 if (atomic_read(&buf->priority))
Peter Hurleyd7a68be2013-06-15 09:36:11 -0400496 break;
Peter Hurleye9975fd2013-06-15 09:36:10 -0400497
Peter Hurley069f38b2015-07-12 20:50:49 -0400498 /* paired w/ release in __tty_buffer_request_room();
Peter Hurley62a0d8d2014-05-02 10:56:12 -0400499 * ensures commit value read is not stale if the head
500 * is advancing to the next buffer
501 */
Peter Hurley069f38b2015-07-12 20:50:49 -0400502 next = smp_load_acquire(&head->next);
Dmitry Vyukovfacd8852015-09-17 17:17:10 +0200503 /* paired w/ release in __tty_buffer_request_room() or in
504 * tty_buffer_flush(); ensures we see the committed buffer data
505 */
506 count = smp_load_acquire(&head->commit) - head->read;
Peter Hurleyd7a68be2013-06-15 09:36:11 -0400507 if (!count) {
Peter Hurley1a486322015-04-13 13:24:34 -0400508 if (next == NULL) {
509 check_other_closed(tty);
Peter Hurley39f610e2013-03-20 13:20:43 -0400510 break;
Peter Hurley1a486322015-04-13 13:24:34 -0400511 }
Peter Hurley62a0d8d2014-05-02 10:56:12 -0400512 buf->head = next;
Peter Hurleyd7a68be2013-06-15 09:36:11 -0400513 tty_buffer_free(port, head);
514 continue;
Alan Coxe0495732008-10-13 10:36:58 +0100515 }
Peter Hurleyd7a68be2013-06-15 09:36:11 -0400516
517 count = receive_buf(tty, head, count);
518 if (!count)
519 break;
Peter Hurleyaf5554f2015-07-12 20:50:50 -0400520 head->read += count;
Alan Coxe0495732008-10-13 10:36:58 +0100521 }
Linus Torvalds45242002009-10-14 08:59:49 -0700522
Peter Hurleya7c8d582013-06-15 09:36:15 -0400523 mutex_unlock(&buf->lock);
Alan Coxe0495732008-10-13 10:36:58 +0100524
525 tty_ldisc_deref(disc);
526}
527
528/**
Alan Coxe0495732008-10-13 10:36:58 +0100529 * tty_flip_buffer_push - terminal
Jiri Slaby2e124b42013-01-03 15:53:06 +0100530 * @port: tty port to push
Alan Coxe0495732008-10-13 10:36:58 +0100531 *
Peter Hurleya9c3f682014-02-22 07:31:21 -0500532 * Queue a push of the terminal flip buffers to the line discipline.
533 * Can be called from IRQ/atomic context.
Alan Coxe0495732008-10-13 10:36:58 +0100534 *
535 * In the event of the queue being busy for flipping the work will be
536 * held off and retried later.
Alan Coxe0495732008-10-13 10:36:58 +0100537 */
538
Jiri Slaby2e124b42013-01-03 15:53:06 +0100539void tty_flip_buffer_push(struct tty_port *port)
Alan Coxe0495732008-10-13 10:36:58 +0100540{
Peter Hurleya9c3f682014-02-22 07:31:21 -0500541 tty_schedule_flip(port);
Alan Coxe0495732008-10-13 10:36:58 +0100542}
543EXPORT_SYMBOL(tty_flip_buffer_push);
544
545/**
546 * tty_buffer_init - prepare a tty buffer structure
547 * @tty: tty to initialise
548 *
549 * Set up the initial state of the buffer management for a tty device.
550 * Must be called before the other tty buffer functions are used.
Alan Coxe0495732008-10-13 10:36:58 +0100551 */
552
Jiri Slabyecbbfd42012-10-18 22:26:47 +0200553void tty_buffer_init(struct tty_port *port)
Alan Coxe0495732008-10-13 10:36:58 +0100554{
Jiri Slabyecbbfd42012-10-18 22:26:47 +0200555 struct tty_bufhead *buf = &port->buf;
Jiri Slaby5cff39c2012-10-18 22:26:45 +0200556
Peter Hurleya7c8d582013-06-15 09:36:15 -0400557 mutex_init(&buf->lock);
Peter Hurley7391ee12013-06-15 09:36:07 -0400558 tty_buffer_reset(&buf->sentinel, 0);
559 buf->head = &buf->sentinel;
560 buf->tail = &buf->sentinel;
Peter Hurley809850b2013-06-15 09:36:06 -0400561 init_llist_head(&buf->free);
Peter Hurley5dda4ca2013-11-22 12:09:56 -0500562 atomic_set(&buf->mem_used, 0);
Peter Hurleya7c8d582013-06-15 09:36:15 -0400563 atomic_set(&buf->priority, 0);
Jiri Slaby5cff39c2012-10-18 22:26:45 +0200564 INIT_WORK(&buf->work, flush_to_ldisc);
Peter Hurley4d18e6ef2013-11-22 12:09:55 -0500565 buf->mem_limit = TTYB_DEFAULT_MEM_LIMIT;
Alan Coxe0495732008-10-13 10:36:58 +0100566}
Peter Hurley4d18e6ef2013-11-22 12:09:55 -0500567
568/**
569 * tty_buffer_set_limit - change the tty buffer memory limit
570 * @port: tty port to change
571 *
572 * Change the tty buffer memory limit.
573 * Must be called before the other tty buffer functions are used.
574 */
575
576int tty_buffer_set_limit(struct tty_port *port, int limit)
577{
578 if (limit < MIN_TTYB_SIZE)
579 return -EINVAL;
580 port->buf.mem_limit = limit;
581 return 0;
582}
583EXPORT_SYMBOL_GPL(tty_buffer_set_limit);
Peter Hurley1d1d14d2015-01-17 15:42:05 -0500584
585/* slave ptys can claim nested buffer lock when handling BRK and INTR */
586void tty_buffer_set_lock_subclass(struct tty_port *port)
587{
588 lockdep_set_subclass(&port->buf.lock, TTY_LOCK_SLAVE);
589}
Peter Hurleye1760582015-10-17 16:36:23 -0400590
591bool tty_buffer_restart_work(struct tty_port *port)
592{
593 return queue_work(system_unbound_wq, &port->buf.work);
594}
595
596bool tty_buffer_cancel_work(struct tty_port *port)
597{
598 return cancel_work_sync(&port->buf.work);
599}