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 * Copyright (c) 1990, 2010, Oracle and/or its affiliates. All rights reserved.
23 * Copyright (c) 2011 Bayard G. Bell. All rights reserved.
24 * Copyright (c) 2013 by Delphix. All rights reserved.
25 * Copyright (c) 2017 Joyent Inc
26 * Copyright 2019 Nexenta by DDN, Inc.
27 */
28
29 /*
30 * Copyright (c) 1983,1984,1985,1986,1987,1988,1989 AT&T.
31 * All rights reserved.
32 * Use is subject to license terms.
33 */
34
35 #include <sys/param.h>
36 #include <sys/types.h>
37 #include <sys/systm.h>
38 #include <sys/cred.h>
39 #include <sys/proc.h>
40 #include <sys/user.h>
41 #include <sys/buf.h>
42 #include <sys/vfs.h>
43 #include <sys/vnode.h>
44 #include <sys/pathname.h>
45 #include <sys/uio.h>
46 #include <sys/file.h>
47 #include <sys/stat.h>
48 #include <sys/errno.h>
49 #include <sys/socket.h>
50 #include <sys/sysmacros.h>
51 #include <sys/siginfo.h>
52 #include <sys/tiuser.h>
53 #include <sys/statvfs.h>
54 #include <sys/stream.h>
55 #include <sys/strsun.h>
56 #include <sys/strsubr.h>
57 #include <sys/stropts.h>
58 #include <sys/timod.h>
59 #include <sys/t_kuser.h>
60 #include <sys/kmem.h>
61 #include <sys/kstat.h>
62 #include <sys/dirent.h>
63 #include <sys/cmn_err.h>
64 #include <sys/debug.h>
65 #include <sys/unistd.h>
66 #include <sys/vtrace.h>
67 #include <sys/mode.h>
68 #include <sys/acl.h>
69 #include <sys/sdt.h>
70 #include <sys/debug.h>
71
72 #include <rpc/types.h>
73 #include <rpc/auth.h>
74 #include <rpc/auth_unix.h>
75 #include <rpc/auth_des.h>
76 #include <rpc/svc.h>
77 #include <rpc/xdr.h>
78 #include <rpc/rpc_rdma.h>
79
80 #include <nfs/nfs.h>
81 #include <nfs/export.h>
82 #include <nfs/nfssys.h>
83 #include <nfs/nfs_clnt.h>
84 #include <nfs/nfs_acl.h>
85 #include <nfs/nfs_log.h>
86 #include <nfs/lm.h>
87 #include <nfs/nfs_dispatch.h>
88 #include <nfs/nfs4_drc.h>
89
90 #include <sys/modctl.h>
91 #include <sys/cladm.h>
92 #include <sys/clconf.h>
93
94 #include <sys/tsol/label.h>
95
96 #define MAXHOST 32
97 const char *kinet_ntop6(uchar_t *, char *, size_t);
98
99 /*
100 * Module linkage information.
101 */
102
103 static struct modlmisc modlmisc = {
104 &mod_miscops, "NFS server module"
105 };
106
107 static struct modlinkage modlinkage = {
108 MODREV_1, (void *)&modlmisc, NULL
109 };
110
111 zone_key_t nfssrv_zone_key;
112 list_t nfssrv_globals_list;
113 krwlock_t nfssrv_globals_rwl;
114
115 kmem_cache_t *nfs_xuio_cache;
116 int nfs_loaned_buffers = 0;
117
118 int
119 _init(void)
120 {
121 int status;
122
123 nfs_srvinit();
124
125 status = mod_install((struct modlinkage *)&modlinkage);
126 if (status != 0) {
127 /*
128 * Could not load module, cleanup previous
129 * initialization work.
130 */
131 nfs_srvfini();
132
133 return (status);
134 }
135
136 /*
137 * Initialise some placeholders for nfssys() calls. These have
138 * to be declared by the nfs module, since that handles nfssys()
139 * calls - also used by NFS clients - but are provided by this
140 * nfssrv module. These also then serve as confirmation to the
141 * relevant code in nfs that nfssrv has been loaded, as they're
142 * initially NULL.
143 */
144 nfs_srv_quiesce_func = nfs_srv_quiesce_all;
145 nfs_srv_dss_func = rfs4_dss_setpaths;
146
147 /* setup DSS paths here; must be done before initial server startup */
148 rfs4_dss_paths = rfs4_dss_oldpaths = NULL;
149
150 /* initialize the copy reduction caches */
151
152 nfs_xuio_cache = kmem_cache_create("nfs_xuio_cache",
153 sizeof (nfs_xuio_t), 0, NULL, NULL, NULL, NULL, NULL, 0);
154
155 return (status);
156 }
157
158 int
159 _fini()
160 {
161 return (EBUSY);
162 }
163
164 int
165 _info(struct modinfo *modinfop)
166 {
167 return (mod_info(&modlinkage, modinfop));
168 }
169
170 /*
171 * PUBLICFH_CHECK() checks if the dispatch routine supports
172 * RPC_PUBLICFH_OK, if the filesystem is exported public, and if the
173 * incoming request is using the public filehandle. The check duplicates
174 * the exportmatch() call done in checkexport(), and we should consider
175 * modifying those routines to avoid the duplication. For now, we optimize
176 * by calling exportmatch() only after checking that the dispatch routine
177 * supports RPC_PUBLICFH_OK, and if the filesystem is explicitly exported
178 * public (i.e., not the placeholder).
179 */
180 #define PUBLICFH_CHECK(ne, disp, exi, fsid, xfid) \
181 ((disp->dis_flags & RPC_PUBLICFH_OK) && \
182 ((exi->exi_export.ex_flags & EX_PUBLIC) || \
183 (exi == ne->exi_public && exportmatch(ne->exi_root, \
184 fsid, xfid))))
185
186 static void nfs_srv_shutdown_all(int);
187 static void rfs4_server_start(nfs_globals_t *, int);
188 static void nullfree(void);
189 static void rfs_dispatch(struct svc_req *, SVCXPRT *);
190 static void acl_dispatch(struct svc_req *, SVCXPRT *);
191 static int checkauth(struct exportinfo *, struct svc_req *, cred_t *, int,
192 bool_t, bool_t *);
193 static char *client_name(struct svc_req *req);
194 static char *client_addr(struct svc_req *req, char *buf);
195 extern int sec_svc_getcred(struct svc_req *, cred_t *cr, char **, int *);
196 extern bool_t sec_svc_inrootlist(int, caddr_t, int, caddr_t *);
197 static void *nfs_server_zone_init(zoneid_t);
198 static void nfs_server_zone_fini(zoneid_t, void *);
199 static void nfs_server_zone_shutdown(zoneid_t, void *);
200
201 #define NFSLOG_COPY_NETBUF(exi, xprt, nb) { \
202 (nb)->maxlen = (xprt)->xp_rtaddr.maxlen; \
203 (nb)->len = (xprt)->xp_rtaddr.len; \
204 (nb)->buf = kmem_alloc((nb)->len, KM_SLEEP); \
205 bcopy((xprt)->xp_rtaddr.buf, (nb)->buf, (nb)->len); \
206 }
207
208 /*
209 * Public Filehandle common nfs routines
210 */
211 static int MCLpath(char **);
212 static void URLparse(char *);
213
214 /*
215 * NFS callout table.
216 * This table is used by svc_getreq() to dispatch a request with
217 * a given prog/vers pair to an appropriate service provider
218 * dispatch routine.
219 *
220 * NOTE: ordering is relied upon below when resetting the version min/max
221 * for NFS_PROGRAM. Careful, if this is ever changed.
222 */
223 static SVC_CALLOUT __nfs_sc_clts[] = {
224 { NFS_PROGRAM, NFS_VERSMIN, NFS_VERSMAX, rfs_dispatch },
225 { NFS_ACL_PROGRAM, NFS_ACL_VERSMIN, NFS_ACL_VERSMAX, acl_dispatch }
226 };
227
228 static SVC_CALLOUT_TABLE nfs_sct_clts = {
229 sizeof (__nfs_sc_clts) / sizeof (__nfs_sc_clts[0]), FALSE,
230 __nfs_sc_clts
231 };
232
233 static SVC_CALLOUT __nfs_sc_cots[] = {
234 { NFS_PROGRAM, NFS_VERSMIN, NFS_VERSMAX, rfs_dispatch },
235 { NFS_ACL_PROGRAM, NFS_ACL_VERSMIN, NFS_ACL_VERSMAX, acl_dispatch }
236 };
237
238 static SVC_CALLOUT_TABLE nfs_sct_cots = {
239 sizeof (__nfs_sc_cots) / sizeof (__nfs_sc_cots[0]), FALSE, __nfs_sc_cots
240 };
241
242 static SVC_CALLOUT __nfs_sc_rdma[] = {
243 { NFS_PROGRAM, NFS_VERSMIN, NFS_VERSMAX, rfs_dispatch },
244 { NFS_ACL_PROGRAM, NFS_ACL_VERSMIN, NFS_ACL_VERSMAX, acl_dispatch }
245 };
246
247 static SVC_CALLOUT_TABLE nfs_sct_rdma = {
248 sizeof (__nfs_sc_rdma) / sizeof (__nfs_sc_rdma[0]), FALSE, __nfs_sc_rdma
249 };
250
251 /*
252 * DSS: distributed stable storage
253 * lists of all DSS paths: current, and before last warmstart
254 */
255 nvlist_t *rfs4_dss_paths, *rfs4_dss_oldpaths;
256
257 int rfs4_dispatch(struct rpcdisp *, struct svc_req *, SVCXPRT *, char *);
258 bool_t rfs4_minorvers_mismatch(struct svc_req *, SVCXPRT *, void *);
259
260 /*
261 * Stash NFS zone globals in TSD to avoid some lock contention
262 * from frequent zone_getspecific calls.
263 */
264 static uint_t nfs_server_tsd_key;
265
266 nfs_globals_t *
267 nfs_srv_getzg(void)
268 {
269 nfs_globals_t *ng;
270
271 ng = tsd_get(nfs_server_tsd_key);
272 if (ng == NULL) {
273 ng = zone_getspecific(nfssrv_zone_key, curzone);
274 (void) tsd_set(nfs_server_tsd_key, ng);
275 }
276
277 return (ng);
278 }
279
280 /*
281 * Will be called at the point the server pool is being unregistered
282 * from the pool list. From that point onwards, the pool is waiting
283 * to be drained and as such the server state is stale and pertains
284 * to the old instantiation of the NFS server pool.
285 */
286 void
287 nfs_srv_offline(void)
288 {
289 nfs_globals_t *ng;
290
291 ng = nfs_srv_getzg();
292
293 mutex_enter(&ng->nfs_server_upordown_lock);
294 if (ng->nfs_server_upordown == NFS_SERVER_RUNNING) {
295 ng->nfs_server_upordown = NFS_SERVER_OFFLINE;
296 }
297 mutex_exit(&ng->nfs_server_upordown_lock);
298 }
299
300 /*
301 * Will be called at the point the server pool is being destroyed so
302 * all transports have been closed and no service threads are in
303 * existence.
304 *
305 * If we quiesce the server, we're shutting it down without destroying the
306 * server state. This allows it to warm start subsequently.
307 */
308 void
309 nfs_srv_stop_all(void)
310 {
311 int quiesce = 0;
312 nfs_srv_shutdown_all(quiesce);
313 }
314
315 /*
316 * This alternative shutdown routine can be requested via nfssys()
317 */
318 void
319 nfs_srv_quiesce_all(void)
320 {
321 int quiesce = 1;
322 nfs_srv_shutdown_all(quiesce);
323 }
324
325 static void
326 nfs_srv_shutdown_all(int quiesce)
327 {
328 nfs_globals_t *ng = nfs_srv_getzg();
329
330 mutex_enter(&ng->nfs_server_upordown_lock);
331 if (quiesce) {
332 if (ng->nfs_server_upordown == NFS_SERVER_RUNNING ||
333 ng->nfs_server_upordown == NFS_SERVER_OFFLINE) {
334 ng->nfs_server_upordown = NFS_SERVER_QUIESCED;
335 cv_signal(&ng->nfs_server_upordown_cv);
336
337 /* reset DSS state */
338 rfs4_dss_numnewpaths = 0;
339 rfs4_dss_newpaths = NULL;
340
341 cmn_err(CE_NOTE, "nfs_server: server is now quiesced; "
342 "NFSv4 state has been preserved");
343 }
344 } else {
345 if (ng->nfs_server_upordown == NFS_SERVER_OFFLINE) {
346 ng->nfs_server_upordown = NFS_SERVER_STOPPING;
347 mutex_exit(&ng->nfs_server_upordown_lock);
348 rfs4_state_zone_fini();
349 rfs4_fini_drc();
350 mutex_enter(&ng->nfs_server_upordown_lock);
351 ng->nfs_server_upordown = NFS_SERVER_STOPPED;
352
353 /* reset DSS state */
354 rfs4_dss_numnewpaths = 0;
355 rfs4_dss_newpaths = NULL;
356
357 cv_signal(&ng->nfs_server_upordown_cv);
358 }
359 }
360 mutex_exit(&ng->nfs_server_upordown_lock);
361 }
362
363 static int
364 nfs_srv_set_sc_versions(struct file *fp, SVC_CALLOUT_TABLE **sctpp,
365 rpcvers_t versmin, rpcvers_t versmax)
366 {
367 struct strioctl strioc;
368 struct T_info_ack tinfo;
369 int error, retval;
370
371 /*
372 * Find out what type of transport this is.
373 */
374 strioc.ic_cmd = TI_GETINFO;
375 strioc.ic_timout = -1;
376 strioc.ic_len = sizeof (tinfo);
377 strioc.ic_dp = (char *)&tinfo;
378 tinfo.PRIM_type = T_INFO_REQ;
379
380 error = strioctl(fp->f_vnode, I_STR, (intptr_t)&strioc, 0, K_TO_K,
381 CRED(), &retval);
382 if (error || retval)
383 return (error);
384
385 /*
386 * Based on our query of the transport type...
387 *
388 * Reset the min/max versions based on the caller's request
389 * NOTE: This assumes that NFS_PROGRAM is first in the array!!
390 * And the second entry is the NFS_ACL_PROGRAM.
391 */
392 switch (tinfo.SERV_type) {
393 case T_CLTS:
394 if (versmax == NFS_V4)
395 return (EINVAL);
396 __nfs_sc_clts[0].sc_versmin = versmin;
397 __nfs_sc_clts[0].sc_versmax = versmax;
398 __nfs_sc_clts[1].sc_versmin = versmin;
399 __nfs_sc_clts[1].sc_versmax = versmax;
400 *sctpp = &nfs_sct_clts;
401 break;
402 case T_COTS:
403 case T_COTS_ORD:
404 __nfs_sc_cots[0].sc_versmin = versmin;
405 __nfs_sc_cots[0].sc_versmax = versmax;
406 /* For the NFS_ACL program, check the max version */
407 if (versmax > NFS_ACL_VERSMAX)
408 versmax = NFS_ACL_VERSMAX;
409 __nfs_sc_cots[1].sc_versmin = versmin;
410 __nfs_sc_cots[1].sc_versmax = versmax;
411 *sctpp = &nfs_sct_cots;
412 break;
413 default:
414 error = EINVAL;
415 }
416
417 return (error);
418 }
419
420 /*
421 * NFS Server system call.
422 * Does all of the work of running a NFS server.
423 * uap->fd is the fd of an open transport provider
424 */
425 int
426 nfs_svc(struct nfs_svc_args *arg, model_t model)
427 {
428 nfs_globals_t *ng;
429 file_t *fp;
430 SVCMASTERXPRT *xprt;
431 int error;
432 int readsize;
433 char buf[KNC_STRSIZE];
434 size_t len;
435 STRUCT_HANDLE(nfs_svc_args, uap);
436 struct netbuf addrmask;
437 SVC_CALLOUT_TABLE *sctp = NULL;
438
439 #ifdef lint
440 model = model; /* STRUCT macros don't always refer to it */
441 #endif
442
443 ng = nfs_srv_getzg();
444 STRUCT_SET_HANDLE(uap, model, arg);
445
446 /* Check privileges in nfssys() */
447
448 if ((fp = getf(STRUCT_FGET(uap, fd))) == NULL)
449 return (EBADF);
450
451 /* Setup global file handle in nfs_export */
452 if ((error = nfs_export_get_rootfh(ng)) != 0)
453 return (error);
454
455 /*
456 * Set read buffer size to rsize
457 * and add room for RPC headers.
458 */
459 readsize = nfs3tsize() + (RPC_MAXDATASIZE - NFS_MAXDATA);
460 if (readsize < RPC_MAXDATASIZE)
461 readsize = RPC_MAXDATASIZE;
462
463 error = copyinstr((const char *)STRUCT_FGETP(uap, netid), buf,
464 KNC_STRSIZE, &len);
465 if (error) {
466 releasef(STRUCT_FGET(uap, fd));
467 return (error);
468 }
469
470 addrmask.len = STRUCT_FGET(uap, addrmask.len);
471 addrmask.maxlen = STRUCT_FGET(uap, addrmask.maxlen);
472 addrmask.buf = kmem_alloc(addrmask.maxlen, KM_SLEEP);
473 error = copyin(STRUCT_FGETP(uap, addrmask.buf), addrmask.buf,
474 addrmask.len);
475 if (error) {
476 releasef(STRUCT_FGET(uap, fd));
477 kmem_free(addrmask.buf, addrmask.maxlen);
478 return (error);
479 }
480
481 ng->nfs_versmin = STRUCT_FGET(uap, versmin);
482 ng->nfs_versmax = STRUCT_FGET(uap, versmax);
483
484 /* Double check the vers min/max ranges */
485 if ((ng->nfs_versmin > ng->nfs_versmax) ||
486 (ng->nfs_versmin < NFS_VERSMIN) ||
487 (ng->nfs_versmax > NFS_VERSMAX)) {
488 ng->nfs_versmin = NFS_VERSMIN_DEFAULT;
489 ng->nfs_versmax = NFS_VERSMAX_DEFAULT;
490 }
491
492 if (error = nfs_srv_set_sc_versions(fp, &sctp, ng->nfs_versmin,
493 ng->nfs_versmax)) {
494 releasef(STRUCT_FGET(uap, fd));
495 kmem_free(addrmask.buf, addrmask.maxlen);
496 return (error);
497 }
498
499 /* Initialize nfsv4 server */
500 if (ng->nfs_versmax == (rpcvers_t)NFS_V4)
501 rfs4_server_start(ng, STRUCT_FGET(uap, delegation));
502
503 /* Create a transport handle. */
504 error = svc_tli_kcreate(fp, readsize, buf, &addrmask, &xprt,
505 sctp, NULL, NFS_SVCPOOL_ID, TRUE);
506
507 if (error)
508 kmem_free(addrmask.buf, addrmask.maxlen);
509
510 releasef(STRUCT_FGET(uap, fd));
511
512 /* HA-NFSv4: save the cluster nodeid */
513 if (cluster_bootflags & CLUSTER_BOOTED)
514 lm_global_nlmid = clconf_get_nodeid();
515
516 return (error);
517 }
518
519 static void
520 rfs4_server_start(nfs_globals_t *ng, int nfs4_srv_delegation)
521 {
522 /*
523 * Determine if the server has previously been "started" and
524 * if not, do the per instance initialization
525 */
526 mutex_enter(&ng->nfs_server_upordown_lock);
527
528 if (ng->nfs_server_upordown != NFS_SERVER_RUNNING) {
529 /* Do we need to stop and wait on the previous server? */
530 while (ng->nfs_server_upordown == NFS_SERVER_STOPPING ||
531 ng->nfs_server_upordown == NFS_SERVER_OFFLINE)
532 cv_wait(&ng->nfs_server_upordown_cv,
533 &ng->nfs_server_upordown_lock);
534
535 if (ng->nfs_server_upordown != NFS_SERVER_RUNNING) {
536 (void) svc_pool_control(NFS_SVCPOOL_ID,
537 SVCPSET_UNREGISTER_PROC, (void *)&nfs_srv_offline);
538 (void) svc_pool_control(NFS_SVCPOOL_ID,
539 SVCPSET_SHUTDOWN_PROC, (void *)&nfs_srv_stop_all);
540
541 rfs4_do_server_start(ng->nfs_server_upordown,
542 nfs4_srv_delegation,
543 cluster_bootflags & CLUSTER_BOOTED);
544
545 ng->nfs_server_upordown = NFS_SERVER_RUNNING;
546 }
547 cv_signal(&ng->nfs_server_upordown_cv);
548 }
549 mutex_exit(&ng->nfs_server_upordown_lock);
550 }
551
552 /*
553 * If RDMA device available,
554 * start RDMA listener.
555 */
556 int
557 rdma_start(struct rdma_svc_args *rsa)
558 {
559 nfs_globals_t *ng;
560 int error;
561 rdma_xprt_group_t started_rdma_xprts;
562 rdma_stat stat;
563 int svc_state = 0;
564
565 /* Double check the vers min/max ranges */
566 if ((rsa->nfs_versmin > rsa->nfs_versmax) ||
567 (rsa->nfs_versmin < NFS_VERSMIN) ||
568 (rsa->nfs_versmax > NFS_VERSMAX)) {
569 rsa->nfs_versmin = NFS_VERSMIN_DEFAULT;
570 rsa->nfs_versmax = NFS_VERSMAX_DEFAULT;
571 }
572
573 ng = nfs_srv_getzg();
574 ng->nfs_versmin = rsa->nfs_versmin;
575 ng->nfs_versmax = rsa->nfs_versmax;
576
577 /* Set the versions in the callout table */
578 __nfs_sc_rdma[0].sc_versmin = rsa->nfs_versmin;
579 __nfs_sc_rdma[0].sc_versmax = rsa->nfs_versmax;
580 /* For the NFS_ACL program, check the max version */
581 __nfs_sc_rdma[1].sc_versmin = rsa->nfs_versmin;
582 if (rsa->nfs_versmax > NFS_ACL_VERSMAX)
583 __nfs_sc_rdma[1].sc_versmax = NFS_ACL_VERSMAX;
584 else
585 __nfs_sc_rdma[1].sc_versmax = rsa->nfs_versmax;
586
587 /* Initialize nfsv4 server */
588 if (rsa->nfs_versmax == (rpcvers_t)NFS_V4)
589 rfs4_server_start(ng, rsa->delegation);
590
591 started_rdma_xprts.rtg_count = 0;
592 started_rdma_xprts.rtg_listhead = NULL;
593 started_rdma_xprts.rtg_poolid = rsa->poolid;
594
595 restart:
596 error = svc_rdma_kcreate(rsa->netid, &nfs_sct_rdma, rsa->poolid,
597 &started_rdma_xprts);
598
599 svc_state = !error;
600
601 while (!error) {
602
603 /*
604 * wait till either interrupted by a signal on
605 * nfs service stop/restart or signalled by a
606 * rdma attach/detatch.
607 */
608
609 stat = rdma_kwait();
610
611 /*
612 * stop services if running -- either on a HCA detach event
613 * or if the nfs service is stopped/restarted.
614 */
615
616 if ((stat == RDMA_HCA_DETACH || stat == RDMA_INTR) &&
617 svc_state) {
618 rdma_stop(&started_rdma_xprts);
619 svc_state = 0;
620 }
621
622 /*
623 * nfs service stop/restart, break out of the
624 * wait loop and return;
625 */
626 if (stat == RDMA_INTR)
627 return (0);
628
629 /*
630 * restart stopped services on a HCA attach event
631 * (if not already running)
632 */
633
634 if ((stat == RDMA_HCA_ATTACH) && (svc_state == 0))
635 goto restart;
636
637 /*
638 * loop until a nfs service stop/restart
639 */
640 }
641
642 return (error);
643 }
644
645 /* ARGSUSED */
646 void
647 rpc_null(caddr_t *argp, caddr_t *resp, struct exportinfo *exi,
648 struct svc_req *req, cred_t *cr, bool_t ro)
649 {
650 }
651
652 /* ARGSUSED */
653 void
654 rpc_null_v3(caddr_t *argp, caddr_t *resp, struct exportinfo *exi,
655 struct svc_req *req, cred_t *cr, bool_t ro)
656 {
657 DTRACE_NFSV3_4(op__null__start, struct svc_req *, req,
658 cred_t *, cr, vnode_t *, NULL, struct exportinfo *, exi);
659 DTRACE_NFSV3_4(op__null__done, struct svc_req *, req,
660 cred_t *, cr, vnode_t *, NULL, struct exportinfo *, exi);
661 }
662
663 /* ARGSUSED */
664 static void
665 rfs_error(caddr_t *argp, caddr_t *resp, struct exportinfo *exi,
666 struct svc_req *req, cred_t *cr, bool_t ro)
667 {
668 /* return (EOPNOTSUPP); */
669 }
670
671 static void
672 nullfree(void)
673 {
674 }
675
676 static char *rfscallnames_v2[] = {
677 "RFS2_NULL",
678 "RFS2_GETATTR",
679 "RFS2_SETATTR",
680 "RFS2_ROOT",
681 "RFS2_LOOKUP",
682 "RFS2_READLINK",
683 "RFS2_READ",
684 "RFS2_WRITECACHE",
685 "RFS2_WRITE",
686 "RFS2_CREATE",
687 "RFS2_REMOVE",
688 "RFS2_RENAME",
689 "RFS2_LINK",
690 "RFS2_SYMLINK",
691 "RFS2_MKDIR",
692 "RFS2_RMDIR",
693 "RFS2_READDIR",
694 "RFS2_STATFS"
695 };
696
697 static struct rpcdisp rfsdisptab_v2[] = {
698 /*
699 * NFS VERSION 2
700 */
701
702 /* RFS_NULL = 0 */
703 {rpc_null,
704 xdr_void, NULL_xdrproc_t, 0,
705 xdr_void, NULL_xdrproc_t, 0,
706 nullfree, RPC_IDEMPOTENT,
707 0},
708
709 /* RFS_GETATTR = 1 */
710 {rfs_getattr,
711 xdr_fhandle, xdr_fastfhandle, sizeof (fhandle_t),
712 xdr_attrstat, xdr_fastattrstat, sizeof (struct nfsattrstat),
713 nullfree, RPC_IDEMPOTENT|RPC_ALLOWANON|RPC_MAPRESP,
714 rfs_getattr_getfh},
715
716 /* RFS_SETATTR = 2 */
717 {rfs_setattr,
718 xdr_saargs, NULL_xdrproc_t, sizeof (struct nfssaargs),
719 xdr_attrstat, xdr_fastattrstat, sizeof (struct nfsattrstat),
720 nullfree, RPC_MAPRESP,
721 rfs_setattr_getfh},
722
723 /* RFS_ROOT = 3 *** NO LONGER SUPPORTED *** */
724 {rfs_error,
725 xdr_void, NULL_xdrproc_t, 0,
726 xdr_void, NULL_xdrproc_t, 0,
727 nullfree, RPC_IDEMPOTENT,
728 0},
729
730 /* RFS_LOOKUP = 4 */
731 {rfs_lookup,
732 xdr_diropargs, NULL_xdrproc_t, sizeof (struct nfsdiropargs),
733 xdr_diropres, xdr_fastdiropres, sizeof (struct nfsdiropres),
734 nullfree, RPC_IDEMPOTENT|RPC_MAPRESP|RPC_PUBLICFH_OK,
735 rfs_lookup_getfh},
736
737 /* RFS_READLINK = 5 */
738 {rfs_readlink,
739 xdr_fhandle, xdr_fastfhandle, sizeof (fhandle_t),
740 xdr_rdlnres, NULL_xdrproc_t, sizeof (struct nfsrdlnres),
741 rfs_rlfree, RPC_IDEMPOTENT,
742 rfs_readlink_getfh},
743
744 /* RFS_READ = 6 */
745 {rfs_read,
746 xdr_readargs, NULL_xdrproc_t, sizeof (struct nfsreadargs),
747 xdr_rdresult, NULL_xdrproc_t, sizeof (struct nfsrdresult),
748 rfs_rdfree, RPC_IDEMPOTENT,
749 rfs_read_getfh},
750
751 /* RFS_WRITECACHE = 7 *** NO LONGER SUPPORTED *** */
752 {rfs_error,
753 xdr_void, NULL_xdrproc_t, 0,
754 xdr_void, NULL_xdrproc_t, 0,
755 nullfree, RPC_IDEMPOTENT,
756 0},
757
758 /* RFS_WRITE = 8 */
759 {rfs_write,
760 xdr_writeargs, NULL_xdrproc_t, sizeof (struct nfswriteargs),
761 xdr_attrstat, xdr_fastattrstat, sizeof (struct nfsattrstat),
762 nullfree, RPC_MAPRESP,
763 rfs_write_getfh},
764
765 /* RFS_CREATE = 9 */
766 {rfs_create,
767 xdr_creatargs, NULL_xdrproc_t, sizeof (struct nfscreatargs),
768 xdr_diropres, xdr_fastdiropres, sizeof (struct nfsdiropres),
769 nullfree, RPC_MAPRESP,
770 rfs_create_getfh},
771
772 /* RFS_REMOVE = 10 */
773 {rfs_remove,
774 xdr_diropargs, NULL_xdrproc_t, sizeof (struct nfsdiropargs),
775 #ifdef _LITTLE_ENDIAN
776 xdr_enum, xdr_fastenum, sizeof (enum nfsstat),
777 #else
778 xdr_enum, NULL_xdrproc_t, sizeof (enum nfsstat),
779 #endif
780 nullfree, RPC_MAPRESP,
781 rfs_remove_getfh},
782
783 /* RFS_RENAME = 11 */
784 {rfs_rename,
785 xdr_rnmargs, NULL_xdrproc_t, sizeof (struct nfsrnmargs),
786 #ifdef _LITTLE_ENDIAN
787 xdr_enum, xdr_fastenum, sizeof (enum nfsstat),
788 #else
789 xdr_enum, NULL_xdrproc_t, sizeof (enum nfsstat),
790 #endif
791 nullfree, RPC_MAPRESP,
792 rfs_rename_getfh},
793
794 /* RFS_LINK = 12 */
795 {rfs_link,
796 xdr_linkargs, NULL_xdrproc_t, sizeof (struct nfslinkargs),
797 #ifdef _LITTLE_ENDIAN
798 xdr_enum, xdr_fastenum, sizeof (enum nfsstat),
799 #else
800 xdr_enum, NULL_xdrproc_t, sizeof (enum nfsstat),
801 #endif
802 nullfree, RPC_MAPRESP,
803 rfs_link_getfh},
804
805 /* RFS_SYMLINK = 13 */
806 {rfs_symlink,
807 xdr_slargs, NULL_xdrproc_t, sizeof (struct nfsslargs),
808 #ifdef _LITTLE_ENDIAN
809 xdr_enum, xdr_fastenum, sizeof (enum nfsstat),
810 #else
811 xdr_enum, NULL_xdrproc_t, sizeof (enum nfsstat),
812 #endif
813 nullfree, RPC_MAPRESP,
814 rfs_symlink_getfh},
815
816 /* RFS_MKDIR = 14 */
817 {rfs_mkdir,
818 xdr_creatargs, NULL_xdrproc_t, sizeof (struct nfscreatargs),
819 xdr_diropres, xdr_fastdiropres, sizeof (struct nfsdiropres),
820 nullfree, RPC_MAPRESP,
821 rfs_mkdir_getfh},
822
823 /* RFS_RMDIR = 15 */
824 {rfs_rmdir,
825 xdr_diropargs, NULL_xdrproc_t, sizeof (struct nfsdiropargs),
826 #ifdef _LITTLE_ENDIAN
827 xdr_enum, xdr_fastenum, sizeof (enum nfsstat),
828 #else
829 xdr_enum, NULL_xdrproc_t, sizeof (enum nfsstat),
830 #endif
831 nullfree, RPC_MAPRESP,
832 rfs_rmdir_getfh},
833
834 /* RFS_READDIR = 16 */
835 {rfs_readdir,
836 xdr_rddirargs, NULL_xdrproc_t, sizeof (struct nfsrddirargs),
837 xdr_putrddirres, NULL_xdrproc_t, sizeof (struct nfsrddirres),
838 rfs_rddirfree, RPC_IDEMPOTENT,
839 rfs_readdir_getfh},
840
841 /* RFS_STATFS = 17 */
842 {rfs_statfs,
843 xdr_fhandle, xdr_fastfhandle, sizeof (fhandle_t),
844 xdr_statfs, xdr_faststatfs, sizeof (struct nfsstatfs),
845 nullfree, RPC_IDEMPOTENT|RPC_ALLOWANON|RPC_MAPRESP,
846 rfs_statfs_getfh},
847 };
848
849 static char *rfscallnames_v3[] = {
850 "RFS3_NULL",
851 "RFS3_GETATTR",
852 "RFS3_SETATTR",
853 "RFS3_LOOKUP",
854 "RFS3_ACCESS",
855 "RFS3_READLINK",
856 "RFS3_READ",
857 "RFS3_WRITE",
858 "RFS3_CREATE",
859 "RFS3_MKDIR",
860 "RFS3_SYMLINK",
861 "RFS3_MKNOD",
862 "RFS3_REMOVE",
863 "RFS3_RMDIR",
864 "RFS3_RENAME",
865 "RFS3_LINK",
866 "RFS3_READDIR",
867 "RFS3_READDIRPLUS",
868 "RFS3_FSSTAT",
869 "RFS3_FSINFO",
870 "RFS3_PATHCONF",
871 "RFS3_COMMIT"
872 };
873
874 static struct rpcdisp rfsdisptab_v3[] = {
875 /*
876 * NFS VERSION 3
877 */
878
879 /* RFS_NULL = 0 */
880 {rpc_null_v3,
881 xdr_void, NULL_xdrproc_t, 0,
882 xdr_void, NULL_xdrproc_t, 0,
883 nullfree, RPC_IDEMPOTENT,
884 0},
885
886 /* RFS3_GETATTR = 1 */
887 {rfs3_getattr,
888 xdr_nfs_fh3_server, NULL_xdrproc_t, sizeof (GETATTR3args),
889 xdr_GETATTR3res, NULL_xdrproc_t, sizeof (GETATTR3res),
890 nullfree, (RPC_IDEMPOTENT | RPC_ALLOWANON),
891 rfs3_getattr_getfh},
892
893 /* RFS3_SETATTR = 2 */
894 {rfs3_setattr,
895 xdr_SETATTR3args, NULL_xdrproc_t, sizeof (SETATTR3args),
896 xdr_SETATTR3res, NULL_xdrproc_t, sizeof (SETATTR3res),
897 nullfree, 0,
898 rfs3_setattr_getfh},
899
900 /* RFS3_LOOKUP = 3 */
901 {rfs3_lookup,
902 xdr_diropargs3, NULL_xdrproc_t, sizeof (LOOKUP3args),
903 xdr_LOOKUP3res, NULL_xdrproc_t, sizeof (LOOKUP3res),
904 nullfree, (RPC_IDEMPOTENT | RPC_PUBLICFH_OK),
905 rfs3_lookup_getfh},
906
907 /* RFS3_ACCESS = 4 */
908 {rfs3_access,
909 xdr_ACCESS3args, NULL_xdrproc_t, sizeof (ACCESS3args),
910 xdr_ACCESS3res, NULL_xdrproc_t, sizeof (ACCESS3res),
911 nullfree, RPC_IDEMPOTENT,
912 rfs3_access_getfh},
913
914 /* RFS3_READLINK = 5 */
915 {rfs3_readlink,
916 xdr_nfs_fh3_server, NULL_xdrproc_t, sizeof (READLINK3args),
917 xdr_READLINK3res, NULL_xdrproc_t, sizeof (READLINK3res),
918 rfs3_readlink_free, RPC_IDEMPOTENT,
919 rfs3_readlink_getfh},
920
921 /* RFS3_READ = 6 */
922 {rfs3_read,
923 xdr_READ3args, NULL_xdrproc_t, sizeof (READ3args),
924 xdr_READ3res, NULL_xdrproc_t, sizeof (READ3res),
925 rfs3_read_free, RPC_IDEMPOTENT,
926 rfs3_read_getfh},
927
928 /* RFS3_WRITE = 7 */
929 {rfs3_write,
930 xdr_WRITE3args, NULL_xdrproc_t, sizeof (WRITE3args),
931 xdr_WRITE3res, NULL_xdrproc_t, sizeof (WRITE3res),
932 nullfree, 0,
933 rfs3_write_getfh},
934
935 /* RFS3_CREATE = 8 */
936 {rfs3_create,
937 xdr_CREATE3args, NULL_xdrproc_t, sizeof (CREATE3args),
938 xdr_CREATE3res, NULL_xdrproc_t, sizeof (CREATE3res),
939 nullfree, 0,
940 rfs3_create_getfh},
941
942 /* RFS3_MKDIR = 9 */
943 {rfs3_mkdir,
944 xdr_MKDIR3args, NULL_xdrproc_t, sizeof (MKDIR3args),
945 xdr_MKDIR3res, NULL_xdrproc_t, sizeof (MKDIR3res),
946 nullfree, 0,
947 rfs3_mkdir_getfh},
948
949 /* RFS3_SYMLINK = 10 */
950 {rfs3_symlink,
951 xdr_SYMLINK3args, NULL_xdrproc_t, sizeof (SYMLINK3args),
952 xdr_SYMLINK3res, NULL_xdrproc_t, sizeof (SYMLINK3res),
953 nullfree, 0,
954 rfs3_symlink_getfh},
955
956 /* RFS3_MKNOD = 11 */
957 {rfs3_mknod,
958 xdr_MKNOD3args, NULL_xdrproc_t, sizeof (MKNOD3args),
959 xdr_MKNOD3res, NULL_xdrproc_t, sizeof (MKNOD3res),
960 nullfree, 0,
961 rfs3_mknod_getfh},
962
963 /* RFS3_REMOVE = 12 */
964 {rfs3_remove,
965 xdr_diropargs3, NULL_xdrproc_t, sizeof (REMOVE3args),
966 xdr_REMOVE3res, NULL_xdrproc_t, sizeof (REMOVE3res),
967 nullfree, 0,
968 rfs3_remove_getfh},
969
970 /* RFS3_RMDIR = 13 */
971 {rfs3_rmdir,
972 xdr_diropargs3, NULL_xdrproc_t, sizeof (RMDIR3args),
973 xdr_RMDIR3res, NULL_xdrproc_t, sizeof (RMDIR3res),
974 nullfree, 0,
975 rfs3_rmdir_getfh},
976
977 /* RFS3_RENAME = 14 */
978 {rfs3_rename,
979 xdr_RENAME3args, NULL_xdrproc_t, sizeof (RENAME3args),
980 xdr_RENAME3res, NULL_xdrproc_t, sizeof (RENAME3res),
981 nullfree, 0,
982 rfs3_rename_getfh},
983
984 /* RFS3_LINK = 15 */
985 {rfs3_link,
986 xdr_LINK3args, NULL_xdrproc_t, sizeof (LINK3args),
987 xdr_LINK3res, NULL_xdrproc_t, sizeof (LINK3res),
988 nullfree, 0,
989 rfs3_link_getfh},
990
991 /* RFS3_READDIR = 16 */
992 {rfs3_readdir,
993 xdr_READDIR3args, NULL_xdrproc_t, sizeof (READDIR3args),
994 xdr_READDIR3res, NULL_xdrproc_t, sizeof (READDIR3res),
995 rfs3_readdir_free, RPC_IDEMPOTENT,
996 rfs3_readdir_getfh},
997
998 /* RFS3_READDIRPLUS = 17 */
999 {rfs3_readdirplus,
1000 xdr_READDIRPLUS3args, NULL_xdrproc_t, sizeof (READDIRPLUS3args),
1001 xdr_READDIRPLUS3res, NULL_xdrproc_t, sizeof (READDIRPLUS3res),
1002 rfs3_readdirplus_free, RPC_AVOIDWORK,
1003 rfs3_readdirplus_getfh},
1004
1005 /* RFS3_FSSTAT = 18 */
1006 {rfs3_fsstat,
1007 xdr_nfs_fh3_server, NULL_xdrproc_t, sizeof (FSSTAT3args),
1008 xdr_FSSTAT3res, NULL_xdrproc_t, sizeof (FSSTAT3res),
1009 nullfree, RPC_IDEMPOTENT,
1010 rfs3_fsstat_getfh},
1011
1012 /* RFS3_FSINFO = 19 */
1013 {rfs3_fsinfo,
1014 xdr_nfs_fh3_server, NULL_xdrproc_t, sizeof (FSINFO3args),
1015 xdr_FSINFO3res, NULL_xdrproc_t, sizeof (FSINFO3res),
1016 nullfree, RPC_IDEMPOTENT|RPC_ALLOWANON,
1017 rfs3_fsinfo_getfh},
1018
1019 /* RFS3_PATHCONF = 20 */
1020 {rfs3_pathconf,
1021 xdr_nfs_fh3_server, NULL_xdrproc_t, sizeof (PATHCONF3args),
1022 xdr_PATHCONF3res, NULL_xdrproc_t, sizeof (PATHCONF3res),
1023 nullfree, RPC_IDEMPOTENT,
1024 rfs3_pathconf_getfh},
1025
1026 /* RFS3_COMMIT = 21 */
1027 {rfs3_commit,
1028 xdr_COMMIT3args, NULL_xdrproc_t, sizeof (COMMIT3args),
1029 xdr_COMMIT3res, NULL_xdrproc_t, sizeof (COMMIT3res),
1030 nullfree, RPC_IDEMPOTENT,
1031 rfs3_commit_getfh},
1032 };
1033
1034 static char *rfscallnames_v4[] = {
1035 "RFS4_NULL",
1036 "RFS4_COMPOUND",
1037 "RFS4_NULL",
1038 "RFS4_NULL",
1039 "RFS4_NULL",
1040 "RFS4_NULL",
1041 "RFS4_NULL",
1042 "RFS4_NULL",
1043 "RFS4_CREATE"
1044 };
1045
1046 static struct rpcdisp rfsdisptab_v4[] = {
1047 /*
1048 * NFS VERSION 4
1049 */
1050
1051 /* RFS_NULL = 0 */
1052 {rpc_null,
1053 xdr_void, NULL_xdrproc_t, 0,
1054 xdr_void, NULL_xdrproc_t, 0,
1055 nullfree, RPC_IDEMPOTENT, 0},
1056
1057 /* RFS4_compound = 1 */
1058 {rfs4_compound,
1059 xdr_COMPOUND4args_srv, NULL_xdrproc_t, sizeof (COMPOUND4args),
1060 xdr_COMPOUND4res_srv, NULL_xdrproc_t, sizeof (COMPOUND4res),
1061 rfs4_compound_free, 0, 0},
1062 };
1063
1064 union rfs_args {
1065 /*
1066 * NFS VERSION 2
1067 */
1068
1069 /* RFS_NULL = 0 */
1070
1071 /* RFS_GETATTR = 1 */
1072 fhandle_t nfs2_getattr_args;
1073
1074 /* RFS_SETATTR = 2 */
1075 struct nfssaargs nfs2_setattr_args;
1076
1077 /* RFS_ROOT = 3 *** NO LONGER SUPPORTED *** */
1078
1079 /* RFS_LOOKUP = 4 */
1080 struct nfsdiropargs nfs2_lookup_args;
1081
1082 /* RFS_READLINK = 5 */
1083 fhandle_t nfs2_readlink_args;
1084
1085 /* RFS_READ = 6 */
1086 struct nfsreadargs nfs2_read_args;
1087
1088 /* RFS_WRITECACHE = 7 *** NO LONGER SUPPORTED *** */
1089
1090 /* RFS_WRITE = 8 */
1091 struct nfswriteargs nfs2_write_args;
1092
1093 /* RFS_CREATE = 9 */
1094 struct nfscreatargs nfs2_create_args;
1095
1096 /* RFS_REMOVE = 10 */
1097 struct nfsdiropargs nfs2_remove_args;
1098
1099 /* RFS_RENAME = 11 */
1100 struct nfsrnmargs nfs2_rename_args;
1101
1102 /* RFS_LINK = 12 */
1103 struct nfslinkargs nfs2_link_args;
1104
1105 /* RFS_SYMLINK = 13 */
1106 struct nfsslargs nfs2_symlink_args;
1107
1108 /* RFS_MKDIR = 14 */
1109 struct nfscreatargs nfs2_mkdir_args;
1110
1111 /* RFS_RMDIR = 15 */
1112 struct nfsdiropargs nfs2_rmdir_args;
1113
1114 /* RFS_READDIR = 16 */
1115 struct nfsrddirargs nfs2_readdir_args;
1116
1117 /* RFS_STATFS = 17 */
1118 fhandle_t nfs2_statfs_args;
1119
1120 /*
1121 * NFS VERSION 3
1122 */
1123
1124 /* RFS_NULL = 0 */
1125
1126 /* RFS3_GETATTR = 1 */
1127 GETATTR3args nfs3_getattr_args;
1128
1129 /* RFS3_SETATTR = 2 */
1130 SETATTR3args nfs3_setattr_args;
1131
1132 /* RFS3_LOOKUP = 3 */
1133 LOOKUP3args nfs3_lookup_args;
1134
1135 /* RFS3_ACCESS = 4 */
1136 ACCESS3args nfs3_access_args;
1137
1138 /* RFS3_READLINK = 5 */
1139 READLINK3args nfs3_readlink_args;
1140
1141 /* RFS3_READ = 6 */
1142 READ3args nfs3_read_args;
1143
1144 /* RFS3_WRITE = 7 */
1145 WRITE3args nfs3_write_args;
1146
1147 /* RFS3_CREATE = 8 */
1148 CREATE3args nfs3_create_args;
1149
1150 /* RFS3_MKDIR = 9 */
1151 MKDIR3args nfs3_mkdir_args;
1152
1153 /* RFS3_SYMLINK = 10 */
1154 SYMLINK3args nfs3_symlink_args;
1155
1156 /* RFS3_MKNOD = 11 */
1157 MKNOD3args nfs3_mknod_args;
1158
1159 /* RFS3_REMOVE = 12 */
1160 REMOVE3args nfs3_remove_args;
1161
1162 /* RFS3_RMDIR = 13 */
1163 RMDIR3args nfs3_rmdir_args;
1164
1165 /* RFS3_RENAME = 14 */
1166 RENAME3args nfs3_rename_args;
1167
1168 /* RFS3_LINK = 15 */
1169 LINK3args nfs3_link_args;
1170
1171 /* RFS3_READDIR = 16 */
1172 READDIR3args nfs3_readdir_args;
1173
1174 /* RFS3_READDIRPLUS = 17 */
1175 READDIRPLUS3args nfs3_readdirplus_args;
1176
1177 /* RFS3_FSSTAT = 18 */
1178 FSSTAT3args nfs3_fsstat_args;
1179
1180 /* RFS3_FSINFO = 19 */
1181 FSINFO3args nfs3_fsinfo_args;
1182
1183 /* RFS3_PATHCONF = 20 */
1184 PATHCONF3args nfs3_pathconf_args;
1185
1186 /* RFS3_COMMIT = 21 */
1187 COMMIT3args nfs3_commit_args;
1188
1189 /*
1190 * NFS VERSION 4
1191 */
1192
1193 /* RFS_NULL = 0 */
1194
1195 /* COMPUND = 1 */
1196 COMPOUND4args nfs4_compound_args;
1197 };
1198
1199 union rfs_res {
1200 /*
1201 * NFS VERSION 2
1202 */
1203
1204 /* RFS_NULL = 0 */
1205
1206 /* RFS_GETATTR = 1 */
1207 struct nfsattrstat nfs2_getattr_res;
1208
1209 /* RFS_SETATTR = 2 */
1210 struct nfsattrstat nfs2_setattr_res;
1211
1212 /* RFS_ROOT = 3 *** NO LONGER SUPPORTED *** */
1213
1214 /* RFS_LOOKUP = 4 */
1215 struct nfsdiropres nfs2_lookup_res;
1216
1217 /* RFS_READLINK = 5 */
1218 struct nfsrdlnres nfs2_readlink_res;
1219
1220 /* RFS_READ = 6 */
1221 struct nfsrdresult nfs2_read_res;
1222
1223 /* RFS_WRITECACHE = 7 *** NO LONGER SUPPORTED *** */
1224
1225 /* RFS_WRITE = 8 */
1226 struct nfsattrstat nfs2_write_res;
1227
1228 /* RFS_CREATE = 9 */
1229 struct nfsdiropres nfs2_create_res;
1230
1231 /* RFS_REMOVE = 10 */
1232 enum nfsstat nfs2_remove_res;
1233
1234 /* RFS_RENAME = 11 */
1235 enum nfsstat nfs2_rename_res;
1236
1237 /* RFS_LINK = 12 */
1238 enum nfsstat nfs2_link_res;
1239
1240 /* RFS_SYMLINK = 13 */
1241 enum nfsstat nfs2_symlink_res;
1242
1243 /* RFS_MKDIR = 14 */
1244 struct nfsdiropres nfs2_mkdir_res;
1245
1246 /* RFS_RMDIR = 15 */
1247 enum nfsstat nfs2_rmdir_res;
1248
1249 /* RFS_READDIR = 16 */
1250 struct nfsrddirres nfs2_readdir_res;
1251
1252 /* RFS_STATFS = 17 */
1253 struct nfsstatfs nfs2_statfs_res;
1254
1255 /*
1256 * NFS VERSION 3
1257 */
1258
1259 /* RFS_NULL = 0 */
1260
1261 /* RFS3_GETATTR = 1 */
1262 GETATTR3res nfs3_getattr_res;
1263
1264 /* RFS3_SETATTR = 2 */
1265 SETATTR3res nfs3_setattr_res;
1266
1267 /* RFS3_LOOKUP = 3 */
1268 LOOKUP3res nfs3_lookup_res;
1269
1270 /* RFS3_ACCESS = 4 */
1271 ACCESS3res nfs3_access_res;
1272
1273 /* RFS3_READLINK = 5 */
1274 READLINK3res nfs3_readlink_res;
1275
1276 /* RFS3_READ = 6 */
1277 READ3res nfs3_read_res;
1278
1279 /* RFS3_WRITE = 7 */
1280 WRITE3res nfs3_write_res;
1281
1282 /* RFS3_CREATE = 8 */
1283 CREATE3res nfs3_create_res;
1284
1285 /* RFS3_MKDIR = 9 */
1286 MKDIR3res nfs3_mkdir_res;
1287
1288 /* RFS3_SYMLINK = 10 */
1289 SYMLINK3res nfs3_symlink_res;
1290
1291 /* RFS3_MKNOD = 11 */
1292 MKNOD3res nfs3_mknod_res;
1293
1294 /* RFS3_REMOVE = 12 */
1295 REMOVE3res nfs3_remove_res;
1296
1297 /* RFS3_RMDIR = 13 */
1298 RMDIR3res nfs3_rmdir_res;
1299
1300 /* RFS3_RENAME = 14 */
1301 RENAME3res nfs3_rename_res;
1302
1303 /* RFS3_LINK = 15 */
1304 LINK3res nfs3_link_res;
1305
1306 /* RFS3_READDIR = 16 */
1307 READDIR3res nfs3_readdir_res;
1308
1309 /* RFS3_READDIRPLUS = 17 */
1310 READDIRPLUS3res nfs3_readdirplus_res;
1311
1312 /* RFS3_FSSTAT = 18 */
1313 FSSTAT3res nfs3_fsstat_res;
1314
1315 /* RFS3_FSINFO = 19 */
1316 FSINFO3res nfs3_fsinfo_res;
1317
1318 /* RFS3_PATHCONF = 20 */
1319 PATHCONF3res nfs3_pathconf_res;
1320
1321 /* RFS3_COMMIT = 21 */
1322 COMMIT3res nfs3_commit_res;
1323
1324 /*
1325 * NFS VERSION 4
1326 */
1327
1328 /* RFS_NULL = 0 */
1329
1330 /* RFS4_COMPOUND = 1 */
1331 COMPOUND4res nfs4_compound_res;
1332
1333 };
1334
1335 static struct rpc_disptable rfs_disptable[] = {
1336 {sizeof (rfsdisptab_v2) / sizeof (rfsdisptab_v2[0]),
1337 rfscallnames_v2,
1338 rfsdisptab_v2},
1339 {sizeof (rfsdisptab_v3) / sizeof (rfsdisptab_v3[0]),
1340 rfscallnames_v3,
1341 rfsdisptab_v3},
1342 {sizeof (rfsdisptab_v4) / sizeof (rfsdisptab_v4[0]),
1343 rfscallnames_v4,
1344 rfsdisptab_v4},
1345 };
1346
1347 /*
1348 * If nfs_portmon is set, then clients are required to use privileged
1349 * ports (ports < IPPORT_RESERVED) in order to get NFS services.
1350 *
1351 * N.B.: this attempt to carry forward the already ill-conceived notion
1352 * of privileged ports for TCP/UDP is really quite ineffectual. Not only
1353 * is it transport-dependent, it's laughably easy to spoof. If you're
1354 * really interested in security, you must start with secure RPC instead.
1355 */
1356 static int nfs_portmon = 0;
1357
1358 #ifdef DEBUG
1359 static int cred_hits = 0;
1360 static int cred_misses = 0;
1361 #endif
1362
1363 #ifdef DEBUG
1364 /*
1365 * Debug code to allow disabling of rfs_dispatch() use of
1366 * fastxdrargs() and fastxdrres() calls for testing purposes.
1367 */
1368 static int rfs_no_fast_xdrargs = 0;
1369 static int rfs_no_fast_xdrres = 0;
1370 #endif
1371
1372 union acl_args {
1373 /*
1374 * ACL VERSION 2
1375 */
1376
1377 /* ACL2_NULL = 0 */
1378
1379 /* ACL2_GETACL = 1 */
1380 GETACL2args acl2_getacl_args;
1381
1382 /* ACL2_SETACL = 2 */
1383 SETACL2args acl2_setacl_args;
1384
1385 /* ACL2_GETATTR = 3 */
1386 GETATTR2args acl2_getattr_args;
1387
1388 /* ACL2_ACCESS = 4 */
1389 ACCESS2args acl2_access_args;
1390
1391 /* ACL2_GETXATTRDIR = 5 */
1392 GETXATTRDIR2args acl2_getxattrdir_args;
1393
1394 /*
1395 * ACL VERSION 3
1396 */
1397
1398 /* ACL3_NULL = 0 */
1399
1400 /* ACL3_GETACL = 1 */
1401 GETACL3args acl3_getacl_args;
1402
1403 /* ACL3_SETACL = 2 */
1404 SETACL3args acl3_setacl;
1405
1406 /* ACL3_GETXATTRDIR = 3 */
1407 GETXATTRDIR3args acl3_getxattrdir_args;
1408
1409 };
1410
1411 union acl_res {
1412 /*
1413 * ACL VERSION 2
1414 */
1415
1416 /* ACL2_NULL = 0 */
1417
1418 /* ACL2_GETACL = 1 */
1419 GETACL2res acl2_getacl_res;
1420
1421 /* ACL2_SETACL = 2 */
1422 SETACL2res acl2_setacl_res;
1423
1424 /* ACL2_GETATTR = 3 */
1425 GETATTR2res acl2_getattr_res;
1426
1427 /* ACL2_ACCESS = 4 */
1428 ACCESS2res acl2_access_res;
1429
1430 /* ACL2_GETXATTRDIR = 5 */
1431 GETXATTRDIR2args acl2_getxattrdir_res;
1432
1433 /*
1434 * ACL VERSION 3
1435 */
1436
1437 /* ACL3_NULL = 0 */
1438
1439 /* ACL3_GETACL = 1 */
1440 GETACL3res acl3_getacl_res;
1441
1442 /* ACL3_SETACL = 2 */
1443 SETACL3res acl3_setacl_res;
1444
1445 /* ACL3_GETXATTRDIR = 3 */
1446 GETXATTRDIR3res acl3_getxattrdir_res;
1447
1448 };
1449
1450 static bool_t
1451 auth_tooweak(struct svc_req *req, char *res)
1452 {
1453
1454 if (req->rq_vers == NFS_VERSION && req->rq_proc == RFS_LOOKUP) {
1455 struct nfsdiropres *dr = (struct nfsdiropres *)res;
1456 if ((enum wnfsstat)dr->dr_status == WNFSERR_CLNT_FLAVOR)
1457 return (TRUE);
1458 } else if (req->rq_vers == NFS_V3 && req->rq_proc == NFSPROC3_LOOKUP) {
1459 LOOKUP3res *resp = (LOOKUP3res *)res;
1460 if ((enum wnfsstat)resp->status == WNFSERR_CLNT_FLAVOR)
1461 return (TRUE);
1462 }
1463 return (FALSE);
1464 }
1465
1466 static void
1467 common_dispatch(struct svc_req *req, SVCXPRT *xprt, rpcvers_t min_vers,
1468 rpcvers_t max_vers, char *pgmname, struct rpc_disptable *disptable)
1469 {
1470 int which;
1471 rpcvers_t vers;
1472 char *args;
1473 union {
1474 union rfs_args ra;
1475 union acl_args aa;
1476 } args_buf;
1477 char *res;
1478 union {
1479 union rfs_res rr;
1480 union acl_res ar;
1481 } res_buf;
1482 struct rpcdisp *disp = NULL;
1483 int dis_flags = 0;
1484 cred_t *cr;
1485 int error = 0;
1486 int anon_ok;
1487 struct exportinfo *exi = NULL;
1488 unsigned int nfslog_rec_id;
1489 int dupstat;
1490 struct dupreq *dr;
1491 int authres;
1492 bool_t publicfh_ok = FALSE;
1493 enum_t auth_flavor;
1494 bool_t dupcached = FALSE;
1495 struct netbuf nb;
1496 bool_t logging_enabled = FALSE;
1497 struct exportinfo *nfslog_exi = NULL;
1498 char **procnames;
1499 char cbuf[INET6_ADDRSTRLEN]; /* to hold both IPv4 and IPv6 addr */
1500 bool_t ro = FALSE;
1501 nfs_globals_t *ng = nfs_srv_getzg();
1502 nfs_export_t *ne = ng->nfs_export;
1503 kstat_named_t *svstat, *procstat;
1504
1505 ASSERT(req->rq_prog == NFS_PROGRAM || req->rq_prog == NFS_ACL_PROGRAM);
1506
1507 vers = req->rq_vers;
1508
1509 svstat = ng->svstat[req->rq_vers];
1510 procstat = (req->rq_prog == NFS_PROGRAM) ?
1511 ng->rfsproccnt[vers] : ng->aclproccnt[vers];
1512
1513 if (vers < min_vers || vers > max_vers) {
1514 svcerr_progvers(req->rq_xprt, min_vers, max_vers);
1515 error++;
1516 cmn_err(CE_NOTE, "%s: bad version number %u", pgmname, vers);
1517 goto done;
1518 }
1519 vers -= min_vers;
1520
1521 which = req->rq_proc;
1522 if (which < 0 || which >= disptable[(int)vers].dis_nprocs) {
1523 svcerr_noproc(req->rq_xprt);
1524 error++;
1525 goto done;
1526 }
1527
1528 procstat[which].value.ui64++;
1529
1530 disp = &disptable[(int)vers].dis_table[which];
1531 procnames = disptable[(int)vers].dis_procnames;
1532
1533 auth_flavor = req->rq_cred.oa_flavor;
1534
1535 /*
1536 * Deserialize into the args struct.
1537 */
1538 args = (char *)&args_buf;
1539
1540 #ifdef DEBUG
1541 if (rfs_no_fast_xdrargs || (auth_flavor == RPCSEC_GSS) ||
1542 disp->dis_fastxdrargs == NULL_xdrproc_t ||
1543 !SVC_GETARGS(xprt, disp->dis_fastxdrargs, (char *)&args))
1544 #else
1545 if ((auth_flavor == RPCSEC_GSS) ||
1546 disp->dis_fastxdrargs == NULL_xdrproc_t ||
1547 !SVC_GETARGS(xprt, disp->dis_fastxdrargs, (char *)&args))
1548 #endif
1549 {
1550 bzero(args, disp->dis_argsz);
1551 if (!SVC_GETARGS(xprt, disp->dis_xdrargs, args)) {
1552 error++;
1553 /*
1554 * Check if we are outside our capabilities.
1555 */
1556 if (rfs4_minorvers_mismatch(req, xprt, (void *)args))
1557 goto done;
1558
1559 svcerr_decode(xprt);
1560 cmn_err(CE_NOTE,
1561 "Failed to decode arguments for %s version %u "
1562 "procedure %s client %s%s",
1563 pgmname, vers + min_vers, procnames[which],
1564 client_name(req), client_addr(req, cbuf));
1565 goto done;
1566 }
1567 }
1568
1569 /*
1570 * If Version 4 use that specific dispatch function.
1571 */
1572 if (req->rq_vers == 4) {
1573 error += rfs4_dispatch(disp, req, xprt, args);
1574 goto done;
1575 }
1576
1577 dis_flags = disp->dis_flags;
1578
1579 /*
1580 * Find export information and check authentication,
1581 * setting the credential if everything is ok.
1582 */
1583 if (disp->dis_getfh != NULL) {
1584 void *fh;
1585 fsid_t *fsid;
1586 fid_t *fid, *xfid;
1587 fhandle_t *fh2;
1588 nfs_fh3 *fh3;
1589
1590 fh = (*disp->dis_getfh)(args);
1591 switch (req->rq_vers) {
1592 case NFS_VERSION:
1593 fh2 = (fhandle_t *)fh;
1594 fsid = &fh2->fh_fsid;
1595 fid = (fid_t *)&fh2->fh_len;
1596 xfid = (fid_t *)&fh2->fh_xlen;
1597 break;
1598 case NFS_V3:
1599 fh3 = (nfs_fh3 *)fh;
1600 fsid = &fh3->fh3_fsid;
1601 fid = FH3TOFIDP(fh3);
1602 xfid = FH3TOXFIDP(fh3);
1603 break;
1604 }
1605
1606 /*
1607 * Fix for bug 1038302 - corbin
1608 * There is a problem here if anonymous access is
1609 * disallowed. If the current request is part of the
1610 * client's mount process for the requested filesystem,
1611 * then it will carry root (uid 0) credentials on it, and
1612 * will be denied by checkauth if that client does not
1613 * have explicit root=0 permission. This will cause the
1614 * client's mount operation to fail. As a work-around,
1615 * we check here to see if the request is a getattr or
1616 * statfs operation on the exported vnode itself, and
1617 * pass a flag to checkauth with the result of this test.
1618 *
1619 * The filehandle refers to the mountpoint itself if
1620 * the fh_data and fh_xdata portions of the filehandle
1621 * are equal.
1622 *
1623 * Added anon_ok argument to checkauth().
1624 */
1625
1626 if ((dis_flags & RPC_ALLOWANON) && EQFID(fid, xfid))
1627 anon_ok = 1;
1628 else
1629 anon_ok = 0;
1630
1631 cr = xprt->xp_cred;
1632 ASSERT(cr != NULL);
1633 #ifdef DEBUG
1634 {
1635 if (crgetref(cr) != 1) {
1636 crfree(cr);
1637 cr = crget();
1638 xprt->xp_cred = cr;
1639 cred_misses++;
1640 } else
1641 cred_hits++;
1642 }
1643 #else
1644 if (crgetref(cr) != 1) {
1645 crfree(cr);
1646 cr = crget();
1647 xprt->xp_cred = cr;
1648 }
1649 #endif
1650
1651 exi = checkexport(fsid, xfid);
1652
1653 if (exi != NULL) {
1654 publicfh_ok = PUBLICFH_CHECK(ne, disp, exi, fsid, xfid);
1655
1656 /*
1657 * Don't allow non-V4 clients access
1658 * to pseudo exports
1659 */
1660 if (PSEUDO(exi)) {
1661 svcerr_weakauth(xprt);
1662 error++;
1663 goto done;
1664 }
1665
1666 authres = checkauth(exi, req, cr, anon_ok, publicfh_ok,
1667 &ro);
1668 /*
1669 * authres > 0: authentication OK - proceed
1670 * authres == 0: authentication weak - return error
1671 * authres < 0: authentication timeout - drop
1672 */
1673 if (authres <= 0) {
1674 if (authres == 0) {
1675 svcerr_weakauth(xprt);
1676 error++;
1677 }
1678 goto done;
1679 }
1680 }
1681 } else
1682 cr = NULL;
1683
1684 if ((dis_flags & RPC_MAPRESP) && (auth_flavor != RPCSEC_GSS)) {
1685 res = (char *)SVC_GETRES(xprt, disp->dis_ressz);
1686 if (res == NULL)
1687 res = (char *)&res_buf;
1688 } else
1689 res = (char *)&res_buf;
1690
1691 if (!(dis_flags & RPC_IDEMPOTENT)) {
1692 dupstat = SVC_DUP_EXT(xprt, req, res, disp->dis_ressz, &dr,
1693 &dupcached);
1694
1695 switch (dupstat) {
1696 case DUP_ERROR:
1697 svcerr_systemerr(xprt);
1698 error++;
1699 goto done;
1700 /* NOTREACHED */
1701 case DUP_INPROGRESS:
1702 if (res != (char *)&res_buf)
1703 SVC_FREERES(xprt);
1704 error++;
1705 goto done;
1706 /* NOTREACHED */
1707 case DUP_NEW:
1708 case DUP_DROP:
1709 curthread->t_flag |= T_DONTPEND;
1710
1711 (*disp->dis_proc)(args, res, exi, req, cr, ro);
1712
1713 curthread->t_flag &= ~T_DONTPEND;
1714 if (curthread->t_flag & T_WOULDBLOCK) {
1715 curthread->t_flag &= ~T_WOULDBLOCK;
1716 SVC_DUPDONE_EXT(xprt, dr, res, NULL,
1717 disp->dis_ressz, DUP_DROP);
1718 if (res != (char *)&res_buf)
1719 SVC_FREERES(xprt);
1720 error++;
1721 goto done;
1722 }
1723 if (dis_flags & RPC_AVOIDWORK) {
1724 SVC_DUPDONE_EXT(xprt, dr, res, NULL,
1725 disp->dis_ressz, DUP_DROP);
1726 } else {
1727 SVC_DUPDONE_EXT(xprt, dr, res,
1728 disp->dis_resfree == nullfree ? NULL :
1729 disp->dis_resfree,
1730 disp->dis_ressz, DUP_DONE);
1731 dupcached = TRUE;
1732 }
1733 break;
1734 case DUP_DONE:
1735 break;
1736 }
1737
1738 } else {
1739 curthread->t_flag |= T_DONTPEND;
1740
1741 (*disp->dis_proc)(args, res, exi, req, cr, ro);
1742
1743 curthread->t_flag &= ~T_DONTPEND;
1744 if (curthread->t_flag & T_WOULDBLOCK) {
1745 curthread->t_flag &= ~T_WOULDBLOCK;
1746 if (res != (char *)&res_buf)
1747 SVC_FREERES(xprt);
1748 error++;
1749 goto done;
1750 }
1751 }
1752
1753 if (auth_tooweak(req, res)) {
1754 svcerr_weakauth(xprt);
1755 error++;
1756 goto done;
1757 }
1758
1759 /*
1760 * Check to see if logging has been enabled on the server.
1761 * If so, then obtain the export info struct to be used for
1762 * the later writing of the log record. This is done for
1763 * the case that a lookup is done across a non-logged public
1764 * file system.
1765 */
1766 if (nfslog_buffer_list != NULL) {
1767 nfslog_exi = nfslog_get_exi(ne, exi, req, res, &nfslog_rec_id);
1768 /*
1769 * Is logging enabled?
1770 */
1771 logging_enabled = (nfslog_exi != NULL);
1772
1773 /*
1774 * Copy the netbuf for logging purposes, before it is
1775 * freed by svc_sendreply().
1776 */
1777 if (logging_enabled) {
1778 NFSLOG_COPY_NETBUF(nfslog_exi, xprt, &nb);
1779 /*
1780 * If RPC_MAPRESP flag set (i.e. in V2 ops) the
1781 * res gets copied directly into the mbuf and
1782 * may be freed soon after the sendreply. So we
1783 * must copy it here to a safe place...
1784 */
1785 if (res != (char *)&res_buf) {
1786 bcopy(res, (char *)&res_buf, disp->dis_ressz);
1787 }
1788 }
1789 }
1790
1791 /*
1792 * Serialize and send results struct
1793 */
1794 #ifdef DEBUG
1795 if (rfs_no_fast_xdrres == 0 && res != (char *)&res_buf)
1796 #else
1797 if (res != (char *)&res_buf)
1798 #endif
1799 {
1800 if (!svc_sendreply(xprt, disp->dis_fastxdrres, res)) {
1801 cmn_err(CE_NOTE, "%s: bad sendreply", pgmname);
1802 svcerr_systemerr(xprt);
1803 error++;
1804 }
1805 } else {
1806 if (!svc_sendreply(xprt, disp->dis_xdrres, res)) {
1807 cmn_err(CE_NOTE, "%s: bad sendreply", pgmname);
1808 svcerr_systemerr(xprt);
1809 error++;
1810 }
1811 }
1812
1813 /*
1814 * Log if needed
1815 */
1816 if (logging_enabled) {
1817 nfslog_write_record(nfslog_exi, req, args, (char *)&res_buf,
1818 cr, &nb, nfslog_rec_id, NFSLOG_ONE_BUFFER);
1819 exi_rele(nfslog_exi);
1820 kmem_free((&nb)->buf, (&nb)->len);
1821 }
1822
1823 /*
1824 * Free results struct. With the addition of NFS V4 we can
1825 * have non-idempotent procedures with functions.
1826 */
1827 if (disp->dis_resfree != nullfree && dupcached == FALSE) {
1828 (*disp->dis_resfree)(res);
1829 }
1830
1831 done:
1832 /*
1833 * Free arguments struct
1834 */
1835 if (disp) {
1836 if (!SVC_FREEARGS(xprt, disp->dis_xdrargs, args)) {
1837 cmn_err(CE_NOTE, "%s: bad freeargs", pgmname);
1838 error++;
1839 }
1840 } else {
1841 if (!SVC_FREEARGS(xprt, (xdrproc_t)0, (caddr_t)0)) {
1842 cmn_err(CE_NOTE, "%s: bad freeargs", pgmname);
1843 error++;
1844 }
1845 }
1846
1847 if (exi != NULL)
1848 exi_rele(exi);
1849
1850 svstat[NFS_BADCALLS].value.ui64 += error;
1851 svstat[NFS_CALLS].value.ui64++;
1852 }
1853
1854 static void
1855 rfs_dispatch(struct svc_req *req, SVCXPRT *xprt)
1856 {
1857 common_dispatch(req, xprt, NFS_VERSMIN, NFS_VERSMAX,
1858 "NFS", rfs_disptable);
1859 }
1860
1861 static char *aclcallnames_v2[] = {
1862 "ACL2_NULL",
1863 "ACL2_GETACL",
1864 "ACL2_SETACL",
1865 "ACL2_GETATTR",
1866 "ACL2_ACCESS",
1867 "ACL2_GETXATTRDIR"
1868 };
1869
1870 static struct rpcdisp acldisptab_v2[] = {
1871 /*
1872 * ACL VERSION 2
1873 */
1874
1875 /* ACL2_NULL = 0 */
1876 {rpc_null,
1877 xdr_void, NULL_xdrproc_t, 0,
1878 xdr_void, NULL_xdrproc_t, 0,
1879 nullfree, RPC_IDEMPOTENT,
1880 0},
1881
1882 /* ACL2_GETACL = 1 */
1883 {acl2_getacl,
1884 xdr_GETACL2args, xdr_fastGETACL2args, sizeof (GETACL2args),
1885 xdr_GETACL2res, NULL_xdrproc_t, sizeof (GETACL2res),
1886 acl2_getacl_free, RPC_IDEMPOTENT,
1887 acl2_getacl_getfh},
1888
1889 /* ACL2_SETACL = 2 */
1890 {acl2_setacl,
1891 xdr_SETACL2args, NULL_xdrproc_t, sizeof (SETACL2args),
1892 #ifdef _LITTLE_ENDIAN
1893 xdr_SETACL2res, xdr_fastSETACL2res, sizeof (SETACL2res),
1894 #else
1895 xdr_SETACL2res, NULL_xdrproc_t, sizeof (SETACL2res),
1896 #endif
1897 nullfree, RPC_MAPRESP,
1898 acl2_setacl_getfh},
1899
1900 /* ACL2_GETATTR = 3 */
1901 {acl2_getattr,
1902 xdr_GETATTR2args, xdr_fastGETATTR2args, sizeof (GETATTR2args),
1903 #ifdef _LITTLE_ENDIAN
1904 xdr_GETATTR2res, xdr_fastGETATTR2res, sizeof (GETATTR2res),
1905 #else
1906 xdr_GETATTR2res, NULL_xdrproc_t, sizeof (GETATTR2res),
1907 #endif
1908 nullfree, RPC_IDEMPOTENT|RPC_ALLOWANON|RPC_MAPRESP,
1909 acl2_getattr_getfh},
1910
1911 /* ACL2_ACCESS = 4 */
1912 {acl2_access,
1913 xdr_ACCESS2args, xdr_fastACCESS2args, sizeof (ACCESS2args),
1914 #ifdef _LITTLE_ENDIAN
1915 xdr_ACCESS2res, xdr_fastACCESS2res, sizeof (ACCESS2res),
1916 #else
1917 xdr_ACCESS2res, NULL_xdrproc_t, sizeof (ACCESS2res),
1918 #endif
1919 nullfree, RPC_IDEMPOTENT|RPC_MAPRESP,
1920 acl2_access_getfh},
1921
1922 /* ACL2_GETXATTRDIR = 5 */
1923 {acl2_getxattrdir,
1924 xdr_GETXATTRDIR2args, NULL_xdrproc_t, sizeof (GETXATTRDIR2args),
1925 xdr_GETXATTRDIR2res, NULL_xdrproc_t, sizeof (GETXATTRDIR2res),
1926 nullfree, RPC_IDEMPOTENT,
1927 acl2_getxattrdir_getfh},
1928 };
1929
1930 static char *aclcallnames_v3[] = {
1931 "ACL3_NULL",
1932 "ACL3_GETACL",
1933 "ACL3_SETACL",
1934 "ACL3_GETXATTRDIR"
1935 };
1936
1937 static struct rpcdisp acldisptab_v3[] = {
1938 /*
1939 * ACL VERSION 3
1940 */
1941
1942 /* ACL3_NULL = 0 */
1943 {rpc_null,
1944 xdr_void, NULL_xdrproc_t, 0,
1945 xdr_void, NULL_xdrproc_t, 0,
1946 nullfree, RPC_IDEMPOTENT,
1947 0},
1948
1949 /* ACL3_GETACL = 1 */
1950 {acl3_getacl,
1951 xdr_GETACL3args, NULL_xdrproc_t, sizeof (GETACL3args),
1952 xdr_GETACL3res, NULL_xdrproc_t, sizeof (GETACL3res),
1953 acl3_getacl_free, RPC_IDEMPOTENT,
1954 acl3_getacl_getfh},
1955
1956 /* ACL3_SETACL = 2 */
1957 {acl3_setacl,
1958 xdr_SETACL3args, NULL_xdrproc_t, sizeof (SETACL3args),
1959 xdr_SETACL3res, NULL_xdrproc_t, sizeof (SETACL3res),
1960 nullfree, 0,
1961 acl3_setacl_getfh},
1962
1963 /* ACL3_GETXATTRDIR = 3 */
1964 {acl3_getxattrdir,
1965 xdr_GETXATTRDIR3args, NULL_xdrproc_t, sizeof (GETXATTRDIR3args),
1966 xdr_GETXATTRDIR3res, NULL_xdrproc_t, sizeof (GETXATTRDIR3res),
1967 nullfree, RPC_IDEMPOTENT,
1968 acl3_getxattrdir_getfh},
1969 };
1970
1971 static struct rpc_disptable acl_disptable[] = {
1972 {sizeof (acldisptab_v2) / sizeof (acldisptab_v2[0]),
1973 aclcallnames_v2,
1974 acldisptab_v2},
1975 {sizeof (acldisptab_v3) / sizeof (acldisptab_v3[0]),
1976 aclcallnames_v3,
1977 acldisptab_v3},
1978 };
1979
1980 static void
1981 acl_dispatch(struct svc_req *req, SVCXPRT *xprt)
1982 {
1983 common_dispatch(req, xprt, NFS_ACL_VERSMIN, NFS_ACL_VERSMAX,
1984 "ACL", acl_disptable);
1985 }
1986
1987 int
1988 checkwin(int flavor, int window, struct svc_req *req)
1989 {
1990 struct authdes_cred *adc;
1991
1992 switch (flavor) {
1993 case AUTH_DES:
1994 adc = (struct authdes_cred *)req->rq_clntcred;
1995 CTASSERT(sizeof (struct authdes_cred) <= RQCRED_SIZE);
1996 if (adc->adc_fullname.window > window)
1997 return (0);
1998 break;
1999
2000 default:
2001 break;
2002 }
2003 return (1);
2004 }
2005
2006
2007 /*
2008 * checkauth() will check the access permission against the export
2009 * information. Then map root uid/gid to appropriate uid/gid.
2010 *
2011 * This routine is used by NFS V3 and V2 code.
2012 */
2013 static int
2014 checkauth(struct exportinfo *exi, struct svc_req *req, cred_t *cr, int anon_ok,
2015 bool_t publicfh_ok, bool_t *ro)
2016 {
2017 int i, nfsflavor, rpcflavor, stat, access;
2018 struct secinfo *secp;
2019 caddr_t principal;
2020 char buf[INET6_ADDRSTRLEN]; /* to hold both IPv4 and IPv6 addr */
2021 int anon_res = 0;
2022
2023 uid_t uid;
2024 gid_t gid;
2025 uint_t ngids;
2026 gid_t *gids;
2027
2028 /*
2029 * Check for privileged port number
2030 * N.B.: this assumes that we know the format of a netbuf.
2031 */
2032 if (nfs_portmon) {
2033 struct sockaddr *ca;
2034 ca = (struct sockaddr *)svc_getrpccaller(req->rq_xprt)->buf;
2035
2036 if (ca == NULL)
2037 return (0);
2038
2039 if ((ca->sa_family == AF_INET &&
2040 ntohs(((struct sockaddr_in *)ca)->sin_port) >=
2041 IPPORT_RESERVED) ||
2042 (ca->sa_family == AF_INET6 &&
2043 ntohs(((struct sockaddr_in6 *)ca)->sin6_port) >=
2044 IPPORT_RESERVED)) {
2045 cmn_err(CE_NOTE,
2046 "nfs_server: client %s%ssent NFS request from "
2047 "unprivileged port",
2048 client_name(req), client_addr(req, buf));
2049 return (0);
2050 }
2051 }
2052
2053 /*
2054 * return 1 on success or 0 on failure
2055 */
2056 stat = sec_svc_getcred(req, cr, &principal, &nfsflavor);
2057
2058 /*
2059 * A failed AUTH_UNIX sec_svc_getcred() implies we couldn't set
2060 * the credentials; below we map that to anonymous.
2061 */
2062 if (!stat && nfsflavor != AUTH_UNIX) {
2063 cmn_err(CE_NOTE,
2064 "nfs_server: couldn't get unix cred for %s",
2065 client_name(req));
2066 return (0);
2067 }
2068
2069 /*
2070 * Short circuit checkauth() on operations that support the
2071 * public filehandle, and if the request for that operation
2072 * is using the public filehandle. Note that we must call
2073 * sec_svc_getcred() first so that xp_cookie is set to the
2074 * right value. Normally xp_cookie is just the RPC flavor
2075 * of the the request, but in the case of RPCSEC_GSS it
2076 * could be a pseudo flavor.
2077 */
2078 if (publicfh_ok)
2079 return (1);
2080
2081 rpcflavor = req->rq_cred.oa_flavor;
2082 /*
2083 * Check if the auth flavor is valid for this export
2084 */
2085 access = nfsauth_access(exi, req, cr, &uid, &gid, &ngids, &gids);
2086 if (access & NFSAUTH_DROP)
2087 return (-1); /* drop the request */
2088
2089 if (access & NFSAUTH_RO)
2090 *ro = TRUE;
2091
2092 if (access & NFSAUTH_DENIED) {
2093 /*
2094 * If anon_ok == 1 and we got NFSAUTH_DENIED, it was
2095 * probably due to the flavor not matching during
2096 * the mount attempt. So map the flavor to AUTH_NONE
2097 * so that the credentials get mapped to the anonymous
2098 * user.
2099 */
2100 if (anon_ok == 1)
2101 rpcflavor = AUTH_NONE;
2102 else
2103 return (0); /* deny access */
2104
2105 } else if (access & NFSAUTH_MAPNONE) {
2106 /*
2107 * Access was granted even though the flavor mismatched
2108 * because AUTH_NONE was one of the exported flavors.
2109 */
2110 rpcflavor = AUTH_NONE;
2111
2112 } else if (access & NFSAUTH_WRONGSEC) {
2113 /*
2114 * NFSAUTH_WRONGSEC is used for NFSv4. If we get here,
2115 * it means a client ignored the list of allowed flavors
2116 * returned via the MOUNT protocol. So we just disallow it!
2117 */
2118 return (0);
2119 }
2120
2121 if (rpcflavor != AUTH_SYS)
2122 kmem_free(gids, ngids * sizeof (gid_t));
2123
2124 switch (rpcflavor) {
2125 case AUTH_NONE:
2126 anon_res = crsetugid(cr, exi->exi_export.ex_anon,
2127 exi->exi_export.ex_anon);
2128 (void) crsetgroups(cr, 0, NULL);
2129 break;
2130
2131 case AUTH_UNIX:
2132 if (!stat || crgetuid(cr) == 0 && !(access & NFSAUTH_UIDMAP)) {
2133 anon_res = crsetugid(cr, exi->exi_export.ex_anon,
2134 exi->exi_export.ex_anon);
2135 (void) crsetgroups(cr, 0, NULL);
2136 } else if (crgetuid(cr) == 0 && access & NFSAUTH_ROOT) {
2137 /*
2138 * It is root, so apply rootid to get real UID
2139 * Find the secinfo structure. We should be able
2140 * to find it by the time we reach here.
2141 * nfsauth_access() has done the checking.
2142 */
2143 secp = NULL;
2144 for (i = 0; i < exi->exi_export.ex_seccnt; i++) {
2145 struct secinfo *sptr;
2146 sptr = &exi->exi_export.ex_secinfo[i];
2147 if (sptr->s_secinfo.sc_nfsnum == nfsflavor) {
2148 secp = sptr;
2149 break;
2150 }
2151 }
2152 if (secp != NULL) {
2153 (void) crsetugid(cr, secp->s_rootid,
2154 secp->s_rootid);
2155 (void) crsetgroups(cr, 0, NULL);
2156 }
2157 } else if (crgetuid(cr) != uid || crgetgid(cr) != gid) {
2158 if (crsetugid(cr, uid, gid) != 0)
2159 anon_res = crsetugid(cr,
2160 exi->exi_export.ex_anon,
2161 exi->exi_export.ex_anon);
2162 (void) crsetgroups(cr, 0, NULL);
2163 } else if (access & NFSAUTH_GROUPS) {
2164 (void) crsetgroups(cr, ngids, gids);
2165 }
2166
2167 kmem_free(gids, ngids * sizeof (gid_t));
2168
2169 break;
2170
2171 case AUTH_DES:
2172 case RPCSEC_GSS:
2173 /*
2174 * Find the secinfo structure. We should be able
2175 * to find it by the time we reach here.
2176 * nfsauth_access() has done the checking.
2177 */
2178 secp = NULL;
2179 for (i = 0; i < exi->exi_export.ex_seccnt; i++) {
2180 if (exi->exi_export.ex_secinfo[i].s_secinfo.sc_nfsnum ==
2181 nfsflavor) {
2182 secp = &exi->exi_export.ex_secinfo[i];
2183 break;
2184 }
2185 }
2186
2187 if (!secp) {
2188 cmn_err(CE_NOTE, "nfs_server: client %s%shad "
2189 "no secinfo data for flavor %d",
2190 client_name(req), client_addr(req, buf),
2191 nfsflavor);
2192 return (0);
2193 }
2194
2195 if (!checkwin(rpcflavor, secp->s_window, req)) {
2196 cmn_err(CE_NOTE,
2197 "nfs_server: client %s%sused invalid "
2198 "auth window value",
2199 client_name(req), client_addr(req, buf));
2200 return (0);
2201 }
2202
2203 /*
2204 * Map root principals listed in the share's root= list to root,
2205 * and map any others principals that were mapped to root by RPC
2206 * to anon.
2207 */
2208 if (principal && sec_svc_inrootlist(rpcflavor, principal,
2209 secp->s_rootcnt, secp->s_rootnames)) {
2210 if (crgetuid(cr) == 0 && secp->s_rootid == 0)
2211 return (1);
2212
2213
2214 (void) crsetugid(cr, secp->s_rootid, secp->s_rootid);
2215
2216 /*
2217 * NOTE: If and when kernel-land privilege tracing is
2218 * added this may have to be replaced with code that
2219 * retrieves root's supplementary groups (e.g., using
2220 * kgss_get_group_info(). In the meantime principals
2221 * mapped to uid 0 get all privileges, so setting cr's
2222 * supplementary groups for them does nothing.
2223 */
2224 (void) crsetgroups(cr, 0, NULL);
2225
2226 return (1);
2227 }
2228
2229 /*
2230 * Not a root princ, or not in root list, map UID 0/nobody to
2231 * the anon ID for the share. (RPC sets cr's UIDs and GIDs to
2232 * UID_NOBODY and GID_NOBODY, respectively.)
2233 */
2234 if (crgetuid(cr) != 0 &&
2235 (crgetuid(cr) != UID_NOBODY || crgetgid(cr) != GID_NOBODY))
2236 return (1);
2237
2238 anon_res = crsetugid(cr, exi->exi_export.ex_anon,
2239 exi->exi_export.ex_anon);
2240 (void) crsetgroups(cr, 0, NULL);
2241 break;
2242 default:
2243 return (0);
2244 } /* switch on rpcflavor */
2245
2246 /*
2247 * Even if anon access is disallowed via ex_anon == -1, we allow
2248 * this access if anon_ok is set. So set creds to the default
2249 * "nobody" id.
2250 */
2251 if (anon_res != 0) {
2252 if (anon_ok == 0) {
2253 cmn_err(CE_NOTE,
2254 "nfs_server: client %s%ssent wrong "
2255 "authentication for %s",
2256 client_name(req), client_addr(req, buf),
2257 exi->exi_export.ex_path ?
2258 exi->exi_export.ex_path : "?");
2259 return (0);
2260 }
2261
2262 if (crsetugid(cr, UID_NOBODY, GID_NOBODY) != 0)
2263 return (0);
2264 }
2265
2266 return (1);
2267 }
2268
2269 /*
2270 * returns 0 on failure, -1 on a drop, -2 on wrong security flavor,
2271 * and 1 on success
2272 */
2273 int
2274 checkauth4(struct compound_state *cs, struct svc_req *req)
2275 {
2276 int i, rpcflavor, access;
2277 struct secinfo *secp;
2278 char buf[MAXHOST + 1];
2279 int anon_res = 0, nfsflavor;
2280 struct exportinfo *exi;
2281 cred_t *cr;
2282 caddr_t principal;
2283
2284 uid_t uid;
2285 gid_t gid;
2286 uint_t ngids;
2287 gid_t *gids;
2288
2289 exi = cs->exi;
2290 cr = cs->cr;
2291 principal = cs->principal;
2292 nfsflavor = cs->nfsflavor;
2293
2294 ASSERT(cr != NULL);
2295
2296 rpcflavor = req->rq_cred.oa_flavor;
2297 cs->access &= ~CS_ACCESS_LIMITED;
2298
2299 /*
2300 * Check for privileged port number
2301 * N.B.: this assumes that we know the format of a netbuf.
2302 */
2303 if (nfs_portmon) {
2304 struct sockaddr *ca;
2305 ca = (struct sockaddr *)svc_getrpccaller(req->rq_xprt)->buf;
2306
2307 if (ca == NULL)
2308 return (0);
2309
2310 if ((ca->sa_family == AF_INET &&
2311 ntohs(((struct sockaddr_in *)ca)->sin_port) >=
2312 IPPORT_RESERVED) ||
2313 (ca->sa_family == AF_INET6 &&
2314 ntohs(((struct sockaddr_in6 *)ca)->sin6_port) >=
2315 IPPORT_RESERVED)) {
2316 cmn_err(CE_NOTE,
2317 "nfs_server: client %s%ssent NFSv4 request from "
2318 "unprivileged port",
2319 client_name(req), client_addr(req, buf));
2320 return (0);
2321 }
2322 }
2323
2324 /*
2325 * Check the access right per auth flavor on the vnode of
2326 * this export for the given request.
2327 */
2328 access = nfsauth4_access(cs->exi, cs->vp, req, cr, &uid, &gid, &ngids,
2329 &gids);
2330
2331 if (access & NFSAUTH_WRONGSEC)
2332 return (-2); /* no access for this security flavor */
2333
2334 if (access & NFSAUTH_DROP)
2335 return (-1); /* drop the request */
2336
2337 if (access & NFSAUTH_DENIED) {
2338
2339 if (exi->exi_export.ex_seccnt > 0)
2340 return (0); /* deny access */
2341
2342 } else if (access & NFSAUTH_LIMITED) {
2343
2344 cs->access |= CS_ACCESS_LIMITED;
2345
2346 } else if (access & NFSAUTH_MAPNONE) {
2347 /*
2348 * Access was granted even though the flavor mismatched
2349 * because AUTH_NONE was one of the exported flavors.
2350 */
2351 rpcflavor = AUTH_NONE;
2352 }
2353
2354 /*
2355 * XXX probably need to redo some of it for nfsv4?
2356 * return 1 on success or 0 on failure
2357 */
2358
2359 if (rpcflavor != AUTH_SYS)
2360 kmem_free(gids, ngids * sizeof (gid_t));
2361
2362 switch (rpcflavor) {
2363 case AUTH_NONE:
2364 anon_res = crsetugid(cr, exi->exi_export.ex_anon,
2365 exi->exi_export.ex_anon);
2366 (void) crsetgroups(cr, 0, NULL);
2367 break;
2368
2369 case AUTH_UNIX:
2370 if (crgetuid(cr) == 0 && !(access & NFSAUTH_UIDMAP)) {
2371 anon_res = crsetugid(cr, exi->exi_export.ex_anon,
2372 exi->exi_export.ex_anon);
2373 (void) crsetgroups(cr, 0, NULL);
2374 } else if (crgetuid(cr) == 0 && access & NFSAUTH_ROOT) {
2375 /*
2376 * It is root, so apply rootid to get real UID
2377 * Find the secinfo structure. We should be able
2378 * to find it by the time we reach here.
2379 * nfsauth_access() has done the checking.
2380 */
2381 secp = NULL;
2382 for (i = 0; i < exi->exi_export.ex_seccnt; i++) {
2383 struct secinfo *sptr;
2384 sptr = &exi->exi_export.ex_secinfo[i];
2385 if (sptr->s_secinfo.sc_nfsnum == nfsflavor) {
2386 secp = &exi->exi_export.ex_secinfo[i];
2387 break;
2388 }
2389 }
2390 if (secp != NULL) {
2391 (void) crsetugid(cr, secp->s_rootid,
2392 secp->s_rootid);
2393 (void) crsetgroups(cr, 0, NULL);
2394 }
2395 } else if (crgetuid(cr) != uid || crgetgid(cr) != gid) {
2396 if (crsetugid(cr, uid, gid) != 0)
2397 anon_res = crsetugid(cr,
2398 exi->exi_export.ex_anon,
2399 exi->exi_export.ex_anon);
2400 (void) crsetgroups(cr, 0, NULL);
2401 } if (access & NFSAUTH_GROUPS) {
2402 (void) crsetgroups(cr, ngids, gids);
2403 }
2404
2405 kmem_free(gids, ngids * sizeof (gid_t));
2406
2407 break;
2408
2409 default:
2410 /*
2411 * Find the secinfo structure. We should be able
2412 * to find it by the time we reach here.
2413 * nfsauth_access() has done the checking.
2414 */
2415 secp = NULL;
2416 for (i = 0; i < exi->exi_export.ex_seccnt; i++) {
2417 if (exi->exi_export.ex_secinfo[i].s_secinfo.sc_nfsnum ==
2418 nfsflavor) {
2419 secp = &exi->exi_export.ex_secinfo[i];
2420 break;
2421 }
2422 }
2423
2424 if (!secp) {
2425 cmn_err(CE_NOTE, "nfs_server: client %s%shad "
2426 "no secinfo data for flavor %d",
2427 client_name(req), client_addr(req, buf),
2428 nfsflavor);
2429 return (0);
2430 }
2431
2432 if (!checkwin(rpcflavor, secp->s_window, req)) {
2433 cmn_err(CE_NOTE,
2434 "nfs_server: client %s%sused invalid "
2435 "auth window value",
2436 client_name(req), client_addr(req, buf));
2437 return (0);
2438 }
2439
2440 /*
2441 * Map root principals listed in the share's root= list to root,
2442 * and map any others principals that were mapped to root by RPC
2443 * to anon. If not going to anon, set to rootid (root_mapping).
2444 */
2445 if (principal && sec_svc_inrootlist(rpcflavor, principal,
2446 secp->s_rootcnt, secp->s_rootnames)) {
2447 if (crgetuid(cr) == 0 && secp->s_rootid == 0)
2448 return (1);
2449
2450 (void) crsetugid(cr, secp->s_rootid, secp->s_rootid);
2451
2452 /*
2453 * NOTE: If and when kernel-land privilege tracing is
2454 * added this may have to be replaced with code that
2455 * retrieves root's supplementary groups (e.g., using
2456 * kgss_get_group_info(). In the meantime principals
2457 * mapped to uid 0 get all privileges, so setting cr's
2458 * supplementary groups for them does nothing.
2459 */
2460 (void) crsetgroups(cr, 0, NULL);
2461
2462 return (1);
2463 }
2464
2465 /*
2466 * Not a root princ, or not in root list, map UID 0/nobody to
2467 * the anon ID for the share. (RPC sets cr's UIDs and GIDs to
2468 * UID_NOBODY and GID_NOBODY, respectively.)
2469 */
2470 if (crgetuid(cr) != 0 &&
2471 (crgetuid(cr) != UID_NOBODY || crgetgid(cr) != GID_NOBODY))
2472 return (1);
2473
2474 anon_res = crsetugid(cr, exi->exi_export.ex_anon,
2475 exi->exi_export.ex_anon);
2476 (void) crsetgroups(cr, 0, NULL);
2477 break;
2478 } /* switch on rpcflavor */
2479
2480 /*
2481 * Even if anon access is disallowed via ex_anon == -1, we allow
2482 * this access if anon_ok is set. So set creds to the default
2483 * "nobody" id.
2484 */
2485
2486 if (anon_res != 0) {
2487 cmn_err(CE_NOTE,
2488 "nfs_server: client %s%ssent wrong "
2489 "authentication for %s",
2490 client_name(req), client_addr(req, buf),
2491 exi->exi_export.ex_path ?
2492 exi->exi_export.ex_path : "?");
2493 return (0);
2494 }
2495
2496 return (1);
2497 }
2498
2499
2500 static char *
2501 client_name(struct svc_req *req)
2502 {
2503 char *hostname = NULL;
2504
2505 /*
2506 * If it's a Unix cred then use the
2507 * hostname from the credential.
2508 */
2509 if (req->rq_cred.oa_flavor == AUTH_UNIX) {
2510 hostname = ((struct authunix_parms *)
2511 req->rq_clntcred)->aup_machname;
2512 }
2513 if (hostname == NULL)
2514 hostname = "";
2515
2516 return (hostname);
2517 }
2518
2519 static char *
2520 client_addr(struct svc_req *req, char *buf)
2521 {
2522 struct sockaddr *ca;
2523 uchar_t *b;
2524 char *frontspace = "";
2525
2526 /*
2527 * We assume we are called in tandem with client_name and the
2528 * format string looks like "...client %s%sblah blah..."
2529 *
2530 * If it's a Unix cred then client_name returned
2531 * a host name, so we need insert a space between host name
2532 * and IP address.
2533 */
2534 if (req->rq_cred.oa_flavor == AUTH_UNIX)
2535 frontspace = " ";
2536
2537 /*
2538 * Convert the caller's IP address to a dotted string
2539 */
2540 ca = (struct sockaddr *)svc_getrpccaller(req->rq_xprt)->buf;
2541
2542 if (ca->sa_family == AF_INET) {
2543 b = (uchar_t *)&((struct sockaddr_in *)ca)->sin_addr;
2544 (void) sprintf(buf, "%s(%d.%d.%d.%d) ", frontspace,
2545 b[0] & 0xFF, b[1] & 0xFF, b[2] & 0xFF, b[3] & 0xFF);
2546 } else if (ca->sa_family == AF_INET6) {
2547 struct sockaddr_in6 *sin6;
2548 sin6 = (struct sockaddr_in6 *)ca;
2549 (void) kinet_ntop6((uchar_t *)&sin6->sin6_addr,
2550 buf, INET6_ADDRSTRLEN);
2551
2552 } else {
2553
2554 /*
2555 * No IP address to print. If there was a host name
2556 * printed, then we print a space.
2557 */
2558 (void) sprintf(buf, frontspace);
2559 }
2560
2561 return (buf);
2562 }
2563
2564 /*
2565 * NFS Server initialization routine. This routine should only be called
2566 * once. It performs the following tasks:
2567 * - Call sub-initialization routines (localize access to variables)
2568 * - Initialize all locks
2569 * - initialize the version 3 write verifier
2570 */
2571 void
2572 nfs_srvinit(void)
2573 {
2574
2575 /* Truly global stuff in this module (not per zone) */
2576 rw_init(&nfssrv_globals_rwl, NULL, RW_DEFAULT, NULL);
2577 list_create(&nfssrv_globals_list, sizeof (nfs_globals_t),
2578 offsetof(nfs_globals_t, nfs_g_link));
2579 tsd_create(&nfs_server_tsd_key, NULL);
2580
2581 /* The order here is important */
2582 nfs_exportinit();
2583 rfs_srvrinit();
2584 rfs3_srvrinit();
2585 rfs4_srvrinit();
2586 nfsauth_init();
2587
2588 /*
2589 * NFS server zone-specific global variables
2590 * Note the zone_init is called for the GZ here.
2591 */
2592 zone_key_create(&nfssrv_zone_key, nfs_server_zone_init,
2593 nfs_server_zone_shutdown, nfs_server_zone_fini);
2594 }
2595
2596 /*
2597 * NFS Server finalization routine. This routine is called to cleanup the
2598 * initialization work previously performed if the NFS server module could
2599 * not be loaded correctly.
2600 */
2601 void
2602 nfs_srvfini(void)
2603 {
2604
2605 /*
2606 * NFS server zone-specific global variables
2607 * Note the zone_fini is called for the GZ here.
2608 */
2609 (void) zone_key_delete(nfssrv_zone_key);
2610
2611 /* The order here is important (reverse of init) */
2612 nfsauth_fini();
2613 rfs4_srvrfini();
2614 rfs3_srvrfini();
2615 rfs_srvrfini();
2616 nfs_exportfini();
2617
2618 /* Truly global stuff in this module (not per zone) */
2619 tsd_destroy(&nfs_server_tsd_key);
2620 list_destroy(&nfssrv_globals_list);
2621 rw_destroy(&nfssrv_globals_rwl);
2622 }
2623
2624 /*
2625 * Zone init, shutdown, fini functions for the NFS server
2626 *
2627 * This design is careful to create the entire hierarhcy of
2628 * NFS server "globals" (including those created by various
2629 * per-module *_zone_init functions, etc.) so that all these
2630 * objects have exactly the same lifetime.
2631 *
2632 * These objects are also kept on a list for two reasons:
2633 * 1: It makes finding these in mdb _much_ easier.
2634 * 2: It allows operating across all zone globals for
2635 * functions like nfs_auth.c:exi_cache_reclaim
2636 */
2637 static void *
2638 nfs_server_zone_init(zoneid_t zoneid)
2639 {
2640 nfs_globals_t *ng;
2641
2642 ng = kmem_zalloc(sizeof (*ng), KM_SLEEP);
2643
2644 ng->nfs_versmin = NFS_VERSMIN_DEFAULT;
2645 ng->nfs_versmax = NFS_VERSMAX_DEFAULT;
2646
2647 /* Init the stuff to control start/stop */
2648 ng->nfs_server_upordown = NFS_SERVER_STOPPED;
2649 mutex_init(&ng->nfs_server_upordown_lock, NULL, MUTEX_DEFAULT, NULL);
2650 cv_init(&ng->nfs_server_upordown_cv, NULL, CV_DEFAULT, NULL);
2651 mutex_init(&ng->rdma_wait_mutex, NULL, MUTEX_DEFAULT, NULL);
2652 cv_init(&ng->rdma_wait_cv, NULL, CV_DEFAULT, NULL);
2653
2654 ng->nfs_zoneid = zoneid;
2655
2656 /*
2657 * Order here is important.
2658 * export init must precede srv init calls.
2659 */
2660 nfs_export_zone_init(ng);
2661 rfs_stat_zone_init(ng);
2662 rfs_srv_zone_init(ng);
2663 rfs3_srv_zone_init(ng);
2664 rfs4_srv_zone_init(ng);
2665 nfsauth_zone_init(ng);
2666
2667 rw_enter(&nfssrv_globals_rwl, RW_WRITER);
2668 list_insert_tail(&nfssrv_globals_list, ng);
2669 rw_exit(&nfssrv_globals_rwl);
2670
2671 return (ng);
2672 }
2673
2674 /* ARGSUSED */
2675 static void
2676 nfs_server_zone_shutdown(zoneid_t zoneid, void *data)
2677 {
2678 nfs_globals_t *ng;
2679
2680 ng = (nfs_globals_t *)data;
2681
2682 /*
2683 * Order is like _fini, but only
2684 * some modules need this hook.
2685 */
2686 nfsauth_zone_shutdown(ng);
2687 nfs_export_zone_shutdown(ng);
2688 }
2689
2690 /* ARGSUSED */
2691 static void
2692 nfs_server_zone_fini(zoneid_t zoneid, void *data)
2693 {
2694 nfs_globals_t *ng;
2695
2696 ng = (nfs_globals_t *)data;
2697
2698 rw_enter(&nfssrv_globals_rwl, RW_WRITER);
2699 list_remove(&nfssrv_globals_list, ng);
2700 rw_exit(&nfssrv_globals_rwl);
2701
2702 /*
2703 * Order here is important.
2704 * reverse order from init
2705 */
2706 nfsauth_zone_fini(ng);
2707 rfs4_srv_zone_fini(ng);
2708 rfs3_srv_zone_fini(ng);
2709 rfs_srv_zone_fini(ng);
2710 rfs_stat_zone_fini(ng);
2711 nfs_export_zone_fini(ng);
2712
2713 mutex_destroy(&ng->nfs_server_upordown_lock);
2714 cv_destroy(&ng->nfs_server_upordown_cv);
2715 mutex_destroy(&ng->rdma_wait_mutex);
2716 cv_destroy(&ng->rdma_wait_cv);
2717
2718 kmem_free(ng, sizeof (*ng));
2719 }
2720
2721 /*
2722 * Set up an iovec array of up to cnt pointers.
2723 */
2724 void
2725 mblk_to_iov(mblk_t *m, int cnt, struct iovec *iovp)
2726 {
2727 while (m != NULL && cnt-- > 0) {
2728 iovp->iov_base = (caddr_t)m->b_rptr;
2729 iovp->iov_len = (m->b_wptr - m->b_rptr);
2730 iovp++;
2731 m = m->b_cont;
2732 }
2733 }
2734
2735 /*
2736 * Common code between NFS Version 2 and NFS Version 3 for the public
2737 * filehandle multicomponent lookups.
2738 */
2739
2740 /*
2741 * Public filehandle evaluation of a multi-component lookup, following
2742 * symbolic links, if necessary. This may result in a vnode in another
2743 * filesystem, which is OK as long as the other filesystem is exported.
2744 *
2745 * Note that the exi will be set either to NULL or a new reference to the
2746 * exportinfo struct that corresponds to the vnode of the multi-component path.
2747 * It is the callers responsibility to release this reference.
2748 */
2749 int
2750 rfs_publicfh_mclookup(char *p, vnode_t *dvp, cred_t *cr, vnode_t **vpp,
2751 struct exportinfo **exi, struct sec_ol *sec)
2752 {
2753 int pathflag;
2754 vnode_t *mc_dvp = NULL;
2755 vnode_t *realvp;
2756 int error;
2757
2758 *exi = NULL;
2759
2760 /*
2761 * check if the given path is a url or native path. Since p is
2762 * modified by MCLpath(), it may be empty after returning from
2763 * there, and should be checked.
2764 */
2765 if ((pathflag = MCLpath(&p)) == -1)
2766 return (EIO);
2767
2768 /*
2769 * If pathflag is SECURITY_QUERY, turn the SEC_QUERY bit
2770 * on in sec->sec_flags. This bit will later serve as an
2771 * indication in makefh_ol() or makefh3_ol() to overload the
2772 * filehandle to contain the sec modes used by the server for
2773 * the path.
2774 */
2775 if (pathflag == SECURITY_QUERY) {
2776 if ((sec->sec_index = (uint_t)(*p)) > 0) {
2777 sec->sec_flags |= SEC_QUERY;
2778 p++;
2779 if ((pathflag = MCLpath(&p)) == -1)
2780 return (EIO);
2781 } else {
2782 cmn_err(CE_NOTE,
2783 "nfs_server: invalid security index %d, "
2784 "violating WebNFS SNEGO protocol.", sec->sec_index);
2785 return (EIO);
2786 }
2787 }
2788
2789 if (p[0] == '\0') {
2790 error = ENOENT;
2791 goto publicfh_done;
2792 }
2793
2794 error = rfs_pathname(p, &mc_dvp, vpp, dvp, cr, pathflag);
2795
2796 /*
2797 * If name resolves to "/" we get EINVAL since we asked for
2798 * the vnode of the directory that the file is in. Try again
2799 * with NULL directory vnode.
2800 */
2801 if (error == EINVAL) {
2802 error = rfs_pathname(p, NULL, vpp, dvp, cr, pathflag);
2803 if (!error) {
2804 ASSERT(*vpp != NULL);
2805 if ((*vpp)->v_type == VDIR) {
2806 VN_HOLD(*vpp);
2807 mc_dvp = *vpp;
2808 } else {
2809 /*
2810 * This should not happen, the filesystem is
2811 * in an inconsistent state. Fail the lookup
2812 * at this point.
2813 */
2814 VN_RELE(*vpp);
2815 error = EINVAL;
2816 }
2817 }
2818 }
2819
2820 if (error)
2821 goto publicfh_done;
2822
2823 if (*vpp == NULL) {
2824 error = ENOENT;
2825 goto publicfh_done;
2826 }
2827
2828 ASSERT(mc_dvp != NULL);
2829 ASSERT(*vpp != NULL);
2830
2831 if ((*vpp)->v_type == VDIR) {
2832 do {
2833 /*
2834 * *vpp may be an AutoFS node, so we perform
2835 * a VOP_ACCESS() to trigger the mount of the intended
2836 * filesystem, so we can perform the lookup in the
2837 * intended filesystem.
2838 */
2839 (void) VOP_ACCESS(*vpp, 0, 0, cr, NULL);
2840
2841 /*
2842 * If vnode is covered, get the
2843 * the topmost vnode.
2844 */
2845 if (vn_mountedvfs(*vpp) != NULL) {
2846 error = traverse(vpp);
2847 if (error) {
2848 VN_RELE(*vpp);
2849 goto publicfh_done;
2850 }
2851 }
2852
2853 if (VOP_REALVP(*vpp, &realvp, NULL) == 0 &&
2854 realvp != *vpp) {
2855 /*
2856 * If realvp is different from *vpp
2857 * then release our reference on *vpp, so that
2858 * the export access check be performed on the
2859 * real filesystem instead.
2860 */
2861 VN_HOLD(realvp);
2862 VN_RELE(*vpp);
2863 *vpp = realvp;
2864 } else {
2865 break;
2866 }
2867 /* LINTED */
2868 } while (TRUE);
2869
2870 /*
2871 * Let nfs_vptexi() figure what the real parent is.
2872 */
2873 VN_RELE(mc_dvp);
2874 mc_dvp = NULL;
2875
2876 } else {
2877 /*
2878 * If vnode is covered, get the
2879 * the topmost vnode.
2880 */
2881 if (vn_mountedvfs(mc_dvp) != NULL) {
2882 error = traverse(&mc_dvp);
2883 if (error) {
2884 VN_RELE(*vpp);
2885 goto publicfh_done;
2886 }
2887 }
2888
2889 if (VOP_REALVP(mc_dvp, &realvp, NULL) == 0 &&
2890 realvp != mc_dvp) {
2891 /*
2892 * *vpp is a file, obtain realvp of the parent
2893 * directory vnode.
2894 */
2895 VN_HOLD(realvp);
2896 VN_RELE(mc_dvp);
2897 mc_dvp = realvp;
2898 }
2899 }
2900
2901 /*
2902 * The pathname may take us from the public filesystem to another.
2903 * If that's the case then just set the exportinfo to the new export
2904 * and build filehandle for it. Thanks to per-access checking there's
2905 * no security issues with doing this. If the client is not allowed
2906 * access to this new export then it will get an access error when it
2907 * tries to use the filehandle
2908 */
2909 if (error = nfs_check_vpexi(mc_dvp, *vpp, kcred, exi)) {
2910 VN_RELE(*vpp);
2911 goto publicfh_done;
2912 }
2913
2914 /*
2915 * Not allowed access to pseudo exports.
2916 */
2917 if (PSEUDO(*exi)) {
2918 error = ENOENT;
2919 VN_RELE(*vpp);
2920 goto publicfh_done;
2921 }
2922
2923 /*
2924 * Do a lookup for the index file. We know the index option doesn't
2925 * allow paths through handling in the share command, so mc_dvp will
2926 * be the parent for the index file vnode, if its present. Use
2927 * temporary pointers to preserve and reuse the vnode pointers of the
2928 * original directory in case there's no index file. Note that the
2929 * index file is a native path, and should not be interpreted by
2930 * the URL parser in rfs_pathname()
2931 */
2932 if (((*exi)->exi_export.ex_flags & EX_INDEX) &&
2933 ((*vpp)->v_type == VDIR) && (pathflag == URLPATH)) {
2934 vnode_t *tvp, *tmc_dvp; /* temporary vnode pointers */
2935
2936 tmc_dvp = mc_dvp;
2937 mc_dvp = tvp = *vpp;
2938
2939 error = rfs_pathname((*exi)->exi_export.ex_index, NULL, vpp,
2940 mc_dvp, cr, NATIVEPATH);
2941
2942 if (error == ENOENT) {
2943 *vpp = tvp;
2944 mc_dvp = tmc_dvp;
2945 error = 0;
2946 } else { /* ok or error other than ENOENT */
2947 if (tmc_dvp)
2948 VN_RELE(tmc_dvp);
2949 if (error)
2950 goto publicfh_done;
2951
2952 /*
2953 * Found a valid vp for index "filename". Sanity check
2954 * for odd case where a directory is provided as index
2955 * option argument and leads us to another filesystem
2956 */
2957
2958 /* Release the reference on the old exi value */
2959 ASSERT(*exi != NULL);
2960 exi_rele(*exi);
2961 *exi = NULL;
2962
2963 if (error = nfs_check_vpexi(mc_dvp, *vpp, kcred, exi)) {
2964 VN_RELE(*vpp);
2965 goto publicfh_done;
2966 }
2967 /* Have a new *exi */
2968 }
2969 }
2970
2971 publicfh_done:
2972 if (mc_dvp)
2973 VN_RELE(mc_dvp);
2974
2975 return (error);
2976 }
2977
2978 /*
2979 * Evaluate a multi-component path
2980 */
2981 int
2982 rfs_pathname(
2983 char *path, /* pathname to evaluate */
2984 vnode_t **dirvpp, /* ret for ptr to parent dir vnode */
2985 vnode_t **compvpp, /* ret for ptr to component vnode */
2986 vnode_t *startdvp, /* starting vnode */
2987 cred_t *cr, /* user's credential */
2988 int pathflag) /* flag to identify path, e.g. URL */
2989 {
2990 char namebuf[TYPICALMAXPATHLEN];
2991 struct pathname pn;
2992 int error;
2993
2994 ASSERT3U(crgetzoneid(cr), ==, curzone->zone_id);
2995
2996 /*
2997 * If pathname starts with '/', then set startdvp to root.
2998 */
2999 if (*path == '/') {
3000 while (*path == '/')
3001 path++;
3002
3003 startdvp = ZONE_ROOTVP();
3004 }
3005
3006 error = pn_get_buf(path, UIO_SYSSPACE, &pn, namebuf, sizeof (namebuf));
3007 if (error == 0) {
3008 /*
3009 * Call the URL parser for URL paths to modify the original
3010 * string to handle any '%' encoded characters that exist.
3011 * Done here to avoid an extra bcopy in the lookup.
3012 * We need to be careful about pathlen's. We know that
3013 * rfs_pathname() is called with a non-empty path. However,
3014 * it could be emptied due to the path simply being all /'s,
3015 * which is valid to proceed with the lookup, or due to the
3016 * URL parser finding an encoded null character at the
3017 * beginning of path which should not proceed with the lookup.
3018 */
3019 if (pn.pn_pathlen != 0 && pathflag == URLPATH) {
3020 URLparse(pn.pn_path);
3021 if ((pn.pn_pathlen = strlen(pn.pn_path)) == 0)
3022 return (ENOENT);
3023 }
3024 VN_HOLD(startdvp);
3025 error = lookuppnvp(&pn, NULL, NO_FOLLOW, dirvpp, compvpp,
3026 ZONE_ROOTVP(), startdvp, cr);
3027 }
3028 if (error == ENAMETOOLONG) {
3029 /*
3030 * This thread used a pathname > TYPICALMAXPATHLEN bytes long.
3031 */
3032 if (error = pn_get(path, UIO_SYSSPACE, &pn))
3033 return (error);
3034 if (pn.pn_pathlen != 0 && pathflag == URLPATH) {
3035 URLparse(pn.pn_path);
3036 if ((pn.pn_pathlen = strlen(pn.pn_path)) == 0) {
3037 pn_free(&pn);
3038 return (ENOENT);
3039 }
3040 }
3041 VN_HOLD(startdvp);
3042 error = lookuppnvp(&pn, NULL, NO_FOLLOW, dirvpp, compvpp,
3043 ZONE_ROOTVP(), startdvp, cr);
3044 pn_free(&pn);
3045 }
3046
3047 return (error);
3048 }
3049
3050 /*
3051 * Adapt the multicomponent lookup path depending on the pathtype
3052 */
3053 static int
3054 MCLpath(char **path)
3055 {
3056 unsigned char c = (unsigned char)**path;
3057
3058 /*
3059 * If the MCL path is between 0x20 and 0x7E (graphic printable
3060 * character of the US-ASCII coded character set), its a URL path,
3061 * per RFC 1738.
3062 */
3063 if (c >= 0x20 && c <= 0x7E)
3064 return (URLPATH);
3065
3066 /*
3067 * If the first octet of the MCL path is not an ASCII character
3068 * then it must be interpreted as a tag value that describes the
3069 * format of the remaining octets of the MCL path.
3070 *
3071 * If the first octet of the MCL path is 0x81 it is a query
3072 * for the security info.
3073 */
3074 switch (c) {
3075 case 0x80: /* native path, i.e. MCL via mount protocol */
3076 (*path)++;
3077 return (NATIVEPATH);
3078 case 0x81: /* security query */
3079 (*path)++;
3080 return (SECURITY_QUERY);
3081 default:
3082 return (-1);
3083 }
3084 }
3085
3086 #define fromhex(c) ((c >= '0' && c <= '9') ? (c - '0') : \
3087 ((c >= 'A' && c <= 'F') ? (c - 'A' + 10) :\
3088 ((c >= 'a' && c <= 'f') ? (c - 'a' + 10) : 0)))
3089
3090 /*
3091 * The implementation of URLparse guarantees that the final string will
3092 * fit in the original one. Replaces '%' occurrences followed by 2 characters
3093 * with its corresponding hexadecimal character.
3094 */
3095 static void
3096 URLparse(char *str)
3097 {
3098 char *p, *q;
3099
3100 p = q = str;
3101 while (*p) {
3102 *q = *p;
3103 if (*p++ == '%') {
3104 if (*p) {
3105 *q = fromhex(*p) * 16;
3106 p++;
3107 if (*p) {
3108 *q += fromhex(*p);
3109 p++;
3110 }
3111 }
3112 }
3113 q++;
3114 }
3115 *q = '\0';
3116 }
3117
3118
3119 /*
3120 * Get the export information for the lookup vnode, and verify its
3121 * useable.
3122 */
3123 int
3124 nfs_check_vpexi(vnode_t *mc_dvp, vnode_t *vp, cred_t *cr,
3125 struct exportinfo **exi)
3126 {
3127 int walk;
3128 int error = 0;
3129
3130 *exi = nfs_vptoexi(mc_dvp, vp, cr, &walk, NULL, FALSE);
3131 if (*exi == NULL)
3132 error = EACCES;
3133 else {
3134 /*
3135 * If nosub is set for this export then
3136 * a lookup relative to the public fh
3137 * must not terminate below the
3138 * exported directory.
3139 */
3140 if ((*exi)->exi_export.ex_flags & EX_NOSUB && walk > 0)
3141 error = EACCES;
3142 }
3143
3144 return (error);
3145 }
3146
3147 /*
3148 * Used by NFSv3 and NFSv4 server to query label of
3149 * a pathname component during lookup/access ops.
3150 */
3151 ts_label_t *
3152 nfs_getflabel(vnode_t *vp, struct exportinfo *exi)
3153 {
3154 zone_t *zone;
3155 ts_label_t *zone_label;
3156 char *path;
3157
3158 mutex_enter(&vp->v_lock);
3159 if (vp->v_path != vn_vpath_empty) {
3160 zone = zone_find_by_any_path(vp->v_path, B_FALSE);
3161 mutex_exit(&vp->v_lock);
3162 } else {
3163 /*
3164 * v_path not cached. Fall back on pathname of exported
3165 * file system as we rely on pathname from which we can
3166 * derive a label. The exported file system portion of
3167 * path is sufficient to obtain a label.
3168 */
3169 path = exi->exi_export.ex_path;
3170 if (path == NULL) {
3171 mutex_exit(&vp->v_lock);
3172 return (NULL);
3173 }
3174 zone = zone_find_by_any_path(path, B_FALSE);
3175 mutex_exit(&vp->v_lock);
3176 }
3177 /*
3178 * Caller has verified that the file is either
3179 * exported or visible. So if the path falls in
3180 * global zone, admin_low is returned; otherwise
3181 * the zone's label is returned.
3182 */
3183 zone_label = zone->zone_slabel;
3184 label_hold(zone_label);
3185 zone_rele(zone);
3186 return (zone_label);
3187 }
3188
3189 /*
3190 * TX NFS routine used by NFSv3 and NFSv4 to do label check
3191 * on client label and server's file object lable.
3192 */
3193 boolean_t
3194 do_rfs_label_check(bslabel_t *clabel, vnode_t *vp, int flag,
3195 struct exportinfo *exi)
3196 {
3197 bslabel_t *slabel;
3198 ts_label_t *tslabel;
3199 boolean_t result;
3200
3201 if ((tslabel = nfs_getflabel(vp, exi)) == NULL) {
3202 return (B_FALSE);
3203 }
3204 slabel = label2bslabel(tslabel);
3205 DTRACE_PROBE4(tx__rfs__log__info__labelcheck, char *,
3206 "comparing server's file label(1) with client label(2) (vp(3))",
3207 bslabel_t *, slabel, bslabel_t *, clabel, vnode_t *, vp);
3208
3209 if (flag == EQUALITY_CHECK)
3210 result = blequal(clabel, slabel);
3211 else
3212 result = bldominates(clabel, slabel);
3213 label_rele(tslabel);
3214 return (result);
3215 }
3216
3217 /*
3218 * Callback function to return the loaned buffers.
3219 * Calls VOP_RETZCBUF() only after all uio_iov[]
3220 * buffers are returned. nu_ref maintains the count.
3221 */
3222 void
3223 rfs_free_xuio(void *free_arg)
3224 {
3225 uint_t ref;
3226 nfs_xuio_t *nfsuiop = (nfs_xuio_t *)free_arg;
3227
3228 ref = atomic_dec_uint_nv(&nfsuiop->nu_ref);
3229
3230 /*
3231 * Call VOP_RETZCBUF() only when all the iov buffers
3232 * are sent OTW.
3233 */
3234 if (ref != 0)
3235 return;
3236
3237 if (((uio_t *)nfsuiop)->uio_extflg & UIO_XUIO) {
3238 (void) VOP_RETZCBUF(nfsuiop->nu_vp, (xuio_t *)free_arg, NULL,
3239 NULL);
3240 VN_RELE(nfsuiop->nu_vp);
3241 }
3242
3243 kmem_cache_free(nfs_xuio_cache, free_arg);
3244 }
3245
3246 xuio_t *
3247 rfs_setup_xuio(vnode_t *vp)
3248 {
3249 nfs_xuio_t *nfsuiop;
3250
3251 nfsuiop = kmem_cache_alloc(nfs_xuio_cache, KM_SLEEP);
3252
3253 bzero(nfsuiop, sizeof (nfs_xuio_t));
3254 nfsuiop->nu_vp = vp;
3255
3256 /*
3257 * ref count set to 1. more may be added
3258 * if multiple mblks refer to multiple iov's.
3259 * This is done in uio_to_mblk().
3260 */
3261
3262 nfsuiop->nu_ref = 1;
3263
3264 nfsuiop->nu_frtn.free_func = rfs_free_xuio;
3265 nfsuiop->nu_frtn.free_arg = (char *)nfsuiop;
3266
3267 nfsuiop->nu_uio.xu_type = UIOTYPE_ZEROCOPY;
3268
3269 return (&nfsuiop->nu_uio);
3270 }
3271
3272 mblk_t *
3273 uio_to_mblk(uio_t *uiop)
3274 {
3275 struct iovec *iovp;
3276 int i;
3277 mblk_t *mp, *mp1;
3278 nfs_xuio_t *nfsuiop = (nfs_xuio_t *)uiop;
3279
3280 if (uiop->uio_iovcnt == 0)
3281 return (NULL);
3282
3283 iovp = uiop->uio_iov;
3284 mp = mp1 = esballoca((uchar_t *)iovp->iov_base, iovp->iov_len,
3285 BPRI_MED, &nfsuiop->nu_frtn);
3286 ASSERT(mp != NULL);
3287
3288 mp->b_wptr += iovp->iov_len;
3289 mp->b_datap->db_type = M_DATA;
3290
3291 for (i = 1; i < uiop->uio_iovcnt; i++) {
3292 iovp = (uiop->uio_iov + i);
3293
3294 mp1->b_cont = esballoca(
3295 (uchar_t *)iovp->iov_base, iovp->iov_len, BPRI_MED,
3296 &nfsuiop->nu_frtn);
3297
3298 mp1 = mp1->b_cont;
3299 ASSERT(mp1 != NULL);
3300 mp1->b_wptr += iovp->iov_len;
3301 mp1->b_datap->db_type = M_DATA;
3302 }
3303
3304 nfsuiop->nu_ref = uiop->uio_iovcnt;
3305
3306 return (mp);
3307 }
3308
3309 /*
3310 * Allocate memory to hold data for a read request of len bytes.
3311 *
3312 * We don't allocate buffers greater than kmem_max_cached in size to avoid
3313 * allocating memory from the kmem_oversized arena. If we allocate oversized
3314 * buffers, we incur heavy cross-call activity when freeing these large buffers
3315 * in the TCP receive path. Note that we can't set b_wptr here since the
3316 * length of the data returned may differ from the length requested when
3317 * reading the end of a file; we set b_wptr in rfs_rndup_mblks() once the
3318 * length of the read is known.
3319 */
3320 mblk_t *
3321 rfs_read_alloc(uint_t len, struct iovec **iov, int *iovcnt)
3322 {
3323 struct iovec *iovarr;
3324 mblk_t *mp, **mpp = ∓
3325 size_t mpsize;
3326 uint_t remain = len;
3327 int i, err = 0;
3328
3329 *iovcnt = howmany(len, kmem_max_cached);
3330
3331 iovarr = kmem_alloc(*iovcnt * sizeof (struct iovec), KM_SLEEP);
3332 *iov = iovarr;
3333
3334 for (i = 0; i < *iovcnt; remain -= mpsize, i++) {
3335 ASSERT(remain <= len);
3336 /*
3337 * We roundup the size we allocate to a multiple of
3338 * BYTES_PER_XDR_UNIT (4 bytes) so that the call to
3339 * xdrmblk_putmblk() never fails.
3340 */
3341 ASSERT(kmem_max_cached % BYTES_PER_XDR_UNIT == 0);
3342 mpsize = MIN(kmem_max_cached, remain);
3343 *mpp = allocb_wait(RNDUP(mpsize), BPRI_MED, STR_NOSIG, &err);
3344 ASSERT(*mpp != NULL);
3345 ASSERT(err == 0);
3346
3347 iovarr[i].iov_base = (caddr_t)(*mpp)->b_rptr;
3348 iovarr[i].iov_len = mpsize;
3349 mpp = &(*mpp)->b_cont;
3350 }
3351 return (mp);
3352 }
3353
3354 void
3355 rfs_rndup_mblks(mblk_t *mp, uint_t len, int buf_loaned)
3356 {
3357 int i;
3358 int alloc_err = 0;
3359 mblk_t *rmp;
3360 uint_t mpsize, remainder;
3361
3362 remainder = P2NPHASE(len, BYTES_PER_XDR_UNIT);
3363
3364 /*
3365 * Non copy-reduction case. This function assumes that blocks were
3366 * allocated in multiples of BYTES_PER_XDR_UNIT bytes, which makes this
3367 * padding safe without bounds checking.
3368 */
3369 if (!buf_loaned) {
3370 /*
3371 * Set the size of each mblk in the chain until we've consumed
3372 * the specified length for all but the last one.
3373 */
3374 while ((mpsize = MBLKSIZE(mp)) < len) {
3375 ASSERT(mpsize % BYTES_PER_XDR_UNIT == 0);
3376 mp->b_wptr += mpsize;
3377 len -= mpsize;
3378 mp = mp->b_cont;
3379 ASSERT(mp != NULL);
3380 }
3381
3382 ASSERT(len + remainder <= mpsize);
3383 mp->b_wptr += len;
3384 for (i = 0; i < remainder; i++)
3385 *mp->b_wptr++ = '\0';
3386 return;
3387 }
3388
3389 /*
3390 * No remainder mblk required.
3391 */
3392 if (remainder == 0)
3393 return;
3394
3395 /*
3396 * Get to the last mblk in the chain.
3397 */
3398 while (mp->b_cont != NULL)
3399 mp = mp->b_cont;
3400
3401 /*
3402 * In case of copy-reduction mblks, the size of the mblks are fixed
3403 * and are of the size of the loaned buffers. Allocate a remainder
3404 * mblk and chain it to the data buffers. This is sub-optimal, but not
3405 * expected to happen commonly.
3406 */
3407 rmp = allocb_wait(remainder, BPRI_MED, STR_NOSIG, &alloc_err);
3408 ASSERT(rmp != NULL);
3409 ASSERT(alloc_err == 0);
3410
3411 for (i = 0; i < remainder; i++)
3412 *rmp->b_wptr++ = '\0';
3413
3414 rmp->b_datap->db_type = M_DATA;
3415 mp->b_cont = rmp;
3416 }