usr.sbin/bhyve/pci_virtio_block.c

   1 /*-
   2  * Copyright (c) 2011 NetApp, Inc.
   3  * All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  * 1. Redistributions of source code must retain the above copyright
   9  *    notice, this list of conditions and the following disclaimer.
  10  * 2. Redistributions in binary form must reproduce the above copyright
  11  *    notice, this list of conditions and the following disclaimer in the
  12  *    documentation and/or other materials provided with the distribution.
  13  *
  14  * THIS SOFTWARE IS PROVIDED BY NETAPP, INC ``AS IS'' AND
  15  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  16  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  17  * ARE DISCLAIMED.  IN NO EVENT SHALL NETAPP, INC OR CONTRIBUTORS BE LIABLE
  18  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  19  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  20  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  21  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  22  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  23  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  24  * SUCH DAMAGE.
  25  *
  26  * $FreeBSD$
  27  */
  28
  29 #include <sys/cdefs.h>
  30 __FBSDID("$FreeBSD$");
  31
  32 #include <sys/param.h>
  33 #include <sys/linker_set.h>
  34 #include <sys/stat.h>
  35 #include <sys/uio.h>
  36 #include <sys/ioctl.h>
  37 #include <sys/disk.h>
  38
  39 #include <errno.h>
  40 #include <fcntl.h>
  41 #include <stdio.h>
  42 #include <stdlib.h>
  43 #include <stdint.h>
  44 #include <string.h>
  45 #include <strings.h>
  46 #include <unistd.h>
  47 #include <assert.h>
  48 #include <pthread.h>
  49 #include <md5.h>
  50
  51 #include "bhyverun.h"
  52 #include "pci_emul.h"
  53 #include "virtio.h"
  54
  55 #ifndef min
  56 #define min(a, b)       ((a) < (b) ? (a) : (b))
  57 #endif
  58
  59 #define VTBLK_RINGSZ    64
  60
  61 #define VTBLK_MAXSEGS   32
  62
  63 #define VTBLK_S_OK      0
  64 #define VTBLK_S_IOERR   1
  65 #define VTBLK_S_UNSUPP  2
  66
  67 #define VTBLK_BLK_ID_BYTES      20
  68
  69 /*
  70  * Host capabilities
  71  */
  72 #define VTBLK_S_HOSTCAPS      \
  73   ( 0x00000004 |        /* host maximum request segments */ \
  74     VIRTIO_RING_F_INDIRECT_DESC )       /* indirect descriptors */
  75
  76 /*
  77  * Config space "registers"
  78  */
  79 struct vtblk_config {
  80         uint64_t        vbc_capacity;
  81         uint32_t        vbc_size_max;
  82         uint32_t        vbc_seg_max;
  83         uint16_t        vbc_geom_c;
  84         uint8_t         vbc_geom_h;
  85         uint8_t         vbc_geom_s;
  86         uint32_t        vbc_blk_size;
  87         uint32_t        vbc_sectors_max;
  88 } __packed;
  89
  90 /*
  91  * Fixed-size block header
  92  */
  93 struct virtio_blk_hdr {
  94 #define VBH_OP_READ             0
  95 #define VBH_OP_WRITE            1
  96 #define VBH_OP_IDENT            8
  97 #define VBH_FLAG_BARRIER        0x80000000      /* OR'ed into vbh_type */
  98         uint32_t        vbh_type;
  99         uint32_t        vbh_ioprio;
 100         uint64_t        vbh_sector;
 101 } __packed;
 102
 103 /*
 104  * Debug printf
 105  */
 106 static int pci_vtblk_debug;
 107 #define DPRINTF(params) if (pci_vtblk_debug) printf params
 108 #define WPRINTF(params) printf params
 109
 110 /*
 111  * Per-device softc
 112  */
 113 struct pci_vtblk_softc {
 114         struct virtio_softc vbsc_vs;
 115         struct vqueue_info vbsc_vq;
 116         int             vbsc_fd;
 117         struct vtblk_config vbsc_cfg;
 118         char vbsc_ident[VTBLK_BLK_ID_BYTES];
 119 };
 120
 121 static void pci_vtblk_reset(void *);
 122 static void pci_vtblk_notify(void *, struct vqueue_info *);
 123 static int pci_vtblk_cfgread(void *, int, int, uint32_t *);
 124 static int pci_vtblk_cfgwrite(void *, int, int, uint32_t);
 125
 126 static struct virtio_consts vtblk_vi_consts = {
 127         "vtblk",                /* our name */
 128         1,                      /* we support 1 virtqueue */
 129         sizeof(struct vtblk_config), /* config reg size */
 130         pci_vtblk_reset,        /* reset */
 131         pci_vtblk_notify,       /* device-wide qnotify */
 132         pci_vtblk_cfgread,      /* read PCI config */
 133         pci_vtblk_cfgwrite,     /* write PCI config */
 134         VTBLK_S_HOSTCAPS,       /* our capabilities */
 135 };
 136
 137 static void
 138 pci_vtblk_reset(void *vsc)
 139 {
 140         struct pci_vtblk_softc *sc = vsc;
 141
 142         DPRINTF(("vtblk: device reset requested !\n"));
 143         vi_reset_dev(&sc->vbsc_vs);
 144 }
 145
 146 static void
 147 pci_vtblk_proc(struct pci_vtblk_softc *sc, struct vqueue_info *vq)
 148 {
 149         struct virtio_blk_hdr *vbh;
 150         uint8_t *status;
 151         int i, n;
 152         int err;
 153         int iolen;
 154         int writeop, type;
 155         off_t offset;
 156         struct iovec iov[VTBLK_MAXSEGS + 2];
 157         uint16_t flags[VTBLK_MAXSEGS + 2];
 158
 159         n = vq_getchain(vq, iov, VTBLK_MAXSEGS + 2, flags);
 160
 161         /*
 162          * The first descriptor will be the read-only fixed header,
 163          * and the last is for status (hence +2 above and below).
 164          * The remaining iov's are the actual data I/O vectors.
 165          *
 166          * XXX - note - this fails on crash dump, which does a
 167          * VIRTIO_BLK_T_FLUSH with a zero transfer length
 168          */
 169         assert(n >= 2 && n <= VTBLK_MAXSEGS + 2);
 170
 171         assert((flags[0] & VRING_DESC_F_WRITE) == 0);
 172         assert(iov[0].iov_len == sizeof(struct virtio_blk_hdr));
 173         vbh = iov[0].iov_base;
 174
 175         status = iov[--n].iov_base;
 176         assert(iov[n].iov_len == 1);
 177         assert(flags[n] & VRING_DESC_F_WRITE);
 178
 179         /*
 180          * XXX
 181          * The guest should not be setting the BARRIER flag because
 182          * we don't advertise the capability.
 183          */
 184         type = vbh->vbh_type & ~VBH_FLAG_BARRIER;
 185         writeop = (type == VBH_OP_WRITE);
 186
 187         offset = vbh->vbh_sector * DEV_BSIZE;
 188
 189         iolen = 0;
 190         for (i = 1; i < n; i++) {
 191                 /*
 192                  * - write op implies read-only descriptor,
 193                  * - read/ident op implies write-only descriptor,
 194                  * therefore test the inverse of the descriptor bit
 195                  * to the op.
 196                  */
 197                 assert(((flags[i] & VRING_DESC_F_WRITE) == 0) == writeop);
 198                 iolen += iov[i].iov_len;
 199         }
 200
 201         DPRINTF(("virtio-block: %s op, %d bytes, %d segs, offset %ld\n\r",
 202                  writeop ? "write" : "read/ident", iolen, i - 1, offset));
 203
 204         switch (type) {
 205         case VBH_OP_WRITE:
 206                 err = pwritev(sc->vbsc_fd, iov + 1, i - 1, offset);
 207                 break;
 208         case VBH_OP_READ:
 209                 err = preadv(sc->vbsc_fd, iov + 1, i - 1, offset);
 210                 break;
 211         case VBH_OP_IDENT:
 212                 /* Assume a single buffer */
 213                 strlcpy(iov[1].iov_base, sc->vbsc_ident,
 214                     min(iov[1].iov_len, sizeof(sc->vbsc_ident)));
 215                 err = 0;
 216                 break;
 217         default:
 218                 err = -ENOSYS;
 219                 break;
 220         }
 221
 222         /* convert errno into a virtio block error return */
 223         if (err < 0) {
 224                 if (err == -ENOSYS)
 225                         *status = VTBLK_S_UNSUPP;
 226                 else
 227                         *status = VTBLK_S_IOERR;
 228         } else
 229                 *status = VTBLK_S_OK;
 230
 231         /*
 232          * Return the descriptor back to the host.
 233          * We wrote 1 byte (our status) to host.
 234          */
 235         vq_relchain(vq, 1);
 236 }
 237
 238 static void
 239 pci_vtblk_notify(void *vsc, struct vqueue_info *vq)
 240 {
 241         struct pci_vtblk_softc *sc = vsc;
 242
 243         vq_startchains(vq);
 244         while (vq_has_descs(vq))
 245                 pci_vtblk_proc(sc, vq);
 246         vq_endchains(vq, 1);    /* Generate interrupt if appropriate. */
 247 }
 248
 249 static int
 250 pci_vtblk_init(struct vmctx *ctx, struct pci_devinst *pi, char *opts)
 251 {
 252         struct stat sbuf;
 253         MD5_CTX mdctx;
 254         u_char digest[16];
 255         struct pci_vtblk_softc *sc;
 256         off_t size;
 257         int fd;
 258         int sectsz;
 259
 260         if (opts == NULL) {
 261                 printf("virtio-block: backing device required\n");
 262                 return (1);
 263         }
 264
 265         /*
 266          * The supplied backing file has to exist
 267          */
 268         fd = open(opts, O_RDWR);
 269         if (fd < 0) {
 270                 perror("Could not open backing file");
 271                 return (1);
 272         }
 273
 274         if (fstat(fd, &sbuf) < 0) {
 275                 perror("Could not stat backing file");
 276                 close(fd);
 277                 return (1);
 278         }
 279
 280         /*
 281          * Deal with raw devices
 282          */
 283         size = sbuf.st_size;
 284         sectsz = DEV_BSIZE;
 285         if (S_ISCHR(sbuf.st_mode)) {
 286                 if (ioctl(fd, DIOCGMEDIASIZE, &size) < 0 ||
 287                     ioctl(fd, DIOCGSECTORSIZE, &sectsz)) {
 288                         perror("Could not fetch dev blk/sector size");
 289                         close(fd);
 290                         return (1);
 291                 }
 292                 assert(size != 0);
 293                 assert(sectsz != 0);
 294         }
 295
 296         sc = malloc(sizeof(struct pci_vtblk_softc));
 297         memset(sc, 0, sizeof(struct pci_vtblk_softc));
 298
 299         /* record fd of storage device/file */
 300         sc->vbsc_fd = fd;
 301
 302         /* init virtio softc and virtqueues */
 303         vi_softc_linkup(&sc->vbsc_vs, &vtblk_vi_consts, sc, pi, &sc->vbsc_vq);
 304         sc->vbsc_vq.vq_qsize = VTBLK_RINGSZ;
 305         /* sc->vbsc_vq.vq_notify = we have no per-queue notify */
 306
 307         /*
 308          * Create an identifier for the backing file. Use parts of the
 309          * md5 sum of the filename
 310          */
 311         MD5Init(&mdctx);
 312         MD5Update(&mdctx, opts, strlen(opts));
 313         MD5Final(digest, &mdctx);
 314         sprintf(sc->vbsc_ident, "BHYVE-%02X%02X-%02X%02X-%02X%02X",
 315             digest[0], digest[1], digest[2], digest[3], digest[4], digest[5]);
 316
 317         /* setup virtio block config space */
 318         sc->vbsc_cfg.vbc_capacity = size / sectsz;
 319         sc->vbsc_cfg.vbc_seg_max = VTBLK_MAXSEGS;
 320         sc->vbsc_cfg.vbc_blk_size = sectsz;
 321         sc->vbsc_cfg.vbc_size_max = 0;  /* not negotiated */
 322         sc->vbsc_cfg.vbc_geom_c = 0;    /* no geometry */
 323         sc->vbsc_cfg.vbc_geom_h = 0;
 324         sc->vbsc_cfg.vbc_geom_s = 0;
 325         sc->vbsc_cfg.vbc_sectors_max = 0;
 326
 327         /*
 328          * Should we move some of this into virtio.c?  Could
 329          * have the device, class, and subdev_0 as fields in
 330          * the virtio constants structure.
 331          */
 332         pci_set_cfgdata16(pi, PCIR_DEVICE, VIRTIO_DEV_BLOCK);
 333         pci_set_cfgdata16(pi, PCIR_VENDOR, VIRTIO_VENDOR);
 334         pci_set_cfgdata8(pi, PCIR_CLASS, PCIC_STORAGE);
 335         pci_set_cfgdata16(pi, PCIR_SUBDEV_0, VIRTIO_TYPE_BLOCK);
 336
 337         if (vi_intr_init(&sc->vbsc_vs, 1, fbsdrun_virtio_msix()))
 338                 return (1);
 339         vi_set_io_bar(&sc->vbsc_vs, 0);
 340         return (0);
 341 }
 342
 343 static int
 344 pci_vtblk_cfgwrite(void *vsc, int offset, int size, uint32_t value)
 345 {
 346
 347         DPRINTF(("vtblk: write to readonly reg %d\n\r", offset));
 348         return (1);
 349 }
 350
 351 static int
 352 pci_vtblk_cfgread(void *vsc, int offset, int size, uint32_t *retval)
 353 {
 354         struct pci_vtblk_softc *sc = vsc;
 355         void *ptr;
 356
 357         /* our caller has already verified offset and size */
 358         ptr = (uint8_t *)&sc->vbsc_cfg + offset;
 359         memcpy(retval, ptr, size);
 360         return (0);
 361 }
 362
 363 struct pci_devemu pci_de_vblk = {
 364         .pe_emu =       "virtio-blk",
 365         .pe_init =      pci_vtblk_init,
 366         .pe_barwrite =  vi_pci_write,
 367         .pe_barread =   vi_pci_read
 368 };
 369 PCI_EMUL_SET(pci_de_vblk);