1fa9e4066Sahrens /* 2fa9e4066Sahrens * CDDL HEADER START 3fa9e4066Sahrens * 4fa9e4066Sahrens * The contents of this file are subject to the terms of the 5ea8dc4b6Seschrock * Common Development and Distribution License (the "License"). 6ea8dc4b6Seschrock * You may not use this file except in compliance with the License. 7fa9e4066Sahrens * 8fa9e4066Sahrens * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 9fa9e4066Sahrens * or http://www.opensolaris.org/os/licensing. 10fa9e4066Sahrens * See the License for the specific language governing permissions 11fa9e4066Sahrens * and limitations under the License. 12fa9e4066Sahrens * 13fa9e4066Sahrens * When distributing Covered Code, include this CDDL HEADER in each 14fa9e4066Sahrens * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 15fa9e4066Sahrens * If applicable, add the following below this CDDL HEADER, with the 16fa9e4066Sahrens * fields enclosed by brackets "[]" replaced with your own identifying 17fa9e4066Sahrens * information: Portions Copyright [yyyy] [name of copyright owner] 18fa9e4066Sahrens * 19fa9e4066Sahrens * CDDL HEADER END 20fa9e4066Sahrens */ 21fa9e4066Sahrens /* 226b90ca48Slling * Copyright 2006 Sun Microsystems, Inc. All rights reserved. 23fa9e4066Sahrens * Use is subject to license terms. 24fa9e4066Sahrens */ 25fa9e4066Sahrens 26fa9e4066Sahrens #pragma ident "%Z%%M% %I% %E% SMI" 27fa9e4066Sahrens 28fa9e4066Sahrens #include <assert.h> 29fa9e4066Sahrens #include <errno.h> 30fa9e4066Sahrens #include <libgen.h> 31fa9e4066Sahrens #include <libintl.h> 32fa9e4066Sahrens #include <libuutil.h> 33fa9e4066Sahrens #include <locale.h> 34fa9e4066Sahrens #include <stddef.h> 35fa9e4066Sahrens #include <stdio.h> 36fa9e4066Sahrens #include <stdlib.h> 37fa9e4066Sahrens #include <strings.h> 38fa9e4066Sahrens #include <unistd.h> 39fa9e4066Sahrens #include <fcntl.h> 40fa9e4066Sahrens #include <zone.h> 41fa9e4066Sahrens #include <sys/mkdev.h> 42fa9e4066Sahrens #include <sys/mntent.h> 43fa9e4066Sahrens #include <sys/mnttab.h> 44fa9e4066Sahrens #include <sys/mount.h> 45fa9e4066Sahrens #include <sys/stat.h> 46fa9e4066Sahrens 47fa9e4066Sahrens #include <libzfs.h> 48fa9e4066Sahrens 49fa9e4066Sahrens #include "zfs_iter.h" 50*99653d4eSeschrock #include "zfs_util.h" 51*99653d4eSeschrock 52*99653d4eSeschrock libzfs_handle_t *g_zfs; 53fa9e4066Sahrens 54fa9e4066Sahrens static FILE *mnttab_file; 55fa9e4066Sahrens 56fa9e4066Sahrens static int zfs_do_clone(int argc, char **argv); 57fa9e4066Sahrens static int zfs_do_create(int argc, char **argv); 58fa9e4066Sahrens static int zfs_do_destroy(int argc, char **argv); 59fa9e4066Sahrens static int zfs_do_get(int argc, char **argv); 60fa9e4066Sahrens static int zfs_do_inherit(int argc, char **argv); 61fa9e4066Sahrens static int zfs_do_list(int argc, char **argv); 62fa9e4066Sahrens static int zfs_do_mount(int argc, char **argv); 63fa9e4066Sahrens static int zfs_do_rename(int argc, char **argv); 64fa9e4066Sahrens static int zfs_do_rollback(int argc, char **argv); 65fa9e4066Sahrens static int zfs_do_set(int argc, char **argv); 66fa9e4066Sahrens static int zfs_do_snapshot(int argc, char **argv); 67fa9e4066Sahrens static int zfs_do_unmount(int argc, char **argv); 68fa9e4066Sahrens static int zfs_do_share(int argc, char **argv); 69fa9e4066Sahrens static int zfs_do_unshare(int argc, char **argv); 70f2a3c691Sahrens static int zfs_do_send(int argc, char **argv); 71f2a3c691Sahrens static int zfs_do_receive(int argc, char **argv); 72*99653d4eSeschrock static int zfs_do_promote(int argc, char **argv); 73fa9e4066Sahrens 74fa9e4066Sahrens /* 75fa9e4066Sahrens * These libumem hooks provide a reasonable set of defaults for the allocator's 76fa9e4066Sahrens * debugging facilities. 77fa9e4066Sahrens */ 78fa9e4066Sahrens const char * 79fa9e4066Sahrens _umem_debug_init() 80fa9e4066Sahrens { 81fa9e4066Sahrens return ("default,verbose"); /* $UMEM_DEBUG setting */ 82fa9e4066Sahrens } 83fa9e4066Sahrens 84fa9e4066Sahrens const char * 85fa9e4066Sahrens _umem_logging_init(void) 86fa9e4066Sahrens { 87fa9e4066Sahrens return ("fail,contents"); /* $UMEM_LOGGING setting */ 88fa9e4066Sahrens } 89fa9e4066Sahrens 9065cd9f28Seschrock typedef enum { 9165cd9f28Seschrock HELP_CLONE, 9265cd9f28Seschrock HELP_CREATE, 9365cd9f28Seschrock HELP_DESTROY, 9465cd9f28Seschrock HELP_GET, 9565cd9f28Seschrock HELP_INHERIT, 9665cd9f28Seschrock HELP_LIST, 9765cd9f28Seschrock HELP_MOUNT, 98*99653d4eSeschrock HELP_PROMOTE, 99f2a3c691Sahrens HELP_RECEIVE, 10065cd9f28Seschrock HELP_RENAME, 10165cd9f28Seschrock HELP_ROLLBACK, 102f2a3c691Sahrens HELP_SEND, 10365cd9f28Seschrock HELP_SET, 10465cd9f28Seschrock HELP_SHARE, 10565cd9f28Seschrock HELP_SNAPSHOT, 10665cd9f28Seschrock HELP_UNMOUNT, 10765cd9f28Seschrock HELP_UNSHARE 10865cd9f28Seschrock } zfs_help_t; 10965cd9f28Seschrock 110fa9e4066Sahrens typedef struct zfs_command { 111fa9e4066Sahrens const char *name; 112fa9e4066Sahrens int (*func)(int argc, char **argv); 11365cd9f28Seschrock zfs_help_t usage; 114fa9e4066Sahrens } zfs_command_t; 115fa9e4066Sahrens 116fa9e4066Sahrens /* 117fa9e4066Sahrens * Master command table. Each ZFS command has a name, associated function, and 118ea8dc4b6Seschrock * usage message. The usage messages need to be internationalized, so we have 119ea8dc4b6Seschrock * to have a function to return the usage message based on a command index. 12065cd9f28Seschrock * 12165cd9f28Seschrock * These commands are organized according to how they are displayed in the usage 12265cd9f28Seschrock * message. An empty command (one with a NULL name) indicates an empty line in 12365cd9f28Seschrock * the generic usage message. 124fa9e4066Sahrens */ 125fa9e4066Sahrens static zfs_command_t command_table[] = { 12665cd9f28Seschrock { "create", zfs_do_create, HELP_CREATE }, 12765cd9f28Seschrock { "destroy", zfs_do_destroy, HELP_DESTROY }, 128fa9e4066Sahrens { NULL }, 12965cd9f28Seschrock { "snapshot", zfs_do_snapshot, HELP_SNAPSHOT }, 13065cd9f28Seschrock { "rollback", zfs_do_rollback, HELP_ROLLBACK }, 13165cd9f28Seschrock { "clone", zfs_do_clone, HELP_CLONE }, 132*99653d4eSeschrock { "promote", zfs_do_promote, HELP_PROMOTE }, 13365cd9f28Seschrock { "rename", zfs_do_rename, HELP_RENAME }, 134fa9e4066Sahrens { NULL }, 13565cd9f28Seschrock { "list", zfs_do_list, HELP_LIST }, 136fa9e4066Sahrens { NULL }, 13765cd9f28Seschrock { "set", zfs_do_set, HELP_SET }, 13865cd9f28Seschrock { "get", zfs_do_get, HELP_GET }, 13965cd9f28Seschrock { "inherit", zfs_do_inherit, HELP_INHERIT }, 140fa9e4066Sahrens { NULL }, 14165cd9f28Seschrock { "mount", zfs_do_mount, HELP_MOUNT }, 142fa9e4066Sahrens { NULL }, 14365cd9f28Seschrock { "unmount", zfs_do_unmount, HELP_UNMOUNT }, 144fa9e4066Sahrens { NULL }, 14565cd9f28Seschrock { "share", zfs_do_share, HELP_SHARE }, 146fa9e4066Sahrens { NULL }, 14765cd9f28Seschrock { "unshare", zfs_do_unshare, HELP_UNSHARE }, 148fa9e4066Sahrens { NULL }, 149f2a3c691Sahrens { "send", zfs_do_send, HELP_SEND }, 150f2a3c691Sahrens { "receive", zfs_do_receive, HELP_RECEIVE }, 151fa9e4066Sahrens }; 152fa9e4066Sahrens 153fa9e4066Sahrens #define NCOMMAND (sizeof (command_table) / sizeof (command_table[0])) 154fa9e4066Sahrens 155fa9e4066Sahrens zfs_command_t *current_command; 156fa9e4066Sahrens 15765cd9f28Seschrock static const char * 15865cd9f28Seschrock get_usage(zfs_help_t idx) 15965cd9f28Seschrock { 16065cd9f28Seschrock switch (idx) { 16165cd9f28Seschrock case HELP_CLONE: 16265cd9f28Seschrock return (gettext("\tclone <snapshot> <filesystem|volume>\n")); 16365cd9f28Seschrock case HELP_CREATE: 16465cd9f28Seschrock return (gettext("\tcreate <filesystem>\n" 16565cd9f28Seschrock "\tcreate [-s] [-b blocksize] -V <size> <volume>\n")); 16665cd9f28Seschrock case HELP_DESTROY: 16765cd9f28Seschrock return (gettext("\tdestroy [-rRf] " 16865cd9f28Seschrock "<filesystem|volume|snapshot>\n")); 16965cd9f28Seschrock case HELP_GET: 17065cd9f28Seschrock return (gettext("\tget [-rHp] [-o field[,field]...] " 17165cd9f28Seschrock "[-s source[,source]...]\n" 17265cd9f28Seschrock "\t <all | property[,property]...> " 17365cd9f28Seschrock "<filesystem|volume|snapshot> ...\n")); 17465cd9f28Seschrock case HELP_INHERIT: 17565cd9f28Seschrock return (gettext("\tinherit [-r] <property> " 17665cd9f28Seschrock "<filesystem|volume> ...\n")); 17765cd9f28Seschrock case HELP_LIST: 17865cd9f28Seschrock return (gettext("\tlist [-rH] [-o property[,property]...] " 17965cd9f28Seschrock "[-t type[,type]...]\n" 18065cd9f28Seschrock "\t [filesystem|volume|snapshot] ...\n")); 18165cd9f28Seschrock case HELP_MOUNT: 18265cd9f28Seschrock return (gettext("\tmount\n" 18365cd9f28Seschrock "\tmount [-o opts] [-O] -a\n" 18465cd9f28Seschrock "\tmount [-o opts] [-O] <filesystem>\n")); 185*99653d4eSeschrock case HELP_PROMOTE: 186*99653d4eSeschrock return (gettext("\tpromote <clone filesystem>\n")); 187f2a3c691Sahrens case HELP_RECEIVE: 188f2a3c691Sahrens return (gettext("\treceive [-vn] <filesystem|volume|snapshot>\n" 189f2a3c691Sahrens "\treceive [-vn] -d <filesystem>\n")); 19065cd9f28Seschrock case HELP_RENAME: 19165cd9f28Seschrock return (gettext("\trename <filesystem|volume|snapshot> " 19265cd9f28Seschrock "<filesystem|volume|snapshot>\n")); 19365cd9f28Seschrock case HELP_ROLLBACK: 19465cd9f28Seschrock return (gettext("\trollback [-rRf] <snapshot>\n")); 195f2a3c691Sahrens case HELP_SEND: 196f2a3c691Sahrens return (gettext("\tsend [-i <snapshot>] <snapshot>\n")); 19765cd9f28Seschrock case HELP_SET: 19865cd9f28Seschrock return (gettext("\tset <property=value> " 19965cd9f28Seschrock "<filesystem|volume> ...\n")); 20065cd9f28Seschrock case HELP_SHARE: 20165cd9f28Seschrock return (gettext("\tshare -a\n" 20265cd9f28Seschrock "\tshare <filesystem>\n")); 20365cd9f28Seschrock case HELP_SNAPSHOT: 20465cd9f28Seschrock return (gettext("\tsnapshot <filesystem@name|volume@name>\n")); 20565cd9f28Seschrock case HELP_UNMOUNT: 20665cd9f28Seschrock return (gettext("\tunmount [-f] -a\n" 20765cd9f28Seschrock "\tunmount [-f] <filesystem|mountpoint>\n")); 20865cd9f28Seschrock case HELP_UNSHARE: 20965cd9f28Seschrock return (gettext("\tunshare [-f] -a\n" 21065cd9f28Seschrock "\tunshare [-f] <filesystem|mountpoint>\n")); 21165cd9f28Seschrock } 21265cd9f28Seschrock 21365cd9f28Seschrock abort(); 21465cd9f28Seschrock /* NOTREACHED */ 21565cd9f28Seschrock } 21665cd9f28Seschrock 217fa9e4066Sahrens /* 218fa9e4066Sahrens * Utility function to guarantee malloc() success. 219fa9e4066Sahrens */ 220fa9e4066Sahrens void * 221fa9e4066Sahrens safe_malloc(size_t size) 222fa9e4066Sahrens { 223fa9e4066Sahrens void *data; 224fa9e4066Sahrens 225fa9e4066Sahrens if ((data = calloc(1, size)) == NULL) { 226fa9e4066Sahrens (void) fprintf(stderr, "internal error: out of memory\n"); 227fa9e4066Sahrens exit(1); 228fa9e4066Sahrens } 229fa9e4066Sahrens 230fa9e4066Sahrens return (data); 231fa9e4066Sahrens } 232fa9e4066Sahrens 233fa9e4066Sahrens /* 234fa9e4066Sahrens * Display usage message. If we're inside a command, display only the usage for 235fa9e4066Sahrens * that command. Otherwise, iterate over the entire command table and display 236fa9e4066Sahrens * a complete usage message. 237fa9e4066Sahrens */ 238fa9e4066Sahrens static void 239*99653d4eSeschrock usage(boolean_t requested) 240fa9e4066Sahrens { 241fa9e4066Sahrens int i; 242*99653d4eSeschrock boolean_t show_properties = B_FALSE; 243fa9e4066Sahrens FILE *fp = requested ? stdout : stderr; 244fa9e4066Sahrens 245fa9e4066Sahrens if (current_command == NULL) { 246fa9e4066Sahrens 247fa9e4066Sahrens (void) fprintf(fp, gettext("usage: zfs command args ...\n")); 248fa9e4066Sahrens (void) fprintf(fp, 249fa9e4066Sahrens gettext("where 'command' is one of the following:\n\n")); 250fa9e4066Sahrens 251fa9e4066Sahrens for (i = 0; i < NCOMMAND; i++) { 252fa9e4066Sahrens if (command_table[i].name == NULL) 253fa9e4066Sahrens (void) fprintf(fp, "\n"); 254fa9e4066Sahrens else 255fa9e4066Sahrens (void) fprintf(fp, "%s", 25665cd9f28Seschrock get_usage(command_table[i].usage)); 257fa9e4066Sahrens } 258fa9e4066Sahrens 259fa9e4066Sahrens (void) fprintf(fp, gettext("\nEach dataset is of the form: " 260fa9e4066Sahrens "pool/[dataset/]*dataset[@name]\n")); 261fa9e4066Sahrens } else { 262fa9e4066Sahrens (void) fprintf(fp, gettext("usage:\n")); 26365cd9f28Seschrock (void) fprintf(fp, "%s", get_usage(current_command->usage)); 264fa9e4066Sahrens } 265fa9e4066Sahrens 266fa9e4066Sahrens if (current_command == NULL || 267fa9e4066Sahrens strcmp(current_command->name, "set") == 0 || 268fa9e4066Sahrens strcmp(current_command->name, "get") == 0 || 269fa9e4066Sahrens strcmp(current_command->name, "inherit") == 0 || 270fa9e4066Sahrens strcmp(current_command->name, "list") == 0) 271*99653d4eSeschrock show_properties = B_TRUE; 272fa9e4066Sahrens 273fa9e4066Sahrens if (show_properties) { 274fa9e4066Sahrens 275fa9e4066Sahrens (void) fprintf(fp, 276fa9e4066Sahrens gettext("\nThe following properties are supported:\n")); 277fa9e4066Sahrens 278fa9e4066Sahrens (void) fprintf(fp, "\n\t%-13s %s %s %s\n\n", 279fa9e4066Sahrens "PROPERTY", "EDIT", "INHERIT", "VALUES"); 280fa9e4066Sahrens 281fa9e4066Sahrens for (i = 0; i < ZFS_NPROP_VISIBLE; i++) { 282fa9e4066Sahrens (void) fprintf(fp, "\t%-13s ", zfs_prop_to_name(i)); 283fa9e4066Sahrens 284fa9e4066Sahrens if (zfs_prop_readonly(i)) 285fa9e4066Sahrens (void) fprintf(fp, " NO "); 286fa9e4066Sahrens else 287fa9e4066Sahrens (void) fprintf(fp, " YES "); 288fa9e4066Sahrens 289fa9e4066Sahrens if (zfs_prop_inheritable(i)) 290fa9e4066Sahrens (void) fprintf(fp, " YES "); 291fa9e4066Sahrens else 292fa9e4066Sahrens (void) fprintf(fp, " NO "); 293fa9e4066Sahrens 294fa9e4066Sahrens if (zfs_prop_values(i) == NULL) 295fa9e4066Sahrens (void) fprintf(fp, "-\n"); 296fa9e4066Sahrens else 297fa9e4066Sahrens (void) fprintf(fp, "%s\n", zfs_prop_values(i)); 298fa9e4066Sahrens } 299fa9e4066Sahrens (void) fprintf(fp, gettext("\nSizes are specified in bytes " 300fa9e4066Sahrens "with standard units such as K, M, G, etc.\n")); 301fa9e4066Sahrens } 302fa9e4066Sahrens 303fa9e4066Sahrens exit(requested ? 0 : 2); 304fa9e4066Sahrens } 305fa9e4066Sahrens 306fa9e4066Sahrens /* 307fa9e4066Sahrens * zfs clone <fs, snap, vol> fs 308fa9e4066Sahrens * 309fa9e4066Sahrens * Given an existing dataset, create a writable copy whose initial contents 310fa9e4066Sahrens * are the same as the source. The newly created dataset maintains a 311fa9e4066Sahrens * dependency on the original; the original cannot be destroyed so long as 312fa9e4066Sahrens * the clone exists. 313fa9e4066Sahrens */ 314fa9e4066Sahrens static int 315fa9e4066Sahrens zfs_do_clone(int argc, char **argv) 316fa9e4066Sahrens { 317fa9e4066Sahrens zfs_handle_t *zhp; 318fa9e4066Sahrens int ret; 319fa9e4066Sahrens 320fa9e4066Sahrens /* check options */ 321fa9e4066Sahrens if (argc > 1 && argv[1][0] == '-') { 322fa9e4066Sahrens (void) fprintf(stderr, gettext("invalid option '%c'\n"), 323fa9e4066Sahrens argv[1][1]); 324*99653d4eSeschrock usage(B_FALSE); 325fa9e4066Sahrens } 326fa9e4066Sahrens 327fa9e4066Sahrens /* check number of arguments */ 328fa9e4066Sahrens if (argc < 2) { 329fa9e4066Sahrens (void) fprintf(stderr, gettext("missing source dataset " 330fa9e4066Sahrens "argument\n")); 331*99653d4eSeschrock usage(B_FALSE); 332fa9e4066Sahrens } 333fa9e4066Sahrens if (argc < 3) { 334fa9e4066Sahrens (void) fprintf(stderr, gettext("missing target dataset " 335fa9e4066Sahrens "argument\n")); 336*99653d4eSeschrock usage(B_FALSE); 337fa9e4066Sahrens } 338fa9e4066Sahrens if (argc > 3) { 339fa9e4066Sahrens (void) fprintf(stderr, gettext("too many arguments\n")); 340*99653d4eSeschrock usage(B_FALSE); 341fa9e4066Sahrens } 342fa9e4066Sahrens 343fa9e4066Sahrens /* open the source dataset */ 344*99653d4eSeschrock if ((zhp = zfs_open(g_zfs, argv[1], ZFS_TYPE_SNAPSHOT)) == NULL) 345fa9e4066Sahrens return (1); 346fa9e4066Sahrens 347fa9e4066Sahrens /* pass to libzfs */ 348fa9e4066Sahrens ret = zfs_clone(zhp, argv[2]); 349fa9e4066Sahrens 350fa9e4066Sahrens /* create the mountpoint if necessary */ 351fa9e4066Sahrens if (ret == 0) { 352*99653d4eSeschrock zfs_handle_t *clone = zfs_open(g_zfs, argv[2], ZFS_TYPE_ANY); 353fa9e4066Sahrens if (clone != NULL) { 354fa9e4066Sahrens if ((ret = zfs_mount(clone, NULL, 0)) == 0) 355fa9e4066Sahrens ret = zfs_share(clone); 356fa9e4066Sahrens zfs_close(clone); 357fa9e4066Sahrens } 358fa9e4066Sahrens } 359fa9e4066Sahrens 360fa9e4066Sahrens zfs_close(zhp); 361fa9e4066Sahrens 362fa9e4066Sahrens return (ret == 0 ? 0 : 1); 363fa9e4066Sahrens } 364fa9e4066Sahrens 365fa9e4066Sahrens /* 366fa9e4066Sahrens * zfs create fs 367fa9e4066Sahrens * zfs create [-s] -V vol size 368fa9e4066Sahrens * 369fa9e4066Sahrens * Create a new dataset. This command can be used to create filesystems 370fa9e4066Sahrens * and volumes. Snapshot creation is handled by 'zfs snapshot'. 371fa9e4066Sahrens * For volumes, the user must specify a size to be used. 372fa9e4066Sahrens * 373fa9e4066Sahrens * The '-s' flag applies only to volumes, and indicates that we should not try 374fa9e4066Sahrens * to set the reservation for this volume. By default we set a reservation 375fa9e4066Sahrens * equal to the size for any volume. 376fa9e4066Sahrens */ 377fa9e4066Sahrens static int 378fa9e4066Sahrens zfs_do_create(int argc, char **argv) 379fa9e4066Sahrens { 380fa9e4066Sahrens zfs_type_t type = ZFS_TYPE_FILESYSTEM; 381fa9e4066Sahrens zfs_handle_t *zhp; 382fa9e4066Sahrens char *size = NULL; 383fa9e4066Sahrens char *blocksize = NULL; 384fa9e4066Sahrens int c; 385*99653d4eSeschrock boolean_t noreserve = B_FALSE; 386fa9e4066Sahrens int ret; 387fa9e4066Sahrens 388fa9e4066Sahrens /* check options */ 389fa9e4066Sahrens while ((c = getopt(argc, argv, ":V:b:s")) != -1) { 390fa9e4066Sahrens switch (c) { 391fa9e4066Sahrens case 'V': 392fa9e4066Sahrens type = ZFS_TYPE_VOLUME; 393fa9e4066Sahrens size = optarg; 394fa9e4066Sahrens break; 395fa9e4066Sahrens case 'b': 396fa9e4066Sahrens blocksize = optarg; 397fa9e4066Sahrens break; 398fa9e4066Sahrens case 's': 399*99653d4eSeschrock noreserve = B_TRUE; 400fa9e4066Sahrens break; 401fa9e4066Sahrens case ':': 402fa9e4066Sahrens (void) fprintf(stderr, gettext("missing size " 403fa9e4066Sahrens "argument\n")); 404*99653d4eSeschrock usage(B_FALSE); 405fa9e4066Sahrens break; 406fa9e4066Sahrens case '?': 407fa9e4066Sahrens (void) fprintf(stderr, gettext("invalid option '%c'\n"), 408fa9e4066Sahrens optopt); 409*99653d4eSeschrock usage(B_FALSE); 410fa9e4066Sahrens } 411fa9e4066Sahrens } 412fa9e4066Sahrens 413fa9e4066Sahrens if (noreserve && type != ZFS_TYPE_VOLUME) { 414fa9e4066Sahrens (void) fprintf(stderr, gettext("'-s' can only be used when " 415fa9e4066Sahrens "creating a volume\n")); 416*99653d4eSeschrock usage(B_FALSE); 417fa9e4066Sahrens } 418fa9e4066Sahrens 419fa9e4066Sahrens argc -= optind; 420fa9e4066Sahrens argv += optind; 421fa9e4066Sahrens 422fa9e4066Sahrens /* check number of arguments */ 423fa9e4066Sahrens if (argc == 0) { 424fa9e4066Sahrens (void) fprintf(stderr, gettext("missing %s argument\n"), 425fa9e4066Sahrens zfs_type_to_name(type)); 426*99653d4eSeschrock usage(B_FALSE); 427fa9e4066Sahrens } 428fa9e4066Sahrens if (argc > 1) { 429fa9e4066Sahrens (void) fprintf(stderr, gettext("too many arguments\n")); 430*99653d4eSeschrock usage(B_FALSE); 431fa9e4066Sahrens } 432fa9e4066Sahrens 433fa9e4066Sahrens /* pass to libzfs */ 434*99653d4eSeschrock if (zfs_create(g_zfs, argv[0], type, size, blocksize) != 0) 435fa9e4066Sahrens return (1); 436fa9e4066Sahrens 437*99653d4eSeschrock if ((zhp = zfs_open(g_zfs, argv[0], ZFS_TYPE_ANY)) == NULL) 438fa9e4066Sahrens return (1); 439fa9e4066Sahrens 440fa9e4066Sahrens /* 441fa9e4066Sahrens * Volume handling. By default, we try to create a reservation of equal 442fa9e4066Sahrens * size for the volume. If we can't do this, then destroy the dataset 443fa9e4066Sahrens * and report an error. 444fa9e4066Sahrens */ 445fa9e4066Sahrens if (type == ZFS_TYPE_VOLUME && !noreserve) { 446fa9e4066Sahrens if (zfs_prop_set(zhp, ZFS_PROP_RESERVATION, size) != 0) { 447fa9e4066Sahrens (void) fprintf(stderr, gettext("use '-s' to create a " 448fa9e4066Sahrens "volume without a matching reservation\n")); 449fa9e4066Sahrens (void) zfs_destroy(zhp); 450fa9e4066Sahrens return (1); 451fa9e4066Sahrens } 452fa9e4066Sahrens } 453fa9e4066Sahrens 454fa9e4066Sahrens /* 455fa9e4066Sahrens * Mount and/or share the new filesystem as appropriate. We provide a 456fa9e4066Sahrens * verbose error message to let the user know that their filesystem was 457fa9e4066Sahrens * in fact created, even if we failed to mount or share it. 458fa9e4066Sahrens */ 459fa9e4066Sahrens if (zfs_mount(zhp, NULL, 0) != 0) { 460fa9e4066Sahrens (void) fprintf(stderr, gettext("filesystem successfully " 461fa9e4066Sahrens "created, but not mounted\n")); 462fa9e4066Sahrens ret = 1; 463fa9e4066Sahrens } else if (zfs_share(zhp) != 0) { 464fa9e4066Sahrens (void) fprintf(stderr, gettext("filesystem successfully " 465fa9e4066Sahrens "created, but not shared\n")); 466fa9e4066Sahrens ret = 1; 467fa9e4066Sahrens } else { 468fa9e4066Sahrens ret = 0; 469fa9e4066Sahrens } 470fa9e4066Sahrens 471fa9e4066Sahrens zfs_close(zhp); 472fa9e4066Sahrens return (ret); 473fa9e4066Sahrens } 474fa9e4066Sahrens 475fa9e4066Sahrens /* 476fa9e4066Sahrens * zfs destroy [-rf] <fs, snap, vol> 477fa9e4066Sahrens * 478fa9e4066Sahrens * -r Recursively destroy all children 479fa9e4066Sahrens * -R Recursively destroy all dependents, including clones 480fa9e4066Sahrens * -f Force unmounting of any dependents 481fa9e4066Sahrens * 482fa9e4066Sahrens * Destroys the given dataset. By default, it will unmount any filesystems, 483fa9e4066Sahrens * and refuse to destroy a dataset that has any dependents. A dependent can 484fa9e4066Sahrens * either be a child, or a clone of a child. 485fa9e4066Sahrens */ 486fa9e4066Sahrens typedef struct destroy_cbdata { 487*99653d4eSeschrock boolean_t cb_first; 488fa9e4066Sahrens int cb_force; 489fa9e4066Sahrens int cb_recurse; 490fa9e4066Sahrens int cb_error; 491fa9e4066Sahrens int cb_needforce; 492fa9e4066Sahrens int cb_doclones; 493fa9e4066Sahrens zfs_handle_t *cb_target; 494fa9e4066Sahrens } destroy_cbdata_t; 495fa9e4066Sahrens 496fa9e4066Sahrens /* 497fa9e4066Sahrens * Check for any dependents based on the '-r' or '-R' flags. 498fa9e4066Sahrens */ 499fa9e4066Sahrens static int 500fa9e4066Sahrens destroy_check_dependent(zfs_handle_t *zhp, void *data) 501fa9e4066Sahrens { 502fa9e4066Sahrens destroy_cbdata_t *cbp = data; 503fa9e4066Sahrens const char *tname = zfs_get_name(cbp->cb_target); 504fa9e4066Sahrens const char *name = zfs_get_name(zhp); 505fa9e4066Sahrens 506fa9e4066Sahrens if (strncmp(tname, name, strlen(tname)) == 0 && 507fa9e4066Sahrens (name[strlen(tname)] == '/' || name[strlen(tname)] == '@')) { 508fa9e4066Sahrens /* 509fa9e4066Sahrens * This is a direct descendant, not a clone somewhere else in 510fa9e4066Sahrens * the hierarchy. 511fa9e4066Sahrens */ 512fa9e4066Sahrens if (cbp->cb_recurse) 513fa9e4066Sahrens goto out; 514fa9e4066Sahrens 515fa9e4066Sahrens if (cbp->cb_first) { 516fa9e4066Sahrens (void) fprintf(stderr, gettext("cannot destroy '%s': " 517fa9e4066Sahrens "%s has children\n"), 518fa9e4066Sahrens zfs_get_name(cbp->cb_target), 519fa9e4066Sahrens zfs_type_to_name(zfs_get_type(cbp->cb_target))); 520fa9e4066Sahrens (void) fprintf(stderr, gettext("use '-r' to destroy " 521fa9e4066Sahrens "the following datasets:\n")); 522*99653d4eSeschrock cbp->cb_first = B_FALSE; 523fa9e4066Sahrens cbp->cb_error = 1; 524fa9e4066Sahrens } 525fa9e4066Sahrens 526fa9e4066Sahrens (void) fprintf(stderr, "%s\n", zfs_get_name(zhp)); 527fa9e4066Sahrens } else { 528fa9e4066Sahrens /* 529fa9e4066Sahrens * This is a clone. We only want to report this if the '-r' 530fa9e4066Sahrens * wasn't specified, or the target is a snapshot. 531fa9e4066Sahrens */ 532fa9e4066Sahrens if (!cbp->cb_recurse && 533fa9e4066Sahrens zfs_get_type(cbp->cb_target) != ZFS_TYPE_SNAPSHOT) 534fa9e4066Sahrens goto out; 535fa9e4066Sahrens 536fa9e4066Sahrens if (cbp->cb_first) { 537fa9e4066Sahrens (void) fprintf(stderr, gettext("cannot destroy '%s': " 538fa9e4066Sahrens "%s has dependent clones\n"), 539fa9e4066Sahrens zfs_get_name(cbp->cb_target), 540fa9e4066Sahrens zfs_type_to_name(zfs_get_type(cbp->cb_target))); 541fa9e4066Sahrens (void) fprintf(stderr, gettext("use '-R' to destroy " 542fa9e4066Sahrens "the following datasets:\n")); 543*99653d4eSeschrock cbp->cb_first = B_FALSE; 544fa9e4066Sahrens cbp->cb_error = 1; 545fa9e4066Sahrens } 546fa9e4066Sahrens 547fa9e4066Sahrens (void) fprintf(stderr, "%s\n", zfs_get_name(zhp)); 548fa9e4066Sahrens } 549fa9e4066Sahrens 550fa9e4066Sahrens out: 551fa9e4066Sahrens zfs_close(zhp); 552fa9e4066Sahrens return (0); 553fa9e4066Sahrens } 554fa9e4066Sahrens 555fa9e4066Sahrens static int 556fa9e4066Sahrens destroy_callback(zfs_handle_t *zhp, void *data) 557fa9e4066Sahrens { 558fa9e4066Sahrens destroy_cbdata_t *cbp = data; 559fa9e4066Sahrens 560fa9e4066Sahrens /* 561fa9e4066Sahrens * Ignore pools (which we've already flagged as an error before getting 562fa9e4066Sahrens * here. 563fa9e4066Sahrens */ 564fa9e4066Sahrens if (strchr(zfs_get_name(zhp), '/') == NULL && 565fa9e4066Sahrens zfs_get_type(zhp) == ZFS_TYPE_FILESYSTEM) { 566fa9e4066Sahrens zfs_close(zhp); 567fa9e4066Sahrens return (0); 568fa9e4066Sahrens } 569fa9e4066Sahrens 570fa9e4066Sahrens /* 571fa9e4066Sahrens * Bail out on the first error. 572fa9e4066Sahrens */ 573fa9e4066Sahrens if (zfs_unmount(zhp, NULL, cbp->cb_force ? MS_FORCE : 0) != 0 || 574fa9e4066Sahrens zfs_destroy(zhp) != 0) { 575fa9e4066Sahrens zfs_close(zhp); 576fa9e4066Sahrens return (-1); 577fa9e4066Sahrens } 578fa9e4066Sahrens 579fa9e4066Sahrens zfs_close(zhp); 580fa9e4066Sahrens return (0); 581fa9e4066Sahrens } 582fa9e4066Sahrens 583fa9e4066Sahrens 584fa9e4066Sahrens static int 585fa9e4066Sahrens zfs_do_destroy(int argc, char **argv) 586fa9e4066Sahrens { 587fa9e4066Sahrens destroy_cbdata_t cb = { 0 }; 588fa9e4066Sahrens int c; 589fa9e4066Sahrens zfs_handle_t *zhp; 590fa9e4066Sahrens 591fa9e4066Sahrens /* check options */ 592fa9e4066Sahrens while ((c = getopt(argc, argv, "frR")) != -1) { 593fa9e4066Sahrens switch (c) { 594fa9e4066Sahrens case 'f': 595fa9e4066Sahrens cb.cb_force = 1; 596fa9e4066Sahrens break; 597fa9e4066Sahrens case 'r': 598fa9e4066Sahrens cb.cb_recurse = 1; 599fa9e4066Sahrens break; 600fa9e4066Sahrens case 'R': 601fa9e4066Sahrens cb.cb_recurse = 1; 602fa9e4066Sahrens cb.cb_doclones = 1; 603fa9e4066Sahrens break; 604fa9e4066Sahrens case '?': 605fa9e4066Sahrens default: 606fa9e4066Sahrens (void) fprintf(stderr, gettext("invalid option '%c'\n"), 607fa9e4066Sahrens optopt); 608*99653d4eSeschrock usage(B_FALSE); 609fa9e4066Sahrens } 610fa9e4066Sahrens } 611fa9e4066Sahrens 612fa9e4066Sahrens argc -= optind; 613fa9e4066Sahrens argv += optind; 614fa9e4066Sahrens 615fa9e4066Sahrens /* check number of arguments */ 616fa9e4066Sahrens if (argc == 0) { 617fa9e4066Sahrens (void) fprintf(stderr, gettext("missing path argument\n")); 618*99653d4eSeschrock usage(B_FALSE); 619fa9e4066Sahrens } 620fa9e4066Sahrens if (argc > 1) { 621fa9e4066Sahrens (void) fprintf(stderr, gettext("too many arguments\n")); 622*99653d4eSeschrock usage(B_FALSE); 623fa9e4066Sahrens } 624fa9e4066Sahrens 625fa9e4066Sahrens /* Open the given dataset */ 626*99653d4eSeschrock if ((zhp = zfs_open(g_zfs, argv[0], ZFS_TYPE_ANY)) == NULL) 627fa9e4066Sahrens return (1); 628fa9e4066Sahrens 629fa9e4066Sahrens cb.cb_target = zhp; 630fa9e4066Sahrens 631fa9e4066Sahrens /* 632fa9e4066Sahrens * Perform an explicit check for pools before going any further. 633fa9e4066Sahrens */ 634fa9e4066Sahrens if (!cb.cb_recurse && strchr(zfs_get_name(zhp), '/') == NULL && 635fa9e4066Sahrens zfs_get_type(zhp) == ZFS_TYPE_FILESYSTEM) { 636fa9e4066Sahrens (void) fprintf(stderr, gettext("cannot destroy '%s': " 637fa9e4066Sahrens "operation does not apply to pools\n"), 638fa9e4066Sahrens zfs_get_name(zhp)); 639fa9e4066Sahrens (void) fprintf(stderr, gettext("use 'zfs destroy -r " 640fa9e4066Sahrens "%s' to destroy all datasets in the pool\n"), 641fa9e4066Sahrens zfs_get_name(zhp)); 642fa9e4066Sahrens (void) fprintf(stderr, gettext("use 'zpool destroy %s' " 643fa9e4066Sahrens "to destroy the pool itself\n"), zfs_get_name(zhp)); 644fa9e4066Sahrens zfs_close(zhp); 645fa9e4066Sahrens return (1); 646fa9e4066Sahrens } 647fa9e4066Sahrens 648fa9e4066Sahrens 649fa9e4066Sahrens /* 650fa9e4066Sahrens * Check for any dependents and/or clones. 651fa9e4066Sahrens */ 652*99653d4eSeschrock cb.cb_first = B_TRUE; 653fa9e4066Sahrens if (!cb.cb_doclones) 654fa9e4066Sahrens (void) zfs_iter_dependents(zhp, destroy_check_dependent, &cb); 655fa9e4066Sahrens 656fa9e4066Sahrens if (cb.cb_error) { 657fa9e4066Sahrens zfs_close(zhp); 658fa9e4066Sahrens return (1); 659fa9e4066Sahrens } 660fa9e4066Sahrens 661fa9e4066Sahrens /* 662fa9e4066Sahrens * Do the real thing. 663fa9e4066Sahrens */ 664fa9e4066Sahrens if (zfs_iter_dependents(zhp, destroy_callback, &cb) == 0 && 665fa9e4066Sahrens destroy_callback(zhp, &cb) == 0) 666fa9e4066Sahrens return (0); 667fa9e4066Sahrens 668fa9e4066Sahrens return (1); 669fa9e4066Sahrens } 670fa9e4066Sahrens 671fa9e4066Sahrens /* 67207ba0419Seschrock * zfs get [-rHp] [-o field[,field]...] [-s source[,source]...] 67307ba0419Seschrock * < all | property[,property]... > < fs | snap | vol > ... 674fa9e4066Sahrens * 675fa9e4066Sahrens * -r recurse over any child datasets 676fa9e4066Sahrens * -H scripted mode. Headers are stripped, and fields are separated 677fa9e4066Sahrens * by tabs instead of spaces. 678fa9e4066Sahrens * -o Set of fields to display. One of "name,property,value,source". 679fa9e4066Sahrens * Default is all four. 680fa9e4066Sahrens * -s Set of sources to allow. One of 681fa9e4066Sahrens * "local,default,inherited,temporary,none". Default is all 682fa9e4066Sahrens * five. 683fa9e4066Sahrens * -p Display values in parsable (literal) format. 684fa9e4066Sahrens * 685fa9e4066Sahrens * Prints properties for the given datasets. The user can control which 686fa9e4066Sahrens * columns to display as well as which property types to allow. 687fa9e4066Sahrens */ 688fa9e4066Sahrens typedef struct get_cbdata { 689fa9e4066Sahrens int cb_sources; 690fa9e4066Sahrens int cb_columns[4]; 691fa9e4066Sahrens int cb_nprop; 692*99653d4eSeschrock boolean_t cb_scripted; 693*99653d4eSeschrock boolean_t cb_literal; 694*99653d4eSeschrock boolean_t cb_isall; 695*99653d4eSeschrock zfs_prop_t cb_prop[ZFS_NPROP_ALL]; 696fa9e4066Sahrens } get_cbdata_t; 697fa9e4066Sahrens 698fa9e4066Sahrens #define GET_COL_NAME 1 699fa9e4066Sahrens #define GET_COL_PROPERTY 2 700fa9e4066Sahrens #define GET_COL_VALUE 3 701fa9e4066Sahrens #define GET_COL_SOURCE 4 702fa9e4066Sahrens 703fa9e4066Sahrens /* 704fa9e4066Sahrens * Display a single line of output, according to the settings in the callback 705fa9e4066Sahrens * structure. 706fa9e4066Sahrens */ 707fa9e4066Sahrens static void 708fa9e4066Sahrens print_one_property(zfs_handle_t *zhp, get_cbdata_t *cbp, zfs_prop_t prop, 709fa9e4066Sahrens const char *value, zfs_source_t sourcetype, const char *source) 710fa9e4066Sahrens { 711fa9e4066Sahrens int i; 712fa9e4066Sahrens int width; 713fa9e4066Sahrens const char *str; 714fa9e4066Sahrens char buf[128]; 715fa9e4066Sahrens 716fa9e4066Sahrens /* 717fa9e4066Sahrens * Ignore those source types that the user has chosen to ignore. 718fa9e4066Sahrens */ 719fa9e4066Sahrens if ((sourcetype & cbp->cb_sources) == 0) 720fa9e4066Sahrens return; 721fa9e4066Sahrens 722fa9e4066Sahrens for (i = 0; i < 4; i++) { 723fa9e4066Sahrens switch (cbp->cb_columns[i]) { 724fa9e4066Sahrens case GET_COL_NAME: 725fa9e4066Sahrens width = 15; 726fa9e4066Sahrens str = zfs_get_name(zhp); 727fa9e4066Sahrens break; 728fa9e4066Sahrens 729fa9e4066Sahrens case GET_COL_PROPERTY: 730fa9e4066Sahrens width = 13; 731fa9e4066Sahrens str = zfs_prop_to_name(prop); 732fa9e4066Sahrens break; 733fa9e4066Sahrens 734fa9e4066Sahrens case GET_COL_VALUE: 735fa9e4066Sahrens width = 25; 736fa9e4066Sahrens str = value; 737fa9e4066Sahrens break; 738fa9e4066Sahrens 739fa9e4066Sahrens case GET_COL_SOURCE: 740fa9e4066Sahrens width = 15; 741fa9e4066Sahrens switch (sourcetype) { 742fa9e4066Sahrens case ZFS_SRC_NONE: 743fa9e4066Sahrens str = "-"; 744fa9e4066Sahrens break; 745fa9e4066Sahrens 746fa9e4066Sahrens case ZFS_SRC_DEFAULT: 747fa9e4066Sahrens str = "default"; 748fa9e4066Sahrens break; 749fa9e4066Sahrens 750fa9e4066Sahrens case ZFS_SRC_LOCAL: 751fa9e4066Sahrens str = "local"; 752fa9e4066Sahrens break; 753fa9e4066Sahrens 754fa9e4066Sahrens case ZFS_SRC_TEMPORARY: 755fa9e4066Sahrens str = "temporary"; 756fa9e4066Sahrens break; 757fa9e4066Sahrens 758fa9e4066Sahrens case ZFS_SRC_INHERITED: 759fa9e4066Sahrens (void) snprintf(buf, sizeof (buf), 760fa9e4066Sahrens "inherited from %s", source); 761fa9e4066Sahrens str = buf; 762fa9e4066Sahrens break; 763fa9e4066Sahrens } 764fa9e4066Sahrens break; 765fa9e4066Sahrens 766fa9e4066Sahrens default: 767fa9e4066Sahrens continue; 768fa9e4066Sahrens } 769fa9e4066Sahrens 770fa9e4066Sahrens if (cbp->cb_columns[i + 1] == 0) 771fa9e4066Sahrens (void) printf("%s", str); 772fa9e4066Sahrens else if (cbp->cb_scripted) 773fa9e4066Sahrens (void) printf("%s\t", str); 774fa9e4066Sahrens else 775fa9e4066Sahrens (void) printf("%-*s ", width, str); 776fa9e4066Sahrens 777fa9e4066Sahrens } 778fa9e4066Sahrens 779fa9e4066Sahrens (void) printf("\n"); 780fa9e4066Sahrens } 781fa9e4066Sahrens 782fa9e4066Sahrens /* 783fa9e4066Sahrens * Invoked to display the properties for a single dataset. 784fa9e4066Sahrens */ 785fa9e4066Sahrens static int 786fa9e4066Sahrens get_callback(zfs_handle_t *zhp, void *data) 787fa9e4066Sahrens { 788fa9e4066Sahrens char buf[ZFS_MAXPROPLEN]; 789fa9e4066Sahrens zfs_source_t sourcetype; 790fa9e4066Sahrens char source[ZFS_MAXNAMELEN]; 791fa9e4066Sahrens get_cbdata_t *cbp = data; 792fa9e4066Sahrens int i; 793fa9e4066Sahrens 794fa9e4066Sahrens for (i = 0; i < cbp->cb_nprop; i++) { 795fa9e4066Sahrens if (zfs_prop_get(zhp, cbp->cb_prop[i], buf, 796fa9e4066Sahrens sizeof (buf), &sourcetype, source, sizeof (source), 797fa9e4066Sahrens cbp->cb_literal) != 0) { 79807ba0419Seschrock if (cbp->cb_isall) 79907ba0419Seschrock continue; 800fa9e4066Sahrens (void) strlcpy(buf, "-", sizeof (buf)); 801fa9e4066Sahrens sourcetype = ZFS_SRC_NONE; 802fa9e4066Sahrens } 803fa9e4066Sahrens 804fa9e4066Sahrens print_one_property(zhp, cbp, cbp->cb_prop[i], 805fa9e4066Sahrens buf, sourcetype, source); 806fa9e4066Sahrens } 807fa9e4066Sahrens 808fa9e4066Sahrens return (0); 809fa9e4066Sahrens } 810fa9e4066Sahrens 811fa9e4066Sahrens static int 812fa9e4066Sahrens zfs_do_get(int argc, char **argv) 813fa9e4066Sahrens { 814fa9e4066Sahrens get_cbdata_t cb = { 0 }; 815*99653d4eSeschrock boolean_t recurse = B_FALSE; 816fa9e4066Sahrens int c; 81707ba0419Seschrock char *value, *fields, *badopt; 818fa9e4066Sahrens int i; 81907ba0419Seschrock int ret; 820fa9e4066Sahrens 821fa9e4066Sahrens /* 822fa9e4066Sahrens * Set up default columns and sources. 823fa9e4066Sahrens */ 824fa9e4066Sahrens cb.cb_sources = ZFS_SRC_ALL; 825fa9e4066Sahrens cb.cb_columns[0] = GET_COL_NAME; 826fa9e4066Sahrens cb.cb_columns[1] = GET_COL_PROPERTY; 827fa9e4066Sahrens cb.cb_columns[2] = GET_COL_VALUE; 828fa9e4066Sahrens cb.cb_columns[3] = GET_COL_SOURCE; 829fa9e4066Sahrens 830fa9e4066Sahrens /* check options */ 831fa9e4066Sahrens while ((c = getopt(argc, argv, ":o:s:rHp")) != -1) { 832fa9e4066Sahrens switch (c) { 833fa9e4066Sahrens case 'p': 834*99653d4eSeschrock cb.cb_literal = B_TRUE; 835fa9e4066Sahrens break; 836fa9e4066Sahrens case 'r': 837*99653d4eSeschrock recurse = B_TRUE; 838fa9e4066Sahrens break; 839fa9e4066Sahrens case 'H': 840*99653d4eSeschrock cb.cb_scripted = B_TRUE; 841fa9e4066Sahrens break; 842fa9e4066Sahrens case ':': 843fa9e4066Sahrens (void) fprintf(stderr, gettext("missing argument for " 844fa9e4066Sahrens "'%c' option\n"), optopt); 845*99653d4eSeschrock usage(B_FALSE); 846fa9e4066Sahrens break; 847fa9e4066Sahrens case 'o': 848fa9e4066Sahrens /* 849fa9e4066Sahrens * Process the set of columns to display. We zero out 850fa9e4066Sahrens * the structure to give us a blank slate. 851fa9e4066Sahrens */ 852fa9e4066Sahrens bzero(&cb.cb_columns, sizeof (cb.cb_columns)); 853fa9e4066Sahrens i = 0; 854fa9e4066Sahrens while (*optarg != '\0') { 855fa9e4066Sahrens static char *col_subopts[] = 856fa9e4066Sahrens { "name", "property", "value", "source", 857fa9e4066Sahrens NULL }; 858fa9e4066Sahrens 859fa9e4066Sahrens if (i == 4) { 860fa9e4066Sahrens (void) fprintf(stderr, gettext("too " 861fa9e4066Sahrens "many fields given to -o " 862fa9e4066Sahrens "option\n")); 863*99653d4eSeschrock usage(B_FALSE); 864fa9e4066Sahrens } 865fa9e4066Sahrens 866fa9e4066Sahrens switch (getsubopt(&optarg, col_subopts, 867fa9e4066Sahrens &value)) { 868fa9e4066Sahrens case 0: 869fa9e4066Sahrens cb.cb_columns[i++] = GET_COL_NAME; 870fa9e4066Sahrens break; 871fa9e4066Sahrens case 1: 872fa9e4066Sahrens cb.cb_columns[i++] = GET_COL_PROPERTY; 873fa9e4066Sahrens break; 874fa9e4066Sahrens case 2: 875fa9e4066Sahrens cb.cb_columns[i++] = GET_COL_VALUE; 876fa9e4066Sahrens break; 877fa9e4066Sahrens case 3: 878fa9e4066Sahrens cb.cb_columns[i++] = GET_COL_SOURCE; 879fa9e4066Sahrens break; 880fa9e4066Sahrens default: 881fa9e4066Sahrens (void) fprintf(stderr, 882fa9e4066Sahrens gettext("invalid column name " 883fa9e4066Sahrens "'%s'\n"), value); 884*99653d4eSeschrock usage(B_FALSE); 885fa9e4066Sahrens } 886fa9e4066Sahrens } 887fa9e4066Sahrens break; 888fa9e4066Sahrens 889fa9e4066Sahrens case 's': 890fa9e4066Sahrens cb.cb_sources = 0; 891fa9e4066Sahrens while (*optarg != '\0') { 892fa9e4066Sahrens static char *source_subopts[] = { 893fa9e4066Sahrens "local", "default", "inherited", 894fa9e4066Sahrens "temporary", "none", NULL }; 895fa9e4066Sahrens 896fa9e4066Sahrens switch (getsubopt(&optarg, source_subopts, 897fa9e4066Sahrens &value)) { 898fa9e4066Sahrens case 0: 899fa9e4066Sahrens cb.cb_sources |= ZFS_SRC_LOCAL; 900fa9e4066Sahrens break; 901fa9e4066Sahrens case 1: 902fa9e4066Sahrens cb.cb_sources |= ZFS_SRC_DEFAULT; 903fa9e4066Sahrens break; 904fa9e4066Sahrens case 2: 905fa9e4066Sahrens cb.cb_sources |= ZFS_SRC_INHERITED; 906fa9e4066Sahrens break; 907fa9e4066Sahrens case 3: 908fa9e4066Sahrens cb.cb_sources |= ZFS_SRC_TEMPORARY; 909fa9e4066Sahrens break; 910fa9e4066Sahrens case 4: 911fa9e4066Sahrens cb.cb_sources |= ZFS_SRC_NONE; 912fa9e4066Sahrens break; 913fa9e4066Sahrens default: 914fa9e4066Sahrens (void) fprintf(stderr, 915fa9e4066Sahrens gettext("invalid source " 916fa9e4066Sahrens "'%s'\n"), value); 917*99653d4eSeschrock usage(B_FALSE); 918fa9e4066Sahrens } 919fa9e4066Sahrens } 920fa9e4066Sahrens break; 921fa9e4066Sahrens 922fa9e4066Sahrens case '?': 923fa9e4066Sahrens (void) fprintf(stderr, gettext("invalid option '%c'\n"), 924fa9e4066Sahrens optopt); 925*99653d4eSeschrock usage(B_FALSE); 926fa9e4066Sahrens } 927fa9e4066Sahrens } 928fa9e4066Sahrens 929fa9e4066Sahrens argc -= optind; 930fa9e4066Sahrens argv += optind; 931fa9e4066Sahrens 932fa9e4066Sahrens if (argc < 1) { 933fa9e4066Sahrens (void) fprintf(stderr, gettext("missing property " 934fa9e4066Sahrens "argument\n")); 935*99653d4eSeschrock usage(B_FALSE); 936fa9e4066Sahrens } 937fa9e4066Sahrens 938fa9e4066Sahrens fields = argv[0]; 939fa9e4066Sahrens 940fa9e4066Sahrens /* 94107ba0419Seschrock * If the user specifies 'all', the behavior of 'zfs get' is slightly 94207ba0419Seschrock * different, because we don't show properties which don't apply to the 94307ba0419Seschrock * given dataset. 944fa9e4066Sahrens */ 94507ba0419Seschrock if (strcmp(fields, "all") == 0) 946*99653d4eSeschrock cb.cb_isall = B_TRUE; 94707ba0419Seschrock 94807ba0419Seschrock if ((ret = zfs_get_proplist(fields, cb.cb_prop, ZFS_NPROP_ALL, 94907ba0419Seschrock &cb.cb_nprop, &badopt)) != 0) { 95007ba0419Seschrock if (ret == EINVAL) 95107ba0419Seschrock (void) fprintf(stderr, gettext("invalid property " 95207ba0419Seschrock "'%s'\n"), badopt); 95307ba0419Seschrock else 95407ba0419Seschrock (void) fprintf(stderr, gettext("too many properties " 95507ba0419Seschrock "specified\n")); 956*99653d4eSeschrock usage(B_FALSE); 957fa9e4066Sahrens } 958fa9e4066Sahrens 959fa9e4066Sahrens argc--; 960fa9e4066Sahrens argv++; 961fa9e4066Sahrens 962fa9e4066Sahrens /* check for at least one dataset name */ 963fa9e4066Sahrens if (argc < 1) { 964fa9e4066Sahrens (void) fprintf(stderr, gettext("missing dataset argument\n")); 965*99653d4eSeschrock usage(B_FALSE); 966fa9e4066Sahrens } 967fa9e4066Sahrens 968fa9e4066Sahrens /* 969fa9e4066Sahrens * Print out any headers 970fa9e4066Sahrens */ 971fa9e4066Sahrens if (!cb.cb_scripted) { 972fa9e4066Sahrens int i; 973fa9e4066Sahrens for (i = 0; i < 4; i++) { 974fa9e4066Sahrens switch (cb.cb_columns[i]) { 975fa9e4066Sahrens case GET_COL_NAME: 976fa9e4066Sahrens (void) printf("%-15s ", "NAME"); 977fa9e4066Sahrens break; 978fa9e4066Sahrens case GET_COL_PROPERTY: 979fa9e4066Sahrens (void) printf("%-13s ", "PROPERTY"); 980fa9e4066Sahrens break; 981fa9e4066Sahrens case GET_COL_VALUE: 982fa9e4066Sahrens (void) printf("%-25s ", "VALUE"); 983fa9e4066Sahrens break; 984fa9e4066Sahrens case GET_COL_SOURCE: 985fa9e4066Sahrens (void) printf("%s", "SOURCE"); 986fa9e4066Sahrens break; 987fa9e4066Sahrens } 988fa9e4066Sahrens } 989fa9e4066Sahrens (void) printf("\n"); 990fa9e4066Sahrens } 991fa9e4066Sahrens 992fa9e4066Sahrens /* run for each object */ 993fa9e4066Sahrens return (zfs_for_each(argc, argv, recurse, ZFS_TYPE_ANY, 994fa9e4066Sahrens get_callback, &cb)); 995fa9e4066Sahrens } 996fa9e4066Sahrens 997fa9e4066Sahrens /* 998fa9e4066Sahrens * inherit [-r] <property> <fs|vol> ... 999fa9e4066Sahrens * 1000fa9e4066Sahrens * -r Recurse over all children 1001fa9e4066Sahrens * 1002fa9e4066Sahrens * For each dataset specified on the command line, inherit the given property 1003fa9e4066Sahrens * from its parent. Inheriting a property at the pool level will cause it to 1004fa9e4066Sahrens * use the default value. The '-r' flag will recurse over all children, and is 1005fa9e4066Sahrens * useful for setting a property on a hierarchy-wide basis, regardless of any 1006fa9e4066Sahrens * local modifications for each dataset. 1007fa9e4066Sahrens */ 1008fa9e4066Sahrens static int 1009fa9e4066Sahrens inherit_callback(zfs_handle_t *zhp, void *data) 1010fa9e4066Sahrens { 1011fa9e4066Sahrens zfs_prop_t prop = (zfs_prop_t)data; 1012fa9e4066Sahrens 1013fa9e4066Sahrens return (zfs_prop_inherit(zhp, prop) != 0); 1014fa9e4066Sahrens } 1015fa9e4066Sahrens 1016fa9e4066Sahrens static int 1017fa9e4066Sahrens zfs_do_inherit(int argc, char **argv) 1018fa9e4066Sahrens { 1019*99653d4eSeschrock boolean_t recurse = B_FALSE; 1020fa9e4066Sahrens int c; 1021fa9e4066Sahrens zfs_prop_t prop; 1022fa9e4066Sahrens char *propname; 1023fa9e4066Sahrens 1024fa9e4066Sahrens /* check options */ 1025fa9e4066Sahrens while ((c = getopt(argc, argv, "r")) != -1) { 1026fa9e4066Sahrens switch (c) { 1027fa9e4066Sahrens case 'r': 1028*99653d4eSeschrock recurse = B_TRUE; 1029fa9e4066Sahrens break; 1030fa9e4066Sahrens case '?': 1031fa9e4066Sahrens default: 1032fa9e4066Sahrens (void) fprintf(stderr, gettext("invalid option '%c'\n"), 1033fa9e4066Sahrens optopt); 1034*99653d4eSeschrock usage(B_FALSE); 1035fa9e4066Sahrens } 1036fa9e4066Sahrens } 1037fa9e4066Sahrens 1038fa9e4066Sahrens argc -= optind; 1039fa9e4066Sahrens argv += optind; 1040fa9e4066Sahrens 1041fa9e4066Sahrens /* check number of arguments */ 1042fa9e4066Sahrens if (argc < 1) { 1043fa9e4066Sahrens (void) fprintf(stderr, gettext("missing property argument\n")); 1044*99653d4eSeschrock usage(B_FALSE); 1045fa9e4066Sahrens } 1046fa9e4066Sahrens if (argc < 2) { 1047fa9e4066Sahrens (void) fprintf(stderr, gettext("missing dataset argument\n")); 1048*99653d4eSeschrock usage(B_FALSE); 1049fa9e4066Sahrens } 1050fa9e4066Sahrens 1051fa9e4066Sahrens propname = argv[0]; 1052fa9e4066Sahrens 1053fa9e4066Sahrens /* 1054fa9e4066Sahrens * Get and validate the property before iterating over the datasets. We 1055fa9e4066Sahrens * do this now so as to avoid printing out an error message for each and 1056fa9e4066Sahrens * every dataset. 1057fa9e4066Sahrens */ 1058fa9e4066Sahrens if ((prop = zfs_name_to_prop(propname)) == ZFS_PROP_INVAL) { 1059fa9e4066Sahrens (void) fprintf(stderr, gettext("invalid property '%s'\n"), 1060fa9e4066Sahrens propname); 1061*99653d4eSeschrock usage(B_FALSE); 1062fa9e4066Sahrens } 1063fa9e4066Sahrens if (zfs_prop_readonly(prop)) { 1064fa9e4066Sahrens (void) fprintf(stderr, gettext("%s property is read-only\n"), 1065fa9e4066Sahrens propname); 1066fa9e4066Sahrens return (1); 1067fa9e4066Sahrens } 1068fa9e4066Sahrens if (!zfs_prop_inheritable(prop)) { 1069fa9e4066Sahrens (void) fprintf(stderr, gettext("%s property cannot be " 1070fa9e4066Sahrens "inherited\n"), propname); 1071fa9e4066Sahrens (void) fprintf(stderr, gettext("use 'zfs set %s=none' to " 1072fa9e4066Sahrens "clear\n"), propname); 1073fa9e4066Sahrens return (1); 1074fa9e4066Sahrens } 1075fa9e4066Sahrens 1076fa9e4066Sahrens return (zfs_for_each(argc - 1, argv + 1, recurse, 1077fa9e4066Sahrens ZFS_TYPE_FILESYSTEM | ZFS_TYPE_VOLUME, 1078fa9e4066Sahrens inherit_callback, (void *)prop)); 1079fa9e4066Sahrens } 1080fa9e4066Sahrens 1081fa9e4066Sahrens /* 108207ba0419Seschrock * list [-rH] [-o property[,property]...] [-t type[,type]...] <dataset> ... 1083fa9e4066Sahrens * 1084fa9e4066Sahrens * -r Recurse over all children 1085fa9e4066Sahrens * -H Scripted mode; elide headers and separate colums by tabs 1086fa9e4066Sahrens * -o Control which fields to display. 108707ba0419Seschrock * -t Control which object types to display. 1088fa9e4066Sahrens * 1089fa9e4066Sahrens * When given no arguments, lists all filesystems in the system. 1090fa9e4066Sahrens * Otherwise, list the specified datasets, optionally recursing down them if 1091fa9e4066Sahrens * '-r' is specified. 1092fa9e4066Sahrens */ 1093fa9e4066Sahrens typedef struct list_cbdata { 1094*99653d4eSeschrock boolean_t cb_first; 1095*99653d4eSeschrock boolean_t cb_scripted; 109607ba0419Seschrock zfs_prop_t cb_fields[ZFS_NPROP_ALL]; 1097fa9e4066Sahrens int cb_fieldcount; 1098fa9e4066Sahrens } list_cbdata_t; 1099fa9e4066Sahrens 1100fa9e4066Sahrens /* 1101fa9e4066Sahrens * Given a list of columns to display, output appropriate headers for each one. 1102fa9e4066Sahrens */ 1103fa9e4066Sahrens static void 110407ba0419Seschrock print_header(zfs_prop_t *fields, size_t count) 1105fa9e4066Sahrens { 1106fa9e4066Sahrens int i; 1107fa9e4066Sahrens 1108fa9e4066Sahrens for (i = 0; i < count; i++) { 1109fa9e4066Sahrens if (i != 0) 1110fa9e4066Sahrens (void) printf(" "); 1111fa9e4066Sahrens if (i == count - 1) 1112fa9e4066Sahrens (void) printf("%s", zfs_prop_column_name(fields[i])); 1113fa9e4066Sahrens else /* LINTED - format specifier */ 1114fa9e4066Sahrens (void) printf(zfs_prop_column_format(fields[i]), 1115fa9e4066Sahrens zfs_prop_column_name(fields[i])); 1116fa9e4066Sahrens } 1117fa9e4066Sahrens 1118fa9e4066Sahrens (void) printf("\n"); 1119fa9e4066Sahrens } 1120fa9e4066Sahrens 1121fa9e4066Sahrens /* 1122fa9e4066Sahrens * Given a dataset and a list of fields, print out all the properties according 1123fa9e4066Sahrens * to the described layout. 1124fa9e4066Sahrens */ 1125fa9e4066Sahrens static void 112607ba0419Seschrock print_dataset(zfs_handle_t *zhp, zfs_prop_t *fields, size_t count, int scripted) 1127fa9e4066Sahrens { 1128fa9e4066Sahrens int i; 1129fa9e4066Sahrens char property[ZFS_MAXPROPLEN]; 1130fa9e4066Sahrens 1131fa9e4066Sahrens for (i = 0; i < count; i++) { 1132fa9e4066Sahrens if (i != 0) { 1133fa9e4066Sahrens if (scripted) 1134fa9e4066Sahrens (void) printf("\t"); 1135fa9e4066Sahrens else 1136fa9e4066Sahrens (void) printf(" "); 1137fa9e4066Sahrens } 1138fa9e4066Sahrens 1139fa9e4066Sahrens if (zfs_prop_get(zhp, fields[i], property, 1140*99653d4eSeschrock sizeof (property), NULL, NULL, 0, B_FALSE) != 0) 1141fa9e4066Sahrens (void) strlcpy(property, "-", sizeof (property)); 1142fa9e4066Sahrens 114307ba0419Seschrock /* 114407ba0419Seschrock * If this is being called in scripted mode, or if this is the 114507ba0419Seschrock * last column and it is left-justified, don't include a width 114607ba0419Seschrock * format specifier. 114707ba0419Seschrock */ 114807ba0419Seschrock if (scripted || (i == count - 1 && 114907ba0419Seschrock strchr(zfs_prop_column_format(fields[i]), '-') != NULL)) 1150fa9e4066Sahrens (void) printf("%s", property); 1151fa9e4066Sahrens else /* LINTED - format specifier */ 1152fa9e4066Sahrens (void) printf(zfs_prop_column_format(fields[i]), 1153fa9e4066Sahrens property); 1154fa9e4066Sahrens } 1155fa9e4066Sahrens 1156fa9e4066Sahrens (void) printf("\n"); 1157fa9e4066Sahrens } 1158fa9e4066Sahrens 1159fa9e4066Sahrens /* 1160fa9e4066Sahrens * Generic callback function to list a dataset or snapshot. 1161fa9e4066Sahrens */ 1162fa9e4066Sahrens static int 1163fa9e4066Sahrens list_callback(zfs_handle_t *zhp, void *data) 1164fa9e4066Sahrens { 1165fa9e4066Sahrens list_cbdata_t *cbp = data; 1166fa9e4066Sahrens 1167fa9e4066Sahrens if (cbp->cb_first) { 1168fa9e4066Sahrens if (!cbp->cb_scripted) 1169fa9e4066Sahrens print_header(cbp->cb_fields, cbp->cb_fieldcount); 1170*99653d4eSeschrock cbp->cb_first = B_FALSE; 1171fa9e4066Sahrens } 1172fa9e4066Sahrens 1173fa9e4066Sahrens print_dataset(zhp, cbp->cb_fields, cbp->cb_fieldcount, 1174fa9e4066Sahrens cbp->cb_scripted); 1175fa9e4066Sahrens 1176fa9e4066Sahrens return (0); 1177fa9e4066Sahrens } 1178fa9e4066Sahrens 1179fa9e4066Sahrens static int 1180fa9e4066Sahrens zfs_do_list(int argc, char **argv) 1181fa9e4066Sahrens { 1182fa9e4066Sahrens int c; 1183*99653d4eSeschrock boolean_t recurse = B_FALSE; 1184*99653d4eSeschrock boolean_t scripted = B_FALSE; 1185fa9e4066Sahrens static char default_fields[] = 1186fa9e4066Sahrens "name,used,available,referenced,mountpoint"; 1187fa9e4066Sahrens int types = ZFS_TYPE_ANY; 1188fa9e4066Sahrens char *fields = NULL; 1189fa9e4066Sahrens char *basic_fields = default_fields; 1190fa9e4066Sahrens list_cbdata_t cb = { 0 }; 1191fa9e4066Sahrens char *value; 1192fa9e4066Sahrens int ret; 1193fa9e4066Sahrens char *type_subopts[] = { "filesystem", "volume", "snapshot", NULL }; 119407ba0419Seschrock char *badopt; 119507ba0419Seschrock int alloffset; 1196fa9e4066Sahrens 1197fa9e4066Sahrens /* check options */ 1198fa9e4066Sahrens while ((c = getopt(argc, argv, ":o:rt:H")) != -1) { 1199fa9e4066Sahrens switch (c) { 1200fa9e4066Sahrens case 'o': 1201fa9e4066Sahrens fields = optarg; 1202fa9e4066Sahrens break; 1203fa9e4066Sahrens case 'r': 1204*99653d4eSeschrock recurse = B_TRUE; 1205fa9e4066Sahrens break; 1206fa9e4066Sahrens case 'H': 1207*99653d4eSeschrock scripted = B_TRUE; 1208fa9e4066Sahrens break; 1209fa9e4066Sahrens case 't': 1210fa9e4066Sahrens types = 0; 1211fa9e4066Sahrens while (*optarg != '\0') { 1212fa9e4066Sahrens switch (getsubopt(&optarg, type_subopts, 1213fa9e4066Sahrens &value)) { 1214fa9e4066Sahrens case 0: 1215fa9e4066Sahrens types |= ZFS_TYPE_FILESYSTEM; 1216fa9e4066Sahrens break; 1217fa9e4066Sahrens case 1: 1218fa9e4066Sahrens types |= ZFS_TYPE_VOLUME; 1219fa9e4066Sahrens break; 1220fa9e4066Sahrens case 2: 1221fa9e4066Sahrens types |= ZFS_TYPE_SNAPSHOT; 1222fa9e4066Sahrens break; 1223fa9e4066Sahrens default: 1224fa9e4066Sahrens (void) fprintf(stderr, 1225fa9e4066Sahrens gettext("invalid type '%s'\n"), 1226fa9e4066Sahrens value); 1227*99653d4eSeschrock usage(B_FALSE); 1228fa9e4066Sahrens } 1229fa9e4066Sahrens } 1230fa9e4066Sahrens break; 1231fa9e4066Sahrens case ':': 1232fa9e4066Sahrens (void) fprintf(stderr, gettext("missing argument for " 1233fa9e4066Sahrens "'%c' option\n"), optopt); 1234*99653d4eSeschrock usage(B_FALSE); 1235fa9e4066Sahrens break; 1236fa9e4066Sahrens case '?': 1237fa9e4066Sahrens (void) fprintf(stderr, gettext("invalid option '%c'\n"), 1238fa9e4066Sahrens optopt); 1239*99653d4eSeschrock usage(B_FALSE); 1240fa9e4066Sahrens } 1241fa9e4066Sahrens } 1242fa9e4066Sahrens 1243fa9e4066Sahrens argc -= optind; 1244fa9e4066Sahrens argv += optind; 1245fa9e4066Sahrens 1246fa9e4066Sahrens if (fields == NULL) 1247fa9e4066Sahrens fields = basic_fields; 1248fa9e4066Sahrens 124907ba0419Seschrock /* 125007ba0419Seschrock * If the user specifies '-o all', the zfs_get_proplist() doesn't 125107ba0419Seschrock * normally include the name of the dataset. For 'zfs list', we always 125207ba0419Seschrock * want this property to be first. 125307ba0419Seschrock */ 125407ba0419Seschrock if (strcmp(fields, "all") == 0) { 125507ba0419Seschrock cb.cb_fields[0] = ZFS_PROP_NAME; 125607ba0419Seschrock alloffset = 1; 125707ba0419Seschrock } else { 125807ba0419Seschrock alloffset = 0; 1259fa9e4066Sahrens } 1260fa9e4066Sahrens 126107ba0419Seschrock if ((ret = zfs_get_proplist(fields, cb.cb_fields + alloffset, 126207ba0419Seschrock ZFS_NPROP_ALL - alloffset, &cb.cb_fieldcount, &badopt)) != 0) { 126307ba0419Seschrock if (ret == EINVAL) 1264fa9e4066Sahrens (void) fprintf(stderr, gettext("invalid property " 126507ba0419Seschrock "'%s'\n"), badopt); 126607ba0419Seschrock else 126707ba0419Seschrock (void) fprintf(stderr, gettext("too many properties " 126807ba0419Seschrock "specified\n")); 1269*99653d4eSeschrock usage(B_FALSE); 1270fa9e4066Sahrens } 1271fa9e4066Sahrens 127207ba0419Seschrock cb.cb_fieldcount += alloffset; 1273fa9e4066Sahrens cb.cb_scripted = scripted; 1274*99653d4eSeschrock cb.cb_first = B_TRUE; 1275fa9e4066Sahrens 1276fa9e4066Sahrens ret = zfs_for_each(argc, argv, recurse, types, list_callback, &cb); 1277fa9e4066Sahrens 1278*99653d4eSeschrock if (ret == 0 && cb.cb_first) 1279fa9e4066Sahrens (void) printf(gettext("no datasets available\n")); 1280fa9e4066Sahrens 1281fa9e4066Sahrens return (ret); 1282fa9e4066Sahrens } 1283fa9e4066Sahrens 1284fa9e4066Sahrens /* 1285fa9e4066Sahrens * zfs rename <fs | snap | vol> <fs | snap | vol> 1286fa9e4066Sahrens * 1287fa9e4066Sahrens * Renames the given dataset to another of the same type. 1288fa9e4066Sahrens */ 1289fa9e4066Sahrens /* ARGSUSED */ 1290fa9e4066Sahrens static int 1291fa9e4066Sahrens zfs_do_rename(int argc, char **argv) 1292fa9e4066Sahrens { 1293fa9e4066Sahrens zfs_handle_t *zhp; 1294*99653d4eSeschrock int ret; 1295fa9e4066Sahrens 1296fa9e4066Sahrens /* check options */ 1297fa9e4066Sahrens if (argc > 1 && argv[1][0] == '-') { 1298fa9e4066Sahrens (void) fprintf(stderr, gettext("invalid option '%c'\n"), 1299fa9e4066Sahrens argv[1][1]); 1300*99653d4eSeschrock usage(B_FALSE); 1301fa9e4066Sahrens } 1302fa9e4066Sahrens 1303fa9e4066Sahrens /* check number of arguments */ 1304fa9e4066Sahrens if (argc < 2) { 1305fa9e4066Sahrens (void) fprintf(stderr, gettext("missing source dataset " 1306fa9e4066Sahrens "argument\n")); 1307*99653d4eSeschrock usage(B_FALSE); 1308fa9e4066Sahrens } 1309fa9e4066Sahrens if (argc < 3) { 1310fa9e4066Sahrens (void) fprintf(stderr, gettext("missing target dataset " 1311fa9e4066Sahrens "argument\n")); 1312*99653d4eSeschrock usage(B_FALSE); 1313fa9e4066Sahrens } 1314fa9e4066Sahrens if (argc > 3) { 1315fa9e4066Sahrens (void) fprintf(stderr, gettext("too many arguments\n")); 1316*99653d4eSeschrock usage(B_FALSE); 1317fa9e4066Sahrens } 1318fa9e4066Sahrens 1319*99653d4eSeschrock if ((zhp = zfs_open(g_zfs, argv[1], ZFS_TYPE_ANY)) == NULL) 1320fa9e4066Sahrens return (1); 1321fa9e4066Sahrens 1322*99653d4eSeschrock ret = (zfs_rename(zhp, argv[2]) != 0); 1323fa9e4066Sahrens 1324*99653d4eSeschrock zfs_close(zhp); 1325*99653d4eSeschrock return (ret); 1326*99653d4eSeschrock } 1327*99653d4eSeschrock 1328*99653d4eSeschrock /* 1329*99653d4eSeschrock * zfs promote <fs> 1330*99653d4eSeschrock * 1331*99653d4eSeschrock * Promotes the given clone fs to be the parent 1332*99653d4eSeschrock */ 1333*99653d4eSeschrock /* ARGSUSED */ 1334*99653d4eSeschrock static int 1335*99653d4eSeschrock zfs_do_promote(int argc, char **argv) 1336*99653d4eSeschrock { 1337*99653d4eSeschrock zfs_handle_t *zhp; 1338*99653d4eSeschrock int ret; 1339*99653d4eSeschrock 1340*99653d4eSeschrock /* check options */ 1341*99653d4eSeschrock if (argc > 1 && argv[1][0] == '-') { 1342*99653d4eSeschrock (void) fprintf(stderr, gettext("invalid option '%c'\n"), 1343*99653d4eSeschrock argv[1][1]); 1344*99653d4eSeschrock usage(B_FALSE); 1345*99653d4eSeschrock } 1346*99653d4eSeschrock 1347*99653d4eSeschrock /* check number of arguments */ 1348*99653d4eSeschrock if (argc < 2) { 1349*99653d4eSeschrock (void) fprintf(stderr, gettext("missing clone filesystem" 1350*99653d4eSeschrock "argument\n")); 1351*99653d4eSeschrock usage(B_FALSE); 1352*99653d4eSeschrock } 1353*99653d4eSeschrock if (argc > 2) { 1354*99653d4eSeschrock (void) fprintf(stderr, gettext("too many arguments\n")); 1355*99653d4eSeschrock usage(B_FALSE); 1356*99653d4eSeschrock } 1357*99653d4eSeschrock 1358*99653d4eSeschrock zhp = zfs_open(g_zfs, argv[1], ZFS_TYPE_FILESYSTEM | ZFS_TYPE_VOLUME); 1359*99653d4eSeschrock if (zhp == NULL) 1360*99653d4eSeschrock return (1); 1361*99653d4eSeschrock 1362*99653d4eSeschrock ret = (zfs_promote(zhp) != 0); 1363*99653d4eSeschrock 1364fa9e4066Sahrens zfs_close(zhp); 1365fa9e4066Sahrens return (ret); 1366fa9e4066Sahrens } 1367fa9e4066Sahrens 1368fa9e4066Sahrens /* 1369fa9e4066Sahrens * zfs rollback [-rfR] <snapshot> 1370fa9e4066Sahrens * 1371fa9e4066Sahrens * -r Delete any intervening snapshots before doing rollback 1372fa9e4066Sahrens * -R Delete any snapshots and their clones 1373fa9e4066Sahrens * -f Force unmount filesystems, even if they are in use. 1374fa9e4066Sahrens * 1375fa9e4066Sahrens * Given a filesystem, rollback to a specific snapshot, discarding any changes 1376fa9e4066Sahrens * since then and making it the active dataset. If more recent snapshots exist, 1377fa9e4066Sahrens * the command will complain unless the '-r' flag is given. 1378fa9e4066Sahrens */ 1379fa9e4066Sahrens typedef struct rollback_cbdata { 1380fa9e4066Sahrens uint64_t cb_create; 1381*99653d4eSeschrock boolean_t cb_first; 1382fa9e4066Sahrens int cb_doclones; 1383fa9e4066Sahrens char *cb_target; 1384fa9e4066Sahrens int cb_error; 1385*99653d4eSeschrock boolean_t cb_recurse; 1386*99653d4eSeschrock boolean_t cb_dependent; 1387fa9e4066Sahrens } rollback_cbdata_t; 1388fa9e4066Sahrens 1389fa9e4066Sahrens /* 1390fa9e4066Sahrens * Report any snapshots more recent than the one specified. Used when '-r' is 1391fa9e4066Sahrens * not specified. We reuse this same callback for the snapshot dependents - if 1392fa9e4066Sahrens * 'cb_dependent' is set, then this is a dependent and we should report it 1393fa9e4066Sahrens * without checking the transaction group. 1394fa9e4066Sahrens */ 1395fa9e4066Sahrens static int 1396fa9e4066Sahrens rollback_check(zfs_handle_t *zhp, void *data) 1397fa9e4066Sahrens { 1398fa9e4066Sahrens rollback_cbdata_t *cbp = data; 1399fa9e4066Sahrens 1400*99653d4eSeschrock if (cbp->cb_doclones) { 1401*99653d4eSeschrock zfs_close(zhp); 1402fa9e4066Sahrens return (0); 1403*99653d4eSeschrock } 1404fa9e4066Sahrens 1405fa9e4066Sahrens if (!cbp->cb_dependent) { 1406fa9e4066Sahrens if (strcmp(zfs_get_name(zhp), cbp->cb_target) != 0 && 1407b12a1c38Slling zfs_get_type(zhp) == ZFS_TYPE_SNAPSHOT && 1408fa9e4066Sahrens zfs_prop_get_int(zhp, ZFS_PROP_CREATETXG) > 1409fa9e4066Sahrens cbp->cb_create) { 1410fa9e4066Sahrens 1411fa9e4066Sahrens if (cbp->cb_first && !cbp->cb_recurse) { 1412fa9e4066Sahrens (void) fprintf(stderr, gettext("cannot " 1413fa9e4066Sahrens "rollback to '%s': more recent snapshots " 1414fa9e4066Sahrens "exist\n"), 1415fa9e4066Sahrens cbp->cb_target); 1416fa9e4066Sahrens (void) fprintf(stderr, gettext("use '-r' to " 1417fa9e4066Sahrens "force deletion of the following " 1418fa9e4066Sahrens "snapshots:\n")); 1419fa9e4066Sahrens cbp->cb_first = 0; 1420fa9e4066Sahrens cbp->cb_error = 1; 1421fa9e4066Sahrens } 1422fa9e4066Sahrens 1423fa9e4066Sahrens if (cbp->cb_recurse) { 1424*99653d4eSeschrock cbp->cb_dependent = B_TRUE; 1425fa9e4066Sahrens (void) zfs_iter_dependents(zhp, rollback_check, 1426fa9e4066Sahrens cbp); 1427*99653d4eSeschrock cbp->cb_dependent = B_FALSE; 1428fa9e4066Sahrens } else { 1429fa9e4066Sahrens (void) fprintf(stderr, "%s\n", 1430fa9e4066Sahrens zfs_get_name(zhp)); 1431fa9e4066Sahrens } 1432fa9e4066Sahrens } 1433fa9e4066Sahrens } else { 1434fa9e4066Sahrens if (cbp->cb_first && cbp->cb_recurse) { 1435fa9e4066Sahrens (void) fprintf(stderr, gettext("cannot rollback to " 1436fa9e4066Sahrens "'%s': clones of previous snapshots exist\n"), 1437fa9e4066Sahrens cbp->cb_target); 1438fa9e4066Sahrens (void) fprintf(stderr, gettext("use '-R' to " 1439fa9e4066Sahrens "force deletion of the following clones and " 1440fa9e4066Sahrens "dependents:\n")); 1441fa9e4066Sahrens cbp->cb_first = 0; 1442fa9e4066Sahrens cbp->cb_error = 1; 1443fa9e4066Sahrens } 1444fa9e4066Sahrens 1445fa9e4066Sahrens (void) fprintf(stderr, "%s\n", zfs_get_name(zhp)); 1446fa9e4066Sahrens } 1447fa9e4066Sahrens 1448fa9e4066Sahrens zfs_close(zhp); 1449fa9e4066Sahrens return (0); 1450fa9e4066Sahrens } 1451fa9e4066Sahrens 1452fa9e4066Sahrens static int 1453fa9e4066Sahrens zfs_do_rollback(int argc, char **argv) 1454fa9e4066Sahrens { 1455fa9e4066Sahrens int ret; 1456fa9e4066Sahrens int c; 1457fa9e4066Sahrens rollback_cbdata_t cb = { 0 }; 1458fa9e4066Sahrens zfs_handle_t *zhp, *snap; 1459fa9e4066Sahrens char parentname[ZFS_MAXNAMELEN]; 1460fa9e4066Sahrens char *delim; 1461b12a1c38Slling int force = 0; 1462fa9e4066Sahrens 1463fa9e4066Sahrens /* check options */ 1464fa9e4066Sahrens while ((c = getopt(argc, argv, "rfR")) != -1) { 1465fa9e4066Sahrens switch (c) { 1466fa9e4066Sahrens case 'f': 1467b12a1c38Slling force = 1; 1468fa9e4066Sahrens break; 1469fa9e4066Sahrens case 'r': 1470fa9e4066Sahrens cb.cb_recurse = 1; 1471fa9e4066Sahrens break; 1472fa9e4066Sahrens case 'R': 1473fa9e4066Sahrens cb.cb_recurse = 1; 1474fa9e4066Sahrens cb.cb_doclones = 1; 1475fa9e4066Sahrens break; 1476fa9e4066Sahrens case '?': 1477fa9e4066Sahrens (void) fprintf(stderr, gettext("invalid option '%c'\n"), 1478fa9e4066Sahrens optopt); 1479*99653d4eSeschrock usage(B_FALSE); 1480fa9e4066Sahrens } 1481fa9e4066Sahrens } 1482fa9e4066Sahrens 1483fa9e4066Sahrens argc -= optind; 1484fa9e4066Sahrens argv += optind; 1485fa9e4066Sahrens 1486fa9e4066Sahrens /* check number of arguments */ 1487fa9e4066Sahrens if (argc < 1) { 1488fa9e4066Sahrens (void) fprintf(stderr, gettext("missing dataset argument\n")); 1489*99653d4eSeschrock usage(B_FALSE); 1490fa9e4066Sahrens } 1491fa9e4066Sahrens if (argc > 1) { 1492fa9e4066Sahrens (void) fprintf(stderr, gettext("too many arguments\n")); 1493*99653d4eSeschrock usage(B_FALSE); 1494fa9e4066Sahrens } 1495fa9e4066Sahrens 1496fa9e4066Sahrens /* open the snapshot */ 1497*99653d4eSeschrock if ((snap = zfs_open(g_zfs, argv[0], ZFS_TYPE_SNAPSHOT)) == NULL) 1498fa9e4066Sahrens return (1); 1499fa9e4066Sahrens 1500b12a1c38Slling /* open the parent dataset */ 1501b12a1c38Slling (void) strlcpy(parentname, argv[0], sizeof (parentname)); 1502fa9e4066Sahrens verify((delim = strrchr(parentname, '@')) != NULL); 1503fa9e4066Sahrens *delim = '\0'; 1504*99653d4eSeschrock if ((zhp = zfs_open(g_zfs, parentname, ZFS_TYPE_ANY)) == NULL) { 1505fa9e4066Sahrens zfs_close(snap); 1506fa9e4066Sahrens return (1); 1507fa9e4066Sahrens } 1508fa9e4066Sahrens 1509fa9e4066Sahrens /* 1510fa9e4066Sahrens * Check for more recent snapshots and/or clones based on the presence 1511fa9e4066Sahrens * of '-r' and '-R'. 1512fa9e4066Sahrens */ 1513b12a1c38Slling cb.cb_target = argv[0]; 1514b12a1c38Slling cb.cb_create = zfs_prop_get_int(snap, ZFS_PROP_CREATETXG); 1515*99653d4eSeschrock cb.cb_first = B_TRUE; 1516fa9e4066Sahrens cb.cb_error = 0; 1517fa9e4066Sahrens (void) zfs_iter_children(zhp, rollback_check, &cb); 1518fa9e4066Sahrens 1519fa9e4066Sahrens if ((ret = cb.cb_error) != 0) 1520fa9e4066Sahrens goto out; 1521fa9e4066Sahrens 1522fa9e4066Sahrens /* 1523b12a1c38Slling * Rollback parent to the given snapshot. 1524fa9e4066Sahrens */ 1525b12a1c38Slling ret = zfs_rollback(zhp, snap, force); 1526fa9e4066Sahrens 1527fa9e4066Sahrens out: 1528fa9e4066Sahrens zfs_close(snap); 1529fa9e4066Sahrens zfs_close(zhp); 1530fa9e4066Sahrens 1531fa9e4066Sahrens if (ret == 0) 1532fa9e4066Sahrens return (0); 1533fa9e4066Sahrens else 1534fa9e4066Sahrens return (1); 1535fa9e4066Sahrens } 1536fa9e4066Sahrens 1537fa9e4066Sahrens /* 1538fa9e4066Sahrens * zfs set property=value { fs | snap | vol } ... 1539fa9e4066Sahrens * 1540fa9e4066Sahrens * Sets the given property for all datasets specified on the command line. 1541fa9e4066Sahrens */ 1542fa9e4066Sahrens typedef struct set_cbdata { 1543fa9e4066Sahrens char *cb_propname; 1544fa9e4066Sahrens char *cb_value; 1545fa9e4066Sahrens zfs_prop_t cb_prop; 1546fa9e4066Sahrens } set_cbdata_t; 1547fa9e4066Sahrens 1548fa9e4066Sahrens static int 1549fa9e4066Sahrens set_callback(zfs_handle_t *zhp, void *data) 1550fa9e4066Sahrens { 1551fa9e4066Sahrens set_cbdata_t *cbp = data; 1552fa9e4066Sahrens int ret = 1; 1553fa9e4066Sahrens 1554fa9e4066Sahrens /* don't allow setting of properties for snapshots */ 1555fa9e4066Sahrens if (zfs_get_type(zhp) == ZFS_TYPE_SNAPSHOT) { 1556fa9e4066Sahrens (void) fprintf(stderr, gettext("cannot set %s property for " 1557fa9e4066Sahrens "'%s': snapshot properties cannot be modified\n"), 1558fa9e4066Sahrens cbp->cb_propname, zfs_get_name(zhp)); 1559fa9e4066Sahrens return (1); 1560fa9e4066Sahrens } 1561fa9e4066Sahrens 1562fa9e4066Sahrens /* 15635c5460e9Seschrock * If we're changing the volsize, make sure the value is appropriate, 15645c5460e9Seschrock * and set the reservation if this is a non-sparse volume. 1565fa9e4066Sahrens */ 1566fa9e4066Sahrens if (cbp->cb_prop == ZFS_PROP_VOLSIZE && 15675c5460e9Seschrock zfs_get_type(zhp) == ZFS_TYPE_VOLUME) { 1568fa9e4066Sahrens uint64_t volsize = zfs_prop_get_int(zhp, ZFS_PROP_VOLSIZE); 1569fa9e4066Sahrens uint64_t avail = zfs_prop_get_int(zhp, ZFS_PROP_AVAILABLE); 15705c5460e9Seschrock uint64_t reservation = zfs_prop_get_int(zhp, 15715c5460e9Seschrock ZFS_PROP_RESERVATION); 15725c5460e9Seschrock uint64_t blocksize = zfs_prop_get_int(zhp, 15735c5460e9Seschrock ZFS_PROP_VOLBLOCKSIZE); 1574fa9e4066Sahrens uint64_t value; 1575fa9e4066Sahrens 1576fa9e4066Sahrens verify(zfs_nicestrtonum(cbp->cb_value, &value) == 0); 1577fa9e4066Sahrens 15785c5460e9Seschrock if (value % blocksize != 0) { 15795c5460e9Seschrock char buf[64]; 15805c5460e9Seschrock 15815c5460e9Seschrock zfs_nicenum(blocksize, buf, sizeof (buf)); 15825c5460e9Seschrock (void) fprintf(stderr, gettext("cannot set %s for " 15835c5460e9Seschrock "'%s': must be a multiple of volume block size " 15845c5460e9Seschrock "(%s)\n"), cbp->cb_propname, zfs_get_name(zhp), 15855c5460e9Seschrock buf); 15865c5460e9Seschrock return (1); 15875c5460e9Seschrock } 15885c5460e9Seschrock 15895c5460e9Seschrock if (value == 0) { 15905c5460e9Seschrock (void) fprintf(stderr, gettext("cannot set %s for " 15915c5460e9Seschrock "'%s': cannot be zero\n"), cbp->cb_propname, 15925c5460e9Seschrock zfs_get_name(zhp)); 15935c5460e9Seschrock return (1); 15945c5460e9Seschrock } 15955c5460e9Seschrock 15965c5460e9Seschrock if (volsize == reservation) { 1597fa9e4066Sahrens if (value > volsize && (value - volsize) > avail) { 1598fa9e4066Sahrens (void) fprintf(stderr, gettext("cannot set " 1599fa9e4066Sahrens "%s property for '%s': volume size exceeds " 1600fa9e4066Sahrens "amount of available space\n"), 1601fa9e4066Sahrens cbp->cb_propname, zfs_get_name(zhp)); 1602fa9e4066Sahrens return (1); 1603fa9e4066Sahrens } 1604fa9e4066Sahrens 1605fa9e4066Sahrens if (zfs_prop_set(zhp, ZFS_PROP_RESERVATION, 1606fa9e4066Sahrens cbp->cb_value) != 0) { 1607fa9e4066Sahrens (void) fprintf(stderr, gettext("volsize and " 1608fa9e4066Sahrens "reservation must remain equal\n")); 1609fa9e4066Sahrens return (1); 1610fa9e4066Sahrens } 1611fa9e4066Sahrens } 16125c5460e9Seschrock } 1613fa9e4066Sahrens 1614fa9e4066Sahrens /* 1615fa9e4066Sahrens * Do not allow the reservation to be set above the volume size. We do 1616fa9e4066Sahrens * this here instead of inside libzfs because libzfs violates this rule 1617fa9e4066Sahrens * internally. 1618fa9e4066Sahrens */ 1619fa9e4066Sahrens if (cbp->cb_prop == ZFS_PROP_RESERVATION && 1620fa9e4066Sahrens zfs_get_type(zhp) == ZFS_TYPE_VOLUME) { 1621fa9e4066Sahrens uint64_t value; 1622fa9e4066Sahrens uint64_t volsize; 1623fa9e4066Sahrens 1624fa9e4066Sahrens volsize = zfs_prop_get_int(zhp, ZFS_PROP_VOLSIZE); 1625fa9e4066Sahrens if (strcmp(cbp->cb_value, "none") == 0) 1626fa9e4066Sahrens value = 0; 1627fa9e4066Sahrens else 1628fa9e4066Sahrens verify(zfs_nicestrtonum(cbp->cb_value, &value) == 0); 1629fa9e4066Sahrens 1630fa9e4066Sahrens if (value > volsize) { 1631fa9e4066Sahrens (void) fprintf(stderr, gettext("cannot set %s " 1632fa9e4066Sahrens "for '%s': size is greater than current " 1633fa9e4066Sahrens "volume size\n"), cbp->cb_propname, 1634fa9e4066Sahrens zfs_get_name(zhp)); 1635fa9e4066Sahrens return (-1); 1636fa9e4066Sahrens } 1637fa9e4066Sahrens } 1638fa9e4066Sahrens 1639fa9e4066Sahrens if (zfs_prop_set(zhp, cbp->cb_prop, cbp->cb_value) != 0) 1640fa9e4066Sahrens return (1); 1641fa9e4066Sahrens 1642fa9e4066Sahrens ret = 0; 1643fa9e4066Sahrens error: 1644fa9e4066Sahrens return (ret); 1645fa9e4066Sahrens } 1646fa9e4066Sahrens 1647fa9e4066Sahrens static int 1648fa9e4066Sahrens zfs_do_set(int argc, char **argv) 1649fa9e4066Sahrens { 1650fa9e4066Sahrens set_cbdata_t cb; 1651fa9e4066Sahrens 1652fa9e4066Sahrens /* check for options */ 1653fa9e4066Sahrens if (argc > 1 && argv[1][0] == '-') { 1654fa9e4066Sahrens (void) fprintf(stderr, gettext("invalid option '%c'\n"), 1655fa9e4066Sahrens argv[1][1]); 1656*99653d4eSeschrock usage(B_FALSE); 1657fa9e4066Sahrens } 1658fa9e4066Sahrens 1659fa9e4066Sahrens /* check number of arguments */ 1660fa9e4066Sahrens if (argc < 2) { 1661fa9e4066Sahrens (void) fprintf(stderr, gettext("missing property=value " 1662fa9e4066Sahrens "argument\n")); 1663*99653d4eSeschrock usage(B_FALSE); 1664fa9e4066Sahrens } 1665fa9e4066Sahrens if (argc < 3) { 1666fa9e4066Sahrens (void) fprintf(stderr, gettext("missing dataset name\n")); 1667*99653d4eSeschrock usage(B_FALSE); 1668fa9e4066Sahrens } 1669fa9e4066Sahrens 1670fa9e4066Sahrens /* validate property=value argument */ 1671fa9e4066Sahrens cb.cb_propname = argv[1]; 1672fa9e4066Sahrens if ((cb.cb_value = strchr(cb.cb_propname, '=')) == NULL) { 1673fa9e4066Sahrens (void) fprintf(stderr, gettext("missing value in " 1674fa9e4066Sahrens "property=value argument\n")); 1675*99653d4eSeschrock usage(B_FALSE); 1676fa9e4066Sahrens } 1677fa9e4066Sahrens 1678fa9e4066Sahrens *cb.cb_value = '\0'; 1679fa9e4066Sahrens cb.cb_value++; 1680fa9e4066Sahrens 1681fa9e4066Sahrens if (*cb.cb_propname == '\0') { 1682fa9e4066Sahrens (void) fprintf(stderr, 1683fa9e4066Sahrens gettext("missing property in property=value argument\n")); 1684*99653d4eSeschrock usage(B_FALSE); 1685fa9e4066Sahrens } 1686fa9e4066Sahrens if (*cb.cb_value == '\0') { 1687fa9e4066Sahrens (void) fprintf(stderr, 1688fa9e4066Sahrens gettext("missing value in property=value argument\n")); 1689*99653d4eSeschrock usage(B_FALSE); 1690fa9e4066Sahrens } 1691fa9e4066Sahrens 1692fa9e4066Sahrens /* get the property type */ 1693fa9e4066Sahrens if ((cb.cb_prop = zfs_name_to_prop(cb.cb_propname)) == 1694fa9e4066Sahrens ZFS_PROP_INVAL) { 1695fa9e4066Sahrens (void) fprintf(stderr, 1696fa9e4066Sahrens gettext("invalid property '%s'\n"), cb.cb_propname); 1697*99653d4eSeschrock usage(B_FALSE); 1698fa9e4066Sahrens } 1699fa9e4066Sahrens 1700fa9e4066Sahrens /* 1701fa9e4066Sahrens * Validate that the value is appropriate for this property. We do this 1702fa9e4066Sahrens * once now so we don't generate multiple errors each time we try to 1703fa9e4066Sahrens * apply it to a dataset. 1704fa9e4066Sahrens */ 1705*99653d4eSeschrock if (zfs_prop_validate(g_zfs, cb.cb_prop, cb.cb_value, NULL) != 0) 1706fa9e4066Sahrens return (1); 1707fa9e4066Sahrens 1708*99653d4eSeschrock return (zfs_for_each(argc - 2, argv + 2, B_FALSE, 1709fa9e4066Sahrens ZFS_TYPE_ANY, set_callback, &cb)); 1710fa9e4066Sahrens } 1711fa9e4066Sahrens 1712fa9e4066Sahrens /* 1713fa9e4066Sahrens * zfs snapshot <fs@snap> 1714fa9e4066Sahrens * 1715fa9e4066Sahrens * Creates a snapshot with the given name. While functionally equivalent to 1716fa9e4066Sahrens * 'zfs create', it is a separate command to diffferentiate intent. 1717fa9e4066Sahrens */ 1718fa9e4066Sahrens static int 1719fa9e4066Sahrens zfs_do_snapshot(int argc, char **argv) 1720fa9e4066Sahrens { 1721fa9e4066Sahrens /* check options */ 1722fa9e4066Sahrens if (argc > 1 && argv[1][0] == '-') { 1723fa9e4066Sahrens (void) fprintf(stderr, gettext("invalid option '%c'\n"), 1724fa9e4066Sahrens argv[1][1]); 1725*99653d4eSeschrock usage(B_FALSE); 1726fa9e4066Sahrens } 1727fa9e4066Sahrens 1728fa9e4066Sahrens /* check number of arguments */ 1729fa9e4066Sahrens if (argc < 2) { 1730fa9e4066Sahrens (void) fprintf(stderr, gettext("missing snapshot argument\n")); 1731*99653d4eSeschrock usage(B_FALSE); 1732fa9e4066Sahrens } 1733fa9e4066Sahrens if (argc > 2) { 1734fa9e4066Sahrens (void) fprintf(stderr, gettext("too many arguments\n")); 1735*99653d4eSeschrock usage(B_FALSE); 1736fa9e4066Sahrens } 1737fa9e4066Sahrens 1738*99653d4eSeschrock return (zfs_snapshot(g_zfs, argv[1]) != 0); 1739fa9e4066Sahrens } 1740fa9e4066Sahrens 1741fa9e4066Sahrens /* 1742f2a3c691Sahrens * zfs send [-i <fs@snap>] <fs@snap> 1743fa9e4066Sahrens * 1744fa9e4066Sahrens * Send a backup stream to stdout. 1745fa9e4066Sahrens */ 1746fa9e4066Sahrens static int 1747f2a3c691Sahrens zfs_do_send(int argc, char **argv) 1748fa9e4066Sahrens { 1749fa9e4066Sahrens char *fromname = NULL; 1750fa9e4066Sahrens zfs_handle_t *zhp_from = NULL, *zhp_to; 1751fa9e4066Sahrens int c, err; 1752fa9e4066Sahrens 1753fa9e4066Sahrens /* check options */ 1754fa9e4066Sahrens while ((c = getopt(argc, argv, ":i:")) != -1) { 1755fa9e4066Sahrens switch (c) { 1756fa9e4066Sahrens case 'i': 1757fa9e4066Sahrens fromname = optarg; 1758fa9e4066Sahrens break; 1759fa9e4066Sahrens case ':': 1760fa9e4066Sahrens (void) fprintf(stderr, gettext("missing argument for " 1761fa9e4066Sahrens "'%c' option\n"), optopt); 1762*99653d4eSeschrock usage(B_FALSE); 1763fa9e4066Sahrens break; 1764fa9e4066Sahrens case '?': 1765fa9e4066Sahrens (void) fprintf(stderr, gettext("invalid option '%c'\n"), 1766fa9e4066Sahrens optopt); 1767*99653d4eSeschrock usage(B_FALSE); 1768fa9e4066Sahrens } 1769fa9e4066Sahrens } 1770fa9e4066Sahrens 1771fa9e4066Sahrens argc -= optind; 1772fa9e4066Sahrens argv += optind; 1773fa9e4066Sahrens 1774fa9e4066Sahrens /* check number of arguments */ 1775fa9e4066Sahrens if (argc < 1) { 1776fa9e4066Sahrens (void) fprintf(stderr, gettext("missing snapshot argument\n")); 1777*99653d4eSeschrock usage(B_FALSE); 1778fa9e4066Sahrens } 1779fa9e4066Sahrens if (argc > 1) { 1780fa9e4066Sahrens (void) fprintf(stderr, gettext("too many arguments\n")); 1781*99653d4eSeschrock usage(B_FALSE); 1782fa9e4066Sahrens } 1783fa9e4066Sahrens 1784fa9e4066Sahrens if (isatty(STDOUT_FILENO)) { 1785fa9e4066Sahrens (void) fprintf(stderr, 1786f2a3c691Sahrens gettext("Error: Stream can not be written " 1787fa9e4066Sahrens "to a terminal.\n" 1788fa9e4066Sahrens "You must redirect standard output.\n")); 1789fa9e4066Sahrens return (1); 1790fa9e4066Sahrens } 1791fa9e4066Sahrens 1792fa9e4066Sahrens if (fromname) { 1793*99653d4eSeschrock if ((zhp_from = zfs_open(g_zfs, fromname, 1794*99653d4eSeschrock ZFS_TYPE_SNAPSHOT)) == NULL) 1795fa9e4066Sahrens return (1); 1796fa9e4066Sahrens } 1797*99653d4eSeschrock if ((zhp_to = zfs_open(g_zfs, argv[0], ZFS_TYPE_SNAPSHOT)) == NULL) 1798fa9e4066Sahrens return (1); 1799fa9e4066Sahrens 1800f2a3c691Sahrens err = zfs_send(zhp_to, zhp_from); 1801fa9e4066Sahrens 1802fa9e4066Sahrens if (zhp_from) 1803fa9e4066Sahrens zfs_close(zhp_from); 1804fa9e4066Sahrens zfs_close(zhp_to); 1805fa9e4066Sahrens 1806fa9e4066Sahrens return (err != 0); 1807fa9e4066Sahrens } 1808fa9e4066Sahrens 1809fa9e4066Sahrens /* 1810f2a3c691Sahrens * zfs receive <fs@snap> 1811fa9e4066Sahrens * 1812fa9e4066Sahrens * Restore a backup stream from stdin. 1813fa9e4066Sahrens */ 1814fa9e4066Sahrens static int 1815f2a3c691Sahrens zfs_do_receive(int argc, char **argv) 1816fa9e4066Sahrens { 1817fa9e4066Sahrens int c, err; 1818*99653d4eSeschrock boolean_t isprefix = B_FALSE; 1819*99653d4eSeschrock boolean_t dryrun = B_FALSE; 1820*99653d4eSeschrock boolean_t verbose = B_FALSE; 1821fa9e4066Sahrens 1822fa9e4066Sahrens /* check options */ 1823fa9e4066Sahrens while ((c = getopt(argc, argv, ":dnv")) != -1) { 1824fa9e4066Sahrens switch (c) { 1825fa9e4066Sahrens case 'd': 1826*99653d4eSeschrock isprefix = B_TRUE; 1827fa9e4066Sahrens break; 1828fa9e4066Sahrens case 'n': 1829*99653d4eSeschrock dryrun = B_TRUE; 1830fa9e4066Sahrens break; 1831fa9e4066Sahrens case 'v': 1832*99653d4eSeschrock verbose = B_TRUE; 1833fa9e4066Sahrens break; 1834fa9e4066Sahrens case ':': 1835fa9e4066Sahrens (void) fprintf(stderr, gettext("missing argument for " 1836fa9e4066Sahrens "'%c' option\n"), optopt); 1837*99653d4eSeschrock usage(B_FALSE); 1838fa9e4066Sahrens break; 1839fa9e4066Sahrens case '?': 1840fa9e4066Sahrens (void) fprintf(stderr, gettext("invalid option '%c'\n"), 1841fa9e4066Sahrens optopt); 1842*99653d4eSeschrock usage(B_FALSE); 1843fa9e4066Sahrens } 1844fa9e4066Sahrens } 1845fa9e4066Sahrens 1846fa9e4066Sahrens argc -= optind; 1847fa9e4066Sahrens argv += optind; 1848fa9e4066Sahrens 1849fa9e4066Sahrens /* check number of arguments */ 1850fa9e4066Sahrens if (argc < 1) { 1851fa9e4066Sahrens (void) fprintf(stderr, gettext("missing snapshot argument\n")); 1852*99653d4eSeschrock usage(B_FALSE); 1853fa9e4066Sahrens } 1854fa9e4066Sahrens if (argc > 1) { 1855fa9e4066Sahrens (void) fprintf(stderr, gettext("too many arguments\n")); 1856*99653d4eSeschrock usage(B_FALSE); 1857fa9e4066Sahrens } 1858fa9e4066Sahrens 1859fa9e4066Sahrens if (isatty(STDIN_FILENO)) { 1860fa9e4066Sahrens (void) fprintf(stderr, 1861fa9e4066Sahrens gettext("Error: Backup stream can not be read " 1862fa9e4066Sahrens "from a terminal.\n" 1863fa9e4066Sahrens "You must redirect standard input.\n")); 1864fa9e4066Sahrens return (1); 1865fa9e4066Sahrens } 1866fa9e4066Sahrens 1867*99653d4eSeschrock err = zfs_receive(g_zfs, argv[0], isprefix, verbose, dryrun); 1868fa9e4066Sahrens return (err != 0); 1869fa9e4066Sahrens } 1870fa9e4066Sahrens 18717f7322feSeschrock typedef struct get_all_cbdata { 18727f7322feSeschrock zfs_handle_t **cb_handles; 18737f7322feSeschrock size_t cb_alloc; 18747f7322feSeschrock size_t cb_used; 18757f7322feSeschrock } get_all_cbdata_t; 18767f7322feSeschrock 18777f7322feSeschrock static int 18787f7322feSeschrock get_one_filesystem(zfs_handle_t *zhp, void *data) 18797f7322feSeschrock { 18807f7322feSeschrock get_all_cbdata_t *cbp = data; 18817f7322feSeschrock 18827f7322feSeschrock /* 18837f7322feSeschrock * Skip any zvols 18847f7322feSeschrock */ 18857f7322feSeschrock if (zfs_get_type(zhp) != ZFS_TYPE_FILESYSTEM) { 18867f7322feSeschrock zfs_close(zhp); 18877f7322feSeschrock return (0); 18887f7322feSeschrock } 18897f7322feSeschrock 18907f7322feSeschrock if (cbp->cb_alloc == cbp->cb_used) { 18917f7322feSeschrock zfs_handle_t **handles; 18927f7322feSeschrock 18937f7322feSeschrock if (cbp->cb_alloc == 0) 18947f7322feSeschrock cbp->cb_alloc = 64; 18957f7322feSeschrock else 18967f7322feSeschrock cbp->cb_alloc *= 2; 18977f7322feSeschrock 18987f7322feSeschrock handles = safe_malloc(cbp->cb_alloc * sizeof (void *)); 18997f7322feSeschrock 19007f7322feSeschrock if (cbp->cb_handles) { 19017f7322feSeschrock bcopy(cbp->cb_handles, handles, 19027f7322feSeschrock cbp->cb_used * sizeof (void *)); 19037f7322feSeschrock free(cbp->cb_handles); 19047f7322feSeschrock } 19057f7322feSeschrock 19067f7322feSeschrock cbp->cb_handles = handles; 19077f7322feSeschrock } 19087f7322feSeschrock 19097f7322feSeschrock cbp->cb_handles[cbp->cb_used++] = zhp; 19107f7322feSeschrock 19117f7322feSeschrock return (zfs_iter_filesystems(zhp, get_one_filesystem, data)); 19127f7322feSeschrock } 19137f7322feSeschrock 19147f7322feSeschrock static void 19157f7322feSeschrock get_all_filesystems(zfs_handle_t ***fslist, size_t *count) 19167f7322feSeschrock { 19177f7322feSeschrock get_all_cbdata_t cb = { 0 }; 19187f7322feSeschrock 1919*99653d4eSeschrock (void) zfs_iter_root(g_zfs, get_one_filesystem, &cb); 19207f7322feSeschrock 19217f7322feSeschrock *fslist = cb.cb_handles; 19227f7322feSeschrock *count = cb.cb_used; 19237f7322feSeschrock } 19247f7322feSeschrock 19257f7322feSeschrock static int 19267f7322feSeschrock mountpoint_compare(const void *a, const void *b) 19277f7322feSeschrock { 19287f7322feSeschrock zfs_handle_t **za = (zfs_handle_t **)a; 19297f7322feSeschrock zfs_handle_t **zb = (zfs_handle_t **)b; 19307f7322feSeschrock char mounta[MAXPATHLEN]; 19317f7322feSeschrock char mountb[MAXPATHLEN]; 19327f7322feSeschrock 19337f7322feSeschrock verify(zfs_prop_get(*za, ZFS_PROP_MOUNTPOINT, mounta, 1934*99653d4eSeschrock sizeof (mounta), NULL, NULL, 0, B_FALSE) == 0); 19357f7322feSeschrock verify(zfs_prop_get(*zb, ZFS_PROP_MOUNTPOINT, mountb, 1936*99653d4eSeschrock sizeof (mountb), NULL, NULL, 0, B_FALSE) == 0); 19377f7322feSeschrock 19387f7322feSeschrock return (strcmp(mounta, mountb)); 19397f7322feSeschrock } 1940fa9e4066Sahrens 1941fa9e4066Sahrens /* 1942fa9e4066Sahrens * Generic callback for sharing or mounting filesystems. Because the code is so 1943fa9e4066Sahrens * similar, we have a common function with an extra parameter to determine which 1944fa9e4066Sahrens * mode we are using. 1945fa9e4066Sahrens */ 1946fa9e4066Sahrens #define OP_SHARE 0x1 1947fa9e4066Sahrens #define OP_MOUNT 0x2 1948fa9e4066Sahrens 1949fa9e4066Sahrens typedef struct share_mount_cbdata { 1950fa9e4066Sahrens int cb_type; 1951fa9e4066Sahrens int cb_explicit; 1952fa9e4066Sahrens int cb_flags; 1953fa9e4066Sahrens const char *cb_options; 1954fa9e4066Sahrens } share_mount_cbdata_t; 1955fa9e4066Sahrens 1956fa9e4066Sahrens /* 1957fa9e4066Sahrens * Share or mount the filesystem. 1958fa9e4066Sahrens */ 1959fa9e4066Sahrens static int 1960fa9e4066Sahrens share_mount_callback(zfs_handle_t *zhp, void *data) 1961fa9e4066Sahrens { 1962fa9e4066Sahrens char mountpoint[ZFS_MAXPROPLEN]; 1963fa9e4066Sahrens char shareopts[ZFS_MAXPROPLEN]; 1964fa9e4066Sahrens share_mount_cbdata_t *cbp = data; 1965fa9e4066Sahrens const char *cmdname = cbp->cb_type == OP_SHARE ? "share" : "mount"; 1966fa9e4066Sahrens struct mnttab mnt; 1967fa9e4066Sahrens uint64_t zoned; 1968fa9e4066Sahrens 1969fa9e4066Sahrens if (cbp->cb_options == NULL) 1970fa9e4066Sahrens mnt.mnt_mntopts = ""; 1971fa9e4066Sahrens else 1972fa9e4066Sahrens mnt.mnt_mntopts = (char *)cbp->cb_options; 1973fa9e4066Sahrens 1974fa9e4066Sahrens /* 1975fa9e4066Sahrens * Check to make sure we can mount/share this dataset. If we are in the 1976fa9e4066Sahrens * global zone and the filesystem is exported to a local zone, or if we 1977fa9e4066Sahrens * are in a local zone and the filesystem is not exported, then it is an 1978fa9e4066Sahrens * error. 1979fa9e4066Sahrens */ 1980fa9e4066Sahrens zoned = zfs_prop_get_int(zhp, ZFS_PROP_ZONED); 1981fa9e4066Sahrens 1982fa9e4066Sahrens if (zoned && getzoneid() == GLOBAL_ZONEID) { 1983fa9e4066Sahrens if (!cbp->cb_explicit) 1984fa9e4066Sahrens return (0); 1985fa9e4066Sahrens 1986fa9e4066Sahrens (void) fprintf(stderr, gettext("cannot %s '%s': dataset is " 1987fa9e4066Sahrens "exported to a local zone\n"), cmdname, zfs_get_name(zhp)); 1988fa9e4066Sahrens return (1); 1989fa9e4066Sahrens 1990fa9e4066Sahrens } else if (!zoned && getzoneid() != GLOBAL_ZONEID) { 1991fa9e4066Sahrens if (!cbp->cb_explicit) 1992fa9e4066Sahrens return (0); 1993fa9e4066Sahrens 1994fa9e4066Sahrens (void) fprintf(stderr, gettext("cannot %s '%s': permission " 1995fa9e4066Sahrens "denied\n"), cmdname, zfs_get_name(zhp)); 1996fa9e4066Sahrens return (1); 1997fa9e4066Sahrens } 1998fa9e4066Sahrens 1999fa9e4066Sahrens /* 2000fa9e4066Sahrens * Inore any filesystems which don't apply to us. This includes those 2001fa9e4066Sahrens * with a legacy mountpoint, or those with legacy share options. 2002fa9e4066Sahrens */ 2003fa9e4066Sahrens verify(zfs_prop_get(zhp, ZFS_PROP_MOUNTPOINT, mountpoint, 2004*99653d4eSeschrock sizeof (mountpoint), NULL, NULL, 0, B_FALSE) == 0); 2005fa9e4066Sahrens verify(zfs_prop_get(zhp, ZFS_PROP_SHARENFS, shareopts, 2006*99653d4eSeschrock sizeof (shareopts), NULL, NULL, 0, B_FALSE) == 0); 2007fa9e4066Sahrens 2008fa9e4066Sahrens if (cbp->cb_type == OP_SHARE) { 2009fa9e4066Sahrens if (strcmp(shareopts, "off") == 0) { 2010fa9e4066Sahrens if (!cbp->cb_explicit) 2011fa9e4066Sahrens return (0); 2012fa9e4066Sahrens 2013fa9e4066Sahrens (void) fprintf(stderr, gettext("cannot share '%s': " 2014fa9e4066Sahrens "legacy share\n"), zfs_get_name(zhp)); 2015fa9e4066Sahrens (void) fprintf(stderr, gettext("use share(1M) to " 2016fa9e4066Sahrens "share this filesystem\n")); 2017fa9e4066Sahrens return (1); 2018fa9e4066Sahrens } 2019fa9e4066Sahrens } 2020fa9e4066Sahrens 2021fa9e4066Sahrens /* 2022fa9e4066Sahrens * We cannot share or mount legacy filesystems. If the shareopts is 2023fa9e4066Sahrens * non-legacy but the mountpoint is legacy, we treat it as a legacy 2024fa9e4066Sahrens * share. 2025fa9e4066Sahrens */ 2026fa9e4066Sahrens if (strcmp(mountpoint, "legacy") == 0) { 2027fa9e4066Sahrens if (!cbp->cb_explicit) 2028fa9e4066Sahrens return (0); 2029fa9e4066Sahrens 2030fa9e4066Sahrens (void) fprintf(stderr, gettext("cannot %s '%s': " 2031fa9e4066Sahrens "legacy mountpoint\n"), cmdname, zfs_get_name(zhp)); 2032fa9e4066Sahrens (void) fprintf(stderr, gettext("use %s to " 2033fa9e4066Sahrens "%s this filesystem\n"), cbp->cb_type == OP_SHARE ? 2034fa9e4066Sahrens "share(1M)" : "mount(1M)", cmdname); 2035fa9e4066Sahrens return (1); 2036fa9e4066Sahrens } 2037fa9e4066Sahrens 2038fa9e4066Sahrens if (strcmp(mountpoint, "none") == 0) { 2039fa9e4066Sahrens if (!cbp->cb_explicit) 2040fa9e4066Sahrens return (0); 2041fa9e4066Sahrens 2042fa9e4066Sahrens (void) fprintf(stderr, gettext("cannot %s '%s': no " 2043fa9e4066Sahrens "mountpoint set\n"), cmdname, zfs_get_name(zhp)); 2044fa9e4066Sahrens return (1); 2045fa9e4066Sahrens } 2046fa9e4066Sahrens 2047fa9e4066Sahrens /* 2048fa9e4066Sahrens * At this point, we have verified that the mountpoint and/or shareopts 2049fa9e4066Sahrens * are appropriate for auto management. Determine if the filesystem is 2050fa9e4066Sahrens * currently mounted or shared, and abort if this is an explicit 2051fa9e4066Sahrens * request. 2052fa9e4066Sahrens */ 2053fa9e4066Sahrens switch (cbp->cb_type) { 2054fa9e4066Sahrens case OP_SHARE: 2055fa9e4066Sahrens if (zfs_is_shared(zhp, NULL)) { 2056fa9e4066Sahrens if (cbp->cb_explicit) { 2057fa9e4066Sahrens (void) fprintf(stderr, gettext("cannot share " 2058fa9e4066Sahrens "'%s': filesystem already shared\n"), 2059fa9e4066Sahrens zfs_get_name(zhp)); 2060fa9e4066Sahrens return (1); 2061fa9e4066Sahrens } else { 2062fa9e4066Sahrens return (0); 2063fa9e4066Sahrens } 2064fa9e4066Sahrens } 2065fa9e4066Sahrens break; 2066fa9e4066Sahrens 2067fa9e4066Sahrens case OP_MOUNT: 2068fa9e4066Sahrens if (!hasmntopt(&mnt, MNTOPT_REMOUNT) && 2069fa9e4066Sahrens zfs_is_mounted(zhp, NULL)) { 2070fa9e4066Sahrens if (cbp->cb_explicit) { 2071fa9e4066Sahrens (void) fprintf(stderr, gettext("cannot mount " 2072fa9e4066Sahrens "'%s': filesystem already mounted\n"), 2073fa9e4066Sahrens zfs_get_name(zhp)); 2074fa9e4066Sahrens return (1); 2075fa9e4066Sahrens } else { 2076fa9e4066Sahrens return (0); 2077fa9e4066Sahrens } 2078fa9e4066Sahrens } 2079fa9e4066Sahrens break; 2080fa9e4066Sahrens } 2081fa9e4066Sahrens 2082fa9e4066Sahrens /* 2083fa9e4066Sahrens * Mount and optionally share the filesystem. 2084fa9e4066Sahrens */ 2085fa9e4066Sahrens switch (cbp->cb_type) { 2086fa9e4066Sahrens case OP_SHARE: 2087fa9e4066Sahrens { 2088fa9e4066Sahrens if (!zfs_is_mounted(zhp, NULL) && 2089fa9e4066Sahrens zfs_mount(zhp, NULL, 0) != 0) 2090fa9e4066Sahrens return (1); 2091fa9e4066Sahrens 2092fa9e4066Sahrens if (zfs_share(zhp) != 0) 2093fa9e4066Sahrens return (1); 2094fa9e4066Sahrens } 2095fa9e4066Sahrens break; 2096fa9e4066Sahrens 2097fa9e4066Sahrens case OP_MOUNT: 2098fa9e4066Sahrens if (zfs_mount(zhp, cbp->cb_options, cbp->cb_flags) != 0) 2099fa9e4066Sahrens return (1); 2100fa9e4066Sahrens break; 2101fa9e4066Sahrens } 2102fa9e4066Sahrens 2103fa9e4066Sahrens return (0); 2104fa9e4066Sahrens } 2105fa9e4066Sahrens 2106fa9e4066Sahrens static int 2107fa9e4066Sahrens share_or_mount(int type, int argc, char **argv) 2108fa9e4066Sahrens { 2109fa9e4066Sahrens int do_all = 0; 2110fa9e4066Sahrens int c, ret; 2111fa9e4066Sahrens share_mount_cbdata_t cb = { 0 }; 2112fa9e4066Sahrens 2113fa9e4066Sahrens cb.cb_type = type; 2114fa9e4066Sahrens 2115fa9e4066Sahrens /* check options */ 2116fa9e4066Sahrens while ((c = getopt(argc, argv, type == OP_MOUNT ? ":ao:O" : "a")) 2117fa9e4066Sahrens != -1) { 2118fa9e4066Sahrens switch (c) { 2119fa9e4066Sahrens case 'a': 2120fa9e4066Sahrens do_all = 1; 2121fa9e4066Sahrens break; 2122fa9e4066Sahrens case 'o': 2123fa9e4066Sahrens cb.cb_options = optarg; 2124fa9e4066Sahrens break; 2125fa9e4066Sahrens case 'O': 2126fa9e4066Sahrens cb.cb_flags |= MS_OVERLAY; 2127fa9e4066Sahrens break; 2128fa9e4066Sahrens case ':': 2129fa9e4066Sahrens (void) fprintf(stderr, gettext("missing argument for " 2130fa9e4066Sahrens "'%c' option\n"), optopt); 2131*99653d4eSeschrock usage(B_FALSE); 2132fa9e4066Sahrens break; 2133fa9e4066Sahrens case '?': 2134fa9e4066Sahrens (void) fprintf(stderr, gettext("invalid option '%c'\n"), 2135fa9e4066Sahrens optopt); 2136*99653d4eSeschrock usage(B_FALSE); 2137fa9e4066Sahrens } 2138fa9e4066Sahrens } 2139fa9e4066Sahrens 2140fa9e4066Sahrens argc -= optind; 2141fa9e4066Sahrens argv += optind; 2142fa9e4066Sahrens 2143fa9e4066Sahrens /* check number of arguments */ 2144fa9e4066Sahrens if (do_all) { 21457f7322feSeschrock zfs_handle_t **fslist = NULL; 21467f7322feSeschrock size_t i, count = 0; 21477f7322feSeschrock 2148fa9e4066Sahrens if (argc != 0) { 2149fa9e4066Sahrens (void) fprintf(stderr, gettext("too many arguments\n")); 2150*99653d4eSeschrock usage(B_FALSE); 2151fa9e4066Sahrens } 2152fa9e4066Sahrens 21537f7322feSeschrock get_all_filesystems(&fslist, &count); 21547f7322feSeschrock 21557f7322feSeschrock if (count == 0) 21567f7322feSeschrock return (0); 21577f7322feSeschrock 21587f7322feSeschrock qsort(fslist, count, sizeof (void *), mountpoint_compare); 21597f7322feSeschrock 21607f7322feSeschrock for (i = 0; i < count; i++) { 21617f7322feSeschrock if ((ret = share_mount_callback(fslist[i], &cb)) != 0) 21627f7322feSeschrock break; 21637f7322feSeschrock } 21647f7322feSeschrock 21657f7322feSeschrock for (i = 0; i < count; i++) 21667f7322feSeschrock zfs_close(fslist[i]); 21677f7322feSeschrock 21687f7322feSeschrock free(fslist); 2169fa9e4066Sahrens } else if (argc == 0) { 2170fa9e4066Sahrens struct mnttab entry; 2171fa9e4066Sahrens 2172fa9e4066Sahrens if (type == OP_SHARE) { 2173fa9e4066Sahrens (void) fprintf(stderr, gettext("missing filesystem " 2174fa9e4066Sahrens "argument\n")); 2175*99653d4eSeschrock usage(B_FALSE); 2176fa9e4066Sahrens } 2177fa9e4066Sahrens 2178fa9e4066Sahrens /* 2179fa9e4066Sahrens * When mount is given no arguments, go through /etc/mnttab and 2180fa9e4066Sahrens * display any active ZFS mounts. We hide any snapshots, since 2181fa9e4066Sahrens * they are controlled automatically. 2182fa9e4066Sahrens */ 2183fa9e4066Sahrens rewind(mnttab_file); 2184fa9e4066Sahrens while (getmntent(mnttab_file, &entry) == 0) { 2185fa9e4066Sahrens if (strcmp(entry.mnt_fstype, MNTTYPE_ZFS) != 0 || 2186fa9e4066Sahrens strchr(entry.mnt_special, '@') != NULL) 2187fa9e4066Sahrens continue; 2188fa9e4066Sahrens 2189fa9e4066Sahrens (void) printf("%-30s %s\n", entry.mnt_special, 2190fa9e4066Sahrens entry.mnt_mountp); 2191fa9e4066Sahrens } 2192fa9e4066Sahrens 2193fa9e4066Sahrens ret = 0; 2194fa9e4066Sahrens } else { 2195fa9e4066Sahrens zfs_handle_t *zhp; 2196fa9e4066Sahrens 2197fa9e4066Sahrens if (argc > 1) { 2198fa9e4066Sahrens (void) fprintf(stderr, 2199fa9e4066Sahrens gettext("too many arguments\n")); 2200*99653d4eSeschrock usage(B_FALSE); 2201fa9e4066Sahrens } 2202fa9e4066Sahrens 2203*99653d4eSeschrock if ((zhp = zfs_open(g_zfs, argv[0], 2204*99653d4eSeschrock ZFS_TYPE_FILESYSTEM)) == NULL) 2205fa9e4066Sahrens ret = 1; 2206fa9e4066Sahrens else { 2207*99653d4eSeschrock cb.cb_explicit = B_TRUE; 2208fa9e4066Sahrens ret = share_mount_callback(zhp, &cb); 2209fa9e4066Sahrens zfs_close(zhp); 2210fa9e4066Sahrens } 2211fa9e4066Sahrens } 2212fa9e4066Sahrens 2213fa9e4066Sahrens return (ret); 2214fa9e4066Sahrens } 2215fa9e4066Sahrens 2216fa9e4066Sahrens /* 2217fa9e4066Sahrens * zfs mount -a 2218fa9e4066Sahrens * zfs mount filesystem 2219fa9e4066Sahrens * 2220fa9e4066Sahrens * Mount all filesystems, or mount the given filesystem. 2221fa9e4066Sahrens */ 2222fa9e4066Sahrens static int 2223fa9e4066Sahrens zfs_do_mount(int argc, char **argv) 2224fa9e4066Sahrens { 2225fa9e4066Sahrens return (share_or_mount(OP_MOUNT, argc, argv)); 2226fa9e4066Sahrens } 2227fa9e4066Sahrens 2228fa9e4066Sahrens /* 2229fa9e4066Sahrens * zfs share -a 2230fa9e4066Sahrens * zfs share filesystem 2231fa9e4066Sahrens * 2232fa9e4066Sahrens * Share all filesystems, or share the given filesystem. 2233fa9e4066Sahrens */ 2234fa9e4066Sahrens static int 2235fa9e4066Sahrens zfs_do_share(int argc, char **argv) 2236fa9e4066Sahrens { 2237fa9e4066Sahrens return (share_or_mount(OP_SHARE, argc, argv)); 2238fa9e4066Sahrens } 2239fa9e4066Sahrens 2240fa9e4066Sahrens typedef struct unshare_unmount_node { 2241fa9e4066Sahrens zfs_handle_t *un_zhp; 2242fa9e4066Sahrens char *un_mountp; 2243fa9e4066Sahrens uu_avl_node_t un_avlnode; 2244fa9e4066Sahrens } unshare_unmount_node_t; 2245fa9e4066Sahrens 2246fa9e4066Sahrens /* ARGSUSED */ 2247fa9e4066Sahrens static int 2248fa9e4066Sahrens unshare_unmount_compare(const void *larg, const void *rarg, void *unused) 2249fa9e4066Sahrens { 2250fa9e4066Sahrens const unshare_unmount_node_t *l = larg; 2251fa9e4066Sahrens const unshare_unmount_node_t *r = rarg; 2252fa9e4066Sahrens 2253fa9e4066Sahrens return (strcmp(l->un_mountp, r->un_mountp)); 2254fa9e4066Sahrens } 2255fa9e4066Sahrens 2256fa9e4066Sahrens /* 2257fa9e4066Sahrens * Convenience routine used by zfs_do_umount() and manual_unmount(). Given an 2258fa9e4066Sahrens * absolute path, find the entry /etc/mnttab, verify that its a ZFS filesystem, 2259fa9e4066Sahrens * and unmount it appropriately. 2260fa9e4066Sahrens */ 2261fa9e4066Sahrens static int 2262*99653d4eSeschrock unshare_unmount_path(int type, char *path, int flags, boolean_t is_manual) 2263fa9e4066Sahrens { 2264fa9e4066Sahrens zfs_handle_t *zhp; 2265fa9e4066Sahrens int ret; 2266fa9e4066Sahrens struct stat64 statbuf; 2267fa9e4066Sahrens struct extmnttab entry; 2268fa9e4066Sahrens const char *cmdname = (type == OP_SHARE) ? "unshare" : "unmount"; 2269fa9e4066Sahrens char property[ZFS_MAXPROPLEN]; 2270fa9e4066Sahrens 2271fa9e4066Sahrens /* 2272fa9e4066Sahrens * Search for the path in /etc/mnttab. Rather than looking for the 2273fa9e4066Sahrens * specific path, which can be fooled by non-standard paths (i.e. ".." 2274fa9e4066Sahrens * or "//"), we stat() the path and search for the corresponding 2275fa9e4066Sahrens * (major,minor) device pair. 2276fa9e4066Sahrens */ 2277fa9e4066Sahrens if (stat64(path, &statbuf) != 0) { 2278fa9e4066Sahrens (void) fprintf(stderr, gettext("cannot %s '%s': %s\n"), 2279fa9e4066Sahrens cmdname, path, strerror(errno)); 2280fa9e4066Sahrens return (1); 2281fa9e4066Sahrens } 2282fa9e4066Sahrens 2283fa9e4066Sahrens /* 2284fa9e4066Sahrens * Search for the given (major,minor) pair in the mount table. 2285fa9e4066Sahrens */ 2286fa9e4066Sahrens rewind(mnttab_file); 2287fa9e4066Sahrens while ((ret = getextmntent(mnttab_file, &entry, 0)) == 0) { 2288fa9e4066Sahrens if (entry.mnt_major == major(statbuf.st_dev) && 2289fa9e4066Sahrens entry.mnt_minor == minor(statbuf.st_dev)) 2290fa9e4066Sahrens break; 2291fa9e4066Sahrens } 2292fa9e4066Sahrens if (ret != 0) { 2293fa9e4066Sahrens (void) fprintf(stderr, gettext("cannot %s '%s': not " 2294fa9e4066Sahrens "currently mounted\n"), cmdname, path); 2295fa9e4066Sahrens return (1); 2296fa9e4066Sahrens } 2297fa9e4066Sahrens 2298fa9e4066Sahrens if (strcmp(entry.mnt_fstype, MNTTYPE_ZFS) != 0) { 2299fa9e4066Sahrens (void) fprintf(stderr, gettext("cannot %s '%s': not a ZFS " 2300fa9e4066Sahrens "filesystem\n"), cmdname, path); 2301fa9e4066Sahrens return (1); 2302fa9e4066Sahrens } 2303fa9e4066Sahrens 2304*99653d4eSeschrock if ((zhp = zfs_open(g_zfs, entry.mnt_special, 2305*99653d4eSeschrock ZFS_TYPE_FILESYSTEM)) == NULL) 2306fa9e4066Sahrens return (1); 2307fa9e4066Sahrens 2308fa9e4066Sahrens verify(zfs_prop_get(zhp, type == OP_SHARE ? 2309fa9e4066Sahrens ZFS_PROP_SHARENFS : ZFS_PROP_MOUNTPOINT, property, 2310*99653d4eSeschrock sizeof (property), NULL, NULL, 0, B_FALSE) == 0); 2311fa9e4066Sahrens 2312fa9e4066Sahrens if (type == OP_SHARE) { 2313fa9e4066Sahrens if (strcmp(property, "off") == 0) { 2314fa9e4066Sahrens (void) fprintf(stderr, gettext("cannot unshare " 2315fa9e4066Sahrens "'%s': legacy share\n"), path); 2316fa9e4066Sahrens (void) fprintf(stderr, gettext("use " 2317fa9e4066Sahrens "unshare(1M) to unshare this filesystem\n")); 2318fa9e4066Sahrens ret = 1; 2319fa9e4066Sahrens } else if (!zfs_is_shared(zhp, NULL)) { 2320fa9e4066Sahrens (void) fprintf(stderr, gettext("cannot unshare '%s': " 2321fa9e4066Sahrens "not currently shared\n"), path); 2322fa9e4066Sahrens ret = 1; 2323fa9e4066Sahrens } else { 2324fa9e4066Sahrens ret = zfs_unshareall(zhp); 2325fa9e4066Sahrens } 2326fa9e4066Sahrens } else { 23276b90ca48Slling if (is_manual) { 23286b90ca48Slling ret = zfs_unmount(zhp, NULL, flags); 2329c0ea9bc7Slling } else if (strcmp(property, "legacy") == 0) { 2330fa9e4066Sahrens (void) fprintf(stderr, gettext("cannot unmount " 2331fa9e4066Sahrens "'%s': legacy mountpoint\n"), 2332fa9e4066Sahrens zfs_get_name(zhp)); 2333fa9e4066Sahrens (void) fprintf(stderr, gettext("use umount(1M) " 2334fa9e4066Sahrens "to unmount this filesystem\n")); 2335fa9e4066Sahrens ret = 1; 2336fa9e4066Sahrens } else { 2337fa9e4066Sahrens ret = zfs_unmountall(zhp, flags); 2338fa9e4066Sahrens } 2339fa9e4066Sahrens } 2340fa9e4066Sahrens 2341fa9e4066Sahrens zfs_close(zhp); 2342fa9e4066Sahrens 2343fa9e4066Sahrens return (ret != 0); 2344fa9e4066Sahrens } 2345fa9e4066Sahrens 2346fa9e4066Sahrens /* 2347fa9e4066Sahrens * Generic callback for unsharing or unmounting a filesystem. 2348fa9e4066Sahrens */ 2349fa9e4066Sahrens static int 2350fa9e4066Sahrens unshare_unmount(int type, int argc, char **argv) 2351fa9e4066Sahrens { 2352fa9e4066Sahrens int do_all = 0; 2353fa9e4066Sahrens int flags = 0; 2354fa9e4066Sahrens int ret = 0; 2355fa9e4066Sahrens int c; 2356fa9e4066Sahrens zfs_handle_t *zhp; 2357fa9e4066Sahrens char property[ZFS_MAXPROPLEN]; 2358fa9e4066Sahrens 2359fa9e4066Sahrens /* check options */ 2360fa9e4066Sahrens while ((c = getopt(argc, argv, type == OP_SHARE ? "a" : "af")) != -1) { 2361fa9e4066Sahrens switch (c) { 2362fa9e4066Sahrens case 'a': 2363fa9e4066Sahrens do_all = 1; 2364fa9e4066Sahrens break; 2365fa9e4066Sahrens case 'f': 2366fa9e4066Sahrens flags = MS_FORCE; 2367fa9e4066Sahrens break; 2368fa9e4066Sahrens case '?': 2369fa9e4066Sahrens (void) fprintf(stderr, gettext("invalid option '%c'\n"), 2370fa9e4066Sahrens optopt); 2371*99653d4eSeschrock usage(B_FALSE); 2372fa9e4066Sahrens } 2373fa9e4066Sahrens } 2374fa9e4066Sahrens 2375fa9e4066Sahrens argc -= optind; 2376fa9e4066Sahrens argv += optind; 2377fa9e4066Sahrens 2378fa9e4066Sahrens /* ensure correct number of arguments */ 2379fa9e4066Sahrens if (do_all) { 2380fa9e4066Sahrens if (argc != 0) { 2381fa9e4066Sahrens (void) fprintf(stderr, gettext("too many arguments\n")); 2382*99653d4eSeschrock usage(B_FALSE); 2383fa9e4066Sahrens } 2384fa9e4066Sahrens } else if (argc != 1) { 2385fa9e4066Sahrens if (argc == 0) 2386fa9e4066Sahrens (void) fprintf(stderr, 2387fa9e4066Sahrens gettext("missing filesystem argument\n")); 2388fa9e4066Sahrens else 2389fa9e4066Sahrens (void) fprintf(stderr, 2390fa9e4066Sahrens gettext("too many arguments\n")); 2391*99653d4eSeschrock usage(B_FALSE); 2392fa9e4066Sahrens } 2393fa9e4066Sahrens 2394fa9e4066Sahrens if (do_all) { 2395fa9e4066Sahrens /* 2396fa9e4066Sahrens * We could make use of zfs_for_each() to walk all datasets in 2397fa9e4066Sahrens * the system, but this would be very inefficient, especially 2398fa9e4066Sahrens * since we would have to linearly search /etc/mnttab for each 2399fa9e4066Sahrens * one. Instead, do one pass through /etc/mnttab looking for 2400fa9e4066Sahrens * zfs entries and call zfs_unmount() for each one. 2401fa9e4066Sahrens * 2402fa9e4066Sahrens * Things get a little tricky if the administrator has created 2403fa9e4066Sahrens * mountpoints beneath other ZFS filesystems. In this case, we 2404fa9e4066Sahrens * have to unmount the deepest filesystems first. To accomplish 2405fa9e4066Sahrens * this, we place all the mountpoints in an AVL tree sorted by 2406fa9e4066Sahrens * the special type (dataset name), and walk the result in 2407fa9e4066Sahrens * reverse to make sure to get any snapshots first. 2408fa9e4066Sahrens */ 2409fa9e4066Sahrens struct mnttab entry; 2410fa9e4066Sahrens uu_avl_pool_t *pool; 2411fa9e4066Sahrens uu_avl_t *tree; 2412fa9e4066Sahrens unshare_unmount_node_t *node; 2413fa9e4066Sahrens uu_avl_index_t idx; 2414fa9e4066Sahrens uu_avl_walk_t *walk; 2415fa9e4066Sahrens 2416fa9e4066Sahrens if ((pool = uu_avl_pool_create("unmount_pool", 2417fa9e4066Sahrens sizeof (unshare_unmount_node_t), 2418fa9e4066Sahrens offsetof(unshare_unmount_node_t, un_avlnode), 2419fa9e4066Sahrens unshare_unmount_compare, 2420fa9e4066Sahrens UU_DEFAULT)) == NULL) { 2421fa9e4066Sahrens (void) fprintf(stderr, gettext("internal error: " 2422fa9e4066Sahrens "out of memory\n")); 2423fa9e4066Sahrens exit(1); 2424fa9e4066Sahrens } 2425fa9e4066Sahrens 2426fa9e4066Sahrens if ((tree = uu_avl_create(pool, NULL, UU_DEFAULT)) == NULL) { 2427fa9e4066Sahrens (void) fprintf(stderr, gettext("internal error: " 2428fa9e4066Sahrens "out of memory\n")); 2429fa9e4066Sahrens exit(1); 2430fa9e4066Sahrens } 2431fa9e4066Sahrens 2432fa9e4066Sahrens rewind(mnttab_file); 2433fa9e4066Sahrens while (getmntent(mnttab_file, &entry) == 0) { 2434fa9e4066Sahrens 2435fa9e4066Sahrens /* ignore non-ZFS entries */ 2436fa9e4066Sahrens if (strcmp(entry.mnt_fstype, MNTTYPE_ZFS) != 0) 2437fa9e4066Sahrens continue; 2438fa9e4066Sahrens 2439fa9e4066Sahrens /* ignore snapshots */ 2440fa9e4066Sahrens if (strchr(entry.mnt_special, '@') != NULL) 2441fa9e4066Sahrens continue; 2442fa9e4066Sahrens 2443*99653d4eSeschrock if ((zhp = zfs_open(g_zfs, entry.mnt_special, 2444fa9e4066Sahrens ZFS_TYPE_FILESYSTEM)) == NULL) { 2445fa9e4066Sahrens ret = 1; 2446fa9e4066Sahrens continue; 2447fa9e4066Sahrens } 2448fa9e4066Sahrens 2449fa9e4066Sahrens verify(zfs_prop_get(zhp, type == OP_SHARE ? 2450fa9e4066Sahrens ZFS_PROP_SHARENFS : ZFS_PROP_MOUNTPOINT, 2451fa9e4066Sahrens property, sizeof (property), NULL, NULL, 2452*99653d4eSeschrock 0, B_FALSE) == 0); 2453fa9e4066Sahrens 2454fa9e4066Sahrens /* Ignore legacy mounts and shares */ 2455fa9e4066Sahrens if ((type == OP_SHARE && 2456fa9e4066Sahrens strcmp(property, "off") == 0) || 2457fa9e4066Sahrens (type == OP_MOUNT && 2458fa9e4066Sahrens strcmp(property, "legacy") == 0)) { 2459fa9e4066Sahrens zfs_close(zhp); 2460fa9e4066Sahrens continue; 2461fa9e4066Sahrens } 2462fa9e4066Sahrens 2463fa9e4066Sahrens node = safe_malloc(sizeof (unshare_unmount_node_t)); 2464fa9e4066Sahrens node->un_zhp = zhp; 2465fa9e4066Sahrens 2466fa9e4066Sahrens if ((node->un_mountp = strdup(entry.mnt_mountp)) == 2467fa9e4066Sahrens NULL) { 2468fa9e4066Sahrens (void) fprintf(stderr, gettext("internal error:" 2469fa9e4066Sahrens " out of memory\n")); 2470fa9e4066Sahrens exit(1); 2471fa9e4066Sahrens } 2472fa9e4066Sahrens 2473fa9e4066Sahrens uu_avl_node_init(node, &node->un_avlnode, pool); 2474fa9e4066Sahrens 2475fa9e4066Sahrens if (uu_avl_find(tree, node, NULL, &idx) == NULL) { 2476fa9e4066Sahrens uu_avl_insert(tree, node, idx); 2477fa9e4066Sahrens } else { 2478fa9e4066Sahrens zfs_close(node->un_zhp); 2479fa9e4066Sahrens free(node->un_mountp); 2480fa9e4066Sahrens free(node); 2481fa9e4066Sahrens } 2482fa9e4066Sahrens } 2483fa9e4066Sahrens 2484fa9e4066Sahrens /* 2485fa9e4066Sahrens * Walk the AVL tree in reverse, unmounting each filesystem and 2486fa9e4066Sahrens * removing it from the AVL tree in the process. 2487fa9e4066Sahrens */ 2488fa9e4066Sahrens if ((walk = uu_avl_walk_start(tree, 2489fa9e4066Sahrens UU_WALK_REVERSE | UU_WALK_ROBUST)) == NULL) { 2490fa9e4066Sahrens (void) fprintf(stderr, 2491fa9e4066Sahrens gettext("internal error: out of memory")); 2492fa9e4066Sahrens exit(1); 2493fa9e4066Sahrens } 2494fa9e4066Sahrens 2495fa9e4066Sahrens while ((node = uu_avl_walk_next(walk)) != NULL) { 2496fa9e4066Sahrens uu_avl_remove(tree, node); 2497fa9e4066Sahrens 2498fa9e4066Sahrens switch (type) { 2499fa9e4066Sahrens case OP_SHARE: 2500fa9e4066Sahrens if (zfs_unshare(node->un_zhp, 2501fa9e4066Sahrens node->un_mountp) != 0) 2502fa9e4066Sahrens ret = 1; 2503fa9e4066Sahrens break; 2504fa9e4066Sahrens 2505fa9e4066Sahrens case OP_MOUNT: 2506fa9e4066Sahrens if (zfs_unmount(node->un_zhp, 2507fa9e4066Sahrens node->un_mountp, flags) != 0) 2508fa9e4066Sahrens ret = 1; 2509fa9e4066Sahrens break; 2510fa9e4066Sahrens } 2511fa9e4066Sahrens 2512fa9e4066Sahrens zfs_close(node->un_zhp); 2513fa9e4066Sahrens free(node->un_mountp); 2514fa9e4066Sahrens free(node); 2515fa9e4066Sahrens } 2516fa9e4066Sahrens 2517fa9e4066Sahrens uu_avl_walk_end(walk); 2518fa9e4066Sahrens uu_avl_destroy(tree); 2519fa9e4066Sahrens uu_avl_pool_destroy(pool); 2520fa9e4066Sahrens } else { 2521fa9e4066Sahrens /* 2522fa9e4066Sahrens * We have an argument, but it may be a full path or a ZFS 2523fa9e4066Sahrens * filesystem. Pass full paths off to unmount_path() (shared by 2524fa9e4066Sahrens * manual_unmount), otherwise open the filesystem and pass to 2525fa9e4066Sahrens * zfs_unmount(). 2526fa9e4066Sahrens */ 2527fa9e4066Sahrens if (argv[0][0] == '/') 2528fa9e4066Sahrens return (unshare_unmount_path(type, argv[0], 2529*99653d4eSeschrock flags, B_FALSE)); 2530fa9e4066Sahrens 2531*99653d4eSeschrock if ((zhp = zfs_open(g_zfs, argv[0], 2532*99653d4eSeschrock ZFS_TYPE_FILESYSTEM)) == NULL) 2533fa9e4066Sahrens return (1); 2534fa9e4066Sahrens 2535fa9e4066Sahrens verify(zfs_prop_get(zhp, type == OP_SHARE ? 2536fa9e4066Sahrens ZFS_PROP_SHARENFS : ZFS_PROP_MOUNTPOINT, property, 2537*99653d4eSeschrock sizeof (property), NULL, NULL, 0, B_FALSE) == 0); 2538fa9e4066Sahrens 2539fa9e4066Sahrens switch (type) { 2540fa9e4066Sahrens case OP_SHARE: 2541fa9e4066Sahrens if (strcmp(property, "off") == 0) { 2542fa9e4066Sahrens (void) fprintf(stderr, gettext("cannot unshare " 2543fa9e4066Sahrens "'%s': legacy share\n"), zfs_get_name(zhp)); 2544fa9e4066Sahrens (void) fprintf(stderr, gettext("use unshare(1M)" 2545fa9e4066Sahrens " to unshare this filesystem\n")); 2546fa9e4066Sahrens ret = 1; 2547fa9e4066Sahrens } else if (!zfs_is_shared(zhp, NULL)) { 2548fa9e4066Sahrens (void) fprintf(stderr, gettext("cannot unshare " 2549fa9e4066Sahrens "'%s': not currently shared\n"), 2550fa9e4066Sahrens zfs_get_name(zhp)); 2551fa9e4066Sahrens ret = 1; 2552fa9e4066Sahrens } else if (zfs_unshareall(zhp) != 0) { 2553fa9e4066Sahrens ret = 1; 2554fa9e4066Sahrens } 2555fa9e4066Sahrens break; 2556fa9e4066Sahrens 2557fa9e4066Sahrens case OP_MOUNT: 2558fa9e4066Sahrens if (strcmp(property, "legacy") == 0) { 2559fa9e4066Sahrens (void) fprintf(stderr, gettext("cannot unmount " 2560fa9e4066Sahrens "'%s': legacy mountpoint\n"), 2561fa9e4066Sahrens zfs_get_name(zhp)); 2562fa9e4066Sahrens (void) fprintf(stderr, gettext("use umount(1M) " 2563fa9e4066Sahrens "to unmount this filesystem\n")); 2564fa9e4066Sahrens ret = 1; 2565fa9e4066Sahrens } else if (!zfs_is_mounted(zhp, NULL)) { 2566fa9e4066Sahrens (void) fprintf(stderr, gettext("cannot unmount " 2567fa9e4066Sahrens "'%s': not currently mounted\n"), 2568fa9e4066Sahrens zfs_get_name(zhp)); 2569fa9e4066Sahrens ret = 1; 2570fa9e4066Sahrens } else if (zfs_unmountall(zhp, flags) != 0) { 2571fa9e4066Sahrens ret = 1; 2572fa9e4066Sahrens } 2573fa9e4066Sahrens } 2574fa9e4066Sahrens 2575fa9e4066Sahrens zfs_close(zhp); 2576fa9e4066Sahrens } 2577fa9e4066Sahrens 2578fa9e4066Sahrens return (ret); 2579fa9e4066Sahrens } 2580fa9e4066Sahrens 2581fa9e4066Sahrens /* 2582fa9e4066Sahrens * zfs unmount -a 2583fa9e4066Sahrens * zfs unmount filesystem 2584fa9e4066Sahrens * 2585fa9e4066Sahrens * Unmount all filesystems, or a specific ZFS filesystem. 2586fa9e4066Sahrens */ 2587fa9e4066Sahrens static int 2588fa9e4066Sahrens zfs_do_unmount(int argc, char **argv) 2589fa9e4066Sahrens { 2590fa9e4066Sahrens return (unshare_unmount(OP_MOUNT, argc, argv)); 2591fa9e4066Sahrens } 2592fa9e4066Sahrens 2593fa9e4066Sahrens /* 2594fa9e4066Sahrens * zfs unshare -a 2595fa9e4066Sahrens * zfs unshare filesystem 2596fa9e4066Sahrens * 2597fa9e4066Sahrens * Unshare all filesystems, or a specific ZFS filesystem. 2598fa9e4066Sahrens */ 2599fa9e4066Sahrens static int 2600fa9e4066Sahrens zfs_do_unshare(int argc, char **argv) 2601fa9e4066Sahrens { 2602fa9e4066Sahrens return (unshare_unmount(OP_SHARE, argc, argv)); 2603fa9e4066Sahrens } 2604fa9e4066Sahrens 2605fa9e4066Sahrens /* 2606fa9e4066Sahrens * Called when invoked as /etc/fs/zfs/mount. Do the mount if the mountpoint is 2607fa9e4066Sahrens * 'legacy'. Otherwise, complain that use should be using 'zfs mount'. 2608fa9e4066Sahrens */ 2609fa9e4066Sahrens static int 2610fa9e4066Sahrens manual_mount(int argc, char **argv) 2611fa9e4066Sahrens { 2612fa9e4066Sahrens zfs_handle_t *zhp; 2613fa9e4066Sahrens char mountpoint[ZFS_MAXPROPLEN]; 2614fa9e4066Sahrens char mntopts[MNT_LINE_MAX] = { '\0' }; 2615fa9e4066Sahrens int ret; 2616fa9e4066Sahrens int c; 2617fa9e4066Sahrens int flags = 0; 2618fa9e4066Sahrens char *dataset, *path; 2619fa9e4066Sahrens 2620fa9e4066Sahrens /* check options */ 2621ea8dc4b6Seschrock while ((c = getopt(argc, argv, ":mo:O")) != -1) { 2622fa9e4066Sahrens switch (c) { 2623fa9e4066Sahrens case 'o': 2624fa9e4066Sahrens (void) strlcpy(mntopts, optarg, sizeof (mntopts)); 2625fa9e4066Sahrens break; 2626fa9e4066Sahrens case 'O': 2627fa9e4066Sahrens flags |= MS_OVERLAY; 2628fa9e4066Sahrens break; 2629ea8dc4b6Seschrock case 'm': 2630ea8dc4b6Seschrock flags |= MS_NOMNTTAB; 2631ea8dc4b6Seschrock break; 2632fa9e4066Sahrens case ':': 2633fa9e4066Sahrens (void) fprintf(stderr, gettext("missing argument for " 2634fa9e4066Sahrens "'%c' option\n"), optopt); 2635*99653d4eSeschrock usage(B_FALSE); 2636fa9e4066Sahrens break; 2637fa9e4066Sahrens case '?': 2638fa9e4066Sahrens (void) fprintf(stderr, gettext("invalid option '%c'\n"), 2639fa9e4066Sahrens optopt); 2640fa9e4066Sahrens (void) fprintf(stderr, gettext("usage: mount [-o opts] " 2641fa9e4066Sahrens "<path>\n")); 2642fa9e4066Sahrens return (2); 2643fa9e4066Sahrens } 2644fa9e4066Sahrens } 2645fa9e4066Sahrens 2646fa9e4066Sahrens argc -= optind; 2647fa9e4066Sahrens argv += optind; 2648fa9e4066Sahrens 2649fa9e4066Sahrens /* check that we only have two arguments */ 2650fa9e4066Sahrens if (argc != 2) { 2651fa9e4066Sahrens if (argc == 0) 2652fa9e4066Sahrens (void) fprintf(stderr, gettext("missing dataset " 2653fa9e4066Sahrens "argument\n")); 2654fa9e4066Sahrens else if (argc == 1) 2655fa9e4066Sahrens (void) fprintf(stderr, 2656fa9e4066Sahrens gettext("missing mountpoint argument\n")); 2657fa9e4066Sahrens else 2658fa9e4066Sahrens (void) fprintf(stderr, gettext("too many arguments\n")); 2659fa9e4066Sahrens (void) fprintf(stderr, "usage: mount <dataset> <mountpoint>\n"); 2660fa9e4066Sahrens return (2); 2661fa9e4066Sahrens } 2662fa9e4066Sahrens 2663fa9e4066Sahrens dataset = argv[0]; 2664fa9e4066Sahrens path = argv[1]; 2665fa9e4066Sahrens 2666fa9e4066Sahrens /* try to open the dataset */ 2667*99653d4eSeschrock if ((zhp = zfs_open(g_zfs, dataset, ZFS_TYPE_FILESYSTEM)) == NULL) 2668fa9e4066Sahrens return (1); 2669fa9e4066Sahrens 2670fa9e4066Sahrens (void) zfs_prop_get(zhp, ZFS_PROP_MOUNTPOINT, mountpoint, 2671*99653d4eSeschrock sizeof (mountpoint), NULL, NULL, 0, B_FALSE); 2672fa9e4066Sahrens 2673fa9e4066Sahrens /* check for legacy mountpoint and complain appropriately */ 2674fa9e4066Sahrens ret = 0; 2675fa9e4066Sahrens if (strcmp(mountpoint, ZFS_MOUNTPOINT_LEGACY) == 0) { 2676fa9e4066Sahrens if (mount(dataset, path, MS_OPTIONSTR | flags, MNTTYPE_ZFS, 2677fa9e4066Sahrens NULL, 0, mntopts, sizeof (mntopts)) != 0) { 2678fa9e4066Sahrens (void) fprintf(stderr, gettext("mount failed: %s\n"), 2679fa9e4066Sahrens strerror(errno)); 2680fa9e4066Sahrens ret = 1; 2681fa9e4066Sahrens } 2682fa9e4066Sahrens } else { 2683fa9e4066Sahrens (void) fprintf(stderr, gettext("filesystem '%s' cannot be " 2684fa9e4066Sahrens "mounted using 'mount -F zfs'\n"), dataset); 2685fa9e4066Sahrens (void) fprintf(stderr, gettext("Use 'zfs set mountpoint=%s' " 2686fa9e4066Sahrens "instead.\n"), path); 2687fa9e4066Sahrens (void) fprintf(stderr, gettext("If you must use 'mount -F zfs' " 2688fa9e4066Sahrens "or /etc/vfstab, use 'zfs set mountpoint=legacy'.\n")); 2689fa9e4066Sahrens (void) fprintf(stderr, gettext("See zfs(1M) for more " 2690fa9e4066Sahrens "information.\n")); 2691fa9e4066Sahrens ret = 1; 2692fa9e4066Sahrens } 2693fa9e4066Sahrens 2694fa9e4066Sahrens return (ret); 2695fa9e4066Sahrens } 2696fa9e4066Sahrens 2697fa9e4066Sahrens /* 2698fa9e4066Sahrens * Called when invoked as /etc/fs/zfs/umount. Unlike a manual mount, we allow 2699fa9e4066Sahrens * unmounts of non-legacy filesystems, as this is the dominant administrative 2700fa9e4066Sahrens * interface. 2701fa9e4066Sahrens */ 2702fa9e4066Sahrens static int 2703fa9e4066Sahrens manual_unmount(int argc, char **argv) 2704fa9e4066Sahrens { 2705fa9e4066Sahrens int flags = 0; 2706fa9e4066Sahrens int c; 2707fa9e4066Sahrens 2708fa9e4066Sahrens /* check options */ 2709fa9e4066Sahrens while ((c = getopt(argc, argv, "f")) != -1) { 2710fa9e4066Sahrens switch (c) { 2711fa9e4066Sahrens case 'f': 2712fa9e4066Sahrens flags = MS_FORCE; 2713fa9e4066Sahrens break; 2714fa9e4066Sahrens case '?': 2715fa9e4066Sahrens (void) fprintf(stderr, gettext("invalid option '%c'\n"), 2716fa9e4066Sahrens optopt); 2717fa9e4066Sahrens (void) fprintf(stderr, gettext("usage: unmount [-f] " 2718fa9e4066Sahrens "<path>\n")); 2719fa9e4066Sahrens return (2); 2720fa9e4066Sahrens } 2721fa9e4066Sahrens } 2722fa9e4066Sahrens 2723fa9e4066Sahrens argc -= optind; 2724fa9e4066Sahrens argv += optind; 2725fa9e4066Sahrens 2726fa9e4066Sahrens /* check arguments */ 2727fa9e4066Sahrens if (argc != 1) { 2728fa9e4066Sahrens if (argc == 0) 2729fa9e4066Sahrens (void) fprintf(stderr, gettext("missing path " 2730fa9e4066Sahrens "argument\n")); 2731fa9e4066Sahrens else 2732fa9e4066Sahrens (void) fprintf(stderr, gettext("too many arguments\n")); 2733fa9e4066Sahrens (void) fprintf(stderr, gettext("usage: unmount [-f] <path>\n")); 2734fa9e4066Sahrens return (2); 2735fa9e4066Sahrens } 2736fa9e4066Sahrens 2737*99653d4eSeschrock return (unshare_unmount_path(OP_MOUNT, argv[0], flags, B_TRUE)); 2738fa9e4066Sahrens } 2739fa9e4066Sahrens 2740fa9e4066Sahrens static int 2741fa9e4066Sahrens volcheck(zpool_handle_t *zhp, void *data) 2742fa9e4066Sahrens { 2743fa9e4066Sahrens int isinit = (int)data; 2744fa9e4066Sahrens 2745fa9e4066Sahrens if (isinit) 2746fa9e4066Sahrens return (zpool_create_zvol_links(zhp)); 2747fa9e4066Sahrens else 2748fa9e4066Sahrens return (zpool_remove_zvol_links(zhp)); 2749fa9e4066Sahrens } 2750fa9e4066Sahrens 2751fa9e4066Sahrens /* 2752fa9e4066Sahrens * Iterate over all pools in the system and either create or destroy /dev/zvol 2753fa9e4066Sahrens * links, depending on the value of 'isinit'. 2754fa9e4066Sahrens */ 2755fa9e4066Sahrens static int 2756*99653d4eSeschrock do_volcheck(boolean_t isinit) 2757fa9e4066Sahrens { 2758*99653d4eSeschrock return (zpool_iter(g_zfs, volcheck, (void *)isinit) ? 1 : 0); 2759fa9e4066Sahrens } 2760fa9e4066Sahrens 2761fa9e4066Sahrens int 2762fa9e4066Sahrens main(int argc, char **argv) 2763fa9e4066Sahrens { 2764fa9e4066Sahrens int ret; 2765fa9e4066Sahrens int i; 2766fa9e4066Sahrens char *progname; 2767fa9e4066Sahrens char *cmdname; 2768fa9e4066Sahrens 2769fa9e4066Sahrens (void) setlocale(LC_ALL, ""); 2770fa9e4066Sahrens (void) textdomain(TEXT_DOMAIN); 2771fa9e4066Sahrens 2772fa9e4066Sahrens opterr = 0; 2773fa9e4066Sahrens 2774*99653d4eSeschrock if ((g_zfs = libzfs_init()) == NULL) { 2775*99653d4eSeschrock (void) fprintf(stderr, gettext("internal error: failed to " 2776*99653d4eSeschrock "initialize ZFS library\n")); 2777*99653d4eSeschrock return (1); 2778*99653d4eSeschrock } 2779*99653d4eSeschrock 2780*99653d4eSeschrock libzfs_print_on_error(g_zfs, B_TRUE); 2781*99653d4eSeschrock 2782fa9e4066Sahrens if ((mnttab_file = fopen(MNTTAB, "r")) == NULL) { 2783fa9e4066Sahrens (void) fprintf(stderr, gettext("internal error: unable to " 2784fa9e4066Sahrens "open %s\n"), MNTTAB); 2785fa9e4066Sahrens return (1); 2786fa9e4066Sahrens } 2787fa9e4066Sahrens 2788fa9e4066Sahrens /* 2789fa9e4066Sahrens * This command also doubles as the /etc/fs mount and unmount program. 2790fa9e4066Sahrens * Determine if we should take this behavior based on argv[0]. 2791fa9e4066Sahrens */ 2792fa9e4066Sahrens progname = basename(argv[0]); 2793fa9e4066Sahrens if (strcmp(progname, "mount") == 0) { 2794fa9e4066Sahrens ret = manual_mount(argc, argv); 2795fa9e4066Sahrens } else if (strcmp(progname, "umount") == 0) { 2796fa9e4066Sahrens ret = manual_unmount(argc, argv); 2797fa9e4066Sahrens } else { 2798fa9e4066Sahrens /* 2799fa9e4066Sahrens * Make sure the user has specified some command. 2800fa9e4066Sahrens */ 2801fa9e4066Sahrens if (argc < 2) { 2802fa9e4066Sahrens (void) fprintf(stderr, gettext("missing command\n")); 2803*99653d4eSeschrock usage(B_FALSE); 2804fa9e4066Sahrens } 2805fa9e4066Sahrens 2806fa9e4066Sahrens cmdname = argv[1]; 2807fa9e4066Sahrens 2808fa9e4066Sahrens /* 2809fa9e4066Sahrens * The 'umount' command is an alias for 'unmount' 2810fa9e4066Sahrens */ 2811fa9e4066Sahrens if (strcmp(cmdname, "umount") == 0) 2812fa9e4066Sahrens cmdname = "unmount"; 2813fa9e4066Sahrens 2814fa9e4066Sahrens /* 2815f2a3c691Sahrens * The 'recv' command is an alias for 'receive' 2816f2a3c691Sahrens */ 2817f2a3c691Sahrens if (strcmp(cmdname, "recv") == 0) 2818f2a3c691Sahrens cmdname = "receive"; 2819f2a3c691Sahrens 2820f2a3c691Sahrens /* 2821fa9e4066Sahrens * Special case '-?' 2822fa9e4066Sahrens */ 2823fa9e4066Sahrens if (strcmp(cmdname, "-?") == 0) 2824*99653d4eSeschrock usage(B_TRUE); 2825fa9e4066Sahrens 2826fa9e4066Sahrens /* 2827fa9e4066Sahrens * 'volinit' and 'volfini' do not appear in the usage message, 2828fa9e4066Sahrens * so we have to special case them here. 2829fa9e4066Sahrens */ 2830fa9e4066Sahrens if (strcmp(cmdname, "volinit") == 0) 2831*99653d4eSeschrock return (do_volcheck(B_TRUE)); 2832fa9e4066Sahrens else if (strcmp(cmdname, "volfini") == 0) 2833*99653d4eSeschrock return (do_volcheck(B_FALSE)); 2834fa9e4066Sahrens 2835fa9e4066Sahrens /* 2836fa9e4066Sahrens * Run the appropriate command. 2837fa9e4066Sahrens */ 2838fa9e4066Sahrens for (i = 0; i < NCOMMAND; i++) { 2839fa9e4066Sahrens if (command_table[i].name == NULL) 2840fa9e4066Sahrens continue; 2841fa9e4066Sahrens 2842fa9e4066Sahrens if (strcmp(cmdname, command_table[i].name) == 0) { 2843fa9e4066Sahrens current_command = &command_table[i]; 2844fa9e4066Sahrens ret = command_table[i].func(argc - 1, argv + 1); 2845fa9e4066Sahrens break; 2846fa9e4066Sahrens } 2847fa9e4066Sahrens } 2848fa9e4066Sahrens 2849fa9e4066Sahrens if (i == NCOMMAND) { 2850fa9e4066Sahrens (void) fprintf(stderr, gettext("unrecognized " 2851fa9e4066Sahrens "command '%s'\n"), cmdname); 2852*99653d4eSeschrock usage(B_FALSE); 2853fa9e4066Sahrens } 2854fa9e4066Sahrens } 2855fa9e4066Sahrens 2856fa9e4066Sahrens (void) fclose(mnttab_file); 2857fa9e4066Sahrens 2858*99653d4eSeschrock libzfs_fini(g_zfs); 2859*99653d4eSeschrock 2860fa9e4066Sahrens /* 2861fa9e4066Sahrens * The 'ZFS_ABORT' environment variable causes us to dump core on exit 2862fa9e4066Sahrens * for the purposes of running ::findleaks. 2863fa9e4066Sahrens */ 2864fa9e4066Sahrens if (getenv("ZFS_ABORT") != NULL) { 2865fa9e4066Sahrens (void) printf("dumping core by request\n"); 2866fa9e4066Sahrens abort(); 2867fa9e4066Sahrens } 2868fa9e4066Sahrens 2869fa9e4066Sahrens return (ret); 2870fa9e4066Sahrens } 2871