1 /* 2 * The Guest 9p transport driver 3 * 4 * This is a block based transport driver based on the lguest block driver 5 * code. 6 * 7 */ 8 /* 9 * Copyright (C) 2007 Eric Van Hensbergen, IBM Corporation 10 * 11 * Based on virtio console driver 12 * Copyright (C) 2006, 2007 Rusty Russell, IBM Corporation 13 * 14 * This program is free software; you can redistribute it and/or modify 15 * it under the terms of the GNU General Public License version 2 16 * as published by the Free Software Foundation. 17 * 18 * This program is distributed in the hope that it will be useful, 19 * but WITHOUT ANY WARRANTY; without even the implied warranty of 20 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 21 * GNU General Public License for more details. 22 * 23 * You should have received a copy of the GNU General Public License 24 * along with this program; if not, write to: 25 * Free Software Foundation 26 * 51 Franklin Street, Fifth Floor 27 * Boston, MA 02111-1301 USA 28 * 29 */ 30 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> 42 #include <net/9p/9p.h> 43 #include <linux/parser.h> 44 #include <net/9p/transport.h> 45 #include <linux/scatterlist.h> 46 #include <linux/virtio.h> 47 #include <linux/virtio_9p.h> 48 49 #define VIRTQUEUE_NUM 128 50 51 /* a single mutex to manage channel initialization and attachment */ 52 static DEFINE_MUTEX(virtio_9p_lock); 53 /* global which tracks highest initialized channel */ 54 static int chan_index; 55 56 #define P9_INIT_MAXTAG 16 57 58 59 /** 60 * enum p9_req_status_t - virtio request status 61 * @REQ_STATUS_IDLE: request slot unused 62 * @REQ_STATUS_SENT: request sent to server 63 * @REQ_STATUS_RCVD: response received from server 64 * @REQ_STATUS_FLSH: request has been flushed 65 * 66 * The @REQ_STATUS_IDLE state is used to mark a request slot as unused 67 * but use is actually tracked by the idpool structure which handles tag 68 * id allocation. 69 * 70 */ 71 72 enum p9_req_status_t { 73 REQ_STATUS_IDLE, 74 REQ_STATUS_SENT, 75 REQ_STATUS_RCVD, 76 REQ_STATUS_FLSH, 77 }; 78 79 /** 80 * struct p9_req_t - virtio request slots 81 * @status: status of this request slot 82 * @wq: wait_queue for the client to block on for this request 83 * 84 * The virtio transport uses an array to track outstanding requests 85 * instead of a list. While this may incurr overhead during initial 86 * allocation or expansion, it makes request lookup much easier as the 87 * tag id is a index into an array. (We use tag+1 so that we can accomodate 88 * the -1 tag for the T_VERSION request). 89 * This also has the nice effect of only having to allocate wait_queues 90 * once, instead of constantly allocating and freeing them. Its possible 91 * other resources could benefit from this scheme as well. 92 * 93 */ 94 95 struct p9_req_t { 96 int status; 97 wait_queue_head_t *wq; 98 }; 99 100 /** 101 * struct virtio_chan - per-instance transport information 102 * @initialized: whether the channel is initialized 103 * @inuse: whether the channel is in use 104 * @lock: protects multiple elements within this structure 105 * @vdev: virtio dev associated with this channel 106 * @vq: virtio queue associated with this channel 107 * @tagpool: accounting for tag ids (and request slots) 108 * @reqs: array of request slots 109 * @max_tag: current number of request_slots allocated 110 * @sg: scatter gather list which is used to pack a request (protected?) 111 * 112 * We keep all per-channel information in a structure. 113 * This structure is allocated within the devices dev->mem space. 114 * A pointer to the structure will get put in the transport private. 115 * 116 */ 117 118 static struct virtio_chan { 119 bool initialized; 120 bool inuse; 121 122 spinlock_t lock; 123 124 struct virtio_device *vdev; 125 struct virtqueue *vq; 126 127 struct p9_idpool *tagpool; 128 struct p9_req_t *reqs; 129 int max_tag; 130 131 /* Scatterlist: can be too big for stack. */ 132 struct scatterlist sg[VIRTQUEUE_NUM]; 133 } channels[MAX_9P_CHAN]; 134 135 /** 136 * p9_lookup_tag - Lookup requests by tag 137 * @c: virtio channel to lookup tag within 138 * @tag: numeric id for transaction 139 * 140 * this is a simple array lookup, but will grow the 141 * request_slots as necessary to accomodate transaction 142 * ids which did not previously have a slot. 143 * 144 * Bugs: there is currently no upper limit on request slots set 145 * here, but that should be constrained by the id accounting. 146 */ 147 148 static struct p9_req_t *p9_lookup_tag(struct virtio_chan *c, u16 tag) 149 { 150 /* This looks up the original request by tag so we know which 151 * buffer to read the data into */ 152 tag++; 153 154 while (tag >= c->max_tag) { 155 int old_max = c->max_tag; 156 int count; 157 158 if (c->max_tag) 159 c->max_tag *= 2; 160 else 161 c->max_tag = P9_INIT_MAXTAG; 162 163 c->reqs = krealloc(c->reqs, sizeof(struct p9_req_t)*c->max_tag, 164 GFP_ATOMIC); 165 if (!c->reqs) { 166 printk(KERN_ERR "Couldn't grow tag array\n"); 167 BUG(); 168 } 169 for (count = old_max; count < c->max_tag; count++) { 170 c->reqs[count].status = REQ_STATUS_IDLE; 171 c->reqs[count].wq = kmalloc(sizeof(wait_queue_head_t), 172 GFP_ATOMIC); 173 if (!c->reqs[count].wq) { 174 printk(KERN_ERR "Couldn't grow tag array\n"); 175 BUG(); 176 } 177 init_waitqueue_head(c->reqs[count].wq); 178 } 179 } 180 181 return &c->reqs[tag]; 182 } 183 184 185 /* How many bytes left in this page. */ 186 static unsigned int rest_of_page(void *data) 187 { 188 return PAGE_SIZE - ((unsigned long)data % PAGE_SIZE); 189 } 190 191 /** 192 * p9_virtio_close - reclaim resources of a channel 193 * @trans: transport state 194 * 195 * This reclaims a channel by freeing its resources and 196 * reseting its inuse flag. 197 * 198 */ 199 200 static void p9_virtio_close(struct p9_trans *trans) 201 { 202 struct virtio_chan *chan = trans->priv; 203 int count; 204 unsigned long flags; 205 206 spin_lock_irqsave(&chan->lock, flags); 207 p9_idpool_destroy(chan->tagpool); 208 for (count = 0; count < chan->max_tag; count++) 209 kfree(chan->reqs[count].wq); 210 kfree(chan->reqs); 211 chan->max_tag = 0; 212 spin_unlock_irqrestore(&chan->lock, flags); 213 214 mutex_lock(&virtio_9p_lock); 215 chan->inuse = false; 216 mutex_unlock(&virtio_9p_lock); 217 218 kfree(trans); 219 } 220 221 /** 222 * req_done - callback which signals activity from the server 223 * @vq: virtio queue activity was received on 224 * 225 * This notifies us that the server has triggered some activity 226 * on the virtio channel - most likely a response to request we 227 * sent. Figure out which requests now have responses and wake up 228 * those threads. 229 * 230 * Bugs: could do with some additional sanity checking, but appears to work. 231 * 232 */ 233 234 static void req_done(struct virtqueue *vq) 235 { 236 struct virtio_chan *chan = vq->vdev->priv; 237 struct p9_fcall *rc; 238 unsigned int len; 239 unsigned long flags; 240 struct p9_req_t *req; 241 242 spin_lock_irqsave(&chan->lock, flags); 243 while ((rc = chan->vq->vq_ops->get_buf(chan->vq, &len)) != NULL) { 244 req = p9_lookup_tag(chan, rc->tag); 245 req->status = REQ_STATUS_RCVD; 246 wake_up(req->wq); 247 } 248 /* In case queue is stopped waiting for more buffers. */ 249 spin_unlock_irqrestore(&chan->lock, flags); 250 } 251 252 /** 253 * pack_sg_list - pack a scatter gather list from a linear buffer 254 * @sg: scatter/gather list to pack into 255 * @start: which segment of the sg_list to start at 256 * @limit: maximum segment to pack data to 257 * @data: data to pack into scatter/gather list 258 * @count: amount of data to pack into the scatter/gather list 259 * 260 * sg_lists have multiple segments of various sizes. This will pack 261 * arbitrary data into an existing scatter gather list, segmenting the 262 * data as necessary within constraints. 263 * 264 */ 265 266 static int 267 pack_sg_list(struct scatterlist *sg, int start, int limit, char *data, 268 int count) 269 { 270 int s; 271 int index = start; 272 273 while (count) { 274 s = rest_of_page(data); 275 if (s > count) 276 s = count; 277 sg_set_buf(&sg[index++], data, s); 278 count -= s; 279 data += s; 280 BUG_ON(index > limit); 281 } 282 283 return index-start; 284 } 285 286 /** 287 * p9_virtio_rpc - issue a request and wait for a response 288 * @t: transport state 289 * @tc: &p9_fcall request to transmit 290 * @rc: &p9_fcall to put reponse into 291 * 292 */ 293 294 static int 295 p9_virtio_rpc(struct p9_trans *t, struct p9_fcall *tc, struct p9_fcall **rc) 296 { 297 int in, out; 298 int n, err, size; 299 struct virtio_chan *chan = t->priv; 300 char *rdata; 301 struct p9_req_t *req; 302 unsigned long flags; 303 304 if (*rc == NULL) { 305 *rc = kmalloc(sizeof(struct p9_fcall) + t->msize, GFP_KERNEL); 306 if (!*rc) 307 return -ENOMEM; 308 } 309 310 rdata = (char *)*rc+sizeof(struct p9_fcall); 311 312 n = P9_NOTAG; 313 if (tc->id != P9_TVERSION) { 314 n = p9_idpool_get(chan->tagpool); 315 if (n < 0) 316 return -ENOMEM; 317 } 318 319 spin_lock_irqsave(&chan->lock, flags); 320 req = p9_lookup_tag(chan, n); 321 spin_unlock_irqrestore(&chan->lock, flags); 322 323 p9_set_tag(tc, n); 324 325 P9_DPRINTK(P9_DEBUG_TRANS, "9p debug: virtio rpc tag %d\n", n); 326 327 out = pack_sg_list(chan->sg, 0, VIRTQUEUE_NUM, tc->sdata, tc->size); 328 in = pack_sg_list(chan->sg, out, VIRTQUEUE_NUM-out, rdata, t->msize); 329 330 req->status = REQ_STATUS_SENT; 331 332 if (chan->vq->vq_ops->add_buf(chan->vq, chan->sg, out, in, tc)) { 333 P9_DPRINTK(P9_DEBUG_TRANS, 334 "9p debug: virtio rpc add_buf returned failure"); 335 return -EIO; 336 } 337 338 chan->vq->vq_ops->kick(chan->vq); 339 340 wait_event(*req->wq, req->status == REQ_STATUS_RCVD); 341 342 size = le32_to_cpu(*(__le32 *) rdata); 343 344 err = p9_deserialize_fcall(rdata, size, *rc, t->extended); 345 if (err < 0) { 346 P9_DPRINTK(P9_DEBUG_TRANS, 347 "9p debug: virtio rpc deserialize returned %d\n", err); 348 return err; 349 } 350 351 #ifdef CONFIG_NET_9P_DEBUG 352 if ((p9_debug_level&P9_DEBUG_FCALL) == P9_DEBUG_FCALL) { 353 char buf[150]; 354 355 p9_printfcall(buf, sizeof(buf), *rc, t->extended); 356 printk(KERN_NOTICE ">>> %p %s\n", t, buf); 357 } 358 #endif 359 360 if (n != P9_NOTAG && p9_idpool_check(n, chan->tagpool)) 361 p9_idpool_put(n, chan->tagpool); 362 363 req->status = REQ_STATUS_IDLE; 364 365 return 0; 366 } 367 368 /** 369 * p9_virtio_probe - probe for existence of 9P virtio channels 370 * @vdev: virtio device to probe 371 * 372 * This probes for existing virtio channels. At present only 373 * a single channel is in use, so in the future more work may need 374 * to be done here. 375 * 376 */ 377 378 static int p9_virtio_probe(struct virtio_device *vdev) 379 { 380 int err; 381 struct virtio_chan *chan; 382 int index; 383 384 mutex_lock(&virtio_9p_lock); 385 index = chan_index++; 386 chan = &channels[index]; 387 mutex_unlock(&virtio_9p_lock); 388 389 if (chan_index > MAX_9P_CHAN) { 390 printk(KERN_ERR "9p: virtio: Maximum channels exceeded\n"); 391 BUG(); 392 err = -ENOMEM; 393 goto fail; 394 } 395 396 chan->vdev = vdev; 397 398 /* We expect one virtqueue, for requests. */ 399 chan->vq = vdev->config->find_vq(vdev, 0, req_done); 400 if (IS_ERR(chan->vq)) { 401 err = PTR_ERR(chan->vq); 402 goto out_free_vq; 403 } 404 chan->vq->vdev->priv = chan; 405 spin_lock_init(&chan->lock); 406 407 sg_init_table(chan->sg, VIRTQUEUE_NUM); 408 409 chan->inuse = false; 410 chan->initialized = true; 411 return 0; 412 413 out_free_vq: 414 vdev->config->del_vq(chan->vq); 415 fail: 416 mutex_lock(&virtio_9p_lock); 417 chan_index--; 418 mutex_unlock(&virtio_9p_lock); 419 return err; 420 } 421 422 423 /** 424 * p9_virtio_create - allocate a new virtio channel 425 * @devname: string identifying the channel to connect to (unused) 426 * @args: args passed from sys_mount() for per-transport options (unused) 427 * @msize: requested maximum packet size 428 * @extended: 9p2000.u enabled flag 429 * 430 * This sets up a transport channel for 9p communication. Right now 431 * we only match the first available channel, but eventually we couldlook up 432 * alternate channels by matching devname versus a virtio_config entry. 433 * We use a simple reference count mechanism to ensure that only a single 434 * mount has a channel open at a time. 435 * 436 * Bugs: doesn't allow identification of a specific channel 437 * to allocate, channels are allocated sequentially. This was 438 * a pragmatic decision to get things rolling, but ideally some 439 * way of identifying the channel to attach to would be nice 440 * if we are going to support multiple channels. 441 * 442 */ 443 444 static struct p9_trans * 445 p9_virtio_create(const char *devname, char *args, int msize, 446 unsigned char extended) 447 { 448 struct p9_trans *trans; 449 struct virtio_chan *chan = channels; 450 int index = 0; 451 452 mutex_lock(&virtio_9p_lock); 453 while (index < MAX_9P_CHAN) { 454 if (chan->initialized && !chan->inuse) { 455 chan->inuse = true; 456 break; 457 } else { 458 index++; 459 chan = &channels[index]; 460 } 461 } 462 mutex_unlock(&virtio_9p_lock); 463 464 if (index >= MAX_9P_CHAN) { 465 printk(KERN_ERR "9p: no channels available\n"); 466 return ERR_PTR(-ENODEV); 467 } 468 469 chan->tagpool = p9_idpool_create(); 470 if (IS_ERR(chan->tagpool)) { 471 printk(KERN_ERR "9p: couldn't allocate tagpool\n"); 472 return ERR_PTR(-ENOMEM); 473 } 474 p9_idpool_get(chan->tagpool); /* reserve tag 0 */ 475 chan->max_tag = 0; 476 chan->reqs = NULL; 477 478 trans = kmalloc(sizeof(struct p9_trans), GFP_KERNEL); 479 if (!trans) { 480 printk(KERN_ERR "9p: couldn't allocate transport\n"); 481 return ERR_PTR(-ENOMEM); 482 } 483 trans->extended = extended; 484 trans->msize = msize; 485 trans->close = p9_virtio_close; 486 trans->rpc = p9_virtio_rpc; 487 trans->priv = chan; 488 489 return trans; 490 } 491 492 /** 493 * p9_virtio_remove - clean up resources associated with a virtio device 494 * @vdev: virtio device to remove 495 * 496 */ 497 498 static void p9_virtio_remove(struct virtio_device *vdev) 499 { 500 struct virtio_chan *chan = vdev->priv; 501 502 BUG_ON(chan->inuse); 503 504 if (chan->initialized) { 505 vdev->config->del_vq(chan->vq); 506 chan->initialized = false; 507 } 508 } 509 510 #define VIRTIO_ID_9P 9 511 512 static struct virtio_device_id id_table[] = { 513 { VIRTIO_ID_9P, VIRTIO_DEV_ANY_ID }, 514 { 0 }, 515 }; 516 517 /* The standard "struct lguest_driver": */ 518 static struct virtio_driver p9_virtio_drv = { 519 .driver.name = KBUILD_MODNAME, 520 .driver.owner = THIS_MODULE, 521 .id_table = id_table, 522 .probe = p9_virtio_probe, 523 .remove = p9_virtio_remove, 524 }; 525 526 static struct p9_trans_module p9_virtio_trans = { 527 .name = "virtio", 528 .create = p9_virtio_create, 529 .maxsize = PAGE_SIZE*16, 530 .def = 0, 531 }; 532 533 /* The standard init function */ 534 static int __init p9_virtio_init(void) 535 { 536 int count; 537 538 for (count = 0; count < MAX_9P_CHAN; count++) 539 channels[count].initialized = false; 540 541 v9fs_register_trans(&p9_virtio_trans); 542 return register_virtio_driver(&p9_virtio_drv); 543 } 544 545 static void __exit p9_virtio_cleanup(void) 546 { 547 unregister_virtio_driver(&p9_virtio_drv); 548 } 549 550 module_init(p9_virtio_init); 551 module_exit(p9_virtio_cleanup); 552 553 MODULE_DEVICE_TABLE(virtio, id_table); 554 MODULE_AUTHOR("Eric Van Hensbergen <ericvh@gmail.com>"); 555 MODULE_DESCRIPTION("Virtio 9p Transport"); 556 MODULE_LICENSE("GPL"); 557