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) 1990, 2010, Oracle and/or its affiliates. All rights reserved.
24 */
25
26 /*
27 * Copyright 1983, 1984, 1985, 1986, 1987, 1988, 1989 AT&T.
28 * All rights reserved.
29 */
30
31 /*
32 * Copyright 2018 Nexenta Systems, Inc.
33 */
34
35 #include <sys/types.h>
36 #include <sys/param.h>
37 #include <sys/time.h>
38 #include <sys/vfs.h>
39 #include <sys/vnode.h>
40 #include <sys/socket.h>
41 #include <sys/errno.h>
42 #include <sys/uio.h>
43 #include <sys/proc.h>
44 #include <sys/user.h>
45 #include <sys/file.h>
46 #include <sys/tiuser.h>
47 #include <sys/kmem.h>
48 #include <sys/pathname.h>
49 #include <sys/debug.h>
50 #include <sys/vtrace.h>
51 #include <sys/cmn_err.h>
52 #include <sys/acl.h>
53 #include <sys/utsname.h>
54 #include <sys/sdt.h>
55 #include <netinet/in.h>
56 #include <sys/avl.h>
57
58 #include <rpc/types.h>
59 #include <rpc/auth.h>
60 #include <rpc/svc.h>
61
62 #include <nfs/nfs.h>
63 #include <nfs/export.h>
64 #include <nfs/nfssys.h>
65 #include <nfs/nfs_clnt.h>
66 #include <nfs/nfs_acl.h>
67 #include <nfs/nfs_log.h>
68 #include <nfs/lm.h>
69 #include <sys/sunddi.h>
70
71 /*
72 * exi_id support
73 *
74 * exi_id_next The next exi_id available.
75 * exi_id_overflow The exi_id_next already overflowed, so we should
76 * thoroughly check for duplicates.
77 * exi_id_tree AVL tree indexed by exi_id.
78 * nfs_exi_id_lock Lock to protect the export ID list
79 *
80 * All exi_id_next, exi_id_overflow, and exi_id_tree are protected by
81 * nfs_exi_id_lock.
82 */
83 static int exi_id_next;
84 static bool_t exi_id_overflow;
85 avl_tree_t exi_id_tree;
86 kmutex_t nfs_exi_id_lock;
87
88 static int unexport(nfs_export_t *, exportinfo_t *);
89 static void exportfree(exportinfo_t *);
90 static int loadindex(exportdata_t *);
91
92 extern void nfsauth_cache_free(exportinfo_t *);
93 extern int sec_svc_loadrootnames(int, int, caddr_t **, model_t);
94 extern void sec_svc_freerootnames(int, int, caddr_t *);
95
96 static int build_seclist_nodups(exportdata_t *, secinfo_t *, int);
97 static void srv_secinfo_add(secinfo_t **, int *, secinfo_t *, int, int);
98 static void srv_secinfo_remove(secinfo_t **, int *, secinfo_t *, int);
99 static void srv_secinfo_treeclimb(nfs_export_t *, exportinfo_t *,
100 secinfo_t *, int, bool_t);
101
102 #ifdef VOLATILE_FH_TEST
103 static struct ex_vol_rename *find_volrnm_fh(exportinfo_t *, nfs_fh4 *);
104 static uint32_t find_volrnm_fh_id(exportinfo_t *, nfs_fh4 *);
105 static void free_volrnm_list(exportinfo_t *);
106 #endif /* VOLATILE_FH_TEST */
107
108 fhandle_t nullfh2; /* for comparing V2 filehandles */
109
110 /*
111 * macro for static dtrace probes to trace server namespace ref count mods.
112 */
113 #define SECREF_TRACE(seclist, tag, flav, aftcnt) \
114 DTRACE_PROBE4(nfss__i__nmspc__secref, struct secinfo *, (seclist), \
115 char *, (tag), int, (int)(flav), int, (int)(aftcnt))
116
117
118 #define exptablehash(fsid, fid) (nfs_fhhash((fsid), (fid)) & (EXPTABLESIZE - 1))
119
120 extern nfs_export_t *
121 nfs_get_export(void)
122 {
123 nfs_globals_t *ng = zone_getspecific(nfssrv_zone_key, curzone);
124 nfs_export_t *ne = ng->nfs_export;
125 ASSERT(ne != NULL);
126 return (ne);
127 }
128
129 static uint8_t
130 xor_hash(uint8_t *data, int len)
131 {
132 uint8_t h = 0;
133
134 while (len--)
135 h ^= *data++;
136
137 return (h);
138 }
139
140 /*
141 * File handle hash function, XOR over all bytes in fsid and fid.
142 */
143 static unsigned
144 nfs_fhhash(fsid_t *fsid, fid_t *fid)
145 {
146 int len;
147 uint8_t h;
148
149 h = xor_hash((uint8_t *)fsid, sizeof (fsid_t));
150
151 /*
152 * Sanity check the length before using it
153 * blindly in case the client trashed it.
154 */
155 len = fid->fid_len > NFS_FH4MAXDATA ? 0 : fid->fid_len;
156 h ^= xor_hash((uint8_t *)fid->fid_data, len);
157
158 return ((unsigned)h);
159 }
160
161 /*
162 * Free the memory allocated within a secinfo entry.
163 */
164 void
165 srv_secinfo_entry_free(struct secinfo *secp)
166 {
167 if (secp->s_rootcnt > 0 && secp->s_rootnames != NULL) {
168 sec_svc_freerootnames(secp->s_secinfo.sc_rpcnum,
169 secp->s_rootcnt, secp->s_rootnames);
170 secp->s_rootcnt = 0;
171 }
172
173 if ((secp->s_secinfo.sc_rpcnum == RPCSEC_GSS) &&
174 (secp->s_secinfo.sc_gss_mech_type)) {
175 kmem_free(secp->s_secinfo.sc_gss_mech_type->elements,
176 secp->s_secinfo.sc_gss_mech_type->length);
177 kmem_free(secp->s_secinfo.sc_gss_mech_type,
178 sizeof (rpc_gss_OID_desc));
179 secp->s_secinfo.sc_gss_mech_type = NULL;
180 }
181 }
182
183 /*
184 * Free a list of secinfo allocated in the exportdata structure.
185 */
186 void
187 srv_secinfo_list_free(struct secinfo *secinfo, int cnt)
188 {
189 int i;
190
191 if (cnt == 0)
192 return;
193
194 for (i = 0; i < cnt; i++)
195 srv_secinfo_entry_free(&secinfo[i]);
196
197 kmem_free(secinfo, cnt * sizeof (struct secinfo));
198 }
199
200 /*
201 * Allocate and copy a secinfo data from "from" to "to".
202 *
203 * This routine is used by srv_secinfo_add() to add a new flavor to an
204 * ancestor's export node. The rootnames are not copied because the
205 * allowable rootname access only applies to the explicit exported node,
206 * not its ancestor's.
207 *
208 * "to" should have already been allocated and zeroed before calling
209 * this routine.
210 *
211 * This routine is used under the protection of exported_lock (RW_WRITER).
212 */
213 void
214 srv_secinfo_copy(struct secinfo *from, struct secinfo *to)
215 {
216 to->s_secinfo.sc_nfsnum = from->s_secinfo.sc_nfsnum;
217 to->s_secinfo.sc_rpcnum = from->s_secinfo.sc_rpcnum;
218
219 if (from->s_secinfo.sc_rpcnum == RPCSEC_GSS) {
220 to->s_secinfo.sc_service = from->s_secinfo.sc_service;
221 bcopy(from->s_secinfo.sc_name, to->s_secinfo.sc_name,
222 strlen(from->s_secinfo.sc_name));
223 bcopy(from->s_secinfo.sc_gss_mech, to->s_secinfo.sc_gss_mech,
224 strlen(from->s_secinfo.sc_gss_mech));
225
226 /* copy mechanism oid */
227 to->s_secinfo.sc_gss_mech_type =
228 kmem_alloc(sizeof (rpc_gss_OID_desc), KM_SLEEP);
229 to->s_secinfo.sc_gss_mech_type->length =
230 from->s_secinfo.sc_gss_mech_type->length;
231 to->s_secinfo.sc_gss_mech_type->elements =
232 kmem_alloc(from->s_secinfo.sc_gss_mech_type->length,
233 KM_SLEEP);
234 bcopy(from->s_secinfo.sc_gss_mech_type->elements,
235 to->s_secinfo.sc_gss_mech_type->elements,
236 from->s_secinfo.sc_gss_mech_type->length);
237 }
238
239 to->s_refcnt = from->s_refcnt;
240 to->s_window = from->s_window;
241 /* no need to copy the mode bits - s_flags */
242 }
243
244 /*
245 * Create a secinfo array without duplicates. The condensed
246 * flavor list is used to propagate flavor ref counts to an
247 * export's ancestor pseudonodes.
248 */
249 static int
250 build_seclist_nodups(exportdata_t *exd, secinfo_t *nodups, int exponly)
251 {
252 int ccnt, c;
253 int ncnt, n;
254 struct secinfo *cursec;
255
256 ncnt = 0;
257 ccnt = exd->ex_seccnt;
258 cursec = exd->ex_secinfo;
259
260 for (c = 0; c < ccnt; c++) {
261
262 if (exponly && ! SEC_REF_EXPORTED(&cursec[c]))
263 continue;
264
265 for (n = 0; n < ncnt; n++) {
266 if (nodups[n].s_secinfo.sc_nfsnum ==
267 cursec[c].s_secinfo.sc_nfsnum)
268 break;
269 }
270
271 /*
272 * The structure copy below also copys ptrs embedded
273 * within struct secinfo. The ptrs are copied but
274 * they are never freed from the nodups array. If
275 * an ancestor's secinfo array doesn't contain one
276 * of the nodups flavors, then the entry is properly
277 * copied into the ancestor's secinfo array.
278 * (see srv_secinfo_copy)
279 */
280 if (n == ncnt) {
281 nodups[n] = cursec[c];
282 ncnt++;
283 }
284 }
285 return (ncnt);
286 }
287
288 /*
289 * Add the new security flavors from newdata to the current list, pcursec.
290 * Upon return, *pcursec has the newly merged secinfo list.
291 *
292 * There should be at least 1 secinfo entry in newsec.
293 *
294 * This routine is used under the protection of exported_lock (RW_WRITER).
295 */
296 static void
297 srv_secinfo_add(secinfo_t **pcursec, int *pcurcnt, secinfo_t *newsec,
298 int newcnt, int is_pseudo)
299 {
300 int ccnt, c; /* sec count in current data - curdata */
301 int n; /* index for newsec - newsecinfo */
302 int tcnt; /* total sec count after merge */
303 int mcnt; /* total sec count after merge */
304 struct secinfo *msec; /* merged secinfo list */
305 struct secinfo *cursec;
306
307 cursec = *pcursec;
308 ccnt = *pcurcnt;
309
310 ASSERT(newcnt > 0);
311 tcnt = ccnt + newcnt;
312
313 for (n = 0; n < newcnt; n++) {
314 for (c = 0; c < ccnt; c++) {
315 if (newsec[n].s_secinfo.sc_nfsnum ==
316 cursec[c].s_secinfo.sc_nfsnum) {
317 cursec[c].s_refcnt += newsec[n].s_refcnt;
318 SECREF_TRACE(cursec, "add_ref",
319 cursec[c].s_secinfo.sc_nfsnum,
320 cursec[c].s_refcnt);
321 tcnt--;
322 break;
323 }
324 }
325 }
326
327 if (tcnt == ccnt)
328 return; /* no change; no new flavors */
329
330 msec = kmem_zalloc(tcnt * sizeof (struct secinfo), KM_SLEEP);
331
332 /* move current secinfo list data to the new list */
333 for (c = 0; c < ccnt; c++)
334 msec[c] = cursec[c];
335
336 /* Add the flavor that's not in the current data */
337 mcnt = ccnt;
338 for (n = 0; n < newcnt; n++) {
339 for (c = 0; c < ccnt; c++) {
340 if (newsec[n].s_secinfo.sc_nfsnum ==
341 cursec[c].s_secinfo.sc_nfsnum)
342 break;
343 }
344
345 /* This is the one. Add it. */
346 if (c == ccnt) {
347 srv_secinfo_copy(&newsec[n], &msec[mcnt]);
348
349 if (is_pseudo)
350 msec[mcnt].s_flags = M_RO;
351
352 SECREF_TRACE(msec, "new_ref",
353 msec[mcnt].s_secinfo.sc_nfsnum,
354 msec[mcnt].s_refcnt);
355 mcnt++;
356 }
357 }
358
359 ASSERT(mcnt == tcnt);
360
361 /*
362 * Done. Update curdata. Free the old secinfo list in
363 * curdata and return the new sec array info
364 */
365 if (ccnt > 0)
366 kmem_free(cursec, ccnt * sizeof (struct secinfo));
367 *pcurcnt = tcnt;
368 *pcursec = msec;
369 }
370
371 /*
372 * For NFS V4.
373 * Remove the security data of the unexported node from its ancestors.
374 * Assume there is at least one flavor entry in the current sec list
375 * (pcursec).
376 *
377 * This routine is used under the protection of exported_lock (RW_WRITER).
378 *
379 * Every element of remsec is an explicitly exported flavor. If
380 * srv_secinfo_remove() is called fom an exportfs error path, then
381 * the flavor list was derived from the user's share cmdline,
382 * and all flavors are explicit. If it was called from the unshare path,
383 * build_seclist_nodups() was called with the exponly flag.
384 */
385 static void
386 srv_secinfo_remove(secinfo_t **pcursec, int *pcurcnt, secinfo_t *remsec,
387 int remcnt)
388 {
389 int ccnt, c; /* sec count in current data - cursec */
390 int r; /* sec count in removal data - remsec */
391 int tcnt, mcnt; /* total sec count after removing */
392 struct secinfo *msec; /* final secinfo list after removing */
393 struct secinfo *cursec;
394
395 cursec = *pcursec;
396 ccnt = *pcurcnt;
397 tcnt = ccnt;
398
399 for (r = 0; r < remcnt; r++) {
400 /*
401 * At unshare/reshare time, only explicitly shared flavor ref
402 * counts are decremented and propagated to ancestors.
403 * Implicit flavor refs came from shared descendants, and
404 * they must be kept.
405 */
406 if (! SEC_REF_EXPORTED(&remsec[r]))
407 continue;
408
409 for (c = 0; c < ccnt; c++) {
410 if (remsec[r].s_secinfo.sc_nfsnum ==
411 cursec[c].s_secinfo.sc_nfsnum) {
412
413 /*
414 * Decrement secinfo reference count by 1.
415 * If this entry is invalid after decrementing
416 * the count (i.e. count < 1), this entry will
417 * be removed.
418 */
419 cursec[c].s_refcnt--;
420
421 SECREF_TRACE(cursec, "del_ref",
422 cursec[c].s_secinfo.sc_nfsnum,
423 cursec[c].s_refcnt);
424
425 ASSERT(cursec[c].s_refcnt >= 0);
426
427 if (SEC_REF_INVALID(&cursec[c]))
428 tcnt--;
429 break;
430 }
431 }
432 }
433
434 ASSERT(tcnt >= 0);
435 if (tcnt == ccnt)
436 return; /* no change; no flavors to remove */
437
438 if (tcnt == 0) {
439 srv_secinfo_list_free(cursec, ccnt);
440 *pcurcnt = 0;
441 *pcursec = NULL;
442 return;
443 }
444
445 msec = kmem_zalloc(tcnt * sizeof (struct secinfo), KM_SLEEP);
446
447 /* walk thru the given secinfo list to remove the flavors */
448 mcnt = 0;
449 for (c = 0; c < ccnt; c++) {
450 if (SEC_REF_INVALID(&cursec[c])) {
451 srv_secinfo_entry_free(&cursec[c]);
452 } else {
453 msec[mcnt] = cursec[c];
454 mcnt++;
455 }
456 }
457
458 ASSERT(mcnt == tcnt);
459 /*
460 * Done. Update curdata.
461 * Free the existing secinfo list in curdata. All pointers
462 * within the list have either been moved to msec or freed
463 * if it's invalid.
464 */
465 kmem_free(*pcursec, ccnt * sizeof (struct secinfo));
466 *pcursec = msec;
467 *pcurcnt = tcnt;
468 }
469
470
471 /*
472 * For the reshare case, sec flavor accounting happens in 3 steps:
473 * 1) propagate addition of new flavor refs up the ancestor tree
474 * 2) transfer flavor refs of descendants to new/reshared exportdata
475 * 3) propagate removal of old flavor refs up the ancestor tree
476 *
477 * srv_secinfo_exp2exp() implements step 2 of a reshare. At this point,
478 * the new flavor list has already been propagated up through the
479 * ancestor tree via srv_secinfo_treeclimb().
480 *
481 * If there is more than 1 export reference to an old flavor (i.e. some
482 * of its children shared with this flavor), this flavor information
483 * needs to be transferred to the new exportdata struct. A flavor in
484 * the old exportdata has descendant refs when its s_refcnt > 1 or it
485 * is implicitly shared (M_SEC4_EXPORTED not set in s_flags).
486 *
487 * SEC_REF_EXPORTED() is only true when M_SEC4_EXPORTED is set
488 * SEC_REF_SELF() is only true when both M_SEC4_EXPORTED is set and s_refcnt==1
489 *
490 * Transferring descendant flavor refcnts happens in 2 passes:
491 * a) flavors used before (oldsecinfo) and after (curdata->ex_secinfo) reshare
492 * b) flavors used before but not after reshare
493 *
494 * This routine is used under the protection of exported_lock (RW_WRITER).
495 */
496 void
497 srv_secinfo_exp2exp(exportdata_t *curdata, secinfo_t *oldsecinfo, int ocnt)
498 {
499 int ccnt, c; /* sec count in current data - curdata */
500 int o; /* sec count in old data - oldsecinfo */
501 int tcnt, mcnt; /* total sec count after the transfer */
502 struct secinfo *msec; /* merged secinfo list */
503
504 ccnt = curdata->ex_seccnt;
505
506 ASSERT(ocnt > 0);
507 ASSERT(!(curdata->ex_flags & EX_PSEUDO));
508
509 /*
510 * If the oldsecinfo has flavors with more than 1 reference count
511 * and the flavor is specified in the reshare, transfer the flavor
512 * refs to the new seclist (curdata.ex_secinfo).
513 */
514 tcnt = ccnt + ocnt;
515
516 for (o = 0; o < ocnt; o++) {
517
518 if (SEC_REF_SELF(&oldsecinfo[o])) {
519 tcnt--;
520 continue;
521 }
522
523 for (c = 0; c < ccnt; c++) {
524 if (oldsecinfo[o].s_secinfo.sc_nfsnum ==
525 curdata->ex_secinfo[c].s_secinfo.sc_nfsnum) {
526
527 /*
528 * add old reference to the current
529 * secinfo count
530 */
531 curdata->ex_secinfo[c].s_refcnt +=
532 oldsecinfo[o].s_refcnt;
533
534 /*
535 * Delete the old export flavor
536 * reference. The initial reference
537 * was created during srv_secinfo_add,
538 * and the count is decremented below
539 * to account for the initial reference.
540 */
541 if (SEC_REF_EXPORTED(&oldsecinfo[o]))
542 curdata->ex_secinfo[c].s_refcnt--;
543
544 SECREF_TRACE(curdata->ex_path,
545 "reshare_xfer_common_child_refs",
546 curdata->ex_secinfo[c].s_secinfo.sc_nfsnum,
547 curdata->ex_secinfo[c].s_refcnt);
548
549 ASSERT(curdata->ex_secinfo[c].s_refcnt >= 0);
550
551 tcnt--;
552 break;
553 }
554 }
555 }
556
557 if (tcnt == ccnt)
558 return; /* no more transfer to do */
559
560 /*
561 * oldsecinfo has flavors referenced by its children that are not
562 * in the current (new) export flavor list. Add these flavors.
563 */
564 msec = kmem_zalloc(tcnt * sizeof (struct secinfo), KM_SLEEP);
565
566 /* move current secinfo list data to the new list */
567 for (c = 0; c < ccnt; c++)
568 msec[c] = curdata->ex_secinfo[c];
569
570 /*
571 * Add the flavor that's not in the new export, but still
572 * referenced by its children.
573 */
574 mcnt = ccnt;
575 for (o = 0; o < ocnt; o++) {
576 if (! SEC_REF_SELF(&oldsecinfo[o])) {
577 for (c = 0; c < ccnt; c++) {
578 if (oldsecinfo[o].s_secinfo.sc_nfsnum ==
579 curdata->ex_secinfo[c].s_secinfo.sc_nfsnum)
580 break;
581 }
582
583 /*
584 * This is the one. Add it. Decrement the ref count
585 * by 1 if the flavor is an explicitly shared flavor
586 * for the oldsecinfo export node.
587 */
588 if (c == ccnt) {
589 srv_secinfo_copy(&oldsecinfo[o], &msec[mcnt]);
590 if (SEC_REF_EXPORTED(&oldsecinfo[o]))
591 msec[mcnt].s_refcnt--;
592
593 SECREF_TRACE(curdata,
594 "reshare_xfer_implicit_child_refs",
595 msec[mcnt].s_secinfo.sc_nfsnum,
596 msec[mcnt].s_refcnt);
597
598 ASSERT(msec[mcnt].s_refcnt >= 0);
599 mcnt++;
600 }
601 }
602 }
603
604 ASSERT(mcnt == tcnt);
605 /*
606 * Done. Update curdata, free the existing secinfo list in
607 * curdata and set the new value.
608 */
609 if (ccnt > 0)
610 kmem_free(curdata->ex_secinfo, ccnt * sizeof (struct secinfo));
611 curdata->ex_seccnt = tcnt;
612 curdata->ex_secinfo = msec;
613 }
614
615 /*
616 * When unsharing an old export node and the old node becomes a pseudo node,
617 * if there is more than 1 export reference to an old flavor (i.e. some of
618 * its children shared with this flavor), this flavor information needs to
619 * be transferred to the new shared node.
620 *
621 * This routine is used under the protection of exported_lock (RW_WRITER).
622 */
623 void
624 srv_secinfo_exp2pseu(exportdata_t *curdata, exportdata_t *olddata)
625 {
626 int ocnt, o; /* sec count in transfer data - trandata */
627 int tcnt, mcnt; /* total sec count after transfer */
628 struct secinfo *msec; /* merged secinfo list */
629
630 ASSERT(curdata->ex_flags & EX_PSEUDO);
631 ASSERT(curdata->ex_seccnt == 0);
632
633 ocnt = olddata->ex_seccnt;
634
635 /*
636 * If the olddata has flavors with more than 1 reference count,
637 * transfer the information to the curdata.
638 */
639 tcnt = ocnt;
640
641 for (o = 0; o < ocnt; o++) {
642 if (SEC_REF_SELF(&olddata->ex_secinfo[o]))
643 tcnt--;
644 }
645
646 if (tcnt == 0)
647 return; /* no transfer to do */
648
649 msec = kmem_zalloc(tcnt * sizeof (struct secinfo), KM_SLEEP);
650
651 mcnt = 0;
652 for (o = 0; o < ocnt; o++) {
653 if (! SEC_REF_SELF(&olddata->ex_secinfo[o])) {
654
655 /*
656 * Decrement the reference count by 1 if the flavor is
657 * an explicitly shared flavor for the olddata export
658 * node.
659 */
660 srv_secinfo_copy(&olddata->ex_secinfo[o], &msec[mcnt]);
661 msec[mcnt].s_flags = M_RO;
662 if (SEC_REF_EXPORTED(&olddata->ex_secinfo[o]))
663 msec[mcnt].s_refcnt--;
664
665 SECREF_TRACE(curdata, "unshare_morph_pseudo",
666 msec[mcnt].s_secinfo.sc_nfsnum,
667 msec[mcnt].s_refcnt);
668
669 ASSERT(msec[mcnt].s_refcnt >= 0);
670 mcnt++;
671 }
672 }
673
674 ASSERT(mcnt == tcnt);
675 /*
676 * Done. Update curdata.
677 * Free up the existing secinfo list in curdata and
678 * set the new value.
679 */
680 curdata->ex_seccnt = tcnt;
681 curdata->ex_secinfo = msec;
682 }
683
684 /*
685 * Find for given treenode the exportinfo which has its
686 * exp_visible linked on its exi_visible list.
687 *
688 * Note: We could add new pointer either to treenode or
689 * to exp_visible, which will point there directly.
690 * This would buy some speed for some memory.
691 */
692 exportinfo_t *
693 vis2exi(treenode_t *tnode)
694 {
695 exportinfo_t *exi_ret = NULL;
696 #ifdef DEBUG
697 zone_t *zone = NULL;
698 #endif
699
700 for (;;) {
701 tnode = tnode->tree_parent;
702 #ifdef DEBUG
703 if (zone == NULL && tnode->tree_exi != NULL)
704 zone = tnode->tree_exi->exi_zone;
705 #endif
706 if (TREE_ROOT(tnode)) {
707 ASSERT3P(zone, ==, tnode->tree_exi->exi_zone);
708 exi_ret = tnode->tree_exi;
709 break;
710 }
711 }
712
713 ASSERT(exi_ret); /* Every visible should have its home exportinfo */
714 return (exi_ret);
715 }
716
717 /*
718 * For NFS V4.
719 * Add or remove the newly exported or unexported security flavors of the
720 * given exportinfo from its ancestors upto the system root.
721 */
722 static void
723 srv_secinfo_treeclimb(nfs_export_t *ne, exportinfo_t *exip, secinfo_t *sec,
724 int seccnt, bool_t isadd)
725 {
726 treenode_t *tnode;
727
728 ASSERT(RW_WRITE_HELD(&ne->exported_lock));
729 ASSERT3U(exip->exi_zoneid, ==, curzone->zone_id);
730
731 /*
732 * exi_tree can be null for the zone root
733 * which means we're already at the "top"
734 * and there's nothing more to "climb".
735 */
736 tnode = exip->exi_tree;
737 if (tnode == NULL) {
738 /* Should only happen for... */
739 ASSERT(exip == ne->exi_root);
740 return;
741 }
742
743 if (seccnt == 0)
744 return;
745
746 /*
747 * If flavors are being added and the new export root isn't
748 * also VROOT, its implicitly allowed flavors are inherited from
749 * its pseudonode.
750 * Note - for VROOT exports the implicitly allowed flavors were
751 * transferred from the PSEUDO export in exportfs()
752 */
753 if (isadd && !(exip->exi_vp->v_flag & VROOT) &&
754 !VN_IS_CURZONEROOT(exip->exi_vp) &&
755 tnode->tree_vis->vis_seccnt > 0) {
756 srv_secinfo_add(&exip->exi_export.ex_secinfo,
757 &exip->exi_export.ex_seccnt, tnode->tree_vis->vis_secinfo,
758 tnode->tree_vis->vis_seccnt, FALSE);
759 }
760
761 /*
762 * Move to parent node and propagate sec flavor
763 * to exportinfo and to visible structures.
764 */
765 tnode = tnode->tree_parent;
766
767 while (tnode != NULL) {
768
769 /* If there is exportinfo, update it */
770 if (tnode->tree_exi != NULL) {
771 secinfo_t **pxsec =
772 &tnode->tree_exi->exi_export.ex_secinfo;
773 int *pxcnt = &tnode->tree_exi->exi_export.ex_seccnt;
774 int is_pseudo = PSEUDO(tnode->tree_exi);
775 if (isadd)
776 srv_secinfo_add(pxsec, pxcnt, sec, seccnt,
777 is_pseudo);
778 else
779 srv_secinfo_remove(pxsec, pxcnt, sec, seccnt);
780 }
781
782 /* Update every visible - only root node has no visible */
783 if (tnode->tree_vis != NULL) {
784 secinfo_t **pxsec = &tnode->tree_vis->vis_secinfo;
785 int *pxcnt = &tnode->tree_vis->vis_seccnt;
786 if (isadd)
787 srv_secinfo_add(pxsec, pxcnt, sec, seccnt,
788 FALSE);
789 else
790 srv_secinfo_remove(pxsec, pxcnt, sec, seccnt);
791 }
792 tnode = tnode->tree_parent;
793 }
794 }
795
796 /* hash_name is a text substitution for either fid_hash or path_hash */
797 #define exp_hash_unlink(exi, hash_name) \
798 if (*(exi)->hash_name.bckt == (exi)) \
799 *(exi)->hash_name.bckt = (exi)->hash_name.next; \
800 if ((exi)->hash_name.prev) \
801 (exi)->hash_name.prev->hash_name.next = (exi)->hash_name.next; \
802 if ((exi)->hash_name.next) \
803 (exi)->hash_name.next->hash_name.prev = (exi)->hash_name.prev; \
804 (exi)->hash_name.bckt = NULL;
805
806 #define exp_hash_link(exi, hash_name, bucket) \
807 (exi)->hash_name.bckt = (bucket); \
808 (exi)->hash_name.prev = NULL; \
809 (exi)->hash_name.next = *(bucket); \
810 if ((exi)->hash_name.next) \
811 (exi)->hash_name.next->hash_name.prev = (exi); \
812 *(bucket) = (exi);
813
814 void
815 export_link(nfs_export_t *ne, exportinfo_t *exi)
816 {
817 exportinfo_t **bckt;
818
819 ASSERT(RW_WRITE_HELD(&ne->exported_lock));
820
821 bckt = &ne->exptable[exptablehash(&exi->exi_fsid, &exi->exi_fid)];
822 exp_hash_link(exi, fid_hash, bckt);
823
824 bckt = &ne->exptable_path_hash[pkp_tab_hash(exi->exi_export.ex_path,
825 strlen(exi->exi_export.ex_path))];
826 exp_hash_link(exi, path_hash, bckt);
827 }
828
829 /*
830 * Helper functions for exi_id handling
831 */
832 static int
833 exi_id_compar(const void *v1, const void *v2)
834 {
835 const struct exportinfo *e1 = v1;
836 const struct exportinfo *e2 = v2;
837
838 if (e1->exi_id < e2->exi_id)
839 return (-1);
840 if (e1->exi_id > e2->exi_id)
841 return (1);
842
843 return (0);
844 }
845
846 int
847 exi_id_get_next()
848 {
849 struct exportinfo e;
850 int ret = exi_id_next;
851
852 ASSERT(MUTEX_HELD(&nfs_exi_id_lock));
853
854 do {
855 exi_id_next++;
856 if (exi_id_next == 0)
857 exi_id_overflow = TRUE;
858
859 if (!exi_id_overflow)
860 break;
861
862 if (exi_id_next == ret)
863 cmn_err(CE_PANIC, "exi_id exhausted");
864
865 e.exi_id = exi_id_next;
866 } while (avl_find(&exi_id_tree, &e, NULL) != NULL);
867
868 return (ret);
869 }
870
871 /*
872 * Get the root file handle for this zone.
873 * Called when nfs_svc() starts
874 */
875 int
876 nfs_export_get_rootfh(nfs_globals_t *g)
877 {
878 nfs_export_t *ne = g->nfs_export;
879 int err;
880
881 ne->exi_rootfid.fid_len = MAXFIDSZ;
882 err = vop_fid_pseudo(ne->exi_root->exi_vp, &ne->exi_rootfid);
883 if (err != 0) {
884 ne->exi_rootfid.fid_len = 0;
885 return (err);
886 }
887
888 /* Setup the fhandle template exi_fh */
889 ne->exi_root->exi_fh.fh_fsid = rootdir->v_vfsp->vfs_fsid;
890 ne->exi_root->exi_fh.fh_xlen = ne->exi_rootfid.fid_len;
891 bcopy(ne->exi_rootfid.fid_data, ne->exi_root->exi_fh.fh_xdata,
892 ne->exi_rootfid.fid_len);
893 ne->exi_root->exi_fh.fh_len = sizeof (ne->exi_root->exi_fh.fh_data);
894
895 return (0);
896 }
897
898 void
899 nfs_export_zone_init(nfs_globals_t *ng)
900 {
901 int i;
902 nfs_export_t *ne;
903 zone_t *zone;
904
905 ne = kmem_zalloc(sizeof (*ne), KM_SLEEP);
906
907 rw_init(&ne->exported_lock, NULL, RW_DEFAULT, NULL);
908
909 ne->ne_globals = ng; /* "up" pointer */
910
911 /*
912 * Allocate the place holder for the public file handle, which
913 * is all zeroes. It is initially set to the root filesystem.
914 */
915 ne->exi_root = kmem_zalloc(sizeof (*ne->exi_root), KM_SLEEP);
916 ne->exi_public = ne->exi_root;
917
918 ne->exi_root->exi_export.ex_flags = EX_PUBLIC;
919 ne->exi_root->exi_export.ex_pathlen = 1; /* length of "/" */
920 ne->exi_root->exi_export.ex_path =
921 kmem_alloc(ne->exi_root->exi_export.ex_pathlen + 1, KM_SLEEP);
922 ne->exi_root->exi_export.ex_path[0] = '/';
923 ne->exi_root->exi_export.ex_path[1] = '\0';
924
925 ne->exi_root->exi_count = 1;
926 mutex_init(&ne->exi_root->exi_lock, NULL, MUTEX_DEFAULT, NULL);
927
928 /*
929 * Because we cannot:
930 * ASSERT(curzone->zone_id == ng->nfs_zoneid);
931 * We grab the zone pointer explicitly (like netstacks do) and
932 * set the rootvp here.
933 */
934 zone = zone_find_by_id_nolock(ng->nfs_zoneid);
935 ne->exi_root->exi_vp = zone->zone_rootvp;
936 ne->exi_root->exi_zone = zone; /* XXX KEBE SAYS lose me, and... */
937 /* ne->exi_root->exi_zoneid = ng->nfs_zoneid; */ /* use me instead! */
938
939 /*
940 * Fill in ne->exi_rootfid later, in nfs_export_get_rootfid
941 * because we can't correctly return errors here.
942 */
943
944 /* Initialize auth cache and auth cache lock */
945 for (i = 0; i < AUTH_TABLESIZE; i++) {
946 ne->exi_root->exi_cache[i] = kmem_alloc(sizeof (avl_tree_t),
947 KM_SLEEP);
948 avl_create(ne->exi_root->exi_cache[i],
949 nfsauth_cache_clnt_compar, sizeof (struct auth_cache_clnt),
950 offsetof(struct auth_cache_clnt, authc_link));
951 }
952 rw_init(&ne->exi_root->exi_cache_lock, NULL, RW_DEFAULT, NULL);
953
954 /* setup exi_fh later, in nfs_export_get_rootfid */
955
956 rw_enter(&ne->exported_lock, RW_WRITER);
957
958 /* Publish the exportinfo in the hash table */
959 export_link(ne, ne->exi_root);
960
961 /* Initialize exi_id and exi_kstats */
962 mutex_enter(&nfs_exi_id_lock);
963 ne->exi_root->exi_id = exi_id_get_next();
964 avl_add(&exi_id_tree, ne->exi_root);
965 mutex_exit(&nfs_exi_id_lock);
966
967 rw_exit(&ne->exported_lock);
968 ne->ns_root = NULL;
969
970 ng->nfs_export = ne;
971 }
972
973 /*
974 * During zone shutdown, remove exports
975 */
976 void
977 nfs_export_zone_shutdown(nfs_globals_t *ng)
978 {
979 nfs_export_t *ne = ng->nfs_export;
980 struct exportinfo *exi, *nexi;
981 int i, errors;
982
983 rw_enter(&ne->exported_lock, RW_READER);
984
985 errors = 0;
986 for (i = 0; i < EXPTABLESIZE; i++) {
987
988 exi = ne->exptable[i];
989 if (exi != NULL)
990 exi_hold(exi);
991
992 while (exi != NULL) {
993
994 /*
995 * Get and hold next export before
996 * dropping the rwlock and unexport
997 */
998 nexi = exi->fid_hash.next;
999 if (nexi != NULL)
1000 exi_hold(nexi);
1001
1002 rw_exit(&ne->exported_lock);
1003
1004 /*
1005 * Skip ne->exi_root which gets special
1006 * create/destroy handling.
1007 */
1008 if (exi != ne->exi_root &&
1009 unexport(ne, exi) != 0)
1010 errors++;
1011 exi_rele(exi);
1012
1013 rw_enter(&ne->exported_lock, RW_READER);
1014 exi = nexi;
1015 }
1016 }
1017 if (errors > 0) {
1018 cmn_err(CE_NOTE,
1019 "NFS: failed un-exports in zone %d",
1020 (int) ng->nfs_zoneid);
1021 }
1022
1023 rw_exit(&ne->exported_lock);
1024 }
1025
1026 void
1027 nfs_export_zone_fini(nfs_globals_t *ng)
1028 {
1029 int i;
1030 nfs_export_t *ne = ng->nfs_export;
1031 struct exportinfo *exi;
1032
1033 ng->nfs_export = NULL;
1034
1035 rw_enter(&ne->exported_lock, RW_WRITER);
1036
1037 mutex_enter(&nfs_exi_id_lock);
1038 avl_remove(&exi_id_tree, ne->exi_root);
1039 mutex_exit(&nfs_exi_id_lock);
1040
1041 export_unlink(ne, ne->exi_root);
1042
1043 rw_exit(&ne->exported_lock);
1044
1045 /* Deallocate the place holder for the public file handle */
1046 srv_secinfo_list_free(ne->exi_root->exi_export.ex_secinfo,
1047 ne->exi_root->exi_export.ex_seccnt);
1048 mutex_destroy(&ne->exi_root->exi_lock);
1049
1050 rw_destroy(&ne->exi_root->exi_cache_lock);
1051 for (i = 0; i < AUTH_TABLESIZE; i++) {
1052 avl_destroy(ne->exi_root->exi_cache[i]);
1053 kmem_free(ne->exi_root->exi_cache[i], sizeof (avl_tree_t));
1054 }
1055
1056 kmem_free(ne->exi_root->exi_export.ex_path,
1057 ne->exi_root->exi_export.ex_pathlen + 1);
1058 kmem_free(ne->exi_root, sizeof (*ne->exi_root));
1059
1060 /*
1061 * The shutdown hook should have left the exi_id_tree
1062 * with nothing belonging to this zone.
1063 */
1064 mutex_enter(&nfs_exi_id_lock);
1065 i = 0;
1066 exi = avl_first(&exi_id_tree);
1067 while (exi != NULL) {
1068 if (exi->exi_zoneid == ng->nfs_zoneid)
1069 i++;
1070 exi = AVL_NEXT(&exi_id_tree, exi);
1071 }
1072 mutex_exit(&nfs_exi_id_lock);
1073 if (i > 0) {
1074 cmn_err(CE_NOTE,
1075 "NFS: zone %d has %d export IDs left after shutdown",
1076 (int) ng->nfs_zoneid, i);
1077 }
1078 rw_destroy(&ne->exported_lock);
1079 kmem_free(ne, sizeof (*ne));
1080 }
1081
1082 /*
1083 * Initialization routine for export routines.
1084 * Should only be called once.
1085 */
1086 void
1087 nfs_exportinit(void)
1088 {
1089 mutex_init(&nfs_exi_id_lock, NULL, MUTEX_DEFAULT, NULL);
1090
1091 /* exi_id handling initialization */
1092 exi_id_next = 0;
1093 exi_id_overflow = FALSE;
1094 avl_create(&exi_id_tree, exi_id_compar, sizeof (struct exportinfo),
1095 offsetof(struct exportinfo, exi_id_link));
1096
1097 nfslog_init();
1098 }
1099
1100 /*
1101 * Finalization routine for export routines.
1102 */
1103 void
1104 nfs_exportfini(void)
1105 {
1106 avl_destroy(&exi_id_tree);
1107 mutex_destroy(&nfs_exi_id_lock);
1108 }
1109
1110 /*
1111 * Check if 2 gss mechanism identifiers are the same.
1112 *
1113 * return FALSE if not the same.
1114 * return TRUE if the same.
1115 */
1116 static bool_t
1117 nfs_mech_equal(rpc_gss_OID mech1, rpc_gss_OID mech2)
1118 {
1119 if ((mech1->length == 0) && (mech2->length == 0))
1120 return (TRUE);
1121
1122 if (mech1->length != mech2->length)
1123 return (FALSE);
1124
1125 return (bcmp(mech1->elements, mech2->elements, mech1->length) == 0);
1126 }
1127
1128 /*
1129 * This routine is used by rpc to map rpc security number
1130 * to nfs specific security flavor number.
1131 *
1132 * The gss callback prototype is
1133 * callback(struct svc_req *, gss_cred_id_t *, gss_ctx_id_t *,
1134 * rpc_gss_lock_t *, void **),
1135 * since nfs does not use the gss_cred_id_t/gss_ctx_id_t arguments
1136 * we cast them to void.
1137 */
1138 /*ARGSUSED*/
1139 bool_t
1140 rfs_gsscallback(struct svc_req *req, gss_cred_id_t deleg, void *gss_context,
1141 rpc_gss_lock_t *lock, void **cookie)
1142 {
1143 int i, j;
1144 rpc_gss_rawcred_t *raw_cred;
1145 struct exportinfo *exi;
1146 nfs_export_t *ne = nfs_get_export();
1147
1148 /*
1149 * We don't deal with delegated credentials.
1150 */
1151 if (deleg != GSS_C_NO_CREDENTIAL)
1152 return (FALSE);
1153
1154 raw_cred = lock->raw_cred;
1155 *cookie = NULL;
1156
1157 rw_enter(&ne->exported_lock, RW_READER);
1158
1159 for (i = 0; i < EXPTABLESIZE; i++) {
1160 exi = ne->exptable[i];
1161 while (exi) {
1162 if (exi->exi_export.ex_seccnt > 0) {
1163 struct secinfo *secp;
1164 seconfig_t *se;
1165 int seccnt;
1166
1167 secp = exi->exi_export.ex_secinfo;
1168 seccnt = exi->exi_export.ex_seccnt;
1169 for (j = 0; j < seccnt; j++) {
1170 /*
1171 * If there is a map of the triplet
1172 * (mechanism, service, qop) between
1173 * raw_cred and the exported flavor,
1174 * get the psudo flavor number.
1175 * Also qop should not be NULL, it
1176 * should be "default" or something
1177 * else.
1178 */
1179 se = &secp[j].s_secinfo;
1180 if ((se->sc_rpcnum == RPCSEC_GSS) &&
1181
1182 (nfs_mech_equal(
1183 se->sc_gss_mech_type,
1184 raw_cred->mechanism)) &&
1185
1186 (se->sc_service ==
1187 raw_cred->service) &&
1188 (raw_cred->qop == se->sc_qop)) {
1189
1190 *cookie = (void *)(uintptr_t)
1191 se->sc_nfsnum;
1192 goto done;
1193 }
1194 }
1195 }
1196 exi = exi->fid_hash.next;
1197 }
1198 }
1199 done:
1200 rw_exit(&ne->exported_lock);
1201
1202 /*
1203 * If no nfs pseudo number mapping can be found in the export
1204 * table, assign the nfsflavor to NFS_FLAVOR_NOMAP. In V4, we may
1205 * recover the flavor mismatch from NFS layer (NFS4ERR_WRONGSEC).
1206 *
1207 * For example:
1208 * server first shares with krb5i;
1209 * client mounts with krb5i;
1210 * server re-shares with krb5p;
1211 * client tries with krb5i, but no mapping can be found;
1212 * rpcsec_gss module calls this routine to do the mapping,
1213 * if this routine fails, request is rejected from
1214 * the rpc layer.
1215 * What we need is to let the nfs layer rejects the request.
1216 * For V4, we can reject with NFS4ERR_WRONGSEC and the client
1217 * may recover from it by getting the new flavor via SECINFO.
1218 *
1219 * nfs pseudo number for RPCSEC_GSS mapping (see nfssec.conf)
1220 * is owned by IANA (see RFC 2623).
1221 *
1222 * XXX NFS_FLAVOR_NOMAP is defined in Solaris to work around
1223 * the implementation issue. This number should not overlap with
1224 * any new IANA defined pseudo flavor numbers.
1225 */
1226 if (*cookie == NULL)
1227 *cookie = (void *)NFS_FLAVOR_NOMAP;
1228
1229 lock->locked = TRUE;
1230
1231 return (TRUE);
1232 }
1233
1234
1235 /*
1236 * Exportfs system call; credentials should be checked before
1237 * calling this function.
1238 */
1239 int
1240 exportfs(struct exportfs_args *args, model_t model, cred_t *cr)
1241 {
1242 vnode_t *vp;
1243 vnode_t *dvp;
1244 struct exportdata *kex;
1245 struct exportinfo *exi = NULL;
1246 struct exportinfo *ex, *ex1, *ex2;
1247 fid_t fid;
1248 fsid_t fsid;
1249 int error;
1250 size_t allocsize;
1251 struct secinfo *sp;
1252 struct secinfo *exs;
1253 rpc_gss_callback_t cb;
1254 char *pathbuf;
1255 char *log_buffer;
1256 char *tagbuf;
1257 int callback;
1258 int allocd_seccnt;
1259 STRUCT_HANDLE(exportfs_args, uap);
1260 STRUCT_DECL(exportdata, uexi);
1261 struct secinfo newsec[MAX_FLAVORS];
1262 int newcnt;
1263 struct secinfo oldsec[MAX_FLAVORS];
1264 int oldcnt;
1265 int i;
1266 struct pathname lookpn;
1267 nfs_export_t *ne = nfs_get_export();
1268
1269 STRUCT_SET_HANDLE(uap, model, args);
1270
1271 /* Read in pathname from userspace */
1272 if (error = pn_get(STRUCT_FGETP(uap, dname), UIO_USERSPACE, &lookpn))
1273 return (error);
1274
1275 /* Walk the export list looking for that pathname */
1276 rw_enter(&ne->exported_lock, RW_READER);
1277 DTRACE_PROBE(nfss__i__exported_lock1_start);
1278 for (ex1 = ne->exptable_path_hash[pkp_tab_hash(lookpn.pn_path,
1279 strlen(lookpn.pn_path))]; ex1; ex1 = ex1->path_hash.next) {
1280 if (ex1 != ne->exi_root && 0 ==
1281 strcmp(ex1->exi_export.ex_path, lookpn.pn_path)) {
1282 exi_hold(ex1);
1283 break;
1284 }
1285 }
1286 DTRACE_PROBE(nfss__i__exported_lock1_stop);
1287 rw_exit(&ne->exported_lock);
1288
1289 /* Is this an unshare? */
1290 if (STRUCT_FGETP(uap, uex) == NULL) {
1291 pn_free(&lookpn);
1292 if (ex1 == NULL)
1293 return (EINVAL);
1294 error = unexport(ne, ex1);
1295 exi_rele(ex1);
1296 return (error);
1297 }
1298
1299 /* It is a share or a re-share */
1300 error = lookupname(STRUCT_FGETP(uap, dname), UIO_USERSPACE,
1301 FOLLOW, &dvp, &vp);
1302 if (error == EINVAL) {
1303 /*
1304 * if fname resolves to / we get EINVAL error
1305 * since we wanted the parent vnode. Try again
1306 * with NULL dvp.
1307 */
1308 error = lookupname(STRUCT_FGETP(uap, dname), UIO_USERSPACE,
1309 FOLLOW, NULL, &vp);
1310 dvp = NULL;
1311 }
1312 if (!error && vp == NULL) {
1313 /* Last component of fname not found */
1314 if (dvp != NULL)
1315 VN_RELE(dvp);
1316 error = ENOENT;
1317 }
1318 if (error) {
1319 pn_free(&lookpn);
1320 if (ex1)
1321 exi_rele(ex1);
1322 return (error);
1323 }
1324
1325 /*
1326 * 'vp' may be an AUTOFS node, so we perform a
1327 * VOP_ACCESS() to trigger the mount of the
1328 * intended filesystem, so we can share the intended
1329 * filesystem instead of the AUTOFS filesystem.
1330 */
1331 (void) VOP_ACCESS(vp, 0, 0, cr, NULL);
1332
1333 /*
1334 * We're interested in the top most filesystem.
1335 * This is specially important when uap->dname is a trigger
1336 * AUTOFS node, since we're really interested in sharing the
1337 * filesystem AUTOFS mounted as result of the VOP_ACCESS()
1338 * call not the AUTOFS node itself.
1339 */
1340 if (vn_mountedvfs(vp) != NULL) {
1341 if (error = traverse(&vp)) {
1342 VN_RELE(vp);
1343 if (dvp != NULL)
1344 VN_RELE(dvp);
1345 pn_free(&lookpn);
1346 if (ex1)
1347 exi_rele(ex1);
1348 return (error);
1349 }
1350 }
1351
1352 /* Do not allow sharing another vnode for already shared path */
1353 if (ex1 && !PSEUDO(ex1) && !VN_CMP(ex1->exi_vp, vp)) {
1354 VN_RELE(vp);
1355 if (dvp != NULL)
1356 VN_RELE(dvp);
1357 pn_free(&lookpn);
1358 exi_rele(ex1);
1359 return (EEXIST);
1360 }
1361 if (ex1)
1362 exi_rele(ex1);
1363
1364 /*
1365 * Get the vfs id
1366 */
1367 bzero(&fid, sizeof (fid));
1368 fid.fid_len = MAXFIDSZ;
1369 error = VOP_FID(vp, &fid, NULL);
1370 fsid = vp->v_vfsp->vfs_fsid;
1371
1372 if (error) {
1373 VN_RELE(vp);
1374 if (dvp != NULL)
1375 VN_RELE(dvp);
1376 /*
1377 * If VOP_FID returns ENOSPC then the fid supplied
1378 * is too small. For now we simply return EREMOTE.
1379 */
1380 if (error == ENOSPC)
1381 error = EREMOTE;
1382 pn_free(&lookpn);
1383 return (error);
1384 }
1385
1386 /*
1387 * Do not allow re-sharing a shared vnode under a different path
1388 * PSEUDO export has ex_path fabricated, e.g. "/tmp (pseudo)", skip it.
1389 */
1390 rw_enter(&ne->exported_lock, RW_READER);
1391 DTRACE_PROBE(nfss__i__exported_lock2_start);
1392 for (ex2 = ne->exptable[exptablehash(&fsid, &fid)]; ex2;
1393 ex2 = ex2->fid_hash.next) {
1394 if (ex2 != ne->exi_root && !PSEUDO(ex2) &&
1395 VN_CMP(ex2->exi_vp, vp) &&
1396 strcmp(ex2->exi_export.ex_path, lookpn.pn_path) != 0) {
1397 DTRACE_PROBE(nfss__i__exported_lock2_stop);
1398 rw_exit(&ne->exported_lock);
1399 VN_RELE(vp);
1400 if (dvp != NULL)
1401 VN_RELE(dvp);
1402 pn_free(&lookpn);
1403 return (EEXIST);
1404 }
1405 }
1406 DTRACE_PROBE(nfss__i__exported_lock2_stop);
1407 rw_exit(&ne->exported_lock);
1408 pn_free(&lookpn);
1409
1410 exi = kmem_zalloc(sizeof (*exi), KM_SLEEP);
1411 exi->exi_fsid = fsid;
1412 exi->exi_fid = fid;
1413 exi->exi_vp = vp;
1414 exi->exi_count = 1;
1415 exi->exi_zone = crgetzone(cr);
1416 ASSERT(exi->exi_zone != NULL); /* XXX KEBE ASKS... */
1417 ASSERT3P(exi->exi_zone, ==, curzone); /* ... are these legit? */
1418 exi->exi_volatile_dev = (vfssw[vp->v_vfsp->vfs_fstype].vsw_flag &
1419 VSW_VOLATILEDEV) ? 1 : 0;
1420 mutex_init(&exi->exi_lock, NULL, MUTEX_DEFAULT, NULL);
1421 exi->exi_dvp = dvp;
1422
1423 /*
1424 * Initialize auth cache and auth cache lock
1425 */
1426 for (i = 0; i < AUTH_TABLESIZE; i++) {
1427 exi->exi_cache[i] = kmem_alloc(sizeof (avl_tree_t), KM_SLEEP);
1428 avl_create(exi->exi_cache[i], nfsauth_cache_clnt_compar,
1429 sizeof (struct auth_cache_clnt),
1430 offsetof(struct auth_cache_clnt, authc_link));
1431 }
1432 rw_init(&exi->exi_cache_lock, NULL, RW_DEFAULT, NULL);
1433
1434 /*
1435 * Build up the template fhandle
1436 */
1437 exi->exi_fh.fh_fsid = fsid;
1438 if (exi->exi_fid.fid_len > sizeof (exi->exi_fh.fh_xdata)) {
1439 error = EREMOTE;
1440 goto out1;
1441 }
1442 exi->exi_fh.fh_xlen = exi->exi_fid.fid_len;
1443 bcopy(exi->exi_fid.fid_data, exi->exi_fh.fh_xdata,
1444 exi->exi_fid.fid_len);
1445
1446 exi->exi_fh.fh_len = sizeof (exi->exi_fh.fh_data);
1447
1448 kex = &exi->exi_export;
1449
1450 /*
1451 * Load in everything, and do sanity checking
1452 */
1453 STRUCT_INIT(uexi, model);
1454 if (copyin(STRUCT_FGETP(uap, uex), STRUCT_BUF(uexi),
1455 STRUCT_SIZE(uexi))) {
1456 error = EFAULT;
1457 goto out1;
1458 }
1459
1460 kex->ex_version = STRUCT_FGET(uexi, ex_version);
1461 if (kex->ex_version != EX_CURRENT_VERSION) {
1462 error = EINVAL;
1463 cmn_err(CE_WARN,
1464 "NFS: exportfs requires export struct version 2 - got %d\n",
1465 kex->ex_version);
1466 goto out1;
1467 }
1468
1469 /*
1470 * Must have at least one security entry
1471 */
1472 kex->ex_seccnt = STRUCT_FGET(uexi, ex_seccnt);
1473 if (kex->ex_seccnt < 1) {
1474 error = EINVAL;
1475 goto out1;
1476 }
1477
1478 kex->ex_path = STRUCT_FGETP(uexi, ex_path);
1479 kex->ex_pathlen = STRUCT_FGET(uexi, ex_pathlen);
1480 kex->ex_flags = STRUCT_FGET(uexi, ex_flags);
1481 kex->ex_anon = STRUCT_FGET(uexi, ex_anon);
1482 kex->ex_secinfo = STRUCT_FGETP(uexi, ex_secinfo);
1483 kex->ex_index = STRUCT_FGETP(uexi, ex_index);
1484 kex->ex_log_buffer = STRUCT_FGETP(uexi, ex_log_buffer);
1485 kex->ex_log_bufferlen = STRUCT_FGET(uexi, ex_log_bufferlen);
1486 kex->ex_tag = STRUCT_FGETP(uexi, ex_tag);
1487 kex->ex_taglen = STRUCT_FGET(uexi, ex_taglen);
1488
1489 /*
1490 * Copy the exported pathname into
1491 * an appropriately sized buffer.
1492 */
1493 pathbuf = kmem_alloc(MAXPATHLEN, KM_SLEEP);
1494 if (copyinstr(kex->ex_path, pathbuf, MAXPATHLEN, &kex->ex_pathlen)) {
1495 kmem_free(pathbuf, MAXPATHLEN);
1496 error = EFAULT;
1497 goto out1;
1498 }
1499 kex->ex_path = kmem_alloc(kex->ex_pathlen + 1, KM_SLEEP);
1500 bcopy(pathbuf, kex->ex_path, kex->ex_pathlen);
1501 kex->ex_path[kex->ex_pathlen] = '\0';
1502 kmem_free(pathbuf, MAXPATHLEN);
1503
1504 /*
1505 * Get the path to the logging buffer and the tag
1506 */
1507 if (kex->ex_flags & EX_LOG) {
1508 log_buffer = kmem_alloc(MAXPATHLEN, KM_SLEEP);
1509 if (copyinstr(kex->ex_log_buffer, log_buffer, MAXPATHLEN,
1510 &kex->ex_log_bufferlen)) {
1511 kmem_free(log_buffer, MAXPATHLEN);
1512 error = EFAULT;
1513 goto out2;
1514 }
1515 kex->ex_log_buffer =
1516 kmem_alloc(kex->ex_log_bufferlen + 1, KM_SLEEP);
1517 bcopy(log_buffer, kex->ex_log_buffer, kex->ex_log_bufferlen);
1518 kex->ex_log_buffer[kex->ex_log_bufferlen] = '\0';
1519 kmem_free(log_buffer, MAXPATHLEN);
1520
1521 tagbuf = kmem_alloc(MAXPATHLEN, KM_SLEEP);
1522 if (copyinstr(kex->ex_tag, tagbuf, MAXPATHLEN,
1523 &kex->ex_taglen)) {
1524 kmem_free(tagbuf, MAXPATHLEN);
1525 error = EFAULT;
1526 goto out3;
1527 }
1528 kex->ex_tag = kmem_alloc(kex->ex_taglen + 1, KM_SLEEP);
1529 bcopy(tagbuf, kex->ex_tag, kex->ex_taglen);
1530 kex->ex_tag[kex->ex_taglen] = '\0';
1531 kmem_free(tagbuf, MAXPATHLEN);
1532 }
1533
1534 /*
1535 * Load the security information for each flavor
1536 */
1537 allocsize = kex->ex_seccnt * SIZEOF_STRUCT(secinfo, model);
1538 sp = kmem_zalloc(allocsize, KM_SLEEP);
1539 if (copyin(kex->ex_secinfo, sp, allocsize)) {
1540 kmem_free(sp, allocsize);
1541 error = EFAULT;
1542 goto out4;
1543 }
1544
1545 /*
1546 * All of these nested structures need to be converted to
1547 * the kernel native format.
1548 */
1549 if (model != DATAMODEL_NATIVE) {
1550 size_t allocsize2;
1551 struct secinfo *sp2;
1552
1553 allocsize2 = kex->ex_seccnt * sizeof (struct secinfo);
1554 sp2 = kmem_zalloc(allocsize2, KM_SLEEP);
1555
1556 for (i = 0; i < kex->ex_seccnt; i++) {
1557 STRUCT_HANDLE(secinfo, usi);
1558
1559 STRUCT_SET_HANDLE(usi, model,
1560 (struct secinfo *)((caddr_t)sp +
1561 (i * SIZEOF_STRUCT(secinfo, model))));
1562 bcopy(STRUCT_FGET(usi, s_secinfo.sc_name),
1563 sp2[i].s_secinfo.sc_name, MAX_NAME_LEN);
1564 sp2[i].s_secinfo.sc_nfsnum =
1565 STRUCT_FGET(usi, s_secinfo.sc_nfsnum);
1566 sp2[i].s_secinfo.sc_rpcnum =
1567 STRUCT_FGET(usi, s_secinfo.sc_rpcnum);
1568 bcopy(STRUCT_FGET(usi, s_secinfo.sc_gss_mech),
1569 sp2[i].s_secinfo.sc_gss_mech, MAX_NAME_LEN);
1570 sp2[i].s_secinfo.sc_gss_mech_type =
1571 STRUCT_FGETP(usi, s_secinfo.sc_gss_mech_type);
1572 sp2[i].s_secinfo.sc_qop =
1573 STRUCT_FGET(usi, s_secinfo.sc_qop);
1574 sp2[i].s_secinfo.sc_service =
1575 STRUCT_FGET(usi, s_secinfo.sc_service);
1576
1577 sp2[i].s_flags = STRUCT_FGET(usi, s_flags);
1578 sp2[i].s_window = STRUCT_FGET(usi, s_window);
1579 sp2[i].s_rootid = STRUCT_FGET(usi, s_rootid);
1580 sp2[i].s_rootcnt = STRUCT_FGET(usi, s_rootcnt);
1581 sp2[i].s_rootnames = STRUCT_FGETP(usi, s_rootnames);
1582 }
1583 kmem_free(sp, allocsize);
1584 sp = sp2;
1585 allocsize = allocsize2;
1586 }
1587
1588 kex->ex_secinfo = sp;
1589
1590 /*
1591 * And now copy rootnames for each individual secinfo.
1592 */
1593 callback = 0;
1594 allocd_seccnt = 0;
1595 while (allocd_seccnt < kex->ex_seccnt) {
1596
1597 exs = &sp[allocd_seccnt];
1598 if (exs->s_rootcnt > 0) {
1599 if (!sec_svc_loadrootnames(exs->s_secinfo.sc_rpcnum,
1600 exs->s_rootcnt, &exs->s_rootnames, model)) {
1601 error = EFAULT;
1602 goto out5;
1603 }
1604 }
1605
1606 if (exs->s_secinfo.sc_rpcnum == RPCSEC_GSS) {
1607 rpc_gss_OID mech_tmp;
1608 STRUCT_DECL(rpc_gss_OID_s, umech_tmp);
1609 caddr_t elements_tmp;
1610
1611 /* Copyin mechanism type */
1612 STRUCT_INIT(umech_tmp, model);
1613 mech_tmp = kmem_alloc(sizeof (*mech_tmp), KM_SLEEP);
1614 if (copyin(exs->s_secinfo.sc_gss_mech_type,
1615 STRUCT_BUF(umech_tmp), STRUCT_SIZE(umech_tmp))) {
1616 kmem_free(mech_tmp, sizeof (*mech_tmp));
1617 error = EFAULT;
1618 goto out5;
1619 }
1620 mech_tmp->length = STRUCT_FGET(umech_tmp, length);
1621 mech_tmp->elements = STRUCT_FGETP(umech_tmp, elements);
1622
1623 elements_tmp = kmem_alloc(mech_tmp->length, KM_SLEEP);
1624 if (copyin(mech_tmp->elements, elements_tmp,
1625 mech_tmp->length)) {
1626 kmem_free(elements_tmp, mech_tmp->length);
1627 kmem_free(mech_tmp, sizeof (*mech_tmp));
1628 error = EFAULT;
1629 goto out5;
1630 }
1631 mech_tmp->elements = elements_tmp;
1632 exs->s_secinfo.sc_gss_mech_type = mech_tmp;
1633 allocd_seccnt++;
1634
1635 callback = 1;
1636 } else
1637 allocd_seccnt++;
1638 }
1639
1640 /*
1641 * Init the secinfo reference count and mark these flavors
1642 * explicitly exported flavors.
1643 */
1644 for (i = 0; i < kex->ex_seccnt; i++) {
1645 kex->ex_secinfo[i].s_flags |= M_4SEC_EXPORTED;
1646 kex->ex_secinfo[i].s_refcnt = 1;
1647 }
1648
1649 /*
1650 * Set up rpcsec_gss callback routine entry if any.
1651 */
1652 if (callback) {
1653 cb.callback = rfs_gsscallback;
1654 cb.program = NFS_ACL_PROGRAM;
1655 for (cb.version = NFS_ACL_VERSMIN;
1656 cb.version <= NFS_ACL_VERSMAX; cb.version++) {
1657 (void) sec_svc_control(RPC_SVC_SET_GSS_CALLBACK,
1658 (void *)&cb);
1659 }
1660
1661 cb.program = NFS_PROGRAM;
1662 for (cb.version = NFS_VERSMIN;
1663 cb.version <= NFS_VERSMAX; cb.version++) {
1664 (void) sec_svc_control(RPC_SVC_SET_GSS_CALLBACK,
1665 (void *)&cb);
1666 }
1667 }
1668
1669 /*
1670 * Check the index flag. Do this here to avoid holding the
1671 * lock while dealing with the index option (as we do with
1672 * the public option).
1673 */
1674 if (kex->ex_flags & EX_INDEX) {
1675 if (!kex->ex_index) { /* sanity check */
1676 error = EINVAL;
1677 goto out5;
1678 }
1679 if (error = loadindex(kex))
1680 goto out5;
1681 }
1682
1683 if (kex->ex_flags & EX_LOG) {
1684 if (error = nfslog_setup(exi))
1685 goto out6;
1686 }
1687
1688 /*
1689 * Insert the new entry at the front of the export list
1690 */
1691 rw_enter(&ne->exported_lock, RW_WRITER);
1692 DTRACE_PROBE(nfss__i__exported_lock3_start);
1693
1694 export_link(ne, exi);
1695
1696 /*
1697 * Check the rest of the list for an old entry for the fs.
1698 * If one is found then unlink it, wait until this is the
1699 * only reference and then free it.
1700 */
1701 for (ex = exi->fid_hash.next; ex != NULL; ex = ex->fid_hash.next) {
1702 if (ex != ne->exi_root && VN_CMP(ex->exi_vp, vp)) {
1703 mutex_enter(&nfs_exi_id_lock);
1704 avl_remove(&exi_id_tree, ex);
1705 mutex_exit(&nfs_exi_id_lock);
1706 export_unlink(ne, ex);
1707 break;
1708 }
1709 }
1710
1711 /*
1712 * If the public filehandle is pointing at the
1713 * old entry, then point it back at the root.
1714 */
1715 if (ex != NULL && ex == ne->exi_public)
1716 ne->exi_public = ne->exi_root;
1717
1718 /*
1719 * If the public flag is on, make the global exi_public
1720 * point to this entry and turn off the public bit so that
1721 * we can distinguish it from the place holder export.
1722 */
1723 if (kex->ex_flags & EX_PUBLIC) {
1724 ne->exi_public = exi;
1725 kex->ex_flags &= ~EX_PUBLIC;
1726 }
1727
1728 #ifdef VOLATILE_FH_TEST
1729 /*
1730 * Set up the volatile_id value if volatile on share.
1731 * The list of volatile renamed filehandles is always destroyed,
1732 * if the fs was reshared.
1733 */
1734 if (kex->ex_flags & EX_VOLFH)
1735 exi->exi_volatile_id = gethrestime_sec();
1736
1737 mutex_init(&exi->exi_vol_rename_lock, NULL, MUTEX_DEFAULT, NULL);
1738 #endif /* VOLATILE_FH_TEST */
1739
1740 /*
1741 * If this is a new export, then climb up
1742 * the tree and check if any pseudo exports
1743 * need to be created to provide a path for
1744 * NFS v4 clients.
1745 */
1746 if (ex == NULL) {
1747 error = treeclimb_export(exi);
1748 if (error)
1749 goto out7;
1750 } else {
1751 /* If it's a re-export update namespace tree */
1752 exi->exi_tree = ex->exi_tree;
1753 exi->exi_tree->tree_exi = exi;
1754
1755 /* Update the change timestamp */
1756 tree_update_change(ne, exi->exi_tree, NULL);
1757 }
1758
1759 /*
1760 * build a unique flavor list from the flavors specified
1761 * in the share cmd. unique means that each flavor only
1762 * appears once in the secinfo list -- no duplicates allowed.
1763 */
1764 newcnt = build_seclist_nodups(&exi->exi_export, newsec, FALSE);
1765
1766 srv_secinfo_treeclimb(ne, exi, newsec, newcnt, TRUE);
1767
1768 /*
1769 * If re-sharing an old export entry, update the secinfo data
1770 * depending on if the old entry is a pseudo node or not.
1771 */
1772 if (ex != NULL) {
1773 oldcnt = build_seclist_nodups(&ex->exi_export, oldsec, FALSE);
1774 if (PSEUDO(ex)) {
1775 /*
1776 * The dir being shared is a pseudo export root (which
1777 * will be transformed into a real export root). The
1778 * flavor(s) of the new share were propagated to the
1779 * ancestors by srv_secinfo_treeclimb() above. Now
1780 * transfer the implicit flavor refs from the old
1781 * pseudo exprot root to the new (real) export root.
1782 */
1783 srv_secinfo_add(&exi->exi_export.ex_secinfo,
1784 &exi->exi_export.ex_seccnt, oldsec, oldcnt, TRUE);
1785 } else {
1786 /*
1787 * First transfer implicit flavor refs to new export.
1788 * Remove old flavor refs last.
1789 */
1790 srv_secinfo_exp2exp(&exi->exi_export, oldsec, oldcnt);
1791 srv_secinfo_treeclimb(ne, ex, oldsec, oldcnt, FALSE);
1792 }
1793 }
1794
1795 /*
1796 * If it's a re-export and the old entry has a pseudonode list,
1797 * transfer it to the new export.
1798 */
1799 if (ex != NULL && (ex->exi_visible != NULL)) {
1800 exi->exi_visible = ex->exi_visible;
1801 ex->exi_visible = NULL;
1802 }
1803
1804 /*
1805 * Initialize exi_id and exi_kstats
1806 */
1807 if (ex != NULL) {
1808 exi->exi_id = ex->exi_id;
1809 } else {
1810 mutex_enter(&nfs_exi_id_lock);
1811 exi->exi_id = exi_id_get_next();
1812 mutex_exit(&nfs_exi_id_lock);
1813 }
1814 mutex_enter(&nfs_exi_id_lock);
1815 avl_add(&exi_id_tree, exi);
1816 mutex_exit(&nfs_exi_id_lock);
1817
1818 DTRACE_PROBE(nfss__i__exported_lock3_stop);
1819 rw_exit(&ne->exported_lock);
1820
1821 if (ne->exi_public == exi || kex->ex_flags & EX_LOG) {
1822 /*
1823 * Log share operation to this buffer only.
1824 */
1825 nfslog_share_record(exi, cr);
1826 }
1827
1828 if (ex != NULL)
1829 exi_rele(ex);
1830
1831 return (0);
1832
1833 out7:
1834 /* Unlink the new export in exptable. */
1835 export_unlink(ne, exi);
1836 DTRACE_PROBE(nfss__i__exported_lock3_stop);
1837 rw_exit(&ne->exported_lock);
1838 out6:
1839 if (kex->ex_flags & EX_INDEX)
1840 kmem_free(kex->ex_index, strlen(kex->ex_index) + 1);
1841 out5:
1842 /* free partially completed allocation */
1843 while (--allocd_seccnt >= 0) {
1844 exs = &kex->ex_secinfo[allocd_seccnt];
1845 srv_secinfo_entry_free(exs);
1846 }
1847
1848 if (kex->ex_secinfo) {
1849 kmem_free(kex->ex_secinfo,
1850 kex->ex_seccnt * sizeof (struct secinfo));
1851 }
1852
1853 out4:
1854 if ((kex->ex_flags & EX_LOG) && kex->ex_tag != NULL)
1855 kmem_free(kex->ex_tag, kex->ex_taglen + 1);
1856 out3:
1857 if ((kex->ex_flags & EX_LOG) && kex->ex_log_buffer != NULL)
1858 kmem_free(kex->ex_log_buffer, kex->ex_log_bufferlen + 1);
1859 out2:
1860 kmem_free(kex->ex_path, kex->ex_pathlen + 1);
1861 out1:
1862 VN_RELE(vp);
1863 if (dvp != NULL)
1864 VN_RELE(dvp);
1865 mutex_destroy(&exi->exi_lock);
1866 rw_destroy(&exi->exi_cache_lock);
1867 for (i = 0; i < AUTH_TABLESIZE; i++) {
1868 avl_destroy(exi->exi_cache[i]);
1869 kmem_free(exi->exi_cache[i], sizeof (avl_tree_t));
1870 }
1871
1872 kmem_free(exi, sizeof (*exi));
1873
1874 return (error);
1875 }
1876
1877 /*
1878 * Remove the exportinfo from the export list
1879 */
1880 void
1881 export_unlink(nfs_export_t *ne, struct exportinfo *exi)
1882 {
1883 ASSERT(RW_WRITE_HELD(&ne->exported_lock));
1884
1885 exp_hash_unlink(exi, fid_hash);
1886 exp_hash_unlink(exi, path_hash);
1887 }
1888
1889 /*
1890 * Unexport an exported filesystem
1891 */
1892 static int
1893 unexport(nfs_export_t *ne, struct exportinfo *exi)
1894 {
1895 struct secinfo cursec[MAX_FLAVORS];
1896 int curcnt;
1897
1898 rw_enter(&ne->exported_lock, RW_WRITER);
1899
1900 /* Check if exi is still linked in the export table */
1901 if (!EXP_LINKED(exi) || PSEUDO(exi)) {
1902 rw_exit(&ne->exported_lock);
1903 return (EINVAL);
1904 }
1905
1906 mutex_enter(&nfs_exi_id_lock);
1907 avl_remove(&exi_id_tree, exi);
1908 mutex_exit(&nfs_exi_id_lock);
1909 export_unlink(ne, exi);
1910
1911 /*
1912 * Remove security flavors before treeclimb_unexport() is called
1913 * because srv_secinfo_treeclimb needs the namespace tree
1914 */
1915 curcnt = build_seclist_nodups(&exi->exi_export, cursec, TRUE);
1916 srv_secinfo_treeclimb(ne, exi, cursec, curcnt, FALSE);
1917
1918 /*
1919 * If there's a visible list, then need to leave
1920 * a pseudo export here to retain the visible list
1921 * for paths to exports below.
1922 */
1923 if (exi->exi_visible != NULL) {
1924 struct exportinfo *newexi;
1925
1926 newexi = pseudo_exportfs(ne, exi->exi_vp, &exi->exi_fid,
1927 exi->exi_visible, &exi->exi_export);
1928 exi->exi_visible = NULL;
1929
1930 /* interconnect the existing treenode with the new exportinfo */
1931 newexi->exi_zone = exi->exi_zone; /* XXX KEBE SAYS LOSE ME */
1932 newexi->exi_tree = exi->exi_tree;
1933 newexi->exi_tree->tree_exi = newexi;
1934
1935 /* Update the change timestamp */
1936 tree_update_change(ne, exi->exi_tree, NULL);
1937 } else {
1938 treeclimb_unexport(ne, exi);
1939 }
1940
1941 rw_exit(&ne->exported_lock);
1942
1943 /*
1944 * Need to call into the NFSv4 server and release all data
1945 * held on this particular export. This is important since
1946 * the v4 server may be holding file locks or vnodes under
1947 * this export.
1948 */
1949 rfs4_clean_state_exi(ne, exi);
1950
1951 /*
1952 * Notify the lock manager that the filesystem is being
1953 * unexported.
1954 */
1955 lm_unexport(exi);
1956
1957 /*
1958 * If this was a public export, restore
1959 * the public filehandle to the root.
1960 */
1961
1962 /*
1963 * XXX KEBE ASKS --> Should CRED() instead be
1964 * exi->exi_zone->zone_kcred?
1965 */
1966 if (exi == ne->exi_public) {
1967 ne->exi_public = ne->exi_root;
1968
1969 nfslog_share_record(ne->exi_public, CRED());
1970 }
1971
1972 if (exi->exi_export.ex_flags & EX_LOG)
1973 nfslog_unshare_record(exi, CRED());
1974
1975 exi_rele(exi);
1976 return (0);
1977 }
1978
1979 /*
1980 * Get file handle system call.
1981 * Takes file name and returns a file handle for it.
1982 * Credentials must be verified before calling.
1983 */
1984 int
1985 nfs_getfh(struct nfs_getfh_args *args, model_t model, cred_t *cr)
1986 {
1987 nfs_fh3 fh;
1988 char buf[NFS3_MAXFHSIZE];
1989 char *logptr, logbuf[NFS3_MAXFHSIZE];
1990 int l = NFS3_MAXFHSIZE;
1991 vnode_t *vp;
1992 vnode_t *dvp;
1993 struct exportinfo *exi;
1994 int error;
1995 int vers;
1996 STRUCT_HANDLE(nfs_getfh_args, uap);
1997
1998 #ifdef lint
1999 model = model; /* STRUCT macros don't always use it */
2000 #endif
2001
2002 STRUCT_SET_HANDLE(uap, model, args);
2003
2004 error = lookupname(STRUCT_FGETP(uap, fname), UIO_USERSPACE,
2005 FOLLOW, &dvp, &vp);
2006 if (error == EINVAL) {
2007 /*
2008 * if fname resolves to / we get EINVAL error
2009 * since we wanted the parent vnode. Try again
2010 * with NULL dvp.
2011 */
2012 error = lookupname(STRUCT_FGETP(uap, fname), UIO_USERSPACE,
2013 FOLLOW, NULL, &vp);
2014 dvp = NULL;
2015 }
2016 if (!error && vp == NULL) {
2017 /*
2018 * Last component of fname not found
2019 */
2020 if (dvp != NULL) {
2021 VN_RELE(dvp);
2022 }
2023 error = ENOENT;
2024 }
2025 if (error)
2026 return (error);
2027
2028 /*
2029 * 'vp' may be an AUTOFS node, so we perform a
2030 * VOP_ACCESS() to trigger the mount of the
2031 * intended filesystem, so we can share the intended
2032 * filesystem instead of the AUTOFS filesystem.
2033 */
2034 (void) VOP_ACCESS(vp, 0, 0, cr, NULL);
2035
2036 /*
2037 * We're interested in the top most filesystem.
2038 * This is specially important when uap->dname is a trigger
2039 * AUTOFS node, since we're really interested in sharing the
2040 * filesystem AUTOFS mounted as result of the VOP_ACCESS()
2041 * call not the AUTOFS node itself.
2042 */
2043 if (vn_mountedvfs(vp) != NULL) {
2044 if (error = traverse(&vp)) {
2045 VN_RELE(vp);
2046 if (dvp != NULL)
2047 VN_RELE(dvp);
2048 return (error);
2049 }
2050 }
2051
2052 vers = STRUCT_FGET(uap, vers);
2053 exi = nfs_vptoexi(dvp, vp, cr, NULL, &error, FALSE);
2054 if (!error) {
2055 if (vers == NFS_VERSION) {
2056 error = makefh((fhandle_t *)buf, vp, exi);
2057 l = NFS_FHSIZE;
2058 logptr = buf;
2059 } else if (vers == NFS_V3) {
2060 int i, sz, pad;
2061
2062 error = makefh3(&fh, vp, exi);
2063 l = RNDUP(fh.fh3_length);
2064 if (!error && (l > sizeof (fhandle3_t)))
2065 error = EREMOTE;
2066 logptr = logbuf;
2067 if (!error) {
2068 i = 0;
2069 sz = sizeof (fsid_t);
2070 bcopy(&fh.fh3_fsid, &buf[i], sz);
2071 i += sz;
2072
2073 /*
2074 * For backwards compatibility, the
2075 * fid length may be less than
2076 * NFS_FHMAXDATA, but it was always
2077 * encoded as NFS_FHMAXDATA bytes.
2078 */
2079
2080 sz = sizeof (ushort_t);
2081 bcopy(&fh.fh3_len, &buf[i], sz);
2082 i += sz;
2083 bcopy(fh.fh3_data, &buf[i], fh.fh3_len);
2084 i += fh.fh3_len;
2085 pad = (NFS_FHMAXDATA - fh.fh3_len);
2086 if (pad > 0) {
2087 bzero(&buf[i], pad);
2088 i += pad;
2089 l += pad;
2090 }
2091
2092 sz = sizeof (ushort_t);
2093 bcopy(&fh.fh3_xlen, &buf[i], sz);
2094 i += sz;
2095 bcopy(fh.fh3_xdata, &buf[i], fh.fh3_xlen);
2096 i += fh.fh3_xlen;
2097 pad = (NFS_FHMAXDATA - fh.fh3_xlen);
2098 if (pad > 0) {
2099 bzero(&buf[i], pad);
2100 i += pad;
2101 l += pad;
2102 }
2103 }
2104 /*
2105 * If we need to do NFS logging, the filehandle
2106 * must be downsized to 32 bytes.
2107 */
2108 if (!error && exi->exi_export.ex_flags & EX_LOG) {
2109 i = 0;
2110 sz = sizeof (fsid_t);
2111 bcopy(&fh.fh3_fsid, &logbuf[i], sz);
2112 i += sz;
2113 sz = sizeof (ushort_t);
2114 bcopy(&fh.fh3_len, &logbuf[i], sz);
2115 i += sz;
2116 sz = NFS_FHMAXDATA;
2117 bcopy(fh.fh3_data, &logbuf[i], sz);
2118 i += sz;
2119 sz = sizeof (ushort_t);
2120 bcopy(&fh.fh3_xlen, &logbuf[i], sz);
2121 i += sz;
2122 sz = NFS_FHMAXDATA;
2123 bcopy(fh.fh3_xdata, &logbuf[i], sz);
2124 i += sz;
2125 }
2126 }
2127 if (!error && exi->exi_export.ex_flags & EX_LOG) {
2128 nfslog_getfh(exi, (fhandle_t *)logptr,
2129 STRUCT_FGETP(uap, fname), UIO_USERSPACE, cr);
2130 }
2131 exi_rele(exi);
2132 if (!error) {
2133 if (copyout(&l, STRUCT_FGETP(uap, lenp), sizeof (int)))
2134 error = EFAULT;
2135 if (copyout(buf, STRUCT_FGETP(uap, fhp), l))
2136 error = EFAULT;
2137 }
2138 }
2139 VN_RELE(vp);
2140 if (dvp != NULL) {
2141 VN_RELE(dvp);
2142 }
2143 return (error);
2144 }
2145
2146 /*
2147 * Strategy: if vp is in the export list, then
2148 * return the associated file handle. Otherwise, ".."
2149 * once up the vp and try again, until the root of the
2150 * filesystem is reached.
2151 */
2152 struct exportinfo *
2153 nfs_vptoexi(vnode_t *dvp, vnode_t *vp, cred_t *cr, int *walk,
2154 int *err, bool_t v4srv)
2155 {
2156 fid_t fid;
2157 int error;
2158 struct exportinfo *exi;
2159
2160 ASSERT(vp);
2161 VN_HOLD(vp);
2162 if (dvp != NULL) {
2163 VN_HOLD(dvp);
2164 }
2165 if (walk != NULL)
2166 *walk = 0;
2167
2168 for (;;) {
2169 bzero(&fid, sizeof (fid));
2170 fid.fid_len = MAXFIDSZ;
2171 error = vop_fid_pseudo(vp, &fid);
2172 if (error) {
2173 /*
2174 * If vop_fid_pseudo returns ENOSPC then the fid
2175 * supplied is too small. For now we simply
2176 * return EREMOTE.
2177 */
2178 if (error == ENOSPC)
2179 error = EREMOTE;
2180 break;
2181 }
2182
2183 if (v4srv)
2184 exi = checkexport4(&vp->v_vfsp->vfs_fsid, &fid, vp);
2185 else
2186 exi = checkexport(&vp->v_vfsp->vfs_fsid, &fid);
2187
2188 if (exi != NULL) {
2189 /*
2190 * Found the export info
2191 */
2192 break;
2193 }
2194
2195 /*
2196 * We have just failed finding a matching export.
2197 * If we're at the root of this filesystem, then
2198 * it's time to stop (with failure).
2199 */
2200 ASSERT3P(vp->v_vfsp->vfs_zone, ==, curzone);
2201 if ((vp->v_flag & VROOT) || VN_IS_CURZONEROOT(vp)) {
2202 error = EINVAL;
2203 break;
2204 }
2205
2206 if (walk != NULL)
2207 (*walk)++;
2208
2209 /*
2210 * Now, do a ".." up vp. If dvp is supplied, use it,
2211 * otherwise, look it up.
2212 */
2213 if (dvp == NULL) {
2214 error = VOP_LOOKUP(vp, "..", &dvp, NULL, 0, NULL, cr,
2215 NULL, NULL, NULL);
2216 if (error)
2217 break;
2218 }
2219 VN_RELE(vp);
2220 vp = dvp;
2221 dvp = NULL;
2222 }
2223 VN_RELE(vp);
2224 if (dvp != NULL) {
2225 VN_RELE(dvp);
2226 }
2227 if (error != 0) {
2228 if (err != NULL)
2229 *err = error;
2230 return (NULL);
2231 }
2232 return (exi);
2233 }
2234
2235 int
2236 chk_clnt_sec(exportinfo_t *exi, struct svc_req *req)
2237 {
2238 int i, nfsflavor;
2239 struct secinfo *sp;
2240
2241 /*
2242 * Get the nfs flavor number from xprt.
2243 */
2244 nfsflavor = (int)(uintptr_t)req->rq_xprt->xp_cookie;
2245
2246 sp = exi->exi_export.ex_secinfo;
2247 for (i = 0; i < exi->exi_export.ex_seccnt; i++) {
2248 if ((nfsflavor == sp[i].s_secinfo.sc_nfsnum) &&
2249 SEC_REF_EXPORTED(sp + i))
2250 return (TRUE);
2251 }
2252 return (FALSE);
2253 }
2254
2255 /*
2256 * Make an fhandle from a vnode
2257 */
2258 int
2259 makefh(fhandle_t *fh, vnode_t *vp, exportinfo_t *exi)
2260 {
2261 int error;
2262
2263 *fh = exi->exi_fh; /* struct copy */
2264
2265 error = VOP_FID(vp, (fid_t *)&fh->fh_len, NULL);
2266 if (error) {
2267 /*
2268 * Should be something other than EREMOTE
2269 */
2270 return (EREMOTE);
2271 }
2272 return (0);
2273 }
2274
2275 /*
2276 * This routine makes an overloaded V2 fhandle which contains
2277 * sec modes.
2278 *
2279 * Note that the first four octets contain the length octet,
2280 * the status octet, and two padded octets to make them XDR
2281 * four-octet aligned.
2282 *
2283 * 1 2 3 4 32
2284 * +---+---+---+---+---+---+---+---+ +---+---+---+---+ +---+
2285 * | l | s | | | sec_1 |...| sec_n |...| |
2286 * +---+---+---+---+---+---+---+---+ +---+---+---+---+ +---+
2287 *
2288 * where
2289 *
2290 * the status octet s indicates whether there are more security
2291 * flavors (1 means yes, 0 means no) that require the client to
2292 * perform another 0x81 LOOKUP to get them,
2293 *
2294 * the length octet l is the length describing the number of
2295 * valid octets that follow. (l = 4 * n, where n is the number
2296 * of security flavors sent in the current overloaded filehandle.)
2297 *
2298 * sec_index should always be in the inclusive range: [1 - ex_seccnt],
2299 * and it tells server where to start within the secinfo array.
2300 * Usually it will always be 1; however, if more flavors are used
2301 * for the public export than can be encoded in the overloaded FH
2302 * (7 for NFS2), subsequent SNEGO MCLs will have a larger index
2303 * so the server will pick up where it left off from the previous
2304 * MCL reply.
2305 *
2306 * With NFS4 support, implicitly allowed flavors are also in
2307 * the secinfo array; however, they should not be returned in
2308 * SNEGO MCL replies.
2309 */
2310 int
2311 makefh_ol(fhandle_t *fh, exportinfo_t *exi, uint_t sec_index)
2312 {
2313 secinfo_t sec[MAX_FLAVORS];
2314 int totalcnt, i, *ipt, cnt, seccnt, secidx, fh_max_cnt;
2315 char *c;
2316
2317 if (fh == NULL || exi == NULL || sec_index < 1)
2318 return (EREMOTE);
2319
2320 /*
2321 * WebNFS clients need to know the unique set of explicitly
2322 * shared flavors in used for the public export. When
2323 * "TRUE" is passed to build_seclist_nodups(), only explicitly
2324 * shared flavors are included in the list.
2325 */
2326 seccnt = build_seclist_nodups(&exi->exi_export, sec, TRUE);
2327 if (sec_index > seccnt)
2328 return (EREMOTE);
2329
2330 fh_max_cnt = (NFS_FHSIZE / sizeof (int)) - 1;
2331 totalcnt = seccnt - sec_index + 1;
2332 cnt = totalcnt > fh_max_cnt ? fh_max_cnt : totalcnt;
2333
2334 c = (char *)fh;
2335 /*
2336 * Encode the length octet representing the number of
2337 * security flavors (in bytes) in this overloaded fh.
2338 */
2339 *c = cnt * sizeof (int);
2340
2341 /*
2342 * Encode the status octet that indicates whether there
2343 * are more security flavors the client needs to get.
2344 */
2345 *(c + 1) = totalcnt > fh_max_cnt;
2346
2347 /*
2348 * put security flavors in the overloaded fh
2349 */
2350 ipt = (int *)(c + sizeof (int32_t));
2351 secidx = sec_index - 1;
2352 for (i = 0; i < cnt; i++) {
2353 ipt[i] = htonl(sec[i + secidx].s_secinfo.sc_nfsnum);
2354 }
2355 return (0);
2356 }
2357
2358 /*
2359 * Make an nfs_fh3 from a vnode
2360 */
2361 int
2362 makefh3(nfs_fh3 *fh, vnode_t *vp, struct exportinfo *exi)
2363 {
2364 int error;
2365 fid_t fid;
2366
2367 bzero(&fid, sizeof (fid));
2368 fid.fid_len = sizeof (fh->fh3_data);
2369 error = VOP_FID(vp, &fid, NULL);
2370 if (error)
2371 return (EREMOTE);
2372
2373 bzero(fh, sizeof (nfs_fh3));
2374 fh->fh3_fsid = exi->exi_fsid;
2375 fh->fh3_len = fid.fid_len;
2376 bcopy(fid.fid_data, fh->fh3_data, fh->fh3_len);
2377
2378 fh->fh3_xlen = exi->exi_fid.fid_len;
2379 ASSERT(fh->fh3_xlen <= sizeof (fh->fh3_xdata));
2380 bcopy(exi->exi_fid.fid_data, fh->fh3_xdata, fh->fh3_xlen);
2381
2382 fh->fh3_length = sizeof (fh->fh3_fsid)
2383 + sizeof (fh->fh3_len) + fh->fh3_len
2384 + sizeof (fh->fh3_xlen) + fh->fh3_xlen;
2385 fh->fh3_flags = 0;
2386
2387 return (0);
2388 }
2389
2390 /*
2391 * This routine makes an overloaded V3 fhandle which contains
2392 * sec modes.
2393 *
2394 * 1 4
2395 * +--+--+--+--+
2396 * | len |
2397 * +--+--+--+--+
2398 * up to 64
2399 * +--+--+--+--+--+--+--+--+--+--+--+--+ +--+--+--+--+
2400 * |s | | | | sec_1 | sec_2 | ... | sec_n |
2401 * +--+--+--+--+--+--+--+--+--+--+--+--+ +--+--+--+--+
2402 *
2403 * len = 4 * (n+1), where n is the number of security flavors
2404 * sent in the current overloaded filehandle.
2405 *
2406 * the status octet s indicates whether there are more security
2407 * mechanisms (1 means yes, 0 means no) that require the client
2408 * to perform another 0x81 LOOKUP to get them.
2409 *
2410 * Three octets are padded after the status octet.
2411 */
2412 int
2413 makefh3_ol(nfs_fh3 *fh, struct exportinfo *exi, uint_t sec_index)
2414 {
2415 secinfo_t sec[MAX_FLAVORS];
2416 int totalcnt, cnt, *ipt, i, seccnt, fh_max_cnt, secidx;
2417 char *c;
2418
2419 if (fh == NULL || exi == NULL || sec_index < 1)
2420 return (EREMOTE);
2421
2422 /*
2423 * WebNFS clients need to know the unique set of explicitly
2424 * shared flavors in used for the public export. When
2425 * "TRUE" is passed to build_seclist_nodups(), only explicitly
2426 * shared flavors are included in the list.
2427 */
2428 seccnt = build_seclist_nodups(&exi->exi_export, sec, TRUE);
2429
2430 if (sec_index > seccnt)
2431 return (EREMOTE);
2432
2433 fh_max_cnt = (NFS3_FHSIZE / sizeof (int)) - 1;
2434 totalcnt = seccnt - sec_index + 1;
2435 cnt = totalcnt > fh_max_cnt ? fh_max_cnt : totalcnt;
2436
2437 /*
2438 * Place the length in fh3_length representing the number
2439 * of security flavors (in bytes) in this overloaded fh.
2440 */
2441 fh->fh3_flags = FH_WEBNFS;
2442 fh->fh3_length = (cnt+1) * sizeof (int32_t);
2443
2444 c = (char *)&fh->fh3_u.nfs_fh3_i.fh3_i;
2445 /*
2446 * Encode the status octet that indicates whether there
2447 * are more security flavors the client needs to get.
2448 */
2449 *c = totalcnt > fh_max_cnt;
2450
2451 /*
2452 * put security flavors in the overloaded fh
2453 */
2454 secidx = sec_index - 1;
2455 ipt = (int *)(c + sizeof (int32_t));
2456 for (i = 0; i < cnt; i++) {
2457 ipt[i] = htonl(sec[i + secidx].s_secinfo.sc_nfsnum);
2458 }
2459 return (0);
2460 }
2461
2462 /*
2463 * Make an nfs_fh4 from a vnode
2464 */
2465 int
2466 makefh4(nfs_fh4 *fh, vnode_t *vp, struct exportinfo *exi)
2467 {
2468 int error;
2469 nfs_fh4_fmt_t *fh_fmtp = (nfs_fh4_fmt_t *)fh->nfs_fh4_val;
2470 fid_t fid;
2471
2472 bzero(&fid, sizeof (fid));
2473 fid.fid_len = MAXFIDSZ;
2474 /*
2475 * vop_fid_pseudo() is used to set up NFSv4 namespace, so
2476 * use vop_fid_pseudo() here to get the fid instead of VOP_FID.
2477 */
2478 error = vop_fid_pseudo(vp, &fid);
2479 if (error)
2480 return (error);
2481
2482 fh->nfs_fh4_len = NFS_FH4_LEN;
2483
2484 fh_fmtp->fh4_i.fhx_fsid = exi->exi_fh.fh_fsid;
2485 fh_fmtp->fh4_i.fhx_xlen = exi->exi_fh.fh_xlen;
2486
2487 bzero(fh_fmtp->fh4_i.fhx_data, sizeof (fh_fmtp->fh4_i.fhx_data));
2488 bzero(fh_fmtp->fh4_i.fhx_xdata, sizeof (fh_fmtp->fh4_i.fhx_xdata));
2489 ASSERT(exi->exi_fh.fh_xlen <= sizeof (fh_fmtp->fh4_i.fhx_xdata));
2490 bcopy(exi->exi_fh.fh_xdata, fh_fmtp->fh4_i.fhx_xdata,
2491 exi->exi_fh.fh_xlen);
2492
2493 fh_fmtp->fh4_len = fid.fid_len;
2494 ASSERT(fid.fid_len <= sizeof (fh_fmtp->fh4_data));
2495 bcopy(fid.fid_data, fh_fmtp->fh4_data, fid.fid_len);
2496 fh_fmtp->fh4_flag = 0;
2497
2498 #ifdef VOLATILE_FH_TEST
2499 /*
2500 * XXX (temporary?)
2501 * Use the rnode volatile_id value to add volatility to the fh.
2502 *
2503 * For testing purposes there are currently two scenarios, based
2504 * on whether the filesystem was shared with "volatile_fh"
2505 * or "expire_on_rename". In the first case, use the value of
2506 * export struct share_time as the volatile_id. In the second
2507 * case use the vnode volatile_id value (which is set to the
2508 * time in which the file was renamed).
2509 *
2510 * Note that the above are temporary constructs for testing only
2511 * XXX
2512 */
2513 if (exi->exi_export.ex_flags & EX_VOLRNM) {
2514 fh_fmtp->fh4_volatile_id = find_volrnm_fh_id(exi, fh);
2515 } else if (exi->exi_export.ex_flags & EX_VOLFH) {
2516 fh_fmtp->fh4_volatile_id = exi->exi_volatile_id;
2517 } else {
2518 fh_fmtp->fh4_volatile_id = 0;
2519 }
2520 #endif /* VOLATILE_FH_TEST */
2521
2522 return (0);
2523 }
2524
2525 /*
2526 * Convert an fhandle into a vnode.
2527 * Uses the file id (fh_len + fh_data) in the fhandle to get the vnode.
2528 * WARNING: users of this routine must do a VN_RELE on the vnode when they
2529 * are done with it.
2530 */
2531 vnode_t *
2532 nfs_fhtovp(fhandle_t *fh, struct exportinfo *exi)
2533 {
2534 vfs_t *vfsp;
2535 vnode_t *vp;
2536 int error;
2537 fid_t *fidp;
2538
2539 TRACE_0(TR_FAC_NFS, TR_FHTOVP_START,
2540 "fhtovp_start");
2541
2542 if (exi == NULL) {
2543 TRACE_1(TR_FAC_NFS, TR_FHTOVP_END,
2544 "fhtovp_end:(%S)", "exi NULL");
2545 return (NULL); /* not exported */
2546 }
2547
2548 ASSERT(exi->exi_vp != NULL);
2549
2550 if (PUBLIC_FH2(fh)) {
2551 if (exi->exi_export.ex_flags & EX_PUBLIC) {
2552 TRACE_1(TR_FAC_NFS, TR_FHTOVP_END,
2553 "fhtovp_end:(%S)", "root not exported");
2554 return (NULL);
2555 }
2556 vp = exi->exi_vp;
2557 VN_HOLD(vp);
2558 return (vp);
2559 }
2560
2561 vfsp = exi->exi_vp->v_vfsp;
2562 ASSERT(vfsp != NULL);
2563 fidp = (fid_t *)&fh->fh_len;
2564
2565 error = VFS_VGET(vfsp, &vp, fidp);
2566 if (error || vp == NULL) {
2567 TRACE_1(TR_FAC_NFS, TR_FHTOVP_END,
2568 "fhtovp_end:(%S)", "VFS_GET failed or vp NULL");
2569 return (NULL);
2570 }
2571 TRACE_1(TR_FAC_NFS, TR_FHTOVP_END,
2572 "fhtovp_end:(%S)", "end");
2573 return (vp);
2574 }
2575
2576 /*
2577 * Convert an nfs_fh3 into a vnode.
2578 * Uses the file id (fh_len + fh_data) in the file handle to get the vnode.
2579 * WARNING: users of this routine must do a VN_RELE on the vnode when they
2580 * are done with it.
2581 */
2582 vnode_t *
2583 nfs3_fhtovp(nfs_fh3 *fh, struct exportinfo *exi)
2584 {
2585 vfs_t *vfsp;
2586 vnode_t *vp;
2587 int error;
2588 fid_t *fidp;
2589
2590 if (exi == NULL)
2591 return (NULL); /* not exported */
2592
2593 ASSERT(exi->exi_vp != NULL);
2594
2595 if (PUBLIC_FH3(fh)) {
2596 if (exi->exi_export.ex_flags & EX_PUBLIC)
2597 return (NULL);
2598 vp = exi->exi_vp;
2599 VN_HOLD(vp);
2600 return (vp);
2601 }
2602
2603 if (fh->fh3_length < NFS3_OLDFHSIZE ||
2604 fh->fh3_length > NFS3_MAXFHSIZE)
2605 return (NULL);
2606
2607 vfsp = exi->exi_vp->v_vfsp;
2608 ASSERT(vfsp != NULL);
2609 fidp = FH3TOFIDP(fh);
2610
2611 error = VFS_VGET(vfsp, &vp, fidp);
2612 if (error || vp == NULL)
2613 return (NULL);
2614
2615 return (vp);
2616 }
2617
2618 /*
2619 * Convert an nfs_fh4 into a vnode.
2620 * Uses the file id (fh_len + fh_data) in the file handle to get the vnode.
2621 * WARNING: users of this routine must do a VN_RELE on the vnode when they
2622 * are done with it.
2623 */
2624 vnode_t *
2625 nfs4_fhtovp(nfs_fh4 *fh, struct exportinfo *exi, nfsstat4 *statp)
2626 {
2627 vfs_t *vfsp;
2628 vnode_t *vp = NULL;
2629 int error;
2630 fid_t *fidp;
2631 nfs_fh4_fmt_t *fh_fmtp;
2632 #ifdef VOLATILE_FH_TEST
2633 uint32_t volatile_id = 0;
2634 #endif /* VOLATILE_FH_TEST */
2635
2636 if (exi == NULL) {
2637 *statp = NFS4ERR_STALE;
2638 return (NULL); /* not exported */
2639 }
2640 ASSERT(exi->exi_vp != NULL);
2641
2642 /* caller should have checked this */
2643 ASSERT(fh->nfs_fh4_len >= NFS_FH4_LEN);
2644
2645 fh_fmtp = (nfs_fh4_fmt_t *)fh->nfs_fh4_val;
2646 vfsp = exi->exi_vp->v_vfsp;
2647 ASSERT(vfsp != NULL);
2648 fidp = (fid_t *)&fh_fmtp->fh4_len;
2649
2650 #ifdef VOLATILE_FH_TEST
2651 /* XXX check if volatile - should be changed later */
2652 if (exi->exi_export.ex_flags & (EX_VOLRNM | EX_VOLFH)) {
2653 /*
2654 * Filesystem is shared with volatile filehandles
2655 */
2656 if (exi->exi_export.ex_flags & EX_VOLRNM)
2657 volatile_id = find_volrnm_fh_id(exi, fh);
2658 else
2659 volatile_id = exi->exi_volatile_id;
2660
2661 if (fh_fmtp->fh4_volatile_id != volatile_id) {
2662 *statp = NFS4ERR_FHEXPIRED;
2663 return (NULL);
2664 }
2665 }
2666 /*
2667 * XXX even if test_volatile_fh false, the fh may contain a
2668 * volatile id if obtained when the test was set.
2669 */
2670 fh_fmtp->fh4_volatile_id = (uchar_t)0;
2671 #endif /* VOLATILE_FH_TEST */
2672
2673 error = VFS_VGET(vfsp, &vp, fidp);
2674 /*
2675 * If we can not get vp from VFS_VGET, perhaps this is
2676 * an nfs v2/v3/v4 node in an nfsv4 pseudo filesystem.
2677 * Check it out.
2678 */
2679 if (error && PSEUDO(exi))
2680 error = nfs4_vget_pseudo(exi, &vp, fidp);
2681
2682 if (error || vp == NULL) {
2683 *statp = NFS4ERR_STALE;
2684 return (NULL);
2685 }
2686 /* XXX - disgusting hack */
2687 if (vp->v_type == VNON && vp->v_flag & V_XATTRDIR)
2688 vp->v_type = VDIR;
2689 *statp = NFS4_OK;
2690 return (vp);
2691 }
2692
2693 /*
2694 * Find the export structure associated with the given filesystem.
2695 * If found, then increment the ref count (exi_count).
2696 */
2697 struct exportinfo *
2698 checkexport(fsid_t *fsid, fid_t *fid)
2699 {
2700 struct exportinfo *exi;
2701 nfs_export_t *ne = nfs_get_export();
2702
2703 rw_enter(&ne->exported_lock, RW_READER);
2704 for (exi = ne->exptable[exptablehash(fsid, fid)];
2705 exi != NULL;
2706 exi = exi->fid_hash.next) {
2707 if (exportmatch(exi, fsid, fid)) {
2708 /*
2709 * If this is the place holder for the
2710 * public file handle, then return the
2711 * real export entry for the public file
2712 * handle.
2713 */
2714 if (exi->exi_export.ex_flags & EX_PUBLIC) {
2715 exi = ne->exi_public;
2716 }
2717
2718 exi_hold(exi);
2719 rw_exit(&ne->exported_lock);
2720 return (exi);
2721 }
2722 }
2723 rw_exit(&ne->exported_lock);
2724 return (NULL);
2725 }
2726
2727
2728 /*
2729 * "old school" version of checkexport() for NFS4. NFS4
2730 * rfs4_compound holds exported_lock for duration of compound
2731 * processing. This version doesn't manipulate exi_count
2732 * since NFS4 breaks fundamental assumptions in the exi_count
2733 * design.
2734 */
2735 struct exportinfo *
2736 checkexport4(fsid_t *fsid, fid_t *fid, vnode_t *vp)
2737 {
2738 struct exportinfo *exi;
2739 nfs_export_t *ne = nfs_get_export();
2740
2741 ASSERT(RW_LOCK_HELD(&ne->exported_lock));
2742
2743 for (exi = ne->exptable[exptablehash(fsid, fid)];
2744 exi != NULL;
2745 exi = exi->fid_hash.next) {
2746 if (exportmatch(exi, fsid, fid)) {
2747 /*
2748 * If this is the place holder for the
2749 * public file handle, then return the
2750 * real export entry for the public file
2751 * handle.
2752 */
2753 if (exi->exi_export.ex_flags & EX_PUBLIC) {
2754 exi = ne->exi_public;
2755 }
2756
2757 /*
2758 * If vp is given, check if vp is the
2759 * same vnode as the exported node.
2760 *
2761 * Since VOP_FID of a lofs node returns the
2762 * fid of its real node (ufs), the exported
2763 * node for lofs and (pseudo) ufs may have
2764 * the same fsid and fid.
2765 */
2766 if (vp == NULL || vp == exi->exi_vp)
2767 return (exi);
2768 }
2769 }
2770
2771 return (NULL);
2772 }
2773
2774 /*
2775 * Free an entire export list node
2776 */
2777 void
2778 exportfree(struct exportinfo *exi)
2779 {
2780 struct exportdata *ex;
2781 struct charset_cache *cache;
2782 int i;
2783
2784 ex = &exi->exi_export;
2785
2786 ASSERT(exi->exi_vp != NULL && !(exi->exi_export.ex_flags & EX_PUBLIC));
2787 VN_RELE(exi->exi_vp);
2788 if (exi->exi_dvp != NULL)
2789 VN_RELE(exi->exi_dvp);
2790
2791 if (ex->ex_flags & EX_INDEX)
2792 kmem_free(ex->ex_index, strlen(ex->ex_index) + 1);
2793
2794 kmem_free(ex->ex_path, ex->ex_pathlen + 1);
2795 nfsauth_cache_free(exi);
2796
2797 /*
2798 * if there is a character set mapping cached, clean it up.
2799 */
2800 for (cache = exi->exi_charset; cache != NULL;
2801 cache = exi->exi_charset) {
2802 if (cache->inbound != (kiconv_t)-1)
2803 (void) kiconv_close(cache->inbound);
2804 if (cache->outbound != (kiconv_t)-1)
2805 (void) kiconv_close(cache->outbound);
2806 exi->exi_charset = cache->next;
2807 kmem_free(cache, sizeof (struct charset_cache));
2808 }
2809
2810 if (exi->exi_logbuffer != NULL)
2811 nfslog_disable(exi);
2812
2813 if (ex->ex_flags & EX_LOG) {
2814 kmem_free(ex->ex_log_buffer, ex->ex_log_bufferlen + 1);
2815 kmem_free(ex->ex_tag, ex->ex_taglen + 1);
2816 }
2817
2818 if (exi->exi_visible)
2819 free_visible(exi->exi_visible);
2820
2821 srv_secinfo_list_free(ex->ex_secinfo, ex->ex_seccnt);
2822
2823 #ifdef VOLATILE_FH_TEST
2824 free_volrnm_list(exi);
2825 mutex_destroy(&exi->exi_vol_rename_lock);
2826 #endif /* VOLATILE_FH_TEST */
2827
2828 mutex_destroy(&exi->exi_lock);
2829 rw_destroy(&exi->exi_cache_lock);
2830 /*
2831 * All nodes in the exi_cache AVL trees were removed and freed in the
2832 * nfsauth_cache_free() call above. We will just destroy and free the
2833 * empty AVL trees here.
2834 */
2835 for (i = 0; i < AUTH_TABLESIZE; i++) {
2836 avl_destroy(exi->exi_cache[i]);
2837 kmem_free(exi->exi_cache[i], sizeof (avl_tree_t));
2838 }
2839
2840 kmem_free(exi, sizeof (*exi));
2841 }
2842
2843 /*
2844 * load the index file from user space into kernel space.
2845 */
2846 static int
2847 loadindex(struct exportdata *kex)
2848 {
2849 int error;
2850 char index[MAXNAMELEN+1];
2851 size_t len;
2852
2853 /*
2854 * copyinstr copies the complete string including the NULL and
2855 * returns the len with the NULL byte included in the calculation
2856 * as long as the max length is not exceeded.
2857 */
2858 if (error = copyinstr(kex->ex_index, index, sizeof (index), &len))
2859 return (error);
2860
2861 kex->ex_index = kmem_alloc(len, KM_SLEEP);
2862 bcopy(index, kex->ex_index, len);
2863
2864 return (0);
2865 }
2866
2867 void
2868 exi_hold(struct exportinfo *exi)
2869 {
2870 mutex_enter(&exi->exi_lock);
2871 exi->exi_count++;
2872 mutex_exit(&exi->exi_lock);
2873 }
2874
2875 /*
2876 * When a thread completes using exi, it should call exi_rele().
2877 * exi_rele() decrements exi_count. It releases exi if exi_count == 0, i.e.
2878 * if this is the last user of exi and exi is not on exportinfo list anymore
2879 */
2880 void
2881 exi_rele(struct exportinfo *exi)
2882 {
2883 mutex_enter(&exi->exi_lock);
2884 exi->exi_count--;
2885 if (exi->exi_count == 0) {
2886 mutex_exit(&exi->exi_lock);
2887 exportfree(exi);
2888 } else
2889 mutex_exit(&exi->exi_lock);
2890 }
2891
2892 #ifdef VOLATILE_FH_TEST
2893 /*
2894 * Test for volatile fh's - add file handle to list and set its volatile id
2895 * to time it was renamed. If EX_VOLFH is also on and the fs is reshared,
2896 * the vol_rename queue is purged.
2897 *
2898 * XXX This code is for unit testing purposes only... To correctly use it, it
2899 * needs to tie a rename list to the export struct and (more
2900 * important), protect access to the exi rename list using a write lock.
2901 */
2902
2903 /*
2904 * get the fh vol record if it's in the volatile on rename list. Don't check
2905 * volatile_id in the file handle - compare only the file handles.
2906 */
2907 static struct ex_vol_rename *
2908 find_volrnm_fh(struct exportinfo *exi, nfs_fh4 *fh4p)
2909 {
2910 struct ex_vol_rename *p = NULL;
2911 fhandle4_t *fhp;
2912
2913 /* XXX shouldn't we assert &exported_lock held? */
2914 ASSERT(MUTEX_HELD(&exi->exi_vol_rename_lock));
2915
2916 if (fh4p->nfs_fh4_len != NFS_FH4_LEN) {
2917 return (NULL);
2918 }
2919 fhp = &((nfs_fh4_fmt_t *)fh4p->nfs_fh4_val)->fh4_i;
2920 for (p = exi->exi_vol_rename; p != NULL; p = p->vrn_next) {
2921 if (bcmp(fhp, &p->vrn_fh_fmt.fh4_i,
2922 sizeof (fhandle4_t)) == 0)
2923 break;
2924 }
2925 return (p);
2926 }
2927
2928 /*
2929 * get the volatile id for the fh (if there is - else return 0). Ignore the
2930 * volatile_id in the file handle - compare only the file handles.
2931 */
2932 static uint32_t
2933 find_volrnm_fh_id(struct exportinfo *exi, nfs_fh4 *fh4p)
2934 {
2935 struct ex_vol_rename *p;
2936 uint32_t volatile_id;
2937
2938 mutex_enter(&exi->exi_vol_rename_lock);
2939 p = find_volrnm_fh(exi, fh4p);
2940 volatile_id = (p ? p->vrn_fh_fmt.fh4_volatile_id :
2941 exi->exi_volatile_id);
2942 mutex_exit(&exi->exi_vol_rename_lock);
2943 return (volatile_id);
2944 }
2945
2946 /*
2947 * Free the volatile on rename list - will be called if a filesystem is
2948 * unshared or reshared without EX_VOLRNM
2949 */
2950 static void
2951 free_volrnm_list(struct exportinfo *exi)
2952 {
2953 struct ex_vol_rename *p, *pnext;
2954
2955 /* no need to hold mutex lock - this one is called from exportfree */
2956 for (p = exi->exi_vol_rename; p != NULL; p = pnext) {
2957 pnext = p->vrn_next;
2958 kmem_free(p, sizeof (*p));
2959 }
2960 exi->exi_vol_rename = NULL;
2961 }
2962
2963 /*
2964 * Add a file handle to the volatile on rename list.
2965 */
2966 void
2967 add_volrnm_fh(struct exportinfo *exi, vnode_t *vp)
2968 {
2969 struct ex_vol_rename *p;
2970 char fhbuf[NFS4_FHSIZE];
2971 nfs_fh4 fh4;
2972 int error;
2973
2974 fh4.nfs_fh4_val = fhbuf;
2975 error = makefh4(&fh4, vp, exi);
2976 if ((error) || (fh4.nfs_fh4_len != sizeof (p->vrn_fh_fmt))) {
2977 return;
2978 }
2979
2980 mutex_enter(&exi->exi_vol_rename_lock);
2981
2982 p = find_volrnm_fh(exi, &fh4);
2983
2984 if (p == NULL) {
2985 p = kmem_alloc(sizeof (*p), KM_SLEEP);
2986 bcopy(fh4.nfs_fh4_val, &p->vrn_fh_fmt, sizeof (p->vrn_fh_fmt));
2987 p->vrn_next = exi->exi_vol_rename;
2988 exi->exi_vol_rename = p;
2989 }
2990
2991 p->vrn_fh_fmt.fh4_volatile_id = gethrestime_sec();
2992 mutex_exit(&exi->exi_vol_rename_lock);
2993 }
2994
2995 #endif /* VOLATILE_FH_TEST */