Branch data Line data Source code
1 : : /*
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>
14 : : #include <linux/wait.h>
15 : : #include <linux/bitops.h>
16 : : #include <linux/delay.h>
17 : : #include <linux/module.h>
18 : : #include <linux/ratelimit.h>
19 : :
20 : :
21 : : #define MIN_TTYB_SIZE 256
22 : : #define TTYB_ALIGN_MASK 255
23 : :
24 : : /*
25 : : * Byte threshold to limit memory consumption for flip buffers.
26 : : * The actual memory limit is > 2x this amount.
27 : : */
28 : : #define TTYB_DEFAULT_MEM_LIMIT 65536
29 : :
30 : : /*
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 : :
40 : :
41 : : /**
42 : : * tty_buffer_lock_exclusive - gain exclusive access to buffer
43 : : * tty_buffer_unlock_exclusive - release exclusive access
44 : : *
45 : : * @port - tty_port owning the flip buffer
46 : : *
47 : : * Guarantees safe use of the line discipline's receive_buf() method by
48 : : * excluding the buffer work and any pending flush from using the flip
49 : : * buffer. Data can continue to be added concurrently to the flip buffer
50 : : * from the driver side.
51 : : *
52 : : * On release, the buffer work is restarted if there is data in the
53 : : * flip buffer
54 : : */
55 : :
56 : 0 : void tty_buffer_lock_exclusive(struct tty_port *port)
57 : : {
58 : : struct tty_bufhead *buf = &port->buf;
59 : :
60 : 0 : atomic_inc(&buf->priority);
61 : 0 : mutex_lock(&buf->lock);
62 : 0 : }
63 : :
64 : 0 : void tty_buffer_unlock_exclusive(struct tty_port *port)
65 : : {
66 : : struct tty_bufhead *buf = &port->buf;
67 : : int restart;
68 : :
69 : 0 : restart = buf->head->commit != buf->head->read;
70 : :
71 : 0 : atomic_dec(&buf->priority);
72 : 0 : mutex_unlock(&buf->lock);
73 [ # # ]: 0 : if (restart)
74 : 0 : queue_work(system_unbound_wq, &buf->work);
75 : 0 : }
76 : :
77 : : /**
78 : : * tty_buffer_space_avail - return unused buffer space
79 : : * @port - tty_port owning the flip buffer
80 : : *
81 : : * Returns the # of bytes which can be written by the driver without
82 : : * reaching the buffer limit.
83 : : *
84 : : * Note: this does not guarantee that memory is available to write
85 : : * the returned # of bytes (use tty_prepare_flip_string_xxx() to
86 : : * pre-allocate if memory guarantee is required).
87 : : */
88 : :
89 : 0 : int tty_buffer_space_avail(struct tty_port *port)
90 : : {
91 : 182184 : int space = port->buf.mem_limit - atomic_read(&port->buf.mem_used);
92 : 182184 : return max(space, 0);
93 : : }
94 : : EXPORT_SYMBOL_GPL(tty_buffer_space_avail);
95 : :
96 : : static void tty_buffer_reset(struct tty_buffer *p, size_t size)
97 : : {
98 : 432 : p->used = 0;
99 : 432 : p->size = size;
100 : 432 : p->next = NULL;
101 : 432 : p->commit = 0;
102 : 432 : p->read = 0;
103 : 432 : p->flags = 0;
104 : : }
105 : :
106 : : /**
107 : : * tty_buffer_free_all - free buffers used by a tty
108 : : * @tty: tty to free from
109 : : *
110 : : * Remove all the buffers pending on a tty whether queued with data
111 : : * or in the free ring. Must be called when the tty is no longer in use
112 : : */
113 : :
114 : 0 : void tty_buffer_free_all(struct tty_port *port)
115 : : {
116 : : struct tty_bufhead *buf = &port->buf;
117 : : struct tty_buffer *p, *next;
118 : : struct llist_node *llist;
119 : :
120 [ + + ]: 564 : while ((p = buf->head) != NULL) {
121 : 188 : buf->head = p->next;
122 [ + + ]: 188 : if (p->size > 0)
123 : 191 : kfree(p);
124 : : }
125 : : llist = llist_del_all(&buf->free);
126 [ - + ]: 188 : llist_for_each_entry_safe(p, next, llist, free)
127 : 0 : kfree(p);
128 : :
129 : : tty_buffer_reset(&buf->sentinel, 0);
130 : 188 : buf->head = &buf->sentinel;
131 : 188 : buf->tail = &buf->sentinel;
132 : :
133 : 188 : atomic_set(&buf->mem_used, 0);
134 : 188 : }
135 : :
136 : : /**
137 : : * tty_buffer_alloc - allocate a tty buffer
138 : : * @tty: tty device
139 : : * @size: desired size (characters)
140 : : *
141 : : * Allocate a new tty buffer to hold the desired number of characters.
142 : : * We round our buffers off in 256 character chunks to get better
143 : : * allocation behaviour.
144 : : * Return NULL if out of memory or the allocation would exceed the
145 : : * per device queue
146 : : */
147 : :
148 : 0 : static struct tty_buffer *tty_buffer_alloc(struct tty_port *port, size_t size)
149 : : {
150 : : struct llist_node *free;
151 : : struct tty_buffer *p;
152 : :
153 : : /* Round the buffer size out */
154 : 11251 : size = __ALIGN_MASK(size, TTYB_ALIGN_MASK);
155 : :
156 [ + + ]: 11251 : if (size <= MIN_TTYB_SIZE) {
157 : 11250 : free = llist_del_first(&port->buf.free);
158 [ + ]: 11250 : if (free) {
159 : : p = llist_entry(free, struct tty_buffer, free);
160 : : goto found;
161 : : }
162 : : }
163 : :
164 : : /* Should possibly check if this fails for the largest buffer we
165 : : have queued and recycle that ? */
166 [ + - ]: 11271 : if (atomic_read(&port->buf.mem_used) > port->buf.mem_limit)
167 : : return NULL;
168 : 20 : p = kmalloc(sizeof(struct tty_buffer) + 2 * size, GFP_ATOMIC);
169 [ + - ]: 20 : if (p == NULL)
170 : : return NULL;
171 : :
172 : : found:
173 : : tty_buffer_reset(p, size);
174 : 0 : atomic_add(size, &port->buf.mem_used);
175 : 11251 : return p;
176 : : }
177 : :
178 : : /**
179 : : * tty_buffer_free - free a tty buffer
180 : : * @tty: tty owning the buffer
181 : : * @b: the buffer to free
182 : : *
183 : : * Free a tty buffer, or add it to the free list according to our
184 : : * internal strategy
185 : : */
186 : :
187 : 0 : static void tty_buffer_free(struct tty_port *port, struct tty_buffer *b)
188 : : {
189 : : struct tty_bufhead *buf = &port->buf;
190 : :
191 : : /* Dumb strategy for now - should keep some stats */
192 [ - + ]: 11251 : WARN_ON(atomic_sub_return(b->size, &buf->mem_used) < 0);
193 : :
194 [ - + ]: 11251 : if (b->size > MIN_TTYB_SIZE)
195 : 0 : kfree(b);
196 [ + + ]: 11251 : else if (b->size > 0)
197 : 11248 : llist_add(&b->free, &buf->free);
198 : 0 : }
199 : :
200 : : /**
201 : : * tty_buffer_flush - flush full tty buffers
202 : : * @tty: tty to flush
203 : : *
204 : : * flush all the buffers containing receive data.
205 : : *
206 : : * Locking: takes buffer lock to ensure single-threaded flip buffer
207 : : * 'consumer'
208 : : */
209 : :
210 : 0 : void tty_buffer_flush(struct tty_struct *tty)
211 : : {
212 : 128 : struct tty_port *port = tty->port;
213 : : struct tty_bufhead *buf = &port->buf;
214 : : struct tty_buffer *next;
215 : :
216 : 128 : atomic_inc(&buf->priority);
217 : :
218 : 128 : mutex_lock(&buf->lock);
219 [ - + ]: 256 : while ((next = buf->head->next) != NULL) {
220 : 0 : tty_buffer_free(port, buf->head);
221 : 0 : buf->head = next;
222 : : }
223 : 128 : buf->head->read = buf->head->commit;
224 : : atomic_dec(&buf->priority);
225 : 128 : mutex_unlock(&buf->lock);
226 : 128 : }
227 : :
228 : : /**
229 : : * tty_buffer_request_room - grow tty buffer if needed
230 : : * @tty: tty structure
231 : : * @size: size desired
232 : : * @flags: buffer flags if new buffer allocated (default = 0)
233 : : *
234 : : * Make at least size bytes of linear space available for the tty
235 : : * buffer. If we fail return the size we managed to find.
236 : : *
237 : : * Will change over to a new buffer if the current buffer is encoded as
238 : : * TTY_NORMAL (so has no flags buffer) and the new buffer requires
239 : : * a flags buffer.
240 : : */
241 : 0 : static int __tty_buffer_request_room(struct tty_port *port, size_t size,
242 : : int flags)
243 : : {
244 : : struct tty_bufhead *buf = &port->buf;
245 : : struct tty_buffer *b, *n;
246 : : int left, change;
247 : :
248 : 130029 : b = buf->tail;
249 [ + + ]: 130029 : if (b->flags & TTYB_NORMAL)
250 : 130026 : left = 2 * b->size - b->used;
251 : : else
252 : 3 : left = b->size - b->used;
253 : :
254 [ + + ][ + - ]: 130029 : change = (b->flags & TTYB_NORMAL) && (~flags & TTYB_NORMAL);
255 [ + + ]: 130029 : if (change || left < size) {
256 : : /* This is the slow path - looking for new buffers to use */
257 [ + - ]: 11251 : if ((n = tty_buffer_alloc(port, size)) != NULL) {
258 : 11251 : n->flags = flags;
259 : 11251 : buf->tail = n;
260 : 11251 : b->commit = b->used;
261 : 11251 : smp_mb();
262 : 11251 : b->next = n;
263 [ # # ]: 0 : } else if (change)
264 : : size = 0;
265 : : else
266 : : size = left;
267 : : }
268 : 0 : return size;
269 : : }
270 : :
271 : 0 : int tty_buffer_request_room(struct tty_port *port, size_t size)
272 : : {
273 : 0 : return __tty_buffer_request_room(port, size, 0);
274 : : }
275 : : EXPORT_SYMBOL_GPL(tty_buffer_request_room);
276 : :
277 : : /**
278 : : * tty_insert_flip_string_fixed_flag - Add characters to the tty buffer
279 : : * @port: tty port
280 : : * @chars: characters
281 : : * @flag: flag value for each character
282 : : * @size: size
283 : : *
284 : : * Queue a series of bytes to the tty buffering. All the characters
285 : : * passed are marked with the supplied flag. Returns the number added.
286 : : */
287 : :
288 : 130029 : int tty_insert_flip_string_fixed_flag(struct tty_port *port,
289 : : const unsigned char *chars, char flag, size_t size)
290 : : {
291 : : int copied = 0;
292 : : do {
293 : 130029 : int goal = min_t(size_t, size - copied, TTY_BUFFER_PAGE);
294 : 130029 : int flags = (flag == TTY_NORMAL) ? TTYB_NORMAL : 0;
295 : 130029 : int space = __tty_buffer_request_room(port, goal, flags);
296 : 130029 : struct tty_buffer *tb = port->buf.tail;
297 [ + - ]: 130029 : if (unlikely(space == 0))
298 : : break;
299 : 260058 : memcpy(char_buf_ptr(tb, tb->used), chars, space);
300 [ - + ]: 130029 : if (~tb->flags & TTYB_NORMAL)
301 [ # # ][ # # ]: 0 : memset(flag_buf_ptr(tb, tb->used), flag, space);
[ # # ]
302 : 130029 : tb->used += space;
303 : 130029 : copied += space;
304 : 130029 : chars += space;
305 : : /* There is a small chance that we need to split the data over
306 : : several buffers. If this is the case we must loop */
307 [ - + ]: 130029 : } while (unlikely(size > copied));
308 : 130029 : return copied;
309 : : }
310 : : EXPORT_SYMBOL(tty_insert_flip_string_fixed_flag);
311 : :
312 : : /**
313 : : * tty_insert_flip_string_flags - Add characters to the tty buffer
314 : : * @port: tty port
315 : : * @chars: characters
316 : : * @flags: flag bytes
317 : : * @size: size
318 : : *
319 : : * Queue a series of bytes to the tty buffering. For each character
320 : : * the flags array indicates the status of the character. Returns the
321 : : * number added.
322 : : */
323 : :
324 : 0 : int tty_insert_flip_string_flags(struct tty_port *port,
325 : : const unsigned char *chars, const char *flags, size_t size)
326 : : {
327 : : int copied = 0;
328 : : do {
329 : 0 : int goal = min_t(size_t, size - copied, TTY_BUFFER_PAGE);
330 : : int space = tty_buffer_request_room(port, goal);
331 : 0 : struct tty_buffer *tb = port->buf.tail;
332 [ # # ]: 0 : if (unlikely(space == 0))
333 : : break;
334 : 0 : memcpy(char_buf_ptr(tb, tb->used), chars, space);
335 : 0 : memcpy(flag_buf_ptr(tb, tb->used), flags, space);
336 : 0 : tb->used += space;
337 : 0 : copied += space;
338 : 0 : chars += space;
339 : 0 : flags += space;
340 : : /* There is a small chance that we need to split the data over
341 : : several buffers. If this is the case we must loop */
342 [ # # ]: 0 : } while (unlikely(size > copied));
343 : 0 : return copied;
344 : : }
345 : : EXPORT_SYMBOL(tty_insert_flip_string_flags);
346 : :
347 : : /**
348 : : * tty_schedule_flip - push characters to ldisc
349 : : * @port: tty port to push from
350 : : *
351 : : * Takes any pending buffers and transfers their ownership to the
352 : : * ldisc side of the queue. It then schedules those characters for
353 : : * processing by the line discipline.
354 : : * Note that this function can only be used when the low_latency flag
355 : : * is unset. Otherwise the workqueue won't be flushed.
356 : : */
357 : :
358 : 0 : void tty_schedule_flip(struct tty_port *port)
359 : : {
360 : : struct tty_bufhead *buf = &port->buf;
361 [ # # ]: 0 : WARN_ON(port->low_latency);
362 : :
363 : 0 : buf->tail->commit = buf->tail->used;
364 : 0 : schedule_work(&buf->work);
365 : 0 : }
366 : : EXPORT_SYMBOL(tty_schedule_flip);
367 : :
368 : : /**
369 : : * tty_prepare_flip_string - make room for characters
370 : : * @port: tty port
371 : : * @chars: return pointer for character write area
372 : : * @size: desired size
373 : : *
374 : : * Prepare a block of space in the buffer for data. Returns the length
375 : : * available and buffer pointer to the space which is now allocated and
376 : : * accounted for as ready for normal characters. This is used for drivers
377 : : * that need their own block copy routines into the buffer. There is no
378 : : * guarantee the buffer is a DMA target!
379 : : */
380 : :
381 : 0 : int tty_prepare_flip_string(struct tty_port *port, unsigned char **chars,
382 : : size_t size)
383 : : {
384 : 0 : int space = __tty_buffer_request_room(port, size, TTYB_NORMAL);
385 [ # # ]: 0 : if (likely(space)) {
386 : 0 : struct tty_buffer *tb = port->buf.tail;
387 : 0 : *chars = char_buf_ptr(tb, tb->used);
388 [ # # ]: 0 : if (~tb->flags & TTYB_NORMAL)
389 [ # # ]: 0 : memset(flag_buf_ptr(tb, tb->used), TTY_NORMAL, space);
390 : 0 : tb->used += space;
391 : : }
392 : 0 : return space;
393 : : }
394 : : EXPORT_SYMBOL_GPL(tty_prepare_flip_string);
395 : :
396 : :
397 : : static int
398 : 0 : receive_buf(struct tty_struct *tty, struct tty_buffer *head, int count)
399 : : {
400 : 62156 : struct tty_ldisc *disc = tty->ldisc;
401 : 62156 : unsigned char *p = char_buf_ptr(head, head->read);
402 : : char *f = NULL;
403 : :
404 [ + + ]: 62156 : if (~head->flags & TTYB_NORMAL)
405 : : f = flag_buf_ptr(head, head->read);
406 : :
407 [ + - ]: 62156 : if (disc->ops->receive_buf2)
408 : 62156 : count = disc->ops->receive_buf2(tty, p, f, count);
409 : : else {
410 : 0 : count = min_t(int, count, tty->receive_room);
411 [ # # ]: 0 : if (count)
412 : 0 : disc->ops->receive_buf(tty, p, f, count);
413 : : }
414 : 0 : head->read += count;
415 : 0 : return count;
416 : : }
417 : :
418 : : /**
419 : : * flush_to_ldisc
420 : : * @work: tty structure passed from work queue.
421 : : *
422 : : * This routine is called out of the software interrupt to flush data
423 : : * from the buffer chain to the line discipline.
424 : : *
425 : : * The receive_buf method is single threaded for each tty instance.
426 : : *
427 : : * Locking: takes buffer lock to ensure single-threaded flip buffer
428 : : * 'consumer'
429 : : */
430 : :
431 : 0 : static void flush_to_ldisc(struct work_struct *work)
432 : : {
433 : 61051 : struct tty_port *port = container_of(work, struct tty_port, buf.work);
434 : : struct tty_bufhead *buf = &port->buf;
435 : : struct tty_struct *tty;
436 : : struct tty_ldisc *disc;
437 : :
438 : 61051 : tty = port->itty;
439 [ + - ]: 61051 : if (tty == NULL)
440 : : return;
441 : :
442 : 61051 : disc = tty_ldisc_ref(tty);
443 [ + - ]: 61051 : if (disc == NULL)
444 : : return;
445 : :
446 : 133110 : mutex_lock(&buf->lock);
447 : :
448 : : while (1) {
449 : 133110 : struct tty_buffer *head = buf->head;
450 : : int count;
451 : :
452 : : /* Ldisc or user is trying to gain exclusive access */
453 [ + - ]: 133110 : if (atomic_read(&buf->priority))
454 : : break;
455 : :
456 : 133110 : count = head->commit - head->read;
457 [ + + ]: 133110 : if (!count) {
458 [ + + ]: 70954 : if (head->next == NULL)
459 : : break;
460 : 11251 : buf->head = head->next;
461 : 11251 : tty_buffer_free(port, head);
462 : 11251 : continue;
463 : : }
464 : :
465 : 62156 : count = receive_buf(tty, head, count);
466 [ + + ]: 62156 : if (!count)
467 : : break;
468 : : }
469 : :
470 : 61051 : mutex_unlock(&buf->lock);
471 : :
472 : 61051 : tty_ldisc_deref(disc);
473 : : }
474 : :
475 : : /**
476 : : * tty_flush_to_ldisc
477 : : * @tty: tty to push
478 : : *
479 : : * Push the terminal flip buffers to the line discipline.
480 : : *
481 : : * Must not be called from IRQ context.
482 : : */
483 : 0 : void tty_flush_to_ldisc(struct tty_struct *tty)
484 : : {
485 [ + - ]: 66 : if (!tty->port->low_latency)
486 : 66 : flush_work(&tty->port->buf.work);
487 : 0 : }
488 : :
489 : : /**
490 : : * tty_flip_buffer_push - terminal
491 : : * @port: tty port to push
492 : : *
493 : : * Queue a push of the terminal flip buffers to the line discipline. This
494 : : * function must not be called from IRQ context if port->low_latency is
495 : : * set.
496 : : *
497 : : * In the event of the queue being busy for flipping the work will be
498 : : * held off and retried later.
499 : : */
500 : :
501 : 0 : void tty_flip_buffer_push(struct tty_port *port)
502 : : {
503 : : struct tty_bufhead *buf = &port->buf;
504 : :
505 : 130114 : buf->tail->commit = buf->tail->used;
506 : :
507 [ - + ]: 130114 : if (port->low_latency)
508 : 0 : flush_to_ldisc(&buf->work);
509 : : else
510 : 130114 : schedule_work(&buf->work);
511 : 130114 : }
512 : : EXPORT_SYMBOL(tty_flip_buffer_push);
513 : :
514 : : /**
515 : : * tty_buffer_init - prepare a tty buffer structure
516 : : * @tty: tty to initialise
517 : : *
518 : : * Set up the initial state of the buffer management for a tty device.
519 : : * Must be called before the other tty buffer functions are used.
520 : : */
521 : :
522 : 0 : void tty_buffer_init(struct tty_port *port)
523 : : {
524 : : struct tty_bufhead *buf = &port->buf;
525 : :
526 : 244 : mutex_init(&buf->lock);
527 : : tty_buffer_reset(&buf->sentinel, 0);
528 : 244 : buf->head = &buf->sentinel;
529 : 244 : buf->tail = &buf->sentinel;
530 : : init_llist_head(&buf->free);
531 : 244 : atomic_set(&buf->mem_used, 0);
532 : 244 : atomic_set(&buf->priority, 0);
533 : 488 : INIT_WORK(&buf->work, flush_to_ldisc);
534 : 244 : buf->mem_limit = TTYB_DEFAULT_MEM_LIMIT;
535 : 244 : }
536 : :
537 : : /**
538 : : * tty_buffer_set_limit - change the tty buffer memory limit
539 : : * @port: tty port to change
540 : : *
541 : : * Change the tty buffer memory limit.
542 : : * Must be called before the other tty buffer functions are used.
543 : : */
544 : :
545 : 0 : int tty_buffer_set_limit(struct tty_port *port, int limit)
546 : : {
547 [ # # ]: 0 : if (limit < MIN_TTYB_SIZE)
548 : : return -EINVAL;
549 : 0 : port->buf.mem_limit = limit;
550 : 0 : return 0;
551 : : }
552 : : EXPORT_SYMBOL_GPL(tty_buffer_set_limit);
|
