diff options
Diffstat (limited to 'usr/src/boot/lib')
| -rw-r--r-- | usr/src/boot/lib/libstand/Makefile.inc | 119 | ||||
| -rw-r--r-- | usr/src/boot/lib/libstand/cd9660.c | 34 | ||||
| -rw-r--r-- | usr/src/boot/lib/libstand/zfs/Makefile.inc | 44 | ||||
| -rw-r--r-- | usr/src/boot/lib/libstand/zfs/devicename_stubs.c | 47 | ||||
| -rw-r--r-- | usr/src/boot/lib/libstand/zfs/gzip.c | 66 | ||||
| -rw-r--r-- | usr/src/boot/lib/libstand/zfs/libzfs.h | 68 | ||||
| -rw-r--r-- | usr/src/boot/lib/libstand/zfs/zfs.c | 1028 | ||||
| -rw-r--r-- | usr/src/boot/lib/libstand/zfs/zfsimpl.c | 2571 |
8 files changed, 3914 insertions, 63 deletions
diff --git a/usr/src/boot/lib/libstand/Makefile.inc b/usr/src/boot/lib/libstand/Makefile.inc index 3af130cdfd..1fb9e216f9 100644 --- a/usr/src/boot/lib/libstand/Makefile.inc +++ b/usr/src/boot/lib/libstand/Makefile.inc @@ -20,13 +20,13 @@ # # standalone components and stuff we have modified locally -SRCS= $(LIB_BASE)/libz/gzguts.h $(LIB_BASE)/libz/zutil.h -SRCS += $(LIBSTAND_SRC)/__main.c $(LIBSTAND_SRC)/assert.c -SRCS += $(LIBSTAND_SRC)/bcd.c $(LIBSTAND_SRC)/environment.c -SRCS += $(LIBSTAND_SRC)/getopt.c $(LIBSTAND_SRC)/strtol.c -SRCS += $(LIBSTAND_SRC)/strtoul.c $(LIBSTAND_SRC)/random.c -SRCS += $(LIBSTAND_SRC)/sbrk.c $(LIBSTAND_SRC)/twiddle.c -SRCS += $(LIBSTAND_SRC)/zalloc.c $(LIBSTAND_SRC)/zalloc_malloc.c +SRCS= $(LIBSRC)/libz/gzguts.h $(LIBSRC)/libz/zutil.h +SRCS += $(SASRC)/__main.c $(SASRC)/assert.c +SRCS += $(SASRC)/bcd.c $(SASRC)/environment.c +SRCS += $(SASRC)/getopt.c $(SASRC)/strtol.c +SRCS += $(SASRC)/strtoul.c $(SASRC)/random.c +SRCS += $(SASRC)/sbrk.c $(SASRC)/twiddle.c +SRCS += $(SASRC)/zalloc.c $(SASRC)/zalloc_malloc.c OBJS= __main.o assert.o bcd.o environment.o \ getopt.o gets.o globals.o pager.o printf.o \ @@ -34,32 +34,32 @@ OBJS= __main.o assert.o bcd.o environment.o \ sbrk.o twiddle.o zalloc.o zalloc_malloc.o # private (pruned) versions of libc string functions -SRCS += $(LIBSTAND_SRC)/strcasecmp.c +SRCS += $(SASRC)/strcasecmp.c OBJS += strcasecmp.o # from libc -SRCS += $(LIB_BASE)/libc/net/ntoh.c +SRCS += $(LIBSRC)/libc/net/ntoh.c OBJS += ntoh.o # string functions from libc -SRCS += $(LIB_BASE)/libc/string/bcmp.c $(LIB_BASE)/libc/string/bcopy.c -SRCS += $(LIB_BASE)/libc/string/bzero.c $(LIB_BASE)/libc/string/ffs.c -SRCS += $(LIB_BASE)/libc/string/fls.c $(LIB_BASE)/libc/string/memccpy.c -SRCS += $(LIB_BASE)/libc/string/memchr.c $(LIB_BASE)/libc/string/memcmp.c -SRCS += $(LIB_BASE)/libc/string/memcpy.c $(LIB_BASE)/libc/string/memmove.c -SRCS += $(LIB_BASE)/libc/string/memset.c $(LIB_BASE)/libc/string/strcat.c -SRCS += $(LIB_BASE)/libc/string/strchr.c $(LIB_BASE)/libc/string/strcmp.c -SRCS += $(LIB_BASE)/libc/string/strcpy.c $(LIB_BASE)/libc/string/stpcpy.c -SRCS += $(LIB_BASE)/libc/string/stpncpy.c $(LIB_BASE)/libc/string/strcspn.c -SRCS += $(LIB_BASE)/libc/string/strlcat.c $(LIB_BASE)/libc/string/strlcpy.c -SRCS += $(LIB_BASE)/libc/string/strlen.c $(LIB_BASE)/libc/string/strncat.c -SRCS += $(LIB_BASE)/libc/string/strncmp.c $(LIB_BASE)/libc/string/strncpy.c -SRCS += $(LIB_BASE)/libc/string/strpbrk.c $(LIB_BASE)/libc/string/strrchr.c -SRCS += $(LIB_BASE)/libc/string/strsep.c $(LIB_BASE)/libc/string/strspn.c -SRCS += $(LIB_BASE)/libc/string/strstr.c $(LIB_BASE)/libc/string/strtok.c -SRCS += $(LIB_BASE)/libc/string/swab.c - -SRCS += $(LIBSTAND_SRC)/qdivrem.c +SRCS += $(LIBSRC)/libc/string/bcmp.c $(LIBSRC)/libc/string/bcopy.c +SRCS += $(LIBSRC)/libc/string/bzero.c $(LIBSRC)/libc/string/ffs.c +SRCS += $(LIBSRC)/libc/string/fls.c $(LIBSRC)/libc/string/memccpy.c +SRCS += $(LIBSRC)/libc/string/memchr.c $(LIBSRC)/libc/string/memcmp.c +SRCS += $(LIBSRC)/libc/string/memcpy.c $(LIBSRC)/libc/string/memmove.c +SRCS += $(LIBSRC)/libc/string/memset.c $(LIBSRC)/libc/string/strcat.c +SRCS += $(LIBSRC)/libc/string/strchr.c $(LIBSRC)/libc/string/strcmp.c +SRCS += $(LIBSRC)/libc/string/strcpy.c $(LIBSRC)/libc/string/stpcpy.c +SRCS += $(LIBSRC)/libc/string/stpncpy.c $(LIBSRC)/libc/string/strcspn.c +SRCS += $(LIBSRC)/libc/string/strlcat.c $(LIBSRC)/libc/string/strlcpy.c +SRCS += $(LIBSRC)/libc/string/strlen.c $(LIBSRC)/libc/string/strncat.c +SRCS += $(LIBSRC)/libc/string/strncmp.c $(LIBSRC)/libc/string/strncpy.c +SRCS += $(LIBSRC)/libc/string/strpbrk.c $(LIBSRC)/libc/string/strrchr.c +SRCS += $(LIBSRC)/libc/string/strsep.c $(LIBSRC)/libc/string/strspn.c +SRCS += $(LIBSRC)/libc/string/strstr.c $(LIBSRC)/libc/string/strtok.c +SRCS += $(LIBSRC)/libc/string/swab.c + +SRCS += $(SASRC)/qdivrem.c OBJS += bcmp.o bcopy.o bzero.o ffs.o fls.o \ memccpy.o memchr.o memcmp.o memcpy.o memmove.o memset.o \ @@ -68,12 +68,12 @@ OBJS += bcmp.o bcopy.o bzero.o ffs.o fls.o \ strpbrk.o strrchr.o strsep.o strspn.o strstr.o strtok.o swab.o # uuid functions from libc -SRCS += $(LIB_BASE)/libc/uuid/uuid_create_nil.c -SRCS += $(LIB_BASE)/libc/uuid/uuid_equal.c -SRCS += $(LIB_BASE)/libc/uuid/uuid_is_nil.c +SRCS += $(LIBSRC)/libc/uuid/uuid_create_nil.c +SRCS += $(LIBSRC)/libc/uuid/uuid_equal.c +SRCS += $(LIBSRC)/libc/uuid/uuid_is_nil.c -SRCS += $(LIBSTAND_SRC)/uuid_from_string.c -SRCS += $(LIBSTAND_SRC)/uuid_to_string.c +SRCS += $(SASRC)/uuid_from_string.c +SRCS += $(SASRC)/uuid_to_string.c OBJS += uuid_create_nil.o uuid_equal.o uuid_from_string.o uuid_is_nil.o \ uuid_to_string.o @@ -108,28 +108,28 @@ libstand_bzlib_private.h: $(SRC)/common/bzip2/bzlib_private.h sed -e 's|<stdlib.h>|"stand.h"|' $^ > $@ # decompression functionality from libz -CFLAGS += -DHAVE_MEMCPY -I$(LIB_BASE)/libz -SRCS += $(LIB_BASE)/libz/adler32.c $(LIB_BASE)/libz/crc32.c \ +CFLAGS += -DHAVE_MEMCPY -I$(LIBSRC)/libz +SRCS += $(LIBSRC)/libz/adler32.c $(LIBSRC)/libz/crc32.c \ libstand_zutil.h libstand_gzguts.h OBJS += adler32.o crc32.o -_infback.c: $(LIB_BASE)/libz/infback.c +_infback.c: $(LIBSRC)/libz/infback.c sed -e "s|zutil\.h|libstand_zutil.h|" \ -e "s|gzguts\.h|libstand_gzguts.h|" \ $^ > $@ -_inffast.c: $(LIB_BASE)/libz/inffast.c +_inffast.c: $(LIBSRC)/libz/inffast.c sed -e "s|zutil\.h|libstand_zutil.h|" \ -e "s|gzguts\.h|libstand_gzguts.h|" \ $^ > $@ -_inflate.c: $(LIB_BASE)/libz/inflate.c +_inflate.c: $(LIBSRC)/libz/inflate.c sed -e "s|zutil\.h|libstand_zutil.h|" \ -e "s|gzguts\.h|libstand_gzguts.h|" \ $^ > $@ -_inftrees.c: $(LIB_BASE)/libz/inftrees.c +_inftrees.c: $(LIBSRC)/libz/inftrees.c sed -e "s|zutil\.h|libstand_zutil.h|" \ -e "s|gzguts\.h|libstand_gzguts.h|" \ $^ > $@ -_zutil.c: $(LIB_BASE)/libz/zutil.c +_zutil.c: $(LIBSRC)/libz/zutil.c sed -e "s|zutil\.h|libstand_zutil.h|" \ -e "s|gzguts\.h|libstand_gzguts.h|" \ $^ > $@ @@ -139,7 +139,7 @@ OBJS += _infback.o _inffast.o _inflate.o _inftrees.o _zutil.o CLEANFILES += _infback.c _inffast.c _inflate.c _inftrees.c _zutil.c # depend on stand.h being able to be included multiple times -libstand_zutil.h: $(LIB_BASE)/libz/zutil.h +libstand_zutil.h: $(LIBSRC)/libz/zutil.h sed -e 's|<fcntl.h>|"stand.h"|' \ -e 's|<stddef.h>|"stand.h"|' \ -e 's|<string.h>|"stand.h"|' \ @@ -147,7 +147,7 @@ libstand_zutil.h: $(LIB_BASE)/libz/zutil.h -e 's|<stdlib.h>|"stand.h"|' \ $^ > $@ -libstand_gzguts.h: $(LIB_BASE)/libz/gzguts.h +libstand_gzguts.h: $(LIBSRC)/libz/gzguts.h sed -e 's|<fcntl.h>|"stand.h"|' \ -e 's|<stddef.h>|"stand.h"|' \ -e 's|<string.h>|"stand.h"|' \ @@ -158,35 +158,35 @@ libstand_gzguts.h: $(LIB_BASE)/libz/gzguts.h CLEANFILES += libstand_zutil.h libstand_gzguts.h # io routines -SRCS += $(LIBSTAND_SRC)/closeall.c $(LIBSTAND_SRC)/dev.c \ - $(LIBSTAND_SRC)/ioctl.c $(LIBSTAND_SRC)/nullfs.c \ - $(LIBSTAND_SRC)/stat.c $(LIBSTAND_SRC)/fstat.c $(LIBSTAND_SRC)/close.c \ - $(LIBSTAND_SRC)/lseek.c $(LIBSTAND_SRC)/open.c $(LIBSTAND_SRC)/read.c \ - $(LIBSTAND_SRC)/write.c $(LIBSTAND_SRC)/readdir.c +SRCS += $(SASRC)/closeall.c $(SASRC)/dev.c \ + $(SASRC)/ioctl.c $(SASRC)/nullfs.c \ + $(SASRC)/stat.c $(SASRC)/fstat.c $(SASRC)/close.c \ + $(SASRC)/lseek.c $(SASRC)/open.c $(SASRC)/read.c \ + $(SASRC)/write.c $(SASRC)/readdir.c OBJS += closeall.o dev.o ioctl.o nullfs.o stat.o fstat.o close.o lseek.o \ open.o read.o write.o readdir.o # network routines -SRCS += $(LIBSTAND_SRC)/arp.c $(LIBSTAND_SRC)/ether.c $(LIBSTAND_SRC)/ip.c \ - $(LIBSTAND_SRC)/inet_ntoa.c $(LIBSTAND_SRC)/in_cksum.c \ - $(LIBSTAND_SRC)/net.c $(LIBSTAND_SRC)/udp.c $(LIBSTAND_SRC)/netif.c \ - $(LIBSTAND_SRC)/rpc.c +SRCS += $(SASRC)/arp.c $(SASRC)/ether.c $(SASRC)/ip.c \ + $(SASRC)/inet_ntoa.c $(SASRC)/in_cksum.c \ + $(SASRC)/net.c $(SASRC)/udp.c $(SASRC)/netif.c \ + $(SASRC)/rpc.c OBJS += arp.o ether.o ip.o inet_ntoa.o in_cksum.o net.o udp.o netif.o rpc.o # network info services: -SRCS += $(LIBSTAND_SRC)/bootp.c $(LIBSTAND_SRC)/rarp.c \ - $(LIBSTAND_SRC)/bootparam.c +SRCS += $(SASRC)/bootp.c $(SASRC)/rarp.c \ + $(SASRC)/bootparam.c OBJS += bootp.o rarp.o bootparam.o # boot filesystems -SRCS += $(LIBSTAND_SRC)/ufs.c -SRCS += $(LIBSTAND_SRC)/nfs.c -SRCS += $(LIBSTAND_SRC)/cd9660.c -SRCS += $(LIBSTAND_SRC)/tftp.c -SRCS += $(LIBSTAND_SRC)/gzipfs.c -SRCS += $(LIBSTAND_SRC)/bzipfs.c -SRCS += $(LIBSTAND_SRC)/dosfs.c +SRCS += $(SASRC)/ufs.c +SRCS += $(SASRC)/nfs.c +SRCS += $(SASRC)/cd9660.c +SRCS += $(SASRC)/tftp.c +SRCS += $(SASRC)/gzipfs.c +SRCS += $(SASRC)/bzipfs.c +SRCS += $(SASRC)/dosfs.c OBJS += ufs.o OBJS += nfs.o OBJS += cd9660.o @@ -195,3 +195,4 @@ OBJS += gzipfs.o OBJS += bzipfs.o OBJS += dosfs.o # +.PARALLEL: diff --git a/usr/src/boot/lib/libstand/cd9660.c b/usr/src/boot/lib/libstand/cd9660.c index 1e094450cd..487b994408 100644 --- a/usr/src/boot/lib/libstand/cd9660.c +++ b/usr/src/boot/lib/libstand/cd9660.c @@ -41,6 +41,7 @@ */ #include <sys/param.h> #include <string.h> +#include <stdbool.h> #include <sys/dirent.h> #include <fs/cd9660/iso.h> #include <fs/cd9660/cd9660_rrip.h> @@ -226,8 +227,8 @@ static int dirmatch(struct open_file *f, const char *path, struct iso_directory_record *dp, int use_rrip, int lenskip) { - size_t len; - char *cp; + size_t len, plen; + char *cp, *sep; int i, icase; if (use_rrip) @@ -241,7 +242,14 @@ dirmatch(struct open_file *f, const char *path, struct iso_directory_record *dp, } else icase = 0; - if (strlen(path) != len) + sep = strchr(path, '/'); + if (sep != NULL) { + plen = sep - path; + } else { + plen = strlen(path); + } + + if (plen != len) return (0); for (i = len; --i >= 0; path++, cp++) { @@ -283,6 +291,7 @@ cd9660_open(const char *path, struct open_file *f) struct iso_directory_record rec; struct iso_directory_record *dp = NULL; int rc, first, use_rrip, lenskip; + bool isdir = false; /* First find the volume descriptor */ buf = malloc(buf_size = ISO_DEFAULT_BLOCK_SIZE); @@ -372,7 +381,24 @@ cd9660_open(const char *path, struct open_file *f) rec = *dp; while (*path && *path != '/') /* look for next component */ path++; - if (*path) path++; /* skip '/' */ + + if (*path) /* this component was directory */ + isdir = true; + + while (*path == '/') + path++; /* skip '/' */ + + if (*path) /* We do have next component. */ + isdir = false; + } + + /* + * if the path had trailing / but the path does point to file, + * report the error ENOTDIR. + */ + if (isdir == true && (isonum_711(rec.flags) & 2) == 0) { + rc = ENOTDIR; + goto out; } /* allocate file system specific data structure */ diff --git a/usr/src/boot/lib/libstand/zfs/Makefile.inc b/usr/src/boot/lib/libstand/zfs/Makefile.inc new file mode 100644 index 0000000000..083b6f8d07 --- /dev/null +++ b/usr/src/boot/lib/libstand/zfs/Makefile.inc @@ -0,0 +1,44 @@ +# +# This file and its contents are supplied under the terms of the +# Common Development and Distribution License ("CDDL"), version 1.0. +# You may only use this file in accordance with the terms of version +# 1.0 of the CDDL. +# +# A full copy of the text of the CDDL should have accompanied this +# source. A copy of the CDDL is also available via the Internet at +# http://www.illumos.org/license/CDDL. +# + +# +# Copyright 2016 Toomas Soome <tsoome@me.com> +# + +SRCS += $(ZFSSRC)/zfs.c +SRCS += $(ZFSSRC)/gzip.c +SRCS += $(SRC)/common/crypto/edonr/edonr.c +SRCS += $(SRC)/common/crypto/skein/skein.c +SRCS += $(SRC)/common/crypto/skein/skein_iv.c +SRCS += $(SRC)/common/crypto/skein/skein_block.c +OBJS += zfs.o +OBJS += gzip.o +OBJS += edonr.o +OBJS += skein.o +OBJS += skein_iv.o +OBJS += skein_block.o + +zfs.o := CPPFLAGS += -I../../common +zfs.o := CPPFLAGS += -I../../../cddl/boot/zfs + +# Do not unroll skein loops, reduce code size +skein_block.o := CPPFLAGS += -DSKEIN_LOOP=111 + +%.o: $(ZFSSRC)/%.c + $(COMPILE.c) -o $@ $< + +%.o: $(SRC)/common/crypto/edonr/%.c + $(COMPILE.c) -o $@ $< + +%.o: $(SRC)/common/crypto/skein/%.c + $(COMPILE.c) -o $@ $< + +zfs.o: $(ZFSSRC)/zfsimpl.c diff --git a/usr/src/boot/lib/libstand/zfs/devicename_stubs.c b/usr/src/boot/lib/libstand/zfs/devicename_stubs.c new file mode 100644 index 0000000000..41bf907e0c --- /dev/null +++ b/usr/src/boot/lib/libstand/zfs/devicename_stubs.c @@ -0,0 +1,47 @@ +/*- + * Copyright (c) 2012 Andriy Gapon <avg@FreeBSD.org> + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + */ + +#include <sys/cdefs.h> +__FBSDID("$FreeBSD$"); + +#include <stand.h> +#include "libzfs.h" + +__attribute__((weak)) +int +zfs_parsedev(struct zfs_devdesc *dev, const char *devspec, const char **path) +{ + return (EINVAL); +} + +__attribute__((weak)) +char * +zfs_fmtdev(void *vdev) +{ + static char buf[128]; + + return (buf); +} diff --git a/usr/src/boot/lib/libstand/zfs/gzip.c b/usr/src/boot/lib/libstand/zfs/gzip.c new file mode 100644 index 0000000000..676d1cb87f --- /dev/null +++ b/usr/src/boot/lib/libstand/zfs/gzip.c @@ -0,0 +1,66 @@ +/* + * This file and its contents are supplied under the terms of the + * Common Development and Distribution License ("CDDL"), version 1.0. + * You may only use this file in accordance with the terms of version + * 1.0 of the CDDL. + * + * A full copy of the text of the CDDL should have accompanied this + * source. A copy of the CDDL is also available via the Internet at + * http://www.illumos.org/license/CDDL. + */ + +/* + * Copyright 2015 Toomas Soome <tsoome@me.com> + * Copyright 2008 Sun Microsystems, Inc. All rights reserved. + * Use is subject to license terms. + */ + +#include <zlib.h> +#include <strings.h> + +int gzip_decompress(void *, void *, size_t, size_t, int); +/* + * Uncompress the buffer 'src' into the buffer 'dst'. The caller must store + * the expected decompressed data size externally so it can be passed in. + * The resulting decompressed size is then returned through dstlen. This + * function return Z_OK on success, or another error code on failure. + */ +static int +z_uncompress(void *dst, size_t *dstlen, const void *src, size_t srclen) +{ + z_stream zs; + int err; + + bzero(&zs, sizeof (zs)); + zs.next_in = (unsigned char *)src; + zs.avail_in = srclen; + zs.next_out = dst; + zs.avail_out = *dstlen; + + /* + * Call inflateInit2() specifying a window size of DEF_WBITS + * with the 6th bit set to indicate that the compression format + * type (zlib or gzip) should be automatically detected. + */ + if ((err = inflateInit2(&zs, 15 | 0x20)) != Z_OK) + return (err); + + if ((err = inflate(&zs, Z_FINISH)) != Z_STREAM_END) { + (void) inflateEnd(&zs); + return (err == Z_OK ? Z_BUF_ERROR : err); + } + + *dstlen = zs.total_out; + return (inflateEnd(&zs)); +} + +int +gzip_decompress(void *s_start, void *d_start, size_t s_len, size_t d_len, int n) +{ + size_t dstlen = d_len; + + if (z_uncompress(d_start, &dstlen, s_start, s_len) != Z_OK) + return (-1); + + return (0); +} diff --git a/usr/src/boot/lib/libstand/zfs/libzfs.h b/usr/src/boot/lib/libstand/zfs/libzfs.h new file mode 100644 index 0000000000..a8430290f1 --- /dev/null +++ b/usr/src/boot/lib/libstand/zfs/libzfs.h @@ -0,0 +1,68 @@ +/* + * Copyright (c) 2012 Andriy Gapon <avg@FreeBSD.org> + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + */ + +#ifndef _BOOT_LIBZFS_H_ +#define _BOOT_LIBZFS_H_ + +#define ZFS_MAXNAMELEN 256 + +/* + * ZFS fully-qualified device descriptor. + */ +struct zfs_devdesc { + struct devdesc dd; /* Must be first. */ + uint64_t pool_guid; + uint64_t root_guid; +}; + +struct zfs_boot_args +{ + uint32_t size; + uint32_t reserved; + uint64_t pool; + uint64_t root; + uint64_t primary_pool; + uint64_t primary_vdev; +}; + +int zfs_parsedev(struct zfs_devdesc *dev, const char *devspec, + const char **path); +char *zfs_bootfs(void *vdev); +char *zfs_fmtdev(void *vdev); +int zfs_probe_dev(const char *devname, uint64_t *pool_guid); +int zfs_list(const char *name); +uint64_t ldi_get_size(void *); +#ifdef __FreeBSD__ +void init_zfs_bootenv(char *currdev); +int zfs_bootenv(const char *name); +int zfs_belist_add(const char *name, uint64_t __unused); +int zfs_set_env(void); +#endif + +extern struct devsw zfs_dev; +extern struct fs_ops zfs_fsops; + +#endif /*_BOOT_LIBZFS_H_*/ diff --git a/usr/src/boot/lib/libstand/zfs/zfs.c b/usr/src/boot/lib/libstand/zfs/zfs.c new file mode 100644 index 0000000000..471fd6b32f --- /dev/null +++ b/usr/src/boot/lib/libstand/zfs/zfs.c @@ -0,0 +1,1028 @@ +/* + * Copyright (c) 2007 Doug Rabson + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + */ + +#include <sys/cdefs.h> + +/* + * Stand-alone file reading package. + */ + +#include <stand.h> +#include <sys/disk.h> +#include <sys/param.h> +#include <sys/time.h> +#include <sys/queue.h> +#include <disk.h> +#include <part.h> +#include <stddef.h> +#include <stdarg.h> +#include <string.h> +#include <bootstrap.h> +#include <inttypes.h> + +#include "libzfs.h" + +#include "zfsimpl.c" + +/* Define the range of indexes to be populated with ZFS Boot Environments */ +#define ZFS_BE_FIRST 4 +#define ZFS_BE_LAST 8 + +static int zfs_open(const char *path, struct open_file *f); +static int zfs_close(struct open_file *f); +static int zfs_read(struct open_file *f, void *buf, size_t size, size_t *resid); +static off_t zfs_seek(struct open_file *f, off_t offset, int where); +static int zfs_stat(struct open_file *f, struct stat *sb); +static int zfs_readdir(struct open_file *f, struct dirent *d); + +struct devsw zfs_dev; + +struct fs_ops zfs_fsops = { + "zfs", + zfs_open, + zfs_close, + zfs_read, + null_write, + zfs_seek, + zfs_stat, + zfs_readdir +}; + +/* + * In-core open file. + */ +struct file { + off_t f_seekp; /* seek pointer */ + dnode_phys_t f_dnode; + uint64_t f_zap_type; /* zap type for readdir */ + uint64_t f_num_leafs; /* number of fzap leaf blocks */ + zap_leaf_phys_t *f_zap_leaf; /* zap leaf buffer */ +}; + +#ifdef __FreeBSD__ +static int zfs_env_index; +static int zfs_env_count; +#endif + +SLIST_HEAD(zfs_be_list, zfs_be_entry) zfs_be_head = SLIST_HEAD_INITIALIZER(zfs_be_head); +struct zfs_be_list *zfs_be_headp; +struct zfs_be_entry { + const char *name; + SLIST_ENTRY(zfs_be_entry) entries; +} *zfs_be, *zfs_be_tmp; + +/* + * Open a file. + */ +static int +zfs_open(const char *upath, struct open_file *f) +{ + struct zfsmount *mount = (struct zfsmount *)f->f_devdata; + struct file *fp; + int rc; + + if (f->f_dev != &zfs_dev) + return (EINVAL); + + /* allocate file system specific data structure */ + fp = malloc(sizeof(struct file)); + bzero(fp, sizeof(struct file)); + f->f_fsdata = (void *)fp; + + rc = zfs_lookup(mount, upath, &fp->f_dnode); + fp->f_seekp = 0; + if (rc) { + f->f_fsdata = NULL; + free(fp); + } + return (rc); +} + +static int +zfs_close(struct open_file *f) +{ + struct file *fp = (struct file *)f->f_fsdata; + + dnode_cache_obj = 0; + f->f_fsdata = (void *)0; + if (fp == (struct file *)0) + return (0); + + free(fp); + return (0); +} + +/* + * Copy a portion of a file into kernel memory. + * Cross block boundaries when necessary. + */ +static int +zfs_read(struct open_file *f, void *start, size_t size, size_t *resid /* out */) +{ + const spa_t *spa = ((struct zfsmount *)f->f_devdata)->spa; + struct file *fp = (struct file *)f->f_fsdata; + struct stat sb; + size_t n; + int rc; + + rc = zfs_stat(f, &sb); + if (rc) + return (rc); + n = size; + if (fp->f_seekp + n > sb.st_size) + n = sb.st_size - fp->f_seekp; + + rc = dnode_read(spa, &fp->f_dnode, fp->f_seekp, start, n); + if (rc) + return (rc); + + if (0) { + int i; + for (i = 0; i < n; i++) + putchar(((char*) start)[i]); + } + fp->f_seekp += n; + if (resid) + *resid = size - n; + + return (0); +} + +static off_t +zfs_seek(struct open_file *f, off_t offset, int where) +{ + struct file *fp = (struct file *)f->f_fsdata; + + switch (where) { + case SEEK_SET: + fp->f_seekp = offset; + break; + case SEEK_CUR: + fp->f_seekp += offset; + break; + case SEEK_END: + { + struct stat sb; + int error; + + error = zfs_stat(f, &sb); + if (error != 0) { + errno = error; + return (-1); + } + fp->f_seekp = sb.st_size - offset; + break; + } + default: + errno = EINVAL; + return (-1); + } + return (fp->f_seekp); +} + +static int +zfs_stat(struct open_file *f, struct stat *sb) +{ + const spa_t *spa = ((struct zfsmount *)f->f_devdata)->spa; + struct file *fp = (struct file *)f->f_fsdata; + + return (zfs_dnode_stat(spa, &fp->f_dnode, sb)); +} + +static int +zfs_readdir(struct open_file *f, struct dirent *d) +{ + const spa_t *spa = ((struct zfsmount *)f->f_devdata)->spa; + struct file *fp = (struct file *)f->f_fsdata; + mzap_ent_phys_t mze; + struct stat sb; + size_t bsize = fp->f_dnode.dn_datablkszsec << SPA_MINBLOCKSHIFT; + int rc; + + rc = zfs_stat(f, &sb); + if (rc) + return (rc); + if (!S_ISDIR(sb.st_mode)) + return (ENOTDIR); + + /* + * If this is the first read, get the zap type. + */ + if (fp->f_seekp == 0) { + rc = dnode_read(spa, &fp->f_dnode, + 0, &fp->f_zap_type, sizeof(fp->f_zap_type)); + if (rc) + return (rc); + + if (fp->f_zap_type == ZBT_MICRO) { + fp->f_seekp = offsetof(mzap_phys_t, mz_chunk); + } else { + rc = dnode_read(spa, &fp->f_dnode, + offsetof(zap_phys_t, zap_num_leafs), + &fp->f_num_leafs, + sizeof(fp->f_num_leafs)); + if (rc) + return (rc); + + fp->f_seekp = bsize; + fp->f_zap_leaf = (zap_leaf_phys_t *)malloc(bsize); + rc = dnode_read(spa, &fp->f_dnode, + fp->f_seekp, + fp->f_zap_leaf, + bsize); + if (rc) + return (rc); + } + } + + if (fp->f_zap_type == ZBT_MICRO) { + mzap_next: + if (fp->f_seekp >= bsize) + return (ENOENT); + + rc = dnode_read(spa, &fp->f_dnode, + fp->f_seekp, &mze, sizeof(mze)); + if (rc) + return (rc); + fp->f_seekp += sizeof(mze); + + if (!mze.mze_name[0]) + goto mzap_next; + + d->d_fileno = ZFS_DIRENT_OBJ(mze.mze_value); + d->d_type = ZFS_DIRENT_TYPE(mze.mze_value); + strcpy(d->d_name, mze.mze_name); + d->d_namlen = strlen(d->d_name); + return (0); + } else { + zap_leaf_t zl; + zap_leaf_chunk_t *zc, *nc; + int chunk; + size_t namelen; + char *p; + uint64_t value; + + /* + * Initialise this so we can use the ZAP size + * calculating macros. + */ + zl.l_bs = ilog2(bsize); + zl.l_phys = fp->f_zap_leaf; + + /* + * Figure out which chunk we are currently looking at + * and consider seeking to the next leaf. We use the + * low bits of f_seekp as a simple chunk index. + */ + fzap_next: + chunk = fp->f_seekp & (bsize - 1); + if (chunk == ZAP_LEAF_NUMCHUNKS(&zl)) { + fp->f_seekp = (fp->f_seekp & ~(bsize - 1)) + bsize; + chunk = 0; + + /* + * Check for EOF and read the new leaf. + */ + if (fp->f_seekp >= bsize * fp->f_num_leafs) + return (ENOENT); + + rc = dnode_read(spa, &fp->f_dnode, + fp->f_seekp, + fp->f_zap_leaf, + bsize); + if (rc) + return (rc); + } + + zc = &ZAP_LEAF_CHUNK(&zl, chunk); + fp->f_seekp++; + if (zc->l_entry.le_type != ZAP_CHUNK_ENTRY) + goto fzap_next; + + namelen = zc->l_entry.le_name_numints; + if (namelen > sizeof(d->d_name)) + namelen = sizeof(d->d_name); + + /* + * Paste the name back together. + */ + nc = &ZAP_LEAF_CHUNK(&zl, zc->l_entry.le_name_chunk); + p = d->d_name; + while (namelen > 0) { + int len; + len = namelen; + if (len > ZAP_LEAF_ARRAY_BYTES) + len = ZAP_LEAF_ARRAY_BYTES; + memcpy(p, nc->l_array.la_array, len); + p += len; + namelen -= len; + nc = &ZAP_LEAF_CHUNK(&zl, nc->l_array.la_next); + } + d->d_name[sizeof(d->d_name) - 1] = 0; + + /* + * Assume the first eight bytes of the value are + * a uint64_t. + */ + value = fzap_leaf_value(&zl, zc); + + d->d_fileno = ZFS_DIRENT_OBJ(value); + d->d_type = ZFS_DIRENT_TYPE(value); + d->d_namlen = strlen(d->d_name); + + return (0); + } +} + +static int +vdev_read(vdev_t *vdev, void *priv, off_t offset, void *buf, size_t bytes) +{ + int fd, ret; + size_t res, size, remainder, rb_size, blksz; + unsigned secsz; + off_t off; + char *bouncebuf, *rb_buf; + + fd = (uintptr_t) priv; + bouncebuf = NULL; + + ret = ioctl(fd, DIOCGSECTORSIZE, &secsz); + if (ret != 0) + return (ret); + + off = offset / secsz; + remainder = offset % secsz; + if (lseek(fd, off * secsz, SEEK_SET) == -1) + return (errno); + + rb_buf = buf; + rb_size = bytes; + size = roundup2(bytes + remainder, secsz); + blksz = size; + if (remainder != 0 || size != bytes) { + bouncebuf = zfs_alloc(secsz); + if (bouncebuf == NULL) { + printf("vdev_read: out of memory\n"); + return (ENOMEM); + } + rb_buf = bouncebuf; + blksz = rb_size - remainder; + } + + while (bytes > 0) { + res = read(fd, rb_buf, rb_size); + if (res != rb_size) { + ret = EIO; + goto error; + } + if (bytes < blksz) + blksz = bytes; + if (bouncebuf != NULL) + memcpy(buf, rb_buf + remainder, blksz); + buf = (void *)((uintptr_t)buf + blksz); + bytes -= blksz; + remainder = 0; + blksz = rb_size; + } + + ret = 0; +error: + if (bouncebuf != NULL) + zfs_free(bouncebuf, secsz); + return (ret); +} + +static int +zfs_dev_init(void) +{ + spa_t *spa; + spa_t *next; + spa_t *prev; + + zfs_init(); + if (archsw.arch_zfs_probe == NULL) + return (ENXIO); + archsw.arch_zfs_probe(); + + prev = NULL; + spa = STAILQ_FIRST(&zfs_pools); + while (spa != NULL) { + next = STAILQ_NEXT(spa, spa_link); + if (zfs_spa_init(spa)) { + if (prev == NULL) + STAILQ_REMOVE_HEAD(&zfs_pools, spa_link); + else + STAILQ_REMOVE_AFTER(&zfs_pools, prev, spa_link); + } else + prev = spa; + spa = next; + } + return (0); +} + +struct zfs_probe_args { + int fd; + const char *devname; + uint64_t *pool_guid; + u_int secsz; +}; + +static int +zfs_diskread(void *arg, void *buf, size_t blocks, uint64_t offset) +{ + struct zfs_probe_args *ppa; + + ppa = (struct zfs_probe_args *)arg; + return (vdev_read(NULL, (void *)(uintptr_t)ppa->fd, + offset * ppa->secsz, buf, blocks * ppa->secsz)); +} + +static int +zfs_probe(int fd, uint64_t *pool_guid) +{ + spa_t *spa; + int ret; + + spa = NULL; + ret = vdev_probe(vdev_read, (void *)(uintptr_t)fd, &spa); + if (ret == 0 && pool_guid != NULL) + *pool_guid = spa->spa_guid; + return (ret); +} + +static int +zfs_probe_partition(void *arg, const char *partname, + const struct ptable_entry *part) +{ + struct zfs_probe_args *ppa, pa; + struct ptable *table; + char devname[32]; + int ret = 0; + + /* filter out partitions *not* used by zfs */ + switch (part->type) { + case PART_RESERVED: /* efi reserverd */ + case PART_VTOC_BOOT: /* vtoc boot area */ + case PART_VTOC_SWAP: + return (ret); + default: + break; + } + ppa = (struct zfs_probe_args *)arg; + strncpy(devname, ppa->devname, strlen(ppa->devname) - 1); + devname[strlen(ppa->devname) - 1] = '\0'; + sprintf(devname, "%s%s:", devname, partname); + pa.fd = open(devname, O_RDONLY); + if (pa.fd == -1) + return (ret); + ret = zfs_probe(pa.fd, ppa->pool_guid); + if (ret == 0) + return (ret); + if (part->type == PART_SOLARIS2) { + pa.devname = devname; + pa.pool_guid = ppa->pool_guid; + pa.secsz = ppa->secsz; + table = ptable_open(&pa, part->end - part->start + 1, + ppa->secsz, zfs_diskread); + if (table != NULL) { + enum ptable_type pt = ptable_gettype(table); + + if (pt == PTABLE_VTOC8 || pt == PTABLE_VTOC) + ptable_iterate(table, &pa, zfs_probe_partition); + ptable_close(table); + } + } + close(pa.fd); + return (0); +} + +int +zfs_probe_dev(const char *devname, uint64_t *pool_guid) +{ + struct disk_devdesc *dev; + struct ptable *table; + struct zfs_probe_args pa; + uint64_t mediasz; + int ret; + + if (pool_guid) + *pool_guid = 0; + pa.fd = open(devname, O_RDONLY); + if (pa.fd == -1) + return (ENXIO); + /* + * We will not probe the whole disk, we can not boot from such + * disks and some systems will misreport the disk sizes and will + * hang while accessing the disk. + */ + if (archsw.arch_getdev((void **)&dev, devname, NULL) == 0) { + int partition = dev->d_partition; + int slice = dev->d_slice; + + free(dev); + if (partition != -1 && slice != -1) { + ret = zfs_probe(pa.fd, pool_guid); + if (ret == 0) + return (0); + } + } + + /* Probe each partition */ + ret = ioctl(pa.fd, DIOCGMEDIASIZE, &mediasz); + if (ret == 0) + ret = ioctl(pa.fd, DIOCGSECTORSIZE, &pa.secsz); + if (ret == 0) { + pa.devname = devname; + pa.pool_guid = pool_guid; + table = ptable_open(&pa, mediasz / pa.secsz, pa.secsz, + zfs_diskread); + if (table != NULL) { + ptable_iterate(table, &pa, zfs_probe_partition); + ptable_close(table); + } + } + close(pa.fd); + if (pool_guid && *pool_guid == 0) + ret = ENXIO; + return (ret); +} + +/* + * Print information about ZFS pools + */ +static int +zfs_dev_print(int verbose) +{ + spa_t *spa; + char line[80]; + int ret = 0; + + if (STAILQ_EMPTY(&zfs_pools)) + return (0); + + printf("%s devices:", zfs_dev.dv_name); + if ((ret = pager_output("\n")) != 0) + return (ret); + + if (verbose) { + return (spa_all_status()); + } + STAILQ_FOREACH(spa, &zfs_pools, spa_link) { + sprintf(line, " zfs:%s\n", spa->spa_name); + ret = pager_output(line); + if (ret != 0) + break; + } + return (ret); +} + +/* + * Attempt to open the pool described by (dev) for use by (f). + */ +static int +zfs_dev_open(struct open_file *f, ...) +{ + va_list args; + struct zfs_devdesc *dev; + struct zfsmount *mount; + spa_t *spa; + int rv; + + va_start(args, f); + dev = va_arg(args, struct zfs_devdesc *); + va_end(args); + + if (dev->pool_guid == 0) + spa = STAILQ_FIRST(&zfs_pools); + else + spa = spa_find_by_guid(dev->pool_guid); + if (!spa) + return (ENXIO); + mount = malloc(sizeof(*mount)); + rv = zfs_mount(spa, dev->root_guid, mount); + if (rv != 0) { + free(mount); + return (rv); + } + if (mount->objset.os_type != DMU_OST_ZFS) { + printf("Unexpected object set type %ju\n", + (uintmax_t)mount->objset.os_type); + free(mount); + return (EIO); + } + f->f_devdata = mount; + free(dev); + return (0); +} + +static int +zfs_dev_close(struct open_file *f) +{ + + free(f->f_devdata); + f->f_devdata = NULL; + return (0); +} + +static int +zfs_dev_strategy(void *devdata, int rw, daddr_t dblk, size_t size, + char *buf, size_t *rsize) +{ + + return (ENOSYS); +} + +struct devsw zfs_dev = { + .dv_name = "zfs", + .dv_type = DEVT_ZFS, + .dv_init = zfs_dev_init, + .dv_strategy = zfs_dev_strategy, + .dv_open = zfs_dev_open, + .dv_close = zfs_dev_close, + .dv_ioctl = noioctl, + .dv_print = zfs_dev_print, + .dv_cleanup = NULL +}; + +int +zfs_parsedev(struct zfs_devdesc *dev, const char *devspec, const char **path) +{ + static char rootname[ZFS_MAXNAMELEN]; + static char poolname[ZFS_MAXNAMELEN]; + spa_t *spa; + const char *end; + const char *np; + const char *sep; + int rv; + + np = devspec; + if (*np != ':') + return (EINVAL); + np++; + end = strrchr(np, ':'); + if (end == NULL) + return (EINVAL); + sep = strchr(np, '/'); + if (sep == NULL || sep >= end) + sep = end; + memcpy(poolname, np, sep - np); + poolname[sep - np] = '\0'; + if (sep < end) { + sep++; + memcpy(rootname, sep, end - sep); + rootname[end - sep] = '\0'; + } + else + rootname[0] = '\0'; + + spa = spa_find_by_name(poolname); + if (!spa) + return (ENXIO); + dev->pool_guid = spa->spa_guid; + rv = zfs_lookup_dataset(spa, rootname, &dev->root_guid); + if (rv != 0) + return (rv); + if (path != NULL) + *path = (*end == '\0') ? end : end + 1; + dev->dd.d_dev = &zfs_dev; + return (0); +} + +char * +zfs_bootfs(void *zdev) +{ + static char rootname[ZFS_MAXNAMELEN]; + static char buf[2 * ZFS_MAXNAMELEN]; + struct zfs_devdesc *dev = (struct zfs_devdesc *)zdev; + uint64_t objnum; + spa_t *spa; + int n; + + buf[0] = '\0'; + if (dev->dd.d_dev->dv_type != DEVT_ZFS) + return (buf); + + spa = spa_find_by_guid(dev->pool_guid); + if (spa == NULL) { + printf("ZFS: can't find pool by guid\n"); + return (buf); + } + if (zfs_rlookup(spa, dev->root_guid, rootname)) { + printf("ZFS: can't find filesystem by guid\n"); + return (buf); + } + if (zfs_lookup_dataset(spa, rootname, &objnum)) { + printf("ZFS: can't find filesystem by name\n"); + return (buf); + } + + /* Set the environment. */ + snprintf(buf, sizeof (buf), "%" PRIu64, dev->pool_guid); + setenv("zfs-bootpool", buf, 1); + snprintf(buf, sizeof (buf), "%" PRIu64, spa->spa_boot_vdev->v_guid); + setenv("zfs-bootvdev", buf, 1); + snprintf(buf, sizeof (buf), "%s/%" PRIu64, spa->spa_name, objnum); + setenv("zfs-bootfs", buf, 1); + if (spa->spa_boot_vdev->v_phys_path != NULL) + setenv("bootpath", spa->spa_boot_vdev->v_phys_path, 1); + if (spa->spa_boot_vdev->v_devid != NULL) + setenv("diskdevid", spa->spa_boot_vdev->v_devid, 1); + + /* + * Build the command line string. Once our kernel will read + * the environment and we can stop caring about old kernels, + * we can remove this part. + */ + snprintf(buf, sizeof(buf), "zfs-bootfs=%s/%" PRIu64, spa->spa_name, + objnum); + n = strlen(buf); + if (spa->spa_boot_vdev->v_phys_path != NULL) { + snprintf(buf+n, sizeof (buf) - n, ",bootpath=\"%s\"", + spa->spa_boot_vdev->v_phys_path); + n = strlen(buf); + } + if (spa->spa_boot_vdev->v_devid != NULL) { + snprintf(buf+n, sizeof (buf) - n, ",diskdevid=\"%s\"", + spa->spa_boot_vdev->v_devid); + } + return (buf); +} + +char * +zfs_fmtdev(void *vdev) +{ + static char rootname[ZFS_MAXNAMELEN]; + static char buf[2 * ZFS_MAXNAMELEN + 8]; + struct zfs_devdesc *dev = (struct zfs_devdesc *)vdev; + spa_t *spa; + + buf[0] = '\0'; + if (dev->dd.d_dev->dv_type != DEVT_ZFS) + return (buf); + + if (dev->pool_guid == 0) { + spa = STAILQ_FIRST(&zfs_pools); + dev->pool_guid = spa->spa_guid; + } else + spa = spa_find_by_guid(dev->pool_guid); + if (spa == NULL) { + printf("ZFS: can't find pool by guid\n"); + return (buf); + } + if (dev->root_guid == 0 && zfs_get_root(spa, &dev->root_guid)) { + printf("ZFS: can't find root filesystem\n"); + return (buf); + } + if (zfs_rlookup(spa, dev->root_guid, rootname)) { + printf("ZFS: can't find filesystem by guid\n"); + return (buf); + } + + if (rootname[0] == '\0') + sprintf(buf, "%s:%s:", dev->dd.d_dev->dv_name, spa->spa_name); + else + sprintf(buf, "%s:%s/%s:", dev->dd.d_dev->dv_name, spa->spa_name, + rootname); + return (buf); +} + +int +zfs_list(const char *name) +{ + static char poolname[ZFS_MAXNAMELEN]; + uint64_t objid; + spa_t *spa; + const char *dsname; + int len; + int rv; + + len = strlen(name); + dsname = strchr(name, '/'); + if (dsname != NULL) { + len = dsname - name; + dsname++; + } else + dsname = ""; + memcpy(poolname, name, len); + poolname[len] = '\0'; + + spa = spa_find_by_name(poolname); + if (!spa) + return (ENXIO); + rv = zfs_lookup_dataset(spa, dsname, &objid); + if (rv != 0) + return (rv); + + return (zfs_list_dataset(spa, objid)); +} + +#ifdef __FreeBSD__ +void +init_zfs_bootenv(char *currdev) +{ + char *beroot; + + if (strlen(currdev) == 0) + return; + if(strncmp(currdev, "zfs:", 4) != 0) + return; + /* Remove the trailing : */ + currdev[strlen(currdev) - 1] = '\0'; + setenv("zfs_be_active", currdev, 1); + setenv("zfs_be_currpage", "1", 1); + /* Forward past zfs: */ + currdev = strchr(currdev, ':'); + currdev++; + /* Remove the last element (current bootenv) */ + beroot = strrchr(currdev, '/'); + if (beroot != NULL) + beroot[0] = '\0'; + beroot = currdev; + setenv("zfs_be_root", beroot, 1); +} + +int +zfs_bootenv(const char *name) +{ + static char poolname[ZFS_MAXNAMELEN], *dsname, *root; + char becount[4]; + uint64_t objid; + spa_t *spa; + int len, rv, pages, perpage, currpage; + + if (name == NULL) + return (EINVAL); + if ((root = getenv("zfs_be_root")) == NULL) + return (EINVAL); + + if (strcmp(name, root) != 0) { + if (setenv("zfs_be_root", name, 1) != 0) + return (ENOMEM); + } + + SLIST_INIT(&zfs_be_head); + zfs_env_count = 0; + len = strlen(name); + dsname = strchr(name, '/'); + if (dsname != NULL) { + len = dsname - name; + dsname++; + } else + dsname = ""; + memcpy(poolname, name, len); + poolname[len] = '\0'; + + spa = spa_find_by_name(poolname); + if (!spa) + return (ENXIO); + rv = zfs_lookup_dataset(spa, dsname, &objid); + if (rv != 0) + return (rv); + rv = zfs_callback_dataset(spa, objid, zfs_belist_add); + + /* Calculate and store the number of pages of BEs */ + perpage = (ZFS_BE_LAST - ZFS_BE_FIRST + 1); + pages = (zfs_env_count / perpage) + ((zfs_env_count % perpage) > 0 ? 1 : 0); + snprintf(becount, 4, "%d", pages); + if (setenv("zfs_be_pages", becount, 1) != 0) + return (ENOMEM); + + /* Roll over the page counter if it has exceeded the maximum */ + currpage = strtol(getenv("zfs_be_currpage"), NULL, 10); + if (currpage > pages) { + if (setenv("zfs_be_currpage", "1", 1) != 0) + return (ENOMEM); + } + + /* Populate the menu environment variables */ + zfs_set_env(); + + /* Clean up the SLIST of ZFS BEs */ + while (!SLIST_EMPTY(&zfs_be_head)) { + zfs_be = SLIST_FIRST(&zfs_be_head); + SLIST_REMOVE_HEAD(&zfs_be_head, entries); + free(zfs_be); + } + + return (rv); +} + +int +zfs_belist_add(const char *name, uint64_t value __unused) +{ + + /* Skip special datasets that start with a $ character */ + if (strncmp(name, "$", 1) == 0) { + return (0); + } + /* Add the boot environment to the head of the SLIST */ + zfs_be = malloc(sizeof(struct zfs_be_entry)); + if (zfs_be == NULL) { + return (ENOMEM); + } + zfs_be->name = name; + SLIST_INSERT_HEAD(&zfs_be_head, zfs_be, entries); + zfs_env_count++; + + return (0); +} + +int +zfs_set_env(void) +{ + char envname[32], envval[256]; + char *beroot, *pagenum; + int rv, page, ctr; + + beroot = getenv("zfs_be_root"); + if (beroot == NULL) { + return (1); + } + + pagenum = getenv("zfs_be_currpage"); + if (pagenum != NULL) { + page = strtol(pagenum, NULL, 10); + } else { + page = 1; + } + + ctr = 1; + rv = 0; + zfs_env_index = ZFS_BE_FIRST; + SLIST_FOREACH_SAFE(zfs_be, &zfs_be_head, entries, zfs_be_tmp) { + /* Skip to the requested page number */ + if (ctr <= ((ZFS_BE_LAST - ZFS_BE_FIRST + 1) * (page - 1))) { + ctr++; + continue; + } + + snprintf(envname, sizeof(envname), "bootenvmenu_caption[%d]", zfs_env_index); + snprintf(envval, sizeof(envval), "%s", zfs_be->name); + rv = setenv(envname, envval, 1); + if (rv != 0) { + break; + } + + snprintf(envname, sizeof(envname), "bootenvansi_caption[%d]", zfs_env_index); + rv = setenv(envname, envval, 1); + if (rv != 0){ + break; + } + + snprintf(envname, sizeof(envname), "bootenvmenu_command[%d]", zfs_env_index); + rv = setenv(envname, "set_bootenv", 1); + if (rv != 0){ + break; + } + + snprintf(envname, sizeof(envname), "bootenv_root[%d]", zfs_env_index); + snprintf(envval, sizeof(envval), "zfs:%s/%s", beroot, zfs_be->name); + rv = setenv(envname, envval, 1); + if (rv != 0){ + break; + } + + zfs_env_index++; + if (zfs_env_index > ZFS_BE_LAST) { + break; + } + + } + + for (; zfs_env_index <= ZFS_BE_LAST; zfs_env_index++) { + snprintf(envname, sizeof(envname), "bootenvmenu_caption[%d]", zfs_env_index); + (void)unsetenv(envname); + snprintf(envname, sizeof(envname), "bootenvansi_caption[%d]", zfs_env_index); + (void)unsetenv(envname); + snprintf(envname, sizeof(envname), "bootenvmenu_command[%d]", zfs_env_index); + (void)unsetenv(envname); + snprintf(envname, sizeof(envname), "bootenv_root[%d]", zfs_env_index); + (void)unsetenv(envname); + } + + return (rv); +} +#endif diff --git a/usr/src/boot/lib/libstand/zfs/zfsimpl.c b/usr/src/boot/lib/libstand/zfs/zfsimpl.c new file mode 100644 index 0000000000..b3edf4653a --- /dev/null +++ b/usr/src/boot/lib/libstand/zfs/zfsimpl.c @@ -0,0 +1,2571 @@ +/*- + * Copyright (c) 2007 Doug Rabson + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + */ + +#include <sys/cdefs.h> + +/* + * Stand-alone ZFS file reader. + */ + +#include <sys/stat.h> +#include <sys/stdint.h> + +#include "zfsimpl.h" +#include "zfssubr.c" + + +struct zfsmount { + const spa_t *spa; + objset_phys_t objset; + uint64_t rootobj; +}; + +/* + * List of all vdevs, chained through v_alllink. + */ +static vdev_list_t zfs_vdevs; + + /* + * List of ZFS features supported for read + */ +static const char *features_for_read[] = { + "org.illumos:lz4_compress", + "com.delphix:hole_birth", + "com.delphix:extensible_dataset", + "com.delphix:embedded_data", + "org.open-zfs:large_blocks", + "org.illumos:sha512", + "org.illumos:skein", + "org.illumos:edonr", + "org.zfsonlinux:large_dnode", + "com.joyent:multi_vdev_crash_dump", + NULL +}; + +/* + * List of all pools, chained through spa_link. + */ +static spa_list_t zfs_pools; + +static const dnode_phys_t *dnode_cache_obj; +static uint64_t dnode_cache_bn; +static char *dnode_cache_buf; +static char *zap_scratch; +static char *zfs_temp_buf, *zfs_temp_end, *zfs_temp_ptr; + +#define TEMP_SIZE (1024 * 1024) + +static int zio_read(const spa_t *spa, const blkptr_t *bp, void *buf); +static int zfs_get_root(const spa_t *spa, uint64_t *objid); +static int zfs_rlookup(const spa_t *spa, uint64_t objnum, char *result); +static int zap_lookup(const spa_t *spa, const dnode_phys_t *dnode, + const char *name, uint64_t integer_size, uint64_t num_integers, + void *value); + +static void +zfs_init(void) +{ + STAILQ_INIT(&zfs_vdevs); + STAILQ_INIT(&zfs_pools); + + zfs_temp_buf = malloc(TEMP_SIZE); + zfs_temp_end = zfs_temp_buf + TEMP_SIZE; + zfs_temp_ptr = zfs_temp_buf; + dnode_cache_buf = malloc(SPA_MAXBLOCKSIZE); + zap_scratch = malloc(SPA_MAXBLOCKSIZE); + + zfs_init_crc(); +} + +static void * +zfs_alloc(size_t size) +{ + char *ptr; + + if (zfs_temp_ptr + size > zfs_temp_end) { + printf("ZFS: out of temporary buffer space\n"); + for (;;) ; + } + ptr = zfs_temp_ptr; + zfs_temp_ptr += size; + + return (ptr); +} + +static void +zfs_free(void *ptr, size_t size) +{ + + zfs_temp_ptr -= size; + if (zfs_temp_ptr != ptr) { + printf("ZFS: zfs_alloc()/zfs_free() mismatch\n"); + for (;;) ; + } +} + +static int +xdr_int(const unsigned char **xdr, int *ip) +{ + *ip = ((*xdr)[0] << 24) + | ((*xdr)[1] << 16) + | ((*xdr)[2] << 8) + | ((*xdr)[3] << 0); + (*xdr) += 4; + return (0); +} + +static int +xdr_u_int(const unsigned char **xdr, u_int *ip) +{ + *ip = ((*xdr)[0] << 24) + | ((*xdr)[1] << 16) + | ((*xdr)[2] << 8) + | ((*xdr)[3] << 0); + (*xdr) += 4; + return (0); +} + +static int +xdr_uint64_t(const unsigned char **xdr, uint64_t *lp) +{ + u_int hi, lo; + + xdr_u_int(xdr, &hi); + xdr_u_int(xdr, &lo); + *lp = (((uint64_t) hi) << 32) | lo; + return (0); +} + +static int +nvlist_find(const unsigned char *nvlist, const char *name, int type, + int* elementsp, void *valuep) +{ + const unsigned char *p, *pair; + int junk; + int encoded_size, decoded_size; + + p = nvlist; + xdr_int(&p, &junk); + xdr_int(&p, &junk); + + pair = p; + xdr_int(&p, &encoded_size); + xdr_int(&p, &decoded_size); + while (encoded_size && decoded_size) { + int namelen, pairtype, elements; + const char *pairname; + + xdr_int(&p, &namelen); + pairname = (const char*) p; + p += roundup(namelen, 4); + xdr_int(&p, &pairtype); + + if (!memcmp(name, pairname, namelen) && type == pairtype) { + xdr_int(&p, &elements); + if (elementsp) + *elementsp = elements; + if (type == DATA_TYPE_UINT64) { + xdr_uint64_t(&p, (uint64_t *) valuep); + return (0); + } else if (type == DATA_TYPE_STRING) { + int len; + xdr_int(&p, &len); + (*(const char**) valuep) = (const char*) p; + return (0); + } else if (type == DATA_TYPE_NVLIST + || type == DATA_TYPE_NVLIST_ARRAY) { + (*(const unsigned char**) valuep) = + (const unsigned char*) p; + return (0); + } else { + return (EIO); + } + } else { + /* + * Not the pair we are looking for, skip to the next one. + */ + p = pair + encoded_size; + } + + pair = p; + xdr_int(&p, &encoded_size); + xdr_int(&p, &decoded_size); + } + + return (EIO); +} + +static int +nvlist_check_features_for_read(const unsigned char *nvlist) +{ + const unsigned char *p, *pair; + int junk; + int encoded_size, decoded_size; + int rc; + + rc = 0; + + p = nvlist; + xdr_int(&p, &junk); + xdr_int(&p, &junk); + + pair = p; + xdr_int(&p, &encoded_size); + xdr_int(&p, &decoded_size); + while (encoded_size && decoded_size) { + int namelen, pairtype; + const char *pairname; + int i, found; + + found = 0; + + xdr_int(&p, &namelen); + pairname = (const char*) p; + p += roundup(namelen, 4); + xdr_int(&p, &pairtype); + + for (i = 0; features_for_read[i] != NULL; i++) { + if (!memcmp(pairname, features_for_read[i], namelen)) { + found = 1; + break; + } + } + + if (!found) { + printf("ZFS: unsupported feature: %s\n", pairname); + rc = EIO; + } + + p = pair + encoded_size; + + pair = p; + xdr_int(&p, &encoded_size); + xdr_int(&p, &decoded_size); + } + + return (rc); +} + +/* + * Return the next nvlist in an nvlist array. + */ +static const unsigned char * +nvlist_next(const unsigned char *nvlist) +{ + const unsigned char *p, *pair; + int junk; + int encoded_size, decoded_size; + + p = nvlist; + xdr_int(&p, &junk); + xdr_int(&p, &junk); + + pair = p; + xdr_int(&p, &encoded_size); + xdr_int(&p, &decoded_size); + while (encoded_size && decoded_size) { + p = pair + encoded_size; + + pair = p; + xdr_int(&p, &encoded_size); + xdr_int(&p, &decoded_size); + } + + return p; +} + +#ifdef TEST + +static const unsigned char * +nvlist_print(const unsigned char *nvlist, unsigned int indent) +{ + static const char* typenames[] = { + "DATA_TYPE_UNKNOWN", + "DATA_TYPE_BOOLEAN", + "DATA_TYPE_BYTE", + "DATA_TYPE_INT16", + "DATA_TYPE_UINT16", + "DATA_TYPE_INT32", + "DATA_TYPE_UINT32", + "DATA_TYPE_INT64", + "DATA_TYPE_UINT64", + "DATA_TYPE_STRING", + "DATA_TYPE_BYTE_ARRAY", + "DATA_TYPE_INT16_ARRAY", + "DATA_TYPE_UINT16_ARRAY", + "DATA_TYPE_INT32_ARRAY", + "DATA_TYPE_UINT32_ARRAY", + "DATA_TYPE_INT64_ARRAY", + "DATA_TYPE_UINT64_ARRAY", + "DATA_TYPE_STRING_ARRAY", + "DATA_TYPE_HRTIME", + "DATA_TYPE_NVLIST", + "DATA_TYPE_NVLIST_ARRAY", + "DATA_TYPE_BOOLEAN_VALUE", + "DATA_TYPE_INT8", + "DATA_TYPE_UINT8", + "DATA_TYPE_BOOLEAN_ARRAY", + "DATA_TYPE_INT8_ARRAY", + "DATA_TYPE_UINT8_ARRAY" + }; + + unsigned int i, j; + const unsigned char *p, *pair; + int junk; + int encoded_size, decoded_size; + + p = nvlist; + xdr_int(&p, &junk); + xdr_int(&p, &junk); + + pair = p; + xdr_int(&p, &encoded_size); + xdr_int(&p, &decoded_size); + while (encoded_size && decoded_size) { + int namelen, pairtype, elements; + const char *pairname; + + xdr_int(&p, &namelen); + pairname = (const char*) p; + p += roundup(namelen, 4); + xdr_int(&p, &pairtype); + + for (i = 0; i < indent; i++) + printf(" "); + printf("%s %s", typenames[pairtype], pairname); + + xdr_int(&p, &elements); + switch (pairtype) { + case DATA_TYPE_UINT64: { + uint64_t val; + xdr_uint64_t(&p, &val); + printf(" = 0x%jx\n", (uintmax_t)val); + break; + } + + case DATA_TYPE_STRING: { + int len; + xdr_int(&p, &len); + printf(" = \"%s\"\n", p); + break; + } + + case DATA_TYPE_NVLIST: + printf("\n"); + nvlist_print(p, indent + 1); + break; + + case DATA_TYPE_NVLIST_ARRAY: + for (j = 0; j < elements; j++) { + printf("[%d]\n", j); + p = nvlist_print(p, indent + 1); + if (j != elements - 1) { + for (i = 0; i < indent; i++) + printf(" "); + printf("%s %s", typenames[pairtype], pairname); + } + } + break; + + default: + printf("\n"); + } + + p = pair + encoded_size; + + pair = p; + xdr_int(&p, &encoded_size); + xdr_int(&p, &decoded_size); + } + + return p; +} + +#endif + +static int +vdev_read_phys(vdev_t *vdev, const blkptr_t *bp, void *buf, + off_t offset, size_t size) +{ + size_t psize; + int rc; + + if (!vdev->v_phys_read) + return (EIO); + + if (bp) { + psize = BP_GET_PSIZE(bp); + } else { + psize = size; + } + + /*printf("ZFS: reading %zu bytes at 0x%jx to %p\n", psize, (uintmax_t)offset, buf);*/ + rc = vdev->v_phys_read(vdev, vdev->v_read_priv, offset, buf, psize); + if (rc) + return (rc); + if (bp && zio_checksum_verify(vdev->spa, bp, buf)) + return (EIO); + + return (0); +} + +static int +vdev_disk_read(vdev_t *vdev, const blkptr_t *bp, void *buf, + off_t offset, size_t bytes) +{ + + return (vdev_read_phys(vdev, bp, buf, + offset + VDEV_LABEL_START_SIZE, bytes)); +} + + +static int +vdev_mirror_read(vdev_t *vdev, const blkptr_t *bp, void *buf, + off_t offset, size_t bytes) +{ + vdev_t *kid; + int rc; + + rc = EIO; + STAILQ_FOREACH(kid, &vdev->v_children, v_childlink) { + if (kid->v_state != VDEV_STATE_HEALTHY) + continue; + rc = kid->v_read(kid, bp, buf, offset, bytes); + if (!rc) + return (0); + } + + return (rc); +} + +static int +vdev_replacing_read(vdev_t *vdev, const blkptr_t *bp, void *buf, + off_t offset, size_t bytes) +{ + vdev_t *kid; + + /* + * Here we should have two kids: + * First one which is the one we are replacing and we can trust + * only this one to have valid data, but it might not be present. + * Second one is that one we are replacing with. It is most likely + * healthy, but we can't trust it has needed data, so we won't use it. + */ + kid = STAILQ_FIRST(&vdev->v_children); + if (kid == NULL) + return (EIO); + if (kid->v_state != VDEV_STATE_HEALTHY) + return (EIO); + return (kid->v_read(kid, bp, buf, offset, bytes)); +} + +static vdev_t * +vdev_find(uint64_t guid) +{ + vdev_t *vdev; + + STAILQ_FOREACH(vdev, &zfs_vdevs, v_alllink) + if (vdev->v_guid == guid) + return (vdev); + + return (0); +} + +static vdev_t * +vdev_create(uint64_t guid, vdev_read_t *vdev_read) +{ + vdev_t *vdev; + + vdev = malloc(sizeof(vdev_t)); + memset(vdev, 0, sizeof(vdev_t)); + STAILQ_INIT(&vdev->v_children); + vdev->v_guid = guid; + vdev->v_state = VDEV_STATE_OFFLINE; + vdev->v_read = vdev_read; + vdev->v_phys_read = 0; + vdev->v_read_priv = 0; + STAILQ_INSERT_TAIL(&zfs_vdevs, vdev, v_alllink); + + return (vdev); +} + +static int +vdev_init_from_nvlist(const unsigned char *nvlist, vdev_t *pvdev, + vdev_t **vdevp, int is_newer) +{ + int rc; + uint64_t guid, id, ashift, nparity; + const char *type; + const char *path; + vdev_t *vdev, *kid; + const unsigned char *kids; + int nkids, i, is_new; + uint64_t is_offline, is_faulted, is_degraded, is_removed, isnt_present; + + if (nvlist_find(nvlist, ZPOOL_CONFIG_GUID, DATA_TYPE_UINT64, + NULL, &guid) || + nvlist_find(nvlist, ZPOOL_CONFIG_ID, DATA_TYPE_UINT64, NULL, &id) || + nvlist_find(nvlist, ZPOOL_CONFIG_TYPE, DATA_TYPE_STRING, + NULL, &type)) { + printf("ZFS: can't find vdev details\n"); + return (ENOENT); + } + + if (strcmp(type, VDEV_TYPE_MIRROR) + && strcmp(type, VDEV_TYPE_DISK) +#ifdef ZFS_TEST + && strcmp(type, VDEV_TYPE_FILE) +#endif + && strcmp(type, VDEV_TYPE_RAIDZ) + && strcmp(type, VDEV_TYPE_REPLACING)) { + printf("ZFS: can only boot from disk, mirror, raidz1, raidz2 and raidz3 vdevs\n"); + return (EIO); + } + + is_offline = is_removed = is_faulted = is_degraded = isnt_present = 0; + + nvlist_find(nvlist, ZPOOL_CONFIG_OFFLINE, DATA_TYPE_UINT64, NULL, + &is_offline); + nvlist_find(nvlist, ZPOOL_CONFIG_REMOVED, DATA_TYPE_UINT64, NULL, + &is_removed); + nvlist_find(nvlist, ZPOOL_CONFIG_FAULTED, DATA_TYPE_UINT64, NULL, + &is_faulted); + nvlist_find(nvlist, ZPOOL_CONFIG_DEGRADED, DATA_TYPE_UINT64, NULL, + &is_degraded); + nvlist_find(nvlist, ZPOOL_CONFIG_NOT_PRESENT, DATA_TYPE_UINT64, NULL, + &isnt_present); + + vdev = vdev_find(guid); + if (!vdev) { + is_new = 1; + + if (!strcmp(type, VDEV_TYPE_MIRROR)) + vdev = vdev_create(guid, vdev_mirror_read); + else if (!strcmp(type, VDEV_TYPE_RAIDZ)) + vdev = vdev_create(guid, vdev_raidz_read); + else if (!strcmp(type, VDEV_TYPE_REPLACING)) + vdev = vdev_create(guid, vdev_replacing_read); + else + vdev = vdev_create(guid, vdev_disk_read); + + vdev->v_id = id; + vdev->v_top = pvdev != NULL ? pvdev : vdev; + if (nvlist_find(nvlist, ZPOOL_CONFIG_ASHIFT, + DATA_TYPE_UINT64, NULL, &ashift) == 0) { + vdev->v_ashift = ashift; + } else { + vdev->v_ashift = 0; + } + if (nvlist_find(nvlist, ZPOOL_CONFIG_NPARITY, + DATA_TYPE_UINT64, NULL, &nparity) == 0) { + vdev->v_nparity = nparity; + } else { + vdev->v_nparity = 0; + } + if (nvlist_find(nvlist, ZPOOL_CONFIG_PATH, + DATA_TYPE_STRING, NULL, &path) == 0) { + if (strncmp(path, "/dev/dsk/", 9) == 0) + path += 9; + vdev->v_name = strdup(path); + if (nvlist_find(nvlist, ZPOOL_CONFIG_PHYS_PATH, + DATA_TYPE_STRING, NULL, &path) == 0) { + vdev->v_phys_path = strdup(path); + } else { + vdev->v_phys_path = NULL; + } + if (nvlist_find(nvlist, ZPOOL_CONFIG_DEVID, + DATA_TYPE_STRING, NULL, &path) == 0) { + vdev->v_devid = strdup(path); + } else { + vdev->v_devid = NULL; + } + } else { + if (!strcmp(type, "raidz")) { + if (vdev->v_nparity == 1) + vdev->v_name = "raidz1"; + else if (vdev->v_nparity == 2) + vdev->v_name = "raidz2"; + else if (vdev->v_nparity == 3) + vdev->v_name = "raidz3"; + else { + printf("ZFS: can only boot from disk, mirror, raidz1, raidz2 and raidz3 vdevs\n"); + return (EIO); + } + } else { + vdev->v_name = strdup(type); + } + } + } else { + is_new = 0; + } + + if (is_new || is_newer) { + /* + * This is either new vdev or we've already seen this vdev, + * but from an older vdev label, so let's refresh its state + * from the newer label. + */ + if (is_offline) + vdev->v_state = VDEV_STATE_OFFLINE; + else if (is_removed) + vdev->v_state = VDEV_STATE_REMOVED; + else if (is_faulted) + vdev->v_state = VDEV_STATE_FAULTED; + else if (is_degraded) + vdev->v_state = VDEV_STATE_DEGRADED; + else if (isnt_present) + vdev->v_state = VDEV_STATE_CANT_OPEN; + } + + rc = nvlist_find(nvlist, ZPOOL_CONFIG_CHILDREN, DATA_TYPE_NVLIST_ARRAY, + &nkids, &kids); + /* + * Its ok if we don't have any kids. + */ + if (rc == 0) { + vdev->v_nchildren = nkids; + for (i = 0; i < nkids; i++) { + rc = vdev_init_from_nvlist(kids, vdev, &kid, is_newer); + if (rc) + return (rc); + if (is_new) + STAILQ_INSERT_TAIL(&vdev->v_children, kid, + v_childlink); + kids = nvlist_next(kids); + } + } else { + vdev->v_nchildren = 0; + } + + if (vdevp) + *vdevp = vdev; + return (0); +} + +static void +vdev_set_state(vdev_t *vdev) +{ + vdev_t *kid; + int good_kids; + int bad_kids; + + /* + * A mirror or raidz is healthy if all its kids are healthy. A + * mirror is degraded if any of its kids is healthy; a raidz + * is degraded if at most nparity kids are offline. + */ + if (STAILQ_FIRST(&vdev->v_children)) { + good_kids = 0; + bad_kids = 0; + STAILQ_FOREACH(kid, &vdev->v_children, v_childlink) { + if (kid->v_state == VDEV_STATE_HEALTHY) + good_kids++; + else + bad_kids++; + } + if (bad_kids == 0) { + vdev->v_state = VDEV_STATE_HEALTHY; + } else { + if (vdev->v_read == vdev_mirror_read) { + if (good_kids) { + vdev->v_state = VDEV_STATE_DEGRADED; + } else { + vdev->v_state = VDEV_STATE_OFFLINE; + } + } else if (vdev->v_read == vdev_raidz_read) { + if (bad_kids > vdev->v_nparity) { + vdev->v_state = VDEV_STATE_OFFLINE; + } else { + vdev->v_state = VDEV_STATE_DEGRADED; + } + } + } + } +} + +static spa_t * +spa_find_by_guid(uint64_t guid) +{ + spa_t *spa; + + STAILQ_FOREACH(spa, &zfs_pools, spa_link) + if (spa->spa_guid == guid) + return (spa); + + return (0); +} + +static spa_t * +spa_find_by_name(const char *name) +{ + spa_t *spa; + + STAILQ_FOREACH(spa, &zfs_pools, spa_link) + if (!strcmp(spa->spa_name, name)) + return (spa); + + return (0); +} + +spa_t * +spa_get_primary(void) +{ + return (STAILQ_FIRST(&zfs_pools)); +} + +vdev_t * +spa_get_primary_vdev(const spa_t *spa) +{ + vdev_t *vdev; + vdev_t *kid; + + if (spa == NULL) + spa = spa_get_primary(); + if (spa == NULL) + return (NULL); + vdev = STAILQ_FIRST(&spa->spa_vdevs); + if (vdev == NULL) + return (NULL); + for (kid = STAILQ_FIRST(&vdev->v_children); kid != NULL; + kid = STAILQ_FIRST(&vdev->v_children)) + vdev = kid; + return (vdev); +} + +static spa_t * +spa_create(uint64_t guid, const char *name) +{ + spa_t *spa; + + if ((spa = malloc(sizeof(spa_t))) == NULL) + return (NULL); + memset(spa, 0, sizeof(spa_t)); + if ((spa->spa_name = strdup(name)) == NULL) { + free(spa); + return (NULL); + } + STAILQ_INIT(&spa->spa_vdevs); + spa->spa_guid = guid; + STAILQ_INSERT_TAIL(&zfs_pools, spa, spa_link); + + return (spa); +} + +static const char * +state_name(vdev_state_t state) +{ + static const char* names[] = { + "UNKNOWN", + "CLOSED", + "OFFLINE", + "REMOVED", + "CANT_OPEN", + "FAULTED", + "DEGRADED", + "ONLINE" + }; + return names[state]; +} + +static int +pager_printf(const char *fmt, ...) +{ + char line[80]; + va_list args; + + va_start(args, fmt); + vsnprintf(line, sizeof (line), fmt, args); + va_end(args); + return (pager_output(line)); +} + +#define STATUS_FORMAT " %s %s\n" + +static int +print_state(int indent, const char *name, vdev_state_t state) +{ + int i; + char buf[512]; + + buf[0] = 0; + for (i = 0; i < indent; i++) + strcat(buf, " "); + strcat(buf, name); + return (pager_printf(STATUS_FORMAT, buf, state_name(state))); +} + +static int +vdev_status(vdev_t *vdev, int indent) +{ + vdev_t *kid; + int ret; + ret = print_state(indent, vdev->v_name, vdev->v_state); + if (ret != 0) + return (ret); + + STAILQ_FOREACH(kid, &vdev->v_children, v_childlink) { + ret = vdev_status(kid, indent + 1); + if (ret != 0) + return (ret); + } + return (ret); +} + +static int +spa_status(spa_t *spa) +{ + static char bootfs[ZFS_MAXNAMELEN]; + uint64_t rootid; + vdev_t *vdev; + int good_kids, bad_kids, degraded_kids, ret; + vdev_state_t state; + + ret = pager_printf(" pool: %s\n", spa->spa_name); + if (ret != 0) + return (ret); + + if (zfs_get_root(spa, &rootid) == 0 && + zfs_rlookup(spa, rootid, bootfs) == 0) { + if (bootfs[0] == '\0') + ret = pager_printf("bootfs: %s\n", spa->spa_name); + else + ret = pager_printf("bootfs: %s/%s\n", spa->spa_name, + bootfs); + if (ret != 0) + return (ret); + } + ret = pager_printf("config:\n\n"); + if (ret != 0) + return (ret); + ret = pager_printf(STATUS_FORMAT, "NAME", "STATE"); + if (ret != 0) + return (ret); + + good_kids = 0; + degraded_kids = 0; + bad_kids = 0; + STAILQ_FOREACH(vdev, &spa->spa_vdevs, v_childlink) { + if (vdev->v_state == VDEV_STATE_HEALTHY) + good_kids++; + else if (vdev->v_state == VDEV_STATE_DEGRADED) + degraded_kids++; + else + bad_kids++; + } + + state = VDEV_STATE_CLOSED; + if (good_kids > 0 && (degraded_kids + bad_kids) == 0) + state = VDEV_STATE_HEALTHY; + else if ((good_kids + degraded_kids) > 0) + state = VDEV_STATE_DEGRADED; + + ret = print_state(0, spa->spa_name, state); + if (ret != 0) + return (ret); + STAILQ_FOREACH(vdev, &spa->spa_vdevs, v_childlink) { + ret = vdev_status(vdev, 1); + if (ret != 0) + return (ret); + } + return (ret); +} + +int +spa_all_status(void) +{ + spa_t *spa; + int first = 1, ret = 0; + + STAILQ_FOREACH(spa, &zfs_pools, spa_link) { + if (!first) { + ret = pager_printf("\n"); + if (ret != 0) + return (ret); + } + first = 0; + ret = spa_status(spa); + if (ret != 0) + return (ret); + } + return (ret); +} + +uint64_t +vdev_label_offset(uint64_t psize, int l, uint64_t offset) +{ + uint64_t label_offset; + + if (l < VDEV_LABELS / 2) + label_offset = 0; + else + label_offset = psize - VDEV_LABELS * sizeof (vdev_label_t); + + return (offset + l * sizeof (vdev_label_t) + label_offset); +} + +static int +vdev_probe(vdev_phys_read_t *phys_read, void *read_priv, spa_t **spap) +{ + vdev_t vtmp; + vdev_phys_t *vdev_label = (vdev_phys_t *) zap_scratch; + vdev_phys_t *tmp_label; + spa_t *spa; + vdev_t *vdev, *top_vdev, *pool_vdev; + off_t off; + blkptr_t bp; + const unsigned char *nvlist = NULL; + uint64_t val; + uint64_t guid; + uint64_t best_txg = 0; + uint64_t pool_txg, pool_guid; + uint64_t psize; + const char *pool_name; + const unsigned char *vdevs; + const unsigned char *features; + int i, l, rc, is_newer; + char *upbuf; + const struct uberblock *up; + + /* + * Load the vdev label and figure out which + * uberblock is most current. + */ + memset(&vtmp, 0, sizeof(vtmp)); + vtmp.v_phys_read = phys_read; + vtmp.v_read_priv = read_priv; + psize = P2ALIGN(ldi_get_size(read_priv), + (uint64_t)sizeof (vdev_label_t)); + + /* Test for minimum device size. */ + if (psize < SPA_MINDEVSIZE) + return (EIO); + + tmp_label = zfs_alloc(sizeof (vdev_phys_t)); + + for (l = 0; l < VDEV_LABELS; l++) { + off = vdev_label_offset(psize, l, + offsetof(vdev_label_t, vl_vdev_phys)); + + BP_ZERO(&bp); + BP_SET_LSIZE(&bp, sizeof(vdev_phys_t)); + BP_SET_PSIZE(&bp, sizeof(vdev_phys_t)); + BP_SET_CHECKSUM(&bp, ZIO_CHECKSUM_LABEL); + BP_SET_COMPRESS(&bp, ZIO_COMPRESS_OFF); + DVA_SET_OFFSET(BP_IDENTITY(&bp), off); + ZIO_SET_CHECKSUM(&bp.blk_cksum, off, 0, 0, 0); + + if (vdev_read_phys(&vtmp, &bp, tmp_label, off, 0)) + continue; + + if (tmp_label->vp_nvlist[0] != NV_ENCODE_XDR) + continue; + + nvlist = (const unsigned char *) tmp_label->vp_nvlist + 4; + if (nvlist_find(nvlist, ZPOOL_CONFIG_POOL_TXG, + DATA_TYPE_UINT64, NULL, &pool_txg) != 0) + continue; + + if (best_txg <= pool_txg) { + best_txg = pool_txg; + memcpy(vdev_label, tmp_label, sizeof (vdev_phys_t)); + } + } + + zfs_free(tmp_label, sizeof (vdev_phys_t)); + + if (best_txg == 0) + return (EIO); + + if (vdev_label->vp_nvlist[0] != NV_ENCODE_XDR) + return (EIO); + + nvlist = (const unsigned char *) vdev_label->vp_nvlist + 4; + + if (nvlist_find(nvlist, ZPOOL_CONFIG_VERSION, DATA_TYPE_UINT64, + NULL, &val) != 0) { + return (EIO); + } + + if (!SPA_VERSION_IS_SUPPORTED(val)) { + printf("ZFS: unsupported ZFS version %u (should be %u)\n", + (unsigned) val, (unsigned) SPA_VERSION); + return (EIO); + } + + /* Check ZFS features for read */ + if (nvlist_find(nvlist, ZPOOL_CONFIG_FEATURES_FOR_READ, + DATA_TYPE_NVLIST, NULL, &features) == 0 && + nvlist_check_features_for_read(features) != 0) { + return (EIO); + } + + if (nvlist_find(nvlist, ZPOOL_CONFIG_POOL_STATE, DATA_TYPE_UINT64, + NULL, &val) != 0) { + return (EIO); + } + + if (val == POOL_STATE_DESTROYED) { + /* We don't boot only from destroyed pools. */ + return (EIO); + } + + if (nvlist_find(nvlist, ZPOOL_CONFIG_POOL_TXG, DATA_TYPE_UINT64, + NULL, &pool_txg) != 0 || + nvlist_find(nvlist, ZPOOL_CONFIG_POOL_GUID, DATA_TYPE_UINT64, + NULL, &pool_guid) != 0 || + nvlist_find(nvlist, ZPOOL_CONFIG_POOL_NAME, DATA_TYPE_STRING, + NULL, &pool_name) != 0) { + /* + * Cache and spare devices end up here - just ignore + * them. + */ + /*printf("ZFS: can't find pool details\n");*/ + return (EIO); + } + + if (nvlist_find(nvlist, ZPOOL_CONFIG_IS_LOG, DATA_TYPE_UINT64, + NULL, &val) == 0 && val != 0) { + return (EIO); + } + + /* + * Create the pool if this is the first time we've seen it. + */ + spa = spa_find_by_guid(pool_guid); + if (spa == NULL) { + spa = spa_create(pool_guid, pool_name); + if (spa == NULL) + return (ENOMEM); + } + if (pool_txg > spa->spa_txg) { + spa->spa_txg = pool_txg; + is_newer = 1; + } else { + is_newer = 0; + } + + /* + * Get the vdev tree and create our in-core copy of it. + * If we already have a vdev with this guid, this must + * be some kind of alias (overlapping slices, dangerously dedicated + * disks etc). + */ + if (nvlist_find(nvlist, ZPOOL_CONFIG_GUID, DATA_TYPE_UINT64, + NULL, &guid) != 0) { + return (EIO); + } + vdev = vdev_find(guid); + if (vdev && vdev->v_phys_read) /* Has this vdev already been inited? */ + return (EIO); + + if (nvlist_find(nvlist, ZPOOL_CONFIG_VDEV_TREE, DATA_TYPE_NVLIST, + NULL, &vdevs)) { + return (EIO); + } + + rc = vdev_init_from_nvlist(vdevs, NULL, &top_vdev, is_newer); + if (rc != 0) + return (rc); + + /* + * Add the toplevel vdev to the pool if its not already there. + */ + STAILQ_FOREACH(pool_vdev, &spa->spa_vdevs, v_childlink) + if (top_vdev == pool_vdev) + break; + if (!pool_vdev && top_vdev) { + top_vdev->spa = spa; + STAILQ_INSERT_TAIL(&spa->spa_vdevs, top_vdev, v_childlink); + } + + /* + * We should already have created an incomplete vdev for this + * vdev. Find it and initialise it with our read proc. + */ + vdev = vdev_find(guid); + if (vdev) { + vdev->v_phys_read = phys_read; + vdev->v_read_priv = read_priv; + vdev->v_state = VDEV_STATE_HEALTHY; + } else { + printf("ZFS: inconsistent nvlist contents\n"); + return (EIO); + } + + /* Record boot vdev for spa. */ + if (is_newer == 1) + spa->spa_boot_vdev = vdev; + + /* + * Re-evaluate top-level vdev state. + */ + vdev_set_state(top_vdev); + + /* + * Ok, we are happy with the pool so far. Lets find + * the best uberblock and then we can actually access + * the contents of the pool. + */ + upbuf = zfs_alloc(VDEV_UBERBLOCK_SIZE(vdev)); + up = (const struct uberblock *)upbuf; + for (l = 0; l < VDEV_LABELS; l++) { + for (i = 0; i < VDEV_UBERBLOCK_COUNT(vdev); i++) { + off = vdev_label_offset(psize, l, + VDEV_UBERBLOCK_OFFSET(vdev, i)); + BP_ZERO(&bp); + DVA_SET_OFFSET(&bp.blk_dva[0], off); + BP_SET_LSIZE(&bp, VDEV_UBERBLOCK_SIZE(vdev)); + BP_SET_PSIZE(&bp, VDEV_UBERBLOCK_SIZE(vdev)); + BP_SET_CHECKSUM(&bp, ZIO_CHECKSUM_LABEL); + BP_SET_COMPRESS(&bp, ZIO_COMPRESS_OFF); + ZIO_SET_CHECKSUM(&bp.blk_cksum, off, 0, 0, 0); + + if (vdev_read_phys(vdev, &bp, upbuf, off, 0) != 0) + continue; + + if (up->ub_magic != UBERBLOCK_MAGIC) + continue; + if (up->ub_txg < spa->spa_txg) + continue; + if (up->ub_txg > spa->spa_uberblock.ub_txg || + (up->ub_txg == spa->spa_uberblock.ub_txg && + up->ub_timestamp > + spa->spa_uberblock.ub_timestamp)) { + spa->spa_uberblock = *up; + } + } + } + zfs_free(upbuf, VDEV_UBERBLOCK_SIZE(vdev)); + + vdev->spa = spa; + if (spap != NULL) + *spap = spa; + return (0); +} + +static int +ilog2(int n) +{ + int v; + + for (v = 0; v < 32; v++) + if (n == (1 << v)) + return v; + return -1; +} + +static int +zio_read_gang(const spa_t *spa, const blkptr_t *bp, void *buf) +{ + blkptr_t gbh_bp; + zio_gbh_phys_t zio_gb; + char *pbuf; + int i; + + /* Artificial BP for gang block header. */ + gbh_bp = *bp; + BP_SET_PSIZE(&gbh_bp, SPA_GANGBLOCKSIZE); + BP_SET_LSIZE(&gbh_bp, SPA_GANGBLOCKSIZE); + BP_SET_CHECKSUM(&gbh_bp, ZIO_CHECKSUM_GANG_HEADER); + BP_SET_COMPRESS(&gbh_bp, ZIO_COMPRESS_OFF); + for (i = 0; i < SPA_DVAS_PER_BP; i++) + DVA_SET_GANG(&gbh_bp.blk_dva[i], 0); + + /* Read gang header block using the artificial BP. */ + if (zio_read(spa, &gbh_bp, &zio_gb)) + return (EIO); + + pbuf = buf; + for (i = 0; i < SPA_GBH_NBLKPTRS; i++) { + blkptr_t *gbp = &zio_gb.zg_blkptr[i]; + + if (BP_IS_HOLE(gbp)) + continue; + if (zio_read(spa, gbp, pbuf)) + return (EIO); + pbuf += BP_GET_PSIZE(gbp); + } + + if (zio_checksum_verify(spa, bp, buf)) + return (EIO); + return (0); +} + +static int +zio_read(const spa_t *spa, const blkptr_t *bp, void *buf) +{ + int cpfunc = BP_GET_COMPRESS(bp); + uint64_t align, size; + void *pbuf; + int i, error; + + /* + * Process data embedded in block pointer + */ + if (BP_IS_EMBEDDED(bp)) { + ASSERT(BPE_GET_ETYPE(bp) == BP_EMBEDDED_TYPE_DATA); + + size = BPE_GET_PSIZE(bp); + ASSERT(size <= BPE_PAYLOAD_SIZE); + + if (cpfunc != ZIO_COMPRESS_OFF) + pbuf = zfs_alloc(size); + else + pbuf = buf; + + decode_embedded_bp_compressed(bp, pbuf); + error = 0; + + if (cpfunc != ZIO_COMPRESS_OFF) { + error = zio_decompress_data(cpfunc, pbuf, + size, buf, BP_GET_LSIZE(bp)); + zfs_free(pbuf, size); + } + if (error != 0) + printf("ZFS: i/o error - unable to decompress block pointer data, error %d\n", + error); + return (error); + } + + error = EIO; + + for (i = 0; i < SPA_DVAS_PER_BP; i++) { + const dva_t *dva = &bp->blk_dva[i]; + vdev_t *vdev; + int vdevid; + off_t offset; + + if (!dva->dva_word[0] && !dva->dva_word[1]) + continue; + + vdevid = DVA_GET_VDEV(dva); + offset = DVA_GET_OFFSET(dva); + STAILQ_FOREACH(vdev, &spa->spa_vdevs, v_childlink) { + if (vdev->v_id == vdevid) + break; + } + if (!vdev || !vdev->v_read) + continue; + + size = BP_GET_PSIZE(bp); + if (vdev->v_read == vdev_raidz_read) { + align = 1ULL << vdev->v_top->v_ashift; + if (P2PHASE(size, align) != 0) + size = P2ROUNDUP(size, align); + } + if (size != BP_GET_PSIZE(bp) || cpfunc != ZIO_COMPRESS_OFF) + pbuf = zfs_alloc(size); + else + pbuf = buf; + + if (DVA_GET_GANG(dva)) + error = zio_read_gang(spa, bp, pbuf); + else + error = vdev->v_read(vdev, bp, pbuf, offset, size); + if (error == 0) { + if (cpfunc != ZIO_COMPRESS_OFF) + error = zio_decompress_data(cpfunc, pbuf, + BP_GET_PSIZE(bp), buf, BP_GET_LSIZE(bp)); + else if (size != BP_GET_PSIZE(bp)) + bcopy(pbuf, buf, BP_GET_PSIZE(bp)); + } + if (buf != pbuf) + zfs_free(pbuf, size); + if (error == 0) + break; + } + if (error != 0) + printf("ZFS: i/o error - all block copies unavailable\n"); + return (error); +} + +static int +dnode_read(const spa_t *spa, const dnode_phys_t *dnode, off_t offset, void *buf, size_t buflen) +{ + int ibshift = dnode->dn_indblkshift - SPA_BLKPTRSHIFT; + int bsize = dnode->dn_datablkszsec << SPA_MINBLOCKSHIFT; + int nlevels = dnode->dn_nlevels; + int i, rc; + + if (bsize > SPA_MAXBLOCKSIZE) { + printf("ZFS: I/O error - blocks larger than %llu are not " + "supported\n", SPA_MAXBLOCKSIZE); + return (EIO); + } + + /* + * Note: bsize may not be a power of two here so we need to do an + * actual divide rather than a bitshift. + */ + while (buflen > 0) { + uint64_t bn = offset / bsize; + int boff = offset % bsize; + int ibn; + const blkptr_t *indbp; + blkptr_t bp; + + if (bn > dnode->dn_maxblkid) { + printf("warning: zfs bug: bn %llx > dn_maxblkid %llx\n", + (unsigned long long)bn, + (unsigned long long)dnode->dn_maxblkid); + /* + * zfs bug, will not return error + * return (EIO); + */ + } + + if (dnode == dnode_cache_obj && bn == dnode_cache_bn) + goto cached; + + indbp = dnode->dn_blkptr; + for (i = 0; i < nlevels; i++) { + /* + * Copy the bp from the indirect array so that + * we can re-use the scratch buffer for multi-level + * objects. + */ + ibn = bn >> ((nlevels - i - 1) * ibshift); + ibn &= ((1 << ibshift) - 1); + bp = indbp[ibn]; + if (BP_IS_HOLE(&bp)) { + memset(dnode_cache_buf, 0, bsize); + break; + } + rc = zio_read(spa, &bp, dnode_cache_buf); + if (rc) + return (rc); + indbp = (const blkptr_t *) dnode_cache_buf; + } + dnode_cache_obj = dnode; + dnode_cache_bn = bn; + cached: + + /* + * The buffer contains our data block. Copy what we + * need from it and loop. + */ + i = bsize - boff; + if (i > buflen) i = buflen; + memcpy(buf, &dnode_cache_buf[boff], i); + buf = ((char*) buf) + i; + offset += i; + buflen -= i; + } + + return (0); +} + +/* + * Lookup a value in a microzap directory. Assumes that the zap + * scratch buffer contains the directory contents. + */ +static int +mzap_lookup(const dnode_phys_t *dnode, const char *name, uint64_t *value) +{ + const mzap_phys_t *mz; + const mzap_ent_phys_t *mze; + size_t size; + int chunks, i; + + /* + * Microzap objects use exactly one block. Read the whole + * thing. + */ + size = dnode->dn_datablkszsec * 512; + + mz = (const mzap_phys_t *) zap_scratch; + chunks = size / MZAP_ENT_LEN - 1; + + for (i = 0; i < chunks; i++) { + mze = &mz->mz_chunk[i]; + if (!strcmp(mze->mze_name, name)) { + *value = mze->mze_value; + return (0); + } + } + + return (ENOENT); +} + +/* + * Compare a name with a zap leaf entry. Return non-zero if the name + * matches. + */ +static int +fzap_name_equal(const zap_leaf_t *zl, const zap_leaf_chunk_t *zc, const char *name) +{ + size_t namelen; + const zap_leaf_chunk_t *nc; + const char *p; + + namelen = zc->l_entry.le_name_numints; + + nc = &ZAP_LEAF_CHUNK(zl, zc->l_entry.le_name_chunk); + p = name; + while (namelen > 0) { + size_t len; + len = namelen; + if (len > ZAP_LEAF_ARRAY_BYTES) + len = ZAP_LEAF_ARRAY_BYTES; + if (memcmp(p, nc->l_array.la_array, len)) + return (0); + p += len; + namelen -= len; + nc = &ZAP_LEAF_CHUNK(zl, nc->l_array.la_next); + } + + return 1; +} + +/* + * Extract a uint64_t value from a zap leaf entry. + */ +static uint64_t +fzap_leaf_value(const zap_leaf_t *zl, const zap_leaf_chunk_t *zc) +{ + const zap_leaf_chunk_t *vc; + int i; + uint64_t value; + const uint8_t *p; + + vc = &ZAP_LEAF_CHUNK(zl, zc->l_entry.le_value_chunk); + for (i = 0, value = 0, p = vc->l_array.la_array; i < 8; i++) { + value = (value << 8) | p[i]; + } + + return value; +} + +static void +stv(int len, void *addr, uint64_t value) +{ + switch (len) { + case 1: + *(uint8_t *)addr = value; + return; + case 2: + *(uint16_t *)addr = value; + return; + case 4: + *(uint32_t *)addr = value; + return; + case 8: + *(uint64_t *)addr = value; + return; + } +} + +/* + * Extract a array from a zap leaf entry. + */ +static void +fzap_leaf_array(const zap_leaf_t *zl, const zap_leaf_chunk_t *zc, + uint64_t integer_size, uint64_t num_integers, void *buf) +{ + uint64_t array_int_len = zc->l_entry.le_value_intlen; + uint64_t value = 0; + uint64_t *u64 = buf; + char *p = buf; + int len = MIN(zc->l_entry.le_value_numints, num_integers); + int chunk = zc->l_entry.le_value_chunk; + int byten = 0; + + if (integer_size == 8 && len == 1) { + *u64 = fzap_leaf_value(zl, zc); + return; + } + + while (len > 0) { + struct zap_leaf_array *la = &ZAP_LEAF_CHUNK(zl, chunk).l_array; + int i; + + ASSERT3U(chunk, <, ZAP_LEAF_NUMCHUNKS(zl)); + for (i = 0; i < ZAP_LEAF_ARRAY_BYTES && len > 0; i++) { + value = (value << 8) | la->la_array[i]; + byten++; + if (byten == array_int_len) { + stv(integer_size, p, value); + byten = 0; + len--; + if (len == 0) + return; + p += integer_size; + } + } + chunk = la->la_next; + } +} + +static int +fzap_check_size(uint64_t integer_size, uint64_t num_integers) +{ + + switch (integer_size) { + case 1: + case 2: + case 4: + case 8: + break; + default: + return (EINVAL); + } + + if (integer_size * num_integers > ZAP_MAXVALUELEN) + return (E2BIG); + + return (0); +} + +/* + * Lookup a value in a fatzap directory. Assumes that the zap scratch + * buffer contains the directory header. + */ +static int +fzap_lookup(const spa_t *spa, const dnode_phys_t *dnode, const char *name, + uint64_t integer_size, uint64_t num_integers, void *value) +{ + int bsize = dnode->dn_datablkszsec << SPA_MINBLOCKSHIFT; + zap_phys_t zh = *(zap_phys_t *) zap_scratch; + fat_zap_t z; + uint64_t *ptrtbl; + uint64_t hash; + int rc; + + if (zh.zap_magic != ZAP_MAGIC) + return (EIO); + + if ((rc = fzap_check_size(integer_size, num_integers)) != 0) + return (rc); + + z.zap_block_shift = ilog2(bsize); + z.zap_phys = (zap_phys_t *) zap_scratch; + + /* + * Figure out where the pointer table is and read it in if necessary. + */ + if (zh.zap_ptrtbl.zt_blk) { + rc = dnode_read(spa, dnode, zh.zap_ptrtbl.zt_blk * bsize, + zap_scratch, bsize); + if (rc) + return (rc); + ptrtbl = (uint64_t *) zap_scratch; + } else { + ptrtbl = &ZAP_EMBEDDED_PTRTBL_ENT(&z, 0); + } + + hash = zap_hash(zh.zap_salt, name); + + zap_leaf_t zl; + zl.l_bs = z.zap_block_shift; + + off_t off = ptrtbl[hash >> (64 - zh.zap_ptrtbl.zt_shift)] << zl.l_bs; + zap_leaf_chunk_t *zc; + + rc = dnode_read(spa, dnode, off, zap_scratch, bsize); + if (rc) + return (rc); + + zl.l_phys = (zap_leaf_phys_t *) zap_scratch; + + /* + * Make sure this chunk matches our hash. + */ + if (zl.l_phys->l_hdr.lh_prefix_len > 0 + && zl.l_phys->l_hdr.lh_prefix + != hash >> (64 - zl.l_phys->l_hdr.lh_prefix_len)) + return (ENOENT); + + /* + * Hash within the chunk to find our entry. + */ + int shift = (64 - ZAP_LEAF_HASH_SHIFT(&zl) - zl.l_phys->l_hdr.lh_prefix_len); + int h = (hash >> shift) & ((1 << ZAP_LEAF_HASH_SHIFT(&zl)) - 1); + h = zl.l_phys->l_hash[h]; + if (h == 0xffff) + return (ENOENT); + zc = &ZAP_LEAF_CHUNK(&zl, h); + while (zc->l_entry.le_hash != hash) { + if (zc->l_entry.le_next == 0xffff) { + zc = 0; + break; + } + zc = &ZAP_LEAF_CHUNK(&zl, zc->l_entry.le_next); + } + if (fzap_name_equal(&zl, zc, name)) { + if (zc->l_entry.le_value_intlen > integer_size) + return (EINVAL); + + fzap_leaf_array(&zl, zc, integer_size, num_integers, value); + return (0); + } + + return (ENOENT); +} + +/* + * Lookup a name in a zap object and return its value as a uint64_t. + */ +static int +zap_lookup(const spa_t *spa, const dnode_phys_t *dnode, const char *name, + uint64_t integer_size, uint64_t num_integers, void *value) +{ + int rc; + uint64_t zap_type; + size_t size = dnode->dn_datablkszsec << SPA_MINBLOCKSHIFT; + + rc = dnode_read(spa, dnode, 0, zap_scratch, size); + if (rc) + return (rc); + + zap_type = *(uint64_t *) zap_scratch; + if (zap_type == ZBT_MICRO) + return mzap_lookup(dnode, name, value); + else if (zap_type == ZBT_HEADER) { + return fzap_lookup(spa, dnode, name, integer_size, + num_integers, value); + } + printf("ZFS: invalid zap_type=%d\n", (int)zap_type); + return (EIO); +} + +/* + * List a microzap directory. Assumes that the zap scratch buffer contains + * the directory contents. + */ +static int +mzap_list(const dnode_phys_t *dnode, int (*callback)(const char *, uint64_t)) +{ + const mzap_phys_t *mz; + const mzap_ent_phys_t *mze; + size_t size; + int chunks, i, rc; + + /* + * Microzap objects use exactly one block. Read the whole + * thing. + */ + size = dnode->dn_datablkszsec * 512; + mz = (const mzap_phys_t *) zap_scratch; + chunks = size / MZAP_ENT_LEN - 1; + + for (i = 0; i < chunks; i++) { + mze = &mz->mz_chunk[i]; + if (mze->mze_name[0]) { + rc = callback(mze->mze_name, mze->mze_value); + if (rc != 0) + return (rc); + } + } + + return (0); +} + +/* + * List a fatzap directory. Assumes that the zap scratch buffer contains + * the directory header. + */ +static int +fzap_list(const spa_t *spa, const dnode_phys_t *dnode, int (*callback)(const char *, uint64_t)) +{ + int bsize = dnode->dn_datablkszsec << SPA_MINBLOCKSHIFT; + zap_phys_t zh = *(zap_phys_t *) zap_scratch; + fat_zap_t z; + int i, j, rc; + + if (zh.zap_magic != ZAP_MAGIC) + return (EIO); + + z.zap_block_shift = ilog2(bsize); + z.zap_phys = (zap_phys_t *) zap_scratch; + + /* + * This assumes that the leaf blocks start at block 1. The + * documentation isn't exactly clear on this. + */ + zap_leaf_t zl; + zl.l_bs = z.zap_block_shift; + for (i = 0; i < zh.zap_num_leafs; i++) { + off_t off = (i + 1) << zl.l_bs; + char name[256], *p; + uint64_t value; + + if (dnode_read(spa, dnode, off, zap_scratch, bsize)) + return (EIO); + + zl.l_phys = (zap_leaf_phys_t *) zap_scratch; + + for (j = 0; j < ZAP_LEAF_NUMCHUNKS(&zl); j++) { + zap_leaf_chunk_t *zc, *nc; + int namelen; + + zc = &ZAP_LEAF_CHUNK(&zl, j); + if (zc->l_entry.le_type != ZAP_CHUNK_ENTRY) + continue; + namelen = zc->l_entry.le_name_numints; + if (namelen > sizeof(name)) + namelen = sizeof(name); + + /* + * Paste the name back together. + */ + nc = &ZAP_LEAF_CHUNK(&zl, zc->l_entry.le_name_chunk); + p = name; + while (namelen > 0) { + int len; + len = namelen; + if (len > ZAP_LEAF_ARRAY_BYTES) + len = ZAP_LEAF_ARRAY_BYTES; + memcpy(p, nc->l_array.la_array, len); + p += len; + namelen -= len; + nc = &ZAP_LEAF_CHUNK(&zl, nc->l_array.la_next); + } + + /* + * Assume the first eight bytes of the value are + * a uint64_t. + */ + value = fzap_leaf_value(&zl, zc); + + //printf("%s 0x%jx\n", name, (uintmax_t)value); + rc = callback((const char *)name, value); + if (rc != 0) + return (rc); + } + } + + return (0); +} + +static int zfs_printf(const char *name, uint64_t value __unused) +{ + + printf("%s\n", name); + + return (0); +} + +/* + * List a zap directory. + */ +static int +zap_list(const spa_t *spa, const dnode_phys_t *dnode) +{ + uint64_t zap_type; + size_t size = dnode->dn_datablkszsec * 512; + + if (dnode_read(spa, dnode, 0, zap_scratch, size)) + return (EIO); + + zap_type = *(uint64_t *) zap_scratch; + if (zap_type == ZBT_MICRO) + return mzap_list(dnode, zfs_printf); + else + return fzap_list(spa, dnode, zfs_printf); +} + +static int +objset_get_dnode(const spa_t *spa, const objset_phys_t *os, uint64_t objnum, dnode_phys_t *dnode) +{ + off_t offset; + + offset = objnum * sizeof(dnode_phys_t); + return dnode_read(spa, &os->os_meta_dnode, offset, + dnode, sizeof(dnode_phys_t)); +} + +static int +mzap_rlookup(const spa_t *spa, const dnode_phys_t *dnode, char *name, uint64_t value) +{ + const mzap_phys_t *mz; + const mzap_ent_phys_t *mze; + size_t size; + int chunks, i; + + /* + * Microzap objects use exactly one block. Read the whole + * thing. + */ + size = dnode->dn_datablkszsec * 512; + + mz = (const mzap_phys_t *) zap_scratch; + chunks = size / MZAP_ENT_LEN - 1; + + for (i = 0; i < chunks; i++) { + mze = &mz->mz_chunk[i]; + if (value == mze->mze_value) { + strcpy(name, mze->mze_name); + return (0); + } + } + + return (ENOENT); +} + +static void +fzap_name_copy(const zap_leaf_t *zl, const zap_leaf_chunk_t *zc, char *name) +{ + size_t namelen; + const zap_leaf_chunk_t *nc; + char *p; + + namelen = zc->l_entry.le_name_numints; + + nc = &ZAP_LEAF_CHUNK(zl, zc->l_entry.le_name_chunk); + p = name; + while (namelen > 0) { + size_t len; + len = namelen; + if (len > ZAP_LEAF_ARRAY_BYTES) + len = ZAP_LEAF_ARRAY_BYTES; + memcpy(p, nc->l_array.la_array, len); + p += len; + namelen -= len; + nc = &ZAP_LEAF_CHUNK(zl, nc->l_array.la_next); + } + + *p = '\0'; +} + +static int +fzap_rlookup(const spa_t *spa, const dnode_phys_t *dnode, char *name, uint64_t value) +{ + int bsize = dnode->dn_datablkszsec << SPA_MINBLOCKSHIFT; + zap_phys_t zh = *(zap_phys_t *) zap_scratch; + fat_zap_t z; + int i, j; + + if (zh.zap_magic != ZAP_MAGIC) + return (EIO); + + z.zap_block_shift = ilog2(bsize); + z.zap_phys = (zap_phys_t *) zap_scratch; + + /* + * This assumes that the leaf blocks start at block 1. The + * documentation isn't exactly clear on this. + */ + zap_leaf_t zl; + zl.l_bs = z.zap_block_shift; + for (i = 0; i < zh.zap_num_leafs; i++) { + off_t off = (i + 1) << zl.l_bs; + + if (dnode_read(spa, dnode, off, zap_scratch, bsize)) + return (EIO); + + zl.l_phys = (zap_leaf_phys_t *) zap_scratch; + + for (j = 0; j < ZAP_LEAF_NUMCHUNKS(&zl); j++) { + zap_leaf_chunk_t *zc; + + zc = &ZAP_LEAF_CHUNK(&zl, j); + if (zc->l_entry.le_type != ZAP_CHUNK_ENTRY) + continue; + if (zc->l_entry.le_value_intlen != 8 || + zc->l_entry.le_value_numints != 1) + continue; + + if (fzap_leaf_value(&zl, zc) == value) { + fzap_name_copy(&zl, zc, name); + return (0); + } + } + } + + return (ENOENT); +} + +static int +zap_rlookup(const spa_t *spa, const dnode_phys_t *dnode, char *name, uint64_t value) +{ + int rc; + uint64_t zap_type; + size_t size = dnode->dn_datablkszsec * 512; + + rc = dnode_read(spa, dnode, 0, zap_scratch, size); + if (rc) + return (rc); + + zap_type = *(uint64_t *) zap_scratch; + if (zap_type == ZBT_MICRO) + return mzap_rlookup(spa, dnode, name, value); + else + return fzap_rlookup(spa, dnode, name, value); +} + +static int +zfs_rlookup(const spa_t *spa, uint64_t objnum, char *result) +{ + char name[256]; + char component[256]; + uint64_t dir_obj, parent_obj, child_dir_zapobj; + dnode_phys_t child_dir_zap, dataset, dir, parent; + dsl_dir_phys_t *dd; + dsl_dataset_phys_t *ds; + char *p; + int len; + + p = &name[sizeof(name) - 1]; + *p = '\0'; + + if (objset_get_dnode(spa, &spa->spa_mos, objnum, &dataset)) { + printf("ZFS: can't find dataset %ju\n", (uintmax_t)objnum); + return (EIO); + } + ds = (dsl_dataset_phys_t *)&dataset.dn_bonus; + dir_obj = ds->ds_dir_obj; + + for (;;) { + if (objset_get_dnode(spa, &spa->spa_mos, dir_obj, &dir) != 0) + return (EIO); + dd = (dsl_dir_phys_t *)&dir.dn_bonus; + + /* Actual loop condition. */ + parent_obj = dd->dd_parent_obj; + if (parent_obj == 0) + break; + + if (objset_get_dnode(spa, &spa->spa_mos, parent_obj, &parent) != 0) + return (EIO); + dd = (dsl_dir_phys_t *)&parent.dn_bonus; + child_dir_zapobj = dd->dd_child_dir_zapobj; + if (objset_get_dnode(spa, &spa->spa_mos, child_dir_zapobj, &child_dir_zap) != 0) + return (EIO); + if (zap_rlookup(spa, &child_dir_zap, component, dir_obj) != 0) + return (EIO); + + len = strlen(component); + p -= len; + memcpy(p, component, len); + --p; + *p = '/'; + + /* Actual loop iteration. */ + dir_obj = parent_obj; + } + + if (*p != '\0') + ++p; + strcpy(result, p); + + return (0); +} + +static int +zfs_lookup_dataset(const spa_t *spa, const char *name, uint64_t *objnum) +{ + char element[256]; + uint64_t dir_obj, child_dir_zapobj; + dnode_phys_t child_dir_zap, dir; + dsl_dir_phys_t *dd; + const char *p, *q; + + if (objset_get_dnode(spa, &spa->spa_mos, DMU_POOL_DIRECTORY_OBJECT, &dir)) + return (EIO); + if (zap_lookup(spa, &dir, DMU_POOL_ROOT_DATASET, sizeof (dir_obj), + 1, &dir_obj)) + return (EIO); + + p = name; + for (;;) { + if (objset_get_dnode(spa, &spa->spa_mos, dir_obj, &dir)) + return (EIO); + dd = (dsl_dir_phys_t *)&dir.dn_bonus; + + while (*p == '/') + p++; + /* Actual loop condition #1. */ + if (*p == '\0') + break; + + q = strchr(p, '/'); + if (q) { + memcpy(element, p, q - p); + element[q - p] = '\0'; + p = q + 1; + } else { + strcpy(element, p); + p += strlen(p); + } + + child_dir_zapobj = dd->dd_child_dir_zapobj; + if (objset_get_dnode(spa, &spa->spa_mos, child_dir_zapobj, &child_dir_zap) != 0) + return (EIO); + + /* Actual loop condition #2. */ + if (zap_lookup(spa, &child_dir_zap, element, sizeof (dir_obj), + 1, &dir_obj) != 0) + return (ENOENT); + } + + *objnum = dd->dd_head_dataset_obj; + return (0); +} + +#pragma GCC diagnostic ignored "-Wstrict-aliasing" +static int +zfs_list_dataset(const spa_t *spa, uint64_t objnum/*, int pos, char *entry*/) +{ + uint64_t dir_obj, child_dir_zapobj; + dnode_phys_t child_dir_zap, dir, dataset; + dsl_dataset_phys_t *ds; + dsl_dir_phys_t *dd; + + if (objset_get_dnode(spa, &spa->spa_mos, objnum, &dataset)) { + printf("ZFS: can't find dataset %ju\n", (uintmax_t)objnum); + return (EIO); + } + ds = (dsl_dataset_phys_t *) &dataset.dn_bonus; + dir_obj = ds->ds_dir_obj; + + if (objset_get_dnode(spa, &spa->spa_mos, dir_obj, &dir)) { + printf("ZFS: can't find dirobj %ju\n", (uintmax_t)dir_obj); + return (EIO); + } + dd = (dsl_dir_phys_t *)&dir.dn_bonus; + + child_dir_zapobj = dd->dd_child_dir_zapobj; + if (objset_get_dnode(spa, &spa->spa_mos, child_dir_zapobj, &child_dir_zap) != 0) { + printf("ZFS: can't find child zap %ju\n", (uintmax_t)dir_obj); + return (EIO); + } + + return (zap_list(spa, &child_dir_zap) != 0); +} + +int +zfs_callback_dataset(const spa_t *spa, uint64_t objnum, int (*callback)(const char *, uint64_t)) +{ + uint64_t dir_obj, child_dir_zapobj, zap_type; + dnode_phys_t child_dir_zap, dir, dataset; + dsl_dataset_phys_t *ds; + dsl_dir_phys_t *dd; + int err; + + err = objset_get_dnode(spa, &spa->spa_mos, objnum, &dataset); + if (err != 0) { + printf("ZFS: can't find dataset %ju\n", (uintmax_t)objnum); + return (err); + } + ds = (dsl_dataset_phys_t *) &dataset.dn_bonus; + dir_obj = ds->ds_dir_obj; + + err = objset_get_dnode(spa, &spa->spa_mos, dir_obj, &dir); + if (err != 0) { + printf("ZFS: can't find dirobj %ju\n", (uintmax_t)dir_obj); + return (err); + } + dd = (dsl_dir_phys_t *)&dir.dn_bonus; + + child_dir_zapobj = dd->dd_child_dir_zapobj; + err = objset_get_dnode(spa, &spa->spa_mos, child_dir_zapobj, &child_dir_zap); + if (err != 0) { + printf("ZFS: can't find child zap %ju\n", (uintmax_t)dir_obj); + return (err); + } + + err = dnode_read(spa, &child_dir_zap, 0, zap_scratch, child_dir_zap.dn_datablkszsec * 512); + if (err != 0) + return (err); + + zap_type = *(uint64_t *) zap_scratch; + if (zap_type == ZBT_MICRO) + return mzap_list(&child_dir_zap, callback); + else + return fzap_list(spa, &child_dir_zap, callback); +} + +/* + * Find the object set given the object number of its dataset object + * and return its details in *objset + */ +static int +zfs_mount_dataset(const spa_t *spa, uint64_t objnum, objset_phys_t *objset) +{ + dnode_phys_t dataset; + dsl_dataset_phys_t *ds; + + if (objset_get_dnode(spa, &spa->spa_mos, objnum, &dataset)) { + printf("ZFS: can't find dataset %ju\n", (uintmax_t)objnum); + return (EIO); + } + + ds = (dsl_dataset_phys_t *) &dataset.dn_bonus; + if (zio_read(spa, &ds->ds_bp, objset)) { + printf("ZFS: can't read object set for dataset %ju\n", + (uintmax_t)objnum); + return (EIO); + } + + return (0); +} + +/* + * Find the object set pointed to by the BOOTFS property or the root + * dataset if there is none and return its details in *objset + */ +static int +zfs_get_root(const spa_t *spa, uint64_t *objid) +{ + dnode_phys_t dir, propdir; + uint64_t props, bootfs, root; + + *objid = 0; + + /* + * Start with the MOS directory object. + */ + if (objset_get_dnode(spa, &spa->spa_mos, DMU_POOL_DIRECTORY_OBJECT, &dir)) { + printf("ZFS: can't read MOS object directory\n"); + return (EIO); + } + + /* + * Lookup the pool_props and see if we can find a bootfs. + */ + if (zap_lookup(spa, &dir, DMU_POOL_PROPS, sizeof (props), 1, &props) == 0 + && objset_get_dnode(spa, &spa->spa_mos, props, &propdir) == 0 + && zap_lookup(spa, &propdir, "bootfs", sizeof (bootfs), 1, &bootfs) == 0 + && bootfs != 0) + { + *objid = bootfs; + return (0); + } + /* + * Lookup the root dataset directory + */ + if (zap_lookup(spa, &dir, DMU_POOL_ROOT_DATASET, sizeof (root), 1, &root) + || objset_get_dnode(spa, &spa->spa_mos, root, &dir)) { + printf("ZFS: can't find root dsl_dir\n"); + return (EIO); + } + + /* + * Use the information from the dataset directory's bonus buffer + * to find the dataset object and from that the object set itself. + */ + dsl_dir_phys_t *dd = (dsl_dir_phys_t *) &dir.dn_bonus; + *objid = dd->dd_head_dataset_obj; + return (0); +} + +static int +zfs_mount(const spa_t *spa, uint64_t rootobj, struct zfsmount *mnt) +{ + + mnt->spa = spa; + + /* + * Find the root object set if not explicitly provided + */ + if (rootobj == 0 && zfs_get_root(spa, &rootobj)) { + printf("ZFS: can't find root filesystem\n"); + return (EIO); + } + + if (zfs_mount_dataset(spa, rootobj, &mnt->objset)) { + printf("ZFS: can't open root filesystem\n"); + return (EIO); + } + + mnt->rootobj = rootobj; + + return (0); +} + +/* + * callback function for feature name checks. + */ +static int +check_feature(const char *name, uint64_t value) +{ + int i; + + if (value == 0) + return (0); + if (name[0] == '\0') + return (0); + + for (i = 0; features_for_read[i] != NULL; i++) { + if (strcmp(name, features_for_read[i]) == 0) + return (0); + } + printf("ZFS: unsupported feature: %s\n", name); + return (EIO); +} + +/* + * Checks whether the MOS features that are active are supported. + */ +static int +check_mos_features(const spa_t *spa) +{ + dnode_phys_t dir; + uint64_t objnum, zap_type; + size_t size; + int rc; + + if ((rc = objset_get_dnode(spa, &spa->spa_mos, DMU_OT_OBJECT_DIRECTORY, + &dir)) != 0) + return (rc); + if ((rc = zap_lookup(spa, &dir, DMU_POOL_FEATURES_FOR_READ, + sizeof (objnum), 1, &objnum)) != 0) { + /* + * It is older pool without features. As we have already + * tested the label, just return without raising the error. + */ + if (rc == ENOENT) + rc = 0; + return (rc); + } + + if ((rc = objset_get_dnode(spa, &spa->spa_mos, objnum, &dir)) != 0) + return (rc); + + if (dir.dn_type != DMU_OTN_ZAP_METADATA) + return (EIO); + + size = dir.dn_datablkszsec * 512; + if (dnode_read(spa, &dir, 0, zap_scratch, size)) + return (EIO); + + zap_type = *(uint64_t *) zap_scratch; + if (zap_type == ZBT_MICRO) + rc = mzap_list(&dir, check_feature); + else + rc = fzap_list(spa, &dir, check_feature); + + return (rc); +} + +static int +zfs_spa_init(spa_t *spa) +{ + dnode_phys_t dir; + int rc; + + if (zio_read(spa, &spa->spa_uberblock.ub_rootbp, &spa->spa_mos)) { + printf("ZFS: can't read MOS of pool %s\n", spa->spa_name); + return (EIO); + } + if (spa->spa_mos.os_type != DMU_OST_META) { + printf("ZFS: corrupted MOS of pool %s\n", spa->spa_name); + return (EIO); + } + + if (objset_get_dnode(spa, &spa->spa_mos, DMU_POOL_DIRECTORY_OBJECT, + &dir)) { + printf("ZFS: failed to read pool %s directory object\n", + spa->spa_name); + return (EIO); + } + /* this is allowed to fail, older pools do not have salt */ + rc = zap_lookup(spa, &dir, DMU_POOL_CHECKSUM_SALT, 1, + sizeof (spa->spa_cksum_salt.zcs_bytes), + spa->spa_cksum_salt.zcs_bytes); + + rc = check_mos_features(spa); + if (rc != 0) { + printf("ZFS: pool %s is not supported\n", spa->spa_name); + } + + return (rc); +} + +static int +zfs_dnode_stat(const spa_t *spa, dnode_phys_t *dn, struct stat *sb) +{ + + if (dn->dn_bonustype != DMU_OT_SA) { + znode_phys_t *zp = (znode_phys_t *)dn->dn_bonus; + + sb->st_mode = zp->zp_mode; + sb->st_uid = zp->zp_uid; + sb->st_gid = zp->zp_gid; + sb->st_size = zp->zp_size; + } else { + sa_hdr_phys_t *sahdrp; + int hdrsize; + size_t size = 0; + void *buf = NULL; + + if (dn->dn_bonuslen != 0) + sahdrp = (sa_hdr_phys_t *)DN_BONUS(dn); + else { + if ((dn->dn_flags & DNODE_FLAG_SPILL_BLKPTR) != 0) { + blkptr_t *bp = DN_SPILL_BLKPTR(dn); + int error; + + size = BP_GET_LSIZE(bp); + buf = zfs_alloc(size); + error = zio_read(spa, bp, buf); + if (error != 0) { + zfs_free(buf, size); + return (error); + } + sahdrp = buf; + } else { + return (EIO); + } + } + hdrsize = SA_HDR_SIZE(sahdrp); + sb->st_mode = *(uint64_t *)((char *)sahdrp + hdrsize + + SA_MODE_OFFSET); + sb->st_uid = *(uint64_t *)((char *)sahdrp + hdrsize + + SA_UID_OFFSET); + sb->st_gid = *(uint64_t *)((char *)sahdrp + hdrsize + + SA_GID_OFFSET); + sb->st_size = *(uint64_t *)((char *)sahdrp + hdrsize + + SA_SIZE_OFFSET); + if (buf != NULL) + zfs_free(buf, size); + } + + return (0); +} + +static int +zfs_dnode_readlink(const spa_t *spa, dnode_phys_t *dn, char *path, size_t psize) +{ + int rc = 0; + + if (dn->dn_bonustype == DMU_OT_SA) { + sa_hdr_phys_t *sahdrp = NULL; + size_t size = 0; + void *buf = NULL; + int hdrsize; + char *p; + + if (dn->dn_bonuslen != 0) + sahdrp = (sa_hdr_phys_t *)DN_BONUS(dn); + else { + blkptr_t *bp; + + if ((dn->dn_flags & DNODE_FLAG_SPILL_BLKPTR) == 0) + return (EIO); + bp = DN_SPILL_BLKPTR(dn); + + size = BP_GET_LSIZE(bp); + buf = zfs_alloc(size); + rc = zio_read(spa, bp, buf); + if (rc != 0) { + zfs_free(buf, size); + return (rc); + } + sahdrp = buf; + } + hdrsize = SA_HDR_SIZE(sahdrp); + p = (char *)((uintptr_t)sahdrp + hdrsize + SA_SYMLINK_OFFSET); + memcpy(path, p, psize); + if (buf != NULL) + zfs_free(buf, size); + return (0); + } + /* + * Second test is purely to silence bogus compiler + * warning about accessing past the end of dn_bonus. + */ + if (psize + sizeof(znode_phys_t) <= dn->dn_bonuslen && + sizeof(znode_phys_t) <= sizeof(dn->dn_bonus)) { + memcpy(path, &dn->dn_bonus[sizeof(znode_phys_t)], psize); + } else { + rc = dnode_read(spa, dn, 0, path, psize); + } + return (rc); +} + +struct obj_list { + uint64_t objnum; + STAILQ_ENTRY(obj_list) entry; +}; + +/* + * Lookup a file and return its dnode. + */ +static int +zfs_lookup(const struct zfsmount *mnt, const char *upath, dnode_phys_t *dnode) +{ + int rc; + uint64_t objnum; + const spa_t *spa; + dnode_phys_t dn; + const char *p, *q; + char element[256]; + char path[1024]; + int symlinks_followed = 0; + struct stat sb; + struct obj_list *entry, *tentry; + STAILQ_HEAD(, obj_list) on_cache = STAILQ_HEAD_INITIALIZER(on_cache); + + spa = mnt->spa; + if (mnt->objset.os_type != DMU_OST_ZFS) { + printf("ZFS: unexpected object set type %ju\n", + (uintmax_t)mnt->objset.os_type); + return (EIO); + } + + if ((entry = malloc(sizeof(struct obj_list))) == NULL) + return (ENOMEM); + + /* + * Get the root directory dnode. + */ + rc = objset_get_dnode(spa, &mnt->objset, MASTER_NODE_OBJ, &dn); + if (rc) { + free(entry); + return (rc); + } + + rc = zap_lookup(spa, &dn, ZFS_ROOT_OBJ, sizeof(objnum), 1, &objnum); + if (rc) { + free(entry); + return (rc); + } + entry->objnum = objnum; + STAILQ_INSERT_HEAD(&on_cache, entry, entry); + + rc = objset_get_dnode(spa, &mnt->objset, objnum, &dn); + if (rc != 0) + goto done; + + p = upath; + while (p && *p) { + rc = objset_get_dnode(spa, &mnt->objset, objnum, &dn); + if (rc != 0) + goto done; + + while (*p == '/') + p++; + if (*p == '\0') + break; + q = p; + while (*q != '\0' && *q != '/') + q++; + + /* skip dot */ + if (p + 1 == q && p[0] == '.') { + p++; + continue; + } + /* double dot */ + if (p + 2 == q && p[0] == '.' && p[1] == '.') { + p += 2; + if (STAILQ_FIRST(&on_cache) == + STAILQ_LAST(&on_cache, obj_list, entry)) { + rc = ENOENT; + goto done; + } + entry = STAILQ_FIRST(&on_cache); + STAILQ_REMOVE_HEAD(&on_cache, entry); + free(entry); + objnum = (STAILQ_FIRST(&on_cache))->objnum; + continue; + } + if (q - p + 1 > sizeof(element)) { + rc = ENAMETOOLONG; + goto done; + } + memcpy(element, p, q - p); + element[q - p] = 0; + p = q; + + if ((rc = zfs_dnode_stat(spa, &dn, &sb)) != 0) + goto done; + if (!S_ISDIR(sb.st_mode)) { + rc = ENOTDIR; + goto done; + } + + rc = zap_lookup(spa, &dn, element, sizeof(objnum), 1, &objnum); + if (rc) + goto done; + objnum = ZFS_DIRENT_OBJ(objnum); + + if ((entry = malloc(sizeof(struct obj_list))) == NULL) { + rc = ENOMEM; + goto done; + } + entry->objnum = objnum; + STAILQ_INSERT_HEAD(&on_cache, entry, entry); + rc = objset_get_dnode(spa, &mnt->objset, objnum, &dn); + if (rc) + goto done; + + /* + * Check for symlink. + */ + rc = zfs_dnode_stat(spa, &dn, &sb); + if (rc) + goto done; + if (S_ISLNK(sb.st_mode)) { + if (symlinks_followed > 10) { + rc = EMLINK; + goto done; + } + symlinks_followed++; + + /* + * Read the link value and copy the tail of our + * current path onto the end. + */ + if (sb.st_size + strlen(p) + 1 > sizeof(path)) { + rc = ENAMETOOLONG; + goto done; + } + strcpy(&path[sb.st_size], p); + + rc = zfs_dnode_readlink(spa, &dn, path, sb.st_size); + if (rc != 0) + goto done; + + /* + * Restart with the new path, starting either at + * the root or at the parent depending whether or + * not the link is relative. + */ + p = path; + if (*p == '/') { + while (STAILQ_FIRST(&on_cache) != + STAILQ_LAST(&on_cache, obj_list, entry)) { + entry = STAILQ_FIRST(&on_cache); + STAILQ_REMOVE_HEAD(&on_cache, entry); + free(entry); + } + } else { + entry = STAILQ_FIRST(&on_cache); + STAILQ_REMOVE_HEAD(&on_cache, entry); + free(entry); + } + objnum = (STAILQ_FIRST(&on_cache))->objnum; + } + } + + *dnode = dn; +done: + STAILQ_FOREACH_SAFE(entry, &on_cache, entry, tentry) + free(entry); + return (rc); +} |