xref: /freebsd/stand/libsa/zfs/zfs.c (revision 9c067b844f85a224f0416e6eb46ba3ef82aec5c4)
1 /*-
2  * Copyright (c) 2007 Doug Rabson
3  * All rights reserved.
4  *
5  * Redistribution and use in source and binary forms, with or without
6  * modification, are permitted provided that the following conditions
7  * are met:
8  * 1. Redistributions of source code must retain the above copyright
9  *    notice, this list of conditions and the following disclaimer.
10  * 2. Redistributions in binary form must reproduce the above copyright
11  *    notice, this list of conditions and the following disclaimer in the
12  *    documentation and/or other materials provided with the distribution.
13  *
14  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
15  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
16  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
17  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
18  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
19  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
20  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
21  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
22  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
23  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
24  * SUCH DAMAGE.
25  *
26  *	$FreeBSD$
27  */
28 
29 #include <sys/cdefs.h>
30 __FBSDID("$FreeBSD$");
31 
32 /*
33  *	Stand-alone file reading package.
34  */
35 
36 #include <stand.h>
37 #include <sys/disk.h>
38 #include <sys/param.h>
39 #include <sys/time.h>
40 #include <sys/queue.h>
41 #include <part.h>
42 #include <stddef.h>
43 #include <stdarg.h>
44 #include <string.h>
45 #include <bootstrap.h>
46 
47 #include "libzfs.h"
48 
49 #include "zfsimpl.c"
50 
51 /* Define the range of indexes to be populated with ZFS Boot Environments */
52 #define		ZFS_BE_FIRST	4
53 #define		ZFS_BE_LAST	8
54 
55 static int	zfs_open(const char *path, struct open_file *f);
56 static int	zfs_close(struct open_file *f);
57 static int	zfs_read(struct open_file *f, void *buf, size_t size, size_t *resid);
58 static off_t	zfs_seek(struct open_file *f, off_t offset, int where);
59 static int	zfs_stat(struct open_file *f, struct stat *sb);
60 static int	zfs_readdir(struct open_file *f, struct dirent *d);
61 static int	zfs_mount(const char *dev, const char *path, void **data);
62 static int	zfs_unmount(const char *dev, void *data);
63 
64 static void	zfs_bootenv_initial(const char *envname, spa_t *spa,
65 		    const char *name, const char *dsname, int checkpoint);
66 static void	zfs_checkpoints_initial(spa_t *spa, const char *name,
67 		    const char *dsname);
68 
69 static int	zfs_parsedev(struct devdesc **idev, const char *devspec,
70 		    const char **path);
71 
72 struct devsw zfs_dev;
73 
74 struct fs_ops zfs_fsops = {
75 	.fs_name = "zfs",
76 	.fo_open = zfs_open,
77 	.fo_close = zfs_close,
78 	.fo_read = zfs_read,
79 	.fo_write = null_write,
80 	.fo_seek = zfs_seek,
81 	.fo_stat = zfs_stat,
82 	.fo_readdir = zfs_readdir,
83 	.fo_mount = zfs_mount,
84 	.fo_unmount = zfs_unmount
85 };
86 
87 /*
88  * In-core open file.
89  */
90 struct file {
91 	off_t		f_seekp;	/* seek pointer */
92 	dnode_phys_t	f_dnode;
93 	uint64_t	f_zap_type;	/* zap type for readdir */
94 	uint64_t	f_num_leafs;	/* number of fzap leaf blocks */
95 	zap_leaf_phys_t	*f_zap_leaf;	/* zap leaf buffer */
96 };
97 
98 static int	zfs_env_index;
99 static int	zfs_env_count;
100 
101 SLIST_HEAD(zfs_be_list, zfs_be_entry) zfs_be_head = SLIST_HEAD_INITIALIZER(zfs_be_head);
102 struct zfs_be_list *zfs_be_headp;
103 struct zfs_be_entry {
104 	char *name;
105 	SLIST_ENTRY(zfs_be_entry) entries;
106 } *zfs_be, *zfs_be_tmp;
107 
108 /*
109  * Open a file.
110  */
111 static int
112 zfs_open(const char *upath, struct open_file *f)
113 {
114 	struct devdesc *dev = f->f_devdata;
115 	struct zfsmount *mount = dev->d_opendata;
116 	struct file *fp;
117 	int rc;
118 
119 	if (f->f_dev != &zfs_dev)
120 		return (EINVAL);
121 
122 	/* allocate file system specific data structure */
123 	fp = calloc(1, sizeof(struct file));
124 	if (fp == NULL)
125 		return (ENOMEM);
126 	f->f_fsdata = fp;
127 
128 	rc = zfs_lookup(mount, upath, &fp->f_dnode);
129 	fp->f_seekp = 0;
130 	if (rc) {
131 		f->f_fsdata = NULL;
132 		free(fp);
133 	}
134 	return (rc);
135 }
136 
137 static int
138 zfs_close(struct open_file *f)
139 {
140 	struct file *fp = (struct file *)f->f_fsdata;
141 
142 	dnode_cache_obj = NULL;
143 	f->f_fsdata = NULL;
144 
145 	free(fp);
146 	return (0);
147 }
148 
149 /*
150  * Copy a portion of a file into kernel memory.
151  * Cross block boundaries when necessary.
152  */
153 static int
154 zfs_read(struct open_file *f, void *start, size_t size, size_t *resid	/* out */)
155 {
156 	struct devdesc *dev = f->f_devdata;
157 	const spa_t *spa = ((struct zfsmount *)dev->d_opendata)->spa;
158 	struct file *fp = (struct file *)f->f_fsdata;
159 	struct stat sb;
160 	size_t n;
161 	int rc;
162 
163 	rc = zfs_stat(f, &sb);
164 	if (rc)
165 		return (rc);
166 	n = size;
167 	if (fp->f_seekp + n > sb.st_size)
168 		n = sb.st_size - fp->f_seekp;
169 
170 	rc = dnode_read(spa, &fp->f_dnode, fp->f_seekp, start, n);
171 	if (rc)
172 		return (rc);
173 
174 	if (0) {
175 	    int i;
176 	    for (i = 0; i < n; i++)
177 		putchar(((char*) start)[i]);
178 	}
179 	fp->f_seekp += n;
180 	if (resid)
181 		*resid = size - n;
182 
183 	return (0);
184 }
185 
186 static off_t
187 zfs_seek(struct open_file *f, off_t offset, int where)
188 {
189 	struct file *fp = (struct file *)f->f_fsdata;
190 
191 	switch (where) {
192 	case SEEK_SET:
193 		fp->f_seekp = offset;
194 		break;
195 	case SEEK_CUR:
196 		fp->f_seekp += offset;
197 		break;
198 	case SEEK_END:
199 	    {
200 		struct stat sb;
201 		int error;
202 
203 		error = zfs_stat(f, &sb);
204 		if (error != 0) {
205 			errno = error;
206 			return (-1);
207 		}
208 		fp->f_seekp = sb.st_size - offset;
209 		break;
210 	    }
211 	default:
212 		errno = EINVAL;
213 		return (-1);
214 	}
215 	return (fp->f_seekp);
216 }
217 
218 static int
219 zfs_stat(struct open_file *f, struct stat *sb)
220 {
221 	struct devdesc *dev = f->f_devdata;
222 	const spa_t *spa = ((struct zfsmount *)dev->d_opendata)->spa;
223 	struct file *fp = (struct file *)f->f_fsdata;
224 
225 	return (zfs_dnode_stat(spa, &fp->f_dnode, sb));
226 }
227 
228 static int
229 zfs_readdir(struct open_file *f, struct dirent *d)
230 {
231 	struct devdesc *dev = f->f_devdata;
232 	const spa_t *spa = ((struct zfsmount *)dev->d_opendata)->spa;
233 	struct file *fp = (struct file *)f->f_fsdata;
234 	mzap_ent_phys_t mze;
235 	struct stat sb;
236 	size_t bsize = fp->f_dnode.dn_datablkszsec << SPA_MINBLOCKSHIFT;
237 	int rc;
238 
239 	rc = zfs_stat(f, &sb);
240 	if (rc)
241 		return (rc);
242 	if (!S_ISDIR(sb.st_mode))
243 		return (ENOTDIR);
244 
245 	/*
246 	 * If this is the first read, get the zap type.
247 	 */
248 	if (fp->f_seekp == 0) {
249 		rc = dnode_read(spa, &fp->f_dnode,
250 				0, &fp->f_zap_type, sizeof(fp->f_zap_type));
251 		if (rc)
252 			return (rc);
253 
254 		if (fp->f_zap_type == ZBT_MICRO) {
255 			fp->f_seekp = offsetof(mzap_phys_t, mz_chunk);
256 		} else {
257 			rc = dnode_read(spa, &fp->f_dnode,
258 					offsetof(zap_phys_t, zap_num_leafs),
259 					&fp->f_num_leafs,
260 					sizeof(fp->f_num_leafs));
261 			if (rc)
262 				return (rc);
263 
264 			fp->f_seekp = bsize;
265 			fp->f_zap_leaf = malloc(bsize);
266 			if (fp->f_zap_leaf == NULL)
267 				return (ENOMEM);
268 			rc = dnode_read(spa, &fp->f_dnode,
269 					fp->f_seekp,
270 					fp->f_zap_leaf,
271 					bsize);
272 			if (rc)
273 				return (rc);
274 		}
275 	}
276 
277 	if (fp->f_zap_type == ZBT_MICRO) {
278 	mzap_next:
279 		if (fp->f_seekp >= bsize)
280 			return (ENOENT);
281 
282 		rc = dnode_read(spa, &fp->f_dnode,
283 				fp->f_seekp, &mze, sizeof(mze));
284 		if (rc)
285 			return (rc);
286 		fp->f_seekp += sizeof(mze);
287 
288 		if (!mze.mze_name[0])
289 			goto mzap_next;
290 
291 		d->d_fileno = ZFS_DIRENT_OBJ(mze.mze_value);
292 		d->d_type = ZFS_DIRENT_TYPE(mze.mze_value);
293 		strcpy(d->d_name, mze.mze_name);
294 		d->d_namlen = strlen(d->d_name);
295 		return (0);
296 	} else {
297 		zap_leaf_t zl;
298 		zap_leaf_chunk_t *zc, *nc;
299 		int chunk;
300 		size_t namelen;
301 		char *p;
302 		uint64_t value;
303 
304 		/*
305 		 * Initialise this so we can use the ZAP size
306 		 * calculating macros.
307 		 */
308 		zl.l_bs = ilog2(bsize);
309 		zl.l_phys = fp->f_zap_leaf;
310 
311 		/*
312 		 * Figure out which chunk we are currently looking at
313 		 * and consider seeking to the next leaf. We use the
314 		 * low bits of f_seekp as a simple chunk index.
315 		 */
316 	fzap_next:
317 		chunk = fp->f_seekp & (bsize - 1);
318 		if (chunk == ZAP_LEAF_NUMCHUNKS(&zl)) {
319 			fp->f_seekp = rounddown2(fp->f_seekp, bsize) + bsize;
320 			chunk = 0;
321 
322 			/*
323 			 * Check for EOF and read the new leaf.
324 			 */
325 			if (fp->f_seekp >= bsize * fp->f_num_leafs)
326 				return (ENOENT);
327 
328 			rc = dnode_read(spa, &fp->f_dnode,
329 					fp->f_seekp,
330 					fp->f_zap_leaf,
331 					bsize);
332 			if (rc)
333 				return (rc);
334 		}
335 
336 		zc = &ZAP_LEAF_CHUNK(&zl, chunk);
337 		fp->f_seekp++;
338 		if (zc->l_entry.le_type != ZAP_CHUNK_ENTRY)
339 			goto fzap_next;
340 
341 		namelen = zc->l_entry.le_name_numints;
342 		if (namelen > sizeof(d->d_name))
343 			namelen = sizeof(d->d_name);
344 
345 		/*
346 		 * Paste the name back together.
347 		 */
348 		nc = &ZAP_LEAF_CHUNK(&zl, zc->l_entry.le_name_chunk);
349 		p = d->d_name;
350 		while (namelen > 0) {
351 			int len;
352 			len = namelen;
353 			if (len > ZAP_LEAF_ARRAY_BYTES)
354 				len = ZAP_LEAF_ARRAY_BYTES;
355 			memcpy(p, nc->l_array.la_array, len);
356 			p += len;
357 			namelen -= len;
358 			nc = &ZAP_LEAF_CHUNK(&zl, nc->l_array.la_next);
359 		}
360 		d->d_name[sizeof(d->d_name) - 1] = 0;
361 
362 		/*
363 		 * Assume the first eight bytes of the value are
364 		 * a uint64_t.
365 		 */
366 		value = fzap_leaf_value(&zl, zc);
367 
368 		d->d_fileno = ZFS_DIRENT_OBJ(value);
369 		d->d_type = ZFS_DIRENT_TYPE(value);
370 		d->d_namlen = strlen(d->d_name);
371 
372 		return (0);
373 	}
374 }
375 
376 /*
377  * if path is NULL, create mount structure, but do not add it to list.
378  */
379 static int
380 zfs_mount(const char *dev, const char *path, void **data)
381 {
382 	struct zfs_devdesc *zfsdev = NULL;
383 	spa_t *spa;
384 	struct zfsmount *mnt = NULL;
385 	int rv;
386 
387 	errno = 0;
388 	rv = zfs_parsedev((struct devdesc **)&zfsdev, dev, NULL);
389 	if (rv != 0) {
390 		return (rv);
391 	}
392 
393 	spa = spa_find_by_dev(zfsdev);
394 	if (spa == NULL) {
395 		rv = ENXIO;
396 		goto err;
397 	}
398 
399 	mnt = calloc(1, sizeof(*mnt));
400 	if (mnt == NULL) {
401 		rv = ENOMEM;
402 		goto err;
403 	}
404 
405 	if (mnt->path != NULL) {
406 		mnt->path = strdup(path);
407 		if (mnt->path == NULL) {
408 			rv = ENOMEM;
409 			goto err;
410 		}
411 	}
412 
413 	rv = zfs_mount_impl(spa, zfsdev->root_guid, mnt);
414 
415 	if (rv == 0 && mnt->objset.os_type != DMU_OST_ZFS) {
416 		printf("Unexpected object set type %ju\n",
417 		    (uintmax_t)mnt->objset.os_type);
418 		rv = EIO;
419 	}
420 err:
421 	if (rv != 0) {
422 		if (mnt != NULL)
423 			free(mnt->path);
424 		free(mnt);
425 		free(zfsdev);
426 		return (rv);
427 	}
428 
429 	*data = mnt;
430 	if (path != NULL)
431 		STAILQ_INSERT_TAIL(&zfsmount, mnt, next);
432 
433 	free(zfsdev);
434 
435 	return (rv);
436 }
437 
438 static int
439 zfs_unmount(const char *dev, void *data)
440 {
441 	struct zfsmount *mnt = data;
442 
443 	STAILQ_REMOVE(&zfsmount, mnt, zfsmount, next);
444 	free(mnt->path);
445 	free(mnt);
446 	return (0);
447 }
448 
449 static int
450 vdev_read(vdev_t *vdev, void *priv, off_t offset, void *buf, size_t bytes)
451 {
452 	int fd, ret;
453 	size_t res, head, tail, total_size, full_sec_size;
454 	unsigned secsz, do_tail_read;
455 	off_t start_sec;
456 	char *outbuf, *bouncebuf;
457 
458 	fd = (uintptr_t) priv;
459 	outbuf = (char *) buf;
460 	bouncebuf = NULL;
461 
462 	ret = ioctl(fd, DIOCGSECTORSIZE, &secsz);
463 	if (ret != 0)
464 		return (ret);
465 
466 	/*
467 	 * Handling reads of arbitrary offset and size - multi-sector case
468 	 * and single-sector case.
469 	 *
470 	 *                        Multi-sector Case
471 	 *                (do_tail_read = true if tail > 0)
472 	 *
473 	 *   |<----------------------total_size--------------------->|
474 	 *   |                                                       |
475 	 *   |<--head-->|<--------------bytes------------>|<--tail-->|
476 	 *   |          |                                 |          |
477 	 *   |          |       |<~full_sec_size~>|       |          |
478 	 *   +------------------+                 +------------------+
479 	 *   |          |0101010|     .  .  .     |0101011|          |
480 	 *   +------------------+                 +------------------+
481 	 *         start_sec                         start_sec + n
482 	 *
483 	 *
484 	 *                      Single-sector Case
485 	 *                    (do_tail_read = false)
486 	 *
487 	 *              |<------total_size = secsz----->|
488 	 *              |                               |
489 	 *              |<-head->|<---bytes--->|<-tail->|
490 	 *              +-------------------------------+
491 	 *              |        |0101010101010|        |
492 	 *              +-------------------------------+
493 	 *                          start_sec
494 	 */
495 	start_sec = offset / secsz;
496 	head = offset % secsz;
497 	total_size = roundup2(head + bytes, secsz);
498 	tail = total_size - (head + bytes);
499 	do_tail_read = ((tail > 0) && (head + bytes > secsz));
500 	full_sec_size = total_size;
501 	if (head > 0)
502 		full_sec_size -= secsz;
503 	if (do_tail_read)
504 		full_sec_size -= secsz;
505 
506 	/* Return of partial sector data requires a bounce buffer. */
507 	if ((head > 0) || do_tail_read || bytes < secsz) {
508 		bouncebuf = malloc(secsz);
509 		if (bouncebuf == NULL) {
510 			printf("vdev_read: out of memory\n");
511 			return (ENOMEM);
512 		}
513 	}
514 
515 	if (lseek(fd, start_sec * secsz, SEEK_SET) == -1) {
516 		ret = errno;
517 		goto error;
518 	}
519 
520 	/* Partial data return from first sector */
521 	if (head > 0) {
522 		res = read(fd, bouncebuf, secsz);
523 		if (res != secsz) {
524 			ret = EIO;
525 			goto error;
526 		}
527 		memcpy(outbuf, bouncebuf + head, min(secsz - head, bytes));
528 		outbuf += min(secsz - head, bytes);
529 	}
530 
531 	/*
532 	 * Full data return from read sectors.
533 	 * Note, there is still corner case where we read
534 	 * from sector boundary, but less than sector size, e.g. reading 512B
535 	 * from 4k sector.
536 	 */
537 	if (full_sec_size > 0) {
538 		if (bytes < full_sec_size) {
539 			res = read(fd, bouncebuf, secsz);
540 			if (res != secsz) {
541 				ret = EIO;
542 				goto error;
543 			}
544 			memcpy(outbuf, bouncebuf, bytes);
545 		} else {
546 			res = read(fd, outbuf, full_sec_size);
547 			if (res != full_sec_size) {
548 				ret = EIO;
549 				goto error;
550 			}
551 			outbuf += full_sec_size;
552 		}
553 	}
554 
555 	/* Partial data return from last sector */
556 	if (do_tail_read) {
557 		res = read(fd, bouncebuf, secsz);
558 		if (res != secsz) {
559 			ret = EIO;
560 			goto error;
561 		}
562 		memcpy(outbuf, bouncebuf, secsz - tail);
563 	}
564 
565 	ret = 0;
566 error:
567 	free(bouncebuf);
568 	return (ret);
569 }
570 
571 static int
572 vdev_write(vdev_t *vdev, off_t offset, void *buf, size_t bytes)
573 {
574 	int fd, ret;
575 	size_t head, tail, total_size, full_sec_size;
576 	unsigned secsz, do_tail_write;
577 	off_t start_sec;
578 	ssize_t res;
579 	char *outbuf, *bouncebuf;
580 
581 	fd = (uintptr_t)vdev->v_priv;
582 	outbuf = (char *)buf;
583 	bouncebuf = NULL;
584 
585 	ret = ioctl(fd, DIOCGSECTORSIZE, &secsz);
586 	if (ret != 0)
587 		return (ret);
588 
589 	start_sec = offset / secsz;
590 	head = offset % secsz;
591 	total_size = roundup2(head + bytes, secsz);
592 	tail = total_size - (head + bytes);
593 	do_tail_write = ((tail > 0) && (head + bytes > secsz));
594 	full_sec_size = total_size;
595 	if (head > 0)
596 		full_sec_size -= secsz;
597 	if (do_tail_write)
598 		full_sec_size -= secsz;
599 
600 	/* Partial sector write requires a bounce buffer. */
601 	if ((head > 0) || do_tail_write || bytes < secsz) {
602 		bouncebuf = malloc(secsz);
603 		if (bouncebuf == NULL) {
604 			printf("vdev_write: out of memory\n");
605 			return (ENOMEM);
606 		}
607 	}
608 
609 	if (lseek(fd, start_sec * secsz, SEEK_SET) == -1) {
610 		ret = errno;
611 		goto error;
612 	}
613 
614 	/* Partial data for first sector */
615 	if (head > 0) {
616 		res = read(fd, bouncebuf, secsz);
617 		if ((unsigned)res != secsz) {
618 			ret = EIO;
619 			goto error;
620 		}
621 		memcpy(bouncebuf + head, outbuf, min(secsz - head, bytes));
622 		(void) lseek(fd, -secsz, SEEK_CUR);
623 		res = write(fd, bouncebuf, secsz);
624 		if ((unsigned)res != secsz) {
625 			ret = EIO;
626 			goto error;
627 		}
628 		outbuf += min(secsz - head, bytes);
629 	}
630 
631 	/*
632 	 * Full data write to sectors.
633 	 * Note, there is still corner case where we write
634 	 * to sector boundary, but less than sector size, e.g. write 512B
635 	 * to 4k sector.
636 	 */
637 	if (full_sec_size > 0) {
638 		if (bytes < full_sec_size) {
639 			res = read(fd, bouncebuf, secsz);
640 			if ((unsigned)res != secsz) {
641 				ret = EIO;
642 				goto error;
643 			}
644 			memcpy(bouncebuf, outbuf, bytes);
645 			(void) lseek(fd, -secsz, SEEK_CUR);
646 			res = write(fd, bouncebuf, secsz);
647 			if ((unsigned)res != secsz) {
648 				ret = EIO;
649 				goto error;
650 			}
651 		} else {
652 			res = write(fd, outbuf, full_sec_size);
653 			if ((unsigned)res != full_sec_size) {
654 				ret = EIO;
655 				goto error;
656 			}
657 			outbuf += full_sec_size;
658 		}
659 	}
660 
661 	/* Partial data write to last sector */
662 	if (do_tail_write) {
663 		res = read(fd, bouncebuf, secsz);
664 		if ((unsigned)res != secsz) {
665 			ret = EIO;
666 			goto error;
667 		}
668 		memcpy(bouncebuf, outbuf, secsz - tail);
669 		(void) lseek(fd, -secsz, SEEK_CUR);
670 		res = write(fd, bouncebuf, secsz);
671 		if ((unsigned)res != secsz) {
672 			ret = EIO;
673 			goto error;
674 		}
675 	}
676 
677 	ret = 0;
678 error:
679 	free(bouncebuf);
680 	return (ret);
681 }
682 
683 static int
684 zfs_dev_init(void)
685 {
686 	spa_t *spa;
687 	spa_t *next;
688 	spa_t *prev;
689 
690 	zfs_init();
691 	if (archsw.arch_zfs_probe == NULL)
692 		return (ENXIO);
693 	archsw.arch_zfs_probe();
694 
695 	prev = NULL;
696 	spa = STAILQ_FIRST(&zfs_pools);
697 	while (spa != NULL) {
698 		next = STAILQ_NEXT(spa, spa_link);
699 		if (zfs_spa_init(spa)) {
700 			if (prev == NULL)
701 				STAILQ_REMOVE_HEAD(&zfs_pools, spa_link);
702 			else
703 				STAILQ_REMOVE_AFTER(&zfs_pools, prev, spa_link);
704 		} else
705 			prev = spa;
706 		spa = next;
707 	}
708 	return (0);
709 }
710 
711 struct zfs_probe_args {
712 	int		fd;
713 	const char	*devname;
714 	uint64_t	*pool_guid;
715 	u_int		secsz;
716 };
717 
718 static int
719 zfs_diskread(void *arg, void *buf, size_t blocks, uint64_t offset)
720 {
721 	struct zfs_probe_args *ppa;
722 
723 	ppa = (struct zfs_probe_args *)arg;
724 	return (vdev_read(NULL, (void *)(uintptr_t)ppa->fd,
725 	    offset * ppa->secsz, buf, blocks * ppa->secsz));
726 }
727 
728 static int
729 zfs_probe(int fd, uint64_t *pool_guid)
730 {
731 	spa_t *spa;
732 	int ret;
733 
734 	spa = NULL;
735 	ret = vdev_probe(vdev_read, vdev_write, (void *)(uintptr_t)fd, &spa);
736 	if (ret == 0 && pool_guid != NULL)
737 		if (*pool_guid == 0)
738 			*pool_guid = spa->spa_guid;
739 	return (ret);
740 }
741 
742 static int
743 zfs_probe_partition(void *arg, const char *partname,
744     const struct ptable_entry *part)
745 {
746 	struct zfs_probe_args *ppa, pa;
747 	struct ptable *table;
748 	char devname[32];
749 	int ret;
750 
751 	/* Probe only freebsd-zfs and freebsd partitions */
752 	if (part->type != PART_FREEBSD &&
753 	    part->type != PART_FREEBSD_ZFS)
754 		return (0);
755 
756 	ppa = (struct zfs_probe_args *)arg;
757 	strncpy(devname, ppa->devname, strlen(ppa->devname) - 1);
758 	devname[strlen(ppa->devname) - 1] = '\0';
759 	snprintf(devname, sizeof(devname), "%s%s:", devname, partname);
760 	pa.fd = open(devname, O_RDWR);
761 	if (pa.fd == -1)
762 		return (0);
763 	ret = zfs_probe(pa.fd, ppa->pool_guid);
764 	if (ret == 0)
765 		return (0);
766 	/* Do we have BSD label here? */
767 	if (part->type == PART_FREEBSD) {
768 		pa.devname = devname;
769 		pa.pool_guid = ppa->pool_guid;
770 		pa.secsz = ppa->secsz;
771 		table = ptable_open(&pa, part->end - part->start + 1,
772 		    ppa->secsz, zfs_diskread);
773 		if (table != NULL) {
774 			ptable_iterate(table, &pa, zfs_probe_partition);
775 			ptable_close(table);
776 		}
777 	}
778 	close(pa.fd);
779 	return (0);
780 }
781 
782 /*
783  * Return bootenv nvlist from pool label.
784  */
785 int
786 zfs_get_bootenv(void *vdev, nvlist_t **benvp)
787 {
788 	struct zfs_devdesc *dev = (struct zfs_devdesc *)vdev;
789 	nvlist_t *benv = NULL;
790 	vdev_t *vd;
791 	spa_t *spa;
792 
793 	if (dev->dd.d_dev->dv_type != DEVT_ZFS)
794 		return (ENOTSUP);
795 
796 	if ((spa = spa_find_by_dev(dev)) == NULL)
797 		return (ENXIO);
798 
799 	if (spa->spa_bootenv == NULL) {
800 		STAILQ_FOREACH(vd, &spa->spa_root_vdev->v_children,
801 		    v_childlink) {
802 			benv = vdev_read_bootenv(vd);
803 
804 			if (benv != NULL)
805 				break;
806 		}
807 		spa->spa_bootenv = benv;
808 	} else {
809 		benv = spa->spa_bootenv;
810 	}
811 
812 	if (benv == NULL)
813 		return (ENOENT);
814 
815 	*benvp = benv;
816 	return (0);
817 }
818 
819 /*
820  * Store nvlist to pool label bootenv area. Also updates cached pointer in spa.
821  */
822 int
823 zfs_set_bootenv(void *vdev, nvlist_t *benv)
824 {
825 	struct zfs_devdesc *dev = (struct zfs_devdesc *)vdev;
826 	spa_t *spa;
827 	vdev_t *vd;
828 
829 	if (dev->dd.d_dev->dv_type != DEVT_ZFS)
830 		return (ENOTSUP);
831 
832 	if ((spa = spa_find_by_dev(dev)) == NULL)
833 		return (ENXIO);
834 
835 	STAILQ_FOREACH(vd, &spa->spa_root_vdev->v_children, v_childlink) {
836 		vdev_write_bootenv(vd, benv);
837 	}
838 
839 	spa->spa_bootenv = benv;
840 	return (0);
841 }
842 
843 /*
844  * Get bootonce value by key. The bootonce <key, value> pair is removed
845  * from the bootenv nvlist and the remaining nvlist is committed back to disk.
846  */
847 int
848 zfs_get_bootonce(void *vdev, const char *key, char *buf, size_t size)
849 {
850 	nvlist_t *benv;
851 	char *result = NULL;
852 	int result_size, rv;
853 
854 	if ((rv = zfs_get_bootenv(vdev, &benv)) != 0)
855 		return (rv);
856 
857 	if ((rv = nvlist_find(benv, key, DATA_TYPE_STRING, NULL,
858 	    &result, &result_size)) == 0) {
859 		if (result_size == 0) {
860 			/* ignore empty string */
861 			rv = ENOENT;
862 		} else {
863 			size = MIN((size_t)result_size + 1, size);
864 			strlcpy(buf, result, size);
865 		}
866 		(void) nvlist_remove(benv, key, DATA_TYPE_STRING);
867 		(void) zfs_set_bootenv(vdev, benv);
868 	}
869 
870 	return (rv);
871 }
872 
873 /*
874  * nvstore backend.
875  */
876 
877 static int zfs_nvstore_setter(void *, int, const char *,
878     const void *, size_t);
879 static int zfs_nvstore_setter_str(void *, const char *, const char *,
880     const char *);
881 static int zfs_nvstore_unset_impl(void *, const char *, bool);
882 static int zfs_nvstore_setenv(void *, void *);
883 
884 /*
885  * nvstore is only present for current rootfs pool.
886  */
887 static int
888 zfs_nvstore_sethook(struct env_var *ev, int flags __unused, const void *value)
889 {
890 	struct zfs_devdesc *dev;
891 	int rv;
892 
893 	archsw.arch_getdev((void **)&dev, NULL, NULL);
894 	if (dev == NULL)
895 		return (ENXIO);
896 
897 	rv = zfs_nvstore_setter_str(dev, NULL, ev->ev_name, value);
898 
899 	free(dev);
900 	return (rv);
901 }
902 
903 /*
904  * nvstore is only present for current rootfs pool.
905  */
906 static int
907 zfs_nvstore_unsethook(struct env_var *ev)
908 {
909 	struct zfs_devdesc *dev;
910 	int rv;
911 
912 	archsw.arch_getdev((void **)&dev, NULL, NULL);
913 	if (dev == NULL)
914 		return (ENXIO);
915 
916 	rv = zfs_nvstore_unset_impl(dev, ev->ev_name, false);
917 
918 	free(dev);
919 	return (rv);
920 }
921 
922 static int
923 zfs_nvstore_getter(void *vdev, const char *name, void **data)
924 {
925 	struct zfs_devdesc *dev = (struct zfs_devdesc *)vdev;
926 	spa_t *spa;
927 	nvlist_t *nv;
928 	char *str, **ptr;
929 	int size;
930 	int rv;
931 
932 	if (dev->dd.d_dev->dv_type != DEVT_ZFS)
933 		return (ENOTSUP);
934 
935 	if ((spa = spa_find_by_dev(dev)) == NULL)
936 		return (ENXIO);
937 
938 	if (spa->spa_bootenv == NULL)
939 		return (ENXIO);
940 
941 	if (nvlist_find(spa->spa_bootenv, OS_NVSTORE, DATA_TYPE_NVLIST,
942 	    NULL, &nv, NULL) != 0)
943 		return (ENOENT);
944 
945 	rv = nvlist_find(nv, name, DATA_TYPE_STRING, NULL, &str, &size);
946 	if (rv == 0) {
947 		ptr = (char **)data;
948 		asprintf(ptr, "%.*s", size, str);
949 		if (*data == NULL)
950 			rv = ENOMEM;
951 	}
952 	nvlist_destroy(nv);
953 	return (rv);
954 }
955 
956 static int
957 zfs_nvstore_setter(void *vdev, int type, const char *name,
958     const void *data, size_t size)
959 {
960 	struct zfs_devdesc *dev = (struct zfs_devdesc *)vdev;
961 	spa_t *spa;
962 	nvlist_t *nv;
963 	int rv;
964 	bool env_set = true;
965 
966 	if (dev->dd.d_dev->dv_type != DEVT_ZFS)
967 		return (ENOTSUP);
968 
969 	if ((spa = spa_find_by_dev(dev)) == NULL)
970 		return (ENXIO);
971 
972 	if (spa->spa_bootenv == NULL)
973 		return (ENXIO);
974 
975 	if (nvlist_find(spa->spa_bootenv, OS_NVSTORE, DATA_TYPE_NVLIST,
976 	    NULL, &nv, NULL) != 0) {
977 		nv = nvlist_create(NV_UNIQUE_NAME);
978 		if (nv == NULL)
979 			return (ENOMEM);
980 	}
981 
982 	rv = 0;
983 	switch (type) {
984         case DATA_TYPE_INT8:
985 		if (size != sizeof (int8_t)) {
986 			rv = EINVAL;
987 			break;
988 		}
989 		rv = nvlist_add_int8(nv, name, *(int8_t *)data);
990 		break;
991 
992         case DATA_TYPE_INT16:
993 		if (size != sizeof (int16_t)) {
994 			rv = EINVAL;
995 			break;
996 		}
997 		rv = nvlist_add_int16(nv, name, *(int16_t *)data);
998 		break;
999 
1000         case DATA_TYPE_INT32:
1001 		if (size != sizeof (int32_t)) {
1002 			rv = EINVAL;
1003 			break;
1004 		}
1005 		rv = nvlist_add_int32(nv, name, *(int32_t *)data);
1006 		break;
1007 
1008         case DATA_TYPE_INT64:
1009 		if (size != sizeof (int64_t)) {
1010 			rv = EINVAL;
1011 			break;
1012 		}
1013 		rv = nvlist_add_int64(nv, name, *(int64_t *)data);
1014 		break;
1015 
1016         case DATA_TYPE_BYTE:
1017 		if (size != sizeof (uint8_t)) {
1018 			rv = EINVAL;
1019 			break;
1020 		}
1021 		rv = nvlist_add_byte(nv, name, *(int8_t *)data);
1022 		break;
1023 
1024         case DATA_TYPE_UINT8:
1025 		if (size != sizeof (uint8_t)) {
1026 			rv = EINVAL;
1027 			break;
1028 		}
1029 		rv = nvlist_add_uint8(nv, name, *(int8_t *)data);
1030 		break;
1031 
1032         case DATA_TYPE_UINT16:
1033 		if (size != sizeof (uint16_t)) {
1034 			rv = EINVAL;
1035 			break;
1036 		}
1037 		rv = nvlist_add_uint16(nv, name, *(uint16_t *)data);
1038 		break;
1039 
1040         case DATA_TYPE_UINT32:
1041 		if (size != sizeof (uint32_t)) {
1042 			rv = EINVAL;
1043 			break;
1044 		}
1045 		rv = nvlist_add_uint32(nv, name, *(uint32_t *)data);
1046 		break;
1047 
1048         case DATA_TYPE_UINT64:
1049 		if (size != sizeof (uint64_t)) {
1050 			rv = EINVAL;
1051 			break;
1052 		}
1053 		rv = nvlist_add_uint64(nv, name, *(uint64_t *)data);
1054 		break;
1055 
1056         case DATA_TYPE_STRING:
1057 		rv = nvlist_add_string(nv, name, data);
1058 		break;
1059 
1060 	case DATA_TYPE_BOOLEAN_VALUE:
1061 		if (size != sizeof (boolean_t)) {
1062 			rv = EINVAL;
1063 			break;
1064 		}
1065 		rv = nvlist_add_boolean_value(nv, name, *(boolean_t *)data);
1066 		break;
1067 
1068 	default:
1069 		rv = EINVAL;
1070 		break;
1071 	}
1072 
1073 	if (rv == 0) {
1074 		rv = nvlist_add_nvlist(spa->spa_bootenv, OS_NVSTORE, nv);
1075 		if (rv == 0) {
1076 			rv = zfs_set_bootenv(vdev, spa->spa_bootenv);
1077 		}
1078 		if (rv == 0) {
1079 			if (env_set) {
1080 				rv = zfs_nvstore_setenv(vdev,
1081 				    nvpair_find(nv, name));
1082 			} else {
1083 				env_discard(env_getenv(name));
1084 				rv = 0;
1085 			}
1086 		}
1087 	}
1088 
1089 	nvlist_destroy(nv);
1090 	return (rv);
1091 }
1092 
1093 static int
1094 get_int64(const char *data, int64_t *ip)
1095 {
1096 	char *end;
1097 	int64_t val;
1098 
1099 	errno = 0;
1100 	val = strtoll(data, &end, 0);
1101 	if (errno != 0 || *data == '\0' || *end != '\0')
1102 		return (EINVAL);
1103 
1104 	*ip = val;
1105 	return (0);
1106 }
1107 
1108 static int
1109 get_uint64(const char *data, uint64_t *ip)
1110 {
1111 	char *end;
1112 	uint64_t val;
1113 
1114 	errno = 0;
1115 	val = strtoull(data, &end, 0);
1116 	if (errno != 0 || *data == '\0' || *end != '\0')
1117 		return (EINVAL);
1118 
1119 	*ip = val;
1120 	return (0);
1121 }
1122 
1123 /*
1124  * Translate textual data to data type. If type is not set, and we are
1125  * creating new pair, use DATA_TYPE_STRING.
1126  */
1127 static int
1128 zfs_nvstore_setter_str(void *vdev, const char *type, const char *name,
1129     const char *data)
1130 {
1131 	struct zfs_devdesc *dev = (struct zfs_devdesc *)vdev;
1132 	spa_t *spa;
1133 	nvlist_t *nv;
1134 	int rv;
1135 	data_type_t dt;
1136 	int64_t val;
1137 	uint64_t uval;
1138 
1139 	if (dev->dd.d_dev->dv_type != DEVT_ZFS)
1140 		return (ENOTSUP);
1141 
1142 	if ((spa = spa_find_by_dev(dev)) == NULL)
1143 		return (ENXIO);
1144 
1145 	if (spa->spa_bootenv == NULL)
1146 		return (ENXIO);
1147 
1148 	if (nvlist_find(spa->spa_bootenv, OS_NVSTORE, DATA_TYPE_NVLIST,
1149 	    NULL, &nv, NULL) != 0) {
1150 		nv = NULL;
1151 	}
1152 
1153 	if (type == NULL) {
1154 		nvp_header_t *nvh;
1155 
1156 		/*
1157 		 * if there is no existing pair, default to string.
1158 		 * Otherwise, use type from existing pair.
1159 		 */
1160 		nvh = nvpair_find(nv, name);
1161 		if (nvh == NULL) {
1162 			dt = DATA_TYPE_STRING;
1163 		} else {
1164 			nv_string_t *nvp_name;
1165 			nv_pair_data_t *nvp_data;
1166 
1167 			nvp_name = (nv_string_t *)(nvh + 1);
1168 			nvp_data = (nv_pair_data_t *)(&nvp_name->nv_data[0] +
1169 			    NV_ALIGN4(nvp_name->nv_size));
1170 			dt = nvp_data->nv_type;
1171 		}
1172 	} else {
1173 		dt = nvpair_type_from_name(type);
1174 	}
1175 	nvlist_destroy(nv);
1176 
1177 	rv = 0;
1178 	switch (dt) {
1179         case DATA_TYPE_INT8:
1180 		rv = get_int64(data, &val);
1181 		if (rv == 0) {
1182 			int8_t v = val;
1183 
1184 			rv = zfs_nvstore_setter(vdev, dt, name, &v, sizeof (v));
1185 		}
1186 		break;
1187         case DATA_TYPE_INT16:
1188 		rv = get_int64(data, &val);
1189 		if (rv == 0) {
1190 			int16_t v = val;
1191 
1192 			rv = zfs_nvstore_setter(vdev, dt, name, &v, sizeof (v));
1193 		}
1194 		break;
1195         case DATA_TYPE_INT32:
1196 		rv = get_int64(data, &val);
1197 		if (rv == 0) {
1198 			int32_t v = val;
1199 
1200 			rv = zfs_nvstore_setter(vdev, dt, name, &v, sizeof (v));
1201 		}
1202 		break;
1203         case DATA_TYPE_INT64:
1204 		rv = get_int64(data, &val);
1205 		if (rv == 0) {
1206 			rv = zfs_nvstore_setter(vdev, dt, name, &val,
1207 			    sizeof (val));
1208 		}
1209 		break;
1210 
1211         case DATA_TYPE_BYTE:
1212 		rv = get_uint64(data, &uval);
1213 		if (rv == 0) {
1214 			uint8_t v = uval;
1215 
1216 			rv = zfs_nvstore_setter(vdev, dt, name, &v, sizeof (v));
1217 		}
1218 		break;
1219 
1220         case DATA_TYPE_UINT8:
1221 		rv = get_uint64(data, &uval);
1222 		if (rv == 0) {
1223 			uint8_t v = uval;
1224 
1225 			rv = zfs_nvstore_setter(vdev, dt, name, &v, sizeof (v));
1226 		}
1227 		break;
1228 
1229         case DATA_TYPE_UINT16:
1230 		rv = get_uint64(data, &uval);
1231 		if (rv == 0) {
1232 			uint16_t v = uval;
1233 
1234 			rv = zfs_nvstore_setter(vdev, dt, name, &v, sizeof (v));
1235 		}
1236 		break;
1237 
1238         case DATA_TYPE_UINT32:
1239 		rv = get_uint64(data, &uval);
1240 		if (rv == 0) {
1241 			uint32_t v = uval;
1242 
1243 			rv = zfs_nvstore_setter(vdev, dt, name, &v, sizeof (v));
1244 		}
1245 		break;
1246 
1247         case DATA_TYPE_UINT64:
1248 		rv = get_uint64(data, &uval);
1249 		if (rv == 0) {
1250 			rv = zfs_nvstore_setter(vdev, dt, name, &uval,
1251 			    sizeof (uval));
1252 		}
1253 		break;
1254 
1255         case DATA_TYPE_STRING:
1256 		rv = zfs_nvstore_setter(vdev, dt, name, data, strlen(data) + 1);
1257 		break;
1258 
1259 	case DATA_TYPE_BOOLEAN_VALUE:
1260 		rv = get_int64(data, &val);
1261 		if (rv == 0) {
1262 			boolean_t v = val;
1263 
1264 			rv = zfs_nvstore_setter(vdev, dt, name, &v, sizeof (v));
1265 		}
1266 
1267 	default:
1268 		rv = EINVAL;
1269 	}
1270 	return (rv);
1271 }
1272 
1273 static int
1274 zfs_nvstore_unset_impl(void *vdev, const char *name, bool unset_env)
1275 {
1276 	struct zfs_devdesc *dev = (struct zfs_devdesc *)vdev;
1277 	spa_t *spa;
1278 	nvlist_t *nv;
1279 	int rv;
1280 
1281 	if (dev->dd.d_dev->dv_type != DEVT_ZFS)
1282 		return (ENOTSUP);
1283 
1284 	if ((spa = spa_find_by_dev(dev)) == NULL)
1285 		return (ENXIO);
1286 
1287 	if (spa->spa_bootenv == NULL)
1288 		return (ENXIO);
1289 
1290 	if (nvlist_find(spa->spa_bootenv, OS_NVSTORE, DATA_TYPE_NVLIST,
1291 	    NULL, &nv, NULL) != 0)
1292 		return (ENOENT);
1293 
1294 	rv = nvlist_remove(nv, name, DATA_TYPE_UNKNOWN);
1295 	if (rv == 0) {
1296 		if (nvlist_next_nvpair(nv, NULL) == NULL) {
1297 			rv = nvlist_remove(spa->spa_bootenv, OS_NVSTORE,
1298 			    DATA_TYPE_NVLIST);
1299 		} else {
1300 			rv = nvlist_add_nvlist(spa->spa_bootenv,
1301 			    OS_NVSTORE, nv);
1302 		}
1303 		if (rv == 0)
1304 			rv = zfs_set_bootenv(vdev, spa->spa_bootenv);
1305 	}
1306 
1307 	if (unset_env)
1308 		env_discard(env_getenv(name));
1309 	return (rv);
1310 }
1311 
1312 static int
1313 zfs_nvstore_unset(void *vdev, const char *name)
1314 {
1315 	return (zfs_nvstore_unset_impl(vdev, name, true));
1316 }
1317 
1318 static int
1319 zfs_nvstore_print(void *vdev __unused, void *ptr)
1320 {
1321 
1322 	nvpair_print(ptr, 0);
1323 	return (0);
1324 }
1325 
1326 /*
1327  * Create environment variable from nvpair.
1328  * set hook will update nvstore with new value, unset hook will remove
1329  * variable from nvstore.
1330  */
1331 static int
1332 zfs_nvstore_setenv(void *vdev __unused, void *ptr)
1333 {
1334 	nvp_header_t *nvh = ptr;
1335 	nv_string_t *nvp_name, *nvp_value;
1336 	nv_pair_data_t *nvp_data;
1337 	char *name, *value;
1338 	int rv = 0;
1339 
1340 	if (nvh == NULL)
1341 		return (ENOENT);
1342 
1343 	nvp_name = (nv_string_t *)(nvh + 1);
1344 	nvp_data = (nv_pair_data_t *)(&nvp_name->nv_data[0] +
1345 	    NV_ALIGN4(nvp_name->nv_size));
1346 
1347 	if ((name = nvstring_get(nvp_name)) == NULL)
1348 		return (ENOMEM);
1349 
1350 	value = NULL;
1351 	switch (nvp_data->nv_type) {
1352 	case DATA_TYPE_BYTE:
1353 	case DATA_TYPE_UINT8:
1354 		(void) asprintf(&value, "%uc",
1355 		    *(unsigned *)&nvp_data->nv_data[0]);
1356 		if (value == NULL)
1357 			rv = ENOMEM;
1358 		break;
1359 
1360 	case DATA_TYPE_INT8:
1361 		(void) asprintf(&value, "%c", *(int *)&nvp_data->nv_data[0]);
1362 		if (value == NULL)
1363 			rv = ENOMEM;
1364 		break;
1365 
1366 	case DATA_TYPE_INT16:
1367 		(void) asprintf(&value, "%hd", *(short *)&nvp_data->nv_data[0]);
1368 		if (value == NULL)
1369 			rv = ENOMEM;
1370 		break;
1371 
1372 	case DATA_TYPE_UINT16:
1373 		(void) asprintf(&value, "%hu",
1374 		    *(unsigned short *)&nvp_data->nv_data[0]);
1375 		if (value == NULL)
1376 			rv = ENOMEM;
1377 		break;
1378 
1379 	case DATA_TYPE_BOOLEAN_VALUE:
1380 	case DATA_TYPE_INT32:
1381 		(void) asprintf(&value, "%d", *(int *)&nvp_data->nv_data[0]);
1382 		if (value == NULL)
1383 			rv = ENOMEM;
1384 		break;
1385 
1386 	case DATA_TYPE_UINT32:
1387 		(void) asprintf(&value, "%u",
1388 		    *(unsigned *)&nvp_data->nv_data[0]);
1389 		if (value == NULL)
1390 			rv = ENOMEM;
1391 		break;
1392 
1393 	case DATA_TYPE_INT64:
1394 		(void) asprintf(&value, "%jd",
1395 		    (intmax_t)*(int64_t *)&nvp_data->nv_data[0]);
1396 		if (value == NULL)
1397 			rv = ENOMEM;
1398 		break;
1399 
1400 	case DATA_TYPE_UINT64:
1401 		(void) asprintf(&value, "%ju",
1402 		    (uintmax_t)*(uint64_t *)&nvp_data->nv_data[0]);
1403 		if (value == NULL)
1404 			rv = ENOMEM;
1405 		break;
1406 
1407 	case DATA_TYPE_STRING:
1408 		nvp_value = (nv_string_t *)&nvp_data->nv_data[0];
1409 		if ((value = nvstring_get(nvp_value)) == NULL) {
1410 			rv = ENOMEM;
1411 			break;
1412 		}
1413 		break;
1414 
1415 	default:
1416 		rv = EINVAL;
1417 		break;
1418 	}
1419 
1420 	if (value != NULL) {
1421 		rv = env_setenv(name, EV_VOLATILE | EV_NOHOOK, value,
1422 		    zfs_nvstore_sethook, zfs_nvstore_unsethook);
1423 		free(value);
1424 	}
1425 	free(name);
1426 	return (rv);
1427 }
1428 
1429 static int
1430 zfs_nvstore_iterate(void *vdev, int (*cb)(void *, void *))
1431 {
1432 	struct zfs_devdesc *dev = (struct zfs_devdesc *)vdev;
1433 	spa_t *spa;
1434 	nvlist_t *nv;
1435 	nvp_header_t *nvh;
1436 	int rv;
1437 
1438 	if (dev->dd.d_dev->dv_type != DEVT_ZFS)
1439 		return (ENOTSUP);
1440 
1441 	if ((spa = spa_find_by_dev(dev)) == NULL)
1442 		return (ENXIO);
1443 
1444 	if (spa->spa_bootenv == NULL)
1445 		return (ENXIO);
1446 
1447 	if (nvlist_find(spa->spa_bootenv, OS_NVSTORE, DATA_TYPE_NVLIST,
1448 	    NULL, &nv, NULL) != 0)
1449 		return (ENOENT);
1450 
1451 	rv = 0;
1452 	nvh = NULL;
1453 	while ((nvh = nvlist_next_nvpair(nv, nvh)) != NULL) {
1454 		rv = cb(vdev, nvh);
1455 		if (rv != 0)
1456 			break;
1457 	}
1458 	return (rv);
1459 }
1460 
1461 nvs_callbacks_t nvstore_zfs_cb = {
1462 	.nvs_getter = zfs_nvstore_getter,
1463 	.nvs_setter = zfs_nvstore_setter,
1464 	.nvs_setter_str = zfs_nvstore_setter_str,
1465 	.nvs_unset = zfs_nvstore_unset,
1466 	.nvs_print = zfs_nvstore_print,
1467 	.nvs_iterate = zfs_nvstore_iterate
1468 };
1469 
1470 int
1471 zfs_attach_nvstore(void *vdev)
1472 {
1473 	struct zfs_devdesc *dev = vdev;
1474 	spa_t *spa;
1475 	uint64_t version;
1476 	int rv;
1477 
1478 	if (dev->dd.d_dev->dv_type != DEVT_ZFS)
1479 		return (ENOTSUP);
1480 
1481 	if ((spa = spa_find_by_dev(dev)) == NULL)
1482 		return (ENXIO);
1483 
1484 	rv = nvlist_find(spa->spa_bootenv, BOOTENV_VERSION, DATA_TYPE_UINT64,
1485 	    NULL, &version, NULL);
1486 
1487 	if (rv != 0 || version != VB_NVLIST) {
1488 		return (ENXIO);
1489 	}
1490 
1491 	dev = malloc(sizeof (*dev));
1492 	if (dev == NULL)
1493 		return (ENOMEM);
1494 	memcpy(dev, vdev, sizeof (*dev));
1495 
1496 	rv = nvstore_init(spa->spa_name, &nvstore_zfs_cb, dev);
1497 	if (rv != 0)
1498 		free(dev);
1499 	else
1500 		rv = zfs_nvstore_iterate(dev, zfs_nvstore_setenv);
1501 	return (rv);
1502 }
1503 
1504 int
1505 zfs_probe_dev(const char *devname, uint64_t *pool_guid, bool parts_too)
1506 {
1507 	struct ptable *table;
1508 	struct zfs_probe_args pa;
1509 	uint64_t mediasz;
1510 	int ret;
1511 
1512 	if (pool_guid)
1513 		*pool_guid = 0;
1514 	pa.fd = open(devname, O_RDWR);
1515 	if (pa.fd == -1)
1516 		return (ENXIO);
1517 	/* Probe the whole disk */
1518 	ret = zfs_probe(pa.fd, pool_guid);
1519 	if (ret == 0)
1520 		return (0);
1521 	if (!parts_too)
1522 		return (ENXIO);
1523 
1524 	/* Probe each partition */
1525 	ret = ioctl(pa.fd, DIOCGMEDIASIZE, &mediasz);
1526 	if (ret == 0)
1527 		ret = ioctl(pa.fd, DIOCGSECTORSIZE, &pa.secsz);
1528 	if (ret == 0) {
1529 		pa.devname = devname;
1530 		pa.pool_guid = pool_guid;
1531 		table = ptable_open(&pa, mediasz / pa.secsz, pa.secsz,
1532 		    zfs_diskread);
1533 		if (table != NULL) {
1534 			ptable_iterate(table, &pa, zfs_probe_partition);
1535 			ptable_close(table);
1536 		}
1537 	}
1538 	close(pa.fd);
1539 	if (pool_guid && *pool_guid == 0)
1540 		ret = ENXIO;
1541 	return (ret);
1542 }
1543 
1544 /*
1545  * Print information about ZFS pools
1546  */
1547 static int
1548 zfs_dev_print(int verbose)
1549 {
1550 	spa_t *spa;
1551 	char line[80];
1552 	int ret = 0;
1553 
1554 	if (STAILQ_EMPTY(&zfs_pools))
1555 		return (0);
1556 
1557 	printf("%s devices:", zfs_dev.dv_name);
1558 	if ((ret = pager_output("\n")) != 0)
1559 		return (ret);
1560 
1561 	if (verbose) {
1562 		return (spa_all_status());
1563 	}
1564 	STAILQ_FOREACH(spa, &zfs_pools, spa_link) {
1565 		snprintf(line, sizeof(line), "    zfs:%s\n", spa->spa_name);
1566 		ret = pager_output(line);
1567 		if (ret != 0)
1568 			break;
1569 	}
1570 	return (ret);
1571 }
1572 
1573 /*
1574  * Attempt to open the pool described by (dev) for use by (f).
1575  */
1576 static int
1577 zfs_dev_open(struct open_file *f, ...)
1578 {
1579 	va_list		args;
1580 	struct zfs_devdesc	*dev;
1581 	struct zfsmount	*mount;
1582 	spa_t		*spa;
1583 	int		rv;
1584 
1585 	va_start(args, f);
1586 	dev = va_arg(args, struct zfs_devdesc *);
1587 	va_end(args);
1588 
1589 	if ((spa = spa_find_by_dev(dev)) == NULL)
1590 		return (ENXIO);
1591 
1592 	STAILQ_FOREACH(mount, &zfsmount, next) {
1593 		if (spa->spa_guid == mount->spa->spa_guid)
1594 			break;
1595 	}
1596 
1597 	rv = 0;
1598 	/* This device is not set as currdev, mount us private copy. */
1599 	if (mount == NULL)
1600 		rv = zfs_mount(devformat(&dev->dd), NULL, (void **)&mount);
1601 
1602 	if (rv == 0) {
1603 		dev->dd.d_opendata = mount;
1604 	}
1605 	return (rv);
1606 }
1607 
1608 static int
1609 zfs_dev_close(struct open_file *f)
1610 {
1611 	struct devdesc *dev;
1612 	struct zfsmount	*mnt, *mount;
1613 
1614 	dev = f->f_devdata;
1615 	mnt = dev->d_opendata;
1616 
1617 	STAILQ_FOREACH(mount, &zfsmount, next) {
1618 		if (mnt->spa->spa_guid == mount->spa->spa_guid)
1619 			break;
1620 	}
1621 
1622 	/* XXX */
1623 	return (0);
1624 }
1625 
1626 static int
1627 zfs_dev_strategy(void *devdata, int rw, daddr_t dblk, size_t size, char *buf, size_t *rsize)
1628 {
1629 
1630 	return (ENOSYS);
1631 }
1632 
1633 struct devsw zfs_dev = {
1634 	.dv_name = "zfs",
1635 	.dv_type = DEVT_ZFS,
1636 	.dv_init = zfs_dev_init,
1637 	.dv_strategy = zfs_dev_strategy,
1638 	.dv_open = zfs_dev_open,
1639 	.dv_close = zfs_dev_close,
1640 	.dv_ioctl = noioctl,
1641 	.dv_print = zfs_dev_print,
1642 	.dv_cleanup = nullsys,
1643 	.dv_fmtdev = zfs_fmtdev,
1644 	.dv_parsedev = zfs_parsedev,
1645 };
1646 
1647 static int
1648 zfs_parsedev(struct devdesc **idev, const char *devspec, const char **path)
1649 {
1650 	static char	rootname[ZFS_MAXNAMELEN];
1651 	static char	poolname[ZFS_MAXNAMELEN];
1652 	spa_t		*spa;
1653 	const char	*end;
1654 	const char	*np;
1655 	const char	*sep;
1656 	int		rv;
1657 	struct zfs_devdesc *dev;
1658 
1659 	np = devspec + 3;			/* Skip the leading 'zfs' */
1660 	if (*np != ':')
1661 		return (EINVAL);
1662 	np++;
1663 	end = strrchr(np, ':');
1664 	if (end == NULL)
1665 		return (EINVAL);
1666 	sep = strchr(np, '/');
1667 	if (sep == NULL || sep >= end)
1668 		sep = end;
1669 	memcpy(poolname, np, sep - np);
1670 	poolname[sep - np] = '\0';
1671 	if (sep < end) {
1672 		sep++;
1673 		memcpy(rootname, sep, end - sep);
1674 		rootname[end - sep] = '\0';
1675 	}
1676 	else
1677 		rootname[0] = '\0';
1678 
1679 	spa = spa_find_by_name(poolname);
1680 	if (!spa)
1681 		return (ENXIO);
1682 	dev = malloc(sizeof(*dev));
1683 	if (dev == NULL)
1684 		return (ENOMEM);
1685 	dev->pool_guid = spa->spa_guid;
1686 	rv = zfs_lookup_dataset(spa, rootname, &dev->root_guid);
1687 	if (rv != 0) {
1688 		free(dev);
1689 		return (rv);
1690 	}
1691 	if (path != NULL)
1692 		*path = (*end == '\0') ? end : end + 1;
1693 	dev->dd.d_dev = &zfs_dev;
1694 	*idev = &dev->dd;
1695 	return (0);
1696 }
1697 
1698 char *
1699 zfs_fmtdev(struct devdesc *vdev)
1700 {
1701 	static char		rootname[ZFS_MAXNAMELEN];
1702 	static char		buf[2 * ZFS_MAXNAMELEN + 8];
1703 	struct zfs_devdesc	*dev = (struct zfs_devdesc *)vdev;
1704 	spa_t			*spa;
1705 
1706 	buf[0] = '\0';
1707 	if (vdev->d_dev->dv_type != DEVT_ZFS)
1708 		return (buf);
1709 
1710 	/* Do we have any pools? */
1711 	spa = STAILQ_FIRST(&zfs_pools);
1712 	if (spa == NULL)
1713 		return (buf);
1714 
1715 	if (dev->pool_guid == 0)
1716 		dev->pool_guid = spa->spa_guid;
1717 	else
1718 		spa = spa_find_by_guid(dev->pool_guid);
1719 
1720 	if (spa == NULL) {
1721 		printf("ZFS: can't find pool by guid\n");
1722 		return (buf);
1723 	}
1724 	if (dev->root_guid == 0 && zfs_get_root(spa, &dev->root_guid)) {
1725 		printf("ZFS: can't find root filesystem\n");
1726 		return (buf);
1727 	}
1728 	if (zfs_rlookup(spa, dev->root_guid, rootname)) {
1729 		printf("ZFS: can't find filesystem by guid\n");
1730 		return (buf);
1731 	}
1732 
1733 	if (rootname[0] == '\0')
1734 		snprintf(buf, sizeof(buf), "%s:%s:", dev->dd.d_dev->dv_name,
1735 		    spa->spa_name);
1736 	else
1737 		snprintf(buf, sizeof(buf), "%s:%s/%s:", dev->dd.d_dev->dv_name,
1738 		    spa->spa_name, rootname);
1739 	return (buf);
1740 }
1741 
1742 static int
1743 split_devname(const char *name, char *poolname, size_t size,
1744     const char **dsnamep)
1745 {
1746 	const char *dsname;
1747 	size_t len;
1748 
1749 	ASSERT(name != NULL);
1750 	ASSERT(poolname != NULL);
1751 
1752 	len = strlen(name);
1753 	dsname = strchr(name, '/');
1754 	if (dsname != NULL) {
1755 		len = dsname - name;
1756 		dsname++;
1757 	} else
1758 		dsname = "";
1759 
1760 	if (len + 1 > size)
1761 		return (EINVAL);
1762 
1763 	strlcpy(poolname, name, len + 1);
1764 
1765 	if (dsnamep != NULL)
1766 		*dsnamep = dsname;
1767 
1768 	return (0);
1769 }
1770 
1771 int
1772 zfs_list(const char *name)
1773 {
1774 	static char	poolname[ZFS_MAXNAMELEN];
1775 	uint64_t	objid;
1776 	spa_t		*spa;
1777 	const char	*dsname;
1778 	int		rv;
1779 
1780 	if (split_devname(name, poolname, sizeof(poolname), &dsname) != 0)
1781 		return (EINVAL);
1782 
1783 	spa = spa_find_by_name(poolname);
1784 	if (!spa)
1785 		return (ENXIO);
1786 	rv = zfs_lookup_dataset(spa, dsname, &objid);
1787 	if (rv != 0)
1788 		return (rv);
1789 
1790 	return (zfs_list_dataset(spa, objid));
1791 }
1792 
1793 void
1794 init_zfs_boot_options(const char *currdev_in)
1795 {
1796 	char poolname[ZFS_MAXNAMELEN];
1797 	char *beroot, *currdev;
1798 	spa_t *spa;
1799 	int currdev_len;
1800 	const char *dsname;
1801 
1802 	currdev = NULL;
1803 	currdev_len = strlen(currdev_in);
1804 	if (currdev_len == 0)
1805 		return;
1806 	if (strncmp(currdev_in, "zfs:", 4) != 0)
1807 		return;
1808 	currdev = strdup(currdev_in);
1809 	if (currdev == NULL)
1810 		return;
1811 	/* Remove the trailing : */
1812 	currdev[currdev_len - 1] = '\0';
1813 
1814 	setenv("zfs_be_active", currdev, 1);
1815 	setenv("zfs_be_currpage", "1", 1);
1816 	/* Remove the last element (current bootenv) */
1817 	beroot = strrchr(currdev, '/');
1818 	if (beroot != NULL)
1819 		beroot[0] = '\0';
1820 	beroot = strchr(currdev, ':') + 1;
1821 	setenv("zfs_be_root", beroot, 1);
1822 
1823 	if (split_devname(beroot, poolname, sizeof(poolname), &dsname) != 0)
1824 		return;
1825 
1826 	spa = spa_find_by_name(poolname);
1827 	if (spa == NULL)
1828 		return;
1829 
1830 	zfs_bootenv_initial("bootenvs", spa, beroot, dsname, 0);
1831 	zfs_checkpoints_initial(spa, beroot, dsname);
1832 
1833 	free(currdev);
1834 }
1835 
1836 static void
1837 zfs_checkpoints_initial(spa_t *spa, const char *name, const char *dsname)
1838 {
1839 	char envname[32];
1840 
1841 	if (spa->spa_uberblock_checkpoint.ub_checkpoint_txg != 0) {
1842 		snprintf(envname, sizeof(envname), "zpool_checkpoint");
1843 		setenv(envname, name, 1);
1844 
1845 		spa->spa_uberblock = &spa->spa_uberblock_checkpoint;
1846 		spa->spa_mos = &spa->spa_mos_checkpoint;
1847 
1848 		zfs_bootenv_initial("bootenvs_check", spa, name, dsname, 1);
1849 
1850 		spa->spa_uberblock = &spa->spa_uberblock_master;
1851 		spa->spa_mos = &spa->spa_mos_master;
1852 	}
1853 }
1854 
1855 static void
1856 zfs_bootenv_initial(const char *envprefix, spa_t *spa, const char *rootname,
1857    const char *dsname, int checkpoint)
1858 {
1859 	char		envname[32], envval[256];
1860 	uint64_t	objid;
1861 	int		bootenvs_idx, rv;
1862 
1863 	SLIST_INIT(&zfs_be_head);
1864 	zfs_env_count = 0;
1865 
1866 	rv = zfs_lookup_dataset(spa, dsname, &objid);
1867 	if (rv != 0)
1868 		return;
1869 
1870 	rv = zfs_callback_dataset(spa, objid, zfs_belist_add);
1871 	bootenvs_idx = 0;
1872 	/* Populate the initial environment variables */
1873 	SLIST_FOREACH_SAFE(zfs_be, &zfs_be_head, entries, zfs_be_tmp) {
1874 		/* Enumerate all bootenvs for general usage */
1875 		snprintf(envname, sizeof(envname), "%s[%d]",
1876 		    envprefix, bootenvs_idx);
1877 		snprintf(envval, sizeof(envval), "zfs:%s%s/%s",
1878 		    checkpoint ? "!" : "", rootname, zfs_be->name);
1879 		rv = setenv(envname, envval, 1);
1880 		if (rv != 0)
1881 			break;
1882 		bootenvs_idx++;
1883 	}
1884 	snprintf(envname, sizeof(envname), "%s_count", envprefix);
1885 	snprintf(envval, sizeof(envval), "%d", bootenvs_idx);
1886 	setenv(envname, envval, 1);
1887 
1888 	/* Clean up the SLIST of ZFS BEs */
1889 	while (!SLIST_EMPTY(&zfs_be_head)) {
1890 		zfs_be = SLIST_FIRST(&zfs_be_head);
1891 		SLIST_REMOVE_HEAD(&zfs_be_head, entries);
1892 		free(zfs_be->name);
1893 		free(zfs_be);
1894 	}
1895 }
1896 
1897 int
1898 zfs_bootenv(const char *name)
1899 {
1900 	char		poolname[ZFS_MAXNAMELEN], *root;
1901 	const char	*dsname;
1902 	char		becount[4];
1903 	uint64_t	objid;
1904 	spa_t		*spa;
1905 	int		rv, pages, perpage, currpage;
1906 
1907 	if (name == NULL)
1908 		return (EINVAL);
1909 	if ((root = getenv("zfs_be_root")) == NULL)
1910 		return (EINVAL);
1911 
1912 	if (strcmp(name, root) != 0) {
1913 		if (setenv("zfs_be_root", name, 1) != 0)
1914 			return (ENOMEM);
1915 	}
1916 
1917 	SLIST_INIT(&zfs_be_head);
1918 	zfs_env_count = 0;
1919 
1920 	if (split_devname(name, poolname, sizeof(poolname), &dsname) != 0)
1921 		return (EINVAL);
1922 
1923 	spa = spa_find_by_name(poolname);
1924 	if (!spa)
1925 		return (ENXIO);
1926 	rv = zfs_lookup_dataset(spa, dsname, &objid);
1927 	if (rv != 0)
1928 		return (rv);
1929 	rv = zfs_callback_dataset(spa, objid, zfs_belist_add);
1930 
1931 	/* Calculate and store the number of pages of BEs */
1932 	perpage = (ZFS_BE_LAST - ZFS_BE_FIRST + 1);
1933 	pages = (zfs_env_count / perpage) + ((zfs_env_count % perpage) > 0 ? 1 : 0);
1934 	snprintf(becount, 4, "%d", pages);
1935 	if (setenv("zfs_be_pages", becount, 1) != 0)
1936 		return (ENOMEM);
1937 
1938 	/* Roll over the page counter if it has exceeded the maximum */
1939 	currpage = strtol(getenv("zfs_be_currpage"), NULL, 10);
1940 	if (currpage > pages) {
1941 		if (setenv("zfs_be_currpage", "1", 1) != 0)
1942 			return (ENOMEM);
1943 	}
1944 
1945 	/* Populate the menu environment variables */
1946 	zfs_set_env();
1947 
1948 	/* Clean up the SLIST of ZFS BEs */
1949 	while (!SLIST_EMPTY(&zfs_be_head)) {
1950 		zfs_be = SLIST_FIRST(&zfs_be_head);
1951 		SLIST_REMOVE_HEAD(&zfs_be_head, entries);
1952 		free(zfs_be->name);
1953 		free(zfs_be);
1954 	}
1955 
1956 	return (rv);
1957 }
1958 
1959 int
1960 zfs_belist_add(const char *name, uint64_t value __unused)
1961 {
1962 
1963 	/* Skip special datasets that start with a $ character */
1964 	if (strncmp(name, "$", 1) == 0) {
1965 		return (0);
1966 	}
1967 	/* Add the boot environment to the head of the SLIST */
1968 	zfs_be = malloc(sizeof(struct zfs_be_entry));
1969 	if (zfs_be == NULL) {
1970 		return (ENOMEM);
1971 	}
1972 	zfs_be->name = strdup(name);
1973 	if (zfs_be->name == NULL) {
1974 		free(zfs_be);
1975 		return (ENOMEM);
1976 	}
1977 	SLIST_INSERT_HEAD(&zfs_be_head, zfs_be, entries);
1978 	zfs_env_count++;
1979 
1980 	return (0);
1981 }
1982 
1983 int
1984 zfs_set_env(void)
1985 {
1986 	char envname[32], envval[256];
1987 	char *beroot, *pagenum;
1988 	int rv, page, ctr;
1989 
1990 	beroot = getenv("zfs_be_root");
1991 	if (beroot == NULL) {
1992 		return (1);
1993 	}
1994 
1995 	pagenum = getenv("zfs_be_currpage");
1996 	if (pagenum != NULL) {
1997 		page = strtol(pagenum, NULL, 10);
1998 	} else {
1999 		page = 1;
2000 	}
2001 
2002 	ctr = 1;
2003 	rv = 0;
2004 	zfs_env_index = ZFS_BE_FIRST;
2005 	SLIST_FOREACH_SAFE(zfs_be, &zfs_be_head, entries, zfs_be_tmp) {
2006 		/* Skip to the requested page number */
2007 		if (ctr <= ((ZFS_BE_LAST - ZFS_BE_FIRST + 1) * (page - 1))) {
2008 			ctr++;
2009 			continue;
2010 		}
2011 
2012 		snprintf(envname, sizeof(envname), "bootenvmenu_caption[%d]", zfs_env_index);
2013 		snprintf(envval, sizeof(envval), "%s", zfs_be->name);
2014 		rv = setenv(envname, envval, 1);
2015 		if (rv != 0) {
2016 			break;
2017 		}
2018 
2019 		snprintf(envname, sizeof(envname), "bootenvansi_caption[%d]", zfs_env_index);
2020 		rv = setenv(envname, envval, 1);
2021 		if (rv != 0){
2022 			break;
2023 		}
2024 
2025 		snprintf(envname, sizeof(envname), "bootenvmenu_command[%d]", zfs_env_index);
2026 		rv = setenv(envname, "set_bootenv", 1);
2027 		if (rv != 0){
2028 			break;
2029 		}
2030 
2031 		snprintf(envname, sizeof(envname), "bootenv_root[%d]", zfs_env_index);
2032 		snprintf(envval, sizeof(envval), "zfs:%s/%s", beroot, zfs_be->name);
2033 		rv = setenv(envname, envval, 1);
2034 		if (rv != 0){
2035 			break;
2036 		}
2037 
2038 		zfs_env_index++;
2039 		if (zfs_env_index > ZFS_BE_LAST) {
2040 			break;
2041 		}
2042 
2043 	}
2044 
2045 	for (; zfs_env_index <= ZFS_BE_LAST; zfs_env_index++) {
2046 		snprintf(envname, sizeof(envname), "bootenvmenu_caption[%d]", zfs_env_index);
2047 		(void)unsetenv(envname);
2048 		snprintf(envname, sizeof(envname), "bootenvansi_caption[%d]", zfs_env_index);
2049 		(void)unsetenv(envname);
2050 		snprintf(envname, sizeof(envname), "bootenvmenu_command[%d]", zfs_env_index);
2051 		(void)unsetenv(envname);
2052 		snprintf(envname, sizeof(envname), "bootenv_root[%d]", zfs_env_index);
2053 		(void)unsetenv(envname);
2054 	}
2055 
2056 	return (rv);
2057 }
2058