TTY: switch tty_schedule_flip
[linux-3.10.git] / drivers / tty / tty_buffer.c
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/init.h>
15 #include <linux/wait.h>
16 #include <linux/bitops.h>
17 #include <linux/delay.h>
18 #include <linux/module.h>
19
20 /**
21  *      tty_buffer_free_all             -       free buffers used by a tty
22  *      @tty: tty to free from
23  *
24  *      Remove all the buffers pending on a tty whether queued with data
25  *      or in the free ring. Must be called when the tty is no longer in use
26  *
27  *      Locking: none
28  */
29
30 void tty_buffer_free_all(struct tty_port *port)
31 {
32         struct tty_bufhead *buf = &port->buf;
33         struct tty_buffer *thead;
34
35         while ((thead = buf->head) != NULL) {
36                 buf->head = thead->next;
37                 kfree(thead);
38         }
39         while ((thead = buf->free) != NULL) {
40                 buf->free = thead->next;
41                 kfree(thead);
42         }
43         buf->tail = NULL;
44         buf->memory_used = 0;
45 }
46
47 /**
48  *      tty_buffer_alloc        -       allocate a tty buffer
49  *      @tty: tty device
50  *      @size: desired size (characters)
51  *
52  *      Allocate a new tty buffer to hold the desired number of characters.
53  *      Return NULL if out of memory or the allocation would exceed the
54  *      per device queue
55  *
56  *      Locking: Caller must hold tty->buf.lock
57  */
58
59 static struct tty_buffer *tty_buffer_alloc(struct tty_port *port, size_t size)
60 {
61         struct tty_buffer *p;
62
63         if (port->buf.memory_used + size > 65536)
64                 return NULL;
65         p = kmalloc(sizeof(struct tty_buffer) + 2 * size, GFP_ATOMIC);
66         if (p == NULL)
67                 return NULL;
68         p->used = 0;
69         p->size = size;
70         p->next = NULL;
71         p->commit = 0;
72         p->read = 0;
73         p->char_buf_ptr = (char *)(p->data);
74         p->flag_buf_ptr = (unsigned char *)p->char_buf_ptr + size;
75         port->buf.memory_used += size;
76         return p;
77 }
78
79 /**
80  *      tty_buffer_free         -       free a tty buffer
81  *      @tty: tty owning the buffer
82  *      @b: the buffer to free
83  *
84  *      Free a tty buffer, or add it to the free list according to our
85  *      internal strategy
86  *
87  *      Locking: Caller must hold tty->buf.lock
88  */
89
90 static void tty_buffer_free(struct tty_port *port, struct tty_buffer *b)
91 {
92         struct tty_bufhead *buf = &port->buf;
93
94         /* Dumb strategy for now - should keep some stats */
95         buf->memory_used -= b->size;
96         WARN_ON(buf->memory_used < 0);
97
98         if (b->size >= 512)
99                 kfree(b);
100         else {
101                 b->next = buf->free;
102                 buf->free = b;
103         }
104 }
105
106 /**
107  *      __tty_buffer_flush              -       flush full tty buffers
108  *      @tty: tty to flush
109  *
110  *      flush all the buffers containing receive data. Caller must
111  *      hold the buffer lock and must have ensured no parallel flush to
112  *      ldisc is running.
113  *
114  *      Locking: Caller must hold tty->buf.lock
115  */
116
117 static void __tty_buffer_flush(struct tty_port *port)
118 {
119         struct tty_bufhead *buf = &port->buf;
120         struct tty_buffer *thead;
121
122         while ((thead = buf->head) != NULL) {
123                 buf->head = thead->next;
124                 tty_buffer_free(port, thead);
125         }
126         buf->tail = NULL;
127 }
128
129 /**
130  *      tty_buffer_flush                -       flush full tty buffers
131  *      @tty: tty to flush
132  *
133  *      flush all the buffers containing receive data. If the buffer is
134  *      being processed by flush_to_ldisc then we defer the processing
135  *      to that function
136  *
137  *      Locking: none
138  */
139
140 void tty_buffer_flush(struct tty_struct *tty)
141 {
142         struct tty_port *port = tty->port;
143         struct tty_bufhead *buf = &port->buf;
144         unsigned long flags;
145
146         spin_lock_irqsave(&buf->lock, flags);
147
148         /* If the data is being pushed to the tty layer then we can't
149            process it here. Instead set a flag and the flush_to_ldisc
150            path will process the flush request before it exits */
151         if (test_bit(TTYP_FLUSHING, &port->iflags)) {
152                 set_bit(TTYP_FLUSHPENDING, &port->iflags);
153                 spin_unlock_irqrestore(&buf->lock, flags);
154                 wait_event(tty->read_wait,
155                                 test_bit(TTYP_FLUSHPENDING, &port->iflags) == 0);
156                 return;
157         } else
158                 __tty_buffer_flush(port);
159         spin_unlock_irqrestore(&buf->lock, flags);
160 }
161
162 /**
163  *      tty_buffer_find         -       find a free tty buffer
164  *      @tty: tty owning the buffer
165  *      @size: characters wanted
166  *
167  *      Locate an existing suitable tty buffer or if we are lacking one then
168  *      allocate a new one. We round our buffers off in 256 character chunks
169  *      to get better allocation behaviour.
170  *
171  *      Locking: Caller must hold tty->buf.lock
172  */
173
174 static struct tty_buffer *tty_buffer_find(struct tty_port *port, size_t size)
175 {
176         struct tty_buffer **tbh = &port->buf.free;
177         while ((*tbh) != NULL) {
178                 struct tty_buffer *t = *tbh;
179                 if (t->size >= size) {
180                         *tbh = t->next;
181                         t->next = NULL;
182                         t->used = 0;
183                         t->commit = 0;
184                         t->read = 0;
185                         port->buf.memory_used += t->size;
186                         return t;
187                 }
188                 tbh = &((*tbh)->next);
189         }
190         /* Round the buffer size out */
191         size = (size + 0xFF) & ~0xFF;
192         return tty_buffer_alloc(port, size);
193         /* Should possibly check if this fails for the largest buffer we
194            have queued and recycle that ? */
195 }
196 /**
197  *      __tty_buffer_request_room               -       grow tty buffer if needed
198  *      @tty: tty structure
199  *      @size: size desired
200  *
201  *      Make at least size bytes of linear space available for the tty
202  *      buffer. If we fail return the size we managed to find.
203  *      Locking: Caller must hold port->buf.lock
204  */
205 static int __tty_buffer_request_room(struct tty_port *port, size_t size)
206 {
207         struct tty_bufhead *buf = &port->buf;
208         struct tty_buffer *b, *n;
209         int left;
210         /* OPTIMISATION: We could keep a per tty "zero" sized buffer to
211            remove this conditional if its worth it. This would be invisible
212            to the callers */
213         b = buf->tail;
214         if (b != NULL)
215                 left = b->size - b->used;
216         else
217                 left = 0;
218
219         if (left < size) {
220                 /* This is the slow path - looking for new buffers to use */
221                 if ((n = tty_buffer_find(port, size)) != NULL) {
222                         if (b != NULL) {
223                                 b->next = n;
224                                 b->commit = b->used;
225                         } else
226                                 buf->head = n;
227                         buf->tail = n;
228                 } else
229                         size = left;
230         }
231
232         return size;
233 }
234
235
236 /**
237  *      tty_buffer_request_room         -       grow tty buffer if needed
238  *      @port: tty port structure
239  *      @size: size desired
240  *
241  *      Make at least size bytes of linear space available for the tty
242  *      buffer. If we fail return the size we managed to find.
243  *
244  *      Locking: Takes port->buf.lock
245  */
246 int tty_buffer_request_room(struct tty_port *port, size_t size)
247 {
248         unsigned long flags;
249         int length;
250
251         spin_lock_irqsave(&port->buf.lock, flags);
252         length = __tty_buffer_request_room(port, size);
253         spin_unlock_irqrestore(&port->buf.lock, flags);
254         return length;
255 }
256 EXPORT_SYMBOL_GPL(tty_buffer_request_room);
257
258 /**
259  *      tty_insert_flip_string_fixed_flag - Add characters to the tty buffer
260  *      @port: tty port
261  *      @chars: characters
262  *      @flag: flag value for each character
263  *      @size: size
264  *
265  *      Queue a series of bytes to the tty buffering. All the characters
266  *      passed are marked with the supplied flag. Returns the number added.
267  *
268  *      Locking: Called functions may take port->buf.lock
269  */
270
271 int tty_insert_flip_string_fixed_flag(struct tty_port *port,
272                 const unsigned char *chars, char flag, size_t size)
273 {
274         struct tty_bufhead *buf = &port->buf;
275         int copied = 0;
276         do {
277                 int goal = min_t(size_t, size - copied, TTY_BUFFER_PAGE);
278                 int space;
279                 unsigned long flags;
280                 struct tty_buffer *tb;
281
282                 spin_lock_irqsave(&buf->lock, flags);
283                 space = __tty_buffer_request_room(port, goal);
284                 tb = buf->tail;
285                 /* If there is no space then tb may be NULL */
286                 if (unlikely(space == 0)) {
287                         spin_unlock_irqrestore(&buf->lock, flags);
288                         break;
289                 }
290                 memcpy(tb->char_buf_ptr + tb->used, chars, space);
291                 memset(tb->flag_buf_ptr + tb->used, flag, space);
292                 tb->used += space;
293                 spin_unlock_irqrestore(&buf->lock, flags);
294                 copied += space;
295                 chars += space;
296                 /* There is a small chance that we need to split the data over
297                    several buffers. If this is the case we must loop */
298         } while (unlikely(size > copied));
299         return copied;
300 }
301 EXPORT_SYMBOL(tty_insert_flip_string_fixed_flag);
302
303 /**
304  *      tty_insert_flip_string_flags    -       Add characters to the tty buffer
305  *      @port: tty port
306  *      @chars: characters
307  *      @flags: flag bytes
308  *      @size: size
309  *
310  *      Queue a series of bytes to the tty buffering. For each character
311  *      the flags array indicates the status of the character. Returns the
312  *      number added.
313  *
314  *      Locking: Called functions may take port->buf.lock
315  */
316
317 int tty_insert_flip_string_flags(struct tty_port *port,
318                 const unsigned char *chars, const char *flags, size_t size)
319 {
320         struct tty_bufhead *buf = &port->buf;
321         int copied = 0;
322         do {
323                 int goal = min_t(size_t, size - copied, TTY_BUFFER_PAGE);
324                 int space;
325                 unsigned long __flags;
326                 struct tty_buffer *tb;
327
328                 spin_lock_irqsave(&buf->lock, __flags);
329                 space = __tty_buffer_request_room(port, goal);
330                 tb = buf->tail;
331                 /* If there is no space then tb may be NULL */
332                 if (unlikely(space == 0)) {
333                         spin_unlock_irqrestore(&buf->lock, __flags);
334                         break;
335                 }
336                 memcpy(tb->char_buf_ptr + tb->used, chars, space);
337                 memcpy(tb->flag_buf_ptr + tb->used, flags, space);
338                 tb->used += space;
339                 spin_unlock_irqrestore(&buf->lock, __flags);
340                 copied += space;
341                 chars += space;
342                 flags += space;
343                 /* There is a small chance that we need to split the data over
344                    several buffers. If this is the case we must loop */
345         } while (unlikely(size > copied));
346         return copied;
347 }
348 EXPORT_SYMBOL(tty_insert_flip_string_flags);
349
350 /**
351  *      tty_schedule_flip       -       push characters to ldisc
352  *      @port: tty port to push from
353  *
354  *      Takes any pending buffers and transfers their ownership to the
355  *      ldisc side of the queue. It then schedules those characters for
356  *      processing by the line discipline.
357  *      Note that this function can only be used when the low_latency flag
358  *      is unset. Otherwise the workqueue won't be flushed.
359  *
360  *      Locking: Takes port->buf.lock
361  */
362
363 void tty_schedule_flip(struct tty_port *port)
364 {
365         struct tty_bufhead *buf = &port->buf;
366         unsigned long flags;
367         WARN_ON(port->low_latency);
368
369         spin_lock_irqsave(&buf->lock, flags);
370         if (buf->tail != NULL)
371                 buf->tail->commit = buf->tail->used;
372         spin_unlock_irqrestore(&buf->lock, flags);
373         schedule_work(&buf->work);
374 }
375 EXPORT_SYMBOL(tty_schedule_flip);
376
377 /**
378  *      tty_prepare_flip_string         -       make room for characters
379  *      @port: tty port
380  *      @chars: return pointer for character write area
381  *      @size: desired size
382  *
383  *      Prepare a block of space in the buffer for data. Returns the length
384  *      available and buffer pointer to the space which is now allocated and
385  *      accounted for as ready for normal characters. This is used for drivers
386  *      that need their own block copy routines into the buffer. There is no
387  *      guarantee the buffer is a DMA target!
388  *
389  *      Locking: May call functions taking port->buf.lock
390  */
391
392 int tty_prepare_flip_string(struct tty_port *port, unsigned char **chars,
393                 size_t size)
394 {
395         struct tty_bufhead *buf = &port->buf;
396         int space;
397         unsigned long flags;
398         struct tty_buffer *tb;
399
400         spin_lock_irqsave(&buf->lock, flags);
401         space = __tty_buffer_request_room(port, size);
402
403         tb = buf->tail;
404         if (likely(space)) {
405                 *chars = tb->char_buf_ptr + tb->used;
406                 memset(tb->flag_buf_ptr + tb->used, TTY_NORMAL, space);
407                 tb->used += space;
408         }
409         spin_unlock_irqrestore(&buf->lock, flags);
410         return space;
411 }
412 EXPORT_SYMBOL_GPL(tty_prepare_flip_string);
413
414 /**
415  *      tty_prepare_flip_string_flags   -       make room for characters
416  *      @port: tty port
417  *      @chars: return pointer for character write area
418  *      @flags: return pointer for status flag write area
419  *      @size: desired size
420  *
421  *      Prepare a block of space in the buffer for data. Returns the length
422  *      available and buffer pointer to the space which is now allocated and
423  *      accounted for as ready for characters. This is used for drivers
424  *      that need their own block copy routines into the buffer. There is no
425  *      guarantee the buffer is a DMA target!
426  *
427  *      Locking: May call functions taking port->buf.lock
428  */
429
430 int tty_prepare_flip_string_flags(struct tty_port *port,
431                         unsigned char **chars, char **flags, size_t size)
432 {
433         struct tty_bufhead *buf = &port->buf;
434         int space;
435         unsigned long __flags;
436         struct tty_buffer *tb;
437
438         spin_lock_irqsave(&buf->lock, __flags);
439         space = __tty_buffer_request_room(port, size);
440
441         tb = buf->tail;
442         if (likely(space)) {
443                 *chars = tb->char_buf_ptr + tb->used;
444                 *flags = tb->flag_buf_ptr + tb->used;
445                 tb->used += space;
446         }
447         spin_unlock_irqrestore(&buf->lock, __flags);
448         return space;
449 }
450 EXPORT_SYMBOL_GPL(tty_prepare_flip_string_flags);
451
452
453
454 /**
455  *      flush_to_ldisc
456  *      @work: tty structure passed from work queue.
457  *
458  *      This routine is called out of the software interrupt to flush data
459  *      from the buffer chain to the line discipline.
460  *
461  *      Locking: holds tty->buf.lock to guard buffer list. Drops the lock
462  *      while invoking the line discipline receive_buf method. The
463  *      receive_buf method is single threaded for each tty instance.
464  */
465
466 static void flush_to_ldisc(struct work_struct *work)
467 {
468         struct tty_port *port = container_of(work, struct tty_port, buf.work);
469         struct tty_bufhead *buf = &port->buf;
470         struct tty_struct *tty;
471         unsigned long   flags;
472         struct tty_ldisc *disc;
473
474         tty = port->itty;
475         if (WARN_RATELIMIT(tty == NULL, "tty is NULL\n"))
476                 return;
477
478         disc = tty_ldisc_ref(tty);
479         if (disc == NULL)       /*  !TTY_LDISC */
480                 return;
481
482         spin_lock_irqsave(&buf->lock, flags);
483
484         if (!test_and_set_bit(TTYP_FLUSHING, &port->iflags)) {
485                 struct tty_buffer *head;
486                 while ((head = buf->head) != NULL) {
487                         int count;
488                         char *char_buf;
489                         unsigned char *flag_buf;
490
491                         count = head->commit - head->read;
492                         if (!count) {
493                                 if (head->next == NULL)
494                                         break;
495                                 buf->head = head->next;
496                                 tty_buffer_free(port, head);
497                                 continue;
498                         }
499                         /* Ldisc or user is trying to flush the buffers
500                            we are feeding to the ldisc, stop feeding the
501                            line discipline as we want to empty the queue */
502                         if (test_bit(TTYP_FLUSHPENDING, &port->iflags))
503                                 break;
504                         if (!tty->receive_room)
505                                 break;
506                         if (count > tty->receive_room)
507                                 count = tty->receive_room;
508                         char_buf = head->char_buf_ptr + head->read;
509                         flag_buf = head->flag_buf_ptr + head->read;
510                         head->read += count;
511                         spin_unlock_irqrestore(&buf->lock, flags);
512                         disc->ops->receive_buf(tty, char_buf,
513                                                         flag_buf, count);
514                         spin_lock_irqsave(&buf->lock, flags);
515                 }
516                 clear_bit(TTYP_FLUSHING, &port->iflags);
517         }
518
519         /* We may have a deferred request to flush the input buffer,
520            if so pull the chain under the lock and empty the queue */
521         if (test_bit(TTYP_FLUSHPENDING, &port->iflags)) {
522                 __tty_buffer_flush(port);
523                 clear_bit(TTYP_FLUSHPENDING, &port->iflags);
524                 wake_up(&tty->read_wait);
525         }
526         spin_unlock_irqrestore(&buf->lock, flags);
527
528         tty_ldisc_deref(disc);
529 }
530
531 /**
532  *      tty_flush_to_ldisc
533  *      @tty: tty to push
534  *
535  *      Push the terminal flip buffers to the line discipline.
536  *
537  *      Must not be called from IRQ context.
538  */
539 void tty_flush_to_ldisc(struct tty_struct *tty)
540 {
541         if (!tty->port->low_latency)
542                 flush_work(&tty->port->buf.work);
543 }
544
545 /**
546  *      tty_flip_buffer_push    -       terminal
547  *      @port: tty port to push
548  *
549  *      Queue a push of the terminal flip buffers to the line discipline. This
550  *      function must not be called from IRQ context if port->low_latency is
551  *      set.
552  *
553  *      In the event of the queue being busy for flipping the work will be
554  *      held off and retried later.
555  *
556  *      Locking: tty buffer lock. Driver locks in low latency mode.
557  */
558
559 void tty_flip_buffer_push(struct tty_port *port)
560 {
561         struct tty_bufhead *buf = &port->buf;
562         unsigned long flags;
563
564         spin_lock_irqsave(&buf->lock, flags);
565         if (buf->tail != NULL)
566                 buf->tail->commit = buf->tail->used;
567         spin_unlock_irqrestore(&buf->lock, flags);
568
569         if (port->low_latency)
570                 flush_to_ldisc(&buf->work);
571         else
572                 schedule_work(&buf->work);
573 }
574 EXPORT_SYMBOL(tty_flip_buffer_push);
575
576 /**
577  *      tty_buffer_init         -       prepare a tty buffer structure
578  *      @tty: tty to initialise
579  *
580  *      Set up the initial state of the buffer management for a tty device.
581  *      Must be called before the other tty buffer functions are used.
582  *
583  *      Locking: none
584  */
585
586 void tty_buffer_init(struct tty_port *port)
587 {
588         struct tty_bufhead *buf = &port->buf;
589
590         spin_lock_init(&buf->lock);
591         buf->head = NULL;
592         buf->tail = NULL;
593         buf->free = NULL;
594         buf->memory_used = 0;
595         INIT_WORK(&buf->work, flush_to_ldisc);
596 }
597