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 2014 Nexenta Systems, Inc.  All rights reserved.
  24  * Copyright (c) 2003, 2010, Oracle and/or its affiliates. All rights reserved.
  25  */
  26 
  27 #include <sys/systm.h>
  28 
  29 #include <nfs/nfs.h>
  30 #include <nfs/export.h>
  31 #include <sys/cmn_err.h>
  32 #include <sys/avl.h>
  33 
  34 #define PSEUDOFS_SUFFIX         " (pseudo)"
  35 
  36 /*
  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.
  43  *
  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.
  47  *
  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)
  50  */
  51 int
  52 vop_fid_pseudo(vnode_t *vp, fid_t *fidp)
  53 {
  54         struct vattr va;
  55         int error;
  56 
  57         error = VOP_FID(vp, fidp, NULL);
  58 
  59         /*
  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].
  65          *
  66          * Note: nfs[2,3,4]_fid() only gets called for diskless clients.
  67          */
  68         if (error == EREMOTE ||
  69             (error == 0 && fidp->fid_len > NFS_FH4MAXDATA)) {
  70 
  71                 va.va_mask = AT_NODEID;
  72                 error = VOP_GETATTR(vp, &va, 0, CRED(), NULL);
  73                 if (error)
  74                         return (error);
  75 
  76                 fidp->fid_len = sizeof (va.va_nodeid);
  77                 bcopy(&va.va_nodeid, fidp->fid_data, fidp->fid_len);
  78                 return (0);
  79         }
  80 
  81         return (error);
  82 }
  83 
  84 /*
  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.
  87  */
  88 int
  89 nfs4_vget_pseudo(struct exportinfo *exi, vnode_t **vpp, fid_t *fidp)
  90 {
  91         fid_t exp_fid;
  92         struct exp_visible *visp;
  93         int error;
  94 
  95         /* check if the given fid is in the visible list */
  96 
  97         for (visp = exi->exi_visible; visp; visp = visp->vis_next) {
  98                 if (EQFID(fidp, &visp->vis_fid)) {
  99                         VN_HOLD(visp->vis_vp);
 100                         *vpp = visp->vis_vp;
 101                         return (0);
 102                 }
 103         }
 104 
 105         /* check if the given fid is the same as the exported node */
 106 
 107         bzero(&exp_fid, sizeof (exp_fid));
 108         exp_fid.fid_len = MAXFIDSZ;
 109         error = vop_fid_pseudo(exi->exi_vp, &exp_fid);
 110         if (error)
 111                 return (error);
 112 
 113         if (EQFID(fidp, &exp_fid)) {
 114                 VN_HOLD(exi->exi_vp);
 115                 *vpp = exi->exi_vp;
 116                 return (0);
 117         }
 118 
 119         return (ENOENT);
 120 }
 121 
 122 /*
 123  * Create a pseudo export entry
 124  *
 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.
 133  *
 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.
 138  *
 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
 143  */
 144 struct exportinfo *
 145 pseudo_exportfs(vnode_t *vp, fid_t *fid, struct exp_visible *vis_head,
 146             struct exportdata *exdata)
 147 {
 148         struct exportinfo *exi;
 149         struct exportdata *kex;
 150         fsid_t fsid;
 151         int vpathlen;
 152         int i;
 153 
 154         ASSERT(RW_WRITE_HELD(&exported_lock));
 155 
 156         fsid = vp->v_vfsp->vfs_fsid;
 157         exi = kmem_zalloc(sizeof (*exi), KM_SLEEP);
 158         exi->exi_fsid = fsid;
 159         exi->exi_fid = *fid;
 160         exi->exi_vp = vp;
 161         VN_HOLD(exi->exi_vp);
 162         exi->exi_visible = vis_head;
 163         exi->exi_count = 1;
 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);
 167 
 168         /*
 169          * Build up the template fhandle
 170          */
 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);
 177 
 178         kex = &exi->exi_export;
 179         kex->ex_flags = EX_PSEUDO;
 180 
 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);
 184 
 185         if (vpathlen)
 186                 (void) strcpy(kex->ex_path, vp->v_path);
 187         (void) strcpy(kex->ex_path + vpathlen, PSEUDOFS_SUFFIX);
 188 
 189         /* Transfer the secinfo data from exdata to this new pseudo node */
 190         if (exdata)
 191                 srv_secinfo_exp2pseu(&exi->exi_export, exdata);
 192 
 193         /*
 194          * Initialize auth cache and auth cache lock
 195          */
 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));
 201         }
 202         rw_init(&exi->exi_cache_lock, NULL, RW_DEFAULT, NULL);
 203 
 204         /*
 205          * Insert the new entry at the front of the export list
 206          */
 207         export_link(exi);
 208 
 209         return (exi);
 210 }
 211 
 212 /*
 213  * Free a list of visible directories
 214  */
 215 void
 216 free_visible(struct exp_visible *head)
 217 {
 218         struct exp_visible *visp, *next;
 219 
 220         for (visp = head; visp; visp = next) {
 221                 if (visp->vis_vp != NULL)
 222                         VN_RELE(visp->vis_vp);
 223 
 224                 next = visp->vis_next;
 225                 srv_secinfo_list_free(visp->vis_secinfo, visp->vis_seccnt);
 226                 kmem_free(visp, sizeof (*visp));
 227         }
 228 }
 229 
 230 /*
 231  * Connects newchild (or subtree with newchild in head)
 232  * to the parent node. We always add it to the beginning
 233  * of sibling list.
 234  */
 235 static void
 236 tree_add_child(treenode_t *parent, treenode_t *newchild)
 237 {
 238         newchild->tree_parent = parent;
 239         newchild->tree_sibling = parent->tree_child_first;
 240         parent->tree_child_first = newchild;
 241 }
 242 
 243 /* Look up among direct children a node with the exact tree_vis pointer */
 244 static treenode_t *
 245 tree_find_child_by_vis(treenode_t *t, exp_visible_t *vis)
 246 {
 247         for (t = t->tree_child_first; t; t = t->tree_sibling)
 248                 if (t->tree_vis == vis)
 249                         return (t);
 250         return (NULL);
 251 }
 252 
 253 /*
 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
 256  * if needed.
 257  */
 258 static treenode_t *
 259 tree_prepend_node(treenode_t *n, exp_visible_t *v, exportinfo_t *e)
 260 {
 261         treenode_t *tnode = kmem_zalloc(sizeof (*tnode), KM_SLEEP);
 262 
 263         if (n) {
 264                 tnode->tree_child_first = n;
 265                 n->tree_parent = tnode;
 266         }
 267         if (v) {
 268                 tnode->tree_vis = v;
 269         }
 270         if (e) {
 271                 tnode->tree_exi = e;
 272                 e->exi_tree = tnode;
 273         }
 274         return (tnode);
 275 }
 276 
 277 /*
 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.
 281  */
 282 static void
 283 tree_remove_node(treenode_t *node)
 284 {
 285         treenode_t *parent = node->tree_parent;
 286         treenode_t *s; /* s for sibling */
 287 
 288         if (parent == NULL) {
 289                 kmem_free(node, sizeof (*node));
 290                 ns_root = NULL;
 291                 return;
 292         }
 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 */
 297         } else {
 298                 s = parent->tree_child_first;
 299                 while (s->tree_sibling != node)
 300                         s = s->tree_sibling;
 301                 s->tree_sibling = s->tree_sibling->tree_sibling;
 302         }
 303         kmem_free(node, sizeof (*node));
 304 }
 305 
 306 /*
 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.
 311  *
 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.
 318  *
 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.
 322  *
 323  * share /x/a
 324  * mount -F ufs /dev/dsk/... /x/y
 325  * mkdir -p /x/y/a/b
 326  * share  /x/y/a/b
 327  *
 328  * When more_visible() is called during the second share,
 329  * the existing namespace is following:
 330  *                                   exp_visible_t
 331  *   treenode_t       exportinfo_t      v0     v1
 332  * ns_root+---+        +------------+  +---+  +---+
 333  *      t0| / |........| E0 pseudo  |->| x |->| a |
 334  *        +---+        +------------+  +---+  +---+
 335  *          |                           /    /
 336  *        +---+                        /    /
 337  *      t1| x |------------------------    /
 338  *        +---+                           /
 339  *          |                            /
 340  *        +---+                         /
 341  *      t2| a |-------------------------
 342  *        +---+........+------------+
 343  *                     | E1 real    |
 344  *                     +------------+
 345  *
 346  * This is being added:
 347  *
 348  *    tree_head  vis_head
 349  *        +---+  +---+
 350  *      t3| x |->| x |v2
 351  *        +---+  +---+
 352  *          |      |
 353  *        +---+  +---+                     v4     v5
 354  *      t4| y |->| y |v3  +------------+  +---+  +---+
 355  *        +---+\ +---+    | E2 pseudo  |->| a |->| b |
 356  *          |   \....... >+------------+  +---+  +---+
 357  *        +---+                           /      /
 358  *      t5| a |---------------------------      /
 359  *        +---+                                /
 360  *          |                                 /
 361  *        +---+-------------------------------
 362  *      t6| b |           +------------+
 363  *        +---+..........>| E3 real    |
 364  *                        +------------+
 365  *
 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
 370  *
 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.
 374  *
 375  * Illustration for this scenario:
 376  *
 377  * mkdir -p /v/a/b/c
 378  * share /v/a/b/c
 379  * mkdir /v/a/b/c1
 380  * mkdir -p /v/a1
 381  * mv /v/a/b /v/a1
 382  * share /v/a1/b/c1
 383  *
 384  *           EXISTING
 385  *           treenode
 386  *           namespace:    +-----------+   visibles
 387  *                         |exportinfo |-->v->a->b->c
 388  * connect_point->+---+--->+-----------+
 389  *                | / |T0
 390  *                +---+
 391  *                  |                            NEW treenode chain:
 392  *         child->+---+
 393  *                | v |T1                          +---+<-curr
 394  *                +---+                          N1| v |
 395  *                  |                              +---+
 396  *                +---+                              |
 397  *                | a |T2                          +---+<-tree_head
 398  *                +---+                          N2| a1|
 399  *                  |                              +---+
 400  *                +---+                              |
 401  *                | b |T3                          +---+
 402  *                +---+                          N3| b |
 403  *                  |                              +---+
 404  *                +---+                              |
 405  *                | c |T4                          +---+
 406  *                +---+                          N4| c1|
 407  *                                                 +---+
 408  *
 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:
 412  *
 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
 421  *
 422  * What will happen to NEW treenodes N1, N2, N3, N4 in more_visible() later:
 423  *
 424  * N1: is merged - i.e. N1 is kmem_free()d. T0 has a child T1 with the same
 425  *     tree_vis as N1
 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
 430  *     become duplicates.
 431  * N4: not processed separately
 432  */
 433 static void
 434 more_visible(struct exportinfo *exi, treenode_t *tree_head)
 435 {
 436         struct exp_visible *vp1, *vp2, *vis_head, *tail, *next;
 437         int found;
 438         treenode_t *child, *curr, *connect_point;
 439 
 440         vis_head = tree_head->tree_vis;
 441         connect_point = exi->exi_tree;
 442 
 443         /*
 444          * If exportinfo doesn't already have a visible
 445          * list just assign the entire supplied list.
 446          */
 447         if (exi->exi_visible == NULL) {
 448                 tree_add_child(exi->exi_tree, tree_head);
 449                 exi->exi_visible = vis_head;
 450                 return;
 451         }
 452 
 453         /* The outer loop traverses the supplied list. */
 454         for (vp1 = vis_head; vp1; vp1 = next) {
 455                 found = 0;
 456                 next = vp1->vis_next;
 457 
 458                 /* The inner loop searches the exportinfo visible list. */
 459                 for (vp2 = exi->exi_visible; vp2; vp2 = vp2->vis_next) {
 460                         tail = vp2;
 461                         if (EQFID(&vp1->vis_fid, &vp2->vis_fid)) {
 462                                 found = 1;
 463                                 vp2->vis_count++;
 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;
 470                                 break;
 471                         }
 472                 }
 473 
 474                 /* If not found - add to the end of the list */
 475                 if (! found) {
 476                         tail->vis_next = vp1;
 477                         vp1->vis_next = NULL;
 478                 }
 479 
 480                 curr = tree_head;
 481                 tree_head = tree_head->tree_child_first;
 482 
 483                 if (! connect_point) /* No longer merging */
 484                         continue;
 485                 /*
 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.
 489                  */
 490                 child = tree_find_child_by_vis(connect_point, curr->tree_vis);
 491 
 492                 /*
 493                  * Merging cannot be done if a valid child->tree_exi would
 494                  * be overwritten by a new curr->tree_exi.
 495                  */
 496                 if (child &&
 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;
 501                         }
 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;
 507                 }
 508         }
 509 }
 510 
 511 /*
 512  * Remove one visible entry from the pseudo exportfs.
 513  *
 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.
 522  *
 523  * When the last path is removed, the visible list will be null.
 524  */
 525 static void
 526 less_visible(struct exportinfo *exi, struct exp_visible *vp1)
 527 {
 528         struct exp_visible *vp2;
 529         struct exp_visible *prev, *next;
 530 
 531         for (vp2 = exi->exi_visible, prev = NULL; vp2; vp2 = next) {
 532 
 533                 next = vp2->vis_next;
 534 
 535                 if (vp1 == vp2) {
 536                         /*
 537                          * Decrement the ref count.
 538                          * Remove the entry if it's zero.
 539                          */
 540                         if (--vp2->vis_count <= 0) {
 541                                 if (prev == NULL)
 542                                         exi->exi_visible = next;
 543                                 else
 544                                         prev->vis_next = next;
 545                                 VN_RELE(vp2->vis_vp);
 546                                 srv_secinfo_list_free(vp2->vis_secinfo,
 547                                     vp2->vis_seccnt);
 548                                 kmem_free(vp2, sizeof (*vp1));
 549                         }
 550                         break;
 551                 }
 552                 prev = vp2;
 553         }
 554 }
 555 
 556 /*
 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.
 563  *
 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.
 570  *
 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
 574  * for this case.
 575  *
 576  * Here is an example of a possible setup:
 577  *
 578  * () - a new fs; fs mount point
 579  * EXPORT - a real exported node
 580  * PSEUDO - a pseudo node
 581  * vis - visible list
 582  * f# - security flavor#
 583  * (f#) - security flavor# propagated from its descendents
 584  * "" - covered vnode
 585  *
 586  *
 587  *                 /
 588  *                 |
 589  *                 (a) PSEUDO (f1,f2)
 590  *                 |   vis: b,b,"c","n"
 591  *                 |
 592  *                 b
 593  *        ---------|------------------
 594  *        |                          |
 595  *        (c) EXPORT,f1(f2)          (n) PSEUDO (f1,f2)
 596  *        |   vis: "e","d"           |   vis: m,m,,p,q,"o"
 597  *        |                          |
 598  *  ------------------          -------------------
 599  *  |        |        |         |                  |
 600  *  (d)      (e)      f         m EXPORT,f1(f2)    p
 601  *  EXPORT   EXPORT             |                  |
 602  *  f1       f2                 |                  |
 603  *           |                  |                  |
 604  *           j                 (o) EXPORT,f2       q EXPORT f2
 605  *
 606  */
 607 int
 608 treeclimb_export(struct exportinfo *exip)
 609 {
 610         vnode_t *dvp, *vp;
 611         fid_t fid;
 612         int error;
 613         int exportdir;
 614         struct exportinfo *exi = NULL;
 615         struct exportinfo *new_exi = exip;
 616         struct exp_visible *visp;
 617         struct exp_visible *vis_head = NULL;
 618         struct vattr va;
 619         treenode_t *tree_head = NULL;
 620 
 621         ASSERT(RW_WRITE_HELD(&exported_lock));
 622 
 623         vp = exip->exi_vp;
 624         VN_HOLD(vp);
 625         exportdir = 1;
 626 
 627         for (;;) {
 628 
 629                 bzero(&fid, sizeof (fid));
 630                 fid.fid_len = MAXFIDSZ;
 631                 error = vop_fid_pseudo(vp, &fid);
 632                 if (error)
 633                         break;
 634 
 635                 if (! exportdir) {
 636                         /*
 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).
 641                          */
 642                         exi = checkexport4(&vp->v_vfsp->vfs_fsid, &fid, vp);
 643                         if (exi != NULL && vp->v_flag & VROOT) {
 644                                 /*
 645                                  * Found an export info
 646                                  *
 647                                  * Extend the list of visible
 648                                  * directories whether it's a pseudo
 649                                  * or a real export.
 650                                  */
 651                                 more_visible(exi, tree_head);
 652                                 break;  /* and climb no further */
 653                         }
 654                 }
 655 
 656                 /*
 657                  * If at the root of the filesystem, need
 658                  * to traverse across the mountpoint
 659                  * and continue the climb on the mounted-on
 660                  * filesystem.
 661                  */
 662                 if (vp->v_flag & VROOT) {
 663 
 664                         if (! exportdir) {
 665                                 /*
 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.
 670                                  */
 671                                 new_exi = pseudo_exportfs(vp, &fid, vis_head,
 672                                     NULL);
 673                                 vis_head = NULL;
 674                         }
 675 
 676                         if (VN_CMP(vp, rootdir)) {
 677                                 /* at system root */
 678                                 /*
 679                                  * If sharing "/", new_exi is shared exportinfo
 680                                  * (exip). Otherwise, new_exi is exportinfo
 681                                  * created in pseudo_exportfs() above.
 682                                  */
 683                                 ns_root = tree_prepend_node(tree_head, 0,
 684                                     new_exi);
 685                                 break;
 686                         }
 687 
 688                         vp = untraverse(vp);
 689                         exportdir = 0;
 690                         continue;
 691                 }
 692 
 693                 /*
 694                  * Do a getattr to obtain the nodeid (inode num)
 695                  * for this vnode.
 696                  */
 697                 va.va_mask = AT_NODEID;
 698                 error = VOP_GETATTR(vp, &va, 0, CRED(), NULL);
 699                 if (error)
 700                         break;
 701 
 702                 /*
 703                  *  Add this directory fid to visible list
 704                  */
 705                 visp = kmem_alloc(sizeof (*visp), KM_SLEEP);
 706                 VN_HOLD(vp);
 707                 visp->vis_vp = vp;
 708                 visp->vis_fid = fid;         /* structure copy */
 709                 visp->vis_ino = va.va_nodeid;
 710                 visp->vis_count = 1;
 711                 visp->vis_exported = exportdir;
 712                 visp->vis_secinfo = NULL;
 713                 visp->vis_seccnt = 0;
 714                 visp->vis_next = vis_head;
 715                 vis_head = visp;
 716 
 717 
 718                 /*
 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)
 722                  * 3. null otherwise
 723                  */
 724                 tree_head = tree_prepend_node(tree_head, visp, new_exi);
 725                 new_exi = NULL;
 726 
 727                 /*
 728                  * Now, do a ".." to find parent dir of vp.
 729                  */
 730                 error = VOP_LOOKUP(vp, "..", &dvp, NULL, 0, NULL, CRED(),
 731                     NULL, NULL, NULL);
 732 
 733                 if (error == ENOTDIR && exportdir) {
 734                         dvp = exip->exi_dvp;
 735                         ASSERT(dvp != NULL);
 736                         VN_HOLD(dvp);
 737                         error = 0;
 738                 }
 739 
 740                 if (error)
 741                         break;
 742 
 743                 exportdir = 0;
 744                 VN_RELE(vp);
 745                 vp = dvp;
 746         }
 747 
 748         VN_RELE(vp);
 749 
 750         /*
 751          * We can have set error due to error in:
 752          * 1. vop_fid_pseudo()
 753          * 2. VOP_GETATTR()
 754          * 3. VOP_LOOKUP()
 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.
 759          */
 760         if (error) {
 761                 /* Free unconnected visibles, if there are any. */
 762                 if (vis_head)
 763                         free_visible(vis_head);
 764 
 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);
 768 
 769                 while (tree_head) {
 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) {
 774                                 export_unlink(e);
 775                                 exi_rele(e);
 776                         }
 777                         tree_head = tree_head->tree_child_first;
 778                         kmem_free(t2, sizeof (*t2));
 779                 }
 780         }
 781 
 782         return (error);
 783 }
 784 
 785 /*
 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
 790  *
 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.
 796  */
 797 void
 798 treeclimb_unexport(struct exportinfo *exip)
 799 {
 800         treenode_t *tnode, *old_nd;
 801 
 802         ASSERT(RW_WRITE_HELD(&exported_lock));
 803 
 804         tnode = exip->exi_tree;
 805         /*
 806          * The unshared exportinfo was unlinked in unexport().
 807          * Zeroing tree_exi ensures that we will skip it.
 808          */
 809         tnode->tree_exi = NULL;
 810 
 811         if (tnode->tree_vis) /* system root has tree_vis == NULL */
 812                 tnode->tree_vis->vis_exported = 0;
 813 
 814         while (tnode) {
 815 
 816                 /* Stop at VROOT node which is exported or has child */
 817                 if (TREE_ROOT(tnode) &&
 818                     (TREE_EXPORTED(tnode) || tnode->tree_child_first))
 819                         break;
 820 
 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);
 826                 }
 827 
 828                 /* Release visible in parent's exportinfo */
 829                 if (tnode->tree_vis)
 830                         less_visible(vis2exi(tnode), tnode->tree_vis);
 831 
 832                 /* Continue with parent */
 833                 old_nd = tnode;
 834                 tnode = tnode->tree_parent;
 835 
 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);
 839         }
 840 }
 841 
 842 /*
 843  * Traverse backward across mountpoint from the
 844  * root vnode of a filesystem to its mounted-on
 845  * vnode.
 846  */
 847 vnode_t *
 848 untraverse(vnode_t *vp)
 849 {
 850         vnode_t *tvp, *nextvp;
 851 
 852         tvp = vp;
 853         for (;;) {
 854                 if (! (tvp->v_flag & VROOT))
 855                         break;
 856 
 857                 /* lock vfs to prevent unmount of this vfs */
 858                 vfs_lock_wait(tvp->v_vfsp);
 859 
 860                 if ((nextvp = tvp->v_vfsp->vfs_vnodecovered) == NULL) {
 861                         vfs_unlock(tvp->v_vfsp);
 862                         break;
 863                 }
 864 
 865                 /*
 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.
 873                  */
 874                 VN_HOLD(nextvp);
 875                 vfs_unlock(tvp->v_vfsp);
 876                 VN_RELE(tvp);
 877                 tvp = nextvp;
 878         }
 879 
 880         return (tvp);
 881 }
 882 
 883 /*
 884  * Given an exportinfo, climb up to find the exportinfo for the VROOT
 885  * of the filesystem.
 886  *
 887  * e.g.         /
 888  *              |
 889  *              a (VROOT) pseudo-exportinfo
 890  *              |
 891  *              b
 892  *              |
 893  *              c  #share /a/b/c
 894  *              |
 895  *              d
 896  *
 897  * where c is in the same filesystem as a.
 898  * So, get_root_export(*exportinfo_for_c) returns exportinfo_for_a
 899  *
 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
 902  * VROOT exportinfo.
 903  */
 904 struct exportinfo *
 905 get_root_export(struct exportinfo *exip)
 906 {
 907         treenode_t *tnode = exip->exi_tree;
 908         exportinfo_t *exi = NULL;
 909 
 910         while (tnode) {
 911                 if (TREE_ROOT(tnode)) {
 912                         exi = tnode->tree_exi;
 913                         break;
 914                 }
 915                 tnode = tnode->tree_parent;
 916         }
 917         ASSERT(exi);
 918         return (exi);
 919 }
 920 
 921 /*
 922  * Return true if the supplied vnode has a sub-directory exported.
 923  */
 924 int
 925 has_visible(struct exportinfo *exi, vnode_t *vp)
 926 {
 927         struct exp_visible *visp;
 928         fid_t fid;
 929         bool_t vp_is_exported;
 930 
 931         vp_is_exported = VN_CMP(vp,  exi->exi_vp);
 932 
 933         /*
 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.
 937          */
 938         if (vp_is_exported && (vp->v_flag & VROOT))
 939                 return (exi->exi_visible ? 1 : 0);
 940 
 941         /*
 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.
 944          */
 945         exi = get_root_export(exi);
 946 
 947         if (!exi->exi_visible)
 948                 return (0);
 949 
 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) {
 954                 return (0);
 955         }
 956 
 957         /*
 958          * See if vp is in the visible list of the root node exportinfo.
 959          */
 960         for (visp = exi->exi_visible; visp; visp = visp->vis_next) {
 961                 if (EQFID(&fid, &visp->vis_fid)) {
 962                         /*
 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.
 966                          */
 967                         if (vp_is_exported && visp->vis_count < 2)
 968                                 break;
 969 
 970                         return (1);
 971                 }
 972         }
 973 
 974         return (0);
 975 }
 976 
 977 /*
 978  * Returns true if the supplied vnode is visible
 979  * in this export.  If vnode is visible, return
 980  * vis_exported in expseudo.
 981  */
 982 int
 983 nfs_visible(struct exportinfo *exi, vnode_t *vp, int *expseudo)
 984 {
 985         struct exp_visible *visp;
 986         fid_t fid;
 987 
 988         /*
 989          * First check to see if vp is export root.
 990          *
 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).
 998          *
 999          * Previously, rootdir was special cased here; however,
1000          * the export root special case handles the rootdir
1001          * case also.
1002          */
1003         if (VN_CMP(vp, exi->exi_vp)) {
1004                 *expseudo = 0;
1005                 return (1);
1006         }
1007 
1008         /*
1009          * Only a PSEUDO node has a visible list or an exported VROOT
1010          * node may have a visible list.
1011          */
1012         if (! PSEUDO(exi))
1013                 exi = get_root_export(exi);
1014 
1015         /* Get the fid of the vnode */
1016 
1017         bzero(&fid, sizeof (fid));
1018         fid.fid_len = MAXFIDSZ;
1019         if (vop_fid_pseudo(vp, &fid) != 0) {
1020                 *expseudo = 0;
1021                 return (0);
1022         }
1023 
1024         /*
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.
1030          *
1031          * expseudo is not set because this is not an export
1032          */
1033         if (EQFID(&exi->exi_fid, &fid) &&
1034             EQFSID(&exi->exi_fsid, &vp->v_vfsp->vfs_fsid)) {
1035                 *expseudo = 0;
1036                 return (1);
1037         }
1038 
1039 
1040         /* See if it matches any fid in the visible list */
1041 
1042         for (visp = exi->exi_visible; visp; visp = visp->vis_next) {
1043                 if (EQFID(&fid, &visp->vis_fid)) {
1044                         *expseudo = visp->vis_exported;
1045                         return (1);
1046                 }
1047         }
1048 
1049         *expseudo = 0;
1050 
1051         return (0);
1052 }
1053 
1054 /*
1055  * Returns true if the supplied vnode is the
1056  * directory of an export point.
1057  */
1058 int
1059 nfs_exported(struct exportinfo *exi, vnode_t *vp)
1060 {
1061         struct exp_visible *visp;
1062         fid_t fid;
1063 
1064         /*
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.
1073          *
1074          * Note: VN_CMP() won't match for LOFS shares, but they're
1075          * handled below w/EQFID/EQFSID.
1076          */
1077         if (VN_CMP(vp, exi->exi_vp))
1078                 return (1);
1079 
1080         /* Get the fid of the vnode */
1081 
1082         bzero(&fid, sizeof (fid));
1083         fid.fid_len = MAXFIDSZ;
1084         if (vop_fid_pseudo(vp, &fid) != 0)
1085                 return (0);
1086 
1087         if (EQFID(&fid, &exi->exi_fid) &&
1088             EQFSID(&vp->v_vfsp->vfs_fsid, &exi->exi_fsid)) {
1089                 return (1);
1090         }
1091 
1092         /* See if it matches any fid in the visible list */
1093 
1094         for (visp = exi->exi_visible; visp; visp = visp->vis_next) {
1095                 if (EQFID(&fid, &visp->vis_fid))
1096                         return (visp->vis_exported);
1097         }
1098 
1099         return (0);
1100 }
1101 
1102 /*
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
1106  * directory.
1107  *
1108  * NOTE: this code does not match inode number for ".",
1109  * but it isn't required because NFS4 server rddir
1110  * skips . and .. entries.
1111  */
1112 int
1113 nfs_visible_inode(struct exportinfo *exi, ino64_t ino, int *expseudo)
1114 {
1115         struct exp_visible *visp;
1116 
1117         /*
1118          * Only a PSEUDO node has a visible list or an exported VROOT
1119          * node may have a visible list.
1120          */
1121         if (! PSEUDO(exi))
1122                 exi = get_root_export(exi);
1123 
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;
1127                         return (1);
1128                 }
1129 
1130         *expseudo = 0;
1131         return (0);
1132 }