drivers/xen/blkback/vbd.c

   1 /******************************************************************************
   2  * blkback/vbd.c
   3  *
   4  * Routines for managing virtual block devices (VBDs).
   5  *
   6  * Copyright (c) 2003-2005, Keir Fraser & Steve Hand
   7  *
   8  * This program is free software; you can redistribute it and/or
   9  * modify it under the terms of the GNU General Public License version 2
  10  * as published by the Free Software Foundation; or, when distributed
  11  * separately from the Linux kernel or incorporated into other
  12  * software packages, subject to the following license:
  13  *
  14  * Permission is hereby granted, free of charge, to any person obtaining a copy
  15  * of this source file (the "Software"), to deal in the Software without
  16  * restriction, including without limitation the rights to use, copy, modify,
  17  * merge, publish, distribute, sublicense, and/or sell copies of the Software,
  18  * and to permit persons to whom the Software is furnished to do so, subject to
  19  * the following conditions:
  20  *
  21  * The above copyright notice and this permission notice shall be included in
  22  * all copies or substantial portions of the Software.
  23  *
  24  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  25  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  26  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
  27  * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  28  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
  29  * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
  30  * IN THE SOFTWARE.
  31  */
  32
  33 #include "common.h"
  34
  35 #define vbd_sz(_v)   ((_v)->bdev->bd_part ?                             \
  36         (_v)->bdev->bd_part->nr_sects : get_capacity((_v)->bdev->bd_disk))
  37
  38 unsigned long long vbd_size(struct vbd *vbd)
  39 {
  40         return vbd_sz(vbd);
  41 }
  42
  43 unsigned int vbd_info(struct vbd *vbd)
  44 {
  45         return vbd->type | (vbd->readonly?VDISK_READONLY:0);
  46 }
  47
  48 unsigned long vbd_secsize(struct vbd *vbd)
  49 {
  50         return bdev_logical_block_size(vbd->bdev);
  51 }
  52
  53 int vbd_create(blkif_t *blkif, blkif_vdev_t handle, unsigned major,
  54                unsigned minor, int readonly, int cdrom)
  55 {
  56         struct vbd *vbd;
  57         struct block_device *bdev;
  58
  59         vbd = &blkif->vbd;
  60         vbd->handle   = handle;
  61         vbd->readonly = readonly;
  62         vbd->type     = 0;
  63
  64         vbd->pdevice  = MKDEV(major, minor);
  65
  66         bdev = open_by_devnum(vbd->pdevice,
  67                               vbd->readonly ? FMODE_READ : FMODE_WRITE);
  68
  69         if (IS_ERR(bdev)) {
  70                 DPRINTK("vbd_creat: device %08x could not be opened.\n",
  71                         vbd->pdevice);
  72                 return -ENOENT;
  73         }
  74
  75         vbd->bdev = bdev;
  76         vbd->size = vbd_size(vbd);
  77
  78         if (vbd->bdev->bd_disk == NULL) {
  79                 DPRINTK("vbd_creat: device %08x doesn't exist.\n",
  80                         vbd->pdevice);
  81                 vbd_free(vbd);
  82                 return -ENOENT;
  83         }
  84
  85         if (vbd->bdev->bd_disk->flags & GENHD_FL_CD || cdrom)
  86                 vbd->type |= VDISK_CDROM;
  87         if (vbd->bdev->bd_disk->flags & GENHD_FL_REMOVABLE)
  88                 vbd->type |= VDISK_REMOVABLE;
  89
  90         DPRINTK("Successful creation of handle=%04x (dom=%u)\n",
  91                 handle, blkif->domid);
  92         return 0;
  93 }
  94
  95 void vbd_free(struct vbd *vbd)
  96 {
  97         if (vbd->bdev)
  98                 blkdev_put(vbd->bdev,
  99                            vbd->readonly ? FMODE_READ : FMODE_WRITE);
 100         vbd->bdev = NULL;
 101 }
 102
 103 int vbd_translate(struct phys_req *req, blkif_t *blkif, int operation)
 104 {
 105         struct vbd *vbd = &blkif->vbd;
 106         int rc = -EACCES;
 107
 108         if ((operation != READ) && vbd->readonly)
 109                 goto out;
 110
 111         if (vbd->bdev == NULL)
 112                 goto out;
 113
 114         if (unlikely((req->sector_number + req->nr_sects) > vbd_sz(vbd)))
 115                 goto out;
 116
 117         req->dev  = vbd->pdevice;
 118         req->bdev = vbd->bdev;
 119         rc = 0;
 120
 121  out:
 122         return rc;
 123 }
 124
 125 void vbd_resize(blkif_t *blkif)
 126 {
 127         struct vbd *vbd = &blkif->vbd;
 128         struct xenbus_transaction xbt;
 129         int err;
 130         struct xenbus_device *dev = blkif->be->dev;
 131         unsigned long long new_size = vbd_size(vbd);
 132
 133         printk(KERN_INFO "VBD Resize: new size %Lu\n", new_size);
 134         vbd->size = new_size;
 135 again:
 136         err = xenbus_transaction_start(&xbt);
 137         if (err) {
 138                 printk(KERN_WARNING "Error starting transaction");
 139                 return;
 140         }
 141         err = xenbus_printf(xbt, dev->nodename, "sectors", "%Lu",
 142                             vbd_size(vbd));
 143         if (err) {
 144                 printk(KERN_WARNING "Error writing new size");
 145                 goto abort;
 146         }
 147         /*
 148          * Write the current state; we will use this to synchronize
 149          * the front-end. If the current state is "connected" the
 150          * front-end will get the new size information online.
 151          */
 152         err = xenbus_printf(xbt, dev->nodename, "state", "%d", dev->state);
 153         if (err) {
 154                 printk(KERN_WARNING "Error writing the state");
 155                 goto abort;
 156         }
 157
 158         err = xenbus_transaction_end(xbt, 0);
 159         if (err == -EAGAIN)
 160                 goto again;
 161         if (err)
 162                 printk(KERN_WARNING "Error ending transaction");
 163 abort:
 164         xenbus_transaction_end(xbt, 1);
 165 }