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         if (unlikely(buf->head == NULL))
 123                 return;
 124         while ((thead = buf->head->next) != NULL) {
 125                 tty_buffer_free(port, buf->head);
 126                 buf->head = thead;
 127         }
 128         WARN_ON(buf->head != buf->tail);
 129         buf->head->read = buf->head->commit;
 130 }
 131
 132 /**
 133  *      tty_buffer_flush                -       flush full tty buffers
 134  *      @tty: tty to flush
 135  *
 136  *      flush all the buffers containing receive data. If the buffer is
 137  *      being processed by flush_to_ldisc then we defer the processing
 138  *      to that function
 139  *
 140  *      Locking: none
 141  */
 142
 143 void tty_buffer_flush(struct tty_struct *tty)
 144 {
 145         struct tty_port *port = tty->port;
 146         struct tty_bufhead *buf = &port->buf;
 147         unsigned long flags;
 148
 149         spin_lock_irqsave(&buf->lock, flags);
 150
 151         /* If the data is being pushed to the tty layer then we can't
 152            process it here. Instead set a flag and the flush_to_ldisc
 153            path will process the flush request before it exits */
 154         if (test_bit(TTYP_FLUSHING, &port->iflags)) {
 155                 set_bit(TTYP_FLUSHPENDING, &port->iflags);
 156                 spin_unlock_irqrestore(&buf->lock, flags);
 157                 wait_event(tty->read_wait,
 158                                 test_bit(TTYP_FLUSHPENDING, &port->iflags) == 0);
 159                 return;
 160         } else
 161                 __tty_buffer_flush(port);
 162         spin_unlock_irqrestore(&buf->lock, flags);
 163 }
 164
 165 /**
 166  *      tty_buffer_find         -       find a free tty buffer
 167  *      @tty: tty owning the buffer
 168  *      @size: characters wanted
 169  *
 170  *      Locate an existing suitable tty buffer or if we are lacking one then
 171  *      allocate a new one. We round our buffers off in 256 character chunks
 172  *      to get better allocation behaviour.
 173  *
 174  *      Locking: Caller must hold tty->buf.lock
 175  */
 176
 177 static struct tty_buffer *tty_buffer_find(struct tty_port *port, size_t size)
 178 {
 179         struct tty_buffer **tbh = &port->buf.free;
 180         while ((*tbh) != NULL) {
 181                 struct tty_buffer *t = *tbh;
 182                 if (t->size >= size) {
 183                         *tbh = t->next;
 184                         t->next = NULL;
 185                         t->used = 0;
 186                         t->commit = 0;
 187                         t->read = 0;
 188                         port->buf.memory_used += t->size;
 189                         return t;
 190                 }
 191                 tbh = &((*tbh)->next);
 192         }
 193         /* Round the buffer size out */
 194         size = (size + 0xFF) & ~0xFF;
 195         return tty_buffer_alloc(port, size);
 196         /* Should possibly check if this fails for the largest buffer we
 197            have queued and recycle that ? */
 198 }
 199 /**
 200  *      tty_buffer_request_room         -       grow tty buffer if needed
 201  *      @tty: tty structure
 202  *      @size: size desired
 203  *
 204  *      Make at least size bytes of linear space available for the tty
 205  *      buffer. If we fail return the size we managed to find.
 206  *
 207  *      Locking: Takes port->buf.lock
 208  */
 209 int tty_buffer_request_room(struct tty_port *port, size_t size)
 210 {
 211         struct tty_bufhead *buf = &port->buf;
 212         struct tty_buffer *b, *n;
 213         int left;
 214         unsigned long flags;
 215         spin_lock_irqsave(&buf->lock, flags);
 216         /* OPTIMISATION: We could keep a per tty "zero" sized buffer to
 217            remove this conditional if its worth it. This would be invisible
 218            to the callers */
 219         b = buf->tail;
 220         if (b != NULL)
 221                 left = b->size - b->used;
 222         else
 223                 left = 0;
 224
 225         if (left < size) {
 226                 /* This is the slow path - looking for new buffers to use */
 227                 if ((n = tty_buffer_find(port, size)) != NULL) {
 228                         if (b != NULL) {
 229                                 b->next = n;
 230                                 b->commit = b->used;
 231                         } else
 232                                 buf->head = n;
 233                         buf->tail = n;
 234                 } else
 235                         size = left;
 236         }
 237         spin_unlock_irqrestore(&buf->lock, flags);
 238         return size;
 239 }
 240 EXPORT_SYMBOL_GPL(tty_buffer_request_room);
 241
 242 /**
 243  *      tty_insert_flip_string_fixed_flag - Add characters to the tty buffer
 244  *      @port: tty port
 245  *      @chars: characters
 246  *      @flag: flag value for each character
 247  *      @size: size
 248  *
 249  *      Queue a series of bytes to the tty buffering. All the characters
 250  *      passed are marked with the supplied flag. Returns the number added.
 251  *
 252  *      Locking: Called functions may take port->buf.lock
 253  */
 254
 255 int tty_insert_flip_string_fixed_flag(struct tty_port *port,
 256                 const unsigned char *chars, char flag, size_t size)
 257 {
 258         int copied = 0;
 259         do {
 260                 int goal = min_t(size_t, size - copied, TTY_BUFFER_PAGE);
 261                 int space = tty_buffer_request_room(port, goal);
 262                 struct tty_buffer *tb = port->buf.tail;
 263                 /* If there is no space then tb may be NULL */
 264                 if (unlikely(space == 0)) {
 265                         break;
 266                 }
 267                 memcpy(tb->char_buf_ptr + tb->used, chars, space);
 268                 memset(tb->flag_buf_ptr + tb->used, flag, space);
 269                 tb->used += space;
 270                 copied += space;
 271                 chars += space;
 272                 /* There is a small chance that we need to split the data over
 273                    several buffers. If this is the case we must loop */
 274         } while (unlikely(size > copied));
 275         return copied;
 276 }
 277 EXPORT_SYMBOL(tty_insert_flip_string_fixed_flag);
 278
 279 /**
 280  *      tty_insert_flip_string_flags    -       Add characters to the tty buffer
 281  *      @port: tty port
 282  *      @chars: characters
 283  *      @flags: flag bytes
 284  *      @size: size
 285  *
 286  *      Queue a series of bytes to the tty buffering. For each character
 287  *      the flags array indicates the status of the character. Returns the
 288  *      number added.
 289  *
 290  *      Locking: Called functions may take port->buf.lock
 291  */
 292
 293 int tty_insert_flip_string_flags(struct tty_port *port,
 294                 const unsigned char *chars, const char *flags, size_t size)
 295 {
 296         int copied = 0;
 297         do {
 298                 int goal = min_t(size_t, size - copied, TTY_BUFFER_PAGE);
 299                 int space = tty_buffer_request_room(port, goal);
 300                 struct tty_buffer *tb = port->buf.tail;
 301                 /* If there is no space then tb may be NULL */
 302                 if (unlikely(space == 0)) {
 303                         break;
 304                 }
 305                 memcpy(tb->char_buf_ptr + tb->used, chars, space);
 306                 memcpy(tb->flag_buf_ptr + 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  *      Locking: Takes port->buf.lock
 329  */
 330
 331 void tty_schedule_flip(struct tty_port *port)
 332 {
 333         struct tty_bufhead *buf = &port->buf;
 334         unsigned long flags;
 335         WARN_ON(port->low_latency);
 336
 337         spin_lock_irqsave(&buf->lock, flags);
 338         if (buf->tail != NULL)
 339                 buf->tail->commit = buf->tail->used;
 340         spin_unlock_irqrestore(&buf->lock, flags);
 341         schedule_work(&buf->work);
 342 }
 343 EXPORT_SYMBOL(tty_schedule_flip);
 344
 345 /**
 346  *      tty_prepare_flip_string         -       make room for characters
 347  *      @port: tty port
 348  *      @chars: return pointer for character write area
 349  *      @size: desired size
 350  *
 351  *      Prepare a block of space in the buffer for data. Returns the length
 352  *      available and buffer pointer to the space which is now allocated and
 353  *      accounted for as ready for normal characters. This is used for drivers
 354  *      that need their own block copy routines into the buffer. There is no
 355  *      guarantee the buffer is a DMA target!
 356  *
 357  *      Locking: May call functions taking port->buf.lock
 358  */
 359
 360 int tty_prepare_flip_string(struct tty_port *port, unsigned char **chars,
 361                 size_t size)
 362 {
 363         int space = tty_buffer_request_room(port, size);
 364         if (likely(space)) {
 365                 struct tty_buffer *tb = port->buf.tail;
 366                 *chars = tb->char_buf_ptr + tb->used;
 367                 memset(tb->flag_buf_ptr + tb->used, TTY_NORMAL, space);
 368                 tb->used += space;
 369         }
 370         return space;
 371 }
 372 EXPORT_SYMBOL_GPL(tty_prepare_flip_string);
 373
 374 /**
 375  *      tty_prepare_flip_string_flags   -       make room for characters
 376  *      @port: tty port
 377  *      @chars: return pointer for character write area
 378  *      @flags: return pointer for status flag write area
 379  *      @size: desired size
 380  *
 381  *      Prepare a block of space in the buffer for data. Returns the length
 382  *      available and buffer pointer to the space which is now allocated and
 383  *      accounted for as ready for characters. This is used for drivers
 384  *      that need their own block copy routines into the buffer. There is no
 385  *      guarantee the buffer is a DMA target!
 386  *
 387  *      Locking: May call functions taking port->buf.lock
 388  */
 389
 390 int tty_prepare_flip_string_flags(struct tty_port *port,
 391                         unsigned char **chars, char **flags, size_t size)
 392 {
 393         int space = tty_buffer_request_room(port, size);
 394         if (likely(space)) {
 395                 struct tty_buffer *tb = port->buf.tail;
 396                 *chars = tb->char_buf_ptr + tb->used;
 397                 *flags = tb->flag_buf_ptr + tb->used;
 398                 tb->used += space;
 399         }
 400         return space;
 401 }
 402 EXPORT_SYMBOL_GPL(tty_prepare_flip_string_flags);
 403
 404
 405
 406 /**
 407  *      flush_to_ldisc
 408  *      @work: tty structure passed from work queue.
 409  *
 410  *      This routine is called out of the software interrupt to flush data
 411  *      from the buffer chain to the line discipline.
 412  *
 413  *      Locking: holds tty->buf.lock to guard buffer list. Drops the lock
 414  *      while invoking the line discipline receive_buf method. The
 415  *      receive_buf method is single threaded for each tty instance.
 416  */
 417
 418 static void flush_to_ldisc(struct work_struct *work)
 419 {
 420         struct tty_port *port = container_of(work, struct tty_port, buf.work);
 421         struct tty_bufhead *buf = &port->buf;
 422         struct tty_struct *tty;
 423         unsigned long   flags;
 424         struct tty_ldisc *disc;
 425
 426         tty = port->itty;
 427         if (WARN_RATELIMIT(tty == NULL, "tty is NULL\n"))
 428                 return;
 429
 430         disc = tty_ldisc_ref(tty);
 431         if (disc == NULL)       /*  !TTY_LDISC */
 432                 return;
 433
 434         spin_lock_irqsave(&buf->lock, flags);
 435
 436         if (!test_and_set_bit(TTYP_FLUSHING, &port->iflags)) {
 437                 struct tty_buffer *head;
 438                 while ((head = buf->head) != NULL) {
 439                         int count;
 440                         char *char_buf;
 441                         unsigned char *flag_buf;
 442
 443                         count = head->commit - head->read;
 444                         if (!count) {
 445                                 if (head->next == NULL)
 446                                         break;
 447                                 buf->head = head->next;
 448                                 tty_buffer_free(port, head);
 449                                 continue;
 450                         }
 451                         /* Ldisc or user is trying to flush the buffers
 452                            we are feeding to the ldisc, stop feeding the
 453                            line discipline as we want to empty the queue */
 454                         if (test_bit(TTYP_FLUSHPENDING, &port->iflags))
 455                                 break;
 456                         if (!tty->receive_room)
 457                                 break;
 458                         if (count > tty->receive_room)
 459                                 count = tty->receive_room;
 460                         char_buf = head->char_buf_ptr + head->read;
 461                         flag_buf = head->flag_buf_ptr + head->read;
 462                         head->read += count;
 463                         spin_unlock_irqrestore(&buf->lock, flags);
 464                         disc->ops->receive_buf(tty, char_buf,
 465                                                         flag_buf, count);
 466                         spin_lock_irqsave(&buf->lock, flags);
 467                 }
 468                 clear_bit(TTYP_FLUSHING, &port->iflags);
 469         }
 470
 471         /* We may have a deferred request to flush the input buffer,
 472            if so pull the chain under the lock and empty the queue */
 473         if (test_bit(TTYP_FLUSHPENDING, &port->iflags)) {
 474                 __tty_buffer_flush(port);
 475                 clear_bit(TTYP_FLUSHPENDING, &port->iflags);
 476                 wake_up(&tty->read_wait);
 477         }
 478         spin_unlock_irqrestore(&buf->lock, flags);
 479
 480         tty_ldisc_deref(disc);
 481 }
 482
 483 /**
 484  *      tty_flush_to_ldisc
 485  *      @tty: tty to push
 486  *
 487  *      Push the terminal flip buffers to the line discipline.
 488  *
 489  *      Must not be called from IRQ context.
 490  */
 491 void tty_flush_to_ldisc(struct tty_struct *tty)
 492 {
 493         if (!tty->port->low_latency)
 494                 flush_work(&tty->port->buf.work);
 495 }
 496
 497 /**
 498  *      tty_flip_buffer_push    -       terminal
 499  *      @port: tty port to push
 500  *
 501  *      Queue a push of the terminal flip buffers to the line discipline. This
 502  *      function must not be called from IRQ context if port->low_latency is
 503  *      set.
 504  *
 505  *      In the event of the queue being busy for flipping the work will be
 506  *      held off and retried later.
 507  *
 508  *      Locking: tty buffer lock. Driver locks in low latency mode.
 509  */
 510
 511 void tty_flip_buffer_push(struct tty_port *port)
 512 {
 513         struct tty_bufhead *buf = &port->buf;
 514         unsigned long flags;
 515
 516         spin_lock_irqsave(&buf->lock, flags);
 517         if (buf->tail != NULL)
 518                 buf->tail->commit = buf->tail->used;
 519         spin_unlock_irqrestore(&buf->lock, flags);
 520
 521         if (port->low_latency)
 522                 flush_to_ldisc(&buf->work);
 523         else
 524                 schedule_work(&buf->work);
 525 }
 526 EXPORT_SYMBOL(tty_flip_buffer_push);
 527
 528 /**
 529  *      tty_buffer_init         -       prepare a tty buffer structure
 530  *      @tty: tty to initialise
 531  *
 532  *      Set up the initial state of the buffer management for a tty device.
 533  *      Must be called before the other tty buffer functions are used.
 534  *
 535  *      Locking: none
 536  */
 537
 538 void tty_buffer_init(struct tty_port *port)
 539 {
 540         struct tty_bufhead *buf = &port->buf;
 541
 542         spin_lock_init(&buf->lock);
 543         buf->head = NULL;
 544         buf->tail = NULL;
 545         buf->free = NULL;
 546         buf->memory_used = 0;
 547         INIT_WORK(&buf->work, flush_to_ldisc);
 548 }
 549