sys/boot/zfs/zfs.c

   1 /*-
   2  * Copyright (c) 2007 Doug Rabson
   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 AND CONTRIBUTORS ``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 /*
  33  *      Stand-alone file reading package.
  34  */
  35
  36 #include <sys/param.h>
  37 #include <sys/disklabel.h>
  38 #include <sys/time.h>
  39 #include <sys/queue.h>
  40 #include <stddef.h>
  41 #include <stdarg.h>
  42 #include <string.h>
  43 #include <stand.h>
  44 #include <bootstrap.h>
  45
  46 #include "libzfs.h"
  47
  48 #include "zfsimpl.c"
  49
  50 static int      zfs_open(const char *path, struct open_file *f);
  51 static int      zfs_write(struct open_file *f, void *buf, size_t size, size_t *resid);
  52 static int      zfs_close(struct open_file *f);
  53 static int      zfs_read(struct open_file *f, void *buf, size_t size, size_t *resid);
  54 static off_t    zfs_seek(struct open_file *f, off_t offset, int where);
  55 static int      zfs_stat(struct open_file *f, struct stat *sb);
  56 static int      zfs_readdir(struct open_file *f, struct dirent *d);
  57
  58 struct devsw zfs_dev;
  59 struct devsw zfs_dev_compat;
  60
  61 struct fs_ops zfs_fsops = {
  62         "zfs",
  63         zfs_open,
  64         zfs_close,
  65         zfs_read,
  66         zfs_write,
  67         zfs_seek,
  68         zfs_stat,
  69         zfs_readdir
  70 };
  71
  72 /*
  73  * In-core open file.
  74  */
  75 struct file {
  76         off_t           f_seekp;        /* seek pointer */
  77         dnode_phys_t    f_dnode;
  78         uint64_t        f_zap_type;     /* zap type for readdir */
  79         uint64_t        f_num_leafs;    /* number of fzap leaf blocks */
  80         zap_leaf_phys_t *f_zap_leaf;    /* zap leaf buffer */
  81 };
  82
  83 /*
  84  * Open a file.
  85  */
  86 static int
  87 zfs_open(const char *upath, struct open_file *f)
  88 {
  89         struct zfsmount *mount = (struct zfsmount *)f->f_devdata;
  90         struct file *fp;
  91         int rc;
  92
  93         if (f->f_dev != &zfs_dev && f->f_dev != &zfs_dev_compat)
  94                 return (EINVAL);
  95
  96         /* allocate file system specific data structure */
  97         fp = malloc(sizeof(struct file));
  98         bzero(fp, sizeof(struct file));
  99         f->f_fsdata = (void *)fp;
 100
 101         rc = zfs_lookup(mount, upath, &fp->f_dnode);
 102         fp->f_seekp = 0;
 103         if (rc) {
 104                 f->f_fsdata = NULL;
 105                 free(fp);
 106         }
 107         return (rc);
 108 }
 109
 110 static int
 111 zfs_close(struct open_file *f)
 112 {
 113         struct file *fp = (struct file *)f->f_fsdata;
 114
 115         dnode_cache_obj = 0;
 116         f->f_fsdata = (void *)0;
 117         if (fp == (struct file *)0)
 118                 return (0);
 119
 120         free(fp);
 121         return (0);
 122 }
 123
 124 /*
 125  * Copy a portion of a file into kernel memory.
 126  * Cross block boundaries when necessary.
 127  */
 128 static int
 129 zfs_read(struct open_file *f, void *start, size_t size, size_t *resid   /* out */)
 130 {
 131         spa_t *spa = ((struct zfsmount *)f->f_devdata)->spa;
 132         struct file *fp = (struct file *)f->f_fsdata;
 133         struct stat sb;
 134         size_t n;
 135         int rc;
 136
 137         rc = zfs_stat(f, &sb);
 138         if (rc)
 139                 return (rc);
 140         n = size;
 141         if (fp->f_seekp + n > sb.st_size)
 142                 n = sb.st_size - fp->f_seekp;
 143
 144         rc = dnode_read(spa, &fp->f_dnode, fp->f_seekp, start, n);
 145         if (rc)
 146                 return (rc);
 147
 148         if (0) {
 149             int i;
 150             for (i = 0; i < n; i++)
 151                 putchar(((char*) start)[i]);
 152         }
 153         fp->f_seekp += n;
 154         if (resid)
 155                 *resid = size - n;
 156
 157         return (0);
 158 }
 159
 160 /*
 161  * Don't be silly - the bootstrap has no business writing anything.
 162  */
 163 static int
 164 zfs_write(struct open_file *f, void *start, size_t size, size_t *resid  /* out */)
 165 {
 166
 167         return (EROFS);
 168 }
 169
 170 static off_t
 171 zfs_seek(struct open_file *f, off_t offset, int where)
 172 {
 173         struct file *fp = (struct file *)f->f_fsdata;
 174
 175         switch (where) {
 176         case SEEK_SET:
 177                 fp->f_seekp = offset;
 178                 break;
 179         case SEEK_CUR:
 180                 fp->f_seekp += offset;
 181                 break;
 182         case SEEK_END:
 183             {
 184                 struct stat sb;
 185                 int error;
 186
 187                 error = zfs_stat(f, &sb);
 188                 if (error != 0) {
 189                         errno = error;
 190                         return (-1);
 191                 }
 192                 fp->f_seekp = sb.st_size - offset;
 193                 break;
 194             }
 195         default:
 196                 errno = EINVAL;
 197                 return (-1);
 198         }
 199         return (fp->f_seekp);
 200 }
 201
 202 static int
 203 zfs_stat(struct open_file *f, struct stat *sb)
 204 {
 205         spa_t *spa = ((struct zfsmount *)f->f_devdata)->spa;
 206         struct file *fp = (struct file *)f->f_fsdata;
 207
 208         return (zfs_dnode_stat(spa, &fp->f_dnode, sb));
 209 }
 210
 211 static int
 212 zfs_readdir(struct open_file *f, struct dirent *d)
 213 {
 214         spa_t *spa = ((struct zfsmount *)f->f_devdata)->spa;
 215         struct file *fp = (struct file *)f->f_fsdata;
 216         mzap_ent_phys_t mze;
 217         struct stat sb;
 218         size_t bsize = fp->f_dnode.dn_datablkszsec << SPA_MINBLOCKSHIFT;
 219         int rc;
 220
 221         rc = zfs_stat(f, &sb);
 222         if (rc)
 223                 return (rc);
 224         if (!S_ISDIR(sb.st_mode))
 225                 return (ENOTDIR);
 226
 227         /*
 228          * If this is the first read, get the zap type.
 229          */
 230         if (fp->f_seekp == 0) {
 231                 rc = dnode_read(spa, &fp->f_dnode,
 232                                 0, &fp->f_zap_type, sizeof(fp->f_zap_type));
 233                 if (rc)
 234                         return (rc);
 235
 236                 if (fp->f_zap_type == ZBT_MICRO) {
 237                         fp->f_seekp = offsetof(mzap_phys_t, mz_chunk);
 238                 } else {
 239                         rc = dnode_read(spa, &fp->f_dnode,
 240                                         offsetof(zap_phys_t, zap_num_leafs),
 241                                         &fp->f_num_leafs,
 242                                         sizeof(fp->f_num_leafs));
 243                         if (rc)
 244                                 return (rc);
 245
 246                         fp->f_seekp = bsize;
 247                         fp->f_zap_leaf = (zap_leaf_phys_t *)malloc(bsize);
 248                         rc = dnode_read(spa, &fp->f_dnode,
 249                                         fp->f_seekp,
 250                                         fp->f_zap_leaf,
 251                                         bsize);
 252                         if (rc)
 253                                 return (rc);
 254                 }
 255         }
 256
 257         if (fp->f_zap_type == ZBT_MICRO) {
 258         mzap_next:
 259                 if (fp->f_seekp >= bsize)
 260                         return (ENOENT);
 261
 262                 rc = dnode_read(spa, &fp->f_dnode,
 263                                 fp->f_seekp, &mze, sizeof(mze));
 264                 if (rc)
 265                         return (rc);
 266                 fp->f_seekp += sizeof(mze);
 267
 268                 if (!mze.mze_name[0])
 269                         goto mzap_next;
 270
 271                 d->d_fileno = ZFS_DIRENT_OBJ(mze.mze_value);
 272                 d->d_type = ZFS_DIRENT_TYPE(mze.mze_value);
 273                 strcpy(d->d_name, mze.mze_name);
 274                 d->d_namlen = strlen(d->d_name);
 275                 return (0);
 276         } else {
 277                 zap_leaf_t zl;
 278                 zap_leaf_chunk_t *zc, *nc;
 279                 int chunk;
 280                 size_t namelen;
 281                 char *p;
 282                 uint64_t value;
 283
 284                 /*
 285                  * Initialise this so we can use the ZAP size
 286                  * calculating macros.
 287                  */
 288                 zl.l_bs = ilog2(bsize);
 289                 zl.l_phys = fp->f_zap_leaf;
 290
 291                 /*
 292                  * Figure out which chunk we are currently looking at
 293                  * and consider seeking to the next leaf. We use the
 294                  * low bits of f_seekp as a simple chunk index.
 295                  */
 296         fzap_next:
 297                 chunk = fp->f_seekp & (bsize - 1);
 298                 if (chunk == ZAP_LEAF_NUMCHUNKS(&zl)) {
 299                         fp->f_seekp = (fp->f_seekp & ~(bsize - 1)) + bsize;
 300                         chunk = 0;
 301
 302                         /*
 303                          * Check for EOF and read the new leaf.
 304                          */
 305                         if (fp->f_seekp >= bsize * fp->f_num_leafs)
 306                                 return (ENOENT);
 307
 308                         rc = dnode_read(spa, &fp->f_dnode,
 309                                         fp->f_seekp,
 310                                         fp->f_zap_leaf,
 311                                         bsize);
 312                         if (rc)
 313                                 return (rc);
 314                 }
 315
 316                 zc = &ZAP_LEAF_CHUNK(&zl, chunk);
 317                 fp->f_seekp++;
 318                 if (zc->l_entry.le_type != ZAP_CHUNK_ENTRY)
 319                         goto fzap_next;
 320
 321                 namelen = zc->l_entry.le_name_length;
 322                 if (namelen > sizeof(d->d_name))
 323                         namelen = sizeof(d->d_name);
 324
 325                 /*
 326                  * Paste the name back together.
 327                  */
 328                 nc = &ZAP_LEAF_CHUNK(&zl, zc->l_entry.le_name_chunk);
 329                 p = d->d_name;
 330                 while (namelen > 0) {
 331                         int len;
 332                         len = namelen;
 333                         if (len > ZAP_LEAF_ARRAY_BYTES)
 334                                 len = ZAP_LEAF_ARRAY_BYTES;
 335                         memcpy(p, nc->l_array.la_array, len);
 336                         p += len;
 337                         namelen -= len;
 338                         nc = &ZAP_LEAF_CHUNK(&zl, nc->l_array.la_next);
 339                 }
 340                 d->d_name[sizeof(d->d_name) - 1] = 0;
 341
 342                 /*
 343                  * Assume the first eight bytes of the value are
 344                  * a uint64_t.
 345                  */
 346                 value = fzap_leaf_value(&zl, zc);
 347
 348                 d->d_fileno = ZFS_DIRENT_OBJ(value);
 349                 d->d_type = ZFS_DIRENT_TYPE(value);
 350                 d->d_namlen = strlen(d->d_name);
 351
 352                 return (0);
 353         }
 354 }
 355
 356 static int
 357 vdev_read(vdev_t *vdev, void *priv, off_t offset, void *buf, size_t size)
 358 {
 359         int fd;
 360
 361         fd = (uintptr_t) priv;
 362         lseek(fd, offset, SEEK_SET);
 363         if (read(fd, buf, size) == size) {
 364                 return 0;
 365         } else {
 366                 return (EIO);
 367         }
 368 }
 369
 370 static int
 371 zfs_dev_init(void)
 372 {
 373         zfs_init();
 374         if (archsw.arch_zfs_probe == NULL)
 375                 return (ENXIO);
 376         archsw.arch_zfs_probe();
 377         return (0);
 378 }
 379
 380 int
 381 zfs_probe_dev(const char *devname, uint64_t *pool_guid)
 382 {
 383         spa_t *spa;
 384         int fd;
 385         int ret;
 386
 387         fd = open(devname, O_RDONLY);
 388         if (fd == -1)
 389                 return (ENXIO);
 390         ret = vdev_probe(vdev_read, (void *)(uintptr_t)fd, &spa);
 391         if (ret != 0)
 392                 close(fd);
 393         else if (pool_guid != NULL)
 394                 *pool_guid = spa->spa_guid;
 395         return (0);
 396 }
 397
 398 /*
 399  * Print information about ZFS pools
 400  */
 401 static void
 402 zfs_dev_print(int verbose)
 403 {
 404         spa_t *spa;
 405         char line[80];
 406
 407         if (verbose) {
 408                 spa_all_status();
 409                 return;
 410         }
 411         STAILQ_FOREACH(spa, &zfs_pools, spa_link) {
 412                 sprintf(line, "    zfs:%s\n", spa->spa_name);
 413                 pager_output(line);
 414         }
 415 }
 416
 417 /*
 418  * Attempt to open the pool described by (dev) for use by (f).
 419  */
 420 static int
 421 zfs_dev_open(struct open_file *f, ...)
 422 {
 423         va_list         args;
 424         struct zfs_devdesc      *dev;
 425         struct zfsmount *mount;
 426         spa_t           *spa;
 427         int             rv;
 428
 429         va_start(args, f);
 430         dev = va_arg(args, struct zfs_devdesc *);
 431         va_end(args);
 432
 433         spa = spa_find_by_guid(dev->pool_guid);
 434         if (!spa)
 435                 return (ENXIO);
 436         rv = zfs_spa_init(spa);
 437         if (rv != 0)
 438                 return (rv);
 439         mount = malloc(sizeof(*mount));
 440         rv = zfs_mount(spa, dev->root_guid, mount);
 441         if (rv != 0) {
 442                 free(mount);
 443                 return (rv);
 444         }
 445         if (mount->objset.os_type != DMU_OST_ZFS) {
 446                 printf("Unexpected object set type %ju\n",
 447                     (uintmax_t)mount->objset.os_type);
 448                 free(mount);
 449                 return (EIO);
 450         }
 451         f->f_devdata = mount;
 452         free(dev);
 453         return (0);
 454 }
 455
 456 static int
 457 zfs_dev_close(struct open_file *f)
 458 {
 459
 460         free(f->f_devdata);
 461         f->f_devdata = NULL;
 462         return (0);
 463 }
 464
 465 static int
 466 zfs_dev_strategy(void *devdata, int rw, daddr_t dblk, size_t size, char *buf, size_t *rsize)
 467 {
 468
 469         return (ENOSYS);
 470 }
 471
 472 struct devsw zfs_dev = {
 473         .dv_name = "zfs",
 474         .dv_type = DEVT_ZFS,
 475         .dv_init = zfs_dev_init,
 476         .dv_strategy = zfs_dev_strategy,
 477         .dv_open = zfs_dev_open,
 478         .dv_close = zfs_dev_close,
 479         .dv_ioctl = noioctl,
 480         .dv_print = zfs_dev_print,
 481         .dv_cleanup = NULL
 482 };
 483
 484 int
 485 zfs_parsedev(struct zfs_devdesc *dev, const char *devspec, const char **path)
 486 {
 487         static char     rootname[ZFS_MAXNAMELEN];
 488         static char     poolname[ZFS_MAXNAMELEN];
 489         spa_t           *spa;
 490         const char      *end;
 491         const char      *np;
 492         const char      *sep;
 493         int             rv;
 494
 495         np = devspec;
 496         if (*np != ':')
 497                 return (EINVAL);
 498         np++;
 499         end = strchr(np, ':');
 500         if (end == NULL)
 501                 return (EINVAL);
 502         sep = strchr(np, '/');
 503         if (sep == NULL || sep >= end)
 504                 sep = end;
 505         memcpy(poolname, np, sep - np);
 506         poolname[sep - np] = '\0';
 507         if (sep < end) {
 508                 sep++;
 509                 memcpy(rootname, sep, end - sep);
 510                 rootname[end - sep] = '\0';
 511         }
 512         else
 513                 rootname[0] = '\0';
 514
 515         spa = spa_find_by_name(poolname);
 516         if (!spa)
 517                 return (ENXIO);
 518         rv = zfs_spa_init(spa);
 519         if (rv != 0)
 520                 return (rv);
 521         dev->pool_guid = spa->spa_guid;
 522         if (rootname[0] != '\0') {
 523                 rv = zfs_lookup_dataset(spa, rootname, &dev->root_guid);
 524                 if (rv != 0)
 525                         return (rv);
 526         } else
 527                 dev->root_guid = 0;
 528         if (path != NULL)
 529                 *path = (*end == '\0') ? end : end + 1;
 530         dev->d_dev = &zfs_dev;
 531         dev->d_type = zfs_dev.dv_type;
 532         return (0);
 533 }
 534
 535 char *
 536 zfs_fmtdev(void *vdev)
 537 {
 538         static char             rootname[ZFS_MAXNAMELEN];
 539         static char             buf[2 * ZFS_MAXNAMELEN + 8];
 540         struct zfs_devdesc      *dev = (struct zfs_devdesc *)vdev;
 541         spa_t                   *spa;
 542
 543         buf[0] = '\0';
 544         if (dev->d_type != DEVT_ZFS)
 545                 return (buf);
 546
 547         spa = spa_find_by_guid(dev->pool_guid);
 548         if (spa == NULL) {
 549                 printf("ZFS: can't find pool by guid\n");
 550                 return (buf);
 551         }
 552         if (zfs_spa_init(spa) != 0) {
 553                 printf("ZFS: can't init pool\n");
 554                 return (buf);
 555         }
 556         if (dev->root_guid == 0 && zfs_get_root(spa, &dev->root_guid)) {
 557                 printf("ZFS: can't find root filesystem\n");
 558                 return (buf);
 559         }
 560         if (zfs_rlookup(spa, dev->root_guid, rootname)) {
 561                 printf("ZFS: can't find filesystem by guid\n");
 562                 return (buf);
 563         }
 564
 565         if (rootname[0] == '\0')
 566                 sprintf(buf, "%s:%s:", dev->d_dev->dv_name, spa->spa_name);
 567         else
 568                 sprintf(buf, "%s:%s/%s:", dev->d_dev->dv_name, spa->spa_name,
 569                     rootname);
 570         return (buf);
 571 }