1 /*
2 * The Virtio 9p transport driver
3 *
4 * This is a block based transport driver based on the lguest block driver
5 * code.
6 *
7 * Copyright (C) 2007, 2008 Eric Van Hensbergen, IBM Corporation
8 *
9 * Based on virtio console driver
10 * Copyright (C) 2006, 2007 Rusty Russell, IBM Corporation
11 *
12 * This program is free software; you can redistribute it and/or modify
13 * it under the terms of the GNU General Public License version 2
14 * as published by the Free Software Foundation.
15 *
16 * This program is distributed in the hope that it will be useful,
17 * but WITHOUT ANY WARRANTY; without even the implied warranty of
18 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19 * GNU General Public License for more details.
20 *
21 * You should have received a copy of the GNU General Public License
22 * along with this program; if not, write to:
23 * Free Software Foundation
24 * 51 Franklin Street, Fifth Floor
25 * Boston, MA 02111-1301 USA
26 *
27 */
28
29 #include <linux/in.h>
30 #include <linux/module.h>
31 #include <linux/net.h>
32 #include <linux/ipv6.h>
33 #include <linux/errno.h>
34 #include <linux/kernel.h>
35 #include <linux/un.h>
36 #include <linux/uaccess.h>
37 #include <linux/inet.h>
38 #include <linux/idr.h>
39 #include <linux/file.h>
40 #include <net/9p/9p.h>
41 #include <linux/parser.h>
42 #include <net/9p/client.h>
43 #include <net/9p/transport.h>
44 #include <linux/scatterlist.h>
45 #include <linux/virtio.h>
46 #include <linux/virtio_9p.h>
47
48 #define VIRTQUEUE_NUM 128
49
50 /* a single mutex to manage channel initialization and attachment */
51 static DEFINE_MUTEX(virtio_9p_lock);
52 /* global which tracks highest initialized channel */
53 static int chan_index;
54
55 /**
56 * struct virtio_chan - per-instance transport information
57 * @initialized: whether the channel is initialized
58 * @inuse: whether the channel is in use
59 * @lock: protects multiple elements within this structure
60 * @client: client instance
61 * @vdev: virtio dev associated with this channel
62 * @vq: virtio queue associated with this channel
63 * @sg: scatter gather list which is used to pack a request (protected?)
64 *
65 * We keep all per-channel information in a structure.
66 * This structure is allocated within the devices dev->mem space.
67 * A pointer to the structure will get put in the transport private.
68 *
69 */
70
71 static struct virtio_chan {
72 bool initialized;
73 bool inuse;
74
75 spinlock_t lock;
76
77 struct p9_client *client;
78 struct virtio_device *vdev;
79 struct virtqueue *vq;
80
81 /* Scatterlist: can be too big for stack. */
82 struct scatterlist sg[VIRTQUEUE_NUM];
83 } channels[MAX_9P_CHAN];
84
85 /* How many bytes left in this page. */
86 static unsigned int rest_of_page(void *data)
87 {
88 return PAGE_SIZE - ((unsigned long)data % PAGE_SIZE);
89 }
90
91 /**
92 * p9_virtio_close - reclaim resources of a channel
93 * @client: client instance
94 *
95 * This reclaims a channel by freeing its resources and
96 * reseting its inuse flag.
97 *
98 */
99
100 static void p9_virtio_close(struct p9_client *client)
101 {
102 struct virtio_chan *chan = client->trans;
103
104 mutex_lock(&virtio_9p_lock);
105 chan->inuse = false;
106 mutex_unlock(&virtio_9p_lock);
107 }
108
109 /**
110 * req_done - callback which signals activity from the server
111 * @vq: virtio queue activity was received on
112 *
113 * This notifies us that the server has triggered some activity
114 * on the virtio channel - most likely a response to request we
115 * sent. Figure out which requests now have responses and wake up
116 * those threads.
117 *
118 * Bugs: could do with some additional sanity checking, but appears to work.
119 *
120 */
121
122 static void req_done(struct virtqueue *vq)
123 {
124 struct virtio_chan *chan = vq->vdev->priv;
125 struct p9_fcall *rc;
126 unsigned int len;
127 struct p9_req_t *req;
128
129 P9_DPRINTK(P9_DEBUG_TRANS, ": request done\n");
130
131 while ((rc = chan->vq->vq_ops->get_buf(chan->vq, &len)) != NULL) {
132 P9_DPRINTK(P9_DEBUG_TRANS, ": rc %p\n", rc);
133 P9_DPRINTK(P9_DEBUG_TRANS, ": lookup tag %d\n", rc->tag);
134 req = p9_tag_lookup(chan->client, rc->tag);
135 req->status = REQ_STATUS_RCVD;
136 p9_client_cb(chan->client, req);
137 }
138 }
139
140 /**
141 * pack_sg_list - pack a scatter gather list from a linear buffer
142 * @sg: scatter/gather list to pack into
143 * @start: which segment of the sg_list to start at
144 * @limit: maximum segment to pack data to
145 * @data: data to pack into scatter/gather list
146 * @count: amount of data to pack into the scatter/gather list
147 *
148 * sg_lists have multiple segments of various sizes. This will pack
149 * arbitrary data into an existing scatter gather list, segmenting the
150 * data as necessary within constraints.
151 *
152 */
153
154 static int
155 pack_sg_list(struct scatterlist *sg, int start, int limit, char *data,
156 int count)
157 {
158 int s;
159 int index = start;
160
161 while (count) {
162 s = rest_of_page(data);
163 if (s > count)
164 s = count;
165 sg_set_buf(&sg[index++], data, s);
166 count -= s;
167 data += s;
168 BUG_ON(index > limit);
169 }
170
171 return index-start;
172 }
173
174 /* We don't currently allow canceling of virtio requests */
175 static int p9_virtio_cancel(struct p9_client *client, struct p9_req_t *req)
176 {
177 return 1;
178 }
179
180 /**
181 * p9_virtio_request - issue a request
182 * @client: client instance issuing the request
183 * @req: request to be issued
184 *
185 */
186
187 static int
188 p9_virtio_request(struct p9_client *client, struct p9_req_t *req)
189 {
190 int in, out;
191 struct virtio_chan *chan = client->trans;
192 char *rdata = (char *)req->rc+sizeof(struct p9_fcall);
193
194 P9_DPRINTK(P9_DEBUG_TRANS, "9p debug: virtio request\n");
195
196 out = pack_sg_list(chan->sg, 0, VIRTQUEUE_NUM, req->tc->sdata,
197 req->tc->size);
198 in = pack_sg_list(chan->sg, out, VIRTQUEUE_NUM-out, rdata,
199 client->msize);
200
201 req->status = REQ_STATUS_SENT;
202
203 if (chan->vq->vq_ops->add_buf(chan->vq, chan->sg, out, in, req->tc)) {
204 P9_DPRINTK(P9_DEBUG_TRANS,
205 "9p debug: virtio rpc add_buf returned failure");
206 return -EIO;
207 }
208
209 chan->vq->vq_ops->kick(chan->vq);
210
211 P9_DPRINTK(P9_DEBUG_TRANS, "9p debug: virtio request kicked\n");
212 return 0;
213 }
214
215 /**
216 * p9_virtio_probe - probe for existence of 9P virtio channels
217 * @vdev: virtio device to probe
218 *
219 * This probes for existing virtio channels. At present only
220 * a single channel is in use, so in the future more work may need
221 * to be done here.
222 *
223 */
224
225 static int p9_virtio_probe(struct virtio_device *vdev)
226 {
227 int err;
228 struct virtio_chan *chan;
229 int index;
230
231 mutex_lock(&virtio_9p_lock);
232 index = chan_index++;
233 chan = &channels[index];
234 mutex_unlock(&virtio_9p_lock);
235
236 if (chan_index > MAX_9P_CHAN) {
237 printk(KERN_ERR "9p: virtio: Maximum channels exceeded\n");
238 BUG();
239 err = -ENOMEM;
240 goto fail;
241 }
242
243 chan->vdev = vdev;
244
245 /* We expect one virtqueue, for requests. */
246 chan->vq = virtio_find_single_vq(vdev, req_done, "requests");
247 if (IS_ERR(chan->vq)) {
248 err = PTR_ERR(chan->vq);
249 goto out_free_vq;
250 }
251 chan->vq->vdev->priv = chan;
252 spin_lock_init(&chan->lock);
253
254 sg_init_table(chan->sg, VIRTQUEUE_NUM);
255
256 chan->inuse = false;
257 chan->initialized = true;
258 return 0;
259
260 out_free_vq:
261 vdev->config->del_vqs(vdev);
262 fail:
263 mutex_lock(&virtio_9p_lock);
264 chan_index--;
265 mutex_unlock(&virtio_9p_lock);
266 return err;
267 }
268
269
270 /**
271 * p9_virtio_create - allocate a new virtio channel
272 * @client: client instance invoking this transport
273 * @devname: string identifying the channel to connect to (unused)
274 * @args: args passed from sys_mount() for per-transport options (unused)
275 *
276 * This sets up a transport channel for 9p communication. Right now
277 * we only match the first available channel, but eventually we couldlook up
278 * alternate channels by matching devname versus a virtio_config entry.
279 * We use a simple reference count mechanism to ensure that only a single
280 * mount has a channel open at a time.
281 *
282 * Bugs: doesn't allow identification of a specific channel
283 * to allocate, channels are allocated sequentially. This was
284 * a pragmatic decision to get things rolling, but ideally some
285 * way of identifying the channel to attach to would be nice
286 * if we are going to support multiple channels.
287 *
288 */
289
290 static int
291 p9_virtio_create(struct p9_client *client, const char *devname, char *args)
292 {
293 struct virtio_chan *chan = channels;
294 int index = 0;
295
296 mutex_lock(&virtio_9p_lock);
297 while (index < MAX_9P_CHAN) {
298 if (chan->initialized && !chan->inuse) {
299 chan->inuse = true;
300 break;
301 } else {
302 index++;
303 chan = &channels[index];
304 }
305 }
306 mutex_unlock(&virtio_9p_lock);
307
308 if (index >= MAX_9P_CHAN) {
309 printk(KERN_ERR "9p: no channels available\n");
310 return -ENODEV;
311 }
312
313 client->trans = (void *)chan;
314 chan->client = client;
315
316 return 0;
317 }
318
319 /**
320 * p9_virtio_remove - clean up resources associated with a virtio device
321 * @vdev: virtio device to remove
322 *
323 */
324
325 static void p9_virtio_remove(struct virtio_device *vdev)
326 {
327 struct virtio_chan *chan = vdev->priv;
328
329 BUG_ON(chan->inuse);
330
331 if (chan->initialized) {
332 vdev->config->del_vqs(vdev);
333 chan->initialized = false;
334 }
335 }
336
337 #define VIRTIO_ID_9P 9
338
339 static struct virtio_device_id id_table[] = {
340 { VIRTIO_ID_9P, VIRTIO_DEV_ANY_ID },
341 { 0 },
342 };
343
344 /* The standard "struct lguest_driver": */
345 static struct virtio_driver p9_virtio_drv = {
346 .driver.name = KBUILD_MODNAME,
347 .driver.owner = THIS_MODULE,
348 .id_table = id_table,
349 .probe = p9_virtio_probe,
350 .remove = p9_virtio_remove,
351 };
352
353 static struct p9_trans_module p9_virtio_trans = {
354 .name = "virtio",
355 .create = p9_virtio_create,
356 .close = p9_virtio_close,
357 .request = p9_virtio_request,
358 .cancel = p9_virtio_cancel,
359 .maxsize = PAGE_SIZE*16,
360 .def = 0,
361 .owner = THIS_MODULE,
362 };
363
364 /* The standard init function */
365 static int __init p9_virtio_init(void)
366 {
367 int count;
368
369 for (count = 0; count < MAX_9P_CHAN; count++)
370 channels[count].initialized = false;
371
372 v9fs_register_trans(&p9_virtio_trans);
373 return register_virtio_driver(&p9_virtio_drv);
374 }
375
376 static void __exit p9_virtio_cleanup(void)
377 {
378 unregister_virtio_driver(&p9_virtio_drv);
379 v9fs_unregister_trans(&p9_virtio_trans);
380 }
381
382 module_init(p9_virtio_init);
383 module_exit(p9_virtio_cleanup);
384
385 MODULE_DEVICE_TABLE(virtio, id_table);
386 MODULE_AUTHOR("Eric Van Hensbergen <ericvh@gmail.com>");
387 MODULE_DESCRIPTION("Virtio 9p Transport");
388 MODULE_LICENSE("GPL");
389
|
This page was automatically generated by the
LXR engine.
|