usr.sbin/bhyve/block_if.c

   1 /*-
   2  * Copyright (c) 2013  Peter Grehan <grehan@freebsd.org>
   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 THE AUTHOR ``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 THE AUTHOR 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/queue.h>
  34 #include <sys/errno.h>
  35 #include <sys/stat.h>
  36 #include <sys/ioctl.h>
  37 #include <sys/disk.h>
  38
  39 #include <assert.h>
  40 #include <fcntl.h>
  41 #include <stdio.h>
  42 #include <stdlib.h>
  43 #include <string.h>
  44 #include <pthread.h>
  45 #include <pthread_np.h>
  46 #include <unistd.h>
  47
  48 #include "bhyverun.h"
  49 #include "block_if.h"
  50
  51 #define BLOCKIF_SIG     0xb109b109
  52
  53 #define BLOCKIF_MAXREQ  32
  54
  55 enum blockop {
  56         BOP_READ,
  57         BOP_WRITE,
  58         BOP_FLUSH,
  59         BOP_CANCEL
  60 };
  61
  62 enum blockstat {
  63         BST_FREE,
  64         BST_INUSE
  65 };
  66
  67 struct blockif_elem {
  68         TAILQ_ENTRY(blockif_elem) be_link;
  69         struct blockif_req  *be_req;
  70         enum blockop         be_op;
  71         enum blockstat       be_status;
  72 };
  73
  74 struct blockif_ctxt {
  75         int                     bc_magic;
  76         int                     bc_fd;
  77         int                     bc_rdonly;
  78         off_t                   bc_size;
  79         int                     bc_sectsz;
  80         pthread_t               bc_btid;
  81         pthread_mutex_t         bc_mtx;
  82         pthread_cond_t          bc_cond;
  83         int                     bc_closing;
  84
  85         /* Request elements and free/inuse queues */
  86         TAILQ_HEAD(, blockif_elem) bc_freeq;
  87         TAILQ_HEAD(, blockif_elem) bc_inuseq;
  88         u_int                   bc_req_count;
  89         struct blockif_elem     bc_reqs[BLOCKIF_MAXREQ];
  90 };
  91
  92 static int
  93 blockif_enqueue(struct blockif_ctxt *bc, struct blockif_req *breq,
  94                 enum blockop op)
  95 {
  96         struct blockif_elem *be;
  97
  98         assert(bc->bc_req_count < BLOCKIF_MAXREQ);
  99
 100         be = TAILQ_FIRST(&bc->bc_freeq);
 101         assert(be != NULL);
 102         assert(be->be_status == BST_FREE);
 103
 104         TAILQ_REMOVE(&bc->bc_freeq, be, be_link);
 105         be->be_status = BST_INUSE;
 106         be->be_req = breq;
 107         be->be_op = op;
 108         TAILQ_INSERT_TAIL(&bc->bc_inuseq, be, be_link);
 109
 110         bc->bc_req_count++;
 111
 112         return (0);
 113 }
 114
 115 static int
 116 blockif_dequeue(struct blockif_ctxt *bc, struct blockif_elem *el)
 117 {
 118         struct blockif_elem *be;
 119
 120         if (bc->bc_req_count == 0)
 121                 return (ENOENT);
 122
 123         be = TAILQ_FIRST(&bc->bc_inuseq);
 124         assert(be != NULL);
 125         assert(be->be_status == BST_INUSE);
 126         *el = *be;
 127
 128         TAILQ_REMOVE(&bc->bc_inuseq, be, be_link);
 129         be->be_status = BST_FREE;
 130         be->be_req = NULL;
 131         TAILQ_INSERT_TAIL(&bc->bc_freeq, be, be_link);
 132
 133         bc->bc_req_count--;
 134
 135         return (0);
 136 }
 137
 138 static void
 139 blockif_proc(struct blockif_ctxt *bc, struct blockif_elem *be)
 140 {
 141         struct blockif_req *br;
 142         int err;
 143
 144         br = be->be_req;
 145         err = 0;
 146
 147         switch (be->be_op) {
 148         case BOP_READ:
 149                 if (preadv(bc->bc_fd, br->br_iov, br->br_iovcnt,
 150                            br->br_offset) < 0)
 151                         err = errno;
 152                 break;
 153         case BOP_WRITE:
 154                 if (bc->bc_rdonly)
 155                         err = EROFS;
 156                 else if (pwritev(bc->bc_fd, br->br_iov, br->br_iovcnt,
 157                              br->br_offset) < 0)
 158                         err = errno;
 159                 break;
 160         case BOP_FLUSH:
 161                 break;
 162         case BOP_CANCEL:
 163                 err = EINTR;
 164                 break;
 165         default:
 166                 err = EINVAL;
 167                 break;
 168         }
 169
 170         (*br->br_callback)(br, err);
 171 }
 172
 173 static void *
 174 blockif_thr(void *arg)
 175 {
 176         struct blockif_ctxt *bc;
 177         struct blockif_elem req;
 178
 179         bc = arg;
 180
 181         for (;;) {
 182                 pthread_mutex_lock(&bc->bc_mtx);
 183                 while (!blockif_dequeue(bc, &req)) {
 184                         pthread_mutex_unlock(&bc->bc_mtx);
 185                         blockif_proc(bc, &req);
 186                         pthread_mutex_lock(&bc->bc_mtx);
 187                 }
 188                 pthread_cond_wait(&bc->bc_cond, &bc->bc_mtx);
 189                 pthread_mutex_unlock(&bc->bc_mtx);
 190
 191                 /*
 192                  * Check ctxt status here to see if exit requested
 193                  */
 194                 if (bc->bc_closing)
 195                         pthread_exit(NULL);
 196         }
 197
 198         /* Not reached */
 199         return (NULL);
 200 }
 201
 202 struct blockif_ctxt *
 203 blockif_open(const char *optstr, const char *ident)
 204 {
 205         char tname[MAXCOMLEN + 1];
 206         char *nopt, *xopts;
 207         struct blockif_ctxt *bc;
 208         struct stat sbuf;
 209         off_t size;
 210         int extra, fd, i, sectsz;
 211         int nocache, sync, ro;
 212
 213         nocache = 0;
 214         sync = 0;
 215         ro = 0;
 216
 217         /*
 218          * The first element in the optstring is always a pathname.
 219          * Optional elements follow
 220          */
 221         nopt = strdup(optstr);
 222         for (xopts = strtok(nopt, ",");
 223              xopts != NULL;
 224              xopts = strtok(NULL, ",")) {
 225                 if (!strcmp(xopts, "nocache"))
 226                         nocache = 1;
 227                 else if (!strcmp(xopts, "sync"))
 228                         sync = 1;
 229                 else if (!strcmp(xopts, "ro"))
 230                         ro = 1;
 231         }
 232
 233         extra = 0;
 234         if (nocache)
 235                 extra |= O_DIRECT;
 236         if (sync)
 237                 extra |= O_SYNC;
 238
 239         fd = open(nopt, (ro ? O_RDONLY : O_RDWR) | extra);
 240         if (fd < 0 && !ro) {
 241                 /* Attempt a r/w fail with a r/o open */
 242                 fd = open(nopt, O_RDONLY | extra);
 243                 ro = 1;
 244         }
 245
 246         if (fd < 0) {
 247                 perror("Could not open backing file");
 248                 return (NULL);
 249         }
 250
 251         if (fstat(fd, &sbuf) < 0) {
 252                 perror("Could not stat backing file");
 253                 close(fd);
 254                 return (NULL);
 255         }
 256
 257         /*
 258          * Deal with raw devices
 259          */
 260         size = sbuf.st_size;
 261         sectsz = DEV_BSIZE;
 262         if (S_ISCHR(sbuf.st_mode)) {
 263                 if (ioctl(fd, DIOCGMEDIASIZE, &size) < 0 ||
 264                     ioctl(fd, DIOCGSECTORSIZE, &sectsz)) {
 265                         perror("Could not fetch dev blk/sector size");
 266                         close(fd);
 267                         return (NULL);
 268                 }
 269                 assert(size != 0);
 270                 assert(sectsz != 0);
 271         }
 272
 273         bc = calloc(1, sizeof(struct blockif_ctxt));
 274         if (bc == NULL) {
 275                 close(fd);
 276                 return (NULL);
 277         }
 278
 279         bc->bc_magic = BLOCKIF_SIG;
 280         bc->bc_fd = fd;
 281         bc->bc_rdonly = ro;
 282         bc->bc_size = size;
 283         bc->bc_sectsz = sectsz;
 284         pthread_mutex_init(&bc->bc_mtx, NULL);
 285         pthread_cond_init(&bc->bc_cond, NULL);
 286         TAILQ_INIT(&bc->bc_freeq);
 287         TAILQ_INIT(&bc->bc_inuseq);
 288         bc->bc_req_count = 0;
 289         for (i = 0; i < BLOCKIF_MAXREQ; i++) {
 290                 bc->bc_reqs[i].be_status = BST_FREE;
 291                 TAILQ_INSERT_HEAD(&bc->bc_freeq, &bc->bc_reqs[i], be_link);
 292         }
 293
 294         pthread_create(&bc->bc_btid, NULL, blockif_thr, bc);
 295
 296         snprintf(tname, sizeof(tname), "blk-%s", ident);
 297         pthread_set_name_np(bc->bc_btid, tname);
 298
 299         return (bc);
 300 }
 301
 302 static int
 303 blockif_request(struct blockif_ctxt *bc, struct blockif_req *breq,
 304                 enum blockop op)
 305 {
 306         int err;
 307
 308         err = 0;
 309
 310         pthread_mutex_lock(&bc->bc_mtx);
 311         if (bc->bc_req_count < BLOCKIF_MAXREQ) {
 312                 /*
 313                  * Enqueue and inform the block i/o thread
 314                  * that there is work available
 315                  */
 316                 blockif_enqueue(bc, breq, op);
 317                 pthread_cond_signal(&bc->bc_cond);
 318         } else {
 319                 /*
 320                  * Callers are not allowed to enqueue more than
 321                  * the specified blockif queue limit. Return an
 322                  * error to indicate that the queue length has been
 323                  * exceeded.
 324                  */
 325                 err = E2BIG;
 326         }
 327         pthread_mutex_unlock(&bc->bc_mtx);
 328
 329         return (err);
 330 }
 331
 332 int
 333 blockif_read(struct blockif_ctxt *bc, struct blockif_req *breq)
 334 {
 335
 336         assert(bc->bc_magic == BLOCKIF_SIG);
 337         return (blockif_request(bc, breq, BOP_READ));
 338 }
 339
 340 int
 341 blockif_write(struct blockif_ctxt *bc, struct blockif_req *breq)
 342 {
 343
 344         assert(bc->bc_magic == BLOCKIF_SIG);
 345         return (blockif_request(bc, breq, BOP_WRITE));
 346 }
 347
 348 int
 349 blockif_flush(struct blockif_ctxt *bc, struct blockif_req *breq)
 350 {
 351
 352         assert(bc->bc_magic == BLOCKIF_SIG);
 353         return (blockif_request(bc, breq, BOP_FLUSH));
 354 }
 355
 356 int
 357 blockif_cancel(struct blockif_ctxt *bc, struct blockif_req *breq)
 358 {
 359
 360         assert(bc->bc_magic == BLOCKIF_SIG);
 361         return (blockif_request(bc, breq, BOP_CANCEL));
 362 }
 363
 364 int
 365 blockif_close(struct blockif_ctxt *bc)
 366 {
 367         void *jval;
 368         int err;
 369
 370         err = 0;
 371
 372         assert(bc->bc_magic == BLOCKIF_SIG);
 373
 374         /*
 375          * Stop the block i/o thread
 376          */
 377         bc->bc_closing = 1;
 378         pthread_cond_signal(&bc->bc_cond);
 379         pthread_join(bc->bc_btid, &jval);
 380
 381         /* XXX Cancel queued i/o's ??? */
 382
 383         /*
 384          * Release resources
 385          */
 386         bc->bc_magic = 0;
 387         close(bc->bc_fd);
 388         free(bc);
 389
 390         return (0);
 391 }
 392
 393 /*
 394  * Return virtual C/H/S values for a given block. Use the algorithm
 395  * outlined in the VHD specification to calculate values.
 396  */
 397 void
 398 blockif_chs(struct blockif_ctxt *bc, uint16_t *c, uint8_t *h, uint8_t *s)
 399 {
 400         off_t sectors;          /* total sectors of the block dev */
 401         off_t hcyl;             /* cylinders times heads */
 402         uint16_t secpt;         /* sectors per track */
 403         uint8_t heads;
 404
 405         assert(bc->bc_magic == BLOCKIF_SIG);
 406
 407         sectors = bc->bc_size / bc->bc_sectsz;
 408
 409         /* Clamp the size to the largest possible with CHS */
 410         if (sectors > 65535UL*16*255)
 411                 sectors = 65535UL*16*255;
 412
 413         if (sectors >= 65536UL*16*63) {
 414                 secpt = 255;
 415                 heads = 16;
 416                 hcyl = sectors / secpt;
 417         } else {
 418                 secpt = 17;
 419                 hcyl = sectors / secpt;
 420                 heads = (hcyl + 1023) / 1024;
 421
 422                 if (heads < 4)
 423                         heads = 4;
 424
 425                 if (hcyl >= (heads * 1024) || heads > 16) {
 426                         secpt = 31;
 427                         heads = 16;
 428                         hcyl = sectors / secpt;
 429                 }
 430                 if (hcyl >= (heads * 1024)) {
 431                         secpt = 63;
 432                         heads = 16;
 433                         hcyl = sectors / secpt;
 434                 }
 435         }
 436
 437         *c = hcyl / heads;
 438         *h = heads;
 439         *s = secpt;
 440 }
 441
 442 /*
 443  * Accessors
 444  */
 445 off_t
 446 blockif_size(struct blockif_ctxt *bc)
 447 {
 448
 449         assert(bc->bc_magic == BLOCKIF_SIG);
 450         return (bc->bc_size);
 451 }
 452
 453 int
 454 blockif_sectsz(struct blockif_ctxt *bc)
 455 {
 456
 457         assert(bc->bc_magic == BLOCKIF_SIG);
 458         return (bc->bc_sectsz);
 459 }
 460
 461 int
 462 blockif_queuesz(struct blockif_ctxt *bc)
 463 {
 464
 465         assert(bc->bc_magic == BLOCKIF_SIG);
 466         return (BLOCKIF_MAXREQ);
 467 }
 468
 469 int
 470 blockif_is_ro(struct blockif_ctxt *bc)
 471 {
 472
 473         assert(bc->bc_magic == BLOCKIF_SIG);
 474         return (bc->bc_rdonly);
 475 }