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" 5099653d4eSeschrock #include "zfs_util.h" 5199653d4eSeschrock 5299653d4eSeschrock 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); 7299653d4eSeschrock 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, 9899653d4eSeschrock 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 }, 13299653d4eSeschrock { "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")); 18599653d4eSeschrock case HELP_PROMOTE: 18699653d4eSeschrock 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: 2041d452cf5Sahrens return (gettext("\tsnapshot [-r] " 2051d452cf5Sahrens "<filesystem@name|volume@name>\n")); 20665cd9f28Seschrock case HELP_UNMOUNT: 20765cd9f28Seschrock return (gettext("\tunmount [-f] -a\n" 20865cd9f28Seschrock "\tunmount [-f] <filesystem|mountpoint>\n")); 20965cd9f28Seschrock case HELP_UNSHARE: 21065cd9f28Seschrock return (gettext("\tunshare [-f] -a\n" 21165cd9f28Seschrock "\tunshare [-f] <filesystem|mountpoint>\n")); 21265cd9f28Seschrock } 21365cd9f28Seschrock 21465cd9f28Seschrock abort(); 21565cd9f28Seschrock /* NOTREACHED */ 21665cd9f28Seschrock } 21765cd9f28Seschrock 218fa9e4066Sahrens /* 219fa9e4066Sahrens * Utility function to guarantee malloc() success. 220fa9e4066Sahrens */ 221fa9e4066Sahrens void * 222fa9e4066Sahrens safe_malloc(size_t size) 223fa9e4066Sahrens { 224fa9e4066Sahrens void *data; 225fa9e4066Sahrens 226fa9e4066Sahrens if ((data = calloc(1, size)) == NULL) { 227fa9e4066Sahrens (void) fprintf(stderr, "internal error: out of memory\n"); 228fa9e4066Sahrens exit(1); 229fa9e4066Sahrens } 230fa9e4066Sahrens 231fa9e4066Sahrens return (data); 232fa9e4066Sahrens } 233fa9e4066Sahrens 234fa9e4066Sahrens /* 235fa9e4066Sahrens * Display usage message. If we're inside a command, display only the usage for 236fa9e4066Sahrens * that command. Otherwise, iterate over the entire command table and display 237fa9e4066Sahrens * a complete usage message. 238fa9e4066Sahrens */ 239fa9e4066Sahrens static void 24099653d4eSeschrock usage(boolean_t requested) 241fa9e4066Sahrens { 242fa9e4066Sahrens int i; 24399653d4eSeschrock boolean_t show_properties = B_FALSE; 244fa9e4066Sahrens FILE *fp = requested ? stdout : stderr; 245fa9e4066Sahrens 246fa9e4066Sahrens if (current_command == NULL) { 247fa9e4066Sahrens 248fa9e4066Sahrens (void) fprintf(fp, gettext("usage: zfs command args ...\n")); 249fa9e4066Sahrens (void) fprintf(fp, 250fa9e4066Sahrens gettext("where 'command' is one of the following:\n\n")); 251fa9e4066Sahrens 252fa9e4066Sahrens for (i = 0; i < NCOMMAND; i++) { 253fa9e4066Sahrens if (command_table[i].name == NULL) 254fa9e4066Sahrens (void) fprintf(fp, "\n"); 255fa9e4066Sahrens else 256fa9e4066Sahrens (void) fprintf(fp, "%s", 25765cd9f28Seschrock get_usage(command_table[i].usage)); 258fa9e4066Sahrens } 259fa9e4066Sahrens 260fa9e4066Sahrens (void) fprintf(fp, gettext("\nEach dataset is of the form: " 261fa9e4066Sahrens "pool/[dataset/]*dataset[@name]\n")); 262fa9e4066Sahrens } else { 263fa9e4066Sahrens (void) fprintf(fp, gettext("usage:\n")); 26465cd9f28Seschrock (void) fprintf(fp, "%s", get_usage(current_command->usage)); 265fa9e4066Sahrens } 266fa9e4066Sahrens 2675c21526aSdarrenm if (current_command != NULL && 2685c21526aSdarrenm (strcmp(current_command->name, "set") == 0 || 269fa9e4066Sahrens strcmp(current_command->name, "get") == 0 || 270fa9e4066Sahrens strcmp(current_command->name, "inherit") == 0 || 2715c21526aSdarrenm strcmp(current_command->name, "list") == 0)) 27299653d4eSeschrock show_properties = B_TRUE; 273fa9e4066Sahrens 274fa9e4066Sahrens if (show_properties) { 275fa9e4066Sahrens 276fa9e4066Sahrens (void) fprintf(fp, 277fa9e4066Sahrens gettext("\nThe following properties are supported:\n")); 278fa9e4066Sahrens 279fa9e4066Sahrens (void) fprintf(fp, "\n\t%-13s %s %s %s\n\n", 280fa9e4066Sahrens "PROPERTY", "EDIT", "INHERIT", "VALUES"); 281fa9e4066Sahrens 282fa9e4066Sahrens for (i = 0; i < ZFS_NPROP_VISIBLE; i++) { 283fa9e4066Sahrens (void) fprintf(fp, "\t%-13s ", zfs_prop_to_name(i)); 284fa9e4066Sahrens 285fa9e4066Sahrens if (zfs_prop_readonly(i)) 286fa9e4066Sahrens (void) fprintf(fp, " NO "); 287fa9e4066Sahrens else 288fa9e4066Sahrens (void) fprintf(fp, " YES "); 289fa9e4066Sahrens 290fa9e4066Sahrens if (zfs_prop_inheritable(i)) 291fa9e4066Sahrens (void) fprintf(fp, " YES "); 292fa9e4066Sahrens else 293fa9e4066Sahrens (void) fprintf(fp, " NO "); 294fa9e4066Sahrens 295fa9e4066Sahrens if (zfs_prop_values(i) == NULL) 296fa9e4066Sahrens (void) fprintf(fp, "-\n"); 297fa9e4066Sahrens else 298fa9e4066Sahrens (void) fprintf(fp, "%s\n", zfs_prop_values(i)); 299fa9e4066Sahrens } 300fa9e4066Sahrens (void) fprintf(fp, gettext("\nSizes are specified in bytes " 301fa9e4066Sahrens "with standard units such as K, M, G, etc.\n")); 3025c21526aSdarrenm } else { 3035c21526aSdarrenm /* 3045c21526aSdarrenm * TRANSLATION NOTE: 3055c21526aSdarrenm * "zfs set|get" must not be localised this is the 3065c21526aSdarrenm * command name and arguments. 3075c21526aSdarrenm */ 3085c21526aSdarrenm (void) fprintf(fp, 3095c21526aSdarrenm gettext("\nFor the property list, run: zfs set|get\n")); 310fa9e4066Sahrens } 311fa9e4066Sahrens 312fa9e4066Sahrens exit(requested ? 0 : 2); 313fa9e4066Sahrens } 314fa9e4066Sahrens 315fa9e4066Sahrens /* 316fa9e4066Sahrens * zfs clone <fs, snap, vol> fs 317fa9e4066Sahrens * 318fa9e4066Sahrens * Given an existing dataset, create a writable copy whose initial contents 319fa9e4066Sahrens * are the same as the source. The newly created dataset maintains a 320fa9e4066Sahrens * dependency on the original; the original cannot be destroyed so long as 321fa9e4066Sahrens * the clone exists. 322fa9e4066Sahrens */ 323fa9e4066Sahrens static int 324fa9e4066Sahrens zfs_do_clone(int argc, char **argv) 325fa9e4066Sahrens { 326fa9e4066Sahrens zfs_handle_t *zhp; 327fa9e4066Sahrens int ret; 328fa9e4066Sahrens 329fa9e4066Sahrens /* check options */ 330fa9e4066Sahrens if (argc > 1 && argv[1][0] == '-') { 331fa9e4066Sahrens (void) fprintf(stderr, gettext("invalid option '%c'\n"), 332fa9e4066Sahrens argv[1][1]); 33399653d4eSeschrock usage(B_FALSE); 334fa9e4066Sahrens } 335fa9e4066Sahrens 336fa9e4066Sahrens /* check number of arguments */ 337fa9e4066Sahrens if (argc < 2) { 338fa9e4066Sahrens (void) fprintf(stderr, gettext("missing source dataset " 339fa9e4066Sahrens "argument\n")); 34099653d4eSeschrock usage(B_FALSE); 341fa9e4066Sahrens } 342fa9e4066Sahrens if (argc < 3) { 343fa9e4066Sahrens (void) fprintf(stderr, gettext("missing target dataset " 344fa9e4066Sahrens "argument\n")); 34599653d4eSeschrock usage(B_FALSE); 346fa9e4066Sahrens } 347fa9e4066Sahrens if (argc > 3) { 348fa9e4066Sahrens (void) fprintf(stderr, gettext("too many arguments\n")); 34999653d4eSeschrock usage(B_FALSE); 350fa9e4066Sahrens } 351fa9e4066Sahrens 352fa9e4066Sahrens /* open the source dataset */ 35399653d4eSeschrock if ((zhp = zfs_open(g_zfs, argv[1], ZFS_TYPE_SNAPSHOT)) == NULL) 354fa9e4066Sahrens return (1); 355fa9e4066Sahrens 356fa9e4066Sahrens /* pass to libzfs */ 357fa9e4066Sahrens ret = zfs_clone(zhp, argv[2]); 358fa9e4066Sahrens 359fa9e4066Sahrens /* create the mountpoint if necessary */ 360fa9e4066Sahrens if (ret == 0) { 36199653d4eSeschrock zfs_handle_t *clone = zfs_open(g_zfs, argv[2], ZFS_TYPE_ANY); 362fa9e4066Sahrens if (clone != NULL) { 363fa9e4066Sahrens if ((ret = zfs_mount(clone, NULL, 0)) == 0) 364fa9e4066Sahrens ret = zfs_share(clone); 365fa9e4066Sahrens zfs_close(clone); 366fa9e4066Sahrens } 367fa9e4066Sahrens } 368fa9e4066Sahrens 369fa9e4066Sahrens zfs_close(zhp); 370fa9e4066Sahrens 371fa9e4066Sahrens return (ret == 0 ? 0 : 1); 372fa9e4066Sahrens } 373fa9e4066Sahrens 374fa9e4066Sahrens /* 375fa9e4066Sahrens * zfs create fs 3761d452cf5Sahrens * zfs create [-s] [-b blocksize] -V vol size 377fa9e4066Sahrens * 378fa9e4066Sahrens * Create a new dataset. This command can be used to create filesystems 379fa9e4066Sahrens * and volumes. Snapshot creation is handled by 'zfs snapshot'. 380fa9e4066Sahrens * For volumes, the user must specify a size to be used. 381fa9e4066Sahrens * 382fa9e4066Sahrens * The '-s' flag applies only to volumes, and indicates that we should not try 383fa9e4066Sahrens * to set the reservation for this volume. By default we set a reservation 384fa9e4066Sahrens * equal to the size for any volume. 385fa9e4066Sahrens */ 386fa9e4066Sahrens static int 387fa9e4066Sahrens zfs_do_create(int argc, char **argv) 388fa9e4066Sahrens { 389fa9e4066Sahrens zfs_type_t type = ZFS_TYPE_FILESYSTEM; 390fa9e4066Sahrens zfs_handle_t *zhp; 391fa9e4066Sahrens char *size = NULL; 392fa9e4066Sahrens char *blocksize = NULL; 393fa9e4066Sahrens int c; 39499653d4eSeschrock boolean_t noreserve = B_FALSE; 395fa9e4066Sahrens int ret; 396fa9e4066Sahrens 397fa9e4066Sahrens /* check options */ 398fa9e4066Sahrens while ((c = getopt(argc, argv, ":V:b:s")) != -1) { 399fa9e4066Sahrens switch (c) { 400fa9e4066Sahrens case 'V': 401fa9e4066Sahrens type = ZFS_TYPE_VOLUME; 402fa9e4066Sahrens size = optarg; 403fa9e4066Sahrens break; 404fa9e4066Sahrens case 'b': 405fa9e4066Sahrens blocksize = optarg; 406fa9e4066Sahrens break; 407fa9e4066Sahrens case 's': 40899653d4eSeschrock noreserve = B_TRUE; 409fa9e4066Sahrens break; 410fa9e4066Sahrens case ':': 411fa9e4066Sahrens (void) fprintf(stderr, gettext("missing size " 412fa9e4066Sahrens "argument\n")); 41399653d4eSeschrock usage(B_FALSE); 414fa9e4066Sahrens break; 415fa9e4066Sahrens case '?': 416fa9e4066Sahrens (void) fprintf(stderr, gettext("invalid option '%c'\n"), 417fa9e4066Sahrens optopt); 41899653d4eSeschrock usage(B_FALSE); 419fa9e4066Sahrens } 420fa9e4066Sahrens } 421fa9e4066Sahrens 422fa9e4066Sahrens if (noreserve && type != ZFS_TYPE_VOLUME) { 423fa9e4066Sahrens (void) fprintf(stderr, gettext("'-s' can only be used when " 424fa9e4066Sahrens "creating a volume\n")); 42599653d4eSeschrock usage(B_FALSE); 426fa9e4066Sahrens } 427fa9e4066Sahrens 428fa9e4066Sahrens argc -= optind; 429fa9e4066Sahrens argv += optind; 430fa9e4066Sahrens 431fa9e4066Sahrens /* check number of arguments */ 432fa9e4066Sahrens if (argc == 0) { 433fa9e4066Sahrens (void) fprintf(stderr, gettext("missing %s argument\n"), 434fa9e4066Sahrens zfs_type_to_name(type)); 43599653d4eSeschrock usage(B_FALSE); 436fa9e4066Sahrens } 437fa9e4066Sahrens if (argc > 1) { 438fa9e4066Sahrens (void) fprintf(stderr, gettext("too many arguments\n")); 43999653d4eSeschrock usage(B_FALSE); 440fa9e4066Sahrens } 441fa9e4066Sahrens 442fa9e4066Sahrens /* pass to libzfs */ 44399653d4eSeschrock if (zfs_create(g_zfs, argv[0], type, size, blocksize) != 0) 444fa9e4066Sahrens return (1); 445fa9e4066Sahrens 44699653d4eSeschrock if ((zhp = zfs_open(g_zfs, argv[0], ZFS_TYPE_ANY)) == NULL) 447fa9e4066Sahrens return (1); 448fa9e4066Sahrens 449fa9e4066Sahrens /* 450fa9e4066Sahrens * Volume handling. By default, we try to create a reservation of equal 451fa9e4066Sahrens * size for the volume. If we can't do this, then destroy the dataset 452fa9e4066Sahrens * and report an error. 453fa9e4066Sahrens */ 454fa9e4066Sahrens if (type == ZFS_TYPE_VOLUME && !noreserve) { 455fa9e4066Sahrens if (zfs_prop_set(zhp, ZFS_PROP_RESERVATION, size) != 0) { 456fa9e4066Sahrens (void) fprintf(stderr, gettext("use '-s' to create a " 457fa9e4066Sahrens "volume without a matching reservation\n")); 458fa9e4066Sahrens (void) zfs_destroy(zhp); 459fa9e4066Sahrens return (1); 460fa9e4066Sahrens } 461fa9e4066Sahrens } 462fa9e4066Sahrens 463fa9e4066Sahrens /* 464fa9e4066Sahrens * Mount and/or share the new filesystem as appropriate. We provide a 465fa9e4066Sahrens * verbose error message to let the user know that their filesystem was 466fa9e4066Sahrens * in fact created, even if we failed to mount or share it. 467fa9e4066Sahrens */ 468fa9e4066Sahrens if (zfs_mount(zhp, NULL, 0) != 0) { 469fa9e4066Sahrens (void) fprintf(stderr, gettext("filesystem successfully " 470fa9e4066Sahrens "created, but not mounted\n")); 471fa9e4066Sahrens ret = 1; 472fa9e4066Sahrens } else if (zfs_share(zhp) != 0) { 473fa9e4066Sahrens (void) fprintf(stderr, gettext("filesystem successfully " 474fa9e4066Sahrens "created, but not shared\n")); 475fa9e4066Sahrens ret = 1; 476fa9e4066Sahrens } else { 477fa9e4066Sahrens ret = 0; 478fa9e4066Sahrens } 479fa9e4066Sahrens 480fa9e4066Sahrens zfs_close(zhp); 481fa9e4066Sahrens return (ret); 482fa9e4066Sahrens } 483fa9e4066Sahrens 484fa9e4066Sahrens /* 485fa9e4066Sahrens * zfs destroy [-rf] <fs, snap, vol> 486fa9e4066Sahrens * 487fa9e4066Sahrens * -r Recursively destroy all children 488fa9e4066Sahrens * -R Recursively destroy all dependents, including clones 489fa9e4066Sahrens * -f Force unmounting of any dependents 490fa9e4066Sahrens * 491fa9e4066Sahrens * Destroys the given dataset. By default, it will unmount any filesystems, 492fa9e4066Sahrens * and refuse to destroy a dataset that has any dependents. A dependent can 493fa9e4066Sahrens * either be a child, or a clone of a child. 494fa9e4066Sahrens */ 495fa9e4066Sahrens typedef struct destroy_cbdata { 49699653d4eSeschrock boolean_t cb_first; 497fa9e4066Sahrens int cb_force; 498fa9e4066Sahrens int cb_recurse; 499fa9e4066Sahrens int cb_error; 500fa9e4066Sahrens int cb_needforce; 501fa9e4066Sahrens int cb_doclones; 502fa9e4066Sahrens zfs_handle_t *cb_target; 5031d452cf5Sahrens char *cb_snapname; 504fa9e4066Sahrens } destroy_cbdata_t; 505fa9e4066Sahrens 506fa9e4066Sahrens /* 507fa9e4066Sahrens * Check for any dependents based on the '-r' or '-R' flags. 508fa9e4066Sahrens */ 509fa9e4066Sahrens static int 510fa9e4066Sahrens destroy_check_dependent(zfs_handle_t *zhp, void *data) 511fa9e4066Sahrens { 512fa9e4066Sahrens destroy_cbdata_t *cbp = data; 513fa9e4066Sahrens const char *tname = zfs_get_name(cbp->cb_target); 514fa9e4066Sahrens const char *name = zfs_get_name(zhp); 515fa9e4066Sahrens 516fa9e4066Sahrens if (strncmp(tname, name, strlen(tname)) == 0 && 517fa9e4066Sahrens (name[strlen(tname)] == '/' || name[strlen(tname)] == '@')) { 518fa9e4066Sahrens /* 519fa9e4066Sahrens * This is a direct descendant, not a clone somewhere else in 520fa9e4066Sahrens * the hierarchy. 521fa9e4066Sahrens */ 522fa9e4066Sahrens if (cbp->cb_recurse) 523fa9e4066Sahrens goto out; 524fa9e4066Sahrens 525fa9e4066Sahrens if (cbp->cb_first) { 526fa9e4066Sahrens (void) fprintf(stderr, gettext("cannot destroy '%s': " 527fa9e4066Sahrens "%s has children\n"), 528fa9e4066Sahrens zfs_get_name(cbp->cb_target), 529fa9e4066Sahrens zfs_type_to_name(zfs_get_type(cbp->cb_target))); 530fa9e4066Sahrens (void) fprintf(stderr, gettext("use '-r' to destroy " 531fa9e4066Sahrens "the following datasets:\n")); 53299653d4eSeschrock cbp->cb_first = B_FALSE; 533fa9e4066Sahrens cbp->cb_error = 1; 534fa9e4066Sahrens } 535fa9e4066Sahrens 536fa9e4066Sahrens (void) fprintf(stderr, "%s\n", zfs_get_name(zhp)); 537fa9e4066Sahrens } else { 538fa9e4066Sahrens /* 539fa9e4066Sahrens * This is a clone. We only want to report this if the '-r' 540fa9e4066Sahrens * wasn't specified, or the target is a snapshot. 541fa9e4066Sahrens */ 542fa9e4066Sahrens if (!cbp->cb_recurse && 543fa9e4066Sahrens zfs_get_type(cbp->cb_target) != ZFS_TYPE_SNAPSHOT) 544fa9e4066Sahrens goto out; 545fa9e4066Sahrens 546fa9e4066Sahrens if (cbp->cb_first) { 547fa9e4066Sahrens (void) fprintf(stderr, gettext("cannot destroy '%s': " 548fa9e4066Sahrens "%s has dependent clones\n"), 549fa9e4066Sahrens zfs_get_name(cbp->cb_target), 550fa9e4066Sahrens zfs_type_to_name(zfs_get_type(cbp->cb_target))); 551fa9e4066Sahrens (void) fprintf(stderr, gettext("use '-R' to destroy " 552fa9e4066Sahrens "the following datasets:\n")); 55399653d4eSeschrock cbp->cb_first = B_FALSE; 554fa9e4066Sahrens cbp->cb_error = 1; 555fa9e4066Sahrens } 556fa9e4066Sahrens 557fa9e4066Sahrens (void) fprintf(stderr, "%s\n", zfs_get_name(zhp)); 558fa9e4066Sahrens } 559fa9e4066Sahrens 560fa9e4066Sahrens out: 561fa9e4066Sahrens zfs_close(zhp); 562fa9e4066Sahrens return (0); 563fa9e4066Sahrens } 564fa9e4066Sahrens 565fa9e4066Sahrens static int 566fa9e4066Sahrens destroy_callback(zfs_handle_t *zhp, void *data) 567fa9e4066Sahrens { 568fa9e4066Sahrens destroy_cbdata_t *cbp = data; 569fa9e4066Sahrens 570fa9e4066Sahrens /* 571fa9e4066Sahrens * Ignore pools (which we've already flagged as an error before getting 572fa9e4066Sahrens * here. 573fa9e4066Sahrens */ 574fa9e4066Sahrens if (strchr(zfs_get_name(zhp), '/') == NULL && 575fa9e4066Sahrens zfs_get_type(zhp) == ZFS_TYPE_FILESYSTEM) { 576fa9e4066Sahrens zfs_close(zhp); 577fa9e4066Sahrens return (0); 578fa9e4066Sahrens } 579fa9e4066Sahrens 580fa9e4066Sahrens /* 581fa9e4066Sahrens * Bail out on the first error. 582fa9e4066Sahrens */ 583fa9e4066Sahrens if (zfs_unmount(zhp, NULL, cbp->cb_force ? MS_FORCE : 0) != 0 || 584fa9e4066Sahrens zfs_destroy(zhp) != 0) { 585fa9e4066Sahrens zfs_close(zhp); 586fa9e4066Sahrens return (-1); 587fa9e4066Sahrens } 588fa9e4066Sahrens 589fa9e4066Sahrens zfs_close(zhp); 590fa9e4066Sahrens return (0); 591fa9e4066Sahrens } 592fa9e4066Sahrens 5931d452cf5Sahrens static int 5941d452cf5Sahrens destroy_snap_clones(zfs_handle_t *zhp, void *arg) 5951d452cf5Sahrens { 5961d452cf5Sahrens destroy_cbdata_t *cbp = arg; 5971d452cf5Sahrens char thissnap[MAXPATHLEN]; 5981d452cf5Sahrens zfs_handle_t *szhp; 5991d452cf5Sahrens 6001d452cf5Sahrens (void) snprintf(thissnap, sizeof (thissnap), 6011d452cf5Sahrens "%s@%s", zfs_get_name(zhp), cbp->cb_snapname); 6021d452cf5Sahrens 6031d452cf5Sahrens libzfs_print_on_error(g_zfs, B_FALSE); 6041d452cf5Sahrens szhp = zfs_open(g_zfs, thissnap, ZFS_TYPE_SNAPSHOT); 6051d452cf5Sahrens libzfs_print_on_error(g_zfs, B_TRUE); 6061d452cf5Sahrens if (szhp) { 6071d452cf5Sahrens /* 6081d452cf5Sahrens * Destroy any clones of this snapshot 6091d452cf5Sahrens */ 6101d452cf5Sahrens (void) zfs_iter_dependents(szhp, destroy_callback, cbp); 6111d452cf5Sahrens zfs_close(szhp); 6121d452cf5Sahrens } 6131d452cf5Sahrens 6141d452cf5Sahrens return (zfs_iter_filesystems(zhp, destroy_snap_clones, arg)); 6151d452cf5Sahrens } 616fa9e4066Sahrens 617fa9e4066Sahrens static int 618fa9e4066Sahrens zfs_do_destroy(int argc, char **argv) 619fa9e4066Sahrens { 620fa9e4066Sahrens destroy_cbdata_t cb = { 0 }; 621fa9e4066Sahrens int c; 622fa9e4066Sahrens zfs_handle_t *zhp; 6231d452cf5Sahrens char *cp; 624fa9e4066Sahrens 625fa9e4066Sahrens /* check options */ 626fa9e4066Sahrens while ((c = getopt(argc, argv, "frR")) != -1) { 627fa9e4066Sahrens switch (c) { 628fa9e4066Sahrens case 'f': 629fa9e4066Sahrens cb.cb_force = 1; 630fa9e4066Sahrens break; 631fa9e4066Sahrens case 'r': 632fa9e4066Sahrens cb.cb_recurse = 1; 633fa9e4066Sahrens break; 634fa9e4066Sahrens case 'R': 635fa9e4066Sahrens cb.cb_recurse = 1; 636fa9e4066Sahrens cb.cb_doclones = 1; 637fa9e4066Sahrens break; 638fa9e4066Sahrens case '?': 639fa9e4066Sahrens default: 640fa9e4066Sahrens (void) fprintf(stderr, gettext("invalid option '%c'\n"), 641fa9e4066Sahrens optopt); 64299653d4eSeschrock usage(B_FALSE); 643fa9e4066Sahrens } 644fa9e4066Sahrens } 645fa9e4066Sahrens 646fa9e4066Sahrens argc -= optind; 647fa9e4066Sahrens argv += optind; 648fa9e4066Sahrens 649fa9e4066Sahrens /* check number of arguments */ 650fa9e4066Sahrens if (argc == 0) { 651fa9e4066Sahrens (void) fprintf(stderr, gettext("missing path argument\n")); 65299653d4eSeschrock usage(B_FALSE); 653fa9e4066Sahrens } 654fa9e4066Sahrens if (argc > 1) { 655fa9e4066Sahrens (void) fprintf(stderr, gettext("too many arguments\n")); 65699653d4eSeschrock usage(B_FALSE); 657fa9e4066Sahrens } 658fa9e4066Sahrens 6591d452cf5Sahrens /* 6601d452cf5Sahrens * If we are doing recursive destroy of a snapshot, then the 6611d452cf5Sahrens * named snapshot may not exist. Go straight to libzfs. 6621d452cf5Sahrens */ 6631d452cf5Sahrens if (cb.cb_recurse && (cp = strchr(argv[0], '@'))) { 6641d452cf5Sahrens int ret; 6651d452cf5Sahrens 6661d452cf5Sahrens *cp = '\0'; 6671d452cf5Sahrens if ((zhp = zfs_open(g_zfs, argv[0], ZFS_TYPE_ANY)) == NULL) 6681d452cf5Sahrens return (1); 6691d452cf5Sahrens *cp = '@'; 6701d452cf5Sahrens cp++; 6711d452cf5Sahrens 6721d452cf5Sahrens if (cb.cb_doclones) { 6731d452cf5Sahrens cb.cb_snapname = cp; 6741d452cf5Sahrens (void) destroy_snap_clones(zhp, &cb); 6751d452cf5Sahrens } 6761d452cf5Sahrens 6771d452cf5Sahrens ret = zfs_destroy_snaps(zhp, cp); 6781d452cf5Sahrens zfs_close(zhp); 6791d452cf5Sahrens if (ret) { 6801d452cf5Sahrens (void) fprintf(stderr, 6811d452cf5Sahrens gettext("no snapshots destroyed\n")); 6821d452cf5Sahrens } 6831d452cf5Sahrens return (ret != 0); 6841d452cf5Sahrens } 6851d452cf5Sahrens 6861d452cf5Sahrens 687fa9e4066Sahrens /* Open the given dataset */ 68899653d4eSeschrock if ((zhp = zfs_open(g_zfs, argv[0], ZFS_TYPE_ANY)) == NULL) 689fa9e4066Sahrens return (1); 690fa9e4066Sahrens 691fa9e4066Sahrens cb.cb_target = zhp; 692fa9e4066Sahrens 693fa9e4066Sahrens /* 694fa9e4066Sahrens * Perform an explicit check for pools before going any further. 695fa9e4066Sahrens */ 696fa9e4066Sahrens if (!cb.cb_recurse && strchr(zfs_get_name(zhp), '/') == NULL && 697fa9e4066Sahrens zfs_get_type(zhp) == ZFS_TYPE_FILESYSTEM) { 698fa9e4066Sahrens (void) fprintf(stderr, gettext("cannot destroy '%s': " 699fa9e4066Sahrens "operation does not apply to pools\n"), 700fa9e4066Sahrens zfs_get_name(zhp)); 701fa9e4066Sahrens (void) fprintf(stderr, gettext("use 'zfs destroy -r " 702fa9e4066Sahrens "%s' to destroy all datasets in the pool\n"), 703fa9e4066Sahrens zfs_get_name(zhp)); 704fa9e4066Sahrens (void) fprintf(stderr, gettext("use 'zpool destroy %s' " 705fa9e4066Sahrens "to destroy the pool itself\n"), zfs_get_name(zhp)); 706fa9e4066Sahrens zfs_close(zhp); 707fa9e4066Sahrens return (1); 708fa9e4066Sahrens } 709fa9e4066Sahrens 710fa9e4066Sahrens /* 711fa9e4066Sahrens * Check for any dependents and/or clones. 712fa9e4066Sahrens */ 71399653d4eSeschrock cb.cb_first = B_TRUE; 714fa9e4066Sahrens if (!cb.cb_doclones) 715fa9e4066Sahrens (void) zfs_iter_dependents(zhp, destroy_check_dependent, &cb); 716fa9e4066Sahrens 717fa9e4066Sahrens if (cb.cb_error) { 718fa9e4066Sahrens zfs_close(zhp); 719fa9e4066Sahrens return (1); 720fa9e4066Sahrens } 721fa9e4066Sahrens 722fa9e4066Sahrens /* 723fa9e4066Sahrens * Do the real thing. 724fa9e4066Sahrens */ 725fa9e4066Sahrens if (zfs_iter_dependents(zhp, destroy_callback, &cb) == 0 && 726fa9e4066Sahrens destroy_callback(zhp, &cb) == 0) 727fa9e4066Sahrens return (0); 728fa9e4066Sahrens 729fa9e4066Sahrens return (1); 730fa9e4066Sahrens } 731fa9e4066Sahrens 732fa9e4066Sahrens /* 73307ba0419Seschrock * zfs get [-rHp] [-o field[,field]...] [-s source[,source]...] 73407ba0419Seschrock * < all | property[,property]... > < fs | snap | vol > ... 735fa9e4066Sahrens * 736fa9e4066Sahrens * -r recurse over any child datasets 737fa9e4066Sahrens * -H scripted mode. Headers are stripped, and fields are separated 738fa9e4066Sahrens * by tabs instead of spaces. 739fa9e4066Sahrens * -o Set of fields to display. One of "name,property,value,source". 740fa9e4066Sahrens * Default is all four. 741fa9e4066Sahrens * -s Set of sources to allow. One of 742fa9e4066Sahrens * "local,default,inherited,temporary,none". Default is all 743fa9e4066Sahrens * five. 744fa9e4066Sahrens * -p Display values in parsable (literal) format. 745fa9e4066Sahrens * 746fa9e4066Sahrens * Prints properties for the given datasets. The user can control which 747fa9e4066Sahrens * columns to display as well as which property types to allow. 748fa9e4066Sahrens */ 749fa9e4066Sahrens typedef struct get_cbdata { 750fa9e4066Sahrens int cb_sources; 751fa9e4066Sahrens int cb_columns[4]; 752fa9e4066Sahrens int cb_nprop; 75399653d4eSeschrock boolean_t cb_scripted; 75499653d4eSeschrock boolean_t cb_literal; 75599653d4eSeschrock boolean_t cb_isall; 75699653d4eSeschrock zfs_prop_t cb_prop[ZFS_NPROP_ALL]; 757fa9e4066Sahrens } get_cbdata_t; 758fa9e4066Sahrens 759fa9e4066Sahrens #define GET_COL_NAME 1 760fa9e4066Sahrens #define GET_COL_PROPERTY 2 761fa9e4066Sahrens #define GET_COL_VALUE 3 762fa9e4066Sahrens #define GET_COL_SOURCE 4 763fa9e4066Sahrens 764fa9e4066Sahrens /* 765fa9e4066Sahrens * Display a single line of output, according to the settings in the callback 766fa9e4066Sahrens * structure. 767fa9e4066Sahrens */ 768fa9e4066Sahrens static void 769fa9e4066Sahrens print_one_property(zfs_handle_t *zhp, get_cbdata_t *cbp, zfs_prop_t prop, 770fa9e4066Sahrens const char *value, zfs_source_t sourcetype, const char *source) 771fa9e4066Sahrens { 772fa9e4066Sahrens int i; 773fa9e4066Sahrens int width; 774fa9e4066Sahrens const char *str; 775fa9e4066Sahrens char buf[128]; 776fa9e4066Sahrens 777fa9e4066Sahrens /* 778fa9e4066Sahrens * Ignore those source types that the user has chosen to ignore. 779fa9e4066Sahrens */ 780fa9e4066Sahrens if ((sourcetype & cbp->cb_sources) == 0) 781fa9e4066Sahrens return; 782fa9e4066Sahrens 783fa9e4066Sahrens for (i = 0; i < 4; i++) { 784fa9e4066Sahrens switch (cbp->cb_columns[i]) { 785fa9e4066Sahrens case GET_COL_NAME: 786fa9e4066Sahrens width = 15; 787fa9e4066Sahrens str = zfs_get_name(zhp); 788fa9e4066Sahrens break; 789fa9e4066Sahrens 790fa9e4066Sahrens case GET_COL_PROPERTY: 791fa9e4066Sahrens width = 13; 792fa9e4066Sahrens str = zfs_prop_to_name(prop); 793fa9e4066Sahrens break; 794fa9e4066Sahrens 795fa9e4066Sahrens case GET_COL_VALUE: 796fa9e4066Sahrens width = 25; 797fa9e4066Sahrens str = value; 798fa9e4066Sahrens break; 799fa9e4066Sahrens 800fa9e4066Sahrens case GET_COL_SOURCE: 801fa9e4066Sahrens width = 15; 802fa9e4066Sahrens switch (sourcetype) { 803fa9e4066Sahrens case ZFS_SRC_NONE: 804fa9e4066Sahrens str = "-"; 805fa9e4066Sahrens break; 806fa9e4066Sahrens 807fa9e4066Sahrens case ZFS_SRC_DEFAULT: 808fa9e4066Sahrens str = "default"; 809fa9e4066Sahrens break; 810fa9e4066Sahrens 811fa9e4066Sahrens case ZFS_SRC_LOCAL: 812fa9e4066Sahrens str = "local"; 813fa9e4066Sahrens break; 814fa9e4066Sahrens 815fa9e4066Sahrens case ZFS_SRC_TEMPORARY: 816fa9e4066Sahrens str = "temporary"; 817fa9e4066Sahrens break; 818fa9e4066Sahrens 819fa9e4066Sahrens case ZFS_SRC_INHERITED: 820fa9e4066Sahrens (void) snprintf(buf, sizeof (buf), 821fa9e4066Sahrens "inherited from %s", source); 822fa9e4066Sahrens str = buf; 823fa9e4066Sahrens break; 824fa9e4066Sahrens } 825fa9e4066Sahrens break; 826fa9e4066Sahrens 827fa9e4066Sahrens default: 828fa9e4066Sahrens continue; 829fa9e4066Sahrens } 830fa9e4066Sahrens 831fa9e4066Sahrens if (cbp->cb_columns[i + 1] == 0) 832fa9e4066Sahrens (void) printf("%s", str); 833fa9e4066Sahrens else if (cbp->cb_scripted) 834fa9e4066Sahrens (void) printf("%s\t", str); 835fa9e4066Sahrens else 836fa9e4066Sahrens (void) printf("%-*s ", width, str); 837fa9e4066Sahrens 838fa9e4066Sahrens } 839fa9e4066Sahrens 840fa9e4066Sahrens (void) printf("\n"); 841fa9e4066Sahrens } 842fa9e4066Sahrens 843fa9e4066Sahrens /* 844fa9e4066Sahrens * Invoked to display the properties for a single dataset. 845fa9e4066Sahrens */ 846fa9e4066Sahrens static int 847fa9e4066Sahrens get_callback(zfs_handle_t *zhp, void *data) 848fa9e4066Sahrens { 849fa9e4066Sahrens char buf[ZFS_MAXPROPLEN]; 850fa9e4066Sahrens zfs_source_t sourcetype; 851fa9e4066Sahrens char source[ZFS_MAXNAMELEN]; 852fa9e4066Sahrens get_cbdata_t *cbp = data; 853fa9e4066Sahrens int i; 854fa9e4066Sahrens 855fa9e4066Sahrens for (i = 0; i < cbp->cb_nprop; i++) { 856fa9e4066Sahrens if (zfs_prop_get(zhp, cbp->cb_prop[i], buf, 857fa9e4066Sahrens sizeof (buf), &sourcetype, source, sizeof (source), 858fa9e4066Sahrens cbp->cb_literal) != 0) { 85907ba0419Seschrock if (cbp->cb_isall) 86007ba0419Seschrock continue; 861fa9e4066Sahrens (void) strlcpy(buf, "-", sizeof (buf)); 862fa9e4066Sahrens sourcetype = ZFS_SRC_NONE; 863fa9e4066Sahrens } 864fa9e4066Sahrens 865fa9e4066Sahrens print_one_property(zhp, cbp, cbp->cb_prop[i], 866fa9e4066Sahrens buf, sourcetype, source); 867fa9e4066Sahrens } 868fa9e4066Sahrens 869fa9e4066Sahrens return (0); 870fa9e4066Sahrens } 871fa9e4066Sahrens 872fa9e4066Sahrens static int 873fa9e4066Sahrens zfs_do_get(int argc, char **argv) 874fa9e4066Sahrens { 875fa9e4066Sahrens get_cbdata_t cb = { 0 }; 87699653d4eSeschrock boolean_t recurse = B_FALSE; 877fa9e4066Sahrens int c; 87807ba0419Seschrock char *value, *fields, *badopt; 879fa9e4066Sahrens int i; 88007ba0419Seschrock int ret; 881fa9e4066Sahrens 882fa9e4066Sahrens /* 883fa9e4066Sahrens * Set up default columns and sources. 884fa9e4066Sahrens */ 885fa9e4066Sahrens cb.cb_sources = ZFS_SRC_ALL; 886fa9e4066Sahrens cb.cb_columns[0] = GET_COL_NAME; 887fa9e4066Sahrens cb.cb_columns[1] = GET_COL_PROPERTY; 888fa9e4066Sahrens cb.cb_columns[2] = GET_COL_VALUE; 889fa9e4066Sahrens cb.cb_columns[3] = GET_COL_SOURCE; 890fa9e4066Sahrens 891fa9e4066Sahrens /* check options */ 892fa9e4066Sahrens while ((c = getopt(argc, argv, ":o:s:rHp")) != -1) { 893fa9e4066Sahrens switch (c) { 894fa9e4066Sahrens case 'p': 89599653d4eSeschrock cb.cb_literal = B_TRUE; 896fa9e4066Sahrens break; 897fa9e4066Sahrens case 'r': 89899653d4eSeschrock recurse = B_TRUE; 899fa9e4066Sahrens break; 900fa9e4066Sahrens case 'H': 90199653d4eSeschrock cb.cb_scripted = B_TRUE; 902fa9e4066Sahrens break; 903fa9e4066Sahrens case ':': 904fa9e4066Sahrens (void) fprintf(stderr, gettext("missing argument for " 905fa9e4066Sahrens "'%c' option\n"), optopt); 90699653d4eSeschrock usage(B_FALSE); 907fa9e4066Sahrens break; 908fa9e4066Sahrens case 'o': 909fa9e4066Sahrens /* 910fa9e4066Sahrens * Process the set of columns to display. We zero out 911fa9e4066Sahrens * the structure to give us a blank slate. 912fa9e4066Sahrens */ 913fa9e4066Sahrens bzero(&cb.cb_columns, sizeof (cb.cb_columns)); 914fa9e4066Sahrens i = 0; 915fa9e4066Sahrens while (*optarg != '\0') { 916fa9e4066Sahrens static char *col_subopts[] = 917fa9e4066Sahrens { "name", "property", "value", "source", 918fa9e4066Sahrens NULL }; 919fa9e4066Sahrens 920fa9e4066Sahrens if (i == 4) { 921fa9e4066Sahrens (void) fprintf(stderr, gettext("too " 922fa9e4066Sahrens "many fields given to -o " 923fa9e4066Sahrens "option\n")); 92499653d4eSeschrock usage(B_FALSE); 925fa9e4066Sahrens } 926fa9e4066Sahrens 927fa9e4066Sahrens switch (getsubopt(&optarg, col_subopts, 928fa9e4066Sahrens &value)) { 929fa9e4066Sahrens case 0: 930fa9e4066Sahrens cb.cb_columns[i++] = GET_COL_NAME; 931fa9e4066Sahrens break; 932fa9e4066Sahrens case 1: 933fa9e4066Sahrens cb.cb_columns[i++] = GET_COL_PROPERTY; 934fa9e4066Sahrens break; 935fa9e4066Sahrens case 2: 936fa9e4066Sahrens cb.cb_columns[i++] = GET_COL_VALUE; 937fa9e4066Sahrens break; 938fa9e4066Sahrens case 3: 939fa9e4066Sahrens cb.cb_columns[i++] = GET_COL_SOURCE; 940fa9e4066Sahrens break; 941fa9e4066Sahrens default: 942fa9e4066Sahrens (void) fprintf(stderr, 943fa9e4066Sahrens gettext("invalid column name " 944fa9e4066Sahrens "'%s'\n"), value); 94599653d4eSeschrock usage(B_FALSE); 946fa9e4066Sahrens } 947fa9e4066Sahrens } 948fa9e4066Sahrens break; 949fa9e4066Sahrens 950fa9e4066Sahrens case 's': 951fa9e4066Sahrens cb.cb_sources = 0; 952fa9e4066Sahrens while (*optarg != '\0') { 953fa9e4066Sahrens static char *source_subopts[] = { 954fa9e4066Sahrens "local", "default", "inherited", 955fa9e4066Sahrens "temporary", "none", NULL }; 956fa9e4066Sahrens 957fa9e4066Sahrens switch (getsubopt(&optarg, source_subopts, 958fa9e4066Sahrens &value)) { 959fa9e4066Sahrens case 0: 960fa9e4066Sahrens cb.cb_sources |= ZFS_SRC_LOCAL; 961fa9e4066Sahrens break; 962fa9e4066Sahrens case 1: 963fa9e4066Sahrens cb.cb_sources |= ZFS_SRC_DEFAULT; 964fa9e4066Sahrens break; 965fa9e4066Sahrens case 2: 966fa9e4066Sahrens cb.cb_sources |= ZFS_SRC_INHERITED; 967fa9e4066Sahrens break; 968fa9e4066Sahrens case 3: 969fa9e4066Sahrens cb.cb_sources |= ZFS_SRC_TEMPORARY; 970fa9e4066Sahrens break; 971fa9e4066Sahrens case 4: 972fa9e4066Sahrens cb.cb_sources |= ZFS_SRC_NONE; 973fa9e4066Sahrens break; 974fa9e4066Sahrens default: 975fa9e4066Sahrens (void) fprintf(stderr, 976fa9e4066Sahrens gettext("invalid source " 977fa9e4066Sahrens "'%s'\n"), value); 97899653d4eSeschrock usage(B_FALSE); 979fa9e4066Sahrens } 980fa9e4066Sahrens } 981fa9e4066Sahrens break; 982fa9e4066Sahrens 983fa9e4066Sahrens case '?': 984fa9e4066Sahrens (void) fprintf(stderr, gettext("invalid option '%c'\n"), 985fa9e4066Sahrens optopt); 98699653d4eSeschrock usage(B_FALSE); 987fa9e4066Sahrens } 988fa9e4066Sahrens } 989fa9e4066Sahrens 990fa9e4066Sahrens argc -= optind; 991fa9e4066Sahrens argv += optind; 992fa9e4066Sahrens 993fa9e4066Sahrens if (argc < 1) { 994fa9e4066Sahrens (void) fprintf(stderr, gettext("missing property " 995fa9e4066Sahrens "argument\n")); 99699653d4eSeschrock usage(B_FALSE); 997fa9e4066Sahrens } 998fa9e4066Sahrens 999fa9e4066Sahrens fields = argv[0]; 1000fa9e4066Sahrens 1001fa9e4066Sahrens /* 100207ba0419Seschrock * If the user specifies 'all', the behavior of 'zfs get' is slightly 100307ba0419Seschrock * different, because we don't show properties which don't apply to the 100407ba0419Seschrock * given dataset. 1005fa9e4066Sahrens */ 100607ba0419Seschrock if (strcmp(fields, "all") == 0) 100799653d4eSeschrock cb.cb_isall = B_TRUE; 100807ba0419Seschrock 100907ba0419Seschrock if ((ret = zfs_get_proplist(fields, cb.cb_prop, ZFS_NPROP_ALL, 101007ba0419Seschrock &cb.cb_nprop, &badopt)) != 0) { 101107ba0419Seschrock if (ret == EINVAL) 101207ba0419Seschrock (void) fprintf(stderr, gettext("invalid property " 101307ba0419Seschrock "'%s'\n"), badopt); 101407ba0419Seschrock else 101507ba0419Seschrock (void) fprintf(stderr, gettext("too many properties " 101607ba0419Seschrock "specified\n")); 101799653d4eSeschrock usage(B_FALSE); 1018fa9e4066Sahrens } 1019fa9e4066Sahrens 1020fa9e4066Sahrens argc--; 1021fa9e4066Sahrens argv++; 1022fa9e4066Sahrens 1023fa9e4066Sahrens /* check for at least one dataset name */ 1024fa9e4066Sahrens if (argc < 1) { 1025fa9e4066Sahrens (void) fprintf(stderr, gettext("missing dataset argument\n")); 102699653d4eSeschrock usage(B_FALSE); 1027fa9e4066Sahrens } 1028fa9e4066Sahrens 1029fa9e4066Sahrens /* 1030fa9e4066Sahrens * Print out any headers 1031fa9e4066Sahrens */ 1032fa9e4066Sahrens if (!cb.cb_scripted) { 1033fa9e4066Sahrens int i; 1034fa9e4066Sahrens for (i = 0; i < 4; i++) { 1035fa9e4066Sahrens switch (cb.cb_columns[i]) { 1036fa9e4066Sahrens case GET_COL_NAME: 1037fa9e4066Sahrens (void) printf("%-15s ", "NAME"); 1038fa9e4066Sahrens break; 1039fa9e4066Sahrens case GET_COL_PROPERTY: 1040fa9e4066Sahrens (void) printf("%-13s ", "PROPERTY"); 1041fa9e4066Sahrens break; 1042fa9e4066Sahrens case GET_COL_VALUE: 1043fa9e4066Sahrens (void) printf("%-25s ", "VALUE"); 1044fa9e4066Sahrens break; 1045fa9e4066Sahrens case GET_COL_SOURCE: 1046fa9e4066Sahrens (void) printf("%s", "SOURCE"); 1047fa9e4066Sahrens break; 1048fa9e4066Sahrens } 1049fa9e4066Sahrens } 1050fa9e4066Sahrens (void) printf("\n"); 1051fa9e4066Sahrens } 1052fa9e4066Sahrens 1053fa9e4066Sahrens /* run for each object */ 1054fa9e4066Sahrens return (zfs_for_each(argc, argv, recurse, ZFS_TYPE_ANY, 1055fa9e4066Sahrens get_callback, &cb)); 1056fa9e4066Sahrens } 1057fa9e4066Sahrens 1058fa9e4066Sahrens /* 1059fa9e4066Sahrens * inherit [-r] <property> <fs|vol> ... 1060fa9e4066Sahrens * 1061fa9e4066Sahrens * -r Recurse over all children 1062fa9e4066Sahrens * 1063fa9e4066Sahrens * For each dataset specified on the command line, inherit the given property 1064fa9e4066Sahrens * from its parent. Inheriting a property at the pool level will cause it to 1065fa9e4066Sahrens * use the default value. The '-r' flag will recurse over all children, and is 1066fa9e4066Sahrens * useful for setting a property on a hierarchy-wide basis, regardless of any 1067fa9e4066Sahrens * local modifications for each dataset. 1068fa9e4066Sahrens */ 1069fa9e4066Sahrens static int 1070fa9e4066Sahrens inherit_callback(zfs_handle_t *zhp, void *data) 1071fa9e4066Sahrens { 1072fa9e4066Sahrens zfs_prop_t prop = (zfs_prop_t)data; 1073fa9e4066Sahrens 1074fa9e4066Sahrens return (zfs_prop_inherit(zhp, prop) != 0); 1075fa9e4066Sahrens } 1076fa9e4066Sahrens 1077fa9e4066Sahrens static int 1078fa9e4066Sahrens zfs_do_inherit(int argc, char **argv) 1079fa9e4066Sahrens { 108099653d4eSeschrock boolean_t recurse = B_FALSE; 1081fa9e4066Sahrens int c; 1082fa9e4066Sahrens zfs_prop_t prop; 1083fa9e4066Sahrens char *propname; 1084fa9e4066Sahrens 1085fa9e4066Sahrens /* check options */ 1086fa9e4066Sahrens while ((c = getopt(argc, argv, "r")) != -1) { 1087fa9e4066Sahrens switch (c) { 1088fa9e4066Sahrens case 'r': 108999653d4eSeschrock recurse = B_TRUE; 1090fa9e4066Sahrens break; 1091fa9e4066Sahrens case '?': 1092fa9e4066Sahrens default: 1093fa9e4066Sahrens (void) fprintf(stderr, gettext("invalid option '%c'\n"), 1094fa9e4066Sahrens optopt); 109599653d4eSeschrock usage(B_FALSE); 1096fa9e4066Sahrens } 1097fa9e4066Sahrens } 1098fa9e4066Sahrens 1099fa9e4066Sahrens argc -= optind; 1100fa9e4066Sahrens argv += optind; 1101fa9e4066Sahrens 1102fa9e4066Sahrens /* check number of arguments */ 1103fa9e4066Sahrens if (argc < 1) { 1104fa9e4066Sahrens (void) fprintf(stderr, gettext("missing property argument\n")); 110599653d4eSeschrock usage(B_FALSE); 1106fa9e4066Sahrens } 1107fa9e4066Sahrens if (argc < 2) { 1108fa9e4066Sahrens (void) fprintf(stderr, gettext("missing dataset argument\n")); 110999653d4eSeschrock usage(B_FALSE); 1110fa9e4066Sahrens } 1111fa9e4066Sahrens 1112fa9e4066Sahrens propname = argv[0]; 1113fa9e4066Sahrens 1114fa9e4066Sahrens /* 1115fa9e4066Sahrens * Get and validate the property before iterating over the datasets. We 1116fa9e4066Sahrens * do this now so as to avoid printing out an error message for each and 1117fa9e4066Sahrens * every dataset. 1118fa9e4066Sahrens */ 1119fa9e4066Sahrens if ((prop = zfs_name_to_prop(propname)) == ZFS_PROP_INVAL) { 1120fa9e4066Sahrens (void) fprintf(stderr, gettext("invalid property '%s'\n"), 1121fa9e4066Sahrens propname); 112299653d4eSeschrock usage(B_FALSE); 1123fa9e4066Sahrens } 1124fa9e4066Sahrens if (zfs_prop_readonly(prop)) { 1125fa9e4066Sahrens (void) fprintf(stderr, gettext("%s property is read-only\n"), 1126fa9e4066Sahrens propname); 1127fa9e4066Sahrens return (1); 1128fa9e4066Sahrens } 1129fa9e4066Sahrens if (!zfs_prop_inheritable(prop)) { 1130fa9e4066Sahrens (void) fprintf(stderr, gettext("%s property cannot be " 1131fa9e4066Sahrens "inherited\n"), propname); 1132fa9e4066Sahrens (void) fprintf(stderr, gettext("use 'zfs set %s=none' to " 1133fa9e4066Sahrens "clear\n"), propname); 1134fa9e4066Sahrens return (1); 1135fa9e4066Sahrens } 1136fa9e4066Sahrens 1137fa9e4066Sahrens return (zfs_for_each(argc - 1, argv + 1, recurse, 1138fa9e4066Sahrens ZFS_TYPE_FILESYSTEM | ZFS_TYPE_VOLUME, 1139fa9e4066Sahrens inherit_callback, (void *)prop)); 1140fa9e4066Sahrens } 1141fa9e4066Sahrens 1142fa9e4066Sahrens /* 114307ba0419Seschrock * list [-rH] [-o property[,property]...] [-t type[,type]...] <dataset> ... 1144fa9e4066Sahrens * 1145fa9e4066Sahrens * -r Recurse over all children 1146fa9e4066Sahrens * -H Scripted mode; elide headers and separate colums by tabs 1147fa9e4066Sahrens * -o Control which fields to display. 114807ba0419Seschrock * -t Control which object types to display. 1149fa9e4066Sahrens * 1150fa9e4066Sahrens * When given no arguments, lists all filesystems in the system. 1151fa9e4066Sahrens * Otherwise, list the specified datasets, optionally recursing down them if 1152fa9e4066Sahrens * '-r' is specified. 1153fa9e4066Sahrens */ 1154fa9e4066Sahrens typedef struct list_cbdata { 115599653d4eSeschrock boolean_t cb_first; 115699653d4eSeschrock boolean_t cb_scripted; 115707ba0419Seschrock zfs_prop_t cb_fields[ZFS_NPROP_ALL]; 1158fa9e4066Sahrens int cb_fieldcount; 1159fa9e4066Sahrens } list_cbdata_t; 1160fa9e4066Sahrens 1161fa9e4066Sahrens /* 1162fa9e4066Sahrens * Given a list of columns to display, output appropriate headers for each one. 1163fa9e4066Sahrens */ 1164fa9e4066Sahrens static void 116507ba0419Seschrock print_header(zfs_prop_t *fields, size_t count) 1166fa9e4066Sahrens { 1167fa9e4066Sahrens int i; 1168fa9e4066Sahrens 1169fa9e4066Sahrens for (i = 0; i < count; i++) { 1170fa9e4066Sahrens if (i != 0) 1171fa9e4066Sahrens (void) printf(" "); 1172fa9e4066Sahrens if (i == count - 1) 1173fa9e4066Sahrens (void) printf("%s", zfs_prop_column_name(fields[i])); 1174fa9e4066Sahrens else /* LINTED - format specifier */ 1175fa9e4066Sahrens (void) printf(zfs_prop_column_format(fields[i]), 1176fa9e4066Sahrens zfs_prop_column_name(fields[i])); 1177fa9e4066Sahrens } 1178fa9e4066Sahrens 1179fa9e4066Sahrens (void) printf("\n"); 1180fa9e4066Sahrens } 1181fa9e4066Sahrens 1182fa9e4066Sahrens /* 1183fa9e4066Sahrens * Given a dataset and a list of fields, print out all the properties according 1184fa9e4066Sahrens * to the described layout. 1185fa9e4066Sahrens */ 1186fa9e4066Sahrens static void 118707ba0419Seschrock print_dataset(zfs_handle_t *zhp, zfs_prop_t *fields, size_t count, int scripted) 1188fa9e4066Sahrens { 1189fa9e4066Sahrens int i; 1190fa9e4066Sahrens char property[ZFS_MAXPROPLEN]; 1191fa9e4066Sahrens 1192fa9e4066Sahrens for (i = 0; i < count; i++) { 1193fa9e4066Sahrens if (i != 0) { 1194fa9e4066Sahrens if (scripted) 1195fa9e4066Sahrens (void) printf("\t"); 1196fa9e4066Sahrens else 1197fa9e4066Sahrens (void) printf(" "); 1198fa9e4066Sahrens } 1199fa9e4066Sahrens 1200fa9e4066Sahrens if (zfs_prop_get(zhp, fields[i], property, 120199653d4eSeschrock sizeof (property), NULL, NULL, 0, B_FALSE) != 0) 1202fa9e4066Sahrens (void) strlcpy(property, "-", sizeof (property)); 1203fa9e4066Sahrens 120407ba0419Seschrock /* 120507ba0419Seschrock * If this is being called in scripted mode, or if this is the 120607ba0419Seschrock * last column and it is left-justified, don't include a width 120707ba0419Seschrock * format specifier. 120807ba0419Seschrock */ 120907ba0419Seschrock if (scripted || (i == count - 1 && 121007ba0419Seschrock strchr(zfs_prop_column_format(fields[i]), '-') != NULL)) 1211fa9e4066Sahrens (void) printf("%s", property); 1212fa9e4066Sahrens else /* LINTED - format specifier */ 1213fa9e4066Sahrens (void) printf(zfs_prop_column_format(fields[i]), 1214fa9e4066Sahrens property); 1215fa9e4066Sahrens } 1216fa9e4066Sahrens 1217fa9e4066Sahrens (void) printf("\n"); 1218fa9e4066Sahrens } 1219fa9e4066Sahrens 1220fa9e4066Sahrens /* 1221fa9e4066Sahrens * Generic callback function to list a dataset or snapshot. 1222fa9e4066Sahrens */ 1223fa9e4066Sahrens static int 1224fa9e4066Sahrens list_callback(zfs_handle_t *zhp, void *data) 1225fa9e4066Sahrens { 1226fa9e4066Sahrens list_cbdata_t *cbp = data; 1227fa9e4066Sahrens 1228fa9e4066Sahrens if (cbp->cb_first) { 1229fa9e4066Sahrens if (!cbp->cb_scripted) 1230fa9e4066Sahrens print_header(cbp->cb_fields, cbp->cb_fieldcount); 123199653d4eSeschrock cbp->cb_first = B_FALSE; 1232fa9e4066Sahrens } 1233fa9e4066Sahrens 1234fa9e4066Sahrens print_dataset(zhp, cbp->cb_fields, cbp->cb_fieldcount, 1235fa9e4066Sahrens cbp->cb_scripted); 1236fa9e4066Sahrens 1237fa9e4066Sahrens return (0); 1238fa9e4066Sahrens } 1239fa9e4066Sahrens 1240fa9e4066Sahrens static int 1241fa9e4066Sahrens zfs_do_list(int argc, char **argv) 1242fa9e4066Sahrens { 1243fa9e4066Sahrens int c; 124499653d4eSeschrock boolean_t recurse = B_FALSE; 124599653d4eSeschrock boolean_t scripted = B_FALSE; 1246fa9e4066Sahrens static char default_fields[] = 1247fa9e4066Sahrens "name,used,available,referenced,mountpoint"; 1248fa9e4066Sahrens int types = ZFS_TYPE_ANY; 1249fa9e4066Sahrens char *fields = NULL; 1250fa9e4066Sahrens char *basic_fields = default_fields; 1251fa9e4066Sahrens list_cbdata_t cb = { 0 }; 1252fa9e4066Sahrens char *value; 1253fa9e4066Sahrens int ret; 1254fa9e4066Sahrens char *type_subopts[] = { "filesystem", "volume", "snapshot", NULL }; 125507ba0419Seschrock char *badopt; 125607ba0419Seschrock int alloffset; 1257fa9e4066Sahrens 1258fa9e4066Sahrens /* check options */ 1259fa9e4066Sahrens while ((c = getopt(argc, argv, ":o:rt:H")) != -1) { 1260fa9e4066Sahrens switch (c) { 1261fa9e4066Sahrens case 'o': 1262fa9e4066Sahrens fields = optarg; 1263fa9e4066Sahrens break; 1264fa9e4066Sahrens case 'r': 126599653d4eSeschrock recurse = B_TRUE; 1266fa9e4066Sahrens break; 1267fa9e4066Sahrens case 'H': 126899653d4eSeschrock scripted = B_TRUE; 1269fa9e4066Sahrens break; 1270fa9e4066Sahrens case 't': 1271fa9e4066Sahrens types = 0; 1272fa9e4066Sahrens while (*optarg != '\0') { 1273fa9e4066Sahrens switch (getsubopt(&optarg, type_subopts, 1274fa9e4066Sahrens &value)) { 1275fa9e4066Sahrens case 0: 1276fa9e4066Sahrens types |= ZFS_TYPE_FILESYSTEM; 1277fa9e4066Sahrens break; 1278fa9e4066Sahrens case 1: 1279fa9e4066Sahrens types |= ZFS_TYPE_VOLUME; 1280fa9e4066Sahrens break; 1281fa9e4066Sahrens case 2: 1282fa9e4066Sahrens types |= ZFS_TYPE_SNAPSHOT; 1283fa9e4066Sahrens break; 1284fa9e4066Sahrens default: 1285fa9e4066Sahrens (void) fprintf(stderr, 1286fa9e4066Sahrens gettext("invalid type '%s'\n"), 1287fa9e4066Sahrens value); 128899653d4eSeschrock usage(B_FALSE); 1289fa9e4066Sahrens } 1290fa9e4066Sahrens } 1291fa9e4066Sahrens break; 1292fa9e4066Sahrens case ':': 1293fa9e4066Sahrens (void) fprintf(stderr, gettext("missing argument for " 1294fa9e4066Sahrens "'%c' option\n"), optopt); 129599653d4eSeschrock usage(B_FALSE); 1296fa9e4066Sahrens break; 1297fa9e4066Sahrens case '?': 1298fa9e4066Sahrens (void) fprintf(stderr, gettext("invalid option '%c'\n"), 1299fa9e4066Sahrens optopt); 130099653d4eSeschrock usage(B_FALSE); 1301fa9e4066Sahrens } 1302fa9e4066Sahrens } 1303fa9e4066Sahrens 1304fa9e4066Sahrens argc -= optind; 1305fa9e4066Sahrens argv += optind; 1306fa9e4066Sahrens 1307fa9e4066Sahrens if (fields == NULL) 1308fa9e4066Sahrens fields = basic_fields; 1309fa9e4066Sahrens 131007ba0419Seschrock /* 131107ba0419Seschrock * If the user specifies '-o all', the zfs_get_proplist() doesn't 131207ba0419Seschrock * normally include the name of the dataset. For 'zfs list', we always 131307ba0419Seschrock * want this property to be first. 131407ba0419Seschrock */ 131507ba0419Seschrock if (strcmp(fields, "all") == 0) { 131607ba0419Seschrock cb.cb_fields[0] = ZFS_PROP_NAME; 131707ba0419Seschrock alloffset = 1; 131807ba0419Seschrock } else { 131907ba0419Seschrock alloffset = 0; 1320fa9e4066Sahrens } 1321fa9e4066Sahrens 132207ba0419Seschrock if ((ret = zfs_get_proplist(fields, cb.cb_fields + alloffset, 132307ba0419Seschrock ZFS_NPROP_ALL - alloffset, &cb.cb_fieldcount, &badopt)) != 0) { 132407ba0419Seschrock if (ret == EINVAL) 1325fa9e4066Sahrens (void) fprintf(stderr, gettext("invalid property " 132607ba0419Seschrock "'%s'\n"), badopt); 132707ba0419Seschrock else 132807ba0419Seschrock (void) fprintf(stderr, gettext("too many properties " 132907ba0419Seschrock "specified\n")); 133099653d4eSeschrock usage(B_FALSE); 1331fa9e4066Sahrens } 1332fa9e4066Sahrens 133307ba0419Seschrock cb.cb_fieldcount += alloffset; 1334fa9e4066Sahrens cb.cb_scripted = scripted; 133599653d4eSeschrock cb.cb_first = B_TRUE; 1336fa9e4066Sahrens 1337fa9e4066Sahrens ret = zfs_for_each(argc, argv, recurse, types, list_callback, &cb); 1338fa9e4066Sahrens 133999653d4eSeschrock if (ret == 0 && cb.cb_first) 1340fa9e4066Sahrens (void) printf(gettext("no datasets available\n")); 1341fa9e4066Sahrens 1342fa9e4066Sahrens return (ret); 1343fa9e4066Sahrens } 1344fa9e4066Sahrens 1345fa9e4066Sahrens /* 1346fa9e4066Sahrens * zfs rename <fs | snap | vol> <fs | snap | vol> 1347fa9e4066Sahrens * 1348fa9e4066Sahrens * Renames the given dataset to another of the same type. 1349fa9e4066Sahrens */ 1350fa9e4066Sahrens /* ARGSUSED */ 1351fa9e4066Sahrens static int 1352fa9e4066Sahrens zfs_do_rename(int argc, char **argv) 1353fa9e4066Sahrens { 1354fa9e4066Sahrens zfs_handle_t *zhp; 135599653d4eSeschrock int ret; 1356fa9e4066Sahrens 1357fa9e4066Sahrens /* check options */ 1358fa9e4066Sahrens if (argc > 1 && argv[1][0] == '-') { 1359fa9e4066Sahrens (void) fprintf(stderr, gettext("invalid option '%c'\n"), 1360fa9e4066Sahrens argv[1][1]); 136199653d4eSeschrock usage(B_FALSE); 1362fa9e4066Sahrens } 1363fa9e4066Sahrens 1364fa9e4066Sahrens /* check number of arguments */ 1365fa9e4066Sahrens if (argc < 2) { 1366fa9e4066Sahrens (void) fprintf(stderr, gettext("missing source dataset " 1367fa9e4066Sahrens "argument\n")); 136899653d4eSeschrock usage(B_FALSE); 1369fa9e4066Sahrens } 1370fa9e4066Sahrens if (argc < 3) { 1371fa9e4066Sahrens (void) fprintf(stderr, gettext("missing target dataset " 1372fa9e4066Sahrens "argument\n")); 137399653d4eSeschrock usage(B_FALSE); 1374fa9e4066Sahrens } 1375fa9e4066Sahrens if (argc > 3) { 1376fa9e4066Sahrens (void) fprintf(stderr, gettext("too many arguments\n")); 137799653d4eSeschrock usage(B_FALSE); 1378fa9e4066Sahrens } 1379fa9e4066Sahrens 138099653d4eSeschrock if ((zhp = zfs_open(g_zfs, argv[1], ZFS_TYPE_ANY)) == NULL) 1381fa9e4066Sahrens return (1); 1382fa9e4066Sahrens 138399653d4eSeschrock ret = (zfs_rename(zhp, argv[2]) != 0); 1384fa9e4066Sahrens 138599653d4eSeschrock zfs_close(zhp); 138699653d4eSeschrock return (ret); 138799653d4eSeschrock } 138899653d4eSeschrock 138999653d4eSeschrock /* 139099653d4eSeschrock * zfs promote <fs> 139199653d4eSeschrock * 139299653d4eSeschrock * Promotes the given clone fs to be the parent 139399653d4eSeschrock */ 139499653d4eSeschrock /* ARGSUSED */ 139599653d4eSeschrock static int 139699653d4eSeschrock zfs_do_promote(int argc, char **argv) 139799653d4eSeschrock { 139899653d4eSeschrock zfs_handle_t *zhp; 139999653d4eSeschrock int ret; 140099653d4eSeschrock 140199653d4eSeschrock /* check options */ 140299653d4eSeschrock if (argc > 1 && argv[1][0] == '-') { 140399653d4eSeschrock (void) fprintf(stderr, gettext("invalid option '%c'\n"), 140499653d4eSeschrock argv[1][1]); 140599653d4eSeschrock usage(B_FALSE); 140699653d4eSeschrock } 140799653d4eSeschrock 140899653d4eSeschrock /* check number of arguments */ 140999653d4eSeschrock if (argc < 2) { 141099653d4eSeschrock (void) fprintf(stderr, gettext("missing clone filesystem" 141199653d4eSeschrock "argument\n")); 141299653d4eSeschrock usage(B_FALSE); 141399653d4eSeschrock } 141499653d4eSeschrock if (argc > 2) { 141599653d4eSeschrock (void) fprintf(stderr, gettext("too many arguments\n")); 141699653d4eSeschrock usage(B_FALSE); 141799653d4eSeschrock } 141899653d4eSeschrock 141999653d4eSeschrock zhp = zfs_open(g_zfs, argv[1], ZFS_TYPE_FILESYSTEM | ZFS_TYPE_VOLUME); 142099653d4eSeschrock if (zhp == NULL) 142199653d4eSeschrock return (1); 142299653d4eSeschrock 142399653d4eSeschrock ret = (zfs_promote(zhp) != 0); 142499653d4eSeschrock 1425fa9e4066Sahrens zfs_close(zhp); 1426fa9e4066Sahrens return (ret); 1427fa9e4066Sahrens } 1428fa9e4066Sahrens 1429fa9e4066Sahrens /* 1430fa9e4066Sahrens * zfs rollback [-rfR] <snapshot> 1431fa9e4066Sahrens * 1432fa9e4066Sahrens * -r Delete any intervening snapshots before doing rollback 1433fa9e4066Sahrens * -R Delete any snapshots and their clones 1434fa9e4066Sahrens * -f Force unmount filesystems, even if they are in use. 1435fa9e4066Sahrens * 1436fa9e4066Sahrens * Given a filesystem, rollback to a specific snapshot, discarding any changes 1437fa9e4066Sahrens * since then and making it the active dataset. If more recent snapshots exist, 1438fa9e4066Sahrens * the command will complain unless the '-r' flag is given. 1439fa9e4066Sahrens */ 1440fa9e4066Sahrens typedef struct rollback_cbdata { 1441fa9e4066Sahrens uint64_t cb_create; 144299653d4eSeschrock boolean_t cb_first; 1443fa9e4066Sahrens int cb_doclones; 1444fa9e4066Sahrens char *cb_target; 1445fa9e4066Sahrens int cb_error; 144699653d4eSeschrock boolean_t cb_recurse; 144799653d4eSeschrock boolean_t cb_dependent; 1448fa9e4066Sahrens } rollback_cbdata_t; 1449fa9e4066Sahrens 1450fa9e4066Sahrens /* 1451fa9e4066Sahrens * Report any snapshots more recent than the one specified. Used when '-r' is 1452fa9e4066Sahrens * not specified. We reuse this same callback for the snapshot dependents - if 1453fa9e4066Sahrens * 'cb_dependent' is set, then this is a dependent and we should report it 1454fa9e4066Sahrens * without checking the transaction group. 1455fa9e4066Sahrens */ 1456fa9e4066Sahrens static int 1457fa9e4066Sahrens rollback_check(zfs_handle_t *zhp, void *data) 1458fa9e4066Sahrens { 1459fa9e4066Sahrens rollback_cbdata_t *cbp = data; 1460fa9e4066Sahrens 146199653d4eSeschrock if (cbp->cb_doclones) { 146299653d4eSeschrock zfs_close(zhp); 1463fa9e4066Sahrens return (0); 146499653d4eSeschrock } 1465fa9e4066Sahrens 1466fa9e4066Sahrens if (!cbp->cb_dependent) { 1467fa9e4066Sahrens if (strcmp(zfs_get_name(zhp), cbp->cb_target) != 0 && 1468b12a1c38Slling zfs_get_type(zhp) == ZFS_TYPE_SNAPSHOT && 1469fa9e4066Sahrens zfs_prop_get_int(zhp, ZFS_PROP_CREATETXG) > 1470fa9e4066Sahrens cbp->cb_create) { 1471fa9e4066Sahrens 1472fa9e4066Sahrens if (cbp->cb_first && !cbp->cb_recurse) { 1473fa9e4066Sahrens (void) fprintf(stderr, gettext("cannot " 1474fa9e4066Sahrens "rollback to '%s': more recent snapshots " 1475fa9e4066Sahrens "exist\n"), 1476fa9e4066Sahrens cbp->cb_target); 1477fa9e4066Sahrens (void) fprintf(stderr, gettext("use '-r' to " 1478fa9e4066Sahrens "force deletion of the following " 1479fa9e4066Sahrens "snapshots:\n")); 1480fa9e4066Sahrens cbp->cb_first = 0; 1481fa9e4066Sahrens cbp->cb_error = 1; 1482fa9e4066Sahrens } 1483fa9e4066Sahrens 1484fa9e4066Sahrens if (cbp->cb_recurse) { 148599653d4eSeschrock cbp->cb_dependent = B_TRUE; 1486fa9e4066Sahrens (void) zfs_iter_dependents(zhp, rollback_check, 1487fa9e4066Sahrens cbp); 148899653d4eSeschrock cbp->cb_dependent = B_FALSE; 1489fa9e4066Sahrens } else { 1490fa9e4066Sahrens (void) fprintf(stderr, "%s\n", 1491fa9e4066Sahrens zfs_get_name(zhp)); 1492fa9e4066Sahrens } 1493fa9e4066Sahrens } 1494fa9e4066Sahrens } else { 1495fa9e4066Sahrens if (cbp->cb_first && cbp->cb_recurse) { 1496fa9e4066Sahrens (void) fprintf(stderr, gettext("cannot rollback to " 1497fa9e4066Sahrens "'%s': clones of previous snapshots exist\n"), 1498fa9e4066Sahrens cbp->cb_target); 1499fa9e4066Sahrens (void) fprintf(stderr, gettext("use '-R' to " 1500fa9e4066Sahrens "force deletion of the following clones and " 1501fa9e4066Sahrens "dependents:\n")); 1502fa9e4066Sahrens cbp->cb_first = 0; 1503fa9e4066Sahrens cbp->cb_error = 1; 1504fa9e4066Sahrens } 1505fa9e4066Sahrens 1506fa9e4066Sahrens (void) fprintf(stderr, "%s\n", zfs_get_name(zhp)); 1507fa9e4066Sahrens } 1508fa9e4066Sahrens 1509fa9e4066Sahrens zfs_close(zhp); 1510fa9e4066Sahrens return (0); 1511fa9e4066Sahrens } 1512fa9e4066Sahrens 1513fa9e4066Sahrens static int 1514fa9e4066Sahrens zfs_do_rollback(int argc, char **argv) 1515fa9e4066Sahrens { 1516fa9e4066Sahrens int ret; 1517fa9e4066Sahrens int c; 1518fa9e4066Sahrens rollback_cbdata_t cb = { 0 }; 1519fa9e4066Sahrens zfs_handle_t *zhp, *snap; 1520fa9e4066Sahrens char parentname[ZFS_MAXNAMELEN]; 1521fa9e4066Sahrens char *delim; 1522b12a1c38Slling int force = 0; 1523fa9e4066Sahrens 1524fa9e4066Sahrens /* check options */ 1525fa9e4066Sahrens while ((c = getopt(argc, argv, "rfR")) != -1) { 1526fa9e4066Sahrens switch (c) { 1527fa9e4066Sahrens case 'f': 1528b12a1c38Slling force = 1; 1529fa9e4066Sahrens break; 1530fa9e4066Sahrens case 'r': 1531fa9e4066Sahrens cb.cb_recurse = 1; 1532fa9e4066Sahrens break; 1533fa9e4066Sahrens case 'R': 1534fa9e4066Sahrens cb.cb_recurse = 1; 1535fa9e4066Sahrens cb.cb_doclones = 1; 1536fa9e4066Sahrens break; 1537fa9e4066Sahrens case '?': 1538fa9e4066Sahrens (void) fprintf(stderr, gettext("invalid option '%c'\n"), 1539fa9e4066Sahrens optopt); 154099653d4eSeschrock usage(B_FALSE); 1541fa9e4066Sahrens } 1542fa9e4066Sahrens } 1543fa9e4066Sahrens 1544fa9e4066Sahrens argc -= optind; 1545fa9e4066Sahrens argv += optind; 1546fa9e4066Sahrens 1547fa9e4066Sahrens /* check number of arguments */ 1548fa9e4066Sahrens if (argc < 1) { 1549fa9e4066Sahrens (void) fprintf(stderr, gettext("missing dataset argument\n")); 155099653d4eSeschrock usage(B_FALSE); 1551fa9e4066Sahrens } 1552fa9e4066Sahrens if (argc > 1) { 1553fa9e4066Sahrens (void) fprintf(stderr, gettext("too many arguments\n")); 155499653d4eSeschrock usage(B_FALSE); 1555fa9e4066Sahrens } 1556fa9e4066Sahrens 1557fa9e4066Sahrens /* open the snapshot */ 155899653d4eSeschrock if ((snap = zfs_open(g_zfs, argv[0], ZFS_TYPE_SNAPSHOT)) == NULL) 1559fa9e4066Sahrens return (1); 1560fa9e4066Sahrens 1561b12a1c38Slling /* open the parent dataset */ 1562b12a1c38Slling (void) strlcpy(parentname, argv[0], sizeof (parentname)); 1563fa9e4066Sahrens verify((delim = strrchr(parentname, '@')) != NULL); 1564fa9e4066Sahrens *delim = '\0'; 156599653d4eSeschrock if ((zhp = zfs_open(g_zfs, parentname, ZFS_TYPE_ANY)) == NULL) { 1566fa9e4066Sahrens zfs_close(snap); 1567fa9e4066Sahrens return (1); 1568fa9e4066Sahrens } 1569fa9e4066Sahrens 1570fa9e4066Sahrens /* 1571fa9e4066Sahrens * Check for more recent snapshots and/or clones based on the presence 1572fa9e4066Sahrens * of '-r' and '-R'. 1573fa9e4066Sahrens */ 1574b12a1c38Slling cb.cb_target = argv[0]; 1575b12a1c38Slling cb.cb_create = zfs_prop_get_int(snap, ZFS_PROP_CREATETXG); 157699653d4eSeschrock cb.cb_first = B_TRUE; 1577fa9e4066Sahrens cb.cb_error = 0; 1578fa9e4066Sahrens (void) zfs_iter_children(zhp, rollback_check, &cb); 1579fa9e4066Sahrens 1580fa9e4066Sahrens if ((ret = cb.cb_error) != 0) 1581fa9e4066Sahrens goto out; 1582fa9e4066Sahrens 1583fa9e4066Sahrens /* 1584b12a1c38Slling * Rollback parent to the given snapshot. 1585fa9e4066Sahrens */ 1586b12a1c38Slling ret = zfs_rollback(zhp, snap, force); 1587fa9e4066Sahrens 1588fa9e4066Sahrens out: 1589fa9e4066Sahrens zfs_close(snap); 1590fa9e4066Sahrens zfs_close(zhp); 1591fa9e4066Sahrens 1592fa9e4066Sahrens if (ret == 0) 1593fa9e4066Sahrens return (0); 1594fa9e4066Sahrens else 1595fa9e4066Sahrens return (1); 1596fa9e4066Sahrens } 1597fa9e4066Sahrens 1598fa9e4066Sahrens /* 1599fa9e4066Sahrens * zfs set property=value { fs | snap | vol } ... 1600fa9e4066Sahrens * 1601fa9e4066Sahrens * Sets the given property for all datasets specified on the command line. 1602fa9e4066Sahrens */ 1603fa9e4066Sahrens typedef struct set_cbdata { 1604fa9e4066Sahrens char *cb_propname; 1605fa9e4066Sahrens char *cb_value; 1606fa9e4066Sahrens zfs_prop_t cb_prop; 1607fa9e4066Sahrens } set_cbdata_t; 1608fa9e4066Sahrens 1609fa9e4066Sahrens static int 1610fa9e4066Sahrens set_callback(zfs_handle_t *zhp, void *data) 1611fa9e4066Sahrens { 1612fa9e4066Sahrens set_cbdata_t *cbp = data; 1613fa9e4066Sahrens int ret = 1; 1614fa9e4066Sahrens 1615fa9e4066Sahrens /* don't allow setting of properties for snapshots */ 1616fa9e4066Sahrens if (zfs_get_type(zhp) == ZFS_TYPE_SNAPSHOT) { 1617fa9e4066Sahrens (void) fprintf(stderr, gettext("cannot set %s property for " 1618fa9e4066Sahrens "'%s': snapshot properties cannot be modified\n"), 1619fa9e4066Sahrens cbp->cb_propname, zfs_get_name(zhp)); 1620fa9e4066Sahrens return (1); 1621fa9e4066Sahrens } 1622fa9e4066Sahrens 1623fa9e4066Sahrens /* 16245c5460e9Seschrock * If we're changing the volsize, make sure the value is appropriate, 16255c5460e9Seschrock * and set the reservation if this is a non-sparse volume. 1626fa9e4066Sahrens */ 1627fa9e4066Sahrens if (cbp->cb_prop == ZFS_PROP_VOLSIZE && 16285c5460e9Seschrock zfs_get_type(zhp) == ZFS_TYPE_VOLUME) { 1629fa9e4066Sahrens uint64_t volsize = zfs_prop_get_int(zhp, ZFS_PROP_VOLSIZE); 1630fa9e4066Sahrens uint64_t avail = zfs_prop_get_int(zhp, ZFS_PROP_AVAILABLE); 16315c5460e9Seschrock uint64_t reservation = zfs_prop_get_int(zhp, 16325c5460e9Seschrock ZFS_PROP_RESERVATION); 16335c5460e9Seschrock uint64_t blocksize = zfs_prop_get_int(zhp, 16345c5460e9Seschrock ZFS_PROP_VOLBLOCKSIZE); 1635fa9e4066Sahrens uint64_t value; 1636fa9e4066Sahrens 1637fa9e4066Sahrens verify(zfs_nicestrtonum(cbp->cb_value, &value) == 0); 1638fa9e4066Sahrens 16395c5460e9Seschrock if (value % blocksize != 0) { 16405c5460e9Seschrock char buf[64]; 16415c5460e9Seschrock 16425c5460e9Seschrock zfs_nicenum(blocksize, buf, sizeof (buf)); 16435c5460e9Seschrock (void) fprintf(stderr, gettext("cannot set %s for " 16445c5460e9Seschrock "'%s': must be a multiple of volume block size " 16455c5460e9Seschrock "(%s)\n"), cbp->cb_propname, zfs_get_name(zhp), 16465c5460e9Seschrock buf); 16475c5460e9Seschrock return (1); 16485c5460e9Seschrock } 16495c5460e9Seschrock 16505c5460e9Seschrock if (value == 0) { 16515c5460e9Seschrock (void) fprintf(stderr, gettext("cannot set %s for " 16525c5460e9Seschrock "'%s': cannot be zero\n"), cbp->cb_propname, 16535c5460e9Seschrock zfs_get_name(zhp)); 16545c5460e9Seschrock return (1); 16555c5460e9Seschrock } 16565c5460e9Seschrock 16575c5460e9Seschrock if (volsize == reservation) { 1658fa9e4066Sahrens if (value > volsize && (value - volsize) > avail) { 1659fa9e4066Sahrens (void) fprintf(stderr, gettext("cannot set " 1660fa9e4066Sahrens "%s property for '%s': volume size exceeds " 1661fa9e4066Sahrens "amount of available space\n"), 1662fa9e4066Sahrens cbp->cb_propname, zfs_get_name(zhp)); 1663fa9e4066Sahrens return (1); 1664fa9e4066Sahrens } 1665fa9e4066Sahrens 1666fa9e4066Sahrens if (zfs_prop_set(zhp, ZFS_PROP_RESERVATION, 1667fa9e4066Sahrens cbp->cb_value) != 0) { 1668fa9e4066Sahrens (void) fprintf(stderr, gettext("volsize and " 1669fa9e4066Sahrens "reservation must remain equal\n")); 1670fa9e4066Sahrens return (1); 1671fa9e4066Sahrens } 1672fa9e4066Sahrens } 16735c5460e9Seschrock } 1674fa9e4066Sahrens 1675fa9e4066Sahrens /* 1676fa9e4066Sahrens * Do not allow the reservation to be set above the volume size. We do 1677fa9e4066Sahrens * this here instead of inside libzfs because libzfs violates this rule 1678fa9e4066Sahrens * internally. 1679fa9e4066Sahrens */ 1680fa9e4066Sahrens if (cbp->cb_prop == ZFS_PROP_RESERVATION && 1681fa9e4066Sahrens zfs_get_type(zhp) == ZFS_TYPE_VOLUME) { 1682fa9e4066Sahrens uint64_t value; 1683fa9e4066Sahrens uint64_t volsize; 1684fa9e4066Sahrens 1685fa9e4066Sahrens volsize = zfs_prop_get_int(zhp, ZFS_PROP_VOLSIZE); 1686fa9e4066Sahrens if (strcmp(cbp->cb_value, "none") == 0) 1687fa9e4066Sahrens value = 0; 1688fa9e4066Sahrens else 1689fa9e4066Sahrens verify(zfs_nicestrtonum(cbp->cb_value, &value) == 0); 1690fa9e4066Sahrens 1691fa9e4066Sahrens if (value > volsize) { 1692fa9e4066Sahrens (void) fprintf(stderr, gettext("cannot set %s " 1693fa9e4066Sahrens "for '%s': size is greater than current " 1694fa9e4066Sahrens "volume size\n"), cbp->cb_propname, 1695fa9e4066Sahrens zfs_get_name(zhp)); 1696fa9e4066Sahrens return (-1); 1697fa9e4066Sahrens } 1698fa9e4066Sahrens } 1699fa9e4066Sahrens 1700efc555ebSnd150628 if (zfs_prop_set(zhp, cbp->cb_prop, cbp->cb_value) != 0) { 1701efc555ebSnd150628 switch (libzfs_errno(g_zfs)) { 1702efc555ebSnd150628 case EZFS_MOUNTFAILED: 1703efc555ebSnd150628 (void) fprintf(stderr, gettext("property may be set " 1704efc555ebSnd150628 "but unable to remount filesystem\n")); 1705efc555ebSnd150628 break; 1706efc555ebSnd150628 case EZFS_SHAREFAILED: 1707efc555ebSnd150628 (void) fprintf(stderr, gettext("property may be set " 1708efc555ebSnd150628 "but unable to reshare filesystem\n")); 1709efc555ebSnd150628 break; 1710efc555ebSnd150628 } 1711fa9e4066Sahrens return (1); 1712efc555ebSnd150628 } 1713fa9e4066Sahrens ret = 0; 1714fa9e4066Sahrens error: 1715fa9e4066Sahrens return (ret); 1716fa9e4066Sahrens } 1717fa9e4066Sahrens 1718fa9e4066Sahrens static int 1719fa9e4066Sahrens zfs_do_set(int argc, char **argv) 1720fa9e4066Sahrens { 1721fa9e4066Sahrens set_cbdata_t cb; 1722fa9e4066Sahrens 1723fa9e4066Sahrens /* check for options */ 1724fa9e4066Sahrens if (argc > 1 && argv[1][0] == '-') { 1725fa9e4066Sahrens (void) fprintf(stderr, gettext("invalid option '%c'\n"), 1726fa9e4066Sahrens argv[1][1]); 172799653d4eSeschrock usage(B_FALSE); 1728fa9e4066Sahrens } 1729fa9e4066Sahrens 1730fa9e4066Sahrens /* check number of arguments */ 1731fa9e4066Sahrens if (argc < 2) { 1732fa9e4066Sahrens (void) fprintf(stderr, gettext("missing property=value " 1733fa9e4066Sahrens "argument\n")); 173499653d4eSeschrock usage(B_FALSE); 1735fa9e4066Sahrens } 1736fa9e4066Sahrens if (argc < 3) { 1737fa9e4066Sahrens (void) fprintf(stderr, gettext("missing dataset name\n")); 173899653d4eSeschrock usage(B_FALSE); 1739fa9e4066Sahrens } 1740fa9e4066Sahrens 1741fa9e4066Sahrens /* validate property=value argument */ 1742fa9e4066Sahrens cb.cb_propname = argv[1]; 1743fa9e4066Sahrens if ((cb.cb_value = strchr(cb.cb_propname, '=')) == NULL) { 1744fa9e4066Sahrens (void) fprintf(stderr, gettext("missing value in " 1745fa9e4066Sahrens "property=value argument\n")); 174699653d4eSeschrock usage(B_FALSE); 1747fa9e4066Sahrens } 1748fa9e4066Sahrens 1749fa9e4066Sahrens *cb.cb_value = '\0'; 1750fa9e4066Sahrens cb.cb_value++; 1751fa9e4066Sahrens 1752fa9e4066Sahrens if (*cb.cb_propname == '\0') { 1753fa9e4066Sahrens (void) fprintf(stderr, 1754fa9e4066Sahrens gettext("missing property in property=value argument\n")); 175599653d4eSeschrock usage(B_FALSE); 1756fa9e4066Sahrens } 1757fa9e4066Sahrens if (*cb.cb_value == '\0') { 1758fa9e4066Sahrens (void) fprintf(stderr, 1759fa9e4066Sahrens gettext("missing value in property=value argument\n")); 176099653d4eSeschrock usage(B_FALSE); 1761fa9e4066Sahrens } 1762fa9e4066Sahrens 1763fa9e4066Sahrens /* get the property type */ 1764fa9e4066Sahrens if ((cb.cb_prop = zfs_name_to_prop(cb.cb_propname)) == 1765fa9e4066Sahrens ZFS_PROP_INVAL) { 1766fa9e4066Sahrens (void) fprintf(stderr, 1767fa9e4066Sahrens gettext("invalid property '%s'\n"), cb.cb_propname); 176899653d4eSeschrock usage(B_FALSE); 1769fa9e4066Sahrens } 1770fa9e4066Sahrens 1771fa9e4066Sahrens /* 1772fa9e4066Sahrens * Validate that the value is appropriate for this property. We do this 1773fa9e4066Sahrens * once now so we don't generate multiple errors each time we try to 1774fa9e4066Sahrens * apply it to a dataset. 1775fa9e4066Sahrens */ 177699653d4eSeschrock if (zfs_prop_validate(g_zfs, cb.cb_prop, cb.cb_value, NULL) != 0) 1777fa9e4066Sahrens return (1); 1778fa9e4066Sahrens 177999653d4eSeschrock return (zfs_for_each(argc - 2, argv + 2, B_FALSE, 1780fa9e4066Sahrens ZFS_TYPE_ANY, set_callback, &cb)); 1781fa9e4066Sahrens } 1782fa9e4066Sahrens 1783fa9e4066Sahrens /* 17841d452cf5Sahrens * zfs snapshot [-r] <fs@snap> 1785fa9e4066Sahrens * 1786fa9e4066Sahrens * Creates a snapshot with the given name. While functionally equivalent to 1787fa9e4066Sahrens * 'zfs create', it is a separate command to diffferentiate intent. 1788fa9e4066Sahrens */ 1789fa9e4066Sahrens static int 1790fa9e4066Sahrens zfs_do_snapshot(int argc, char **argv) 1791fa9e4066Sahrens { 17921d452cf5Sahrens int recursive = B_FALSE; 17931d452cf5Sahrens int ret; 17941d452cf5Sahrens char c; 17951d452cf5Sahrens 1796fa9e4066Sahrens /* check options */ 17971d452cf5Sahrens while ((c = getopt(argc, argv, ":r")) != -1) { 17981d452cf5Sahrens switch (c) { 17991d452cf5Sahrens case 'r': 18001d452cf5Sahrens recursive = B_TRUE; 18011d452cf5Sahrens break; 18021d452cf5Sahrens case '?': 1803fa9e4066Sahrens (void) fprintf(stderr, gettext("invalid option '%c'\n"), 18041d452cf5Sahrens optopt); 180599653d4eSeschrock usage(B_FALSE); 1806fa9e4066Sahrens } 18071d452cf5Sahrens } 18081d452cf5Sahrens 18091d452cf5Sahrens argc -= optind; 18101d452cf5Sahrens argv += optind; 1811fa9e4066Sahrens 1812fa9e4066Sahrens /* check number of arguments */ 18131d452cf5Sahrens if (argc < 1) { 1814fa9e4066Sahrens (void) fprintf(stderr, gettext("missing snapshot argument\n")); 181599653d4eSeschrock usage(B_FALSE); 1816fa9e4066Sahrens } 18171d452cf5Sahrens if (argc > 1) { 1818fa9e4066Sahrens (void) fprintf(stderr, gettext("too many arguments\n")); 181999653d4eSeschrock usage(B_FALSE); 1820fa9e4066Sahrens } 1821fa9e4066Sahrens 18221d452cf5Sahrens ret = zfs_snapshot(g_zfs, argv[0], recursive); 18231d452cf5Sahrens if (ret && recursive) 18241d452cf5Sahrens (void) fprintf(stderr, gettext("no snapshots were created\n")); 18251d452cf5Sahrens return (ret != 0); 18261d452cf5Sahrens 1827fa9e4066Sahrens } 1828fa9e4066Sahrens 1829fa9e4066Sahrens /* 1830f2a3c691Sahrens * zfs send [-i <fs@snap>] <fs@snap> 1831fa9e4066Sahrens * 1832fa9e4066Sahrens * Send a backup stream to stdout. 1833fa9e4066Sahrens */ 1834fa9e4066Sahrens static int 1835f2a3c691Sahrens zfs_do_send(int argc, char **argv) 1836fa9e4066Sahrens { 1837fa9e4066Sahrens char *fromname = NULL; 1838fa9e4066Sahrens zfs_handle_t *zhp_from = NULL, *zhp_to; 1839fa9e4066Sahrens int c, err; 1840fa9e4066Sahrens 1841fa9e4066Sahrens /* check options */ 1842fa9e4066Sahrens while ((c = getopt(argc, argv, ":i:")) != -1) { 1843fa9e4066Sahrens switch (c) { 1844fa9e4066Sahrens case 'i': 1845fa9e4066Sahrens fromname = optarg; 1846fa9e4066Sahrens break; 1847fa9e4066Sahrens case ':': 1848fa9e4066Sahrens (void) fprintf(stderr, gettext("missing argument for " 1849fa9e4066Sahrens "'%c' option\n"), optopt); 185099653d4eSeschrock usage(B_FALSE); 1851fa9e4066Sahrens break; 1852fa9e4066Sahrens case '?': 1853fa9e4066Sahrens (void) fprintf(stderr, gettext("invalid option '%c'\n"), 1854fa9e4066Sahrens optopt); 185599653d4eSeschrock usage(B_FALSE); 1856fa9e4066Sahrens } 1857fa9e4066Sahrens } 1858fa9e4066Sahrens 1859fa9e4066Sahrens argc -= optind; 1860fa9e4066Sahrens argv += optind; 1861fa9e4066Sahrens 1862fa9e4066Sahrens /* check number of arguments */ 1863fa9e4066Sahrens if (argc < 1) { 1864fa9e4066Sahrens (void) fprintf(stderr, gettext("missing snapshot argument\n")); 186599653d4eSeschrock usage(B_FALSE); 1866fa9e4066Sahrens } 1867fa9e4066Sahrens if (argc > 1) { 1868fa9e4066Sahrens (void) fprintf(stderr, gettext("too many arguments\n")); 186999653d4eSeschrock usage(B_FALSE); 1870fa9e4066Sahrens } 1871fa9e4066Sahrens 1872fa9e4066Sahrens if (isatty(STDOUT_FILENO)) { 1873fa9e4066Sahrens (void) fprintf(stderr, 1874f2a3c691Sahrens gettext("Error: Stream can not be written " 1875fa9e4066Sahrens "to a terminal.\n" 1876fa9e4066Sahrens "You must redirect standard output.\n")); 1877fa9e4066Sahrens return (1); 1878fa9e4066Sahrens } 1879fa9e4066Sahrens 1880fa9e4066Sahrens if (fromname) { 188199653d4eSeschrock if ((zhp_from = zfs_open(g_zfs, fromname, 188299653d4eSeschrock ZFS_TYPE_SNAPSHOT)) == NULL) 1883fa9e4066Sahrens return (1); 1884fa9e4066Sahrens } 188599653d4eSeschrock if ((zhp_to = zfs_open(g_zfs, argv[0], ZFS_TYPE_SNAPSHOT)) == NULL) 1886fa9e4066Sahrens return (1); 1887fa9e4066Sahrens 1888f2a3c691Sahrens err = zfs_send(zhp_to, zhp_from); 1889fa9e4066Sahrens 1890fa9e4066Sahrens if (zhp_from) 1891fa9e4066Sahrens zfs_close(zhp_from); 1892fa9e4066Sahrens zfs_close(zhp_to); 1893fa9e4066Sahrens 1894fa9e4066Sahrens return (err != 0); 1895fa9e4066Sahrens } 1896fa9e4066Sahrens 1897fa9e4066Sahrens /* 1898f2a3c691Sahrens * zfs receive <fs@snap> 1899fa9e4066Sahrens * 1900fa9e4066Sahrens * Restore a backup stream from stdin. 1901fa9e4066Sahrens */ 1902fa9e4066Sahrens static int 1903f2a3c691Sahrens zfs_do_receive(int argc, char **argv) 1904fa9e4066Sahrens { 1905fa9e4066Sahrens int c, err; 190699653d4eSeschrock boolean_t isprefix = B_FALSE; 190799653d4eSeschrock boolean_t dryrun = B_FALSE; 190899653d4eSeschrock boolean_t verbose = B_FALSE; 1909fa9e4066Sahrens 1910fa9e4066Sahrens /* check options */ 1911fa9e4066Sahrens while ((c = getopt(argc, argv, ":dnv")) != -1) { 1912fa9e4066Sahrens switch (c) { 1913fa9e4066Sahrens case 'd': 191499653d4eSeschrock isprefix = B_TRUE; 1915fa9e4066Sahrens break; 1916fa9e4066Sahrens case 'n': 191799653d4eSeschrock dryrun = B_TRUE; 1918fa9e4066Sahrens break; 1919fa9e4066Sahrens case 'v': 192099653d4eSeschrock verbose = B_TRUE; 1921fa9e4066Sahrens break; 1922fa9e4066Sahrens case ':': 1923fa9e4066Sahrens (void) fprintf(stderr, gettext("missing argument for " 1924fa9e4066Sahrens "'%c' option\n"), optopt); 192599653d4eSeschrock usage(B_FALSE); 1926fa9e4066Sahrens break; 1927fa9e4066Sahrens case '?': 1928fa9e4066Sahrens (void) fprintf(stderr, gettext("invalid option '%c'\n"), 1929fa9e4066Sahrens optopt); 193099653d4eSeschrock usage(B_FALSE); 1931fa9e4066Sahrens } 1932fa9e4066Sahrens } 1933fa9e4066Sahrens 1934fa9e4066Sahrens argc -= optind; 1935fa9e4066Sahrens argv += optind; 1936fa9e4066Sahrens 1937fa9e4066Sahrens /* check number of arguments */ 1938fa9e4066Sahrens if (argc < 1) { 1939fa9e4066Sahrens (void) fprintf(stderr, gettext("missing snapshot argument\n")); 194099653d4eSeschrock usage(B_FALSE); 1941fa9e4066Sahrens } 1942fa9e4066Sahrens if (argc > 1) { 1943fa9e4066Sahrens (void) fprintf(stderr, gettext("too many arguments\n")); 194499653d4eSeschrock usage(B_FALSE); 1945fa9e4066Sahrens } 1946fa9e4066Sahrens 1947fa9e4066Sahrens if (isatty(STDIN_FILENO)) { 1948fa9e4066Sahrens (void) fprintf(stderr, 1949fa9e4066Sahrens gettext("Error: Backup stream can not be read " 1950fa9e4066Sahrens "from a terminal.\n" 1951fa9e4066Sahrens "You must redirect standard input.\n")); 1952fa9e4066Sahrens return (1); 1953fa9e4066Sahrens } 1954fa9e4066Sahrens 195599653d4eSeschrock err = zfs_receive(g_zfs, argv[0], isprefix, verbose, dryrun); 1956fa9e4066Sahrens return (err != 0); 1957fa9e4066Sahrens } 1958fa9e4066Sahrens 19597f7322feSeschrock typedef struct get_all_cbdata { 19607f7322feSeschrock zfs_handle_t **cb_handles; 19617f7322feSeschrock size_t cb_alloc; 19627f7322feSeschrock size_t cb_used; 19637f7322feSeschrock } get_all_cbdata_t; 19647f7322feSeschrock 19657f7322feSeschrock static int 19667f7322feSeschrock get_one_filesystem(zfs_handle_t *zhp, void *data) 19677f7322feSeschrock { 19687f7322feSeschrock get_all_cbdata_t *cbp = data; 19697f7322feSeschrock 19707f7322feSeschrock /* 19717f7322feSeschrock * Skip any zvols 19727f7322feSeschrock */ 19737f7322feSeschrock if (zfs_get_type(zhp) != ZFS_TYPE_FILESYSTEM) { 19747f7322feSeschrock zfs_close(zhp); 19757f7322feSeschrock return (0); 19767f7322feSeschrock } 19777f7322feSeschrock 19787f7322feSeschrock if (cbp->cb_alloc == cbp->cb_used) { 19797f7322feSeschrock zfs_handle_t **handles; 19807f7322feSeschrock 19817f7322feSeschrock if (cbp->cb_alloc == 0) 19827f7322feSeschrock cbp->cb_alloc = 64; 19837f7322feSeschrock else 19847f7322feSeschrock cbp->cb_alloc *= 2; 19857f7322feSeschrock 19867f7322feSeschrock handles = safe_malloc(cbp->cb_alloc * sizeof (void *)); 19877f7322feSeschrock 19887f7322feSeschrock if (cbp->cb_handles) { 19897f7322feSeschrock bcopy(cbp->cb_handles, handles, 19907f7322feSeschrock cbp->cb_used * sizeof (void *)); 19917f7322feSeschrock free(cbp->cb_handles); 19927f7322feSeschrock } 19937f7322feSeschrock 19947f7322feSeschrock cbp->cb_handles = handles; 19957f7322feSeschrock } 19967f7322feSeschrock 19977f7322feSeschrock cbp->cb_handles[cbp->cb_used++] = zhp; 19987f7322feSeschrock 19997f7322feSeschrock return (zfs_iter_filesystems(zhp, get_one_filesystem, data)); 20007f7322feSeschrock } 20017f7322feSeschrock 20027f7322feSeschrock static void 20037f7322feSeschrock get_all_filesystems(zfs_handle_t ***fslist, size_t *count) 20047f7322feSeschrock { 20057f7322feSeschrock get_all_cbdata_t cb = { 0 }; 20067f7322feSeschrock 200799653d4eSeschrock (void) zfs_iter_root(g_zfs, get_one_filesystem, &cb); 20087f7322feSeschrock 20097f7322feSeschrock *fslist = cb.cb_handles; 20107f7322feSeschrock *count = cb.cb_used; 20117f7322feSeschrock } 20127f7322feSeschrock 20137f7322feSeschrock static int 20147f7322feSeschrock mountpoint_compare(const void *a, const void *b) 20157f7322feSeschrock { 20167f7322feSeschrock zfs_handle_t **za = (zfs_handle_t **)a; 20177f7322feSeschrock zfs_handle_t **zb = (zfs_handle_t **)b; 20187f7322feSeschrock char mounta[MAXPATHLEN]; 20197f7322feSeschrock char mountb[MAXPATHLEN]; 20207f7322feSeschrock 20217f7322feSeschrock verify(zfs_prop_get(*za, ZFS_PROP_MOUNTPOINT, mounta, 202299653d4eSeschrock sizeof (mounta), NULL, NULL, 0, B_FALSE) == 0); 20237f7322feSeschrock verify(zfs_prop_get(*zb, ZFS_PROP_MOUNTPOINT, mountb, 202499653d4eSeschrock sizeof (mountb), NULL, NULL, 0, B_FALSE) == 0); 20257f7322feSeschrock 20267f7322feSeschrock return (strcmp(mounta, mountb)); 20277f7322feSeschrock } 2028fa9e4066Sahrens 2029fa9e4066Sahrens /* 2030fa9e4066Sahrens * Generic callback for sharing or mounting filesystems. Because the code is so 2031fa9e4066Sahrens * similar, we have a common function with an extra parameter to determine which 2032fa9e4066Sahrens * mode we are using. 2033fa9e4066Sahrens */ 2034fa9e4066Sahrens #define OP_SHARE 0x1 2035fa9e4066Sahrens #define OP_MOUNT 0x2 2036fa9e4066Sahrens 2037fa9e4066Sahrens typedef struct share_mount_cbdata { 2038fa9e4066Sahrens int cb_type; 2039fa9e4066Sahrens int cb_explicit; 2040fa9e4066Sahrens int cb_flags; 2041fa9e4066Sahrens const char *cb_options; 2042fa9e4066Sahrens } share_mount_cbdata_t; 2043fa9e4066Sahrens 2044fa9e4066Sahrens /* 2045fa9e4066Sahrens * Share or mount the filesystem. 2046fa9e4066Sahrens */ 2047fa9e4066Sahrens static int 2048fa9e4066Sahrens share_mount_callback(zfs_handle_t *zhp, void *data) 2049fa9e4066Sahrens { 2050fa9e4066Sahrens char mountpoint[ZFS_MAXPROPLEN]; 2051fa9e4066Sahrens char shareopts[ZFS_MAXPROPLEN]; 2052fa9e4066Sahrens share_mount_cbdata_t *cbp = data; 2053fa9e4066Sahrens const char *cmdname = cbp->cb_type == OP_SHARE ? "share" : "mount"; 2054fa9e4066Sahrens struct mnttab mnt; 2055fa9e4066Sahrens uint64_t zoned; 2056fa9e4066Sahrens 2057fa9e4066Sahrens if (cbp->cb_options == NULL) 2058fa9e4066Sahrens mnt.mnt_mntopts = ""; 2059fa9e4066Sahrens else 2060fa9e4066Sahrens mnt.mnt_mntopts = (char *)cbp->cb_options; 2061fa9e4066Sahrens 2062fa9e4066Sahrens /* 2063fa9e4066Sahrens * Check to make sure we can mount/share this dataset. If we are in the 2064fa9e4066Sahrens * global zone and the filesystem is exported to a local zone, or if we 2065fa9e4066Sahrens * are in a local zone and the filesystem is not exported, then it is an 2066fa9e4066Sahrens * error. 2067fa9e4066Sahrens */ 2068fa9e4066Sahrens zoned = zfs_prop_get_int(zhp, ZFS_PROP_ZONED); 2069fa9e4066Sahrens 2070fa9e4066Sahrens if (zoned && getzoneid() == GLOBAL_ZONEID) { 2071fa9e4066Sahrens if (!cbp->cb_explicit) 2072fa9e4066Sahrens return (0); 2073fa9e4066Sahrens 2074fa9e4066Sahrens (void) fprintf(stderr, gettext("cannot %s '%s': dataset is " 2075fa9e4066Sahrens "exported to a local zone\n"), cmdname, zfs_get_name(zhp)); 2076fa9e4066Sahrens return (1); 2077fa9e4066Sahrens 2078fa9e4066Sahrens } else if (!zoned && getzoneid() != GLOBAL_ZONEID) { 2079fa9e4066Sahrens if (!cbp->cb_explicit) 2080fa9e4066Sahrens return (0); 2081fa9e4066Sahrens 2082fa9e4066Sahrens (void) fprintf(stderr, gettext("cannot %s '%s': permission " 2083fa9e4066Sahrens "denied\n"), cmdname, zfs_get_name(zhp)); 2084fa9e4066Sahrens return (1); 2085fa9e4066Sahrens } 2086fa9e4066Sahrens 2087fa9e4066Sahrens /* 2088fa9e4066Sahrens * Inore any filesystems which don't apply to us. This includes those 2089fa9e4066Sahrens * with a legacy mountpoint, or those with legacy share options. 2090fa9e4066Sahrens */ 2091fa9e4066Sahrens verify(zfs_prop_get(zhp, ZFS_PROP_MOUNTPOINT, mountpoint, 209299653d4eSeschrock sizeof (mountpoint), NULL, NULL, 0, B_FALSE) == 0); 2093fa9e4066Sahrens verify(zfs_prop_get(zhp, ZFS_PROP_SHARENFS, shareopts, 209499653d4eSeschrock sizeof (shareopts), NULL, NULL, 0, B_FALSE) == 0); 2095fa9e4066Sahrens 2096fa9e4066Sahrens if (cbp->cb_type == OP_SHARE) { 2097fa9e4066Sahrens if (strcmp(shareopts, "off") == 0) { 2098fa9e4066Sahrens if (!cbp->cb_explicit) 2099fa9e4066Sahrens return (0); 2100fa9e4066Sahrens 2101fa9e4066Sahrens (void) fprintf(stderr, gettext("cannot share '%s': " 2102fa9e4066Sahrens "legacy share\n"), zfs_get_name(zhp)); 2103fa9e4066Sahrens (void) fprintf(stderr, gettext("use share(1M) to " 2104fa9e4066Sahrens "share this filesystem\n")); 2105fa9e4066Sahrens return (1); 2106fa9e4066Sahrens } 2107fa9e4066Sahrens } 2108fa9e4066Sahrens 2109fa9e4066Sahrens /* 2110fa9e4066Sahrens * We cannot share or mount legacy filesystems. If the shareopts is 2111fa9e4066Sahrens * non-legacy but the mountpoint is legacy, we treat it as a legacy 2112fa9e4066Sahrens * share. 2113fa9e4066Sahrens */ 2114fa9e4066Sahrens if (strcmp(mountpoint, "legacy") == 0) { 2115fa9e4066Sahrens if (!cbp->cb_explicit) 2116fa9e4066Sahrens return (0); 2117fa9e4066Sahrens 2118fa9e4066Sahrens (void) fprintf(stderr, gettext("cannot %s '%s': " 2119fa9e4066Sahrens "legacy mountpoint\n"), cmdname, zfs_get_name(zhp)); 2120fa9e4066Sahrens (void) fprintf(stderr, gettext("use %s to " 2121fa9e4066Sahrens "%s this filesystem\n"), cbp->cb_type == OP_SHARE ? 2122fa9e4066Sahrens "share(1M)" : "mount(1M)", cmdname); 2123fa9e4066Sahrens return (1); 2124fa9e4066Sahrens } 2125fa9e4066Sahrens 2126fa9e4066Sahrens if (strcmp(mountpoint, "none") == 0) { 2127fa9e4066Sahrens if (!cbp->cb_explicit) 2128fa9e4066Sahrens return (0); 2129fa9e4066Sahrens 2130fa9e4066Sahrens (void) fprintf(stderr, gettext("cannot %s '%s': no " 2131fa9e4066Sahrens "mountpoint set\n"), cmdname, zfs_get_name(zhp)); 2132fa9e4066Sahrens return (1); 2133fa9e4066Sahrens } 2134fa9e4066Sahrens 2135fa9e4066Sahrens /* 2136fa9e4066Sahrens * At this point, we have verified that the mountpoint and/or shareopts 2137fa9e4066Sahrens * are appropriate for auto management. Determine if the filesystem is 2138fa9e4066Sahrens * currently mounted or shared, and abort if this is an explicit 2139fa9e4066Sahrens * request. 2140fa9e4066Sahrens */ 2141fa9e4066Sahrens switch (cbp->cb_type) { 2142fa9e4066Sahrens case OP_SHARE: 2143fa9e4066Sahrens if (zfs_is_shared(zhp, NULL)) { 2144fa9e4066Sahrens if (cbp->cb_explicit) { 2145fa9e4066Sahrens (void) fprintf(stderr, gettext("cannot share " 2146fa9e4066Sahrens "'%s': filesystem already shared\n"), 2147fa9e4066Sahrens zfs_get_name(zhp)); 2148fa9e4066Sahrens return (1); 2149fa9e4066Sahrens } else { 2150fa9e4066Sahrens return (0); 2151fa9e4066Sahrens } 2152fa9e4066Sahrens } 2153fa9e4066Sahrens break; 2154fa9e4066Sahrens 2155fa9e4066Sahrens case OP_MOUNT: 2156fa9e4066Sahrens if (!hasmntopt(&mnt, MNTOPT_REMOUNT) && 2157fa9e4066Sahrens zfs_is_mounted(zhp, NULL)) { 2158fa9e4066Sahrens if (cbp->cb_explicit) { 2159fa9e4066Sahrens (void) fprintf(stderr, gettext("cannot mount " 2160fa9e4066Sahrens "'%s': filesystem already mounted\n"), 2161fa9e4066Sahrens zfs_get_name(zhp)); 2162fa9e4066Sahrens return (1); 2163fa9e4066Sahrens } else { 2164fa9e4066Sahrens return (0); 2165fa9e4066Sahrens } 2166fa9e4066Sahrens } 2167fa9e4066Sahrens break; 2168fa9e4066Sahrens } 2169fa9e4066Sahrens 2170fa9e4066Sahrens /* 2171fa9e4066Sahrens * Mount and optionally share the filesystem. 2172fa9e4066Sahrens */ 2173fa9e4066Sahrens switch (cbp->cb_type) { 2174fa9e4066Sahrens case OP_SHARE: 2175fa9e4066Sahrens { 2176fa9e4066Sahrens if (!zfs_is_mounted(zhp, NULL) && 2177fa9e4066Sahrens zfs_mount(zhp, NULL, 0) != 0) 2178fa9e4066Sahrens return (1); 2179fa9e4066Sahrens 2180fa9e4066Sahrens if (zfs_share(zhp) != 0) 2181fa9e4066Sahrens return (1); 2182fa9e4066Sahrens } 2183fa9e4066Sahrens break; 2184fa9e4066Sahrens 2185fa9e4066Sahrens case OP_MOUNT: 2186fa9e4066Sahrens if (zfs_mount(zhp, cbp->cb_options, cbp->cb_flags) != 0) 2187fa9e4066Sahrens return (1); 2188fa9e4066Sahrens break; 2189fa9e4066Sahrens } 2190fa9e4066Sahrens 2191fa9e4066Sahrens return (0); 2192fa9e4066Sahrens } 2193fa9e4066Sahrens 2194fa9e4066Sahrens static int 2195fa9e4066Sahrens share_or_mount(int type, int argc, char **argv) 2196fa9e4066Sahrens { 2197fa9e4066Sahrens int do_all = 0; 2198fa9e4066Sahrens int c, ret; 2199fa9e4066Sahrens share_mount_cbdata_t cb = { 0 }; 2200fa9e4066Sahrens 2201fa9e4066Sahrens cb.cb_type = type; 2202fa9e4066Sahrens 2203fa9e4066Sahrens /* check options */ 2204fa9e4066Sahrens while ((c = getopt(argc, argv, type == OP_MOUNT ? ":ao:O" : "a")) 2205fa9e4066Sahrens != -1) { 2206fa9e4066Sahrens switch (c) { 2207fa9e4066Sahrens case 'a': 2208fa9e4066Sahrens do_all = 1; 2209fa9e4066Sahrens break; 2210fa9e4066Sahrens case 'o': 2211fa9e4066Sahrens cb.cb_options = optarg; 2212fa9e4066Sahrens break; 2213fa9e4066Sahrens case 'O': 2214fa9e4066Sahrens cb.cb_flags |= MS_OVERLAY; 2215fa9e4066Sahrens break; 2216fa9e4066Sahrens case ':': 2217fa9e4066Sahrens (void) fprintf(stderr, gettext("missing argument for " 2218fa9e4066Sahrens "'%c' option\n"), optopt); 221999653d4eSeschrock usage(B_FALSE); 2220fa9e4066Sahrens break; 2221fa9e4066Sahrens case '?': 2222fa9e4066Sahrens (void) fprintf(stderr, gettext("invalid option '%c'\n"), 2223fa9e4066Sahrens optopt); 222499653d4eSeschrock usage(B_FALSE); 2225fa9e4066Sahrens } 2226fa9e4066Sahrens } 2227fa9e4066Sahrens 2228fa9e4066Sahrens argc -= optind; 2229fa9e4066Sahrens argv += optind; 2230fa9e4066Sahrens 2231fa9e4066Sahrens /* check number of arguments */ 2232fa9e4066Sahrens if (do_all) { 22337f7322feSeschrock zfs_handle_t **fslist = NULL; 22347f7322feSeschrock size_t i, count = 0; 22357f7322feSeschrock 2236fa9e4066Sahrens if (argc != 0) { 2237fa9e4066Sahrens (void) fprintf(stderr, gettext("too many arguments\n")); 223899653d4eSeschrock usage(B_FALSE); 2239fa9e4066Sahrens } 2240fa9e4066Sahrens 22417f7322feSeschrock get_all_filesystems(&fslist, &count); 22427f7322feSeschrock 22437f7322feSeschrock if (count == 0) 22447f7322feSeschrock return (0); 22457f7322feSeschrock 22467f7322feSeschrock qsort(fslist, count, sizeof (void *), mountpoint_compare); 22477f7322feSeschrock 22487f7322feSeschrock for (i = 0; i < count; i++) { 2249*55b04f29Slling if (share_mount_callback(fslist[i], &cb) != 0) 2250*55b04f29Slling ret = 1; 22517f7322feSeschrock } 22527f7322feSeschrock 22537f7322feSeschrock for (i = 0; i < count; i++) 22547f7322feSeschrock zfs_close(fslist[i]); 22557f7322feSeschrock 22567f7322feSeschrock free(fslist); 2257fa9e4066Sahrens } else if (argc == 0) { 2258fa9e4066Sahrens struct mnttab entry; 2259fa9e4066Sahrens 2260fa9e4066Sahrens if (type == OP_SHARE) { 2261fa9e4066Sahrens (void) fprintf(stderr, gettext("missing filesystem " 2262fa9e4066Sahrens "argument\n")); 226399653d4eSeschrock usage(B_FALSE); 2264fa9e4066Sahrens } 2265fa9e4066Sahrens 2266fa9e4066Sahrens /* 2267fa9e4066Sahrens * When mount is given no arguments, go through /etc/mnttab and 2268fa9e4066Sahrens * display any active ZFS mounts. We hide any snapshots, since 2269fa9e4066Sahrens * they are controlled automatically. 2270fa9e4066Sahrens */ 2271fa9e4066Sahrens rewind(mnttab_file); 2272fa9e4066Sahrens while (getmntent(mnttab_file, &entry) == 0) { 2273fa9e4066Sahrens if (strcmp(entry.mnt_fstype, MNTTYPE_ZFS) != 0 || 2274fa9e4066Sahrens strchr(entry.mnt_special, '@') != NULL) 2275fa9e4066Sahrens continue; 2276fa9e4066Sahrens 2277fa9e4066Sahrens (void) printf("%-30s %s\n", entry.mnt_special, 2278fa9e4066Sahrens entry.mnt_mountp); 2279fa9e4066Sahrens } 2280fa9e4066Sahrens 2281fa9e4066Sahrens ret = 0; 2282fa9e4066Sahrens } else { 2283fa9e4066Sahrens zfs_handle_t *zhp; 2284fa9e4066Sahrens 2285fa9e4066Sahrens if (argc > 1) { 2286fa9e4066Sahrens (void) fprintf(stderr, 2287fa9e4066Sahrens gettext("too many arguments\n")); 228899653d4eSeschrock usage(B_FALSE); 2289fa9e4066Sahrens } 2290fa9e4066Sahrens 229199653d4eSeschrock if ((zhp = zfs_open(g_zfs, argv[0], 229299653d4eSeschrock ZFS_TYPE_FILESYSTEM)) == NULL) 2293fa9e4066Sahrens ret = 1; 2294fa9e4066Sahrens else { 229599653d4eSeschrock cb.cb_explicit = B_TRUE; 2296fa9e4066Sahrens ret = share_mount_callback(zhp, &cb); 2297fa9e4066Sahrens zfs_close(zhp); 2298fa9e4066Sahrens } 2299fa9e4066Sahrens } 2300fa9e4066Sahrens 2301fa9e4066Sahrens return (ret); 2302fa9e4066Sahrens } 2303fa9e4066Sahrens 2304fa9e4066Sahrens /* 2305fa9e4066Sahrens * zfs mount -a 2306fa9e4066Sahrens * zfs mount filesystem 2307fa9e4066Sahrens * 2308fa9e4066Sahrens * Mount all filesystems, or mount the given filesystem. 2309fa9e4066Sahrens */ 2310fa9e4066Sahrens static int 2311fa9e4066Sahrens zfs_do_mount(int argc, char **argv) 2312fa9e4066Sahrens { 2313fa9e4066Sahrens return (share_or_mount(OP_MOUNT, argc, argv)); 2314fa9e4066Sahrens } 2315fa9e4066Sahrens 2316fa9e4066Sahrens /* 2317fa9e4066Sahrens * zfs share -a 2318fa9e4066Sahrens * zfs share filesystem 2319fa9e4066Sahrens * 2320fa9e4066Sahrens * Share all filesystems, or share the given filesystem. 2321fa9e4066Sahrens */ 2322fa9e4066Sahrens static int 2323fa9e4066Sahrens zfs_do_share(int argc, char **argv) 2324fa9e4066Sahrens { 2325fa9e4066Sahrens return (share_or_mount(OP_SHARE, argc, argv)); 2326fa9e4066Sahrens } 2327fa9e4066Sahrens 2328fa9e4066Sahrens typedef struct unshare_unmount_node { 2329fa9e4066Sahrens zfs_handle_t *un_zhp; 2330fa9e4066Sahrens char *un_mountp; 2331fa9e4066Sahrens uu_avl_node_t un_avlnode; 2332fa9e4066Sahrens } unshare_unmount_node_t; 2333fa9e4066Sahrens 2334fa9e4066Sahrens /* ARGSUSED */ 2335fa9e4066Sahrens static int 2336fa9e4066Sahrens unshare_unmount_compare(const void *larg, const void *rarg, void *unused) 2337fa9e4066Sahrens { 2338fa9e4066Sahrens const unshare_unmount_node_t *l = larg; 2339fa9e4066Sahrens const unshare_unmount_node_t *r = rarg; 2340fa9e4066Sahrens 2341fa9e4066Sahrens return (strcmp(l->un_mountp, r->un_mountp)); 2342fa9e4066Sahrens } 2343fa9e4066Sahrens 2344fa9e4066Sahrens /* 2345fa9e4066Sahrens * Convenience routine used by zfs_do_umount() and manual_unmount(). Given an 2346fa9e4066Sahrens * absolute path, find the entry /etc/mnttab, verify that its a ZFS filesystem, 2347fa9e4066Sahrens * and unmount it appropriately. 2348fa9e4066Sahrens */ 2349fa9e4066Sahrens static int 235099653d4eSeschrock unshare_unmount_path(int type, char *path, int flags, boolean_t is_manual) 2351fa9e4066Sahrens { 2352fa9e4066Sahrens zfs_handle_t *zhp; 2353fa9e4066Sahrens int ret; 2354fa9e4066Sahrens struct stat64 statbuf; 2355fa9e4066Sahrens struct extmnttab entry; 2356fa9e4066Sahrens const char *cmdname = (type == OP_SHARE) ? "unshare" : "unmount"; 2357fa9e4066Sahrens char property[ZFS_MAXPROPLEN]; 2358fa9e4066Sahrens 2359fa9e4066Sahrens /* 2360fa9e4066Sahrens * Search for the path in /etc/mnttab. Rather than looking for the 2361fa9e4066Sahrens * specific path, which can be fooled by non-standard paths (i.e. ".." 2362fa9e4066Sahrens * or "//"), we stat() the path and search for the corresponding 2363fa9e4066Sahrens * (major,minor) device pair. 2364fa9e4066Sahrens */ 2365fa9e4066Sahrens if (stat64(path, &statbuf) != 0) { 2366fa9e4066Sahrens (void) fprintf(stderr, gettext("cannot %s '%s': %s\n"), 2367fa9e4066Sahrens cmdname, path, strerror(errno)); 2368fa9e4066Sahrens return (1); 2369fa9e4066Sahrens } 2370fa9e4066Sahrens 2371fa9e4066Sahrens /* 2372fa9e4066Sahrens * Search for the given (major,minor) pair in the mount table. 2373fa9e4066Sahrens */ 2374fa9e4066Sahrens rewind(mnttab_file); 2375fa9e4066Sahrens while ((ret = getextmntent(mnttab_file, &entry, 0)) == 0) { 2376fa9e4066Sahrens if (entry.mnt_major == major(statbuf.st_dev) && 2377fa9e4066Sahrens entry.mnt_minor == minor(statbuf.st_dev)) 2378fa9e4066Sahrens break; 2379fa9e4066Sahrens } 2380fa9e4066Sahrens if (ret != 0) { 2381fa9e4066Sahrens (void) fprintf(stderr, gettext("cannot %s '%s': not " 2382fa9e4066Sahrens "currently mounted\n"), cmdname, path); 2383fa9e4066Sahrens return (1); 2384fa9e4066Sahrens } 2385fa9e4066Sahrens 2386fa9e4066Sahrens if (strcmp(entry.mnt_fstype, MNTTYPE_ZFS) != 0) { 2387fa9e4066Sahrens (void) fprintf(stderr, gettext("cannot %s '%s': not a ZFS " 2388fa9e4066Sahrens "filesystem\n"), cmdname, path); 2389fa9e4066Sahrens return (1); 2390fa9e4066Sahrens } 2391fa9e4066Sahrens 239299653d4eSeschrock if ((zhp = zfs_open(g_zfs, entry.mnt_special, 239399653d4eSeschrock ZFS_TYPE_FILESYSTEM)) == NULL) 2394fa9e4066Sahrens return (1); 2395fa9e4066Sahrens 2396fa9e4066Sahrens verify(zfs_prop_get(zhp, type == OP_SHARE ? 2397fa9e4066Sahrens ZFS_PROP_SHARENFS : ZFS_PROP_MOUNTPOINT, property, 239899653d4eSeschrock sizeof (property), NULL, NULL, 0, B_FALSE) == 0); 2399fa9e4066Sahrens 2400fa9e4066Sahrens if (type == OP_SHARE) { 2401fa9e4066Sahrens if (strcmp(property, "off") == 0) { 2402fa9e4066Sahrens (void) fprintf(stderr, gettext("cannot unshare " 2403fa9e4066Sahrens "'%s': legacy share\n"), path); 2404fa9e4066Sahrens (void) fprintf(stderr, gettext("use " 2405fa9e4066Sahrens "unshare(1M) to unshare this filesystem\n")); 2406fa9e4066Sahrens ret = 1; 2407fa9e4066Sahrens } else if (!zfs_is_shared(zhp, NULL)) { 2408fa9e4066Sahrens (void) fprintf(stderr, gettext("cannot unshare '%s': " 2409fa9e4066Sahrens "not currently shared\n"), path); 2410fa9e4066Sahrens ret = 1; 2411fa9e4066Sahrens } else { 2412fa9e4066Sahrens ret = zfs_unshareall(zhp); 2413fa9e4066Sahrens } 2414fa9e4066Sahrens } else { 24156b90ca48Slling if (is_manual) { 24166b90ca48Slling ret = zfs_unmount(zhp, NULL, flags); 2417c0ea9bc7Slling } else if (strcmp(property, "legacy") == 0) { 2418fa9e4066Sahrens (void) fprintf(stderr, gettext("cannot unmount " 2419fa9e4066Sahrens "'%s': legacy mountpoint\n"), 2420fa9e4066Sahrens zfs_get_name(zhp)); 2421fa9e4066Sahrens (void) fprintf(stderr, gettext("use umount(1M) " 2422fa9e4066Sahrens "to unmount this filesystem\n")); 2423fa9e4066Sahrens ret = 1; 2424fa9e4066Sahrens } else { 2425fa9e4066Sahrens ret = zfs_unmountall(zhp, flags); 2426fa9e4066Sahrens } 2427fa9e4066Sahrens } 2428fa9e4066Sahrens 2429fa9e4066Sahrens zfs_close(zhp); 2430fa9e4066Sahrens 2431fa9e4066Sahrens return (ret != 0); 2432fa9e4066Sahrens } 2433fa9e4066Sahrens 2434fa9e4066Sahrens /* 2435fa9e4066Sahrens * Generic callback for unsharing or unmounting a filesystem. 2436fa9e4066Sahrens */ 2437fa9e4066Sahrens static int 2438fa9e4066Sahrens unshare_unmount(int type, int argc, char **argv) 2439fa9e4066Sahrens { 2440fa9e4066Sahrens int do_all = 0; 2441fa9e4066Sahrens int flags = 0; 2442fa9e4066Sahrens int ret = 0; 2443fa9e4066Sahrens int c; 2444fa9e4066Sahrens zfs_handle_t *zhp; 2445fa9e4066Sahrens char property[ZFS_MAXPROPLEN]; 2446fa9e4066Sahrens 2447fa9e4066Sahrens /* check options */ 2448fa9e4066Sahrens while ((c = getopt(argc, argv, type == OP_SHARE ? "a" : "af")) != -1) { 2449fa9e4066Sahrens switch (c) { 2450fa9e4066Sahrens case 'a': 2451fa9e4066Sahrens do_all = 1; 2452fa9e4066Sahrens break; 2453fa9e4066Sahrens case 'f': 2454fa9e4066Sahrens flags = MS_FORCE; 2455fa9e4066Sahrens break; 2456fa9e4066Sahrens case '?': 2457fa9e4066Sahrens (void) fprintf(stderr, gettext("invalid option '%c'\n"), 2458fa9e4066Sahrens optopt); 245999653d4eSeschrock usage(B_FALSE); 2460fa9e4066Sahrens } 2461fa9e4066Sahrens } 2462fa9e4066Sahrens 2463fa9e4066Sahrens argc -= optind; 2464fa9e4066Sahrens argv += optind; 2465fa9e4066Sahrens 2466fa9e4066Sahrens /* ensure correct number of arguments */ 2467fa9e4066Sahrens if (do_all) { 2468fa9e4066Sahrens if (argc != 0) { 2469fa9e4066Sahrens (void) fprintf(stderr, gettext("too many arguments\n")); 247099653d4eSeschrock usage(B_FALSE); 2471fa9e4066Sahrens } 2472fa9e4066Sahrens } else if (argc != 1) { 2473fa9e4066Sahrens if (argc == 0) 2474fa9e4066Sahrens (void) fprintf(stderr, 2475fa9e4066Sahrens gettext("missing filesystem argument\n")); 2476fa9e4066Sahrens else 2477fa9e4066Sahrens (void) fprintf(stderr, 2478fa9e4066Sahrens gettext("too many arguments\n")); 247999653d4eSeschrock usage(B_FALSE); 2480fa9e4066Sahrens } 2481fa9e4066Sahrens 2482fa9e4066Sahrens if (do_all) { 2483fa9e4066Sahrens /* 2484fa9e4066Sahrens * We could make use of zfs_for_each() to walk all datasets in 2485fa9e4066Sahrens * the system, but this would be very inefficient, especially 2486fa9e4066Sahrens * since we would have to linearly search /etc/mnttab for each 2487fa9e4066Sahrens * one. Instead, do one pass through /etc/mnttab looking for 2488fa9e4066Sahrens * zfs entries and call zfs_unmount() for each one. 2489fa9e4066Sahrens * 2490fa9e4066Sahrens * Things get a little tricky if the administrator has created 2491fa9e4066Sahrens * mountpoints beneath other ZFS filesystems. In this case, we 2492fa9e4066Sahrens * have to unmount the deepest filesystems first. To accomplish 2493fa9e4066Sahrens * this, we place all the mountpoints in an AVL tree sorted by 2494fa9e4066Sahrens * the special type (dataset name), and walk the result in 2495fa9e4066Sahrens * reverse to make sure to get any snapshots first. 2496fa9e4066Sahrens */ 2497fa9e4066Sahrens struct mnttab entry; 2498fa9e4066Sahrens uu_avl_pool_t *pool; 2499fa9e4066Sahrens uu_avl_t *tree; 2500fa9e4066Sahrens unshare_unmount_node_t *node; 2501fa9e4066Sahrens uu_avl_index_t idx; 2502fa9e4066Sahrens uu_avl_walk_t *walk; 2503fa9e4066Sahrens 2504fa9e4066Sahrens if ((pool = uu_avl_pool_create("unmount_pool", 2505fa9e4066Sahrens sizeof (unshare_unmount_node_t), 2506fa9e4066Sahrens offsetof(unshare_unmount_node_t, un_avlnode), 2507fa9e4066Sahrens unshare_unmount_compare, 2508fa9e4066Sahrens UU_DEFAULT)) == NULL) { 2509fa9e4066Sahrens (void) fprintf(stderr, gettext("internal error: " 2510fa9e4066Sahrens "out of memory\n")); 2511fa9e4066Sahrens exit(1); 2512fa9e4066Sahrens } 2513fa9e4066Sahrens 2514fa9e4066Sahrens if ((tree = uu_avl_create(pool, NULL, UU_DEFAULT)) == NULL) { 2515fa9e4066Sahrens (void) fprintf(stderr, gettext("internal error: " 2516fa9e4066Sahrens "out of memory\n")); 2517fa9e4066Sahrens exit(1); 2518fa9e4066Sahrens } 2519fa9e4066Sahrens 2520fa9e4066Sahrens rewind(mnttab_file); 2521fa9e4066Sahrens while (getmntent(mnttab_file, &entry) == 0) { 2522fa9e4066Sahrens 2523fa9e4066Sahrens /* ignore non-ZFS entries */ 2524fa9e4066Sahrens if (strcmp(entry.mnt_fstype, MNTTYPE_ZFS) != 0) 2525fa9e4066Sahrens continue; 2526fa9e4066Sahrens 2527fa9e4066Sahrens /* ignore snapshots */ 2528fa9e4066Sahrens if (strchr(entry.mnt_special, '@') != NULL) 2529fa9e4066Sahrens continue; 2530fa9e4066Sahrens 253199653d4eSeschrock if ((zhp = zfs_open(g_zfs, entry.mnt_special, 2532fa9e4066Sahrens ZFS_TYPE_FILESYSTEM)) == NULL) { 2533fa9e4066Sahrens ret = 1; 2534fa9e4066Sahrens continue; 2535fa9e4066Sahrens } 2536fa9e4066Sahrens 2537fa9e4066Sahrens verify(zfs_prop_get(zhp, type == OP_SHARE ? 2538fa9e4066Sahrens ZFS_PROP_SHARENFS : ZFS_PROP_MOUNTPOINT, 2539fa9e4066Sahrens property, sizeof (property), NULL, NULL, 254099653d4eSeschrock 0, B_FALSE) == 0); 2541fa9e4066Sahrens 2542fa9e4066Sahrens /* Ignore legacy mounts and shares */ 2543fa9e4066Sahrens if ((type == OP_SHARE && 2544fa9e4066Sahrens strcmp(property, "off") == 0) || 2545fa9e4066Sahrens (type == OP_MOUNT && 2546fa9e4066Sahrens strcmp(property, "legacy") == 0)) { 2547fa9e4066Sahrens zfs_close(zhp); 2548fa9e4066Sahrens continue; 2549fa9e4066Sahrens } 2550fa9e4066Sahrens 2551fa9e4066Sahrens node = safe_malloc(sizeof (unshare_unmount_node_t)); 2552fa9e4066Sahrens node->un_zhp = zhp; 2553fa9e4066Sahrens 2554fa9e4066Sahrens if ((node->un_mountp = strdup(entry.mnt_mountp)) == 2555fa9e4066Sahrens NULL) { 2556fa9e4066Sahrens (void) fprintf(stderr, gettext("internal error:" 2557fa9e4066Sahrens " out of memory\n")); 2558fa9e4066Sahrens exit(1); 2559fa9e4066Sahrens } 2560fa9e4066Sahrens 2561fa9e4066Sahrens uu_avl_node_init(node, &node->un_avlnode, pool); 2562fa9e4066Sahrens 2563fa9e4066Sahrens if (uu_avl_find(tree, node, NULL, &idx) == NULL) { 2564fa9e4066Sahrens uu_avl_insert(tree, node, idx); 2565fa9e4066Sahrens } else { 2566fa9e4066Sahrens zfs_close(node->un_zhp); 2567fa9e4066Sahrens free(node->un_mountp); 2568fa9e4066Sahrens free(node); 2569fa9e4066Sahrens } 2570fa9e4066Sahrens } 2571fa9e4066Sahrens 2572fa9e4066Sahrens /* 2573fa9e4066Sahrens * Walk the AVL tree in reverse, unmounting each filesystem and 2574fa9e4066Sahrens * removing it from the AVL tree in the process. 2575fa9e4066Sahrens */ 2576fa9e4066Sahrens if ((walk = uu_avl_walk_start(tree, 2577fa9e4066Sahrens UU_WALK_REVERSE | UU_WALK_ROBUST)) == NULL) { 2578fa9e4066Sahrens (void) fprintf(stderr, 2579fa9e4066Sahrens gettext("internal error: out of memory")); 2580fa9e4066Sahrens exit(1); 2581fa9e4066Sahrens } 2582fa9e4066Sahrens 2583fa9e4066Sahrens while ((node = uu_avl_walk_next(walk)) != NULL) { 2584fa9e4066Sahrens uu_avl_remove(tree, node); 2585fa9e4066Sahrens 2586fa9e4066Sahrens switch (type) { 2587fa9e4066Sahrens case OP_SHARE: 2588fa9e4066Sahrens if (zfs_unshare(node->un_zhp, 2589fa9e4066Sahrens node->un_mountp) != 0) 2590fa9e4066Sahrens ret = 1; 2591fa9e4066Sahrens break; 2592fa9e4066Sahrens 2593fa9e4066Sahrens case OP_MOUNT: 2594fa9e4066Sahrens if (zfs_unmount(node->un_zhp, 2595fa9e4066Sahrens node->un_mountp, flags) != 0) 2596fa9e4066Sahrens ret = 1; 2597fa9e4066Sahrens break; 2598fa9e4066Sahrens } 2599fa9e4066Sahrens 2600fa9e4066Sahrens zfs_close(node->un_zhp); 2601fa9e4066Sahrens free(node->un_mountp); 2602fa9e4066Sahrens free(node); 2603fa9e4066Sahrens } 2604fa9e4066Sahrens 2605fa9e4066Sahrens uu_avl_walk_end(walk); 2606fa9e4066Sahrens uu_avl_destroy(tree); 2607fa9e4066Sahrens uu_avl_pool_destroy(pool); 2608fa9e4066Sahrens } else { 2609fa9e4066Sahrens /* 2610fa9e4066Sahrens * We have an argument, but it may be a full path or a ZFS 2611fa9e4066Sahrens * filesystem. Pass full paths off to unmount_path() (shared by 2612fa9e4066Sahrens * manual_unmount), otherwise open the filesystem and pass to 2613fa9e4066Sahrens * zfs_unmount(). 2614fa9e4066Sahrens */ 2615fa9e4066Sahrens if (argv[0][0] == '/') 2616fa9e4066Sahrens return (unshare_unmount_path(type, argv[0], 261799653d4eSeschrock flags, B_FALSE)); 2618fa9e4066Sahrens 261999653d4eSeschrock if ((zhp = zfs_open(g_zfs, argv[0], 262099653d4eSeschrock ZFS_TYPE_FILESYSTEM)) == NULL) 2621fa9e4066Sahrens return (1); 2622fa9e4066Sahrens 2623fa9e4066Sahrens verify(zfs_prop_get(zhp, type == OP_SHARE ? 2624fa9e4066Sahrens ZFS_PROP_SHARENFS : ZFS_PROP_MOUNTPOINT, property, 262599653d4eSeschrock sizeof (property), NULL, NULL, 0, B_FALSE) == 0); 2626fa9e4066Sahrens 2627fa9e4066Sahrens switch (type) { 2628fa9e4066Sahrens case OP_SHARE: 2629fa9e4066Sahrens if (strcmp(property, "off") == 0) { 2630fa9e4066Sahrens (void) fprintf(stderr, gettext("cannot unshare " 2631fa9e4066Sahrens "'%s': legacy share\n"), zfs_get_name(zhp)); 2632fa9e4066Sahrens (void) fprintf(stderr, gettext("use unshare(1M)" 2633fa9e4066Sahrens " to unshare this filesystem\n")); 2634fa9e4066Sahrens ret = 1; 2635fa9e4066Sahrens } else if (!zfs_is_shared(zhp, NULL)) { 2636fa9e4066Sahrens (void) fprintf(stderr, gettext("cannot unshare " 2637fa9e4066Sahrens "'%s': not currently shared\n"), 2638fa9e4066Sahrens zfs_get_name(zhp)); 2639fa9e4066Sahrens ret = 1; 2640fa9e4066Sahrens } else if (zfs_unshareall(zhp) != 0) { 2641fa9e4066Sahrens ret = 1; 2642fa9e4066Sahrens } 2643fa9e4066Sahrens break; 2644fa9e4066Sahrens 2645fa9e4066Sahrens case OP_MOUNT: 2646fa9e4066Sahrens if (strcmp(property, "legacy") == 0) { 2647fa9e4066Sahrens (void) fprintf(stderr, gettext("cannot unmount " 2648fa9e4066Sahrens "'%s': legacy mountpoint\n"), 2649fa9e4066Sahrens zfs_get_name(zhp)); 2650fa9e4066Sahrens (void) fprintf(stderr, gettext("use umount(1M) " 2651fa9e4066Sahrens "to unmount this filesystem\n")); 2652fa9e4066Sahrens ret = 1; 2653fa9e4066Sahrens } else if (!zfs_is_mounted(zhp, NULL)) { 2654fa9e4066Sahrens (void) fprintf(stderr, gettext("cannot unmount " 2655fa9e4066Sahrens "'%s': not currently mounted\n"), 2656fa9e4066Sahrens zfs_get_name(zhp)); 2657fa9e4066Sahrens ret = 1; 2658fa9e4066Sahrens } else if (zfs_unmountall(zhp, flags) != 0) { 2659fa9e4066Sahrens ret = 1; 2660fa9e4066Sahrens } 2661fa9e4066Sahrens } 2662fa9e4066Sahrens 2663fa9e4066Sahrens zfs_close(zhp); 2664fa9e4066Sahrens } 2665fa9e4066Sahrens 2666fa9e4066Sahrens return (ret); 2667fa9e4066Sahrens } 2668fa9e4066Sahrens 2669fa9e4066Sahrens /* 2670fa9e4066Sahrens * zfs unmount -a 2671fa9e4066Sahrens * zfs unmount filesystem 2672fa9e4066Sahrens * 2673fa9e4066Sahrens * Unmount all filesystems, or a specific ZFS filesystem. 2674fa9e4066Sahrens */ 2675fa9e4066Sahrens static int 2676fa9e4066Sahrens zfs_do_unmount(int argc, char **argv) 2677fa9e4066Sahrens { 2678fa9e4066Sahrens return (unshare_unmount(OP_MOUNT, argc, argv)); 2679fa9e4066Sahrens } 2680fa9e4066Sahrens 2681fa9e4066Sahrens /* 2682fa9e4066Sahrens * zfs unshare -a 2683fa9e4066Sahrens * zfs unshare filesystem 2684fa9e4066Sahrens * 2685fa9e4066Sahrens * Unshare all filesystems, or a specific ZFS filesystem. 2686fa9e4066Sahrens */ 2687fa9e4066Sahrens static int 2688fa9e4066Sahrens zfs_do_unshare(int argc, char **argv) 2689fa9e4066Sahrens { 2690fa9e4066Sahrens return (unshare_unmount(OP_SHARE, argc, argv)); 2691fa9e4066Sahrens } 2692fa9e4066Sahrens 2693fa9e4066Sahrens /* 2694fa9e4066Sahrens * Called when invoked as /etc/fs/zfs/mount. Do the mount if the mountpoint is 2695fa9e4066Sahrens * 'legacy'. Otherwise, complain that use should be using 'zfs mount'. 2696fa9e4066Sahrens */ 2697fa9e4066Sahrens static int 2698fa9e4066Sahrens manual_mount(int argc, char **argv) 2699fa9e4066Sahrens { 2700fa9e4066Sahrens zfs_handle_t *zhp; 2701fa9e4066Sahrens char mountpoint[ZFS_MAXPROPLEN]; 2702fa9e4066Sahrens char mntopts[MNT_LINE_MAX] = { '\0' }; 2703fa9e4066Sahrens int ret; 2704fa9e4066Sahrens int c; 2705fa9e4066Sahrens int flags = 0; 2706fa9e4066Sahrens char *dataset, *path; 2707fa9e4066Sahrens 2708fa9e4066Sahrens /* check options */ 2709ea8dc4b6Seschrock while ((c = getopt(argc, argv, ":mo:O")) != -1) { 2710fa9e4066Sahrens switch (c) { 2711fa9e4066Sahrens case 'o': 2712fa9e4066Sahrens (void) strlcpy(mntopts, optarg, sizeof (mntopts)); 2713fa9e4066Sahrens break; 2714fa9e4066Sahrens case 'O': 2715fa9e4066Sahrens flags |= MS_OVERLAY; 2716fa9e4066Sahrens break; 2717ea8dc4b6Seschrock case 'm': 2718ea8dc4b6Seschrock flags |= MS_NOMNTTAB; 2719ea8dc4b6Seschrock break; 2720fa9e4066Sahrens case ':': 2721fa9e4066Sahrens (void) fprintf(stderr, gettext("missing argument for " 2722fa9e4066Sahrens "'%c' option\n"), optopt); 272399653d4eSeschrock usage(B_FALSE); 2724fa9e4066Sahrens break; 2725fa9e4066Sahrens case '?': 2726fa9e4066Sahrens (void) fprintf(stderr, gettext("invalid option '%c'\n"), 2727fa9e4066Sahrens optopt); 2728fa9e4066Sahrens (void) fprintf(stderr, gettext("usage: mount [-o opts] " 2729fa9e4066Sahrens "<path>\n")); 2730fa9e4066Sahrens return (2); 2731fa9e4066Sahrens } 2732fa9e4066Sahrens } 2733fa9e4066Sahrens 2734fa9e4066Sahrens argc -= optind; 2735fa9e4066Sahrens argv += optind; 2736fa9e4066Sahrens 2737fa9e4066Sahrens /* check that we only have two arguments */ 2738fa9e4066Sahrens if (argc != 2) { 2739fa9e4066Sahrens if (argc == 0) 2740fa9e4066Sahrens (void) fprintf(stderr, gettext("missing dataset " 2741fa9e4066Sahrens "argument\n")); 2742fa9e4066Sahrens else if (argc == 1) 2743fa9e4066Sahrens (void) fprintf(stderr, 2744fa9e4066Sahrens gettext("missing mountpoint argument\n")); 2745fa9e4066Sahrens else 2746fa9e4066Sahrens (void) fprintf(stderr, gettext("too many arguments\n")); 2747fa9e4066Sahrens (void) fprintf(stderr, "usage: mount <dataset> <mountpoint>\n"); 2748fa9e4066Sahrens return (2); 2749fa9e4066Sahrens } 2750fa9e4066Sahrens 2751fa9e4066Sahrens dataset = argv[0]; 2752fa9e4066Sahrens path = argv[1]; 2753fa9e4066Sahrens 2754fa9e4066Sahrens /* try to open the dataset */ 275599653d4eSeschrock if ((zhp = zfs_open(g_zfs, dataset, ZFS_TYPE_FILESYSTEM)) == NULL) 2756fa9e4066Sahrens return (1); 2757fa9e4066Sahrens 2758fa9e4066Sahrens (void) zfs_prop_get(zhp, ZFS_PROP_MOUNTPOINT, mountpoint, 275999653d4eSeschrock sizeof (mountpoint), NULL, NULL, 0, B_FALSE); 2760fa9e4066Sahrens 2761fa9e4066Sahrens /* check for legacy mountpoint and complain appropriately */ 2762fa9e4066Sahrens ret = 0; 2763fa9e4066Sahrens if (strcmp(mountpoint, ZFS_MOUNTPOINT_LEGACY) == 0) { 2764fa9e4066Sahrens if (mount(dataset, path, MS_OPTIONSTR | flags, MNTTYPE_ZFS, 2765fa9e4066Sahrens NULL, 0, mntopts, sizeof (mntopts)) != 0) { 2766fa9e4066Sahrens (void) fprintf(stderr, gettext("mount failed: %s\n"), 2767fa9e4066Sahrens strerror(errno)); 2768fa9e4066Sahrens ret = 1; 2769fa9e4066Sahrens } 2770fa9e4066Sahrens } else { 2771fa9e4066Sahrens (void) fprintf(stderr, gettext("filesystem '%s' cannot be " 2772fa9e4066Sahrens "mounted using 'mount -F zfs'\n"), dataset); 2773fa9e4066Sahrens (void) fprintf(stderr, gettext("Use 'zfs set mountpoint=%s' " 2774fa9e4066Sahrens "instead.\n"), path); 2775fa9e4066Sahrens (void) fprintf(stderr, gettext("If you must use 'mount -F zfs' " 2776fa9e4066Sahrens "or /etc/vfstab, use 'zfs set mountpoint=legacy'.\n")); 2777fa9e4066Sahrens (void) fprintf(stderr, gettext("See zfs(1M) for more " 2778fa9e4066Sahrens "information.\n")); 2779fa9e4066Sahrens ret = 1; 2780fa9e4066Sahrens } 2781fa9e4066Sahrens 2782fa9e4066Sahrens return (ret); 2783fa9e4066Sahrens } 2784fa9e4066Sahrens 2785fa9e4066Sahrens /* 2786fa9e4066Sahrens * Called when invoked as /etc/fs/zfs/umount. Unlike a manual mount, we allow 2787fa9e4066Sahrens * unmounts of non-legacy filesystems, as this is the dominant administrative 2788fa9e4066Sahrens * interface. 2789fa9e4066Sahrens */ 2790fa9e4066Sahrens static int 2791fa9e4066Sahrens manual_unmount(int argc, char **argv) 2792fa9e4066Sahrens { 2793fa9e4066Sahrens int flags = 0; 2794fa9e4066Sahrens int c; 2795fa9e4066Sahrens 2796fa9e4066Sahrens /* check options */ 2797fa9e4066Sahrens while ((c = getopt(argc, argv, "f")) != -1) { 2798fa9e4066Sahrens switch (c) { 2799fa9e4066Sahrens case 'f': 2800fa9e4066Sahrens flags = MS_FORCE; 2801fa9e4066Sahrens break; 2802fa9e4066Sahrens case '?': 2803fa9e4066Sahrens (void) fprintf(stderr, gettext("invalid option '%c'\n"), 2804fa9e4066Sahrens optopt); 2805fa9e4066Sahrens (void) fprintf(stderr, gettext("usage: unmount [-f] " 2806fa9e4066Sahrens "<path>\n")); 2807fa9e4066Sahrens return (2); 2808fa9e4066Sahrens } 2809fa9e4066Sahrens } 2810fa9e4066Sahrens 2811fa9e4066Sahrens argc -= optind; 2812fa9e4066Sahrens argv += optind; 2813fa9e4066Sahrens 2814fa9e4066Sahrens /* check arguments */ 2815fa9e4066Sahrens if (argc != 1) { 2816fa9e4066Sahrens if (argc == 0) 2817fa9e4066Sahrens (void) fprintf(stderr, gettext("missing path " 2818fa9e4066Sahrens "argument\n")); 2819fa9e4066Sahrens else 2820fa9e4066Sahrens (void) fprintf(stderr, gettext("too many arguments\n")); 2821fa9e4066Sahrens (void) fprintf(stderr, gettext("usage: unmount [-f] <path>\n")); 2822fa9e4066Sahrens return (2); 2823fa9e4066Sahrens } 2824fa9e4066Sahrens 282599653d4eSeschrock return (unshare_unmount_path(OP_MOUNT, argv[0], flags, B_TRUE)); 2826fa9e4066Sahrens } 2827fa9e4066Sahrens 2828fa9e4066Sahrens static int 2829fa9e4066Sahrens volcheck(zpool_handle_t *zhp, void *data) 2830fa9e4066Sahrens { 2831fa9e4066Sahrens int isinit = (int)data; 2832fa9e4066Sahrens 2833fa9e4066Sahrens if (isinit) 2834fa9e4066Sahrens return (zpool_create_zvol_links(zhp)); 2835fa9e4066Sahrens else 2836fa9e4066Sahrens return (zpool_remove_zvol_links(zhp)); 2837fa9e4066Sahrens } 2838fa9e4066Sahrens 2839fa9e4066Sahrens /* 2840fa9e4066Sahrens * Iterate over all pools in the system and either create or destroy /dev/zvol 2841fa9e4066Sahrens * links, depending on the value of 'isinit'. 2842fa9e4066Sahrens */ 2843fa9e4066Sahrens static int 284499653d4eSeschrock do_volcheck(boolean_t isinit) 2845fa9e4066Sahrens { 284699653d4eSeschrock return (zpool_iter(g_zfs, volcheck, (void *)isinit) ? 1 : 0); 2847fa9e4066Sahrens } 2848fa9e4066Sahrens 2849fa9e4066Sahrens int 2850fa9e4066Sahrens main(int argc, char **argv) 2851fa9e4066Sahrens { 2852fa9e4066Sahrens int ret; 2853fa9e4066Sahrens int i; 2854fa9e4066Sahrens char *progname; 2855fa9e4066Sahrens char *cmdname; 2856fa9e4066Sahrens 2857fa9e4066Sahrens (void) setlocale(LC_ALL, ""); 2858fa9e4066Sahrens (void) textdomain(TEXT_DOMAIN); 2859fa9e4066Sahrens 2860fa9e4066Sahrens opterr = 0; 2861fa9e4066Sahrens 286299653d4eSeschrock if ((g_zfs = libzfs_init()) == NULL) { 286399653d4eSeschrock (void) fprintf(stderr, gettext("internal error: failed to " 286499653d4eSeschrock "initialize ZFS library\n")); 286599653d4eSeschrock return (1); 286699653d4eSeschrock } 286799653d4eSeschrock 286899653d4eSeschrock libzfs_print_on_error(g_zfs, B_TRUE); 286999653d4eSeschrock 2870fa9e4066Sahrens if ((mnttab_file = fopen(MNTTAB, "r")) == NULL) { 2871fa9e4066Sahrens (void) fprintf(stderr, gettext("internal error: unable to " 2872fa9e4066Sahrens "open %s\n"), MNTTAB); 2873fa9e4066Sahrens return (1); 2874fa9e4066Sahrens } 2875fa9e4066Sahrens 2876fa9e4066Sahrens /* 2877fa9e4066Sahrens * This command also doubles as the /etc/fs mount and unmount program. 2878fa9e4066Sahrens * Determine if we should take this behavior based on argv[0]. 2879fa9e4066Sahrens */ 2880fa9e4066Sahrens progname = basename(argv[0]); 2881fa9e4066Sahrens if (strcmp(progname, "mount") == 0) { 2882fa9e4066Sahrens ret = manual_mount(argc, argv); 2883fa9e4066Sahrens } else if (strcmp(progname, "umount") == 0) { 2884fa9e4066Sahrens ret = manual_unmount(argc, argv); 2885fa9e4066Sahrens } else { 2886fa9e4066Sahrens /* 2887fa9e4066Sahrens * Make sure the user has specified some command. 2888fa9e4066Sahrens */ 2889fa9e4066Sahrens if (argc < 2) { 2890fa9e4066Sahrens (void) fprintf(stderr, gettext("missing command\n")); 289199653d4eSeschrock usage(B_FALSE); 2892fa9e4066Sahrens } 2893fa9e4066Sahrens 2894fa9e4066Sahrens cmdname = argv[1]; 2895fa9e4066Sahrens 2896fa9e4066Sahrens /* 2897fa9e4066Sahrens * The 'umount' command is an alias for 'unmount' 2898fa9e4066Sahrens */ 2899fa9e4066Sahrens if (strcmp(cmdname, "umount") == 0) 2900fa9e4066Sahrens cmdname = "unmount"; 2901fa9e4066Sahrens 2902fa9e4066Sahrens /* 2903f2a3c691Sahrens * The 'recv' command is an alias for 'receive' 2904f2a3c691Sahrens */ 2905f2a3c691Sahrens if (strcmp(cmdname, "recv") == 0) 2906f2a3c691Sahrens cmdname = "receive"; 2907f2a3c691Sahrens 2908f2a3c691Sahrens /* 2909fa9e4066Sahrens * Special case '-?' 2910fa9e4066Sahrens */ 2911fa9e4066Sahrens if (strcmp(cmdname, "-?") == 0) 291299653d4eSeschrock usage(B_TRUE); 2913fa9e4066Sahrens 2914fa9e4066Sahrens /* 2915fa9e4066Sahrens * 'volinit' and 'volfini' do not appear in the usage message, 2916fa9e4066Sahrens * so we have to special case them here. 2917fa9e4066Sahrens */ 2918fa9e4066Sahrens if (strcmp(cmdname, "volinit") == 0) 291999653d4eSeschrock return (do_volcheck(B_TRUE)); 2920fa9e4066Sahrens else if (strcmp(cmdname, "volfini") == 0) 292199653d4eSeschrock return (do_volcheck(B_FALSE)); 2922fa9e4066Sahrens 2923fa9e4066Sahrens /* 2924fa9e4066Sahrens * Run the appropriate command. 2925fa9e4066Sahrens */ 2926fa9e4066Sahrens for (i = 0; i < NCOMMAND; i++) { 2927fa9e4066Sahrens if (command_table[i].name == NULL) 2928fa9e4066Sahrens continue; 2929fa9e4066Sahrens 2930fa9e4066Sahrens if (strcmp(cmdname, command_table[i].name) == 0) { 2931fa9e4066Sahrens current_command = &command_table[i]; 2932fa9e4066Sahrens ret = command_table[i].func(argc - 1, argv + 1); 2933fa9e4066Sahrens break; 2934fa9e4066Sahrens } 2935fa9e4066Sahrens } 2936fa9e4066Sahrens 2937fa9e4066Sahrens if (i == NCOMMAND) { 2938fa9e4066Sahrens (void) fprintf(stderr, gettext("unrecognized " 2939fa9e4066Sahrens "command '%s'\n"), cmdname); 294099653d4eSeschrock usage(B_FALSE); 2941fa9e4066Sahrens } 2942fa9e4066Sahrens } 2943fa9e4066Sahrens 2944fa9e4066Sahrens (void) fclose(mnttab_file); 2945fa9e4066Sahrens 294699653d4eSeschrock libzfs_fini(g_zfs); 294799653d4eSeschrock 2948fa9e4066Sahrens /* 2949fa9e4066Sahrens * The 'ZFS_ABORT' environment variable causes us to dump core on exit 2950fa9e4066Sahrens * for the purposes of running ::findleaks. 2951fa9e4066Sahrens */ 2952fa9e4066Sahrens if (getenv("ZFS_ABORT") != NULL) { 2953fa9e4066Sahrens (void) printf("dumping core by request\n"); 2954fa9e4066Sahrens abort(); 2955fa9e4066Sahrens } 2956fa9e4066Sahrens 2957fa9e4066Sahrens return (ret); 2958fa9e4066Sahrens } 2959