1fa9e4066Sahrens /* 2fa9e4066Sahrens * CDDL HEADER START 3fa9e4066Sahrens * 4fa9e4066Sahrens * The contents of this file are subject to the terms of the 5fa9e4066Sahrens * Common Development and Distribution License, Version 1.0 only 6fa9e4066Sahrens * (the "License"). You may not use this file except in compliance 7fa9e4066Sahrens * with the License. 8fa9e4066Sahrens * 9fa9e4066Sahrens * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 10fa9e4066Sahrens * or http://www.opensolaris.org/os/licensing. 11fa9e4066Sahrens * See the License for the specific language governing permissions 12fa9e4066Sahrens * and limitations under the License. 13fa9e4066Sahrens * 14fa9e4066Sahrens * When distributing Covered Code, include this CDDL HEADER in each 15fa9e4066Sahrens * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 16fa9e4066Sahrens * If applicable, add the following below this CDDL HEADER, with the 17fa9e4066Sahrens * fields enclosed by brackets "[]" replaced with your own identifying 18fa9e4066Sahrens * information: Portions Copyright [yyyy] [name of copyright owner] 19fa9e4066Sahrens * 20fa9e4066Sahrens * CDDL HEADER END 21fa9e4066Sahrens */ 22fa9e4066Sahrens /* 23b12a1c38Slling * Copyright 2006 Sun Microsystems, Inc. All rights reserved. 24fa9e4066Sahrens * Use is subject to license terms. 25fa9e4066Sahrens */ 26fa9e4066Sahrens 27fa9e4066Sahrens #pragma ident "%Z%%M% %I% %E% SMI" 28fa9e4066Sahrens 29fa9e4066Sahrens #include <assert.h> 30fa9e4066Sahrens #include <ctype.h> 31fa9e4066Sahrens #include <errno.h> 32fa9e4066Sahrens #include <libdevinfo.h> 33fa9e4066Sahrens #include <libintl.h> 34fa9e4066Sahrens #include <math.h> 35fa9e4066Sahrens #include <stdio.h> 36fa9e4066Sahrens #include <stdlib.h> 37fa9e4066Sahrens #include <strings.h> 38fa9e4066Sahrens #include <unistd.h> 39fa9e4066Sahrens #include <zone.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 zfs_baderror(type); 69fa9e4066Sahrens return (NULL); 70fa9e4066Sahrens } 71fa9e4066Sahrens 72fa9e4066Sahrens /* 73fa9e4066Sahrens * Given a path and mask of ZFS types, return a string describing this dataset. 74fa9e4066Sahrens * This is used when we fail to open a dataset and we cannot get an exact type. 75fa9e4066Sahrens * We guess what the type would have been based on the path and the mask of 76fa9e4066Sahrens * acceptable types. 77fa9e4066Sahrens */ 78fa9e4066Sahrens static const char * 79fa9e4066Sahrens path_to_str(const char *path, int types) 80fa9e4066Sahrens { 81fa9e4066Sahrens /* 82fa9e4066Sahrens * When given a single type, always report the exact type. 83fa9e4066Sahrens */ 84fa9e4066Sahrens if (types == ZFS_TYPE_SNAPSHOT) 85fa9e4066Sahrens return (dgettext(TEXT_DOMAIN, "snapshot")); 86fa9e4066Sahrens if (types == ZFS_TYPE_FILESYSTEM) 87fa9e4066Sahrens return (dgettext(TEXT_DOMAIN, "filesystem")); 88fa9e4066Sahrens if (types == ZFS_TYPE_VOLUME) 89fa9e4066Sahrens return (dgettext(TEXT_DOMAIN, "volume")); 90fa9e4066Sahrens 91fa9e4066Sahrens /* 92fa9e4066Sahrens * The user is requesting more than one type of dataset. If this is the 93fa9e4066Sahrens * case, consult the path itself. If we're looking for a snapshot, and 94fa9e4066Sahrens * a '@' is found, then report it as "snapshot". Otherwise, remove the 95fa9e4066Sahrens * snapshot attribute and try again. 96fa9e4066Sahrens */ 97fa9e4066Sahrens if (types & ZFS_TYPE_SNAPSHOT) { 98fa9e4066Sahrens if (strchr(path, '@') != NULL) 99fa9e4066Sahrens return (dgettext(TEXT_DOMAIN, "snapshot")); 100fa9e4066Sahrens return (path_to_str(path, types & ~ZFS_TYPE_SNAPSHOT)); 101fa9e4066Sahrens } 102fa9e4066Sahrens 103fa9e4066Sahrens 104fa9e4066Sahrens /* 105fa9e4066Sahrens * The user has requested either filesystems or volumes. 106fa9e4066Sahrens * We have no way of knowing a priori what type this would be, so always 107fa9e4066Sahrens * report it as "filesystem" or "volume", our two primitive types. 108fa9e4066Sahrens */ 109fa9e4066Sahrens if (types & ZFS_TYPE_FILESYSTEM) 110fa9e4066Sahrens return (dgettext(TEXT_DOMAIN, "filesystem")); 111fa9e4066Sahrens 112fa9e4066Sahrens assert(types & ZFS_TYPE_VOLUME); 113fa9e4066Sahrens return (dgettext(TEXT_DOMAIN, "volume")); 114fa9e4066Sahrens } 115fa9e4066Sahrens 116fa9e4066Sahrens /* 117fa9e4066Sahrens * Validate a ZFS path. This is used even before trying to open the dataset, to 118fa9e4066Sahrens * provide a more meaningful error message. We place a more useful message in 119fa9e4066Sahrens * 'buf' detailing exactly why the name was not valid. 120fa9e4066Sahrens */ 121fa9e4066Sahrens static int 122fa9e4066Sahrens zfs_validate_name(const char *path, int type, char *buf, size_t buflen) 123fa9e4066Sahrens { 124fa9e4066Sahrens namecheck_err_t why; 125fa9e4066Sahrens char what; 126fa9e4066Sahrens 127fa9e4066Sahrens if (dataset_namecheck(path, &why, &what) != 0) { 128fa9e4066Sahrens if (buf != NULL) { 129fa9e4066Sahrens switch (why) { 130b81d61a6Slling case NAME_ERR_TOOLONG: 131b81d61a6Slling (void) strlcpy(buf, dgettext(TEXT_DOMAIN, 132b81d61a6Slling "name is too long"), buflen); 133b81d61a6Slling break; 134b81d61a6Slling 135fa9e4066Sahrens case NAME_ERR_LEADING_SLASH: 136fa9e4066Sahrens (void) strlcpy(buf, dgettext(TEXT_DOMAIN, 137fa9e4066Sahrens "leading slash"), buflen); 138fa9e4066Sahrens break; 139fa9e4066Sahrens 140fa9e4066Sahrens case NAME_ERR_EMPTY_COMPONENT: 141fa9e4066Sahrens (void) strlcpy(buf, dgettext(TEXT_DOMAIN, 142fa9e4066Sahrens "empty component"), buflen); 143fa9e4066Sahrens break; 144fa9e4066Sahrens 145fa9e4066Sahrens case NAME_ERR_TRAILING_SLASH: 146fa9e4066Sahrens (void) strlcpy(buf, dgettext(TEXT_DOMAIN, 147fa9e4066Sahrens "trailing slash"), buflen); 148fa9e4066Sahrens break; 149fa9e4066Sahrens 150fa9e4066Sahrens case NAME_ERR_INVALCHAR: 151fa9e4066Sahrens (void) snprintf(buf, buflen, 152fa9e4066Sahrens dgettext(TEXT_DOMAIN, "invalid character " 153fa9e4066Sahrens "'%c'"), what); 154fa9e4066Sahrens break; 155fa9e4066Sahrens 156fa9e4066Sahrens case NAME_ERR_MULTIPLE_AT: 157fa9e4066Sahrens (void) strlcpy(buf, dgettext(TEXT_DOMAIN, 158fa9e4066Sahrens "multiple '@' delimiters"), buflen); 159fa9e4066Sahrens break; 160fa9e4066Sahrens } 161fa9e4066Sahrens } 162fa9e4066Sahrens 163fa9e4066Sahrens return (0); 164fa9e4066Sahrens } 165fa9e4066Sahrens 166fa9e4066Sahrens if (!(type & ZFS_TYPE_SNAPSHOT) && strchr(path, '@') != NULL) { 167fa9e4066Sahrens if (buf != NULL) 168fa9e4066Sahrens (void) strlcpy(buf, 169fa9e4066Sahrens dgettext(TEXT_DOMAIN, 170fa9e4066Sahrens "snapshot delimiter '@'"), buflen); 171fa9e4066Sahrens return (0); 172fa9e4066Sahrens } 173fa9e4066Sahrens 174fa9e4066Sahrens return (1); 175fa9e4066Sahrens } 176fa9e4066Sahrens 177fa9e4066Sahrens int 178fa9e4066Sahrens zfs_name_valid(const char *name, zfs_type_t type) 179fa9e4066Sahrens { 180fa9e4066Sahrens return (zfs_validate_name(name, type, NULL, NULL)); 181fa9e4066Sahrens } 182fa9e4066Sahrens 183fa9e4066Sahrens /* 184fa9e4066Sahrens * Utility function to gather stats (objset and zpl) for the given object. 185fa9e4066Sahrens */ 186fa9e4066Sahrens static int 187fa9e4066Sahrens get_stats(zfs_handle_t *zhp) 188fa9e4066Sahrens { 189fa9e4066Sahrens zfs_cmd_t zc = { 0 }; 190fa9e4066Sahrens 191fa9e4066Sahrens (void) strlcpy(zc.zc_name, zhp->zfs_name, sizeof (zc.zc_name)); 192fa9e4066Sahrens 1937f7322feSeschrock zc.zc_config_src = (uint64_t)(uintptr_t)zfs_malloc(1024); 1947f7322feSeschrock zc.zc_config_src_size = 1024; 1957f7322feSeschrock 1967f7322feSeschrock while (ioctl(zfs_fd, ZFS_IOC_OBJSET_STATS, &zc) != 0) { 1977f7322feSeschrock if (errno == ENOMEM) { 1987f7322feSeschrock zc.zc_config_src = (uint64_t)(uintptr_t) 1997f7322feSeschrock zfs_malloc(zc.zc_config_src_size); 2007f7322feSeschrock } else { 2017f7322feSeschrock free((void *)(uintptr_t)zc.zc_config_src); 2027f7322feSeschrock return (-1); 2037f7322feSeschrock } 2047f7322feSeschrock } 205fa9e4066Sahrens 206fa9e4066Sahrens bcopy(&zc.zc_objset_stats, &zhp->zfs_dmustats, 207fa9e4066Sahrens sizeof (zc.zc_objset_stats)); 208fa9e4066Sahrens 2097f7322feSeschrock verify(nvlist_unpack((void *)(uintptr_t)zc.zc_config_src, 2107f7322feSeschrock zc.zc_config_src_size, &zhp->zfs_props, 0) == 0); 211fa9e4066Sahrens 212fa9e4066Sahrens zhp->zfs_volsize = zc.zc_volsize; 213fa9e4066Sahrens zhp->zfs_volblocksize = zc.zc_volblocksize; 214fa9e4066Sahrens 215fa9e4066Sahrens return (0); 216fa9e4066Sahrens } 217fa9e4066Sahrens 218fa9e4066Sahrens /* 219fa9e4066Sahrens * Refresh the properties currently stored in the handle. 220fa9e4066Sahrens */ 221fa9e4066Sahrens void 222fa9e4066Sahrens zfs_refresh_properties(zfs_handle_t *zhp) 223fa9e4066Sahrens { 224fa9e4066Sahrens (void) get_stats(zhp); 225fa9e4066Sahrens } 226fa9e4066Sahrens 227fa9e4066Sahrens /* 228fa9e4066Sahrens * Makes a handle from the given dataset name. Used by zfs_open() and 229fa9e4066Sahrens * zfs_iter_* to create child handles on the fly. 230fa9e4066Sahrens */ 231fa9e4066Sahrens zfs_handle_t * 232fa9e4066Sahrens make_dataset_handle(const char *path) 233fa9e4066Sahrens { 234fa9e4066Sahrens zfs_handle_t *zhp = zfs_malloc(sizeof (zfs_handle_t)); 235fa9e4066Sahrens 236fa9e4066Sahrens (void) strlcpy(zhp->zfs_name, path, sizeof (zhp->zfs_name)); 237fa9e4066Sahrens 238fa9e4066Sahrens if (get_stats(zhp) != 0) { 239fa9e4066Sahrens free(zhp); 240fa9e4066Sahrens return (NULL); 241fa9e4066Sahrens } 242fa9e4066Sahrens 243fa9e4066Sahrens /* 244fa9e4066Sahrens * We've managed to open the dataset and gather statistics. Determine 245fa9e4066Sahrens * the high-level type. 246fa9e4066Sahrens */ 247fa9e4066Sahrens if (zhp->zfs_dmustats.dds_is_snapshot) 248fa9e4066Sahrens zhp->zfs_type = ZFS_TYPE_SNAPSHOT; 249fa9e4066Sahrens else if (zhp->zfs_dmustats.dds_type == DMU_OST_ZVOL) 250fa9e4066Sahrens zhp->zfs_type = ZFS_TYPE_VOLUME; 251fa9e4066Sahrens else if (zhp->zfs_dmustats.dds_type == DMU_OST_ZFS) 252fa9e4066Sahrens zhp->zfs_type = ZFS_TYPE_FILESYSTEM; 253fa9e4066Sahrens else 254fa9e4066Sahrens /* we should never see any other dataset types */ 255fa9e4066Sahrens zfs_baderror(zhp->zfs_dmustats.dds_type); 256fa9e4066Sahrens 257fa9e4066Sahrens return (zhp); 258fa9e4066Sahrens } 259fa9e4066Sahrens 260fa9e4066Sahrens /* 261fa9e4066Sahrens * Opens the given snapshot, filesystem, or volume. The 'types' 262fa9e4066Sahrens * argument is a mask of acceptable types. The function will print an 263fa9e4066Sahrens * appropriate error message and return NULL if it can't be opened. 264fa9e4066Sahrens */ 265fa9e4066Sahrens zfs_handle_t * 266fa9e4066Sahrens zfs_open(const char *path, int types) 267fa9e4066Sahrens { 268fa9e4066Sahrens zfs_handle_t *zhp; 269fa9e4066Sahrens 270fa9e4066Sahrens /* 271fa9e4066Sahrens * Validate the name before we even try to open it. We don't care about 272fa9e4066Sahrens * the verbose invalid messages here; just report a generic error. 273fa9e4066Sahrens */ 274fa9e4066Sahrens if (!zfs_validate_name(path, types, NULL, 0)) { 275fa9e4066Sahrens zfs_error(dgettext(TEXT_DOMAIN, 276fa9e4066Sahrens "cannot open '%s': invalid %s name"), path, 277fa9e4066Sahrens path_to_str(path, types)); 278fa9e4066Sahrens return (NULL); 279fa9e4066Sahrens } 280fa9e4066Sahrens 281fa9e4066Sahrens /* 282fa9e4066Sahrens * Try to get stats for the dataset, which will tell us if it exists. 283fa9e4066Sahrens */ 284fa9e4066Sahrens errno = 0; 285fa9e4066Sahrens if ((zhp = make_dataset_handle(path)) == NULL) { 286fa9e4066Sahrens switch (errno) { 287fa9e4066Sahrens case ENOENT: 288fa9e4066Sahrens /* 289fa9e4066Sahrens * The dataset doesn't exist. 290fa9e4066Sahrens */ 291fa9e4066Sahrens zfs_error(dgettext(TEXT_DOMAIN, 292fa9e4066Sahrens "cannot open '%s': no such %s"), path, 293fa9e4066Sahrens path_to_str(path, types)); 294fa9e4066Sahrens break; 295fa9e4066Sahrens 296fa9e4066Sahrens case EBUSY: 297fa9e4066Sahrens /* 298fa9e4066Sahrens * We were able to open the dataset but couldn't 299fa9e4066Sahrens * get the stats. 300fa9e4066Sahrens */ 301fa9e4066Sahrens zfs_error(dgettext(TEXT_DOMAIN, 302fa9e4066Sahrens "cannot open '%s': %s is busy"), path, 303fa9e4066Sahrens path_to_str(path, types)); 304fa9e4066Sahrens break; 305fa9e4066Sahrens 306fa9e4066Sahrens default: 307fa9e4066Sahrens zfs_baderror(errno); 308fa9e4066Sahrens 309fa9e4066Sahrens } 310fa9e4066Sahrens return (NULL); 311fa9e4066Sahrens } 312fa9e4066Sahrens 313fa9e4066Sahrens if (!(types & zhp->zfs_type)) { 314fa9e4066Sahrens zfs_error(dgettext(TEXT_DOMAIN, "cannot open '%s': operation " 315fa9e4066Sahrens "not supported for %ss"), path, 316fa9e4066Sahrens zfs_type_to_name(zhp->zfs_type)); 317fa9e4066Sahrens free(zhp); 318fa9e4066Sahrens return (NULL); 319fa9e4066Sahrens } 320fa9e4066Sahrens 321fa9e4066Sahrens return (zhp); 322fa9e4066Sahrens } 323fa9e4066Sahrens 324fa9e4066Sahrens /* 325fa9e4066Sahrens * Release a ZFS handle. Nothing to do but free the associated memory. 326fa9e4066Sahrens */ 327fa9e4066Sahrens void 328fa9e4066Sahrens zfs_close(zfs_handle_t *zhp) 329fa9e4066Sahrens { 330fa9e4066Sahrens if (zhp->zfs_mntopts) 331fa9e4066Sahrens free(zhp->zfs_mntopts); 332fa9e4066Sahrens free(zhp); 333fa9e4066Sahrens } 334fa9e4066Sahrens 335fa9e4066Sahrens struct { 336fa9e4066Sahrens const char *name; 337fa9e4066Sahrens uint64_t value; 338fa9e4066Sahrens } checksum_table[] = { 339fa9e4066Sahrens { "on", ZIO_CHECKSUM_ON }, 340fa9e4066Sahrens { "off", ZIO_CHECKSUM_OFF }, 341fa9e4066Sahrens { "fletcher2", ZIO_CHECKSUM_FLETCHER_2 }, 342fa9e4066Sahrens { "fletcher4", ZIO_CHECKSUM_FLETCHER_4 }, 343fa9e4066Sahrens { "sha256", ZIO_CHECKSUM_SHA256 }, 344fa9e4066Sahrens { NULL } 345fa9e4066Sahrens }; 346fa9e4066Sahrens 347fa9e4066Sahrens struct { 348fa9e4066Sahrens const char *name; 349fa9e4066Sahrens uint64_t value; 350fa9e4066Sahrens } compress_table[] = { 351fa9e4066Sahrens { "on", ZIO_COMPRESS_ON }, 352fa9e4066Sahrens { "off", ZIO_COMPRESS_OFF }, 353fa9e4066Sahrens { "lzjb", ZIO_COMPRESS_LZJB }, 354fa9e4066Sahrens { NULL } 355fa9e4066Sahrens }; 356fa9e4066Sahrens 357fa9e4066Sahrens struct { 358fa9e4066Sahrens const char *name; 359fa9e4066Sahrens uint64_t value; 360fa9e4066Sahrens } snapdir_table[] = { 361a0965f35Sbonwick { "hidden", ZFS_SNAPDIR_HIDDEN }, 362a0965f35Sbonwick { "visible", ZFS_SNAPDIR_VISIBLE }, 363fa9e4066Sahrens { NULL } 364fa9e4066Sahrens }; 365fa9e4066Sahrens 366fa9e4066Sahrens struct { 367fa9e4066Sahrens const char *name; 368fa9e4066Sahrens uint64_t value; 369fa9e4066Sahrens } acl_mode_table[] = { 370fa9e4066Sahrens { "discard", DISCARD }, 371fa9e4066Sahrens { "groupmask", GROUPMASK }, 372fa9e4066Sahrens { "passthrough", PASSTHROUGH }, 373fa9e4066Sahrens { NULL } 374fa9e4066Sahrens }; 375fa9e4066Sahrens 376fa9e4066Sahrens struct { 377fa9e4066Sahrens const char *name; 378fa9e4066Sahrens uint64_t value; 379fa9e4066Sahrens } acl_inherit_table[] = { 380fa9e4066Sahrens { "discard", DISCARD }, 381fa9e4066Sahrens { "noallow", NOALLOW }, 382fa9e4066Sahrens { "secure", SECURE }, 383fa9e4066Sahrens { "passthrough", PASSTHROUGH }, 384fa9e4066Sahrens { NULL } 385fa9e4066Sahrens }; 386fa9e4066Sahrens 387fa9e4066Sahrens 388fa9e4066Sahrens /* 389fa9e4066Sahrens * Given a numeric suffix, convert the value into a number of bits that the 390fa9e4066Sahrens * resulting value must be shifted. 391fa9e4066Sahrens */ 392fa9e4066Sahrens static int 393fa9e4066Sahrens str2shift(const char *buf, char *reason, size_t len) 394fa9e4066Sahrens { 395fa9e4066Sahrens const char *ends = "BKMGTPEZ"; 396fa9e4066Sahrens int i; 397fa9e4066Sahrens 398fa9e4066Sahrens if (buf[0] == '\0') 399fa9e4066Sahrens return (0); 400fa9e4066Sahrens for (i = 0; i < strlen(ends); i++) { 401fa9e4066Sahrens if (toupper(buf[0]) == ends[i]) 402fa9e4066Sahrens break; 403fa9e4066Sahrens } 404fa9e4066Sahrens if (i == strlen(ends)) { 405fa9e4066Sahrens (void) snprintf(reason, len, dgettext(TEXT_DOMAIN, "invalid " 406fa9e4066Sahrens "numeric suffix '%s'"), buf); 407fa9e4066Sahrens return (-1); 408fa9e4066Sahrens } 409fa9e4066Sahrens 410fa9e4066Sahrens /* 411fa9e4066Sahrens * We want to allow trailing 'b' characters for 'GB' or 'Mb'. But don't 412fa9e4066Sahrens * allow 'BB' - that's just weird. 413fa9e4066Sahrens */ 414fa9e4066Sahrens if (buf[1] == '\0' || (toupper(buf[1]) == 'B' && buf[2] == '\0' && 415fa9e4066Sahrens toupper(buf[0]) != 'B')) { 416fa9e4066Sahrens return (10*i); 417fa9e4066Sahrens } 418fa9e4066Sahrens 419fa9e4066Sahrens (void) snprintf(reason, len, dgettext(TEXT_DOMAIN, "invalid numeric " 420fa9e4066Sahrens "suffix '%s'"), buf); 421fa9e4066Sahrens return (-1); 422fa9e4066Sahrens } 423fa9e4066Sahrens 424fa9e4066Sahrens /* 425fa9e4066Sahrens * Convert a string of the form '100G' into a real number. Used when setting 426fa9e4066Sahrens * properties or creating a volume. 'buf' is used to place an extended error 427fa9e4066Sahrens * message for the caller to use. 428fa9e4066Sahrens */ 429fa9e4066Sahrens static int 430fa9e4066Sahrens nicestrtonum(const char *value, uint64_t *num, char *buf, size_t buflen) 431fa9e4066Sahrens { 432fa9e4066Sahrens char *end; 433fa9e4066Sahrens int shift; 434fa9e4066Sahrens 435fa9e4066Sahrens *num = 0; 436fa9e4066Sahrens 437fa9e4066Sahrens /* Check to see if this looks like a number. */ 438fa9e4066Sahrens if ((value[0] < '0' || value[0] > '9') && value[0] != '.') { 439fa9e4066Sahrens (void) strlcpy(buf, dgettext(TEXT_DOMAIN, 440fa9e4066Sahrens "must be a numeric value"), buflen); 441fa9e4066Sahrens return (-1); 442fa9e4066Sahrens } 443fa9e4066Sahrens 444fa9e4066Sahrens /* Rely on stroll() to process the numeric portion. */ 445fa9e4066Sahrens errno = 0; 446fa9e4066Sahrens *num = strtoll(value, &end, 10); 447fa9e4066Sahrens 448fa9e4066Sahrens /* 449fa9e4066Sahrens * Check for ERANGE, which indicates that the value is too large to fit 450fa9e4066Sahrens * in a 64-bit value. 451fa9e4066Sahrens */ 452fa9e4066Sahrens if (errno == ERANGE) { 453fa9e4066Sahrens (void) strlcpy(buf, dgettext(TEXT_DOMAIN, 454fa9e4066Sahrens "value is too large"), buflen); 455fa9e4066Sahrens return (-1); 456fa9e4066Sahrens } 457fa9e4066Sahrens 458fa9e4066Sahrens /* 459fa9e4066Sahrens * If we have a decimal value, then do the computation with floating 460fa9e4066Sahrens * point arithmetic. Otherwise, use standard arithmetic. 461fa9e4066Sahrens */ 462fa9e4066Sahrens if (*end == '.') { 463fa9e4066Sahrens double fval = strtod(value, &end); 464fa9e4066Sahrens 465fa9e4066Sahrens if ((shift = str2shift(end, buf, buflen)) == -1) 466fa9e4066Sahrens return (-1); 467fa9e4066Sahrens 468fa9e4066Sahrens fval *= pow(2, shift); 469fa9e4066Sahrens 470fa9e4066Sahrens if (fval > UINT64_MAX) { 471fa9e4066Sahrens (void) strlcpy(buf, dgettext(TEXT_DOMAIN, 472fa9e4066Sahrens "value is too large"), buflen); 473fa9e4066Sahrens return (-1); 474fa9e4066Sahrens } 475fa9e4066Sahrens 476fa9e4066Sahrens *num = (uint64_t)fval; 477fa9e4066Sahrens } else { 478fa9e4066Sahrens if ((shift = str2shift(end, buf, buflen)) == -1) 479fa9e4066Sahrens return (-1); 480fa9e4066Sahrens 481fa9e4066Sahrens /* Check for overflow */ 482fa9e4066Sahrens if (shift >= 64 || (*num << shift) >> shift != *num) { 483fa9e4066Sahrens (void) strlcpy(buf, dgettext(TEXT_DOMAIN, 484fa9e4066Sahrens "value is too large"), buflen); 485fa9e4066Sahrens return (-1); 486fa9e4066Sahrens } 487fa9e4066Sahrens 488fa9e4066Sahrens *num <<= shift; 489fa9e4066Sahrens } 490fa9e4066Sahrens 491fa9e4066Sahrens return (0); 492fa9e4066Sahrens } 493fa9e4066Sahrens 494fa9e4066Sahrens int 495fa9e4066Sahrens zfs_nicestrtonum(const char *str, uint64_t *val) 496fa9e4066Sahrens { 497fa9e4066Sahrens char buf[1]; 498fa9e4066Sahrens 499fa9e4066Sahrens return (nicestrtonum(str, val, buf, sizeof (buf))); 500fa9e4066Sahrens } 501fa9e4066Sahrens 502fa9e4066Sahrens /* 503fa9e4066Sahrens * Given a property type and value, verify that the value is appropriate. Used 504fa9e4066Sahrens * by zfs_prop_set() and some libzfs consumers. 505fa9e4066Sahrens */ 506fa9e4066Sahrens int 507fa9e4066Sahrens zfs_prop_validate(zfs_prop_t prop, const char *value, uint64_t *intval) 508fa9e4066Sahrens { 509fa9e4066Sahrens const char *propname = zfs_prop_to_name(prop); 510fa9e4066Sahrens uint64_t number; 511fa9e4066Sahrens char reason[64]; 512fa9e4066Sahrens int i; 513fa9e4066Sahrens 514fa9e4066Sahrens /* 515fa9e4066Sahrens * Check to see if this a read-only property. 516fa9e4066Sahrens */ 517fa9e4066Sahrens if (zfs_prop_readonly(prop)) { 518fa9e4066Sahrens zfs_error(dgettext(TEXT_DOMAIN, 519fa9e4066Sahrens "cannot set %s property: read-only property"), propname); 520fa9e4066Sahrens return (-1); 521fa9e4066Sahrens } 522fa9e4066Sahrens 523fa9e4066Sahrens /* See if the property value is too long */ 524fa9e4066Sahrens if (strlen(value) >= ZFS_MAXPROPLEN) { 525fa9e4066Sahrens zfs_error(dgettext(TEXT_DOMAIN, 526fa9e4066Sahrens "bad %s value '%s': value is too long"), propname, 527fa9e4066Sahrens value); 528fa9e4066Sahrens return (-1); 529fa9e4066Sahrens } 530fa9e4066Sahrens 531fa9e4066Sahrens /* Perform basic checking based on property type */ 532fa9e4066Sahrens switch (zfs_prop_get_type(prop)) { 533fa9e4066Sahrens case prop_type_boolean: 534fa9e4066Sahrens if (strcmp(value, "on") == 0) { 535fa9e4066Sahrens number = 1; 536fa9e4066Sahrens } else if (strcmp(value, "off") == 0) { 537fa9e4066Sahrens number = 0; 538fa9e4066Sahrens } else { 539fa9e4066Sahrens zfs_error(dgettext(TEXT_DOMAIN, 540fa9e4066Sahrens "bad %s value '%s': must be 'on' or 'off'"), 541fa9e4066Sahrens propname, value); 542fa9e4066Sahrens return (-1); 543fa9e4066Sahrens } 544fa9e4066Sahrens break; 545fa9e4066Sahrens 546fa9e4066Sahrens case prop_type_number: 547fa9e4066Sahrens /* treat 'none' as 0 */ 548fa9e4066Sahrens if (strcmp(value, "none") == 0) { 549fa9e4066Sahrens number = 0; 550fa9e4066Sahrens break; 551fa9e4066Sahrens } 552fa9e4066Sahrens 553fa9e4066Sahrens if (nicestrtonum(value, &number, reason, 554fa9e4066Sahrens sizeof (reason)) != 0) { 555fa9e4066Sahrens zfs_error(dgettext(TEXT_DOMAIN, 556fa9e4066Sahrens "bad %s value '%s': %s"), propname, value, 557fa9e4066Sahrens reason); 558fa9e4066Sahrens return (-1); 559fa9e4066Sahrens } 560fa9e4066Sahrens 561fa9e4066Sahrens /* don't allow 0 for quota, use 'none' instead */ 562fa9e4066Sahrens if (prop == ZFS_PROP_QUOTA && number == 0 && 563fa9e4066Sahrens strcmp(value, "none") != 0) { 564fa9e4066Sahrens zfs_error(dgettext(TEXT_DOMAIN, 565fa9e4066Sahrens "bad %s value '%s': use '%s=none' to disable"), 566fa9e4066Sahrens propname, value, propname); 567fa9e4066Sahrens return (-1); 568fa9e4066Sahrens } 569fa9e4066Sahrens 570fa9e4066Sahrens /* must be power of two within SPA_{MIN,MAX}BLOCKSIZE */ 571fa9e4066Sahrens if (prop == ZFS_PROP_RECORDSIZE || 572fa9e4066Sahrens prop == ZFS_PROP_VOLBLOCKSIZE) { 573fa9e4066Sahrens if (number < SPA_MINBLOCKSIZE || 574fa9e4066Sahrens number > SPA_MAXBLOCKSIZE || !ISP2(number)) { 575fa9e4066Sahrens zfs_error(dgettext(TEXT_DOMAIN, 576fa9e4066Sahrens "bad %s value '%s': " 577fa9e4066Sahrens "must be power of 2 from %u to %uk"), 578fa9e4066Sahrens propname, value, 579fa9e4066Sahrens (uint_t)SPA_MINBLOCKSIZE, 580fa9e4066Sahrens (uint_t)SPA_MAXBLOCKSIZE >> 10); 581fa9e4066Sahrens return (-1); 582fa9e4066Sahrens } 583fa9e4066Sahrens } 584fa9e4066Sahrens 585fa9e4066Sahrens break; 586fa9e4066Sahrens 587fa9e4066Sahrens case prop_type_string: 588fa9e4066Sahrens case prop_type_index: 589fa9e4066Sahrens /* 590fa9e4066Sahrens * The two writable string values, 'mountpoint' and 591fa9e4066Sahrens * 'checksum' need special consideration. The 'index' types are 592fa9e4066Sahrens * specified as strings by the user, but passed to the kernel as 593fa9e4066Sahrens * integers. 594fa9e4066Sahrens */ 595fa9e4066Sahrens switch (prop) { 596fa9e4066Sahrens case ZFS_PROP_MOUNTPOINT: 597fa9e4066Sahrens if (strcmp(value, ZFS_MOUNTPOINT_NONE) == 0 || 598fa9e4066Sahrens strcmp(value, ZFS_MOUNTPOINT_LEGACY) == 0) 599fa9e4066Sahrens break; 600fa9e4066Sahrens 601fa9e4066Sahrens if (value[0] != '/') { 602fa9e4066Sahrens zfs_error(dgettext(TEXT_DOMAIN, 603fa9e4066Sahrens "bad %s value '%s': must be an absolute " 604fa9e4066Sahrens "path, 'none', or 'legacy'"), 605fa9e4066Sahrens propname, value); 606fa9e4066Sahrens return (-1); 607fa9e4066Sahrens } 608fa9e4066Sahrens break; 609fa9e4066Sahrens 610fa9e4066Sahrens case ZFS_PROP_CHECKSUM: 611fa9e4066Sahrens for (i = 0; checksum_table[i].name != NULL; i++) { 612fa9e4066Sahrens if (strcmp(value, checksum_table[i].name) 613fa9e4066Sahrens == 0) { 614fa9e4066Sahrens number = checksum_table[i].value; 615fa9e4066Sahrens break; 616fa9e4066Sahrens } 617fa9e4066Sahrens } 618fa9e4066Sahrens 619fa9e4066Sahrens if (checksum_table[i].name == NULL) { 620fa9e4066Sahrens zfs_error(dgettext(TEXT_DOMAIN, 621fa9e4066Sahrens "bad %s value '%s': must be 'on', 'off', " 622fa9e4066Sahrens "'fletcher2', 'fletcher4', or 'sha256'"), 623fa9e4066Sahrens propname, value); 624fa9e4066Sahrens return (-1); 625fa9e4066Sahrens } 626fa9e4066Sahrens break; 627fa9e4066Sahrens 628fa9e4066Sahrens case ZFS_PROP_COMPRESSION: 629fa9e4066Sahrens for (i = 0; compress_table[i].name != NULL; i++) { 630fa9e4066Sahrens if (strcmp(value, compress_table[i].name) 631fa9e4066Sahrens == 0) { 632fa9e4066Sahrens number = compress_table[i].value; 633fa9e4066Sahrens break; 634fa9e4066Sahrens } 635fa9e4066Sahrens } 636fa9e4066Sahrens 637fa9e4066Sahrens if (compress_table[i].name == NULL) { 638fa9e4066Sahrens zfs_error(dgettext(TEXT_DOMAIN, 639fa9e4066Sahrens "bad %s value '%s': must be 'on', 'off', " 640fa9e4066Sahrens "or 'lzjb'"), 641fa9e4066Sahrens propname, value); 642fa9e4066Sahrens return (-1); 643fa9e4066Sahrens } 644fa9e4066Sahrens break; 645fa9e4066Sahrens 646fa9e4066Sahrens case ZFS_PROP_SNAPDIR: 647fa9e4066Sahrens for (i = 0; snapdir_table[i].name != NULL; i++) { 648fa9e4066Sahrens if (strcmp(value, snapdir_table[i].name) == 0) { 649fa9e4066Sahrens number = snapdir_table[i].value; 650fa9e4066Sahrens break; 651fa9e4066Sahrens } 652fa9e4066Sahrens } 653fa9e4066Sahrens 654fa9e4066Sahrens if (snapdir_table[i].name == NULL) { 655fa9e4066Sahrens zfs_error(dgettext(TEXT_DOMAIN, 656fa9e4066Sahrens "bad %s value '%s': must be 'hidden' " 657fa9e4066Sahrens "or 'visible'"), 658fa9e4066Sahrens propname, value); 659fa9e4066Sahrens return (-1); 660fa9e4066Sahrens } 661fa9e4066Sahrens break; 662fa9e4066Sahrens 663fa9e4066Sahrens case ZFS_PROP_ACLMODE: 664fa9e4066Sahrens for (i = 0; acl_mode_table[i].name != NULL; i++) { 665fa9e4066Sahrens if (strcmp(value, acl_mode_table[i].name) 666fa9e4066Sahrens == 0) { 667fa9e4066Sahrens number = acl_mode_table[i].value; 668fa9e4066Sahrens break; 669fa9e4066Sahrens } 670fa9e4066Sahrens } 671fa9e4066Sahrens 672fa9e4066Sahrens if (acl_mode_table[i].name == NULL) { 673fa9e4066Sahrens zfs_error(dgettext(TEXT_DOMAIN, 674fa9e4066Sahrens "bad %s value '%s': must be 'discard', " 675fa9e4066Sahrens "'groupmask' or 'passthrough'"), 676fa9e4066Sahrens propname, value); 677fa9e4066Sahrens return (-1); 678fa9e4066Sahrens } 679fa9e4066Sahrens break; 680fa9e4066Sahrens 681fa9e4066Sahrens case ZFS_PROP_ACLINHERIT: 682fa9e4066Sahrens for (i = 0; acl_inherit_table[i].name != NULL; i++) { 683fa9e4066Sahrens if (strcmp(value, acl_inherit_table[i].name) 684fa9e4066Sahrens == 0) { 685fa9e4066Sahrens number = acl_inherit_table[i].value; 686fa9e4066Sahrens break; 687fa9e4066Sahrens } 688fa9e4066Sahrens } 689fa9e4066Sahrens 690fa9e4066Sahrens if (acl_inherit_table[i].name == NULL) { 691fa9e4066Sahrens zfs_error(dgettext(TEXT_DOMAIN, 692fa9e4066Sahrens "bad %s value '%s': must be 'discard', " 693de122929Smarks "'noallow', 'secure' or 'passthrough'"), 694fa9e4066Sahrens propname, value); 695fa9e4066Sahrens return (-1); 696fa9e4066Sahrens } 697fa9e4066Sahrens break; 698fa9e4066Sahrens 699fa9e4066Sahrens case ZFS_PROP_SHARENFS: 700fa9e4066Sahrens /* 701fa9e4066Sahrens * Nothing to do for 'sharenfs', this gets passed on to 702fa9e4066Sahrens * share(1M) verbatim. 703fa9e4066Sahrens */ 704fa9e4066Sahrens break; 705fa9e4066Sahrens } 706fa9e4066Sahrens } 707fa9e4066Sahrens 708fa9e4066Sahrens if (intval != NULL) 709fa9e4066Sahrens *intval = number; 710fa9e4066Sahrens 711fa9e4066Sahrens return (0); 712fa9e4066Sahrens } 713fa9e4066Sahrens 714fa9e4066Sahrens /* 715fa9e4066Sahrens * Given a property name and value, set the property for the given dataset. 716fa9e4066Sahrens */ 717fa9e4066Sahrens int 718fa9e4066Sahrens zfs_prop_set(zfs_handle_t *zhp, zfs_prop_t prop, const char *propval) 719fa9e4066Sahrens { 720fa9e4066Sahrens const char *propname = zfs_prop_to_name(prop); 721fa9e4066Sahrens uint64_t number; 722fa9e4066Sahrens zfs_cmd_t zc = { 0 }; 723fa9e4066Sahrens int ret; 724fa9e4066Sahrens prop_changelist_t *cl; 725fa9e4066Sahrens 726fa9e4066Sahrens if (zfs_prop_validate(prop, propval, &number) != 0) 727fa9e4066Sahrens return (-1); 728fa9e4066Sahrens 729fa9e4066Sahrens /* 730fa9e4066Sahrens * Check to see if the value applies to this type 731fa9e4066Sahrens */ 732fa9e4066Sahrens if (!zfs_prop_valid_for_type(prop, zhp->zfs_type)) { 733fa9e4066Sahrens zfs_error(dgettext(TEXT_DOMAIN, 734fa9e4066Sahrens "cannot set %s for '%s': property does not apply to %ss"), 735fa9e4066Sahrens propname, zhp->zfs_name, zfs_type_to_name(zhp->zfs_type)); 736fa9e4066Sahrens return (-1); 737fa9e4066Sahrens } 738fa9e4066Sahrens 739fa9e4066Sahrens /* 740fa9e4066Sahrens * For the mountpoint and sharenfs properties, check if it can be set 741fa9e4066Sahrens * in a global/non-global zone based on the zoned property value: 742fa9e4066Sahrens * 743fa9e4066Sahrens * global zone non-global zone 744fa9e4066Sahrens * ----------------------------------------------------- 745fa9e4066Sahrens * zoned=on mountpoint (no) mountpoint (yes) 746fa9e4066Sahrens * sharenfs (no) sharenfs (no) 747fa9e4066Sahrens * 748fa9e4066Sahrens * zoned=off mountpoint (yes) N/A 749fa9e4066Sahrens * sharenfs (yes) 750fa9e4066Sahrens */ 751fa9e4066Sahrens if (prop == ZFS_PROP_MOUNTPOINT || prop == ZFS_PROP_SHARENFS) { 752fa9e4066Sahrens if (zfs_prop_get_int(zhp, ZFS_PROP_ZONED)) { 753fa9e4066Sahrens if (getzoneid() == GLOBAL_ZONEID) { 754fa9e4066Sahrens zfs_error(dgettext(TEXT_DOMAIN, 7555c5460e9Seschrock "cannot set %s for '%s': " 756fa9e4066Sahrens "dataset is used in a non-global zone"), 757fa9e4066Sahrens propname, zhp->zfs_name); 758fa9e4066Sahrens return (-1); 759fa9e4066Sahrens } else if (prop == ZFS_PROP_SHARENFS) { 760fa9e4066Sahrens zfs_error(dgettext(TEXT_DOMAIN, 7615c5460e9Seschrock "cannot set %s for '%s': filesystems " 762fa9e4066Sahrens "cannot be shared in a non-global zone"), 763fa9e4066Sahrens propname, zhp->zfs_name); 764fa9e4066Sahrens return (-1); 765fa9e4066Sahrens } 766fa9e4066Sahrens } else if (getzoneid() != GLOBAL_ZONEID) { 767fa9e4066Sahrens /* 768fa9e4066Sahrens * If zoned property is 'off', this must be in 769fa9e4066Sahrens * a globle zone. If not, something is wrong. 770fa9e4066Sahrens */ 771fa9e4066Sahrens zfs_error(dgettext(TEXT_DOMAIN, 7725c5460e9Seschrock "cannot set %s for '%s': dataset is " 773fa9e4066Sahrens "used in a non-global zone, but 'zoned' " 774fa9e4066Sahrens "property is not set"), 775fa9e4066Sahrens propname, zhp->zfs_name); 776fa9e4066Sahrens return (-1); 777fa9e4066Sahrens } 778fa9e4066Sahrens } 779fa9e4066Sahrens 780fa9e4066Sahrens if ((cl = changelist_gather(zhp, prop, 0)) == NULL) 781fa9e4066Sahrens return (-1); 782fa9e4066Sahrens 783fa9e4066Sahrens if (prop == ZFS_PROP_MOUNTPOINT && changelist_haszonedchild(cl)) { 784fa9e4066Sahrens zfs_error(dgettext(TEXT_DOMAIN, "cannot set %s for '%s', " 785fa9e4066Sahrens "child dataset with inherited mountpoint is used " 786fa9e4066Sahrens "in a non-global zone"), 787fa9e4066Sahrens propname, zhp->zfs_name); 788fa9e4066Sahrens ret = -1; 789fa9e4066Sahrens goto error; 790fa9e4066Sahrens } 791fa9e4066Sahrens 792fa9e4066Sahrens if ((ret = changelist_prefix(cl)) != 0) 793fa9e4066Sahrens goto error; 794fa9e4066Sahrens 795fa9e4066Sahrens /* 796fa9e4066Sahrens * Execute the corresponding ioctl() to set this property. 797fa9e4066Sahrens */ 798fa9e4066Sahrens (void) strlcpy(zc.zc_name, zhp->zfs_name, sizeof (zc.zc_name)); 799fa9e4066Sahrens 800fa9e4066Sahrens switch (prop) { 801fa9e4066Sahrens case ZFS_PROP_QUOTA: 802fa9e4066Sahrens zc.zc_cookie = number; 803fa9e4066Sahrens ret = ioctl(zfs_fd, ZFS_IOC_SET_QUOTA, &zc); 804fa9e4066Sahrens break; 805fa9e4066Sahrens case ZFS_PROP_RESERVATION: 806fa9e4066Sahrens zc.zc_cookie = number; 807fa9e4066Sahrens ret = ioctl(zfs_fd, ZFS_IOC_SET_RESERVATION, &zc); 808fa9e4066Sahrens break; 809fa9e4066Sahrens case ZFS_PROP_MOUNTPOINT: 810fa9e4066Sahrens case ZFS_PROP_SHARENFS: 811fa9e4066Sahrens /* 812fa9e4066Sahrens * These properties are passed down as real strings. 813fa9e4066Sahrens */ 814fa9e4066Sahrens (void) strlcpy(zc.zc_prop_name, propname, 815fa9e4066Sahrens sizeof (zc.zc_prop_name)); 816fa9e4066Sahrens (void) strlcpy(zc.zc_prop_value, propval, 817fa9e4066Sahrens sizeof (zc.zc_prop_value)); 818fa9e4066Sahrens zc.zc_intsz = 1; 819fa9e4066Sahrens zc.zc_numints = strlen(propval) + 1; 820fa9e4066Sahrens ret = ioctl(zfs_fd, ZFS_IOC_SET_PROP, &zc); 821fa9e4066Sahrens break; 822fa9e4066Sahrens case ZFS_PROP_VOLSIZE: 823fa9e4066Sahrens zc.zc_volsize = number; 824fa9e4066Sahrens ret = ioctl(zfs_fd, ZFS_IOC_SET_VOLSIZE, &zc); 825fa9e4066Sahrens break; 826fa9e4066Sahrens case ZFS_PROP_VOLBLOCKSIZE: 827fa9e4066Sahrens zc.zc_volblocksize = number; 828fa9e4066Sahrens ret = ioctl(zfs_fd, ZFS_IOC_SET_VOLBLOCKSIZE, &zc); 829fa9e4066Sahrens break; 830fa9e4066Sahrens default: 831fa9e4066Sahrens (void) strlcpy(zc.zc_prop_name, propname, 832fa9e4066Sahrens sizeof (zc.zc_prop_name)); 833fa9e4066Sahrens /* LINTED - alignment */ 834fa9e4066Sahrens *(uint64_t *)zc.zc_prop_value = number; 835fa9e4066Sahrens zc.zc_intsz = 8; 836fa9e4066Sahrens zc.zc_numints = 1; 837fa9e4066Sahrens ret = ioctl(zfs_fd, ZFS_IOC_SET_PROP, &zc); 838fa9e4066Sahrens break; 839fa9e4066Sahrens } 840fa9e4066Sahrens 841fa9e4066Sahrens if (ret != 0) { 842fa9e4066Sahrens switch (errno) { 843fa9e4066Sahrens 844fa9e4066Sahrens case EPERM: 845fa9e4066Sahrens zfs_error(dgettext(TEXT_DOMAIN, 846fa9e4066Sahrens "cannot set %s for '%s': permission " 847fa9e4066Sahrens "denied"), propname, zhp->zfs_name); 848fa9e4066Sahrens break; 849fa9e4066Sahrens 850fa9e4066Sahrens case ENOENT: 851fa9e4066Sahrens zfs_error(dgettext(TEXT_DOMAIN, 852fa9e4066Sahrens "cannot open '%s': no such %s"), zhp->zfs_name, 853fa9e4066Sahrens zfs_type_to_name(zhp->zfs_type)); 854fa9e4066Sahrens break; 855fa9e4066Sahrens 856fa9e4066Sahrens case ENOSPC: 857fa9e4066Sahrens /* 858fa9e4066Sahrens * For quotas and reservations, ENOSPC indicates 859fa9e4066Sahrens * something different; setting a quota or reservation 860fa9e4066Sahrens * doesn't use any disk space. 861fa9e4066Sahrens */ 862fa9e4066Sahrens switch (prop) { 863fa9e4066Sahrens case ZFS_PROP_QUOTA: 864fa9e4066Sahrens zfs_error(dgettext(TEXT_DOMAIN, "cannot set %s " 865fa9e4066Sahrens "for '%s': size is less than current " 866fa9e4066Sahrens "used or reserved space"), propname, 867fa9e4066Sahrens zhp->zfs_name); 868fa9e4066Sahrens break; 869fa9e4066Sahrens 870fa9e4066Sahrens case ZFS_PROP_RESERVATION: 871fa9e4066Sahrens zfs_error(dgettext(TEXT_DOMAIN, "cannot set %s " 872fa9e4066Sahrens "for '%s': size is greater than available " 873fa9e4066Sahrens "space"), propname, zhp->zfs_name); 874fa9e4066Sahrens break; 875fa9e4066Sahrens 876fa9e4066Sahrens default: 877fa9e4066Sahrens zfs_error(dgettext(TEXT_DOMAIN, 878fa9e4066Sahrens "cannot set %s for '%s': out of space"), 879fa9e4066Sahrens propname, zhp->zfs_name); 880fa9e4066Sahrens break; 881fa9e4066Sahrens } 882fa9e4066Sahrens break; 883fa9e4066Sahrens 884fa9e4066Sahrens case EBUSY: 885fa9e4066Sahrens if (prop == ZFS_PROP_VOLBLOCKSIZE) { 886fa9e4066Sahrens zfs_error(dgettext(TEXT_DOMAIN, 887fa9e4066Sahrens "cannot set %s for '%s': " 888fa9e4066Sahrens "volume already contains data"), 889fa9e4066Sahrens propname, zhp->zfs_name); 890fa9e4066Sahrens } else { 891fa9e4066Sahrens zfs_baderror(errno); 892fa9e4066Sahrens } 893fa9e4066Sahrens break; 894fa9e4066Sahrens 8952a79c5feSlling case EROFS: 8962a79c5feSlling zfs_error(dgettext(TEXT_DOMAIN, "cannot set %s for " 8972a79c5feSlling "'%s': read only %s"), propname, zhp->zfs_name, 8982a79c5feSlling zfs_type_to_name(zhp->zfs_type)); 8992a79c5feSlling break; 9002a79c5feSlling 901fa9e4066Sahrens case EOVERFLOW: 902fa9e4066Sahrens /* 903fa9e4066Sahrens * This platform can't address a volume this big. 904fa9e4066Sahrens */ 905fa9e4066Sahrens #ifdef _ILP32 906fa9e4066Sahrens if (prop == ZFS_PROP_VOLSIZE) { 907fa9e4066Sahrens zfs_error(dgettext(TEXT_DOMAIN, 908fa9e4066Sahrens "cannot set %s for '%s': " 909fa9e4066Sahrens "max volume size is 1TB on 32-bit systems"), 910fa9e4066Sahrens propname, zhp->zfs_name); 911fa9e4066Sahrens break; 912fa9e4066Sahrens } 913fa9e4066Sahrens #endif 914fa9e4066Sahrens zfs_baderror(errno); 915fa9e4066Sahrens default: 916fa9e4066Sahrens zfs_baderror(errno); 917fa9e4066Sahrens } 918fa9e4066Sahrens } else { 919fa9e4066Sahrens /* 920fa9e4066Sahrens * Refresh the statistics so the new property value 921fa9e4066Sahrens * is reflected. 922fa9e4066Sahrens */ 923fa9e4066Sahrens if ((ret = changelist_postfix(cl)) != 0) 924fa9e4066Sahrens goto error; 925fa9e4066Sahrens 926fa9e4066Sahrens (void) get_stats(zhp); 927fa9e4066Sahrens } 928fa9e4066Sahrens 929fa9e4066Sahrens error: 930fa9e4066Sahrens changelist_free(cl); 931fa9e4066Sahrens return (ret); 932fa9e4066Sahrens } 933fa9e4066Sahrens 934fa9e4066Sahrens /* 935fa9e4066Sahrens * Given a property, inherit the value from the parent dataset. 936fa9e4066Sahrens */ 937fa9e4066Sahrens int 938fa9e4066Sahrens zfs_prop_inherit(zfs_handle_t *zhp, zfs_prop_t prop) 939fa9e4066Sahrens { 940fa9e4066Sahrens const char *propname = zfs_prop_to_name(prop); 941fa9e4066Sahrens zfs_cmd_t zc = { 0 }; 942fa9e4066Sahrens int ret; 943fa9e4066Sahrens prop_changelist_t *cl; 944fa9e4066Sahrens 945fa9e4066Sahrens /* 946fa9e4066Sahrens * Verify that this property is inheritable. 947fa9e4066Sahrens */ 948fa9e4066Sahrens if (zfs_prop_readonly(prop)) { 949fa9e4066Sahrens zfs_error(dgettext(TEXT_DOMAIN, 950fa9e4066Sahrens "cannot inherit %s for '%s': property is read-only"), 951fa9e4066Sahrens propname, zhp->zfs_name); 952fa9e4066Sahrens return (-1); 953fa9e4066Sahrens } 954fa9e4066Sahrens 955fa9e4066Sahrens if (!zfs_prop_inheritable(prop)) { 956fa9e4066Sahrens zfs_error(dgettext(TEXT_DOMAIN, 957fa9e4066Sahrens "cannot inherit %s for '%s': property is not inheritable"), 958fa9e4066Sahrens propname, zhp->zfs_name); 959fa9e4066Sahrens return (-1); 960fa9e4066Sahrens } 961fa9e4066Sahrens 962fa9e4066Sahrens /* 963fa9e4066Sahrens * Check to see if the value applies to this type 964fa9e4066Sahrens */ 965fa9e4066Sahrens if (!zfs_prop_valid_for_type(prop, zhp->zfs_type)) { 966fa9e4066Sahrens zfs_error(dgettext(TEXT_DOMAIN, 967fa9e4066Sahrens "cannot inherit %s for '%s': property does " 968fa9e4066Sahrens "not apply to %ss"), propname, zhp->zfs_name, 969fa9e4066Sahrens zfs_type_to_name(zhp->zfs_type)); 970fa9e4066Sahrens return (-1); 971fa9e4066Sahrens } 972fa9e4066Sahrens 973fa9e4066Sahrens (void) strlcpy(zc.zc_name, zhp->zfs_name, sizeof (zc.zc_name)); 974fa9e4066Sahrens (void) strlcpy(zc.zc_prop_name, propname, sizeof (zc.zc_prop_name)); 975fa9e4066Sahrens 976fa9e4066Sahrens if (prop == ZFS_PROP_MOUNTPOINT && getzoneid() == GLOBAL_ZONEID && 977fa9e4066Sahrens zfs_prop_get_int(zhp, ZFS_PROP_ZONED)) { 978fa9e4066Sahrens zfs_error(dgettext(TEXT_DOMAIN, "cannot inherit %s for '%s', " 979fa9e4066Sahrens "dataset is used in a non-global zone"), propname, 980fa9e4066Sahrens zhp->zfs_name); 981fa9e4066Sahrens return (-1); 982fa9e4066Sahrens } 983fa9e4066Sahrens 984fa9e4066Sahrens /* 985fa9e4066Sahrens * Determine datasets which will be affected by this change, if any. 986fa9e4066Sahrens */ 987fa9e4066Sahrens if ((cl = changelist_gather(zhp, prop, 0)) == NULL) 988fa9e4066Sahrens return (-1); 989fa9e4066Sahrens 990fa9e4066Sahrens if (prop == ZFS_PROP_MOUNTPOINT && changelist_haszonedchild(cl)) { 991fa9e4066Sahrens zfs_error(dgettext(TEXT_DOMAIN, "cannot inherit %s for '%s', " 992fa9e4066Sahrens "child dataset with inherited mountpoint is " 993fa9e4066Sahrens "used in a non-global zone"), 994fa9e4066Sahrens propname, zhp->zfs_name); 995fa9e4066Sahrens ret = -1; 996fa9e4066Sahrens goto error; 997fa9e4066Sahrens } 998fa9e4066Sahrens 999fa9e4066Sahrens if ((ret = changelist_prefix(cl)) != 0) 1000fa9e4066Sahrens goto error; 1001fa9e4066Sahrens 1002fa9e4066Sahrens zc.zc_numints = 0; 1003fa9e4066Sahrens 1004fa9e4066Sahrens if ((ret = ioctl(zfs_fd, ZFS_IOC_SET_PROP, &zc)) != 0) { 1005fa9e4066Sahrens switch (errno) { 1006fa9e4066Sahrens case EPERM: 1007fa9e4066Sahrens zfs_error(dgettext(TEXT_DOMAIN, 1008fa9e4066Sahrens "cannot inherit %s for '%s': permission " 1009fa9e4066Sahrens "denied"), propname, zhp->zfs_name); 1010fa9e4066Sahrens break; 1011fa9e4066Sahrens case ENOENT: 1012fa9e4066Sahrens zfs_error(dgettext(TEXT_DOMAIN, 1013fa9e4066Sahrens "cannot open '%s': no such %s"), zhp->zfs_name, 1014fa9e4066Sahrens zfs_type_to_name(zhp->zfs_type)); 1015fa9e4066Sahrens break; 1016fa9e4066Sahrens case ENOSPC: 1017fa9e4066Sahrens zfs_error(dgettext(TEXT_DOMAIN, 1018fa9e4066Sahrens "cannot inherit %s for '%s': " 1019fa9e4066Sahrens "out of space"), propname, zhp->zfs_name); 1020fa9e4066Sahrens break; 1021fa9e4066Sahrens default: 1022fa9e4066Sahrens zfs_baderror(errno); 1023fa9e4066Sahrens } 1024fa9e4066Sahrens 1025fa9e4066Sahrens } else { 1026fa9e4066Sahrens 1027fa9e4066Sahrens if ((ret = changelist_postfix(cl)) != 0) 1028fa9e4066Sahrens goto error; 1029fa9e4066Sahrens 1030fa9e4066Sahrens /* 1031fa9e4066Sahrens * Refresh the statistics so the new property is reflected. 1032fa9e4066Sahrens */ 1033fa9e4066Sahrens (void) get_stats(zhp); 1034fa9e4066Sahrens } 1035fa9e4066Sahrens 1036fa9e4066Sahrens 1037fa9e4066Sahrens error: 1038fa9e4066Sahrens changelist_free(cl); 1039fa9e4066Sahrens return (ret); 1040fa9e4066Sahrens } 1041fa9e4066Sahrens 1042fa9e4066Sahrens static void 1043fa9e4066Sahrens nicebool(int value, char *buf, size_t buflen) 1044fa9e4066Sahrens { 1045fa9e4066Sahrens if (value) 1046fa9e4066Sahrens (void) strlcpy(buf, "on", buflen); 1047fa9e4066Sahrens else 1048fa9e4066Sahrens (void) strlcpy(buf, "off", buflen); 1049fa9e4066Sahrens } 1050fa9e4066Sahrens 10517f7322feSeschrock /* 10527f7322feSeschrock * True DSL properties are stored in an nvlist. The following two functions 10537f7322feSeschrock * extract them appropriately. 10547f7322feSeschrock */ 10557f7322feSeschrock static uint64_t 10567f7322feSeschrock getprop_uint64(zfs_handle_t *zhp, zfs_prop_t prop, char **source) 10577f7322feSeschrock { 10587f7322feSeschrock nvlist_t *nv; 10597f7322feSeschrock uint64_t value; 10607f7322feSeschrock 10617f7322feSeschrock if (nvlist_lookup_nvlist(zhp->zfs_props, 10627f7322feSeschrock zfs_prop_to_name(prop), &nv) == 0) { 10637f7322feSeschrock verify(nvlist_lookup_uint64(nv, ZFS_PROP_VALUE, &value) == 0); 10647f7322feSeschrock verify(nvlist_lookup_string(nv, ZFS_PROP_SOURCE, source) == 0); 10657f7322feSeschrock } else { 10667f7322feSeschrock value = zfs_prop_default_numeric(prop); 10677f7322feSeschrock *source = ""; 10687f7322feSeschrock } 10697f7322feSeschrock 10707f7322feSeschrock return (value); 10717f7322feSeschrock } 10727f7322feSeschrock 10737f7322feSeschrock static char * 10747f7322feSeschrock getprop_string(zfs_handle_t *zhp, zfs_prop_t prop, char **source) 10757f7322feSeschrock { 10767f7322feSeschrock nvlist_t *nv; 10777f7322feSeschrock char *value; 10787f7322feSeschrock 10797f7322feSeschrock if (nvlist_lookup_nvlist(zhp->zfs_props, 10807f7322feSeschrock zfs_prop_to_name(prop), &nv) == 0) { 10817f7322feSeschrock verify(nvlist_lookup_string(nv, ZFS_PROP_VALUE, &value) == 0); 10827f7322feSeschrock verify(nvlist_lookup_string(nv, ZFS_PROP_SOURCE, source) == 0); 10837f7322feSeschrock } else { 10847f7322feSeschrock if ((value = (char *)zfs_prop_default_string(prop)) == NULL) 10857f7322feSeschrock value = ""; 10867f7322feSeschrock *source = ""; 10877f7322feSeschrock } 10887f7322feSeschrock 10897f7322feSeschrock return (value); 10907f7322feSeschrock } 10917f7322feSeschrock 1092fa9e4066Sahrens /* 1093fa9e4066Sahrens * Internal function for getting a numeric property. Both zfs_prop_get() and 1094fa9e4066Sahrens * zfs_prop_get_int() are built using this interface. 1095fa9e4066Sahrens * 1096fa9e4066Sahrens * Certain properties can be overridden using 'mount -o'. In this case, scan 1097fa9e4066Sahrens * the contents of the /etc/mnttab entry, searching for the appropriate options. 1098fa9e4066Sahrens * If they differ from the on-disk values, report the current values and mark 1099fa9e4066Sahrens * the source "temporary". 1100fa9e4066Sahrens */ 1101fa9e4066Sahrens static uint64_t 1102fa9e4066Sahrens get_numeric_property(zfs_handle_t *zhp, zfs_prop_t prop, zfs_source_t *src, 1103fa9e4066Sahrens char **source) 1104fa9e4066Sahrens { 1105fa9e4066Sahrens uint64_t val; 1106fa9e4066Sahrens struct mnttab mnt; 1107fa9e4066Sahrens 1108fa9e4066Sahrens *source = NULL; 1109fa9e4066Sahrens 1110fa9e4066Sahrens if (zhp->zfs_mntopts == NULL) 1111fa9e4066Sahrens mnt.mnt_mntopts = ""; 1112fa9e4066Sahrens else 1113fa9e4066Sahrens mnt.mnt_mntopts = zhp->zfs_mntopts; 1114fa9e4066Sahrens 1115fa9e4066Sahrens switch (prop) { 1116fa9e4066Sahrens case ZFS_PROP_ATIME: 11177f7322feSeschrock val = getprop_uint64(zhp, prop, source); 1118fa9e4066Sahrens 1119fa9e4066Sahrens if (hasmntopt(&mnt, MNTOPT_ATIME) && !val) { 1120fa9e4066Sahrens val = TRUE; 1121fa9e4066Sahrens if (src) 1122fa9e4066Sahrens *src = ZFS_SRC_TEMPORARY; 1123fa9e4066Sahrens } else if (hasmntopt(&mnt, MNTOPT_NOATIME) && val) { 1124fa9e4066Sahrens val = FALSE; 1125fa9e4066Sahrens if (src) 1126fa9e4066Sahrens *src = ZFS_SRC_TEMPORARY; 1127fa9e4066Sahrens } 11287f7322feSeschrock return (val); 1129fa9e4066Sahrens 1130fa9e4066Sahrens case ZFS_PROP_AVAILABLE: 1131fa9e4066Sahrens return (zhp->zfs_dmustats.dds_available); 1132fa9e4066Sahrens 1133fa9e4066Sahrens case ZFS_PROP_DEVICES: 11347f7322feSeschrock val = getprop_uint64(zhp, prop, source); 1135fa9e4066Sahrens 1136fa9e4066Sahrens if (hasmntopt(&mnt, MNTOPT_DEVICES) && !val) { 1137fa9e4066Sahrens val = TRUE; 1138fa9e4066Sahrens if (src) 1139fa9e4066Sahrens *src = ZFS_SRC_TEMPORARY; 1140fa9e4066Sahrens } else if (hasmntopt(&mnt, MNTOPT_NODEVICES) && val) { 1141fa9e4066Sahrens val = FALSE; 1142fa9e4066Sahrens if (src) 1143fa9e4066Sahrens *src = ZFS_SRC_TEMPORARY; 1144fa9e4066Sahrens } 1145fa9e4066Sahrens return (val); 1146fa9e4066Sahrens 1147fa9e4066Sahrens case ZFS_PROP_EXEC: 11487f7322feSeschrock val = getprop_uint64(zhp, prop, source); 1149fa9e4066Sahrens 1150fa9e4066Sahrens if (hasmntopt(&mnt, MNTOPT_EXEC) && !val) { 1151fa9e4066Sahrens val = TRUE; 1152fa9e4066Sahrens if (src) 1153fa9e4066Sahrens *src = ZFS_SRC_TEMPORARY; 1154fa9e4066Sahrens } else if (hasmntopt(&mnt, MNTOPT_NOEXEC) && val) { 1155fa9e4066Sahrens val = FALSE; 1156fa9e4066Sahrens if (src) 1157fa9e4066Sahrens *src = ZFS_SRC_TEMPORARY; 1158fa9e4066Sahrens } 1159fa9e4066Sahrens return (val); 1160fa9e4066Sahrens 1161fa9e4066Sahrens case ZFS_PROP_RECORDSIZE: 1162fa9e4066Sahrens case ZFS_PROP_COMPRESSION: 11637f7322feSeschrock case ZFS_PROP_ZONED: 11647f7322feSeschrock val = getprop_uint64(zhp, prop, source); 11657f7322feSeschrock return (val); 1166fa9e4066Sahrens 1167fa9e4066Sahrens case ZFS_PROP_READONLY: 11687f7322feSeschrock val = getprop_uint64(zhp, prop, source); 1169fa9e4066Sahrens 1170fa9e4066Sahrens if (hasmntopt(&mnt, MNTOPT_RO) && !val) { 1171fa9e4066Sahrens val = TRUE; 1172fa9e4066Sahrens if (src) 1173fa9e4066Sahrens *src = ZFS_SRC_TEMPORARY; 1174fa9e4066Sahrens } else if (hasmntopt(&mnt, MNTOPT_RW) && val) { 1175fa9e4066Sahrens val = FALSE; 1176fa9e4066Sahrens if (src) 1177fa9e4066Sahrens *src = ZFS_SRC_TEMPORARY; 1178fa9e4066Sahrens } 1179fa9e4066Sahrens return (val); 1180fa9e4066Sahrens 1181fa9e4066Sahrens case ZFS_PROP_QUOTA: 1182fa9e4066Sahrens if (zhp->zfs_dmustats.dds_quota == 0) 1183fa9e4066Sahrens *source = ""; /* default */ 1184fa9e4066Sahrens else 1185fa9e4066Sahrens *source = zhp->zfs_name; 1186fa9e4066Sahrens return (zhp->zfs_dmustats.dds_quota); 1187fa9e4066Sahrens 1188fa9e4066Sahrens case ZFS_PROP_RESERVATION: 1189fa9e4066Sahrens if (zhp->zfs_dmustats.dds_reserved == 0) 1190fa9e4066Sahrens *source = ""; /* default */ 1191fa9e4066Sahrens else 1192fa9e4066Sahrens *source = zhp->zfs_name; 1193fa9e4066Sahrens return (zhp->zfs_dmustats.dds_reserved); 1194fa9e4066Sahrens 1195fa9e4066Sahrens case ZFS_PROP_COMPRESSRATIO: 1196fa9e4066Sahrens /* 1197fa9e4066Sahrens * Using physical space and logical space, calculate the 1198fa9e4066Sahrens * compression ratio. We return the number as a multiple of 1199fa9e4066Sahrens * 100, so '2.5x' would be returned as 250. 1200fa9e4066Sahrens */ 1201fa9e4066Sahrens if (zhp->zfs_dmustats.dds_compressed_bytes == 0) 1202fa9e4066Sahrens return (100ULL); 1203fa9e4066Sahrens else 1204fa9e4066Sahrens return (zhp->zfs_dmustats.dds_uncompressed_bytes * 100 / 1205fa9e4066Sahrens zhp->zfs_dmustats.dds_compressed_bytes); 1206fa9e4066Sahrens 1207fa9e4066Sahrens case ZFS_PROP_REFERENCED: 1208fa9e4066Sahrens /* 1209fa9e4066Sahrens * 'referenced' refers to the amount of physical space 1210fa9e4066Sahrens * referenced (possibly shared) by this object. 1211fa9e4066Sahrens */ 1212fa9e4066Sahrens return (zhp->zfs_dmustats.dds_space_refd); 1213fa9e4066Sahrens 1214fa9e4066Sahrens case ZFS_PROP_SETUID: 12157f7322feSeschrock val = getprop_uint64(zhp, prop, source); 1216fa9e4066Sahrens 1217fa9e4066Sahrens if (hasmntopt(&mnt, MNTOPT_SETUID) && !val) { 1218fa9e4066Sahrens val = TRUE; 1219fa9e4066Sahrens if (src) 1220fa9e4066Sahrens *src = ZFS_SRC_TEMPORARY; 1221fa9e4066Sahrens } else if (hasmntopt(&mnt, MNTOPT_NOSETUID) && val) { 1222fa9e4066Sahrens val = FALSE; 1223fa9e4066Sahrens if (src) 1224fa9e4066Sahrens *src = ZFS_SRC_TEMPORARY; 1225fa9e4066Sahrens } 1226fa9e4066Sahrens return (val); 1227fa9e4066Sahrens 1228fa9e4066Sahrens case ZFS_PROP_VOLSIZE: 1229fa9e4066Sahrens return (zhp->zfs_volsize); 1230fa9e4066Sahrens 1231fa9e4066Sahrens case ZFS_PROP_VOLBLOCKSIZE: 1232fa9e4066Sahrens return (zhp->zfs_volblocksize); 1233fa9e4066Sahrens 1234fa9e4066Sahrens case ZFS_PROP_USED: 1235fa9e4066Sahrens return (zhp->zfs_dmustats.dds_space_used); 1236fa9e4066Sahrens 1237fa9e4066Sahrens case ZFS_PROP_CREATETXG: 1238fa9e4066Sahrens return (zhp->zfs_dmustats.dds_creation_txg); 1239fa9e4066Sahrens 1240fa9e4066Sahrens case ZFS_PROP_MOUNTED: 1241fa9e4066Sahrens /* 1242fa9e4066Sahrens * Unlike other properties, we defer calculation of 'MOUNTED' 1243fa9e4066Sahrens * until actually requested. This is because the getmntany() 1244fa9e4066Sahrens * call can be extremely expensive on systems with a large 1245fa9e4066Sahrens * number of filesystems, and the property isn't needed in 1246fa9e4066Sahrens * normal use cases. 1247fa9e4066Sahrens */ 1248fa9e4066Sahrens if (zhp->zfs_mntopts == NULL) { 1249fa9e4066Sahrens struct mnttab search = { 0 }, entry; 1250fa9e4066Sahrens 1251fa9e4066Sahrens search.mnt_special = (char *)zhp->zfs_name; 1252fa9e4066Sahrens rewind(mnttab_file); 1253fa9e4066Sahrens 1254fa9e4066Sahrens if (getmntany(mnttab_file, &entry, &search) == 0) 1255fa9e4066Sahrens zhp->zfs_mntopts = 1256fa9e4066Sahrens zfs_strdup(entry.mnt_mntopts); 1257fa9e4066Sahrens } 1258fa9e4066Sahrens return (zhp->zfs_mntopts != NULL); 1259fa9e4066Sahrens 1260fa9e4066Sahrens default: 1261fa9e4066Sahrens zfs_baderror(EINVAL); 1262fa9e4066Sahrens } 1263fa9e4066Sahrens 1264fa9e4066Sahrens return (0); 1265fa9e4066Sahrens } 1266fa9e4066Sahrens 1267fa9e4066Sahrens /* 1268fa9e4066Sahrens * Calculate the source type, given the raw source string. 1269fa9e4066Sahrens */ 1270fa9e4066Sahrens static void 1271fa9e4066Sahrens get_source(zfs_handle_t *zhp, zfs_source_t *srctype, char *source, 1272fa9e4066Sahrens char *statbuf, size_t statlen) 1273fa9e4066Sahrens { 1274fa9e4066Sahrens if (statbuf == NULL || *srctype == ZFS_SRC_TEMPORARY) 1275fa9e4066Sahrens return; 1276fa9e4066Sahrens 1277fa9e4066Sahrens if (source == NULL) { 1278fa9e4066Sahrens *srctype = ZFS_SRC_NONE; 1279fa9e4066Sahrens } else if (source[0] == '\0') { 1280fa9e4066Sahrens *srctype = ZFS_SRC_DEFAULT; 1281fa9e4066Sahrens } else { 1282fa9e4066Sahrens if (strcmp(source, zhp->zfs_name) == 0) { 1283fa9e4066Sahrens *srctype = ZFS_SRC_LOCAL; 1284fa9e4066Sahrens } else { 1285fa9e4066Sahrens (void) strlcpy(statbuf, source, statlen); 1286fa9e4066Sahrens *srctype = ZFS_SRC_INHERITED; 1287fa9e4066Sahrens } 1288fa9e4066Sahrens } 1289fa9e4066Sahrens 1290fa9e4066Sahrens } 1291fa9e4066Sahrens 1292fa9e4066Sahrens /* 1293fa9e4066Sahrens * Retrieve a property from the given object. If 'literal' is specified, then 1294fa9e4066Sahrens * numbers are left as exact values. Otherwise, numbers are converted to a 1295fa9e4066Sahrens * human-readable form. 1296fa9e4066Sahrens * 1297fa9e4066Sahrens * Returns 0 on success, or -1 on error. 1298fa9e4066Sahrens */ 1299fa9e4066Sahrens int 1300fa9e4066Sahrens zfs_prop_get(zfs_handle_t *zhp, zfs_prop_t prop, char *propbuf, size_t proplen, 1301fa9e4066Sahrens zfs_source_t *src, char *statbuf, size_t statlen, int literal) 1302fa9e4066Sahrens { 1303fa9e4066Sahrens char *source = NULL; 1304fa9e4066Sahrens uint64_t val; 1305fa9e4066Sahrens char *str; 1306fa9e4066Sahrens int i; 1307fa9e4066Sahrens const char *root; 1308fa9e4066Sahrens 1309fa9e4066Sahrens /* 1310fa9e4066Sahrens * Check to see if this property applies to our object 1311fa9e4066Sahrens */ 1312fa9e4066Sahrens if (!zfs_prop_valid_for_type(prop, zhp->zfs_type)) 1313fa9e4066Sahrens return (-1); 1314fa9e4066Sahrens 1315fa9e4066Sahrens if (src) 1316fa9e4066Sahrens *src = ZFS_SRC_NONE; 1317fa9e4066Sahrens 1318fa9e4066Sahrens switch (prop) { 1319fa9e4066Sahrens case ZFS_PROP_ATIME: 1320fa9e4066Sahrens case ZFS_PROP_READONLY: 1321fa9e4066Sahrens case ZFS_PROP_SETUID: 1322fa9e4066Sahrens case ZFS_PROP_ZONED: 1323fa9e4066Sahrens case ZFS_PROP_DEVICES: 1324fa9e4066Sahrens case ZFS_PROP_EXEC: 1325fa9e4066Sahrens /* 1326fa9e4066Sahrens * Basic boolean values are built on top of 1327fa9e4066Sahrens * get_numeric_property(). 1328fa9e4066Sahrens */ 1329fa9e4066Sahrens nicebool(get_numeric_property(zhp, prop, src, &source), 1330fa9e4066Sahrens propbuf, proplen); 1331fa9e4066Sahrens 1332fa9e4066Sahrens break; 1333fa9e4066Sahrens 1334fa9e4066Sahrens case ZFS_PROP_AVAILABLE: 1335fa9e4066Sahrens case ZFS_PROP_RECORDSIZE: 1336fa9e4066Sahrens case ZFS_PROP_CREATETXG: 1337fa9e4066Sahrens case ZFS_PROP_REFERENCED: 1338fa9e4066Sahrens case ZFS_PROP_USED: 1339fa9e4066Sahrens case ZFS_PROP_VOLSIZE: 1340fa9e4066Sahrens case ZFS_PROP_VOLBLOCKSIZE: 1341fa9e4066Sahrens /* 1342fa9e4066Sahrens * Basic numeric values are built on top of 1343fa9e4066Sahrens * get_numeric_property(). 1344fa9e4066Sahrens */ 1345fa9e4066Sahrens val = get_numeric_property(zhp, prop, src, &source); 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 */ 1433fa9e4066Sahrens root = zhp->zfs_dmustats.dds_altroot; 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: 14677f7322feSeschrock (void) strlcpy(propbuf, getprop_string(zhp, prop, &source), 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: 1479fa9e4066Sahrens val = get_numeric_property(zhp, prop, src, &source); 1480fa9e4066Sahrens 1481fa9e4066Sahrens /* 1482fa9e4066Sahrens * If quota or reservation is 0, we translate this into 'none' 1483fa9e4066Sahrens * (unless literal is set), and indicate that it's the default 1484fa9e4066Sahrens * value. Otherwise, we print the number nicely and indicate 1485fa9e4066Sahrens * that its set locally. 1486fa9e4066Sahrens */ 1487fa9e4066Sahrens if (val == 0) { 1488fa9e4066Sahrens if (literal) 1489fa9e4066Sahrens (void) strlcpy(propbuf, "0", proplen); 1490fa9e4066Sahrens else 1491fa9e4066Sahrens (void) strlcpy(propbuf, "none", proplen); 1492fa9e4066Sahrens } else { 1493fa9e4066Sahrens if (literal) 1494fa9e4066Sahrens (void) snprintf(propbuf, proplen, "%llu", val); 1495fa9e4066Sahrens else 1496fa9e4066Sahrens zfs_nicenum(val, propbuf, proplen); 1497fa9e4066Sahrens } 1498fa9e4066Sahrens break; 1499fa9e4066Sahrens 1500fa9e4066Sahrens case ZFS_PROP_COMPRESSRATIO: 1501fa9e4066Sahrens val = get_numeric_property(zhp, prop, src, &source); 1502fa9e4066Sahrens (void) snprintf(propbuf, proplen, "%lld.%02lldx", val / 100, 1503fa9e4066Sahrens val % 100); 1504fa9e4066Sahrens break; 1505fa9e4066Sahrens 1506fa9e4066Sahrens case ZFS_PROP_TYPE: 1507fa9e4066Sahrens switch (zhp->zfs_type) { 1508fa9e4066Sahrens case ZFS_TYPE_FILESYSTEM: 1509fa9e4066Sahrens str = "filesystem"; 1510fa9e4066Sahrens break; 1511fa9e4066Sahrens case ZFS_TYPE_VOLUME: 1512fa9e4066Sahrens str = "volume"; 1513fa9e4066Sahrens break; 1514fa9e4066Sahrens case ZFS_TYPE_SNAPSHOT: 1515fa9e4066Sahrens str = "snapshot"; 1516fa9e4066Sahrens break; 1517fa9e4066Sahrens default: 1518fa9e4066Sahrens zfs_baderror(zhp->zfs_type); 1519fa9e4066Sahrens } 1520fa9e4066Sahrens (void) snprintf(propbuf, proplen, "%s", str); 1521fa9e4066Sahrens break; 1522fa9e4066Sahrens 1523fa9e4066Sahrens case ZFS_PROP_MOUNTED: 1524fa9e4066Sahrens /* 1525fa9e4066Sahrens * The 'mounted' property is a pseudo-property that described 1526fa9e4066Sahrens * whether the filesystem is currently mounted. Even though 1527fa9e4066Sahrens * it's a boolean value, the typical values of "on" and "off" 1528fa9e4066Sahrens * don't make sense, so we translate to "yes" and "no". 1529fa9e4066Sahrens */ 1530fa9e4066Sahrens if (get_numeric_property(zhp, ZFS_PROP_MOUNTED, src, &source)) 1531fa9e4066Sahrens (void) strlcpy(propbuf, "yes", proplen); 1532fa9e4066Sahrens else 1533fa9e4066Sahrens (void) strlcpy(propbuf, "no", proplen); 1534fa9e4066Sahrens break; 1535fa9e4066Sahrens 1536fa9e4066Sahrens case ZFS_PROP_NAME: 1537fa9e4066Sahrens /* 1538fa9e4066Sahrens * The 'name' property is a pseudo-property derived from the 1539fa9e4066Sahrens * dataset name. It is presented as a real property to simplify 1540fa9e4066Sahrens * consumers. 1541fa9e4066Sahrens */ 1542fa9e4066Sahrens (void) strlcpy(propbuf, zhp->zfs_name, proplen); 1543fa9e4066Sahrens break; 1544fa9e4066Sahrens 1545fa9e4066Sahrens default: 1546fa9e4066Sahrens zfs_baderror(EINVAL); 1547fa9e4066Sahrens } 1548fa9e4066Sahrens 1549fa9e4066Sahrens get_source(zhp, src, source, statbuf, statlen); 1550fa9e4066Sahrens 1551fa9e4066Sahrens return (0); 1552fa9e4066Sahrens } 1553fa9e4066Sahrens 1554fa9e4066Sahrens /* 1555fa9e4066Sahrens * Utility function to get the given numeric property. Does no validation that 1556fa9e4066Sahrens * the given property is the appropriate type; should only be used with 1557fa9e4066Sahrens * hard-coded property types. 1558fa9e4066Sahrens */ 1559fa9e4066Sahrens uint64_t 1560fa9e4066Sahrens zfs_prop_get_int(zfs_handle_t *zhp, zfs_prop_t prop) 1561fa9e4066Sahrens { 1562fa9e4066Sahrens char *source; 1563fa9e4066Sahrens zfs_source_t sourcetype = ZFS_SRC_NONE; 1564fa9e4066Sahrens 1565fa9e4066Sahrens return (get_numeric_property(zhp, prop, &sourcetype, &source)); 1566fa9e4066Sahrens } 1567fa9e4066Sahrens 1568fa9e4066Sahrens /* 1569fa9e4066Sahrens * Similar to zfs_prop_get(), but returns the value as an integer. 1570fa9e4066Sahrens */ 1571fa9e4066Sahrens int 1572fa9e4066Sahrens zfs_prop_get_numeric(zfs_handle_t *zhp, zfs_prop_t prop, uint64_t *value, 1573fa9e4066Sahrens zfs_source_t *src, char *statbuf, size_t statlen) 1574fa9e4066Sahrens { 1575fa9e4066Sahrens char *source; 1576fa9e4066Sahrens 1577fa9e4066Sahrens /* 1578fa9e4066Sahrens * Check to see if this property applies to our object 1579fa9e4066Sahrens */ 1580fa9e4066Sahrens if (!zfs_prop_valid_for_type(prop, zhp->zfs_type)) 1581fa9e4066Sahrens return (-1); 1582fa9e4066Sahrens 1583fa9e4066Sahrens if (src) 1584fa9e4066Sahrens *src = ZFS_SRC_NONE; 1585fa9e4066Sahrens 1586fa9e4066Sahrens *value = get_numeric_property(zhp, prop, src, &source); 1587fa9e4066Sahrens 1588fa9e4066Sahrens get_source(zhp, src, source, statbuf, statlen); 1589fa9e4066Sahrens 1590fa9e4066Sahrens return (0); 1591fa9e4066Sahrens } 1592fa9e4066Sahrens 1593fa9e4066Sahrens /* 1594fa9e4066Sahrens * Returns the name of the given zfs handle. 1595fa9e4066Sahrens */ 1596fa9e4066Sahrens const char * 1597fa9e4066Sahrens zfs_get_name(const zfs_handle_t *zhp) 1598fa9e4066Sahrens { 1599fa9e4066Sahrens return (zhp->zfs_name); 1600fa9e4066Sahrens } 1601fa9e4066Sahrens 1602fa9e4066Sahrens /* 1603fa9e4066Sahrens * Returns the type of the given zfs handle. 1604fa9e4066Sahrens */ 1605fa9e4066Sahrens zfs_type_t 1606fa9e4066Sahrens zfs_get_type(const zfs_handle_t *zhp) 1607fa9e4066Sahrens { 1608fa9e4066Sahrens return (zhp->zfs_type); 1609fa9e4066Sahrens } 1610fa9e4066Sahrens 1611fa9e4066Sahrens /* 16127f7322feSeschrock * Iterate over all child filesystems 1613fa9e4066Sahrens */ 1614fa9e4066Sahrens int 16157f7322feSeschrock zfs_iter_filesystems(zfs_handle_t *zhp, zfs_iter_f func, void *data) 1616fa9e4066Sahrens { 1617fa9e4066Sahrens zfs_cmd_t zc = { 0 }; 1618fa9e4066Sahrens zfs_handle_t *nzhp; 1619fa9e4066Sahrens int ret; 1620fa9e4066Sahrens 1621fa9e4066Sahrens for ((void) strlcpy(zc.zc_name, zhp->zfs_name, sizeof (zc.zc_name)); 1622fa9e4066Sahrens ioctl(zfs_fd, ZFS_IOC_DATASET_LIST_NEXT, &zc) == 0; 1623fa9e4066Sahrens (void) strlcpy(zc.zc_name, zhp->zfs_name, sizeof (zc.zc_name))) { 1624fa9e4066Sahrens /* 1625fa9e4066Sahrens * Ignore private dataset names. 1626fa9e4066Sahrens */ 1627fa9e4066Sahrens if (dataset_name_hidden(zc.zc_name)) 1628fa9e4066Sahrens continue; 1629fa9e4066Sahrens 1630fa9e4066Sahrens /* 1631fa9e4066Sahrens * Silently ignore errors, as the only plausible explanation is 1632fa9e4066Sahrens * that the pool has since been removed. 1633fa9e4066Sahrens */ 1634fa9e4066Sahrens if ((nzhp = make_dataset_handle(zc.zc_name)) == NULL) 1635fa9e4066Sahrens continue; 1636fa9e4066Sahrens 1637fa9e4066Sahrens if ((ret = func(nzhp, data)) != 0) 1638fa9e4066Sahrens return (ret); 1639fa9e4066Sahrens } 1640fa9e4066Sahrens 1641fa9e4066Sahrens /* 1642fa9e4066Sahrens * An errno value of ESRCH indicates normal completion. If ENOENT is 1643fa9e4066Sahrens * returned, then the underlying dataset has been removed since we 1644fa9e4066Sahrens * obtained the handle. 1645fa9e4066Sahrens */ 1646fa9e4066Sahrens if (errno != ESRCH && errno != ENOENT) 1647fa9e4066Sahrens zfs_baderror(errno); 1648fa9e4066Sahrens 16497f7322feSeschrock return (0); 16507f7322feSeschrock } 16517f7322feSeschrock 16527f7322feSeschrock /* 16537f7322feSeschrock * Iterate over all snapshots 16547f7322feSeschrock */ 16557f7322feSeschrock int 16567f7322feSeschrock zfs_iter_snapshots(zfs_handle_t *zhp, zfs_iter_f func, void *data) 16577f7322feSeschrock { 16587f7322feSeschrock zfs_cmd_t zc = { 0 }; 16597f7322feSeschrock zfs_handle_t *nzhp; 16607f7322feSeschrock int ret; 1661fa9e4066Sahrens 1662fa9e4066Sahrens for ((void) strlcpy(zc.zc_name, zhp->zfs_name, sizeof (zc.zc_name)); 1663fa9e4066Sahrens ioctl(zfs_fd, ZFS_IOC_SNAPSHOT_LIST_NEXT, &zc) == 0; 1664fa9e4066Sahrens (void) strlcpy(zc.zc_name, zhp->zfs_name, sizeof (zc.zc_name))) { 1665fa9e4066Sahrens 1666fa9e4066Sahrens if ((nzhp = make_dataset_handle(zc.zc_name)) == NULL) 1667fa9e4066Sahrens continue; 1668fa9e4066Sahrens 1669fa9e4066Sahrens if ((ret = func(nzhp, data)) != 0) 1670fa9e4066Sahrens return (ret); 1671fa9e4066Sahrens } 1672fa9e4066Sahrens 1673fa9e4066Sahrens /* 1674fa9e4066Sahrens * An errno value of ESRCH indicates normal completion. If ENOENT is 1675fa9e4066Sahrens * returned, then the underlying dataset has been removed since we 1676fa9e4066Sahrens * obtained the handle. Silently ignore this case, and return success. 1677fa9e4066Sahrens */ 1678fa9e4066Sahrens if (errno != ESRCH && errno != ENOENT) 1679fa9e4066Sahrens zfs_baderror(errno); 1680fa9e4066Sahrens 1681fa9e4066Sahrens return (0); 1682fa9e4066Sahrens } 1683fa9e4066Sahrens 16847f7322feSeschrock /* 16857f7322feSeschrock * Iterate over all children, snapshots and filesystems 16867f7322feSeschrock */ 16877f7322feSeschrock int 16887f7322feSeschrock zfs_iter_children(zfs_handle_t *zhp, zfs_iter_f func, void *data) 16897f7322feSeschrock { 16907f7322feSeschrock int ret; 16917f7322feSeschrock 16927f7322feSeschrock if ((ret = zfs_iter_filesystems(zhp, func, data)) != 0) 16937f7322feSeschrock return (ret); 16947f7322feSeschrock 16957f7322feSeschrock return (zfs_iter_snapshots(zhp, func, data)); 16967f7322feSeschrock } 16977f7322feSeschrock 1698fa9e4066Sahrens /* 1699fa9e4066Sahrens * Given a complete name, return just the portion that refers to the parent. 1700fa9e4066Sahrens * Can return NULL if this is a pool. 1701fa9e4066Sahrens */ 1702fa9e4066Sahrens static int 1703fa9e4066Sahrens parent_name(const char *path, char *buf, size_t buflen) 1704fa9e4066Sahrens { 1705fa9e4066Sahrens char *loc; 1706fa9e4066Sahrens 1707fa9e4066Sahrens if ((loc = strrchr(path, '/')) == NULL) 1708fa9e4066Sahrens return (-1); 1709fa9e4066Sahrens 1710fa9e4066Sahrens (void) strncpy(buf, path, MIN(buflen, loc - path)); 1711fa9e4066Sahrens buf[loc - path] = '\0'; 1712fa9e4066Sahrens 1713fa9e4066Sahrens return (0); 1714fa9e4066Sahrens } 1715fa9e4066Sahrens 1716fa9e4066Sahrens /* 1717fa9e4066Sahrens * Checks to make sure that the given path has a parent, and that it exists. 1718fa9e4066Sahrens */ 1719fa9e4066Sahrens static int 1720fa9e4066Sahrens check_parents(const char *path, zfs_type_t type) 1721fa9e4066Sahrens { 1722fa9e4066Sahrens zfs_cmd_t zc = { 0 }; 1723fa9e4066Sahrens char parent[ZFS_MAXNAMELEN]; 1724fa9e4066Sahrens char *slash; 17257f7322feSeschrock zfs_handle_t *zhp; 1726fa9e4066Sahrens 1727fa9e4066Sahrens /* get parent, and check to see if this is just a pool */ 1728fa9e4066Sahrens if (parent_name(path, parent, sizeof (parent)) != 0) { 1729fa9e4066Sahrens zfs_error(dgettext(TEXT_DOMAIN, 1730fa9e4066Sahrens "cannot create '%s': missing dataset name"), 1731fa9e4066Sahrens path, zfs_type_to_name(type)); 1732fa9e4066Sahrens zfs_error(dgettext(TEXT_DOMAIN, 1733fa9e4066Sahrens "use 'zpool create' to create a storage pool")); 1734fa9e4066Sahrens return (-1); 1735fa9e4066Sahrens } 1736fa9e4066Sahrens 1737fa9e4066Sahrens /* check to see if the pool exists */ 1738fa9e4066Sahrens if ((slash = strchr(parent, '/')) == NULL) 1739fa9e4066Sahrens slash = parent + strlen(parent); 1740fa9e4066Sahrens (void) strncpy(zc.zc_name, parent, slash - parent); 1741fa9e4066Sahrens zc.zc_name[slash - parent] = '\0'; 1742fa9e4066Sahrens if (ioctl(zfs_fd, ZFS_IOC_OBJSET_STATS, &zc) != 0 && 1743fa9e4066Sahrens errno == ENOENT) { 1744fa9e4066Sahrens zfs_error(dgettext(TEXT_DOMAIN, 1745fa9e4066Sahrens "cannot create '%s': no such pool '%s'"), path, zc.zc_name); 1746fa9e4066Sahrens return (-1); 1747fa9e4066Sahrens } 1748fa9e4066Sahrens 1749fa9e4066Sahrens /* check to see if the parent dataset exists */ 17507f7322feSeschrock if ((zhp = make_dataset_handle(parent)) == NULL) { 1751fa9e4066Sahrens switch (errno) { 1752fa9e4066Sahrens case ENOENT: 1753fa9e4066Sahrens zfs_error(dgettext(TEXT_DOMAIN, 1754fa9e4066Sahrens "cannot create '%s': parent does not exist"), path); 1755fa9e4066Sahrens return (-1); 1756fa9e4066Sahrens 1757fa9e4066Sahrens default: 1758fa9e4066Sahrens zfs_baderror(errno); 1759fa9e4066Sahrens } 1760fa9e4066Sahrens } 1761fa9e4066Sahrens 1762fa9e4066Sahrens /* we are in a non-global zone, but parent is in the global zone */ 17637f7322feSeschrock if (getzoneid() != GLOBAL_ZONEID && 1764*20c8013fSlling !zfs_prop_get_int(zhp, ZFS_PROP_ZONED)) { 1765fa9e4066Sahrens zfs_error(dgettext(TEXT_DOMAIN, 1766fa9e4066Sahrens "cannot create '%s': permission denied"), path); 17677f7322feSeschrock zfs_close(zhp); 1768fa9e4066Sahrens return (-1); 1769fa9e4066Sahrens } 1770fa9e4066Sahrens 1771fa9e4066Sahrens /* make sure parent is a filesystem */ 17727f7322feSeschrock if (zfs_get_type(zhp) != ZFS_TYPE_FILESYSTEM) { 1773fa9e4066Sahrens zfs_error(dgettext(TEXT_DOMAIN, 1774fa9e4066Sahrens "cannot create '%s': parent is not a filesystem"), 1775fa9e4066Sahrens path); 17767f7322feSeschrock zfs_close(zhp); 1777fa9e4066Sahrens return (-1); 1778fa9e4066Sahrens } 1779fa9e4066Sahrens 17807f7322feSeschrock zfs_close(zhp); 1781fa9e4066Sahrens return (0); 1782fa9e4066Sahrens } 1783fa9e4066Sahrens 1784fa9e4066Sahrens /* 1785fa9e4066Sahrens * Create a new filesystem or volume. 'sizestr' and 'blocksizestr' are used 1786fa9e4066Sahrens * only for volumes, and indicate the size and blocksize of the volume. 1787fa9e4066Sahrens */ 1788fa9e4066Sahrens int 1789fa9e4066Sahrens zfs_create(const char *path, zfs_type_t type, 1790fa9e4066Sahrens const char *sizestr, const char *blocksizestr) 1791fa9e4066Sahrens { 1792fa9e4066Sahrens char reason[64]; 1793fa9e4066Sahrens zfs_cmd_t zc = { 0 }; 1794fa9e4066Sahrens int ret; 1795fa9e4066Sahrens uint64_t size = 0; 1796fa9e4066Sahrens uint64_t blocksize = zfs_prop_default_numeric(ZFS_PROP_VOLBLOCKSIZE); 1797fa9e4066Sahrens 1798fa9e4066Sahrens /* convert sizestr into integer size */ 1799fa9e4066Sahrens if (sizestr != NULL && nicestrtonum(sizestr, &size, 1800fa9e4066Sahrens reason, sizeof (reason)) != 0) { 1801fa9e4066Sahrens zfs_error(dgettext(TEXT_DOMAIN, 1802fa9e4066Sahrens "bad volume size '%s': %s"), sizestr, reason); 1803fa9e4066Sahrens return (-1); 1804fa9e4066Sahrens } 1805fa9e4066Sahrens 1806fa9e4066Sahrens /* convert blocksizestr into integer blocksize */ 1807fa9e4066Sahrens if (blocksizestr != NULL && nicestrtonum(blocksizestr, &blocksize, 1808fa9e4066Sahrens reason, sizeof (reason)) != 0) { 1809fa9e4066Sahrens zfs_error(dgettext(TEXT_DOMAIN, 1810fa9e4066Sahrens "bad volume blocksize '%s': %s"), blocksizestr, reason); 1811fa9e4066Sahrens return (-1); 1812fa9e4066Sahrens } 1813fa9e4066Sahrens 1814fa9e4066Sahrens /* validate the path, taking care to note the extended error message */ 1815fa9e4066Sahrens if (!zfs_validate_name(path, type, reason, sizeof (reason))) { 1816fa9e4066Sahrens zfs_error(dgettext(TEXT_DOMAIN, 1817fa9e4066Sahrens "cannot create '%s': %s in %s name"), path, reason, 1818fa9e4066Sahrens zfs_type_to_name(type)); 1819fa9e4066Sahrens if (strstr(reason, "snapshot") != NULL) 1820fa9e4066Sahrens zfs_error(dgettext(TEXT_DOMAIN, 1821fa9e4066Sahrens "use 'zfs snapshot' to create a snapshot")); 1822fa9e4066Sahrens return (-1); 1823fa9e4066Sahrens } 1824fa9e4066Sahrens 1825fa9e4066Sahrens /* validate parents exist */ 1826fa9e4066Sahrens if (check_parents(path, type) != 0) 1827fa9e4066Sahrens return (-1); 1828fa9e4066Sahrens 1829fa9e4066Sahrens /* 1830fa9e4066Sahrens * The failure modes when creating a dataset of a different type over 1831fa9e4066Sahrens * one that already exists is a little strange. In particular, if you 1832fa9e4066Sahrens * try to create a dataset on top of an existing dataset, the ioctl() 1833fa9e4066Sahrens * will return ENOENT, not EEXIST. To prevent this from happening, we 1834fa9e4066Sahrens * first try to see if the dataset exists. 1835fa9e4066Sahrens */ 1836fa9e4066Sahrens (void) strlcpy(zc.zc_name, path, sizeof (zc.zc_name)); 1837fa9e4066Sahrens if (ioctl(zfs_fd, ZFS_IOC_OBJSET_STATS, &zc) == 0) { 1838fa9e4066Sahrens zfs_error(dgettext(TEXT_DOMAIN, 1839fa9e4066Sahrens "cannot create '%s': dataset exists"), path); 1840fa9e4066Sahrens return (-1); 1841fa9e4066Sahrens } 1842fa9e4066Sahrens 1843fa9e4066Sahrens if (type == ZFS_TYPE_VOLUME) 1844fa9e4066Sahrens zc.zc_objset_type = DMU_OST_ZVOL; 1845fa9e4066Sahrens else 1846fa9e4066Sahrens zc.zc_objset_type = DMU_OST_ZFS; 1847fa9e4066Sahrens 1848fa9e4066Sahrens if (type == ZFS_TYPE_VOLUME) { 18495c5460e9Seschrock /* 18505c5460e9Seschrock * If we are creating a volume, the size and block size must 18515c5460e9Seschrock * satisfy a few restraints. First, the blocksize must be a 18525c5460e9Seschrock * valid block size between SPA_{MIN,MAX}BLOCKSIZE. Second, the 18535c5460e9Seschrock * volsize must be a multiple of the block size, and cannot be 18545c5460e9Seschrock * zero. 18555c5460e9Seschrock */ 1856fa9e4066Sahrens if (size == 0) { 1857fa9e4066Sahrens zfs_error(dgettext(TEXT_DOMAIN, 1858fa9e4066Sahrens "bad volume size '%s': cannot be zero"), sizestr); 1859fa9e4066Sahrens return (-1); 1860fa9e4066Sahrens } 1861fa9e4066Sahrens 18625c5460e9Seschrock if (blocksize < SPA_MINBLOCKSIZE || 18635c5460e9Seschrock blocksize > SPA_MAXBLOCKSIZE || !ISP2(blocksize)) { 18645c5460e9Seschrock zfs_error(dgettext(TEXT_DOMAIN, 18655c5460e9Seschrock "bad volume block size '%s': " 18665c5460e9Seschrock "must be power of 2 from %u to %uk"), 18675c5460e9Seschrock blocksizestr, 18685c5460e9Seschrock (uint_t)SPA_MINBLOCKSIZE, 18695c5460e9Seschrock (uint_t)SPA_MAXBLOCKSIZE >> 10); 18705c5460e9Seschrock return (-1); 18715c5460e9Seschrock } 18725c5460e9Seschrock 18735c5460e9Seschrock if (size % blocksize != 0) { 18745c5460e9Seschrock char buf[64]; 18755c5460e9Seschrock zfs_nicenum(blocksize, buf, sizeof (buf)); 18765c5460e9Seschrock zfs_error(dgettext(TEXT_DOMAIN, 18775c5460e9Seschrock "bad volume size '%s': " 18785c5460e9Seschrock "must be multiple of volume block size (%s)"), 18795c5460e9Seschrock sizestr, buf); 18805c5460e9Seschrock return (-1); 18815c5460e9Seschrock } 18825c5460e9Seschrock 1883fa9e4066Sahrens zc.zc_volsize = size; 1884fa9e4066Sahrens zc.zc_volblocksize = blocksize; 1885fa9e4066Sahrens } 1886fa9e4066Sahrens 1887fa9e4066Sahrens /* create the dataset */ 1888fa9e4066Sahrens ret = ioctl(zfs_fd, ZFS_IOC_CREATE, &zc); 1889fa9e4066Sahrens 1890fa9e4066Sahrens if (ret == 0 && type == ZFS_TYPE_VOLUME) 1891fa9e4066Sahrens ret = zvol_create_link(path); 1892fa9e4066Sahrens 1893fa9e4066Sahrens /* check for failure */ 1894fa9e4066Sahrens if (ret != 0) { 1895fa9e4066Sahrens char parent[ZFS_MAXNAMELEN]; 1896fa9e4066Sahrens (void) parent_name(path, parent, sizeof (parent)); 1897fa9e4066Sahrens 1898fa9e4066Sahrens switch (errno) { 1899fa9e4066Sahrens case ENOENT: 1900fa9e4066Sahrens /* 1901fa9e4066Sahrens * The parent dataset has been deleted since our 1902fa9e4066Sahrens * previous check. 1903fa9e4066Sahrens */ 1904fa9e4066Sahrens zfs_error(dgettext(TEXT_DOMAIN, 1905fa9e4066Sahrens "cannot create '%s': no such parent '%s'"), 1906fa9e4066Sahrens path, parent); 1907fa9e4066Sahrens break; 1908fa9e4066Sahrens 1909fa9e4066Sahrens case EPERM: 1910fa9e4066Sahrens /* 1911fa9e4066Sahrens * The user doesn't have permission to create a new 1912fa9e4066Sahrens * dataset here. 1913fa9e4066Sahrens */ 1914fa9e4066Sahrens zfs_error(dgettext(TEXT_DOMAIN, 1915fa9e4066Sahrens "cannot create '%s': permission denied"), path); 1916fa9e4066Sahrens break; 1917fa9e4066Sahrens 1918fa9e4066Sahrens case EDQUOT: 1919fa9e4066Sahrens case ENOSPC: 1920fa9e4066Sahrens /* 1921fa9e4066Sahrens * The parent dataset does not have enough free space 1922fa9e4066Sahrens * to create a new dataset. 1923fa9e4066Sahrens */ 1924fa9e4066Sahrens zfs_error(dgettext(TEXT_DOMAIN, 1925fa9e4066Sahrens "cannot create '%s': not enough space in '%s'"), 1926fa9e4066Sahrens path, parent); 1927fa9e4066Sahrens break; 1928fa9e4066Sahrens 1929fa9e4066Sahrens case EEXIST: 1930fa9e4066Sahrens /* 1931fa9e4066Sahrens * The target dataset already exists. We should have 1932fa9e4066Sahrens * caught this above, but there may be some unexplained 1933fa9e4066Sahrens * race condition. 1934fa9e4066Sahrens */ 1935fa9e4066Sahrens zfs_error(dgettext(TEXT_DOMAIN, 1936fa9e4066Sahrens "cannot create '%s': dataset exists"), path); 1937fa9e4066Sahrens break; 1938fa9e4066Sahrens 1939fa9e4066Sahrens case EINVAL: 1940fa9e4066Sahrens /* 1941fa9e4066Sahrens * The target dataset does not support children. 1942fa9e4066Sahrens */ 1943fa9e4066Sahrens zfs_error(dgettext(TEXT_DOMAIN, 1944fa9e4066Sahrens "cannot create '%s': children unsupported in '%s'"), 1945fa9e4066Sahrens path, parent); 1946fa9e4066Sahrens break; 1947fa9e4066Sahrens 1948fa9e4066Sahrens case EDOM: 1949fa9e4066Sahrens zfs_error(dgettext(TEXT_DOMAIN, "bad %s value '%s': " 1950fa9e4066Sahrens "must be power of 2 from %u to %uk"), 1951fa9e4066Sahrens zfs_prop_to_name(ZFS_PROP_VOLBLOCKSIZE), 1952fa9e4066Sahrens blocksizestr ? blocksizestr : "<unknown>", 1953fa9e4066Sahrens (uint_t)SPA_MINBLOCKSIZE, 1954fa9e4066Sahrens (uint_t)SPA_MAXBLOCKSIZE >> 10); 1955fa9e4066Sahrens break; 1956fa9e4066Sahrens #ifdef _ILP32 1957fa9e4066Sahrens case EOVERFLOW: 1958fa9e4066Sahrens /* 1959fa9e4066Sahrens * This platform can't address a volume this big. 1960fa9e4066Sahrens */ 1961fa9e4066Sahrens if (type == ZFS_TYPE_VOLUME) { 1962fa9e4066Sahrens zfs_error(dgettext(TEXT_DOMAIN, 1963fa9e4066Sahrens "cannot create '%s': " 1964fa9e4066Sahrens "max volume size is 1TB on 32-bit systems"), 1965fa9e4066Sahrens path); 1966fa9e4066Sahrens break; 1967fa9e4066Sahrens } 1968fa9e4066Sahrens #endif 1969fa9e4066Sahrens 1970fa9e4066Sahrens default: 1971fa9e4066Sahrens zfs_baderror(errno); 1972fa9e4066Sahrens } 1973fa9e4066Sahrens 1974fa9e4066Sahrens return (-1); 1975fa9e4066Sahrens } 1976fa9e4066Sahrens 1977fa9e4066Sahrens return (0); 1978fa9e4066Sahrens } 1979fa9e4066Sahrens 1980fa9e4066Sahrens /* 1981fa9e4066Sahrens * Destroys the given dataset. The caller must make sure that the filesystem 1982fa9e4066Sahrens * isn't mounted, and that there are no active dependents. 1983fa9e4066Sahrens */ 1984fa9e4066Sahrens int 1985fa9e4066Sahrens zfs_destroy(zfs_handle_t *zhp) 1986fa9e4066Sahrens { 1987fa9e4066Sahrens zfs_cmd_t zc = { 0 }; 1988fa9e4066Sahrens int ret; 1989fa9e4066Sahrens 1990fa9e4066Sahrens (void) strlcpy(zc.zc_name, zhp->zfs_name, sizeof (zc.zc_name)); 1991fa9e4066Sahrens 1992fa9e4066Sahrens /* 1993fa9e4066Sahrens * We use the check for 'zfs_volblocksize' instead of ZFS_TYPE_VOLUME 1994fa9e4066Sahrens * so that we do the right thing for snapshots of volumes. 1995fa9e4066Sahrens */ 1996fa9e4066Sahrens if (zhp->zfs_volblocksize != 0) { 1997fa9e4066Sahrens if (zvol_remove_link(zhp->zfs_name) != 0) 1998fa9e4066Sahrens return (-1); 1999fa9e4066Sahrens 2000fa9e4066Sahrens zc.zc_objset_type = DMU_OST_ZVOL; 2001fa9e4066Sahrens } else { 2002fa9e4066Sahrens zc.zc_objset_type = DMU_OST_ZFS; 2003fa9e4066Sahrens } 2004fa9e4066Sahrens 2005fa9e4066Sahrens ret = ioctl(zfs_fd, ZFS_IOC_DESTROY, &zc); 2006fa9e4066Sahrens 2007fa9e4066Sahrens if (ret != 0) { 2008fa9e4066Sahrens switch (errno) { 2009fa9e4066Sahrens 2010fa9e4066Sahrens case EPERM: 2011fa9e4066Sahrens /* 2012fa9e4066Sahrens * We don't have permission to destroy this dataset. 2013fa9e4066Sahrens */ 2014fa9e4066Sahrens zfs_error(dgettext(TEXT_DOMAIN, 2015fa9e4066Sahrens "cannot destroy '%s': permission denied"), 2016fa9e4066Sahrens zhp->zfs_name); 2017fa9e4066Sahrens break; 2018fa9e4066Sahrens 2019fa9e4066Sahrens case ENOENT: 2020fa9e4066Sahrens /* 2021fa9e4066Sahrens * We've hit a race condition where the dataset has been 2022fa9e4066Sahrens * destroyed since we opened it. 2023fa9e4066Sahrens */ 2024fa9e4066Sahrens zfs_error(dgettext(TEXT_DOMAIN, 2025fa9e4066Sahrens "cannot destroy '%s': no such %s"), 2026fa9e4066Sahrens zhp->zfs_name, zfs_type_to_name(zhp->zfs_type)); 2027fa9e4066Sahrens break; 2028fa9e4066Sahrens 2029fa9e4066Sahrens case EBUSY: 2030fa9e4066Sahrens /* 2031fa9e4066Sahrens * Even if we destroy all children, there is a chance we 2032fa9e4066Sahrens * can hit this case if: 2033fa9e4066Sahrens * 2034fa9e4066Sahrens * - A child dataset has since been created 2035fa9e4066Sahrens * - A filesystem is mounted 2036fa9e4066Sahrens * 2037fa9e4066Sahrens * This error message is awful, but hopefully we've 2038fa9e4066Sahrens * already caught the common cases (and aborted more 2039fa9e4066Sahrens * appropriately) before calling this function. There's 2040fa9e4066Sahrens * nothing else we can do at this point. 2041fa9e4066Sahrens */ 2042fa9e4066Sahrens zfs_error(dgettext(TEXT_DOMAIN, 2043fa9e4066Sahrens "cannot destroy '%s': %s is busy"), 2044fa9e4066Sahrens zhp->zfs_name, zfs_type_to_name(zhp->zfs_type)); 2045fa9e4066Sahrens break; 2046fa9e4066Sahrens 2047fa9e4066Sahrens default: 2048fa9e4066Sahrens zfs_baderror(errno); 2049fa9e4066Sahrens } 2050fa9e4066Sahrens 2051fa9e4066Sahrens return (-1); 2052fa9e4066Sahrens } 2053fa9e4066Sahrens 2054fa9e4066Sahrens remove_mountpoint(zhp); 2055fa9e4066Sahrens 2056fa9e4066Sahrens return (0); 2057fa9e4066Sahrens } 2058fa9e4066Sahrens 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 char reason[64]; 2066fa9e4066Sahrens zfs_cmd_t zc = { 0 }; 2067fa9e4066Sahrens char parent[ZFS_MAXNAMELEN]; 2068fa9e4066Sahrens int ret; 2069fa9e4066Sahrens 2070fa9e4066Sahrens assert(zhp->zfs_type == ZFS_TYPE_SNAPSHOT); 2071fa9e4066Sahrens 2072fa9e4066Sahrens /* validate the target name */ 2073fa9e4066Sahrens if (!zfs_validate_name(target, ZFS_TYPE_FILESYSTEM, reason, 2074fa9e4066Sahrens sizeof (reason))) { 2075fa9e4066Sahrens zfs_error(dgettext(TEXT_DOMAIN, 2076fa9e4066Sahrens "cannot create '%s': %s in filesystem name"), target, 2077fa9e4066Sahrens reason, zfs_type_to_name(ZFS_TYPE_FILESYSTEM)); 2078fa9e4066Sahrens return (-1); 2079fa9e4066Sahrens } 2080fa9e4066Sahrens 2081fa9e4066Sahrens /* validate parents exist */ 2082fa9e4066Sahrens if (check_parents(target, zhp->zfs_type) != 0) 2083fa9e4066Sahrens return (-1); 2084fa9e4066Sahrens 2085fa9e4066Sahrens (void) parent_name(target, parent, sizeof (parent)); 2086fa9e4066Sahrens 2087fa9e4066Sahrens /* do the clone */ 2088fa9e4066Sahrens if (zhp->zfs_volblocksize != 0) 2089fa9e4066Sahrens zc.zc_objset_type = DMU_OST_ZVOL; 2090fa9e4066Sahrens else 2091fa9e4066Sahrens zc.zc_objset_type = DMU_OST_ZFS; 2092fa9e4066Sahrens 2093fa9e4066Sahrens (void) strlcpy(zc.zc_name, target, sizeof (zc.zc_name)); 2094fa9e4066Sahrens (void) strlcpy(zc.zc_filename, zhp->zfs_name, sizeof (zc.zc_filename)); 2095fa9e4066Sahrens ret = ioctl(zfs_fd, ZFS_IOC_CREATE, &zc); 2096fa9e4066Sahrens 2097fa9e4066Sahrens if (ret != 0) { 2098fa9e4066Sahrens switch (errno) { 2099fa9e4066Sahrens case EPERM: 2100fa9e4066Sahrens /* 2101fa9e4066Sahrens * The user doesn't have permission to create the clone. 2102fa9e4066Sahrens */ 2103fa9e4066Sahrens zfs_error(dgettext(TEXT_DOMAIN, 2104fa9e4066Sahrens "cannot create '%s': permission denied"), 2105fa9e4066Sahrens target); 2106fa9e4066Sahrens break; 2107fa9e4066Sahrens 2108fa9e4066Sahrens case ENOENT: 2109fa9e4066Sahrens /* 2110fa9e4066Sahrens * The parent doesn't exist. We should have caught this 2111fa9e4066Sahrens * above, but there may a race condition that has since 2112fa9e4066Sahrens * destroyed the parent. 2113fa9e4066Sahrens * 2114fa9e4066Sahrens * At this point, we don't know whether it's the source 2115fa9e4066Sahrens * that doesn't exist anymore, or whether the target 2116fa9e4066Sahrens * dataset doesn't exist. 2117fa9e4066Sahrens */ 2118fa9e4066Sahrens zfs_error(dgettext(TEXT_DOMAIN, 2119fa9e4066Sahrens "cannot create '%s': no such parent '%s'"), 2120fa9e4066Sahrens target, parent); 2121fa9e4066Sahrens break; 2122fa9e4066Sahrens 2123fa9e4066Sahrens case EDQUOT: 2124fa9e4066Sahrens case ENOSPC: 2125fa9e4066Sahrens /* 2126fa9e4066Sahrens * There is not enough space in the target dataset 2127fa9e4066Sahrens */ 2128fa9e4066Sahrens zfs_error(dgettext(TEXT_DOMAIN, 2129fa9e4066Sahrens "cannot create '%s': not enough space in '%s'"), 2130fa9e4066Sahrens target, parent); 2131fa9e4066Sahrens break; 2132fa9e4066Sahrens 2133fa9e4066Sahrens case EEXIST: 2134fa9e4066Sahrens /* 2135fa9e4066Sahrens * The target already exists. 2136fa9e4066Sahrens */ 2137fa9e4066Sahrens zfs_error(dgettext(TEXT_DOMAIN, 2138fa9e4066Sahrens "cannot create '%s': dataset exists"), target); 2139fa9e4066Sahrens break; 2140fa9e4066Sahrens 2141fa9e4066Sahrens case EXDEV: 2142fa9e4066Sahrens /* 2143fa9e4066Sahrens * The source and target pools differ. 2144fa9e4066Sahrens */ 2145fa9e4066Sahrens zfs_error(dgettext(TEXT_DOMAIN, "cannot create '%s': " 2146fa9e4066Sahrens "source and target pools differ"), target); 2147fa9e4066Sahrens break; 2148fa9e4066Sahrens 2149fa9e4066Sahrens default: 2150fa9e4066Sahrens zfs_baderror(errno); 2151fa9e4066Sahrens } 2152fa9e4066Sahrens } else if (zhp->zfs_volblocksize != 0) { 2153fa9e4066Sahrens ret = zvol_create_link(target); 2154fa9e4066Sahrens } 2155fa9e4066Sahrens 2156fa9e4066Sahrens return (ret); 2157fa9e4066Sahrens } 2158fa9e4066Sahrens 2159fa9e4066Sahrens /* 2160fa9e4066Sahrens * Takes a snapshot of the given dataset 2161fa9e4066Sahrens */ 2162fa9e4066Sahrens int 2163fa9e4066Sahrens zfs_snapshot(const char *path) 2164fa9e4066Sahrens { 2165fa9e4066Sahrens char reason[64]; 2166fa9e4066Sahrens const char *delim; 2167fa9e4066Sahrens char *parent; 2168fa9e4066Sahrens zfs_handle_t *zhp; 2169fa9e4066Sahrens zfs_cmd_t zc = { 0 }; 2170fa9e4066Sahrens int ret; 2171fa9e4066Sahrens 2172fa9e4066Sahrens /* validate the snapshot name */ 2173fa9e4066Sahrens if (!zfs_validate_name(path, ZFS_TYPE_SNAPSHOT, reason, 2174fa9e4066Sahrens sizeof (reason))) { 2175fa9e4066Sahrens zfs_error(dgettext(TEXT_DOMAIN, 2176fa9e4066Sahrens "cannot snapshot '%s': %s in snapshot name"), path, 2177fa9e4066Sahrens reason); 2178fa9e4066Sahrens return (-1); 2179fa9e4066Sahrens } 2180fa9e4066Sahrens 2181fa9e4066Sahrens /* make sure we have a snapshot */ 2182fa9e4066Sahrens if ((delim = strchr(path, '@')) == NULL) { 2183fa9e4066Sahrens zfs_error(dgettext(TEXT_DOMAIN, 2184fa9e4066Sahrens "cannot snapshot '%s': missing '@' delim in snapshot " 2185fa9e4066Sahrens "name"), path); 2186fa9e4066Sahrens zfs_error(dgettext(TEXT_DOMAIN, 2187fa9e4066Sahrens "use 'zfs create' to create a filesystem")); 2188fa9e4066Sahrens return (-1); 2189fa9e4066Sahrens } 2190fa9e4066Sahrens 2191fa9e4066Sahrens /* make sure the parent exists and is of the appropriate type */ 2192fa9e4066Sahrens parent = zfs_malloc(delim - path + 1); 2193fa9e4066Sahrens (void) strncpy(parent, path, delim - path); 2194fa9e4066Sahrens parent[delim - path] = '\0'; 2195fa9e4066Sahrens 2196fa9e4066Sahrens if ((zhp = zfs_open(parent, ZFS_TYPE_FILESYSTEM | 2197fa9e4066Sahrens ZFS_TYPE_VOLUME)) == NULL) { 2198fa9e4066Sahrens free(parent); 2199fa9e4066Sahrens return (-1); 2200fa9e4066Sahrens } 2201fa9e4066Sahrens 2202fa9e4066Sahrens (void) strlcpy(zc.zc_name, path, sizeof (zc.zc_name)); 2203fa9e4066Sahrens 2204fa9e4066Sahrens if (zhp->zfs_type == ZFS_TYPE_VOLUME) 2205fa9e4066Sahrens zc.zc_objset_type = DMU_OST_ZVOL; 2206fa9e4066Sahrens else 2207fa9e4066Sahrens zc.zc_objset_type = DMU_OST_ZFS; 2208fa9e4066Sahrens 2209fa9e4066Sahrens ret = ioctl(zfs_fd, ZFS_IOC_CREATE, &zc); 2210fa9e4066Sahrens 2211fa9e4066Sahrens if (ret == 0 && zhp->zfs_type == ZFS_TYPE_VOLUME) { 2212fa9e4066Sahrens ret = zvol_create_link(path); 2213fa9e4066Sahrens if (ret != 0) 2214fa9e4066Sahrens (void) ioctl(zfs_fd, ZFS_IOC_DESTROY, &zc); 2215fa9e4066Sahrens } 2216fa9e4066Sahrens 2217fa9e4066Sahrens if (ret != 0) { 2218fa9e4066Sahrens switch (errno) { 2219fa9e4066Sahrens case EPERM: 2220fa9e4066Sahrens /* 2221fa9e4066Sahrens * User doesn't have permission to create a snapshot 2222fa9e4066Sahrens */ 2223fa9e4066Sahrens zfs_error(dgettext(TEXT_DOMAIN, "cannot create '%s': " 2224fa9e4066Sahrens "permission denied"), path); 2225fa9e4066Sahrens break; 2226fa9e4066Sahrens 2227fa9e4066Sahrens case EDQUOT: 2228fa9e4066Sahrens case ENOSPC: 2229fa9e4066Sahrens /* 2230fa9e4066Sahrens * Out of space in parent. 2231fa9e4066Sahrens */ 2232fa9e4066Sahrens zfs_error(dgettext(TEXT_DOMAIN, "cannot create '%s': " 2233fa9e4066Sahrens "not enough space in '%s'"), path, parent); 2234fa9e4066Sahrens break; 2235fa9e4066Sahrens 2236fa9e4066Sahrens case EEXIST: 2237fa9e4066Sahrens /* 2238fa9e4066Sahrens * Snapshot already exists. 2239fa9e4066Sahrens */ 2240fa9e4066Sahrens zfs_error(dgettext(TEXT_DOMAIN, "cannot create '%s': " 2241fa9e4066Sahrens "snapshot exists"), path); 2242fa9e4066Sahrens break; 2243fa9e4066Sahrens 2244fa9e4066Sahrens case ENOENT: 2245fa9e4066Sahrens /* 2246fa9e4066Sahrens * Shouldn't happen because we verified the parent 2247fa9e4066Sahrens * above. But there may be a race condition where it 2248fa9e4066Sahrens * has since been removed. 2249fa9e4066Sahrens */ 2250fa9e4066Sahrens zfs_error(dgettext(TEXT_DOMAIN, "cannot open '%s': " 2251fa9e4066Sahrens "no such %s"), parent, 2252fa9e4066Sahrens zfs_type_to_name(zhp->zfs_type)); 2253fa9e4066Sahrens break; 2254fa9e4066Sahrens 2255fa9e4066Sahrens default: 2256fa9e4066Sahrens zfs_baderror(errno); 2257fa9e4066Sahrens } 2258fa9e4066Sahrens } 2259fa9e4066Sahrens 2260fa9e4066Sahrens free(parent); 2261fa9e4066Sahrens zfs_close(zhp); 2262fa9e4066Sahrens 2263fa9e4066Sahrens return (ret); 2264fa9e4066Sahrens } 2265fa9e4066Sahrens 2266fa9e4066Sahrens /* 2267fa9e4066Sahrens * Dumps a backup of tosnap, incremental from fromsnap if it isn't NULL. 2268fa9e4066Sahrens */ 2269fa9e4066Sahrens int 2270fa9e4066Sahrens zfs_backup(zfs_handle_t *zhp_to, zfs_handle_t *zhp_from) 2271fa9e4066Sahrens { 2272fa9e4066Sahrens zfs_cmd_t zc = { 0 }; 2273fa9e4066Sahrens int ret; 2274fa9e4066Sahrens 2275fa9e4066Sahrens /* do the ioctl() */ 2276fa9e4066Sahrens (void) strlcpy(zc.zc_name, zhp_to->zfs_name, sizeof (zc.zc_name)); 2277fa9e4066Sahrens if (zhp_from) { 2278fa9e4066Sahrens (void) strlcpy(zc.zc_prop_value, zhp_from->zfs_name, 2279fa9e4066Sahrens sizeof (zc.zc_name)); 2280fa9e4066Sahrens } else { 2281fa9e4066Sahrens zc.zc_prop_value[0] = '\0'; 2282fa9e4066Sahrens } 2283fa9e4066Sahrens zc.zc_cookie = STDOUT_FILENO; 2284fa9e4066Sahrens 2285fa9e4066Sahrens ret = ioctl(zfs_fd, ZFS_IOC_SENDBACKUP, &zc); 2286fa9e4066Sahrens if (ret != 0) { 2287fa9e4066Sahrens switch (errno) { 2288fa9e4066Sahrens case EPERM: 2289fa9e4066Sahrens /* 2290fa9e4066Sahrens * User doesn't have permission to do a backup 2291fa9e4066Sahrens */ 2292fa9e4066Sahrens zfs_error(dgettext(TEXT_DOMAIN, "cannot backup '%s': " 2293fa9e4066Sahrens "permission denied"), zhp_to->zfs_name); 2294fa9e4066Sahrens break; 2295fa9e4066Sahrens 2296fa9e4066Sahrens case EXDEV: 2297fa9e4066Sahrens zfs_error(dgettext(TEXT_DOMAIN, 2298fa9e4066Sahrens "cannot do incremental backup from %s:\n" 2299fa9e4066Sahrens "it is not an earlier snapshot from the " 2300fa9e4066Sahrens "same fs as %s"), 2301fa9e4066Sahrens zhp_from->zfs_name, zhp_to->zfs_name); 2302fa9e4066Sahrens break; 2303fa9e4066Sahrens 2304fa9e4066Sahrens case ENOENT: 2305fa9e4066Sahrens /* 2306fa9e4066Sahrens * Shouldn't happen because we verified the parent 2307fa9e4066Sahrens * above. But there may be a race condition where it 2308fa9e4066Sahrens * has since been removed. 2309fa9e4066Sahrens */ 2310fa9e4066Sahrens zfs_error(dgettext(TEXT_DOMAIN, "cannot open: " 2311fa9e4066Sahrens "no such snapshot")); 2312fa9e4066Sahrens break; 2313fa9e4066Sahrens 2314fa9e4066Sahrens case EDQUOT: 2315fa9e4066Sahrens case EFBIG: 2316fa9e4066Sahrens case EIO: 2317fa9e4066Sahrens case ENOLINK: 2318fa9e4066Sahrens case ENOSPC: 2319fa9e4066Sahrens case ENOSTR: 2320fa9e4066Sahrens case ENXIO: 2321fa9e4066Sahrens case EPIPE: 2322fa9e4066Sahrens case ERANGE: 2323fa9e4066Sahrens case EFAULT: 2324fa9e4066Sahrens case EROFS: 2325fa9e4066Sahrens zfs_error(dgettext(TEXT_DOMAIN, 2326fa9e4066Sahrens "cannot write backup stream: %s"), 2327fa9e4066Sahrens strerror(errno)); 2328fa9e4066Sahrens break; 2329fa9e4066Sahrens 2330fa9e4066Sahrens case EINTR: 2331fa9e4066Sahrens zfs_error(dgettext(TEXT_DOMAIN, 2332fa9e4066Sahrens "backup failed: signal recieved")); 2333fa9e4066Sahrens break; 2334fa9e4066Sahrens 2335fa9e4066Sahrens default: 2336fa9e4066Sahrens zfs_baderror(errno); 2337fa9e4066Sahrens } 2338fa9e4066Sahrens } 2339fa9e4066Sahrens 2340fa9e4066Sahrens return (ret); 2341fa9e4066Sahrens } 2342fa9e4066Sahrens 2343fa9e4066Sahrens /* 2344fa9e4066Sahrens * Restores a backup of tosnap from stdin. 2345fa9e4066Sahrens */ 2346fa9e4066Sahrens int 2347fa9e4066Sahrens zfs_restore(const char *tosnap, int isprefix, int verbose, int dryrun) 2348fa9e4066Sahrens { 2349fa9e4066Sahrens zfs_cmd_t zc = { 0 }; 2350fa9e4066Sahrens time_t begin_time; 23519b4f025eSahrens int ioctl_err, err, bytes, size; 2352fa9e4066Sahrens char *cp; 2353fa9e4066Sahrens dmu_replay_record_t drr; 2354fa9e4066Sahrens struct drr_begin *drrb = &zc.zc_begin_record; 2355fa9e4066Sahrens 2356fa9e4066Sahrens begin_time = time(NULL); 2357fa9e4066Sahrens 2358fa9e4066Sahrens /* trim off snapname, if any */ 2359fa9e4066Sahrens (void) strcpy(zc.zc_name, tosnap); 2360fa9e4066Sahrens cp = strchr(zc.zc_name, '@'); 2361fa9e4066Sahrens if (cp) 2362fa9e4066Sahrens *cp = '\0'; 2363fa9e4066Sahrens 2364fa9e4066Sahrens /* read in the BEGIN record */ 2365fa9e4066Sahrens cp = (char *)&drr; 2366fa9e4066Sahrens bytes = 0; 2367fa9e4066Sahrens do { 23689b4f025eSahrens size = read(STDIN_FILENO, cp, sizeof (drr) - bytes); 23699b4f025eSahrens cp += size; 23709b4f025eSahrens bytes += size; 23719b4f025eSahrens } while (size > 0); 2372fa9e4066Sahrens 23739b4f025eSahrens if (size < 0 || bytes != sizeof (drr)) { 2374fa9e4066Sahrens zfs_error(dgettext(TEXT_DOMAIN, 23759b4f025eSahrens "cannot restore: invalid backup stream " 2376fa9e4066Sahrens "(couldn't read first record)")); 2377fa9e4066Sahrens return (-1); 2378fa9e4066Sahrens } 2379fa9e4066Sahrens 2380fa9e4066Sahrens zc.zc_begin_record = drr.drr_u.drr_begin; 2381fa9e4066Sahrens 2382fa9e4066Sahrens if (drrb->drr_magic != DMU_BACKUP_MAGIC && 2383fa9e4066Sahrens drrb->drr_magic != BSWAP_64(DMU_BACKUP_MAGIC)) { 2384fa9e4066Sahrens zfs_error(dgettext(TEXT_DOMAIN, 23859b4f025eSahrens "cannot restore: invalid backup stream " 2386fa9e4066Sahrens "(invalid magic number)")); 2387fa9e4066Sahrens return (-1); 2388fa9e4066Sahrens } 2389fa9e4066Sahrens 2390fa9e4066Sahrens if (drrb->drr_version != DMU_BACKUP_VERSION && 2391fa9e4066Sahrens drrb->drr_version != BSWAP_64(DMU_BACKUP_VERSION)) { 2392fa9e4066Sahrens if (drrb->drr_magic == BSWAP_64(DMU_BACKUP_MAGIC)) 2393fa9e4066Sahrens drrb->drr_version = BSWAP_64(drrb->drr_version); 2394fa9e4066Sahrens zfs_error(dgettext(TEXT_DOMAIN, 23959b4f025eSahrens "cannot restore: only backup version 0x%llx is supported, " 2396fa9e4066Sahrens "stream is version %llx."), 2397fa9e4066Sahrens DMU_BACKUP_VERSION, drrb->drr_version); 2398fa9e4066Sahrens return (-1); 2399fa9e4066Sahrens } 2400fa9e4066Sahrens 2401fa9e4066Sahrens /* 2402fa9e4066Sahrens * Determine name of destination snapshot. 2403fa9e4066Sahrens */ 2404fa9e4066Sahrens (void) strcpy(drrb->drr_toname, tosnap); 2405fa9e4066Sahrens if (isprefix) { 2406fa9e4066Sahrens if (strchr(tosnap, '@') != NULL) { 2407fa9e4066Sahrens zfs_error(dgettext(TEXT_DOMAIN, 24089b4f025eSahrens "cannot restore: " 2409fa9e4066Sahrens "argument to -d must be a filesystem")); 2410fa9e4066Sahrens return (-1); 2411fa9e4066Sahrens } 2412fa9e4066Sahrens 2413fa9e4066Sahrens cp = strchr(drr.drr_u.drr_begin.drr_toname, '/'); 2414fa9e4066Sahrens if (cp == NULL) 2415fa9e4066Sahrens cp = drr.drr_u.drr_begin.drr_toname; 2416fa9e4066Sahrens else 2417fa9e4066Sahrens cp++; 2418fa9e4066Sahrens 2419fa9e4066Sahrens (void) strcat(drrb->drr_toname, "/"); 2420fa9e4066Sahrens (void) strcat(drrb->drr_toname, cp); 2421fa9e4066Sahrens } else if (strchr(tosnap, '@') == NULL) { 2422fa9e4066Sahrens /* 2423fa9e4066Sahrens * they specified just a filesystem; tack on the 2424fa9e4066Sahrens * snapname from the backup. 2425fa9e4066Sahrens */ 2426fa9e4066Sahrens cp = strchr(drr.drr_u.drr_begin.drr_toname, '@'); 2427fa9e4066Sahrens if (cp == NULL || strlen(tosnap) + strlen(cp) >= MAXNAMELEN) { 2428fa9e4066Sahrens zfs_error(dgettext(TEXT_DOMAIN, 24299b4f025eSahrens "cannot restore: invalid backup stream " 2430fa9e4066Sahrens "(invalid snapshot name)")); 2431fa9e4066Sahrens return (-1); 2432fa9e4066Sahrens } 2433fa9e4066Sahrens (void) strcat(drrb->drr_toname, cp); 2434fa9e4066Sahrens } 2435fa9e4066Sahrens 2436fa9e4066Sahrens if (drrb->drr_fromguid) { 2437fa9e4066Sahrens zfs_handle_t *h; 2438fa9e4066Sahrens /* incremental backup stream */ 2439fa9e4066Sahrens 2440fa9e4066Sahrens /* do the ioctl to the containing fs */ 2441fa9e4066Sahrens (void) strcpy(zc.zc_name, drrb->drr_toname); 2442fa9e4066Sahrens cp = strchr(zc.zc_name, '@'); 2443fa9e4066Sahrens *cp = '\0'; 2444fa9e4066Sahrens 2445fa9e4066Sahrens /* make sure destination fs exists */ 2446fa9e4066Sahrens h = zfs_open(zc.zc_name, ZFS_TYPE_FILESYSTEM | ZFS_TYPE_VOLUME); 2447fa9e4066Sahrens if (h == NULL) { 2448fa9e4066Sahrens zfs_error(dgettext(TEXT_DOMAIN, 24499b4f025eSahrens "cannot restore incrememtal backup: destination\n" 2450fa9e4066Sahrens "filesystem %s does not exist"), 2451fa9e4066Sahrens zc.zc_name); 2452fa9e4066Sahrens return (-1); 2453fa9e4066Sahrens } 24549b4f025eSahrens if (!dryrun) { 24559b4f025eSahrens /* unmount destination fs or remove device link. */ 24569b4f025eSahrens if (h->zfs_type == ZFS_TYPE_FILESYSTEM) { 24579b4f025eSahrens (void) zfs_unmount(h, NULL, 0); 24589b4f025eSahrens } else { 24599b4f025eSahrens (void) zvol_remove_link(h->zfs_name); 24609b4f025eSahrens } 24619b4f025eSahrens } 2462fa9e4066Sahrens zfs_close(h); 2463fa9e4066Sahrens } else { 2464fa9e4066Sahrens /* full backup stream */ 2465fa9e4066Sahrens 2466fa9e4066Sahrens (void) strcpy(zc.zc_name, drrb->drr_toname); 24679b4f025eSahrens 24689b4f025eSahrens /* make sure they aren't trying to restore into the root */ 24699b4f025eSahrens if (strchr(zc.zc_name, '/') == NULL) { 2470fa9e4066Sahrens cp = strchr(zc.zc_name, '@'); 2471fa9e4066Sahrens if (cp) 2472fa9e4066Sahrens *cp = '\0'; 2473fa9e4066Sahrens zfs_error(dgettext(TEXT_DOMAIN, 24749b4f025eSahrens "cannot restore: destination fs %s already exists"), 2475fa9e4066Sahrens zc.zc_name); 2476fa9e4066Sahrens return (-1); 2477fa9e4066Sahrens } 2478fa9e4066Sahrens 2479fa9e4066Sahrens if (isprefix) { 2480fa9e4066Sahrens zfs_handle_t *h; 2481fa9e4066Sahrens 24829b4f025eSahrens /* make sure prefix exists */ 2483fa9e4066Sahrens h = zfs_open(tosnap, ZFS_TYPE_FILESYSTEM | 2484fa9e4066Sahrens ZFS_TYPE_VOLUME); 2485fa9e4066Sahrens if (h == NULL) { 2486fa9e4066Sahrens zfs_error(dgettext(TEXT_DOMAIN, 24879b4f025eSahrens "cannot restore: " 2488fa9e4066Sahrens "filesystem %s does not exist"), 2489fa9e4066Sahrens tosnap); 2490fa9e4066Sahrens return (-1); 2491fa9e4066Sahrens } 2492fa9e4066Sahrens 2493fa9e4066Sahrens /* create any necessary ancestors up to prefix */ 24949b4f025eSahrens zc.zc_objset_type = DMU_OST_ZFS; 24959b4f025eSahrens /* 24969b4f025eSahrens * zc.zc_name is now the full name of the snap 24979b4f025eSahrens * we're restoring into 24989b4f025eSahrens */ 2499fa9e4066Sahrens cp = zc.zc_name + strlen(tosnap) + 1; 2500fa9e4066Sahrens while (cp = strchr(cp, '/')) { 2501fa9e4066Sahrens *cp = '\0'; 2502fa9e4066Sahrens err = ioctl(zfs_fd, ZFS_IOC_CREATE, &zc); 25039b4f025eSahrens if (err && errno != ENOENT && errno != EEXIST) { 2504fa9e4066Sahrens zfs_error(dgettext(TEXT_DOMAIN, 25059b4f025eSahrens "cannot restore: " 2506fa9e4066Sahrens "couldn't create ancestor %s"), 2507fa9e4066Sahrens zc.zc_name); 2508fa9e4066Sahrens return (-1); 2509fa9e4066Sahrens } 25109b4f025eSahrens *cp = '/'; 25119b4f025eSahrens cp++; 2512fa9e4066Sahrens } 2513fa9e4066Sahrens } 25149b4f025eSahrens 25159b4f025eSahrens /* Make sure destination fs does not exist */ 25169b4f025eSahrens cp = strchr(zc.zc_name, '@'); 25179b4f025eSahrens *cp = '\0'; 25189b4f025eSahrens if (ioctl(zfs_fd, ZFS_IOC_OBJSET_STATS, &zc) == 0) { 25199b4f025eSahrens zfs_error(dgettext(TEXT_DOMAIN, 25209b4f025eSahrens "cannot restore full backup: " 25219b4f025eSahrens "destination filesystem %s already exists"), 25229b4f025eSahrens zc.zc_name); 25239b4f025eSahrens return (-1); 25249b4f025eSahrens } 25259b4f025eSahrens 25269b4f025eSahrens /* Do the recvbackup ioctl to the fs's parent. */ 25279b4f025eSahrens cp = strrchr(zc.zc_name, '/'); 25289b4f025eSahrens *cp = '\0'; 2529fa9e4066Sahrens } 2530fa9e4066Sahrens 2531fa9e4066Sahrens (void) strcpy(zc.zc_prop_value, tosnap); 2532fa9e4066Sahrens zc.zc_cookie = STDIN_FILENO; 2533fa9e4066Sahrens zc.zc_intsz = isprefix; 2534fa9e4066Sahrens if (verbose) { 2535fa9e4066Sahrens (void) printf("%s %s backup of %s into %s\n", 2536fa9e4066Sahrens dryrun ? "would restore" : "restoring", 2537fa9e4066Sahrens drrb->drr_fromguid ? "incremental" : "full", 2538fa9e4066Sahrens drr.drr_u.drr_begin.drr_toname, 2539fa9e4066Sahrens zc.zc_begin_record.drr_toname); 2540fa9e4066Sahrens (void) fflush(stdout); 2541fa9e4066Sahrens } 2542fa9e4066Sahrens if (dryrun) 2543fa9e4066Sahrens return (0); 25449b4f025eSahrens err = ioctl_err = ioctl(zfs_fd, ZFS_IOC_RECVBACKUP, &zc); 25459b4f025eSahrens if (ioctl_err != 0) { 2546fa9e4066Sahrens switch (errno) { 2547fa9e4066Sahrens case ENODEV: 2548fa9e4066Sahrens zfs_error(dgettext(TEXT_DOMAIN, 25499b4f025eSahrens "cannot restore: " 25509b4f025eSahrens "most recent snapshot does not " 2551fa9e4066Sahrens "match incremental backup source")); 2552fa9e4066Sahrens break; 2553fa9e4066Sahrens case ETXTBSY: 2554fa9e4066Sahrens zfs_error(dgettext(TEXT_DOMAIN, 25559b4f025eSahrens "cannot restore: " 25569b4f025eSahrens "destination has been modified since " 25579b4f025eSahrens "most recent snapshot --\n" 25589b4f025eSahrens "use 'zfs rollback' to discard changes")); 2559fa9e4066Sahrens break; 2560fa9e4066Sahrens case EEXIST: 2561fa9e4066Sahrens if (drrb->drr_fromguid == 0) { 2562fa9e4066Sahrens /* it's the containing fs that exists */ 2563fa9e4066Sahrens cp = strchr(drrb->drr_toname, '@'); 2564fa9e4066Sahrens *cp = '\0'; 2565fa9e4066Sahrens } 2566fa9e4066Sahrens zfs_error(dgettext(TEXT_DOMAIN, 25679b4f025eSahrens "cannot restore to %s: destination already exists"), 2568fa9e4066Sahrens drrb->drr_toname); 2569fa9e4066Sahrens break; 2570fa9e4066Sahrens case ENOENT: 2571fa9e4066Sahrens zfs_error(dgettext(TEXT_DOMAIN, 25729b4f025eSahrens "cannot restore: destination does not exist")); 2573fa9e4066Sahrens break; 2574fa9e4066Sahrens case EBUSY: 2575fa9e4066Sahrens zfs_error(dgettext(TEXT_DOMAIN, 25769b4f025eSahrens "cannot restore: destination is in use")); 2577fa9e4066Sahrens break; 2578fa9e4066Sahrens case ENOSPC: 2579fa9e4066Sahrens zfs_error(dgettext(TEXT_DOMAIN, 25809b4f025eSahrens "cannot restore: out of space")); 2581fa9e4066Sahrens break; 2582fa9e4066Sahrens case EDQUOT: 2583fa9e4066Sahrens zfs_error(dgettext(TEXT_DOMAIN, 25849b4f025eSahrens "cannot restore: quota exceeded")); 2585fa9e4066Sahrens break; 2586fa9e4066Sahrens case EINTR: 2587fa9e4066Sahrens zfs_error(dgettext(TEXT_DOMAIN, 25889b4f025eSahrens "restore failed: signal recieved")); 2589fa9e4066Sahrens break; 2590fa9e4066Sahrens case EINVAL: 2591fa9e4066Sahrens zfs_error(dgettext(TEXT_DOMAIN, 25929b4f025eSahrens "cannot restore: invalid backup stream")); 25939b4f025eSahrens break; 25949b4f025eSahrens case EPERM: 25959b4f025eSahrens zfs_error(dgettext(TEXT_DOMAIN, 25969b4f025eSahrens "cannot restore: permission denied")); 2597fa9e4066Sahrens break; 2598fa9e4066Sahrens default: 2599fa9e4066Sahrens zfs_baderror(errno); 2600fa9e4066Sahrens } 2601fa9e4066Sahrens } 2602fa9e4066Sahrens 2603fa9e4066Sahrens /* 26049b4f025eSahrens * Mount or recreate the /dev links for the target filesystem 26059b4f025eSahrens * (if created, or if we tore them down to do an incremental 26069b4f025eSahrens * restore), and the /dev links for the new snapshot (if 26079b4f025eSahrens * created). 2608fa9e4066Sahrens */ 2609fa9e4066Sahrens cp = strchr(drrb->drr_toname, '@'); 26109b4f025eSahrens if (cp && (ioctl_err == 0 || drrb->drr_fromguid)) { 2611fa9e4066Sahrens zfs_handle_t *h; 2612fa9e4066Sahrens 2613fa9e4066Sahrens *cp = '\0'; 2614fa9e4066Sahrens h = zfs_open(drrb->drr_toname, 2615fa9e4066Sahrens ZFS_TYPE_FILESYSTEM | ZFS_TYPE_VOLUME); 26169b4f025eSahrens *cp = '@'; 2617fa9e4066Sahrens if (h) { 26189b4f025eSahrens if (h->zfs_type == ZFS_TYPE_FILESYSTEM) { 2619fa9e4066Sahrens err = zfs_mount(h, NULL, 0); 26209b4f025eSahrens } else { 2621fa9e4066Sahrens err = zvol_create_link(h->zfs_name); 26229b4f025eSahrens if (err == 0 && ioctl_err == 0) { 26239b4f025eSahrens err = 26249b4f025eSahrens zvol_create_link(drrb->drr_toname); 26259b4f025eSahrens } 26269b4f025eSahrens } 2627fa9e4066Sahrens zfs_close(h); 2628fa9e4066Sahrens } 2629fa9e4066Sahrens } 2630fa9e4066Sahrens 26319b4f025eSahrens if (err || ioctl_err) 26329b4f025eSahrens return (-1); 2633fa9e4066Sahrens 2634fa9e4066Sahrens if (verbose) { 2635fa9e4066Sahrens char buf1[64]; 2636fa9e4066Sahrens char buf2[64]; 2637fa9e4066Sahrens uint64_t bytes = zc.zc_cookie; 2638fa9e4066Sahrens time_t delta = time(NULL) - begin_time; 2639fa9e4066Sahrens if (delta == 0) 2640fa9e4066Sahrens delta = 1; 2641fa9e4066Sahrens zfs_nicenum(bytes, buf1, sizeof (buf1)); 2642fa9e4066Sahrens zfs_nicenum(bytes/delta, buf2, sizeof (buf1)); 2643fa9e4066Sahrens 2644fa9e4066Sahrens (void) printf("restored %sb backup in %lu seconds (%sb/sec)\n", 2645fa9e4066Sahrens buf1, delta, buf2); 2646fa9e4066Sahrens } 2647fa9e4066Sahrens return (0); 2648fa9e4066Sahrens } 2649fa9e4066Sahrens 2650fa9e4066Sahrens /* 2651b12a1c38Slling * Destroy any more recent snapshots. We invoke this callback on any dependents 2652b12a1c38Slling * of the snapshot first. If the 'cb_dependent' member is non-zero, then this 2653b12a1c38Slling * is a dependent and we should just destroy it without checking the transaction 2654b12a1c38Slling * group. 2655fa9e4066Sahrens */ 2656b12a1c38Slling typedef struct rollback_data { 2657b12a1c38Slling const char *cb_target; /* the snapshot */ 2658b12a1c38Slling uint64_t cb_create; /* creation time reference */ 2659b12a1c38Slling prop_changelist_t *cb_clp; /* changelist pointer */ 2660b12a1c38Slling int cb_error; 2661b12a1c38Slling int cb_dependent; 2662b12a1c38Slling } rollback_data_t; 2663b12a1c38Slling 2664b12a1c38Slling static int 2665b12a1c38Slling rollback_destroy(zfs_handle_t *zhp, void *data) 2666b12a1c38Slling { 2667b12a1c38Slling rollback_data_t *cbp = data; 2668b12a1c38Slling 2669b12a1c38Slling if (!cbp->cb_dependent) { 2670b12a1c38Slling if (strcmp(zhp->zfs_name, cbp->cb_target) != 0 && 2671b12a1c38Slling zfs_get_type(zhp) == ZFS_TYPE_SNAPSHOT && 2672b12a1c38Slling zfs_prop_get_int(zhp, ZFS_PROP_CREATETXG) > 2673b12a1c38Slling cbp->cb_create) { 2674b12a1c38Slling 2675b12a1c38Slling cbp->cb_dependent = TRUE; 2676b12a1c38Slling (void) zfs_iter_dependents(zhp, rollback_destroy, cbp); 2677b12a1c38Slling cbp->cb_dependent = FALSE; 2678b12a1c38Slling 2679b12a1c38Slling if (zfs_destroy(zhp) != 0) 2680b12a1c38Slling cbp->cb_error = 1; 2681b12a1c38Slling else 2682b12a1c38Slling changelist_remove(zhp, cbp->cb_clp); 2683b12a1c38Slling } 2684b12a1c38Slling } else { 2685b12a1c38Slling if (zfs_destroy(zhp) != 0) 2686b12a1c38Slling cbp->cb_error = 1; 2687b12a1c38Slling else 2688b12a1c38Slling changelist_remove(zhp, cbp->cb_clp); 2689b12a1c38Slling } 2690b12a1c38Slling 2691b12a1c38Slling zfs_close(zhp); 2692b12a1c38Slling return (0); 2693b12a1c38Slling } 2694b12a1c38Slling 2695b12a1c38Slling /* 2696b12a1c38Slling * Rollback the dataset to its latest snapshot. 2697b12a1c38Slling */ 2698b12a1c38Slling static int 2699b12a1c38Slling do_rollback(zfs_handle_t *zhp) 2700fa9e4066Sahrens { 2701fa9e4066Sahrens int ret; 2702fa9e4066Sahrens zfs_cmd_t zc = { 0 }; 2703fa9e4066Sahrens 2704fa9e4066Sahrens assert(zhp->zfs_type == ZFS_TYPE_FILESYSTEM || 2705fa9e4066Sahrens zhp->zfs_type == ZFS_TYPE_VOLUME); 2706fa9e4066Sahrens 2707fa9e4066Sahrens if (zhp->zfs_type == ZFS_TYPE_VOLUME && 2708fa9e4066Sahrens zvol_remove_link(zhp->zfs_name) != 0) 2709fa9e4066Sahrens return (-1); 2710fa9e4066Sahrens 2711fa9e4066Sahrens (void) strlcpy(zc.zc_name, zhp->zfs_name, sizeof (zc.zc_name)); 2712fa9e4066Sahrens 2713fa9e4066Sahrens if (zhp->zfs_volblocksize != 0) 2714fa9e4066Sahrens zc.zc_objset_type = DMU_OST_ZVOL; 2715fa9e4066Sahrens else 2716fa9e4066Sahrens zc.zc_objset_type = DMU_OST_ZFS; 2717fa9e4066Sahrens 2718fa9e4066Sahrens /* 2719fa9e4066Sahrens * We rely on the consumer to verify that there are no newer snapshots 2720fa9e4066Sahrens * for the given dataset. Given these constraints, we can simply pass 2721fa9e4066Sahrens * the name on to the ioctl() call. There is still an unlikely race 2722fa9e4066Sahrens * condition where the user has taken a snapshot since we verified that 2723fa9e4066Sahrens * this was the most recent. 2724fa9e4066Sahrens */ 2725fa9e4066Sahrens if ((ret = ioctl(zfs_fd, ZFS_IOC_ROLLBACK, &zc)) != 0) { 2726fa9e4066Sahrens switch (errno) { 2727fa9e4066Sahrens case EPERM: 2728fa9e4066Sahrens /* 2729fa9e4066Sahrens * The user doesn't have permission to rollback the 2730fa9e4066Sahrens * given dataset. 2731fa9e4066Sahrens */ 2732fa9e4066Sahrens zfs_error(dgettext(TEXT_DOMAIN, "cannot rollback '%s': " 2733fa9e4066Sahrens "permission denied"), zhp->zfs_name); 2734fa9e4066Sahrens break; 2735fa9e4066Sahrens 2736fa9e4066Sahrens case EDQUOT: 2737fa9e4066Sahrens case ENOSPC: 2738fa9e4066Sahrens /* 2739fa9e4066Sahrens * The parent dataset doesn't have enough space to 2740fa9e4066Sahrens * rollback to the last snapshot. 2741fa9e4066Sahrens */ 2742fa9e4066Sahrens { 2743fa9e4066Sahrens char parent[ZFS_MAXNAMELEN]; 2744fa9e4066Sahrens (void) parent_name(zhp->zfs_name, parent, 2745fa9e4066Sahrens sizeof (parent)); 2746fa9e4066Sahrens zfs_error(dgettext(TEXT_DOMAIN, "cannot " 2747fa9e4066Sahrens "rollback '%s': out of space"), parent); 2748fa9e4066Sahrens } 2749fa9e4066Sahrens break; 2750fa9e4066Sahrens 2751fa9e4066Sahrens case ENOENT: 2752fa9e4066Sahrens /* 2753fa9e4066Sahrens * The dataset doesn't exist. This shouldn't happen 2754fa9e4066Sahrens * except in race conditions. 2755fa9e4066Sahrens */ 2756fa9e4066Sahrens zfs_error(dgettext(TEXT_DOMAIN, "cannot rollback '%s': " 2757fa9e4066Sahrens "no such %s"), zhp->zfs_name, 2758fa9e4066Sahrens zfs_type_to_name(zhp->zfs_type)); 2759fa9e4066Sahrens break; 2760fa9e4066Sahrens 2761fa9e4066Sahrens case EBUSY: 2762fa9e4066Sahrens /* 2763fa9e4066Sahrens * The filesystem is busy. This should have been caught 2764fa9e4066Sahrens * by the caller before getting here, but there may be 2765fa9e4066Sahrens * an unexpected problem. 2766fa9e4066Sahrens */ 2767fa9e4066Sahrens zfs_error(dgettext(TEXT_DOMAIN, "cannot rollback '%s': " 2768fa9e4066Sahrens "%s is busy"), zhp->zfs_name, 2769fa9e4066Sahrens zfs_type_to_name(zhp->zfs_type)); 2770fa9e4066Sahrens break; 2771fa9e4066Sahrens 2772fa9e4066Sahrens default: 2773fa9e4066Sahrens zfs_baderror(errno); 2774fa9e4066Sahrens } 2775fa9e4066Sahrens } else if (zhp->zfs_type == ZFS_TYPE_VOLUME) { 2776fa9e4066Sahrens ret = zvol_create_link(zhp->zfs_name); 2777fa9e4066Sahrens } 2778fa9e4066Sahrens 2779fa9e4066Sahrens return (ret); 2780fa9e4066Sahrens } 2781fa9e4066Sahrens 2782b12a1c38Slling /* 2783b12a1c38Slling * Given a dataset, rollback to a specific snapshot, discarding any 2784b12a1c38Slling * data changes since then and making it the active dataset. 2785b12a1c38Slling * 2786b12a1c38Slling * Any snapshots more recent than the target are destroyed, along with 2787b12a1c38Slling * their dependents. 2788b12a1c38Slling */ 2789b12a1c38Slling int 2790b12a1c38Slling zfs_rollback(zfs_handle_t *zhp, zfs_handle_t *snap, int flag) 2791b12a1c38Slling { 2792b12a1c38Slling int ret; 2793b12a1c38Slling rollback_data_t cb = { 0 }; 2794b12a1c38Slling prop_changelist_t *clp; 2795b12a1c38Slling 2796b12a1c38Slling /* 2797b12a1c38Slling * Unmount all dependendents of the dataset and the dataset itself. 2798b12a1c38Slling * The list we need to gather is the same as for doing rename 2799b12a1c38Slling */ 2800b12a1c38Slling clp = changelist_gather(zhp, ZFS_PROP_NAME, flag ? MS_FORCE: 0); 2801b12a1c38Slling if (clp == NULL) 2802b12a1c38Slling return (-1); 2803b12a1c38Slling 2804b12a1c38Slling if ((ret = changelist_prefix(clp)) != 0) 2805b12a1c38Slling goto out; 2806b12a1c38Slling 2807b12a1c38Slling /* 2808b12a1c38Slling * Destroy all recent snapshots and its dependends. 2809b12a1c38Slling */ 2810b12a1c38Slling cb.cb_target = snap->zfs_name; 2811b12a1c38Slling cb.cb_create = zfs_prop_get_int(snap, ZFS_PROP_CREATETXG); 2812b12a1c38Slling cb.cb_clp = clp; 2813b12a1c38Slling (void) zfs_iter_children(zhp, rollback_destroy, &cb); 2814b12a1c38Slling 2815b12a1c38Slling if ((ret = cb.cb_error) != 0) { 2816b12a1c38Slling (void) changelist_postfix(clp); 2817b12a1c38Slling goto out; 2818b12a1c38Slling } 2819b12a1c38Slling 2820b12a1c38Slling /* 2821b12a1c38Slling * Now that we have verified that the snapshot is the latest, 2822b12a1c38Slling * rollback to the given snapshot. 2823b12a1c38Slling */ 2824b12a1c38Slling ret = do_rollback(zhp); 2825b12a1c38Slling 2826b12a1c38Slling if (ret != 0) { 2827b12a1c38Slling (void) changelist_postfix(clp); 2828b12a1c38Slling goto out; 2829b12a1c38Slling } 2830b12a1c38Slling 2831b12a1c38Slling /* 2832b12a1c38Slling * We only want to re-mount the filesystem if it was mounted in the 2833b12a1c38Slling * first place. 2834b12a1c38Slling */ 2835b12a1c38Slling ret = changelist_postfix(clp); 2836b12a1c38Slling 2837b12a1c38Slling out: 2838b12a1c38Slling changelist_free(clp); 2839b12a1c38Slling return (ret); 2840b12a1c38Slling } 2841b12a1c38Slling 2842fa9e4066Sahrens /* 2843fa9e4066Sahrens * Iterate over all dependents for a given dataset. This includes both 2844fa9e4066Sahrens * hierarchical dependents (children) and data dependents (snapshots and 2845fa9e4066Sahrens * clones). The bulk of the processing occurs in get_dependents() in 2846fa9e4066Sahrens * libzfs_graph.c. 2847fa9e4066Sahrens */ 2848fa9e4066Sahrens int 2849fa9e4066Sahrens zfs_iter_dependents(zfs_handle_t *zhp, zfs_iter_f func, void *data) 2850fa9e4066Sahrens { 2851fa9e4066Sahrens char **dependents; 2852fa9e4066Sahrens size_t count; 2853fa9e4066Sahrens int i; 2854fa9e4066Sahrens zfs_handle_t *child; 2855fa9e4066Sahrens int ret = 0; 2856fa9e4066Sahrens 2857fa9e4066Sahrens dependents = get_dependents(zhp->zfs_name, &count); 2858fa9e4066Sahrens for (i = 0; i < count; i++) { 2859fa9e4066Sahrens if ((child = make_dataset_handle(dependents[i])) == NULL) 2860fa9e4066Sahrens continue; 2861fa9e4066Sahrens 2862fa9e4066Sahrens if ((ret = func(child, data)) != 0) 2863fa9e4066Sahrens break; 2864fa9e4066Sahrens } 2865fa9e4066Sahrens 2866fa9e4066Sahrens for (i = 0; i < count; i++) 2867fa9e4066Sahrens free(dependents[i]); 2868fa9e4066Sahrens free(dependents); 2869fa9e4066Sahrens 2870fa9e4066Sahrens return (ret); 2871fa9e4066Sahrens } 2872fa9e4066Sahrens 2873fa9e4066Sahrens /* 2874fa9e4066Sahrens * Renames the given dataset. 2875fa9e4066Sahrens */ 2876fa9e4066Sahrens int 2877fa9e4066Sahrens zfs_rename(zfs_handle_t *zhp, const char *target) 2878fa9e4066Sahrens { 2879fa9e4066Sahrens int ret; 2880fa9e4066Sahrens zfs_cmd_t zc = { 0 }; 2881fa9e4066Sahrens char reason[64]; 2882fa9e4066Sahrens char *delim; 2883fa9e4066Sahrens prop_changelist_t *cl; 2884fa9e4066Sahrens char parent[ZFS_MAXNAMELEN]; 2885fa9e4066Sahrens 2886fa9e4066Sahrens (void) strlcpy(zc.zc_name, zhp->zfs_name, sizeof (zc.zc_name)); 2887fa9e4066Sahrens (void) strlcpy(zc.zc_prop_value, target, sizeof (zc.zc_prop_value)); 2888fa9e4066Sahrens 2889fa9e4066Sahrens /* if we have the same exact name, just return success */ 2890fa9e4066Sahrens if (strcmp(zhp->zfs_name, target) == 0) 2891fa9e4066Sahrens return (0); 2892fa9e4066Sahrens 2893fa9e4066Sahrens /* 2894fa9e4066Sahrens * Make sure the target name is valid 2895fa9e4066Sahrens */ 2896fa9e4066Sahrens if (!zfs_validate_name(target, zhp->zfs_type, reason, 2897fa9e4066Sahrens sizeof (reason))) { 2898fa9e4066Sahrens zfs_error(dgettext(TEXT_DOMAIN, 2899fa9e4066Sahrens "cannot create '%s': %s in %s name"), target, reason, 2900fa9e4066Sahrens zfs_type_to_name(zhp->zfs_type)); 2901fa9e4066Sahrens return (-1); 2902fa9e4066Sahrens } 2903fa9e4066Sahrens 2904fa9e4066Sahrens if (zhp->zfs_type == ZFS_TYPE_SNAPSHOT) { 2905fa9e4066Sahrens if ((delim = strchr(target, '@')) == NULL) { 2906fa9e4066Sahrens zfs_error(dgettext(TEXT_DOMAIN, 2907fa9e4066Sahrens "cannot rename to '%s': not a snapshot"), target); 2908fa9e4066Sahrens return (-1); 2909fa9e4066Sahrens } 2910fa9e4066Sahrens 2911fa9e4066Sahrens /* 2912fa9e4066Sahrens * Make sure we're renaming within the same dataset. 2913fa9e4066Sahrens */ 2914fa9e4066Sahrens if (strncmp(zhp->zfs_name, target, delim - target) != 0 || 2915fa9e4066Sahrens zhp->zfs_name[delim - target] != '@') { 2916fa9e4066Sahrens zfs_error(dgettext(TEXT_DOMAIN, 2917fa9e4066Sahrens "cannot rename to '%s': snapshots must be part " 2918fa9e4066Sahrens "of same dataset"), target); 2919fa9e4066Sahrens return (-1); 2920fa9e4066Sahrens } 2921fa9e4066Sahrens 2922fa9e4066Sahrens (void) strncpy(parent, target, delim - target); 2923fa9e4066Sahrens parent[delim - target] = '\0'; 2924fa9e4066Sahrens } else { 2925fa9e4066Sahrens /* validate parents */ 2926fa9e4066Sahrens if (check_parents(target, zhp->zfs_type) != 0) 2927fa9e4066Sahrens return (-1); 2928fa9e4066Sahrens 2929fa9e4066Sahrens (void) parent_name(target, parent, sizeof (parent)); 2930fa9e4066Sahrens 2931fa9e4066Sahrens /* make sure we're in the same pool */ 2932fa9e4066Sahrens verify((delim = strchr(target, '/')) != NULL); 2933fa9e4066Sahrens if (strncmp(zhp->zfs_name, target, delim - target) != 0 || 2934fa9e4066Sahrens zhp->zfs_name[delim - target] != '/') { 2935fa9e4066Sahrens zfs_error(dgettext(TEXT_DOMAIN, 2936fa9e4066Sahrens "cannot rename to '%s': " 2937fa9e4066Sahrens "datasets must be within same pool"), target); 2938fa9e4066Sahrens return (-1); 2939fa9e4066Sahrens } 2940fa9e4066Sahrens } 2941fa9e4066Sahrens 2942fa9e4066Sahrens if (getzoneid() == GLOBAL_ZONEID && 2943fa9e4066Sahrens zfs_prop_get_int(zhp, ZFS_PROP_ZONED)) { 2944fa9e4066Sahrens zfs_error(dgettext(TEXT_DOMAIN, "cannot rename %s, " 2945fa9e4066Sahrens "dataset is used in a non-global zone"), zhp->zfs_name); 2946fa9e4066Sahrens return (-1); 2947fa9e4066Sahrens } 2948fa9e4066Sahrens 2949fa9e4066Sahrens if ((cl = changelist_gather(zhp, ZFS_PROP_NAME, 0)) == NULL) 2950fa9e4066Sahrens return (1); 2951fa9e4066Sahrens 2952fa9e4066Sahrens if (changelist_haszonedchild(cl)) { 2953fa9e4066Sahrens zfs_error(dgettext(TEXT_DOMAIN, 2954fa9e4066Sahrens "cannot rename '%s': child dataset with inherited " 2955fa9e4066Sahrens "mountpoint is used in a non-global zone"), zhp->zfs_name); 2956fa9e4066Sahrens ret = -1; 2957fa9e4066Sahrens goto error; 2958fa9e4066Sahrens } 2959fa9e4066Sahrens 2960fa9e4066Sahrens if ((ret = changelist_prefix(cl)) != 0) 2961fa9e4066Sahrens goto error; 2962fa9e4066Sahrens 2963fa9e4066Sahrens if (zhp->zfs_volblocksize != 0) 2964fa9e4066Sahrens zc.zc_objset_type = DMU_OST_ZVOL; 2965fa9e4066Sahrens else 2966fa9e4066Sahrens zc.zc_objset_type = DMU_OST_ZFS; 2967fa9e4066Sahrens 2968fa9e4066Sahrens if ((ret = ioctl(zfs_fd, ZFS_IOC_RENAME, &zc)) != 0) { 2969fa9e4066Sahrens switch (errno) { 2970fa9e4066Sahrens case EPERM: 2971fa9e4066Sahrens /* 2972fa9e4066Sahrens * The user doesn't have permission to rename the 2973fa9e4066Sahrens * given dataset. 2974fa9e4066Sahrens */ 2975fa9e4066Sahrens zfs_error(dgettext(TEXT_DOMAIN, "cannot rename '%s': " 2976fa9e4066Sahrens "permission denied"), zhp->zfs_name); 2977fa9e4066Sahrens break; 2978fa9e4066Sahrens 2979fa9e4066Sahrens case EDQUOT: 2980fa9e4066Sahrens case ENOSPC: 2981fa9e4066Sahrens /* 2982fa9e4066Sahrens * Not enough space in the parent dataset. 2983fa9e4066Sahrens */ 2984fa9e4066Sahrens zfs_error(dgettext(TEXT_DOMAIN, "cannot " 2985fa9e4066Sahrens "rename '%s': not enough space in '%s'"), 2986fa9e4066Sahrens zhp->zfs_name, parent); 2987fa9e4066Sahrens break; 2988fa9e4066Sahrens 2989fa9e4066Sahrens case ENOENT: 2990fa9e4066Sahrens /* 2991fa9e4066Sahrens * The destination doesn't exist. 2992fa9e4066Sahrens */ 2993fa9e4066Sahrens zfs_error(dgettext(TEXT_DOMAIN, "cannot rename '%s' " 2994fa9e4066Sahrens "to '%s': destination doesn't exist"), 2995fa9e4066Sahrens zhp->zfs_name, target); 2996fa9e4066Sahrens break; 2997fa9e4066Sahrens 2998fa9e4066Sahrens case EEXIST: 2999fa9e4066Sahrens /* 3000fa9e4066Sahrens * The destination already exists. 3001fa9e4066Sahrens */ 3002fa9e4066Sahrens zfs_error(dgettext(TEXT_DOMAIN, "cannot rename '%s' " 3003fa9e4066Sahrens "to '%s': destination already exists"), 3004fa9e4066Sahrens zhp->zfs_name, target); 3005fa9e4066Sahrens break; 3006fa9e4066Sahrens 3007fa9e4066Sahrens case EBUSY: 3008fa9e4066Sahrens /* 3009fa9e4066Sahrens * The filesystem is busy. This should have been caught 3010fa9e4066Sahrens * by the caller before getting here, but there may be 3011fa9e4066Sahrens * an unexpected problem. 3012fa9e4066Sahrens */ 3013fa9e4066Sahrens zfs_error(dgettext(TEXT_DOMAIN, "cannot rename '%s': " 3014fa9e4066Sahrens "%s is busy"), zhp->zfs_name, 3015fa9e4066Sahrens zfs_type_to_name(zhp->zfs_type)); 3016fa9e4066Sahrens break; 3017fa9e4066Sahrens 3018fa9e4066Sahrens default: 3019fa9e4066Sahrens zfs_baderror(errno); 3020fa9e4066Sahrens } 3021fa9e4066Sahrens 3022fa9e4066Sahrens /* 3023fa9e4066Sahrens * On failure, we still want to remount any filesystems that 3024fa9e4066Sahrens * were previously mounted, so we don't alter the system state. 3025fa9e4066Sahrens */ 3026fa9e4066Sahrens (void) changelist_postfix(cl); 3027fa9e4066Sahrens } else { 3028fa9e4066Sahrens changelist_rename(cl, zfs_get_name(zhp), target); 3029fa9e4066Sahrens 3030fa9e4066Sahrens ret = changelist_postfix(cl); 3031fa9e4066Sahrens } 3032fa9e4066Sahrens 3033fa9e4066Sahrens error: 3034fa9e4066Sahrens changelist_free(cl); 3035fa9e4066Sahrens return (ret); 3036fa9e4066Sahrens } 3037fa9e4066Sahrens 3038fa9e4066Sahrens /* 3039fa9e4066Sahrens * Given a zvol dataset, issue the ioctl to create the appropriate minor node, 3040fa9e4066Sahrens * poke devfsadm to create the /dev link, and then wait for the link to appear. 3041fa9e4066Sahrens */ 3042fa9e4066Sahrens int 3043fa9e4066Sahrens zvol_create_link(const char *dataset) 3044fa9e4066Sahrens { 3045fa9e4066Sahrens zfs_cmd_t zc = { 0 }; 3046fa9e4066Sahrens di_devlink_handle_t hdl; 3047fa9e4066Sahrens 3048fa9e4066Sahrens (void) strlcpy(zc.zc_name, dataset, sizeof (zc.zc_name)); 3049fa9e4066Sahrens 3050fa9e4066Sahrens /* 3051fa9e4066Sahrens * Issue the appropriate ioctl. 3052fa9e4066Sahrens */ 3053fa9e4066Sahrens if (ioctl(zfs_fd, ZFS_IOC_CREATE_MINOR, &zc) != 0) { 3054fa9e4066Sahrens switch (errno) { 3055fa9e4066Sahrens case EPERM: 3056fa9e4066Sahrens zfs_error(dgettext(TEXT_DOMAIN, "cannot create " 3057fa9e4066Sahrens "device links for '%s': permission denied"), 3058fa9e4066Sahrens dataset); 3059fa9e4066Sahrens break; 3060fa9e4066Sahrens 3061fa9e4066Sahrens case EEXIST: 3062fa9e4066Sahrens /* 3063fa9e4066Sahrens * Silently ignore the case where the link already 3064fa9e4066Sahrens * exists. This allows 'zfs volinit' to be run multiple 3065fa9e4066Sahrens * times without errors. 3066fa9e4066Sahrens */ 3067fa9e4066Sahrens return (0); 3068fa9e4066Sahrens 3069fa9e4066Sahrens default: 3070fa9e4066Sahrens zfs_baderror(errno); 3071fa9e4066Sahrens } 3072fa9e4066Sahrens 3073fa9e4066Sahrens return (-1); 3074fa9e4066Sahrens } 3075fa9e4066Sahrens 3076fa9e4066Sahrens /* 3077fa9e4066Sahrens * Call devfsadm and wait for the links to magically appear. 3078fa9e4066Sahrens */ 3079fa9e4066Sahrens if ((hdl = di_devlink_init(ZFS_DRIVER, DI_MAKE_LINK)) == NULL) { 3080fa9e4066Sahrens zfs_error(dgettext(TEXT_DOMAIN, 3081fa9e4066Sahrens "cannot create device links for '%s'"), dataset); 3082fa9e4066Sahrens (void) ioctl(zfs_fd, ZFS_IOC_REMOVE_MINOR, &zc); 3083fa9e4066Sahrens return (-1); 3084fa9e4066Sahrens } else { 3085fa9e4066Sahrens (void) di_devlink_fini(&hdl); 3086fa9e4066Sahrens } 3087fa9e4066Sahrens 3088fa9e4066Sahrens return (0); 3089fa9e4066Sahrens } 3090fa9e4066Sahrens 3091fa9e4066Sahrens /* 3092fa9e4066Sahrens * Remove a minor node for the given zvol and the associated /dev links. 3093fa9e4066Sahrens */ 3094fa9e4066Sahrens int 3095fa9e4066Sahrens zvol_remove_link(const char *dataset) 3096fa9e4066Sahrens { 3097fa9e4066Sahrens zfs_cmd_t zc = { 0 }; 3098fa9e4066Sahrens 3099fa9e4066Sahrens (void) strlcpy(zc.zc_name, dataset, sizeof (zc.zc_name)); 3100fa9e4066Sahrens 3101fa9e4066Sahrens if (ioctl(zfs_fd, ZFS_IOC_REMOVE_MINOR, &zc) != 0) { 3102fa9e4066Sahrens switch (errno) { 3103fa9e4066Sahrens case EPERM: 3104fa9e4066Sahrens zfs_error(dgettext(TEXT_DOMAIN, "cannot remove " 3105fa9e4066Sahrens "device links for '%s': permission denied"), 3106fa9e4066Sahrens dataset); 3107fa9e4066Sahrens break; 3108fa9e4066Sahrens 3109fa9e4066Sahrens case EBUSY: 3110fa9e4066Sahrens zfs_error(dgettext(TEXT_DOMAIN, "cannot remove " 3111fa9e4066Sahrens "device links for '%s': volume is in use"), 3112fa9e4066Sahrens dataset); 3113fa9e4066Sahrens break; 3114fa9e4066Sahrens 3115fa9e4066Sahrens case ENXIO: 3116fa9e4066Sahrens /* 3117fa9e4066Sahrens * Silently ignore the case where the link no longer 3118fa9e4066Sahrens * exists, so that 'zfs volfini' can be run multiple 3119fa9e4066Sahrens * times without errors. 3120fa9e4066Sahrens */ 3121fa9e4066Sahrens return (0); 3122fa9e4066Sahrens 3123fa9e4066Sahrens default: 3124fa9e4066Sahrens zfs_baderror(errno); 3125fa9e4066Sahrens } 3126fa9e4066Sahrens 3127fa9e4066Sahrens return (-1); 3128fa9e4066Sahrens } 3129fa9e4066Sahrens 3130fa9e4066Sahrens return (0); 3131fa9e4066Sahrens } 3132