]> git.ipfire.org Git - people/ms/u-boot.git/blob - fs/zfs/zfs.c
projects / people / ms / u-boot.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Merge remote-tracking branch 'u-boot/master' into u-boot-arm-merged
[people/ms/u-boot.git] / fs / zfs / zfs.c
1 /*
2 *
3 * ZFS filesystem ported to u-boot by
4 * Jorgen Lundman <lundman at lundman.net>
5 *
6 * GRUB -- GRand Unified Bootloader
7 * Copyright (C) 1999,2000,2001,2002,2003,2004
8 * Free Software Foundation, Inc.
9 * Copyright 2004 Sun Microsystems, Inc.
10 *
11 * GRUB is free software; you can redistribute it and/or modify
12 * it under the terms of the GNU General Public License as published by
13 * the Free Software Foundation; either version 2 of the License, or
14 * (at your option) any later version.
15 *
16 * GRUB is distributed in the hope that it will be useful,
17 * but WITHOUT ANY WARRANTY; without even the implied warranty of
18 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19 * GNU General Public License for more details.
20 *
21 * You should have received a copy of the GNU General Public License
22 * along with GRUB. If not, see <http://www.gnu.org/licenses/>.
23 *
24 */
25
26 #include <common.h>
27 #include <malloc.h>
28 #include <linux/stat.h>
29 #include <linux/time.h>
30 #include <linux/ctype.h>
31 #include <asm/byteorder.h>
32 #include "zfs_common.h"
33 #include "div64.h"
34
35 block_dev_desc_t *zfs_dev_desc;
36
37 /*
38 * The zfs plug-in routines for GRUB are:
39 *
40 * zfs_mount() - locates a valid uberblock of the root pool and reads
41 * in its MOS at the memory address MOS.
42 *
43 * zfs_open() - locates a plain file object by following the MOS
44 * and places its dnode at the memory address DNODE.
45 *
46 * zfs_read() - read in the data blocks pointed by the DNODE.
47 *
48 */
49
50 #include <zfs/zfs.h>
51 #include <zfs/zio.h>
52 #include <zfs/dnode.h>
53 #include <zfs/uberblock_impl.h>
54 #include <zfs/vdev_impl.h>
55 #include <zfs/zio_checksum.h>
56 #include <zfs/zap_impl.h>
57 #include <zfs/zap_leaf.h>
58 #include <zfs/zfs_znode.h>
59 #include <zfs/dmu.h>
60 #include <zfs/dmu_objset.h>
61 #include <zfs/sa_impl.h>
62 #include <zfs/dsl_dir.h>
63 #include <zfs/dsl_dataset.h>
64
65
66 #define ZPOOL_PROP_BOOTFS "bootfs"
67
68
69 /*
70 * For nvlist manipulation. (from nvpair.h)
71 */
72 #define NV_ENCODE_NATIVE 0
73 #define NV_ENCODE_XDR 1
74 #define NV_BIG_ENDIAN 0
75 #define NV_LITTLE_ENDIAN 1
76 #define DATA_TYPE_UINT64 8
77 #define DATA_TYPE_STRING 9
78 #define DATA_TYPE_NVLIST 19
79 #define DATA_TYPE_NVLIST_ARRAY 20
80
81
82 /*
83 * Macros to get fields in a bp or DVA.
84 */
85 #define P2PHASE(x, align) ((x) & ((align) - 1))
86 #define DVA_OFFSET_TO_PHYS_SECTOR(offset) \
87 ((offset + VDEV_LABEL_START_SIZE) >> SPA_MINBLOCKSHIFT)
88
89 /*
90 * return x rounded down to an align boundary
91 * eg, P2ALIGN(1200, 1024) == 1024 (1*align)
92 * eg, P2ALIGN(1024, 1024) == 1024 (1*align)
93 * eg, P2ALIGN(0x1234, 0x100) == 0x1200 (0x12*align)
94 * eg, P2ALIGN(0x5600, 0x100) == 0x5600 (0x56*align)
95 */
96 #define P2ALIGN(x, align) ((x) & -(align))
97
98 /*
99 * FAT ZAP data structures
100 */
101 #define ZFS_CRC64_POLY 0xC96C5795D7870F42ULL /* ECMA-182, reflected form */
102 #define ZAP_HASH_IDX(hash, n) (((n) == 0) ? 0 : ((hash) >> (64 - (n))))
103 #define CHAIN_END 0xffff /* end of the chunk chain */
104
105 /*
106 * The amount of space within the chunk available for the array is:
107 * chunk size - space for type (1) - space for next pointer (2)
108 */
109 #define ZAP_LEAF_ARRAY_BYTES (ZAP_LEAF_CHUNKSIZE - 3)
110
111 #define ZAP_LEAF_HASH_SHIFT(bs) (bs - 5)
112 #define ZAP_LEAF_HASH_NUMENTRIES(bs) (1 << ZAP_LEAF_HASH_SHIFT(bs))
113 #define LEAF_HASH(bs, h) \
114 ((ZAP_LEAF_HASH_NUMENTRIES(bs)-1) & \
115 ((h) >> (64 - ZAP_LEAF_HASH_SHIFT(bs)-l->l_hdr.lh_prefix_len)))
116
117 /*
118 * The amount of space available for chunks is:
119 * block size shift - hash entry size (2) * number of hash
120 * entries - header space (2*chunksize)
121 */
122 #define ZAP_LEAF_NUMCHUNKS(bs) \
123 (((1<<bs) - 2*ZAP_LEAF_HASH_NUMENTRIES(bs)) / \
124 ZAP_LEAF_CHUNKSIZE - 2)
125
126 /*
127 * The chunks start immediately after the hash table. The end of the
128 * hash table is at l_hash + HASH_NUMENTRIES, which we simply cast to a
129 * chunk_t.
130 */
131 #define ZAP_LEAF_CHUNK(l, bs, idx) \
132 ((zap_leaf_chunk_t *)(l->l_hash + ZAP_LEAF_HASH_NUMENTRIES(bs)))[idx]
133 #define ZAP_LEAF_ENTRY(l, bs, idx) (&ZAP_LEAF_CHUNK(l, bs, idx).l_entry)
134
135
136 /*
137 * Decompression Entry - lzjb
138 */
139 #ifndef NBBY
140 #define NBBY 8
141 #endif
142
143
144
145 typedef int zfs_decomp_func_t(void *s_start, void *d_start,
146 uint32_t s_len, uint32_t d_len);
147 typedef struct decomp_entry {
148 char *name;
149 zfs_decomp_func_t *decomp_func;
150 } decomp_entry_t;
151
152 typedef struct dnode_end {
153 dnode_phys_t dn;
154 zfs_endian_t endian;
155 } dnode_end_t;
156
157 struct zfs_data {
158 /* cache for a file block of the currently zfs_open()-ed file */
159 char *file_buf;
160 uint64_t file_start;
161 uint64_t file_end;
162
163 /* XXX: ashift is per vdev, not per pool. We currently only ever touch
164 * a single vdev, but when/if raid-z or stripes are supported, this
165 * may need revision.
166 */
167 uint64_t vdev_ashift;
168 uint64_t label_txg;
169 uint64_t pool_guid;
170
171 /* cache for a dnode block */
172 dnode_phys_t *dnode_buf;
173 dnode_phys_t *dnode_mdn;
174 uint64_t dnode_start;
175 uint64_t dnode_end;
176 zfs_endian_t dnode_endian;
177
178 uberblock_t current_uberblock;
179
180 dnode_end_t mos;
181 dnode_end_t mdn;
182 dnode_end_t dnode;
183
184 uint64_t vdev_phys_sector;
185
186 int (*userhook)(const char *, const struct zfs_dirhook_info *);
187 struct zfs_dirhook_info *dirinfo;
188
189 };
190
191
192
193
194 static int
195 zlib_decompress(void *s, void *d,
196 uint32_t slen, uint32_t dlen)
197 {
198 if (zlib_decompress(s, d, slen, dlen) < 0)
199 return ZFS_ERR_BAD_FS;
200 return ZFS_ERR_NONE;
201 }
202
203 static decomp_entry_t decomp_table[ZIO_COMPRESS_FUNCTIONS] = {
204 {"inherit", NULL}, /* ZIO_COMPRESS_INHERIT */
205 {"on", lzjb_decompress}, /* ZIO_COMPRESS_ON */
206 {"off", NULL}, /* ZIO_COMPRESS_OFF */
207 {"lzjb", lzjb_decompress}, /* ZIO_COMPRESS_LZJB */
208 {"empty", NULL}, /* ZIO_COMPRESS_EMPTY */
209 {"gzip-1", zlib_decompress}, /* ZIO_COMPRESS_GZIP1 */
210 {"gzip-2", zlib_decompress}, /* ZIO_COMPRESS_GZIP2 */
211 {"gzip-3", zlib_decompress}, /* ZIO_COMPRESS_GZIP3 */
212 {"gzip-4", zlib_decompress}, /* ZIO_COMPRESS_GZIP4 */
213 {"gzip-5", zlib_decompress}, /* ZIO_COMPRESS_GZIP5 */
214 {"gzip-6", zlib_decompress}, /* ZIO_COMPRESS_GZIP6 */
215 {"gzip-7", zlib_decompress}, /* ZIO_COMPRESS_GZIP7 */
216 {"gzip-8", zlib_decompress}, /* ZIO_COMPRESS_GZIP8 */
217 {"gzip-9", zlib_decompress}, /* ZIO_COMPRESS_GZIP9 */
218 };
219
220
221
222 static int zio_read_data(blkptr_t *bp, zfs_endian_t endian,
223 void *buf, struct zfs_data *data);
224
225 static int
226 zio_read(blkptr_t *bp, zfs_endian_t endian, void **buf,
227 size_t *size, struct zfs_data *data);
228
229 /*
230 * Our own version of log2(). Same thing as highbit()-1.
231 */
232 static int
233 zfs_log2(uint64_t num)
234 {
235 int i = 0;
236
237 while (num > 1) {
238 i++;
239 num = num >> 1;
240 }
241
242 return i;
243 }
244
245
246 /* Checksum Functions */
247 static void
248 zio_checksum_off(const void *buf __attribute__ ((unused)),
249 uint64_t size __attribute__ ((unused)),
250 zfs_endian_t endian __attribute__ ((unused)),
251 zio_cksum_t *zcp)
252 {
253 ZIO_SET_CHECKSUM(zcp, 0, 0, 0, 0);
254 }
255
256 /* Checksum Table and Values */
257 static zio_checksum_info_t zio_checksum_table[ZIO_CHECKSUM_FUNCTIONS] = {
258 {NULL, 0, 0, "inherit"},
259 {NULL, 0, 0, "on"},
260 {zio_checksum_off, 0, 0, "off"},
261 {zio_checksum_SHA256, 1, 1, "label"},
262 {zio_checksum_SHA256, 1, 1, "gang_header"},
263 {NULL, 0, 0, "zilog"},
264 {fletcher_2_endian, 0, 0, "fletcher2"},
265 {fletcher_4_endian, 1, 0, "fletcher4"},
266 {zio_checksum_SHA256, 1, 0, "SHA256"},
267 {NULL, 0, 0, "zilog2"},
268 };
269
270 /*
271 * zio_checksum_verify: Provides support for checksum verification.
272 *
273 * Fletcher2, Fletcher4, and SHA256 are supported.
274 *
275 */
276 static int
277 zio_checksum_verify(zio_cksum_t zc, uint32_t checksum,
278 zfs_endian_t endian, char *buf, int size)
279 {
280 zio_eck_t *zec = (zio_eck_t *) (buf + size) - 1;
281 zio_checksum_info_t *ci = &zio_checksum_table[checksum];
282 zio_cksum_t actual_cksum, expected_cksum;
283
284 if (checksum >= ZIO_CHECKSUM_FUNCTIONS || ci->ci_func == NULL) {
285 printf("zfs unknown checksum function %d\n", checksum);
286 return ZFS_ERR_NOT_IMPLEMENTED_YET;
287 }
288
289 if (ci->ci_eck) {
290 expected_cksum = zec->zec_cksum;
291 zec->zec_cksum = zc;
292 ci->ci_func(buf, size, endian, &actual_cksum);
293 zec->zec_cksum = expected_cksum;
294 zc = expected_cksum;
295 } else {
296 ci->ci_func(buf, size, endian, &actual_cksum);
297 }
298
299 if ((actual_cksum.zc_word[0] != zc.zc_word[0])
300 || (actual_cksum.zc_word[1] != zc.zc_word[1])
301 || (actual_cksum.zc_word[2] != zc.zc_word[2])
302 || (actual_cksum.zc_word[3] != zc.zc_word[3])) {
303 return ZFS_ERR_BAD_FS;
304 }
305
306 return ZFS_ERR_NONE;
307 }
308
309 /*
310 * vdev_uberblock_compare takes two uberblock structures and returns an integer
311 * indicating the more recent of the two.
312 * Return Value = 1 if ub2 is more recent
313 * Return Value = -1 if ub1 is more recent
314 * The most recent uberblock is determined using its transaction number and
315 * timestamp. The uberblock with the highest transaction number is
316 * considered "newer". If the transaction numbers of the two blocks match, the
317 * timestamps are compared to determine the "newer" of the two.
318 */
319 static int
320 vdev_uberblock_compare(uberblock_t *ub1, uberblock_t *ub2)
321 {
322 zfs_endian_t ub1_endian, ub2_endian;
323 if (zfs_to_cpu64(ub1->ub_magic, LITTLE_ENDIAN) == UBERBLOCK_MAGIC)
324 ub1_endian = LITTLE_ENDIAN;
325 else
326 ub1_endian = BIG_ENDIAN;
327 if (zfs_to_cpu64(ub2->ub_magic, LITTLE_ENDIAN) == UBERBLOCK_MAGIC)
328 ub2_endian = LITTLE_ENDIAN;
329 else
330 ub2_endian = BIG_ENDIAN;
331
332 if (zfs_to_cpu64(ub1->ub_txg, ub1_endian)
333 < zfs_to_cpu64(ub2->ub_txg, ub2_endian))
334 return -1;
335 if (zfs_to_cpu64(ub1->ub_txg, ub1_endian)
336 > zfs_to_cpu64(ub2->ub_txg, ub2_endian))
337 return 1;
338
339 if (zfs_to_cpu64(ub1->ub_timestamp, ub1_endian)
340 < zfs_to_cpu64(ub2->ub_timestamp, ub2_endian))
341 return -1;
342 if (zfs_to_cpu64(ub1->ub_timestamp, ub1_endian)
343 > zfs_to_cpu64(ub2->ub_timestamp, ub2_endian))
344 return 1;
345
346 return 0;
347 }
348
349 /*
350 * Three pieces of information are needed to verify an uberblock: the magic
351 * number, the version number, and the checksum.
352 *
353 * Currently Implemented: version number, magic number, label txg
354 * Need to Implement: checksum
355 *
356 */
357 static int
358 uberblock_verify(uberblock_t *uber, int offset, struct zfs_data *data)
359 {
360 int err;
361 zfs_endian_t endian = UNKNOWN_ENDIAN;
362 zio_cksum_t zc;
363
364 if (uber->ub_txg < data->label_txg) {
365 debug("ignoring partially written label: uber_txg < label_txg %llu %llu\n",
366 uber->ub_txg, data->label_txg);
367 return ZFS_ERR_BAD_FS;
368 }
369
370 if (zfs_to_cpu64(uber->ub_magic, LITTLE_ENDIAN) == UBERBLOCK_MAGIC
371 && zfs_to_cpu64(uber->ub_version, LITTLE_ENDIAN) > 0
372 && zfs_to_cpu64(uber->ub_version, LITTLE_ENDIAN) <= SPA_VERSION)
373 endian = LITTLE_ENDIAN;
374
375 if (zfs_to_cpu64(uber->ub_magic, BIG_ENDIAN) == UBERBLOCK_MAGIC
376 && zfs_to_cpu64(uber->ub_version, BIG_ENDIAN) > 0
377 && zfs_to_cpu64(uber->ub_version, BIG_ENDIAN) <= SPA_VERSION)
378 endian = BIG_ENDIAN;
379
380 if (endian == UNKNOWN_ENDIAN) {
381 printf("invalid uberblock magic\n");
382 return ZFS_ERR_BAD_FS;
383 }
384
385 memset(&zc, 0, sizeof(zc));
386 zc.zc_word[0] = cpu_to_zfs64(offset, endian);
387 err = zio_checksum_verify(zc, ZIO_CHECKSUM_LABEL, endian,
388 (char *) uber, UBERBLOCK_SIZE(data->vdev_ashift));
389
390 if (!err) {
391 /* Check that the data pointed by the rootbp is usable. */
392 void *osp = NULL;
393 size_t ospsize;
394 err = zio_read(&uber->ub_rootbp, endian, &osp, &ospsize, data);
395 free(osp);
396
397 if (!err && ospsize < OBJSET_PHYS_SIZE_V14) {
398 printf("uberblock rootbp points to invalid data\n");
399 return ZFS_ERR_BAD_FS;
400 }
401 }
402
403 return err;
404 }
405
406 /*
407 * Find the best uberblock.
408 * Return:
409 * Success - Pointer to the best uberblock.
410 * Failure - NULL
411 */
412 static uberblock_t *find_bestub(char *ub_array, struct zfs_data *data)
413 {
414 const uint64_t sector = data->vdev_phys_sector;
415 uberblock_t *ubbest = NULL;
416 uberblock_t *ubnext;
417 unsigned int i, offset, pickedub = 0;
418 int err = ZFS_ERR_NONE;
419
420 const unsigned int UBCOUNT = UBERBLOCK_COUNT(data->vdev_ashift);
421 const uint64_t UBBYTES = UBERBLOCK_SIZE(data->vdev_ashift);
422
423 for (i = 0; i < UBCOUNT; i++) {
424 ubnext = (uberblock_t *) (i * UBBYTES + ub_array);
425 offset = (sector << SPA_MINBLOCKSHIFT) + VDEV_PHYS_SIZE + (i * UBBYTES);
426
427 err = uberblock_verify(ubnext, offset, data);
428 if (err)
429 continue;
430
431 if (ubbest == NULL || vdev_uberblock_compare(ubnext, ubbest) > 0) {
432 ubbest = ubnext;
433 pickedub = i;
434 }
435 }
436
437 if (ubbest)
438 debug("zfs Found best uberblock at idx %d, txg %llu\n",
439 pickedub, (unsigned long long) ubbest->ub_txg);
440
441 return ubbest;
442 }
443
444 static inline size_t
445 get_psize(blkptr_t *bp, zfs_endian_t endian)
446 {
447 return (((zfs_to_cpu64((bp)->blk_prop, endian) >> 16) & 0xffff) + 1)
448 << SPA_MINBLOCKSHIFT;
449 }
450
451 static uint64_t
452 dva_get_offset(dva_t *dva, zfs_endian_t endian)
453 {
454 return zfs_to_cpu64((dva)->dva_word[1],
455 endian) << SPA_MINBLOCKSHIFT;
456 }
457
458 /*
459 * Read a block of data based on the gang block address dva,
460 * and put its data in buf.
461 *
462 */
463 static int
464 zio_read_gang(blkptr_t *bp, zfs_endian_t endian, dva_t *dva, void *buf,
465 struct zfs_data *data)
466 {
467 zio_gbh_phys_t *zio_gb;
468 uint64_t offset, sector;
469 unsigned i;
470 int err;
471 zio_cksum_t zc;
472
473 memset(&zc, 0, sizeof(zc));
474
475 zio_gb = malloc(SPA_GANGBLOCKSIZE);
476 if (!zio_gb)
477 return ZFS_ERR_OUT_OF_MEMORY;
478
479 offset = dva_get_offset(dva, endian);
480 sector = DVA_OFFSET_TO_PHYS_SECTOR(offset);
481
482 /* read in the gang block header */
483 err = zfs_devread(sector, 0, SPA_GANGBLOCKSIZE, (char *) zio_gb);
484
485 if (err) {
486 free(zio_gb);
487 return err;
488 }
489
490 /* XXX */
491 /* self checksuming the gang block header */
492 ZIO_SET_CHECKSUM(&zc, DVA_GET_VDEV(dva),
493 dva_get_offset(dva, endian), bp->blk_birth, 0);
494 err = zio_checksum_verify(zc, ZIO_CHECKSUM_GANG_HEADER, endian,
495 (char *) zio_gb, SPA_GANGBLOCKSIZE);
496 if (err) {
497 free(zio_gb);
498 return err;
499 }
500
501 endian = (zfs_to_cpu64(bp->blk_prop, endian) >> 63) & 1;
502
503 for (i = 0; i < SPA_GBH_NBLKPTRS; i++) {
504 if (zio_gb->zg_blkptr[i].blk_birth == 0)
505 continue;
506
507 err = zio_read_data(&zio_gb->zg_blkptr[i], endian, buf, data);
508 if (err) {
509 free(zio_gb);
510 return err;
511 }
512 buf = (char *) buf + get_psize(&zio_gb->zg_blkptr[i], endian);
513 }
514 free(zio_gb);
515 return ZFS_ERR_NONE;
516 }
517
518 /*
519 * Read in a block of raw data to buf.
520 */
521 static int
522 zio_read_data(blkptr_t *bp, zfs_endian_t endian, void *buf,
523 struct zfs_data *data)
524 {
525 int i, psize;
526 int err = ZFS_ERR_NONE;
527
528 psize = get_psize(bp, endian);
529
530 /* pick a good dva from the block pointer */
531 for (i = 0; i < SPA_DVAS_PER_BP; i++) {
532 uint64_t offset, sector;
533
534 if (bp->blk_dva[i].dva_word[0] == 0 && bp->blk_dva[i].dva_word[1] == 0)
535 continue;
536
537 if ((zfs_to_cpu64(bp->blk_dva[i].dva_word[1], endian)>>63) & 1) {
538 err = zio_read_gang(bp, endian, &bp->blk_dva[i], buf, data);
539 } else {
540 /* read in a data block */
541 offset = dva_get_offset(&bp->blk_dva[i], endian);
542 sector = DVA_OFFSET_TO_PHYS_SECTOR(offset);
543
544 err = zfs_devread(sector, 0, psize, buf);
545 }
546
547 if (!err) {
548 /*Check the underlying checksum before we rule this DVA as "good"*/
549 uint32_t checkalgo = (zfs_to_cpu64((bp)->blk_prop, endian) >> 40) & 0xff;
550
551 err = zio_checksum_verify(bp->blk_cksum, checkalgo, endian, buf, psize);
552 if (!err)
553 return ZFS_ERR_NONE;
554 }
555
556 /* If read failed or checksum bad, reset the error. Hopefully we've got some more DVA's to try.*/
557 }
558
559 if (!err) {
560 printf("couldn't find a valid DVA\n");
561 err = ZFS_ERR_BAD_FS;
562 }
563
564 return err;
565 }
566
567 /*
568 * Read in a block of data, verify its checksum, decompress if needed,
569 * and put the uncompressed data in buf.
570 */
571 static int
572 zio_read(blkptr_t *bp, zfs_endian_t endian, void **buf,
573 size_t *size, struct zfs_data *data)
574 {
575 size_t lsize, psize;
576 unsigned int comp;
577 char *compbuf = NULL;
578 int err;
579
580 *buf = NULL;
581
582 comp = (zfs_to_cpu64((bp)->blk_prop, endian)>>32) & 0xff;
583 lsize = (BP_IS_HOLE(bp) ? 0 :
584 (((zfs_to_cpu64((bp)->blk_prop, endian) & 0xffff) + 1)
585 << SPA_MINBLOCKSHIFT));
586 psize = get_psize(bp, endian);
587
588 if (size)
589 *size = lsize;
590
591 if (comp >= ZIO_COMPRESS_FUNCTIONS) {
592 printf("compression algorithm %u not supported\n", (unsigned int) comp);
593 return ZFS_ERR_NOT_IMPLEMENTED_YET;
594 }
595
596 if (comp != ZIO_COMPRESS_OFF && decomp_table[comp].decomp_func == NULL) {
597 printf("compression algorithm %s not supported\n", decomp_table[comp].name);
598 return ZFS_ERR_NOT_IMPLEMENTED_YET;
599 }
600
601 if (comp != ZIO_COMPRESS_OFF) {
602 compbuf = malloc(psize);
603 if (!compbuf)
604 return ZFS_ERR_OUT_OF_MEMORY;
605 } else {
606 compbuf = *buf = malloc(lsize);
607 }
608
609 err = zio_read_data(bp, endian, compbuf, data);
610 if (err) {
611 free(compbuf);
612 *buf = NULL;
613 return err;
614 }
615
616 if (comp != ZIO_COMPRESS_OFF) {
617 *buf = malloc(lsize);
618 if (!*buf) {
619 free(compbuf);
620 return ZFS_ERR_OUT_OF_MEMORY;
621 }
622
623 err = decomp_table[comp].decomp_func(compbuf, *buf, psize, lsize);
624 free(compbuf);
625 if (err) {
626 free(*buf);
627 *buf = NULL;
628 return err;
629 }
630 }
631
632 return ZFS_ERR_NONE;
633 }
634
635 /*
636 * Get the block from a block id.
637 * push the block onto the stack.
638 *
639 */
640 static int
641 dmu_read(dnode_end_t *dn, uint64_t blkid, void **buf,
642 zfs_endian_t *endian_out, struct zfs_data *data)
643 {
644 int idx, level;
645 blkptr_t *bp_array = dn->dn.dn_blkptr;
646 int epbs = dn->dn.dn_indblkshift - SPA_BLKPTRSHIFT;
647 blkptr_t *bp;
648 void *tmpbuf = 0;
649 zfs_endian_t endian;
650 int err = ZFS_ERR_NONE;
651
652 bp = malloc(sizeof(blkptr_t));
653 if (!bp)
654 return ZFS_ERR_OUT_OF_MEMORY;
655
656 endian = dn->endian;
657 for (level = dn->dn.dn_nlevels - 1; level >= 0; level--) {
658 idx = (blkid >> (epbs * level)) & ((1 << epbs) - 1);
659 *bp = bp_array[idx];
660 if (bp_array != dn->dn.dn_blkptr) {
661 free(bp_array);
662 bp_array = 0;
663 }
664
665 if (BP_IS_HOLE(bp)) {
666 size_t size = zfs_to_cpu16(dn->dn.dn_datablkszsec,
667 dn->endian)
668 << SPA_MINBLOCKSHIFT;
669 *buf = malloc(size);
670 if (*buf) {
671 err = ZFS_ERR_OUT_OF_MEMORY;
672 break;
673 }
674 memset(*buf, 0, size);
675 endian = (zfs_to_cpu64(bp->blk_prop, endian) >> 63) & 1;
676 break;
677 }
678 if (level == 0) {
679 err = zio_read(bp, endian, buf, 0, data);
680 endian = (zfs_to_cpu64(bp->blk_prop, endian) >> 63) & 1;
681 break;
682 }
683 err = zio_read(bp, endian, &tmpbuf, 0, data);
684 endian = (zfs_to_cpu64(bp->blk_prop, endian) >> 63) & 1;
685 if (err)
686 break;
687 bp_array = tmpbuf;
688 }
689 if (bp_array != dn->dn.dn_blkptr)
690 free(bp_array);
691 if (endian_out)
692 *endian_out = endian;
693
694 free(bp);
695 return err;
696 }
697
698 /*
699 * mzap_lookup: Looks up property described by "name" and returns the value
700 * in "value".
701 */
702 static int
703 mzap_lookup(mzap_phys_t *zapobj, zfs_endian_t endian,
704 int objsize, char *name, uint64_t * value)
705 {
706 int i, chunks;
707 mzap_ent_phys_t *mzap_ent = zapobj->mz_chunk;
708
709 chunks = objsize / MZAP_ENT_LEN - 1;
710 for (i = 0; i < chunks; i++) {
711 if (strcmp(mzap_ent[i].mze_name, name) == 0) {
712 *value = zfs_to_cpu64(mzap_ent[i].mze_value, endian);
713 return ZFS_ERR_NONE;
714 }
715 }
716
717 printf("couldn't find '%s'\n", name);
718 return ZFS_ERR_FILE_NOT_FOUND;
719 }
720
721 static int
722 mzap_iterate(mzap_phys_t *zapobj, zfs_endian_t endian, int objsize,
723 int (*hook)(const char *name,
724 uint64_t val,
725 struct zfs_data *data),
726 struct zfs_data *data)
727 {
728 int i, chunks;
729 mzap_ent_phys_t *mzap_ent = zapobj->mz_chunk;
730
731 chunks = objsize / MZAP_ENT_LEN - 1;
732 for (i = 0; i < chunks; i++) {
733 if (hook(mzap_ent[i].mze_name,
734 zfs_to_cpu64(mzap_ent[i].mze_value, endian),
735 data))
736 return 1;
737 }
738
739 return 0;
740 }
741
742 static uint64_t
743 zap_hash(uint64_t salt, const char *name)
744 {
745 static uint64_t table[256];
746 const uint8_t *cp;
747 uint8_t c;
748 uint64_t crc = salt;
749
750 if (table[128] == 0) {
751 uint64_t *ct;
752 int i, j;
753 for (i = 0; i < 256; i++) {
754 for (ct = table + i, *ct = i, j = 8; j > 0; j--)
755 *ct = (*ct >> 1) ^ (-(*ct & 1) & ZFS_CRC64_POLY);
756 }
757 }
758
759 for (cp = (const uint8_t *) name; (c = *cp) != '\0'; cp++)
760 crc = (crc >> 8) ^ table[(crc ^ c) & 0xFF];
761
762 /*
763 * Only use 28 bits, since we need 4 bits in the cookie for the
764 * collision differentiator. We MUST use the high bits, since
765 * those are the onces that we first pay attention to when
766 * chosing the bucket.
767 */
768 crc &= ~((1ULL << (64 - ZAP_HASHBITS)) - 1);
769
770 return crc;
771 }
772
773 /*
774 * Only to be used on 8-bit arrays.
775 * array_len is actual len in bytes (not encoded le_value_length).
776 * buf is null-terminated.
777 */
778 /* XXX */
779 static int
780 zap_leaf_array_equal(zap_leaf_phys_t *l, zfs_endian_t endian,
781 int blksft, int chunk, int array_len, const char *buf)
782 {
783 int bseen = 0;
784
785 while (bseen < array_len) {
786 struct zap_leaf_array *la = &ZAP_LEAF_CHUNK(l, blksft, chunk).l_array;
787 int toread = MIN(array_len - bseen, ZAP_LEAF_ARRAY_BYTES);
788
789 if (chunk >= ZAP_LEAF_NUMCHUNKS(blksft))
790 return 0;
791
792 if (memcmp(la->la_array, buf + bseen, toread) != 0)
793 break;
794 chunk = zfs_to_cpu16(la->la_next, endian);
795 bseen += toread;
796 }
797 return (bseen == array_len);
798 }
799
800 /* XXX */
801 static int
802 zap_leaf_array_get(zap_leaf_phys_t *l, zfs_endian_t endian, int blksft,
803 int chunk, int array_len, char *buf)
804 {
805 int bseen = 0;
806
807 while (bseen < array_len) {
808 struct zap_leaf_array *la = &ZAP_LEAF_CHUNK(l, blksft, chunk).l_array;
809 int toread = MIN(array_len - bseen, ZAP_LEAF_ARRAY_BYTES);
810
811 if (chunk >= ZAP_LEAF_NUMCHUNKS(blksft))
812 /* Don't use errno because this error is to be ignored. */
813 return ZFS_ERR_BAD_FS;
814
815 memcpy(buf + bseen, la->la_array, toread);
816 chunk = zfs_to_cpu16(la->la_next, endian);
817 bseen += toread;
818 }
819 return ZFS_ERR_NONE;
820 }
821
822
823 /*
824 * Given a zap_leaf_phys_t, walk thru the zap leaf chunks to get the
825 * value for the property "name".
826 *
827 */
828 /* XXX */
829 static int
830 zap_leaf_lookup(zap_leaf_phys_t *l, zfs_endian_t endian,
831 int blksft, uint64_t h,
832 const char *name, uint64_t *value)
833 {
834 uint16_t chunk;
835 struct zap_leaf_entry *le;
836
837 /* Verify if this is a valid leaf block */
838 if (zfs_to_cpu64(l->l_hdr.lh_block_type, endian) != ZBT_LEAF) {
839 printf("invalid leaf type\n");
840 return ZFS_ERR_BAD_FS;
841 }
842 if (zfs_to_cpu32(l->l_hdr.lh_magic, endian) != ZAP_LEAF_MAGIC) {
843 printf("invalid leaf magic\n");
844 return ZFS_ERR_BAD_FS;
845 }
846
847 for (chunk = zfs_to_cpu16(l->l_hash[LEAF_HASH(blksft, h)], endian);
848 chunk != CHAIN_END; chunk = le->le_next) {
849
850 if (chunk >= ZAP_LEAF_NUMCHUNKS(blksft)) {
851 printf("invalid chunk number\n");
852 return ZFS_ERR_BAD_FS;
853 }
854
855 le = ZAP_LEAF_ENTRY(l, blksft, chunk);
856
857 /* Verify the chunk entry */
858 if (le->le_type != ZAP_CHUNK_ENTRY) {
859 printf("invalid chunk entry\n");
860 return ZFS_ERR_BAD_FS;
861 }
862
863 if (zfs_to_cpu64(le->le_hash, endian) != h)
864 continue;
865
866 if (zap_leaf_array_equal(l, endian, blksft,
867 zfs_to_cpu16(le->le_name_chunk, endian),
868 zfs_to_cpu16(le->le_name_length, endian),
869 name)) {
870 struct zap_leaf_array *la;
871
872 if (le->le_int_size != 8 || le->le_value_length != 1) {
873 printf("invalid leaf chunk entry\n");
874 return ZFS_ERR_BAD_FS;
875 }
876 /* get the uint64_t property value */
877 la = &ZAP_LEAF_CHUNK(l, blksft, le->le_value_chunk).l_array;
878
879 *value = be64_to_cpu(la->la_array64);
880
881 return ZFS_ERR_NONE;
882 }
883 }
884
885 printf("couldn't find '%s'\n", name);
886 return ZFS_ERR_FILE_NOT_FOUND;
887 }
888
889
890 /* Verify if this is a fat zap header block */
891 static int
892 zap_verify(zap_phys_t *zap)
893 {
894 if (zap->zap_magic != (uint64_t) ZAP_MAGIC) {
895 printf("bad ZAP magic\n");
896 return ZFS_ERR_BAD_FS;
897 }
898
899 if (zap->zap_flags != 0) {
900 printf("bad ZAP flags\n");
901 return ZFS_ERR_BAD_FS;
902 }
903
904 if (zap->zap_salt == 0) {
905 printf("bad ZAP salt\n");
906 return ZFS_ERR_BAD_FS;
907 }
908
909 return ZFS_ERR_NONE;
910 }
911
912 /*
913 * Fat ZAP lookup
914 *
915 */
916 /* XXX */
917 static int
918 fzap_lookup(dnode_end_t *zap_dnode, zap_phys_t *zap,
919 char *name, uint64_t *value, struct zfs_data *data)
920 {
921 void *l;
922 uint64_t hash, idx, blkid;
923 int blksft = zfs_log2(zfs_to_cpu16(zap_dnode->dn.dn_datablkszsec,
924 zap_dnode->endian) << DNODE_SHIFT);
925 int err;
926 zfs_endian_t leafendian;
927
928 err = zap_verify(zap);
929 if (err)
930 return err;
931
932 hash = zap_hash(zap->zap_salt, name);
933
934 /* get block id from index */
935 if (zap->zap_ptrtbl.zt_numblks != 0) {
936 printf("external pointer tables not supported\n");
937 return ZFS_ERR_NOT_IMPLEMENTED_YET;
938 }
939 idx = ZAP_HASH_IDX(hash, zap->zap_ptrtbl.zt_shift);
940 blkid = ((uint64_t *) zap)[idx + (1 << (blksft - 3 - 1))];
941
942 /* Get the leaf block */
943 if ((1U << blksft) < sizeof(zap_leaf_phys_t)) {
944 printf("ZAP leaf is too small\n");
945 return ZFS_ERR_BAD_FS;
946 }
947 err = dmu_read(zap_dnode, blkid, &l, &leafendian, data);
948 if (err)
949 return err;
950
951 err = zap_leaf_lookup(l, leafendian, blksft, hash, name, value);
952 free(l);
953 return err;
954 }
955
956 /* XXX */
957 static int
958 fzap_iterate(dnode_end_t *zap_dnode, zap_phys_t *zap,
959 int (*hook)(const char *name,
960 uint64_t val,
961 struct zfs_data *data),
962 struct zfs_data *data)
963 {
964 zap_leaf_phys_t *l;
965 void *l_in;
966 uint64_t idx, blkid;
967 uint16_t chunk;
968 int blksft = zfs_log2(zfs_to_cpu16(zap_dnode->dn.dn_datablkszsec,
969 zap_dnode->endian) << DNODE_SHIFT);
970 int err;
971 zfs_endian_t endian;
972
973 if (zap_verify(zap))
974 return 0;
975
976 /* get block id from index */
977 if (zap->zap_ptrtbl.zt_numblks != 0) {
978 printf("external pointer tables not supported\n");
979 return 0;
980 }
981 /* Get the leaf block */
982 if ((1U << blksft) < sizeof(zap_leaf_phys_t)) {
983 printf("ZAP leaf is too small\n");
984 return 0;
985 }
986 for (idx = 0; idx < zap->zap_ptrtbl.zt_numblks; idx++) {
987 blkid = ((uint64_t *) zap)[idx + (1 << (blksft - 3 - 1))];
988
989 err = dmu_read(zap_dnode, blkid, &l_in, &endian, data);
990 l = l_in;
991 if (err)
992 continue;
993
994 /* Verify if this is a valid leaf block */
995 if (zfs_to_cpu64(l->l_hdr.lh_block_type, endian) != ZBT_LEAF) {
996 free(l);
997 continue;
998 }
999 if (zfs_to_cpu32(l->l_hdr.lh_magic, endian) != ZAP_LEAF_MAGIC) {
1000 free(l);
1001 continue;
1002 }
1003
1004 for (chunk = 0; chunk < ZAP_LEAF_NUMCHUNKS(blksft); chunk++) {
1005 char *buf;
1006 struct zap_leaf_array *la;
1007 struct zap_leaf_entry *le;
1008 uint64_t val;
1009 le = ZAP_LEAF_ENTRY(l, blksft, chunk);
1010
1011 /* Verify the chunk entry */
1012 if (le->le_type != ZAP_CHUNK_ENTRY)
1013 continue;
1014
1015 buf = malloc(zfs_to_cpu16(le->le_name_length, endian)
1016 + 1);
1017 if (zap_leaf_array_get(l, endian, blksft, le->le_name_chunk,
1018 le->le_name_length, buf)) {
1019 free(buf);
1020 continue;
1021 }
1022 buf[le->le_name_length] = 0;
1023
1024 if (le->le_int_size != 8
1025 || zfs_to_cpu16(le->le_value_length, endian) != 1)
1026 continue;
1027
1028 /* get the uint64_t property value */
1029 la = &ZAP_LEAF_CHUNK(l, blksft, le->le_value_chunk).l_array;
1030 val = be64_to_cpu(la->la_array64);
1031 if (hook(buf, val, data))
1032 return 1;
1033 free(buf);
1034 }
1035 }
1036 return 0;
1037 }
1038
1039
1040 /*
1041 * Read in the data of a zap object and find the value for a matching
1042 * property name.
1043 *
1044 */
1045 static int
1046 zap_lookup(dnode_end_t *zap_dnode, char *name, uint64_t *val,
1047 struct zfs_data *data)
1048 {
1049 uint64_t block_type;
1050 int size;
1051 void *zapbuf;
1052 int err;
1053 zfs_endian_t endian;
1054
1055 /* Read in the first block of the zap object data. */
1056 size = zfs_to_cpu16(zap_dnode->dn.dn_datablkszsec,
1057 zap_dnode->endian) << SPA_MINBLOCKSHIFT;
1058 err = dmu_read(zap_dnode, 0, &zapbuf, &endian, data);
1059 if (err)
1060 return err;
1061 block_type = zfs_to_cpu64(*((uint64_t *) zapbuf), endian);
1062
1063 if (block_type == ZBT_MICRO) {
1064 err = (mzap_lookup(zapbuf, endian, size, name, val));
1065 free(zapbuf);
1066 return err;
1067 } else if (block_type == ZBT_HEADER) {
1068 /* this is a fat zap */
1069 err = (fzap_lookup(zap_dnode, zapbuf, name, val, data));
1070 free(zapbuf);
1071 return err;
1072 }
1073
1074 printf("unknown ZAP type\n");
1075 return ZFS_ERR_BAD_FS;
1076 }
1077
1078 static int
1079 zap_iterate(dnode_end_t *zap_dnode,
1080 int (*hook)(const char *name, uint64_t val,
1081 struct zfs_data *data),
1082 struct zfs_data *data)
1083 {
1084 uint64_t block_type;
1085 int size;
1086 void *zapbuf;
1087 int err;
1088 int ret;
1089 zfs_endian_t endian;
1090
1091 /* Read in the first block of the zap object data. */
1092 size = zfs_to_cpu16(zap_dnode->dn.dn_datablkszsec, zap_dnode->endian) << SPA_MINBLOCKSHIFT;
1093 err = dmu_read(zap_dnode, 0, &zapbuf, &endian, data);
1094 if (err)
1095 return 0;
1096 block_type = zfs_to_cpu64(*((uint64_t *) zapbuf), endian);
1097
1098 if (block_type == ZBT_MICRO) {
1099 ret = mzap_iterate(zapbuf, endian, size, hook, data);
1100 free(zapbuf);
1101 return ret;
1102 } else if (block_type == ZBT_HEADER) {
1103 /* this is a fat zap */
1104 ret = fzap_iterate(zap_dnode, zapbuf, hook, data);
1105 free(zapbuf);
1106 return ret;
1107 }
1108 printf("unknown ZAP type\n");
1109 return 0;
1110 }
1111
1112
1113 /*
1114 * Get the dnode of an object number from the metadnode of an object set.
1115 *
1116 * Input
1117 * mdn - metadnode to get the object dnode
1118 * objnum - object number for the object dnode
1119 * buf - data buffer that holds the returning dnode
1120 */
1121 static int
1122 dnode_get(dnode_end_t *mdn, uint64_t objnum, uint8_t type,
1123 dnode_end_t *buf, struct zfs_data *data)
1124 {
1125 uint64_t blkid, blksz; /* the block id this object dnode is in */
1126 int epbs; /* shift of number of dnodes in a block */
1127 int idx; /* index within a block */
1128 void *dnbuf;
1129 int err;
1130 zfs_endian_t endian;
1131
1132 blksz = zfs_to_cpu16(mdn->dn.dn_datablkszsec,
1133 mdn->endian) << SPA_MINBLOCKSHIFT;
1134
1135 epbs = zfs_log2(blksz) - DNODE_SHIFT;
1136 blkid = objnum >> epbs;
1137 idx = objnum & ((1 << epbs) - 1);
1138
1139 if (data->dnode_buf != NULL && memcmp(data->dnode_mdn, mdn,
1140 sizeof(*mdn)) == 0
1141 && objnum >= data->dnode_start && objnum < data->dnode_end) {
1142 memmove(&(buf->dn), &(data->dnode_buf)[idx], DNODE_SIZE);
1143 buf->endian = data->dnode_endian;
1144 if (type && buf->dn.dn_type != type) {
1145 printf("incorrect dnode type: %02X != %02x\n", buf->dn.dn_type, type);
1146 return ZFS_ERR_BAD_FS;
1147 }
1148 return ZFS_ERR_NONE;
1149 }
1150
1151 err = dmu_read(mdn, blkid, &dnbuf, &endian, data);
1152 if (err)
1153 return err;
1154
1155 free(data->dnode_buf);
1156 free(data->dnode_mdn);
1157 data->dnode_mdn = malloc(sizeof(*mdn));
1158 if (!data->dnode_mdn) {
1159 data->dnode_buf = 0;
1160 } else {
1161 memcpy(data->dnode_mdn, mdn, sizeof(*mdn));
1162 data->dnode_buf = dnbuf;
1163 data->dnode_start = blkid << epbs;
1164 data->dnode_end = (blkid + 1) << epbs;
1165 data->dnode_endian = endian;
1166 }
1167
1168 memmove(&(buf->dn), (dnode_phys_t *) dnbuf + idx, DNODE_SIZE);
1169 buf->endian = endian;
1170 if (type && buf->dn.dn_type != type) {
1171 printf("incorrect dnode type\n");
1172 return ZFS_ERR_BAD_FS;
1173 }
1174
1175 return ZFS_ERR_NONE;
1176 }
1177
1178 /*
1179 * Get the file dnode for a given file name where mdn is the meta dnode
1180 * for this ZFS object set. When found, place the file dnode in dn.
1181 * The 'path' argument will be mangled.
1182 *
1183 */
1184 static int
1185 dnode_get_path(dnode_end_t *mdn, const char *path_in, dnode_end_t *dn,
1186 struct zfs_data *data)
1187 {
1188 uint64_t objnum, version;
1189 char *cname, ch;
1190 int err = ZFS_ERR_NONE;
1191 char *path, *path_buf;
1192 struct dnode_chain {
1193 struct dnode_chain *next;
1194 dnode_end_t dn;
1195 };
1196 struct dnode_chain *dnode_path = 0, *dn_new, *root;
1197
1198 dn_new = malloc(sizeof(*dn_new));
1199 if (!dn_new)
1200 return ZFS_ERR_OUT_OF_MEMORY;
1201 dn_new->next = 0;
1202 dnode_path = root = dn_new;
1203
1204 err = dnode_get(mdn, MASTER_NODE_OBJ, DMU_OT_MASTER_NODE,
1205 &(dnode_path->dn), data);
1206 if (err) {
1207 free(dn_new);
1208 return err;
1209 }
1210
1211 err = zap_lookup(&(dnode_path->dn), ZPL_VERSION_STR, &version, data);
1212 if (err) {
1213 free(dn_new);
1214 return err;
1215 }
1216 if (version > ZPL_VERSION) {
1217 free(dn_new);
1218 printf("too new ZPL version\n");
1219 return ZFS_ERR_NOT_IMPLEMENTED_YET;
1220 }
1221
1222 err = zap_lookup(&(dnode_path->dn), ZFS_ROOT_OBJ, &objnum, data);
1223 if (err) {
1224 free(dn_new);
1225 return err;
1226 }
1227
1228 err = dnode_get(mdn, objnum, 0, &(dnode_path->dn), data);
1229 if (err) {
1230 free(dn_new);
1231 return err;
1232 }
1233
1234 path = path_buf = strdup(path_in);
1235 if (!path_buf) {
1236 free(dn_new);
1237 return ZFS_ERR_OUT_OF_MEMORY;
1238 }
1239
1240 while (1) {
1241 /* skip leading slashes */
1242 while (*path == '/')
1243 path++;
1244 if (!*path)
1245 break;
1246 /* get the next component name */
1247 cname = path;
1248 while (*path && *path != '/')
1249 path++;
1250 /* Skip dot. */
1251 if (cname + 1 == path && cname[0] == '.')
1252 continue;
1253 /* Handle double dot. */
1254 if (cname + 2 == path && cname[0] == '.' && cname[1] == '.') {
1255 if (dn_new->next) {
1256 dn_new = dnode_path;
1257 dnode_path = dn_new->next;
1258 free(dn_new);
1259 } else {
1260 printf("can't resolve ..\n");
1261 err = ZFS_ERR_FILE_NOT_FOUND;
1262 break;
1263 }
1264 continue;
1265 }
1266
1267 ch = *path;
1268 *path = 0; /* ensure null termination */
1269
1270 if (dnode_path->dn.dn.dn_type != DMU_OT_DIRECTORY_CONTENTS) {
1271 free(path_buf);
1272 printf("not a directory\n");
1273 return ZFS_ERR_BAD_FILE_TYPE;
1274 }
1275 err = zap_lookup(&(dnode_path->dn), cname, &objnum, data);
1276 if (err)
1277 break;
1278
1279 dn_new = malloc(sizeof(*dn_new));
1280 if (!dn_new) {
1281 err = ZFS_ERR_OUT_OF_MEMORY;
1282 break;
1283 }
1284 dn_new->next = dnode_path;
1285 dnode_path = dn_new;
1286
1287 objnum = ZFS_DIRENT_OBJ(objnum);
1288 err = dnode_get(mdn, objnum, 0, &(dnode_path->dn), data);
1289 if (err)
1290 break;
1291
1292 *path = ch;
1293 }
1294
1295 if (!err)
1296 memcpy(dn, &(dnode_path->dn), sizeof(*dn));
1297
1298 while (dnode_path) {
1299 dn_new = dnode_path->next;
1300 free(dnode_path);
1301 dnode_path = dn_new;
1302 }
1303 free(path_buf);
1304 return err;
1305 }
1306
1307
1308 /*
1309 * Given a MOS metadnode, get the metadnode of a given filesystem name (fsname),
1310 * e.g. pool/rootfs, or a given object number (obj), e.g. the object number
1311 * of pool/rootfs.
1312 *
1313 * If no fsname and no obj are given, return the DSL_DIR metadnode.
1314 * If fsname is given, return its metadnode and its matching object number.
1315 * If only obj is given, return the metadnode for this object number.
1316 *
1317 */
1318 static int
1319 get_filesystem_dnode(dnode_end_t *mosmdn, char *fsname,
1320 dnode_end_t *mdn, struct zfs_data *data)
1321 {
1322 uint64_t objnum;
1323 int err;
1324
1325 err = dnode_get(mosmdn, DMU_POOL_DIRECTORY_OBJECT,
1326 DMU_OT_OBJECT_DIRECTORY, mdn, data);
1327 if (err)
1328 return err;
1329
1330 err = zap_lookup(mdn, DMU_POOL_ROOT_DATASET, &objnum, data);
1331 if (err)
1332 return err;
1333
1334 err = dnode_get(mosmdn, objnum, DMU_OT_DSL_DIR, mdn, data);
1335 if (err)
1336 return err;
1337
1338 while (*fsname) {
1339 uint64_t childobj;
1340 char *cname, ch;
1341
1342 while (*fsname == '/')
1343 fsname++;
1344
1345 if (!*fsname || *fsname == '@')
1346 break;
1347
1348 cname = fsname;
1349 while (*fsname && !isspace(*fsname) && *fsname != '/')
1350 fsname++;
1351 ch = *fsname;
1352 *fsname = 0;
1353
1354 childobj = zfs_to_cpu64((((dsl_dir_phys_t *) DN_BONUS(&mdn->dn)))->dd_child_dir_zapobj, mdn->endian);
1355 err = dnode_get(mosmdn, childobj,
1356 DMU_OT_DSL_DIR_CHILD_MAP, mdn, data);
1357 if (err)
1358 return err;
1359
1360 err = zap_lookup(mdn, cname, &objnum, data);
1361 if (err)
1362 return err;
1363
1364 err = dnode_get(mosmdn, objnum, DMU_OT_DSL_DIR, mdn, data);
1365 if (err)
1366 return err;
1367
1368 *fsname = ch;
1369 }
1370 return ZFS_ERR_NONE;
1371 }
1372
1373 static int
1374 make_mdn(dnode_end_t *mdn, struct zfs_data *data)
1375 {
1376 void *osp;
1377 blkptr_t *bp;
1378 size_t ospsize;
1379 int err;
1380
1381 bp = &(((dsl_dataset_phys_t *) DN_BONUS(&mdn->dn))->ds_bp);
1382 err = zio_read(bp, mdn->endian, &osp, &ospsize, data);
1383 if (err)
1384 return err;
1385 if (ospsize < OBJSET_PHYS_SIZE_V14) {
1386 free(osp);
1387 printf("too small osp\n");
1388 return ZFS_ERR_BAD_FS;
1389 }
1390
1391 mdn->endian = (zfs_to_cpu64(bp->blk_prop, mdn->endian)>>63) & 1;
1392 memmove((char *) &(mdn->dn),
1393 (char *) &((objset_phys_t *) osp)->os_meta_dnode, DNODE_SIZE);
1394 free(osp);
1395 return ZFS_ERR_NONE;
1396 }
1397
1398 static int
1399 dnode_get_fullpath(const char *fullpath, dnode_end_t *mdn,
1400 uint64_t *mdnobj, dnode_end_t *dn, int *isfs,
1401 struct zfs_data *data)
1402 {
1403 char *fsname, *snapname;
1404 const char *ptr_at, *filename;
1405 uint64_t headobj;
1406 int err;
1407
1408 ptr_at = strchr(fullpath, '@');
1409 if (!ptr_at) {
1410 *isfs = 1;
1411 filename = 0;
1412 snapname = 0;
1413 fsname = strdup(fullpath);
1414 } else {
1415 const char *ptr_slash = strchr(ptr_at, '/');
1416
1417 *isfs = 0;
1418 fsname = malloc(ptr_at - fullpath + 1);
1419 if (!fsname)
1420 return ZFS_ERR_OUT_OF_MEMORY;
1421 memcpy(fsname, fullpath, ptr_at - fullpath);
1422 fsname[ptr_at - fullpath] = 0;
1423 if (ptr_at[1] && ptr_at[1] != '/') {
1424 snapname = malloc(ptr_slash - ptr_at);
1425 if (!snapname) {
1426 free(fsname);
1427 return ZFS_ERR_OUT_OF_MEMORY;
1428 }
1429 memcpy(snapname, ptr_at + 1, ptr_slash - ptr_at - 1);
1430 snapname[ptr_slash - ptr_at - 1] = 0;
1431 } else {
1432 snapname = 0;
1433 }
1434 if (ptr_slash)
1435 filename = ptr_slash;
1436 else
1437 filename = "/";
1438 printf("zfs fsname = '%s' snapname='%s' filename = '%s'\n",
1439 fsname, snapname, filename);
1440 }
1441
1442
1443 err = get_filesystem_dnode(&(data->mos), fsname, dn, data);
1444
1445 if (err) {
1446 free(fsname);
1447 free(snapname);
1448 return err;
1449 }
1450
1451 headobj = zfs_to_cpu64(((dsl_dir_phys_t *) DN_BONUS(&dn->dn))->dd_head_dataset_obj, dn->endian);
1452
1453 err = dnode_get(&(data->mos), headobj, DMU_OT_DSL_DATASET, mdn, data);
1454 if (err) {
1455 free(fsname);
1456 free(snapname);
1457 return err;
1458 }
1459
1460 if (snapname) {
1461 uint64_t snapobj;
1462
1463 snapobj = zfs_to_cpu64(((dsl_dataset_phys_t *) DN_BONUS(&mdn->dn))->ds_snapnames_zapobj, mdn->endian);
1464
1465 err = dnode_get(&(data->mos), snapobj,
1466 DMU_OT_DSL_DS_SNAP_MAP, mdn, data);
1467 if (!err)
1468 err = zap_lookup(mdn, snapname, &headobj, data);
1469 if (!err)
1470 err = dnode_get(&(data->mos), headobj, DMU_OT_DSL_DATASET, mdn, data);
1471 if (err) {
1472 free(fsname);
1473 free(snapname);
1474 return err;
1475 }
1476 }
1477
1478 if (mdnobj)
1479 *mdnobj = headobj;
1480
1481 make_mdn(mdn, data);
1482
1483 if (*isfs) {
1484 free(fsname);
1485 free(snapname);
1486 return ZFS_ERR_NONE;
1487 }
1488 err = dnode_get_path(mdn, filename, dn, data);
1489 free(fsname);
1490 free(snapname);
1491 return err;
1492 }
1493
1494 /*
1495 * For a given XDR packed nvlist, verify the first 4 bytes and move on.
1496 *
1497 * An XDR packed nvlist is encoded as (comments from nvs_xdr_create) :
1498 *
1499 * encoding method/host endian (4 bytes)
1500 * nvl_version (4 bytes)
1501 * nvl_nvflag (4 bytes)
1502 * encoded nvpairs:
1503 * encoded size of the nvpair (4 bytes)
1504 * decoded size of the nvpair (4 bytes)
1505 * name string size (4 bytes)
1506 * name string data (sizeof(NV_ALIGN4(string))
1507 * data type (4 bytes)
1508 * # of elements in the nvpair (4 bytes)
1509 * data
1510 * 2 zero's for the last nvpair
1511 * (end of the entire list) (8 bytes)
1512 *
1513 */
1514
1515 static int
1516 nvlist_find_value(char *nvlist, char *name, int valtype, char **val,
1517 size_t *size_out, size_t *nelm_out)
1518 {
1519 int name_len, type, encode_size;
1520 char *nvpair, *nvp_name;
1521
1522 /* Verify if the 1st and 2nd byte in the nvlist are valid. */
1523 /* NOTE: independently of what endianness header announces all
1524 subsequent values are big-endian. */
1525 if (nvlist[0] != NV_ENCODE_XDR || (nvlist[1] != NV_LITTLE_ENDIAN
1526 && nvlist[1] != NV_BIG_ENDIAN)) {
1527 printf("zfs incorrect nvlist header\n");
1528 return ZFS_ERR_BAD_FS;
1529 }
1530
1531 /* skip the header, nvl_version, and nvl_nvflag */
1532 nvlist = nvlist + 4 * 3;
1533 /*
1534 * Loop thru the nvpair list
1535 * The XDR representation of an integer is in big-endian byte order.
1536 */
1537 while ((encode_size = be32_to_cpu(*(uint32_t *) nvlist))) {
1538 int nelm;
1539
1540 nvpair = nvlist + 4 * 2; /* skip the encode/decode size */
1541
1542 name_len = be32_to_cpu(*(uint32_t *) nvpair);
1543 nvpair += 4;
1544
1545 nvp_name = nvpair;
1546 nvpair = nvpair + ((name_len + 3) & ~3); /* align */
1547
1548 type = be32_to_cpu(*(uint32_t *) nvpair);
1549 nvpair += 4;
1550
1551 nelm = be32_to_cpu(*(uint32_t *) nvpair);
1552 if (nelm < 1) {
1553 printf("empty nvpair\n");
1554 return ZFS_ERR_BAD_FS;
1555 }
1556
1557 nvpair += 4;
1558
1559 if ((strncmp(nvp_name, name, name_len) == 0) && type == valtype) {
1560 *val = nvpair;
1561 *size_out = encode_size;
1562 if (nelm_out)
1563 *nelm_out = nelm;
1564 return 1;
1565 }
1566
1567 nvlist += encode_size; /* goto the next nvpair */
1568 }
1569 return 0;
1570 }
1571
1572 int
1573 zfs_nvlist_lookup_uint64(char *nvlist, char *name, uint64_t *out)
1574 {
1575 char *nvpair;
1576 size_t size;
1577 int found;
1578
1579 found = nvlist_find_value(nvlist, name, DATA_TYPE_UINT64, &nvpair, &size, 0);
1580 if (!found)
1581 return 0;
1582 if (size < sizeof(uint64_t)) {
1583 printf("invalid uint64\n");
1584 return ZFS_ERR_BAD_FS;
1585 }
1586
1587 *out = be64_to_cpu(*(uint64_t *) nvpair);
1588 return 1;
1589 }
1590
1591 char *
1592 zfs_nvlist_lookup_string(char *nvlist, char *name)
1593 {
1594 char *nvpair;
1595 char *ret;
1596 size_t slen;
1597 size_t size;
1598 int found;
1599
1600 found = nvlist_find_value(nvlist, name, DATA_TYPE_STRING, &nvpair, &size, 0);
1601 if (!found)
1602 return 0;
1603 if (size < 4) {
1604 printf("invalid string\n");
1605 return 0;
1606 }
1607 slen = be32_to_cpu(*(uint32_t *) nvpair);
1608 if (slen > size - 4)
1609 slen = size - 4;
1610 ret = malloc(slen + 1);
1611 if (!ret)
1612 return 0;
1613 memcpy(ret, nvpair + 4, slen);
1614 ret[slen] = 0;
1615 return ret;
1616 }
1617
1618 char *
1619 zfs_nvlist_lookup_nvlist(char *nvlist, char *name)
1620 {
1621 char *nvpair;
1622 char *ret;
1623 size_t size;
1624 int found;
1625
1626 found = nvlist_find_value(nvlist, name, DATA_TYPE_NVLIST, &nvpair,
1627 &size, 0);
1628 if (!found)
1629 return 0;
1630 ret = calloc(1, size + 3 * sizeof(uint32_t));
1631 if (!ret)
1632 return 0;
1633 memcpy(ret, nvlist, sizeof(uint32_t));
1634
1635 memcpy(ret + sizeof(uint32_t), nvpair, size);
1636 return ret;
1637 }
1638
1639 int
1640 zfs_nvlist_lookup_nvlist_array_get_nelm(char *nvlist, char *name)
1641 {
1642 char *nvpair;
1643 size_t nelm, size;
1644 int found;
1645
1646 found = nvlist_find_value(nvlist, name, DATA_TYPE_NVLIST, &nvpair,
1647 &size, &nelm);
1648 if (!found)
1649 return -1;
1650 return nelm;
1651 }
1652
1653 char *
1654 zfs_nvlist_lookup_nvlist_array(char *nvlist, char *name,
1655 size_t index)
1656 {
1657 char *nvpair, *nvpairptr;
1658 int found;
1659 char *ret;
1660 size_t size;
1661 unsigned i;
1662 size_t nelm;
1663
1664 found = nvlist_find_value(nvlist, name, DATA_TYPE_NVLIST, &nvpair,
1665 &size, &nelm);
1666 if (!found)
1667 return 0;
1668 if (index >= nelm) {
1669 printf("trying to lookup past nvlist array\n");
1670 return 0;
1671 }
1672
1673 nvpairptr = nvpair;
1674
1675 for (i = 0; i < index; i++) {
1676 uint32_t encode_size;
1677
1678 /* skip the header, nvl_version, and nvl_nvflag */
1679 nvpairptr = nvpairptr + 4 * 2;
1680
1681 while (nvpairptr < nvpair + size
1682 && (encode_size = be32_to_cpu(*(uint32_t *) nvpairptr)))
1683 nvlist += encode_size; /* goto the next nvpair */
1684
1685 nvlist = nvlist + 4 * 2; /* skip the ending 2 zeros - 8 bytes */
1686 }
1687
1688 if (nvpairptr >= nvpair + size
1689 || nvpairptr + be32_to_cpu(*(uint32_t *) (nvpairptr + 4 * 2))
1690 >= nvpair + size) {
1691 printf("incorrect nvlist array\n");
1692 return 0;
1693 }
1694
1695 ret = calloc(1, be32_to_cpu(*(uint32_t *) (nvpairptr + 4 * 2))
1696 + 3 * sizeof(uint32_t));
1697 if (!ret)
1698 return 0;
1699 memcpy(ret, nvlist, sizeof(uint32_t));
1700
1701 memcpy(ret + sizeof(uint32_t), nvpairptr, size);
1702 return ret;
1703 }
1704
1705 static int
1706 int_zfs_fetch_nvlist(struct zfs_data *data, char **nvlist)
1707 {
1708 int err;
1709
1710 *nvlist = malloc(VDEV_PHYS_SIZE);
1711 /* Read in the vdev name-value pair list (112K). */
1712 err = zfs_devread(data->vdev_phys_sector, 0, VDEV_PHYS_SIZE, *nvlist);
1713 if (err) {
1714 free(*nvlist);
1715 *nvlist = 0;
1716 return err;
1717 }
1718 return ZFS_ERR_NONE;
1719 }
1720
1721 /*
1722 * Check the disk label information and retrieve needed vdev name-value pairs.
1723 *
1724 */
1725 static int
1726 check_pool_label(struct zfs_data *data)
1727 {
1728 uint64_t pool_state;
1729 char *nvlist; /* for the pool */
1730 char *vdevnvlist; /* for the vdev */
1731 uint64_t diskguid;
1732 uint64_t version;
1733 int found;
1734 int err;
1735
1736 err = int_zfs_fetch_nvlist(data, &nvlist);
1737 if (err)
1738 return err;
1739
1740 found = zfs_nvlist_lookup_uint64(nvlist, ZPOOL_CONFIG_POOL_STATE,
1741 &pool_state);
1742 if (!found) {
1743 free(nvlist);
1744 printf("zfs pool state not found\n");
1745 return ZFS_ERR_BAD_FS;
1746 }
1747
1748 if (pool_state == POOL_STATE_DESTROYED) {
1749 free(nvlist);
1750 printf("zpool is marked as destroyed\n");
1751 return ZFS_ERR_BAD_FS;
1752 }
1753
1754 data->label_txg = 0;
1755 found = zfs_nvlist_lookup_uint64(nvlist, ZPOOL_CONFIG_POOL_TXG,
1756 &data->label_txg);
1757 if (!found) {
1758 free(nvlist);
1759 printf("zfs pool txg not found\n");
1760 return ZFS_ERR_BAD_FS;
1761 }
1762
1763 /* not an active device */
1764 if (data->label_txg == 0) {
1765 free(nvlist);
1766 printf("zpool is not active\n");
1767 return ZFS_ERR_BAD_FS;
1768 }
1769
1770 found = zfs_nvlist_lookup_uint64(nvlist, ZPOOL_CONFIG_VERSION,
1771 &version);
1772 if (!found) {
1773 free(nvlist);
1774 printf("zpool config version not found\n");
1775 return ZFS_ERR_BAD_FS;
1776 }
1777
1778 if (version > SPA_VERSION) {
1779 free(nvlist);
1780 printf("SPA version too new %llu > %llu\n",
1781 (unsigned long long) version,
1782 (unsigned long long) SPA_VERSION);
1783 return ZFS_ERR_NOT_IMPLEMENTED_YET;
1784 }
1785
1786 vdevnvlist = zfs_nvlist_lookup_nvlist(nvlist, ZPOOL_CONFIG_VDEV_TREE);
1787 if (!vdevnvlist) {
1788 free(nvlist);
1789 printf("ZFS config vdev tree not found\n");
1790 return ZFS_ERR_BAD_FS;
1791 }
1792
1793 found = zfs_nvlist_lookup_uint64(vdevnvlist, ZPOOL_CONFIG_ASHIFT,
1794 &data->vdev_ashift);
1795 free(vdevnvlist);
1796 if (!found) {
1797 free(nvlist);
1798 printf("ZPOOL config ashift not found\n");
1799 return ZFS_ERR_BAD_FS;
1800 }
1801
1802 found = zfs_nvlist_lookup_uint64(nvlist, ZPOOL_CONFIG_GUID, &diskguid);
1803 if (!found) {
1804 free(nvlist);
1805 printf("ZPOOL config guid not found\n");
1806 return ZFS_ERR_BAD_FS;
1807 }
1808
1809 found = zfs_nvlist_lookup_uint64(nvlist, ZPOOL_CONFIG_POOL_GUID, &data->pool_guid);
1810 if (!found) {
1811 free(nvlist);
1812 printf("ZPOOL config pool guid not found\n");
1813 return ZFS_ERR_BAD_FS;
1814 }
1815
1816 free(nvlist);
1817
1818 printf("ZFS Pool GUID: %llu (%016llx) Label: GUID: %llu (%016llx), txg: %llu, SPA v%llu, ashift: %llu\n",
1819 (unsigned long long) data->pool_guid,
1820 (unsigned long long) data->pool_guid,
1821 (unsigned long long) diskguid,
1822 (unsigned long long) diskguid,
1823 (unsigned long long) data->label_txg,
1824 (unsigned long long) version,
1825 (unsigned long long) data->vdev_ashift);
1826
1827 return ZFS_ERR_NONE;
1828 }
1829
1830 /*
1831 * vdev_label_start returns the physical disk offset (in bytes) of
1832 * label "l".
1833 */
1834 static uint64_t vdev_label_start(uint64_t psize, int l)
1835 {
1836 return (l * sizeof(vdev_label_t) + (l < VDEV_LABELS / 2 ?
1837 0 : psize -
1838 VDEV_LABELS * sizeof(vdev_label_t)));
1839 }
1840
1841 void
1842 zfs_unmount(struct zfs_data *data)
1843 {
1844 free(data->dnode_buf);
1845 free(data->dnode_mdn);
1846 free(data->file_buf);
1847 free(data);
1848 }
1849
1850 /*
1851 * zfs_mount() locates a valid uberblock of the root pool and read in its MOS
1852 * to the memory address MOS.
1853 *
1854 */
1855 struct zfs_data *
1856 zfs_mount(device_t dev)
1857 {
1858 struct zfs_data *data = 0;
1859 int label = 0, bestlabel = -1;
1860 char *ub_array;
1861 uberblock_t *ubbest;
1862 uberblock_t *ubcur = NULL;
1863 void *osp = 0;
1864 size_t ospsize;
1865 int err;
1866
1867 data = malloc(sizeof(*data));
1868 if (!data)
1869 return 0;
1870 memset(data, 0, sizeof(*data));
1871
1872 ub_array = malloc(VDEV_UBERBLOCK_RING);
1873 if (!ub_array) {
1874 zfs_unmount(data);
1875 return 0;
1876 }
1877
1878 ubbest = malloc(sizeof(*ubbest));
1879 if (!ubbest) {
1880 zfs_unmount(data);
1881 return 0;
1882 }
1883 memset(ubbest, 0, sizeof(*ubbest));
1884
1885 /*
1886 * some eltorito stacks don't give us a size and
1887 * we end up setting the size to MAXUINT, further
1888 * some of these devices stop working once a single
1889 * read past the end has been issued. Checking
1890 * for a maximum part_length and skipping the backup
1891 * labels at the end of the slice/partition/device
1892 * avoids breaking down on such devices.
1893 */
1894 const int vdevnum =
1895 dev->part_length == 0 ?
1896 VDEV_LABELS / 2 : VDEV_LABELS;
1897
1898 /* Size in bytes of the device (disk or partition) aligned to label size*/
1899 uint64_t device_size =
1900 dev->part_length << SECTOR_BITS;
1901
1902 const uint64_t alignedbytes =
1903 P2ALIGN(device_size, (uint64_t) sizeof(vdev_label_t));
1904
1905 for (label = 0; label < vdevnum; label++) {
1906 uint64_t labelstartbytes = vdev_label_start(alignedbytes, label);
1907 uint64_t labelstart = labelstartbytes >> SECTOR_BITS;
1908
1909 debug("zfs reading label %d at sector %llu (byte %llu)\n",
1910 label, (unsigned long long) labelstart,
1911 (unsigned long long) labelstartbytes);
1912
1913 data->vdev_phys_sector = labelstart +
1914 ((VDEV_SKIP_SIZE + VDEV_BOOT_HEADER_SIZE) >> SECTOR_BITS);
1915
1916 err = check_pool_label(data);
1917 if (err) {
1918 printf("zfs error checking label %d\n", label);
1919 continue;
1920 }
1921
1922 /* Read in the uberblock ring (128K). */
1923 err = zfs_devread(data->vdev_phys_sector +
1924 (VDEV_PHYS_SIZE >> SECTOR_BITS),
1925 0, VDEV_UBERBLOCK_RING, ub_array);
1926 if (err) {
1927 printf("zfs error reading uberblock ring for label %d\n", label);
1928 continue;
1929 }
1930
1931 ubcur = find_bestub(ub_array, data);
1932 if (!ubcur) {
1933 printf("zfs No good uberblocks found in label %d\n", label);
1934 continue;
1935 }
1936
1937 if (vdev_uberblock_compare(ubcur, ubbest) > 0) {
1938 /* Looks like the block is good, so use it.*/
1939 memcpy(ubbest, ubcur, sizeof(*ubbest));
1940 bestlabel = label;
1941 debug("zfs Current best uberblock found in label %d\n", label);
1942 }
1943 }
1944 free(ub_array);
1945
1946 /* We zero'd the structure to begin with. If we never assigned to it,
1947 magic will still be zero. */
1948 if (!ubbest->ub_magic) {
1949 printf("couldn't find a valid ZFS label\n");
1950 zfs_unmount(data);
1951 free(ubbest);
1952 return 0;
1953 }
1954
1955 debug("zfs ubbest %p in label %d\n", ubbest, bestlabel);
1956
1957 zfs_endian_t ub_endian =
1958 zfs_to_cpu64(ubbest->ub_magic, LITTLE_ENDIAN) == UBERBLOCK_MAGIC
1959 ? LITTLE_ENDIAN : BIG_ENDIAN;
1960
1961 debug("zfs endian set to %s\n", !ub_endian ? "big" : "little");
1962
1963 err = zio_read(&ubbest->ub_rootbp, ub_endian, &osp, &ospsize, data);
1964
1965 if (err) {
1966 printf("couldn't zio_read object directory\n");
1967 zfs_unmount(data);
1968 free(ubbest);
1969 return 0;
1970 }
1971
1972 if (ospsize < OBJSET_PHYS_SIZE_V14) {
1973 printf("osp too small\n");
1974 zfs_unmount(data);
1975 free(osp);
1976 free(ubbest);
1977 return 0;
1978 }
1979
1980 /* Got the MOS. Save it at the memory addr MOS. */
1981 memmove(&(data->mos.dn), &((objset_phys_t *) osp)->os_meta_dnode, DNODE_SIZE);
1982 data->mos.endian =
1983 (zfs_to_cpu64(ubbest->ub_rootbp.blk_prop, ub_endian) >> 63) & 1;
1984 memmove(&(data->current_uberblock), ubbest, sizeof(uberblock_t));
1985
1986 free(osp);
1987 free(ubbest);
1988
1989 return data;
1990 }
1991
1992 int
1993 zfs_fetch_nvlist(device_t dev, char **nvlist)
1994 {
1995 struct zfs_data *zfs;
1996 int err;
1997
1998 zfs = zfs_mount(dev);
1999 if (!zfs)
2000 return ZFS_ERR_BAD_FS;
2001 err = int_zfs_fetch_nvlist(zfs, nvlist);
2002 zfs_unmount(zfs);
2003 return err;
2004 }
2005
2006 /*
2007 * zfs_open() locates a file in the rootpool by following the
2008 * MOS and places the dnode of the file in the memory address DNODE.
2009 */
2010 int
2011 zfs_open(struct zfs_file *file, const char *fsfilename)
2012 {
2013 struct zfs_data *data;
2014 int err;
2015 int isfs;
2016
2017 data = zfs_mount(file->device);
2018 if (!data)
2019 return ZFS_ERR_BAD_FS;
2020
2021 err = dnode_get_fullpath(fsfilename, &(data->mdn), 0,
2022 &(data->dnode), &isfs, data);
2023 if (err) {
2024 zfs_unmount(data);
2025 return err;
2026 }
2027
2028 if (isfs) {
2029 zfs_unmount(data);
2030 printf("Missing @ or / separator\n");
2031 return ZFS_ERR_FILE_NOT_FOUND;
2032 }
2033
2034 /* We found the dnode for this file. Verify if it is a plain file. */
2035 if (data->dnode.dn.dn_type != DMU_OT_PLAIN_FILE_CONTENTS) {
2036 zfs_unmount(data);
2037 printf("not a file\n");
2038 return ZFS_ERR_BAD_FILE_TYPE;
2039 }
2040
2041 /* get the file size and set the file position to 0 */
2042
2043 /*
2044 * For DMU_OT_SA we will need to locate the SIZE attribute
2045 * attribute, which could be either in the bonus buffer
2046 * or the "spill" block.
2047 */
2048 if (data->dnode.dn.dn_bonustype == DMU_OT_SA) {
2049 void *sahdrp;
2050 int hdrsize;
2051
2052 if (data->dnode.dn.dn_bonuslen != 0) {
2053 sahdrp = (sa_hdr_phys_t *) DN_BONUS(&data->dnode.dn);
2054 } else if (data->dnode.dn.dn_flags & DNODE_FLAG_SPILL_BLKPTR) {
2055 blkptr_t *bp = &data->dnode.dn.dn_spill;
2056
2057 err = zio_read(bp, data->dnode.endian, &sahdrp, NULL, data);
2058 if (err)
2059 return err;
2060 } else {
2061 printf("filesystem is corrupt :(\n");
2062 return ZFS_ERR_BAD_FS;
2063 }
2064
2065 hdrsize = SA_HDR_SIZE(((sa_hdr_phys_t *) sahdrp));
2066 file->size = *(uint64_t *) ((char *) sahdrp + hdrsize + SA_SIZE_OFFSET);
2067 } else {
2068 file->size = zfs_to_cpu64(((znode_phys_t *) DN_BONUS(&data->dnode.dn))->zp_size, data->dnode.endian);
2069 }
2070
2071 file->data = data;
2072 file->offset = 0;
2073
2074 return ZFS_ERR_NONE;
2075 }
2076
2077 uint64_t
2078 zfs_read(zfs_file_t file, char *buf, uint64_t len)
2079 {
2080 struct zfs_data *data = (struct zfs_data *) file->data;
2081 int blksz, movesize;
2082 uint64_t length;
2083 int64_t red;
2084 int err;
2085
2086 if (data->file_buf == NULL) {
2087 data->file_buf = malloc(SPA_MAXBLOCKSIZE);
2088 if (!data->file_buf)
2089 return -1;
2090 data->file_start = data->file_end = 0;
2091 }
2092
2093 /*
2094 * If offset is in memory, move it into the buffer provided and return.
2095 */
2096 if (file->offset >= data->file_start
2097 && file->offset + len <= data->file_end) {
2098 memmove(buf, data->file_buf + file->offset - data->file_start,
2099 len);
2100 return len;
2101 }
2102
2103 blksz = zfs_to_cpu16(data->dnode.dn.dn_datablkszsec,
2104 data->dnode.endian) << SPA_MINBLOCKSHIFT;
2105
2106 /*
2107 * Entire Dnode is too big to fit into the space available. We
2108 * will need to read it in chunks. This could be optimized to
2109 * read in as large a chunk as there is space available, but for
2110 * now, this only reads in one data block at a time.
2111 */
2112 length = len;
2113 red = 0;
2114 while (length) {
2115 void *t;
2116 /*
2117 * Find requested blkid and the offset within that block.
2118 */
2119 uint64_t blkid = file->offset + red;
2120 blkid = do_div(blkid, blksz);
2121 free(data->file_buf);
2122 data->file_buf = 0;
2123
2124 err = dmu_read(&(data->dnode), blkid, &t,
2125 0, data);
2126 data->file_buf = t;
2127 if (err)
2128 return -1;
2129
2130 data->file_start = blkid * blksz;
2131 data->file_end = data->file_start + blksz;
2132
2133 movesize = MIN(length, data->file_end - (int) file->offset - red);
2134
2135 memmove(buf, data->file_buf + file->offset + red
2136 - data->file_start, movesize);
2137 buf += movesize;
2138 length -= movesize;
2139 red += movesize;
2140 }
2141
2142 return len;
2143 }
2144
2145 int
2146 zfs_close(zfs_file_t file)
2147 {
2148 zfs_unmount((struct zfs_data *) file->data);
2149 return ZFS_ERR_NONE;
2150 }
2151
2152 int
2153 zfs_getmdnobj(device_t dev, const char *fsfilename,
2154 uint64_t *mdnobj)
2155 {
2156 struct zfs_data *data;
2157 int err;
2158 int isfs;
2159
2160 data = zfs_mount(dev);
2161 if (!data)
2162 return ZFS_ERR_BAD_FS;
2163
2164 err = dnode_get_fullpath(fsfilename, &(data->mdn), mdnobj,
2165 &(data->dnode), &isfs, data);
2166 zfs_unmount(data);
2167 return err;
2168 }
2169
2170 static void
2171 fill_fs_info(struct zfs_dirhook_info *info,
2172 dnode_end_t mdn, struct zfs_data *data)
2173 {
2174 int err;
2175 dnode_end_t dn;
2176 uint64_t objnum;
2177 uint64_t headobj;
2178
2179 memset(info, 0, sizeof(*info));
2180
2181 info->dir = 1;
2182
2183 if (mdn.dn.dn_type == DMU_OT_DSL_DIR) {
2184 headobj = zfs_to_cpu64(((dsl_dir_phys_t *) DN_BONUS(&mdn.dn))->dd_head_dataset_obj, mdn.endian);
2185
2186 err = dnode_get(&(data->mos), headobj, DMU_OT_DSL_DATASET, &mdn, data);
2187 if (err) {
2188 printf("zfs failed here 1\n");
2189 return;
2190 }
2191 }
2192 make_mdn(&mdn, data);
2193 err = dnode_get(&mdn, MASTER_NODE_OBJ, DMU_OT_MASTER_NODE,
2194 &dn, data);
2195 if (err) {
2196 printf("zfs failed here 2\n");
2197 return;
2198 }
2199
2200 err = zap_lookup(&dn, ZFS_ROOT_OBJ, &objnum, data);
2201 if (err) {
2202 printf("zfs failed here 3\n");
2203 return;
2204 }
2205
2206 err = dnode_get(&mdn, objnum, 0, &dn, data);
2207 if (err) {
2208 printf("zfs failed here 4\n");
2209 return;
2210 }
2211
2212 info->mtimeset = 1;
2213 info->mtime = zfs_to_cpu64(((znode_phys_t *) DN_BONUS(&dn.dn))->zp_mtime[0], dn.endian);
2214
2215 return;
2216 }
2217
2218 static int iterate_zap(const char *name, uint64_t val, struct zfs_data *data)
2219 {
2220 struct zfs_dirhook_info info;
2221 dnode_end_t dn;
2222
2223 memset(&info, 0, sizeof(info));
2224
2225 dnode_get(&(data->mdn), val, 0, &dn, data);
2226 info.mtimeset = 1;
2227 info.mtime = zfs_to_cpu64(((znode_phys_t *) DN_BONUS(&dn.dn))->zp_mtime[0], dn.endian);
2228 info.dir = (dn.dn.dn_type == DMU_OT_DIRECTORY_CONTENTS);
2229 debug("zfs type=%d, name=%s\n",
2230 (int)dn.dn.dn_type, (char *)name);
2231 if (!data->userhook)
2232 return 0;
2233 return data->userhook(name, &info);
2234 }
2235
2236 static int iterate_zap_fs(const char *name, uint64_t val, struct zfs_data *data)
2237 {
2238 struct zfs_dirhook_info info;
2239 dnode_end_t mdn;
2240 int err;
2241 err = dnode_get(&(data->mos), val, 0, &mdn, data);
2242 if (err)
2243 return 0;
2244 if (mdn.dn.dn_type != DMU_OT_DSL_DIR)
2245 return 0;
2246
2247 fill_fs_info(&info, mdn, data);
2248
2249 if (!data->userhook)
2250 return 0;
2251 return data->userhook(name, &info);
2252 }
2253
2254 static int iterate_zap_snap(const char *name, uint64_t val, struct zfs_data *data)
2255 {
2256 struct zfs_dirhook_info info;
2257 char *name2;
2258 int ret = 0;
2259 dnode_end_t mdn;
2260 int err;
2261
2262 err = dnode_get(&(data->mos), val, 0, &mdn, data);
2263 if (err)
2264 return 0;
2265
2266 if (mdn.dn.dn_type != DMU_OT_DSL_DATASET)
2267 return 0;
2268
2269 fill_fs_info(&info, mdn, data);
2270
2271 name2 = malloc(strlen(name) + 2);
2272 name2[0] = '@';
2273 memcpy(name2 + 1, name, strlen(name) + 1);
2274 if (data->userhook)
2275 ret = data->userhook(name2, &info);
2276 free(name2);
2277 return ret;
2278 }
2279
2280 int
2281 zfs_ls(device_t device, const char *path,
2282 int (*hook)(const char *, const struct zfs_dirhook_info *))
2283 {
2284 struct zfs_data *data;
2285 int err;
2286 int isfs;
2287
2288 data = zfs_mount(device);
2289 if (!data)
2290 return ZFS_ERR_BAD_FS;
2291
2292 data->userhook = hook;
2293
2294 err = dnode_get_fullpath(path, &(data->mdn), 0, &(data->dnode), &isfs, data);
2295 if (err) {
2296 zfs_unmount(data);
2297 return err;
2298 }
2299 if (isfs) {
2300 uint64_t childobj, headobj;
2301 uint64_t snapobj;
2302 dnode_end_t dn;
2303 struct zfs_dirhook_info info;
2304
2305 fill_fs_info(&info, data->dnode, data);
2306 hook("@", &info);
2307
2308 childobj = zfs_to_cpu64(((dsl_dir_phys_t *) DN_BONUS(&data->dnode.dn))->dd_child_dir_zapobj, data->dnode.endian);
2309 headobj = zfs_to_cpu64(((dsl_dir_phys_t *) DN_BONUS(&data->dnode.dn))->dd_head_dataset_obj, data->dnode.endian);
2310 err = dnode_get(&(data->mos), childobj,
2311 DMU_OT_DSL_DIR_CHILD_MAP, &dn, data);
2312 if (err) {
2313 zfs_unmount(data);
2314 return err;
2315 }
2316
2317
2318 zap_iterate(&dn, iterate_zap_fs, data);
2319
2320 err = dnode_get(&(data->mos), headobj, DMU_OT_DSL_DATASET, &dn, data);
2321 if (err) {
2322 zfs_unmount(data);
2323 return err;
2324 }
2325
2326 snapobj = zfs_to_cpu64(((dsl_dataset_phys_t *) DN_BONUS(&dn.dn))->ds_snapnames_zapobj, dn.endian);
2327
2328 err = dnode_get(&(data->mos), snapobj,
2329 DMU_OT_DSL_DS_SNAP_MAP, &dn, data);
2330 if (err) {
2331 zfs_unmount(data);
2332 return err;
2333 }
2334
2335 zap_iterate(&dn, iterate_zap_snap, data);
2336 } else {
2337 if (data->dnode.dn.dn_type != DMU_OT_DIRECTORY_CONTENTS) {
2338 zfs_unmount(data);
2339 printf("not a directory\n");
2340 return ZFS_ERR_BAD_FILE_TYPE;
2341 }
2342 zap_iterate(&(data->dnode), iterate_zap, data);
2343 }
2344 zfs_unmount(data);
2345 return ZFS_ERR_NONE;
2346 }
"Das U-Boot" Source Tree