drivers/char/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  -       Add characters to the tty buffer
 235  *      @tty: tty structure
 236  *      @chars: characters
 237  *      @size: size
 238  *
 239  *      Queue a series of bytes to the tty buffering. All the characters
 240  *      passed are marked as without error. Returns the number added.
 241  *
 242  *      Locking: Called functions may take tty->buf.lock
 243  */
 244
 245 int tty_insert_flip_string(struct tty_struct *tty, const unsigned char *chars,
 246                                 size_t size)
 247 {
 248         int copied = 0;
 249         do {
 250                 int goal = min(size - copied, TTY_BUFFER_PAGE);
 251                 int space = tty_buffer_request_room(tty, goal);
 252                 struct tty_buffer *tb = tty->buf.tail;
 253                 /* If there is no space then tb may be NULL */
 254                 if (unlikely(space == 0))
 255                         break;
 256                 memcpy(tb->char_buf_ptr + tb->used, chars, space);
 257                 memset(tb->flag_buf_ptr + tb->used, TTY_NORMAL, space);
 258                 tb->used += space;
 259                 copied += space;
 260                 chars += space;
 261                 /* There is a small chance that we need to split the data over
 262                    several buffers. If this is the case we must loop */
 263         } while (unlikely(size > copied));
 264         return copied;
 265 }
 266 EXPORT_SYMBOL(tty_insert_flip_string);
 267
 268 /**
 269  *      tty_insert_flip_string_flags    -       Add characters to the tty buffer
 270  *      @tty: tty structure
 271  *      @chars: characters
 272  *      @flags: flag bytes
 273  *      @size: size
 274  *
 275  *      Queue a series of bytes to the tty buffering. For each character
 276  *      the flags array indicates the status of the character. Returns the
 277  *      number added.
 278  *
 279  *      Locking: Called functions may take tty->buf.lock
 280  */
 281
 282 int tty_insert_flip_string_flags(struct tty_struct *tty,
 283                 const unsigned char *chars, const char *flags, size_t size)
 284 {
 285         int copied = 0;
 286         do {
 287                 int goal = min(size - copied, TTY_BUFFER_PAGE);
 288                 int space = tty_buffer_request_room(tty, goal);
 289                 struct tty_buffer *tb = tty->buf.tail;
 290                 /* If there is no space then tb may be NULL */
 291                 if (unlikely(space == 0))
 292                         break;
 293                 memcpy(tb->char_buf_ptr + tb->used, chars, space);
 294                 memcpy(tb->flag_buf_ptr + tb->used, flags, space);
 295                 tb->used += space;
 296                 copied += space;
 297                 chars += space;
 298                 flags += space;
 299                 /* There is a small chance that we need to split the data over
 300                    several buffers. If this is the case we must loop */
 301         } while (unlikely(size > copied));
 302         return copied;
 303 }
 304 EXPORT_SYMBOL(tty_insert_flip_string_flags);
 305
 306 /**
 307  *      tty_schedule_flip       -       push characters to ldisc
 308  *      @tty: tty to push from
 309  *
 310  *      Takes any pending buffers and transfers their ownership to the
 311  *      ldisc side of the queue. It then schedules those characters for
 312  *      processing by the line discipline.
 313  *
 314  *      Locking: Takes tty->buf.lock
 315  */
 316
 317 void tty_schedule_flip(struct tty_struct *tty)
 318 {
 319         unsigned long flags;
 320         spin_lock_irqsave(&tty->buf.lock, flags);
 321         if (tty->buf.tail != NULL)
 322                 tty->buf.tail->commit = tty->buf.tail->used;
 323         spin_unlock_irqrestore(&tty->buf.lock, flags);
 324         schedule_delayed_work(&tty->buf.work, 1);
 325 }
 326 EXPORT_SYMBOL(tty_schedule_flip);
 327
 328 /**
 329  *      tty_prepare_flip_string         -       make room for characters
 330  *      @tty: tty
 331  *      @chars: return pointer for character write area
 332  *      @size: desired size
 333  *
 334  *      Prepare a block of space in the buffer for data. Returns the length
 335  *      available and buffer pointer to the space which is now allocated and
 336  *      accounted for as ready for normal characters. This is used for drivers
 337  *      that need their own block copy routines into the buffer. There is no
 338  *      guarantee the buffer is a DMA target!
 339  *
 340  *      Locking: May call functions taking tty->buf.lock
 341  */
 342
 343 int tty_prepare_flip_string(struct tty_struct *tty, unsigned char **chars,
 344                                                                 size_t size)
 345 {
 346         int space = tty_buffer_request_room(tty, size);
 347         if (likely(space)) {
 348                 struct tty_buffer *tb = tty->buf.tail;
 349                 *chars = tb->char_buf_ptr + tb->used;
 350                 memset(tb->flag_buf_ptr + tb->used, TTY_NORMAL, space);
 351                 tb->used += space;
 352         }
 353         return space;
 354 }
 355 EXPORT_SYMBOL_GPL(tty_prepare_flip_string);
 356
 357 /**
 358  *      tty_prepare_flip_string_flags   -       make room for characters
 359  *      @tty: tty
 360  *      @chars: return pointer for character write area
 361  *      @flags: return pointer for status flag write area
 362  *      @size: desired size
 363  *
 364  *      Prepare a block of space in the buffer for data. Returns the length
 365  *      available and buffer pointer to the space which is now allocated and
 366  *      accounted for as ready for characters. This is used for drivers
 367  *      that need their own block copy routines into the buffer. There is no
 368  *      guarantee the buffer is a DMA target!
 369  *
 370  *      Locking: May call functions taking tty->buf.lock
 371  */
 372
 373 int tty_prepare_flip_string_flags(struct tty_struct *tty,
 374                         unsigned char **chars, char **flags, size_t size)
 375 {
 376         int space = tty_buffer_request_room(tty, size);
 377         if (likely(space)) {
 378                 struct tty_buffer *tb = tty->buf.tail;
 379                 *chars = tb->char_buf_ptr + tb->used;
 380                 *flags = tb->flag_buf_ptr + tb->used;
 381                 tb->used += space;
 382         }
 383         return space;
 384 }
 385 EXPORT_SYMBOL_GPL(tty_prepare_flip_string_flags);
 386
 387
 388
 389 /**
 390  *      flush_to_ldisc
 391  *      @work: tty structure passed from work queue.
 392  *
 393  *      This routine is called out of the software interrupt to flush data
 394  *      from the buffer chain to the line discipline.
 395  *
 396  *      Locking: holds tty->buf.lock to guard buffer list. Drops the lock
 397  *      while invoking the line discipline receive_buf method. The
 398  *      receive_buf method is single threaded for each tty instance.
 399  */
 400
 401 static void flush_to_ldisc(struct work_struct *work)
 402 {
 403         struct tty_struct *tty =
 404                 container_of(work, struct tty_struct, buf.work.work);
 405         unsigned long   flags;
 406         struct tty_ldisc *disc;
 407
 408         disc = tty_ldisc_ref(tty);
 409         if (disc == NULL)       /*  !TTY_LDISC */
 410                 return;
 411
 412         spin_lock_irqsave(&tty->buf.lock, flags);
 413
 414         if (!test_and_set_bit(TTY_FLUSHING, &tty->flags)) {
 415                 struct tty_buffer *head, *tail = tty->buf.tail;
 416                 int seen_tail = 0;
 417                 while ((head = tty->buf.head) != NULL) {
 418                         int count;
 419                         char *char_buf;
 420                         unsigned char *flag_buf;
 421
 422                         count = head->commit - head->read;
 423                         if (!count) {
 424                                 if (head->next == NULL)
 425                                         break;
 426                                 /*
 427                                   There's a possibility tty might get new buffer
 428                                   added during the unlock window below. We could
 429                                   end up spinning in here forever hogging the CPU
 430                                   completely. To avoid this let's have a rest each
 431                                   time we processed the tail buffer.
 432                                 */
 433                                 if (tail == head)
 434                                         seen_tail = 1;
 435                                 tty->buf.head = head->next;
 436                                 tty_buffer_free(tty, head);
 437                                 continue;
 438                         }
 439                         /* Ldisc or user is trying to flush the buffers
 440                            we are feeding to the ldisc, stop feeding the
 441                            line discipline as we want to empty the queue */
 442                         if (test_bit(TTY_FLUSHPENDING, &tty->flags))
 443                                 break;
 444                         if (!tty->receive_room || seen_tail) {
 445                                 schedule_delayed_work(&tty->buf.work, 1);
 446                                 break;
 447                         }
 448                         if (count > tty->receive_room)
 449                                 count = tty->receive_room;
 450                         char_buf = head->char_buf_ptr + head->read;
 451                         flag_buf = head->flag_buf_ptr + head->read;
 452                         head->read += count;
 453                         spin_unlock_irqrestore(&tty->buf.lock, flags);
 454                         disc->ops->receive_buf(tty, char_buf,
 455                                                         flag_buf, count);
 456                         spin_lock_irqsave(&tty->buf.lock, flags);
 457                 }
 458                 clear_bit(TTY_FLUSHING, &tty->flags);
 459         }
 460
 461         /* We may have a deferred request to flush the input buffer,
 462            if so pull the chain under the lock and empty the queue */
 463         if (test_bit(TTY_FLUSHPENDING, &tty->flags)) {
 464                 __tty_buffer_flush(tty);
 465                 clear_bit(TTY_FLUSHPENDING, &tty->flags);
 466                 wake_up(&tty->read_wait);
 467         }
 468         spin_unlock_irqrestore(&tty->buf.lock, flags);
 469
 470         tty_ldisc_deref(disc);
 471 }
 472
 473 /**
 474  *      tty_flush_to_ldisc
 475  *      @tty: tty to push
 476  *
 477  *      Push the terminal flip buffers to the line discipline.
 478  *
 479  *      Must not be called from IRQ context.
 480  */
 481 void tty_flush_to_ldisc(struct tty_struct *tty)
 482 {
 483         flush_delayed_work(&tty->buf.work);
 484 }
 485
 486 /**
 487  *      tty_flip_buffer_push    -       terminal
 488  *      @tty: tty to push
 489  *
 490  *      Queue a push of the terminal flip buffers to the line discipline. This
 491  *      function must not be called from IRQ context if tty->low_latency is set.
 492  *
 493  *      In the event of the queue being busy for flipping the work will be
 494  *      held off and retried later.
 495  *
 496  *      Locking: tty buffer lock. Driver locks in low latency mode.
 497  */
 498
 499 void tty_flip_buffer_push(struct tty_struct *tty)
 500 {
 501         unsigned long flags;
 502         spin_lock_irqsave(&tty->buf.lock, flags);
 503         if (tty->buf.tail != NULL)
 504                 tty->buf.tail->commit = tty->buf.tail->used;
 505         spin_unlock_irqrestore(&tty->buf.lock, flags);
 506
 507         if (tty->low_latency)
 508                 flush_to_ldisc(&tty->buf.work.work);
 509         else
 510                 schedule_delayed_work(&tty->buf.work, 1);
 511 }
 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  *      Locking: none
 522  */
 523
 524 void tty_buffer_init(struct tty_struct *tty)
 525 {
 526         spin_lock_init(&tty->buf.lock);
 527         tty->buf.head = NULL;
 528         tty->buf.tail = NULL;
 529         tty->buf.free = NULL;
 530         tty->buf.memory_used = 0;
 531         INIT_DELAYED_WORK(&tty->buf.work, flush_to_ldisc);
 532 }
 533