1 /*
2 * CDDL HEADER START
3 *
4 * The contents of this file are subject to the terms of the
5 * Common Development and Distribution License (the "License").
6 * You may not use this file except in compliance with the License.
7 *
8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9 * or http://www.opensolaris.org/os/licensing.
10 * See the License for the specific language governing permissions
11 * and limitations under the License.
12 *
13 * When distributing Covered Code, include this CDDL HEADER in each
14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15 * If applicable, add the following below this CDDL HEADER, with the
16 * fields enclosed by brackets "[]" replaced with your own identifying
17 * information: Portions Copyright [yyyy] [name of copyright owner]
18 *
19 * CDDL HEADER END
20 */
21 /*
22 * Copyright (c) 2005, 2010, Oracle and/or its affiliates. All rights reserved.
23 * Copyright (c) 2012, 2015 by Delphix. All rights reserved.
24 * Copyright (c) 2014 Integros [integros.com]
25 * Copyright 2016 Nexenta Systems, Inc. All rights reserved.
26 * Copyright 2019 Joyent, Inc.
27 * Copyright 2020 Joshua M. Clulow <josh@sysmgr.org>
28 * Copyright 2020 OmniOS Community Edition (OmniOSce) Association.
29 * Copyright 2022 Oxide Computer Company
30 */
31
32 /* Portions Copyright 2010 Robert Milkowski */
33
34 #include <sys/types.h>
35 #include <sys/param.h>
36 #include <sys/systm.h>
37 #include <sys/sysmacros.h>
38 #include <sys/kmem.h>
39 #include <sys/pathname.h>
40 #include <sys/vnode.h>
41 #include <sys/vfs.h>
42 #include <sys/vfs_opreg.h>
43 #include <sys/mntent.h>
44 #include <sys/mount.h>
45 #include <sys/cmn_err.h>
46 #include "fs/fs_subr.h"
47 #include <sys/zfs_znode.h>
48 #include <sys/zfs_dir.h>
49 #include <sys/zil.h>
50 #include <sys/fs/zfs.h>
51 #include <sys/dmu.h>
52 #include <sys/dsl_prop.h>
53 #include <sys/dsl_dataset.h>
54 #include <sys/dsl_deleg.h>
55 #include <sys/spa.h>
56 #include <sys/zap.h>
57 #include <sys/sa.h>
58 #include <sys/sa_impl.h>
59 #include <sys/varargs.h>
60 #include <sys/policy.h>
61 #include <sys/atomic.h>
62 #include <sys/mkdev.h>
63 #include <sys/modctl.h>
64 #include <sys/refstr.h>
65 #include <sys/zfs_ioctl.h>
66 #include <sys/zfs_ctldir.h>
67 #include <sys/zfs_fuid.h>
68 #include <sys/bootconf.h>
69 #include <sys/ddi.h>
70 #include <sys/sunddi.h>
71 #include <sys/dnlc.h>
72 #include <sys/dmu_objset.h>
73 #include <sys/spa_boot.h>
74 #include <sys/vdev_impl.h>
75 #include "zfs_comutil.h"
76
77 int zfsfstype;
78 vfsops_t *zfs_vfsops = NULL;
79 static major_t zfs_major;
80 static minor_t zfs_minor;
81 static kmutex_t zfs_dev_mtx;
82
83 extern int sys_shutdown;
84
85 static int zfs_mount(vfs_t *vfsp, vnode_t *mvp, struct mounta *uap, cred_t *cr);
86 static int zfs_umount(vfs_t *vfsp, int fflag, cred_t *cr);
87 static int zfs_mountroot(vfs_t *vfsp, enum whymountroot);
88 static int zfs_root(vfs_t *vfsp, vnode_t **vpp);
89 static int zfs_statvfs(vfs_t *vfsp, struct statvfs64 *statp);
90 static int zfs_vget(vfs_t *vfsp, vnode_t **vpp, fid_t *fidp);
91 static void zfs_freevfs(vfs_t *vfsp);
92
93 static const fs_operation_def_t zfs_vfsops_template[] = {
94 VFSNAME_MOUNT, { .vfs_mount = zfs_mount },
95 VFSNAME_MOUNTROOT, { .vfs_mountroot = zfs_mountroot },
96 VFSNAME_UNMOUNT, { .vfs_unmount = zfs_umount },
97 VFSNAME_ROOT, { .vfs_root = zfs_root },
98 VFSNAME_STATVFS, { .vfs_statvfs = zfs_statvfs },
99 VFSNAME_SYNC, { .vfs_sync = zfs_sync },
100 VFSNAME_VGET, { .vfs_vget = zfs_vget },
101 VFSNAME_FREEVFS, { .vfs_freevfs = zfs_freevfs },
102 NULL, NULL
103 };
104
105 /*
106 * We need to keep a count of active fs's.
107 * This is necessary to prevent our module
108 * from being unloaded after a umount -f
109 */
110 static uint32_t zfs_active_fs_count = 0;
111
112 static char *noatime_cancel[] = { MNTOPT_ATIME, NULL };
113 static char *atime_cancel[] = { MNTOPT_NOATIME, NULL };
114 static char *noxattr_cancel[] = { MNTOPT_XATTR, NULL };
115 static char *xattr_cancel[] = { MNTOPT_NOXATTR, NULL };
116
117 /*
118 * MO_DEFAULT is not used since the default value is determined
119 * by the equivalent property.
120 */
121 static mntopt_t mntopts[] = {
122 { MNTOPT_NOXATTR, noxattr_cancel, NULL, 0, NULL },
123 { MNTOPT_XATTR, xattr_cancel, NULL, 0, NULL },
124 { MNTOPT_NOATIME, noatime_cancel, NULL, 0, NULL },
125 { MNTOPT_ATIME, atime_cancel, NULL, 0, NULL }
126 };
127
128 static mntopts_t zfs_mntopts = {
129 sizeof (mntopts) / sizeof (mntopt_t),
130 mntopts
131 };
132
133 /*ARGSUSED*/
134 int
zfs_sync(vfs_t * vfsp,short flag,cred_t * cr)135 zfs_sync(vfs_t *vfsp, short flag, cred_t *cr)
136 {
137 /*
138 * Data integrity is job one. We don't want a compromised kernel
139 * writing to the storage pool, so we never sync during panic.
140 */
141 if (panicstr)
142 return (0);
143
144 /*
145 * SYNC_ATTR is used by fsflush() to force old filesystems like UFS
146 * to sync metadata, which they would otherwise cache indefinitely.
147 * Semantically, the only requirement is that the sync be initiated.
148 * The DMU syncs out txgs frequently, so there's nothing to do.
149 */
150 if (flag & SYNC_ATTR)
151 return (0);
152
153 if (vfsp != NULL) {
154 /*
155 * Sync a specific filesystem.
156 */
157 zfsvfs_t *zfsvfs = vfsp->vfs_data;
158 dsl_pool_t *dp;
159
160 ZFS_ENTER(zfsvfs);
161 dp = dmu_objset_pool(zfsvfs->z_os);
162
163 /*
164 * If the system is shutting down, then skip any
165 * filesystems which may exist on a suspended pool.
166 */
167 if (sys_shutdown && spa_suspended(dp->dp_spa)) {
168 ZFS_EXIT(zfsvfs);
169 return (0);
170 }
171
172 if (zfsvfs->z_log != NULL)
173 zil_commit(zfsvfs->z_log, 0);
174
175 ZFS_EXIT(zfsvfs);
176 } else {
177 /*
178 * Sync all ZFS filesystems. This is what happens when you
179 * run sync(8). Unlike other filesystems, ZFS honors the
180 * request by waiting for all pools to commit all dirty data.
181 */
182 spa_sync_allpools();
183 }
184
185 return (0);
186 }
187
188 static int
zfs_create_unique_device(dev_t * dev)189 zfs_create_unique_device(dev_t *dev)
190 {
191 major_t new_major;
192
193 do {
194 ASSERT3U(zfs_minor, <=, MAXMIN32);
195 minor_t start = zfs_minor;
196 do {
197 mutex_enter(&zfs_dev_mtx);
198 if (zfs_minor >= MAXMIN32) {
199 /*
200 * If we're still using the real major
201 * keep out of /dev/zfs and /dev/zvol minor
202 * number space. If we're using a getudev()'ed
203 * major number, we can use all of its minors.
204 */
205 if (zfs_major == ddi_name_to_major(ZFS_DRIVER))
206 zfs_minor = ZFS_MIN_MINOR;
207 else
208 zfs_minor = 0;
209 } else {
210 zfs_minor++;
211 }
212 *dev = makedevice(zfs_major, zfs_minor);
213 mutex_exit(&zfs_dev_mtx);
214 } while (vfs_devismounted(*dev) && zfs_minor != start);
215 if (zfs_minor == start) {
216 /*
217 * We are using all ~262,000 minor numbers for the
218 * current major number. Create a new major number.
219 */
220 if ((new_major = getudev()) == (major_t)-1) {
221 cmn_err(CE_WARN,
222 "zfs_mount: Can't get unique major "
223 "device number.");
224 return (-1);
225 }
226 mutex_enter(&zfs_dev_mtx);
227 zfs_major = new_major;
228 zfs_minor = 0;
229
230 mutex_exit(&zfs_dev_mtx);
231 } else {
232 break;
233 }
234 /* CONSTANTCONDITION */
235 } while (1);
236
237 return (0);
238 }
239
240 static void
atime_changed_cb(void * arg,uint64_t newval)241 atime_changed_cb(void *arg, uint64_t newval)
242 {
243 zfsvfs_t *zfsvfs = arg;
244
245 if (newval == TRUE) {
246 zfsvfs->z_atime = TRUE;
247 vfs_clearmntopt(zfsvfs->z_vfs, MNTOPT_NOATIME);
248 vfs_setmntopt(zfsvfs->z_vfs, MNTOPT_ATIME, NULL, 0);
249 } else {
250 zfsvfs->z_atime = FALSE;
251 vfs_clearmntopt(zfsvfs->z_vfs, MNTOPT_ATIME);
252 vfs_setmntopt(zfsvfs->z_vfs, MNTOPT_NOATIME, NULL, 0);
253 }
254 }
255
256 static void
xattr_changed_cb(void * arg,uint64_t newval)257 xattr_changed_cb(void *arg, uint64_t newval)
258 {
259 zfsvfs_t *zfsvfs = arg;
260
261 if (newval == TRUE) {
262 /* XXX locking on vfs_flag? */
263 zfsvfs->z_vfs->vfs_flag |= VFS_XATTR;
264 vfs_clearmntopt(zfsvfs->z_vfs, MNTOPT_NOXATTR);
265 vfs_setmntopt(zfsvfs->z_vfs, MNTOPT_XATTR, NULL, 0);
266 } else {
267 /* XXX locking on vfs_flag? */
268 zfsvfs->z_vfs->vfs_flag &= ~VFS_XATTR;
269 vfs_clearmntopt(zfsvfs->z_vfs, MNTOPT_XATTR);
270 vfs_setmntopt(zfsvfs->z_vfs, MNTOPT_NOXATTR, NULL, 0);
271 }
272 }
273
274 static void
blksz_changed_cb(void * arg,uint64_t newval)275 blksz_changed_cb(void *arg, uint64_t newval)
276 {
277 zfsvfs_t *zfsvfs = arg;
278 ASSERT3U(newval, <=, spa_maxblocksize(dmu_objset_spa(zfsvfs->z_os)));
279 ASSERT3U(newval, >=, SPA_MINBLOCKSIZE);
280 ASSERT(ISP2(newval));
281
282 zfsvfs->z_max_blksz = newval;
283 zfsvfs->z_vfs->vfs_bsize = newval;
284 }
285
286 static void
readonly_changed_cb(void * arg,uint64_t newval)287 readonly_changed_cb(void *arg, uint64_t newval)
288 {
289 zfsvfs_t *zfsvfs = arg;
290
291 if (newval) {
292 /* XXX locking on vfs_flag? */
293 zfsvfs->z_vfs->vfs_flag |= VFS_RDONLY;
294 vfs_clearmntopt(zfsvfs->z_vfs, MNTOPT_RW);
295 vfs_setmntopt(zfsvfs->z_vfs, MNTOPT_RO, NULL, 0);
296 } else {
297 /* XXX locking on vfs_flag? */
298 zfsvfs->z_vfs->vfs_flag &= ~VFS_RDONLY;
299 vfs_clearmntopt(zfsvfs->z_vfs, MNTOPT_RO);
300 vfs_setmntopt(zfsvfs->z_vfs, MNTOPT_RW, NULL, 0);
301 }
302 }
303
304 static void
devices_changed_cb(void * arg,uint64_t newval)305 devices_changed_cb(void *arg, uint64_t newval)
306 {
307 zfsvfs_t *zfsvfs = arg;
308
309 if (newval == FALSE) {
310 zfsvfs->z_vfs->vfs_flag |= VFS_NODEVICES;
311 vfs_clearmntopt(zfsvfs->z_vfs, MNTOPT_DEVICES);
312 vfs_setmntopt(zfsvfs->z_vfs, MNTOPT_NODEVICES, NULL, 0);
313 } else {
314 zfsvfs->z_vfs->vfs_flag &= ~VFS_NODEVICES;
315 vfs_clearmntopt(zfsvfs->z_vfs, MNTOPT_NODEVICES);
316 vfs_setmntopt(zfsvfs->z_vfs, MNTOPT_DEVICES, NULL, 0);
317 }
318 }
319
320 static void
setuid_changed_cb(void * arg,uint64_t newval)321 setuid_changed_cb(void *arg, uint64_t newval)
322 {
323 zfsvfs_t *zfsvfs = arg;
324
325 if (newval == FALSE) {
326 zfsvfs->z_vfs->vfs_flag |= VFS_NOSETUID;
327 vfs_clearmntopt(zfsvfs->z_vfs, MNTOPT_SETUID);
328 vfs_setmntopt(zfsvfs->z_vfs, MNTOPT_NOSETUID, NULL, 0);
329 } else {
330 zfsvfs->z_vfs->vfs_flag &= ~VFS_NOSETUID;
331 vfs_clearmntopt(zfsvfs->z_vfs, MNTOPT_NOSETUID);
332 vfs_setmntopt(zfsvfs->z_vfs, MNTOPT_SETUID, NULL, 0);
333 }
334 }
335
336 static void
exec_changed_cb(void * arg,uint64_t newval)337 exec_changed_cb(void *arg, uint64_t newval)
338 {
339 zfsvfs_t *zfsvfs = arg;
340
341 if (newval == FALSE) {
342 zfsvfs->z_vfs->vfs_flag |= VFS_NOEXEC;
343 vfs_clearmntopt(zfsvfs->z_vfs, MNTOPT_EXEC);
344 vfs_setmntopt(zfsvfs->z_vfs, MNTOPT_NOEXEC, NULL, 0);
345 } else {
346 zfsvfs->z_vfs->vfs_flag &= ~VFS_NOEXEC;
347 vfs_clearmntopt(zfsvfs->z_vfs, MNTOPT_NOEXEC);
348 vfs_setmntopt(zfsvfs->z_vfs, MNTOPT_EXEC, NULL, 0);
349 }
350 }
351
352 /*
353 * The nbmand mount option can be changed at mount time.
354 * We can't allow it to be toggled on live file systems or incorrect
355 * behavior may be seen from cifs clients
356 *
357 * This property isn't registered via dsl_prop_register(), but this callback
358 * will be called when a file system is first mounted
359 */
360 static void
nbmand_changed_cb(void * arg,uint64_t newval)361 nbmand_changed_cb(void *arg, uint64_t newval)
362 {
363 zfsvfs_t *zfsvfs = arg;
364 if (newval == FALSE) {
365 vfs_clearmntopt(zfsvfs->z_vfs, MNTOPT_NBMAND);
366 vfs_setmntopt(zfsvfs->z_vfs, MNTOPT_NONBMAND, NULL, 0);
367 } else {
368 vfs_clearmntopt(zfsvfs->z_vfs, MNTOPT_NONBMAND);
369 vfs_setmntopt(zfsvfs->z_vfs, MNTOPT_NBMAND, NULL, 0);
370 }
371 }
372
373 static void
snapdir_changed_cb(void * arg,uint64_t newval)374 snapdir_changed_cb(void *arg, uint64_t newval)
375 {
376 zfsvfs_t *zfsvfs = arg;
377
378 zfsvfs->z_show_ctldir = newval;
379 }
380
381 static void
vscan_changed_cb(void * arg,uint64_t newval)382 vscan_changed_cb(void *arg, uint64_t newval)
383 {
384 zfsvfs_t *zfsvfs = arg;
385
386 zfsvfs->z_vscan = newval;
387 }
388
389 static void
acl_mode_changed_cb(void * arg,uint64_t newval)390 acl_mode_changed_cb(void *arg, uint64_t newval)
391 {
392 zfsvfs_t *zfsvfs = arg;
393
394 zfsvfs->z_acl_mode = newval;
395 }
396
397 static void
acl_inherit_changed_cb(void * arg,uint64_t newval)398 acl_inherit_changed_cb(void *arg, uint64_t newval)
399 {
400 zfsvfs_t *zfsvfs = arg;
401
402 zfsvfs->z_acl_inherit = newval;
403 }
404
405 static void
acl_implicit_changed_cb(void * arg,uint64_t newval)406 acl_implicit_changed_cb(void *arg, uint64_t newval)
407 {
408 zfsvfs_t *zfsvfs = arg;
409
410 zfsvfs->z_acl_implicit = (boolean_t)newval;
411 }
412
413 static int
zfs_register_callbacks(vfs_t * vfsp)414 zfs_register_callbacks(vfs_t *vfsp)
415 {
416 struct dsl_dataset *ds = NULL;
417 objset_t *os = NULL;
418 zfsvfs_t *zfsvfs = NULL;
419 uint64_t nbmand;
420 boolean_t readonly = B_FALSE;
421 boolean_t do_readonly = B_FALSE;
422 boolean_t setuid = B_FALSE;
423 boolean_t do_setuid = B_FALSE;
424 boolean_t exec = B_FALSE;
425 boolean_t do_exec = B_FALSE;
426 boolean_t devices = B_FALSE;
427 boolean_t do_devices = B_FALSE;
428 boolean_t xattr = B_FALSE;
429 boolean_t do_xattr = B_FALSE;
430 boolean_t atime = B_FALSE;
431 boolean_t do_atime = B_FALSE;
432 int error = 0;
433
434 ASSERT(vfsp);
435 zfsvfs = vfsp->vfs_data;
436 ASSERT(zfsvfs);
437 os = zfsvfs->z_os;
438
439 /*
440 * The act of registering our callbacks will destroy any mount
441 * options we may have. In order to enable temporary overrides
442 * of mount options, we stash away the current values and
443 * restore them after we register the callbacks.
444 */
445 if (vfs_optionisset(vfsp, MNTOPT_RO, NULL) ||
446 !spa_writeable(dmu_objset_spa(os))) {
447 readonly = B_TRUE;
448 do_readonly = B_TRUE;
449 } else if (vfs_optionisset(vfsp, MNTOPT_RW, NULL)) {
450 readonly = B_FALSE;
451 do_readonly = B_TRUE;
452 }
453 if (vfs_optionisset(vfsp, MNTOPT_NOSUID, NULL)) {
454 devices = B_FALSE;
455 setuid = B_FALSE;
456 do_devices = B_TRUE;
457 do_setuid = B_TRUE;
458 } else {
459 if (vfs_optionisset(vfsp, MNTOPT_NODEVICES, NULL)) {
460 devices = B_FALSE;
461 do_devices = B_TRUE;
462 } else if (vfs_optionisset(vfsp, MNTOPT_DEVICES, NULL)) {
463 devices = B_TRUE;
464 do_devices = B_TRUE;
465 }
466
467 if (vfs_optionisset(vfsp, MNTOPT_NOSETUID, NULL)) {
468 setuid = B_FALSE;
469 do_setuid = B_TRUE;
470 } else if (vfs_optionisset(vfsp, MNTOPT_SETUID, NULL)) {
471 setuid = B_TRUE;
472 do_setuid = B_TRUE;
473 }
474 }
475 if (vfs_optionisset(vfsp, MNTOPT_NOEXEC, NULL)) {
476 exec = B_FALSE;
477 do_exec = B_TRUE;
478 } else if (vfs_optionisset(vfsp, MNTOPT_EXEC, NULL)) {
479 exec = B_TRUE;
480 do_exec = B_TRUE;
481 }
482 if (vfs_optionisset(vfsp, MNTOPT_NOXATTR, NULL)) {
483 xattr = B_FALSE;
484 do_xattr = B_TRUE;
485 } else if (vfs_optionisset(vfsp, MNTOPT_XATTR, NULL)) {
486 xattr = B_TRUE;
487 do_xattr = B_TRUE;
488 }
489 if (vfs_optionisset(vfsp, MNTOPT_NOATIME, NULL)) {
490 atime = B_FALSE;
491 do_atime = B_TRUE;
492 } else if (vfs_optionisset(vfsp, MNTOPT_ATIME, NULL)) {
493 atime = B_TRUE;
494 do_atime = B_TRUE;
495 }
496
497 /*
498 * nbmand is a special property. It can only be changed at
499 * mount time.
500 *
501 * This is weird, but it is documented to only be changeable
502 * at mount time.
503 */
504 if (vfs_optionisset(vfsp, MNTOPT_NONBMAND, NULL)) {
505 nbmand = B_FALSE;
506 } else if (vfs_optionisset(vfsp, MNTOPT_NBMAND, NULL)) {
507 nbmand = B_TRUE;
508 } else {
509 char osname[ZFS_MAX_DATASET_NAME_LEN];
510
511 dmu_objset_name(os, osname);
512 if (error = dsl_prop_get_integer(osname, "nbmand", &nbmand,
513 NULL)) {
514 return (error);
515 }
516 }
517
518 /*
519 * Register property callbacks.
520 *
521 * It would probably be fine to just check for i/o error from
522 * the first prop_register(), but I guess I like to go
523 * overboard...
524 */
525 ds = dmu_objset_ds(os);
526 dsl_pool_config_enter(dmu_objset_pool(os), FTAG);
527 error = dsl_prop_register(ds,
528 zfs_prop_to_name(ZFS_PROP_ATIME), atime_changed_cb, zfsvfs);
529 error = error ? error : dsl_prop_register(ds,
530 zfs_prop_to_name(ZFS_PROP_XATTR), xattr_changed_cb, zfsvfs);
531 error = error ? error : dsl_prop_register(ds,
532 zfs_prop_to_name(ZFS_PROP_RECORDSIZE), blksz_changed_cb, zfsvfs);
533 error = error ? error : dsl_prop_register(ds,
534 zfs_prop_to_name(ZFS_PROP_READONLY), readonly_changed_cb, zfsvfs);
535 error = error ? error : dsl_prop_register(ds,
536 zfs_prop_to_name(ZFS_PROP_DEVICES), devices_changed_cb, zfsvfs);
537 error = error ? error : dsl_prop_register(ds,
538 zfs_prop_to_name(ZFS_PROP_SETUID), setuid_changed_cb, zfsvfs);
539 error = error ? error : dsl_prop_register(ds,
540 zfs_prop_to_name(ZFS_PROP_EXEC), exec_changed_cb, zfsvfs);
541 error = error ? error : dsl_prop_register(ds,
542 zfs_prop_to_name(ZFS_PROP_SNAPDIR), snapdir_changed_cb, zfsvfs);
543 error = error ? error : dsl_prop_register(ds,
544 zfs_prop_to_name(ZFS_PROP_ACLMODE), acl_mode_changed_cb, zfsvfs);
545 error = error ? error : dsl_prop_register(ds,
546 zfs_prop_to_name(ZFS_PROP_ACLINHERIT), acl_inherit_changed_cb,
547 zfsvfs);
548 error = error ? error : dsl_prop_register(ds,
549 zfs_prop_to_name(ZFS_PROP_ACLIMPLICIT),
550 acl_implicit_changed_cb, zfsvfs);
551 error = error ? error : dsl_prop_register(ds,
552 zfs_prop_to_name(ZFS_PROP_VSCAN), vscan_changed_cb, zfsvfs);
553 dsl_pool_config_exit(dmu_objset_pool(os), FTAG);
554 if (error)
555 goto unregister;
556
557 /*
558 * Invoke our callbacks to restore temporary mount options.
559 */
560 if (do_readonly)
561 readonly_changed_cb(zfsvfs, readonly);
562 if (do_setuid)
563 setuid_changed_cb(zfsvfs, setuid);
564 if (do_exec)
565 exec_changed_cb(zfsvfs, exec);
566 if (do_devices)
567 devices_changed_cb(zfsvfs, devices);
568 if (do_xattr)
569 xattr_changed_cb(zfsvfs, xattr);
570 if (do_atime)
571 atime_changed_cb(zfsvfs, atime);
572
573 nbmand_changed_cb(zfsvfs, nbmand);
574
575 return (0);
576
577 unregister:
578 dsl_prop_unregister_all(ds, zfsvfs);
579 return (error);
580 }
581
582 static int
zfs_space_delta_cb(dmu_object_type_t bonustype,void * data,uint64_t * userp,uint64_t * groupp,uint64_t * projectp)583 zfs_space_delta_cb(dmu_object_type_t bonustype, void *data,
584 uint64_t *userp, uint64_t *groupp, uint64_t *projectp)
585 {
586 sa_hdr_phys_t sa;
587 sa_hdr_phys_t *sap = data;
588 uint64_t flags;
589 int hdrsize;
590 boolean_t swap = B_FALSE;
591
592 /*
593 * Is it a valid type of object to track?
594 */
595 if (bonustype != DMU_OT_ZNODE && bonustype != DMU_OT_SA)
596 return (SET_ERROR(ENOENT));
597
598 /*
599 * If we have a NULL data pointer
600 * then assume the id's aren't changing and
601 * return EEXIST to the dmu to let it know to
602 * use the same ids
603 */
604 if (data == NULL)
605 return (SET_ERROR(EEXIST));
606
607 if (bonustype == DMU_OT_ZNODE) {
608 znode_phys_t *znp = data;
609 *userp = znp->zp_uid;
610 *groupp = znp->zp_gid;
611 *projectp = ZFS_DEFAULT_PROJID;
612 return (0);
613 }
614
615 if (sap->sa_magic == 0) {
616 /*
617 * This should only happen for newly created files
618 * that haven't had the znode data filled in yet.
619 */
620 *userp = 0;
621 *groupp = 0;
622 *projectp = ZFS_DEFAULT_PROJID;
623 return (0);
624 }
625
626 sa = *sap;
627 if (sa.sa_magic == BSWAP_32(SA_MAGIC)) {
628 sa.sa_magic = SA_MAGIC;
629 sa.sa_layout_info = BSWAP_16(sa.sa_layout_info);
630 swap = B_TRUE;
631 } else {
632 VERIFY3U(sa.sa_magic, ==, SA_MAGIC);
633 }
634
635 hdrsize = sa_hdrsize(&sa);
636 VERIFY3U(hdrsize, >=, sizeof (sa_hdr_phys_t));
637
638 *userp = *((uint64_t *)((uintptr_t)data + hdrsize + SA_UID_OFFSET));
639 *groupp = *((uint64_t *)((uintptr_t)data + hdrsize + SA_GID_OFFSET));
640 flags = *((uint64_t *)((uintptr_t)data + hdrsize + SA_FLAGS_OFFSET));
641 if (swap)
642 flags = BSWAP_64(flags);
643
644 if (flags & ZFS_PROJID)
645 *projectp = *((uint64_t *)((uintptr_t)data + hdrsize +
646 SA_PROJID_OFFSET));
647 else
648 *projectp = ZFS_DEFAULT_PROJID;
649
650 if (swap) {
651 *userp = BSWAP_64(*userp);
652 *groupp = BSWAP_64(*groupp);
653 *projectp = BSWAP_64(*projectp);
654 }
655 return (0);
656 }
657
658 static void
fuidstr_to_sid(zfsvfs_t * zfsvfs,const char * fuidstr,char * domainbuf,int buflen,uid_t * ridp)659 fuidstr_to_sid(zfsvfs_t *zfsvfs, const char *fuidstr,
660 char *domainbuf, int buflen, uid_t *ridp)
661 {
662 uint64_t fuid;
663 const char *domain;
664
665 fuid = zfs_strtonum(fuidstr, NULL);
666
667 domain = zfs_fuid_find_by_idx(zfsvfs, FUID_INDEX(fuid));
668 if (domain)
669 (void) strlcpy(domainbuf, domain, buflen);
670 else
671 domainbuf[0] = '\0';
672 *ridp = FUID_RID(fuid);
673 }
674
675 static uint64_t
zfs_userquota_prop_to_obj(zfsvfs_t * zfsvfs,zfs_userquota_prop_t type)676 zfs_userquota_prop_to_obj(zfsvfs_t *zfsvfs, zfs_userquota_prop_t type)
677 {
678 switch (type) {
679 case ZFS_PROP_USERUSED:
680 case ZFS_PROP_USEROBJUSED:
681 return (DMU_USERUSED_OBJECT);
682 case ZFS_PROP_GROUPUSED:
683 case ZFS_PROP_GROUPOBJUSED:
684 return (DMU_GROUPUSED_OBJECT);
685 case ZFS_PROP_PROJECTUSED:
686 case ZFS_PROP_PROJECTOBJUSED:
687 return (DMU_PROJECTUSED_OBJECT);
688 case ZFS_PROP_USERQUOTA:
689 return (zfsvfs->z_userquota_obj);
690 case ZFS_PROP_GROUPQUOTA:
691 return (zfsvfs->z_groupquota_obj);
692 case ZFS_PROP_USEROBJQUOTA:
693 return (zfsvfs->z_userobjquota_obj);
694 case ZFS_PROP_GROUPOBJQUOTA:
695 return (zfsvfs->z_groupobjquota_obj);
696 case ZFS_PROP_PROJECTQUOTA:
697 return (zfsvfs->z_projectquota_obj);
698 case ZFS_PROP_PROJECTOBJQUOTA:
699 return (zfsvfs->z_projectobjquota_obj);
700 default:
701 return (ZFS_NO_OBJECT);
702 }
703 }
704
705 int
zfs_userspace_many(zfsvfs_t * zfsvfs,zfs_userquota_prop_t type,uint64_t * cookiep,void * vbuf,uint64_t * bufsizep)706 zfs_userspace_many(zfsvfs_t *zfsvfs, zfs_userquota_prop_t type,
707 uint64_t *cookiep, void *vbuf, uint64_t *bufsizep)
708 {
709 int error;
710 zap_cursor_t zc;
711 zap_attribute_t za;
712 zfs_useracct_t *buf = vbuf;
713 uint64_t obj;
714 int offset = 0;
715
716 if (!dmu_objset_userspace_present(zfsvfs->z_os))
717 return (SET_ERROR(ENOTSUP));
718
719 if ((type == ZFS_PROP_PROJECTQUOTA || type == ZFS_PROP_PROJECTUSED ||
720 type == ZFS_PROP_PROJECTOBJQUOTA ||
721 type == ZFS_PROP_PROJECTOBJUSED) &&
722 !dmu_objset_projectquota_present(zfsvfs->z_os))
723 return (SET_ERROR(ENOTSUP));
724
725 if ((type == ZFS_PROP_USEROBJUSED || type == ZFS_PROP_GROUPOBJUSED ||
726 type == ZFS_PROP_USEROBJQUOTA || type == ZFS_PROP_GROUPOBJQUOTA ||
727 type == ZFS_PROP_PROJECTOBJUSED ||
728 type == ZFS_PROP_PROJECTOBJQUOTA) &&
729 !dmu_objset_userobjspace_present(zfsvfs->z_os))
730 return (SET_ERROR(ENOTSUP));
731
732 obj = zfs_userquota_prop_to_obj(zfsvfs, type);
733 if (obj == ZFS_NO_OBJECT) {
734 *bufsizep = 0;
735 return (0);
736 }
737
738 if (type == ZFS_PROP_USEROBJUSED || type == ZFS_PROP_GROUPOBJUSED ||
739 type == ZFS_PROP_PROJECTOBJUSED)
740 offset = DMU_OBJACCT_PREFIX_LEN;
741
742 for (zap_cursor_init_serialized(&zc, zfsvfs->z_os, obj, *cookiep);
743 (error = zap_cursor_retrieve(&zc, &za)) == 0;
744 zap_cursor_advance(&zc)) {
745 if ((uintptr_t)buf - (uintptr_t)vbuf + sizeof (zfs_useracct_t) >
746 *bufsizep)
747 break;
748
749 /*
750 * skip object quota (with zap name prefix DMU_OBJACCT_PREFIX)
751 * when dealing with block quota and vice versa.
752 */
753 if ((offset > 0) != (strncmp(za.za_name, DMU_OBJACCT_PREFIX,
754 DMU_OBJACCT_PREFIX_LEN) == 0))
755 continue;
756
757 fuidstr_to_sid(zfsvfs, za.za_name + offset,
758 buf->zu_domain, sizeof (buf->zu_domain), &buf->zu_rid);
759
760 buf->zu_space = za.za_first_integer;
761 buf++;
762 }
763 if (error == ENOENT)
764 error = 0;
765
766 ASSERT3U((uintptr_t)buf - (uintptr_t)vbuf, <=, *bufsizep);
767 *bufsizep = (uintptr_t)buf - (uintptr_t)vbuf;
768 *cookiep = zap_cursor_serialize(&zc);
769 zap_cursor_fini(&zc);
770 return (error);
771 }
772
773 /*
774 * buf must be big enough (eg, 32 bytes)
775 */
776 static int
id_to_fuidstr(zfsvfs_t * zfsvfs,const char * domain,uid_t rid,char * buf,boolean_t addok)777 id_to_fuidstr(zfsvfs_t *zfsvfs, const char *domain, uid_t rid,
778 char *buf, boolean_t addok)
779 {
780 uint64_t fuid;
781 int domainid = 0;
782
783 if (domain && domain[0]) {
784 domainid = zfs_fuid_find_by_domain(zfsvfs, domain, NULL, addok);
785 if (domainid == -1)
786 return (SET_ERROR(ENOENT));
787 }
788 fuid = FUID_ENCODE(domainid, rid);
789 (void) sprintf(buf, "%llx", (longlong_t)fuid);
790 return (0);
791 }
792
793 int
zfs_userspace_one(zfsvfs_t * zfsvfs,zfs_userquota_prop_t type,const char * domain,uint64_t rid,uint64_t * valp)794 zfs_userspace_one(zfsvfs_t *zfsvfs, zfs_userquota_prop_t type,
795 const char *domain, uint64_t rid, uint64_t *valp)
796 {
797 char buf[20 + DMU_OBJACCT_PREFIX_LEN];
798 int offset = 0;
799 int err;
800 uint64_t obj;
801
802 *valp = 0;
803
804 if (!dmu_objset_userspace_present(zfsvfs->z_os))
805 return (SET_ERROR(ENOTSUP));
806
807 if ((type == ZFS_PROP_USEROBJUSED || type == ZFS_PROP_GROUPOBJUSED ||
808 type == ZFS_PROP_USEROBJQUOTA || type == ZFS_PROP_GROUPOBJQUOTA ||
809 type == ZFS_PROP_PROJECTOBJUSED ||
810 type == ZFS_PROP_PROJECTOBJQUOTA) &&
811 !dmu_objset_userobjspace_present(zfsvfs->z_os))
812 return (SET_ERROR(ENOTSUP));
813
814 if (type == ZFS_PROP_PROJECTQUOTA || type == ZFS_PROP_PROJECTUSED ||
815 type == ZFS_PROP_PROJECTOBJQUOTA ||
816 type == ZFS_PROP_PROJECTOBJUSED) {
817 if (!dmu_objset_projectquota_present(zfsvfs->z_os))
818 return (SET_ERROR(ENOTSUP));
819 if (!zpl_is_valid_projid(rid))
820 return (SET_ERROR(EINVAL));
821 }
822
823 obj = zfs_userquota_prop_to_obj(zfsvfs, type);
824 if (obj == ZFS_NO_OBJECT)
825 return (0);
826
827 if (type == ZFS_PROP_USEROBJUSED || type == ZFS_PROP_GROUPOBJUSED ||
828 type == ZFS_PROP_PROJECTOBJUSED) {
829 strncpy(buf, DMU_OBJACCT_PREFIX, DMU_OBJACCT_PREFIX_LEN);
830 offset = DMU_OBJACCT_PREFIX_LEN;
831 }
832
833 err = id_to_fuidstr(zfsvfs, domain, rid, buf + offset, B_FALSE);
834 if (err)
835 return (err);
836
837 err = zap_lookup(zfsvfs->z_os, obj, buf, 8, 1, valp);
838 if (err == ENOENT)
839 err = 0;
840 return (err);
841 }
842
843 int
zfs_set_userquota(zfsvfs_t * zfsvfs,zfs_userquota_prop_t type,const char * domain,uint64_t rid,uint64_t quota)844 zfs_set_userquota(zfsvfs_t *zfsvfs, zfs_userquota_prop_t type,
845 const char *domain, uint64_t rid, uint64_t quota)
846 {
847 char buf[32];
848 int err;
849 dmu_tx_t *tx;
850 uint64_t *objp;
851 boolean_t fuid_dirtied;
852
853 if (zfsvfs->z_version < ZPL_VERSION_USERSPACE)
854 return (SET_ERROR(ENOTSUP));
855
856 switch (type) {
857 case ZFS_PROP_USERQUOTA:
858 objp = &zfsvfs->z_userquota_obj;
859 break;
860 case ZFS_PROP_GROUPQUOTA:
861 objp = &zfsvfs->z_groupquota_obj;
862 break;
863 case ZFS_PROP_USEROBJQUOTA:
864 objp = &zfsvfs->z_userobjquota_obj;
865 break;
866 case ZFS_PROP_GROUPOBJQUOTA:
867 objp = &zfsvfs->z_groupobjquota_obj;
868 break;
869 case ZFS_PROP_PROJECTQUOTA:
870 if (!dmu_objset_projectquota_enabled(zfsvfs->z_os))
871 return (SET_ERROR(ENOTSUP));
872 if (!zpl_is_valid_projid(rid))
873 return (SET_ERROR(EINVAL));
874
875 objp = &zfsvfs->z_projectquota_obj;
876 break;
877 case ZFS_PROP_PROJECTOBJQUOTA:
878 if (!dmu_objset_projectquota_enabled(zfsvfs->z_os))
879 return (SET_ERROR(ENOTSUP));
880 if (!zpl_is_valid_projid(rid))
881 return (SET_ERROR(EINVAL));
882
883 objp = &zfsvfs->z_projectobjquota_obj;
884 break;
885 default:
886 return (SET_ERROR(EINVAL));
887 }
888
889 err = id_to_fuidstr(zfsvfs, domain, rid, buf, B_TRUE);
890 if (err)
891 return (err);
892 fuid_dirtied = zfsvfs->z_fuid_dirty;
893
894 tx = dmu_tx_create(zfsvfs->z_os);
895 dmu_tx_hold_zap(tx, *objp ? *objp : DMU_NEW_OBJECT, B_TRUE, NULL);
896 if (*objp == 0) {
897 dmu_tx_hold_zap(tx, MASTER_NODE_OBJ, B_TRUE,
898 zfs_userquota_prop_prefixes[type]);
899 }
900 if (fuid_dirtied)
901 zfs_fuid_txhold(zfsvfs, tx);
902 err = dmu_tx_assign(tx, TXG_WAIT);
903 if (err) {
904 dmu_tx_abort(tx);
905 return (err);
906 }
907
908 mutex_enter(&zfsvfs->z_lock);
909 if (*objp == 0) {
910 *objp = zap_create(zfsvfs->z_os, DMU_OT_USERGROUP_QUOTA,
911 DMU_OT_NONE, 0, tx);
912 VERIFY(0 == zap_add(zfsvfs->z_os, MASTER_NODE_OBJ,
913 zfs_userquota_prop_prefixes[type], 8, 1, objp, tx));
914 }
915 mutex_exit(&zfsvfs->z_lock);
916
917 if (quota == 0) {
918 err = zap_remove(zfsvfs->z_os, *objp, buf, tx);
919 if (err == ENOENT)
920 err = 0;
921 } else {
922 err = zap_update(zfsvfs->z_os, *objp, buf, 8, 1, "a, tx);
923 }
924 ASSERT(err == 0);
925 if (fuid_dirtied)
926 zfs_fuid_sync(zfsvfs, tx);
927 dmu_tx_commit(tx);
928 return (err);
929 }
930
931 boolean_t
zfs_id_overobjquota(zfsvfs_t * zfsvfs,uint64_t usedobj,uint64_t id)932 zfs_id_overobjquota(zfsvfs_t *zfsvfs, uint64_t usedobj, uint64_t id)
933 {
934 char buf[20 + DMU_OBJACCT_PREFIX_LEN];
935 uint64_t used, quota, quotaobj;
936 int err;
937
938 if (!dmu_objset_userobjspace_present(zfsvfs->z_os)) {
939 if (dmu_objset_userobjspace_upgradable(zfsvfs->z_os)) {
940 dsl_pool_config_enter(
941 dmu_objset_pool(zfsvfs->z_os), FTAG);
942 dmu_objset_id_quota_upgrade(zfsvfs->z_os);
943 dsl_pool_config_exit(
944 dmu_objset_pool(zfsvfs->z_os), FTAG);
945 }
946 return (B_FALSE);
947 }
948
949 if (usedobj == DMU_PROJECTUSED_OBJECT) {
950 if (!dmu_objset_projectquota_present(zfsvfs->z_os)) {
951 if (dmu_objset_projectquota_upgradable(zfsvfs->z_os)) {
952 dsl_pool_config_enter(
953 dmu_objset_pool(zfsvfs->z_os), FTAG);
954 dmu_objset_id_quota_upgrade(zfsvfs->z_os);
955 dsl_pool_config_exit(
956 dmu_objset_pool(zfsvfs->z_os), FTAG);
957 }
958 return (B_FALSE);
959 }
960 quotaobj = zfsvfs->z_projectobjquota_obj;
961 } else if (usedobj == DMU_USERUSED_OBJECT) {
962 quotaobj = zfsvfs->z_userobjquota_obj;
963 } else if (usedobj == DMU_GROUPUSED_OBJECT) {
964 quotaobj = zfsvfs->z_groupobjquota_obj;
965 } else {
966 return (B_FALSE);
967 }
968 if (quotaobj == 0 || zfsvfs->z_replay)
969 return (B_FALSE);
970
971 (void) sprintf(buf, "%llx", (longlong_t)id);
972 err = zap_lookup(zfsvfs->z_os, quotaobj, buf, 8, 1, "a);
973 if (err != 0)
974 return (B_FALSE);
975
976 (void) sprintf(buf, DMU_OBJACCT_PREFIX "%llx", (longlong_t)id);
977 err = zap_lookup(zfsvfs->z_os, usedobj, buf, 8, 1, &used);
978 if (err != 0)
979 return (B_FALSE);
980 return (used >= quota);
981 }
982
983 boolean_t
zfs_id_overblockquota(zfsvfs_t * zfsvfs,uint64_t usedobj,uint64_t id)984 zfs_id_overblockquota(zfsvfs_t *zfsvfs, uint64_t usedobj, uint64_t id)
985 {
986 char buf[20];
987 uint64_t used, quota, quotaobj;
988 int err;
989
990 if (usedobj == DMU_PROJECTUSED_OBJECT) {
991 if (!dmu_objset_projectquota_present(zfsvfs->z_os)) {
992 if (dmu_objset_projectquota_upgradable(zfsvfs->z_os)) {
993 dsl_pool_config_enter(
994 dmu_objset_pool(zfsvfs->z_os), FTAG);
995 dmu_objset_id_quota_upgrade(zfsvfs->z_os);
996 dsl_pool_config_exit(
997 dmu_objset_pool(zfsvfs->z_os), FTAG);
998 }
999 return (B_FALSE);
1000 }
1001 quotaobj = zfsvfs->z_projectquota_obj;
1002 } else if (usedobj == DMU_USERUSED_OBJECT) {
1003 quotaobj = zfsvfs->z_userquota_obj;
1004 } else if (usedobj == DMU_GROUPUSED_OBJECT) {
1005 quotaobj = zfsvfs->z_groupquota_obj;
1006 } else {
1007 return (B_FALSE);
1008 }
1009 if (quotaobj == 0 || zfsvfs->z_replay)
1010 return (B_FALSE);
1011
1012 (void) sprintf(buf, "%llx", (longlong_t)id);
1013 err = zap_lookup(zfsvfs->z_os, quotaobj, buf, 8, 1, "a);
1014 if (err != 0)
1015 return (B_FALSE);
1016
1017 err = zap_lookup(zfsvfs->z_os, usedobj, buf, 8, 1, &used);
1018 if (err != 0)
1019 return (B_FALSE);
1020 return (used >= quota);
1021 }
1022
1023 boolean_t
zfs_id_overquota(zfsvfs_t * zfsvfs,uint64_t usedobj,uint64_t id)1024 zfs_id_overquota(zfsvfs_t *zfsvfs, uint64_t usedobj, uint64_t id)
1025 {
1026 return (zfs_id_overblockquota(zfsvfs, usedobj, id) ||
1027 zfs_id_overobjquota(zfsvfs, usedobj, id));
1028 }
1029
1030 /*
1031 * Associate this zfsvfs with the given objset, which must be owned.
1032 * This will cache a bunch of on-disk state from the objset in the
1033 * zfsvfs.
1034 */
1035 static int
zfsvfs_init(zfsvfs_t * zfsvfs,objset_t * os)1036 zfsvfs_init(zfsvfs_t *zfsvfs, objset_t *os)
1037 {
1038 int error;
1039 uint64_t val;
1040
1041 zfsvfs->z_max_blksz = SPA_OLD_MAXBLOCKSIZE;
1042 zfsvfs->z_show_ctldir = ZFS_SNAPDIR_VISIBLE;
1043 zfsvfs->z_os = os;
1044
1045 error = zfs_get_zplprop(os, ZFS_PROP_VERSION, &zfsvfs->z_version);
1046 if (error != 0)
1047 return (error);
1048 if (zfsvfs->z_version >
1049 zfs_zpl_version_map(spa_version(dmu_objset_spa(os)))) {
1050 (void) printf("Can't mount a version %lld file system "
1051 "on a version %lld pool\n. Pool must be upgraded to mount "
1052 "this file system.", (u_longlong_t)zfsvfs->z_version,
1053 (u_longlong_t)spa_version(dmu_objset_spa(os)));
1054 return (SET_ERROR(ENOTSUP));
1055 }
1056 error = zfs_get_zplprop(os, ZFS_PROP_NORMALIZE, &val);
1057 if (error != 0)
1058 return (error);
1059 zfsvfs->z_norm = (int)val;
1060
1061 error = zfs_get_zplprop(os, ZFS_PROP_UTF8ONLY, &val);
1062 if (error != 0)
1063 return (error);
1064 zfsvfs->z_utf8 = (val != 0);
1065
1066 error = zfs_get_zplprop(os, ZFS_PROP_CASE, &val);
1067 if (error != 0)
1068 return (error);
1069 zfsvfs->z_case = (uint_t)val;
1070
1071 /*
1072 * Fold case on file systems that are always or sometimes case
1073 * insensitive.
1074 */
1075 if (zfsvfs->z_case == ZFS_CASE_INSENSITIVE ||
1076 zfsvfs->z_case == ZFS_CASE_MIXED)
1077 zfsvfs->z_norm |= U8_TEXTPREP_TOUPPER;
1078
1079 zfsvfs->z_use_fuids = USE_FUIDS(zfsvfs->z_version, zfsvfs->z_os);
1080 zfsvfs->z_use_sa = USE_SA(zfsvfs->z_version, zfsvfs->z_os);
1081
1082 uint64_t sa_obj = 0;
1083 if (zfsvfs->z_use_sa) {
1084 /* should either have both of these objects or none */
1085 error = zap_lookup(os, MASTER_NODE_OBJ, ZFS_SA_ATTRS, 8, 1,
1086 &sa_obj);
1087 if (error != 0)
1088 return (error);
1089 }
1090
1091 error = sa_setup(os, sa_obj, zfs_attr_table, ZPL_END,
1092 &zfsvfs->z_attr_table);
1093 if (error != 0)
1094 return (error);
1095
1096 if (zfsvfs->z_version >= ZPL_VERSION_SA)
1097 sa_register_update_callback(os, zfs_sa_upgrade);
1098
1099 error = zap_lookup(os, MASTER_NODE_OBJ, ZFS_ROOT_OBJ, 8, 1,
1100 &zfsvfs->z_root);
1101 if (error != 0)
1102 return (error);
1103 ASSERT(zfsvfs->z_root != 0);
1104
1105 error = zap_lookup(os, MASTER_NODE_OBJ, ZFS_UNLINKED_SET, 8, 1,
1106 &zfsvfs->z_unlinkedobj);
1107 if (error != 0)
1108 return (error);
1109
1110 error = zap_lookup(os, MASTER_NODE_OBJ,
1111 zfs_userquota_prop_prefixes[ZFS_PROP_USERQUOTA],
1112 8, 1, &zfsvfs->z_userquota_obj);
1113 if (error == ENOENT)
1114 zfsvfs->z_userquota_obj = 0;
1115 else if (error != 0)
1116 return (error);
1117
1118 error = zap_lookup(os, MASTER_NODE_OBJ,
1119 zfs_userquota_prop_prefixes[ZFS_PROP_GROUPQUOTA],
1120 8, 1, &zfsvfs->z_groupquota_obj);
1121 if (error == ENOENT)
1122 zfsvfs->z_groupquota_obj = 0;
1123 else if (error != 0)
1124 return (error);
1125
1126 error = zap_lookup(os, MASTER_NODE_OBJ,
1127 zfs_userquota_prop_prefixes[ZFS_PROP_PROJECTQUOTA],
1128 8, 1, &zfsvfs->z_projectquota_obj);
1129 if (error == ENOENT)
1130 zfsvfs->z_projectquota_obj = 0;
1131 else if (error != 0)
1132 return (error);
1133
1134 error = zap_lookup(os, MASTER_NODE_OBJ,
1135 zfs_userquota_prop_prefixes[ZFS_PROP_USEROBJQUOTA],
1136 8, 1, &zfsvfs->z_userobjquota_obj);
1137 if (error == ENOENT)
1138 zfsvfs->z_userobjquota_obj = 0;
1139 else if (error != 0)
1140 return (error);
1141
1142 error = zap_lookup(os, MASTER_NODE_OBJ,
1143 zfs_userquota_prop_prefixes[ZFS_PROP_GROUPOBJQUOTA],
1144 8, 1, &zfsvfs->z_groupobjquota_obj);
1145 if (error == ENOENT)
1146 zfsvfs->z_groupobjquota_obj = 0;
1147 else if (error != 0)
1148 return (error);
1149
1150 error = zap_lookup(os, MASTER_NODE_OBJ,
1151 zfs_userquota_prop_prefixes[ZFS_PROP_PROJECTOBJQUOTA],
1152 8, 1, &zfsvfs->z_projectobjquota_obj);
1153 if (error == ENOENT)
1154 zfsvfs->z_projectobjquota_obj = 0;
1155 else if (error != 0)
1156 return (error);
1157
1158 error = zap_lookup(os, MASTER_NODE_OBJ, ZFS_FUID_TABLES, 8, 1,
1159 &zfsvfs->z_fuid_obj);
1160 if (error == ENOENT)
1161 zfsvfs->z_fuid_obj = 0;
1162 else if (error != 0)
1163 return (error);
1164
1165 error = zap_lookup(os, MASTER_NODE_OBJ, ZFS_SHARES_DIR, 8, 1,
1166 &zfsvfs->z_shares_dir);
1167 if (error == ENOENT)
1168 zfsvfs->z_shares_dir = 0;
1169 else if (error != 0)
1170 return (error);
1171
1172 return (0);
1173 }
1174
1175 int
zfsvfs_create(const char * osname,boolean_t readonly,zfsvfs_t ** zfvp)1176 zfsvfs_create(const char *osname, boolean_t readonly, zfsvfs_t **zfvp)
1177 {
1178 objset_t *os;
1179 zfsvfs_t *zfsvfs;
1180 int error;
1181 boolean_t ro = (readonly || (strchr(osname, '@') != NULL));
1182
1183 zfsvfs = kmem_zalloc(sizeof (zfsvfs_t), KM_SLEEP);
1184
1185 error = dmu_objset_own(osname, DMU_OST_ZFS, ro, B_TRUE, zfsvfs, &os);
1186 if (error != 0) {
1187 kmem_free(zfsvfs, sizeof (zfsvfs_t));
1188 return (error);
1189 }
1190
1191 error = zfsvfs_create_impl(zfvp, zfsvfs, os);
1192 if (error != 0) {
1193 dmu_objset_disown(os, B_TRUE, zfsvfs);
1194 }
1195 return (error);
1196 }
1197
1198
1199 int
zfsvfs_create_impl(zfsvfs_t ** zfvp,zfsvfs_t * zfsvfs,objset_t * os)1200 zfsvfs_create_impl(zfsvfs_t **zfvp, zfsvfs_t *zfsvfs, objset_t *os)
1201 {
1202 int error;
1203
1204 zfsvfs->z_vfs = NULL;
1205 zfsvfs->z_parent = zfsvfs;
1206
1207 mutex_init(&zfsvfs->z_znodes_lock, NULL, MUTEX_DEFAULT, NULL);
1208 mutex_init(&zfsvfs->z_lock, NULL, MUTEX_DEFAULT, NULL);
1209 list_create(&zfsvfs->z_all_znodes, sizeof (znode_t),
1210 offsetof(znode_t, z_link_node));
1211 rrm_init(&zfsvfs->z_teardown_lock, B_FALSE);
1212 rw_init(&zfsvfs->z_teardown_inactive_lock, NULL, RW_DEFAULT, NULL);
1213 rw_init(&zfsvfs->z_fuid_lock, NULL, RW_DEFAULT, NULL);
1214 for (int i = 0; i != ZFS_OBJ_MTX_SZ; i++)
1215 mutex_init(&zfsvfs->z_hold_mtx[i], NULL, MUTEX_DEFAULT, NULL);
1216
1217 error = zfsvfs_init(zfsvfs, os);
1218 if (error != 0) {
1219 *zfvp = NULL;
1220 kmem_free(zfsvfs, sizeof (zfsvfs_t));
1221 return (error);
1222 }
1223
1224 zfsvfs->z_drain_task = TASKQID_INVALID;
1225 zfsvfs->z_draining = B_FALSE;
1226 zfsvfs->z_drain_cancel = B_TRUE;
1227
1228 *zfvp = zfsvfs;
1229 return (0);
1230 }
1231
1232 static int
zfsvfs_setup(zfsvfs_t * zfsvfs,boolean_t mounting)1233 zfsvfs_setup(zfsvfs_t *zfsvfs, boolean_t mounting)
1234 {
1235 int error;
1236
1237 error = zfs_register_callbacks(zfsvfs->z_vfs);
1238 if (error)
1239 return (error);
1240
1241 zfsvfs->z_log = zil_open(zfsvfs->z_os, zfs_get_data);
1242
1243 /*
1244 * If we are not mounting (ie: online recv), then we don't
1245 * have to worry about replaying the log as we blocked all
1246 * operations out since we closed the ZIL.
1247 */
1248 if (mounting) {
1249 boolean_t readonly;
1250
1251 /*
1252 * During replay we remove the read only flag to
1253 * allow replays to succeed.
1254 */
1255 readonly = zfsvfs->z_vfs->vfs_flag & VFS_RDONLY;
1256 if (readonly != 0) {
1257 zfsvfs->z_vfs->vfs_flag &= ~VFS_RDONLY;
1258 } else {
1259 zfs_unlinked_drain(zfsvfs);
1260 }
1261
1262 /*
1263 * Parse and replay the intent log.
1264 *
1265 * Because of ziltest, this must be done after
1266 * zfs_unlinked_drain(). (Further note: ziltest
1267 * doesn't use readonly mounts, where
1268 * zfs_unlinked_drain() isn't called.) This is because
1269 * ziltest causes spa_sync() to think it's committed,
1270 * but actually it is not, so the intent log contains
1271 * many txg's worth of changes.
1272 *
1273 * In particular, if object N is in the unlinked set in
1274 * the last txg to actually sync, then it could be
1275 * actually freed in a later txg and then reallocated
1276 * in a yet later txg. This would write a "create
1277 * object N" record to the intent log. Normally, this
1278 * would be fine because the spa_sync() would have
1279 * written out the fact that object N is free, before
1280 * we could write the "create object N" intent log
1281 * record.
1282 *
1283 * But when we are in ziltest mode, we advance the "open
1284 * txg" without actually spa_sync()-ing the changes to
1285 * disk. So we would see that object N is still
1286 * allocated and in the unlinked set, and there is an
1287 * intent log record saying to allocate it.
1288 */
1289 if (spa_writeable(dmu_objset_spa(zfsvfs->z_os))) {
1290 if (zil_replay_disable) {
1291 zil_destroy(zfsvfs->z_log, B_FALSE);
1292 } else {
1293 zfsvfs->z_replay = B_TRUE;
1294 zil_replay(zfsvfs->z_os, zfsvfs,
1295 zfs_replay_vector);
1296 zfsvfs->z_replay = B_FALSE;
1297 }
1298 }
1299
1300 /* restore readonly bit */
1301 if (readonly != 0)
1302 zfsvfs->z_vfs->vfs_flag |= VFS_RDONLY;
1303 }
1304
1305 /*
1306 * Set the objset user_ptr to track its zfsvfs.
1307 */
1308 mutex_enter(&zfsvfs->z_os->os_user_ptr_lock);
1309 dmu_objset_set_user(zfsvfs->z_os, zfsvfs);
1310 mutex_exit(&zfsvfs->z_os->os_user_ptr_lock);
1311
1312 return (0);
1313 }
1314
1315 void
zfsvfs_free(zfsvfs_t * zfsvfs)1316 zfsvfs_free(zfsvfs_t *zfsvfs)
1317 {
1318 int i;
1319 extern krwlock_t zfsvfs_lock; /* in zfs_znode.c */
1320
1321 /*
1322 * This is a barrier to prevent the filesystem from going away in
1323 * zfs_znode_move() until we can safely ensure that the filesystem is
1324 * not unmounted. We consider the filesystem valid before the barrier
1325 * and invalid after the barrier.
1326 */
1327 rw_enter(&zfsvfs_lock, RW_READER);
1328 rw_exit(&zfsvfs_lock);
1329
1330 zfs_fuid_destroy(zfsvfs);
1331
1332 mutex_destroy(&zfsvfs->z_znodes_lock);
1333 mutex_destroy(&zfsvfs->z_lock);
1334 list_destroy(&zfsvfs->z_all_znodes);
1335 rrm_destroy(&zfsvfs->z_teardown_lock);
1336 rw_destroy(&zfsvfs->z_teardown_inactive_lock);
1337 rw_destroy(&zfsvfs->z_fuid_lock);
1338 for (i = 0; i != ZFS_OBJ_MTX_SZ; i++)
1339 mutex_destroy(&zfsvfs->z_hold_mtx[i]);
1340 kmem_free(zfsvfs, sizeof (zfsvfs_t));
1341 }
1342
1343 static void
zfs_set_fuid_feature(zfsvfs_t * zfsvfs)1344 zfs_set_fuid_feature(zfsvfs_t *zfsvfs)
1345 {
1346 zfsvfs->z_use_fuids = USE_FUIDS(zfsvfs->z_version, zfsvfs->z_os);
1347 if (zfsvfs->z_vfs) {
1348 if (zfsvfs->z_use_fuids) {
1349 vfs_set_feature(zfsvfs->z_vfs, VFSFT_XVATTR);
1350 vfs_set_feature(zfsvfs->z_vfs, VFSFT_SYSATTR_VIEWS);
1351 vfs_set_feature(zfsvfs->z_vfs, VFSFT_ACEMASKONACCESS);
1352 vfs_set_feature(zfsvfs->z_vfs, VFSFT_ACLONCREATE);
1353 vfs_set_feature(zfsvfs->z_vfs, VFSFT_ACCESS_FILTER);
1354 vfs_set_feature(zfsvfs->z_vfs, VFSFT_REPARSE);
1355 } else {
1356 vfs_clear_feature(zfsvfs->z_vfs, VFSFT_XVATTR);
1357 vfs_clear_feature(zfsvfs->z_vfs, VFSFT_SYSATTR_VIEWS);
1358 vfs_clear_feature(zfsvfs->z_vfs, VFSFT_ACEMASKONACCESS);
1359 vfs_clear_feature(zfsvfs->z_vfs, VFSFT_ACLONCREATE);
1360 vfs_clear_feature(zfsvfs->z_vfs, VFSFT_ACCESS_FILTER);
1361 vfs_clear_feature(zfsvfs->z_vfs, VFSFT_REPARSE);
1362 }
1363 }
1364 zfsvfs->z_use_sa = USE_SA(zfsvfs->z_version, zfsvfs->z_os);
1365 }
1366
1367 static int
zfs_domount(vfs_t * vfsp,char * osname)1368 zfs_domount(vfs_t *vfsp, char *osname)
1369 {
1370 dev_t mount_dev;
1371 uint64_t recordsize, fsid_guid;
1372 int error = 0;
1373 zfsvfs_t *zfsvfs;
1374 boolean_t readonly = vfsp->vfs_flag & VFS_RDONLY ? B_TRUE : B_FALSE;
1375
1376 ASSERT(vfsp);
1377 ASSERT(osname);
1378
1379 error = zfsvfs_create(osname, readonly, &zfsvfs);
1380 if (error)
1381 return (error);
1382 zfsvfs->z_vfs = vfsp;
1383
1384 /* Initialize the generic filesystem structure. */
1385 vfsp->vfs_bcount = 0;
1386 vfsp->vfs_data = NULL;
1387
1388 if (zfs_create_unique_device(&mount_dev) == -1) {
1389 error = SET_ERROR(ENODEV);
1390 goto out;
1391 }
1392 ASSERT(vfs_devismounted(mount_dev) == 0);
1393
1394 if (error = dsl_prop_get_integer(osname, "recordsize", &recordsize,
1395 NULL))
1396 goto out;
1397
1398 vfsp->vfs_dev = mount_dev;
1399 vfsp->vfs_fstype = zfsfstype;
1400 vfsp->vfs_bsize = recordsize;
1401 vfsp->vfs_flag |= VFS_NOTRUNC;
1402 vfsp->vfs_data = zfsvfs;
1403
1404 /*
1405 * The fsid is 64 bits, composed of an 8-bit fs type, which
1406 * separates our fsid from any other filesystem types, and a
1407 * 56-bit objset unique ID. The objset unique ID is unique to
1408 * all objsets open on this system, provided by unique_create().
1409 * The 8-bit fs type must be put in the low bits of fsid[1]
1410 * because that's where other Solaris filesystems put it.
1411 */
1412 fsid_guid = dmu_objset_fsid_guid(zfsvfs->z_os);
1413 ASSERT((fsid_guid & ~((1ULL<<56)-1)) == 0);
1414 vfsp->vfs_fsid.val[0] = fsid_guid;
1415 vfsp->vfs_fsid.val[1] = ((fsid_guid>>32) << 8) |
1416 zfsfstype & 0xFF;
1417
1418 /*
1419 * Set features for file system.
1420 */
1421 zfs_set_fuid_feature(zfsvfs);
1422 if (zfsvfs->z_case == ZFS_CASE_INSENSITIVE) {
1423 vfs_set_feature(vfsp, VFSFT_DIRENTFLAGS);
1424 vfs_set_feature(vfsp, VFSFT_CASEINSENSITIVE);
1425 vfs_set_feature(vfsp, VFSFT_NOCASESENSITIVE);
1426 } else if (zfsvfs->z_case == ZFS_CASE_MIXED) {
1427 vfs_set_feature(vfsp, VFSFT_DIRENTFLAGS);
1428 vfs_set_feature(vfsp, VFSFT_CASEINSENSITIVE);
1429 }
1430 vfs_set_feature(vfsp, VFSFT_ZEROCOPY_SUPPORTED);
1431
1432 if (dmu_objset_is_snapshot(zfsvfs->z_os)) {
1433 uint64_t pval;
1434
1435 atime_changed_cb(zfsvfs, B_FALSE);
1436 readonly_changed_cb(zfsvfs, B_TRUE);
1437 if (error = dsl_prop_get_integer(osname, "xattr", &pval, NULL))
1438 goto out;
1439 xattr_changed_cb(zfsvfs, pval);
1440 zfsvfs->z_issnap = B_TRUE;
1441 zfsvfs->z_os->os_sync = ZFS_SYNC_DISABLED;
1442
1443 mutex_enter(&zfsvfs->z_os->os_user_ptr_lock);
1444 dmu_objset_set_user(zfsvfs->z_os, zfsvfs);
1445 mutex_exit(&zfsvfs->z_os->os_user_ptr_lock);
1446 } else {
1447 error = zfsvfs_setup(zfsvfs, B_TRUE);
1448 }
1449
1450 /* cache the root vnode for this mount */
1451 znode_t *rootzp;
1452 if (error = zfs_zget(zfsvfs, zfsvfs->z_root, &rootzp)) {
1453 goto out;
1454 }
1455 zfsvfs->z_rootdir = ZTOV(rootzp);
1456
1457 if (!zfsvfs->z_issnap)
1458 zfsctl_create(zfsvfs);
1459 out:
1460 if (error) {
1461 dmu_objset_disown(zfsvfs->z_os, B_TRUE, zfsvfs);
1462 zfsvfs_free(zfsvfs);
1463 } else {
1464 atomic_inc_32(&zfs_active_fs_count);
1465 }
1466
1467 return (error);
1468 }
1469
1470 void
zfs_unregister_callbacks(zfsvfs_t * zfsvfs)1471 zfs_unregister_callbacks(zfsvfs_t *zfsvfs)
1472 {
1473 objset_t *os = zfsvfs->z_os;
1474
1475 if (!dmu_objset_is_snapshot(os))
1476 dsl_prop_unregister_all(dmu_objset_ds(os), zfsvfs);
1477 }
1478
1479 /*
1480 * Convert a decimal digit string to a uint64_t integer.
1481 */
1482 static int
str_to_uint64(char * str,uint64_t * objnum)1483 str_to_uint64(char *str, uint64_t *objnum)
1484 {
1485 uint64_t num = 0;
1486
1487 while (*str) {
1488 if (*str < '0' || *str > '9')
1489 return (SET_ERROR(EINVAL));
1490
1491 num = num*10 + *str++ - '0';
1492 }
1493
1494 *objnum = num;
1495 return (0);
1496 }
1497
1498 /*
1499 * The boot path passed from the boot loader is in the form of
1500 * "rootpool-name/root-filesystem-object-number'. Convert this
1501 * string to a dataset name: "rootpool-name/root-filesystem-name".
1502 */
1503 static int
zfs_parse_bootfs(char * bpath,char * outpath)1504 zfs_parse_bootfs(char *bpath, char *outpath)
1505 {
1506 char *slashp;
1507 uint64_t objnum;
1508 int error;
1509
1510 if (*bpath == 0 || *bpath == '/')
1511 return (SET_ERROR(EINVAL));
1512
1513 (void) strcpy(outpath, bpath);
1514
1515 slashp = strchr(bpath, '/');
1516
1517 /* if no '/', just return the pool name */
1518 if (slashp == NULL) {
1519 return (0);
1520 }
1521
1522 /* if not a number, just return the root dataset name */
1523 if (str_to_uint64(slashp+1, &objnum)) {
1524 return (0);
1525 }
1526
1527 *slashp = '\0';
1528 error = dsl_dsobj_to_dsname(bpath, objnum, outpath);
1529 *slashp = '/';
1530
1531 return (error);
1532 }
1533
1534 /*
1535 * Check that the hex label string is appropriate for the dataset being
1536 * mounted into the global_zone proper.
1537 *
1538 * Return an error if the hex label string is not default or
1539 * admin_low/admin_high. For admin_low labels, the corresponding
1540 * dataset must be readonly.
1541 */
1542 int
zfs_check_global_label(const char * dsname,const char * hexsl)1543 zfs_check_global_label(const char *dsname, const char *hexsl)
1544 {
1545 if (strcasecmp(hexsl, ZFS_MLSLABEL_DEFAULT) == 0)
1546 return (0);
1547 if (strcasecmp(hexsl, ADMIN_HIGH) == 0)
1548 return (0);
1549 if (strcasecmp(hexsl, ADMIN_LOW) == 0) {
1550 /* must be readonly */
1551 uint64_t rdonly;
1552
1553 if (dsl_prop_get_integer(dsname,
1554 zfs_prop_to_name(ZFS_PROP_READONLY), &rdonly, NULL))
1555 return (SET_ERROR(EACCES));
1556 return (rdonly ? 0 : EACCES);
1557 }
1558 return (SET_ERROR(EACCES));
1559 }
1560
1561 static int
zfs_statfs_project(zfsvfs_t * zfsvfs,znode_t * zp,struct statvfs64 * statp,uint32_t bshift)1562 zfs_statfs_project(zfsvfs_t *zfsvfs, znode_t *zp, struct statvfs64 *statp,
1563 uint32_t bshift)
1564 {
1565 char buf[20 + DMU_OBJACCT_PREFIX_LEN];
1566 uint64_t offset = DMU_OBJACCT_PREFIX_LEN;
1567 uint64_t quota;
1568 uint64_t used;
1569 int err;
1570
1571 strlcpy(buf, DMU_OBJACCT_PREFIX, DMU_OBJACCT_PREFIX_LEN + 1);
1572 err = id_to_fuidstr(zfsvfs, NULL, zp->z_projid, buf + offset, B_FALSE);
1573 if (err)
1574 return (err);
1575
1576 if (zfsvfs->z_projectquota_obj == 0)
1577 goto objs;
1578
1579 err = zap_lookup(zfsvfs->z_os, zfsvfs->z_projectquota_obj,
1580 buf + offset, 8, 1, "a);
1581 if (err == ENOENT)
1582 goto objs;
1583 else if (err)
1584 return (err);
1585
1586 err = zap_lookup(zfsvfs->z_os, DMU_PROJECTUSED_OBJECT,
1587 buf + offset, 8, 1, &used);
1588 if (unlikely(err == ENOENT)) {
1589 uint32_t blksize;
1590 u_longlong_t nblocks;
1591
1592 /*
1593 * Quota accounting is async, so it is possible race case.
1594 * There is at least one object with the given project ID.
1595 */
1596 sa_object_size(zp->z_sa_hdl, &blksize, &nblocks);
1597 if (unlikely(zp->z_blksz == 0))
1598 blksize = zfsvfs->z_max_blksz;
1599
1600 used = blksize * nblocks;
1601 } else if (err) {
1602 return (err);
1603 }
1604
1605 statp->f_blocks = quota >> bshift;
1606 statp->f_bfree = (quota > used) ? ((quota - used) >> bshift) : 0;
1607 statp->f_bavail = statp->f_bfree;
1608
1609 objs:
1610 if (zfsvfs->z_projectobjquota_obj == 0)
1611 return (0);
1612
1613 err = zap_lookup(zfsvfs->z_os, zfsvfs->z_projectobjquota_obj,
1614 buf + offset, 8, 1, "a);
1615 if (err == ENOENT)
1616 return (0);
1617 else if (err)
1618 return (err);
1619
1620 err = zap_lookup(zfsvfs->z_os, DMU_PROJECTUSED_OBJECT,
1621 buf, 8, 1, &used);
1622 if (unlikely(err == ENOENT)) {
1623 /*
1624 * Quota accounting is async, so it is possible race case.
1625 * There is at least one object with the given project ID.
1626 */
1627 used = 1;
1628 } else if (err) {
1629 return (err);
1630 }
1631
1632 statp->f_files = quota;
1633 statp->f_ffree = (quota > used) ? (quota - used) : 0;
1634
1635 return (0);
1636 }
1637
1638 /*
1639 * Determine whether the mount is allowed according to MAC check.
1640 * by comparing (where appropriate) label of the dataset against
1641 * the label of the zone being mounted into. If the dataset has
1642 * no label, create one.
1643 *
1644 * Returns 0 if access allowed, error otherwise (e.g. EACCES)
1645 */
1646 static int
zfs_mount_label_policy(vfs_t * vfsp,char * osname)1647 zfs_mount_label_policy(vfs_t *vfsp, char *osname)
1648 {
1649 int error, retv;
1650 zone_t *mntzone = NULL;
1651 ts_label_t *mnt_tsl;
1652 bslabel_t *mnt_sl;
1653 bslabel_t ds_sl;
1654 char ds_hexsl[MAXNAMELEN];
1655
1656 retv = EACCES; /* assume the worst */
1657
1658 /*
1659 * Start by getting the dataset label if it exists.
1660 */
1661 error = dsl_prop_get(osname, zfs_prop_to_name(ZFS_PROP_MLSLABEL),
1662 1, sizeof (ds_hexsl), &ds_hexsl, NULL);
1663 if (error)
1664 return (SET_ERROR(EACCES));
1665
1666 /*
1667 * If labeling is NOT enabled, then disallow the mount of datasets
1668 * which have a non-default label already. No other label checks
1669 * are needed.
1670 */
1671 if (!is_system_labeled()) {
1672 if (strcasecmp(ds_hexsl, ZFS_MLSLABEL_DEFAULT) == 0)
1673 return (0);
1674 return (SET_ERROR(EACCES));
1675 }
1676
1677 /*
1678 * Get the label of the mountpoint. If mounting into the global
1679 * zone (i.e. mountpoint is not within an active zone and the
1680 * zoned property is off), the label must be default or
1681 * admin_low/admin_high only; no other checks are needed.
1682 */
1683 mntzone = zone_find_by_any_path(refstr_value(vfsp->vfs_mntpt), B_FALSE);
1684 if (mntzone->zone_id == GLOBAL_ZONEID) {
1685 uint64_t zoned;
1686
1687 zone_rele(mntzone);
1688
1689 if (dsl_prop_get_integer(osname,
1690 zfs_prop_to_name(ZFS_PROP_ZONED), &zoned, NULL))
1691 return (SET_ERROR(EACCES));
1692 if (!zoned)
1693 return (zfs_check_global_label(osname, ds_hexsl));
1694 else
1695 /*
1696 * This is the case of a zone dataset being mounted
1697 * initially, before the zone has been fully created;
1698 * allow this mount into global zone.
1699 */
1700 return (0);
1701 }
1702
1703 mnt_tsl = mntzone->zone_slabel;
1704 ASSERT(mnt_tsl != NULL);
1705 label_hold(mnt_tsl);
1706 mnt_sl = label2bslabel(mnt_tsl);
1707
1708 if (strcasecmp(ds_hexsl, ZFS_MLSLABEL_DEFAULT) == 0) {
1709 /*
1710 * The dataset doesn't have a real label, so fabricate one.
1711 */
1712 char *str = NULL;
1713
1714 if (l_to_str_internal(mnt_sl, &str) == 0 &&
1715 dsl_prop_set_string(osname,
1716 zfs_prop_to_name(ZFS_PROP_MLSLABEL),
1717 ZPROP_SRC_LOCAL, str) == 0)
1718 retv = 0;
1719 if (str != NULL)
1720 kmem_free(str, strlen(str) + 1);
1721 } else if (hexstr_to_label(ds_hexsl, &ds_sl) == 0) {
1722 /*
1723 * Now compare labels to complete the MAC check. If the
1724 * labels are equal then allow access. If the mountpoint
1725 * label dominates the dataset label, allow readonly access.
1726 * Otherwise, access is denied.
1727 */
1728 if (blequal(mnt_sl, &ds_sl))
1729 retv = 0;
1730 else if (bldominates(mnt_sl, &ds_sl)) {
1731 vfs_setmntopt(vfsp, MNTOPT_RO, NULL, 0);
1732 retv = 0;
1733 }
1734 }
1735
1736 label_rele(mnt_tsl);
1737 zone_rele(mntzone);
1738 return (retv);
1739 }
1740
1741 /*
1742 * Load a string-valued boot property and attempt to convert it to a 64-bit
1743 * unsigned integer. If the value is not present, or the conversion fails,
1744 * return the provided default value.
1745 */
1746 static uint64_t
spa_get_bootprop_uint64(const char * name,uint64_t defval)1747 spa_get_bootprop_uint64(const char *name, uint64_t defval)
1748 {
1749 char *propval;
1750 u_longlong_t r;
1751 int e;
1752
1753 if ((propval = spa_get_bootprop(name)) == NULL) {
1754 /*
1755 * The property does not exist.
1756 */
1757 return (defval);
1758 }
1759
1760 e = ddi_strtoull(propval, NULL, 10, &r);
1761
1762 spa_free_bootprop(propval);
1763
1764 /*
1765 * If the conversion succeeded, return the value. If there was any
1766 * kind of failure, just return the default value.
1767 */
1768 return (e == 0 ? r : defval);
1769 }
1770
1771 static int
zfs_mountroot(vfs_t * vfsp,enum whymountroot why)1772 zfs_mountroot(vfs_t *vfsp, enum whymountroot why)
1773 {
1774 int error = 0;
1775 static int zfsrootdone = 0;
1776 zfsvfs_t *zfsvfs = NULL;
1777 znode_t *zp = NULL;
1778 vnode_t *vp = NULL;
1779 char *zfs_bootfs;
1780 char *zfs_devid;
1781 char *zfs_rootdisk_path;
1782 uint64_t zfs_bootpool;
1783 uint64_t zfs_bootvdev;
1784
1785 ASSERT(vfsp);
1786
1787 /*
1788 * The filesystem that we mount as root is defined in the
1789 * boot property "zfs-bootfs" with a format of
1790 * "poolname/root-dataset-objnum".
1791 */
1792 if (why == ROOT_INIT) {
1793 if (zfsrootdone++)
1794 return (SET_ERROR(EBUSY));
1795
1796 /*
1797 * the process of doing a spa_load will require the
1798 * clock to be set before we could (for example) do
1799 * something better by looking at the timestamp on
1800 * an uberblock, so just set it to -1.
1801 */
1802 clkset(-1);
1803
1804 if ((zfs_bootfs = spa_get_bootprop("zfs-bootfs")) == NULL) {
1805 cmn_err(CE_NOTE, "spa_get_bootfs: can not get "
1806 "bootfs name");
1807 return (SET_ERROR(EINVAL));
1808 }
1809 zfs_devid = spa_get_bootprop("diskdevid");
1810
1811 /*
1812 * The boot loader may also provide us with the GUID for both
1813 * the pool and the nominated boot vdev. A GUID value of 0 is
1814 * explicitly invalid (see "spa_change_guid()"), so we use this
1815 * as a sentinel value when no GUID is present.
1816 */
1817 zfs_bootpool = spa_get_bootprop_uint64("zfs-bootpool", 0);
1818 zfs_bootvdev = spa_get_bootprop_uint64("zfs-bootvdev", 0);
1819
1820 /*
1821 * If we have been given a root disk override path, we want to
1822 * ignore device paths from the pool configuration and use only
1823 * the specific path we were given in the boot properties.
1824 */
1825 zfs_rootdisk_path = spa_get_bootprop("zfs-rootdisk-path");
1826
1827 /*
1828 * Initialise the early boot device rescan mechanism. A scan
1829 * will not actually be performed unless we need to do so in
1830 * order to find the correct /devices path for a relocated
1831 * device.
1832 */
1833 vdev_disk_preroot_init(zfs_rootdisk_path);
1834
1835 error = spa_import_rootpool(rootfs.bo_name, zfs_devid,
1836 zfs_bootpool, zfs_bootvdev);
1837
1838 spa_free_bootprop(zfs_devid);
1839
1840 if (error != 0) {
1841 spa_free_bootprop(zfs_bootfs);
1842 spa_free_bootprop(zfs_rootdisk_path);
1843 vdev_disk_preroot_fini();
1844 cmn_err(CE_NOTE, "spa_import_rootpool: error %d",
1845 error);
1846 return (error);
1847 }
1848
1849 if (error = zfs_parse_bootfs(zfs_bootfs, rootfs.bo_name)) {
1850 spa_free_bootprop(zfs_bootfs);
1851 spa_free_bootprop(zfs_rootdisk_path);
1852 vdev_disk_preroot_fini();
1853 cmn_err(CE_NOTE, "zfs_parse_bootfs: error %d",
1854 error);
1855 return (error);
1856 }
1857
1858 spa_free_bootprop(zfs_bootfs);
1859 spa_free_bootprop(zfs_rootdisk_path);
1860
1861 if ((error = vfs_lock(vfsp)) != 0) {
1862 vdev_disk_preroot_fini();
1863 return (error);
1864 }
1865
1866 if (error = zfs_domount(vfsp, rootfs.bo_name)) {
1867 cmn_err(CE_NOTE, "zfs_domount: error %d", error);
1868 goto out;
1869 }
1870
1871 /* zfs_domount has already cached the root vnode for us */
1872 zfsvfs = (zfsvfs_t *)vfsp->vfs_data;
1873 ASSERT(zfsvfs);
1874 ASSERT(zfsvfs->z_rootdir);
1875
1876 vp = zfsvfs->z_rootdir;
1877 mutex_enter(&vp->v_lock);
1878 vp->v_flag |= VROOT;
1879 mutex_exit(&vp->v_lock);
1880
1881 /*
1882 * Leave rootvp held. The root file system is never unmounted.
1883 */
1884 VN_HOLD(vp);
1885 rootvp = vp;
1886
1887 vfs_add((struct vnode *)0, vfsp,
1888 (vfsp->vfs_flag & VFS_RDONLY) ? MS_RDONLY : 0);
1889 out:
1890 vdev_disk_preroot_fini();
1891 vfs_unlock(vfsp);
1892 return (error);
1893 } else if (why == ROOT_REMOUNT) {
1894 readonly_changed_cb(vfsp->vfs_data, B_FALSE);
1895 vfsp->vfs_flag |= VFS_REMOUNT;
1896
1897 /* refresh mount options */
1898 zfs_unregister_callbacks(vfsp->vfs_data);
1899 return (zfs_register_callbacks(vfsp));
1900
1901 } else if (why == ROOT_UNMOUNT) {
1902 zfs_unregister_callbacks((zfsvfs_t *)vfsp->vfs_data);
1903 (void) zfs_sync(vfsp, 0, 0);
1904 return (0);
1905 }
1906
1907 /*
1908 * if "why" is equal to anything else other than ROOT_INIT,
1909 * ROOT_REMOUNT, or ROOT_UNMOUNT, we do not support it.
1910 */
1911 return (SET_ERROR(ENOTSUP));
1912 }
1913
1914 /*ARGSUSED*/
1915 static int
zfs_mount(vfs_t * vfsp,vnode_t * mvp,struct mounta * uap,cred_t * cr)1916 zfs_mount(vfs_t *vfsp, vnode_t *mvp, struct mounta *uap, cred_t *cr)
1917 {
1918 char *osname;
1919 pathname_t spn;
1920 int error = 0;
1921 uio_seg_t fromspace = (uap->flags & MS_SYSSPACE) ?
1922 UIO_SYSSPACE : UIO_USERSPACE;
1923 int canwrite;
1924
1925 if (mvp->v_type != VDIR)
1926 return (SET_ERROR(ENOTDIR));
1927
1928 mutex_enter(&mvp->v_lock);
1929 if ((uap->flags & MS_REMOUNT) == 0 &&
1930 (uap->flags & MS_OVERLAY) == 0 &&
1931 (mvp->v_count != 1 || (mvp->v_flag & VROOT))) {
1932 mutex_exit(&mvp->v_lock);
1933 return (SET_ERROR(EBUSY));
1934 }
1935 mutex_exit(&mvp->v_lock);
1936
1937 /*
1938 * ZFS does not support passing unparsed data in via MS_DATA.
1939 * Users should use the MS_OPTIONSTR interface; this means
1940 * that all option parsing is already done and the options struct
1941 * can be interrogated.
1942 */
1943 if ((uap->flags & MS_DATA) && uap->datalen > 0)
1944 return (SET_ERROR(EINVAL));
1945
1946 /*
1947 * Get the objset name (the "special" mount argument).
1948 */
1949 if (error = pn_get(uap->spec, fromspace, &spn))
1950 return (error);
1951
1952 osname = spn.pn_path;
1953
1954 /*
1955 * Check for mount privilege?
1956 *
1957 * If we don't have privilege then see if
1958 * we have local permission to allow it
1959 */
1960 error = secpolicy_fs_mount(cr, mvp, vfsp);
1961 if (error) {
1962 if (dsl_deleg_access(osname, ZFS_DELEG_PERM_MOUNT, cr) == 0) {
1963 vattr_t vattr;
1964
1965 /*
1966 * Make sure user is the owner of the mount point
1967 * or has sufficient privileges.
1968 */
1969
1970 vattr.va_mask = AT_UID;
1971
1972 if (VOP_GETATTR(mvp, &vattr, 0, cr, NULL)) {
1973 goto out;
1974 }
1975
1976 if (secpolicy_vnode_owner(cr, vattr.va_uid) != 0 &&
1977 VOP_ACCESS(mvp, VWRITE, 0, cr, NULL) != 0) {
1978 goto out;
1979 }
1980 secpolicy_fs_mount_clearopts(cr, vfsp);
1981 } else {
1982 goto out;
1983 }
1984 }
1985
1986 /*
1987 * Refuse to mount a filesystem if we are in a local zone and the
1988 * dataset is not visible.
1989 */
1990 if (!INGLOBALZONE(curproc) &&
1991 (!zone_dataset_visible(osname, &canwrite) || !canwrite)) {
1992 error = SET_ERROR(EPERM);
1993 goto out;
1994 }
1995
1996 error = zfs_mount_label_policy(vfsp, osname);
1997 if (error)
1998 goto out;
1999
2000 /*
2001 * When doing a remount, we simply refresh our temporary properties
2002 * according to those options set in the current VFS options.
2003 */
2004 if (uap->flags & MS_REMOUNT) {
2005 /* refresh mount options */
2006 zfs_unregister_callbacks(vfsp->vfs_data);
2007 error = zfs_register_callbacks(vfsp);
2008 goto out;
2009 }
2010
2011 error = zfs_domount(vfsp, osname);
2012
2013 /*
2014 * Add an extra VFS_HOLD on our parent vfs so that it can't
2015 * disappear due to a forced unmount.
2016 */
2017 if (error == 0 && ((zfsvfs_t *)vfsp->vfs_data)->z_issnap)
2018 VFS_HOLD(mvp->v_vfsp);
2019
2020 out:
2021 pn_free(&spn);
2022 return (error);
2023 }
2024
2025 static int
zfs_statvfs(vfs_t * vfsp,struct statvfs64 * statp)2026 zfs_statvfs(vfs_t *vfsp, struct statvfs64 *statp)
2027 {
2028 zfsvfs_t *zfsvfs = vfsp->vfs_data;
2029 dev32_t d32;
2030 uint64_t refdbytes, availbytes, usedobjs, availobjs;
2031 int err = 0;
2032
2033 ZFS_ENTER(zfsvfs);
2034
2035 dmu_objset_space(zfsvfs->z_os,
2036 &refdbytes, &availbytes, &usedobjs, &availobjs);
2037
2038 /*
2039 * The underlying storage pool actually uses multiple block sizes.
2040 * We report the fragsize as the smallest block size we support,
2041 * and we report our blocksize as the filesystem's maximum blocksize.
2042 */
2043 statp->f_frsize = 1UL << SPA_MINBLOCKSHIFT;
2044 statp->f_bsize = zfsvfs->z_max_blksz;
2045
2046 /*
2047 * The following report "total" blocks of various kinds in the
2048 * file system, but reported in terms of f_frsize - the
2049 * "fragment" size.
2050 */
2051
2052 statp->f_blocks = (refdbytes + availbytes) >> SPA_MINBLOCKSHIFT;
2053 statp->f_bfree = availbytes >> SPA_MINBLOCKSHIFT;
2054 statp->f_bavail = statp->f_bfree; /* no root reservation */
2055
2056 /*
2057 * statvfs() should really be called statufs(), because it assumes
2058 * static metadata. ZFS doesn't preallocate files, so the best
2059 * we can do is report the max that could possibly fit in f_files,
2060 * and that minus the number actually used in f_ffree.
2061 * For f_ffree, report the smaller of the number of object available
2062 * and the number of blocks (each object will take at least a block).
2063 */
2064 statp->f_ffree = MIN(availobjs, statp->f_bfree);
2065 statp->f_favail = statp->f_ffree; /* no "root reservation" */
2066 statp->f_files = statp->f_ffree + usedobjs;
2067
2068 (void) cmpldev(&d32, vfsp->vfs_dev);
2069 statp->f_fsid = d32;
2070
2071 /*
2072 * We're a zfs filesystem.
2073 */
2074 (void) strcpy(statp->f_basetype, vfssw[vfsp->vfs_fstype].vsw_name);
2075
2076 statp->f_flag = vf_to_stf(vfsp->vfs_flag);
2077
2078 statp->f_namemax = MAXNAMELEN - 1;
2079
2080 /*
2081 * We have all of 32 characters to stuff a string here.
2082 * Is there anything useful we could/should provide?
2083 */
2084 bzero(statp->f_fstr, sizeof (statp->f_fstr));
2085
2086 if (dmu_objset_projectquota_enabled(zfsvfs->z_os) &&
2087 dmu_objset_projectquota_present(zfsvfs->z_os)) {
2088 znode_t *zp;
2089
2090 /*
2091 * In ZoL, zfs_statvfs is passed a Linux dentry (directory
2092 * entry), instead of a vfsp. The ZoL code uses the dentry
2093 * to get the znode from the dentry's inode. This represents
2094 * whatever filename was passed to the user-level statvfs
2095 * syscall.
2096 *
2097 * We're using the VFS root znode here, so this represents a
2098 * potential difference from ZoL.
2099 */
2100 if (zfs_zget(zfsvfs, zfsvfs->z_root, &zp) == 0) {
2101 uint32_t bshift = ddi_fls(statp->f_bsize) - 1;
2102
2103 if (zp->z_pflags & ZFS_PROJINHERIT && zp->z_projid &&
2104 zpl_is_valid_projid(zp->z_projid))
2105 err = zfs_statfs_project(zfsvfs, zp, statp,
2106 bshift);
2107 VN_RELE(ZTOV(zp));
2108 }
2109 }
2110
2111 ZFS_EXIT(zfsvfs);
2112 return (err);
2113 }
2114
2115 static int
zfs_root(vfs_t * vfsp,vnode_t ** vpp)2116 zfs_root(vfs_t *vfsp, vnode_t **vpp)
2117 {
2118 zfsvfs_t *zfsvfs = vfsp->vfs_data;
2119 struct vnode *vp;
2120 int error;
2121
2122 ZFS_ENTER(zfsvfs);
2123
2124 vp = zfsvfs->z_rootdir;
2125 if (vp != NULL) {
2126 VN_HOLD(vp);
2127 error = 0;
2128 } else {
2129 /* forced unmount */
2130 error = EIO;
2131 }
2132 *vpp = vp;
2133
2134 ZFS_EXIT(zfsvfs);
2135 return (error);
2136
2137 }
2138
2139 /*
2140 * Teardown the zfsvfs::z_os.
2141 *
2142 * Note, if 'unmounting' is FALSE, we return with the 'z_teardown_lock'
2143 * and 'z_teardown_inactive_lock' held.
2144 */
2145 static int
zfsvfs_teardown(zfsvfs_t * zfsvfs,boolean_t unmounting)2146 zfsvfs_teardown(zfsvfs_t *zfsvfs, boolean_t unmounting)
2147 {
2148 znode_t *zp;
2149
2150 zfs_unlinked_drain_stop_wait(zfsvfs);
2151
2152 rrm_enter(&zfsvfs->z_teardown_lock, RW_WRITER, FTAG);
2153
2154 if (!unmounting) {
2155 /*
2156 * We purge the parent filesystem's vfsp as the parent
2157 * filesystem and all of its snapshots have their vnode's
2158 * v_vfsp set to the parent's filesystem's vfsp. Note,
2159 * 'z_parent' is self referential for non-snapshots.
2160 */
2161 (void) dnlc_purge_vfsp(zfsvfs->z_parent->z_vfs, 0);
2162 }
2163
2164 /*
2165 * Close the zil. NB: Can't close the zil while zfs_inactive
2166 * threads are blocked as zil_close can call zfs_inactive.
2167 */
2168 if (zfsvfs->z_log) {
2169 zil_close(zfsvfs->z_log);
2170 zfsvfs->z_log = NULL;
2171 }
2172
2173 rw_enter(&zfsvfs->z_teardown_inactive_lock, RW_WRITER);
2174
2175 /*
2176 * If we are not unmounting (ie: online recv) and someone already
2177 * unmounted this file system while we were doing the switcheroo,
2178 * or a reopen of z_os failed then just bail out now.
2179 */
2180 if (!unmounting && (zfsvfs->z_unmounted || zfsvfs->z_os == NULL)) {
2181 rw_exit(&zfsvfs->z_teardown_inactive_lock);
2182 rrm_exit(&zfsvfs->z_teardown_lock, FTAG);
2183 return (SET_ERROR(EIO));
2184 }
2185
2186 /*
2187 * At this point there are no vops active, and any new vops will
2188 * fail with EIO since we have z_teardown_lock for writer (only
2189 * relavent for forced unmount).
2190 *
2191 * Release all holds on dbufs.
2192 */
2193 mutex_enter(&zfsvfs->z_znodes_lock);
2194 for (zp = list_head(&zfsvfs->z_all_znodes); zp != NULL;
2195 zp = list_next(&zfsvfs->z_all_znodes, zp))
2196 if (zp->z_sa_hdl) {
2197 ASSERT(ZTOV(zp)->v_count > 0);
2198 zfs_znode_dmu_fini(zp);
2199 }
2200 mutex_exit(&zfsvfs->z_znodes_lock);
2201
2202 /*
2203 * If we are unmounting, set the unmounted flag and let new vops
2204 * unblock. zfs_inactive will have the unmounted behavior, and all
2205 * other vops will fail with EIO.
2206 */
2207 if (unmounting) {
2208 /*
2209 * Clear the cached root vnode now that we are unmounted.
2210 * Its release must be performed outside the teardown locks to
2211 * avoid recursive lock entry via zfs_inactive().
2212 */
2213 vnode_t *vp = zfsvfs->z_rootdir;
2214 zfsvfs->z_rootdir = NULL;
2215
2216 zfsvfs->z_unmounted = B_TRUE;
2217 rw_exit(&zfsvfs->z_teardown_inactive_lock);
2218 rrm_exit(&zfsvfs->z_teardown_lock, FTAG);
2219
2220 /* Drop the cached root vp now that it is safe */
2221 VN_RELE(vp);
2222 }
2223
2224 /*
2225 * z_os will be NULL if there was an error in attempting to reopen
2226 * zfsvfs, so just return as the properties had already been
2227 * unregistered and cached data had been evicted before.
2228 */
2229 if (zfsvfs->z_os == NULL)
2230 return (0);
2231
2232 /*
2233 * Unregister properties.
2234 */
2235 zfs_unregister_callbacks(zfsvfs);
2236
2237 /*
2238 * Evict cached data
2239 */
2240 if (dsl_dataset_is_dirty(dmu_objset_ds(zfsvfs->z_os)) &&
2241 !(zfsvfs->z_vfs->vfs_flag & VFS_RDONLY))
2242 txg_wait_synced(dmu_objset_pool(zfsvfs->z_os), 0);
2243 dmu_objset_evict_dbufs(zfsvfs->z_os);
2244
2245 return (0);
2246 }
2247
2248 /*ARGSUSED*/
2249 static int
zfs_umount(vfs_t * vfsp,int fflag,cred_t * cr)2250 zfs_umount(vfs_t *vfsp, int fflag, cred_t *cr)
2251 {
2252 zfsvfs_t *zfsvfs = vfsp->vfs_data;
2253 objset_t *os;
2254 int ret;
2255
2256 ret = secpolicy_fs_unmount(cr, vfsp);
2257 if (ret) {
2258 if (dsl_deleg_access((char *)refstr_value(vfsp->vfs_resource),
2259 ZFS_DELEG_PERM_MOUNT, cr))
2260 return (ret);
2261 }
2262
2263 /*
2264 * We purge the parent filesystem's vfsp as the parent filesystem
2265 * and all of its snapshots have their vnode's v_vfsp set to the
2266 * parent's filesystem's vfsp. Note, 'z_parent' is self
2267 * referential for non-snapshots.
2268 */
2269 (void) dnlc_purge_vfsp(zfsvfs->z_parent->z_vfs, 0);
2270
2271 /*
2272 * Unmount any snapshots mounted under .zfs before unmounting the
2273 * dataset itself.
2274 */
2275 if (zfsvfs->z_ctldir != NULL &&
2276 (ret = zfsctl_umount_snapshots(vfsp, fflag, cr)) != 0) {
2277 return (ret);
2278 }
2279
2280 if (!(fflag & MS_FORCE)) {
2281 /*
2282 * Check the number of active vnodes in the file system.
2283 * Our count is maintained in the vfs structure, but the
2284 * number is off by 1 to indicate a hold on the vfs
2285 * structure itself.
2286 */
2287 boolean_t draining;
2288 uint_t thresh = 1;
2289 vnode_t *ctlvp, *rvp;
2290
2291 /*
2292 * The cached vnode for the root directory of the mount also
2293 * maintains a hold on the vfs structure.
2294 */
2295 rvp = zfsvfs->z_rootdir;
2296 thresh++;
2297
2298 /*
2299 * The '.zfs' directory maintains a reference of its own, and
2300 * any active references underneath are reflected in the vnode
2301 * count. Allow one additional reference for it.
2302 */
2303 ctlvp = zfsvfs->z_ctldir;
2304 if (ctlvp != NULL) {
2305 thresh++;
2306 }
2307
2308 /*
2309 * If it's running, the asynchronous unlinked drain task needs
2310 * to be stopped before the number of active vnodes can be
2311 * reliably checked.
2312 */
2313 draining = zfsvfs->z_draining;
2314 if (draining)
2315 zfs_unlinked_drain_stop_wait(zfsvfs);
2316
2317 if (vfsp->vfs_count > thresh || rvp->v_count > 1 ||
2318 (ctlvp != NULL && ctlvp->v_count > 1)) {
2319 if (draining) {
2320 /* If it was draining, restart the task */
2321 zfs_unlinked_drain(zfsvfs);
2322 }
2323 return (SET_ERROR(EBUSY));
2324 }
2325 }
2326
2327 vfsp->vfs_flag |= VFS_UNMOUNTED;
2328
2329 VERIFY(zfsvfs_teardown(zfsvfs, B_TRUE) == 0);
2330 os = zfsvfs->z_os;
2331
2332 /*
2333 * z_os will be NULL if there was an error in
2334 * attempting to reopen zfsvfs.
2335 */
2336 if (os != NULL) {
2337 /*
2338 * Unset the objset user_ptr.
2339 */
2340 mutex_enter(&os->os_user_ptr_lock);
2341 dmu_objset_set_user(os, NULL);
2342 mutex_exit(&os->os_user_ptr_lock);
2343
2344 /*
2345 * Finally release the objset
2346 */
2347 dmu_objset_disown(os, B_TRUE, zfsvfs);
2348 }
2349
2350 /*
2351 * We can now safely destroy the '.zfs' directory node.
2352 */
2353 if (zfsvfs->z_ctldir != NULL)
2354 zfsctl_destroy(zfsvfs);
2355
2356 return (0);
2357 }
2358
2359 static int
zfs_vget(vfs_t * vfsp,vnode_t ** vpp,fid_t * fidp)2360 zfs_vget(vfs_t *vfsp, vnode_t **vpp, fid_t *fidp)
2361 {
2362 zfsvfs_t *zfsvfs = vfsp->vfs_data;
2363 znode_t *zp;
2364 uint64_t object = 0;
2365 uint64_t fid_gen = 0;
2366 uint64_t gen_mask;
2367 uint64_t zp_gen;
2368 int i, err;
2369
2370 *vpp = NULL;
2371
2372 ZFS_ENTER(zfsvfs);
2373
2374 if (fidp->fid_len == LONG_FID_LEN) {
2375 zfid_long_t *zlfid = (zfid_long_t *)fidp;
2376 uint64_t objsetid = 0;
2377 uint64_t setgen = 0;
2378
2379 for (i = 0; i < sizeof (zlfid->zf_setid); i++)
2380 objsetid |= ((uint64_t)zlfid->zf_setid[i]) << (8 * i);
2381
2382 for (i = 0; i < sizeof (zlfid->zf_setgen); i++)
2383 setgen |= ((uint64_t)zlfid->zf_setgen[i]) << (8 * i);
2384
2385 ZFS_EXIT(zfsvfs);
2386
2387 err = zfsctl_lookup_objset(vfsp, objsetid, &zfsvfs);
2388 if (err)
2389 return (SET_ERROR(EINVAL));
2390 ZFS_ENTER(zfsvfs);
2391 }
2392
2393 if (fidp->fid_len == SHORT_FID_LEN || fidp->fid_len == LONG_FID_LEN) {
2394 zfid_short_t *zfid = (zfid_short_t *)fidp;
2395
2396 for (i = 0; i < sizeof (zfid->zf_object); i++)
2397 object |= ((uint64_t)zfid->zf_object[i]) << (8 * i);
2398
2399 for (i = 0; i < sizeof (zfid->zf_gen); i++)
2400 fid_gen |= ((uint64_t)zfid->zf_gen[i]) << (8 * i);
2401 } else {
2402 ZFS_EXIT(zfsvfs);
2403 return (SET_ERROR(EINVAL));
2404 }
2405
2406 /* A zero fid_gen means we are in the .zfs control directories */
2407 if (fid_gen == 0 &&
2408 (object == ZFSCTL_INO_ROOT || object == ZFSCTL_INO_SNAPDIR)) {
2409 *vpp = zfsvfs->z_ctldir;
2410 ASSERT(*vpp != NULL);
2411 if (object == ZFSCTL_INO_SNAPDIR) {
2412 VERIFY(zfsctl_root_lookup(*vpp, "snapshot", vpp, NULL,
2413 0, NULL, NULL, NULL, NULL, NULL) == 0);
2414 } else {
2415 VN_HOLD(*vpp);
2416 }
2417 ZFS_EXIT(zfsvfs);
2418 return (0);
2419 }
2420
2421 gen_mask = -1ULL >> (64 - 8 * i);
2422
2423 dprintf("getting %llu [%u mask %llx]\n", object, fid_gen, gen_mask);
2424 if (err = zfs_zget(zfsvfs, object, &zp)) {
2425 ZFS_EXIT(zfsvfs);
2426 return (err);
2427 }
2428 (void) sa_lookup(zp->z_sa_hdl, SA_ZPL_GEN(zfsvfs), &zp_gen,
2429 sizeof (uint64_t));
2430 zp_gen = zp_gen & gen_mask;
2431 if (zp_gen == 0)
2432 zp_gen = 1;
2433 if (zp->z_unlinked || zp_gen != fid_gen) {
2434 dprintf("znode gen (%u) != fid gen (%u)\n", zp_gen, fid_gen);
2435 VN_RELE(ZTOV(zp));
2436 ZFS_EXIT(zfsvfs);
2437 return (SET_ERROR(EINVAL));
2438 }
2439
2440 *vpp = ZTOV(zp);
2441 ZFS_EXIT(zfsvfs);
2442 return (0);
2443 }
2444
2445 /*
2446 * Block out VOPs and close zfsvfs_t::z_os
2447 *
2448 * Note, if successful, then we return with the 'z_teardown_lock' and
2449 * 'z_teardown_inactive_lock' write held. We leave ownership of the underlying
2450 * dataset and objset intact so that they can be atomically handed off during
2451 * a subsequent rollback or recv operation and the resume thereafter.
2452 */
2453 int
zfs_suspend_fs(zfsvfs_t * zfsvfs)2454 zfs_suspend_fs(zfsvfs_t *zfsvfs)
2455 {
2456 int error;
2457
2458 if ((error = zfsvfs_teardown(zfsvfs, B_FALSE)) != 0)
2459 return (error);
2460
2461 return (0);
2462 }
2463
2464 /*
2465 * Rebuild SA and release VOPs. Note that ownership of the underlying dataset
2466 * is an invariant across any of the operations that can be performed while the
2467 * filesystem was suspended. Whether it succeeded or failed, the preconditions
2468 * are the same: the relevant objset and associated dataset are owned by
2469 * zfsvfs, held, and long held on entry.
2470 */
2471 int
zfs_resume_fs(zfsvfs_t * zfsvfs,dsl_dataset_t * ds)2472 zfs_resume_fs(zfsvfs_t *zfsvfs, dsl_dataset_t *ds)
2473 {
2474 int err;
2475 znode_t *zp;
2476
2477 ASSERT(RRM_WRITE_HELD(&zfsvfs->z_teardown_lock));
2478 ASSERT(RW_WRITE_HELD(&zfsvfs->z_teardown_inactive_lock));
2479
2480 /*
2481 * We already own this, so just update the objset_t, as the one we
2482 * had before may have been evicted.
2483 */
2484 objset_t *os;
2485 VERIFY3P(ds->ds_owner, ==, zfsvfs);
2486 VERIFY(dsl_dataset_long_held(ds));
2487 VERIFY0(dmu_objset_from_ds(ds, &os));
2488
2489 err = zfsvfs_init(zfsvfs, os);
2490 if (err != 0)
2491 goto bail;
2492
2493 VERIFY(zfsvfs_setup(zfsvfs, B_FALSE) == 0);
2494
2495 zfs_set_fuid_feature(zfsvfs);
2496
2497 /*
2498 * Attempt to re-establish all the active znodes with
2499 * their dbufs. If a zfs_rezget() fails, then we'll let
2500 * any potential callers discover that via ZFS_ENTER_VERIFY_VP
2501 * when they try to use their znode.
2502 */
2503 mutex_enter(&zfsvfs->z_znodes_lock);
2504 for (zp = list_head(&zfsvfs->z_all_znodes); zp;
2505 zp = list_next(&zfsvfs->z_all_znodes, zp)) {
2506 (void) zfs_rezget(zp);
2507 }
2508 mutex_exit(&zfsvfs->z_znodes_lock);
2509
2510 if (((zfsvfs->z_vfs->vfs_flag & VFS_RDONLY) == 0) &&
2511 !zfsvfs->z_unmounted) {
2512 /*
2513 * zfs_suspend_fs() could have interrupted freeing
2514 * of dnodes. We need to restart this freeing so
2515 * that we don't "leak" the space.
2516 */
2517 zfs_unlinked_drain(zfsvfs);
2518 }
2519
2520 bail:
2521 /* release the VOPs */
2522 rw_exit(&zfsvfs->z_teardown_inactive_lock);
2523 rrm_exit(&zfsvfs->z_teardown_lock, FTAG);
2524
2525 if (err) {
2526 /*
2527 * Since we couldn't setup the sa framework, try to force
2528 * unmount this file system.
2529 */
2530 if (vn_vfswlock(zfsvfs->z_vfs->vfs_vnodecovered) == 0)
2531 (void) dounmount(zfsvfs->z_vfs, MS_FORCE, CRED());
2532 }
2533 return (err);
2534 }
2535
2536 static void
zfs_freevfs(vfs_t * vfsp)2537 zfs_freevfs(vfs_t *vfsp)
2538 {
2539 zfsvfs_t *zfsvfs = vfsp->vfs_data;
2540
2541 /*
2542 * If this is a snapshot, we have an extra VFS_HOLD on our parent
2543 * from zfs_mount(). Release it here. If we came through
2544 * zfs_mountroot() instead, we didn't grab an extra hold, so
2545 * skip the VFS_RELE for rootvfs.
2546 */
2547 if (zfsvfs->z_issnap && (vfsp != rootvfs))
2548 VFS_RELE(zfsvfs->z_parent->z_vfs);
2549
2550 zfsvfs_free(zfsvfs);
2551
2552 atomic_dec_32(&zfs_active_fs_count);
2553 }
2554
2555 /*
2556 * VFS_INIT() initialization. Note that there is no VFS_FINI(),
2557 * so we can't safely do any non-idempotent initialization here.
2558 * Leave that to zfs_init() and zfs_fini(), which are called
2559 * from the module's _init() and _fini() entry points.
2560 */
2561 /*ARGSUSED*/
2562 static int
zfs_vfsinit(int fstype,char * name)2563 zfs_vfsinit(int fstype, char *name)
2564 {
2565 int error;
2566
2567 zfsfstype = fstype;
2568
2569 /*
2570 * Setup vfsops and vnodeops tables.
2571 */
2572 error = vfs_setfsops(fstype, zfs_vfsops_template, &zfs_vfsops);
2573 if (error != 0) {
2574 cmn_err(CE_WARN, "zfs: bad vfs ops template");
2575 }
2576
2577 error = zfs_create_op_tables();
2578 if (error) {
2579 zfs_remove_op_tables();
2580 cmn_err(CE_WARN, "zfs: bad vnode ops template");
2581 (void) vfs_freevfsops_by_type(zfsfstype);
2582 return (error);
2583 }
2584
2585 mutex_init(&zfs_dev_mtx, NULL, MUTEX_DEFAULT, NULL);
2586
2587 /*
2588 * Unique major number for all zfs mounts.
2589 * If we run out of 32-bit minors, we'll getudev() another major.
2590 */
2591 zfs_major = ddi_name_to_major(ZFS_DRIVER);
2592 zfs_minor = ZFS_MIN_MINOR;
2593
2594 return (0);
2595 }
2596
2597 void
zfs_init(void)2598 zfs_init(void)
2599 {
2600 /*
2601 * Initialize .zfs directory structures
2602 */
2603 zfsctl_init();
2604
2605 /*
2606 * Initialize znode cache, vnode ops, etc...
2607 */
2608 zfs_znode_init();
2609
2610 dmu_objset_register_type(DMU_OST_ZFS, zfs_space_delta_cb);
2611 }
2612
2613 void
zfs_fini(void)2614 zfs_fini(void)
2615 {
2616 zfsctl_fini();
2617 zfs_znode_fini();
2618 }
2619
2620 int
zfs_busy(void)2621 zfs_busy(void)
2622 {
2623 return (zfs_active_fs_count != 0);
2624 }
2625
2626 int
zfs_set_version(zfsvfs_t * zfsvfs,uint64_t newvers)2627 zfs_set_version(zfsvfs_t *zfsvfs, uint64_t newvers)
2628 {
2629 int error;
2630 objset_t *os = zfsvfs->z_os;
2631 dmu_tx_t *tx;
2632
2633 if (newvers < ZPL_VERSION_INITIAL || newvers > ZPL_VERSION)
2634 return (SET_ERROR(EINVAL));
2635
2636 if (newvers < zfsvfs->z_version)
2637 return (SET_ERROR(EINVAL));
2638
2639 if (zfs_spa_version_map(newvers) >
2640 spa_version(dmu_objset_spa(zfsvfs->z_os)))
2641 return (SET_ERROR(ENOTSUP));
2642
2643 tx = dmu_tx_create(os);
2644 dmu_tx_hold_zap(tx, MASTER_NODE_OBJ, B_FALSE, ZPL_VERSION_STR);
2645 if (newvers >= ZPL_VERSION_SA && !zfsvfs->z_use_sa) {
2646 dmu_tx_hold_zap(tx, MASTER_NODE_OBJ, B_TRUE,
2647 ZFS_SA_ATTRS);
2648 dmu_tx_hold_zap(tx, DMU_NEW_OBJECT, FALSE, NULL);
2649 }
2650 error = dmu_tx_assign(tx, TXG_WAIT);
2651 if (error) {
2652 dmu_tx_abort(tx);
2653 return (error);
2654 }
2655
2656 error = zap_update(os, MASTER_NODE_OBJ, ZPL_VERSION_STR,
2657 8, 1, &newvers, tx);
2658
2659 if (error) {
2660 dmu_tx_commit(tx);
2661 return (error);
2662 }
2663
2664 if (newvers >= ZPL_VERSION_SA && !zfsvfs->z_use_sa) {
2665 uint64_t sa_obj;
2666
2667 ASSERT3U(spa_version(dmu_objset_spa(zfsvfs->z_os)), >=,
2668 SPA_VERSION_SA);
2669 sa_obj = zap_create(os, DMU_OT_SA_MASTER_NODE,
2670 DMU_OT_NONE, 0, tx);
2671
2672 error = zap_add(os, MASTER_NODE_OBJ,
2673 ZFS_SA_ATTRS, 8, 1, &sa_obj, tx);
2674 ASSERT0(error);
2675
2676 VERIFY(0 == sa_set_sa_object(os, sa_obj));
2677 sa_register_update_callback(os, zfs_sa_upgrade);
2678 }
2679
2680 spa_history_log_internal_ds(dmu_objset_ds(os), "upgrade", tx,
2681 "from %llu to %llu", zfsvfs->z_version, newvers);
2682
2683 dmu_tx_commit(tx);
2684
2685 zfsvfs->z_version = newvers;
2686 os->os_version = newvers;
2687
2688 zfs_set_fuid_feature(zfsvfs);
2689
2690 return (0);
2691 }
2692
2693 /*
2694 * Read a property stored within the master node.
2695 */
2696 int
zfs_get_zplprop(objset_t * os,zfs_prop_t prop,uint64_t * value)2697 zfs_get_zplprop(objset_t *os, zfs_prop_t prop, uint64_t *value)
2698 {
2699 uint64_t *cached_copy = NULL;
2700
2701 /*
2702 * Figure out where in the objset_t the cached copy would live, if it
2703 * is available for the requested property.
2704 */
2705 if (os != NULL) {
2706 switch (prop) {
2707 case ZFS_PROP_VERSION:
2708 cached_copy = &os->os_version;
2709 break;
2710 case ZFS_PROP_NORMALIZE:
2711 cached_copy = &os->os_normalization;
2712 break;
2713 case ZFS_PROP_UTF8ONLY:
2714 cached_copy = &os->os_utf8only;
2715 break;
2716 case ZFS_PROP_CASE:
2717 cached_copy = &os->os_casesensitivity;
2718 break;
2719 default:
2720 break;
2721 }
2722 }
2723 if (cached_copy != NULL && *cached_copy != OBJSET_PROP_UNINITIALIZED) {
2724 *value = *cached_copy;
2725 return (0);
2726 }
2727
2728 /*
2729 * If the property wasn't cached, look up the file system's value for
2730 * the property. For the version property, we look up a slightly
2731 * different string.
2732 */
2733 const char *pname;
2734 int error = ENOENT;
2735 if (prop == ZFS_PROP_VERSION) {
2736 pname = ZPL_VERSION_STR;
2737 } else {
2738 pname = zfs_prop_to_name(prop);
2739 }
2740
2741 if (os != NULL) {
2742 ASSERT3U(os->os_phys->os_type, ==, DMU_OST_ZFS);
2743 error = zap_lookup(os, MASTER_NODE_OBJ, pname, 8, 1, value);
2744 }
2745
2746 if (error == ENOENT) {
2747 /* No value set, use the default value */
2748 switch (prop) {
2749 case ZFS_PROP_VERSION:
2750 *value = ZPL_VERSION;
2751 break;
2752 case ZFS_PROP_NORMALIZE:
2753 case ZFS_PROP_UTF8ONLY:
2754 *value = 0;
2755 break;
2756 case ZFS_PROP_CASE:
2757 *value = ZFS_CASE_SENSITIVE;
2758 break;
2759 default:
2760 return (error);
2761 }
2762 error = 0;
2763 }
2764
2765 /*
2766 * If one of the methods for getting the property value above worked,
2767 * copy it into the objset_t's cache.
2768 */
2769 if (error == 0 && cached_copy != NULL) {
2770 *cached_copy = *value;
2771 }
2772
2773 return (error);
2774 }
2775
2776 /*
2777 * Return true if the coresponding vfs's unmounted flag is set.
2778 * Otherwise return false.
2779 * If this function returns true we know VFS unmount has been initiated.
2780 */
2781 boolean_t
zfs_get_vfs_flag_unmounted(objset_t * os)2782 zfs_get_vfs_flag_unmounted(objset_t *os)
2783 {
2784 zfsvfs_t *zfvp;
2785 boolean_t unmounted = B_FALSE;
2786
2787 ASSERT(dmu_objset_type(os) == DMU_OST_ZFS);
2788
2789 mutex_enter(&os->os_user_ptr_lock);
2790 zfvp = dmu_objset_get_user(os);
2791 if (zfvp != NULL && zfvp->z_vfs != NULL &&
2792 (zfvp->z_vfs->vfs_flag & VFS_UNMOUNTED))
2793 unmounted = B_TRUE;
2794 mutex_exit(&os->os_user_ptr_lock);
2795
2796 return (unmounted);
2797 }
2798
2799 static vfsdef_t vfw = {
2800 VFSDEF_VERSION,
2801 MNTTYPE_ZFS,
2802 zfs_vfsinit,
2803 VSW_HASPROTO|VSW_CANRWRO|VSW_CANREMOUNT|VSW_VOLATILEDEV|VSW_STATS|
2804 VSW_XID|VSW_ZMOUNT,
2805 &zfs_mntopts
2806 };
2807
2808 struct modlfs zfs_modlfs = {
2809 &mod_fsops, "ZFS filesystem version " SPA_VERSION_STRING, &vfw
2810 };
2811