1fa9e4066Sahrens /* 2fa9e4066Sahrens * CDDL HEADER START 3fa9e4066Sahrens * 4fa9e4066Sahrens * The contents of this file are subject to the terms of the 5ea8dc4b6Seschrock * Common Development and Distribution License (the "License"). 6ea8dc4b6Seschrock * You may not use this file except in compliance with the License. 7fa9e4066Sahrens * 8fa9e4066Sahrens * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 9fa9e4066Sahrens * or http://www.opensolaris.org/os/licensing. 10fa9e4066Sahrens * See the License for the specific language governing permissions 11fa9e4066Sahrens * and limitations under the License. 12fa9e4066Sahrens * 13fa9e4066Sahrens * When distributing Covered Code, include this CDDL HEADER in each 14fa9e4066Sahrens * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 15fa9e4066Sahrens * If applicable, add the following below this CDDL HEADER, with the 16fa9e4066Sahrens * fields enclosed by brackets "[]" replaced with your own identifying 17fa9e4066Sahrens * information: Portions Copyright [yyyy] [name of copyright owner] 18fa9e4066Sahrens * 19fa9e4066Sahrens * CDDL HEADER END 20fa9e4066Sahrens */ 21fa9e4066Sahrens /* 22b12a1c38Slling * Copyright 2006 Sun Microsystems, Inc. All rights reserved. 23fa9e4066Sahrens * Use is subject to license terms. 24fa9e4066Sahrens */ 25fa9e4066Sahrens 26fa9e4066Sahrens #pragma ident "%Z%%M% %I% %E% SMI" 27fa9e4066Sahrens 28fa9e4066Sahrens #include <assert.h> 29fa9e4066Sahrens #include <ctype.h> 30fa9e4066Sahrens #include <errno.h> 31fa9e4066Sahrens #include <libdevinfo.h> 32fa9e4066Sahrens #include <libintl.h> 33fa9e4066Sahrens #include <math.h> 34fa9e4066Sahrens #include <stdio.h> 35fa9e4066Sahrens #include <stdlib.h> 36fa9e4066Sahrens #include <strings.h> 37fa9e4066Sahrens #include <unistd.h> 38fa9e4066Sahrens #include <zone.h> 3999653d4eSeschrock #include <fcntl.h> 40fa9e4066Sahrens #include <sys/mntent.h> 41fa9e4066Sahrens #include <sys/mnttab.h> 42b12a1c38Slling #include <sys/mount.h> 43fa9e4066Sahrens 44fa9e4066Sahrens #include <sys/spa.h> 45fa9e4066Sahrens #include <sys/zio.h> 46fa9e4066Sahrens #include <libzfs.h> 47fa9e4066Sahrens 48fa9e4066Sahrens #include "zfs_namecheck.h" 49fa9e4066Sahrens #include "zfs_prop.h" 50fa9e4066Sahrens #include "libzfs_impl.h" 51fa9e4066Sahrens 52fa9e4066Sahrens /* 53fa9e4066Sahrens * Given a single type (not a mask of types), return the type in a human 54fa9e4066Sahrens * readable form. 55fa9e4066Sahrens */ 56fa9e4066Sahrens const char * 57fa9e4066Sahrens zfs_type_to_name(zfs_type_t type) 58fa9e4066Sahrens { 59fa9e4066Sahrens switch (type) { 60fa9e4066Sahrens case ZFS_TYPE_FILESYSTEM: 61fa9e4066Sahrens return (dgettext(TEXT_DOMAIN, "filesystem")); 62fa9e4066Sahrens case ZFS_TYPE_SNAPSHOT: 63fa9e4066Sahrens return (dgettext(TEXT_DOMAIN, "snapshot")); 64fa9e4066Sahrens case ZFS_TYPE_VOLUME: 65fa9e4066Sahrens return (dgettext(TEXT_DOMAIN, "volume")); 66fa9e4066Sahrens } 67fa9e4066Sahrens 68fa9e4066Sahrens return (NULL); 69fa9e4066Sahrens } 70fa9e4066Sahrens 71fa9e4066Sahrens /* 72fa9e4066Sahrens * Given a path and mask of ZFS types, return a string describing this dataset. 73fa9e4066Sahrens * This is used when we fail to open a dataset and we cannot get an exact type. 74fa9e4066Sahrens * We guess what the type would have been based on the path and the mask of 75fa9e4066Sahrens * acceptable types. 76fa9e4066Sahrens */ 77fa9e4066Sahrens static const char * 78fa9e4066Sahrens path_to_str(const char *path, int types) 79fa9e4066Sahrens { 80fa9e4066Sahrens /* 81fa9e4066Sahrens * When given a single type, always report the exact type. 82fa9e4066Sahrens */ 83fa9e4066Sahrens if (types == ZFS_TYPE_SNAPSHOT) 84fa9e4066Sahrens return (dgettext(TEXT_DOMAIN, "snapshot")); 85fa9e4066Sahrens if (types == ZFS_TYPE_FILESYSTEM) 86fa9e4066Sahrens return (dgettext(TEXT_DOMAIN, "filesystem")); 87fa9e4066Sahrens if (types == ZFS_TYPE_VOLUME) 88fa9e4066Sahrens return (dgettext(TEXT_DOMAIN, "volume")); 89fa9e4066Sahrens 90fa9e4066Sahrens /* 91fa9e4066Sahrens * The user is requesting more than one type of dataset. If this is the 92fa9e4066Sahrens * case, consult the path itself. If we're looking for a snapshot, and 93fa9e4066Sahrens * a '@' is found, then report it as "snapshot". Otherwise, remove the 94fa9e4066Sahrens * snapshot attribute and try again. 95fa9e4066Sahrens */ 96fa9e4066Sahrens if (types & ZFS_TYPE_SNAPSHOT) { 97fa9e4066Sahrens if (strchr(path, '@') != NULL) 98fa9e4066Sahrens return (dgettext(TEXT_DOMAIN, "snapshot")); 99fa9e4066Sahrens return (path_to_str(path, types & ~ZFS_TYPE_SNAPSHOT)); 100fa9e4066Sahrens } 101fa9e4066Sahrens 102fa9e4066Sahrens 103fa9e4066Sahrens /* 104fa9e4066Sahrens * The user has requested either filesystems or volumes. 105fa9e4066Sahrens * We have no way of knowing a priori what type this would be, so always 106fa9e4066Sahrens * report it as "filesystem" or "volume", our two primitive types. 107fa9e4066Sahrens */ 108fa9e4066Sahrens if (types & ZFS_TYPE_FILESYSTEM) 109fa9e4066Sahrens return (dgettext(TEXT_DOMAIN, "filesystem")); 110fa9e4066Sahrens 111fa9e4066Sahrens assert(types & ZFS_TYPE_VOLUME); 112fa9e4066Sahrens return (dgettext(TEXT_DOMAIN, "volume")); 113fa9e4066Sahrens } 114fa9e4066Sahrens 115fa9e4066Sahrens /* 116fa9e4066Sahrens * Validate a ZFS path. This is used even before trying to open the dataset, to 117fa9e4066Sahrens * provide a more meaningful error message. We place a more useful message in 118fa9e4066Sahrens * 'buf' detailing exactly why the name was not valid. 119fa9e4066Sahrens */ 120fa9e4066Sahrens static int 12199653d4eSeschrock zfs_validate_name(libzfs_handle_t *hdl, const char *path, int type) 122fa9e4066Sahrens { 123fa9e4066Sahrens namecheck_err_t why; 124fa9e4066Sahrens char what; 125fa9e4066Sahrens 126fa9e4066Sahrens if (dataset_namecheck(path, &why, &what) != 0) { 12799653d4eSeschrock if (hdl != NULL) { 128fa9e4066Sahrens switch (why) { 129b81d61a6Slling case NAME_ERR_TOOLONG: 13099653d4eSeschrock zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, 13199653d4eSeschrock "name is too long")); 132b81d61a6Slling break; 133b81d61a6Slling 134fa9e4066Sahrens case NAME_ERR_LEADING_SLASH: 13599653d4eSeschrock zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, 13699653d4eSeschrock "leading slash in name")); 137fa9e4066Sahrens break; 138fa9e4066Sahrens 139fa9e4066Sahrens case NAME_ERR_EMPTY_COMPONENT: 14099653d4eSeschrock zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, 14199653d4eSeschrock "empty component in name")); 142fa9e4066Sahrens break; 143fa9e4066Sahrens 144fa9e4066Sahrens case NAME_ERR_TRAILING_SLASH: 14599653d4eSeschrock zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, 14699653d4eSeschrock "trailing slash in name")); 147fa9e4066Sahrens break; 148fa9e4066Sahrens 149fa9e4066Sahrens case NAME_ERR_INVALCHAR: 15099653d4eSeschrock zfs_error_aux(hdl, 151fa9e4066Sahrens dgettext(TEXT_DOMAIN, "invalid character " 15299653d4eSeschrock "'%c' in name"), what); 153fa9e4066Sahrens break; 154fa9e4066Sahrens 155fa9e4066Sahrens case NAME_ERR_MULTIPLE_AT: 15699653d4eSeschrock zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, 15799653d4eSeschrock "multiple '@' delimiters in name")); 158fa9e4066Sahrens break; 159fa9e4066Sahrens } 160fa9e4066Sahrens } 161fa9e4066Sahrens 162fa9e4066Sahrens return (0); 163fa9e4066Sahrens } 164fa9e4066Sahrens 165fa9e4066Sahrens if (!(type & ZFS_TYPE_SNAPSHOT) && strchr(path, '@') != NULL) { 16699653d4eSeschrock if (hdl != NULL) 16799653d4eSeschrock zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, 16899653d4eSeschrock "snapshot delimiter '@' in filesystem name")); 169fa9e4066Sahrens return (0); 170fa9e4066Sahrens } 171fa9e4066Sahrens 172*1d452cf5Sahrens if (type == ZFS_TYPE_SNAPSHOT && strchr(path, '@') == NULL) { 173*1d452cf5Sahrens if (hdl != NULL) 174*1d452cf5Sahrens zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, 175*1d452cf5Sahrens "missing '@' delimeter in snapshot name")); 176*1d452cf5Sahrens return (0); 177*1d452cf5Sahrens } 178*1d452cf5Sahrens 17999653d4eSeschrock return (-1); 180fa9e4066Sahrens } 181fa9e4066Sahrens 182fa9e4066Sahrens int 183fa9e4066Sahrens zfs_name_valid(const char *name, zfs_type_t type) 184fa9e4066Sahrens { 18599653d4eSeschrock return (zfs_validate_name(NULL, name, type)); 186fa9e4066Sahrens } 187fa9e4066Sahrens 188fa9e4066Sahrens /* 189fa9e4066Sahrens * Utility function to gather stats (objset and zpl) for the given object. 190fa9e4066Sahrens */ 191fa9e4066Sahrens static int 192fa9e4066Sahrens get_stats(zfs_handle_t *zhp) 193fa9e4066Sahrens { 194fa9e4066Sahrens zfs_cmd_t zc = { 0 }; 195fa9e4066Sahrens 196fa9e4066Sahrens (void) strlcpy(zc.zc_name, zhp->zfs_name, sizeof (zc.zc_name)); 197fa9e4066Sahrens 19899653d4eSeschrock if ((zc.zc_config_src = (uint64_t)(uintptr_t)malloc(1024)) == NULL) 19999653d4eSeschrock return (-1); 2007f7322feSeschrock zc.zc_config_src_size = 1024; 2017f7322feSeschrock 20299653d4eSeschrock while (ioctl(zhp->zfs_hdl->libzfs_fd, ZFS_IOC_OBJSET_STATS, &zc) != 0) { 2037f7322feSeschrock if (errno == ENOMEM) { 20499653d4eSeschrock free((void *)(uintptr_t)zc.zc_config_src); 20599653d4eSeschrock if ((zc.zc_config_src = (uint64_t)(uintptr_t) 20699653d4eSeschrock malloc(zc.zc_config_src_size)) == NULL) 20799653d4eSeschrock return (-1); 2087f7322feSeschrock } else { 2097f7322feSeschrock free((void *)(uintptr_t)zc.zc_config_src); 2107f7322feSeschrock return (-1); 2117f7322feSeschrock } 2127f7322feSeschrock } 213fa9e4066Sahrens 214fa9e4066Sahrens bcopy(&zc.zc_objset_stats, &zhp->zfs_dmustats, 215fa9e4066Sahrens sizeof (zc.zc_objset_stats)); 216fa9e4066Sahrens 217ea8dc4b6Seschrock (void) strcpy(zhp->zfs_root, zc.zc_root); 218ea8dc4b6Seschrock 21999653d4eSeschrock if (zhp->zfs_props) { 22099653d4eSeschrock nvlist_free(zhp->zfs_props); 22199653d4eSeschrock zhp->zfs_props = NULL; 22299653d4eSeschrock } 22399653d4eSeschrock 22499653d4eSeschrock if (nvlist_unpack((void *)(uintptr_t)zc.zc_config_src, 22599653d4eSeschrock zc.zc_config_src_size, &zhp->zfs_props, 0) != 0) { 22699653d4eSeschrock free((void *)(uintptr_t)zc.zc_config_src); 22799653d4eSeschrock return (-1); 22899653d4eSeschrock } 229fa9e4066Sahrens 230fa9e4066Sahrens zhp->zfs_volsize = zc.zc_volsize; 231fa9e4066Sahrens zhp->zfs_volblocksize = zc.zc_volblocksize; 232fa9e4066Sahrens 23399653d4eSeschrock free((void *)(uintptr_t)zc.zc_config_src); 23499653d4eSeschrock 235fa9e4066Sahrens return (0); 236fa9e4066Sahrens } 237fa9e4066Sahrens 238fa9e4066Sahrens /* 239fa9e4066Sahrens * Refresh the properties currently stored in the handle. 240fa9e4066Sahrens */ 241fa9e4066Sahrens void 242fa9e4066Sahrens zfs_refresh_properties(zfs_handle_t *zhp) 243fa9e4066Sahrens { 244fa9e4066Sahrens (void) get_stats(zhp); 245fa9e4066Sahrens } 246fa9e4066Sahrens 247fa9e4066Sahrens /* 248fa9e4066Sahrens * Makes a handle from the given dataset name. Used by zfs_open() and 249fa9e4066Sahrens * zfs_iter_* to create child handles on the fly. 250fa9e4066Sahrens */ 251fa9e4066Sahrens zfs_handle_t * 25299653d4eSeschrock make_dataset_handle(libzfs_handle_t *hdl, const char *path) 253fa9e4066Sahrens { 25499653d4eSeschrock zfs_handle_t *zhp = calloc(sizeof (zfs_handle_t), 1); 25599653d4eSeschrock 25699653d4eSeschrock if (zhp == NULL) 25799653d4eSeschrock return (NULL); 25899653d4eSeschrock 25999653d4eSeschrock zhp->zfs_hdl = hdl; 260fa9e4066Sahrens 26131fd60d3Sahrens top: 262fa9e4066Sahrens (void) strlcpy(zhp->zfs_name, path, sizeof (zhp->zfs_name)); 263fa9e4066Sahrens 264fa9e4066Sahrens if (get_stats(zhp) != 0) { 265fa9e4066Sahrens free(zhp); 266fa9e4066Sahrens return (NULL); 267fa9e4066Sahrens } 268fa9e4066Sahrens 26931fd60d3Sahrens if (zhp->zfs_dmustats.dds_inconsistent) { 27031fd60d3Sahrens zfs_cmd_t zc = { 0 }; 27131fd60d3Sahrens 27231fd60d3Sahrens /* 27331fd60d3Sahrens * If it is dds_inconsistent, then we've caught it in 27431fd60d3Sahrens * the middle of a 'zfs receive' or 'zfs destroy', and 27531fd60d3Sahrens * it is inconsistent from the ZPL's point of view, so 27631fd60d3Sahrens * can't be mounted. However, it could also be that we 27731fd60d3Sahrens * have crashed in the middle of one of those 27831fd60d3Sahrens * operations, in which case we need to get rid of the 27931fd60d3Sahrens * inconsistent state. We do that by either rolling 28031fd60d3Sahrens * back to the previous snapshot (which will fail if 28131fd60d3Sahrens * there is none), or destroying the filesystem. Note 28231fd60d3Sahrens * that if we are still in the middle of an active 28331fd60d3Sahrens * 'receive' or 'destroy', then the rollback and destroy 28431fd60d3Sahrens * will fail with EBUSY and we will drive on as usual. 28531fd60d3Sahrens */ 28631fd60d3Sahrens 28731fd60d3Sahrens (void) strlcpy(zc.zc_name, zhp->zfs_name, sizeof (zc.zc_name)); 28831fd60d3Sahrens 28931fd60d3Sahrens if (zhp->zfs_type == ZFS_TYPE_VOLUME) { 29099653d4eSeschrock (void) zvol_remove_link(hdl, zhp->zfs_name); 29131fd60d3Sahrens zc.zc_objset_type = DMU_OST_ZVOL; 29231fd60d3Sahrens } else { 29331fd60d3Sahrens zc.zc_objset_type = DMU_OST_ZFS; 29431fd60d3Sahrens } 29531fd60d3Sahrens 29631fd60d3Sahrens /* If we can successfully roll it back, reget the stats */ 29799653d4eSeschrock if (ioctl(hdl->libzfs_fd, ZFS_IOC_ROLLBACK, &zc) == 0) 29831fd60d3Sahrens goto top; 29931fd60d3Sahrens /* 30031fd60d3Sahrens * If we can sucessfully destroy it, pretend that it 30131fd60d3Sahrens * never existed. 30231fd60d3Sahrens */ 30399653d4eSeschrock if (ioctl(hdl->libzfs_fd, ZFS_IOC_DESTROY, &zc) == 0) { 30431fd60d3Sahrens free(zhp); 30531fd60d3Sahrens errno = ENOENT; 30631fd60d3Sahrens return (NULL); 30731fd60d3Sahrens } 30831fd60d3Sahrens } 30931fd60d3Sahrens 310fa9e4066Sahrens /* 311fa9e4066Sahrens * We've managed to open the dataset and gather statistics. Determine 312fa9e4066Sahrens * the high-level type. 313fa9e4066Sahrens */ 314fa9e4066Sahrens if (zhp->zfs_dmustats.dds_is_snapshot) 315fa9e4066Sahrens zhp->zfs_type = ZFS_TYPE_SNAPSHOT; 316fa9e4066Sahrens else if (zhp->zfs_dmustats.dds_type == DMU_OST_ZVOL) 317fa9e4066Sahrens zhp->zfs_type = ZFS_TYPE_VOLUME; 318fa9e4066Sahrens else if (zhp->zfs_dmustats.dds_type == DMU_OST_ZFS) 319fa9e4066Sahrens zhp->zfs_type = ZFS_TYPE_FILESYSTEM; 320fa9e4066Sahrens else 32199653d4eSeschrock abort(); /* we should never see any other types */ 322fa9e4066Sahrens 323fa9e4066Sahrens return (zhp); 324fa9e4066Sahrens } 325fa9e4066Sahrens 326fa9e4066Sahrens /* 327fa9e4066Sahrens * Opens the given snapshot, filesystem, or volume. The 'types' 328fa9e4066Sahrens * argument is a mask of acceptable types. The function will print an 329fa9e4066Sahrens * appropriate error message and return NULL if it can't be opened. 330fa9e4066Sahrens */ 331fa9e4066Sahrens zfs_handle_t * 33299653d4eSeschrock zfs_open(libzfs_handle_t *hdl, const char *path, int types) 333fa9e4066Sahrens { 334fa9e4066Sahrens zfs_handle_t *zhp; 33599653d4eSeschrock char errbuf[1024]; 33699653d4eSeschrock 33799653d4eSeschrock (void) snprintf(errbuf, sizeof (errbuf), 33899653d4eSeschrock dgettext(TEXT_DOMAIN, "cannot open '%s'"), path); 339fa9e4066Sahrens 340fa9e4066Sahrens /* 34199653d4eSeschrock * Validate the name before we even try to open it. 342fa9e4066Sahrens */ 34399653d4eSeschrock if (!zfs_validate_name(hdl, path, ZFS_TYPE_ANY)) { 34499653d4eSeschrock zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, 34599653d4eSeschrock "invalid dataset name")); 34699653d4eSeschrock (void) zfs_error(hdl, EZFS_INVALIDNAME, errbuf); 347fa9e4066Sahrens return (NULL); 348fa9e4066Sahrens } 349fa9e4066Sahrens 350fa9e4066Sahrens /* 351fa9e4066Sahrens * Try to get stats for the dataset, which will tell us if it exists. 352fa9e4066Sahrens */ 353fa9e4066Sahrens errno = 0; 35499653d4eSeschrock if ((zhp = make_dataset_handle(hdl, path)) == NULL) { 35599653d4eSeschrock (void) zfs_standard_error(hdl, errno, errbuf, path); 356fa9e4066Sahrens return (NULL); 357fa9e4066Sahrens } 358fa9e4066Sahrens 359fa9e4066Sahrens if (!(types & zhp->zfs_type)) { 36099653d4eSeschrock (void) zfs_error(hdl, EZFS_BADTYPE, errbuf); 36194de1d4cSeschrock zfs_close(zhp); 362fa9e4066Sahrens return (NULL); 363fa9e4066Sahrens } 364fa9e4066Sahrens 365fa9e4066Sahrens return (zhp); 366fa9e4066Sahrens } 367fa9e4066Sahrens 368fa9e4066Sahrens /* 369fa9e4066Sahrens * Release a ZFS handle. Nothing to do but free the associated memory. 370fa9e4066Sahrens */ 371fa9e4066Sahrens void 372fa9e4066Sahrens zfs_close(zfs_handle_t *zhp) 373fa9e4066Sahrens { 374fa9e4066Sahrens if (zhp->zfs_mntopts) 375fa9e4066Sahrens free(zhp->zfs_mntopts); 37699653d4eSeschrock if (zhp->zfs_props) 37799653d4eSeschrock nvlist_free(zhp->zfs_props); 378fa9e4066Sahrens free(zhp); 379fa9e4066Sahrens } 380fa9e4066Sahrens 381fa9e4066Sahrens struct { 382fa9e4066Sahrens const char *name; 383fa9e4066Sahrens uint64_t value; 384fa9e4066Sahrens } checksum_table[] = { 385fa9e4066Sahrens { "on", ZIO_CHECKSUM_ON }, 386fa9e4066Sahrens { "off", ZIO_CHECKSUM_OFF }, 387fa9e4066Sahrens { "fletcher2", ZIO_CHECKSUM_FLETCHER_2 }, 388fa9e4066Sahrens { "fletcher4", ZIO_CHECKSUM_FLETCHER_4 }, 389fa9e4066Sahrens { "sha256", ZIO_CHECKSUM_SHA256 }, 390fa9e4066Sahrens { NULL } 391fa9e4066Sahrens }; 392fa9e4066Sahrens 393fa9e4066Sahrens struct { 394fa9e4066Sahrens const char *name; 395fa9e4066Sahrens uint64_t value; 396fa9e4066Sahrens } compress_table[] = { 397fa9e4066Sahrens { "on", ZIO_COMPRESS_ON }, 398fa9e4066Sahrens { "off", ZIO_COMPRESS_OFF }, 399fa9e4066Sahrens { "lzjb", ZIO_COMPRESS_LZJB }, 400fa9e4066Sahrens { NULL } 401fa9e4066Sahrens }; 402fa9e4066Sahrens 403fa9e4066Sahrens struct { 404fa9e4066Sahrens const char *name; 405fa9e4066Sahrens uint64_t value; 406fa9e4066Sahrens } snapdir_table[] = { 407a0965f35Sbonwick { "hidden", ZFS_SNAPDIR_HIDDEN }, 408a0965f35Sbonwick { "visible", ZFS_SNAPDIR_VISIBLE }, 409fa9e4066Sahrens { NULL } 410fa9e4066Sahrens }; 411fa9e4066Sahrens 412fa9e4066Sahrens struct { 413fa9e4066Sahrens const char *name; 414fa9e4066Sahrens uint64_t value; 415fa9e4066Sahrens } acl_mode_table[] = { 416fa9e4066Sahrens { "discard", DISCARD }, 417fa9e4066Sahrens { "groupmask", GROUPMASK }, 418fa9e4066Sahrens { "passthrough", PASSTHROUGH }, 419fa9e4066Sahrens { NULL } 420fa9e4066Sahrens }; 421fa9e4066Sahrens 422fa9e4066Sahrens struct { 423fa9e4066Sahrens const char *name; 424fa9e4066Sahrens uint64_t value; 425fa9e4066Sahrens } acl_inherit_table[] = { 426fa9e4066Sahrens { "discard", DISCARD }, 427fa9e4066Sahrens { "noallow", NOALLOW }, 428fa9e4066Sahrens { "secure", SECURE }, 429fa9e4066Sahrens { "passthrough", PASSTHROUGH }, 430fa9e4066Sahrens { NULL } 431fa9e4066Sahrens }; 432fa9e4066Sahrens 433fa9e4066Sahrens 434fa9e4066Sahrens /* 435fa9e4066Sahrens * Given a numeric suffix, convert the value into a number of bits that the 436fa9e4066Sahrens * resulting value must be shifted. 437fa9e4066Sahrens */ 438fa9e4066Sahrens static int 43999653d4eSeschrock str2shift(libzfs_handle_t *hdl, const char *buf) 440fa9e4066Sahrens { 441fa9e4066Sahrens const char *ends = "BKMGTPEZ"; 442fa9e4066Sahrens int i; 443fa9e4066Sahrens 444fa9e4066Sahrens if (buf[0] == '\0') 445fa9e4066Sahrens return (0); 446fa9e4066Sahrens for (i = 0; i < strlen(ends); i++) { 447fa9e4066Sahrens if (toupper(buf[0]) == ends[i]) 448fa9e4066Sahrens break; 449fa9e4066Sahrens } 450fa9e4066Sahrens if (i == strlen(ends)) { 45199653d4eSeschrock zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, 45299653d4eSeschrock "invalid numeric suffix '%s'"), buf); 453fa9e4066Sahrens return (-1); 454fa9e4066Sahrens } 455fa9e4066Sahrens 456fa9e4066Sahrens /* 457fa9e4066Sahrens * We want to allow trailing 'b' characters for 'GB' or 'Mb'. But don't 458fa9e4066Sahrens * allow 'BB' - that's just weird. 459fa9e4066Sahrens */ 460fa9e4066Sahrens if (buf[1] == '\0' || (toupper(buf[1]) == 'B' && buf[2] == '\0' && 46199653d4eSeschrock toupper(buf[0]) != 'B')) 462fa9e4066Sahrens return (10*i); 463fa9e4066Sahrens 46499653d4eSeschrock zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, 46599653d4eSeschrock "invalid numeric suffix '%s'"), buf); 466fa9e4066Sahrens return (-1); 467fa9e4066Sahrens } 468fa9e4066Sahrens 469fa9e4066Sahrens /* 470fa9e4066Sahrens * Convert a string of the form '100G' into a real number. Used when setting 471fa9e4066Sahrens * properties or creating a volume. 'buf' is used to place an extended error 472fa9e4066Sahrens * message for the caller to use. 473fa9e4066Sahrens */ 474fa9e4066Sahrens static int 47599653d4eSeschrock nicestrtonum(libzfs_handle_t *hdl, const char *value, uint64_t *num) 476fa9e4066Sahrens { 477fa9e4066Sahrens char *end; 478fa9e4066Sahrens int shift; 479fa9e4066Sahrens 480fa9e4066Sahrens *num = 0; 481fa9e4066Sahrens 482fa9e4066Sahrens /* Check to see if this looks like a number. */ 483fa9e4066Sahrens if ((value[0] < '0' || value[0] > '9') && value[0] != '.') { 48499653d4eSeschrock if (hdl) 48599653d4eSeschrock zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, 48699653d4eSeschrock "bad numeric value '%s'"), value); 487fa9e4066Sahrens return (-1); 488fa9e4066Sahrens } 489fa9e4066Sahrens 490fa9e4066Sahrens /* Rely on stroll() to process the numeric portion. */ 491fa9e4066Sahrens errno = 0; 492fa9e4066Sahrens *num = strtoll(value, &end, 10); 493fa9e4066Sahrens 494fa9e4066Sahrens /* 495fa9e4066Sahrens * Check for ERANGE, which indicates that the value is too large to fit 496fa9e4066Sahrens * in a 64-bit value. 497fa9e4066Sahrens */ 498fa9e4066Sahrens if (errno == ERANGE) { 49999653d4eSeschrock if (hdl) 50099653d4eSeschrock zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, 50199653d4eSeschrock "numeric value is too large")); 502fa9e4066Sahrens return (-1); 503fa9e4066Sahrens } 504fa9e4066Sahrens 505fa9e4066Sahrens /* 506fa9e4066Sahrens * If we have a decimal value, then do the computation with floating 507fa9e4066Sahrens * point arithmetic. Otherwise, use standard arithmetic. 508fa9e4066Sahrens */ 509fa9e4066Sahrens if (*end == '.') { 510fa9e4066Sahrens double fval = strtod(value, &end); 511fa9e4066Sahrens 51299653d4eSeschrock if ((shift = str2shift(hdl, end)) == -1) 513fa9e4066Sahrens return (-1); 514fa9e4066Sahrens 515fa9e4066Sahrens fval *= pow(2, shift); 516fa9e4066Sahrens 517fa9e4066Sahrens if (fval > UINT64_MAX) { 51899653d4eSeschrock if (hdl) 51999653d4eSeschrock zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, 52099653d4eSeschrock "numeric value is too large")); 521fa9e4066Sahrens return (-1); 522fa9e4066Sahrens } 523fa9e4066Sahrens 524fa9e4066Sahrens *num = (uint64_t)fval; 525fa9e4066Sahrens } else { 52699653d4eSeschrock if ((shift = str2shift(hdl, end)) == -1) 527fa9e4066Sahrens return (-1); 528fa9e4066Sahrens 529fa9e4066Sahrens /* Check for overflow */ 530fa9e4066Sahrens if (shift >= 64 || (*num << shift) >> shift != *num) { 53199653d4eSeschrock if (hdl) 53299653d4eSeschrock zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, 53399653d4eSeschrock "numeric value is too large")); 534fa9e4066Sahrens return (-1); 535fa9e4066Sahrens } 536fa9e4066Sahrens 537fa9e4066Sahrens *num <<= shift; 538fa9e4066Sahrens } 539fa9e4066Sahrens 540fa9e4066Sahrens return (0); 541fa9e4066Sahrens } 542fa9e4066Sahrens 543fa9e4066Sahrens int 544fa9e4066Sahrens zfs_nicestrtonum(const char *str, uint64_t *val) 545fa9e4066Sahrens { 54699653d4eSeschrock return (nicestrtonum(NULL, str, val)); 547fa9e4066Sahrens } 548fa9e4066Sahrens 549fa9e4066Sahrens /* 550fa9e4066Sahrens * Given a property type and value, verify that the value is appropriate. Used 551fa9e4066Sahrens * by zfs_prop_set() and some libzfs consumers. 552fa9e4066Sahrens */ 553fa9e4066Sahrens int 55499653d4eSeschrock zfs_prop_validate(libzfs_handle_t *hdl, zfs_prop_t prop, const char *value, 55599653d4eSeschrock uint64_t *intval) 556fa9e4066Sahrens { 557fa9e4066Sahrens const char *propname = zfs_prop_to_name(prop); 558fa9e4066Sahrens uint64_t number; 55999653d4eSeschrock char errbuf[1024]; 560fa9e4066Sahrens int i; 561fa9e4066Sahrens 562fa9e4066Sahrens /* 563fa9e4066Sahrens * Check to see if this a read-only property. 564fa9e4066Sahrens */ 56599653d4eSeschrock if (zfs_prop_readonly(prop)) 56699653d4eSeschrock return (zfs_error(hdl, EZFS_PROPREADONLY, 56799653d4eSeschrock dgettext(TEXT_DOMAIN, "cannot set %s property"), propname)); 56899653d4eSeschrock 56999653d4eSeschrock (void) snprintf(errbuf, sizeof (errbuf), 57099653d4eSeschrock dgettext(TEXT_DOMAIN, "bad %s value '%s'"), propname, value); 571fa9e4066Sahrens 572fa9e4066Sahrens /* See if the property value is too long */ 573fa9e4066Sahrens if (strlen(value) >= ZFS_MAXPROPLEN) { 57499653d4eSeschrock zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, "value is too long")); 57599653d4eSeschrock return (zfs_error(hdl, EZFS_BADPROP, errbuf)); 576fa9e4066Sahrens } 577fa9e4066Sahrens 578fa9e4066Sahrens /* Perform basic checking based on property type */ 579fa9e4066Sahrens switch (zfs_prop_get_type(prop)) { 580fa9e4066Sahrens case prop_type_boolean: 581fa9e4066Sahrens if (strcmp(value, "on") == 0) { 582fa9e4066Sahrens number = 1; 583fa9e4066Sahrens } else if (strcmp(value, "off") == 0) { 584fa9e4066Sahrens number = 0; 585fa9e4066Sahrens } else { 58699653d4eSeschrock zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, 58799653d4eSeschrock "must be 'on' or 'off'")); 58899653d4eSeschrock return (zfs_error(hdl, EZFS_BADPROP, errbuf)); 589fa9e4066Sahrens } 590fa9e4066Sahrens break; 591fa9e4066Sahrens 592fa9e4066Sahrens case prop_type_number: 593fa9e4066Sahrens /* treat 'none' as 0 */ 594fa9e4066Sahrens if (strcmp(value, "none") == 0) { 595fa9e4066Sahrens number = 0; 596fa9e4066Sahrens break; 597fa9e4066Sahrens } 598fa9e4066Sahrens 59999653d4eSeschrock if (nicestrtonum(hdl, value, &number) != 0) 60099653d4eSeschrock return (zfs_error(hdl, EZFS_BADPROP, errbuf)); 601fa9e4066Sahrens 602fa9e4066Sahrens /* don't allow 0 for quota, use 'none' instead */ 603fa9e4066Sahrens if (prop == ZFS_PROP_QUOTA && number == 0 && 604fa9e4066Sahrens strcmp(value, "none") != 0) { 60599653d4eSeschrock zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, 60699653d4eSeschrock "use 'quota=none' to disable")); 60799653d4eSeschrock return (zfs_error(hdl, EZFS_BADPROP, errbuf)); 608fa9e4066Sahrens } 609fa9e4066Sahrens 610fa9e4066Sahrens /* must be power of two within SPA_{MIN,MAX}BLOCKSIZE */ 611fa9e4066Sahrens if (prop == ZFS_PROP_RECORDSIZE || 612fa9e4066Sahrens prop == ZFS_PROP_VOLBLOCKSIZE) { 613fa9e4066Sahrens if (number < SPA_MINBLOCKSIZE || 614fa9e4066Sahrens number > SPA_MAXBLOCKSIZE || !ISP2(number)) { 61599653d4eSeschrock zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, 616fa9e4066Sahrens "must be power of 2 from %u to %uk"), 617fa9e4066Sahrens (uint_t)SPA_MINBLOCKSIZE, 618fa9e4066Sahrens (uint_t)SPA_MAXBLOCKSIZE >> 10); 61999653d4eSeschrock return (zfs_error(hdl, EZFS_BADPROP, errbuf)); 620fa9e4066Sahrens } 621fa9e4066Sahrens } 622fa9e4066Sahrens 623fa9e4066Sahrens break; 624fa9e4066Sahrens 625fa9e4066Sahrens case prop_type_string: 626fa9e4066Sahrens case prop_type_index: 627fa9e4066Sahrens /* 628fa9e4066Sahrens * The two writable string values, 'mountpoint' and 629fa9e4066Sahrens * 'checksum' need special consideration. The 'index' types are 630fa9e4066Sahrens * specified as strings by the user, but passed to the kernel as 631fa9e4066Sahrens * integers. 632fa9e4066Sahrens */ 633fa9e4066Sahrens switch (prop) { 634fa9e4066Sahrens case ZFS_PROP_MOUNTPOINT: 635fa9e4066Sahrens if (strcmp(value, ZFS_MOUNTPOINT_NONE) == 0 || 636fa9e4066Sahrens strcmp(value, ZFS_MOUNTPOINT_LEGACY) == 0) 637fa9e4066Sahrens break; 638fa9e4066Sahrens 639fa9e4066Sahrens if (value[0] != '/') { 64099653d4eSeschrock zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, 64199653d4eSeschrock "must be an absolute path, 'none', or " 64299653d4eSeschrock "'legacy'")); 64399653d4eSeschrock return (zfs_error(hdl, EZFS_BADPROP, errbuf)); 644fa9e4066Sahrens } 645fa9e4066Sahrens break; 646fa9e4066Sahrens 647fa9e4066Sahrens case ZFS_PROP_CHECKSUM: 648fa9e4066Sahrens for (i = 0; checksum_table[i].name != NULL; i++) { 649fa9e4066Sahrens if (strcmp(value, checksum_table[i].name) 650fa9e4066Sahrens == 0) { 651fa9e4066Sahrens number = checksum_table[i].value; 652fa9e4066Sahrens break; 653fa9e4066Sahrens } 654fa9e4066Sahrens } 655fa9e4066Sahrens 656fa9e4066Sahrens if (checksum_table[i].name == NULL) { 65799653d4eSeschrock zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, 65899653d4eSeschrock "must be 'on', 'off', 'fletcher2', " 65999653d4eSeschrock "'fletcher4', or 'sha256'")); 66099653d4eSeschrock return (zfs_error(hdl, EZFS_BADPROP, errbuf)); 661fa9e4066Sahrens } 662fa9e4066Sahrens break; 663fa9e4066Sahrens 664fa9e4066Sahrens case ZFS_PROP_COMPRESSION: 665fa9e4066Sahrens for (i = 0; compress_table[i].name != NULL; i++) { 666fa9e4066Sahrens if (strcmp(value, compress_table[i].name) 667fa9e4066Sahrens == 0) { 668fa9e4066Sahrens number = compress_table[i].value; 669fa9e4066Sahrens break; 670fa9e4066Sahrens } 671fa9e4066Sahrens } 672fa9e4066Sahrens 673fa9e4066Sahrens if (compress_table[i].name == NULL) { 67499653d4eSeschrock zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, 67599653d4eSeschrock "must be 'on', 'off', or 'lzjb'")); 67699653d4eSeschrock return (zfs_error(hdl, EZFS_BADPROP, errbuf)); 677fa9e4066Sahrens } 678fa9e4066Sahrens break; 679fa9e4066Sahrens 680fa9e4066Sahrens case ZFS_PROP_SNAPDIR: 681fa9e4066Sahrens for (i = 0; snapdir_table[i].name != NULL; i++) { 682fa9e4066Sahrens if (strcmp(value, snapdir_table[i].name) == 0) { 683fa9e4066Sahrens number = snapdir_table[i].value; 684fa9e4066Sahrens break; 685fa9e4066Sahrens } 686fa9e4066Sahrens } 687fa9e4066Sahrens 688fa9e4066Sahrens if (snapdir_table[i].name == NULL) { 68999653d4eSeschrock zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, 69099653d4eSeschrock "must be 'hidden' or 'visible'")); 69199653d4eSeschrock return (zfs_error(hdl, EZFS_BADPROP, errbuf)); 692fa9e4066Sahrens } 693fa9e4066Sahrens break; 694fa9e4066Sahrens 695fa9e4066Sahrens case ZFS_PROP_ACLMODE: 696fa9e4066Sahrens for (i = 0; acl_mode_table[i].name != NULL; i++) { 697fa9e4066Sahrens if (strcmp(value, acl_mode_table[i].name) 698fa9e4066Sahrens == 0) { 699fa9e4066Sahrens number = acl_mode_table[i].value; 700fa9e4066Sahrens break; 701fa9e4066Sahrens } 702fa9e4066Sahrens } 703fa9e4066Sahrens 704fa9e4066Sahrens if (acl_mode_table[i].name == NULL) { 70599653d4eSeschrock zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, 70699653d4eSeschrock "must be 'disacard', 'groupmask', or " 70799653d4eSeschrock "'passthrough'")); 70899653d4eSeschrock return (zfs_error(hdl, EZFS_BADPROP, errbuf)); 709fa9e4066Sahrens } 710fa9e4066Sahrens break; 711fa9e4066Sahrens 712fa9e4066Sahrens case ZFS_PROP_ACLINHERIT: 713fa9e4066Sahrens for (i = 0; acl_inherit_table[i].name != NULL; i++) { 714fa9e4066Sahrens if (strcmp(value, acl_inherit_table[i].name) 715fa9e4066Sahrens == 0) { 716fa9e4066Sahrens number = acl_inherit_table[i].value; 717fa9e4066Sahrens break; 718fa9e4066Sahrens } 719fa9e4066Sahrens } 720fa9e4066Sahrens 721fa9e4066Sahrens if (acl_inherit_table[i].name == NULL) { 72299653d4eSeschrock zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, 72399653d4eSeschrock "must be 'discard, 'noallow', 'secure', " 72499653d4eSeschrock "or 'passthrough'")); 72599653d4eSeschrock return (zfs_error(hdl, EZFS_BADPROP, errbuf)); 726fa9e4066Sahrens } 727fa9e4066Sahrens break; 728fa9e4066Sahrens 729fa9e4066Sahrens case ZFS_PROP_SHARENFS: 730fa9e4066Sahrens /* 731fa9e4066Sahrens * Nothing to do for 'sharenfs', this gets passed on to 732fa9e4066Sahrens * share(1M) verbatim. 733fa9e4066Sahrens */ 734fa9e4066Sahrens break; 735fa9e4066Sahrens } 736fa9e4066Sahrens } 737fa9e4066Sahrens 738fa9e4066Sahrens if (intval != NULL) 739fa9e4066Sahrens *intval = number; 740fa9e4066Sahrens 741fa9e4066Sahrens return (0); 742fa9e4066Sahrens } 743fa9e4066Sahrens 744fa9e4066Sahrens /* 745fa9e4066Sahrens * Given a property name and value, set the property for the given dataset. 746fa9e4066Sahrens */ 747fa9e4066Sahrens int 748fa9e4066Sahrens zfs_prop_set(zfs_handle_t *zhp, zfs_prop_t prop, const char *propval) 749fa9e4066Sahrens { 750fa9e4066Sahrens const char *propname = zfs_prop_to_name(prop); 751fa9e4066Sahrens uint64_t number; 752fa9e4066Sahrens zfs_cmd_t zc = { 0 }; 753fa9e4066Sahrens int ret; 754fa9e4066Sahrens prop_changelist_t *cl; 75599653d4eSeschrock char errbuf[1024]; 75699653d4eSeschrock libzfs_handle_t *hdl = zhp->zfs_hdl; 757fa9e4066Sahrens 75899653d4eSeschrock if (zfs_prop_validate(zhp->zfs_hdl, prop, propval, &number) != 0) 759fa9e4066Sahrens return (-1); 760fa9e4066Sahrens 76199653d4eSeschrock 76299653d4eSeschrock (void) snprintf(errbuf, sizeof (errbuf), 76399653d4eSeschrock dgettext(TEXT_DOMAIN, "cannot set %s for '%s'"), propname, 76499653d4eSeschrock zhp->zfs_name); 76599653d4eSeschrock 766fa9e4066Sahrens /* 767fa9e4066Sahrens * Check to see if the value applies to this type 768fa9e4066Sahrens */ 76999653d4eSeschrock if (!zfs_prop_valid_for_type(prop, zhp->zfs_type)) 77099653d4eSeschrock return (zfs_error(hdl, EZFS_PROPTYPE, errbuf)); 771fa9e4066Sahrens 772fa9e4066Sahrens /* 773fa9e4066Sahrens * For the mountpoint and sharenfs properties, check if it can be set 774fa9e4066Sahrens * in a global/non-global zone based on the zoned property value: 775fa9e4066Sahrens * 776fa9e4066Sahrens * global zone non-global zone 777fa9e4066Sahrens * ----------------------------------------------------- 778fa9e4066Sahrens * zoned=on mountpoint (no) mountpoint (yes) 779fa9e4066Sahrens * sharenfs (no) sharenfs (no) 780fa9e4066Sahrens * 781fa9e4066Sahrens * zoned=off mountpoint (yes) N/A 782fa9e4066Sahrens * sharenfs (yes) 783fa9e4066Sahrens */ 784fa9e4066Sahrens if (prop == ZFS_PROP_MOUNTPOINT || prop == ZFS_PROP_SHARENFS) { 785fa9e4066Sahrens if (zfs_prop_get_int(zhp, ZFS_PROP_ZONED)) { 786fa9e4066Sahrens if (getzoneid() == GLOBAL_ZONEID) { 78799653d4eSeschrock zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, 78899653d4eSeschrock "dataset is used in a non-global zone")); 78999653d4eSeschrock return (zfs_error(hdl, EZFS_ZONED, errbuf)); 790fa9e4066Sahrens } else if (prop == ZFS_PROP_SHARENFS) { 79199653d4eSeschrock zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, 79299653d4eSeschrock "filesystems cannot be shared in a " 79399653d4eSeschrock "non-global zone")); 79499653d4eSeschrock return (zfs_error(hdl, EZFS_ZONED, errbuf)); 795fa9e4066Sahrens } 796fa9e4066Sahrens } else if (getzoneid() != GLOBAL_ZONEID) { 797fa9e4066Sahrens /* 798fa9e4066Sahrens * If zoned property is 'off', this must be in 799fa9e4066Sahrens * a globle zone. If not, something is wrong. 800fa9e4066Sahrens */ 80199653d4eSeschrock zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, 80299653d4eSeschrock "dataset is used in a non-global zone, but " 80399653d4eSeschrock "'zoned' property is not set")); 80499653d4eSeschrock return (zfs_error(hdl, EZFS_ZONED, errbuf)); 805fa9e4066Sahrens } 806fa9e4066Sahrens } 807fa9e4066Sahrens 808fa9e4066Sahrens if ((cl = changelist_gather(zhp, prop, 0)) == NULL) 809fa9e4066Sahrens return (-1); 810fa9e4066Sahrens 811fa9e4066Sahrens if (prop == ZFS_PROP_MOUNTPOINT && changelist_haszonedchild(cl)) { 81299653d4eSeschrock zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, 81399653d4eSeschrock "child dataset with inherited mountpoint is used " 81499653d4eSeschrock "in a non-global zone")); 81599653d4eSeschrock ret = zfs_error(hdl, EZFS_ZONED, errbuf); 816fa9e4066Sahrens goto error; 817fa9e4066Sahrens } 818fa9e4066Sahrens 819fa9e4066Sahrens if ((ret = changelist_prefix(cl)) != 0) 820fa9e4066Sahrens goto error; 821fa9e4066Sahrens 822fa9e4066Sahrens /* 823fa9e4066Sahrens * Execute the corresponding ioctl() to set this property. 824fa9e4066Sahrens */ 825fa9e4066Sahrens (void) strlcpy(zc.zc_name, zhp->zfs_name, sizeof (zc.zc_name)); 826fa9e4066Sahrens 827fa9e4066Sahrens switch (prop) { 828fa9e4066Sahrens case ZFS_PROP_QUOTA: 829fa9e4066Sahrens zc.zc_cookie = number; 83099653d4eSeschrock ret = ioctl(zhp->zfs_hdl->libzfs_fd, ZFS_IOC_SET_QUOTA, &zc); 831fa9e4066Sahrens break; 832fa9e4066Sahrens case ZFS_PROP_RESERVATION: 833fa9e4066Sahrens zc.zc_cookie = number; 83499653d4eSeschrock ret = ioctl(zhp->zfs_hdl->libzfs_fd, ZFS_IOC_SET_RESERVATION, 83599653d4eSeschrock &zc); 836fa9e4066Sahrens break; 837fa9e4066Sahrens case ZFS_PROP_MOUNTPOINT: 838fa9e4066Sahrens case ZFS_PROP_SHARENFS: 839fa9e4066Sahrens /* 840fa9e4066Sahrens * These properties are passed down as real strings. 841fa9e4066Sahrens */ 842fa9e4066Sahrens (void) strlcpy(zc.zc_prop_name, propname, 843fa9e4066Sahrens sizeof (zc.zc_prop_name)); 844fa9e4066Sahrens (void) strlcpy(zc.zc_prop_value, propval, 845fa9e4066Sahrens sizeof (zc.zc_prop_value)); 846fa9e4066Sahrens zc.zc_intsz = 1; 847fa9e4066Sahrens zc.zc_numints = strlen(propval) + 1; 84899653d4eSeschrock ret = ioctl(zhp->zfs_hdl->libzfs_fd, ZFS_IOC_SET_PROP, &zc); 849fa9e4066Sahrens break; 850fa9e4066Sahrens case ZFS_PROP_VOLSIZE: 851fa9e4066Sahrens zc.zc_volsize = number; 85299653d4eSeschrock ret = ioctl(zhp->zfs_hdl->libzfs_fd, ZFS_IOC_SET_VOLSIZE, &zc); 853fa9e4066Sahrens break; 854fa9e4066Sahrens case ZFS_PROP_VOLBLOCKSIZE: 855fa9e4066Sahrens zc.zc_volblocksize = number; 85699653d4eSeschrock ret = ioctl(zhp->zfs_hdl->libzfs_fd, ZFS_IOC_SET_VOLBLOCKSIZE, 85799653d4eSeschrock &zc); 858fa9e4066Sahrens break; 859fa9e4066Sahrens default: 860fa9e4066Sahrens (void) strlcpy(zc.zc_prop_name, propname, 861fa9e4066Sahrens sizeof (zc.zc_prop_name)); 862fa9e4066Sahrens /* LINTED - alignment */ 863fa9e4066Sahrens *(uint64_t *)zc.zc_prop_value = number; 864fa9e4066Sahrens zc.zc_intsz = 8; 865fa9e4066Sahrens zc.zc_numints = 1; 86699653d4eSeschrock ret = ioctl(zhp->zfs_hdl->libzfs_fd, ZFS_IOC_SET_PROP, &zc); 867fa9e4066Sahrens break; 868fa9e4066Sahrens } 869fa9e4066Sahrens 870fa9e4066Sahrens if (ret != 0) { 871fa9e4066Sahrens switch (errno) { 872fa9e4066Sahrens 873fa9e4066Sahrens case ENOSPC: 874fa9e4066Sahrens /* 875fa9e4066Sahrens * For quotas and reservations, ENOSPC indicates 876fa9e4066Sahrens * something different; setting a quota or reservation 877fa9e4066Sahrens * doesn't use any disk space. 878fa9e4066Sahrens */ 879fa9e4066Sahrens switch (prop) { 880fa9e4066Sahrens case ZFS_PROP_QUOTA: 88199653d4eSeschrock zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, 88299653d4eSeschrock "size is less than current used or " 88399653d4eSeschrock "reserved space")); 88499653d4eSeschrock (void) zfs_error(hdl, EZFS_PROPSPACE, errbuf); 885fa9e4066Sahrens break; 886fa9e4066Sahrens 887fa9e4066Sahrens case ZFS_PROP_RESERVATION: 88899653d4eSeschrock zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, 88999653d4eSeschrock "size is greater than available space")); 89099653d4eSeschrock (void) zfs_error(hdl, EZFS_PROPSPACE, errbuf); 891fa9e4066Sahrens break; 892fa9e4066Sahrens 893fa9e4066Sahrens default: 89499653d4eSeschrock (void) zfs_standard_error(hdl, errno, errbuf); 895fa9e4066Sahrens break; 896fa9e4066Sahrens } 897fa9e4066Sahrens break; 898fa9e4066Sahrens 899fa9e4066Sahrens case EBUSY: 90099653d4eSeschrock if (prop == ZFS_PROP_VOLBLOCKSIZE) 90199653d4eSeschrock (void) zfs_error(hdl, EZFS_VOLHASDATA, errbuf); 90299653d4eSeschrock else 90399653d4eSeschrock return (zfs_standard_error(hdl, EBUSY, errbuf)); 904fa9e4066Sahrens break; 905fa9e4066Sahrens 9062a79c5feSlling case EROFS: 90799653d4eSeschrock (void) zfs_error(hdl, EZFS_DSREADONLY, errbuf); 9082a79c5feSlling break; 9092a79c5feSlling 910fa9e4066Sahrens case EOVERFLOW: 911fa9e4066Sahrens /* 912fa9e4066Sahrens * This platform can't address a volume this big. 913fa9e4066Sahrens */ 914fa9e4066Sahrens #ifdef _ILP32 915fa9e4066Sahrens if (prop == ZFS_PROP_VOLSIZE) { 91699653d4eSeschrock (void) zfs_error(hdl, EZFS_VOLTOOBIG, errbuf); 917fa9e4066Sahrens break; 918fa9e4066Sahrens } 919fa9e4066Sahrens #endif 92099653d4eSeschrock /* FALLTHROUGH */ 921fa9e4066Sahrens default: 92299653d4eSeschrock (void) zfs_standard_error(hdl, errno, errbuf); 923fa9e4066Sahrens } 924fa9e4066Sahrens } else { 925fa9e4066Sahrens /* 926fa9e4066Sahrens * Refresh the statistics so the new property value 927fa9e4066Sahrens * is reflected. 928fa9e4066Sahrens */ 929fa9e4066Sahrens if ((ret = changelist_postfix(cl)) != 0) 930fa9e4066Sahrens goto error; 931fa9e4066Sahrens 932fa9e4066Sahrens (void) get_stats(zhp); 933fa9e4066Sahrens } 934fa9e4066Sahrens 935fa9e4066Sahrens error: 936fa9e4066Sahrens changelist_free(cl); 937fa9e4066Sahrens return (ret); 938fa9e4066Sahrens } 939fa9e4066Sahrens 940fa9e4066Sahrens /* 941fa9e4066Sahrens * Given a property, inherit the value from the parent dataset. 942fa9e4066Sahrens */ 943fa9e4066Sahrens int 944fa9e4066Sahrens zfs_prop_inherit(zfs_handle_t *zhp, zfs_prop_t prop) 945fa9e4066Sahrens { 946fa9e4066Sahrens const char *propname = zfs_prop_to_name(prop); 947fa9e4066Sahrens zfs_cmd_t zc = { 0 }; 948fa9e4066Sahrens int ret; 949fa9e4066Sahrens prop_changelist_t *cl; 95099653d4eSeschrock libzfs_handle_t *hdl = zhp->zfs_hdl; 95199653d4eSeschrock char errbuf[1024]; 95299653d4eSeschrock 95399653d4eSeschrock (void) snprintf(errbuf, sizeof (errbuf), dgettext(TEXT_DOMAIN, 95499653d4eSeschrock "cannot inherit %s for '%s'"), propname, zhp->zfs_name); 955fa9e4066Sahrens 956fa9e4066Sahrens /* 957fa9e4066Sahrens * Verify that this property is inheritable. 958fa9e4066Sahrens */ 95999653d4eSeschrock if (zfs_prop_readonly(prop)) 96099653d4eSeschrock return (zfs_error(hdl, EZFS_PROPREADONLY, errbuf)); 961fa9e4066Sahrens 96299653d4eSeschrock if (!zfs_prop_inheritable(prop)) 96399653d4eSeschrock return (zfs_error(hdl, EZFS_PROPNONINHERIT, errbuf)); 964fa9e4066Sahrens 965fa9e4066Sahrens /* 966fa9e4066Sahrens * Check to see if the value applies to this type 967fa9e4066Sahrens */ 96899653d4eSeschrock if (!zfs_prop_valid_for_type(prop, zhp->zfs_type)) 96999653d4eSeschrock return (zfs_error(hdl, EZFS_PROPTYPE, errbuf)); 970fa9e4066Sahrens 971fa9e4066Sahrens (void) strlcpy(zc.zc_name, zhp->zfs_name, sizeof (zc.zc_name)); 972fa9e4066Sahrens (void) strlcpy(zc.zc_prop_name, propname, sizeof (zc.zc_prop_name)); 973fa9e4066Sahrens 974fa9e4066Sahrens if (prop == ZFS_PROP_MOUNTPOINT && getzoneid() == GLOBAL_ZONEID && 975fa9e4066Sahrens zfs_prop_get_int(zhp, ZFS_PROP_ZONED)) { 97699653d4eSeschrock zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, 97799653d4eSeschrock "dataset is used in a non-global zone")); 97899653d4eSeschrock return (zfs_error(hdl, EZFS_ZONED, errbuf)); 979fa9e4066Sahrens } 980fa9e4066Sahrens 981fa9e4066Sahrens /* 982fa9e4066Sahrens * Determine datasets which will be affected by this change, if any. 983fa9e4066Sahrens */ 984fa9e4066Sahrens if ((cl = changelist_gather(zhp, prop, 0)) == NULL) 985fa9e4066Sahrens return (-1); 986fa9e4066Sahrens 987fa9e4066Sahrens if (prop == ZFS_PROP_MOUNTPOINT && changelist_haszonedchild(cl)) { 98899653d4eSeschrock zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, 98999653d4eSeschrock "child dataset with inherited mountpoint is used " 99099653d4eSeschrock "in a non-global zone")); 99199653d4eSeschrock ret = zfs_error(hdl, EZFS_ZONED, errbuf); 992fa9e4066Sahrens goto error; 993fa9e4066Sahrens } 994fa9e4066Sahrens 995fa9e4066Sahrens if ((ret = changelist_prefix(cl)) != 0) 996fa9e4066Sahrens goto error; 997fa9e4066Sahrens 998fa9e4066Sahrens zc.zc_numints = 0; 999fa9e4066Sahrens 100099653d4eSeschrock if ((ret = ioctl(zhp->zfs_hdl->libzfs_fd, 100199653d4eSeschrock ZFS_IOC_SET_PROP, &zc)) != 0) { 100299653d4eSeschrock return (zfs_standard_error(hdl, errno, errbuf)); 1003fa9e4066Sahrens } else { 1004fa9e4066Sahrens 1005efc555ebSnd if ((ret = changelist_postfix(cl)) != 0) 1006fa9e4066Sahrens goto error; 1007fa9e4066Sahrens 1008fa9e4066Sahrens /* 1009fa9e4066Sahrens * Refresh the statistics so the new property is reflected. 1010fa9e4066Sahrens */ 1011fa9e4066Sahrens (void) get_stats(zhp); 1012fa9e4066Sahrens } 1013fa9e4066Sahrens 1014fa9e4066Sahrens 1015fa9e4066Sahrens error: 1016fa9e4066Sahrens changelist_free(cl); 1017fa9e4066Sahrens return (ret); 1018fa9e4066Sahrens } 1019fa9e4066Sahrens 1020fa9e4066Sahrens static void 1021fa9e4066Sahrens nicebool(int value, char *buf, size_t buflen) 1022fa9e4066Sahrens { 1023fa9e4066Sahrens if (value) 1024fa9e4066Sahrens (void) strlcpy(buf, "on", buflen); 1025fa9e4066Sahrens else 1026fa9e4066Sahrens (void) strlcpy(buf, "off", buflen); 1027fa9e4066Sahrens } 1028fa9e4066Sahrens 10297f7322feSeschrock /* 10307f7322feSeschrock * True DSL properties are stored in an nvlist. The following two functions 10317f7322feSeschrock * extract them appropriately. 10327f7322feSeschrock */ 10337f7322feSeschrock static uint64_t 10347f7322feSeschrock getprop_uint64(zfs_handle_t *zhp, zfs_prop_t prop, char **source) 10357f7322feSeschrock { 10367f7322feSeschrock nvlist_t *nv; 10377f7322feSeschrock uint64_t value; 10387f7322feSeschrock 10397f7322feSeschrock if (nvlist_lookup_nvlist(zhp->zfs_props, 10407f7322feSeschrock zfs_prop_to_name(prop), &nv) == 0) { 10417f7322feSeschrock verify(nvlist_lookup_uint64(nv, ZFS_PROP_VALUE, &value) == 0); 10427f7322feSeschrock verify(nvlist_lookup_string(nv, ZFS_PROP_SOURCE, source) == 0); 10437f7322feSeschrock } else { 10447f7322feSeschrock value = zfs_prop_default_numeric(prop); 10457f7322feSeschrock *source = ""; 10467f7322feSeschrock } 10477f7322feSeschrock 10487f7322feSeschrock return (value); 10497f7322feSeschrock } 10507f7322feSeschrock 10517f7322feSeschrock static char * 10527f7322feSeschrock getprop_string(zfs_handle_t *zhp, zfs_prop_t prop, char **source) 10537f7322feSeschrock { 10547f7322feSeschrock nvlist_t *nv; 10557f7322feSeschrock char *value; 10567f7322feSeschrock 10577f7322feSeschrock if (nvlist_lookup_nvlist(zhp->zfs_props, 10587f7322feSeschrock zfs_prop_to_name(prop), &nv) == 0) { 10597f7322feSeschrock verify(nvlist_lookup_string(nv, ZFS_PROP_VALUE, &value) == 0); 10607f7322feSeschrock verify(nvlist_lookup_string(nv, ZFS_PROP_SOURCE, source) == 0); 10617f7322feSeschrock } else { 10627f7322feSeschrock if ((value = (char *)zfs_prop_default_string(prop)) == NULL) 10637f7322feSeschrock value = ""; 10647f7322feSeschrock *source = ""; 10657f7322feSeschrock } 10667f7322feSeschrock 10677f7322feSeschrock return (value); 10687f7322feSeschrock } 10697f7322feSeschrock 1070fa9e4066Sahrens /* 1071fa9e4066Sahrens * Internal function for getting a numeric property. Both zfs_prop_get() and 1072fa9e4066Sahrens * zfs_prop_get_int() are built using this interface. 1073fa9e4066Sahrens * 1074fa9e4066Sahrens * Certain properties can be overridden using 'mount -o'. In this case, scan 1075fa9e4066Sahrens * the contents of the /etc/mnttab entry, searching for the appropriate options. 1076fa9e4066Sahrens * If they differ from the on-disk values, report the current values and mark 1077fa9e4066Sahrens * the source "temporary". 1078fa9e4066Sahrens */ 107999653d4eSeschrock static int 1080fa9e4066Sahrens get_numeric_property(zfs_handle_t *zhp, zfs_prop_t prop, zfs_source_t *src, 108199653d4eSeschrock char **source, uint64_t *val) 1082fa9e4066Sahrens { 1083fa9e4066Sahrens struct mnttab mnt; 1084fa9e4066Sahrens 1085fa9e4066Sahrens *source = NULL; 1086fa9e4066Sahrens 1087fa9e4066Sahrens if (zhp->zfs_mntopts == NULL) 1088fa9e4066Sahrens mnt.mnt_mntopts = ""; 1089fa9e4066Sahrens else 1090fa9e4066Sahrens mnt.mnt_mntopts = zhp->zfs_mntopts; 1091fa9e4066Sahrens 1092fa9e4066Sahrens switch (prop) { 1093fa9e4066Sahrens case ZFS_PROP_ATIME: 109499653d4eSeschrock *val = getprop_uint64(zhp, prop, source); 1095fa9e4066Sahrens 109699653d4eSeschrock if (hasmntopt(&mnt, MNTOPT_ATIME) && !*val) { 109799653d4eSeschrock *val = B_TRUE; 1098fa9e4066Sahrens if (src) 1099fa9e4066Sahrens *src = ZFS_SRC_TEMPORARY; 110099653d4eSeschrock } else if (hasmntopt(&mnt, MNTOPT_NOATIME) && *val) { 110199653d4eSeschrock *val = B_FALSE; 1102fa9e4066Sahrens if (src) 1103fa9e4066Sahrens *src = ZFS_SRC_TEMPORARY; 1104fa9e4066Sahrens } 110599653d4eSeschrock break; 1106fa9e4066Sahrens 1107fa9e4066Sahrens case ZFS_PROP_AVAILABLE: 110899653d4eSeschrock *val = zhp->zfs_dmustats.dds_available; 110999653d4eSeschrock break; 1110fa9e4066Sahrens 1111fa9e4066Sahrens case ZFS_PROP_DEVICES: 111299653d4eSeschrock *val = getprop_uint64(zhp, prop, source); 1113fa9e4066Sahrens 111499653d4eSeschrock if (hasmntopt(&mnt, MNTOPT_DEVICES) && !*val) { 111599653d4eSeschrock *val = B_TRUE; 1116fa9e4066Sahrens if (src) 1117fa9e4066Sahrens *src = ZFS_SRC_TEMPORARY; 111899653d4eSeschrock } else if (hasmntopt(&mnt, MNTOPT_NODEVICES) && *val) { 111999653d4eSeschrock *val = B_FALSE; 1120fa9e4066Sahrens if (src) 1121fa9e4066Sahrens *src = ZFS_SRC_TEMPORARY; 1122fa9e4066Sahrens } 112399653d4eSeschrock break; 1124fa9e4066Sahrens 1125fa9e4066Sahrens case ZFS_PROP_EXEC: 112699653d4eSeschrock *val = getprop_uint64(zhp, prop, source); 1127fa9e4066Sahrens 112899653d4eSeschrock if (hasmntopt(&mnt, MNTOPT_EXEC) && !*val) { 112999653d4eSeschrock *val = B_TRUE; 1130fa9e4066Sahrens if (src) 1131fa9e4066Sahrens *src = ZFS_SRC_TEMPORARY; 113299653d4eSeschrock } else if (hasmntopt(&mnt, MNTOPT_NOEXEC) && *val) { 113399653d4eSeschrock *val = B_FALSE; 1134fa9e4066Sahrens if (src) 1135fa9e4066Sahrens *src = ZFS_SRC_TEMPORARY; 1136fa9e4066Sahrens } 113799653d4eSeschrock break; 1138fa9e4066Sahrens 1139fa9e4066Sahrens case ZFS_PROP_RECORDSIZE: 1140fa9e4066Sahrens case ZFS_PROP_COMPRESSION: 11417f7322feSeschrock case ZFS_PROP_ZONED: 114299653d4eSeschrock *val = getprop_uint64(zhp, prop, source); 114399653d4eSeschrock break; 1144fa9e4066Sahrens 1145fa9e4066Sahrens case ZFS_PROP_READONLY: 114699653d4eSeschrock *val = getprop_uint64(zhp, prop, source); 1147fa9e4066Sahrens 114899653d4eSeschrock if (hasmntopt(&mnt, MNTOPT_RO) && !*val) { 114999653d4eSeschrock *val = B_TRUE; 1150fa9e4066Sahrens if (src) 1151fa9e4066Sahrens *src = ZFS_SRC_TEMPORARY; 115299653d4eSeschrock } else if (hasmntopt(&mnt, MNTOPT_RW) && *val) { 115399653d4eSeschrock *val = B_FALSE; 1154fa9e4066Sahrens if (src) 1155fa9e4066Sahrens *src = ZFS_SRC_TEMPORARY; 1156fa9e4066Sahrens } 115799653d4eSeschrock break; 1158fa9e4066Sahrens 1159ea8dc4b6Seschrock case ZFS_PROP_CREATION: 116099653d4eSeschrock *val = zhp->zfs_dmustats.dds_creation_time; 116199653d4eSeschrock break; 1162ea8dc4b6Seschrock 1163fa9e4066Sahrens case ZFS_PROP_QUOTA: 1164fa9e4066Sahrens if (zhp->zfs_dmustats.dds_quota == 0) 1165fa9e4066Sahrens *source = ""; /* default */ 1166fa9e4066Sahrens else 1167fa9e4066Sahrens *source = zhp->zfs_name; 116899653d4eSeschrock *val = zhp->zfs_dmustats.dds_quota; 116999653d4eSeschrock break; 1170fa9e4066Sahrens 1171fa9e4066Sahrens case ZFS_PROP_RESERVATION: 1172fa9e4066Sahrens if (zhp->zfs_dmustats.dds_reserved == 0) 1173fa9e4066Sahrens *source = ""; /* default */ 1174fa9e4066Sahrens else 1175fa9e4066Sahrens *source = zhp->zfs_name; 117699653d4eSeschrock *val = zhp->zfs_dmustats.dds_reserved; 117799653d4eSeschrock break; 1178fa9e4066Sahrens 1179fa9e4066Sahrens case ZFS_PROP_COMPRESSRATIO: 1180fa9e4066Sahrens /* 1181fa9e4066Sahrens * Using physical space and logical space, calculate the 1182fa9e4066Sahrens * compression ratio. We return the number as a multiple of 1183fa9e4066Sahrens * 100, so '2.5x' would be returned as 250. 1184fa9e4066Sahrens */ 1185fa9e4066Sahrens if (zhp->zfs_dmustats.dds_compressed_bytes == 0) 118699653d4eSeschrock *val = 100ULL; 1187fa9e4066Sahrens else 118899653d4eSeschrock *val = 118999653d4eSeschrock (zhp->zfs_dmustats.dds_uncompressed_bytes * 100 / 1190fa9e4066Sahrens zhp->zfs_dmustats.dds_compressed_bytes); 119199653d4eSeschrock break; 1192fa9e4066Sahrens 1193fa9e4066Sahrens case ZFS_PROP_REFERENCED: 1194fa9e4066Sahrens /* 1195fa9e4066Sahrens * 'referenced' refers to the amount of physical space 1196fa9e4066Sahrens * referenced (possibly shared) by this object. 1197fa9e4066Sahrens */ 119899653d4eSeschrock *val = zhp->zfs_dmustats.dds_space_refd; 119999653d4eSeschrock break; 1200fa9e4066Sahrens 1201fa9e4066Sahrens case ZFS_PROP_SETUID: 120299653d4eSeschrock *val = getprop_uint64(zhp, prop, source); 1203fa9e4066Sahrens 120499653d4eSeschrock if (hasmntopt(&mnt, MNTOPT_SETUID) && !*val) { 120599653d4eSeschrock *val = B_TRUE; 1206fa9e4066Sahrens if (src) 1207fa9e4066Sahrens *src = ZFS_SRC_TEMPORARY; 120899653d4eSeschrock } else if (hasmntopt(&mnt, MNTOPT_NOSETUID) && *val) { 120999653d4eSeschrock *val = B_FALSE; 1210fa9e4066Sahrens if (src) 1211fa9e4066Sahrens *src = ZFS_SRC_TEMPORARY; 1212fa9e4066Sahrens } 121399653d4eSeschrock break; 1214fa9e4066Sahrens 1215fa9e4066Sahrens case ZFS_PROP_VOLSIZE: 121699653d4eSeschrock *val = zhp->zfs_volsize; 121799653d4eSeschrock break; 1218fa9e4066Sahrens 1219fa9e4066Sahrens case ZFS_PROP_VOLBLOCKSIZE: 122099653d4eSeschrock *val = zhp->zfs_volblocksize; 122199653d4eSeschrock break; 1222fa9e4066Sahrens 1223fa9e4066Sahrens case ZFS_PROP_USED: 122499653d4eSeschrock *val = zhp->zfs_dmustats.dds_space_used; 122599653d4eSeschrock break; 1226fa9e4066Sahrens 1227fa9e4066Sahrens case ZFS_PROP_CREATETXG: 122899653d4eSeschrock *val = zhp->zfs_dmustats.dds_creation_txg; 122999653d4eSeschrock break; 1230fa9e4066Sahrens 1231fa9e4066Sahrens case ZFS_PROP_MOUNTED: 1232fa9e4066Sahrens /* 1233fa9e4066Sahrens * Unlike other properties, we defer calculation of 'MOUNTED' 1234fa9e4066Sahrens * until actually requested. This is because the getmntany() 1235fa9e4066Sahrens * call can be extremely expensive on systems with a large 1236fa9e4066Sahrens * number of filesystems, and the property isn't needed in 1237fa9e4066Sahrens * normal use cases. 1238fa9e4066Sahrens */ 1239fa9e4066Sahrens if (zhp->zfs_mntopts == NULL) { 1240fa9e4066Sahrens struct mnttab search = { 0 }, entry; 1241fa9e4066Sahrens 1242fa9e4066Sahrens search.mnt_special = (char *)zhp->zfs_name; 124396dedd18Snd search.mnt_fstype = MNTTYPE_ZFS; 124499653d4eSeschrock rewind(zhp->zfs_hdl->libzfs_mnttab); 1245fa9e4066Sahrens 124699653d4eSeschrock if (getmntany(zhp->zfs_hdl->libzfs_mnttab, &entry, 124799653d4eSeschrock &search) == 0 && (zhp->zfs_mntopts = 124899653d4eSeschrock zfs_strdup(zhp->zfs_hdl, 124999653d4eSeschrock entry.mnt_mntopts)) == NULL) 125099653d4eSeschrock return (-1); 1251fa9e4066Sahrens } 125299653d4eSeschrock *val = (zhp->zfs_mntopts != NULL); 125399653d4eSeschrock break; 1254fa9e4066Sahrens 1255fa9e4066Sahrens default: 125699653d4eSeschrock zfs_error_aux(zhp->zfs_hdl, dgettext(TEXT_DOMAIN, 125799653d4eSeschrock "cannot get non-numeric property")); 125899653d4eSeschrock return (zfs_error(zhp->zfs_hdl, EZFS_BADPROP, 125999653d4eSeschrock dgettext(TEXT_DOMAIN, "internal error"))); 1260fa9e4066Sahrens } 1261fa9e4066Sahrens 1262fa9e4066Sahrens return (0); 1263fa9e4066Sahrens } 1264fa9e4066Sahrens 1265fa9e4066Sahrens /* 1266fa9e4066Sahrens * Calculate the source type, given the raw source string. 1267fa9e4066Sahrens */ 1268fa9e4066Sahrens static void 1269fa9e4066Sahrens get_source(zfs_handle_t *zhp, zfs_source_t *srctype, char *source, 1270fa9e4066Sahrens char *statbuf, size_t statlen) 1271fa9e4066Sahrens { 1272fa9e4066Sahrens if (statbuf == NULL || *srctype == ZFS_SRC_TEMPORARY) 1273fa9e4066Sahrens return; 1274fa9e4066Sahrens 1275fa9e4066Sahrens if (source == NULL) { 1276fa9e4066Sahrens *srctype = ZFS_SRC_NONE; 1277fa9e4066Sahrens } else if (source[0] == '\0') { 1278fa9e4066Sahrens *srctype = ZFS_SRC_DEFAULT; 1279fa9e4066Sahrens } else { 1280fa9e4066Sahrens if (strcmp(source, zhp->zfs_name) == 0) { 1281fa9e4066Sahrens *srctype = ZFS_SRC_LOCAL; 1282fa9e4066Sahrens } else { 1283fa9e4066Sahrens (void) strlcpy(statbuf, source, statlen); 1284fa9e4066Sahrens *srctype = ZFS_SRC_INHERITED; 1285fa9e4066Sahrens } 1286fa9e4066Sahrens } 1287fa9e4066Sahrens 1288fa9e4066Sahrens } 1289fa9e4066Sahrens 1290fa9e4066Sahrens /* 1291fa9e4066Sahrens * Retrieve a property from the given object. If 'literal' is specified, then 1292fa9e4066Sahrens * numbers are left as exact values. Otherwise, numbers are converted to a 1293fa9e4066Sahrens * human-readable form. 1294fa9e4066Sahrens * 1295fa9e4066Sahrens * Returns 0 on success, or -1 on error. 1296fa9e4066Sahrens */ 1297fa9e4066Sahrens int 1298fa9e4066Sahrens zfs_prop_get(zfs_handle_t *zhp, zfs_prop_t prop, char *propbuf, size_t proplen, 129999653d4eSeschrock zfs_source_t *src, char *statbuf, size_t statlen, boolean_t literal) 1300fa9e4066Sahrens { 1301fa9e4066Sahrens char *source = NULL; 1302fa9e4066Sahrens uint64_t val; 1303fa9e4066Sahrens char *str; 1304fa9e4066Sahrens int i; 1305fa9e4066Sahrens const char *root; 1306fa9e4066Sahrens 1307fa9e4066Sahrens /* 1308fa9e4066Sahrens * Check to see if this property applies to our object 1309fa9e4066Sahrens */ 1310fa9e4066Sahrens if (!zfs_prop_valid_for_type(prop, zhp->zfs_type)) 1311fa9e4066Sahrens return (-1); 1312fa9e4066Sahrens 1313fa9e4066Sahrens if (src) 1314fa9e4066Sahrens *src = ZFS_SRC_NONE; 1315fa9e4066Sahrens 1316fa9e4066Sahrens switch (prop) { 1317fa9e4066Sahrens case ZFS_PROP_ATIME: 1318fa9e4066Sahrens case ZFS_PROP_READONLY: 1319fa9e4066Sahrens case ZFS_PROP_SETUID: 1320fa9e4066Sahrens case ZFS_PROP_ZONED: 1321fa9e4066Sahrens case ZFS_PROP_DEVICES: 1322fa9e4066Sahrens case ZFS_PROP_EXEC: 1323fa9e4066Sahrens /* 1324fa9e4066Sahrens * Basic boolean values are built on top of 1325fa9e4066Sahrens * get_numeric_property(). 1326fa9e4066Sahrens */ 132799653d4eSeschrock if (get_numeric_property(zhp, prop, src, &source, &val) != 0) 132899653d4eSeschrock return (-1); 132999653d4eSeschrock nicebool(val, propbuf, proplen); 1330fa9e4066Sahrens 1331fa9e4066Sahrens break; 1332fa9e4066Sahrens 1333fa9e4066Sahrens case ZFS_PROP_AVAILABLE: 1334fa9e4066Sahrens case ZFS_PROP_RECORDSIZE: 1335fa9e4066Sahrens case ZFS_PROP_CREATETXG: 1336fa9e4066Sahrens case ZFS_PROP_REFERENCED: 1337fa9e4066Sahrens case ZFS_PROP_USED: 1338fa9e4066Sahrens case ZFS_PROP_VOLSIZE: 1339fa9e4066Sahrens case ZFS_PROP_VOLBLOCKSIZE: 1340fa9e4066Sahrens /* 1341fa9e4066Sahrens * Basic numeric values are built on top of 1342fa9e4066Sahrens * get_numeric_property(). 1343fa9e4066Sahrens */ 134499653d4eSeschrock if (get_numeric_property(zhp, prop, src, &source, &val) != 0) 134599653d4eSeschrock return (-1); 1346fa9e4066Sahrens if (literal) 1347fa9e4066Sahrens (void) snprintf(propbuf, proplen, "%llu", val); 1348fa9e4066Sahrens else 1349fa9e4066Sahrens zfs_nicenum(val, propbuf, proplen); 1350fa9e4066Sahrens break; 1351fa9e4066Sahrens 1352fa9e4066Sahrens case ZFS_PROP_COMPRESSION: 13537f7322feSeschrock val = getprop_uint64(zhp, prop, &source); 1354fa9e4066Sahrens for (i = 0; compress_table[i].name != NULL; i++) { 13557f7322feSeschrock if (compress_table[i].value == val) 1356fa9e4066Sahrens break; 1357fa9e4066Sahrens } 1358fa9e4066Sahrens assert(compress_table[i].name != NULL); 1359fa9e4066Sahrens (void) strlcpy(propbuf, compress_table[i].name, proplen); 1360fa9e4066Sahrens break; 1361fa9e4066Sahrens 1362fa9e4066Sahrens case ZFS_PROP_CHECKSUM: 13637f7322feSeschrock val = getprop_uint64(zhp, prop, &source); 1364fa9e4066Sahrens for (i = 0; checksum_table[i].name != NULL; i++) { 13657f7322feSeschrock if (checksum_table[i].value == val) 1366fa9e4066Sahrens break; 1367fa9e4066Sahrens } 1368fa9e4066Sahrens assert(checksum_table[i].name != NULL); 1369fa9e4066Sahrens (void) strlcpy(propbuf, checksum_table[i].name, proplen); 1370fa9e4066Sahrens break; 1371fa9e4066Sahrens 1372fa9e4066Sahrens case ZFS_PROP_SNAPDIR: 13737f7322feSeschrock val = getprop_uint64(zhp, prop, &source); 1374fa9e4066Sahrens for (i = 0; snapdir_table[i].name != NULL; i++) { 13757f7322feSeschrock if (snapdir_table[i].value == val) 1376fa9e4066Sahrens break; 1377fa9e4066Sahrens } 1378fa9e4066Sahrens assert(snapdir_table[i].name != NULL); 1379fa9e4066Sahrens (void) strlcpy(propbuf, snapdir_table[i].name, proplen); 1380fa9e4066Sahrens break; 1381fa9e4066Sahrens 1382fa9e4066Sahrens case ZFS_PROP_ACLMODE: 13837f7322feSeschrock val = getprop_uint64(zhp, prop, &source); 1384fa9e4066Sahrens for (i = 0; acl_mode_table[i].name != NULL; i++) { 13857f7322feSeschrock if (acl_mode_table[i].value == val) 1386fa9e4066Sahrens break; 1387fa9e4066Sahrens } 1388fa9e4066Sahrens assert(acl_mode_table[i].name != NULL); 1389fa9e4066Sahrens (void) strlcpy(propbuf, acl_mode_table[i].name, proplen); 1390fa9e4066Sahrens break; 1391fa9e4066Sahrens 1392fa9e4066Sahrens case ZFS_PROP_ACLINHERIT: 13937f7322feSeschrock val = getprop_uint64(zhp, prop, &source); 1394fa9e4066Sahrens for (i = 0; acl_inherit_table[i].name != NULL; i++) { 13957f7322feSeschrock if (acl_inherit_table[i].value == val) 1396fa9e4066Sahrens break; 1397fa9e4066Sahrens } 1398fa9e4066Sahrens assert(acl_inherit_table[i].name != NULL); 1399fa9e4066Sahrens (void) strlcpy(propbuf, acl_inherit_table[i].name, proplen); 1400fa9e4066Sahrens break; 1401fa9e4066Sahrens 1402fa9e4066Sahrens case ZFS_PROP_CREATION: 1403fa9e4066Sahrens /* 1404fa9e4066Sahrens * 'creation' is a time_t stored in the statistics. We convert 1405fa9e4066Sahrens * this into a string unless 'literal' is specified. 1406fa9e4066Sahrens */ 1407fa9e4066Sahrens { 1408fa9e4066Sahrens time_t time = (time_t) 1409fa9e4066Sahrens zhp->zfs_dmustats.dds_creation_time; 1410fa9e4066Sahrens struct tm t; 1411fa9e4066Sahrens 1412fa9e4066Sahrens if (literal || 1413fa9e4066Sahrens localtime_r(&time, &t) == NULL || 1414fa9e4066Sahrens strftime(propbuf, proplen, "%a %b %e %k:%M %Y", 1415fa9e4066Sahrens &t) == 0) 1416fa9e4066Sahrens (void) snprintf(propbuf, proplen, "%llu", 1417fa9e4066Sahrens zhp->zfs_dmustats.dds_creation_time); 1418fa9e4066Sahrens } 1419fa9e4066Sahrens break; 1420fa9e4066Sahrens 1421fa9e4066Sahrens case ZFS_PROP_MOUNTPOINT: 1422fa9e4066Sahrens /* 1423fa9e4066Sahrens * Getting the precise mountpoint can be tricky. 1424fa9e4066Sahrens * 1425fa9e4066Sahrens * - for 'none' or 'legacy', return those values. 1426fa9e4066Sahrens * - for default mountpoints, construct it as /zfs/<dataset> 1427fa9e4066Sahrens * - for inherited mountpoints, we want to take everything 1428fa9e4066Sahrens * after our ancestor and append it to the inherited value. 1429fa9e4066Sahrens * 1430fa9e4066Sahrens * If the pool has an alternate root, we want to prepend that 1431fa9e4066Sahrens * root to any values we return. 1432fa9e4066Sahrens */ 1433ea8dc4b6Seschrock root = zhp->zfs_root; 14347f7322feSeschrock str = getprop_string(zhp, prop, &source); 1435fa9e4066Sahrens 14367f7322feSeschrock if (str[0] == '\0') { 1437fa9e4066Sahrens (void) snprintf(propbuf, proplen, "%s/zfs/%s", 1438fa9e4066Sahrens root, zhp->zfs_name); 14397f7322feSeschrock } else if (str[0] == '/') { 14407f7322feSeschrock const char *relpath = zhp->zfs_name + strlen(source); 1441fa9e4066Sahrens 1442fa9e4066Sahrens if (relpath[0] == '/') 1443fa9e4066Sahrens relpath++; 14447f7322feSeschrock if (str[1] == '\0') 14457f7322feSeschrock str++; 1446fa9e4066Sahrens 1447fa9e4066Sahrens if (relpath[0] == '\0') 1448fa9e4066Sahrens (void) snprintf(propbuf, proplen, "%s%s", 14497f7322feSeschrock root, str); 1450fa9e4066Sahrens else 1451fa9e4066Sahrens (void) snprintf(propbuf, proplen, "%s%s%s%s", 14527f7322feSeschrock root, str, relpath[0] == '@' ? "" : "/", 1453fa9e4066Sahrens relpath); 1454fa9e4066Sahrens } else { 1455fa9e4066Sahrens /* 'legacy' or 'none' */ 14567f7322feSeschrock (void) strlcpy(propbuf, str, proplen); 1457fa9e4066Sahrens } 1458fa9e4066Sahrens 1459fa9e4066Sahrens break; 1460fa9e4066Sahrens 1461fa9e4066Sahrens case ZFS_PROP_SHARENFS: 14627f7322feSeschrock (void) strlcpy(propbuf, getprop_string(zhp, prop, &source), 14637f7322feSeschrock proplen); 1464fa9e4066Sahrens break; 1465fa9e4066Sahrens 1466fa9e4066Sahrens case ZFS_PROP_ORIGIN: 1467ea8dc4b6Seschrock (void) strlcpy(propbuf, zhp->zfs_dmustats.dds_clone_of, 1468fa9e4066Sahrens proplen); 1469fa9e4066Sahrens /* 1470fa9e4066Sahrens * If there is no parent at all, return failure to indicate that 1471fa9e4066Sahrens * it doesn't apply to this dataset. 1472fa9e4066Sahrens */ 1473fa9e4066Sahrens if (propbuf[0] == '\0') 1474fa9e4066Sahrens return (-1); 1475fa9e4066Sahrens break; 1476fa9e4066Sahrens 1477fa9e4066Sahrens case ZFS_PROP_QUOTA: 1478fa9e4066Sahrens case ZFS_PROP_RESERVATION: 147999653d4eSeschrock if (get_numeric_property(zhp, prop, src, &source, &val) != 0) 148099653d4eSeschrock return (-1); 1481fa9e4066Sahrens 1482fa9e4066Sahrens /* 1483fa9e4066Sahrens * If quota or reservation is 0, we translate this into 'none' 1484fa9e4066Sahrens * (unless literal is set), and indicate that it's the default 1485fa9e4066Sahrens * value. Otherwise, we print the number nicely and indicate 1486fa9e4066Sahrens * that its set locally. 1487fa9e4066Sahrens */ 1488fa9e4066Sahrens if (val == 0) { 1489fa9e4066Sahrens if (literal) 1490fa9e4066Sahrens (void) strlcpy(propbuf, "0", proplen); 1491fa9e4066Sahrens else 1492fa9e4066Sahrens (void) strlcpy(propbuf, "none", proplen); 1493fa9e4066Sahrens } else { 1494fa9e4066Sahrens if (literal) 1495fa9e4066Sahrens (void) snprintf(propbuf, proplen, "%llu", val); 1496fa9e4066Sahrens else 1497fa9e4066Sahrens zfs_nicenum(val, propbuf, proplen); 1498fa9e4066Sahrens } 1499fa9e4066Sahrens break; 1500fa9e4066Sahrens 1501fa9e4066Sahrens case ZFS_PROP_COMPRESSRATIO: 150299653d4eSeschrock if (get_numeric_property(zhp, prop, src, &source, &val) != 0) 150399653d4eSeschrock return (-1); 1504fa9e4066Sahrens (void) snprintf(propbuf, proplen, "%lld.%02lldx", val / 100, 1505fa9e4066Sahrens val % 100); 1506fa9e4066Sahrens break; 1507fa9e4066Sahrens 1508fa9e4066Sahrens case ZFS_PROP_TYPE: 1509fa9e4066Sahrens switch (zhp->zfs_type) { 1510fa9e4066Sahrens case ZFS_TYPE_FILESYSTEM: 1511fa9e4066Sahrens str = "filesystem"; 1512fa9e4066Sahrens break; 1513fa9e4066Sahrens case ZFS_TYPE_VOLUME: 1514fa9e4066Sahrens str = "volume"; 1515fa9e4066Sahrens break; 1516fa9e4066Sahrens case ZFS_TYPE_SNAPSHOT: 1517fa9e4066Sahrens str = "snapshot"; 1518fa9e4066Sahrens break; 1519fa9e4066Sahrens default: 152099653d4eSeschrock abort(); 1521fa9e4066Sahrens } 1522fa9e4066Sahrens (void) snprintf(propbuf, proplen, "%s", str); 1523fa9e4066Sahrens break; 1524fa9e4066Sahrens 1525fa9e4066Sahrens case ZFS_PROP_MOUNTED: 1526fa9e4066Sahrens /* 1527fa9e4066Sahrens * The 'mounted' property is a pseudo-property that described 1528fa9e4066Sahrens * whether the filesystem is currently mounted. Even though 1529fa9e4066Sahrens * it's a boolean value, the typical values of "on" and "off" 1530fa9e4066Sahrens * don't make sense, so we translate to "yes" and "no". 1531fa9e4066Sahrens */ 153299653d4eSeschrock if (get_numeric_property(zhp, ZFS_PROP_MOUNTED, 153399653d4eSeschrock src, &source, &val) != 0) 153499653d4eSeschrock return (-1); 153599653d4eSeschrock if (val) 1536fa9e4066Sahrens (void) strlcpy(propbuf, "yes", proplen); 1537fa9e4066Sahrens else 1538fa9e4066Sahrens (void) strlcpy(propbuf, "no", proplen); 1539fa9e4066Sahrens break; 1540fa9e4066Sahrens 1541fa9e4066Sahrens case ZFS_PROP_NAME: 1542fa9e4066Sahrens /* 1543fa9e4066Sahrens * The 'name' property is a pseudo-property derived from the 1544fa9e4066Sahrens * dataset name. It is presented as a real property to simplify 1545fa9e4066Sahrens * consumers. 1546fa9e4066Sahrens */ 1547fa9e4066Sahrens (void) strlcpy(propbuf, zhp->zfs_name, proplen); 1548fa9e4066Sahrens break; 1549fa9e4066Sahrens 1550fa9e4066Sahrens default: 155199653d4eSeschrock abort(); 1552fa9e4066Sahrens } 1553fa9e4066Sahrens 1554fa9e4066Sahrens get_source(zhp, src, source, statbuf, statlen); 1555fa9e4066Sahrens 1556fa9e4066Sahrens return (0); 1557fa9e4066Sahrens } 1558fa9e4066Sahrens 1559fa9e4066Sahrens /* 1560fa9e4066Sahrens * Utility function to get the given numeric property. Does no validation that 1561fa9e4066Sahrens * the given property is the appropriate type; should only be used with 1562fa9e4066Sahrens * hard-coded property types. 1563fa9e4066Sahrens */ 1564fa9e4066Sahrens uint64_t 1565fa9e4066Sahrens zfs_prop_get_int(zfs_handle_t *zhp, zfs_prop_t prop) 1566fa9e4066Sahrens { 1567fa9e4066Sahrens char *source; 1568fa9e4066Sahrens zfs_source_t sourcetype = ZFS_SRC_NONE; 156999653d4eSeschrock uint64_t val; 157099653d4eSeschrock 157199653d4eSeschrock (void) get_numeric_property(zhp, prop, &sourcetype, &source, &val); 1572fa9e4066Sahrens 157399653d4eSeschrock return (val); 1574fa9e4066Sahrens } 1575fa9e4066Sahrens 1576fa9e4066Sahrens /* 1577fa9e4066Sahrens * Similar to zfs_prop_get(), but returns the value as an integer. 1578fa9e4066Sahrens */ 1579fa9e4066Sahrens int 1580fa9e4066Sahrens zfs_prop_get_numeric(zfs_handle_t *zhp, zfs_prop_t prop, uint64_t *value, 1581fa9e4066Sahrens zfs_source_t *src, char *statbuf, size_t statlen) 1582fa9e4066Sahrens { 1583fa9e4066Sahrens char *source; 1584fa9e4066Sahrens 1585fa9e4066Sahrens /* 1586fa9e4066Sahrens * Check to see if this property applies to our object 1587fa9e4066Sahrens */ 1588fa9e4066Sahrens if (!zfs_prop_valid_for_type(prop, zhp->zfs_type)) 158999653d4eSeschrock return (zfs_error(zhp->zfs_hdl, EZFS_PROPTYPE, 159099653d4eSeschrock dgettext(TEXT_DOMAIN, "cannot get property '%s'"), 159199653d4eSeschrock zfs_prop_to_name(prop))); 1592fa9e4066Sahrens 1593fa9e4066Sahrens if (src) 1594fa9e4066Sahrens *src = ZFS_SRC_NONE; 1595fa9e4066Sahrens 159699653d4eSeschrock if (get_numeric_property(zhp, prop, src, &source, value) != 0) 159799653d4eSeschrock return (-1); 1598fa9e4066Sahrens 1599fa9e4066Sahrens get_source(zhp, src, source, statbuf, statlen); 1600fa9e4066Sahrens 1601fa9e4066Sahrens return (0); 1602fa9e4066Sahrens } 1603fa9e4066Sahrens 1604fa9e4066Sahrens /* 1605fa9e4066Sahrens * Returns the name of the given zfs handle. 1606fa9e4066Sahrens */ 1607fa9e4066Sahrens const char * 1608fa9e4066Sahrens zfs_get_name(const zfs_handle_t *zhp) 1609fa9e4066Sahrens { 1610fa9e4066Sahrens return (zhp->zfs_name); 1611fa9e4066Sahrens } 1612fa9e4066Sahrens 1613fa9e4066Sahrens /* 1614fa9e4066Sahrens * Returns the type of the given zfs handle. 1615fa9e4066Sahrens */ 1616fa9e4066Sahrens zfs_type_t 1617fa9e4066Sahrens zfs_get_type(const zfs_handle_t *zhp) 1618fa9e4066Sahrens { 1619fa9e4066Sahrens return (zhp->zfs_type); 1620fa9e4066Sahrens } 1621fa9e4066Sahrens 1622fa9e4066Sahrens /* 16237f7322feSeschrock * Iterate over all child filesystems 1624fa9e4066Sahrens */ 1625fa9e4066Sahrens int 16267f7322feSeschrock zfs_iter_filesystems(zfs_handle_t *zhp, zfs_iter_f func, void *data) 1627fa9e4066Sahrens { 1628fa9e4066Sahrens zfs_cmd_t zc = { 0 }; 1629fa9e4066Sahrens zfs_handle_t *nzhp; 1630fa9e4066Sahrens int ret; 1631fa9e4066Sahrens 1632fa9e4066Sahrens for ((void) strlcpy(zc.zc_name, zhp->zfs_name, sizeof (zc.zc_name)); 163399653d4eSeschrock ioctl(zhp->zfs_hdl->libzfs_fd, ZFS_IOC_DATASET_LIST_NEXT, &zc) == 0; 1634fa9e4066Sahrens (void) strlcpy(zc.zc_name, zhp->zfs_name, sizeof (zc.zc_name))) { 1635fa9e4066Sahrens /* 1636fa9e4066Sahrens * Ignore private dataset names. 1637fa9e4066Sahrens */ 1638fa9e4066Sahrens if (dataset_name_hidden(zc.zc_name)) 1639fa9e4066Sahrens continue; 1640fa9e4066Sahrens 1641fa9e4066Sahrens /* 1642fa9e4066Sahrens * Silently ignore errors, as the only plausible explanation is 1643fa9e4066Sahrens * that the pool has since been removed. 1644fa9e4066Sahrens */ 164599653d4eSeschrock if ((nzhp = make_dataset_handle(zhp->zfs_hdl, 164699653d4eSeschrock zc.zc_name)) == NULL) 1647fa9e4066Sahrens continue; 1648fa9e4066Sahrens 1649fa9e4066Sahrens if ((ret = func(nzhp, data)) != 0) 1650fa9e4066Sahrens return (ret); 1651fa9e4066Sahrens } 1652fa9e4066Sahrens 1653fa9e4066Sahrens /* 1654fa9e4066Sahrens * An errno value of ESRCH indicates normal completion. If ENOENT is 1655fa9e4066Sahrens * returned, then the underlying dataset has been removed since we 1656fa9e4066Sahrens * obtained the handle. 1657fa9e4066Sahrens */ 1658fa9e4066Sahrens if (errno != ESRCH && errno != ENOENT) 165999653d4eSeschrock return (zfs_standard_error(zhp->zfs_hdl, errno, 166099653d4eSeschrock dgettext(TEXT_DOMAIN, "cannot iterate filesystems"))); 1661fa9e4066Sahrens 16627f7322feSeschrock return (0); 16637f7322feSeschrock } 16647f7322feSeschrock 16657f7322feSeschrock /* 16667f7322feSeschrock * Iterate over all snapshots 16677f7322feSeschrock */ 16687f7322feSeschrock int 16697f7322feSeschrock zfs_iter_snapshots(zfs_handle_t *zhp, zfs_iter_f func, void *data) 16707f7322feSeschrock { 16717f7322feSeschrock zfs_cmd_t zc = { 0 }; 16727f7322feSeschrock zfs_handle_t *nzhp; 16737f7322feSeschrock int ret; 1674fa9e4066Sahrens 1675fa9e4066Sahrens for ((void) strlcpy(zc.zc_name, zhp->zfs_name, sizeof (zc.zc_name)); 167699653d4eSeschrock ioctl(zhp->zfs_hdl->libzfs_fd, ZFS_IOC_SNAPSHOT_LIST_NEXT, 167799653d4eSeschrock &zc) == 0; 1678fa9e4066Sahrens (void) strlcpy(zc.zc_name, zhp->zfs_name, sizeof (zc.zc_name))) { 1679fa9e4066Sahrens 168099653d4eSeschrock if ((nzhp = make_dataset_handle(zhp->zfs_hdl, 168199653d4eSeschrock zc.zc_name)) == NULL) 1682fa9e4066Sahrens continue; 1683fa9e4066Sahrens 1684fa9e4066Sahrens if ((ret = func(nzhp, data)) != 0) 1685fa9e4066Sahrens return (ret); 1686fa9e4066Sahrens } 1687fa9e4066Sahrens 1688fa9e4066Sahrens /* 1689fa9e4066Sahrens * An errno value of ESRCH indicates normal completion. If ENOENT is 1690fa9e4066Sahrens * returned, then the underlying dataset has been removed since we 1691fa9e4066Sahrens * obtained the handle. Silently ignore this case, and return success. 1692fa9e4066Sahrens */ 1693fa9e4066Sahrens if (errno != ESRCH && errno != ENOENT) 169499653d4eSeschrock return (zfs_standard_error(zhp->zfs_hdl, errno, 169599653d4eSeschrock dgettext(TEXT_DOMAIN, "cannot iterate filesystems"))); 1696fa9e4066Sahrens 1697fa9e4066Sahrens return (0); 1698fa9e4066Sahrens } 1699fa9e4066Sahrens 17007f7322feSeschrock /* 17017f7322feSeschrock * Iterate over all children, snapshots and filesystems 17027f7322feSeschrock */ 17037f7322feSeschrock int 17047f7322feSeschrock zfs_iter_children(zfs_handle_t *zhp, zfs_iter_f func, void *data) 17057f7322feSeschrock { 17067f7322feSeschrock int ret; 17077f7322feSeschrock 17087f7322feSeschrock if ((ret = zfs_iter_filesystems(zhp, func, data)) != 0) 17097f7322feSeschrock return (ret); 17107f7322feSeschrock 17117f7322feSeschrock return (zfs_iter_snapshots(zhp, func, data)); 17127f7322feSeschrock } 17137f7322feSeschrock 1714fa9e4066Sahrens /* 1715fa9e4066Sahrens * Given a complete name, return just the portion that refers to the parent. 1716fa9e4066Sahrens * Can return NULL if this is a pool. 1717fa9e4066Sahrens */ 1718fa9e4066Sahrens static int 1719fa9e4066Sahrens parent_name(const char *path, char *buf, size_t buflen) 1720fa9e4066Sahrens { 1721fa9e4066Sahrens char *loc; 1722fa9e4066Sahrens 1723fa9e4066Sahrens if ((loc = strrchr(path, '/')) == NULL) 1724fa9e4066Sahrens return (-1); 1725fa9e4066Sahrens 1726fa9e4066Sahrens (void) strncpy(buf, path, MIN(buflen, loc - path)); 1727fa9e4066Sahrens buf[loc - path] = '\0'; 1728fa9e4066Sahrens 1729fa9e4066Sahrens return (0); 1730fa9e4066Sahrens } 1731fa9e4066Sahrens 1732fa9e4066Sahrens /* 1733fa9e4066Sahrens * Checks to make sure that the given path has a parent, and that it exists. 1734fa9e4066Sahrens */ 1735fa9e4066Sahrens static int 173699653d4eSeschrock check_parents(libzfs_handle_t *hdl, const char *path) 1737fa9e4066Sahrens { 1738fa9e4066Sahrens zfs_cmd_t zc = { 0 }; 1739fa9e4066Sahrens char parent[ZFS_MAXNAMELEN]; 1740fa9e4066Sahrens char *slash; 17417f7322feSeschrock zfs_handle_t *zhp; 174299653d4eSeschrock char errbuf[1024]; 174399653d4eSeschrock 174499653d4eSeschrock (void) snprintf(errbuf, sizeof (errbuf), "cannot create '%s'", 174599653d4eSeschrock path); 1746fa9e4066Sahrens 1747fa9e4066Sahrens /* get parent, and check to see if this is just a pool */ 1748fa9e4066Sahrens if (parent_name(path, parent, sizeof (parent)) != 0) { 174999653d4eSeschrock zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, 175099653d4eSeschrock "missing dataset name")); 175199653d4eSeschrock return (zfs_error(hdl, EZFS_INVALIDNAME, errbuf)); 1752fa9e4066Sahrens } 1753fa9e4066Sahrens 1754fa9e4066Sahrens /* check to see if the pool exists */ 1755fa9e4066Sahrens if ((slash = strchr(parent, '/')) == NULL) 1756fa9e4066Sahrens slash = parent + strlen(parent); 1757fa9e4066Sahrens (void) strncpy(zc.zc_name, parent, slash - parent); 1758fa9e4066Sahrens zc.zc_name[slash - parent] = '\0'; 175999653d4eSeschrock if (ioctl(hdl->libzfs_fd, ZFS_IOC_OBJSET_STATS, &zc) != 0 && 1760fa9e4066Sahrens errno == ENOENT) { 176199653d4eSeschrock zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, 176299653d4eSeschrock "no such pool '%s'"), zc.zc_name); 176399653d4eSeschrock return (zfs_error(hdl, EZFS_NOENT, errbuf)); 1764fa9e4066Sahrens } 1765fa9e4066Sahrens 1766fa9e4066Sahrens /* check to see if the parent dataset exists */ 176799653d4eSeschrock if ((zhp = make_dataset_handle(hdl, parent)) == NULL) { 1768fa9e4066Sahrens switch (errno) { 1769fa9e4066Sahrens case ENOENT: 177099653d4eSeschrock zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, 177199653d4eSeschrock "parent does not exist")); 177299653d4eSeschrock return (zfs_error(hdl, EZFS_NOENT, errbuf)); 1773fa9e4066Sahrens 1774fa9e4066Sahrens default: 177599653d4eSeschrock return (zfs_standard_error(hdl, errno, errbuf)); 1776fa9e4066Sahrens } 1777fa9e4066Sahrens } 1778fa9e4066Sahrens 1779fa9e4066Sahrens /* we are in a non-global zone, but parent is in the global zone */ 17807f7322feSeschrock if (getzoneid() != GLOBAL_ZONEID && 178120c8013fSlling !zfs_prop_get_int(zhp, ZFS_PROP_ZONED)) { 178299653d4eSeschrock (void) zfs_standard_error(hdl, EPERM, errbuf); 17837f7322feSeschrock zfs_close(zhp); 1784fa9e4066Sahrens return (-1); 1785fa9e4066Sahrens } 1786fa9e4066Sahrens 1787fa9e4066Sahrens /* make sure parent is a filesystem */ 17887f7322feSeschrock if (zfs_get_type(zhp) != ZFS_TYPE_FILESYSTEM) { 178999653d4eSeschrock zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, 179099653d4eSeschrock "parent is not a filesystem")); 179199653d4eSeschrock (void) zfs_error(hdl, EZFS_BADTYPE, errbuf); 17927f7322feSeschrock zfs_close(zhp); 1793fa9e4066Sahrens return (-1); 1794fa9e4066Sahrens } 1795fa9e4066Sahrens 17967f7322feSeschrock zfs_close(zhp); 1797fa9e4066Sahrens return (0); 1798fa9e4066Sahrens } 1799fa9e4066Sahrens 1800fa9e4066Sahrens /* 1801fa9e4066Sahrens * Create a new filesystem or volume. 'sizestr' and 'blocksizestr' are used 1802fa9e4066Sahrens * only for volumes, and indicate the size and blocksize of the volume. 1803fa9e4066Sahrens */ 1804fa9e4066Sahrens int 180599653d4eSeschrock zfs_create(libzfs_handle_t *hdl, const char *path, zfs_type_t type, 1806fa9e4066Sahrens const char *sizestr, const char *blocksizestr) 1807fa9e4066Sahrens { 1808fa9e4066Sahrens zfs_cmd_t zc = { 0 }; 1809fa9e4066Sahrens int ret; 1810fa9e4066Sahrens uint64_t size = 0; 1811fa9e4066Sahrens uint64_t blocksize = zfs_prop_default_numeric(ZFS_PROP_VOLBLOCKSIZE); 181299653d4eSeschrock char errbuf[1024]; 1813fa9e4066Sahrens 1814fa9e4066Sahrens /* convert sizestr into integer size */ 181599653d4eSeschrock if (sizestr != NULL && nicestrtonum(hdl, sizestr, &size) != 0) 181699653d4eSeschrock return (zfs_error(hdl, EZFS_BADPROP, dgettext(TEXT_DOMAIN, 181799653d4eSeschrock "bad volume size '%s'"), sizestr)); 1818fa9e4066Sahrens 1819fa9e4066Sahrens /* convert blocksizestr into integer blocksize */ 182099653d4eSeschrock if (blocksizestr != NULL && nicestrtonum(hdl, blocksizestr, 182199653d4eSeschrock &blocksize) != 0) 182299653d4eSeschrock return (zfs_error(hdl, EZFS_BADPROP, dgettext(TEXT_DOMAIN, 182399653d4eSeschrock "bad volume blocksize '%s'"), blocksizestr)); 182499653d4eSeschrock 182599653d4eSeschrock (void) snprintf(errbuf, sizeof (errbuf), dgettext(TEXT_DOMAIN, 182699653d4eSeschrock "cannot create '%s'"), path); 1827fa9e4066Sahrens 1828fa9e4066Sahrens /* validate the path, taking care to note the extended error message */ 182999653d4eSeschrock if (!zfs_validate_name(hdl, path, type)) 183099653d4eSeschrock return (zfs_error(hdl, EZFS_INVALIDNAME, errbuf)); 1831fa9e4066Sahrens 1832fa9e4066Sahrens /* validate parents exist */ 183399653d4eSeschrock if (check_parents(hdl, path) != 0) 1834fa9e4066Sahrens return (-1); 1835fa9e4066Sahrens 1836fa9e4066Sahrens /* 1837fa9e4066Sahrens * The failure modes when creating a dataset of a different type over 1838fa9e4066Sahrens * one that already exists is a little strange. In particular, if you 1839fa9e4066Sahrens * try to create a dataset on top of an existing dataset, the ioctl() 1840fa9e4066Sahrens * will return ENOENT, not EEXIST. To prevent this from happening, we 1841fa9e4066Sahrens * first try to see if the dataset exists. 1842fa9e4066Sahrens */ 1843fa9e4066Sahrens (void) strlcpy(zc.zc_name, path, sizeof (zc.zc_name)); 184499653d4eSeschrock if (ioctl(hdl->libzfs_fd, ZFS_IOC_OBJSET_STATS, &zc) == 0) { 184599653d4eSeschrock zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, 184699653d4eSeschrock "dataset already exists")); 184799653d4eSeschrock return (zfs_error(hdl, EZFS_EXISTS, errbuf)); 1848fa9e4066Sahrens } 1849fa9e4066Sahrens 1850fa9e4066Sahrens if (type == ZFS_TYPE_VOLUME) 1851fa9e4066Sahrens zc.zc_objset_type = DMU_OST_ZVOL; 1852fa9e4066Sahrens else 1853fa9e4066Sahrens zc.zc_objset_type = DMU_OST_ZFS; 1854fa9e4066Sahrens 1855fa9e4066Sahrens if (type == ZFS_TYPE_VOLUME) { 18565c5460e9Seschrock /* 18575c5460e9Seschrock * If we are creating a volume, the size and block size must 18585c5460e9Seschrock * satisfy a few restraints. First, the blocksize must be a 18595c5460e9Seschrock * valid block size between SPA_{MIN,MAX}BLOCKSIZE. Second, the 18605c5460e9Seschrock * volsize must be a multiple of the block size, and cannot be 18615c5460e9Seschrock * zero. 18625c5460e9Seschrock */ 1863fa9e4066Sahrens if (size == 0) { 186499653d4eSeschrock zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, 186599653d4eSeschrock "cannot be zero")); 186699653d4eSeschrock return (zfs_error(hdl, EZFS_BADPROP, 186799653d4eSeschrock dgettext(TEXT_DOMAIN, "bad volume size '%s'"), 186899653d4eSeschrock sizestr)); 1869fa9e4066Sahrens } 1870fa9e4066Sahrens 18715c5460e9Seschrock if (blocksize < SPA_MINBLOCKSIZE || 18725c5460e9Seschrock blocksize > SPA_MAXBLOCKSIZE || !ISP2(blocksize)) { 187399653d4eSeschrock zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, 18745c5460e9Seschrock "must be power of 2 from %u to %uk"), 18755c5460e9Seschrock (uint_t)SPA_MINBLOCKSIZE, 18765c5460e9Seschrock (uint_t)SPA_MAXBLOCKSIZE >> 10); 187799653d4eSeschrock return (zfs_error(hdl, EZFS_BADPROP, 187899653d4eSeschrock dgettext(TEXT_DOMAIN, 187999653d4eSeschrock "bad volume block size '%s'"), blocksizestr)); 18805c5460e9Seschrock } 18815c5460e9Seschrock 18825c5460e9Seschrock if (size % blocksize != 0) { 188399653d4eSeschrock zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, 188499653d4eSeschrock "must be a multiple of volume block size")); 188599653d4eSeschrock return (zfs_error(hdl, EZFS_BADPROP, 188699653d4eSeschrock dgettext(TEXT_DOMAIN, "bad volume size '%s'"), 188799653d4eSeschrock sizestr)); 18885c5460e9Seschrock } 18895c5460e9Seschrock 1890fa9e4066Sahrens zc.zc_volsize = size; 1891fa9e4066Sahrens zc.zc_volblocksize = blocksize; 1892fa9e4066Sahrens } 1893fa9e4066Sahrens 1894fa9e4066Sahrens /* create the dataset */ 189599653d4eSeschrock ret = ioctl(hdl->libzfs_fd, ZFS_IOC_CREATE, &zc); 1896fa9e4066Sahrens 1897fa9e4066Sahrens if (ret == 0 && type == ZFS_TYPE_VOLUME) 189899653d4eSeschrock ret = zvol_create_link(hdl, path); 1899fa9e4066Sahrens 1900fa9e4066Sahrens /* check for failure */ 1901fa9e4066Sahrens if (ret != 0) { 1902fa9e4066Sahrens char parent[ZFS_MAXNAMELEN]; 1903fa9e4066Sahrens (void) parent_name(path, parent, sizeof (parent)); 1904fa9e4066Sahrens 1905fa9e4066Sahrens switch (errno) { 1906fa9e4066Sahrens case ENOENT: 190799653d4eSeschrock zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, 190899653d4eSeschrock "no such parent '%s'"), parent); 190999653d4eSeschrock return (zfs_error(hdl, EZFS_NOENT, errbuf)); 1910fa9e4066Sahrens 1911fa9e4066Sahrens case EINVAL: 191299653d4eSeschrock zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, 191399653d4eSeschrock "parent '%s' is not a filesysem"), parent); 191499653d4eSeschrock return (zfs_error(hdl, EZFS_BADTYPE, errbuf)); 1915fa9e4066Sahrens 1916fa9e4066Sahrens case EDOM: 191799653d4eSeschrock zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, 1918fa9e4066Sahrens "must be power of 2 from %u to %uk"), 1919fa9e4066Sahrens (uint_t)SPA_MINBLOCKSIZE, 1920fa9e4066Sahrens (uint_t)SPA_MAXBLOCKSIZE >> 10); 192199653d4eSeschrock 192299653d4eSeschrock return (zfs_error(hdl, EZFS_BADPROP, 192399653d4eSeschrock dgettext(TEXT_DOMAIN, "bad block size '%s'"), 192499653d4eSeschrock blocksizestr ? blocksizestr : "<unknown>")); 192599653d4eSeschrock 1926fa9e4066Sahrens #ifdef _ILP32 1927fa9e4066Sahrens case EOVERFLOW: 1928fa9e4066Sahrens /* 1929fa9e4066Sahrens * This platform can't address a volume this big. 1930fa9e4066Sahrens */ 193199653d4eSeschrock if (type == ZFS_TYPE_VOLUME) 193299653d4eSeschrock return (zfs_error(hdl, EZFS_VOLTOOBIG, 193399653d4eSeschrock errbuf)); 1934fa9e4066Sahrens #endif 193599653d4eSeschrock /* FALLTHROUGH */ 1936fa9e4066Sahrens default: 193799653d4eSeschrock return (zfs_standard_error(hdl, errno, errbuf)); 1938fa9e4066Sahrens } 1939fa9e4066Sahrens } 1940fa9e4066Sahrens 1941fa9e4066Sahrens return (0); 1942fa9e4066Sahrens } 1943fa9e4066Sahrens 1944fa9e4066Sahrens /* 1945fa9e4066Sahrens * Destroys the given dataset. The caller must make sure that the filesystem 1946fa9e4066Sahrens * isn't mounted, and that there are no active dependents. 1947fa9e4066Sahrens */ 1948fa9e4066Sahrens int 1949fa9e4066Sahrens zfs_destroy(zfs_handle_t *zhp) 1950fa9e4066Sahrens { 1951fa9e4066Sahrens zfs_cmd_t zc = { 0 }; 1952fa9e4066Sahrens int ret; 1953fa9e4066Sahrens 1954fa9e4066Sahrens (void) strlcpy(zc.zc_name, zhp->zfs_name, sizeof (zc.zc_name)); 1955fa9e4066Sahrens 1956fa9e4066Sahrens /* 1957fa9e4066Sahrens * We use the check for 'zfs_volblocksize' instead of ZFS_TYPE_VOLUME 1958fa9e4066Sahrens * so that we do the right thing for snapshots of volumes. 1959fa9e4066Sahrens */ 1960fa9e4066Sahrens if (zhp->zfs_volblocksize != 0) { 196199653d4eSeschrock if (zvol_remove_link(zhp->zfs_hdl, zhp->zfs_name) != 0) 1962fa9e4066Sahrens return (-1); 1963fa9e4066Sahrens 1964fa9e4066Sahrens zc.zc_objset_type = DMU_OST_ZVOL; 1965fa9e4066Sahrens } else { 1966fa9e4066Sahrens zc.zc_objset_type = DMU_OST_ZFS; 1967fa9e4066Sahrens } 1968fa9e4066Sahrens 196999653d4eSeschrock ret = ioctl(zhp->zfs_hdl->libzfs_fd, ZFS_IOC_DESTROY, &zc); 1970*1d452cf5Sahrens if (ret != 0) { 197199653d4eSeschrock return (zfs_standard_error(zhp->zfs_hdl, errno, 197299653d4eSeschrock dgettext(TEXT_DOMAIN, "cannot destroy '%s'"), 197399653d4eSeschrock zhp->zfs_name)); 1974*1d452cf5Sahrens } 1975fa9e4066Sahrens 1976fa9e4066Sahrens remove_mountpoint(zhp); 1977fa9e4066Sahrens 1978fa9e4066Sahrens return (0); 1979fa9e4066Sahrens } 1980fa9e4066Sahrens 1981*1d452cf5Sahrens struct destroydata { 1982*1d452cf5Sahrens char *snapname; 1983*1d452cf5Sahrens boolean_t gotone; 1984*1d452cf5Sahrens }; 1985*1d452cf5Sahrens 1986*1d452cf5Sahrens static int 1987*1d452cf5Sahrens zfs_remove_link_cb(zfs_handle_t *zhp, void *arg) 1988*1d452cf5Sahrens { 1989*1d452cf5Sahrens struct destroydata *dd = arg; 1990*1d452cf5Sahrens zfs_handle_t *szhp; 1991*1d452cf5Sahrens char name[ZFS_MAXNAMELEN]; 1992*1d452cf5Sahrens 1993*1d452cf5Sahrens (void) strcpy(name, zhp->zfs_name); 1994*1d452cf5Sahrens (void) strcat(name, "@"); 1995*1d452cf5Sahrens (void) strcat(name, dd->snapname); 1996*1d452cf5Sahrens 1997*1d452cf5Sahrens szhp = make_dataset_handle(zhp->zfs_hdl, name); 1998*1d452cf5Sahrens if (szhp) { 1999*1d452cf5Sahrens dd->gotone = B_TRUE; 2000*1d452cf5Sahrens zfs_close(szhp); 2001*1d452cf5Sahrens } 2002*1d452cf5Sahrens 2003*1d452cf5Sahrens if (zhp->zfs_type == ZFS_TYPE_VOLUME) { 2004*1d452cf5Sahrens (void) zvol_remove_link(zhp->zfs_hdl, name); 2005*1d452cf5Sahrens /* 2006*1d452cf5Sahrens * NB: this is simply a best-effort. We don't want to 2007*1d452cf5Sahrens * return an error, because then we wouldn't visit all 2008*1d452cf5Sahrens * the volumes. 2009*1d452cf5Sahrens */ 2010*1d452cf5Sahrens } 2011*1d452cf5Sahrens 2012*1d452cf5Sahrens return (zfs_iter_filesystems(zhp, zfs_remove_link_cb, arg)); 2013*1d452cf5Sahrens } 2014*1d452cf5Sahrens 2015*1d452cf5Sahrens /* 2016*1d452cf5Sahrens * Destroys all snapshots with the given name in zhp & descendants. 2017*1d452cf5Sahrens */ 2018*1d452cf5Sahrens int 2019*1d452cf5Sahrens zfs_destroy_snaps(zfs_handle_t *zhp, char *snapname) 2020*1d452cf5Sahrens { 2021*1d452cf5Sahrens zfs_cmd_t zc = { 0 }; 2022*1d452cf5Sahrens int ret; 2023*1d452cf5Sahrens struct destroydata dd = { 0 }; 2024*1d452cf5Sahrens 2025*1d452cf5Sahrens dd.snapname = snapname; 2026*1d452cf5Sahrens (void) zfs_remove_link_cb(zhp, &dd); 2027*1d452cf5Sahrens 2028*1d452cf5Sahrens if (!dd.gotone) { 2029*1d452cf5Sahrens return (zfs_standard_error(zhp->zfs_hdl, ENOENT, 2030*1d452cf5Sahrens dgettext(TEXT_DOMAIN, "cannot destroy '%s@%s'"), 2031*1d452cf5Sahrens zhp->zfs_name, snapname)); 2032*1d452cf5Sahrens } 2033*1d452cf5Sahrens 2034*1d452cf5Sahrens (void) strlcpy(zc.zc_name, zhp->zfs_name, sizeof (zc.zc_name)); 2035*1d452cf5Sahrens (void) strlcpy(zc.zc_prop_value, snapname, sizeof (zc.zc_prop_value)); 2036*1d452cf5Sahrens 2037*1d452cf5Sahrens ret = ioctl(zhp->zfs_hdl->libzfs_fd, ZFS_IOC_DESTROY_SNAPS, &zc); 2038*1d452cf5Sahrens if (ret != 0) { 2039*1d452cf5Sahrens char errbuf[1024]; 2040*1d452cf5Sahrens 2041*1d452cf5Sahrens (void) snprintf(errbuf, sizeof (errbuf), dgettext(TEXT_DOMAIN, 2042*1d452cf5Sahrens "cannot destroy '%s@%s'"), zc.zc_name, snapname); 2043*1d452cf5Sahrens 2044*1d452cf5Sahrens switch (errno) { 2045*1d452cf5Sahrens case EEXIST: 2046*1d452cf5Sahrens zfs_error_aux(zhp->zfs_hdl, dgettext(TEXT_DOMAIN, 2047*1d452cf5Sahrens "snapshot is cloned")); 2048*1d452cf5Sahrens return (zfs_error(zhp->zfs_hdl, EZFS_EXISTS, errbuf)); 2049*1d452cf5Sahrens 2050*1d452cf5Sahrens default: 2051*1d452cf5Sahrens return (zfs_standard_error(zhp->zfs_hdl, errno, 2052*1d452cf5Sahrens errbuf)); 2053*1d452cf5Sahrens } 2054*1d452cf5Sahrens } 2055*1d452cf5Sahrens 2056*1d452cf5Sahrens return (0); 2057*1d452cf5Sahrens } 2058*1d452cf5Sahrens 2059fa9e4066Sahrens /* 2060fa9e4066Sahrens * Clones the given dataset. The target must be of the same type as the source. 2061fa9e4066Sahrens */ 2062fa9e4066Sahrens int 2063fa9e4066Sahrens zfs_clone(zfs_handle_t *zhp, const char *target) 2064fa9e4066Sahrens { 2065fa9e4066Sahrens zfs_cmd_t zc = { 0 }; 2066fa9e4066Sahrens char parent[ZFS_MAXNAMELEN]; 2067fa9e4066Sahrens int ret; 206899653d4eSeschrock char errbuf[1024]; 206999653d4eSeschrock libzfs_handle_t *hdl = zhp->zfs_hdl; 2070fa9e4066Sahrens 2071fa9e4066Sahrens assert(zhp->zfs_type == ZFS_TYPE_SNAPSHOT); 2072fa9e4066Sahrens 207399653d4eSeschrock (void) snprintf(errbuf, sizeof (errbuf), dgettext(TEXT_DOMAIN, 207499653d4eSeschrock "cannot create '%s'"), target); 207599653d4eSeschrock 2076fa9e4066Sahrens /* validate the target name */ 207799653d4eSeschrock if (!zfs_validate_name(hdl, target, ZFS_TYPE_FILESYSTEM)) 207899653d4eSeschrock return (zfs_error(hdl, EZFS_INVALIDNAME, errbuf)); 2079fa9e4066Sahrens 2080fa9e4066Sahrens /* validate parents exist */ 208199653d4eSeschrock if (check_parents(zhp->zfs_hdl, target) != 0) 2082fa9e4066Sahrens return (-1); 2083fa9e4066Sahrens 2084fa9e4066Sahrens (void) parent_name(target, parent, sizeof (parent)); 2085fa9e4066Sahrens 2086fa9e4066Sahrens /* do the clone */ 2087fa9e4066Sahrens if (zhp->zfs_volblocksize != 0) 2088fa9e4066Sahrens zc.zc_objset_type = DMU_OST_ZVOL; 2089fa9e4066Sahrens else 2090fa9e4066Sahrens zc.zc_objset_type = DMU_OST_ZFS; 2091fa9e4066Sahrens 2092fa9e4066Sahrens (void) strlcpy(zc.zc_name, target, sizeof (zc.zc_name)); 2093fa9e4066Sahrens (void) strlcpy(zc.zc_filename, zhp->zfs_name, sizeof (zc.zc_filename)); 209499653d4eSeschrock ret = ioctl(zhp->zfs_hdl->libzfs_fd, ZFS_IOC_CREATE, &zc); 2095fa9e4066Sahrens 2096fa9e4066Sahrens if (ret != 0) { 2097fa9e4066Sahrens switch (errno) { 2098fa9e4066Sahrens 2099fa9e4066Sahrens case ENOENT: 2100fa9e4066Sahrens /* 2101fa9e4066Sahrens * The parent doesn't exist. We should have caught this 2102fa9e4066Sahrens * above, but there may a race condition that has since 2103fa9e4066Sahrens * destroyed the parent. 2104fa9e4066Sahrens * 2105fa9e4066Sahrens * At this point, we don't know whether it's the source 2106fa9e4066Sahrens * that doesn't exist anymore, or whether the target 2107fa9e4066Sahrens * dataset doesn't exist. 2108fa9e4066Sahrens */ 210999653d4eSeschrock zfs_error_aux(zhp->zfs_hdl, dgettext(TEXT_DOMAIN, 211099653d4eSeschrock "no such parent '%s'"), parent); 211199653d4eSeschrock return (zfs_error(zhp->zfs_hdl, EZFS_NOENT, errbuf)); 2112fa9e4066Sahrens 211399653d4eSeschrock case EXDEV: 211499653d4eSeschrock zfs_error_aux(zhp->zfs_hdl, dgettext(TEXT_DOMAIN, 211599653d4eSeschrock "source and target pools differ")); 211699653d4eSeschrock return (zfs_error(zhp->zfs_hdl, EZFS_CROSSTARGET, 211799653d4eSeschrock errbuf)); 2118fa9e4066Sahrens 211999653d4eSeschrock default: 212099653d4eSeschrock return (zfs_standard_error(zhp->zfs_hdl, errno, 212199653d4eSeschrock errbuf)); 212299653d4eSeschrock } 212399653d4eSeschrock } else if (zhp->zfs_volblocksize != 0) { 212499653d4eSeschrock ret = zvol_create_link(zhp->zfs_hdl, target); 212599653d4eSeschrock } 2126fa9e4066Sahrens 212799653d4eSeschrock return (ret); 212899653d4eSeschrock } 212999653d4eSeschrock 213099653d4eSeschrock typedef struct promote_data { 213199653d4eSeschrock char cb_mountpoint[MAXPATHLEN]; 213299653d4eSeschrock const char *cb_target; 213399653d4eSeschrock const char *cb_errbuf; 213499653d4eSeschrock uint64_t cb_pivot_txg; 213599653d4eSeschrock } promote_data_t; 213699653d4eSeschrock 213799653d4eSeschrock static int 213899653d4eSeschrock promote_snap_cb(zfs_handle_t *zhp, void *data) 213999653d4eSeschrock { 214099653d4eSeschrock promote_data_t *pd = data; 214199653d4eSeschrock zfs_handle_t *szhp; 214299653d4eSeschrock int err; 214399653d4eSeschrock char snapname[MAXPATHLEN]; 214499653d4eSeschrock char *cp; 214599653d4eSeschrock 214699653d4eSeschrock /* We don't care about snapshots after the pivot point */ 214799653d4eSeschrock if (zfs_prop_get_int(zhp, ZFS_PROP_CREATETXG) > pd->cb_pivot_txg) 214899653d4eSeschrock return (0); 214999653d4eSeschrock 215099653d4eSeschrock /* 215199653d4eSeschrock * Unmount it. We actually need to open it to provoke it to be 215299653d4eSeschrock * mounted first, because if it is not mounted, umount2 will 215399653d4eSeschrock * mount it! 215499653d4eSeschrock */ 215599653d4eSeschrock (void) strcpy(snapname, pd->cb_mountpoint); 215699653d4eSeschrock (void) strcat(snapname, "/.zfs/snapshot/"); 215799653d4eSeschrock cp = strchr(zhp->zfs_name, '@'); 215899653d4eSeschrock (void) strcat(snapname, cp+1); 215999653d4eSeschrock err = open(snapname, O_RDONLY); 216099653d4eSeschrock if (err != -1) 216199653d4eSeschrock (void) close(err); 216299653d4eSeschrock (void) umount2(snapname, MS_FORCE); 216399653d4eSeschrock 216499653d4eSeschrock /* Check for conflicting names */ 216599653d4eSeschrock (void) strcpy(snapname, pd->cb_target); 216699653d4eSeschrock (void) strcat(snapname, cp); 216799653d4eSeschrock szhp = make_dataset_handle(zhp->zfs_hdl, snapname); 216899653d4eSeschrock if (szhp != NULL) { 216999653d4eSeschrock zfs_close(szhp); 217099653d4eSeschrock zfs_error_aux(zhp->zfs_hdl, dgettext(TEXT_DOMAIN, 217199653d4eSeschrock "snapshot name '%s' from origin \n" 217299653d4eSeschrock "conflicts with '%s' from target"), 217399653d4eSeschrock zhp->zfs_name, snapname); 217499653d4eSeschrock return (zfs_error(zhp->zfs_hdl, EZFS_EXISTS, pd->cb_errbuf)); 217599653d4eSeschrock } 217699653d4eSeschrock return (0); 217799653d4eSeschrock } 217899653d4eSeschrock 217999653d4eSeschrock /* 218099653d4eSeschrock * Promotes the given clone fs to be the clone parent. 218199653d4eSeschrock */ 218299653d4eSeschrock int 218399653d4eSeschrock zfs_promote(zfs_handle_t *zhp) 218499653d4eSeschrock { 218599653d4eSeschrock libzfs_handle_t *hdl = zhp->zfs_hdl; 218699653d4eSeschrock zfs_cmd_t zc = { 0 }; 218799653d4eSeschrock char parent[MAXPATHLEN]; 218899653d4eSeschrock char *cp; 218999653d4eSeschrock int ret; 219099653d4eSeschrock zfs_handle_t *pzhp; 219199653d4eSeschrock promote_data_t pd; 219299653d4eSeschrock char errbuf[1024]; 219399653d4eSeschrock 219499653d4eSeschrock (void) snprintf(errbuf, sizeof (errbuf), dgettext(TEXT_DOMAIN, 219599653d4eSeschrock "cannot promote '%s'"), zhp->zfs_name); 219699653d4eSeschrock 219799653d4eSeschrock if (zhp->zfs_type == ZFS_TYPE_SNAPSHOT) { 219899653d4eSeschrock zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, 219999653d4eSeschrock "snapshots can not be promoted")); 220099653d4eSeschrock return (zfs_error(hdl, EZFS_BADTYPE, errbuf)); 220199653d4eSeschrock } 220299653d4eSeschrock 220399653d4eSeschrock (void) strcpy(parent, zhp->zfs_dmustats.dds_clone_of); 220499653d4eSeschrock if (parent[0] == '\0') { 220599653d4eSeschrock zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, 220699653d4eSeschrock "not a cloned filesystem")); 220799653d4eSeschrock return (zfs_error(hdl, EZFS_BADTYPE, errbuf)); 220899653d4eSeschrock } 220999653d4eSeschrock cp = strchr(parent, '@'); 221099653d4eSeschrock *cp = '\0'; 221199653d4eSeschrock 221299653d4eSeschrock /* Walk the snapshots we will be moving */ 221399653d4eSeschrock pzhp = zfs_open(hdl, zhp->zfs_dmustats.dds_clone_of, ZFS_TYPE_SNAPSHOT); 221499653d4eSeschrock if (pzhp == NULL) 221599653d4eSeschrock return (-1); 221699653d4eSeschrock pd.cb_pivot_txg = zfs_prop_get_int(pzhp, ZFS_PROP_CREATETXG); 221799653d4eSeschrock zfs_close(pzhp); 221899653d4eSeschrock pd.cb_target = zhp->zfs_name; 221999653d4eSeschrock pd.cb_errbuf = errbuf; 222099653d4eSeschrock pzhp = zfs_open(hdl, parent, ZFS_TYPE_ANY); 222199653d4eSeschrock if (pzhp == NULL) 222299653d4eSeschrock return (-1); 222399653d4eSeschrock (void) zfs_prop_get(pzhp, ZFS_PROP_MOUNTPOINT, pd.cb_mountpoint, 222499653d4eSeschrock sizeof (pd.cb_mountpoint), NULL, NULL, 0, FALSE); 222599653d4eSeschrock ret = zfs_iter_snapshots(pzhp, promote_snap_cb, &pd); 222699653d4eSeschrock if (ret != 0) 222799653d4eSeschrock return (-1); 222899653d4eSeschrock 222999653d4eSeschrock /* issue the ioctl */ 223099653d4eSeschrock (void) strlcpy(zc.zc_name, zhp->zfs_name, sizeof (zc.zc_name)); 223199653d4eSeschrock ret = ioctl(hdl->libzfs_fd, ZFS_IOC_PROMOTE, &zc); 223299653d4eSeschrock 223399653d4eSeschrock if (ret != 0) { 223499653d4eSeschrock switch (errno) { 223599653d4eSeschrock 223699653d4eSeschrock case EEXIST: 2237fa9e4066Sahrens /* 223899653d4eSeschrock * There is a conflicting snapshot name. We 223999653d4eSeschrock * should have caught this above, but they could 224099653d4eSeschrock * have renamed something in the mean time. 2241fa9e4066Sahrens */ 224299653d4eSeschrock zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, 224399653d4eSeschrock "conflicting snapshot name from parent '%s'"), 224499653d4eSeschrock parent); 224599653d4eSeschrock return (zfs_error(hdl, EZFS_EXISTS, errbuf)); 2246fa9e4066Sahrens 2247fa9e4066Sahrens default: 224899653d4eSeschrock return (zfs_standard_error(hdl, errno, errbuf)); 2249fa9e4066Sahrens } 2250fa9e4066Sahrens } 2251fa9e4066Sahrens 2252fa9e4066Sahrens return (ret); 2253fa9e4066Sahrens } 2254fa9e4066Sahrens 2255*1d452cf5Sahrens static int 2256*1d452cf5Sahrens zfs_create_link_cb(zfs_handle_t *zhp, void *arg) 2257*1d452cf5Sahrens { 2258*1d452cf5Sahrens char *snapname = arg; 2259*1d452cf5Sahrens 2260*1d452cf5Sahrens if (zhp->zfs_type == ZFS_TYPE_VOLUME) { 2261*1d452cf5Sahrens char name[MAXPATHLEN]; 2262*1d452cf5Sahrens 2263*1d452cf5Sahrens (void) strcpy(name, zhp->zfs_name); 2264*1d452cf5Sahrens (void) strcat(name, "@"); 2265*1d452cf5Sahrens (void) strcat(name, snapname); 2266*1d452cf5Sahrens (void) zvol_create_link(zhp->zfs_hdl, name); 2267*1d452cf5Sahrens /* 2268*1d452cf5Sahrens * NB: this is simply a best-effort. We don't want to 2269*1d452cf5Sahrens * return an error, because then we wouldn't visit all 2270*1d452cf5Sahrens * the volumes. 2271*1d452cf5Sahrens */ 2272*1d452cf5Sahrens } 2273*1d452cf5Sahrens return (zfs_iter_filesystems(zhp, zfs_create_link_cb, snapname)); 2274*1d452cf5Sahrens } 2275*1d452cf5Sahrens 2276fa9e4066Sahrens /* 2277fa9e4066Sahrens * Takes a snapshot of the given dataset 2278fa9e4066Sahrens */ 2279fa9e4066Sahrens int 2280*1d452cf5Sahrens zfs_snapshot(libzfs_handle_t *hdl, const char *path, boolean_t recursive) 2281fa9e4066Sahrens { 2282fa9e4066Sahrens const char *delim; 2283fa9e4066Sahrens char *parent; 2284fa9e4066Sahrens zfs_handle_t *zhp; 2285fa9e4066Sahrens zfs_cmd_t zc = { 0 }; 2286fa9e4066Sahrens int ret; 228799653d4eSeschrock char errbuf[1024]; 2288fa9e4066Sahrens 228999653d4eSeschrock (void) snprintf(errbuf, sizeof (errbuf), dgettext(TEXT_DOMAIN, 229099653d4eSeschrock "cannot snapshot '%s'"), path); 229199653d4eSeschrock 229299653d4eSeschrock /* validate the target name */ 229399653d4eSeschrock if (!zfs_validate_name(hdl, path, ZFS_TYPE_SNAPSHOT)) 229499653d4eSeschrock return (zfs_error(hdl, EZFS_INVALIDNAME, errbuf)); 2295fa9e4066Sahrens 2296fa9e4066Sahrens /* make sure the parent exists and is of the appropriate type */ 2297*1d452cf5Sahrens delim = strchr(path, '@'); 229899653d4eSeschrock if ((parent = zfs_alloc(hdl, delim - path + 1)) == NULL) 229999653d4eSeschrock return (-1); 2300fa9e4066Sahrens (void) strncpy(parent, path, delim - path); 2301fa9e4066Sahrens parent[delim - path] = '\0'; 2302fa9e4066Sahrens 230399653d4eSeschrock if ((zhp = zfs_open(hdl, parent, ZFS_TYPE_FILESYSTEM | 2304fa9e4066Sahrens ZFS_TYPE_VOLUME)) == NULL) { 2305fa9e4066Sahrens free(parent); 2306fa9e4066Sahrens return (-1); 2307fa9e4066Sahrens } 2308fa9e4066Sahrens 2309*1d452cf5Sahrens (void) strlcpy(zc.zc_name, zhp->zfs_name, sizeof (zc.zc_name)); 2310*1d452cf5Sahrens (void) strlcpy(zc.zc_prop_value, delim+1, sizeof (zc.zc_prop_value)); 2311*1d452cf5Sahrens zc.zc_cookie = recursive; 2312*1d452cf5Sahrens ret = ioctl(zhp->zfs_hdl->libzfs_fd, ZFS_IOC_SNAPSHOT, &zc); 2313fa9e4066Sahrens 2314*1d452cf5Sahrens /* 2315*1d452cf5Sahrens * if it was recursive, the one that actually failed will be in 2316*1d452cf5Sahrens * zc.zc_name. 2317*1d452cf5Sahrens */ 2318*1d452cf5Sahrens (void) snprintf(errbuf, sizeof (errbuf), dgettext(TEXT_DOMAIN, 2319*1d452cf5Sahrens "cannot create snapshot '%s@%s'"), zc.zc_name, zc.zc_prop_value); 2320*1d452cf5Sahrens if (ret == 0 && recursive) { 2321*1d452cf5Sahrens (void) zfs_iter_filesystems(zhp, 2322*1d452cf5Sahrens zfs_create_link_cb, (char *)delim+1); 2323*1d452cf5Sahrens } 2324fa9e4066Sahrens if (ret == 0 && zhp->zfs_type == ZFS_TYPE_VOLUME) { 232599653d4eSeschrock ret = zvol_create_link(zhp->zfs_hdl, path); 2326*1d452cf5Sahrens if (ret != 0) { 232799653d4eSeschrock (void) ioctl(zhp->zfs_hdl->libzfs_fd, ZFS_IOC_DESTROY, 232899653d4eSeschrock &zc); 2329*1d452cf5Sahrens } 2330fa9e4066Sahrens } 2331fa9e4066Sahrens 233299653d4eSeschrock if (ret != 0) 233399653d4eSeschrock (void) zfs_standard_error(hdl, errno, errbuf); 2334fa9e4066Sahrens 2335fa9e4066Sahrens free(parent); 2336fa9e4066Sahrens zfs_close(zhp); 2337fa9e4066Sahrens 2338fa9e4066Sahrens return (ret); 2339fa9e4066Sahrens } 2340fa9e4066Sahrens 2341fa9e4066Sahrens /* 2342fa9e4066Sahrens * Dumps a backup of tosnap, incremental from fromsnap if it isn't NULL. 2343fa9e4066Sahrens */ 2344fa9e4066Sahrens int 2345f2a3c691Sahrens zfs_send(zfs_handle_t *zhp_to, zfs_handle_t *zhp_from) 2346fa9e4066Sahrens { 2347fa9e4066Sahrens zfs_cmd_t zc = { 0 }; 2348fa9e4066Sahrens int ret; 234999653d4eSeschrock char errbuf[1024]; 235099653d4eSeschrock libzfs_handle_t *hdl = zhp_to->zfs_hdl; 235199653d4eSeschrock 235299653d4eSeschrock (void) snprintf(errbuf, sizeof (errbuf), dgettext(TEXT_DOMAIN, 235399653d4eSeschrock "cannot send '%s'"), zhp_to->zfs_name); 2354fa9e4066Sahrens 2355fa9e4066Sahrens /* do the ioctl() */ 2356fa9e4066Sahrens (void) strlcpy(zc.zc_name, zhp_to->zfs_name, sizeof (zc.zc_name)); 2357fa9e4066Sahrens if (zhp_from) { 2358fa9e4066Sahrens (void) strlcpy(zc.zc_prop_value, zhp_from->zfs_name, 2359fa9e4066Sahrens sizeof (zc.zc_name)); 2360fa9e4066Sahrens } else { 2361fa9e4066Sahrens zc.zc_prop_value[0] = '\0'; 2362fa9e4066Sahrens } 2363fa9e4066Sahrens zc.zc_cookie = STDOUT_FILENO; 2364fa9e4066Sahrens 236599653d4eSeschrock ret = ioctl(zhp_to->zfs_hdl->libzfs_fd, ZFS_IOC_SENDBACKUP, &zc); 2366fa9e4066Sahrens if (ret != 0) { 2367fa9e4066Sahrens switch (errno) { 2368fa9e4066Sahrens 2369fa9e4066Sahrens case EXDEV: 237099653d4eSeschrock zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, 237199653d4eSeschrock "not an ealier snapshot from the same fs")); 237299653d4eSeschrock return (zfs_error(hdl, EZFS_CROSSTARGET, errbuf)); 2373fa9e4066Sahrens 2374fa9e4066Sahrens case EDQUOT: 2375fa9e4066Sahrens case EFBIG: 2376fa9e4066Sahrens case EIO: 2377fa9e4066Sahrens case ENOLINK: 2378fa9e4066Sahrens case ENOSPC: 2379fa9e4066Sahrens case ENOSTR: 2380fa9e4066Sahrens case ENXIO: 2381fa9e4066Sahrens case EPIPE: 2382fa9e4066Sahrens case ERANGE: 2383fa9e4066Sahrens case EFAULT: 2384fa9e4066Sahrens case EROFS: 238599653d4eSeschrock zfs_error_aux(hdl, strerror(errno)); 238699653d4eSeschrock return (zfs_error(hdl, EZFS_BADBACKUP, errbuf)); 2387fa9e4066Sahrens 2388fa9e4066Sahrens default: 238999653d4eSeschrock return (zfs_standard_error(hdl, errno, errbuf)); 2390fa9e4066Sahrens } 2391fa9e4066Sahrens } 2392fa9e4066Sahrens 2393fa9e4066Sahrens return (ret); 2394fa9e4066Sahrens } 2395fa9e4066Sahrens 2396fa9e4066Sahrens /* 2397fa9e4066Sahrens * Restores a backup of tosnap from stdin. 2398fa9e4066Sahrens */ 2399fa9e4066Sahrens int 240099653d4eSeschrock zfs_receive(libzfs_handle_t *hdl, const char *tosnap, int isprefix, 240199653d4eSeschrock int verbose, int dryrun) 2402fa9e4066Sahrens { 2403fa9e4066Sahrens zfs_cmd_t zc = { 0 }; 2404fa9e4066Sahrens time_t begin_time; 24059b4f025eSahrens int ioctl_err, err, bytes, size; 2406fa9e4066Sahrens char *cp; 2407fa9e4066Sahrens dmu_replay_record_t drr; 2408fa9e4066Sahrens struct drr_begin *drrb = &zc.zc_begin_record; 240999653d4eSeschrock char errbuf[1024]; 2410fa9e4066Sahrens 2411fa9e4066Sahrens begin_time = time(NULL); 2412fa9e4066Sahrens 241399653d4eSeschrock (void) snprintf(errbuf, sizeof (errbuf), dgettext(TEXT_DOMAIN, 241499653d4eSeschrock "cannot receive")); 241599653d4eSeschrock 2416fa9e4066Sahrens /* trim off snapname, if any */ 2417fa9e4066Sahrens (void) strcpy(zc.zc_name, tosnap); 2418fa9e4066Sahrens cp = strchr(zc.zc_name, '@'); 2419fa9e4066Sahrens if (cp) 2420fa9e4066Sahrens *cp = '\0'; 2421fa9e4066Sahrens 2422fa9e4066Sahrens /* read in the BEGIN record */ 2423fa9e4066Sahrens cp = (char *)&drr; 2424fa9e4066Sahrens bytes = 0; 2425fa9e4066Sahrens do { 24269b4f025eSahrens size = read(STDIN_FILENO, cp, sizeof (drr) - bytes); 24279b4f025eSahrens cp += size; 24289b4f025eSahrens bytes += size; 24299b4f025eSahrens } while (size > 0); 2430fa9e4066Sahrens 24319b4f025eSahrens if (size < 0 || bytes != sizeof (drr)) { 243299653d4eSeschrock zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, "invalid " 243399653d4eSeschrock "stream (failed to read first record)")); 243499653d4eSeschrock return (zfs_error(hdl, EZFS_BADSTREAM, errbuf)); 2435fa9e4066Sahrens } 2436fa9e4066Sahrens 2437fa9e4066Sahrens zc.zc_begin_record = drr.drr_u.drr_begin; 2438fa9e4066Sahrens 2439fa9e4066Sahrens if (drrb->drr_magic != DMU_BACKUP_MAGIC && 2440fa9e4066Sahrens drrb->drr_magic != BSWAP_64(DMU_BACKUP_MAGIC)) { 244199653d4eSeschrock zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, "invalid " 244299653d4eSeschrock "stream (bad magic number)")); 244399653d4eSeschrock return (zfs_error(hdl, EZFS_BADSTREAM, errbuf)); 2444fa9e4066Sahrens } 2445fa9e4066Sahrens 2446fa9e4066Sahrens if (drrb->drr_version != DMU_BACKUP_VERSION && 2447fa9e4066Sahrens drrb->drr_version != BSWAP_64(DMU_BACKUP_VERSION)) { 244899653d4eSeschrock zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, "only version " 244999653d4eSeschrock "0x%llx is supported (stream is version 0x%llx)"), 2450fa9e4066Sahrens DMU_BACKUP_VERSION, drrb->drr_version); 245199653d4eSeschrock return (zfs_error(hdl, EZFS_BADSTREAM, errbuf)); 2452fa9e4066Sahrens } 2453fa9e4066Sahrens 2454fa9e4066Sahrens /* 2455fa9e4066Sahrens * Determine name of destination snapshot. 2456fa9e4066Sahrens */ 2457ea8dc4b6Seschrock (void) strcpy(zc.zc_filename, tosnap); 2458fa9e4066Sahrens if (isprefix) { 2459fa9e4066Sahrens if (strchr(tosnap, '@') != NULL) { 246099653d4eSeschrock zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, 246199653d4eSeschrock "destination must be a filesystem")); 246299653d4eSeschrock return (zfs_error(hdl, EZFS_BADTYPE, errbuf)); 2463fa9e4066Sahrens } 2464fa9e4066Sahrens 2465fa9e4066Sahrens cp = strchr(drr.drr_u.drr_begin.drr_toname, '/'); 2466fa9e4066Sahrens if (cp == NULL) 2467fa9e4066Sahrens cp = drr.drr_u.drr_begin.drr_toname; 2468fa9e4066Sahrens else 2469fa9e4066Sahrens cp++; 2470fa9e4066Sahrens 2471ea8dc4b6Seschrock (void) strcat(zc.zc_filename, "/"); 2472ea8dc4b6Seschrock (void) strcat(zc.zc_filename, cp); 2473fa9e4066Sahrens } else if (strchr(tosnap, '@') == NULL) { 2474fa9e4066Sahrens /* 2475fa9e4066Sahrens * they specified just a filesystem; tack on the 2476fa9e4066Sahrens * snapname from the backup. 2477fa9e4066Sahrens */ 2478fa9e4066Sahrens cp = strchr(drr.drr_u.drr_begin.drr_toname, '@'); 247999653d4eSeschrock if (cp == NULL || strlen(tosnap) + strlen(cp) >= MAXNAMELEN) 248099653d4eSeschrock return (zfs_error(hdl, EZFS_INVALIDNAME, errbuf)); 2481ea8dc4b6Seschrock (void) strcat(zc.zc_filename, cp); 2482fa9e4066Sahrens } 2483fa9e4066Sahrens 2484fa9e4066Sahrens if (drrb->drr_fromguid) { 2485fa9e4066Sahrens zfs_handle_t *h; 2486fa9e4066Sahrens /* incremental backup stream */ 2487fa9e4066Sahrens 2488fa9e4066Sahrens /* do the ioctl to the containing fs */ 2489ea8dc4b6Seschrock (void) strcpy(zc.zc_name, zc.zc_filename); 2490fa9e4066Sahrens cp = strchr(zc.zc_name, '@'); 2491fa9e4066Sahrens *cp = '\0'; 2492fa9e4066Sahrens 2493fa9e4066Sahrens /* make sure destination fs exists */ 249499653d4eSeschrock h = zfs_open(hdl, zc.zc_name, 249599653d4eSeschrock ZFS_TYPE_FILESYSTEM | ZFS_TYPE_VOLUME); 249699653d4eSeschrock if (h == NULL) 2497fa9e4066Sahrens return (-1); 24989b4f025eSahrens if (!dryrun) { 24999b4f025eSahrens /* unmount destination fs or remove device link. */ 25009b4f025eSahrens if (h->zfs_type == ZFS_TYPE_FILESYSTEM) { 25019b4f025eSahrens (void) zfs_unmount(h, NULL, 0); 25029b4f025eSahrens } else { 250399653d4eSeschrock (void) zvol_remove_link(hdl, h->zfs_name); 25049b4f025eSahrens } 25059b4f025eSahrens } 2506fa9e4066Sahrens zfs_close(h); 2507fa9e4066Sahrens } else { 2508fa9e4066Sahrens /* full backup stream */ 2509fa9e4066Sahrens 2510ea8dc4b6Seschrock (void) strcpy(zc.zc_name, zc.zc_filename); 25119b4f025eSahrens 2512f2a3c691Sahrens /* make sure they aren't trying to receive into the root */ 25139b4f025eSahrens if (strchr(zc.zc_name, '/') == NULL) { 2514fa9e4066Sahrens cp = strchr(zc.zc_name, '@'); 2515fa9e4066Sahrens if (cp) 2516fa9e4066Sahrens *cp = '\0'; 251799653d4eSeschrock zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, 251899653d4eSeschrock "destination '%s' already exists"), zc.zc_name); 251999653d4eSeschrock return (zfs_error(hdl, EZFS_EXISTS, errbuf)); 2520fa9e4066Sahrens } 2521fa9e4066Sahrens 2522fa9e4066Sahrens if (isprefix) { 2523fa9e4066Sahrens zfs_handle_t *h; 2524fa9e4066Sahrens 25259b4f025eSahrens /* make sure prefix exists */ 252699653d4eSeschrock h = zfs_open(hdl, tosnap, ZFS_TYPE_FILESYSTEM); 252799653d4eSeschrock if (h == NULL) 2528fa9e4066Sahrens return (-1); 2529ea8dc4b6Seschrock zfs_close(h); 2530fa9e4066Sahrens 2531fa9e4066Sahrens /* create any necessary ancestors up to prefix */ 25329b4f025eSahrens zc.zc_objset_type = DMU_OST_ZFS; 2533ea8dc4b6Seschrock 25349b4f025eSahrens /* 25359b4f025eSahrens * zc.zc_name is now the full name of the snap 2536ea8dc4b6Seschrock * we're restoring into. Attempt to create, 2537ea8dc4b6Seschrock * mount, and share any ancestor filesystems, up 2538ea8dc4b6Seschrock * to the one that was named. 25399b4f025eSahrens */ 2540ea8dc4b6Seschrock for (cp = zc.zc_name + strlen(tosnap) + 1; 2541ea8dc4b6Seschrock cp = strchr(cp, '/'); *cp = '/', cp++) { 2542ea8dc4b6Seschrock const char *opname; 2543fa9e4066Sahrens *cp = '\0'; 2544ea8dc4b6Seschrock 254599653d4eSeschrock opname = dgettext(TEXT_DOMAIN, "create"); 254699653d4eSeschrock if (zfs_create(hdl, zc.zc_name, 254799653d4eSeschrock ZFS_TYPE_FILESYSTEM, NULL, NULL) != 0) { 2548ea8dc4b6Seschrock if (errno == EEXIST) 2549ea8dc4b6Seschrock continue; 2550ea8dc4b6Seschrock goto ancestorerr; 2551fa9e4066Sahrens } 2552ea8dc4b6Seschrock 255399653d4eSeschrock opname = dgettext(TEXT_DOMAIN, "open"); 255499653d4eSeschrock h = zfs_open(hdl, zc.zc_name, 255599653d4eSeschrock ZFS_TYPE_FILESYSTEM); 2556ea8dc4b6Seschrock if (h == NULL) 2557ea8dc4b6Seschrock goto ancestorerr; 2558ea8dc4b6Seschrock 255999653d4eSeschrock opname = dgettext(TEXT_DOMAIN, "mount"); 2560ea8dc4b6Seschrock if (zfs_mount(h, NULL, 0) != 0) 2561ea8dc4b6Seschrock goto ancestorerr; 2562ea8dc4b6Seschrock 256399653d4eSeschrock opname = dgettext(TEXT_DOMAIN, "share"); 2564ea8dc4b6Seschrock if (zfs_share(h) != 0) 2565ea8dc4b6Seschrock goto ancestorerr; 2566ea8dc4b6Seschrock 2567ea8dc4b6Seschrock zfs_close(h); 2568ea8dc4b6Seschrock 2569ea8dc4b6Seschrock continue; 2570ea8dc4b6Seschrock ancestorerr: 257199653d4eSeschrock zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, 257299653d4eSeschrock "failed to %s ancestor '%s'"), opname, 257399653d4eSeschrock zc.zc_name); 257499653d4eSeschrock return (zfs_error(hdl, EZFS_BADRESTORE, 257599653d4eSeschrock errbuf)); 2576fa9e4066Sahrens } 2577fa9e4066Sahrens } 25789b4f025eSahrens 25799b4f025eSahrens /* Make sure destination fs does not exist */ 25809b4f025eSahrens cp = strchr(zc.zc_name, '@'); 25819b4f025eSahrens *cp = '\0'; 258299653d4eSeschrock if (ioctl(hdl->libzfs_fd, ZFS_IOC_OBJSET_STATS, &zc) == 0) { 258399653d4eSeschrock zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, 258499653d4eSeschrock "destination '%s' exists"), zc.zc_name); 258599653d4eSeschrock return (zfs_error(hdl, EZFS_EXISTS, errbuf)); 25869b4f025eSahrens } 25879b4f025eSahrens 25889b4f025eSahrens /* Do the recvbackup ioctl to the fs's parent. */ 25899b4f025eSahrens cp = strrchr(zc.zc_name, '/'); 25909b4f025eSahrens *cp = '\0'; 2591fa9e4066Sahrens } 2592fa9e4066Sahrens 2593fa9e4066Sahrens (void) strcpy(zc.zc_prop_value, tosnap); 2594fa9e4066Sahrens zc.zc_cookie = STDIN_FILENO; 2595fa9e4066Sahrens zc.zc_intsz = isprefix; 2596fa9e4066Sahrens if (verbose) { 2597f2a3c691Sahrens (void) printf("%s %s stream of %s into %s\n", 2598f2a3c691Sahrens dryrun ? "would receive" : "receiving", 2599fa9e4066Sahrens drrb->drr_fromguid ? "incremental" : "full", 2600fa9e4066Sahrens drr.drr_u.drr_begin.drr_toname, 2601ea8dc4b6Seschrock zc.zc_filename); 2602fa9e4066Sahrens (void) fflush(stdout); 2603fa9e4066Sahrens } 2604fa9e4066Sahrens if (dryrun) 2605fa9e4066Sahrens return (0); 260699653d4eSeschrock err = ioctl_err = ioctl(hdl->libzfs_fd, ZFS_IOC_RECVBACKUP, &zc); 26079b4f025eSahrens if (ioctl_err != 0) { 2608fa9e4066Sahrens switch (errno) { 2609fa9e4066Sahrens case ENODEV: 261099653d4eSeschrock zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, 261199653d4eSeschrock "most recent snapshot does not match incremental " 261299653d4eSeschrock "source")); 261399653d4eSeschrock (void) zfs_error(hdl, EZFS_BADRESTORE, errbuf); 2614fa9e4066Sahrens break; 2615fa9e4066Sahrens case ETXTBSY: 261699653d4eSeschrock zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, 261799653d4eSeschrock "destination has been modified since most recent " 261899653d4eSeschrock "snapshot")); 261999653d4eSeschrock (void) zfs_error(hdl, EZFS_BADRESTORE, errbuf); 2620fa9e4066Sahrens break; 2621fa9e4066Sahrens case EEXIST: 2622fa9e4066Sahrens if (drrb->drr_fromguid == 0) { 2623fa9e4066Sahrens /* it's the containing fs that exists */ 2624ea8dc4b6Seschrock cp = strchr(zc.zc_filename, '@'); 2625fa9e4066Sahrens *cp = '\0'; 2626fa9e4066Sahrens } 262799653d4eSeschrock zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, 262899653d4eSeschrock "destination already exists")); 262999653d4eSeschrock (void) zfs_error(hdl, EZFS_EXISTS, dgettext(TEXT_DOMAIN, 263099653d4eSeschrock "cannot restore to %s"), zc.zc_filename); 2631fa9e4066Sahrens break; 2632fa9e4066Sahrens case EINVAL: 263399653d4eSeschrock (void) zfs_error(hdl, EZFS_BADSTREAM, errbuf); 26349b4f025eSahrens break; 2635ea8dc4b6Seschrock case ECKSUM: 263699653d4eSeschrock zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, 263799653d4eSeschrock "invalid stream (checksum mismatch)")); 263899653d4eSeschrock (void) zfs_error(hdl, EZFS_BADSTREAM, errbuf); 2639fa9e4066Sahrens break; 2640fa9e4066Sahrens default: 264199653d4eSeschrock (void) zfs_standard_error(hdl, errno, errbuf); 2642fa9e4066Sahrens } 2643fa9e4066Sahrens } 2644fa9e4066Sahrens 2645fa9e4066Sahrens /* 26469b4f025eSahrens * Mount or recreate the /dev links for the target filesystem 26479b4f025eSahrens * (if created, or if we tore them down to do an incremental 26489b4f025eSahrens * restore), and the /dev links for the new snapshot (if 26499b4f025eSahrens * created). 2650fa9e4066Sahrens */ 2651ea8dc4b6Seschrock cp = strchr(zc.zc_filename, '@'); 26529b4f025eSahrens if (cp && (ioctl_err == 0 || drrb->drr_fromguid)) { 2653fa9e4066Sahrens zfs_handle_t *h; 2654fa9e4066Sahrens 2655fa9e4066Sahrens *cp = '\0'; 265699653d4eSeschrock h = zfs_open(hdl, zc.zc_filename, 2657fa9e4066Sahrens ZFS_TYPE_FILESYSTEM | ZFS_TYPE_VOLUME); 26589b4f025eSahrens *cp = '@'; 2659fa9e4066Sahrens if (h) { 26609b4f025eSahrens if (h->zfs_type == ZFS_TYPE_FILESYSTEM) { 2661fa9e4066Sahrens err = zfs_mount(h, NULL, 0); 26629b4f025eSahrens } else { 266399653d4eSeschrock err = zvol_create_link(hdl, h->zfs_name); 2664ea8dc4b6Seschrock if (err == 0 && ioctl_err == 0) 266599653d4eSeschrock err = zvol_create_link(hdl, 266699653d4eSeschrock zc.zc_filename); 26679b4f025eSahrens } 2668fa9e4066Sahrens zfs_close(h); 2669fa9e4066Sahrens } 2670fa9e4066Sahrens } 2671fa9e4066Sahrens 26729b4f025eSahrens if (err || ioctl_err) 26739b4f025eSahrens return (-1); 2674fa9e4066Sahrens 2675fa9e4066Sahrens if (verbose) { 2676fa9e4066Sahrens char buf1[64]; 2677fa9e4066Sahrens char buf2[64]; 2678fa9e4066Sahrens uint64_t bytes = zc.zc_cookie; 2679fa9e4066Sahrens time_t delta = time(NULL) - begin_time; 2680fa9e4066Sahrens if (delta == 0) 2681fa9e4066Sahrens delta = 1; 2682fa9e4066Sahrens zfs_nicenum(bytes, buf1, sizeof (buf1)); 2683fa9e4066Sahrens zfs_nicenum(bytes/delta, buf2, sizeof (buf1)); 2684fa9e4066Sahrens 2685f2a3c691Sahrens (void) printf("received %sb stream in %lu seconds (%sb/sec)\n", 2686fa9e4066Sahrens buf1, delta, buf2); 2687fa9e4066Sahrens } 2688fa9e4066Sahrens return (0); 2689fa9e4066Sahrens } 2690fa9e4066Sahrens 2691fa9e4066Sahrens /* 2692b12a1c38Slling * Destroy any more recent snapshots. We invoke this callback on any dependents 2693b12a1c38Slling * of the snapshot first. If the 'cb_dependent' member is non-zero, then this 2694b12a1c38Slling * is a dependent and we should just destroy it without checking the transaction 2695b12a1c38Slling * group. 2696fa9e4066Sahrens */ 2697b12a1c38Slling typedef struct rollback_data { 2698b12a1c38Slling const char *cb_target; /* the snapshot */ 2699b12a1c38Slling uint64_t cb_create; /* creation time reference */ 2700b12a1c38Slling prop_changelist_t *cb_clp; /* changelist pointer */ 2701b12a1c38Slling int cb_error; 270299653d4eSeschrock boolean_t cb_dependent; 2703b12a1c38Slling } rollback_data_t; 2704b12a1c38Slling 2705b12a1c38Slling static int 2706b12a1c38Slling rollback_destroy(zfs_handle_t *zhp, void *data) 2707b12a1c38Slling { 2708b12a1c38Slling rollback_data_t *cbp = data; 2709b12a1c38Slling 2710b12a1c38Slling if (!cbp->cb_dependent) { 2711b12a1c38Slling if (strcmp(zhp->zfs_name, cbp->cb_target) != 0 && 2712b12a1c38Slling zfs_get_type(zhp) == ZFS_TYPE_SNAPSHOT && 2713b12a1c38Slling zfs_prop_get_int(zhp, ZFS_PROP_CREATETXG) > 2714b12a1c38Slling cbp->cb_create) { 2715b12a1c38Slling 271699653d4eSeschrock cbp->cb_dependent = B_TRUE; 2717b12a1c38Slling (void) zfs_iter_dependents(zhp, rollback_destroy, cbp); 271899653d4eSeschrock cbp->cb_dependent = B_FALSE; 2719b12a1c38Slling 2720b12a1c38Slling if (zfs_destroy(zhp) != 0) 2721b12a1c38Slling cbp->cb_error = 1; 2722b12a1c38Slling else 2723b12a1c38Slling changelist_remove(zhp, cbp->cb_clp); 2724b12a1c38Slling } 2725b12a1c38Slling } else { 2726b12a1c38Slling if (zfs_destroy(zhp) != 0) 2727b12a1c38Slling cbp->cb_error = 1; 2728b12a1c38Slling else 2729b12a1c38Slling changelist_remove(zhp, cbp->cb_clp); 2730b12a1c38Slling } 2731b12a1c38Slling 2732b12a1c38Slling zfs_close(zhp); 2733b12a1c38Slling return (0); 2734b12a1c38Slling } 2735b12a1c38Slling 2736b12a1c38Slling /* 2737b12a1c38Slling * Rollback the dataset to its latest snapshot. 2738b12a1c38Slling */ 2739b12a1c38Slling static int 2740b12a1c38Slling do_rollback(zfs_handle_t *zhp) 2741fa9e4066Sahrens { 2742fa9e4066Sahrens int ret; 2743fa9e4066Sahrens zfs_cmd_t zc = { 0 }; 2744fa9e4066Sahrens 2745fa9e4066Sahrens assert(zhp->zfs_type == ZFS_TYPE_FILESYSTEM || 2746fa9e4066Sahrens zhp->zfs_type == ZFS_TYPE_VOLUME); 2747fa9e4066Sahrens 2748fa9e4066Sahrens if (zhp->zfs_type == ZFS_TYPE_VOLUME && 274999653d4eSeschrock zvol_remove_link(zhp->zfs_hdl, zhp->zfs_name) != 0) 2750fa9e4066Sahrens return (-1); 2751fa9e4066Sahrens 2752fa9e4066Sahrens (void) strlcpy(zc.zc_name, zhp->zfs_name, sizeof (zc.zc_name)); 2753fa9e4066Sahrens 2754fa9e4066Sahrens if (zhp->zfs_volblocksize != 0) 2755fa9e4066Sahrens zc.zc_objset_type = DMU_OST_ZVOL; 2756fa9e4066Sahrens else 2757fa9e4066Sahrens zc.zc_objset_type = DMU_OST_ZFS; 2758fa9e4066Sahrens 2759fa9e4066Sahrens /* 2760fa9e4066Sahrens * We rely on the consumer to verify that there are no newer snapshots 2761fa9e4066Sahrens * for the given dataset. Given these constraints, we can simply pass 2762fa9e4066Sahrens * the name on to the ioctl() call. There is still an unlikely race 2763fa9e4066Sahrens * condition where the user has taken a snapshot since we verified that 2764fa9e4066Sahrens * this was the most recent. 2765fa9e4066Sahrens */ 276699653d4eSeschrock if ((ret = ioctl(zhp->zfs_hdl->libzfs_fd, ZFS_IOC_ROLLBACK, 276799653d4eSeschrock &zc)) != 0) { 276899653d4eSeschrock (void) zfs_standard_error(zhp->zfs_hdl, errno, 276999653d4eSeschrock dgettext(TEXT_DOMAIN, "cannot rollback '%s'"), 277099653d4eSeschrock zhp->zfs_name); 2771fa9e4066Sahrens } else if (zhp->zfs_type == ZFS_TYPE_VOLUME) { 277299653d4eSeschrock ret = zvol_create_link(zhp->zfs_hdl, zhp->zfs_name); 2773fa9e4066Sahrens } 2774fa9e4066Sahrens 2775fa9e4066Sahrens return (ret); 2776fa9e4066Sahrens } 2777fa9e4066Sahrens 2778b12a1c38Slling /* 2779b12a1c38Slling * Given a dataset, rollback to a specific snapshot, discarding any 2780b12a1c38Slling * data changes since then and making it the active dataset. 2781b12a1c38Slling * 2782b12a1c38Slling * Any snapshots more recent than the target are destroyed, along with 2783b12a1c38Slling * their dependents. 2784b12a1c38Slling */ 2785b12a1c38Slling int 2786b12a1c38Slling zfs_rollback(zfs_handle_t *zhp, zfs_handle_t *snap, int flag) 2787b12a1c38Slling { 2788b12a1c38Slling int ret; 2789b12a1c38Slling rollback_data_t cb = { 0 }; 2790b12a1c38Slling prop_changelist_t *clp; 2791b12a1c38Slling 2792b12a1c38Slling /* 2793b12a1c38Slling * Unmount all dependendents of the dataset and the dataset itself. 2794b12a1c38Slling * The list we need to gather is the same as for doing rename 2795b12a1c38Slling */ 2796b12a1c38Slling clp = changelist_gather(zhp, ZFS_PROP_NAME, flag ? MS_FORCE: 0); 2797b12a1c38Slling if (clp == NULL) 2798b12a1c38Slling return (-1); 2799b12a1c38Slling 2800b12a1c38Slling if ((ret = changelist_prefix(clp)) != 0) 2801b12a1c38Slling goto out; 2802b12a1c38Slling 2803b12a1c38Slling /* 2804b12a1c38Slling * Destroy all recent snapshots and its dependends. 2805b12a1c38Slling */ 2806b12a1c38Slling cb.cb_target = snap->zfs_name; 2807b12a1c38Slling cb.cb_create = zfs_prop_get_int(snap, ZFS_PROP_CREATETXG); 2808b12a1c38Slling cb.cb_clp = clp; 2809b12a1c38Slling (void) zfs_iter_children(zhp, rollback_destroy, &cb); 2810b12a1c38Slling 2811b12a1c38Slling if ((ret = cb.cb_error) != 0) { 2812b12a1c38Slling (void) changelist_postfix(clp); 2813b12a1c38Slling goto out; 2814b12a1c38Slling } 2815b12a1c38Slling 2816b12a1c38Slling /* 2817b12a1c38Slling * Now that we have verified that the snapshot is the latest, 2818b12a1c38Slling * rollback to the given snapshot. 2819b12a1c38Slling */ 2820b12a1c38Slling ret = do_rollback(zhp); 2821b12a1c38Slling 2822b12a1c38Slling if (ret != 0) { 2823b12a1c38Slling (void) changelist_postfix(clp); 2824b12a1c38Slling goto out; 2825b12a1c38Slling } 2826b12a1c38Slling 2827b12a1c38Slling /* 2828b12a1c38Slling * We only want to re-mount the filesystem if it was mounted in the 2829b12a1c38Slling * first place. 2830b12a1c38Slling */ 2831b12a1c38Slling ret = changelist_postfix(clp); 2832b12a1c38Slling 2833b12a1c38Slling out: 2834b12a1c38Slling changelist_free(clp); 2835b12a1c38Slling return (ret); 2836b12a1c38Slling } 2837b12a1c38Slling 2838fa9e4066Sahrens /* 2839fa9e4066Sahrens * Iterate over all dependents for a given dataset. This includes both 2840fa9e4066Sahrens * hierarchical dependents (children) and data dependents (snapshots and 2841fa9e4066Sahrens * clones). The bulk of the processing occurs in get_dependents() in 2842fa9e4066Sahrens * libzfs_graph.c. 2843fa9e4066Sahrens */ 2844fa9e4066Sahrens int 2845fa9e4066Sahrens zfs_iter_dependents(zfs_handle_t *zhp, zfs_iter_f func, void *data) 2846fa9e4066Sahrens { 2847fa9e4066Sahrens char **dependents; 2848fa9e4066Sahrens size_t count; 2849fa9e4066Sahrens int i; 2850fa9e4066Sahrens zfs_handle_t *child; 2851fa9e4066Sahrens int ret = 0; 2852fa9e4066Sahrens 285399653d4eSeschrock dependents = get_dependents(zhp->zfs_hdl, zhp->zfs_name, &count); 2854fa9e4066Sahrens for (i = 0; i < count; i++) { 285599653d4eSeschrock if ((child = make_dataset_handle(zhp->zfs_hdl, 285699653d4eSeschrock dependents[i])) == NULL) 2857fa9e4066Sahrens continue; 2858fa9e4066Sahrens 2859fa9e4066Sahrens if ((ret = func(child, data)) != 0) 2860fa9e4066Sahrens break; 2861fa9e4066Sahrens } 2862fa9e4066Sahrens 2863fa9e4066Sahrens for (i = 0; i < count; i++) 2864fa9e4066Sahrens free(dependents[i]); 2865fa9e4066Sahrens free(dependents); 2866fa9e4066Sahrens 2867fa9e4066Sahrens return (ret); 2868fa9e4066Sahrens } 2869fa9e4066Sahrens 2870fa9e4066Sahrens /* 2871fa9e4066Sahrens * Renames the given dataset. 2872fa9e4066Sahrens */ 2873fa9e4066Sahrens int 2874fa9e4066Sahrens zfs_rename(zfs_handle_t *zhp, const char *target) 2875fa9e4066Sahrens { 2876fa9e4066Sahrens int ret; 2877fa9e4066Sahrens zfs_cmd_t zc = { 0 }; 2878fa9e4066Sahrens char *delim; 2879fa9e4066Sahrens prop_changelist_t *cl; 2880fa9e4066Sahrens char parent[ZFS_MAXNAMELEN]; 288199653d4eSeschrock libzfs_handle_t *hdl = zhp->zfs_hdl; 288299653d4eSeschrock char errbuf[1024]; 2883fa9e4066Sahrens 2884fa9e4066Sahrens (void) strlcpy(zc.zc_name, zhp->zfs_name, sizeof (zc.zc_name)); 2885fa9e4066Sahrens (void) strlcpy(zc.zc_prop_value, target, sizeof (zc.zc_prop_value)); 2886fa9e4066Sahrens 2887fa9e4066Sahrens /* if we have the same exact name, just return success */ 2888fa9e4066Sahrens if (strcmp(zhp->zfs_name, target) == 0) 2889fa9e4066Sahrens return (0); 2890fa9e4066Sahrens 289199653d4eSeschrock (void) snprintf(errbuf, sizeof (errbuf), dgettext(TEXT_DOMAIN, 289299653d4eSeschrock "cannot rename to '%s'"), target); 289399653d4eSeschrock 2894fa9e4066Sahrens /* 2895fa9e4066Sahrens * Make sure the target name is valid 2896fa9e4066Sahrens */ 289799653d4eSeschrock if (!zfs_validate_name(hdl, target, zhp->zfs_type)) 289899653d4eSeschrock return (zfs_error(hdl, EZFS_INVALIDNAME, errbuf)); 2899fa9e4066Sahrens 2900fa9e4066Sahrens if (zhp->zfs_type == ZFS_TYPE_SNAPSHOT) { 290199653d4eSeschrock 2902fa9e4066Sahrens if ((delim = strchr(target, '@')) == NULL) { 290399653d4eSeschrock zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, 290499653d4eSeschrock "not a snapshot")); 290599653d4eSeschrock return (zfs_error(hdl, EZFS_BADTYPE, errbuf)); 2906fa9e4066Sahrens } 2907fa9e4066Sahrens 2908fa9e4066Sahrens /* 2909fa9e4066Sahrens * Make sure we're renaming within the same dataset. 2910fa9e4066Sahrens */ 2911fa9e4066Sahrens if (strncmp(zhp->zfs_name, target, delim - target) != 0 || 2912fa9e4066Sahrens zhp->zfs_name[delim - target] != '@') { 291399653d4eSeschrock zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, 291499653d4eSeschrock "snapshots must be part of same dataset")); 291599653d4eSeschrock return (zfs_error(hdl, EZFS_CROSSTARGET, errbuf)); 2916fa9e4066Sahrens } 2917fa9e4066Sahrens 2918fa9e4066Sahrens (void) strncpy(parent, target, delim - target); 2919fa9e4066Sahrens parent[delim - target] = '\0'; 2920fa9e4066Sahrens } else { 2921fa9e4066Sahrens /* validate parents */ 292299653d4eSeschrock if (check_parents(hdl, target) != 0) 2923fa9e4066Sahrens return (-1); 2924fa9e4066Sahrens 2925fa9e4066Sahrens (void) parent_name(target, parent, sizeof (parent)); 2926fa9e4066Sahrens 2927fa9e4066Sahrens /* make sure we're in the same pool */ 2928fa9e4066Sahrens verify((delim = strchr(target, '/')) != NULL); 2929fa9e4066Sahrens if (strncmp(zhp->zfs_name, target, delim - target) != 0 || 2930fa9e4066Sahrens zhp->zfs_name[delim - target] != '/') { 293199653d4eSeschrock zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, 293299653d4eSeschrock "datasets must be within same pool")); 293399653d4eSeschrock return (zfs_error(hdl, EZFS_CROSSTARGET, errbuf)); 2934fa9e4066Sahrens } 2935fa9e4066Sahrens } 2936fa9e4066Sahrens 293799653d4eSeschrock (void) snprintf(errbuf, sizeof (errbuf), 293899653d4eSeschrock dgettext(TEXT_DOMAIN, "cannot rename '%s'"), zhp->zfs_name); 293999653d4eSeschrock 2940fa9e4066Sahrens if (getzoneid() == GLOBAL_ZONEID && 2941fa9e4066Sahrens zfs_prop_get_int(zhp, ZFS_PROP_ZONED)) { 294299653d4eSeschrock zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, 294399653d4eSeschrock "dataset is used in a non-global zone")); 294499653d4eSeschrock return (zfs_error(hdl, EZFS_ZONED, errbuf)); 2945fa9e4066Sahrens } 2946fa9e4066Sahrens 2947fa9e4066Sahrens if ((cl = changelist_gather(zhp, ZFS_PROP_NAME, 0)) == NULL) 294899653d4eSeschrock return (-1); 2949fa9e4066Sahrens 2950fa9e4066Sahrens if (changelist_haszonedchild(cl)) { 295199653d4eSeschrock zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, 295299653d4eSeschrock "child dataset with inherited mountpoint is used " 295399653d4eSeschrock "in a non-global zone")); 295499653d4eSeschrock ret = zfs_error(hdl, EZFS_ZONED, errbuf); 2955fa9e4066Sahrens goto error; 2956fa9e4066Sahrens } 2957fa9e4066Sahrens 2958fa9e4066Sahrens if ((ret = changelist_prefix(cl)) != 0) 2959fa9e4066Sahrens goto error; 2960fa9e4066Sahrens 2961fa9e4066Sahrens if (zhp->zfs_volblocksize != 0) 2962fa9e4066Sahrens zc.zc_objset_type = DMU_OST_ZVOL; 2963fa9e4066Sahrens else 2964fa9e4066Sahrens zc.zc_objset_type = DMU_OST_ZFS; 2965fa9e4066Sahrens 296699653d4eSeschrock if ((ret = ioctl(zhp->zfs_hdl->libzfs_fd, ZFS_IOC_RENAME, &zc)) != 0) { 296799653d4eSeschrock (void) zfs_standard_error(zhp->zfs_hdl, errno, errbuf); 2968fa9e4066Sahrens 2969fa9e4066Sahrens /* 2970fa9e4066Sahrens * On failure, we still want to remount any filesystems that 2971fa9e4066Sahrens * were previously mounted, so we don't alter the system state. 2972fa9e4066Sahrens */ 2973fa9e4066Sahrens (void) changelist_postfix(cl); 2974fa9e4066Sahrens } else { 2975fa9e4066Sahrens changelist_rename(cl, zfs_get_name(zhp), target); 2976fa9e4066Sahrens 2977fa9e4066Sahrens ret = changelist_postfix(cl); 2978fa9e4066Sahrens } 2979fa9e4066Sahrens 2980fa9e4066Sahrens error: 2981fa9e4066Sahrens changelist_free(cl); 2982fa9e4066Sahrens return (ret); 2983fa9e4066Sahrens } 2984fa9e4066Sahrens 2985fa9e4066Sahrens /* 2986fa9e4066Sahrens * Given a zvol dataset, issue the ioctl to create the appropriate minor node, 2987fa9e4066Sahrens * poke devfsadm to create the /dev link, and then wait for the link to appear. 2988fa9e4066Sahrens */ 2989fa9e4066Sahrens int 299099653d4eSeschrock zvol_create_link(libzfs_handle_t *hdl, const char *dataset) 2991fa9e4066Sahrens { 2992fa9e4066Sahrens zfs_cmd_t zc = { 0 }; 299399653d4eSeschrock di_devlink_handle_t dhdl; 2994fa9e4066Sahrens 2995fa9e4066Sahrens (void) strlcpy(zc.zc_name, dataset, sizeof (zc.zc_name)); 2996fa9e4066Sahrens 2997fa9e4066Sahrens /* 2998fa9e4066Sahrens * Issue the appropriate ioctl. 2999fa9e4066Sahrens */ 300099653d4eSeschrock if (ioctl(hdl->libzfs_fd, ZFS_IOC_CREATE_MINOR, &zc) != 0) { 3001fa9e4066Sahrens switch (errno) { 3002fa9e4066Sahrens case EEXIST: 3003fa9e4066Sahrens /* 3004fa9e4066Sahrens * Silently ignore the case where the link already 3005fa9e4066Sahrens * exists. This allows 'zfs volinit' to be run multiple 3006fa9e4066Sahrens * times without errors. 3007fa9e4066Sahrens */ 3008fa9e4066Sahrens return (0); 3009fa9e4066Sahrens 3010fa9e4066Sahrens default: 301199653d4eSeschrock return (zfs_standard_error(hdl, errno, 301299653d4eSeschrock dgettext(TEXT_DOMAIN, "cannot create device links " 301399653d4eSeschrock "for '%s'"), dataset)); 3014fa9e4066Sahrens } 3015fa9e4066Sahrens } 3016fa9e4066Sahrens 3017fa9e4066Sahrens /* 3018fa9e4066Sahrens * Call devfsadm and wait for the links to magically appear. 3019fa9e4066Sahrens */ 302099653d4eSeschrock if ((dhdl = di_devlink_init(ZFS_DRIVER, DI_MAKE_LINK)) == NULL) { 302199653d4eSeschrock zfs_error_aux(hdl, strerror(errno)); 302299653d4eSeschrock (void) zfs_error(hdl, EZFS_DEVLINKS, 302399653d4eSeschrock dgettext(TEXT_DOMAIN, "cannot create device links " 302499653d4eSeschrock "for '%s'"), dataset); 302599653d4eSeschrock (void) ioctl(hdl->libzfs_fd, ZFS_IOC_REMOVE_MINOR, &zc); 3026fa9e4066Sahrens return (-1); 3027fa9e4066Sahrens } else { 302899653d4eSeschrock (void) di_devlink_fini(&dhdl); 3029fa9e4066Sahrens } 3030fa9e4066Sahrens 3031fa9e4066Sahrens return (0); 3032fa9e4066Sahrens } 3033fa9e4066Sahrens 3034fa9e4066Sahrens /* 3035fa9e4066Sahrens * Remove a minor node for the given zvol and the associated /dev links. 3036fa9e4066Sahrens */ 3037fa9e4066Sahrens int 303899653d4eSeschrock zvol_remove_link(libzfs_handle_t *hdl, const char *dataset) 3039fa9e4066Sahrens { 3040fa9e4066Sahrens zfs_cmd_t zc = { 0 }; 3041fa9e4066Sahrens 3042fa9e4066Sahrens (void) strlcpy(zc.zc_name, dataset, sizeof (zc.zc_name)); 3043fa9e4066Sahrens 304499653d4eSeschrock if (ioctl(hdl->libzfs_fd, ZFS_IOC_REMOVE_MINOR, &zc) != 0) { 3045fa9e4066Sahrens switch (errno) { 3046fa9e4066Sahrens case ENXIO: 3047fa9e4066Sahrens /* 3048fa9e4066Sahrens * Silently ignore the case where the link no longer 3049fa9e4066Sahrens * exists, so that 'zfs volfini' can be run multiple 3050fa9e4066Sahrens * times without errors. 3051fa9e4066Sahrens */ 3052fa9e4066Sahrens return (0); 3053fa9e4066Sahrens 3054fa9e4066Sahrens default: 305599653d4eSeschrock return (zfs_standard_error(hdl, errno, 305699653d4eSeschrock dgettext(TEXT_DOMAIN, "cannot remove device " 305799653d4eSeschrock "links for '%s'"), dataset)); 3058fa9e4066Sahrens } 3059fa9e4066Sahrens } 3060fa9e4066Sahrens 3061fa9e4066Sahrens return (0); 3062fa9e4066Sahrens } 3063