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