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