1 /* 2 * blkfront.c 3 * 4 * XenLinux virtual block device driver. 5 * 6 * Copyright (c) 2003-2004, Keir Fraser & Steve Hand 7 * Modifications by Mark A. Williamson are (c) Intel Research Cambridge 8 * Copyright (c) 2004, Christian Limpach 9 * Copyright (c) 2004, Andrew Warfield 10 * Copyright (c) 2005, Christopher Clark 11 * Copyright (c) 2005, XenSource Ltd 12 * 13 * This program is free software; you can redistribute it and/or 14 * modify it under the terms of the GNU General Public License version 2 15 * as published by the Free Software Foundation; or, when distributed 16 * separately from the Linux kernel or incorporated into other 17 * software packages, subject to the following license: 18 * 19 * Permission is hereby granted, free of charge, to any person obtaining a copy 20 * of this source file (the "Software"), to deal in the Software without 21 * restriction, including without limitation the rights to use, copy, modify, 22 * merge, publish, distribute, sublicense, and/or sell copies of the Software, 23 * and to permit persons to whom the Software is furnished to do so, subject to 24 * the following conditions: 25 * 26 * The above copyright notice and this permission notice shall be included in 27 * all copies or substantial portions of the Software. 28 * 29 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 30 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 31 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 32 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 33 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING 34 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS 35 * IN THE SOFTWARE. 36 */ 37 38 #include <linux/interrupt.h> 39 #include <linux/blkdev.h> 40 #include <linux/hdreg.h> 41 #include <linux/cdrom.h> 42 #include <linux/module.h> 43 #include <linux/slab.h> 44 #include <linux/mutex.h> 45 #include <linux/scatterlist.h> 46 #include <linux/bitmap.h> 47 #include <linux/llist.h> 48 49 #include <xen/xen.h> 50 #include <xen/xenbus.h> 51 #include <xen/grant_table.h> 52 #include <xen/events.h> 53 #include <xen/page.h> 54 #include <xen/platform_pci.h> 55 56 #include <xen/interface/grant_table.h> 57 #include <xen/interface/io/blkif.h> 58 #include <xen/interface/io/protocols.h> 59 60 #include <asm/xen/hypervisor.h> 61 62 enum blkif_state { 63 BLKIF_STATE_DISCONNECTED, 64 BLKIF_STATE_CONNECTED, 65 BLKIF_STATE_SUSPENDED, 66 }; 67 68 struct grant { 69 grant_ref_t gref; 70 unsigned long pfn; 71 struct llist_node node; 72 }; 73 74 struct blk_shadow { 75 struct blkif_request req; 76 struct request *request; 77 unsigned long frame[BLKIF_MAX_SEGMENTS_PER_REQUEST]; 78 struct grant *grants_used[BLKIF_MAX_SEGMENTS_PER_REQUEST]; 79 }; 80 81 static DEFINE_MUTEX(blkfront_mutex); 82 static const struct block_device_operations xlvbd_block_fops; 83 84 #define BLK_RING_SIZE __CONST_RING_SIZE(blkif, PAGE_SIZE) 85 86 /* 87 * We have one of these per vbd, whether ide, scsi or 'other'. They 88 * hang in private_data off the gendisk structure. We may end up 89 * putting all kinds of interesting stuff here :-) 90 */ 91 struct blkfront_info 92 { 93 spinlock_t io_lock; 94 struct mutex mutex; 95 struct xenbus_device *xbdev; 96 struct gendisk *gd; 97 int vdevice; 98 blkif_vdev_t handle; 99 enum blkif_state connected; 100 int ring_ref; 101 struct blkif_front_ring ring; 102 struct scatterlist sg[BLKIF_MAX_SEGMENTS_PER_REQUEST]; 103 unsigned int evtchn, irq; 104 struct request_queue *rq; 105 struct work_struct work; 106 struct gnttab_free_callback callback; 107 struct blk_shadow shadow[BLK_RING_SIZE]; 108 struct llist_head persistent_gnts; 109 unsigned int persistent_gnts_c; 110 unsigned long shadow_free; 111 unsigned int feature_flush; 112 unsigned int flush_op; 113 unsigned int feature_discard:1; 114 unsigned int feature_secdiscard:1; 115 unsigned int discard_granularity; 116 unsigned int discard_alignment; 117 unsigned int feature_persistent:1; 118 int is_ready; 119 }; 120 121 static unsigned int nr_minors; 122 static unsigned long *minors; 123 static DEFINE_SPINLOCK(minor_lock); 124 125 #define MAXIMUM_OUTSTANDING_BLOCK_REQS \ 126 (BLKIF_MAX_SEGMENTS_PER_REQUEST * BLK_RING_SIZE) 127 #define GRANT_INVALID_REF 0 128 129 #define PARTS_PER_DISK 16 130 #define PARTS_PER_EXT_DISK 256 131 132 #define BLKIF_MAJOR(dev) ((dev)>>8) 133 #define BLKIF_MINOR(dev) ((dev) & 0xff) 134 135 #define EXT_SHIFT 28 136 #define EXTENDED (1<<EXT_SHIFT) 137 #define VDEV_IS_EXTENDED(dev) ((dev)&(EXTENDED)) 138 #define BLKIF_MINOR_EXT(dev) ((dev)&(~EXTENDED)) 139 #define EMULATED_HD_DISK_MINOR_OFFSET (0) 140 #define EMULATED_HD_DISK_NAME_OFFSET (EMULATED_HD_DISK_MINOR_OFFSET / 256) 141 #define EMULATED_SD_DISK_MINOR_OFFSET (0) 142 #define EMULATED_SD_DISK_NAME_OFFSET (EMULATED_SD_DISK_MINOR_OFFSET / 256) 143 144 #define DEV_NAME "xvd" /* name in /dev */ 145 146 static int get_id_from_freelist(struct blkfront_info *info) 147 { 148 unsigned long free = info->shadow_free; 149 BUG_ON(free >= BLK_RING_SIZE); 150 info->shadow_free = info->shadow[free].req.u.rw.id; 151 info->shadow[free].req.u.rw.id = 0x0fffffee; /* debug */ 152 return free; 153 } 154 155 static int add_id_to_freelist(struct blkfront_info *info, 156 unsigned long id) 157 { 158 if (info->shadow[id].req.u.rw.id != id) 159 return -EINVAL; 160 if (info->shadow[id].request == NULL) 161 return -EINVAL; 162 info->shadow[id].req.u.rw.id = info->shadow_free; 163 info->shadow[id].request = NULL; 164 info->shadow_free = id; 165 return 0; 166 } 167 168 static const char *op_name(int op) 169 { 170 static const char *const names[] = { 171 [BLKIF_OP_READ] = "read", 172 [BLKIF_OP_WRITE] = "write", 173 [BLKIF_OP_WRITE_BARRIER] = "barrier", 174 [BLKIF_OP_FLUSH_DISKCACHE] = "flush", 175 [BLKIF_OP_DISCARD] = "discard" }; 176 177 if (op < 0 || op >= ARRAY_SIZE(names)) 178 return "unknown"; 179 180 if (!names[op]) 181 return "reserved"; 182 183 return names[op]; 184 } 185 static int xlbd_reserve_minors(unsigned int minor, unsigned int nr) 186 { 187 unsigned int end = minor + nr; 188 int rc; 189 190 if (end > nr_minors) { 191 unsigned long *bitmap, *old; 192 193 bitmap = kcalloc(BITS_TO_LONGS(end), sizeof(*bitmap), 194 GFP_KERNEL); 195 if (bitmap == NULL) 196 return -ENOMEM; 197 198 spin_lock(&minor_lock); 199 if (end > nr_minors) { 200 old = minors; 201 memcpy(bitmap, minors, 202 BITS_TO_LONGS(nr_minors) * sizeof(*bitmap)); 203 minors = bitmap; 204 nr_minors = BITS_TO_LONGS(end) * BITS_PER_LONG; 205 } else 206 old = bitmap; 207 spin_unlock(&minor_lock); 208 kfree(old); 209 } 210 211 spin_lock(&minor_lock); 212 if (find_next_bit(minors, end, minor) >= end) { 213 bitmap_set(minors, minor, nr); 214 rc = 0; 215 } else 216 rc = -EBUSY; 217 spin_unlock(&minor_lock); 218 219 return rc; 220 } 221 222 static void xlbd_release_minors(unsigned int minor, unsigned int nr) 223 { 224 unsigned int end = minor + nr; 225 226 BUG_ON(end > nr_minors); 227 spin_lock(&minor_lock); 228 bitmap_clear(minors, minor, nr); 229 spin_unlock(&minor_lock); 230 } 231 232 static void blkif_restart_queue_callback(void *arg) 233 { 234 struct blkfront_info *info = (struct blkfront_info *)arg; 235 schedule_work(&info->work); 236 } 237 238 static int blkif_getgeo(struct block_device *bd, struct hd_geometry *hg) 239 { 240 /* We don't have real geometry info, but let's at least return 241 values consistent with the size of the device */ 242 sector_t nsect = get_capacity(bd->bd_disk); 243 sector_t cylinders = nsect; 244 245 hg->heads = 0xff; 246 hg->sectors = 0x3f; 247 sector_div(cylinders, hg->heads * hg->sectors); 248 hg->cylinders = cylinders; 249 if ((sector_t)(hg->cylinders + 1) * hg->heads * hg->sectors < nsect) 250 hg->cylinders = 0xffff; 251 return 0; 252 } 253 254 static int blkif_ioctl(struct block_device *bdev, fmode_t mode, 255 unsigned command, unsigned long argument) 256 { 257 struct blkfront_info *info = bdev->bd_disk->private_data; 258 int i; 259 260 dev_dbg(&info->xbdev->dev, "command: 0x%x, argument: 0x%lx\n", 261 command, (long)argument); 262 263 switch (command) { 264 case CDROMMULTISESSION: 265 dev_dbg(&info->xbdev->dev, "FIXME: support multisession CDs later\n"); 266 for (i = 0; i < sizeof(struct cdrom_multisession); i++) 267 if (put_user(0, (char __user *)(argument + i))) 268 return -EFAULT; 269 return 0; 270 271 case CDROM_GET_CAPABILITY: { 272 struct gendisk *gd = info->gd; 273 if (gd->flags & GENHD_FL_CD) 274 return 0; 275 return -EINVAL; 276 } 277 278 default: 279 /*printk(KERN_ALERT "ioctl %08x not supported by Xen blkdev\n", 280 command);*/ 281 return -EINVAL; /* same return as native Linux */ 282 } 283 284 return 0; 285 } 286 287 /* 288 * Generate a Xen blkfront IO request from a blk layer request. Reads 289 * and writes are handled as expected. 290 * 291 * @req: a request struct 292 */ 293 static int blkif_queue_request(struct request *req) 294 { 295 struct blkfront_info *info = req->rq_disk->private_data; 296 unsigned long buffer_mfn; 297 struct blkif_request *ring_req; 298 unsigned long id; 299 unsigned int fsect, lsect; 300 int i, ref; 301 302 /* 303 * Used to store if we are able to queue the request by just using 304 * existing persistent grants, or if we have to get new grants, 305 * as there are not sufficiently many free. 306 */ 307 bool new_persistent_gnts; 308 grant_ref_t gref_head; 309 struct page *granted_page; 310 struct grant *gnt_list_entry = NULL; 311 struct scatterlist *sg; 312 313 if (unlikely(info->connected != BLKIF_STATE_CONNECTED)) 314 return 1; 315 316 /* Check if we have enought grants to allocate a requests */ 317 if (info->persistent_gnts_c < BLKIF_MAX_SEGMENTS_PER_REQUEST) { 318 new_persistent_gnts = 1; 319 if (gnttab_alloc_grant_references( 320 BLKIF_MAX_SEGMENTS_PER_REQUEST - info->persistent_gnts_c, 321 &gref_head) < 0) { 322 gnttab_request_free_callback( 323 &info->callback, 324 blkif_restart_queue_callback, 325 info, 326 BLKIF_MAX_SEGMENTS_PER_REQUEST); 327 return 1; 328 } 329 } else 330 new_persistent_gnts = 0; 331 332 /* Fill out a communications ring structure. */ 333 ring_req = RING_GET_REQUEST(&info->ring, info->ring.req_prod_pvt); 334 id = get_id_from_freelist(info); 335 info->shadow[id].request = req; 336 337 ring_req->u.rw.id = id; 338 ring_req->u.rw.sector_number = (blkif_sector_t)blk_rq_pos(req); 339 ring_req->u.rw.handle = info->handle; 340 341 ring_req->operation = rq_data_dir(req) ? 342 BLKIF_OP_WRITE : BLKIF_OP_READ; 343 344 if (req->cmd_flags & (REQ_FLUSH | REQ_FUA)) { 345 /* 346 * Ideally we can do an unordered flush-to-disk. In case the 347 * backend onlysupports barriers, use that. A barrier request 348 * a superset of FUA, so we can implement it the same 349 * way. (It's also a FLUSH+FUA, since it is 350 * guaranteed ordered WRT previous writes.) 351 */ 352 ring_req->operation = info->flush_op; 353 } 354 355 if (unlikely(req->cmd_flags & (REQ_DISCARD | REQ_SECURE))) { 356 /* id, sector_number and handle are set above. */ 357 ring_req->operation = BLKIF_OP_DISCARD; 358 ring_req->u.discard.nr_sectors = blk_rq_sectors(req); 359 if ((req->cmd_flags & REQ_SECURE) && info->feature_secdiscard) 360 ring_req->u.discard.flag = BLKIF_DISCARD_SECURE; 361 else 362 ring_req->u.discard.flag = 0; 363 } else { 364 ring_req->u.rw.nr_segments = blk_rq_map_sg(req->q, req, 365 info->sg); 366 BUG_ON(ring_req->u.rw.nr_segments > 367 BLKIF_MAX_SEGMENTS_PER_REQUEST); 368 369 for_each_sg(info->sg, sg, ring_req->u.rw.nr_segments, i) { 370 fsect = sg->offset >> 9; 371 lsect = fsect + (sg->length >> 9) - 1; 372 373 if (info->persistent_gnts_c) { 374 BUG_ON(llist_empty(&info->persistent_gnts)); 375 gnt_list_entry = llist_entry( 376 llist_del_first(&info->persistent_gnts), 377 struct grant, node); 378 379 ref = gnt_list_entry->gref; 380 buffer_mfn = pfn_to_mfn(gnt_list_entry->pfn); 381 info->persistent_gnts_c--; 382 } else { 383 ref = gnttab_claim_grant_reference(&gref_head); 384 BUG_ON(ref == -ENOSPC); 385 386 gnt_list_entry = 387 kmalloc(sizeof(struct grant), 388 GFP_ATOMIC); 389 if (!gnt_list_entry) 390 return -ENOMEM; 391 392 granted_page = alloc_page(GFP_ATOMIC); 393 if (!granted_page) { 394 kfree(gnt_list_entry); 395 return -ENOMEM; 396 } 397 398 gnt_list_entry->pfn = 399 page_to_pfn(granted_page); 400 gnt_list_entry->gref = ref; 401 402 buffer_mfn = pfn_to_mfn(page_to_pfn( 403 granted_page)); 404 gnttab_grant_foreign_access_ref(ref, 405 info->xbdev->otherend_id, 406 buffer_mfn, 0); 407 } 408 409 info->shadow[id].grants_used[i] = gnt_list_entry; 410 411 if (rq_data_dir(req)) { 412 char *bvec_data; 413 void *shared_data; 414 415 BUG_ON(sg->offset + sg->length > PAGE_SIZE); 416 417 shared_data = kmap_atomic( 418 pfn_to_page(gnt_list_entry->pfn)); 419 bvec_data = kmap_atomic(sg_page(sg)); 420 421 /* 422 * this does not wipe data stored outside the 423 * range sg->offset..sg->offset+sg->length. 424 * Therefore, blkback *could* see data from 425 * previous requests. This is OK as long as 426 * persistent grants are shared with just one 427 * domain. It may need refactoring if this 428 * changes 429 */ 430 memcpy(shared_data + sg->offset, 431 bvec_data + sg->offset, 432 sg->length); 433 434 kunmap_atomic(bvec_data); 435 kunmap_atomic(shared_data); 436 } 437 438 info->shadow[id].frame[i] = mfn_to_pfn(buffer_mfn); 439 ring_req->u.rw.seg[i] = 440 (struct blkif_request_segment) { 441 .gref = ref, 442 .first_sect = fsect, 443 .last_sect = lsect }; 444 } 445 } 446 447 info->ring.req_prod_pvt++; 448 449 /* Keep a private copy so we can reissue requests when recovering. */ 450 info->shadow[id].req = *ring_req; 451 452 if (new_persistent_gnts) 453 gnttab_free_grant_references(gref_head); 454 455 return 0; 456 } 457 458 459 static inline void flush_requests(struct blkfront_info *info) 460 { 461 int notify; 462 463 RING_PUSH_REQUESTS_AND_CHECK_NOTIFY(&info->ring, notify); 464 465 if (notify) 466 notify_remote_via_irq(info->irq); 467 } 468 469 /* 470 * do_blkif_request 471 * read a block; request is in a request queue 472 */ 473 static void do_blkif_request(struct request_queue *rq) 474 { 475 struct blkfront_info *info = NULL; 476 struct request *req; 477 int queued; 478 479 pr_debug("Entered do_blkif_request\n"); 480 481 queued = 0; 482 483 while ((req = blk_peek_request(rq)) != NULL) { 484 info = req->rq_disk->private_data; 485 486 if (RING_FULL(&info->ring)) 487 goto wait; 488 489 blk_start_request(req); 490 491 if ((req->cmd_type != REQ_TYPE_FS) || 492 ((req->cmd_flags & (REQ_FLUSH | REQ_FUA)) && 493 !info->flush_op)) { 494 __blk_end_request_all(req, -EIO); 495 continue; 496 } 497 498 pr_debug("do_blk_req %p: cmd %p, sec %lx, " 499 "(%u/%u) buffer:%p [%s]\n", 500 req, req->cmd, (unsigned long)blk_rq_pos(req), 501 blk_rq_cur_sectors(req), blk_rq_sectors(req), 502 req->buffer, rq_data_dir(req) ? "write" : "read"); 503 504 if (blkif_queue_request(req)) { 505 blk_requeue_request(rq, req); 506 wait: 507 /* Avoid pointless unplugs. */ 508 blk_stop_queue(rq); 509 break; 510 } 511 512 queued++; 513 } 514 515 if (queued != 0) 516 flush_requests(info); 517 } 518 519 static int xlvbd_init_blk_queue(struct gendisk *gd, u16 sector_size) 520 { 521 struct request_queue *rq; 522 struct blkfront_info *info = gd->private_data; 523 524 rq = blk_init_queue(do_blkif_request, &info->io_lock); 525 if (rq == NULL) 526 return -1; 527 528 queue_flag_set_unlocked(QUEUE_FLAG_VIRT, rq); 529 530 if (info->feature_discard) { 531 queue_flag_set_unlocked(QUEUE_FLAG_DISCARD, rq); 532 blk_queue_max_discard_sectors(rq, get_capacity(gd)); 533 rq->limits.discard_granularity = info->discard_granularity; 534 rq->limits.discard_alignment = info->discard_alignment; 535 if (info->feature_secdiscard) 536 queue_flag_set_unlocked(QUEUE_FLAG_SECDISCARD, rq); 537 } 538 539 /* Hard sector size and max sectors impersonate the equiv. hardware. */ 540 blk_queue_logical_block_size(rq, sector_size); 541 blk_queue_max_hw_sectors(rq, 512); 542 543 /* Each segment in a request is up to an aligned page in size. */ 544 blk_queue_segment_boundary(rq, PAGE_SIZE - 1); 545 blk_queue_max_segment_size(rq, PAGE_SIZE); 546 547 /* Ensure a merged request will fit in a single I/O ring slot. */ 548 blk_queue_max_segments(rq, BLKIF_MAX_SEGMENTS_PER_REQUEST); 549 550 /* Make sure buffer addresses are sector-aligned. */ 551 blk_queue_dma_alignment(rq, 511); 552 553 /* Make sure we don't use bounce buffers. */ 554 blk_queue_bounce_limit(rq, BLK_BOUNCE_ANY); 555 556 gd->queue = rq; 557 558 return 0; 559 } 560 561 562 static void xlvbd_flush(struct blkfront_info *info) 563 { 564 blk_queue_flush(info->rq, info->feature_flush); 565 printk(KERN_INFO "blkfront: %s: %s: %s %s\n", 566 info->gd->disk_name, 567 info->flush_op == BLKIF_OP_WRITE_BARRIER ? 568 "barrier" : (info->flush_op == BLKIF_OP_FLUSH_DISKCACHE ? 569 "flush diskcache" : "barrier or flush"), 570 info->feature_flush ? "enabled" : "disabled", 571 info->feature_persistent ? "using persistent grants" : ""); 572 } 573 574 static int xen_translate_vdev(int vdevice, int *minor, unsigned int *offset) 575 { 576 int major; 577 major = BLKIF_MAJOR(vdevice); 578 *minor = BLKIF_MINOR(vdevice); 579 switch (major) { 580 case XEN_IDE0_MAJOR: 581 *offset = (*minor / 64) + EMULATED_HD_DISK_NAME_OFFSET; 582 *minor = ((*minor / 64) * PARTS_PER_DISK) + 583 EMULATED_HD_DISK_MINOR_OFFSET; 584 break; 585 case XEN_IDE1_MAJOR: 586 *offset = (*minor / 64) + 2 + EMULATED_HD_DISK_NAME_OFFSET; 587 *minor = (((*minor / 64) + 2) * PARTS_PER_DISK) + 588 EMULATED_HD_DISK_MINOR_OFFSET; 589 break; 590 case XEN_SCSI_DISK0_MAJOR: 591 *offset = (*minor / PARTS_PER_DISK) + EMULATED_SD_DISK_NAME_OFFSET; 592 *minor = *minor + EMULATED_SD_DISK_MINOR_OFFSET; 593 break; 594 case XEN_SCSI_DISK1_MAJOR: 595 case XEN_SCSI_DISK2_MAJOR: 596 case XEN_SCSI_DISK3_MAJOR: 597 case XEN_SCSI_DISK4_MAJOR: 598 case XEN_SCSI_DISK5_MAJOR: 599 case XEN_SCSI_DISK6_MAJOR: 600 case XEN_SCSI_DISK7_MAJOR: 601 *offset = (*minor / PARTS_PER_DISK) + 602 ((major - XEN_SCSI_DISK1_MAJOR + 1) * 16) + 603 EMULATED_SD_DISK_NAME_OFFSET; 604 *minor = *minor + 605 ((major - XEN_SCSI_DISK1_MAJOR + 1) * 16 * PARTS_PER_DISK) + 606 EMULATED_SD_DISK_MINOR_OFFSET; 607 break; 608 case XEN_SCSI_DISK8_MAJOR: 609 case XEN_SCSI_DISK9_MAJOR: 610 case XEN_SCSI_DISK10_MAJOR: 611 case XEN_SCSI_DISK11_MAJOR: 612 case XEN_SCSI_DISK12_MAJOR: 613 case XEN_SCSI_DISK13_MAJOR: 614 case XEN_SCSI_DISK14_MAJOR: 615 case XEN_SCSI_DISK15_MAJOR: 616 *offset = (*minor / PARTS_PER_DISK) + 617 ((major - XEN_SCSI_DISK8_MAJOR + 8) * 16) + 618 EMULATED_SD_DISK_NAME_OFFSET; 619 *minor = *minor + 620 ((major - XEN_SCSI_DISK8_MAJOR + 8) * 16 * PARTS_PER_DISK) + 621 EMULATED_SD_DISK_MINOR_OFFSET; 622 break; 623 case XENVBD_MAJOR: 624 *offset = *minor / PARTS_PER_DISK; 625 break; 626 default: 627 printk(KERN_WARNING "blkfront: your disk configuration is " 628 "incorrect, please use an xvd device instead\n"); 629 return -ENODEV; 630 } 631 return 0; 632 } 633 634 static char *encode_disk_name(char *ptr, unsigned int n) 635 { 636 if (n >= 26) 637 ptr = encode_disk_name(ptr, n / 26 - 1); 638 *ptr = 'a' + n % 26; 639 return ptr + 1; 640 } 641 642 static int xlvbd_alloc_gendisk(blkif_sector_t capacity, 643 struct blkfront_info *info, 644 u16 vdisk_info, u16 sector_size) 645 { 646 struct gendisk *gd; 647 int nr_minors = 1; 648 int err; 649 unsigned int offset; 650 int minor; 651 int nr_parts; 652 char *ptr; 653 654 BUG_ON(info->gd != NULL); 655 BUG_ON(info->rq != NULL); 656 657 if ((info->vdevice>>EXT_SHIFT) > 1) { 658 /* this is above the extended range; something is wrong */ 659 printk(KERN_WARNING "blkfront: vdevice 0x%x is above the extended range; ignoring\n", info->vdevice); 660 return -ENODEV; 661 } 662 663 if (!VDEV_IS_EXTENDED(info->vdevice)) { 664 err = xen_translate_vdev(info->vdevice, &minor, &offset); 665 if (err) 666 return err; 667 nr_parts = PARTS_PER_DISK; 668 } else { 669 minor = BLKIF_MINOR_EXT(info->vdevice); 670 nr_parts = PARTS_PER_EXT_DISK; 671 offset = minor / nr_parts; 672 if (xen_hvm_domain() && offset < EMULATED_HD_DISK_NAME_OFFSET + 4) 673 printk(KERN_WARNING "blkfront: vdevice 0x%x might conflict with " 674 "emulated IDE disks,\n\t choose an xvd device name" 675 "from xvde on\n", info->vdevice); 676 } 677 if (minor >> MINORBITS) { 678 pr_warn("blkfront: %#x's minor (%#x) out of range; ignoring\n", 679 info->vdevice, minor); 680 return -ENODEV; 681 } 682 683 if ((minor % nr_parts) == 0) 684 nr_minors = nr_parts; 685 686 err = xlbd_reserve_minors(minor, nr_minors); 687 if (err) 688 goto out; 689 err = -ENODEV; 690 691 gd = alloc_disk(nr_minors); 692 if (gd == NULL) 693 goto release; 694 695 strcpy(gd->disk_name, DEV_NAME); 696 ptr = encode_disk_name(gd->disk_name + sizeof(DEV_NAME) - 1, offset); 697 BUG_ON(ptr >= gd->disk_name + DISK_NAME_LEN); 698 if (nr_minors > 1) 699 *ptr = 0; 700 else 701 snprintf(ptr, gd->disk_name + DISK_NAME_LEN - ptr, 702 "%d", minor & (nr_parts - 1)); 703 704 gd->major = XENVBD_MAJOR; 705 gd->first_minor = minor; 706 gd->fops = &xlvbd_block_fops; 707 gd->private_data = info; 708 gd->driverfs_dev = &(info->xbdev->dev); 709 set_capacity(gd, capacity); 710 711 if (xlvbd_init_blk_queue(gd, sector_size)) { 712 del_gendisk(gd); 713 goto release; 714 } 715 716 info->rq = gd->queue; 717 info->gd = gd; 718 719 xlvbd_flush(info); 720 721 if (vdisk_info & VDISK_READONLY) 722 set_disk_ro(gd, 1); 723 724 if (vdisk_info & VDISK_REMOVABLE) 725 gd->flags |= GENHD_FL_REMOVABLE; 726 727 if (vdisk_info & VDISK_CDROM) 728 gd->flags |= GENHD_FL_CD; 729 730 return 0; 731 732 release: 733 xlbd_release_minors(minor, nr_minors); 734 out: 735 return err; 736 } 737 738 static void xlvbd_release_gendisk(struct blkfront_info *info) 739 { 740 unsigned int minor, nr_minors; 741 unsigned long flags; 742 743 if (info->rq == NULL) 744 return; 745 746 spin_lock_irqsave(&info->io_lock, flags); 747 748 /* No more blkif_request(). */ 749 blk_stop_queue(info->rq); 750 751 /* No more gnttab callback work. */ 752 gnttab_cancel_free_callback(&info->callback); 753 spin_unlock_irqrestore(&info->io_lock, flags); 754 755 /* Flush gnttab callback work. Must be done with no locks held. */ 756 flush_work(&info->work); 757 758 del_gendisk(info->gd); 759 760 minor = info->gd->first_minor; 761 nr_minors = info->gd->minors; 762 xlbd_release_minors(minor, nr_minors); 763 764 blk_cleanup_queue(info->rq); 765 info->rq = NULL; 766 767 put_disk(info->gd); 768 info->gd = NULL; 769 } 770 771 static void kick_pending_request_queues(struct blkfront_info *info) 772 { 773 if (!RING_FULL(&info->ring)) { 774 /* Re-enable calldowns. */ 775 blk_start_queue(info->rq); 776 /* Kick things off immediately. */ 777 do_blkif_request(info->rq); 778 } 779 } 780 781 static void blkif_restart_queue(struct work_struct *work) 782 { 783 struct blkfront_info *info = container_of(work, struct blkfront_info, work); 784 785 spin_lock_irq(&info->io_lock); 786 if (info->connected == BLKIF_STATE_CONNECTED) 787 kick_pending_request_queues(info); 788 spin_unlock_irq(&info->io_lock); 789 } 790 791 static void blkif_free(struct blkfront_info *info, int suspend) 792 { 793 struct llist_node *all_gnts; 794 struct grant *persistent_gnt, *tmp; 795 struct llist_node *n; 796 797 /* Prevent new requests being issued until we fix things up. */ 798 spin_lock_irq(&info->io_lock); 799 info->connected = suspend ? 800 BLKIF_STATE_SUSPENDED : BLKIF_STATE_DISCONNECTED; 801 /* No more blkif_request(). */ 802 if (info->rq) 803 blk_stop_queue(info->rq); 804 805 /* Remove all persistent grants */ 806 if (info->persistent_gnts_c) { 807 all_gnts = llist_del_all(&info->persistent_gnts); 808 persistent_gnt = llist_entry(all_gnts, typeof(*(persistent_gnt)), node); 809 while (persistent_gnt) { 810 gnttab_end_foreign_access(persistent_gnt->gref, 0, 0UL); 811 __free_page(pfn_to_page(persistent_gnt->pfn)); 812 tmp = persistent_gnt; 813 n = persistent_gnt->node.next; 814 if (n) 815 persistent_gnt = llist_entry(n, typeof(*(persistent_gnt)), node); 816 else 817 persistent_gnt = NULL; 818 kfree(tmp); 819 } 820 info->persistent_gnts_c = 0; 821 } 822 823 /* No more gnttab callback work. */ 824 gnttab_cancel_free_callback(&info->callback); 825 spin_unlock_irq(&info->io_lock); 826 827 /* Flush gnttab callback work. Must be done with no locks held. */ 828 flush_work(&info->work); 829 830 /* Free resources associated with old device channel. */ 831 if (info->ring_ref != GRANT_INVALID_REF) { 832 gnttab_end_foreign_access(info->ring_ref, 0, 833 (unsigned long)info->ring.sring); 834 info->ring_ref = GRANT_INVALID_REF; 835 info->ring.sring = NULL; 836 } 837 if (info->irq) 838 unbind_from_irqhandler(info->irq, info); 839 info->evtchn = info->irq = 0; 840 841 } 842 843 static void blkif_completion(struct blk_shadow *s, struct blkfront_info *info, 844 struct blkif_response *bret) 845 { 846 int i = 0; 847 struct bio_vec *bvec; 848 struct req_iterator iter; 849 unsigned long flags; 850 char *bvec_data; 851 void *shared_data; 852 unsigned int offset = 0; 853 854 if (bret->operation == BLKIF_OP_READ) { 855 /* 856 * Copy the data received from the backend into the bvec. 857 * Since bv_offset can be different than 0, and bv_len different 858 * than PAGE_SIZE, we have to keep track of the current offset, 859 * to be sure we are copying the data from the right shared page. 860 */ 861 rq_for_each_segment(bvec, s->request, iter) { 862 BUG_ON((bvec->bv_offset + bvec->bv_len) > PAGE_SIZE); 863 if (bvec->bv_offset < offset) 864 i++; 865 BUG_ON(i >= s->req.u.rw.nr_segments); 866 shared_data = kmap_atomic( 867 pfn_to_page(s->grants_used[i]->pfn)); 868 bvec_data = bvec_kmap_irq(bvec, &flags); 869 memcpy(bvec_data, shared_data + bvec->bv_offset, 870 bvec->bv_len); 871 bvec_kunmap_irq(bvec_data, &flags); 872 kunmap_atomic(shared_data); 873 offset = bvec->bv_offset + bvec->bv_len; 874 } 875 } 876 /* Add the persistent grant into the list of free grants */ 877 for (i = 0; i < s->req.u.rw.nr_segments; i++) { 878 llist_add(&s->grants_used[i]->node, &info->persistent_gnts); 879 info->persistent_gnts_c++; 880 } 881 } 882 883 static irqreturn_t blkif_interrupt(int irq, void *dev_id) 884 { 885 struct request *req; 886 struct blkif_response *bret; 887 RING_IDX i, rp; 888 unsigned long flags; 889 struct blkfront_info *info = (struct blkfront_info *)dev_id; 890 int error; 891 892 spin_lock_irqsave(&info->io_lock, flags); 893 894 if (unlikely(info->connected != BLKIF_STATE_CONNECTED)) { 895 spin_unlock_irqrestore(&info->io_lock, flags); 896 return IRQ_HANDLED; 897 } 898 899 again: 900 rp = info->ring.sring->rsp_prod; 901 rmb(); /* Ensure we see queued responses up to 'rp'. */ 902 903 for (i = info->ring.rsp_cons; i != rp; i++) { 904 unsigned long id; 905 906 bret = RING_GET_RESPONSE(&info->ring, i); 907 id = bret->id; 908 /* 909 * The backend has messed up and given us an id that we would 910 * never have given to it (we stamp it up to BLK_RING_SIZE - 911 * look in get_id_from_freelist. 912 */ 913 if (id >= BLK_RING_SIZE) { 914 WARN(1, "%s: response to %s has incorrect id (%ld)\n", 915 info->gd->disk_name, op_name(bret->operation), id); 916 /* We can't safely get the 'struct request' as 917 * the id is busted. */ 918 continue; 919 } 920 req = info->shadow[id].request; 921 922 if (bret->operation != BLKIF_OP_DISCARD) 923 blkif_completion(&info->shadow[id], info, bret); 924 925 if (add_id_to_freelist(info, id)) { 926 WARN(1, "%s: response to %s (id %ld) couldn't be recycled!\n", 927 info->gd->disk_name, op_name(bret->operation), id); 928 continue; 929 } 930 931 error = (bret->status == BLKIF_RSP_OKAY) ? 0 : -EIO; 932 switch (bret->operation) { 933 case BLKIF_OP_DISCARD: 934 if (unlikely(bret->status == BLKIF_RSP_EOPNOTSUPP)) { 935 struct request_queue *rq = info->rq; 936 printk(KERN_WARNING "blkfront: %s: %s op failed\n", 937 info->gd->disk_name, op_name(bret->operation)); 938 error = -EOPNOTSUPP; 939 info->feature_discard = 0; 940 info->feature_secdiscard = 0; 941 queue_flag_clear(QUEUE_FLAG_DISCARD, rq); 942 queue_flag_clear(QUEUE_FLAG_SECDISCARD, rq); 943 } 944 __blk_end_request_all(req, error); 945 break; 946 case BLKIF_OP_FLUSH_DISKCACHE: 947 case BLKIF_OP_WRITE_BARRIER: 948 if (unlikely(bret->status == BLKIF_RSP_EOPNOTSUPP)) { 949 printk(KERN_WARNING "blkfront: %s: %s op failed\n", 950 info->gd->disk_name, op_name(bret->operation)); 951 error = -EOPNOTSUPP; 952 } 953 if (unlikely(bret->status == BLKIF_RSP_ERROR && 954 info->shadow[id].req.u.rw.nr_segments == 0)) { 955 printk(KERN_WARNING "blkfront: %s: empty %s op failed\n", 956 info->gd->disk_name, op_name(bret->operation)); 957 error = -EOPNOTSUPP; 958 } 959 if (unlikely(error)) { 960 if (error == -EOPNOTSUPP) 961 error = 0; 962 info->feature_flush = 0; 963 info->flush_op = 0; 964 xlvbd_flush(info); 965 } 966 /* fall through */ 967 case BLKIF_OP_READ: 968 case BLKIF_OP_WRITE: 969 if (unlikely(bret->status != BLKIF_RSP_OKAY)) 970 dev_dbg(&info->xbdev->dev, "Bad return from blkdev data " 971 "request: %x\n", bret->status); 972 973 __blk_end_request_all(req, error); 974 break; 975 default: 976 BUG(); 977 } 978 } 979 980 info->ring.rsp_cons = i; 981 982 if (i != info->ring.req_prod_pvt) { 983 int more_to_do; 984 RING_FINAL_CHECK_FOR_RESPONSES(&info->ring, more_to_do); 985 if (more_to_do) 986 goto again; 987 } else 988 info->ring.sring->rsp_event = i + 1; 989 990 kick_pending_request_queues(info); 991 992 spin_unlock_irqrestore(&info->io_lock, flags); 993 994 return IRQ_HANDLED; 995 } 996 997 998 static int setup_blkring(struct xenbus_device *dev, 999 struct blkfront_info *info) 1000 { 1001 struct blkif_sring *sring; 1002 int err; 1003 1004 info->ring_ref = GRANT_INVALID_REF; 1005 1006 sring = (struct blkif_sring *)__get_free_page(GFP_NOIO | __GFP_HIGH); 1007 if (!sring) { 1008 xenbus_dev_fatal(dev, -ENOMEM, "allocating shared ring"); 1009 return -ENOMEM; 1010 } 1011 SHARED_RING_INIT(sring); 1012 FRONT_RING_INIT(&info->ring, sring, PAGE_SIZE); 1013 1014 sg_init_table(info->sg, BLKIF_MAX_SEGMENTS_PER_REQUEST); 1015 1016 err = xenbus_grant_ring(dev, virt_to_mfn(info->ring.sring)); 1017 if (err < 0) { 1018 free_page((unsigned long)sring); 1019 info->ring.sring = NULL; 1020 goto fail; 1021 } 1022 info->ring_ref = err; 1023 1024 err = xenbus_alloc_evtchn(dev, &info->evtchn); 1025 if (err) 1026 goto fail; 1027 1028 err = bind_evtchn_to_irqhandler(info->evtchn, blkif_interrupt, 0, 1029 "blkif", info); 1030 if (err <= 0) { 1031 xenbus_dev_fatal(dev, err, 1032 "bind_evtchn_to_irqhandler failed"); 1033 goto fail; 1034 } 1035 info->irq = err; 1036 1037 return 0; 1038 fail: 1039 blkif_free(info, 0); 1040 return err; 1041 } 1042 1043 1044 /* Common code used when first setting up, and when resuming. */ 1045 static int talk_to_blkback(struct xenbus_device *dev, 1046 struct blkfront_info *info) 1047 { 1048 const char *message = NULL; 1049 struct xenbus_transaction xbt; 1050 int err; 1051 1052 /* Create shared ring, alloc event channel. */ 1053 err = setup_blkring(dev, info); 1054 if (err) 1055 goto out; 1056 1057 again: 1058 err = xenbus_transaction_start(&xbt); 1059 if (err) { 1060 xenbus_dev_fatal(dev, err, "starting transaction"); 1061 goto destroy_blkring; 1062 } 1063 1064 err = xenbus_printf(xbt, dev->nodename, 1065 "ring-ref", "%u", info->ring_ref); 1066 if (err) { 1067 message = "writing ring-ref"; 1068 goto abort_transaction; 1069 } 1070 err = xenbus_printf(xbt, dev->nodename, 1071 "event-channel", "%u", info->evtchn); 1072 if (err) { 1073 message = "writing event-channel"; 1074 goto abort_transaction; 1075 } 1076 err = xenbus_printf(xbt, dev->nodename, "protocol", "%s", 1077 XEN_IO_PROTO_ABI_NATIVE); 1078 if (err) { 1079 message = "writing protocol"; 1080 goto abort_transaction; 1081 } 1082 err = xenbus_printf(xbt, dev->nodename, 1083 "feature-persistent", "%u", 1); 1084 if (err) 1085 dev_warn(&dev->dev, 1086 "writing persistent grants feature to xenbus"); 1087 1088 err = xenbus_transaction_end(xbt, 0); 1089 if (err) { 1090 if (err == -EAGAIN) 1091 goto again; 1092 xenbus_dev_fatal(dev, err, "completing transaction"); 1093 goto destroy_blkring; 1094 } 1095 1096 xenbus_switch_state(dev, XenbusStateInitialised); 1097 1098 return 0; 1099 1100 abort_transaction: 1101 xenbus_transaction_end(xbt, 1); 1102 if (message) 1103 xenbus_dev_fatal(dev, err, "%s", message); 1104 destroy_blkring: 1105 blkif_free(info, 0); 1106 out: 1107 return err; 1108 } 1109 1110 /** 1111 * Entry point to this code when a new device is created. Allocate the basic 1112 * structures and the ring buffer for communication with the backend, and 1113 * inform the backend of the appropriate details for those. Switch to 1114 * Initialised state. 1115 */ 1116 static int blkfront_probe(struct xenbus_device *dev, 1117 const struct xenbus_device_id *id) 1118 { 1119 int err, vdevice, i; 1120 struct blkfront_info *info; 1121 1122 /* FIXME: Use dynamic device id if this is not set. */ 1123 err = xenbus_scanf(XBT_NIL, dev->nodename, 1124 "virtual-device", "%i", &vdevice); 1125 if (err != 1) { 1126 /* go looking in the extended area instead */ 1127 err = xenbus_scanf(XBT_NIL, dev->nodename, "virtual-device-ext", 1128 "%i", &vdevice); 1129 if (err != 1) { 1130 xenbus_dev_fatal(dev, err, "reading virtual-device"); 1131 return err; 1132 } 1133 } 1134 1135 if (xen_hvm_domain()) { 1136 char *type; 1137 int len; 1138 /* no unplug has been done: do not hook devices != xen vbds */ 1139 if (xen_platform_pci_unplug & XEN_UNPLUG_UNNECESSARY) { 1140 int major; 1141 1142 if (!VDEV_IS_EXTENDED(vdevice)) 1143 major = BLKIF_MAJOR(vdevice); 1144 else 1145 major = XENVBD_MAJOR; 1146 1147 if (major != XENVBD_MAJOR) { 1148 printk(KERN_INFO 1149 "%s: HVM does not support vbd %d as xen block device\n", 1150 __FUNCTION__, vdevice); 1151 return -ENODEV; 1152 } 1153 } 1154 /* do not create a PV cdrom device if we are an HVM guest */ 1155 type = xenbus_read(XBT_NIL, dev->nodename, "device-type", &len); 1156 if (IS_ERR(type)) 1157 return -ENODEV; 1158 if (strncmp(type, "cdrom", 5) == 0) { 1159 kfree(type); 1160 return -ENODEV; 1161 } 1162 kfree(type); 1163 } 1164 info = kzalloc(sizeof(*info), GFP_KERNEL); 1165 if (!info) { 1166 xenbus_dev_fatal(dev, -ENOMEM, "allocating info structure"); 1167 return -ENOMEM; 1168 } 1169 1170 mutex_init(&info->mutex); 1171 spin_lock_init(&info->io_lock); 1172 info->xbdev = dev; 1173 info->vdevice = vdevice; 1174 init_llist_head(&info->persistent_gnts); 1175 info->persistent_gnts_c = 0; 1176 info->connected = BLKIF_STATE_DISCONNECTED; 1177 INIT_WORK(&info->work, blkif_restart_queue); 1178 1179 for (i = 0; i < BLK_RING_SIZE; i++) 1180 info->shadow[i].req.u.rw.id = i+1; 1181 info->shadow[BLK_RING_SIZE-1].req.u.rw.id = 0x0fffffff; 1182 1183 /* Front end dir is a number, which is used as the id. */ 1184 info->handle = simple_strtoul(strrchr(dev->nodename, '/')+1, NULL, 0); 1185 dev_set_drvdata(&dev->dev, info); 1186 1187 err = talk_to_blkback(dev, info); 1188 if (err) { 1189 kfree(info); 1190 dev_set_drvdata(&dev->dev, NULL); 1191 return err; 1192 } 1193 1194 return 0; 1195 } 1196 1197 1198 static int blkif_recover(struct blkfront_info *info) 1199 { 1200 int i; 1201 struct blkif_request *req; 1202 struct blk_shadow *copy; 1203 int j; 1204 1205 /* Stage 1: Make a safe copy of the shadow state. */ 1206 copy = kmalloc(sizeof(info->shadow), 1207 GFP_NOIO | __GFP_REPEAT | __GFP_HIGH); 1208 if (!copy) 1209 return -ENOMEM; 1210 memcpy(copy, info->shadow, sizeof(info->shadow)); 1211 1212 /* Stage 2: Set up free list. */ 1213 memset(&info->shadow, 0, sizeof(info->shadow)); 1214 for (i = 0; i < BLK_RING_SIZE; i++) 1215 info->shadow[i].req.u.rw.id = i+1; 1216 info->shadow_free = info->ring.req_prod_pvt; 1217 info->shadow[BLK_RING_SIZE-1].req.u.rw.id = 0x0fffffff; 1218 1219 /* Stage 3: Find pending requests and requeue them. */ 1220 for (i = 0; i < BLK_RING_SIZE; i++) { 1221 /* Not in use? */ 1222 if (!copy[i].request) 1223 continue; 1224 1225 /* Grab a request slot and copy shadow state into it. */ 1226 req = RING_GET_REQUEST(&info->ring, info->ring.req_prod_pvt); 1227 *req = copy[i].req; 1228 1229 /* We get a new request id, and must reset the shadow state. */ 1230 req->u.rw.id = get_id_from_freelist(info); 1231 memcpy(&info->shadow[req->u.rw.id], ©[i], sizeof(copy[i])); 1232 1233 if (req->operation != BLKIF_OP_DISCARD) { 1234 /* Rewrite any grant references invalidated by susp/resume. */ 1235 for (j = 0; j < req->u.rw.nr_segments; j++) 1236 gnttab_grant_foreign_access_ref( 1237 req->u.rw.seg[j].gref, 1238 info->xbdev->otherend_id, 1239 pfn_to_mfn(info->shadow[req->u.rw.id].frame[j]), 1240 0); 1241 } 1242 info->shadow[req->u.rw.id].req = *req; 1243 1244 info->ring.req_prod_pvt++; 1245 } 1246 1247 kfree(copy); 1248 1249 xenbus_switch_state(info->xbdev, XenbusStateConnected); 1250 1251 spin_lock_irq(&info->io_lock); 1252 1253 /* Now safe for us to use the shared ring */ 1254 info->connected = BLKIF_STATE_CONNECTED; 1255 1256 /* Send off requeued requests */ 1257 flush_requests(info); 1258 1259 /* Kick any other new requests queued since we resumed */ 1260 kick_pending_request_queues(info); 1261 1262 spin_unlock_irq(&info->io_lock); 1263 1264 return 0; 1265 } 1266 1267 /** 1268 * We are reconnecting to the backend, due to a suspend/resume, or a backend 1269 * driver restart. We tear down our blkif structure and recreate it, but 1270 * leave the device-layer structures intact so that this is transparent to the 1271 * rest of the kernel. 1272 */ 1273 static int blkfront_resume(struct xenbus_device *dev) 1274 { 1275 struct blkfront_info *info = dev_get_drvdata(&dev->dev); 1276 int err; 1277 1278 dev_dbg(&dev->dev, "blkfront_resume: %s\n", dev->nodename); 1279 1280 blkif_free(info, info->connected == BLKIF_STATE_CONNECTED); 1281 1282 err = talk_to_blkback(dev, info); 1283 if (info->connected == BLKIF_STATE_SUSPENDED && !err) 1284 err = blkif_recover(info); 1285 1286 return err; 1287 } 1288 1289 static void 1290 blkfront_closing(struct blkfront_info *info) 1291 { 1292 struct xenbus_device *xbdev = info->xbdev; 1293 struct block_device *bdev = NULL; 1294 1295 mutex_lock(&info->mutex); 1296 1297 if (xbdev->state == XenbusStateClosing) { 1298 mutex_unlock(&info->mutex); 1299 return; 1300 } 1301 1302 if (info->gd) 1303 bdev = bdget_disk(info->gd, 0); 1304 1305 mutex_unlock(&info->mutex); 1306 1307 if (!bdev) { 1308 xenbus_frontend_closed(xbdev); 1309 return; 1310 } 1311 1312 mutex_lock(&bdev->bd_mutex); 1313 1314 if (bdev->bd_openers) { 1315 xenbus_dev_error(xbdev, -EBUSY, 1316 "Device in use; refusing to close"); 1317 xenbus_switch_state(xbdev, XenbusStateClosing); 1318 } else { 1319 xlvbd_release_gendisk(info); 1320 xenbus_frontend_closed(xbdev); 1321 } 1322 1323 mutex_unlock(&bdev->bd_mutex); 1324 bdput(bdev); 1325 } 1326 1327 static void blkfront_setup_discard(struct blkfront_info *info) 1328 { 1329 int err; 1330 char *type; 1331 unsigned int discard_granularity; 1332 unsigned int discard_alignment; 1333 unsigned int discard_secure; 1334 1335 type = xenbus_read(XBT_NIL, info->xbdev->otherend, "type", NULL); 1336 if (IS_ERR(type)) 1337 return; 1338 1339 info->feature_secdiscard = 0; 1340 if (strncmp(type, "phy", 3) == 0) { 1341 err = xenbus_gather(XBT_NIL, info->xbdev->otherend, 1342 "discard-granularity", "%u", &discard_granularity, 1343 "discard-alignment", "%u", &discard_alignment, 1344 NULL); 1345 if (!err) { 1346 info->feature_discard = 1; 1347 info->discard_granularity = discard_granularity; 1348 info->discard_alignment = discard_alignment; 1349 } 1350 err = xenbus_gather(XBT_NIL, info->xbdev->otherend, 1351 "discard-secure", "%d", &discard_secure, 1352 NULL); 1353 if (!err) 1354 info->feature_secdiscard = discard_secure; 1355 1356 } else if (strncmp(type, "file", 4) == 0) 1357 info->feature_discard = 1; 1358 1359 kfree(type); 1360 } 1361 1362 /* 1363 * Invoked when the backend is finally 'ready' (and has told produced 1364 * the details about the physical device - #sectors, size, etc). 1365 */ 1366 static void blkfront_connect(struct blkfront_info *info) 1367 { 1368 unsigned long long sectors; 1369 unsigned long sector_size; 1370 unsigned int binfo; 1371 int err; 1372 int barrier, flush, discard, persistent; 1373 1374 switch (info->connected) { 1375 case BLKIF_STATE_CONNECTED: 1376 /* 1377 * Potentially, the back-end may be signalling 1378 * a capacity change; update the capacity. 1379 */ 1380 err = xenbus_scanf(XBT_NIL, info->xbdev->otherend, 1381 "sectors", "%Lu", §ors); 1382 if (XENBUS_EXIST_ERR(err)) 1383 return; 1384 printk(KERN_INFO "Setting capacity to %Lu\n", 1385 sectors); 1386 set_capacity(info->gd, sectors); 1387 revalidate_disk(info->gd); 1388 1389 /* fall through */ 1390 case BLKIF_STATE_SUSPENDED: 1391 return; 1392 1393 default: 1394 break; 1395 } 1396 1397 dev_dbg(&info->xbdev->dev, "%s:%s.\n", 1398 __func__, info->xbdev->otherend); 1399 1400 err = xenbus_gather(XBT_NIL, info->xbdev->otherend, 1401 "sectors", "%llu", §ors, 1402 "info", "%u", &binfo, 1403 "sector-size", "%lu", §or_size, 1404 NULL); 1405 if (err) { 1406 xenbus_dev_fatal(info->xbdev, err, 1407 "reading backend fields at %s", 1408 info->xbdev->otherend); 1409 return; 1410 } 1411 1412 info->feature_flush = 0; 1413 info->flush_op = 0; 1414 1415 err = xenbus_gather(XBT_NIL, info->xbdev->otherend, 1416 "feature-barrier", "%d", &barrier, 1417 NULL); 1418 1419 /* 1420 * If there's no "feature-barrier" defined, then it means 1421 * we're dealing with a very old backend which writes 1422 * synchronously; nothing to do. 1423 * 1424 * If there are barriers, then we use flush. 1425 */ 1426 if (!err && barrier) { 1427 info->feature_flush = REQ_FLUSH | REQ_FUA; 1428 info->flush_op = BLKIF_OP_WRITE_BARRIER; 1429 } 1430 /* 1431 * And if there is "feature-flush-cache" use that above 1432 * barriers. 1433 */ 1434 err = xenbus_gather(XBT_NIL, info->xbdev->otherend, 1435 "feature-flush-cache", "%d", &flush, 1436 NULL); 1437 1438 if (!err && flush) { 1439 info->feature_flush = REQ_FLUSH; 1440 info->flush_op = BLKIF_OP_FLUSH_DISKCACHE; 1441 } 1442 1443 err = xenbus_gather(XBT_NIL, info->xbdev->otherend, 1444 "feature-discard", "%d", &discard, 1445 NULL); 1446 1447 if (!err && discard) 1448 blkfront_setup_discard(info); 1449 1450 err = xenbus_gather(XBT_NIL, info->xbdev->otherend, 1451 "feature-persistent", "%u", &persistent, 1452 NULL); 1453 if (err) 1454 info->feature_persistent = 0; 1455 else 1456 info->feature_persistent = persistent; 1457 1458 err = xlvbd_alloc_gendisk(sectors, info, binfo, sector_size); 1459 if (err) { 1460 xenbus_dev_fatal(info->xbdev, err, "xlvbd_add at %s", 1461 info->xbdev->otherend); 1462 return; 1463 } 1464 1465 xenbus_switch_state(info->xbdev, XenbusStateConnected); 1466 1467 /* Kick pending requests. */ 1468 spin_lock_irq(&info->io_lock); 1469 info->connected = BLKIF_STATE_CONNECTED; 1470 kick_pending_request_queues(info); 1471 spin_unlock_irq(&info->io_lock); 1472 1473 add_disk(info->gd); 1474 1475 info->is_ready = 1; 1476 } 1477 1478 /** 1479 * Callback received when the backend's state changes. 1480 */ 1481 static void blkback_changed(struct xenbus_device *dev, 1482 enum xenbus_state backend_state) 1483 { 1484 struct blkfront_info *info = dev_get_drvdata(&dev->dev); 1485 1486 dev_dbg(&dev->dev, "blkfront:blkback_changed to state %d.\n", backend_state); 1487 1488 switch (backend_state) { 1489 case XenbusStateInitialising: 1490 case XenbusStateInitWait: 1491 case XenbusStateInitialised: 1492 case XenbusStateReconfiguring: 1493 case XenbusStateReconfigured: 1494 case XenbusStateUnknown: 1495 case XenbusStateClosed: 1496 break; 1497 1498 case XenbusStateConnected: 1499 blkfront_connect(info); 1500 break; 1501 1502 case XenbusStateClosing: 1503 blkfront_closing(info); 1504 break; 1505 } 1506 } 1507 1508 static int blkfront_remove(struct xenbus_device *xbdev) 1509 { 1510 struct blkfront_info *info = dev_get_drvdata(&xbdev->dev); 1511 struct block_device *bdev = NULL; 1512 struct gendisk *disk; 1513 1514 dev_dbg(&xbdev->dev, "%s removed", xbdev->nodename); 1515 1516 blkif_free(info, 0); 1517 1518 mutex_lock(&info->mutex); 1519 1520 disk = info->gd; 1521 if (disk) 1522 bdev = bdget_disk(disk, 0); 1523 1524 info->xbdev = NULL; 1525 mutex_unlock(&info->mutex); 1526 1527 if (!bdev) { 1528 kfree(info); 1529 return 0; 1530 } 1531 1532 /* 1533 * The xbdev was removed before we reached the Closed 1534 * state. See if it's safe to remove the disk. If the bdev 1535 * isn't closed yet, we let release take care of it. 1536 */ 1537 1538 mutex_lock(&bdev->bd_mutex); 1539 info = disk->private_data; 1540 1541 dev_warn(disk_to_dev(disk), 1542 "%s was hot-unplugged, %d stale handles\n", 1543 xbdev->nodename, bdev->bd_openers); 1544 1545 if (info && !bdev->bd_openers) { 1546 xlvbd_release_gendisk(info); 1547 disk->private_data = NULL; 1548 kfree(info); 1549 } 1550 1551 mutex_unlock(&bdev->bd_mutex); 1552 bdput(bdev); 1553 1554 return 0; 1555 } 1556 1557 static int blkfront_is_ready(struct xenbus_device *dev) 1558 { 1559 struct blkfront_info *info = dev_get_drvdata(&dev->dev); 1560 1561 return info->is_ready && info->xbdev; 1562 } 1563 1564 static int blkif_open(struct block_device *bdev, fmode_t mode) 1565 { 1566 struct gendisk *disk = bdev->bd_disk; 1567 struct blkfront_info *info; 1568 int err = 0; 1569 1570 mutex_lock(&blkfront_mutex); 1571 1572 info = disk->private_data; 1573 if (!info) { 1574 /* xbdev gone */ 1575 err = -ERESTARTSYS; 1576 goto out; 1577 } 1578 1579 mutex_lock(&info->mutex); 1580 1581 if (!info->gd) 1582 /* xbdev is closed */ 1583 err = -ERESTARTSYS; 1584 1585 mutex_unlock(&info->mutex); 1586 1587 out: 1588 mutex_unlock(&blkfront_mutex); 1589 return err; 1590 } 1591 1592 static int blkif_release(struct gendisk *disk, fmode_t mode) 1593 { 1594 struct blkfront_info *info = disk->private_data; 1595 struct block_device *bdev; 1596 struct xenbus_device *xbdev; 1597 1598 mutex_lock(&blkfront_mutex); 1599 1600 bdev = bdget_disk(disk, 0); 1601 1602 if (bdev->bd_openers) 1603 goto out; 1604 1605 /* 1606 * Check if we have been instructed to close. We will have 1607 * deferred this request, because the bdev was still open. 1608 */ 1609 1610 mutex_lock(&info->mutex); 1611 xbdev = info->xbdev; 1612 1613 if (xbdev && xbdev->state == XenbusStateClosing) { 1614 /* pending switch to state closed */ 1615 dev_info(disk_to_dev(bdev->bd_disk), "releasing disk\n"); 1616 xlvbd_release_gendisk(info); 1617 xenbus_frontend_closed(info->xbdev); 1618 } 1619 1620 mutex_unlock(&info->mutex); 1621 1622 if (!xbdev) { 1623 /* sudden device removal */ 1624 dev_info(disk_to_dev(bdev->bd_disk), "releasing disk\n"); 1625 xlvbd_release_gendisk(info); 1626 disk->private_data = NULL; 1627 kfree(info); 1628 } 1629 1630 out: 1631 bdput(bdev); 1632 mutex_unlock(&blkfront_mutex); 1633 return 0; 1634 } 1635 1636 static const struct block_device_operations xlvbd_block_fops = 1637 { 1638 .owner = THIS_MODULE, 1639 .open = blkif_open, 1640 .release = blkif_release, 1641 .getgeo = blkif_getgeo, 1642 .ioctl = blkif_ioctl, 1643 }; 1644 1645 1646 static const struct xenbus_device_id blkfront_ids[] = { 1647 { "vbd" }, 1648 { "" } 1649 }; 1650 1651 static DEFINE_XENBUS_DRIVER(blkfront, , 1652 .probe = blkfront_probe, 1653 .remove = blkfront_remove, 1654 .resume = blkfront_resume, 1655 .otherend_changed = blkback_changed, 1656 .is_ready = blkfront_is_ready, 1657 ); 1658 1659 static int __init xlblk_init(void) 1660 { 1661 int ret; 1662 1663 if (!xen_domain()) 1664 return -ENODEV; 1665 1666 if (xen_hvm_domain() && !xen_platform_pci_unplug) 1667 return -ENODEV; 1668 1669 if (register_blkdev(XENVBD_MAJOR, DEV_NAME)) { 1670 printk(KERN_WARNING "xen_blk: can't get major %d with name %s\n", 1671 XENVBD_MAJOR, DEV_NAME); 1672 return -ENODEV; 1673 } 1674 1675 ret = xenbus_register_frontend(&blkfront_driver); 1676 if (ret) { 1677 unregister_blkdev(XENVBD_MAJOR, DEV_NAME); 1678 return ret; 1679 } 1680 1681 return 0; 1682 } 1683 module_init(xlblk_init); 1684 1685 1686 static void __exit xlblk_exit(void) 1687 { 1688 xenbus_unregister_driver(&blkfront_driver); 1689 unregister_blkdev(XENVBD_MAJOR, DEV_NAME); 1690 kfree(minors); 1691 } 1692 module_exit(xlblk_exit); 1693 1694 MODULE_DESCRIPTION("Xen virtual block device frontend"); 1695 MODULE_LICENSE("GPL"); 1696 MODULE_ALIAS_BLOCKDEV_MAJOR(XENVBD_MAJOR); 1697 MODULE_ALIAS("xen:vbd"); 1698 MODULE_ALIAS("xenblk"); 1699