The Design and Implementation of the FreeBSD Operating System, Second Edition
Now available: The Design and Implementation of the FreeBSD Operating System (Second Edition)


[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]

FreeBSD/Linux Kernel Cross Reference
sys/boot/zfs/zfs.c

Version: -  FREEBSD  -  FREEBSD-12-STABLE  -  FREEBSD-12-0  -  FREEBSD-11-STABLE  -  FREEBSD-11-2  -  FREEBSD-11-1  -  FREEBSD-11-0  -  FREEBSD-10-STABLE  -  FREEBSD-10-4  -  FREEBSD-10-3  -  FREEBSD-10-2  -  FREEBSD-10-1  -  FREEBSD-10-0  -  FREEBSD-9-STABLE  -  FREEBSD-9-3  -  FREEBSD-9-2  -  FREEBSD-9-1  -  FREEBSD-9-0  -  FREEBSD-8-STABLE  -  FREEBSD-8-4  -  FREEBSD-8-3  -  FREEBSD-8-2  -  FREEBSD-8-1  -  FREEBSD-8-0  -  FREEBSD-7-STABLE  -  FREEBSD-7-4  -  FREEBSD-7-3  -  FREEBSD-7-2  -  FREEBSD-7-1  -  FREEBSD-7-0  -  FREEBSD-6-STABLE  -  FREEBSD-6-4  -  FREEBSD-6-3  -  FREEBSD-6-2  -  FREEBSD-6-1  -  FREEBSD-6-0  -  FREEBSD-5-STABLE  -  FREEBSD-5-5  -  FREEBSD-5-4  -  FREEBSD-5-3  -  FREEBSD-5-2  -  FREEBSD-5-1  -  FREEBSD-5-0  -  FREEBSD-4-STABLE  -  FREEBSD-3-STABLE  -  FREEBSD22  -  linux-2.6  -  linux-2.4.22  -  MK83  -  MK84  -  PLAN9  -  DFBSD  -  NETBSD  -  NETBSD5  -  NETBSD4  -  NETBSD3  -  NETBSD20  -  OPENBSD  -  xnu-517  -  xnu-792  -  xnu-792.6.70  -  xnu-1228  -  xnu-1456.1.26  -  xnu-1699.24.8  -  xnu-2050.18.24  -  OPENSOLARIS  -  minix-3-1-1 
SearchContext: -  none  -  3  -  10 

    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: releng/9.2/sys/boot/zfs/zfs.c 243243 2012-11-18 17:09:29Z ae $
   27  */
   28 
   29 #include <sys/cdefs.h>
   30 __FBSDID("$FreeBSD: releng/9.2/sys/boot/zfs/zfs.c 243243 2012-11-18 17:09:29Z ae $");
   31 
   32 /*
   33  *      Stand-alone file reading package.
   34  */
   35 
   36 #include <sys/disk.h>
   37 #include <sys/param.h>
   38 #include <sys/time.h>
   39 #include <sys/queue.h>
   40 #include <part.h>
   41 #include <stddef.h>
   42 #include <stdarg.h>
   43 #include <string.h>
   44 #include <stand.h>
   45 #include <bootstrap.h>
   46 
   47 #include "libzfs.h"
   48 
   49 #include "zfsimpl.c"
   50 
   51 static int      zfs_open(const char *path, struct open_file *f);
   52 static int      zfs_write(struct open_file *f, void *buf, size_t size, size_t *resid);
   53 static int      zfs_close(struct open_file *f);
   54 static int      zfs_read(struct open_file *f, void *buf, size_t size, size_t *resid);
   55 static off_t    zfs_seek(struct open_file *f, off_t offset, int where);
   56 static int      zfs_stat(struct open_file *f, struct stat *sb);
   57 static int      zfs_readdir(struct open_file *f, struct dirent *d);
   58 
   59 struct devsw zfs_dev;
   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)
   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         const 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         const 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         const 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_numints;
  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         spa_t *spa;
  374         spa_t *next;
  375         spa_t *prev;
  376 
  377         zfs_init();
  378         if (archsw.arch_zfs_probe == NULL)
  379                 return (ENXIO);
  380         archsw.arch_zfs_probe();
  381 
  382         prev = NULL;
  383         spa = STAILQ_FIRST(&zfs_pools);
  384         while (spa != NULL) {
  385                 next = STAILQ_NEXT(spa, spa_link);
  386                 if (zfs_spa_init(spa)) {
  387                         if (prev == NULL)
  388                                 STAILQ_REMOVE_HEAD(&zfs_pools, spa_link);
  389                         else
  390                                 STAILQ_REMOVE_AFTER(&zfs_pools, prev, spa_link);
  391                 } else
  392                         prev = spa;
  393                 spa = next;
  394         }
  395         return (0);
  396 }
  397 
  398 struct zfs_probe_args {
  399         int             fd;
  400         const char      *devname;
  401         uint64_t        *pool_guid;
  402         uint16_t        secsz;
  403 };
  404 
  405 static int
  406 zfs_diskread(void *arg, void *buf, size_t blocks, off_t offset)
  407 {
  408         struct zfs_probe_args *ppa;
  409 
  410         ppa = (struct zfs_probe_args *)arg;
  411         return (vdev_read(NULL, (void *)(uintptr_t)ppa->fd,
  412             offset * ppa->secsz, buf, blocks * ppa->secsz));
  413 }
  414 
  415 static int
  416 zfs_probe(int fd, uint64_t *pool_guid)
  417 {
  418         spa_t *spa;
  419         int ret;
  420 
  421         ret = vdev_probe(vdev_read, (void *)(uintptr_t)fd, &spa);
  422         if (ret == 0 && pool_guid != NULL)
  423                 *pool_guid = spa->spa_guid;
  424         return (ret);
  425 }
  426 
  427 static void
  428 zfs_probe_partition(void *arg, const char *partname,
  429     const struct ptable_entry *part)
  430 {
  431         struct zfs_probe_args *ppa, pa;
  432         struct ptable *table;
  433         char devname[32];
  434         int ret;
  435 
  436         /* Probe only freebsd-zfs and freebsd partitions */
  437         if (part->type != PART_FREEBSD &&
  438             part->type != PART_FREEBSD_ZFS)
  439                 return;
  440 
  441         ppa = (struct zfs_probe_args *)arg;
  442         strncpy(devname, ppa->devname, strlen(ppa->devname) - 1);
  443         devname[strlen(ppa->devname) - 1] = '\0';
  444         sprintf(devname, "%s%s:", devname, partname);
  445         pa.fd = open(devname, O_RDONLY);
  446         if (pa.fd == -1)
  447                 return;
  448         ret = zfs_probe(pa.fd, ppa->pool_guid);
  449         if (ret == 0)
  450                 return;
  451         /* Do we have BSD label here? */
  452         if (part->type == PART_FREEBSD) {
  453                 pa.devname = devname;
  454                 pa.pool_guid = ppa->pool_guid;
  455                 pa.secsz = ppa->secsz;
  456                 table = ptable_open(&pa, part->end - part->start + 1,
  457                     ppa->secsz, zfs_diskread);
  458                 if (table != NULL) {
  459                         ptable_iterate(table, &pa, zfs_probe_partition);
  460                         ptable_close(table);
  461                 }
  462         }
  463         close(pa.fd);
  464 }
  465 
  466 int
  467 zfs_probe_dev(const char *devname, uint64_t *pool_guid)
  468 {
  469         struct ptable *table;
  470         struct zfs_probe_args pa;
  471         off_t mediasz;
  472         int ret;
  473 
  474         pa.fd = open(devname, O_RDONLY);
  475         if (pa.fd == -1)
  476                 return (ENXIO);
  477         /* Probe the whole disk */
  478         ret = zfs_probe(pa.fd, pool_guid);
  479         if (ret == 0)
  480                 return (0);
  481         /* Probe each partition */
  482         ret = ioctl(pa.fd, DIOCGMEDIASIZE, &mediasz);
  483         if (ret == 0)
  484                 ret = ioctl(pa.fd, DIOCGSECTORSIZE, &pa.secsz);
  485         if (ret == 0) {
  486                 pa.devname = devname;
  487                 pa.pool_guid = pool_guid;
  488                 table = ptable_open(&pa, mediasz / pa.secsz, pa.secsz,
  489                     zfs_diskread);
  490                 if (table != NULL) {
  491                         ptable_iterate(table, &pa, zfs_probe_partition);
  492                         ptable_close(table);
  493                 }
  494         }
  495         close(pa.fd);
  496         return (0);
  497 }
  498 
  499 /*
  500  * Print information about ZFS pools
  501  */
  502 static void
  503 zfs_dev_print(int verbose)
  504 {
  505         spa_t *spa;
  506         char line[80];
  507 
  508         if (verbose) {
  509                 spa_all_status();
  510                 return;
  511         }
  512         STAILQ_FOREACH(spa, &zfs_pools, spa_link) {
  513                 sprintf(line, "    zfs:%s\n", spa->spa_name);
  514                 pager_output(line);
  515         }
  516 }
  517 
  518 /*
  519  * Attempt to open the pool described by (dev) for use by (f).
  520  */
  521 static int
  522 zfs_dev_open(struct open_file *f, ...)
  523 {
  524         va_list         args;
  525         struct zfs_devdesc      *dev;
  526         struct zfsmount *mount;
  527         spa_t           *spa;
  528         int             rv;
  529 
  530         va_start(args, f);
  531         dev = va_arg(args, struct zfs_devdesc *);
  532         va_end(args);
  533 
  534         if (dev->pool_guid == 0)
  535                 spa = STAILQ_FIRST(&zfs_pools);
  536         else
  537                 spa = spa_find_by_guid(dev->pool_guid);
  538         if (!spa)
  539                 return (ENXIO);
  540         mount = malloc(sizeof(*mount));
  541         rv = zfs_mount(spa, dev->root_guid, mount);
  542         if (rv != 0) {
  543                 free(mount);
  544                 return (rv);
  545         }
  546         if (mount->objset.os_type != DMU_OST_ZFS) {
  547                 printf("Unexpected object set type %ju\n",
  548                     (uintmax_t)mount->objset.os_type);
  549                 free(mount);
  550                 return (EIO);
  551         }
  552         f->f_devdata = mount;
  553         free(dev);
  554         return (0);
  555 }
  556 
  557 static int
  558 zfs_dev_close(struct open_file *f)
  559 {
  560 
  561         free(f->f_devdata);
  562         f->f_devdata = NULL;
  563         return (0);
  564 }
  565 
  566 static int
  567 zfs_dev_strategy(void *devdata, int rw, daddr_t dblk, size_t size, char *buf, size_t *rsize)
  568 {
  569 
  570         return (ENOSYS);
  571 }
  572 
  573 struct devsw zfs_dev = {
  574         .dv_name = "zfs",
  575         .dv_type = DEVT_ZFS,
  576         .dv_init = zfs_dev_init,
  577         .dv_strategy = zfs_dev_strategy,
  578         .dv_open = zfs_dev_open,
  579         .dv_close = zfs_dev_close,
  580         .dv_ioctl = noioctl,
  581         .dv_print = zfs_dev_print,
  582         .dv_cleanup = NULL
  583 };
  584 
  585 int
  586 zfs_parsedev(struct zfs_devdesc *dev, const char *devspec, const char **path)
  587 {
  588         static char     rootname[ZFS_MAXNAMELEN];
  589         static char     poolname[ZFS_MAXNAMELEN];
  590         spa_t           *spa;
  591         const char      *end;
  592         const char      *np;
  593         const char      *sep;
  594         int             rv;
  595 
  596         np = devspec;
  597         if (*np != ':')
  598                 return (EINVAL);
  599         np++;
  600         end = strchr(np, ':');
  601         if (end == NULL)
  602                 return (EINVAL);
  603         sep = strchr(np, '/');
  604         if (sep == NULL || sep >= end)
  605                 sep = end;
  606         memcpy(poolname, np, sep - np);
  607         poolname[sep - np] = '\0';
  608         if (sep < end) {
  609                 sep++;
  610                 memcpy(rootname, sep, end - sep);
  611                 rootname[end - sep] = '\0';
  612         }
  613         else
  614                 rootname[0] = '\0';
  615 
  616         spa = spa_find_by_name(poolname);
  617         if (!spa)
  618                 return (ENXIO);
  619         dev->pool_guid = spa->spa_guid;
  620         rv = zfs_lookup_dataset(spa, rootname, &dev->root_guid);
  621         if (rv != 0)
  622                 return (rv);
  623         if (path != NULL)
  624                 *path = (*end == '\0') ? end : end + 1;
  625         dev->d_dev = &zfs_dev;
  626         dev->d_type = zfs_dev.dv_type;
  627         return (0);
  628 }
  629 
  630 char *
  631 zfs_fmtdev(void *vdev)
  632 {
  633         static char             rootname[ZFS_MAXNAMELEN];
  634         static char             buf[2 * ZFS_MAXNAMELEN + 8];
  635         struct zfs_devdesc      *dev = (struct zfs_devdesc *)vdev;
  636         spa_t                   *spa;
  637 
  638         buf[0] = '\0';
  639         if (dev->d_type != DEVT_ZFS)
  640                 return (buf);
  641 
  642         if (dev->pool_guid == 0) {
  643                 spa = STAILQ_FIRST(&zfs_pools);
  644                 dev->pool_guid = spa->spa_guid;
  645         } else
  646                 spa = spa_find_by_guid(dev->pool_guid);
  647         if (spa == NULL) {
  648                 printf("ZFS: can't find pool by guid\n");
  649                 return (buf);
  650         }
  651         if (dev->root_guid == 0 && zfs_get_root(spa, &dev->root_guid)) {
  652                 printf("ZFS: can't find root filesystem\n");
  653                 return (buf);
  654         }
  655         if (zfs_rlookup(spa, dev->root_guid, rootname)) {
  656                 printf("ZFS: can't find filesystem by guid\n");
  657                 return (buf);
  658         }
  659 
  660         if (rootname[0] == '\0')
  661                 sprintf(buf, "%s:%s:", dev->d_dev->dv_name, spa->spa_name);
  662         else
  663                 sprintf(buf, "%s:%s/%s:", dev->d_dev->dv_name, spa->spa_name,
  664                     rootname);
  665         return (buf);
  666 }
  667 
  668 int
  669 zfs_list(const char *name)
  670 {
  671         static char     poolname[ZFS_MAXNAMELEN];
  672         uint64_t        objid;
  673         spa_t           *spa;
  674         const char      *dsname;
  675         int             len;
  676         int             rv;
  677 
  678         len = strlen(name);
  679         dsname = strchr(name, '/');
  680         if (dsname != NULL) {
  681                 len = dsname - name;
  682                 dsname++;
  683         } else
  684                 dsname = "";
  685         memcpy(poolname, name, len);
  686         poolname[len] = '\0';
  687 
  688         spa = spa_find_by_name(poolname);
  689         if (!spa)
  690                 return (ENXIO);
  691         rv = zfs_lookup_dataset(spa, dsname, &objid);
  692         if (rv != 0)
  693                 return (rv);
  694         rv = zfs_list_dataset(spa, objid);
  695         return (rv);
  696 }

Cache object: dd79782ce779101835476e6e0f78d336


[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]


This page is part of the FreeBSD/Linux Linux Kernel Cross-Reference, and was automatically generated using a modified version of the LXR engine.