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