1
2
3
4
5
6#include <linux/types.h>
7#include <linux/errno.h>
8#include <linux/tty.h>
9#include <linux/tty_driver.h>
10#include <linux/tty_flip.h>
11#include <linux/timer.h>
12#include <linux/string.h>
13#include <linux/slab.h>
14#include <linux/sched.h>
15#include <linux/wait.h>
16#include <linux/bitops.h>
17#include <linux/delay.h>
18#include <linux/module.h>
19#include <linux/ratelimit.h>
20#include "tty.h"
21
22#define MIN_TTYB_SIZE 256
23#define TTYB_ALIGN_MASK 255
24
25
26
27
28
29#define TTYB_DEFAULT_MEM_LIMIT (640 * 1024UL)
30
31
32
33
34
35
36
37
38
39#define TTY_BUFFER_PAGE (((PAGE_SIZE - sizeof(struct tty_buffer)) / 2) & ~0xFF)
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56void tty_buffer_lock_exclusive(struct tty_port *port)
57{
58 struct tty_bufhead *buf = &port->buf;
59
60 atomic_inc(&buf->priority);
61 mutex_lock(&buf->lock);
62}
63EXPORT_SYMBOL_GPL(tty_buffer_lock_exclusive);
64
65void tty_buffer_unlock_exclusive(struct tty_port *port)
66{
67 struct tty_bufhead *buf = &port->buf;
68 int restart;
69
70 restart = buf->head->commit != buf->head->read;
71
72 atomic_dec(&buf->priority);
73 mutex_unlock(&buf->lock);
74 if (restart)
75 queue_work(system_unbound_wq, &buf->work);
76}
77EXPORT_SYMBOL_GPL(tty_buffer_unlock_exclusive);
78
79
80
81
82
83
84
85
86
87
88
89
90
91unsigned int tty_buffer_space_avail(struct tty_port *port)
92{
93 int space = port->buf.mem_limit - atomic_read(&port->buf.mem_used);
94
95 return max(space, 0);
96}
97EXPORT_SYMBOL_GPL(tty_buffer_space_avail);
98
99static void tty_buffer_reset(struct tty_buffer *p, size_t size)
100{
101 p->used = 0;
102 p->size = size;
103 p->next = NULL;
104 p->commit = 0;
105 p->read = 0;
106 p->flags = 0;
107}
108
109
110
111
112
113
114
115
116
117void tty_buffer_free_all(struct tty_port *port)
118{
119 struct tty_bufhead *buf = &port->buf;
120 struct tty_buffer *p, *next;
121 struct llist_node *llist;
122 unsigned int freed = 0;
123 int still_used;
124
125 while ((p = buf->head) != NULL) {
126 buf->head = p->next;
127 freed += p->size;
128 if (p->size > 0)
129 kfree(p);
130 }
131 llist = llist_del_all(&buf->free);
132 llist_for_each_entry_safe(p, next, llist, free)
133 kfree(p);
134
135 tty_buffer_reset(&buf->sentinel, 0);
136 buf->head = &buf->sentinel;
137 buf->tail = &buf->sentinel;
138
139 still_used = atomic_xchg(&buf->mem_used, 0);
140 WARN(still_used != freed, "we still have not freed %d bytes!",
141 still_used - freed);
142}
143
144
145
146
147
148
149
150
151
152
153
154
155
156static struct tty_buffer *tty_buffer_alloc(struct tty_port *port, size_t size)
157{
158 struct llist_node *free;
159 struct tty_buffer *p;
160
161
162 size = __ALIGN_MASK(size, TTYB_ALIGN_MASK);
163
164 if (size <= MIN_TTYB_SIZE) {
165 free = llist_del_first(&port->buf.free);
166 if (free) {
167 p = llist_entry(free, struct tty_buffer, free);
168 goto found;
169 }
170 }
171
172
173
174
175 if (atomic_read(&port->buf.mem_used) > port->buf.mem_limit)
176 return NULL;
177 p = kmalloc(sizeof(struct tty_buffer) + 2 * size, GFP_ATOMIC);
178 if (p == NULL)
179 return NULL;
180
181found:
182 tty_buffer_reset(p, size);
183 atomic_add(size, &port->buf.mem_used);
184 return p;
185}
186
187
188
189
190
191
192
193
194
195
196static void tty_buffer_free(struct tty_port *port, struct tty_buffer *b)
197{
198 struct tty_bufhead *buf = &port->buf;
199
200
201 WARN_ON(atomic_sub_return(b->size, &buf->mem_used) < 0);
202
203 if (b->size > MIN_TTYB_SIZE)
204 kfree(b);
205 else if (b->size > 0)
206 llist_add(&b->free, &buf->free);
207}
208
209
210
211
212
213
214
215
216
217
218
219
220
221void tty_buffer_flush(struct tty_struct *tty, struct tty_ldisc *ld)
222{
223 struct tty_port *port = tty->port;
224 struct tty_bufhead *buf = &port->buf;
225 struct tty_buffer *next;
226
227 atomic_inc(&buf->priority);
228
229 mutex_lock(&buf->lock);
230
231
232
233 while ((next = smp_load_acquire(&buf->head->next)) != NULL) {
234 tty_buffer_free(port, buf->head);
235 buf->head = next;
236 }
237 buf->head->read = buf->head->commit;
238
239 if (ld && ld->ops->flush_buffer)
240 ld->ops->flush_buffer(tty);
241
242 atomic_dec(&buf->priority);
243 mutex_unlock(&buf->lock);
244}
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259static int __tty_buffer_request_room(struct tty_port *port, size_t size,
260 int flags)
261{
262 struct tty_bufhead *buf = &port->buf;
263 struct tty_buffer *b, *n;
264 int left, change;
265
266 b = buf->tail;
267 if (b->flags & TTYB_NORMAL)
268 left = 2 * b->size - b->used;
269 else
270 left = b->size - b->used;
271
272 change = (b->flags & TTYB_NORMAL) && (~flags & TTYB_NORMAL);
273 if (change || left < size) {
274
275 n = tty_buffer_alloc(port, size);
276 if (n != NULL) {
277 n->flags = flags;
278 buf->tail = n;
279
280
281
282 smp_store_release(&b->commit, b->used);
283
284
285
286
287 smp_store_release(&b->next, n);
288 } else if (change)
289 size = 0;
290 else
291 size = left;
292 }
293 return size;
294}
295
296int tty_buffer_request_room(struct tty_port *port, size_t size)
297{
298 return __tty_buffer_request_room(port, size, 0);
299}
300EXPORT_SYMBOL_GPL(tty_buffer_request_room);
301
302
303
304
305
306
307
308
309
310
311
312
313int tty_insert_flip_string_fixed_flag(struct tty_port *port,
314 const unsigned char *chars, char flag, size_t size)
315{
316 int copied = 0;
317
318 do {
319 int goal = min_t(size_t, size - copied, TTY_BUFFER_PAGE);
320 int flags = (flag == TTY_NORMAL) ? TTYB_NORMAL : 0;
321 int space = __tty_buffer_request_room(port, goal, flags);
322 struct tty_buffer *tb = port->buf.tail;
323
324 if (unlikely(space == 0))
325 break;
326 memcpy(char_buf_ptr(tb, tb->used), chars, space);
327 if (~tb->flags & TTYB_NORMAL)
328 memset(flag_buf_ptr(tb, tb->used), flag, space);
329 tb->used += space;
330 copied += space;
331 chars += space;
332
333
334
335 } while (unlikely(size > copied));
336 return copied;
337}
338EXPORT_SYMBOL(tty_insert_flip_string_fixed_flag);
339
340
341
342
343
344
345
346
347
348
349
350
351
352int tty_insert_flip_string_flags(struct tty_port *port,
353 const unsigned char *chars, const char *flags, size_t size)
354{
355 int copied = 0;
356
357 do {
358 int goal = min_t(size_t, size - copied, TTY_BUFFER_PAGE);
359 int space = tty_buffer_request_room(port, goal);
360 struct tty_buffer *tb = port->buf.tail;
361
362 if (unlikely(space == 0))
363 break;
364 memcpy(char_buf_ptr(tb, tb->used), chars, space);
365 memcpy(flag_buf_ptr(tb, tb->used), flags, space);
366 tb->used += space;
367 copied += space;
368 chars += space;
369 flags += space;
370
371
372
373 } while (unlikely(size > copied));
374 return copied;
375}
376EXPORT_SYMBOL(tty_insert_flip_string_flags);
377
378
379
380
381
382
383
384
385
386
387int __tty_insert_flip_char(struct tty_port *port, unsigned char ch, char flag)
388{
389 struct tty_buffer *tb;
390 int flags = (flag == TTY_NORMAL) ? TTYB_NORMAL : 0;
391
392 if (!__tty_buffer_request_room(port, 1, flags))
393 return 0;
394
395 tb = port->buf.tail;
396 if (~tb->flags & TTYB_NORMAL)
397 *flag_buf_ptr(tb, tb->used) = flag;
398 *char_buf_ptr(tb, tb->used++) = ch;
399
400 return 1;
401}
402EXPORT_SYMBOL(__tty_insert_flip_char);
403
404
405
406
407
408
409
410
411
412
413void tty_schedule_flip(struct tty_port *port)
414{
415 struct tty_bufhead *buf = &port->buf;
416
417
418
419
420 smp_store_release(&buf->tail->commit, buf->tail->used);
421 queue_work(system_unbound_wq, &buf->work);
422}
423EXPORT_SYMBOL(tty_schedule_flip);
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438int tty_prepare_flip_string(struct tty_port *port, unsigned char **chars,
439 size_t size)
440{
441 int space = __tty_buffer_request_room(port, size, TTYB_NORMAL);
442
443 if (likely(space)) {
444 struct tty_buffer *tb = port->buf.tail;
445
446 *chars = char_buf_ptr(tb, tb->used);
447 if (~tb->flags & TTYB_NORMAL)
448 memset(flag_buf_ptr(tb, tb->used), TTY_NORMAL, space);
449 tb->used += space;
450 }
451 return space;
452}
453EXPORT_SYMBOL_GPL(tty_prepare_flip_string);
454
455
456
457
458
459
460
461
462
463
464
465
466
467int tty_ldisc_receive_buf(struct tty_ldisc *ld, const unsigned char *p,
468 const char *f, int count)
469{
470 if (ld->ops->receive_buf2)
471 count = ld->ops->receive_buf2(ld->tty, p, f, count);
472 else {
473 count = min_t(int, count, ld->tty->receive_room);
474 if (count && ld->ops->receive_buf)
475 ld->ops->receive_buf(ld->tty, p, f, count);
476 }
477 return count;
478}
479EXPORT_SYMBOL_GPL(tty_ldisc_receive_buf);
480
481static int
482receive_buf(struct tty_port *port, struct tty_buffer *head, int count)
483{
484 unsigned char *p = char_buf_ptr(head, head->read);
485 const char *f = NULL;
486 int n;
487
488 if (~head->flags & TTYB_NORMAL)
489 f = flag_buf_ptr(head, head->read);
490
491 n = port->client_ops->receive_buf(port, p, f, count);
492 if (n > 0)
493 memset(p, 0, n);
494 return n;
495}
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510static void flush_to_ldisc(struct work_struct *work)
511{
512 struct tty_port *port = container_of(work, struct tty_port, buf.work);
513 struct tty_bufhead *buf = &port->buf;
514
515 mutex_lock(&buf->lock);
516
517 while (1) {
518 struct tty_buffer *head = buf->head;
519 struct tty_buffer *next;
520 int count;
521
522
523 if (atomic_read(&buf->priority))
524 break;
525
526
527
528
529
530 next = smp_load_acquire(&head->next);
531
532
533
534 count = smp_load_acquire(&head->commit) - head->read;
535 if (!count) {
536 if (next == NULL)
537 break;
538 buf->head = next;
539 tty_buffer_free(port, head);
540 continue;
541 }
542
543 count = receive_buf(port, head, count);
544 if (!count)
545 break;
546 head->read += count;
547 }
548
549 mutex_unlock(&buf->lock);
550
551}
552
553
554
555
556
557
558
559
560
561
562
563
564void tty_flip_buffer_push(struct tty_port *port)
565{
566 tty_schedule_flip(port);
567}
568EXPORT_SYMBOL(tty_flip_buffer_push);
569
570
571
572
573
574
575
576
577
578void tty_buffer_init(struct tty_port *port)
579{
580 struct tty_bufhead *buf = &port->buf;
581
582 mutex_init(&buf->lock);
583 tty_buffer_reset(&buf->sentinel, 0);
584 buf->head = &buf->sentinel;
585 buf->tail = &buf->sentinel;
586 init_llist_head(&buf->free);
587 atomic_set(&buf->mem_used, 0);
588 atomic_set(&buf->priority, 0);
589 INIT_WORK(&buf->work, flush_to_ldisc);
590 buf->mem_limit = TTYB_DEFAULT_MEM_LIMIT;
591}
592
593
594
595
596
597
598
599
600
601
602int tty_buffer_set_limit(struct tty_port *port, int limit)
603{
604 if (limit < MIN_TTYB_SIZE)
605 return -EINVAL;
606 port->buf.mem_limit = limit;
607 return 0;
608}
609EXPORT_SYMBOL_GPL(tty_buffer_set_limit);
610
611
612void tty_buffer_set_lock_subclass(struct tty_port *port)
613{
614 lockdep_set_subclass(&port->buf.lock, TTY_LOCK_SLAVE);
615}
616
617bool tty_buffer_restart_work(struct tty_port *port)
618{
619 return queue_work(system_unbound_wq, &port->buf.work);
620}
621
622bool tty_buffer_cancel_work(struct tty_port *port)
623{
624 return cancel_work_sync(&port->buf.work);
625}
626
627void tty_buffer_flush_work(struct tty_port *port)
628{
629 flush_work(&port->buf.work);
630}
631