sys/boot/zfs/zfsimpl.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
  27 #include <sys/cdefs.h>
  28 __FBSDID("$FreeBSD$");
  29
  30 /*
  31  *      Stand-alone ZFS file reader.
  32  */
  33
  34 #include <sys/stat.h>
  35 #include <sys/stdint.h>
  36
  37 #include "zfsimpl.h"
  38 #include "zfssubr.c"
  39
  40
  41 struct zfsmount {
  42         const spa_t     *spa;
  43         objset_phys_t   objset;
  44         uint64_t        rootobj;
  45 };
  46
  47 /*
  48  * List of all vdevs, chained through v_alllink.
  49  */
  50 static vdev_list_t zfs_vdevs;
  51
  52  /*
  53  * List of ZFS features supported for read
  54  */
  55 static const char *features_for_read[] = {
  56         "org.illumos:lz4_compress",
  57         "com.delphix:hole_birth",
  58         "com.delphix:extensible_dataset",
  59         "com.delphix:embedded_data",
  60         "org.open-zfs:large_blocks",
  61         "org.illumos:sha512",
  62         "org.illumos:skein",
  63         NULL
  64 };
  65
  66 /*
  67  * List of all pools, chained through spa_link.
  68  */
  69 static spa_list_t zfs_pools;
  70
  71 static uint64_t zfs_crc64_table[256];
  72 static const dnode_phys_t *dnode_cache_obj = 0;
  73 static uint64_t dnode_cache_bn;
  74 static char *dnode_cache_buf;
  75 static char *zap_scratch;
  76 static char *zfs_temp_buf, *zfs_temp_end, *zfs_temp_ptr;
  77
  78 #define TEMP_SIZE       (1024 * 1024)
  79
  80 static int zio_read(const spa_t *spa, const blkptr_t *bp, void *buf);
  81 static int zfs_get_root(const spa_t *spa, uint64_t *objid);
  82 static int zfs_rlookup(const spa_t *spa, uint64_t objnum, char *result);
  83 static int zap_lookup(const spa_t *spa, const dnode_phys_t *dnode,
  84     const char *name, uint64_t integer_size, uint64_t num_integers,
  85     void *value);
  86
  87 static void
  88 zfs_init(void)
  89 {
  90         STAILQ_INIT(&zfs_vdevs);
  91         STAILQ_INIT(&zfs_pools);
  92
  93         zfs_temp_buf = malloc(TEMP_SIZE);
  94         zfs_temp_end = zfs_temp_buf + TEMP_SIZE;
  95         zfs_temp_ptr = zfs_temp_buf;
  96         dnode_cache_buf = malloc(SPA_MAXBLOCKSIZE);
  97         zap_scratch = malloc(SPA_MAXBLOCKSIZE);
  98
  99         zfs_init_crc();
 100 }
 101
 102 static void *
 103 zfs_alloc(size_t size)
 104 {
 105         char *ptr;
 106
 107         if (zfs_temp_ptr + size > zfs_temp_end) {
 108                 printf("ZFS: out of temporary buffer space\n");
 109                 for (;;) ;
 110         }
 111         ptr = zfs_temp_ptr;
 112         zfs_temp_ptr += size;
 113
 114         return (ptr);
 115 }
 116
 117 static void
 118 zfs_free(void *ptr, size_t size)
 119 {
 120
 121         zfs_temp_ptr -= size;
 122         if (zfs_temp_ptr != ptr) {
 123                 printf("ZFS: zfs_alloc()/zfs_free() mismatch\n");
 124                 for (;;) ;
 125         }
 126 }
 127
 128 static int
 129 xdr_int(const unsigned char **xdr, int *ip)
 130 {
 131         *ip = ((*xdr)[0] << 24)
 132                 | ((*xdr)[1] << 16)
 133                 | ((*xdr)[2] << 8)
 134                 | ((*xdr)[3] << 0);
 135         (*xdr) += 4;
 136         return (0);
 137 }
 138
 139 static int
 140 xdr_u_int(const unsigned char **xdr, u_int *ip)
 141 {
 142         *ip = ((*xdr)[0] << 24)
 143                 | ((*xdr)[1] << 16)
 144                 | ((*xdr)[2] << 8)
 145                 | ((*xdr)[3] << 0);
 146         (*xdr) += 4;
 147         return (0);
 148 }
 149
 150 static int
 151 xdr_uint64_t(const unsigned char **xdr, uint64_t *lp)
 152 {
 153         u_int hi, lo;
 154
 155         xdr_u_int(xdr, &hi);
 156         xdr_u_int(xdr, &lo);
 157         *lp = (((uint64_t) hi) << 32) | lo;
 158         return (0);
 159 }
 160
 161 static int
 162 nvlist_find(const unsigned char *nvlist, const char *name, int type,
 163             int* elementsp, void *valuep)
 164 {
 165         const unsigned char *p, *pair;
 166         int junk;
 167         int encoded_size, decoded_size;
 168
 169         p = nvlist;
 170         xdr_int(&p, &junk);
 171         xdr_int(&p, &junk);
 172
 173         pair = p;
 174         xdr_int(&p, &encoded_size);
 175         xdr_int(&p, &decoded_size);
 176         while (encoded_size && decoded_size) {
 177                 int namelen, pairtype, elements;
 178                 const char *pairname;
 179
 180                 xdr_int(&p, &namelen);
 181                 pairname = (const char*) p;
 182                 p += roundup(namelen, 4);
 183                 xdr_int(&p, &pairtype);
 184
 185                 if (!memcmp(name, pairname, namelen) && type == pairtype) {
 186                         xdr_int(&p, &elements);
 187                         if (elementsp)
 188                                 *elementsp = elements;
 189                         if (type == DATA_TYPE_UINT64) {
 190                                 xdr_uint64_t(&p, (uint64_t *) valuep);
 191                                 return (0);
 192                         } else if (type == DATA_TYPE_STRING) {
 193                                 int len;
 194                                 xdr_int(&p, &len);
 195                                 (*(const char**) valuep) = (const char*) p;
 196                                 return (0);
 197                         } else if (type == DATA_TYPE_NVLIST
 198                                    || type == DATA_TYPE_NVLIST_ARRAY) {
 199                                 (*(const unsigned char**) valuep) =
 200                                          (const unsigned char*) p;
 201                                 return (0);
 202                         } else {
 203                                 return (EIO);
 204                         }
 205                 } else {
 206                         /*
 207                          * Not the pair we are looking for, skip to the next one.
 208                          */
 209                         p = pair + encoded_size;
 210                 }
 211
 212                 pair = p;
 213                 xdr_int(&p, &encoded_size);
 214                 xdr_int(&p, &decoded_size);
 215         }
 216
 217         return (EIO);
 218 }
 219
 220 static int
 221 nvlist_check_features_for_read(const unsigned char *nvlist)
 222 {
 223         const unsigned char *p, *pair;
 224         int junk;
 225         int encoded_size, decoded_size;
 226         int rc;
 227
 228         rc = 0;
 229
 230         p = nvlist;
 231         xdr_int(&p, &junk);
 232         xdr_int(&p, &junk);
 233
 234         pair = p;
 235         xdr_int(&p, &encoded_size);
 236         xdr_int(&p, &decoded_size);
 237         while (encoded_size && decoded_size) {
 238                 int namelen, pairtype;
 239                 const char *pairname;
 240                 int i, found;
 241
 242                 found = 0;
 243
 244                 xdr_int(&p, &namelen);
 245                 pairname = (const char*) p;
 246                 p += roundup(namelen, 4);
 247                 xdr_int(&p, &pairtype);
 248
 249                 for (i = 0; features_for_read[i] != NULL; i++) {
 250                         if (!memcmp(pairname, features_for_read[i], namelen)) {
 251                                 found = 1;
 252                                 break;
 253                         }
 254                 }
 255
 256                 if (!found) {
 257                         printf("ZFS: unsupported feature: %s\n", pairname);
 258                         rc = EIO;
 259                 }
 260
 261                 p = pair + encoded_size;
 262
 263                 pair = p;
 264                 xdr_int(&p, &encoded_size);
 265                 xdr_int(&p, &decoded_size);
 266         }
 267
 268         return (rc);
 269 }
 270
 271 /*
 272  * Return the next nvlist in an nvlist array.
 273  */
 274 static const unsigned char *
 275 nvlist_next(const unsigned char *nvlist)
 276 {
 277         const unsigned char *p, *pair;
 278         int junk;
 279         int encoded_size, decoded_size;
 280
 281         p = nvlist;
 282         xdr_int(&p, &junk);
 283         xdr_int(&p, &junk);
 284
 285         pair = p;
 286         xdr_int(&p, &encoded_size);
 287         xdr_int(&p, &decoded_size);
 288         while (encoded_size && decoded_size) {
 289                 p = pair + encoded_size;
 290
 291                 pair = p;
 292                 xdr_int(&p, &encoded_size);
 293                 xdr_int(&p, &decoded_size);
 294         }
 295
 296         return p;
 297 }
 298
 299 #ifdef TEST
 300
 301 static const unsigned char *
 302 nvlist_print(const unsigned char *nvlist, unsigned int indent)
 303 {
 304         static const char* typenames[] = {
 305                 "DATA_TYPE_UNKNOWN",
 306                 "DATA_TYPE_BOOLEAN",
 307                 "DATA_TYPE_BYTE",
 308                 "DATA_TYPE_INT16",
 309                 "DATA_TYPE_UINT16",
 310                 "DATA_TYPE_INT32",
 311                 "DATA_TYPE_UINT32",
 312                 "DATA_TYPE_INT64",
 313                 "DATA_TYPE_UINT64",
 314                 "DATA_TYPE_STRING",
 315                 "DATA_TYPE_BYTE_ARRAY",
 316                 "DATA_TYPE_INT16_ARRAY",
 317                 "DATA_TYPE_UINT16_ARRAY",
 318                 "DATA_TYPE_INT32_ARRAY",
 319                 "DATA_TYPE_UINT32_ARRAY",
 320                 "DATA_TYPE_INT64_ARRAY",
 321                 "DATA_TYPE_UINT64_ARRAY",
 322                 "DATA_TYPE_STRING_ARRAY",
 323                 "DATA_TYPE_HRTIME",
 324                 "DATA_TYPE_NVLIST",
 325                 "DATA_TYPE_NVLIST_ARRAY",
 326                 "DATA_TYPE_BOOLEAN_VALUE",
 327                 "DATA_TYPE_INT8",
 328                 "DATA_TYPE_UINT8",
 329                 "DATA_TYPE_BOOLEAN_ARRAY",
 330                 "DATA_TYPE_INT8_ARRAY",
 331                 "DATA_TYPE_UINT8_ARRAY"
 332         };
 333
 334         unsigned int i, j;
 335         const unsigned char *p, *pair;
 336         int junk;
 337         int encoded_size, decoded_size;
 338
 339         p = nvlist;
 340         xdr_int(&p, &junk);
 341         xdr_int(&p, &junk);
 342
 343         pair = p;
 344         xdr_int(&p, &encoded_size);
 345         xdr_int(&p, &decoded_size);
 346         while (encoded_size && decoded_size) {
 347                 int namelen, pairtype, elements;
 348                 const char *pairname;
 349
 350                 xdr_int(&p, &namelen);
 351                 pairname = (const char*) p;
 352                 p += roundup(namelen, 4);
 353                 xdr_int(&p, &pairtype);
 354
 355                 for (i = 0; i < indent; i++)
 356                         printf(" ");
 357                 printf("%s %s", typenames[pairtype], pairname);
 358
 359                 xdr_int(&p, &elements);
 360                 switch (pairtype) {
 361                 case DATA_TYPE_UINT64: {
 362                         uint64_t val;
 363                         xdr_uint64_t(&p, &val);
 364                         printf(" = 0x%jx\n", (uintmax_t)val);
 365                         break;
 366                 }
 367
 368                 case DATA_TYPE_STRING: {
 369                         int len;
 370                         xdr_int(&p, &len);
 371                         printf(" = \"%s\"\n", p);
 372                         break;
 373                 }
 374
 375                 case DATA_TYPE_NVLIST:
 376                         printf("\n");
 377                         nvlist_print(p, indent + 1);
 378                         break;
 379
 380                 case DATA_TYPE_NVLIST_ARRAY:
 381                         for (j = 0; j < elements; j++) {
 382                                 printf("[%d]\n", j);
 383                                 p = nvlist_print(p, indent + 1);
 384                                 if (j != elements - 1) {
 385                                         for (i = 0; i < indent; i++)
 386                                                 printf(" ");
 387                                         printf("%s %s", typenames[pairtype], pairname);
 388                                 }
 389                         }
 390                         break;
 391
 392                 default:
 393                         printf("\n");
 394                 }
 395
 396                 p = pair + encoded_size;
 397
 398                 pair = p;
 399                 xdr_int(&p, &encoded_size);
 400                 xdr_int(&p, &decoded_size);
 401         }
 402
 403         return p;
 404 }
 405
 406 #endif
 407
 408 static int
 409 vdev_read_phys(vdev_t *vdev, const blkptr_t *bp, void *buf,
 410     off_t offset, size_t size)
 411 {
 412         size_t psize;
 413         int rc;
 414
 415         if (!vdev->v_phys_read)
 416                 return (EIO);
 417
 418         if (bp) {
 419                 psize = BP_GET_PSIZE(bp);
 420         } else {
 421                 psize = size;
 422         }
 423
 424         /*printf("ZFS: reading %d bytes at 0x%jx to %p\n", psize, (uintmax_t)offset, buf);*/
 425         rc = vdev->v_phys_read(vdev, vdev->v_read_priv, offset, buf, psize);
 426         if (rc)
 427                 return (rc);
 428         if (bp && zio_checksum_verify(vdev->spa, bp, buf))
 429                 return (EIO);
 430
 431         return (0);
 432 }
 433
 434 static int
 435 vdev_disk_read(vdev_t *vdev, const blkptr_t *bp, void *buf,
 436     off_t offset, size_t bytes)
 437 {
 438
 439         return (vdev_read_phys(vdev, bp, buf,
 440                 offset + VDEV_LABEL_START_SIZE, bytes));
 441 }
 442
 443
 444 static int
 445 vdev_mirror_read(vdev_t *vdev, const blkptr_t *bp, void *buf,
 446     off_t offset, size_t bytes)
 447 {
 448         vdev_t *kid;
 449         int rc;
 450
 451         rc = EIO;
 452         STAILQ_FOREACH(kid, &vdev->v_children, v_childlink) {
 453                 if (kid->v_state != VDEV_STATE_HEALTHY)
 454                         continue;
 455                 rc = kid->v_read(kid, bp, buf, offset, bytes);
 456                 if (!rc)
 457                         return (0);
 458         }
 459
 460         return (rc);
 461 }
 462
 463 static int
 464 vdev_replacing_read(vdev_t *vdev, const blkptr_t *bp, void *buf,
 465     off_t offset, size_t bytes)
 466 {
 467         vdev_t *kid;
 468
 469         /*
 470          * Here we should have two kids:
 471          * First one which is the one we are replacing and we can trust
 472          * only this one to have valid data, but it might not be present.
 473          * Second one is that one we are replacing with. It is most likely
 474          * healthy, but we can't trust it has needed data, so we won't use it.
 475          */
 476         kid = STAILQ_FIRST(&vdev->v_children);
 477         if (kid == NULL)
 478                 return (EIO);
 479         if (kid->v_state != VDEV_STATE_HEALTHY)
 480                 return (EIO);
 481         return (kid->v_read(kid, bp, buf, offset, bytes));
 482 }
 483
 484 static vdev_t *
 485 vdev_find(uint64_t guid)
 486 {
 487         vdev_t *vdev;
 488
 489         STAILQ_FOREACH(vdev, &zfs_vdevs, v_alllink)
 490                 if (vdev->v_guid == guid)
 491                         return (vdev);
 492
 493         return (0);
 494 }
 495
 496 static vdev_t *
 497 vdev_create(uint64_t guid, vdev_read_t *read)
 498 {
 499         vdev_t *vdev;
 500
 501         vdev = malloc(sizeof(vdev_t));
 502         memset(vdev, 0, sizeof(vdev_t));
 503         STAILQ_INIT(&vdev->v_children);
 504         vdev->v_guid = guid;
 505         vdev->v_state = VDEV_STATE_OFFLINE;
 506         vdev->v_read = read;
 507         vdev->v_phys_read = 0;
 508         vdev->v_read_priv = 0;
 509         STAILQ_INSERT_TAIL(&zfs_vdevs, vdev, v_alllink);
 510
 511         return (vdev);
 512 }
 513
 514 static int
 515 vdev_init_from_nvlist(const unsigned char *nvlist, vdev_t *pvdev,
 516     vdev_t **vdevp, int is_newer)
 517 {
 518         int rc;
 519         uint64_t guid, id, ashift, nparity;
 520         const char *type;
 521         const char *path;
 522         vdev_t *vdev, *kid;
 523         const unsigned char *kids;
 524         int nkids, i, is_new;
 525         uint64_t is_offline, is_faulted, is_degraded, is_removed, isnt_present;
 526
 527         if (nvlist_find(nvlist, ZPOOL_CONFIG_GUID,
 528                         DATA_TYPE_UINT64, 0, &guid)
 529             || nvlist_find(nvlist, ZPOOL_CONFIG_ID,
 530                            DATA_TYPE_UINT64, 0, &id)
 531             || nvlist_find(nvlist, ZPOOL_CONFIG_TYPE,
 532                            DATA_TYPE_STRING, 0, &type)) {
 533                 printf("ZFS: can't find vdev details\n");
 534                 return (ENOENT);
 535         }
 536
 537         if (strcmp(type, VDEV_TYPE_MIRROR)
 538             && strcmp(type, VDEV_TYPE_DISK)
 539 #ifdef ZFS_TEST
 540             && strcmp(type, VDEV_TYPE_FILE)
 541 #endif
 542             && strcmp(type, VDEV_TYPE_RAIDZ)
 543             && strcmp(type, VDEV_TYPE_REPLACING)) {
 544                 printf("ZFS: can only boot from disk, mirror, raidz1, raidz2 and raidz3 vdevs\n");
 545                 return (EIO);
 546         }
 547
 548         is_offline = is_removed = is_faulted = is_degraded = isnt_present = 0;
 549
 550         nvlist_find(nvlist, ZPOOL_CONFIG_OFFLINE, DATA_TYPE_UINT64, 0,
 551                         &is_offline);
 552         nvlist_find(nvlist, ZPOOL_CONFIG_REMOVED, DATA_TYPE_UINT64, 0,
 553                         &is_removed);
 554         nvlist_find(nvlist, ZPOOL_CONFIG_FAULTED, DATA_TYPE_UINT64, 0,
 555                         &is_faulted);
 556         nvlist_find(nvlist, ZPOOL_CONFIG_DEGRADED, DATA_TYPE_UINT64, 0,
 557                         &is_degraded);
 558         nvlist_find(nvlist, ZPOOL_CONFIG_NOT_PRESENT, DATA_TYPE_UINT64, 0,
 559                         &isnt_present);
 560
 561         vdev = vdev_find(guid);
 562         if (!vdev) {
 563                 is_new = 1;
 564
 565                 if (!strcmp(type, VDEV_TYPE_MIRROR))
 566                         vdev = vdev_create(guid, vdev_mirror_read);
 567                 else if (!strcmp(type, VDEV_TYPE_RAIDZ))
 568                         vdev = vdev_create(guid, vdev_raidz_read);
 569                 else if (!strcmp(type, VDEV_TYPE_REPLACING))
 570                         vdev = vdev_create(guid, vdev_replacing_read);
 571                 else
 572                         vdev = vdev_create(guid, vdev_disk_read);
 573
 574                 vdev->v_id = id;
 575                 vdev->v_top = pvdev != NULL ? pvdev : vdev;
 576                 if (nvlist_find(nvlist, ZPOOL_CONFIG_ASHIFT,
 577                         DATA_TYPE_UINT64, 0, &ashift) == 0)
 578                         vdev->v_ashift = ashift;
 579                 else
 580                         vdev->v_ashift = 0;
 581                 if (nvlist_find(nvlist, ZPOOL_CONFIG_NPARITY,
 582                         DATA_TYPE_UINT64, 0, &nparity) == 0)
 583                         vdev->v_nparity = nparity;
 584                 else
 585                         vdev->v_nparity = 0;
 586                 if (nvlist_find(nvlist, ZPOOL_CONFIG_PATH,
 587                                 DATA_TYPE_STRING, 0, &path) == 0) {
 588                         if (strncmp(path, "/dev/", 5) == 0)
 589                                 path += 5;
 590                         vdev->v_name = strdup(path);
 591                 } else {
 592                         if (!strcmp(type, "raidz")) {
 593                                 if (vdev->v_nparity == 1)
 594                                         vdev->v_name = "raidz1";
 595                                 else if (vdev->v_nparity == 2)
 596                                         vdev->v_name = "raidz2";
 597                                 else if (vdev->v_nparity == 3)
 598                                         vdev->v_name = "raidz3";
 599                                 else {
 600                                         printf("ZFS: can only boot from disk, mirror, raidz1, raidz2 and raidz3 vdevs\n");
 601                                         return (EIO);
 602                                 }
 603                         } else {
 604                                 vdev->v_name = strdup(type);
 605                         }
 606                 }
 607         } else {
 608                 is_new = 0;
 609         }
 610
 611         if (is_new || is_newer) {
 612                 /*
 613                  * This is either new vdev or we've already seen this vdev,
 614                  * but from an older vdev label, so let's refresh its state
 615                  * from the newer label.
 616                  */
 617                 if (is_offline)
 618                         vdev->v_state = VDEV_STATE_OFFLINE;
 619                 else if (is_removed)
 620                         vdev->v_state = VDEV_STATE_REMOVED;
 621                 else if (is_faulted)
 622                         vdev->v_state = VDEV_STATE_FAULTED;
 623                 else if (is_degraded)
 624                         vdev->v_state = VDEV_STATE_DEGRADED;
 625                 else if (isnt_present)
 626                         vdev->v_state = VDEV_STATE_CANT_OPEN;
 627         }
 628
 629         rc = nvlist_find(nvlist, ZPOOL_CONFIG_CHILDREN,
 630                          DATA_TYPE_NVLIST_ARRAY, &nkids, &kids);
 631         /*
 632          * Its ok if we don't have any kids.
 633          */
 634         if (rc == 0) {
 635                 vdev->v_nchildren = nkids;
 636                 for (i = 0; i < nkids; i++) {
 637                         rc = vdev_init_from_nvlist(kids, vdev, &kid, is_newer);
 638                         if (rc)
 639                                 return (rc);
 640                         if (is_new)
 641                                 STAILQ_INSERT_TAIL(&vdev->v_children, kid,
 642                                                    v_childlink);
 643                         kids = nvlist_next(kids);
 644                 }
 645         } else {
 646                 vdev->v_nchildren = 0;
 647         }
 648
 649         if (vdevp)
 650                 *vdevp = vdev;
 651         return (0);
 652 }
 653
 654 static void
 655 vdev_set_state(vdev_t *vdev)
 656 {
 657         vdev_t *kid;
 658         int good_kids;
 659         int bad_kids;
 660
 661         /*
 662          * A mirror or raidz is healthy if all its kids are healthy. A
 663          * mirror is degraded if any of its kids is healthy; a raidz
 664          * is degraded if at most nparity kids are offline.
 665          */
 666         if (STAILQ_FIRST(&vdev->v_children)) {
 667                 good_kids = 0;
 668                 bad_kids = 0;
 669                 STAILQ_FOREACH(kid, &vdev->v_children, v_childlink) {
 670                         if (kid->v_state == VDEV_STATE_HEALTHY)
 671                                 good_kids++;
 672                         else
 673                                 bad_kids++;
 674                 }
 675                 if (bad_kids == 0) {
 676                         vdev->v_state = VDEV_STATE_HEALTHY;
 677                 } else {
 678                         if (vdev->v_read == vdev_mirror_read) {
 679                                 if (good_kids) {
 680                                         vdev->v_state = VDEV_STATE_DEGRADED;
 681                                 } else {
 682                                         vdev->v_state = VDEV_STATE_OFFLINE;
 683                                 }
 684                         } else if (vdev->v_read == vdev_raidz_read) {
 685                                 if (bad_kids > vdev->v_nparity) {
 686                                         vdev->v_state = VDEV_STATE_OFFLINE;
 687                                 } else {
 688                                         vdev->v_state = VDEV_STATE_DEGRADED;
 689                                 }
 690                         }
 691                 }
 692         }
 693 }
 694
 695 static spa_t *
 696 spa_find_by_guid(uint64_t guid)
 697 {
 698         spa_t *spa;
 699
 700         STAILQ_FOREACH(spa, &zfs_pools, spa_link)
 701                 if (spa->spa_guid == guid)
 702                         return (spa);
 703
 704         return (0);
 705 }
 706
 707 static spa_t *
 708 spa_find_by_name(const char *name)
 709 {
 710         spa_t *spa;
 711
 712         STAILQ_FOREACH(spa, &zfs_pools, spa_link)
 713                 if (!strcmp(spa->spa_name, name))
 714                         return (spa);
 715
 716         return (0);
 717 }
 718
 719 #ifdef BOOT2
 720 static spa_t *
 721 spa_get_primary(void)
 722 {
 723
 724         return (STAILQ_FIRST(&zfs_pools));
 725 }
 726
 727 static vdev_t *
 728 spa_get_primary_vdev(const spa_t *spa)
 729 {
 730         vdev_t *vdev;
 731         vdev_t *kid;
 732
 733         if (spa == NULL)
 734                 spa = spa_get_primary();
 735         if (spa == NULL)
 736                 return (NULL);
 737         vdev = STAILQ_FIRST(&spa->spa_vdevs);
 738         if (vdev == NULL)
 739                 return (NULL);
 740         for (kid = STAILQ_FIRST(&vdev->v_children); kid != NULL;
 741              kid = STAILQ_FIRST(&vdev->v_children))
 742                 vdev = kid;
 743         return (vdev);
 744 }
 745 #endif
 746
 747 static spa_t *
 748 spa_create(uint64_t guid)
 749 {
 750         spa_t *spa;
 751
 752         spa = malloc(sizeof(spa_t));
 753         memset(spa, 0, sizeof(spa_t));
 754         STAILQ_INIT(&spa->spa_vdevs);
 755         spa->spa_guid = guid;
 756         STAILQ_INSERT_TAIL(&zfs_pools, spa, spa_link);
 757
 758         return (spa);
 759 }
 760
 761 static const char *
 762 state_name(vdev_state_t state)
 763 {
 764         static const char* names[] = {
 765                 "UNKNOWN",
 766                 "CLOSED",
 767                 "OFFLINE",
 768                 "REMOVED",
 769                 "CANT_OPEN",
 770                 "FAULTED",
 771                 "DEGRADED",
 772                 "ONLINE"
 773         };
 774         return names[state];
 775 }
 776
 777 #ifdef BOOT2
 778
 779 #define pager_printf printf
 780
 781 #else
 782
 783 static void
 784 pager_printf(const char *fmt, ...)
 785 {
 786         char line[80];
 787         va_list args;
 788
 789         va_start(args, fmt);
 790         vsprintf(line, fmt, args);
 791         va_end(args);
 792         pager_output(line);
 793 }
 794
 795 #endif
 796
 797 #define STATUS_FORMAT   "        %s %s\n"
 798
 799 static void
 800 print_state(int indent, const char *name, vdev_state_t state)
 801 {
 802         int i;
 803         char buf[512];
 804
 805         buf[0] = 0;
 806         for (i = 0; i < indent; i++)
 807                 strcat(buf, "  ");
 808         strcat(buf, name);
 809         pager_printf(STATUS_FORMAT, buf, state_name(state));
 810
 811 }
 812
 813 static void
 814 vdev_status(vdev_t *vdev, int indent)
 815 {
 816         vdev_t *kid;
 817         print_state(indent, vdev->v_name, vdev->v_state);
 818
 819         STAILQ_FOREACH(kid, &vdev->v_children, v_childlink) {
 820                 vdev_status(kid, indent + 1);
 821         }
 822 }
 823
 824 static void
 825 spa_status(spa_t *spa)
 826 {
 827         static char bootfs[ZFS_MAXNAMELEN];
 828         uint64_t rootid;
 829         vdev_t *vdev;
 830         int good_kids, bad_kids, degraded_kids;
 831         vdev_state_t state;
 832
 833         pager_printf("  pool: %s\n", spa->spa_name);
 834         if (zfs_get_root(spa, &rootid) == 0 &&
 835             zfs_rlookup(spa, rootid, bootfs) == 0) {
 836                 if (bootfs[0] == '\0')
 837                         pager_printf("bootfs: %s\n", spa->spa_name);
 838                 else
 839                         pager_printf("bootfs: %s/%s\n", spa->spa_name, bootfs);
 840         }
 841         pager_printf("config:\n\n");
 842         pager_printf(STATUS_FORMAT, "NAME", "STATE");
 843
 844         good_kids = 0;
 845         degraded_kids = 0;
 846         bad_kids = 0;
 847         STAILQ_FOREACH(vdev, &spa->spa_vdevs, v_childlink) {
 848                 if (vdev->v_state == VDEV_STATE_HEALTHY)
 849                         good_kids++;
 850                 else if (vdev->v_state == VDEV_STATE_DEGRADED)
 851                         degraded_kids++;
 852                 else
 853                         bad_kids++;
 854         }
 855
 856         state = VDEV_STATE_CLOSED;
 857         if (good_kids > 0 && (degraded_kids + bad_kids) == 0)
 858                 state = VDEV_STATE_HEALTHY;
 859         else if ((good_kids + degraded_kids) > 0)
 860                 state = VDEV_STATE_DEGRADED;
 861
 862         print_state(0, spa->spa_name, state);
 863         STAILQ_FOREACH(vdev, &spa->spa_vdevs, v_childlink) {
 864                 vdev_status(vdev, 1);
 865         }
 866 }
 867
 868 static void
 869 spa_all_status(void)
 870 {
 871         spa_t *spa;
 872         int first = 1;
 873
 874         STAILQ_FOREACH(spa, &zfs_pools, spa_link) {
 875                 if (!first)
 876                         pager_printf("\n");
 877                 first = 0;
 878                 spa_status(spa);
 879         }
 880 }
 881
 882 static int
 883 vdev_probe(vdev_phys_read_t *read, void *read_priv, spa_t **spap)
 884 {
 885         vdev_t vtmp;
 886         vdev_phys_t *vdev_label = (vdev_phys_t *) zap_scratch;
 887         spa_t *spa;
 888         vdev_t *vdev, *top_vdev, *pool_vdev;
 889         off_t off;
 890         blkptr_t bp;
 891         const unsigned char *nvlist;
 892         uint64_t val;
 893         uint64_t guid;
 894         uint64_t pool_txg, pool_guid;
 895         uint64_t is_log;
 896         const char *pool_name;
 897         const unsigned char *vdevs;
 898         const unsigned char *features;
 899         int i, rc, is_newer;
 900         char *upbuf;
 901         const struct uberblock *up;
 902
 903         /*
 904          * Load the vdev label and figure out which
 905          * uberblock is most current.
 906          */
 907         memset(&vtmp, 0, sizeof(vtmp));
 908         vtmp.v_phys_read = read;
 909         vtmp.v_read_priv = read_priv;
 910         off = offsetof(vdev_label_t, vl_vdev_phys);
 911         BP_ZERO(&bp);
 912         BP_SET_LSIZE(&bp, sizeof(vdev_phys_t));
 913         BP_SET_PSIZE(&bp, sizeof(vdev_phys_t));
 914         BP_SET_CHECKSUM(&bp, ZIO_CHECKSUM_LABEL);
 915         BP_SET_COMPRESS(&bp, ZIO_COMPRESS_OFF);
 916         DVA_SET_OFFSET(BP_IDENTITY(&bp), off);
 917         ZIO_SET_CHECKSUM(&bp.blk_cksum, off, 0, 0, 0);
 918         if (vdev_read_phys(&vtmp, &bp, vdev_label, off, 0))
 919                 return (EIO);
 920
 921         if (vdev_label->vp_nvlist[0] != NV_ENCODE_XDR) {
 922                 return (EIO);
 923         }
 924
 925         nvlist = (const unsigned char *) vdev_label->vp_nvlist + 4;
 926
 927         if (nvlist_find(nvlist,
 928                         ZPOOL_CONFIG_VERSION,
 929                         DATA_TYPE_UINT64, 0, &val)) {
 930                 return (EIO);
 931         }
 932
 933         if (!SPA_VERSION_IS_SUPPORTED(val)) {
 934                 printf("ZFS: unsupported ZFS version %u (should be %u)\n",
 935                     (unsigned) val, (unsigned) SPA_VERSION);
 936                 return (EIO);
 937         }
 938
 939         /* Check ZFS features for read */
 940         if (nvlist_find(nvlist,
 941                         ZPOOL_CONFIG_FEATURES_FOR_READ,
 942                         DATA_TYPE_NVLIST, 0, &features) == 0
 943             && nvlist_check_features_for_read(features) != 0)
 944                 return (EIO);
 945
 946         if (nvlist_find(nvlist,
 947                         ZPOOL_CONFIG_POOL_STATE,
 948                         DATA_TYPE_UINT64, 0, &val)) {
 949                 return (EIO);
 950         }
 951
 952         if (val == POOL_STATE_DESTROYED) {
 953                 /* We don't boot only from destroyed pools. */
 954                 return (EIO);
 955         }
 956
 957         if (nvlist_find(nvlist,
 958                         ZPOOL_CONFIG_POOL_TXG,
 959                         DATA_TYPE_UINT64, 0, &pool_txg)
 960             || nvlist_find(nvlist,
 961                            ZPOOL_CONFIG_POOL_GUID,
 962                            DATA_TYPE_UINT64, 0, &pool_guid)
 963             || nvlist_find(nvlist,
 964                            ZPOOL_CONFIG_POOL_NAME,
 965                            DATA_TYPE_STRING, 0, &pool_name)) {
 966                 /*
 967                  * Cache and spare devices end up here - just ignore
 968                  * them.
 969                  */
 970                 /*printf("ZFS: can't find pool details\n");*/
 971                 return (EIO);
 972         }
 973
 974         is_log = 0;
 975         (void) nvlist_find(nvlist, ZPOOL_CONFIG_IS_LOG, DATA_TYPE_UINT64, 0,
 976             &is_log);
 977         if (is_log)
 978                 return (EIO);
 979
 980         /*
 981          * Create the pool if this is the first time we've seen it.
 982          */
 983         spa = spa_find_by_guid(pool_guid);
 984         if (!spa) {
 985                 spa = spa_create(pool_guid);
 986                 spa->spa_name = strdup(pool_name);
 987         }
 988         if (pool_txg > spa->spa_txg) {
 989                 spa->spa_txg = pool_txg;
 990                 is_newer = 1;
 991         } else
 992                 is_newer = 0;
 993
 994         /*
 995          * Get the vdev tree and create our in-core copy of it.
 996          * If we already have a vdev with this guid, this must
 997          * be some kind of alias (overlapping slices, dangerously dedicated
 998          * disks etc).
 999          */
1000         if (nvlist_find(nvlist,
1001                         ZPOOL_CONFIG_GUID,
1002                         DATA_TYPE_UINT64, 0, &guid)) {
1003                 return (EIO);
1004         }
1005         vdev = vdev_find(guid);
1006         if (vdev && vdev->v_phys_read)  /* Has this vdev already been inited? */
1007                 return (EIO);
1008
1009         if (nvlist_find(nvlist,
1010                         ZPOOL_CONFIG_VDEV_TREE,
1011                         DATA_TYPE_NVLIST, 0, &vdevs)) {
1012                 return (EIO);
1013         }
1014
1015         rc = vdev_init_from_nvlist(vdevs, NULL, &top_vdev, is_newer);
1016         if (rc)
1017                 return (rc);
1018
1019         /*
1020          * Add the toplevel vdev to the pool if its not already there.
1021          */
1022         STAILQ_FOREACH(pool_vdev, &spa->spa_vdevs, v_childlink)
1023                 if (top_vdev == pool_vdev)
1024                         break;
1025         if (!pool_vdev && top_vdev)
1026                 STAILQ_INSERT_TAIL(&spa->spa_vdevs, top_vdev, v_childlink);
1027
1028         /*
1029          * We should already have created an incomplete vdev for this
1030          * vdev. Find it and initialise it with our read proc.
1031          */
1032         vdev = vdev_find(guid);
1033         if (vdev) {
1034                 vdev->v_phys_read = read;
1035                 vdev->v_read_priv = read_priv;
1036                 vdev->v_state = VDEV_STATE_HEALTHY;
1037         } else {
1038                 printf("ZFS: inconsistent nvlist contents\n");
1039                 return (EIO);
1040         }
1041
1042         /*
1043          * Re-evaluate top-level vdev state.
1044          */
1045         vdev_set_state(top_vdev);
1046
1047         /*
1048          * Ok, we are happy with the pool so far. Lets find
1049          * the best uberblock and then we can actually access
1050          * the contents of the pool.
1051          */
1052         upbuf = zfs_alloc(VDEV_UBERBLOCK_SIZE(vdev));
1053         up = (const struct uberblock *)upbuf;
1054         for (i = 0;
1055              i < VDEV_UBERBLOCK_COUNT(vdev);
1056              i++) {
1057                 off = VDEV_UBERBLOCK_OFFSET(vdev, i);
1058                 BP_ZERO(&bp);
1059                 DVA_SET_OFFSET(&bp.blk_dva[0], off);
1060                 BP_SET_LSIZE(&bp, VDEV_UBERBLOCK_SIZE(vdev));
1061                 BP_SET_PSIZE(&bp, VDEV_UBERBLOCK_SIZE(vdev));
1062                 BP_SET_CHECKSUM(&bp, ZIO_CHECKSUM_LABEL);
1063                 BP_SET_COMPRESS(&bp, ZIO_COMPRESS_OFF);
1064                 ZIO_SET_CHECKSUM(&bp.blk_cksum, off, 0, 0, 0);
1065
1066                 if (vdev_read_phys(vdev, &bp, upbuf, off, 0))
1067                         continue;
1068
1069                 if (up->ub_magic != UBERBLOCK_MAGIC)
1070                         continue;
1071                 if (up->ub_txg < spa->spa_txg)
1072                         continue;
1073                 if (up->ub_txg > spa->spa_uberblock.ub_txg) {
1074                         spa->spa_uberblock = *up;
1075                 } else if (up->ub_txg == spa->spa_uberblock.ub_txg) {
1076                         if (up->ub_timestamp > spa->spa_uberblock.ub_timestamp)
1077                                 spa->spa_uberblock = *up;
1078                 }
1079         }
1080         zfs_free(upbuf, VDEV_UBERBLOCK_SIZE(vdev));
1081
1082         vdev->spa = spa;
1083         if (spap)
1084                 *spap = spa;
1085         return (0);
1086 }
1087
1088 static int
1089 ilog2(int n)
1090 {
1091         int v;
1092
1093         for (v = 0; v < 32; v++)
1094                 if (n == (1 << v))
1095                         return v;
1096         return -1;
1097 }
1098
1099 static int
1100 zio_read_gang(const spa_t *spa, const blkptr_t *bp, void *buf)
1101 {
1102         blkptr_t gbh_bp;
1103         zio_gbh_phys_t zio_gb;
1104         char *pbuf;
1105         int i;
1106
1107         /* Artificial BP for gang block header. */
1108         gbh_bp = *bp;
1109         BP_SET_PSIZE(&gbh_bp, SPA_GANGBLOCKSIZE);
1110         BP_SET_LSIZE(&gbh_bp, SPA_GANGBLOCKSIZE);
1111         BP_SET_CHECKSUM(&gbh_bp, ZIO_CHECKSUM_GANG_HEADER);
1112         BP_SET_COMPRESS(&gbh_bp, ZIO_COMPRESS_OFF);
1113         for (i = 0; i < SPA_DVAS_PER_BP; i++)
1114                 DVA_SET_GANG(&gbh_bp.blk_dva[i], 0);
1115
1116         /* Read gang header block using the artificial BP. */
1117         if (zio_read(spa, &gbh_bp, &zio_gb))
1118                 return (EIO);
1119
1120         pbuf = buf;
1121         for (i = 0; i < SPA_GBH_NBLKPTRS; i++) {
1122                 blkptr_t *gbp = &zio_gb.zg_blkptr[i];
1123
1124                 if (BP_IS_HOLE(gbp))
1125                         continue;
1126                 if (zio_read(spa, gbp, pbuf))
1127                         return (EIO);
1128                 pbuf += BP_GET_PSIZE(gbp);
1129         }
1130
1131         if (zio_checksum_verify(spa, bp, buf))
1132                 return (EIO);
1133         return (0);
1134 }
1135
1136 static int
1137 zio_read(const spa_t *spa, const blkptr_t *bp, void *buf)
1138 {
1139         int cpfunc = BP_GET_COMPRESS(bp);
1140         uint64_t align, size;
1141         void *pbuf;
1142         int i, error;
1143
1144         /*
1145          * Process data embedded in block pointer
1146          */
1147         if (BP_IS_EMBEDDED(bp)) {
1148                 ASSERT(BPE_GET_ETYPE(bp) == BP_EMBEDDED_TYPE_DATA);
1149
1150                 size = BPE_GET_PSIZE(bp);
1151                 ASSERT(size <= BPE_PAYLOAD_SIZE);
1152
1153                 if (cpfunc != ZIO_COMPRESS_OFF)
1154                         pbuf = zfs_alloc(size);
1155                 else
1156                         pbuf = buf;
1157
1158                 decode_embedded_bp_compressed(bp, pbuf);
1159                 error = 0;
1160
1161                 if (cpfunc != ZIO_COMPRESS_OFF) {
1162                         error = zio_decompress_data(cpfunc, pbuf,
1163                             size, buf, BP_GET_LSIZE(bp));
1164                         zfs_free(pbuf, size);
1165                 }
1166                 if (error != 0)
1167                         printf("ZFS: i/o error - unable to decompress block pointer data, error %d\n",
1168                             error);
1169                 return (error);
1170         }
1171
1172         error = EIO;
1173
1174         for (i = 0; i < SPA_DVAS_PER_BP; i++) {
1175                 const dva_t *dva = &bp->blk_dva[i];
1176                 vdev_t *vdev;
1177                 int vdevid;
1178                 off_t offset;
1179
1180                 if (!dva->dva_word[0] && !dva->dva_word[1])
1181                         continue;
1182
1183                 vdevid = DVA_GET_VDEV(dva);
1184                 offset = DVA_GET_OFFSET(dva);
1185                 STAILQ_FOREACH(vdev, &spa->spa_vdevs, v_childlink) {
1186                         if (vdev->v_id == vdevid)
1187                                 break;
1188                 }
1189                 if (!vdev || !vdev->v_read)
1190                         continue;
1191
1192                 size = BP_GET_PSIZE(bp);
1193                 if (vdev->v_read == vdev_raidz_read) {
1194                         align = 1ULL << vdev->v_top->v_ashift;
1195                         if (P2PHASE(size, align) != 0)
1196                                 size = P2ROUNDUP(size, align);
1197                 }
1198                 if (size != BP_GET_PSIZE(bp) || cpfunc != ZIO_COMPRESS_OFF)
1199                         pbuf = zfs_alloc(size);
1200                 else
1201                         pbuf = buf;
1202
1203                 if (DVA_GET_GANG(dva))
1204                         error = zio_read_gang(spa, bp, pbuf);
1205                 else
1206                         error = vdev->v_read(vdev, bp, pbuf, offset, size);
1207                 if (error == 0) {
1208                         if (cpfunc != ZIO_COMPRESS_OFF)
1209                                 error = zio_decompress_data(cpfunc, pbuf,
1210                                     BP_GET_PSIZE(bp), buf, BP_GET_LSIZE(bp));
1211                         else if (size != BP_GET_PSIZE(bp))
1212                                 bcopy(pbuf, buf, BP_GET_PSIZE(bp));
1213                 }
1214                 if (buf != pbuf)
1215                         zfs_free(pbuf, size);
1216                 if (error == 0)
1217                         break;
1218         }
1219         if (error != 0)
1220                 printf("ZFS: i/o error - all block copies unavailable\n");
1221         return (error);
1222 }
1223
1224 static int
1225 dnode_read(const spa_t *spa, const dnode_phys_t *dnode, off_t offset, void *buf, size_t buflen)
1226 {
1227         int ibshift = dnode->dn_indblkshift - SPA_BLKPTRSHIFT;
1228         int bsize = dnode->dn_datablkszsec << SPA_MINBLOCKSHIFT;
1229         int nlevels = dnode->dn_nlevels;
1230         int i, rc;
1231
1232         if (bsize > SPA_MAXBLOCKSIZE) {
1233                 printf("ZFS: I/O error - blocks larger than %llu are not "
1234                     "supported\n", SPA_MAXBLOCKSIZE);
1235                 return (EIO);
1236         }
1237
1238         /*
1239          * Note: bsize may not be a power of two here so we need to do an
1240          * actual divide rather than a bitshift.
1241          */
1242         while (buflen > 0) {
1243                 uint64_t bn = offset / bsize;
1244                 int boff = offset % bsize;
1245                 int ibn;
1246                 const blkptr_t *indbp;
1247                 blkptr_t bp;
1248
1249                 if (bn > dnode->dn_maxblkid)
1250                         return (EIO);
1251
1252                 if (dnode == dnode_cache_obj && bn == dnode_cache_bn)
1253                         goto cached;
1254
1255                 indbp = dnode->dn_blkptr;
1256                 for (i = 0; i < nlevels; i++) {
1257                         /*
1258                          * Copy the bp from the indirect array so that
1259                          * we can re-use the scratch buffer for multi-level
1260                          * objects.
1261                          */
1262                         ibn = bn >> ((nlevels - i - 1) * ibshift);
1263                         ibn &= ((1 << ibshift) - 1);
1264                         bp = indbp[ibn];
1265                         if (BP_IS_HOLE(&bp)) {
1266                                 memset(dnode_cache_buf, 0, bsize);
1267                                 break;
1268                         }
1269                         rc = zio_read(spa, &bp, dnode_cache_buf);
1270                         if (rc)
1271                                 return (rc);
1272                         indbp = (const blkptr_t *) dnode_cache_buf;
1273                 }
1274                 dnode_cache_obj = dnode;
1275                 dnode_cache_bn = bn;
1276         cached:
1277
1278                 /*
1279                  * The buffer contains our data block. Copy what we
1280                  * need from it and loop.
1281                  */
1282                 i = bsize - boff;
1283                 if (i > buflen) i = buflen;
1284                 memcpy(buf, &dnode_cache_buf[boff], i);
1285                 buf = ((char*) buf) + i;
1286                 offset += i;
1287                 buflen -= i;
1288         }
1289
1290         return (0);
1291 }
1292
1293 /*
1294  * Lookup a value in a microzap directory. Assumes that the zap
1295  * scratch buffer contains the directory contents.
1296  */
1297 static int
1298 mzap_lookup(const dnode_phys_t *dnode, const char *name, uint64_t *value)
1299 {
1300         const mzap_phys_t *mz;
1301         const mzap_ent_phys_t *mze;
1302         size_t size;
1303         int chunks, i;
1304
1305         /*
1306          * Microzap objects use exactly one block. Read the whole
1307          * thing.
1308          */
1309         size = dnode->dn_datablkszsec * 512;
1310
1311         mz = (const mzap_phys_t *) zap_scratch;
1312         chunks = size / MZAP_ENT_LEN - 1;
1313
1314         for (i = 0; i < chunks; i++) {
1315                 mze = &mz->mz_chunk[i];
1316                 if (!strcmp(mze->mze_name, name)) {
1317                         *value = mze->mze_value;
1318                         return (0);
1319                 }
1320         }
1321
1322         return (ENOENT);
1323 }
1324
1325 /*
1326  * Compare a name with a zap leaf entry. Return non-zero if the name
1327  * matches.
1328  */
1329 static int
1330 fzap_name_equal(const zap_leaf_t *zl, const zap_leaf_chunk_t *zc, const char *name)
1331 {
1332         size_t namelen;
1333         const zap_leaf_chunk_t *nc;
1334         const char *p;
1335
1336         namelen = zc->l_entry.le_name_numints;
1337
1338         nc = &ZAP_LEAF_CHUNK(zl, zc->l_entry.le_name_chunk);
1339         p = name;
1340         while (namelen > 0) {
1341                 size_t len;
1342                 len = namelen;
1343                 if (len > ZAP_LEAF_ARRAY_BYTES)
1344                         len = ZAP_LEAF_ARRAY_BYTES;
1345                 if (memcmp(p, nc->l_array.la_array, len))
1346                         return (0);
1347                 p += len;
1348                 namelen -= len;
1349                 nc = &ZAP_LEAF_CHUNK(zl, nc->l_array.la_next);
1350         }
1351
1352         return 1;
1353 }
1354
1355 /*
1356  * Extract a uint64_t value from a zap leaf entry.
1357  */
1358 static uint64_t
1359 fzap_leaf_value(const zap_leaf_t *zl, const zap_leaf_chunk_t *zc)
1360 {
1361         const zap_leaf_chunk_t *vc;
1362         int i;
1363         uint64_t value;
1364         const uint8_t *p;
1365
1366         vc = &ZAP_LEAF_CHUNK(zl, zc->l_entry.le_value_chunk);
1367         for (i = 0, value = 0, p = vc->l_array.la_array; i < 8; i++) {
1368                 value = (value << 8) | p[i];
1369         }
1370
1371         return value;
1372 }
1373
1374 static void
1375 stv(int len, void *addr, uint64_t value)
1376 {
1377         switch (len) {
1378         case 1:
1379                 *(uint8_t *)addr = value;
1380                 return;
1381         case 2:
1382                 *(uint16_t *)addr = value;
1383                 return;
1384         case 4:
1385                 *(uint32_t *)addr = value;
1386                 return;
1387         case 8:
1388                 *(uint64_t *)addr = value;
1389                 return;
1390         }
1391 }
1392
1393 /*
1394  * Extract a array from a zap leaf entry.
1395  */
1396 static void
1397 fzap_leaf_array(const zap_leaf_t *zl, const zap_leaf_chunk_t *zc,
1398     uint64_t integer_size, uint64_t num_integers, void *buf)
1399 {
1400         uint64_t array_int_len = zc->l_entry.le_value_intlen;
1401         uint64_t value = 0;
1402         uint64_t *u64 = buf;
1403         char *p = buf;
1404         int len = MIN(zc->l_entry.le_value_numints, num_integers);
1405         int chunk = zc->l_entry.le_value_chunk;
1406         int byten = 0;
1407
1408         if (integer_size == 8 && len == 1) {
1409                 *u64 = fzap_leaf_value(zl, zc);
1410                 return;
1411         }
1412
1413         while (len > 0) {
1414                 struct zap_leaf_array *la = &ZAP_LEAF_CHUNK(zl, chunk).l_array;
1415                 int i;
1416
1417                 ASSERT3U(chunk, <, ZAP_LEAF_NUMCHUNKS(zl));
1418                 for (i = 0; i < ZAP_LEAF_ARRAY_BYTES && len > 0; i++) {
1419                         value = (value << 8) | la->la_array[i];
1420                         byten++;
1421                         if (byten == array_int_len) {
1422                                 stv(integer_size, p, value);
1423                                 byten = 0;
1424                                 len--;
1425                                 if (len == 0)
1426                                         return;
1427                                 p += integer_size;
1428                         }
1429                 }
1430                 chunk = la->la_next;
1431         }
1432 }
1433
1434 /*
1435  * Lookup a value in a fatzap directory. Assumes that the zap scratch
1436  * buffer contains the directory header.
1437  */
1438 static int
1439 fzap_lookup(const spa_t *spa, const dnode_phys_t *dnode, const char *name,
1440     uint64_t integer_size, uint64_t num_integers, void *value)
1441 {
1442         int bsize = dnode->dn_datablkszsec << SPA_MINBLOCKSHIFT;
1443         zap_phys_t zh = *(zap_phys_t *) zap_scratch;
1444         fat_zap_t z;
1445         uint64_t *ptrtbl;
1446         uint64_t hash;
1447         int rc;
1448
1449         if (zh.zap_magic != ZAP_MAGIC)
1450                 return (EIO);
1451
1452         z.zap_block_shift = ilog2(bsize);
1453         z.zap_phys = (zap_phys_t *) zap_scratch;
1454
1455         /*
1456          * Figure out where the pointer table is and read it in if necessary.
1457          */
1458         if (zh.zap_ptrtbl.zt_blk) {
1459                 rc = dnode_read(spa, dnode, zh.zap_ptrtbl.zt_blk * bsize,
1460                                zap_scratch, bsize);
1461                 if (rc)
1462                         return (rc);
1463                 ptrtbl = (uint64_t *) zap_scratch;
1464         } else {
1465                 ptrtbl = &ZAP_EMBEDDED_PTRTBL_ENT(&z, 0);
1466         }
1467
1468         hash = zap_hash(zh.zap_salt, name);
1469
1470         zap_leaf_t zl;
1471         zl.l_bs = z.zap_block_shift;
1472
1473         off_t off = ptrtbl[hash >> (64 - zh.zap_ptrtbl.zt_shift)] << zl.l_bs;
1474         zap_leaf_chunk_t *zc;
1475
1476         rc = dnode_read(spa, dnode, off, zap_scratch, bsize);
1477         if (rc)
1478                 return (rc);
1479
1480         zl.l_phys = (zap_leaf_phys_t *) zap_scratch;
1481
1482         /*
1483          * Make sure this chunk matches our hash.
1484          */
1485         if (zl.l_phys->l_hdr.lh_prefix_len > 0
1486             && zl.l_phys->l_hdr.lh_prefix
1487             != hash >> (64 - zl.l_phys->l_hdr.lh_prefix_len))
1488                 return (ENOENT);
1489
1490         /*
1491          * Hash within the chunk to find our entry.
1492          */
1493         int shift = (64 - ZAP_LEAF_HASH_SHIFT(&zl) - zl.l_phys->l_hdr.lh_prefix_len);
1494         int h = (hash >> shift) & ((1 << ZAP_LEAF_HASH_SHIFT(&zl)) - 1);
1495         h = zl.l_phys->l_hash[h];
1496         if (h == 0xffff)
1497                 return (ENOENT);
1498         zc = &ZAP_LEAF_CHUNK(&zl, h);
1499         while (zc->l_entry.le_hash != hash) {
1500                 if (zc->l_entry.le_next == 0xffff) {
1501                         zc = 0;
1502                         break;
1503                 }
1504                 zc = &ZAP_LEAF_CHUNK(&zl, zc->l_entry.le_next);
1505         }
1506         if (fzap_name_equal(&zl, zc, name)) {
1507                 if (zc->l_entry.le_value_intlen * zc->l_entry.le_value_numints >
1508                     integer_size * num_integers)
1509                         return (E2BIG);
1510                 fzap_leaf_array(&zl, zc, integer_size, num_integers, value);
1511                 return (0);
1512         }
1513
1514         return (ENOENT);
1515 }
1516
1517 /*
1518  * Lookup a name in a zap object and return its value as a uint64_t.
1519  */
1520 static int
1521 zap_lookup(const spa_t *spa, const dnode_phys_t *dnode, const char *name,
1522     uint64_t integer_size, uint64_t num_integers, void *value)
1523 {
1524         int rc;
1525         uint64_t zap_type;
1526         size_t size = dnode->dn_datablkszsec << SPA_MINBLOCKSHIFT;
1527
1528         rc = dnode_read(spa, dnode, 0, zap_scratch, size);
1529         if (rc)
1530                 return (rc);
1531
1532         zap_type = *(uint64_t *) zap_scratch;
1533         if (zap_type == ZBT_MICRO)
1534                 return mzap_lookup(dnode, name, value);
1535         else if (zap_type == ZBT_HEADER) {
1536                 return fzap_lookup(spa, dnode, name, integer_size,
1537                     num_integers, value);
1538         }
1539         printf("ZFS: invalid zap_type=%d\n", (int)zap_type);
1540         return (EIO);
1541 }
1542
1543 /*
1544  * List a microzap directory. Assumes that the zap scratch buffer contains
1545  * the directory contents.
1546  */
1547 static int
1548 mzap_list(const dnode_phys_t *dnode, int (*callback)(const char *, uint64_t))
1549 {
1550         const mzap_phys_t *mz;
1551         const mzap_ent_phys_t *mze;
1552         size_t size;
1553         int chunks, i, rc;
1554
1555         /*
1556          * Microzap objects use exactly one block. Read the whole
1557          * thing.
1558          */
1559         size = dnode->dn_datablkszsec * 512;
1560         mz = (const mzap_phys_t *) zap_scratch;
1561         chunks = size / MZAP_ENT_LEN - 1;
1562
1563         for (i = 0; i < chunks; i++) {
1564                 mze = &mz->mz_chunk[i];
1565                 if (mze->mze_name[0]) {
1566                         rc = callback(mze->mze_name, mze->mze_value);
1567                         if (rc != 0)
1568                                 return (rc);
1569                 }
1570         }
1571
1572         return (0);
1573 }
1574
1575 /*
1576  * List a fatzap directory. Assumes that the zap scratch buffer contains
1577  * the directory header.
1578  */
1579 static int
1580 fzap_list(const spa_t *spa, const dnode_phys_t *dnode, int (*callback)(const char *, uint64_t))
1581 {
1582         int bsize = dnode->dn_datablkszsec << SPA_MINBLOCKSHIFT;
1583         zap_phys_t zh = *(zap_phys_t *) zap_scratch;
1584         fat_zap_t z;
1585         int i, j, rc;
1586
1587         if (zh.zap_magic != ZAP_MAGIC)
1588                 return (EIO);
1589
1590         z.zap_block_shift = ilog2(bsize);
1591         z.zap_phys = (zap_phys_t *) zap_scratch;
1592
1593         /*
1594          * This assumes that the leaf blocks start at block 1. The
1595          * documentation isn't exactly clear on this.
1596          */
1597         zap_leaf_t zl;
1598         zl.l_bs = z.zap_block_shift;
1599         for (i = 0; i < zh.zap_num_leafs; i++) {
1600                 off_t off = (i + 1) << zl.l_bs;
1601                 char name[256], *p;
1602                 uint64_t value;
1603
1604                 if (dnode_read(spa, dnode, off, zap_scratch, bsize))
1605                         return (EIO);
1606
1607                 zl.l_phys = (zap_leaf_phys_t *) zap_scratch;
1608
1609                 for (j = 0; j < ZAP_LEAF_NUMCHUNKS(&zl); j++) {
1610                         zap_leaf_chunk_t *zc, *nc;
1611                         int namelen;
1612
1613                         zc = &ZAP_LEAF_CHUNK(&zl, j);
1614                         if (zc->l_entry.le_type != ZAP_CHUNK_ENTRY)
1615                                 continue;
1616                         namelen = zc->l_entry.le_name_numints;
1617                         if (namelen > sizeof(name))
1618                                 namelen = sizeof(name);
1619
1620                         /*
1621                          * Paste the name back together.
1622                          */
1623                         nc = &ZAP_LEAF_CHUNK(&zl, zc->l_entry.le_name_chunk);
1624                         p = name;
1625                         while (namelen > 0) {
1626                                 int len;
1627                                 len = namelen;
1628                                 if (len > ZAP_LEAF_ARRAY_BYTES)
1629                                         len = ZAP_LEAF_ARRAY_BYTES;
1630                                 memcpy(p, nc->l_array.la_array, len);
1631                                 p += len;
1632                                 namelen -= len;
1633                                 nc = &ZAP_LEAF_CHUNK(&zl, nc->l_array.la_next);
1634                         }
1635
1636                         /*
1637                          * Assume the first eight bytes of the value are
1638                          * a uint64_t.
1639                          */
1640                         value = fzap_leaf_value(&zl, zc);
1641
1642                         //printf("%s 0x%jx\n", name, (uintmax_t)value);
1643                         rc = callback((const char *)name, value);
1644                         if (rc != 0)
1645                                 return (rc);
1646                 }
1647         }
1648
1649         return (0);
1650 }
1651
1652 static int zfs_printf(const char *name, uint64_t value __unused)
1653 {
1654
1655         printf("%s\n", name);
1656
1657         return (0);
1658 }
1659
1660 /*
1661  * List a zap directory.
1662  */
1663 static int
1664 zap_list(const spa_t *spa, const dnode_phys_t *dnode)
1665 {
1666         uint64_t zap_type;
1667         size_t size = dnode->dn_datablkszsec * 512;
1668
1669         if (dnode_read(spa, dnode, 0, zap_scratch, size))
1670                 return (EIO);
1671
1672         zap_type = *(uint64_t *) zap_scratch;
1673         if (zap_type == ZBT_MICRO)
1674                 return mzap_list(dnode, zfs_printf);
1675         else
1676                 return fzap_list(spa, dnode, zfs_printf);
1677 }
1678
1679 static int
1680 objset_get_dnode(const spa_t *spa, const objset_phys_t *os, uint64_t objnum, dnode_phys_t *dnode)
1681 {
1682         off_t offset;
1683
1684         offset = objnum * sizeof(dnode_phys_t);
1685         return dnode_read(spa, &os->os_meta_dnode, offset,
1686                 dnode, sizeof(dnode_phys_t));
1687 }
1688
1689 static int
1690 mzap_rlookup(const spa_t *spa, const dnode_phys_t *dnode, char *name, uint64_t value)
1691 {
1692         const mzap_phys_t *mz;
1693         const mzap_ent_phys_t *mze;
1694         size_t size;
1695         int chunks, i;
1696
1697         /*
1698          * Microzap objects use exactly one block. Read the whole
1699          * thing.
1700          */
1701         size = dnode->dn_datablkszsec * 512;
1702
1703         mz = (const mzap_phys_t *) zap_scratch;
1704         chunks = size / MZAP_ENT_LEN - 1;
1705
1706         for (i = 0; i < chunks; i++) {
1707                 mze = &mz->mz_chunk[i];
1708                 if (value == mze->mze_value) {
1709                         strcpy(name, mze->mze_name);
1710                         return (0);
1711                 }
1712         }
1713
1714         return (ENOENT);
1715 }
1716
1717 static void
1718 fzap_name_copy(const zap_leaf_t *zl, const zap_leaf_chunk_t *zc, char *name)
1719 {
1720         size_t namelen;
1721         const zap_leaf_chunk_t *nc;
1722         char *p;
1723
1724         namelen = zc->l_entry.le_name_numints;
1725
1726         nc = &ZAP_LEAF_CHUNK(zl, zc->l_entry.le_name_chunk);
1727         p = name;
1728         while (namelen > 0) {
1729                 size_t len;
1730                 len = namelen;
1731                 if (len > ZAP_LEAF_ARRAY_BYTES)
1732                         len = ZAP_LEAF_ARRAY_BYTES;
1733                 memcpy(p, nc->l_array.la_array, len);
1734                 p += len;
1735                 namelen -= len;
1736                 nc = &ZAP_LEAF_CHUNK(zl, nc->l_array.la_next);
1737         }
1738
1739         *p = '\0';
1740 }
1741
1742 static int
1743 fzap_rlookup(const spa_t *spa, const dnode_phys_t *dnode, char *name, uint64_t value)
1744 {
1745         int bsize = dnode->dn_datablkszsec << SPA_MINBLOCKSHIFT;
1746         zap_phys_t zh = *(zap_phys_t *) zap_scratch;
1747         fat_zap_t z;
1748         int i, j;
1749
1750         if (zh.zap_magic != ZAP_MAGIC)
1751                 return (EIO);
1752
1753         z.zap_block_shift = ilog2(bsize);
1754         z.zap_phys = (zap_phys_t *) zap_scratch;
1755
1756         /*
1757          * This assumes that the leaf blocks start at block 1. The
1758          * documentation isn't exactly clear on this.
1759          */
1760         zap_leaf_t zl;
1761         zl.l_bs = z.zap_block_shift;
1762         for (i = 0; i < zh.zap_num_leafs; i++) {
1763                 off_t off = (i + 1) << zl.l_bs;
1764
1765                 if (dnode_read(spa, dnode, off, zap_scratch, bsize))
1766                         return (EIO);
1767
1768                 zl.l_phys = (zap_leaf_phys_t *) zap_scratch;
1769
1770                 for (j = 0; j < ZAP_LEAF_NUMCHUNKS(&zl); j++) {
1771                         zap_leaf_chunk_t *zc;
1772
1773                         zc = &ZAP_LEAF_CHUNK(&zl, j);
1774                         if (zc->l_entry.le_type != ZAP_CHUNK_ENTRY)
1775                                 continue;
1776                         if (zc->l_entry.le_value_intlen != 8 ||
1777                             zc->l_entry.le_value_numints != 1)
1778                                 continue;
1779
1780                         if (fzap_leaf_value(&zl, zc) == value) {
1781                                 fzap_name_copy(&zl, zc, name);
1782                                 return (0);
1783                         }
1784                 }
1785         }
1786
1787         return (ENOENT);
1788 }
1789
1790 static int
1791 zap_rlookup(const spa_t *spa, const dnode_phys_t *dnode, char *name, uint64_t value)
1792 {
1793         int rc;
1794         uint64_t zap_type;
1795         size_t size = dnode->dn_datablkszsec * 512;
1796
1797         rc = dnode_read(spa, dnode, 0, zap_scratch, size);
1798         if (rc)
1799                 return (rc);
1800
1801         zap_type = *(uint64_t *) zap_scratch;
1802         if (zap_type == ZBT_MICRO)
1803                 return mzap_rlookup(spa, dnode, name, value);
1804         else
1805                 return fzap_rlookup(spa, dnode, name, value);
1806 }
1807
1808 static int
1809 zfs_rlookup(const spa_t *spa, uint64_t objnum, char *result)
1810 {
1811         char name[256];
1812         char component[256];
1813         uint64_t dir_obj, parent_obj, child_dir_zapobj;
1814         dnode_phys_t child_dir_zap, dataset, dir, parent;
1815         dsl_dir_phys_t *dd;
1816         dsl_dataset_phys_t *ds;
1817         char *p;
1818         int len;
1819
1820         p = &name[sizeof(name) - 1];
1821         *p = '\0';
1822
1823         if (objset_get_dnode(spa, &spa->spa_mos, objnum, &dataset)) {
1824                 printf("ZFS: can't find dataset %ju\n", (uintmax_t)objnum);
1825                 return (EIO);
1826         }
1827         ds = (dsl_dataset_phys_t *)&dataset.dn_bonus;
1828         dir_obj = ds->ds_dir_obj;
1829
1830         for (;;) {
1831                 if (objset_get_dnode(spa, &spa->spa_mos, dir_obj, &dir) != 0)
1832                         return (EIO);
1833                 dd = (dsl_dir_phys_t *)&dir.dn_bonus;
1834
1835                 /* Actual loop condition. */
1836                 parent_obj  = dd->dd_parent_obj;
1837                 if (parent_obj == 0)
1838                         break;
1839
1840                 if (objset_get_dnode(spa, &spa->spa_mos, parent_obj, &parent) != 0)
1841                         return (EIO);
1842                 dd = (dsl_dir_phys_t *)&parent.dn_bonus;
1843                 child_dir_zapobj = dd->dd_child_dir_zapobj;
1844                 if (objset_get_dnode(spa, &spa->spa_mos, child_dir_zapobj, &child_dir_zap) != 0)
1845                         return (EIO);
1846                 if (zap_rlookup(spa, &child_dir_zap, component, dir_obj) != 0)
1847                         return (EIO);
1848
1849                 len = strlen(component);
1850                 p -= len;
1851                 memcpy(p, component, len);
1852                 --p;
1853                 *p = '/';
1854
1855                 /* Actual loop iteration. */
1856                 dir_obj = parent_obj;
1857         }
1858
1859         if (*p != '\0')
1860                 ++p;
1861         strcpy(result, p);
1862
1863         return (0);
1864 }
1865
1866 static int
1867 zfs_lookup_dataset(const spa_t *spa, const char *name, uint64_t *objnum)
1868 {
1869         char element[256];
1870         uint64_t dir_obj, child_dir_zapobj;
1871         dnode_phys_t child_dir_zap, dir;
1872         dsl_dir_phys_t *dd;
1873         const char *p, *q;
1874
1875         if (objset_get_dnode(spa, &spa->spa_mos, DMU_POOL_DIRECTORY_OBJECT, &dir))
1876                 return (EIO);
1877         if (zap_lookup(spa, &dir, DMU_POOL_ROOT_DATASET, sizeof (dir_obj),
1878             1, &dir_obj))
1879                 return (EIO);
1880
1881         p = name;
1882         for (;;) {
1883                 if (objset_get_dnode(spa, &spa->spa_mos, dir_obj, &dir))
1884                         return (EIO);
1885                 dd = (dsl_dir_phys_t *)&dir.dn_bonus;
1886
1887                 while (*p == '/')
1888                         p++;
1889                 /* Actual loop condition #1. */
1890                 if (*p == '\0')
1891                         break;
1892
1893                 q = strchr(p, '/');
1894                 if (q) {
1895                         memcpy(element, p, q - p);
1896                         element[q - p] = '\0';
1897                         p = q + 1;
1898                 } else {
1899                         strcpy(element, p);
1900                         p += strlen(p);
1901                 }
1902
1903                 child_dir_zapobj = dd->dd_child_dir_zapobj;
1904                 if (objset_get_dnode(spa, &spa->spa_mos, child_dir_zapobj, &child_dir_zap) != 0)
1905                         return (EIO);
1906
1907                 /* Actual loop condition #2. */
1908                 if (zap_lookup(spa, &child_dir_zap, element, sizeof (dir_obj),
1909                     1, &dir_obj) != 0)
1910                         return (ENOENT);
1911         }
1912
1913         *objnum = dd->dd_head_dataset_obj;
1914         return (0);
1915 }
1916
1917 #ifndef BOOT2
1918 static int
1919 zfs_list_dataset(const spa_t *spa, uint64_t objnum/*, int pos, char *entry*/)
1920 {
1921         uint64_t dir_obj, child_dir_zapobj;
1922         dnode_phys_t child_dir_zap, dir, dataset;
1923         dsl_dataset_phys_t *ds;
1924         dsl_dir_phys_t *dd;
1925
1926         if (objset_get_dnode(spa, &spa->spa_mos, objnum, &dataset)) {
1927                 printf("ZFS: can't find dataset %ju\n", (uintmax_t)objnum);
1928                 return (EIO);
1929         }
1930         ds = (dsl_dataset_phys_t *) &dataset.dn_bonus;
1931         dir_obj = ds->ds_dir_obj;
1932
1933         if (objset_get_dnode(spa, &spa->spa_mos, dir_obj, &dir)) {
1934                 printf("ZFS: can't find dirobj %ju\n", (uintmax_t)dir_obj);
1935                 return (EIO);
1936         }
1937         dd = (dsl_dir_phys_t *)&dir.dn_bonus;
1938
1939         child_dir_zapobj = dd->dd_child_dir_zapobj;
1940         if (objset_get_dnode(spa, &spa->spa_mos, child_dir_zapobj, &child_dir_zap) != 0) {
1941                 printf("ZFS: can't find child zap %ju\n", (uintmax_t)dir_obj);
1942                 return (EIO);
1943         }
1944
1945         return (zap_list(spa, &child_dir_zap) != 0);
1946 }
1947
1948 int
1949 zfs_callback_dataset(const spa_t *spa, uint64_t objnum, int (*callback)(const char *, uint64_t))
1950 {
1951         uint64_t dir_obj, child_dir_zapobj, zap_type;
1952         dnode_phys_t child_dir_zap, dir, dataset;
1953         dsl_dataset_phys_t *ds;
1954         dsl_dir_phys_t *dd;
1955         int err;
1956
1957         err = objset_get_dnode(spa, &spa->spa_mos, objnum, &dataset);
1958         if (err != 0) {
1959                 printf("ZFS: can't find dataset %ju\n", (uintmax_t)objnum);
1960                 return (err);
1961         }
1962         ds = (dsl_dataset_phys_t *) &dataset.dn_bonus;
1963         dir_obj = ds->ds_dir_obj;
1964
1965         err = objset_get_dnode(spa, &spa->spa_mos, dir_obj, &dir);
1966         if (err != 0) {
1967                 printf("ZFS: can't find dirobj %ju\n", (uintmax_t)dir_obj);
1968                 return (err);
1969         }
1970         dd = (dsl_dir_phys_t *)&dir.dn_bonus;
1971
1972         child_dir_zapobj = dd->dd_child_dir_zapobj;
1973         err = objset_get_dnode(spa, &spa->spa_mos, child_dir_zapobj, &child_dir_zap);
1974         if (err != 0) {
1975                 printf("ZFS: can't find child zap %ju\n", (uintmax_t)dir_obj);
1976                 return (err);
1977         }
1978
1979         err = dnode_read(spa, &child_dir_zap, 0, zap_scratch, child_dir_zap.dn_datablkszsec * 512);
1980         if (err != 0)
1981                 return (err);
1982
1983         zap_type = *(uint64_t *) zap_scratch;
1984         if (zap_type == ZBT_MICRO)
1985                 return mzap_list(&child_dir_zap, callback);
1986         else
1987                 return fzap_list(spa, &child_dir_zap, callback);
1988 }
1989 #endif
1990
1991 /*
1992  * Find the object set given the object number of its dataset object
1993  * and return its details in *objset
1994  */
1995 static int
1996 zfs_mount_dataset(const spa_t *spa, uint64_t objnum, objset_phys_t *objset)
1997 {
1998         dnode_phys_t dataset;
1999         dsl_dataset_phys_t *ds;
2000
2001         if (objset_get_dnode(spa, &spa->spa_mos, objnum, &dataset)) {
2002                 printf("ZFS: can't find dataset %ju\n", (uintmax_t)objnum);
2003                 return (EIO);
2004         }
2005
2006         ds = (dsl_dataset_phys_t *) &dataset.dn_bonus;
2007         if (zio_read(spa, &ds->ds_bp, objset)) {
2008                 printf("ZFS: can't read object set for dataset %ju\n",
2009                     (uintmax_t)objnum);
2010                 return (EIO);
2011         }
2012
2013         return (0);
2014 }
2015
2016 /*
2017  * Find the object set pointed to by the BOOTFS property or the root
2018  * dataset if there is none and return its details in *objset
2019  */
2020 static int
2021 zfs_get_root(const spa_t *spa, uint64_t *objid)
2022 {
2023         dnode_phys_t dir, propdir;
2024         uint64_t props, bootfs, root;
2025
2026         *objid = 0;
2027
2028         /*
2029          * Start with the MOS directory object.
2030          */
2031         if (objset_get_dnode(spa, &spa->spa_mos, DMU_POOL_DIRECTORY_OBJECT, &dir)) {
2032                 printf("ZFS: can't read MOS object directory\n");
2033                 return (EIO);
2034         }
2035
2036         /*
2037          * Lookup the pool_props and see if we can find a bootfs.
2038          */
2039         if (zap_lookup(spa, &dir, DMU_POOL_PROPS, sizeof (props), 1, &props) == 0
2040              && objset_get_dnode(spa, &spa->spa_mos, props, &propdir) == 0
2041              && zap_lookup(spa, &propdir, "bootfs", sizeof (bootfs), 1, &bootfs) == 0
2042              && bootfs != 0)
2043         {
2044                 *objid = bootfs;
2045                 return (0);
2046         }
2047         /*
2048          * Lookup the root dataset directory
2049          */
2050         if (zap_lookup(spa, &dir, DMU_POOL_ROOT_DATASET, sizeof (root), 1, &root)
2051             || objset_get_dnode(spa, &spa->spa_mos, root, &dir)) {
2052                 printf("ZFS: can't find root dsl_dir\n");
2053                 return (EIO);
2054         }
2055
2056         /*
2057          * Use the information from the dataset directory's bonus buffer
2058          * to find the dataset object and from that the object set itself.
2059          */
2060         dsl_dir_phys_t *dd = (dsl_dir_phys_t *) &dir.dn_bonus;
2061         *objid = dd->dd_head_dataset_obj;
2062         return (0);
2063 }
2064
2065 static int
2066 zfs_mount(const spa_t *spa, uint64_t rootobj, struct zfsmount *mount)
2067 {
2068
2069         mount->spa = spa;
2070
2071         /*
2072          * Find the root object set if not explicitly provided
2073          */
2074         if (rootobj == 0 && zfs_get_root(spa, &rootobj)) {
2075                 printf("ZFS: can't find root filesystem\n");
2076                 return (EIO);
2077         }
2078
2079         if (zfs_mount_dataset(spa, rootobj, &mount->objset)) {
2080                 printf("ZFS: can't open root filesystem\n");
2081                 return (EIO);
2082         }
2083
2084         mount->rootobj = rootobj;
2085
2086         return (0);
2087 }
2088
2089 /*
2090  * callback function for feature name checks.
2091  */
2092 static int
2093 check_feature(const char *name, uint64_t value)
2094 {
2095         int i;
2096
2097         if (value == 0)
2098                 return (0);
2099         if (name[0] == '\0')
2100                 return (0);
2101
2102         for (i = 0; features_for_read[i] != NULL; i++) {
2103                 if (strcmp(name, features_for_read[i]) == 0)
2104                         return (0);
2105         }
2106         printf("ZFS: unsupported feature: %s\n", name);
2107         return (EIO);
2108 }
2109
2110 /*
2111  * Checks whether the MOS features that are active are supported.
2112  */
2113 static int
2114 check_mos_features(const spa_t *spa)
2115 {
2116         dnode_phys_t dir;
2117         uint64_t objnum, zap_type;
2118         size_t size;
2119         int rc;
2120
2121         if ((rc = objset_get_dnode(spa, &spa->spa_mos, DMU_OT_OBJECT_DIRECTORY,
2122             &dir)) != 0)
2123                 return (rc);
2124         if ((rc = zap_lookup(spa, &dir, DMU_POOL_FEATURES_FOR_READ,
2125             sizeof (objnum), 1, &objnum)) != 0)
2126                 return (rc);
2127
2128         if ((rc = objset_get_dnode(spa, &spa->spa_mos, objnum, &dir)) != 0)
2129                 return (rc);
2130
2131         if (dir.dn_type != DMU_OTN_ZAP_METADATA)
2132                 return (EIO);
2133
2134         size = dir.dn_datablkszsec * 512;
2135         if (dnode_read(spa, &dir, 0, zap_scratch, size))
2136                 return (EIO);
2137
2138         zap_type = *(uint64_t *) zap_scratch;
2139         if (zap_type == ZBT_MICRO)
2140                 rc = mzap_list(&dir, check_feature);
2141         else
2142                 rc = fzap_list(spa, &dir, check_feature);
2143
2144         return (rc);
2145 }
2146
2147 static int
2148 zfs_spa_init(spa_t *spa)
2149 {
2150         dnode_phys_t dir;
2151         int rc;
2152
2153         if (zio_read(spa, &spa->spa_uberblock.ub_rootbp, &spa->spa_mos)) {
2154                 printf("ZFS: can't read MOS of pool %s\n", spa->spa_name);
2155                 return (EIO);
2156         }
2157         if (spa->spa_mos.os_type != DMU_OST_META) {
2158                 printf("ZFS: corrupted MOS of pool %s\n", spa->spa_name);
2159                 return (EIO);
2160         }
2161
2162         if (objset_get_dnode(spa, &spa->spa_mos, DMU_POOL_DIRECTORY_OBJECT,
2163             &dir)) {
2164                 printf("ZFS: failed to read pool %s directory object\n",
2165                     spa->spa_name);
2166                 return (EIO);
2167         }
2168         /* this is allowed to fail, older pools do not have salt */
2169         rc = zap_lookup(spa, &dir, DMU_POOL_CHECKSUM_SALT, 1,
2170             sizeof (spa->spa_cksum_salt.zcs_bytes),
2171             spa->spa_cksum_salt.zcs_bytes);
2172
2173         rc = check_mos_features(spa);
2174         if (rc != 0) {
2175                 printf("ZFS: pool %s is not supported\n", spa->spa_name);
2176         }
2177
2178         return (rc);
2179 }
2180
2181 static int
2182 zfs_dnode_stat(const spa_t *spa, dnode_phys_t *dn, struct stat *sb)
2183 {
2184
2185         if (dn->dn_bonustype != DMU_OT_SA) {
2186                 znode_phys_t *zp = (znode_phys_t *)dn->dn_bonus;
2187
2188                 sb->st_mode = zp->zp_mode;
2189                 sb->st_uid = zp->zp_uid;
2190                 sb->st_gid = zp->zp_gid;
2191                 sb->st_size = zp->zp_size;
2192         } else {
2193                 sa_hdr_phys_t *sahdrp;
2194                 int hdrsize;
2195                 size_t size = 0;
2196                 void *buf = NULL;
2197
2198                 if (dn->dn_bonuslen != 0)
2199                         sahdrp = (sa_hdr_phys_t *)DN_BONUS(dn);
2200                 else {
2201                         if ((dn->dn_flags & DNODE_FLAG_SPILL_BLKPTR) != 0) {
2202                                 blkptr_t *bp = &dn->dn_spill;
2203                                 int error;
2204
2205                                 size = BP_GET_LSIZE(bp);
2206                                 buf = zfs_alloc(size);
2207                                 error = zio_read(spa, bp, buf);
2208                                 if (error != 0) {
2209                                         zfs_free(buf, size);
2210                                         return (error);
2211                                 }
2212                                 sahdrp = buf;
2213                         } else {
2214                                 return (EIO);
2215                         }
2216                 }
2217                 hdrsize = SA_HDR_SIZE(sahdrp);
2218                 sb->st_mode = *(uint64_t *)((char *)sahdrp + hdrsize +
2219                     SA_MODE_OFFSET);
2220                 sb->st_uid = *(uint64_t *)((char *)sahdrp + hdrsize +
2221                     SA_UID_OFFSET);
2222                 sb->st_gid = *(uint64_t *)((char *)sahdrp + hdrsize +
2223                     SA_GID_OFFSET);
2224                 sb->st_size = *(uint64_t *)((char *)sahdrp + hdrsize +
2225                     SA_SIZE_OFFSET);
2226                 if (buf != NULL)
2227                         zfs_free(buf, size);
2228         }
2229
2230         return (0);
2231 }
2232
2233 /*
2234  * Lookup a file and return its dnode.
2235  */
2236 static int
2237 zfs_lookup(const struct zfsmount *mount, const char *upath, dnode_phys_t *dnode)
2238 {
2239         int rc;
2240         uint64_t objnum, rootnum, parentnum;
2241         const spa_t *spa;
2242         dnode_phys_t dn;
2243         const char *p, *q;
2244         char element[256];
2245         char path[1024];
2246         int symlinks_followed = 0;
2247         struct stat sb;
2248
2249         spa = mount->spa;
2250         if (mount->objset.os_type != DMU_OST_ZFS) {
2251                 printf("ZFS: unexpected object set type %ju\n",
2252                     (uintmax_t)mount->objset.os_type);
2253                 return (EIO);
2254         }
2255
2256         /*
2257          * Get the root directory dnode.
2258          */
2259         rc = objset_get_dnode(spa, &mount->objset, MASTER_NODE_OBJ, &dn);
2260         if (rc)
2261                 return (rc);
2262
2263         rc = zap_lookup(spa, &dn, ZFS_ROOT_OBJ, sizeof (rootnum), 1, &rootnum);
2264         if (rc)
2265                 return (rc);
2266
2267         rc = objset_get_dnode(spa, &mount->objset, rootnum, &dn);
2268         if (rc)
2269                 return (rc);
2270
2271         objnum = rootnum;
2272         p = upath;
2273         while (p && *p) {
2274                 while (*p == '/')
2275                         p++;
2276                 if (!*p)
2277                         break;
2278                 q = strchr(p, '/');
2279                 if (q) {
2280                         memcpy(element, p, q - p);
2281                         element[q - p] = 0;
2282                         p = q;
2283                 } else {
2284                         strcpy(element, p);
2285                         p = 0;
2286                 }
2287
2288                 rc = zfs_dnode_stat(spa, &dn, &sb);
2289                 if (rc)
2290                         return (rc);
2291                 if (!S_ISDIR(sb.st_mode))
2292                         return (ENOTDIR);
2293
2294                 parentnum = objnum;
2295                 rc = zap_lookup(spa, &dn, element, sizeof (objnum), 1, &objnum);
2296                 if (rc)
2297                         return (rc);
2298                 objnum = ZFS_DIRENT_OBJ(objnum);
2299
2300                 rc = objset_get_dnode(spa, &mount->objset, objnum, &dn);
2301                 if (rc)
2302                         return (rc);
2303
2304                 /*
2305                  * Check for symlink.
2306                  */
2307                 rc = zfs_dnode_stat(spa, &dn, &sb);
2308                 if (rc)
2309                         return (rc);
2310                 if (S_ISLNK(sb.st_mode)) {
2311                         if (symlinks_followed > 10)
2312                                 return (EMLINK);
2313                         symlinks_followed++;
2314
2315                         /*
2316                          * Read the link value and copy the tail of our
2317                          * current path onto the end.
2318                          */
2319                         if (p)
2320                                 strcpy(&path[sb.st_size], p);
2321                         else
2322                                 path[sb.st_size] = 0;
2323                         /*
2324                          * Second test is purely to silence bogus compiler
2325                          * warning about accessing past the end of dn_bonus.
2326                          */
2327                         if (sb.st_size + sizeof(znode_phys_t) <=
2328                             dn.dn_bonuslen && sizeof(znode_phys_t) <=
2329                             sizeof(dn.dn_bonus)) {
2330                                 memcpy(path, &dn.dn_bonus[sizeof(znode_phys_t)],
2331                                         sb.st_size);
2332                         } else {
2333                                 rc = dnode_read(spa, &dn, 0, path, sb.st_size);
2334                                 if (rc)
2335                                         return (rc);
2336                         }
2337
2338                         /*
2339                          * Restart with the new path, starting either at
2340                          * the root or at the parent depending whether or
2341                          * not the link is relative.
2342                          */
2343                         p = path;
2344                         if (*p == '/')
2345                                 objnum = rootnum;
2346                         else
2347                                 objnum = parentnum;
2348                         objset_get_dnode(spa, &mount->objset, objnum, &dn);
2349                 }
2350         }
2351
2352         *dnode = dn;
2353         return (0);
2354 }