Skip to content

Commit

Permalink
virtio_console: Merge struct buffer_token into struct port_buffer
Browse files Browse the repository at this point in the history 
Refactoring the splice functionality by unifying the approach for
sending scatter-lists and regular buffers. This simplifies
buffer handling and reduces code size. Splice will now allocate
a port_buffer and send_buf() and free_buf() can always be used
for any buffer.

Signed-off-by: Sjur Brændeland <sjur.brandeland@stericsson.com>
Acked-by: Amit Shah <amit.shah@redhat.com>
Signed-off-by: Rusty Russell <rusty@rustcorp.com.au>
  • Loading branch information
Sjur Brændeland authored and Rusty Russell committed Dec 18, 2012
1 parent 9a2bdcc commit 276a3e9
Showing 1 changed file with 53 additions and 76 deletions.
129 changes: 53 additions & 76 deletions drivers/char/virtio_console.c
View file
Original file line number Diff line number Diff line change
Expand Up @@ -111,6 +111,12 @@ struct port_buffer {
size_t len;
/* offset in the buf from which to consume data */
size_t offset;

/* If sgpages == 0 then buf is used */
unsigned int sgpages;

/* sg is used if spages > 0. sg must be the last in is struct */
struct scatterlist sg[0];
};

/*
Expand Down Expand Up @@ -338,17 +344,39 @@ static inline bool use_multiport(struct ports_device *portdev)

static void free_buf(struct port_buffer *buf)
{
unsigned int i;

kfree(buf->buf);
for (i = 0; i < buf->sgpages; i++) {
struct page *page = sg_page(&buf->sg[i]);
if (!page)
break;
put_page(page);
}

kfree(buf);
}

static struct port_buffer *alloc_buf(size_t buf_size)
static struct port_buffer *alloc_buf(struct virtqueue *vq, size_t buf_size,
int pages)
{
struct port_buffer *buf;

buf = kmalloc(sizeof(*buf), GFP_KERNEL);
/*
* Allocate buffer and the sg list. The sg list array is allocated
* directly after the port_buffer struct.
*/
buf = kmalloc(sizeof(*buf) + sizeof(struct scatterlist) * pages,
GFP_KERNEL);
if (!buf)
goto fail;

buf->sgpages = pages;
if (pages > 0) {
buf->buf = NULL;
return buf;
}

buf->buf = kmalloc(buf_size, GFP_KERNEL);
if (!buf->buf)
goto free_buf;
Expand Down Expand Up @@ -478,52 +506,26 @@ static ssize_t send_control_msg(struct port *port, unsigned int event,
return 0;
}

struct buffer_token {
union {
void *buf;
struct scatterlist *sg;
} u;
/* If sgpages == 0 then buf is used, else sg is used */
unsigned int sgpages;
};

static void reclaim_sg_pages(struct scatterlist *sg, unsigned int nrpages)
{
int i;
struct page *page;

for (i = 0; i < nrpages; i++) {
page = sg_page(&sg[i]);
if (!page)
break;
put_page(page);
}
kfree(sg);
}

/* Callers must take the port->outvq_lock */
static void reclaim_consumed_buffers(struct port *port)
{
struct buffer_token *tok;
struct port_buffer *buf;
unsigned int len;

if (!port->portdev) {
/* Device has been unplugged. vqs are already gone. */
return;
}
while ((tok = virtqueue_get_buf(port->out_vq, &len))) {
if (tok->sgpages)
reclaim_sg_pages(tok->u.sg, tok->sgpages);
else
kfree(tok->u.buf);
kfree(tok);
while ((buf = virtqueue_get_buf(port->out_vq, &len))) {
free_buf(buf);
port->outvq_full = false;
}
}

static ssize_t __send_to_port(struct port *port, struct scatterlist *sg,
int nents, size_t in_count,
struct buffer_token *tok, bool nonblock)
void *data, bool nonblock)
{
struct virtqueue *out_vq;
int err;
Expand All @@ -536,7 +538,7 @@ static ssize_t __send_to_port(struct port *port, struct scatterlist *sg,

reclaim_consumed_buffers(port);

err = virtqueue_add_buf(out_vq, sg, nents, 0, tok, GFP_ATOMIC);
err = virtqueue_add_buf(out_vq, sg, nents, 0, data, GFP_ATOMIC);

/* Tell Host to go! */
virtqueue_kick(out_vq);
Expand Down Expand Up @@ -574,37 +576,6 @@ static ssize_t __send_to_port(struct port *port, struct scatterlist *sg,
return in_count;
}

static ssize_t send_buf(struct port *port, void *in_buf, size_t in_count,
bool nonblock)
{
struct scatterlist sg[1];
struct buffer_token *tok;

tok = kmalloc(sizeof(*tok), GFP_ATOMIC);
if (!tok)
return -ENOMEM;
tok->sgpages = 0;
tok->u.buf = in_buf;

sg_init_one(sg, in_buf, in_count);

return __send_to_port(port, sg, 1, in_count, tok, nonblock);
}

static ssize_t send_pages(struct port *port, struct scatterlist *sg, int nents,
size_t in_count, bool nonblock)
{
struct buffer_token *tok;

tok = kmalloc(sizeof(*tok), GFP_ATOMIC);
if (!tok)
return -ENOMEM;
tok->sgpages = nents;
tok->u.sg = sg;

return __send_to_port(port, sg, nents, in_count, tok, nonblock);
}

/*
* Give out the data that's requested from the buffer that we have
* queued up.
Expand Down Expand Up @@ -750,9 +721,10 @@ static ssize_t port_fops_write(struct file *filp, const char __user *ubuf,
size_t count, loff_t *offp)
{
struct port *port;
char *buf;
struct port_buffer *buf;
ssize_t ret;
bool nonblock;
struct scatterlist sg[1];

/* Userspace could be out to fool us */
if (!count)
Expand All @@ -768,11 +740,11 @@ static ssize_t port_fops_write(struct file *filp, const char __user *ubuf,

count = min((size_t)(32 * 1024), count);

buf = kmalloc(count, GFP_KERNEL);
buf = alloc_buf(port->out_vq, count, 0);
if (!buf)
return -ENOMEM;

ret = copy_from_user(buf, ubuf, count);
ret = copy_from_user(buf->buf, ubuf, count);
if (ret) {
ret = -EFAULT;
goto free_buf;
Expand All @@ -786,13 +758,14 @@ static ssize_t port_fops_write(struct file *filp, const char __user *ubuf,
* through to the host.
*/
nonblock = true;
ret = send_buf(port, buf, count, nonblock);
sg_init_one(sg, buf->buf, count);
ret = __send_to_port(port, sg, 1, count, buf, nonblock);

if (nonblock && ret > 0)
goto out;

free_buf:
kfree(buf);
free_buf(buf);
out:
return ret;
}
Expand Down Expand Up @@ -858,6 +831,7 @@ static ssize_t port_fops_splice_write(struct pipe_inode_info *pipe,
struct port *port = filp->private_data;
struct sg_list sgl;
ssize_t ret;
struct port_buffer *buf;
struct splice_desc sd = {
.total_len = len,
.flags = flags,
Expand All @@ -869,17 +843,18 @@ static ssize_t port_fops_splice_write(struct pipe_inode_info *pipe,
if (ret < 0)
return ret;

buf = alloc_buf(port->out_vq, 0, pipe->nrbufs);
if (!buf)
return -ENOMEM;

sgl.n = 0;
sgl.len = 0;
sgl.size = pipe->nrbufs;
sgl.sg = kmalloc(sizeof(struct scatterlist) * sgl.size, GFP_KERNEL);
if (unlikely(!sgl.sg))
return -ENOMEM;

sgl.sg = buf->sg;
sg_init_table(sgl.sg, sgl.size);
ret = __splice_from_pipe(pipe, &sd, pipe_to_sg);
if (likely(ret > 0))
ret = send_pages(port, sgl.sg, sgl.n, sgl.len, true);
ret = __send_to_port(port, buf->sg, sgl.n, sgl.len, buf, true);

if (unlikely(ret <= 0))
kfree(sgl.sg);
Expand Down Expand Up @@ -1035,6 +1010,7 @@ static const struct file_operations port_fops = {
static int put_chars(u32 vtermno, const char *buf, int count)
{
struct port *port;
struct scatterlist sg[1];

if (unlikely(early_put_chars))
return early_put_chars(vtermno, buf, count);
Expand All @@ -1043,7 +1019,8 @@ static int put_chars(u32 vtermno, const char *buf, int count)
if (!port)
return -EPIPE;

return send_buf(port, (void *)buf, count, false);
sg_init_one(sg, buf, count);
return __send_to_port(port, sg, 1, count, (void *)buf, false);
}

/*
Expand Down Expand Up @@ -1264,7 +1241,7 @@ static unsigned int fill_queue(struct virtqueue *vq, spinlock_t *lock)

nr_added_bufs = 0;
do {
buf = alloc_buf(PAGE_SIZE);
buf = alloc_buf(vq, PAGE_SIZE, 0);
if (!buf)
break;

Expand Down

0 comments on commit 276a3e9

Please sign in to comment.