Commit | Line | Data |
---|---|---|
b530cc79 | 1 | /* |
fea511a6 | 2 | * The Virtio 9p transport driver |
b530cc79 | 3 | * |
e2735b77 EVH |
4 | * This is a block based transport driver based on the lguest block driver |
5 | * code. | |
b530cc79 | 6 | * |
fea511a6 | 7 | * Copyright (C) 2007, 2008 Eric Van Hensbergen, IBM Corporation |
b530cc79 EVH |
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 | ||
5d385153 JP |
29 | #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt |
30 | ||
b530cc79 EVH |
31 | #include <linux/in.h> |
32 | #include <linux/module.h> | |
33 | #include <linux/net.h> | |
34 | #include <linux/ipv6.h> | |
35 | #include <linux/errno.h> | |
36 | #include <linux/kernel.h> | |
37 | #include <linux/un.h> | |
38 | #include <linux/uaccess.h> | |
39 | #include <linux/inet.h> | |
40 | #include <linux/idr.h> | |
41 | #include <linux/file.h> | |
b9cdc88d | 42 | #include <linux/highmem.h> |
5a0e3ad6 | 43 | #include <linux/slab.h> |
b530cc79 EVH |
44 | #include <net/9p/9p.h> |
45 | #include <linux/parser.h> | |
8b81ef58 | 46 | #include <net/9p/client.h> |
b530cc79 EVH |
47 | #include <net/9p/transport.h> |
48 | #include <linux/scatterlist.h> | |
68da9ba4 | 49 | #include <linux/swap.h> |
b530cc79 EVH |
50 | #include <linux/virtio.h> |
51 | #include <linux/virtio_9p.h> | |
4038866d | 52 | #include "trans_common.h" |
b530cc79 | 53 | |
e2735b77 EVH |
54 | #define VIRTQUEUE_NUM 128 |
55 | ||
b530cc79 | 56 | /* a single mutex to manage channel initialization and attachment */ |
c1549497 | 57 | static DEFINE_MUTEX(virtio_9p_lock); |
68da9ba4 VJJ |
58 | static DECLARE_WAIT_QUEUE_HEAD(vp_wq); |
59 | static atomic_t vp_pinned = ATOMIC_INIT(0); | |
b530cc79 | 60 | |
ee443996 EVH |
61 | /** |
62 | * struct virtio_chan - per-instance transport information | |
63 | * @initialized: whether the channel is initialized | |
64 | * @inuse: whether the channel is in use | |
65 | * @lock: protects multiple elements within this structure | |
0e15597e | 66 | * @client: client instance |
ee443996 EVH |
67 | * @vdev: virtio dev associated with this channel |
68 | * @vq: virtio queue associated with this channel | |
ee443996 EVH |
69 | * @sg: scatter gather list which is used to pack a request (protected?) |
70 | * | |
71 | * We keep all per-channel information in a structure. | |
b530cc79 EVH |
72 | * This structure is allocated within the devices dev->mem space. |
73 | * A pointer to the structure will get put in the transport private. | |
ee443996 | 74 | * |
b530cc79 | 75 | */ |
ee443996 | 76 | |
37c1209d | 77 | struct virtio_chan { |
ee443996 | 78 | bool inuse; |
b530cc79 | 79 | |
e2735b77 EVH |
80 | spinlock_t lock; |
81 | ||
fea511a6 | 82 | struct p9_client *client; |
b530cc79 | 83 | struct virtio_device *vdev; |
e2735b77 | 84 | struct virtqueue *vq; |
52f44e0d VJJ |
85 | int ring_bufs_avail; |
86 | wait_queue_head_t *vc_wq; | |
68da9ba4 VJJ |
87 | /* This is global limit. Since we don't have a global structure, |
88 | * will be placing it in each channel. | |
89 | */ | |
7293bfba | 90 | unsigned long p9_max_pages; |
e2735b77 EVH |
91 | /* Scatterlist: can be too big for stack. */ |
92 | struct scatterlist sg[VIRTQUEUE_NUM]; | |
37c1209d | 93 | |
97ee9b02 AK |
94 | int tag_len; |
95 | /* | |
96 | * tag name to identify a mount Non-null terminated | |
97 | */ | |
98 | char *tag; | |
99 | ||
37c1209d AK |
100 | struct list_head chan_list; |
101 | }; | |
102 | ||
103 | static struct list_head virtio_chan_list; | |
b530cc79 EVH |
104 | |
105 | /* How many bytes left in this page. */ | |
106 | static unsigned int rest_of_page(void *data) | |
107 | { | |
222e4ade | 108 | return PAGE_SIZE - offset_in_page(data); |
b530cc79 EVH |
109 | } |
110 | ||
ee443996 EVH |
111 | /** |
112 | * p9_virtio_close - reclaim resources of a channel | |
0e15597e | 113 | * @client: client instance |
ee443996 EVH |
114 | * |
115 | * This reclaims a channel by freeing its resources and | |
116 | * reseting its inuse flag. | |
117 | * | |
118 | */ | |
119 | ||
8b81ef58 | 120 | static void p9_virtio_close(struct p9_client *client) |
e2735b77 | 121 | { |
8b81ef58 | 122 | struct virtio_chan *chan = client->trans; |
b530cc79 | 123 | |
c1549497 | 124 | mutex_lock(&virtio_9p_lock); |
fb786100 AK |
125 | if (chan) |
126 | chan->inuse = false; | |
c1549497 | 127 | mutex_unlock(&virtio_9p_lock); |
b530cc79 EVH |
128 | } |
129 | ||
ee443996 EVH |
130 | /** |
131 | * req_done - callback which signals activity from the server | |
132 | * @vq: virtio queue activity was received on | |
133 | * | |
134 | * This notifies us that the server has triggered some activity | |
135 | * on the virtio channel - most likely a response to request we | |
136 | * sent. Figure out which requests now have responses and wake up | |
137 | * those threads. | |
138 | * | |
139 | * Bugs: could do with some additional sanity checking, but appears to work. | |
140 | * | |
141 | */ | |
142 | ||
e2735b77 | 143 | static void req_done(struct virtqueue *vq) |
b530cc79 | 144 | { |
e2735b77 | 145 | struct virtio_chan *chan = vq->vdev->priv; |
e2735b77 | 146 | unsigned int len; |
e2735b77 | 147 | struct p9_req_t *req; |
419b3956 | 148 | unsigned long flags; |
e2735b77 | 149 | |
5d385153 | 150 | p9_debug(P9_DEBUG_TRANS, ": request done\n"); |
91b8534f | 151 | |
a01a9840 | 152 | while (1) { |
419b3956 | 153 | spin_lock_irqsave(&chan->lock, flags); |
474fe9f7 AV |
154 | req = virtqueue_get_buf(chan->vq, &len); |
155 | if (req == NULL) { | |
52f44e0d | 156 | spin_unlock_irqrestore(&chan->lock, flags); |
a01a9840 VJJ |
157 | break; |
158 | } | |
a01a9840 VJJ |
159 | chan->ring_bufs_avail = 1; |
160 | spin_unlock_irqrestore(&chan->lock, flags); | |
161 | /* Wakeup if anyone waiting for VirtIO ring space. */ | |
162 | wake_up(chan->vc_wq); | |
2b6e72ed | 163 | p9_client_cb(chan->client, req, REQ_STATUS_RCVD); |
a01a9840 | 164 | } |
e2735b77 | 165 | } |
b530cc79 | 166 | |
ee443996 EVH |
167 | /** |
168 | * pack_sg_list - pack a scatter gather list from a linear buffer | |
169 | * @sg: scatter/gather list to pack into | |
170 | * @start: which segment of the sg_list to start at | |
171 | * @limit: maximum segment to pack data to | |
172 | * @data: data to pack into scatter/gather list | |
173 | * @count: amount of data to pack into the scatter/gather list | |
174 | * | |
175 | * sg_lists have multiple segments of various sizes. This will pack | |
176 | * arbitrary data into an existing scatter gather list, segmenting the | |
177 | * data as necessary within constraints. | |
178 | * | |
179 | */ | |
180 | ||
abfa034e AK |
181 | static int pack_sg_list(struct scatterlist *sg, int start, |
182 | int limit, char *data, int count) | |
e2735b77 EVH |
183 | { |
184 | int s; | |
185 | int index = start; | |
186 | ||
187 | while (count) { | |
188 | s = rest_of_page(data); | |
189 | if (s > count) | |
190 | s = count; | |
5fcb08be | 191 | BUG_ON(index > limit); |
0b36f1ad RR |
192 | /* Make sure we don't terminate early. */ |
193 | sg_unmark_end(&sg[index]); | |
e2735b77 EVH |
194 | sg_set_buf(&sg[index++], data, s); |
195 | count -= s; | |
196 | data += s; | |
e2735b77 | 197 | } |
0b36f1ad RR |
198 | if (index-start) |
199 | sg_mark_end(&sg[index - 1]); | |
e2735b77 | 200 | return index-start; |
b530cc79 EVH |
201 | } |
202 | ||
91b8534f EVH |
203 | /* We don't currently allow canceling of virtio requests */ |
204 | static int p9_virtio_cancel(struct p9_client *client, struct p9_req_t *req) | |
205 | { | |
206 | return 1; | |
207 | } | |
208 | ||
4038866d VJJ |
209 | /** |
210 | * pack_sg_list_p - Just like pack_sg_list. Instead of taking a buffer, | |
211 | * this takes a list of pages. | |
212 | * @sg: scatter/gather list to pack into | |
213 | * @start: which segment of the sg_list to start at | |
2c53040f | 214 | * @pdata: a list of pages to add into sg. |
abfa034e | 215 | * @nr_pages: number of pages to pack into the scatter/gather list |
4f3b35c1 | 216 | * @offs: amount of data in the beginning of first page _not_ to pack |
4038866d VJJ |
217 | * @count: amount of data to pack into the scatter/gather list |
218 | */ | |
219 | static int | |
abfa034e | 220 | pack_sg_list_p(struct scatterlist *sg, int start, int limit, |
4f3b35c1 | 221 | struct page **pdata, int nr_pages, size_t offs, int count) |
4038866d | 222 | { |
abfa034e | 223 | int i = 0, s; |
4f3b35c1 | 224 | int data_off = offs; |
4038866d VJJ |
225 | int index = start; |
226 | ||
abfa034e AK |
227 | BUG_ON(nr_pages > (limit - start)); |
228 | /* | |
229 | * if the first page doesn't start at | |
230 | * page boundary find the offset | |
231 | */ | |
abfa034e | 232 | while (nr_pages) { |
4f3b35c1 | 233 | s = PAGE_SIZE - data_off; |
abfa034e AK |
234 | if (s > count) |
235 | s = count; | |
0b36f1ad RR |
236 | /* Make sure we don't terminate early. */ |
237 | sg_unmark_end(&sg[index]); | |
abfa034e AK |
238 | sg_set_page(&sg[index++], pdata[i++], s, data_off); |
239 | data_off = 0; | |
4038866d | 240 | count -= s; |
abfa034e | 241 | nr_pages--; |
4038866d | 242 | } |
0b36f1ad RR |
243 | |
244 | if (index-start) | |
245 | sg_mark_end(&sg[index - 1]); | |
abfa034e | 246 | return index - start; |
4038866d VJJ |
247 | } |
248 | ||
ee443996 | 249 | /** |
91b8534f | 250 | * p9_virtio_request - issue a request |
0e15597e AK |
251 | * @client: client instance issuing the request |
252 | * @req: request to be issued | |
ee443996 EVH |
253 | * |
254 | */ | |
255 | ||
e2735b77 | 256 | static int |
91b8534f | 257 | p9_virtio_request(struct p9_client *client, struct p9_req_t *req) |
b530cc79 | 258 | { |
abfa034e | 259 | int err; |
0b36f1ad | 260 | int in, out, out_sgs, in_sgs; |
419b3956 | 261 | unsigned long flags; |
abfa034e | 262 | struct virtio_chan *chan = client->trans; |
0b36f1ad | 263 | struct scatterlist *sgs[2]; |
b530cc79 | 264 | |
5d385153 | 265 | p9_debug(P9_DEBUG_TRANS, "9p debug: virtio request\n"); |
b530cc79 | 266 | |
419b3956 | 267 | req->status = REQ_STATUS_SENT; |
abfa034e AK |
268 | req_retry: |
269 | spin_lock_irqsave(&chan->lock, flags); | |
270 | ||
0b36f1ad | 271 | out_sgs = in_sgs = 0; |
abfa034e AK |
272 | /* Handle out VirtIO ring buffers */ |
273 | out = pack_sg_list(chan->sg, 0, | |
274 | VIRTQUEUE_NUM, req->tc->sdata, req->tc->size); | |
0b36f1ad RR |
275 | if (out) |
276 | sgs[out_sgs++] = chan->sg; | |
419b3956 | 277 | |
abfa034e AK |
278 | in = pack_sg_list(chan->sg, out, |
279 | VIRTQUEUE_NUM, req->rc->sdata, req->rc->capacity); | |
0b36f1ad RR |
280 | if (in) |
281 | sgs[out_sgs + in_sgs++] = chan->sg + out; | |
4038866d | 282 | |
474fe9f7 | 283 | err = virtqueue_add_sgs(chan->vq, sgs, out_sgs, in_sgs, req, |
f96fde41 | 284 | GFP_ATOMIC); |
abfa034e AK |
285 | if (err < 0) { |
286 | if (err == -ENOSPC) { | |
287 | chan->ring_bufs_avail = 0; | |
288 | spin_unlock_irqrestore(&chan->lock, flags); | |
289 | err = wait_event_interruptible(*chan->vc_wq, | |
290 | chan->ring_bufs_avail); | |
68da9ba4 VJJ |
291 | if (err == -ERESTARTSYS) |
292 | return err; | |
68da9ba4 | 293 | |
5d385153 | 294 | p9_debug(P9_DEBUG_TRANS, "Retry virtio request\n"); |
abfa034e | 295 | goto req_retry; |
4038866d | 296 | } else { |
abfa034e | 297 | spin_unlock_irqrestore(&chan->lock, flags); |
5d385153 | 298 | p9_debug(P9_DEBUG_TRANS, |
0b36f1ad | 299 | "virtio rpc add_sgs returned failure\n"); |
abfa034e | 300 | return -EIO; |
4038866d | 301 | } |
abfa034e AK |
302 | } |
303 | virtqueue_kick(chan->vq); | |
304 | spin_unlock_irqrestore(&chan->lock, flags); | |
4038866d | 305 | |
5d385153 | 306 | p9_debug(P9_DEBUG_TRANS, "virtio request kicked\n"); |
abfa034e AK |
307 | return 0; |
308 | } | |
309 | ||
310 | static int p9_get_mapped_pages(struct virtio_chan *chan, | |
4f3b35c1 AV |
311 | struct page ***pages, |
312 | struct iov_iter *data, | |
313 | int count, | |
314 | size_t *offs, | |
315 | int *need_drop) | |
abfa034e | 316 | { |
4f3b35c1 | 317 | int nr_pages; |
abfa034e | 318 | int err; |
4f3b35c1 AV |
319 | |
320 | if (!iov_iter_count(data)) | |
321 | return 0; | |
322 | ||
323 | if (!(data->type & ITER_KVEC)) { | |
324 | int n; | |
abfa034e AK |
325 | /* |
326 | * We allow only p9_max_pages pinned. We wait for the | |
327 | * Other zc request to finish here | |
328 | */ | |
329 | if (atomic_read(&vp_pinned) >= chan->p9_max_pages) { | |
330 | err = wait_event_interruptible(vp_wq, | |
331 | (atomic_read(&vp_pinned) < chan->p9_max_pages)); | |
332 | if (err == -ERESTARTSYS) | |
333 | return err; | |
334 | } | |
4f3b35c1 AV |
335 | n = iov_iter_get_pages_alloc(data, pages, count, offs); |
336 | if (n < 0) | |
337 | return n; | |
338 | *need_drop = 1; | |
339 | nr_pages = DIV_ROUND_UP(n + *offs, PAGE_SIZE); | |
abfa034e | 340 | atomic_add(nr_pages, &vp_pinned); |
4f3b35c1 | 341 | return n; |
abfa034e AK |
342 | } else { |
343 | /* kernel buffer, no need to pin pages */ | |
4f3b35c1 AV |
344 | int index; |
345 | size_t len; | |
346 | void *p; | |
347 | ||
348 | /* we'd already checked that it's non-empty */ | |
349 | while (1) { | |
350 | len = iov_iter_single_seg_count(data); | |
351 | if (likely(len)) { | |
352 | p = data->kvec->iov_base + data->iov_offset; | |
353 | break; | |
354 | } | |
355 | iov_iter_advance(data, 0); | |
356 | } | |
357 | if (len > count) | |
358 | len = count; | |
359 | ||
360 | nr_pages = DIV_ROUND_UP((unsigned long)p + len, PAGE_SIZE) - | |
361 | (unsigned long)p / PAGE_SIZE; | |
362 | ||
363 | *pages = kmalloc(sizeof(struct page *) * nr_pages, GFP_NOFS); | |
364 | if (!*pages) | |
365 | return -ENOMEM; | |
366 | ||
367 | *need_drop = 0; | |
222e4ade | 368 | p -= (*offs = offset_in_page(p)); |
4f3b35c1 AV |
369 | for (index = 0; index < nr_pages; index++) { |
370 | if (is_vmalloc_addr(p)) | |
371 | (*pages)[index] = vmalloc_to_page(p); | |
b6f52ae2 | 372 | else |
4f3b35c1 AV |
373 | (*pages)[index] = kmap_to_page(p); |
374 | p += PAGE_SIZE; | |
4038866d | 375 | } |
4f3b35c1 | 376 | return len; |
4038866d | 377 | } |
abfa034e | 378 | } |
4038866d | 379 | |
abfa034e AK |
380 | /** |
381 | * p9_virtio_zc_request - issue a zero copy request | |
382 | * @client: client instance issuing the request | |
383 | * @req: request to be issued | |
384 | * @uidata: user bffer that should be ued for zero copy read | |
385 | * @uodata: user buffer that shoud be user for zero copy write | |
386 | * @inlen: read buffer size | |
387 | * @olen: write buffer size | |
388 | * @hdrlen: reader header size, This is the size of response protocol data | |
389 | * | |
390 | */ | |
391 | static int | |
392 | p9_virtio_zc_request(struct p9_client *client, struct p9_req_t *req, | |
4f3b35c1 AV |
393 | struct iov_iter *uidata, struct iov_iter *uodata, |
394 | int inlen, int outlen, int in_hdr_len) | |
abfa034e | 395 | { |
0b36f1ad | 396 | int in, out, err, out_sgs, in_sgs; |
abfa034e AK |
397 | unsigned long flags; |
398 | int in_nr_pages = 0, out_nr_pages = 0; | |
399 | struct page **in_pages = NULL, **out_pages = NULL; | |
400 | struct virtio_chan *chan = client->trans; | |
0b36f1ad | 401 | struct scatterlist *sgs[4]; |
4f3b35c1 AV |
402 | size_t offs; |
403 | int need_drop = 0; | |
4038866d | 404 | |
5d385153 | 405 | p9_debug(P9_DEBUG_TRANS, "virtio request\n"); |
abfa034e AK |
406 | |
407 | if (uodata) { | |
4f3b35c1 AV |
408 | int n = p9_get_mapped_pages(chan, &out_pages, uodata, |
409 | outlen, &offs, &need_drop); | |
410 | if (n < 0) | |
411 | return n; | |
412 | out_nr_pages = DIV_ROUND_UP(n + offs, PAGE_SIZE); | |
413 | if (n != outlen) { | |
414 | __le32 v = cpu_to_le32(n); | |
415 | memcpy(&req->tc->sdata[req->tc->size - 4], &v, 4); | |
416 | outlen = n; | |
4038866d | 417 | } |
4f3b35c1 AV |
418 | } else if (uidata) { |
419 | int n = p9_get_mapped_pages(chan, &in_pages, uidata, | |
420 | inlen, &offs, &need_drop); | |
421 | if (n < 0) | |
422 | return n; | |
423 | in_nr_pages = DIV_ROUND_UP(n + offs, PAGE_SIZE); | |
424 | if (n != inlen) { | |
425 | __le32 v = cpu_to_le32(n); | |
426 | memcpy(&req->tc->sdata[req->tc->size - 4], &v, 4); | |
427 | inlen = n; | |
4038866d | 428 | } |
4038866d | 429 | } |
abfa034e AK |
430 | req->status = REQ_STATUS_SENT; |
431 | req_retry_pinned: | |
432 | spin_lock_irqsave(&chan->lock, flags); | |
0b36f1ad RR |
433 | |
434 | out_sgs = in_sgs = 0; | |
435 | ||
abfa034e AK |
436 | /* out data */ |
437 | out = pack_sg_list(chan->sg, 0, | |
438 | VIRTQUEUE_NUM, req->tc->sdata, req->tc->size); | |
439 | ||
0b36f1ad RR |
440 | if (out) |
441 | sgs[out_sgs++] = chan->sg; | |
442 | ||
443 | if (out_pages) { | |
444 | sgs[out_sgs++] = chan->sg + out; | |
abfa034e | 445 | out += pack_sg_list_p(chan->sg, out, VIRTQUEUE_NUM, |
4f3b35c1 | 446 | out_pages, out_nr_pages, offs, outlen); |
0b36f1ad RR |
447 | } |
448 | ||
abfa034e AK |
449 | /* |
450 | * Take care of in data | |
451 | * For example TREAD have 11. | |
452 | * 11 is the read/write header = PDU Header(7) + IO Size (4). | |
453 | * Arrange in such a way that server places header in the | |
454 | * alloced memory and payload onto the user buffer. | |
455 | */ | |
456 | in = pack_sg_list(chan->sg, out, | |
457 | VIRTQUEUE_NUM, req->rc->sdata, in_hdr_len); | |
0b36f1ad RR |
458 | if (in) |
459 | sgs[out_sgs + in_sgs++] = chan->sg + out; | |
460 | ||
461 | if (in_pages) { | |
462 | sgs[out_sgs + in_sgs++] = chan->sg + out + in; | |
abfa034e | 463 | in += pack_sg_list_p(chan->sg, out + in, VIRTQUEUE_NUM, |
4f3b35c1 | 464 | in_pages, in_nr_pages, offs, inlen); |
0b36f1ad | 465 | } |
b530cc79 | 466 | |
0b36f1ad | 467 | BUG_ON(out_sgs + in_sgs > ARRAY_SIZE(sgs)); |
474fe9f7 | 468 | err = virtqueue_add_sgs(chan->vq, sgs, out_sgs, in_sgs, req, |
f96fde41 | 469 | GFP_ATOMIC); |
419b3956 | 470 | if (err < 0) { |
52f44e0d VJJ |
471 | if (err == -ENOSPC) { |
472 | chan->ring_bufs_avail = 0; | |
473 | spin_unlock_irqrestore(&chan->lock, flags); | |
474 | err = wait_event_interruptible(*chan->vc_wq, | |
abfa034e | 475 | chan->ring_bufs_avail); |
52f44e0d | 476 | if (err == -ERESTARTSYS) |
abfa034e | 477 | goto err_out; |
52f44e0d | 478 | |
5d385153 | 479 | p9_debug(P9_DEBUG_TRANS, "Retry virtio request\n"); |
316ad550 | 480 | goto req_retry_pinned; |
52f44e0d VJJ |
481 | } else { |
482 | spin_unlock_irqrestore(&chan->lock, flags); | |
5d385153 | 483 | p9_debug(P9_DEBUG_TRANS, |
0b36f1ad | 484 | "virtio rpc add_sgs returned failure\n"); |
abfa034e AK |
485 | err = -EIO; |
486 | goto err_out; | |
52f44e0d | 487 | } |
e2735b77 | 488 | } |
dc3f5e68 | 489 | virtqueue_kick(chan->vq); |
419b3956 | 490 | spin_unlock_irqrestore(&chan->lock, flags); |
5d385153 | 491 | p9_debug(P9_DEBUG_TRANS, "virtio request kicked\n"); |
abfa034e AK |
492 | err = wait_event_interruptible(*req->wq, |
493 | req->status >= REQ_STATUS_RCVD); | |
494 | /* | |
495 | * Non kernel buffers are pinned, unpin them | |
496 | */ | |
497 | err_out: | |
4f3b35c1 | 498 | if (need_drop) { |
abfa034e AK |
499 | if (in_pages) { |
500 | p9_release_pages(in_pages, in_nr_pages); | |
501 | atomic_sub(in_nr_pages, &vp_pinned); | |
502 | } | |
503 | if (out_pages) { | |
504 | p9_release_pages(out_pages, out_nr_pages); | |
505 | atomic_sub(out_nr_pages, &vp_pinned); | |
506 | } | |
507 | /* wakeup anybody waiting for slots to pin pages */ | |
508 | wake_up(&vp_wq); | |
509 | } | |
510 | kfree(in_pages); | |
511 | kfree(out_pages); | |
512 | return err; | |
b530cc79 EVH |
513 | } |
514 | ||
86c84373 AK |
515 | static ssize_t p9_mount_tag_show(struct device *dev, |
516 | struct device_attribute *attr, char *buf) | |
517 | { | |
518 | struct virtio_chan *chan; | |
519 | struct virtio_device *vdev; | |
520 | ||
521 | vdev = dev_to_virtio(dev); | |
522 | chan = vdev->priv; | |
523 | ||
179a5bc4 AR |
524 | memcpy(buf, chan->tag, chan->tag_len); |
525 | buf[chan->tag_len] = 0; | |
526 | ||
527 | return chan->tag_len + 1; | |
86c84373 AK |
528 | } |
529 | ||
530 | static DEVICE_ATTR(mount_tag, 0444, p9_mount_tag_show, NULL); | |
531 | ||
ee443996 EVH |
532 | /** |
533 | * p9_virtio_probe - probe for existence of 9P virtio channels | |
534 | * @vdev: virtio device to probe | |
535 | * | |
37c1209d | 536 | * This probes for existing virtio channels. |
ee443996 EVH |
537 | * |
538 | */ | |
539 | ||
e2735b77 | 540 | static int p9_virtio_probe(struct virtio_device *vdev) |
b530cc79 | 541 | { |
97ee9b02 AK |
542 | __u16 tag_len; |
543 | char *tag; | |
b530cc79 EVH |
544 | int err; |
545 | struct virtio_chan *chan; | |
b530cc79 | 546 | |
7754f53e MT |
547 | if (!vdev->config->get) { |
548 | dev_err(&vdev->dev, "%s failure: config access disabled\n", | |
549 | __func__); | |
550 | return -EINVAL; | |
551 | } | |
552 | ||
37c1209d AK |
553 | chan = kmalloc(sizeof(struct virtio_chan), GFP_KERNEL); |
554 | if (!chan) { | |
5d385153 | 555 | pr_err("Failed to allocate virtio 9P channel\n"); |
b530cc79 EVH |
556 | err = -ENOMEM; |
557 | goto fail; | |
558 | } | |
559 | ||
e2735b77 | 560 | chan->vdev = vdev; |
b530cc79 | 561 | |
e2735b77 | 562 | /* We expect one virtqueue, for requests. */ |
d2a7ddda | 563 | chan->vq = virtio_find_single_vq(vdev, req_done, "requests"); |
e2735b77 EVH |
564 | if (IS_ERR(chan->vq)) { |
565 | err = PTR_ERR(chan->vq); | |
566 | goto out_free_vq; | |
b530cc79 | 567 | } |
e2735b77 EVH |
568 | chan->vq->vdev->priv = chan; |
569 | spin_lock_init(&chan->lock); | |
b530cc79 | 570 | |
e2735b77 | 571 | sg_init_table(chan->sg, VIRTQUEUE_NUM); |
b530cc79 | 572 | |
b530cc79 | 573 | chan->inuse = false; |
97ee9b02 | 574 | if (virtio_has_feature(vdev, VIRTIO_9P_MOUNT_TAG)) { |
855e0c52 | 575 | virtio_cread(vdev, struct virtio_9p_config, tag_len, &tag_len); |
97ee9b02 AK |
576 | } else { |
577 | err = -EINVAL; | |
578 | goto out_free_vq; | |
579 | } | |
580 | tag = kmalloc(tag_len, GFP_KERNEL); | |
581 | if (!tag) { | |
582 | err = -ENOMEM; | |
583 | goto out_free_vq; | |
584 | } | |
855e0c52 RR |
585 | |
586 | virtio_cread_bytes(vdev, offsetof(struct virtio_9p_config, tag), | |
587 | tag, tag_len); | |
97ee9b02 AK |
588 | chan->tag = tag; |
589 | chan->tag_len = tag_len; | |
86c84373 AK |
590 | err = sysfs_create_file(&(vdev->dev.kobj), &dev_attr_mount_tag.attr); |
591 | if (err) { | |
52f44e0d | 592 | goto out_free_tag; |
86c84373 | 593 | } |
52f44e0d VJJ |
594 | chan->vc_wq = kmalloc(sizeof(wait_queue_head_t), GFP_KERNEL); |
595 | if (!chan->vc_wq) { | |
596 | err = -ENOMEM; | |
597 | goto out_free_tag; | |
598 | } | |
599 | init_waitqueue_head(chan->vc_wq); | |
600 | chan->ring_bufs_avail = 1; | |
68da9ba4 VJJ |
601 | /* Ceiling limit to avoid denial of service attacks */ |
602 | chan->p9_max_pages = nr_free_buffer_pages()/4; | |
52f44e0d | 603 | |
64b4cc39 MT |
604 | virtio_device_ready(vdev); |
605 | ||
37c1209d AK |
606 | mutex_lock(&virtio_9p_lock); |
607 | list_add_tail(&chan->chan_list, &virtio_chan_list); | |
608 | mutex_unlock(&virtio_9p_lock); | |
e0d6cb9c MM |
609 | |
610 | /* Let udev rules use the new mount_tag attribute. */ | |
611 | kobject_uevent(&(vdev->dev.kobj), KOBJ_CHANGE); | |
612 | ||
b530cc79 EVH |
613 | return 0; |
614 | ||
52f44e0d VJJ |
615 | out_free_tag: |
616 | kfree(tag); | |
e2735b77 | 617 | out_free_vq: |
d2a7ddda | 618 | vdev->config->del_vqs(vdev); |
37c1209d | 619 | kfree(chan); |
b530cc79 | 620 | fail: |
b530cc79 EVH |
621 | return err; |
622 | } | |
623 | ||
ee443996 EVH |
624 | |
625 | /** | |
626 | * p9_virtio_create - allocate a new virtio channel | |
8b81ef58 | 627 | * @client: client instance invoking this transport |
ee443996 EVH |
628 | * @devname: string identifying the channel to connect to (unused) |
629 | * @args: args passed from sys_mount() for per-transport options (unused) | |
ee443996 EVH |
630 | * |
631 | * This sets up a transport channel for 9p communication. Right now | |
b530cc79 EVH |
632 | * we only match the first available channel, but eventually we couldlook up |
633 | * alternate channels by matching devname versus a virtio_config entry. | |
634 | * We use a simple reference count mechanism to ensure that only a single | |
ee443996 EVH |
635 | * mount has a channel open at a time. |
636 | * | |
ee443996 EVH |
637 | */ |
638 | ||
8b81ef58 EVH |
639 | static int |
640 | p9_virtio_create(struct p9_client *client, const char *devname, char *args) | |
b530cc79 | 641 | { |
37c1209d | 642 | struct virtio_chan *chan; |
c1a7c226 | 643 | int ret = -ENOENT; |
37c1209d | 644 | int found = 0; |
b530cc79 | 645 | |
c1549497 | 646 | mutex_lock(&virtio_9p_lock); |
37c1209d | 647 | list_for_each_entry(chan, &virtio_chan_list, chan_list) { |
0b20406c SE |
648 | if (!strncmp(devname, chan->tag, chan->tag_len) && |
649 | strlen(devname) == chan->tag_len) { | |
f75580c4 AK |
650 | if (!chan->inuse) { |
651 | chan->inuse = true; | |
37c1209d | 652 | found = 1; |
f75580c4 AK |
653 | break; |
654 | } | |
c1a7c226 | 655 | ret = -EBUSY; |
b530cc79 EVH |
656 | } |
657 | } | |
c1549497 | 658 | mutex_unlock(&virtio_9p_lock); |
b530cc79 | 659 | |
37c1209d | 660 | if (!found) { |
c7c72c5a | 661 | pr_err("no channels available for device %s\n", devname); |
c1a7c226 | 662 | return ret; |
e2735b77 EVH |
663 | } |
664 | ||
8b81ef58 | 665 | client->trans = (void *)chan; |
562ada61 | 666 | client->status = Connected; |
fea511a6 | 667 | chan->client = client; |
b530cc79 | 668 | |
8b81ef58 | 669 | return 0; |
b530cc79 EVH |
670 | } |
671 | ||
ee443996 EVH |
672 | /** |
673 | * p9_virtio_remove - clean up resources associated with a virtio device | |
674 | * @vdev: virtio device to remove | |
675 | * | |
676 | */ | |
677 | ||
f3933545 EVH |
678 | static void p9_virtio_remove(struct virtio_device *vdev) |
679 | { | |
680 | struct virtio_chan *chan = vdev->priv; | |
8051a2a5 | 681 | unsigned long warning_time; |
37c1209d AK |
682 | |
683 | mutex_lock(&virtio_9p_lock); | |
8051a2a5 MT |
684 | |
685 | /* Remove self from list so we don't get new users. */ | |
37c1209d | 686 | list_del(&chan->chan_list); |
8051a2a5 MT |
687 | warning_time = jiffies; |
688 | ||
689 | /* Wait for existing users to close. */ | |
690 | while (chan->inuse) { | |
691 | mutex_unlock(&virtio_9p_lock); | |
692 | msleep(250); | |
693 | if (time_after(jiffies, warning_time + 10 * HZ)) { | |
694 | dev_emerg(&vdev->dev, | |
695 | "p9_virtio_remove: waiting for device in use.\n"); | |
696 | warning_time = jiffies; | |
697 | } | |
698 | mutex_lock(&virtio_9p_lock); | |
699 | } | |
700 | ||
37c1209d | 701 | mutex_unlock(&virtio_9p_lock); |
8051a2a5 | 702 | |
ea52bf8e | 703 | vdev->config->reset(vdev); |
8051a2a5 MT |
704 | vdev->config->del_vqs(vdev); |
705 | ||
86c84373 | 706 | sysfs_remove_file(&(vdev->dev.kobj), &dev_attr_mount_tag.attr); |
e0d6cb9c | 707 | kobject_uevent(&(vdev->dev.kobj), KOBJ_CHANGE); |
97ee9b02 | 708 | kfree(chan->tag); |
52f44e0d | 709 | kfree(chan->vc_wq); |
37c1209d | 710 | kfree(chan); |
f3933545 | 711 | |
f3933545 EVH |
712 | } |
713 | ||
b530cc79 EVH |
714 | static struct virtio_device_id id_table[] = { |
715 | { VIRTIO_ID_9P, VIRTIO_DEV_ANY_ID }, | |
716 | { 0 }, | |
717 | }; | |
718 | ||
97ee9b02 AK |
719 | static unsigned int features[] = { |
720 | VIRTIO_9P_MOUNT_TAG, | |
721 | }; | |
722 | ||
b530cc79 EVH |
723 | /* The standard "struct lguest_driver": */ |
724 | static struct virtio_driver p9_virtio_drv = { | |
97ee9b02 AK |
725 | .feature_table = features, |
726 | .feature_table_size = ARRAY_SIZE(features), | |
727 | .driver.name = KBUILD_MODNAME, | |
728 | .driver.owner = THIS_MODULE, | |
729 | .id_table = id_table, | |
730 | .probe = p9_virtio_probe, | |
731 | .remove = p9_virtio_remove, | |
b530cc79 EVH |
732 | }; |
733 | ||
734 | static struct p9_trans_module p9_virtio_trans = { | |
735 | .name = "virtio", | |
736 | .create = p9_virtio_create, | |
8b81ef58 | 737 | .close = p9_virtio_close, |
91b8534f | 738 | .request = p9_virtio_request, |
dc893e19 | 739 | .zc_request = p9_virtio_zc_request, |
91b8534f | 740 | .cancel = p9_virtio_cancel, |
b49d8b5d AK |
741 | /* |
742 | * We leave one entry for input and one entry for response | |
743 | * headers. We also skip one more entry to accomodate, address | |
744 | * that are not at page boundary, that can result in an extra | |
745 | * page in zero copy. | |
746 | */ | |
747 | .maxsize = PAGE_SIZE * (VIRTQUEUE_NUM - 3), | |
f94741fd | 748 | .def = 1, |
72029fe8 | 749 | .owner = THIS_MODULE, |
b530cc79 EVH |
750 | }; |
751 | ||
752 | /* The standard init function */ | |
753 | static int __init p9_virtio_init(void) | |
754 | { | |
37c1209d | 755 | INIT_LIST_HEAD(&virtio_chan_list); |
b530cc79 EVH |
756 | |
757 | v9fs_register_trans(&p9_virtio_trans); | |
758 | return register_virtio_driver(&p9_virtio_drv); | |
759 | } | |
760 | ||
f3933545 EVH |
761 | static void __exit p9_virtio_cleanup(void) |
762 | { | |
763 | unregister_virtio_driver(&p9_virtio_drv); | |
72029fe8 | 764 | v9fs_unregister_trans(&p9_virtio_trans); |
f3933545 EVH |
765 | } |
766 | ||
b530cc79 | 767 | module_init(p9_virtio_init); |
f3933545 | 768 | module_exit(p9_virtio_cleanup); |
b530cc79 EVH |
769 | |
770 | MODULE_DEVICE_TABLE(virtio, id_table); | |
771 | MODULE_AUTHOR("Eric Van Hensbergen <ericvh@gmail.com>"); | |
772 | MODULE_DESCRIPTION("Virtio 9p Transport"); | |
773 | MODULE_LICENSE("GPL"); |