zfsimpl.c revision 42b4b09e4b7ff97dc2592e69bbc2aff411cb9e55
1199767fToomas Soome/*-
2199767fToomas Soome * Copyright (c) 2007 Doug Rabson
3199767fToomas Soome * All rights reserved.
4199767fToomas Soome *
5199767fToomas Soome * Redistribution and use in source and binary forms, with or without
6199767fToomas Soome * modification, are permitted provided that the following conditions
7199767fToomas Soome * are met:
8199767fToomas Soome * 1. Redistributions of source code must retain the above copyright
9199767fToomas Soome *    notice, this list of conditions and the following disclaimer.
10199767fToomas Soome * 2. Redistributions in binary form must reproduce the above copyright
11199767fToomas Soome *    notice, this list of conditions and the following disclaimer in the
12199767fToomas Soome *    documentation and/or other materials provided with the distribution.
13199767fToomas Soome *
24199767fToomas Soome * SUCH DAMAGE.
25199767fToomas Soome */
26199767fToomas Soome
27199767fToomas Soome#include <sys/cdefs.h>
28199767fToomas Soome
29199767fToomas Soome/*
30199767fToomas Soome *	Stand-alone ZFS file reader.
31199767fToomas Soome */
32199767fToomas Soome
3313a6e30Toomas Soome#include <sys/endian.h>
34199767fToomas Soome#include <sys/stat.h>
35199767fToomas Soome#include <sys/stdint.h>
36199767fToomas Soome
37199767fToomas Soome#include "zfsimpl.h"
38199767fToomas Soome#include "zfssubr.c"
39199767fToomas Soome
40199767fToomas Soome
41199767fToomas Soomestruct zfsmount {
42199767fToomas Soome	const spa_t	*spa;
43199767fToomas Soome	objset_phys_t	objset;
44199767fToomas Soome	uint64_t	rootobj;
45199767fToomas Soome};
46199767fToomas Soome
47199767fToomas Soome/*
48199767fToomas Soome * List of all vdevs, chained through v_alllink.
49199767fToomas Soome */
50199767fToomas Soomestatic vdev_list_t zfs_vdevs;
51199767fToomas Soome
52199767fToomas Soome /*
53199767fToomas Soome * List of ZFS features supported for read
54199767fToomas Soome */
55199767fToomas Soomestatic const char *features_for_read[] = {
56199767fToomas Soome	"org.illumos:lz4_compress",
57199767fToomas Soome	"com.delphix:hole_birth",
58199767fToomas Soome	"com.delphix:extensible_dataset",
59199767fToomas Soome	"com.delphix:embedded_data",
60199767fToomas Soome	"org.open-zfs:large_blocks",
61199767fToomas Soome	"org.illumos:sha512",
624a04e8dToomas Soome	"org.illumos:skein",
634a04e8dToomas Soome	"org.illumos:edonr",
64f905073Toomas Soome	"org.zfsonlinux:large_dnode",
656f8e6e5Alex Wilson	"com.joyent:multi_vdev_crash_dump",
6642b4b09Andy Fiddaman	"com.delphix:spacemap_histogram",
6742b4b09Andy Fiddaman	"com.delphix:zpool_checkpoint",
6842b4b09Andy Fiddaman	"com.delphix:spacemap_v2",
6942b4b09Andy Fiddaman	"com.datto:encryption",
7042b4b09Andy Fiddaman	"com.datto:bookmark_v2",
7142b4b09Andy Fiddaman	"org.zfsonlinux:allocation_classes",
7242b4b09Andy Fiddaman	"com.datto:resilver_defer",
73199767fToomas Soome	NULL
74199767fToomas Soome};
75199767fToomas Soome
76199767fToomas Soome/*
77199767fToomas Soome * List of all pools, chained through spa_link.
78199767fToomas Soome */
79199767fToomas Soomestatic spa_list_t zfs_pools;
80199767fToomas Soome
81edb3504Toomas Soomestatic const dnode_phys_t *dnode_cache_obj;
82199767fToomas Soomestatic uint64_t dnode_cache_bn;
83199767fToomas Soomestatic char *dnode_cache_buf;
84199767fToomas Soomestatic char *zap_scratch;
85199767fToomas Soomestatic char *zfs_temp_buf, *zfs_temp_end, *zfs_temp_ptr;
86199767fToomas Soome
87199767fToomas Soome#define TEMP_SIZE	(1024 * 1024)
88199767fToomas Soome
89199767fToomas Soomestatic int zio_read(const spa_t *spa, const blkptr_t *bp, void *buf);
90199767fToomas Soomestatic int zfs_get_root(const spa_t *spa, uint64_t *objid);
91199767fToomas Soomestatic int zfs_rlookup(const spa_t *spa, uint64_t objnum, char *result);
924a04e8dToomas Soomestatic int zap_lookup(const spa_t *spa, const dnode_phys_t *dnode,
934a04e8dToomas Soome    const char *name, uint64_t integer_size, uint64_t num_integers,
944a04e8dToomas Soome    void *value);
95199767fToomas Soome
96199767fToomas Soomestatic void
97199767fToomas Soomezfs_init(void)
98199767fToomas Soome{
99199767fToomas Soome	STAILQ_INIT(&zfs_vdevs);
100199767fToomas Soome	STAILQ_INIT(&zfs_pools);
101199767fToomas Soome
102199767fToomas Soome	zfs_temp_buf = malloc(TEMP_SIZE);
103199767fToomas Soome	zfs_temp_end = zfs_temp_buf + TEMP_SIZE;
104199767fToomas Soome	zfs_temp_ptr = zfs_temp_buf;
105199767fToomas Soome	dnode_cache_buf = malloc(SPA_MAXBLOCKSIZE);
106199767fToomas Soome	zap_scratch = malloc(SPA_MAXBLOCKSIZE);
107199767fToomas Soome
108199767fToomas Soome	zfs_init_crc();
109199767fToomas Soome}
110199767fToomas Soome
111199767fToomas Soomestatic void *
112199767fToomas Soomezfs_alloc(size_t size)
113199767fToomas Soome{
114199767fToomas Soome	char *ptr;
115199767fToomas Soome
116199767fToomas Soome	if (zfs_temp_ptr + size > zfs_temp_end) {
117b5b5d63Toomas Soome		panic("ZFS: out of temporary buffer space");
118199767fToomas Soome	}
119199767fToomas Soome	ptr = zfs_temp_ptr;
120199767fToomas Soome	zfs_temp_ptr += size;
121199767fToomas Soome
122199767fToomas Soome	return (ptr);
123199767fToomas Soome}
124199767fToomas Soome
125199767fToomas Soomestatic void
126199767fToomas Soomezfs_free(void *ptr, size_t size)
127199767fToomas Soome{
128199767fToomas Soome
129199767fToomas Soome	zfs_temp_ptr -= size;
130199767fToomas Soome	if (zfs_temp_ptr != ptr) {
131b5b5d63Toomas Soome		panic("ZFS: zfs_alloc()/zfs_free() mismatch");
132199767fToomas Soome	}
133199767fToomas Soome}
134199767fToomas Soome
135199767fToomas Soomestatic int
136199767fToomas Soomexdr_int(const unsigned char **xdr, int *ip)
137199767fToomas Soome{
13813a6e30Toomas Soome	*ip = be32dec(*xdr);
139199767fToomas Soome	(*xdr) += 4;
140199767fToomas Soome	return (0);
141199767fToomas Soome}
142199767fToomas Soome
143199767fToomas Soomestatic int
144199767fToomas Soomexdr_u_int(const unsigned char **xdr, u_int *ip)
145199767fToomas Soome{
14613a6e30Toomas Soome	*ip = be32dec(*xdr);
147199767fToomas Soome	(*xdr) += 4;
148199767fToomas Soome	return (0);
149199767fToomas Soome}
150199767fToomas Soome
151199767fToomas Soomestatic int
152199767fToomas Soomexdr_uint64_t(const unsigned char **xdr, uint64_t *lp)
153199767fToomas Soome{
154199767fToomas Soome	u_int hi, lo;
155199767fToomas Soome
156199767fToomas Soome	xdr_u_int(xdr, &hi);
157199767fToomas Soome	xdr_u_int(xdr, &lo);
158199767fToomas Soome	*lp = (((uint64_t) hi) << 32) | lo;
159199767fToomas Soome	return (0);
160199767fToomas Soome}
161199767fToomas Soome
162199767fToomas Soomestatic int
163199767fToomas Soomenvlist_find(const unsigned char *nvlist, const char *name, int type,
164199767fToomas Soome	    int* elementsp, void *valuep)
165199767fToomas Soome{
166199767fToomas Soome	const unsigned char *p, *pair;
167199767fToomas Soome	int junk;
168199767fToomas Soome	int encoded_size, decoded_size;
169199767fToomas Soome
170199767fToomas Soome	p = nvlist;
171199767fToomas Soome	xdr_int(&p, &junk);
172199767fToomas Soome	xdr_int(&p, &junk);
173199767fToomas Soome
174199767fToomas Soome	pair = p;
175199767fToomas Soome	xdr_int(&p, &encoded_size);
176199767fToomas Soome	xdr_int(&p, &decoded_size);
177199767fToomas Soome	while (encoded_size && decoded_size) {
178199767fToomas Soome		int namelen, pairtype, elements;
179199767fToomas Soome		const char *pairname;
180199767fToomas Soome
181199767fToomas Soome		xdr_int(&p, &namelen);
182199767fToomas Soome		pairname = (const char*) p;
183199767fToomas Soome		p += roundup(namelen, 4);
184199767fToomas Soome		xdr_int(&p, &pairtype);
185199767fToomas Soome
186199767fToomas Soome		if (!memcmp(name, pairname, namelen) && type == pairtype) {
187199767fToomas Soome			xdr_int(&p, &elements);
188199767fToomas Soome			if (elementsp)
189199767fToomas Soome				*elementsp = elements;
190199767fToomas Soome			if (type == DATA_TYPE_UINT64) {
191199767fToomas Soome				xdr_uint64_t(&p, (uint64_t *) valuep);
192199767fToomas Soome				return (0);
193199767fToomas Soome			} else if (type == DATA_TYPE_STRING) {
194199767fToomas Soome				int len;
195199767fToomas Soome				xdr_int(&p, &len);
196199767fToomas Soome				(*(const char**) valuep) = (const char*) p;
197199767fToomas Soome				return (0);
198199767fToomas Soome			} else if (type == DATA_TYPE_NVLIST
199199767fToomas Soome				   || type == DATA_TYPE_NVLIST_ARRAY) {
200199767fToomas Soome				(*(const unsigned char**) valuep) =
201199767fToomas Soome					 (const unsigned char*) p;
202199767fToomas Soome				return (0);
203199767fToomas Soome			} else {
204199767fToomas Soome				return (EIO);
205199767fToomas Soome			}
206199767fToomas Soome		} else {
207199767fToomas Soome			/*
208199767fToomas Soome			 * Not the pair we are looking for, skip to the next one.
209199767fToomas Soome			 */
210199767fToomas Soome			p = pair + encoded_size;
211199767fToomas Soome		}
212199767fToomas Soome
213199767fToomas Soome		pair = p;
214199767fToomas Soome		xdr_int(&p, &encoded_size);
215199767fToomas Soome		xdr_int(&p, &decoded_size);
216199767fToomas Soome	}
217199767fToomas Soome
218199767fToomas Soome	return (EIO);
219199767fToomas Soome}
220199767fToomas Soome
221199767fToomas Soomestatic int
222199767fToomas Soomenvlist_check_features_for_read(const unsigned char *nvlist)
223199767fToomas Soome{
224199767fToomas Soome	const unsigned char *p, *pair;
225199767fToomas Soome	int junk;
226199767fToomas Soome	int encoded_size, decoded_size;
227199767fToomas Soome	int rc;
228199767fToomas Soome
229199767fToomas Soome	rc = 0;
230199767fToomas Soome
231199767fToomas Soome	p = nvlist;
232199767fToomas Soome	xdr_int(&p, &junk);
233199767fToomas Soome	xdr_int(&p, &junk);
234199767fToomas Soome
235199767fToomas Soome	pair = p;
236199767fToomas Soome	xdr_int(&p, &encoded_size);
237199767fToomas Soome	xdr_int(&p, &decoded_size);
238199767fToomas Soome	while (encoded_size && decoded_size) {
239199767fToomas Soome		int namelen, pairtype;
240199767fToomas Soome		const char *pairname;
241199767fToomas Soome		int i, found;
242199767fToomas Soome
243199767fToomas Soome		found = 0;
244199767fToomas Soome
245199767fToomas Soome		xdr_int(&p, &namelen);
246199767fToomas Soome		pairname = (const char*) p;
247199767fToomas Soome		p += roundup(namelen, 4);
248199767fToomas Soome		xdr_int(&p, &pairtype);
249199767fToomas Soome
250199767fToomas Soome		for (i = 0; features_for_read[i] != NULL; i++) {
251199767fToomas Soome			if (!memcmp(pairname, features_for_read[i], namelen)) {
252199767fToomas Soome				found = 1;
253199767fToomas Soome				break;
254199767fToomas Soome			}
255199767fToomas Soome		}
256199767fToomas Soome
257199767fToomas Soome		if (!found) {
258199767fToomas Soome			printf("ZFS: unsupported feature: %s\n", pairname);
259199767fToomas Soome			rc = EIO;
260199767fToomas Soome		}
261199767fToomas Soome
262199767fToomas Soome		p = pair + encoded_size;
263199767fToomas Soome
264199767fToomas Soome		pair = p;
265199767fToomas Soome		xdr_int(&p, &encoded_size);
266199767fToomas Soome		xdr_int(&p, &decoded_size);
267199767fToomas Soome	}
268199767fToomas Soome
269199767fToomas Soome	return (rc);
270199767fToomas Soome}
271199767fToomas Soome
272199767fToomas Soome/*
273199767fToomas Soome * Return the next nvlist in an nvlist array.
274199767fToomas Soome */
275199767fToomas Soomestatic const unsigned char *
276199767fToomas Soomenvlist_next(const unsigned char *nvlist)
277199767fToomas Soome{
278199767fToomas Soome	const unsigned char *p, *pair;
279199767fToomas Soome	int junk;
280199767fToomas Soome	int encoded_size, decoded_size;
281199767fToomas Soome
282199767fToomas Soome	p = nvlist;
283199767fToomas Soome	xdr_int(&p, &junk);
284199767fToomas Soome	xdr_int(&p, &junk);
285199767fToomas Soome
286199767fToomas Soome	pair = p;
287199767fToomas Soome	xdr_int(&p, &encoded_size);
288199767fToomas Soome	xdr_int(&p, &decoded_size);
289199767fToomas Soome	while (encoded_size && decoded_size) {
290199767fToomas Soome		p = pair + encoded_size;
291199767fToomas Soome
292199767fToomas Soome		pair = p;
293199767fToomas Soome		xdr_int(&p, &encoded_size);
294199767fToomas Soome		xdr_int(&p, &decoded_size);
295199767fToomas Soome	}
296199767fToomas Soome
297199767fToomas Soome	return p;
298199767fToomas Soome}
299199767fToomas Soome
300199767fToomas Soome#ifdef TEST
301199767fToomas Soome
302199767fToomas Soomestatic const unsigned char *
303199767fToomas Soomenvlist_print(const unsigned char *nvlist, unsigned int indent)
304199767fToomas Soome{
305199767fToomas Soome	static const char* typenames[] = {
306199767fToomas Soome		"DATA_TYPE_UNKNOWN",
307199767fToomas Soome		"DATA_TYPE_BOOLEAN",
308199767fToomas Soome		"DATA_TYPE_BYTE",
309199767fToomas Soome		"DATA_TYPE_INT16",
310199767fToomas Soome		"DATA_TYPE_UINT16",
311199767fToomas Soome		"DATA_TYPE_INT32",
312199767fToomas Soome		"DATA_TYPE_UINT32",
313199767fToomas Soome		"DATA_TYPE_INT64",
314199767fToomas Soome		"DATA_TYPE_UINT64",
315199767fToomas Soome		"DATA_TYPE_STRING",
316199767fToomas Soome		"DATA_TYPE_BYTE_ARRAY",
317199767fToomas Soome		"DATA_TYPE_INT16_ARRAY",
318199767fToomas Soome		"DATA_TYPE_UINT16_ARRAY",
319199767fToomas Soome		"DATA_TYPE_INT32_ARRAY",
320199767fToomas Soome		"DATA_TYPE_UINT32_ARRAY",
321199767fToomas Soome		"DATA_TYPE_INT64_ARRAY",
322199767fToomas Soome		"DATA_TYPE_UINT64_ARRAY",
323199767fToomas Soome		"DATA_TYPE_STRING_ARRAY",
324199767fToomas Soome		"DATA_TYPE_HRTIME",
325199767fToomas Soome		"DATA_TYPE_NVLIST",
326199767fToomas Soome		"DATA_TYPE_NVLIST_ARRAY",
327199767fToomas Soome		"DATA_TYPE_BOOLEAN_VALUE",
328199767fToomas Soome		"DATA_TYPE_INT8",
329199767fToomas Soome		"DATA_TYPE_UINT8",
330199767fToomas Soome		"DATA_TYPE_BOOLEAN_ARRAY",
331199767fToomas Soome		"DATA_TYPE_INT8_ARRAY",
332199767fToomas Soome		"DATA_TYPE_UINT8_ARRAY"
333199767fToomas Soome	};
334199767fToomas Soome
335199767fToomas Soome	unsigned int i, j;
336199767fToomas Soome	const unsigned char *p, *pair;
337199767fToomas Soome	int junk;
338199767fToomas Soome	int encoded_size, decoded_size;
339199767fToomas Soome
340199767fToomas Soome	p = nvlist;
341199767fToomas Soome	xdr_int(&p, &junk);
342199767fToomas Soome	xdr_int(&p, &junk);
343199767fToomas Soome
344199767fToomas Soome	pair = p;
345199767fToomas Soome	xdr_int(&p, &encoded_size);
346199767fToomas Soome	xdr_int(&p, &decoded_size);
347199767fToomas Soome	while (encoded_size && decoded_size) {
348199767fToomas Soome		int namelen, pairtype, elements;
349199767fToomas Soome		const char *pairname;
350199767fToomas Soome
351199767fToomas Soome		xdr_int(&p, &namelen);
352199767fToomas Soome		pairname = (const char*) p;
353199767fToomas Soome		p += roundup(namelen, 4);
354199767fToomas Soome		xdr_int(&p, &pairtype);
355199767fToomas Soome
356199767fToomas Soome		for (i = 0; i < indent; i++)
357199767fToomas Soome			printf(" ");
358199767fToomas Soome		printf("%s %s", typenames[pairtype], pairname);
359199767fToomas Soome
360199767fToomas Soome		xdr_int(&p, &elements);
361199767fToomas Soome		switch (pairtype) {
362199767fToomas Soome		case DATA_TYPE_UINT64: {
363199767fToomas Soome			uint64_t val;
364199767fToomas Soome			xdr_uint64_t(&p, &val);
365199767fToomas Soome			printf(" = 0x%jx\n", (uintmax_t)val);
366199767fToomas Soome			break;
367199767fToomas Soome		}
368199767fToomas Soome
369199767fToomas Soome		case DATA_TYPE_STRING: {
370199767fToomas Soome			int len;
371199767fToomas Soome			xdr_int(&p, &len);
372199767fToomas Soome			printf(" = \"%s\"\n", p);
373199767fToomas Soome			break;
374199767fToomas Soome		}
375199767fToomas Soome
376199767fToomas Soome		case DATA_TYPE_NVLIST:
377199767fToomas Soome			printf("\n");
378199767fToomas Soome			nvlist_print(p, indent + 1);
379199767fToomas Soome			break;
380199767fToomas Soome
381199767fToomas Soome		case DATA_TYPE_NVLIST_ARRAY:
382199767fToomas Soome			for (j = 0; j < elements; j++) {
383199767fToomas Soome				printf("[%d]\n", j);
384199767fToomas Soome				p = nvlist_print(p, indent + 1);
385199767fToomas Soome				if (j != elements - 1) {
386199767fToomas Soome					for (i = 0; i < indent; i++)
387199767fToomas Soome						printf(" ");
388199767fToomas Soome					printf("%s %s", typenames[pairtype], pairname);
389199767fToomas Soome				}
390199767fToomas Soome			}
391199767fToomas Soome			break;
392199767fToomas Soome
393199767fToomas Soome		default:
394199767fToomas Soome			printf("\n");
395199767fToomas Soome		}
396199767fToomas Soome
397199767fToomas Soome		p = pair + encoded_size;
398199767fToomas Soome
399199767fToomas Soome		pair = p;
400199767fToomas Soome		xdr_int(&p, &encoded_size);
401199767fToomas Soome		xdr_int(&p, &decoded_size);
402199767fToomas Soome	}
403199767fToomas Soome
404199767fToomas Soome	return p;
405199767fToomas Soome}
406199767fToomas Soome
407199767fToomas Soome#endif
408199767fToomas Soome
409199767fToomas Soomestatic int
410199767fToomas Soomevdev_read_phys(vdev_t *vdev, const blkptr_t *bp, void *buf,
411199767fToomas Soome    off_t offset, size_t size)
412199767fToomas Soome{
413199767fToomas Soome	size_t psize;
414199767fToomas Soome	int rc;
415199767fToomas Soome
416199767fToomas Soome	if (!vdev->v_phys_read)
417199767fToomas Soome		return (EIO);
418199767fToomas Soome
419199767fToomas Soome	if (bp) {
420199767fToomas Soome		psize = BP_GET_PSIZE(bp);
421199767fToomas Soome	} else {
422199767fToomas Soome		psize = size;
423199767fToomas Soome	}
424199767fToomas Soome
425f905073Toomas Soome	/*printf("ZFS: reading %zu bytes at 0x%jx to %p\n", psize, (uintmax_t)offset, buf);*/
426199767fToomas Soome	rc = vdev->v_phys_read(vdev, vdev->v_read_priv, offset, buf, psize);
427199767fToomas Soome	if (rc)
428199767fToomas Soome		return (rc);
4294a04e8dToomas Soome	if (bp && zio_checksum_verify(vdev->spa, bp, buf))
430199767fToomas Soome		return (EIO);
431199767fToomas Soome
432199767fToomas Soome	return (0);
433199767fToomas Soome}
434199767fToomas Soome
435199767fToomas Soomestatic int
436199767fToomas Soomevdev_disk_read(vdev_t *vdev, const blkptr_t *bp, void *buf,
437199767fToomas Soome    off_t offset, size_t bytes)
438199767fToomas Soome{
439199767fToomas Soome
440199767fToomas Soome	return (vdev_read_phys(vdev, bp, buf,
441199767fToomas Soome		offset + VDEV_LABEL_START_SIZE, bytes));
442199767fToomas Soome}
443199767fToomas Soome
444199767fToomas Soome
445199767fToomas Soomestatic int
446199767fToomas Soomevdev_mirror_read(vdev_t *vdev, const blkptr_t *bp, void *buf,
447199767fToomas Soome    off_t offset, size_t bytes)
448199767fToomas Soome{
449199767fToomas Soome	vdev_t *kid;
450199767fToomas Soome	int rc;
451199767fToomas Soome
452199767fToomas Soome	rc = EIO;
453199767fToomas Soome	STAILQ_FOREACH(kid, &vdev->v_children, v_childlink) {
454199767fToomas Soome		if (kid->v_state != VDEV_STATE_HEALTHY)
455199767fToomas Soome			continue;
456199767fToomas Soome		rc = kid->v_read(kid, bp, buf, offset, bytes);
457199767fToomas Soome		if (!rc)
458199767fToomas Soome			return (0);
459199767fToomas Soome	}
460199767fToomas Soome
461199767fToomas Soome	return (rc);
462199767fToomas Soome}
463199767fToomas Soome
464199767fToomas Soomestatic int
465199767fToomas Soomevdev_replacing_read(vdev_t *vdev, const blkptr_t *bp, void *buf,
466199767fToomas Soome    off_t offset, size_t bytes)
467199767fToomas Soome{
468199767fToomas Soome	vdev_t *kid;
469199767fToomas Soome
470199767fToomas Soome	/*
471199767fToomas Soome	 * Here we should have two kids:
472199767fToomas Soome	 * First one which is the one we are replacing and we can trust
473199767fToomas Soome	 * only this one to have valid data, but it might not be present.
474199767fToomas Soome	 * Second one is that one we are replacing with. It is most likely
475199767fToomas Soome	 * healthy, but we can't trust it has needed data, so we won't use it.
476199767fToomas Soome	 */
477199767fToomas Soome	kid = STAILQ_FIRST(&vdev->v_children);
478199767fToomas Soome	if (kid == NULL)
479199767fToomas Soome		return (EIO);
480199767fToomas Soome	if (kid->v_state != VDEV_STATE_HEALTHY)
481199767fToomas Soome		return (EIO);
482199767fToomas Soome	return (kid->v_read(kid, bp, buf, offset, bytes));
483199767fToomas Soome}
484199767fToomas Soome
485199767fToomas Soomestatic vdev_t *
486199767fToomas Soomevdev_find(uint64_t guid)
487199767fToomas Soome{
488199767fToomas Soome	vdev_t *vdev;
489199767fToomas Soome
490199767fToomas Soome	STAILQ_FOREACH(vdev, &zfs_vdevs, v_alllink)
491199767fToomas Soome		if (vdev->v_guid == guid)
492199767fToomas Soome			return (vdev);
493199767fToomas Soome
494199767fToomas Soome	return (0);
495199767fToomas Soome}
496199767fToomas Soome
497199767fToomas Soomestatic vdev_t *
498199767fToomas Soomevdev_create(uint64_t guid, vdev_read_t *vdev_read)
499199767fToomas Soome{
500199767fToomas Soome	vdev_t *vdev;
501199767fToomas Soome
502199767fToomas Soome	vdev = malloc(sizeof(vdev_t));
503199767fToomas Soome	memset(vdev, 0, sizeof(vdev_t));
504199767fToomas Soome	STAILQ_INIT(&vdev->v_children);
505199767fToomas Soome	vdev->v_guid = guid;
506199767fToomas Soome	vdev->v_state = VDEV_STATE_OFFLINE;
507199767fToomas Soome	vdev->v_read = vdev_read;
508199767fToomas Soome	vdev->v_phys_read = 0;
509199767fToomas Soome	vdev->v_read_priv = 0;
510199767fToomas Soome	STAILQ_INSERT_TAIL(&zfs_vdevs, vdev, v_alllink);
511199767fToomas Soome
512199767fToomas Soome	return (vdev);
513199767fToomas Soome}
514199767fToomas Soome
515199767fToomas Soomestatic int
516199767fToomas Soomevdev_init_from_nvlist(const unsigned char *nvlist, vdev_t *pvdev,
517199767fToomas Soome    vdev_t **vdevp, int is_newer)
518199767fToomas Soome{
519199767fToomas Soome	int rc;
520199767fToomas Soome	uint64_t guid, id, ashift, nparity;
521199767fToomas Soome	const char *type;
522199767fToomas Soome	const char *path;
523199767fToomas Soome	vdev_t *vdev, *kid;
524199767fToomas Soome	const unsigned char *kids;
525199767fToomas Soome	int nkids, i, is_new;
526199767fToomas Soome	uint64_t is_offline, is_faulted, is_degraded, is_removed, isnt_present;
527199767fToomas Soome
528edb3504Toomas Soome	if (nvlist_find(nvlist, ZPOOL_CONFIG_GUID, DATA_TYPE_UINT64,
529edb3504Toomas Soome	    NULL, &guid) ||
530edb3504Toomas Soome	    nvlist_find(nvlist, ZPOOL_CONFIG_ID, DATA_TYPE_UINT64, NULL, &id) ||
531edb3504Toomas Soome	    nvlist_find(nvlist, ZPOOL_CONFIG_TYPE, DATA_TYPE_STRING,
532edb3504Toomas Soome	    NULL, &type)) {
533199767fToomas Soome		printf("ZFS: can't find vdev details\n");
534199767fToomas Soome		return (ENOENT);
535199767fToomas Soome	}
536199767fToomas Soome
537199767fToomas Soome	if (strcmp(type, VDEV_TYPE_MIRROR)
538199767fToomas Soome	    && strcmp(type, VDEV_TYPE_DISK)
539199767fToomas Soome#ifdef ZFS_TEST
540199767fToomas Soome	    && strcmp(type, VDEV_TYPE_FILE)
541199767fToomas Soome#endif
542199767fToomas Soome	    && strcmp(type, VDEV_TYPE_RAIDZ)
543199767fToomas Soome	    && strcmp(type, VDEV_TYPE_REPLACING)) {
544199767fToomas Soome		printf("ZFS: can only boot from disk, mirror, raidz1, raidz2 and raidz3 vdevs\n");
545199767fToomas Soome		return (EIO);
546199767fToomas Soome	}
547199767fToomas Soome
548199767fToomas Soome	is_offline = is_removed = is_faulted = is_degraded = isnt_present = 0;
549199767fToomas Soome
550edb3504Toomas Soome	nvlist_find(nvlist, ZPOOL_CONFIG_OFFLINE, DATA_TYPE_UINT64, NULL,
551edb3504Toomas Soome	    &is_offline);
552edb3504Toomas Soome	nvlist_find(nvlist, ZPOOL_CONFIG_REMOVED, DATA_TYPE_UINT64, NULL,
553edb3504Toomas Soome	    &is_removed);
554edb3504Toomas Soome	nvlist_find(nvlist, ZPOOL_CONFIG_FAULTED, DATA_TYPE_UINT64, NULL,
555edb3504Toomas Soome	    &is_faulted);
556edb3504Toomas Soome	nvlist_find(nvlist, ZPOOL_CONFIG_DEGRADED, DATA_TYPE_UINT64, NULL,
557edb3504Toomas Soome	    &is_degraded);
558edb3504Toomas Soome	nvlist_find(nvlist, ZPOOL_CONFIG_NOT_PRESENT, DATA_TYPE_UINT64, NULL,
559edb3504Toomas Soome	    &isnt_present);
560199767fToomas Soome
561199767fToomas Soome	vdev = vdev_find(guid);
562199767fToomas Soome	if (!vdev) {
563199767fToomas Soome		is_new = 1;
564199767fToomas Soome
565199767fToomas Soome		if (!strcmp(type, VDEV_TYPE_MIRROR))
566199767fToomas Soome			vdev = vdev_create(guid, vdev_mirror_read);
567199767fToomas Soome		else if (!strcmp(type, VDEV_TYPE_RAIDZ))
568199767fToomas Soome			vdev = vdev_create(guid, vdev_raidz_read);
569199767fToomas Soome		else if (!strcmp(type, VDEV_TYPE_REPLACING))
570199767fToomas Soome			vdev = vdev_create(guid, vdev_replacing_read);
571199767fToomas Soome		else
572199767fToomas Soome			vdev = vdev_create(guid, vdev_disk_read);
573199767fToomas Soome
574199767fToomas Soome		vdev->v_id = id;
575199767fToomas Soome		vdev->v_top = pvdev != NULL ? pvdev : vdev;
576199767fToomas Soome		if (nvlist_find(nvlist, ZPOOL_CONFIG_ASHIFT,
577edb3504Toomas Soome		    DATA_TYPE_UINT64, NULL, &ashift) == 0) {
578199767fToomas Soome			vdev->v_ashift = ashift;
579edb3504Toomas Soome		} else {
580199767fToomas Soome			vdev->v_ashift = 0;
581edb3504Toomas Soome		}
582199767fToomas Soome		if (nvlist_find(nvlist, ZPOOL_CONFIG_NPARITY,
583edb3504Toomas Soome		    DATA_TYPE_UINT64, NULL, &nparity) == 0) {
584199767fToomas Soome			vdev->v_nparity = nparity;
585edb3504Toomas Soome		} else {
586199767fToomas Soome			vdev->v_nparity = 0;
587edb3504Toomas Soome		}
588199767fToomas Soome		if (nvlist_find(nvlist, ZPOOL_CONFIG_PATH,
589edb3504Toomas Soome		    DATA_TYPE_STRING, NULL, &path) == 0) {
590199767fToomas Soome			if (strncmp(path, "/dev/dsk/", 9) == 0)
591199767fToomas Soome				path += 9;
592199767fToomas Soome			vdev->v_name = strdup(path);
593199767fToomas Soome			if (nvlist_find(nvlist, ZPOOL_CONFIG_PHYS_PATH,
594edb3504Toomas Soome			    DATA_TYPE_STRING, NULL, &path) == 0) {
595199767fToomas Soome				vdev->v_phys_path = strdup(path);
596edb3504Toomas Soome			} else {
597199767fToomas Soome				vdev->v_phys_path = NULL;
598edb3504Toomas Soome			}
599199767fToomas Soome			if (nvlist_find(nvlist, ZPOOL_CONFIG_DEVID,
600edb3504Toomas Soome			    DATA_TYPE_STRING, NULL, &path) == 0) {
601199767fToomas Soome				vdev->v_devid = strdup(path);
602edb3504Toomas Soome			} else {
603199767fToomas Soome				vdev->v_devid = NULL;
604edb3504Toomas Soome			}
605199767fToomas Soome		} else {
606199767fToomas Soome			if (!strcmp(type, "raidz")) {
607199767fToomas Soome				if (vdev->v_nparity == 1)
608199767fToomas Soome					vdev->v_name = "raidz1";
609199767fToomas Soome				else if (vdev->v_nparity == 2)
610199767fToomas Soome					vdev->v_name = "raidz2";
611199767fToomas Soome				else if (vdev->v_nparity == 3)
612199767fToomas Soome					vdev->v_name = "raidz3";
613199767fToomas Soome				else {
614199767fToomas Soome					printf("ZFS: can only boot from disk, mirror, raidz1, raidz2 and raidz3 vdevs\n");
615199767fToomas Soome					return (EIO);
616199767fToomas Soome				}
617199767fToomas Soome			} else {
618199767fToomas Soome				vdev->v_name = strdup(type);
619199767fToomas Soome			}
620199767fToomas Soome		}
621199767fToomas Soome	} else {
622199767fToomas Soome		is_new = 0;
623199767fToomas Soome	}
624199767fToomas Soome
625199767fToomas Soome	if (is_new || is_newer) {
626199767fToomas Soome		/*
627199767fToomas Soome		 * This is either new vdev or we've already seen this vdev,
628199767fToomas Soome		 * but from an older vdev label, so let's refresh its state
629199767fToomas Soome		 * from the newer label.
630199767fToomas Soome		 */
631199767fToomas Soome		if (is_offline)
632199767fToomas Soome			vdev->v_state = VDEV_STATE_OFFLINE;
633199767fToomas Soome		else if (is_removed)
634199767fToomas Soome			vdev->v_state = VDEV_STATE_REMOVED;
635199767fToomas Soome		else if (is_faulted)
636199767fToomas Soome			vdev->v_state = VDEV_STATE_FAULTED;
637199767fToomas Soome		else if (is_degraded)
638199767fToomas Soome			vdev->v_state = VDEV_STATE_DEGRADED;
639199767fToomas Soome		else if (isnt_present)
640199767fToomas Soome			vdev->v_state = VDEV_STATE_CANT_OPEN;
641199767fToomas Soome	}
642199767fToomas Soome
643edb3504Toomas Soome	rc = nvlist_find(nvlist, ZPOOL_CONFIG_CHILDREN, DATA_TYPE_NVLIST_ARRAY,
644edb3504Toomas Soome	    &nkids, &kids);
645199767fToomas Soome	/*
646199767fToomas Soome	 * Its ok if we don't have any kids.
647199767fToomas Soome	 */
648199767fToomas Soome	if (rc == 0) {
649199767fToomas Soome		vdev->v_nchildren = nkids;
650199767fToomas Soome		for (i = 0; i < nkids; i++) {
651199767fToomas Soome			rc = vdev_init_from_nvlist(kids, vdev, &kid, is_newer);
652199767fToomas Soome			if (rc)
653199767fToomas Soome				return (rc);
654199767fToomas Soome			if (is_new)
655199767fToomas Soome				STAILQ_INSERT_TAIL(&vdev->v_children, kid,
656199767fToomas Soome						   v_childlink);
657199767fToomas Soome			kids = nvlist_next(kids);
658199767fToomas Soome		}
659199767fToomas Soome	} else {
660199767fToomas Soome		vdev->v_nchildren = 0;
661199767fToomas Soome	}
662199767fToomas Soome
663199767fToomas Soome	if (vdevp)
664199767fToomas Soome		*vdevp = vdev;
665199767fToomas Soome	return (0);
666199767fToomas Soome}
667199767fToomas Soome
668199767fToomas Soomestatic void
669199767fToomas Soomevdev_set_state(vdev_t *vdev)
670199767fToomas Soome{
671199767fToomas Soome	vdev_t *kid;
672199767fToomas Soome	int good_kids;
673199767fToomas Soome	int bad_kids;
674199767fToomas Soome
675199767fToomas Soome	/*
676199767fToomas Soome	 * A mirror or raidz is healthy if all its kids are healthy. A
677199767fToomas Soome	 * mirror is degraded if any of its kids is healthy; a raidz
678199767fToomas Soome	 * is degraded if at most nparity kids are offline.
679199767fToomas Soome	 */
680199767fToomas Soome	if (STAILQ_FIRST(&vdev->v_children)) {
681199767fToomas Soome		good_kids = 0;
682199767fToomas Soome		bad_kids = 0;
683199767fToomas Soome		STAILQ_FOREACH(kid, &vdev->v_children, v_childlink) {
684199767fToomas Soome			if (kid->v_state == VDEV_STATE_HEALTHY)
685199767fToomas Soome				good_kids++;
686199767fToomas Soome			else
687199767fToomas Soome				bad_kids++;
688199767fToomas Soome		}
689199767fToomas Soome		if (bad_kids == 0) {
690199767fToomas Soome			vdev->v_state = VDEV_STATE_HEALTHY;
691199767fToomas Soome		} else {
692199767fToomas Soome			if (vdev->v_read == vdev_mirror_read) {
693199767fToomas Soome				if (good_kids) {
694199767fToomas Soome					vdev->v_state = VDEV_STATE_DEGRADED;
695199767fToomas Soome				} else {
696199767fToomas Soome					vdev->v_state = VDEV_STATE_OFFLINE;
697199767fToomas Soome				}
698199767fToomas Soome			} else if (vdev->v_read == vdev_raidz_read) {
699199767fToomas Soome				if (bad_kids > vdev->v_nparity) {
700199767fToomas Soome					vdev->v_state = VDEV_STATE_OFFLINE;
701199767fToomas Soome				} else {
702199767fToomas Soome					vdev->v_state = VDEV_STATE_DEGRADED;
703199767fToomas Soome				}
704199767fToomas Soome			}
705199767fToomas Soome		}
706199767fToomas Soome	}
707199767fToomas Soome}
708199767fToomas Soome
709199767fToomas Soomestatic spa_t *
710199767fToomas Soomespa_find_by_guid(uint64_t guid)
711199767fToomas Soome{
712199767fToomas Soome	spa_t *spa;
713199767fToomas Soome
714199767fToomas Soome	STAILQ_FOREACH(spa, &zfs_pools, spa_link)
715199767fToomas Soome		if (spa->spa_guid == guid)
716199767fToomas Soome			return (spa);
717199767fToomas Soome
718199767fToomas Soome	return (0);
719199767fToomas Soome}
720199767fToomas Soome
721199767fToomas Soomestatic spa_t *
722199767fToomas Soomespa_find_by_name(const char *name)
723199767fToomas Soome{
724199767fToomas Soome	spa_t *spa;
725199767fToomas Soome
726199767fToomas Soome	STAILQ_FOREACH(spa, &zfs_pools, spa_link)
727199767fToomas Soome		if (!strcmp(spa->spa_name, name))
728199767fToomas Soome			return (spa);
729199767fToomas Soome
730199767fToomas Soome	return (0);
731199767fToomas Soome}
732199767fToomas Soome
733199767fToomas Soomespa_t *
734199767fToomas Soomespa_get_primary(void)
735199767fToomas Soome{
736199767fToomas Soome	return (STAILQ_FIRST(&zfs_pools));
737199767fToomas Soome}
738199767fToomas Soome
739199767fToomas Soomevdev_t *
740199767fToomas Soomespa_get_primary_vdev(const spa_t *spa)
741199767fToomas Soome{
742199767fToomas Soome	vdev_t *vdev;
743199767fToomas Soome	vdev_t *kid;
744199767fToomas Soome
745199767fToomas Soome	if (spa == NULL)
746199767fToomas Soome		spa = spa_get_primary();
747199767fToomas Soome	if (spa == NULL)
748199767fToomas Soome		return (NULL);
749199767fToomas Soome	vdev = STAILQ_FIRST(&spa->spa_vdevs);
750199767fToomas Soome	if (vdev == NULL)
751199767fToomas Soome		return (NULL);
752199767fToomas Soome	for (kid = STAILQ_FIRST(&vdev->v_children); kid != NULL;
753199767fToomas Soome	     kid = STAILQ_FIRST(&vdev->v_children))
754199767fToomas Soome		vdev = kid;
755199767fToomas Soome	return (vdev);
756199767fToomas Soome}
757199767fToomas Soome
758199767fToomas Soomestatic spa_t *
759edb3504Toomas Soomespa_create(uint64_t guid, const char *name)
760199767fToomas Soome{
761199767fToomas Soome	spa_t *spa;
762199767fToomas Soome
76302f1166Toomas Soome	if ((spa = calloc(1, sizeof (spa_t))) == NULL)
764edb3504Toomas Soome		return (NULL);
765edb3504Toomas Soome	if ((spa->spa_name = strdup(name)) == NULL) {
766edb3504Toomas Soome		free(spa);
767edb3504Toomas Soome		return (NULL);
768edb3504Toomas Soome	}
769199767fToomas Soome	STAILQ_INIT(&spa->spa_vdevs);
770199767fToomas Soome	spa->spa_guid = guid;
771199767fToomas Soome	STAILQ_INSERT_TAIL(&zfs_pools, spa, spa_link);
772199767fToomas Soome
773199767fToomas Soome	return (spa);
774199767fToomas Soome}
775199767fToomas Soome
776199767fToomas Soomestatic const char *
777199767fToomas Soomestate_name(vdev_state_t state)
778199767fToomas Soome{
779199767fToomas Soome	static const char* names[] = {
780199767fToomas Soome		"UNKNOWN",
781199767fToomas Soome		"CLOSED",
782199767fToomas Soome		"OFFLINE",
783199767fToomas Soome		"REMOVED",
784199767fToomas Soome		"CANT_OPEN",
785199767fToomas Soome		"FAULTED",
786199767fToomas Soome		"DEGRADED",
787199767fToomas Soome		"ONLINE"
788199767fToomas Soome	};
789199767fToomas Soome	return names[state];
790199767fToomas Soome}
791199767fToomas Soome
792199767fToomas Soomestatic int
793199767fToomas Soomepager_printf(const char *fmt, ...)
794199767fToomas Soome{
795199767fToomas Soome	char line[80];
796199767fToomas Soome	va_list args;
797199767fToomas Soome
798199767fToomas Soome	va_start(args, fmt);
799199767fToomas Soome	vsnprintf(line, sizeof (line), fmt, args);
800199767fToomas Soome	va_end(args);
801199767fToomas Soome	return (pager_output(line));
802199767fToomas Soome}
803199767fToomas Soome
804199767fToomas Soome#define STATUS_FORMAT	"        %s %s\n"
805199767fToomas Soome
806199767fToomas Soomestatic int
807199767fToomas Soomeprint_state(int indent, const char *name, vdev_state_t state)
808199767fToomas Soome{
809199767fToomas Soome	int i;
810199767fToomas Soome	char buf[512];
811199767fToomas Soome
812199767fToomas Soome	buf[0] = 0;
813199767fToomas Soome	for (i = 0; i < indent; i++)
814199767fToomas Soome		strcat(buf, "  ");
815199767fToomas Soome	strcat(buf, name);
816199767fToomas Soome	return (pager_printf(STATUS_FORMAT, buf, state_name(state)));
817199767fToomas Soome}
818199767fToomas Soome
819199767fToomas Soomestatic int
820199767fToomas Soomevdev_status(vdev_t *vdev, int indent)
821199767fToomas Soome{
822199767fToomas Soome	vdev_t *kid;
823199767fToomas Soome	int ret;
824199767fToomas Soome	ret = print_state(indent, vdev->v_name, vdev->v_state);
825199767fToomas Soome	if (ret != 0)
826199767fToomas Soome		return (ret);
827199767fToomas Soome
828199767fToomas Soome	STAILQ_FOREACH(kid, &vdev->v_children, v_childlink) {
829199767fToomas Soome		ret = vdev_status(kid, indent + 1);
830199767fToomas Soome		if (ret != 0)
831199767fToomas Soome			return (ret);
832199767fToomas Soome	}
833199767fToomas Soome	return (ret);
834199767fToomas Soome}
835199767fToomas Soome
836199767fToomas Soomestatic int
837199767fToomas Soomespa_status(spa_t *spa)
838199767fToomas Soome{
839199767fToomas Soome	static char bootfs[ZFS_MAXNAMELEN];
840199767fToomas Soome	uint64_t rootid;
841199767fToomas Soome	vdev_t *vdev;
842199767fToomas Soome	int good_kids, bad_kids, degraded_kids, ret;
843199767fToomas Soome	vdev_state_t state;
844199767fToomas Soome
845199767fToomas Soome	ret = pager_printf("  pool: %s\n", spa->spa_name);
846199767fToomas Soome	if (ret != 0)
847199767fToomas Soome		return (ret);
848199767fToomas Soome
849199767fToomas Soome	if (zfs_get_root(spa, &rootid) == 0 &&
850199767fToomas Soome	    zfs_rlookup(spa, rootid, bootfs) == 0) {
851199767fToomas Soome		if (bootfs[0] == '\0')
852199767fToomas Soome			ret = pager_printf("bootfs: %s\n", spa->spa_name);
853199767fToomas Soome		else
854199767fToomas Soome			ret = pager_printf("bootfs: %s/%s\n", spa->spa_name,
855199767fToomas Soome			    bootfs);
856199767fToomas Soome		if (ret != 0)
857199767fToomas Soome			return (ret);
858199767fToomas Soome	}
859199767fToomas Soome	ret = pager_printf("config:\n\n");
860199767fToomas Soome	if (ret != 0)
861199767fToomas Soome		return (ret);
862199767fToomas Soome	ret = pager_printf(STATUS_FORMAT, "NAME", "STATE");
863199767fToomas Soome	if (ret != 0)
864199767fToomas Soome		return (ret);
865199767fToomas Soome
866199767fToomas Soome	good_kids = 0;
867199767fToomas Soome	degraded_kids = 0;
868199767fToomas Soome	bad_kids = 0;
869199767fToomas Soome	STAILQ_FOREACH(vdev, &spa->spa_vdevs, v_childlink) {
870199767fToomas Soome		if (vdev->v_state == VDEV_STATE_HEALTHY)
871199767fToomas Soome			good_kids++;
872199767fToomas Soome		else if (vdev->v_state == VDEV_STATE_DEGRADED)
873199767fToomas Soome			degraded_kids++;
874199767fToomas Soome		else
875199767fToomas Soome			bad_kids++;
876199767fToomas Soome	}
877199767fToomas Soome
878199767fToomas Soome	state = VDEV_STATE_CLOSED;
879199767fToomas Soome	if (good_kids > 0 && (degraded_kids + bad_kids) == 0)
880199767fToomas Soome		state = VDEV_STATE_HEALTHY;
881199767fToomas Soome	else if ((good_kids + degraded_kids) > 0)
882199767fToomas Soome		state = VDEV_STATE_DEGRADED;
883199767fToomas Soome
884199767fToomas Soome	ret = print_state(0, spa->spa_name, state);
885199767fToomas Soome	if (ret != 0)
886199767fToomas Soome		return (ret);
887199767fToomas Soome	STAILQ_FOREACH(vdev, &spa->spa_vdevs, v_childlink) {
888199767fToomas Soome		ret = vdev_status(vdev, 1);
889199767fToomas Soome		if (ret != 0)
890199767fToomas Soome			return (ret);
891199767fToomas Soome	}
892199767fToomas Soome	return (ret);
893199767fToomas Soome}
894199767fToomas Soome
895199767fToomas Soomeint
896199767fToomas Soomespa_all_status(void)
897199767fToomas Soome{
898199767fToomas Soome	spa_t *spa;
899199767fToomas Soome	int first = 1, ret = 0;
900199767fToomas Soome
901199767fToomas Soome	STAILQ_FOREACH(spa, &zfs_pools, spa_link) {
902199767fToomas Soome		if (!first) {
903199767fToomas Soome			ret = pager_printf("\n");
904199767fToomas Soome			if (ret != 0)
905199767fToomas Soome				return (ret);
906199767fToomas Soome		}
907199767fToomas Soome		first = 0;
908199767fToomas Soome		ret = spa_status(spa);
909199767fToomas Soome		if (ret != 0)
910199767fToomas Soome			return (ret);
911199767fToomas Soome	}
912199767fToomas Soome	return (ret);
913199767fToomas Soome}
914199767fToomas Soome
915edb3504Toomas Soomeuint64_t
916edb3504Toomas Soomevdev_label_offset(uint64_t psize, int l, uint64_t offset)
917edb3504Toomas Soome{
918edb3504Toomas Soome	uint64_t label_offset;
919edb3504Toomas Soome
920edb3504Toomas Soome	if (l < VDEV_LABELS / 2)
921edb3504Toomas Soome		label_offset = 0;
922edb3504Toomas Soome	else
923edb3504Toomas Soome		label_offset = psize - VDEV_LABELS * sizeof (vdev_label_t);
924edb3504Toomas Soome
925edb3504Toomas Soome	return (offset + l * sizeof (vdev_label_t) + label_offset);
926edb3504Toomas Soome}
927edb3504Toomas Soome
928199767fToomas Soomestatic int
929199767fToomas Soomevdev_probe(vdev_phys_read_t *phys_read, void *read_priv, spa_t **spap)
930199767fToomas Soome{
931199767fToomas Soome	vdev_t vtmp;
932199767fToomas Soome	vdev_phys_t *vdev_label = (vdev_phys_t *) zap_scratch;
9336617bbfToomas Soome	vdev_phys_t *tmp_label;
934199767fToomas Soome	spa_t *spa;
935199767fToomas Soome	vdev_t *vdev, *top_vdev, *pool_vdev;
936199767fToomas Soome	off_t off;
937199767fToomas Soome	blkptr_t bp;
938edb3504Toomas Soome	const unsigned char *nvlist = NULL;
939199767fToomas Soome	uint64_t val;
940199767fToomas Soome	uint64_t guid;
941edb3504Toomas Soome	uint64_t best_txg = 0;
942199767fToomas Soome	uint64_t pool_txg, pool_guid;
943edb3504Toomas Soome	uint64_t psize;
944199767fToomas Soome	const char *pool_name;
945199767fToomas Soome	const unsigned char *vdevs;
946199767fToomas Soome	const unsigned char *features;
947edb3504Toomas Soome	int i, l, rc, is_newer;
948199767fToomas Soome	char *upbuf;
949199767fToomas Soome	const struct uberblock *up;
950199767fToomas Soome
951199767fToomas Soome	/*
952199767fToomas Soome	 * Load the vdev label and figure out which
953199767fToomas Soome	 * uberblock is most current.
954199767fToomas Soome	 */
955199767fToomas Soome	memset(&vtmp, 0, sizeof(vtmp));
956199767fToomas Soome	vtmp.v_phys_read = phys_read;
957199767fToomas Soome	vtmp.v_read_priv = read_priv;
958edb3504Toomas Soome	psize = P2ALIGN(ldi_get_size(read_priv),
959edb3504Toomas Soome	    (uint64_t)sizeof (vdev_label_t));
960199767fToomas Soome
9616617bbfToomas Soome	/* Test for minimum device size. */
9626617bbfToomas Soome	if (psize < SPA_MINDEVSIZE)
9636617bbfToomas Soome		return (EIO);
9646617bbfToomas Soome
9656617bbfToomas Soome	tmp_label = zfs_alloc(sizeof (vdev_phys_t));
9666617bbfToomas Soome
967edb3504Toomas Soome	for (l = 0; l < VDEV_LABELS; l++) {
968edb3504Toomas Soome		off = vdev_label_offset(psize, l,
969edb3504Toomas Soome		    offsetof(vdev_label_t, vl_vdev_phys));
970edb3504Toomas Soome
971edb3504Toomas Soome		BP_ZERO(&bp);
972edb3504Toomas Soome		BP_SET_LSIZE(&bp, sizeof(vdev_phys_t));
973edb3504Toomas Soome		BP_SET_PSIZE(&bp, sizeof(vdev_phys_t));
974edb3504Toomas Soome		BP_SET_CHECKSUM(&bp, ZIO_CHECKSUM_LABEL);
975edb3504Toomas Soome		BP_SET_COMPRESS(&bp, ZIO_COMPRESS_OFF);
976edb3504Toomas Soome		DVA_SET_OFFSET(BP_IDENTITY(&bp), off);
977edb3504Toomas Soome		ZIO_SET_CHECKSUM(&bp.blk_cksum, off, 0, 0, 0);
978edb3504Toomas Soome
979edb3504Toomas Soome		if (vdev_read_phys(&vtmp, &bp, tmp_label, off, 0))
980edb3504Toomas Soome			continue;
981edb3504Toomas Soome
982edb3504Toomas Soome		if (tmp_label->vp_nvlist[0] != NV_ENCODE_XDR)
983edb3504Toomas Soome			continue;
984edb3504Toomas Soome
985edb3504Toomas Soome		nvlist = (const unsigned char *) tmp_label->vp_nvlist + 4;
986edb3504Toomas Soome		if (nvlist_find(nvlist, ZPOOL_CONFIG_POOL_TXG,
987edb3504Toomas Soome		    DATA_TYPE_UINT64, NULL, &pool_txg) != 0)
988edb3504Toomas Soome			continue;
989edb3504Toomas Soome
990edb3504Toomas Soome		if (best_txg <= pool_txg) {
991edb3504Toomas Soome			best_txg = pool_txg;
992edb3504Toomas Soome			memcpy(vdev_label, tmp_label, sizeof (vdev_phys_t));
993edb3504Toomas Soome		}
994199767fToomas Soome	}
995199767fToomas Soome
996edb3504Toomas Soome	zfs_free(tmp_label, sizeof (vdev_phys_t));
997edb3504Toomas Soome
9986617bbfToomas Soome	if (best_txg == 0)
9996617bbfToomas Soome		return (EIO);
10006617bbfToomas Soome
1001edb3504Toomas Soome	if (vdev_label->vp_nvlist[0] != NV_ENCODE_XDR)
1002edb3504Toomas Soome		return (EIO);
1003edb3504Toomas Soome
1004199767fToomas Soome	nvlist = (const unsigned char *) vdev_label->vp_nvlist + 4;
1005199767fToomas Soome
1006edb3504Toomas Soome	if (nvlist_find(nvlist, ZPOOL_CONFIG_VERSION, DATA_TYPE_UINT64,
1007edb3504Toomas Soome	    NULL, &val) != 0) {
1008199767fToomas Soome		return (EIO);
1009199767fToomas Soome	}
1010199767fToomas Soome
1011199767fToomas Soome	if (!SPA_VERSION_IS_SUPPORTED(val)) {
1012199767fToomas Soome		printf("ZFS: unsupported ZFS version %u (should be %u)\n",
1013199767fToomas Soome		    (unsigned) val, (unsigned) SPA_VERSION);
1014199767fToomas Soome		return (EIO);
1015199767fToomas Soome	}
1016199767fToomas Soome
1017199767fToomas Soome	/* Check ZFS features for read */
1018edb3504Toomas Soome	if (nvlist_find(nvlist, ZPOOL_CONFIG_FEATURES_FOR_READ,
1019edb3504Toomas Soome	    DATA_TYPE_NVLIST, NULL, &features) == 0 &&
1020edb3504Toomas Soome	    nvlist_check_features_for_read(features) != 0) {
1021199767fToomas Soome		return (EIO);
1022edb3504Toomas Soome	}
1023199767fToomas Soome
1024edb3504Toomas Soome	if (nvlist_find(nvlist, ZPOOL_CONFIG_POOL_STATE, DATA_TYPE_UINT64,
1025edb3504Toomas Soome	    NULL, &val) != 0) {
1026199767fToomas Soome		return (EIO);
1027199767fToomas Soome	}
1028199767fToomas Soome
1029199767fToomas Soome	if (val == POOL_STATE_DESTROYED) {
1030199767fToomas Soome		/* We don't boot only from destroyed pools. */
1031199767fToomas Soome		return (EIO);
1032199767fToomas Soome	}
1033199767fToomas Soome
1034edb3504Toomas Soome	if (nvlist_find(nvlist, ZPOOL_CONFIG_POOL_TXG, DATA_TYPE_UINT64,
1035edb3504Toomas Soome	    NULL, &pool_txg) != 0 ||
1036edb3504Toomas Soome	    nvlist_find(nvlist, ZPOOL_CONFIG_POOL_GUID, DATA_TYPE_UINT64,
1037edb3504Toomas Soome	    NULL, &pool_guid) != 0 ||
1038edb3504Toomas Soome	    nvlist_find(nvlist, ZPOOL_CONFIG_POOL_NAME, DATA_TYPE_STRING,
1039edb3504Toomas Soome	    NULL, &pool_name) != 0) {
1040199767fToomas Soome		/*
1041199767fToomas Soome		 * Cache and spare devices end up here - just ignore
1042199767fToomas Soome		 * them.
1043199767fToomas Soome		 */
1044199767fToomas Soome		/*printf("ZFS: can't find pool details\n");*/
1045199767fToomas Soome		return (EIO);
1046199767fToomas Soome	}
1047199767fToomas Soome
1048edb3504Toomas Soome	if (nvlist_find(nvlist, ZPOOL_CONFIG_IS_LOG, DATA_TYPE_UINT64,
1049edb3504Toomas Soome	    NULL, &val) == 0 && val != 0) {
1050199767fToomas Soome		return (EIO);
1051edb3504Toomas Soome	}
1052199767fToomas Soome
1053199767fToomas Soome	/*
1054199767fToomas Soome	 * Create the pool if this is the first time we've seen it.
1055199767fToomas Soome	 */
1056199767fToomas Soome	spa = spa_find_by_guid(pool_guid);
1057edb3504Toomas Soome	if (spa == NULL) {
1058edb3504Toomas Soome		spa = spa_create(pool_guid, pool_name);
1059edb3504Toomas Soome		if (spa == NULL)
1060edb3504Toomas Soome			return (ENOMEM);
1061199767fToomas Soome	}
1062199767fToomas Soome	if (pool_txg > spa->spa_txg) {
1063199767fToomas Soome		spa->spa_txg = pool_txg;
1064199767fToomas Soome		is_newer = 1;
1065edb3504Toomas Soome	} else {
1066199767fToomas Soome		is_newer = 0;
1067edb3504Toomas Soome	}
1068199767fToomas Soome
1069199767fToomas Soome	/*
1070199767fToomas Soome	 * Get the vdev tree and create our in-core copy of it.
1071199767fToomas Soome	 * If we already have a vdev with this guid, this must
1072199767fToomas Soome	 * be some kind of alias (overlapping slices, dangerously dedicated
1073199767fToomas Soome	 * disks etc).
1074199767fToomas Soome	 */
1075edb3504Toomas Soome	if (nvlist_find(nvlist, ZPOOL_CONFIG_GUID, DATA_TYPE_UINT64,
1076edb3504Toomas Soome	    NULL, &guid) != 0) {
1077199767fToomas Soome		return (EIO);
1078199767fToomas Soome	}
1079199767fToomas Soome	vdev = vdev_find(guid);
1080199767fToomas Soome	if (vdev && vdev->v_phys_read)	/* Has this vdev already been inited? */
1081199767fToomas Soome		return (EIO);
1082199767fToomas Soome
1083edb3504Toomas Soome	if (nvlist_find(nvlist, ZPOOL_CONFIG_VDEV_TREE, DATA_TYPE_NVLIST,
1084edb3504Toomas Soome	    NULL, &vdevs)) {
1085199767fToomas Soome		return (EIO);
1086199767fToomas Soome	}
1087199767fToomas Soome
1088199767fToomas Soome	rc = vdev_init_from_nvlist(vdevs, NULL, &top_vdev, is_newer);
1089edb3504Toomas Soome	if (rc != 0)
1090199767fToomas Soome		return (rc);
1091199767fToomas Soome
1092199767fToomas Soome	/*
1093199767fToomas Soome	 * Add the toplevel vdev to the pool if its not already there.
1094199767fToomas Soome	 */
1095199767fToomas Soome	STAILQ_FOREACH(pool_vdev, &spa->spa_vdevs, v_childlink)
1096199767fToomas Soome		if (top_vdev == pool_vdev)
1097199767fToomas Soome			break;
10984a04e8dToomas Soome	if (!pool_vdev && top_vdev) {
10994a04e8dToomas Soome		top_vdev->spa = spa;
1100199767fToomas Soome		STAILQ_INSERT_TAIL(&spa->spa_vdevs, top_vdev, v_childlink);
11014a04e8dToomas Soome	}
1102199767fToomas Soome
1103199767fToomas Soome	/*
1104199767fToomas Soome	 * We should already have created an incomplete vdev for this
1105199767fToomas Soome	 * vdev. Find it and initialise it with our read proc.
1106199767fToomas Soome	 */
1107199767fToomas Soome	vdev = vdev_find(guid);
1108199767fToomas Soome	if (vdev) {
1109199767fToomas Soome		vdev->v_phys_read = phys_read;
1110199767fToomas Soome		vdev->v_read_priv = read_priv;
1111199767fToomas Soome		vdev->v_state = VDEV_STATE_HEALTHY;
1112199767fToomas Soome	} else {
1113199767fToomas Soome		printf("ZFS: inconsistent nvlist contents\n");
1114199767fToomas Soome		return (EIO);
1115199767fToomas Soome	}
1116199767fToomas Soome
11174513705Toomas Soome	/* Record boot vdev for spa. */
11184513705Toomas Soome	if (is_newer == 1)
11194513705Toomas Soome		spa->spa_boot_vdev = vdev;
11204513705Toomas Soome
1121199767fToomas Soome	/*
1122199767fToomas Soome	 * Re-evaluate top-level vdev state.
1123199767fToomas Soome	 */
1124199767fToomas Soome	vdev_set_state(top_vdev);
1125199767fToomas Soome
1126199767fToomas Soome	/*
1127199767fToomas Soome	 * Ok, we are happy with the pool so far. Lets find
1128199767fToomas Soome	 * the best uberblock and then we can actually access
1129199767fToomas Soome	 * the contents of the pool.
1130199767fToomas Soome	 */
1131199767fToomas Soome	upbuf = zfs_alloc(VDEV_UBERBLOCK_SIZE(vdev));
1132199767fToomas Soome	up = (const struct uberblock *)upbuf;
1133edb3504Toomas Soome	for (l = 0; l < VDEV_LABELS; l++) {
1134edb3504Toomas Soome		for (i = 0; i < VDEV_UBERBLOCK_COUNT(vdev); i++) {
1135edb3504Toomas Soome			off = vdev_label_offset(psize, l,
1136edb3504Toomas Soome			    VDEV_UBERBLOCK_OFFSET(vdev, i));
1137edb3504Toomas Soome			BP_ZERO(&bp);
1138edb3504Toomas Soome			DVA_SET_OFFSET(&bp.blk_dva[0], off);
1139edb3504Toomas Soome			BP_SET_LSIZE(&bp, VDEV_UBERBLOCK_SIZE(vdev));
1140edb3504Toomas Soome			BP_SET_PSIZE(&bp, VDEV_UBERBLOCK_SIZE(vdev));
1141edb3504Toomas Soome			BP_SET_CHECKSUM(&bp, ZIO_CHECKSUM_LABEL);
1142edb3504Toomas Soome			BP_SET_COMPRESS(&bp, ZIO_COMPRESS_OFF);
1143edb3504Toomas Soome			ZIO_SET_CHECKSUM(&bp.blk_cksum, off, 0, 0, 0);
1144edb3504Toomas Soome
1145edb3504Toomas Soome			if (vdev_read_phys(vdev, &bp, upbuf, off, 0) != 0)
1146edb3504Toomas Soome				continue;
1147edb3504Toomas Soome
1148edb3504Toomas Soome			if (up->ub_magic != UBERBLOCK_MAGIC)
1149edb3504Toomas Soome				continue;
1150edb3504Toomas Soome			if (up->ub_txg < spa->spa_txg)
1151edb3504Toomas Soome				continue;
1152edb3504Toomas Soome			if (up->ub_txg > spa->spa_uberblock.ub_txg ||
1153edb3504Toomas Soome			    (up->ub_txg == spa->spa_uberblock.ub_txg &&
1154edb3504Toomas Soome			    up->ub_timestamp >
1155edb3504Toomas Soome			    spa->spa_uberblock.ub_timestamp)) {
1156199767fToomas Soome				spa->spa_uberblock = *up;
1157edb3504Toomas Soome			}
1158199767fToomas Soome		}
1159199767fToomas Soome	}
1160199767fToomas Soome	zfs_free(upbuf, VDEV_UBERBLOCK_SIZE(vdev));
1161199767fToomas Soome
11624a04e8dToomas Soome	vdev->spa = spa;
1163edb3504Toomas Soome	if (spap != NULL)
1164199767fToomas Soome		*spap = spa;
1165199767fToomas Soome	return (0);
1166199767fToomas Soome}
1167199767fToomas Soome
1168199767fToomas Soomestatic int
1169199767fToomas Soomeilog2(int n)
1170199767fToomas Soome{
1171199767fToomas Soome	int v;
1172199767fToomas Soome
1173199767fToomas Soome	for (v = 0; v < 32; v++)
1174199767fToomas Soome		if (n == (1 << v))
1175199767fToomas Soome			return v;
1176199767fToomas Soome	return -1;
1177199767fToomas Soome}
1178199767fToomas Soome
1179199767fToomas Soomestatic int
1180199767fToomas Soomezio_read_gang(const spa_t *spa, const blkptr_t *bp, void *buf)
1181199767fToomas Soome{
1182199767fToomas Soome	blkptr_t gbh_bp;
1183199767fToomas Soome	zio_gbh_phys_t zio_gb;
1184199767fToomas Soome	char *pbuf;
1185199767fToomas Soome	int i;
1186199767fToomas Soome
1187199767fToomas Soome	/* Artificial BP for gang block header. */
1188199767fToomas Soome	gbh_bp = *bp;
1189199767fToomas Soome	BP_SET_PSIZE(&gbh_bp, SPA_GANGBLOCKSIZE);
1190199767fToomas Soome	BP_SET_LSIZE(&gbh_bp, SPA_GANGBLOCKSIZE);
1191199767fToomas Soome	BP_SET_CHECKSUM(&gbh_bp, ZIO_CHECKSUM_GANG_HEADER);
1192199767fToomas Soome	BP_SET_COMPRESS(&gbh_bp, ZIO_COMPRESS_OFF);
1193199767fToomas Soome	for (i = 0; i < SPA_DVAS_PER_BP; i++)
1194199767fToomas Soome		DVA_SET_GANG(&gbh_bp.blk_dva[i], 0);
1195199767fToomas Soome
1196199767fToomas Soome	/* Read gang header block using the artificial BP. */
1197199767fToomas Soome	if (zio_read(spa, &gbh_bp, &zio_gb))
1198199767fToomas Soome		return (EIO);
1199199767fToomas Soome
1200199767fToomas Soome	pbuf = buf;
1201199767fToomas Soome	for (i = 0; i < SPA_GBH_NBLKPTRS; i++) {
1202199767fToomas Soome		blkptr_t *gbp = &zio_gb.zg_blkptr[i];
1203199767fToomas Soome
1204199767fToomas Soome		if (BP_IS_HOLE(gbp))
1205199767fToomas Soome			continue;
1206199767fToomas Soome		if (zio_read(spa, gbp, pbuf))
1207199767fToomas Soome			return (EIO);
1208199767fToomas Soome		pbuf += BP_GET_PSIZE(gbp);
1209199767fToomas Soome	}
1210199767fToomas Soome
12114a04e8dToomas Soome	if (zio_checksum_verify(spa, bp, buf))
1212199767fToomas Soome		return (EIO);
1213199767fToomas Soome	return (0);
1214199767fToomas Soome}
1215199767fToomas Soome
1216199767fToomas Soomestatic int
1217199767fToomas Soomezio_read(const spa_t *spa, const blkptr_t *bp, void *buf)
1218199767fToomas Soome{
1219199767fToomas Soome	int cpfunc = BP_GET_COMPRESS(bp);
1220199767fToomas Soome	uint64_t align, size;
1221199767fToomas Soome	void *pbuf;
1222199767fToomas Soome	int i, error;
1223199767fToomas Soome
1224199767fToomas Soome	/*
1225199767fToomas Soome	 * Process data embedded in block pointer
1226199767fToomas Soome	 */
1227199767fToomas Soome	if (BP_IS_EMBEDDED(bp)) {
1228199767fToomas Soome		ASSERT(BPE_GET_ETYPE(bp) == BP_EMBEDDED_TYPE_DATA);
1229199767fToomas Soome
1230199767fToomas Soome		size = BPE_GET_PSIZE(bp);
1231199767fToomas Soome		ASSERT(size <= BPE_PAYLOAD_SIZE);
1232199767fToomas Soome
1233199767fToomas Soome		if (cpfunc != ZIO_COMPRESS_OFF)
1234199767fToomas Soome			pbuf = zfs_alloc(size);
1235199767fToomas Soome		else
1236199767fToomas Soome			pbuf = buf;
1237199767fToomas Soome
1238199767fToomas Soome		decode_embedded_bp_compressed(bp, pbuf);
1239199767fToomas Soome		error = 0;
1240199767fToomas Soome
1241199767fToomas Soome		if (cpfunc != ZIO_COMPRESS_OFF) {
1242199767fToomas Soome			error = zio_decompress_data(cpfunc, pbuf,
1243199767fToomas Soome			    size, buf, BP_GET_LSIZE(bp));
1244199767fToomas Soome			zfs_free(pbuf, size);
1245199767fToomas Soome		}
1246199767fToomas Soome		if (error != 0)
1247199767fToomas Soome			printf("ZFS: i/o error - unable to decompress block pointer data, error %d\n",
1248199767fToomas Soome			    error);
1249199767fToomas Soome		return (error);
1250199767fToomas Soome	}
1251199767fToomas Soome
1252199767fToomas Soome	error = EIO;
1253199767fToomas Soome
1254199767fToomas Soome	for (i = 0; i < SPA_DVAS_PER_BP; i++) {
1255199767fToomas Soome		const dva_t *dva = &bp->blk_dva[i];
1256199767fToomas Soome		vdev_t *vdev;
1257199767fToomas Soome		int vdevid;
1258199767fToomas Soome		off_t offset;
1259199767fToomas Soome
1260199767fToomas Soome		if (!dva->dva_word[0] && !dva->dva_word[1])
1261199767fToomas Soome			continue;
1262199767fToomas Soome
1263199767fToomas Soome		vdevid = DVA_GET_VDEV(dva);
1264199767fToomas Soome		offset = DVA_GET_OFFSET(dva);
1265199767fToomas Soome		STAILQ_FOREACH(vdev, &spa->spa_vdevs, v_childlink) {
1266199767fToomas Soome			if (vdev->v_id == vdevid)
1267199767fToomas Soome				break;
1268199767fToomas Soome		}
1269199767fToomas Soome		if (!vdev || !vdev->v_read)
1270199767fToomas Soome			continue;
1271199767fToomas Soome
1272199767fToomas Soome		size = BP_GET_PSIZE(bp);
1273199767fToomas Soome		if (vdev->v_read == vdev_raidz_read) {
1274199767fToomas Soome			align = 1ULL << vdev->v_top->v_ashift;
1275199767fToomas Soome			if (P2PHASE(size, align) != 0)
1276199767fToomas Soome				size = P2ROUNDUP(size, align);
1277199767fToomas Soome		}
1278199767fToomas Soome		if (size != BP_GET_PSIZE(bp) || cpfunc != ZIO_COMPRESS_OFF)
1279199767fToomas Soome			pbuf = zfs_alloc(size);
1280199767fToomas Soome		else
1281199767fToomas Soome			pbuf = buf;
1282199767fToomas Soome
1283199767fToomas Soome		if (DVA_GET_GANG(dva))
1284199767fToomas Soome			error = zio_read_gang(spa, bp, pbuf);
1285199767fToomas Soome		else
1286199767fToomas Soome			error = vdev->v_read(vdev, bp, pbuf, offset, size);
1287199767fToomas Soome		if (error == 0) {
1288199767fToomas Soome			if (cpfunc != ZIO_COMPRESS_OFF)
1289199767fToomas Soome				error = zio_decompress_data(cpfunc, pbuf,
1290199767fToomas Soome				    BP_GET_PSIZE(bp), buf, BP_GET_LSIZE(bp));
1291199767fToomas Soome			else if (size != BP_GET_PSIZE(bp))
1292199767fToomas Soome				bcopy(pbuf, buf, BP_GET_PSIZE(bp));
1293199767fToomas Soome		}
1294199767fToomas Soome		if (buf != pbuf)
1295199767fToomas Soome			zfs_free(pbuf, size);
1296199767fToomas Soome		if (error == 0)
1297199767fToomas Soome			break;
1298199767fToomas Soome	}
1299199767fToomas Soome	if (error != 0)
1300199767fToomas Soome		printf("ZFS: i/o error - all block copies unavailable\n");
1301199767fToomas Soome	return (error);
1302199767fToomas Soome}
1303199767fToomas Soome
1304199767fToomas Soomestatic int
1305199767fToomas Soomednode_read(const spa_t *spa, const dnode_phys_t *dnode, off_t offset, void *buf, size_t buflen)
1306199767fToomas Soome{
1307199767fToomas Soome	int ibshift = dnode->dn_indblkshift - SPA_BLKPTRSHIFT;
1308199767fToomas Soome	int bsize = dnode->dn_datablkszsec << SPA_MINBLOCKSHIFT;
1309199767fToomas Soome	int nlevels = dnode->dn_nlevels;
1310199767fToomas Soome	int i, rc;
1311199767fToomas Soome
1312199767fToomas Soome	if (bsize > SPA_MAXBLOCKSIZE) {
1313199767fToomas Soome		printf("ZFS: I/O error - blocks larger than %llu are not "
1314199767fToomas Soome		    "supported\n", SPA_MAXBLOCKSIZE);
1315199767fToomas Soome		return (EIO);
1316199767fToomas Soome	}
1317199767fToomas Soome
1318199767fToomas Soome	/*
1319199767fToomas Soome	 * Note: bsize may not be a power of two here so we need to do an
1320199767fToomas Soome	 * actual divide rather than a bitshift.
1321199767fToomas Soome	 */
1322199767fToomas Soome	while (buflen > 0) {
1323199767fToomas Soome		uint64_t bn = offset / bsize;
1324199767fToomas Soome		int boff = offset % bsize;
1325199767fToomas Soome		int ibn;
1326199767fToomas Soome		const blkptr_t *indbp;
1327199767fToomas Soome		blkptr_t bp;
1328199767fToomas Soome
1329199767fToomas Soome		if (bn > dnode->dn_maxblkid) {
1330199767fToomas Soome			printf("warning: zfs bug: bn %llx > dn_maxblkid %llx\n",
1331199767fToomas Soome			    (unsigned long long)bn,
1332199767fToomas Soome			    (unsigned long long)dnode->dn_maxblkid);
1333199767fToomas Soome			/*
1334199767fToomas Soome			 * zfs bug, will not return error
1335199767fToomas Soome			 * return (EIO);
1336199767fToomas Soome			 */
1337199767fToomas Soome		}
1338199767fToomas Soome
1339199767fToomas Soome		if (dnode == dnode_cache_obj && bn == dnode_cache_bn)
1340199767fToomas Soome			goto cached;
1341199767fToomas Soome
1342199767fToomas Soome		indbp = dnode->dn_blkptr;
1343199767fToomas Soome		for (i = 0; i < nlevels; i++) {
1344199767fToomas Soome			/*
1345199767fToomas Soome			 * Copy the bp from the indirect array so that
1346199767fToomas Soome			 * we can re-use the scratch buffer for multi-level
1347199767fToomas Soome			 * objects.
1348199767fToomas Soome			 */
1349199767fToomas Soome			ibn = bn >> ((nlevels - i - 1) * ibshift);
1350199767fToomas Soome			ibn &= ((1 << ibshift) - 1);
1351199767fToomas Soome			bp = indbp[ibn];
1352199767fToomas Soome			if (BP_IS_HOLE(&bp)) {
1353199767fToomas Soome				memset(dnode_cache_buf, 0, bsize);
1354199767fToomas Soome				break;
1355199767fToomas Soome			}
1356199767fToomas Soome			rc = zio_read(spa, &bp, dnode_cache_buf);
1357199767fToomas Soome			if (rc)
1358199767fToomas Soome				return (rc);
1359199767fToomas Soome			indbp = (const blkptr_t *) dnode_cache_buf;
1360199767fToomas Soome		}
1361199767fToomas Soome		dnode_cache_obj = dnode;
1362199767fToomas Soome		dnode_cache_bn = bn;
1363199767fToomas Soome	cached:
1364199767fToomas Soome
1365199767fToomas Soome		/*
1366199767fToomas Soome		 * The buffer contains our data block. Copy what we
1367199767fToomas Soome		 * need from it and loop.
136842b4b09Andy Fiddaman		 */
1369199767fToomas Soome		i = bsize - boff;
1370199767fToomas Soome		if (i > buflen) i = buflen;
1371199767fToomas Soome		memcpy(buf, &dnode_cache_buf[boff], i);
1372199767fToomas Soome		buf = ((char*) buf) + i;
1373199767fToomas Soome		offset += i;
1374199767fToomas Soome		buflen -= i;
1375199767fToomas Soome	}
1376199767fToomas Soome
1377199767fToomas Soome	return (0);
1378199767fToomas Soome}
1379199767fToomas Soome
1380199767fToomas Soome/*
1381199767fToomas Soome * Lookup a value in a microzap directory. Assumes that the zap
1382199767fToomas Soome * scratch buffer contains the directory contents.
1383199767fToomas Soome */
1384199767fToomas Soomestatic int
1385199767fToomas Soomemzap_lookup(const dnode_phys_t *dnode, const char *name, uint64_t *value)
1386199767fToomas Soome{
1387199767fToomas Soome	const mzap_phys_t *mz;
1388199767fToomas Soome	const mzap_ent_phys_t *mze;
1389199767fToomas Soome	size_t size;
1390199767fToomas Soome	int chunks, i;
1391199767fToomas Soome
1392199767fToomas Soome	/*
1393199767fToomas Soome	 * Microzap objects use exactly one block. Read the whole
1394199767fToomas Soome	 * thing.
1395199767fToomas Soome	 */
1396199767fToomas Soome	size = dnode->dn_datablkszsec * 512;
1397199767fToomas Soome
1398199767fToomas Soome	mz = (const mzap_phys_t *) zap_scratch;
1399199767fToomas Soome	chunks = size / MZAP_ENT_LEN - 1;
1400199767fToomas Soome
1401199767fToomas Soome	for (i = 0; i < chunks; i++) {
1402199767fToomas Soome		mze = &mz->mz_chunk[i];
1403199767fToomas Soome		if (!strcmp(mze->mze_name, name)) {
1404199767fToomas Soome			*value = mze->mze_value;
1405199767fToomas Soome			return (0);
1406199767fToomas Soome		}
1407199767fToomas Soome	}
1408199767fToomas Soome
1409199767fToomas Soome	return (ENOENT);
1410199767fToomas Soome}
1411199767fToomas Soome
1412199767fToomas Soome/*
1413199767fToomas Soome * Compare a name with a zap leaf entry. Return non-zero if the name
1414199767fToomas Soome * matches.
1415199767fToomas Soome */
1416199767fToomas Soomestatic int
1417199767fToomas Soomefzap_name_equal(const zap_leaf_t *zl, const zap_leaf_chunk_t *zc, const char *name)
1418199767fToomas Soome{
1419199767fToomas Soome	size_t namelen;
1420199767fToomas Soome	const zap_leaf_chunk_t *nc;
1421199767fToomas Soome	const char *p;
1422199767fToomas Soome
1423199767fToomas Soome	namelen = zc->l_entry.le_name_numints;
142442b4b09Andy Fiddaman
1425199767fToomas Soome	nc = &ZAP_LEAF_CHUNK(zl, zc->l_entry.le_name_chunk);
1426199767fToomas Soome	p = name;
1427199767fToomas Soome	while (namelen > 0) {
1428199767fToomas Soome		size_t len;
1429199767fToomas Soome		len = namelen;
1430199767fToomas Soome		if (len > ZAP_LEAF_ARRAY_BYTES)
1431199767fToomas Soome			len = ZAP_LEAF_ARRAY_BYTES;
1432199767fToomas Soome		if (memcmp(p, nc->l_array.la_array, len))
1433199767fToomas Soome			return (0);
1434199767fToomas Soome		p += len;
1435199767fToomas Soome		namelen -= len;
1436199767fToomas Soome		nc = &ZAP_LEAF_CHUNK(zl, nc->l_array.la_next);
1437199767fToomas Soome	}
1438199767fToomas Soome
1439199767fToomas Soome	return 1;
1440199767fToomas Soome}
1441199767fToomas Soome
1442199767fToomas Soome/*
1443199767fToomas Soome * Extract a uint64_t value from a zap leaf entry.
1444199767fToomas Soome */
1445199767fToomas Soomestatic uint64_t
1446199767fToomas Soomefzap_leaf_value(const zap_leaf_t *zl, const zap_leaf_chunk_t *zc)
1447199767fToomas Soome{
1448199767fToomas Soome	const zap_leaf_chunk_t *vc;
1449199767fToomas Soome	int i;
1450199767fToomas Soome	uint64_t value;
1451199767fToomas Soome	const uint8_t *p;
1452199767fToomas Soome
1453199767fToomas Soome	vc = &ZAP_LEAF_CHUNK(zl, zc->l_entry.le_value_chunk);
1454199767fToomas Soome	for (i = 0, value = 0, p = vc->l_array.la_array; i < 8; i++) {
1455199767fToomas Soome		value = (value << 8) | p[i];
1456199767fToomas Soome	}
1457199767fToomas Soome
1458199767fToomas Soome	return value;
1459199767fToomas Soome}
1460199767fToomas Soome
14614a04e8dToomas Soomestatic void
14624a04e8dToomas Soomestv(int len, void *addr, uint64_t value)
14634a04e8dToomas Soome{
14644a04e8dToomas Soome	switch (len) {
14654a04e8dToomas Soome	case 1:
14664a04e8dToomas Soome		*(uint8_t *)addr = value;
14674a04e8dToomas Soome		return;
14684a04e8dToomas Soome	case 2:
14694a04e8dToomas Soome		*(uint16_t *)addr = value;
14704a04e8dToomas Soome		return;
14714a04e8dToomas Soome	case 4:
14724a04e8dToomas Soome		*(uint32_t *)addr = value;
14734a04e8dToomas Soome		return;
14744a04e8dToomas Soome	case 8:
14754a04e8dToomas Soome		*(uint64_t *)addr = value;
14764a04e8dToomas Soome		return;
14774a04e8dToomas Soome	}
14784a04e8dToomas Soome}
14794a04e8dToomas Soome
14804a04e8dToomas Soome/*
14814a04e8dToomas Soome * Extract a array from a zap leaf entry.
14824a04e8dToomas Soome */
14834a04e8dToomas Soomestatic void
14844a04e8dToomas Soomefzap_leaf_array(const zap_leaf_t *zl, const zap_leaf_chunk_t *zc,
14854a04e8dToomas Soome    uint64_t integer_size, uint64_t num_integers, void *buf)
14864a04e8dToomas Soome{
14874a04e8dToomas Soome	uint64_t array_int_len = zc->l_entry.le_value_intlen;
14884a04e8dToomas Soome	uint64_t value = 0;
14894a04e8dToomas Soome	uint64_t *u64 = buf;
14904a04e8dToomas Soome	char *p = buf;
14914a04e8dToomas Soome	int len = MIN(zc->l_entry.le_value_numints, num_integers);
14924a04e8dToomas Soome	int chunk = zc->l_entry.le_value_chunk;
14934a04e8dToomas Soome	int byten = 0;
14944a04e8dToomas Soome
14954a04e8dToomas Soome	if (integer_size == 8 && len == 1) {
14964a04e8dToomas Soome		*u64 = fzap_leaf_value(zl, zc);
14974a04e8dToomas Soome		return;
14984a04e8dToomas Soome	}
14994a04e8dToomas Soome
15004a04e8dToomas Soome	while (len > 0) {
15014a04e8dToomas Soome		struct zap_leaf_array *la = &ZAP_LEAF_CHUNK(zl, chunk).l_array;
15024a04e8dToomas Soome		int i;
15034a04e8dToomas Soome
15044a04e8dToomas Soome		ASSERT3U(chunk, <, ZAP_LEAF_NUMCHUNKS(zl));
15054a04e8dToomas Soome		for (i = 0; i < ZAP_LEAF_ARRAY_BYTES && len > 0; i++) {
15064a04e8dToomas Soome			value = (value << 8) | la->la_array[i];
15074a04e8dToomas Soome			byten++;
15084a04e8dToomas Soome			if (byten == array_int_len) {
15094a04e8dToomas Soome				stv(integer_size, p, value);
15104a04e8dToomas Soome				byten = 0;
15114a04e8dToomas Soome				len--;
15124a04e8dToomas Soome				if (len == 0)
15134a04e8dToomas Soome					return;
15144a04e8dToomas Soome				p += integer_size;
15154a04e8dToomas Soome			}
15164a04e8dToomas Soome		}
15174a04e8dToomas Soome		chunk = la->la_next;
15184a04e8dToomas Soome	}
15194a04e8dToomas Soome}
15204a04e8dToomas Soome
15214a04e8dToomas Soomestatic int
15224a04e8dToomas Soomefzap_check_size(uint64_t integer_size, uint64_t num_integers)
15234a04e8dToomas Soome{
15244a04e8dToomas Soome
15254a04e8dToomas Soome	switch (integer_size) {
15264a04e8dToomas Soome	case 1:
15274a04e8dToomas Soome	case 2:
15284a04e8dToomas Soome	case 4:
15294a04e8dToomas Soome	case 8:
15304a04e8dToomas Soome		break;
15314a04e8dToomas Soome	default:
15324a04e8dToomas Soome		return (EINVAL);
15334a04e8dToomas Soome	}
15344a04e8dToomas Soome
15354a04e8dToomas Soome	if (integer_size * num_integers > ZAP_MAXVALUELEN)
15364a04e8dToomas Soome		return (E2BIG);
15374a04e8dToomas Soome
15384a04e8dToomas Soome	return (0);
15394a04e8dToomas Soome}
15404a04e8dToomas Soome
1541199767fToomas Soome/*
1542199767fToomas Soome * Lookup a value in a fatzap directory. Assumes that the zap scratch
1543199767fToomas Soome * buffer contains the directory header.
1544199767fToomas Soome */
1545199767fToomas Soomestatic int
15464a04e8dToomas Soomefzap_lookup(const spa_t *spa, const dnode_phys_t *dnode, const char *name,
15474a04e8dToomas Soome    uint64_t integer_size, uint64_t num_integers, void *value)
1548199767fToomas Soome{
1549199767fToomas Soome	int bsize = dnode->dn_datablkszsec << SPA_MINBLOCKSHIFT;
1550199767fToomas Soome	zap_phys_t zh = *(zap_phys_t *) zap_scratch;
1551199767fToomas Soome	fat_zap_t z;
1552199767fToomas Soome	uint64_t *ptrtbl;
1553199767fToomas Soome	uint64_t hash;
1554199767fToomas Soome	int rc;
1555199767fToomas Soome
1556199767fToomas Soome	if (zh.zap_magic != ZAP_MAGIC)
1557199767fToomas Soome		return (EIO);
1558199767fToomas Soome
15594a04e8dToomas Soome	if ((rc = fzap_check_size(integer_size, num_integers)) != 0)
15604a04e8dToomas Soome		return (rc);
15614a04e8dToomas Soome
1562199767fToomas Soome	z.zap_block_shift = ilog2(bsize);
1563199767fToomas Soome	z.zap_phys = (zap_phys_t *) zap_scratch;
1564199767fToomas Soome
1565199767fToomas Soome	/*
1566199767fToomas Soome	 * Figure out where the pointer table is and read it in if necessary.
1567199767fToomas Soome	 */
1568199767fToomas Soome	if (zh.zap_ptrtbl.zt_blk) {
1569199767fToomas Soome		rc = dnode_read(spa, dnode, zh.zap_ptrtbl.zt_blk * bsize,
1570199767fToomas Soome			       zap_scratch, bsize);
1571199767fToomas Soome		if (rc)
1572199767fToomas Soome			return (rc);
1573199767fToomas Soome		ptrtbl = (uint64_t *) zap_scratch;
1574199767fToomas Soome	} else {
1575199767fToomas Soome		ptrtbl = &ZAP_EMBEDDED_PTRTBL_ENT(&z, 0);
1576199767fToomas Soome	}
1577199767fToomas Soome
1578199767fToomas Soome	hash = zap_hash(zh.zap_salt, name);
1579199767fToomas Soome
1580199767fToomas Soome	zap_leaf_t zl;
1581199767fToomas Soome	zl.l_bs = z.zap_block_shift;
1582199767fToomas Soome
1583199767fToomas Soome	off_t off = ptrtbl[hash >> (64 - zh.zap_ptrtbl.zt_shift)] << zl.l_bs;
1584199767fToomas Soome	zap_leaf_chunk_t *zc;
1585199767fToomas Soome
1586199767fToomas Soome	rc = dnode_read(spa, dnode, off, zap_scratch, bsize);
1587199767fToomas Soome	if (rc)
1588199767fToomas Soome		return (rc);
1589199767fToomas Soome
1590199767fToomas Soome	zl.l_phys = (zap_leaf_phys_t *) zap_scratch;
1591199767fToomas Soome
1592199767fToomas Soome	/*
1593199767fToomas Soome	 * Make sure this chunk matches our hash.
1594199767fToomas Soome	 */
1595199767fToomas Soome	if (zl.l_phys->l_hdr.lh_prefix_len > 0
1596199767fToomas Soome	    && zl.l_phys->l_hdr.lh_prefix
1597199767fToomas Soome	    != hash >> (64 - zl.l_phys->l_hdr.lh_prefix_len))
1598199767fToomas Soome		return (ENOENT);
1599199767fToomas Soome
1600199767fToomas Soome	/*
1601199767fToomas Soome	 * Hash within the chunk to find our entry.
1602199767fToomas Soome	 */
1603199767fToomas Soome	int shift = (64 - ZAP_LEAF_HASH_SHIFT(&zl) - zl.l_phys->l_hdr.lh_prefix_len);
1604199767fToomas Soome	int h = (hash >> shift) & ((1 << ZAP_LEAF_HASH_SHIFT(&zl)) - 1);
1605199767fToomas Soome	h = zl.l_phys->l_hash[h];
1606199767fToomas Soome	if (h == 0xffff)
1607199767fToomas Soome		return (ENOENT);
1608199767fToomas Soome	zc = &ZAP_LEAF_CHUNK(&zl, h);
1609199767fToomas Soome	while (zc->l_entry.le_hash != hash) {
1610199767fToomas Soome		if (zc->l_entry.le_next == 0xffff) {
1611199767fToomas Soome			zc = 0;
1612199767fToomas Soome			break;
1613199767fToomas Soome		}
1614199767fToomas Soome		zc = &ZAP_LEAF_CHUNK(&zl, zc->l_entry.le_next);
1615199767fToomas Soome	}
1616199767fToomas Soome	if (fzap_name_equal(&zl, zc, name)) {
16174a04e8dToomas Soome		if (zc->l_entry.le_value_intlen > integer_size)
16184a04e8dToomas Soome			return (EINVAL);
16194a04e8dToomas Soome
16204a04e8dToomas Soome		fzap_leaf_array(&zl, zc, integer_size, num_integers, value);
1621199767fToomas Soome		return (0);
1622199767fToomas Soome	}
1623199767fToomas Soome
1624199767fToomas Soome	return (ENOENT);
1625199767fToomas Soome}
1626199767fToomas Soome
1627199767fToomas Soome/*
1628199767fToomas Soome * Lookup a name in a zap object and return its value as a uint64_t.
1629199767fToomas Soome */
1630199767fToomas Soomestatic int
16314a04e8dToomas Soomezap_lookup(const spa_t *spa, const dnode_phys_t *dnode, const char *name,
16324a04e8dToomas Soome    uint64_t integer_size, uint64_t num_integers, void *value)
1633199767fToomas Soome{
1634199767fToomas Soome	int rc;
1635199767fToomas Soome	uint64_t zap_type;
1636199767fToomas Soome	size_t size = dnode->dn_datablkszsec << SPA_MINBLOCKSHIFT;
1637199767fToomas Soome
1638199767fToomas Soome	rc = dnode_read(spa, dnode, 0, zap_scratch, size);
1639199767fToomas Soome	if (rc)
1640199767fToomas Soome		return (rc);
1641199767fToomas Soome
1642199767fToomas Soome	zap_type = *(uint64_t *) zap_scratch;
1643199767fToomas Soome	if (zap_type == ZBT_MICRO)
1644199767fToomas Soome		return mzap_lookup(dnode, name, value);
16454a04e8dToomas Soome	else if (zap_type == ZBT_HEADER) {
16464a04e8dToomas Soome		return fzap_lookup(spa, dnode, name, integer_size,
16474a04e8dToomas Soome		    num_integers, value);
16484a04e8dToomas Soome	}
1649199767fToomas Soome	printf("ZFS: invalid zap_type=%d\n", (int)zap_type);
1650199767fToomas Soome	return (EIO);
1651199767fToomas Soome}
1652199767fToomas Soome
1653199767fToomas Soome/*
1654199767fToomas Soome * List a microzap directory. Assumes that the zap scratch buffer contains
1655199767fToomas Soome * the directory contents.
1656199767fToomas Soome */
1657199767fToomas Soomestatic int
1658199767fToomas Soomemzap_list(const dnode_phys_t *dnode, int (*callback)(const char *, uint64_t))
1659199767fToomas Soome{
1660199767fToomas Soome	const mzap_phys_t *mz;
1661199767fToomas Soome	const mzap_ent_phys_t *mze;
1662199767fToomas Soome	size_t size;
1663199767fToomas Soome	int chunks, i, rc;
1664199767fToomas Soome
1665199767fToomas Soome	/*
1666199767fToomas Soome	 * Microzap objects use exactly one block. Read the whole
1667199767fToomas Soome	 * thing.
1668199767fToomas Soome	 */
1669199767fToomas Soome	size = dnode->dn_datablkszsec * 512;
1670199767fToomas Soome	mz = (const mzap_phys_t *) zap_scratch;
1671199767fToomas Soome	chunks = size / MZAP_ENT_LEN - 1;
1672199767fToomas Soome
1673199767fToomas Soome	for (i = 0; i < chunks; i++) {
1674199767fToomas Soome		mze = &mz->mz_chunk[i];
1675199767fToomas Soome		if (mze->mze_name[0]) {
1676199767fToomas Soome			rc = callback(mze->mze_name, mze->mze_value);
1677199767fToomas Soome			if (rc != 0)
1678199767fToomas Soome				return (rc);
1679199767fToomas Soome		}
1680199767fToomas Soome	}
1681199767fToomas Soome
1682199767fToomas Soome	return (0);
1683199767fToomas Soome}
1684199767fToomas Soome
1685199767fToomas Soome/*
1686199767fToomas Soome * List a fatzap directory. Assumes that the zap scratch buffer contains
1687199767fToomas Soome * the directory header.
1688199767fToomas Soome */
1689199767fToomas Soomestatic int
1690199767fToomas Soomefzap_list(const spa_t *spa, const dnode_phys_t *dnode, int (*callback)(const char *, uint64_t))
1691199767fToomas Soome{
1692199767fToomas Soome	int bsize = dnode->dn_datablkszsec << SPA_MINBLOCKSHIFT;
1693199767fToomas Soome	zap_phys_t zh = *(zap_phys_t *) zap_scratch;
1694199767fToomas Soome	fat_zap_t z;
1695199767fToomas Soome	int i, j, rc;
1696199767fToomas Soome
1697199767fToomas Soome	if (zh.zap_magic != ZAP_MAGIC)
1698199767fToomas Soome		return (EIO);
1699199767fToomas Soome
1700199767fToomas Soome	z.zap_block_shift = ilog2(bsize);
1701199767fToomas Soome	z.zap_phys = (zap_phys_t *) zap_scratch;
1702199767fToomas Soome
1703199767fToomas Soome	/*
1704199767fToomas Soome	 * This assumes that the leaf blocks start at block 1. The
1705199767fToomas Soome	 * documentation isn't exactly clear on this.
1706199767fToomas Soome	 */
1707199767fToomas Soome	zap_leaf_t zl;
1708199767fToomas Soome	zl.l_bs = z.zap_block_shift;
1709199767fToomas Soome	for (i = 0; i < zh.zap_num_leafs; i++) {
1710130d765Toomas Soome		off_t off = ((off_t)(i + 1)) << zl.l_bs;
1711199767fToomas Soome		char name[256], *p;
1712199767fToomas Soome		uint64_t value;
1713199767fToomas Soome
1714199767fToomas Soome		if (dnode_read(spa, dnode, off, zap_scratch, bsize))
1715199767fToomas Soome			return (EIO);
1716199767fToomas Soome
1717199767fToomas Soome		zl.l_phys = (zap_leaf_phys_t *) zap_scratch;
1718199767fToomas Soome
1719199767fToomas Soome		for (j = 0; j < ZAP_LEAF_NUMCHUNKS(&zl); j++) {
1720199767fToomas Soome			zap_leaf_chunk_t *zc, *nc;
1721199767fToomas Soome			int namelen;
1722199767fToomas Soome
1723199767fToomas Soome			zc = &ZAP_LEAF_CHUNK(&zl, j);
1724199767fToomas Soome			if (zc->l_entry.le_type != ZAP_CHUNK_ENTRY)
1725199767fToomas Soome				continue;
1726199767fToomas Soome			namelen = zc->l_entry.le_name_numints;
1727199767fToomas Soome			if (namelen > sizeof(name))
1728199767fToomas Soome				namelen = sizeof(name);
1729199767fToomas Soome
1730199767fToomas Soome			/*
1731199767fToomas Soome			 * Paste the name back together.
1732199767fToomas Soome			 */
1733199767fToomas Soome			nc = &ZAP_LEAF_CHUNK(&zl, zc->l_entry.le_name_chunk);
1734199767fToomas Soome			p = name;
1735199767fToomas Soome			while (namelen > 0) {
1736199767fToomas Soome				int len;
1737199767fToomas Soome				len = namelen;
1738199767fToomas Soome				if (len > ZAP_LEAF_ARRAY_BYTES)
1739199767fToomas Soome					len = ZAP_LEAF_ARRAY_BYTES;
1740199767fToomas Soome				memcpy(p, nc->l_array.la_array, len);
1741199767fToomas Soome				p += len;
1742199767fToomas Soome				namelen -= len;
1743199767fToomas Soome				nc = &ZAP_LEAF_CHUNK(&zl, nc->l_array.la_next);
1744199767fToomas Soome			}
1745199767fToomas Soome
1746199767fToomas Soome			/*
1747199767fToomas Soome			 * Assume the first eight bytes of the value are
1748199767fToomas Soome			 * a uint64_t.
1749199767fToomas Soome			 */
1750199767fToomas Soome			value = fzap_leaf_value(&zl, zc);
1751199767fToomas Soome
1752199767fToomas Soome			//printf("%s 0x%jx\n", name, (uintmax_t)value);
1753199767fToomas Soome			rc = callback((const char *)name, value);
1754199767fToomas Soome			if (rc != 0)
1755199767fToomas Soome				return (rc);
1756199767fToomas Soome		}
1757199767fToomas Soome	}
1758199767fToomas Soome
1759199767fToomas Soome	return (0);
1760199767fToomas Soome}
1761199767fToomas Soome
1762199767fToomas Soomestatic int zfs_printf(const char *name, uint64_t value __unused)
1763199767fToomas Soome{
1764199767fToomas Soome
1765199767fToomas Soome	printf("%s\n", name);
1766199767fToomas Soome
1767199767fToomas Soome	return (0);
1768199767fToomas Soome}
1769199767fToomas Soome
1770199767fToomas Soome/*
1771199767fToomas Soome * List a zap directory.
1772199767fToomas Soome */
1773199767fToomas Soomestatic int
1774199767fToomas Soomezap_list(const spa_t *spa, const dnode_phys_t *dnode)
1775199767fToomas Soome{
1776199767fToomas Soome	uint64_t zap_type;
1777199767fToomas Soome	size_t size = dnode->dn_datablkszsec * 512;
1778199767fToomas Soome
1779199767fToomas Soome	if (dnode_read(spa, dnode, 0, zap_scratch, size))
1780199767fToomas Soome		return (EIO);
1781199767fToomas Soome
1782199767fToomas Soome	zap_type = *(uint64_t *) zap_scratch;
1783199767fToomas Soome	if (zap_type == ZBT_MICRO)
1784199767fToomas Soome		return mzap_list(dnode, zfs_printf);
1785199767fToomas Soome	else
1786199767fToomas Soome		return fzap_list(spa, dnode, zfs_printf);
1787199767fToomas Soome}
1788199767fToomas Soome
1789199767fToomas Soomestatic int
1790199767fToomas Soomeobjset_get_dnode(const spa_t *spa, const objset_phys_t *os, uint64_t objnum, dnode_phys_t *dnode)
1791199767fToomas Soome{
1792199767fToomas Soome	off_t offset;
1793199767fToomas Soome
1794199767fToomas Soome	offset = objnum * sizeof(dnode_phys_t);
1795199767fToomas Soome	return dnode_read(spa, &os->os_meta_dnode, offset,
1796199767fToomas Soome		dnode, sizeof(dnode_phys_t));
1797199767fToomas Soome}
1798199767fToomas Soome
1799199767fToomas Soomestatic int
1800199767fToomas Soomemzap_rlookup(const spa_t *spa, const dnode_phys_t *dnode, char *name, uint64_t value)
1801199767fToomas Soome{
1802199767fToomas Soome	const mzap_phys_t *mz;
1803199767fToomas Soome	const mzap_ent_phys_t *mze;
1804199767fToomas Soome	size_t size;
1805199767fToomas Soome	int chunks, i;
1806199767fToomas Soome
1807199767fToomas Soome	/*
1808199767fToomas Soome	 * Microzap objects use exactly one block. Read the whole
1809199767fToomas Soome	 * thing.
1810199767fToomas Soome	 */
1811199767fToomas Soome	size = dnode->dn_datablkszsec * 512;
1812199767fToomas Soome
1813199767fToomas Soome	mz = (const mzap_phys_t *) zap_scratch;
1814199767fToomas Soome	chunks = size / MZAP_ENT_LEN - 1;
1815199767fToomas Soome
1816199767fToomas Soome	for (i = 0; i < chunks; i++) {
1817199767fToomas Soome		mze = &mz->mz_chunk[i];
1818199767fToomas Soome		if (value == mze->mze_value) {
1819199767fToomas Soome			strcpy(name, mze->mze_name);
1820199767fToomas Soome			return (0);
1821199767fToomas Soome		}
1822199767fToomas Soome	}
1823199767fToomas Soome
1824199767fToomas Soome	return (ENOENT);
1825199767fToomas Soome}
1826199767fToomas Soome
1827199767fToomas Soomestatic void
1828199767fToomas Soomefzap_name_copy(const zap_leaf_t *zl, const zap_leaf_chunk_t *zc, char *name)
1829199767fToomas Soome{
1830199767fToomas Soome	size_t namelen;
1831199767fToomas Soome	const zap_leaf_chunk_t *nc;
1832199767fToomas Soome	char *p;
1833199767fToomas Soome
1834199767fToomas Soome	namelen = zc->l_entry.le_name_numints;
1835199767fToomas Soome
1836199767fToomas Soome	nc = &ZAP_LEAF_CHUNK(zl, zc->l_entry.le_name_chunk);
1837199767fToomas Soome	p = name;
1838199767fToomas Soome	while (namelen > 0) {
1839199767fToomas Soome		size_t len;
1840199767fToomas Soome		len = namelen;
1841199767fToomas Soome		if (len > ZAP_LEAF_ARRAY_BYTES)
1842199767fToomas Soome			len = ZAP_LEAF_ARRAY_BYTES;
1843199767fToomas Soome		memcpy(p, nc->l_array.la_array, len);
1844199767fToomas Soome		p += len;
1845199767fToomas Soome		namelen -= len;
1846199767fToomas Soome		nc = &ZAP_LEAF_CHUNK(zl, nc->l_array.la_next);
1847199767fToomas Soome	}
1848199767fToomas Soome
1849199767fToomas Soome	*p = '\0';
1850199767fToomas Soome}
1851199767fToomas Soome
1852199767fToomas Soomestatic int
1853199767fToomas Soomefzap_rlookup(const spa_t *spa, const dnode_phys_t *dnode, char *name, uint64_t value)
1854199767fToomas Soome{
1855199767fToomas Soome	int bsize = dnode->dn_datablkszsec << SPA_MINBLOCKSHIFT;
1856199767fToomas Soome	zap_phys_t zh = *(zap_phys_t *) zap_scratch;
1857199767fToomas Soome	fat_zap_t z;
1858199767fToomas Soome	int i, j;
1859199767fToomas Soome
1860199767fToomas Soome	if (zh.zap_magic != ZAP_MAGIC)
1861199767fToomas Soome		return (EIO);
1862199767fToomas Soome
1863199767fToomas Soome	z.zap_block_shift = ilog2(bsize);
1864199767fToomas Soome	z.zap_phys = (zap_phys_t *) zap_scratch;
1865199767fToomas Soome
1866199767fToomas Soome	/*
1867199767fToomas Soome	 * This assumes that the leaf blocks start at block 1. The
1868199767fToomas Soome	 * documentation isn't exactly clear on this.
1869199767fToomas Soome	 */
1870199767fToomas Soome	zap_leaf_t zl;
1871199767fToomas Soome	zl.l_bs = z.zap_block_shift;
1872199767fToomas Soome	for (i = 0; i < zh.zap_num_leafs; i++) {
1873130d765Toomas Soome		off_t off = ((off_t)(i + 1)) << zl.l_bs;
1874199767fToomas Soome
1875199767fToomas Soome		if (dnode_read(spa, dnode, off, zap_scratch, bsize))
1876199767fToomas Soome			return (EIO);
1877199767fToomas Soome
1878199767fToomas Soome		zl.l_phys = (zap_leaf_phys_t *) zap_scratch;
1879199767fToomas Soome
1880199767fToomas Soome		for (j = 0; j < ZAP_LEAF_NUMCHUNKS(&zl); j++) {
1881199767fToomas Soome			zap_leaf_chunk_t *zc;
1882199767fToomas Soome
1883199767fToomas Soome			zc = &ZAP_LEAF_CHUNK(&zl, j);
1884199767fToomas Soome			if (zc->l_entry.le_type != ZAP_CHUNK_ENTRY)
1885199767fToomas Soome				continue;
1886199767fToomas Soome			if (zc->l_entry.le_value_intlen != 8 ||
1887199767fToomas Soome			    zc->l_entry.le_value_numints != 1)
1888199767fToomas Soome				continue;
1889199767fToomas Soome
1890199767fToomas Soome			if (fzap_leaf_value(&zl, zc) == value) {
1891199767fToomas Soome				fzap_name_copy(&zl, zc, name);
1892199767fToomas Soome				return (0);
1893199767fToomas Soome			}
1894199767fToomas Soome		}
1895199767fToomas Soome	}
1896199767fToomas Soome
1897199767fToomas Soome	return (ENOENT);
1898199767fToomas Soome}
1899199767fToomas Soome
1900199767fToomas Soomestatic int
1901199767fToomas Soomezap_rlookup(const spa_t *spa, const dnode_phys_t *dnode, char *name, uint64_t value)
1902199767fToomas Soome{
1903199767fToomas Soome	int rc;
1904199767fToomas Soome	uint64_t zap_type;
1905199767fToomas Soome	size_t size = dnode->dn_datablkszsec * 512;
1906199767fToomas Soome
1907199767fToomas Soome	rc = dnode_read(spa, dnode, 0, zap_scratch, size);
1908199767fToomas Soome	if (rc)
1909199767fToomas Soome		return (rc);
1910199767fToomas Soome
1911199767fToomas Soome	zap_type = *(uint64_t *) zap_scratch;
1912199767fToomas Soome	if (zap_type == ZBT_MICRO)
1913199767fToomas Soome		return mzap_rlookup(spa, dnode, name, value);
1914199767fToomas Soome	else
1915199767fToomas Soome		return fzap_rlookup(spa, dnode, name, value);
1916199767fToomas Soome}
1917199767fToomas Soome
1918199767fToomas Soomestatic int
1919199767fToomas Soomezfs_rlookup(const spa_t *spa, uint64_t objnum, char *result)
1920199767fToomas Soome{
1921199767fToomas Soome	char name[256];
1922199767fToomas Soome	char component[256];
1923199767fToomas Soome	uint64_t dir_obj, parent_obj, child_dir_zapobj;
1924199767fToomas Soome	dnode_phys_t child_dir_zap, dataset, dir, parent;
1925199767fToomas Soome	dsl_dir_phys_t *dd;
1926199767fToomas Soome	dsl_dataset_phys_t *ds;
1927199767fToomas Soome	char *p;
1928199767fToomas Soome	int len;
1929199767fToomas Soome
1930199767fToomas Soome	p = &name[sizeof(name) - 1];
1931199767fToomas Soome	*p = '\0';
1932199767fToomas Soome
1933199767fToomas Soome	if (objset_get_dnode(spa, &spa->spa_mos, objnum, &dataset)) {
1934199767fToomas Soome		printf("ZFS: can't find dataset %ju\n", (uintmax_t)objnum);
1935199767fToomas Soome		return (EIO);
1936199767fToomas Soome	}
1937199767fToomas Soome	ds = (dsl_dataset_phys_t *)&dataset.dn_bonus;
1938199767fToomas Soome	dir_obj = ds->ds_dir_obj;
1939199767fToomas Soome
1940199767fToomas Soome	for (;;) {
1941199767fToomas Soome		if (objset_get_dnode(spa, &spa->spa_mos, dir_obj, &dir) != 0)
1942199767fToomas Soome			return (EIO);
1943199767fToomas Soome		dd = (dsl_dir_phys_t *)&dir.dn_bonus;
1944199767fToomas Soome
1945199767fToomas Soome		/* Actual loop condition. */
1946199767fToomas Soome		parent_obj  = dd->dd_parent_obj;
1947199767fToomas Soome		if (parent_obj == 0)
1948199767fToomas Soome			break;
1949199767fToomas Soome
1950199767fToomas Soome		if (objset_get_dnode(spa, &spa->spa_mos, parent_obj, &parent) != 0)
1951199767fToomas Soome			return (EIO);
1952199767fToomas Soome		dd = (dsl_dir_phys_t *)&parent.dn_bonus;
1953199767fToomas Soome		child_dir_zapobj = dd->dd_child_dir_zapobj;
1954199767fToomas Soome		if (objset_get_dnode(spa, &spa->spa_mos, child_dir_zapobj, &child_dir_zap) != 0)
1955199767fToomas Soome			return (EIO);
1956199767fToomas Soome		if (zap_rlookup(spa, &child_dir_zap, component, dir_obj) != 0)
1957199767fToomas Soome			return (EIO);
1958199767fToomas Soome
1959199767fToomas Soome		len = strlen(component);
1960199767fToomas Soome		p -= len;
1961199767fToomas Soome		memcpy(p, component, len);
1962199767fToomas Soome		--p;
1963199767fToomas Soome		*p = '/';
1964199767fToomas Soome
1965199767fToomas Soome		/* Actual loop iteration. */
1966199767fToomas Soome		dir_obj = parent_obj;
1967199767fToomas Soome	}
1968199767fToomas Soome
1969199767fToomas Soome	if (*p != '\0')
1970199767fToomas Soome		++p;
1971199767fToomas Soome	strcpy(result, p);
1972199767fToomas Soome
1973199767fToomas Soome	return (0);
1974199767fToomas Soome}
1975199767fToomas Soome
1976199767fToomas Soomestatic int
1977199767fToomas Soomezfs_lookup_dataset(const spa_t *spa, const char *name, uint64_t *objnum)
1978199767fToomas Soome{
1979199767fToomas Soome	char element[256];
1980199767fToomas Soome	uint64_t dir_obj, child_dir_zapobj;
1981199767fToomas Soome	dnode_phys_t child_dir_zap, dir;
1982199767fToomas Soome	dsl_dir_phys_t *dd;
1983199767fToomas Soome	const char *p, *q;
1984199767fToomas Soome
1985199767fToomas Soome	if (objset_get_dnode(spa, &spa->spa_mos, DMU_POOL_DIRECTORY_OBJECT, &dir))
1986199767fToomas Soome		return (EIO);
19874a04e8dToomas Soome	if (zap_lookup(spa, &dir, DMU_POOL_ROOT_DATASET, sizeof (dir_obj),
19884a04e8dToomas Soome	    1, &dir_obj))
1989199767fToomas Soome		return (EIO);
1990199767fToomas Soome
1991199767fToomas Soome	p = name;
1992199767fToomas Soome	for (;;) {
1993199767fToomas Soome		if (objset_get_dnode(spa, &spa->spa_mos, dir_obj, &dir))
1994199767fToomas Soome			return (EIO);
1995199767fToomas Soome		dd = (dsl_dir_phys_t *)&dir.dn_bonus;
1996199767fToomas Soome
1997199767fToomas Soome		while (*p == '/')
1998199767fToomas Soome			p++;
1999199767fToomas Soome		/* Actual loop condition #1. */
2000199767fToomas Soome		if (*p == '\0')
2001199767fToomas Soome			break;
2002199767fToomas Soome
2003199767fToomas Soome		q = strchr(p, '/');
2004199767fToomas Soome		if (q) {
2005199767fToomas Soome			memcpy(element, p, q - p);
2006199767fToomas Soome			element[q - p] = '\0';
2007199767fToomas Soome			p = q + 1;
2008199767fToomas Soome		} else {
2009199767fToomas Soome			strcpy(element, p);
2010199767fToomas Soome			p += strlen(p);
2011199767fToomas Soome		}
2012199767fToomas Soome
2013199767fToomas Soome		child_dir_zapobj = dd->dd_child_dir_zapobj;
2014199767fToomas Soome		if (objset_get_dnode(spa, &spa->spa_mos, child_dir_zapobj, &child_dir_zap) != 0)
2015199767fToomas Soome			return (EIO);
2016199767fToomas Soome
2017199767fToomas Soome		/* Actual loop condition #2. */
20184a04e8dToomas Soome		if (zap_lookup(spa, &child_dir_zap, element, sizeof (dir_obj),
20194a04e8dToomas Soome		    1, &dir_obj) != 0)
2020199767fToomas Soome			return (ENOENT);
2021199767fToomas Soome	}
2022199767fToomas Soome
2023199767fToomas Soome	*objnum = dd->dd_head_dataset_obj;
2024199767fToomas Soome	return (0);
2025199767fToomas Soome}
2026199767fToomas Soome
2027199767fToomas Soome#pragma GCC diagnostic ignored "-Wstrict-aliasing"
2028199767fToomas Soomestatic int
2029199767fToomas Soomezfs_list_dataset(const spa_t *spa, uint64_t objnum/*, int pos, char *entry*/)
2030199767fToomas Soome{
2031199767fToomas Soome	uint64_t dir_obj, child_dir_zapobj;
2032199767fToomas Soome	dnode_phys_t child_dir_zap, dir, dataset;
2033199767fToomas Soome	dsl_dataset_phys_t *ds;
2034199767fToomas Soome	dsl_dir_phys_t *dd;
2035199767fToomas Soome
2036199767fToomas Soome	if (objset_get_dnode(spa, &spa->spa_mos, objnum, &dataset)) {
2037199767fToomas Soome		printf("ZFS: can't find dataset %ju\n", (uintmax_t)objnum);
2038199767fToomas Soome		return (EIO);
2039199767fToomas Soome	}
2040199767fToomas Soome	ds = (dsl_dataset_phys_t *) &dataset.dn_bonus;
2041199767fToomas Soome	dir_obj = ds->ds_dir_obj;
2042199767fToomas Soome
2043199767fToomas Soome	if (objset_get_dnode(spa, &spa->spa_mos, dir_obj, &dir)) {
2044199767fToomas Soome		printf("ZFS: can't find dirobj %ju\n", (uintmax_t)dir_obj);
2045199767fToomas Soome		return (EIO);
2046199767fToomas Soome	}
2047199767fToomas Soome	dd = (dsl_dir_phys_t *)&dir.dn_bonus;
2048199767fToomas Soome
2049199767fToomas Soome	child_dir_zapobj = dd->dd_child_dir_zapobj;
2050199767fToomas Soome	if (objset_get_dnode(spa, &spa->spa_mos, child_dir_zapobj, &child_dir_zap) != 0) {
2051199767fToomas Soome		printf("ZFS: can't find child zap %ju\n", (uintmax_t)dir_obj);
2052199767fToomas Soome		return (EIO);
2053199767fToomas Soome	}
2054199767fToomas Soome
2055199767fToomas Soome	return (zap_list(spa, &child_dir_zap) != 0);
2056199767fToomas Soome}
2057199767fToomas Soome
2058199767fToomas Soomeint
2059199767fToomas Soomezfs_callback_dataset(const spa_t *spa, uint64_t objnum, int (*callback)(const char *, uint64_t))
2060199767fToomas Soome{
2061199767fToomas Soome	uint64_t dir_obj, child_dir_zapobj, zap_type;
2062199767fToomas Soome	dnode_phys_t child_dir_zap, dir, dataset;
2063199767fToomas Soome	dsl_dataset_phys_t *ds;
2064199767fToomas Soome	dsl_dir_phys_t *dd;
2065199767fToomas Soome	int err;
2066199767fToomas Soome
2067199767fToomas Soome	err = objset_get_dnode(spa, &spa->spa_mos, objnum, &dataset);
2068199767fToomas Soome	if (err != 0) {
2069199767fToomas Soome		printf("ZFS: can't find dataset %ju\n", (uintmax_t)objnum);
2070199767fToomas Soome		return (err);
2071199767fToomas Soome	}
2072199767fToomas Soome	ds = (dsl_dataset_phys_t *) &dataset.dn_bonus;
2073199767fToomas Soome	dir_obj = ds->ds_dir_obj;
2074199767fToomas Soome
2075199767fToomas Soome	err = objset_get_dnode(spa, &spa->spa_mos, dir_obj, &dir);
2076199767fToomas Soome	if (err != 0) {
2077199767fToomas Soome		printf("ZFS: can't find dirobj %ju\n", (uintmax_t)dir_obj);
2078199767fToomas Soome		return (err);
2079199767fToomas Soome	}
2080199767fToomas Soome	dd = (dsl_dir_phys_t *)&dir.dn_bonus;
2081199767fToomas Soome
2082199767fToomas Soome	child_dir_zapobj = dd->dd_child_dir_zapobj;
2083199767fToomas Soome	err = objset_get_dnode(spa, &spa->spa_mos, child_dir_zapobj, &child_dir_zap);
2084199767fToomas Soome	if (err != 0) {
2085199767fToomas Soome		printf("ZFS: can't find child zap %ju\n", (uintmax_t)dir_obj);
2086199767fToomas Soome		return (err);
2087199767fToomas Soome	}
2088199767fToomas Soome
2089199767fToomas Soome	err = dnode_read(spa, &child_dir_zap, 0, zap_scratch, child_dir_zap.dn_datablkszsec * 512);
2090199767fToomas Soome	if (err != 0)
2091199767fToomas Soome		return (err);
2092199767fToomas Soome
2093199767fToomas Soome	zap_type = *(uint64_t *) zap_scratch;
2094199767fToomas Soome	if (zap_type == ZBT_MICRO)
2095199767fToomas Soome		return mzap_list(&child_dir_zap, callback);
2096199767fToomas Soome	else
2097199767fToomas Soome		return fzap_list(spa, &child_dir_zap, callback);
2098199767fToomas Soome}
2099199767fToomas Soome
2100199767fToomas Soome/*
2101199767fToomas Soome * Find the object set given the object number of its dataset object
2102199767fToomas Soome * and return its details in *objset
2103199767fToomas Soome */
2104199767fToomas Soomestatic int
2105199767fToomas Soomezfs_mount_dataset(const spa_t *spa, uint64_t objnum, objset_phys_t *objset)
2106199767fToomas Soome{
2107199767fToomas Soome	dnode_phys_t dataset;
2108199767fToomas Soome	dsl_dataset_phys_t *ds;
2109199767fToomas Soome
2110199767fToomas Soome	if (objset_get_dnode(spa, &spa->spa_mos, objnum, &dataset)) {
2111199767fToomas Soome		printf("ZFS: can't find dataset %ju\n", (uintmax_t)objnum);
2112199767fToomas Soome		return (EIO);
2113199767fToomas Soome	}
2114199767fToomas Soome
2115199767fToomas Soome	ds = (dsl_dataset_phys_t *) &dataset.dn_bonus;
2116199767fToomas Soome	if (zio_read(spa, &ds->ds_bp, objset)) {
2117199767fToomas Soome		printf("ZFS: can't read object set for dataset %ju\n",
2118199767fToomas Soome		    (uintmax_t)objnum);
2119199767fToomas Soome		return (EIO);
2120199767fToomas Soome	}
2121199767fToomas Soome
2122199767fToomas Soome	return (0);
2123199767fToomas Soome}
2124199767fToomas Soome
2125199767fToomas Soome/*
2126199767fToomas Soome * Find the object set pointed to by the BOOTFS property or the root
2127199767fToomas Soome * dataset if there is none and return its details in *objset
2128199767fToomas Soome */
2129199767fToomas Soomestatic int
2130199767fToomas Soomezfs_get_root(const spa_t *spa, uint64_t *objid)
2131199767fToomas Soome{
2132199767fToomas Soome	dnode_phys_t dir, propdir;
2133199767fToomas Soome	uint64_t props, bootfs, root;
2134199767fToomas Soome
2135199767fToomas Soome	*objid = 0;
2136199767fToomas Soome
2137199767fToomas Soome	/*
2138199767fToomas Soome	 * Start with the MOS directory object.
2139199767fToomas Soome	 */
2140199767fToomas Soome	if (objset_get_dnode(spa, &spa->spa_mos, DMU_POOL_DIRECTORY_OBJECT, &dir)) {
2141199767fToomas Soome		printf("ZFS: can't read MOS object directory\n");
2142199767fToomas Soome		return (EIO);
2143199767fToomas Soome	}
2144199767fToomas Soome
2145199767fToomas Soome	/*
2146199767fToomas Soome	 * Lookup the pool_props and see if we can find a bootfs.
2147199767fToomas Soome	 */
21484a04e8dToomas Soome	if (zap_lookup(spa, &dir, DMU_POOL_PROPS, sizeof (props), 1, &props) == 0
2149199767fToomas Soome	     && objset_get_dnode(spa, &spa->spa_mos, props, &propdir) == 0
21504a04e8dToomas Soome	     && zap_lookup(spa, &propdir, "bootfs", sizeof (bootfs), 1, &bootfs) == 0
2151199767fToomas Soome	     && bootfs != 0)
2152199767fToomas Soome	{
2153199767fToomas Soome		*objid = bootfs;
2154199767fToomas Soome		return (0);
2155199767fToomas Soome	}
2156199767fToomas Soome	/*
2157199767fToomas Soome	 * Lookup the root dataset directory
2158199767fToomas Soome	 */
21594a04e8dToomas Soome	if (zap_lookup(spa, &dir, DMU_POOL_ROOT_DATASET, sizeof (root), 1, &root)
2160199767fToomas Soome	    || objset_get_dnode(spa, &spa->spa_mos, root, &dir)) {
2161199767fToomas Soome		printf("ZFS: can't find root dsl_dir\n");
2162199767fToomas Soome		return (EIO);
2163199767fToomas Soome	}
2164199767fToomas Soome
2165199767fToomas Soome	/*
2166199767fToomas Soome	 * Use the information from the dataset directory's bonus buffer
2167199767fToomas Soome	 * to find the dataset object and from that the object set itself.
2168199767fToomas Soome	 */
2169199767fToomas Soome	dsl_dir_phys_t *dd = (dsl_dir_phys_t *) &dir.dn_bonus;
2170199767fToomas Soome	*objid = dd->dd_head_dataset_obj;
2171199767fToomas Soome	return (0);
2172199767fToomas Soome}
2173199767fToomas Soome
2174199767fToomas Soomestatic int
2175199767fToomas Soomezfs_mount(const spa_t *spa, uint64_t rootobj, struct zfsmount *mnt)
2176199767fToomas Soome{
2177199767fToomas Soome
2178199767fToomas Soome	mnt->spa = spa;
2179199767fToomas Soome
2180199767fToomas Soome	/*
2181199767fToomas Soome	 * Find the root object set if not explicitly provided
2182199767fToomas Soome	 */
2183199767fToomas Soome	if (rootobj == 0 && zfs_get_root(spa, &rootobj)) {
2184199767fToomas Soome		printf("ZFS: can't find root filesystem\n");
2185199767fToomas Soome		return (EIO);
2186199767fToomas Soome	}
2187199767fToomas Soome
2188199767fToomas Soome	if (zfs_mount_dataset(spa, rootobj, &mnt->objset)) {
2189199767fToomas Soome		printf("ZFS: can't open root filesystem\n");
2190199767fToomas Soome		return (EIO);
2191199767fToomas Soome	}
2192199767fToomas Soome
2193199767fToomas Soome	mnt->rootobj = rootobj;
2194199767fToomas Soome
2195199767fToomas Soome	return (0);
2196199767fToomas Soome}
2197199767fToomas Soome
2198199767fToomas Soome/*
2199199767fToomas Soome * callback function for feature name checks.
2200199767fToomas Soome */
2201199767fToomas Soomestatic int
2202199767fToomas Soomecheck_feature(const char *name, uint64_t value)
2203199767fToomas Soome{
2204199767fToomas Soome	int i;
2205199767fToomas Soome
2206199767fToomas Soome	if (value == 0)
2207199767fToomas Soome		return (0);
2208199767fToomas Soome	if (name[0] == '\0')
2209199767fToomas Soome		return (0);
2210199767fToomas Soome
2211199767fToomas Soome	for (i = 0; features_for_read[i] != NULL; i++) {
2212199767fToomas Soome		if (strcmp(name, features_for_read[i]) == 0)
2213199767fToomas Soome			return (0);
2214199767fToomas Soome	}
2215199767fToomas Soome	printf("ZFS: unsupported feature: %s\n", name);
2216199767fToomas Soome	return (EIO);
2217199767fToomas Soome}
2218199767fToomas Soome
2219199767fToomas Soome/*
2220199767fToomas Soome * Checks whether the MOS features that are active are supported.
2221199767fToomas Soome */
2222199767fToomas Soomestatic int
2223199767fToomas Soomecheck_mos_features(const spa_t *spa)
2224199767fToomas Soome{
2225199767fToomas Soome	dnode_phys_t dir;
2226199767fToomas Soome	uint64_t objnum, zap_type;
2227199767fToomas Soome	size_t size;
2228199767fToomas Soome	int rc;
2229199767fToomas Soome
2230199767fToomas Soome	if ((rc = objset_get_dnode(spa, &spa->spa_mos, DMU_OT_OBJECT_DIRECTORY,
2231199767fToomas Soome	    &dir)) != 0)
2232199767fToomas Soome		return (rc);
22335e069aaToomas Soome	if ((rc = zap_lookup(spa, &dir, DMU_POOL_FEATURES_FOR_READ,
22344a04e8dToomas Soome	    sizeof (objnum), 1, &objnum)) != 0) {
22355e069aaToomas Soome		/*
22365e069aaToomas Soome		 * It is older pool without features. As we have already
22375e069aaToomas Soome		 * tested the label, just return without raising the error.
22385e069aaToomas Soome		 */
22395e069aaToomas Soome		if (rc == ENOENT)
22405e069aaToomas Soome			rc = 0;
2241199767fToomas Soome		return (rc);
22425e069aaToomas Soome	}
2243199767fToomas Soome
2244199767fToomas Soome	if ((rc = objset_get_dnode(spa, &spa->spa_mos, objnum, &dir)) != 0)
2245199767fToomas Soome		return (rc);
2246199767fToomas Soome
2247199767fToomas Soome	if (dir.dn_type != DMU_OTN_ZAP_METADATA)
2248199767fToomas Soome		return (EIO);
2249199767fToomas Soome
2250199767fToomas Soome	size = dir.dn_datablkszsec * 512;
2251199767fToomas Soome	if (dnode_read(spa, &dir, 0, zap_scratch, size))
2252199767fToomas Soome		return (EIO);
2253199767fToomas Soome
2254199767fToomas Soome	zap_type = *(uint64_t *) zap_scratch;
2255199767fToomas Soome	if (zap_type == ZBT_MICRO)
2256199767fToomas Soome		rc = mzap_list(&dir, check_feature);
2257199767fToomas Soome	else
2258199767fToomas Soome		rc = fzap_list(spa, &dir, check_feature);
2259199767fToomas Soome
2260199767fToomas Soome	return (rc);
2261199767fToomas Soome}
2262199767fToomas Soome
2263199767fToomas Soomestatic int
2264199767fToomas Soomezfs_spa_init(spa_t *spa)
2265199767fToomas Soome{
22664a04e8dToomas Soome	dnode_phys_t dir;
2267199767fToomas Soome	int rc;
2268199767fToomas Soome
2269199767fToomas Soome	if (zio_read(spa, &spa->spa_uberblock.ub_rootbp, &spa->spa_mos)) {
2270199767fToomas Soome		printf("ZFS: can't read MOS of pool %s\n", spa->spa_name);
2271199767fToomas Soome		return (EIO);
2272199767fToomas Soome	}
2273199767fToomas Soome	if (spa->spa_mos.os_type != DMU_OST_META) {
2274199767fToomas Soome		printf("ZFS: corrupted MOS of pool %s\n", spa->spa_name);
2275199767fToomas Soome		return (EIO);
2276199767fToomas Soome	}
2277199767fToomas Soome
22784a04e8dToomas Soome	if (objset_get_dnode(spa, &spa->spa_mos, DMU_POOL_DIRECTORY_OBJECT,
22794a04e8dToomas Soome	    &dir)) {
22804a04e8dToomas Soome		printf("ZFS: failed to read pool %s directory object\n",
22814a04e8dToomas Soome		    spa->spa_name);
22824a04e8dToomas Soome		return (EIO);
22834a04e8dToomas Soome	}
22844a04e8dToomas Soome	/* this is allowed to fail, older pools do not have salt */
22854a04e8dToomas Soome	rc = zap_lookup(spa, &dir, DMU_POOL_CHECKSUM_SALT, 1,
22864a04e8dToomas Soome	    sizeof (spa->spa_cksum_salt.zcs_bytes),
22874a04e8dToomas Soome	    spa->spa_cksum_salt.zcs_bytes);
22884a04e8dToomas Soome
2289199767fToomas Soome	rc = check_mos_features(spa);
2290199767fToomas Soome	if (rc != 0) {
2291199767fToomas Soome		printf("ZFS: pool %s is not supported\n", spa->spa_name);
2292199767fToomas Soome	}
2293199767fToomas Soome
2294199767fToomas Soome	return (rc);
2295199767fToomas Soome}
2296199767fToomas Soome
2297199767fToomas Soomestatic int
2298199767fToomas Soomezfs_dnode_stat(const spa_t *spa, dnode_phys_t *dn, struct stat *sb)
2299199767fToomas Soome{
2300199767fToomas Soome
2301199767fToomas Soome	if (dn->dn_bonustype != DMU_OT_SA) {
2302199767fToomas Soome		znode_phys_t *zp = (znode_phys_t *)dn->dn_bonus;
2303199767fToomas Soome
2304199767fToomas Soome		sb->st_mode = zp->zp_mode;
2305199767fToomas Soome		sb->st_uid = zp->zp_uid;
2306199767fToomas Soome		sb->st_gid = zp->zp_gid;
2307199767fToomas Soome		sb->st_size = zp->zp_size;
2308199767fToomas Soome	} else {
2309199767fToomas Soome		sa_hdr_phys_t *sahdrp;
2310199767fToomas Soome		int hdrsize;
2311199767fToomas Soome		size_t size = 0;
2312199767fToomas Soome		void *buf = NULL;
2313199767fToomas Soome
2314199767fToomas Soome		if (dn->dn_bonuslen != 0)
2315199767fToomas Soome			sahdrp = (sa_hdr_phys_t *)DN_BONUS(dn);
2316199767fToomas Soome		else {
2317199767fToomas Soome			if ((dn->dn_flags & DNODE_FLAG_SPILL_BLKPTR) != 0) {
2318f905073Toomas Soome				blkptr_t *bp = DN_SPILL_BLKPTR(dn);
2319199767fToomas Soome				int error;
2320199767fToomas Soome
2321199767fToomas Soome				size = BP_GET_LSIZE(bp);
2322199767fToomas Soome				buf = zfs_alloc(size);
2323199767fToomas Soome				error = zio_read(spa, bp, buf);
2324199767fToomas Soome				if (error != 0) {
2325199767fToomas Soome					zfs_free(buf, size);
2326199767fToomas Soome					return (error);
2327199767fToomas Soome				}
2328199767fToomas Soome				sahdrp = buf;
2329199767fToomas Soome			} else {
2330199767fToomas Soome				return (EIO);
2331199767fToomas Soome			}
2332199767fToomas Soome		}
2333199767fToomas Soome		hdrsize = SA_HDR_SIZE(sahdrp);
2334199767fToomas Soome		sb->st_mode = *(uint64_t *)((char *)sahdrp + hdrsize +
2335199767fToomas Soome		    SA_MODE_OFFSET);
2336199767fToomas Soome		sb->st_uid = *(uint64_t *)((char *)sahdrp + hdrsize +
2337199767fToomas Soome		    SA_UID_OFFSET);
2338199767fToomas Soome		sb->st_gid = *(uint64_t *)((char *)sahdrp + hdrsize +
2339199767fToomas Soome		    SA_GID_OFFSET);
2340199767fToomas Soome		sb->st_size = *(uint64_t *)((char *)sahdrp + hdrsize +
2341199767fToomas Soome		    SA_SIZE_OFFSET);
2342199767fToomas Soome		if (buf != NULL)
2343199767fToomas Soome			zfs_free(buf, size);
2344199767fToomas Soome	}
2345199767fToomas Soome
2346199767fToomas Soome	return (0);
2347199767fToomas Soome}
2348199767fToomas Soome
2349fae4f9eToomas Soomestatic int
2350fae4f9eToomas Soomezfs_dnode_readlink(const spa_t *spa, dnode_phys_t *dn, char *path, size_t psize)
2351fae4f9eToomas Soome{
2352fae4f9eToomas Soome	int rc = 0;
2353fae4f9eToomas Soome
2354fae4f9eToomas Soome	if (dn->dn_bonustype == DMU_OT_SA) {
2355fae4f9eToomas Soome		sa_hdr_phys_t *sahdrp = NULL;
2356fae4f9eToomas Soome		size_t size = 0;
2357fae4f9eToomas Soome		void *buf = NULL;
2358fae4f9eToomas Soome		int hdrsize;
2359fae4f9eToomas Soome		char *p;
2360fae4f9eToomas Soome
2361fae4f9eToomas Soome		if (dn->dn_bonuslen != 0)
2362fae4f9eToomas Soome			sahdrp = (sa_hdr_phys_t *)DN_BONUS(dn);
2363fae4f9eToomas Soome		else {
2364fae4f9eToomas Soome			blkptr_t *bp;
2365fae4f9eToomas Soome
2366fae4f9eToomas Soome			if ((dn->dn_flags & DNODE_FLAG_SPILL_BLKPTR) == 0)
2367fae4f9eToomas Soome				return (EIO);
2368f905073Toomas Soome			bp = DN_SPILL_BLKPTR(dn);
2369fae4f9eToomas Soome
2370fae4f9eToomas Soome			size = BP_GET_LSIZE(bp);
2371fae4f9eToomas Soome			buf = zfs_alloc(size);
2372fae4f9eToomas Soome			rc = zio_read(spa, bp, buf);
2373fae4f9eToomas Soome			if (rc != 0) {
2374fae4f9eToomas Soome				zfs_free(buf, size);
2375fae4f9eToomas Soome				return (rc);
2376fae4f9eToomas Soome			}
2377fae4f9eToomas Soome			sahdrp = buf;
2378fae4f9eToomas Soome		}
2379fae4f9eToomas Soome		hdrsize = SA_HDR_SIZE(sahdrp);
2380fae4f9eToomas Soome		p = (char *)((uintptr_t)sahdrp + hdrsize + SA_SYMLINK_OFFSET);
2381fae4f9eToomas Soome		memcpy(path, p, psize);
2382fae4f9eToomas Soome		if (buf != NULL)
2383fae4f9eToomas Soome			zfs_free(buf, size);
2384fae4f9eToomas Soome		return (0);
2385fae4f9eToomas Soome	}
2386fae4f9eToomas Soome	/*
2387fae4f9eToomas Soome	 * Second test is purely to silence bogus compiler
2388fae4f9eToomas Soome	 * warning about accessing past the end of dn_bonus.
2389fae4f9eToomas Soome	 */
2390fae4f9eToomas Soome	if (psize + sizeof(znode_phys_t) <= dn->dn_bonuslen &&
2391fae4f9eToomas Soome	    sizeof(znode_phys_t) <= sizeof(dn->dn_bonus)) {
2392fae4f9eToomas Soome		memcpy(path, &dn->dn_bonus[sizeof(znode_phys_t)], psize);
2393fae4f9eToomas Soome	} else {
2394fae4f9eToomas Soome		rc = dnode_read(spa, dn, 0, path, psize);
2395fae4f9eToomas Soome	}
2396fae4f9eToomas Soome	return (rc);
2397fae4f9eToomas Soome}
2398fae4f9eToomas Soome
2399fae4f9eToomas Soomestruct obj_list {
2400fae4f9eToomas Soome	uint64_t		objnum;
2401fae4f9eToomas Soome	STAILQ_ENTRY(obj_list)	entry;
2402fae4f9eToomas Soome};
2403fae4f9eToomas Soome
2404199767fToomas Soome/*
2405199767fToomas Soome * Lookup a file and return its dnode.
2406199767fToomas Soome */
2407199767fToomas Soomestatic int
2408199767fToomas Soomezfs_lookup(const struct zfsmount *mnt, const char *upath, dnode_phys_t *dnode)
2409199767fToomas Soome{
2410199767fToomas Soome	int rc;
2411fae4f9eToomas Soome	uint64_t objnum;
2412199767fToomas Soome	const spa_t *spa;
2413199767fToomas Soome	dnode_phys_t dn;
2414199767fToomas Soome	const char *p, *q;
2415199767fToomas Soome	char element[256];
2416199767fToomas Soome	char path[1024];
2417199767fToomas Soome	int symlinks_followed = 0;
2418199767fToomas Soome	struct stat sb;
2419fae4f9eToomas Soome	struct obj_list *entry, *tentry;
2420fae4f9eToomas Soome	STAILQ_HEAD(, obj_list) on_cache = STAILQ_HEAD_INITIALIZER(on_cache);
2421199767fToomas Soome
2422199767fToomas Soome	spa = mnt->spa;
2423199767fToomas Soome	if (mnt->objset.os_type != DMU_OST_ZFS) {
2424199767fToomas Soome		printf("ZFS: unexpected object set type %ju\n",
2425199767fToomas Soome		    (uintmax_t)mnt->objset.os_type);
2426199767fToomas Soome		return (EIO);
2427199767fToomas Soome	}
2428199767fToomas Soome
2429fae4f9eToomas Soome	if ((entry = malloc(sizeof(struct obj_list))) == NULL)
2430fae4f9eToomas Soome		return (ENOMEM);
2431fae4f9eToomas Soome
2432199767fToomas Soome	/*
2433199767fToomas Soome	 * Get the root directory dnode.
2434199767fToomas Soome	 */
2435199767fToomas Soome	rc = objset_get_dnode(spa, &mnt->objset, MASTER_NODE_OBJ, &dn);
2436fae4f9eToomas Soome	if (rc) {
2437fae4f9eToomas Soome		free(entry);
2438199767fToomas Soome		return (rc);
2439fae4f9eToomas Soome	}
2440199767fToomas Soome
24414a04e8dToomas Soome	rc = zap_lookup(spa, &dn, ZFS_ROOT_OBJ, sizeof(objnum), 1, &objnum);
2442fae4f9eToomas Soome	if (rc) {
2443fae4f9eToomas Soome		free(entry);
2444199767fToomas Soome		return (rc);
2445fae4f9eToomas Soome	}
2446fae4f9eToomas Soome	entry->objnum = objnum;
2447fae4f9eToomas Soome	STAILQ_INSERT_HEAD(&on_cache, entry, entry);
2448199767fToomas Soome
2449fae4f9eToomas Soome	rc = objset_get_dnode(spa, &mnt->objset, objnum, &dn);
2450fae4f9eToomas Soome	if (rc != 0)
2451fae4f9eToomas Soome		goto done;
2452199767fToomas Soome
2453199767fToomas Soome	p = upath;
2454199767fToomas Soome	while (p && *p) {
2455fae4f9eToomas Soome		rc = objset_get_dnode(spa, &mnt->objset, objnum, &dn);
2456fae4f9eToomas Soome		if (rc != 0)
2457fae4f9eToomas Soome			goto done;
2458fae4f9eToomas Soome
2459199767fToomas Soome		while (*p == '/')
2460199767fToomas Soome			p++;
2461fae4f9eToomas Soome		if (*p == '\0')
2462199767fToomas Soome			break;
2463fae4f9eToomas Soome		q = p;
2464fae4f9eToomas Soome		while (*q != '\0' && *q != '/')
2465fae4f9eToomas Soome			q++;
2466199767fToomas Soome
2467fae4f9eToomas Soome		/* skip dot */
2468fae4f9eToomas Soome		if (p + 1 == q && p[0] == '.') {
2469fae4f9eToomas Soome			p++;
2470fae4f9eToomas Soome			continue;
2471fae4f9eToomas Soome		}
2472fae4f9eToomas Soome		/* double dot */
2473fae4f9eToomas Soome		if (p + 2 == q && p[0] == '.' && p[1] == '.') {
2474fae4f9eToomas Soome			p += 2;
2475fae4f9eToomas Soome			if (STAILQ_FIRST(&on_cache) ==
2476fae4f9eToomas Soome			    STAILQ_LAST(&on_cache, obj_list, entry)) {
2477fae4f9eToomas Soome				rc = ENOENT;
2478fae4f9eToomas Soome				goto done;
2479fae4f9eToomas Soome			}
2480fae4f9eToomas Soome			entry = STAILQ_FIRST(&on_cache);
2481fae4f9eToomas Soome			STAILQ_REMOVE_HEAD(&on_cache, entry);
2482fae4f9eToomas Soome			free(entry);
2483fae4f9eToomas Soome			objnum = (STAILQ_FIRST(&on_cache))->objnum;
2484fae4f9eToomas Soome			continue;
2485fae4f9eToomas Soome		}
2486fae4f9eToomas Soome		if (q - p + 1 > sizeof(element)) {
2487fae4f9eToomas Soome			rc = ENAMETOOLONG;
2488fae4f9eToomas Soome			goto done;
2489fae4f9eToomas Soome		}
2490fae4f9eToomas Soome		memcpy(element, p, q - p);
2491fae4f9eToomas Soome		element[q - p] = 0;
2492fae4f9eToomas Soome		p = q;
2493fae4f9eToomas Soome
2494fae4f9eToomas Soome		if ((rc = zfs_dnode_stat(spa, &dn, &sb)) != 0)
2495fae4f9eToomas Soome			goto done;
2496fae4f9eToomas Soome		if (!S_ISDIR(sb.st_mode)) {
2497fae4f9eToomas Soome			rc = ENOTDIR;
2498fae4f9eToomas Soome			goto done;
2499fae4f9eToomas Soome		}
2500199767fToomas Soome
25014a04e8dToomas Soome		rc = zap_lookup(spa, &dn, element, sizeof(objnum), 1, &objnum);
2502199767fToomas Soome		if (rc)
2503fae4f9eToomas Soome			goto done;
2504199767fToomas Soome		objnum = ZFS_DIRENT_OBJ(objnum);
2505199767fToomas Soome
2506fae4f9eToomas Soome		if ((entry = malloc(sizeof(struct obj_list))) == NULL) {
2507fae4f9eToomas Soome			rc = ENOMEM;
2508fae4f9eToomas Soome			goto done;
2509fae4f9eToomas Soome		}
2510fae4f9eToomas Soome		entry->objnum = objnum;
2511fae4f9eToomas Soome		STAILQ_INSERT_HEAD(&on_cache, entry, entry);
2512199767fToomas Soome		rc = objset_get_dnode(spa, &mnt->objset, objnum, &dn);
2513199767fToomas Soome		if (rc)
2514fae4f9eToomas Soome			goto done;
2515199767fToomas Soome
2516199767fToomas Soome		/*
2517199767fToomas Soome		 * Check for symlink.
2518199767fToomas Soome		 */
2519199767fToomas Soome		rc = zfs_dnode_stat(spa, &dn, &sb);
2520199767fToomas Soome		if (rc)
2521fae4f9eToomas Soome			goto done;
2522199767fToomas Soome		if (S_ISLNK(sb.st_mode)) {
2523fae4f9eToomas Soome			if (symlinks_followed > 10) {
2524fae4f9eToomas Soome				rc = EMLINK;
2525fae4f9eToomas Soome				goto done;
2526fae4f9eToomas Soome			}
2527199767fToomas Soome			symlinks_followed++;
2528199767fToomas Soome
2529199767fToomas Soome			/*
2530199767fToomas Soome			 * Read the link value and copy the tail of our
2531199767fToomas Soome			 * current path onto the end.
2532199767fToomas Soome			 */
2533fae4f9eToomas Soome			if (sb.st_size + strlen(p) + 1 > sizeof(path)) {
2534fae4f9eToomas Soome				rc = ENAMETOOLONG;
2535fae4f9eToomas Soome				goto done;
2536199767fToomas Soome			}
2537fae4f9eToomas Soome			strcpy(&path[sb.st_size], p);
2538fae4f9eToomas Soome
2539fae4f9eToomas Soome			rc = zfs_dnode_readlink(spa, &dn, path, sb.st_size);
2540fae4f9eToomas Soome			if (rc != 0)
2541fae4f9eToomas Soome				goto done;
2542199767fToomas Soome
2543199767fToomas Soome			/*
2544199767fToomas Soome			 * Restart with the new path, starting either at
2545199767fToomas Soome			 * the root or at the parent depending whether or
2546199767fToomas Soome			 * not the link is relative.
2547199767fToomas Soome			 */
2548199767fToomas Soome			p = path;
2549fae4f9eToomas Soome			if (*p == '/') {
2550fae4f9eToomas Soome				while (STAILQ_FIRST(&on_cache) !=
2551fae4f9eToomas Soome				    STAILQ_LAST(&on_cache, obj_list, entry)) {
2552fae4f9eToomas Soome					entry = STAILQ_FIRST(&on_cache);
2553fae4f9eToomas Soome					STAILQ_REMOVE_HEAD(&on_cache, entry);
2554fae4f9eToomas Soome					free(entry);
2555fae4f9eToomas Soome				}
2556fae4f9eToomas Soome			} else {
2557fae4f9eToomas Soome				entry = STAILQ_FIRST(&on_cache);
2558fae4f9eToomas Soome				STAILQ_REMOVE_HEAD(&on_cache, entry);
2559fae4f9eToomas Soome				free(entry);
2560fae4f9eToomas Soome			}
2561fae4f9eToomas Soome			objnum = (STAILQ_FIRST(&on_cache))->objnum;
2562199767fToomas Soome		}
2563199767fToomas Soome	}
2564199767fToomas Soome
2565199767fToomas Soome	*dnode = dn;
2566fae4f9eToomas Soomedone:
2567fae4f9eToomas Soome	STAILQ_FOREACH_SAFE(entry, &on_cache, entry, tentry)
2568fae4f9eToomas Soome		free(entry);
2569fae4f9eToomas Soome	return (rc);
2570199767fToomas Soome}