1 /* Xenbus code for blkif backend 2 Copyright (C) 2005 Rusty Russell <rusty@rustcorp.com.au> 3 Copyright (C) 2005 XenSource Ltd 4 5 This program is free software; you can redistribute it and/or modify 6 it under the terms of the GNU General Public License as published by 7 the Free Software Foundation; either version 2 of the License, or 8 (at your option) any later version. 9 10 This program is distributed in the hope that it will be useful, 11 but WITHOUT ANY WARRANTY; without even the implied warranty of 12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 13 GNU General Public License for more details. 14 15 */ 16 17 #include <stdarg.h> 18 #include <linux/module.h> 19 #include <linux/kthread.h> 20 #include <xen/events.h> 21 #include <xen/grant_table.h> 22 #include "common.h" 23 24 struct backend_info { 25 struct xenbus_device *dev; 26 struct xen_blkif *blkif; 27 struct xenbus_watch backend_watch; 28 unsigned major; 29 unsigned minor; 30 char *mode; 31 }; 32 33 static struct kmem_cache *xen_blkif_cachep; 34 static void connect(struct backend_info *); 35 static int connect_ring(struct backend_info *); 36 static void backend_changed(struct xenbus_watch *, const char **, 37 unsigned int); 38 39 struct xenbus_device *xen_blkbk_xenbus(struct backend_info *be) 40 { 41 return be->dev; 42 } 43 44 static int blkback_name(struct xen_blkif *blkif, char *buf) 45 { 46 char *devpath, *devname; 47 struct xenbus_device *dev = blkif->be->dev; 48 49 devpath = xenbus_read(XBT_NIL, dev->nodename, "dev", NULL); 50 if (IS_ERR(devpath)) 51 return PTR_ERR(devpath); 52 53 devname = strstr(devpath, "/dev/"); 54 if (devname != NULL) 55 devname += strlen("/dev/"); 56 else 57 devname = devpath; 58 59 snprintf(buf, TASK_COMM_LEN, "blkback.%d.%s", blkif->domid, devname); 60 kfree(devpath); 61 62 return 0; 63 } 64 65 static void xen_update_blkif_status(struct xen_blkif *blkif) 66 { 67 int err; 68 char name[TASK_COMM_LEN]; 69 70 /* Not ready to connect? */ 71 if (!blkif->irq || !blkif->vbd.bdev) 72 return; 73 74 /* Already connected? */ 75 if (blkif->be->dev->state == XenbusStateConnected) 76 return; 77 78 /* Attempt to connect: exit if we fail to. */ 79 connect(blkif->be); 80 if (blkif->be->dev->state != XenbusStateConnected) 81 return; 82 83 err = blkback_name(blkif, name); 84 if (err) { 85 xenbus_dev_error(blkif->be->dev, err, "get blkback dev name"); 86 return; 87 } 88 89 err = filemap_write_and_wait(blkif->vbd.bdev->bd_inode->i_mapping); 90 if (err) { 91 xenbus_dev_error(blkif->be->dev, err, "block flush"); 92 return; 93 } 94 invalidate_inode_pages2(blkif->vbd.bdev->bd_inode->i_mapping); 95 96 blkif->xenblkd = kthread_run(xen_blkif_schedule, blkif, "%s", name); 97 if (IS_ERR(blkif->xenblkd)) { 98 err = PTR_ERR(blkif->xenblkd); 99 blkif->xenblkd = NULL; 100 xenbus_dev_error(blkif->be->dev, err, "start xenblkd"); 101 return; 102 } 103 } 104 105 static struct xen_blkif *xen_blkif_alloc(domid_t domid) 106 { 107 struct xen_blkif *blkif; 108 struct pending_req *req, *n; 109 int i, j; 110 111 BUILD_BUG_ON(MAX_INDIRECT_PAGES > BLKIF_MAX_INDIRECT_PAGES_PER_REQUEST); 112 113 blkif = kmem_cache_zalloc(xen_blkif_cachep, GFP_KERNEL); 114 if (!blkif) 115 return ERR_PTR(-ENOMEM); 116 117 blkif->domid = domid; 118 spin_lock_init(&blkif->blk_ring_lock); 119 atomic_set(&blkif->refcnt, 1); 120 init_waitqueue_head(&blkif->wq); 121 init_completion(&blkif->drain_complete); 122 atomic_set(&blkif->drain, 0); 123 blkif->st_print = jiffies; 124 init_waitqueue_head(&blkif->waiting_to_free); 125 blkif->persistent_gnts.rb_node = NULL; 126 spin_lock_init(&blkif->free_pages_lock); 127 INIT_LIST_HEAD(&blkif->free_pages); 128 INIT_LIST_HEAD(&blkif->persistent_purge_list); 129 blkif->free_pages_num = 0; 130 atomic_set(&blkif->persistent_gnt_in_use, 0); 131 atomic_set(&blkif->inflight, 0); 132 INIT_WORK(&blkif->persistent_purge_work, xen_blkbk_unmap_purged_grants); 133 134 INIT_LIST_HEAD(&blkif->pending_free); 135 136 for (i = 0; i < XEN_BLKIF_REQS; i++) { 137 req = kzalloc(sizeof(*req), GFP_KERNEL); 138 if (!req) 139 goto fail; 140 list_add_tail(&req->free_list, 141 &blkif->pending_free); 142 for (j = 0; j < MAX_INDIRECT_SEGMENTS; j++) { 143 req->segments[j] = kzalloc(sizeof(*req->segments[0]), 144 GFP_KERNEL); 145 if (!req->segments[j]) 146 goto fail; 147 } 148 for (j = 0; j < MAX_INDIRECT_PAGES; j++) { 149 req->indirect_pages[j] = kzalloc(sizeof(*req->indirect_pages[0]), 150 GFP_KERNEL); 151 if (!req->indirect_pages[j]) 152 goto fail; 153 } 154 } 155 spin_lock_init(&blkif->pending_free_lock); 156 init_waitqueue_head(&blkif->pending_free_wq); 157 init_waitqueue_head(&blkif->shutdown_wq); 158 159 return blkif; 160 161 fail: 162 list_for_each_entry_safe(req, n, &blkif->pending_free, free_list) { 163 list_del(&req->free_list); 164 for (j = 0; j < MAX_INDIRECT_SEGMENTS; j++) { 165 if (!req->segments[j]) 166 break; 167 kfree(req->segments[j]); 168 } 169 for (j = 0; j < MAX_INDIRECT_PAGES; j++) { 170 if (!req->indirect_pages[j]) 171 break; 172 kfree(req->indirect_pages[j]); 173 } 174 kfree(req); 175 } 176 177 kmem_cache_free(xen_blkif_cachep, blkif); 178 179 return ERR_PTR(-ENOMEM); 180 } 181 182 static int xen_blkif_map(struct xen_blkif *blkif, unsigned long shared_page, 183 unsigned int evtchn) 184 { 185 int err; 186 187 /* Already connected through? */ 188 if (blkif->irq) 189 return 0; 190 191 err = xenbus_map_ring_valloc(blkif->be->dev, shared_page, &blkif->blk_ring); 192 if (err < 0) 193 return err; 194 195 switch (blkif->blk_protocol) { 196 case BLKIF_PROTOCOL_NATIVE: 197 { 198 struct blkif_sring *sring; 199 sring = (struct blkif_sring *)blkif->blk_ring; 200 BACK_RING_INIT(&blkif->blk_rings.native, sring, PAGE_SIZE); 201 break; 202 } 203 case BLKIF_PROTOCOL_X86_32: 204 { 205 struct blkif_x86_32_sring *sring_x86_32; 206 sring_x86_32 = (struct blkif_x86_32_sring *)blkif->blk_ring; 207 BACK_RING_INIT(&blkif->blk_rings.x86_32, sring_x86_32, PAGE_SIZE); 208 break; 209 } 210 case BLKIF_PROTOCOL_X86_64: 211 { 212 struct blkif_x86_64_sring *sring_x86_64; 213 sring_x86_64 = (struct blkif_x86_64_sring *)blkif->blk_ring; 214 BACK_RING_INIT(&blkif->blk_rings.x86_64, sring_x86_64, PAGE_SIZE); 215 break; 216 } 217 default: 218 BUG(); 219 } 220 221 err = bind_interdomain_evtchn_to_irqhandler(blkif->domid, evtchn, 222 xen_blkif_be_int, 0, 223 "blkif-backend", blkif); 224 if (err < 0) { 225 xenbus_unmap_ring_vfree(blkif->be->dev, blkif->blk_ring); 226 blkif->blk_rings.common.sring = NULL; 227 return err; 228 } 229 blkif->irq = err; 230 231 return 0; 232 } 233 234 static void xen_blkif_disconnect(struct xen_blkif *blkif) 235 { 236 if (blkif->xenblkd) { 237 kthread_stop(blkif->xenblkd); 238 wake_up(&blkif->shutdown_wq); 239 blkif->xenblkd = NULL; 240 } 241 242 atomic_dec(&blkif->refcnt); 243 wait_event(blkif->waiting_to_free, atomic_read(&blkif->refcnt) == 0); 244 atomic_inc(&blkif->refcnt); 245 246 if (blkif->irq) { 247 unbind_from_irqhandler(blkif->irq, blkif); 248 blkif->irq = 0; 249 } 250 251 if (blkif->blk_rings.common.sring) { 252 xenbus_unmap_ring_vfree(blkif->be->dev, blkif->blk_ring); 253 blkif->blk_rings.common.sring = NULL; 254 } 255 } 256 257 static void xen_blkif_free(struct xen_blkif *blkif) 258 { 259 struct pending_req *req, *n; 260 int i = 0, j; 261 262 if (!atomic_dec_and_test(&blkif->refcnt)) 263 BUG(); 264 265 /* Remove all persistent grants and the cache of ballooned pages. */ 266 xen_blkbk_free_caches(blkif); 267 268 /* Make sure everything is drained before shutting down */ 269 BUG_ON(blkif->persistent_gnt_c != 0); 270 BUG_ON(atomic_read(&blkif->persistent_gnt_in_use) != 0); 271 BUG_ON(blkif->free_pages_num != 0); 272 BUG_ON(!list_empty(&blkif->persistent_purge_list)); 273 BUG_ON(!list_empty(&blkif->free_pages)); 274 BUG_ON(!RB_EMPTY_ROOT(&blkif->persistent_gnts)); 275 276 /* Check that there is no request in use */ 277 list_for_each_entry_safe(req, n, &blkif->pending_free, free_list) { 278 list_del(&req->free_list); 279 280 for (j = 0; j < MAX_INDIRECT_SEGMENTS; j++) 281 kfree(req->segments[j]); 282 283 for (j = 0; j < MAX_INDIRECT_PAGES; j++) 284 kfree(req->indirect_pages[j]); 285 286 kfree(req); 287 i++; 288 } 289 290 WARN_ON(i != XEN_BLKIF_REQS); 291 292 kmem_cache_free(xen_blkif_cachep, blkif); 293 } 294 295 int __init xen_blkif_interface_init(void) 296 { 297 xen_blkif_cachep = kmem_cache_create("blkif_cache", 298 sizeof(struct xen_blkif), 299 0, 0, NULL); 300 if (!xen_blkif_cachep) 301 return -ENOMEM; 302 303 return 0; 304 } 305 306 /* 307 * sysfs interface for VBD I/O requests 308 */ 309 310 #define VBD_SHOW(name, format, args...) \ 311 static ssize_t show_##name(struct device *_dev, \ 312 struct device_attribute *attr, \ 313 char *buf) \ 314 { \ 315 struct xenbus_device *dev = to_xenbus_device(_dev); \ 316 struct backend_info *be = dev_get_drvdata(&dev->dev); \ 317 \ 318 return sprintf(buf, format, ##args); \ 319 } \ 320 static DEVICE_ATTR(name, S_IRUGO, show_##name, NULL) 321 322 VBD_SHOW(oo_req, "%llu\n", be->blkif->st_oo_req); 323 VBD_SHOW(rd_req, "%llu\n", be->blkif->st_rd_req); 324 VBD_SHOW(wr_req, "%llu\n", be->blkif->st_wr_req); 325 VBD_SHOW(f_req, "%llu\n", be->blkif->st_f_req); 326 VBD_SHOW(ds_req, "%llu\n", be->blkif->st_ds_req); 327 VBD_SHOW(rd_sect, "%llu\n", be->blkif->st_rd_sect); 328 VBD_SHOW(wr_sect, "%llu\n", be->blkif->st_wr_sect); 329 330 static struct attribute *xen_vbdstat_attrs[] = { 331 &dev_attr_oo_req.attr, 332 &dev_attr_rd_req.attr, 333 &dev_attr_wr_req.attr, 334 &dev_attr_f_req.attr, 335 &dev_attr_ds_req.attr, 336 &dev_attr_rd_sect.attr, 337 &dev_attr_wr_sect.attr, 338 NULL 339 }; 340 341 static struct attribute_group xen_vbdstat_group = { 342 .name = "statistics", 343 .attrs = xen_vbdstat_attrs, 344 }; 345 346 VBD_SHOW(physical_device, "%x:%x\n", be->major, be->minor); 347 VBD_SHOW(mode, "%s\n", be->mode); 348 349 static int xenvbd_sysfs_addif(struct xenbus_device *dev) 350 { 351 int error; 352 353 error = device_create_file(&dev->dev, &dev_attr_physical_device); 354 if (error) 355 goto fail1; 356 357 error = device_create_file(&dev->dev, &dev_attr_mode); 358 if (error) 359 goto fail2; 360 361 error = sysfs_create_group(&dev->dev.kobj, &xen_vbdstat_group); 362 if (error) 363 goto fail3; 364 365 return 0; 366 367 fail3: sysfs_remove_group(&dev->dev.kobj, &xen_vbdstat_group); 368 fail2: device_remove_file(&dev->dev, &dev_attr_mode); 369 fail1: device_remove_file(&dev->dev, &dev_attr_physical_device); 370 return error; 371 } 372 373 static void xenvbd_sysfs_delif(struct xenbus_device *dev) 374 { 375 sysfs_remove_group(&dev->dev.kobj, &xen_vbdstat_group); 376 device_remove_file(&dev->dev, &dev_attr_mode); 377 device_remove_file(&dev->dev, &dev_attr_physical_device); 378 } 379 380 381 static void xen_vbd_free(struct xen_vbd *vbd) 382 { 383 if (vbd->bdev) 384 blkdev_put(vbd->bdev, vbd->readonly ? FMODE_READ : FMODE_WRITE); 385 vbd->bdev = NULL; 386 } 387 388 static int xen_vbd_create(struct xen_blkif *blkif, blkif_vdev_t handle, 389 unsigned major, unsigned minor, int readonly, 390 int cdrom) 391 { 392 struct xen_vbd *vbd; 393 struct block_device *bdev; 394 struct request_queue *q; 395 396 vbd = &blkif->vbd; 397 vbd->handle = handle; 398 vbd->readonly = readonly; 399 vbd->type = 0; 400 401 vbd->pdevice = MKDEV(major, minor); 402 403 bdev = blkdev_get_by_dev(vbd->pdevice, vbd->readonly ? 404 FMODE_READ : FMODE_WRITE, NULL); 405 406 if (IS_ERR(bdev)) { 407 DPRINTK("xen_vbd_create: device %08x could not be opened.\n", 408 vbd->pdevice); 409 return -ENOENT; 410 } 411 412 vbd->bdev = bdev; 413 if (vbd->bdev->bd_disk == NULL) { 414 DPRINTK("xen_vbd_create: device %08x doesn't exist.\n", 415 vbd->pdevice); 416 xen_vbd_free(vbd); 417 return -ENOENT; 418 } 419 vbd->size = vbd_sz(vbd); 420 421 if (vbd->bdev->bd_disk->flags & GENHD_FL_CD || cdrom) 422 vbd->type |= VDISK_CDROM; 423 if (vbd->bdev->bd_disk->flags & GENHD_FL_REMOVABLE) 424 vbd->type |= VDISK_REMOVABLE; 425 426 q = bdev_get_queue(bdev); 427 if (q && q->flush_flags) 428 vbd->flush_support = true; 429 430 if (q && blk_queue_secdiscard(q)) 431 vbd->discard_secure = true; 432 433 DPRINTK("Successful creation of handle=%04x (dom=%u)\n", 434 handle, blkif->domid); 435 return 0; 436 } 437 static int xen_blkbk_remove(struct xenbus_device *dev) 438 { 439 struct backend_info *be = dev_get_drvdata(&dev->dev); 440 441 DPRINTK(""); 442 443 if (be->major || be->minor) 444 xenvbd_sysfs_delif(dev); 445 446 if (be->backend_watch.node) { 447 unregister_xenbus_watch(&be->backend_watch); 448 kfree(be->backend_watch.node); 449 be->backend_watch.node = NULL; 450 } 451 452 if (be->blkif) { 453 xen_blkif_disconnect(be->blkif); 454 xen_vbd_free(&be->blkif->vbd); 455 xen_blkif_free(be->blkif); 456 be->blkif = NULL; 457 } 458 459 kfree(be->mode); 460 kfree(be); 461 dev_set_drvdata(&dev->dev, NULL); 462 return 0; 463 } 464 465 int xen_blkbk_flush_diskcache(struct xenbus_transaction xbt, 466 struct backend_info *be, int state) 467 { 468 struct xenbus_device *dev = be->dev; 469 int err; 470 471 err = xenbus_printf(xbt, dev->nodename, "feature-flush-cache", 472 "%d", state); 473 if (err) 474 dev_warn(&dev->dev, "writing feature-flush-cache (%d)", err); 475 476 return err; 477 } 478 479 static void xen_blkbk_discard(struct xenbus_transaction xbt, struct backend_info *be) 480 { 481 struct xenbus_device *dev = be->dev; 482 struct xen_blkif *blkif = be->blkif; 483 int err; 484 int state = 0; 485 struct block_device *bdev = be->blkif->vbd.bdev; 486 struct request_queue *q = bdev_get_queue(bdev); 487 488 if (blk_queue_discard(q)) { 489 err = xenbus_printf(xbt, dev->nodename, 490 "discard-granularity", "%u", 491 q->limits.discard_granularity); 492 if (err) { 493 dev_warn(&dev->dev, "writing discard-granularity (%d)", err); 494 return; 495 } 496 err = xenbus_printf(xbt, dev->nodename, 497 "discard-alignment", "%u", 498 q->limits.discard_alignment); 499 if (err) { 500 dev_warn(&dev->dev, "writing discard-alignment (%d)", err); 501 return; 502 } 503 state = 1; 504 /* Optional. */ 505 err = xenbus_printf(xbt, dev->nodename, 506 "discard-secure", "%d", 507 blkif->vbd.discard_secure); 508 if (err) { 509 dev_warn(&dev->dev, "writing discard-secure (%d)", err); 510 return; 511 } 512 } 513 err = xenbus_printf(xbt, dev->nodename, "feature-discard", 514 "%d", state); 515 if (err) 516 dev_warn(&dev->dev, "writing feature-discard (%d)", err); 517 } 518 int xen_blkbk_barrier(struct xenbus_transaction xbt, 519 struct backend_info *be, int state) 520 { 521 struct xenbus_device *dev = be->dev; 522 int err; 523 524 err = xenbus_printf(xbt, dev->nodename, "feature-barrier", 525 "%d", state); 526 if (err) 527 dev_warn(&dev->dev, "writing feature-barrier (%d)", err); 528 529 return err; 530 } 531 532 /* 533 * Entry point to this code when a new device is created. Allocate the basic 534 * structures, and watch the store waiting for the hotplug scripts to tell us 535 * the device's physical major and minor numbers. Switch to InitWait. 536 */ 537 static int xen_blkbk_probe(struct xenbus_device *dev, 538 const struct xenbus_device_id *id) 539 { 540 int err; 541 struct backend_info *be = kzalloc(sizeof(struct backend_info), 542 GFP_KERNEL); 543 if (!be) { 544 xenbus_dev_fatal(dev, -ENOMEM, 545 "allocating backend structure"); 546 return -ENOMEM; 547 } 548 be->dev = dev; 549 dev_set_drvdata(&dev->dev, be); 550 551 be->blkif = xen_blkif_alloc(dev->otherend_id); 552 if (IS_ERR(be->blkif)) { 553 err = PTR_ERR(be->blkif); 554 be->blkif = NULL; 555 xenbus_dev_fatal(dev, err, "creating block interface"); 556 goto fail; 557 } 558 559 /* setup back pointer */ 560 be->blkif->be = be; 561 562 err = xenbus_watch_pathfmt(dev, &be->backend_watch, backend_changed, 563 "%s/%s", dev->nodename, "physical-device"); 564 if (err) 565 goto fail; 566 567 err = xenbus_switch_state(dev, XenbusStateInitWait); 568 if (err) 569 goto fail; 570 571 return 0; 572 573 fail: 574 DPRINTK("failed"); 575 xen_blkbk_remove(dev); 576 return err; 577 } 578 579 580 /* 581 * Callback received when the hotplug scripts have placed the physical-device 582 * node. Read it and the mode node, and create a vbd. If the frontend is 583 * ready, connect. 584 */ 585 static void backend_changed(struct xenbus_watch *watch, 586 const char **vec, unsigned int len) 587 { 588 int err; 589 unsigned major; 590 unsigned minor; 591 struct backend_info *be 592 = container_of(watch, struct backend_info, backend_watch); 593 struct xenbus_device *dev = be->dev; 594 int cdrom = 0; 595 unsigned long handle; 596 char *device_type; 597 598 DPRINTK(""); 599 600 err = xenbus_scanf(XBT_NIL, dev->nodename, "physical-device", "%x:%x", 601 &major, &minor); 602 if (XENBUS_EXIST_ERR(err)) { 603 /* 604 * Since this watch will fire once immediately after it is 605 * registered, we expect this. Ignore it, and wait for the 606 * hotplug scripts. 607 */ 608 return; 609 } 610 if (err != 2) { 611 xenbus_dev_fatal(dev, err, "reading physical-device"); 612 return; 613 } 614 615 if (be->major | be->minor) { 616 if (be->major != major || be->minor != minor) 617 pr_warn(DRV_PFX "changing physical device (from %x:%x to %x:%x) not supported.\n", 618 be->major, be->minor, major, minor); 619 return; 620 } 621 622 be->mode = xenbus_read(XBT_NIL, dev->nodename, "mode", NULL); 623 if (IS_ERR(be->mode)) { 624 err = PTR_ERR(be->mode); 625 be->mode = NULL; 626 xenbus_dev_fatal(dev, err, "reading mode"); 627 return; 628 } 629 630 device_type = xenbus_read(XBT_NIL, dev->otherend, "device-type", NULL); 631 if (!IS_ERR(device_type)) { 632 cdrom = strcmp(device_type, "cdrom") == 0; 633 kfree(device_type); 634 } 635 636 /* Front end dir is a number, which is used as the handle. */ 637 err = kstrtoul(strrchr(dev->otherend, '/') + 1, 0, &handle); 638 if (err) 639 return; 640 641 be->major = major; 642 be->minor = minor; 643 644 err = xen_vbd_create(be->blkif, handle, major, minor, 645 !strchr(be->mode, 'w'), cdrom); 646 647 if (err) 648 xenbus_dev_fatal(dev, err, "creating vbd structure"); 649 else { 650 err = xenvbd_sysfs_addif(dev); 651 if (err) { 652 xen_vbd_free(&be->blkif->vbd); 653 xenbus_dev_fatal(dev, err, "creating sysfs entries"); 654 } 655 } 656 657 if (err) { 658 kfree(be->mode); 659 be->mode = NULL; 660 be->major = 0; 661 be->minor = 0; 662 } else { 663 /* We're potentially connected now */ 664 xen_update_blkif_status(be->blkif); 665 } 666 } 667 668 669 /* 670 * Callback received when the frontend's state changes. 671 */ 672 static void frontend_changed(struct xenbus_device *dev, 673 enum xenbus_state frontend_state) 674 { 675 struct backend_info *be = dev_get_drvdata(&dev->dev); 676 int err; 677 678 DPRINTK("%s", xenbus_strstate(frontend_state)); 679 680 switch (frontend_state) { 681 case XenbusStateInitialising: 682 if (dev->state == XenbusStateClosed) { 683 pr_info(DRV_PFX "%s: prepare for reconnect\n", 684 dev->nodename); 685 xenbus_switch_state(dev, XenbusStateInitWait); 686 } 687 break; 688 689 case XenbusStateInitialised: 690 case XenbusStateConnected: 691 /* 692 * Ensure we connect even when two watches fire in 693 * close succession and we miss the intermediate value 694 * of frontend_state. 695 */ 696 if (dev->state == XenbusStateConnected) 697 break; 698 699 /* 700 * Enforce precondition before potential leak point. 701 * xen_blkif_disconnect() is idempotent. 702 */ 703 xen_blkif_disconnect(be->blkif); 704 705 err = connect_ring(be); 706 if (err) 707 break; 708 xen_update_blkif_status(be->blkif); 709 break; 710 711 case XenbusStateClosing: 712 xenbus_switch_state(dev, XenbusStateClosing); 713 break; 714 715 case XenbusStateClosed: 716 xen_blkif_disconnect(be->blkif); 717 xenbus_switch_state(dev, XenbusStateClosed); 718 if (xenbus_dev_is_online(dev)) 719 break; 720 /* fall through if not online */ 721 case XenbusStateUnknown: 722 /* implies xen_blkif_disconnect() via xen_blkbk_remove() */ 723 device_unregister(&dev->dev); 724 break; 725 726 default: 727 xenbus_dev_fatal(dev, -EINVAL, "saw state %d at frontend", 728 frontend_state); 729 break; 730 } 731 } 732 733 734 /* ** Connection ** */ 735 736 737 /* 738 * Write the physical details regarding the block device to the store, and 739 * switch to Connected state. 740 */ 741 static void connect(struct backend_info *be) 742 { 743 struct xenbus_transaction xbt; 744 int err; 745 struct xenbus_device *dev = be->dev; 746 747 DPRINTK("%s", dev->otherend); 748 749 /* Supply the information about the device the frontend needs */ 750 again: 751 err = xenbus_transaction_start(&xbt); 752 if (err) { 753 xenbus_dev_fatal(dev, err, "starting transaction"); 754 return; 755 } 756 757 /* If we can't advertise it is OK. */ 758 xen_blkbk_flush_diskcache(xbt, be, be->blkif->vbd.flush_support); 759 760 xen_blkbk_discard(xbt, be); 761 762 xen_blkbk_barrier(xbt, be, be->blkif->vbd.flush_support); 763 764 err = xenbus_printf(xbt, dev->nodename, "feature-persistent", "%u", 1); 765 if (err) { 766 xenbus_dev_fatal(dev, err, "writing %s/feature-persistent", 767 dev->nodename); 768 goto abort; 769 } 770 err = xenbus_printf(xbt, dev->nodename, "feature-max-indirect-segments", "%u", 771 MAX_INDIRECT_SEGMENTS); 772 if (err) 773 dev_warn(&dev->dev, "writing %s/feature-max-indirect-segments (%d)", 774 dev->nodename, err); 775 776 err = xenbus_printf(xbt, dev->nodename, "sectors", "%llu", 777 (unsigned long long)vbd_sz(&be->blkif->vbd)); 778 if (err) { 779 xenbus_dev_fatal(dev, err, "writing %s/sectors", 780 dev->nodename); 781 goto abort; 782 } 783 784 /* FIXME: use a typename instead */ 785 err = xenbus_printf(xbt, dev->nodename, "info", "%u", 786 be->blkif->vbd.type | 787 (be->blkif->vbd.readonly ? VDISK_READONLY : 0)); 788 if (err) { 789 xenbus_dev_fatal(dev, err, "writing %s/info", 790 dev->nodename); 791 goto abort; 792 } 793 err = xenbus_printf(xbt, dev->nodename, "sector-size", "%lu", 794 (unsigned long) 795 bdev_logical_block_size(be->blkif->vbd.bdev)); 796 if (err) { 797 xenbus_dev_fatal(dev, err, "writing %s/sector-size", 798 dev->nodename); 799 goto abort; 800 } 801 err = xenbus_printf(xbt, dev->nodename, "physical-sector-size", "%u", 802 bdev_physical_block_size(be->blkif->vbd.bdev)); 803 if (err) 804 xenbus_dev_error(dev, err, "writing %s/physical-sector-size", 805 dev->nodename); 806 807 err = xenbus_transaction_end(xbt, 0); 808 if (err == -EAGAIN) 809 goto again; 810 if (err) 811 xenbus_dev_fatal(dev, err, "ending transaction"); 812 813 err = xenbus_switch_state(dev, XenbusStateConnected); 814 if (err) 815 xenbus_dev_fatal(dev, err, "%s: switching to Connected state", 816 dev->nodename); 817 818 return; 819 abort: 820 xenbus_transaction_end(xbt, 1); 821 } 822 823 824 static int connect_ring(struct backend_info *be) 825 { 826 struct xenbus_device *dev = be->dev; 827 unsigned long ring_ref; 828 unsigned int evtchn; 829 unsigned int pers_grants; 830 char protocol[64] = ""; 831 int err; 832 833 DPRINTK("%s", dev->otherend); 834 835 err = xenbus_gather(XBT_NIL, dev->otherend, "ring-ref", "%lu", 836 &ring_ref, "event-channel", "%u", &evtchn, NULL); 837 if (err) { 838 xenbus_dev_fatal(dev, err, 839 "reading %s/ring-ref and event-channel", 840 dev->otherend); 841 return err; 842 } 843 844 be->blkif->blk_protocol = BLKIF_PROTOCOL_NATIVE; 845 err = xenbus_gather(XBT_NIL, dev->otherend, "protocol", 846 "%63s", protocol, NULL); 847 if (err) 848 strcpy(protocol, "unspecified, assuming native"); 849 else if (0 == strcmp(protocol, XEN_IO_PROTO_ABI_NATIVE)) 850 be->blkif->blk_protocol = BLKIF_PROTOCOL_NATIVE; 851 else if (0 == strcmp(protocol, XEN_IO_PROTO_ABI_X86_32)) 852 be->blkif->blk_protocol = BLKIF_PROTOCOL_X86_32; 853 else if (0 == strcmp(protocol, XEN_IO_PROTO_ABI_X86_64)) 854 be->blkif->blk_protocol = BLKIF_PROTOCOL_X86_64; 855 else { 856 xenbus_dev_fatal(dev, err, "unknown fe protocol %s", protocol); 857 return -1; 858 } 859 err = xenbus_gather(XBT_NIL, dev->otherend, 860 "feature-persistent", "%u", 861 &pers_grants, NULL); 862 if (err) 863 pers_grants = 0; 864 865 be->blkif->vbd.feature_gnt_persistent = pers_grants; 866 be->blkif->vbd.overflow_max_grants = 0; 867 868 pr_info(DRV_PFX "ring-ref %ld, event-channel %d, protocol %d (%s) %s\n", 869 ring_ref, evtchn, be->blkif->blk_protocol, protocol, 870 pers_grants ? "persistent grants" : ""); 871 872 /* Map the shared frame, irq etc. */ 873 err = xen_blkif_map(be->blkif, ring_ref, evtchn); 874 if (err) { 875 xenbus_dev_fatal(dev, err, "mapping ring-ref %lu port %u", 876 ring_ref, evtchn); 877 return err; 878 } 879 880 return 0; 881 } 882 883 884 /* ** Driver Registration ** */ 885 886 887 static const struct xenbus_device_id xen_blkbk_ids[] = { 888 { "vbd" }, 889 { "" } 890 }; 891 892 893 static DEFINE_XENBUS_DRIVER(xen_blkbk, , 894 .probe = xen_blkbk_probe, 895 .remove = xen_blkbk_remove, 896 .otherend_changed = frontend_changed 897 ); 898 899 900 int xen_blkif_xenbus_init(void) 901 { 902 return xenbus_register_backend(&xen_blkbk_driver); 903 } 904