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 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
128 static 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 */
134 static zfs_snapentry_t *
zfsctl_snapshot_alloc(const char * full_name,const char * full_path,spa_t * spa,uint64_t objsetid,struct dentry * root_dentry)135 zfsctl_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 */
159 static void
zfsctl_snapshot_free(zfs_snapentry_t * se)160 zfsctl_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 */
173 static void
zfsctl_snapshot_hold(zfs_snapentry_t * se)174 zfsctl_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 */
183 static void
zfsctl_snapshot_rele(zfs_snapentry_t * se)184 zfsctl_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 */
195 static void
zfsctl_snapshot_add(zfs_snapentry_t * se)196 zfsctl_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 */
210 static void
zfsctl_snapshot_remove(zfs_snapentry_t * se)211 zfsctl_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 */
222 static int
snapentry_compare_by_name(const void * a,const void * b)223 snapentry_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 */
242 static int
snapentry_compare_by_objsetid(const void * a,const void * b)243 snapentry_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 */
266 static zfs_snapentry_t *
zfsctl_snapshot_find_by_name(const char * snapname)267 zfsctl_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 */
286 static zfs_snapentry_t *
zfsctl_snapshot_find_by_objsetid(spa_t * spa,uint64_t objsetid)287 zfsctl_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 */
306 static int
zfsctl_snapshot_rename(const char * old_snapname,const char * new_snapname)307 zfsctl_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 */
329 static void
snapentry_expire(void * data)330 snapentry_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 */
364 static void
zfsctl_snapshot_unmount_cancel(zfs_snapentry_t * se)365 zfsctl_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 */
386 static void
zfsctl_snapshot_unmount_delay_impl(zfs_snapentry_t * se,int delay)387 zfsctl_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 */
420 int
zfsctl_snapshot_unmount_delay(spa_t * spa,uint64_t objsetid,int delay)421 zfsctl_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 */
442 static boolean_t
zfsctl_snapshot_ismounted(const char * snapname)443 zfsctl_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 */
461 boolean_t
zfsctl_is_node(struct inode * ip)462 zfsctl_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 */
470 boolean_t
zfsctl_is_snapdir(struct inode * ip)471 zfsctl_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 */
479 static struct inode *
zfsctl_inode_alloc(zfsvfs_t * zfsvfs,uint64_t id,const struct file_operations * fops,const struct inode_operations * ops)480 zfsctl_inode_alloc(zfsvfs_t *zfsvfs, uint64_t id,
481 const struct file_operations *fops, const struct inode_operations *ops)
482 {
483 inode_timespec_t now;
484 struct inode *ip;
485 znode_t *zp;
486
487 ip = new_inode(zfsvfs->z_sb);
488 if (ip == NULL)
489 return (NULL);
490
491 now = current_time(ip);
492 zp = ITOZ(ip);
493 ASSERT3P(zp->z_dirlocks, ==, NULL);
494 ASSERT3P(zp->z_acl_cached, ==, NULL);
495 ASSERT3P(zp->z_xattr_cached, ==, NULL);
496 zp->z_id = id;
497 zp->z_unlinked = B_FALSE;
498 zp->z_atime_dirty = B_FALSE;
499 zp->z_zn_prefetch = B_FALSE;
500 zp->z_is_sa = B_FALSE;
501 #if !defined(HAVE_FILEMAP_RANGE_HAS_PAGE)
502 zp->z_is_mapped = B_FALSE;
503 #endif
504 zp->z_is_ctldir = B_TRUE;
505 zp->z_sa_hdl = NULL;
506 zp->z_blksz = 0;
507 zp->z_seq = 0;
508 zp->z_mapcnt = 0;
509 zp->z_size = 0;
510 zp->z_pflags = 0;
511 zp->z_mode = 0;
512 zp->z_sync_cnt = 0;
513 zp->z_sync_writes_cnt = 0;
514 zp->z_async_writes_cnt = 0;
515 ip->i_generation = 0;
516 ip->i_ino = id;
517 ip->i_mode = (S_IFDIR | S_IRWXUGO);
518 ip->i_uid = SUID_TO_KUID(0);
519 ip->i_gid = SGID_TO_KGID(0);
520 ip->i_blkbits = SPA_MINBLOCKSHIFT;
521 zpl_inode_set_atime_to_ts(ip, now);
522 zpl_inode_set_mtime_to_ts(ip, now);
523 zpl_inode_set_ctime_to_ts(ip, now);
524 ip->i_fop = fops;
525 ip->i_op = ops;
526 #if defined(IOP_XATTR)
527 ip->i_opflags &= ~IOP_XATTR;
528 #endif
529
530 if (insert_inode_locked(ip)) {
531 unlock_new_inode(ip);
532 iput(ip);
533 return (NULL);
534 }
535
536 mutex_enter(&zfsvfs->z_znodes_lock);
537 list_insert_tail(&zfsvfs->z_all_znodes, zp);
538 zfsvfs->z_nr_znodes++;
539 membar_producer();
540 mutex_exit(&zfsvfs->z_znodes_lock);
541
542 unlock_new_inode(ip);
543
544 return (ip);
545 }
546
547 /*
548 * Lookup the inode with given id, it will be allocated if needed.
549 */
550 static struct inode *
zfsctl_inode_lookup(zfsvfs_t * zfsvfs,uint64_t id,const struct file_operations * fops,const struct inode_operations * ops)551 zfsctl_inode_lookup(zfsvfs_t *zfsvfs, uint64_t id,
552 const struct file_operations *fops, const struct inode_operations *ops)
553 {
554 struct inode *ip = NULL;
555
556 while (ip == NULL) {
557 ip = ilookup(zfsvfs->z_sb, (unsigned long)id);
558 if (ip)
559 break;
560
561 /* May fail due to concurrent zfsctl_inode_alloc() */
562 ip = zfsctl_inode_alloc(zfsvfs, id, fops, ops);
563 }
564
565 return (ip);
566 }
567
568 /*
569 * Create the '.zfs' directory. This directory is cached as part of the VFS
570 * structure. This results in a hold on the zfsvfs_t. The code in zfs_umount()
571 * therefore checks against a vfs_count of 2 instead of 1. This reference
572 * is removed when the ctldir is destroyed in the unmount. All other entities
573 * under the '.zfs' directory are created dynamically as needed.
574 *
575 * Because the dynamically created '.zfs' directory entries assume the use
576 * of 64-bit inode numbers this support must be disabled on 32-bit systems.
577 */
578 int
zfsctl_create(zfsvfs_t * zfsvfs)579 zfsctl_create(zfsvfs_t *zfsvfs)
580 {
581 ASSERT(zfsvfs->z_ctldir == NULL);
582
583 zfsvfs->z_ctldir = zfsctl_inode_alloc(zfsvfs, ZFSCTL_INO_ROOT,
584 &zpl_fops_root, &zpl_ops_root);
585 if (zfsvfs->z_ctldir == NULL)
586 return (SET_ERROR(ENOENT));
587
588 return (0);
589 }
590
591 /*
592 * Destroy the '.zfs' directory or remove a snapshot from zfs_snapshots_by_name.
593 * Only called when the filesystem is unmounted.
594 */
595 void
zfsctl_destroy(zfsvfs_t * zfsvfs)596 zfsctl_destroy(zfsvfs_t *zfsvfs)
597 {
598 if (zfsvfs->z_issnap) {
599 zfs_snapentry_t *se;
600 spa_t *spa = zfsvfs->z_os->os_spa;
601 uint64_t objsetid = dmu_objset_id(zfsvfs->z_os);
602
603 rw_enter(&zfs_snapshot_lock, RW_WRITER);
604 se = zfsctl_snapshot_find_by_objsetid(spa, objsetid);
605 if (se != NULL)
606 zfsctl_snapshot_remove(se);
607 rw_exit(&zfs_snapshot_lock);
608 if (se != NULL) {
609 zfsctl_snapshot_unmount_cancel(se);
610 zfsctl_snapshot_rele(se);
611 }
612 } else if (zfsvfs->z_ctldir) {
613 iput(zfsvfs->z_ctldir);
614 zfsvfs->z_ctldir = NULL;
615 }
616 }
617
618 /*
619 * Given a root znode, retrieve the associated .zfs directory.
620 * Add a hold to the vnode and return it.
621 */
622 struct inode *
zfsctl_root(znode_t * zp)623 zfsctl_root(znode_t *zp)
624 {
625 ASSERT(zfs_has_ctldir(zp));
626 /* Must have an existing ref, so igrab() cannot return NULL */
627 VERIFY3P(igrab(ZTOZSB(zp)->z_ctldir), !=, NULL);
628 return (ZTOZSB(zp)->z_ctldir);
629 }
630
631 /*
632 * Generate a long fid to indicate a snapdir. We encode whether snapdir is
633 * already mounted in gen field. We do this because nfsd lookup will not
634 * trigger automount. Next time the nfsd does fh_to_dentry, we will notice
635 * this and do automount and return ESTALE to force nfsd revalidate and follow
636 * mount.
637 */
638 static int
zfsctl_snapdir_fid(struct inode * ip,fid_t * fidp)639 zfsctl_snapdir_fid(struct inode *ip, fid_t *fidp)
640 {
641 zfid_short_t *zfid = (zfid_short_t *)fidp;
642 zfid_long_t *zlfid = (zfid_long_t *)fidp;
643 uint32_t gen = 0;
644 uint64_t object;
645 uint64_t objsetid;
646 int i;
647 struct dentry *dentry;
648
649 if (fidp->fid_len < LONG_FID_LEN) {
650 fidp->fid_len = LONG_FID_LEN;
651 return (SET_ERROR(ENOSPC));
652 }
653
654 object = ip->i_ino;
655 objsetid = ZFSCTL_INO_SNAPDIRS - ip->i_ino;
656 zfid->zf_len = LONG_FID_LEN;
657
658 dentry = d_obtain_alias(igrab(ip));
659 if (!IS_ERR(dentry)) {
660 gen = !!d_mountpoint(dentry);
661 dput(dentry);
662 }
663
664 for (i = 0; i < sizeof (zfid->zf_object); i++)
665 zfid->zf_object[i] = (uint8_t)(object >> (8 * i));
666
667 for (i = 0; i < sizeof (zfid->zf_gen); i++)
668 zfid->zf_gen[i] = (uint8_t)(gen >> (8 * i));
669
670 for (i = 0; i < sizeof (zlfid->zf_setid); i++)
671 zlfid->zf_setid[i] = (uint8_t)(objsetid >> (8 * i));
672
673 for (i = 0; i < sizeof (zlfid->zf_setgen); i++)
674 zlfid->zf_setgen[i] = 0;
675
676 return (0);
677 }
678
679 /*
680 * Generate an appropriate fid for an entry in the .zfs directory.
681 */
682 int
zfsctl_fid(struct inode * ip,fid_t * fidp)683 zfsctl_fid(struct inode *ip, fid_t *fidp)
684 {
685 znode_t *zp = ITOZ(ip);
686 zfsvfs_t *zfsvfs = ITOZSB(ip);
687 uint64_t object = zp->z_id;
688 zfid_short_t *zfid;
689 int i;
690
691 ZFS_ENTER(zfsvfs);
692
693 if (zfsctl_is_snapdir(ip)) {
694 ZFS_EXIT(zfsvfs);
695 return (zfsctl_snapdir_fid(ip, fidp));
696 }
697
698 if (fidp->fid_len < SHORT_FID_LEN) {
699 fidp->fid_len = SHORT_FID_LEN;
700 ZFS_EXIT(zfsvfs);
701 return (SET_ERROR(ENOSPC));
702 }
703
704 zfid = (zfid_short_t *)fidp;
705
706 zfid->zf_len = SHORT_FID_LEN;
707
708 for (i = 0; i < sizeof (zfid->zf_object); i++)
709 zfid->zf_object[i] = (uint8_t)(object >> (8 * i));
710
711 /* .zfs znodes always have a generation number of 0 */
712 for (i = 0; i < sizeof (zfid->zf_gen); i++)
713 zfid->zf_gen[i] = 0;
714
715 ZFS_EXIT(zfsvfs);
716 return (0);
717 }
718
719 /*
720 * Construct a full dataset name in full_name: "pool/dataset@snap_name"
721 */
722 static int
zfsctl_snapshot_name(zfsvfs_t * zfsvfs,const char * snap_name,int len,char * full_name)723 zfsctl_snapshot_name(zfsvfs_t *zfsvfs, const char *snap_name, int len,
724 char *full_name)
725 {
726 objset_t *os = zfsvfs->z_os;
727
728 if (zfs_component_namecheck(snap_name, NULL, NULL) != 0)
729 return (SET_ERROR(EILSEQ));
730
731 dmu_objset_name(os, full_name);
732 if ((strlen(full_name) + 1 + strlen(snap_name)) >= len)
733 return (SET_ERROR(ENAMETOOLONG));
734
735 (void) strcat(full_name, "@");
736 (void) strcat(full_name, snap_name);
737
738 return (0);
739 }
740
741 /*
742 * Returns full path in full_path: "/pool/dataset/.zfs/snapshot/snap_name/"
743 */
744 static int
zfsctl_snapshot_path_objset(zfsvfs_t * zfsvfs,uint64_t objsetid,int path_len,char * full_path)745 zfsctl_snapshot_path_objset(zfsvfs_t *zfsvfs, uint64_t objsetid,
746 int path_len, char *full_path)
747 {
748 objset_t *os = zfsvfs->z_os;
749 fstrans_cookie_t cookie;
750 char *snapname;
751 boolean_t case_conflict;
752 uint64_t id, pos = 0;
753 int error = 0;
754
755 if (zfsvfs->z_vfs->vfs_mntpoint == NULL)
756 return (SET_ERROR(ENOENT));
757
758 cookie = spl_fstrans_mark();
759 snapname = kmem_alloc(ZFS_MAX_DATASET_NAME_LEN, KM_SLEEP);
760
761 while (error == 0) {
762 dsl_pool_config_enter(dmu_objset_pool(os), FTAG);
763 error = dmu_snapshot_list_next(zfsvfs->z_os,
764 ZFS_MAX_DATASET_NAME_LEN, snapname, &id, &pos,
765 &case_conflict);
766 dsl_pool_config_exit(dmu_objset_pool(os), FTAG);
767 if (error)
768 goto out;
769
770 if (id == objsetid)
771 break;
772 }
773
774 snprintf(full_path, path_len, "%s/.zfs/snapshot/%s",
775 zfsvfs->z_vfs->vfs_mntpoint, snapname);
776 out:
777 kmem_free(snapname, ZFS_MAX_DATASET_NAME_LEN);
778 spl_fstrans_unmark(cookie);
779
780 return (error);
781 }
782
783 /*
784 * Special case the handling of "..".
785 */
786 int
zfsctl_root_lookup(struct inode * dip,const char * name,struct inode ** ipp,int flags,cred_t * cr,int * direntflags,pathname_t * realpnp)787 zfsctl_root_lookup(struct inode *dip, const char *name, struct inode **ipp,
788 int flags, cred_t *cr, int *direntflags, pathname_t *realpnp)
789 {
790 zfsvfs_t *zfsvfs = ITOZSB(dip);
791 int error = 0;
792
793 ZFS_ENTER(zfsvfs);
794
795 if (strcmp(name, "..") == 0) {
796 *ipp = dip->i_sb->s_root->d_inode;
797 } else if (strcmp(name, ZFS_SNAPDIR_NAME) == 0) {
798 *ipp = zfsctl_inode_lookup(zfsvfs, ZFSCTL_INO_SNAPDIR,
799 &zpl_fops_snapdir, &zpl_ops_snapdir);
800 } else if (strcmp(name, ZFS_SHAREDIR_NAME) == 0) {
801 *ipp = zfsctl_inode_lookup(zfsvfs, ZFSCTL_INO_SHARES,
802 &zpl_fops_shares, &zpl_ops_shares);
803 } else {
804 *ipp = NULL;
805 }
806
807 if (*ipp == NULL)
808 error = SET_ERROR(ENOENT);
809
810 ZFS_EXIT(zfsvfs);
811
812 return (error);
813 }
814
815 /*
816 * Lookup entry point for the 'snapshot' directory. Try to open the
817 * snapshot if it exist, creating the pseudo filesystem inode as necessary.
818 */
819 int
zfsctl_snapdir_lookup(struct inode * dip,const char * name,struct inode ** ipp,int flags,cred_t * cr,int * direntflags,pathname_t * realpnp)820 zfsctl_snapdir_lookup(struct inode *dip, const char *name, struct inode **ipp,
821 int flags, cred_t *cr, int *direntflags, pathname_t *realpnp)
822 {
823 zfsvfs_t *zfsvfs = ITOZSB(dip);
824 uint64_t id;
825 int error;
826
827 ZFS_ENTER(zfsvfs);
828
829 error = dmu_snapshot_lookup(zfsvfs->z_os, name, &id);
830 if (error) {
831 ZFS_EXIT(zfsvfs);
832 return (error);
833 }
834
835 *ipp = zfsctl_inode_lookup(zfsvfs, ZFSCTL_INO_SNAPDIRS - id,
836 &simple_dir_operations, &simple_dir_inode_operations);
837 if (*ipp == NULL)
838 error = SET_ERROR(ENOENT);
839
840 ZFS_EXIT(zfsvfs);
841
842 return (error);
843 }
844
845 /*
846 * Renaming a directory under '.zfs/snapshot' will automatically trigger
847 * a rename of the snapshot to the new given name. The rename is confined
848 * to the '.zfs/snapshot' directory snapshots cannot be moved elsewhere.
849 */
850 int
zfsctl_snapdir_rename(struct inode * sdip,const char * snm,struct inode * tdip,const char * tnm,cred_t * cr,int flags)851 zfsctl_snapdir_rename(struct inode *sdip, const char *snm,
852 struct inode *tdip, const char *tnm, cred_t *cr, int flags)
853 {
854 zfsvfs_t *zfsvfs = ITOZSB(sdip);
855 char *to, *from, *real, *fsname;
856 int error;
857
858 if (!zfs_admin_snapshot)
859 return (SET_ERROR(EACCES));
860
861 ZFS_ENTER(zfsvfs);
862
863 to = kmem_alloc(ZFS_MAX_DATASET_NAME_LEN, KM_SLEEP);
864 from = kmem_alloc(ZFS_MAX_DATASET_NAME_LEN, KM_SLEEP);
865 real = kmem_alloc(ZFS_MAX_DATASET_NAME_LEN, KM_SLEEP);
866 fsname = kmem_alloc(ZFS_MAX_DATASET_NAME_LEN, KM_SLEEP);
867
868 if (zfsvfs->z_case == ZFS_CASE_INSENSITIVE) {
869 error = dmu_snapshot_realname(zfsvfs->z_os, snm, real,
870 ZFS_MAX_DATASET_NAME_LEN, NULL);
871 if (error == 0) {
872 snm = real;
873 } else if (error != ENOTSUP) {
874 goto out;
875 }
876 }
877
878 dmu_objset_name(zfsvfs->z_os, fsname);
879
880 error = zfsctl_snapshot_name(ITOZSB(sdip), snm,
881 ZFS_MAX_DATASET_NAME_LEN, from);
882 if (error == 0)
883 error = zfsctl_snapshot_name(ITOZSB(tdip), tnm,
884 ZFS_MAX_DATASET_NAME_LEN, to);
885 if (error == 0)
886 error = zfs_secpolicy_rename_perms(from, to, cr);
887 if (error != 0)
888 goto out;
889
890 /*
891 * Cannot move snapshots out of the snapdir.
892 */
893 if (sdip != tdip) {
894 error = SET_ERROR(EINVAL);
895 goto out;
896 }
897
898 /*
899 * No-op when names are identical.
900 */
901 if (strcmp(snm, tnm) == 0) {
902 error = 0;
903 goto out;
904 }
905
906 rw_enter(&zfs_snapshot_lock, RW_WRITER);
907
908 error = dsl_dataset_rename_snapshot(fsname, snm, tnm, B_FALSE);
909 if (error == 0)
910 (void) zfsctl_snapshot_rename(snm, tnm);
911
912 rw_exit(&zfs_snapshot_lock);
913 out:
914 kmem_free(from, ZFS_MAX_DATASET_NAME_LEN);
915 kmem_free(to, ZFS_MAX_DATASET_NAME_LEN);
916 kmem_free(real, ZFS_MAX_DATASET_NAME_LEN);
917 kmem_free(fsname, ZFS_MAX_DATASET_NAME_LEN);
918
919 ZFS_EXIT(zfsvfs);
920
921 return (error);
922 }
923
924 /*
925 * Removing a directory under '.zfs/snapshot' will automatically trigger
926 * the removal of the snapshot with the given name.
927 */
928 int
zfsctl_snapdir_remove(struct inode * dip,const char * name,cred_t * cr,int flags)929 zfsctl_snapdir_remove(struct inode *dip, const char *name, cred_t *cr,
930 int flags)
931 {
932 zfsvfs_t *zfsvfs = ITOZSB(dip);
933 char *snapname, *real;
934 int error;
935
936 if (!zfs_admin_snapshot)
937 return (SET_ERROR(EACCES));
938
939 ZFS_ENTER(zfsvfs);
940
941 snapname = kmem_alloc(ZFS_MAX_DATASET_NAME_LEN, KM_SLEEP);
942 real = kmem_alloc(ZFS_MAX_DATASET_NAME_LEN, KM_SLEEP);
943
944 if (zfsvfs->z_case == ZFS_CASE_INSENSITIVE) {
945 error = dmu_snapshot_realname(zfsvfs->z_os, name, real,
946 ZFS_MAX_DATASET_NAME_LEN, NULL);
947 if (error == 0) {
948 name = real;
949 } else if (error != ENOTSUP) {
950 goto out;
951 }
952 }
953
954 error = zfsctl_snapshot_name(ITOZSB(dip), name,
955 ZFS_MAX_DATASET_NAME_LEN, snapname);
956 if (error == 0)
957 error = zfs_secpolicy_destroy_perms(snapname, cr);
958 if (error != 0)
959 goto out;
960
961 error = zfsctl_snapshot_unmount(snapname, MNT_FORCE);
962 if ((error == 0) || (error == ENOENT))
963 error = dsl_destroy_snapshot(snapname, B_FALSE);
964 out:
965 kmem_free(snapname, ZFS_MAX_DATASET_NAME_LEN);
966 kmem_free(real, ZFS_MAX_DATASET_NAME_LEN);
967
968 ZFS_EXIT(zfsvfs);
969
970 return (error);
971 }
972
973 /*
974 * Creating a directory under '.zfs/snapshot' will automatically trigger
975 * the creation of a new snapshot with the given name.
976 */
977 int
zfsctl_snapdir_mkdir(struct inode * dip,const char * dirname,vattr_t * vap,struct inode ** ipp,cred_t * cr,int flags)978 zfsctl_snapdir_mkdir(struct inode *dip, const char *dirname, vattr_t *vap,
979 struct inode **ipp, cred_t *cr, int flags)
980 {
981 zfsvfs_t *zfsvfs = ITOZSB(dip);
982 char *dsname;
983 int error;
984
985 if (!zfs_admin_snapshot)
986 return (SET_ERROR(EACCES));
987
988 dsname = kmem_alloc(ZFS_MAX_DATASET_NAME_LEN, KM_SLEEP);
989
990 if (zfs_component_namecheck(dirname, NULL, NULL) != 0) {
991 error = SET_ERROR(EILSEQ);
992 goto out;
993 }
994
995 dmu_objset_name(zfsvfs->z_os, dsname);
996
997 error = zfs_secpolicy_snapshot_perms(dsname, cr);
998 if (error != 0)
999 goto out;
1000
1001 if (error == 0) {
1002 error = dmu_objset_snapshot_one(dsname, dirname);
1003 if (error != 0)
1004 goto out;
1005
1006 error = zfsctl_snapdir_lookup(dip, dirname, ipp,
1007 0, cr, NULL, NULL);
1008 }
1009 out:
1010 kmem_free(dsname, ZFS_MAX_DATASET_NAME_LEN);
1011
1012 return (error);
1013 }
1014
1015 /*
1016 * Flush everything out of the kernel's export table and such.
1017 * This is needed as once the snapshot is used over NFS, its
1018 * entries in svc_export and svc_expkey caches hold reference
1019 * to the snapshot mount point. There is no known way of flushing
1020 * only the entries related to the snapshot.
1021 */
1022 static void
exportfs_flush(void)1023 exportfs_flush(void)
1024 {
1025 char *argv[] = { "/usr/sbin/exportfs", "-f", NULL };
1026 char *envp[] = { NULL };
1027
1028 (void) call_usermodehelper(argv[0], argv, envp, UMH_WAIT_PROC);
1029 }
1030
1031 /*
1032 * Attempt to unmount a snapshot by making a call to user space.
1033 * There is no assurance that this can or will succeed, is just a
1034 * best effort. In the case where it does fail, perhaps because
1035 * it's in use, the unmount will fail harmlessly.
1036 */
1037 int
zfsctl_snapshot_unmount(const char * snapname,int flags)1038 zfsctl_snapshot_unmount(const char *snapname, int flags)
1039 {
1040 char *argv[] = { "/usr/bin/env", "umount", "-t", "zfs", "-n", NULL,
1041 NULL };
1042 char *envp[] = { NULL };
1043 zfs_snapentry_t *se;
1044 int error;
1045
1046 rw_enter(&zfs_snapshot_lock, RW_READER);
1047 if ((se = zfsctl_snapshot_find_by_name(snapname)) == NULL) {
1048 rw_exit(&zfs_snapshot_lock);
1049 return (SET_ERROR(ENOENT));
1050 }
1051 rw_exit(&zfs_snapshot_lock);
1052
1053 exportfs_flush();
1054
1055 if (flags & MNT_FORCE)
1056 argv[4] = "-fn";
1057 argv[5] = se->se_path;
1058 dprintf("unmount; path=%s\n", se->se_path);
1059 error = call_usermodehelper(argv[0], argv, envp, UMH_WAIT_PROC);
1060 zfsctl_snapshot_rele(se);
1061
1062
1063 /*
1064 * The umount system utility will return 256 on error. We must
1065 * assume this error is because the file system is busy so it is
1066 * converted to the more sensible EBUSY.
1067 */
1068 if (error)
1069 error = SET_ERROR(EBUSY);
1070
1071 return (error);
1072 }
1073
1074 int
zfsctl_snapshot_mount(struct path * path,int flags)1075 zfsctl_snapshot_mount(struct path *path, int flags)
1076 {
1077 struct dentry *dentry = path->dentry;
1078 struct inode *ip = dentry->d_inode;
1079 zfsvfs_t *zfsvfs;
1080 zfsvfs_t *snap_zfsvfs;
1081 zfs_snapentry_t *se;
1082 char *full_name, *full_path;
1083 char *argv[] = { "/usr/bin/env", "mount", "-t", "zfs", "-n", NULL, NULL,
1084 NULL };
1085 char *envp[] = { NULL };
1086 int error;
1087 struct path spath;
1088
1089 if (ip == NULL)
1090 return (SET_ERROR(EISDIR));
1091
1092 zfsvfs = ITOZSB(ip);
1093 ZFS_ENTER(zfsvfs);
1094
1095 full_name = kmem_zalloc(ZFS_MAX_DATASET_NAME_LEN, KM_SLEEP);
1096 full_path = kmem_zalloc(MAXPATHLEN, KM_SLEEP);
1097
1098 error = zfsctl_snapshot_name(zfsvfs, dname(dentry),
1099 ZFS_MAX_DATASET_NAME_LEN, full_name);
1100 if (error)
1101 goto error;
1102
1103 /*
1104 * Construct a mount point path from sb of the ctldir inode and dirent
1105 * name, instead of from d_path(), so that chroot'd process doesn't fail
1106 * on mount.zfs(8).
1107 */
1108 snprintf(full_path, MAXPATHLEN, "%s/.zfs/snapshot/%s",
1109 zfsvfs->z_vfs->vfs_mntpoint ? zfsvfs->z_vfs->vfs_mntpoint : "",
1110 dname(dentry));
1111
1112 /*
1113 * Multiple concurrent automounts of a snapshot are never allowed.
1114 * The snapshot may be manually mounted as many times as desired.
1115 */
1116 if (zfsctl_snapshot_ismounted(full_name)) {
1117 error = 0;
1118 goto error;
1119 }
1120
1121 /*
1122 * Attempt to mount the snapshot from user space. Normally this
1123 * would be done using the vfs_kern_mount() function, however that
1124 * function is marked GPL-only and cannot be used. On error we
1125 * careful to log the real error to the console and return EISDIR
1126 * to safely abort the automount. This should be very rare.
1127 *
1128 * If the user mode helper happens to return EBUSY, a concurrent
1129 * mount is already in progress in which case the error is ignored.
1130 * Take note that if the program was executed successfully the return
1131 * value from call_usermodehelper() will be (exitcode << 8 + signal).
1132 */
1133 dprintf("mount; name=%s path=%s\n", full_name, full_path);
1134 argv[5] = full_name;
1135 argv[6] = full_path;
1136 error = call_usermodehelper(argv[0], argv, envp, UMH_WAIT_PROC);
1137 if (error) {
1138 if (!(error & MOUNT_BUSY << 8)) {
1139 zfs_dbgmsg("Unable to automount %s error=%d",
1140 full_path, error);
1141 error = SET_ERROR(EISDIR);
1142 } else {
1143 /*
1144 * EBUSY, this could mean a concurrent mount, or the
1145 * snapshot has already been mounted at completely
1146 * different place. We return 0 so VFS will retry. For
1147 * the latter case the VFS will retry several times
1148 * and return ELOOP, which is probably not a very good
1149 * behavior.
1150 */
1151 error = 0;
1152 }
1153 goto error;
1154 }
1155
1156 /*
1157 * Follow down in to the mounted snapshot and set MNT_SHRINKABLE
1158 * to identify this as an automounted filesystem.
1159 */
1160 spath = *path;
1161 path_get(&spath);
1162 if (follow_down_one(&spath)) {
1163 snap_zfsvfs = ITOZSB(spath.dentry->d_inode);
1164 snap_zfsvfs->z_parent = zfsvfs;
1165 dentry = spath.dentry;
1166 spath.mnt->mnt_flags |= MNT_SHRINKABLE;
1167
1168 rw_enter(&zfs_snapshot_lock, RW_WRITER);
1169 se = zfsctl_snapshot_alloc(full_name, full_path,
1170 snap_zfsvfs->z_os->os_spa, dmu_objset_id(snap_zfsvfs->z_os),
1171 dentry);
1172 zfsctl_snapshot_add(se);
1173 zfsctl_snapshot_unmount_delay_impl(se, zfs_expire_snapshot);
1174 rw_exit(&zfs_snapshot_lock);
1175 }
1176 path_put(&spath);
1177 error:
1178 kmem_free(full_name, ZFS_MAX_DATASET_NAME_LEN);
1179 kmem_free(full_path, MAXPATHLEN);
1180
1181 ZFS_EXIT(zfsvfs);
1182
1183 return (error);
1184 }
1185
1186 /*
1187 * Get the snapdir inode from fid
1188 */
1189 int
zfsctl_snapdir_vget(struct super_block * sb,uint64_t objsetid,int gen,struct inode ** ipp)1190 zfsctl_snapdir_vget(struct super_block *sb, uint64_t objsetid, int gen,
1191 struct inode **ipp)
1192 {
1193 int error;
1194 struct path path;
1195 char *mnt;
1196 struct dentry *dentry;
1197
1198 mnt = kmem_alloc(MAXPATHLEN, KM_SLEEP);
1199
1200 error = zfsctl_snapshot_path_objset(sb->s_fs_info, objsetid,
1201 MAXPATHLEN, mnt);
1202 if (error)
1203 goto out;
1204
1205 /* Trigger automount */
1206 error = -kern_path(mnt, LOOKUP_FOLLOW|LOOKUP_DIRECTORY, &path);
1207 if (error)
1208 goto out;
1209
1210 path_put(&path);
1211 /*
1212 * Get the snapdir inode. Note, we don't want to use the above
1213 * path because it contains the root of the snapshot rather
1214 * than the snapdir.
1215 */
1216 *ipp = ilookup(sb, ZFSCTL_INO_SNAPDIRS - objsetid);
1217 if (*ipp == NULL) {
1218 error = SET_ERROR(ENOENT);
1219 goto out;
1220 }
1221
1222 /* check gen, see zfsctl_snapdir_fid */
1223 dentry = d_obtain_alias(igrab(*ipp));
1224 if (gen != (!IS_ERR(dentry) && d_mountpoint(dentry))) {
1225 iput(*ipp);
1226 *ipp = NULL;
1227 error = SET_ERROR(ENOENT);
1228 }
1229 if (!IS_ERR(dentry))
1230 dput(dentry);
1231 out:
1232 kmem_free(mnt, MAXPATHLEN);
1233 return (error);
1234 }
1235
1236 int
zfsctl_shares_lookup(struct inode * dip,char * name,struct inode ** ipp,int flags,cred_t * cr,int * direntflags,pathname_t * realpnp)1237 zfsctl_shares_lookup(struct inode *dip, char *name, struct inode **ipp,
1238 int flags, cred_t *cr, int *direntflags, pathname_t *realpnp)
1239 {
1240 zfsvfs_t *zfsvfs = ITOZSB(dip);
1241 znode_t *zp;
1242 znode_t *dzp;
1243 int error;
1244
1245 ZFS_ENTER(zfsvfs);
1246
1247 if (zfsvfs->z_shares_dir == 0) {
1248 ZFS_EXIT(zfsvfs);
1249 return (SET_ERROR(ENOTSUP));
1250 }
1251
1252 if ((error = zfs_zget(zfsvfs, zfsvfs->z_shares_dir, &dzp)) == 0) {
1253 error = zfs_lookup(dzp, name, &zp, 0, cr, NULL, NULL);
1254 zrele(dzp);
1255 }
1256
1257 ZFS_EXIT(zfsvfs);
1258
1259 return (error);
1260 }
1261
1262 /*
1263 * Initialize the various pieces we'll need to create and manipulate .zfs
1264 * directories. Currently this is unused but available.
1265 */
1266 void
zfsctl_init(void)1267 zfsctl_init(void)
1268 {
1269 avl_create(&zfs_snapshots_by_name, snapentry_compare_by_name,
1270 sizeof (zfs_snapentry_t), offsetof(zfs_snapentry_t,
1271 se_node_name));
1272 avl_create(&zfs_snapshots_by_objsetid, snapentry_compare_by_objsetid,
1273 sizeof (zfs_snapentry_t), offsetof(zfs_snapentry_t,
1274 se_node_objsetid));
1275 rw_init(&zfs_snapshot_lock, NULL, RW_DEFAULT, NULL);
1276 }
1277
1278 /*
1279 * Cleanup the various pieces we needed for .zfs directories. In particular
1280 * ensure the expiry timer is canceled safely.
1281 */
1282 void
zfsctl_fini(void)1283 zfsctl_fini(void)
1284 {
1285 avl_destroy(&zfs_snapshots_by_name);
1286 avl_destroy(&zfs_snapshots_by_objsetid);
1287 rw_destroy(&zfs_snapshot_lock);
1288 }
1289
1290 module_param(zfs_admin_snapshot, int, 0644);
1291 MODULE_PARM_DESC(zfs_admin_snapshot, "Enable mkdir/rmdir/mv in .zfs/snapshot");
1292
1293 module_param(zfs_expire_snapshot, int, 0644);
1294 MODULE_PARM_DESC(zfs_expire_snapshot, "Seconds to expire .zfs/snapshot");
1295