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) 2003, 2010, Oracle and/or its affiliates. All rights reserved.
24 */
25
26 /*
27 * Copyright 2018 Nexenta Systems, Inc.
28 * Copyright (c) 2015, Joyent, Inc.
29 */
30
31 #include <sys/systm.h>
32
33 #include <nfs/nfs.h>
34 #include <nfs/export.h>
35 #include <sys/cmn_err.h>
36 #include <sys/avl.h>
37
38 #define PSEUDOFS_SUFFIX " (pseudo)"
39
40 /*
41 * A version of VOP_FID that deals with a remote VOP_FID for nfs.
42 * If vp is an nfs node, nfs4_fid() returns EREMOTE, nfs3_fid() and nfs_fid()
43 * returns the filehandle of vp as its fid. When nfs uses fid to set the
44 * exportinfo filehandle template, a remote nfs filehandle would be too big for
45 * the fid of the exported directory. This routine remaps the value of the
46 * attribute va_nodeid of vp to be the fid of vp, so that the fid can fit.
47 *
48 * We need this fid mainly for setting up NFSv4 server namespace where an
49 * nfs filesystem is also part of it. Thus, need to be able to setup a pseudo
50 * exportinfo for an nfs node.
51 *
52 * e.g. mount a filesystem on top of a nfs dir, and then share the new mount
53 * (like exporting a local disk from a "diskless" client)
54 */
55 int
vop_fid_pseudo(vnode_t * vp,fid_t * fidp)56 vop_fid_pseudo(vnode_t *vp, fid_t *fidp)
57 {
58 struct vattr va;
59 int error;
60
61 error = VOP_FID(vp, fidp, NULL);
62
63 /*
64 * XXX nfs4_fid() does nothing and returns EREMOTE.
65 * XXX nfs3_fid()/nfs_fid() returns nfs filehandle as its fid
66 * which has a bigger length than local fid.
67 * NFS_FH4MAXDATA is the size of
68 * fhandle4_t.fh_xdata[NFS_FH4MAXDATA].
69 *
70 * Note: nfs[2,3,4]_fid() only gets called for diskless clients.
71 */
72 if (error == EREMOTE ||
73 (error == 0 && fidp->fid_len > NFS_FH4MAXDATA)) {
74
75 va.va_mask = AT_NODEID;
76 error = VOP_GETATTR(vp, &va, 0, CRED(), NULL);
77 if (error)
78 return (error);
79
80 fidp->fid_len = sizeof (va.va_nodeid);
81 bcopy(&va.va_nodeid, fidp->fid_data, fidp->fid_len);
82 return (0);
83 }
84
85 return (error);
86 }
87
88 /*
89 * Get an nfsv4 vnode of the given fid from the visible list of an
90 * nfs filesystem or get the exi_vp if it is the root node.
91 */
92 int
nfs4_vget_pseudo(struct exportinfo * exi,vnode_t ** vpp,fid_t * fidp)93 nfs4_vget_pseudo(struct exportinfo *exi, vnode_t **vpp, fid_t *fidp)
94 {
95 fid_t exp_fid;
96 struct exp_visible *visp;
97 int error;
98
99 /* check if the given fid is in the visible list */
100
101 for (visp = exi->exi_visible; visp; visp = visp->vis_next) {
102 if (EQFID(fidp, &visp->vis_fid)) {
103 VN_HOLD(visp->vis_vp);
104 *vpp = visp->vis_vp;
105 return (0);
106 }
107 }
108
109 /* check if the given fid is the same as the exported node */
110
111 bzero(&exp_fid, sizeof (exp_fid));
112 exp_fid.fid_len = MAXFIDSZ;
113 error = vop_fid_pseudo(exi->exi_vp, &exp_fid);
114 if (error)
115 return (error);
116
117 if (EQFID(fidp, &exp_fid)) {
118 VN_HOLD(exi->exi_vp);
119 *vpp = exi->exi_vp;
120 return (0);
121 }
122
123 return (ENOENT);
124 }
125
126 /*
127 * Create a pseudo export entry
128 *
129 * This is an export entry that's created as the
130 * side-effect of a "real" export. As a part of
131 * a real export, the pathname to the export is
132 * checked to see if all the directory components
133 * are accessible via an NFSv4 client, i.e. are
134 * exported. If treeclimb_export() finds an unexported
135 * mountpoint along the path, then it calls this
136 * function to export it.
137 *
138 * This pseudo export differs from a real export in that
139 * it only allows read-only access. A "visible" list of
140 * directories is added to filter lookup and readdir results
141 * to only contain dirnames which lead to descendant shares.
142 *
143 * A visible list has a per-file-system scope. Any exportinfo
144 * struct (real or pseudo) can have a visible list as long as
145 * a) its export root is VROOT, or is the zone's root for in-zone NFS service
146 * b) a descendant of the export root is shared
147 */
148 struct exportinfo *
pseudo_exportfs(nfs_export_t * ne,vnode_t * vp,fid_t * fid,struct exp_visible * vis_head,struct exportdata * exdata)149 pseudo_exportfs(nfs_export_t *ne, vnode_t *vp, fid_t *fid,
150 struct exp_visible *vis_head, struct exportdata *exdata)
151 {
152 struct exportinfo *exi;
153 struct exportdata *kex;
154 fsid_t fsid;
155 int vpathlen;
156 int i;
157
158 ASSERT(RW_WRITE_HELD(&ne->exported_lock));
159
160 fsid = vp->v_vfsp->vfs_fsid;
161 exi = kmem_zalloc(sizeof (*exi), KM_SLEEP);
162 exi->exi_fsid = fsid;
163 exi->exi_fid = *fid;
164 exi->exi_vp = vp;
165 VN_HOLD(exi->exi_vp);
166 exi->exi_visible = vis_head;
167 exi->exi_count = 1;
168 exi->exi_zoneid = ne->ne_globals->nfs_zoneid;
169 exi->exi_volatile_dev = (vfssw[vp->v_vfsp->vfs_fstype].vsw_flag &
170 VSW_VOLATILEDEV) ? 1 : 0;
171 mutex_init(&exi->exi_lock, NULL, MUTEX_DEFAULT, NULL);
172
173 /*
174 * Build up the template fhandle
175 */
176 exi->exi_fh.fh_fsid = fsid;
177 ASSERT(exi->exi_fid.fid_len <= sizeof (exi->exi_fh.fh_xdata));
178 exi->exi_fh.fh_xlen = exi->exi_fid.fid_len;
179 bcopy(exi->exi_fid.fid_data, exi->exi_fh.fh_xdata,
180 exi->exi_fid.fid_len);
181 exi->exi_fh.fh_len = sizeof (exi->exi_fh.fh_data);
182
183 kex = &exi->exi_export;
184 kex->ex_flags = EX_PSEUDO;
185
186 vpathlen = strlen(vp->v_path);
187 kex->ex_pathlen = vpathlen + strlen(PSEUDOFS_SUFFIX);
188 kex->ex_path = kmem_alloc(kex->ex_pathlen + 1, KM_SLEEP);
189
190 if (vpathlen)
191 (void) strncpy(kex->ex_path, vp->v_path, vpathlen);
192 (void) strcpy(kex->ex_path + vpathlen, PSEUDOFS_SUFFIX);
193
194 /* Transfer the secinfo data from exdata to this new pseudo node */
195 if (exdata)
196 srv_secinfo_exp2pseu(&exi->exi_export, exdata);
197
198 /*
199 * Initialize auth cache and auth cache lock
200 */
201 for (i = 0; i < AUTH_TABLESIZE; i++) {
202 exi->exi_cache[i] = kmem_alloc(sizeof (avl_tree_t), KM_SLEEP);
203 avl_create(exi->exi_cache[i], nfsauth_cache_clnt_compar,
204 sizeof (struct auth_cache_clnt),
205 offsetof(struct auth_cache_clnt, authc_link));
206 }
207 rw_init(&exi->exi_cache_lock, NULL, RW_DEFAULT, NULL);
208
209 /*
210 * Insert the new entry at the front of the export list
211 */
212 export_link(ne, exi);
213
214 /*
215 * Initialize exi_id and exi_kstats
216 */
217 mutex_enter(&nfs_exi_id_lock);
218 exi->exi_id = exi_id_get_next();
219 avl_add(&exi_id_tree, exi);
220 mutex_exit(&nfs_exi_id_lock);
221
222 return (exi);
223 }
224
225 /*
226 * Free a list of visible directories
227 */
228 void
free_visible(struct exp_visible * head)229 free_visible(struct exp_visible *head)
230 {
231 struct exp_visible *visp, *next;
232
233 for (visp = head; visp; visp = next) {
234 if (visp->vis_vp != NULL)
235 VN_RELE(visp->vis_vp);
236
237 next = visp->vis_next;
238 srv_secinfo_list_free(visp->vis_secinfo, visp->vis_seccnt);
239 kmem_free(visp, sizeof (*visp));
240 }
241 }
242
243 /*
244 * Connects newchild (or subtree with newchild in head)
245 * to the parent node. We always add it to the beginning
246 * of sibling list.
247 */
248 static void
tree_add_child(treenode_t * parent,treenode_t * newchild)249 tree_add_child(treenode_t *parent, treenode_t *newchild)
250 {
251 newchild->tree_parent = parent;
252 newchild->tree_sibling = parent->tree_child_first;
253 parent->tree_child_first = newchild;
254 }
255
256 /* Look up among direct children a node with the exact tree_vis pointer */
257 static treenode_t *
tree_find_child_by_vis(treenode_t * t,exp_visible_t * vis)258 tree_find_child_by_vis(treenode_t *t, exp_visible_t *vis)
259 {
260 for (t = t->tree_child_first; t; t = t->tree_sibling)
261 if (t->tree_vis == vis)
262 return (t);
263 return (NULL);
264 }
265
266 /*
267 * Add new node to the head of subtree pointed by 'n'. n can be NULL.
268 * Interconnects the new treenode with exp_visible and exportinfo
269 * if needed.
270 */
271 static treenode_t *
tree_prepend_node(treenode_t * n,exp_visible_t * v,exportinfo_t * e)272 tree_prepend_node(treenode_t *n, exp_visible_t *v, exportinfo_t *e)
273 {
274 treenode_t *tnode = kmem_zalloc(sizeof (*tnode), KM_SLEEP);
275
276 if (n) {
277 tnode->tree_child_first = n;
278 n->tree_parent = tnode;
279 }
280 if (v) {
281 tnode->tree_vis = v;
282 }
283 if (e) {
284 tnode->tree_exi = e;
285 e->exi_tree = tnode;
286 }
287 return (tnode);
288 }
289
290 /*
291 * Removes node from the tree and frees the treenode struct.
292 * Does not free structures pointed by tree_exi and tree_vis,
293 * they should be already freed.
294 */
295 static void
tree_remove_node(nfs_export_t * ne,treenode_t * node)296 tree_remove_node(nfs_export_t *ne, treenode_t *node)
297 {
298 treenode_t *parent = node->tree_parent;
299 treenode_t *s; /* s for sibling */
300
301 if (parent == NULL) {
302 kmem_free(node, sizeof (*node));
303 ne->ns_root = NULL;
304 return;
305 }
306 /* This node is first child */
307 if (parent->tree_child_first == node) {
308 parent->tree_child_first = node->tree_sibling;
309 /* This node is not first child */
310 } else {
311 s = parent->tree_child_first;
312 while (s->tree_sibling != node)
313 s = s->tree_sibling;
314 s->tree_sibling = s->tree_sibling->tree_sibling;
315 }
316 kmem_free(node, sizeof (*node));
317 }
318
319 /*
320 * When we export a new directory we need to add a new
321 * path segment through the pseudofs to reach the new
322 * directory. This new path is reflected in a list of
323 * directories added to the "visible" list.
324 *
325 * Here there are two lists of visible fids: one hanging off the
326 * pseudo exportinfo, and the one we want to add. It's possible
327 * that the two lists share a common path segment
328 * and have some common directories. We need to combine
329 * the lists so there's no duplicate entries. Where a common
330 * path component is found, the vis_count field is bumped.
331 *
332 * This example shows that the treenode chain (tree_head) and
333 * exp_visible chain (vis_head) can differ in length. The latter
334 * can be shorter. The outer loop must loop over the vis_head chain.
335 *
336 * share /x/a
337 * mount -F ufs /dev/dsk/... /x/y
338 * mkdir -p /x/y/a/b
339 * share /x/y/a/b
340 *
341 * When more_visible() is called during the second share,
342 * the existing namespace is following:
343 * exp_visible_t
344 * treenode_t exportinfo_t v0 v1
345 * ns_root+---+ +------------+ +---+ +---+
346 * t0| / |........| E0 pseudo |->| x |->| a |
347 * +---+ +------------+ +---+ +---+
348 * | / /
349 * +---+ / /
350 * t1| x |------------------------ /
351 * +---+ /
352 * | /
353 * +---+ /
354 * t2| a |-------------------------
355 * +---+........+------------+
356 * | E1 real |
357 * +------------+
358 *
359 * This is being added:
360 *
361 * tree_head vis_head
362 * +---+ +---+
363 * t3| x |->| x |v2
364 * +---+ +---+
365 * | |
366 * +---+ +---+ v4 v5
367 * t4| y |->| y |v3 +------------+ +---+ +---+
368 * +---+\ +---+ | E2 pseudo |->| a |->| b |
369 * | \....... >+------------+ +---+ +---+
370 * +---+ / /
371 * t5| a |--------------------------- /
372 * +---+ /
373 * | /
374 * +---+-------------------------------
375 * t6| b | +------------+
376 * +---+..........>| E3 real |
377 * +------------+
378 *
379 * more_visible() will:
380 * - kmem_free() t3 and v2
381 * - add t4, t5, t6 as a child of t1 (t4 will become sibling of t2)
382 * - add v3 to the end of E0->exi_visible
383 *
384 * Note that v4 and v5 were already processed in pseudo_exportfs() and
385 * added to E2. The outer loop of more_visible() will loop only over v2
386 * and v3. The inner loop of more_visible() always loops over v0 and v1.
387 *
388 * Illustration for this scenario:
389 *
390 * mkdir -p /v/a/b/c
391 * share /v/a/b/c
392 * mkdir /v/a/b/c1
393 * mkdir -p /v/a1
394 * mv /v/a/b /v/a1
395 * share /v/a1/b/c1
396 *
397 * EXISTING
398 * treenode
399 * namespace: +-----------+ visibles
400 * |exportinfo |-->v->a->b->c
401 * connect_point->+---+--->+-----------+
402 * | / |T0
403 * +---+
404 * | NEW treenode chain:
405 * child->+---+
406 * | v |T1 +---+<-curr
407 * +---+ N1| v |
408 * | +---+
409 * +---+ |
410 * | a |T2 +---+<-tree_head
411 * +---+ N2| a1|
412 * | +---+
413 * +---+ |
414 * | b |T3 +---+
415 * +---+ N3| b |
416 * | +---+
417 * +---+ |
418 * | c |T4 +---+
419 * +---+ N4| c1|
420 * +---+
421 *
422 * The picture above illustrates the position of following pointers after line
423 * 'child = tree_find_child_by_vis(connect_point, curr->tree_vis);'
424 * was executed for the first time in the outer 'for' loop:
425 *
426 * connect_point..parent treenode in the EXISTING namespace to which the 'curr'
427 * should be connected. If 'connect_point' already has a child
428 * with the same value of tree_vis as the curr->tree_vis is,
429 * the 'curr' will not be added, but kmem_free()d.
430 * child..........the result of tree_find_child_by_vis()
431 * curr...........currently processed treenode from the NEW treenode chain
432 * tree_head......current head of the NEW treenode chain, in this case it was
433 * already moved down to its child - preparation for another loop
434 *
435 * What will happen to NEW treenodes N1, N2, N3, N4 in more_visible() later:
436 *
437 * N1: is merged - i.e. N1 is kmem_free()d. T0 has a child T1 with the same
438 * tree_vis as N1
439 * N2: is added as a new child of T1
440 * Note: not just N2, but the whole chain N2->N3->N4 is added
441 * N3: not processed separately (it was added together with N2)
442 * Even that N3 and T3 have same tree_vis, they are NOT merged, but will
443 * become duplicates.
444 * N4: not processed separately
445 */
446 static void
more_visible(struct exportinfo * exi,treenode_t * tree_head)447 more_visible(struct exportinfo *exi, treenode_t *tree_head)
448 {
449 struct exp_visible *vp1, *vp2, *vis_head, *tail, *next;
450 int found;
451 treenode_t *child, *curr, *connect_point;
452 nfs_export_t *ne = nfs_get_export();
453
454 vis_head = tree_head->tree_vis;
455 connect_point = exi->exi_tree;
456
457 /*
458 * If exportinfo doesn't already have a visible
459 * list just assign the entire supplied list.
460 */
461 if (exi->exi_visible == NULL) {
462 tree_add_child(connect_point, tree_head);
463 exi->exi_visible = vis_head;
464
465 /* Update the change timestamp */
466 tree_update_change(ne, connect_point, &vis_head->vis_change);
467
468 return;
469 }
470
471 /* The outer loop traverses the supplied list. */
472 for (vp1 = vis_head; vp1; vp1 = next) {
473 found = 0;
474 next = vp1->vis_next;
475
476 /* The inner loop searches the exportinfo visible list. */
477 for (vp2 = exi->exi_visible; vp2; vp2 = vp2->vis_next) {
478 tail = vp2;
479 if (EQFID(&vp1->vis_fid, &vp2->vis_fid)) {
480 found = 1;
481 vp2->vis_count++;
482 VN_RELE(vp1->vis_vp);
483 /* Transfer vis_exported from vp1 to vp2. */
484 if (vp1->vis_exported && !vp2->vis_exported)
485 vp2->vis_exported = 1;
486 kmem_free(vp1, sizeof (*vp1));
487 tree_head->tree_vis = vp2;
488 break;
489 }
490 }
491
492 /* If not found - add to the end of the list */
493 if (! found) {
494 tail->vis_next = vp1;
495 vp1->vis_next = NULL;
496 }
497
498 curr = tree_head;
499 tree_head = tree_head->tree_child_first;
500
501 if (! connect_point) /* No longer merging */
502 continue;
503 /*
504 * The inner loop could set curr->tree_vis to the EXISTING
505 * exp_visible vp2, so we can search among the children of
506 * connect_point for the curr->tree_vis. No need for EQFID.
507 */
508 child = tree_find_child_by_vis(connect_point, curr->tree_vis);
509
510 /*
511 * Merging cannot be done if a valid child->tree_exi would
512 * be overwritten by a new curr->tree_exi.
513 */
514 if (child &&
515 (child->tree_exi == NULL || curr->tree_exi == NULL)) {
516 if (curr->tree_exi) { /* Transfer the exportinfo */
517 child->tree_exi = curr->tree_exi;
518 child->tree_exi->exi_tree = child;
519 }
520 kmem_free(curr, sizeof (treenode_t));
521 connect_point = child;
522 } else { /* Branching */
523 tree_add_child(connect_point, curr);
524
525 /* Update the change timestamp */
526 tree_update_change(ne, connect_point,
527 &curr->tree_vis->vis_change);
528
529 connect_point = NULL;
530 }
531 }
532 }
533
534 /*
535 * Remove one visible entry from the pseudo exportfs.
536 *
537 * When we unexport a directory, we have to remove path
538 * components from the visible list in the pseudo exportfs
539 * entry. The supplied visible contains one fid of one path
540 * component. The visible list of the export
541 * is checked against provided visible, matching fid has its
542 * reference count decremented. If a reference count drops to
543 * zero, then it means no paths now use this directory, so its
544 * fid can be removed from the visible list.
545 *
546 * When the last path is removed, the visible list will be null.
547 */
548 static void
less_visible(struct exportinfo * exi,struct exp_visible * vp1)549 less_visible(struct exportinfo *exi, struct exp_visible *vp1)
550 {
551 struct exp_visible *vp2;
552 struct exp_visible *prev, *next;
553
554 for (vp2 = exi->exi_visible, prev = NULL; vp2; vp2 = next) {
555
556 next = vp2->vis_next;
557
558 if (vp1 == vp2) {
559 /*
560 * Decrement the ref count.
561 * Remove the entry if it's zero.
562 */
563 if (--vp2->vis_count <= 0) {
564 if (prev == NULL)
565 exi->exi_visible = next;
566 else
567 prev->vis_next = next;
568 VN_RELE(vp2->vis_vp);
569 srv_secinfo_list_free(vp2->vis_secinfo,
570 vp2->vis_seccnt);
571 kmem_free(vp2, sizeof (*vp1));
572 }
573 break;
574 }
575 prev = vp2;
576 }
577 }
578
579 /*
580 * This function checks the path to a new export to
581 * check whether all the pathname components are
582 * exported. It works by climbing the file tree one
583 * component at a time via "..", crossing mountpoints
584 * if necessary until an export entry is found, or the
585 * system root is reached.
586 *
587 * If an unexported mountpoint is found, then
588 * a new pseudo export is added and the pathname from
589 * the mountpoint down to the export is added to the
590 * visible list for the new pseudo export. If an existing
591 * pseudo export is found, then the pathname is added
592 * to its visible list.
593 *
594 * Note that there's some tests for exportdir.
595 * The exportinfo entry that's passed as a parameter
596 * is that of the real export and exportdir is set
597 * for this case.
598 *
599 * Here is an example of a possible setup:
600 *
601 * () - a new fs; fs mount point
602 * EXPORT - a real exported node
603 * PSEUDO - a pseudo node
604 * vis - visible list
605 * f# - security flavor#
606 * (f#) - security flavor# propagated from its descendents
607 * "" - covered vnode
608 *
609 *
610 * /
611 * |
612 * (a) PSEUDO (f1,f2)
613 * | vis: b,b,"c","n"
614 * |
615 * b
616 * ---------|------------------
617 * | |
618 * (c) EXPORT,f1(f2) (n) PSEUDO (f1,f2)
619 * | vis: "e","d" | vis: m,m,,p,q,"o"
620 * | |
621 * ------------------ -------------------
622 * | | | | |
623 * (d) (e) f m EXPORT,f1(f2) p
624 * EXPORT EXPORT | |
625 * f1 f2 | |
626 * | | |
627 * j (o) EXPORT,f2 q EXPORT f2
628 *
629 */
630 int
treeclimb_export(struct exportinfo * exip)631 treeclimb_export(struct exportinfo *exip)
632 {
633 vnode_t *dvp, *vp;
634 fid_t fid;
635 int error;
636 int exportdir;
637 struct exportinfo *new_exi = exip;
638 struct exp_visible *visp;
639 struct exp_visible *vis_head = NULL;
640 struct vattr va;
641 treenode_t *tree_head = NULL;
642 timespec_t now;
643 nfs_export_t *ne;
644
645 ne = exip->exi_ne;
646 ASSERT3P(ne, ==, nfs_get_export()); /* curzone reality check */
647 ASSERT(RW_WRITE_HELD(&ne->exported_lock));
648
649 gethrestime(&now);
650
651 vp = exip->exi_vp;
652 VN_HOLD(vp);
653 exportdir = 1;
654
655 for (;;) {
656
657 bzero(&fid, sizeof (fid));
658 fid.fid_len = MAXFIDSZ;
659 error = vop_fid_pseudo(vp, &fid);
660 if (error)
661 break;
662
663 ASSERT3U(exip->exi_zoneid, ==, curzone->zone_id);
664 /*
665 * The root of the file system, or the zone's root for
666 * in-zone NFS service needs special handling
667 */
668 if (vp->v_flag & VROOT || vp == EXI_TO_ZONEROOTVP(exip)) {
669 if (!exportdir) {
670 struct exportinfo *exi;
671
672 /*
673 * Check if this VROOT dir is already exported.
674 * If so, then attach the pseudonodes. If not,
675 * then continue .. traversal until we hit a
676 * VROOT export (pseudo or real).
677 */
678 exi = checkexport4(&vp->v_vfsp->vfs_fsid, &fid,
679 vp);
680 if (exi != NULL) {
681 /*
682 * Found an export info
683 *
684 * Extend the list of visible
685 * directories whether it's a pseudo
686 * or a real export.
687 */
688 more_visible(exi, tree_head);
689 break; /* and climb no further */
690 }
691
692 /*
693 * Found the root directory of a filesystem
694 * that isn't exported. Need to export
695 * this as a pseudo export so that an NFS v4
696 * client can do lookups in it.
697 */
698 new_exi = pseudo_exportfs(ne, vp, &fid,
699 vis_head, NULL);
700 vis_head = NULL;
701 }
702
703 if (VN_IS_CURZONEROOT(vp)) {
704 /* at system root */
705 /*
706 * If sharing "/", new_exi is shared exportinfo
707 * (exip). Otherwise, new_exi is exportinfo
708 * created by pseudo_exportfs() above.
709 */
710 ne->ns_root = tree_prepend_node(tree_head, NULL,
711 new_exi);
712
713 /* Update the change timestamp */
714 tree_update_change(ne, ne->ns_root, &now);
715
716 break;
717 }
718
719 /*
720 * Traverse across the mountpoint and continue the
721 * climb on the mounted-on filesystem.
722 */
723 vp = untraverse(vp, ne->exi_root->exi_vp);
724 exportdir = 0;
725 continue;
726 }
727
728 /*
729 * Do a getattr to obtain the nodeid (inode num)
730 * for this vnode.
731 */
732 va.va_mask = AT_NODEID;
733 error = VOP_GETATTR(vp, &va, 0, CRED(), NULL);
734 if (error)
735 break;
736
737 /*
738 * Add this directory fid to visible list
739 */
740 visp = kmem_alloc(sizeof (*visp), KM_SLEEP);
741 VN_HOLD(vp);
742 visp->vis_vp = vp;
743 visp->vis_fid = fid; /* structure copy */
744 visp->vis_ino = va.va_nodeid;
745 visp->vis_count = 1;
746 visp->vis_exported = exportdir;
747 visp->vis_secinfo = NULL;
748 visp->vis_seccnt = 0;
749 visp->vis_change = now; /* structure copy */
750 visp->vis_next = vis_head;
751 vis_head = visp;
752
753 /*
754 * Will set treenode's pointer to exportinfo to
755 * 1. shared exportinfo (exip) - if first visit here
756 * 2. freshly allocated pseudo export (if any)
757 * 3. null otherwise
758 */
759 tree_head = tree_prepend_node(tree_head, visp, new_exi);
760 new_exi = NULL;
761
762 /*
763 * Now, do a ".." to find parent dir of vp.
764 */
765 error = VOP_LOOKUP(vp, "..", &dvp, NULL, 0, NULL, CRED(),
766 NULL, NULL, NULL);
767
768 if (error == ENOTDIR && exportdir) {
769 dvp = exip->exi_dvp;
770 ASSERT(dvp != NULL);
771 VN_HOLD(dvp);
772 error = 0;
773 }
774
775 if (error)
776 break;
777
778 exportdir = 0;
779 VN_RELE(vp);
780 vp = dvp;
781 }
782
783 VN_RELE(vp);
784
785 /*
786 * We can have set error due to error in:
787 * 1. vop_fid_pseudo()
788 * 2. VOP_GETATTR()
789 * 3. VOP_LOOKUP()
790 * We must free pseudo exportinfos, visibles and treenodes.
791 * Visibles are referenced from treenode_t::tree_vis and
792 * exportinfo_t::exi_visible. To avoid double freeing, only
793 * exi_visible pointer is used, via exi_rele(), for the clean-up.
794 */
795 if (error) {
796 /* Free unconnected visibles, if there are any. */
797 if (vis_head)
798 free_visible(vis_head);
799
800 /* Connect unconnected exportinfo, if there is any. */
801 if (new_exi && new_exi != exip)
802 tree_head = tree_prepend_node(tree_head, NULL, new_exi);
803
804 while (tree_head) {
805 treenode_t *t2 = tree_head;
806 exportinfo_t *e = tree_head->tree_exi;
807 /* exip will be freed in exportfs() */
808 if (e && e != exip) {
809 mutex_enter(&nfs_exi_id_lock);
810 avl_remove(&exi_id_tree, e);
811 mutex_exit(&nfs_exi_id_lock);
812 export_unlink(ne, e);
813 exi_rele(e);
814 }
815 tree_head = tree_head->tree_child_first;
816 kmem_free(t2, sizeof (*t2));
817 }
818 }
819
820 return (error);
821 }
822
823 /*
824 * Walk up the tree and:
825 * 1. release pseudo exportinfo if it has no child
826 * 2. release visible in parent's exportinfo
827 * 3. delete non-exported leaf nodes from tree
828 *
829 * Deleting of nodes will start only if the unshared
830 * node was a leaf node.
831 * Deleting of nodes will finish when we reach a node which
832 * has children or is a real export, then we might still need
833 * to continue releasing visibles, until we reach VROOT or zone's root node.
834 */
835 void
treeclimb_unexport(nfs_export_t * ne,struct exportinfo * exip)836 treeclimb_unexport(nfs_export_t *ne, struct exportinfo *exip)
837 {
838 treenode_t *tnode, *old_nd;
839 treenode_t *connect_point = NULL;
840
841 ASSERT(RW_WRITE_HELD(&ne->exported_lock));
842 ASSERT(curzone->zone_id == exip->exi_zoneid ||
843 curzone->zone_id == global_zone->zone_id);
844
845 /*
846 * exi_tree can be null for the zone root
847 * which means we're already at the "top"
848 * and there's nothing more to "climb".
849 */
850 tnode = exip->exi_tree;
851 if (tnode == NULL) {
852 /* Should only happen for... */
853 ASSERT(exip == ne->exi_root);
854 return;
855 }
856
857 /*
858 * The unshared exportinfo was unlinked in unexport().
859 * Zeroing tree_exi ensures that we will skip it.
860 */
861 tnode->tree_exi = NULL;
862
863 if (tnode->tree_vis != NULL) /* system root has tree_vis == NULL */
864 tnode->tree_vis->vis_exported = 0;
865
866 while (tnode != NULL) {
867
868 /*
869 * Stop at VROOT (or zone root) node which is exported or has
870 * child.
871 */
872 if (TREE_ROOT(tnode) &&
873 (TREE_EXPORTED(tnode) || tnode->tree_child_first != NULL))
874 break;
875
876 /* Release pseudo export if it has no child */
877 if (TREE_ROOT(tnode) && !TREE_EXPORTED(tnode) &&
878 tnode->tree_child_first == NULL) {
879 mutex_enter(&nfs_exi_id_lock);
880 avl_remove(&exi_id_tree, tnode->tree_exi);
881 mutex_exit(&nfs_exi_id_lock);
882 export_unlink(ne, tnode->tree_exi);
883 exi_rele(tnode->tree_exi);
884 tnode->tree_exi = NULL;
885 }
886
887 /* Release visible in parent's exportinfo */
888 if (tnode->tree_vis != NULL)
889 less_visible(vis2exi(tnode), tnode->tree_vis);
890
891 /* Continue with parent */
892 old_nd = tnode;
893 tnode = tnode->tree_parent;
894
895 /* Remove itself, if this is a leaf and non-exported node */
896 if (old_nd->tree_child_first == NULL &&
897 !TREE_EXPORTED(old_nd)) {
898 tree_remove_node(ne, old_nd);
899 connect_point = tnode;
900 }
901 }
902
903 /* Update the change timestamp */
904 if (connect_point != NULL)
905 tree_update_change(ne, connect_point, NULL);
906 }
907
908 /*
909 * Traverse backward across mountpoint from the
910 * root vnode of a filesystem to its mounted-on
911 * vnode.
912 */
913 vnode_t *
untraverse(vnode_t * vp,vnode_t * zone_rootvp)914 untraverse(vnode_t *vp, vnode_t *zone_rootvp)
915 {
916 vnode_t *tvp, *nextvp;
917
918 tvp = vp;
919 for (;;) {
920 if (!(tvp->v_flag & VROOT) && !VN_CMP(tvp, zone_rootvp))
921 break;
922
923 /* lock vfs to prevent unmount of this vfs */
924 vfs_lock_wait(tvp->v_vfsp);
925
926 if ((nextvp = tvp->v_vfsp->vfs_vnodecovered) == NULL) {
927 vfs_unlock(tvp->v_vfsp);
928 break;
929 }
930
931 /*
932 * Hold nextvp to prevent unmount. After unlock vfs and
933 * rele tvp, any number of overlays could be unmounted.
934 * Putting a hold on vfs_vnodecovered will only allow
935 * tvp's vfs to be unmounted. Of course if caller placed
936 * extra hold on vp before calling untraverse, the following
937 * hold would not be needed. Since prev actions of caller
938 * are unknown, we need to hold here just to be safe.
939 */
940 VN_HOLD(nextvp);
941 vfs_unlock(tvp->v_vfsp);
942 VN_RELE(tvp);
943 tvp = nextvp;
944 }
945
946 return (tvp);
947 }
948
949 /*
950 * Given an exportinfo, climb up to find the exportinfo for the VROOT
951 * (or zone root) of the filesystem.
952 *
953 * e.g. /
954 * |
955 * a (VROOT) pseudo-exportinfo
956 * |
957 * b
958 * |
959 * c #share /a/b/c
960 * |
961 * d
962 *
963 * where c is in the same filesystem as a.
964 * So, get_root_export(*exportinfo_for_c) returns exportinfo_for_a
965 *
966 * If d is shared, then c will be put into a's visible list.
967 * Note: visible list is per filesystem and is attached to the
968 * VROOT exportinfo. Returned exi does NOT have a new hold.
969 */
970 struct exportinfo *
get_root_export(struct exportinfo * exip)971 get_root_export(struct exportinfo *exip)
972 {
973 treenode_t *tnode = exip->exi_tree;
974 exportinfo_t *exi = NULL;
975
976 while (tnode) {
977 if (TREE_ROOT(tnode)) {
978 exi = tnode->tree_exi;
979 break;
980 }
981 tnode = tnode->tree_parent;
982 }
983 ASSERT(exi);
984 return (exi);
985 }
986
987 /*
988 * Return true if the supplied vnode has a sub-directory exported.
989 */
990 int
has_visible(struct exportinfo * exi,vnode_t * vp)991 has_visible(struct exportinfo *exi, vnode_t *vp)
992 {
993 struct exp_visible *visp;
994 fid_t fid;
995 bool_t vp_is_exported;
996
997 vp_is_exported = VN_CMP(vp, exi->exi_vp);
998
999 /*
1000 * An exported root vnode has a sub-dir shared if it has a visible
1001 * list. i.e. if it does not have a visible list, then there is no
1002 * node in this filesystem leads to any other shared node.
1003 */
1004 ASSERT3P(curzone->zone_id, ==, exi->exi_zoneid);
1005 if (vp_is_exported &&
1006 ((vp->v_flag & VROOT) || VN_IS_CURZONEROOT(vp))) {
1007 return (exi->exi_visible ? 1 : 0);
1008 }
1009
1010 /*
1011 * Only the exportinfo of a fs root node may have a visible list.
1012 * Either it is a pseudo root node, or a real exported root node.
1013 */
1014 exi = get_root_export(exi);
1015
1016 if (!exi->exi_visible)
1017 return (0);
1018
1019 /* Get the fid of the vnode */
1020 bzero(&fid, sizeof (fid));
1021 fid.fid_len = MAXFIDSZ;
1022 if (vop_fid_pseudo(vp, &fid) != 0) {
1023 return (0);
1024 }
1025
1026 /*
1027 * See if vp is in the visible list of the root node exportinfo.
1028 */
1029 for (visp = exi->exi_visible; visp; visp = visp->vis_next) {
1030 if (EQFID(&fid, &visp->vis_fid)) {
1031 /*
1032 * If vp is an exported non-root node with only 1 path
1033 * count (for itself), it indicates no sub-dir shared
1034 * using this vp as a path.
1035 */
1036 if (vp_is_exported && visp->vis_count < 2)
1037 break;
1038
1039 return (1);
1040 }
1041 }
1042
1043 return (0);
1044 }
1045
1046 /*
1047 * Returns true if the supplied vnode is visible
1048 * in this export. If vnode is visible, return
1049 * vis_exported in expseudo.
1050 */
1051 int
nfs_visible(struct exportinfo * exi,vnode_t * vp,int * expseudo)1052 nfs_visible(struct exportinfo *exi, vnode_t *vp, int *expseudo)
1053 {
1054 struct exp_visible *visp;
1055 fid_t fid;
1056
1057 /*
1058 * First check to see if vp is export root.
1059 *
1060 * A pseudo export root can never be exported
1061 * (it would be a real export then); however,
1062 * it is always visible. If a pseudo root object
1063 * was exported by server admin, then the entire
1064 * pseudo exportinfo (and all visible entries) would
1065 * be destroyed. A pseudo exportinfo only exists
1066 * to provide access to real (descendant) export(s).
1067 *
1068 * Previously, rootdir was special cased here; however,
1069 * the export root special case handles the rootdir
1070 * case also.
1071 */
1072 if (VN_CMP(vp, exi->exi_vp)) {
1073 *expseudo = 0;
1074 return (1);
1075 }
1076
1077 /*
1078 * Only a PSEUDO node has a visible list or an exported VROOT
1079 * node may have a visible list.
1080 */
1081 if (!PSEUDO(exi))
1082 exi = get_root_export(exi);
1083
1084 /* Get the fid of the vnode */
1085
1086 bzero(&fid, sizeof (fid));
1087 fid.fid_len = MAXFIDSZ;
1088 if (vop_fid_pseudo(vp, &fid) != 0) {
1089 *expseudo = 0;
1090 return (0);
1091 }
1092
1093 /*
1094 * We can't trust VN_CMP() above because of LOFS.
1095 * Even though VOP_CMP will do the right thing for LOFS
1096 * objects, VN_CMP will short circuit out early when the
1097 * vnode ops ptrs are different. Just in case we're dealing
1098 * with LOFS, compare exi_fid/fsid here.
1099 *
1100 * expseudo is not set because this is not an export
1101 */
1102 if (EQFID(&exi->exi_fid, &fid) &&
1103 EQFSID(&exi->exi_fsid, &vp->v_vfsp->vfs_fsid)) {
1104 *expseudo = 0;
1105 return (1);
1106 }
1107
1108
1109 /* See if it matches any fid in the visible list */
1110
1111 for (visp = exi->exi_visible; visp; visp = visp->vis_next) {
1112 if (EQFID(&fid, &visp->vis_fid)) {
1113 *expseudo = visp->vis_exported;
1114 return (1);
1115 }
1116 }
1117
1118 *expseudo = 0;
1119
1120 return (0);
1121 }
1122
1123 /*
1124 * Returns true if the supplied vnode is the
1125 * directory of an export point.
1126 */
1127 int
nfs_exported(struct exportinfo * exi,vnode_t * vp)1128 nfs_exported(struct exportinfo *exi, vnode_t *vp)
1129 {
1130 struct exp_visible *visp;
1131 fid_t fid;
1132
1133 /*
1134 * First check to see if vp is the export root
1135 * This check required for the case of lookup ..
1136 * where .. is a V_ROOT vnode and a pseudo exportroot.
1137 * Pseudo export root objects do not have an entry
1138 * in the visible list even though every V_ROOT
1139 * pseudonode is visible. It is safe to compare
1140 * vp here because pseudo_exportfs put a hold on
1141 * it when exi_vp was initialized.
1142 *
1143 * Note: VN_CMP() won't match for LOFS shares, but they're
1144 * handled below w/EQFID/EQFSID.
1145 */
1146 if (VN_CMP(vp, exi->exi_vp))
1147 return (1);
1148
1149 /* Get the fid of the vnode */
1150
1151 bzero(&fid, sizeof (fid));
1152 fid.fid_len = MAXFIDSZ;
1153 if (vop_fid_pseudo(vp, &fid) != 0)
1154 return (0);
1155
1156 if (EQFID(&fid, &exi->exi_fid) &&
1157 EQFSID(&vp->v_vfsp->vfs_fsid, &exi->exi_fsid)) {
1158 return (1);
1159 }
1160
1161 /* See if it matches any fid in the visible list */
1162
1163 for (visp = exi->exi_visible; visp; visp = visp->vis_next) {
1164 if (EQFID(&fid, &visp->vis_fid))
1165 return (visp->vis_exported);
1166 }
1167
1168 return (0);
1169 }
1170
1171 /*
1172 * Returns true if the supplied inode is visible
1173 * in this export. This function is used by
1174 * readdir which uses inode numbers from the
1175 * directory.
1176 *
1177 * NOTE: this code does not match inode number for ".",
1178 * but it isn't required because NFS4 server rddir
1179 * skips . and .. entries.
1180 */
1181 int
nfs_visible_inode(struct exportinfo * exi,ino64_t ino,struct exp_visible ** visp)1182 nfs_visible_inode(struct exportinfo *exi, ino64_t ino,
1183 struct exp_visible **visp)
1184 {
1185 /*
1186 * Only a PSEUDO node has a visible list or an exported VROOT
1187 * node may have a visible list.
1188 */
1189 if (!PSEUDO(exi))
1190 exi = get_root_export(exi);
1191
1192 for (*visp = exi->exi_visible; *visp != NULL; *visp = (*visp)->vis_next)
1193 if ((u_longlong_t)ino == (*visp)->vis_ino) {
1194 return (1);
1195 }
1196
1197 return (0);
1198 }
1199
1200 /*
1201 * Get the change attribute from visible and returns TRUE.
1202 * If the change value is not available returns FALSE.
1203 */
1204 bool_t
nfs_visible_change(struct exportinfo * exi,vnode_t * vp,timespec_t * change)1205 nfs_visible_change(struct exportinfo *exi, vnode_t *vp, timespec_t *change)
1206 {
1207 struct exp_visible *visp;
1208 fid_t fid;
1209 treenode_t *node;
1210 nfs_export_t *ne = nfs_get_export();
1211
1212 /*
1213 * First check to see if vp is export root.
1214 */
1215 if (VN_CMP(vp, exi->exi_vp))
1216 goto exproot;
1217
1218 /*
1219 * Only a PSEUDO node has a visible list or an exported VROOT
1220 * node may have a visible list.
1221 */
1222 if (!PSEUDO(exi))
1223 exi = get_root_export(exi);
1224
1225 /* Get the fid of the vnode */
1226 bzero(&fid, sizeof (fid));
1227 fid.fid_len = MAXFIDSZ;
1228 if (vop_fid_pseudo(vp, &fid) != 0)
1229 return (FALSE);
1230
1231 /*
1232 * We can't trust VN_CMP() above because of LOFS.
1233 * Even though VOP_CMP will do the right thing for LOFS
1234 * objects, VN_CMP will short circuit out early when the
1235 * vnode ops ptrs are different. Just in case we're dealing
1236 * with LOFS, compare exi_fid/fsid here.
1237 */
1238 if (EQFID(&exi->exi_fid, &fid) &&
1239 EQFSID(&exi->exi_fsid, &vp->v_vfsp->vfs_fsid))
1240 goto exproot;
1241
1242 /* See if it matches any fid in the visible list */
1243 for (visp = exi->exi_visible; visp; visp = visp->vis_next) {
1244 if (EQFID(&fid, &visp->vis_fid)) {
1245 *change = visp->vis_change;
1246 return (TRUE);
1247 }
1248 }
1249
1250 return (FALSE);
1251
1252 exproot:
1253 /* The VROOT export have its visible available through treenode */
1254 node = exi->exi_tree;
1255 if (node != ne->ns_root) {
1256 ASSERT(node->tree_vis != NULL);
1257 *change = node->tree_vis->vis_change;
1258 } else {
1259 ASSERT(node->tree_vis == NULL);
1260 *change = ne->ns_root_change;
1261 }
1262 return (TRUE);
1263 }
1264
1265 /*
1266 * Update the change attribute value for a particular treenode. The change
1267 * attribute value is stored in the visible attached to the treenode, or in the
1268 * ns_root_change.
1269 *
1270 * If the change value is not supplied, the current time is used.
1271 */
1272 void
tree_update_change(nfs_export_t * ne,treenode_t * tnode,timespec_t * change)1273 tree_update_change(nfs_export_t *ne, treenode_t *tnode, timespec_t *change)
1274 {
1275 timespec_t *vis_change;
1276
1277 ASSERT(tnode != NULL);
1278 ASSERT((tnode != ne->ns_root && tnode->tree_vis != NULL) ||
1279 (tnode == ne->ns_root && tnode->tree_vis == NULL));
1280
1281 vis_change = tnode == ne->ns_root ? &ne->ns_root_change
1282 : &tnode->tree_vis->vis_change;
1283
1284 if (change != NULL)
1285 *vis_change = *change;
1286 else
1287 gethrestime(vis_change);
1288 }
1289