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