upstream/illumos/illumos-gate: comparison usr/src/lib/libzfs/common/libzfs

equal deleted inserted replaced

-:54d99ec6d12d
+:5cee47eddab6
 {
 	zfs_cmd_t zc = { 0 };
 	(void) strlcpy(zc.zc_name, zhp->zpool_name, sizeof (zc.zc_name));
 	if (ioctl(zhp->zpool_hdl->libzfs_fd, ZFS_IOC_OBJSET_STATS, &zc) != 0 ||
-	    zc.zc_root[0] == '\0')
+	    zc.zc_value[0] == '\0')
 		return (-1);
-	(void) strlcpy(buf, zc.zc_root, buflen);
+	(void) strlcpy(buf, zc.zc_value, buflen);
 	return (0);
 }
 /*
 int
 zpool_create(libzfs_handle_t *hdl, const char *pool, nvlist_t *nvroot,
 const char *altroot)
 {
 	zfs_cmd_t zc = { 0 };
-	char *packed;
-	size_t len;
 	char msg[1024];
 	(void) snprintf(msg, sizeof (msg), dgettext(TEXT_DOMAIN,
 	    "cannot create '%s'"), pool);
 	if (altroot != NULL && altroot[0] != '/')
 		return (zfs_error(hdl, EZFS_BADPATH,
 		    dgettext(TEXT_DOMAIN, "bad alternate root '%s'"), altroot));
-	if (nvlist_size(nvroot, &len, NV_ENCODE_NATIVE) != 0)
+	if (zcmd_write_src_nvlist(hdl, &zc, nvroot, NULL) != 0)
-		return (no_memory(hdl));
-	if ((packed = zfs_alloc(hdl, len)) == NULL)
 		return (-1);
-	if (nvlist_pack(nvroot, &packed, &len,
-	    NV_ENCODE_NATIVE, 0) != 0) {
-		free(packed);
-		return (no_memory(hdl));
-	}
 	(void) strlcpy(zc.zc_name, pool, sizeof (zc.zc_name));
-	zc.zc_config_src = (uint64_t)(uintptr_t)packed;
-	zc.zc_config_src_size = len;
 	if (altroot != NULL)
-		(void) strlcpy(zc.zc_root, altroot, sizeof (zc.zc_root));
+		(void) strlcpy(zc.zc_value, altroot, sizeof (zc.zc_value));
 	if (ioctl(hdl->libzfs_fd, ZFS_IOC_POOL_CREATE, &zc) != 0) {
-		free(packed);
+		zcmd_free_nvlists(&zc);
 		switch (errno) {
 		case EBUSY:
 			/*
 			 * This can happen if the user has specified the same
 		default:
 			return (zpool_standard_error(hdl, errno, msg));
 		}
 	}
-	free(packed);
+	zcmd_free_nvlists(&zc);
 	/*
 	 * If this is an alternate root pool, then we automatically set the
-	 * moutnpoint of the root dataset to be '/'.
+	 * mountpoint of the root dataset to be '/'.
 	 */
 	if (altroot != NULL) {
 		zfs_handle_t *zhp;
 		verify((zhp = zfs_open(hdl, pool, ZFS_TYPE_ANY)) != NULL);
-		verify(zfs_prop_set(zhp, ZFS_PROP_MOUNTPOINT, "/") == 0);
+		verify(zfs_prop_set(zhp, zfs_prop_to_name(ZFS_PROP_MOUNTPOINT),
+		    "/") == 0);
 		zfs_close(zhp);
 	}
 	return (0);
 * necessary verification to ensure that the vdev specification is well-formed.
 */
 int
 zpool_add(zpool_handle_t *zhp, nvlist_t *nvroot)
 {
-	char *packed;
+	zfs_cmd_t zc = { 0 };
-	size_t len;
-	zfs_cmd_t zc;
 	int ret;
 	libzfs_handle_t *hdl = zhp->zpool_hdl;
 	char msg[1024];
 	nvlist_t **spares;
 	uint_t nspares;
 		zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, "pool must be "
 		    "upgraded to add hot spares"));
 		return (zfs_error(hdl, EZFS_BADVERSION, msg));
 	}
-	verify(nvlist_size(nvroot, &len, NV_ENCODE_NATIVE) == 0);
+	if (zcmd_write_src_nvlist(hdl, &zc, nvroot, NULL) != 0)
-	if ((packed = zfs_alloc(zhp->zpool_hdl, len)) == NULL)
 		return (-1);
-	verify(nvlist_pack(nvroot, &packed, &len, NV_ENCODE_NATIVE, 0) == 0);
 	(void) strlcpy(zc.zc_name, zhp->zpool_name, sizeof (zc.zc_name));
-	zc.zc_config_src = (uint64_t)(uintptr_t)packed;
-	zc.zc_config_src_size = len;
 	if (ioctl(zhp->zpool_hdl->libzfs_fd, ZFS_IOC_VDEV_ADD, &zc) != 0) {
 		switch (errno) {
 		case EBUSY:
 			/*
 		ret = -1;
 	} else {
 		ret = 0;
 	}
-	free(packed);
+	zcmd_free_nvlists(&zc);
 	return (ret);
 }
 /*
 */
 int
 zpool_import(libzfs_handle_t *hdl, nvlist_t *config, const char *newname,
 const char *altroot)
 {
-	zfs_cmd_t zc;
+	zfs_cmd_t zc = { 0 };
-	char *packed;
-	size_t len;
 	char *thename;
 	char *origname;
 	int ret;
 	verify(nvlist_lookup_string(config, ZPOOL_CONFIG_POOL_NAME,
 		    altroot));
 	(void) strlcpy(zc.zc_name, thename, sizeof (zc.zc_name));
 	if (altroot != NULL)
-		(void) strlcpy(zc.zc_root, altroot, sizeof (zc.zc_root));
+		(void) strlcpy(zc.zc_value, altroot, sizeof (zc.zc_value));
 	else
-		zc.zc_root[0] = '\0';
+		zc.zc_value[0] = '\0';
 	verify(nvlist_lookup_uint64(config, ZPOOL_CONFIG_POOL_GUID,
 	    &zc.zc_guid) == 0);
-	verify(nvlist_size(config, &len, NV_ENCODE_NATIVE) == 0);
+	if (zcmd_write_src_nvlist(hdl, &zc, config, NULL) != 0)
-	if ((packed = zfs_alloc(hdl, len)) == NULL)
 		return (-1);
-	verify(nvlist_pack(config, &packed, &len, NV_ENCODE_NATIVE, 0) == 0);
-	zc.zc_config_src = (uint64_t)(uintptr_t)packed;
-	zc.zc_config_src_size = len;
 	ret = 0;
 	if (ioctl(hdl->libzfs_fd, ZFS_IOC_POOL_IMPORT, &zc) != 0) {
 		char desc[1024];
 		if (newname == NULL)
 			ret = zpool_create_zvol_links(zhp);
 			zpool_close(zhp);
 		}
 	}
-	free(packed);
+	zcmd_free_nvlists(&zc);
 	return (ret);
 }
 /*
 * Scrub the pool.
 zpool_vdev_attach(zpool_handle_t *zhp,
 const char *old_disk, const char *new_disk, nvlist_t *nvroot, int replacing)
 {
 	zfs_cmd_t zc = { 0 };
 	char msg[1024];
-	char *packed;
 	int ret;
-	size_t len;
 	nvlist_t *tgt;
 	boolean_t avail_spare;
 	uint64_t val;
 	char *path;
 	nvlist_t **child;
 		zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
 		    "device has already been replaced with a spare"));
 		return (zfs_error(hdl, EZFS_BADTARGET, msg));
 	}
-	verify(nvlist_size(nvroot, &len, NV_ENCODE_NATIVE) == 0);
+	if (zcmd_write_src_nvlist(hdl, &zc, nvroot, NULL) != 0)
-	if ((packed = zfs_alloc(zhp->zpool_hdl, len)) == NULL)
 		return (-1);
-	verify(nvlist_pack(nvroot, &packed, &len, NV_ENCODE_NATIVE, 0) == 0);
-	zc.zc_config_src = (uint64_t)(uintptr_t)packed;
-	zc.zc_config_src_size = len;
 	ret = ioctl(zhp->zpool_hdl->libzfs_fd, ZFS_IOC_VDEV_ATTACH, &zc);
-	free(packed);
+	zcmd_free_nvlists(&zc);
 	if (ret == 0)
 		return (0);
 	switch (errno) {
 	libzfs_handle_t *hdl = zhp->zpool_hdl;
 	if (path)
 		(void) snprintf(msg, sizeof (msg),
 		    dgettext(TEXT_DOMAIN, "cannot clear errors for %s"),
-		    zc.zc_prop_value);
+		    path);
 	else
 		(void) snprintf(msg, sizeof (msg),
 		    dgettext(TEXT_DOMAIN, "cannot clear errors for %s"),
 		    zhp->zpool_name);
 	/*
 	 * We check for volblocksize intead of ZFS_TYPE_VOLUME so that we
 	 * correctly handle snapshots of volumes.
 	 */
-	if (zhp->zfs_volblocksize != 0) {
+	if (ZFS_IS_VOLUME(zhp)) {
 		if (linktype)
 			ret = zvol_create_link(zhp->zfs_hdl, zhp->zfs_name);
 		else
 			ret = zvol_remove_link(zhp->zfs_hdl, zhp->zfs_name);
 	}
 set_path(zpool_handle_t *zhp, nvlist_t *nv, const char *path)
 {
 	zfs_cmd_t zc = { 0 };
 	(void) strncpy(zc.zc_name, zhp->zpool_name, sizeof (zc.zc_name));
-	(void) strncpy(zc.zc_prop_value, path, sizeof (zc.zc_prop_value));
+	(void) strncpy(zc.zc_value, path, sizeof (zc.zc_value));
 	verify(nvlist_lookup_uint64(nv, ZPOOL_CONFIG_GUID,
 	    &zc.zc_guid) == 0);
 	(void) ioctl(zhp->zpool_hdl->libzfs_fd, ZFS_IOC_VDEV_SETPATH, &zc);
 }
 int
 zpool_get_errlog(zpool_handle_t *zhp, nvlist_t ***list, size_t *nelem)
 {
 	zfs_cmd_t zc = { 0 };
 	uint64_t count;
-	zbookmark_t *zb;
+	zbookmark_t *zb = NULL;
+	libzfs_handle_t *hdl = zhp->zpool_hdl;
 	int i, j;
 	if (zhp->zpool_error_log != NULL) {
 		*list = zhp->zpool_error_log;
 		*nelem = zhp->zpool_error_count;
 	 * has increased, allocate more space and continue until we get the
 	 * entire list.
 	 */
 	verify(nvlist_lookup_uint64(zhp->zpool_config, ZPOOL_CONFIG_ERRCOUNT,
 	    &count) == 0);
-	if ((zc.zc_config_dst = (uintptr_t)zfs_alloc(zhp->zpool_hdl,
+	if ((zc.zc_nvlist_dst = (uintptr_t)zfs_alloc(zhp->zpool_hdl,
 	    count * sizeof (zbookmark_t))) == NULL)
 		return (-1);
-	zc.zc_config_dst_size = count;
+	zc.zc_nvlist_dst_size = count;
 	(void) strcpy(zc.zc_name, zhp->zpool_name);
 	for (;;) {
 		if (ioctl(zhp->zpool_hdl->libzfs_fd, ZFS_IOC_ERROR_LOG,
 		    &zc) != 0) {
-			free((void *)(uintptr_t)zc.zc_config_dst);
+			free((void *)(uintptr_t)zc.zc_nvlist_dst);
 			if (errno == ENOMEM) {
-				if ((zc.zc_config_dst = (uintptr_t)
+				if ((zc.zc_nvlist_dst = (uintptr_t)
 				    zfs_alloc(zhp->zpool_hdl,
-				    zc.zc_config_dst_size)) == NULL)
+				    zc.zc_nvlist_dst_size)) == NULL)
 					return (-1);
 			} else {
 				return (-1);
 			}
 		} else {
 	}
 	/*
 	 * Sort the resulting bookmarks.  This is a little confusing due to the
 	 * implementation of ZFS_IOC_ERROR_LOG.  The bookmarks are copied last
-	 * to first, and 'zc_config_dst_size' indicates the number of boomarks
+	 * to first, and 'zc_nvlist_dst_size' indicates the number of boomarks
 	 * _not_ copied as part of the process.  So we point the start of our
 	 * array appropriate and decrement the total number of elements.
 	 */
-	zb = ((zbookmark_t *)(uintptr_t)zc.zc_config_dst) +
+	zb = ((zbookmark_t *)(uintptr_t)zc.zc_nvlist_dst) +
-	    zc.zc_config_dst_size;
+	    zc.zc_nvlist_dst_size;
-	count -= zc.zc_config_dst_size;
+	count -= zc.zc_nvlist_dst_size;
+	zc.zc_nvlist_dst = 0ULL;
 	qsort(zb, count, sizeof (zbookmark_t), zbookmark_compare);
 	/*
 	 * Count the number of unique elements
 	 * If the user has only requested the number of items, return it now
 	 * without bothering with the extra work.
 	 */
 	if (list == NULL) {
 		*nelem = j;
-		free((void *)(uintptr_t)zc.zc_config_dst);
+		free((void *)(uintptr_t)zc.zc_nvlist_dst);
 		return (0);
 	}
 	zhp->zpool_error_count = j;
 	/*
 	 * Allocate an array of nvlists to hold the results
 	 */
 	if ((zhp->zpool_error_log = zfs_alloc(zhp->zpool_hdl,
 	    j * sizeof (nvlist_t *))) == NULL) {
-		free((void *)(uintptr_t)zc.zc_config_dst);
+		free((void *)(uintptr_t)zc.zc_nvlist_dst);
 		return (-1);
 	}
 	/*
 	 * Fill in the results with names from the kernel.
 		if (i > 0 && memcmp(&zb[i - 1], &zb[i],
 		    sizeof (zbookmark_t)) == 0)
 			continue;
-		if (nvlist_alloc(&nv, NV_UNIQUE_NAME,
+		if (zcmd_alloc_dst_nvlist(hdl, &zc, 0) != 0)
-		    0) != 0)
 			goto nomem;
-		zhp->zpool_error_log[j] = nv;
 		zc.zc_bookmark = zb[i];
-		if (ioctl(zhp->zpool_hdl->libzfs_fd, ZFS_IOC_BOOKMARK_NAME,
+		for (;;) {
-		    &zc) == 0) {
+			if (ioctl(zhp->zpool_hdl->libzfs_fd,
-			if (nvlist_add_string(nv, ZPOOL_ERR_DATASET,
+			    ZFS_IOC_BOOKMARK_NAME, &zc) != 0) {
-			    zc.zc_prop_name) != 0 ||
+				if (errno == ENOMEM) {
-			    nvlist_add_string(nv, ZPOOL_ERR_OBJECT,
+					if (zcmd_expand_dst_nvlist(hdl, &zc)
-			    zc.zc_prop_value) != 0 ||
+					    != 0) {
-			    nvlist_add_string(nv, ZPOOL_ERR_RANGE,
+						zcmd_free_nvlists(&zc);
-			    zc.zc_filename) != 0)
+						goto nomem;
-				goto nomem;
+					}
-		} else {
-			(void) snprintf(buf, sizeof (buf), "%llx",
+					continue;
-			    zb[i].zb_objset);
+				} else {
-			if (nvlist_add_string(nv,
+					if (nvlist_alloc(&nv, NV_UNIQUE_NAME,
-			    ZPOOL_ERR_DATASET, buf) != 0)
+					    0) != 0)
-				goto nomem;
+						goto nomem;
-			(void) snprintf(buf, sizeof (buf), "%llx",
-			    zb[i].zb_object);
+					zhp->zpool_error_log[j] = nv;
-			if (nvlist_add_string(nv, ZPOOL_ERR_OBJECT,
+					(void) snprintf(buf, sizeof (buf),
-			    buf) != 0)
+					    "%llx", zb[i].zb_objset);
-				goto nomem;
+					if (nvlist_add_string(nv,
-			(void) snprintf(buf, sizeof (buf), "lvl=%u blkid=%llu",
+					    ZPOOL_ERR_DATASET, buf) != 0)
-			    (int)zb[i].zb_level, (long long)zb[i].zb_blkid);
+						goto nomem;
-			if (nvlist_add_string(nv, ZPOOL_ERR_RANGE,
+					(void) snprintf(buf, sizeof (buf),
-			    buf) != 0)
+					    "%llx", zb[i].zb_object);
-				goto nomem;
+					if (nvlist_add_string(nv,
+					    ZPOOL_ERR_OBJECT, buf) != 0)
+						goto nomem;
+					(void) snprintf(buf, sizeof (buf),
+					    "lvl=%u blkid=%llu",
+					    (int)zb[i].zb_level,
+					    (long long)zb[i].zb_blkid);
+					if (nvlist_add_string(nv,
+					    ZPOOL_ERR_RANGE, buf) != 0)
+						goto nomem;
+				}
+			} else {
+				if (zcmd_read_dst_nvlist(hdl, &zc,
+				    &zhp->zpool_error_log[j]) != 0) {
+					zcmd_free_nvlists(&zc);
+					goto nomem;
+				}
+			}
+			break;
 		}
+		zcmd_free_nvlists(&zc);
 		j++;
 	}
 	*list = zhp->zpool_error_log;
 	*nelem = zhp->zpool_error_count;
+	free(zb);
-	free((void *)(uintptr_t)zc.zc_config_dst);
 	return (0);
 nomem:
-	free((void *)(uintptr_t)zc.zc_config_dst);
+	free(zb);
-	for (i = 0; i < zhp->zpool_error_count; i++) {
+	free((void *)(uintptr_t)zc.zc_nvlist_dst);
-		if (zhp->zpool_error_log[i])
+	for (i = 0; i < zhp->zpool_error_count; i++)
-			free(zhp->zpool_error_log[i]);
+		nvlist_free(zhp->zpool_error_log[i]);
-	}
 	free(zhp->zpool_error_log);
 	zhp->zpool_error_log = NULL;
 	return (no_memory(zhp->zpool_hdl));
 }

changeset 2676	5cee47eddab6
parent 2468	b5038d012f66
child 2856	6f4d5ee1906a