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.
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.
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]
23 * Copyright 2014 Nexenta Systems, Inc. All rights reserved.
24 * Copyright (c) 2003, 2010, Oracle and/or its affiliates. All rights reserved.
27 #include <sys/systm.h>
30 #include <nfs/export.h>
31 #include <sys/cmn_err.h>
34 #define PSEUDOFS_SUFFIX " (pseudo)"
37 * A version of VOP_FID that deals with a remote VOP_FID for nfs.
38 * If vp is an nfs node, nfs4_fid() returns EREMOTE, nfs3_fid() and nfs_fid()
39 * returns the filehandle of vp as its fid. When nfs uses fid to set the
40 * exportinfo filehandle template, a remote nfs filehandle would be too big for
41 * the fid of the exported directory. This routine remaps the value of the
42 * attribute va_nodeid of vp to be the fid of vp, so that the fid can fit.
44 * We need this fid mainly for setting up NFSv4 server namespace where an
45 * nfs filesystem is also part of it. Thus, need to be able to setup a pseudo
46 * exportinfo for an nfs node.
48 * e.g. mount a filesystem on top of a nfs dir, and then share the new mount
49 * (like exporting a local disk from a "diskless" client)
52 vop_fid_pseudo(vnode_t
*vp
, fid_t
*fidp
)
57 error
= VOP_FID(vp
, fidp
, NULL
);
60 * XXX nfs4_fid() does nothing and returns EREMOTE.
61 * XXX nfs3_fid()/nfs_fid() returns nfs filehandle as its fid
62 * which has a bigger length than local fid.
63 * NFS_FH4MAXDATA is the size of
64 * fhandle4_t.fh_xdata[NFS_FH4MAXDATA].
66 * Note: nfs[2,3,4]_fid() only gets called for diskless clients.
68 if (error
== EREMOTE
||
69 (error
== 0 && fidp
->fid_len
> NFS_FH4MAXDATA
)) {
71 va
.va_mask
= AT_NODEID
;
72 error
= VOP_GETATTR(vp
, &va
, 0, CRED(), NULL
);
76 fidp
->fid_len
= sizeof (va
.va_nodeid
);
77 bcopy(&va
.va_nodeid
, fidp
->fid_data
, fidp
->fid_len
);
85 * Get an nfsv4 vnode of the given fid from the visible list of an
86 * nfs filesystem or get the exi_vp if it is the root node.
89 nfs4_vget_pseudo(struct exportinfo
*exi
, vnode_t
**vpp
, fid_t
*fidp
)
92 struct exp_visible
*visp
;
95 /* check if the given fid is in the visible list */
97 for (visp
= exi
->exi_visible
; visp
; visp
= visp
->vis_next
) {
98 if (EQFID(fidp
, &visp
->vis_fid
)) {
99 VN_HOLD(visp
->vis_vp
);
105 /* check if the given fid is the same as the exported node */
107 bzero(&exp_fid
, sizeof (exp_fid
));
108 exp_fid
.fid_len
= MAXFIDSZ
;
109 error
= vop_fid_pseudo(exi
->exi_vp
, &exp_fid
);
113 if (EQFID(fidp
, &exp_fid
)) {
114 VN_HOLD(exi
->exi_vp
);
123 * Create a pseudo export entry
125 * This is an export entry that's created as the
126 * side-effect of a "real" export. As a part of
127 * a real export, the pathname to the export is
128 * checked to see if all the directory components
129 * are accessible via an NFSv4 client, i.e. are
130 * exported. If treeclimb_export() finds an unexported
131 * mountpoint along the path, then it calls this
132 * function to export it.
134 * This pseudo export differs from a real export in that
135 * it only allows read-only access. A "visible" list of
136 * directories is added to filter lookup and readdir results
137 * to only contain dirnames which lead to descendant shares.
139 * A visible list has a per-file-system scope. Any exportinfo
140 * struct (real or pseudo) can have a visible list as long as
141 * a) its export root is VROOT
142 * b) a descendant of the export root is shared
145 pseudo_exportfs(vnode_t
*vp
, fid_t
*fid
, struct exp_visible
*vis_head
,
146 struct exportdata
*exdata
)
148 struct exportinfo
*exi
;
149 struct exportdata
*kex
;
154 ASSERT(RW_WRITE_HELD(&exported_lock
));
156 fsid
= vp
->v_vfsp
->vfs_fsid
;
157 exi
= kmem_zalloc(sizeof (*exi
), KM_SLEEP
);
158 exi
->exi_fsid
= fsid
;
161 VN_HOLD(exi
->exi_vp
);
162 exi
->exi_visible
= vis_head
;
164 exi
->exi_volatile_dev
= (vfssw
[vp
->v_vfsp
->vfs_fstype
].vsw_flag
&
165 VSW_VOLATILEDEV
) ? 1 : 0;
166 mutex_init(&exi
->exi_lock
, NULL
, MUTEX_DEFAULT
, NULL
);
169 * Build up the template fhandle
171 exi
->exi_fh
.fh_fsid
= fsid
;
172 ASSERT(exi
->exi_fid
.fid_len
<= sizeof (exi
->exi_fh
.fh_xdata
));
173 exi
->exi_fh
.fh_xlen
= exi
->exi_fid
.fid_len
;
174 bcopy(exi
->exi_fid
.fid_data
, exi
->exi_fh
.fh_xdata
,
175 exi
->exi_fid
.fid_len
);
176 exi
->exi_fh
.fh_len
= sizeof (exi
->exi_fh
.fh_data
);
178 kex
= &exi
->exi_export
;
179 kex
->ex_flags
= EX_PSEUDO
;
181 vpathlen
= vp
->v_path
? strlen(vp
->v_path
) : 0;
182 kex
->ex_pathlen
= vpathlen
+ strlen(PSEUDOFS_SUFFIX
);
183 kex
->ex_path
= kmem_alloc(kex
->ex_pathlen
+ 1, KM_SLEEP
);
186 (void) strcpy(kex
->ex_path
, vp
->v_path
);
187 (void) strcpy(kex
->ex_path
+ vpathlen
, PSEUDOFS_SUFFIX
);
189 /* Transfer the secinfo data from exdata to this new pseudo node */
191 srv_secinfo_exp2pseu(&exi
->exi_export
, exdata
);
194 * Initialize auth cache and auth cache lock
196 for (i
= 0; i
< AUTH_TABLESIZE
; i
++) {
197 exi
->exi_cache
[i
] = kmem_alloc(sizeof (avl_tree_t
), KM_SLEEP
);
198 avl_create(exi
->exi_cache
[i
], nfsauth_cache_clnt_compar
,
199 sizeof (struct auth_cache_clnt
),
200 offsetof(struct auth_cache_clnt
, authc_link
));
202 rw_init(&exi
->exi_cache_lock
, NULL
, RW_DEFAULT
, NULL
);
205 * Insert the new entry at the front of the export list
213 * Free a list of visible directories
216 free_visible(struct exp_visible
*head
)
218 struct exp_visible
*visp
, *next
;
220 for (visp
= head
; visp
; visp
= next
) {
221 if (visp
->vis_vp
!= NULL
)
222 VN_RELE(visp
->vis_vp
);
224 next
= visp
->vis_next
;
225 srv_secinfo_list_free(visp
->vis_secinfo
, visp
->vis_seccnt
);
226 kmem_free(visp
, sizeof (*visp
));
231 * Connects newchild (or subtree with newchild in head)
232 * to the parent node. We always add it to the beginning
236 tree_add_child(treenode_t
*parent
, treenode_t
*newchild
)
238 newchild
->tree_parent
= parent
;
239 newchild
->tree_sibling
= parent
->tree_child_first
;
240 parent
->tree_child_first
= newchild
;
243 /* Look up among direct children a node with the exact tree_vis pointer */
245 tree_find_child_by_vis(treenode_t
*t
, exp_visible_t
*vis
)
247 for (t
= t
->tree_child_first
; t
; t
= t
->tree_sibling
)
248 if (t
->tree_vis
== vis
)
254 * Add new node to the head of subtree pointed by 'n'. n can be NULL.
255 * Interconnects the new treenode with exp_visible and exportinfo
259 tree_prepend_node(treenode_t
*n
, exp_visible_t
*v
, exportinfo_t
*e
)
261 treenode_t
*tnode
= kmem_zalloc(sizeof (*tnode
), KM_SLEEP
);
264 tnode
->tree_child_first
= n
;
265 n
->tree_parent
= tnode
;
278 * Removes node from the tree and frees the treenode struct.
279 * Does not free structures pointed by tree_exi and tree_vis,
280 * they should be already freed.
283 tree_remove_node(treenode_t
*node
)
285 treenode_t
*parent
= node
->tree_parent
;
286 treenode_t
*s
; /* s for sibling */
288 if (parent
== NULL
) {
289 kmem_free(node
, sizeof (*node
));
293 /* This node is first child */
294 if (parent
->tree_child_first
== node
) {
295 parent
->tree_child_first
= node
->tree_sibling
;
296 /* This node is not first child */
298 s
= parent
->tree_child_first
;
299 while (s
->tree_sibling
!= node
)
301 s
->tree_sibling
= s
->tree_sibling
->tree_sibling
;
303 kmem_free(node
, sizeof (*node
));
307 * When we export a new directory we need to add a new
308 * path segment through the pseudofs to reach the new
309 * directory. This new path is reflected in a list of
310 * directories added to the "visible" list.
312 * Here there are two lists of visible fids: one hanging off the
313 * pseudo exportinfo, and the one we want to add. It's possible
314 * that the two lists share a common path segment
315 * and have some common directories. We need to combine
316 * the lists so there's no duplicate entries. Where a common
317 * path component is found, the vis_count field is bumped.
319 * This example shows that the treenode chain (tree_head) and
320 * exp_visible chain (vis_head) can differ in length. The latter
321 * can be shorter. The outer loop must loop over the vis_head chain.
324 * mount -F ufs /dev/dsk/... /x/y
328 * When more_visible() is called during the second share,
329 * the existing namespace is following:
331 * treenode_t exportinfo_t v0 v1
332 * ns_root+---+ +------------+ +---+ +---+
333 * t0| / |........| E0 pseudo |->| x |->| a |
334 * +---+ +------------+ +---+ +---+
337 * t1| x |------------------------ /
341 * t2| a |-------------------------
342 * +---+........+------------+
346 * This is being added:
354 * t4| y |->| y |v3 +------------+ +---+ +---+
355 * +---+\ +---+ | E2 pseudo |->| a |->| b |
356 * | \....... >+------------+ +---+ +---+
358 * t5| a |--------------------------- /
361 * +---+-------------------------------
362 * t6| b | +------------+
363 * +---+..........>| E3 real |
366 * more_visible() will:
367 * - kmem_free() t3 and v2
368 * - add t4, t5, t6 as a child of t1 (t4 will become sibling of t2)
369 * - add v3 to the end of E0->exi_visible
371 * Note that v4 and v5 were already processed in pseudo_exportfs() and
372 * added to E2. The outer loop of more_visible() will loop only over v2
373 * and v3. The inner loop of more_visible() always loops over v0 and v1.
375 * Illustration for this scenario:
386 * namespace: +-----------+ visibles
387 * |exportinfo |-->v->a->b->c
388 * connect_point->+---+--->+-----------+
391 * | NEW treenode chain:
393 * | v |T1 +---+<-curr
397 * | a |T2 +---+<-tree_head
409 * The picture above illustrates the position of following pointers after line
410 * 'child = tree_find_child_by_vis(connect_point, curr->tree_vis);'
411 * was executed for the first time in the outer 'for' loop:
413 * connect_point..parent treenode in the EXISTING namespace to which the 'curr'
414 * should be connected. If 'connect_point' already has a child
415 * with the same value of tree_vis as the curr->tree_vis is,
416 * the 'curr' will not be added, but kmem_free()d.
417 * child..........the result of tree_find_child_by_vis()
418 * curr...........currently processed treenode from the NEW treenode chain
419 * tree_head......current head of the NEW treenode chain, in this case it was
420 * already moved down to its child - preparation for another loop
422 * What will happen to NEW treenodes N1, N2, N3, N4 in more_visible() later:
424 * N1: is merged - i.e. N1 is kmem_free()d. T0 has a child T1 with the same
426 * N2: is added as a new child of T1
427 * Note: not just N2, but the whole chain N2->N3->N4 is added
428 * N3: not processed separately (it was added together with N2)
429 * Even that N3 and T3 have same tree_vis, they are NOT merged, but will
431 * N4: not processed separately
434 more_visible(struct exportinfo
*exi
, treenode_t
*tree_head
)
436 struct exp_visible
*vp1
, *vp2
, *vis_head
, *tail
, *next
;
438 treenode_t
*child
, *curr
, *connect_point
;
440 vis_head
= tree_head
->tree_vis
;
441 connect_point
= exi
->exi_tree
;
444 * If exportinfo doesn't already have a visible
445 * list just assign the entire supplied list.
447 if (exi
->exi_visible
== NULL
) {
448 tree_add_child(exi
->exi_tree
, tree_head
);
449 exi
->exi_visible
= vis_head
;
453 /* The outer loop traverses the supplied list. */
454 for (vp1
= vis_head
; vp1
; vp1
= next
) {
456 next
= vp1
->vis_next
;
458 /* The inner loop searches the exportinfo visible list. */
459 for (vp2
= exi
->exi_visible
; vp2
; vp2
= vp2
->vis_next
) {
461 if (EQFID(&vp1
->vis_fid
, &vp2
->vis_fid
)) {
464 VN_RELE(vp1
->vis_vp
);
465 /* Transfer vis_exported from vp1 to vp2. */
466 if (vp1
->vis_exported
&& !vp2
->vis_exported
)
467 vp2
->vis_exported
= 1;
468 kmem_free(vp1
, sizeof (*vp1
));
469 tree_head
->tree_vis
= vp2
;
474 /* If not found - add to the end of the list */
476 tail
->vis_next
= vp1
;
477 vp1
->vis_next
= NULL
;
481 tree_head
= tree_head
->tree_child_first
;
483 if (! connect_point
) /* No longer merging */
486 * The inner loop could set curr->tree_vis to the EXISTING
487 * exp_visible vp2, so we can search among the children of
488 * connect_point for the curr->tree_vis. No need for EQFID.
490 child
= tree_find_child_by_vis(connect_point
, curr
->tree_vis
);
493 * Merging cannot be done if a valid child->tree_exi would
494 * be overwritten by a new curr->tree_exi.
497 (child
->tree_exi
== NULL
|| curr
->tree_exi
== NULL
)) {
498 if (curr
->tree_exi
) { /* Transfer the exportinfo */
499 child
->tree_exi
= curr
->tree_exi
;
500 child
->tree_exi
->exi_tree
= child
;
502 kmem_free(curr
, sizeof (treenode_t
));
503 connect_point
= child
;
504 } else { /* Branching */
505 tree_add_child(connect_point
, curr
);
506 connect_point
= NULL
;
512 * Remove one visible entry from the pseudo exportfs.
514 * When we unexport a directory, we have to remove path
515 * components from the visible list in the pseudo exportfs
516 * entry. The supplied visible contains one fid of one path
517 * component. The visible list of the export
518 * is checked against provided visible, matching fid has its
519 * reference count decremented. If a reference count drops to
520 * zero, then it means no paths now use this directory, so its
521 * fid can be removed from the visible list.
523 * When the last path is removed, the visible list will be null.
526 less_visible(struct exportinfo
*exi
, struct exp_visible
*vp1
)
528 struct exp_visible
*vp2
;
529 struct exp_visible
*prev
, *next
;
531 for (vp2
= exi
->exi_visible
, prev
= NULL
; vp2
; vp2
= next
) {
533 next
= vp2
->vis_next
;
537 * Decrement the ref count.
538 * Remove the entry if it's zero.
540 if (--vp2
->vis_count
<= 0) {
542 exi
->exi_visible
= next
;
544 prev
->vis_next
= next
;
545 VN_RELE(vp2
->vis_vp
);
546 srv_secinfo_list_free(vp2
->vis_secinfo
,
548 kmem_free(vp2
, sizeof (*vp1
));
557 * This function checks the path to a new export to
558 * check whether all the pathname components are
559 * exported. It works by climbing the file tree one
560 * component at a time via "..", crossing mountpoints
561 * if necessary until an export entry is found, or the
562 * system root is reached.
564 * If an unexported mountpoint is found, then
565 * a new pseudo export is added and the pathname from
566 * the mountpoint down to the export is added to the
567 * visible list for the new pseudo export. If an existing
568 * pseudo export is found, then the pathname is added
569 * to its visible list.
571 * Note that there's some tests for exportdir.
572 * The exportinfo entry that's passed as a parameter
573 * is that of the real export and exportdir is set
576 * Here is an example of a possible setup:
578 * () - a new fs; fs mount point
579 * EXPORT - a real exported node
580 * PSEUDO - a pseudo node
582 * f# - security flavor#
583 * (f#) - security flavor# propagated from its descendents
593 * ---------|------------------
595 * (c) EXPORT,f1(f2) (n) PSEUDO (f1,f2)
596 * | vis: "e","d" | vis: m,m,,p,q,"o"
598 * ------------------ -------------------
600 * (d) (e) f m EXPORT,f1(f2) p
604 * j (o) EXPORT,f2 q EXPORT f2
608 treeclimb_export(struct exportinfo
*exip
)
614 struct exportinfo
*exi
= NULL
;
615 struct exportinfo
*new_exi
= exip
;
616 struct exp_visible
*visp
;
617 struct exp_visible
*vis_head
= NULL
;
619 treenode_t
*tree_head
= NULL
;
621 ASSERT(RW_WRITE_HELD(&exported_lock
));
629 bzero(&fid
, sizeof (fid
));
630 fid
.fid_len
= MAXFIDSZ
;
631 error
= vop_fid_pseudo(vp
, &fid
);
637 * Check if this exportroot is a VROOT dir. If so,
638 * then attach the pseudonodes. If not, then
639 * continue .. traversal until we hit a VROOT
640 * export (pseudo or real).
642 exi
= checkexport4(&vp
->v_vfsp
->vfs_fsid
, &fid
, vp
);
643 if (exi
!= NULL
&& vp
->v_flag
& VROOT
) {
645 * Found an export info
647 * Extend the list of visible
648 * directories whether it's a pseudo
651 more_visible(exi
, tree_head
);
652 break; /* and climb no further */
657 * If at the root of the filesystem, need
658 * to traverse across the mountpoint
659 * and continue the climb on the mounted-on
662 if (vp
->v_flag
& VROOT
) {
666 * Found the root directory of a filesystem
667 * that isn't exported. Need to export
668 * this as a pseudo export so that an NFS v4
669 * client can do lookups in it.
671 new_exi
= pseudo_exportfs(vp
, &fid
, vis_head
,
676 if (VN_CMP(vp
, rootdir
)) {
679 * If sharing "/", new_exi is shared exportinfo
680 * (exip). Otherwise, new_exi is exportinfo
681 * created in pseudo_exportfs() above.
683 ns_root
= tree_prepend_node(tree_head
, 0,
694 * Do a getattr to obtain the nodeid (inode num)
697 va
.va_mask
= AT_NODEID
;
698 error
= VOP_GETATTR(vp
, &va
, 0, CRED(), NULL
);
703 * Add this directory fid to visible list
705 visp
= kmem_alloc(sizeof (*visp
), KM_SLEEP
);
708 visp
->vis_fid
= fid
; /* structure copy */
709 visp
->vis_ino
= va
.va_nodeid
;
711 visp
->vis_exported
= exportdir
;
712 visp
->vis_secinfo
= NULL
;
713 visp
->vis_seccnt
= 0;
714 visp
->vis_next
= vis_head
;
719 * Will set treenode's pointer to exportinfo to
720 * 1. shared exportinfo (exip) - if first visit here
721 * 2. freshly allocated pseudo export (if any)
724 tree_head
= tree_prepend_node(tree_head
, visp
, new_exi
);
728 * Now, do a ".." to find parent dir of vp.
730 error
= VOP_LOOKUP(vp
, "..", &dvp
, NULL
, 0, NULL
, CRED(),
733 if (error
== ENOTDIR
&& exportdir
) {
751 * We can have set error due to error in:
752 * 1. vop_fid_pseudo()
755 * We must free pseudo exportinfos, visibles and treenodes.
756 * Visibles are referenced from treenode_t::tree_vis and
757 * exportinfo_t::exi_visible. To avoid double freeing, only
758 * exi_visible pointer is used, via exi_rele(), for the clean-up.
761 /* Free unconnected visibles, if there are any. */
763 free_visible(vis_head
);
765 /* Connect unconnected exportinfo, if there is any. */
766 if (new_exi
&& new_exi
!= exip
)
767 tree_head
= tree_prepend_node(tree_head
, 0, new_exi
);
770 treenode_t
*t2
= tree_head
;
771 exportinfo_t
*e
= tree_head
->tree_exi
;
772 /* exip will be freed in exportfs() */
773 if (e
&& e
!= exip
) {
777 tree_head
= tree_head
->tree_child_first
;
778 kmem_free(t2
, sizeof (*t2
));
786 * Walk up the tree and:
787 * 1. release pseudo exportinfo if it has no child
788 * 2. release visible in parent's exportinfo
789 * 3. delete non-exported leaf nodes from tree
791 * Deleting of nodes will start only if the unshared
792 * node was a leaf node.
793 * Deleting of nodes will finish when we reach a node which
794 * has children or is a real export, then we might still need
795 * to continue releasing visibles, until we reach VROOT node.
798 treeclimb_unexport(struct exportinfo
*exip
)
800 treenode_t
*tnode
, *old_nd
;
802 ASSERT(RW_WRITE_HELD(&exported_lock
));
804 tnode
= exip
->exi_tree
;
806 * The unshared exportinfo was unlinked in unexport().
807 * Zeroing tree_exi ensures that we will skip it.
809 tnode
->tree_exi
= NULL
;
811 if (tnode
->tree_vis
) /* system root has tree_vis == NULL */
812 tnode
->tree_vis
->vis_exported
= 0;
816 /* Stop at VROOT node which is exported or has child */
817 if (TREE_ROOT(tnode
) &&
818 (TREE_EXPORTED(tnode
) || tnode
->tree_child_first
))
821 /* Release pseudo export if it has no child */
822 if (TREE_ROOT(tnode
) && !TREE_EXPORTED(tnode
) &&
823 tnode
->tree_child_first
== 0) {
824 export_unlink(tnode
->tree_exi
);
825 exi_rele(tnode
->tree_exi
);
828 /* Release visible in parent's exportinfo */
830 less_visible(vis2exi(tnode
), tnode
->tree_vis
);
832 /* Continue with parent */
834 tnode
= tnode
->tree_parent
;
836 /* Remove itself, if this is a leaf and non-exported node */
837 if (old_nd
->tree_child_first
== NULL
&& !TREE_EXPORTED(old_nd
))
838 tree_remove_node(old_nd
);
843 * Traverse backward across mountpoint from the
844 * root vnode of a filesystem to its mounted-on
848 untraverse(vnode_t
*vp
)
850 vnode_t
*tvp
, *nextvp
;
854 if (! (tvp
->v_flag
& VROOT
))
857 /* lock vfs to prevent unmount of this vfs */
858 vfs_lock_wait(tvp
->v_vfsp
);
860 if ((nextvp
= tvp
->v_vfsp
->vfs_vnodecovered
) == NULL
) {
861 vfs_unlock(tvp
->v_vfsp
);
866 * Hold nextvp to prevent unmount. After unlock vfs and
867 * rele tvp, any number of overlays could be unmounted.
868 * Putting a hold on vfs_vnodecovered will only allow
869 * tvp's vfs to be unmounted. Of course if caller placed
870 * extra hold on vp before calling untraverse, the following
871 * hold would not be needed. Since prev actions of caller
872 * are unknown, we need to hold here just to be safe.
875 vfs_unlock(tvp
->v_vfsp
);
884 * Given an exportinfo, climb up to find the exportinfo for the VROOT
889 * a (VROOT) pseudo-exportinfo
897 * where c is in the same filesystem as a.
898 * So, get_root_export(*exportinfo_for_c) returns exportinfo_for_a
900 * If d is shared, then c will be put into a's visible list.
901 * Note: visible list is per filesystem and is attached to the
905 get_root_export(struct exportinfo
*exip
)
907 treenode_t
*tnode
= exip
->exi_tree
;
908 exportinfo_t
*exi
= NULL
;
911 if (TREE_ROOT(tnode
)) {
912 exi
= tnode
->tree_exi
;
915 tnode
= tnode
->tree_parent
;
922 * Return true if the supplied vnode has a sub-directory exported.
925 has_visible(struct exportinfo
*exi
, vnode_t
*vp
)
927 struct exp_visible
*visp
;
929 bool_t vp_is_exported
;
931 vp_is_exported
= VN_CMP(vp
, exi
->exi_vp
);
934 * An exported root vnode has a sub-dir shared if it has a visible list.
935 * i.e. if it does not have a visible list, then there is no node in
936 * this filesystem leads to any other shared node.
938 if (vp_is_exported
&& (vp
->v_flag
& VROOT
))
939 return (exi
->exi_visible
? 1 : 0);
942 * Only the exportinfo of a fs root node may have a visible list.
943 * Either it is a pseudo root node, or a real exported root node.
945 exi
= get_root_export(exi
);
947 if (!exi
->exi_visible
)
950 /* Get the fid of the vnode */
951 bzero(&fid
, sizeof (fid
));
952 fid
.fid_len
= MAXFIDSZ
;
953 if (vop_fid_pseudo(vp
, &fid
) != 0) {
958 * See if vp is in the visible list of the root node exportinfo.
960 for (visp
= exi
->exi_visible
; visp
; visp
= visp
->vis_next
) {
961 if (EQFID(&fid
, &visp
->vis_fid
)) {
963 * If vp is an exported non-root node with only 1 path
964 * count (for itself), it indicates no sub-dir shared
965 * using this vp as a path.
967 if (vp_is_exported
&& visp
->vis_count
< 2)
978 * Returns true if the supplied vnode is visible
979 * in this export. If vnode is visible, return
980 * vis_exported in expseudo.
983 nfs_visible(struct exportinfo
*exi
, vnode_t
*vp
, int *expseudo
)
985 struct exp_visible
*visp
;
989 * First check to see if vp is export root.
991 * A pseudo export root can never be exported
992 * (it would be a real export then); however,
993 * it is always visible. If a pseudo root object
994 * was exported by server admin, then the entire
995 * pseudo exportinfo (and all visible entries) would
996 * be destroyed. A pseudo exportinfo only exists
997 * to provide access to real (descendant) export(s).
999 * Previously, rootdir was special cased here; however,
1000 * the export root special case handles the rootdir
1003 if (VN_CMP(vp
, exi
->exi_vp
)) {
1009 * Only a PSEUDO node has a visible list or an exported VROOT
1010 * node may have a visible list.
1013 exi
= get_root_export(exi
);
1015 /* Get the fid of the vnode */
1017 bzero(&fid
, sizeof (fid
));
1018 fid
.fid_len
= MAXFIDSZ
;
1019 if (vop_fid_pseudo(vp
, &fid
) != 0) {
1025 * We can't trust VN_CMP() above because of LOFS.
1026 * Even though VOP_CMP will do the right thing for LOFS
1027 * objects, VN_CMP will short circuit out early when the
1028 * vnode ops ptrs are different. Just in case we're dealing
1029 * with LOFS, compare exi_fid/fsid here.
1031 * expseudo is not set because this is not an export
1033 if (EQFID(&exi
->exi_fid
, &fid
) &&
1034 EQFSID(&exi
->exi_fsid
, &vp
->v_vfsp
->vfs_fsid
)) {
1040 /* See if it matches any fid in the visible list */
1042 for (visp
= exi
->exi_visible
; visp
; visp
= visp
->vis_next
) {
1043 if (EQFID(&fid
, &visp
->vis_fid
)) {
1044 *expseudo
= visp
->vis_exported
;
1055 * Returns true if the supplied vnode is the
1056 * directory of an export point.
1059 nfs_exported(struct exportinfo
*exi
, vnode_t
*vp
)
1061 struct exp_visible
*visp
;
1065 * First check to see if vp is the export root
1066 * This check required for the case of lookup ..
1067 * where .. is a V_ROOT vnode and a pseudo exportroot.
1068 * Pseudo export root objects do not have an entry
1069 * in the visible list even though every V_ROOT
1070 * pseudonode is visible. It is safe to compare
1071 * vp here because pseudo_exportfs put a hold on
1072 * it when exi_vp was initialized.
1074 * Note: VN_CMP() won't match for LOFS shares, but they're
1075 * handled below w/EQFID/EQFSID.
1077 if (VN_CMP(vp
, exi
->exi_vp
))
1080 /* Get the fid of the vnode */
1082 bzero(&fid
, sizeof (fid
));
1083 fid
.fid_len
= MAXFIDSZ
;
1084 if (vop_fid_pseudo(vp
, &fid
) != 0)
1087 if (EQFID(&fid
, &exi
->exi_fid
) &&
1088 EQFSID(&vp
->v_vfsp
->vfs_fsid
, &exi
->exi_fsid
)) {
1092 /* See if it matches any fid in the visible list */
1094 for (visp
= exi
->exi_visible
; visp
; visp
= visp
->vis_next
) {
1095 if (EQFID(&fid
, &visp
->vis_fid
))
1096 return (visp
->vis_exported
);
1103 * Returns true if the supplied inode is visible
1104 * in this export. This function is used by
1105 * readdir which uses inode numbers from the
1108 * NOTE: this code does not match inode number for ".",
1109 * but it isn't required because NFS4 server rddir
1110 * skips . and .. entries.
1113 nfs_visible_inode(struct exportinfo
*exi
, ino64_t ino
, int *expseudo
)
1115 struct exp_visible
*visp
;
1118 * Only a PSEUDO node has a visible list or an exported VROOT
1119 * node may have a visible list.
1122 exi
= get_root_export(exi
);
1124 for (visp
= exi
->exi_visible
; visp
; visp
= visp
->vis_next
)
1125 if ((u_longlong_t
)ino
== visp
->vis_ino
) {
1126 *expseudo
= visp
->vis_exported
;