OpenE2K
/
linux
6
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

net/9p: Remove MAX_9P_CHAN limit 

Use a list to track the channel instead of statically
allocated array

Signed-off-by: Aneesh Kumar K.V <aneesh.kumar@linux.vnet.ibm.com>
Signed-off-by: Eric Van Hensbergen <ericvh@gmail.com>
This commit is contained in:
Aneesh Kumar K.V 2010-02-15 17:27:01 +00:00 committed by Eric Van Hensbergen
parent f75580c4af
commit 37c1209d41
2 changed files with 27 additions and 46 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
include/linux/virtio_9p.h
View File

@ -5,7 +5,4 @@
#include <linux/virtio_ids.h> #include <linux/virtio_ids.h>
#include <linux/virtio_config.h> #include <linux/virtio_config.h>
/* Maximum number of virtio channels per partition (1 for now) */
#define MAX_9P_CHAN 10
#endif /* _LINUX_VIRTIO_9P_H */ #endif /* _LINUX_VIRTIO_9P_H */

70
net/9p/trans_virtio.c
View File

@ -49,8 +49,6 @@
/* a single mutex to manage channel initialization and attachment */ /* a single mutex to manage channel initialization and attachment */
static DEFINE_MUTEX(virtio_9p_lock); static DEFINE_MUTEX(virtio_9p_lock);
/* global which tracks highest initialized channel */
static int chan_index;
/** /**
* struct virtio_chan - per-instance transport information * struct virtio_chan - per-instance transport information
@ -68,8 +66,7 @@ static int chan_index;
* *
*/ */
static struct virtio_chan { struct virtio_chan {
bool initialized;
bool inuse; bool inuse;
spinlock_t lock; spinlock_t lock;
@ -80,7 +77,11 @@ static struct virtio_chan {
/* Scatterlist: can be too big for stack. */ /* Scatterlist: can be too big for stack. */
struct scatterlist sg[VIRTQUEUE_NUM]; struct scatterlist sg[VIRTQUEUE_NUM];
} channels[MAX_9P_CHAN];
struct list_head chan_list;
};
static struct list_head virtio_chan_list;
/* How many bytes left in this page. */ /* How many bytes left in this page. */
static unsigned int rest_of_page(void *data) static unsigned int rest_of_page(void *data)
@ -217,9 +218,7 @@ p9_virtio_request(struct p9_client *client, struct p9_req_t *req)
* p9_virtio_probe - probe for existence of 9P virtio channels * p9_virtio_probe - probe for existence of 9P virtio channels
* @vdev: virtio device to probe * @vdev: virtio device to probe
* *
* This probes for existing virtio channels. At present only * This probes for existing virtio channels.
* a single channel is in use, so in the future more work may need
* to be done here.
* *
*/ */
@ -227,16 +226,10 @@ static int p9_virtio_probe(struct virtio_device *vdev)
{ {
int err; int err;
struct virtio_chan *chan; struct virtio_chan *chan;
int index;
mutex_lock(&virtio_9p_lock); chan = kmalloc(sizeof(struct virtio_chan), GFP_KERNEL);
index = chan_index++; if (!chan) {
chan = &channels[index]; printk(KERN_ERR "9p: Failed to allocate virtio 9P channel\n");
mutex_unlock(&virtio_9p_lock);
if (chan_index > MAX_9P_CHAN) {
printk(KERN_ERR "9p: virtio: Maximum channels exceeded\n");
BUG();
err = -ENOMEM; err = -ENOMEM;
goto fail; goto fail;
} }
@ -255,15 +248,15 @@ static int p9_virtio_probe(struct virtio_device *vdev)
sg_init_table(chan->sg, VIRTQUEUE_NUM); sg_init_table(chan->sg, VIRTQUEUE_NUM);
chan->inuse = false; chan->inuse = false;
chan->initialized = true; mutex_lock(&virtio_9p_lock);
list_add_tail(&chan->chan_list, &virtio_chan_list);
mutex_unlock(&virtio_9p_lock);
return 0; return 0;
out_free_vq: out_free_vq:
vdev->config->del_vqs(vdev); vdev->config->del_vqs(vdev);
kfree(chan);
fail: fail:
mutex_lock(&virtio_9p_lock);
chan_index--;
mutex_unlock(&virtio_9p_lock);
return err; return err;
} }
@ -280,35 +273,27 @@ fail:
* We use a simple reference count mechanism to ensure that only a single * We use a simple reference count mechanism to ensure that only a single
* mount has a channel open at a time. * mount has a channel open at a time.
* *
* Bugs: doesn't allow identification of a specific channel
* to allocate, channels are allocated sequentially. This was
* a pragmatic decision to get things rolling, but ideally some
* way of identifying the channel to attach to would be nice
* if we are going to support multiple channels.
*
*/ */
static int static int
p9_virtio_create(struct p9_client *client, const char *devname, char *args) p9_virtio_create(struct p9_client *client, const char *devname, char *args)
{ {
struct virtio_chan *chan = channels; struct virtio_chan *chan;
int index = 0; int found = 0;
mutex_lock(&virtio_9p_lock); mutex_lock(&virtio_9p_lock);
while (index < MAX_9P_CHAN) { list_for_each_entry(chan, &virtio_chan_list, chan_list) {
if (chan->initialized && if (!strcmp(devname, dev_name(&chan->vdev->dev))) {
!strcmp(devname, dev_name(&chan->vdev->dev))) {
if (!chan->inuse) { if (!chan->inuse) {
chan->inuse = true; chan->inuse = true;
found = 1;
break; break;
} }
} }
index++;
chan = &channels[index];
} }
mutex_unlock(&virtio_9p_lock); mutex_unlock(&virtio_9p_lock);
if (index >= MAX_9P_CHAN) { if (!found) {
printk(KERN_ERR "9p: no channels available\n"); printk(KERN_ERR "9p: no channels available\n");
return -ENODEV; return -ENODEV;
} }
@ -331,11 +316,13 @@ static void p9_virtio_remove(struct virtio_device *vdev)
struct virtio_chan *chan = vdev->priv; struct virtio_chan *chan = vdev->priv;
BUG_ON(chan->inuse); BUG_ON(chan->inuse);
vdev->config->del_vqs(vdev);
mutex_lock(&virtio_9p_lock);
list_del(&chan->chan_list);
mutex_unlock(&virtio_9p_lock);
kfree(chan);
if (chan->initialized) {
vdev->config->del_vqs(vdev);
chan->initialized = false;
}
} }
static struct virtio_device_id id_table[] = { static struct virtio_device_id id_table[] = {
@ -366,10 +353,7 @@ static struct p9_trans_module p9_virtio_trans = {
/* The standard init function */ /* The standard init function */
static int __init p9_virtio_init(void) static int __init p9_virtio_init(void)
{ {
int count; INIT_LIST_HEAD(&virtio_chan_list);
for (count = 0; count < MAX_9P_CHAN; count++)
channels[count].initialized = false;
v9fs_register_trans(&p9_virtio_trans); v9fs_register_trans(&p9_virtio_trans);
return register_virtio_driver(&p9_virtio_drv); return register_virtio_driver(&p9_virtio_drv);