cmd/zfs/zfs_main.c

   1 /*
   2  * CDDL HEADER START
   3  *
   4  * The contents of this file are subject to the terms of the
   5  * Common Development and Distribution License (the "License").
   6  * You may not use this file except in compliance with the License.
   7  *
   8  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
   9  * or http://www.opensolaris.org/os/licensing.
  10  * See the License for the specific language governing permissions
  11  * and limitations under the License.
  12  *
  13  * When distributing Covered Code, include this CDDL HEADER in each
  14  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
  15  * If applicable, add the following below this CDDL HEADER, with the
  16  * fields enclosed by brackets "[]" replaced with your own identifying
  17  * information: Portions Copyright [yyyy] [name of copyright owner]
  18  *
  19  * CDDL HEADER END
  20  */
  21
  22 /*
  23  * Copyright (c) 2005, 2010, Oracle and/or its affiliates. All rights reserved.
  24  */
  25
  26 #include <assert.h>
  27 #include <ctype.h>
  28 #include <errno.h>
  29 #include <libgen.h>
  30 #include <libintl.h>
  31 #include <libuutil.h>
  32 #include <libnvpair.h>
  33 #include <locale.h>
  34 #include <stddef.h>
  35 #include <stdio.h>
  36 #include <stdlib.h>
  37 #include <strings.h>
  38 #include <unistd.h>
  39 #include <fcntl.h>
  40 #include <zone.h>
  41 #include <grp.h>
  42 #include <pwd.h>
  43 #include <sys/mkdev.h>
  44 #include <sys/mntent.h>
  45 #include <sys/mnttab.h>
  46 #include <sys/mount.h>
  47 #include <sys/stat.h>
  48 #include <sys/fs/zfs.h>
  49 #include <sys/types.h>
  50 #include <time.h>
  51
  52 #include <libzfs.h>
  53 #include <libuutil.h>
  54
  55 #include "zfs_iter.h"
  56 #include "zfs_util.h"
  57 #include "zfs_comutil.h"
  58
  59 libzfs_handle_t *g_zfs;
  60
  61 static FILE *mnttab_file;
  62 static char history_str[HIS_MAX_RECORD_LEN];
  63 const char *pypath = "/usr/lib/zfs/pyzfs.py";
  64
  65 static int zfs_do_clone(int argc, char **argv);
  66 static int zfs_do_create(int argc, char **argv);
  67 static int zfs_do_destroy(int argc, char **argv);
  68 static int zfs_do_get(int argc, char **argv);
  69 static int zfs_do_inherit(int argc, char **argv);
  70 static int zfs_do_list(int argc, char **argv);
  71 static int zfs_do_mount(int argc, char **argv);
  72 static int zfs_do_rename(int argc, char **argv);
  73 static int zfs_do_rollback(int argc, char **argv);
  74 static int zfs_do_set(int argc, char **argv);
  75 static int zfs_do_upgrade(int argc, char **argv);
  76 static int zfs_do_snapshot(int argc, char **argv);
  77 static int zfs_do_unmount(int argc, char **argv);
  78 static int zfs_do_share(int argc, char **argv);
  79 static int zfs_do_unshare(int argc, char **argv);
  80 static int zfs_do_send(int argc, char **argv);
  81 static int zfs_do_receive(int argc, char **argv);
  82 static int zfs_do_promote(int argc, char **argv);
  83 static int zfs_do_userspace(int argc, char **argv);
  84 static int zfs_do_python(int argc, char **argv);
  85 static int zfs_do_hold(int argc, char **argv);
  86 static int zfs_do_release(int argc, char **argv);
  87
  88 /*
  89  * Enable a reasonable set of defaults for libumem debugging on DEBUG builds.
  90  */
  91
  92 #ifdef DEBUG
  93 const char *
  94 _umem_debug_init(void)
  95 {
  96         return ("default,verbose"); /* $UMEM_DEBUG setting */
  97 }
  98
  99 const char *
 100 _umem_logging_init(void)
 101 {
 102         return ("fail,contents"); /* $UMEM_LOGGING setting */
 103 }
 104 #endif
 105
 106 typedef enum {
 107         HELP_CLONE,
 108         HELP_CREATE,
 109         HELP_DESTROY,
 110         HELP_GET,
 111         HELP_INHERIT,
 112         HELP_UPGRADE,
 113         HELP_LIST,
 114         HELP_MOUNT,
 115         HELP_PROMOTE,
 116         HELP_RECEIVE,
 117         HELP_RENAME,
 118         HELP_ROLLBACK,
 119         HELP_SEND,
 120         HELP_SET,
 121         HELP_SHARE,
 122         HELP_SNAPSHOT,
 123         HELP_UNMOUNT,
 124         HELP_UNSHARE,
 125         HELP_ALLOW,
 126         HELP_UNALLOW,
 127         HELP_USERSPACE,
 128         HELP_GROUPSPACE,
 129         HELP_HOLD,
 130         HELP_HOLDS,
 131         HELP_RELEASE
 132 } zfs_help_t;
 133
 134 typedef struct zfs_command {
 135         const char      *name;
 136         int             (*func)(int argc, char **argv);
 137         zfs_help_t      usage;
 138 } zfs_command_t;
 139
 140 /*
 141  * Master command table.  Each ZFS command has a name, associated function, and
 142  * usage message.  The usage messages need to be internationalized, so we have
 143  * to have a function to return the usage message based on a command index.
 144  *
 145  * These commands are organized according to how they are displayed in the usage
 146  * message.  An empty command (one with a NULL name) indicates an empty line in
 147  * the generic usage message.
 148  */
 149 static zfs_command_t command_table[] = {
 150         { "create",     zfs_do_create,          HELP_CREATE             },
 151         { "destroy",    zfs_do_destroy,         HELP_DESTROY            },
 152         { NULL },
 153         { "snapshot",   zfs_do_snapshot,        HELP_SNAPSHOT           },
 154         { "rollback",   zfs_do_rollback,        HELP_ROLLBACK           },
 155         { "clone",      zfs_do_clone,           HELP_CLONE              },
 156         { "promote",    zfs_do_promote,         HELP_PROMOTE            },
 157         { "rename",     zfs_do_rename,          HELP_RENAME             },
 158         { NULL },
 159         { "list",       zfs_do_list,            HELP_LIST               },
 160         { NULL },
 161         { "set",        zfs_do_set,             HELP_SET                },
 162         { "get",        zfs_do_get,             HELP_GET                },
 163         { "inherit",    zfs_do_inherit,         HELP_INHERIT            },
 164         { "upgrade",    zfs_do_upgrade,         HELP_UPGRADE            },
 165         { "userspace",  zfs_do_userspace,       HELP_USERSPACE          },
 166         { "groupspace", zfs_do_userspace,       HELP_GROUPSPACE         },
 167         { NULL },
 168         { "mount",      zfs_do_mount,           HELP_MOUNT              },
 169         { "unmount",    zfs_do_unmount,         HELP_UNMOUNT            },
 170         { "share",      zfs_do_share,           HELP_SHARE              },
 171         { "unshare",    zfs_do_unshare,         HELP_UNSHARE            },
 172         { NULL },
 173         { "send",       zfs_do_send,            HELP_SEND               },
 174         { "receive",    zfs_do_receive,         HELP_RECEIVE            },
 175         { NULL },
 176         { "allow",      zfs_do_python,          HELP_ALLOW              },
 177         { NULL },
 178         { "unallow",    zfs_do_python,          HELP_UNALLOW            },
 179         { NULL },
 180         { "hold",       zfs_do_hold,            HELP_HOLD               },
 181         { "holds",      zfs_do_python,          HELP_HOLDS              },
 182         { "release",    zfs_do_release,         HELP_RELEASE            },
 183 };
 184
 185 #define NCOMMAND        (sizeof (command_table) / sizeof (command_table[0]))
 186
 187 zfs_command_t *current_command;
 188
 189 static const char *
 190 get_usage(zfs_help_t idx)
 191 {
 192         switch (idx) {
 193         case HELP_CLONE:
 194                 return (gettext("\tclone [-p] [-o property=value] ... "
 195                     "<snapshot> <filesystem|volume>\n"));
 196         case HELP_CREATE:
 197                 return (gettext("\tcreate [-p] [-o property=value] ... "
 198                     "<filesystem>\n"
 199                     "\tcreate [-ps] [-b blocksize] [-o property=value] ... "
 200                     "-V <size> <volume>\n"));
 201         case HELP_DESTROY:
 202                 return (gettext("\tdestroy [-rRf] <filesystem|volume>\n"
 203                     "\tdestroy [-rRd] <snapshot>\n"));
 204         case HELP_GET:
 205                 return (gettext("\tget [-rHp] [-d max] "
 206                     "[-o \"all\" | field[,...]] [-s source[,...]]\n"
 207                     "\t    <\"all\" | property[,...]> "
 208                     "[filesystem|volume|snapshot] ...\n"));
 209         case HELP_INHERIT:
 210                 return (gettext("\tinherit [-rS] <property> "
 211                     "<filesystem|volume|snapshot> ...\n"));
 212         case HELP_UPGRADE:
 213                 return (gettext("\tupgrade [-v]\n"
 214                     "\tupgrade [-r] [-V version] <-a | filesystem ...>\n"));
 215         case HELP_LIST:
 216                 return (gettext("\tlist [-rH][-d max] "
 217                     "[-o property[,...]] [-t type[,...]] [-s property] ...\n"
 218                     "\t    [-S property] ... "
 219                     "[filesystem|volume|snapshot] ...\n"));
 220         case HELP_MOUNT:
 221                 return (gettext("\tmount\n"
 222                     "\tmount [-vO] [-o opts] <-a | filesystem>\n"));
 223         case HELP_PROMOTE:
 224                 return (gettext("\tpromote <clone-filesystem>\n"));
 225         case HELP_RECEIVE:
 226                 return (gettext("\treceive [-vnFu] <filesystem|volume|"
 227                 "snapshot>\n"
 228                 "\treceive [-vnFu] [-d | -e] <filesystem>\n"));
 229         case HELP_RENAME:
 230                 return (gettext("\trename <filesystem|volume|snapshot> "
 231                     "<filesystem|volume|snapshot>\n"
 232                     "\trename -p <filesystem|volume> <filesystem|volume>\n"
 233                     "\trename -r <snapshot> <snapshot>"));
 234         case HELP_ROLLBACK:
 235                 return (gettext("\trollback [-rRf] <snapshot>\n"));
 236         case HELP_SEND:
 237                 return (gettext("\tsend [-RDp] [-[iI] snapshot] <snapshot>\n"));
 238         case HELP_SET:
 239                 return (gettext("\tset <property=value> "
 240                     "<filesystem|volume|snapshot> ...\n"));
 241         case HELP_SHARE:
 242                 return (gettext("\tshare <-a | filesystem>\n"));
 243         case HELP_SNAPSHOT:
 244                 return (gettext("\tsnapshot [-r] [-o property=value] ... "
 245                     "<filesystem@snapname|volume@snapname>\n"));
 246         case HELP_UNMOUNT:
 247                 return (gettext("\tunmount [-f] "
 248                     "<-a | filesystem|mountpoint>\n"));
 249         case HELP_UNSHARE:
 250                 return (gettext("\tunshare "
 251                     "<-a | filesystem|mountpoint>\n"));
 252         case HELP_ALLOW:
 253                 return (gettext("\tallow <filesystem|volume>\n"
 254                     "\tallow [-ldug] "
 255                     "<\"everyone\"|user|group>[,...] <perm|@setname>[,...]\n"
 256                     "\t    <filesystem|volume>\n"
 257                     "\tallow [-ld] -e <perm|@setname>[,...] "
 258                     "<filesystem|volume>\n"
 259                     "\tallow -c <perm|@setname>[,...] <filesystem|volume>\n"
 260                     "\tallow -s @setname <perm|@setname>[,...] "
 261                     "<filesystem|volume>\n"));
 262         case HELP_UNALLOW:
 263                 return (gettext("\tunallow [-rldug] "
 264                     "<\"everyone\"|user|group>[,...]\n"
 265                     "\t    [<perm|@setname>[,...]] <filesystem|volume>\n"
 266                     "\tunallow [-rld] -e [<perm|@setname>[,...]] "
 267                     "<filesystem|volume>\n"
 268                     "\tunallow [-r] -c [<perm|@setname>[,...]] "
 269                     "<filesystem|volume>\n"
 270                     "\tunallow [-r] -s @setname [<perm|@setname>[,...]] "
 271                     "<filesystem|volume>\n"));
 272         case HELP_USERSPACE:
 273                 return (gettext("\tuserspace [-hniHp] [-o field[,...]] "
 274                     "[-sS field] ... [-t type[,...]]\n"
 275                     "\t    <filesystem|snapshot>\n"));
 276         case HELP_GROUPSPACE:
 277                 return (gettext("\tgroupspace [-hniHpU] [-o field[,...]] "
 278                     "[-sS field] ... [-t type[,...]]\n"
 279                     "\t    <filesystem|snapshot>\n"));
 280         case HELP_HOLD:
 281                 return (gettext("\thold [-r] <tag> <snapshot> ...\n"));
 282         case HELP_HOLDS:
 283                 return (gettext("\tholds [-r] <snapshot> ...\n"));
 284         case HELP_RELEASE:
 285                 return (gettext("\trelease [-r] <tag> <snapshot> ...\n"));
 286         }
 287
 288         abort();
 289         /* NOTREACHED */
 290 }
 291
 292 void
 293 nomem(void)
 294 {
 295         (void) fprintf(stderr, gettext("internal error: out of memory\n"));
 296         exit(1);
 297 }
 298
 299 /*
 300  * Utility function to guarantee malloc() success.
 301  */
 302
 303 void *
 304 safe_malloc(size_t size)
 305 {
 306         void *data;
 307
 308         if ((data = calloc(1, size)) == NULL)
 309                 nomem();
 310
 311         return (data);
 312 }
 313
 314 static char *
 315 safe_strdup(char *str)
 316 {
 317         char *dupstr = strdup(str);
 318
 319         if (dupstr == NULL)
 320                 nomem();
 321
 322         return (dupstr);
 323 }
 324
 325 /*
 326  * Callback routine that will print out information for each of
 327  * the properties.
 328  */
 329 static int
 330 usage_prop_cb(int prop, void *cb)
 331 {
 332         FILE *fp = cb;
 333
 334         (void) fprintf(fp, "\t%-15s ", zfs_prop_to_name(prop));
 335
 336         if (zfs_prop_readonly(prop))
 337                 (void) fprintf(fp, " NO    ");
 338         else
 339                 (void) fprintf(fp, "YES    ");
 340
 341         if (zfs_prop_inheritable(prop))
 342                 (void) fprintf(fp, "  YES   ");
 343         else
 344                 (void) fprintf(fp, "   NO   ");
 345
 346         if (zfs_prop_values(prop) == NULL)
 347                 (void) fprintf(fp, "-\n");
 348         else
 349                 (void) fprintf(fp, "%s\n", zfs_prop_values(prop));
 350
 351         return (ZPROP_CONT);
 352 }
 353
 354 /*
 355  * Display usage message.  If we're inside a command, display only the usage for
 356  * that command.  Otherwise, iterate over the entire command table and display
 357  * a complete usage message.
 358  */
 359 static void
 360 usage(boolean_t requested)
 361 {
 362         int i;
 363         boolean_t show_properties = B_FALSE;
 364         FILE *fp = requested ? stdout : stderr;
 365
 366         if (current_command == NULL) {
 367
 368                 (void) fprintf(fp, gettext("usage: zfs command args ...\n"));
 369                 (void) fprintf(fp,
 370                     gettext("where 'command' is one of the following:\n\n"));
 371
 372                 for (i = 0; i < NCOMMAND; i++) {
 373                         if (command_table[i].name == NULL)
 374                                 (void) fprintf(fp, "\n");
 375                         else
 376                                 (void) fprintf(fp, "%s",
 377                                     get_usage(command_table[i].usage));
 378                 }
 379
 380                 (void) fprintf(fp, gettext("\nEach dataset is of the form: "
 381                     "pool/[dataset/]*dataset[@name]\n"));
 382         } else {
 383                 (void) fprintf(fp, gettext("usage:\n"));
 384                 (void) fprintf(fp, "%s", get_usage(current_command->usage));
 385         }
 386
 387         if (current_command != NULL &&
 388             (strcmp(current_command->name, "set") == 0 ||
 389             strcmp(current_command->name, "get") == 0 ||
 390             strcmp(current_command->name, "inherit") == 0 ||
 391             strcmp(current_command->name, "list") == 0))
 392                 show_properties = B_TRUE;
 393
 394         if (show_properties) {
 395                 (void) fprintf(fp,
 396                     gettext("\nThe following properties are supported:\n"));
 397
 398                 (void) fprintf(fp, "\n\t%-14s %s  %s   %s\n\n",
 399                     "PROPERTY", "EDIT", "INHERIT", "VALUES");
 400
 401                 /* Iterate over all properties */
 402                 (void) zprop_iter(usage_prop_cb, fp, B_FALSE, B_TRUE,
 403                     ZFS_TYPE_DATASET);
 404
 405                 (void) fprintf(fp, "\t%-15s ", "userused@...");
 406                 (void) fprintf(fp, " NO       NO   <size>\n");
 407                 (void) fprintf(fp, "\t%-15s ", "groupused@...");
 408                 (void) fprintf(fp, " NO       NO   <size>\n");
 409                 (void) fprintf(fp, "\t%-15s ", "userquota@...");
 410                 (void) fprintf(fp, "YES       NO   <size> | none\n");
 411                 (void) fprintf(fp, "\t%-15s ", "groupquota@...");
 412                 (void) fprintf(fp, "YES       NO   <size> | none\n");
 413
 414                 (void) fprintf(fp, gettext("\nSizes are specified in bytes "
 415                     "with standard units such as K, M, G, etc.\n"));
 416                 (void) fprintf(fp, gettext("\nUser-defined properties can "
 417                     "be specified by using a name containing a colon (:).\n"));
 418                 (void) fprintf(fp, gettext("\nThe {user|group}{used|quota}@ "
 419                     "properties must be appended with\n"
 420                     "a user or group specifier of one of these forms:\n"
 421                     "    POSIX name      (eg: \"matt\")\n"
 422                     "    POSIX id        (eg: \"126829\")\n"
 423                     "    SMB name@domain (eg: \"matt@sun\")\n"
 424                     "    SMB SID         (eg: \"S-1-234-567-89\")\n"));
 425         } else {
 426                 (void) fprintf(fp,
 427                     gettext("\nFor the property list, run: %s\n"),
 428                     "zfs set|get");
 429                 (void) fprintf(fp,
 430                     gettext("\nFor the delegated permission list, run: %s\n"),
 431                     "zfs allow|unallow");
 432         }
 433
 434         /*
 435          * See comments at end of main().
 436          */
 437         if (getenv("ZFS_ABORT") != NULL) {
 438                 (void) printf("dumping core by request\n");
 439                 abort();
 440         }
 441
 442         exit(requested ? 0 : 2);
 443 }
 444
 445 static int
 446 parseprop(nvlist_t *props)
 447 {
 448         char *propname = optarg;
 449         char *propval, *strval;
 450
 451         if ((propval = strchr(propname, '=')) == NULL) {
 452                 (void) fprintf(stderr, gettext("missing "
 453                     "'=' for -o option\n"));
 454                 return (-1);
 455         }
 456         *propval = '\0';
 457         propval++;
 458         if (nvlist_lookup_string(props, propname, &strval) == 0) {
 459                 (void) fprintf(stderr, gettext("property '%s' "
 460                     "specified multiple times\n"), propname);
 461                 return (-1);
 462         }
 463         if (nvlist_add_string(props, propname, propval) != 0)
 464                 nomem();
 465         return (0);
 466 }
 467
 468 static int
 469 parse_depth(char *opt, int *flags)
 470 {
 471         char *tmp;
 472         int depth;
 473
 474         depth = (int)strtol(opt, &tmp, 0);
 475         if (*tmp) {
 476                 (void) fprintf(stderr,
 477                     gettext("%s is not an integer\n"), optarg);
 478                 usage(B_FALSE);
 479         }
 480         if (depth < 0) {
 481                 (void) fprintf(stderr,
 482                     gettext("Depth can not be negative.\n"));
 483                 usage(B_FALSE);
 484         }
 485         *flags |= (ZFS_ITER_DEPTH_LIMIT|ZFS_ITER_RECURSE);
 486         return (depth);
 487 }
 488
 489 #define PROGRESS_DELAY 2                /* seconds */
 490
 491 static char *pt_reverse = "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b";
 492 static time_t pt_begin;
 493 static char *pt_header = NULL;
 494 static boolean_t pt_shown;
 495
 496 static void
 497 start_progress_timer(void)
 498 {
 499         pt_begin = time(NULL) + PROGRESS_DELAY;
 500         pt_shown = B_FALSE;
 501 }
 502
 503 static void
 504 set_progress_header(char *header)
 505 {
 506         assert(pt_header == NULL);
 507         pt_header = safe_strdup(header);
 508         if (pt_shown) {
 509                 (void) printf("%s: ", header);
 510                 (void) fflush(stdout);
 511         }
 512 }
 513
 514 static void
 515 update_progress(char *update)
 516 {
 517         if (!pt_shown && time(NULL) > pt_begin) {
 518                 int len = strlen(update);
 519
 520                 (void) printf("%s: %s%*.*s", pt_header, update, len, len,
 521                     pt_reverse);
 522                 (void) fflush(stdout);
 523                 pt_shown = B_TRUE;
 524         } else if (pt_shown) {
 525                 int len = strlen(update);
 526
 527                 (void) printf("%s%*.*s", update, len, len, pt_reverse);
 528                 (void) fflush(stdout);
 529         }
 530 }
 531
 532 static void
 533 finish_progress(char *done)
 534 {
 535         if (pt_shown) {
 536                 (void) printf("%s\n", done);
 537                 (void) fflush(stdout);
 538         }
 539         free(pt_header);
 540         pt_header = NULL;
 541 }
 542 /*
 543  * zfs clone [-p] [-o prop=value] ... <snap> <fs | vol>
 544  *
 545  * Given an existing dataset, create a writable copy whose initial contents
 546  * are the same as the source.  The newly created dataset maintains a
 547  * dependency on the original; the original cannot be destroyed so long as
 548  * the clone exists.
 549  *
 550  * The '-p' flag creates all the non-existing ancestors of the target first.
 551  */
 552 static int
 553 zfs_do_clone(int argc, char **argv)
 554 {
 555         zfs_handle_t *zhp = NULL;
 556         boolean_t parents = B_FALSE;
 557         nvlist_t *props;
 558         int ret;
 559         int c;
 560
 561         if (nvlist_alloc(&props, NV_UNIQUE_NAME, 0) != 0)
 562                 nomem();
 563
 564         /* check options */
 565         while ((c = getopt(argc, argv, "o:p")) != -1) {
 566                 switch (c) {
 567                 case 'o':
 568                         if (parseprop(props))
 569                                 return (1);
 570                         break;
 571                 case 'p':
 572                         parents = B_TRUE;
 573                         break;
 574                 case '?':
 575                         (void) fprintf(stderr, gettext("invalid option '%c'\n"),
 576                             optopt);
 577                         goto usage;
 578                 }
 579         }
 580
 581         argc -= optind;
 582         argv += optind;
 583
 584         /* check number of arguments */
 585         if (argc < 1) {
 586                 (void) fprintf(stderr, gettext("missing source dataset "
 587                     "argument\n"));
 588                 goto usage;
 589         }
 590         if (argc < 2) {
 591                 (void) fprintf(stderr, gettext("missing target dataset "
 592                     "argument\n"));
 593                 goto usage;
 594         }
 595         if (argc > 2) {
 596                 (void) fprintf(stderr, gettext("too many arguments\n"));
 597                 goto usage;
 598         }
 599
 600         /* open the source dataset */
 601         if ((zhp = zfs_open(g_zfs, argv[0], ZFS_TYPE_SNAPSHOT)) == NULL)
 602                 return (1);
 603
 604         if (parents && zfs_name_valid(argv[1], ZFS_TYPE_FILESYSTEM |
 605             ZFS_TYPE_VOLUME)) {
 606                 /*
 607                  * Now create the ancestors of the target dataset.  If the
 608                  * target already exists and '-p' option was used we should not
 609                  * complain.
 610                  */
 611                 if (zfs_dataset_exists(g_zfs, argv[1], ZFS_TYPE_FILESYSTEM |
 612                     ZFS_TYPE_VOLUME))
 613                         return (0);
 614                 if (zfs_create_ancestors(g_zfs, argv[1]) != 0)
 615                         return (1);
 616         }
 617
 618         /* pass to libzfs */
 619         ret = zfs_clone(zhp, argv[1], props);
 620
 621         /* create the mountpoint if necessary */
 622         if (ret == 0) {
 623                 zfs_handle_t *clone;
 624
 625                 clone = zfs_open(g_zfs, argv[1], ZFS_TYPE_DATASET);
 626                 if (clone != NULL) {
 627                         if ((ret = zfs_mount(clone, NULL, 0)) == 0)
 628                                 ret = zfs_share(clone);
 629                         zfs_close(clone);
 630                 }
 631         }
 632
 633         zfs_close(zhp);
 634         nvlist_free(props);
 635
 636         return (!!ret);
 637
 638 usage:
 639         if (zhp)
 640                 zfs_close(zhp);
 641         nvlist_free(props);
 642         usage(B_FALSE);
 643         return (-1);
 644 }
 645
 646 /*
 647  * zfs create [-p] [-o prop=value] ... fs
 648  * zfs create [-ps] [-b blocksize] [-o prop=value] ... -V vol size
 649  *
 650  * Create a new dataset.  This command can be used to create filesystems
 651  * and volumes.  Snapshot creation is handled by 'zfs snapshot'.
 652  * For volumes, the user must specify a size to be used.
 653  *
 654  * The '-s' flag applies only to volumes, and indicates that we should not try
 655  * to set the reservation for this volume.  By default we set a reservation
 656  * equal to the size for any volume.  For pools with SPA_VERSION >=
 657  * SPA_VERSION_REFRESERVATION, we set a refreservation instead.
 658  *
 659  * The '-p' flag creates all the non-existing ancestors of the target first.
 660  */
 661 static int
 662 zfs_do_create(int argc, char **argv)
 663 {
 664         zfs_type_t type = ZFS_TYPE_FILESYSTEM;
 665         zfs_handle_t *zhp = NULL;
 666         uint64_t volsize;
 667         int c;
 668         boolean_t noreserve = B_FALSE;
 669         boolean_t bflag = B_FALSE;
 670         boolean_t parents = B_FALSE;
 671         int ret = 1;
 672         nvlist_t *props;
 673         uint64_t intval;
 674         int canmount;
 675
 676         if (nvlist_alloc(&props, NV_UNIQUE_NAME, 0) != 0)
 677                 nomem();
 678
 679         /* check options */
 680         while ((c = getopt(argc, argv, ":V:b:so:p")) != -1) {
 681                 switch (c) {
 682                 case 'V':
 683                         type = ZFS_TYPE_VOLUME;
 684                         if (zfs_nicestrtonum(g_zfs, optarg, &intval) != 0) {
 685                                 (void) fprintf(stderr, gettext("bad volume "
 686                                     "size '%s': %s\n"), optarg,
 687                                     libzfs_error_description(g_zfs));
 688                                 goto error;
 689                         }
 690
 691                         if (nvlist_add_uint64(props,
 692                             zfs_prop_to_name(ZFS_PROP_VOLSIZE), intval) != 0)
 693                                 nomem();
 694                         volsize = intval;
 695                         break;
 696                 case 'p':
 697                         parents = B_TRUE;
 698                         break;
 699                 case 'b':
 700                         bflag = B_TRUE;
 701                         if (zfs_nicestrtonum(g_zfs, optarg, &intval) != 0) {
 702                                 (void) fprintf(stderr, gettext("bad volume "
 703                                     "block size '%s': %s\n"), optarg,
 704                                     libzfs_error_description(g_zfs));
 705                                 goto error;
 706                         }
 707
 708                         if (nvlist_add_uint64(props,
 709                             zfs_prop_to_name(ZFS_PROP_VOLBLOCKSIZE),
 710                             intval) != 0)
 711                                 nomem();
 712                         break;
 713                 case 'o':
 714                         if (parseprop(props))
 715                                 goto error;
 716                         break;
 717                 case 's':
 718                         noreserve = B_TRUE;
 719                         break;
 720                 case ':':
 721                         (void) fprintf(stderr, gettext("missing size "
 722                             "argument\n"));
 723                         goto badusage;
 724                         break;
 725                 case '?':
 726                         (void) fprintf(stderr, gettext("invalid option '%c'\n"),
 727                             optopt);
 728                         goto badusage;
 729                 }
 730         }
 731
 732         if ((bflag || noreserve) && type != ZFS_TYPE_VOLUME) {
 733                 (void) fprintf(stderr, gettext("'-s' and '-b' can only be "
 734                     "used when creating a volume\n"));
 735                 goto badusage;
 736         }
 737
 738         argc -= optind;
 739         argv += optind;
 740
 741         /* check number of arguments */
 742         if (argc == 0) {
 743                 (void) fprintf(stderr, gettext("missing %s argument\n"),
 744                     zfs_type_to_name(type));
 745                 goto badusage;
 746         }
 747         if (argc > 1) {
 748                 (void) fprintf(stderr, gettext("too many arguments\n"));
 749                 goto badusage;
 750         }
 751
 752         if (type == ZFS_TYPE_VOLUME && !noreserve) {
 753                 zpool_handle_t *zpool_handle;
 754                 uint64_t spa_version;
 755                 char *p;
 756                 zfs_prop_t resv_prop;
 757                 char *strval;
 758
 759                 if (p = strchr(argv[0], '/'))
 760                         *p = '\0';
 761                 zpool_handle = zpool_open(g_zfs, argv[0]);
 762                 if (p != NULL)
 763                         *p = '/';
 764                 if (zpool_handle == NULL)
 765                         goto error;
 766                 spa_version = zpool_get_prop_int(zpool_handle,
 767                     ZPOOL_PROP_VERSION, NULL);
 768                 zpool_close(zpool_handle);
 769                 if (spa_version >= SPA_VERSION_REFRESERVATION)
 770                         resv_prop = ZFS_PROP_REFRESERVATION;
 771                 else
 772                         resv_prop = ZFS_PROP_RESERVATION;
 773                 volsize = zvol_volsize_to_reservation(volsize, props);
 774
 775                 if (nvlist_lookup_string(props, zfs_prop_to_name(resv_prop),
 776                     &strval) != 0) {
 777                         if (nvlist_add_uint64(props,
 778                             zfs_prop_to_name(resv_prop), volsize) != 0) {
 779                                 nvlist_free(props);
 780                                 nomem();
 781                         }
 782                 }
 783         }
 784
 785         if (parents && zfs_name_valid(argv[0], type)) {
 786                 /*
 787                  * Now create the ancestors of target dataset.  If the target
 788                  * already exists and '-p' option was used we should not
 789                  * complain.
 790                  */
 791                 if (zfs_dataset_exists(g_zfs, argv[0], type)) {
 792                         ret = 0;
 793                         goto error;
 794                 }
 795                 if (zfs_create_ancestors(g_zfs, argv[0]) != 0)
 796                         goto error;
 797         }
 798
 799         /* pass to libzfs */
 800         if (zfs_create(g_zfs, argv[0], type, props) != 0)
 801                 goto error;
 802
 803         if ((zhp = zfs_open(g_zfs, argv[0], ZFS_TYPE_DATASET)) == NULL)
 804                 goto error;
 805         /*
 806          * if the user doesn't want the dataset automatically mounted,
 807          * then skip the mount/share step
 808          */
 809
 810         canmount = zfs_prop_get_int(zhp, ZFS_PROP_CANMOUNT);
 811
 812         /*
 813          * Mount and/or share the new filesystem as appropriate.  We provide a
 814          * verbose error message to let the user know that their filesystem was
 815          * in fact created, even if we failed to mount or share it.
 816          */
 817         ret = 0;
 818         if (canmount == ZFS_CANMOUNT_ON) {
 819                 if (zfs_mount(zhp, NULL, 0) != 0) {
 820                         (void) fprintf(stderr, gettext("filesystem "
 821                             "successfully created, but not mounted\n"));
 822                         ret = 1;
 823                 } else if (zfs_share(zhp) != 0) {
 824                         (void) fprintf(stderr, gettext("filesystem "
 825                             "successfully created, but not shared\n"));
 826                         ret = 1;
 827                 }
 828         }
 829
 830 error:
 831         if (zhp)
 832                 zfs_close(zhp);
 833         nvlist_free(props);
 834         return (ret);
 835 badusage:
 836         nvlist_free(props);
 837         usage(B_FALSE);
 838         return (2);
 839 }
 840
 841 /*
 842  * zfs destroy [-rRf] <fs, vol>
 843  * zfs destroy [-rRd] <snap>
 844  *
 845  *      -r      Recursively destroy all children
 846  *      -R      Recursively destroy all dependents, including clones
 847  *      -f      Force unmounting of any dependents
 848  *      -d      If we can't destroy now, mark for deferred destruction
 849  *
 850  * Destroys the given dataset.  By default, it will unmount any filesystems,
 851  * and refuse to destroy a dataset that has any dependents.  A dependent can
 852  * either be a child, or a clone of a child.
 853  */
 854 typedef struct destroy_cbdata {
 855         boolean_t       cb_first;
 856         int             cb_force;
 857         int             cb_recurse;
 858         int             cb_error;
 859         int             cb_needforce;
 860         int             cb_doclones;
 861         boolean_t       cb_closezhp;
 862         zfs_handle_t    *cb_target;
 863         char            *cb_snapname;
 864         boolean_t       cb_defer_destroy;
 865 } destroy_cbdata_t;
 866
 867 /*
 868  * Check for any dependents based on the '-r' or '-R' flags.
 869  */
 870 static int
 871 destroy_check_dependent(zfs_handle_t *zhp, void *data)
 872 {
 873         destroy_cbdata_t *cbp = data;
 874         const char *tname = zfs_get_name(cbp->cb_target);
 875         const char *name = zfs_get_name(zhp);
 876
 877         if (strncmp(tname, name, strlen(tname)) == 0 &&
 878             (name[strlen(tname)] == '/' || name[strlen(tname)] == '@')) {
 879                 /*
 880                  * This is a direct descendant, not a clone somewhere else in
 881                  * the hierarchy.
 882                  */
 883                 if (cbp->cb_recurse)
 884                         goto out;
 885
 886                 if (cbp->cb_first) {
 887                         (void) fprintf(stderr, gettext("cannot destroy '%s': "
 888                             "%s has children\n"),
 889                             zfs_get_name(cbp->cb_target),
 890                             zfs_type_to_name(zfs_get_type(cbp->cb_target)));
 891                         (void) fprintf(stderr, gettext("use '-r' to destroy "
 892                             "the following datasets:\n"));
 893                         cbp->cb_first = B_FALSE;
 894                         cbp->cb_error = 1;
 895                 }
 896
 897                 (void) fprintf(stderr, "%s\n", zfs_get_name(zhp));
 898         } else {
 899                 /*
 900                  * This is a clone.  We only want to report this if the '-r'
 901                  * wasn't specified, or the target is a snapshot.
 902                  */
 903                 if (!cbp->cb_recurse &&
 904                     zfs_get_type(cbp->cb_target) != ZFS_TYPE_SNAPSHOT)
 905                         goto out;
 906
 907                 if (cbp->cb_first) {
 908                         (void) fprintf(stderr, gettext("cannot destroy '%s': "
 909                             "%s has dependent clones\n"),
 910                             zfs_get_name(cbp->cb_target),
 911                             zfs_type_to_name(zfs_get_type(cbp->cb_target)));
 912                         (void) fprintf(stderr, gettext("use '-R' to destroy "
 913                             "the following datasets:\n"));
 914                         cbp->cb_first = B_FALSE;
 915                         cbp->cb_error = 1;
 916                 }
 917
 918                 (void) fprintf(stderr, "%s\n", zfs_get_name(zhp));
 919         }
 920
 921 out:
 922         zfs_close(zhp);
 923         return (0);
 924 }
 925
 926 static int
 927 destroy_callback(zfs_handle_t *zhp, void *data)
 928 {
 929         destroy_cbdata_t *cbp = data;
 930
 931         /*
 932          * Ignore pools (which we've already flagged as an error before getting
 933          * here).
 934          */
 935         if (strchr(zfs_get_name(zhp), '/') == NULL &&
 936             zfs_get_type(zhp) == ZFS_TYPE_FILESYSTEM) {
 937                 zfs_close(zhp);
 938                 return (0);
 939         }
 940
 941         /*
 942          * Bail out on the first error.
 943          */
 944         if (zfs_unmount(zhp, NULL, cbp->cb_force ? MS_FORCE : 0) != 0 ||
 945             zfs_destroy(zhp, cbp->cb_defer_destroy) != 0) {
 946                 zfs_close(zhp);
 947                 return (-1);
 948         }
 949
 950         zfs_close(zhp);
 951         return (0);
 952 }
 953
 954 static int
 955 destroy_snap_clones(zfs_handle_t *zhp, void *arg)
 956 {
 957         destroy_cbdata_t *cbp = arg;
 958         char thissnap[MAXPATHLEN];
 959         zfs_handle_t *szhp;
 960         boolean_t closezhp = cbp->cb_closezhp;
 961         int rv;
 962
 963         (void) snprintf(thissnap, sizeof (thissnap),
 964             "%s@%s", zfs_get_name(zhp), cbp->cb_snapname);
 965
 966         libzfs_print_on_error(g_zfs, B_FALSE);
 967         szhp = zfs_open(g_zfs, thissnap, ZFS_TYPE_SNAPSHOT);
 968         libzfs_print_on_error(g_zfs, B_TRUE);
 969         if (szhp) {
 970                 /*
 971                  * Destroy any clones of this snapshot
 972                  */
 973                 if (zfs_iter_dependents(szhp, B_FALSE, destroy_callback,
 974                     cbp) != 0) {
 975                         zfs_close(szhp);
 976                         if (closezhp)
 977                                 zfs_close(zhp);
 978                         return (-1);
 979                 }
 980                 zfs_close(szhp);
 981         }
 982
 983         cbp->cb_closezhp = B_TRUE;
 984         rv = zfs_iter_filesystems(zhp, destroy_snap_clones, arg);
 985         if (closezhp)
 986                 zfs_close(zhp);
 987         return (rv);
 988 }
 989
 990 static int
 991 zfs_do_destroy(int argc, char **argv)
 992 {
 993         destroy_cbdata_t cb = { 0 };
 994         int c;
 995         zfs_handle_t *zhp;
 996         char *cp;
 997         zfs_type_t type = ZFS_TYPE_DATASET;
 998
 999         /* check options */
1000         while ((c = getopt(argc, argv, "dfrR")) != -1) {
1001                 switch (c) {
1002                 case 'd':
1003                         cb.cb_defer_destroy = B_TRUE;
1004                         type = ZFS_TYPE_SNAPSHOT;
1005                         break;
1006                 case 'f':
1007                         cb.cb_force = 1;
1008                         break;
1009                 case 'r':
1010                         cb.cb_recurse = 1;
1011                         break;
1012                 case 'R':
1013                         cb.cb_recurse = 1;
1014                         cb.cb_doclones = 1;
1015                         break;
1016                 case '?':
1017                 default:
1018                         (void) fprintf(stderr, gettext("invalid option '%c'\n"),
1019                             optopt);
1020                         usage(B_FALSE);
1021                 }
1022         }
1023
1024         argc -= optind;
1025         argv += optind;
1026
1027         /* check number of arguments */
1028         if (argc == 0) {
1029                 (void) fprintf(stderr, gettext("missing path argument\n"));
1030                 usage(B_FALSE);
1031         }
1032         if (argc > 1) {
1033                 (void) fprintf(stderr, gettext("too many arguments\n"));
1034                 usage(B_FALSE);
1035         }
1036
1037         /*
1038          * If we are doing recursive destroy of a snapshot, then the
1039          * named snapshot may not exist.  Go straight to libzfs.
1040          */
1041         if (cb.cb_recurse && (cp = strchr(argv[0], '@'))) {
1042                 int ret;
1043
1044                 *cp = '\0';
1045                 if ((zhp = zfs_open(g_zfs, argv[0], ZFS_TYPE_DATASET)) == NULL)
1046                         return (1);
1047                 *cp = '@';
1048                 cp++;
1049
1050                 if (cb.cb_doclones) {
1051                         boolean_t defer = cb.cb_defer_destroy;
1052
1053                         /*
1054                          * Temporarily ignore the defer_destroy setting since
1055                          * it's not supported for clones.
1056                          */
1057                         cb.cb_defer_destroy = B_FALSE;
1058                         cb.cb_snapname = cp;
1059                         if (destroy_snap_clones(zhp, &cb) != 0) {
1060                                 zfs_close(zhp);
1061                                 return (1);
1062                         }
1063                         cb.cb_defer_destroy = defer;
1064                 }
1065
1066                 ret = zfs_destroy_snaps(zhp, cp, cb.cb_defer_destroy);
1067                 zfs_close(zhp);
1068                 if (ret) {
1069                         (void) fprintf(stderr,
1070                             gettext("no snapshots destroyed\n"));
1071                 }
1072                 return (ret != 0);
1073         }
1074
1075         /* Open the given dataset */
1076         if ((zhp = zfs_open(g_zfs, argv[0], type)) == NULL)
1077                 return (1);
1078
1079         cb.cb_target = zhp;
1080
1081         /*
1082          * Perform an explicit check for pools before going any further.
1083          */
1084         if (!cb.cb_recurse && strchr(zfs_get_name(zhp), '/') == NULL &&
1085             zfs_get_type(zhp) == ZFS_TYPE_FILESYSTEM) {
1086                 (void) fprintf(stderr, gettext("cannot destroy '%s': "
1087                     "operation does not apply to pools\n"),
1088                     zfs_get_name(zhp));
1089                 (void) fprintf(stderr, gettext("use 'zfs destroy -r "
1090                     "%s' to destroy all datasets in the pool\n"),
1091                     zfs_get_name(zhp));
1092                 (void) fprintf(stderr, gettext("use 'zpool destroy %s' "
1093                     "to destroy the pool itself\n"), zfs_get_name(zhp));
1094                 zfs_close(zhp);
1095                 return (1);
1096         }
1097
1098         /*
1099          * Check for any dependents and/or clones.
1100          */
1101         cb.cb_first = B_TRUE;
1102         if (!cb.cb_doclones && !cb.cb_defer_destroy &&
1103             zfs_iter_dependents(zhp, B_TRUE, destroy_check_dependent,
1104             &cb) != 0) {
1105                 zfs_close(zhp);
1106                 return (1);
1107         }
1108
1109         if (cb.cb_error || (!cb.cb_defer_destroy &&
1110             (zfs_iter_dependents(zhp, B_FALSE, destroy_callback, &cb) != 0))) {
1111                 zfs_close(zhp);
1112                 return (1);
1113         }
1114
1115         /*
1116          * Do the real thing.  The callback will close the handle regardless of
1117          * whether it succeeds or not.
1118          */
1119
1120         if (destroy_callback(zhp, &cb) != 0)
1121                 return (1);
1122
1123         return (0);
1124 }
1125
1126 static boolean_t
1127 is_recvd_column(zprop_get_cbdata_t *cbp)
1128 {
1129         int i;
1130         zfs_get_column_t col;
1131
1132         for (i = 0; i < ZFS_GET_NCOLS &&
1133             (col = cbp->cb_columns[i]) != GET_COL_NONE; i++)
1134                 if (col == GET_COL_RECVD)
1135                         return (B_TRUE);
1136         return (B_FALSE);
1137 }
1138
1139 /*
1140  * zfs get [-rHp] [-o all | field[,field]...] [-s source[,source]...]
1141  *      < all | property[,property]... > < fs | snap | vol > ...
1142  *
1143  *      -r      recurse over any child datasets
1144  *      -H      scripted mode.  Headers are stripped, and fields are separated
1145  *              by tabs instead of spaces.
1146  *      -o      Set of fields to display.  One of "name,property,value,
1147  *              received,source". Default is "name,property,value,source".
1148  *              "all" is an alias for all five.
1149  *      -s      Set of sources to allow.  One of
1150  *              "local,default,inherited,received,temporary,none".  Default is
1151  *              all six.
1152  *      -p      Display values in parsable (literal) format.
1153  *
1154  *  Prints properties for the given datasets.  The user can control which
1155  *  columns to display as well as which property types to allow.
1156  */
1157
1158 /*
1159  * Invoked to display the properties for a single dataset.
1160  */
1161 static int
1162 get_callback(zfs_handle_t *zhp, void *data)
1163 {
1164         char buf[ZFS_MAXPROPLEN];
1165         char rbuf[ZFS_MAXPROPLEN];
1166         zprop_source_t sourcetype;
1167         char source[ZFS_MAXNAMELEN];
1168         zprop_get_cbdata_t *cbp = data;
1169         nvlist_t *user_props = zfs_get_user_props(zhp);
1170         zprop_list_t *pl = cbp->cb_proplist;
1171         nvlist_t *propval;
1172         char *strval;
1173         char *sourceval;
1174         boolean_t received = is_recvd_column(cbp);
1175
1176         for (; pl != NULL; pl = pl->pl_next) {
1177                 char *recvdval = NULL;
1178                 /*
1179                  * Skip the special fake placeholder.  This will also skip over
1180                  * the name property when 'all' is specified.
1181                  */
1182                 if (pl->pl_prop == ZFS_PROP_NAME &&
1183                     pl == cbp->cb_proplist)
1184                         continue;
1185
1186                 if (pl->pl_prop != ZPROP_INVAL) {
1187                         if (zfs_prop_get(zhp, pl->pl_prop, buf,
1188                             sizeof (buf), &sourcetype, source,
1189                             sizeof (source),
1190                             cbp->cb_literal) != 0) {
1191                                 if (pl->pl_all)
1192                                         continue;
1193                                 if (!zfs_prop_valid_for_type(pl->pl_prop,
1194                                     ZFS_TYPE_DATASET)) {
1195                                         (void) fprintf(stderr,
1196                                             gettext("No such property '%s'\n"),
1197                                             zfs_prop_to_name(pl->pl_prop));
1198                                         continue;
1199                                 }
1200                                 sourcetype = ZPROP_SRC_NONE;
1201                                 (void) strlcpy(buf, "-", sizeof (buf));
1202                         }
1203
1204                         if (received && (zfs_prop_get_recvd(zhp,
1205                             zfs_prop_to_name(pl->pl_prop), rbuf, sizeof (rbuf),
1206                             cbp->cb_literal) == 0))
1207                                 recvdval = rbuf;
1208
1209                         zprop_print_one_property(zfs_get_name(zhp), cbp,
1210                             zfs_prop_to_name(pl->pl_prop),
1211                             buf, sourcetype, source, recvdval);
1212                 } else if (zfs_prop_userquota(pl->pl_user_prop)) {
1213                         sourcetype = ZPROP_SRC_LOCAL;
1214
1215                         if (zfs_prop_get_userquota(zhp, pl->pl_user_prop,
1216                             buf, sizeof (buf), cbp->cb_literal) != 0) {
1217                                 sourcetype = ZPROP_SRC_NONE;
1218                                 (void) strlcpy(buf, "-", sizeof (buf));
1219                         }
1220
1221                         zprop_print_one_property(zfs_get_name(zhp), cbp,
1222                             pl->pl_user_prop, buf, sourcetype, source, NULL);
1223                 } else {
1224                         if (nvlist_lookup_nvlist(user_props,
1225                             pl->pl_user_prop, &propval) != 0) {
1226                                 if (pl->pl_all)
1227                                         continue;
1228                                 sourcetype = ZPROP_SRC_NONE;
1229                                 strval = "-";
1230                         } else {
1231                                 verify(nvlist_lookup_string(propval,
1232                                     ZPROP_VALUE, &strval) == 0);
1233                                 verify(nvlist_lookup_string(propval,
1234                                     ZPROP_SOURCE, &sourceval) == 0);
1235
1236                                 if (strcmp(sourceval,
1237                                     zfs_get_name(zhp)) == 0) {
1238                                         sourcetype = ZPROP_SRC_LOCAL;
1239                                 } else if (strcmp(sourceval,
1240                                     ZPROP_SOURCE_VAL_RECVD) == 0) {
1241                                         sourcetype = ZPROP_SRC_RECEIVED;
1242                                 } else {
1243                                         sourcetype = ZPROP_SRC_INHERITED;
1244                                         (void) strlcpy(source,
1245                                             sourceval, sizeof (source));
1246                                 }
1247                         }
1248
1249                         if (received && (zfs_prop_get_recvd(zhp,
1250                             pl->pl_user_prop, rbuf, sizeof (rbuf),
1251                             cbp->cb_literal) == 0))
1252                                 recvdval = rbuf;
1253
1254                         zprop_print_one_property(zfs_get_name(zhp), cbp,
1255                             pl->pl_user_prop, strval, sourcetype,
1256                             source, recvdval);
1257                 }
1258         }
1259
1260         return (0);
1261 }
1262
1263 static int
1264 zfs_do_get(int argc, char **argv)
1265 {
1266         zprop_get_cbdata_t cb = { 0 };
1267         int i, c, flags = 0;
1268         char *value, *fields;
1269         int ret;
1270         int limit = 0;
1271         zprop_list_t fake_name = { 0 };
1272
1273         /*
1274          * Set up default columns and sources.
1275          */
1276         cb.cb_sources = ZPROP_SRC_ALL;
1277         cb.cb_columns[0] = GET_COL_NAME;
1278         cb.cb_columns[1] = GET_COL_PROPERTY;
1279         cb.cb_columns[2] = GET_COL_VALUE;
1280         cb.cb_columns[3] = GET_COL_SOURCE;
1281         cb.cb_type = ZFS_TYPE_DATASET;
1282
1283         /* check options */
1284         while ((c = getopt(argc, argv, ":d:o:s:rHp")) != -1) {
1285                 switch (c) {
1286                 case 'p':
1287                         cb.cb_literal = B_TRUE;
1288                         break;
1289                 case 'd':
1290                         limit = parse_depth(optarg, &flags);
1291                         break;
1292                 case 'r':
1293                         flags |= ZFS_ITER_RECURSE;
1294                         break;
1295                 case 'H':
1296                         cb.cb_scripted = B_TRUE;
1297                         break;
1298                 case ':':
1299                         (void) fprintf(stderr, gettext("missing argument for "
1300                             "'%c' option\n"), optopt);
1301                         usage(B_FALSE);
1302                         break;
1303                 case 'o':
1304                         /*
1305                          * Process the set of columns to display.  We zero out
1306                          * the structure to give us a blank slate.
1307                          */
1308                         bzero(&cb.cb_columns, sizeof (cb.cb_columns));
1309                         i = 0;
1310                         while (*optarg != '\0') {
1311                                 static char *col_subopts[] =
1312                                     { "name", "property", "value", "received",
1313                                     "source", "all", NULL };
1314
1315                                 if (i == ZFS_GET_NCOLS) {
1316                                         (void) fprintf(stderr, gettext("too "
1317                                             "many fields given to -o "
1318                                             "option\n"));
1319                                         usage(B_FALSE);
1320                                 }
1321
1322                                 switch (getsubopt(&optarg, col_subopts,
1323                                     &value)) {
1324                                 case 0:
1325                                         cb.cb_columns[i++] = GET_COL_NAME;
1326                                         break;
1327                                 case 1:
1328                                         cb.cb_columns[i++] = GET_COL_PROPERTY;
1329                                         break;
1330                                 case 2:
1331                                         cb.cb_columns[i++] = GET_COL_VALUE;
1332                                         break;
1333                                 case 3:
1334                                         cb.cb_columns[i++] = GET_COL_RECVD;
1335                                         flags |= ZFS_ITER_RECVD_PROPS;
1336                                         break;
1337                                 case 4:
1338                                         cb.cb_columns[i++] = GET_COL_SOURCE;
1339                                         break;
1340                                 case 5:
1341                                         if (i > 0) {
1342                                                 (void) fprintf(stderr,
1343                                                     gettext("\"all\" conflicts "
1344                                                     "with specific fields "
1345                                                     "given to -o option\n"));
1346                                                 usage(B_FALSE);
1347                                         }
1348                                         cb.cb_columns[0] = GET_COL_NAME;
1349                                         cb.cb_columns[1] = GET_COL_PROPERTY;
1350                                         cb.cb_columns[2] = GET_COL_VALUE;
1351                                         cb.cb_columns[3] = GET_COL_RECVD;
1352                                         cb.cb_columns[4] = GET_COL_SOURCE;
1353                                         flags |= ZFS_ITER_RECVD_PROPS;
1354                                         i = ZFS_GET_NCOLS;
1355                                         break;
1356                                 default:
1357                                         (void) fprintf(stderr,
1358                                             gettext("invalid column name "
1359                                             "'%s'\n"), value);
1360                                         usage(B_FALSE);
1361                                 }
1362                         }
1363                         break;
1364
1365                 case 's':
1366                         cb.cb_sources = 0;
1367                         while (*optarg != '\0') {
1368                                 static char *source_subopts[] = {
1369                                         "local", "default", "inherited",
1370                                         "received", "temporary", "none",
1371                                         NULL };
1372
1373                                 switch (getsubopt(&optarg, source_subopts,
1374                                     &value)) {
1375                                 case 0:
1376                                         cb.cb_sources |= ZPROP_SRC_LOCAL;
1377                                         break;
1378                                 case 1:
1379                                         cb.cb_sources |= ZPROP_SRC_DEFAULT;
1380                                         break;
1381                                 case 2:
1382                                         cb.cb_sources |= ZPROP_SRC_INHERITED;
1383                                         break;
1384                                 case 3:
1385                                         cb.cb_sources |= ZPROP_SRC_RECEIVED;
1386                                         break;
1387                                 case 4:
1388                                         cb.cb_sources |= ZPROP_SRC_TEMPORARY;
1389                                         break;
1390                                 case 5:
1391                                         cb.cb_sources |= ZPROP_SRC_NONE;
1392                                         break;
1393                                 default:
1394                                         (void) fprintf(stderr,
1395                                             gettext("invalid source "
1396                                             "'%s'\n"), value);
1397                                         usage(B_FALSE);
1398                                 }
1399                         }
1400                         break;
1401
1402                 case '?':
1403                         (void) fprintf(stderr, gettext("invalid option '%c'\n"),
1404                             optopt);
1405                         usage(B_FALSE);
1406                 }
1407         }
1408
1409         argc -= optind;
1410         argv += optind;
1411
1412         if (argc < 1) {
1413                 (void) fprintf(stderr, gettext("missing property "
1414                     "argument\n"));
1415                 usage(B_FALSE);
1416         }
1417
1418         fields = argv[0];
1419
1420         if (zprop_get_list(g_zfs, fields, &cb.cb_proplist, ZFS_TYPE_DATASET)
1421             != 0)
1422                 usage(B_FALSE);
1423
1424         argc--;
1425         argv++;
1426
1427         /*
1428          * As part of zfs_expand_proplist(), we keep track of the maximum column
1429          * width for each property.  For the 'NAME' (and 'SOURCE') columns, we
1430          * need to know the maximum name length.  However, the user likely did
1431          * not specify 'name' as one of the properties to fetch, so we need to
1432          * make sure we always include at least this property for
1433          * print_get_headers() to work properly.
1434          */
1435         if (cb.cb_proplist != NULL) {
1436                 fake_name.pl_prop = ZFS_PROP_NAME;
1437                 fake_name.pl_width = strlen(gettext("NAME"));
1438                 fake_name.pl_next = cb.cb_proplist;
1439                 cb.cb_proplist = &fake_name;
1440         }
1441
1442         cb.cb_first = B_TRUE;
1443
1444         /* run for each object */
1445         ret = zfs_for_each(argc, argv, flags, ZFS_TYPE_DATASET, NULL,
1446             &cb.cb_proplist, limit, get_callback, &cb);
1447
1448         if (cb.cb_proplist == &fake_name)
1449                 zprop_free_list(fake_name.pl_next);
1450         else
1451                 zprop_free_list(cb.cb_proplist);
1452
1453         return (ret);
1454 }
1455
1456 /*
1457  * inherit [-rS] <property> <fs|vol> ...
1458  *
1459  *      -r      Recurse over all children
1460  *      -S      Revert to received value, if any
1461  *
1462  * For each dataset specified on the command line, inherit the given property
1463  * from its parent.  Inheriting a property at the pool level will cause it to
1464  * use the default value.  The '-r' flag will recurse over all children, and is
1465  * useful for setting a property on a hierarchy-wide basis, regardless of any
1466  * local modifications for each dataset.
1467  */
1468
1469 typedef struct inherit_cbdata {
1470         const char *cb_propname;
1471         boolean_t cb_received;
1472 } inherit_cbdata_t;
1473
1474 static int
1475 inherit_recurse_cb(zfs_handle_t *zhp, void *data)
1476 {
1477         inherit_cbdata_t *cb = data;
1478         zfs_prop_t prop = zfs_name_to_prop(cb->cb_propname);
1479
1480         /*
1481          * If we're doing it recursively, then ignore properties that
1482          * are not valid for this type of dataset.
1483          */
1484         if (prop != ZPROP_INVAL &&
1485             !zfs_prop_valid_for_type(prop, zfs_get_type(zhp)))
1486                 return (0);
1487
1488         return (zfs_prop_inherit(zhp, cb->cb_propname, cb->cb_received) != 0);
1489 }
1490
1491 static int
1492 inherit_cb(zfs_handle_t *zhp, void *data)
1493 {
1494         inherit_cbdata_t *cb = data;
1495
1496         return (zfs_prop_inherit(zhp, cb->cb_propname, cb->cb_received) != 0);
1497 }
1498
1499 static int
1500 zfs_do_inherit(int argc, char **argv)
1501 {
1502         int c;
1503         zfs_prop_t prop;
1504         inherit_cbdata_t cb = { 0 };
1505         char *propname;
1506         int ret;
1507         int flags = 0;
1508         boolean_t received = B_FALSE;
1509
1510         /* check options */
1511         while ((c = getopt(argc, argv, "rS")) != -1) {
1512                 switch (c) {
1513                 case 'r':
1514                         flags |= ZFS_ITER_RECURSE;
1515                         break;
1516                 case 'S':
1517                         received = B_TRUE;
1518                         break;
1519                 case '?':
1520                 default:
1521                         (void) fprintf(stderr, gettext("invalid option '%c'\n"),
1522                             optopt);
1523                         usage(B_FALSE);
1524                 }
1525         }
1526
1527         argc -= optind;
1528         argv += optind;
1529
1530         /* check number of arguments */
1531         if (argc < 1) {
1532                 (void) fprintf(stderr, gettext("missing property argument\n"));
1533                 usage(B_FALSE);
1534         }
1535         if (argc < 2) {
1536                 (void) fprintf(stderr, gettext("missing dataset argument\n"));
1537                 usage(B_FALSE);
1538         }
1539
1540         propname = argv[0];
1541         argc--;
1542         argv++;
1543
1544         if ((prop = zfs_name_to_prop(propname)) != ZPROP_INVAL) {
1545                 if (zfs_prop_readonly(prop)) {
1546                         (void) fprintf(stderr, gettext(
1547                             "%s property is read-only\n"),
1548                             propname);
1549                         return (1);
1550                 }
1551                 if (!zfs_prop_inheritable(prop) && !received) {
1552                         (void) fprintf(stderr, gettext("'%s' property cannot "
1553                             "be inherited\n"), propname);
1554                         if (prop == ZFS_PROP_QUOTA ||
1555                             prop == ZFS_PROP_RESERVATION ||
1556                             prop == ZFS_PROP_REFQUOTA ||
1557                             prop == ZFS_PROP_REFRESERVATION)
1558                                 (void) fprintf(stderr, gettext("use 'zfs set "
1559                                     "%s=none' to clear\n"), propname);
1560                         return (1);
1561                 }
1562                 if (received && (prop == ZFS_PROP_VOLSIZE ||
1563                     prop == ZFS_PROP_VERSION)) {
1564                         (void) fprintf(stderr, gettext("'%s' property cannot "
1565                             "be reverted to a received value\n"), propname);
1566                         return (1);
1567                 }
1568         } else if (!zfs_prop_user(propname)) {
1569                 (void) fprintf(stderr, gettext("invalid property '%s'\n"),
1570                     propname);
1571                 usage(B_FALSE);
1572         }
1573
1574         cb.cb_propname = propname;
1575         cb.cb_received = received;
1576
1577         if (flags & ZFS_ITER_RECURSE) {
1578                 ret = zfs_for_each(argc, argv, flags, ZFS_TYPE_DATASET,
1579                     NULL, NULL, 0, inherit_recurse_cb, &cb);
1580         } else {
1581                 ret = zfs_for_each(argc, argv, flags, ZFS_TYPE_DATASET,
1582                     NULL, NULL, 0, inherit_cb, &cb);
1583         }
1584
1585         return (ret);
1586 }
1587
1588 typedef struct upgrade_cbdata {
1589         uint64_t cb_numupgraded;
1590         uint64_t cb_numsamegraded;
1591         uint64_t cb_numfailed;
1592         uint64_t cb_version;
1593         boolean_t cb_newer;
1594         boolean_t cb_foundone;
1595         char cb_lastfs[ZFS_MAXNAMELEN];
1596 } upgrade_cbdata_t;
1597
1598 static int
1599 same_pool(zfs_handle_t *zhp, const char *name)
1600 {
1601         int len1 = strcspn(name, "/@");
1602         const char *zhname = zfs_get_name(zhp);
1603         int len2 = strcspn(zhname, "/@");
1604
1605         if (len1 != len2)
1606                 return (B_FALSE);
1607         return (strncmp(name, zhname, len1) == 0);
1608 }
1609
1610 static int
1611 upgrade_list_callback(zfs_handle_t *zhp, void *data)
1612 {
1613         upgrade_cbdata_t *cb = data;
1614         int version = zfs_prop_get_int(zhp, ZFS_PROP_VERSION);
1615
1616         /* list if it's old/new */
1617         if ((!cb->cb_newer && version < ZPL_VERSION) ||
1618             (cb->cb_newer && version > ZPL_VERSION)) {
1619                 char *str;
1620                 if (cb->cb_newer) {
1621                         str = gettext("The following filesystems are "
1622                             "formatted using a newer software version and\n"
1623                             "cannot be accessed on the current system.\n\n");
1624                 } else {
1625                         str = gettext("The following filesystems are "
1626                             "out of date, and can be upgraded.  After being\n"
1627                             "upgraded, these filesystems (and any 'zfs send' "
1628                             "streams generated from\n"
1629                             "subsequent snapshots) will no longer be "
1630                             "accessible by older software versions.\n\n");
1631                 }
1632
1633                 if (!cb->cb_foundone) {
1634                         (void) puts(str);
1635                         (void) printf(gettext("VER  FILESYSTEM\n"));
1636                         (void) printf(gettext("---  ------------\n"));
1637                         cb->cb_foundone = B_TRUE;
1638                 }
1639
1640                 (void) printf("%2u   %s\n", version, zfs_get_name(zhp));
1641         }
1642
1643         return (0);
1644 }
1645
1646 static int
1647 upgrade_set_callback(zfs_handle_t *zhp, void *data)
1648 {
1649         upgrade_cbdata_t *cb = data;
1650         int version = zfs_prop_get_int(zhp, ZFS_PROP_VERSION);
1651         int needed_spa_version;
1652         int spa_version;
1653
1654         if (zfs_spa_version(zhp, &spa_version) < 0)
1655                 return (-1);
1656
1657         needed_spa_version = zfs_spa_version_map(cb->cb_version);
1658
1659         if (needed_spa_version < 0)
1660                 return (-1);
1661
1662         if (spa_version < needed_spa_version) {
1663                 /* can't upgrade */
1664                 (void) printf(gettext("%s: can not be "
1665                     "upgraded; the pool version needs to first "
1666                     "be upgraded\nto version %d\n\n"),
1667                     zfs_get_name(zhp), needed_spa_version);
1668                 cb->cb_numfailed++;
1669                 return (0);
1670         }
1671
1672         /* upgrade */
1673         if (version < cb->cb_version) {
1674                 char verstr[16];
1675                 (void) snprintf(verstr, sizeof (verstr),
1676                     "%llu", cb->cb_version);
1677                 if (cb->cb_lastfs[0] && !same_pool(zhp, cb->cb_lastfs)) {
1678                         /*
1679                          * If they did "zfs upgrade -a", then we could
1680                          * be doing ioctls to different pools.  We need
1681                          * to log this history once to each pool.
1682                          */
1683                         verify(zpool_stage_history(g_zfs, history_str) == 0);
1684                 }
1685                 if (zfs_prop_set(zhp, "version", verstr) == 0)
1686                         cb->cb_numupgraded++;
1687                 else
1688                         cb->cb_numfailed++;
1689                 (void) strcpy(cb->cb_lastfs, zfs_get_name(zhp));
1690         } else if (version > cb->cb_version) {
1691                 /* can't downgrade */
1692                 (void) printf(gettext("%s: can not be downgraded; "
1693                     "it is already at version %u\n"),
1694                     zfs_get_name(zhp), version);
1695                 cb->cb_numfailed++;
1696         } else {
1697                 cb->cb_numsamegraded++;
1698         }
1699         return (0);
1700 }
1701
1702 /*
1703  * zfs upgrade
1704  * zfs upgrade -v
1705  * zfs upgrade [-r] [-V <version>] <-a | filesystem>
1706  */
1707 static int
1708 zfs_do_upgrade(int argc, char **argv)
1709 {
1710         boolean_t all = B_FALSE;
1711         boolean_t showversions = B_FALSE;
1712         int ret;
1713         upgrade_cbdata_t cb = { 0 };
1714         char c;
1715         int flags = ZFS_ITER_ARGS_CAN_BE_PATHS;
1716
1717         /* check options */
1718         while ((c = getopt(argc, argv, "rvV:a")) != -1) {
1719                 switch (c) {
1720                 case 'r':
1721                         flags |= ZFS_ITER_RECURSE;
1722                         break;
1723                 case 'v':
1724                         showversions = B_TRUE;
1725                         break;
1726                 case 'V':
1727                         if (zfs_prop_string_to_index(ZFS_PROP_VERSION,
1728                             optarg, &cb.cb_version) != 0) {
1729                                 (void) fprintf(stderr,
1730                                     gettext("invalid version %s\n"), optarg);
1731                                 usage(B_FALSE);
1732                         }
1733                         break;
1734                 case 'a':
1735                         all = B_TRUE;
1736                         break;
1737                 case '?':
1738                 default:
1739                         (void) fprintf(stderr, gettext("invalid option '%c'\n"),
1740                             optopt);
1741                         usage(B_FALSE);
1742                 }
1743         }
1744
1745         argc -= optind;
1746         argv += optind;
1747
1748         if ((!all && !argc) && ((flags & ZFS_ITER_RECURSE) | cb.cb_version))
1749                 usage(B_FALSE);
1750         if (showversions && (flags & ZFS_ITER_RECURSE || all ||
1751             cb.cb_version || argc))
1752                 usage(B_FALSE);
1753         if ((all || argc) && (showversions))
1754                 usage(B_FALSE);
1755         if (all && argc)
1756                 usage(B_FALSE);
1757
1758         if (showversions) {
1759                 /* Show info on available versions. */
1760                 (void) printf(gettext("The following filesystem versions are "
1761                     "supported:\n\n"));
1762                 (void) printf(gettext("VER  DESCRIPTION\n"));
1763                 (void) printf("---  -----------------------------------------"
1764                     "---------------\n");
1765                 (void) printf(gettext(" 1   Initial ZFS filesystem version\n"));
1766                 (void) printf(gettext(" 2   Enhanced directory entries\n"));
1767                 (void) printf(gettext(" 3   Case insensitive and File system "
1768                     "unique identifier (FUID)\n"));
1769                 (void) printf(gettext(" 4   userquota, groupquota "
1770                     "properties\n"));
1771                 (void) printf(gettext(" 5   System attributes\n"));
1772                 (void) printf(gettext("\nFor more information on a particular "
1773                     "version, including supported releases,\n"));
1774                 (void) printf("see the ZFS Administration Guide.\n\n");
1775                 ret = 0;
1776         } else if (argc || all) {
1777                 /* Upgrade filesystems */
1778                 if (cb.cb_version == 0)
1779                         cb.cb_version = ZPL_VERSION;
1780                 ret = zfs_for_each(argc, argv, flags, ZFS_TYPE_FILESYSTEM,
1781                     NULL, NULL, 0, upgrade_set_callback, &cb);
1782                 (void) printf(gettext("%llu filesystems upgraded\n"),
1783                     cb.cb_numupgraded);
1784                 if (cb.cb_numsamegraded) {
1785                         (void) printf(gettext("%llu filesystems already at "
1786                             "this version\n"),
1787                             cb.cb_numsamegraded);
1788                 }
1789                 if (cb.cb_numfailed != 0)
1790                         ret = 1;
1791         } else {
1792                 /* List old-version filesytems */
1793                 boolean_t found;
1794                 (void) printf(gettext("This system is currently running "
1795                     "ZFS filesystem version %llu.\n\n"), ZPL_VERSION);
1796
1797                 flags |= ZFS_ITER_RECURSE;
1798                 ret = zfs_for_each(0, NULL, flags, ZFS_TYPE_FILESYSTEM,
1799                     NULL, NULL, 0, upgrade_list_callback, &cb);
1800
1801                 found = cb.cb_foundone;
1802                 cb.cb_foundone = B_FALSE;
1803                 cb.cb_newer = B_TRUE;
1804
1805                 ret = zfs_for_each(0, NULL, flags, ZFS_TYPE_FILESYSTEM,
1806                     NULL, NULL, 0, upgrade_list_callback, &cb);
1807
1808                 if (!cb.cb_foundone && !found) {
1809                         (void) printf(gettext("All filesystems are "
1810                             "formatted with the current version.\n"));
1811                 }
1812         }
1813
1814         return (ret);
1815 }
1816
1817 /*
1818  * zfs userspace
1819  */
1820 static int
1821 userspace_cb(void *arg, const char *domain, uid_t rid, uint64_t space)
1822 {
1823         zfs_userquota_prop_t *typep = arg;
1824         zfs_userquota_prop_t p = *typep;
1825         char *name = NULL;
1826         char *ug, *propname;
1827         char namebuf[32];
1828         char sizebuf[32];
1829
1830         if (domain == NULL || domain[0] == '\0') {
1831                 if (p == ZFS_PROP_GROUPUSED || p == ZFS_PROP_GROUPQUOTA) {
1832                         struct group *g = getgrgid(rid);
1833                         if (g)
1834                                 name = g->gr_name;
1835                 } else {
1836                         struct passwd *p = getpwuid(rid);
1837                         if (p)
1838                                 name = p->pw_name;
1839                 }
1840         }
1841
1842         if (p == ZFS_PROP_GROUPUSED || p == ZFS_PROP_GROUPQUOTA)
1843                 ug = "group";
1844         else
1845                 ug = "user";
1846
1847         if (p == ZFS_PROP_USERUSED || p == ZFS_PROP_GROUPUSED)
1848                 propname = "used";
1849         else
1850                 propname = "quota";
1851
1852         if (name == NULL) {
1853                 (void) snprintf(namebuf, sizeof (namebuf),
1854                     "%llu", (longlong_t)rid);
1855                 name = namebuf;
1856         }
1857         zfs_nicenum(space, sizebuf, sizeof (sizebuf));
1858
1859         (void) printf("%s %s %s%c%s %s\n", propname, ug, domain,
1860             domain[0] ? '-' : ' ', name, sizebuf);
1861
1862         return (0);
1863 }
1864
1865 static int
1866 zfs_do_userspace(int argc, char **argv)
1867 {
1868         zfs_handle_t *zhp;
1869         zfs_userquota_prop_t p;
1870         int error;
1871
1872         /*
1873          * Try the python version.  If the execv fails, we'll continue
1874          * and do a simplistic implementation.
1875          */
1876         (void) execv(pypath, argv-1);
1877
1878         (void) printf("internal error: %s not found\n"
1879             "falling back on built-in implementation, "
1880             "some features will not work\n", pypath);
1881
1882         if ((zhp = zfs_open(g_zfs, argv[argc-1], ZFS_TYPE_DATASET)) == NULL)
1883                 return (1);
1884
1885         (void) printf("PROP TYPE NAME VALUE\n");
1886
1887         for (p = 0; p < ZFS_NUM_USERQUOTA_PROPS; p++) {
1888                 error = zfs_userspace(zhp, p, userspace_cb, &p);
1889                 if (error)
1890                         break;
1891         }
1892         return (error);
1893 }
1894
1895 /*
1896  * list [-r][-d max] [-H] [-o property[,property]...] [-t type[,type]...]
1897  *      [-s property [-s property]...] [-S property [-S property]...]
1898  *      <dataset> ...
1899  *
1900  *      -r      Recurse over all children
1901  *      -d      Limit recursion by depth.
1902  *      -H      Scripted mode; elide headers and separate columns by tabs
1903  *      -o      Control which fields to display.
1904  *      -t      Control which object types to display.
1905  *      -s      Specify sort columns, descending order.
1906  *      -S      Specify sort columns, ascending order.
1907  *
1908  * When given no arguments, lists all filesystems in the system.
1909  * Otherwise, list the specified datasets, optionally recursing down them if
1910  * '-r' is specified.
1911  */
1912 typedef struct list_cbdata {
1913         boolean_t       cb_first;
1914         boolean_t       cb_scripted;
1915         zprop_list_t    *cb_proplist;
1916 } list_cbdata_t;
1917
1918 /*
1919  * Given a list of columns to display, output appropriate headers for each one.
1920  */
1921 static void
1922 print_header(zprop_list_t *pl)
1923 {
1924         char headerbuf[ZFS_MAXPROPLEN];
1925         const char *header;
1926         int i;
1927         boolean_t first = B_TRUE;
1928         boolean_t right_justify;
1929
1930         for (; pl != NULL; pl = pl->pl_next) {
1931                 if (!first) {
1932                         (void) printf("  ");
1933                 } else {
1934                         first = B_FALSE;
1935                 }
1936
1937                 right_justify = B_FALSE;
1938                 if (pl->pl_prop != ZPROP_INVAL) {
1939                         header = zfs_prop_column_name(pl->pl_prop);
1940                         right_justify = zfs_prop_align_right(pl->pl_prop);
1941                 } else {
1942                         for (i = 0; pl->pl_user_prop[i] != '\0'; i++)
1943                                 headerbuf[i] = toupper(pl->pl_user_prop[i]);
1944                         headerbuf[i] = '\0';
1945                         header = headerbuf;
1946                 }
1947
1948                 if (pl->pl_next == NULL && !right_justify)
1949                         (void) printf("%s", header);
1950                 else if (right_justify)
1951                         (void) printf("%*s", pl->pl_width, header);
1952                 else
1953                         (void) printf("%-*s", pl->pl_width, header);
1954         }
1955
1956         (void) printf("\n");
1957 }
1958
1959 /*
1960  * Given a dataset and a list of fields, print out all the properties according
1961  * to the described layout.
1962  */
1963 static void
1964 print_dataset(zfs_handle_t *zhp, zprop_list_t *pl, boolean_t scripted)
1965 {
1966         boolean_t first = B_TRUE;
1967         char property[ZFS_MAXPROPLEN];
1968         nvlist_t *userprops = zfs_get_user_props(zhp);
1969         nvlist_t *propval;
1970         char *propstr;
1971         boolean_t right_justify;
1972         int width;
1973
1974         for (; pl != NULL; pl = pl->pl_next) {
1975                 if (!first) {
1976                         if (scripted)
1977                                 (void) printf("\t");
1978                         else
1979                                 (void) printf("  ");
1980                 } else {
1981                         first = B_FALSE;
1982                 }
1983
1984                 if (pl->pl_prop != ZPROP_INVAL) {
1985                         if (zfs_prop_get(zhp, pl->pl_prop, property,
1986                             sizeof (property), NULL, NULL, 0, B_FALSE) != 0)
1987                                 propstr = "-";
1988                         else
1989                                 propstr = property;
1990
1991                         right_justify = zfs_prop_align_right(pl->pl_prop);
1992                 } else if (zfs_prop_userquota(pl->pl_user_prop)) {
1993                         if (zfs_prop_get_userquota(zhp, pl->pl_user_prop,
1994                             property, sizeof (property), B_FALSE) != 0)
1995                                 propstr = "-";
1996                         else
1997                                 propstr = property;
1998                         right_justify = B_TRUE;
1999                 } else {
2000                         if (nvlist_lookup_nvlist(userprops,
2001                             pl->pl_user_prop, &propval) != 0)
2002                                 propstr = "-";
2003                         else
2004                                 verify(nvlist_lookup_string(propval,
2005                                     ZPROP_VALUE, &propstr) == 0);
2006                         right_justify = B_FALSE;
2007                 }
2008
2009                 width = pl->pl_width;
2010
2011                 /*
2012                  * If this is being called in scripted mode, or if this is the
2013                  * last column and it is left-justified, don't include a width
2014                  * format specifier.
2015                  */
2016                 if (scripted || (pl->pl_next == NULL && !right_justify))
2017                         (void) printf("%s", propstr);
2018                 else if (right_justify)
2019                         (void) printf("%*s", width, propstr);
2020                 else
2021                         (void) printf("%-*s", width, propstr);
2022         }
2023
2024         (void) printf("\n");
2025 }
2026
2027 /*
2028  * Generic callback function to list a dataset or snapshot.
2029  */
2030 static int
2031 list_callback(zfs_handle_t *zhp, void *data)
2032 {
2033         list_cbdata_t *cbp = data;
2034
2035         if (cbp->cb_first) {
2036                 if (!cbp->cb_scripted)
2037                         print_header(cbp->cb_proplist);
2038                 cbp->cb_first = B_FALSE;
2039         }
2040
2041         print_dataset(zhp, cbp->cb_proplist, cbp->cb_scripted);
2042
2043         return (0);
2044 }
2045
2046 static int
2047 zfs_do_list(int argc, char **argv)
2048 {
2049         int c;
2050         boolean_t scripted = B_FALSE;
2051         static char default_fields[] =
2052             "name,used,available,referenced,mountpoint";
2053         int types = ZFS_TYPE_DATASET;
2054         boolean_t types_specified = B_FALSE;
2055         char *fields = NULL;
2056         list_cbdata_t cb = { 0 };
2057         char *value;
2058         int limit = 0;
2059         int ret;
2060         zfs_sort_column_t *sortcol = NULL;
2061         int flags = ZFS_ITER_PROP_LISTSNAPS | ZFS_ITER_ARGS_CAN_BE_PATHS;
2062
2063         /* check options */
2064         while ((c = getopt(argc, argv, ":d:o:rt:Hs:S:")) != -1) {
2065                 switch (c) {
2066                 case 'o':
2067                         fields = optarg;
2068                         break;
2069                 case 'd':
2070                         limit = parse_depth(optarg, &flags);
2071                         break;
2072                 case 'r':
2073                         flags |= ZFS_ITER_RECURSE;
2074                         break;
2075                 case 'H':
2076                         scripted = B_TRUE;
2077                         break;
2078                 case 's':
2079                         if (zfs_add_sort_column(&sortcol, optarg,
2080                             B_FALSE) != 0) {
2081                                 (void) fprintf(stderr,
2082                                     gettext("invalid property '%s'\n"), optarg);
2083                                 usage(B_FALSE);
2084                         }
2085                         break;
2086                 case 'S':
2087                         if (zfs_add_sort_column(&sortcol, optarg,
2088                             B_TRUE) != 0) {
2089                                 (void) fprintf(stderr,
2090                                     gettext("invalid property '%s'\n"), optarg);
2091                                 usage(B_FALSE);
2092                         }
2093                         break;
2094                 case 't':
2095                         types = 0;
2096                         types_specified = B_TRUE;
2097                         flags &= ~ZFS_ITER_PROP_LISTSNAPS;
2098                         while (*optarg != '\0') {
2099                                 static char *type_subopts[] = { "filesystem",
2100                                     "volume", "snapshot", "all", NULL };
2101
2102                                 switch (getsubopt(&optarg, type_subopts,
2103                                     &value)) {
2104                                 case 0:
2105                                         types |= ZFS_TYPE_FILESYSTEM;
2106                                         break;
2107                                 case 1:
2108                                         types |= ZFS_TYPE_VOLUME;
2109                                         break;
2110                                 case 2:
2111                                         types |= ZFS_TYPE_SNAPSHOT;
2112                                         break;
2113                                 case 3:
2114                                         types = ZFS_TYPE_DATASET;
2115                                         break;
2116
2117                                 default:
2118                                         (void) fprintf(stderr,
2119                                             gettext("invalid type '%s'\n"),
2120                                             value);
2121                                         usage(B_FALSE);
2122                                 }
2123                         }
2124                         break;
2125                 case ':':
2126                         (void) fprintf(stderr, gettext("missing argument for "
2127                             "'%c' option\n"), optopt);
2128                         usage(B_FALSE);
2129                         break;
2130                 case '?':
2131                         (void) fprintf(stderr, gettext("invalid option '%c'\n"),
2132                             optopt);
2133                         usage(B_FALSE);
2134                 }
2135         }
2136
2137         argc -= optind;
2138         argv += optind;
2139
2140         if (fields == NULL)
2141                 fields = default_fields;
2142
2143         /*
2144          * If "-o space" and no types were specified, don't display snapshots.
2145          */
2146         if (strcmp(fields, "space") == 0 && types_specified == B_FALSE)
2147                 types &= ~ZFS_TYPE_SNAPSHOT;
2148
2149         /*
2150          * If the user specifies '-o all', the zprop_get_list() doesn't
2151          * normally include the name of the dataset.  For 'zfs list', we always
2152          * want this property to be first.
2153          */
2154         if (zprop_get_list(g_zfs, fields, &cb.cb_proplist, ZFS_TYPE_DATASET)
2155             != 0)
2156                 usage(B_FALSE);
2157
2158         cb.cb_scripted = scripted;
2159         cb.cb_first = B_TRUE;
2160
2161         ret = zfs_for_each(argc, argv, flags, types, sortcol, &cb.cb_proplist,
2162             limit, list_callback, &cb);
2163
2164         zprop_free_list(cb.cb_proplist);
2165         zfs_free_sort_columns(sortcol);
2166
2167         if (ret == 0 && cb.cb_first && !cb.cb_scripted)
2168                 (void) printf(gettext("no datasets available\n"));
2169
2170         return (ret);
2171 }
2172
2173 /*
2174  * zfs rename <fs | snap | vol> <fs | snap | vol>
2175  * zfs rename -p <fs | vol> <fs | vol>
2176  * zfs rename -r <snap> <snap>
2177  *
2178  * Renames the given dataset to another of the same type.
2179  *
2180  * The '-p' flag creates all the non-existing ancestors of the target first.
2181  */
2182 /* ARGSUSED */
2183 static int
2184 zfs_do_rename(int argc, char **argv)
2185 {
2186         zfs_handle_t *zhp;
2187         int c;
2188         int ret;
2189         boolean_t recurse = B_FALSE;
2190         boolean_t parents = B_FALSE;
2191
2192         /* check options */
2193         while ((c = getopt(argc, argv, "pr")) != -1) {
2194                 switch (c) {
2195                 case 'p':
2196                         parents = B_TRUE;
2197                         break;
2198                 case 'r':
2199                         recurse = B_TRUE;
2200                         break;
2201                 case '?':
2202                 default:
2203                         (void) fprintf(stderr, gettext("invalid option '%c'\n"),
2204                             optopt);
2205                         usage(B_FALSE);
2206                 }
2207         }
2208
2209         argc -= optind;
2210         argv += optind;
2211
2212         /* check number of arguments */
2213         if (argc < 1) {
2214                 (void) fprintf(stderr, gettext("missing source dataset "
2215                     "argument\n"));
2216                 usage(B_FALSE);
2217         }
2218         if (argc < 2) {
2219                 (void) fprintf(stderr, gettext("missing target dataset "
2220                     "argument\n"));
2221                 usage(B_FALSE);
2222         }
2223         if (argc > 2) {
2224                 (void) fprintf(stderr, gettext("too many arguments\n"));
2225                 usage(B_FALSE);
2226         }
2227
2228         if (recurse && parents) {
2229                 (void) fprintf(stderr, gettext("-p and -r options are mutually "
2230                     "exclusive\n"));
2231                 usage(B_FALSE);
2232         }
2233
2234         if (recurse && strchr(argv[0], '@') == 0) {
2235                 (void) fprintf(stderr, gettext("source dataset for recursive "
2236                     "rename must be a snapshot\n"));
2237                 usage(B_FALSE);
2238         }
2239
2240         if ((zhp = zfs_open(g_zfs, argv[0], parents ? ZFS_TYPE_FILESYSTEM |
2241             ZFS_TYPE_VOLUME : ZFS_TYPE_DATASET)) == NULL)
2242                 return (1);
2243
2244         /* If we were asked and the name looks good, try to create ancestors. */
2245         if (parents && zfs_name_valid(argv[1], zfs_get_type(zhp)) &&
2246             zfs_create_ancestors(g_zfs, argv[1]) != 0) {
2247                 zfs_close(zhp);
2248                 return (1);
2249         }
2250
2251         ret = (zfs_rename(zhp, argv[1], recurse) != 0);
2252
2253         zfs_close(zhp);
2254         return (ret);
2255 }
2256
2257 /*
2258  * zfs promote <fs>
2259  *
2260  * Promotes the given clone fs to be the parent
2261  */
2262 /* ARGSUSED */
2263 static int
2264 zfs_do_promote(int argc, char **argv)
2265 {
2266         zfs_handle_t *zhp;
2267         int ret;
2268
2269         /* check options */
2270         if (argc > 1 && argv[1][0] == '-') {
2271                 (void) fprintf(stderr, gettext("invalid option '%c'\n"),
2272                     argv[1][1]);
2273                 usage(B_FALSE);
2274         }
2275
2276         /* check number of arguments */
2277         if (argc < 2) {
2278                 (void) fprintf(stderr, gettext("missing clone filesystem"
2279                     " argument\n"));
2280                 usage(B_FALSE);
2281         }
2282         if (argc > 2) {
2283                 (void) fprintf(stderr, gettext("too many arguments\n"));
2284                 usage(B_FALSE);
2285         }
2286
2287         zhp = zfs_open(g_zfs, argv[1], ZFS_TYPE_FILESYSTEM | ZFS_TYPE_VOLUME);
2288         if (zhp == NULL)
2289                 return (1);
2290
2291         ret = (zfs_promote(zhp) != 0);
2292
2293
2294         zfs_close(zhp);
2295         return (ret);
2296 }
2297
2298 /*
2299  * zfs rollback [-rRf] <snapshot>
2300  *
2301  *      -r      Delete any intervening snapshots before doing rollback
2302  *      -R      Delete any snapshots and their clones
2303  *      -f      ignored for backwards compatability
2304  *
2305  * Given a filesystem, rollback to a specific snapshot, discarding any changes
2306  * since then and making it the active dataset.  If more recent snapshots exist,
2307  * the command will complain unless the '-r' flag is given.
2308  */
2309 typedef struct rollback_cbdata {
2310         uint64_t        cb_create;
2311         boolean_t       cb_first;
2312         int             cb_doclones;
2313         char            *cb_target;
2314         int             cb_error;
2315         boolean_t       cb_recurse;
2316         boolean_t       cb_dependent;
2317 } rollback_cbdata_t;
2318
2319 /*
2320  * Report any snapshots more recent than the one specified.  Used when '-r' is
2321  * not specified.  We reuse this same callback for the snapshot dependents - if
2322  * 'cb_dependent' is set, then this is a dependent and we should report it
2323  * without checking the transaction group.
2324  */
2325 static int
2326 rollback_check(zfs_handle_t *zhp, void *data)
2327 {
2328         rollback_cbdata_t *cbp = data;
2329
2330         if (cbp->cb_doclones) {
2331                 zfs_close(zhp);
2332                 return (0);
2333         }
2334
2335         if (!cbp->cb_dependent) {
2336                 if (strcmp(zfs_get_name(zhp), cbp->cb_target) != 0 &&
2337                     zfs_get_type(zhp) == ZFS_TYPE_SNAPSHOT &&
2338                     zfs_prop_get_int(zhp, ZFS_PROP_CREATETXG) >
2339                     cbp->cb_create) {
2340
2341                         if (cbp->cb_first && !cbp->cb_recurse) {
2342                                 (void) fprintf(stderr, gettext("cannot "
2343                                     "rollback to '%s': more recent snapshots "
2344                                     "exist\n"),
2345                                     cbp->cb_target);
2346                                 (void) fprintf(stderr, gettext("use '-r' to "
2347                                     "force deletion of the following "
2348                                     "snapshots:\n"));
2349                                 cbp->cb_first = 0;
2350                                 cbp->cb_error = 1;
2351                         }
2352
2353                         if (cbp->cb_recurse) {
2354                                 cbp->cb_dependent = B_TRUE;
2355                                 if (zfs_iter_dependents(zhp, B_TRUE,
2356                                     rollback_check, cbp) != 0) {
2357                                         zfs_close(zhp);
2358                                         return (-1);
2359                                 }
2360                                 cbp->cb_dependent = B_FALSE;
2361                         } else {
2362                                 (void) fprintf(stderr, "%s\n",
2363                                     zfs_get_name(zhp));
2364                         }
2365                 }
2366         } else {
2367                 if (cbp->cb_first && cbp->cb_recurse) {
2368                         (void) fprintf(stderr, gettext("cannot rollback to "
2369                             "'%s': clones of previous snapshots exist\n"),
2370                             cbp->cb_target);
2371                         (void) fprintf(stderr, gettext("use '-R' to "
2372                             "force deletion of the following clones and "
2373                             "dependents:\n"));
2374                         cbp->cb_first = 0;
2375                         cbp->cb_error = 1;
2376                 }
2377
2378                 (void) fprintf(stderr, "%s\n", zfs_get_name(zhp));
2379         }
2380
2381         zfs_close(zhp);
2382         return (0);
2383 }
2384
2385 static int
2386 zfs_do_rollback(int argc, char **argv)
2387 {
2388         int ret;
2389         int c;
2390         boolean_t force = B_FALSE;
2391         rollback_cbdata_t cb = { 0 };
2392         zfs_handle_t *zhp, *snap;
2393         char parentname[ZFS_MAXNAMELEN];
2394         char *delim;
2395
2396         /* check options */
2397         while ((c = getopt(argc, argv, "rRf")) != -1) {
2398                 switch (c) {
2399                 case 'r':
2400                         cb.cb_recurse = 1;
2401                         break;
2402                 case 'R':
2403                         cb.cb_recurse = 1;
2404                         cb.cb_doclones = 1;
2405                         break;
2406                 case 'f':
2407                         force = B_TRUE;
2408                         break;
2409                 case '?':
2410                         (void) fprintf(stderr, gettext("invalid option '%c'\n"),
2411                             optopt);
2412                         usage(B_FALSE);
2413                 }
2414         }
2415
2416         argc -= optind;
2417         argv += optind;
2418
2419         /* check number of arguments */
2420         if (argc < 1) {
2421                 (void) fprintf(stderr, gettext("missing dataset argument\n"));
2422                 usage(B_FALSE);
2423         }
2424         if (argc > 1) {
2425                 (void) fprintf(stderr, gettext("too many arguments\n"));
2426                 usage(B_FALSE);
2427         }
2428
2429         /* open the snapshot */
2430         if ((snap = zfs_open(g_zfs, argv[0], ZFS_TYPE_SNAPSHOT)) == NULL)
2431                 return (1);
2432
2433         /* open the parent dataset */
2434         (void) strlcpy(parentname, argv[0], sizeof (parentname));
2435         verify((delim = strrchr(parentname, '@')) != NULL);
2436         *delim = '\0';
2437         if ((zhp = zfs_open(g_zfs, parentname, ZFS_TYPE_DATASET)) == NULL) {
2438                 zfs_close(snap);
2439                 return (1);
2440         }
2441
2442         /*
2443          * Check for more recent snapshots and/or clones based on the presence
2444          * of '-r' and '-R'.
2445          */
2446         cb.cb_target = argv[0];
2447         cb.cb_create = zfs_prop_get_int(snap, ZFS_PROP_CREATETXG);
2448         cb.cb_first = B_TRUE;
2449         cb.cb_error = 0;
2450         if ((ret = zfs_iter_children(zhp, rollback_check, &cb)) != 0)
2451                 goto out;
2452
2453         if ((ret = cb.cb_error) != 0)
2454                 goto out;
2455
2456         /*
2457          * Rollback parent to the given snapshot.
2458          */
2459         ret = zfs_rollback(zhp, snap, force);
2460
2461 out:
2462         zfs_close(snap);
2463         zfs_close(zhp);
2464
2465         if (ret == 0)
2466                 return (0);
2467         else
2468                 return (1);
2469 }
2470
2471 /*
2472  * zfs set property=value { fs | snap | vol } ...
2473  *
2474  * Sets the given property for all datasets specified on the command line.
2475  */
2476 typedef struct set_cbdata {
2477         char            *cb_propname;
2478         char            *cb_value;
2479 } set_cbdata_t;
2480
2481 static int
2482 set_callback(zfs_handle_t *zhp, void *data)
2483 {
2484         set_cbdata_t *cbp = data;
2485
2486         if (zfs_prop_set(zhp, cbp->cb_propname, cbp->cb_value) != 0) {
2487                 switch (libzfs_errno(g_zfs)) {
2488                 case EZFS_MOUNTFAILED:
2489                         (void) fprintf(stderr, gettext("property may be set "
2490                             "but unable to remount filesystem\n"));
2491                         break;
2492                 case EZFS_SHARENFSFAILED:
2493                         (void) fprintf(stderr, gettext("property may be set "
2494                             "but unable to reshare filesystem\n"));
2495                         break;
2496                 }
2497                 return (1);
2498         }
2499         return (0);
2500 }
2501
2502 static int
2503 zfs_do_set(int argc, char **argv)
2504 {
2505         set_cbdata_t cb;
2506         int ret;
2507
2508         /* check for options */
2509         if (argc > 1 && argv[1][0] == '-') {
2510                 (void) fprintf(stderr, gettext("invalid option '%c'\n"),
2511                     argv[1][1]);
2512                 usage(B_FALSE);
2513         }
2514
2515         /* check number of arguments */
2516         if (argc < 2) {
2517                 (void) fprintf(stderr, gettext("missing property=value "
2518                     "argument\n"));
2519                 usage(B_FALSE);
2520         }
2521         if (argc < 3) {
2522                 (void) fprintf(stderr, gettext("missing dataset name\n"));
2523                 usage(B_FALSE);
2524         }
2525
2526         /* validate property=value argument */
2527         cb.cb_propname = argv[1];
2528         if (((cb.cb_value = strchr(cb.cb_propname, '=')) == NULL) ||
2529             (cb.cb_value[1] == '\0')) {
2530                 (void) fprintf(stderr, gettext("missing value in "
2531                     "property=value argument\n"));
2532                 usage(B_FALSE);
2533         }
2534
2535         *cb.cb_value = '\0';
2536         cb.cb_value++;
2537
2538         if (*cb.cb_propname == '\0') {
2539                 (void) fprintf(stderr,
2540                     gettext("missing property in property=value argument\n"));
2541                 usage(B_FALSE);
2542         }
2543
2544         ret = zfs_for_each(argc - 2, argv + 2, NULL,
2545             ZFS_TYPE_DATASET, NULL, NULL, 0, set_callback, &cb);
2546
2547         return (ret);
2548 }
2549
2550 /*
2551  * zfs snapshot [-r] [-o prop=value] ... <fs@snap>
2552  *
2553  * Creates a snapshot with the given name.  While functionally equivalent to
2554  * 'zfs create', it is a separate command to differentiate intent.
2555  */
2556 static int
2557 zfs_do_snapshot(int argc, char **argv)
2558 {
2559         boolean_t recursive = B_FALSE;
2560         int ret;
2561         char c;
2562         nvlist_t *props;
2563
2564         if (nvlist_alloc(&props, NV_UNIQUE_NAME, 0) != 0)
2565                 nomem();
2566
2567         /* check options */
2568         while ((c = getopt(argc, argv, "ro:")) != -1) {
2569                 switch (c) {
2570                 case 'o':
2571                         if (parseprop(props))
2572                                 return (1);
2573                         break;
2574                 case 'r':
2575                         recursive = B_TRUE;
2576                         break;
2577                 case '?':
2578                         (void) fprintf(stderr, gettext("invalid option '%c'\n"),
2579                             optopt);
2580                         goto usage;
2581                 }
2582         }
2583
2584         argc -= optind;
2585         argv += optind;
2586
2587         /* check number of arguments */
2588         if (argc < 1) {
2589                 (void) fprintf(stderr, gettext("missing snapshot argument\n"));
2590                 goto usage;
2591         }
2592         if (argc > 1) {
2593                 (void) fprintf(stderr, gettext("too many arguments\n"));
2594                 goto usage;
2595         }
2596
2597         ret = zfs_snapshot(g_zfs, argv[0], recursive, props);
2598         nvlist_free(props);
2599         if (ret && recursive)
2600                 (void) fprintf(stderr, gettext("no snapshots were created\n"));
2601         return (ret != 0);
2602
2603 usage:
2604         nvlist_free(props);
2605         usage(B_FALSE);
2606         return (-1);
2607 }
2608
2609 /*
2610  * zfs send [-vDp] -R [-i|-I <@snap>] <fs@snap>
2611  * zfs send [-vDp] [-i|-I <@snap>] <fs@snap>
2612  *
2613  * Send a backup stream to stdout.
2614  */
2615 static int
2616 zfs_do_send(int argc, char **argv)
2617 {
2618         char *fromname = NULL;
2619         char *toname = NULL;
2620         char *cp;
2621         zfs_handle_t *zhp;
2622         sendflags_t flags = { 0 };
2623         int c, err;
2624         nvlist_t *dbgnv;
2625         boolean_t extraverbose = B_FALSE;
2626
2627         /* check options */
2628         while ((c = getopt(argc, argv, ":i:I:RDpv")) != -1) {
2629                 switch (c) {
2630                 case 'i':
2631                         if (fromname)
2632                                 usage(B_FALSE);
2633                         fromname = optarg;
2634                         break;
2635                 case 'I':
2636                         if (fromname)
2637                                 usage(B_FALSE);
2638                         fromname = optarg;
2639                         flags.doall = B_TRUE;
2640                         break;
2641                 case 'R':
2642                         flags.replicate = B_TRUE;
2643                         break;
2644                 case 'p':
2645                         flags.props = B_TRUE;
2646                         break;
2647                 case 'v':
2648                         if (flags.verbose)
2649                                 extraverbose = B_TRUE;
2650                         flags.verbose = B_TRUE;
2651                         break;
2652                 case 'D':
2653                         flags.dedup = B_TRUE;
2654                         break;
2655                 case ':':
2656                         (void) fprintf(stderr, gettext("missing argument for "
2657                             "'%c' option\n"), optopt);
2658                         usage(B_FALSE);
2659                         break;
2660                 case '?':
2661                         (void) fprintf(stderr, gettext("invalid option '%c'\n"),
2662                             optopt);
2663                         usage(B_FALSE);
2664                 }
2665         }
2666
2667         argc -= optind;
2668         argv += optind;
2669
2670         /* check number of arguments */
2671         if (argc < 1) {
2672                 (void) fprintf(stderr, gettext("missing snapshot argument\n"));
2673                 usage(B_FALSE);
2674         }
2675         if (argc > 1) {
2676                 (void) fprintf(stderr, gettext("too many arguments\n"));
2677                 usage(B_FALSE);
2678         }
2679
2680         if (isatty(STDOUT_FILENO)) {
2681                 (void) fprintf(stderr,
2682                     gettext("Error: Stream can not be written to a terminal.\n"
2683                     "You must redirect standard output.\n"));
2684                 return (1);
2685         }
2686
2687         cp = strchr(argv[0], '@');
2688         if (cp == NULL) {
2689                 (void) fprintf(stderr,
2690                     gettext("argument must be a snapshot\n"));
2691                 usage(B_FALSE);
2692         }
2693         *cp = '\0';
2694         toname = cp + 1;
2695         zhp = zfs_open(g_zfs, argv[0], ZFS_TYPE_FILESYSTEM | ZFS_TYPE_VOLUME);
2696         if (zhp == NULL)
2697                 return (1);
2698
2699         /*
2700          * If they specified the full path to the snapshot, chop off
2701          * everything except the short name of the snapshot, but special
2702          * case if they specify the origin.
2703          */
2704         if (fromname && (cp = strchr(fromname, '@')) != NULL) {
2705                 char origin[ZFS_MAXNAMELEN];
2706                 zprop_source_t src;
2707
2708                 (void) zfs_prop_get(zhp, ZFS_PROP_ORIGIN,
2709                     origin, sizeof (origin), &src, NULL, 0, B_FALSE);
2710
2711                 if (strcmp(origin, fromname) == 0) {
2712                         fromname = NULL;
2713                         flags.fromorigin = B_TRUE;
2714                 } else {
2715                         *cp = '\0';
2716                         if (cp != fromname && strcmp(argv[0], fromname)) {
2717                                 (void) fprintf(stderr,
2718                                     gettext("incremental source must be "
2719                                     "in same filesystem\n"));
2720                                 usage(B_FALSE);
2721                         }
2722                         fromname = cp + 1;
2723                         if (strchr(fromname, '@') || strchr(fromname, '/')) {
2724                                 (void) fprintf(stderr,
2725                                     gettext("invalid incremental source\n"));
2726                                 usage(B_FALSE);
2727                         }
2728                 }
2729         }
2730
2731         if (flags.replicate && fromname == NULL)
2732                 flags.doall = B_TRUE;
2733
2734         err = zfs_send(zhp, fromname, toname, flags, STDOUT_FILENO, NULL, 0,
2735             extraverbose ? &dbgnv : NULL);
2736
2737         if (extraverbose) {
2738                 /*
2739                  * dump_nvlist prints to stdout, but that's been
2740                  * redirected to a file.  Make it print to stderr
2741                  * instead.
2742                  */
2743                 (void) dup2(STDERR_FILENO, STDOUT_FILENO);
2744                 dump_nvlist(dbgnv, 0);
2745                 nvlist_free(dbgnv);
2746         }
2747         zfs_close(zhp);
2748
2749         return (err != 0);
2750 }
2751
2752 /*
2753  * zfs receive [-vnFu] [-d | -e] <fs@snap>
2754  *
2755  * Restore a backup stream from stdin.
2756  */
2757 static int
2758 zfs_do_receive(int argc, char **argv)
2759 {
2760         int c, err;
2761         recvflags_t flags = { 0 };
2762
2763         /* check options */
2764         while ((c = getopt(argc, argv, ":denuvF")) != -1) {
2765                 switch (c) {
2766                 case 'd':
2767                         flags.isprefix = B_TRUE;
2768                         break;
2769                 case 'e':
2770                         flags.isprefix = B_TRUE;
2771                         flags.istail = B_TRUE;
2772                         break;
2773                 case 'n':
2774                         flags.dryrun = B_TRUE;
2775                         break;
2776                 case 'u':
2777                         flags.nomount = B_TRUE;
2778                         break;
2779                 case 'v':
2780                         flags.verbose = B_TRUE;
2781                         break;
2782                 case 'F':
2783                         flags.force = B_TRUE;
2784                         break;
2785                 case ':':
2786                         (void) fprintf(stderr, gettext("missing argument for "
2787                             "'%c' option\n"), optopt);
2788                         usage(B_FALSE);
2789                         break;
2790                 case '?':
2791                         (void) fprintf(stderr, gettext("invalid option '%c'\n"),
2792                             optopt);
2793                         usage(B_FALSE);
2794                 }
2795         }
2796
2797         argc -= optind;
2798         argv += optind;
2799
2800         /* check number of arguments */
2801         if (argc < 1) {
2802                 (void) fprintf(stderr, gettext("missing snapshot argument\n"));
2803                 usage(B_FALSE);
2804         }
2805         if (argc > 1) {
2806                 (void) fprintf(stderr, gettext("too many arguments\n"));
2807                 usage(B_FALSE);
2808         }
2809
2810         if (isatty(STDIN_FILENO)) {
2811                 (void) fprintf(stderr,
2812                     gettext("Error: Backup stream can not be read "
2813                     "from a terminal.\n"
2814                     "You must redirect standard input.\n"));
2815                 return (1);
2816         }
2817
2818         err = zfs_receive(g_zfs, argv[0], flags, STDIN_FILENO, NULL);
2819
2820         return (err != 0);
2821 }
2822
2823 static int
2824 zfs_do_hold_rele_impl(int argc, char **argv, boolean_t holding)
2825 {
2826         int errors = 0;
2827         int i;
2828         const char *tag;
2829         boolean_t recursive = B_FALSE;
2830         boolean_t temphold = B_FALSE;
2831         const char *opts = holding ? "rt" : "r";
2832         int c;
2833
2834         /* check options */
2835         while ((c = getopt(argc, argv, opts)) != -1) {
2836                 switch (c) {
2837                 case 'r':
2838                         recursive = B_TRUE;
2839                         break;
2840                 case 't':
2841                         temphold = B_TRUE;
2842                         break;
2843                 case '?':
2844                         (void) fprintf(stderr, gettext("invalid option '%c'\n"),
2845                             optopt);
2846                         usage(B_FALSE);
2847                 }
2848         }
2849
2850         argc -= optind;
2851         argv += optind;
2852
2853         /* check number of arguments */
2854         if (argc < 2)
2855                 usage(B_FALSE);
2856
2857         tag = argv[0];
2858         --argc;
2859         ++argv;
2860
2861         if (holding && tag[0] == '.') {
2862                 /* tags starting with '.' are reserved for libzfs */
2863                 (void) fprintf(stderr, gettext("tag may not start with '.'\n"));
2864                 usage(B_FALSE);
2865         }
2866
2867         for (i = 0; i < argc; ++i) {
2868                 zfs_handle_t *zhp;
2869                 char parent[ZFS_MAXNAMELEN];
2870                 const char *delim;
2871                 char *path = argv[i];
2872
2873                 delim = strchr(path, '@');
2874                 if (delim == NULL) {
2875                         (void) fprintf(stderr,
2876                             gettext("'%s' is not a snapshot\n"), path);
2877                         ++errors;
2878                         continue;
2879                 }
2880                 (void) strncpy(parent, path, delim - path);
2881                 parent[delim - path] = '\0';
2882
2883                 zhp = zfs_open(g_zfs, parent,
2884                     ZFS_TYPE_FILESYSTEM | ZFS_TYPE_VOLUME);
2885                 if (zhp == NULL) {
2886                         ++errors;
2887                         continue;
2888                 }
2889                 if (holding) {
2890                         if (zfs_hold(zhp, delim+1, tag, recursive,
2891                             temphold, B_FALSE) != 0)
2892                                 ++errors;
2893                 } else {
2894                         if (zfs_release(zhp, delim+1, tag, recursive) != 0)
2895                                 ++errors;
2896                 }
2897                 zfs_close(zhp);
2898         }
2899
2900         return (errors != 0);
2901 }
2902
2903 /*
2904  * zfs hold [-r] [-t] <tag> <snap> ...
2905  *
2906  *      -r      Recursively hold
2907  *      -t      Temporary hold (hidden option)
2908  *
2909  * Apply a user-hold with the given tag to the list of snapshots.
2910  */
2911 static int
2912 zfs_do_hold(int argc, char **argv)
2913 {
2914         return (zfs_do_hold_rele_impl(argc, argv, B_TRUE));
2915 }
2916
2917 /*
2918  * zfs release [-r] <tag> <snap> ...
2919  *
2920  *      -r      Recursively release
2921  *
2922  * Release a user-hold with the given tag from the list of snapshots.
2923  */
2924 static int
2925 zfs_do_release(int argc, char **argv)
2926 {
2927         return (zfs_do_hold_rele_impl(argc, argv, B_FALSE));
2928 }
2929
2930 typedef struct get_all_cbdata {
2931         zfs_handle_t    **cb_handles;
2932         size_t          cb_alloc;
2933         size_t          cb_used;
2934         uint_t          cb_types;
2935         boolean_t       cb_verbose;
2936 } get_all_cbdata_t;
2937
2938 #define CHECK_SPINNER 30
2939 #define SPINNER_TIME 3          /* seconds */
2940 #define MOUNT_TIME 5            /* seconds */
2941
2942 static int
2943 get_one_dataset(zfs_handle_t *zhp, void *data)
2944 {
2945         static char *spin[] = { "-", "\\", "|", "/" };
2946         static int spinval = 0;
2947         static int spincheck = 0;
2948         static time_t last_spin_time = (time_t)0;
2949         get_all_cbdata_t *cbp = data;
2950         zfs_type_t type = zfs_get_type(zhp);
2951
2952         if (cbp->cb_verbose) {
2953                 if (--spincheck < 0) {
2954                         time_t now = time(NULL);
2955                         if (last_spin_time + SPINNER_TIME < now) {
2956                                 update_progress(spin[spinval++ % 4]);
2957                                 last_spin_time = now;
2958                         }
2959                         spincheck = CHECK_SPINNER;
2960                 }
2961         }
2962
2963         /*
2964          * Interate over any nested datasets.
2965          */
2966         if (type == ZFS_TYPE_FILESYSTEM &&
2967             zfs_iter_filesystems(zhp, get_one_dataset, data) != 0) {
2968                 zfs_close(zhp);
2969                 return (1);
2970         }
2971
2972         /*
2973          * Skip any datasets whose type does not match.
2974          */
2975         if ((type & cbp->cb_types) == 0) {
2976                 zfs_close(zhp);
2977                 return (0);
2978         }
2979
2980         if (cbp->cb_alloc == cbp->cb_used) {
2981                 zfs_handle_t **handles;
2982
2983                 if (cbp->cb_alloc == 0)
2984                         cbp->cb_alloc = 64;
2985                 else
2986                         cbp->cb_alloc *= 2;
2987
2988                 handles = safe_malloc(cbp->cb_alloc * sizeof (void *));
2989
2990                 if (cbp->cb_handles) {
2991                         bcopy(cbp->cb_handles, handles,
2992                             cbp->cb_used * sizeof (void *));
2993                         free(cbp->cb_handles);
2994                 }
2995
2996                 cbp->cb_handles = handles;
2997         }
2998
2999         cbp->cb_handles[cbp->cb_used++] = zhp;
3000
3001         return (0);
3002 }
3003
3004 static void
3005 get_all_datasets(uint_t types, zfs_handle_t ***dslist, size_t *count,
3006     boolean_t verbose)
3007 {
3008         get_all_cbdata_t cb = { 0 };
3009         cb.cb_types = types;
3010         cb.cb_verbose = verbose;
3011
3012         if (verbose)
3013                 set_progress_header(gettext("Reading ZFS config"));
3014
3015         (void) zfs_iter_root(g_zfs, get_one_dataset, &cb);
3016
3017         *dslist = cb.cb_handles;
3018         *count = cb.cb_used;
3019
3020         if (verbose)
3021                 finish_progress(gettext("done."));
3022 }
3023
3024 static int
3025 dataset_cmp(const void *a, const void *b)
3026 {
3027         zfs_handle_t **za = (zfs_handle_t **)a;
3028         zfs_handle_t **zb = (zfs_handle_t **)b;
3029         char mounta[MAXPATHLEN];
3030         char mountb[MAXPATHLEN];
3031         boolean_t gota, gotb;
3032
3033         if ((gota = (zfs_get_type(*za) == ZFS_TYPE_FILESYSTEM)) != 0)
3034                 verify(zfs_prop_get(*za, ZFS_PROP_MOUNTPOINT, mounta,
3035                     sizeof (mounta), NULL, NULL, 0, B_FALSE) == 0);
3036         if ((gotb = (zfs_get_type(*zb) == ZFS_TYPE_FILESYSTEM)) != 0)
3037                 verify(zfs_prop_get(*zb, ZFS_PROP_MOUNTPOINT, mountb,
3038                     sizeof (mountb), NULL, NULL, 0, B_FALSE) == 0);
3039
3040         if (gota && gotb)
3041                 return (strcmp(mounta, mountb));
3042
3043         if (gota)
3044                 return (-1);
3045         if (gotb)
3046                 return (1);
3047
3048         return (strcmp(zfs_get_name(a), zfs_get_name(b)));
3049 }
3050
3051 /*
3052  * Generic callback for sharing or mounting filesystems.  Because the code is so
3053  * similar, we have a common function with an extra parameter to determine which
3054  * mode we are using.
3055  */
3056 #define OP_SHARE        0x1
3057 #define OP_MOUNT        0x2
3058
3059 /*
3060  * Share or mount a dataset.
3061  */
3062 static int
3063 share_mount_one(zfs_handle_t *zhp, int op, int flags, char *protocol,
3064     boolean_t explicit, const char *options)
3065 {
3066         char mountpoint[ZFS_MAXPROPLEN];
3067         char shareopts[ZFS_MAXPROPLEN];
3068         char smbshareopts[ZFS_MAXPROPLEN];
3069         const char *cmdname = op == OP_SHARE ? "share" : "mount";
3070         struct mnttab mnt;
3071         uint64_t zoned, canmount;
3072         zfs_type_t type = zfs_get_type(zhp);
3073         boolean_t shared_nfs, shared_smb;
3074
3075         assert(type & (ZFS_TYPE_FILESYSTEM | ZFS_TYPE_VOLUME));
3076
3077         if (type == ZFS_TYPE_FILESYSTEM) {
3078                 /*
3079                  * Check to make sure we can mount/share this dataset.  If we
3080                  * are in the global zone and the filesystem is exported to a
3081                  * local zone, or if we are in a local zone and the
3082                  * filesystem is not exported, then it is an error.
3083                  */
3084                 zoned = zfs_prop_get_int(zhp, ZFS_PROP_ZONED);
3085
3086                 if (zoned && getzoneid() == GLOBAL_ZONEID) {
3087                         if (!explicit)
3088                                 return (0);
3089
3090                         (void) fprintf(stderr, gettext("cannot %s '%s': "
3091                             "dataset is exported to a local zone\n"), cmdname,
3092                             zfs_get_name(zhp));
3093                         return (1);
3094
3095                 } else if (!zoned && getzoneid() != GLOBAL_ZONEID) {
3096                         if (!explicit)
3097                                 return (0);
3098
3099                         (void) fprintf(stderr, gettext("cannot %s '%s': "
3100                             "permission denied\n"), cmdname,
3101                             zfs_get_name(zhp));
3102                         return (1);
3103                 }
3104
3105                 /*
3106                  * Ignore any filesystems which don't apply to us. This
3107                  * includes those with a legacy mountpoint, or those with
3108                  * legacy share options.
3109                  */
3110                 verify(zfs_prop_get(zhp, ZFS_PROP_MOUNTPOINT, mountpoint,
3111                     sizeof (mountpoint), NULL, NULL, 0, B_FALSE) == 0);
3112                 verify(zfs_prop_get(zhp, ZFS_PROP_SHARENFS, shareopts,
3113                     sizeof (shareopts), NULL, NULL, 0, B_FALSE) == 0);
3114                 verify(zfs_prop_get(zhp, ZFS_PROP_SHARESMB, smbshareopts,
3115                     sizeof (smbshareopts), NULL, NULL, 0, B_FALSE) == 0);
3116
3117                 if (op == OP_SHARE && strcmp(shareopts, "off") == 0 &&
3118                     strcmp(smbshareopts, "off") == 0) {
3119                         if (!explicit)
3120                                 return (0);
3121
3122                         (void) fprintf(stderr, gettext("cannot share '%s': "
3123                             "legacy share\n"), zfs_get_name(zhp));
3124                         (void) fprintf(stderr, gettext("use share(1M) to "
3125                             "share this filesystem, or set "
3126                             "sharenfs property on\n"));
3127                         return (1);
3128                 }
3129
3130                 /*
3131                  * We cannot share or mount legacy filesystems. If the
3132                  * shareopts is non-legacy but the mountpoint is legacy, we
3133                  * treat it as a legacy share.
3134                  */
3135                 if (strcmp(mountpoint, "legacy") == 0) {
3136                         if (!explicit)
3137                                 return (0);
3138
3139                         (void) fprintf(stderr, gettext("cannot %s '%s': "
3140                             "legacy mountpoint\n"), cmdname, zfs_get_name(zhp));
3141                         (void) fprintf(stderr, gettext("use %s(1M) to "
3142                             "%s this filesystem\n"), cmdname, cmdname);
3143                         return (1);
3144                 }
3145
3146                 if (strcmp(mountpoint, "none") == 0) {
3147                         if (!explicit)
3148                                 return (0);
3149
3150                         (void) fprintf(stderr, gettext("cannot %s '%s': no "
3151                             "mountpoint set\n"), cmdname, zfs_get_name(zhp));
3152                         return (1);
3153                 }
3154
3155                 /*
3156                  * canmount     explicit        outcome
3157                  * on           no              pass through
3158                  * on           yes             pass through
3159                  * off          no              return 0
3160                  * off          yes             display error, return 1
3161                  * noauto       no              return 0
3162                  * noauto       yes             pass through
3163                  */
3164                 canmount = zfs_prop_get_int(zhp, ZFS_PROP_CANMOUNT);
3165                 if (canmount == ZFS_CANMOUNT_OFF) {
3166                         if (!explicit)
3167                                 return (0);
3168
3169                         (void) fprintf(stderr, gettext("cannot %s '%s': "
3170                             "'canmount' property is set to 'off'\n"), cmdname,
3171                             zfs_get_name(zhp));
3172                         return (1);
3173                 } else if (canmount == ZFS_CANMOUNT_NOAUTO && !explicit) {
3174                         return (0);
3175                 }
3176
3177                 /*
3178                  * At this point, we have verified that the mountpoint and/or
3179                  * shareopts are appropriate for auto management. If the
3180                  * filesystem is already mounted or shared, return (failing
3181                  * for explicit requests); otherwise mount or share the
3182                  * filesystem.
3183                  */
3184                 switch (op) {
3185                 case OP_SHARE:
3186
3187                         shared_nfs = zfs_is_shared_nfs(zhp, NULL);
3188                         shared_smb = zfs_is_shared_smb(zhp, NULL);
3189
3190                         if (shared_nfs && shared_smb ||
3191                             (shared_nfs && strcmp(shareopts, "on") == 0 &&
3192                             strcmp(smbshareopts, "off") == 0) ||
3193                             (shared_smb && strcmp(smbshareopts, "on") == 0 &&
3194                             strcmp(shareopts, "off") == 0)) {
3195                                 if (!explicit)
3196                                         return (0);
3197
3198                                 (void) fprintf(stderr, gettext("cannot share "
3199                                     "'%s': filesystem already shared\n"),
3200                                     zfs_get_name(zhp));
3201                                 return (1);
3202                         }
3203
3204                         if (!zfs_is_mounted(zhp, NULL) &&
3205                             zfs_mount(zhp, NULL, 0) != 0)
3206                                 return (1);
3207
3208                         if (protocol == NULL) {
3209                                 if (zfs_shareall(zhp) != 0)
3210                                         return (1);
3211                         } else if (strcmp(protocol, "nfs") == 0) {
3212                                 if (zfs_share_nfs(zhp))
3213                                         return (1);
3214                         } else if (strcmp(protocol, "smb") == 0) {
3215                                 if (zfs_share_smb(zhp))
3216                                         return (1);
3217                         } else {
3218                                 (void) fprintf(stderr, gettext("cannot share "
3219                                     "'%s': invalid share type '%s' "
3220                                     "specified\n"),
3221                                     zfs_get_name(zhp), protocol);
3222                                 return (1);
3223                         }
3224
3225                         break;
3226
3227                 case OP_MOUNT:
3228                         if (options == NULL)
3229                                 mnt.mnt_mntopts = "";
3230                         else
3231                                 mnt.mnt_mntopts = (char *)options;
3232
3233                         if (!hasmntopt(&mnt, MNTOPT_REMOUNT) &&
3234                             zfs_is_mounted(zhp, NULL)) {
3235                                 if (!explicit)
3236                                         return (0);
3237
3238                                 (void) fprintf(stderr, gettext("cannot mount "
3239                                     "'%s': filesystem already mounted\n"),
3240                                     zfs_get_name(zhp));
3241                                 return (1);
3242                         }
3243
3244                         if (zfs_mount(zhp, options, flags) != 0)
3245                                 return (1);
3246                         break;
3247                 }
3248         } else
3249                 assert(op == OP_SHARE);
3250
3251         return (0);
3252 }
3253
3254 /*
3255  * Reports progress in the form "(current/total)".  Not thread-safe.
3256  */
3257 static void
3258 report_mount_progress(int current, int total)
3259 {
3260         static time_t last_progress_time = 0;
3261         time_t now = time(NULL);
3262         char info[32];
3263
3264         /* report 1..n instead of 0..n-1 */
3265         ++current;
3266
3267         /* display header if we're here for the first time */
3268         if (current == 1) {
3269                 set_progress_header(gettext("Mounting ZFS filesystems"));
3270         } else if (current != total && last_progress_time + MOUNT_TIME >= now) {
3271                 /* too soon to report again */
3272                 return;
3273         }
3274
3275         last_progress_time = now;
3276
3277         (void) sprintf(info, "(%d/%d)", current, total);
3278
3279         if (current == total)
3280                 finish_progress(info);
3281         else
3282                 update_progress(info);
3283 }
3284
3285 static void
3286 append_options(char *mntopts, char *newopts)
3287 {
3288         int len = strlen(mntopts);
3289
3290         /* original length plus new string to append plus 1 for the comma */
3291         if (len + 1 + strlen(newopts) >= MNT_LINE_MAX) {
3292                 (void) fprintf(stderr, gettext("the opts argument for "
3293                     "'%c' option is too long (more than %d chars)\n"),
3294                     "-o", MNT_LINE_MAX);
3295                 usage(B_FALSE);
3296         }
3297
3298         if (*mntopts)
3299                 mntopts[len++] = ',';
3300
3301         (void) strcpy(&mntopts[len], newopts);
3302 }
3303
3304 static int
3305 share_mount(int op, int argc, char **argv)
3306 {
3307         int do_all = 0;
3308         boolean_t verbose = B_FALSE;
3309         int c, ret = 0;
3310         char *options = NULL;
3311         int types, flags = 0;
3312
3313         /* check options */
3314         while ((c = getopt(argc, argv, op == OP_MOUNT ? ":avo:O" : "a"))
3315             != -1) {
3316                 switch (c) {
3317                 case 'a':
3318                         do_all = 1;
3319                         break;
3320                 case 'v':
3321                         verbose = B_TRUE;
3322                         break;
3323                 case 'o':
3324                         if (*optarg == '\0') {
3325                                 (void) fprintf(stderr, gettext("empty mount "
3326                                     "options (-o) specified\n"));
3327                                 usage(B_FALSE);
3328                         }
3329
3330                         if (options == NULL)
3331                                 options = safe_malloc(MNT_LINE_MAX + 1);
3332
3333                         /* option validation is done later */
3334                         append_options(options, optarg);
3335                         break;
3336
3337                 case 'O':
3338                         flags |= MS_OVERLAY;
3339                         break;
3340                 case ':':
3341                         (void) fprintf(stderr, gettext("missing argument for "
3342                             "'%c' option\n"), optopt);
3343                         usage(B_FALSE);
3344                         break;
3345                 case '?':
3346                         (void) fprintf(stderr, gettext("invalid option '%c'\n"),
3347                             optopt);
3348                         usage(B_FALSE);
3349                 }
3350         }
3351
3352         argc -= optind;
3353         argv += optind;
3354
3355         /* check number of arguments */
3356         if (do_all) {
3357                 zfs_handle_t **dslist = NULL;
3358                 size_t i, count = 0;
3359                 char *protocol = NULL;
3360
3361                 if (op == OP_MOUNT) {
3362                         types = ZFS_TYPE_FILESYSTEM;
3363                 } else if (argc > 0) {
3364                         if (strcmp(argv[0], "nfs") == 0 ||
3365                             strcmp(argv[0], "smb") == 0) {
3366                                 types = ZFS_TYPE_FILESYSTEM;
3367                         } else {
3368                                 (void) fprintf(stderr, gettext("share type "
3369                                     "must be 'nfs' or 'smb'\n"));
3370                                 usage(B_FALSE);
3371                         }
3372                         protocol = argv[0];
3373                         argc--;
3374                         argv++;
3375                 } else {
3376                         types = ZFS_TYPE_FILESYSTEM | ZFS_TYPE_VOLUME;
3377                 }
3378
3379                 if (argc != 0) {
3380                         (void) fprintf(stderr, gettext("too many arguments\n"));
3381                         usage(B_FALSE);
3382                 }
3383
3384                 start_progress_timer();
3385                 get_all_datasets(types, &dslist, &count, verbose);
3386
3387                 if (count == 0)
3388                         return (0);
3389
3390                 qsort(dslist, count, sizeof (void *), dataset_cmp);
3391
3392                 for (i = 0; i < count; i++) {
3393                         if (verbose)
3394                                 report_mount_progress(i, count);
3395
3396                         if (share_mount_one(dslist[i], op, flags, protocol,
3397                             B_FALSE, options) != 0)
3398                                 ret = 1;
3399                         zfs_close(dslist[i]);
3400                 }
3401
3402                 free(dslist);
3403         } else if (argc == 0) {
3404                 struct mnttab entry;
3405
3406                 if ((op == OP_SHARE) || (options != NULL)) {
3407                         (void) fprintf(stderr, gettext("missing filesystem "
3408                             "argument (specify -a for all)\n"));
3409                         usage(B_FALSE);
3410                 }
3411
3412                 /*
3413                  * When mount is given no arguments, go through /etc/mnttab and
3414                  * display any active ZFS mounts.  We hide any snapshots, since
3415                  * they are controlled automatically.
3416                  */
3417                 rewind(mnttab_file);
3418                 while (getmntent(mnttab_file, &entry) == 0) {
3419                         if (strcmp(entry.mnt_fstype, MNTTYPE_ZFS) != 0 ||
3420                             strchr(entry.mnt_special, '@') != NULL)
3421                                 continue;
3422
3423                         (void) printf("%-30s  %s\n", entry.mnt_special,
3424                             entry.mnt_mountp);
3425                 }
3426
3427         } else {
3428                 zfs_handle_t *zhp;
3429
3430                 types = ZFS_TYPE_FILESYSTEM;
3431                 if (op == OP_SHARE)
3432                         types |= ZFS_TYPE_VOLUME;
3433
3434                 if (argc > 1) {
3435                         (void) fprintf(stderr,
3436                             gettext("too many arguments\n"));
3437                         usage(B_FALSE);
3438                 }
3439
3440                 if ((zhp = zfs_open(g_zfs, argv[0], types)) == NULL) {
3441                         ret = 1;
3442                 } else {
3443                         ret = share_mount_one(zhp, op, flags, NULL, B_TRUE,
3444                             options);
3445                         zfs_close(zhp);
3446                 }
3447         }
3448
3449         return (ret);
3450 }
3451
3452 /*
3453  * zfs mount -a [nfs]
3454  * zfs mount filesystem
3455  *
3456  * Mount all filesystems, or mount the given filesystem.
3457  */
3458 static int
3459 zfs_do_mount(int argc, char **argv)
3460 {
3461         return (share_mount(OP_MOUNT, argc, argv));
3462 }
3463
3464 /*
3465  * zfs share -a [nfs | smb]
3466  * zfs share filesystem
3467  *
3468  * Share all filesystems, or share the given filesystem.
3469  */
3470 static int
3471 zfs_do_share(int argc, char **argv)
3472 {
3473         return (share_mount(OP_SHARE, argc, argv));
3474 }
3475
3476 typedef struct unshare_unmount_node {
3477         zfs_handle_t    *un_zhp;
3478         char            *un_mountp;
3479         uu_avl_node_t   un_avlnode;
3480 } unshare_unmount_node_t;
3481
3482 /* ARGSUSED */
3483 static int
3484 unshare_unmount_compare(const void *larg, const void *rarg, void *unused)
3485 {
3486         const unshare_unmount_node_t *l = larg;
3487         const unshare_unmount_node_t *r = rarg;
3488
3489         return (strcmp(l->un_mountp, r->un_mountp));
3490 }
3491
3492 /*
3493  * Convenience routine used by zfs_do_umount() and manual_unmount().  Given an
3494  * absolute path, find the entry /etc/mnttab, verify that its a ZFS filesystem,
3495  * and unmount it appropriately.
3496  */
3497 static int
3498 unshare_unmount_path(int op, char *path, int flags, boolean_t is_manual)
3499 {
3500         zfs_handle_t *zhp;
3501         int ret;
3502         struct stat64 statbuf;
3503         struct extmnttab entry;
3504         const char *cmdname = (op == OP_SHARE) ? "unshare" : "unmount";
3505         ino_t path_inode;
3506
3507         /*
3508          * Search for the path in /etc/mnttab.  Rather than looking for the
3509          * specific path, which can be fooled by non-standard paths (i.e. ".."
3510          * or "//"), we stat() the path and search for the corresponding
3511          * (major,minor) device pair.
3512          */
3513         if (stat64(path, &statbuf) != 0) {
3514                 (void) fprintf(stderr, gettext("cannot %s '%s': %s\n"),
3515                     cmdname, path, strerror(errno));
3516                 return (1);
3517         }
3518         path_inode = statbuf.st_ino;
3519
3520         /*
3521          * Search for the given (major,minor) pair in the mount table.
3522          */
3523         rewind(mnttab_file);
3524         while ((ret = getextmntent(mnttab_file, &entry, 0)) == 0) {
3525                 if (entry.mnt_major == major(statbuf.st_dev) &&
3526                     entry.mnt_minor == minor(statbuf.st_dev))
3527                         break;
3528         }
3529         if (ret != 0) {
3530                 if (op == OP_SHARE) {
3531                         (void) fprintf(stderr, gettext("cannot %s '%s': not "
3532                             "currently mounted\n"), cmdname, path);
3533                         return (1);
3534                 }
3535                 (void) fprintf(stderr, gettext("warning: %s not in mnttab\n"),
3536                     path);
3537                 if ((ret = umount2(path, flags)) != 0)
3538                         (void) fprintf(stderr, gettext("%s: %s\n"), path,
3539                             strerror(errno));
3540                 return (ret != 0);
3541         }
3542
3543         if (strcmp(entry.mnt_fstype, MNTTYPE_ZFS) != 0) {
3544                 (void) fprintf(stderr, gettext("cannot %s '%s': not a ZFS "
3545                     "filesystem\n"), cmdname, path);
3546                 return (1);
3547         }
3548
3549         if ((zhp = zfs_open(g_zfs, entry.mnt_special,
3550             ZFS_TYPE_FILESYSTEM)) == NULL)
3551                 return (1);
3552
3553         ret = 1;
3554         if (stat64(entry.mnt_mountp, &statbuf) != 0) {
3555                 (void) fprintf(stderr, gettext("cannot %s '%s': %s\n"),
3556                     cmdname, path, strerror(errno));
3557                 goto out;
3558         } else if (statbuf.st_ino != path_inode) {
3559                 (void) fprintf(stderr, gettext("cannot "
3560                     "%s '%s': not a mountpoint\n"), cmdname, path);
3561                 goto out;
3562         }
3563
3564         if (op == OP_SHARE) {
3565                 char nfs_mnt_prop[ZFS_MAXPROPLEN];
3566                 char smbshare_prop[ZFS_MAXPROPLEN];
3567
3568                 verify(zfs_prop_get(zhp, ZFS_PROP_SHARENFS, nfs_mnt_prop,
3569                     sizeof (nfs_mnt_prop), NULL, NULL, 0, B_FALSE) == 0);
3570                 verify(zfs_prop_get(zhp, ZFS_PROP_SHARESMB, smbshare_prop,
3571                     sizeof (smbshare_prop), NULL, NULL, 0, B_FALSE) == 0);
3572
3573                 if (strcmp(nfs_mnt_prop, "off") == 0 &&
3574                     strcmp(smbshare_prop, "off") == 0) {
3575                         (void) fprintf(stderr, gettext("cannot unshare "
3576                             "'%s': legacy share\n"), path);
3577                         (void) fprintf(stderr, gettext("use "
3578                             "unshare(1M) to unshare this filesystem\n"));
3579                 } else if (!zfs_is_shared(zhp)) {
3580                         (void) fprintf(stderr, gettext("cannot unshare '%s': "
3581                             "not currently shared\n"), path);
3582                 } else {
3583                         ret = zfs_unshareall_bypath(zhp, path);
3584                 }
3585         } else {
3586                 char mtpt_prop[ZFS_MAXPROPLEN];
3587
3588                 verify(zfs_prop_get(zhp, ZFS_PROP_MOUNTPOINT, mtpt_prop,
3589                     sizeof (mtpt_prop), NULL, NULL, 0, B_FALSE) == 0);
3590
3591                 if (is_manual) {
3592                         ret = zfs_unmount(zhp, NULL, flags);
3593                 } else if (strcmp(mtpt_prop, "legacy") == 0) {
3594                         (void) fprintf(stderr, gettext("cannot unmount "
3595                             "'%s': legacy mountpoint\n"),
3596                             zfs_get_name(zhp));
3597                         (void) fprintf(stderr, gettext("use umount(1M) "
3598                             "to unmount this filesystem\n"));
3599                 } else {
3600                         ret = zfs_unmountall(zhp, flags);
3601                 }
3602         }
3603
3604 out:
3605         zfs_close(zhp);
3606
3607         return (ret != 0);
3608 }
3609
3610 /*
3611  * Generic callback for unsharing or unmounting a filesystem.
3612  */
3613 static int
3614 unshare_unmount(int op, int argc, char **argv)
3615 {
3616         int do_all = 0;
3617         int flags = 0;
3618         int ret = 0;
3619         int types, c;
3620         zfs_handle_t *zhp;
3621         char nfs_mnt_prop[ZFS_MAXPROPLEN];
3622         char sharesmb[ZFS_MAXPROPLEN];
3623
3624         /* check options */
3625         while ((c = getopt(argc, argv, op == OP_SHARE ? "a" : "af")) != -1) {
3626                 switch (c) {
3627                 case 'a':
3628                         do_all = 1;
3629                         break;
3630                 case 'f':
3631                         flags = MS_FORCE;
3632                         break;
3633                 case '?':
3634                         (void) fprintf(stderr, gettext("invalid option '%c'\n"),
3635                             optopt);
3636                         usage(B_FALSE);
3637                 }
3638         }
3639
3640         argc -= optind;
3641         argv += optind;
3642
3643         if (do_all) {
3644                 /*
3645                  * We could make use of zfs_for_each() to walk all datasets in
3646                  * the system, but this would be very inefficient, especially
3647                  * since we would have to linearly search /etc/mnttab for each
3648                  * one.  Instead, do one pass through /etc/mnttab looking for
3649                  * zfs entries and call zfs_unmount() for each one.
3650                  *
3651                  * Things get a little tricky if the administrator has created
3652                  * mountpoints beneath other ZFS filesystems.  In this case, we
3653                  * have to unmount the deepest filesystems first.  To accomplish
3654                  * this, we place all the mountpoints in an AVL tree sorted by
3655                  * the special type (dataset name), and walk the result in
3656                  * reverse to make sure to get any snapshots first.
3657                  */
3658                 struct mnttab entry;
3659                 uu_avl_pool_t *pool;
3660                 uu_avl_t *tree;
3661                 unshare_unmount_node_t *node;
3662                 uu_avl_index_t idx;
3663                 uu_avl_walk_t *walk;
3664
3665                 if (argc != 0) {
3666                         (void) fprintf(stderr, gettext("too many arguments\n"));
3667                         usage(B_FALSE);
3668                 }
3669
3670                 if (((pool = uu_avl_pool_create("unmount_pool",
3671                     sizeof (unshare_unmount_node_t),
3672                     offsetof(unshare_unmount_node_t, un_avlnode),
3673                     unshare_unmount_compare, UU_DEFAULT)) == NULL) ||
3674                     ((tree = uu_avl_create(pool, NULL, UU_DEFAULT)) == NULL))
3675                         nomem();
3676
3677                 rewind(mnttab_file);
3678                 while (getmntent(mnttab_file, &entry) == 0) {
3679
3680                         /* ignore non-ZFS entries */
3681                         if (strcmp(entry.mnt_fstype, MNTTYPE_ZFS) != 0)
3682                                 continue;
3683
3684                         /* ignore snapshots */
3685                         if (strchr(entry.mnt_special, '@') != NULL)
3686                                 continue;
3687
3688                         if ((zhp = zfs_open(g_zfs, entry.mnt_special,
3689                             ZFS_TYPE_FILESYSTEM)) == NULL) {
3690                                 ret = 1;
3691                                 continue;
3692                         }
3693
3694                         switch (op) {
3695                         case OP_SHARE:
3696                                 verify(zfs_prop_get(zhp, ZFS_PROP_SHARENFS,
3697                                     nfs_mnt_prop,
3698                                     sizeof (nfs_mnt_prop),
3699                                     NULL, NULL, 0, B_FALSE) == 0);
3700                                 if (strcmp(nfs_mnt_prop, "off") != 0)
3701                                         break;
3702                                 verify(zfs_prop_get(zhp, ZFS_PROP_SHARESMB,
3703                                     nfs_mnt_prop,
3704                                     sizeof (nfs_mnt_prop),
3705                                     NULL, NULL, 0, B_FALSE) == 0);
3706                                 if (strcmp(nfs_mnt_prop, "off") == 0)
3707                                         continue;
3708                                 break;
3709                         case OP_MOUNT:
3710                                 /* Ignore legacy mounts */
3711                                 verify(zfs_prop_get(zhp, ZFS_PROP_MOUNTPOINT,
3712                                     nfs_mnt_prop,
3713                                     sizeof (nfs_mnt_prop),
3714                                     NULL, NULL, 0, B_FALSE) == 0);
3715                                 if (strcmp(nfs_mnt_prop, "legacy") == 0)
3716                                         continue;
3717                                 /* Ignore canmount=noauto mounts */
3718                                 if (zfs_prop_get_int(zhp, ZFS_PROP_CANMOUNT) ==
3719                                     ZFS_CANMOUNT_NOAUTO)
3720                                         continue;
3721                         default:
3722                                 break;
3723                         }
3724
3725                         node = safe_malloc(sizeof (unshare_unmount_node_t));
3726                         node->un_zhp = zhp;
3727                         node->un_mountp = safe_strdup(entry.mnt_mountp);
3728
3729                         uu_avl_node_init(node, &node->un_avlnode, pool);
3730
3731                         if (uu_avl_find(tree, node, NULL, &idx) == NULL) {
3732                                 uu_avl_insert(tree, node, idx);
3733                         } else {
3734                                 zfs_close(node->un_zhp);
3735                                 free(node->un_mountp);
3736                                 free(node);
3737                         }
3738                 }
3739
3740                 /*
3741                  * Walk the AVL tree in reverse, unmounting each filesystem and
3742                  * removing it from the AVL tree in the process.
3743                  */
3744                 if ((walk = uu_avl_walk_start(tree,
3745                     UU_WALK_REVERSE | UU_WALK_ROBUST)) == NULL)
3746                         nomem();
3747
3748                 while ((node = uu_avl_walk_next(walk)) != NULL) {
3749                         uu_avl_remove(tree, node);
3750
3751                         switch (op) {
3752                         case OP_SHARE:
3753                                 if (zfs_unshareall_bypath(node->un_zhp,
3754                                     node->un_mountp) != 0)
3755                                         ret = 1;
3756                                 break;
3757
3758                         case OP_MOUNT:
3759                                 if (zfs_unmount(node->un_zhp,
3760                                     node->un_mountp, flags) != 0)
3761                                         ret = 1;
3762                                 break;
3763                         }
3764
3765                         zfs_close(node->un_zhp);
3766                         free(node->un_mountp);
3767                         free(node);
3768                 }
3769
3770                 uu_avl_walk_end(walk);
3771                 uu_avl_destroy(tree);
3772                 uu_avl_pool_destroy(pool);
3773
3774         } else {
3775                 if (argc != 1) {
3776                         if (argc == 0)
3777                                 (void) fprintf(stderr,
3778                                     gettext("missing filesystem argument\n"));
3779                         else
3780                                 (void) fprintf(stderr,
3781                                     gettext("too many arguments\n"));
3782                         usage(B_FALSE);
3783                 }
3784
3785                 /*
3786                  * We have an argument, but it may be a full path or a ZFS
3787                  * filesystem.  Pass full paths off to unmount_path() (shared by
3788                  * manual_unmount), otherwise open the filesystem and pass to
3789                  * zfs_unmount().
3790                  */
3791                 if (argv[0][0] == '/')
3792                         return (unshare_unmount_path(op, argv[0],
3793                             flags, B_FALSE));
3794
3795                 types = ZFS_TYPE_FILESYSTEM;
3796                 if (op == OP_SHARE)
3797                         types |= ZFS_TYPE_VOLUME;
3798
3799                 if ((zhp = zfs_open(g_zfs, argv[0], types)) == NULL)
3800                         return (1);
3801
3802                 if (zfs_get_type(zhp) == ZFS_TYPE_FILESYSTEM) {
3803                         verify(zfs_prop_get(zhp, op == OP_SHARE ?
3804                             ZFS_PROP_SHARENFS : ZFS_PROP_MOUNTPOINT,
3805                             nfs_mnt_prop, sizeof (nfs_mnt_prop), NULL,
3806                             NULL, 0, B_FALSE) == 0);
3807
3808                         switch (op) {
3809                         case OP_SHARE:
3810                                 verify(zfs_prop_get(zhp, ZFS_PROP_SHARENFS,
3811                                     nfs_mnt_prop,
3812                                     sizeof (nfs_mnt_prop),
3813                                     NULL, NULL, 0, B_FALSE) == 0);
3814                                 verify(zfs_prop_get(zhp, ZFS_PROP_SHARESMB,
3815                                     sharesmb, sizeof (sharesmb), NULL, NULL,
3816                                     0, B_FALSE) == 0);
3817
3818                                 if (strcmp(nfs_mnt_prop, "off") == 0 &&
3819                                     strcmp(sharesmb, "off") == 0) {
3820                                         (void) fprintf(stderr, gettext("cannot "
3821                                             "unshare '%s': legacy share\n"),
3822                                             zfs_get_name(zhp));
3823                                         (void) fprintf(stderr, gettext("use "
3824                                             "unshare(1M) to unshare this "
3825                                             "filesystem\n"));
3826                                         ret = 1;
3827                                 } else if (!zfs_is_shared(zhp)) {
3828                                         (void) fprintf(stderr, gettext("cannot "
3829                                             "unshare '%s': not currently "
3830                                             "shared\n"), zfs_get_name(zhp));
3831                                         ret = 1;
3832                                 } else if (zfs_unshareall(zhp) != 0) {
3833                                         ret = 1;
3834                                 }
3835                                 break;
3836
3837                         case OP_MOUNT:
3838                                 if (strcmp(nfs_mnt_prop, "legacy") == 0) {
3839                                         (void) fprintf(stderr, gettext("cannot "
3840                                             "unmount '%s': legacy "
3841                                             "mountpoint\n"), zfs_get_name(zhp));
3842                                         (void) fprintf(stderr, gettext("use "
3843                                             "umount(1M) to unmount this "
3844                                             "filesystem\n"));
3845                                         ret = 1;
3846                                 } else if (!zfs_is_mounted(zhp, NULL)) {
3847                                         (void) fprintf(stderr, gettext("cannot "
3848                                             "unmount '%s': not currently "
3849                                             "mounted\n"),
3850                                             zfs_get_name(zhp));
3851                                         ret = 1;
3852                                 } else if (zfs_unmountall(zhp, flags) != 0) {
3853                                         ret = 1;
3854                                 }
3855                                 break;
3856                         }
3857                 }
3858
3859                 zfs_close(zhp);
3860         }
3861
3862         return (ret);
3863 }
3864
3865 /*
3866  * zfs unmount -a
3867  * zfs unmount filesystem
3868  *
3869  * Unmount all filesystems, or a specific ZFS filesystem.
3870  */
3871 static int
3872 zfs_do_unmount(int argc, char **argv)
3873 {
3874         return (unshare_unmount(OP_MOUNT, argc, argv));
3875 }
3876
3877 /*
3878  * zfs unshare -a
3879  * zfs unshare filesystem
3880  *
3881  * Unshare all filesystems, or a specific ZFS filesystem.
3882  */
3883 static int
3884 zfs_do_unshare(int argc, char **argv)
3885 {
3886         return (unshare_unmount(OP_SHARE, argc, argv));
3887 }
3888
3889 /* ARGSUSED */
3890 static int
3891 zfs_do_python(int argc, char **argv)
3892 {
3893         (void) execv(pypath, argv-1);
3894         (void) printf("internal error: %s not found\n", pypath);
3895         return (-1);
3896 }
3897
3898 /*
3899  * Called when invoked as /etc/fs/zfs/mount.  Do the mount if the mountpoint is
3900  * 'legacy'.  Otherwise, complain that use should be using 'zfs mount'.
3901  */
3902 static int
3903 manual_mount(int argc, char **argv)
3904 {
3905         zfs_handle_t *zhp;
3906         char mountpoint[ZFS_MAXPROPLEN];
3907         char mntopts[MNT_LINE_MAX] = { '\0' };
3908         int ret;
3909         int c;
3910         int flags = 0;
3911         char *dataset, *path;
3912
3913         /* check options */
3914         while ((c = getopt(argc, argv, ":mo:O")) != -1) {
3915                 switch (c) {
3916                 case 'o':
3917                         (void) strlcpy(mntopts, optarg, sizeof (mntopts));
3918                         break;
3919                 case 'O':
3920                         flags |= MS_OVERLAY;
3921                         break;
3922                 case 'm':
3923                         flags |= MS_NOMNTTAB;
3924                         break;
3925                 case ':':
3926                         (void) fprintf(stderr, gettext("missing argument for "
3927                             "'%c' option\n"), optopt);
3928                         usage(B_FALSE);
3929                         break;
3930                 case '?':
3931                         (void) fprintf(stderr, gettext("invalid option '%c'\n"),
3932                             optopt);
3933                         (void) fprintf(stderr, gettext("usage: mount [-o opts] "
3934                             "<path>\n"));
3935                         return (2);
3936                 }
3937         }
3938
3939         argc -= optind;
3940         argv += optind;
3941
3942         /* check that we only have two arguments */
3943         if (argc != 2) {
3944                 if (argc == 0)
3945                         (void) fprintf(stderr, gettext("missing dataset "
3946                             "argument\n"));
3947                 else if (argc == 1)
3948                         (void) fprintf(stderr,
3949                             gettext("missing mountpoint argument\n"));
3950                 else
3951                         (void) fprintf(stderr, gettext("too many arguments\n"));
3952                 (void) fprintf(stderr, "usage: mount <dataset> <mountpoint>\n");
3953                 return (2);
3954         }
3955
3956         dataset = argv[0];
3957         path = argv[1];
3958
3959         /* try to open the dataset */
3960         if ((zhp = zfs_open(g_zfs, dataset, ZFS_TYPE_FILESYSTEM)) == NULL)
3961                 return (1);
3962
3963         (void) zfs_prop_get(zhp, ZFS_PROP_MOUNTPOINT, mountpoint,
3964             sizeof (mountpoint), NULL, NULL, 0, B_FALSE);
3965
3966         /* check for legacy mountpoint and complain appropriately */
3967         ret = 0;
3968         if (strcmp(mountpoint, ZFS_MOUNTPOINT_LEGACY) == 0) {
3969                 if (mount(dataset, path, MS_OPTIONSTR | flags, MNTTYPE_ZFS,
3970                     NULL, 0, mntopts, sizeof (mntopts)) != 0) {
3971                         (void) fprintf(stderr, gettext("mount failed: %s\n"),
3972                             strerror(errno));
3973                         ret = 1;
3974                 }
3975         } else {
3976                 (void) fprintf(stderr, gettext("filesystem '%s' cannot be "
3977                     "mounted using 'mount -F zfs'\n"), dataset);
3978                 (void) fprintf(stderr, gettext("Use 'zfs set mountpoint=%s' "
3979                     "instead.\n"), path);
3980                 (void) fprintf(stderr, gettext("If you must use 'mount -F zfs' "
3981                     "or /etc/vfstab, use 'zfs set mountpoint=legacy'.\n"));
3982                 (void) fprintf(stderr, gettext("See zfs(1M) for more "
3983                     "information.\n"));
3984                 ret = 1;
3985         }
3986
3987         return (ret);
3988 }
3989
3990 /*
3991  * Called when invoked as /etc/fs/zfs/umount.  Unlike a manual mount, we allow
3992  * unmounts of non-legacy filesystems, as this is the dominant administrative
3993  * interface.
3994  */
3995 static int
3996 manual_unmount(int argc, char **argv)
3997 {
3998         int flags = 0;
3999         int c;
4000
4001         /* check options */
4002         while ((c = getopt(argc, argv, "f")) != -1) {
4003                 switch (c) {
4004                 case 'f':
4005                         flags = MS_FORCE;
4006                         break;
4007                 case '?':
4008                         (void) fprintf(stderr, gettext("invalid option '%c'\n"),
4009                             optopt);
4010                         (void) fprintf(stderr, gettext("usage: unmount [-f] "
4011                             "<path>\n"));
4012                         return (2);
4013                 }
4014         }
4015
4016         argc -= optind;
4017         argv += optind;
4018
4019         /* check arguments */
4020         if (argc != 1) {
4021                 if (argc == 0)
4022                         (void) fprintf(stderr, gettext("missing path "
4023                             "argument\n"));
4024                 else
4025                         (void) fprintf(stderr, gettext("too many arguments\n"));
4026                 (void) fprintf(stderr, gettext("usage: unmount [-f] <path>\n"));
4027                 return (2);
4028         }
4029
4030         return (unshare_unmount_path(OP_MOUNT, argv[0], flags, B_TRUE));
4031 }
4032
4033 static int
4034 find_command_idx(char *command, int *idx)
4035 {
4036         int i;
4037
4038         for (i = 0; i < NCOMMAND; i++) {
4039                 if (command_table[i].name == NULL)
4040                         continue;
4041
4042                 if (strcmp(command, command_table[i].name) == 0) {
4043                         *idx = i;
4044                         return (0);
4045                 }
4046         }
4047         return (1);
4048 }
4049
4050 int
4051 main(int argc, char **argv)
4052 {
4053         int ret;
4054         int i;
4055         char *progname;
4056         char *cmdname;
4057
4058         (void) setlocale(LC_ALL, "");
4059         (void) textdomain(TEXT_DOMAIN);
4060
4061         opterr = 0;
4062
4063         if ((g_zfs = libzfs_init()) == NULL) {
4064                 (void) fprintf(stderr, gettext("internal error: failed to "
4065                     "initialize ZFS library\n"));
4066                 return (1);
4067         }
4068
4069         zpool_set_history_str("zfs", argc, argv, history_str);
4070         verify(zpool_stage_history(g_zfs, history_str) == 0);
4071
4072         libzfs_print_on_error(g_zfs, B_TRUE);
4073
4074         if ((mnttab_file = fopen(MNTTAB, "r")) == NULL) {
4075                 (void) fprintf(stderr, gettext("internal error: unable to "
4076                     "open %s\n"), MNTTAB);
4077                 return (1);
4078         }
4079
4080         /*
4081          * This command also doubles as the /etc/fs mount and unmount program.
4082          * Determine if we should take this behavior based on argv[0].
4083          */
4084         progname = basename(argv[0]);
4085         if (strcmp(progname, "mount") == 0) {
4086                 ret = manual_mount(argc, argv);
4087         } else if (strcmp(progname, "umount") == 0) {
4088                 ret = manual_unmount(argc, argv);
4089         } else {
4090                 /*
4091                  * Make sure the user has specified some command.
4092                  */
4093                 if (argc < 2) {
4094                         (void) fprintf(stderr, gettext("missing command\n"));
4095                         usage(B_FALSE);
4096                 }
4097
4098                 cmdname = argv[1];
4099
4100                 /*
4101                  * The 'umount' command is an alias for 'unmount'
4102                  */
4103                 if (strcmp(cmdname, "umount") == 0)
4104                         cmdname = "unmount";
4105
4106                 /*
4107                  * The 'recv' command is an alias for 'receive'
4108                  */
4109                 if (strcmp(cmdname, "recv") == 0)
4110                         cmdname = "receive";
4111
4112                 /*
4113                  * Special case '-?'
4114                  */
4115                 if (strcmp(cmdname, "-?") == 0)
4116                         usage(B_TRUE);
4117
4118                 /*
4119                  * Run the appropriate command.
4120                  */
4121                 libzfs_mnttab_cache(g_zfs, B_TRUE);
4122                 if (find_command_idx(cmdname, &i) == 0) {
4123                         current_command = &command_table[i];
4124                         ret = command_table[i].func(argc - 1, argv + 1);
4125                 } else if (strchr(cmdname, '=') != NULL) {
4126                         verify(find_command_idx("set", &i) == 0);
4127                         current_command = &command_table[i];
4128                         ret = command_table[i].func(argc, argv);
4129                 } else {
4130                         (void) fprintf(stderr, gettext("unrecognized "
4131                             "command '%s'\n"), cmdname);
4132                         usage(B_FALSE);
4133                 }
4134                 libzfs_mnttab_cache(g_zfs, B_FALSE);
4135         }
4136
4137         (void) fclose(mnttab_file);
4138
4139         libzfs_fini(g_zfs);
4140
4141         /*
4142          * The 'ZFS_ABORT' environment variable causes us to dump core on exit
4143          * for the purposes of running ::findleaks.
4144          */
4145         if (getenv("ZFS_ABORT") != NULL) {
4146                 (void) printf("dumping core by request\n");
4147                 abort();
4148         }
4149
4150         return (ret);
4151 }