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