stand/common/vdisk.c

   1 /*-
   2  * Copyright 2019 Toomas Soome <tsoome@me.com>
   3  *
   4  * Redistribution and use in source and binary forms, with or without
   5  * modification, are permitted provided that the following conditions
   6  * are met:
   7  * 1. Redistributions of source code must retain the above copyright
   8  *    notice, this list of conditions and the following disclaimer.
   9  * 2. Redistributions in binary form must reproduce the above copyright
  10  *    notice, this list of conditions and the following disclaimer in the
  11  *    documentation and/or other materials provided with the distribution.
  12  *
  13  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  14  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  15  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  16  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  17  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  18  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  19  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  20  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  21  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  22  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  23  * SUCH DAMAGE.
  24  */
  25
  26 #include <sys/cdefs.h>
  27 __FBSDID("$FreeBSD$");
  28
  29 #include <stand.h>
  30 #include <stdarg.h>
  31 #include <machine/_inttypes.h>
  32 #include <bootstrap.h>
  33 #include <sys/disk.h>
  34 #include <sys/errno.h>
  35 #include <sys/queue.h>
  36 #include <sys/param.h>
  37 #include <disk.h>
  38
  39 static int vdisk_init(void);
  40 static int vdisk_strategy(void *, int, daddr_t, size_t, char *, size_t *);
  41 static int vdisk_open(struct open_file *, ...);
  42 static int vdisk_close(struct open_file *);
  43 static int vdisk_ioctl(struct open_file *, u_long, void *);
  44 static int vdisk_print(int);
  45
  46 struct devsw vdisk_dev = {
  47         .dv_name = "vdisk",
  48         .dv_type = DEVT_DISK,
  49         .dv_init = vdisk_init,
  50         .dv_strategy = vdisk_strategy,
  51         .dv_open = vdisk_open,
  52         .dv_close = vdisk_close,
  53         .dv_ioctl = vdisk_ioctl,
  54         .dv_print = vdisk_print,
  55         .dv_cleanup = NULL
  56 };
  57
  58 typedef STAILQ_HEAD(vdisk_info_list, vdisk_info) vdisk_info_list_t;
  59
  60 typedef struct vdisk_info
  61 {
  62         STAILQ_ENTRY(vdisk_info)        vdisk_link; /* link in device list */
  63         char                    *vdisk_path;
  64         int                     vdisk_unit;
  65         int                     vdisk_fd;
  66         uint64_t                vdisk_size;     /* size in bytes */
  67         uint32_t                vdisk_sectorsz;
  68         uint32_t                vdisk_open;     /* reference counter */
  69 } vdisk_info_t;
  70
  71 static vdisk_info_list_t vdisk_list;    /* list of mapped vdisks. */
  72
  73 static vdisk_info_t *
  74 vdisk_get_info(struct devdesc *dev)
  75 {
  76         vdisk_info_t *vd;
  77
  78         STAILQ_FOREACH(vd, &vdisk_list, vdisk_link) {
  79                 if (vd->vdisk_unit == dev->d_unit)
  80                         return (vd);
  81         }
  82         return (vd);
  83 }
  84
  85 COMMAND_SET(map_vdisk, "map-vdisk", "map file as virtual disk", command_mapvd);
  86
  87 static int
  88 command_mapvd(int argc, char *argv[])
  89 {
  90         vdisk_info_t *vd, *p;
  91         struct stat sb;
  92
  93         if (argc != 2) {
  94                 printf("usage: %s filename\n", argv[0]);
  95                 return (CMD_ERROR);
  96         }
  97
  98         STAILQ_FOREACH(vd, &vdisk_list, vdisk_link) {
  99                 if (strcmp(vd->vdisk_path, argv[1]) == 0) {
 100                         printf("%s: file %s is already mapped as %s%d\n",
 101                             argv[0], argv[1], vdisk_dev.dv_name,
 102                             vd->vdisk_unit);
 103                         return (CMD_ERROR);
 104                 }
 105         }
 106
 107         if (stat(argv[1], &sb) < 0) {
 108                 /*
 109                  * ENOSYS is really ENOENT because we did try to walk
 110                  * through devsw list to try to open this file.
 111                  */
 112                 if (errno == ENOSYS)
 113                         errno = ENOENT;
 114
 115                 printf("%s: stat failed: %s\n", argv[0], strerror(errno));
 116                 return (CMD_ERROR);
 117         }
 118
 119         /*
 120          * Avoid mapping small files.
 121          */
 122         if (sb.st_size < 1024 * 1024) {
 123                 printf("%s: file %s is too small.\n", argv[0], argv[1]);
 124                 return (CMD_ERROR);
 125         }
 126
 127         vd = calloc(1, sizeof (*vd));
 128         if (vd == NULL) {
 129                 printf("%s: out of memory\n", argv[0]);
 130                 return (CMD_ERROR);
 131         }
 132         vd->vdisk_path = strdup(argv[1]);
 133         if (vd->vdisk_path == NULL) {
 134                 free (vd);
 135                 printf("%s: out of memory\n", argv[0]);
 136                 return (CMD_ERROR);
 137         }
 138         vd->vdisk_fd = open(vd->vdisk_path, O_RDONLY);
 139         if (vd->vdisk_fd < 0) {
 140                 printf("%s: open failed: %s\n", argv[0], strerror(errno));
 141                 free(vd->vdisk_path);
 142                 free(vd);
 143                 return (CMD_ERROR);
 144         }
 145
 146         vd->vdisk_size = sb.st_size;
 147         vd->vdisk_sectorsz = DEV_BSIZE;
 148         STAILQ_FOREACH(p, &vdisk_list, vdisk_link) {
 149                 vdisk_info_t *n;
 150                 if (p->vdisk_unit == vd->vdisk_unit) {
 151                         vd->vdisk_unit++;
 152                         continue;
 153                 }
 154                 n = STAILQ_NEXT(p, vdisk_link);
 155                 if (p->vdisk_unit < vd->vdisk_unit) {
 156                         if (n == NULL) {
 157                                 /* p is last elem */
 158                                 STAILQ_INSERT_TAIL(&vdisk_list, vd, vdisk_link);
 159                                 break;
 160                         }
 161                         if (n->vdisk_unit > vd->vdisk_unit) {
 162                                 /* p < vd < n */
 163                                 STAILQ_INSERT_AFTER(&vdisk_list, p, vd,
 164                                     vdisk_link);
 165                                 break;
 166                         }
 167                         /* else n < vd or n == vd */
 168                         vd->vdisk_unit++;
 169                         continue;
 170                 }
 171                 /* p > vd only if p is the first element */
 172                 STAILQ_INSERT_HEAD(&vdisk_list, vd, vdisk_link);
 173                 break;
 174         }
 175
 176         /* if the list was empty or contiguous */
 177         if (p == NULL)
 178                 STAILQ_INSERT_TAIL(&vdisk_list, vd, vdisk_link);
 179
 180         printf("%s: file %s is mapped as %s%d\n", argv[0], vd->vdisk_path,
 181             vdisk_dev.dv_name, vd->vdisk_unit);
 182         return (CMD_OK);
 183 }
 184
 185 COMMAND_SET(unmap_vdisk, "unmap-vdisk", "unmap virtual disk", command_unmapvd);
 186
 187 /*
 188  * unmap-vdisk vdiskX
 189  */
 190 static int
 191 command_unmapvd(int argc, char *argv[])
 192 {
 193         size_t len;
 194         vdisk_info_t *vd;
 195         long unit;
 196         char *end;
 197
 198         if (argc != 2) {
 199                 printf("usage: %s %sN\n", argv[0], vdisk_dev.dv_name);
 200                 return (CMD_ERROR);
 201         }
 202
 203         len = strlen(vdisk_dev.dv_name);
 204         if (strncmp(vdisk_dev.dv_name, argv[1], len) != 0) {
 205                 printf("%s: unknown device %s\n", argv[0], argv[1]);
 206                 return (CMD_ERROR);
 207         }
 208         errno = 0;
 209         unit = strtol(argv[1] + len, &end, 10);
 210         if (errno != 0 || (*end != '\0' && strcmp(end, ":") != 0)) {
 211                 printf("%s: unknown device %s\n", argv[0], argv[1]);
 212                 return (CMD_ERROR);
 213         }
 214
 215         STAILQ_FOREACH(vd, &vdisk_list, vdisk_link) {
 216                 if (vd->vdisk_unit == unit)
 217                         break;
 218         }
 219
 220         if (vd == NULL) {
 221                 printf("%s: unknown device %s\n", argv[0], argv[1]);
 222                 return (CMD_ERROR);
 223         }
 224
 225         if (vd->vdisk_open != 0) {
 226                 printf("%s: %s is in use, unable to unmap.\n",
 227                     argv[0], argv[1]);
 228                 return (CMD_ERROR);
 229         }
 230
 231         STAILQ_REMOVE(&vdisk_list, vd, vdisk_info, vdisk_link);
 232         (void) close(vd->vdisk_fd);
 233         printf("%s (%s) unmapped\n", argv[1], vd->vdisk_path);
 234         free(vd->vdisk_path);
 235         free(vd);
 236
 237         return (CMD_OK);
 238 }
 239
 240 static int
 241 vdisk_init(void)
 242 {
 243         STAILQ_INIT(&vdisk_list);
 244         return (0);
 245 }
 246
 247 static int
 248 vdisk_strategy(void *devdata, int rw, daddr_t blk, size_t size,
 249     char *buf, size_t *rsize)
 250 {
 251         struct disk_devdesc *dev;
 252         vdisk_info_t *vd;
 253         ssize_t rv;
 254
 255         dev = devdata;
 256         if (dev == NULL)
 257                 return (EINVAL);
 258         vd = vdisk_get_info((struct devdesc *)dev);
 259         if (vd == NULL)
 260                 return (EINVAL);
 261
 262         if (size == 0 || (size % 512) != 0)
 263                 return (EIO);
 264
 265         if (dev->dd.d_dev->dv_type == DEVT_DISK) {
 266                 daddr_t offset;
 267
 268                 offset = dev->d_offset * vd->vdisk_sectorsz;
 269                 offset /= 512;
 270                 blk += offset;
 271         }
 272         if (lseek(vd->vdisk_fd, blk << 9, SEEK_SET) == -1)
 273                 return (EIO);
 274
 275         errno = 0;
 276         switch (rw & F_MASK) {
 277         case F_READ:
 278                 rv = read(vd->vdisk_fd, buf, size);
 279                 break;
 280         case F_WRITE:
 281                 rv = write(vd->vdisk_fd, buf, size);
 282                 break;
 283         default:
 284                 return (ENOSYS);
 285         }
 286
 287         if (errno == 0 && rsize != NULL) {
 288                 *rsize = rv;
 289         }
 290         return (errno);
 291 }
 292
 293 static int
 294 vdisk_open(struct open_file *f, ...)
 295 {
 296         va_list args;
 297         struct disk_devdesc *dev;
 298         vdisk_info_t *vd;
 299         int rc = 0;
 300
 301         va_start(args, f);
 302         dev = va_arg(args, struct disk_devdesc *);
 303         va_end(args);
 304         if (dev == NULL)
 305                 return (EINVAL);
 306         vd = vdisk_get_info((struct devdesc *)dev);
 307         if (vd == NULL)
 308                 return (EINVAL);
 309
 310         if (dev->dd.d_dev->dv_type == DEVT_DISK) {
 311                 rc = disk_open(dev, vd->vdisk_size, vd->vdisk_sectorsz);
 312         }
 313         if (rc == 0)
 314                 vd->vdisk_open++;
 315         return (rc);
 316 }
 317
 318 static int
 319 vdisk_close(struct open_file *f)
 320 {
 321         struct disk_devdesc *dev;
 322         vdisk_info_t *vd;
 323
 324         dev = (struct disk_devdesc *)(f->f_devdata);
 325         if (dev == NULL)
 326                 return (EINVAL);
 327         vd = vdisk_get_info((struct devdesc *)dev);
 328         if (vd == NULL)
 329                 return (EINVAL);
 330
 331         vd->vdisk_open--;
 332         if (dev->dd.d_dev->dv_type == DEVT_DISK)
 333                 return (disk_close(dev));
 334         return (0);
 335 }
 336
 337 static int
 338 vdisk_ioctl(struct open_file *f, u_long cmd, void *data)
 339 {
 340         struct disk_devdesc *dev;
 341         vdisk_info_t *vd;
 342         int rc;
 343
 344         dev = (struct disk_devdesc *)(f->f_devdata);
 345         if (dev == NULL)
 346                 return (EINVAL);
 347         vd = vdisk_get_info((struct devdesc *)dev);
 348         if (vd == NULL)
 349                 return (EINVAL);
 350
 351         if (dev->dd.d_dev->dv_type == DEVT_DISK) {
 352                 rc = disk_ioctl(dev, cmd, data);
 353                 if (rc != ENOTTY)
 354                         return (rc);
 355         }
 356
 357         switch (cmd) {
 358         case DIOCGSECTORSIZE:
 359                 *(u_int *)data = vd->vdisk_sectorsz;
 360                 break;
 361         case DIOCGMEDIASIZE:
 362                 *(uint64_t *)data = vd->vdisk_size;
 363                 break;
 364         default:
 365                 return (ENOTTY);
 366         }
 367         return (0);
 368 }
 369
 370 static int
 371 vdisk_print(int verbose)
 372 {
 373         int ret = 0;
 374         vdisk_info_t *vd;
 375         char line[80];
 376
 377         if (STAILQ_EMPTY(&vdisk_list))
 378                 return (ret);
 379
 380         printf("%s devices:", vdisk_dev.dv_name);
 381         if ((ret = pager_output("\n")) != 0)
 382                 return (ret);
 383
 384         STAILQ_FOREACH(vd, &vdisk_list, vdisk_link) {
 385                 struct disk_devdesc vd_dev;
 386
 387                 if (verbose) {
 388                         printf("  %s", vd->vdisk_path);
 389                         if ((ret = pager_output("\n")) != 0)
 390                                 break;
 391                 }
 392                 snprintf(line, sizeof(line),
 393                     "    %s%d", vdisk_dev.dv_name, vd->vdisk_unit);
 394                 printf("%s:    %" PRIu64 " X %u blocks", line,
 395                     vd->vdisk_size / vd->vdisk_sectorsz,
 396                     vd->vdisk_sectorsz);
 397                 if ((ret = pager_output("\n")) != 0)
 398                         break;
 399
 400                 vd_dev.dd.d_dev = &vdisk_dev;
 401                 vd_dev.dd.d_unit = vd->vdisk_unit;
 402                 vd_dev.d_slice = -1;
 403                 vd_dev.d_partition = -1;
 404
 405                 ret = disk_open(&vd_dev, vd->vdisk_size, vd->vdisk_sectorsz);
 406                 if (ret == 0) {
 407                         ret = disk_print(&vd_dev, line, verbose);
 408                         disk_close(&vd_dev);
 409                         if (ret != 0)
 410                                 break;
 411                 } else {
 412                         ret = 0;
 413                 }
 414         }
 415
 416         return (ret);
 417 }