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 https://opensource.org/licenses/CDDL-1.0. 10 * See the License for the specific language governing permissions 11 * and limitations under the License. 12 * 13 * When distributing Covered Code, include this CDDL HEADER in each 14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 15 * If applicable, add the following below this CDDL HEADER, with the 16 * fields enclosed by brackets "[]" replaced with your own identifying 17 * information: Portions Copyright [yyyy] [name of copyright owner] 18 * 19 * CDDL HEADER END 20 */ 21/* 22 * 23 * Copyright (c) 2005, 2010, Oracle and/or its affiliates. All rights reserved. 24 * Copyright (C) 2011 Lawrence Livermore National Security, LLC. 25 * Produced at Lawrence Livermore National Laboratory (cf, DISCLAIMER). 26 * LLNL-CODE-403049. 27 * Rewritten for Linux by: 28 * Rohan Puri <rohan.puri15@gmail.com> 29 * Brian Behlendorf <behlendorf1@llnl.gov> 30 * Copyright (c) 2013 by Delphix. All rights reserved. 31 * Copyright 2015, OmniTI Computer Consulting, Inc. All rights reserved. 32 * Copyright (c) 2018 George Melikov. All Rights Reserved. 33 * Copyright (c) 2019 Datto, Inc. All rights reserved. 34 * Copyright (c) 2020 The MathWorks, Inc. All rights reserved. 35 */ 36 37/* 38 * ZFS control directory (a.k.a. ".zfs") 39 * 40 * This directory provides a common location for all ZFS meta-objects. 41 * Currently, this is only the 'snapshot' and 'shares' directory, but this may 42 * expand in the future. The elements are built dynamically, as the hierarchy 43 * does not actually exist on disk. 44 * 45 * For 'snapshot', we don't want to have all snapshots always mounted, because 46 * this would take up a huge amount of space in /etc/mnttab. We have three 47 * types of objects: 48 * 49 * ctldir ------> snapshotdir -------> snapshot 50 * | 51 * | 52 * V 53 * mounted fs 54 * 55 * The 'snapshot' node contains just enough information to lookup '..' and act 56 * as a mountpoint for the snapshot. Whenever we lookup a specific snapshot, we 57 * perform an automount of the underlying filesystem and return the 58 * corresponding inode. 59 * 60 * All mounts are handled automatically by an user mode helper which invokes 61 * the mount procedure. Unmounts are handled by allowing the mount 62 * point to expire so the kernel may automatically unmount it. 63 * 64 * The '.zfs', '.zfs/snapshot', and all directories created under 65 * '.zfs/snapshot' (ie: '.zfs/snapshot/<snapname>') all share the same 66 * zfsvfs_t as the head filesystem (what '.zfs' lives under). 67 * 68 * File systems mounted on top of the '.zfs/snapshot/<snapname>' paths 69 * (ie: snapshots) are complete ZFS filesystems and have their own unique 70 * zfsvfs_t. However, the fsid reported by these mounts will be the same 71 * as that used by the parent zfsvfs_t to make NFS happy. 72 */ 73 74#include <sys/types.h> 75#include <sys/param.h> 76#include <sys/time.h> 77#include <sys/sysmacros.h> 78#include <sys/pathname.h> 79#include <sys/vfs.h> 80#include <sys/zfs_ctldir.h> 81#include <sys/zfs_ioctl.h> 82#include <sys/zfs_vfsops.h> 83#include <sys/zfs_vnops.h> 84#include <sys/stat.h> 85#include <sys/dmu.h> 86#include <sys/dmu_objset.h> 87#include <sys/dsl_destroy.h> 88#include <sys/dsl_deleg.h> 89#include <sys/zpl.h> 90#include <sys/mntent.h> 91#include "zfs_namecheck.h" 92 93/* 94 * Two AVL trees are maintained which contain all currently automounted 95 * snapshots. Every automounted snapshots maps to a single zfs_snapentry_t 96 * entry which MUST: 97 * 98 * - be attached to both trees, and 99 * - be unique, no duplicate entries are allowed. 100 * 101 * The zfs_snapshots_by_name tree is indexed by the full dataset name 102 * while the zfs_snapshots_by_objsetid tree is indexed by the unique 103 * objsetid. This allows for fast lookups either by name or objsetid. 104 */ 105static avl_tree_t zfs_snapshots_by_name; 106static avl_tree_t zfs_snapshots_by_objsetid; 107static krwlock_t zfs_snapshot_lock; 108 109/* 110 * Control Directory Tunables (.zfs) 111 */ 112int zfs_expire_snapshot = ZFSCTL_EXPIRE_SNAPSHOT; 113static int zfs_admin_snapshot = 0; 114 115typedef struct { 116 char *se_name; /* full snapshot name */ 117 char *se_path; /* full mount path */ 118 spa_t *se_spa; /* pool spa */ 119 uint64_t se_objsetid; /* snapshot objset id */ 120 struct dentry *se_root_dentry; /* snapshot root dentry */ 121 krwlock_t se_taskqid_lock; /* scheduled unmount taskqid lock */ 122 taskqid_t se_taskqid; /* scheduled unmount taskqid */ 123 avl_node_t se_node_name; /* zfs_snapshots_by_name link */ 124 avl_node_t se_node_objsetid; /* zfs_snapshots_by_objsetid link */ 125 zfs_refcount_t se_refcount; /* reference count */ 126} zfs_snapentry_t; 127 128static void zfsctl_snapshot_unmount_delay_impl(zfs_snapentry_t *se, int delay); 129 130/* 131 * Allocate a new zfs_snapentry_t being careful to make a copy of the 132 * the snapshot name and provided mount point. No reference is taken. 133 */ 134static zfs_snapentry_t * 135zfsctl_snapshot_alloc(const char *full_name, const char *full_path, spa_t *spa, 136 uint64_t objsetid, struct dentry *root_dentry) 137{ 138 zfs_snapentry_t *se; 139 140 se = kmem_zalloc(sizeof (zfs_snapentry_t), KM_SLEEP); 141 142 se->se_name = kmem_strdup(full_name); 143 se->se_path = kmem_strdup(full_path); 144 se->se_spa = spa; 145 se->se_objsetid = objsetid; 146 se->se_root_dentry = root_dentry; 147 se->se_taskqid = TASKQID_INVALID; 148 rw_init(&se->se_taskqid_lock, NULL, RW_DEFAULT, NULL); 149 150 zfs_refcount_create(&se->se_refcount); 151 152 return (se); 153} 154 155/* 156 * Free a zfs_snapentry_t the caller must ensure there are no active 157 * references. 158 */ 159static void 160zfsctl_snapshot_free(zfs_snapentry_t *se) 161{ 162 zfs_refcount_destroy(&se->se_refcount); 163 kmem_strfree(se->se_name); 164 kmem_strfree(se->se_path); 165 rw_destroy(&se->se_taskqid_lock); 166 167 kmem_free(se, sizeof (zfs_snapentry_t)); 168} 169 170/* 171 * Hold a reference on the zfs_snapentry_t. 172 */ 173static void 174zfsctl_snapshot_hold(zfs_snapentry_t *se) 175{ 176 zfs_refcount_add(&se->se_refcount, NULL); 177} 178 179/* 180 * Release a reference on the zfs_snapentry_t. When the number of 181 * references drops to zero the structure will be freed. 182 */ 183static void 184zfsctl_snapshot_rele(zfs_snapentry_t *se) 185{ 186 if (zfs_refcount_remove(&se->se_refcount, NULL) == 0) 187 zfsctl_snapshot_free(se); 188} 189 190/* 191 * Add a zfs_snapentry_t to both the zfs_snapshots_by_name and 192 * zfs_snapshots_by_objsetid trees. While the zfs_snapentry_t is part 193 * of the trees a reference is held. 194 */ 195static void 196zfsctl_snapshot_add(zfs_snapentry_t *se) 197{ 198 ASSERT(RW_WRITE_HELD(&zfs_snapshot_lock)); 199 zfsctl_snapshot_hold(se); 200 avl_add(&zfs_snapshots_by_name, se); 201 avl_add(&zfs_snapshots_by_objsetid, se); 202} 203 204/* 205 * Remove a zfs_snapentry_t from both the zfs_snapshots_by_name and 206 * zfs_snapshots_by_objsetid trees. Upon removal a reference is dropped, 207 * this can result in the structure being freed if that was the last 208 * remaining reference. 209 */ 210static void 211zfsctl_snapshot_remove(zfs_snapentry_t *se) 212{ 213 ASSERT(RW_WRITE_HELD(&zfs_snapshot_lock)); 214 avl_remove(&zfs_snapshots_by_name, se); 215 avl_remove(&zfs_snapshots_by_objsetid, se); 216 zfsctl_snapshot_rele(se); 217} 218 219/* 220 * Snapshot name comparison function for the zfs_snapshots_by_name. 221 */ 222static int 223snapentry_compare_by_name(const void *a, const void *b) 224{ 225 const zfs_snapentry_t *se_a = a; 226 const zfs_snapentry_t *se_b = b; 227 int ret; 228 229 ret = strcmp(se_a->se_name, se_b->se_name); 230 231 if (ret < 0) 232 return (-1); 233 else if (ret > 0) 234 return (1); 235 else 236 return (0); 237} 238 239/* 240 * Snapshot name comparison function for the zfs_snapshots_by_objsetid. 241 */ 242static int 243snapentry_compare_by_objsetid(const void *a, const void *b) 244{ 245 const zfs_snapentry_t *se_a = a; 246 const zfs_snapentry_t *se_b = b; 247 248 if (se_a->se_spa != se_b->se_spa) 249 return ((ulong_t)se_a->se_spa < (ulong_t)se_b->se_spa ? -1 : 1); 250 251 if (se_a->se_objsetid < se_b->se_objsetid) 252 return (-1); 253 else if (se_a->se_objsetid > se_b->se_objsetid) 254 return (1); 255 else 256 return (0); 257} 258 259/* 260 * Find a zfs_snapentry_t in zfs_snapshots_by_name. If the snapname 261 * is found a pointer to the zfs_snapentry_t is returned and a reference 262 * taken on the structure. The caller is responsible for dropping the 263 * reference with zfsctl_snapshot_rele(). If the snapname is not found 264 * NULL will be returned. 265 */ 266static zfs_snapentry_t * 267zfsctl_snapshot_find_by_name(const char *snapname) 268{ 269 zfs_snapentry_t *se, search; 270 271 ASSERT(RW_LOCK_HELD(&zfs_snapshot_lock)); 272 273 search.se_name = (char *)snapname; 274 se = avl_find(&zfs_snapshots_by_name, &search, NULL); 275 if (se) 276 zfsctl_snapshot_hold(se); 277 278 return (se); 279} 280 281/* 282 * Find a zfs_snapentry_t in zfs_snapshots_by_objsetid given the objset id 283 * rather than the snapname. In all other respects it behaves the same 284 * as zfsctl_snapshot_find_by_name(). 285 */ 286static zfs_snapentry_t * 287zfsctl_snapshot_find_by_objsetid(spa_t *spa, uint64_t objsetid) 288{ 289 zfs_snapentry_t *se, search; 290 291 ASSERT(RW_LOCK_HELD(&zfs_snapshot_lock)); 292 293 search.se_spa = spa; 294 search.se_objsetid = objsetid; 295 se = avl_find(&zfs_snapshots_by_objsetid, &search, NULL); 296 if (se) 297 zfsctl_snapshot_hold(se); 298 299 return (se); 300} 301 302/* 303 * Rename a zfs_snapentry_t in the zfs_snapshots_by_name. The structure is 304 * removed, renamed, and added back to the new correct location in the tree. 305 */ 306static int 307zfsctl_snapshot_rename(const char *old_snapname, const char *new_snapname) 308{ 309 zfs_snapentry_t *se; 310 311 ASSERT(RW_WRITE_HELD(&zfs_snapshot_lock)); 312 313 se = zfsctl_snapshot_find_by_name(old_snapname); 314 if (se == NULL) 315 return (SET_ERROR(ENOENT)); 316 317 zfsctl_snapshot_remove(se); 318 kmem_strfree(se->se_name); 319 se->se_name = kmem_strdup(new_snapname); 320 zfsctl_snapshot_add(se); 321 zfsctl_snapshot_rele(se); 322 323 return (0); 324} 325 326/* 327 * Delayed task responsible for unmounting an expired automounted snapshot. 328 */ 329static void 330snapentry_expire(void *data) 331{ 332 zfs_snapentry_t *se = (zfs_snapentry_t *)data; 333 spa_t *spa = se->se_spa; 334 uint64_t objsetid = se->se_objsetid; 335 336 if (zfs_expire_snapshot <= 0) { 337 zfsctl_snapshot_rele(se); 338 return; 339 } 340 341 rw_enter(&se->se_taskqid_lock, RW_WRITER); 342 se->se_taskqid = TASKQID_INVALID; 343 rw_exit(&se->se_taskqid_lock); 344 (void) zfsctl_snapshot_unmount(se->se_name, MNT_EXPIRE); 345 zfsctl_snapshot_rele(se); 346 347 /* 348 * Reschedule the unmount if the zfs_snapentry_t wasn't removed. 349 * This can occur when the snapshot is busy. 350 */ 351 rw_enter(&zfs_snapshot_lock, RW_READER); 352 if ((se = zfsctl_snapshot_find_by_objsetid(spa, objsetid)) != NULL) { 353 zfsctl_snapshot_unmount_delay_impl(se, zfs_expire_snapshot); 354 zfsctl_snapshot_rele(se); 355 } 356 rw_exit(&zfs_snapshot_lock); 357} 358 359/* 360 * Cancel an automatic unmount of a snapname. This callback is responsible 361 * for dropping the reference on the zfs_snapentry_t which was taken when 362 * during dispatch. 363 */ 364static void 365zfsctl_snapshot_unmount_cancel(zfs_snapentry_t *se) 366{ 367 int err = 0; 368 rw_enter(&se->se_taskqid_lock, RW_WRITER); 369 err = taskq_cancel_id(system_delay_taskq, se->se_taskqid); 370 /* 371 * if we get ENOENT, the taskq couldn't be found to be 372 * canceled, so we can just mark it as invalid because 373 * it's already gone. If we got EBUSY, then we already 374 * blocked until it was gone _anyway_, so we don't care. 375 */ 376 se->se_taskqid = TASKQID_INVALID; 377 rw_exit(&se->se_taskqid_lock); 378 if (err == 0) { 379 zfsctl_snapshot_rele(se); 380 } 381} 382 383/* 384 * Dispatch the unmount task for delayed handling with a hold protecting it. 385 */ 386static void 387zfsctl_snapshot_unmount_delay_impl(zfs_snapentry_t *se, int delay) 388{ 389 390 if (delay <= 0) 391 return; 392 393 zfsctl_snapshot_hold(se); 394 rw_enter(&se->se_taskqid_lock, RW_WRITER); 395 /* 396 * If this condition happens, we managed to: 397 * - dispatch once 398 * - want to dispatch _again_ before it returned 399 * 400 * So let's just return - if that task fails at unmounting, 401 * we'll eventually dispatch again, and if it succeeds, 402 * no problem. 403 */ 404 if (se->se_taskqid != TASKQID_INVALID) { 405 rw_exit(&se->se_taskqid_lock); 406 zfsctl_snapshot_rele(se); 407 return; 408 } 409 se->se_taskqid = taskq_dispatch_delay(system_delay_taskq, 410 snapentry_expire, se, TQ_SLEEP, ddi_get_lbolt() + delay * HZ); 411 rw_exit(&se->se_taskqid_lock); 412} 413 414/* 415 * Schedule an automatic unmount of objset id to occur in delay seconds from 416 * now. Any previous delayed unmount will be cancelled in favor of the 417 * updated deadline. A reference is taken by zfsctl_snapshot_find_by_name() 418 * and held until the outstanding task is handled or cancelled. 419 */ 420int 421zfsctl_snapshot_unmount_delay(spa_t *spa, uint64_t objsetid, int delay) 422{ 423 zfs_snapentry_t *se; 424 int error = ENOENT; 425 426 rw_enter(&zfs_snapshot_lock, RW_READER); 427 if ((se = zfsctl_snapshot_find_by_objsetid(spa, objsetid)) != NULL) { 428 zfsctl_snapshot_unmount_cancel(se); 429 zfsctl_snapshot_unmount_delay_impl(se, delay); 430 zfsctl_snapshot_rele(se); 431 error = 0; 432 } 433 rw_exit(&zfs_snapshot_lock); 434 435 return (error); 436} 437 438/* 439 * Check if snapname is currently mounted. Returned non-zero when mounted 440 * and zero when unmounted. 441 */ 442static boolean_t 443zfsctl_snapshot_ismounted(const char *snapname) 444{ 445 zfs_snapentry_t *se; 446 boolean_t ismounted = B_FALSE; 447 448 rw_enter(&zfs_snapshot_lock, RW_READER); 449 if ((se = zfsctl_snapshot_find_by_name(snapname)) != NULL) { 450 zfsctl_snapshot_rele(se); 451 ismounted = B_TRUE; 452 } 453 rw_exit(&zfs_snapshot_lock); 454 455 return (ismounted); 456} 457 458/* 459 * Check if the given inode is a part of the virtual .zfs directory. 460 */ 461boolean_t 462zfsctl_is_node(struct inode *ip) 463{ 464 return (ITOZ(ip)->z_is_ctldir); 465} 466 467/* 468 * Check if the given inode is a .zfs/snapshots/snapname directory. 469 */ 470boolean_t 471zfsctl_is_snapdir(struct inode *ip) 472{ 473 return (zfsctl_is_node(ip) && (ip->i_ino <= ZFSCTL_INO_SNAPDIRS)); 474} 475 476/* 477 * Allocate a new inode with the passed id and ops. 478 */ 479static struct inode * 480zfsctl_inode_alloc(zfsvfs_t *zfsvfs, uint64_t id, 481 const struct file_operations *fops, const struct inode_operations *ops, 482 uint64_t creation) 483{ 484 struct inode *ip; 485 znode_t *zp; 486 inode_timespec_t now = {.tv_sec = creation}; 487 488 ip = new_inode(zfsvfs->z_sb); 489 if (ip == NULL) 490 return (NULL); 491 492 if (!creation) 493 now = current_time(ip); 494 zp = ITOZ(ip); 495 ASSERT3P(zp->z_dirlocks, ==, NULL); 496 ASSERT3P(zp->z_acl_cached, ==, NULL); 497 ASSERT3P(zp->z_xattr_cached, ==, NULL); 498 zp->z_id = id; 499 zp->z_unlinked = B_FALSE; 500 zp->z_atime_dirty = B_FALSE; 501 zp->z_zn_prefetch = B_FALSE; 502 zp->z_is_sa = B_FALSE; 503#if !defined(HAVE_FILEMAP_RANGE_HAS_PAGE) 504 zp->z_is_mapped = B_FALSE; 505#endif 506 zp->z_is_ctldir = B_TRUE; 507 zp->z_sa_hdl = NULL; 508 zp->z_blksz = 0; 509 zp->z_seq = 0; 510 zp->z_mapcnt = 0; 511 zp->z_size = 0; 512 zp->z_pflags = 0; 513 zp->z_mode = 0; 514 zp->z_sync_cnt = 0; 515 zp->z_sync_writes_cnt = 0; 516 zp->z_async_writes_cnt = 0; 517 ip->i_generation = 0; 518 ip->i_ino = id; 519 ip->i_mode = (S_IFDIR | S_IRWXUGO); 520 ip->i_uid = SUID_TO_KUID(0); 521 ip->i_gid = SGID_TO_KGID(0); 522 ip->i_blkbits = SPA_MINBLOCKSHIFT; 523 zpl_inode_set_atime_to_ts(ip, now); 524 zpl_inode_set_mtime_to_ts(ip, now); 525 zpl_inode_set_ctime_to_ts(ip, now); 526 ip->i_fop = fops; 527 ip->i_op = ops; 528#if defined(IOP_XATTR) 529 ip->i_opflags &= ~IOP_XATTR; 530#endif 531 532 if (insert_inode_locked(ip)) { 533 unlock_new_inode(ip); 534 iput(ip); 535 return (NULL); 536 } 537 538 mutex_enter(&zfsvfs->z_znodes_lock); 539 list_insert_tail(&zfsvfs->z_all_znodes, zp); 540 membar_producer(); 541 mutex_exit(&zfsvfs->z_znodes_lock); 542 543 unlock_new_inode(ip); 544 545 return (ip); 546} 547 548/* 549 * Lookup the inode with given id, it will be allocated if needed. 550 */ 551static struct inode * 552zfsctl_inode_lookup(zfsvfs_t *zfsvfs, uint64_t id, 553 const struct file_operations *fops, const struct inode_operations *ops) 554{ 555 struct inode *ip = NULL; 556 uint64_t creation = 0; 557 dsl_dataset_t *snap_ds; 558 dsl_pool_t *pool; 559 560 while (ip == NULL) { 561 ip = ilookup(zfsvfs->z_sb, (unsigned long)id); 562 if (ip) 563 break; 564 565 if (id <= ZFSCTL_INO_SNAPDIRS && !creation) { 566 pool = dmu_objset_pool(zfsvfs->z_os); 567 dsl_pool_config_enter(pool, FTAG); 568 if (!dsl_dataset_hold_obj(pool, 569 ZFSCTL_INO_SNAPDIRS - id, FTAG, &snap_ds)) { 570 creation = dsl_get_creation(snap_ds); 571 dsl_dataset_rele(snap_ds, FTAG); 572 } 573 dsl_pool_config_exit(pool, FTAG); 574 } 575 576 /* May fail due to concurrent zfsctl_inode_alloc() */ 577 ip = zfsctl_inode_alloc(zfsvfs, id, fops, ops, creation); 578 } 579 580 return (ip); 581} 582 583/* 584 * Create the '.zfs' directory. This directory is cached as part of the VFS 585 * structure. This results in a hold on the zfsvfs_t. The code in zfs_umount() 586 * therefore checks against a vfs_count of 2 instead of 1. This reference 587 * is removed when the ctldir is destroyed in the unmount. All other entities 588 * under the '.zfs' directory are created dynamically as needed. 589 * 590 * Because the dynamically created '.zfs' directory entries assume the use 591 * of 64-bit inode numbers this support must be disabled on 32-bit systems. 592 */ 593int 594zfsctl_create(zfsvfs_t *zfsvfs) 595{ 596 ASSERT(zfsvfs->z_ctldir == NULL); 597 598 zfsvfs->z_ctldir = zfsctl_inode_alloc(zfsvfs, ZFSCTL_INO_ROOT, 599 &zpl_fops_root, &zpl_ops_root, 0); 600 if (zfsvfs->z_ctldir == NULL) 601 return (SET_ERROR(ENOENT)); 602 603 return (0); 604} 605 606/* 607 * Destroy the '.zfs' directory or remove a snapshot from zfs_snapshots_by_name. 608 * Only called when the filesystem is unmounted. 609 */ 610void 611zfsctl_destroy(zfsvfs_t *zfsvfs) 612{ 613 if (zfsvfs->z_issnap) { 614 zfs_snapentry_t *se; 615 spa_t *spa = zfsvfs->z_os->os_spa; 616 uint64_t objsetid = dmu_objset_id(zfsvfs->z_os); 617 618 rw_enter(&zfs_snapshot_lock, RW_WRITER); 619 se = zfsctl_snapshot_find_by_objsetid(spa, objsetid); 620 if (se != NULL) 621 zfsctl_snapshot_remove(se); 622 rw_exit(&zfs_snapshot_lock); 623 if (se != NULL) { 624 zfsctl_snapshot_unmount_cancel(se); 625 zfsctl_snapshot_rele(se); 626 } 627 } else if (zfsvfs->z_ctldir) { 628 iput(zfsvfs->z_ctldir); 629 zfsvfs->z_ctldir = NULL; 630 } 631} 632 633/* 634 * Given a root znode, retrieve the associated .zfs directory. 635 * Add a hold to the vnode and return it. 636 */ 637struct inode * 638zfsctl_root(znode_t *zp) 639{ 640 ASSERT(zfs_has_ctldir(zp)); 641 /* Must have an existing ref, so igrab() cannot return NULL */ 642 VERIFY3P(igrab(ZTOZSB(zp)->z_ctldir), !=, NULL); 643 return (ZTOZSB(zp)->z_ctldir); 644} 645 646/* 647 * Generate a long fid to indicate a snapdir. We encode whether snapdir is 648 * already mounted in gen field. We do this because nfsd lookup will not 649 * trigger automount. Next time the nfsd does fh_to_dentry, we will notice 650 * this and do automount and return ESTALE to force nfsd revalidate and follow 651 * mount. 652 */ 653static int 654zfsctl_snapdir_fid(struct inode *ip, fid_t *fidp) 655{ 656 zfid_short_t *zfid = (zfid_short_t *)fidp; 657 zfid_long_t *zlfid = (zfid_long_t *)fidp; 658 uint32_t gen = 0; 659 uint64_t object; 660 uint64_t objsetid; 661 int i; 662 struct dentry *dentry; 663 664 if (fidp->fid_len < LONG_FID_LEN) { 665 fidp->fid_len = LONG_FID_LEN; 666 return (SET_ERROR(ENOSPC)); 667 } 668 669 object = ip->i_ino; 670 objsetid = ZFSCTL_INO_SNAPDIRS - ip->i_ino; 671 zfid->zf_len = LONG_FID_LEN; 672 673 dentry = d_obtain_alias(igrab(ip)); 674 if (!IS_ERR(dentry)) { 675 gen = !!d_mountpoint(dentry); 676 dput(dentry); 677 } 678 679 for (i = 0; i < sizeof (zfid->zf_object); i++) 680 zfid->zf_object[i] = (uint8_t)(object >> (8 * i)); 681 682 for (i = 0; i < sizeof (zfid->zf_gen); i++) 683 zfid->zf_gen[i] = (uint8_t)(gen >> (8 * i)); 684 685 for (i = 0; i < sizeof (zlfid->zf_setid); i++) 686 zlfid->zf_setid[i] = (uint8_t)(objsetid >> (8 * i)); 687 688 for (i = 0; i < sizeof (zlfid->zf_setgen); i++) 689 zlfid->zf_setgen[i] = 0; 690 691 return (0); 692} 693 694/* 695 * Generate an appropriate fid for an entry in the .zfs directory. 696 */ 697int 698zfsctl_fid(struct inode *ip, fid_t *fidp) 699{ 700 znode_t *zp = ITOZ(ip); 701 zfsvfs_t *zfsvfs = ITOZSB(ip); 702 uint64_t object = zp->z_id; 703 zfid_short_t *zfid; 704 int i; 705 int error; 706 707 if ((error = zfs_enter(zfsvfs, FTAG)) != 0) 708 return (error); 709 710 if (zfsctl_is_snapdir(ip)) { 711 zfs_exit(zfsvfs, FTAG); 712 return (zfsctl_snapdir_fid(ip, fidp)); 713 } 714 715 if (fidp->fid_len < SHORT_FID_LEN) { 716 fidp->fid_len = SHORT_FID_LEN; 717 zfs_exit(zfsvfs, FTAG); 718 return (SET_ERROR(ENOSPC)); 719 } 720 721 zfid = (zfid_short_t *)fidp; 722 723 zfid->zf_len = SHORT_FID_LEN; 724 725 for (i = 0; i < sizeof (zfid->zf_object); i++) 726 zfid->zf_object[i] = (uint8_t)(object >> (8 * i)); 727 728 /* .zfs znodes always have a generation number of 0 */ 729 for (i = 0; i < sizeof (zfid->zf_gen); i++) 730 zfid->zf_gen[i] = 0; 731 732 zfs_exit(zfsvfs, FTAG); 733 return (0); 734} 735 736/* 737 * Construct a full dataset name in full_name: "pool/dataset@snap_name" 738 */ 739static int 740zfsctl_snapshot_name(zfsvfs_t *zfsvfs, const char *snap_name, int len, 741 char *full_name) 742{ 743 objset_t *os = zfsvfs->z_os; 744 745 if (zfs_component_namecheck(snap_name, NULL, NULL) != 0) 746 return (SET_ERROR(EILSEQ)); 747 748 dmu_objset_name(os, full_name); 749 if ((strlen(full_name) + 1 + strlen(snap_name)) >= len) 750 return (SET_ERROR(ENAMETOOLONG)); 751 752 (void) strcat(full_name, "@"); 753 (void) strcat(full_name, snap_name); 754 755 return (0); 756} 757 758/* 759 * Returns full path in full_path: "/pool/dataset/.zfs/snapshot/snap_name/" 760 */ 761static int 762zfsctl_snapshot_path_objset(zfsvfs_t *zfsvfs, uint64_t objsetid, 763 int path_len, char *full_path) 764{ 765 objset_t *os = zfsvfs->z_os; 766 fstrans_cookie_t cookie; 767 char *snapname; 768 boolean_t case_conflict; 769 uint64_t id, pos = 0; 770 int error = 0; 771 772 if (zfsvfs->z_vfs->vfs_mntpoint == NULL) 773 return (SET_ERROR(ENOENT)); 774 775 cookie = spl_fstrans_mark(); 776 snapname = kmem_alloc(ZFS_MAX_DATASET_NAME_LEN, KM_SLEEP); 777 778 while (error == 0) { 779 dsl_pool_config_enter(dmu_objset_pool(os), FTAG); 780 error = dmu_snapshot_list_next(zfsvfs->z_os, 781 ZFS_MAX_DATASET_NAME_LEN, snapname, &id, &pos, 782 &case_conflict); 783 dsl_pool_config_exit(dmu_objset_pool(os), FTAG); 784 if (error) 785 goto out; 786 787 if (id == objsetid) 788 break; 789 } 790 791 snprintf(full_path, path_len, "%s/.zfs/snapshot/%s", 792 zfsvfs->z_vfs->vfs_mntpoint, snapname); 793out: 794 kmem_free(snapname, ZFS_MAX_DATASET_NAME_LEN); 795 spl_fstrans_unmark(cookie); 796 797 return (error); 798} 799 800/* 801 * Special case the handling of "..". 802 */ 803int 804zfsctl_root_lookup(struct inode *dip, const char *name, struct inode **ipp, 805 int flags, cred_t *cr, int *direntflags, pathname_t *realpnp) 806{ 807 zfsvfs_t *zfsvfs = ITOZSB(dip); 808 int error = 0; 809 810 if ((error = zfs_enter(zfsvfs, FTAG)) != 0) 811 return (error); 812 813 if (strcmp(name, "..") == 0) { 814 *ipp = dip->i_sb->s_root->d_inode; 815 } else if (strcmp(name, ZFS_SNAPDIR_NAME) == 0) { 816 *ipp = zfsctl_inode_lookup(zfsvfs, ZFSCTL_INO_SNAPDIR, 817 &zpl_fops_snapdir, &zpl_ops_snapdir); 818 } else if (strcmp(name, ZFS_SHAREDIR_NAME) == 0) { 819 *ipp = zfsctl_inode_lookup(zfsvfs, ZFSCTL_INO_SHARES, 820 &zpl_fops_shares, &zpl_ops_shares); 821 } else { 822 *ipp = NULL; 823 } 824 825 if (*ipp == NULL) 826 error = SET_ERROR(ENOENT); 827 828 zfs_exit(zfsvfs, FTAG); 829 830 return (error); 831} 832 833/* 834 * Lookup entry point for the 'snapshot' directory. Try to open the 835 * snapshot if it exist, creating the pseudo filesystem inode as necessary. 836 */ 837int 838zfsctl_snapdir_lookup(struct inode *dip, const char *name, struct inode **ipp, 839 int flags, cred_t *cr, int *direntflags, pathname_t *realpnp) 840{ 841 zfsvfs_t *zfsvfs = ITOZSB(dip); 842 uint64_t id; 843 int error; 844 845 if ((error = zfs_enter(zfsvfs, FTAG)) != 0) 846 return (error); 847 848 error = dmu_snapshot_lookup(zfsvfs->z_os, name, &id); 849 if (error) { 850 zfs_exit(zfsvfs, FTAG); 851 return (error); 852 } 853 854 *ipp = zfsctl_inode_lookup(zfsvfs, ZFSCTL_INO_SNAPDIRS - id, 855 &simple_dir_operations, &simple_dir_inode_operations); 856 if (*ipp == NULL) 857 error = SET_ERROR(ENOENT); 858 859 zfs_exit(zfsvfs, FTAG); 860 861 return (error); 862} 863 864/* 865 * Renaming a directory under '.zfs/snapshot' will automatically trigger 866 * a rename of the snapshot to the new given name. The rename is confined 867 * to the '.zfs/snapshot' directory snapshots cannot be moved elsewhere. 868 */ 869int 870zfsctl_snapdir_rename(struct inode *sdip, const char *snm, 871 struct inode *tdip, const char *tnm, cred_t *cr, int flags) 872{ 873 zfsvfs_t *zfsvfs = ITOZSB(sdip); 874 char *to, *from, *real, *fsname; 875 int error; 876 877 if (!zfs_admin_snapshot) 878 return (SET_ERROR(EACCES)); 879 880 if ((error = zfs_enter(zfsvfs, FTAG)) != 0) 881 return (error); 882 883 to = kmem_alloc(ZFS_MAX_DATASET_NAME_LEN, KM_SLEEP); 884 from = kmem_alloc(ZFS_MAX_DATASET_NAME_LEN, KM_SLEEP); 885 real = kmem_alloc(ZFS_MAX_DATASET_NAME_LEN, KM_SLEEP); 886 fsname = kmem_alloc(ZFS_MAX_DATASET_NAME_LEN, KM_SLEEP); 887 888 if (zfsvfs->z_case == ZFS_CASE_INSENSITIVE) { 889 error = dmu_snapshot_realname(zfsvfs->z_os, snm, real, 890 ZFS_MAX_DATASET_NAME_LEN, NULL); 891 if (error == 0) { 892 snm = real; 893 } else if (error != ENOTSUP) { 894 goto out; 895 } 896 } 897 898 dmu_objset_name(zfsvfs->z_os, fsname); 899 900 error = zfsctl_snapshot_name(ITOZSB(sdip), snm, 901 ZFS_MAX_DATASET_NAME_LEN, from); 902 if (error == 0) 903 error = zfsctl_snapshot_name(ITOZSB(tdip), tnm, 904 ZFS_MAX_DATASET_NAME_LEN, to); 905 if (error == 0) 906 error = zfs_secpolicy_rename_perms(from, to, cr); 907 if (error != 0) 908 goto out; 909 910 /* 911 * Cannot move snapshots out of the snapdir. 912 */ 913 if (sdip != tdip) { 914 error = SET_ERROR(EINVAL); 915 goto out; 916 } 917 918 /* 919 * No-op when names are identical. 920 */ 921 if (strcmp(snm, tnm) == 0) { 922 error = 0; 923 goto out; 924 } 925 926 rw_enter(&zfs_snapshot_lock, RW_WRITER); 927 928 error = dsl_dataset_rename_snapshot(fsname, snm, tnm, B_FALSE); 929 if (error == 0) 930 (void) zfsctl_snapshot_rename(snm, tnm); 931 932 rw_exit(&zfs_snapshot_lock); 933out: 934 kmem_free(from, ZFS_MAX_DATASET_NAME_LEN); 935 kmem_free(to, ZFS_MAX_DATASET_NAME_LEN); 936 kmem_free(real, ZFS_MAX_DATASET_NAME_LEN); 937 kmem_free(fsname, ZFS_MAX_DATASET_NAME_LEN); 938 939 zfs_exit(zfsvfs, FTAG); 940 941 return (error); 942} 943 944/* 945 * Removing a directory under '.zfs/snapshot' will automatically trigger 946 * the removal of the snapshot with the given name. 947 */ 948int 949zfsctl_snapdir_remove(struct inode *dip, const char *name, cred_t *cr, 950 int flags) 951{ 952 zfsvfs_t *zfsvfs = ITOZSB(dip); 953 char *snapname, *real; 954 int error; 955 956 if (!zfs_admin_snapshot) 957 return (SET_ERROR(EACCES)); 958 959 if ((error = zfs_enter(zfsvfs, FTAG)) != 0) 960 return (error); 961 962 snapname = kmem_alloc(ZFS_MAX_DATASET_NAME_LEN, KM_SLEEP); 963 real = kmem_alloc(ZFS_MAX_DATASET_NAME_LEN, KM_SLEEP); 964 965 if (zfsvfs->z_case == ZFS_CASE_INSENSITIVE) { 966 error = dmu_snapshot_realname(zfsvfs->z_os, name, real, 967 ZFS_MAX_DATASET_NAME_LEN, NULL); 968 if (error == 0) { 969 name = real; 970 } else if (error != ENOTSUP) { 971 goto out; 972 } 973 } 974 975 error = zfsctl_snapshot_name(ITOZSB(dip), name, 976 ZFS_MAX_DATASET_NAME_LEN, snapname); 977 if (error == 0) 978 error = zfs_secpolicy_destroy_perms(snapname, cr); 979 if (error != 0) 980 goto out; 981 982 error = zfsctl_snapshot_unmount(snapname, MNT_FORCE); 983 if ((error == 0) || (error == ENOENT)) 984 error = dsl_destroy_snapshot(snapname, B_FALSE); 985out: 986 kmem_free(snapname, ZFS_MAX_DATASET_NAME_LEN); 987 kmem_free(real, ZFS_MAX_DATASET_NAME_LEN); 988 989 zfs_exit(zfsvfs, FTAG); 990 991 return (error); 992} 993 994/* 995 * Creating a directory under '.zfs/snapshot' will automatically trigger 996 * the creation of a new snapshot with the given name. 997 */ 998int 999zfsctl_snapdir_mkdir(struct inode *dip, const char *dirname, vattr_t *vap, 1000 struct inode **ipp, cred_t *cr, int flags) 1001{ 1002 zfsvfs_t *zfsvfs = ITOZSB(dip); 1003 char *dsname; 1004 int error; 1005 1006 if (!zfs_admin_snapshot) 1007 return (SET_ERROR(EACCES)); 1008 1009 dsname = kmem_alloc(ZFS_MAX_DATASET_NAME_LEN, KM_SLEEP); 1010 1011 if (zfs_component_namecheck(dirname, NULL, NULL) != 0) { 1012 error = SET_ERROR(EILSEQ); 1013 goto out; 1014 } 1015 1016 dmu_objset_name(zfsvfs->z_os, dsname); 1017 1018 error = zfs_secpolicy_snapshot_perms(dsname, cr); 1019 if (error != 0) 1020 goto out; 1021 1022 if (error == 0) { 1023 error = dmu_objset_snapshot_one(dsname, dirname); 1024 if (error != 0) 1025 goto out; 1026 1027 error = zfsctl_snapdir_lookup(dip, dirname, ipp, 1028 0, cr, NULL, NULL); 1029 } 1030out: 1031 kmem_free(dsname, ZFS_MAX_DATASET_NAME_LEN); 1032 1033 return (error); 1034} 1035 1036/* 1037 * Flush everything out of the kernel's export table and such. 1038 * This is needed as once the snapshot is used over NFS, its 1039 * entries in svc_export and svc_expkey caches hold reference 1040 * to the snapshot mount point. There is no known way of flushing 1041 * only the entries related to the snapshot. 1042 */ 1043static void 1044exportfs_flush(void) 1045{ 1046 char *argv[] = { "/usr/sbin/exportfs", "-f", NULL }; 1047 char *envp[] = { NULL }; 1048 1049 (void) call_usermodehelper(argv[0], argv, envp, UMH_WAIT_PROC); 1050} 1051 1052/* 1053 * Attempt to unmount a snapshot by making a call to user space. 1054 * There is no assurance that this can or will succeed, is just a 1055 * best effort. In the case where it does fail, perhaps because 1056 * it's in use, the unmount will fail harmlessly. 1057 */ 1058int 1059zfsctl_snapshot_unmount(const char *snapname, int flags) 1060{ 1061 char *argv[] = { "/usr/bin/env", "umount", "-t", "zfs", "-n", NULL, 1062 NULL }; 1063 char *envp[] = { NULL }; 1064 zfs_snapentry_t *se; 1065 int error; 1066 1067 rw_enter(&zfs_snapshot_lock, RW_READER); 1068 if ((se = zfsctl_snapshot_find_by_name(snapname)) == NULL) { 1069 rw_exit(&zfs_snapshot_lock); 1070 return (SET_ERROR(ENOENT)); 1071 } 1072 rw_exit(&zfs_snapshot_lock); 1073 1074 exportfs_flush(); 1075 1076 if (flags & MNT_FORCE) 1077 argv[4] = "-fn"; 1078 argv[5] = se->se_path; 1079 dprintf("unmount; path=%s\n", se->se_path); 1080 error = call_usermodehelper(argv[0], argv, envp, UMH_WAIT_PROC); 1081 zfsctl_snapshot_rele(se); 1082 1083 1084 /* 1085 * The umount system utility will return 256 on error. We must 1086 * assume this error is because the file system is busy so it is 1087 * converted to the more sensible EBUSY. 1088 */ 1089 if (error) 1090 error = SET_ERROR(EBUSY); 1091 1092 return (error); 1093} 1094 1095int 1096zfsctl_snapshot_mount(struct path *path, int flags) 1097{ 1098 struct dentry *dentry = path->dentry; 1099 struct inode *ip = dentry->d_inode; 1100 zfsvfs_t *zfsvfs; 1101 zfsvfs_t *snap_zfsvfs; 1102 zfs_snapentry_t *se; 1103 char *full_name, *full_path; 1104 char *argv[] = { "/usr/bin/env", "mount", "-t", "zfs", "-n", NULL, NULL, 1105 NULL }; 1106 char *envp[] = { NULL }; 1107 int error; 1108 struct path spath; 1109 1110 if (ip == NULL) 1111 return (SET_ERROR(EISDIR)); 1112 1113 zfsvfs = ITOZSB(ip); 1114 if ((error = zfs_enter(zfsvfs, FTAG)) != 0) 1115 return (error); 1116 1117 full_name = kmem_zalloc(ZFS_MAX_DATASET_NAME_LEN, KM_SLEEP); 1118 full_path = kmem_zalloc(MAXPATHLEN, KM_SLEEP); 1119 1120 error = zfsctl_snapshot_name(zfsvfs, dname(dentry), 1121 ZFS_MAX_DATASET_NAME_LEN, full_name); 1122 if (error) 1123 goto error; 1124 1125 /* 1126 * Construct a mount point path from sb of the ctldir inode and dirent 1127 * name, instead of from d_path(), so that chroot'd process doesn't fail 1128 * on mount.zfs(8). 1129 */ 1130 snprintf(full_path, MAXPATHLEN, "%s/.zfs/snapshot/%s", 1131 zfsvfs->z_vfs->vfs_mntpoint ? zfsvfs->z_vfs->vfs_mntpoint : "", 1132 dname(dentry)); 1133 1134 /* 1135 * Multiple concurrent automounts of a snapshot are never allowed. 1136 * The snapshot may be manually mounted as many times as desired. 1137 */ 1138 if (zfsctl_snapshot_ismounted(full_name)) { 1139 error = 0; 1140 goto error; 1141 } 1142 1143 /* 1144 * Attempt to mount the snapshot from user space. Normally this 1145 * would be done using the vfs_kern_mount() function, however that 1146 * function is marked GPL-only and cannot be used. On error we 1147 * careful to log the real error to the console and return EISDIR 1148 * to safely abort the automount. This should be very rare. 1149 * 1150 * If the user mode helper happens to return EBUSY, a concurrent 1151 * mount is already in progress in which case the error is ignored. 1152 * Take note that if the program was executed successfully the return 1153 * value from call_usermodehelper() will be (exitcode << 8 + signal). 1154 */ 1155 dprintf("mount; name=%s path=%s\n", full_name, full_path); 1156 argv[5] = full_name; 1157 argv[6] = full_path; 1158 error = call_usermodehelper(argv[0], argv, envp, UMH_WAIT_PROC); 1159 if (error) { 1160 if (!(error & MOUNT_BUSY << 8)) { 1161 zfs_dbgmsg("Unable to automount %s error=%d", 1162 full_path, error); 1163 error = SET_ERROR(EISDIR); 1164 } else { 1165 /* 1166 * EBUSY, this could mean a concurrent mount, or the 1167 * snapshot has already been mounted at completely 1168 * different place. We return 0 so VFS will retry. For 1169 * the latter case the VFS will retry several times 1170 * and return ELOOP, which is probably not a very good 1171 * behavior. 1172 */ 1173 error = 0; 1174 } 1175 goto error; 1176 } 1177 1178 /* 1179 * Follow down in to the mounted snapshot and set MNT_SHRINKABLE 1180 * to identify this as an automounted filesystem. 1181 */ 1182 spath = *path; 1183 path_get(&spath); 1184 if (follow_down_one(&spath)) { 1185 snap_zfsvfs = ITOZSB(spath.dentry->d_inode); 1186 snap_zfsvfs->z_parent = zfsvfs; 1187 dentry = spath.dentry; 1188 spath.mnt->mnt_flags |= MNT_SHRINKABLE; 1189 1190 rw_enter(&zfs_snapshot_lock, RW_WRITER); 1191 se = zfsctl_snapshot_alloc(full_name, full_path, 1192 snap_zfsvfs->z_os->os_spa, dmu_objset_id(snap_zfsvfs->z_os), 1193 dentry); 1194 zfsctl_snapshot_add(se); 1195 zfsctl_snapshot_unmount_delay_impl(se, zfs_expire_snapshot); 1196 rw_exit(&zfs_snapshot_lock); 1197 } 1198 path_put(&spath); 1199error: 1200 kmem_free(full_name, ZFS_MAX_DATASET_NAME_LEN); 1201 kmem_free(full_path, MAXPATHLEN); 1202 1203 zfs_exit(zfsvfs, FTAG); 1204 1205 return (error); 1206} 1207 1208/* 1209 * Get the snapdir inode from fid 1210 */ 1211int 1212zfsctl_snapdir_vget(struct super_block *sb, uint64_t objsetid, int gen, 1213 struct inode **ipp) 1214{ 1215 int error; 1216 struct path path; 1217 char *mnt; 1218 struct dentry *dentry; 1219 1220 mnt = kmem_alloc(MAXPATHLEN, KM_SLEEP); 1221 1222 error = zfsctl_snapshot_path_objset(sb->s_fs_info, objsetid, 1223 MAXPATHLEN, mnt); 1224 if (error) 1225 goto out; 1226 1227 /* Trigger automount */ 1228 error = -kern_path(mnt, LOOKUP_FOLLOW|LOOKUP_DIRECTORY, &path); 1229 if (error) 1230 goto out; 1231 1232 path_put(&path); 1233 /* 1234 * Get the snapdir inode. Note, we don't want to use the above 1235 * path because it contains the root of the snapshot rather 1236 * than the snapdir. 1237 */ 1238 *ipp = ilookup(sb, ZFSCTL_INO_SNAPDIRS - objsetid); 1239 if (*ipp == NULL) { 1240 error = SET_ERROR(ENOENT); 1241 goto out; 1242 } 1243 1244 /* check gen, see zfsctl_snapdir_fid */ 1245 dentry = d_obtain_alias(igrab(*ipp)); 1246 if (gen != (!IS_ERR(dentry) && d_mountpoint(dentry))) { 1247 iput(*ipp); 1248 *ipp = NULL; 1249 error = SET_ERROR(ENOENT); 1250 } 1251 if (!IS_ERR(dentry)) 1252 dput(dentry); 1253out: 1254 kmem_free(mnt, MAXPATHLEN); 1255 return (error); 1256} 1257 1258int 1259zfsctl_shares_lookup(struct inode *dip, char *name, struct inode **ipp, 1260 int flags, cred_t *cr, int *direntflags, pathname_t *realpnp) 1261{ 1262 zfsvfs_t *zfsvfs = ITOZSB(dip); 1263 znode_t *zp; 1264 znode_t *dzp; 1265 int error; 1266 1267 if ((error = zfs_enter(zfsvfs, FTAG)) != 0) 1268 return (error); 1269 1270 if (zfsvfs->z_shares_dir == 0) { 1271 zfs_exit(zfsvfs, FTAG); 1272 return (SET_ERROR(ENOTSUP)); 1273 } 1274 1275 if ((error = zfs_zget(zfsvfs, zfsvfs->z_shares_dir, &dzp)) == 0) { 1276 error = zfs_lookup(dzp, name, &zp, 0, cr, NULL, NULL); 1277 zrele(dzp); 1278 } 1279 1280 zfs_exit(zfsvfs, FTAG); 1281 1282 return (error); 1283} 1284 1285/* 1286 * Initialize the various pieces we'll need to create and manipulate .zfs 1287 * directories. Currently this is unused but available. 1288 */ 1289void 1290zfsctl_init(void) 1291{ 1292 avl_create(&zfs_snapshots_by_name, snapentry_compare_by_name, 1293 sizeof (zfs_snapentry_t), offsetof(zfs_snapentry_t, 1294 se_node_name)); 1295 avl_create(&zfs_snapshots_by_objsetid, snapentry_compare_by_objsetid, 1296 sizeof (zfs_snapentry_t), offsetof(zfs_snapentry_t, 1297 se_node_objsetid)); 1298 rw_init(&zfs_snapshot_lock, NULL, RW_DEFAULT, NULL); 1299} 1300 1301/* 1302 * Cleanup the various pieces we needed for .zfs directories. In particular 1303 * ensure the expiry timer is canceled safely. 1304 */ 1305void 1306zfsctl_fini(void) 1307{ 1308 avl_destroy(&zfs_snapshots_by_name); 1309 avl_destroy(&zfs_snapshots_by_objsetid); 1310 rw_destroy(&zfs_snapshot_lock); 1311} 1312 1313module_param(zfs_admin_snapshot, int, 0644); 1314MODULE_PARM_DESC(zfs_admin_snapshot, "Enable mkdir/rmdir/mv in .zfs/snapshot"); 1315 1316module_param(zfs_expire_snapshot, int, 0644); 1317MODULE_PARM_DESC(zfs_expire_snapshot, "Seconds to expire .zfs/snapshot"); 1318