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 /* 23fa9e4066Sahrens * Copyright 2005 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> 42fa9e4066Sahrens 43fa9e4066Sahrens #include <sys/spa.h> 44fa9e4066Sahrens #include <sys/zio.h> 45fa9e4066Sahrens #include <libzfs.h> 46fa9e4066Sahrens 47fa9e4066Sahrens #include "zfs_namecheck.h" 48fa9e4066Sahrens #include "zfs_prop.h" 49fa9e4066Sahrens #include "libzfs_impl.h" 50fa9e4066Sahrens 51fa9e4066Sahrens /* 52fa9e4066Sahrens * Given a single type (not a mask of types), return the type in a human 53fa9e4066Sahrens * readable form. 54fa9e4066Sahrens */ 55fa9e4066Sahrens const char * 56fa9e4066Sahrens zfs_type_to_name(zfs_type_t type) 57fa9e4066Sahrens { 58fa9e4066Sahrens switch (type) { 59fa9e4066Sahrens case ZFS_TYPE_FILESYSTEM: 60fa9e4066Sahrens return (dgettext(TEXT_DOMAIN, "filesystem")); 61fa9e4066Sahrens case ZFS_TYPE_SNAPSHOT: 62fa9e4066Sahrens return (dgettext(TEXT_DOMAIN, "snapshot")); 63fa9e4066Sahrens case ZFS_TYPE_VOLUME: 64fa9e4066Sahrens return (dgettext(TEXT_DOMAIN, "volume")); 65fa9e4066Sahrens } 66fa9e4066Sahrens 67fa9e4066Sahrens zfs_baderror(type); 68fa9e4066Sahrens return (NULL); 69fa9e4066Sahrens } 70fa9e4066Sahrens 71fa9e4066Sahrens /* 72fa9e4066Sahrens * Given a path and mask of ZFS types, return a string describing this dataset. 73fa9e4066Sahrens * This is used when we fail to open a dataset and we cannot get an exact type. 74fa9e4066Sahrens * We guess what the type would have been based on the path and the mask of 75fa9e4066Sahrens * acceptable types. 76fa9e4066Sahrens */ 77fa9e4066Sahrens static const char * 78fa9e4066Sahrens path_to_str(const char *path, int types) 79fa9e4066Sahrens { 80fa9e4066Sahrens /* 81fa9e4066Sahrens * When given a single type, always report the exact type. 82fa9e4066Sahrens */ 83fa9e4066Sahrens if (types == ZFS_TYPE_SNAPSHOT) 84fa9e4066Sahrens return (dgettext(TEXT_DOMAIN, "snapshot")); 85fa9e4066Sahrens if (types == ZFS_TYPE_FILESYSTEM) 86fa9e4066Sahrens return (dgettext(TEXT_DOMAIN, "filesystem")); 87fa9e4066Sahrens if (types == ZFS_TYPE_VOLUME) 88fa9e4066Sahrens return (dgettext(TEXT_DOMAIN, "volume")); 89fa9e4066Sahrens 90fa9e4066Sahrens /* 91fa9e4066Sahrens * The user is requesting more than one type of dataset. If this is the 92fa9e4066Sahrens * case, consult the path itself. If we're looking for a snapshot, and 93fa9e4066Sahrens * a '@' is found, then report it as "snapshot". Otherwise, remove the 94fa9e4066Sahrens * snapshot attribute and try again. 95fa9e4066Sahrens */ 96fa9e4066Sahrens if (types & ZFS_TYPE_SNAPSHOT) { 97fa9e4066Sahrens if (strchr(path, '@') != NULL) 98fa9e4066Sahrens return (dgettext(TEXT_DOMAIN, "snapshot")); 99fa9e4066Sahrens return (path_to_str(path, types & ~ZFS_TYPE_SNAPSHOT)); 100fa9e4066Sahrens } 101fa9e4066Sahrens 102fa9e4066Sahrens 103fa9e4066Sahrens /* 104fa9e4066Sahrens * The user has requested either filesystems or volumes. 105fa9e4066Sahrens * We have no way of knowing a priori what type this would be, so always 106fa9e4066Sahrens * report it as "filesystem" or "volume", our two primitive types. 107fa9e4066Sahrens */ 108fa9e4066Sahrens if (types & ZFS_TYPE_FILESYSTEM) 109fa9e4066Sahrens return (dgettext(TEXT_DOMAIN, "filesystem")); 110fa9e4066Sahrens 111fa9e4066Sahrens assert(types & ZFS_TYPE_VOLUME); 112fa9e4066Sahrens return (dgettext(TEXT_DOMAIN, "volume")); 113fa9e4066Sahrens } 114fa9e4066Sahrens 115fa9e4066Sahrens /* 116fa9e4066Sahrens * Validate a ZFS path. This is used even before trying to open the dataset, to 117fa9e4066Sahrens * provide a more meaningful error message. We place a more useful message in 118fa9e4066Sahrens * 'buf' detailing exactly why the name was not valid. 119fa9e4066Sahrens */ 120fa9e4066Sahrens static int 121fa9e4066Sahrens zfs_validate_name(const char *path, int type, char *buf, size_t buflen) 122fa9e4066Sahrens { 123fa9e4066Sahrens namecheck_err_t why; 124fa9e4066Sahrens char what; 125fa9e4066Sahrens 126fa9e4066Sahrens if (dataset_namecheck(path, &why, &what) != 0) { 127fa9e4066Sahrens if (buf != NULL) { 128fa9e4066Sahrens switch (why) { 129fa9e4066Sahrens case NAME_ERR_LEADING_SLASH: 130fa9e4066Sahrens (void) strlcpy(buf, dgettext(TEXT_DOMAIN, 131fa9e4066Sahrens "leading slash"), buflen); 132fa9e4066Sahrens break; 133fa9e4066Sahrens 134fa9e4066Sahrens case NAME_ERR_EMPTY_COMPONENT: 135fa9e4066Sahrens (void) strlcpy(buf, dgettext(TEXT_DOMAIN, 136fa9e4066Sahrens "empty component"), buflen); 137fa9e4066Sahrens break; 138fa9e4066Sahrens 139fa9e4066Sahrens case NAME_ERR_TRAILING_SLASH: 140fa9e4066Sahrens (void) strlcpy(buf, dgettext(TEXT_DOMAIN, 141fa9e4066Sahrens "trailing slash"), buflen); 142fa9e4066Sahrens break; 143fa9e4066Sahrens 144fa9e4066Sahrens case NAME_ERR_INVALCHAR: 145fa9e4066Sahrens (void) snprintf(buf, buflen, 146fa9e4066Sahrens dgettext(TEXT_DOMAIN, "invalid character " 147fa9e4066Sahrens "'%c'"), what); 148fa9e4066Sahrens break; 149fa9e4066Sahrens 150fa9e4066Sahrens case NAME_ERR_MULTIPLE_AT: 151fa9e4066Sahrens (void) strlcpy(buf, dgettext(TEXT_DOMAIN, 152fa9e4066Sahrens "multiple '@' delimiters"), buflen); 153fa9e4066Sahrens break; 154fa9e4066Sahrens } 155fa9e4066Sahrens } 156fa9e4066Sahrens 157fa9e4066Sahrens return (0); 158fa9e4066Sahrens } 159fa9e4066Sahrens 160fa9e4066Sahrens if (!(type & ZFS_TYPE_SNAPSHOT) && strchr(path, '@') != NULL) { 161fa9e4066Sahrens if (buf != NULL) 162fa9e4066Sahrens (void) strlcpy(buf, 163fa9e4066Sahrens dgettext(TEXT_DOMAIN, 164fa9e4066Sahrens "snapshot delimiter '@'"), buflen); 165fa9e4066Sahrens return (0); 166fa9e4066Sahrens } 167fa9e4066Sahrens 168fa9e4066Sahrens return (1); 169fa9e4066Sahrens } 170fa9e4066Sahrens 171fa9e4066Sahrens int 172fa9e4066Sahrens zfs_name_valid(const char *name, zfs_type_t type) 173fa9e4066Sahrens { 174fa9e4066Sahrens return (zfs_validate_name(name, type, NULL, NULL)); 175fa9e4066Sahrens } 176fa9e4066Sahrens 177fa9e4066Sahrens /* 178fa9e4066Sahrens * Utility function to gather stats (objset and zpl) for the given object. 179fa9e4066Sahrens */ 180fa9e4066Sahrens static int 181fa9e4066Sahrens get_stats(zfs_handle_t *zhp) 182fa9e4066Sahrens { 183fa9e4066Sahrens zfs_cmd_t zc = { 0 }; 184fa9e4066Sahrens 185fa9e4066Sahrens (void) strlcpy(zc.zc_name, zhp->zfs_name, sizeof (zc.zc_name)); 186fa9e4066Sahrens 187fa9e4066Sahrens /* 188fa9e4066Sahrens * get the generic DMU stats and per-type (zfs, zvol) stats 189fa9e4066Sahrens */ 190fa9e4066Sahrens if (ioctl(zfs_fd, ZFS_IOC_OBJSET_STATS, &zc) != 0) 191fa9e4066Sahrens return (-1); 192fa9e4066Sahrens 193fa9e4066Sahrens bcopy(&zc.zc_objset_stats, &zhp->zfs_dmustats, 194fa9e4066Sahrens sizeof (zc.zc_objset_stats)); 195fa9e4066Sahrens 196fa9e4066Sahrens bcopy(&zc.zc_zfs_stats, &zhp->zfs_zplstats, sizeof (zc.zc_zfs_stats)); 197fa9e4066Sahrens 198fa9e4066Sahrens zhp->zfs_volsize = zc.zc_volsize; 199fa9e4066Sahrens zhp->zfs_volblocksize = zc.zc_volblocksize; 200fa9e4066Sahrens 201fa9e4066Sahrens return (0); 202fa9e4066Sahrens } 203fa9e4066Sahrens 204fa9e4066Sahrens /* 205fa9e4066Sahrens * Refresh the properties currently stored in the handle. 206fa9e4066Sahrens */ 207fa9e4066Sahrens void 208fa9e4066Sahrens zfs_refresh_properties(zfs_handle_t *zhp) 209fa9e4066Sahrens { 210fa9e4066Sahrens (void) get_stats(zhp); 211fa9e4066Sahrens } 212fa9e4066Sahrens 213fa9e4066Sahrens /* 214fa9e4066Sahrens * Makes a handle from the given dataset name. Used by zfs_open() and 215fa9e4066Sahrens * zfs_iter_* to create child handles on the fly. 216fa9e4066Sahrens */ 217fa9e4066Sahrens zfs_handle_t * 218fa9e4066Sahrens make_dataset_handle(const char *path) 219fa9e4066Sahrens { 220fa9e4066Sahrens zfs_handle_t *zhp = zfs_malloc(sizeof (zfs_handle_t)); 221fa9e4066Sahrens 222fa9e4066Sahrens (void) strlcpy(zhp->zfs_name, path, sizeof (zhp->zfs_name)); 223fa9e4066Sahrens 224fa9e4066Sahrens if (get_stats(zhp) != 0) { 225fa9e4066Sahrens free(zhp); 226fa9e4066Sahrens return (NULL); 227fa9e4066Sahrens } 228fa9e4066Sahrens 229fa9e4066Sahrens /* 230fa9e4066Sahrens * We've managed to open the dataset and gather statistics. Determine 231fa9e4066Sahrens * the high-level type. 232fa9e4066Sahrens */ 233fa9e4066Sahrens if (zhp->zfs_dmustats.dds_is_snapshot) 234fa9e4066Sahrens zhp->zfs_type = ZFS_TYPE_SNAPSHOT; 235fa9e4066Sahrens else if (zhp->zfs_dmustats.dds_type == DMU_OST_ZVOL) 236fa9e4066Sahrens zhp->zfs_type = ZFS_TYPE_VOLUME; 237fa9e4066Sahrens else if (zhp->zfs_dmustats.dds_type == DMU_OST_ZFS) 238fa9e4066Sahrens zhp->zfs_type = ZFS_TYPE_FILESYSTEM; 239fa9e4066Sahrens else 240fa9e4066Sahrens /* we should never see any other dataset types */ 241fa9e4066Sahrens zfs_baderror(zhp->zfs_dmustats.dds_type); 242fa9e4066Sahrens 243fa9e4066Sahrens return (zhp); 244fa9e4066Sahrens } 245fa9e4066Sahrens 246fa9e4066Sahrens /* 247fa9e4066Sahrens * Opens the given snapshot, filesystem, or volume. The 'types' 248fa9e4066Sahrens * argument is a mask of acceptable types. The function will print an 249fa9e4066Sahrens * appropriate error message and return NULL if it can't be opened. 250fa9e4066Sahrens */ 251fa9e4066Sahrens zfs_handle_t * 252fa9e4066Sahrens zfs_open(const char *path, int types) 253fa9e4066Sahrens { 254fa9e4066Sahrens zfs_handle_t *zhp; 255fa9e4066Sahrens 256fa9e4066Sahrens /* 257fa9e4066Sahrens * If the path is longer than the maximum dataset length, treat it as 258fa9e4066Sahrens * ENOENT because we know there can't be any dataset with that path. 259fa9e4066Sahrens */ 260fa9e4066Sahrens if (strlen(path) >= ZFS_MAXNAMELEN) { 261fa9e4066Sahrens zfs_error(dgettext(TEXT_DOMAIN, 262fa9e4066Sahrens "cannot open '%s': no such %s"), path, 263fa9e4066Sahrens path_to_str(path, types)); 264fa9e4066Sahrens return (NULL); 265fa9e4066Sahrens } 266fa9e4066Sahrens 267fa9e4066Sahrens /* 268fa9e4066Sahrens * Validate the name before we even try to open it. We don't care about 269fa9e4066Sahrens * the verbose invalid messages here; just report a generic error. 270fa9e4066Sahrens */ 271fa9e4066Sahrens if (!zfs_validate_name(path, types, NULL, 0)) { 272fa9e4066Sahrens zfs_error(dgettext(TEXT_DOMAIN, 273fa9e4066Sahrens "cannot open '%s': invalid %s name"), path, 274fa9e4066Sahrens path_to_str(path, types)); 275fa9e4066Sahrens return (NULL); 276fa9e4066Sahrens } 277fa9e4066Sahrens 278fa9e4066Sahrens /* 279fa9e4066Sahrens * Try to get stats for the dataset, which will tell us if it exists. 280fa9e4066Sahrens */ 281fa9e4066Sahrens errno = 0; 282fa9e4066Sahrens if ((zhp = make_dataset_handle(path)) == NULL) { 283fa9e4066Sahrens switch (errno) { 284fa9e4066Sahrens case ENOENT: 285fa9e4066Sahrens /* 286fa9e4066Sahrens * The dataset doesn't exist. 287fa9e4066Sahrens */ 288fa9e4066Sahrens zfs_error(dgettext(TEXT_DOMAIN, 289fa9e4066Sahrens "cannot open '%s': no such %s"), path, 290fa9e4066Sahrens path_to_str(path, types)); 291fa9e4066Sahrens break; 292fa9e4066Sahrens 293fa9e4066Sahrens case EBUSY: 294fa9e4066Sahrens /* 295fa9e4066Sahrens * We were able to open the dataset but couldn't 296fa9e4066Sahrens * get the stats. 297fa9e4066Sahrens */ 298fa9e4066Sahrens zfs_error(dgettext(TEXT_DOMAIN, 299fa9e4066Sahrens "cannot open '%s': %s is busy"), path, 300fa9e4066Sahrens path_to_str(path, types)); 301fa9e4066Sahrens break; 302fa9e4066Sahrens 303fa9e4066Sahrens default: 304fa9e4066Sahrens zfs_baderror(errno); 305fa9e4066Sahrens 306fa9e4066Sahrens } 307fa9e4066Sahrens return (NULL); 308fa9e4066Sahrens } 309fa9e4066Sahrens 310fa9e4066Sahrens if (!(types & zhp->zfs_type)) { 311fa9e4066Sahrens zfs_error(dgettext(TEXT_DOMAIN, "cannot open '%s': operation " 312fa9e4066Sahrens "not supported for %ss"), path, 313fa9e4066Sahrens zfs_type_to_name(zhp->zfs_type)); 314fa9e4066Sahrens free(zhp); 315fa9e4066Sahrens return (NULL); 316fa9e4066Sahrens } 317fa9e4066Sahrens 318fa9e4066Sahrens return (zhp); 319fa9e4066Sahrens } 320fa9e4066Sahrens 321fa9e4066Sahrens /* 322fa9e4066Sahrens * Release a ZFS handle. Nothing to do but free the associated memory. 323fa9e4066Sahrens */ 324fa9e4066Sahrens void 325fa9e4066Sahrens zfs_close(zfs_handle_t *zhp) 326fa9e4066Sahrens { 327fa9e4066Sahrens if (zhp->zfs_mntopts) 328fa9e4066Sahrens free(zhp->zfs_mntopts); 329fa9e4066Sahrens free(zhp); 330fa9e4066Sahrens } 331fa9e4066Sahrens 332fa9e4066Sahrens struct { 333fa9e4066Sahrens const char *name; 334fa9e4066Sahrens uint64_t value; 335fa9e4066Sahrens } checksum_table[] = { 336fa9e4066Sahrens { "on", ZIO_CHECKSUM_ON }, 337fa9e4066Sahrens { "off", ZIO_CHECKSUM_OFF }, 338fa9e4066Sahrens { "fletcher2", ZIO_CHECKSUM_FLETCHER_2 }, 339fa9e4066Sahrens { "fletcher4", ZIO_CHECKSUM_FLETCHER_4 }, 340fa9e4066Sahrens { "sha256", ZIO_CHECKSUM_SHA256 }, 341fa9e4066Sahrens { NULL } 342fa9e4066Sahrens }; 343fa9e4066Sahrens 344fa9e4066Sahrens struct { 345fa9e4066Sahrens const char *name; 346fa9e4066Sahrens uint64_t value; 347fa9e4066Sahrens } compress_table[] = { 348fa9e4066Sahrens { "on", ZIO_COMPRESS_ON }, 349fa9e4066Sahrens { "off", ZIO_COMPRESS_OFF }, 350fa9e4066Sahrens { "lzjb", ZIO_COMPRESS_LZJB }, 351fa9e4066Sahrens { NULL } 352fa9e4066Sahrens }; 353fa9e4066Sahrens 354fa9e4066Sahrens struct { 355fa9e4066Sahrens const char *name; 356fa9e4066Sahrens uint64_t value; 357fa9e4066Sahrens } snapdir_table[] = { 358*a0965f35Sbonwick { "hidden", ZFS_SNAPDIR_HIDDEN }, 359*a0965f35Sbonwick { "visible", ZFS_SNAPDIR_VISIBLE }, 360fa9e4066Sahrens { NULL } 361fa9e4066Sahrens }; 362fa9e4066Sahrens 363fa9e4066Sahrens struct { 364fa9e4066Sahrens const char *name; 365fa9e4066Sahrens uint64_t value; 366fa9e4066Sahrens } acl_mode_table[] = { 367fa9e4066Sahrens { "discard", DISCARD }, 368fa9e4066Sahrens { "groupmask", GROUPMASK }, 369fa9e4066Sahrens { "passthrough", PASSTHROUGH }, 370fa9e4066Sahrens { NULL } 371fa9e4066Sahrens }; 372fa9e4066Sahrens 373fa9e4066Sahrens struct { 374fa9e4066Sahrens const char *name; 375fa9e4066Sahrens uint64_t value; 376fa9e4066Sahrens } acl_inherit_table[] = { 377fa9e4066Sahrens { "discard", DISCARD }, 378fa9e4066Sahrens { "noallow", NOALLOW }, 379fa9e4066Sahrens { "secure", SECURE }, 380fa9e4066Sahrens { "passthrough", PASSTHROUGH }, 381fa9e4066Sahrens { NULL } 382fa9e4066Sahrens }; 383fa9e4066Sahrens 384fa9e4066Sahrens 385fa9e4066Sahrens /* 386fa9e4066Sahrens * Given a numeric suffix, convert the value into a number of bits that the 387fa9e4066Sahrens * resulting value must be shifted. 388fa9e4066Sahrens */ 389fa9e4066Sahrens static int 390fa9e4066Sahrens str2shift(const char *buf, char *reason, size_t len) 391fa9e4066Sahrens { 392fa9e4066Sahrens const char *ends = "BKMGTPEZ"; 393fa9e4066Sahrens int i; 394fa9e4066Sahrens 395fa9e4066Sahrens if (buf[0] == '\0') 396fa9e4066Sahrens return (0); 397fa9e4066Sahrens for (i = 0; i < strlen(ends); i++) { 398fa9e4066Sahrens if (toupper(buf[0]) == ends[i]) 399fa9e4066Sahrens break; 400fa9e4066Sahrens } 401fa9e4066Sahrens if (i == strlen(ends)) { 402fa9e4066Sahrens (void) snprintf(reason, len, dgettext(TEXT_DOMAIN, "invalid " 403fa9e4066Sahrens "numeric suffix '%s'"), buf); 404fa9e4066Sahrens return (-1); 405fa9e4066Sahrens } 406fa9e4066Sahrens 407fa9e4066Sahrens /* 408fa9e4066Sahrens * We want to allow trailing 'b' characters for 'GB' or 'Mb'. But don't 409fa9e4066Sahrens * allow 'BB' - that's just weird. 410fa9e4066Sahrens */ 411fa9e4066Sahrens if (buf[1] == '\0' || (toupper(buf[1]) == 'B' && buf[2] == '\0' && 412fa9e4066Sahrens toupper(buf[0]) != 'B')) { 413fa9e4066Sahrens return (10*i); 414fa9e4066Sahrens } 415fa9e4066Sahrens 416fa9e4066Sahrens (void) snprintf(reason, len, dgettext(TEXT_DOMAIN, "invalid numeric " 417fa9e4066Sahrens "suffix '%s'"), buf); 418fa9e4066Sahrens return (-1); 419fa9e4066Sahrens } 420fa9e4066Sahrens 421fa9e4066Sahrens /* 422fa9e4066Sahrens * Convert a string of the form '100G' into a real number. Used when setting 423fa9e4066Sahrens * properties or creating a volume. 'buf' is used to place an extended error 424fa9e4066Sahrens * message for the caller to use. 425fa9e4066Sahrens */ 426fa9e4066Sahrens static int 427fa9e4066Sahrens nicestrtonum(const char *value, uint64_t *num, char *buf, size_t buflen) 428fa9e4066Sahrens { 429fa9e4066Sahrens char *end; 430fa9e4066Sahrens int shift; 431fa9e4066Sahrens 432fa9e4066Sahrens *num = 0; 433fa9e4066Sahrens 434fa9e4066Sahrens /* Check to see if this looks like a number. */ 435fa9e4066Sahrens if ((value[0] < '0' || value[0] > '9') && value[0] != '.') { 436fa9e4066Sahrens (void) strlcpy(buf, dgettext(TEXT_DOMAIN, 437fa9e4066Sahrens "must be a numeric value"), buflen); 438fa9e4066Sahrens return (-1); 439fa9e4066Sahrens } 440fa9e4066Sahrens 441fa9e4066Sahrens /* Rely on stroll() to process the numeric portion. */ 442fa9e4066Sahrens errno = 0; 443fa9e4066Sahrens *num = strtoll(value, &end, 10); 444fa9e4066Sahrens 445fa9e4066Sahrens /* 446fa9e4066Sahrens * Check for ERANGE, which indicates that the value is too large to fit 447fa9e4066Sahrens * in a 64-bit value. 448fa9e4066Sahrens */ 449fa9e4066Sahrens if (errno == ERANGE) { 450fa9e4066Sahrens (void) strlcpy(buf, dgettext(TEXT_DOMAIN, 451fa9e4066Sahrens "value is too large"), buflen); 452fa9e4066Sahrens return (-1); 453fa9e4066Sahrens } 454fa9e4066Sahrens 455fa9e4066Sahrens /* 456fa9e4066Sahrens * If we have a decimal value, then do the computation with floating 457fa9e4066Sahrens * point arithmetic. Otherwise, use standard arithmetic. 458fa9e4066Sahrens */ 459fa9e4066Sahrens if (*end == '.') { 460fa9e4066Sahrens double fval = strtod(value, &end); 461fa9e4066Sahrens 462fa9e4066Sahrens if ((shift = str2shift(end, buf, buflen)) == -1) 463fa9e4066Sahrens return (-1); 464fa9e4066Sahrens 465fa9e4066Sahrens fval *= pow(2, shift); 466fa9e4066Sahrens 467fa9e4066Sahrens if (fval > UINT64_MAX) { 468fa9e4066Sahrens (void) strlcpy(buf, dgettext(TEXT_DOMAIN, 469fa9e4066Sahrens "value is too large"), buflen); 470fa9e4066Sahrens return (-1); 471fa9e4066Sahrens } 472fa9e4066Sahrens 473fa9e4066Sahrens *num = (uint64_t)fval; 474fa9e4066Sahrens } else { 475fa9e4066Sahrens if ((shift = str2shift(end, buf, buflen)) == -1) 476fa9e4066Sahrens return (-1); 477fa9e4066Sahrens 478fa9e4066Sahrens /* Check for overflow */ 479fa9e4066Sahrens if (shift >= 64 || (*num << shift) >> shift != *num) { 480fa9e4066Sahrens (void) strlcpy(buf, dgettext(TEXT_DOMAIN, 481fa9e4066Sahrens "value is too large"), buflen); 482fa9e4066Sahrens return (-1); 483fa9e4066Sahrens } 484fa9e4066Sahrens 485fa9e4066Sahrens *num <<= shift; 486fa9e4066Sahrens } 487fa9e4066Sahrens 488fa9e4066Sahrens return (0); 489fa9e4066Sahrens } 490fa9e4066Sahrens 491fa9e4066Sahrens int 492fa9e4066Sahrens zfs_nicestrtonum(const char *str, uint64_t *val) 493fa9e4066Sahrens { 494fa9e4066Sahrens char buf[1]; 495fa9e4066Sahrens 496fa9e4066Sahrens return (nicestrtonum(str, val, buf, sizeof (buf))); 497fa9e4066Sahrens } 498fa9e4066Sahrens 499fa9e4066Sahrens /* 500fa9e4066Sahrens * Given a property type and value, verify that the value is appropriate. Used 501fa9e4066Sahrens * by zfs_prop_set() and some libzfs consumers. 502fa9e4066Sahrens */ 503fa9e4066Sahrens int 504fa9e4066Sahrens zfs_prop_validate(zfs_prop_t prop, const char *value, uint64_t *intval) 505fa9e4066Sahrens { 506fa9e4066Sahrens const char *propname = zfs_prop_to_name(prop); 507fa9e4066Sahrens uint64_t number; 508fa9e4066Sahrens char reason[64]; 509fa9e4066Sahrens int i; 510fa9e4066Sahrens 511fa9e4066Sahrens /* 512fa9e4066Sahrens * Check to see if this a read-only property. 513fa9e4066Sahrens */ 514fa9e4066Sahrens if (zfs_prop_readonly(prop)) { 515fa9e4066Sahrens zfs_error(dgettext(TEXT_DOMAIN, 516fa9e4066Sahrens "cannot set %s property: read-only property"), propname); 517fa9e4066Sahrens return (-1); 518fa9e4066Sahrens } 519fa9e4066Sahrens 520fa9e4066Sahrens /* See if the property value is too long */ 521fa9e4066Sahrens if (strlen(value) >= ZFS_MAXPROPLEN) { 522fa9e4066Sahrens zfs_error(dgettext(TEXT_DOMAIN, 523fa9e4066Sahrens "bad %s value '%s': value is too long"), propname, 524fa9e4066Sahrens value); 525fa9e4066Sahrens return (-1); 526fa9e4066Sahrens } 527fa9e4066Sahrens 528fa9e4066Sahrens /* Perform basic checking based on property type */ 529fa9e4066Sahrens switch (zfs_prop_get_type(prop)) { 530fa9e4066Sahrens case prop_type_boolean: 531fa9e4066Sahrens if (strcmp(value, "on") == 0) { 532fa9e4066Sahrens number = 1; 533fa9e4066Sahrens } else if (strcmp(value, "off") == 0) { 534fa9e4066Sahrens number = 0; 535fa9e4066Sahrens } else { 536fa9e4066Sahrens zfs_error(dgettext(TEXT_DOMAIN, 537fa9e4066Sahrens "bad %s value '%s': must be 'on' or 'off'"), 538fa9e4066Sahrens propname, value); 539fa9e4066Sahrens return (-1); 540fa9e4066Sahrens } 541fa9e4066Sahrens break; 542fa9e4066Sahrens 543fa9e4066Sahrens case prop_type_number: 544fa9e4066Sahrens /* treat 'none' as 0 */ 545fa9e4066Sahrens if (strcmp(value, "none") == 0) { 546fa9e4066Sahrens number = 0; 547fa9e4066Sahrens break; 548fa9e4066Sahrens } 549fa9e4066Sahrens 550fa9e4066Sahrens if (nicestrtonum(value, &number, reason, 551fa9e4066Sahrens sizeof (reason)) != 0) { 552fa9e4066Sahrens zfs_error(dgettext(TEXT_DOMAIN, 553fa9e4066Sahrens "bad %s value '%s': %s"), propname, value, 554fa9e4066Sahrens reason); 555fa9e4066Sahrens return (-1); 556fa9e4066Sahrens } 557fa9e4066Sahrens 558fa9e4066Sahrens /* don't allow 0 for quota, use 'none' instead */ 559fa9e4066Sahrens if (prop == ZFS_PROP_QUOTA && number == 0 && 560fa9e4066Sahrens strcmp(value, "none") != 0) { 561fa9e4066Sahrens zfs_error(dgettext(TEXT_DOMAIN, 562fa9e4066Sahrens "bad %s value '%s': use '%s=none' to disable"), 563fa9e4066Sahrens propname, value, propname); 564fa9e4066Sahrens return (-1); 565fa9e4066Sahrens } 566fa9e4066Sahrens 567fa9e4066Sahrens /* must be power of two within SPA_{MIN,MAX}BLOCKSIZE */ 568fa9e4066Sahrens if (prop == ZFS_PROP_RECORDSIZE || 569fa9e4066Sahrens prop == ZFS_PROP_VOLBLOCKSIZE) { 570fa9e4066Sahrens if (number < SPA_MINBLOCKSIZE || 571fa9e4066Sahrens number > SPA_MAXBLOCKSIZE || !ISP2(number)) { 572fa9e4066Sahrens zfs_error(dgettext(TEXT_DOMAIN, 573fa9e4066Sahrens "bad %s value '%s': " 574fa9e4066Sahrens "must be power of 2 from %u to %uk"), 575fa9e4066Sahrens propname, value, 576fa9e4066Sahrens (uint_t)SPA_MINBLOCKSIZE, 577fa9e4066Sahrens (uint_t)SPA_MAXBLOCKSIZE >> 10); 578fa9e4066Sahrens return (-1); 579fa9e4066Sahrens } 580fa9e4066Sahrens } 581fa9e4066Sahrens 582fa9e4066Sahrens break; 583fa9e4066Sahrens 584fa9e4066Sahrens case prop_type_string: 585fa9e4066Sahrens case prop_type_index: 586fa9e4066Sahrens /* 587fa9e4066Sahrens * The two writable string values, 'mountpoint' and 588fa9e4066Sahrens * 'checksum' need special consideration. The 'index' types are 589fa9e4066Sahrens * specified as strings by the user, but passed to the kernel as 590fa9e4066Sahrens * integers. 591fa9e4066Sahrens */ 592fa9e4066Sahrens switch (prop) { 593fa9e4066Sahrens case ZFS_PROP_MOUNTPOINT: 594fa9e4066Sahrens if (strcmp(value, ZFS_MOUNTPOINT_NONE) == 0 || 595fa9e4066Sahrens strcmp(value, ZFS_MOUNTPOINT_LEGACY) == 0) 596fa9e4066Sahrens break; 597fa9e4066Sahrens 598fa9e4066Sahrens if (value[0] != '/') { 599fa9e4066Sahrens zfs_error(dgettext(TEXT_DOMAIN, 600fa9e4066Sahrens "bad %s value '%s': must be an absolute " 601fa9e4066Sahrens "path, 'none', or 'legacy'"), 602fa9e4066Sahrens propname, value); 603fa9e4066Sahrens return (-1); 604fa9e4066Sahrens } 605fa9e4066Sahrens break; 606fa9e4066Sahrens 607fa9e4066Sahrens case ZFS_PROP_CHECKSUM: 608fa9e4066Sahrens for (i = 0; checksum_table[i].name != NULL; i++) { 609fa9e4066Sahrens if (strcmp(value, checksum_table[i].name) 610fa9e4066Sahrens == 0) { 611fa9e4066Sahrens number = checksum_table[i].value; 612fa9e4066Sahrens break; 613fa9e4066Sahrens } 614fa9e4066Sahrens } 615fa9e4066Sahrens 616fa9e4066Sahrens if (checksum_table[i].name == NULL) { 617fa9e4066Sahrens zfs_error(dgettext(TEXT_DOMAIN, 618fa9e4066Sahrens "bad %s value '%s': must be 'on', 'off', " 619fa9e4066Sahrens "'fletcher2', 'fletcher4', or 'sha256'"), 620fa9e4066Sahrens propname, value); 621fa9e4066Sahrens return (-1); 622fa9e4066Sahrens } 623fa9e4066Sahrens break; 624fa9e4066Sahrens 625fa9e4066Sahrens case ZFS_PROP_COMPRESSION: 626fa9e4066Sahrens for (i = 0; compress_table[i].name != NULL; i++) { 627fa9e4066Sahrens if (strcmp(value, compress_table[i].name) 628fa9e4066Sahrens == 0) { 629fa9e4066Sahrens number = compress_table[i].value; 630fa9e4066Sahrens break; 631fa9e4066Sahrens } 632fa9e4066Sahrens } 633fa9e4066Sahrens 634fa9e4066Sahrens if (compress_table[i].name == NULL) { 635fa9e4066Sahrens zfs_error(dgettext(TEXT_DOMAIN, 636fa9e4066Sahrens "bad %s value '%s': must be 'on', 'off', " 637fa9e4066Sahrens "or 'lzjb'"), 638fa9e4066Sahrens propname, value); 639fa9e4066Sahrens return (-1); 640fa9e4066Sahrens } 641fa9e4066Sahrens break; 642fa9e4066Sahrens 643fa9e4066Sahrens case ZFS_PROP_SNAPDIR: 644fa9e4066Sahrens for (i = 0; snapdir_table[i].name != NULL; i++) { 645fa9e4066Sahrens if (strcmp(value, snapdir_table[i].name) == 0) { 646fa9e4066Sahrens number = snapdir_table[i].value; 647fa9e4066Sahrens break; 648fa9e4066Sahrens } 649fa9e4066Sahrens } 650fa9e4066Sahrens 651fa9e4066Sahrens if (snapdir_table[i].name == NULL) { 652fa9e4066Sahrens zfs_error(dgettext(TEXT_DOMAIN, 653fa9e4066Sahrens "bad %s value '%s': must be 'hidden' " 654fa9e4066Sahrens "or 'visible'"), 655fa9e4066Sahrens propname, value); 656fa9e4066Sahrens return (-1); 657fa9e4066Sahrens } 658fa9e4066Sahrens break; 659fa9e4066Sahrens 660fa9e4066Sahrens case ZFS_PROP_ACLMODE: 661fa9e4066Sahrens for (i = 0; acl_mode_table[i].name != NULL; i++) { 662fa9e4066Sahrens if (strcmp(value, acl_mode_table[i].name) 663fa9e4066Sahrens == 0) { 664fa9e4066Sahrens number = acl_mode_table[i].value; 665fa9e4066Sahrens break; 666fa9e4066Sahrens } 667fa9e4066Sahrens } 668fa9e4066Sahrens 669fa9e4066Sahrens if (acl_mode_table[i].name == NULL) { 670fa9e4066Sahrens zfs_error(dgettext(TEXT_DOMAIN, 671fa9e4066Sahrens "bad %s value '%s': must be 'discard', " 672fa9e4066Sahrens "'groupmask' or 'passthrough'"), 673fa9e4066Sahrens propname, value); 674fa9e4066Sahrens return (-1); 675fa9e4066Sahrens } 676fa9e4066Sahrens break; 677fa9e4066Sahrens 678fa9e4066Sahrens case ZFS_PROP_ACLINHERIT: 679fa9e4066Sahrens for (i = 0; acl_inherit_table[i].name != NULL; i++) { 680fa9e4066Sahrens if (strcmp(value, acl_inherit_table[i].name) 681fa9e4066Sahrens == 0) { 682fa9e4066Sahrens number = acl_inherit_table[i].value; 683fa9e4066Sahrens break; 684fa9e4066Sahrens } 685fa9e4066Sahrens } 686fa9e4066Sahrens 687fa9e4066Sahrens if (acl_inherit_table[i].name == NULL) { 688fa9e4066Sahrens zfs_error(dgettext(TEXT_DOMAIN, 689fa9e4066Sahrens "bad %s value '%s': must be 'discard', " 690fa9e4066Sahrens "'noallow', 'groupmask' or 'passthrough'"), 691fa9e4066Sahrens propname, value); 692fa9e4066Sahrens return (-1); 693fa9e4066Sahrens } 694fa9e4066Sahrens break; 695fa9e4066Sahrens 696fa9e4066Sahrens case ZFS_PROP_SHARENFS: 697fa9e4066Sahrens /* 698fa9e4066Sahrens * Nothing to do for 'sharenfs', this gets passed on to 699fa9e4066Sahrens * share(1M) verbatim. 700fa9e4066Sahrens */ 701fa9e4066Sahrens break; 702fa9e4066Sahrens } 703fa9e4066Sahrens } 704fa9e4066Sahrens 705fa9e4066Sahrens if (intval != NULL) 706fa9e4066Sahrens *intval = number; 707fa9e4066Sahrens 708fa9e4066Sahrens return (0); 709fa9e4066Sahrens } 710fa9e4066Sahrens 711fa9e4066Sahrens /* 712fa9e4066Sahrens * Given a property name and value, set the property for the given dataset. 713fa9e4066Sahrens */ 714fa9e4066Sahrens int 715fa9e4066Sahrens zfs_prop_set(zfs_handle_t *zhp, zfs_prop_t prop, const char *propval) 716fa9e4066Sahrens { 717fa9e4066Sahrens const char *propname = zfs_prop_to_name(prop); 718fa9e4066Sahrens uint64_t number; 719fa9e4066Sahrens zfs_cmd_t zc = { 0 }; 720fa9e4066Sahrens int ret; 721fa9e4066Sahrens prop_changelist_t *cl; 722fa9e4066Sahrens 723fa9e4066Sahrens if (zfs_prop_validate(prop, propval, &number) != 0) 724fa9e4066Sahrens return (-1); 725fa9e4066Sahrens 726fa9e4066Sahrens /* 727fa9e4066Sahrens * Check to see if the value applies to this type 728fa9e4066Sahrens */ 729fa9e4066Sahrens if (!zfs_prop_valid_for_type(prop, zhp->zfs_type)) { 730fa9e4066Sahrens zfs_error(dgettext(TEXT_DOMAIN, 731fa9e4066Sahrens "cannot set %s for '%s': property does not apply to %ss"), 732fa9e4066Sahrens propname, zhp->zfs_name, zfs_type_to_name(zhp->zfs_type)); 733fa9e4066Sahrens return (-1); 734fa9e4066Sahrens } 735fa9e4066Sahrens 736fa9e4066Sahrens /* 737fa9e4066Sahrens * For the mountpoint and sharenfs properties, check if it can be set 738fa9e4066Sahrens * in a global/non-global zone based on the zoned property value: 739fa9e4066Sahrens * 740fa9e4066Sahrens * global zone non-global zone 741fa9e4066Sahrens * ----------------------------------------------------- 742fa9e4066Sahrens * zoned=on mountpoint (no) mountpoint (yes) 743fa9e4066Sahrens * sharenfs (no) sharenfs (no) 744fa9e4066Sahrens * 745fa9e4066Sahrens * zoned=off mountpoint (yes) N/A 746fa9e4066Sahrens * sharenfs (yes) 747fa9e4066Sahrens */ 748fa9e4066Sahrens if (prop == ZFS_PROP_MOUNTPOINT || prop == ZFS_PROP_SHARENFS) { 749fa9e4066Sahrens if (zfs_prop_get_int(zhp, ZFS_PROP_ZONED)) { 750fa9e4066Sahrens if (getzoneid() == GLOBAL_ZONEID) { 751fa9e4066Sahrens zfs_error(dgettext(TEXT_DOMAIN, 752fa9e4066Sahrens "cannot set %s for '%s', " 753fa9e4066Sahrens "dataset is used in a non-global zone"), 754fa9e4066Sahrens propname, zhp->zfs_name); 755fa9e4066Sahrens return (-1); 756fa9e4066Sahrens } else if (prop == ZFS_PROP_SHARENFS) { 757fa9e4066Sahrens zfs_error(dgettext(TEXT_DOMAIN, 758fa9e4066Sahrens "cannot set %s for '%s', filesystems " 759fa9e4066Sahrens "cannot be shared in a non-global zone"), 760fa9e4066Sahrens propname, zhp->zfs_name); 761fa9e4066Sahrens return (-1); 762fa9e4066Sahrens } 763fa9e4066Sahrens } else if (getzoneid() != GLOBAL_ZONEID) { 764fa9e4066Sahrens /* 765fa9e4066Sahrens * If zoned property is 'off', this must be in 766fa9e4066Sahrens * a globle zone. If not, something is wrong. 767fa9e4066Sahrens */ 768fa9e4066Sahrens zfs_error(dgettext(TEXT_DOMAIN, 769fa9e4066Sahrens "cannot set %s for '%s', dataset is " 770fa9e4066Sahrens "used in a non-global zone, but 'zoned' " 771fa9e4066Sahrens "property is not set"), 772fa9e4066Sahrens propname, zhp->zfs_name); 773fa9e4066Sahrens return (-1); 774fa9e4066Sahrens } 775fa9e4066Sahrens } 776fa9e4066Sahrens 777fa9e4066Sahrens if ((cl = changelist_gather(zhp, prop, 0)) == NULL) 778fa9e4066Sahrens return (-1); 779fa9e4066Sahrens 780fa9e4066Sahrens if (prop == ZFS_PROP_MOUNTPOINT && changelist_haszonedchild(cl)) { 781fa9e4066Sahrens zfs_error(dgettext(TEXT_DOMAIN, "cannot set %s for '%s', " 782fa9e4066Sahrens "child dataset with inherited mountpoint is used " 783fa9e4066Sahrens "in a non-global zone"), 784fa9e4066Sahrens propname, zhp->zfs_name); 785fa9e4066Sahrens ret = -1; 786fa9e4066Sahrens goto error; 787fa9e4066Sahrens } 788fa9e4066Sahrens 789fa9e4066Sahrens if ((ret = changelist_prefix(cl)) != 0) 790fa9e4066Sahrens goto error; 791fa9e4066Sahrens 792fa9e4066Sahrens /* 793fa9e4066Sahrens * Execute the corresponding ioctl() to set this property. 794fa9e4066Sahrens */ 795fa9e4066Sahrens (void) strlcpy(zc.zc_name, zhp->zfs_name, sizeof (zc.zc_name)); 796fa9e4066Sahrens 797fa9e4066Sahrens switch (prop) { 798fa9e4066Sahrens case ZFS_PROP_QUOTA: 799fa9e4066Sahrens zc.zc_cookie = number; 800fa9e4066Sahrens ret = ioctl(zfs_fd, ZFS_IOC_SET_QUOTA, &zc); 801fa9e4066Sahrens break; 802fa9e4066Sahrens case ZFS_PROP_RESERVATION: 803fa9e4066Sahrens zc.zc_cookie = number; 804fa9e4066Sahrens ret = ioctl(zfs_fd, ZFS_IOC_SET_RESERVATION, &zc); 805fa9e4066Sahrens break; 806fa9e4066Sahrens case ZFS_PROP_MOUNTPOINT: 807fa9e4066Sahrens case ZFS_PROP_SHARENFS: 808fa9e4066Sahrens /* 809fa9e4066Sahrens * These properties are passed down as real strings. 810fa9e4066Sahrens */ 811fa9e4066Sahrens (void) strlcpy(zc.zc_prop_name, propname, 812fa9e4066Sahrens sizeof (zc.zc_prop_name)); 813fa9e4066Sahrens (void) strlcpy(zc.zc_prop_value, propval, 814fa9e4066Sahrens sizeof (zc.zc_prop_value)); 815fa9e4066Sahrens zc.zc_intsz = 1; 816fa9e4066Sahrens zc.zc_numints = strlen(propval) + 1; 817fa9e4066Sahrens ret = ioctl(zfs_fd, ZFS_IOC_SET_PROP, &zc); 818fa9e4066Sahrens break; 819fa9e4066Sahrens case ZFS_PROP_VOLSIZE: 820fa9e4066Sahrens zc.zc_volsize = number; 821fa9e4066Sahrens ret = ioctl(zfs_fd, ZFS_IOC_SET_VOLSIZE, &zc); 822fa9e4066Sahrens break; 823fa9e4066Sahrens case ZFS_PROP_VOLBLOCKSIZE: 824fa9e4066Sahrens zc.zc_volblocksize = number; 825fa9e4066Sahrens ret = ioctl(zfs_fd, ZFS_IOC_SET_VOLBLOCKSIZE, &zc); 826fa9e4066Sahrens break; 827fa9e4066Sahrens default: 828fa9e4066Sahrens (void) strlcpy(zc.zc_prop_name, propname, 829fa9e4066Sahrens sizeof (zc.zc_prop_name)); 830fa9e4066Sahrens /* LINTED - alignment */ 831fa9e4066Sahrens *(uint64_t *)zc.zc_prop_value = number; 832fa9e4066Sahrens zc.zc_intsz = 8; 833fa9e4066Sahrens zc.zc_numints = 1; 834fa9e4066Sahrens ret = ioctl(zfs_fd, ZFS_IOC_SET_PROP, &zc); 835fa9e4066Sahrens break; 836fa9e4066Sahrens } 837fa9e4066Sahrens 838fa9e4066Sahrens if (ret != 0) { 839fa9e4066Sahrens switch (errno) { 840fa9e4066Sahrens 841fa9e4066Sahrens case EPERM: 842fa9e4066Sahrens zfs_error(dgettext(TEXT_DOMAIN, 843fa9e4066Sahrens "cannot set %s for '%s': permission " 844fa9e4066Sahrens "denied"), propname, zhp->zfs_name); 845fa9e4066Sahrens break; 846fa9e4066Sahrens 847fa9e4066Sahrens case ENOENT: 848fa9e4066Sahrens zfs_error(dgettext(TEXT_DOMAIN, 849fa9e4066Sahrens "cannot open '%s': no such %s"), zhp->zfs_name, 850fa9e4066Sahrens zfs_type_to_name(zhp->zfs_type)); 851fa9e4066Sahrens break; 852fa9e4066Sahrens 853fa9e4066Sahrens case ENOSPC: 854fa9e4066Sahrens /* 855fa9e4066Sahrens * For quotas and reservations, ENOSPC indicates 856fa9e4066Sahrens * something different; setting a quota or reservation 857fa9e4066Sahrens * doesn't use any disk space. 858fa9e4066Sahrens */ 859fa9e4066Sahrens switch (prop) { 860fa9e4066Sahrens case ZFS_PROP_QUOTA: 861fa9e4066Sahrens zfs_error(dgettext(TEXT_DOMAIN, "cannot set %s " 862fa9e4066Sahrens "for '%s': size is less than current " 863fa9e4066Sahrens "used or reserved space"), propname, 864fa9e4066Sahrens zhp->zfs_name); 865fa9e4066Sahrens break; 866fa9e4066Sahrens 867fa9e4066Sahrens case ZFS_PROP_RESERVATION: 868fa9e4066Sahrens zfs_error(dgettext(TEXT_DOMAIN, "cannot set %s " 869fa9e4066Sahrens "for '%s': size is greater than available " 870fa9e4066Sahrens "space"), propname, zhp->zfs_name); 871fa9e4066Sahrens break; 872fa9e4066Sahrens 873fa9e4066Sahrens default: 874fa9e4066Sahrens zfs_error(dgettext(TEXT_DOMAIN, 875fa9e4066Sahrens "cannot set %s for '%s': out of space"), 876fa9e4066Sahrens propname, zhp->zfs_name); 877fa9e4066Sahrens break; 878fa9e4066Sahrens } 879fa9e4066Sahrens break; 880fa9e4066Sahrens 881fa9e4066Sahrens case EBUSY: 882fa9e4066Sahrens if (prop == ZFS_PROP_VOLBLOCKSIZE) { 883fa9e4066Sahrens zfs_error(dgettext(TEXT_DOMAIN, 884fa9e4066Sahrens "cannot set %s for '%s': " 885fa9e4066Sahrens "volume already contains data"), 886fa9e4066Sahrens propname, zhp->zfs_name); 887fa9e4066Sahrens } else { 888fa9e4066Sahrens zfs_baderror(errno); 889fa9e4066Sahrens } 890fa9e4066Sahrens break; 891fa9e4066Sahrens 892fa9e4066Sahrens case EOVERFLOW: 893fa9e4066Sahrens /* 894fa9e4066Sahrens * This platform can't address a volume this big. 895fa9e4066Sahrens */ 896fa9e4066Sahrens #ifdef _ILP32 897fa9e4066Sahrens if (prop == ZFS_PROP_VOLSIZE) { 898fa9e4066Sahrens zfs_error(dgettext(TEXT_DOMAIN, 899fa9e4066Sahrens "cannot set %s for '%s': " 900fa9e4066Sahrens "max volume size is 1TB on 32-bit systems"), 901fa9e4066Sahrens propname, zhp->zfs_name); 902fa9e4066Sahrens break; 903fa9e4066Sahrens } 904fa9e4066Sahrens #endif 905fa9e4066Sahrens zfs_baderror(errno); 906fa9e4066Sahrens default: 907fa9e4066Sahrens zfs_baderror(errno); 908fa9e4066Sahrens } 909fa9e4066Sahrens } else { 910fa9e4066Sahrens /* 911fa9e4066Sahrens * Refresh the statistics so the new property value 912fa9e4066Sahrens * is reflected. 913fa9e4066Sahrens */ 914fa9e4066Sahrens if ((ret = changelist_postfix(cl)) != 0) 915fa9e4066Sahrens goto error; 916fa9e4066Sahrens 917fa9e4066Sahrens (void) get_stats(zhp); 918fa9e4066Sahrens } 919fa9e4066Sahrens 920fa9e4066Sahrens error: 921fa9e4066Sahrens changelist_free(cl); 922fa9e4066Sahrens return (ret); 923fa9e4066Sahrens } 924fa9e4066Sahrens 925fa9e4066Sahrens /* 926fa9e4066Sahrens * Given a property, inherit the value from the parent dataset. 927fa9e4066Sahrens */ 928fa9e4066Sahrens int 929fa9e4066Sahrens zfs_prop_inherit(zfs_handle_t *zhp, zfs_prop_t prop) 930fa9e4066Sahrens { 931fa9e4066Sahrens const char *propname = zfs_prop_to_name(prop); 932fa9e4066Sahrens zfs_cmd_t zc = { 0 }; 933fa9e4066Sahrens int ret; 934fa9e4066Sahrens prop_changelist_t *cl; 935fa9e4066Sahrens 936fa9e4066Sahrens /* 937fa9e4066Sahrens * Verify that this property is inheritable. 938fa9e4066Sahrens */ 939fa9e4066Sahrens if (zfs_prop_readonly(prop)) { 940fa9e4066Sahrens zfs_error(dgettext(TEXT_DOMAIN, 941fa9e4066Sahrens "cannot inherit %s for '%s': property is read-only"), 942fa9e4066Sahrens propname, zhp->zfs_name); 943fa9e4066Sahrens return (-1); 944fa9e4066Sahrens } 945fa9e4066Sahrens 946fa9e4066Sahrens if (!zfs_prop_inheritable(prop)) { 947fa9e4066Sahrens zfs_error(dgettext(TEXT_DOMAIN, 948fa9e4066Sahrens "cannot inherit %s for '%s': property is not inheritable"), 949fa9e4066Sahrens propname, zhp->zfs_name); 950fa9e4066Sahrens return (-1); 951fa9e4066Sahrens } 952fa9e4066Sahrens 953fa9e4066Sahrens /* 954fa9e4066Sahrens * Check to see if the value applies to this type 955fa9e4066Sahrens */ 956fa9e4066Sahrens if (!zfs_prop_valid_for_type(prop, zhp->zfs_type)) { 957fa9e4066Sahrens zfs_error(dgettext(TEXT_DOMAIN, 958fa9e4066Sahrens "cannot inherit %s for '%s': property does " 959fa9e4066Sahrens "not apply to %ss"), propname, zhp->zfs_name, 960fa9e4066Sahrens zfs_type_to_name(zhp->zfs_type)); 961fa9e4066Sahrens return (-1); 962fa9e4066Sahrens } 963fa9e4066Sahrens 964fa9e4066Sahrens (void) strlcpy(zc.zc_name, zhp->zfs_name, sizeof (zc.zc_name)); 965fa9e4066Sahrens (void) strlcpy(zc.zc_prop_name, propname, sizeof (zc.zc_prop_name)); 966fa9e4066Sahrens 967fa9e4066Sahrens if (prop == ZFS_PROP_MOUNTPOINT && getzoneid() == GLOBAL_ZONEID && 968fa9e4066Sahrens zfs_prop_get_int(zhp, ZFS_PROP_ZONED)) { 969fa9e4066Sahrens zfs_error(dgettext(TEXT_DOMAIN, "cannot inherit %s for '%s', " 970fa9e4066Sahrens "dataset is used in a non-global zone"), propname, 971fa9e4066Sahrens zhp->zfs_name); 972fa9e4066Sahrens return (-1); 973fa9e4066Sahrens } 974fa9e4066Sahrens 975fa9e4066Sahrens /* 976fa9e4066Sahrens * Determine datasets which will be affected by this change, if any. 977fa9e4066Sahrens */ 978fa9e4066Sahrens if ((cl = changelist_gather(zhp, prop, 0)) == NULL) 979fa9e4066Sahrens return (-1); 980fa9e4066Sahrens 981fa9e4066Sahrens if (prop == ZFS_PROP_MOUNTPOINT && changelist_haszonedchild(cl)) { 982fa9e4066Sahrens zfs_error(dgettext(TEXT_DOMAIN, "cannot inherit %s for '%s', " 983fa9e4066Sahrens "child dataset with inherited mountpoint is " 984fa9e4066Sahrens "used in a non-global zone"), 985fa9e4066Sahrens propname, zhp->zfs_name); 986fa9e4066Sahrens ret = -1; 987fa9e4066Sahrens goto error; 988fa9e4066Sahrens } 989fa9e4066Sahrens 990fa9e4066Sahrens if ((ret = changelist_prefix(cl)) != 0) 991fa9e4066Sahrens goto error; 992fa9e4066Sahrens 993fa9e4066Sahrens zc.zc_numints = 0; 994fa9e4066Sahrens 995fa9e4066Sahrens if ((ret = ioctl(zfs_fd, ZFS_IOC_SET_PROP, &zc)) != 0) { 996fa9e4066Sahrens switch (errno) { 997fa9e4066Sahrens case EPERM: 998fa9e4066Sahrens zfs_error(dgettext(TEXT_DOMAIN, 999fa9e4066Sahrens "cannot inherit %s for '%s': permission " 1000fa9e4066Sahrens "denied"), propname, zhp->zfs_name); 1001fa9e4066Sahrens break; 1002fa9e4066Sahrens case ENOENT: 1003fa9e4066Sahrens zfs_error(dgettext(TEXT_DOMAIN, 1004fa9e4066Sahrens "cannot open '%s': no such %s"), zhp->zfs_name, 1005fa9e4066Sahrens zfs_type_to_name(zhp->zfs_type)); 1006fa9e4066Sahrens break; 1007fa9e4066Sahrens case ENOSPC: 1008fa9e4066Sahrens zfs_error(dgettext(TEXT_DOMAIN, 1009fa9e4066Sahrens "cannot inherit %s for '%s': " 1010fa9e4066Sahrens "out of space"), propname, zhp->zfs_name); 1011fa9e4066Sahrens break; 1012fa9e4066Sahrens default: 1013fa9e4066Sahrens zfs_baderror(errno); 1014fa9e4066Sahrens } 1015fa9e4066Sahrens 1016fa9e4066Sahrens } else { 1017fa9e4066Sahrens 1018fa9e4066Sahrens if ((ret = changelist_postfix(cl)) != 0) 1019fa9e4066Sahrens goto error; 1020fa9e4066Sahrens 1021fa9e4066Sahrens /* 1022fa9e4066Sahrens * Refresh the statistics so the new property is reflected. 1023fa9e4066Sahrens */ 1024fa9e4066Sahrens (void) get_stats(zhp); 1025fa9e4066Sahrens } 1026fa9e4066Sahrens 1027fa9e4066Sahrens 1028fa9e4066Sahrens error: 1029fa9e4066Sahrens changelist_free(cl); 1030fa9e4066Sahrens return (ret); 1031fa9e4066Sahrens } 1032fa9e4066Sahrens 1033fa9e4066Sahrens static void 1034fa9e4066Sahrens nicebool(int value, char *buf, size_t buflen) 1035fa9e4066Sahrens { 1036fa9e4066Sahrens if (value) 1037fa9e4066Sahrens (void) strlcpy(buf, "on", buflen); 1038fa9e4066Sahrens else 1039fa9e4066Sahrens (void) strlcpy(buf, "off", buflen); 1040fa9e4066Sahrens } 1041fa9e4066Sahrens 1042fa9e4066Sahrens /* 1043fa9e4066Sahrens * Internal function for getting a numeric property. Both zfs_prop_get() and 1044fa9e4066Sahrens * zfs_prop_get_int() are built using this interface. 1045fa9e4066Sahrens * 1046fa9e4066Sahrens * Certain properties can be overridden using 'mount -o'. In this case, scan 1047fa9e4066Sahrens * the contents of the /etc/mnttab entry, searching for the appropriate options. 1048fa9e4066Sahrens * If they differ from the on-disk values, report the current values and mark 1049fa9e4066Sahrens * the source "temporary". 1050fa9e4066Sahrens */ 1051fa9e4066Sahrens static uint64_t 1052fa9e4066Sahrens get_numeric_property(zfs_handle_t *zhp, zfs_prop_t prop, zfs_source_t *src, 1053fa9e4066Sahrens char **source) 1054fa9e4066Sahrens { 1055fa9e4066Sahrens uint64_t val; 1056fa9e4066Sahrens struct mnttab mnt; 1057fa9e4066Sahrens 1058fa9e4066Sahrens *source = NULL; 1059fa9e4066Sahrens 1060fa9e4066Sahrens if (zhp->zfs_mntopts == NULL) 1061fa9e4066Sahrens mnt.mnt_mntopts = ""; 1062fa9e4066Sahrens else 1063fa9e4066Sahrens mnt.mnt_mntopts = zhp->zfs_mntopts; 1064fa9e4066Sahrens 1065fa9e4066Sahrens switch (prop) { 1066fa9e4066Sahrens case ZFS_PROP_ATIME: 1067fa9e4066Sahrens *source = zhp->zfs_zplstats.zs_atime_setpoint; 1068fa9e4066Sahrens val = zhp->zfs_zplstats.zs_devices; 1069fa9e4066Sahrens 1070fa9e4066Sahrens if (hasmntopt(&mnt, MNTOPT_ATIME) && !val) { 1071fa9e4066Sahrens val = TRUE; 1072fa9e4066Sahrens if (src) 1073fa9e4066Sahrens *src = ZFS_SRC_TEMPORARY; 1074fa9e4066Sahrens } else if (hasmntopt(&mnt, MNTOPT_NOATIME) && val) { 1075fa9e4066Sahrens val = FALSE; 1076fa9e4066Sahrens if (src) 1077fa9e4066Sahrens *src = ZFS_SRC_TEMPORARY; 1078fa9e4066Sahrens } 1079fa9e4066Sahrens return (zhp->zfs_zplstats.zs_atime); 1080fa9e4066Sahrens 1081fa9e4066Sahrens case ZFS_PROP_AVAILABLE: 1082fa9e4066Sahrens return (zhp->zfs_dmustats.dds_available); 1083fa9e4066Sahrens 1084fa9e4066Sahrens case ZFS_PROP_DEVICES: 1085fa9e4066Sahrens *source = zhp->zfs_zplstats.zs_devices_setpoint; 1086fa9e4066Sahrens val = zhp->zfs_zplstats.zs_devices; 1087fa9e4066Sahrens 1088fa9e4066Sahrens if (hasmntopt(&mnt, MNTOPT_DEVICES) && !val) { 1089fa9e4066Sahrens val = TRUE; 1090fa9e4066Sahrens if (src) 1091fa9e4066Sahrens *src = ZFS_SRC_TEMPORARY; 1092fa9e4066Sahrens } else if (hasmntopt(&mnt, MNTOPT_NODEVICES) && val) { 1093fa9e4066Sahrens val = FALSE; 1094fa9e4066Sahrens if (src) 1095fa9e4066Sahrens *src = ZFS_SRC_TEMPORARY; 1096fa9e4066Sahrens } 1097fa9e4066Sahrens return (val); 1098fa9e4066Sahrens 1099fa9e4066Sahrens case ZFS_PROP_EXEC: 1100fa9e4066Sahrens *source = zhp->zfs_zplstats.zs_exec_setpoint; 1101fa9e4066Sahrens val = zhp->zfs_zplstats.zs_exec; 1102fa9e4066Sahrens 1103fa9e4066Sahrens if (hasmntopt(&mnt, MNTOPT_EXEC) && !val) { 1104fa9e4066Sahrens val = TRUE; 1105fa9e4066Sahrens if (src) 1106fa9e4066Sahrens *src = ZFS_SRC_TEMPORARY; 1107fa9e4066Sahrens } else if (hasmntopt(&mnt, MNTOPT_NOEXEC) && val) { 1108fa9e4066Sahrens val = FALSE; 1109fa9e4066Sahrens if (src) 1110fa9e4066Sahrens *src = ZFS_SRC_TEMPORARY; 1111fa9e4066Sahrens } 1112fa9e4066Sahrens return (val); 1113fa9e4066Sahrens 1114fa9e4066Sahrens case ZFS_PROP_RECORDSIZE: 1115fa9e4066Sahrens *source = zhp->zfs_zplstats.zs_recordsize_setpoint; 1116fa9e4066Sahrens return (zhp->zfs_zplstats.zs_recordsize); 1117fa9e4066Sahrens 1118fa9e4066Sahrens case ZFS_PROP_COMPRESSION: 1119fa9e4066Sahrens *source = zhp->zfs_dmustats.dds_compression_setpoint; 1120fa9e4066Sahrens return (zhp->zfs_dmustats.dds_compression); 1121fa9e4066Sahrens 1122fa9e4066Sahrens case ZFS_PROP_READONLY: 1123fa9e4066Sahrens *source = zhp->zfs_zplstats.zs_readonly_setpoint; 1124fa9e4066Sahrens val = zhp->zfs_zplstats.zs_readonly; 1125fa9e4066Sahrens 1126fa9e4066Sahrens if (hasmntopt(&mnt, MNTOPT_RO) && !val) { 1127fa9e4066Sahrens val = TRUE; 1128fa9e4066Sahrens if (src) 1129fa9e4066Sahrens *src = ZFS_SRC_TEMPORARY; 1130fa9e4066Sahrens } else if (hasmntopt(&mnt, MNTOPT_RW) && val) { 1131fa9e4066Sahrens val = FALSE; 1132fa9e4066Sahrens if (src) 1133fa9e4066Sahrens *src = ZFS_SRC_TEMPORARY; 1134fa9e4066Sahrens } 1135fa9e4066Sahrens return (val); 1136fa9e4066Sahrens 1137fa9e4066Sahrens case ZFS_PROP_QUOTA: 1138fa9e4066Sahrens if (zhp->zfs_dmustats.dds_quota == 0) 1139fa9e4066Sahrens *source = ""; /* default */ 1140fa9e4066Sahrens else 1141fa9e4066Sahrens *source = zhp->zfs_name; 1142fa9e4066Sahrens return (zhp->zfs_dmustats.dds_quota); 1143fa9e4066Sahrens 1144fa9e4066Sahrens case ZFS_PROP_RESERVATION: 1145fa9e4066Sahrens if (zhp->zfs_dmustats.dds_reserved == 0) 1146fa9e4066Sahrens *source = ""; /* default */ 1147fa9e4066Sahrens else 1148fa9e4066Sahrens *source = zhp->zfs_name; 1149fa9e4066Sahrens return (zhp->zfs_dmustats.dds_reserved); 1150fa9e4066Sahrens 1151fa9e4066Sahrens case ZFS_PROP_COMPRESSRATIO: 1152fa9e4066Sahrens /* 1153fa9e4066Sahrens * Using physical space and logical space, calculate the 1154fa9e4066Sahrens * compression ratio. We return the number as a multiple of 1155fa9e4066Sahrens * 100, so '2.5x' would be returned as 250. 1156fa9e4066Sahrens */ 1157fa9e4066Sahrens if (zhp->zfs_dmustats.dds_compressed_bytes == 0) 1158fa9e4066Sahrens return (100ULL); 1159fa9e4066Sahrens else 1160fa9e4066Sahrens return (zhp->zfs_dmustats.dds_uncompressed_bytes * 100 / 1161fa9e4066Sahrens zhp->zfs_dmustats.dds_compressed_bytes); 1162fa9e4066Sahrens 1163fa9e4066Sahrens case ZFS_PROP_REFERENCED: 1164fa9e4066Sahrens /* 1165fa9e4066Sahrens * 'referenced' refers to the amount of physical space 1166fa9e4066Sahrens * referenced (possibly shared) by this object. 1167fa9e4066Sahrens */ 1168fa9e4066Sahrens return (zhp->zfs_dmustats.dds_space_refd); 1169fa9e4066Sahrens 1170fa9e4066Sahrens case ZFS_PROP_SETUID: 1171fa9e4066Sahrens *source = zhp->zfs_zplstats.zs_setuid_setpoint; 1172fa9e4066Sahrens val = zhp->zfs_zplstats.zs_setuid; 1173fa9e4066Sahrens 1174fa9e4066Sahrens if (hasmntopt(&mnt, MNTOPT_SETUID) && !val) { 1175fa9e4066Sahrens val = TRUE; 1176fa9e4066Sahrens if (src) 1177fa9e4066Sahrens *src = ZFS_SRC_TEMPORARY; 1178fa9e4066Sahrens } else if (hasmntopt(&mnt, MNTOPT_NOSETUID) && val) { 1179fa9e4066Sahrens val = FALSE; 1180fa9e4066Sahrens if (src) 1181fa9e4066Sahrens *src = ZFS_SRC_TEMPORARY; 1182fa9e4066Sahrens } 1183fa9e4066Sahrens return (val); 1184fa9e4066Sahrens 1185fa9e4066Sahrens case ZFS_PROP_VOLSIZE: 1186fa9e4066Sahrens return (zhp->zfs_volsize); 1187fa9e4066Sahrens 1188fa9e4066Sahrens case ZFS_PROP_VOLBLOCKSIZE: 1189fa9e4066Sahrens return (zhp->zfs_volblocksize); 1190fa9e4066Sahrens 1191fa9e4066Sahrens case ZFS_PROP_ZONED: 1192fa9e4066Sahrens *source = zhp->zfs_dmustats.dds_zoned_setpoint; 1193fa9e4066Sahrens return (zhp->zfs_dmustats.dds_zoned); 1194fa9e4066Sahrens 1195fa9e4066Sahrens case ZFS_PROP_USED: 1196fa9e4066Sahrens return (zhp->zfs_dmustats.dds_space_used); 1197fa9e4066Sahrens 1198fa9e4066Sahrens case ZFS_PROP_CREATETXG: 1199fa9e4066Sahrens return (zhp->zfs_dmustats.dds_creation_txg); 1200fa9e4066Sahrens 1201fa9e4066Sahrens case ZFS_PROP_MOUNTED: 1202fa9e4066Sahrens /* 1203fa9e4066Sahrens * Unlike other properties, we defer calculation of 'MOUNTED' 1204fa9e4066Sahrens * until actually requested. This is because the getmntany() 1205fa9e4066Sahrens * call can be extremely expensive on systems with a large 1206fa9e4066Sahrens * number of filesystems, and the property isn't needed in 1207fa9e4066Sahrens * normal use cases. 1208fa9e4066Sahrens */ 1209fa9e4066Sahrens if (zhp->zfs_mntopts == NULL) { 1210fa9e4066Sahrens struct mnttab search = { 0 }, entry; 1211fa9e4066Sahrens 1212fa9e4066Sahrens search.mnt_special = (char *)zhp->zfs_name; 1213fa9e4066Sahrens rewind(mnttab_file); 1214fa9e4066Sahrens 1215fa9e4066Sahrens if (getmntany(mnttab_file, &entry, &search) == 0) 1216fa9e4066Sahrens zhp->zfs_mntopts = 1217fa9e4066Sahrens zfs_strdup(entry.mnt_mntopts); 1218fa9e4066Sahrens } 1219fa9e4066Sahrens return (zhp->zfs_mntopts != NULL); 1220fa9e4066Sahrens 1221fa9e4066Sahrens default: 1222fa9e4066Sahrens zfs_baderror(EINVAL); 1223fa9e4066Sahrens } 1224fa9e4066Sahrens 1225fa9e4066Sahrens return (0); 1226fa9e4066Sahrens } 1227fa9e4066Sahrens 1228fa9e4066Sahrens /* 1229fa9e4066Sahrens * Calculate the source type, given the raw source string. 1230fa9e4066Sahrens */ 1231fa9e4066Sahrens static void 1232fa9e4066Sahrens get_source(zfs_handle_t *zhp, zfs_source_t *srctype, char *source, 1233fa9e4066Sahrens char *statbuf, size_t statlen) 1234fa9e4066Sahrens { 1235fa9e4066Sahrens if (statbuf == NULL || *srctype == ZFS_SRC_TEMPORARY) 1236fa9e4066Sahrens return; 1237fa9e4066Sahrens 1238fa9e4066Sahrens if (source == NULL) { 1239fa9e4066Sahrens *srctype = ZFS_SRC_NONE; 1240fa9e4066Sahrens } else if (source[0] == '\0') { 1241fa9e4066Sahrens *srctype = ZFS_SRC_DEFAULT; 1242fa9e4066Sahrens } else { 1243fa9e4066Sahrens if (strcmp(source, zhp->zfs_name) == 0) { 1244fa9e4066Sahrens *srctype = ZFS_SRC_LOCAL; 1245fa9e4066Sahrens } else { 1246fa9e4066Sahrens (void) strlcpy(statbuf, source, statlen); 1247fa9e4066Sahrens *srctype = ZFS_SRC_INHERITED; 1248fa9e4066Sahrens } 1249fa9e4066Sahrens } 1250fa9e4066Sahrens 1251fa9e4066Sahrens } 1252fa9e4066Sahrens 1253fa9e4066Sahrens /* 1254fa9e4066Sahrens * Retrieve a property from the given object. If 'literal' is specified, then 1255fa9e4066Sahrens * numbers are left as exact values. Otherwise, numbers are converted to a 1256fa9e4066Sahrens * human-readable form. 1257fa9e4066Sahrens * 1258fa9e4066Sahrens * Returns 0 on success, or -1 on error. 1259fa9e4066Sahrens */ 1260fa9e4066Sahrens int 1261fa9e4066Sahrens zfs_prop_get(zfs_handle_t *zhp, zfs_prop_t prop, char *propbuf, size_t proplen, 1262fa9e4066Sahrens zfs_source_t *src, char *statbuf, size_t statlen, int literal) 1263fa9e4066Sahrens { 1264fa9e4066Sahrens char *source = NULL; 1265fa9e4066Sahrens uint64_t val; 1266fa9e4066Sahrens char *str; 1267fa9e4066Sahrens int i; 1268fa9e4066Sahrens const char *root; 1269fa9e4066Sahrens 1270fa9e4066Sahrens /* 1271fa9e4066Sahrens * Check to see if this property applies to our object 1272fa9e4066Sahrens */ 1273fa9e4066Sahrens if (!zfs_prop_valid_for_type(prop, zhp->zfs_type)) 1274fa9e4066Sahrens return (-1); 1275fa9e4066Sahrens 1276fa9e4066Sahrens if (src) 1277fa9e4066Sahrens *src = ZFS_SRC_NONE; 1278fa9e4066Sahrens 1279fa9e4066Sahrens switch (prop) { 1280fa9e4066Sahrens case ZFS_PROP_ATIME: 1281fa9e4066Sahrens case ZFS_PROP_READONLY: 1282fa9e4066Sahrens case ZFS_PROP_SETUID: 1283fa9e4066Sahrens case ZFS_PROP_ZONED: 1284fa9e4066Sahrens case ZFS_PROP_DEVICES: 1285fa9e4066Sahrens case ZFS_PROP_EXEC: 1286fa9e4066Sahrens /* 1287fa9e4066Sahrens * Basic boolean values are built on top of 1288fa9e4066Sahrens * get_numeric_property(). 1289fa9e4066Sahrens */ 1290fa9e4066Sahrens nicebool(get_numeric_property(zhp, prop, src, &source), 1291fa9e4066Sahrens propbuf, proplen); 1292fa9e4066Sahrens 1293fa9e4066Sahrens break; 1294fa9e4066Sahrens 1295fa9e4066Sahrens case ZFS_PROP_AVAILABLE: 1296fa9e4066Sahrens case ZFS_PROP_RECORDSIZE: 1297fa9e4066Sahrens case ZFS_PROP_CREATETXG: 1298fa9e4066Sahrens case ZFS_PROP_REFERENCED: 1299fa9e4066Sahrens case ZFS_PROP_USED: 1300fa9e4066Sahrens case ZFS_PROP_VOLSIZE: 1301fa9e4066Sahrens case ZFS_PROP_VOLBLOCKSIZE: 1302fa9e4066Sahrens /* 1303fa9e4066Sahrens * Basic numeric values are built on top of 1304fa9e4066Sahrens * get_numeric_property(). 1305fa9e4066Sahrens */ 1306fa9e4066Sahrens val = get_numeric_property(zhp, prop, src, &source); 1307fa9e4066Sahrens if (literal) 1308fa9e4066Sahrens (void) snprintf(propbuf, proplen, "%llu", val); 1309fa9e4066Sahrens else 1310fa9e4066Sahrens zfs_nicenum(val, propbuf, proplen); 1311fa9e4066Sahrens break; 1312fa9e4066Sahrens 1313fa9e4066Sahrens case ZFS_PROP_COMPRESSION: 1314fa9e4066Sahrens for (i = 0; compress_table[i].name != NULL; i++) { 1315fa9e4066Sahrens if (compress_table[i].value == 1316fa9e4066Sahrens zhp->zfs_dmustats.dds_compression) 1317fa9e4066Sahrens break; 1318fa9e4066Sahrens } 1319fa9e4066Sahrens assert(compress_table[i].name != NULL); 1320fa9e4066Sahrens (void) strlcpy(propbuf, compress_table[i].name, proplen); 1321fa9e4066Sahrens source = zhp->zfs_dmustats.dds_compression_setpoint; 1322fa9e4066Sahrens break; 1323fa9e4066Sahrens 1324fa9e4066Sahrens case ZFS_PROP_CHECKSUM: 1325fa9e4066Sahrens for (i = 0; checksum_table[i].name != NULL; i++) { 1326fa9e4066Sahrens if (checksum_table[i].value == 1327fa9e4066Sahrens zhp->zfs_dmustats.dds_checksum) 1328fa9e4066Sahrens break; 1329fa9e4066Sahrens } 1330fa9e4066Sahrens assert(checksum_table[i].name != NULL); 1331fa9e4066Sahrens (void) strlcpy(propbuf, checksum_table[i].name, proplen); 1332fa9e4066Sahrens source = zhp->zfs_dmustats.dds_checksum_setpoint; 1333fa9e4066Sahrens break; 1334fa9e4066Sahrens 1335fa9e4066Sahrens case ZFS_PROP_SNAPDIR: 1336fa9e4066Sahrens for (i = 0; snapdir_table[i].name != NULL; i++) { 1337fa9e4066Sahrens if (snapdir_table[i].value == 1338fa9e4066Sahrens zhp->zfs_zplstats.zs_snapdir) 1339fa9e4066Sahrens break; 1340fa9e4066Sahrens } 1341fa9e4066Sahrens assert(snapdir_table[i].name != NULL); 1342fa9e4066Sahrens (void) strlcpy(propbuf, snapdir_table[i].name, proplen); 1343fa9e4066Sahrens source = zhp->zfs_zplstats.zs_snapdir_setpoint; 1344fa9e4066Sahrens break; 1345fa9e4066Sahrens 1346fa9e4066Sahrens case ZFS_PROP_ACLMODE: 1347fa9e4066Sahrens for (i = 0; acl_mode_table[i].name != NULL; i++) { 1348fa9e4066Sahrens if (acl_mode_table[i].value == 1349fa9e4066Sahrens zhp->zfs_zplstats.zs_acl_mode) 1350fa9e4066Sahrens break; 1351fa9e4066Sahrens } 1352fa9e4066Sahrens assert(acl_mode_table[i].name != NULL); 1353fa9e4066Sahrens (void) strlcpy(propbuf, acl_mode_table[i].name, proplen); 1354fa9e4066Sahrens source = zhp->zfs_zplstats.zs_acl_mode_setpoint; 1355fa9e4066Sahrens break; 1356fa9e4066Sahrens 1357fa9e4066Sahrens case ZFS_PROP_ACLINHERIT: 1358fa9e4066Sahrens for (i = 0; acl_inherit_table[i].name != NULL; i++) { 1359fa9e4066Sahrens if (acl_inherit_table[i].value == 1360fa9e4066Sahrens zhp->zfs_zplstats.zs_acl_inherit) 1361fa9e4066Sahrens break; 1362fa9e4066Sahrens } 1363fa9e4066Sahrens assert(acl_inherit_table[i].name != NULL); 1364fa9e4066Sahrens (void) strlcpy(propbuf, acl_inherit_table[i].name, proplen); 1365fa9e4066Sahrens source = zhp->zfs_zplstats.zs_acl_inherit_setpoint; 1366fa9e4066Sahrens break; 1367fa9e4066Sahrens 1368fa9e4066Sahrens case ZFS_PROP_CREATION: 1369fa9e4066Sahrens /* 1370fa9e4066Sahrens * 'creation' is a time_t stored in the statistics. We convert 1371fa9e4066Sahrens * this into a string unless 'literal' is specified. 1372fa9e4066Sahrens */ 1373fa9e4066Sahrens { 1374fa9e4066Sahrens time_t time = (time_t) 1375fa9e4066Sahrens zhp->zfs_dmustats.dds_creation_time; 1376fa9e4066Sahrens struct tm t; 1377fa9e4066Sahrens 1378fa9e4066Sahrens if (literal || 1379fa9e4066Sahrens localtime_r(&time, &t) == NULL || 1380fa9e4066Sahrens strftime(propbuf, proplen, "%a %b %e %k:%M %Y", 1381fa9e4066Sahrens &t) == 0) 1382fa9e4066Sahrens (void) snprintf(propbuf, proplen, "%llu", 1383fa9e4066Sahrens zhp->zfs_dmustats.dds_creation_time); 1384fa9e4066Sahrens } 1385fa9e4066Sahrens break; 1386fa9e4066Sahrens 1387fa9e4066Sahrens case ZFS_PROP_MOUNTPOINT: 1388fa9e4066Sahrens /* 1389fa9e4066Sahrens * Getting the precise mountpoint can be tricky. 1390fa9e4066Sahrens * 1391fa9e4066Sahrens * - for 'none' or 'legacy', return those values. 1392fa9e4066Sahrens * - for default mountpoints, construct it as /zfs/<dataset> 1393fa9e4066Sahrens * - for inherited mountpoints, we want to take everything 1394fa9e4066Sahrens * after our ancestor and append it to the inherited value. 1395fa9e4066Sahrens * 1396fa9e4066Sahrens * If the pool has an alternate root, we want to prepend that 1397fa9e4066Sahrens * root to any values we return. 1398fa9e4066Sahrens */ 1399fa9e4066Sahrens root = zhp->zfs_dmustats.dds_altroot; 1400fa9e4066Sahrens 1401fa9e4066Sahrens if (zhp->zfs_zplstats.zs_mountpoint[0] == '\0') { 1402fa9e4066Sahrens (void) snprintf(propbuf, proplen, "%s/zfs/%s", 1403fa9e4066Sahrens root, zhp->zfs_name); 1404fa9e4066Sahrens } else if (zhp->zfs_zplstats.zs_mountpoint[0] == '/') { 1405fa9e4066Sahrens const char *relpath = zhp->zfs_name + 1406fa9e4066Sahrens strlen(zhp->zfs_zplstats.zs_mountpoint_setpoint); 1407fa9e4066Sahrens const char *mntpoint = zhp->zfs_zplstats.zs_mountpoint; 1408fa9e4066Sahrens 1409fa9e4066Sahrens if (relpath[0] == '/') 1410fa9e4066Sahrens relpath++; 1411fa9e4066Sahrens if (mntpoint[1] == '\0') 1412fa9e4066Sahrens mntpoint++; 1413fa9e4066Sahrens 1414fa9e4066Sahrens if (relpath[0] == '\0') 1415fa9e4066Sahrens (void) snprintf(propbuf, proplen, "%s%s", 1416fa9e4066Sahrens root, mntpoint); 1417fa9e4066Sahrens else 1418fa9e4066Sahrens (void) snprintf(propbuf, proplen, "%s%s%s%s", 1419fa9e4066Sahrens root, mntpoint, 1420fa9e4066Sahrens relpath[0] == '@' ? "" : "/", 1421fa9e4066Sahrens relpath); 1422fa9e4066Sahrens } else { 1423fa9e4066Sahrens /* 'legacy' or 'none' */ 1424fa9e4066Sahrens (void) strlcpy(propbuf, zhp->zfs_zplstats.zs_mountpoint, 1425fa9e4066Sahrens proplen); 1426fa9e4066Sahrens } 1427fa9e4066Sahrens 1428fa9e4066Sahrens source = zhp->zfs_zplstats.zs_mountpoint_setpoint; 1429fa9e4066Sahrens break; 1430fa9e4066Sahrens 1431fa9e4066Sahrens case ZFS_PROP_SHARENFS: 1432fa9e4066Sahrens (void) strlcpy(propbuf, zhp->zfs_zplstats.zs_sharenfs, proplen); 1433fa9e4066Sahrens source = zhp->zfs_zplstats.zs_sharenfs_setpoint; 1434fa9e4066Sahrens break; 1435fa9e4066Sahrens 1436fa9e4066Sahrens case ZFS_PROP_ORIGIN: 1437fa9e4066Sahrens (void) strlcpy(propbuf, zhp->zfs_dmustats.dds_clone_of, 1438fa9e4066Sahrens proplen); 1439fa9e4066Sahrens /* 1440fa9e4066Sahrens * If there is no parent at all, return failure to indicate that 1441fa9e4066Sahrens * it doesn't apply to this dataset. 1442fa9e4066Sahrens */ 1443fa9e4066Sahrens if (propbuf[0] == '\0') 1444fa9e4066Sahrens return (-1); 1445fa9e4066Sahrens break; 1446fa9e4066Sahrens 1447fa9e4066Sahrens case ZFS_PROP_QUOTA: 1448fa9e4066Sahrens case ZFS_PROP_RESERVATION: 1449fa9e4066Sahrens val = get_numeric_property(zhp, prop, src, &source); 1450fa9e4066Sahrens 1451fa9e4066Sahrens /* 1452fa9e4066Sahrens * If quota or reservation is 0, we translate this into 'none' 1453fa9e4066Sahrens * (unless literal is set), and indicate that it's the default 1454fa9e4066Sahrens * value. Otherwise, we print the number nicely and indicate 1455fa9e4066Sahrens * that its set locally. 1456fa9e4066Sahrens */ 1457fa9e4066Sahrens if (val == 0) { 1458fa9e4066Sahrens if (literal) 1459fa9e4066Sahrens (void) strlcpy(propbuf, "0", proplen); 1460fa9e4066Sahrens else 1461fa9e4066Sahrens (void) strlcpy(propbuf, "none", proplen); 1462fa9e4066Sahrens } else { 1463fa9e4066Sahrens if (literal) 1464fa9e4066Sahrens (void) snprintf(propbuf, proplen, "%llu", val); 1465fa9e4066Sahrens else 1466fa9e4066Sahrens zfs_nicenum(val, propbuf, proplen); 1467fa9e4066Sahrens } 1468fa9e4066Sahrens break; 1469fa9e4066Sahrens 1470fa9e4066Sahrens case ZFS_PROP_COMPRESSRATIO: 1471fa9e4066Sahrens val = get_numeric_property(zhp, prop, src, &source); 1472fa9e4066Sahrens (void) snprintf(propbuf, proplen, "%lld.%02lldx", val / 100, 1473fa9e4066Sahrens val % 100); 1474fa9e4066Sahrens break; 1475fa9e4066Sahrens 1476fa9e4066Sahrens case ZFS_PROP_TYPE: 1477fa9e4066Sahrens switch (zhp->zfs_type) { 1478fa9e4066Sahrens case ZFS_TYPE_FILESYSTEM: 1479fa9e4066Sahrens str = "filesystem"; 1480fa9e4066Sahrens break; 1481fa9e4066Sahrens case ZFS_TYPE_VOLUME: 1482fa9e4066Sahrens str = "volume"; 1483fa9e4066Sahrens break; 1484fa9e4066Sahrens case ZFS_TYPE_SNAPSHOT: 1485fa9e4066Sahrens str = "snapshot"; 1486fa9e4066Sahrens break; 1487fa9e4066Sahrens default: 1488fa9e4066Sahrens zfs_baderror(zhp->zfs_type); 1489fa9e4066Sahrens } 1490fa9e4066Sahrens (void) snprintf(propbuf, proplen, "%s", str); 1491fa9e4066Sahrens break; 1492fa9e4066Sahrens 1493fa9e4066Sahrens case ZFS_PROP_MOUNTED: 1494fa9e4066Sahrens /* 1495fa9e4066Sahrens * The 'mounted' property is a pseudo-property that described 1496fa9e4066Sahrens * whether the filesystem is currently mounted. Even though 1497fa9e4066Sahrens * it's a boolean value, the typical values of "on" and "off" 1498fa9e4066Sahrens * don't make sense, so we translate to "yes" and "no". 1499fa9e4066Sahrens */ 1500fa9e4066Sahrens if (get_numeric_property(zhp, ZFS_PROP_MOUNTED, src, &source)) 1501fa9e4066Sahrens (void) strlcpy(propbuf, "yes", proplen); 1502fa9e4066Sahrens else 1503fa9e4066Sahrens (void) strlcpy(propbuf, "no", proplen); 1504fa9e4066Sahrens break; 1505fa9e4066Sahrens 1506fa9e4066Sahrens case ZFS_PROP_NAME: 1507fa9e4066Sahrens /* 1508fa9e4066Sahrens * The 'name' property is a pseudo-property derived from the 1509fa9e4066Sahrens * dataset name. It is presented as a real property to simplify 1510fa9e4066Sahrens * consumers. 1511fa9e4066Sahrens */ 1512fa9e4066Sahrens (void) strlcpy(propbuf, zhp->zfs_name, proplen); 1513fa9e4066Sahrens break; 1514fa9e4066Sahrens 1515fa9e4066Sahrens default: 1516fa9e4066Sahrens zfs_baderror(EINVAL); 1517fa9e4066Sahrens } 1518fa9e4066Sahrens 1519fa9e4066Sahrens get_source(zhp, src, source, statbuf, statlen); 1520fa9e4066Sahrens 1521fa9e4066Sahrens return (0); 1522fa9e4066Sahrens } 1523fa9e4066Sahrens 1524fa9e4066Sahrens /* 1525fa9e4066Sahrens * Utility function to get the given numeric property. Does no validation that 1526fa9e4066Sahrens * the given property is the appropriate type; should only be used with 1527fa9e4066Sahrens * hard-coded property types. 1528fa9e4066Sahrens */ 1529fa9e4066Sahrens uint64_t 1530fa9e4066Sahrens zfs_prop_get_int(zfs_handle_t *zhp, zfs_prop_t prop) 1531fa9e4066Sahrens { 1532fa9e4066Sahrens char *source; 1533fa9e4066Sahrens zfs_source_t sourcetype = ZFS_SRC_NONE; 1534fa9e4066Sahrens 1535fa9e4066Sahrens return (get_numeric_property(zhp, prop, &sourcetype, &source)); 1536fa9e4066Sahrens } 1537fa9e4066Sahrens 1538fa9e4066Sahrens /* 1539fa9e4066Sahrens * Similar to zfs_prop_get(), but returns the value as an integer. 1540fa9e4066Sahrens */ 1541fa9e4066Sahrens int 1542fa9e4066Sahrens zfs_prop_get_numeric(zfs_handle_t *zhp, zfs_prop_t prop, uint64_t *value, 1543fa9e4066Sahrens zfs_source_t *src, char *statbuf, size_t statlen) 1544fa9e4066Sahrens { 1545fa9e4066Sahrens char *source; 1546fa9e4066Sahrens 1547fa9e4066Sahrens /* 1548fa9e4066Sahrens * Check to see if this property applies to our object 1549fa9e4066Sahrens */ 1550fa9e4066Sahrens if (!zfs_prop_valid_for_type(prop, zhp->zfs_type)) 1551fa9e4066Sahrens return (-1); 1552fa9e4066Sahrens 1553fa9e4066Sahrens if (src) 1554fa9e4066Sahrens *src = ZFS_SRC_NONE; 1555fa9e4066Sahrens 1556fa9e4066Sahrens *value = get_numeric_property(zhp, prop, src, &source); 1557fa9e4066Sahrens 1558fa9e4066Sahrens get_source(zhp, src, source, statbuf, statlen); 1559fa9e4066Sahrens 1560fa9e4066Sahrens return (0); 1561fa9e4066Sahrens } 1562fa9e4066Sahrens 1563fa9e4066Sahrens /* 1564fa9e4066Sahrens * Returns the name of the given zfs handle. 1565fa9e4066Sahrens */ 1566fa9e4066Sahrens const char * 1567fa9e4066Sahrens zfs_get_name(const zfs_handle_t *zhp) 1568fa9e4066Sahrens { 1569fa9e4066Sahrens return (zhp->zfs_name); 1570fa9e4066Sahrens } 1571fa9e4066Sahrens 1572fa9e4066Sahrens /* 1573fa9e4066Sahrens * Returns the type of the given zfs handle. 1574fa9e4066Sahrens */ 1575fa9e4066Sahrens zfs_type_t 1576fa9e4066Sahrens zfs_get_type(const zfs_handle_t *zhp) 1577fa9e4066Sahrens { 1578fa9e4066Sahrens return (zhp->zfs_type); 1579fa9e4066Sahrens } 1580fa9e4066Sahrens 1581fa9e4066Sahrens /* 1582fa9e4066Sahrens * Iterate over all children, datasets and snapshots. 1583fa9e4066Sahrens */ 1584fa9e4066Sahrens int 1585fa9e4066Sahrens zfs_iter_children(zfs_handle_t *zhp, zfs_iter_f func, void *data) 1586fa9e4066Sahrens { 1587fa9e4066Sahrens zfs_cmd_t zc = { 0 }; 1588fa9e4066Sahrens zfs_handle_t *nzhp; 1589fa9e4066Sahrens int ret; 1590fa9e4066Sahrens 1591fa9e4066Sahrens for ((void) strlcpy(zc.zc_name, zhp->zfs_name, sizeof (zc.zc_name)); 1592fa9e4066Sahrens ioctl(zfs_fd, ZFS_IOC_DATASET_LIST_NEXT, &zc) == 0; 1593fa9e4066Sahrens (void) strlcpy(zc.zc_name, zhp->zfs_name, sizeof (zc.zc_name))) { 1594fa9e4066Sahrens /* 1595fa9e4066Sahrens * Ignore private dataset names. 1596fa9e4066Sahrens */ 1597fa9e4066Sahrens if (dataset_name_hidden(zc.zc_name)) 1598fa9e4066Sahrens continue; 1599fa9e4066Sahrens 1600fa9e4066Sahrens /* 1601fa9e4066Sahrens * Silently ignore errors, as the only plausible explanation is 1602fa9e4066Sahrens * that the pool has since been removed. 1603fa9e4066Sahrens */ 1604fa9e4066Sahrens if ((nzhp = make_dataset_handle(zc.zc_name)) == NULL) 1605fa9e4066Sahrens continue; 1606fa9e4066Sahrens 1607fa9e4066Sahrens if ((ret = func(nzhp, data)) != 0) 1608fa9e4066Sahrens return (ret); 1609fa9e4066Sahrens } 1610fa9e4066Sahrens 1611fa9e4066Sahrens /* 1612fa9e4066Sahrens * An errno value of ESRCH indicates normal completion. If ENOENT is 1613fa9e4066Sahrens * returned, then the underlying dataset has been removed since we 1614fa9e4066Sahrens * obtained the handle. 1615fa9e4066Sahrens */ 1616fa9e4066Sahrens if (errno != ESRCH && errno != ENOENT) 1617fa9e4066Sahrens zfs_baderror(errno); 1618fa9e4066Sahrens 1619fa9e4066Sahrens bzero(&zc, sizeof (zc)); 1620fa9e4066Sahrens 1621fa9e4066Sahrens for ((void) strlcpy(zc.zc_name, zhp->zfs_name, sizeof (zc.zc_name)); 1622fa9e4066Sahrens ioctl(zfs_fd, ZFS_IOC_SNAPSHOT_LIST_NEXT, &zc) == 0; 1623fa9e4066Sahrens (void) strlcpy(zc.zc_name, zhp->zfs_name, sizeof (zc.zc_name))) { 1624fa9e4066Sahrens 1625fa9e4066Sahrens if ((nzhp = make_dataset_handle(zc.zc_name)) == NULL) 1626fa9e4066Sahrens continue; 1627fa9e4066Sahrens 1628fa9e4066Sahrens if ((ret = func(nzhp, data)) != 0) 1629fa9e4066Sahrens return (ret); 1630fa9e4066Sahrens } 1631fa9e4066Sahrens 1632fa9e4066Sahrens /* 1633fa9e4066Sahrens * An errno value of ESRCH indicates normal completion. If ENOENT is 1634fa9e4066Sahrens * returned, then the underlying dataset has been removed since we 1635fa9e4066Sahrens * obtained the handle. Silently ignore this case, and return success. 1636fa9e4066Sahrens */ 1637fa9e4066Sahrens if (errno != ESRCH && errno != ENOENT) 1638fa9e4066Sahrens zfs_baderror(errno); 1639fa9e4066Sahrens 1640fa9e4066Sahrens return (0); 1641fa9e4066Sahrens } 1642fa9e4066Sahrens 1643fa9e4066Sahrens /* 1644fa9e4066Sahrens * Given a complete name, return just the portion that refers to the parent. 1645fa9e4066Sahrens * Can return NULL if this is a pool. 1646fa9e4066Sahrens */ 1647fa9e4066Sahrens static int 1648fa9e4066Sahrens parent_name(const char *path, char *buf, size_t buflen) 1649fa9e4066Sahrens { 1650fa9e4066Sahrens char *loc; 1651fa9e4066Sahrens 1652fa9e4066Sahrens if ((loc = strrchr(path, '/')) == NULL) 1653fa9e4066Sahrens return (-1); 1654fa9e4066Sahrens 1655fa9e4066Sahrens (void) strncpy(buf, path, MIN(buflen, loc - path)); 1656fa9e4066Sahrens buf[loc - path] = '\0'; 1657fa9e4066Sahrens 1658fa9e4066Sahrens return (0); 1659fa9e4066Sahrens } 1660fa9e4066Sahrens 1661fa9e4066Sahrens /* 1662fa9e4066Sahrens * Checks to make sure that the given path has a parent, and that it exists. 1663fa9e4066Sahrens */ 1664fa9e4066Sahrens static int 1665fa9e4066Sahrens check_parents(const char *path, zfs_type_t type) 1666fa9e4066Sahrens { 1667fa9e4066Sahrens zfs_cmd_t zc = { 0 }; 1668fa9e4066Sahrens char parent[ZFS_MAXNAMELEN]; 1669fa9e4066Sahrens char *slash; 1670fa9e4066Sahrens 1671fa9e4066Sahrens /* get parent, and check to see if this is just a pool */ 1672fa9e4066Sahrens if (parent_name(path, parent, sizeof (parent)) != 0) { 1673fa9e4066Sahrens zfs_error(dgettext(TEXT_DOMAIN, 1674fa9e4066Sahrens "cannot create '%s': missing dataset name"), 1675fa9e4066Sahrens path, zfs_type_to_name(type)); 1676fa9e4066Sahrens zfs_error(dgettext(TEXT_DOMAIN, 1677fa9e4066Sahrens "use 'zpool create' to create a storage pool")); 1678fa9e4066Sahrens return (-1); 1679fa9e4066Sahrens } 1680fa9e4066Sahrens 1681fa9e4066Sahrens /* check to see if the pool exists */ 1682fa9e4066Sahrens if ((slash = strchr(parent, '/')) == NULL) 1683fa9e4066Sahrens slash = parent + strlen(parent); 1684fa9e4066Sahrens (void) strncpy(zc.zc_name, parent, slash - parent); 1685fa9e4066Sahrens zc.zc_name[slash - parent] = '\0'; 1686fa9e4066Sahrens if (ioctl(zfs_fd, ZFS_IOC_OBJSET_STATS, &zc) != 0 && 1687fa9e4066Sahrens errno == ENOENT) { 1688fa9e4066Sahrens zfs_error(dgettext(TEXT_DOMAIN, 1689fa9e4066Sahrens "cannot create '%s': no such pool '%s'"), path, zc.zc_name); 1690fa9e4066Sahrens return (-1); 1691fa9e4066Sahrens } 1692fa9e4066Sahrens 1693fa9e4066Sahrens /* check to see if the parent dataset exists */ 1694fa9e4066Sahrens (void) strlcpy(zc.zc_name, parent, sizeof (zc.zc_name)); 1695fa9e4066Sahrens if (ioctl(zfs_fd, ZFS_IOC_OBJSET_STATS, &zc) != 0) { 1696fa9e4066Sahrens switch (errno) { 1697fa9e4066Sahrens case ENOENT: 1698fa9e4066Sahrens zfs_error(dgettext(TEXT_DOMAIN, 1699fa9e4066Sahrens "cannot create '%s': parent does not exist"), path); 1700fa9e4066Sahrens return (-1); 1701fa9e4066Sahrens 1702fa9e4066Sahrens default: 1703fa9e4066Sahrens zfs_baderror(errno); 1704fa9e4066Sahrens } 1705fa9e4066Sahrens } 1706fa9e4066Sahrens 1707fa9e4066Sahrens /* we are in a non-global zone, but parent is in the global zone */ 1708fa9e4066Sahrens if (getzoneid() != GLOBAL_ZONEID && !zc.zc_objset_stats.dds_zoned) { 1709fa9e4066Sahrens zfs_error(dgettext(TEXT_DOMAIN, 1710fa9e4066Sahrens "cannot create '%s': permission denied"), path); 1711fa9e4066Sahrens return (-1); 1712fa9e4066Sahrens } 1713fa9e4066Sahrens 1714fa9e4066Sahrens /* make sure parent is a filesystem */ 1715fa9e4066Sahrens if (zc.zc_objset_stats.dds_type != DMU_OST_ZFS) { 1716fa9e4066Sahrens zfs_error(dgettext(TEXT_DOMAIN, 1717fa9e4066Sahrens "cannot create '%s': parent is not a filesystem"), 1718fa9e4066Sahrens path); 1719fa9e4066Sahrens return (-1); 1720fa9e4066Sahrens } 1721fa9e4066Sahrens 1722fa9e4066Sahrens return (0); 1723fa9e4066Sahrens } 1724fa9e4066Sahrens 1725fa9e4066Sahrens /* 1726fa9e4066Sahrens * Create a new filesystem or volume. 'sizestr' and 'blocksizestr' are used 1727fa9e4066Sahrens * only for volumes, and indicate the size and blocksize of the volume. 1728fa9e4066Sahrens */ 1729fa9e4066Sahrens int 1730fa9e4066Sahrens zfs_create(const char *path, zfs_type_t type, 1731fa9e4066Sahrens const char *sizestr, const char *blocksizestr) 1732fa9e4066Sahrens { 1733fa9e4066Sahrens char reason[64]; 1734fa9e4066Sahrens zfs_cmd_t zc = { 0 }; 1735fa9e4066Sahrens int ret; 1736fa9e4066Sahrens uint64_t size = 0; 1737fa9e4066Sahrens uint64_t blocksize = zfs_prop_default_numeric(ZFS_PROP_VOLBLOCKSIZE); 1738fa9e4066Sahrens 1739fa9e4066Sahrens /* convert sizestr into integer size */ 1740fa9e4066Sahrens if (sizestr != NULL && nicestrtonum(sizestr, &size, 1741fa9e4066Sahrens reason, sizeof (reason)) != 0) { 1742fa9e4066Sahrens zfs_error(dgettext(TEXT_DOMAIN, 1743fa9e4066Sahrens "bad volume size '%s': %s"), sizestr, reason); 1744fa9e4066Sahrens return (-1); 1745fa9e4066Sahrens } 1746fa9e4066Sahrens 1747fa9e4066Sahrens /* convert blocksizestr into integer blocksize */ 1748fa9e4066Sahrens if (blocksizestr != NULL && nicestrtonum(blocksizestr, &blocksize, 1749fa9e4066Sahrens reason, sizeof (reason)) != 0) { 1750fa9e4066Sahrens zfs_error(dgettext(TEXT_DOMAIN, 1751fa9e4066Sahrens "bad volume blocksize '%s': %s"), blocksizestr, reason); 1752fa9e4066Sahrens return (-1); 1753fa9e4066Sahrens } 1754fa9e4066Sahrens 1755fa9e4066Sahrens /* make sure the name is not too long */ 1756fa9e4066Sahrens if (strlen(path) >= ZFS_MAXNAMELEN) { 1757fa9e4066Sahrens zfs_error(dgettext(TEXT_DOMAIN, 1758fa9e4066Sahrens "cannot create '%s': %s name is too long"), 1759fa9e4066Sahrens path, zfs_type_to_name(type)); 1760fa9e4066Sahrens return (-1); 1761fa9e4066Sahrens } 1762fa9e4066Sahrens 1763fa9e4066Sahrens /* validate the path, taking care to note the extended error message */ 1764fa9e4066Sahrens if (!zfs_validate_name(path, type, reason, sizeof (reason))) { 1765fa9e4066Sahrens zfs_error(dgettext(TEXT_DOMAIN, 1766fa9e4066Sahrens "cannot create '%s': %s in %s name"), path, reason, 1767fa9e4066Sahrens zfs_type_to_name(type)); 1768fa9e4066Sahrens if (strstr(reason, "snapshot") != NULL) 1769fa9e4066Sahrens zfs_error(dgettext(TEXT_DOMAIN, 1770fa9e4066Sahrens "use 'zfs snapshot' to create a snapshot")); 1771fa9e4066Sahrens return (-1); 1772fa9e4066Sahrens } 1773fa9e4066Sahrens 1774fa9e4066Sahrens /* validate parents exist */ 1775fa9e4066Sahrens if (check_parents(path, type) != 0) 1776fa9e4066Sahrens return (-1); 1777fa9e4066Sahrens 1778fa9e4066Sahrens /* 1779fa9e4066Sahrens * The failure modes when creating a dataset of a different type over 1780fa9e4066Sahrens * one that already exists is a little strange. In particular, if you 1781fa9e4066Sahrens * try to create a dataset on top of an existing dataset, the ioctl() 1782fa9e4066Sahrens * will return ENOENT, not EEXIST. To prevent this from happening, we 1783fa9e4066Sahrens * first try to see if the dataset exists. 1784fa9e4066Sahrens */ 1785fa9e4066Sahrens (void) strlcpy(zc.zc_name, path, sizeof (zc.zc_name)); 1786fa9e4066Sahrens if (ioctl(zfs_fd, ZFS_IOC_OBJSET_STATS, &zc) == 0) { 1787fa9e4066Sahrens zfs_error(dgettext(TEXT_DOMAIN, 1788fa9e4066Sahrens "cannot create '%s': dataset exists"), path); 1789fa9e4066Sahrens return (-1); 1790fa9e4066Sahrens } 1791fa9e4066Sahrens 1792fa9e4066Sahrens if (type == ZFS_TYPE_VOLUME) 1793fa9e4066Sahrens zc.zc_objset_type = DMU_OST_ZVOL; 1794fa9e4066Sahrens else 1795fa9e4066Sahrens zc.zc_objset_type = DMU_OST_ZFS; 1796fa9e4066Sahrens 1797fa9e4066Sahrens if (type == ZFS_TYPE_VOLUME) { 1798fa9e4066Sahrens if (size == 0) { 1799fa9e4066Sahrens zfs_error(dgettext(TEXT_DOMAIN, 1800fa9e4066Sahrens "bad volume size '%s': cannot be zero"), sizestr); 1801fa9e4066Sahrens return (-1); 1802fa9e4066Sahrens } 1803fa9e4066Sahrens 1804fa9e4066Sahrens zc.zc_volsize = size; 1805fa9e4066Sahrens zc.zc_volblocksize = blocksize; 1806fa9e4066Sahrens } 1807fa9e4066Sahrens 1808fa9e4066Sahrens /* create the dataset */ 1809fa9e4066Sahrens 1810fa9e4066Sahrens ret = ioctl(zfs_fd, ZFS_IOC_CREATE, &zc); 1811fa9e4066Sahrens 1812fa9e4066Sahrens if (ret == 0 && type == ZFS_TYPE_VOLUME) 1813fa9e4066Sahrens ret = zvol_create_link(path); 1814fa9e4066Sahrens 1815fa9e4066Sahrens /* check for failure */ 1816fa9e4066Sahrens if (ret != 0) { 1817fa9e4066Sahrens char parent[ZFS_MAXNAMELEN]; 1818fa9e4066Sahrens (void) parent_name(path, parent, sizeof (parent)); 1819fa9e4066Sahrens 1820fa9e4066Sahrens switch (errno) { 1821fa9e4066Sahrens case ENOENT: 1822fa9e4066Sahrens /* 1823fa9e4066Sahrens * The parent dataset has been deleted since our 1824fa9e4066Sahrens * previous check. 1825fa9e4066Sahrens */ 1826fa9e4066Sahrens zfs_error(dgettext(TEXT_DOMAIN, 1827fa9e4066Sahrens "cannot create '%s': no such parent '%s'"), 1828fa9e4066Sahrens path, parent); 1829fa9e4066Sahrens break; 1830fa9e4066Sahrens 1831fa9e4066Sahrens case EPERM: 1832fa9e4066Sahrens /* 1833fa9e4066Sahrens * The user doesn't have permission to create a new 1834fa9e4066Sahrens * dataset here. 1835fa9e4066Sahrens */ 1836fa9e4066Sahrens zfs_error(dgettext(TEXT_DOMAIN, 1837fa9e4066Sahrens "cannot create '%s': permission denied"), path); 1838fa9e4066Sahrens break; 1839fa9e4066Sahrens 1840fa9e4066Sahrens case EDQUOT: 1841fa9e4066Sahrens case ENOSPC: 1842fa9e4066Sahrens /* 1843fa9e4066Sahrens * The parent dataset does not have enough free space 1844fa9e4066Sahrens * to create a new dataset. 1845fa9e4066Sahrens */ 1846fa9e4066Sahrens zfs_error(dgettext(TEXT_DOMAIN, 1847fa9e4066Sahrens "cannot create '%s': not enough space in '%s'"), 1848fa9e4066Sahrens path, parent); 1849fa9e4066Sahrens break; 1850fa9e4066Sahrens 1851fa9e4066Sahrens case EEXIST: 1852fa9e4066Sahrens /* 1853fa9e4066Sahrens * The target dataset already exists. We should have 1854fa9e4066Sahrens * caught this above, but there may be some unexplained 1855fa9e4066Sahrens * race condition. 1856fa9e4066Sahrens */ 1857fa9e4066Sahrens zfs_error(dgettext(TEXT_DOMAIN, 1858fa9e4066Sahrens "cannot create '%s': dataset exists"), path); 1859fa9e4066Sahrens break; 1860fa9e4066Sahrens 1861fa9e4066Sahrens case EINVAL: 1862fa9e4066Sahrens /* 1863fa9e4066Sahrens * The target dataset does not support children. 1864fa9e4066Sahrens */ 1865fa9e4066Sahrens zfs_error(dgettext(TEXT_DOMAIN, 1866fa9e4066Sahrens "cannot create '%s': children unsupported in '%s'"), 1867fa9e4066Sahrens path, parent); 1868fa9e4066Sahrens break; 1869fa9e4066Sahrens 1870fa9e4066Sahrens case EDOM: 1871fa9e4066Sahrens zfs_error(dgettext(TEXT_DOMAIN, "bad %s value '%s': " 1872fa9e4066Sahrens "must be power of 2 from %u to %uk"), 1873fa9e4066Sahrens zfs_prop_to_name(ZFS_PROP_VOLBLOCKSIZE), 1874fa9e4066Sahrens blocksizestr ? blocksizestr : "<unknown>", 1875fa9e4066Sahrens (uint_t)SPA_MINBLOCKSIZE, 1876fa9e4066Sahrens (uint_t)SPA_MAXBLOCKSIZE >> 10); 1877fa9e4066Sahrens break; 1878fa9e4066Sahrens #ifdef _ILP32 1879fa9e4066Sahrens case EOVERFLOW: 1880fa9e4066Sahrens /* 1881fa9e4066Sahrens * This platform can't address a volume this big. 1882fa9e4066Sahrens */ 1883fa9e4066Sahrens if (type == ZFS_TYPE_VOLUME) { 1884fa9e4066Sahrens zfs_error(dgettext(TEXT_DOMAIN, 1885fa9e4066Sahrens "cannot create '%s': " 1886fa9e4066Sahrens "max volume size is 1TB on 32-bit systems"), 1887fa9e4066Sahrens path); 1888fa9e4066Sahrens break; 1889fa9e4066Sahrens } 1890fa9e4066Sahrens #endif 1891fa9e4066Sahrens 1892fa9e4066Sahrens default: 1893fa9e4066Sahrens zfs_baderror(errno); 1894fa9e4066Sahrens } 1895fa9e4066Sahrens 1896fa9e4066Sahrens return (-1); 1897fa9e4066Sahrens } 1898fa9e4066Sahrens 1899fa9e4066Sahrens return (0); 1900fa9e4066Sahrens } 1901fa9e4066Sahrens 1902fa9e4066Sahrens /* 1903fa9e4066Sahrens * Destroys the given dataset. The caller must make sure that the filesystem 1904fa9e4066Sahrens * isn't mounted, and that there are no active dependents. 1905fa9e4066Sahrens */ 1906fa9e4066Sahrens int 1907fa9e4066Sahrens zfs_destroy(zfs_handle_t *zhp) 1908fa9e4066Sahrens { 1909fa9e4066Sahrens zfs_cmd_t zc = { 0 }; 1910fa9e4066Sahrens int ret; 1911fa9e4066Sahrens 1912fa9e4066Sahrens (void) strlcpy(zc.zc_name, zhp->zfs_name, sizeof (zc.zc_name)); 1913fa9e4066Sahrens 1914fa9e4066Sahrens /* 1915fa9e4066Sahrens * We use the check for 'zfs_volblocksize' instead of ZFS_TYPE_VOLUME 1916fa9e4066Sahrens * so that we do the right thing for snapshots of volumes. 1917fa9e4066Sahrens */ 1918fa9e4066Sahrens if (zhp->zfs_volblocksize != 0) { 1919fa9e4066Sahrens if (zvol_remove_link(zhp->zfs_name) != 0) 1920fa9e4066Sahrens return (-1); 1921fa9e4066Sahrens 1922fa9e4066Sahrens zc.zc_objset_type = DMU_OST_ZVOL; 1923fa9e4066Sahrens } else { 1924fa9e4066Sahrens zc.zc_objset_type = DMU_OST_ZFS; 1925fa9e4066Sahrens } 1926fa9e4066Sahrens 1927fa9e4066Sahrens ret = ioctl(zfs_fd, ZFS_IOC_DESTROY, &zc); 1928fa9e4066Sahrens 1929fa9e4066Sahrens if (ret != 0) { 1930fa9e4066Sahrens switch (errno) { 1931fa9e4066Sahrens 1932fa9e4066Sahrens case EPERM: 1933fa9e4066Sahrens /* 1934fa9e4066Sahrens * We don't have permission to destroy this dataset. 1935fa9e4066Sahrens */ 1936fa9e4066Sahrens zfs_error(dgettext(TEXT_DOMAIN, 1937fa9e4066Sahrens "cannot destroy '%s': permission denied"), 1938fa9e4066Sahrens zhp->zfs_name); 1939fa9e4066Sahrens break; 1940fa9e4066Sahrens 1941fa9e4066Sahrens case ENOENT: 1942fa9e4066Sahrens /* 1943fa9e4066Sahrens * We've hit a race condition where the dataset has been 1944fa9e4066Sahrens * destroyed since we opened it. 1945fa9e4066Sahrens */ 1946fa9e4066Sahrens zfs_error(dgettext(TEXT_DOMAIN, 1947fa9e4066Sahrens "cannot destroy '%s': no such %s"), 1948fa9e4066Sahrens zhp->zfs_name, zfs_type_to_name(zhp->zfs_type)); 1949fa9e4066Sahrens break; 1950fa9e4066Sahrens 1951fa9e4066Sahrens case EBUSY: 1952fa9e4066Sahrens /* 1953fa9e4066Sahrens * Even if we destroy all children, there is a chance we 1954fa9e4066Sahrens * can hit this case if: 1955fa9e4066Sahrens * 1956fa9e4066Sahrens * - A child dataset has since been created 1957fa9e4066Sahrens * - A filesystem is mounted 1958fa9e4066Sahrens * 1959fa9e4066Sahrens * This error message is awful, but hopefully we've 1960fa9e4066Sahrens * already caught the common cases (and aborted more 1961fa9e4066Sahrens * appropriately) before calling this function. There's 1962fa9e4066Sahrens * nothing else we can do at this point. 1963fa9e4066Sahrens */ 1964fa9e4066Sahrens zfs_error(dgettext(TEXT_DOMAIN, 1965fa9e4066Sahrens "cannot destroy '%s': %s is busy"), 1966fa9e4066Sahrens zhp->zfs_name, zfs_type_to_name(zhp->zfs_type)); 1967fa9e4066Sahrens break; 1968fa9e4066Sahrens 1969fa9e4066Sahrens default: 1970fa9e4066Sahrens zfs_baderror(errno); 1971fa9e4066Sahrens } 1972fa9e4066Sahrens 1973fa9e4066Sahrens return (-1); 1974fa9e4066Sahrens } 1975fa9e4066Sahrens 1976fa9e4066Sahrens remove_mountpoint(zhp); 1977fa9e4066Sahrens 1978fa9e4066Sahrens return (0); 1979fa9e4066Sahrens } 1980fa9e4066Sahrens 1981fa9e4066Sahrens /* 1982fa9e4066Sahrens * Clones the given dataset. The target must be of the same type as the source. 1983fa9e4066Sahrens */ 1984fa9e4066Sahrens int 1985fa9e4066Sahrens zfs_clone(zfs_handle_t *zhp, const char *target) 1986fa9e4066Sahrens { 1987fa9e4066Sahrens char reason[64]; 1988fa9e4066Sahrens zfs_cmd_t zc = { 0 }; 1989fa9e4066Sahrens char parent[ZFS_MAXNAMELEN]; 1990fa9e4066Sahrens int ret; 1991fa9e4066Sahrens 1992fa9e4066Sahrens assert(zhp->zfs_type == ZFS_TYPE_SNAPSHOT); 1993fa9e4066Sahrens 1994fa9e4066Sahrens /* validate the target name */ 1995fa9e4066Sahrens if (!zfs_validate_name(target, ZFS_TYPE_FILESYSTEM, reason, 1996fa9e4066Sahrens sizeof (reason))) { 1997fa9e4066Sahrens zfs_error(dgettext(TEXT_DOMAIN, 1998fa9e4066Sahrens "cannot create '%s': %s in filesystem name"), target, 1999fa9e4066Sahrens reason, zfs_type_to_name(ZFS_TYPE_FILESYSTEM)); 2000fa9e4066Sahrens return (-1); 2001fa9e4066Sahrens } 2002fa9e4066Sahrens 2003fa9e4066Sahrens /* validate parents exist */ 2004fa9e4066Sahrens if (check_parents(target, zhp->zfs_type) != 0) 2005fa9e4066Sahrens return (-1); 2006fa9e4066Sahrens 2007fa9e4066Sahrens (void) parent_name(target, parent, sizeof (parent)); 2008fa9e4066Sahrens 2009fa9e4066Sahrens /* do the clone */ 2010fa9e4066Sahrens if (zhp->zfs_volblocksize != 0) 2011fa9e4066Sahrens zc.zc_objset_type = DMU_OST_ZVOL; 2012fa9e4066Sahrens else 2013fa9e4066Sahrens zc.zc_objset_type = DMU_OST_ZFS; 2014fa9e4066Sahrens 2015fa9e4066Sahrens (void) strlcpy(zc.zc_name, target, sizeof (zc.zc_name)); 2016fa9e4066Sahrens (void) strlcpy(zc.zc_filename, zhp->zfs_name, sizeof (zc.zc_filename)); 2017fa9e4066Sahrens ret = ioctl(zfs_fd, ZFS_IOC_CREATE, &zc); 2018fa9e4066Sahrens 2019fa9e4066Sahrens if (ret != 0) { 2020fa9e4066Sahrens switch (errno) { 2021fa9e4066Sahrens case EPERM: 2022fa9e4066Sahrens /* 2023fa9e4066Sahrens * The user doesn't have permission to create the clone. 2024fa9e4066Sahrens */ 2025fa9e4066Sahrens zfs_error(dgettext(TEXT_DOMAIN, 2026fa9e4066Sahrens "cannot create '%s': permission denied"), 2027fa9e4066Sahrens target); 2028fa9e4066Sahrens break; 2029fa9e4066Sahrens 2030fa9e4066Sahrens case ENOENT: 2031fa9e4066Sahrens /* 2032fa9e4066Sahrens * The parent doesn't exist. We should have caught this 2033fa9e4066Sahrens * above, but there may a race condition that has since 2034fa9e4066Sahrens * destroyed the parent. 2035fa9e4066Sahrens * 2036fa9e4066Sahrens * At this point, we don't know whether it's the source 2037fa9e4066Sahrens * that doesn't exist anymore, or whether the target 2038fa9e4066Sahrens * dataset doesn't exist. 2039fa9e4066Sahrens */ 2040fa9e4066Sahrens zfs_error(dgettext(TEXT_DOMAIN, 2041fa9e4066Sahrens "cannot create '%s': no such parent '%s'"), 2042fa9e4066Sahrens target, parent); 2043fa9e4066Sahrens break; 2044fa9e4066Sahrens 2045fa9e4066Sahrens case EDQUOT: 2046fa9e4066Sahrens case ENOSPC: 2047fa9e4066Sahrens /* 2048fa9e4066Sahrens * There is not enough space in the target dataset 2049fa9e4066Sahrens */ 2050fa9e4066Sahrens zfs_error(dgettext(TEXT_DOMAIN, 2051fa9e4066Sahrens "cannot create '%s': not enough space in '%s'"), 2052fa9e4066Sahrens target, parent); 2053fa9e4066Sahrens break; 2054fa9e4066Sahrens 2055fa9e4066Sahrens case EEXIST: 2056fa9e4066Sahrens /* 2057fa9e4066Sahrens * The target already exists. 2058fa9e4066Sahrens */ 2059fa9e4066Sahrens zfs_error(dgettext(TEXT_DOMAIN, 2060fa9e4066Sahrens "cannot create '%s': dataset exists"), target); 2061fa9e4066Sahrens break; 2062fa9e4066Sahrens 2063fa9e4066Sahrens case EXDEV: 2064fa9e4066Sahrens /* 2065fa9e4066Sahrens * The source and target pools differ. 2066fa9e4066Sahrens */ 2067fa9e4066Sahrens zfs_error(dgettext(TEXT_DOMAIN, "cannot create '%s': " 2068fa9e4066Sahrens "source and target pools differ"), target); 2069fa9e4066Sahrens break; 2070fa9e4066Sahrens 2071fa9e4066Sahrens default: 2072fa9e4066Sahrens zfs_baderror(errno); 2073fa9e4066Sahrens } 2074fa9e4066Sahrens } else if (zhp->zfs_volblocksize != 0) { 2075fa9e4066Sahrens ret = zvol_create_link(target); 2076fa9e4066Sahrens } 2077fa9e4066Sahrens 2078fa9e4066Sahrens return (ret); 2079fa9e4066Sahrens } 2080fa9e4066Sahrens 2081fa9e4066Sahrens /* 2082fa9e4066Sahrens * Takes a snapshot of the given dataset 2083fa9e4066Sahrens */ 2084fa9e4066Sahrens int 2085fa9e4066Sahrens zfs_snapshot(const char *path) 2086fa9e4066Sahrens { 2087fa9e4066Sahrens char reason[64]; 2088fa9e4066Sahrens const char *delim; 2089fa9e4066Sahrens char *parent; 2090fa9e4066Sahrens zfs_handle_t *zhp; 2091fa9e4066Sahrens zfs_cmd_t zc = { 0 }; 2092fa9e4066Sahrens int ret; 2093fa9e4066Sahrens 2094fa9e4066Sahrens /* validate the snapshot name */ 2095fa9e4066Sahrens if (!zfs_validate_name(path, ZFS_TYPE_SNAPSHOT, reason, 2096fa9e4066Sahrens sizeof (reason))) { 2097fa9e4066Sahrens zfs_error(dgettext(TEXT_DOMAIN, 2098fa9e4066Sahrens "cannot snapshot '%s': %s in snapshot name"), path, 2099fa9e4066Sahrens reason); 2100fa9e4066Sahrens return (-1); 2101fa9e4066Sahrens } 2102fa9e4066Sahrens 2103fa9e4066Sahrens /* make sure we have a snapshot */ 2104fa9e4066Sahrens if ((delim = strchr(path, '@')) == NULL) { 2105fa9e4066Sahrens zfs_error(dgettext(TEXT_DOMAIN, 2106fa9e4066Sahrens "cannot snapshot '%s': missing '@' delim in snapshot " 2107fa9e4066Sahrens "name"), path); 2108fa9e4066Sahrens zfs_error(dgettext(TEXT_DOMAIN, 2109fa9e4066Sahrens "use 'zfs create' to create a filesystem")); 2110fa9e4066Sahrens return (-1); 2111fa9e4066Sahrens } 2112fa9e4066Sahrens 2113fa9e4066Sahrens /* make sure the parent exists and is of the appropriate type */ 2114fa9e4066Sahrens parent = zfs_malloc(delim - path + 1); 2115fa9e4066Sahrens (void) strncpy(parent, path, delim - path); 2116fa9e4066Sahrens parent[delim - path] = '\0'; 2117fa9e4066Sahrens 2118fa9e4066Sahrens if ((zhp = zfs_open(parent, ZFS_TYPE_FILESYSTEM | 2119fa9e4066Sahrens ZFS_TYPE_VOLUME)) == NULL) { 2120fa9e4066Sahrens free(parent); 2121fa9e4066Sahrens return (-1); 2122fa9e4066Sahrens } 2123fa9e4066Sahrens 2124fa9e4066Sahrens (void) strlcpy(zc.zc_name, path, sizeof (zc.zc_name)); 2125fa9e4066Sahrens 2126fa9e4066Sahrens if (zhp->zfs_type == ZFS_TYPE_VOLUME) 2127fa9e4066Sahrens zc.zc_objset_type = DMU_OST_ZVOL; 2128fa9e4066Sahrens else 2129fa9e4066Sahrens zc.zc_objset_type = DMU_OST_ZFS; 2130fa9e4066Sahrens 2131fa9e4066Sahrens ret = ioctl(zfs_fd, ZFS_IOC_CREATE, &zc); 2132fa9e4066Sahrens 2133fa9e4066Sahrens if (ret == 0 && zhp->zfs_type == ZFS_TYPE_VOLUME) { 2134fa9e4066Sahrens ret = zvol_create_link(path); 2135fa9e4066Sahrens if (ret != 0) 2136fa9e4066Sahrens (void) ioctl(zfs_fd, ZFS_IOC_DESTROY, &zc); 2137fa9e4066Sahrens } 2138fa9e4066Sahrens 2139fa9e4066Sahrens if (ret != 0) { 2140fa9e4066Sahrens switch (errno) { 2141fa9e4066Sahrens case EPERM: 2142fa9e4066Sahrens /* 2143fa9e4066Sahrens * User doesn't have permission to create a snapshot 2144fa9e4066Sahrens */ 2145fa9e4066Sahrens zfs_error(dgettext(TEXT_DOMAIN, "cannot create '%s': " 2146fa9e4066Sahrens "permission denied"), path); 2147fa9e4066Sahrens break; 2148fa9e4066Sahrens 2149fa9e4066Sahrens case EDQUOT: 2150fa9e4066Sahrens case ENOSPC: 2151fa9e4066Sahrens /* 2152fa9e4066Sahrens * Out of space in parent. 2153fa9e4066Sahrens */ 2154fa9e4066Sahrens zfs_error(dgettext(TEXT_DOMAIN, "cannot create '%s': " 2155fa9e4066Sahrens "not enough space in '%s'"), path, parent); 2156fa9e4066Sahrens break; 2157fa9e4066Sahrens 2158fa9e4066Sahrens case EEXIST: 2159fa9e4066Sahrens /* 2160fa9e4066Sahrens * Snapshot already exists. 2161fa9e4066Sahrens */ 2162fa9e4066Sahrens zfs_error(dgettext(TEXT_DOMAIN, "cannot create '%s': " 2163fa9e4066Sahrens "snapshot exists"), path); 2164fa9e4066Sahrens break; 2165fa9e4066Sahrens 2166fa9e4066Sahrens case ENOENT: 2167fa9e4066Sahrens /* 2168fa9e4066Sahrens * Shouldn't happen because we verified the parent 2169fa9e4066Sahrens * above. But there may be a race condition where it 2170fa9e4066Sahrens * has since been removed. 2171fa9e4066Sahrens */ 2172fa9e4066Sahrens zfs_error(dgettext(TEXT_DOMAIN, "cannot open '%s': " 2173fa9e4066Sahrens "no such %s"), parent, 2174fa9e4066Sahrens zfs_type_to_name(zhp->zfs_type)); 2175fa9e4066Sahrens break; 2176fa9e4066Sahrens 2177fa9e4066Sahrens default: 2178fa9e4066Sahrens zfs_baderror(errno); 2179fa9e4066Sahrens } 2180fa9e4066Sahrens } 2181fa9e4066Sahrens 2182fa9e4066Sahrens free(parent); 2183fa9e4066Sahrens zfs_close(zhp); 2184fa9e4066Sahrens 2185fa9e4066Sahrens return (ret); 2186fa9e4066Sahrens } 2187fa9e4066Sahrens 2188fa9e4066Sahrens /* 2189fa9e4066Sahrens * Dumps a backup of tosnap, incremental from fromsnap if it isn't NULL. 2190fa9e4066Sahrens */ 2191fa9e4066Sahrens int 2192fa9e4066Sahrens zfs_backup(zfs_handle_t *zhp_to, zfs_handle_t *zhp_from) 2193fa9e4066Sahrens { 2194fa9e4066Sahrens zfs_cmd_t zc = { 0 }; 2195fa9e4066Sahrens int ret; 2196fa9e4066Sahrens 2197fa9e4066Sahrens /* do the ioctl() */ 2198fa9e4066Sahrens (void) strlcpy(zc.zc_name, zhp_to->zfs_name, sizeof (zc.zc_name)); 2199fa9e4066Sahrens if (zhp_from) { 2200fa9e4066Sahrens (void) strlcpy(zc.zc_prop_value, zhp_from->zfs_name, 2201fa9e4066Sahrens sizeof (zc.zc_name)); 2202fa9e4066Sahrens } else { 2203fa9e4066Sahrens zc.zc_prop_value[0] = '\0'; 2204fa9e4066Sahrens } 2205fa9e4066Sahrens zc.zc_cookie = STDOUT_FILENO; 2206fa9e4066Sahrens 2207fa9e4066Sahrens ret = ioctl(zfs_fd, ZFS_IOC_SENDBACKUP, &zc); 2208fa9e4066Sahrens if (ret != 0) { 2209fa9e4066Sahrens switch (errno) { 2210fa9e4066Sahrens case EPERM: 2211fa9e4066Sahrens /* 2212fa9e4066Sahrens * User doesn't have permission to do a backup 2213fa9e4066Sahrens */ 2214fa9e4066Sahrens zfs_error(dgettext(TEXT_DOMAIN, "cannot backup '%s': " 2215fa9e4066Sahrens "permission denied"), zhp_to->zfs_name); 2216fa9e4066Sahrens break; 2217fa9e4066Sahrens 2218fa9e4066Sahrens case EXDEV: 2219fa9e4066Sahrens zfs_error(dgettext(TEXT_DOMAIN, 2220fa9e4066Sahrens "cannot do incremental backup from %s:\n" 2221fa9e4066Sahrens "it is not an earlier snapshot from the " 2222fa9e4066Sahrens "same fs as %s"), 2223fa9e4066Sahrens zhp_from->zfs_name, zhp_to->zfs_name); 2224fa9e4066Sahrens break; 2225fa9e4066Sahrens 2226fa9e4066Sahrens case ENOENT: 2227fa9e4066Sahrens /* 2228fa9e4066Sahrens * Shouldn't happen because we verified the parent 2229fa9e4066Sahrens * above. But there may be a race condition where it 2230fa9e4066Sahrens * has since been removed. 2231fa9e4066Sahrens */ 2232fa9e4066Sahrens zfs_error(dgettext(TEXT_DOMAIN, "cannot open: " 2233fa9e4066Sahrens "no such snapshot")); 2234fa9e4066Sahrens break; 2235fa9e4066Sahrens 2236fa9e4066Sahrens case EDQUOT: 2237fa9e4066Sahrens case EFBIG: 2238fa9e4066Sahrens case EIO: 2239fa9e4066Sahrens case ENOLINK: 2240fa9e4066Sahrens case ENOSPC: 2241fa9e4066Sahrens case ENOSTR: 2242fa9e4066Sahrens case ENXIO: 2243fa9e4066Sahrens case EPIPE: 2244fa9e4066Sahrens case ERANGE: 2245fa9e4066Sahrens case EFAULT: 2246fa9e4066Sahrens case EROFS: 2247fa9e4066Sahrens zfs_error(dgettext(TEXT_DOMAIN, 2248fa9e4066Sahrens "cannot write backup stream: %s"), 2249fa9e4066Sahrens strerror(errno)); 2250fa9e4066Sahrens break; 2251fa9e4066Sahrens 2252fa9e4066Sahrens case EINTR: 2253fa9e4066Sahrens zfs_error(dgettext(TEXT_DOMAIN, 2254fa9e4066Sahrens "backup failed: signal recieved")); 2255fa9e4066Sahrens break; 2256fa9e4066Sahrens 2257fa9e4066Sahrens default: 2258fa9e4066Sahrens zfs_baderror(errno); 2259fa9e4066Sahrens } 2260fa9e4066Sahrens } 2261fa9e4066Sahrens 2262fa9e4066Sahrens return (ret); 2263fa9e4066Sahrens } 2264fa9e4066Sahrens 2265fa9e4066Sahrens /* 2266fa9e4066Sahrens * Restores a backup of tosnap from stdin. 2267fa9e4066Sahrens */ 2268fa9e4066Sahrens int 2269fa9e4066Sahrens zfs_restore(const char *tosnap, int isprefix, int verbose, int dryrun) 2270fa9e4066Sahrens { 2271fa9e4066Sahrens zfs_cmd_t zc = { 0 }; 2272fa9e4066Sahrens time_t begin_time; 2273fa9e4066Sahrens int err, bytes; 2274fa9e4066Sahrens char *cp; 2275fa9e4066Sahrens dmu_replay_record_t drr; 2276fa9e4066Sahrens struct drr_begin *drrb = &zc.zc_begin_record; 2277fa9e4066Sahrens 2278fa9e4066Sahrens begin_time = time(NULL); 2279fa9e4066Sahrens 2280fa9e4066Sahrens /* trim off snapname, if any */ 2281fa9e4066Sahrens (void) strcpy(zc.zc_name, tosnap); 2282fa9e4066Sahrens cp = strchr(zc.zc_name, '@'); 2283fa9e4066Sahrens if (cp) 2284fa9e4066Sahrens *cp = '\0'; 2285fa9e4066Sahrens 2286fa9e4066Sahrens /* read in the BEGIN record */ 2287fa9e4066Sahrens cp = (char *)&drr; 2288fa9e4066Sahrens bytes = 0; 2289fa9e4066Sahrens do { 2290fa9e4066Sahrens err = read(STDIN_FILENO, cp, sizeof (drr) - bytes); 2291fa9e4066Sahrens cp += err; 2292fa9e4066Sahrens bytes += err; 2293fa9e4066Sahrens } while (err > 0); 2294fa9e4066Sahrens 2295fa9e4066Sahrens if (err < 0 || bytes != sizeof (drr)) { 2296fa9e4066Sahrens zfs_error(dgettext(TEXT_DOMAIN, 2297fa9e4066Sahrens "Can't restore: invalid backup stream " 2298fa9e4066Sahrens "(couldn't read first record)")); 2299fa9e4066Sahrens return (-1); 2300fa9e4066Sahrens } 2301fa9e4066Sahrens 2302fa9e4066Sahrens zc.zc_begin_record = drr.drr_u.drr_begin; 2303fa9e4066Sahrens 2304fa9e4066Sahrens if (drrb->drr_magic != DMU_BACKUP_MAGIC && 2305fa9e4066Sahrens drrb->drr_magic != BSWAP_64(DMU_BACKUP_MAGIC)) { 2306fa9e4066Sahrens zfs_error(dgettext(TEXT_DOMAIN, 2307fa9e4066Sahrens "Can't restore: invalid backup stream " 2308fa9e4066Sahrens "(invalid magic number)")); 2309fa9e4066Sahrens return (-1); 2310fa9e4066Sahrens } 2311fa9e4066Sahrens 2312fa9e4066Sahrens if (drrb->drr_version != DMU_BACKUP_VERSION && 2313fa9e4066Sahrens drrb->drr_version != BSWAP_64(DMU_BACKUP_VERSION)) { 2314fa9e4066Sahrens if (drrb->drr_magic == BSWAP_64(DMU_BACKUP_MAGIC)) 2315fa9e4066Sahrens drrb->drr_version = BSWAP_64(drrb->drr_version); 2316fa9e4066Sahrens zfs_error(dgettext(TEXT_DOMAIN, 2317fa9e4066Sahrens "Can't restore: only backup version 0x%llx is supported, " 2318fa9e4066Sahrens "stream is version %llx."), 2319fa9e4066Sahrens DMU_BACKUP_VERSION, drrb->drr_version); 2320fa9e4066Sahrens return (-1); 2321fa9e4066Sahrens } 2322fa9e4066Sahrens 2323fa9e4066Sahrens /* 2324fa9e4066Sahrens * Determine name of destination snapshot. 2325fa9e4066Sahrens */ 2326fa9e4066Sahrens (void) strcpy(drrb->drr_toname, tosnap); 2327fa9e4066Sahrens if (isprefix) { 2328fa9e4066Sahrens if (strchr(tosnap, '@') != NULL) { 2329fa9e4066Sahrens zfs_error(dgettext(TEXT_DOMAIN, 2330fa9e4066Sahrens "Can't restore: " 2331fa9e4066Sahrens "argument to -d must be a filesystem")); 2332fa9e4066Sahrens return (-1); 2333fa9e4066Sahrens } 2334fa9e4066Sahrens 2335fa9e4066Sahrens cp = strchr(drr.drr_u.drr_begin.drr_toname, '/'); 2336fa9e4066Sahrens if (cp == NULL) 2337fa9e4066Sahrens cp = drr.drr_u.drr_begin.drr_toname; 2338fa9e4066Sahrens else 2339fa9e4066Sahrens cp++; 2340fa9e4066Sahrens 2341fa9e4066Sahrens (void) strcat(drrb->drr_toname, "/"); 2342fa9e4066Sahrens (void) strcat(drrb->drr_toname, cp); 2343fa9e4066Sahrens } else if (strchr(tosnap, '@') == NULL) { 2344fa9e4066Sahrens /* 2345fa9e4066Sahrens * they specified just a filesystem; tack on the 2346fa9e4066Sahrens * snapname from the backup. 2347fa9e4066Sahrens */ 2348fa9e4066Sahrens cp = strchr(drr.drr_u.drr_begin.drr_toname, '@'); 2349fa9e4066Sahrens if (cp == NULL || strlen(tosnap) + strlen(cp) >= MAXNAMELEN) { 2350fa9e4066Sahrens zfs_error(dgettext(TEXT_DOMAIN, 2351fa9e4066Sahrens "Can't restore: invalid backup stream " 2352fa9e4066Sahrens "(invalid snapshot name)")); 2353fa9e4066Sahrens return (-1); 2354fa9e4066Sahrens } 2355fa9e4066Sahrens (void) strcat(drrb->drr_toname, cp); 2356fa9e4066Sahrens } 2357fa9e4066Sahrens 2358fa9e4066Sahrens if (drrb->drr_fromguid) { 2359fa9e4066Sahrens zfs_handle_t *h; 2360fa9e4066Sahrens /* incremental backup stream */ 2361fa9e4066Sahrens 2362fa9e4066Sahrens /* do the ioctl to the containing fs */ 2363fa9e4066Sahrens (void) strcpy(zc.zc_name, drrb->drr_toname); 2364fa9e4066Sahrens cp = strchr(zc.zc_name, '@'); 2365fa9e4066Sahrens *cp = '\0'; 2366fa9e4066Sahrens 2367fa9e4066Sahrens /* make sure destination fs exists */ 2368fa9e4066Sahrens h = zfs_open(zc.zc_name, ZFS_TYPE_FILESYSTEM | ZFS_TYPE_VOLUME); 2369fa9e4066Sahrens if (h == NULL) { 2370fa9e4066Sahrens zfs_error(dgettext(TEXT_DOMAIN, 2371fa9e4066Sahrens "Can't restore incrememtal backup: destination\n" 2372fa9e4066Sahrens "filesystem %s does not exist"), 2373fa9e4066Sahrens zc.zc_name); 2374fa9e4066Sahrens return (-1); 2375fa9e4066Sahrens } 2376fa9e4066Sahrens /* unmount destination fs */ 2377fa9e4066Sahrens if (!dryrun) 2378fa9e4066Sahrens (void) zfs_unmount(h, NULL, 0); 2379fa9e4066Sahrens zfs_close(h); 2380fa9e4066Sahrens 2381fa9e4066Sahrens 2382fa9e4066Sahrens } else { 2383fa9e4066Sahrens /* full backup stream */ 2384fa9e4066Sahrens 2385fa9e4066Sahrens /* do the ioctl to the containing fs's parent */ 2386fa9e4066Sahrens (void) strcpy(zc.zc_name, drrb->drr_toname); 2387fa9e4066Sahrens cp = strrchr(zc.zc_name, '/'); 2388fa9e4066Sahrens if (cp == NULL) { 2389fa9e4066Sahrens cp = strchr(zc.zc_name, '@'); 2390fa9e4066Sahrens if (cp) 2391fa9e4066Sahrens *cp = '\0'; 2392fa9e4066Sahrens zfs_error(dgettext(TEXT_DOMAIN, 2393fa9e4066Sahrens "Can't restore: destination fs %s already exists"), 2394fa9e4066Sahrens zc.zc_name); 2395fa9e4066Sahrens return (-1); 2396fa9e4066Sahrens } 2397fa9e4066Sahrens *cp = '\0'; 2398fa9e4066Sahrens 2399fa9e4066Sahrens /* make sure destination fs exists */ 2400fa9e4066Sahrens 2401fa9e4066Sahrens if (isprefix) { 2402fa9e4066Sahrens /* make sure prefix exists */ 2403fa9e4066Sahrens zfs_handle_t *h; 2404fa9e4066Sahrens 2405fa9e4066Sahrens /* make sure destination fs exists */ 2406fa9e4066Sahrens h = zfs_open(tosnap, ZFS_TYPE_FILESYSTEM | 2407fa9e4066Sahrens ZFS_TYPE_VOLUME); 2408fa9e4066Sahrens if (h == NULL) { 2409fa9e4066Sahrens zfs_error(dgettext(TEXT_DOMAIN, 2410fa9e4066Sahrens "Can't restore:" 2411fa9e4066Sahrens "filesystem %s does not exist"), 2412fa9e4066Sahrens tosnap); 2413fa9e4066Sahrens return (-1); 2414fa9e4066Sahrens } 2415fa9e4066Sahrens 2416fa9e4066Sahrens /* create any necessary ancestors up to prefix */ 2417fa9e4066Sahrens cp = zc.zc_name + strlen(tosnap) + 1; 2418fa9e4066Sahrens while (cp = strchr(cp, '/')) { 2419fa9e4066Sahrens *cp = '\0'; 2420fa9e4066Sahrens err = ioctl(zfs_fd, ZFS_IOC_CREATE, &zc); 2421fa9e4066Sahrens if (err && err != ENOENT && err != EEXIST) { 2422fa9e4066Sahrens zfs_error(dgettext(TEXT_DOMAIN, 2423fa9e4066Sahrens "Can't restore:" 2424fa9e4066Sahrens "couldn't create ancestor %s"), 2425fa9e4066Sahrens zc.zc_name); 2426fa9e4066Sahrens return (-1); 2427fa9e4066Sahrens } 2428fa9e4066Sahrens } 2429fa9e4066Sahrens } 2430fa9e4066Sahrens } 2431fa9e4066Sahrens 2432fa9e4066Sahrens (void) strcpy(zc.zc_prop_value, tosnap); 2433fa9e4066Sahrens zc.zc_cookie = STDIN_FILENO; 2434fa9e4066Sahrens zc.zc_intsz = isprefix; 2435fa9e4066Sahrens if (verbose) { 2436fa9e4066Sahrens (void) printf("%s %s backup of %s into %s\n", 2437fa9e4066Sahrens dryrun ? "would restore" : "restoring", 2438fa9e4066Sahrens drrb->drr_fromguid ? "incremental" : "full", 2439fa9e4066Sahrens drr.drr_u.drr_begin.drr_toname, 2440fa9e4066Sahrens zc.zc_begin_record.drr_toname); 2441fa9e4066Sahrens (void) fflush(stdout); 2442fa9e4066Sahrens } 2443fa9e4066Sahrens if (dryrun) 2444fa9e4066Sahrens return (0); 2445fa9e4066Sahrens err = ioctl(zfs_fd, ZFS_IOC_RECVBACKUP, &zc); 2446fa9e4066Sahrens if (err != 0) { 2447fa9e4066Sahrens switch (errno) { 2448fa9e4066Sahrens case ENODEV: 2449fa9e4066Sahrens zfs_error(dgettext(TEXT_DOMAIN, 2450fa9e4066Sahrens "Can't restore: " 2451fa9e4066Sahrens "Most recent snapshot does not " 2452fa9e4066Sahrens "match incremental backup source")); 2453fa9e4066Sahrens break; 2454fa9e4066Sahrens case ETXTBSY: 2455fa9e4066Sahrens zfs_error(dgettext(TEXT_DOMAIN, 2456fa9e4066Sahrens "Can't restore: " 2457fa9e4066Sahrens "Destination has been modified since " 2458fa9e4066Sahrens "most recent snapshot.\n" 2459fa9e4066Sahrens "Use 'zfs rollback' to discard changes.")); 2460fa9e4066Sahrens break; 2461fa9e4066Sahrens case EEXIST: 2462fa9e4066Sahrens if (drrb->drr_fromguid == 0) { 2463fa9e4066Sahrens /* it's the containing fs that exists */ 2464fa9e4066Sahrens cp = strchr(drrb->drr_toname, '@'); 2465fa9e4066Sahrens *cp = '\0'; 2466fa9e4066Sahrens } 2467fa9e4066Sahrens zfs_error(dgettext(TEXT_DOMAIN, 2468fa9e4066Sahrens "Can't restore to %s: Destination already exists"), 2469fa9e4066Sahrens drrb->drr_toname); 2470fa9e4066Sahrens break; 2471fa9e4066Sahrens case ENOENT: 2472fa9e4066Sahrens zfs_error(dgettext(TEXT_DOMAIN, 2473fa9e4066Sahrens "Can't restore: " 2474fa9e4066Sahrens "Destination does not exist")); 2475fa9e4066Sahrens break; 2476fa9e4066Sahrens case EBUSY: 2477fa9e4066Sahrens zfs_error(dgettext(TEXT_DOMAIN, 2478fa9e4066Sahrens "Can't restore: " 2479fa9e4066Sahrens "Destination is in use")); 2480fa9e4066Sahrens break; 2481fa9e4066Sahrens case ENOSPC: 2482fa9e4066Sahrens zfs_error(dgettext(TEXT_DOMAIN, 2483fa9e4066Sahrens "Can't restore: " 2484fa9e4066Sahrens "Out of space")); 2485fa9e4066Sahrens break; 2486fa9e4066Sahrens case EDQUOT: 2487fa9e4066Sahrens zfs_error(dgettext(TEXT_DOMAIN, 2488fa9e4066Sahrens "Can't restore: " 2489fa9e4066Sahrens "Quota exceeded")); 2490fa9e4066Sahrens break; 2491fa9e4066Sahrens case EINTR: 2492fa9e4066Sahrens zfs_error(dgettext(TEXT_DOMAIN, 2493fa9e4066Sahrens "Restore failed: signal recieved")); 2494fa9e4066Sahrens break; 2495fa9e4066Sahrens case EINVAL: 2496fa9e4066Sahrens zfs_error(dgettext(TEXT_DOMAIN, 2497fa9e4066Sahrens "Can't restore: " 2498fa9e4066Sahrens "invalid backup stream")); 2499fa9e4066Sahrens break; 2500fa9e4066Sahrens default: 2501fa9e4066Sahrens zfs_baderror(errno); 2502fa9e4066Sahrens } 2503fa9e4066Sahrens } 2504fa9e4066Sahrens 2505fa9e4066Sahrens /* 2506fa9e4066Sahrens * Mount or recreate the /dev links for the target filesystem. 2507fa9e4066Sahrens */ 2508fa9e4066Sahrens cp = strchr(drrb->drr_toname, '@'); 2509fa9e4066Sahrens if (cp && (err == 0 || drrb->drr_fromguid)) { 2510fa9e4066Sahrens zfs_handle_t *h; 2511fa9e4066Sahrens 2512fa9e4066Sahrens *cp = '\0'; 2513fa9e4066Sahrens h = zfs_open(drrb->drr_toname, 2514fa9e4066Sahrens ZFS_TYPE_FILESYSTEM | ZFS_TYPE_VOLUME); 2515fa9e4066Sahrens if (h) { 2516fa9e4066Sahrens if (h->zfs_type == ZFS_TYPE_FILESYSTEM) 2517fa9e4066Sahrens err = zfs_mount(h, NULL, 0); 2518fa9e4066Sahrens else 2519fa9e4066Sahrens err = zvol_create_link(h->zfs_name); 2520fa9e4066Sahrens zfs_close(h); 2521fa9e4066Sahrens } 2522fa9e4066Sahrens } 2523fa9e4066Sahrens 2524fa9e4066Sahrens /* 2525fa9e4066Sahrens * If the destination snapshot was also specified, and it was a volume, 2526fa9e4066Sahrens * make sure that the appropriate /dev link was created as well. 2527fa9e4066Sahrens */ 2528fa9e4066Sahrens if (err == 0) { 2529fa9e4066Sahrens zfs_handle_t *h; 2530fa9e4066Sahrens 2531fa9e4066Sahrens if (cp) 2532fa9e4066Sahrens *cp = '@'; 2533fa9e4066Sahrens 2534fa9e4066Sahrens h = zfs_open(drrb->drr_toname, ZFS_TYPE_SNAPSHOT | 2535fa9e4066Sahrens ZFS_TYPE_FILESYSTEM | ZFS_TYPE_VOLUME); 2536fa9e4066Sahrens if (h) { 2537fa9e4066Sahrens if (h->zfs_volblocksize) 2538fa9e4066Sahrens err = zvol_create_link(h->zfs_name); 2539fa9e4066Sahrens zfs_close(h); 2540fa9e4066Sahrens } 2541fa9e4066Sahrens } 2542fa9e4066Sahrens 2543fa9e4066Sahrens if (err) 2544fa9e4066Sahrens return (err); 2545fa9e4066Sahrens 2546fa9e4066Sahrens if (verbose) { 2547fa9e4066Sahrens char buf1[64]; 2548fa9e4066Sahrens char buf2[64]; 2549fa9e4066Sahrens uint64_t bytes = zc.zc_cookie; 2550fa9e4066Sahrens time_t delta = time(NULL) - begin_time; 2551fa9e4066Sahrens if (delta == 0) 2552fa9e4066Sahrens delta = 1; 2553fa9e4066Sahrens zfs_nicenum(bytes, buf1, sizeof (buf1)); 2554fa9e4066Sahrens zfs_nicenum(bytes/delta, buf2, sizeof (buf1)); 2555fa9e4066Sahrens 2556fa9e4066Sahrens (void) printf("restored %sb backup in %lu seconds (%sb/sec)\n", 2557fa9e4066Sahrens buf1, delta, buf2); 2558fa9e4066Sahrens } 2559fa9e4066Sahrens return (0); 2560fa9e4066Sahrens } 2561fa9e4066Sahrens 2562fa9e4066Sahrens /* 2563fa9e4066Sahrens * Rollback the given dataset to the previous snapshot. It is up to the caller 2564fa9e4066Sahrens * to verify that there is a previous snapshot available. 2565fa9e4066Sahrens */ 2566fa9e4066Sahrens int 2567fa9e4066Sahrens zfs_rollback(zfs_handle_t *zhp) 2568fa9e4066Sahrens { 2569fa9e4066Sahrens int ret; 2570fa9e4066Sahrens zfs_cmd_t zc = { 0 }; 2571fa9e4066Sahrens 2572fa9e4066Sahrens assert(zhp->zfs_type == ZFS_TYPE_FILESYSTEM || 2573fa9e4066Sahrens zhp->zfs_type == ZFS_TYPE_VOLUME); 2574fa9e4066Sahrens 2575fa9e4066Sahrens if (zhp->zfs_type == ZFS_TYPE_VOLUME && 2576fa9e4066Sahrens zvol_remove_link(zhp->zfs_name) != 0) 2577fa9e4066Sahrens return (-1); 2578fa9e4066Sahrens 2579fa9e4066Sahrens (void) strlcpy(zc.zc_name, zhp->zfs_name, sizeof (zc.zc_name)); 2580fa9e4066Sahrens 2581fa9e4066Sahrens if (zhp->zfs_volblocksize != 0) 2582fa9e4066Sahrens zc.zc_objset_type = DMU_OST_ZVOL; 2583fa9e4066Sahrens else 2584fa9e4066Sahrens zc.zc_objset_type = DMU_OST_ZFS; 2585fa9e4066Sahrens 2586fa9e4066Sahrens /* 2587fa9e4066Sahrens * We rely on the consumer to verify that there are no newer snapshots 2588fa9e4066Sahrens * for the given dataset. Given these constraints, we can simply pass 2589fa9e4066Sahrens * the name on to the ioctl() call. There is still an unlikely race 2590fa9e4066Sahrens * condition where the user has taken a snapshot since we verified that 2591fa9e4066Sahrens * this was the most recent. 2592fa9e4066Sahrens */ 2593fa9e4066Sahrens if ((ret = ioctl(zfs_fd, ZFS_IOC_ROLLBACK, &zc)) != 0) { 2594fa9e4066Sahrens switch (errno) { 2595fa9e4066Sahrens case EPERM: 2596fa9e4066Sahrens /* 2597fa9e4066Sahrens * The user doesn't have permission to rollback the 2598fa9e4066Sahrens * given dataset. 2599fa9e4066Sahrens */ 2600fa9e4066Sahrens zfs_error(dgettext(TEXT_DOMAIN, "cannot rollback '%s': " 2601fa9e4066Sahrens "permission denied"), zhp->zfs_name); 2602fa9e4066Sahrens break; 2603fa9e4066Sahrens 2604fa9e4066Sahrens case EDQUOT: 2605fa9e4066Sahrens case ENOSPC: 2606fa9e4066Sahrens /* 2607fa9e4066Sahrens * The parent dataset doesn't have enough space to 2608fa9e4066Sahrens * rollback to the last snapshot. 2609fa9e4066Sahrens */ 2610fa9e4066Sahrens { 2611fa9e4066Sahrens char parent[ZFS_MAXNAMELEN]; 2612fa9e4066Sahrens (void) parent_name(zhp->zfs_name, parent, 2613fa9e4066Sahrens sizeof (parent)); 2614fa9e4066Sahrens zfs_error(dgettext(TEXT_DOMAIN, "cannot " 2615fa9e4066Sahrens "rollback '%s': out of space"), parent); 2616fa9e4066Sahrens } 2617fa9e4066Sahrens break; 2618fa9e4066Sahrens 2619fa9e4066Sahrens case ENOENT: 2620fa9e4066Sahrens /* 2621fa9e4066Sahrens * The dataset doesn't exist. This shouldn't happen 2622fa9e4066Sahrens * except in race conditions. 2623fa9e4066Sahrens */ 2624fa9e4066Sahrens zfs_error(dgettext(TEXT_DOMAIN, "cannot rollback '%s': " 2625fa9e4066Sahrens "no such %s"), zhp->zfs_name, 2626fa9e4066Sahrens zfs_type_to_name(zhp->zfs_type)); 2627fa9e4066Sahrens break; 2628fa9e4066Sahrens 2629fa9e4066Sahrens case EBUSY: 2630fa9e4066Sahrens /* 2631fa9e4066Sahrens * The filesystem is busy. This should have been caught 2632fa9e4066Sahrens * by the caller before getting here, but there may be 2633fa9e4066Sahrens * an unexpected problem. 2634fa9e4066Sahrens */ 2635fa9e4066Sahrens zfs_error(dgettext(TEXT_DOMAIN, "cannot rollback '%s': " 2636fa9e4066Sahrens "%s is busy"), zhp->zfs_name, 2637fa9e4066Sahrens zfs_type_to_name(zhp->zfs_type)); 2638fa9e4066Sahrens break; 2639fa9e4066Sahrens 2640fa9e4066Sahrens default: 2641fa9e4066Sahrens zfs_baderror(errno); 2642fa9e4066Sahrens } 2643fa9e4066Sahrens } else if (zhp->zfs_type == ZFS_TYPE_VOLUME) { 2644fa9e4066Sahrens ret = zvol_create_link(zhp->zfs_name); 2645fa9e4066Sahrens } 2646fa9e4066Sahrens 2647fa9e4066Sahrens return (ret); 2648fa9e4066Sahrens } 2649fa9e4066Sahrens 2650fa9e4066Sahrens /* 2651fa9e4066Sahrens * Iterate over all dependents for a given dataset. This includes both 2652fa9e4066Sahrens * hierarchical dependents (children) and data dependents (snapshots and 2653fa9e4066Sahrens * clones). The bulk of the processing occurs in get_dependents() in 2654fa9e4066Sahrens * libzfs_graph.c. 2655fa9e4066Sahrens */ 2656fa9e4066Sahrens int 2657fa9e4066Sahrens zfs_iter_dependents(zfs_handle_t *zhp, zfs_iter_f func, void *data) 2658fa9e4066Sahrens { 2659fa9e4066Sahrens char **dependents; 2660fa9e4066Sahrens size_t count; 2661fa9e4066Sahrens int i; 2662fa9e4066Sahrens zfs_handle_t *child; 2663fa9e4066Sahrens int ret = 0; 2664fa9e4066Sahrens 2665fa9e4066Sahrens dependents = get_dependents(zhp->zfs_name, &count); 2666fa9e4066Sahrens for (i = 0; i < count; i++) { 2667fa9e4066Sahrens if ((child = make_dataset_handle(dependents[i])) == NULL) 2668fa9e4066Sahrens continue; 2669fa9e4066Sahrens 2670fa9e4066Sahrens if ((ret = func(child, data)) != 0) 2671fa9e4066Sahrens break; 2672fa9e4066Sahrens } 2673fa9e4066Sahrens 2674fa9e4066Sahrens for (i = 0; i < count; i++) 2675fa9e4066Sahrens free(dependents[i]); 2676fa9e4066Sahrens free(dependents); 2677fa9e4066Sahrens 2678fa9e4066Sahrens return (ret); 2679fa9e4066Sahrens } 2680fa9e4066Sahrens 2681fa9e4066Sahrens /* 2682fa9e4066Sahrens * Renames the given dataset. 2683fa9e4066Sahrens */ 2684fa9e4066Sahrens int 2685fa9e4066Sahrens zfs_rename(zfs_handle_t *zhp, const char *target) 2686fa9e4066Sahrens { 2687fa9e4066Sahrens int ret; 2688fa9e4066Sahrens zfs_cmd_t zc = { 0 }; 2689fa9e4066Sahrens char reason[64]; 2690fa9e4066Sahrens char *delim; 2691fa9e4066Sahrens prop_changelist_t *cl; 2692fa9e4066Sahrens char parent[ZFS_MAXNAMELEN]; 2693fa9e4066Sahrens 2694fa9e4066Sahrens (void) strlcpy(zc.zc_name, zhp->zfs_name, sizeof (zc.zc_name)); 2695fa9e4066Sahrens (void) strlcpy(zc.zc_prop_value, target, sizeof (zc.zc_prop_value)); 2696fa9e4066Sahrens 2697fa9e4066Sahrens /* if we have the same exact name, just return success */ 2698fa9e4066Sahrens if (strcmp(zhp->zfs_name, target) == 0) 2699fa9e4066Sahrens return (0); 2700fa9e4066Sahrens 2701fa9e4066Sahrens /* 2702fa9e4066Sahrens * Make sure the target name is valid 2703fa9e4066Sahrens */ 2704fa9e4066Sahrens if (!zfs_validate_name(target, zhp->zfs_type, reason, 2705fa9e4066Sahrens sizeof (reason))) { 2706fa9e4066Sahrens zfs_error(dgettext(TEXT_DOMAIN, 2707fa9e4066Sahrens "cannot create '%s': %s in %s name"), target, reason, 2708fa9e4066Sahrens zfs_type_to_name(zhp->zfs_type)); 2709fa9e4066Sahrens return (-1); 2710fa9e4066Sahrens } 2711fa9e4066Sahrens 2712fa9e4066Sahrens if (zhp->zfs_type == ZFS_TYPE_SNAPSHOT) { 2713fa9e4066Sahrens if ((delim = strchr(target, '@')) == NULL) { 2714fa9e4066Sahrens zfs_error(dgettext(TEXT_DOMAIN, 2715fa9e4066Sahrens "cannot rename to '%s': not a snapshot"), target); 2716fa9e4066Sahrens return (-1); 2717fa9e4066Sahrens } 2718fa9e4066Sahrens 2719fa9e4066Sahrens /* 2720fa9e4066Sahrens * Make sure we're renaming within the same dataset. 2721fa9e4066Sahrens */ 2722fa9e4066Sahrens if (strncmp(zhp->zfs_name, target, delim - target) != 0 || 2723fa9e4066Sahrens zhp->zfs_name[delim - target] != '@') { 2724fa9e4066Sahrens zfs_error(dgettext(TEXT_DOMAIN, 2725fa9e4066Sahrens "cannot rename to '%s': snapshots must be part " 2726fa9e4066Sahrens "of same dataset"), target); 2727fa9e4066Sahrens return (-1); 2728fa9e4066Sahrens } 2729fa9e4066Sahrens 2730fa9e4066Sahrens (void) strncpy(parent, target, delim - target); 2731fa9e4066Sahrens parent[delim - target] = '\0'; 2732fa9e4066Sahrens } else { 2733fa9e4066Sahrens /* validate parents */ 2734fa9e4066Sahrens if (check_parents(target, zhp->zfs_type) != 0) 2735fa9e4066Sahrens return (-1); 2736fa9e4066Sahrens 2737fa9e4066Sahrens (void) parent_name(target, parent, sizeof (parent)); 2738fa9e4066Sahrens 2739fa9e4066Sahrens /* make sure we're in the same pool */ 2740fa9e4066Sahrens verify((delim = strchr(target, '/')) != NULL); 2741fa9e4066Sahrens if (strncmp(zhp->zfs_name, target, delim - target) != 0 || 2742fa9e4066Sahrens zhp->zfs_name[delim - target] != '/') { 2743fa9e4066Sahrens zfs_error(dgettext(TEXT_DOMAIN, 2744fa9e4066Sahrens "cannot rename to '%s': " 2745fa9e4066Sahrens "datasets must be within same pool"), target); 2746fa9e4066Sahrens return (-1); 2747fa9e4066Sahrens } 2748fa9e4066Sahrens } 2749fa9e4066Sahrens 2750fa9e4066Sahrens if (getzoneid() == GLOBAL_ZONEID && 2751fa9e4066Sahrens zfs_prop_get_int(zhp, ZFS_PROP_ZONED)) { 2752fa9e4066Sahrens zfs_error(dgettext(TEXT_DOMAIN, "cannot rename %s, " 2753fa9e4066Sahrens "dataset is used in a non-global zone"), zhp->zfs_name); 2754fa9e4066Sahrens return (-1); 2755fa9e4066Sahrens } 2756fa9e4066Sahrens 2757fa9e4066Sahrens if ((cl = changelist_gather(zhp, ZFS_PROP_NAME, 0)) == NULL) 2758fa9e4066Sahrens return (1); 2759fa9e4066Sahrens 2760fa9e4066Sahrens if (changelist_haszonedchild(cl)) { 2761fa9e4066Sahrens zfs_error(dgettext(TEXT_DOMAIN, 2762fa9e4066Sahrens "cannot rename '%s': child dataset with inherited " 2763fa9e4066Sahrens "mountpoint is used in a non-global zone"), zhp->zfs_name); 2764fa9e4066Sahrens ret = -1; 2765fa9e4066Sahrens goto error; 2766fa9e4066Sahrens } 2767fa9e4066Sahrens 2768fa9e4066Sahrens if ((ret = changelist_prefix(cl)) != 0) 2769fa9e4066Sahrens goto error; 2770fa9e4066Sahrens 2771fa9e4066Sahrens if (zhp->zfs_volblocksize != 0) 2772fa9e4066Sahrens zc.zc_objset_type = DMU_OST_ZVOL; 2773fa9e4066Sahrens else 2774fa9e4066Sahrens zc.zc_objset_type = DMU_OST_ZFS; 2775fa9e4066Sahrens 2776fa9e4066Sahrens if ((ret = ioctl(zfs_fd, ZFS_IOC_RENAME, &zc)) != 0) { 2777fa9e4066Sahrens switch (errno) { 2778fa9e4066Sahrens case EPERM: 2779fa9e4066Sahrens /* 2780fa9e4066Sahrens * The user doesn't have permission to rename the 2781fa9e4066Sahrens * given dataset. 2782fa9e4066Sahrens */ 2783fa9e4066Sahrens zfs_error(dgettext(TEXT_DOMAIN, "cannot rename '%s': " 2784fa9e4066Sahrens "permission denied"), zhp->zfs_name); 2785fa9e4066Sahrens break; 2786fa9e4066Sahrens 2787fa9e4066Sahrens case EDQUOT: 2788fa9e4066Sahrens case ENOSPC: 2789fa9e4066Sahrens /* 2790fa9e4066Sahrens * Not enough space in the parent dataset. 2791fa9e4066Sahrens */ 2792fa9e4066Sahrens zfs_error(dgettext(TEXT_DOMAIN, "cannot " 2793fa9e4066Sahrens "rename '%s': not enough space in '%s'"), 2794fa9e4066Sahrens zhp->zfs_name, parent); 2795fa9e4066Sahrens break; 2796fa9e4066Sahrens 2797fa9e4066Sahrens case ENOENT: 2798fa9e4066Sahrens /* 2799fa9e4066Sahrens * The destination doesn't exist. 2800fa9e4066Sahrens */ 2801fa9e4066Sahrens zfs_error(dgettext(TEXT_DOMAIN, "cannot rename '%s' " 2802fa9e4066Sahrens "to '%s': destination doesn't exist"), 2803fa9e4066Sahrens zhp->zfs_name, target); 2804fa9e4066Sahrens break; 2805fa9e4066Sahrens 2806fa9e4066Sahrens case EEXIST: 2807fa9e4066Sahrens /* 2808fa9e4066Sahrens * The destination already exists. 2809fa9e4066Sahrens */ 2810fa9e4066Sahrens zfs_error(dgettext(TEXT_DOMAIN, "cannot rename '%s' " 2811fa9e4066Sahrens "to '%s': destination already exists"), 2812fa9e4066Sahrens zhp->zfs_name, target); 2813fa9e4066Sahrens break; 2814fa9e4066Sahrens 2815fa9e4066Sahrens case EBUSY: 2816fa9e4066Sahrens /* 2817fa9e4066Sahrens * The filesystem is busy. This should have been caught 2818fa9e4066Sahrens * by the caller before getting here, but there may be 2819fa9e4066Sahrens * an unexpected problem. 2820fa9e4066Sahrens */ 2821fa9e4066Sahrens zfs_error(dgettext(TEXT_DOMAIN, "cannot rename '%s': " 2822fa9e4066Sahrens "%s is busy"), zhp->zfs_name, 2823fa9e4066Sahrens zfs_type_to_name(zhp->zfs_type)); 2824fa9e4066Sahrens break; 2825fa9e4066Sahrens 2826fa9e4066Sahrens default: 2827fa9e4066Sahrens zfs_baderror(errno); 2828fa9e4066Sahrens } 2829fa9e4066Sahrens 2830fa9e4066Sahrens /* 2831fa9e4066Sahrens * On failure, we still want to remount any filesystems that 2832fa9e4066Sahrens * were previously mounted, so we don't alter the system state. 2833fa9e4066Sahrens */ 2834fa9e4066Sahrens (void) changelist_postfix(cl); 2835fa9e4066Sahrens } else { 2836fa9e4066Sahrens changelist_rename(cl, zfs_get_name(zhp), target); 2837fa9e4066Sahrens 2838fa9e4066Sahrens ret = changelist_postfix(cl); 2839fa9e4066Sahrens } 2840fa9e4066Sahrens 2841fa9e4066Sahrens error: 2842fa9e4066Sahrens changelist_free(cl); 2843fa9e4066Sahrens return (ret); 2844fa9e4066Sahrens } 2845fa9e4066Sahrens 2846fa9e4066Sahrens /* 2847fa9e4066Sahrens * Given a zvol dataset, issue the ioctl to create the appropriate minor node, 2848fa9e4066Sahrens * poke devfsadm to create the /dev link, and then wait for the link to appear. 2849fa9e4066Sahrens */ 2850fa9e4066Sahrens int 2851fa9e4066Sahrens zvol_create_link(const char *dataset) 2852fa9e4066Sahrens { 2853fa9e4066Sahrens zfs_cmd_t zc = { 0 }; 2854fa9e4066Sahrens di_devlink_handle_t hdl; 2855fa9e4066Sahrens 2856fa9e4066Sahrens (void) strlcpy(zc.zc_name, dataset, sizeof (zc.zc_name)); 2857fa9e4066Sahrens 2858fa9e4066Sahrens /* 2859fa9e4066Sahrens * Issue the appropriate ioctl. 2860fa9e4066Sahrens */ 2861fa9e4066Sahrens if (ioctl(zfs_fd, ZFS_IOC_CREATE_MINOR, &zc) != 0) { 2862fa9e4066Sahrens switch (errno) { 2863fa9e4066Sahrens case EPERM: 2864fa9e4066Sahrens zfs_error(dgettext(TEXT_DOMAIN, "cannot create " 2865fa9e4066Sahrens "device links for '%s': permission denied"), 2866fa9e4066Sahrens dataset); 2867fa9e4066Sahrens break; 2868fa9e4066Sahrens 2869fa9e4066Sahrens case EEXIST: 2870fa9e4066Sahrens /* 2871fa9e4066Sahrens * Silently ignore the case where the link already 2872fa9e4066Sahrens * exists. This allows 'zfs volinit' to be run multiple 2873fa9e4066Sahrens * times without errors. 2874fa9e4066Sahrens */ 2875fa9e4066Sahrens return (0); 2876fa9e4066Sahrens 2877fa9e4066Sahrens default: 2878fa9e4066Sahrens zfs_baderror(errno); 2879fa9e4066Sahrens } 2880fa9e4066Sahrens 2881fa9e4066Sahrens return (-1); 2882fa9e4066Sahrens } 2883fa9e4066Sahrens 2884fa9e4066Sahrens /* 2885fa9e4066Sahrens * Call devfsadm and wait for the links to magically appear. 2886fa9e4066Sahrens */ 2887fa9e4066Sahrens if ((hdl = di_devlink_init(ZFS_DRIVER, DI_MAKE_LINK)) == NULL) { 2888fa9e4066Sahrens zfs_error(dgettext(TEXT_DOMAIN, 2889fa9e4066Sahrens "cannot create device links for '%s'"), dataset); 2890fa9e4066Sahrens (void) ioctl(zfs_fd, ZFS_IOC_REMOVE_MINOR, &zc); 2891fa9e4066Sahrens return (-1); 2892fa9e4066Sahrens } else { 2893fa9e4066Sahrens (void) di_devlink_fini(&hdl); 2894fa9e4066Sahrens } 2895fa9e4066Sahrens 2896fa9e4066Sahrens return (0); 2897fa9e4066Sahrens } 2898fa9e4066Sahrens 2899fa9e4066Sahrens /* 2900fa9e4066Sahrens * Remove a minor node for the given zvol and the associated /dev links. 2901fa9e4066Sahrens */ 2902fa9e4066Sahrens int 2903fa9e4066Sahrens zvol_remove_link(const char *dataset) 2904fa9e4066Sahrens { 2905fa9e4066Sahrens zfs_cmd_t zc = { 0 }; 2906fa9e4066Sahrens 2907fa9e4066Sahrens (void) strlcpy(zc.zc_name, dataset, sizeof (zc.zc_name)); 2908fa9e4066Sahrens 2909fa9e4066Sahrens if (ioctl(zfs_fd, ZFS_IOC_REMOVE_MINOR, &zc) != 0) { 2910fa9e4066Sahrens switch (errno) { 2911fa9e4066Sahrens case EPERM: 2912fa9e4066Sahrens zfs_error(dgettext(TEXT_DOMAIN, "cannot remove " 2913fa9e4066Sahrens "device links for '%s': permission denied"), 2914fa9e4066Sahrens dataset); 2915fa9e4066Sahrens break; 2916fa9e4066Sahrens 2917fa9e4066Sahrens case EBUSY: 2918fa9e4066Sahrens zfs_error(dgettext(TEXT_DOMAIN, "cannot remove " 2919fa9e4066Sahrens "device links for '%s': volume is in use"), 2920fa9e4066Sahrens dataset); 2921fa9e4066Sahrens break; 2922fa9e4066Sahrens 2923fa9e4066Sahrens case ENXIO: 2924fa9e4066Sahrens /* 2925fa9e4066Sahrens * Silently ignore the case where the link no longer 2926fa9e4066Sahrens * exists, so that 'zfs volfini' can be run multiple 2927fa9e4066Sahrens * times without errors. 2928fa9e4066Sahrens */ 2929fa9e4066Sahrens return (0); 2930fa9e4066Sahrens 2931fa9e4066Sahrens default: 2932fa9e4066Sahrens zfs_baderror(errno); 2933fa9e4066Sahrens } 2934fa9e4066Sahrens 2935fa9e4066Sahrens return (-1); 2936fa9e4066Sahrens } 2937fa9e4066Sahrens 2938fa9e4066Sahrens return (0); 2939fa9e4066Sahrens } 2940