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