1fa9e4066Sahrens /*
2fa9e4066Sahrens * CDDL HEADER START
3fa9e4066Sahrens *
4fa9e4066Sahrens * The contents of this file are subject to the terms of the
5ea8dc4b6Seschrock * Common Development and Distribution License (the "License").
6ea8dc4b6Seschrock * You may not use this file except in compliance with the License.
7fa9e4066Sahrens *
8fa9e4066Sahrens * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9fa9e4066Sahrens * or http://www.opensolaris.org/os/licensing.
10fa9e4066Sahrens * See the License for the specific language governing permissions
11fa9e4066Sahrens * and limitations under the License.
12fa9e4066Sahrens *
13fa9e4066Sahrens * When distributing Covered Code, include this CDDL HEADER in each
14fa9e4066Sahrens * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15fa9e4066Sahrens * If applicable, add the following below this CDDL HEADER, with the
16fa9e4066Sahrens * fields enclosed by brackets "[]" replaced with your own identifying
17fa9e4066Sahrens * information: Portions Copyright [yyyy] [name of copyright owner]
18fa9e4066Sahrens *
19fa9e4066Sahrens * CDDL HEADER END
20fa9e4066Sahrens */
21f3861e1aSahl
22fa9e4066Sahrens /*
233f9d6ad7SLin Ling * Copyright (c) 2005, 2010, Oracle and/or its affiliates. All rights reserved.
24dfc11533SChris Williamson * Copyright (c) 2011, 2016 by Delphix. All rights reserved.
2533f5ff17SMilan Jurik * Copyright 2012 Milan Jurik. All rights reserved.
26b73ccab0SMike Gerdts * Copyright 2019 Joyent, Inc.
270d8fa8f8SMartin Matuska * Copyright (c) 2011-2012 Pawel Jakub Dawidek. All rights reserved.
28a7a845e4SSteven Hartland * Copyright (c) 2013 Steven Hartland. All rights reserved.
29c3d26abcSMatthew Ahrens * Copyright (c) 2014 Integros [integros.com]
30c16bcc45SIgor Kozhukhov * Copyright 2016 Igor Kozhukhov <ikozhukhov@gmail.com>.
318808ac5dSYuri Pankov * Copyright 2016 Nexenta Systems, Inc.
3252675910SAlek Pinchuk * Copyright (c) 2018 Datto Inc.
331e9e241fSAndrew Stormont * Copyright 2021 RackTop Systems, Inc.
34fa9e4066Sahrens */
35fa9e4066Sahrens
36fa9e4066Sahrens #include <assert.h>
37e9dbad6fSeschrock #include <ctype.h>
38fa9e4066Sahrens #include <errno.h>
395602294fSDan Kimmel #include <getopt.h>
40fa9e4066Sahrens #include <libgen.h>
41fa9e4066Sahrens #include <libintl.h>
42fa9e4066Sahrens #include <libuutil.h>
43ecd6cf80Smarks #include <libnvpair.h>
44fa9e4066Sahrens #include <locale.h>
45fa9e4066Sahrens #include <stddef.h>
46fa9e4066Sahrens #include <stdio.h>
47fa9e4066Sahrens #include <stdlib.h>
48fa9e4066Sahrens #include <strings.h>
49fa9e4066Sahrens #include <unistd.h>
50fa9e4066Sahrens #include <fcntl.h>
51fa9e4066Sahrens #include <zone.h>
5214843421SMatthew Ahrens #include <grp.h>
5314843421SMatthew Ahrens #include <pwd.h>
5499d5e173STim Haley #include <signal.h>
55dfc11533SChris Williamson #include <sys/debug.h>
561af68beaSAlexander Stetsenko #include <sys/list.h>
57fa9e4066Sahrens #include <sys/mkdev.h>
58fa9e4066Sahrens #include <sys/mntent.h>
59fa9e4066Sahrens #include <sys/mnttab.h>
60fa9e4066Sahrens #include <sys/mount.h>
61fa9e4066Sahrens #include <sys/stat.h>
6214843421SMatthew Ahrens #include <sys/fs/zfs.h>
63a8b6ddafSMark J Musante #include <sys/types.h>
64a8b6ddafSMark J Musante #include <time.h>
65f67950b2SNasf-Fan #include <sys/zfs_project.h>
66591e0e13SSebastien Roy #include <synch.h>
67fa9e4066Sahrens
68fa9e4066Sahrens #include <libzfs.h>
694445fffbSMatthew Ahrens #include <libzfs_core.h>
701af68beaSAlexander Stetsenko #include <zfs_prop.h>
711af68beaSAlexander Stetsenko #include <zfs_deleg.h>
72d8ab6e12SDon Brady #include <libzutil.h>
73ecd6cf80Smarks #include <libuutil.h>
741af68beaSAlexander Stetsenko #include <aclutils.h>
751af68beaSAlexander Stetsenko #include <directory.h>
761ed6b69aSGordon Ross #include <idmap.h>
778a981c33SDaniel Hoffman #include <libshare.h>
78fa9e4066Sahrens
79fa9e4066Sahrens #include "zfs_iter.h"
8099653d4eSeschrock #include "zfs_util.h"
810a586ceaSMark Shellenbaum #include "zfs_comutil.h"
82f67950b2SNasf-Fan #include "zfs_projectutil.h"
8399653d4eSeschrock
8499653d4eSeschrock libzfs_handle_t *g_zfs;
85fa9e4066Sahrens
86fa9e4066Sahrens static FILE *mnttab_file;
872a6b87f0Sek static char history_str[HIS_MAX_RECORD_LEN];
884445fffbSMatthew Ahrens static boolean_t log_history = B_TRUE;
89fa9e4066Sahrens
90fa9e4066Sahrens static int zfs_do_clone(int argc, char **argv);
91fa9e4066Sahrens static int zfs_do_create(int argc, char **argv);
92fa9e4066Sahrens static int zfs_do_destroy(int argc, char **argv);
93fa9e4066Sahrens static int zfs_do_get(int argc, char **argv);
94fa9e4066Sahrens static int zfs_do_inherit(int argc, char **argv);
95fa9e4066Sahrens static int zfs_do_list(int argc, char **argv);
96fa9e4066Sahrens static int zfs_do_mount(int argc, char **argv);
97fa9e4066Sahrens static int zfs_do_rename(int argc, char **argv);
98fa9e4066Sahrens static int zfs_do_rollback(int argc, char **argv);
99fa9e4066Sahrens static int zfs_do_set(int argc, char **argv);
100e7437265Sahrens static int zfs_do_upgrade(int argc, char **argv);
101fa9e4066Sahrens static int zfs_do_snapshot(int argc, char **argv);
102fa9e4066Sahrens static int zfs_do_unmount(int argc, char **argv);
103fa9e4066Sahrens static int zfs_do_share(int argc, char **argv);
104fa9e4066Sahrens static int zfs_do_unshare(int argc, char **argv);
105f2a3c691Sahrens static int zfs_do_send(int argc, char **argv);
106f2a3c691Sahrens static int zfs_do_receive(int argc, char **argv);
10799653d4eSeschrock static int zfs_do_promote(int argc, char **argv);
10814843421SMatthew Ahrens static int zfs_do_userspace(int argc, char **argv);
1091af68beaSAlexander Stetsenko static int zfs_do_allow(int argc, char **argv);
1101af68beaSAlexander Stetsenko static int zfs_do_unallow(int argc, char **argv);
111842727c2SChris Kirby static int zfs_do_hold(int argc, char **argv);
1121af68beaSAlexander Stetsenko static int zfs_do_holds(int argc, char **argv);
113842727c2SChris Kirby static int zfs_do_release(int argc, char **argv);
11499d5e173STim Haley static int zfs_do_diff(int argc, char **argv);
11578f17100SMatthew Ahrens static int zfs_do_bookmark(int argc, char **argv);
1165cabbc6bSPrashanth Sreenivasa static int zfs_do_remap(int argc, char **argv);
117dfc11533SChris Williamson static int zfs_do_channel_program(int argc, char **argv);
118eb633035STom Caputi static int zfs_do_load_key(int argc, char **argv);
119eb633035STom Caputi static int zfs_do_unload_key(int argc, char **argv);
120eb633035STom Caputi static int zfs_do_change_key(int argc, char **argv);
121f67950b2SNasf-Fan static int zfs_do_project(int argc, char **argv);
122fa9e4066Sahrens
123fa9e4066Sahrens /*
12429ab75c9Srm * Enable a reasonable set of defaults for libumem debugging on DEBUG builds.
125fa9e4066Sahrens */
12629ab75c9Srm
12729ab75c9Srm #ifdef DEBUG
128fa9e4066Sahrens const char *
_umem_debug_init(void)129f3861e1aSahl _umem_debug_init(void)
130fa9e4066Sahrens {
131fa9e4066Sahrens return ("default,verbose"); /* $UMEM_DEBUG setting */
132fa9e4066Sahrens }
133fa9e4066Sahrens
134fa9e4066Sahrens const char *
_umem_logging_init(void)135fa9e4066Sahrens _umem_logging_init(void)
136fa9e4066Sahrens {
137fa9e4066Sahrens return ("fail,contents"); /* $UMEM_LOGGING setting */
138fa9e4066Sahrens }
13929ab75c9Srm #endif
140fa9e4066Sahrens
14165cd9f28Seschrock typedef enum {
14265cd9f28Seschrock HELP_CLONE,
14365cd9f28Seschrock HELP_CREATE,
14465cd9f28Seschrock HELP_DESTROY,
14565cd9f28Seschrock HELP_GET,
14665cd9f28Seschrock HELP_INHERIT,
147e7437265Sahrens HELP_UPGRADE,
14865cd9f28Seschrock HELP_LIST,
14965cd9f28Seschrock HELP_MOUNT,
15099653d4eSeschrock HELP_PROMOTE,
151f2a3c691Sahrens HELP_RECEIVE,
15265cd9f28Seschrock HELP_RENAME,
15365cd9f28Seschrock HELP_ROLLBACK,
154f2a3c691Sahrens HELP_SEND,
15565cd9f28Seschrock HELP_SET,
15665cd9f28Seschrock HELP_SHARE,
15765cd9f28Seschrock HELP_SNAPSHOT,
15865cd9f28Seschrock HELP_UNMOUNT,
159ecd6cf80Smarks HELP_UNSHARE,
160ecd6cf80Smarks HELP_ALLOW,
16114843421SMatthew Ahrens HELP_UNALLOW,
16214843421SMatthew Ahrens HELP_USERSPACE,
163842727c2SChris Kirby HELP_GROUPSPACE,
164f67950b2SNasf-Fan HELP_PROJECTSPACE,
165f67950b2SNasf-Fan HELP_PROJECT,
166842727c2SChris Kirby HELP_HOLD,
167842727c2SChris Kirby HELP_HOLDS,
16899d5e173STim Haley HELP_RELEASE,
16919b94df9SMatthew Ahrens HELP_DIFF,
1705cabbc6bSPrashanth Sreenivasa HELP_REMAP,
17178f17100SMatthew Ahrens HELP_BOOKMARK,
172dfc11533SChris Williamson HELP_CHANNEL_PROGRAM,
173eb633035STom Caputi HELP_LOAD_KEY,
174eb633035STom Caputi HELP_UNLOAD_KEY,
175eb633035STom Caputi HELP_CHANGE_KEY,
17665cd9f28Seschrock } zfs_help_t;
17765cd9f28Seschrock
178fa9e4066Sahrens typedef struct zfs_command {
179fa9e4066Sahrens const char *name;
180fa9e4066Sahrens int (*func)(int argc, char **argv);
18165cd9f28Seschrock zfs_help_t usage;
182fa9e4066Sahrens } zfs_command_t;
183fa9e4066Sahrens
184fa9e4066Sahrens /*
185fa9e4066Sahrens * Master command table. Each ZFS command has a name, associated function, and
186ea8dc4b6Seschrock * usage message. The usage messages need to be internationalized, so we have
187ea8dc4b6Seschrock * to have a function to return the usage message based on a command index.
18865cd9f28Seschrock *
18965cd9f28Seschrock * These commands are organized according to how they are displayed in the usage
19065cd9f28Seschrock * message. An empty command (one with a NULL name) indicates an empty line in
19165cd9f28Seschrock * the generic usage message.
192fa9e4066Sahrens */
193fa9e4066Sahrens static zfs_command_t command_table[] = {
19465cd9f28Seschrock { "create", zfs_do_create, HELP_CREATE },
19565cd9f28Seschrock { "destroy", zfs_do_destroy, HELP_DESTROY },
196fa9e4066Sahrens { NULL },
19765cd9f28Seschrock { "snapshot", zfs_do_snapshot, HELP_SNAPSHOT },
19865cd9f28Seschrock { "rollback", zfs_do_rollback, HELP_ROLLBACK },
19965cd9f28Seschrock { "clone", zfs_do_clone, HELP_CLONE },
20099653d4eSeschrock { "promote", zfs_do_promote, HELP_PROMOTE },
20165cd9f28Seschrock { "rename", zfs_do_rename, HELP_RENAME },
20278f17100SMatthew Ahrens { "bookmark", zfs_do_bookmark, HELP_BOOKMARK },
203dfc11533SChris Williamson { "program", zfs_do_channel_program, HELP_CHANNEL_PROGRAM },
204fa9e4066Sahrens { NULL },
20565cd9f28Seschrock { "list", zfs_do_list, HELP_LIST },
206fa9e4066Sahrens { NULL },
20765cd9f28Seschrock { "set", zfs_do_set, HELP_SET },
20892241e0bSTom Erickson { "get", zfs_do_get, HELP_GET },
20965cd9f28Seschrock { "inherit", zfs_do_inherit, HELP_INHERIT },
210e7437265Sahrens { "upgrade", zfs_do_upgrade, HELP_UPGRADE },
211f67950b2SNasf-Fan { NULL },
21214843421SMatthew Ahrens { "userspace", zfs_do_userspace, HELP_USERSPACE },
21314843421SMatthew Ahrens { "groupspace", zfs_do_userspace, HELP_GROUPSPACE },
214f67950b2SNasf-Fan { "projectspace", zfs_do_userspace, HELP_PROJECTSPACE },
215f67950b2SNasf-Fan { NULL },
216f67950b2SNasf-Fan { "project", zfs_do_project, HELP_PROJECT },
217fa9e4066Sahrens { NULL },
21865cd9f28Seschrock { "mount", zfs_do_mount, HELP_MOUNT },
21965cd9f28Seschrock { "unmount", zfs_do_unmount, HELP_UNMOUNT },
22065cd9f28Seschrock { "share", zfs_do_share, HELP_SHARE },
22165cd9f28Seschrock { "unshare", zfs_do_unshare, HELP_UNSHARE },
222fa9e4066Sahrens { NULL },
223f2a3c691Sahrens { "send", zfs_do_send, HELP_SEND },
224f2a3c691Sahrens { "receive", zfs_do_receive, HELP_RECEIVE },
225ecd6cf80Smarks { NULL },
2261af68beaSAlexander Stetsenko { "allow", zfs_do_allow, HELP_ALLOW },
227ecd6cf80Smarks { NULL },
2281af68beaSAlexander Stetsenko { "unallow", zfs_do_unallow, HELP_UNALLOW },
229842727c2SChris Kirby { NULL },
230842727c2SChris Kirby { "hold", zfs_do_hold, HELP_HOLD },
2311af68beaSAlexander Stetsenko { "holds", zfs_do_holds, HELP_HOLDS },
232842727c2SChris Kirby { "release", zfs_do_release, HELP_RELEASE },
23399d5e173STim Haley { "diff", zfs_do_diff, HELP_DIFF },
2345cabbc6bSPrashanth Sreenivasa { "remap", zfs_do_remap, HELP_REMAP },
235eb633035STom Caputi { "load-key", zfs_do_load_key, HELP_LOAD_KEY },
236eb633035STom Caputi { "unload-key", zfs_do_unload_key, HELP_UNLOAD_KEY },
237eb633035STom Caputi { "change-key", zfs_do_change_key, HELP_CHANGE_KEY },
238fa9e4066Sahrens };
239fa9e4066Sahrens
240fa9e4066Sahrens #define NCOMMAND (sizeof (command_table) / sizeof (command_table[0]))
241fa9e4066Sahrens
242fa9e4066Sahrens zfs_command_t *current_command;
243fa9e4066Sahrens
24465cd9f28Seschrock static const char *
get_usage(zfs_help_t idx)24565cd9f28Seschrock get_usage(zfs_help_t idx)
24665cd9f28Seschrock {
24765cd9f28Seschrock switch (idx) {
24865cd9f28Seschrock case HELP_CLONE:
249bb0ade09Sahrens return (gettext("\tclone [-p] [-o property=value] ... "
250bb0ade09Sahrens "<snapshot> <filesystem|volume>\n"));
25165cd9f28Seschrock case HELP_CREATE:
2521320ddf5SMike Gerdts return (gettext("\tcreate [-Pnpv] [-o property=value] ... "
253e9dbad6fSeschrock "<filesystem>\n"
2541320ddf5SMike Gerdts "\tcreate [-Pnpsv] [-b blocksize] [-o property=value] ... "
255e45ce728Sahrens "-V <size> <volume>\n"));
25665cd9f28Seschrock case HELP_DESTROY:
25719b94df9SMatthew Ahrens return (gettext("\tdestroy [-fnpRrv] <filesystem|volume>\n"
25819b94df9SMatthew Ahrens "\tdestroy [-dnpRrv] "
25978f17100SMatthew Ahrens "<filesystem|volume>@<snap>[%<snap>][,...]\n"
26078f17100SMatthew Ahrens "\tdestroy <filesystem|volume>#<bookmark>\n"));
26165cd9f28Seschrock case HELP_GET:
262ae1726b6SChris Gerhard return (gettext("\tget [-rHp] [-d max] "
26378f17100SMatthew Ahrens "[-o \"all\" | field[,...]]\n"
26478f17100SMatthew Ahrens "\t [-t type[,...]] [-s source[,...]]\n"
265e45ce728Sahrens "\t <\"all\" | property[,...]> "
266edb901aaSMarcel Telka "[filesystem|volume|snapshot|bookmark] ...\n"));
26765cd9f28Seschrock case HELP_INHERIT:
26892241e0bSTom Erickson return (gettext("\tinherit [-rS] <property> "
269bb0ade09Sahrens "<filesystem|volume|snapshot> ...\n"));
270e7437265Sahrens case HELP_UPGRADE:
271e7437265Sahrens return (gettext("\tupgrade [-v]\n"
272e7437265Sahrens "\tupgrade [-r] [-V version] <-a | filesystem ...>\n"));
27365cd9f28Seschrock case HELP_LIST:
27443d68d68SYuri Pankov return (gettext("\tlist [-Hp] [-r|-d max] [-o property[,...]] "
27543d68d68SYuri Pankov "[-s property]...\n\t [-S property]... [-t type[,...]] "
276e45ce728Sahrens "[filesystem|volume|snapshot] ...\n"));
27765cd9f28Seschrock case HELP_MOUNT:
27865cd9f28Seschrock return (gettext("\tmount\n"
279eb633035STom Caputi "\tmount [-lvO] [-o opts] <-a | filesystem>\n"));
28099653d4eSeschrock case HELP_PROMOTE:
281e45ce728Sahrens return (gettext("\tpromote <clone-filesystem>\n"));
282f2a3c691Sahrens case HELP_RECEIVE:
2836ccda740Sloli return (gettext("\treceive [-vnsFhu] "
2846ccda740Sloli "[-o <property>=<value>] ... [-x <property>] ...\n"
2856ccda740Sloli "\t <filesystem|volume|snapshot>\n"
2866ccda740Sloli "\treceive [-vnsFhu] [-o <property>=<value>] ... "
2876ccda740Sloli "[-x <property>] ... \n"
2886ccda740Sloli "\t [-d | -e] <filesystem>\n"
2899c3fd121SMatthew Ahrens "\treceive -A <filesystem|volume>\n"));
29065cd9f28Seschrock case HELP_RENAME:
2916a9cb0eaSEric Schrock return (gettext("\trename [-f] <filesystem|volume|snapshot> "
292cdf5b4caSmmusante "<filesystem|volume|snapshot>\n"
2936a9cb0eaSEric Schrock "\trename [-f] -p <filesystem|volume> <filesystem|volume>\n"
29478f17100SMatthew Ahrens "\trename -r <snapshot> <snapshot>\n"));
29565cd9f28Seschrock case HELP_ROLLBACK:
296f17c7ff8Sahrens return (gettext("\trollback [-rRf] <snapshot>\n"));
297f2a3c691Sahrens case HELP_SEND:
2986ccda740Sloli return (gettext("\tsend [-DnPpRvLecwhb] [-[iI] snapshot] "
29978f17100SMatthew Ahrens "<snapshot>\n"
3006ccda740Sloli "\tsend [-nvPLecw] [-i snapshot|bookmark] "
3019c3fd121SMatthew Ahrens "<filesystem|volume|snapshot>\n"
3029c3fd121SMatthew Ahrens "\tsend [-nvPe] -t <receive_resume_token>\n"));
30365cd9f28Seschrock case HELP_SET:
30430925561SChris Williamson return (gettext("\tset <property=value> ... "
305bb0ade09Sahrens "<filesystem|volume|snapshot> ...\n"));
30665cd9f28Seschrock case HELP_SHARE:
307eb633035STom Caputi return (gettext("\tshare [-l] <-a | filesystem>\n"));
30865cd9f28Seschrock case HELP_SNAPSHOT:
309bb0ade09Sahrens return (gettext("\tsnapshot [-r] [-o property=value] ... "
31078f17100SMatthew Ahrens "<filesystem|volume>@<snap> ...\n"));
31165cd9f28Seschrock case HELP_UNMOUNT:
312e45ce728Sahrens return (gettext("\tunmount [-f] "
313e45ce728Sahrens "<-a | filesystem|mountpoint>\n"));
31465cd9f28Seschrock case HELP_UNSHARE:
3152269545aSstephanie scheffler return (gettext("\tunshare "
316e45ce728Sahrens "<-a | filesystem|mountpoint>\n"));
317ecd6cf80Smarks case HELP_ALLOW:
31860b94cc3Sstephanie scheffler return (gettext("\tallow <filesystem|volume>\n"
31960b94cc3Sstephanie scheffler "\tallow [-ldug] "
320e45ce728Sahrens "<\"everyone\"|user|group>[,...] <perm|@setname>[,...]\n"
321e45ce728Sahrens "\t <filesystem|volume>\n"
322e45ce728Sahrens "\tallow [-ld] -e <perm|@setname>[,...] "
323e45ce728Sahrens "<filesystem|volume>\n"
324e45ce728Sahrens "\tallow -c <perm|@setname>[,...] <filesystem|volume>\n"
325e45ce728Sahrens "\tallow -s @setname <perm|@setname>[,...] "
326e45ce728Sahrens "<filesystem|volume>\n"));
327ecd6cf80Smarks case HELP_UNALLOW:
328e45ce728Sahrens return (gettext("\tunallow [-rldug] "
329e45ce728Sahrens "<\"everyone\"|user|group>[,...]\n"
330e45ce728Sahrens "\t [<perm|@setname>[,...]] <filesystem|volume>\n"
331e45ce728Sahrens "\tunallow [-rld] -e [<perm|@setname>[,...]] "
332e45ce728Sahrens "<filesystem|volume>\n"
333e45ce728Sahrens "\tunallow [-r] -c [<perm|@setname>[,...]] "
334e45ce728Sahrens "<filesystem|volume>\n"
335e45ce728Sahrens "\tunallow [-r] -s @setname [<perm|@setname>[,...]] "
336e45ce728Sahrens "<filesystem|volume>\n"));
33714843421SMatthew Ahrens case HELP_USERSPACE:
33889f5d17bSYuri Pankov return (gettext("\tuserspace [-Hinp] [-o field[,...]] "
33978f17100SMatthew Ahrens "[-s field] ...\n"
34078f17100SMatthew Ahrens "\t [-S field] ... [-t type[,...]] "
34143d68d68SYuri Pankov "<filesystem|snapshot>\n"));
34214843421SMatthew Ahrens case HELP_GROUPSPACE:
34389f5d17bSYuri Pankov return (gettext("\tgroupspace [-Hinp] [-o field[,...]] "
34478f17100SMatthew Ahrens "[-s field] ...\n"
34578f17100SMatthew Ahrens "\t [-S field] ... [-t type[,...]] "
34643d68d68SYuri Pankov "<filesystem|snapshot>\n"));
347f67950b2SNasf-Fan case HELP_PROJECTSPACE:
348f67950b2SNasf-Fan return (gettext("\tprojectspace [-Hp] [-o field[,...]] "
349f67950b2SNasf-Fan "[-s field] ... \n"
350f67950b2SNasf-Fan "\t [-S field] ... <filesystem|snapshot>\n"));
351f67950b2SNasf-Fan case HELP_PROJECT:
352f67950b2SNasf-Fan return (gettext("\tproject [-d|-r] <directory|file ...>\n"
353f67950b2SNasf-Fan "\tproject -c [-0] [-d|-r] [-p id] <directory|file ...>\n"
354f67950b2SNasf-Fan "\tproject -C [-k] [-r] <directory ...>\n"
355f67950b2SNasf-Fan "\tproject [-p id] [-r] [-s] <directory ...>\n"));
356842727c2SChris Kirby case HELP_HOLD:
357842727c2SChris Kirby return (gettext("\thold [-r] <tag> <snapshot> ...\n"));
358842727c2SChris Kirby case HELP_HOLDS:
359842727c2SChris Kirby return (gettext("\tholds [-r] <snapshot> ...\n"));
360842727c2SChris Kirby case HELP_RELEASE:
361842727c2SChris Kirby return (gettext("\trelease [-r] <tag> <snapshot> ...\n"));
36299d5e173STim Haley case HELP_DIFF:
36399d5e173STim Haley return (gettext("\tdiff [-FHt] <snapshot> "
36499d5e173STim Haley "[snapshot|filesystem]\n"));
3655cabbc6bSPrashanth Sreenivasa case HELP_REMAP:
3665cabbc6bSPrashanth Sreenivasa return (gettext("\tremap <filesystem | volume>\n"));
36778f17100SMatthew Ahrens case HELP_BOOKMARK:
36878f17100SMatthew Ahrens return (gettext("\tbookmark <snapshot> <bookmark>\n"));
369dfc11533SChris Williamson case HELP_CHANNEL_PROGRAM:
37052675910SAlek Pinchuk return (gettext("\tprogram [-jn] [-t <instruction limit>] "
371dfc11533SChris Williamson "[-m <memory limit (b)>] <pool> <program file> "
372dfc11533SChris Williamson "[lua args...]\n"));
373eb633035STom Caputi case HELP_LOAD_KEY:
374eb633035STom Caputi return (gettext("\tload-key [-rn] [-L <keylocation>] "
375eb633035STom Caputi "<-a | filesystem|volume>\n"));
376eb633035STom Caputi case HELP_UNLOAD_KEY:
377eb633035STom Caputi return (gettext("\tunload-key [-r] "
378eb633035STom Caputi "<-a | filesystem|volume>\n"));
379eb633035STom Caputi case HELP_CHANGE_KEY:
380eb633035STom Caputi return (gettext("\tchange-key [-l] [-o keyformat=<value>]\n"
381eb633035STom Caputi "\t [-o keylocation=<value>] [-o pbkfd2iters=<value>]\n"
382eb633035STom Caputi "\t <filesystem|volume>\n"
383eb633035STom Caputi "\tchange-key -i [-l] <filesystem|volume>\n"));
38465cd9f28Seschrock }
38565cd9f28Seschrock
38665cd9f28Seschrock abort();
38765cd9f28Seschrock /* NOTREACHED */
38865cd9f28Seschrock }
38965cd9f28Seschrock
390a8b6ddafSMark J Musante void
nomem(void)391a8b6ddafSMark J Musante nomem(void)
392a8b6ddafSMark J Musante {
393a8b6ddafSMark J Musante (void) fprintf(stderr, gettext("internal error: out of memory\n"));
394a8b6ddafSMark J Musante exit(1);
395a8b6ddafSMark J Musante }
396a8b6ddafSMark J Musante
397fa9e4066Sahrens /*
398fa9e4066Sahrens * Utility function to guarantee malloc() success.
399fa9e4066Sahrens */
400a8b6ddafSMark J Musante
401fa9e4066Sahrens void *
safe_malloc(size_t size)402fa9e4066Sahrens safe_malloc(size_t size)
403fa9e4066Sahrens {
404fa9e4066Sahrens void *data;
405fa9e4066Sahrens
406a8b6ddafSMark J Musante if ((data = calloc(1, size)) == NULL)
407a8b6ddafSMark J Musante nomem();
408fa9e4066Sahrens
409fa9e4066Sahrens return (data);
410fa9e4066Sahrens }
411fa9e4066Sahrens
412dfc11533SChris Williamson void *
safe_realloc(void * data,size_t size)413dfc11533SChris Williamson safe_realloc(void *data, size_t size)
414dfc11533SChris Williamson {
415dfc11533SChris Williamson void *newp;
416dfc11533SChris Williamson if ((newp = realloc(data, size)) == NULL) {
417dfc11533SChris Williamson free(data);
418dfc11533SChris Williamson nomem();
419dfc11533SChris Williamson }
420dfc11533SChris Williamson
421dfc11533SChris Williamson return (newp);
422dfc11533SChris Williamson }
423dfc11533SChris Williamson
424a8b6ddafSMark J Musante static char *
safe_strdup(char * str)425a8b6ddafSMark J Musante safe_strdup(char *str)
426a8b6ddafSMark J Musante {
427a8b6ddafSMark J Musante char *dupstr = strdup(str);
428a8b6ddafSMark J Musante
429a8b6ddafSMark J Musante if (dupstr == NULL)
430a8b6ddafSMark J Musante nomem();
431a8b6ddafSMark J Musante
432a8b6ddafSMark J Musante return (dupstr);
433a8b6ddafSMark J Musante }
434a8b6ddafSMark J Musante
43566e2aaccSgw /*
436990b4856Slling * Callback routine that will print out information for each of
43766e2aaccSgw * the properties.
43866e2aaccSgw */
439990b4856Slling static int
usage_prop_cb(int prop,void * cb)440990b4856Slling usage_prop_cb(int prop, void *cb)
44166e2aaccSgw {
44266e2aaccSgw FILE *fp = cb;
44366e2aaccSgw
444c5904d13Seschrock (void) fprintf(fp, "\t%-15s ", zfs_prop_to_name(prop));
44566e2aaccSgw
446c5904d13Seschrock if (zfs_prop_readonly(prop))
447c5904d13Seschrock (void) fprintf(fp, " NO ");
44866e2aaccSgw else
449c5904d13Seschrock (void) fprintf(fp, "YES ");
45066e2aaccSgw
45166e2aaccSgw if (zfs_prop_inheritable(prop))
45266e2aaccSgw (void) fprintf(fp, " YES ");
45366e2aaccSgw else
45466e2aaccSgw (void) fprintf(fp, " NO ");
45566e2aaccSgw
45666e2aaccSgw if (zfs_prop_values(prop) == NULL)
45766e2aaccSgw (void) fprintf(fp, "-\n");
45866e2aaccSgw else
45966e2aaccSgw (void) fprintf(fp, "%s\n", zfs_prop_values(prop));
46066e2aaccSgw
461990b4856Slling return (ZPROP_CONT);
46266e2aaccSgw }
46366e2aaccSgw
464fa9e4066Sahrens /*
465fa9e4066Sahrens * Display usage message. If we're inside a command, display only the usage for
466fa9e4066Sahrens * that command. Otherwise, iterate over the entire command table and display
467fa9e4066Sahrens * a complete usage message.
468fa9e4066Sahrens */
469fa9e4066Sahrens static void
usage(boolean_t requested)47099653d4eSeschrock usage(boolean_t requested)
471fa9e4066Sahrens {
472fa9e4066Sahrens int i;
47399653d4eSeschrock boolean_t show_properties = B_FALSE;
474fa9e4066Sahrens FILE *fp = requested ? stdout : stderr;
475fa9e4066Sahrens
476fa9e4066Sahrens if (current_command == NULL) {
477fa9e4066Sahrens
478fa9e4066Sahrens (void) fprintf(fp, gettext("usage: zfs command args ...\n"));
479fa9e4066Sahrens (void) fprintf(fp,
480fa9e4066Sahrens gettext("where 'command' is one of the following:\n\n"));
481fa9e4066Sahrens
482fa9e4066Sahrens for (i = 0; i < NCOMMAND; i++) {
483fa9e4066Sahrens if (command_table[i].name == NULL)
484fa9e4066Sahrens (void) fprintf(fp, "\n");
485fa9e4066Sahrens else
486fa9e4066Sahrens (void) fprintf(fp, "%s",
48765cd9f28Seschrock get_usage(command_table[i].usage));
488fa9e4066Sahrens }
489fa9e4066Sahrens
490fa9e4066Sahrens (void) fprintf(fp, gettext("\nEach dataset is of the form: "
491fa9e4066Sahrens "pool/[dataset/]*dataset[@name]\n"));
492fa9e4066Sahrens } else {
493fa9e4066Sahrens (void) fprintf(fp, gettext("usage:\n"));
49465cd9f28Seschrock (void) fprintf(fp, "%s", get_usage(current_command->usage));
495fa9e4066Sahrens }
496fa9e4066Sahrens
4975c21526aSdarrenm if (current_command != NULL &&
4985c21526aSdarrenm (strcmp(current_command->name, "set") == 0 ||
499fa9e4066Sahrens strcmp(current_command->name, "get") == 0 ||
500fa9e4066Sahrens strcmp(current_command->name, "inherit") == 0 ||
5015c21526aSdarrenm strcmp(current_command->name, "list") == 0))
50299653d4eSeschrock show_properties = B_TRUE;
503fa9e4066Sahrens
504fa9e4066Sahrens if (show_properties) {
505fa9e4066Sahrens (void) fprintf(fp,
506fa9e4066Sahrens gettext("\nThe following properties are supported:\n"));
507fa9e4066Sahrens
508a9799022Sck (void) fprintf(fp, "\n\t%-14s %s %s %s\n\n",
509fa9e4066Sahrens "PROPERTY", "EDIT", "INHERIT", "VALUES");
510fa9e4066Sahrens
51166e2aaccSgw /* Iterate over all properties */
512990b4856Slling (void) zprop_iter(usage_prop_cb, fp, B_FALSE, B_TRUE,
513990b4856Slling ZFS_TYPE_DATASET);
514fa9e4066Sahrens
51514843421SMatthew Ahrens (void) fprintf(fp, "\t%-15s ", "userused@...");
51614843421SMatthew Ahrens (void) fprintf(fp, " NO NO <size>\n");
51714843421SMatthew Ahrens (void) fprintf(fp, "\t%-15s ", "groupused@...");
51814843421SMatthew Ahrens (void) fprintf(fp, " NO NO <size>\n");
519f67950b2SNasf-Fan (void) fprintf(fp, "\t%-15s ", "projectused@...");
520f67950b2SNasf-Fan (void) fprintf(fp, " NO NO <size>\n");
521f67950b2SNasf-Fan (void) fprintf(fp, "\t%-15s ", "userobjused@...");
522f67950b2SNasf-Fan (void) fprintf(fp, " NO NO <size>\n");
523f67950b2SNasf-Fan (void) fprintf(fp, "\t%-15s ", "groupobjused@...");
524f67950b2SNasf-Fan (void) fprintf(fp, " NO NO <size>\n");
525f67950b2SNasf-Fan (void) fprintf(fp, "\t%-15s ", "projectobjused@...");
526f67950b2SNasf-Fan (void) fprintf(fp, " NO NO <size>\n");
52714843421SMatthew Ahrens (void) fprintf(fp, "\t%-15s ", "userquota@...");
52814843421SMatthew Ahrens (void) fprintf(fp, "YES NO <size> | none\n");
52914843421SMatthew Ahrens (void) fprintf(fp, "\t%-15s ", "groupquota@...");
53014843421SMatthew Ahrens (void) fprintf(fp, "YES NO <size> | none\n");
531f67950b2SNasf-Fan (void) fprintf(fp, "\t%-15s ", "projectquota@...");
532f67950b2SNasf-Fan (void) fprintf(fp, "YES NO <size> | none\n");
533f67950b2SNasf-Fan (void) fprintf(fp, "\t%-15s ", "userobjquota@...");
534f67950b2SNasf-Fan (void) fprintf(fp, "YES NO <size> | none\n");
535f67950b2SNasf-Fan (void) fprintf(fp, "\t%-15s ", "groupobjquota@...");
536f67950b2SNasf-Fan (void) fprintf(fp, "YES NO <size> | none\n");
537f67950b2SNasf-Fan (void) fprintf(fp, "\t%-15s ", "projectobjquota@...");
538f67950b2SNasf-Fan (void) fprintf(fp, "YES NO <size> | none\n");
53919b94df9SMatthew Ahrens (void) fprintf(fp, "\t%-15s ", "written@<snap>");
54019b94df9SMatthew Ahrens (void) fprintf(fp, " NO NO <size>\n");
54114843421SMatthew Ahrens
542fa9e4066Sahrens (void) fprintf(fp, gettext("\nSizes are specified in bytes "
543fa9e4066Sahrens "with standard units such as K, M, G, etc.\n"));
54474e7dc98SMatthew Ahrens (void) fprintf(fp, gettext("\nUser-defined properties can "
545e9dbad6fSeschrock "be specified by using a name containing a colon (:).\n"));
546f67950b2SNasf-Fan (void) fprintf(fp, gettext("\nThe {user|group|project}"
547f67950b2SNasf-Fan "[obj]{used|quota}@ properties must be appended with\n"
548f67950b2SNasf-Fan "a user|group|project specifier of one of these forms:\n"
54914843421SMatthew Ahrens " POSIX name (eg: \"matt\")\n"
55014843421SMatthew Ahrens " POSIX id (eg: \"126829\")\n"
55114843421SMatthew Ahrens " SMB name@domain (eg: \"matt@sun\")\n"
55214843421SMatthew Ahrens " SMB SID (eg: \"S-1-234-567-89\")\n"));
5535c21526aSdarrenm } else {
5545c21526aSdarrenm (void) fprintf(fp,
555deb8317bSMark J Musante gettext("\nFor the property list, run: %s\n"),
556deb8317bSMark J Musante "zfs set|get");
5576949a980Smarks (void) fprintf(fp,
558deb8317bSMark J Musante gettext("\nFor the delegated permission list, run: %s\n"),
559deb8317bSMark J Musante "zfs allow|unallow");
560fa9e4066Sahrens }
561fa9e4066Sahrens
562e9dbad6fSeschrock /*
563e9dbad6fSeschrock * See comments at end of main().
564e9dbad6fSeschrock */
565e9dbad6fSeschrock if (getenv("ZFS_ABORT") != NULL) {
566e9dbad6fSeschrock (void) printf("dumping core by request\n");
567e9dbad6fSeschrock abort();
568e9dbad6fSeschrock }
569e9dbad6fSeschrock
570fa9e4066Sahrens exit(requested ? 0 : 2);
571fa9e4066Sahrens }
572fa9e4066Sahrens
57330925561SChris Williamson /*
57430925561SChris Williamson * Take a property=value argument string and add it to the given nvlist.
57530925561SChris Williamson * Modifies the argument inplace.
57630925561SChris Williamson */
5776ccda740Sloli static boolean_t
parseprop(nvlist_t * props,char * propname)57830925561SChris Williamson parseprop(nvlist_t *props, char *propname)
579bb0ade09Sahrens {
5806ccda740Sloli char *propval;
581bb0ade09Sahrens
582bb0ade09Sahrens if ((propval = strchr(propname, '=')) == NULL) {
583bb0ade09Sahrens (void) fprintf(stderr, gettext("missing "
58430925561SChris Williamson "'=' for property=value argument\n"));
5856ccda740Sloli return (B_FALSE);
586bb0ade09Sahrens }
587bb0ade09Sahrens *propval = '\0';
588bb0ade09Sahrens propval++;
5896ccda740Sloli if (nvlist_exists(props, propname)) {
590bb0ade09Sahrens (void) fprintf(stderr, gettext("property '%s' "
591bb0ade09Sahrens "specified multiple times\n"), propname);
5926ccda740Sloli return (B_FALSE);
593bb0ade09Sahrens }
594a8b6ddafSMark J Musante if (nvlist_add_string(props, propname, propval) != 0)
595a8b6ddafSMark J Musante nomem();
5966ccda740Sloli return (B_TRUE);
5976ccda740Sloli }
5986ccda740Sloli
5996ccda740Sloli /*
6006ccda740Sloli * Take a property name argument and add it to the given nvlist.
6016ccda740Sloli * Modifies the argument inplace.
6026ccda740Sloli */
6036ccda740Sloli static boolean_t
parsepropname(nvlist_t * props,char * propname)6046ccda740Sloli parsepropname(nvlist_t *props, char *propname)
6056ccda740Sloli {
6066ccda740Sloli if (strchr(propname, '=') != NULL) {
6076ccda740Sloli (void) fprintf(stderr, gettext("invalid character "
6086ccda740Sloli "'=' in property argument\n"));
6096ccda740Sloli return (B_FALSE);
6106ccda740Sloli }
6116ccda740Sloli if (nvlist_exists(props, propname)) {
6126ccda740Sloli (void) fprintf(stderr, gettext("property '%s' "
6136ccda740Sloli "specified multiple times\n"), propname);
6146ccda740Sloli return (B_FALSE);
6156ccda740Sloli }
6166ccda740Sloli if (nvlist_add_boolean(props, propname) != 0)
6176ccda740Sloli nomem();
6186ccda740Sloli return (B_TRUE);
619bb0ade09Sahrens }
620bb0ade09Sahrens
621ae1726b6SChris Gerhard static int
parse_depth(char * opt,int * flags)622ae1726b6SChris Gerhard parse_depth(char *opt, int *flags)
623ae1726b6SChris Gerhard {
624ae1726b6SChris Gerhard char *tmp;
625ae1726b6SChris Gerhard int depth;
626ae1726b6SChris Gerhard
627ae1726b6SChris Gerhard depth = (int)strtol(opt, &tmp, 0);
628ae1726b6SChris Gerhard if (*tmp) {
629ae1726b6SChris Gerhard (void) fprintf(stderr,
630ae1726b6SChris Gerhard gettext("%s is not an integer\n"), optarg);
631ae1726b6SChris Gerhard usage(B_FALSE);
632ae1726b6SChris Gerhard }
633ae1726b6SChris Gerhard if (depth < 0) {
634ae1726b6SChris Gerhard (void) fprintf(stderr,
635ae1726b6SChris Gerhard gettext("Depth can not be negative.\n"));
636ae1726b6SChris Gerhard usage(B_FALSE);
637ae1726b6SChris Gerhard }
638ae1726b6SChris Gerhard *flags |= (ZFS_ITER_DEPTH_LIMIT|ZFS_ITER_RECURSE);
639ae1726b6SChris Gerhard return (depth);
640ae1726b6SChris Gerhard }
641ae1726b6SChris Gerhard
642a8b6ddafSMark J Musante #define PROGRESS_DELAY 2 /* seconds */
643a8b6ddafSMark J Musante
644a8b6ddafSMark J Musante 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";
645a8b6ddafSMark J Musante static time_t pt_begin;
646a8b6ddafSMark J Musante static char *pt_header = NULL;
647a8b6ddafSMark J Musante static boolean_t pt_shown;
648a8b6ddafSMark J Musante
649a8b6ddafSMark J Musante static void
start_progress_timer(void)650a8b6ddafSMark J Musante start_progress_timer(void)
651a8b6ddafSMark J Musante {
652a8b6ddafSMark J Musante pt_begin = time(NULL) + PROGRESS_DELAY;
653a8b6ddafSMark J Musante pt_shown = B_FALSE;
654a8b6ddafSMark J Musante }
655a8b6ddafSMark J Musante
656a8b6ddafSMark J Musante static void
set_progress_header(char * header)657a8b6ddafSMark J Musante set_progress_header(char *header)
658a8b6ddafSMark J Musante {
659a8b6ddafSMark J Musante assert(pt_header == NULL);
660a8b6ddafSMark J Musante pt_header = safe_strdup(header);
661a8b6ddafSMark J Musante if (pt_shown) {
662a8b6ddafSMark J Musante (void) printf("%s: ", header);
663a8b6ddafSMark J Musante (void) fflush(stdout);
664a8b6ddafSMark J Musante }
665a8b6ddafSMark J Musante }
666a8b6ddafSMark J Musante
667a8b6ddafSMark J Musante static void
update_progress(char * update)668a8b6ddafSMark J Musante update_progress(char *update)
669a8b6ddafSMark J Musante {
670a8b6ddafSMark J Musante if (!pt_shown && time(NULL) > pt_begin) {
671a8b6ddafSMark J Musante int len = strlen(update);
672a8b6ddafSMark J Musante
673a8b6ddafSMark J Musante (void) printf("%s: %s%*.*s", pt_header, update, len, len,
674a8b6ddafSMark J Musante pt_reverse);
675a8b6ddafSMark J Musante (void) fflush(stdout);
676a8b6ddafSMark J Musante pt_shown = B_TRUE;
677a8b6ddafSMark J Musante } else if (pt_shown) {
678a8b6ddafSMark J Musante int len = strlen(update);
679a8b6ddafSMark J Musante
680a8b6ddafSMark J Musante (void) printf("%s%*.*s", update, len, len, pt_reverse);
681a8b6ddafSMark J Musante (void) fflush(stdout);
682a8b6ddafSMark J Musante }
683a8b6ddafSMark J Musante }
684a8b6ddafSMark J Musante
685a8b6ddafSMark J Musante static void
finish_progress(char * done)686a8b6ddafSMark J Musante finish_progress(char *done)
687a8b6ddafSMark J Musante {
688a8b6ddafSMark J Musante if (pt_shown) {
689a8b6ddafSMark J Musante (void) printf("%s\n", done);
690a8b6ddafSMark J Musante (void) fflush(stdout);
691a8b6ddafSMark J Musante }
692a8b6ddafSMark J Musante free(pt_header);
693a8b6ddafSMark J Musante pt_header = NULL;
694a8b6ddafSMark J Musante }
6955d7b4d43SMatthew Ahrens
696f5a3d331SBrian Behlendorf static int
zfs_mount_and_share(libzfs_handle_t * hdl,const char * dataset,zfs_type_t type)697f5a3d331SBrian Behlendorf zfs_mount_and_share(libzfs_handle_t *hdl, const char *dataset, zfs_type_t type)
698780828c8SAndriy Gapon {
699f5a3d331SBrian Behlendorf zfs_handle_t *zhp = NULL;
700f5a3d331SBrian Behlendorf int ret = 0;
701f5a3d331SBrian Behlendorf
702f5a3d331SBrian Behlendorf zhp = zfs_open(hdl, dataset, type);
703f5a3d331SBrian Behlendorf if (zhp == NULL)
704f5a3d331SBrian Behlendorf return (1);
705f5a3d331SBrian Behlendorf
706f5a3d331SBrian Behlendorf /*
707f5a3d331SBrian Behlendorf * Volumes may neither be mounted or shared. Potentially in the
708f5a3d331SBrian Behlendorf * future filesystems detected on these volumes could be mounted.
709f5a3d331SBrian Behlendorf */
710f5a3d331SBrian Behlendorf if (zfs_get_type(zhp) == ZFS_TYPE_VOLUME) {
711f5a3d331SBrian Behlendorf zfs_close(zhp);
712f5a3d331SBrian Behlendorf return (0);
713f5a3d331SBrian Behlendorf }
714f5a3d331SBrian Behlendorf
715f5a3d331SBrian Behlendorf /*
716f5a3d331SBrian Behlendorf * Mount and/or share the new filesystem as appropriate. We provide a
717f5a3d331SBrian Behlendorf * verbose error message to let the user know that their filesystem was
718f5a3d331SBrian Behlendorf * in fact created, even if we failed to mount or share it.
719f5a3d331SBrian Behlendorf *
720f5a3d331SBrian Behlendorf * If the user doesn't want the dataset automatically mounted, then
721f5a3d331SBrian Behlendorf * skip the mount/share step
722f5a3d331SBrian Behlendorf */
723f5a3d331SBrian Behlendorf if (zfs_prop_valid_for_type(ZFS_PROP_CANMOUNT, type, B_FALSE) &&
724f5a3d331SBrian Behlendorf zfs_prop_get_int(zhp, ZFS_PROP_CANMOUNT) == ZFS_CANMOUNT_ON) {
725f5a3d331SBrian Behlendorf if (zfs_mount(zhp, NULL, 0) != 0) {
726f5a3d331SBrian Behlendorf (void) fprintf(stderr, gettext("filesystem "
727f5a3d331SBrian Behlendorf "successfully created, but not mounted\n"));
728f5a3d331SBrian Behlendorf ret = 1;
729f5a3d331SBrian Behlendorf } else if (zfs_share(zhp) != 0) {
730f5a3d331SBrian Behlendorf (void) fprintf(stderr, gettext("filesystem "
731f5a3d331SBrian Behlendorf "successfully created, but not shared\n"));
732f5a3d331SBrian Behlendorf ret = 1;
733f5a3d331SBrian Behlendorf }
734f5a3d331SBrian Behlendorf }
735f5a3d331SBrian Behlendorf
736f5a3d331SBrian Behlendorf zfs_close(zhp);
737f5a3d331SBrian Behlendorf
738f5a3d331SBrian Behlendorf return (ret);
739780828c8SAndriy Gapon }
740780828c8SAndriy Gapon
741fa9e4066Sahrens /*
742bb0ade09Sahrens * zfs clone [-p] [-o prop=value] ... <snap> <fs | vol>
743fa9e4066Sahrens *
744fa9e4066Sahrens * Given an existing dataset, create a writable copy whose initial contents
745fa9e4066Sahrens * are the same as the source. The newly created dataset maintains a
746fa9e4066Sahrens * dependency on the original; the original cannot be destroyed so long as
747fa9e4066Sahrens * the clone exists.
7487f1f55eaSvb *
7497f1f55eaSvb * The '-p' flag creates all the non-existing ancestors of the target first.
750fa9e4066Sahrens */
751fa9e4066Sahrens static int
zfs_do_clone(int argc,char ** argv)752fa9e4066Sahrens zfs_do_clone(int argc, char **argv)
753fa9e4066Sahrens {
754bb0ade09Sahrens zfs_handle_t *zhp = NULL;
7557f1f55eaSvb boolean_t parents = B_FALSE;
756bb0ade09Sahrens nvlist_t *props;
75705c998d6SRichard Lowe int ret = 0;
7587f1f55eaSvb int c;
759fa9e4066Sahrens
760a8b6ddafSMark J Musante if (nvlist_alloc(&props, NV_UNIQUE_NAME, 0) != 0)
761a8b6ddafSMark J Musante nomem();
762bb0ade09Sahrens
763fa9e4066Sahrens /* check options */
764bb0ade09Sahrens while ((c = getopt(argc, argv, "o:p")) != -1) {
7657f1f55eaSvb switch (c) {
766bb0ade09Sahrens case 'o':
7676ccda740Sloli if (!parseprop(props, optarg)) {
7686ccda740Sloli nvlist_free(props);
769bb0ade09Sahrens return (1);
7706ccda740Sloli }
771bb0ade09Sahrens break;
7727f1f55eaSvb case 'p':
7737f1f55eaSvb parents = B_TRUE;
7747f1f55eaSvb break;
7757f1f55eaSvb case '?':
7767f1f55eaSvb (void) fprintf(stderr, gettext("invalid option '%c'\n"),
7777f1f55eaSvb optopt);
778bb0ade09Sahrens goto usage;
7797f1f55eaSvb }
780fa9e4066Sahrens }
781fa9e4066Sahrens
7827f1f55eaSvb argc -= optind;
7837f1f55eaSvb argv += optind;
7847f1f55eaSvb
785fa9e4066Sahrens /* check number of arguments */
7867f1f55eaSvb if (argc < 1) {
787fa9e4066Sahrens (void) fprintf(stderr, gettext("missing source dataset "
788fa9e4066Sahrens "argument\n"));
789bb0ade09Sahrens goto usage;
790fa9e4066Sahrens }
7917f1f55eaSvb if (argc < 2) {
792fa9e4066Sahrens (void) fprintf(stderr, gettext("missing target dataset "
793fa9e4066Sahrens "argument\n"));
794bb0ade09Sahrens goto usage;
795fa9e4066Sahrens }
7967f1f55eaSvb if (argc > 2) {
797fa9e4066Sahrens (void) fprintf(stderr, gettext("too many arguments\n"));
798bb0ade09Sahrens goto usage;
799fa9e4066Sahrens }
800fa9e4066Sahrens
801fa9e4066Sahrens /* open the source dataset */
8027f1f55eaSvb if ((zhp = zfs_open(g_zfs, argv[0], ZFS_TYPE_SNAPSHOT)) == NULL)
803fa9e4066Sahrens return (1);
804fa9e4066Sahrens
8057f1f55eaSvb if (parents && zfs_name_valid(argv[1], ZFS_TYPE_FILESYSTEM |
8067f1f55eaSvb ZFS_TYPE_VOLUME)) {
8077f1f55eaSvb /*
8087f1f55eaSvb * Now create the ancestors of the target dataset. If the
8097f1f55eaSvb * target already exists and '-p' option was used we should not
8107f1f55eaSvb * complain.
8117f1f55eaSvb */
8127f1f55eaSvb if (zfs_dataset_exists(g_zfs, argv[1], ZFS_TYPE_FILESYSTEM |
8137f1f55eaSvb ZFS_TYPE_VOLUME))
8147f1f55eaSvb return (0);
8157f1f55eaSvb if (zfs_create_ancestors(g_zfs, argv[1]) != 0)
8167f1f55eaSvb return (1);
8177f1f55eaSvb }
8187f1f55eaSvb
819fa9e4066Sahrens /* pass to libzfs */
820bb0ade09Sahrens ret = zfs_clone(zhp, argv[1], props);
821fa9e4066Sahrens
822fa9e4066Sahrens /* create the mountpoint if necessary */
823fa9e4066Sahrens if (ret == 0) {
824f5a3d331SBrian Behlendorf if (log_history) {
825f5a3d331SBrian Behlendorf (void) zpool_log_history(g_zfs, history_str);
826f5a3d331SBrian Behlendorf log_history = B_FALSE;
827fa9e4066Sahrens }
828f5a3d331SBrian Behlendorf
829f5a3d331SBrian Behlendorf ret = zfs_mount_and_share(g_zfs, argv[1], ZFS_TYPE_DATASET);
830fa9e4066Sahrens }
831fa9e4066Sahrens
832fa9e4066Sahrens zfs_close(zhp);
833bb0ade09Sahrens nvlist_free(props);
834bb0ade09Sahrens
835bb0ade09Sahrens return (!!ret);
836fa9e4066Sahrens
837bb0ade09Sahrens usage:
838bb0ade09Sahrens if (zhp)
839bb0ade09Sahrens zfs_close(zhp);
840bb0ade09Sahrens nvlist_free(props);
841bb0ade09Sahrens usage(B_FALSE);
842bb0ade09Sahrens return (-1);
843fa9e4066Sahrens }
844fa9e4066Sahrens
845fa9e4066Sahrens /*
8461320ddf5SMike Gerdts * zfs create [-Pnpv] [-o prop=value] ... fs
8471320ddf5SMike Gerdts * zfs create [-Pnpsv] [-b blocksize] [-o prop=value] ... -V vol size
848fa9e4066Sahrens *
849fa9e4066Sahrens * Create a new dataset. This command can be used to create filesystems
850fa9e4066Sahrens * and volumes. Snapshot creation is handled by 'zfs snapshot'.
851fa9e4066Sahrens * For volumes, the user must specify a size to be used.
852fa9e4066Sahrens *
853fa9e4066Sahrens * The '-s' flag applies only to volumes, and indicates that we should not try
854fa9e4066Sahrens * to set the reservation for this volume. By default we set a reservation
855a9b821a0Sck * equal to the size for any volume. For pools with SPA_VERSION >=
856a9b821a0Sck * SPA_VERSION_REFRESERVATION, we set a refreservation instead.
8577f1f55eaSvb *
8587f1f55eaSvb * The '-p' flag creates all the non-existing ancestors of the target first.
8591320ddf5SMike Gerdts *
8601320ddf5SMike Gerdts * The '-n' flag is no-op (dry run) mode. This will perform a user-space sanity
8611320ddf5SMike Gerdts * check of arguments and properties, but does not check for permissions,
8621320ddf5SMike Gerdts * available space, etc.
8631320ddf5SMike Gerdts *
8641320ddf5SMike Gerdts * The '-v' flag is for verbose output.
8651320ddf5SMike Gerdts *
8661320ddf5SMike Gerdts * The '-P' flag is used for parseable output. It implies '-v'.
867fa9e4066Sahrens */
868fa9e4066Sahrens static int
zfs_do_create(int argc,char ** argv)869fa9e4066Sahrens zfs_do_create(int argc, char **argv)
870fa9e4066Sahrens {
871fa9e4066Sahrens zfs_type_t type = ZFS_TYPE_FILESYSTEM;
8721320ddf5SMike Gerdts zpool_handle_t *zpool_handle = NULL;
8731320ddf5SMike Gerdts nvlist_t *real_props = NULL;
874c16bcc45SIgor Kozhukhov uint64_t volsize = 0;
875fa9e4066Sahrens int c;
87699653d4eSeschrock boolean_t noreserve = B_FALSE;
8773cb34c60Sahrens boolean_t bflag = B_FALSE;
8787f1f55eaSvb boolean_t parents = B_FALSE;
8791320ddf5SMike Gerdts boolean_t dryrun = B_FALSE;
8801320ddf5SMike Gerdts boolean_t verbose = B_FALSE;
8811320ddf5SMike Gerdts boolean_t parseable = B_FALSE;
882e9dbad6fSeschrock int ret = 1;
883bb0ade09Sahrens nvlist_t *props;
884e9dbad6fSeschrock uint64_t intval;
885e9dbad6fSeschrock
886a8b6ddafSMark J Musante if (nvlist_alloc(&props, NV_UNIQUE_NAME, 0) != 0)
887a8b6ddafSMark J Musante nomem();
888fa9e4066Sahrens
889fa9e4066Sahrens /* check options */
8901320ddf5SMike Gerdts while ((c = getopt(argc, argv, ":PV:b:nso:pv")) != -1) {
891fa9e4066Sahrens switch (c) {
892fa9e4066Sahrens case 'V':
893fa9e4066Sahrens type = ZFS_TYPE_VOLUME;
894e9dbad6fSeschrock if (zfs_nicestrtonum(g_zfs, optarg, &intval) != 0) {
895e9dbad6fSeschrock (void) fprintf(stderr, gettext("bad volume "
896e9dbad6fSeschrock "size '%s': %s\n"), optarg,
897e9dbad6fSeschrock libzfs_error_description(g_zfs));
898e9dbad6fSeschrock goto error;
899e9dbad6fSeschrock }
900e9dbad6fSeschrock
901e9dbad6fSeschrock if (nvlist_add_uint64(props,
902a8b6ddafSMark J Musante zfs_prop_to_name(ZFS_PROP_VOLSIZE), intval) != 0)
903a8b6ddafSMark J Musante nomem();
904e9dbad6fSeschrock volsize = intval;
905fa9e4066Sahrens break;
9061320ddf5SMike Gerdts case 'P':
9071320ddf5SMike Gerdts verbose = B_TRUE;
9081320ddf5SMike Gerdts parseable = B_TRUE;
9091320ddf5SMike Gerdts break;
9107f1f55eaSvb case 'p':
9117f1f55eaSvb parents = B_TRUE;
9127f1f55eaSvb break;
913fa9e4066Sahrens case 'b':
9143cb34c60Sahrens bflag = B_TRUE;
915e9dbad6fSeschrock if (zfs_nicestrtonum(g_zfs, optarg, &intval) != 0) {
916e9dbad6fSeschrock (void) fprintf(stderr, gettext("bad volume "
917e9dbad6fSeschrock "block size '%s': %s\n"), optarg,
918e9dbad6fSeschrock libzfs_error_description(g_zfs));
919e9dbad6fSeschrock goto error;
920e9dbad6fSeschrock }
921e9dbad6fSeschrock
922e9dbad6fSeschrock if (nvlist_add_uint64(props,
923e9dbad6fSeschrock zfs_prop_to_name(ZFS_PROP_VOLBLOCKSIZE),
924a8b6ddafSMark J Musante intval) != 0)
925a8b6ddafSMark J Musante nomem();
926e9dbad6fSeschrock break;
9271320ddf5SMike Gerdts case 'n':
9281320ddf5SMike Gerdts dryrun = B_TRUE;
9291320ddf5SMike Gerdts break;
930e9dbad6fSeschrock case 'o':
9316ccda740Sloli if (!parseprop(props, optarg))
932e9dbad6fSeschrock goto error;
933fa9e4066Sahrens break;
934fa9e4066Sahrens case 's':
93599653d4eSeschrock noreserve = B_TRUE;
936fa9e4066Sahrens break;
9371320ddf5SMike Gerdts case 'v':
9381320ddf5SMike Gerdts verbose = B_TRUE;
9391320ddf5SMike Gerdts break;
940fa9e4066Sahrens case ':':
941fa9e4066Sahrens (void) fprintf(stderr, gettext("missing size "
942fa9e4066Sahrens "argument\n"));
943e9dbad6fSeschrock goto badusage;
944fa9e4066Sahrens case '?':
945fa9e4066Sahrens (void) fprintf(stderr, gettext("invalid option '%c'\n"),
946fa9e4066Sahrens optopt);
947e9dbad6fSeschrock goto badusage;
948fa9e4066Sahrens }
949fa9e4066Sahrens }
950fa9e4066Sahrens
9513cb34c60Sahrens if ((bflag || noreserve) && type != ZFS_TYPE_VOLUME) {
9523cb34c60Sahrens (void) fprintf(stderr, gettext("'-s' and '-b' can only be "
9533cb34c60Sahrens "used when creating a volume\n"));
954e9dbad6fSeschrock goto badusage;
955fa9e4066Sahrens }
956fa9e4066Sahrens
957fa9e4066Sahrens argc -= optind;
958fa9e4066Sahrens argv += optind;
959fa9e4066Sahrens
960fa9e4066Sahrens /* check number of arguments */
961fa9e4066Sahrens if (argc == 0) {
962fa9e4066Sahrens (void) fprintf(stderr, gettext("missing %s argument\n"),
963fa9e4066Sahrens zfs_type_to_name(type));
964e9dbad6fSeschrock goto badusage;
965fa9e4066Sahrens }
966fa9e4066Sahrens if (argc > 1) {
967fa9e4066Sahrens (void) fprintf(stderr, gettext("too many arguments\n"));
968e9dbad6fSeschrock goto badusage;
969e9dbad6fSeschrock }
970e9dbad6fSeschrock
9711320ddf5SMike Gerdts if (dryrun || (type == ZFS_TYPE_VOLUME && !noreserve)) {
9721320ddf5SMike Gerdts char msg[ZFS_MAX_DATASET_NAME_LEN * 2];
973a9b821a0Sck char *p;
974a9b821a0Sck
975c16bcc45SIgor Kozhukhov if ((p = strchr(argv[0], '/')) != NULL)
976a9b821a0Sck *p = '\0';
977a9b821a0Sck zpool_handle = zpool_open(g_zfs, argv[0]);
978a9b821a0Sck if (p != NULL)
979a9b821a0Sck *p = '/';
980a9b821a0Sck if (zpool_handle == NULL)
981a9b821a0Sck goto error;
982c61ea566SGeorge Wilson
983c61ea566SGeorge Wilson (void) snprintf(msg, sizeof (msg),
9841320ddf5SMike Gerdts dryrun ? gettext("cannot verify '%s'") :
985c61ea566SGeorge Wilson gettext("cannot create '%s'"), argv[0]);
986c61ea566SGeorge Wilson if (props && (real_props = zfs_valid_proplist(g_zfs, type,
987eb633035STom Caputi props, 0, NULL, zpool_handle, B_TRUE, msg)) == NULL) {
988e9316f76SJoe Stein zpool_close(zpool_handle);
989c61ea566SGeorge Wilson goto error;
990e9316f76SJoe Stein }
9911320ddf5SMike Gerdts }
9921320ddf5SMike Gerdts
9931320ddf5SMike Gerdts if (type == ZFS_TYPE_VOLUME && !noreserve) {
9941320ddf5SMike Gerdts uint64_t spa_version;
9951320ddf5SMike Gerdts zfs_prop_t resv_prop;
9961320ddf5SMike Gerdts char *strval;
9971320ddf5SMike Gerdts
9981320ddf5SMike Gerdts spa_version = zpool_get_prop_int(zpool_handle,
9991320ddf5SMike Gerdts ZPOOL_PROP_VERSION, NULL);
10001320ddf5SMike Gerdts if (spa_version >= SPA_VERSION_REFRESERVATION)
10011320ddf5SMike Gerdts resv_prop = ZFS_PROP_REFRESERVATION;
10021320ddf5SMike Gerdts else
10031320ddf5SMike Gerdts resv_prop = ZFS_PROP_RESERVATION;
1004c61ea566SGeorge Wilson
1005b73ccab0SMike Gerdts volsize = zvol_volsize_to_reservation(zpool_handle, volsize,
1006b73ccab0SMike Gerdts real_props);
1007a9b821a0Sck
1008a9b821a0Sck if (nvlist_lookup_string(props, zfs_prop_to_name(resv_prop),
1009a9b821a0Sck &strval) != 0) {
1010a9b821a0Sck if (nvlist_add_uint64(props,
1011a9b821a0Sck zfs_prop_to_name(resv_prop), volsize) != 0) {
1012a9b821a0Sck nvlist_free(props);
1013a8b6ddafSMark J Musante nomem();
1014a9b821a0Sck }
1015e9dbad6fSeschrock }
1016fa9e4066Sahrens }
10171320ddf5SMike Gerdts if (zpool_handle != NULL) {
10181320ddf5SMike Gerdts zpool_close(zpool_handle);
10191320ddf5SMike Gerdts nvlist_free(real_props);
10201320ddf5SMike Gerdts }
1021fa9e4066Sahrens
10227f1f55eaSvb if (parents && zfs_name_valid(argv[0], type)) {
10237f1f55eaSvb /*
10247f1f55eaSvb * Now create the ancestors of target dataset. If the target
10257f1f55eaSvb * already exists and '-p' option was used we should not
10267f1f55eaSvb * complain.
10277f1f55eaSvb */
10287f1f55eaSvb if (zfs_dataset_exists(g_zfs, argv[0], type)) {
10297f1f55eaSvb ret = 0;
10307f1f55eaSvb goto error;
10317f1f55eaSvb }
10321320ddf5SMike Gerdts if (verbose) {
10331320ddf5SMike Gerdts (void) printf(parseable ? "create_ancestors\t%s\n" :
10341320ddf5SMike Gerdts dryrun ? "would create ancestors of %s\n" :
10351320ddf5SMike Gerdts "create ancestors of %s\n", argv[0]);
10361320ddf5SMike Gerdts }
10371320ddf5SMike Gerdts if (!dryrun) {
10381320ddf5SMike Gerdts if (zfs_create_ancestors(g_zfs, argv[0]) != 0) {
10391320ddf5SMike Gerdts goto error;
10401320ddf5SMike Gerdts }
10411320ddf5SMike Gerdts }
10421320ddf5SMike Gerdts }
10431320ddf5SMike Gerdts
10441320ddf5SMike Gerdts if (verbose) {
10451320ddf5SMike Gerdts nvpair_t *nvp = NULL;
10461320ddf5SMike Gerdts (void) printf(parseable ? "create\t%s\n" :
10471320ddf5SMike Gerdts dryrun ? "would create %s\n" : "create %s\n", argv[0]);
10481320ddf5SMike Gerdts while ((nvp = nvlist_next_nvpair(props, nvp)) != NULL) {
10491320ddf5SMike Gerdts uint64_t uval;
10501320ddf5SMike Gerdts char *sval;
10511320ddf5SMike Gerdts
10521320ddf5SMike Gerdts switch (nvpair_type(nvp)) {
10531320ddf5SMike Gerdts case DATA_TYPE_UINT64:
10541320ddf5SMike Gerdts VERIFY0(nvpair_value_uint64(nvp, &uval));
10551320ddf5SMike Gerdts (void) printf(parseable ?
10561320ddf5SMike Gerdts "property\t%s\t%llu\n" : "\t%s=%llu\n",
10571320ddf5SMike Gerdts nvpair_name(nvp), (u_longlong_t)uval);
10581320ddf5SMike Gerdts break;
10591320ddf5SMike Gerdts case DATA_TYPE_STRING:
10601320ddf5SMike Gerdts VERIFY0(nvpair_value_string(nvp, &sval));
10611320ddf5SMike Gerdts (void) printf(parseable ?
10621320ddf5SMike Gerdts "property\t%s\t%s\n" : "\t%s=%s\n",
10631320ddf5SMike Gerdts nvpair_name(nvp), sval);
10641320ddf5SMike Gerdts break;
10651320ddf5SMike Gerdts default:
10661320ddf5SMike Gerdts (void) fprintf(stderr, "property '%s' "
10671320ddf5SMike Gerdts "has illegal type %d\n",
10681320ddf5SMike Gerdts nvpair_name(nvp), nvpair_type(nvp));
10691320ddf5SMike Gerdts abort();
10701320ddf5SMike Gerdts }
10711320ddf5SMike Gerdts }
10721320ddf5SMike Gerdts }
10731320ddf5SMike Gerdts if (dryrun) {
10741320ddf5SMike Gerdts ret = 0;
10751320ddf5SMike Gerdts goto error;
10767f1f55eaSvb }
10777f1f55eaSvb
1078fa9e4066Sahrens /* pass to libzfs */
1079e9dbad6fSeschrock if (zfs_create(g_zfs, argv[0], type, props) != 0)
1080e9dbad6fSeschrock goto error;
1081fa9e4066Sahrens
1082f5a3d331SBrian Behlendorf if (log_history) {
1083f5a3d331SBrian Behlendorf (void) zpool_log_history(g_zfs, history_str);
1084f5a3d331SBrian Behlendorf log_history = B_FALSE;
1085fa9e4066Sahrens }
1086fa9e4066Sahrens
1087f5a3d331SBrian Behlendorf ret = zfs_mount_and_share(g_zfs, argv[0], ZFS_TYPE_DATASET);
1088e9dbad6fSeschrock error:
1089e9dbad6fSeschrock nvlist_free(props);
1090fa9e4066Sahrens return (ret);
1091e9dbad6fSeschrock badusage:
1092e9dbad6fSeschrock nvlist_free(props);
1093e9dbad6fSeschrock usage(B_FALSE);
1094e9dbad6fSeschrock return (2);
1095fa9e4066Sahrens }
1096fa9e4066Sahrens
1097fa9e4066Sahrens /*
1098922d9a97SChris Kirby * zfs destroy [-rRf] <fs, vol>
1099922d9a97SChris Kirby * zfs destroy [-rRd] <snap>
1100fa9e4066Sahrens *
110192241e0bSTom Erickson * -r Recursively destroy all children
110292241e0bSTom Erickson * -R Recursively destroy all dependents, including clones
110392241e0bSTom Erickson * -f Force unmounting of any dependents
1104842727c2SChris Kirby * -d If we can't destroy now, mark for deferred destruction
1105fa9e4066Sahrens *
1106fa9e4066Sahrens * Destroys the given dataset. By default, it will unmount any filesystems,
1107fa9e4066Sahrens * and refuse to destroy a dataset that has any dependents. A dependent can
1108fa9e4066Sahrens * either be a child, or a clone of a child.
1109fa9e4066Sahrens */
1110fa9e4066Sahrens typedef struct destroy_cbdata {
111199653d4eSeschrock boolean_t cb_first;
111219b94df9SMatthew Ahrens boolean_t cb_force;
111319b94df9SMatthew Ahrens boolean_t cb_recurse;
111419b94df9SMatthew Ahrens boolean_t cb_error;
111519b94df9SMatthew Ahrens boolean_t cb_doclones;
1116fa9e4066Sahrens zfs_handle_t *cb_target;
1117842727c2SChris Kirby boolean_t cb_defer_destroy;
111819b94df9SMatthew Ahrens boolean_t cb_verbose;
111919b94df9SMatthew Ahrens boolean_t cb_parsable;
112019b94df9SMatthew Ahrens boolean_t cb_dryrun;
112119b94df9SMatthew Ahrens nvlist_t *cb_nvl;
11223b2aab18SMatthew Ahrens nvlist_t *cb_batchedsnaps;
112319b94df9SMatthew Ahrens
112419b94df9SMatthew Ahrens /* first snap in contiguous run */
11254445fffbSMatthew Ahrens char *cb_firstsnap;
112619b94df9SMatthew Ahrens /* previous snap in contiguous run */
11274445fffbSMatthew Ahrens char *cb_prevsnap;
112819b94df9SMatthew Ahrens int64_t cb_snapused;
112919b94df9SMatthew Ahrens char *cb_snapspec;
113078f17100SMatthew Ahrens char *cb_bookmark;
1131fa9e4066Sahrens } destroy_cbdata_t;
1132fa9e4066Sahrens
1133fa9e4066Sahrens /*
1134fa9e4066Sahrens * Check for any dependents based on the '-r' or '-R' flags.
1135fa9e4066Sahrens */
1136fa9e4066Sahrens static int
destroy_check_dependent(zfs_handle_t * zhp,void * data)1137fa9e4066Sahrens destroy_check_dependent(zfs_handle_t *zhp, void *data)
1138fa9e4066Sahrens {
1139fa9e4066Sahrens destroy_cbdata_t *cbp = data;
1140fa9e4066Sahrens const char *tname = zfs_get_name(cbp->cb_target);
1141fa9e4066Sahrens const char *name = zfs_get_name(zhp);
1142fa9e4066Sahrens
1143fa9e4066Sahrens if (strncmp(tname, name, strlen(tname)) == 0 &&
1144fa9e4066Sahrens (name[strlen(tname)] == '/' || name[strlen(tname)] == '@')) {
1145fa9e4066Sahrens /*
1146fa9e4066Sahrens * This is a direct descendant, not a clone somewhere else in
1147fa9e4066Sahrens * the hierarchy.
1148fa9e4066Sahrens */
1149fa9e4066Sahrens if (cbp->cb_recurse)
1150fa9e4066Sahrens goto out;
1151fa9e4066Sahrens
1152fa9e4066Sahrens if (cbp->cb_first) {
1153fa9e4066Sahrens (void) fprintf(stderr, gettext("cannot destroy '%s': "
1154fa9e4066Sahrens "%s has children\n"),
1155fa9e4066Sahrens zfs_get_name(cbp->cb_target),
1156fa9e4066Sahrens zfs_type_to_name(zfs_get_type(cbp->cb_target)));
1157fa9e4066Sahrens (void) fprintf(stderr, gettext("use '-r' to destroy "
1158fa9e4066Sahrens "the following datasets:\n"));
115999653d4eSeschrock cbp->cb_first = B_FALSE;
116019b94df9SMatthew Ahrens cbp->cb_error = B_TRUE;
1161fa9e4066Sahrens }
1162fa9e4066Sahrens
1163fa9e4066Sahrens (void) fprintf(stderr, "%s\n", zfs_get_name(zhp));
1164fa9e4066Sahrens } else {
1165fa9e4066Sahrens /*
1166fa9e4066Sahrens * This is a clone. We only want to report this if the '-r'
1167fa9e4066Sahrens * wasn't specified, or the target is a snapshot.
1168fa9e4066Sahrens */
1169fa9e4066Sahrens if (!cbp->cb_recurse &&
1170fa9e4066Sahrens zfs_get_type(cbp->cb_target) != ZFS_TYPE_SNAPSHOT)
1171fa9e4066Sahrens goto out;
1172fa9e4066Sahrens
1173fa9e4066Sahrens if (cbp->cb_first) {
1174fa9e4066Sahrens (void) fprintf(stderr, gettext("cannot destroy '%s': "
1175fa9e4066Sahrens "%s has dependent clones\n"),
1176fa9e4066Sahrens zfs_get_name(cbp->cb_target),
1177fa9e4066Sahrens zfs_type_to_name(zfs_get_type(cbp->cb_target)));
1178fa9e4066Sahrens (void) fprintf(stderr, gettext("use '-R' to destroy "
1179fa9e4066Sahrens "the following datasets:\n"));
118099653d4eSeschrock cbp->cb_first = B_FALSE;
118119b94df9SMatthew Ahrens cbp->cb_error = B_TRUE;
118219b94df9SMatthew Ahrens cbp->cb_dryrun = B_TRUE;
1183fa9e4066Sahrens }
1184fa9e4066Sahrens
1185fa9e4066Sahrens (void) fprintf(stderr, "%s\n", zfs_get_name(zhp));
1186fa9e4066Sahrens }
1187fa9e4066Sahrens
1188fa9e4066Sahrens out:
1189fa9e4066Sahrens zfs_close(zhp);
1190fa9e4066Sahrens return (0);
1191fa9e4066Sahrens }
1192fa9e4066Sahrens
1193fa9e4066Sahrens static int
destroy_callback(zfs_handle_t * zhp,void * data)1194fa9e4066Sahrens destroy_callback(zfs_handle_t *zhp, void *data)
1195fa9e4066Sahrens {
119619b94df9SMatthew Ahrens destroy_cbdata_t *cb = data;
119719b94df9SMatthew Ahrens const char *name = zfs_get_name(zhp);
119819b94df9SMatthew Ahrens
119919b94df9SMatthew Ahrens if (cb->cb_verbose) {
120019b94df9SMatthew Ahrens if (cb->cb_parsable) {
120119b94df9SMatthew Ahrens (void) printf("destroy\t%s\n", name);
120219b94df9SMatthew Ahrens } else if (cb->cb_dryrun) {
120319b94df9SMatthew Ahrens (void) printf(gettext("would destroy %s\n"),
120419b94df9SMatthew Ahrens name);
120519b94df9SMatthew Ahrens } else {
120619b94df9SMatthew Ahrens (void) printf(gettext("will destroy %s\n"),
120719b94df9SMatthew Ahrens name);
120819b94df9SMatthew Ahrens }
120919b94df9SMatthew Ahrens }
1210fa9e4066Sahrens
1211fa9e4066Sahrens /*
1212fa9e4066Sahrens * Ignore pools (which we've already flagged as an error before getting
1213681d9761SEric Taylor * here).
1214fa9e4066Sahrens */
1215fa9e4066Sahrens if (strchr(zfs_get_name(zhp), '/') == NULL &&
1216fa9e4066Sahrens zfs_get_type(zhp) == ZFS_TYPE_FILESYSTEM) {
1217fa9e4066Sahrens zfs_close(zhp);
1218fa9e4066Sahrens return (0);
1219fa9e4066Sahrens }
12203b2aab18SMatthew Ahrens if (cb->cb_dryrun) {
12213b2aab18SMatthew Ahrens zfs_close(zhp);
12223b2aab18SMatthew Ahrens return (0);
12233b2aab18SMatthew Ahrens }
12243b2aab18SMatthew Ahrens
12253b2aab18SMatthew Ahrens /*
12263b2aab18SMatthew Ahrens * We batch up all contiguous snapshots (even of different
12273b2aab18SMatthew Ahrens * filesystems) and destroy them with one ioctl. We can't
12283b2aab18SMatthew Ahrens * simply do all snap deletions and then all fs deletions,
12293b2aab18SMatthew Ahrens * because we must delete a clone before its origin.
12303b2aab18SMatthew Ahrens */
12313b2aab18SMatthew Ahrens if (zfs_get_type(zhp) == ZFS_TYPE_SNAPSHOT) {
12323b2aab18SMatthew Ahrens fnvlist_add_boolean(cb->cb_batchedsnaps, name);
12333b2aab18SMatthew Ahrens } else {
12343b2aab18SMatthew Ahrens int error = zfs_destroy_snaps_nvl(g_zfs,
12353b2aab18SMatthew Ahrens cb->cb_batchedsnaps, B_FALSE);
12363b2aab18SMatthew Ahrens fnvlist_free(cb->cb_batchedsnaps);
12373b2aab18SMatthew Ahrens cb->cb_batchedsnaps = fnvlist_alloc();
1238fa9e4066Sahrens
12393b2aab18SMatthew Ahrens if (error != 0 ||
12403b2aab18SMatthew Ahrens zfs_unmount(zhp, NULL, cb->cb_force ? MS_FORCE : 0) != 0 ||
124119b94df9SMatthew Ahrens zfs_destroy(zhp, cb->cb_defer_destroy) != 0) {
124219b94df9SMatthew Ahrens zfs_close(zhp);
124319b94df9SMatthew Ahrens return (-1);
124419b94df9SMatthew Ahrens }
1245fa9e4066Sahrens }
1246fa9e4066Sahrens
1247fa9e4066Sahrens zfs_close(zhp);
1248fa9e4066Sahrens return (0);
1249fa9e4066Sahrens }
1250fa9e4066Sahrens
12511d452cf5Sahrens static int
destroy_print_cb(zfs_handle_t * zhp,void * arg)125219b94df9SMatthew Ahrens destroy_print_cb(zfs_handle_t *zhp, void *arg)
1253e5351341SMatthew Ahrens {
125419b94df9SMatthew Ahrens destroy_cbdata_t *cb = arg;
125519b94df9SMatthew Ahrens const char *name = zfs_get_name(zhp);
125619b94df9SMatthew Ahrens int err = 0;
125719b94df9SMatthew Ahrens
125819b94df9SMatthew Ahrens if (nvlist_exists(cb->cb_nvl, name)) {
125919b94df9SMatthew Ahrens if (cb->cb_firstsnap == NULL)
12604445fffbSMatthew Ahrens cb->cb_firstsnap = strdup(name);
126119b94df9SMatthew Ahrens if (cb->cb_prevsnap != NULL)
12624445fffbSMatthew Ahrens free(cb->cb_prevsnap);
126319b94df9SMatthew Ahrens /* this snap continues the current range */
12644445fffbSMatthew Ahrens cb->cb_prevsnap = strdup(name);
12654445fffbSMatthew Ahrens if (cb->cb_firstsnap == NULL || cb->cb_prevsnap == NULL)
12664445fffbSMatthew Ahrens nomem();
126719b94df9SMatthew Ahrens if (cb->cb_verbose) {
126819b94df9SMatthew Ahrens if (cb->cb_parsable) {
126919b94df9SMatthew Ahrens (void) printf("destroy\t%s\n", name);
127019b94df9SMatthew Ahrens } else if (cb->cb_dryrun) {
127119b94df9SMatthew Ahrens (void) printf(gettext("would destroy %s\n"),
127219b94df9SMatthew Ahrens name);
127319b94df9SMatthew Ahrens } else {
127419b94df9SMatthew Ahrens (void) printf(gettext("will destroy %s\n"),
127519b94df9SMatthew Ahrens name);
127619b94df9SMatthew Ahrens }
1277e5351341SMatthew Ahrens }
127819b94df9SMatthew Ahrens } else if (cb->cb_firstsnap != NULL) {
127919b94df9SMatthew Ahrens /* end of this range */
128019b94df9SMatthew Ahrens uint64_t used = 0;
12814445fffbSMatthew Ahrens err = lzc_snaprange_space(cb->cb_firstsnap,
128219b94df9SMatthew Ahrens cb->cb_prevsnap, &used);
128319b94df9SMatthew Ahrens cb->cb_snapused += used;
12844445fffbSMatthew Ahrens free(cb->cb_firstsnap);
128519b94df9SMatthew Ahrens cb->cb_firstsnap = NULL;
12864445fffbSMatthew Ahrens free(cb->cb_prevsnap);
128719b94df9SMatthew Ahrens cb->cb_prevsnap = NULL;
1288e5351341SMatthew Ahrens }
128919b94df9SMatthew Ahrens zfs_close(zhp);
129019b94df9SMatthew Ahrens return (err);
129119b94df9SMatthew Ahrens }
1292e5351341SMatthew Ahrens
129319b94df9SMatthew Ahrens static int
destroy_print_snapshots(zfs_handle_t * fs_zhp,destroy_cbdata_t * cb)129419b94df9SMatthew Ahrens destroy_print_snapshots(zfs_handle_t *fs_zhp, destroy_cbdata_t *cb)
129519b94df9SMatthew Ahrens {
129605c998d6SRichard Lowe int err = 0;
129719b94df9SMatthew Ahrens assert(cb->cb_firstsnap == NULL);
129819b94df9SMatthew Ahrens assert(cb->cb_prevsnap == NULL);
129919b94df9SMatthew Ahrens err = zfs_iter_snapshots_sorted(fs_zhp, destroy_print_cb, cb);
130019b94df9SMatthew Ahrens if (cb->cb_firstsnap != NULL) {
130119b94df9SMatthew Ahrens uint64_t used = 0;
130219b94df9SMatthew Ahrens if (err == 0) {
13034445fffbSMatthew Ahrens err = lzc_snaprange_space(cb->cb_firstsnap,
130419b94df9SMatthew Ahrens cb->cb_prevsnap, &used);
130519b94df9SMatthew Ahrens }
130619b94df9SMatthew Ahrens cb->cb_snapused += used;
13074445fffbSMatthew Ahrens free(cb->cb_firstsnap);
130819b94df9SMatthew Ahrens cb->cb_firstsnap = NULL;
13094445fffbSMatthew Ahrens free(cb->cb_prevsnap);
131019b94df9SMatthew Ahrens cb->cb_prevsnap = NULL;
131119b94df9SMatthew Ahrens }
131219b94df9SMatthew Ahrens return (err);
131319b94df9SMatthew Ahrens }
131419b94df9SMatthew Ahrens
131519b94df9SMatthew Ahrens static int
snapshot_to_nvl_cb(zfs_handle_t * zhp,void * arg)131619b94df9SMatthew Ahrens snapshot_to_nvl_cb(zfs_handle_t *zhp, void *arg)
131719b94df9SMatthew Ahrens {
131819b94df9SMatthew Ahrens destroy_cbdata_t *cb = arg;
131919b94df9SMatthew Ahrens int err = 0;
132019b94df9SMatthew Ahrens
132119b94df9SMatthew Ahrens /* Check for clones. */
132265fec9f6SChristopher Siden if (!cb->cb_doclones && !cb->cb_defer_destroy) {
132319b94df9SMatthew Ahrens cb->cb_target = zhp;
132419b94df9SMatthew Ahrens cb->cb_first = B_TRUE;
132519b94df9SMatthew Ahrens err = zfs_iter_dependents(zhp, B_TRUE,
132619b94df9SMatthew Ahrens destroy_check_dependent, cb);
132719b94df9SMatthew Ahrens }
132819b94df9SMatthew Ahrens
132919b94df9SMatthew Ahrens if (err == 0) {
133019b94df9SMatthew Ahrens if (nvlist_add_boolean(cb->cb_nvl, zfs_get_name(zhp)))
133119b94df9SMatthew Ahrens nomem();
133219b94df9SMatthew Ahrens }
133319b94df9SMatthew Ahrens zfs_close(zhp);
133419b94df9SMatthew Ahrens return (err);
133519b94df9SMatthew Ahrens }
133619b94df9SMatthew Ahrens
133719b94df9SMatthew Ahrens static int
gather_snapshots(zfs_handle_t * zhp,void * arg)133819b94df9SMatthew Ahrens gather_snapshots(zfs_handle_t *zhp, void *arg)
133919b94df9SMatthew Ahrens {
134019b94df9SMatthew Ahrens destroy_cbdata_t *cb = arg;
134119b94df9SMatthew Ahrens int err = 0;
134219b94df9SMatthew Ahrens
134319b94df9SMatthew Ahrens err = zfs_iter_snapspec(zhp, cb->cb_snapspec, snapshot_to_nvl_cb, cb);
134419b94df9SMatthew Ahrens if (err == ENOENT)
134519b94df9SMatthew Ahrens err = 0;
134619b94df9SMatthew Ahrens if (err != 0)
134719b94df9SMatthew Ahrens goto out;
134819b94df9SMatthew Ahrens
134919b94df9SMatthew Ahrens if (cb->cb_verbose) {
135019b94df9SMatthew Ahrens err = destroy_print_snapshots(zhp, cb);
135119b94df9SMatthew Ahrens if (err != 0)
135219b94df9SMatthew Ahrens goto out;
135319b94df9SMatthew Ahrens }
135419b94df9SMatthew Ahrens
135519b94df9SMatthew Ahrens if (cb->cb_recurse)
135619b94df9SMatthew Ahrens err = zfs_iter_filesystems(zhp, gather_snapshots, cb);
135719b94df9SMatthew Ahrens
135819b94df9SMatthew Ahrens out:
135919b94df9SMatthew Ahrens zfs_close(zhp);
136019b94df9SMatthew Ahrens return (err);
136119b94df9SMatthew Ahrens }
136219b94df9SMatthew Ahrens
136319b94df9SMatthew Ahrens static int
destroy_clones(destroy_cbdata_t * cb)136419b94df9SMatthew Ahrens destroy_clones(destroy_cbdata_t *cb)
136519b94df9SMatthew Ahrens {
136619b94df9SMatthew Ahrens nvpair_t *pair;
136719b94df9SMatthew Ahrens for (pair = nvlist_next_nvpair(cb->cb_nvl, NULL);
136819b94df9SMatthew Ahrens pair != NULL;
136919b94df9SMatthew Ahrens pair = nvlist_next_nvpair(cb->cb_nvl, pair)) {
137019b94df9SMatthew Ahrens zfs_handle_t *zhp = zfs_open(g_zfs, nvpair_name(pair),
137119b94df9SMatthew Ahrens ZFS_TYPE_SNAPSHOT);
137219b94df9SMatthew Ahrens if (zhp != NULL) {
137319b94df9SMatthew Ahrens boolean_t defer = cb->cb_defer_destroy;
137405c998d6SRichard Lowe int err = 0;
137519b94df9SMatthew Ahrens
137619b94df9SMatthew Ahrens /*
137719b94df9SMatthew Ahrens * We can't defer destroy non-snapshots, so set it to
137819b94df9SMatthew Ahrens * false while destroying the clones.
137919b94df9SMatthew Ahrens */
138019b94df9SMatthew Ahrens cb->cb_defer_destroy = B_FALSE;
138119b94df9SMatthew Ahrens err = zfs_iter_dependents(zhp, B_FALSE,
138219b94df9SMatthew Ahrens destroy_callback, cb);
138319b94df9SMatthew Ahrens cb->cb_defer_destroy = defer;
138419b94df9SMatthew Ahrens zfs_close(zhp);
138519b94df9SMatthew Ahrens if (err != 0)
138619b94df9SMatthew Ahrens return (err);
138719b94df9SMatthew Ahrens }
138819b94df9SMatthew Ahrens }
138919b94df9SMatthew Ahrens return (0);
13901d452cf5Sahrens }
1391fa9e4066Sahrens
1392fa9e4066Sahrens static int
zfs_do_destroy(int argc,char ** argv)1393fa9e4066Sahrens zfs_do_destroy(int argc, char **argv)
1394fa9e4066Sahrens {
1395fa9e4066Sahrens destroy_cbdata_t cb = { 0 };
13963b2aab18SMatthew Ahrens int rv = 0;
13973b2aab18SMatthew Ahrens int err = 0;
1398fa9e4066Sahrens int c;
13993b2aab18SMatthew Ahrens zfs_handle_t *zhp = NULL;
140078f17100SMatthew Ahrens char *at, *pound;
1401922d9a97SChris Kirby zfs_type_t type = ZFS_TYPE_DATASET;
1402fa9e4066Sahrens
1403fa9e4066Sahrens /* check options */
140419b94df9SMatthew Ahrens while ((c = getopt(argc, argv, "vpndfrR")) != -1) {
1405fa9e4066Sahrens switch (c) {
140619b94df9SMatthew Ahrens case 'v':
140719b94df9SMatthew Ahrens cb.cb_verbose = B_TRUE;
140819b94df9SMatthew Ahrens break;
140919b94df9SMatthew Ahrens case 'p':
141019b94df9SMatthew Ahrens cb.cb_verbose = B_TRUE;
141119b94df9SMatthew Ahrens cb.cb_parsable = B_TRUE;
141219b94df9SMatthew Ahrens break;
141319b94df9SMatthew Ahrens case 'n':
141419b94df9SMatthew Ahrens cb.cb_dryrun = B_TRUE;
141519b94df9SMatthew Ahrens break;
1416842727c2SChris Kirby case 'd':
1417842727c2SChris Kirby cb.cb_defer_destroy = B_TRUE;
1418922d9a97SChris Kirby type = ZFS_TYPE_SNAPSHOT;
1419842727c2SChris Kirby break;
1420fa9e4066Sahrens case 'f':
142119b94df9SMatthew Ahrens cb.cb_force = B_TRUE;
1422fa9e4066Sahrens break;
1423fa9e4066Sahrens case 'r':
142419b94df9SMatthew Ahrens cb.cb_recurse = B_TRUE;
1425fa9e4066Sahrens break;
1426fa9e4066Sahrens case 'R':
142719b94df9SMatthew Ahrens cb.cb_recurse = B_TRUE;
142819b94df9SMatthew Ahrens cb.cb_doclones = B_TRUE;
1429fa9e4066Sahrens break;
1430fa9e4066Sahrens case '?':
1431fa9e4066Sahrens default:
1432fa9e4066Sahrens (void) fprintf(stderr, gettext("invalid option '%c'\n"),
1433fa9e4066Sahrens optopt);
143499653d4eSeschrock usage(B_FALSE);
1435fa9e4066Sahrens }
1436fa9e4066Sahrens }
1437fa9e4066Sahrens
1438fa9e4066Sahrens argc -= optind;
1439fa9e4066Sahrens argv += optind;
1440fa9e4066Sahrens
1441fa9e4066Sahrens /* check number of arguments */
1442fa9e4066Sahrens if (argc == 0) {
144319b94df9SMatthew Ahrens (void) fprintf(stderr, gettext("missing dataset argument\n"));
144499653d4eSeschrock usage(B_FALSE);
1445fa9e4066Sahrens }
1446fa9e4066Sahrens if (argc > 1) {
1447fa9e4066Sahrens (void) fprintf(stderr, gettext("too many arguments\n"));
144899653d4eSeschrock usage(B_FALSE);
1449fa9e4066Sahrens }
1450fa9e4066Sahrens
145119b94df9SMatthew Ahrens at = strchr(argv[0], '@');
145278f17100SMatthew Ahrens pound = strchr(argv[0], '#');
145319b94df9SMatthew Ahrens if (at != NULL) {
14541d452cf5Sahrens
145519b94df9SMatthew Ahrens /* Build the list of snaps to destroy in cb_nvl. */
14563b2aab18SMatthew Ahrens cb.cb_nvl = fnvlist_alloc();
145719b94df9SMatthew Ahrens
145819b94df9SMatthew Ahrens *at = '\0';
145919b94df9SMatthew Ahrens zhp = zfs_open(g_zfs, argv[0],
146019b94df9SMatthew Ahrens ZFS_TYPE_FILESYSTEM | ZFS_TYPE_VOLUME);
146119b94df9SMatthew Ahrens if (zhp == NULL)
1462e5351341SMatthew Ahrens return (1);
1463922d9a97SChris Kirby
146419b94df9SMatthew Ahrens cb.cb_snapspec = at + 1;
146519b94df9SMatthew Ahrens if (gather_snapshots(zfs_handle_dup(zhp), &cb) != 0 ||
146619b94df9SMatthew Ahrens cb.cb_error) {
14673b2aab18SMatthew Ahrens rv = 1;
14683b2aab18SMatthew Ahrens goto out;
146919b94df9SMatthew Ahrens }
1470e5351341SMatthew Ahrens
147119b94df9SMatthew Ahrens if (nvlist_empty(cb.cb_nvl)) {
147219b94df9SMatthew Ahrens (void) fprintf(stderr, gettext("could not find any "
147319b94df9SMatthew Ahrens "snapshots to destroy; check snapshot names.\n"));
14743b2aab18SMatthew Ahrens rv = 1;
14753b2aab18SMatthew Ahrens goto out;
147619b94df9SMatthew Ahrens }
147719b94df9SMatthew Ahrens
147819b94df9SMatthew Ahrens if (cb.cb_verbose) {
147919b94df9SMatthew Ahrens char buf[16];
14806520eed5SToomas Soome zfs_nicebytes(cb.cb_snapused, buf, sizeof (buf));
148119b94df9SMatthew Ahrens if (cb.cb_parsable) {
148219b94df9SMatthew Ahrens (void) printf("reclaim\t%llu\n",
148319b94df9SMatthew Ahrens cb.cb_snapused);
148419b94df9SMatthew Ahrens } else if (cb.cb_dryrun) {
148519b94df9SMatthew Ahrens (void) printf(gettext("would reclaim %s\n"),
148619b94df9SMatthew Ahrens buf);
148719b94df9SMatthew Ahrens } else {
148819b94df9SMatthew Ahrens (void) printf(gettext("will reclaim %s\n"),
148919b94df9SMatthew Ahrens buf);
14903bb79becSeschrock }
14911d452cf5Sahrens }
14921d452cf5Sahrens
149319b94df9SMatthew Ahrens if (!cb.cb_dryrun) {
14943b2aab18SMatthew Ahrens if (cb.cb_doclones) {
14953b2aab18SMatthew Ahrens cb.cb_batchedsnaps = fnvlist_alloc();
149619b94df9SMatthew Ahrens err = destroy_clones(&cb);
14973b2aab18SMatthew Ahrens if (err == 0) {
14983b2aab18SMatthew Ahrens err = zfs_destroy_snaps_nvl(g_zfs,
14993b2aab18SMatthew Ahrens cb.cb_batchedsnaps, B_FALSE);
15003b2aab18SMatthew Ahrens }
15013b2aab18SMatthew Ahrens if (err != 0) {
15023b2aab18SMatthew Ahrens rv = 1;
15033b2aab18SMatthew Ahrens goto out;
15043b2aab18SMatthew Ahrens }
15053b2aab18SMatthew Ahrens }
150619b94df9SMatthew Ahrens if (err == 0) {
15073b2aab18SMatthew Ahrens err = zfs_destroy_snaps_nvl(g_zfs, cb.cb_nvl,
150819b94df9SMatthew Ahrens cb.cb_defer_destroy);
150919b94df9SMatthew Ahrens }
15101d452cf5Sahrens }
15111d452cf5Sahrens
151219b94df9SMatthew Ahrens if (err != 0)
15133b2aab18SMatthew Ahrens rv = 1;
151478f17100SMatthew Ahrens } else if (pound != NULL) {
151578f17100SMatthew Ahrens int err;
151678f17100SMatthew Ahrens nvlist_t *nvl;
151778f17100SMatthew Ahrens
151878f17100SMatthew Ahrens if (cb.cb_dryrun) {
151978f17100SMatthew Ahrens (void) fprintf(stderr,
152078f17100SMatthew Ahrens "dryrun is not supported with bookmark\n");
152178f17100SMatthew Ahrens return (-1);
152278f17100SMatthew Ahrens }
152378f17100SMatthew Ahrens
152478f17100SMatthew Ahrens if (cb.cb_defer_destroy) {
152578f17100SMatthew Ahrens (void) fprintf(stderr,
152678f17100SMatthew Ahrens "defer destroy is not supported with bookmark\n");
152778f17100SMatthew Ahrens return (-1);
152878f17100SMatthew Ahrens }
152978f17100SMatthew Ahrens
153078f17100SMatthew Ahrens if (cb.cb_recurse) {
153178f17100SMatthew Ahrens (void) fprintf(stderr,
153278f17100SMatthew Ahrens "recursive is not supported with bookmark\n");
153378f17100SMatthew Ahrens return (-1);
153478f17100SMatthew Ahrens }
153578f17100SMatthew Ahrens
153678f17100SMatthew Ahrens if (!zfs_bookmark_exists(argv[0])) {
153778f17100SMatthew Ahrens (void) fprintf(stderr, gettext("bookmark '%s' "
153878f17100SMatthew Ahrens "does not exist.\n"), argv[0]);
153978f17100SMatthew Ahrens return (1);
154078f17100SMatthew Ahrens }
154178f17100SMatthew Ahrens
154278f17100SMatthew Ahrens nvl = fnvlist_alloc();
154378f17100SMatthew Ahrens fnvlist_add_boolean(nvl, argv[0]);
154478f17100SMatthew Ahrens
154578f17100SMatthew Ahrens err = lzc_destroy_bookmarks(nvl, NULL);
154678f17100SMatthew Ahrens if (err != 0) {
154778f17100SMatthew Ahrens (void) zfs_standard_error(g_zfs, err,
154878f17100SMatthew Ahrens "cannot destroy bookmark");
154978f17100SMatthew Ahrens }
155078f17100SMatthew Ahrens
155178f17100SMatthew Ahrens nvlist_free(cb.cb_nvl);
155278f17100SMatthew Ahrens
155378f17100SMatthew Ahrens return (err);
155419b94df9SMatthew Ahrens } else {
155519b94df9SMatthew Ahrens /* Open the given dataset */
155619b94df9SMatthew Ahrens if ((zhp = zfs_open(g_zfs, argv[0], type)) == NULL)
155719b94df9SMatthew Ahrens return (1);
1558fa9e4066Sahrens
155919b94df9SMatthew Ahrens cb.cb_target = zhp;
1560fa9e4066Sahrens
156119b94df9SMatthew Ahrens /*
156219b94df9SMatthew Ahrens * Perform an explicit check for pools before going any further.
156319b94df9SMatthew Ahrens */
156419b94df9SMatthew Ahrens if (!cb.cb_recurse && strchr(zfs_get_name(zhp), '/') == NULL &&
156519b94df9SMatthew Ahrens zfs_get_type(zhp) == ZFS_TYPE_FILESYSTEM) {
156619b94df9SMatthew Ahrens (void) fprintf(stderr, gettext("cannot destroy '%s': "
156719b94df9SMatthew Ahrens "operation does not apply to pools\n"),
156819b94df9SMatthew Ahrens zfs_get_name(zhp));
156919b94df9SMatthew Ahrens (void) fprintf(stderr, gettext("use 'zfs destroy -r "
157019b94df9SMatthew Ahrens "%s' to destroy all datasets in the pool\n"),
157119b94df9SMatthew Ahrens zfs_get_name(zhp));
157219b94df9SMatthew Ahrens (void) fprintf(stderr, gettext("use 'zpool destroy %s' "
157319b94df9SMatthew Ahrens "to destroy the pool itself\n"), zfs_get_name(zhp));
15743b2aab18SMatthew Ahrens rv = 1;
15753b2aab18SMatthew Ahrens goto out;
157619b94df9SMatthew Ahrens }
1577fa9e4066Sahrens
157819b94df9SMatthew Ahrens /*
157919b94df9SMatthew Ahrens * Check for any dependents and/or clones.
158019b94df9SMatthew Ahrens */
158119b94df9SMatthew Ahrens cb.cb_first = B_TRUE;
158219b94df9SMatthew Ahrens if (!cb.cb_doclones &&
158319b94df9SMatthew Ahrens zfs_iter_dependents(zhp, B_TRUE, destroy_check_dependent,
158419b94df9SMatthew Ahrens &cb) != 0) {
15853b2aab18SMatthew Ahrens rv = 1;
15863b2aab18SMatthew Ahrens goto out;
158719b94df9SMatthew Ahrens }
15883bb79becSeschrock
158919b94df9SMatthew Ahrens if (cb.cb_error) {
15903b2aab18SMatthew Ahrens rv = 1;
15913b2aab18SMatthew Ahrens goto out;
159219b94df9SMatthew Ahrens }
1593fa9e4066Sahrens
15943b2aab18SMatthew Ahrens cb.cb_batchedsnaps = fnvlist_alloc();
159519b94df9SMatthew Ahrens if (zfs_iter_dependents(zhp, B_FALSE, destroy_callback,
159619b94df9SMatthew Ahrens &cb) != 0) {
15973b2aab18SMatthew Ahrens rv = 1;
15983b2aab18SMatthew Ahrens goto out;
159919b94df9SMatthew Ahrens }
1600ecd6cf80Smarks
160119b94df9SMatthew Ahrens /*
160219b94df9SMatthew Ahrens * Do the real thing. The callback will close the
160319b94df9SMatthew Ahrens * handle regardless of whether it succeeds or not.
160419b94df9SMatthew Ahrens */
16053b2aab18SMatthew Ahrens err = destroy_callback(zhp, &cb);
16063b2aab18SMatthew Ahrens zhp = NULL;
16073b2aab18SMatthew Ahrens if (err == 0) {
16083b2aab18SMatthew Ahrens err = zfs_destroy_snaps_nvl(g_zfs,
16093b2aab18SMatthew Ahrens cb.cb_batchedsnaps, cb.cb_defer_destroy);
16103b2aab18SMatthew Ahrens }
16113b2aab18SMatthew Ahrens if (err != 0)
16123b2aab18SMatthew Ahrens rv = 1;
161319b94df9SMatthew Ahrens }
1614fa9e4066Sahrens
16153b2aab18SMatthew Ahrens out:
16163b2aab18SMatthew Ahrens fnvlist_free(cb.cb_batchedsnaps);
16173b2aab18SMatthew Ahrens fnvlist_free(cb.cb_nvl);
16183b2aab18SMatthew Ahrens if (zhp != NULL)
16193b2aab18SMatthew Ahrens zfs_close(zhp);
16203b2aab18SMatthew Ahrens return (rv);
1621fa9e4066Sahrens }
1622fa9e4066Sahrens
162392241e0bSTom Erickson static boolean_t
is_recvd_column(zprop_get_cbdata_t * cbp)162492241e0bSTom Erickson is_recvd_column(zprop_get_cbdata_t *cbp)
162592241e0bSTom Erickson {
162692241e0bSTom Erickson int i;
162792241e0bSTom Erickson zfs_get_column_t col;
162892241e0bSTom Erickson
162992241e0bSTom Erickson for (i = 0; i < ZFS_GET_NCOLS &&
163092241e0bSTom Erickson (col = cbp->cb_columns[i]) != GET_COL_NONE; i++)
163192241e0bSTom Erickson if (col == GET_COL_RECVD)
163292241e0bSTom Erickson return (B_TRUE);
163392241e0bSTom Erickson return (B_FALSE);
163492241e0bSTom Erickson }
163592241e0bSTom Erickson
1636fa9e4066Sahrens /*
163792241e0bSTom Erickson * zfs get [-rHp] [-o all | field[,field]...] [-s source[,source]...]
163892241e0bSTom Erickson * < all | property[,property]... > < fs | snap | vol > ...
1639fa9e4066Sahrens *
1640fa9e4066Sahrens * -r recurse over any child datasets
1641fa9e4066Sahrens * -H scripted mode. Headers are stripped, and fields are separated
1642fa9e4066Sahrens * by tabs instead of spaces.
164392241e0bSTom Erickson * -o Set of fields to display. One of "name,property,value,
164492241e0bSTom Erickson * received,source". Default is "name,property,value,source".
164592241e0bSTom Erickson * "all" is an alias for all five.
1646fa9e4066Sahrens * -s Set of sources to allow. One of
164792241e0bSTom Erickson * "local,default,inherited,received,temporary,none". Default is
164892241e0bSTom Erickson * all six.
1649fa9e4066Sahrens * -p Display values in parsable (literal) format.
1650fa9e4066Sahrens *
1651fa9e4066Sahrens * Prints properties for the given datasets. The user can control which
1652fa9e4066Sahrens * columns to display as well as which property types to allow.
1653fa9e4066Sahrens */
1654fa9e4066Sahrens
1655fa9e4066Sahrens /*
1656fa9e4066Sahrens * Invoked to display the properties for a single dataset.
1657fa9e4066Sahrens */
1658fa9e4066Sahrens static int
get_callback(zfs_handle_t * zhp,void * data)1659fa9e4066Sahrens get_callback(zfs_handle_t *zhp, void *data)
1660fa9e4066Sahrens {
1661fa9e4066Sahrens char buf[ZFS_MAXPROPLEN];
166292241e0bSTom Erickson char rbuf[ZFS_MAXPROPLEN];
1663990b4856Slling zprop_source_t sourcetype;
16649adfa60dSMatthew Ahrens char source[ZFS_MAX_DATASET_NAME_LEN];
1665990b4856Slling zprop_get_cbdata_t *cbp = data;
166692241e0bSTom Erickson nvlist_t *user_props = zfs_get_user_props(zhp);
1667990b4856Slling zprop_list_t *pl = cbp->cb_proplist;
1668e9dbad6fSeschrock nvlist_t *propval;
1669e9dbad6fSeschrock char *strval;
1670e9dbad6fSeschrock char *sourceval;
167192241e0bSTom Erickson boolean_t received = is_recvd_column(cbp);
1672fa9e4066Sahrens
1673e9dbad6fSeschrock for (; pl != NULL; pl = pl->pl_next) {
167492241e0bSTom Erickson char *recvdval = NULL;
1675e9dbad6fSeschrock /*
1676e9dbad6fSeschrock * Skip the special fake placeholder. This will also skip over
1677e9dbad6fSeschrock * the name property when 'all' is specified.
1678e9dbad6fSeschrock */
1679e9dbad6fSeschrock if (pl->pl_prop == ZFS_PROP_NAME &&
1680e9dbad6fSeschrock pl == cbp->cb_proplist)
1681e9dbad6fSeschrock continue;
1682e9dbad6fSeschrock
1683990b4856Slling if (pl->pl_prop != ZPROP_INVAL) {
1684e9dbad6fSeschrock if (zfs_prop_get(zhp, pl->pl_prop, buf,
1685e9dbad6fSeschrock sizeof (buf), &sourcetype, source,
1686e9dbad6fSeschrock sizeof (source),
1687e9dbad6fSeschrock cbp->cb_literal) != 0) {
1688e9dbad6fSeschrock if (pl->pl_all)
1689e9dbad6fSeschrock continue;
1690b1b8ab34Slling if (!zfs_prop_valid_for_type(pl->pl_prop,
16914c2bdae2STim Chase ZFS_TYPE_DATASET, B_FALSE)) {
1692b1b8ab34Slling (void) fprintf(stderr,
1693b1b8ab34Slling gettext("No such property '%s'\n"),
1694b1b8ab34Slling zfs_prop_to_name(pl->pl_prop));
1695b1b8ab34Slling continue;
1696b1b8ab34Slling }
1697990b4856Slling sourcetype = ZPROP_SRC_NONE;
1698e9dbad6fSeschrock (void) strlcpy(buf, "-", sizeof (buf));
1699e9dbad6fSeschrock }
1700e9dbad6fSeschrock
170192241e0bSTom Erickson if (received && (zfs_prop_get_recvd(zhp,
170292241e0bSTom Erickson zfs_prop_to_name(pl->pl_prop), rbuf, sizeof (rbuf),
170392241e0bSTom Erickson cbp->cb_literal) == 0))
170492241e0bSTom Erickson recvdval = rbuf;
170592241e0bSTom Erickson
1706990b4856Slling zprop_print_one_property(zfs_get_name(zhp), cbp,
1707e9dbad6fSeschrock zfs_prop_to_name(pl->pl_prop),
170892241e0bSTom Erickson buf, sourcetype, source, recvdval);
170914843421SMatthew Ahrens } else if (zfs_prop_userquota(pl->pl_user_prop)) {
171014843421SMatthew Ahrens sourcetype = ZPROP_SRC_LOCAL;
171114843421SMatthew Ahrens
171214843421SMatthew Ahrens if (zfs_prop_get_userquota(zhp, pl->pl_user_prop,
171314843421SMatthew Ahrens buf, sizeof (buf), cbp->cb_literal) != 0) {
171414843421SMatthew Ahrens sourcetype = ZPROP_SRC_NONE;
171514843421SMatthew Ahrens (void) strlcpy(buf, "-", sizeof (buf));
171614843421SMatthew Ahrens }
171714843421SMatthew Ahrens
171819b94df9SMatthew Ahrens zprop_print_one_property(zfs_get_name(zhp), cbp,
171919b94df9SMatthew Ahrens pl->pl_user_prop, buf, sourcetype, source, NULL);
172019b94df9SMatthew Ahrens } else if (zfs_prop_written(pl->pl_user_prop)) {
172119b94df9SMatthew Ahrens sourcetype = ZPROP_SRC_LOCAL;
172219b94df9SMatthew Ahrens
172319b94df9SMatthew Ahrens if (zfs_prop_get_written(zhp, pl->pl_user_prop,
172419b94df9SMatthew Ahrens buf, sizeof (buf), cbp->cb_literal) != 0) {
172519b94df9SMatthew Ahrens sourcetype = ZPROP_SRC_NONE;
172619b94df9SMatthew Ahrens (void) strlcpy(buf, "-", sizeof (buf));
172719b94df9SMatthew Ahrens }
172819b94df9SMatthew Ahrens
172914843421SMatthew Ahrens zprop_print_one_property(zfs_get_name(zhp), cbp,
173092241e0bSTom Erickson pl->pl_user_prop, buf, sourcetype, source, NULL);
1731e9dbad6fSeschrock } else {
173292241e0bSTom Erickson if (nvlist_lookup_nvlist(user_props,
1733e9dbad6fSeschrock pl->pl_user_prop, &propval) != 0) {
1734e9dbad6fSeschrock if (pl->pl_all)
1735e9dbad6fSeschrock continue;
1736990b4856Slling sourcetype = ZPROP_SRC_NONE;
1737e9dbad6fSeschrock strval = "-";
1738e9dbad6fSeschrock } else {
1739e9dbad6fSeschrock verify(nvlist_lookup_string(propval,
1740990b4856Slling ZPROP_VALUE, &strval) == 0);
1741e9dbad6fSeschrock verify(nvlist_lookup_string(propval,
1742990b4856Slling ZPROP_SOURCE, &sourceval) == 0);
1743e9dbad6fSeschrock
1744e9dbad6fSeschrock if (strcmp(sourceval,
1745e9dbad6fSeschrock zfs_get_name(zhp)) == 0) {
1746990b4856Slling sourcetype = ZPROP_SRC_LOCAL;
174792241e0bSTom Erickson } else if (strcmp(sourceval,
174892241e0bSTom Erickson ZPROP_SOURCE_VAL_RECVD) == 0) {
174992241e0bSTom Erickson sourcetype = ZPROP_SRC_RECEIVED;
1750e9dbad6fSeschrock } else {
1751990b4856Slling sourcetype = ZPROP_SRC_INHERITED;
1752e9dbad6fSeschrock (void) strlcpy(source,
1753e9dbad6fSeschrock sourceval, sizeof (source));
1754e9dbad6fSeschrock }
1755e9dbad6fSeschrock }
175607ba0419Seschrock
175792241e0bSTom Erickson if (received && (zfs_prop_get_recvd(zhp,
175892241e0bSTom Erickson pl->pl_user_prop, rbuf, sizeof (rbuf),
175992241e0bSTom Erickson cbp->cb_literal) == 0))
176092241e0bSTom Erickson recvdval = rbuf;
176192241e0bSTom Erickson
1762990b4856Slling zprop_print_one_property(zfs_get_name(zhp), cbp,
1763e9dbad6fSeschrock pl->pl_user_prop, strval, sourcetype,
176492241e0bSTom Erickson source, recvdval);
1765e9dbad6fSeschrock }
1766fa9e4066Sahrens }
1767fa9e4066Sahrens
1768fa9e4066Sahrens return (0);
1769fa9e4066Sahrens }
1770fa9e4066Sahrens
1771fa9e4066Sahrens static int
zfs_do_get(int argc,char ** argv)1772fa9e4066Sahrens zfs_do_get(int argc, char **argv)
1773fa9e4066Sahrens {
1774990b4856Slling zprop_get_cbdata_t cb = { 0 };
17755ead3ed9SShampavman int i, c, flags = ZFS_ITER_ARGS_CAN_BE_PATHS;
1776edb901aaSMarcel Telka int types = ZFS_TYPE_DATASET | ZFS_TYPE_BOOKMARK;
1777e9dbad6fSeschrock char *value, *fields;
177805c998d6SRichard Lowe int ret = 0;
1779ae1726b6SChris Gerhard int limit = 0;
1780990b4856Slling zprop_list_t fake_name = { 0 };
1781fa9e4066Sahrens
1782fa9e4066Sahrens /*
1783fa9e4066Sahrens * Set up default columns and sources.
1784fa9e4066Sahrens */
1785990b4856Slling cb.cb_sources = ZPROP_SRC_ALL;
1786fa9e4066Sahrens cb.cb_columns[0] = GET_COL_NAME;
1787fa9e4066Sahrens cb.cb_columns[1] = GET_COL_PROPERTY;
1788fa9e4066Sahrens cb.cb_columns[2] = GET_COL_VALUE;
1789fa9e4066Sahrens cb.cb_columns[3] = GET_COL_SOURCE;
1790990b4856Slling cb.cb_type = ZFS_TYPE_DATASET;
1791fa9e4066Sahrens
1792fa9e4066Sahrens /* check options */
1793441cac7aSAndrew Stormont while ((c = getopt(argc, argv, ":d:o:s:rt:Hp")) != -1) {
1794fa9e4066Sahrens switch (c) {
1795fa9e4066Sahrens case 'p':
179699653d4eSeschrock cb.cb_literal = B_TRUE;
1797fa9e4066Sahrens break;
1798ae1726b6SChris Gerhard case 'd':
1799ae1726b6SChris Gerhard limit = parse_depth(optarg, &flags);
1800ae1726b6SChris Gerhard break;
1801fa9e4066Sahrens case 'r':
1802d5b5bb25SRich Morris flags |= ZFS_ITER_RECURSE;
1803fa9e4066Sahrens break;
1804fa9e4066Sahrens case 'H':
180599653d4eSeschrock cb.cb_scripted = B_TRUE;
1806fa9e4066Sahrens break;
1807fa9e4066Sahrens case ':':
1808fa9e4066Sahrens (void) fprintf(stderr, gettext("missing argument for "
1809fa9e4066Sahrens "'%c' option\n"), optopt);
181099653d4eSeschrock usage(B_FALSE);
1811fa9e4066Sahrens break;
1812fa9e4066Sahrens case 'o':
1813fa9e4066Sahrens /*
1814fa9e4066Sahrens * Process the set of columns to display. We zero out
1815fa9e4066Sahrens * the structure to give us a blank slate.
1816fa9e4066Sahrens */
1817fa9e4066Sahrens bzero(&cb.cb_columns, sizeof (cb.cb_columns));
1818fa9e4066Sahrens i = 0;
1819fa9e4066Sahrens while (*optarg != '\0') {
1820fa9e4066Sahrens static char *col_subopts[] =
182192241e0bSTom Erickson { "name", "property", "value", "received",
182292241e0bSTom Erickson "source", "all", NULL };
1823fa9e4066Sahrens
182492241e0bSTom Erickson if (i == ZFS_GET_NCOLS) {
1825fa9e4066Sahrens (void) fprintf(stderr, gettext("too "
1826fa9e4066Sahrens "many fields given to -o "
1827fa9e4066Sahrens "option\n"));
182899653d4eSeschrock usage(B_FALSE);
1829fa9e4066Sahrens }
1830fa9e4066Sahrens
1831fa9e4066Sahrens switch (getsubopt(&optarg, col_subopts,
1832fa9e4066Sahrens &value)) {
1833fa9e4066Sahrens case 0:
1834fa9e4066Sahrens cb.cb_columns[i++] = GET_COL_NAME;
1835fa9e4066Sahrens break;
1836fa9e4066Sahrens case 1:
1837fa9e4066Sahrens cb.cb_columns[i++] = GET_COL_PROPERTY;
1838fa9e4066Sahrens break;
1839fa9e4066Sahrens case 2:
1840fa9e4066Sahrens cb.cb_columns[i++] = GET_COL_VALUE;
1841fa9e4066Sahrens break;
1842fa9e4066Sahrens case 3:
184392241e0bSTom Erickson cb.cb_columns[i++] = GET_COL_RECVD;
184492241e0bSTom Erickson flags |= ZFS_ITER_RECVD_PROPS;
184592241e0bSTom Erickson break;
184692241e0bSTom Erickson case 4:
1847fa9e4066Sahrens cb.cb_columns[i++] = GET_COL_SOURCE;
1848fa9e4066Sahrens break;
184992241e0bSTom Erickson case 5:
185092241e0bSTom Erickson if (i > 0) {
185192241e0bSTom Erickson (void) fprintf(stderr,
185292241e0bSTom Erickson gettext("\"all\" conflicts "
185392241e0bSTom Erickson "with specific fields "
185492241e0bSTom Erickson "given to -o option\n"));
185592241e0bSTom Erickson usage(B_FALSE);
185692241e0bSTom Erickson }
185792241e0bSTom Erickson cb.cb_columns[0] = GET_COL_NAME;
185892241e0bSTom Erickson cb.cb_columns[1] = GET_COL_PROPERTY;
185992241e0bSTom Erickson cb.cb_columns[2] = GET_COL_VALUE;
186092241e0bSTom Erickson cb.cb_columns[3] = GET_COL_RECVD;
186192241e0bSTom Erickson cb.cb_columns[4] = GET_COL_SOURCE;
186292241e0bSTom Erickson flags |= ZFS_ITER_RECVD_PROPS;
186392241e0bSTom Erickson i = ZFS_GET_NCOLS;
186492241e0bSTom Erickson break;
1865fa9e4066Sahrens default:
1866fa9e4066Sahrens (void) fprintf(stderr,
1867fa9e4066Sahrens gettext("invalid column name "
1868fa9e4066Sahrens "'%s'\n"), value);
1869b1b8ab34Slling usage(B_FALSE);
1870fa9e4066Sahrens }
1871fa9e4066Sahrens }
1872fa9e4066Sahrens break;
1873fa9e4066Sahrens
1874fa9e4066Sahrens case 's':
1875fa9e4066Sahrens cb.cb_sources = 0;
1876fa9e4066Sahrens while (*optarg != '\0') {
1877fa9e4066Sahrens static char *source_subopts[] = {
1878fa9e4066Sahrens "local", "default", "inherited",
187992241e0bSTom Erickson "received", "temporary", "none",
188092241e0bSTom Erickson NULL };
1881fa9e4066Sahrens
1882fa9e4066Sahrens switch (getsubopt(&optarg, source_subopts,
1883fa9e4066Sahrens &value)) {
1884fa9e4066Sahrens case 0:
1885990b4856Slling cb.cb_sources |= ZPROP_SRC_LOCAL;
1886fa9e4066Sahrens break;
1887fa9e4066Sahrens case 1:
1888990b4856Slling cb.cb_sources |= ZPROP_SRC_DEFAULT;
1889fa9e4066Sahrens break;
1890fa9e4066Sahrens case 2:
1891990b4856Slling cb.cb_sources |= ZPROP_SRC_INHERITED;
1892fa9e4066Sahrens break;
1893fa9e4066Sahrens case 3:
189492241e0bSTom Erickson cb.cb_sources |= ZPROP_SRC_RECEIVED;
1895fa9e4066Sahrens break;
1896fa9e4066Sahrens case 4:
189792241e0bSTom Erickson cb.cb_sources |= ZPROP_SRC_TEMPORARY;
189892241e0bSTom Erickson break;
189992241e0bSTom Erickson case 5:
1900990b4856Slling cb.cb_sources |= ZPROP_SRC_NONE;
1901fa9e4066Sahrens break;
1902fa9e4066Sahrens default:
1903fa9e4066Sahrens (void) fprintf(stderr,
1904fa9e4066Sahrens gettext("invalid source "
1905fa9e4066Sahrens "'%s'\n"), value);
1906b1b8ab34Slling usage(B_FALSE);
1907fa9e4066Sahrens }
1908fa9e4066Sahrens }
1909fa9e4066Sahrens break;
1910fa9e4066Sahrens
1911441cac7aSAndrew Stormont case 't':
1912441cac7aSAndrew Stormont types = 0;
1913441cac7aSAndrew Stormont flags &= ~ZFS_ITER_PROP_LISTSNAPS;
1914441cac7aSAndrew Stormont while (*optarg != '\0') {
1915441cac7aSAndrew Stormont static char *type_subopts[] = { "filesystem",
191678f17100SMatthew Ahrens "volume", "snapshot", "bookmark",
191778f17100SMatthew Ahrens "all", NULL };
1918441cac7aSAndrew Stormont
1919441cac7aSAndrew Stormont switch (getsubopt(&optarg, type_subopts,
1920441cac7aSAndrew Stormont &value)) {
1921441cac7aSAndrew Stormont case 0:
1922441cac7aSAndrew Stormont types |= ZFS_TYPE_FILESYSTEM;
1923441cac7aSAndrew Stormont break;
1924441cac7aSAndrew Stormont case 1:
1925441cac7aSAndrew Stormont types |= ZFS_TYPE_VOLUME;
1926441cac7aSAndrew Stormont break;
1927441cac7aSAndrew Stormont case 2:
1928441cac7aSAndrew Stormont types |= ZFS_TYPE_SNAPSHOT;
1929441cac7aSAndrew Stormont break;
1930441cac7aSAndrew Stormont case 3:
193178f17100SMatthew Ahrens types |= ZFS_TYPE_BOOKMARK;
193278f17100SMatthew Ahrens break;
193378f17100SMatthew Ahrens case 4:
193478f17100SMatthew Ahrens types = ZFS_TYPE_DATASET |
193578f17100SMatthew Ahrens ZFS_TYPE_BOOKMARK;
1936441cac7aSAndrew Stormont break;
1937441cac7aSAndrew Stormont
1938441cac7aSAndrew Stormont default:
1939441cac7aSAndrew Stormont (void) fprintf(stderr,
1940441cac7aSAndrew Stormont gettext("invalid type '%s'\n"),
1941441cac7aSAndrew Stormont value);
1942441cac7aSAndrew Stormont usage(B_FALSE);
1943441cac7aSAndrew Stormont }
1944441cac7aSAndrew Stormont }
1945441cac7aSAndrew Stormont break;
1946441cac7aSAndrew Stormont
1947fa9e4066Sahrens case '?':
1948fa9e4066Sahrens (void) fprintf(stderr, gettext("invalid option '%c'\n"),
1949fa9e4066Sahrens optopt);
195099653d4eSeschrock usage(B_FALSE);
1951fa9e4066Sahrens }
1952fa9e4066Sahrens }
1953fa9e4066Sahrens
1954fa9e4066Sahrens argc -= optind;
1955fa9e4066Sahrens argv += optind;
1956fa9e4066Sahrens
1957fa9e4066Sahrens if (argc < 1) {
1958fa9e4066Sahrens (void) fprintf(stderr, gettext("missing property "
1959fa9e4066Sahrens "argument\n"));
196099653d4eSeschrock usage(B_FALSE);
1961fa9e4066Sahrens }
1962fa9e4066Sahrens
1963fa9e4066Sahrens fields = argv[0];
1964fa9e4066Sahrens
1965990b4856Slling if (zprop_get_list(g_zfs, fields, &cb.cb_proplist, ZFS_TYPE_DATASET)
1966990b4856Slling != 0)
196799653d4eSeschrock usage(B_FALSE);
1968fa9e4066Sahrens
1969fa9e4066Sahrens argc--;
1970fa9e4066Sahrens argv++;
1971fa9e4066Sahrens
1972fa9e4066Sahrens /*
1973e9dbad6fSeschrock * As part of zfs_expand_proplist(), we keep track of the maximum column
1974e9dbad6fSeschrock * width for each property. For the 'NAME' (and 'SOURCE') columns, we
1975e9dbad6fSeschrock * need to know the maximum name length. However, the user likely did
1976e9dbad6fSeschrock * not specify 'name' as one of the properties to fetch, so we need to
1977e9dbad6fSeschrock * make sure we always include at least this property for
1978e9dbad6fSeschrock * print_get_headers() to work properly.
1979fa9e4066Sahrens */
1980e9dbad6fSeschrock if (cb.cb_proplist != NULL) {
1981e9dbad6fSeschrock fake_name.pl_prop = ZFS_PROP_NAME;
1982e9dbad6fSeschrock fake_name.pl_width = strlen(gettext("NAME"));
1983e9dbad6fSeschrock fake_name.pl_next = cb.cb_proplist;
1984e9dbad6fSeschrock cb.cb_proplist = &fake_name;
1985fa9e4066Sahrens }
1986fa9e4066Sahrens
1987e9dbad6fSeschrock cb.cb_first = B_TRUE;
1988e9dbad6fSeschrock
1989fa9e4066Sahrens /* run for each object */
1990441cac7aSAndrew Stormont ret = zfs_for_each(argc, argv, flags, types, NULL,
1991ae1726b6SChris Gerhard &cb.cb_proplist, limit, get_callback, &cb);
1992b6825278Ssjelinek
1993e9dbad6fSeschrock if (cb.cb_proplist == &fake_name)
1994990b4856Slling zprop_free_list(fake_name.pl_next);
1995e9dbad6fSeschrock else
1996990b4856Slling zprop_free_list(cb.cb_proplist);
1997e9dbad6fSeschrock
1998e9dbad6fSeschrock return (ret);
1999fa9e4066Sahrens }
2000fa9e4066Sahrens
2001fa9e4066Sahrens /*
200292241e0bSTom Erickson * inherit [-rS] <property> <fs|vol> ...
2003fa9e4066Sahrens *
200492241e0bSTom Erickson * -r Recurse over all children
200592241e0bSTom Erickson * -S Revert to received value, if any
2006fa9e4066Sahrens *
2007fa9e4066Sahrens * For each dataset specified on the command line, inherit the given property
2008fa9e4066Sahrens * from its parent. Inheriting a property at the pool level will cause it to
2009fa9e4066Sahrens * use the default value. The '-r' flag will recurse over all children, and is
2010fa9e4066Sahrens * useful for setting a property on a hierarchy-wide basis, regardless of any
2011fa9e4066Sahrens * local modifications for each dataset.
2012fa9e4066Sahrens */
201306eeb2adSek
201492241e0bSTom Erickson typedef struct inherit_cbdata {
201592241e0bSTom Erickson const char *cb_propname;
201692241e0bSTom Erickson boolean_t cb_received;
201792241e0bSTom Erickson } inherit_cbdata_t;
201892241e0bSTom Erickson
2019fa9e4066Sahrens static int
inherit_recurse_cb(zfs_handle_t * zhp,void * data)2020bb0ade09Sahrens inherit_recurse_cb(zfs_handle_t *zhp, void *data)
2021fa9e4066Sahrens {
202292241e0bSTom Erickson inherit_cbdata_t *cb = data;
202392241e0bSTom Erickson zfs_prop_t prop = zfs_name_to_prop(cb->cb_propname);
202406eeb2adSek
2025bb0ade09Sahrens /*
2026bb0ade09Sahrens * If we're doing it recursively, then ignore properties that
2027bb0ade09Sahrens * are not valid for this type of dataset.
2028bb0ade09Sahrens */
2029bb0ade09Sahrens if (prop != ZPROP_INVAL &&
20304c2bdae2STim Chase !zfs_prop_valid_for_type(prop, zfs_get_type(zhp), B_FALSE))
2031bb0ade09Sahrens return (0);
2032bb0ade09Sahrens
203392241e0bSTom Erickson return (zfs_prop_inherit(zhp, cb->cb_propname, cb->cb_received) != 0);
2034bb0ade09Sahrens }
2035bb0ade09Sahrens
2036bb0ade09Sahrens static int
inherit_cb(zfs_handle_t * zhp,void * data)2037bb0ade09Sahrens inherit_cb(zfs_handle_t *zhp, void *data)
2038bb0ade09Sahrens {
203992241e0bSTom Erickson inherit_cbdata_t *cb = data;
2040bb0ade09Sahrens
204192241e0bSTom Erickson return (zfs_prop_inherit(zhp, cb->cb_propname, cb->cb_received) != 0);
2042fa9e4066Sahrens }
2043fa9e4066Sahrens
2044fa9e4066Sahrens static int
zfs_do_inherit(int argc,char ** argv)2045fa9e4066Sahrens zfs_do_inherit(int argc, char **argv)
2046fa9e4066Sahrens {
2047fa9e4066Sahrens int c;
2048fa9e4066Sahrens zfs_prop_t prop;
204992241e0bSTom Erickson inherit_cbdata_t cb = { 0 };
2050ecd6cf80Smarks char *propname;
205105c998d6SRichard Lowe int ret = 0;
2052d5b5bb25SRich Morris int flags = 0;
205392241e0bSTom Erickson boolean_t received = B_FALSE;
2054fa9e4066Sahrens
2055fa9e4066Sahrens /* check options */
205692241e0bSTom Erickson while ((c = getopt(argc, argv, "rS")) != -1) {
2057fa9e4066Sahrens switch (c) {
2058fa9e4066Sahrens case 'r':
2059d5b5bb25SRich Morris flags |= ZFS_ITER_RECURSE;
2060fa9e4066Sahrens break;
206192241e0bSTom Erickson case 'S':
206292241e0bSTom Erickson received = B_TRUE;
206392241e0bSTom Erickson break;
2064fa9e4066Sahrens case '?':
2065fa9e4066Sahrens default:
2066fa9e4066Sahrens (void) fprintf(stderr, gettext("invalid option '%c'\n"),
2067fa9e4066Sahrens optopt);
206899653d4eSeschrock usage(B_FALSE);
2069fa9e4066Sahrens }
2070fa9e4066Sahrens }
2071fa9e4066Sahrens
2072fa9e4066Sahrens argc -= optind;
2073fa9e4066Sahrens argv += optind;
2074fa9e4066Sahrens
2075fa9e4066Sahrens /* check number of arguments */
2076fa9e4066Sahrens if (argc < 1) {
2077fa9e4066Sahrens (void) fprintf(stderr, gettext("missing property argument\n"));
207899653d4eSeschrock usage(B_FALSE);
2079fa9e4066Sahrens }
2080fa9e4066Sahrens if (argc < 2) {
2081fa9e4066Sahrens (void) fprintf(stderr, gettext("missing dataset argument\n"));
208299653d4eSeschrock usage(B_FALSE);
2083fa9e4066Sahrens }
2084fa9e4066Sahrens
2085ecd6cf80Smarks propname = argv[0];
2086e9dbad6fSeschrock argc--;
2087e9dbad6fSeschrock argv++;
2088fa9e4066Sahrens
2089990b4856Slling if ((prop = zfs_name_to_prop(propname)) != ZPROP_INVAL) {
2090e9dbad6fSeschrock if (zfs_prop_readonly(prop)) {
2091e9dbad6fSeschrock (void) fprintf(stderr, gettext(
2092e9dbad6fSeschrock "%s property is read-only\n"),
2093ecd6cf80Smarks propname);
2094e9dbad6fSeschrock return (1);
2095e9dbad6fSeschrock }
209692241e0bSTom Erickson if (!zfs_prop_inheritable(prop) && !received) {
2097e9dbad6fSeschrock (void) fprintf(stderr, gettext("'%s' property cannot "
2098ecd6cf80Smarks "be inherited\n"), propname);
2099e9dbad6fSeschrock if (prop == ZFS_PROP_QUOTA ||
2100a9799022Sck prop == ZFS_PROP_RESERVATION ||
2101a9799022Sck prop == ZFS_PROP_REFQUOTA ||
21025ff8cfa9SPaul B. Henson prop == ZFS_PROP_REFRESERVATION) {
2103e9dbad6fSeschrock (void) fprintf(stderr, gettext("use 'zfs set "
2104ecd6cf80Smarks "%s=none' to clear\n"), propname);
21055ff8cfa9SPaul B. Henson (void) fprintf(stderr, gettext("use 'zfs "
21065ff8cfa9SPaul B. Henson "inherit -S %s' to revert to received "
21075ff8cfa9SPaul B. Henson "value\n"), propname);
21085ff8cfa9SPaul B. Henson }
2109e9dbad6fSeschrock return (1);
2110e9dbad6fSeschrock }
2111a79992aaSTom Erickson if (received && (prop == ZFS_PROP_VOLSIZE ||
2112a79992aaSTom Erickson prop == ZFS_PROP_VERSION)) {
2113a79992aaSTom Erickson (void) fprintf(stderr, gettext("'%s' property cannot "
2114a79992aaSTom Erickson "be reverted to a received value\n"), propname);
2115a79992aaSTom Erickson return (1);
2116a79992aaSTom Erickson }
2117ecd6cf80Smarks } else if (!zfs_prop_user(propname)) {
2118ecd6cf80Smarks (void) fprintf(stderr, gettext("invalid property '%s'\n"),
2119ecd6cf80Smarks propname);
212099653d4eSeschrock usage(B_FALSE);
2121fa9e4066Sahrens }
2122fa9e4066Sahrens
212392241e0bSTom Erickson cb.cb_propname = propname;
212492241e0bSTom Erickson cb.cb_received = received;
212592241e0bSTom Erickson
2126d5b5bb25SRich Morris if (flags & ZFS_ITER_RECURSE) {
2127d5b5bb25SRich Morris ret = zfs_for_each(argc, argv, flags, ZFS_TYPE_DATASET,
212892241e0bSTom Erickson NULL, NULL, 0, inherit_recurse_cb, &cb);
2129bb0ade09Sahrens } else {
2130d5b5bb25SRich Morris ret = zfs_for_each(argc, argv, flags, ZFS_TYPE_DATASET,
213192241e0bSTom Erickson NULL, NULL, 0, inherit_cb, &cb);
2132bb0ade09Sahrens }
213306eeb2adSek
213406eeb2adSek return (ret);
2135fa9e4066Sahrens }
2136fa9e4066Sahrens
2137e7437265Sahrens typedef struct upgrade_cbdata {
2138e7437265Sahrens uint64_t cb_numupgraded;
2139e7437265Sahrens uint64_t cb_numsamegraded;
2140e45ce728Sahrens uint64_t cb_numfailed;
2141e7437265Sahrens uint64_t cb_version;
2142e7437265Sahrens boolean_t cb_newer;
2143e7437265Sahrens boolean_t cb_foundone;
21449adfa60dSMatthew Ahrens char cb_lastfs[ZFS_MAX_DATASET_NAME_LEN];
2145e7437265Sahrens } upgrade_cbdata_t;
2146e7437265Sahrens
2147e7437265Sahrens static int
same_pool(zfs_handle_t * zhp,const char * name)2148e7437265Sahrens same_pool(zfs_handle_t *zhp, const char *name)
2149e7437265Sahrens {
2150e7437265Sahrens int len1 = strcspn(name, "/@");
2151e7437265Sahrens const char *zhname = zfs_get_name(zhp);
2152e7437265Sahrens int len2 = strcspn(zhname, "/@");
2153e7437265Sahrens
2154e7437265Sahrens if (len1 != len2)
2155e7437265Sahrens return (B_FALSE);
21562a6b87f0Sek return (strncmp(name, zhname, len1) == 0);
2157e7437265Sahrens }
2158e7437265Sahrens
2159e7437265Sahrens static int
upgrade_list_callback(zfs_handle_t * zhp,void * data)2160e7437265Sahrens upgrade_list_callback(zfs_handle_t *zhp, void *data)
2161e7437265Sahrens {
2162e7437265Sahrens upgrade_cbdata_t *cb = data;
2163e7437265Sahrens int version = zfs_prop_get_int(zhp, ZFS_PROP_VERSION);
2164e7437265Sahrens
2165e7437265Sahrens /* list if it's old/new */
2166e7437265Sahrens if ((!cb->cb_newer && version < ZPL_VERSION) ||
21673cb34c60Sahrens (cb->cb_newer && version > ZPL_VERSION)) {
2168e7437265Sahrens char *str;
2169e7437265Sahrens if (cb->cb_newer) {
2170e7437265Sahrens str = gettext("The following filesystems are "
2171e7437265Sahrens "formatted using a newer software version and\n"
2172e7437265Sahrens "cannot be accessed on the current system.\n\n");
2173e7437265Sahrens } else {
2174e7437265Sahrens str = gettext("The following filesystems are "
2175e7437265Sahrens "out of date, and can be upgraded. After being\n"
2176e7437265Sahrens "upgraded, these filesystems (and any 'zfs send' "
2177e7437265Sahrens "streams generated from\n"
2178e7437265Sahrens "subsequent snapshots) will no longer be "
2179e7437265Sahrens "accessible by older software versions.\n\n");
2180e7437265Sahrens }
2181e7437265Sahrens
2182e7437265Sahrens if (!cb->cb_foundone) {
2183e7437265Sahrens (void) puts(str);
2184e7437265Sahrens (void) printf(gettext("VER FILESYSTEM\n"));
2185e7437265Sahrens (void) printf(gettext("--- ------------\n"));
2186e7437265Sahrens cb->cb_foundone = B_TRUE;
2187e7437265Sahrens }
2188e7437265Sahrens
2189e7437265Sahrens (void) printf("%2u %s\n", version, zfs_get_name(zhp));
2190e7437265Sahrens }
2191e7437265Sahrens
2192e7437265Sahrens return (0);
2193e7437265Sahrens }
2194e7437265Sahrens
2195e7437265Sahrens static int
upgrade_set_callback(zfs_handle_t * zhp,void * data)2196e7437265Sahrens upgrade_set_callback(zfs_handle_t *zhp, void *data)
2197e7437265Sahrens {
2198e7437265Sahrens upgrade_cbdata_t *cb = data;
2199e7437265Sahrens int version = zfs_prop_get_int(zhp, ZFS_PROP_VERSION);
22000a586ceaSMark Shellenbaum int needed_spa_version;
22010a586ceaSMark Shellenbaum int spa_version;
22020a586ceaSMark Shellenbaum
22030a586ceaSMark Shellenbaum if (zfs_spa_version(zhp, &spa_version) < 0)
22040a586ceaSMark Shellenbaum return (-1);
22050a586ceaSMark Shellenbaum
22060a586ceaSMark Shellenbaum needed_spa_version = zfs_spa_version_map(cb->cb_version);
22070a586ceaSMark Shellenbaum
22080a586ceaSMark Shellenbaum if (needed_spa_version < 0)
22090a586ceaSMark Shellenbaum return (-1);
22100a586ceaSMark Shellenbaum
22110a586ceaSMark Shellenbaum if (spa_version < needed_spa_version) {
22120a586ceaSMark Shellenbaum /* can't upgrade */
22130a586ceaSMark Shellenbaum (void) printf(gettext("%s: can not be "
22140a586ceaSMark Shellenbaum "upgraded; the pool version needs to first "
22150a586ceaSMark Shellenbaum "be upgraded\nto version %d\n\n"),
22160a586ceaSMark Shellenbaum zfs_get_name(zhp), needed_spa_version);
22170a586ceaSMark Shellenbaum cb->cb_numfailed++;
22180a586ceaSMark Shellenbaum return (0);
2219da6c28aaSamw }
2220da6c28aaSamw
2221e7437265Sahrens /* upgrade */
2222e7437265Sahrens if (version < cb->cb_version) {
2223e7437265Sahrens char verstr[16];
2224e45ce728Sahrens (void) snprintf(verstr, sizeof (verstr),
2225e45ce728Sahrens "%llu", cb->cb_version);
2226e7437265Sahrens if (cb->cb_lastfs[0] && !same_pool(zhp, cb->cb_lastfs)) {
2227e7437265Sahrens /*
2228e7437265Sahrens * If they did "zfs upgrade -a", then we could
2229e7437265Sahrens * be doing ioctls to different pools. We need
22304445fffbSMatthew Ahrens * to log this history once to each pool, and bypass
22314445fffbSMatthew Ahrens * the normal history logging that happens in main().
2232e7437265Sahrens */
22334445fffbSMatthew Ahrens (void) zpool_log_history(g_zfs, history_str);
22344445fffbSMatthew Ahrens log_history = B_FALSE;
2235e7437265Sahrens }
2236e7437265Sahrens if (zfs_prop_set(zhp, "version", verstr) == 0)
2237e7437265Sahrens cb->cb_numupgraded++;
2238e45ce728Sahrens else
2239e45ce728Sahrens cb->cb_numfailed++;
2240e7437265Sahrens (void) strcpy(cb->cb_lastfs, zfs_get_name(zhp));
2241e7437265Sahrens } else if (version > cb->cb_version) {
2242e7437265Sahrens /* can't downgrade */
2243e7437265Sahrens (void) printf(gettext("%s: can not be downgraded; "
2244e7437265Sahrens "it is already at version %u\n"),
2245e7437265Sahrens zfs_get_name(zhp), version);
2246e45ce728Sahrens cb->cb_numfailed++;
2247e7437265Sahrens } else {
2248e7437265Sahrens cb->cb_numsamegraded++;
2249e7437265Sahrens }
2250e7437265Sahrens return (0);
2251e7437265Sahrens }
2252e7437265Sahrens
2253e7437265Sahrens /*
2254e7437265Sahrens * zfs upgrade
2255e7437265Sahrens * zfs upgrade -v
2256e7437265Sahrens * zfs upgrade [-r] [-V <version>] <-a | filesystem>
2257e7437265Sahrens */
2258e7437265Sahrens static int
zfs_do_upgrade(int argc,char ** argv)2259e7437265Sahrens zfs_do_upgrade(int argc, char **argv)
2260e7437265Sahrens {
2261e7437265Sahrens boolean_t all = B_FALSE;
2262e7437265Sahrens boolean_t showversions = B_FALSE;
226305c998d6SRichard Lowe int ret = 0;
2264e7437265Sahrens upgrade_cbdata_t cb = { 0 };
2265*ef150c2bSRichard Lowe int c;
2266d5b5bb25SRich Morris int flags = ZFS_ITER_ARGS_CAN_BE_PATHS;
2267e7437265Sahrens
2268e7437265Sahrens /* check options */
2269e7437265Sahrens while ((c = getopt(argc, argv, "rvV:a")) != -1) {
2270e7437265Sahrens switch (c) {
2271e7437265Sahrens case 'r':
2272d5b5bb25SRich Morris flags |= ZFS_ITER_RECURSE;
2273e7437265Sahrens break;
2274e7437265Sahrens case 'v':
2275e7437265Sahrens showversions = B_TRUE;
2276e7437265Sahrens break;
2277e7437265Sahrens case 'V':
2278e7437265Sahrens if (zfs_prop_string_to_index(ZFS_PROP_VERSION,
2279e7437265Sahrens optarg, &cb.cb_version) != 0) {
2280e7437265Sahrens (void) fprintf(stderr,
2281e7437265Sahrens gettext("invalid version %s\n"), optarg);
2282e7437265Sahrens usage(B_FALSE);
2283e7437265Sahrens }
2284e7437265Sahrens break;
2285e7437265Sahrens case 'a':
2286e7437265Sahrens all = B_TRUE;
2287e7437265Sahrens break;
2288e7437265Sahrens case '?':
2289e7437265Sahrens default:
2290e7437265Sahrens (void) fprintf(stderr, gettext("invalid option '%c'\n"),
2291e7437265Sahrens optopt);
2292e7437265Sahrens usage(B_FALSE);
2293e7437265Sahrens }
2294e7437265Sahrens }
2295e7437265Sahrens
2296e7437265Sahrens argc -= optind;
2297e7437265Sahrens argv += optind;
2298e7437265Sahrens
2299d5b5bb25SRich Morris if ((!all && !argc) && ((flags & ZFS_ITER_RECURSE) | cb.cb_version))
2300e7437265Sahrens usage(B_FALSE);
2301d5b5bb25SRich Morris if (showversions && (flags & ZFS_ITER_RECURSE || all ||
2302d5b5bb25SRich Morris cb.cb_version || argc))
2303e7437265Sahrens usage(B_FALSE);
2304e7437265Sahrens if ((all || argc) && (showversions))
2305e7437265Sahrens usage(B_FALSE);
2306e7437265Sahrens if (all && argc)
2307e7437265Sahrens usage(B_FALSE);
2308e7437265Sahrens
2309e7437265Sahrens if (showversions) {
2310e7437265Sahrens /* Show info on available versions. */
2311e7437265Sahrens (void) printf(gettext("The following filesystem versions are "
2312e7437265Sahrens "supported:\n\n"));
2313e7437265Sahrens (void) printf(gettext("VER DESCRIPTION\n"));
2314e7437265Sahrens (void) printf("--- -----------------------------------------"
2315e7437265Sahrens "---------------\n");
2316e7437265Sahrens (void) printf(gettext(" 1 Initial ZFS filesystem version\n"));
2317e7437265Sahrens (void) printf(gettext(" 2 Enhanced directory entries\n"));
231819b94df9SMatthew Ahrens (void) printf(gettext(" 3 Case insensitive and filesystem "
231919b94df9SMatthew Ahrens "user identifier (FUID)\n"));
232014843421SMatthew Ahrens (void) printf(gettext(" 4 userquota, groupquota "
232114843421SMatthew Ahrens "properties\n"));
23220a586ceaSMark Shellenbaum (void) printf(gettext(" 5 System attributes\n"));
2323e7437265Sahrens (void) printf(gettext("\nFor more information on a particular "
23249a8685acSstephanie scheffler "version, including supported releases,\n"));
23259a8685acSstephanie scheffler (void) printf("see the ZFS Administration Guide.\n\n");
2326e7437265Sahrens ret = 0;
2327e7437265Sahrens } else if (argc || all) {
2328e7437265Sahrens /* Upgrade filesystems */
2329e7437265Sahrens if (cb.cb_version == 0)
2330e7437265Sahrens cb.cb_version = ZPL_VERSION;
2331d5b5bb25SRich Morris ret = zfs_for_each(argc, argv, flags, ZFS_TYPE_FILESYSTEM,
2332ae1726b6SChris Gerhard NULL, NULL, 0, upgrade_set_callback, &cb);
2333e7437265Sahrens (void) printf(gettext("%llu filesystems upgraded\n"),
2334e7437265Sahrens cb.cb_numupgraded);
2335e7437265Sahrens if (cb.cb_numsamegraded) {
2336e7437265Sahrens (void) printf(gettext("%llu filesystems already at "
2337e7437265Sahrens "this version\n"),
2338e7437265Sahrens cb.cb_numsamegraded);
2339e7437265Sahrens }
2340e45ce728Sahrens if (cb.cb_numfailed != 0)
2341e7437265Sahrens ret = 1;
2342e7437265Sahrens } else {
2343edc8ef7dSToomas Soome /* List old-version filesystems */
2344e7437265Sahrens boolean_t found;
2345e7437265Sahrens (void) printf(gettext("This system is currently running "
2346e7437265Sahrens "ZFS filesystem version %llu.\n\n"), ZPL_VERSION);
2347e7437265Sahrens
2348d5b5bb25SRich Morris flags |= ZFS_ITER_RECURSE;
2349d5b5bb25SRich Morris ret = zfs_for_each(0, NULL, flags, ZFS_TYPE_FILESYSTEM,
2350ae1726b6SChris Gerhard NULL, NULL, 0, upgrade_list_callback, &cb);
2351e7437265Sahrens
2352e7437265Sahrens found = cb.cb_foundone;
2353e7437265Sahrens cb.cb_foundone = B_FALSE;
2354e7437265Sahrens cb.cb_newer = B_TRUE;
2355e7437265Sahrens
2356d5b5bb25SRich Morris ret = zfs_for_each(0, NULL, flags, ZFS_TYPE_FILESYSTEM,
2357ae1726b6SChris Gerhard NULL, NULL, 0, upgrade_list_callback, &cb);
2358e7437265Sahrens
2359e7437265Sahrens if (!cb.cb_foundone && !found) {
2360e7437265Sahrens (void) printf(gettext("All filesystems are "
2361e7437265Sahrens "formatted with the current version.\n"));
2362e7437265Sahrens }
2363e7437265Sahrens }
2364e7437265Sahrens
2365e7437265Sahrens return (ret);
2366e7437265Sahrens }
2367e7437265Sahrens
236889f5d17bSYuri Pankov /*
236989f5d17bSYuri Pankov * zfs userspace [-Hinp] [-o field[,...]] [-s field [-s field]...]
237089f5d17bSYuri Pankov * [-S field [-S field]...] [-t type[,...]] filesystem | snapshot
237189f5d17bSYuri Pankov * zfs groupspace [-Hinp] [-o field[,...]] [-s field [-s field]...]
237289f5d17bSYuri Pankov * [-S field [-S field]...] [-t type[,...]] filesystem | snapshot
2373f67950b2SNasf-Fan * zfs projectspace [-Hp] [-o field[,...]] [-s field [-s field]...]
2374f67950b2SNasf-Fan * [-S field [-S field]...] filesystem | snapshot
237589f5d17bSYuri Pankov *
237689f5d17bSYuri Pankov * -H Scripted mode; elide headers and separate columns by tabs.
237789f5d17bSYuri Pankov * -i Translate SID to POSIX ID.
237889f5d17bSYuri Pankov * -n Print numeric ID instead of user/group name.
237989f5d17bSYuri Pankov * -o Control which fields to display.
238043d68d68SYuri Pankov * -p Use exact (parsable) numeric output.
238189f5d17bSYuri Pankov * -s Specify sort columns, descending order.
238289f5d17bSYuri Pankov * -S Specify sort columns, ascending order.
238389f5d17bSYuri Pankov * -t Control which object types to display.
238489f5d17bSYuri Pankov *
238589f5d17bSYuri Pankov * Displays space consumed by, and quotas on, each user in the specified
238689f5d17bSYuri Pankov * filesystem or snapshot.
238789f5d17bSYuri Pankov */
23881af68beaSAlexander Stetsenko
238989f5d17bSYuri Pankov /* us_field_types, us_field_hdr and us_field_names should be kept in sync */
239089f5d17bSYuri Pankov enum us_field_types {
239189f5d17bSYuri Pankov USFIELD_TYPE,
239289f5d17bSYuri Pankov USFIELD_NAME,
239389f5d17bSYuri Pankov USFIELD_USED,
2394f67950b2SNasf-Fan USFIELD_QUOTA,
2395f67950b2SNasf-Fan USFIELD_OBJUSED,
2396f67950b2SNasf-Fan USFIELD_OBJQUOTA
239789f5d17bSYuri Pankov };
2398f67950b2SNasf-Fan static char *us_field_hdr[] = { "TYPE", "NAME", "USED", "QUOTA",
2399f67950b2SNasf-Fan "OBJUSED", "OBJQUOTA" };
2400f67950b2SNasf-Fan static char *us_field_names[] = { "type", "name", "used", "quota",
2401f67950b2SNasf-Fan "objused", "objquota" };
240289f5d17bSYuri Pankov #define USFIELD_LAST (sizeof (us_field_names) / sizeof (char *))
24031af68beaSAlexander Stetsenko
240489f5d17bSYuri Pankov #define USTYPE_PSX_GRP (1 << 0)
240589f5d17bSYuri Pankov #define USTYPE_PSX_USR (1 << 1)
240689f5d17bSYuri Pankov #define USTYPE_SMB_GRP (1 << 2)
240789f5d17bSYuri Pankov #define USTYPE_SMB_USR (1 << 3)
2408f67950b2SNasf-Fan #define USTYPE_PROJ (1 << 4)
240989f5d17bSYuri Pankov #define USTYPE_ALL \
2410f67950b2SNasf-Fan (USTYPE_PSX_GRP | USTYPE_PSX_USR | USTYPE_SMB_GRP | USTYPE_SMB_USR | \
2411f67950b2SNasf-Fan USTYPE_PROJ)
24121af68beaSAlexander Stetsenko
241389f5d17bSYuri Pankov static int us_type_bits[] = {
241489f5d17bSYuri Pankov USTYPE_PSX_GRP,
241589f5d17bSYuri Pankov USTYPE_PSX_USR,
241689f5d17bSYuri Pankov USTYPE_SMB_GRP,
241789f5d17bSYuri Pankov USTYPE_SMB_USR,
241889f5d17bSYuri Pankov USTYPE_ALL
241989f5d17bSYuri Pankov };
2420f38cb554SJohn Wren Kennedy static char *us_type_names[] = { "posixgroup", "posixuser", "smbgroup",
242189f5d17bSYuri Pankov "smbuser", "all" };
24221af68beaSAlexander Stetsenko
24231af68beaSAlexander Stetsenko typedef struct us_node {
24241af68beaSAlexander Stetsenko nvlist_t *usn_nvl;
24251af68beaSAlexander Stetsenko uu_avl_node_t usn_avlnode;
24261af68beaSAlexander Stetsenko uu_list_node_t usn_listnode;
24271af68beaSAlexander Stetsenko } us_node_t;
24281af68beaSAlexander Stetsenko
24291af68beaSAlexander Stetsenko typedef struct us_cbdata {
243089f5d17bSYuri Pankov nvlist_t **cb_nvlp;
243189f5d17bSYuri Pankov uu_avl_pool_t *cb_avl_pool;
243289f5d17bSYuri Pankov uu_avl_t *cb_avl;
243389f5d17bSYuri Pankov boolean_t cb_numname;
243489f5d17bSYuri Pankov boolean_t cb_nicenum;
243589f5d17bSYuri Pankov boolean_t cb_sid2posix;
243689f5d17bSYuri Pankov zfs_userquota_prop_t cb_prop;
243789f5d17bSYuri Pankov zfs_sort_column_t *cb_sortcol;
243889f5d17bSYuri Pankov size_t cb_width[USFIELD_LAST];
24391af68beaSAlexander Stetsenko } us_cbdata_t;
24401af68beaSAlexander Stetsenko
244189f5d17bSYuri Pankov static boolean_t us_populated = B_FALSE;
244289f5d17bSYuri Pankov
24431af68beaSAlexander Stetsenko typedef struct {
24441af68beaSAlexander Stetsenko zfs_sort_column_t *si_sortcol;
244589f5d17bSYuri Pankov boolean_t si_numname;
24461af68beaSAlexander Stetsenko } us_sort_info_t;
24471af68beaSAlexander Stetsenko
244889f5d17bSYuri Pankov static int
us_field_index(char * field)244989f5d17bSYuri Pankov us_field_index(char *field)
245089f5d17bSYuri Pankov {
245189f5d17bSYuri Pankov int i;
245289f5d17bSYuri Pankov
245389f5d17bSYuri Pankov for (i = 0; i < USFIELD_LAST; i++) {
245489f5d17bSYuri Pankov if (strcmp(field, us_field_names[i]) == 0)
245589f5d17bSYuri Pankov return (i);
245689f5d17bSYuri Pankov }
245789f5d17bSYuri Pankov
245889f5d17bSYuri Pankov return (-1);
245989f5d17bSYuri Pankov }
246089f5d17bSYuri Pankov
24611af68beaSAlexander Stetsenko static int
us_compare(const void * larg,const void * rarg,void * unused)24621af68beaSAlexander Stetsenko us_compare(const void *larg, const void *rarg, void *unused)
24631af68beaSAlexander Stetsenko {
24641af68beaSAlexander Stetsenko const us_node_t *l = larg;
24651af68beaSAlexander Stetsenko const us_node_t *r = rarg;
24661af68beaSAlexander Stetsenko us_sort_info_t *si = (us_sort_info_t *)unused;
24671af68beaSAlexander Stetsenko zfs_sort_column_t *sortcol = si->si_sortcol;
246889f5d17bSYuri Pankov boolean_t numname = si->si_numname;
24691af68beaSAlexander Stetsenko nvlist_t *lnvl = l->usn_nvl;
24701af68beaSAlexander Stetsenko nvlist_t *rnvl = r->usn_nvl;
247189f5d17bSYuri Pankov int rc = 0;
247289f5d17bSYuri Pankov boolean_t lvb, rvb;
24731af68beaSAlexander Stetsenko
24741af68beaSAlexander Stetsenko for (; sortcol != NULL; sortcol = sortcol->sc_next) {
24751af68beaSAlexander Stetsenko char *lvstr = "";
24761af68beaSAlexander Stetsenko char *rvstr = "";
24771af68beaSAlexander Stetsenko uint32_t lv32 = 0;
24781af68beaSAlexander Stetsenko uint32_t rv32 = 0;
24791af68beaSAlexander Stetsenko uint64_t lv64 = 0;
24801af68beaSAlexander Stetsenko uint64_t rv64 = 0;
24811af68beaSAlexander Stetsenko zfs_prop_t prop = sortcol->sc_prop;
24821af68beaSAlexander Stetsenko const char *propname = NULL;
24831af68beaSAlexander Stetsenko boolean_t reverse = sortcol->sc_reverse;
24841af68beaSAlexander Stetsenko
24851af68beaSAlexander Stetsenko switch (prop) {
24861af68beaSAlexander Stetsenko case ZFS_PROP_TYPE:
24871af68beaSAlexander Stetsenko propname = "type";
24881af68beaSAlexander Stetsenko (void) nvlist_lookup_uint32(lnvl, propname, &lv32);
24891af68beaSAlexander Stetsenko (void) nvlist_lookup_uint32(rnvl, propname, &rv32);
24901af68beaSAlexander Stetsenko if (rv32 != lv32)
249189f5d17bSYuri Pankov rc = (rv32 < lv32) ? 1 : -1;
24921af68beaSAlexander Stetsenko break;
24931af68beaSAlexander Stetsenko case ZFS_PROP_NAME:
24941af68beaSAlexander Stetsenko propname = "name";
249589f5d17bSYuri Pankov if (numname) {
249689f5d17bSYuri Pankov (void) nvlist_lookup_uint64(lnvl, propname,
249789f5d17bSYuri Pankov &lv64);
249889f5d17bSYuri Pankov (void) nvlist_lookup_uint64(rnvl, propname,
249989f5d17bSYuri Pankov &rv64);
250089f5d17bSYuri Pankov if (rv64 != lv64)
250189f5d17bSYuri Pankov rc = (rv64 < lv64) ? 1 : -1;
25021af68beaSAlexander Stetsenko } else {
25031af68beaSAlexander Stetsenko (void) nvlist_lookup_string(lnvl, propname,
25041af68beaSAlexander Stetsenko &lvstr);
25051af68beaSAlexander Stetsenko (void) nvlist_lookup_string(rnvl, propname,
25061af68beaSAlexander Stetsenko &rvstr);
25071af68beaSAlexander Stetsenko rc = strcmp(lvstr, rvstr);
25081af68beaSAlexander Stetsenko }
25091af68beaSAlexander Stetsenko break;
25101af68beaSAlexander Stetsenko case ZFS_PROP_USED:
25111af68beaSAlexander Stetsenko case ZFS_PROP_QUOTA:
251289f5d17bSYuri Pankov if (!us_populated)
251389f5d17bSYuri Pankov break;
251489f5d17bSYuri Pankov if (prop == ZFS_PROP_USED)
25151af68beaSAlexander Stetsenko propname = "used";
25161af68beaSAlexander Stetsenko else
25171af68beaSAlexander Stetsenko propname = "quota";
25181af68beaSAlexander Stetsenko (void) nvlist_lookup_uint64(lnvl, propname, &lv64);
25191af68beaSAlexander Stetsenko (void) nvlist_lookup_uint64(rnvl, propname, &rv64);
25201af68beaSAlexander Stetsenko if (rv64 != lv64)
252189f5d17bSYuri Pankov rc = (rv64 < lv64) ? 1 : -1;
252289f5d17bSYuri Pankov break;
2523c16bcc45SIgor Kozhukhov
2524c16bcc45SIgor Kozhukhov default:
2525c16bcc45SIgor Kozhukhov break;
25261af68beaSAlexander Stetsenko }
25271af68beaSAlexander Stetsenko
252889f5d17bSYuri Pankov if (rc != 0) {
25291af68beaSAlexander Stetsenko if (rc < 0)
25301af68beaSAlexander Stetsenko return (reverse ? 1 : -1);
25311af68beaSAlexander Stetsenko else
25321af68beaSAlexander Stetsenko return (reverse ? -1 : 1);
253389f5d17bSYuri Pankov }
25341af68beaSAlexander Stetsenko }
25351af68beaSAlexander Stetsenko
253689f5d17bSYuri Pankov /*
253789f5d17bSYuri Pankov * If entries still seem to be the same, check if they are of the same
253889f5d17bSYuri Pankov * type (smbentity is added only if we are doing SID to POSIX ID
253989f5d17bSYuri Pankov * translation where we can have duplicate type/name combinations).
254089f5d17bSYuri Pankov */
254189f5d17bSYuri Pankov if (nvlist_lookup_boolean_value(lnvl, "smbentity", &lvb) == 0 &&
254289f5d17bSYuri Pankov nvlist_lookup_boolean_value(rnvl, "smbentity", &rvb) == 0 &&
254389f5d17bSYuri Pankov lvb != rvb)
254489f5d17bSYuri Pankov return (lvb < rvb ? -1 : 1);
254589f5d17bSYuri Pankov
254689f5d17bSYuri Pankov return (0);
25471af68beaSAlexander Stetsenko }
25481af68beaSAlexander Stetsenko
2549f67950b2SNasf-Fan static boolean_t
zfs_prop_is_user(unsigned p)2550f67950b2SNasf-Fan zfs_prop_is_user(unsigned p)
2551f67950b2SNasf-Fan {
2552f67950b2SNasf-Fan return (p == ZFS_PROP_USERUSED || p == ZFS_PROP_USERQUOTA ||
2553f67950b2SNasf-Fan p == ZFS_PROP_USEROBJUSED || p == ZFS_PROP_USEROBJQUOTA);
2554f67950b2SNasf-Fan }
2555f67950b2SNasf-Fan
2556f67950b2SNasf-Fan static boolean_t
zfs_prop_is_group(unsigned p)2557f67950b2SNasf-Fan zfs_prop_is_group(unsigned p)
2558f67950b2SNasf-Fan {
2559f67950b2SNasf-Fan return (p == ZFS_PROP_GROUPUSED || p == ZFS_PROP_GROUPQUOTA ||
2560f67950b2SNasf-Fan p == ZFS_PROP_GROUPOBJUSED || p == ZFS_PROP_GROUPOBJQUOTA);
2561f67950b2SNasf-Fan }
2562f67950b2SNasf-Fan
2563f67950b2SNasf-Fan static boolean_t
zfs_prop_is_project(unsigned p)2564f67950b2SNasf-Fan zfs_prop_is_project(unsigned p)
2565f67950b2SNasf-Fan {
2566f67950b2SNasf-Fan return (p == ZFS_PROP_PROJECTUSED || p == ZFS_PROP_PROJECTQUOTA ||
2567f67950b2SNasf-Fan p == ZFS_PROP_PROJECTOBJUSED || p == ZFS_PROP_PROJECTOBJQUOTA);
2568f67950b2SNasf-Fan }
2569f67950b2SNasf-Fan
25701af68beaSAlexander Stetsenko static inline const char *
us_type2str(unsigned field_type)25711af68beaSAlexander Stetsenko us_type2str(unsigned field_type)
25721af68beaSAlexander Stetsenko {
25731af68beaSAlexander Stetsenko switch (field_type) {
25741af68beaSAlexander Stetsenko case USTYPE_PSX_USR:
25751af68beaSAlexander Stetsenko return ("POSIX User");
25761af68beaSAlexander Stetsenko case USTYPE_PSX_GRP:
25771af68beaSAlexander Stetsenko return ("POSIX Group");
25781af68beaSAlexander Stetsenko case USTYPE_SMB_USR:
25791af68beaSAlexander Stetsenko return ("SMB User");
25801af68beaSAlexander Stetsenko case USTYPE_SMB_GRP:
25811af68beaSAlexander Stetsenko return ("SMB Group");
2582f67950b2SNasf-Fan case USTYPE_PROJ:
2583f67950b2SNasf-Fan return ("Project");
25841af68beaSAlexander Stetsenko default:
25851af68beaSAlexander Stetsenko return ("Undefined");
25861af68beaSAlexander Stetsenko }
25871af68beaSAlexander Stetsenko }
25881af68beaSAlexander Stetsenko
25890aea4b19SMatthew Ahrens static int
userspace_cb(void * arg,const char * domain,uid_t rid,uint64_t space)259014843421SMatthew Ahrens userspace_cb(void *arg, const char *domain, uid_t rid, uint64_t space)
259114843421SMatthew Ahrens {
25921af68beaSAlexander Stetsenko us_cbdata_t *cb = (us_cbdata_t *)arg;
25931af68beaSAlexander Stetsenko zfs_userquota_prop_t prop = cb->cb_prop;
25940aea4b19SMatthew Ahrens char *name = NULL;
25951af68beaSAlexander Stetsenko char *propname;
259614843421SMatthew Ahrens char sizebuf[32];
25971af68beaSAlexander Stetsenko us_node_t *node;
25981af68beaSAlexander Stetsenko uu_avl_pool_t *avl_pool = cb->cb_avl_pool;
25991af68beaSAlexander Stetsenko uu_avl_t *avl = cb->cb_avl;
26001af68beaSAlexander Stetsenko uu_avl_index_t idx;
26011af68beaSAlexander Stetsenko nvlist_t *props;
26021af68beaSAlexander Stetsenko us_node_t *n;
26031af68beaSAlexander Stetsenko zfs_sort_column_t *sortcol = cb->cb_sortcol;
2604c16bcc45SIgor Kozhukhov unsigned type = 0;
26051af68beaSAlexander Stetsenko const char *typestr;
26061af68beaSAlexander Stetsenko size_t namelen;
26071af68beaSAlexander Stetsenko size_t typelen;
26081af68beaSAlexander Stetsenko size_t sizelen;
260989f5d17bSYuri Pankov int typeidx, nameidx, sizeidx;
26101af68beaSAlexander Stetsenko us_sort_info_t sortinfo = { sortcol, cb->cb_numname };
261189f5d17bSYuri Pankov boolean_t smbentity = B_FALSE;
261214843421SMatthew Ahrens
261389f5d17bSYuri Pankov if (nvlist_alloc(&props, NV_UNIQUE_NAME, 0) != 0)
261489f5d17bSYuri Pankov nomem();
261589f5d17bSYuri Pankov node = safe_malloc(sizeof (us_node_t));
261689f5d17bSYuri Pankov uu_avl_node_init(node, &node->usn_avlnode, avl_pool);
261789f5d17bSYuri Pankov node->usn_nvl = props;
261889f5d17bSYuri Pankov
261989f5d17bSYuri Pankov if (domain != NULL && domain[0] != '\0') {
262089f5d17bSYuri Pankov /* SMB */
26219adfa60dSMatthew Ahrens char sid[MAXNAMELEN + 32];
26221af68beaSAlexander Stetsenko uid_t id;
262389f5d17bSYuri Pankov int err;
26241ed6b69aSGordon Ross int flag = IDMAP_REQ_FLG_USE_CACHE;
26251af68beaSAlexander Stetsenko
262689f5d17bSYuri Pankov smbentity = B_TRUE;
262789f5d17bSYuri Pankov
26281af68beaSAlexander Stetsenko (void) snprintf(sid, sizeof (sid), "%s-%u", domain, rid);
262989f5d17bSYuri Pankov
26301af68beaSAlexander Stetsenko if (prop == ZFS_PROP_GROUPUSED || prop == ZFS_PROP_GROUPQUOTA) {
26311af68beaSAlexander Stetsenko type = USTYPE_SMB_GRP;
26321af68beaSAlexander Stetsenko err = sid_to_id(sid, B_FALSE, &id);
26331af68beaSAlexander Stetsenko } else {
26341af68beaSAlexander Stetsenko type = USTYPE_SMB_USR;
26351af68beaSAlexander Stetsenko err = sid_to_id(sid, B_TRUE, &id);
26361af68beaSAlexander Stetsenko }
26371af68beaSAlexander Stetsenko
26381af68beaSAlexander Stetsenko if (err == 0) {
26391af68beaSAlexander Stetsenko rid = id;
264089f5d17bSYuri Pankov if (!cb->cb_sid2posix) {
26411ed6b69aSGordon Ross if (type == USTYPE_SMB_USR) {
26421ed6b69aSGordon Ross (void) idmap_getwinnamebyuid(rid, flag,
26431ed6b69aSGordon Ross &name, NULL);
26441ed6b69aSGordon Ross } else {
26451ed6b69aSGordon Ross (void) idmap_getwinnamebygid(rid, flag,
26461ed6b69aSGordon Ross &name, NULL);
26471ed6b69aSGordon Ross }
264889f5d17bSYuri Pankov if (name == NULL)
264989f5d17bSYuri Pankov name = sid;
26501af68beaSAlexander Stetsenko }
26511af68beaSAlexander Stetsenko }
265214843421SMatthew Ahrens }
265314843421SMatthew Ahrens
265489f5d17bSYuri Pankov if (cb->cb_sid2posix || domain == NULL || domain[0] == '\0') {
265589f5d17bSYuri Pankov /* POSIX or -i */
2656f67950b2SNasf-Fan if (zfs_prop_is_group(prop)) {
265789f5d17bSYuri Pankov type = USTYPE_PSX_GRP;
265889f5d17bSYuri Pankov if (!cb->cb_numname) {
265989f5d17bSYuri Pankov struct group *g;
26601af68beaSAlexander Stetsenko
266189f5d17bSYuri Pankov if ((g = getgrgid(rid)) != NULL)
266289f5d17bSYuri Pankov name = g->gr_name;
266389f5d17bSYuri Pankov }
2664f67950b2SNasf-Fan } else if (zfs_prop_is_user(prop)) {
266589f5d17bSYuri Pankov type = USTYPE_PSX_USR;
266689f5d17bSYuri Pankov if (!cb->cb_numname) {
266789f5d17bSYuri Pankov struct passwd *p;
26681af68beaSAlexander Stetsenko
266989f5d17bSYuri Pankov if ((p = getpwuid(rid)) != NULL)
267089f5d17bSYuri Pankov name = p->pw_name;
267189f5d17bSYuri Pankov }
2672f67950b2SNasf-Fan } else {
2673f67950b2SNasf-Fan type = USTYPE_PROJ;
267489f5d17bSYuri Pankov }
26751af68beaSAlexander Stetsenko }
26761af68beaSAlexander Stetsenko
267789f5d17bSYuri Pankov /*
267889f5d17bSYuri Pankov * Make sure that the type/name combination is unique when doing
267989f5d17bSYuri Pankov * SID to POSIX ID translation (hence changing the type from SMB to
268089f5d17bSYuri Pankov * POSIX).
268189f5d17bSYuri Pankov */
268289f5d17bSYuri Pankov if (cb->cb_sid2posix &&
268389f5d17bSYuri Pankov nvlist_add_boolean_value(props, "smbentity", smbentity) != 0)
268489f5d17bSYuri Pankov nomem();
268589f5d17bSYuri Pankov
268689f5d17bSYuri Pankov /* Calculate/update width of TYPE field */
268789f5d17bSYuri Pankov typestr = us_type2str(type);
268889f5d17bSYuri Pankov typelen = strlen(gettext(typestr));
268989f5d17bSYuri Pankov typeidx = us_field_index("type");
269089f5d17bSYuri Pankov if (typelen > cb->cb_width[typeidx])
269189f5d17bSYuri Pankov cb->cb_width[typeidx] = typelen;
26921af68beaSAlexander Stetsenko if (nvlist_add_uint32(props, "type", type) != 0)
26931af68beaSAlexander Stetsenko nomem();
26941af68beaSAlexander Stetsenko
269589f5d17bSYuri Pankov /* Calculate/update width of NAME field */
269689f5d17bSYuri Pankov if ((cb->cb_numname && cb->cb_sid2posix) || name == NULL) {
269789f5d17bSYuri Pankov if (nvlist_add_uint64(props, "name", rid) != 0)
26981af68beaSAlexander Stetsenko nomem();
269989f5d17bSYuri Pankov namelen = snprintf(NULL, 0, "%u", rid);
27001af68beaSAlexander Stetsenko } else {
27011af68beaSAlexander Stetsenko if (nvlist_add_string(props, "name", name) != 0)
27021af68beaSAlexander Stetsenko nomem();
27031af68beaSAlexander Stetsenko namelen = strlen(name);
27041af68beaSAlexander Stetsenko }
270589f5d17bSYuri Pankov nameidx = us_field_index("name");
270689f5d17bSYuri Pankov if (namelen > cb->cb_width[nameidx])
270789f5d17bSYuri Pankov cb->cb_width[nameidx] = namelen;
27081af68beaSAlexander Stetsenko
270989f5d17bSYuri Pankov /*
271089f5d17bSYuri Pankov * Check if this type/name combination is in the list and update it;
271189f5d17bSYuri Pankov * otherwise add new node to the list.
271289f5d17bSYuri Pankov */
271389f5d17bSYuri Pankov if ((n = uu_avl_find(avl, node, &sortinfo, &idx)) == NULL) {
27141af68beaSAlexander Stetsenko uu_avl_insert(avl, node, idx);
271589f5d17bSYuri Pankov } else {
27161af68beaSAlexander Stetsenko nvlist_free(props);
27171af68beaSAlexander Stetsenko free(node);
27181af68beaSAlexander Stetsenko node = n;
27191af68beaSAlexander Stetsenko props = node->usn_nvl;
272014843421SMatthew Ahrens }
272114843421SMatthew Ahrens
272289f5d17bSYuri Pankov /* Calculate/update width of USED/QUOTA fields */
2723f67950b2SNasf-Fan if (cb->cb_nicenum) {
2724f67950b2SNasf-Fan if (prop == ZFS_PROP_USERUSED || prop == ZFS_PROP_GROUPUSED ||
2725f67950b2SNasf-Fan prop == ZFS_PROP_USERQUOTA || prop == ZFS_PROP_GROUPQUOTA ||
2726f67950b2SNasf-Fan prop == ZFS_PROP_PROJECTUSED ||
2727f67950b2SNasf-Fan prop == ZFS_PROP_PROJECTQUOTA) {
27286520eed5SToomas Soome zfs_nicebytes(space, sizebuf, sizeof (sizebuf));
2729f67950b2SNasf-Fan } else {
2730f67950b2SNasf-Fan zfs_nicenum(space, sizebuf, sizeof (sizebuf));
2731f67950b2SNasf-Fan }
2732f67950b2SNasf-Fan } else {
273389f5d17bSYuri Pankov (void) snprintf(sizebuf, sizeof (sizebuf), "%llu", space);
2734f67950b2SNasf-Fan }
273589f5d17bSYuri Pankov sizelen = strlen(sizebuf);
2736f67950b2SNasf-Fan if (prop == ZFS_PROP_USERUSED || prop == ZFS_PROP_GROUPUSED ||
2737f67950b2SNasf-Fan prop == ZFS_PROP_PROJECTUSED) {
273889f5d17bSYuri Pankov propname = "used";
273989f5d17bSYuri Pankov if (!nvlist_exists(props, "quota"))
274089f5d17bSYuri Pankov (void) nvlist_add_uint64(props, "quota", 0);
2741f67950b2SNasf-Fan } else if (prop == ZFS_PROP_USERQUOTA || prop == ZFS_PROP_GROUPQUOTA ||
2742f67950b2SNasf-Fan prop == ZFS_PROP_PROJECTQUOTA) {
274389f5d17bSYuri Pankov propname = "quota";
274489f5d17bSYuri Pankov if (!nvlist_exists(props, "used"))
274589f5d17bSYuri Pankov (void) nvlist_add_uint64(props, "used", 0);
2746f67950b2SNasf-Fan } else if (prop == ZFS_PROP_USEROBJUSED ||
2747f67950b2SNasf-Fan prop == ZFS_PROP_GROUPOBJUSED || prop == ZFS_PROP_PROJECTOBJUSED) {
2748f67950b2SNasf-Fan propname = "objused";
2749f67950b2SNasf-Fan if (!nvlist_exists(props, "objquota"))
2750f67950b2SNasf-Fan (void) nvlist_add_uint64(props, "objquota", 0);
2751f67950b2SNasf-Fan } else if (prop == ZFS_PROP_USEROBJQUOTA ||
2752f67950b2SNasf-Fan prop == ZFS_PROP_GROUPOBJQUOTA ||
2753f67950b2SNasf-Fan prop == ZFS_PROP_PROJECTOBJQUOTA) {
2754f67950b2SNasf-Fan propname = "objquota";
2755f67950b2SNasf-Fan if (!nvlist_exists(props, "objused"))
2756f67950b2SNasf-Fan (void) nvlist_add_uint64(props, "objused", 0);
2757f67950b2SNasf-Fan } else {
2758f67950b2SNasf-Fan return (-1);
275989f5d17bSYuri Pankov }
276089f5d17bSYuri Pankov sizeidx = us_field_index(propname);
276189f5d17bSYuri Pankov if (sizelen > cb->cb_width[sizeidx])
276289f5d17bSYuri Pankov cb->cb_width[sizeidx] = sizelen;
276389f5d17bSYuri Pankov
27641af68beaSAlexander Stetsenko if (nvlist_add_uint64(props, propname, space) != 0)
27651af68beaSAlexander Stetsenko nomem();
27661af68beaSAlexander Stetsenko
27671af68beaSAlexander Stetsenko return (0);
27681af68beaSAlexander Stetsenko }
27691af68beaSAlexander Stetsenko
27701af68beaSAlexander Stetsenko static void
print_us_node(boolean_t scripted,boolean_t parsable,int * fields,int types,size_t * width,us_node_t * node)277189f5d17bSYuri Pankov print_us_node(boolean_t scripted, boolean_t parsable, int *fields, int types,
277289f5d17bSYuri Pankov size_t *width, us_node_t *node)
27731af68beaSAlexander Stetsenko {
27741af68beaSAlexander Stetsenko nvlist_t *nvl = node->usn_nvl;
27759adfa60dSMatthew Ahrens char valstr[MAXNAMELEN];
27761af68beaSAlexander Stetsenko boolean_t first = B_TRUE;
277789f5d17bSYuri Pankov int cfield = 0;
277889f5d17bSYuri Pankov int field;
277989f5d17bSYuri Pankov uint32_t ustype;
278089f5d17bSYuri Pankov
278189f5d17bSYuri Pankov /* Check type */
278289f5d17bSYuri Pankov (void) nvlist_lookup_uint32(nvl, "type", &ustype);
278389f5d17bSYuri Pankov if (!(ustype & types))
278489f5d17bSYuri Pankov return;
278589f5d17bSYuri Pankov
278689f5d17bSYuri Pankov while ((field = fields[cfield]) != USFIELD_LAST) {
278789f5d17bSYuri Pankov nvpair_t *nvp = NULL;
278889f5d17bSYuri Pankov data_type_t type;
278989f5d17bSYuri Pankov uint32_t val32;
279089f5d17bSYuri Pankov uint64_t val64;
2791f67950b2SNasf-Fan char *strval = "-";
279289f5d17bSYuri Pankov
279389f5d17bSYuri Pankov while ((nvp = nvlist_next_nvpair(nvl, nvp)) != NULL) {
279489f5d17bSYuri Pankov if (strcmp(nvpair_name(nvp),
279589f5d17bSYuri Pankov us_field_names[field]) == 0)
27961af68beaSAlexander Stetsenko break;
27971af68beaSAlexander Stetsenko }
27981af68beaSAlexander Stetsenko
2799f67950b2SNasf-Fan type = nvp == NULL ? DATA_TYPE_UNKNOWN : nvpair_type(nvp);
28001af68beaSAlexander Stetsenko switch (type) {
28011af68beaSAlexander Stetsenko case DATA_TYPE_UINT32:
28021af68beaSAlexander Stetsenko (void) nvpair_value_uint32(nvp, &val32);
28031af68beaSAlexander Stetsenko break;
28041af68beaSAlexander Stetsenko case DATA_TYPE_UINT64:
28051af68beaSAlexander Stetsenko (void) nvpair_value_uint64(nvp, &val64);
28061af68beaSAlexander Stetsenko break;
28071af68beaSAlexander Stetsenko case DATA_TYPE_STRING:
28081af68beaSAlexander Stetsenko (void) nvpair_value_string(nvp, &strval);
28091af68beaSAlexander Stetsenko break;
2810f67950b2SNasf-Fan case DATA_TYPE_UNKNOWN:
2811f67950b2SNasf-Fan break;
28121af68beaSAlexander Stetsenko default:
281389f5d17bSYuri Pankov (void) fprintf(stderr, "invalid data type\n");
28141af68beaSAlexander Stetsenko }
28151af68beaSAlexander Stetsenko
28161af68beaSAlexander Stetsenko switch (field) {
28171af68beaSAlexander Stetsenko case USFIELD_TYPE:
2818f67950b2SNasf-Fan if (type == DATA_TYPE_UINT32)
2819f67950b2SNasf-Fan strval = (char *)us_type2str(val32);
28201af68beaSAlexander Stetsenko break;
28211af68beaSAlexander Stetsenko case USFIELD_NAME:
28221af68beaSAlexander Stetsenko if (type == DATA_TYPE_UINT64) {
28231af68beaSAlexander Stetsenko (void) sprintf(valstr, "%llu", val64);
28241af68beaSAlexander Stetsenko strval = valstr;
28251af68beaSAlexander Stetsenko }
28261af68beaSAlexander Stetsenko break;
28271af68beaSAlexander Stetsenko case USFIELD_USED:
28281af68beaSAlexander Stetsenko case USFIELD_QUOTA:
28296520eed5SToomas Soome if (type == DATA_TYPE_UINT64) {
28306520eed5SToomas Soome if (parsable) {
28316520eed5SToomas Soome (void) sprintf(valstr, "%llu", val64);
28326520eed5SToomas Soome strval = valstr;
28336520eed5SToomas Soome } else if (field == USFIELD_QUOTA &&
28346520eed5SToomas Soome val64 == 0) {
28356520eed5SToomas Soome strval = "none";
28366520eed5SToomas Soome } else {
28376520eed5SToomas Soome zfs_nicebytes(val64, valstr,
28386520eed5SToomas Soome sizeof (valstr));
28396520eed5SToomas Soome strval = valstr;
28406520eed5SToomas Soome }
28416520eed5SToomas Soome }
28426520eed5SToomas Soome break;
2843f67950b2SNasf-Fan case USFIELD_OBJUSED:
2844f67950b2SNasf-Fan case USFIELD_OBJQUOTA:
28451af68beaSAlexander Stetsenko if (type == DATA_TYPE_UINT64) {
284689f5d17bSYuri Pankov if (parsable) {
28471af68beaSAlexander Stetsenko (void) sprintf(valstr, "%llu", val64);
28486520eed5SToomas Soome strval = valstr;
28496520eed5SToomas Soome } else if (field == USFIELD_OBJQUOTA &&
28506520eed5SToomas Soome val64 == 0) {
28516520eed5SToomas Soome strval = "none";
285289f5d17bSYuri Pankov } else {
28531af68beaSAlexander Stetsenko zfs_nicenum(val64, valstr,
28541af68beaSAlexander Stetsenko sizeof (valstr));
285589f5d17bSYuri Pankov strval = valstr;
28566520eed5SToomas Soome }
28571af68beaSAlexander Stetsenko }
28581af68beaSAlexander Stetsenko break;
28591af68beaSAlexander Stetsenko }
28601af68beaSAlexander Stetsenko
286189f5d17bSYuri Pankov if (!first) {
286289f5d17bSYuri Pankov if (scripted)
286389f5d17bSYuri Pankov (void) printf("\t");
28641af68beaSAlexander Stetsenko else
286589f5d17bSYuri Pankov (void) printf(" ");
28661af68beaSAlexander Stetsenko }
286789f5d17bSYuri Pankov if (scripted)
286889f5d17bSYuri Pankov (void) printf("%s", strval);
286989f5d17bSYuri Pankov else if (field == USFIELD_TYPE || field == USFIELD_NAME)
287089f5d17bSYuri Pankov (void) printf("%-*s", width[field], strval);
287189f5d17bSYuri Pankov else
287289f5d17bSYuri Pankov (void) printf("%*s", width[field], strval);
28731af68beaSAlexander Stetsenko
28741af68beaSAlexander Stetsenko first = B_FALSE;
287589f5d17bSYuri Pankov cfield++;
28761af68beaSAlexander Stetsenko }
28771af68beaSAlexander Stetsenko
28781af68beaSAlexander Stetsenko (void) printf("\n");
28791af68beaSAlexander Stetsenko }
28801af68beaSAlexander Stetsenko
28811af68beaSAlexander Stetsenko static void
print_us(boolean_t scripted,boolean_t parsable,int * fields,int types,size_t * width,boolean_t rmnode,uu_avl_t * avl)288289f5d17bSYuri Pankov print_us(boolean_t scripted, boolean_t parsable, int *fields, int types,
288389f5d17bSYuri Pankov size_t *width, boolean_t rmnode, uu_avl_t *avl)
28841af68beaSAlexander Stetsenko {
28851af68beaSAlexander Stetsenko us_node_t *node;
28861af68beaSAlexander Stetsenko const char *col;
288789f5d17bSYuri Pankov int cfield = 0;
288889f5d17bSYuri Pankov int field;
28891af68beaSAlexander Stetsenko
28901af68beaSAlexander Stetsenko if (!scripted) {
28911af68beaSAlexander Stetsenko boolean_t first = B_TRUE;
289289f5d17bSYuri Pankov
289389f5d17bSYuri Pankov while ((field = fields[cfield]) != USFIELD_LAST) {
289489f5d17bSYuri Pankov col = gettext(us_field_hdr[field]);
289589f5d17bSYuri Pankov if (field == USFIELD_TYPE || field == USFIELD_NAME) {
289689f5d17bSYuri Pankov (void) printf(first ? "%-*s" : " %-*s",
289789f5d17bSYuri Pankov width[field], col);
289889f5d17bSYuri Pankov } else {
289989f5d17bSYuri Pankov (void) printf(first ? "%*s" : " %*s",
290089f5d17bSYuri Pankov width[field], col);
290189f5d17bSYuri Pankov }
29021af68beaSAlexander Stetsenko first = B_FALSE;
290389f5d17bSYuri Pankov cfield++;
29041af68beaSAlexander Stetsenko }
29051af68beaSAlexander Stetsenko (void) printf("\n");
29061af68beaSAlexander Stetsenko }
29071af68beaSAlexander Stetsenko
290889f5d17bSYuri Pankov for (node = uu_avl_first(avl); node; node = uu_avl_next(avl, node)) {
290989f5d17bSYuri Pankov print_us_node(scripted, parsable, fields, types, width, node);
29101af68beaSAlexander Stetsenko if (rmnode)
29111af68beaSAlexander Stetsenko nvlist_free(node->usn_nvl);
29121af68beaSAlexander Stetsenko }
29131af68beaSAlexander Stetsenko }
29141af68beaSAlexander Stetsenko
291514843421SMatthew Ahrens static int
zfs_do_userspace(int argc,char ** argv)291614843421SMatthew Ahrens zfs_do_userspace(int argc, char **argv)
291714843421SMatthew Ahrens {
291814843421SMatthew Ahrens zfs_handle_t *zhp;
291914843421SMatthew Ahrens zfs_userquota_prop_t p;
29201af68beaSAlexander Stetsenko uu_avl_pool_t *avl_pool;
29211af68beaSAlexander Stetsenko uu_avl_t *avl_tree;
29221af68beaSAlexander Stetsenko uu_avl_walk_t *walk;
292389f5d17bSYuri Pankov char *delim;
2924f67950b2SNasf-Fan char deffields[] = "type,name,used,quota,objused,objquota";
292589f5d17bSYuri Pankov char *ofield = NULL;
292689f5d17bSYuri Pankov char *tfield = NULL;
292789f5d17bSYuri Pankov int cfield = 0;
292889f5d17bSYuri Pankov int fields[256];
292989f5d17bSYuri Pankov int i;
29301af68beaSAlexander Stetsenko boolean_t scripted = B_FALSE;
29311af68beaSAlexander Stetsenko boolean_t prtnum = B_FALSE;
293289f5d17bSYuri Pankov boolean_t parsable = B_FALSE;
29331af68beaSAlexander Stetsenko boolean_t sid2posix = B_FALSE;
293470f56fa6SYuri Pankov int ret = 0;
29351af68beaSAlexander Stetsenko int c;
29361af68beaSAlexander Stetsenko zfs_sort_column_t *sortcol = NULL;
293789f5d17bSYuri Pankov int types = USTYPE_PSX_USR | USTYPE_SMB_USR;
29381af68beaSAlexander Stetsenko us_cbdata_t cb;
29391af68beaSAlexander Stetsenko us_node_t *node;
294089f5d17bSYuri Pankov us_node_t *rmnode;
294189f5d17bSYuri Pankov uu_list_pool_t *listpool;
294289f5d17bSYuri Pankov uu_list_t *list;
294389f5d17bSYuri Pankov uu_avl_index_t idx = 0;
294489f5d17bSYuri Pankov uu_list_index_t idx2 = 0;
294514843421SMatthew Ahrens
29461af68beaSAlexander Stetsenko if (argc < 2)
29471af68beaSAlexander Stetsenko usage(B_FALSE);
29481af68beaSAlexander Stetsenko
2949f67950b2SNasf-Fan if (strcmp(argv[0], "groupspace") == 0) {
295089f5d17bSYuri Pankov /* Toggle default group types */
29511af68beaSAlexander Stetsenko types = USTYPE_PSX_GRP | USTYPE_SMB_GRP;
2952f67950b2SNasf-Fan } else if (strcmp(argv[0], "projectspace") == 0) {
2953f67950b2SNasf-Fan types = USTYPE_PROJ;
2954f67950b2SNasf-Fan prtnum = B_TRUE;
2955f67950b2SNasf-Fan }
29561af68beaSAlexander Stetsenko
29571af68beaSAlexander Stetsenko while ((c = getopt(argc, argv, "nHpo:s:S:t:i")) != -1) {
29581af68beaSAlexander Stetsenko switch (c) {
29591af68beaSAlexander Stetsenko case 'n':
2960f67950b2SNasf-Fan if (types == USTYPE_PROJ) {
2961f67950b2SNasf-Fan (void) fprintf(stderr,
2962f67950b2SNasf-Fan gettext("invalid option 'n'\n"));
2963f67950b2SNasf-Fan usage(B_FALSE);
2964f67950b2SNasf-Fan }
29651af68beaSAlexander Stetsenko prtnum = B_TRUE;
29661af68beaSAlexander Stetsenko break;
29671af68beaSAlexander Stetsenko case 'H':
29681af68beaSAlexander Stetsenko scripted = B_TRUE;
29691af68beaSAlexander Stetsenko break;
29701af68beaSAlexander Stetsenko case 'p':
297189f5d17bSYuri Pankov parsable = B_TRUE;
29721af68beaSAlexander Stetsenko break;
29731af68beaSAlexander Stetsenko case 'o':
297489f5d17bSYuri Pankov ofield = optarg;
29751af68beaSAlexander Stetsenko break;
29761af68beaSAlexander Stetsenko case 's':
29771af68beaSAlexander Stetsenko case 'S':
29781af68beaSAlexander Stetsenko if (zfs_add_sort_column(&sortcol, optarg,
297989f5d17bSYuri Pankov c == 's' ? B_FALSE : B_TRUE) != 0) {
29801af68beaSAlexander Stetsenko (void) fprintf(stderr,
298189f5d17bSYuri Pankov gettext("invalid field '%s'\n"), optarg);
29821af68beaSAlexander Stetsenko usage(B_FALSE);
29831af68beaSAlexander Stetsenko }
29841af68beaSAlexander Stetsenko break;
29851af68beaSAlexander Stetsenko case 't':
2986f67950b2SNasf-Fan if (types == USTYPE_PROJ) {
2987f67950b2SNasf-Fan (void) fprintf(stderr,
2988f67950b2SNasf-Fan gettext("invalid option 't'\n"));
2989f67950b2SNasf-Fan usage(B_FALSE);
2990f67950b2SNasf-Fan }
299189f5d17bSYuri Pankov tfield = optarg;
29921af68beaSAlexander Stetsenko break;
29931af68beaSAlexander Stetsenko case 'i':
2994f67950b2SNasf-Fan if (types == USTYPE_PROJ) {
2995f67950b2SNasf-Fan (void) fprintf(stderr,
2996f67950b2SNasf-Fan gettext("invalid option 'i'\n"));
2997f67950b2SNasf-Fan usage(B_FALSE);
2998f67950b2SNasf-Fan }
29991af68beaSAlexander Stetsenko sid2posix = B_TRUE;
30001af68beaSAlexander Stetsenko break;
30011af68beaSAlexander Stetsenko case ':':
30021af68beaSAlexander Stetsenko (void) fprintf(stderr, gettext("missing argument for "
30031af68beaSAlexander Stetsenko "'%c' option\n"), optopt);
30041af68beaSAlexander Stetsenko usage(B_FALSE);
30051af68beaSAlexander Stetsenko break;
30061af68beaSAlexander Stetsenko case '?':
30071af68beaSAlexander Stetsenko (void) fprintf(stderr, gettext("invalid option '%c'\n"),
30081af68beaSAlexander Stetsenko optopt);
30091af68beaSAlexander Stetsenko usage(B_FALSE);
30101af68beaSAlexander Stetsenko }
30111af68beaSAlexander Stetsenko }
30121af68beaSAlexander Stetsenko
30131af68beaSAlexander Stetsenko argc -= optind;
30141af68beaSAlexander Stetsenko argv += optind;
30151af68beaSAlexander Stetsenko
301689f5d17bSYuri Pankov if (argc < 1) {
301789f5d17bSYuri Pankov (void) fprintf(stderr, gettext("missing dataset name\n"));
301889f5d17bSYuri Pankov usage(B_FALSE);
301989f5d17bSYuri Pankov }
302089f5d17bSYuri Pankov if (argc > 1) {
302189f5d17bSYuri Pankov (void) fprintf(stderr, gettext("too many arguments\n"));
302289f5d17bSYuri Pankov usage(B_FALSE);
30231af68beaSAlexander Stetsenko }
302414843421SMatthew Ahrens
302589f5d17bSYuri Pankov /* Use default output fields if not specified using -o */
302689f5d17bSYuri Pankov if (ofield == NULL)
302789f5d17bSYuri Pankov ofield = deffields;
302889f5d17bSYuri Pankov do {
302989f5d17bSYuri Pankov if ((delim = strchr(ofield, ',')) != NULL)
303089f5d17bSYuri Pankov *delim = '\0';
303189f5d17bSYuri Pankov if ((fields[cfield++] = us_field_index(ofield)) == -1) {
303289f5d17bSYuri Pankov (void) fprintf(stderr, gettext("invalid type '%s' "
303389f5d17bSYuri Pankov "for -o option\n"), ofield);
303489f5d17bSYuri Pankov return (-1);
303589f5d17bSYuri Pankov }
303689f5d17bSYuri Pankov if (delim != NULL)
303789f5d17bSYuri Pankov ofield = delim + 1;
303889f5d17bSYuri Pankov } while (delim != NULL);
303989f5d17bSYuri Pankov fields[cfield] = USFIELD_LAST;
304089f5d17bSYuri Pankov
304189f5d17bSYuri Pankov /* Override output types (-t option) */
304289f5d17bSYuri Pankov if (tfield != NULL) {
304389f5d17bSYuri Pankov types = 0;
304489f5d17bSYuri Pankov
304589f5d17bSYuri Pankov do {
304689f5d17bSYuri Pankov boolean_t found = B_FALSE;
304789f5d17bSYuri Pankov
304889f5d17bSYuri Pankov if ((delim = strchr(tfield, ',')) != NULL)
304989f5d17bSYuri Pankov *delim = '\0';
305089f5d17bSYuri Pankov for (i = 0; i < sizeof (us_type_bits) / sizeof (int);
305189f5d17bSYuri Pankov i++) {
305289f5d17bSYuri Pankov if (strcmp(tfield, us_type_names[i]) == 0) {
305389f5d17bSYuri Pankov found = B_TRUE;
305489f5d17bSYuri Pankov types |= us_type_bits[i];
305589f5d17bSYuri Pankov break;
305689f5d17bSYuri Pankov }
305789f5d17bSYuri Pankov }
305889f5d17bSYuri Pankov if (!found) {
305989f5d17bSYuri Pankov (void) fprintf(stderr, gettext("invalid type "
306089f5d17bSYuri Pankov "'%s' for -t option\n"), tfield);
306189f5d17bSYuri Pankov return (-1);
306289f5d17bSYuri Pankov }
306389f5d17bSYuri Pankov if (delim != NULL)
306489f5d17bSYuri Pankov tfield = delim + 1;
306589f5d17bSYuri Pankov } while (delim != NULL);
306689f5d17bSYuri Pankov }
306714843421SMatthew Ahrens
306889f5d17bSYuri Pankov if ((zhp = zfs_open(g_zfs, argv[0], ZFS_TYPE_DATASET)) == NULL)
306914843421SMatthew Ahrens return (1);
307014843421SMatthew Ahrens
30711af68beaSAlexander Stetsenko if ((avl_pool = uu_avl_pool_create("us_avl_pool", sizeof (us_node_t),
307289f5d17bSYuri Pankov offsetof(us_node_t, usn_avlnode), us_compare, UU_DEFAULT)) == NULL)
30731af68beaSAlexander Stetsenko nomem();
30741af68beaSAlexander Stetsenko if ((avl_tree = uu_avl_create(avl_pool, NULL, UU_DEFAULT)) == NULL)
30751af68beaSAlexander Stetsenko nomem();
30761af68beaSAlexander Stetsenko
307789f5d17bSYuri Pankov /* Always add default sorting columns */
307889f5d17bSYuri Pankov (void) zfs_add_sort_column(&sortcol, "type", B_FALSE);
307989f5d17bSYuri Pankov (void) zfs_add_sort_column(&sortcol, "name", B_FALSE);
308089f5d17bSYuri Pankov
308189f5d17bSYuri Pankov cb.cb_sortcol = sortcol;
30821af68beaSAlexander Stetsenko cb.cb_numname = prtnum;
308389f5d17bSYuri Pankov cb.cb_nicenum = !parsable;
30841af68beaSAlexander Stetsenko cb.cb_avl_pool = avl_pool;
30851af68beaSAlexander Stetsenko cb.cb_avl = avl_tree;
30861af68beaSAlexander Stetsenko cb.cb_sid2posix = sid2posix;
308789f5d17bSYuri Pankov
308889f5d17bSYuri Pankov for (i = 0; i < USFIELD_LAST; i++)
308989f5d17bSYuri Pankov cb.cb_width[i] = strlen(gettext(us_field_hdr[i]));
309014843421SMatthew Ahrens
309114843421SMatthew Ahrens for (p = 0; p < ZFS_NUM_USERQUOTA_PROPS; p++) {
3092f67950b2SNasf-Fan if ((zfs_prop_is_user(p) &&
309389f5d17bSYuri Pankov !(types & (USTYPE_PSX_USR | USTYPE_SMB_USR))) ||
3094f67950b2SNasf-Fan (zfs_prop_is_group(p) &&
3095f67950b2SNasf-Fan !(types & (USTYPE_PSX_GRP | USTYPE_SMB_GRP))) ||
3096f67950b2SNasf-Fan (zfs_prop_is_project(p) && types != USTYPE_PROJ))
30971af68beaSAlexander Stetsenko continue;
3098f67950b2SNasf-Fan
30991af68beaSAlexander Stetsenko cb.cb_prop = p;
310070f56fa6SYuri Pankov if ((ret = zfs_userspace(zhp, p, userspace_cb, &cb)) != 0)
310170f56fa6SYuri Pankov return (ret);
310214843421SMatthew Ahrens }
31031af68beaSAlexander Stetsenko
310489f5d17bSYuri Pankov /* Sort the list */
310570f56fa6SYuri Pankov if ((node = uu_avl_first(avl_tree)) == NULL)
310670f56fa6SYuri Pankov return (0);
310770f56fa6SYuri Pankov
310889f5d17bSYuri Pankov us_populated = B_TRUE;
310970f56fa6SYuri Pankov
311089f5d17bSYuri Pankov listpool = uu_list_pool_create("tmplist", sizeof (us_node_t),
311189f5d17bSYuri Pankov offsetof(us_node_t, usn_listnode), NULL, UU_DEFAULT);
311289f5d17bSYuri Pankov list = uu_list_create(listpool, NULL, UU_DEFAULT);
311389f5d17bSYuri Pankov uu_list_node_init(node, &node->usn_listnode, listpool);
31141af68beaSAlexander Stetsenko
311589f5d17bSYuri Pankov while (node != NULL) {
311689f5d17bSYuri Pankov rmnode = node;
311789f5d17bSYuri Pankov node = uu_avl_next(avl_tree, node);
311889f5d17bSYuri Pankov uu_avl_remove(avl_tree, rmnode);
311989f5d17bSYuri Pankov if (uu_list_find(list, rmnode, NULL, &idx2) == NULL)
312089f5d17bSYuri Pankov uu_list_insert(list, rmnode, idx2);
312189f5d17bSYuri Pankov }
31221af68beaSAlexander Stetsenko
312389f5d17bSYuri Pankov for (node = uu_list_first(list); node != NULL;
312489f5d17bSYuri Pankov node = uu_list_next(list, node)) {
312589f5d17bSYuri Pankov us_sort_info_t sortinfo = { sortcol, cb.cb_numname };
312689f5d17bSYuri Pankov
312789f5d17bSYuri Pankov if (uu_avl_find(avl_tree, node, &sortinfo, &idx) == NULL)
312889f5d17bSYuri Pankov uu_avl_insert(avl_tree, node, idx);
31291af68beaSAlexander Stetsenko }
31301af68beaSAlexander Stetsenko
313189f5d17bSYuri Pankov uu_list_destroy(list);
313289f5d17bSYuri Pankov uu_list_pool_destroy(listpool);
31331af68beaSAlexander Stetsenko
313489f5d17bSYuri Pankov /* Print and free node nvlist memory */
313589f5d17bSYuri Pankov print_us(scripted, parsable, fields, types, cb.cb_width, B_TRUE,
313689f5d17bSYuri Pankov cb.cb_avl);
31371af68beaSAlexander Stetsenko
313889f5d17bSYuri Pankov zfs_free_sort_columns(sortcol);
313989f5d17bSYuri Pankov
314089f5d17bSYuri Pankov /* Clean up the AVL tree */
31411af68beaSAlexander Stetsenko if ((walk = uu_avl_walk_start(cb.cb_avl, UU_WALK_ROBUST)) == NULL)
31421af68beaSAlexander Stetsenko nomem();
31431af68beaSAlexander Stetsenko
31441af68beaSAlexander Stetsenko while ((node = uu_avl_walk_next(walk)) != NULL) {
31451af68beaSAlexander Stetsenko uu_avl_remove(cb.cb_avl, node);
31461af68beaSAlexander Stetsenko free(node);
31471af68beaSAlexander Stetsenko }
31481af68beaSAlexander Stetsenko
31491af68beaSAlexander Stetsenko uu_avl_walk_end(walk);
31501af68beaSAlexander Stetsenko uu_avl_destroy(avl_tree);
31511af68beaSAlexander Stetsenko uu_avl_pool_destroy(avl_pool);
31521af68beaSAlexander Stetsenko
315370f56fa6SYuri Pankov return (ret);
315414843421SMatthew Ahrens }
315514843421SMatthew Ahrens
3156fa9e4066Sahrens /*
315743d68d68SYuri Pankov * list [-Hp][-r|-d max] [-o property[,...]] [-s property] ... [-S property] ...
315843d68d68SYuri Pankov * [-t type[,...]] [filesystem|volume|snapshot] ...
3159fa9e4066Sahrens *
316043d68d68SYuri Pankov * -H Scripted mode; elide headers and separate columns by tabs.
316143d68d68SYuri Pankov * -p Display values in parsable (literal) format.
316243d68d68SYuri Pankov * -r Recurse over all children.
316392241e0bSTom Erickson * -d Limit recursion by depth.
316492241e0bSTom Erickson * -o Control which fields to display.
3165b6825278Ssjelinek * -s Specify sort columns, descending order.
3166b6825278Ssjelinek * -S Specify sort columns, ascending order.
316743d68d68SYuri Pankov * -t Control which object types to display.
3168fa9e4066Sahrens *
316943d68d68SYuri Pankov * When given no arguments, list all filesystems in the system.
3170fa9e4066Sahrens * Otherwise, list the specified datasets, optionally recursing down them if
3171fa9e4066Sahrens * '-r' is specified.
3172fa9e4066Sahrens */
3173fa9e4066Sahrens typedef struct list_cbdata {
317499653d4eSeschrock boolean_t cb_first;
317543d68d68SYuri Pankov boolean_t cb_literal;
317699653d4eSeschrock boolean_t cb_scripted;
3177990b4856Slling zprop_list_t *cb_proplist;
3178fa9e4066Sahrens } list_cbdata_t;
3179fa9e4066Sahrens
3180fa9e4066Sahrens /*
3181fa9e4066Sahrens * Given a list of columns to display, output appropriate headers for each one.
3182fa9e4066Sahrens */
3183fa9e4066Sahrens static void
print_header(list_cbdata_t * cb)318443d68d68SYuri Pankov print_header(list_cbdata_t *cb)
3185fa9e4066Sahrens {
318643d68d68SYuri Pankov zprop_list_t *pl = cb->cb_proplist;
3187e9dbad6fSeschrock char headerbuf[ZFS_MAXPROPLEN];
3188e9dbad6fSeschrock const char *header;
3189fa9e4066Sahrens int i;
3190e9dbad6fSeschrock boolean_t first = B_TRUE;
3191e9dbad6fSeschrock boolean_t right_justify;
3192fa9e4066Sahrens
3193e9dbad6fSeschrock for (; pl != NULL; pl = pl->pl_next) {
3194e9dbad6fSeschrock if (!first) {
3195fa9e4066Sahrens (void) printf(" ");
3196e9dbad6fSeschrock } else {
3197e9dbad6fSeschrock first = B_FALSE;
3198e9dbad6fSeschrock }
3199e9dbad6fSeschrock
3200e9dbad6fSeschrock right_justify = B_FALSE;
3201990b4856Slling if (pl->pl_prop != ZPROP_INVAL) {
3202e9dbad6fSeschrock header = zfs_prop_column_name(pl->pl_prop);
3203e9dbad6fSeschrock right_justify = zfs_prop_align_right(pl->pl_prop);
3204e9dbad6fSeschrock } else {
3205e9dbad6fSeschrock for (i = 0; pl->pl_user_prop[i] != '\0'; i++)
3206e9dbad6fSeschrock headerbuf[i] = toupper(pl->pl_user_prop[i]);
3207e9dbad6fSeschrock headerbuf[i] = '\0';
3208e9dbad6fSeschrock header = headerbuf;
3209e9dbad6fSeschrock }
3210e9dbad6fSeschrock
3211e9dbad6fSeschrock if (pl->pl_next == NULL && !right_justify)
3212e9dbad6fSeschrock (void) printf("%s", header);
3213e9dbad6fSeschrock else if (right_justify)
3214e9dbad6fSeschrock (void) printf("%*s", pl->pl_width, header);
3215e9dbad6fSeschrock else
3216e9dbad6fSeschrock (void) printf("%-*s", pl->pl_width, header);
3217fa9e4066Sahrens }
3218fa9e4066Sahrens
3219fa9e4066Sahrens (void) printf("\n");
3220fa9e4066Sahrens }
3221fa9e4066Sahrens
3222fa9e4066Sahrens /*
3223fa9e4066Sahrens * Given a dataset and a list of fields, print out all the properties according
3224fa9e4066Sahrens * to the described layout.
3225fa9e4066Sahrens */
3226fa9e4066Sahrens static void
print_dataset(zfs_handle_t * zhp,list_cbdata_t * cb)322743d68d68SYuri Pankov print_dataset(zfs_handle_t *zhp, list_cbdata_t *cb)
3228fa9e4066Sahrens {
322943d68d68SYuri Pankov zprop_list_t *pl = cb->cb_proplist;
3230e9dbad6fSeschrock boolean_t first = B_TRUE;
3231fa9e4066Sahrens char property[ZFS_MAXPROPLEN];
3232e9dbad6fSeschrock nvlist_t *userprops = zfs_get_user_props(zhp);
3233e9dbad6fSeschrock nvlist_t *propval;
3234e9dbad6fSeschrock char *propstr;
3235e9dbad6fSeschrock boolean_t right_justify;
3236fa9e4066Sahrens
3237e9dbad6fSeschrock for (; pl != NULL; pl = pl->pl_next) {
3238e9dbad6fSeschrock if (!first) {
323943d68d68SYuri Pankov if (cb->cb_scripted)
3240fa9e4066Sahrens (void) printf("\t");
3241fa9e4066Sahrens else
3242fa9e4066Sahrens (void) printf(" ");
3243e9dbad6fSeschrock } else {
3244e9dbad6fSeschrock first = B_FALSE;
3245e9dbad6fSeschrock }
3246e9dbad6fSeschrock
32470d8fa8f8SMartin Matuska if (pl->pl_prop == ZFS_PROP_NAME) {
32480d8fa8f8SMartin Matuska (void) strlcpy(property, zfs_get_name(zhp),
32490d8fa8f8SMartin Matuska sizeof (property));
32500d8fa8f8SMartin Matuska propstr = property;
32510d8fa8f8SMartin Matuska right_justify = zfs_prop_align_right(pl->pl_prop);
32520d8fa8f8SMartin Matuska } else if (pl->pl_prop != ZPROP_INVAL) {
3253e9dbad6fSeschrock if (zfs_prop_get(zhp, pl->pl_prop, property,
325443d68d68SYuri Pankov sizeof (property), NULL, NULL, 0,
325543d68d68SYuri Pankov cb->cb_literal) != 0)
3256e9dbad6fSeschrock propstr = "-";
3257e9dbad6fSeschrock else
3258e9dbad6fSeschrock propstr = property;
3259e9dbad6fSeschrock right_justify = zfs_prop_align_right(pl->pl_prop);
326014843421SMatthew Ahrens } else if (zfs_prop_userquota(pl->pl_user_prop)) {
326114843421SMatthew Ahrens if (zfs_prop_get_userquota(zhp, pl->pl_user_prop,
326243d68d68SYuri Pankov property, sizeof (property), cb->cb_literal) != 0)
326314843421SMatthew Ahrens propstr = "-";
326414843421SMatthew Ahrens else
326514843421SMatthew Ahrens propstr = property;
326614843421SMatthew Ahrens right_justify = B_TRUE;
326719b94df9SMatthew Ahrens } else if (zfs_prop_written(pl->pl_user_prop)) {
326819b94df9SMatthew Ahrens if (zfs_prop_get_written(zhp, pl->pl_user_prop,
326943d68d68SYuri Pankov property, sizeof (property), cb->cb_literal) != 0)
327019b94df9SMatthew Ahrens propstr = "-";
327119b94df9SMatthew Ahrens else
327219b94df9SMatthew Ahrens propstr = property;
327319b94df9SMatthew Ahrens right_justify = B_TRUE;
3274e9dbad6fSeschrock } else {
3275e9dbad6fSeschrock if (nvlist_lookup_nvlist(userprops,
3276e9dbad6fSeschrock pl->pl_user_prop, &propval) != 0)
3277e9dbad6fSeschrock propstr = "-";
3278e9dbad6fSeschrock else
3279e9dbad6fSeschrock verify(nvlist_lookup_string(propval,
3280990b4856Slling ZPROP_VALUE, &propstr) == 0);
328114843421SMatthew Ahrens right_justify = B_FALSE;
3282fa9e4066Sahrens }
3283fa9e4066Sahrens
328407ba0419Seschrock /*
328507ba0419Seschrock * If this is being called in scripted mode, or if this is the
328607ba0419Seschrock * last column and it is left-justified, don't include a width
328707ba0419Seschrock * format specifier.
328807ba0419Seschrock */
328943d68d68SYuri Pankov if (cb->cb_scripted || (pl->pl_next == NULL && !right_justify))
3290e9dbad6fSeschrock (void) printf("%s", propstr);
3291e9dbad6fSeschrock else if (right_justify)
329243d68d68SYuri Pankov (void) printf("%*s", pl->pl_width, propstr);
3293e9dbad6fSeschrock else
329443d68d68SYuri Pankov (void) printf("%-*s", pl->pl_width, propstr);
3295fa9e4066Sahrens }
3296fa9e4066Sahrens
3297fa9e4066Sahrens (void) printf("\n");
3298fa9e4066Sahrens }
3299fa9e4066Sahrens
3300fa9e4066Sahrens /*
3301fa9e4066Sahrens * Generic callback function to list a dataset or snapshot.
3302fa9e4066Sahrens */
3303fa9e4066Sahrens static int
list_callback(zfs_handle_t * zhp,void * data)3304fa9e4066Sahrens list_callback(zfs_handle_t *zhp, void *data)
3305fa9e4066Sahrens {
3306fa9e4066Sahrens list_cbdata_t *cbp = data;
3307fa9e4066Sahrens
3308fa9e4066Sahrens if (cbp->cb_first) {
3309fa9e4066Sahrens if (!cbp->cb_scripted)
331043d68d68SYuri Pankov print_header(cbp);
331199653d4eSeschrock cbp->cb_first = B_FALSE;
3312fa9e4066Sahrens }
3313fa9e4066Sahrens
331443d68d68SYuri Pankov print_dataset(zhp, cbp);
3315fa9e4066Sahrens
3316fa9e4066Sahrens return (0);
3317fa9e4066Sahrens }
3318fa9e4066Sahrens
3319fa9e4066Sahrens static int
zfs_do_list(int argc,char ** argv)3320fa9e4066Sahrens zfs_do_list(int argc, char **argv)
3321fa9e4066Sahrens {
3322fa9e4066Sahrens int c;
3323fa9e4066Sahrens static char default_fields[] =
3324fa9e4066Sahrens "name,used,available,referenced,mountpoint";
33257f73c863SRich Morris int types = ZFS_TYPE_DATASET;
3326d5b5bb25SRich Morris boolean_t types_specified = B_FALSE;
3327fa9e4066Sahrens char *fields = NULL;
3328fa9e4066Sahrens list_cbdata_t cb = { 0 };
3329fa9e4066Sahrens char *value;
3330ae1726b6SChris Gerhard int limit = 0;
333105c998d6SRichard Lowe int ret = 0;
3332b6825278Ssjelinek zfs_sort_column_t *sortcol = NULL;
3333d5b5bb25SRich Morris int flags = ZFS_ITER_PROP_LISTSNAPS | ZFS_ITER_ARGS_CAN_BE_PATHS;
3334fa9e4066Sahrens
3335fa9e4066Sahrens /* check options */
333643d68d68SYuri Pankov while ((c = getopt(argc, argv, "HS:d:o:prs:t:")) != -1) {
3337fa9e4066Sahrens switch (c) {
3338fa9e4066Sahrens case 'o':
3339fa9e4066Sahrens fields = optarg;
3340fa9e4066Sahrens break;
334143d68d68SYuri Pankov case 'p':
334243d68d68SYuri Pankov cb.cb_literal = B_TRUE;
334343d68d68SYuri Pankov flags |= ZFS_ITER_LITERAL_PROPS;
334443d68d68SYuri Pankov break;
3345ae1726b6SChris Gerhard case 'd':
3346ae1726b6SChris Gerhard limit = parse_depth(optarg, &flags);
3347ae1726b6SChris Gerhard break;
3348fa9e4066Sahrens case 'r':
3349d5b5bb25SRich Morris flags |= ZFS_ITER_RECURSE;
3350fa9e4066Sahrens break;
3351fa9e4066Sahrens case 'H':
335243d68d68SYuri Pankov cb.cb_scripted = B_TRUE;
3353fa9e4066Sahrens break;
3354b6825278Ssjelinek case 's':
3355e9dbad6fSeschrock if (zfs_add_sort_column(&sortcol, optarg,
3356e9dbad6fSeschrock B_FALSE) != 0) {
3357b6825278Ssjelinek (void) fprintf(stderr,
3358b6825278Ssjelinek gettext("invalid property '%s'\n"), optarg);
3359b6825278Ssjelinek usage(B_FALSE);
3360b6825278Ssjelinek }
3361b6825278Ssjelinek break;
3362b6825278Ssjelinek case 'S':
3363e9dbad6fSeschrock if (zfs_add_sort_column(&sortcol, optarg,
3364e9dbad6fSeschrock B_TRUE) != 0) {
3365b6825278Ssjelinek (void) fprintf(stderr,
3366b6825278Ssjelinek gettext("invalid property '%s'\n"), optarg);
3367b6825278Ssjelinek usage(B_FALSE);
3368b6825278Ssjelinek }
3369b6825278Ssjelinek break;
3370fa9e4066Sahrens case 't':
3371fa9e4066Sahrens types = 0;
3372d5b5bb25SRich Morris types_specified = B_TRUE;
3373d5b5bb25SRich Morris flags &= ~ZFS_ITER_PROP_LISTSNAPS;
3374fa9e4066Sahrens while (*optarg != '\0') {
3375d5b5bb25SRich Morris static char *type_subopts[] = { "filesystem",
33767dbbcd83SAdam Stevko "volume", "snapshot", "snap", "bookmark",
337778f17100SMatthew Ahrens "all", NULL };
3378d5b5bb25SRich Morris
3379fa9e4066Sahrens switch (getsubopt(&optarg, type_subopts,
3380fa9e4066Sahrens &value)) {
3381fa9e4066Sahrens case 0:
3382fa9e4066Sahrens types |= ZFS_TYPE_FILESYSTEM;
3383fa9e4066Sahrens break;
3384fa9e4066Sahrens case 1:
3385fa9e4066Sahrens types |= ZFS_TYPE_VOLUME;
3386fa9e4066Sahrens break;
3387fa9e4066Sahrens case 2:
33887dbbcd83SAdam Stevko case 3:
3389fa9e4066Sahrens types |= ZFS_TYPE_SNAPSHOT;
3390fa9e4066Sahrens break;
33917dbbcd83SAdam Stevko case 4:
339278f17100SMatthew Ahrens types |= ZFS_TYPE_BOOKMARK;
339378f17100SMatthew Ahrens break;
33947dbbcd83SAdam Stevko case 5:
339578f17100SMatthew Ahrens types = ZFS_TYPE_DATASET |
339678f17100SMatthew Ahrens ZFS_TYPE_BOOKMARK;
3397d5b5bb25SRich Morris break;
3398fa9e4066Sahrens default:
3399fa9e4066Sahrens (void) fprintf(stderr,
3400fa9e4066Sahrens gettext("invalid type '%s'\n"),
3401fa9e4066Sahrens value);
340299653d4eSeschrock usage(B_FALSE);
3403fa9e4066Sahrens }
3404fa9e4066Sahrens }
3405fa9e4066Sahrens break;
3406fa9e4066Sahrens case ':':
3407fa9e4066Sahrens (void) fprintf(stderr, gettext("missing argument for "
3408fa9e4066Sahrens "'%c' option\n"), optopt);
340999653d4eSeschrock usage(B_FALSE);
3410fa9e4066Sahrens break;
3411fa9e4066Sahrens case '?':
3412fa9e4066Sahrens (void) fprintf(stderr, gettext("invalid option '%c'\n"),
3413fa9e4066Sahrens optopt);
341499653d4eSeschrock usage(B_FALSE);
3415fa9e4066Sahrens }
3416fa9e4066Sahrens }
3417fa9e4066Sahrens
3418fa9e4066Sahrens argc -= optind;
3419fa9e4066Sahrens argv += optind;
3420fa9e4066Sahrens
3421fa9e4066Sahrens if (fields == NULL)
342274e7dc98SMatthew Ahrens fields = default_fields;
342374e7dc98SMatthew Ahrens
34240d8fa8f8SMartin Matuska /*
34250d8fa8f8SMartin Matuska * If we are only going to list snapshot names and sort by name,
34260d8fa8f8SMartin Matuska * then we can use faster version.
34270d8fa8f8SMartin Matuska */
34280d8fa8f8SMartin Matuska if (strcmp(fields, "name") == 0 && zfs_sort_only_by_name(sortcol))
34290d8fa8f8SMartin Matuska flags |= ZFS_ITER_SIMPLE;
34300d8fa8f8SMartin Matuska
343174e7dc98SMatthew Ahrens /*
3432d5b5bb25SRich Morris * If "-o space" and no types were specified, don't display snapshots.
343374e7dc98SMatthew Ahrens */
3434d5b5bb25SRich Morris if (strcmp(fields, "space") == 0 && types_specified == B_FALSE)
343574e7dc98SMatthew Ahrens types &= ~ZFS_TYPE_SNAPSHOT;
3436fa9e4066Sahrens
343707ba0419Seschrock /*
3438990b4856Slling * If the user specifies '-o all', the zprop_get_list() doesn't
343907ba0419Seschrock * normally include the name of the dataset. For 'zfs list', we always
344007ba0419Seschrock * want this property to be first.
344107ba0419Seschrock */
3442990b4856Slling if (zprop_get_list(g_zfs, fields, &cb.cb_proplist, ZFS_TYPE_DATASET)
3443990b4856Slling != 0)
344499653d4eSeschrock usage(B_FALSE);
3445fa9e4066Sahrens
344699653d4eSeschrock cb.cb_first = B_TRUE;
3447fa9e4066Sahrens
3448d5b5bb25SRich Morris ret = zfs_for_each(argc, argv, flags, types, sortcol, &cb.cb_proplist,
3449ae1726b6SChris Gerhard limit, list_callback, &cb);
3450b6825278Ssjelinek
3451990b4856Slling zprop_free_list(cb.cb_proplist);
3452b6825278Ssjelinek zfs_free_sort_columns(sortcol);
3453fa9e4066Sahrens
3454fce7d82bSmmusante if (ret == 0 && cb.cb_first && !cb.cb_scripted)
3455fa9e4066Sahrens (void) printf(gettext("no datasets available\n"));
3456fa9e4066Sahrens
3457fa9e4066Sahrens return (ret);
3458fa9e4066Sahrens }
3459fa9e4066Sahrens
3460fa9e4066Sahrens /*
34616a9cb0eaSEric Schrock * zfs rename [-f] <fs | snap | vol> <fs | snap | vol>
34626a9cb0eaSEric Schrock * zfs rename [-f] -p <fs | vol> <fs | vol>
34637f1f55eaSvb * zfs rename -r <snap> <snap>
3464fa9e4066Sahrens *
3465fa9e4066Sahrens * Renames the given dataset to another of the same type.
34667f1f55eaSvb *
34677f1f55eaSvb * The '-p' flag creates all the non-existing ancestors of the target first.
3468fa9e4066Sahrens */
3469fa9e4066Sahrens /* ARGSUSED */
3470fa9e4066Sahrens static int
zfs_do_rename(int argc,char ** argv)3471fa9e4066Sahrens zfs_do_rename(int argc, char **argv)
3472fa9e4066Sahrens {
3473fa9e4066Sahrens zfs_handle_t *zhp;
3474cdf5b4caSmmusante int c;
347505c998d6SRichard Lowe int ret = 0;
34767f1f55eaSvb boolean_t recurse = B_FALSE;
34777f1f55eaSvb boolean_t parents = B_FALSE;
34786a9cb0eaSEric Schrock boolean_t force_unmount = B_FALSE;
3479fa9e4066Sahrens
3480fa9e4066Sahrens /* check options */
34816a9cb0eaSEric Schrock while ((c = getopt(argc, argv, "prf")) != -1) {
3482cdf5b4caSmmusante switch (c) {
34837f1f55eaSvb case 'p':
34847f1f55eaSvb parents = B_TRUE;
34857f1f55eaSvb break;
3486cdf5b4caSmmusante case 'r':
34877f1f55eaSvb recurse = B_TRUE;
3488cdf5b4caSmmusante break;
34896a9cb0eaSEric Schrock case 'f':
34906a9cb0eaSEric Schrock force_unmount = B_TRUE;
34916a9cb0eaSEric Schrock break;
3492cdf5b4caSmmusante case '?':
3493cdf5b4caSmmusante default:
3494cdf5b4caSmmusante (void) fprintf(stderr, gettext("invalid option '%c'\n"),
3495cdf5b4caSmmusante optopt);
3496cdf5b4caSmmusante usage(B_FALSE);
3497cdf5b4caSmmusante }
3498fa9e4066Sahrens }
3499fa9e4066Sahrens
3500cdf5b4caSmmusante argc -= optind;
3501cdf5b4caSmmusante argv += optind;
3502cdf5b4caSmmusante
3503fa9e4066Sahrens /* check number of arguments */
3504cdf5b4caSmmusante if (argc < 1) {
3505fa9e4066Sahrens (void) fprintf(stderr, gettext("missing source dataset "
3506fa9e4066Sahrens "argument\n"));
350799653d4eSeschrock usage(B_FALSE);
3508fa9e4066Sahrens }
3509cdf5b4caSmmusante if (argc < 2) {
3510fa9e4066Sahrens (void) fprintf(stderr, gettext("missing target dataset "
3511fa9e4066Sahrens "argument\n"));
351299653d4eSeschrock usage(B_FALSE);
3513fa9e4066Sahrens }
3514cdf5b4caSmmusante if (argc > 2) {
3515fa9e4066Sahrens (void) fprintf(stderr, gettext("too many arguments\n"));
351699653d4eSeschrock usage(B_FALSE);
3517fa9e4066Sahrens }
3518fa9e4066Sahrens
35197f1f55eaSvb if (recurse && parents) {
35207f1f55eaSvb (void) fprintf(stderr, gettext("-p and -r options are mutually "
35217f1f55eaSvb "exclusive\n"));
35227f1f55eaSvb usage(B_FALSE);
35237f1f55eaSvb }
35247f1f55eaSvb
3525cdf5b4caSmmusante if (recurse && strchr(argv[0], '@') == 0) {
3526cdf5b4caSmmusante (void) fprintf(stderr, gettext("source dataset for recursive "
3527cdf5b4caSmmusante "rename must be a snapshot\n"));
3528cdf5b4caSmmusante usage(B_FALSE);
3529cdf5b4caSmmusante }
3530cdf5b4caSmmusante
35317f1f55eaSvb if ((zhp = zfs_open(g_zfs, argv[0], parents ? ZFS_TYPE_FILESYSTEM |
3532990b4856Slling ZFS_TYPE_VOLUME : ZFS_TYPE_DATASET)) == NULL)
35337f1f55eaSvb return (1);
35347f1f55eaSvb
35357f1f55eaSvb /* If we were asked and the name looks good, try to create ancestors. */
35367f1f55eaSvb if (parents && zfs_name_valid(argv[1], zfs_get_type(zhp)) &&
35377f1f55eaSvb zfs_create_ancestors(g_zfs, argv[1]) != 0) {
35387f1f55eaSvb zfs_close(zhp);
3539fa9e4066Sahrens return (1);
35407f1f55eaSvb }
3541fa9e4066Sahrens
35426a9cb0eaSEric Schrock ret = (zfs_rename(zhp, argv[1], recurse, force_unmount) != 0);
354399653d4eSeschrock
354499653d4eSeschrock zfs_close(zhp);
354599653d4eSeschrock return (ret);
354699653d4eSeschrock }
354799653d4eSeschrock
354899653d4eSeschrock /*
354999653d4eSeschrock * zfs promote <fs>
355099653d4eSeschrock *
355199653d4eSeschrock * Promotes the given clone fs to be the parent
355299653d4eSeschrock */
355399653d4eSeschrock /* ARGSUSED */
355499653d4eSeschrock static int
zfs_do_promote(int argc,char ** argv)355599653d4eSeschrock zfs_do_promote(int argc, char **argv)
355699653d4eSeschrock {
355799653d4eSeschrock zfs_handle_t *zhp;
355805c998d6SRichard Lowe int ret = 0;
355999653d4eSeschrock
356099653d4eSeschrock /* check options */
356199653d4eSeschrock if (argc > 1 && argv[1][0] == '-') {
356299653d4eSeschrock (void) fprintf(stderr, gettext("invalid option '%c'\n"),
356399653d4eSeschrock argv[1][1]);
356499653d4eSeschrock usage(B_FALSE);
356599653d4eSeschrock }
356699653d4eSeschrock
356799653d4eSeschrock /* check number of arguments */
356899653d4eSeschrock if (argc < 2) {
356999653d4eSeschrock (void) fprintf(stderr, gettext("missing clone filesystem"
357012054bfcSnd " argument\n"));
357199653d4eSeschrock usage(B_FALSE);
357299653d4eSeschrock }
357399653d4eSeschrock if (argc > 2) {
357499653d4eSeschrock (void) fprintf(stderr, gettext("too many arguments\n"));
357599653d4eSeschrock usage(B_FALSE);
357699653d4eSeschrock }
357799653d4eSeschrock
357899653d4eSeschrock zhp = zfs_open(g_zfs, argv[1], ZFS_TYPE_FILESYSTEM | ZFS_TYPE_VOLUME);
357999653d4eSeschrock if (zhp == NULL)
358099653d4eSeschrock return (1);
358199653d4eSeschrock
358299653d4eSeschrock ret = (zfs_promote(zhp) != 0);
3583fa9e4066Sahrens
358406eeb2adSek
3585fa9e4066Sahrens zfs_close(zhp);
3586fa9e4066Sahrens return (ret);
3587fa9e4066Sahrens }
3588fa9e4066Sahrens
3589fa9e4066Sahrens /*
3590f17c7ff8Sahrens * zfs rollback [-rRf] <snapshot>
3591fa9e4066Sahrens *
359292241e0bSTom Erickson * -r Delete any intervening snapshots before doing rollback
359392241e0bSTom Erickson * -R Delete any snapshots and their clones
359492241e0bSTom Erickson * -f ignored for backwards compatability
3595fa9e4066Sahrens *
3596fa9e4066Sahrens * Given a filesystem, rollback to a specific snapshot, discarding any changes
3597fa9e4066Sahrens * since then and making it the active dataset. If more recent snapshots exist,
3598fa9e4066Sahrens * the command will complain unless the '-r' flag is given.
3599fa9e4066Sahrens */
3600fa9e4066Sahrens typedef struct rollback_cbdata {
3601fa9e4066Sahrens uint64_t cb_create;
360299653d4eSeschrock boolean_t cb_first;
3603fa9e4066Sahrens int cb_doclones;
3604fa9e4066Sahrens char *cb_target;
3605fa9e4066Sahrens int cb_error;
360699653d4eSeschrock boolean_t cb_recurse;
3607fa9e4066Sahrens } rollback_cbdata_t;
3608fa9e4066Sahrens
360978f17100SMatthew Ahrens static int
rollback_check_dependent(zfs_handle_t * zhp,void * data)361078f17100SMatthew Ahrens rollback_check_dependent(zfs_handle_t *zhp, void *data)
361178f17100SMatthew Ahrens {
361278f17100SMatthew Ahrens rollback_cbdata_t *cbp = data;
361378f17100SMatthew Ahrens
361478f17100SMatthew Ahrens if (cbp->cb_first && cbp->cb_recurse) {
361578f17100SMatthew Ahrens (void) fprintf(stderr, gettext("cannot rollback to "
361678f17100SMatthew Ahrens "'%s': clones of previous snapshots exist\n"),
361778f17100SMatthew Ahrens cbp->cb_target);
361878f17100SMatthew Ahrens (void) fprintf(stderr, gettext("use '-R' to "
361978f17100SMatthew Ahrens "force deletion of the following clones and "
362078f17100SMatthew Ahrens "dependents:\n"));
362178f17100SMatthew Ahrens cbp->cb_first = 0;
362278f17100SMatthew Ahrens cbp->cb_error = 1;
362378f17100SMatthew Ahrens }
362478f17100SMatthew Ahrens
362578f17100SMatthew Ahrens (void) fprintf(stderr, "%s\n", zfs_get_name(zhp));
362678f17100SMatthew Ahrens
362778f17100SMatthew Ahrens zfs_close(zhp);
362878f17100SMatthew Ahrens return (0);
362978f17100SMatthew Ahrens }
36305d7b4d43SMatthew Ahrens
3631fa9e4066Sahrens /*
3632fa9e4066Sahrens * Report any snapshots more recent than the one specified. Used when '-r' is
3633fa9e4066Sahrens * not specified. We reuse this same callback for the snapshot dependents - if
3634fa9e4066Sahrens * 'cb_dependent' is set, then this is a dependent and we should report it
3635fa9e4066Sahrens * without checking the transaction group.
3636fa9e4066Sahrens */
3637fa9e4066Sahrens static int
rollback_check(zfs_handle_t * zhp,void * data)3638fa9e4066Sahrens rollback_check(zfs_handle_t *zhp, void *data)
3639fa9e4066Sahrens {
3640fa9e4066Sahrens rollback_cbdata_t *cbp = data;
3641fa9e4066Sahrens
364299653d4eSeschrock if (cbp->cb_doclones) {
364399653d4eSeschrock zfs_close(zhp);
3644fa9e4066Sahrens return (0);
364599653d4eSeschrock }
3646fa9e4066Sahrens
364778f17100SMatthew Ahrens if (zfs_prop_get_int(zhp, ZFS_PROP_CREATETXG) > cbp->cb_create) {
364878f17100SMatthew Ahrens if (cbp->cb_first && !cbp->cb_recurse) {
364978f17100SMatthew Ahrens (void) fprintf(stderr, gettext("cannot "
365078f17100SMatthew Ahrens "rollback to '%s': more recent snapshots "
365178f17100SMatthew Ahrens "or bookmarks exist\n"),
3652fa9e4066Sahrens cbp->cb_target);
365378f17100SMatthew Ahrens (void) fprintf(stderr, gettext("use '-r' to "
365478f17100SMatthew Ahrens "force deletion of the following "
365578f17100SMatthew Ahrens "snapshots and bookmarks:\n"));
3656fa9e4066Sahrens cbp->cb_first = 0;
3657fa9e4066Sahrens cbp->cb_error = 1;
3658fa9e4066Sahrens }
3659fa9e4066Sahrens
366078f17100SMatthew Ahrens if (cbp->cb_recurse) {
366178f17100SMatthew Ahrens if (zfs_iter_dependents(zhp, B_TRUE,
366278f17100SMatthew Ahrens rollback_check_dependent, cbp) != 0) {
366378f17100SMatthew Ahrens zfs_close(zhp);
366478f17100SMatthew Ahrens return (-1);
366578f17100SMatthew Ahrens }
366678f17100SMatthew Ahrens } else {
366778f17100SMatthew Ahrens (void) fprintf(stderr, "%s\n",
366878f17100SMatthew Ahrens zfs_get_name(zhp));
366978f17100SMatthew Ahrens }
3670fa9e4066Sahrens }
3671fa9e4066Sahrens zfs_close(zhp);
3672fa9e4066Sahrens return (0);
3673fa9e4066Sahrens }
3674fa9e4066Sahrens
3675fa9e4066Sahrens static int
zfs_do_rollback(int argc,char ** argv)3676fa9e4066Sahrens zfs_do_rollback(int argc, char **argv)
3677fa9e4066Sahrens {
367805c998d6SRichard Lowe int ret = 0;
3679fa9e4066Sahrens int c;
3680c391e322Sahrens boolean_t force = B_FALSE;
3681fa9e4066Sahrens rollback_cbdata_t cb = { 0 };
3682fa9e4066Sahrens zfs_handle_t *zhp, *snap;
36839adfa60dSMatthew Ahrens char parentname[ZFS_MAX_DATASET_NAME_LEN];
3684fa9e4066Sahrens char *delim;
3685fa9e4066Sahrens
3686fa9e4066Sahrens /* check options */
3687f17c7ff8Sahrens while ((c = getopt(argc, argv, "rRf")) != -1) {
3688fa9e4066Sahrens switch (c) {
3689fa9e4066Sahrens case 'r':
3690fa9e4066Sahrens cb.cb_recurse = 1;
3691fa9e4066Sahrens break;
3692fa9e4066Sahrens case 'R':
3693fa9e4066Sahrens cb.cb_recurse = 1;
3694fa9e4066Sahrens cb.cb_doclones = 1;
3695fa9e4066Sahrens break;
3696f17c7ff8Sahrens case 'f':
3697c391e322Sahrens force = B_TRUE;
3698f17c7ff8Sahrens break;
3699fa9e4066Sahrens case '?':
3700fa9e4066Sahrens (void) fprintf(stderr, gettext("invalid option '%c'\n"),
3701fa9e4066Sahrens optopt);
370299653d4eSeschrock usage(B_FALSE);
3703fa9e4066Sahrens }
3704fa9e4066Sahrens }
3705fa9e4066Sahrens
3706fa9e4066Sahrens argc -= optind;
3707fa9e4066Sahrens argv += optind;
3708fa9e4066Sahrens
3709fa9e4066Sahrens /* check number of arguments */
3710fa9e4066Sahrens if (argc < 1) {
3711fa9e4066Sahrens (void) fprintf(stderr, gettext("missing dataset argument\n"));
371299653d4eSeschrock usage(B_FALSE);
3713fa9e4066Sahrens }
3714fa9e4066Sahrens if (argc > 1) {
3715fa9e4066Sahrens (void) fprintf(stderr, gettext("too many arguments\n"));
371699653d4eSeschrock usage(B_FALSE);
3717fa9e4066Sahrens }
3718fa9e4066Sahrens
3719fa9e4066Sahrens /* open the snapshot */
372099653d4eSeschrock if ((snap = zfs_open(g_zfs, argv[0], ZFS_TYPE_SNAPSHOT)) == NULL)
3721fa9e4066Sahrens return (1);
3722fa9e4066Sahrens
3723b12a1c38Slling /* open the parent dataset */
3724b12a1c38Slling (void) strlcpy(parentname, argv[0], sizeof (parentname));
3725fa9e4066Sahrens verify((delim = strrchr(parentname, '@')) != NULL);
3726fa9e4066Sahrens *delim = '\0';
3727990b4856Slling if ((zhp = zfs_open(g_zfs, parentname, ZFS_TYPE_DATASET)) == NULL) {
3728fa9e4066Sahrens zfs_close(snap);
3729fa9e4066Sahrens return (1);
3730fa9e4066Sahrens }
3731fa9e4066Sahrens
3732fa9e4066Sahrens /*
3733fa9e4066Sahrens * Check for more recent snapshots and/or clones based on the presence
3734fa9e4066Sahrens * of '-r' and '-R'.
3735fa9e4066Sahrens */
3736b12a1c38Slling cb.cb_target = argv[0];
3737b12a1c38Slling cb.cb_create = zfs_prop_get_int(snap, ZFS_PROP_CREATETXG);
373899653d4eSeschrock cb.cb_first = B_TRUE;
3739fa9e4066Sahrens cb.cb_error = 0;
37400d8fa8f8SMartin Matuska if ((ret = zfs_iter_snapshots(zhp, B_FALSE, rollback_check, &cb)) != 0)
374178f17100SMatthew Ahrens goto out;
374278f17100SMatthew Ahrens if ((ret = zfs_iter_bookmarks(zhp, rollback_check, &cb)) != 0)
37433bb79becSeschrock goto out;
3744fa9e4066Sahrens
3745fa9e4066Sahrens if ((ret = cb.cb_error) != 0)
3746fa9e4066Sahrens goto out;
3747fa9e4066Sahrens
3748fa9e4066Sahrens /*
3749b12a1c38Slling * Rollback parent to the given snapshot.
3750fa9e4066Sahrens */
3751c391e322Sahrens ret = zfs_rollback(zhp, snap, force);
3752fa9e4066Sahrens
3753fa9e4066Sahrens out:
3754fa9e4066Sahrens zfs_close(snap);
3755fa9e4066Sahrens zfs_close(zhp);
3756fa9e4066Sahrens
3757fa9e4066Sahrens if (ret == 0)
3758fa9e4066Sahrens return (0);
3759fa9e4066Sahrens else
3760fa9e4066Sahrens return (1);
3761fa9e4066Sahrens }
3762fa9e4066Sahrens
3763fa9e4066Sahrens /*
376430925561SChris Williamson * zfs set property=value ... { fs | snap | vol } ...
3765fa9e4066Sahrens *
376630925561SChris Williamson * Sets the given properties for all datasets specified on the command line.
3767fa9e4066Sahrens */
3768fa9e4066Sahrens
3769fa9e4066Sahrens static int
set_callback(zfs_handle_t * zhp,void * data)3770fa9e4066Sahrens set_callback(zfs_handle_t *zhp, void *data)
3771fa9e4066Sahrens {
377230925561SChris Williamson nvlist_t *props = data;
3773fa9e4066Sahrens
377430925561SChris Williamson if (zfs_prop_set_list(zhp, props) != 0) {
3775efc555ebSnd switch (libzfs_errno(g_zfs)) {
3776efc555ebSnd case EZFS_MOUNTFAILED:
3777efc555ebSnd (void) fprintf(stderr, gettext("property may be set "
3778efc555ebSnd "but unable to remount filesystem\n"));
3779efc555ebSnd break;
3780f3861e1aSahl case EZFS_SHARENFSFAILED:
3781efc555ebSnd (void) fprintf(stderr, gettext("property may be set "
3782efc555ebSnd "but unable to reshare filesystem\n"));
3783efc555ebSnd break;
3784efc555ebSnd }
3785fa9e4066Sahrens return (1);
3786efc555ebSnd }
37875ad82045Snd return (0);
3788fa9e4066Sahrens }
3789fa9e4066Sahrens
3790fa9e4066Sahrens static int
zfs_do_set(int argc,char ** argv)3791fa9e4066Sahrens zfs_do_set(int argc, char **argv)
3792fa9e4066Sahrens {
379330925561SChris Williamson nvlist_t *props = NULL;
379430925561SChris Williamson int ds_start = -1; /* argv idx of first dataset arg */
379505c998d6SRichard Lowe int ret = 0;
3796fa9e4066Sahrens
3797fa9e4066Sahrens /* check for options */
3798fa9e4066Sahrens if (argc > 1 && argv[1][0] == '-') {
3799fa9e4066Sahrens (void) fprintf(stderr, gettext("invalid option '%c'\n"),
3800fa9e4066Sahrens argv[1][1]);
380199653d4eSeschrock usage(B_FALSE);
3802fa9e4066Sahrens }
3803fa9e4066Sahrens
3804fa9e4066Sahrens /* check number of arguments */
3805fa9e4066Sahrens if (argc < 2) {
380630925561SChris Williamson (void) fprintf(stderr, gettext("missing arguments\n"));
380799653d4eSeschrock usage(B_FALSE);
3808fa9e4066Sahrens }
3809fa9e4066Sahrens if (argc < 3) {
381030925561SChris Williamson if (strchr(argv[1], '=') == NULL) {
381130925561SChris Williamson (void) fprintf(stderr, gettext("missing property=value "
381230925561SChris Williamson "argument(s)\n"));
381330925561SChris Williamson } else {
381430925561SChris Williamson (void) fprintf(stderr, gettext("missing dataset "
381530925561SChris Williamson "name(s)\n"));
381630925561SChris Williamson }
381799653d4eSeschrock usage(B_FALSE);
3818fa9e4066Sahrens }
3819fa9e4066Sahrens
382030925561SChris Williamson /* validate argument order: prop=val args followed by dataset args */
382130925561SChris Williamson for (int i = 1; i < argc; i++) {
382230925561SChris Williamson if (strchr(argv[i], '=') != NULL) {
382330925561SChris Williamson if (ds_start > 0) {
382430925561SChris Williamson /* out-of-order prop=val argument */
382530925561SChris Williamson (void) fprintf(stderr, gettext("invalid "
382630925561SChris Williamson "argument order\n"), i);
382730925561SChris Williamson usage(B_FALSE);
382830925561SChris Williamson }
382930925561SChris Williamson } else if (ds_start < 0) {
383030925561SChris Williamson ds_start = i;
383130925561SChris Williamson }
383230925561SChris Williamson }
383330925561SChris Williamson if (ds_start < 0) {
383430925561SChris Williamson (void) fprintf(stderr, gettext("missing dataset name(s)\n"));
383599653d4eSeschrock usage(B_FALSE);
3836fa9e4066Sahrens }
3837fa9e4066Sahrens
383830925561SChris Williamson /* Populate a list of property settings */
383930925561SChris Williamson if (nvlist_alloc(&props, NV_UNIQUE_NAME, 0) != 0)
384030925561SChris Williamson nomem();
384130925561SChris Williamson for (int i = 1; i < ds_start; i++) {
38426ccda740Sloli if (!parseprop(props, argv[i])) {
38436ccda740Sloli ret = -1;
384430925561SChris Williamson goto error;
38456ccda740Sloli }
3846fa9e4066Sahrens }
3847fa9e4066Sahrens
384830925561SChris Williamson ret = zfs_for_each(argc - ds_start, argv + ds_start, 0,
384930925561SChris Williamson ZFS_TYPE_DATASET, NULL, NULL, 0, set_callback, props);
385006eeb2adSek
385130925561SChris Williamson error:
385230925561SChris Williamson nvlist_free(props);
385306eeb2adSek return (ret);
3854fa9e4066Sahrens }
3855fa9e4066Sahrens
38564445fffbSMatthew Ahrens typedef struct snap_cbdata {
38574445fffbSMatthew Ahrens nvlist_t *sd_nvl;
38584445fffbSMatthew Ahrens boolean_t sd_recursive;
38594445fffbSMatthew Ahrens const char *sd_snapname;
38604445fffbSMatthew Ahrens } snap_cbdata_t;
38614445fffbSMatthew Ahrens
38624445fffbSMatthew Ahrens static int
zfs_snapshot_cb(zfs_handle_t * zhp,void * arg)38634445fffbSMatthew Ahrens zfs_snapshot_cb(zfs_handle_t *zhp, void *arg)
38644445fffbSMatthew Ahrens {
38654445fffbSMatthew Ahrens snap_cbdata_t *sd = arg;
38664445fffbSMatthew Ahrens char *name;
38674445fffbSMatthew Ahrens int rv = 0;
38684445fffbSMatthew Ahrens int error;
38694445fffbSMatthew Ahrens
3870ca48f36fSKeith M Wesolowski if (sd->sd_recursive &&
3871ca48f36fSKeith M Wesolowski zfs_prop_get_int(zhp, ZFS_PROP_INCONSISTENT) != 0) {
3872ca48f36fSKeith M Wesolowski zfs_close(zhp);
3873ca48f36fSKeith M Wesolowski return (0);
3874ca48f36fSKeith M Wesolowski }
3875ca48f36fSKeith M Wesolowski
38764445fffbSMatthew Ahrens error = asprintf(&name, "%s@%s", zfs_get_name(zhp), sd->sd_snapname);
38774445fffbSMatthew Ahrens if (error == -1)
38784445fffbSMatthew Ahrens nomem();
38794445fffbSMatthew Ahrens fnvlist_add_boolean(sd->sd_nvl, name);
38804445fffbSMatthew Ahrens free(name);
38814445fffbSMatthew Ahrens
38824445fffbSMatthew Ahrens if (sd->sd_recursive)
38834445fffbSMatthew Ahrens rv = zfs_iter_filesystems(zhp, zfs_snapshot_cb, sd);
38844445fffbSMatthew Ahrens zfs_close(zhp);
38854445fffbSMatthew Ahrens return (rv);
38864445fffbSMatthew Ahrens }
38874445fffbSMatthew Ahrens
3888fa9e4066Sahrens /*
3889bb0ade09Sahrens * zfs snapshot [-r] [-o prop=value] ... <fs@snap>
3890fa9e4066Sahrens *
3891fa9e4066Sahrens * Creates a snapshot with the given name. While functionally equivalent to
3892da6c28aaSamw * 'zfs create', it is a separate command to differentiate intent.
3893fa9e4066Sahrens */
3894fa9e4066Sahrens static int
zfs_do_snapshot(int argc,char ** argv)3895fa9e4066Sahrens zfs_do_snapshot(int argc, char **argv)
3896fa9e4066Sahrens {
389705c998d6SRichard Lowe int ret = 0;
3898*ef150c2bSRichard Lowe int c;
3899bb0ade09Sahrens nvlist_t *props;
39004445fffbSMatthew Ahrens snap_cbdata_t sd = { 0 };
39014445fffbSMatthew Ahrens boolean_t multiple_snaps = B_FALSE;
3902bb0ade09Sahrens
3903a8b6ddafSMark J Musante if (nvlist_alloc(&props, NV_UNIQUE_NAME, 0) != 0)
3904a8b6ddafSMark J Musante nomem();
39054445fffbSMatthew Ahrens if (nvlist_alloc(&sd.sd_nvl, NV_UNIQUE_NAME, 0) != 0)
39064445fffbSMatthew Ahrens nomem();
39071d452cf5Sahrens
3908fa9e4066Sahrens /* check options */
3909bb0ade09Sahrens while ((c = getopt(argc, argv, "ro:")) != -1) {
39101d452cf5Sahrens switch (c) {
3911bb0ade09Sahrens case 'o':
39126ccda740Sloli if (!parseprop(props, optarg)) {
39136ccda740Sloli nvlist_free(sd.sd_nvl);
39146ccda740Sloli nvlist_free(props);
3915bb0ade09Sahrens return (1);
39166ccda740Sloli }
3917bb0ade09Sahrens break;
39181d452cf5Sahrens case 'r':
39194445fffbSMatthew Ahrens sd.sd_recursive = B_TRUE;
39204445fffbSMatthew Ahrens multiple_snaps = B_TRUE;
39211d452cf5Sahrens break;
39221d452cf5Sahrens case '?':
39231d452cf5Sahrens (void) fprintf(stderr, gettext("invalid option '%c'\n"),
39241d452cf5Sahrens optopt);
3925bb0ade09Sahrens goto usage;
39261d452cf5Sahrens }
3927fa9e4066Sahrens }
3928fa9e4066Sahrens
39291d452cf5Sahrens argc -= optind;
39301d452cf5Sahrens argv += optind;
39311d452cf5Sahrens
3932fa9e4066Sahrens /* check number of arguments */
39331d452cf5Sahrens if (argc < 1) {
3934fa9e4066Sahrens (void) fprintf(stderr, gettext("missing snapshot argument\n"));
3935bb0ade09Sahrens goto usage;
3936fa9e4066Sahrens }
39374445fffbSMatthew Ahrens
39384445fffbSMatthew Ahrens if (argc > 1)
39394445fffbSMatthew Ahrens multiple_snaps = B_TRUE;
39404445fffbSMatthew Ahrens for (; argc > 0; argc--, argv++) {
39414445fffbSMatthew Ahrens char *atp;
39424445fffbSMatthew Ahrens zfs_handle_t *zhp;
39434445fffbSMatthew Ahrens
39444445fffbSMatthew Ahrens atp = strchr(argv[0], '@');
39454445fffbSMatthew Ahrens if (atp == NULL)
39464445fffbSMatthew Ahrens goto usage;
39474445fffbSMatthew Ahrens *atp = '\0';
39484445fffbSMatthew Ahrens sd.sd_snapname = atp + 1;
39494445fffbSMatthew Ahrens zhp = zfs_open(g_zfs, argv[0],
39504445fffbSMatthew Ahrens ZFS_TYPE_FILESYSTEM | ZFS_TYPE_VOLUME);
39514445fffbSMatthew Ahrens if (zhp == NULL)
39524445fffbSMatthew Ahrens goto usage;
39534445fffbSMatthew Ahrens if (zfs_snapshot_cb(zhp, &sd) != 0)
39544445fffbSMatthew Ahrens goto usage;
3955fa9e4066Sahrens }
3956fa9e4066Sahrens
39574445fffbSMatthew Ahrens ret = zfs_snapshot_nvl(g_zfs, sd.sd_nvl, props);
39584445fffbSMatthew Ahrens nvlist_free(sd.sd_nvl);
3959bb0ade09Sahrens nvlist_free(props);
39604445fffbSMatthew Ahrens if (ret != 0 && multiple_snaps)
39611d452cf5Sahrens (void) fprintf(stderr, gettext("no snapshots were created\n"));
39621d452cf5Sahrens return (ret != 0);
3963bb0ade09Sahrens
3964bb0ade09Sahrens usage:
39654445fffbSMatthew Ahrens nvlist_free(sd.sd_nvl);
3966bb0ade09Sahrens nvlist_free(props);
3967bb0ade09Sahrens usage(B_FALSE);
3968bb0ade09Sahrens return (-1);
3969fa9e4066Sahrens }
3970fa9e4066Sahrens
3971fa9e4066Sahrens /*
3972fa9e4066Sahrens * Send a backup stream to stdout.
3973fa9e4066Sahrens */
3974fa9e4066Sahrens static int
zfs_do_send(int argc,char ** argv)3975f2a3c691Sahrens zfs_do_send(int argc, char **argv)
3976fa9e4066Sahrens {
3977fa9e4066Sahrens char *fromname = NULL;
39783cb34c60Sahrens char *toname = NULL;
39799c3fd121SMatthew Ahrens char *resume_token = NULL;
3980a2eea2e1Sahrens char *cp;
3981a2eea2e1Sahrens zfs_handle_t *zhp;
39829e69d7d0SLori Alt sendflags_t flags = { 0 };
3983fa9e4066Sahrens int c, err;
398419b94df9SMatthew Ahrens nvlist_t *dbgnv = NULL;
39853f9d6ad7SLin Ling boolean_t extraverbose = B_FALSE;
3986fa9e4066Sahrens
39875602294fSDan Kimmel struct option long_options[] = {
39885602294fSDan Kimmel {"replicate", no_argument, NULL, 'R'},
39895602294fSDan Kimmel {"props", no_argument, NULL, 'p'},
39905602294fSDan Kimmel {"parsable", no_argument, NULL, 'P'},
39915602294fSDan Kimmel {"dedup", no_argument, NULL, 'D'},
39925602294fSDan Kimmel {"verbose", no_argument, NULL, 'v'},
39935602294fSDan Kimmel {"dryrun", no_argument, NULL, 'n'},
39945602294fSDan Kimmel {"large-block", no_argument, NULL, 'L'},
39955602294fSDan Kimmel {"embed", no_argument, NULL, 'e'},
39965602294fSDan Kimmel {"resume", required_argument, NULL, 't'},
39975602294fSDan Kimmel {"compressed", no_argument, NULL, 'c'},
3998eb633035STom Caputi {"raw", no_argument, NULL, 'w'},
39996ccda740Sloli {"backup", no_argument, NULL, 'b'},
40006ccda740Sloli {"holds", no_argument, NULL, 'h'},
40015602294fSDan Kimmel {0, 0, 0, 0}
40025602294fSDan Kimmel };
40035602294fSDan Kimmel
4004fa9e4066Sahrens /* check options */
40056ccda740Sloli while ((c = getopt_long(argc, argv, ":i:I:RDpvnPLeht:cwb", long_options,
40065602294fSDan Kimmel NULL)) != -1) {
4007fa9e4066Sahrens switch (c) {
4008fa9e4066Sahrens case 'i':
4009a2eea2e1Sahrens if (fromname)
4010a2eea2e1Sahrens usage(B_FALSE);
4011fa9e4066Sahrens fromname = optarg;
4012fa9e4066Sahrens break;
40133cb34c60Sahrens case 'I':
40143cb34c60Sahrens if (fromname)
40153cb34c60Sahrens usage(B_FALSE);
40163cb34c60Sahrens fromname = optarg;
40179e69d7d0SLori Alt flags.doall = B_TRUE;
40183cb34c60Sahrens break;
40193cb34c60Sahrens case 'R':
40209e69d7d0SLori Alt flags.replicate = B_TRUE;
40213cb34c60Sahrens break;
402292241e0bSTom Erickson case 'p':
402392241e0bSTom Erickson flags.props = B_TRUE;
402492241e0bSTom Erickson break;
40256ccda740Sloli case 'b':
40266ccda740Sloli flags.backup = B_TRUE;
40276ccda740Sloli break;
40286ccda740Sloli case 'h':
40296ccda740Sloli flags.holds = B_TRUE;
40306ccda740Sloli break;
403119b94df9SMatthew Ahrens case 'P':
403219b94df9SMatthew Ahrens flags.parsable = B_TRUE;
403319b94df9SMatthew Ahrens flags.verbose = B_TRUE;
403419b94df9SMatthew Ahrens break;
40353cb34c60Sahrens case 'v':
40363f9d6ad7SLin Ling if (flags.verbose)
40373f9d6ad7SLin Ling extraverbose = B_TRUE;
40389e69d7d0SLori Alt flags.verbose = B_TRUE;
40394e3c9f44SBill Pijewski flags.progress = B_TRUE;
40409e69d7d0SLori Alt break;
40419e69d7d0SLori Alt case 'D':
40429e69d7d0SLori Alt flags.dedup = B_TRUE;
40433cb34c60Sahrens break;
404419b94df9SMatthew Ahrens case 'n':
404519b94df9SMatthew Ahrens flags.dryrun = B_TRUE;
404619b94df9SMatthew Ahrens break;
4047b5152584SMatthew Ahrens case 'L':
4048b5152584SMatthew Ahrens flags.largeblock = B_TRUE;
4049b5152584SMatthew Ahrens break;
40505d7b4d43SMatthew Ahrens case 'e':
40515d7b4d43SMatthew Ahrens flags.embed_data = B_TRUE;
40525d7b4d43SMatthew Ahrens break;
40539c3fd121SMatthew Ahrens case 't':
40549c3fd121SMatthew Ahrens resume_token = optarg;
40559c3fd121SMatthew Ahrens break;
40565602294fSDan Kimmel case 'c':
40575602294fSDan Kimmel flags.compress = B_TRUE;
40585602294fSDan Kimmel break;
4059eb633035STom Caputi case 'w':
4060eb633035STom Caputi flags.raw = B_TRUE;
4061eb633035STom Caputi flags.compress = B_TRUE;
4062eb633035STom Caputi flags.embed_data = B_TRUE;
4063eb633035STom Caputi flags.largeblock = B_TRUE;
4064eb633035STom Caputi break;
4065fa9e4066Sahrens case ':':
40665c653870SPaul Dagnelie /*
40675c653870SPaul Dagnelie * If a parameter was not passed, optopt contains the
40685c653870SPaul Dagnelie * value that would normally lead us into the
40695c653870SPaul Dagnelie * appropriate case statement. If it's > 256, then this
40705c653870SPaul Dagnelie * must be a longopt and we should look at argv to get
40715c653870SPaul Dagnelie * the string. Otherwise it's just the character, so we
40725c653870SPaul Dagnelie * should use it directly.
40735c653870SPaul Dagnelie */
40745c653870SPaul Dagnelie if (optopt <= UINT8_MAX) {
40755c653870SPaul Dagnelie (void) fprintf(stderr,
40765c653870SPaul Dagnelie gettext("missing argument for '%c' "
40775c653870SPaul Dagnelie "option\n"), optopt);
40785c653870SPaul Dagnelie } else {
40795c653870SPaul Dagnelie (void) fprintf(stderr,
40805c653870SPaul Dagnelie gettext("missing argument for '%s' "
40815c653870SPaul Dagnelie "option\n"), argv[optind - 1]);
40825c653870SPaul Dagnelie }
408399653d4eSeschrock usage(B_FALSE);
4084fa9e4066Sahrens break;
4085fa9e4066Sahrens case '?':
40865602294fSDan Kimmel /*FALLTHROUGH*/
40875602294fSDan Kimmel default:
40885c653870SPaul Dagnelie /*
40895c653870SPaul Dagnelie * If an invalid flag was passed, optopt contains the
40905c653870SPaul Dagnelie * character if it was a short flag, or 0 if it was a
40915c653870SPaul Dagnelie * longopt.
40925c653870SPaul Dagnelie */
40935c653870SPaul Dagnelie if (optopt != 0) {
40945c653870SPaul Dagnelie (void) fprintf(stderr,
40955c653870SPaul Dagnelie gettext("invalid option '%c'\n"), optopt);
40965c653870SPaul Dagnelie } else {
40975c653870SPaul Dagnelie (void) fprintf(stderr,
40985c653870SPaul Dagnelie gettext("invalid option '%s'\n"),
40995c653870SPaul Dagnelie argv[optind - 1]);
41005c653870SPaul Dagnelie
41015c653870SPaul Dagnelie }
410299653d4eSeschrock usage(B_FALSE);
4103fa9e4066Sahrens }
4104fa9e4066Sahrens }
4105fa9e4066Sahrens
4106fa9e4066Sahrens argc -= optind;
4107fa9e4066Sahrens argv += optind;
4108fa9e4066Sahrens
41099c3fd121SMatthew Ahrens if (resume_token != NULL) {
41109c3fd121SMatthew Ahrens if (fromname != NULL || flags.replicate || flags.props ||
41116ccda740Sloli flags.backup || flags.dedup) {
41129c3fd121SMatthew Ahrens (void) fprintf(stderr,
41139c3fd121SMatthew Ahrens gettext("invalid flags combined with -t\n"));
41149c3fd121SMatthew Ahrens usage(B_FALSE);
41159c3fd121SMatthew Ahrens }
41169c3fd121SMatthew Ahrens if (argc != 0) {
41179c3fd121SMatthew Ahrens (void) fprintf(stderr, gettext("no additional "
41189c3fd121SMatthew Ahrens "arguments are permitted with -t\n"));
41199c3fd121SMatthew Ahrens usage(B_FALSE);
41209c3fd121SMatthew Ahrens }
41219c3fd121SMatthew Ahrens } else {
41229c3fd121SMatthew Ahrens if (argc < 1) {
41239c3fd121SMatthew Ahrens (void) fprintf(stderr,
41249c3fd121SMatthew Ahrens gettext("missing snapshot argument\n"));
41259c3fd121SMatthew Ahrens usage(B_FALSE);
41269c3fd121SMatthew Ahrens }
41279c3fd121SMatthew Ahrens if (argc > 1) {
41289c3fd121SMatthew Ahrens (void) fprintf(stderr, gettext("too many arguments\n"));
41299c3fd121SMatthew Ahrens usage(B_FALSE);
41309c3fd121SMatthew Ahrens }
4131fa9e4066Sahrens }
4132fa9e4066Sahrens
413319b94df9SMatthew Ahrens if (!flags.dryrun && isatty(STDOUT_FILENO)) {
4134fa9e4066Sahrens (void) fprintf(stderr,
4135a2eea2e1Sahrens gettext("Error: Stream can not be written to a terminal.\n"
4136b1b8ab34Slling "You must redirect standard output.\n"));
4137fa9e4066Sahrens return (1);
4138fa9e4066Sahrens }
4139fa9e4066Sahrens
41409c3fd121SMatthew Ahrens if (resume_token != NULL) {
41419c3fd121SMatthew Ahrens return (zfs_send_resume(g_zfs, &flags, STDOUT_FILENO,
41429c3fd121SMatthew Ahrens resume_token));
41439c3fd121SMatthew Ahrens }
41449c3fd121SMatthew Ahrens
414578f17100SMatthew Ahrens /*
414678f17100SMatthew Ahrens * Special case sending a filesystem, or from a bookmark.
414778f17100SMatthew Ahrens */
414878f17100SMatthew Ahrens if (strchr(argv[0], '@') == NULL ||
414978f17100SMatthew Ahrens (fromname && strchr(fromname, '#') != NULL)) {
41509adfa60dSMatthew Ahrens char frombuf[ZFS_MAX_DATASET_NAME_LEN];
41515d7b4d43SMatthew Ahrens enum lzc_send_flags lzc_flags = 0;
415278f17100SMatthew Ahrens
415378f17100SMatthew Ahrens if (flags.replicate || flags.doall || flags.props ||
41546ccda740Sloli flags.backup || flags.dedup || flags.holds ||
41556ccda740Sloli flags.dryrun || flags.verbose || flags.progress) {
415678f17100SMatthew Ahrens (void) fprintf(stderr,
415778f17100SMatthew Ahrens gettext("Error: "
415878f17100SMatthew Ahrens "Unsupported flag with filesystem or bookmark.\n"));
415978f17100SMatthew Ahrens return (1);
416078f17100SMatthew Ahrens }
416178f17100SMatthew Ahrens
416278f17100SMatthew Ahrens zhp = zfs_open(g_zfs, argv[0], ZFS_TYPE_DATASET);
416378f17100SMatthew Ahrens if (zhp == NULL)
416478f17100SMatthew Ahrens return (1);
416578f17100SMatthew Ahrens
4166b5152584SMatthew Ahrens if (flags.largeblock)
4167b5152584SMatthew Ahrens lzc_flags |= LZC_SEND_FLAG_LARGE_BLOCK;
41685d7b4d43SMatthew Ahrens if (flags.embed_data)
41695d7b4d43SMatthew Ahrens lzc_flags |= LZC_SEND_FLAG_EMBED_DATA;
41705602294fSDan Kimmel if (flags.compress)
41715602294fSDan Kimmel lzc_flags |= LZC_SEND_FLAG_COMPRESS;
4172eb633035STom Caputi if (flags.raw)
4173eb633035STom Caputi lzc_flags |= LZC_SEND_FLAG_RAW;
41745d7b4d43SMatthew Ahrens
417578f17100SMatthew Ahrens if (fromname != NULL &&
417678f17100SMatthew Ahrens (fromname[0] == '#' || fromname[0] == '@')) {
417778f17100SMatthew Ahrens /*
417878f17100SMatthew Ahrens * Incremental source name begins with # or @.
417978f17100SMatthew Ahrens * Default to same fs as target.
418078f17100SMatthew Ahrens */
41813382f241Sluozhengzheng (void) strlcpy(frombuf, argv[0], sizeof (frombuf));
418278f17100SMatthew Ahrens cp = strchr(frombuf, '@');
418378f17100SMatthew Ahrens if (cp != NULL)
418478f17100SMatthew Ahrens *cp = '\0';
418578f17100SMatthew Ahrens (void) strlcat(frombuf, fromname, sizeof (frombuf));
418678f17100SMatthew Ahrens fromname = frombuf;
418778f17100SMatthew Ahrens }
41885d7b4d43SMatthew Ahrens err = zfs_send_one(zhp, fromname, STDOUT_FILENO, lzc_flags);
418978f17100SMatthew Ahrens zfs_close(zhp);
419078f17100SMatthew Ahrens return (err != 0);
41913cb34c60Sahrens }
419278f17100SMatthew Ahrens
419378f17100SMatthew Ahrens cp = strchr(argv[0], '@');
41941af68beaSAlexander Stetsenko *cp = '\0';
41951af68beaSAlexander Stetsenko toname = cp + 1;
41961af68beaSAlexander Stetsenko zhp = zfs_open(g_zfs, argv[0], ZFS_TYPE_FILESYSTEM | ZFS_TYPE_VOLUME);
41971af68beaSAlexander Stetsenko if (zhp == NULL)
41981af68beaSAlexander Stetsenko return (1);
41991af68beaSAlexander Stetsenko
42001af68beaSAlexander Stetsenko /*
42011af68beaSAlexander Stetsenko * If they specified the full path to the snapshot, chop off
42021af68beaSAlexander Stetsenko * everything except the short name of the snapshot, but special
42031af68beaSAlexander Stetsenko * case if they specify the origin.
42041af68beaSAlexander Stetsenko */
42051af68beaSAlexander Stetsenko if (fromname && (cp = strchr(fromname, '@')) != NULL) {
42069adfa60dSMatthew Ahrens char origin[ZFS_MAX_DATASET_NAME_LEN];
42071af68beaSAlexander Stetsenko zprop_source_t src;
42081af68beaSAlexander Stetsenko
42091af68beaSAlexander Stetsenko (void) zfs_prop_get(zhp, ZFS_PROP_ORIGIN,
42101af68beaSAlexander Stetsenko origin, sizeof (origin), &src, NULL, 0, B_FALSE);
42111af68beaSAlexander Stetsenko
42121af68beaSAlexander Stetsenko if (strcmp(origin, fromname) == 0) {
42131af68beaSAlexander Stetsenko fromname = NULL;
42141af68beaSAlexander Stetsenko flags.fromorigin = B_TRUE;
42151af68beaSAlexander Stetsenko } else {
42161af68beaSAlexander Stetsenko *cp = '\0';
42171af68beaSAlexander Stetsenko if (cp != fromname && strcmp(argv[0], fromname)) {
42181af68beaSAlexander Stetsenko (void) fprintf(stderr,
42191af68beaSAlexander Stetsenko gettext("incremental source must be "
42201af68beaSAlexander Stetsenko "in same filesystem\n"));
42211af68beaSAlexander Stetsenko usage(B_FALSE);
42221af68beaSAlexander Stetsenko }
42231af68beaSAlexander Stetsenko fromname = cp + 1;
42241af68beaSAlexander Stetsenko if (strchr(fromname, '@') || strchr(fromname, '/')) {
42251af68beaSAlexander Stetsenko (void) fprintf(stderr,
42261af68beaSAlexander Stetsenko gettext("invalid incremental source\n"));
42271af68beaSAlexander Stetsenko usage(B_FALSE);
42281af68beaSAlexander Stetsenko }
42291af68beaSAlexander Stetsenko }
42301af68beaSAlexander Stetsenko }
42311af68beaSAlexander Stetsenko
42321af68beaSAlexander Stetsenko if (flags.replicate && fromname == NULL)
42331af68beaSAlexander Stetsenko flags.doall = B_TRUE;
42341af68beaSAlexander Stetsenko
423519b94df9SMatthew Ahrens err = zfs_send(zhp, fromname, toname, &flags, STDOUT_FILENO, NULL, 0,
42361af68beaSAlexander Stetsenko extraverbose ? &dbgnv : NULL);
42371af68beaSAlexander Stetsenko
423819b94df9SMatthew Ahrens if (extraverbose && dbgnv != NULL) {
42391af68beaSAlexander Stetsenko /*
42401af68beaSAlexander Stetsenko * dump_nvlist prints to stdout, but that's been
42411af68beaSAlexander Stetsenko * redirected to a file. Make it print to stderr
42421af68beaSAlexander Stetsenko * instead.
42431af68beaSAlexander Stetsenko */
42441af68beaSAlexander Stetsenko (void) dup2(STDERR_FILENO, STDOUT_FILENO);
42451af68beaSAlexander Stetsenko dump_nvlist(dbgnv, 0);
42461af68beaSAlexander Stetsenko nvlist_free(dbgnv);
42471af68beaSAlexander Stetsenko }
42481af68beaSAlexander Stetsenko zfs_close(zhp);
42491af68beaSAlexander Stetsenko
42501af68beaSAlexander Stetsenko return (err != 0);
42511af68beaSAlexander Stetsenko }
42521af68beaSAlexander Stetsenko
42531af68beaSAlexander Stetsenko /*
42541af68beaSAlexander Stetsenko * Restore a backup stream from stdin.
42551af68beaSAlexander Stetsenko */
42561af68beaSAlexander Stetsenko static int
zfs_do_receive(int argc,char ** argv)42571af68beaSAlexander Stetsenko zfs_do_receive(int argc, char **argv)
42581af68beaSAlexander Stetsenko {
4259c16bcc45SIgor Kozhukhov int c, err = 0;
42601af68beaSAlexander Stetsenko recvflags_t flags = { 0 };
42619c3fd121SMatthew Ahrens boolean_t abort_resumable = B_FALSE;
4262a2cdcdd2SPaul Dagnelie nvlist_t *props;
4263a2cdcdd2SPaul Dagnelie
4264a2cdcdd2SPaul Dagnelie if (nvlist_alloc(&props, NV_UNIQUE_NAME, 0) != 0)
4265a2cdcdd2SPaul Dagnelie nomem();
42661af68beaSAlexander Stetsenko
42671af68beaSAlexander Stetsenko /* check options */
42686ccda740Sloli while ((c = getopt(argc, argv, ":o:x:dehnuvFsA")) != -1) {
42691af68beaSAlexander Stetsenko switch (c) {
4270a2cdcdd2SPaul Dagnelie case 'o':
42716ccda740Sloli if (!parseprop(props, optarg)) {
42726ccda740Sloli nvlist_free(props);
42736ccda740Sloli usage(B_FALSE);
42746ccda740Sloli }
42756ccda740Sloli break;
42766ccda740Sloli case 'x':
42776ccda740Sloli if (!parsepropname(props, optarg)) {
42786ccda740Sloli nvlist_free(props);
42796ccda740Sloli usage(B_FALSE);
42806ccda740Sloli }
4281a2cdcdd2SPaul Dagnelie break;
42821af68beaSAlexander Stetsenko case 'd':
42831af68beaSAlexander Stetsenko flags.isprefix = B_TRUE;
42841af68beaSAlexander Stetsenko break;
42851af68beaSAlexander Stetsenko case 'e':
42861af68beaSAlexander Stetsenko flags.isprefix = B_TRUE;
42871af68beaSAlexander Stetsenko flags.istail = B_TRUE;
42881af68beaSAlexander Stetsenko break;
42896ccda740Sloli case 'h':
42906ccda740Sloli flags.skipholds = B_TRUE;
42916ccda740Sloli break;
42921af68beaSAlexander Stetsenko case 'n':
42931af68beaSAlexander Stetsenko flags.dryrun = B_TRUE;
42941af68beaSAlexander Stetsenko break;
42951af68beaSAlexander Stetsenko case 'u':
42961af68beaSAlexander Stetsenko flags.nomount = B_TRUE;
42971af68beaSAlexander Stetsenko break;
42981af68beaSAlexander Stetsenko case 'v':
42991af68beaSAlexander Stetsenko flags.verbose = B_TRUE;
43001af68beaSAlexander Stetsenko break;
43019c3fd121SMatthew Ahrens case 's':
43029c3fd121SMatthew Ahrens flags.resumable = B_TRUE;
43039c3fd121SMatthew Ahrens break;
43041af68beaSAlexander Stetsenko case 'F':
43051af68beaSAlexander Stetsenko flags.force = B_TRUE;
43061af68beaSAlexander Stetsenko break;
43079c3fd121SMatthew Ahrens case 'A':
43089c3fd121SMatthew Ahrens abort_resumable = B_TRUE;
43099c3fd121SMatthew Ahrens break;
43101af68beaSAlexander Stetsenko case ':':
43111af68beaSAlexander Stetsenko (void) fprintf(stderr, gettext("missing argument for "
43121af68beaSAlexander Stetsenko "'%c' option\n"), optopt);
43131af68beaSAlexander Stetsenko usage(B_FALSE);
43141af68beaSAlexander Stetsenko break;
43151af68beaSAlexander Stetsenko case '?':
43161af68beaSAlexander Stetsenko (void) fprintf(stderr, gettext("invalid option '%c'\n"),
43171af68beaSAlexander Stetsenko optopt);
43181af68beaSAlexander Stetsenko usage(B_FALSE);
43191af68beaSAlexander Stetsenko }
43201af68beaSAlexander Stetsenko }
43211af68beaSAlexander Stetsenko
43221af68beaSAlexander Stetsenko argc -= optind;
43231af68beaSAlexander Stetsenko argv += optind;
43241af68beaSAlexander Stetsenko
43251af68beaSAlexander Stetsenko /* check number of arguments */
43261af68beaSAlexander Stetsenko if (argc < 1) {
43271af68beaSAlexander Stetsenko (void) fprintf(stderr, gettext("missing snapshot argument\n"));
43281af68beaSAlexander Stetsenko usage(B_FALSE);
43291af68beaSAlexander Stetsenko }
43301af68beaSAlexander Stetsenko if (argc > 1) {
43311af68beaSAlexander Stetsenko (void) fprintf(stderr, gettext("too many arguments\n"));
43321af68beaSAlexander Stetsenko usage(B_FALSE);
43331af68beaSAlexander Stetsenko }
43341af68beaSAlexander Stetsenko
43359c3fd121SMatthew Ahrens if (abort_resumable) {
43369c3fd121SMatthew Ahrens if (flags.isprefix || flags.istail || flags.dryrun ||
43379c3fd121SMatthew Ahrens flags.resumable || flags.nomount) {
43389c3fd121SMatthew Ahrens (void) fprintf(stderr, gettext("invalid option"));
43399c3fd121SMatthew Ahrens usage(B_FALSE);
43409c3fd121SMatthew Ahrens }
43419c3fd121SMatthew Ahrens
43429adfa60dSMatthew Ahrens char namebuf[ZFS_MAX_DATASET_NAME_LEN];
43439c3fd121SMatthew Ahrens (void) snprintf(namebuf, sizeof (namebuf),
43449c3fd121SMatthew Ahrens "%s/%%recv", argv[0]);
43459c3fd121SMatthew Ahrens
43469c3fd121SMatthew Ahrens if (zfs_dataset_exists(g_zfs, namebuf,
43479c3fd121SMatthew Ahrens ZFS_TYPE_FILESYSTEM | ZFS_TYPE_VOLUME)) {
43489c3fd121SMatthew Ahrens zfs_handle_t *zhp = zfs_open(g_zfs,
43499c3fd121SMatthew Ahrens namebuf, ZFS_TYPE_FILESYSTEM | ZFS_TYPE_VOLUME);
43509c3fd121SMatthew Ahrens if (zhp == NULL)
43519c3fd121SMatthew Ahrens return (1);
43529c3fd121SMatthew Ahrens err = zfs_destroy(zhp, B_FALSE);
43539c3fd121SMatthew Ahrens } else {
43549c3fd121SMatthew Ahrens zfs_handle_t *zhp = zfs_open(g_zfs,
43559c3fd121SMatthew Ahrens argv[0], ZFS_TYPE_FILESYSTEM | ZFS_TYPE_VOLUME);
43569c3fd121SMatthew Ahrens if (zhp == NULL)
43579c3fd121SMatthew Ahrens usage(B_FALSE);
43589c3fd121SMatthew Ahrens if (!zfs_prop_get_int(zhp, ZFS_PROP_INCONSISTENT) ||
43599c3fd121SMatthew Ahrens zfs_prop_get(zhp, ZFS_PROP_RECEIVE_RESUME_TOKEN,
43609c3fd121SMatthew Ahrens NULL, 0, NULL, NULL, 0, B_TRUE) == -1) {
43619c3fd121SMatthew Ahrens (void) fprintf(stderr,
43629c3fd121SMatthew Ahrens gettext("'%s' does not have any "
43639c3fd121SMatthew Ahrens "resumable receive state to abort\n"),
43649c3fd121SMatthew Ahrens argv[0]);
43659c3fd121SMatthew Ahrens return (1);
43669c3fd121SMatthew Ahrens }
43679c3fd121SMatthew Ahrens err = zfs_destroy(zhp, B_FALSE);
43689c3fd121SMatthew Ahrens }
43699c3fd121SMatthew Ahrens
43709c3fd121SMatthew Ahrens return (err != 0);
43719c3fd121SMatthew Ahrens }
43729c3fd121SMatthew Ahrens
43731af68beaSAlexander Stetsenko if (isatty(STDIN_FILENO)) {
43741af68beaSAlexander Stetsenko (void) fprintf(stderr,
43751af68beaSAlexander Stetsenko gettext("Error: Backup stream can not be read "
43761af68beaSAlexander Stetsenko "from a terminal.\n"
43771af68beaSAlexander Stetsenko "You must redirect standard input.\n"));
43781af68beaSAlexander Stetsenko return (1);
43791af68beaSAlexander Stetsenko }
4380a2cdcdd2SPaul Dagnelie err = zfs_receive(g_zfs, argv[0], props, &flags, STDIN_FILENO, NULL);
43811af68beaSAlexander Stetsenko
43821af68beaSAlexander Stetsenko return (err != 0);
43831af68beaSAlexander Stetsenko }
43841af68beaSAlexander Stetsenko
43851af68beaSAlexander Stetsenko /*
43861af68beaSAlexander Stetsenko * allow/unallow stuff
43871af68beaSAlexander Stetsenko */
43881af68beaSAlexander Stetsenko /* copied from zfs/sys/dsl_deleg.h */
43891af68beaSAlexander Stetsenko #define ZFS_DELEG_PERM_CREATE "create"
43901af68beaSAlexander Stetsenko #define ZFS_DELEG_PERM_DESTROY "destroy"
43911af68beaSAlexander Stetsenko #define ZFS_DELEG_PERM_SNAPSHOT "snapshot"
43921af68beaSAlexander Stetsenko #define ZFS_DELEG_PERM_ROLLBACK "rollback"
43931af68beaSAlexander Stetsenko #define ZFS_DELEG_PERM_CLONE "clone"
43941af68beaSAlexander Stetsenko #define ZFS_DELEG_PERM_PROMOTE "promote"
43951af68beaSAlexander Stetsenko #define ZFS_DELEG_PERM_RENAME "rename"
43961af68beaSAlexander Stetsenko #define ZFS_DELEG_PERM_MOUNT "mount"
43971af68beaSAlexander Stetsenko #define ZFS_DELEG_PERM_SHARE "share"
43981af68beaSAlexander Stetsenko #define ZFS_DELEG_PERM_SEND "send"
43991af68beaSAlexander Stetsenko #define ZFS_DELEG_PERM_RECEIVE "receive"
44001af68beaSAlexander Stetsenko #define ZFS_DELEG_PERM_ALLOW "allow"
44011af68beaSAlexander Stetsenko #define ZFS_DELEG_PERM_USERPROP "userprop"
44021af68beaSAlexander Stetsenko #define ZFS_DELEG_PERM_VSCAN "vscan" /* ??? */
44031af68beaSAlexander Stetsenko #define ZFS_DELEG_PERM_USERQUOTA "userquota"
44041af68beaSAlexander Stetsenko #define ZFS_DELEG_PERM_GROUPQUOTA "groupquota"
44051af68beaSAlexander Stetsenko #define ZFS_DELEG_PERM_USERUSED "userused"
44061af68beaSAlexander Stetsenko #define ZFS_DELEG_PERM_GROUPUSED "groupused"
4407f67950b2SNasf-Fan #define ZFS_DELEG_PERM_USEROBJQUOTA "userobjquota"
4408f67950b2SNasf-Fan #define ZFS_DELEG_PERM_GROUPOBJQUOTA "groupobjquota"
4409f67950b2SNasf-Fan #define ZFS_DELEG_PERM_USEROBJUSED "userobjused"
4410f67950b2SNasf-Fan #define ZFS_DELEG_PERM_GROUPOBJUSED "groupobjused"
4411f67950b2SNasf-Fan
44121af68beaSAlexander Stetsenko #define ZFS_DELEG_PERM_HOLD "hold"
44131af68beaSAlexander Stetsenko #define ZFS_DELEG_PERM_RELEASE "release"
44141af68beaSAlexander Stetsenko #define ZFS_DELEG_PERM_DIFF "diff"
441578f17100SMatthew Ahrens #define ZFS_DELEG_PERM_BOOKMARK "bookmark"
44165cabbc6bSPrashanth Sreenivasa #define ZFS_DELEG_PERM_REMAP "remap"
4417eb633035STom Caputi #define ZFS_DELEG_PERM_LOAD_KEY "load-key"
4418eb633035STom Caputi #define ZFS_DELEG_PERM_CHANGE_KEY "change-key"
44191af68beaSAlexander Stetsenko
4420f67950b2SNasf-Fan #define ZFS_DELEG_PERM_PROJECTUSED "projectused"
4421f67950b2SNasf-Fan #define ZFS_DELEG_PERM_PROJECTQUOTA "projectquota"
4422f67950b2SNasf-Fan #define ZFS_DELEG_PERM_PROJECTOBJUSED "projectobjused"
4423f67950b2SNasf-Fan #define ZFS_DELEG_PERM_PROJECTOBJQUOTA "projectobjquota"
4424f67950b2SNasf-Fan
44251af68beaSAlexander Stetsenko #define ZFS_NUM_DELEG_NOTES ZFS_DELEG_NOTE_NONE
44261af68beaSAlexander Stetsenko
44271af68beaSAlexander Stetsenko static zfs_deleg_perm_tab_t zfs_deleg_perm_tbl[] = {
44281af68beaSAlexander Stetsenko { ZFS_DELEG_PERM_ALLOW, ZFS_DELEG_NOTE_ALLOW },
44291af68beaSAlexander Stetsenko { ZFS_DELEG_PERM_CLONE, ZFS_DELEG_NOTE_CLONE },
44301af68beaSAlexander Stetsenko { ZFS_DELEG_PERM_CREATE, ZFS_DELEG_NOTE_CREATE },
44311af68beaSAlexander Stetsenko { ZFS_DELEG_PERM_DESTROY, ZFS_DELEG_NOTE_DESTROY },
44321af68beaSAlexander Stetsenko { ZFS_DELEG_PERM_DIFF, ZFS_DELEG_NOTE_DIFF},
44331af68beaSAlexander Stetsenko { ZFS_DELEG_PERM_HOLD, ZFS_DELEG_NOTE_HOLD },
44341af68beaSAlexander Stetsenko { ZFS_DELEG_PERM_MOUNT, ZFS_DELEG_NOTE_MOUNT },
44351af68beaSAlexander Stetsenko { ZFS_DELEG_PERM_PROMOTE, ZFS_DELEG_NOTE_PROMOTE },
44361af68beaSAlexander Stetsenko { ZFS_DELEG_PERM_RECEIVE, ZFS_DELEG_NOTE_RECEIVE },
44371af68beaSAlexander Stetsenko { ZFS_DELEG_PERM_RELEASE, ZFS_DELEG_NOTE_RELEASE },
44381af68beaSAlexander Stetsenko { ZFS_DELEG_PERM_RENAME, ZFS_DELEG_NOTE_RENAME },
44391af68beaSAlexander Stetsenko { ZFS_DELEG_PERM_ROLLBACK, ZFS_DELEG_NOTE_ROLLBACK },
44401af68beaSAlexander Stetsenko { ZFS_DELEG_PERM_SEND, ZFS_DELEG_NOTE_SEND },
44411af68beaSAlexander Stetsenko { ZFS_DELEG_PERM_SHARE, ZFS_DELEG_NOTE_SHARE },
44421af68beaSAlexander Stetsenko { ZFS_DELEG_PERM_SNAPSHOT, ZFS_DELEG_NOTE_SNAPSHOT },
444378f17100SMatthew Ahrens { ZFS_DELEG_PERM_BOOKMARK, ZFS_DELEG_NOTE_BOOKMARK },
44445cabbc6bSPrashanth Sreenivasa { ZFS_DELEG_PERM_REMAP, ZFS_DELEG_NOTE_REMAP },
4445eb633035STom Caputi { ZFS_DELEG_PERM_LOAD_KEY, ZFS_DELEG_NOTE_LOAD_KEY },
4446eb633035STom Caputi { ZFS_DELEG_PERM_CHANGE_KEY, ZFS_DELEG_NOTE_CHANGE_KEY },
44471af68beaSAlexander Stetsenko
44481af68beaSAlexander Stetsenko { ZFS_DELEG_PERM_GROUPQUOTA, ZFS_DELEG_NOTE_GROUPQUOTA },
44491af68beaSAlexander Stetsenko { ZFS_DELEG_PERM_GROUPUSED, ZFS_DELEG_NOTE_GROUPUSED },
44501af68beaSAlexander Stetsenko { ZFS_DELEG_PERM_USERPROP, ZFS_DELEG_NOTE_USERPROP },
44511af68beaSAlexander Stetsenko { ZFS_DELEG_PERM_USERQUOTA, ZFS_DELEG_NOTE_USERQUOTA },
44521af68beaSAlexander Stetsenko { ZFS_DELEG_PERM_USERUSED, ZFS_DELEG_NOTE_USERUSED },
4453f67950b2SNasf-Fan { ZFS_DELEG_PERM_USEROBJQUOTA, ZFS_DELEG_NOTE_USEROBJQUOTA },
4454f67950b2SNasf-Fan { ZFS_DELEG_PERM_USEROBJUSED, ZFS_DELEG_NOTE_USEROBJUSED },
4455f67950b2SNasf-Fan { ZFS_DELEG_PERM_GROUPOBJQUOTA, ZFS_DELEG_NOTE_GROUPOBJQUOTA },
4456f67950b2SNasf-Fan { ZFS_DELEG_PERM_GROUPOBJUSED, ZFS_DELEG_NOTE_GROUPOBJUSED },
4457f67950b2SNasf-Fan { ZFS_DELEG_PERM_PROJECTUSED, ZFS_DELEG_NOTE_PROJECTUSED },
4458f67950b2SNasf-Fan { ZFS_DELEG_PERM_PROJECTQUOTA, ZFS_DELEG_NOTE_PROJECTQUOTA },
4459f67950b2SNasf-Fan { ZFS_DELEG_PERM_PROJECTOBJUSED, ZFS_DELEG_NOTE_PROJECTOBJUSED },
4460f67950b2SNasf-Fan { ZFS_DELEG_PERM_PROJECTOBJQUOTA, ZFS_DELEG_NOTE_PROJECTOBJQUOTA },
44611af68beaSAlexander Stetsenko { NULL, ZFS_DELEG_NOTE_NONE }
44621af68beaSAlexander Stetsenko };
44631af68beaSAlexander Stetsenko
44641af68beaSAlexander Stetsenko /* permission structure */
44651af68beaSAlexander Stetsenko typedef struct deleg_perm {
44661af68beaSAlexander Stetsenko zfs_deleg_who_type_t dp_who_type;
44671af68beaSAlexander Stetsenko const char *dp_name;
44681af68beaSAlexander Stetsenko boolean_t dp_local;
44691af68beaSAlexander Stetsenko boolean_t dp_descend;
44701af68beaSAlexander Stetsenko } deleg_perm_t;
44711af68beaSAlexander Stetsenko
44721af68beaSAlexander Stetsenko /* */
44731af68beaSAlexander Stetsenko typedef struct deleg_perm_node {
44741af68beaSAlexander Stetsenko deleg_perm_t dpn_perm;
44751af68beaSAlexander Stetsenko
44761af68beaSAlexander Stetsenko uu_avl_node_t dpn_avl_node;
44771af68beaSAlexander Stetsenko } deleg_perm_node_t;
44781af68beaSAlexander Stetsenko
44791af68beaSAlexander Stetsenko typedef struct fs_perm fs_perm_t;
44801af68beaSAlexander Stetsenko
44811af68beaSAlexander Stetsenko /* permissions set */
44821af68beaSAlexander Stetsenko typedef struct who_perm {
44831af68beaSAlexander Stetsenko zfs_deleg_who_type_t who_type;
44841af68beaSAlexander Stetsenko const char *who_name; /* id */
44851af68beaSAlexander Stetsenko char who_ug_name[256]; /* user/group name */
44861af68beaSAlexander Stetsenko fs_perm_t *who_fsperm; /* uplink */
44871af68beaSAlexander Stetsenko
44881af68beaSAlexander Stetsenko uu_avl_t *who_deleg_perm_avl; /* permissions */
44891af68beaSAlexander Stetsenko } who_perm_t;
44901af68beaSAlexander Stetsenko
44911af68beaSAlexander Stetsenko /* */
44921af68beaSAlexander Stetsenko typedef struct who_perm_node {
44931af68beaSAlexander Stetsenko who_perm_t who_perm;
44941af68beaSAlexander Stetsenko uu_avl_node_t who_avl_node;
44951af68beaSAlexander Stetsenko } who_perm_node_t;
44961af68beaSAlexander Stetsenko
44971af68beaSAlexander Stetsenko typedef struct fs_perm_set fs_perm_set_t;
44981af68beaSAlexander Stetsenko /* fs permissions */
44991af68beaSAlexander Stetsenko struct fs_perm {
45001af68beaSAlexander Stetsenko const char *fsp_name;
45011af68beaSAlexander Stetsenko
45021af68beaSAlexander Stetsenko uu_avl_t *fsp_sc_avl; /* sets,create */
45031af68beaSAlexander Stetsenko uu_avl_t *fsp_uge_avl; /* user,group,everyone */
45041af68beaSAlexander Stetsenko
45051af68beaSAlexander Stetsenko fs_perm_set_t *fsp_set; /* uplink */
45061af68beaSAlexander Stetsenko };
45071af68beaSAlexander Stetsenko
45081af68beaSAlexander Stetsenko /* */
45091af68beaSAlexander Stetsenko typedef struct fs_perm_node {
45101af68beaSAlexander Stetsenko fs_perm_t fspn_fsperm;
45111af68beaSAlexander Stetsenko uu_avl_t *fspn_avl;
45121af68beaSAlexander Stetsenko
45131af68beaSAlexander Stetsenko uu_list_node_t fspn_list_node;
45141af68beaSAlexander Stetsenko } fs_perm_node_t;
45151af68beaSAlexander Stetsenko
45161af68beaSAlexander Stetsenko /* top level structure */
45171af68beaSAlexander Stetsenko struct fs_perm_set {
45181af68beaSAlexander Stetsenko uu_list_pool_t *fsps_list_pool;
45191af68beaSAlexander Stetsenko uu_list_t *fsps_list; /* list of fs_perms */
45201af68beaSAlexander Stetsenko
45211af68beaSAlexander Stetsenko uu_avl_pool_t *fsps_named_set_avl_pool;
45221af68beaSAlexander Stetsenko uu_avl_pool_t *fsps_who_perm_avl_pool;
45231af68beaSAlexander Stetsenko uu_avl_pool_t *fsps_deleg_perm_avl_pool;
45241af68beaSAlexander Stetsenko };
45251af68beaSAlexander Stetsenko
45261af68beaSAlexander Stetsenko static inline const char *
deleg_perm_type(zfs_deleg_note_t note)45271af68beaSAlexander Stetsenko deleg_perm_type(zfs_deleg_note_t note)
45281af68beaSAlexander Stetsenko {
45291af68beaSAlexander Stetsenko /* subcommands */
45301af68beaSAlexander Stetsenko switch (note) {
45311af68beaSAlexander Stetsenko /* SUBCOMMANDS */
45321af68beaSAlexander Stetsenko /* OTHER */
45331af68beaSAlexander Stetsenko case ZFS_DELEG_NOTE_GROUPQUOTA:
45341af68beaSAlexander Stetsenko case ZFS_DELEG_NOTE_GROUPUSED:
45351af68beaSAlexander Stetsenko case ZFS_DELEG_NOTE_USERPROP:
45361af68beaSAlexander Stetsenko case ZFS_DELEG_NOTE_USERQUOTA:
45371af68beaSAlexander Stetsenko case ZFS_DELEG_NOTE_USERUSED:
4538f67950b2SNasf-Fan case ZFS_DELEG_NOTE_USEROBJQUOTA:
4539f67950b2SNasf-Fan case ZFS_DELEG_NOTE_USEROBJUSED:
4540f67950b2SNasf-Fan case ZFS_DELEG_NOTE_GROUPOBJQUOTA:
4541f67950b2SNasf-Fan case ZFS_DELEG_NOTE_GROUPOBJUSED:
4542f67950b2SNasf-Fan case ZFS_DELEG_NOTE_PROJECTUSED:
4543f67950b2SNasf-Fan case ZFS_DELEG_NOTE_PROJECTQUOTA:
4544f67950b2SNasf-Fan case ZFS_DELEG_NOTE_PROJECTOBJUSED:
4545f67950b2SNasf-Fan case ZFS_DELEG_NOTE_PROJECTOBJQUOTA:
45461af68beaSAlexander Stetsenko /* other */
45471af68beaSAlexander Stetsenko return (gettext("other"));
45481af68beaSAlexander Stetsenko default:
45491af68beaSAlexander Stetsenko return (gettext("subcommand"));
45501af68beaSAlexander Stetsenko }
45511af68beaSAlexander Stetsenko }
45521af68beaSAlexander Stetsenko
4553c16bcc45SIgor Kozhukhov static int
who_type2weight(zfs_deleg_who_type_t who_type)45541af68beaSAlexander Stetsenko who_type2weight(zfs_deleg_who_type_t who_type)
45551af68beaSAlexander Stetsenko {
45561af68beaSAlexander Stetsenko int res;
45571af68beaSAlexander Stetsenko switch (who_type) {
45581af68beaSAlexander Stetsenko case ZFS_DELEG_NAMED_SET_SETS:
45591af68beaSAlexander Stetsenko case ZFS_DELEG_NAMED_SET:
45601af68beaSAlexander Stetsenko res = 0;
45611af68beaSAlexander Stetsenko break;
45621af68beaSAlexander Stetsenko case ZFS_DELEG_CREATE_SETS:
45631af68beaSAlexander Stetsenko case ZFS_DELEG_CREATE:
45641af68beaSAlexander Stetsenko res = 1;
45651af68beaSAlexander Stetsenko break;
45661af68beaSAlexander Stetsenko case ZFS_DELEG_USER_SETS:
45671af68beaSAlexander Stetsenko case ZFS_DELEG_USER:
45681af68beaSAlexander Stetsenko res = 2;
45691af68beaSAlexander Stetsenko break;
45701af68beaSAlexander Stetsenko case ZFS_DELEG_GROUP_SETS:
45711af68beaSAlexander Stetsenko case ZFS_DELEG_GROUP:
45721af68beaSAlexander Stetsenko res = 3;
45731af68beaSAlexander Stetsenko break;
45741af68beaSAlexander Stetsenko case ZFS_DELEG_EVERYONE_SETS:
45751af68beaSAlexander Stetsenko case ZFS_DELEG_EVERYONE:
45761af68beaSAlexander Stetsenko res = 4;
45771af68beaSAlexander Stetsenko break;
45781af68beaSAlexander Stetsenko default:
45791af68beaSAlexander Stetsenko res = -1;
45801af68beaSAlexander Stetsenko }
45811af68beaSAlexander Stetsenko
45821af68beaSAlexander Stetsenko return (res);
45831af68beaSAlexander Stetsenko }
45841af68beaSAlexander Stetsenko
45851af68beaSAlexander Stetsenko /* ARGSUSED */
45861af68beaSAlexander Stetsenko static int
who_perm_compare(const void * larg,const void * rarg,void * unused)45871af68beaSAlexander Stetsenko who_perm_compare(const void *larg, const void *rarg, void *unused)
45881af68beaSAlexander Stetsenko {
45891af68beaSAlexander Stetsenko const who_perm_node_t *l = larg;
45901af68beaSAlexander Stetsenko const who_perm_node_t *r = rarg;
45911af68beaSAlexander Stetsenko zfs_deleg_who_type_t ltype = l->who_perm.who_type;
45921af68beaSAlexander Stetsenko zfs_deleg_who_type_t rtype = r->who_perm.who_type;
45931af68beaSAlexander Stetsenko int lweight = who_type2weight(ltype);
45941af68beaSAlexander Stetsenko int rweight = who_type2weight(rtype);
45951af68beaSAlexander Stetsenko int res = lweight - rweight;
45961af68beaSAlexander Stetsenko if (res == 0)
45971af68beaSAlexander Stetsenko res = strncmp(l->who_perm.who_name, r->who_perm.who_name,
45981af68beaSAlexander Stetsenko ZFS_MAX_DELEG_NAME-1);
45991af68beaSAlexander Stetsenko
46001af68beaSAlexander Stetsenko if (res == 0)
46011af68beaSAlexander Stetsenko return (0);
46021af68beaSAlexander Stetsenko if (res > 0)
46031af68beaSAlexander Stetsenko return (1);
46041af68beaSAlexander Stetsenko else
46051af68beaSAlexander Stetsenko return (-1);
46061af68beaSAlexander Stetsenko }
46071af68beaSAlexander Stetsenko
46081af68beaSAlexander Stetsenko /* ARGSUSED */
46091af68beaSAlexander Stetsenko static int
deleg_perm_compare(const void * larg,const void * rarg,void * unused)46101af68beaSAlexander Stetsenko deleg_perm_compare(const void *larg, const void *rarg, void *unused)
46111af68beaSAlexander Stetsenko {
46121af68beaSAlexander Stetsenko const deleg_perm_node_t *l = larg;
46131af68beaSAlexander Stetsenko const deleg_perm_node_t *r = rarg;
46141af68beaSAlexander Stetsenko int res = strncmp(l->dpn_perm.dp_name, r->dpn_perm.dp_name,
46151af68beaSAlexander Stetsenko ZFS_MAX_DELEG_NAME-1);
46161af68beaSAlexander Stetsenko
46171af68beaSAlexander Stetsenko if (res == 0)
46181af68beaSAlexander Stetsenko return (0);
46191af68beaSAlexander Stetsenko
46201af68beaSAlexander Stetsenko if (res > 0)
46211af68beaSAlexander Stetsenko return (1);
46221af68beaSAlexander Stetsenko else
46231af68beaSAlexander Stetsenko return (-1);
46241af68beaSAlexander Stetsenko }
46251af68beaSAlexander Stetsenko
46261af68beaSAlexander Stetsenko static inline void
fs_perm_set_init(fs_perm_set_t * fspset)46271af68beaSAlexander Stetsenko fs_perm_set_init(fs_perm_set_t *fspset)
46281af68beaSAlexander Stetsenko {
46291af68beaSAlexander Stetsenko bzero(fspset, sizeof (fs_perm_set_t));
46301af68beaSAlexander Stetsenko
46311af68beaSAlexander Stetsenko if ((fspset->fsps_list_pool = uu_list_pool_create("fsps_list_pool",
46321af68beaSAlexander Stetsenko sizeof (fs_perm_node_t), offsetof(fs_perm_node_t, fspn_list_node),
46331af68beaSAlexander Stetsenko NULL, UU_DEFAULT)) == NULL)
46341af68beaSAlexander Stetsenko nomem();
46351af68beaSAlexander Stetsenko if ((fspset->fsps_list = uu_list_create(fspset->fsps_list_pool, NULL,
46361af68beaSAlexander Stetsenko UU_DEFAULT)) == NULL)
46371af68beaSAlexander Stetsenko nomem();
46381af68beaSAlexander Stetsenko
46391af68beaSAlexander Stetsenko if ((fspset->fsps_named_set_avl_pool = uu_avl_pool_create(
46401af68beaSAlexander Stetsenko "named_set_avl_pool", sizeof (who_perm_node_t), offsetof(
46411af68beaSAlexander Stetsenko who_perm_node_t, who_avl_node), who_perm_compare,
46421af68beaSAlexander Stetsenko UU_DEFAULT)) == NULL)
46431af68beaSAlexander Stetsenko nomem();
46441af68beaSAlexander Stetsenko
46451af68beaSAlexander Stetsenko if ((fspset->fsps_who_perm_avl_pool = uu_avl_pool_create(
46461af68beaSAlexander Stetsenko "who_perm_avl_pool", sizeof (who_perm_node_t), offsetof(
46471af68beaSAlexander Stetsenko who_perm_node_t, who_avl_node), who_perm_compare,
46481af68beaSAlexander Stetsenko UU_DEFAULT)) == NULL)
46491af68beaSAlexander Stetsenko nomem();
46501af68beaSAlexander Stetsenko
46511af68beaSAlexander Stetsenko if ((fspset->fsps_deleg_perm_avl_pool = uu_avl_pool_create(
46521af68beaSAlexander Stetsenko "deleg_perm_avl_pool", sizeof (deleg_perm_node_t), offsetof(
46531af68beaSAlexander Stetsenko deleg_perm_node_t, dpn_avl_node), deleg_perm_compare, UU_DEFAULT))
46541af68beaSAlexander Stetsenko == NULL)
46551af68beaSAlexander Stetsenko nomem();
46561af68beaSAlexander Stetsenko }
46571af68beaSAlexander Stetsenko
46581af68beaSAlexander Stetsenko static inline void fs_perm_fini(fs_perm_t *);
46591af68beaSAlexander Stetsenko static inline void who_perm_fini(who_perm_t *);
46601af68beaSAlexander Stetsenko
46611af68beaSAlexander Stetsenko static inline void
fs_perm_set_fini(fs_perm_set_t * fspset)46621af68beaSAlexander Stetsenko fs_perm_set_fini(fs_perm_set_t *fspset)
46631af68beaSAlexander Stetsenko {
46641af68beaSAlexander Stetsenko fs_perm_node_t *node = uu_list_first(fspset->fsps_list);
46651af68beaSAlexander Stetsenko
46661af68beaSAlexander Stetsenko while (node != NULL) {
46671af68beaSAlexander Stetsenko fs_perm_node_t *next_node =
46681af68beaSAlexander Stetsenko uu_list_next(fspset->fsps_list, node);
46691af68beaSAlexander Stetsenko fs_perm_t *fsperm = &node->fspn_fsperm;
46701af68beaSAlexander Stetsenko fs_perm_fini(fsperm);
46711af68beaSAlexander Stetsenko uu_list_remove(fspset->fsps_list, node);
46721af68beaSAlexander Stetsenko free(node);
46731af68beaSAlexander Stetsenko node = next_node;
46741af68beaSAlexander Stetsenko }
46751af68beaSAlexander Stetsenko
46761af68beaSAlexander Stetsenko uu_avl_pool_destroy(fspset->fsps_named_set_avl_pool);
46771af68beaSAlexander Stetsenko uu_avl_pool_destroy(fspset->fsps_who_perm_avl_pool);
46781af68beaSAlexander Stetsenko uu_avl_pool_destroy(fspset->fsps_deleg_perm_avl_pool);
46791af68beaSAlexander Stetsenko }
46801af68beaSAlexander Stetsenko
46811af68beaSAlexander Stetsenko static inline void
deleg_perm_init(deleg_perm_t * deleg_perm,zfs_deleg_who_type_t type,const char * name)46821af68beaSAlexander Stetsenko deleg_perm_init(deleg_perm_t *deleg_perm, zfs_deleg_who_type_t type,
46831af68beaSAlexander Stetsenko const char *name)
46841af68beaSAlexander Stetsenko {
46851af68beaSAlexander Stetsenko deleg_perm->dp_who_type = type;
46861af68beaSAlexander Stetsenko deleg_perm->dp_name = name;
46871af68beaSAlexander Stetsenko }
46881af68beaSAlexander Stetsenko
46891af68beaSAlexander Stetsenko static inline void
who_perm_init(who_perm_t * who_perm,fs_perm_t * fsperm,zfs_deleg_who_type_t type,const char * name)46901af68beaSAlexander Stetsenko who_perm_init(who_perm_t *who_perm, fs_perm_t *fsperm,
46911af68beaSAlexander Stetsenko zfs_deleg_who_type_t type, const char *name)
46921af68beaSAlexander Stetsenko {
46931af68beaSAlexander Stetsenko uu_avl_pool_t *pool;
46941af68beaSAlexander Stetsenko pool = fsperm->fsp_set->fsps_deleg_perm_avl_pool;
46951af68beaSAlexander Stetsenko
46961af68beaSAlexander Stetsenko bzero(who_perm, sizeof (who_perm_t));
46971af68beaSAlexander Stetsenko
46981af68beaSAlexander Stetsenko if ((who_perm->who_deleg_perm_avl = uu_avl_create(pool, NULL,
46991af68beaSAlexander Stetsenko UU_DEFAULT)) == NULL)
47001af68beaSAlexander Stetsenko nomem();
47011af68beaSAlexander Stetsenko
47021af68beaSAlexander Stetsenko who_perm->who_type = type;
47031af68beaSAlexander Stetsenko who_perm->who_name = name;
47041af68beaSAlexander Stetsenko who_perm->who_fsperm = fsperm;
47051af68beaSAlexander Stetsenko }
47061af68beaSAlexander Stetsenko
47071af68beaSAlexander Stetsenko static inline void
who_perm_fini(who_perm_t * who_perm)47081af68beaSAlexander Stetsenko who_perm_fini(who_perm_t *who_perm)
47091af68beaSAlexander Stetsenko {
47101af68beaSAlexander Stetsenko deleg_perm_node_t *node = uu_avl_first(who_perm->who_deleg_perm_avl);
47111af68beaSAlexander Stetsenko
47121af68beaSAlexander Stetsenko while (node != NULL) {
47131af68beaSAlexander Stetsenko deleg_perm_node_t *next_node =
47141af68beaSAlexander Stetsenko uu_avl_next(who_perm->who_deleg_perm_avl, node);
47151af68beaSAlexander Stetsenko
47161af68beaSAlexander Stetsenko uu_avl_remove(who_perm->who_deleg_perm_avl, node);
47171af68beaSAlexander Stetsenko free(node);
47181af68beaSAlexander Stetsenko node = next_node;
47191af68beaSAlexander Stetsenko }
47201af68beaSAlexander Stetsenko
47211af68beaSAlexander Stetsenko uu_avl_destroy(who_perm->who_deleg_perm_avl);
47221af68beaSAlexander Stetsenko }
47231af68beaSAlexander Stetsenko
47241af68beaSAlexander Stetsenko static inline void
fs_perm_init(fs_perm_t * fsperm,fs_perm_set_t * fspset,const char * fsname)47251af68beaSAlexander Stetsenko fs_perm_init(fs_perm_t *fsperm, fs_perm_set_t *fspset, const char *fsname)
47261af68beaSAlexander Stetsenko {
47271af68beaSAlexander Stetsenko uu_avl_pool_t *nset_pool = fspset->fsps_named_set_avl_pool;
47281af68beaSAlexander Stetsenko uu_avl_pool_t *who_pool = fspset->fsps_who_perm_avl_pool;
47291af68beaSAlexander Stetsenko
47301af68beaSAlexander Stetsenko bzero(fsperm, sizeof (fs_perm_t));
47311af68beaSAlexander Stetsenko
47321af68beaSAlexander Stetsenko if ((fsperm->fsp_sc_avl = uu_avl_create(nset_pool, NULL, UU_DEFAULT))
47331af68beaSAlexander Stetsenko == NULL)
47341af68beaSAlexander Stetsenko nomem();
47351af68beaSAlexander Stetsenko
47361af68beaSAlexander Stetsenko if ((fsperm->fsp_uge_avl = uu_avl_create(who_pool, NULL, UU_DEFAULT))
47371af68beaSAlexander Stetsenko == NULL)
47381af68beaSAlexander Stetsenko nomem();
47391af68beaSAlexander Stetsenko
47401af68beaSAlexander Stetsenko fsperm->fsp_set = fspset;
47411af68beaSAlexander Stetsenko fsperm->fsp_name = fsname;
47421af68beaSAlexander Stetsenko }
47431af68beaSAlexander Stetsenko
47441af68beaSAlexander Stetsenko static inline void
fs_perm_fini(fs_perm_t * fsperm)47451af68beaSAlexander Stetsenko fs_perm_fini(fs_perm_t *fsperm)
47461af68beaSAlexander Stetsenko {
47471af68beaSAlexander Stetsenko who_perm_node_t *node = uu_avl_first(fsperm->fsp_sc_avl);
47481af68beaSAlexander Stetsenko while (node != NULL) {
47491af68beaSAlexander Stetsenko who_perm_node_t *next_node = uu_avl_next(fsperm->fsp_sc_avl,
47501af68beaSAlexander Stetsenko node);
47511af68beaSAlexander Stetsenko who_perm_t *who_perm = &node->who_perm;
47521af68beaSAlexander Stetsenko who_perm_fini(who_perm);
47531af68beaSAlexander Stetsenko uu_avl_remove(fsperm->fsp_sc_avl, node);
47541af68beaSAlexander Stetsenko free(node);
47551af68beaSAlexander Stetsenko node = next_node;
47561af68beaSAlexander Stetsenko }
47571af68beaSAlexander Stetsenko
47581af68beaSAlexander Stetsenko node = uu_avl_first(fsperm->fsp_uge_avl);
47591af68beaSAlexander Stetsenko while (node != NULL) {
47601af68beaSAlexander Stetsenko who_perm_node_t *next_node = uu_avl_next(fsperm->fsp_uge_avl,
47611af68beaSAlexander Stetsenko node);
47621af68beaSAlexander Stetsenko who_perm_t *who_perm = &node->who_perm;
47631af68beaSAlexander Stetsenko who_perm_fini(who_perm);
47641af68beaSAlexander Stetsenko uu_avl_remove(fsperm->fsp_uge_avl, node);
47651af68beaSAlexander Stetsenko free(node);
47661af68beaSAlexander Stetsenko node = next_node;
47671af68beaSAlexander Stetsenko }
47681af68beaSAlexander Stetsenko
47691af68beaSAlexander Stetsenko uu_avl_destroy(fsperm->fsp_sc_avl);
47701af68beaSAlexander Stetsenko uu_avl_destroy(fsperm->fsp_uge_avl);
47711af68beaSAlexander Stetsenko }
47721af68beaSAlexander Stetsenko
4773c16bcc45SIgor Kozhukhov static void
set_deleg_perm_node(uu_avl_t * avl,deleg_perm_node_t * node,zfs_deleg_who_type_t who_type,const char * name,char locality)47741af68beaSAlexander Stetsenko set_deleg_perm_node(uu_avl_t *avl, deleg_perm_node_t *node,
47751af68beaSAlexander Stetsenko zfs_deleg_who_type_t who_type, const char *name, char locality)
47761af68beaSAlexander Stetsenko {
47771af68beaSAlexander Stetsenko uu_avl_index_t idx = 0;
47781af68beaSAlexander Stetsenko
47791af68beaSAlexander Stetsenko deleg_perm_node_t *found_node = NULL;
47801af68beaSAlexander Stetsenko deleg_perm_t *deleg_perm = &node->dpn_perm;
47811af68beaSAlexander Stetsenko
47821af68beaSAlexander Stetsenko deleg_perm_init(deleg_perm, who_type, name);
47831af68beaSAlexander Stetsenko
47841af68beaSAlexander Stetsenko if ((found_node = uu_avl_find(avl, node, NULL, &idx))
47851af68beaSAlexander Stetsenko == NULL)
47861af68beaSAlexander Stetsenko uu_avl_insert(avl, node, idx);
47871af68beaSAlexander Stetsenko else {
47881af68beaSAlexander Stetsenko node = found_node;
47891af68beaSAlexander Stetsenko deleg_perm = &node->dpn_perm;
47901af68beaSAlexander Stetsenko }
47911af68beaSAlexander Stetsenko
47921af68beaSAlexander Stetsenko
47931af68beaSAlexander Stetsenko switch (locality) {
47941af68beaSAlexander Stetsenko case ZFS_DELEG_LOCAL:
47951af68beaSAlexander Stetsenko deleg_perm->dp_local = B_TRUE;
47961af68beaSAlexander Stetsenko break;
47971af68beaSAlexander Stetsenko case ZFS_DELEG_DESCENDENT:
47981af68beaSAlexander Stetsenko deleg_perm->dp_descend = B_TRUE;
47991af68beaSAlexander Stetsenko break;
48001af68beaSAlexander Stetsenko case ZFS_DELEG_NA:
48011af68beaSAlexander Stetsenko break;
48021af68beaSAlexander Stetsenko default:
48031af68beaSAlexander Stetsenko assert(B_FALSE); /* invalid locality */
48041af68beaSAlexander Stetsenko }
48051af68beaSAlexander Stetsenko }
48061af68beaSAlexander Stetsenko
48071af68beaSAlexander Stetsenko static inline int
parse_who_perm(who_perm_t * who_perm,nvlist_t * nvl,char locality)48081af68beaSAlexander Stetsenko parse_who_perm(who_perm_t *who_perm, nvlist_t *nvl, char locality)
48091af68beaSAlexander Stetsenko {
48101af68beaSAlexander Stetsenko nvpair_t *nvp = NULL;
48111af68beaSAlexander Stetsenko fs_perm_set_t *fspset = who_perm->who_fsperm->fsp_set;
48121af68beaSAlexander Stetsenko uu_avl_t *avl = who_perm->who_deleg_perm_avl;
48131af68beaSAlexander Stetsenko zfs_deleg_who_type_t who_type = who_perm->who_type;
48141af68beaSAlexander Stetsenko
48151af68beaSAlexander Stetsenko while ((nvp = nvlist_next_nvpair(nvl, nvp)) != NULL) {
48161af68beaSAlexander Stetsenko const char *name = nvpair_name(nvp);
48171af68beaSAlexander Stetsenko data_type_t type = nvpair_type(nvp);
48181af68beaSAlexander Stetsenko uu_avl_pool_t *avl_pool = fspset->fsps_deleg_perm_avl_pool;
48191af68beaSAlexander Stetsenko deleg_perm_node_t *node =
48201af68beaSAlexander Stetsenko safe_malloc(sizeof (deleg_perm_node_t));
48211af68beaSAlexander Stetsenko
48221af68beaSAlexander Stetsenko assert(type == DATA_TYPE_BOOLEAN);
48231af68beaSAlexander Stetsenko
48241af68beaSAlexander Stetsenko uu_avl_node_init(node, &node->dpn_avl_node, avl_pool);
48251af68beaSAlexander Stetsenko set_deleg_perm_node(avl, node, who_type, name, locality);
48261af68beaSAlexander Stetsenko }
48271af68beaSAlexander Stetsenko
48281af68beaSAlexander Stetsenko return (0);
48291af68beaSAlexander Stetsenko }
48301af68beaSAlexander Stetsenko
48311af68beaSAlexander Stetsenko static inline int
parse_fs_perm(fs_perm_t * fsperm,nvlist_t * nvl)48321af68beaSAlexander Stetsenko parse_fs_perm(fs_perm_t *fsperm, nvlist_t *nvl)
48331af68beaSAlexander Stetsenko {
48341af68beaSAlexander Stetsenko nvpair_t *nvp = NULL;
48351af68beaSAlexander Stetsenko fs_perm_set_t *fspset = fsperm->fsp_set;
48361af68beaSAlexander Stetsenko
48371af68beaSAlexander Stetsenko while ((nvp = nvlist_next_nvpair(nvl, nvp)) != NULL) {
48381af68beaSAlexander Stetsenko nvlist_t *nvl2 = NULL;
48391af68beaSAlexander Stetsenko const char *name = nvpair_name(nvp);
48401af68beaSAlexander Stetsenko uu_avl_t *avl = NULL;
4841c16bcc45SIgor Kozhukhov uu_avl_pool_t *avl_pool = NULL;
48421af68beaSAlexander Stetsenko zfs_deleg_who_type_t perm_type = name[0];
48431af68beaSAlexander Stetsenko char perm_locality = name[1];
48441af68beaSAlexander Stetsenko const char *perm_name = name + 3;
48451af68beaSAlexander Stetsenko boolean_t is_set = B_TRUE;
48461af68beaSAlexander Stetsenko who_perm_t *who_perm = NULL;
48471af68beaSAlexander Stetsenko
48481af68beaSAlexander Stetsenko assert('$' == name[2]);
48491af68beaSAlexander Stetsenko
48501af68beaSAlexander Stetsenko if (nvpair_value_nvlist(nvp, &nvl2) != 0)
48511af68beaSAlexander Stetsenko return (-1);
48521af68beaSAlexander Stetsenko
48531af68beaSAlexander Stetsenko switch (perm_type) {
48541af68beaSAlexander Stetsenko case ZFS_DELEG_CREATE:
48551af68beaSAlexander Stetsenko case ZFS_DELEG_CREATE_SETS:
48561af68beaSAlexander Stetsenko case ZFS_DELEG_NAMED_SET:
48571af68beaSAlexander Stetsenko case ZFS_DELEG_NAMED_SET_SETS:
48581af68beaSAlexander Stetsenko avl_pool = fspset->fsps_named_set_avl_pool;
48591af68beaSAlexander Stetsenko avl = fsperm->fsp_sc_avl;
48601af68beaSAlexander Stetsenko break;
48611af68beaSAlexander Stetsenko case ZFS_DELEG_USER:
48621af68beaSAlexander Stetsenko case ZFS_DELEG_USER_SETS:
48631af68beaSAlexander Stetsenko case ZFS_DELEG_GROUP:
48641af68beaSAlexander Stetsenko case ZFS_DELEG_GROUP_SETS:
48651af68beaSAlexander Stetsenko case ZFS_DELEG_EVERYONE:
48661af68beaSAlexander Stetsenko case ZFS_DELEG_EVERYONE_SETS:
48671af68beaSAlexander Stetsenko avl_pool = fspset->fsps_who_perm_avl_pool;
48681af68beaSAlexander Stetsenko avl = fsperm->fsp_uge_avl;
48691af68beaSAlexander Stetsenko break;
4870c16bcc45SIgor Kozhukhov
4871c16bcc45SIgor Kozhukhov default:
4872c16bcc45SIgor Kozhukhov assert(!"unhandled zfs_deleg_who_type_t");
48731af68beaSAlexander Stetsenko }
48741af68beaSAlexander Stetsenko
48751af68beaSAlexander Stetsenko if (is_set) {
48761af68beaSAlexander Stetsenko who_perm_node_t *found_node = NULL;
48771af68beaSAlexander Stetsenko who_perm_node_t *node = safe_malloc(
48781af68beaSAlexander Stetsenko sizeof (who_perm_node_t));
48791af68beaSAlexander Stetsenko who_perm = &node->who_perm;
48801af68beaSAlexander Stetsenko uu_avl_index_t idx = 0;
48811af68beaSAlexander Stetsenko
48821af68beaSAlexander Stetsenko uu_avl_node_init(node, &node->who_avl_node, avl_pool);
48831af68beaSAlexander Stetsenko who_perm_init(who_perm, fsperm, perm_type, perm_name);
48841af68beaSAlexander Stetsenko
48851af68beaSAlexander Stetsenko if ((found_node = uu_avl_find(avl, node, NULL, &idx))
48861af68beaSAlexander Stetsenko == NULL) {
48871af68beaSAlexander Stetsenko if (avl == fsperm->fsp_uge_avl) {
48881af68beaSAlexander Stetsenko uid_t rid = 0;
48891af68beaSAlexander Stetsenko struct passwd *p = NULL;
48901af68beaSAlexander Stetsenko struct group *g = NULL;
48911af68beaSAlexander Stetsenko const char *nice_name = NULL;
48921af68beaSAlexander Stetsenko
48931af68beaSAlexander Stetsenko switch (perm_type) {
48941af68beaSAlexander Stetsenko case ZFS_DELEG_USER_SETS:
48951af68beaSAlexander Stetsenko case ZFS_DELEG_USER:
48961af68beaSAlexander Stetsenko rid = atoi(perm_name);
48971af68beaSAlexander Stetsenko p = getpwuid(rid);
48981af68beaSAlexander Stetsenko if (p)
48991af68beaSAlexander Stetsenko nice_name = p->pw_name;
49001af68beaSAlexander Stetsenko break;
49011af68beaSAlexander Stetsenko case ZFS_DELEG_GROUP_SETS:
49021af68beaSAlexander Stetsenko case ZFS_DELEG_GROUP:
49031af68beaSAlexander Stetsenko rid = atoi(perm_name);
49041af68beaSAlexander Stetsenko g = getgrgid(rid);
49051af68beaSAlexander Stetsenko if (g)
49061af68beaSAlexander Stetsenko nice_name = g->gr_name;
49071af68beaSAlexander Stetsenko break;
4908c16bcc45SIgor Kozhukhov
4909c16bcc45SIgor Kozhukhov default:
4910c16bcc45SIgor Kozhukhov break;
49111af68beaSAlexander Stetsenko }
49121af68beaSAlexander Stetsenko
49131af68beaSAlexander Stetsenko if (nice_name != NULL)
49141af68beaSAlexander Stetsenko (void) strlcpy(
49151af68beaSAlexander Stetsenko node->who_perm.who_ug_name,
49161af68beaSAlexander Stetsenko nice_name, 256);
49171af68beaSAlexander Stetsenko }
49181af68beaSAlexander Stetsenko
49191af68beaSAlexander Stetsenko uu_avl_insert(avl, node, idx);
49201af68beaSAlexander Stetsenko } else {
49211af68beaSAlexander Stetsenko node = found_node;
49221af68beaSAlexander Stetsenko who_perm = &node->who_perm;
49231af68beaSAlexander Stetsenko }
49241af68beaSAlexander Stetsenko }
49251af68beaSAlexander Stetsenko
49261af68beaSAlexander Stetsenko (void) parse_who_perm(who_perm, nvl2, perm_locality);
49271af68beaSAlexander Stetsenko }
49281af68beaSAlexander Stetsenko
49291af68beaSAlexander Stetsenko return (0);
49301af68beaSAlexander Stetsenko }
49311af68beaSAlexander Stetsenko
49321af68beaSAlexander Stetsenko static inline int
parse_fs_perm_set(fs_perm_set_t * fspset,nvlist_t * nvl)49331af68beaSAlexander Stetsenko parse_fs_perm_set(fs_perm_set_t *fspset, nvlist_t *nvl)
49341af68beaSAlexander Stetsenko {
49351af68beaSAlexander Stetsenko nvpair_t *nvp = NULL;
49361af68beaSAlexander Stetsenko uu_avl_index_t idx = 0;
49371af68beaSAlexander Stetsenko
49381af68beaSAlexander Stetsenko while ((nvp = nvlist_next_nvpair(nvl, nvp)) != NULL) {
49391af68beaSAlexander Stetsenko nvlist_t *nvl2 = NULL;
49401af68beaSAlexander Stetsenko const char *fsname = nvpair_name(nvp);
49411af68beaSAlexander Stetsenko data_type_t type = nvpair_type(nvp);
49421af68beaSAlexander Stetsenko fs_perm_t *fsperm = NULL;
49431af68beaSAlexander Stetsenko fs_perm_node_t *node = safe_malloc(sizeof (fs_perm_node_t));
49441af68beaSAlexander Stetsenko if (node == NULL)
49451af68beaSAlexander Stetsenko nomem();
49461af68beaSAlexander Stetsenko
49471af68beaSAlexander Stetsenko fsperm = &node->fspn_fsperm;
49481af68beaSAlexander Stetsenko
49491af68beaSAlexander Stetsenko assert(DATA_TYPE_NVLIST == type);
49501af68beaSAlexander Stetsenko
49511af68beaSAlexander Stetsenko uu_list_node_init(node, &node->fspn_list_node,
49521af68beaSAlexander Stetsenko fspset->fsps_list_pool);
49531af68beaSAlexander Stetsenko
49541af68beaSAlexander Stetsenko idx = uu_list_numnodes(fspset->fsps_list);
49551af68beaSAlexander Stetsenko fs_perm_init(fsperm, fspset, fsname);
49561af68beaSAlexander Stetsenko
49571af68beaSAlexander Stetsenko if (nvpair_value_nvlist(nvp, &nvl2) != 0)
49581af68beaSAlexander Stetsenko return (-1);
49591af68beaSAlexander Stetsenko
49601af68beaSAlexander Stetsenko (void) parse_fs_perm(fsperm, nvl2);
49611af68beaSAlexander Stetsenko
49621af68beaSAlexander Stetsenko uu_list_insert(fspset->fsps_list, node, idx);
49631af68beaSAlexander Stetsenko }
49641af68beaSAlexander Stetsenko
49651af68beaSAlexander Stetsenko return (0);
49661af68beaSAlexander Stetsenko }
49671af68beaSAlexander Stetsenko
49681af68beaSAlexander Stetsenko static inline const char *
deleg_perm_comment(zfs_deleg_note_t note)49691af68beaSAlexander Stetsenko deleg_perm_comment(zfs_deleg_note_t note)
49701af68beaSAlexander Stetsenko {
49711af68beaSAlexander Stetsenko const char *str = "";
49721af68beaSAlexander Stetsenko
49731af68beaSAlexander Stetsenko /* subcommands */
49741af68beaSAlexander Stetsenko switch (note) {
49751af68beaSAlexander Stetsenko /* SUBCOMMANDS */
49761af68beaSAlexander Stetsenko case ZFS_DELEG_NOTE_ALLOW:
49771af68beaSAlexander Stetsenko str = gettext("Must also have the permission that is being"
49781af68beaSAlexander Stetsenko "\n\t\t\t\tallowed");
49791af68beaSAlexander Stetsenko break;
49801af68beaSAlexander Stetsenko case ZFS_DELEG_NOTE_CLONE:
49811af68beaSAlexander Stetsenko str = gettext("Must also have the 'create' ability and 'mount'"
49821af68beaSAlexander Stetsenko "\n\t\t\t\tability in the origin file system");
49831af68beaSAlexander Stetsenko break;
49841af68beaSAlexander Stetsenko case ZFS_DELEG_NOTE_CREATE:
49851af68beaSAlexander Stetsenko str = gettext("Must also have the 'mount' ability");
49861af68beaSAlexander Stetsenko break;
49871af68beaSAlexander Stetsenko case ZFS_DELEG_NOTE_DESTROY:
49881af68beaSAlexander Stetsenko str = gettext("Must also have the 'mount' ability");
49891af68beaSAlexander Stetsenko break;
49901af68beaSAlexander Stetsenko case ZFS_DELEG_NOTE_DIFF:
49911af68beaSAlexander Stetsenko str = gettext("Allows lookup of paths within a dataset;"
49921af68beaSAlexander Stetsenko "\n\t\t\t\tgiven an object number. Ordinary users need this"
49931af68beaSAlexander Stetsenko "\n\t\t\t\tin order to use zfs diff");
49941af68beaSAlexander Stetsenko break;
49951af68beaSAlexander Stetsenko case ZFS_DELEG_NOTE_HOLD:
49961af68beaSAlexander Stetsenko str = gettext("Allows adding a user hold to a snapshot");
49971af68beaSAlexander Stetsenko break;
49981af68beaSAlexander Stetsenko case ZFS_DELEG_NOTE_MOUNT:
49991af68beaSAlexander Stetsenko str = gettext("Allows mount/umount of ZFS datasets");
50001af68beaSAlexander Stetsenko break;
50011af68beaSAlexander Stetsenko case ZFS_DELEG_NOTE_PROMOTE:
50021af68beaSAlexander Stetsenko str = gettext("Must also have the 'mount'\n\t\t\t\tand"
50031af68beaSAlexander Stetsenko " 'promote' ability in the origin file system");
50041af68beaSAlexander Stetsenko break;
50051af68beaSAlexander Stetsenko case ZFS_DELEG_NOTE_RECEIVE:
50061af68beaSAlexander Stetsenko str = gettext("Must also have the 'mount' and 'create'"
50071af68beaSAlexander Stetsenko " ability");
50081af68beaSAlexander Stetsenko break;
50091af68beaSAlexander Stetsenko case ZFS_DELEG_NOTE_RELEASE:
50101af68beaSAlexander Stetsenko str = gettext("Allows releasing a user hold which\n\t\t\t\t"
50111af68beaSAlexander Stetsenko "might destroy the snapshot");
50121af68beaSAlexander Stetsenko break;
50131af68beaSAlexander Stetsenko case ZFS_DELEG_NOTE_RENAME:
50141af68beaSAlexander Stetsenko str = gettext("Must also have the 'mount' and 'create'"
50151af68beaSAlexander Stetsenko "\n\t\t\t\tability in the new parent");
50161af68beaSAlexander Stetsenko break;
50171af68beaSAlexander Stetsenko case ZFS_DELEG_NOTE_ROLLBACK:
50181af68beaSAlexander Stetsenko str = gettext("");
50191af68beaSAlexander Stetsenko break;
50201af68beaSAlexander Stetsenko case ZFS_DELEG_NOTE_SEND:
50211af68beaSAlexander Stetsenko str = gettext("");
50221af68beaSAlexander Stetsenko break;
50231af68beaSAlexander Stetsenko case ZFS_DELEG_NOTE_SHARE:
50241af68beaSAlexander Stetsenko str = gettext("Allows sharing file systems over NFS or SMB"
50251af68beaSAlexander Stetsenko "\n\t\t\t\tprotocols");
50261af68beaSAlexander Stetsenko break;
50271af68beaSAlexander Stetsenko case ZFS_DELEG_NOTE_SNAPSHOT:
50281af68beaSAlexander Stetsenko str = gettext("");
50291af68beaSAlexander Stetsenko break;
5030eb633035STom Caputi case ZFS_DELEG_NOTE_LOAD_KEY:
5031eb633035STom Caputi str = gettext("Allows loading or unloading an encryption key");
5032eb633035STom Caputi break;
5033eb633035STom Caputi case ZFS_DELEG_NOTE_CHANGE_KEY:
5034eb633035STom Caputi str = gettext("Allows changing or adding an encryption key");
5035eb633035STom Caputi break;
50361af68beaSAlexander Stetsenko /*
50371af68beaSAlexander Stetsenko * case ZFS_DELEG_NOTE_VSCAN:
50381af68beaSAlexander Stetsenko * str = gettext("");
50391af68beaSAlexander Stetsenko * break;
50401af68beaSAlexander Stetsenko */
50411af68beaSAlexander Stetsenko /* OTHER */
50421af68beaSAlexander Stetsenko case ZFS_DELEG_NOTE_GROUPQUOTA:
50431af68beaSAlexander Stetsenko str = gettext("Allows accessing any groupquota@... property");
50441af68beaSAlexander Stetsenko break;
50451af68beaSAlexander Stetsenko case ZFS_DELEG_NOTE_GROUPUSED:
50461af68beaSAlexander Stetsenko str = gettext("Allows reading any groupused@... property");
50471af68beaSAlexander Stetsenko break;
50481af68beaSAlexander Stetsenko case ZFS_DELEG_NOTE_USERPROP:
50491af68beaSAlexander Stetsenko str = gettext("Allows changing any user property");
50501af68beaSAlexander Stetsenko break;
50511af68beaSAlexander Stetsenko case ZFS_DELEG_NOTE_USERQUOTA:
50521af68beaSAlexander Stetsenko str = gettext("Allows accessing any userquota@... property");
50531af68beaSAlexander Stetsenko break;
50541af68beaSAlexander Stetsenko case ZFS_DELEG_NOTE_USERUSED:
50551af68beaSAlexander Stetsenko str = gettext("Allows reading any userused@... property");
50561af68beaSAlexander Stetsenko break;
5057f67950b2SNasf-Fan case ZFS_DELEG_NOTE_USEROBJQUOTA:
5058f67950b2SNasf-Fan str = gettext("Allows accessing any userobjquota@... property");
5059f67950b2SNasf-Fan break;
5060f67950b2SNasf-Fan case ZFS_DELEG_NOTE_GROUPOBJQUOTA:
5061f67950b2SNasf-Fan str = gettext("Allows accessing any \n\t\t\t\t"
5062f67950b2SNasf-Fan "groupobjquota@... property");
5063f67950b2SNasf-Fan break;
5064f67950b2SNasf-Fan case ZFS_DELEG_NOTE_GROUPOBJUSED:
5065f67950b2SNasf-Fan str = gettext("Allows reading any groupobjused@... property");
5066f67950b2SNasf-Fan break;
5067f67950b2SNasf-Fan case ZFS_DELEG_NOTE_USEROBJUSED:
5068f67950b2SNasf-Fan str = gettext("Allows reading any userobjused@... property");
5069f67950b2SNasf-Fan break;
5070f67950b2SNasf-Fan case ZFS_DELEG_NOTE_PROJECTQUOTA:
5071f67950b2SNasf-Fan str = gettext("Allows accessing any projectquota@... property");
5072f67950b2SNasf-Fan break;
5073f67950b2SNasf-Fan case ZFS_DELEG_NOTE_PROJECTOBJQUOTA:
5074f67950b2SNasf-Fan str = gettext("Allows accessing any \n\t\t\t\t"
5075f67950b2SNasf-Fan "projectobjquota@... property");
5076f67950b2SNasf-Fan break;
5077f67950b2SNasf-Fan case ZFS_DELEG_NOTE_PROJECTUSED:
5078f67950b2SNasf-Fan str = gettext("Allows reading any projectused@... property");
5079f67950b2SNasf-Fan break;
5080f67950b2SNasf-Fan case ZFS_DELEG_NOTE_PROJECTOBJUSED:
5081f67950b2SNasf-Fan str = gettext("Allows accessing any \n\t\t\t\t"
5082f67950b2SNasf-Fan "projectobjused@... property");
5083f67950b2SNasf-Fan break;
50841af68beaSAlexander Stetsenko /* other */
50851af68beaSAlexander Stetsenko default:
50861af68beaSAlexander Stetsenko str = "";
50871af68beaSAlexander Stetsenko }
50881af68beaSAlexander Stetsenko
50891af68beaSAlexander Stetsenko return (str);
50901af68beaSAlexander Stetsenko }
50911af68beaSAlexander Stetsenko
50921af68beaSAlexander Stetsenko struct allow_opts {
50931af68beaSAlexander Stetsenko boolean_t local;
50941af68beaSAlexander Stetsenko boolean_t descend;
50951af68beaSAlexander Stetsenko boolean_t user;
50961af68beaSAlexander Stetsenko boolean_t group;
50971af68beaSAlexander Stetsenko boolean_t everyone;
50981af68beaSAlexander Stetsenko boolean_t create;
50991af68beaSAlexander Stetsenko boolean_t set;
51001af68beaSAlexander Stetsenko boolean_t recursive; /* unallow only */
51011af68beaSAlexander Stetsenko boolean_t prt_usage;
51021af68beaSAlexander Stetsenko
51031af68beaSAlexander Stetsenko boolean_t prt_perms;
51041af68beaSAlexander Stetsenko char *who;
51051af68beaSAlexander Stetsenko char *perms;
51061af68beaSAlexander Stetsenko const char *dataset;
51071af68beaSAlexander Stetsenko };
51081af68beaSAlexander Stetsenko
51091af68beaSAlexander Stetsenko static inline int
prop_cmp(const void * a,const void * b)51101af68beaSAlexander Stetsenko prop_cmp(const void *a, const void *b)
51111af68beaSAlexander Stetsenko {
51121af68beaSAlexander Stetsenko const char *str1 = *(const char **)a;
51131af68beaSAlexander Stetsenko const char *str2 = *(const char **)b;
51141af68beaSAlexander Stetsenko return (strcmp(str1, str2));
51151af68beaSAlexander Stetsenko }
51161af68beaSAlexander Stetsenko
51171af68beaSAlexander Stetsenko static void
allow_usage(boolean_t un,boolean_t requested,const char * msg)51181af68beaSAlexander Stetsenko allow_usage(boolean_t un, boolean_t requested, const char *msg)
51191af68beaSAlexander Stetsenko {
51201af68beaSAlexander Stetsenko const char *opt_desc[] = {
51211af68beaSAlexander Stetsenko "-h", gettext("show this help message and exit"),
51221af68beaSAlexander Stetsenko "-l", gettext("set permission locally"),
51231af68beaSAlexander Stetsenko "-d", gettext("set permission for descents"),
51241af68beaSAlexander Stetsenko "-u", gettext("set permission for user"),
51251af68beaSAlexander Stetsenko "-g", gettext("set permission for group"),
51261af68beaSAlexander Stetsenko "-e", gettext("set permission for everyone"),
51271af68beaSAlexander Stetsenko "-c", gettext("set create time permission"),
51281af68beaSAlexander Stetsenko "-s", gettext("define permission set"),
51291af68beaSAlexander Stetsenko /* unallow only */
51301af68beaSAlexander Stetsenko "-r", gettext("remove permissions recursively"),
51311af68beaSAlexander Stetsenko };
51321af68beaSAlexander Stetsenko size_t unallow_size = sizeof (opt_desc) / sizeof (char *);
51331af68beaSAlexander Stetsenko size_t allow_size = unallow_size - 2;
51341af68beaSAlexander Stetsenko const char *props[ZFS_NUM_PROPS];
51351af68beaSAlexander Stetsenko int i;
51361af68beaSAlexander Stetsenko size_t count = 0;
51371af68beaSAlexander Stetsenko FILE *fp = requested ? stdout : stderr;
51381af68beaSAlexander Stetsenko zprop_desc_t *pdtbl = zfs_prop_get_table();
51391af68beaSAlexander Stetsenko const char *fmt = gettext("%-16s %-14s\t%s\n");
51401af68beaSAlexander Stetsenko
51411af68beaSAlexander Stetsenko (void) fprintf(fp, gettext("Usage: %s\n"), get_usage(un ? HELP_UNALLOW :
51421af68beaSAlexander Stetsenko HELP_ALLOW));
51431af68beaSAlexander Stetsenko (void) fprintf(fp, gettext("Options:\n"));
51441af68beaSAlexander Stetsenko for (int i = 0; i < (un ? unallow_size : allow_size); i++) {
51451af68beaSAlexander Stetsenko const char *opt = opt_desc[i++];
51461af68beaSAlexander Stetsenko const char *optdsc = opt_desc[i];
51471af68beaSAlexander Stetsenko (void) fprintf(fp, gettext(" %-10s %s\n"), opt, optdsc);
51481af68beaSAlexander Stetsenko }
51491af68beaSAlexander Stetsenko
51501af68beaSAlexander Stetsenko (void) fprintf(fp, gettext("\nThe following permissions are "
51511af68beaSAlexander Stetsenko "supported:\n\n"));
51521af68beaSAlexander Stetsenko (void) fprintf(fp, fmt, gettext("NAME"), gettext("TYPE"),
51531af68beaSAlexander Stetsenko gettext("NOTES"));
51541af68beaSAlexander Stetsenko for (i = 0; i < ZFS_NUM_DELEG_NOTES; i++) {
51551af68beaSAlexander Stetsenko const char *perm_name = zfs_deleg_perm_tbl[i].z_perm;
51561af68beaSAlexander Stetsenko zfs_deleg_note_t perm_note = zfs_deleg_perm_tbl[i].z_note;
51571af68beaSAlexander Stetsenko const char *perm_type = deleg_perm_type(perm_note);
51581af68beaSAlexander Stetsenko const char *perm_comment = deleg_perm_comment(perm_note);
51591af68beaSAlexander Stetsenko (void) fprintf(fp, fmt, perm_name, perm_type, perm_comment);
51601af68beaSAlexander Stetsenko }
51611af68beaSAlexander Stetsenko
51621af68beaSAlexander Stetsenko for (i = 0; i < ZFS_NUM_PROPS; i++) {
51631af68beaSAlexander Stetsenko zprop_desc_t *pd = &pdtbl[i];
51641af68beaSAlexander Stetsenko if (pd->pd_visible != B_TRUE)
51651af68beaSAlexander Stetsenko continue;
51661af68beaSAlexander Stetsenko
51671af68beaSAlexander Stetsenko if (pd->pd_attr == PROP_READONLY)
51681af68beaSAlexander Stetsenko continue;
51691af68beaSAlexander Stetsenko
51701af68beaSAlexander Stetsenko props[count++] = pd->pd_name;
51711af68beaSAlexander Stetsenko }
51721af68beaSAlexander Stetsenko props[count] = NULL;
51731af68beaSAlexander Stetsenko
51741af68beaSAlexander Stetsenko qsort(props, count, sizeof (char *), prop_cmp);
51751af68beaSAlexander Stetsenko
51761af68beaSAlexander Stetsenko for (i = 0; i < count; i++)
51771af68beaSAlexander Stetsenko (void) fprintf(fp, fmt, props[i], gettext("property"), "");
51781af68beaSAlexander Stetsenko
51791af68beaSAlexander Stetsenko if (msg != NULL)
51801af68beaSAlexander Stetsenko (void) fprintf(fp, gettext("\nzfs: error: %s"), msg);
51811af68beaSAlexander Stetsenko
51821af68beaSAlexander Stetsenko exit(requested ? 0 : 2);
51831af68beaSAlexander Stetsenko }
51841af68beaSAlexander Stetsenko
51851af68beaSAlexander Stetsenko static inline const char *
munge_args(int argc,char ** argv,boolean_t un,size_t expected_argc,char ** permsp)51861af68beaSAlexander Stetsenko munge_args(int argc, char **argv, boolean_t un, size_t expected_argc,
51871af68beaSAlexander Stetsenko char **permsp)
51881af68beaSAlexander Stetsenko {
51891af68beaSAlexander Stetsenko if (un && argc == expected_argc - 1)
51901af68beaSAlexander Stetsenko *permsp = NULL;
51911af68beaSAlexander Stetsenko else if (argc == expected_argc)
51921af68beaSAlexander Stetsenko *permsp = argv[argc - 2];
51931af68beaSAlexander Stetsenko else
51941af68beaSAlexander Stetsenko allow_usage(un, B_FALSE,
51951af68beaSAlexander Stetsenko gettext("wrong number of parameters\n"));
51961af68beaSAlexander Stetsenko
51971af68beaSAlexander Stetsenko return (argv[argc - 1]);
51981af68beaSAlexander Stetsenko }
51991af68beaSAlexander Stetsenko
52001af68beaSAlexander Stetsenko static void
parse_allow_args(int argc,char ** argv,boolean_t un,struct allow_opts * opts)52011af68beaSAlexander Stetsenko parse_allow_args(int argc, char **argv, boolean_t un, struct allow_opts *opts)
52021af68beaSAlexander Stetsenko {
52031af68beaSAlexander Stetsenko int uge_sum = opts->user + opts->group + opts->everyone;
52041af68beaSAlexander Stetsenko int csuge_sum = opts->create + opts->set + uge_sum;
52051af68beaSAlexander Stetsenko int ldcsuge_sum = csuge_sum + opts->local + opts->descend;
52061af68beaSAlexander Stetsenko int all_sum = un ? ldcsuge_sum + opts->recursive : ldcsuge_sum;
52071af68beaSAlexander Stetsenko
52081af68beaSAlexander Stetsenko if (uge_sum > 1)
52091af68beaSAlexander Stetsenko allow_usage(un, B_FALSE,
52101af68beaSAlexander Stetsenko gettext("-u, -g, and -e are mutually exclusive\n"));
52111af68beaSAlexander Stetsenko
5212c16bcc45SIgor Kozhukhov if (opts->prt_usage) {
52131af68beaSAlexander Stetsenko if (argc == 0 && all_sum == 0)
52141af68beaSAlexander Stetsenko allow_usage(un, B_TRUE, NULL);
52151af68beaSAlexander Stetsenko else
52161af68beaSAlexander Stetsenko usage(B_FALSE);
5217c16bcc45SIgor Kozhukhov }
52181af68beaSAlexander Stetsenko
52191af68beaSAlexander Stetsenko if (opts->set) {
52201af68beaSAlexander Stetsenko if (csuge_sum > 1)
52211af68beaSAlexander Stetsenko allow_usage(un, B_FALSE,
52221af68beaSAlexander Stetsenko gettext("invalid options combined with -s\n"));
52231af68beaSAlexander Stetsenko
52241af68beaSAlexander Stetsenko opts->dataset = munge_args(argc, argv, un, 3, &opts->perms);
52251af68beaSAlexander Stetsenko if (argv[0][0] != '@')
52261af68beaSAlexander Stetsenko allow_usage(un, B_FALSE,
52271af68beaSAlexander Stetsenko gettext("invalid set name: missing '@' prefix\n"));
52281af68beaSAlexander Stetsenko opts->who = argv[0];
52291af68beaSAlexander Stetsenko } else if (opts->create) {
52301af68beaSAlexander Stetsenko if (ldcsuge_sum > 1)
52311af68beaSAlexander Stetsenko allow_usage(un, B_FALSE,
52321af68beaSAlexander Stetsenko gettext("invalid options combined with -c\n"));
52331af68beaSAlexander Stetsenko opts->dataset = munge_args(argc, argv, un, 2, &opts->perms);
52341af68beaSAlexander Stetsenko } else if (opts->everyone) {
52351af68beaSAlexander Stetsenko if (csuge_sum > 1)
52361af68beaSAlexander Stetsenko allow_usage(un, B_FALSE,
52371af68beaSAlexander Stetsenko gettext("invalid options combined with -e\n"));
52381af68beaSAlexander Stetsenko opts->dataset = munge_args(argc, argv, un, 2, &opts->perms);
52391af68beaSAlexander Stetsenko } else if (uge_sum == 0 && argc > 0 && strcmp(argv[0], "everyone")
52401af68beaSAlexander Stetsenko == 0) {
52411af68beaSAlexander Stetsenko opts->everyone = B_TRUE;
52421af68beaSAlexander Stetsenko argc--;
52431af68beaSAlexander Stetsenko argv++;
52441af68beaSAlexander Stetsenko opts->dataset = munge_args(argc, argv, un, 2, &opts->perms);
5245c560ed2bSAlexander Eremin } else if (argc == 1 && !un) {
52461af68beaSAlexander Stetsenko opts->prt_perms = B_TRUE;
52471af68beaSAlexander Stetsenko opts->dataset = argv[argc-1];
52481af68beaSAlexander Stetsenko } else {
52491af68beaSAlexander Stetsenko opts->dataset = munge_args(argc, argv, un, 3, &opts->perms);
52501af68beaSAlexander Stetsenko opts->who = argv[0];
52511af68beaSAlexander Stetsenko }
52521af68beaSAlexander Stetsenko
52531af68beaSAlexander Stetsenko if (!opts->local && !opts->descend) {
52541af68beaSAlexander Stetsenko opts->local = B_TRUE;
52551af68beaSAlexander Stetsenko opts->descend = B_TRUE;
52561af68beaSAlexander Stetsenko }
52571af68beaSAlexander Stetsenko }
52581af68beaSAlexander Stetsenko
52591af68beaSAlexander Stetsenko static void
store_allow_perm(zfs_deleg_who_type_t type,boolean_t local,boolean_t descend,const char * who,char * perms,nvlist_t * top_nvl)52601af68beaSAlexander Stetsenko store_allow_perm(zfs_deleg_who_type_t type, boolean_t local, boolean_t descend,
52611af68beaSAlexander Stetsenko const char *who, char *perms, nvlist_t *top_nvl)
52621af68beaSAlexander Stetsenko {
52631af68beaSAlexander Stetsenko int i;
52641af68beaSAlexander Stetsenko char ld[2] = { '\0', '\0' };
52659adfa60dSMatthew Ahrens char who_buf[MAXNAMELEN + 32];
5266c16bcc45SIgor Kozhukhov char base_type = '\0';
5267c16bcc45SIgor Kozhukhov char set_type = '\0';
52681af68beaSAlexander Stetsenko nvlist_t *base_nvl = NULL;
52691af68beaSAlexander Stetsenko nvlist_t *set_nvl = NULL;
52701af68beaSAlexander Stetsenko nvlist_t *nvl;
52711af68beaSAlexander Stetsenko
52721af68beaSAlexander Stetsenko if (nvlist_alloc(&base_nvl, NV_UNIQUE_NAME, 0) != 0)
52731af68beaSAlexander Stetsenko nomem();
52741af68beaSAlexander Stetsenko if (nvlist_alloc(&set_nvl, NV_UNIQUE_NAME, 0) != 0)
52751af68beaSAlexander Stetsenko nomem();
52761af68beaSAlexander Stetsenko
52771af68beaSAlexander Stetsenko switch (type) {
52781af68beaSAlexander Stetsenko case ZFS_DELEG_NAMED_SET_SETS:
52791af68beaSAlexander Stetsenko case ZFS_DELEG_NAMED_SET:
52801af68beaSAlexander Stetsenko set_type = ZFS_DELEG_NAMED_SET_SETS;
52811af68beaSAlexander Stetsenko base_type = ZFS_DELEG_NAMED_SET;
52821af68beaSAlexander Stetsenko ld[0] = ZFS_DELEG_NA;
52831af68beaSAlexander Stetsenko break;
52841af68beaSAlexander Stetsenko case ZFS_DELEG_CREATE_SETS:
52851af68beaSAlexander Stetsenko case ZFS_DELEG_CREATE:
52861af68beaSAlexander Stetsenko set_type = ZFS_DELEG_CREATE_SETS;
52871af68beaSAlexander Stetsenko base_type = ZFS_DELEG_CREATE;
52881af68beaSAlexander Stetsenko ld[0] = ZFS_DELEG_NA;
52891af68beaSAlexander Stetsenko break;
52901af68beaSAlexander Stetsenko case ZFS_DELEG_USER_SETS:
52911af68beaSAlexander Stetsenko case ZFS_DELEG_USER:
52921af68beaSAlexander Stetsenko set_type = ZFS_DELEG_USER_SETS;
52931af68beaSAlexander Stetsenko base_type = ZFS_DELEG_USER;
52941af68beaSAlexander Stetsenko if (local)
52951af68beaSAlexander Stetsenko ld[0] = ZFS_DELEG_LOCAL;
52961af68beaSAlexander Stetsenko if (descend)
52971af68beaSAlexander Stetsenko ld[1] = ZFS_DELEG_DESCENDENT;
52981af68beaSAlexander Stetsenko break;
52991af68beaSAlexander Stetsenko case ZFS_DELEG_GROUP_SETS:
53001af68beaSAlexander Stetsenko case ZFS_DELEG_GROUP:
53011af68beaSAlexander Stetsenko set_type = ZFS_DELEG_GROUP_SETS;
53021af68beaSAlexander Stetsenko base_type = ZFS_DELEG_GROUP;
53031af68beaSAlexander Stetsenko if (local)
53041af68beaSAlexander Stetsenko ld[0] = ZFS_DELEG_LOCAL;
53051af68beaSAlexander Stetsenko if (descend)
53061af68beaSAlexander Stetsenko ld[1] = ZFS_DELEG_DESCENDENT;
53071af68beaSAlexander Stetsenko break;
53081af68beaSAlexander Stetsenko case ZFS_DELEG_EVERYONE_SETS:
53091af68beaSAlexander Stetsenko case ZFS_DELEG_EVERYONE:
53101af68beaSAlexander Stetsenko set_type = ZFS_DELEG_EVERYONE_SETS;
53111af68beaSAlexander Stetsenko base_type = ZFS_DELEG_EVERYONE;
53121af68beaSAlexander Stetsenko if (local)
53131af68beaSAlexander Stetsenko ld[0] = ZFS_DELEG_LOCAL;
53141af68beaSAlexander Stetsenko if (descend)
53151af68beaSAlexander Stetsenko ld[1] = ZFS_DELEG_DESCENDENT;
5316c16bcc45SIgor Kozhukhov break;
5317c16bcc45SIgor Kozhukhov
5318c16bcc45SIgor Kozhukhov default:
5319c16bcc45SIgor Kozhukhov assert(set_type != '\0' && base_type != '\0');
53201af68beaSAlexander Stetsenko }
53211af68beaSAlexander Stetsenko
53221af68beaSAlexander Stetsenko if (perms != NULL) {
53231af68beaSAlexander Stetsenko char *curr = perms;
53241af68beaSAlexander Stetsenko char *end = curr + strlen(perms);
53251af68beaSAlexander Stetsenko
53261af68beaSAlexander Stetsenko while (curr < end) {
53271af68beaSAlexander Stetsenko char *delim = strchr(curr, ',');
53281af68beaSAlexander Stetsenko if (delim == NULL)
53291af68beaSAlexander Stetsenko delim = end;
53301af68beaSAlexander Stetsenko else
53311af68beaSAlexander Stetsenko *delim = '\0';
53321af68beaSAlexander Stetsenko
53331af68beaSAlexander Stetsenko if (curr[0] == '@')
53341af68beaSAlexander Stetsenko nvl = set_nvl;
53351af68beaSAlexander Stetsenko else
53361af68beaSAlexander Stetsenko nvl = base_nvl;
53371af68beaSAlexander Stetsenko
53381af68beaSAlexander Stetsenko (void) nvlist_add_boolean(nvl, curr);
53391af68beaSAlexander Stetsenko if (delim != end)
53401af68beaSAlexander Stetsenko *delim = ',';
53411af68beaSAlexander Stetsenko curr = delim + 1;
53421af68beaSAlexander Stetsenko }
53431af68beaSAlexander Stetsenko
53441af68beaSAlexander Stetsenko for (i = 0; i < 2; i++) {
53451af68beaSAlexander Stetsenko char locality = ld[i];
53461af68beaSAlexander Stetsenko if (locality == 0)
53471af68beaSAlexander Stetsenko continue;
53481af68beaSAlexander Stetsenko
53491af68beaSAlexander Stetsenko if (!nvlist_empty(base_nvl)) {
53501af68beaSAlexander Stetsenko if (who != NULL)
53511af68beaSAlexander Stetsenko (void) snprintf(who_buf,
53521af68beaSAlexander Stetsenko sizeof (who_buf), "%c%c$%s",
53531af68beaSAlexander Stetsenko base_type, locality, who);
53541af68beaSAlexander Stetsenko else
53551af68beaSAlexander Stetsenko (void) snprintf(who_buf,
53561af68beaSAlexander Stetsenko sizeof (who_buf), "%c%c$",
53571af68beaSAlexander Stetsenko base_type, locality);
53581af68beaSAlexander Stetsenko
53591af68beaSAlexander Stetsenko (void) nvlist_add_nvlist(top_nvl, who_buf,
53601af68beaSAlexander Stetsenko base_nvl);
53611af68beaSAlexander Stetsenko }
53621af68beaSAlexander Stetsenko
53631af68beaSAlexander Stetsenko
53641af68beaSAlexander Stetsenko if (!nvlist_empty(set_nvl)) {
53651af68beaSAlexander Stetsenko if (who != NULL)
53661af68beaSAlexander Stetsenko (void) snprintf(who_buf,
53671af68beaSAlexander Stetsenko sizeof (who_buf), "%c%c$%s",
53681af68beaSAlexander Stetsenko set_type, locality, who);
53691af68beaSAlexander Stetsenko else
53701af68beaSAlexander Stetsenko (void) snprintf(who_buf,
53711af68beaSAlexander Stetsenko sizeof (who_buf), "%c%c$",
53721af68beaSAlexander Stetsenko set_type, locality);
53731af68beaSAlexander Stetsenko
53741af68beaSAlexander Stetsenko (void) nvlist_add_nvlist(top_nvl, who_buf,
53751af68beaSAlexander Stetsenko set_nvl);
53761af68beaSAlexander Stetsenko }
53771af68beaSAlexander Stetsenko }
53781af68beaSAlexander Stetsenko } else {
53791af68beaSAlexander Stetsenko for (i = 0; i < 2; i++) {
53801af68beaSAlexander Stetsenko char locality = ld[i];
53811af68beaSAlexander Stetsenko if (locality == 0)
53821af68beaSAlexander Stetsenko continue;
53831af68beaSAlexander Stetsenko
53841af68beaSAlexander Stetsenko if (who != NULL)
53851af68beaSAlexander Stetsenko (void) snprintf(who_buf, sizeof (who_buf),
53861af68beaSAlexander Stetsenko "%c%c$%s", base_type, locality, who);
53871af68beaSAlexander Stetsenko else
53881af68beaSAlexander Stetsenko (void) snprintf(who_buf, sizeof (who_buf),
53891af68beaSAlexander Stetsenko "%c%c$", base_type, locality);
53901af68beaSAlexander Stetsenko (void) nvlist_add_boolean(top_nvl, who_buf);
53911af68beaSAlexander Stetsenko
53921af68beaSAlexander Stetsenko if (who != NULL)
53931af68beaSAlexander Stetsenko (void) snprintf(who_buf, sizeof (who_buf),
53941af68beaSAlexander Stetsenko "%c%c$%s", set_type, locality, who);
53951af68beaSAlexander Stetsenko else
53961af68beaSAlexander Stetsenko (void) snprintf(who_buf, sizeof (who_buf),
53971af68beaSAlexander Stetsenko "%c%c$", set_type, locality);
53981af68beaSAlexander Stetsenko (void) nvlist_add_boolean(top_nvl, who_buf);
53991af68beaSAlexander Stetsenko }
54001af68beaSAlexander Stetsenko }
54011af68beaSAlexander Stetsenko }
54021af68beaSAlexander Stetsenko
54031af68beaSAlexander Stetsenko static int
construct_fsacl_list(boolean_t un,struct allow_opts * opts,nvlist_t ** nvlp)54041af68beaSAlexander Stetsenko construct_fsacl_list(boolean_t un, struct allow_opts *opts, nvlist_t **nvlp)
54051af68beaSAlexander Stetsenko {
54061af68beaSAlexander Stetsenko if (nvlist_alloc(nvlp, NV_UNIQUE_NAME, 0) != 0)
54071af68beaSAlexander Stetsenko nomem();
54081af68beaSAlexander Stetsenko
54091af68beaSAlexander Stetsenko if (opts->set) {
54101af68beaSAlexander Stetsenko store_allow_perm(ZFS_DELEG_NAMED_SET, opts->local,
54111af68beaSAlexander Stetsenko opts->descend, opts->who, opts->perms, *nvlp);
54121af68beaSAlexander Stetsenko } else if (opts->create) {
54131af68beaSAlexander Stetsenko store_allow_perm(ZFS_DELEG_CREATE, opts->local,
54141af68beaSAlexander Stetsenko opts->descend, NULL, opts->perms, *nvlp);
54151af68beaSAlexander Stetsenko } else if (opts->everyone) {
54161af68beaSAlexander Stetsenko store_allow_perm(ZFS_DELEG_EVERYONE, opts->local,
54171af68beaSAlexander Stetsenko opts->descend, NULL, opts->perms, *nvlp);
54181af68beaSAlexander Stetsenko } else {
54191af68beaSAlexander Stetsenko char *curr = opts->who;
54201af68beaSAlexander Stetsenko char *end = curr + strlen(curr);
54211af68beaSAlexander Stetsenko
54221af68beaSAlexander Stetsenko while (curr < end) {
54231af68beaSAlexander Stetsenko const char *who;
5424c16bcc45SIgor Kozhukhov zfs_deleg_who_type_t who_type = ZFS_DELEG_WHO_UNKNOWN;
54251af68beaSAlexander Stetsenko char *endch;
54261af68beaSAlexander Stetsenko char *delim = strchr(curr, ',');
54271af68beaSAlexander Stetsenko char errbuf[256];
54281af68beaSAlexander Stetsenko char id[64];
54291af68beaSAlexander Stetsenko struct passwd *p = NULL;
54301af68beaSAlexander Stetsenko struct group *g = NULL;
54311af68beaSAlexander Stetsenko
54321af68beaSAlexander Stetsenko uid_t rid;
54331af68beaSAlexander Stetsenko if (delim == NULL)
54341af68beaSAlexander Stetsenko delim = end;
54351af68beaSAlexander Stetsenko else
54361af68beaSAlexander Stetsenko *delim = '\0';
54371af68beaSAlexander Stetsenko
54381af68beaSAlexander Stetsenko rid = (uid_t)strtol(curr, &endch, 0);
54391af68beaSAlexander Stetsenko if (opts->user) {
54401af68beaSAlexander Stetsenko who_type = ZFS_DELEG_USER;
54411af68beaSAlexander Stetsenko if (*endch != '\0')
54421af68beaSAlexander Stetsenko p = getpwnam(curr);
54431af68beaSAlexander Stetsenko else
54441af68beaSAlexander Stetsenko p = getpwuid(rid);
54451af68beaSAlexander Stetsenko
54461af68beaSAlexander Stetsenko if (p != NULL)
54471af68beaSAlexander Stetsenko rid = p->pw_uid;
54481af68beaSAlexander Stetsenko else {
54491af68beaSAlexander Stetsenko (void) snprintf(errbuf, 256, gettext(
54501af68beaSAlexander Stetsenko "invalid user %s"), curr);
54511af68beaSAlexander Stetsenko allow_usage(un, B_TRUE, errbuf);
54521af68beaSAlexander Stetsenko }
54531af68beaSAlexander Stetsenko } else if (opts->group) {
54541af68beaSAlexander Stetsenko who_type = ZFS_DELEG_GROUP;
54551af68beaSAlexander Stetsenko if (*endch != '\0')
54561af68beaSAlexander Stetsenko g = getgrnam(curr);
54571af68beaSAlexander Stetsenko else
54581af68beaSAlexander Stetsenko g = getgrgid(rid);
54591af68beaSAlexander Stetsenko
54601af68beaSAlexander Stetsenko if (g != NULL)
54611af68beaSAlexander Stetsenko rid = g->gr_gid;
54621af68beaSAlexander Stetsenko else {
54631af68beaSAlexander Stetsenko (void) snprintf(errbuf, 256, gettext(
54641af68beaSAlexander Stetsenko "invalid group %s"), curr);
54651af68beaSAlexander Stetsenko allow_usage(un, B_TRUE, errbuf);
54661af68beaSAlexander Stetsenko }
54671af68beaSAlexander Stetsenko } else {
54681af68beaSAlexander Stetsenko if (*endch != '\0') {
54691af68beaSAlexander Stetsenko p = getpwnam(curr);
54701af68beaSAlexander Stetsenko } else {
54711af68beaSAlexander Stetsenko p = getpwuid(rid);
54721af68beaSAlexander Stetsenko }
54731af68beaSAlexander Stetsenko
5474c16bcc45SIgor Kozhukhov if (p == NULL) {
54751af68beaSAlexander Stetsenko if (*endch != '\0') {
54761af68beaSAlexander Stetsenko g = getgrnam(curr);
54771af68beaSAlexander Stetsenko } else {
54781af68beaSAlexander Stetsenko g = getgrgid(rid);
54791af68beaSAlexander Stetsenko }
5480c16bcc45SIgor Kozhukhov }
54811af68beaSAlexander Stetsenko
54821af68beaSAlexander Stetsenko if (p != NULL) {
54831af68beaSAlexander Stetsenko who_type = ZFS_DELEG_USER;
54841af68beaSAlexander Stetsenko rid = p->pw_uid;
54851af68beaSAlexander Stetsenko } else if (g != NULL) {
54861af68beaSAlexander Stetsenko who_type = ZFS_DELEG_GROUP;
54871af68beaSAlexander Stetsenko rid = g->gr_gid;
54881af68beaSAlexander Stetsenko } else {
54891af68beaSAlexander Stetsenko (void) snprintf(errbuf, 256, gettext(
54901af68beaSAlexander Stetsenko "invalid user/group %s"), curr);
54911af68beaSAlexander Stetsenko allow_usage(un, B_TRUE, errbuf);
54921af68beaSAlexander Stetsenko }
54931af68beaSAlexander Stetsenko }
54941af68beaSAlexander Stetsenko
54951af68beaSAlexander Stetsenko (void) sprintf(id, "%u", rid);
54961af68beaSAlexander Stetsenko who = id;
54971af68beaSAlexander Stetsenko
54981af68beaSAlexander Stetsenko store_allow_perm(who_type, opts->local,
54991af68beaSAlexander Stetsenko opts->descend, who, opts->perms, *nvlp);
55001af68beaSAlexander Stetsenko curr = delim + 1;
55011af68beaSAlexander Stetsenko }
55021af68beaSAlexander Stetsenko }
55031af68beaSAlexander Stetsenko
55041af68beaSAlexander Stetsenko return (0);
55051af68beaSAlexander Stetsenko }
55061af68beaSAlexander Stetsenko
55071af68beaSAlexander Stetsenko static void
print_set_creat_perms(uu_avl_t * who_avl)55081af68beaSAlexander Stetsenko print_set_creat_perms(uu_avl_t *who_avl)
55091af68beaSAlexander Stetsenko {
55101af68beaSAlexander Stetsenko const char *sc_title[] = {
55111af68beaSAlexander Stetsenko gettext("Permission sets:\n"),
55121af68beaSAlexander Stetsenko gettext("Create time permissions:\n"),
55131af68beaSAlexander Stetsenko NULL
55141af68beaSAlexander Stetsenko };
55151af68beaSAlexander Stetsenko who_perm_node_t *who_node = NULL;
55161af68beaSAlexander Stetsenko int prev_weight = -1;
55171af68beaSAlexander Stetsenko
55181af68beaSAlexander Stetsenko for (who_node = uu_avl_first(who_avl); who_node != NULL;
55191af68beaSAlexander Stetsenko who_node = uu_avl_next(who_avl, who_node)) {
55201af68beaSAlexander Stetsenko uu_avl_t *avl = who_node->who_perm.who_deleg_perm_avl;
55211af68beaSAlexander Stetsenko zfs_deleg_who_type_t who_type = who_node->who_perm.who_type;
55221af68beaSAlexander Stetsenko const char *who_name = who_node->who_perm.who_name;
55231af68beaSAlexander Stetsenko int weight = who_type2weight(who_type);
55241af68beaSAlexander Stetsenko boolean_t first = B_TRUE;
55251af68beaSAlexander Stetsenko deleg_perm_node_t *deleg_node;
55261af68beaSAlexander Stetsenko
55271af68beaSAlexander Stetsenko if (prev_weight != weight) {
552851463258SBill Sommerfeld VERIFY3S(weight, >=, 0);
552951463258SBill Sommerfeld VERIFY3S(weight, <=, 1);
553051463258SBill Sommerfeld (void) printf(sc_title[weight]);
55311af68beaSAlexander Stetsenko prev_weight = weight;
55321af68beaSAlexander Stetsenko }
55331af68beaSAlexander Stetsenko
55341af68beaSAlexander Stetsenko if (who_name == NULL || strnlen(who_name, 1) == 0)
55351af68beaSAlexander Stetsenko (void) printf("\t");
55361af68beaSAlexander Stetsenko else
55371af68beaSAlexander Stetsenko (void) printf("\t%s ", who_name);
55381af68beaSAlexander Stetsenko
55391af68beaSAlexander Stetsenko for (deleg_node = uu_avl_first(avl); deleg_node != NULL;
55401af68beaSAlexander Stetsenko deleg_node = uu_avl_next(avl, deleg_node)) {
55411af68beaSAlexander Stetsenko if (first) {
55421af68beaSAlexander Stetsenko (void) printf("%s",
55431af68beaSAlexander Stetsenko deleg_node->dpn_perm.dp_name);
55441af68beaSAlexander Stetsenko first = B_FALSE;
55451af68beaSAlexander Stetsenko } else
55461af68beaSAlexander Stetsenko (void) printf(",%s",
55471af68beaSAlexander Stetsenko deleg_node->dpn_perm.dp_name);
55481af68beaSAlexander Stetsenko }
55491af68beaSAlexander Stetsenko
55501af68beaSAlexander Stetsenko (void) printf("\n");
55511af68beaSAlexander Stetsenko }
55521af68beaSAlexander Stetsenko }
555398579b20Snd
5554c16bcc45SIgor Kozhukhov static void
print_uge_deleg_perms(uu_avl_t * who_avl,boolean_t local,boolean_t descend,const char * title)55551af68beaSAlexander Stetsenko print_uge_deleg_perms(uu_avl_t *who_avl, boolean_t local, boolean_t descend,
55561af68beaSAlexander Stetsenko const char *title)
55571af68beaSAlexander Stetsenko {
55581af68beaSAlexander Stetsenko who_perm_node_t *who_node = NULL;
55591af68beaSAlexander Stetsenko boolean_t prt_title = B_TRUE;
55601af68beaSAlexander Stetsenko uu_avl_walk_t *walk;
55613cb34c60Sahrens
55621af68beaSAlexander Stetsenko if ((walk = uu_avl_walk_start(who_avl, UU_WALK_ROBUST)) == NULL)
55631af68beaSAlexander Stetsenko nomem();
55643cb34c60Sahrens
55651af68beaSAlexander Stetsenko while ((who_node = uu_avl_walk_next(walk)) != NULL) {
55661af68beaSAlexander Stetsenko const char *who_name = who_node->who_perm.who_name;
55671af68beaSAlexander Stetsenko const char *nice_who_name = who_node->who_perm.who_ug_name;
55681af68beaSAlexander Stetsenko uu_avl_t *avl = who_node->who_perm.who_deleg_perm_avl;
55691af68beaSAlexander Stetsenko zfs_deleg_who_type_t who_type = who_node->who_perm.who_type;
55701af68beaSAlexander Stetsenko char delim = ' ';
55711af68beaSAlexander Stetsenko deleg_perm_node_t *deleg_node;
55721af68beaSAlexander Stetsenko boolean_t prt_who = B_TRUE;
55731af68beaSAlexander Stetsenko
55741af68beaSAlexander Stetsenko for (deleg_node = uu_avl_first(avl);
55751af68beaSAlexander Stetsenko deleg_node != NULL;
55761af68beaSAlexander Stetsenko deleg_node = uu_avl_next(avl, deleg_node)) {
55771af68beaSAlexander Stetsenko if (local != deleg_node->dpn_perm.dp_local ||
55781af68beaSAlexander Stetsenko descend != deleg_node->dpn_perm.dp_descend)
55791af68beaSAlexander Stetsenko continue;
55801af68beaSAlexander Stetsenko
55811af68beaSAlexander Stetsenko if (prt_who) {
55821af68beaSAlexander Stetsenko const char *who = NULL;
55831af68beaSAlexander Stetsenko if (prt_title) {
55841af68beaSAlexander Stetsenko prt_title = B_FALSE;
55851af68beaSAlexander Stetsenko (void) printf(title);
55861af68beaSAlexander Stetsenko }
55871af68beaSAlexander Stetsenko
55881af68beaSAlexander Stetsenko switch (who_type) {
55891af68beaSAlexander Stetsenko case ZFS_DELEG_USER_SETS:
55901af68beaSAlexander Stetsenko case ZFS_DELEG_USER:
55911af68beaSAlexander Stetsenko who = gettext("user");
55921af68beaSAlexander Stetsenko if (nice_who_name)
55931af68beaSAlexander Stetsenko who_name = nice_who_name;
55941af68beaSAlexander Stetsenko break;
55951af68beaSAlexander Stetsenko case ZFS_DELEG_GROUP_SETS:
55961af68beaSAlexander Stetsenko case ZFS_DELEG_GROUP:
55971af68beaSAlexander Stetsenko who = gettext("group");
55981af68beaSAlexander Stetsenko if (nice_who_name)
55991af68beaSAlexander Stetsenko who_name = nice_who_name;
56001af68beaSAlexander Stetsenko break;
56011af68beaSAlexander Stetsenko case ZFS_DELEG_EVERYONE_SETS:
56021af68beaSAlexander Stetsenko case ZFS_DELEG_EVERYONE:
56031af68beaSAlexander Stetsenko who = gettext("everyone");
56041af68beaSAlexander Stetsenko who_name = NULL;
5605c16bcc45SIgor Kozhukhov break;
5606c16bcc45SIgor Kozhukhov
5607c16bcc45SIgor Kozhukhov default:
5608c16bcc45SIgor Kozhukhov assert(who != NULL);
56091af68beaSAlexander Stetsenko }
56101af68beaSAlexander Stetsenko
56111af68beaSAlexander Stetsenko prt_who = B_FALSE;
56121af68beaSAlexander Stetsenko if (who_name == NULL)
56131af68beaSAlexander Stetsenko (void) printf("\t%s", who);
56141af68beaSAlexander Stetsenko else
56151af68beaSAlexander Stetsenko (void) printf("\t%s %s", who, who_name);
56163cb34c60Sahrens }
56171af68beaSAlexander Stetsenko
56181af68beaSAlexander Stetsenko (void) printf("%c%s", delim,
56191af68beaSAlexander Stetsenko deleg_node->dpn_perm.dp_name);
56201af68beaSAlexander Stetsenko delim = ',';
562198579b20Snd }
5622fa9e4066Sahrens
56231af68beaSAlexander Stetsenko if (!prt_who)
56241af68beaSAlexander Stetsenko (void) printf("\n");
56251af68beaSAlexander Stetsenko }
56263cb34c60Sahrens
56271af68beaSAlexander Stetsenko uu_avl_walk_end(walk);
56281af68beaSAlexander Stetsenko }
56293f9d6ad7SLin Ling
56301af68beaSAlexander Stetsenko static void
print_fs_perms(fs_perm_set_t * fspset)56311af68beaSAlexander Stetsenko print_fs_perms(fs_perm_set_t *fspset)
56321af68beaSAlexander Stetsenko {
56331af68beaSAlexander Stetsenko fs_perm_node_t *node = NULL;
56349adfa60dSMatthew Ahrens char buf[MAXNAMELEN + 32];
56351af68beaSAlexander Stetsenko const char *dsname = buf;
56361af68beaSAlexander Stetsenko
56371af68beaSAlexander Stetsenko for (node = uu_list_first(fspset->fsps_list); node != NULL;
56381af68beaSAlexander Stetsenko node = uu_list_next(fspset->fsps_list, node)) {
56391af68beaSAlexander Stetsenko uu_avl_t *sc_avl = node->fspn_fsperm.fsp_sc_avl;
56401af68beaSAlexander Stetsenko uu_avl_t *uge_avl = node->fspn_fsperm.fsp_uge_avl;
56411af68beaSAlexander Stetsenko int left = 0;
56421af68beaSAlexander Stetsenko
56439adfa60dSMatthew Ahrens (void) snprintf(buf, sizeof (buf),
56441af68beaSAlexander Stetsenko gettext("---- Permissions on %s "),
56451af68beaSAlexander Stetsenko node->fspn_fsperm.fsp_name);
56461af68beaSAlexander Stetsenko (void) printf(dsname);
56471af68beaSAlexander Stetsenko left = 70 - strlen(buf);
56481af68beaSAlexander Stetsenko while (left-- > 0)
56491af68beaSAlexander Stetsenko (void) printf("-");
56501af68beaSAlexander Stetsenko (void) printf("\n");
56511af68beaSAlexander Stetsenko
56521af68beaSAlexander Stetsenko print_set_creat_perms(sc_avl);
56531af68beaSAlexander Stetsenko print_uge_deleg_perms(uge_avl, B_TRUE, B_FALSE,
56541af68beaSAlexander Stetsenko gettext("Local permissions:\n"));
56551af68beaSAlexander Stetsenko print_uge_deleg_perms(uge_avl, B_FALSE, B_TRUE,
56561af68beaSAlexander Stetsenko gettext("Descendent permissions:\n"));
56571af68beaSAlexander Stetsenko print_uge_deleg_perms(uge_avl, B_TRUE, B_TRUE,
56581af68beaSAlexander Stetsenko gettext("Local+Descendent permissions:\n"));
56593f9d6ad7SLin Ling }
56601af68beaSAlexander Stetsenko }
5661fa9e4066Sahrens
56621af68beaSAlexander Stetsenko static fs_perm_set_t fs_perm_set = { NULL, NULL, NULL, NULL };
56631af68beaSAlexander Stetsenko
56641af68beaSAlexander Stetsenko struct deleg_perms {
56651af68beaSAlexander Stetsenko boolean_t un;
56661af68beaSAlexander Stetsenko nvlist_t *nvl;
56671af68beaSAlexander Stetsenko };
56681af68beaSAlexander Stetsenko
56691af68beaSAlexander Stetsenko static int
set_deleg_perms(zfs_handle_t * zhp,void * data)56701af68beaSAlexander Stetsenko set_deleg_perms(zfs_handle_t *zhp, void *data)
56711af68beaSAlexander Stetsenko {
56721af68beaSAlexander Stetsenko struct deleg_perms *perms = (struct deleg_perms *)data;
56731af68beaSAlexander Stetsenko zfs_type_t zfs_type = zfs_get_type(zhp);
56741af68beaSAlexander Stetsenko
56751af68beaSAlexander Stetsenko if (zfs_type != ZFS_TYPE_FILESYSTEM && zfs_type != ZFS_TYPE_VOLUME)
56761af68beaSAlexander Stetsenko return (0);
56771af68beaSAlexander Stetsenko
56781af68beaSAlexander Stetsenko return (zfs_set_fsacl(zhp, perms->un, perms->nvl));
5679fa9e4066Sahrens }
5680fa9e4066Sahrens
5681fa9e4066Sahrens static int
zfs_do_allow_unallow_impl(int argc,char ** argv,boolean_t un)56821af68beaSAlexander Stetsenko zfs_do_allow_unallow_impl(int argc, char **argv, boolean_t un)
5683fa9e4066Sahrens {
56841af68beaSAlexander Stetsenko zfs_handle_t *zhp;
56851af68beaSAlexander Stetsenko nvlist_t *perm_nvl = NULL;
56861af68beaSAlexander Stetsenko nvlist_t *update_perm_nvl = NULL;
56871af68beaSAlexander Stetsenko int error = 1;
56881af68beaSAlexander Stetsenko int c;
56891af68beaSAlexander Stetsenko struct allow_opts opts = { 0 };
5690fa9e4066Sahrens
56911af68beaSAlexander Stetsenko const char *optstr = un ? "ldugecsrh" : "ldugecsh";
56921af68beaSAlexander Stetsenko
56931af68beaSAlexander Stetsenko /* check opts */
56941af68beaSAlexander Stetsenko while ((c = getopt(argc, argv, optstr)) != -1) {
5695fa9e4066Sahrens switch (c) {
56961af68beaSAlexander Stetsenko case 'l':
56971af68beaSAlexander Stetsenko opts.local = B_TRUE;
56981af68beaSAlexander Stetsenko break;
5699fa9e4066Sahrens case 'd':
57001af68beaSAlexander Stetsenko opts.descend = B_TRUE;
5701fa9e4066Sahrens break;
57021af68beaSAlexander Stetsenko case 'u':
57031af68beaSAlexander Stetsenko opts.user = B_TRUE;
5704f64930f5STom Erickson break;
57051af68beaSAlexander Stetsenko case 'g':
57061af68beaSAlexander Stetsenko opts.group = B_TRUE;
5707fa9e4066Sahrens break;
57081af68beaSAlexander Stetsenko case 'e':
57091af68beaSAlexander Stetsenko opts.everyone = B_TRUE;
571033408eefSLori Alt break;
57111af68beaSAlexander Stetsenko case 's':
57121af68beaSAlexander Stetsenko opts.set = B_TRUE;
5713fa9e4066Sahrens break;
57141af68beaSAlexander Stetsenko case 'c':
57151af68beaSAlexander Stetsenko opts.create = B_TRUE;
57161af68beaSAlexander Stetsenko break;
57171af68beaSAlexander Stetsenko case 'r':
57181af68beaSAlexander Stetsenko opts.recursive = B_TRUE;
571998579b20Snd break;
5720fa9e4066Sahrens case ':':
5721fa9e4066Sahrens (void) fprintf(stderr, gettext("missing argument for "
5722fa9e4066Sahrens "'%c' option\n"), optopt);
572399653d4eSeschrock usage(B_FALSE);
5724fa9e4066Sahrens break;
57251af68beaSAlexander Stetsenko case 'h':
57261af68beaSAlexander Stetsenko opts.prt_usage = B_TRUE;
57271af68beaSAlexander Stetsenko break;
5728fa9e4066Sahrens case '?':
5729fa9e4066Sahrens (void) fprintf(stderr, gettext("invalid option '%c'\n"),
5730fa9e4066Sahrens optopt);
573199653d4eSeschrock usage(B_FALSE);
5732fa9e4066Sahrens }
5733fa9e4066Sahrens }
5734fa9e4066Sahrens
5735fa9e4066Sahrens argc -= optind;
5736fa9e4066Sahrens argv += optind;
5737fa9e4066Sahrens
57381af68beaSAlexander Stetsenko /* check arguments */
57391af68beaSAlexander Stetsenko parse_allow_args(argc, argv, un, &opts);
57401af68beaSAlexander Stetsenko
57411af68beaSAlexander Stetsenko /* try to open the dataset */
5742a640714eSAlexander Eremin if ((zhp = zfs_open(g_zfs, opts.dataset, ZFS_TYPE_FILESYSTEM |
5743a640714eSAlexander Eremin ZFS_TYPE_VOLUME)) == NULL) {
5744a640714eSAlexander Eremin (void) fprintf(stderr, "Failed to open dataset: %s\n",
57451af68beaSAlexander Stetsenko opts.dataset);
57461af68beaSAlexander Stetsenko return (-1);
5747fa9e4066Sahrens }
57481af68beaSAlexander Stetsenko
57491af68beaSAlexander Stetsenko if (zfs_get_fsacl(zhp, &perm_nvl) != 0)
57501af68beaSAlexander Stetsenko goto cleanup2;
57511af68beaSAlexander Stetsenko
57521af68beaSAlexander Stetsenko fs_perm_set_init(&fs_perm_set);
57531af68beaSAlexander Stetsenko if (parse_fs_perm_set(&fs_perm_set, perm_nvl) != 0) {
5754a640714eSAlexander Eremin (void) fprintf(stderr, "Failed to parse fsacl permissions\n");
57551af68beaSAlexander Stetsenko goto cleanup1;
5756fa9e4066Sahrens }
5757fa9e4066Sahrens
57581af68beaSAlexander Stetsenko if (opts.prt_perms)
57591af68beaSAlexander Stetsenko print_fs_perms(&fs_perm_set);
57601af68beaSAlexander Stetsenko else {
57611af68beaSAlexander Stetsenko (void) construct_fsacl_list(un, &opts, &update_perm_nvl);
57621af68beaSAlexander Stetsenko if (zfs_set_fsacl(zhp, un, update_perm_nvl) != 0)
57631af68beaSAlexander Stetsenko goto cleanup0;
57641af68beaSAlexander Stetsenko
57651af68beaSAlexander Stetsenko if (un && opts.recursive) {
57661af68beaSAlexander Stetsenko struct deleg_perms data = { un, update_perm_nvl };
57671af68beaSAlexander Stetsenko if (zfs_iter_filesystems(zhp, set_deleg_perms,
57681af68beaSAlexander Stetsenko &data) != 0)
57691af68beaSAlexander Stetsenko goto cleanup0;
57701af68beaSAlexander Stetsenko }
5771fa9e4066Sahrens }
5772fa9e4066Sahrens
57731af68beaSAlexander Stetsenko error = 0;
577406eeb2adSek
57751af68beaSAlexander Stetsenko cleanup0:
57761af68beaSAlexander Stetsenko nvlist_free(perm_nvl);
5777aab83bb8SJosef 'Jeff' Sipek nvlist_free(update_perm_nvl);
57781af68beaSAlexander Stetsenko cleanup1:
57791af68beaSAlexander Stetsenko fs_perm_set_fini(&fs_perm_set);
57801af68beaSAlexander Stetsenko cleanup2:
57811af68beaSAlexander Stetsenko zfs_close(zhp);
57821af68beaSAlexander Stetsenko
57831af68beaSAlexander Stetsenko return (error);
57841af68beaSAlexander Stetsenko }
57851af68beaSAlexander Stetsenko
57861af68beaSAlexander Stetsenko static int
zfs_do_allow(int argc,char ** argv)57871af68beaSAlexander Stetsenko zfs_do_allow(int argc, char **argv)
57881af68beaSAlexander Stetsenko {
57891af68beaSAlexander Stetsenko return (zfs_do_allow_unallow_impl(argc, argv, B_FALSE));
57901af68beaSAlexander Stetsenko }
57911af68beaSAlexander Stetsenko
57921af68beaSAlexander Stetsenko static int
zfs_do_unallow(int argc,char ** argv)57931af68beaSAlexander Stetsenko zfs_do_unallow(int argc, char **argv)
57941af68beaSAlexander Stetsenko {
57951af68beaSAlexander Stetsenko return (zfs_do_allow_unallow_impl(argc, argv, B_TRUE));
5796ecd6cf80Smarks }
5797ecd6cf80Smarks
5798842727c2SChris Kirby static int
zfs_do_hold_rele_impl(int argc,char ** argv,boolean_t holding)5799842727c2SChris Kirby zfs_do_hold_rele_impl(int argc, char **argv, boolean_t holding)
5800842727c2SChris Kirby {
5801842727c2SChris Kirby int errors = 0;
5802842727c2SChris Kirby int i;
5803842727c2SChris Kirby const char *tag;
5804842727c2SChris Kirby boolean_t recursive = B_FALSE;
5805ca45db41SChris Kirby const char *opts = holding ? "rt" : "r";
5806842727c2SChris Kirby int c;
5807842727c2SChris Kirby
5808842727c2SChris Kirby /* check options */
5809ca45db41SChris Kirby while ((c = getopt(argc, argv, opts)) != -1) {
5810842727c2SChris Kirby switch (c) {
5811842727c2SChris Kirby case 'r':
5812842727c2SChris Kirby recursive = B_TRUE;
5813842727c2SChris Kirby break;
5814842727c2SChris Kirby case '?':
5815842727c2SChris Kirby (void) fprintf(stderr, gettext("invalid option '%c'\n"),
5816842727c2SChris Kirby optopt);
5817842727c2SChris Kirby usage(B_FALSE);
5818842727c2SChris Kirby }
5819842727c2SChris Kirby }
5820842727c2SChris Kirby
5821842727c2SChris Kirby argc -= optind;
5822842727c2SChris Kirby argv += optind;
5823842727c2SChris Kirby
5824842727c2SChris Kirby /* check number of arguments */
5825842727c2SChris Kirby if (argc < 2)
5826842727c2SChris Kirby usage(B_FALSE);
5827842727c2SChris Kirby
5828842727c2SChris Kirby tag = argv[0];
5829842727c2SChris Kirby --argc;
5830842727c2SChris Kirby ++argv;
5831842727c2SChris Kirby
5832ca45db41SChris Kirby if (holding && tag[0] == '.') {
5833ca45db41SChris Kirby /* tags starting with '.' are reserved for libzfs */
5834ca45db41SChris Kirby (void) fprintf(stderr, gettext("tag may not start with '.'\n"));
5835ca45db41SChris Kirby usage(B_FALSE);
5836842727c2SChris Kirby }
5837842727c2SChris Kirby
5838842727c2SChris Kirby for (i = 0; i < argc; ++i) {
5839842727c2SChris Kirby zfs_handle_t *zhp;
58409adfa60dSMatthew Ahrens char parent[ZFS_MAX_DATASET_NAME_LEN];
5841842727c2SChris Kirby const char *delim;
5842842727c2SChris Kirby char *path = argv[i];
5843842727c2SChris Kirby
5844842727c2SChris Kirby delim = strchr(path, '@');
5845842727c2SChris Kirby if (delim == NULL) {
5846842727c2SChris Kirby (void) fprintf(stderr,
5847842727c2SChris Kirby gettext("'%s' is not a snapshot\n"), path);
5848842727c2SChris Kirby ++errors;
5849842727c2SChris Kirby continue;
5850842727c2SChris Kirby }
5851842727c2SChris Kirby (void) strncpy(parent, path, delim - path);
5852842727c2SChris Kirby parent[delim - path] = '\0';
5853842727c2SChris Kirby
5854842727c2SChris Kirby zhp = zfs_open(g_zfs, parent,
5855842727c2SChris Kirby ZFS_TYPE_FILESYSTEM | ZFS_TYPE_VOLUME);
5856842727c2SChris Kirby if (zhp == NULL) {
5857842727c2SChris Kirby ++errors;
5858842727c2SChris Kirby continue;
5859842727c2SChris Kirby }
5860ca45db41SChris Kirby if (holding) {
5861a7a845e4SSteven Hartland if (zfs_hold(zhp, delim+1, tag, recursive, -1) != 0)
5862ca45db41SChris Kirby ++errors;
5863ca45db41SChris Kirby } else {
5864ca45db41SChris Kirby if (zfs_release(zhp, delim+1, tag, recursive) != 0)
5865ca45db41SChris Kirby ++errors;
5866ca45db41SChris Kirby }
5867842727c2SChris Kirby zfs_close(zhp);
5868842727c2SChris Kirby }
5869842727c2SChris Kirby
5870842727c2SChris Kirby return (errors != 0);
5871842727c2SChris Kirby }
5872842727c2SChris Kirby
5873842727c2SChris Kirby /*
5874ca45db41SChris Kirby * zfs hold [-r] [-t] <tag> <snap> ...
5875842727c2SChris Kirby *
587692241e0bSTom Erickson * -r Recursively hold
5877842727c2SChris Kirby *
5878842727c2SChris Kirby * Apply a user-hold with the given tag to the list of snapshots.
5879842727c2SChris Kirby */
5880842727c2SChris Kirby static int
zfs_do_hold(int argc,char ** argv)5881842727c2SChris Kirby zfs_do_hold(int argc, char **argv)
5882842727c2SChris Kirby {
5883842727c2SChris Kirby return (zfs_do_hold_rele_impl(argc, argv, B_TRUE));
5884842727c2SChris Kirby }
5885842727c2SChris Kirby
5886842727c2SChris Kirby /*
5887842727c2SChris Kirby * zfs release [-r] <tag> <snap> ...
5888842727c2SChris Kirby *
588992241e0bSTom Erickson * -r Recursively release
5890842727c2SChris Kirby *
5891842727c2SChris Kirby * Release a user-hold with the given tag from the list of snapshots.
5892842727c2SChris Kirby */
5893842727c2SChris Kirby static int
zfs_do_release(int argc,char ** argv)5894842727c2SChris Kirby zfs_do_release(int argc, char **argv)
5895842727c2SChris Kirby {
5896842727c2SChris Kirby return (zfs_do_hold_rele_impl(argc, argv, B_FALSE));
5897842727c2SChris Kirby }
5898842727c2SChris Kirby
58991af68beaSAlexander Stetsenko typedef struct holds_cbdata {
59001af68beaSAlexander Stetsenko boolean_t cb_recursive;
59011af68beaSAlexander Stetsenko const char *cb_snapname;
59021af68beaSAlexander Stetsenko nvlist_t **cb_nvlp;
59031af68beaSAlexander Stetsenko size_t cb_max_namelen;
59041af68beaSAlexander Stetsenko size_t cb_max_taglen;
59051af68beaSAlexander Stetsenko } holds_cbdata_t;
59061af68beaSAlexander Stetsenko
59071af68beaSAlexander Stetsenko #define STRFTIME_FMT_STR "%a %b %e %k:%M %Y"
59081af68beaSAlexander Stetsenko #define DATETIME_BUF_LEN (32)
59091af68beaSAlexander Stetsenko /*
59101af68beaSAlexander Stetsenko *
59111af68beaSAlexander Stetsenko */
59121af68beaSAlexander Stetsenko static void
print_holds(boolean_t scripted,size_t nwidth,size_t tagwidth,nvlist_t * nvl)59131af68beaSAlexander Stetsenko print_holds(boolean_t scripted, size_t nwidth, size_t tagwidth, nvlist_t *nvl)
59141af68beaSAlexander Stetsenko {
59151af68beaSAlexander Stetsenko int i;
59161af68beaSAlexander Stetsenko nvpair_t *nvp = NULL;
59171af68beaSAlexander Stetsenko char *hdr_cols[] = { "NAME", "TAG", "TIMESTAMP" };
59181af68beaSAlexander Stetsenko const char *col;
59191af68beaSAlexander Stetsenko
59201af68beaSAlexander Stetsenko if (!scripted) {
59211af68beaSAlexander Stetsenko for (i = 0; i < 3; i++) {
59221af68beaSAlexander Stetsenko col = gettext(hdr_cols[i]);
59231af68beaSAlexander Stetsenko if (i < 2)
59241af68beaSAlexander Stetsenko (void) printf("%-*s ", i ? tagwidth : nwidth,
59251af68beaSAlexander Stetsenko col);
59261af68beaSAlexander Stetsenko else
59271af68beaSAlexander Stetsenko (void) printf("%s\n", col);
59281af68beaSAlexander Stetsenko }
59291af68beaSAlexander Stetsenko }
59301af68beaSAlexander Stetsenko
59311af68beaSAlexander Stetsenko while ((nvp = nvlist_next_nvpair(nvl, nvp)) != NULL) {
59321af68beaSAlexander Stetsenko char *zname = nvpair_name(nvp);
59331af68beaSAlexander Stetsenko nvlist_t *nvl2;
59341af68beaSAlexander Stetsenko nvpair_t *nvp2 = NULL;
59351af68beaSAlexander Stetsenko (void) nvpair_value_nvlist(nvp, &nvl2);
59361af68beaSAlexander Stetsenko while ((nvp2 = nvlist_next_nvpair(nvl2, nvp2)) != NULL) {
59371af68beaSAlexander Stetsenko char tsbuf[DATETIME_BUF_LEN];
59381af68beaSAlexander Stetsenko char *tagname = nvpair_name(nvp2);
59391af68beaSAlexander Stetsenko uint64_t val = 0;
59401af68beaSAlexander Stetsenko time_t time;
59411af68beaSAlexander Stetsenko struct tm t;
59421af68beaSAlexander Stetsenko
59431af68beaSAlexander Stetsenko (void) nvpair_value_uint64(nvp2, &val);
59441af68beaSAlexander Stetsenko time = (time_t)val;
59451af68beaSAlexander Stetsenko (void) localtime_r(&time, &t);
59461af68beaSAlexander Stetsenko (void) strftime(tsbuf, DATETIME_BUF_LEN,
59471af68beaSAlexander Stetsenko gettext(STRFTIME_FMT_STR), &t);
59481af68beaSAlexander Stetsenko
5949e9b7d6e7SAllan Jude if (scripted) {
5950e9b7d6e7SAllan Jude (void) printf("%s\t%s\t%s\n", zname,
5951e9b7d6e7SAllan Jude tagname, tsbuf);
5952e9b7d6e7SAllan Jude } else {
5953e9b7d6e7SAllan Jude (void) printf("%-*s %-*s %s\n", nwidth,
5954e9b7d6e7SAllan Jude zname, tagwidth, tagname, tsbuf);
5955e9b7d6e7SAllan Jude }
59561af68beaSAlexander Stetsenko }
59571af68beaSAlexander Stetsenko }
59581af68beaSAlexander Stetsenko }
59591af68beaSAlexander Stetsenko
59601af68beaSAlexander Stetsenko /*
59611af68beaSAlexander Stetsenko * Generic callback function to list a dataset or snapshot.
59621af68beaSAlexander Stetsenko */
59631af68beaSAlexander Stetsenko static int
holds_callback(zfs_handle_t * zhp,void * data)59641af68beaSAlexander Stetsenko holds_callback(zfs_handle_t *zhp, void *data)
59651af68beaSAlexander Stetsenko {
59661af68beaSAlexander Stetsenko holds_cbdata_t *cbp = data;
59671af68beaSAlexander Stetsenko nvlist_t *top_nvl = *cbp->cb_nvlp;
59681af68beaSAlexander Stetsenko nvlist_t *nvl = NULL;
59691af68beaSAlexander Stetsenko nvpair_t *nvp = NULL;
59701af68beaSAlexander Stetsenko const char *zname = zfs_get_name(zhp);
59719adfa60dSMatthew Ahrens size_t znamelen = strlen(zname);
59721af68beaSAlexander Stetsenko
59731af68beaSAlexander Stetsenko if (cbp->cb_recursive) {
59741af68beaSAlexander Stetsenko const char *snapname;
59751af68beaSAlexander Stetsenko char *delim = strchr(zname, '@');
59761af68beaSAlexander Stetsenko if (delim == NULL)
59771af68beaSAlexander Stetsenko return (0);
59781af68beaSAlexander Stetsenko
59791af68beaSAlexander Stetsenko snapname = delim + 1;
59801af68beaSAlexander Stetsenko if (strcmp(cbp->cb_snapname, snapname))
59811af68beaSAlexander Stetsenko return (0);
59821af68beaSAlexander Stetsenko }
59831af68beaSAlexander Stetsenko
59841af68beaSAlexander Stetsenko if (zfs_get_holds(zhp, &nvl) != 0)
59851af68beaSAlexander Stetsenko return (-1);
59861af68beaSAlexander Stetsenko
59871af68beaSAlexander Stetsenko if (znamelen > cbp->cb_max_namelen)
59881af68beaSAlexander Stetsenko cbp->cb_max_namelen = znamelen;
59891af68beaSAlexander Stetsenko
59901af68beaSAlexander Stetsenko while ((nvp = nvlist_next_nvpair(nvl, nvp)) != NULL) {
59911af68beaSAlexander Stetsenko const char *tag = nvpair_name(nvp);
59929adfa60dSMatthew Ahrens size_t taglen = strlen(tag);
59931af68beaSAlexander Stetsenko if (taglen > cbp->cb_max_taglen)
59941af68beaSAlexander Stetsenko cbp->cb_max_taglen = taglen;
59951af68beaSAlexander Stetsenko }
59961af68beaSAlexander Stetsenko
59971af68beaSAlexander Stetsenko return (nvlist_add_nvlist(top_nvl, zname, nvl));
59981af68beaSAlexander Stetsenko }
59991af68beaSAlexander Stetsenko
60001af68beaSAlexander Stetsenko /*
60011af68beaSAlexander Stetsenko * zfs holds [-r] <snap> ...
60021af68beaSAlexander Stetsenko *
60031af68beaSAlexander Stetsenko * -r Recursively hold
60041af68beaSAlexander Stetsenko */
60051af68beaSAlexander Stetsenko static int
zfs_do_holds(int argc,char ** argv)60061af68beaSAlexander Stetsenko zfs_do_holds(int argc, char **argv)
60071af68beaSAlexander Stetsenko {
60081af68beaSAlexander Stetsenko int errors = 0;
60091af68beaSAlexander Stetsenko int c;
60101af68beaSAlexander Stetsenko int i;
60111af68beaSAlexander Stetsenko boolean_t scripted = B_FALSE;
60121af68beaSAlexander Stetsenko boolean_t recursive = B_FALSE;
60131af68beaSAlexander Stetsenko const char *opts = "rH";
60141af68beaSAlexander Stetsenko nvlist_t *nvl;
60151af68beaSAlexander Stetsenko
60161af68beaSAlexander Stetsenko int types = ZFS_TYPE_SNAPSHOT;
60171af68beaSAlexander Stetsenko holds_cbdata_t cb = { 0 };
60181af68beaSAlexander Stetsenko
60191af68beaSAlexander Stetsenko int limit = 0;
602005c998d6SRichard Lowe int ret = 0;
60211af68beaSAlexander Stetsenko int flags = 0;
60221af68beaSAlexander Stetsenko
60231af68beaSAlexander Stetsenko /* check options */
60241af68beaSAlexander Stetsenko while ((c = getopt(argc, argv, opts)) != -1) {
60251af68beaSAlexander Stetsenko switch (c) {
60261af68beaSAlexander Stetsenko case 'r':
60271af68beaSAlexander Stetsenko recursive = B_TRUE;
60281af68beaSAlexander Stetsenko break;
60291af68beaSAlexander Stetsenko case 'H':
60301af68beaSAlexander Stetsenko scripted = B_TRUE;
60311af68beaSAlexander Stetsenko break;
60321af68beaSAlexander Stetsenko case '?':
60331af68beaSAlexander Stetsenko (void) fprintf(stderr, gettext("invalid option '%c'\n"),
60341af68beaSAlexander Stetsenko optopt);
60351af68beaSAlexander Stetsenko usage(B_FALSE);
60361af68beaSAlexander Stetsenko }
60371af68beaSAlexander Stetsenko }
60381af68beaSAlexander Stetsenko
60391af68beaSAlexander Stetsenko if (recursive) {
60401af68beaSAlexander Stetsenko types |= ZFS_TYPE_FILESYSTEM | ZFS_TYPE_VOLUME;
60411af68beaSAlexander Stetsenko flags |= ZFS_ITER_RECURSE;
60421af68beaSAlexander Stetsenko }
60431af68beaSAlexander Stetsenko
60441af68beaSAlexander Stetsenko argc -= optind;
60451af68beaSAlexander Stetsenko argv += optind;
60461af68beaSAlexander Stetsenko
60471af68beaSAlexander Stetsenko /* check number of arguments */
60481af68beaSAlexander Stetsenko if (argc < 1)
60491af68beaSAlexander Stetsenko usage(B_FALSE);
60501af68beaSAlexander Stetsenko
60511af68beaSAlexander Stetsenko if (nvlist_alloc(&nvl, NV_UNIQUE_NAME, 0) != 0)
60521af68beaSAlexander Stetsenko nomem();
60531af68beaSAlexander Stetsenko
60541af68beaSAlexander Stetsenko for (i = 0; i < argc; ++i) {
60551af68beaSAlexander Stetsenko char *snapshot = argv[i];
60561af68beaSAlexander Stetsenko const char *delim;
60571af68beaSAlexander Stetsenko const char *snapname;
60581af68beaSAlexander Stetsenko
60591af68beaSAlexander Stetsenko delim = strchr(snapshot, '@');
60601af68beaSAlexander Stetsenko if (delim == NULL) {
60611af68beaSAlexander Stetsenko (void) fprintf(stderr,
60621af68beaSAlexander Stetsenko gettext("'%s' is not a snapshot\n"), snapshot);
60631af68beaSAlexander Stetsenko ++errors;
60641af68beaSAlexander Stetsenko continue;
60651af68beaSAlexander Stetsenko }
60661af68beaSAlexander Stetsenko snapname = delim + 1;
60671af68beaSAlexander Stetsenko if (recursive)
60681af68beaSAlexander Stetsenko snapshot[delim - snapshot] = '\0';
60691af68beaSAlexander Stetsenko
60701af68beaSAlexander Stetsenko cb.cb_recursive = recursive;
60711af68beaSAlexander Stetsenko cb.cb_snapname = snapname;
60721af68beaSAlexander Stetsenko cb.cb_nvlp = &nvl;
60731af68beaSAlexander Stetsenko
60741af68beaSAlexander Stetsenko /*
60751af68beaSAlexander Stetsenko * 1. collect holds data, set format options
60761af68beaSAlexander Stetsenko */
60771e9e241fSAndrew Stormont ret = zfs_for_each(1, &argv[i], flags, types, NULL, NULL, limit,
60781af68beaSAlexander Stetsenko holds_callback, &cb);
60791af68beaSAlexander Stetsenko if (ret != 0)
60801af68beaSAlexander Stetsenko ++errors;
60811af68beaSAlexander Stetsenko }
60821af68beaSAlexander Stetsenko
60831af68beaSAlexander Stetsenko /*
60841af68beaSAlexander Stetsenko * 2. print holds data
60851af68beaSAlexander Stetsenko */
60861af68beaSAlexander Stetsenko print_holds(scripted, cb.cb_max_namelen, cb.cb_max_taglen, nvl);
60871af68beaSAlexander Stetsenko
60881af68beaSAlexander Stetsenko nvlist_free(nvl);
60891af68beaSAlexander Stetsenko
60901af68beaSAlexander Stetsenko return (0 != errors);
60911af68beaSAlexander Stetsenko }
60921af68beaSAlexander Stetsenko
6093dae68f5eSmmusante #define CHECK_SPINNER 30
6094dae68f5eSmmusante #define SPINNER_TIME 3 /* seconds */
6095591e0e13SSebastien Roy #define MOUNT_TIME 1 /* seconds */
6096591e0e13SSebastien Roy
6097591e0e13SSebastien Roy typedef struct get_all_state {
6098591e0e13SSebastien Roy boolean_t ga_verbose;
6099591e0e13SSebastien Roy get_all_cb_t *ga_cbp;
6100591e0e13SSebastien Roy } get_all_state_t;
6101dae68f5eSmmusante
61027f7322feSeschrock static int
get_one_dataset(zfs_handle_t * zhp,void * data)6103f3861e1aSahl get_one_dataset(zfs_handle_t *zhp, void *data)
61047f7322feSeschrock {
6105a8b6ddafSMark J Musante static char *spin[] = { "-", "\\", "|", "/" };
6106dae68f5eSmmusante static int spinval = 0;
6107dae68f5eSmmusante static int spincheck = 0;
6108dae68f5eSmmusante static time_t last_spin_time = (time_t)0;
6109591e0e13SSebastien Roy get_all_state_t *state = data;
6110f3861e1aSahl zfs_type_t type = zfs_get_type(zhp);
6111f3861e1aSahl
6112591e0e13SSebastien Roy if (state->ga_verbose) {
6113dae68f5eSmmusante if (--spincheck < 0) {
6114dae68f5eSmmusante time_t now = time(NULL);
6115dae68f5eSmmusante if (last_spin_time + SPINNER_TIME < now) {
6116a8b6ddafSMark J Musante update_progress(spin[spinval++ % 4]);
6117dae68f5eSmmusante last_spin_time = now;
6118dae68f5eSmmusante }
6119dae68f5eSmmusante spincheck = CHECK_SPINNER;
6120dae68f5eSmmusante }
6121dae68f5eSmmusante }
6122dae68f5eSmmusante
6123f3861e1aSahl /*
6124f3861e1aSahl * Interate over any nested datasets.
6125f3861e1aSahl */
61269d9a58e3SEric Taylor if (zfs_iter_filesystems(zhp, get_one_dataset, data) != 0) {
61273ccfa83cSahrens zfs_close(zhp);
6128f3861e1aSahl return (1);
6129f3861e1aSahl }
61307f7322feSeschrock
61317f7322feSeschrock /*
6132f3861e1aSahl * Skip any datasets whose type does not match.
61337f7322feSeschrock */
61349d9a58e3SEric Taylor if ((type & ZFS_TYPE_FILESYSTEM) == 0) {
61357f7322feSeschrock zfs_close(zhp);
61367f7322feSeschrock return (0);
61377f7322feSeschrock }
6138591e0e13SSebastien Roy libzfs_add_handle(state->ga_cbp, zhp);
6139591e0e13SSebastien Roy assert(state->ga_cbp->cb_used <= state->ga_cbp->cb_alloc);
61407f7322feSeschrock
6141f3861e1aSahl return (0);
61427f7322feSeschrock }
61437f7322feSeschrock
61447f7322feSeschrock static void
get_all_datasets(get_all_cb_t * cbp,boolean_t verbose)6145591e0e13SSebastien Roy get_all_datasets(get_all_cb_t *cbp, boolean_t verbose)
61467f7322feSeschrock {
6147591e0e13SSebastien Roy get_all_state_t state = {
6148591e0e13SSebastien Roy .ga_verbose = verbose,
6149591e0e13SSebastien Roy .ga_cbp = cbp
6150591e0e13SSebastien Roy };
6151dae68f5eSmmusante
6152a8b6ddafSMark J Musante if (verbose)
6153a8b6ddafSMark J Musante set_progress_header(gettext("Reading ZFS config"));
6154591e0e13SSebastien Roy (void) zfs_iter_root(g_zfs, get_one_dataset, &state);
6155dae68f5eSmmusante
6156a8b6ddafSMark J Musante if (verbose)
6157a8b6ddafSMark J Musante finish_progress(gettext("done."));
61587f7322feSeschrock }
61597f7322feSeschrock
6160fa9e4066Sahrens /*
6161fa9e4066Sahrens * Generic callback for sharing or mounting filesystems. Because the code is so
6162fa9e4066Sahrens * similar, we have a common function with an extra parameter to determine which
6163fa9e4066Sahrens * mode we are using.
6164fa9e4066Sahrens */
6165591e0e13SSebastien Roy typedef enum { OP_SHARE, OP_MOUNT } share_mount_op_t;
6166591e0e13SSebastien Roy
6167591e0e13SSebastien Roy typedef struct share_mount_state {
6168591e0e13SSebastien Roy share_mount_op_t sm_op;
6169591e0e13SSebastien Roy boolean_t sm_verbose;
6170591e0e13SSebastien Roy int sm_flags;
6171591e0e13SSebastien Roy char *sm_options;
6172591e0e13SSebastien Roy char *sm_proto; /* only valid for OP_SHARE */
6173591e0e13SSebastien Roy mutex_t sm_lock; /* protects the remaining fields */
6174591e0e13SSebastien Roy uint_t sm_total; /* number of filesystems to process */
6175591e0e13SSebastien Roy uint_t sm_done; /* number of filesystems processed */
6176591e0e13SSebastien Roy int sm_status; /* -1 if any of the share/mount operations failed */
6177591e0e13SSebastien Roy } share_mount_state_t;
6178fa9e4066Sahrens
6179fa9e4066Sahrens /*
6180f3861e1aSahl * Share or mount a dataset.
6181fa9e4066Sahrens */
6182fa9e4066Sahrens static int
share_mount_one(zfs_handle_t * zhp,int op,int flags,char * protocol,boolean_t explicit,const char * options)6183da6c28aaSamw share_mount_one(zfs_handle_t *zhp, int op, int flags, char *protocol,
6184da6c28aaSamw boolean_t explicit, const char *options)
6185fa9e4066Sahrens {
6186fa9e4066Sahrens char mountpoint[ZFS_MAXPROPLEN];
6187fa9e4066Sahrens char shareopts[ZFS_MAXPROPLEN];
6188da6c28aaSamw char smbshareopts[ZFS_MAXPROPLEN];
6189f3861e1aSahl const char *cmdname = op == OP_SHARE ? "share" : "mount";
6190fa9e4066Sahrens struct mnttab mnt;
6191e9dbad6fSeschrock uint64_t zoned, canmount;
6192da6c28aaSamw boolean_t shared_nfs, shared_smb;
6193fa9e4066Sahrens
61949d9a58e3SEric Taylor assert(zfs_get_type(zhp) & ZFS_TYPE_FILESYSTEM);
6195fa9e4066Sahrens
61969d9a58e3SEric Taylor /*
61979d9a58e3SEric Taylor * Check to make sure we can mount/share this dataset. If we
61989d9a58e3SEric Taylor * are in the global zone and the filesystem is exported to a
61999d9a58e3SEric Taylor * local zone, or if we are in a local zone and the
62009d9a58e3SEric Taylor * filesystem is not exported, then it is an error.
62019d9a58e3SEric Taylor */
62029d9a58e3SEric Taylor zoned = zfs_prop_get_int(zhp, ZFS_PROP_ZONED);
6203fa9e4066Sahrens
62049d9a58e3SEric Taylor if (zoned && getzoneid() == GLOBAL_ZONEID) {
62059d9a58e3SEric Taylor if (!explicit)
62069d9a58e3SEric Taylor return (0);
6207fa9e4066Sahrens
62089d9a58e3SEric Taylor (void) fprintf(stderr, gettext("cannot %s '%s': "
62099d9a58e3SEric Taylor "dataset is exported to a local zone\n"), cmdname,
62109d9a58e3SEric Taylor zfs_get_name(zhp));
62119d9a58e3SEric Taylor return (1);
6212fa9e4066Sahrens
62139d9a58e3SEric Taylor } else if (!zoned && getzoneid() != GLOBAL_ZONEID) {
62149d9a58e3SEric Taylor if (!explicit)
62159d9a58e3SEric Taylor return (0);
6216fa9e4066Sahrens
62179d9a58e3SEric Taylor (void) fprintf(stderr, gettext("cannot %s '%s': "
62189d9a58e3SEric Taylor "permission denied\n"), cmdname,
62199d9a58e3SEric Taylor zfs_get_name(zhp));
62209d9a58e3SEric Taylor return (1);
62219d9a58e3SEric Taylor }
6222fa9e4066Sahrens
62239d9a58e3SEric Taylor /*
62249d9a58e3SEric Taylor * Ignore any filesystems which don't apply to us. This
62259d9a58e3SEric Taylor * includes those with a legacy mountpoint, or those with
62269d9a58e3SEric Taylor * legacy share options.
62279d9a58e3SEric Taylor */
62289d9a58e3SEric Taylor verify(zfs_prop_get(zhp, ZFS_PROP_MOUNTPOINT, mountpoint,
62299d9a58e3SEric Taylor sizeof (mountpoint), NULL, NULL, 0, B_FALSE) == 0);
62309d9a58e3SEric Taylor verify(zfs_prop_get(zhp, ZFS_PROP_SHARENFS, shareopts,
62319d9a58e3SEric Taylor sizeof (shareopts), NULL, NULL, 0, B_FALSE) == 0);
62329d9a58e3SEric Taylor verify(zfs_prop_get(zhp, ZFS_PROP_SHARESMB, smbshareopts,
62339d9a58e3SEric Taylor sizeof (smbshareopts), NULL, NULL, 0, B_FALSE) == 0);
62349d9a58e3SEric Taylor
62359d9a58e3SEric Taylor if (op == OP_SHARE && strcmp(shareopts, "off") == 0 &&
62369d9a58e3SEric Taylor strcmp(smbshareopts, "off") == 0) {
62379d9a58e3SEric Taylor if (!explicit)
62389d9a58e3SEric Taylor return (0);
6239fa9e4066Sahrens
62409d9a58e3SEric Taylor (void) fprintf(stderr, gettext("cannot share '%s': "
62419d9a58e3SEric Taylor "legacy share\n"), zfs_get_name(zhp));
6242bbf21555SRichard Lowe (void) fprintf(stderr, gettext("use share(8) to "
62439d9a58e3SEric Taylor "share this filesystem, or set "
62449d9a58e3SEric Taylor "sharenfs property on\n"));
62459d9a58e3SEric Taylor return (1);
62469d9a58e3SEric Taylor }
6247fa9e4066Sahrens
62489d9a58e3SEric Taylor /*
62499d9a58e3SEric Taylor * We cannot share or mount legacy filesystems. If the
62509d9a58e3SEric Taylor * shareopts is non-legacy but the mountpoint is legacy, we
62519d9a58e3SEric Taylor * treat it as a legacy share.
62529d9a58e3SEric Taylor */
62539d9a58e3SEric Taylor if (strcmp(mountpoint, "legacy") == 0) {
62549d9a58e3SEric Taylor if (!explicit)
62559d9a58e3SEric Taylor return (0);
6256fa9e4066Sahrens
62579d9a58e3SEric Taylor (void) fprintf(stderr, gettext("cannot %s '%s': "
62589d9a58e3SEric Taylor "legacy mountpoint\n"), cmdname, zfs_get_name(zhp));
6259bbf21555SRichard Lowe (void) fprintf(stderr, gettext("use %s(8) to "
62609d9a58e3SEric Taylor "%s this filesystem\n"), cmdname, cmdname);
62619d9a58e3SEric Taylor return (1);
62629d9a58e3SEric Taylor }
6263fa9e4066Sahrens
62649d9a58e3SEric Taylor if (strcmp(mountpoint, "none") == 0) {
62659d9a58e3SEric Taylor if (!explicit)
62669d9a58e3SEric Taylor return (0);
6267fa9e4066Sahrens
62689d9a58e3SEric Taylor (void) fprintf(stderr, gettext("cannot %s '%s': no "
62699d9a58e3SEric Taylor "mountpoint set\n"), cmdname, zfs_get_name(zhp));
62709d9a58e3SEric Taylor return (1);
62719d9a58e3SEric Taylor }
6272e9dbad6fSeschrock
62739d9a58e3SEric Taylor /*
62749d9a58e3SEric Taylor * canmount explicit outcome
62759d9a58e3SEric Taylor * on no pass through
62769d9a58e3SEric Taylor * on yes pass through
62779d9a58e3SEric Taylor * off no return 0
62789d9a58e3SEric Taylor * off yes display error, return 1
62799d9a58e3SEric Taylor * noauto no return 0
62809d9a58e3SEric Taylor * noauto yes pass through
62819d9a58e3SEric Taylor */
62829d9a58e3SEric Taylor canmount = zfs_prop_get_int(zhp, ZFS_PROP_CANMOUNT);
62839d9a58e3SEric Taylor if (canmount == ZFS_CANMOUNT_OFF) {
62849d9a58e3SEric Taylor if (!explicit)
62859d9a58e3SEric Taylor return (0);
62869d9a58e3SEric Taylor
62879d9a58e3SEric Taylor (void) fprintf(stderr, gettext("cannot %s '%s': "
62889d9a58e3SEric Taylor "'canmount' property is set to 'off'\n"), cmdname,
62899d9a58e3SEric Taylor zfs_get_name(zhp));
62909d9a58e3SEric Taylor return (1);
62919d9a58e3SEric Taylor } else if (canmount == ZFS_CANMOUNT_NOAUTO && !explicit) {
62929d9a58e3SEric Taylor return (0);
62939d9a58e3SEric Taylor }
62949d9a58e3SEric Taylor
6295eb633035STom Caputi /*
6296eb633035STom Caputi * If this filesystem is encrypted and does not have
6297eb633035STom Caputi * a loaded key, we can not mount it.
6298eb633035STom Caputi */
6299eb633035STom Caputi if ((flags & MS_CRYPT) == 0 &&
6300eb633035STom Caputi zfs_prop_get_int(zhp, ZFS_PROP_ENCRYPTION) != ZIO_CRYPT_OFF &&
6301eb633035STom Caputi zfs_prop_get_int(zhp, ZFS_PROP_KEYSTATUS) ==
6302eb633035STom Caputi ZFS_KEYSTATUS_UNAVAILABLE) {
6303eb633035STom Caputi if (!explicit)
6304eb633035STom Caputi return (0);
6305eb633035STom Caputi
6306eb633035STom Caputi (void) fprintf(stderr, gettext("cannot %s '%s': "
6307eb633035STom Caputi "encryption key not loaded\n"), cmdname, zfs_get_name(zhp));
6308eb633035STom Caputi return (1);
6309eb633035STom Caputi }
6310eb633035STom Caputi
63119c3fd121SMatthew Ahrens /*
63129c3fd121SMatthew Ahrens * If this filesystem is inconsistent and has a receive resume
63139c3fd121SMatthew Ahrens * token, we can not mount it.
63149c3fd121SMatthew Ahrens */
63159c3fd121SMatthew Ahrens if (zfs_prop_get_int(zhp, ZFS_PROP_INCONSISTENT) &&
63169c3fd121SMatthew Ahrens zfs_prop_get(zhp, ZFS_PROP_RECEIVE_RESUME_TOKEN,
63179c3fd121SMatthew Ahrens NULL, 0, NULL, NULL, 0, B_TRUE) == 0) {
63189c3fd121SMatthew Ahrens if (!explicit)
63199c3fd121SMatthew Ahrens return (0);
63209c3fd121SMatthew Ahrens
63219c3fd121SMatthew Ahrens (void) fprintf(stderr, gettext("cannot %s '%s': "
63229c3fd121SMatthew Ahrens "Contains partially-completed state from "
63236ccda740Sloli "\"zfs receive -s\", which can be resumed with "
63249c3fd121SMatthew Ahrens "\"zfs send -t\"\n"),
63259c3fd121SMatthew Ahrens cmdname, zfs_get_name(zhp));
63269c3fd121SMatthew Ahrens return (1);
63279c3fd121SMatthew Ahrens }
63289c3fd121SMatthew Ahrens
63299d9a58e3SEric Taylor /*
63309d9a58e3SEric Taylor * At this point, we have verified that the mountpoint and/or
63319d9a58e3SEric Taylor * shareopts are appropriate for auto management. If the
63329d9a58e3SEric Taylor * filesystem is already mounted or shared, return (failing
63339d9a58e3SEric Taylor * for explicit requests); otherwise mount or share the
63349d9a58e3SEric Taylor * filesystem.
63359d9a58e3SEric Taylor */
63369d9a58e3SEric Taylor switch (op) {
63379d9a58e3SEric Taylor case OP_SHARE:
63389d9a58e3SEric Taylor
63399d9a58e3SEric Taylor shared_nfs = zfs_is_shared_nfs(zhp, NULL);
63409d9a58e3SEric Taylor shared_smb = zfs_is_shared_smb(zhp, NULL);
63419d9a58e3SEric Taylor
6342c16bcc45SIgor Kozhukhov if ((shared_nfs && shared_smb) ||
63439d9a58e3SEric Taylor (shared_nfs && strcmp(shareopts, "on") == 0 &&
63449d9a58e3SEric Taylor strcmp(smbshareopts, "off") == 0) ||
63459d9a58e3SEric Taylor (shared_smb && strcmp(smbshareopts, "on") == 0 &&
63469d9a58e3SEric Taylor strcmp(shareopts, "off") == 0)) {
6347f3861e1aSahl if (!explicit)
6348f3861e1aSahl return (0);
6349e9dbad6fSeschrock
63509d9a58e3SEric Taylor (void) fprintf(stderr, gettext("cannot share "
63519d9a58e3SEric Taylor "'%s': filesystem already shared\n"),
6352f3861e1aSahl zfs_get_name(zhp));
6353f3861e1aSahl return (1);
6354f3861e1aSahl }
6355f3861e1aSahl
63569d9a58e3SEric Taylor if (!zfs_is_mounted(zhp, NULL) &&
6357eb633035STom Caputi zfs_mount(zhp, NULL, flags) != 0)
63589d9a58e3SEric Taylor return (1);
6359fa9e4066Sahrens
63609d9a58e3SEric Taylor if (protocol == NULL) {
63619d9a58e3SEric Taylor if (zfs_shareall(zhp) != 0)
6362fa9e4066Sahrens return (1);
63639d9a58e3SEric Taylor } else if (strcmp(protocol, "nfs") == 0) {
63649d9a58e3SEric Taylor if (zfs_share_nfs(zhp))
6365f3861e1aSahl return (1);
63669d9a58e3SEric Taylor } else if (strcmp(protocol, "smb") == 0) {
63679d9a58e3SEric Taylor if (zfs_share_smb(zhp))
6368f3861e1aSahl return (1);
63699d9a58e3SEric Taylor } else {
63709d9a58e3SEric Taylor (void) fprintf(stderr, gettext("cannot share "
63719d9a58e3SEric Taylor "'%s': invalid share type '%s' "
63729d9a58e3SEric Taylor "specified\n"),
63739d9a58e3SEric Taylor zfs_get_name(zhp), protocol);
63749d9a58e3SEric Taylor return (1);
63759d9a58e3SEric Taylor }
6376da6c28aaSamw
63779d9a58e3SEric Taylor break;
6378f3861e1aSahl
63799d9a58e3SEric Taylor case OP_MOUNT:
63809d9a58e3SEric Taylor if (options == NULL)
63819d9a58e3SEric Taylor mnt.mnt_mntopts = "";
63829d9a58e3SEric Taylor else
63839d9a58e3SEric Taylor mnt.mnt_mntopts = (char *)options;
6384f3861e1aSahl
63859d9a58e3SEric Taylor if (!hasmntopt(&mnt, MNTOPT_REMOUNT) &&
63869d9a58e3SEric Taylor zfs_is_mounted(zhp, NULL)) {
63879d9a58e3SEric Taylor if (!explicit)
63889d9a58e3SEric Taylor return (0);
6389fa9e4066Sahrens
63909d9a58e3SEric Taylor (void) fprintf(stderr, gettext("cannot mount "
63919d9a58e3SEric Taylor "'%s': filesystem already mounted\n"),
63929d9a58e3SEric Taylor zfs_get_name(zhp));
63939d9a58e3SEric Taylor return (1);
6394f3861e1aSahl }
63959d9a58e3SEric Taylor
63969d9a58e3SEric Taylor if (zfs_mount(zhp, options, flags) != 0)
63979d9a58e3SEric Taylor return (1);
63989d9a58e3SEric Taylor break;
63999d9a58e3SEric Taylor }
6400fa9e4066Sahrens
6401fa9e4066Sahrens return (0);
6402fa9e4066Sahrens }
6403fa9e4066Sahrens
6404dae68f5eSmmusante /*
6405dae68f5eSmmusante * Reports progress in the form "(current/total)". Not thread-safe.
6406dae68f5eSmmusante */
6407dae68f5eSmmusante static void
report_mount_progress(int current,int total)6408dae68f5eSmmusante report_mount_progress(int current, int total)
6409dae68f5eSmmusante {
6410a8b6ddafSMark J Musante static time_t last_progress_time = 0;
6411dae68f5eSmmusante time_t now = time(NULL);
6412a8b6ddafSMark J Musante char info[32];
6413dae68f5eSmmusante
6414dae68f5eSmmusante /* display header if we're here for the first time */
6415dae68f5eSmmusante if (current == 1) {
6416a8b6ddafSMark J Musante set_progress_header(gettext("Mounting ZFS filesystems"));
64173cb34c60Sahrens } else if (current != total && last_progress_time + MOUNT_TIME >= now) {
64183cb34c60Sahrens /* too soon to report again */
64193cb34c60Sahrens return;
64203cb34c60Sahrens }
6421dae68f5eSmmusante
6422dae68f5eSmmusante last_progress_time = now;
6423dae68f5eSmmusante
6424a8b6ddafSMark J Musante (void) sprintf(info, "(%d/%d)", current, total);
6425dae68f5eSmmusante
6426a8b6ddafSMark J Musante if (current == total)
6427a8b6ddafSMark J Musante finish_progress(info);
6428a8b6ddafSMark J Musante else
6429a8b6ddafSMark J Musante update_progress(info);
6430dae68f5eSmmusante }
6431dae68f5eSmmusante
6432591e0e13SSebastien Roy /*
6433591e0e13SSebastien Roy * zfs_foreach_mountpoint() callback that mounts or shares one filesystem and
6434591e0e13SSebastien Roy * updates the progress meter.
6435591e0e13SSebastien Roy */
6436591e0e13SSebastien Roy static int
share_mount_one_cb(zfs_handle_t * zhp,void * arg)6437591e0e13SSebastien Roy share_mount_one_cb(zfs_handle_t *zhp, void *arg)
6438591e0e13SSebastien Roy {
6439591e0e13SSebastien Roy share_mount_state_t *sms = arg;
6440591e0e13SSebastien Roy int ret;
6441591e0e13SSebastien Roy
6442591e0e13SSebastien Roy ret = share_mount_one(zhp, sms->sm_op, sms->sm_flags, sms->sm_proto,
6443591e0e13SSebastien Roy B_FALSE, sms->sm_options);
6444591e0e13SSebastien Roy
6445591e0e13SSebastien Roy mutex_enter(&sms->sm_lock);
6446591e0e13SSebastien Roy if (ret != 0)
6447591e0e13SSebastien Roy sms->sm_status = ret;
6448591e0e13SSebastien Roy sms->sm_done++;
6449591e0e13SSebastien Roy if (sms->sm_verbose)
6450591e0e13SSebastien Roy report_mount_progress(sms->sm_done, sms->sm_total);
6451591e0e13SSebastien Roy mutex_exit(&sms->sm_lock);
6452591e0e13SSebastien Roy return (ret);
6453591e0e13SSebastien Roy }
6454591e0e13SSebastien Roy
6455c6ef114fSmmusante static void
append_options(char * mntopts,char * newopts)6456c6ef114fSmmusante append_options(char *mntopts, char *newopts)
6457c6ef114fSmmusante {
6458c6ef114fSmmusante int len = strlen(mntopts);
6459c6ef114fSmmusante
6460c6ef114fSmmusante /* original length plus new string to append plus 1 for the comma */
6461c6ef114fSmmusante if (len + 1 + strlen(newopts) >= MNT_LINE_MAX) {
6462c6ef114fSmmusante (void) fprintf(stderr, gettext("the opts argument for "
6463c6ef114fSmmusante "'%c' option is too long (more than %d chars)\n"),
6464c6ef114fSmmusante "-o", MNT_LINE_MAX);
6465c6ef114fSmmusante usage(B_FALSE);
6466c6ef114fSmmusante }
6467c6ef114fSmmusante
6468c6ef114fSmmusante if (*mntopts)
6469c6ef114fSmmusante mntopts[len++] = ',';
6470c6ef114fSmmusante
6471c6ef114fSmmusante (void) strcpy(&mntopts[len], newopts);
6472c6ef114fSmmusante }
6473c6ef114fSmmusante
6474fa9e4066Sahrens static int
share_mount(int op,int argc,char ** argv)6475f3861e1aSahl share_mount(int op, int argc, char **argv)
6476fa9e4066Sahrens {
6477fa9e4066Sahrens int do_all = 0;
6478dae68f5eSmmusante boolean_t verbose = B_FALSE;
647916299908Slling int c, ret = 0;
6480c6ef114fSmmusante char *options = NULL;
64819d9a58e3SEric Taylor int flags = 0;
6482fa9e4066Sahrens
6483fa9e4066Sahrens /* check options */
6484eb633035STom Caputi while ((c = getopt(argc, argv, op == OP_MOUNT ? ":alvo:O" : "al"))
6485fa9e4066Sahrens != -1) {
6486fa9e4066Sahrens switch (c) {
6487fa9e4066Sahrens case 'a':
6488fa9e4066Sahrens do_all = 1;
6489fa9e4066Sahrens break;
6490dae68f5eSmmusante case 'v':
6491dae68f5eSmmusante verbose = B_TRUE;
6492dae68f5eSmmusante break;
6493eb633035STom Caputi case 'l':
6494eb633035STom Caputi flags |= MS_CRYPT;
6495eb633035STom Caputi break;
6496fa9e4066Sahrens case 'o':
6497c6ef114fSmmusante if (*optarg == '\0') {
6498c6ef114fSmmusante (void) fprintf(stderr, gettext("empty mount "
6499c6ef114fSmmusante "options (-o) specified\n"));
6500c6ef114fSmmusante usage(B_FALSE);
6501ce5e3b86Srm }
6502c6ef114fSmmusante
6503c6ef114fSmmusante if (options == NULL)
6504c6ef114fSmmusante options = safe_malloc(MNT_LINE_MAX + 1);
6505c6ef114fSmmusante
6506c6ef114fSmmusante /* option validation is done later */
6507c6ef114fSmmusante append_options(options, optarg);
6508fa9e4066Sahrens break;
6509ce5e3b86Srm
6510fa9e4066Sahrens case 'O':
6511f3861e1aSahl flags |= MS_OVERLAY;
6512fa9e4066Sahrens break;
6513fa9e4066Sahrens case ':':
6514fa9e4066Sahrens (void) fprintf(stderr, gettext("missing argument for "
6515fa9e4066Sahrens "'%c' option\n"), optopt);
651699653d4eSeschrock usage(B_FALSE);
6517fa9e4066Sahrens break;
6518fa9e4066Sahrens case '?':
6519fa9e4066Sahrens (void) fprintf(stderr, gettext("invalid option '%c'\n"),
6520fa9e4066Sahrens optopt);
652199653d4eSeschrock usage(B_FALSE);
6522fa9e4066Sahrens }
6523fa9e4066Sahrens }
6524fa9e4066Sahrens
6525fa9e4066Sahrens argc -= optind;
6526fa9e4066Sahrens argv += optind;
6527fa9e4066Sahrens
6528fa9e4066Sahrens /* check number of arguments */
6529fa9e4066Sahrens if (do_all) {
6530da6c28aaSamw char *protocol = NULL;
65317f7322feSeschrock
65329d9a58e3SEric Taylor if (op == OP_SHARE && argc > 0) {
65339d9a58e3SEric Taylor if (strcmp(argv[0], "nfs") != 0 &&
65349d9a58e3SEric Taylor strcmp(argv[0], "smb") != 0) {
6535f3861e1aSahl (void) fprintf(stderr, gettext("share type "
6536ab003da8SJim Dunham "must be 'nfs' or 'smb'\n"));
6537f3861e1aSahl usage(B_FALSE);
6538f3861e1aSahl }
6539da6c28aaSamw protocol = argv[0];
6540f3861e1aSahl argc--;
6541f3861e1aSahl argv++;
6542f3861e1aSahl }
6543f3861e1aSahl
6544fa9e4066Sahrens if (argc != 0) {
6545fa9e4066Sahrens (void) fprintf(stderr, gettext("too many arguments\n"));
654699653d4eSeschrock usage(B_FALSE);
6547fa9e4066Sahrens }
6548fa9e4066Sahrens
6549a8b6ddafSMark J Musante start_progress_timer();
6550591e0e13SSebastien Roy get_all_cb_t cb = { 0 };
6551591e0e13SSebastien Roy get_all_datasets(&cb, verbose);
65527f7322feSeschrock
6553591e0e13SSebastien Roy if (cb.cb_used == 0)
65547f7322feSeschrock return (0);
65557f7322feSeschrock
6556591e0e13SSebastien Roy if (op == OP_SHARE) {
6557591e0e13SSebastien Roy sa_init_selective_arg_t sharearg;
6558591e0e13SSebastien Roy sharearg.zhandle_arr = cb.cb_handles;
6559591e0e13SSebastien Roy sharearg.zhandle_len = cb.cb_used;
6560591e0e13SSebastien Roy if ((ret = zfs_init_libshare_arg(g_zfs,
6561591e0e13SSebastien Roy SA_INIT_SHARE_API_SELECTIVE, &sharearg)) != SA_OK) {
6562591e0e13SSebastien Roy (void) fprintf(stderr, gettext(
6563591e0e13SSebastien Roy "Could not initialize libshare, %d"), ret);
6564591e0e13SSebastien Roy return (ret);
6565591e0e13SSebastien Roy }
65668a981c33SDaniel Hoffman }
65677f7322feSeschrock
6568591e0e13SSebastien Roy share_mount_state_t share_mount_state = { 0 };
6569591e0e13SSebastien Roy share_mount_state.sm_op = op;
6570591e0e13SSebastien Roy share_mount_state.sm_verbose = verbose;
6571591e0e13SSebastien Roy share_mount_state.sm_flags = flags;
6572591e0e13SSebastien Roy share_mount_state.sm_options = options;
6573591e0e13SSebastien Roy share_mount_state.sm_proto = protocol;
6574591e0e13SSebastien Roy share_mount_state.sm_total = cb.cb_used;
6575591e0e13SSebastien Roy (void) mutex_init(&share_mount_state.sm_lock,
6576591e0e13SSebastien Roy LOCK_NORMAL | LOCK_ERRORCHECK, NULL);
6577591e0e13SSebastien Roy /*
6578591e0e13SSebastien Roy * libshare isn't mt-safe, so only do the operation in parallel
6579591e0e13SSebastien Roy * if we're mounting.
6580591e0e13SSebastien Roy */
6581591e0e13SSebastien Roy zfs_foreach_mountpoint(g_zfs, cb.cb_handles, cb.cb_used,
6582591e0e13SSebastien Roy share_mount_one_cb, &share_mount_state, op == OP_MOUNT);
6583591e0e13SSebastien Roy ret = share_mount_state.sm_status;
65847f7322feSeschrock
6585591e0e13SSebastien Roy for (int i = 0; i < cb.cb_used; i++)
6586591e0e13SSebastien Roy zfs_close(cb.cb_handles[i]);
6587591e0e13SSebastien Roy free(cb.cb_handles);
6588fa9e4066Sahrens } else if (argc == 0) {
6589fa9e4066Sahrens struct mnttab entry;
6590fa9e4066Sahrens
6591ce5e3b86Srm if ((op == OP_SHARE) || (options != NULL)) {
6592fa9e4066Sahrens (void) fprintf(stderr, gettext("missing filesystem "
6593ce5e3b86Srm "argument (specify -a for all)\n"));
659499653d4eSeschrock usage(B_FALSE);
6595fa9e4066Sahrens }
6596fa9e4066Sahrens
6597fa9e4066Sahrens /*
6598fa9e4066Sahrens * When mount is given no arguments, go through /etc/mnttab and
6599fa9e4066Sahrens * display any active ZFS mounts. We hide any snapshots, since
6600fa9e4066Sahrens * they are controlled automatically.
6601fa9e4066Sahrens */
6602fa9e4066Sahrens rewind(mnttab_file);
6603fa9e4066Sahrens while (getmntent(mnttab_file, &entry) == 0) {
6604fa9e4066Sahrens if (strcmp(entry.mnt_fstype, MNTTYPE_ZFS) != 0 ||
6605fa9e4066Sahrens strchr(entry.mnt_special, '@') != NULL)
6606fa9e4066Sahrens continue;
6607fa9e4066Sahrens
6608fa9e4066Sahrens (void) printf("%-30s %s\n", entry.mnt_special,
6609fa9e4066Sahrens entry.mnt_mountp);
6610fa9e4066Sahrens }
6611fa9e4066Sahrens
6612fa9e4066Sahrens } else {
6613fa9e4066Sahrens zfs_handle_t *zhp;
6614fa9e4066Sahrens
6615fa9e4066Sahrens if (argc > 1) {
6616fa9e4066Sahrens (void) fprintf(stderr,
6617fa9e4066Sahrens gettext("too many arguments\n"));
661899653d4eSeschrock usage(B_FALSE);
6619fa9e4066Sahrens }
6620fa9e4066Sahrens
66219d9a58e3SEric Taylor if ((zhp = zfs_open(g_zfs, argv[0],
66229d9a58e3SEric Taylor ZFS_TYPE_FILESYSTEM)) == NULL) {
6623fa9e4066Sahrens ret = 1;
6624f3861e1aSahl } else {
6625da6c28aaSamw ret = share_mount_one(zhp, op, flags, NULL, B_TRUE,
6626f3861e1aSahl options);
6627fa9e4066Sahrens zfs_close(zhp);
6628fa9e4066Sahrens }
6629fa9e4066Sahrens }
6630fa9e4066Sahrens
6631fa9e4066Sahrens return (ret);
6632fa9e4066Sahrens }
6633fa9e4066Sahrens
6634fa9e4066Sahrens /*
6635ab003da8SJim Dunham * zfs mount -a [nfs]
6636fa9e4066Sahrens * zfs mount filesystem
6637fa9e4066Sahrens *
6638fa9e4066Sahrens * Mount all filesystems, or mount the given filesystem.
6639fa9e4066Sahrens */
6640fa9e4066Sahrens static int
zfs_do_mount(int argc,char ** argv)6641fa9e4066Sahrens zfs_do_mount(int argc, char **argv)
6642fa9e4066Sahrens {
6643f3861e1aSahl return (share_mount(OP_MOUNT, argc, argv));
6644fa9e4066Sahrens }
6645fa9e4066Sahrens
6646fa9e4066Sahrens /*
6647ab003da8SJim Dunham * zfs share -a [nfs | smb]
6648fa9e4066Sahrens * zfs share filesystem
6649fa9e4066Sahrens *
6650fa9e4066Sahrens * Share all filesystems, or share the given filesystem.
6651fa9e4066Sahrens */
6652fa9e4066Sahrens static int
zfs_do_share(int argc,char ** argv)6653fa9e4066Sahrens zfs_do_share(int argc, char **argv)
6654fa9e4066Sahrens {
6655f3861e1aSahl return (share_mount(OP_SHARE, argc, argv));
6656fa9e4066Sahrens }
6657fa9e4066Sahrens
6658fa9e4066Sahrens typedef struct unshare_unmount_node {
6659fa9e4066Sahrens zfs_handle_t *un_zhp;
6660fa9e4066Sahrens char *un_mountp;
6661fa9e4066Sahrens uu_avl_node_t un_avlnode;
6662fa9e4066Sahrens } unshare_unmount_node_t;
6663fa9e4066Sahrens
6664fa9e4066Sahrens /* ARGSUSED */
6665fa9e4066Sahrens static int
unshare_unmount_compare(const void * larg,const void * rarg,void * unused)6666fa9e4066Sahrens unshare_unmount_compare(const void *larg, const void *rarg, void *unused)
6667fa9e4066Sahrens {
6668fa9e4066Sahrens const unshare_unmount_node_t *l = larg;
6669fa9e4066Sahrens const unshare_unmount_node_t *r = rarg;
6670fa9e4066Sahrens
6671fa9e4066Sahrens return (strcmp(l->un_mountp, r->un_mountp));
6672fa9e4066Sahrens }
6673fa9e4066Sahrens
6674fa9e4066Sahrens /*
6675fa9e4066Sahrens * Convenience routine used by zfs_do_umount() and manual_unmount(). Given an
6676fa9e4066Sahrens * absolute path, find the entry /etc/mnttab, verify that its a ZFS filesystem,
6677fa9e4066Sahrens * and unmount it appropriately.
6678fa9e4066Sahrens */
6679fa9e4066Sahrens static int
unshare_unmount_path(int op,char * path,int flags,boolean_t is_manual)6680f3861e1aSahl unshare_unmount_path(int op, char *path, int flags, boolean_t is_manual)
6681fa9e4066Sahrens {
6682fa9e4066Sahrens zfs_handle_t *zhp;
668305c998d6SRichard Lowe int ret = 0;
6684fa9e4066Sahrens struct stat64 statbuf;
6685fa9e4066Sahrens struct extmnttab entry;
6686f3861e1aSahl const char *cmdname = (op == OP_SHARE) ? "unshare" : "unmount";
6687c6ef114fSmmusante ino_t path_inode;
6688fa9e4066Sahrens
6689fa9e4066Sahrens /*
6690fa9e4066Sahrens * Search for the path in /etc/mnttab. Rather than looking for the
6691fa9e4066Sahrens * specific path, which can be fooled by non-standard paths (i.e. ".."
6692fa9e4066Sahrens * or "//"), we stat() the path and search for the corresponding
6693fa9e4066Sahrens * (major,minor) device pair.
6694fa9e4066Sahrens */
6695fa9e4066Sahrens if (stat64(path, &statbuf) != 0) {
6696fa9e4066Sahrens (void) fprintf(stderr, gettext("cannot %s '%s': %s\n"),
6697fa9e4066Sahrens cmdname, path, strerror(errno));
6698fa9e4066Sahrens return (1);
6699fa9e4066Sahrens }
6700c6ef114fSmmusante path_inode = statbuf.st_ino;
6701fa9e4066Sahrens
6702fa9e4066Sahrens /*
6703fa9e4066Sahrens * Search for the given (major,minor) pair in the mount table.
6704fa9e4066Sahrens */
6705fa9e4066Sahrens rewind(mnttab_file);
6706fa9e4066Sahrens while ((ret = getextmntent(mnttab_file, &entry, 0)) == 0) {
6707fa9e4066Sahrens if (entry.mnt_major == major(statbuf.st_dev) &&
6708fa9e4066Sahrens entry.mnt_minor == minor(statbuf.st_dev))
6709fa9e4066Sahrens break;
6710fa9e4066Sahrens }
6711fa9e4066Sahrens if (ret != 0) {
671211022c7cStimh if (op == OP_SHARE) {
671311022c7cStimh (void) fprintf(stderr, gettext("cannot %s '%s': not "
671411022c7cStimh "currently mounted\n"), cmdname, path);
671511022c7cStimh return (1);
671611022c7cStimh }
671711022c7cStimh (void) fprintf(stderr, gettext("warning: %s not in mnttab\n"),
671811022c7cStimh path);
671911022c7cStimh if ((ret = umount2(path, flags)) != 0)
672011022c7cStimh (void) fprintf(stderr, gettext("%s: %s\n"), path,
672111022c7cStimh strerror(errno));
672211022c7cStimh return (ret != 0);
6723fa9e4066Sahrens }
6724fa9e4066Sahrens
6725fa9e4066Sahrens if (strcmp(entry.mnt_fstype, MNTTYPE_ZFS) != 0) {
6726fa9e4066Sahrens (void) fprintf(stderr, gettext("cannot %s '%s': not a ZFS "
6727fa9e4066Sahrens "filesystem\n"), cmdname, path);
6728fa9e4066Sahrens return (1);
6729fa9e4066Sahrens }
6730fa9e4066Sahrens
673199653d4eSeschrock if ((zhp = zfs_open(g_zfs, entry.mnt_special,
673299653d4eSeschrock ZFS_TYPE_FILESYSTEM)) == NULL)
6733fa9e4066Sahrens return (1);
6734fa9e4066Sahrens
6735c6ef114fSmmusante ret = 1;
6736d72c03d9SSachin Gaikwad if (stat64(entry.mnt_mountp, &statbuf) != 0) {
6737d72c03d9SSachin Gaikwad (void) fprintf(stderr, gettext("cannot %s '%s': %s\n"),
6738d72c03d9SSachin Gaikwad cmdname, path, strerror(errno));
6739d72c03d9SSachin Gaikwad goto out;
6740d72c03d9SSachin Gaikwad } else if (statbuf.st_ino != path_inode) {
6741d72c03d9SSachin Gaikwad (void) fprintf(stderr, gettext("cannot "
6742d72c03d9SSachin Gaikwad "%s '%s': not a mountpoint\n"), cmdname, path);
6743d72c03d9SSachin Gaikwad goto out;
6744d72c03d9SSachin Gaikwad }
6745d72c03d9SSachin Gaikwad
6746f3861e1aSahl if (op == OP_SHARE) {
6747c6ef114fSmmusante char nfs_mnt_prop[ZFS_MAXPROPLEN];
6748c6ef114fSmmusante char smbshare_prop[ZFS_MAXPROPLEN];
6749c6ef114fSmmusante
6750c6ef114fSmmusante verify(zfs_prop_get(zhp, ZFS_PROP_SHARENFS, nfs_mnt_prop,
6751c6ef114fSmmusante sizeof (nfs_mnt_prop), NULL, NULL, 0, B_FALSE) == 0);
6752c6ef114fSmmusante verify(zfs_prop_get(zhp, ZFS_PROP_SHARESMB, smbshare_prop,
6753c6ef114fSmmusante sizeof (smbshare_prop), NULL, NULL, 0, B_FALSE) == 0);
6754c6ef114fSmmusante
6755da6c28aaSamw if (strcmp(nfs_mnt_prop, "off") == 0 &&
6756da6c28aaSamw strcmp(smbshare_prop, "off") == 0) {
6757fa9e4066Sahrens (void) fprintf(stderr, gettext("cannot unshare "
6758fa9e4066Sahrens "'%s': legacy share\n"), path);
6759fa9e4066Sahrens (void) fprintf(stderr, gettext("use "
6760bbf21555SRichard Lowe "unshare(8) to unshare this filesystem\n"));
6761da6c28aaSamw } else if (!zfs_is_shared(zhp)) {
6762fa9e4066Sahrens (void) fprintf(stderr, gettext("cannot unshare '%s': "
6763fa9e4066Sahrens "not currently shared\n"), path);
6764fa9e4066Sahrens } else {
6765da6c28aaSamw ret = zfs_unshareall_bypath(zhp, path);
6766fa9e4066Sahrens }
6767fa9e4066Sahrens } else {
6768c6ef114fSmmusante char mtpt_prop[ZFS_MAXPROPLEN];
6769c6ef114fSmmusante
6770c6ef114fSmmusante verify(zfs_prop_get(zhp, ZFS_PROP_MOUNTPOINT, mtpt_prop,
6771c6ef114fSmmusante sizeof (mtpt_prop), NULL, NULL, 0, B_FALSE) == 0);
6772c6ef114fSmmusante
6773d72c03d9SSachin Gaikwad if (is_manual) {
6774c0ea9bc7Slling ret = zfs_unmount(zhp, NULL, flags);
6775c6ef114fSmmusante } else if (strcmp(mtpt_prop, "legacy") == 0) {
6776c0ea9bc7Slling (void) fprintf(stderr, gettext("cannot unmount "
6777c0ea9bc7Slling "'%s': legacy mountpoint\n"),
6778c0ea9bc7Slling zfs_get_name(zhp));
6779bbf21555SRichard Lowe (void) fprintf(stderr, gettext("use umount(8) "
6780c0ea9bc7Slling "to unmount this filesystem\n"));
6781fa9e4066Sahrens } else {
6782fa9e4066Sahrens ret = zfs_unmountall(zhp, flags);
6783fa9e4066Sahrens }
6784fa9e4066Sahrens }
6785fa9e4066Sahrens
6786d72c03d9SSachin Gaikwad out:
6787fa9e4066Sahrens zfs_close(zhp);
6788fa9e4066Sahrens
6789fa9e4066Sahrens return (ret != 0);
6790fa9e4066Sahrens }
6791fa9e4066Sahrens
6792fa9e4066Sahrens /*
6793fa9e4066Sahrens * Generic callback for unsharing or unmounting a filesystem.
6794fa9e4066Sahrens */
6795fa9e4066Sahrens static int
unshare_unmount(int op,int argc,char ** argv)6796f3861e1aSahl unshare_unmount(int op, int argc, char **argv)
6797fa9e4066Sahrens {
6798fa9e4066Sahrens int do_all = 0;
6799fa9e4066Sahrens int flags = 0;
6800fa9e4066Sahrens int ret = 0;
68019d9a58e3SEric Taylor int c;
6802fa9e4066Sahrens zfs_handle_t *zhp;
6803ab003da8SJim Dunham char nfs_mnt_prop[ZFS_MAXPROPLEN];
6804da6c28aaSamw char sharesmb[ZFS_MAXPROPLEN];
6805fa9e4066Sahrens
6806fa9e4066Sahrens /* check options */
6807f3861e1aSahl while ((c = getopt(argc, argv, op == OP_SHARE ? "a" : "af")) != -1) {
6808fa9e4066Sahrens switch (c) {
6809fa9e4066Sahrens case 'a':
6810fa9e4066Sahrens do_all = 1;
6811fa9e4066Sahrens break;
6812fa9e4066Sahrens case 'f':
6813fa9e4066Sahrens flags = MS_FORCE;
6814fa9e4066Sahrens break;
6815fa9e4066Sahrens case '?':
6816fa9e4066Sahrens (void) fprintf(stderr, gettext("invalid option '%c'\n"),
6817fa9e4066Sahrens optopt);
681899653d4eSeschrock usage(B_FALSE);
6819fa9e4066Sahrens }
6820fa9e4066Sahrens }
6821fa9e4066Sahrens
6822fa9e4066Sahrens argc -= optind;
6823fa9e4066Sahrens argv += optind;
6824fa9e4066Sahrens
6825fa9e4066Sahrens if (do_all) {
6826fa9e4066Sahrens /*
6827fa9e4066Sahrens * We could make use of zfs_for_each() to walk all datasets in
6828fa9e4066Sahrens * the system, but this would be very inefficient, especially
6829fa9e4066Sahrens * since we would have to linearly search /etc/mnttab for each
6830fa9e4066Sahrens * one. Instead, do one pass through /etc/mnttab looking for
6831fa9e4066Sahrens * zfs entries and call zfs_unmount() for each one.
6832fa9e4066Sahrens *
6833fa9e4066Sahrens * Things get a little tricky if the administrator has created
6834fa9e4066Sahrens * mountpoints beneath other ZFS filesystems. In this case, we
6835fa9e4066Sahrens * have to unmount the deepest filesystems first. To accomplish
6836fa9e4066Sahrens * this, we place all the mountpoints in an AVL tree sorted by
6837fa9e4066Sahrens * the special type (dataset name), and walk the result in
6838fa9e4066Sahrens * reverse to make sure to get any snapshots first.
6839fa9e4066Sahrens */
6840fa9e4066Sahrens struct mnttab entry;
6841fa9e4066Sahrens uu_avl_pool_t *pool;
6842c16bcc45SIgor Kozhukhov uu_avl_t *tree = NULL;
6843fa9e4066Sahrens unshare_unmount_node_t *node;
6844fa9e4066Sahrens uu_avl_index_t idx;
6845fa9e4066Sahrens uu_avl_walk_t *walk;
6846fa9e4066Sahrens
6847f3861e1aSahl if (argc != 0) {
6848f3861e1aSahl (void) fprintf(stderr, gettext("too many arguments\n"));
6849f3861e1aSahl usage(B_FALSE);
6850f3861e1aSahl }
6851f3861e1aSahl
6852a8b6ddafSMark J Musante if (((pool = uu_avl_pool_create("unmount_pool",
6853fa9e4066Sahrens sizeof (unshare_unmount_node_t),
6854fa9e4066Sahrens offsetof(unshare_unmount_node_t, un_avlnode),
6855a8b6ddafSMark J Musante unshare_unmount_compare, UU_DEFAULT)) == NULL) ||
6856a8b6ddafSMark J Musante ((tree = uu_avl_create(pool, NULL, UU_DEFAULT)) == NULL))
6857a8b6ddafSMark J Musante nomem();
6858fa9e4066Sahrens
6859fa9e4066Sahrens rewind(mnttab_file);
6860fa9e4066Sahrens while (getmntent(mnttab_file, &entry) == 0) {
6861fa9e4066Sahrens
6862fa9e4066Sahrens /* ignore non-ZFS entries */
6863fa9e4066Sahrens if (strcmp(entry.mnt_fstype, MNTTYPE_ZFS) != 0)
6864fa9e4066Sahrens continue;
6865fa9e4066Sahrens
6866fa9e4066Sahrens /* ignore snapshots */
6867fa9e4066Sahrens if (strchr(entry.mnt_special, '@') != NULL)
6868fa9e4066Sahrens continue;
6869fa9e4066Sahrens
687099653d4eSeschrock if ((zhp = zfs_open(g_zfs, entry.mnt_special,
6871fa9e4066Sahrens ZFS_TYPE_FILESYSTEM)) == NULL) {
6872fa9e4066Sahrens ret = 1;
6873fa9e4066Sahrens continue;
68748808ac5dSYuri Pankov }
68758808ac5dSYuri Pankov
68768808ac5dSYuri Pankov /*
68778808ac5dSYuri Pankov * Ignore datasets that are excluded/restricted by
68788808ac5dSYuri Pankov * parent pool name.
68798808ac5dSYuri Pankov */
68808808ac5dSYuri Pankov if (zpool_skip_pool(zfs_get_pool_name(zhp))) {
68818808ac5dSYuri Pankov zfs_close(zhp);
68828808ac5dSYuri Pankov continue;
6883fa9e4066Sahrens }
6884fa9e4066Sahrens
6885da6c28aaSamw switch (op) {
6886da6c28aaSamw case OP_SHARE:
6887da6c28aaSamw verify(zfs_prop_get(zhp, ZFS_PROP_SHARENFS,
6888ab003da8SJim Dunham nfs_mnt_prop,
6889ab003da8SJim Dunham sizeof (nfs_mnt_prop),
6890da6c28aaSamw NULL, NULL, 0, B_FALSE) == 0);
6891ab003da8SJim Dunham if (strcmp(nfs_mnt_prop, "off") != 0)
6892da6c28aaSamw break;
6893da6c28aaSamw verify(zfs_prop_get(zhp, ZFS_PROP_SHARESMB,
6894ab003da8SJim Dunham nfs_mnt_prop,
6895ab003da8SJim Dunham sizeof (nfs_mnt_prop),
6896da6c28aaSamw NULL, NULL, 0, B_FALSE) == 0);
6897ab003da8SJim Dunham if (strcmp(nfs_mnt_prop, "off") == 0)
6898da6c28aaSamw continue;
6899da6c28aaSamw break;
6900da6c28aaSamw case OP_MOUNT:
6901da6c28aaSamw /* Ignore legacy mounts */
6902da6c28aaSamw verify(zfs_prop_get(zhp, ZFS_PROP_MOUNTPOINT,
6903ab003da8SJim Dunham nfs_mnt_prop,
6904ab003da8SJim Dunham sizeof (nfs_mnt_prop),
6905da6c28aaSamw NULL, NULL, 0, B_FALSE) == 0);
6906ab003da8SJim Dunham if (strcmp(nfs_mnt_prop, "legacy") == 0)
6907da6c28aaSamw continue;
6908a227b7f4Shs /* Ignore canmount=noauto mounts */
6909a227b7f4Shs if (zfs_prop_get_int(zhp, ZFS_PROP_CANMOUNT) ==
6910a227b7f4Shs ZFS_CANMOUNT_NOAUTO)
6911a227b7f4Shs continue;
6912da6c28aaSamw default:
6913da6c28aaSamw break;
6914fa9e4066Sahrens }
6915fa9e4066Sahrens
6916fa9e4066Sahrens node = safe_malloc(sizeof (unshare_unmount_node_t));
6917fa9e4066Sahrens node->un_zhp = zhp;
6918a8b6ddafSMark J Musante node->un_mountp = safe_strdup(entry.mnt_mountp);
6919fa9e4066Sahrens
6920fa9e4066Sahrens uu_avl_node_init(node, &node->un_avlnode, pool);
6921fa9e4066Sahrens
6922fa9e4066Sahrens if (uu_avl_find(tree, node, NULL, &idx) == NULL) {
6923fa9e4066Sahrens uu_avl_insert(tree, node, idx);
6924fa9e4066Sahrens } else {
6925fa9e4066Sahrens zfs_close(node->un_zhp);
6926fa9e4066Sahrens free(node->un_mountp);
6927fa9e4066Sahrens free(node);
6928fa9e4066Sahrens }
6929fa9e4066Sahrens }
6930fa9e4066Sahrens
6931b8dc1b43SJoyce McIntosh /*
6932b8dc1b43SJoyce McIntosh * Initialize libshare SA_INIT_SHARE_API_SELECTIVE here
6933b8dc1b43SJoyce McIntosh * to avoid unnecessary load/unload of the libshare API
6934b8dc1b43SJoyce McIntosh * per shared dataset downstream.
6935b8dc1b43SJoyce McIntosh */
6936b8dc1b43SJoyce McIntosh if (op == OP_SHARE) {
6937b8dc1b43SJoyce McIntosh get_all_cb_t dslist = { 0 };
6938b8dc1b43SJoyce McIntosh get_all_datasets(&dslist, B_FALSE);
6939b8dc1b43SJoyce McIntosh
6940b8dc1b43SJoyce McIntosh if (dslist.cb_used != 0) {
6941b8dc1b43SJoyce McIntosh sa_init_selective_arg_t sharearg;
6942b8dc1b43SJoyce McIntosh sharearg.zhandle_arr = dslist.cb_handles;
6943b8dc1b43SJoyce McIntosh sharearg.zhandle_len = dslist.cb_used;
6944b8dc1b43SJoyce McIntosh if ((ret = zfs_init_libshare_arg(g_zfs,
6945b8dc1b43SJoyce McIntosh SA_INIT_SHARE_API_SELECTIVE, &sharearg)) !=
6946b8dc1b43SJoyce McIntosh SA_OK) {
6947b8dc1b43SJoyce McIntosh (void) fprintf(stderr, gettext(
6948b8dc1b43SJoyce McIntosh "Could not initialize libshare, "
6949b8dc1b43SJoyce McIntosh "%d"), ret);
6950b8dc1b43SJoyce McIntosh return (1);
6951b8dc1b43SJoyce McIntosh }
6952b8dc1b43SJoyce McIntosh }
6953b8dc1b43SJoyce McIntosh }
6954b8dc1b43SJoyce McIntosh
6955fa9e4066Sahrens /*
6956fa9e4066Sahrens * Walk the AVL tree in reverse, unmounting each filesystem and
6957fa9e4066Sahrens * removing it from the AVL tree in the process.
6958fa9e4066Sahrens */
6959fa9e4066Sahrens if ((walk = uu_avl_walk_start(tree,
6960a8b6ddafSMark J Musante UU_WALK_REVERSE | UU_WALK_ROBUST)) == NULL)
6961a8b6ddafSMark J Musante nomem();
6962fa9e4066Sahrens
6963fa9e4066Sahrens while ((node = uu_avl_walk_next(walk)) != NULL) {
6964fa9e4066Sahrens uu_avl_remove(tree, node);
6965fa9e4066Sahrens
6966f3861e1aSahl switch (op) {
6967fa9e4066Sahrens case OP_SHARE:
6968da6c28aaSamw if (zfs_unshareall_bypath(node->un_zhp,
6969fa9e4066Sahrens node->un_mountp) != 0)
6970fa9e4066Sahrens ret = 1;
6971fa9e4066Sahrens break;
6972fa9e4066Sahrens
6973fa9e4066Sahrens case OP_MOUNT:
6974fa9e4066Sahrens if (zfs_unmount(node->un_zhp,
6975fa9e4066Sahrens node->un_mountp, flags) != 0)
6976fa9e4066Sahrens ret = 1;
6977fa9e4066Sahrens break;
6978fa9e4066Sahrens }
6979fa9e4066Sahrens
6980fa9e4066Sahrens zfs_close(node->un_zhp);
6981fa9e4066Sahrens free(node->un_mountp);
6982fa9e4066Sahrens free(node);
6983fa9e4066Sahrens }
6984fa9e4066Sahrens
6985fa9e4066Sahrens uu_avl_walk_end(walk);
6986fa9e4066Sahrens uu_avl_destroy(tree);
6987fa9e4066Sahrens uu_avl_pool_destroy(pool);
6988f3861e1aSahl
6989fa9e4066Sahrens } else {
6990f3861e1aSahl if (argc != 1) {
6991f3861e1aSahl if (argc == 0)
6992f3861e1aSahl (void) fprintf(stderr,
6993f3861e1aSahl gettext("missing filesystem argument\n"));
6994f3861e1aSahl else
6995f3861e1aSahl (void) fprintf(stderr,
6996f3861e1aSahl gettext("too many arguments\n"));
6997f3861e1aSahl usage(B_FALSE);
6998f3861e1aSahl }
6999f3861e1aSahl
7000fa9e4066Sahrens /*
7001fa9e4066Sahrens * We have an argument, but it may be a full path or a ZFS
7002fa9e4066Sahrens * filesystem. Pass full paths off to unmount_path() (shared by
7003fa9e4066Sahrens * manual_unmount), otherwise open the filesystem and pass to
7004fa9e4066Sahrens * zfs_unmount().
7005fa9e4066Sahrens */
7006fa9e4066Sahrens if (argv[0][0] == '/')
7007f3861e1aSahl return (unshare_unmount_path(op, argv[0],
7008b1b8ab34Slling flags, B_FALSE));
7009fa9e4066Sahrens
70109d9a58e3SEric Taylor if ((zhp = zfs_open(g_zfs, argv[0],
70119d9a58e3SEric Taylor ZFS_TYPE_FILESYSTEM)) == NULL)
7012fa9e4066Sahrens return (1);
7013fa9e4066Sahrens
70149d9a58e3SEric Taylor verify(zfs_prop_get(zhp, op == OP_SHARE ?
70159d9a58e3SEric Taylor ZFS_PROP_SHARENFS : ZFS_PROP_MOUNTPOINT,
70169d9a58e3SEric Taylor nfs_mnt_prop, sizeof (nfs_mnt_prop), NULL,
70179d9a58e3SEric Taylor NULL, 0, B_FALSE) == 0);
7018fa9e4066Sahrens
70199d9a58e3SEric Taylor switch (op) {
70209d9a58e3SEric Taylor case OP_SHARE:
70219d9a58e3SEric Taylor verify(zfs_prop_get(zhp, ZFS_PROP_SHARENFS,
70229d9a58e3SEric Taylor nfs_mnt_prop,
70239d9a58e3SEric Taylor sizeof (nfs_mnt_prop),
70249d9a58e3SEric Taylor NULL, NULL, 0, B_FALSE) == 0);
70259d9a58e3SEric Taylor verify(zfs_prop_get(zhp, ZFS_PROP_SHARESMB,
70269d9a58e3SEric Taylor sharesmb, sizeof (sharesmb), NULL, NULL,
70279d9a58e3SEric Taylor 0, B_FALSE) == 0);
70289d9a58e3SEric Taylor
70299d9a58e3SEric Taylor if (strcmp(nfs_mnt_prop, "off") == 0 &&
70309d9a58e3SEric Taylor strcmp(sharesmb, "off") == 0) {
70319d9a58e3SEric Taylor (void) fprintf(stderr, gettext("cannot "
70329d9a58e3SEric Taylor "unshare '%s': legacy share\n"),
70339d9a58e3SEric Taylor zfs_get_name(zhp));
70349d9a58e3SEric Taylor (void) fprintf(stderr, gettext("use "
7035bbf21555SRichard Lowe "unshare(8) to unshare this "
70369d9a58e3SEric Taylor "filesystem\n"));
70379d9a58e3SEric Taylor ret = 1;
70389d9a58e3SEric Taylor } else if (!zfs_is_shared(zhp)) {
70399d9a58e3SEric Taylor (void) fprintf(stderr, gettext("cannot "
70409d9a58e3SEric Taylor "unshare '%s': not currently "
70419d9a58e3SEric Taylor "shared\n"), zfs_get_name(zhp));
70429d9a58e3SEric Taylor ret = 1;
70439d9a58e3SEric Taylor } else if (zfs_unshareall(zhp) != 0) {
70449d9a58e3SEric Taylor ret = 1;
70459d9a58e3SEric Taylor }
70469d9a58e3SEric Taylor break;
7047f3861e1aSahl
70489d9a58e3SEric Taylor case OP_MOUNT:
70499d9a58e3SEric Taylor if (strcmp(nfs_mnt_prop, "legacy") == 0) {
70509d9a58e3SEric Taylor (void) fprintf(stderr, gettext("cannot "
70519d9a58e3SEric Taylor "unmount '%s': legacy "
70529d9a58e3SEric Taylor "mountpoint\n"), zfs_get_name(zhp));
70539d9a58e3SEric Taylor (void) fprintf(stderr, gettext("use "
7054bbf21555SRichard Lowe "umount(8) to unmount this "
70559d9a58e3SEric Taylor "filesystem\n"));
70569d9a58e3SEric Taylor ret = 1;
70579d9a58e3SEric Taylor } else if (!zfs_is_mounted(zhp, NULL)) {
70589d9a58e3SEric Taylor (void) fprintf(stderr, gettext("cannot "
70599d9a58e3SEric Taylor "unmount '%s': not currently "
70609d9a58e3SEric Taylor "mounted\n"),
70619d9a58e3SEric Taylor zfs_get_name(zhp));
70629d9a58e3SEric Taylor ret = 1;
70639d9a58e3SEric Taylor } else if (zfs_unmountall(zhp, flags) != 0) {
70649d9a58e3SEric Taylor ret = 1;
7065fa9e4066Sahrens }
70669d9a58e3SEric Taylor break;
7067fa9e4066Sahrens }
7068fa9e4066Sahrens
7069fa9e4066Sahrens zfs_close(zhp);
7070fa9e4066Sahrens }
7071fa9e4066Sahrens
7072fa9e4066Sahrens return (ret);
7073fa9e4066Sahrens }
7074fa9e4066Sahrens
7075fa9e4066Sahrens /*
7076fa9e4066Sahrens * zfs unmount -a
7077fa9e4066Sahrens * zfs unmount filesystem
7078fa9e4066Sahrens *
7079fa9e4066Sahrens * Unmount all filesystems, or a specific ZFS filesystem.
7080fa9e4066Sahrens */
7081fa9e4066Sahrens static int
zfs_do_unmount(int argc,char ** argv)7082fa9e4066Sahrens zfs_do_unmount(int argc, char **argv)
7083fa9e4066Sahrens {
7084fa9e4066Sahrens return (unshare_unmount(OP_MOUNT, argc, argv));
7085fa9e4066Sahrens }
7086fa9e4066Sahrens
7087fa9e4066Sahrens /*
7088fa9e4066Sahrens * zfs unshare -a
7089fa9e4066Sahrens * zfs unshare filesystem
7090fa9e4066Sahrens *
7091fa9e4066Sahrens * Unshare all filesystems, or a specific ZFS filesystem.
7092fa9e4066Sahrens */
7093fa9e4066Sahrens static int
zfs_do_unshare(int argc,char ** argv)7094fa9e4066Sahrens zfs_do_unshare(int argc, char **argv)
7095fa9e4066Sahrens {
7096fa9e4066Sahrens return (unshare_unmount(OP_SHARE, argc, argv));
7097fa9e4066Sahrens }
7098fa9e4066Sahrens
7099fa9e4066Sahrens /*
7100fa9e4066Sahrens * Called when invoked as /etc/fs/zfs/mount. Do the mount if the mountpoint is
7101fa9e4066Sahrens * 'legacy'. Otherwise, complain that use should be using 'zfs mount'.
7102fa9e4066Sahrens */
7103fa9e4066Sahrens static int
manual_mount(int argc,char ** argv)7104fa9e4066Sahrens manual_mount(int argc, char **argv)
7105fa9e4066Sahrens {
7106fa9e4066Sahrens zfs_handle_t *zhp;
7107fa9e4066Sahrens char mountpoint[ZFS_MAXPROPLEN];
7108fa9e4066Sahrens char mntopts[MNT_LINE_MAX] = { '\0' };
710905c998d6SRichard Lowe int ret = 0;
7110fa9e4066Sahrens int c;
7111fa9e4066Sahrens int flags = 0;
7112fa9e4066Sahrens char *dataset, *path;
7113fa9e4066Sahrens
7114fa9e4066Sahrens /* check options */
7115ea8dc4b6Seschrock while ((c = getopt(argc, argv, ":mo:O")) != -1) {
7116fa9e4066Sahrens switch (c) {
7117fa9e4066Sahrens case 'o':
7118fa9e4066Sahrens (void) strlcpy(mntopts, optarg, sizeof (mntopts));
7119fa9e4066Sahrens break;
7120fa9e4066Sahrens case 'O':
7121fa9e4066Sahrens flags |= MS_OVERLAY;
7122fa9e4066Sahrens break;
7123ea8dc4b6Seschrock case 'm':
7124ea8dc4b6Seschrock flags |= MS_NOMNTTAB;
7125ea8dc4b6Seschrock break;
7126fa9e4066Sahrens case ':':
7127fa9e4066Sahrens (void) fprintf(stderr, gettext("missing argument for "
7128fa9e4066Sahrens "'%c' option\n"), optopt);
712999653d4eSeschrock usage(B_FALSE);
7130fa9e4066Sahrens break;
7131fa9e4066Sahrens case '?':
7132fa9e4066Sahrens (void) fprintf(stderr, gettext("invalid option '%c'\n"),
7133fa9e4066Sahrens optopt);
7134fa9e4066Sahrens (void) fprintf(stderr, gettext("usage: mount [-o opts] "
7135fa9e4066Sahrens "<path>\n"));
7136fa9e4066Sahrens return (2);
7137fa9e4066Sahrens }
7138fa9e4066Sahrens }
7139fa9e4066Sahrens
7140fa9e4066Sahrens argc -= optind;
7141fa9e4066Sahrens argv += optind;
7142fa9e4066Sahrens
7143fa9e4066Sahrens /* check that we only have two arguments */
7144fa9e4066Sahrens if (argc != 2) {
7145fa9e4066Sahrens if (argc == 0)
7146fa9e4066Sahrens (void) fprintf(stderr, gettext("missing dataset "
7147fa9e4066Sahrens "argument\n"));
7148fa9e4066Sahrens else if (argc == 1)
7149fa9e4066Sahrens (void) fprintf(stderr,
7150fa9e4066Sahrens gettext("missing mountpoint argument\n"));
7151fa9e4066Sahrens else
7152fa9e4066Sahrens (void) fprintf(stderr, gettext("too many arguments\n"));
7153fa9e4066Sahrens (void) fprintf(stderr, "usage: mount <dataset> <mountpoint>\n");
7154fa9e4066Sahrens return (2);
7155fa9e4066Sahrens }
7156fa9e4066Sahrens
7157fa9e4066Sahrens dataset = argv[0];
7158fa9e4066Sahrens path = argv[1];
7159fa9e4066Sahrens
7160fa9e4066Sahrens /* try to open the dataset */
716199653d4eSeschrock if ((zhp = zfs_open(g_zfs, dataset, ZFS_TYPE_FILESYSTEM)) == NULL)
7162fa9e4066Sahrens return (1);
7163fa9e4066Sahrens
7164fa9e4066Sahrens (void) zfs_prop_get(zhp, ZFS_PROP_MOUNTPOINT, mountpoint,
716599653d4eSeschrock sizeof (mountpoint), NULL, NULL, 0, B_FALSE);
7166fa9e4066Sahrens
7167fa9e4066Sahrens /* check for legacy mountpoint and complain appropriately */
7168fa9e4066Sahrens ret = 0;
7169fa9e4066Sahrens if (strcmp(mountpoint, ZFS_MOUNTPOINT_LEGACY) == 0) {
7170fa9e4066Sahrens if (mount(dataset, path, MS_OPTIONSTR | flags, MNTTYPE_ZFS,
7171fa9e4066Sahrens NULL, 0, mntopts, sizeof (mntopts)) != 0) {
7172fa9e4066Sahrens (void) fprintf(stderr, gettext("mount failed: %s\n"),
7173fa9e4066Sahrens strerror(errno));
7174fa9e4066Sahrens ret = 1;
7175fa9e4066Sahrens }
7176fa9e4066Sahrens } else {
7177fa9e4066Sahrens (void) fprintf(stderr, gettext("filesystem '%s' cannot be "
7178fa9e4066Sahrens "mounted using 'mount -F zfs'\n"), dataset);
7179fa9e4066Sahrens (void) fprintf(stderr, gettext("Use 'zfs set mountpoint=%s' "
7180fa9e4066Sahrens "instead.\n"), path);
7181fa9e4066Sahrens (void) fprintf(stderr, gettext("If you must use 'mount -F zfs' "
7182fa9e4066Sahrens "or /etc/vfstab, use 'zfs set mountpoint=legacy'.\n"));
7183bbf21555SRichard Lowe (void) fprintf(stderr, gettext("See zfs(8) for more "
7184fa9e4066Sahrens "information.\n"));
7185fa9e4066Sahrens ret = 1;
7186fa9e4066Sahrens }
7187fa9e4066Sahrens
7188fa9e4066Sahrens return (ret);
7189fa9e4066Sahrens }
7190fa9e4066Sahrens
7191fa9e4066Sahrens /*
7192fa9e4066Sahrens * Called when invoked as /etc/fs/zfs/umount. Unlike a manual mount, we allow
7193fa9e4066Sahrens * unmounts of non-legacy filesystems, as this is the dominant administrative
7194fa9e4066Sahrens * interface.
7195fa9e4066Sahrens */
7196fa9e4066Sahrens static int
manual_unmount(int argc,char ** argv)7197fa9e4066Sahrens manual_unmount(int argc, char **argv)
7198fa9e4066Sahrens {
7199fa9e4066Sahrens int flags = 0;
7200fa9e4066Sahrens int c;
7201fa9e4066Sahrens
7202fa9e4066Sahrens /* check options */
7203fa9e4066Sahrens while ((c = getopt(argc, argv, "f")) != -1) {
7204fa9e4066Sahrens switch (c) {
7205fa9e4066Sahrens case 'f':
7206fa9e4066Sahrens flags = MS_FORCE;
7207fa9e4066Sahrens break;
7208fa9e4066Sahrens case '?':
7209fa9e4066Sahrens (void) fprintf(stderr, gettext("invalid option '%c'\n"),
7210fa9e4066Sahrens optopt);
7211fa9e4066Sahrens (void) fprintf(stderr, gettext("usage: unmount [-f] "
7212fa9e4066Sahrens "<path>\n"));
7213fa9e4066Sahrens return (2);
7214fa9e4066Sahrens }
7215fa9e4066Sahrens }
7216fa9e4066Sahrens
7217fa9e4066Sahrens argc -= optind;
7218fa9e4066Sahrens argv += optind;
7219fa9e4066Sahrens
7220fa9e4066Sahrens /* check arguments */
7221fa9e4066Sahrens if (argc != 1) {
7222fa9e4066Sahrens if (argc == 0)
7223fa9e4066Sahrens (void) fprintf(stderr, gettext("missing path "
7224fa9e4066Sahrens "argument\n"));
7225fa9e4066Sahrens else
7226fa9e4066Sahrens (void) fprintf(stderr, gettext("too many arguments\n"));
7227fa9e4066Sahrens (void) fprintf(stderr, gettext("usage: unmount [-f] <path>\n"));
7228fa9e4066Sahrens return (2);
7229fa9e4066Sahrens }
7230fa9e4066Sahrens
723199653d4eSeschrock return (unshare_unmount_path(OP_MOUNT, argv[0], flags, B_TRUE));
7232fa9e4066Sahrens }
7233fa9e4066Sahrens
7234ecd6cf80Smarks static int
find_command_idx(char * command,int * idx)7235ecd6cf80Smarks find_command_idx(char *command, int *idx)
7236ecd6cf80Smarks {
7237ecd6cf80Smarks int i;
7238ecd6cf80Smarks
7239ecd6cf80Smarks for (i = 0; i < NCOMMAND; i++) {
7240ecd6cf80Smarks if (command_table[i].name == NULL)
7241ecd6cf80Smarks continue;
7242ecd6cf80Smarks
7243ecd6cf80Smarks if (strcmp(command, command_table[i].name) == 0) {
7244ecd6cf80Smarks *idx = i;
7245ecd6cf80Smarks return (0);
7246ecd6cf80Smarks }
7247ecd6cf80Smarks }
7248ecd6cf80Smarks return (1);
7249ecd6cf80Smarks }
7250ecd6cf80Smarks
725199d5e173STim Haley static int
zfs_do_diff(int argc,char ** argv)725299d5e173STim Haley zfs_do_diff(int argc, char **argv)
725399d5e173STim Haley {
725499d5e173STim Haley zfs_handle_t *zhp;
725599d5e173STim Haley int flags = 0;
725699d5e173STim Haley char *tosnap = NULL;
725799d5e173STim Haley char *fromsnap = NULL;
725899d5e173STim Haley char *atp, *copy;
725905c998d6SRichard Lowe int err = 0;
726099d5e173STim Haley int c;
726199d5e173STim Haley
726299d5e173STim Haley while ((c = getopt(argc, argv, "FHt")) != -1) {
726399d5e173STim Haley switch (c) {
726499d5e173STim Haley case 'F':
726599d5e173STim Haley flags |= ZFS_DIFF_CLASSIFY;
726699d5e173STim Haley break;
726799d5e173STim Haley case 'H':
726899d5e173STim Haley flags |= ZFS_DIFF_PARSEABLE;
726999d5e173STim Haley break;
727099d5e173STim Haley case 't':
727199d5e173STim Haley flags |= ZFS_DIFF_TIMESTAMP;
727299d5e173STim Haley break;
727399d5e173STim Haley default:
727499d5e173STim Haley (void) fprintf(stderr,
727599d5e173STim Haley gettext("invalid option '%c'\n"), optopt);
727699d5e173STim Haley usage(B_FALSE);
727799d5e173STim Haley }
727899d5e173STim Haley }
727999d5e173STim Haley
728099d5e173STim Haley argc -= optind;
728199d5e173STim Haley argv += optind;
728299d5e173STim Haley
728399d5e173STim Haley if (argc < 1) {
728499d5e173STim Haley (void) fprintf(stderr,
72855cabbc6bSPrashanth Sreenivasa gettext("must provide at least one snapshot name\n"));
728699d5e173STim Haley usage(B_FALSE);
728799d5e173STim Haley }
728899d5e173STim Haley
728999d5e173STim Haley if (argc > 2) {
729099d5e173STim Haley (void) fprintf(stderr, gettext("too many arguments\n"));
729199d5e173STim Haley usage(B_FALSE);
729299d5e173STim Haley }
729399d5e173STim Haley
729499d5e173STim Haley fromsnap = argv[0];
729599d5e173STim Haley tosnap = (argc == 2) ? argv[1] : NULL;
729699d5e173STim Haley
729799d5e173STim Haley copy = NULL;
729899d5e173STim Haley if (*fromsnap != '@')
729999d5e173STim Haley copy = strdup(fromsnap);
730099d5e173STim Haley else if (tosnap)
730199d5e173STim Haley copy = strdup(tosnap);
730299d5e173STim Haley if (copy == NULL)
730399d5e173STim Haley usage(B_FALSE);
730499d5e173STim Haley
7305c16bcc45SIgor Kozhukhov if ((atp = strchr(copy, '@')) != NULL)
730699d5e173STim Haley *atp = '\0';
730799d5e173STim Haley
730899d5e173STim Haley if ((zhp = zfs_open(g_zfs, copy, ZFS_TYPE_FILESYSTEM)) == NULL)
730999d5e173STim Haley return (1);
731099d5e173STim Haley
731199d5e173STim Haley free(copy);
731299d5e173STim Haley
731399d5e173STim Haley /*
731499d5e173STim Haley * Ignore SIGPIPE so that the library can give us
731599d5e173STim Haley * information on any failure
731699d5e173STim Haley */
731799d5e173STim Haley (void) sigignore(SIGPIPE);
731899d5e173STim Haley
731999d5e173STim Haley err = zfs_show_diffs(zhp, STDOUT_FILENO, fromsnap, tosnap, flags);
732099d5e173STim Haley
732199d5e173STim Haley zfs_close(zhp);
732299d5e173STim Haley
732399d5e173STim Haley return (err != 0);
732499d5e173STim Haley }
732599d5e173STim Haley
73260b2e8253Sloli /*
73270b2e8253Sloli * zfs remap <filesystem | volume>
73280b2e8253Sloli *
73290b2e8253Sloli * Remap the indirect blocks in the given fileystem or volume.
73300b2e8253Sloli */
73315cabbc6bSPrashanth Sreenivasa static int
zfs_do_remap(int argc,char ** argv)73325cabbc6bSPrashanth Sreenivasa zfs_do_remap(int argc, char **argv)
73335cabbc6bSPrashanth Sreenivasa {
73345cabbc6bSPrashanth Sreenivasa const char *fsname;
73355cabbc6bSPrashanth Sreenivasa int err = 0;
73360b2e8253Sloli int c;
73370b2e8253Sloli
73380b2e8253Sloli /* check options */
73390b2e8253Sloli while ((c = getopt(argc, argv, "")) != -1) {
73400b2e8253Sloli switch (c) {
73410b2e8253Sloli case '?':
73420b2e8253Sloli (void) fprintf(stderr,
73430b2e8253Sloli gettext("invalid option '%c'\n"), optopt);
73440b2e8253Sloli usage(B_FALSE);
73450b2e8253Sloli }
73460b2e8253Sloli }
73470b2e8253Sloli
73485cabbc6bSPrashanth Sreenivasa if (argc != 2) {
73495cabbc6bSPrashanth Sreenivasa (void) fprintf(stderr, gettext("wrong number of arguments\n"));
73505cabbc6bSPrashanth Sreenivasa usage(B_FALSE);
73515cabbc6bSPrashanth Sreenivasa }
73525cabbc6bSPrashanth Sreenivasa
73535cabbc6bSPrashanth Sreenivasa fsname = argv[1];
73545cabbc6bSPrashanth Sreenivasa err = zfs_remap_indirects(g_zfs, fsname);
73555cabbc6bSPrashanth Sreenivasa
73565cabbc6bSPrashanth Sreenivasa return (err);
73575cabbc6bSPrashanth Sreenivasa }
73585cabbc6bSPrashanth Sreenivasa
735978f17100SMatthew Ahrens /*
736078f17100SMatthew Ahrens * zfs bookmark <fs@snap> <fs#bmark>
736178f17100SMatthew Ahrens *
736278f17100SMatthew Ahrens * Creates a bookmark with the given name from the given snapshot.
736378f17100SMatthew Ahrens */
736478f17100SMatthew Ahrens static int
zfs_do_bookmark(int argc,char ** argv)736578f17100SMatthew Ahrens zfs_do_bookmark(int argc, char **argv)
736678f17100SMatthew Ahrens {
73679adfa60dSMatthew Ahrens char snapname[ZFS_MAX_DATASET_NAME_LEN];
736878f17100SMatthew Ahrens zfs_handle_t *zhp;
736978f17100SMatthew Ahrens nvlist_t *nvl;
737078f17100SMatthew Ahrens int ret = 0;
737178f17100SMatthew Ahrens int c;
737278f17100SMatthew Ahrens
737378f17100SMatthew Ahrens /* check options */
737478f17100SMatthew Ahrens while ((c = getopt(argc, argv, "")) != -1) {
737578f17100SMatthew Ahrens switch (c) {
737678f17100SMatthew Ahrens case '?':
737778f17100SMatthew Ahrens (void) fprintf(stderr,
737878f17100SMatthew Ahrens gettext("invalid option '%c'\n"), optopt);
737978f17100SMatthew Ahrens goto usage;
738078f17100SMatthew Ahrens }
738178f17100SMatthew Ahrens }
738278f17100SMatthew Ahrens
738378f17100SMatthew Ahrens argc -= optind;
738478f17100SMatthew Ahrens argv += optind;
738578f17100SMatthew Ahrens
738678f17100SMatthew Ahrens /* check number of arguments */
738778f17100SMatthew Ahrens if (argc < 1) {
738878f17100SMatthew Ahrens (void) fprintf(stderr, gettext("missing snapshot argument\n"));
738978f17100SMatthew Ahrens goto usage;
739078f17100SMatthew Ahrens }
739178f17100SMatthew Ahrens if (argc < 2) {
739278f17100SMatthew Ahrens (void) fprintf(stderr, gettext("missing bookmark argument\n"));
739378f17100SMatthew Ahrens goto usage;
739478f17100SMatthew Ahrens }
739578f17100SMatthew Ahrens
739678f17100SMatthew Ahrens if (strchr(argv[1], '#') == NULL) {
739778f17100SMatthew Ahrens (void) fprintf(stderr,
739878f17100SMatthew Ahrens gettext("invalid bookmark name '%s' -- "
739978f17100SMatthew Ahrens "must contain a '#'\n"), argv[1]);
740078f17100SMatthew Ahrens goto usage;
740178f17100SMatthew Ahrens }
740278f17100SMatthew Ahrens
740378f17100SMatthew Ahrens if (argv[0][0] == '@') {
740478f17100SMatthew Ahrens /*
740578f17100SMatthew Ahrens * Snapshot name begins with @.
740678f17100SMatthew Ahrens * Default to same fs as bookmark.
740778f17100SMatthew Ahrens */
740878f17100SMatthew Ahrens (void) strncpy(snapname, argv[1], sizeof (snapname));
740978f17100SMatthew Ahrens *strchr(snapname, '#') = '\0';
741078f17100SMatthew Ahrens (void) strlcat(snapname, argv[0], sizeof (snapname));
741178f17100SMatthew Ahrens } else {
74123382f241Sluozhengzheng (void) strlcpy(snapname, argv[0], sizeof (snapname));
741378f17100SMatthew Ahrens }
741478f17100SMatthew Ahrens zhp = zfs_open(g_zfs, snapname, ZFS_TYPE_SNAPSHOT);
741578f17100SMatthew Ahrens if (zhp == NULL)
741678f17100SMatthew Ahrens goto usage;
741778f17100SMatthew Ahrens zfs_close(zhp);
741878f17100SMatthew Ahrens
741978f17100SMatthew Ahrens
742078f17100SMatthew Ahrens nvl = fnvlist_alloc();
742178f17100SMatthew Ahrens fnvlist_add_string(nvl, argv[1], snapname);
742278f17100SMatthew Ahrens ret = lzc_bookmark(nvl, NULL);
742378f17100SMatthew Ahrens fnvlist_free(nvl);
742478f17100SMatthew Ahrens
742578f17100SMatthew Ahrens if (ret != 0) {
74267ac89354SDon Brady const char *err_msg = NULL;
742778f17100SMatthew Ahrens char errbuf[1024];
742878f17100SMatthew Ahrens
742978f17100SMatthew Ahrens (void) snprintf(errbuf, sizeof (errbuf),
743078f17100SMatthew Ahrens dgettext(TEXT_DOMAIN,
743178f17100SMatthew Ahrens "cannot create bookmark '%s'"), argv[1]);
743278f17100SMatthew Ahrens
743378f17100SMatthew Ahrens switch (ret) {
743478f17100SMatthew Ahrens case EXDEV:
743578f17100SMatthew Ahrens err_msg = "bookmark is in a different pool";
743678f17100SMatthew Ahrens break;
743778f17100SMatthew Ahrens case EEXIST:
743878f17100SMatthew Ahrens err_msg = "bookmark exists";
743978f17100SMatthew Ahrens break;
744078f17100SMatthew Ahrens case EINVAL:
744178f17100SMatthew Ahrens err_msg = "invalid argument";
744278f17100SMatthew Ahrens break;
744378f17100SMatthew Ahrens case ENOTSUP:
744478f17100SMatthew Ahrens err_msg = "bookmark feature not enabled";
744578f17100SMatthew Ahrens break;
74467d46dc6cSMatthew Ahrens case ENOSPC:
74477d46dc6cSMatthew Ahrens err_msg = "out of space";
74487d46dc6cSMatthew Ahrens break;
744978f17100SMatthew Ahrens default:
74507ac89354SDon Brady (void) zfs_standard_error(g_zfs, ret, errbuf);
745178f17100SMatthew Ahrens break;
745278f17100SMatthew Ahrens }
74537ac89354SDon Brady if (err_msg != NULL) {
74547ac89354SDon Brady (void) fprintf(stderr, "%s: %s\n", errbuf,
74557ac89354SDon Brady dgettext(TEXT_DOMAIN, err_msg));
74567ac89354SDon Brady }
745778f17100SMatthew Ahrens }
745878f17100SMatthew Ahrens
74597d46dc6cSMatthew Ahrens return (ret != 0);
746078f17100SMatthew Ahrens
746178f17100SMatthew Ahrens usage:
746278f17100SMatthew Ahrens usage(B_FALSE);
746378f17100SMatthew Ahrens return (-1);
746478f17100SMatthew Ahrens }
746578f17100SMatthew Ahrens
7466dfc11533SChris Williamson static int
zfs_do_channel_program(int argc,char ** argv)7467dfc11533SChris Williamson zfs_do_channel_program(int argc, char **argv)
7468dfc11533SChris Williamson {
7469dfc11533SChris Williamson int ret, fd;
7470*ef150c2bSRichard Lowe int c;
7471dfc11533SChris Williamson char *progbuf, *filename, *poolname;
7472dfc11533SChris Williamson size_t progsize, progread;
74737ac89354SDon Brady nvlist_t *outnvl = NULL;
7474dfc11533SChris Williamson uint64_t instrlimit = ZCP_DEFAULT_INSTRLIMIT;
7475dfc11533SChris Williamson uint64_t memlimit = ZCP_DEFAULT_MEMLIMIT;
747652675910SAlek Pinchuk boolean_t sync_flag = B_TRUE, json_output = B_FALSE;
7477dfc11533SChris Williamson zpool_handle_t *zhp;
7478dfc11533SChris Williamson
7479dfc11533SChris Williamson /* check options */
7480dfc11533SChris Williamson while (-1 !=
748152675910SAlek Pinchuk (c = getopt(argc, argv, "jnt:(instr-limit)m:(memory-limit)"))) {
7482dfc11533SChris Williamson switch (c) {
7483dfc11533SChris Williamson case 't':
7484dfc11533SChris Williamson case 'm': {
7485dfc11533SChris Williamson uint64_t arg;
7486dfc11533SChris Williamson char *endp;
7487dfc11533SChris Williamson
7488dfc11533SChris Williamson errno = 0;
7489dfc11533SChris Williamson arg = strtoull(optarg, &endp, 0);
7490dfc11533SChris Williamson if (errno != 0 || *endp != '\0') {
7491dfc11533SChris Williamson (void) fprintf(stderr, gettext(
7492dfc11533SChris Williamson "invalid argument "
7493dfc11533SChris Williamson "'%s': expected integer\n"), optarg);
7494dfc11533SChris Williamson goto usage;
7495dfc11533SChris Williamson }
7496dfc11533SChris Williamson
7497dfc11533SChris Williamson if (c == 't') {
7498dfc11533SChris Williamson if (arg > ZCP_MAX_INSTRLIMIT || arg == 0) {
7499dfc11533SChris Williamson (void) fprintf(stderr, gettext(
7500dfc11533SChris Williamson "Invalid instruction limit: "
7501dfc11533SChris Williamson "%s\n"), optarg);
7502dfc11533SChris Williamson return (1);
7503dfc11533SChris Williamson } else {
7504dfc11533SChris Williamson instrlimit = arg;
7505dfc11533SChris Williamson }
7506dfc11533SChris Williamson } else {
7507dfc11533SChris Williamson ASSERT3U(c, ==, 'm');
7508dfc11533SChris Williamson if (arg > ZCP_MAX_MEMLIMIT || arg == 0) {
7509dfc11533SChris Williamson (void) fprintf(stderr, gettext(
7510dfc11533SChris Williamson "Invalid memory limit: "
7511dfc11533SChris Williamson "%s\n"), optarg);
7512dfc11533SChris Williamson return (1);
7513dfc11533SChris Williamson } else {
7514dfc11533SChris Williamson memlimit = arg;
7515dfc11533SChris Williamson }
7516dfc11533SChris Williamson }
7517dfc11533SChris Williamson break;
7518dfc11533SChris Williamson }
7519a3b28680SSerapheim Dimitropoulos case 'n': {
7520a3b28680SSerapheim Dimitropoulos sync_flag = B_FALSE;
7521a3b28680SSerapheim Dimitropoulos break;
7522a3b28680SSerapheim Dimitropoulos }
752352675910SAlek Pinchuk case 'j': {
752452675910SAlek Pinchuk json_output = B_TRUE;
752552675910SAlek Pinchuk break;
752652675910SAlek Pinchuk }
7527dfc11533SChris Williamson case '?':
7528dfc11533SChris Williamson (void) fprintf(stderr, gettext("invalid option '%c'\n"),
7529dfc11533SChris Williamson optopt);
7530dfc11533SChris Williamson goto usage;
7531dfc11533SChris Williamson }
7532dfc11533SChris Williamson }
7533dfc11533SChris Williamson
7534dfc11533SChris Williamson argc -= optind;
7535dfc11533SChris Williamson argv += optind;
7536dfc11533SChris Williamson
7537dfc11533SChris Williamson if (argc < 2) {
7538dfc11533SChris Williamson (void) fprintf(stderr,
7539dfc11533SChris Williamson gettext("invalid number of arguments\n"));
7540dfc11533SChris Williamson goto usage;
7541dfc11533SChris Williamson }
7542dfc11533SChris Williamson
7543dfc11533SChris Williamson poolname = argv[0];
7544dfc11533SChris Williamson filename = argv[1];
7545dfc11533SChris Williamson if (strcmp(filename, "-") == 0) {
7546dfc11533SChris Williamson fd = 0;
7547dfc11533SChris Williamson filename = "standard input";
7548dfc11533SChris Williamson } else if ((fd = open(filename, O_RDONLY)) < 0) {
7549dfc11533SChris Williamson (void) fprintf(stderr, gettext("cannot open '%s': %s\n"),
7550dfc11533SChris Williamson filename, strerror(errno));
7551dfc11533SChris Williamson return (1);
7552dfc11533SChris Williamson }
7553dfc11533SChris Williamson
7554dfc11533SChris Williamson if ((zhp = zpool_open(g_zfs, poolname)) == NULL) {
7555dfc11533SChris Williamson (void) fprintf(stderr, gettext("cannot open pool '%s'"),
7556dfc11533SChris Williamson poolname);
7557dfc11533SChris Williamson return (1);
7558dfc11533SChris Williamson }
7559dfc11533SChris Williamson zpool_close(zhp);
7560dfc11533SChris Williamson
7561dfc11533SChris Williamson /*
7562dfc11533SChris Williamson * Read in the channel program, expanding the program buffer as
7563dfc11533SChris Williamson * necessary.
7564dfc11533SChris Williamson */
7565dfc11533SChris Williamson progread = 0;
7566dfc11533SChris Williamson progsize = 1024;
7567dfc11533SChris Williamson progbuf = safe_malloc(progsize);
7568dfc11533SChris Williamson do {
7569dfc11533SChris Williamson ret = read(fd, progbuf + progread, progsize - progread);
7570dfc11533SChris Williamson progread += ret;
7571dfc11533SChris Williamson if (progread == progsize && ret > 0) {
7572dfc11533SChris Williamson progsize *= 2;
7573dfc11533SChris Williamson progbuf = safe_realloc(progbuf, progsize);
7574dfc11533SChris Williamson }
7575dfc11533SChris Williamson } while (ret > 0);
7576dfc11533SChris Williamson
7577dfc11533SChris Williamson if (fd != 0)
7578dfc11533SChris Williamson (void) close(fd);
7579dfc11533SChris Williamson if (ret < 0) {
7580dfc11533SChris Williamson free(progbuf);
7581dfc11533SChris Williamson (void) fprintf(stderr,
7582dfc11533SChris Williamson gettext("cannot read '%s': %s\n"),
7583dfc11533SChris Williamson filename, strerror(errno));
7584dfc11533SChris Williamson return (1);
7585dfc11533SChris Williamson }
7586dfc11533SChris Williamson progbuf[progread] = '\0';
7587dfc11533SChris Williamson
7588dfc11533SChris Williamson /*
7589dfc11533SChris Williamson * Any remaining arguments are passed as arguments to the lua script as
7590dfc11533SChris Williamson * a string array:
7591dfc11533SChris Williamson * {
7592dfc11533SChris Williamson * "argv" -> [ "arg 1", ... "arg n" ],
7593dfc11533SChris Williamson * }
7594dfc11533SChris Williamson */
7595dfc11533SChris Williamson nvlist_t *argnvl = fnvlist_alloc();
7596dfc11533SChris Williamson fnvlist_add_string_array(argnvl, ZCP_ARG_CLIARGV, argv + 2, argc - 2);
7597dfc11533SChris Williamson
7598a3b28680SSerapheim Dimitropoulos if (sync_flag) {
7599a3b28680SSerapheim Dimitropoulos ret = lzc_channel_program(poolname, progbuf,
7600a3b28680SSerapheim Dimitropoulos instrlimit, memlimit, argnvl, &outnvl);
7601a3b28680SSerapheim Dimitropoulos } else {
7602a3b28680SSerapheim Dimitropoulos ret = lzc_channel_program_nosync(poolname, progbuf,
7603a3b28680SSerapheim Dimitropoulos instrlimit, memlimit, argnvl, &outnvl);
7604a3b28680SSerapheim Dimitropoulos }
7605dfc11533SChris Williamson
7606dfc11533SChris Williamson if (ret != 0) {
7607dfc11533SChris Williamson /*
7608dfc11533SChris Williamson * On error, report the error message handed back by lua if one
7609dfc11533SChris Williamson * exists. Otherwise, generate an appropriate error message,
7610dfc11533SChris Williamson * falling back on strerror() for an unexpected return code.
7611dfc11533SChris Williamson */
7612dfc11533SChris Williamson char *errstring = NULL;
76137ac89354SDon Brady const char *msg = gettext("Channel program execution failed");
76147ac89354SDon Brady if (outnvl != NULL && nvlist_exists(outnvl, ZCP_RET_ERROR)) {
7615dfc11533SChris Williamson (void) nvlist_lookup_string(outnvl,
7616dfc11533SChris Williamson ZCP_RET_ERROR, &errstring);
7617dfc11533SChris Williamson if (errstring == NULL)
7618dfc11533SChris Williamson errstring = strerror(ret);
7619dfc11533SChris Williamson } else {
7620dfc11533SChris Williamson switch (ret) {
7621dfc11533SChris Williamson case EINVAL:
7622dfc11533SChris Williamson errstring =
7623dfc11533SChris Williamson "Invalid instruction or memory limit.";
7624dfc11533SChris Williamson break;
7625dfc11533SChris Williamson case ENOMEM:
7626dfc11533SChris Williamson errstring = "Return value too large.";
7627dfc11533SChris Williamson break;
7628dfc11533SChris Williamson case ENOSPC:
7629dfc11533SChris Williamson errstring = "Memory limit exhausted.";
7630dfc11533SChris Williamson break;
7631dfc11533SChris Williamson case ETIME:
7632dfc11533SChris Williamson errstring = "Timed out.";
7633dfc11533SChris Williamson break;
7634dfc11533SChris Williamson case EPERM:
7635dfc11533SChris Williamson errstring = "Permission denied. Channel "
7636dfc11533SChris Williamson "programs must be run as root.";
7637dfc11533SChris Williamson break;
7638dfc11533SChris Williamson default:
76397ac89354SDon Brady (void) zfs_standard_error(g_zfs, ret, msg);
7640dfc11533SChris Williamson }
7641dfc11533SChris Williamson }
76427ac89354SDon Brady if (errstring != NULL)
76437ac89354SDon Brady (void) fprintf(stderr, "%s:\n%s\n", msg, errstring);
7644dfc11533SChris Williamson } else {
764552675910SAlek Pinchuk if (json_output) {
764652675910SAlek Pinchuk (void) nvlist_print_json(stdout, outnvl);
764752675910SAlek Pinchuk } else if (nvlist_empty(outnvl)) {
764852675910SAlek Pinchuk (void) fprintf(stdout, gettext("Channel program fully "
764952675910SAlek Pinchuk "executed and did not produce output.\n"));
7650dfc11533SChris Williamson } else {
765152675910SAlek Pinchuk (void) fprintf(stdout, gettext("Channel program fully "
765252675910SAlek Pinchuk "executed and produced output:\n"));
7653dfc11533SChris Williamson dump_nvlist(outnvl, 4);
7654dfc11533SChris Williamson }
7655dfc11533SChris Williamson }
7656dfc11533SChris Williamson
7657dfc11533SChris Williamson free(progbuf);
7658dfc11533SChris Williamson fnvlist_free(outnvl);
7659dfc11533SChris Williamson fnvlist_free(argnvl);
7660dfc11533SChris Williamson return (ret != 0);
7661dfc11533SChris Williamson
7662dfc11533SChris Williamson usage:
7663dfc11533SChris Williamson usage(B_FALSE);
7664dfc11533SChris Williamson return (-1);
7665dfc11533SChris Williamson }
7666dfc11533SChris Williamson
7667eb633035STom Caputi typedef struct loadkey_cbdata {
7668eb633035STom Caputi boolean_t cb_loadkey;
7669eb633035STom Caputi boolean_t cb_recursive;
7670eb633035STom Caputi boolean_t cb_noop;
7671eb633035STom Caputi char *cb_keylocation;
7672eb633035STom Caputi uint64_t cb_numfailed;
7673eb633035STom Caputi uint64_t cb_numattempted;
7674eb633035STom Caputi } loadkey_cbdata_t;
7675eb633035STom Caputi
7676eb633035STom Caputi static int
load_key_callback(zfs_handle_t * zhp,void * data)7677eb633035STom Caputi load_key_callback(zfs_handle_t *zhp, void *data)
7678eb633035STom Caputi {
7679eb633035STom Caputi int ret;
7680eb633035STom Caputi boolean_t is_encroot;
7681eb633035STom Caputi loadkey_cbdata_t *cb = data;
7682eb633035STom Caputi uint64_t keystatus = zfs_prop_get_int(zhp, ZFS_PROP_KEYSTATUS);
7683eb633035STom Caputi
7684eb633035STom Caputi /*
7685eb633035STom Caputi * If we are working recursively, we want to skip loading / unloading
7686eb633035STom Caputi * keys for non-encryption roots and datasets whose keys are already
7687eb633035STom Caputi * in the desired end-state.
7688eb633035STom Caputi */
7689eb633035STom Caputi if (cb->cb_recursive) {
7690eb633035STom Caputi ret = zfs_crypto_get_encryption_root(zhp, &is_encroot, NULL);
7691eb633035STom Caputi if (ret != 0)
7692eb633035STom Caputi return (ret);
7693eb633035STom Caputi if (!is_encroot)
7694eb633035STom Caputi return (0);
7695eb633035STom Caputi
7696eb633035STom Caputi if ((cb->cb_loadkey && keystatus == ZFS_KEYSTATUS_AVAILABLE) ||
7697eb633035STom Caputi (!cb->cb_loadkey && keystatus == ZFS_KEYSTATUS_UNAVAILABLE))
7698eb633035STom Caputi return (0);
7699eb633035STom Caputi }
7700eb633035STom Caputi
7701eb633035STom Caputi cb->cb_numattempted++;
7702eb633035STom Caputi
7703eb633035STom Caputi if (cb->cb_loadkey)
7704eb633035STom Caputi ret = zfs_crypto_load_key(zhp, cb->cb_noop, cb->cb_keylocation);
7705eb633035STom Caputi else
7706eb633035STom Caputi ret = zfs_crypto_unload_key(zhp);
7707eb633035STom Caputi
7708eb633035STom Caputi if (ret != 0) {
7709eb633035STom Caputi cb->cb_numfailed++;
7710eb633035STom Caputi return (ret);
7711eb633035STom Caputi }
7712eb633035STom Caputi
7713eb633035STom Caputi return (0);
7714eb633035STom Caputi }
7715eb633035STom Caputi
7716eb633035STom Caputi static int
load_unload_keys(int argc,char ** argv,boolean_t loadkey)7717eb633035STom Caputi load_unload_keys(int argc, char **argv, boolean_t loadkey)
7718eb633035STom Caputi {
7719eb633035STom Caputi int c, ret = 0, flags = 0;
7720eb633035STom Caputi boolean_t do_all = B_FALSE;
7721eb633035STom Caputi loadkey_cbdata_t cb = { 0 };
7722eb633035STom Caputi
7723eb633035STom Caputi cb.cb_loadkey = loadkey;
7724eb633035STom Caputi
7725eb633035STom Caputi while ((c = getopt(argc, argv, "anrL:")) != -1) {
7726eb633035STom Caputi /* noop and alternate keylocations only apply to zfs load-key */
7727eb633035STom Caputi if (loadkey) {
7728eb633035STom Caputi switch (c) {
7729eb633035STom Caputi case 'n':
7730eb633035STom Caputi cb.cb_noop = B_TRUE;
7731eb633035STom Caputi continue;
7732eb633035STom Caputi case 'L':
7733eb633035STom Caputi cb.cb_keylocation = optarg;
7734eb633035STom Caputi continue;
7735eb633035STom Caputi default:
7736eb633035STom Caputi break;
7737eb633035STom Caputi }
7738eb633035STom Caputi }
7739eb633035STom Caputi
7740eb633035STom Caputi switch (c) {
7741eb633035STom Caputi case 'a':
7742eb633035STom Caputi do_all = B_TRUE;
7743eb633035STom Caputi cb.cb_recursive = B_TRUE;
7744eb633035STom Caputi break;
7745eb633035STom Caputi case 'r':
7746eb633035STom Caputi flags |= ZFS_ITER_RECURSE;
7747eb633035STom Caputi cb.cb_recursive = B_TRUE;
7748eb633035STom Caputi break;
7749eb633035STom Caputi default:
7750eb633035STom Caputi (void) fprintf(stderr,
7751eb633035STom Caputi gettext("invalid option '%c'\n"), optopt);
7752eb633035STom Caputi usage(B_FALSE);
7753eb633035STom Caputi }
7754eb633035STom Caputi }
7755eb633035STom Caputi
7756eb633035STom Caputi argc -= optind;
7757eb633035STom Caputi argv += optind;
7758eb633035STom Caputi
7759eb633035STom Caputi if (!do_all && argc == 0) {
7760eb633035STom Caputi (void) fprintf(stderr,
7761eb633035STom Caputi gettext("Missing dataset argument or -a option\n"));
7762eb633035STom Caputi usage(B_FALSE);
7763eb633035STom Caputi }
7764eb633035STom Caputi
7765eb633035STom Caputi if (do_all && argc != 0) {
7766eb633035STom Caputi (void) fprintf(stderr,
7767eb633035STom Caputi gettext("Cannot specify dataset with -a option\n"));
7768eb633035STom Caputi usage(B_FALSE);
7769eb633035STom Caputi }
7770eb633035STom Caputi
7771eb633035STom Caputi if (cb.cb_recursive && cb.cb_keylocation != NULL &&
7772eb633035STom Caputi strcmp(cb.cb_keylocation, "prompt") != 0) {
7773eb633035STom Caputi (void) fprintf(stderr, gettext("alternate keylocation may only "
7774eb633035STom Caputi "be 'prompt' with -r or -a\n"));
7775eb633035STom Caputi usage(B_FALSE);
7776eb633035STom Caputi }
7777eb633035STom Caputi
7778eb633035STom Caputi ret = zfs_for_each(argc, argv, flags,
7779eb633035STom Caputi ZFS_TYPE_FILESYSTEM | ZFS_TYPE_VOLUME, NULL, NULL, 0,
7780eb633035STom Caputi load_key_callback, &cb);
7781eb633035STom Caputi
7782eb633035STom Caputi if (cb.cb_noop || (cb.cb_recursive && cb.cb_numattempted != 0)) {
7783eb633035STom Caputi (void) printf(gettext("%llu / %llu key(s) successfully %s\n"),
7784eb633035STom Caputi (u_longlong_t)(cb.cb_numattempted - cb.cb_numfailed),
7785eb633035STom Caputi (u_longlong_t)cb.cb_numattempted,
7786eb633035STom Caputi loadkey ? (cb.cb_noop ? "verified" : "loaded") :
7787eb633035STom Caputi "unloaded");
7788eb633035STom Caputi }
7789eb633035STom Caputi
7790eb633035STom Caputi if (cb.cb_numfailed != 0)
7791eb633035STom Caputi ret = -1;
7792eb633035STom Caputi
7793eb633035STom Caputi return (ret);
7794eb633035STom Caputi }
7795eb633035STom Caputi
7796eb633035STom Caputi static int
zfs_do_load_key(int argc,char ** argv)7797eb633035STom Caputi zfs_do_load_key(int argc, char **argv)
7798eb633035STom Caputi {
7799eb633035STom Caputi return (load_unload_keys(argc, argv, B_TRUE));
7800eb633035STom Caputi }
7801eb633035STom Caputi
7802eb633035STom Caputi
7803eb633035STom Caputi static int
zfs_do_unload_key(int argc,char ** argv)7804eb633035STom Caputi zfs_do_unload_key(int argc, char **argv)
7805eb633035STom Caputi {
7806eb633035STom Caputi return (load_unload_keys(argc, argv, B_FALSE));
7807eb633035STom Caputi }
7808eb633035STom Caputi
7809eb633035STom Caputi static int
zfs_do_change_key(int argc,char ** argv)7810eb633035STom Caputi zfs_do_change_key(int argc, char **argv)
7811eb633035STom Caputi {
7812eb633035STom Caputi int c, ret;
7813eb633035STom Caputi uint64_t keystatus;
7814eb633035STom Caputi boolean_t loadkey = B_FALSE, inheritkey = B_FALSE;
7815eb633035STom Caputi zfs_handle_t *zhp = NULL;
7816eb633035STom Caputi nvlist_t *props = fnvlist_alloc();
7817eb633035STom Caputi
7818eb633035STom Caputi while ((c = getopt(argc, argv, "lio:")) != -1) {
7819eb633035STom Caputi switch (c) {
7820eb633035STom Caputi case 'l':
7821eb633035STom Caputi loadkey = B_TRUE;
7822eb633035STom Caputi break;
7823eb633035STom Caputi case 'i':
7824eb633035STom Caputi inheritkey = B_TRUE;
7825eb633035STom Caputi break;
7826eb633035STom Caputi case 'o':
78276ccda740Sloli if (!parseprop(props, optarg)) {
7828eb633035STom Caputi nvlist_free(props);
7829eb633035STom Caputi return (1);
7830eb633035STom Caputi }
7831eb633035STom Caputi break;
7832eb633035STom Caputi default:
7833eb633035STom Caputi (void) fprintf(stderr,
7834eb633035STom Caputi gettext("invalid option '%c'\n"), optopt);
7835eb633035STom Caputi usage(B_FALSE);
7836eb633035STom Caputi }
7837eb633035STom Caputi }
7838eb633035STom Caputi
7839eb633035STom Caputi if (inheritkey && !nvlist_empty(props)) {
7840eb633035STom Caputi (void) fprintf(stderr,
7841eb633035STom Caputi gettext("Properties not allowed for inheriting\n"));
7842eb633035STom Caputi usage(B_FALSE);
7843eb633035STom Caputi }
7844eb633035STom Caputi
7845eb633035STom Caputi argc -= optind;
7846eb633035STom Caputi argv += optind;
7847eb633035STom Caputi
7848eb633035STom Caputi if (argc < 1) {
7849eb633035STom Caputi (void) fprintf(stderr, gettext("Missing dataset argument\n"));
7850eb633035STom Caputi usage(B_FALSE);
7851eb633035STom Caputi }
7852eb633035STom Caputi
7853eb633035STom Caputi if (argc > 1) {
7854eb633035STom Caputi (void) fprintf(stderr, gettext("Too many arguments\n"));
7855eb633035STom Caputi usage(B_FALSE);
7856eb633035STom Caputi }
7857eb633035STom Caputi
7858eb633035STom Caputi zhp = zfs_open(g_zfs, argv[argc - 1],
7859eb633035STom Caputi ZFS_TYPE_FILESYSTEM | ZFS_TYPE_VOLUME);
7860eb633035STom Caputi if (zhp == NULL)
7861eb633035STom Caputi usage(B_FALSE);
7862eb633035STom Caputi
7863eb633035STom Caputi if (loadkey) {
7864eb633035STom Caputi keystatus = zfs_prop_get_int(zhp, ZFS_PROP_KEYSTATUS);
7865eb633035STom Caputi if (keystatus != ZFS_KEYSTATUS_AVAILABLE) {
7866eb633035STom Caputi ret = zfs_crypto_load_key(zhp, B_FALSE, NULL);
7867eb633035STom Caputi if (ret != 0) {
7868eb633035STom Caputi nvlist_free(props);
7869eb633035STom Caputi zfs_close(zhp);
7870eb633035STom Caputi return (-1);
7871eb633035STom Caputi }
7872eb633035STom Caputi }
7873eb633035STom Caputi
7874eb633035STom Caputi /* refresh the properties so the new keystatus is visible */
7875eb633035STom Caputi zfs_refresh_properties(zhp);
7876eb633035STom Caputi }
7877eb633035STom Caputi
7878eb633035STom Caputi ret = zfs_crypto_rewrap(zhp, props, inheritkey);
7879eb633035STom Caputi if (ret != 0) {
7880eb633035STom Caputi nvlist_free(props);
7881eb633035STom Caputi zfs_close(zhp);
7882eb633035STom Caputi return (-1);
7883eb633035STom Caputi }
7884eb633035STom Caputi
7885eb633035STom Caputi nvlist_free(props);
7886eb633035STom Caputi zfs_close(zhp);
7887eb633035STom Caputi return (0);
7888eb633035STom Caputi }
7889eb633035STom Caputi
7890f67950b2SNasf-Fan /*
7891f67950b2SNasf-Fan * 1) zfs project [-d|-r] <file|directory ...>
7892f67950b2SNasf-Fan * List project ID and inherit flag of file(s) or directories.
7893f67950b2SNasf-Fan * -d: List the directory itself, not its children.
7894f67950b2SNasf-Fan * -r: List subdirectories recursively.
7895f67950b2SNasf-Fan *
7896f67950b2SNasf-Fan * 2) zfs project -C [-k] [-r] <file|directory ...>
7897f67950b2SNasf-Fan * Clear project inherit flag and/or ID on the file(s) or directories.
7898f67950b2SNasf-Fan * -k: Keep the project ID unchanged. If not specified, the project ID
7899f67950b2SNasf-Fan * will be reset as zero.
7900f67950b2SNasf-Fan * -r: Clear on subdirectories recursively.
7901f67950b2SNasf-Fan *
7902f67950b2SNasf-Fan * 3) zfs project -c [-0] [-d|-r] [-p id] <file|directory ...>
7903f67950b2SNasf-Fan * Check project ID and inherit flag on the file(s) or directories,
7904f67950b2SNasf-Fan * report the outliers.
7905f67950b2SNasf-Fan * -0: Print file name followed by a NUL instead of newline.
7906f67950b2SNasf-Fan * -d: Check the directory itself, not its children.
7907f67950b2SNasf-Fan * -p: Specify the referenced ID for comparing with the target file(s)
7908f67950b2SNasf-Fan * or directories' project IDs. If not specified, the target (top)
7909f67950b2SNasf-Fan * directory's project ID will be used as the referenced one.
7910f67950b2SNasf-Fan * -r: Check subdirectories recursively.
7911f67950b2SNasf-Fan *
7912f67950b2SNasf-Fan * 4) zfs project [-p id] [-r] [-s] <file|directory ...>
7913f67950b2SNasf-Fan * Set project ID and/or inherit flag on the file(s) or directories.
7914f67950b2SNasf-Fan * -p: Set the project ID as the given id.
7915f67950b2SNasf-Fan * -r: Set on subdirectory recursively. If not specify "-p" option,
7916f67950b2SNasf-Fan * it will use top-level directory's project ID as the given id,
7917f67950b2SNasf-Fan * then set both project ID and inherit flag on all descendants
7918f67950b2SNasf-Fan * of the top-level directory.
7919f67950b2SNasf-Fan * -s: Set project inherit flag.
7920f67950b2SNasf-Fan */
7921f67950b2SNasf-Fan static int
zfs_do_project(int argc,char ** argv)7922f67950b2SNasf-Fan zfs_do_project(int argc, char **argv)
7923f67950b2SNasf-Fan {
7924f67950b2SNasf-Fan zfs_project_control_t zpc = {
7925f67950b2SNasf-Fan .zpc_expected_projid = ZFS_INVALID_PROJID,
7926f67950b2SNasf-Fan .zpc_op = ZFS_PROJECT_OP_DEFAULT,
7927f67950b2SNasf-Fan .zpc_dironly = B_FALSE,
7928f67950b2SNasf-Fan .zpc_keep_projid = B_FALSE,
7929f67950b2SNasf-Fan .zpc_newline = B_TRUE,
7930f67950b2SNasf-Fan .zpc_recursive = B_FALSE,
7931f67950b2SNasf-Fan .zpc_set_flag = B_FALSE,
7932f67950b2SNasf-Fan };
7933f67950b2SNasf-Fan int ret = 0, c;
7934f67950b2SNasf-Fan
7935f67950b2SNasf-Fan if (argc < 2)
7936f67950b2SNasf-Fan usage(B_FALSE);
7937f67950b2SNasf-Fan
7938f67950b2SNasf-Fan while ((c = getopt(argc, argv, "0Ccdkp:rs")) != -1) {
7939f67950b2SNasf-Fan switch (c) {
7940f67950b2SNasf-Fan case '0':
7941f67950b2SNasf-Fan zpc.zpc_newline = B_FALSE;
7942f67950b2SNasf-Fan break;
7943f67950b2SNasf-Fan case 'C':
7944f67950b2SNasf-Fan if (zpc.zpc_op != ZFS_PROJECT_OP_DEFAULT) {
7945f67950b2SNasf-Fan (void) fprintf(stderr, gettext("cannot "
7946f67950b2SNasf-Fan "specify '-C' '-c' '-s' together\n"));
7947f67950b2SNasf-Fan usage(B_FALSE);
7948f67950b2SNasf-Fan }
7949f67950b2SNasf-Fan
7950f67950b2SNasf-Fan zpc.zpc_op = ZFS_PROJECT_OP_CLEAR;
7951f67950b2SNasf-Fan break;
7952f67950b2SNasf-Fan case 'c':
7953f67950b2SNasf-Fan if (zpc.zpc_op != ZFS_PROJECT_OP_DEFAULT) {
7954f67950b2SNasf-Fan (void) fprintf(stderr, gettext("cannot "
7955f67950b2SNasf-Fan "specify '-C' '-c' '-s' together\n"));
7956f67950b2SNasf-Fan usage(B_FALSE);
7957f67950b2SNasf-Fan }
7958f67950b2SNasf-Fan
7959f67950b2SNasf-Fan zpc.zpc_op = ZFS_PROJECT_OP_CHECK;
7960f67950b2SNasf-Fan break;
7961f67950b2SNasf-Fan case 'd':
7962f67950b2SNasf-Fan zpc.zpc_dironly = B_TRUE;
7963f67950b2SNasf-Fan /* overwrite "-r" option */
7964f67950b2SNasf-Fan zpc.zpc_recursive = B_FALSE;
7965f67950b2SNasf-Fan break;
7966f67950b2SNasf-Fan case 'k':
7967f67950b2SNasf-Fan zpc.zpc_keep_projid = B_TRUE;
7968f67950b2SNasf-Fan break;
7969f67950b2SNasf-Fan case 'p': {
7970f67950b2SNasf-Fan char *endptr;
7971f67950b2SNasf-Fan
7972f67950b2SNasf-Fan errno = 0;
7973f67950b2SNasf-Fan zpc.zpc_expected_projid = strtoull(optarg, &endptr, 0);
7974f67950b2SNasf-Fan if (errno != 0 || *endptr != '\0') {
7975f67950b2SNasf-Fan (void) fprintf(stderr,
7976f67950b2SNasf-Fan gettext("project ID must be less than "
7977f67950b2SNasf-Fan "%u\n"), UINT32_MAX);
7978f67950b2SNasf-Fan usage(B_FALSE);
7979f67950b2SNasf-Fan }
7980f67950b2SNasf-Fan if (zpc.zpc_expected_projid >= UINT32_MAX) {
7981f67950b2SNasf-Fan (void) fprintf(stderr,
7982f67950b2SNasf-Fan gettext("invalid project ID\n"));
7983f67950b2SNasf-Fan usage(B_FALSE);
7984f67950b2SNasf-Fan }
7985f67950b2SNasf-Fan break;
7986f67950b2SNasf-Fan }
7987f67950b2SNasf-Fan case 'r':
7988f67950b2SNasf-Fan zpc.zpc_recursive = B_TRUE;
7989f67950b2SNasf-Fan /* overwrite "-d" option */
7990f67950b2SNasf-Fan zpc.zpc_dironly = B_FALSE;
7991f67950b2SNasf-Fan break;
7992f67950b2SNasf-Fan case 's':
7993f67950b2SNasf-Fan if (zpc.zpc_op != ZFS_PROJECT_OP_DEFAULT) {
7994f67950b2SNasf-Fan (void) fprintf(stderr, gettext("cannot "
7995f67950b2SNasf-Fan "specify '-C' '-c' '-s' together\n"));
7996f67950b2SNasf-Fan usage(B_FALSE);
7997f67950b2SNasf-Fan }
7998f67950b2SNasf-Fan
7999f67950b2SNasf-Fan zpc.zpc_set_flag = B_TRUE;
8000f67950b2SNasf-Fan zpc.zpc_op = ZFS_PROJECT_OP_SET;
8001f67950b2SNasf-Fan break;
8002f67950b2SNasf-Fan default:
8003f67950b2SNasf-Fan (void) fprintf(stderr, gettext("invalid option '%c'\n"),
8004f67950b2SNasf-Fan optopt);
8005f67950b2SNasf-Fan usage(B_FALSE);
8006f67950b2SNasf-Fan }
8007f67950b2SNasf-Fan }
8008f67950b2SNasf-Fan
8009f67950b2SNasf-Fan if (zpc.zpc_op == ZFS_PROJECT_OP_DEFAULT) {
8010f67950b2SNasf-Fan if (zpc.zpc_expected_projid != ZFS_INVALID_PROJID)
8011f67950b2SNasf-Fan zpc.zpc_op = ZFS_PROJECT_OP_SET;
8012f67950b2SNasf-Fan else
8013f67950b2SNasf-Fan zpc.zpc_op = ZFS_PROJECT_OP_LIST;
8014f67950b2SNasf-Fan }
8015f67950b2SNasf-Fan
8016f67950b2SNasf-Fan switch (zpc.zpc_op) {
8017f67950b2SNasf-Fan case ZFS_PROJECT_OP_LIST:
8018f67950b2SNasf-Fan if (zpc.zpc_keep_projid) {
8019f67950b2SNasf-Fan (void) fprintf(stderr,
8020f67950b2SNasf-Fan gettext("'-k' is only valid together with '-C'\n"));
8021f67950b2SNasf-Fan usage(B_FALSE);
8022f67950b2SNasf-Fan }
8023f67950b2SNasf-Fan if (!zpc.zpc_newline) {
8024f67950b2SNasf-Fan (void) fprintf(stderr,
8025f67950b2SNasf-Fan gettext("'-0' is only valid together with '-c'\n"));
8026f67950b2SNasf-Fan usage(B_FALSE);
8027f67950b2SNasf-Fan }
8028f67950b2SNasf-Fan break;
8029f67950b2SNasf-Fan case ZFS_PROJECT_OP_CHECK:
8030f67950b2SNasf-Fan if (zpc.zpc_keep_projid) {
8031f67950b2SNasf-Fan (void) fprintf(stderr,
8032f67950b2SNasf-Fan gettext("'-k' is only valid together with '-C'\n"));
8033f67950b2SNasf-Fan usage(B_FALSE);
8034f67950b2SNasf-Fan }
8035f67950b2SNasf-Fan break;
8036f67950b2SNasf-Fan case ZFS_PROJECT_OP_CLEAR:
8037f67950b2SNasf-Fan if (zpc.zpc_dironly) {
8038f67950b2SNasf-Fan (void) fprintf(stderr,
8039f67950b2SNasf-Fan gettext("'-d' is useless together with '-C'\n"));
8040f67950b2SNasf-Fan usage(B_FALSE);
8041f67950b2SNasf-Fan }
8042f67950b2SNasf-Fan if (!zpc.zpc_newline) {
8043f67950b2SNasf-Fan (void) fprintf(stderr,
8044f67950b2SNasf-Fan gettext("'-0' is only valid together with '-c'\n"));
8045f67950b2SNasf-Fan usage(B_FALSE);
8046f67950b2SNasf-Fan }
8047f67950b2SNasf-Fan if (zpc.zpc_expected_projid != ZFS_INVALID_PROJID) {
8048f67950b2SNasf-Fan (void) fprintf(stderr,
8049f67950b2SNasf-Fan gettext("'-p' is useless together with '-C'\n"));
8050f67950b2SNasf-Fan usage(B_FALSE);
8051f67950b2SNasf-Fan }
8052f67950b2SNasf-Fan break;
8053f67950b2SNasf-Fan case ZFS_PROJECT_OP_SET:
8054f67950b2SNasf-Fan if (zpc.zpc_dironly) {
8055f67950b2SNasf-Fan (void) fprintf(stderr,
8056f67950b2SNasf-Fan gettext("'-d' is useless for set project ID and/or "
8057f67950b2SNasf-Fan "inherit flag\n"));
8058f67950b2SNasf-Fan usage(B_FALSE);
8059f67950b2SNasf-Fan }
8060f67950b2SNasf-Fan if (zpc.zpc_keep_projid) {
8061f67950b2SNasf-Fan (void) fprintf(stderr,
8062f67950b2SNasf-Fan gettext("'-k' is only valid together with '-C'\n"));
8063f67950b2SNasf-Fan usage(B_FALSE);
8064f67950b2SNasf-Fan }
8065f67950b2SNasf-Fan if (!zpc.zpc_newline) {
8066f67950b2SNasf-Fan (void) fprintf(stderr,
8067f67950b2SNasf-Fan gettext("'-0' is only valid together with '-c'\n"));
8068f67950b2SNasf-Fan usage(B_FALSE);
8069f67950b2SNasf-Fan }
8070f67950b2SNasf-Fan break;
8071f67950b2SNasf-Fan default:
8072f67950b2SNasf-Fan ASSERT(0);
8073f67950b2SNasf-Fan break;
8074f67950b2SNasf-Fan }
8075f67950b2SNasf-Fan
8076f67950b2SNasf-Fan argv += optind;
8077f67950b2SNasf-Fan argc -= optind;
8078f67950b2SNasf-Fan if (argc == 0) {
8079f67950b2SNasf-Fan (void) fprintf(stderr,
8080f67950b2SNasf-Fan gettext("missing file or directory target(s)\n"));
8081f67950b2SNasf-Fan usage(B_FALSE);
8082f67950b2SNasf-Fan }
8083f67950b2SNasf-Fan
8084f67950b2SNasf-Fan for (int i = 0; i < argc; i++) {
8085f67950b2SNasf-Fan int err;
8086f67950b2SNasf-Fan
8087f67950b2SNasf-Fan err = zfs_project_handle(argv[i], &zpc);
8088f67950b2SNasf-Fan if (err && !ret)
8089f67950b2SNasf-Fan ret = err;
8090f67950b2SNasf-Fan }
8091f67950b2SNasf-Fan
8092f67950b2SNasf-Fan return (ret);
8093f67950b2SNasf-Fan }
8094f67950b2SNasf-Fan
8095fa9e4066Sahrens int
main(int argc,char ** argv)8096fa9e4066Sahrens main(int argc, char **argv)
8097fa9e4066Sahrens {
809805c998d6SRichard Lowe int ret = 0;
8099fa9e4066Sahrens int i;
8100fa9e4066Sahrens char *progname;
8101fa9e4066Sahrens char *cmdname;
8102fa9e4066Sahrens
8103fa9e4066Sahrens (void) setlocale(LC_ALL, "");
8104fa9e4066Sahrens (void) textdomain(TEXT_DOMAIN);
8105fa9e4066Sahrens
8106fa9e4066Sahrens opterr = 0;
8107fa9e4066Sahrens
810899653d4eSeschrock if ((g_zfs = libzfs_init()) == NULL) {
810999653d4eSeschrock (void) fprintf(stderr, gettext("internal error: failed to "
811099653d4eSeschrock "initialize ZFS library\n"));
811199653d4eSeschrock return (1);
811299653d4eSeschrock }
811399653d4eSeschrock
81144445fffbSMatthew Ahrens zfs_save_arguments(argc, argv, history_str, sizeof (history_str));
8115ecd6cf80Smarks
811699653d4eSeschrock libzfs_print_on_error(g_zfs, B_TRUE);
811799653d4eSeschrock
8118fa9e4066Sahrens if ((mnttab_file = fopen(MNTTAB, "r")) == NULL) {
8119fa9e4066Sahrens (void) fprintf(stderr, gettext("internal error: unable to "
8120fa9e4066Sahrens "open %s\n"), MNTTAB);
8121fa9e4066Sahrens return (1);
8122fa9e4066Sahrens }
8123fa9e4066Sahrens
8124fa9e4066Sahrens /*
8125fa9e4066Sahrens * This command also doubles as the /etc/fs mount and unmount program.
8126fa9e4066Sahrens * Determine if we should take this behavior based on argv[0].
8127fa9e4066Sahrens */
8128fa9e4066Sahrens progname = basename(argv[0]);
8129fa9e4066Sahrens if (strcmp(progname, "mount") == 0) {
8130fa9e4066Sahrens ret = manual_mount(argc, argv);
8131fa9e4066Sahrens } else if (strcmp(progname, "umount") == 0) {
8132fa9e4066Sahrens ret = manual_unmount(argc, argv);
8133fa9e4066Sahrens } else {
8134fa9e4066Sahrens /*
8135fa9e4066Sahrens * Make sure the user has specified some command.
8136fa9e4066Sahrens */
8137fa9e4066Sahrens if (argc < 2) {
8138fa9e4066Sahrens (void) fprintf(stderr, gettext("missing command\n"));
813999653d4eSeschrock usage(B_FALSE);
8140fa9e4066Sahrens }
8141fa9e4066Sahrens
8142fa9e4066Sahrens cmdname = argv[1];
8143fa9e4066Sahrens
8144fa9e4066Sahrens /*
8145fa9e4066Sahrens * The 'umount' command is an alias for 'unmount'
8146fa9e4066Sahrens */
8147fa9e4066Sahrens if (strcmp(cmdname, "umount") == 0)
8148fa9e4066Sahrens cmdname = "unmount";
8149fa9e4066Sahrens
8150f2a3c691Sahrens /*
8151f2a3c691Sahrens * The 'recv' command is an alias for 'receive'
8152f2a3c691Sahrens */
8153f2a3c691Sahrens if (strcmp(cmdname, "recv") == 0)
8154f2a3c691Sahrens cmdname = "receive";
8155f2a3c691Sahrens
81567dbbcd83SAdam Stevko /*
81577dbbcd83SAdam Stevko * The 'snap' command is an alias for 'snapshot'
81587dbbcd83SAdam Stevko */
81597dbbcd83SAdam Stevko if (strcmp(cmdname, "snap") == 0)
81607dbbcd83SAdam Stevko cmdname = "snapshot";
81617dbbcd83SAdam Stevko
8162fa9e4066Sahrens /*
8163fa9e4066Sahrens * Special case '-?'
8164fa9e4066Sahrens */
8165fa9e4066Sahrens if (strcmp(cmdname, "-?") == 0)
816699653d4eSeschrock usage(B_TRUE);
8167fa9e4066Sahrens
8168fa9e4066Sahrens /*
8169fa9e4066Sahrens * Run the appropriate command.
8170fa9e4066Sahrens */
8171b2634b9cSEric Taylor libzfs_mnttab_cache(g_zfs, B_TRUE);
8172ecd6cf80Smarks if (find_command_idx(cmdname, &i) == 0) {
8173ecd6cf80Smarks current_command = &command_table[i];
8174ecd6cf80Smarks ret = command_table[i].func(argc - 1, argv + 1);
817591ebeef5Sahrens } else if (strchr(cmdname, '=') != NULL) {
817691ebeef5Sahrens verify(find_command_idx("set", &i) == 0);
817791ebeef5Sahrens current_command = &command_table[i];
817891ebeef5Sahrens ret = command_table[i].func(argc, argv);
817991ebeef5Sahrens } else {
8180fa9e4066Sahrens (void) fprintf(stderr, gettext("unrecognized "
8181fa9e4066Sahrens "command '%s'\n"), cmdname);
818299653d4eSeschrock usage(B_FALSE);
8183fa9e4066Sahrens }
8184b2634b9cSEric Taylor libzfs_mnttab_cache(g_zfs, B_FALSE);
8185fa9e4066Sahrens }
8186fa9e4066Sahrens
8187fa9e4066Sahrens (void) fclose(mnttab_file);
8188fa9e4066Sahrens
81894445fffbSMatthew Ahrens if (ret == 0 && log_history)
81904445fffbSMatthew Ahrens (void) zpool_log_history(g_zfs, history_str);
81914445fffbSMatthew Ahrens
819299653d4eSeschrock libzfs_fini(g_zfs);
819399653d4eSeschrock
8194fa9e4066Sahrens /*
8195fa9e4066Sahrens * The 'ZFS_ABORT' environment variable causes us to dump core on exit
8196fa9e4066Sahrens * for the purposes of running ::findleaks.
8197fa9e4066Sahrens */
8198fa9e4066Sahrens if (getenv("ZFS_ABORT") != NULL) {
8199fa9e4066Sahrens (void) printf("dumping core by request\n");
8200fa9e4066Sahrens abort();
8201fa9e4066Sahrens }
8202fa9e4066Sahrens
8203fa9e4066Sahrens return (ret);
8204fa9e4066Sahrens }
8205