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