cregit-Linux how code gets into the kernel

Release 4.14 drivers/tty/tty_buffer.c

Directory: drivers/tty
/*
 * Tty buffer allocation management
 */

#include <linux/types.h>
#include <linux/errno.h>
#include <linux/tty.h>
#include <linux/tty_driver.h>
#include <linux/tty_flip.h>
#include <linux/timer.h>
#include <linux/string.h>
#include <linux/slab.h>
#include <linux/sched.h>
#include <linux/wait.h>
#include <linux/bitops.h>
#include <linux/delay.h>
#include <linux/module.h>
#include <linux/ratelimit.h>



#define MIN_TTYB_SIZE	256

#define TTYB_ALIGN_MASK	255

/*
 * Byte threshold to limit memory consumption for flip buffers.
 * The actual memory limit is > 2x this amount.
 */

#define TTYB_DEFAULT_MEM_LIMIT	65536

/*
 * We default to dicing tty buffer allocations to this many characters
 * in order to avoid multiple page allocations. We know the size of
 * tty_buffer itself but it must also be taken into account that the
 * the buffer is 256 byte aligned. See tty_buffer_find for the allocation
 * logic this must match
 */


#define TTY_BUFFER_PAGE	(((PAGE_SIZE - sizeof(struct tty_buffer)) / 2) & ~0xFF)

/**
 *      tty_buffer_lock_exclusive       -       gain exclusive access to buffer
 *      tty_buffer_unlock_exclusive     -       release exclusive access
 *
 *      @port - tty_port owning the flip buffer
 *
 *      Guarantees safe use of the line discipline's receive_buf() method by
 *      excluding the buffer work and any pending flush from using the flip
 *      buffer. Data can continue to be added concurrently to the flip buffer
 *      from the driver side.
 *
 *      On release, the buffer work is restarted if there is data in the
 *      flip buffer
 */


void tty_buffer_lock_exclusive(struct tty_port *port) { struct tty_bufhead *buf = &port->buf; atomic_inc(&buf->priority); mutex_lock(&buf->lock); }

Contributors

PersonTokensPropCommitsCommitProp
Peter Hurley36100.00%1100.00%
Total36100.00%1100.00%

EXPORT_SYMBOL_GPL(tty_buffer_lock_exclusive);
void tty_buffer_unlock_exclusive(struct tty_port *port) { struct tty_bufhead *buf = &port->buf; int restart; restart = buf->head->commit != buf->head->read; atomic_dec(&buf->priority); mutex_unlock(&buf->lock); if (restart) queue_work(system_unbound_wq, &buf->work); }

Contributors

PersonTokensPropCommitsCommitProp
Peter Hurley67100.00%1100.00%
Total67100.00%1100.00%

EXPORT_SYMBOL_GPL(tty_buffer_unlock_exclusive); /** * tty_buffer_space_avail - return unused buffer space * @port - tty_port owning the flip buffer * * Returns the # of bytes which can be written by the driver without * reaching the buffer limit. * * Note: this does not guarantee that memory is available to write * the returned # of bytes (use tty_prepare_flip_string_xxx() to * pre-allocate if memory guarantee is required). */
int tty_buffer_space_avail(struct tty_port *port) { int space = port->buf.mem_limit - atomic_read(&port->buf.mem_used); return max(space, 0); }

Contributors

PersonTokensPropCommitsCommitProp
Peter Hurley37100.00%3100.00%
Total37100.00%3100.00%

EXPORT_SYMBOL_GPL(tty_buffer_space_avail);
static void tty_buffer_reset(struct tty_buffer *p, size_t size) { p->used = 0; p->size = size; p->next = NULL; p->commit = 0; p->read = 0; p->flags = 0; }

Contributors

PersonTokensPropCommitsCommitProp
Peter Hurley50100.00%2100.00%
Total50100.00%2100.00%

/** * tty_buffer_free_all - free buffers used by a tty * @tty: tty to free from * * Remove all the buffers pending on a tty whether queued with data * or in the free ring. Must be called when the tty is no longer in use */
void tty_buffer_free_all(struct tty_port *port) { struct tty_bufhead *buf = &port->buf; struct tty_buffer *p, *next; struct llist_node *llist; while ((p = buf->head) != NULL) { buf->head = p->next; if (p->size > 0) kfree(p); } llist = llist_del_all(&buf->free); llist_for_each_entry_safe(p, next, llist, free) kfree(p); tty_buffer_reset(&buf->sentinel, 0); buf->head = &buf->sentinel; buf->tail = &buf->sentinel; atomic_set(&buf->mem_used, 0); }

Contributors

PersonTokensPropCommitsCommitProp
Peter Hurley6549.62%562.50%
Alan Cox4937.40%112.50%
Jiri Slaby1712.98%225.00%
Total131100.00%8100.00%

/** * tty_buffer_alloc - allocate a tty buffer * @tty: tty device * @size: desired size (characters) * * Allocate a new tty buffer to hold the desired number of characters. * We round our buffers off in 256 character chunks to get better * allocation behaviour. * Return NULL if out of memory or the allocation would exceed the * per device queue */
static struct tty_buffer *tty_buffer_alloc(struct tty_port *port, size_t size) { struct llist_node *free; struct tty_buffer *p; /* Round the buffer size out */ size = __ALIGN_MASK(size, TTYB_ALIGN_MASK); if (size <= MIN_TTYB_SIZE) { free = llist_del_first(&port->buf.free); if (free) { p = llist_entry(free, struct tty_buffer, free); goto found; } } /* Should possibly check if this fails for the largest buffer we have queued and recycle that ? */ if (atomic_read(&port->buf.mem_used) > port->buf.mem_limit) return NULL; p = kmalloc(sizeof(struct tty_buffer) + 2 * size, GFP_ATOMIC); if (p == NULL) return NULL; found: tty_buffer_reset(p, size); atomic_add(size, &port->buf.mem_used); return p; }

Contributors

PersonTokensPropCommitsCommitProp
Peter Hurley8255.03%675.00%
Alan Cox6342.28%112.50%
Jiri Slaby42.68%112.50%
Total149100.00%8100.00%

/** * tty_buffer_free - free a tty buffer * @tty: tty owning the buffer * @b: the buffer to free * * Free a tty buffer, or add it to the free list according to our * internal strategy */
static void tty_buffer_free(struct tty_port *port, struct tty_buffer *b) { struct tty_bufhead *buf = &port->buf; /* Dumb strategy for now - should keep some stats */ WARN_ON(atomic_sub_return(b->size, &buf->mem_used) < 0); if (b->size > MIN_TTYB_SIZE) kfree(b); else if (b->size > 0) llist_add(&b->free, &buf->free); }

Contributors

PersonTokensPropCommitsCommitProp
Alan Cox4151.90%112.50%
Peter Hurley2531.65%562.50%
Jiri Slaby1316.46%225.00%
Total79100.00%8100.00%

/** * tty_buffer_flush - flush full tty buffers * @tty: tty to flush * @ld: optional ldisc ptr (must be referenced) * * flush all the buffers containing receive data. If ld != NULL, * flush the ldisc input buffer. * * Locking: takes buffer lock to ensure single-threaded flip buffer * 'consumer' */
void tty_buffer_flush(struct tty_struct *tty, struct tty_ldisc *ld) { struct tty_port *port = tty->port; struct tty_bufhead *buf = &port->buf; struct tty_buffer *next; atomic_inc(&buf->priority); mutex_lock(&buf->lock); /* paired w/ release in __tty_buffer_request_room; ensures there are * no pending memory accesses to the freed buffer */ while ((next = smp_load_acquire(&buf->head->next)) != NULL) { tty_buffer_free(port, buf->head); buf->head = next; } buf->head->read = buf->head->commit; if (ld && ld->ops->flush_buffer) ld->ops->flush_buffer(tty); atomic_dec(&buf->priority); mutex_unlock(&buf->lock); }

Contributors

PersonTokensPropCommitsCommitProp
Peter Hurley6345.65%654.55%
Alan Cox3626.09%19.09%
Ilya Zykov2014.49%19.09%
Jiri Slaby1410.14%218.18%
Dmitriy Vyukov53.62%19.09%
Total138100.00%11100.00%

/** * tty_buffer_request_room - grow tty buffer if needed * @tty: tty structure * @size: size desired * @flags: buffer flags if new buffer allocated (default = 0) * * Make at least size bytes of linear space available for the tty * buffer. If we fail return the size we managed to find. * * Will change over to a new buffer if the current buffer is encoded as * TTY_NORMAL (so has no flags buffer) and the new buffer requires * a flags buffer. */
static int __tty_buffer_request_room(struct tty_port *port, size_t size, int flags) { struct tty_bufhead *buf = &port->buf; struct tty_buffer *b, *n; int left, change; b = buf->tail; if (b->flags & TTYB_NORMAL) left = 2 * b->size - b->used; else left = b->size - b->used; change = (b->flags & TTYB_NORMAL) && (~flags & TTYB_NORMAL); if (change || left < size) { /* This is the slow path - looking for new buffers to use */ n = tty_buffer_alloc(port, size); if (n != NULL) { n->flags = flags; buf->tail = n; /* paired w/ acquire in flush_to_ldisc(); ensures * flush_to_ldisc() sees buffer data. */ smp_store_release(&b->commit, b->used); /* paired w/ acquire in flush_to_ldisc(); ensures the * latest commit value can be read before the head is * advanced to the next buffer */ smp_store_release(&b->next, n); } else if (change) size = 0; else size = left; } return size; }

Contributors

PersonTokensPropCommitsCommitProp
Alan Cox7542.86%110.00%
Peter Hurley7341.71%440.00%
Jiri Slaby169.14%220.00%
Dmitriy Vyukov63.43%110.00%
Greg Kroah-Hartman42.29%110.00%
Ilya Zykov10.57%110.00%
Total175100.00%10100.00%


int tty_buffer_request_room(struct tty_port *port, size_t size) { return __tty_buffer_request_room(port, size, 0); }

Contributors

PersonTokensPropCommitsCommitProp
Peter Hurley23100.00%1100.00%
Total23100.00%1100.00%

EXPORT_SYMBOL_GPL(tty_buffer_request_room); /** * tty_insert_flip_string_fixed_flag - Add characters to the tty buffer * @port: tty port * @chars: characters * @flag: flag value for each character * @size: size * * Queue a series of bytes to the tty buffering. All the characters * passed are marked with the supplied flag. Returns the number added. */
int tty_insert_flip_string_fixed_flag(struct tty_port *port, const unsigned char *chars, char flag, size_t size) { int copied = 0; do { int goal = min_t(size_t, size - copied, TTY_BUFFER_PAGE); int flags = (flag == TTY_NORMAL) ? TTYB_NORMAL : 0; int space = __tty_buffer_request_room(port, goal, flags); struct tty_buffer *tb = port->buf.tail; if (unlikely(space == 0)) break; memcpy(char_buf_ptr(tb, tb->used), chars, space); if (~tb->flags & TTYB_NORMAL) memset(flag_buf_ptr(tb, tb->used), flag, space); tb->used += space; copied += space; chars += space; /* There is a small chance that we need to split the data over several buffers. If this is the case we must loop */ } while (unlikely(size > copied)); return copied; }

Contributors

PersonTokensPropCommitsCommitProp
Alan Cox10968.55%330.00%
Peter Hurley3320.75%220.00%
Ilya Zykov106.29%110.00%
Jiri Slaby42.52%330.00%
Fang Wenqi31.89%110.00%
Total159100.00%10100.00%

EXPORT_SYMBOL(tty_insert_flip_string_fixed_flag); /** * tty_insert_flip_string_flags - Add characters to the tty buffer * @port: tty port * @chars: characters * @flags: flag bytes * @size: size * * Queue a series of bytes to the tty buffering. For each character * the flags array indicates the status of the character. Returns the * number added. */
int tty_insert_flip_string_flags(struct tty_port *port, const unsigned char *chars, const char *flags, size_t size) { int copied = 0; do { int goal = min_t(size_t, size - copied, TTY_BUFFER_PAGE); int space = tty_buffer_request_room(port, goal); struct tty_buffer *tb = port->buf.tail; if (unlikely(space == 0)) break; memcpy(char_buf_ptr(tb, tb->used), chars, space); memcpy(flag_buf_ptr(tb, tb->used), flags, space); tb->used += space; copied += space; chars += space; flags += space; /* There is a small chance that we need to split the data over several buffers. If this is the case we must loop */ } while (unlikely(size > copied)); return copied; }

Contributors

PersonTokensPropCommitsCommitProp
Alan Cox11581.56%225.00%
Ilya Zykov117.80%112.50%
Peter Hurley85.67%112.50%
Jiri Slaby42.84%337.50%
Fang Wenqi32.13%112.50%
Total141100.00%8100.00%

EXPORT_SYMBOL(tty_insert_flip_string_flags); /** * __tty_insert_flip_char - Add one character to the tty buffer * @port: tty port * @ch: character * @flag: flag byte * * Queue a single byte to the tty buffering, with an optional flag. * This is the slow path of tty_insert_flip_char. */
int __tty_insert_flip_char(struct tty_port *port, unsigned char ch, char flag) { struct tty_buffer *tb; int flags = (flag == TTY_NORMAL) ? TTYB_NORMAL : 0; if (!__tty_buffer_request_room(port, 1, flags)) return 0; tb = port->buf.tail; if (~tb->flags & TTYB_NORMAL) *flag_buf_ptr(tb, tb->used) = flag; *char_buf_ptr(tb, tb->used++) = ch; return 1; }

Contributors

PersonTokensPropCommitsCommitProp
Arnd Bergmann95100.00%3100.00%
Total95100.00%3100.00%

EXPORT_SYMBOL(__tty_insert_flip_char); /** * tty_schedule_flip - push characters to ldisc * @port: tty port to push from * * Takes any pending buffers and transfers their ownership to the * ldisc side of the queue. It then schedules those characters for * processing by the line discipline. */
void tty_schedule_flip(struct tty_port *port) { struct tty_bufhead *buf = &port->buf; /* paired w/ acquire in flush_to_ldisc(); ensures * flush_to_ldisc() sees buffer data. */ smp_store_release(&buf->tail->commit, buf->tail->used); queue_work(system_unbound_wq, &buf->work); }

Contributors

PersonTokensPropCommitsCommitProp
Alan Cox2348.94%116.67%
Jiri Slaby1531.91%350.00%
Dmitriy Vyukov612.77%116.67%
Peter Hurley36.38%116.67%
Total47100.00%6100.00%

EXPORT_SYMBOL(tty_schedule_flip); /** * tty_prepare_flip_string - make room for characters * @port: tty port * @chars: return pointer for character write area * @size: desired size * * Prepare a block of space in the buffer for data. Returns the length * available and buffer pointer to the space which is now allocated and * accounted for as ready for normal characters. This is used for drivers * that need their own block copy routines into the buffer. There is no * guarantee the buffer is a DMA target! */
int tty_prepare_flip_string(struct tty_port *port, unsigned char **chars, size_t size) { int space = __tty_buffer_request_room(port, size, TTYB_NORMAL); if (likely(space)) { struct tty_buffer *tb = port->buf.tail; *chars = char_buf_ptr(tb, tb->used); if (~tb->flags & TTYB_NORMAL) memset(flag_buf_ptr(tb, tb->used), TTY_NORMAL, space); tb->used += space; } return space; }

Contributors

PersonTokensPropCommitsCommitProp
Alan Cox6162.89%116.67%
Peter Hurley2020.62%233.33%
Ilya Zykov1313.40%116.67%
Jiri Slaby33.09%233.33%
Total97100.00%6100.00%

EXPORT_SYMBOL_GPL(tty_prepare_flip_string); /** * tty_ldisc_receive_buf - forward data to line discipline * @ld: line discipline to process input * @p: char buffer * @f: TTY_* flags buffer * @count: number of bytes to process * * Callers other than flush_to_ldisc() need to exclude the kworker * from concurrent use of the line discipline, see paste_selection(). * * Returns the number of bytes not processed */
int tty_ldisc_receive_buf(struct tty_ldisc *ld, const unsigned char *p, char *f, int count) { if (ld->ops->receive_buf2) count = ld->ops->receive_buf2(ld->tty, p, f, count); else { count = min_t(int, count, ld->tty->receive_room); if (count && ld->ops->receive_buf) ld->ops->receive_buf(ld->tty, p, f, count); } return count; }

Contributors

PersonTokensPropCommitsCommitProp
Peter Hurley9798.98%583.33%
Rob Herring11.02%116.67%
Total98100.00%6100.00%

EXPORT_SYMBOL_GPL(tty_ldisc_receive_buf);
static int receive_buf(struct tty_port *port, struct tty_buffer *head, int count) { unsigned char *p = char_buf_ptr(head, head->read); char *f = NULL; if (~head->flags & TTYB_NORMAL) f = flag_buf_ptr(head, head->read); return port->client_ops->receive_buf(port, p, f, count); }

Contributors

PersonTokensPropCommitsCommitProp
Peter Hurley6789.33%150.00%
Rob Herring810.67%150.00%
Total75100.00%2100.00%

/** * flush_to_ldisc * @work: tty structure passed from work queue. * * This routine is called out of the software interrupt to flush data * from the buffer chain to the line discipline. * * The receive_buf method is single threaded for each tty instance. * * Locking: takes buffer lock to ensure single-threaded flip buffer * 'consumer' */
static void flush_to_ldisc(struct work_struct *work) { struct tty_port *port = container_of(work, struct tty_port, buf.work); struct tty_bufhead *buf = &port->buf; mutex_lock(&buf->lock); while (1) { struct tty_buffer *head = buf->head; struct tty_buffer *next; int count; /* Ldisc or user is trying to gain exclusive access */ if (atomic_read(&buf->priority)) break; /* paired w/ release in __tty_buffer_request_room(); * ensures commit value read is not stale if the head * is advancing to the next buffer */ next = smp_load_acquire(&head->next); /* paired w/ release in __tty_buffer_request_room() or in * tty_buffer_flush(); ensures we see the committed buffer data */ count = smp_load_acquire(&head->commit) - head->read; if (!count) { if (next == NULL) break; buf->head = next; tty_buffer_free(port, head); continue; } count = receive_buf(port, head, count); if (!count) break; head->read += count; } mutex_unlock(&buf->lock); }

Contributors

PersonTokensPropCommitsCommitProp
Alan Cox7746.39%15.88%
Peter Hurley5533.13%1058.82%
Jiri Slaby1810.84%317.65%
Linus Torvalds106.02%15.88%
Dmitriy Vyukov53.01%15.88%
Rob Herring10.60%15.88%
Total166100.00%17100.00%

/** * tty_flip_buffer_push - terminal * @port: tty port to push * * Queue a push of the terminal flip buffers to the line discipline. * Can be called from IRQ/atomic context. * * In the event of the queue being busy for flipping the work will be * held off and retried later. */
void tty_flip_buffer_push(struct tty_port *port) { tty_schedule_flip(port); }

Contributors

PersonTokensPropCommitsCommitProp
Alan Cox1173.33%133.33%
Peter Hurley213.33%133.33%
Jiri Slaby213.33%133.33%
Total15100.00%3100.00%

EXPORT_SYMBOL(tty_flip_buffer_push); /** * tty_buffer_init - prepare a tty buffer structure * @tty: tty to initialise * * Set up the initial state of the buffer management for a tty device. * Must be called before the other tty buffer functions are used. */
void tty_buffer_init(struct tty_port *port) { struct tty_bufhead *buf = &port->buf; mutex_init(&buf->lock); tty_buffer_reset(&buf->sentinel, 0); buf->head = &buf->sentinel; buf->tail = &buf->sentinel; init_llist_head(&buf->free); atomic_set(&buf->mem_used, 0); atomic_set(&buf->priority, 0); INIT_WORK(&buf->work, flush_to_ldisc); buf->mem_limit = TTYB_DEFAULT_MEM_LIMIT; }

Contributors

PersonTokensPropCommitsCommitProp
Peter Hurley4646.00%866.67%
Alan Cox3535.00%18.33%
Jiri Slaby1818.00%216.67%
Linus Torvalds11.00%18.33%
Total100100.00%12100.00%

/** * tty_buffer_set_limit - change the tty buffer memory limit * @port: tty port to change * * Change the tty buffer memory limit. * Must be called before the other tty buffer functions are used. */
int tty_buffer_set_limit(struct tty_port *port, int limit) { if (limit < MIN_TTYB_SIZE) return -EINVAL; port->buf.mem_limit = limit; return 0; }

Contributors

PersonTokensPropCommitsCommitProp
Peter Hurley34100.00%1100.00%
Total34100.00%1100.00%

EXPORT_SYMBOL_GPL(tty_buffer_set_limit); /* slave ptys can claim nested buffer lock when handling BRK and INTR */
void tty_buffer_set_lock_subclass(struct tty_port *port) { lockdep_set_subclass(&port->buf.lock, TTY_LOCK_SLAVE); }

Contributors

PersonTokensPropCommitsCommitProp
Peter Hurley22100.00%1100.00%
Total22100.00%1100.00%


bool tty_buffer_restart_work(struct tty_port *port) { return queue_work(system_unbound_wq, &port->buf.work); }

Contributors

PersonTokensPropCommitsCommitProp
Peter Hurley23100.00%1100.00%
Total23100.00%1100.00%


bool tty_buffer_cancel_work(struct tty_port *port) { return cancel_work_sync(&port->buf.work); }

Contributors

PersonTokensPropCommitsCommitProp
Peter Hurley21100.00%1100.00%
Total21100.00%1100.00%


void tty_buffer_flush_work(struct tty_port *port) { flush_work(&port->buf.work); }

Contributors

PersonTokensPropCommitsCommitProp
Brian Bloniarz20100.00%1100.00%
Total20100.00%1100.00%


Overall Contributors

PersonTokensPropCommitsCommitProp
Peter Hurley100246.89%3257.14%
Alan Cox76535.80%35.36%
Jiri Slaby1285.99%610.71%
Arnd Bergmann1014.73%35.36%
Ilya Zykov552.57%11.79%
Dmitriy Vyukov221.03%23.57%
Brian Bloniarz200.94%11.79%
Linus Torvalds110.51%23.57%
Rob Herring100.47%23.57%
Ben Hutchings100.47%11.79%
Fang Wenqi60.28%11.79%
Greg Kroah-Hartman40.19%11.79%
George Spelvin30.14%11.79%
Total2137100.00%56100.00%
Directory: drivers/tty
Information contained on this website is for historical information purposes only and does not indicate or represent copyright ownership.
Created with cregit.