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