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