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) 1994, 2010, Oracle and/or its affiliates. All rights reserved.
23 */
24
25 /* Copyright (c) 1983, 1984, 1985, 1986, 1987, 1988, 1989 AT&T */
26 /* All Rights Reserved */
27
28 #include <sys/param.h>
29 #include <sys/types.h>
30 #include <sys/systm.h>
31 #include <sys/cred.h>
32 #include <sys/buf.h>
33 #include <sys/vfs.h>
34 #include <sys/vnode.h>
35 #include <sys/uio.h>
36 #include <sys/errno.h>
37 #include <sys/sysmacros.h>
38 #include <sys/statvfs.h>
39 #include <sys/kmem.h>
40 #include <sys/dirent.h>
41 #include <sys/cmn_err.h>
42 #include <sys/debug.h>
43 #include <sys/systeminfo.h>
44 #include <sys/flock.h>
45 #include <sys/nbmlock.h>
46 #include <sys/policy.h>
47 #include <sys/sdt.h>
48
49 #include <rpc/types.h>
50 #include <rpc/auth.h>
51 #include <rpc/svc.h>
52 #include <rpc/rpc_rdma.h>
53
54 #include <nfs/nfs.h>
55 #include <nfs/export.h>
56 #include <nfs/nfs_cmd.h>
57
58 #include <sys/strsubr.h>
59
60 #include <sys/tsol/label.h>
61 #include <sys/tsol/tndb.h>
62
63 #include <sys/zone.h>
64
65 #include <inet/ip.h>
66 #include <inet/ip6.h>
67
68 /*
69 * These are the interface routines for the server side of the
70 * Network File System. See the NFS version 3 protocol specification
71 * for a description of this interface.
72 */
73
74 #ifdef DEBUG
75 int rfs3_do_pre_op_attr = 1;
76 int rfs3_do_post_op_attr = 1;
77 int rfs3_do_post_op_fh3 = 1;
78 #endif
79
80 static writeverf3 write3verf;
81
82 static int sattr3_to_vattr(sattr3 *, struct vattr *);
83 static int vattr_to_fattr3(struct vattr *, fattr3 *);
84 static int vattr_to_wcc_attr(struct vattr *, wcc_attr *);
85 static void vattr_to_pre_op_attr(struct vattr *, pre_op_attr *);
86 static void vattr_to_wcc_data(struct vattr *, struct vattr *, wcc_data *);
87 static int rdma_setup_read_data3(READ3args *, READ3resok *);
88
89 extern int nfs_loaned_buffers;
90
91 u_longlong_t nfs3_srv_caller_id;
92
93 /* ARGSUSED */
94 void
95 rfs3_getattr(GETATTR3args *args, GETATTR3res *resp, struct exportinfo *exi,
96 struct svc_req *req, cred_t *cr)
97 {
98 int error;
99 vnode_t *vp;
100 struct vattr va;
101
102 vp = nfs3_fhtovp(&args->object, exi);
103
104 DTRACE_NFSV3_4(op__getattr__start, struct svc_req *, req,
105 cred_t *, cr, vnode_t *, vp, GETATTR3args *, args);
106
107 if (vp == NULL) {
108 error = ESTALE;
109 goto out;
110 }
111
112 va.va_mask = AT_ALL;
113 error = rfs4_delegated_getattr(vp, &va, 0, cr);
114
115 if (!error) {
116 /* Lie about the object type for a referral */
117 if (vn_is_nfs_reparse(vp, cr))
118 va.va_type = VLNK;
119
120 /* overflow error if time or size is out of range */
121 error = vattr_to_fattr3(&va, &resp->resok.obj_attributes);
122 if (error)
123 goto out;
124 resp->status = NFS3_OK;
125
126 DTRACE_NFSV3_4(op__getattr__done, struct svc_req *, req,
127 cred_t *, cr, vnode_t *, vp, GETATTR3res *, resp);
128
129 VN_RELE(vp);
130
131 return;
132 }
133
134 out:
135 if (curthread->t_flag & T_WOULDBLOCK) {
136 curthread->t_flag &= ~T_WOULDBLOCK;
137 resp->status = NFS3ERR_JUKEBOX;
138 } else
139 resp->status = puterrno3(error);
140
141 DTRACE_NFSV3_4(op__getattr__done, struct svc_req *, req,
142 cred_t *, cr, vnode_t *, vp, GETATTR3res *, resp);
143
144 if (vp != NULL)
145 VN_RELE(vp);
146 }
147
148 void *
149 rfs3_getattr_getfh(GETATTR3args *args)
150 {
151
152 return (&args->object);
153 }
154
155 void
156 rfs3_setattr(SETATTR3args *args, SETATTR3res *resp, struct exportinfo *exi,
157 struct svc_req *req, cred_t *cr)
158 {
159 int error;
160 vnode_t *vp;
161 struct vattr *bvap;
162 struct vattr bva;
163 struct vattr *avap;
164 struct vattr ava;
165 int flag;
166 int in_crit = 0;
167 struct flock64 bf;
168 caller_context_t ct;
169
170 bvap = NULL;
171 avap = NULL;
172
173 vp = nfs3_fhtovp(&args->object, exi);
174
175 DTRACE_NFSV3_4(op__setattr__start, struct svc_req *, req,
176 cred_t *, cr, vnode_t *, vp, SETATTR3args *, args);
177
178 if (vp == NULL) {
179 error = ESTALE;
180 goto out;
181 }
182
183 error = sattr3_to_vattr(&args->new_attributes, &ava);
184 if (error)
185 goto out;
186
187 if (is_system_labeled()) {
188 bslabel_t *clabel = req->rq_label;
189
190 ASSERT(clabel != NULL);
191 DTRACE_PROBE2(tx__rfs3__log__info__opsetattr__clabel, char *,
192 "got client label from request(1)", struct svc_req *, req);
193
194 if (!blequal(&l_admin_low->tsl_label, clabel)) {
195 if (!do_rfs_label_check(clabel, vp, EQUALITY_CHECK,
196 exi)) {
197 resp->status = NFS3ERR_ACCES;
198 goto out1;
199 }
200 }
201 }
202
203 /*
204 * We need to specially handle size changes because of
205 * possible conflicting NBMAND locks. Get into critical
206 * region before VOP_GETATTR, so the size attribute is
207 * valid when checking conflicts.
208 *
209 * Also, check to see if the v4 side of the server has
210 * delegated this file. If so, then we return JUKEBOX to
211 * allow the client to retrasmit its request.
212 */
213 if (vp->v_type == VREG && (ava.va_mask & AT_SIZE)) {
214 if (nbl_need_check(vp)) {
215 nbl_start_crit(vp, RW_READER);
216 in_crit = 1;
217 }
218 }
219
220 bva.va_mask = AT_ALL;
221 error = rfs4_delegated_getattr(vp, &bva, 0, cr);
222
223 /*
224 * If we can't get the attributes, then we can't do the
225 * right access checking. So, we'll fail the request.
226 */
227 if (error)
228 goto out;
229
230 #ifdef DEBUG
231 if (rfs3_do_pre_op_attr)
232 bvap = &bva;
233 #else
234 bvap = &bva;
235 #endif
236
237 if (rdonly(exi, req) || vn_is_readonly(vp)) {
238 resp->status = NFS3ERR_ROFS;
239 goto out1;
240 }
241
242 if (args->guard.check &&
243 (args->guard.obj_ctime.seconds != bva.va_ctime.tv_sec ||
244 args->guard.obj_ctime.nseconds != bva.va_ctime.tv_nsec)) {
245 resp->status = NFS3ERR_NOT_SYNC;
246 goto out1;
247 }
248
249 if (args->new_attributes.mtime.set_it == SET_TO_CLIENT_TIME)
250 flag = ATTR_UTIME;
251 else
252 flag = 0;
253
254 /*
255 * If the filesystem is exported with nosuid, then mask off
256 * the setuid and setgid bits.
257 */
258 if ((ava.va_mask & AT_MODE) && vp->v_type == VREG &&
259 (exi->exi_export.ex_flags & EX_NOSUID))
260 ava.va_mode &= ~(VSUID | VSGID);
261
262 ct.cc_sysid = 0;
263 ct.cc_pid = 0;
264 ct.cc_caller_id = nfs3_srv_caller_id;
265 ct.cc_flags = CC_DONTBLOCK;
266
267 /*
268 * We need to specially handle size changes because it is
269 * possible for the client to create a file with modes
270 * which indicate read-only, but with the file opened for
271 * writing. If the client then tries to set the size of
272 * the file, then the normal access checking done in
273 * VOP_SETATTR would prevent the client from doing so,
274 * although it should be legal for it to do so. To get
275 * around this, we do the access checking for ourselves
276 * and then use VOP_SPACE which doesn't do the access
277 * checking which VOP_SETATTR does. VOP_SPACE can only
278 * operate on VREG files, let VOP_SETATTR handle the other
279 * extremely rare cases.
280 * Also the client should not be allowed to change the
281 * size of the file if there is a conflicting non-blocking
282 * mandatory lock in the region the change.
283 */
284 if (vp->v_type == VREG && (ava.va_mask & AT_SIZE)) {
285 if (in_crit) {
286 u_offset_t offset;
287 ssize_t length;
288
289 if (ava.va_size < bva.va_size) {
290 offset = ava.va_size;
291 length = bva.va_size - ava.va_size;
292 } else {
293 offset = bva.va_size;
294 length = ava.va_size - bva.va_size;
295 }
296 if (nbl_conflict(vp, NBL_WRITE, offset, length, 0,
297 NULL)) {
298 error = EACCES;
299 goto out;
300 }
301 }
302
303 if (crgetuid(cr) == bva.va_uid && ava.va_size != bva.va_size) {
304 ava.va_mask &= ~AT_SIZE;
305 bf.l_type = F_WRLCK;
306 bf.l_whence = 0;
307 bf.l_start = (off64_t)ava.va_size;
308 bf.l_len = 0;
309 bf.l_sysid = 0;
310 bf.l_pid = 0;
311 error = VOP_SPACE(vp, F_FREESP, &bf, FWRITE,
312 (offset_t)ava.va_size, cr, &ct);
313 }
314 }
315
316 if (!error && ava.va_mask)
317 error = VOP_SETATTR(vp, &ava, flag, cr, &ct);
318
319 /* check if a monitor detected a delegation conflict */
320 if (error == EAGAIN && (ct.cc_flags & CC_WOULDBLOCK)) {
321 resp->status = NFS3ERR_JUKEBOX;
322 goto out1;
323 }
324
325 #ifdef DEBUG
326 if (rfs3_do_post_op_attr) {
327 ava.va_mask = AT_ALL;
328 avap = rfs4_delegated_getattr(vp, &ava, 0, cr) ? NULL : &ava;
329 } else
330 avap = NULL;
331 #else
332 ava.va_mask = AT_ALL;
333 avap = rfs4_delegated_getattr(vp, &ava, 0, cr) ? NULL : &ava;
334 #endif
335
336 /*
337 * Force modified metadata out to stable storage.
338 */
339 (void) VOP_FSYNC(vp, FNODSYNC, cr, &ct);
340
341 if (error)
342 goto out;
343
344 if (in_crit)
345 nbl_end_crit(vp);
346
347 resp->status = NFS3_OK;
348 vattr_to_wcc_data(bvap, avap, &resp->resok.obj_wcc);
349
350 DTRACE_NFSV3_4(op__setattr__done, struct svc_req *, req,
351 cred_t *, cr, vnode_t *, vp, SETATTR3res *, resp);
352
353 VN_RELE(vp);
354
355 return;
356
357 out:
358 if (curthread->t_flag & T_WOULDBLOCK) {
359 curthread->t_flag &= ~T_WOULDBLOCK;
360 resp->status = NFS3ERR_JUKEBOX;
361 } else
362 resp->status = puterrno3(error);
363 out1:
364 DTRACE_NFSV3_4(op__setattr__done, struct svc_req *, req,
365 cred_t *, cr, vnode_t *, vp, SETATTR3res *, resp);
366
367 if (vp != NULL) {
368 if (in_crit)
369 nbl_end_crit(vp);
370 VN_RELE(vp);
371 }
372 vattr_to_wcc_data(bvap, avap, &resp->resfail.obj_wcc);
373 }
374
375 void *
376 rfs3_setattr_getfh(SETATTR3args *args)
377 {
378
379 return (&args->object);
380 }
381
382 /* ARGSUSED */
383 void
384 rfs3_lookup(LOOKUP3args *args, LOOKUP3res *resp, struct exportinfo *exi,
385 struct svc_req *req, cred_t *cr)
386 {
387 int error;
388 vnode_t *vp;
389 vnode_t *dvp;
390 struct vattr *vap;
391 struct vattr va;
392 struct vattr *dvap;
393 struct vattr dva;
394 nfs_fh3 *fhp;
395 struct sec_ol sec = {0, 0};
396 bool_t publicfh_flag = FALSE, auth_weak = FALSE;
397 struct sockaddr *ca;
398 char *name = NULL;
399
400 dvap = NULL;
401
402 /*
403 * Allow lookups from the root - the default
404 * location of the public filehandle.
405 */
406 if (exi != NULL && (exi->exi_export.ex_flags & EX_PUBLIC)) {
407 dvp = rootdir;
408 VN_HOLD(dvp);
409
410 DTRACE_NFSV3_4(op__lookup__start, struct svc_req *, req,
411 cred_t *, cr, vnode_t *, dvp, LOOKUP3args *, args);
412 } else {
413 dvp = nfs3_fhtovp(&args->what.dir, exi);
414
415 DTRACE_NFSV3_4(op__lookup__start, struct svc_req *, req,
416 cred_t *, cr, vnode_t *, dvp, LOOKUP3args *, args);
417
418 if (dvp == NULL) {
419 error = ESTALE;
420 goto out;
421 }
422 }
423
424 #ifdef DEBUG
425 if (rfs3_do_pre_op_attr) {
426 dva.va_mask = AT_ALL;
427 dvap = VOP_GETATTR(dvp, &dva, 0, cr, NULL) ? NULL : &dva;
428 }
429 #else
430 dva.va_mask = AT_ALL;
431 dvap = VOP_GETATTR(dvp, &dva, 0, cr, NULL) ? NULL : &dva;
432 #endif
433
434 if (args->what.name == nfs3nametoolong) {
435 resp->status = NFS3ERR_NAMETOOLONG;
436 goto out1;
437 }
438
439 if (args->what.name == NULL || *(args->what.name) == '\0') {
440 resp->status = NFS3ERR_ACCES;
441 goto out1;
442 }
443
444 fhp = &args->what.dir;
445 if (strcmp(args->what.name, "..") == 0 &&
446 EQFID(&exi->exi_fid, FH3TOFIDP(fhp))) {
447 resp->status = NFS3ERR_NOENT;
448 goto out1;
449 }
450
451 ca = (struct sockaddr *)svc_getrpccaller(req->rq_xprt)->buf;
452 name = nfscmd_convname(ca, exi, args->what.name,
453 NFSCMD_CONV_INBOUND, MAXPATHLEN + 1);
454
455 if (name == NULL) {
456 resp->status = NFS3ERR_ACCES;
457 goto out1;
458 }
459
460 /*
461 * If the public filehandle is used then allow
462 * a multi-component lookup
463 */
464 if (PUBLIC_FH3(&args->what.dir)) {
465 publicfh_flag = TRUE;
466 error = rfs_publicfh_mclookup(name, dvp, cr, &vp,
467 &exi, &sec);
468 if (error && exi != NULL)
469 exi_rele(exi); /* See comment below Re: publicfh_flag */
470 /*
471 * Since WebNFS may bypass MOUNT, we need to ensure this
472 * request didn't come from an unlabeled admin_low client.
473 */
474 if (is_system_labeled() && error == 0) {
475 int addr_type;
476 void *ipaddr;
477 tsol_tpc_t *tp;
478
479 if (ca->sa_family == AF_INET) {
480 addr_type = IPV4_VERSION;
481 ipaddr = &((struct sockaddr_in *)ca)->sin_addr;
482 } else if (ca->sa_family == AF_INET6) {
483 addr_type = IPV6_VERSION;
484 ipaddr = &((struct sockaddr_in6 *)
485 ca)->sin6_addr;
486 }
487 tp = find_tpc(ipaddr, addr_type, B_FALSE);
488 if (tp == NULL || tp->tpc_tp.tp_doi !=
489 l_admin_low->tsl_doi || tp->tpc_tp.host_type !=
490 SUN_CIPSO) {
491 if (exi != NULL)
492 exi_rele(exi);
493 VN_RELE(vp);
494 resp->status = NFS3ERR_ACCES;
495 error = 1;
496 }
497 if (tp != NULL)
498 TPC_RELE(tp);
499 }
500 } else {
501 error = VOP_LOOKUP(dvp, name, &vp,
502 NULL, 0, NULL, cr, NULL, NULL, NULL);
503 }
504
505 if (name != args->what.name)
506 kmem_free(name, MAXPATHLEN + 1);
507
508 if (is_system_labeled() && error == 0) {
509 bslabel_t *clabel = req->rq_label;
510
511 ASSERT(clabel != NULL);
512 DTRACE_PROBE2(tx__rfs3__log__info__oplookup__clabel, char *,
513 "got client label from request(1)", struct svc_req *, req);
514
515 if (!blequal(&l_admin_low->tsl_label, clabel)) {
516 if (!do_rfs_label_check(clabel, dvp,
517 DOMINANCE_CHECK, exi)) {
518 if (publicfh_flag && exi != NULL)
519 exi_rele(exi);
520 VN_RELE(vp);
521 resp->status = NFS3ERR_ACCES;
522 error = 1;
523 }
524 }
525 }
526
527 #ifdef DEBUG
528 if (rfs3_do_post_op_attr) {
529 dva.va_mask = AT_ALL;
530 dvap = VOP_GETATTR(dvp, &dva, 0, cr, NULL) ? NULL : &dva;
531 } else
532 dvap = NULL;
533 #else
534 dva.va_mask = AT_ALL;
535 dvap = VOP_GETATTR(dvp, &dva, 0, cr, NULL) ? NULL : &dva;
536 #endif
537
538 if (error)
539 goto out;
540
541 if (sec.sec_flags & SEC_QUERY) {
542 error = makefh3_ol(&resp->resok.object, exi, sec.sec_index);
543 } else {
544 error = makefh3(&resp->resok.object, vp, exi);
545 if (!error && publicfh_flag && !chk_clnt_sec(exi, req))
546 auth_weak = TRUE;
547 }
548
549 if (error) {
550 VN_RELE(vp);
551 goto out;
552 }
553
554 /*
555 * If publicfh_flag is true then we have called rfs_publicfh_mclookup
556 * and have obtained a new exportinfo in exi which needs to be
557 * released. Note the the original exportinfo pointed to by exi
558 * will be released by the caller, common_dispatch.
559 */
560 if (publicfh_flag)
561 exi_rele(exi);
562
563 #ifdef DEBUG
564 if (rfs3_do_post_op_attr) {
565 va.va_mask = AT_ALL;
566 vap = rfs4_delegated_getattr(vp, &va, 0, cr) ? NULL : &va;
567 } else
568 vap = NULL;
569 #else
570 va.va_mask = AT_ALL;
571 vap = rfs4_delegated_getattr(vp, &va, 0, cr) ? NULL : &va;
572 #endif
573
574 VN_RELE(vp);
575
576 resp->status = NFS3_OK;
577 vattr_to_post_op_attr(vap, &resp->resok.obj_attributes);
578 vattr_to_post_op_attr(dvap, &resp->resok.dir_attributes);
579
580 /*
581 * If it's public fh, no 0x81, and client's flavor is
582 * invalid, set WebNFS status to WNFSERR_CLNT_FLAVOR now.
583 * Then set RPC status to AUTH_TOOWEAK in common_dispatch.
584 */
585 if (auth_weak)
586 resp->status = (enum nfsstat3)WNFSERR_CLNT_FLAVOR;
587
588 DTRACE_NFSV3_4(op__lookup__done, struct svc_req *, req,
589 cred_t *, cr, vnode_t *, dvp, LOOKUP3res *, resp);
590 VN_RELE(dvp);
591
592 return;
593
594 out:
595 if (curthread->t_flag & T_WOULDBLOCK) {
596 curthread->t_flag &= ~T_WOULDBLOCK;
597 resp->status = NFS3ERR_JUKEBOX;
598 } else
599 resp->status = puterrno3(error);
600 out1:
601 DTRACE_NFSV3_4(op__lookup__done, struct svc_req *, req,
602 cred_t *, cr, vnode_t *, dvp, LOOKUP3res *, resp);
603
604 if (dvp != NULL)
605 VN_RELE(dvp);
606 vattr_to_post_op_attr(dvap, &resp->resfail.dir_attributes);
607
608 }
609
610 void *
611 rfs3_lookup_getfh(LOOKUP3args *args)
612 {
613
614 return (&args->what.dir);
615 }
616
617 /* ARGSUSED */
618 void
619 rfs3_access(ACCESS3args *args, ACCESS3res *resp, struct exportinfo *exi,
620 struct svc_req *req, cred_t *cr)
621 {
622 int error;
623 vnode_t *vp;
624 struct vattr *vap;
625 struct vattr va;
626 int checkwriteperm;
627 boolean_t dominant_label = B_FALSE;
628 boolean_t equal_label = B_FALSE;
629 boolean_t admin_low_client;
630
631 vap = NULL;
632
633 vp = nfs3_fhtovp(&args->object, exi);
634
635 DTRACE_NFSV3_4(op__access__start, struct svc_req *, req,
636 cred_t *, cr, vnode_t *, vp, ACCESS3args *, args);
637
638 if (vp == NULL) {
639 error = ESTALE;
640 goto out;
641 }
642
643 /*
644 * If the file system is exported read only, it is not appropriate
645 * to check write permissions for regular files and directories.
646 * Special files are interpreted by the client, so the underlying
647 * permissions are sent back to the client for interpretation.
648 */
649 if (rdonly(exi, req) && (vp->v_type == VREG || vp->v_type == VDIR))
650 checkwriteperm = 0;
651 else
652 checkwriteperm = 1;
653
654 /*
655 * We need the mode so that we can correctly determine access
656 * permissions relative to a mandatory lock file. Access to
657 * mandatory lock files is denied on the server, so it might
658 * as well be reflected to the server during the open.
659 */
660 va.va_mask = AT_MODE;
661 error = VOP_GETATTR(vp, &va, 0, cr, NULL);
662 if (error)
663 goto out;
664
665 #ifdef DEBUG
666 if (rfs3_do_post_op_attr)
667 vap = &va;
668 #else
669 vap = &va;
670 #endif
671
672 resp->resok.access = 0;
673
674 if (is_system_labeled()) {
675 bslabel_t *clabel = req->rq_label;
676
677 ASSERT(clabel != NULL);
678 DTRACE_PROBE2(tx__rfs3__log__info__opaccess__clabel, char *,
679 "got client label from request(1)", struct svc_req *, req);
680
681 if (!blequal(&l_admin_low->tsl_label, clabel)) {
682 if ((equal_label = do_rfs_label_check(clabel, vp,
683 EQUALITY_CHECK, exi)) == B_FALSE) {
684 dominant_label = do_rfs_label_check(clabel,
685 vp, DOMINANCE_CHECK, exi);
686 } else
687 dominant_label = B_TRUE;
688 admin_low_client = B_FALSE;
689 } else
690 admin_low_client = B_TRUE;
691 }
692
693 if (args->access & ACCESS3_READ) {
694 error = VOP_ACCESS(vp, VREAD, 0, cr, NULL);
695 if (error) {
696 if (curthread->t_flag & T_WOULDBLOCK)
697 goto out;
698 } else if (!MANDLOCK(vp, va.va_mode) &&
699 (!is_system_labeled() || admin_low_client ||
700 dominant_label))
701 resp->resok.access |= ACCESS3_READ;
702 }
703 if ((args->access & ACCESS3_LOOKUP) && vp->v_type == VDIR) {
704 error = VOP_ACCESS(vp, VEXEC, 0, cr, NULL);
705 if (error) {
706 if (curthread->t_flag & T_WOULDBLOCK)
707 goto out;
708 } else if (!is_system_labeled() || admin_low_client ||
709 dominant_label)
710 resp->resok.access |= ACCESS3_LOOKUP;
711 }
712 if (checkwriteperm &&
713 (args->access & (ACCESS3_MODIFY|ACCESS3_EXTEND))) {
714 error = VOP_ACCESS(vp, VWRITE, 0, cr, NULL);
715 if (error) {
716 if (curthread->t_flag & T_WOULDBLOCK)
717 goto out;
718 } else if (!MANDLOCK(vp, va.va_mode) &&
719 (!is_system_labeled() || admin_low_client || equal_label)) {
720 resp->resok.access |=
721 (args->access & (ACCESS3_MODIFY|ACCESS3_EXTEND));
722 }
723 }
724 if (checkwriteperm &&
725 (args->access & ACCESS3_DELETE) && vp->v_type == VDIR) {
726 error = VOP_ACCESS(vp, VWRITE, 0, cr, NULL);
727 if (error) {
728 if (curthread->t_flag & T_WOULDBLOCK)
729 goto out;
730 } else if (!is_system_labeled() || admin_low_client ||
731 equal_label)
732 resp->resok.access |= ACCESS3_DELETE;
733 }
734 if (args->access & ACCESS3_EXECUTE) {
735 error = VOP_ACCESS(vp, VEXEC, 0, cr, NULL);
736 if (error) {
737 if (curthread->t_flag & T_WOULDBLOCK)
738 goto out;
739 } else if (!MANDLOCK(vp, va.va_mode) &&
740 (!is_system_labeled() || admin_low_client ||
741 dominant_label))
742 resp->resok.access |= ACCESS3_EXECUTE;
743 }
744
745 #ifdef DEBUG
746 if (rfs3_do_post_op_attr) {
747 va.va_mask = AT_ALL;
748 vap = rfs4_delegated_getattr(vp, &va, 0, cr) ? NULL : &va;
749 } else
750 vap = NULL;
751 #else
752 va.va_mask = AT_ALL;
753 vap = rfs4_delegated_getattr(vp, &va, 0, cr) ? NULL : &va;
754 #endif
755
756 resp->status = NFS3_OK;
757 vattr_to_post_op_attr(vap, &resp->resok.obj_attributes);
758
759 DTRACE_NFSV3_4(op__access__done, struct svc_req *, req,
760 cred_t *, cr, vnode_t *, vp, ACCESS3res *, resp);
761
762 VN_RELE(vp);
763
764 return;
765
766 out:
767 if (curthread->t_flag & T_WOULDBLOCK) {
768 curthread->t_flag &= ~T_WOULDBLOCK;
769 resp->status = NFS3ERR_JUKEBOX;
770 } else
771 resp->status = puterrno3(error);
772 DTRACE_NFSV3_4(op__access__done, struct svc_req *, req,
773 cred_t *, cr, vnode_t *, vp, ACCESS3res *, resp);
774 if (vp != NULL)
775 VN_RELE(vp);
776 vattr_to_post_op_attr(vap, &resp->resfail.obj_attributes);
777 }
778
779 void *
780 rfs3_access_getfh(ACCESS3args *args)
781 {
782
783 return (&args->object);
784 }
785
786 /* ARGSUSED */
787 void
788 rfs3_readlink(READLINK3args *args, READLINK3res *resp, struct exportinfo *exi,
789 struct svc_req *req, cred_t *cr)
790 {
791 int error;
792 vnode_t *vp;
793 struct vattr *vap;
794 struct vattr va;
795 struct iovec iov;
796 struct uio uio;
797 char *data;
798 struct sockaddr *ca;
799 char *name = NULL;
800 int is_referral = 0;
801
802 vap = NULL;
803
804 vp = nfs3_fhtovp(&args->symlink, exi);
805
806 DTRACE_NFSV3_4(op__readlink__start, struct svc_req *, req,
807 cred_t *, cr, vnode_t *, vp, READLINK3args *, args);
808
809 if (vp == NULL) {
810 error = ESTALE;
811 goto out;
812 }
813
814 va.va_mask = AT_ALL;
815 error = VOP_GETATTR(vp, &va, 0, cr, NULL);
816 if (error)
817 goto out;
818
819 #ifdef DEBUG
820 if (rfs3_do_post_op_attr)
821 vap = &va;
822 #else
823 vap = &va;
824 #endif
825
826 /* We lied about the object type for a referral */
827 if (vn_is_nfs_reparse(vp, cr))
828 is_referral = 1;
829
830 if (vp->v_type != VLNK && !is_referral) {
831 resp->status = NFS3ERR_INVAL;
832 goto out1;
833 }
834
835 if (MANDLOCK(vp, va.va_mode)) {
836 resp->status = NFS3ERR_ACCES;
837 goto out1;
838 }
839
840 if (is_system_labeled()) {
841 bslabel_t *clabel = req->rq_label;
842
843 ASSERT(clabel != NULL);
844 DTRACE_PROBE2(tx__rfs3__log__info__opreadlink__clabel, char *,
845 "got client label from request(1)", struct svc_req *, req);
846
847 if (!blequal(&l_admin_low->tsl_label, clabel)) {
848 if (!do_rfs_label_check(clabel, vp, DOMINANCE_CHECK,
849 exi)) {
850 resp->status = NFS3ERR_ACCES;
851 goto out1;
852 }
853 }
854 }
855
856 data = kmem_alloc(MAXPATHLEN + 1, KM_SLEEP);
857
858 if (is_referral) {
859 char *s;
860 size_t strsz;
861
862 /* Get an artificial symlink based on a referral */
863 s = build_symlink(vp, cr, &strsz);
864 global_svstat_ptr[3][NFS_REFERLINKS].value.ui64++;
865 DTRACE_PROBE2(nfs3serv__func__referral__reflink,
866 vnode_t *, vp, char *, s);
867 if (s == NULL)
868 error = EINVAL;
869 else {
870 error = 0;
871 (void) strlcpy(data, s, MAXPATHLEN + 1);
872 kmem_free(s, strsz);
873 }
874
875 } else {
876
877 iov.iov_base = data;
878 iov.iov_len = MAXPATHLEN;
879 uio.uio_iov = &iov;
880 uio.uio_iovcnt = 1;
881 uio.uio_segflg = UIO_SYSSPACE;
882 uio.uio_extflg = UIO_COPY_CACHED;
883 uio.uio_loffset = 0;
884 uio.uio_resid = MAXPATHLEN;
885
886 error = VOP_READLINK(vp, &uio, cr, NULL);
887
888 if (!error)
889 *(data + MAXPATHLEN - uio.uio_resid) = '\0';
890 }
891
892 #ifdef DEBUG
893 if (rfs3_do_post_op_attr) {
894 va.va_mask = AT_ALL;
895 vap = VOP_GETATTR(vp, &va, 0, cr, NULL) ? NULL : &va;
896 } else
897 vap = NULL;
898 #else
899 va.va_mask = AT_ALL;
900 vap = VOP_GETATTR(vp, &va, 0, cr, NULL) ? NULL : &va;
901 #endif
902 /* Lie about object type again just to be consistent */
903 if (is_referral && vap != NULL)
904 vap->va_type = VLNK;
905
906 #if 0 /* notyet */
907 /*
908 * Don't do this. It causes local disk writes when just
909 * reading the file and the overhead is deemed larger
910 * than the benefit.
911 */
912 /*
913 * Force modified metadata out to stable storage.
914 */
915 (void) VOP_FSYNC(vp, FNODSYNC, cr, NULL);
916 #endif
917
918 if (error) {
919 kmem_free(data, MAXPATHLEN + 1);
920 goto out;
921 }
922
923 ca = (struct sockaddr *)svc_getrpccaller(req->rq_xprt)->buf;
924 name = nfscmd_convname(ca, exi, data, NFSCMD_CONV_OUTBOUND,
925 MAXPATHLEN + 1);
926
927 if (name == NULL) {
928 /*
929 * Even though the conversion failed, we return
930 * something. We just don't translate it.
931 */
932 name = data;
933 }
934
935 resp->status = NFS3_OK;
936 vattr_to_post_op_attr(vap, &resp->resok.symlink_attributes);
937 resp->resok.data = name;
938
939 DTRACE_NFSV3_4(op__readlink__done, struct svc_req *, req,
940 cred_t *, cr, vnode_t *, vp, READLINK3res *, resp);
941 VN_RELE(vp);
942
943 if (name != data)
944 kmem_free(data, MAXPATHLEN + 1);
945
946 return;
947
948 out:
949 if (curthread->t_flag & T_WOULDBLOCK) {
950 curthread->t_flag &= ~T_WOULDBLOCK;
951 resp->status = NFS3ERR_JUKEBOX;
952 } else
953 resp->status = puterrno3(error);
954 out1:
955 DTRACE_NFSV3_4(op__readlink__done, struct svc_req *, req,
956 cred_t *, cr, vnode_t *, vp, READLINK3res *, resp);
957 if (vp != NULL)
958 VN_RELE(vp);
959 vattr_to_post_op_attr(vap, &resp->resfail.symlink_attributes);
960 }
961
962 void *
963 rfs3_readlink_getfh(READLINK3args *args)
964 {
965
966 return (&args->symlink);
967 }
968
969 void
970 rfs3_readlink_free(READLINK3res *resp)
971 {
972
973 if (resp->status == NFS3_OK)
974 kmem_free(resp->resok.data, MAXPATHLEN + 1);
975 }
976
977 /*
978 * Server routine to handle read
979 * May handle RDMA data as well as mblks
980 */
981 /* ARGSUSED */
982 void
983 rfs3_read(READ3args *args, READ3res *resp, struct exportinfo *exi,
984 struct svc_req *req, cred_t *cr)
985 {
986 int error;
987 vnode_t *vp;
988 struct vattr *vap;
989 struct vattr va;
990 struct iovec iov;
991 struct uio uio;
992 u_offset_t offset;
993 mblk_t *mp = NULL;
994 int alloc_err = 0;
995 int in_crit = 0;
996 int need_rwunlock = 0;
997 caller_context_t ct;
998 int rdma_used = 0;
999 int loaned_buffers;
1000 struct uio *uiop;
1001
1002 vap = NULL;
1003
1004 vp = nfs3_fhtovp(&args->file, exi);
1005
1006 DTRACE_NFSV3_4(op__read__start, struct svc_req *, req,
1007 cred_t *, cr, vnode_t *, vp, READ3args *, args);
1008
1009 if (vp == NULL) {
1010 error = ESTALE;
1011 goto out;
1012 }
1013
1014 if (args->wlist) {
1015 if (args->count > clist_len(args->wlist)) {
1016 error = EINVAL;
1017 goto out;
1018 }
1019 rdma_used = 1;
1020 }
1021
1022 /* use loaned buffers for TCP */
1023 loaned_buffers = (nfs_loaned_buffers && !rdma_used) ? 1 : 0;
1024
1025 if (is_system_labeled()) {
1026 bslabel_t *clabel = req->rq_label;
1027
1028 ASSERT(clabel != NULL);
1029 DTRACE_PROBE2(tx__rfs3__log__info__opread__clabel, char *,
1030 "got client label from request(1)", struct svc_req *, req);
1031
1032 if (!blequal(&l_admin_low->tsl_label, clabel)) {
1033 if (!do_rfs_label_check(clabel, vp, DOMINANCE_CHECK,
1034 exi)) {
1035 resp->status = NFS3ERR_ACCES;
1036 goto out1;
1037 }
1038 }
1039 }
1040
1041 ct.cc_sysid = 0;
1042 ct.cc_pid = 0;
1043 ct.cc_caller_id = nfs3_srv_caller_id;
1044 ct.cc_flags = CC_DONTBLOCK;
1045
1046 /*
1047 * Enter the critical region before calling VOP_RWLOCK
1048 * to avoid a deadlock with write requests.
1049 */
1050 if (nbl_need_check(vp)) {
1051 nbl_start_crit(vp, RW_READER);
1052 in_crit = 1;
1053 if (nbl_conflict(vp, NBL_READ, args->offset, args->count, 0,
1054 NULL)) {
1055 error = EACCES;
1056 goto out;
1057 }
1058 }
1059
1060 error = VOP_RWLOCK(vp, V_WRITELOCK_FALSE, &ct);
1061
1062 /* check if a monitor detected a delegation conflict */
1063 if (error == EAGAIN && (ct.cc_flags & CC_WOULDBLOCK)) {
1064 resp->status = NFS3ERR_JUKEBOX;
1065 goto out1;
1066 }
1067
1068 need_rwunlock = 1;
1069
1070 va.va_mask = AT_ALL;
1071 error = VOP_GETATTR(vp, &va, 0, cr, &ct);
1072
1073 /*
1074 * If we can't get the attributes, then we can't do the
1075 * right access checking. So, we'll fail the request.
1076 */
1077 if (error)
1078 goto out;
1079
1080 #ifdef DEBUG
1081 if (rfs3_do_post_op_attr)
1082 vap = &va;
1083 #else
1084 vap = &va;
1085 #endif
1086
1087 if (vp->v_type != VREG) {
1088 resp->status = NFS3ERR_INVAL;
1089 goto out1;
1090 }
1091
1092 if (crgetuid(cr) != va.va_uid) {
1093 error = VOP_ACCESS(vp, VREAD, 0, cr, &ct);
1094 if (error) {
1095 if (curthread->t_flag & T_WOULDBLOCK)
1096 goto out;
1097 error = VOP_ACCESS(vp, VEXEC, 0, cr, &ct);
1098 if (error)
1099 goto out;
1100 }
1101 }
1102
1103 if (MANDLOCK(vp, va.va_mode)) {
1104 resp->status = NFS3ERR_ACCES;
1105 goto out1;
1106 }
1107
1108 offset = args->offset;
1109 if (offset >= va.va_size) {
1110 VOP_RWUNLOCK(vp, V_WRITELOCK_FALSE, &ct);
1111 if (in_crit)
1112 nbl_end_crit(vp);
1113 resp->status = NFS3_OK;
1114 vattr_to_post_op_attr(vap, &resp->resok.file_attributes);
1115 resp->resok.count = 0;
1116 resp->resok.eof = TRUE;
1117 resp->resok.data.data_len = 0;
1118 resp->resok.data.data_val = NULL;
1119 resp->resok.data.mp = NULL;
1120 /* RDMA */
1121 resp->resok.wlist = args->wlist;
1122 resp->resok.wlist_len = resp->resok.count;
1123 if (resp->resok.wlist)
1124 clist_zero_len(resp->resok.wlist);
1125 goto done;
1126 }
1127
1128 if (args->count == 0) {
1129 VOP_RWUNLOCK(vp, V_WRITELOCK_FALSE, &ct);
1130 if (in_crit)
1131 nbl_end_crit(vp);
1132 resp->status = NFS3_OK;
1133 vattr_to_post_op_attr(vap, &resp->resok.file_attributes);
1134 resp->resok.count = 0;
1135 resp->resok.eof = FALSE;
1136 resp->resok.data.data_len = 0;
1137 resp->resok.data.data_val = NULL;
1138 resp->resok.data.mp = NULL;
1139 /* RDMA */
1140 resp->resok.wlist = args->wlist;
1141 resp->resok.wlist_len = resp->resok.count;
1142 if (resp->resok.wlist)
1143 clist_zero_len(resp->resok.wlist);
1144 goto done;
1145 }
1146
1147 /*
1148 * do not allocate memory more the max. allowed
1149 * transfer size
1150 */
1151 if (args->count > rfs3_tsize(req))
1152 args->count = rfs3_tsize(req);
1153
1154 if (loaned_buffers) {
1155 uiop = (uio_t *)rfs_setup_xuio(vp);
1156 ASSERT(uiop != NULL);
1157 uiop->uio_segflg = UIO_SYSSPACE;
1158 uiop->uio_loffset = args->offset;
1159 uiop->uio_resid = args->count;
1160
1161 /* Jump to do the read if successful */
1162 if (VOP_REQZCBUF(vp, UIO_READ, (xuio_t *)uiop, cr, &ct) == 0) {
1163 /*
1164 * Need to hold the vnode until after VOP_RETZCBUF()
1165 * is called.
1166 */
1167 VN_HOLD(vp);
1168 goto doio_read;
1169 }
1170
1171 DTRACE_PROBE2(nfss__i__reqzcbuf_failed, int,
1172 uiop->uio_loffset, int, uiop->uio_resid);
1173
1174 uiop->uio_extflg = 0;
1175 /* failure to setup for zero copy */
1176 rfs_free_xuio((void *)uiop);
1177 loaned_buffers = 0;
1178 }
1179
1180 /*
1181 * If returning data via RDMA Write, then grab the chunk list.
1182 * If we aren't returning READ data w/RDMA_WRITE, then grab
1183 * a mblk.
1184 */
1185 if (rdma_used) {
1186 (void) rdma_get_wchunk(req, &iov, args->wlist);
1187 } else {
1188 /*
1189 * mp will contain the data to be sent out in the read reply.
1190 * This will be freed after the reply has been sent out (by the
1191 * driver).
1192 * Let's roundup the data to a BYTES_PER_XDR_UNIT multiple, so
1193 * that the call to xdrmblk_putmblk() never fails.
1194 */
1195 mp = allocb_wait(RNDUP(args->count), BPRI_MED, STR_NOSIG,
1196 &alloc_err);
1197 ASSERT(mp != NULL);
1198 ASSERT(alloc_err == 0);
1199
1200 iov.iov_base = (caddr_t)mp->b_datap->db_base;
1201 iov.iov_len = args->count;
1202 }
1203
1204 uio.uio_iov = &iov;
1205 uio.uio_iovcnt = 1;
1206 uio.uio_segflg = UIO_SYSSPACE;
1207 uio.uio_extflg = UIO_COPY_CACHED;
1208 uio.uio_loffset = args->offset;
1209 uio.uio_resid = args->count;
1210 uiop = &uio;
1211
1212 doio_read:
1213 error = VOP_READ(vp, uiop, 0, cr, &ct);
1214
1215 if (error) {
1216 if (mp)
1217 freemsg(mp);
1218 /* check if a monitor detected a delegation conflict */
1219 if (error == EAGAIN && (ct.cc_flags & CC_WOULDBLOCK)) {
1220 resp->status = NFS3ERR_JUKEBOX;
1221 goto out1;
1222 }
1223 goto out;
1224 }
1225
1226 /* make mblk using zc buffers */
1227 if (loaned_buffers) {
1228 mp = uio_to_mblk(uiop);
1229 ASSERT(mp != NULL);
1230 }
1231
1232 va.va_mask = AT_ALL;
1233 error = VOP_GETATTR(vp, &va, 0, cr, &ct);
1234
1235 #ifdef DEBUG
1236 if (rfs3_do_post_op_attr) {
1237 if (error)
1238 vap = NULL;
1239 else
1240 vap = &va;
1241 } else
1242 vap = NULL;
1243 #else
1244 if (error)
1245 vap = NULL;
1246 else
1247 vap = &va;
1248 #endif
1249
1250 VOP_RWUNLOCK(vp, V_WRITELOCK_FALSE, &ct);
1251
1252 if (in_crit)
1253 nbl_end_crit(vp);
1254
1255 resp->status = NFS3_OK;
1256 vattr_to_post_op_attr(vap, &resp->resok.file_attributes);
1257 resp->resok.count = args->count - uiop->uio_resid;
1258 if (!error && offset + resp->resok.count == va.va_size)
1259 resp->resok.eof = TRUE;
1260 else
1261 resp->resok.eof = FALSE;
1262 resp->resok.data.data_len = resp->resok.count;
1263
1264 if (mp)
1265 rfs_rndup_mblks(mp, resp->resok.count, loaned_buffers);
1266
1267 resp->resok.data.mp = mp;
1268 resp->resok.size = (uint_t)args->count;
1269
1270 if (rdma_used) {
1271 resp->resok.data.data_val = (caddr_t)iov.iov_base;
1272 if (!rdma_setup_read_data3(args, &(resp->resok))) {
1273 resp->status = NFS3ERR_INVAL;
1274 }
1275 } else {
1276 resp->resok.data.data_val = (caddr_t)mp->b_datap->db_base;
1277 (resp->resok).wlist = NULL;
1278 }
1279
1280 done:
1281 DTRACE_NFSV3_4(op__read__done, struct svc_req *, req,
1282 cred_t *, cr, vnode_t *, vp, READ3res *, resp);
1283
1284 VN_RELE(vp);
1285
1286 return;
1287
1288 out:
1289 if (curthread->t_flag & T_WOULDBLOCK) {
1290 curthread->t_flag &= ~T_WOULDBLOCK;
1291 resp->status = NFS3ERR_JUKEBOX;
1292 } else
1293 resp->status = puterrno3(error);
1294 out1:
1295 DTRACE_NFSV3_4(op__read__done, struct svc_req *, req,
1296 cred_t *, cr, vnode_t *, vp, READ3res *, resp);
1297
1298 if (vp != NULL) {
1299 if (need_rwunlock)
1300 VOP_RWUNLOCK(vp, V_WRITELOCK_FALSE, &ct);
1301 if (in_crit)
1302 nbl_end_crit(vp);
1303 VN_RELE(vp);
1304 }
1305 vattr_to_post_op_attr(vap, &resp->resfail.file_attributes);
1306 }
1307
1308 void
1309 rfs3_read_free(READ3res *resp)
1310 {
1311 mblk_t *mp;
1312
1313 if (resp->status == NFS3_OK) {
1314 mp = resp->resok.data.mp;
1315 if (mp != NULL)
1316 freemsg(mp);
1317 }
1318 }
1319
1320 void *
1321 rfs3_read_getfh(READ3args *args)
1322 {
1323
1324 return (&args->file);
1325 }
1326
1327 #define MAX_IOVECS 12
1328
1329 #ifdef DEBUG
1330 static int rfs3_write_hits = 0;
1331 static int rfs3_write_misses = 0;
1332 #endif
1333
1334 void
1335 rfs3_write(WRITE3args *args, WRITE3res *resp, struct exportinfo *exi,
1336 struct svc_req *req, cred_t *cr)
1337 {
1338 int error;
1339 vnode_t *vp;
1340 struct vattr *bvap = NULL;
1341 struct vattr bva;
1342 struct vattr *avap = NULL;
1343 struct vattr ava;
1344 u_offset_t rlimit;
1345 struct uio uio;
1346 struct iovec iov[MAX_IOVECS];
1347 mblk_t *m;
1348 struct iovec *iovp;
1349 int iovcnt;
1350 int ioflag;
1351 cred_t *savecred;
1352 int in_crit = 0;
1353 int rwlock_ret = -1;
1354 caller_context_t ct;
1355
1356 vp = nfs3_fhtovp(&args->file, exi);
1357
1358 DTRACE_NFSV3_4(op__write__start, struct svc_req *, req,
1359 cred_t *, cr, vnode_t *, vp, WRITE3args *, args);
1360
1361 if (vp == NULL) {
1362 error = ESTALE;
1363 goto err;
1364 }
1365
1366 if (is_system_labeled()) {
1367 bslabel_t *clabel = req->rq_label;
1368
1369 ASSERT(clabel != NULL);
1370 DTRACE_PROBE2(tx__rfs3__log__info__opwrite__clabel, char *,
1371 "got client label from request(1)", struct svc_req *, req);
1372
1373 if (!blequal(&l_admin_low->tsl_label, clabel)) {
1374 if (!do_rfs_label_check(clabel, vp, EQUALITY_CHECK,
1375 exi)) {
1376 resp->status = NFS3ERR_ACCES;
1377 goto err1;
1378 }
1379 }
1380 }
1381
1382 ct.cc_sysid = 0;
1383 ct.cc_pid = 0;
1384 ct.cc_caller_id = nfs3_srv_caller_id;
1385 ct.cc_flags = CC_DONTBLOCK;
1386
1387 /*
1388 * We have to enter the critical region before calling VOP_RWLOCK
1389 * to avoid a deadlock with ufs.
1390 */
1391 if (nbl_need_check(vp)) {
1392 nbl_start_crit(vp, RW_READER);
1393 in_crit = 1;
1394 if (nbl_conflict(vp, NBL_WRITE, args->offset, args->count, 0,
1395 NULL)) {
1396 error = EACCES;
1397 goto err;
1398 }
1399 }
1400
1401 rwlock_ret = VOP_RWLOCK(vp, V_WRITELOCK_TRUE, &ct);
1402
1403 /* check if a monitor detected a delegation conflict */
1404 if (rwlock_ret == EAGAIN && (ct.cc_flags & CC_WOULDBLOCK)) {
1405 resp->status = NFS3ERR_JUKEBOX;
1406 rwlock_ret = -1;
1407 goto err1;
1408 }
1409
1410
1411 bva.va_mask = AT_ALL;
1412 error = VOP_GETATTR(vp, &bva, 0, cr, &ct);
1413
1414 /*
1415 * If we can't get the attributes, then we can't do the
1416 * right access checking. So, we'll fail the request.
1417 */
1418 if (error)
1419 goto err;
1420
1421 bvap = &bva;
1422 #ifdef DEBUG
1423 if (!rfs3_do_pre_op_attr)
1424 bvap = NULL;
1425 #endif
1426 avap = bvap;
1427
1428 if (args->count != args->data.data_len) {
1429 resp->status = NFS3ERR_INVAL;
1430 goto err1;
1431 }
1432
1433 if (rdonly(exi, req)) {
1434 resp->status = NFS3ERR_ROFS;
1435 goto err1;
1436 }
1437
1438 if (vp->v_type != VREG) {
1439 resp->status = NFS3ERR_INVAL;
1440 goto err1;
1441 }
1442
1443 if (crgetuid(cr) != bva.va_uid &&
1444 (error = VOP_ACCESS(vp, VWRITE, 0, cr, &ct)))
1445 goto err;
1446
1447 if (MANDLOCK(vp, bva.va_mode)) {
1448 resp->status = NFS3ERR_ACCES;
1449 goto err1;
1450 }
1451
1452 if (args->count == 0) {
1453 resp->status = NFS3_OK;
1454 vattr_to_wcc_data(bvap, avap, &resp->resok.file_wcc);
1455 resp->resok.count = 0;
1456 resp->resok.committed = args->stable;
1457 resp->resok.verf = write3verf;
1458 goto out;
1459 }
1460
1461 if (args->mblk != NULL) {
1462 iovcnt = 0;
1463 for (m = args->mblk; m != NULL; m = m->b_cont)
1464 iovcnt++;
1465 if (iovcnt <= MAX_IOVECS) {
1466 #ifdef DEBUG
1467 rfs3_write_hits++;
1468 #endif
1469 iovp = iov;
1470 } else {
1471 #ifdef DEBUG
1472 rfs3_write_misses++;
1473 #endif
1474 iovp = kmem_alloc(sizeof (*iovp) * iovcnt, KM_SLEEP);
1475 }
1476 mblk_to_iov(args->mblk, iovcnt, iovp);
1477
1478 } else if (args->rlist != NULL) {
1479 iovcnt = 1;
1480 iovp = iov;
1481 iovp->iov_base = (char *)((args->rlist)->u.c_daddr3);
1482 iovp->iov_len = args->count;
1483 } else {
1484 iovcnt = 1;
1485 iovp = iov;
1486 iovp->iov_base = args->data.data_val;
1487 iovp->iov_len = args->count;
1488 }
1489
1490 uio.uio_iov = iovp;
1491 uio.uio_iovcnt = iovcnt;
1492
1493 uio.uio_segflg = UIO_SYSSPACE;
1494 uio.uio_extflg = UIO_COPY_DEFAULT;
1495 uio.uio_loffset = args->offset;
1496 uio.uio_resid = args->count;
1497 uio.uio_llimit = curproc->p_fsz_ctl;
1498 rlimit = uio.uio_llimit - args->offset;
1499 if (rlimit < (u_offset_t)uio.uio_resid)
1500 uio.uio_resid = (int)rlimit;
1501
1502 if (args->stable == UNSTABLE)
1503 ioflag = 0;
1504 else if (args->stable == FILE_SYNC)
1505 ioflag = FSYNC;
1506 else if (args->stable == DATA_SYNC)
1507 ioflag = FDSYNC;
1508 else {
1509 if (iovp != iov)
1510 kmem_free(iovp, sizeof (*iovp) * iovcnt);
1511 resp->status = NFS3ERR_INVAL;
1512 goto err1;
1513 }
1514
1515 /*
1516 * We're changing creds because VM may fault and we need
1517 * the cred of the current thread to be used if quota
1518 * checking is enabled.
1519 */
1520 savecred = curthread->t_cred;
1521 curthread->t_cred = cr;
1522 error = VOP_WRITE(vp, &uio, ioflag, cr, &ct);
1523 curthread->t_cred = savecred;
1524
1525 if (iovp != iov)
1526 kmem_free(iovp, sizeof (*iovp) * iovcnt);
1527
1528 /* check if a monitor detected a delegation conflict */
1529 if (error == EAGAIN && (ct.cc_flags & CC_WOULDBLOCK)) {
1530 resp->status = NFS3ERR_JUKEBOX;
1531 goto err1;
1532 }
1533
1534 ava.va_mask = AT_ALL;
1535 avap = VOP_GETATTR(vp, &ava, 0, cr, &ct) ? NULL : &ava;
1536
1537 #ifdef DEBUG
1538 if (!rfs3_do_post_op_attr)
1539 avap = NULL;
1540 #endif
1541
1542 if (error)
1543 goto err;
1544
1545 /*
1546 * If we were unable to get the V_WRITELOCK_TRUE, then we
1547 * may not have accurate after attrs, so check if
1548 * we have both attributes, they have a non-zero va_seq, and
1549 * va_seq has changed by exactly one,
1550 * if not, turn off the before attr.
1551 */
1552 if (rwlock_ret != V_WRITELOCK_TRUE) {
1553 if (bvap == NULL || avap == NULL ||
1554 bvap->va_seq == 0 || avap->va_seq == 0 ||
1555 avap->va_seq != (bvap->va_seq + 1)) {
1556 bvap = NULL;
1557 }
1558 }
1559
1560 resp->status = NFS3_OK;
1561 vattr_to_wcc_data(bvap, avap, &resp->resok.file_wcc);
1562 resp->resok.count = args->count - uio.uio_resid;
1563 resp->resok.committed = args->stable;
1564 resp->resok.verf = write3verf;
1565 goto out;
1566
1567 err:
1568 if (curthread->t_flag & T_WOULDBLOCK) {
1569 curthread->t_flag &= ~T_WOULDBLOCK;
1570 resp->status = NFS3ERR_JUKEBOX;
1571 } else
1572 resp->status = puterrno3(error);
1573 err1:
1574 vattr_to_wcc_data(bvap, avap, &resp->resfail.file_wcc);
1575 out:
1576 DTRACE_NFSV3_4(op__write__done, struct svc_req *, req,
1577 cred_t *, cr, vnode_t *, vp, WRITE3res *, resp);
1578
1579 if (vp != NULL) {
1580 if (rwlock_ret != -1)
1581 VOP_RWUNLOCK(vp, V_WRITELOCK_TRUE, &ct);
1582 if (in_crit)
1583 nbl_end_crit(vp);
1584 VN_RELE(vp);
1585 }
1586 }
1587
1588 void *
1589 rfs3_write_getfh(WRITE3args *args)
1590 {
1591
1592 return (&args->file);
1593 }
1594
1595 void
1596 rfs3_create(CREATE3args *args, CREATE3res *resp, struct exportinfo *exi,
1597 struct svc_req *req, cred_t *cr)
1598 {
1599 int error;
1600 int in_crit = 0;
1601 vnode_t *vp;
1602 vnode_t *tvp = NULL;
1603 vnode_t *dvp;
1604 struct vattr *vap;
1605 struct vattr va;
1606 struct vattr *dbvap;
1607 struct vattr dbva;
1608 struct vattr *davap;
1609 struct vattr dava;
1610 enum vcexcl excl;
1611 nfstime3 *mtime;
1612 len_t reqsize;
1613 bool_t trunc;
1614 struct sockaddr *ca;
1615 char *name = NULL;
1616
1617 dbvap = NULL;
1618 davap = NULL;
1619
1620 dvp = nfs3_fhtovp(&args->where.dir, exi);
1621
1622 DTRACE_NFSV3_4(op__create__start, struct svc_req *, req,
1623 cred_t *, cr, vnode_t *, dvp, CREATE3args *, args);
1624
1625 if (dvp == NULL) {
1626 error = ESTALE;
1627 goto out;
1628 }
1629
1630 #ifdef DEBUG
1631 if (rfs3_do_pre_op_attr) {
1632 dbva.va_mask = AT_ALL;
1633 dbvap = VOP_GETATTR(dvp, &dbva, 0, cr, NULL) ? NULL : &dbva;
1634 } else
1635 dbvap = NULL;
1636 #else
1637 dbva.va_mask = AT_ALL;
1638 dbvap = VOP_GETATTR(dvp, &dbva, 0, cr, NULL) ? NULL : &dbva;
1639 #endif
1640 davap = dbvap;
1641
1642 if (args->where.name == nfs3nametoolong) {
1643 resp->status = NFS3ERR_NAMETOOLONG;
1644 goto out1;
1645 }
1646
1647 if (args->where.name == NULL || *(args->where.name) == '\0') {
1648 resp->status = NFS3ERR_ACCES;
1649 goto out1;
1650 }
1651
1652 if (rdonly(exi, req)) {
1653 resp->status = NFS3ERR_ROFS;
1654 goto out1;
1655 }
1656
1657 if (is_system_labeled()) {
1658 bslabel_t *clabel = req->rq_label;
1659
1660 ASSERT(clabel != NULL);
1661 DTRACE_PROBE2(tx__rfs3__log__info__opcreate__clabel, char *,
1662 "got client label from request(1)", struct svc_req *, req);
1663
1664 if (!blequal(&l_admin_low->tsl_label, clabel)) {
1665 if (!do_rfs_label_check(clabel, dvp, EQUALITY_CHECK,
1666 exi)) {
1667 resp->status = NFS3ERR_ACCES;
1668 goto out1;
1669 }
1670 }
1671 }
1672
1673 ca = (struct sockaddr *)svc_getrpccaller(req->rq_xprt)->buf;
1674 name = nfscmd_convname(ca, exi, args->where.name,
1675 NFSCMD_CONV_INBOUND, MAXPATHLEN + 1);
1676
1677 if (name == NULL) {
1678 /* This is really a Solaris EILSEQ */
1679 resp->status = NFS3ERR_INVAL;
1680 goto out1;
1681 }
1682
1683 if (args->how.mode == EXCLUSIVE) {
1684 va.va_mask = AT_TYPE | AT_MODE | AT_MTIME;
1685 va.va_type = VREG;
1686 va.va_mode = (mode_t)0;
1687 /*
1688 * Ensure no time overflows and that types match
1689 */
1690 mtime = (nfstime3 *)&args->how.createhow3_u.verf;
1691 va.va_mtime.tv_sec = mtime->seconds % INT32_MAX;
1692 va.va_mtime.tv_nsec = mtime->nseconds;
1693 excl = EXCL;
1694 } else {
1695 error = sattr3_to_vattr(&args->how.createhow3_u.obj_attributes,
1696 &va);
1697 if (error)
1698 goto out;
1699 va.va_mask |= AT_TYPE;
1700 va.va_type = VREG;
1701 if (args->how.mode == GUARDED)
1702 excl = EXCL;
1703 else {
1704 excl = NONEXCL;
1705
1706 /*
1707 * During creation of file in non-exclusive mode
1708 * if size of file is being set then make sure
1709 * that if the file already exists that no conflicting
1710 * non-blocking mandatory locks exists in the region
1711 * being modified. If there are conflicting locks fail
1712 * the operation with EACCES.
1713 */
1714 if (va.va_mask & AT_SIZE) {
1715 struct vattr tva;
1716
1717 /*
1718 * Does file already exist?
1719 */
1720 error = VOP_LOOKUP(dvp, name, &tvp,
1721 NULL, 0, NULL, cr, NULL, NULL, NULL);
1722
1723 /*
1724 * Check to see if the file has been delegated
1725 * to a v4 client. If so, then begin recall of
1726 * the delegation and return JUKEBOX to allow
1727 * the client to retrasmit its request.
1728 */
1729
1730 trunc = va.va_size == 0;
1731 if (!error &&
1732 rfs4_check_delegated(FWRITE, tvp, trunc)) {
1733 resp->status = NFS3ERR_JUKEBOX;
1734 goto out1;
1735 }
1736
1737 /*
1738 * Check for NBMAND lock conflicts
1739 */
1740 if (!error && nbl_need_check(tvp)) {
1741 u_offset_t offset;
1742 ssize_t len;
1743
1744 nbl_start_crit(tvp, RW_READER);
1745 in_crit = 1;
1746
1747 tva.va_mask = AT_SIZE;
1748 error = VOP_GETATTR(tvp, &tva, 0, cr,
1749 NULL);
1750 /*
1751 * Can't check for conflicts, so return
1752 * error.
1753 */
1754 if (error)
1755 goto out;
1756
1757 offset = tva.va_size < va.va_size ?
1758 tva.va_size : va.va_size;
1759 len = tva.va_size < va.va_size ?
1760 va.va_size - tva.va_size :
1761 tva.va_size - va.va_size;
1762 if (nbl_conflict(tvp, NBL_WRITE,
1763 offset, len, 0, NULL)) {
1764 error = EACCES;
1765 goto out;
1766 }
1767 } else if (tvp) {
1768 VN_RELE(tvp);
1769 tvp = NULL;
1770 }
1771 }
1772 }
1773 if (va.va_mask & AT_SIZE)
1774 reqsize = va.va_size;
1775 }
1776
1777 /*
1778 * Must specify the mode.
1779 */
1780 if (!(va.va_mask & AT_MODE)) {
1781 resp->status = NFS3ERR_INVAL;
1782 goto out1;
1783 }
1784
1785 /*
1786 * If the filesystem is exported with nosuid, then mask off
1787 * the setuid and setgid bits.
1788 */
1789 if (va.va_type == VREG && (exi->exi_export.ex_flags & EX_NOSUID))
1790 va.va_mode &= ~(VSUID | VSGID);
1791
1792 tryagain:
1793 /*
1794 * The file open mode used is VWRITE. If the client needs
1795 * some other semantic, then it should do the access checking
1796 * itself. It would have been nice to have the file open mode
1797 * passed as part of the arguments.
1798 */
1799 error = VOP_CREATE(dvp, name, &va, excl, VWRITE,
1800 &vp, cr, 0, NULL, NULL);
1801
1802 #ifdef DEBUG
1803 if (rfs3_do_post_op_attr) {
1804 dava.va_mask = AT_ALL;
1805 davap = VOP_GETATTR(dvp, &dava, 0, cr, NULL) ? NULL : &dava;
1806 } else
1807 davap = NULL;
1808 #else
1809 dava.va_mask = AT_ALL;
1810 davap = VOP_GETATTR(dvp, &dava, 0, cr, NULL) ? NULL : &dava;
1811 #endif
1812
1813 if (error) {
1814 /*
1815 * If we got something other than file already exists
1816 * then just return this error. Otherwise, we got
1817 * EEXIST. If we were doing a GUARDED create, then
1818 * just return this error. Otherwise, we need to
1819 * make sure that this wasn't a duplicate of an
1820 * exclusive create request.
1821 *
1822 * The assumption is made that a non-exclusive create
1823 * request will never return EEXIST.
1824 */
1825 if (error != EEXIST || args->how.mode == GUARDED)
1826 goto out;
1827 /*
1828 * Lookup the file so that we can get a vnode for it.
1829 */
1830 error = VOP_LOOKUP(dvp, name, &vp, NULL, 0,
1831 NULL, cr, NULL, NULL, NULL);
1832 if (error) {
1833 /*
1834 * We couldn't find the file that we thought that
1835 * we just created. So, we'll just try creating
1836 * it again.
1837 */
1838 if (error == ENOENT)
1839 goto tryagain;
1840 goto out;
1841 }
1842
1843 /*
1844 * If the file is delegated to a v4 client, go ahead
1845 * and initiate recall, this create is a hint that a
1846 * conflicting v3 open has occurred.
1847 */
1848
1849 if (rfs4_check_delegated(FWRITE, vp, FALSE)) {
1850 VN_RELE(vp);
1851 resp->status = NFS3ERR_JUKEBOX;
1852 goto out1;
1853 }
1854
1855 va.va_mask = AT_ALL;
1856 vap = VOP_GETATTR(vp, &va, 0, cr, NULL) ? NULL : &va;
1857
1858 mtime = (nfstime3 *)&args->how.createhow3_u.verf;
1859 /* % with INT32_MAX to prevent overflows */
1860 if (args->how.mode == EXCLUSIVE && (vap == NULL ||
1861 vap->va_mtime.tv_sec !=
1862 (mtime->seconds % INT32_MAX) ||
1863 vap->va_mtime.tv_nsec != mtime->nseconds)) {
1864 VN_RELE(vp);
1865 error = EEXIST;
1866 goto out;
1867 }
1868 } else {
1869
1870 if ((args->how.mode == UNCHECKED ||
1871 args->how.mode == GUARDED) &&
1872 args->how.createhow3_u.obj_attributes.size.set_it &&
1873 va.va_size == 0)
1874 trunc = TRUE;
1875 else
1876 trunc = FALSE;
1877
1878 if (rfs4_check_delegated(FWRITE, vp, trunc)) {
1879 VN_RELE(vp);
1880 resp->status = NFS3ERR_JUKEBOX;
1881 goto out1;
1882 }
1883
1884 va.va_mask = AT_ALL;
1885 vap = VOP_GETATTR(vp, &va, 0, cr, NULL) ? NULL : &va;
1886
1887 /*
1888 * We need to check to make sure that the file got
1889 * created to the indicated size. If not, we do a
1890 * setattr to try to change the size, but we don't
1891 * try too hard. This shouldn't a problem as most
1892 * clients will only specifiy a size of zero which
1893 * local file systems handle. However, even if
1894 * the client does specify a non-zero size, it can
1895 * still recover by checking the size of the file
1896 * after it has created it and then issue a setattr
1897 * request of its own to set the size of the file.
1898 */
1899 if (vap != NULL &&
1900 (args->how.mode == UNCHECKED ||
1901 args->how.mode == GUARDED) &&
1902 args->how.createhow3_u.obj_attributes.size.set_it &&
1903 vap->va_size != reqsize) {
1904 va.va_mask = AT_SIZE;
1905 va.va_size = reqsize;
1906 (void) VOP_SETATTR(vp, &va, 0, cr, NULL);
1907 va.va_mask = AT_ALL;
1908 vap = VOP_GETATTR(vp, &va, 0, cr, NULL) ? NULL : &va;
1909 }
1910 }
1911
1912 if (name != args->where.name)
1913 kmem_free(name, MAXPATHLEN + 1);
1914
1915 #ifdef DEBUG
1916 if (!rfs3_do_post_op_attr)
1917 vap = NULL;
1918 #endif
1919
1920 #ifdef DEBUG
1921 if (!rfs3_do_post_op_fh3)
1922 resp->resok.obj.handle_follows = FALSE;
1923 else {
1924 #endif
1925 error = makefh3(&resp->resok.obj.handle, vp, exi);
1926 if (error)
1927 resp->resok.obj.handle_follows = FALSE;
1928 else
1929 resp->resok.obj.handle_follows = TRUE;
1930 #ifdef DEBUG
1931 }
1932 #endif
1933
1934 /*
1935 * Force modified data and metadata out to stable storage.
1936 */
1937 (void) VOP_FSYNC(vp, FNODSYNC, cr, NULL);
1938 (void) VOP_FSYNC(dvp, 0, cr, NULL);
1939
1940 VN_RELE(vp);
1941 if (tvp != NULL) {
1942 if (in_crit)
1943 nbl_end_crit(tvp);
1944 VN_RELE(tvp);
1945 }
1946
1947 resp->status = NFS3_OK;
1948 vattr_to_post_op_attr(vap, &resp->resok.obj_attributes);
1949 vattr_to_wcc_data(dbvap, davap, &resp->resok.dir_wcc);
1950
1951 DTRACE_NFSV3_4(op__create__done, struct svc_req *, req,
1952 cred_t *, cr, vnode_t *, dvp, CREATE3res *, resp);
1953
1954 VN_RELE(dvp);
1955 return;
1956
1957 out:
1958 if (curthread->t_flag & T_WOULDBLOCK) {
1959 curthread->t_flag &= ~T_WOULDBLOCK;
1960 resp->status = NFS3ERR_JUKEBOX;
1961 } else
1962 resp->status = puterrno3(error);
1963 out1:
1964 DTRACE_NFSV3_4(op__create__done, struct svc_req *, req,
1965 cred_t *, cr, vnode_t *, dvp, CREATE3res *, resp);
1966
1967 if (name != NULL && name != args->where.name)
1968 kmem_free(name, MAXPATHLEN + 1);
1969
1970 if (tvp != NULL) {
1971 if (in_crit)
1972 nbl_end_crit(tvp);
1973 VN_RELE(tvp);
1974 }
1975 if (dvp != NULL)
1976 VN_RELE(dvp);
1977 vattr_to_wcc_data(dbvap, davap, &resp->resfail.dir_wcc);
1978 }
1979
1980 void *
1981 rfs3_create_getfh(CREATE3args *args)
1982 {
1983
1984 return (&args->where.dir);
1985 }
1986
1987 void
1988 rfs3_mkdir(MKDIR3args *args, MKDIR3res *resp, struct exportinfo *exi,
1989 struct svc_req *req, cred_t *cr)
1990 {
1991 int error;
1992 vnode_t *vp = NULL;
1993 vnode_t *dvp;
1994 struct vattr *vap;
1995 struct vattr va;
1996 struct vattr *dbvap;
1997 struct vattr dbva;
1998 struct vattr *davap;
1999 struct vattr dava;
2000 struct sockaddr *ca;
2001 char *name = NULL;
2002
2003 dbvap = NULL;
2004 davap = NULL;
2005
2006 dvp = nfs3_fhtovp(&args->where.dir, exi);
2007
2008 DTRACE_NFSV3_4(op__mkdir__start, struct svc_req *, req,
2009 cred_t *, cr, vnode_t *, dvp, MKDIR3args *, args);
2010
2011 if (dvp == NULL) {
2012 error = ESTALE;
2013 goto out;
2014 }
2015
2016 #ifdef DEBUG
2017 if (rfs3_do_pre_op_attr) {
2018 dbva.va_mask = AT_ALL;
2019 dbvap = VOP_GETATTR(dvp, &dbva, 0, cr, NULL) ? NULL : &dbva;
2020 } else
2021 dbvap = NULL;
2022 #else
2023 dbva.va_mask = AT_ALL;
2024 dbvap = VOP_GETATTR(dvp, &dbva, 0, cr, NULL) ? NULL : &dbva;
2025 #endif
2026 davap = dbvap;
2027
2028 if (args->where.name == nfs3nametoolong) {
2029 resp->status = NFS3ERR_NAMETOOLONG;
2030 goto out1;
2031 }
2032
2033 if (args->where.name == NULL || *(args->where.name) == '\0') {
2034 resp->status = NFS3ERR_ACCES;
2035 goto out1;
2036 }
2037
2038 if (rdonly(exi, req)) {
2039 resp->status = NFS3ERR_ROFS;
2040 goto out1;
2041 }
2042
2043 if (is_system_labeled()) {
2044 bslabel_t *clabel = req->rq_label;
2045
2046 ASSERT(clabel != NULL);
2047 DTRACE_PROBE2(tx__rfs3__log__info__opmkdir__clabel, char *,
2048 "got client label from request(1)", struct svc_req *, req);
2049
2050 if (!blequal(&l_admin_low->tsl_label, clabel)) {
2051 if (!do_rfs_label_check(clabel, dvp, EQUALITY_CHECK,
2052 exi)) {
2053 resp->status = NFS3ERR_ACCES;
2054 goto out1;
2055 }
2056 }
2057 }
2058
2059 error = sattr3_to_vattr(&args->attributes, &va);
2060 if (error)
2061 goto out;
2062
2063 if (!(va.va_mask & AT_MODE)) {
2064 resp->status = NFS3ERR_INVAL;
2065 goto out1;
2066 }
2067
2068 ca = (struct sockaddr *)svc_getrpccaller(req->rq_xprt)->buf;
2069 name = nfscmd_convname(ca, exi, args->where.name,
2070 NFSCMD_CONV_INBOUND, MAXPATHLEN + 1);
2071
2072 if (name == NULL) {
2073 resp->status = NFS3ERR_INVAL;
2074 goto out1;
2075 }
2076
2077 va.va_mask |= AT_TYPE;
2078 va.va_type = VDIR;
2079
2080 error = VOP_MKDIR(dvp, name, &va, &vp, cr, NULL, 0, NULL);
2081
2082 if (name != args->where.name)
2083 kmem_free(name, MAXPATHLEN + 1);
2084
2085 #ifdef DEBUG
2086 if (rfs3_do_post_op_attr) {
2087 dava.va_mask = AT_ALL;
2088 davap = VOP_GETATTR(dvp, &dava, 0, cr, NULL) ? NULL : &dava;
2089 } else
2090 davap = NULL;
2091 #else
2092 dava.va_mask = AT_ALL;
2093 davap = VOP_GETATTR(dvp, &dava, 0, cr, NULL) ? NULL : &dava;
2094 #endif
2095
2096 /*
2097 * Force modified data and metadata out to stable storage.
2098 */
2099 (void) VOP_FSYNC(dvp, 0, cr, NULL);
2100
2101 if (error)
2102 goto out;
2103
2104 #ifdef DEBUG
2105 if (!rfs3_do_post_op_fh3)
2106 resp->resok.obj.handle_follows = FALSE;
2107 else {
2108 #endif
2109 error = makefh3(&resp->resok.obj.handle, vp, exi);
2110 if (error)
2111 resp->resok.obj.handle_follows = FALSE;
2112 else
2113 resp->resok.obj.handle_follows = TRUE;
2114 #ifdef DEBUG
2115 }
2116 #endif
2117
2118 #ifdef DEBUG
2119 if (rfs3_do_post_op_attr) {
2120 va.va_mask = AT_ALL;
2121 vap = VOP_GETATTR(vp, &va, 0, cr, NULL) ? NULL : &va;
2122 } else
2123 vap = NULL;
2124 #else
2125 va.va_mask = AT_ALL;
2126 vap = VOP_GETATTR(vp, &va, 0, cr, NULL) ? NULL : &va;
2127 #endif
2128
2129 /*
2130 * Force modified data and metadata out to stable storage.
2131 */
2132 (void) VOP_FSYNC(vp, 0, cr, NULL);
2133
2134 VN_RELE(vp);
2135
2136 resp->status = NFS3_OK;
2137 vattr_to_post_op_attr(vap, &resp->resok.obj_attributes);
2138 vattr_to_wcc_data(dbvap, davap, &resp->resok.dir_wcc);
2139
2140 DTRACE_NFSV3_4(op__mkdir__done, struct svc_req *, req,
2141 cred_t *, cr, vnode_t *, dvp, MKDIR3res *, resp);
2142 VN_RELE(dvp);
2143
2144 return;
2145
2146 out:
2147 if (curthread->t_flag & T_WOULDBLOCK) {
2148 curthread->t_flag &= ~T_WOULDBLOCK;
2149 resp->status = NFS3ERR_JUKEBOX;
2150 } else
2151 resp->status = puterrno3(error);
2152 out1:
2153 DTRACE_NFSV3_4(op__mkdir__done, struct svc_req *, req,
2154 cred_t *, cr, vnode_t *, dvp, MKDIR3res *, resp);
2155 if (dvp != NULL)
2156 VN_RELE(dvp);
2157 vattr_to_wcc_data(dbvap, davap, &resp->resfail.dir_wcc);
2158 }
2159
2160 void *
2161 rfs3_mkdir_getfh(MKDIR3args *args)
2162 {
2163
2164 return (&args->where.dir);
2165 }
2166
2167 void
2168 rfs3_symlink(SYMLINK3args *args, SYMLINK3res *resp, struct exportinfo *exi,
2169 struct svc_req *req, cred_t *cr)
2170 {
2171 int error;
2172 vnode_t *vp;
2173 vnode_t *dvp;
2174 struct vattr *vap;
2175 struct vattr va;
2176 struct vattr *dbvap;
2177 struct vattr dbva;
2178 struct vattr *davap;
2179 struct vattr dava;
2180 struct sockaddr *ca;
2181 char *name = NULL;
2182 char *symdata = NULL;
2183
2184 dbvap = NULL;
2185 davap = NULL;
2186
2187 dvp = nfs3_fhtovp(&args->where.dir, exi);
2188
2189 DTRACE_NFSV3_4(op__symlink__start, struct svc_req *, req,
2190 cred_t *, cr, vnode_t *, dvp, SYMLINK3args *, args);
2191
2192 if (dvp == NULL) {
2193 error = ESTALE;
2194 goto err;
2195 }
2196
2197 #ifdef DEBUG
2198 if (rfs3_do_pre_op_attr) {
2199 dbva.va_mask = AT_ALL;
2200 dbvap = VOP_GETATTR(dvp, &dbva, 0, cr, NULL) ? NULL : &dbva;
2201 } else
2202 dbvap = NULL;
2203 #else
2204 dbva.va_mask = AT_ALL;
2205 dbvap = VOP_GETATTR(dvp, &dbva, 0, cr, NULL) ? NULL : &dbva;
2206 #endif
2207 davap = dbvap;
2208
2209 if (args->where.name == nfs3nametoolong) {
2210 resp->status = NFS3ERR_NAMETOOLONG;
2211 goto err1;
2212 }
2213
2214 if (args->where.name == NULL || *(args->where.name) == '\0') {
2215 resp->status = NFS3ERR_ACCES;
2216 goto err1;
2217 }
2218
2219 if (rdonly(exi, req)) {
2220 resp->status = NFS3ERR_ROFS;
2221 goto err1;
2222 }
2223
2224 if (is_system_labeled()) {
2225 bslabel_t *clabel = req->rq_label;
2226
2227 ASSERT(clabel != NULL);
2228 DTRACE_PROBE2(tx__rfs3__log__info__opsymlink__clabel, char *,
2229 "got client label from request(1)", struct svc_req *, req);
2230
2231 if (!blequal(&l_admin_low->tsl_label, clabel)) {
2232 if (!do_rfs_label_check(clabel, dvp, EQUALITY_CHECK,
2233 exi)) {
2234 resp->status = NFS3ERR_ACCES;
2235 goto err1;
2236 }
2237 }
2238 }
2239
2240 error = sattr3_to_vattr(&args->symlink.symlink_attributes, &va);
2241 if (error)
2242 goto err;
2243
2244 if (!(va.va_mask & AT_MODE)) {
2245 resp->status = NFS3ERR_INVAL;
2246 goto err1;
2247 }
2248
2249 if (args->symlink.symlink_data == nfs3nametoolong) {
2250 resp->status = NFS3ERR_NAMETOOLONG;
2251 goto err1;
2252 }
2253
2254 ca = (struct sockaddr *)svc_getrpccaller(req->rq_xprt)->buf;
2255 name = nfscmd_convname(ca, exi, args->where.name,
2256 NFSCMD_CONV_INBOUND, MAXPATHLEN + 1);
2257
2258 if (name == NULL) {
2259 /* This is really a Solaris EILSEQ */
2260 resp->status = NFS3ERR_INVAL;
2261 goto err1;
2262 }
2263
2264 symdata = nfscmd_convname(ca, exi, args->symlink.symlink_data,
2265 NFSCMD_CONV_INBOUND, MAXPATHLEN + 1);
2266 if (symdata == NULL) {
2267 /* This is really a Solaris EILSEQ */
2268 resp->status = NFS3ERR_INVAL;
2269 goto err1;
2270 }
2271
2272
2273 va.va_mask |= AT_TYPE;
2274 va.va_type = VLNK;
2275
2276 error = VOP_SYMLINK(dvp, name, &va, symdata, cr, NULL, 0);
2277
2278 #ifdef DEBUG
2279 if (rfs3_do_post_op_attr) {
2280 dava.va_mask = AT_ALL;
2281 davap = VOP_GETATTR(dvp, &dava, 0, cr, NULL) ? NULL : &dava;
2282 } else
2283 davap = NULL;
2284 #else
2285 dava.va_mask = AT_ALL;
2286 davap = VOP_GETATTR(dvp, &dava, 0, cr, NULL) ? NULL : &dava;
2287 #endif
2288
2289 if (error)
2290 goto err;
2291
2292 error = VOP_LOOKUP(dvp, name, &vp, NULL, 0, NULL, cr,
2293 NULL, NULL, NULL);
2294
2295 /*
2296 * Force modified data and metadata out to stable storage.
2297 */
2298 (void) VOP_FSYNC(dvp, 0, cr, NULL);
2299
2300
2301 resp->status = NFS3_OK;
2302 if (error) {
2303 resp->resok.obj.handle_follows = FALSE;
2304 vattr_to_post_op_attr(NULL, &resp->resok.obj_attributes);
2305 vattr_to_wcc_data(dbvap, davap, &resp->resok.dir_wcc);
2306 goto out;
2307 }
2308
2309 #ifdef DEBUG
2310 if (!rfs3_do_post_op_fh3)
2311 resp->resok.obj.handle_follows = FALSE;
2312 else {
2313 #endif
2314 error = makefh3(&resp->resok.obj.handle, vp, exi);
2315 if (error)
2316 resp->resok.obj.handle_follows = FALSE;
2317 else
2318 resp->resok.obj.handle_follows = TRUE;
2319 #ifdef DEBUG
2320 }
2321 #endif
2322
2323 #ifdef DEBUG
2324 if (rfs3_do_post_op_attr) {
2325 va.va_mask = AT_ALL;
2326 vap = VOP_GETATTR(vp, &va, 0, cr, NULL) ? NULL : &va;
2327 } else
2328 vap = NULL;
2329 #else
2330 va.va_mask = AT_ALL;
2331 vap = VOP_GETATTR(vp, &va, 0, cr, NULL) ? NULL : &va;
2332 #endif
2333
2334 /*
2335 * Force modified data and metadata out to stable storage.
2336 */
2337 (void) VOP_FSYNC(vp, 0, cr, NULL);
2338
2339 VN_RELE(vp);
2340
2341 vattr_to_post_op_attr(vap, &resp->resok.obj_attributes);
2342 vattr_to_wcc_data(dbvap, davap, &resp->resok.dir_wcc);
2343 goto out;
2344
2345 err:
2346 if (curthread->t_flag & T_WOULDBLOCK) {
2347 curthread->t_flag &= ~T_WOULDBLOCK;
2348 resp->status = NFS3ERR_JUKEBOX;
2349 } else
2350 resp->status = puterrno3(error);
2351 err1:
2352 vattr_to_wcc_data(dbvap, davap, &resp->resfail.dir_wcc);
2353 out:
2354 if (name != NULL && name != args->where.name)
2355 kmem_free(name, MAXPATHLEN + 1);
2356 if (symdata != NULL && symdata != args->symlink.symlink_data)
2357 kmem_free(symdata, MAXPATHLEN + 1);
2358
2359 DTRACE_NFSV3_4(op__symlink__done, struct svc_req *, req,
2360 cred_t *, cr, vnode_t *, dvp, SYMLINK3res *, resp);
2361
2362 if (dvp != NULL)
2363 VN_RELE(dvp);
2364 }
2365
2366 void *
2367 rfs3_symlink_getfh(SYMLINK3args *args)
2368 {
2369
2370 return (&args->where.dir);
2371 }
2372
2373 void
2374 rfs3_mknod(MKNOD3args *args, MKNOD3res *resp, struct exportinfo *exi,
2375 struct svc_req *req, cred_t *cr)
2376 {
2377 int error;
2378 vnode_t *vp;
2379 vnode_t *realvp;
2380 vnode_t *dvp;
2381 struct vattr *vap;
2382 struct vattr va;
2383 struct vattr *dbvap;
2384 struct vattr dbva;
2385 struct vattr *davap;
2386 struct vattr dava;
2387 int mode;
2388 enum vcexcl excl;
2389 struct sockaddr *ca;
2390 char *name = NULL;
2391
2392 dbvap = NULL;
2393 davap = NULL;
2394
2395 dvp = nfs3_fhtovp(&args->where.dir, exi);
2396
2397 DTRACE_NFSV3_4(op__mknod__start, struct svc_req *, req,
2398 cred_t *, cr, vnode_t *, dvp, MKNOD3args *, args);
2399
2400 if (dvp == NULL) {
2401 error = ESTALE;
2402 goto out;
2403 }
2404
2405 #ifdef DEBUG
2406 if (rfs3_do_pre_op_attr) {
2407 dbva.va_mask = AT_ALL;
2408 dbvap = VOP_GETATTR(dvp, &dbva, 0, cr, NULL) ? NULL : &dbva;
2409 } else
2410 dbvap = NULL;
2411 #else
2412 dbva.va_mask = AT_ALL;
2413 dbvap = VOP_GETATTR(dvp, &dbva, 0, cr, NULL) ? NULL : &dbva;
2414 #endif
2415 davap = dbvap;
2416
2417 if (args->where.name == nfs3nametoolong) {
2418 resp->status = NFS3ERR_NAMETOOLONG;
2419 goto out1;
2420 }
2421
2422 if (args->where.name == NULL || *(args->where.name) == '\0') {
2423 resp->status = NFS3ERR_ACCES;
2424 goto out1;
2425 }
2426
2427 if (rdonly(exi, req)) {
2428 resp->status = NFS3ERR_ROFS;
2429 goto out1;
2430 }
2431
2432 if (is_system_labeled()) {
2433 bslabel_t *clabel = req->rq_label;
2434
2435 ASSERT(clabel != NULL);
2436 DTRACE_PROBE2(tx__rfs3__log__info__opmknod__clabel, char *,
2437 "got client label from request(1)", struct svc_req *, req);
2438
2439 if (!blequal(&l_admin_low->tsl_label, clabel)) {
2440 if (!do_rfs_label_check(clabel, dvp, EQUALITY_CHECK,
2441 exi)) {
2442 resp->status = NFS3ERR_ACCES;
2443 goto out1;
2444 }
2445 }
2446 }
2447
2448 switch (args->what.type) {
2449 case NF3CHR:
2450 case NF3BLK:
2451 error = sattr3_to_vattr(
2452 &args->what.mknoddata3_u.device.dev_attributes, &va);
2453 if (error)
2454 goto out;
2455 if (secpolicy_sys_devices(cr) != 0) {
2456 resp->status = NFS3ERR_PERM;
2457 goto out1;
2458 }
2459 if (args->what.type == NF3CHR)
2460 va.va_type = VCHR;
2461 else
2462 va.va_type = VBLK;
2463 va.va_rdev = makedevice(
2464 args->what.mknoddata3_u.device.spec.specdata1,
2465 args->what.mknoddata3_u.device.spec.specdata2);
2466 va.va_mask |= AT_TYPE | AT_RDEV;
2467 break;
2468 case NF3SOCK:
2469 error = sattr3_to_vattr(
2470 &args->what.mknoddata3_u.pipe_attributes, &va);
2471 if (error)
2472 goto out;
2473 va.va_type = VSOCK;
2474 va.va_mask |= AT_TYPE;
2475 break;
2476 case NF3FIFO:
2477 error = sattr3_to_vattr(
2478 &args->what.mknoddata3_u.pipe_attributes, &va);
2479 if (error)
2480 goto out;
2481 va.va_type = VFIFO;
2482 va.va_mask |= AT_TYPE;
2483 break;
2484 default:
2485 resp->status = NFS3ERR_BADTYPE;
2486 goto out1;
2487 }
2488
2489 /*
2490 * Must specify the mode.
2491 */
2492 if (!(va.va_mask & AT_MODE)) {
2493 resp->status = NFS3ERR_INVAL;
2494 goto out1;
2495 }
2496
2497 ca = (struct sockaddr *)svc_getrpccaller(req->rq_xprt)->buf;
2498 name = nfscmd_convname(ca, exi, args->where.name,
2499 NFSCMD_CONV_INBOUND, MAXPATHLEN + 1);
2500
2501 if (name == NULL) {
2502 resp->status = NFS3ERR_INVAL;
2503 goto out1;
2504 }
2505
2506 excl = EXCL;
2507
2508 mode = 0;
2509
2510 error = VOP_CREATE(dvp, name, &va, excl, mode,
2511 &vp, cr, 0, NULL, NULL);
2512
2513 if (name != args->where.name)
2514 kmem_free(name, MAXPATHLEN + 1);
2515
2516 #ifdef DEBUG
2517 if (rfs3_do_post_op_attr) {
2518 dava.va_mask = AT_ALL;
2519 davap = VOP_GETATTR(dvp, &dava, 0, cr, NULL) ? NULL : &dava;
2520 } else
2521 davap = NULL;
2522 #else
2523 dava.va_mask = AT_ALL;
2524 davap = VOP_GETATTR(dvp, &dava, 0, cr, NULL) ? NULL : &dava;
2525 #endif
2526
2527 /*
2528 * Force modified data and metadata out to stable storage.
2529 */
2530 (void) VOP_FSYNC(dvp, 0, cr, NULL);
2531
2532 if (error)
2533 goto out;
2534
2535 resp->status = NFS3_OK;
2536
2537 #ifdef DEBUG
2538 if (!rfs3_do_post_op_fh3)
2539 resp->resok.obj.handle_follows = FALSE;
2540 else {
2541 #endif
2542 error = makefh3(&resp->resok.obj.handle, vp, exi);
2543 if (error)
2544 resp->resok.obj.handle_follows = FALSE;
2545 else
2546 resp->resok.obj.handle_follows = TRUE;
2547 #ifdef DEBUG
2548 }
2549 #endif
2550
2551 #ifdef DEBUG
2552 if (rfs3_do_post_op_attr) {
2553 va.va_mask = AT_ALL;
2554 vap = VOP_GETATTR(vp, &va, 0, cr, NULL) ? NULL : &va;
2555 } else
2556 vap = NULL;
2557 #else
2558 va.va_mask = AT_ALL;
2559 vap = VOP_GETATTR(vp, &va, 0, cr, NULL) ? NULL : &va;
2560 #endif
2561
2562 /*
2563 * Force modified metadata out to stable storage.
2564 *
2565 * if a underlying vp exists, pass it to VOP_FSYNC
2566 */
2567 if (VOP_REALVP(vp, &realvp, NULL) == 0)
2568 (void) VOP_FSYNC(realvp, FNODSYNC, cr, NULL);
2569 else
2570 (void) VOP_FSYNC(vp, FNODSYNC, cr, NULL);
2571
2572 VN_RELE(vp);
2573
2574 vattr_to_post_op_attr(vap, &resp->resok.obj_attributes);
2575 vattr_to_wcc_data(dbvap, davap, &resp->resok.dir_wcc);
2576 DTRACE_NFSV3_4(op__mknod__done, struct svc_req *, req,
2577 cred_t *, cr, vnode_t *, dvp, MKNOD3res *, resp);
2578 VN_RELE(dvp);
2579 return;
2580
2581 out:
2582 if (curthread->t_flag & T_WOULDBLOCK) {
2583 curthread->t_flag &= ~T_WOULDBLOCK;
2584 resp->status = NFS3ERR_JUKEBOX;
2585 } else
2586 resp->status = puterrno3(error);
2587 out1:
2588 DTRACE_NFSV3_4(op__mknod__done, struct svc_req *, req,
2589 cred_t *, cr, vnode_t *, dvp, MKNOD3res *, resp);
2590 if (dvp != NULL)
2591 VN_RELE(dvp);
2592 vattr_to_wcc_data(dbvap, davap, &resp->resfail.dir_wcc);
2593 }
2594
2595 void *
2596 rfs3_mknod_getfh(MKNOD3args *args)
2597 {
2598
2599 return (&args->where.dir);
2600 }
2601
2602 void
2603 rfs3_remove(REMOVE3args *args, REMOVE3res *resp, struct exportinfo *exi,
2604 struct svc_req *req, cred_t *cr)
2605 {
2606 int error = 0;
2607 vnode_t *vp;
2608 struct vattr *bvap;
2609 struct vattr bva;
2610 struct vattr *avap;
2611 struct vattr ava;
2612 vnode_t *targvp = NULL;
2613 struct sockaddr *ca;
2614 char *name = NULL;
2615
2616 bvap = NULL;
2617 avap = NULL;
2618
2619 vp = nfs3_fhtovp(&args->object.dir, exi);
2620
2621 DTRACE_NFSV3_4(op__remove__start, struct svc_req *, req,
2622 cred_t *, cr, vnode_t *, vp, REMOVE3args *, args);
2623
2624 if (vp == NULL) {
2625 error = ESTALE;
2626 goto err;
2627 }
2628
2629 #ifdef DEBUG
2630 if (rfs3_do_pre_op_attr) {
2631 bva.va_mask = AT_ALL;
2632 bvap = VOP_GETATTR(vp, &bva, 0, cr, NULL) ? NULL : &bva;
2633 } else
2634 bvap = NULL;
2635 #else
2636 bva.va_mask = AT_ALL;
2637 bvap = VOP_GETATTR(vp, &bva, 0, cr, NULL) ? NULL : &bva;
2638 #endif
2639 avap = bvap;
2640
2641 if (vp->v_type != VDIR) {
2642 resp->status = NFS3ERR_NOTDIR;
2643 goto err1;
2644 }
2645
2646 if (args->object.name == nfs3nametoolong) {
2647 resp->status = NFS3ERR_NAMETOOLONG;
2648 goto err1;
2649 }
2650
2651 if (args->object.name == NULL || *(args->object.name) == '\0') {
2652 resp->status = NFS3ERR_ACCES;
2653 goto err1;
2654 }
2655
2656 if (rdonly(exi, req)) {
2657 resp->status = NFS3ERR_ROFS;
2658 goto err1;
2659 }
2660
2661 if (is_system_labeled()) {
2662 bslabel_t *clabel = req->rq_label;
2663
2664 ASSERT(clabel != NULL);
2665 DTRACE_PROBE2(tx__rfs3__log__info__opremove__clabel, char *,
2666 "got client label from request(1)", struct svc_req *, req);
2667
2668 if (!blequal(&l_admin_low->tsl_label, clabel)) {
2669 if (!do_rfs_label_check(clabel, vp, EQUALITY_CHECK,
2670 exi)) {
2671 resp->status = NFS3ERR_ACCES;
2672 goto err1;
2673 }
2674 }
2675 }
2676
2677 ca = (struct sockaddr *)svc_getrpccaller(req->rq_xprt)->buf;
2678 name = nfscmd_convname(ca, exi, args->object.name,
2679 NFSCMD_CONV_INBOUND, MAXPATHLEN + 1);
2680
2681 if (name == NULL) {
2682 resp->status = NFS3ERR_INVAL;
2683 goto err1;
2684 }
2685
2686 /*
2687 * Check for a conflict with a non-blocking mandatory share
2688 * reservation and V4 delegations
2689 */
2690 error = VOP_LOOKUP(vp, name, &targvp, NULL, 0,
2691 NULL, cr, NULL, NULL, NULL);
2692 if (error != 0)
2693 goto err;
2694
2695 if (rfs4_check_delegated(FWRITE, targvp, TRUE)) {
2696 resp->status = NFS3ERR_JUKEBOX;
2697 goto err1;
2698 }
2699
2700 if (!nbl_need_check(targvp)) {
2701 error = VOP_REMOVE(vp, name, cr, NULL, 0);
2702 } else {
2703 nbl_start_crit(targvp, RW_READER);
2704 if (nbl_conflict(targvp, NBL_REMOVE, 0, 0, 0, NULL)) {
2705 error = EACCES;
2706 } else {
2707 error = VOP_REMOVE(vp, name, cr, NULL, 0);
2708 }
2709 nbl_end_crit(targvp);
2710 }
2711 VN_RELE(targvp);
2712 targvp = NULL;
2713
2714 #ifdef DEBUG
2715 if (rfs3_do_post_op_attr) {
2716 ava.va_mask = AT_ALL;
2717 avap = VOP_GETATTR(vp, &ava, 0, cr, NULL) ? NULL : &ava;
2718 } else
2719 avap = NULL;
2720 #else
2721 ava.va_mask = AT_ALL;
2722 avap = VOP_GETATTR(vp, &ava, 0, cr, NULL) ? NULL : &ava;
2723 #endif
2724
2725 /*
2726 * Force modified data and metadata out to stable storage.
2727 */
2728 (void) VOP_FSYNC(vp, 0, cr, NULL);
2729
2730 if (error)
2731 goto err;
2732
2733 resp->status = NFS3_OK;
2734 vattr_to_wcc_data(bvap, avap, &resp->resok.dir_wcc);
2735 goto out;
2736
2737 err:
2738 if (curthread->t_flag & T_WOULDBLOCK) {
2739 curthread->t_flag &= ~T_WOULDBLOCK;
2740 resp->status = NFS3ERR_JUKEBOX;
2741 } else
2742 resp->status = puterrno3(error);
2743 err1:
2744 vattr_to_wcc_data(bvap, avap, &resp->resfail.dir_wcc);
2745 out:
2746 DTRACE_NFSV3_4(op__remove__done, struct svc_req *, req,
2747 cred_t *, cr, vnode_t *, vp, REMOVE3res *, resp);
2748
2749 if (name != NULL && name != args->object.name)
2750 kmem_free(name, MAXPATHLEN + 1);
2751
2752 if (vp != NULL)
2753 VN_RELE(vp);
2754 }
2755
2756 void *
2757 rfs3_remove_getfh(REMOVE3args *args)
2758 {
2759
2760 return (&args->object.dir);
2761 }
2762
2763 void
2764 rfs3_rmdir(RMDIR3args *args, RMDIR3res *resp, struct exportinfo *exi,
2765 struct svc_req *req, cred_t *cr)
2766 {
2767 int error;
2768 vnode_t *vp;
2769 struct vattr *bvap;
2770 struct vattr bva;
2771 struct vattr *avap;
2772 struct vattr ava;
2773 struct sockaddr *ca;
2774 char *name = NULL;
2775
2776 bvap = NULL;
2777 avap = NULL;
2778
2779 vp = nfs3_fhtovp(&args->object.dir, exi);
2780
2781 DTRACE_NFSV3_4(op__rmdir__start, struct svc_req *, req,
2782 cred_t *, cr, vnode_t *, vp, RMDIR3args *, args);
2783
2784 if (vp == NULL) {
2785 error = ESTALE;
2786 goto err;
2787 }
2788
2789 #ifdef DEBUG
2790 if (rfs3_do_pre_op_attr) {
2791 bva.va_mask = AT_ALL;
2792 bvap = VOP_GETATTR(vp, &bva, 0, cr, NULL) ? NULL : &bva;
2793 } else
2794 bvap = NULL;
2795 #else
2796 bva.va_mask = AT_ALL;
2797 bvap = VOP_GETATTR(vp, &bva, 0, cr, NULL) ? NULL : &bva;
2798 #endif
2799 avap = bvap;
2800
2801 if (vp->v_type != VDIR) {
2802 resp->status = NFS3ERR_NOTDIR;
2803 goto err1;
2804 }
2805
2806 if (args->object.name == nfs3nametoolong) {
2807 resp->status = NFS3ERR_NAMETOOLONG;
2808 goto err1;
2809 }
2810
2811 if (args->object.name == NULL || *(args->object.name) == '\0') {
2812 resp->status = NFS3ERR_ACCES;
2813 goto err1;
2814 }
2815
2816 if (rdonly(exi, req)) {
2817 resp->status = NFS3ERR_ROFS;
2818 goto err1;
2819 }
2820
2821 if (is_system_labeled()) {
2822 bslabel_t *clabel = req->rq_label;
2823
2824 ASSERT(clabel != NULL);
2825 DTRACE_PROBE2(tx__rfs3__log__info__opremovedir__clabel, char *,
2826 "got client label from request(1)", struct svc_req *, req);
2827
2828 if (!blequal(&l_admin_low->tsl_label, clabel)) {
2829 if (!do_rfs_label_check(clabel, vp, EQUALITY_CHECK,
2830 exi)) {
2831 resp->status = NFS3ERR_ACCES;
2832 goto err1;
2833 }
2834 }
2835 }
2836
2837 ca = (struct sockaddr *)svc_getrpccaller(req->rq_xprt)->buf;
2838 name = nfscmd_convname(ca, exi, args->object.name,
2839 NFSCMD_CONV_INBOUND, MAXPATHLEN + 1);
2840
2841 if (name == NULL) {
2842 resp->status = NFS3ERR_INVAL;
2843 goto err1;
2844 }
2845
2846 error = VOP_RMDIR(vp, name, rootdir, cr, NULL, 0);
2847
2848 if (name != args->object.name)
2849 kmem_free(name, MAXPATHLEN + 1);
2850
2851 #ifdef DEBUG
2852 if (rfs3_do_post_op_attr) {
2853 ava.va_mask = AT_ALL;
2854 avap = VOP_GETATTR(vp, &ava, 0, cr, NULL) ? NULL : &ava;
2855 } else
2856 avap = NULL;
2857 #else
2858 ava.va_mask = AT_ALL;
2859 avap = VOP_GETATTR(vp, &ava, 0, cr, NULL) ? NULL : &ava;
2860 #endif
2861
2862 /*
2863 * Force modified data and metadata out to stable storage.
2864 */
2865 (void) VOP_FSYNC(vp, 0, cr, NULL);
2866
2867 if (error) {
2868 /*
2869 * System V defines rmdir to return EEXIST, not ENOTEMPTY,
2870 * if the directory is not empty. A System V NFS server
2871 * needs to map NFS3ERR_EXIST to NFS3ERR_NOTEMPTY to transmit
2872 * over the wire.
2873 */
2874 if (error == EEXIST)
2875 error = ENOTEMPTY;
2876 goto err;
2877 }
2878
2879 resp->status = NFS3_OK;
2880 vattr_to_wcc_data(bvap, avap, &resp->resok.dir_wcc);
2881 goto out;
2882
2883 err:
2884 if (curthread->t_flag & T_WOULDBLOCK) {
2885 curthread->t_flag &= ~T_WOULDBLOCK;
2886 resp->status = NFS3ERR_JUKEBOX;
2887 } else
2888 resp->status = puterrno3(error);
2889 err1:
2890 vattr_to_wcc_data(bvap, avap, &resp->resfail.dir_wcc);
2891 out:
2892 DTRACE_NFSV3_4(op__rmdir__done, struct svc_req *, req,
2893 cred_t *, cr, vnode_t *, vp, RMDIR3res *, resp);
2894 if (vp != NULL)
2895 VN_RELE(vp);
2896
2897 }
2898
2899 void *
2900 rfs3_rmdir_getfh(RMDIR3args *args)
2901 {
2902
2903 return (&args->object.dir);
2904 }
2905
2906 void
2907 rfs3_rename(RENAME3args *args, RENAME3res *resp, struct exportinfo *exi,
2908 struct svc_req *req, cred_t *cr)
2909 {
2910 int error = 0;
2911 vnode_t *fvp;
2912 vnode_t *tvp;
2913 vnode_t *targvp;
2914 struct vattr *fbvap;
2915 struct vattr fbva;
2916 struct vattr *favap;
2917 struct vattr fava;
2918 struct vattr *tbvap;
2919 struct vattr tbva;
2920 struct vattr *tavap;
2921 struct vattr tava;
2922 nfs_fh3 *fh3;
2923 struct exportinfo *to_exi;
2924 vnode_t *srcvp = NULL;
2925 bslabel_t *clabel;
2926 struct sockaddr *ca;
2927 char *name = NULL;
2928 char *toname = NULL;
2929
2930 fbvap = NULL;
2931 favap = NULL;
2932 tbvap = NULL;
2933 tavap = NULL;
2934 tvp = NULL;
2935
2936 fvp = nfs3_fhtovp(&args->from.dir, exi);
2937
2938 DTRACE_NFSV3_4(op__rename__start, struct svc_req *, req,
2939 cred_t *, cr, vnode_t *, fvp, RENAME3args *, args);
2940
2941 if (fvp == NULL) {
2942 error = ESTALE;
2943 goto err;
2944 }
2945
2946 if (is_system_labeled()) {
2947 clabel = req->rq_label;
2948 ASSERT(clabel != NULL);
2949 DTRACE_PROBE2(tx__rfs3__log__info__oprename__clabel, char *,
2950 "got client label from request(1)", struct svc_req *, req);
2951
2952 if (!blequal(&l_admin_low->tsl_label, clabel)) {
2953 if (!do_rfs_label_check(clabel, fvp, EQUALITY_CHECK,
2954 exi)) {
2955 resp->status = NFS3ERR_ACCES;
2956 goto err1;
2957 }
2958 }
2959 }
2960
2961 #ifdef DEBUG
2962 if (rfs3_do_pre_op_attr) {
2963 fbva.va_mask = AT_ALL;
2964 fbvap = VOP_GETATTR(fvp, &fbva, 0, cr, NULL) ? NULL : &fbva;
2965 } else
2966 fbvap = NULL;
2967 #else
2968 fbva.va_mask = AT_ALL;
2969 fbvap = VOP_GETATTR(fvp, &fbva, 0, cr, NULL) ? NULL : &fbva;
2970 #endif
2971 favap = fbvap;
2972
2973 fh3 = &args->to.dir;
2974 to_exi = checkexport(&fh3->fh3_fsid, FH3TOXFIDP(fh3));
2975 if (to_exi == NULL) {
2976 resp->status = NFS3ERR_ACCES;
2977 goto err1;
2978 }
2979 exi_rele(to_exi);
2980
2981 if (to_exi != exi) {
2982 resp->status = NFS3ERR_XDEV;
2983 goto err1;
2984 }
2985
2986 tvp = nfs3_fhtovp(&args->to.dir, exi);
2987 if (tvp == NULL) {
2988 error = ESTALE;
2989 goto err;
2990 }
2991
2992 #ifdef DEBUG
2993 if (rfs3_do_pre_op_attr) {
2994 tbva.va_mask = AT_ALL;
2995 tbvap = VOP_GETATTR(tvp, &tbva, 0, cr, NULL) ? NULL : &tbva;
2996 } else
2997 tbvap = NULL;
2998 #else
2999 tbva.va_mask = AT_ALL;
3000 tbvap = VOP_GETATTR(tvp, &tbva, 0, cr, NULL) ? NULL : &tbva;
3001 #endif
3002 tavap = tbvap;
3003
3004 if (fvp->v_type != VDIR || tvp->v_type != VDIR) {
3005 resp->status = NFS3ERR_NOTDIR;
3006 goto err1;
3007 }
3008
3009 if (args->from.name == nfs3nametoolong ||
3010 args->to.name == nfs3nametoolong) {
3011 resp->status = NFS3ERR_NAMETOOLONG;
3012 goto err1;
3013 }
3014 if (args->from.name == NULL || *(args->from.name) == '\0' ||
3015 args->to.name == NULL || *(args->to.name) == '\0') {
3016 resp->status = NFS3ERR_ACCES;
3017 goto err1;
3018 }
3019
3020 if (rdonly(exi, req)) {
3021 resp->status = NFS3ERR_ROFS;
3022 goto err1;
3023 }
3024
3025 if (is_system_labeled()) {
3026 if (!blequal(&l_admin_low->tsl_label, clabel)) {
3027 if (!do_rfs_label_check(clabel, tvp, EQUALITY_CHECK,
3028 exi)) {
3029 resp->status = NFS3ERR_ACCES;
3030 goto err1;
3031 }
3032 }
3033 }
3034
3035 ca = (struct sockaddr *)svc_getrpccaller(req->rq_xprt)->buf;
3036 name = nfscmd_convname(ca, exi, args->from.name,
3037 NFSCMD_CONV_INBOUND, MAXPATHLEN + 1);
3038
3039 if (name == NULL) {
3040 resp->status = NFS3ERR_INVAL;
3041 goto err1;
3042 }
3043
3044 toname = nfscmd_convname(ca, exi, args->to.name,
3045 NFSCMD_CONV_INBOUND, MAXPATHLEN + 1);
3046
3047 if (toname == NULL) {
3048 resp->status = NFS3ERR_INVAL;
3049 goto err1;
3050 }
3051
3052 /*
3053 * Check for a conflict with a non-blocking mandatory share
3054 * reservation or V4 delegations.
3055 */
3056 error = VOP_LOOKUP(fvp, name, &srcvp, NULL, 0,
3057 NULL, cr, NULL, NULL, NULL);
3058 if (error != 0)
3059 goto err;
3060
3061 /*
3062 * If we rename a delegated file we should recall the
3063 * delegation, since future opens should fail or would
3064 * refer to a new file.
3065 */
3066 if (rfs4_check_delegated(FWRITE, srcvp, FALSE)) {
3067 resp->status = NFS3ERR_JUKEBOX;
3068 goto err1;
3069 }
3070
3071 /*
3072 * Check for renaming over a delegated file. Check rfs4_deleg_policy
3073 * first to avoid VOP_LOOKUP if possible.
3074 */
3075 if (rfs4_deleg_policy != SRV_NEVER_DELEGATE &&
3076 VOP_LOOKUP(tvp, toname, &targvp, NULL, 0, NULL, cr,
3077 NULL, NULL, NULL) == 0) {
3078
3079 if (rfs4_check_delegated(FWRITE, targvp, TRUE)) {
3080 VN_RELE(targvp);
3081 resp->status = NFS3ERR_JUKEBOX;
3082 goto err1;
3083 }
3084 VN_RELE(targvp);
3085 }
3086
3087 if (!nbl_need_check(srcvp)) {
3088 error = VOP_RENAME(fvp, name, tvp, toname, cr, NULL, 0);
3089 } else {
3090 nbl_start_crit(srcvp, RW_READER);
3091 if (nbl_conflict(srcvp, NBL_RENAME, 0, 0, 0, NULL))
3092 error = EACCES;
3093 else
3094 error = VOP_RENAME(fvp, name, tvp, toname, cr, NULL, 0);
3095 nbl_end_crit(srcvp);
3096 }
3097 if (error == 0)
3098 vn_renamepath(tvp, srcvp, args->to.name,
3099 strlen(args->to.name));
3100 VN_RELE(srcvp);
3101 srcvp = NULL;
3102
3103 #ifdef DEBUG
3104 if (rfs3_do_post_op_attr) {
3105 fava.va_mask = AT_ALL;
3106 favap = VOP_GETATTR(fvp, &fava, 0, cr, NULL) ? NULL : &fava;
3107 tava.va_mask = AT_ALL;
3108 tavap = VOP_GETATTR(tvp, &tava, 0, cr, NULL) ? NULL : &tava;
3109 } else {
3110 favap = NULL;
3111 tavap = NULL;
3112 }
3113 #else
3114 fava.va_mask = AT_ALL;
3115 favap = VOP_GETATTR(fvp, &fava, 0, cr, NULL) ? NULL : &fava;
3116 tava.va_mask = AT_ALL;
3117 tavap = VOP_GETATTR(tvp, &tava, 0, cr, NULL) ? NULL : &tava;
3118 #endif
3119
3120 /*
3121 * Force modified data and metadata out to stable storage.
3122 */
3123 (void) VOP_FSYNC(fvp, 0, cr, NULL);
3124 (void) VOP_FSYNC(tvp, 0, cr, NULL);
3125
3126 if (error)
3127 goto err;
3128
3129 resp->status = NFS3_OK;
3130 vattr_to_wcc_data(fbvap, favap, &resp->resok.fromdir_wcc);
3131 vattr_to_wcc_data(tbvap, tavap, &resp->resok.todir_wcc);
3132 goto out;
3133
3134 err:
3135 if (curthread->t_flag & T_WOULDBLOCK) {
3136 curthread->t_flag &= ~T_WOULDBLOCK;
3137 resp->status = NFS3ERR_JUKEBOX;
3138 } else {
3139 resp->status = puterrno3(error);
3140 }
3141 err1:
3142 vattr_to_wcc_data(fbvap, favap, &resp->resfail.fromdir_wcc);
3143 vattr_to_wcc_data(tbvap, tavap, &resp->resfail.todir_wcc);
3144
3145 out:
3146 if (name != NULL && name != args->from.name)
3147 kmem_free(name, MAXPATHLEN + 1);
3148 if (toname != NULL && toname != args->to.name)
3149 kmem_free(toname, MAXPATHLEN + 1);
3150
3151 DTRACE_NFSV3_4(op__rename__done, struct svc_req *, req,
3152 cred_t *, cr, vnode_t *, fvp, RENAME3res *, resp);
3153 if (fvp != NULL)
3154 VN_RELE(fvp);
3155 if (tvp != NULL)
3156 VN_RELE(tvp);
3157 }
3158
3159 void *
3160 rfs3_rename_getfh(RENAME3args *args)
3161 {
3162
3163 return (&args->from.dir);
3164 }
3165
3166 void
3167 rfs3_link(LINK3args *args, LINK3res *resp, struct exportinfo *exi,
3168 struct svc_req *req, cred_t *cr)
3169 {
3170 int error;
3171 vnode_t *vp;
3172 vnode_t *dvp;
3173 struct vattr *vap;
3174 struct vattr va;
3175 struct vattr *bvap;
3176 struct vattr bva;
3177 struct vattr *avap;
3178 struct vattr ava;
3179 nfs_fh3 *fh3;
3180 struct exportinfo *to_exi;
3181 bslabel_t *clabel;
3182 struct sockaddr *ca;
3183 char *name = NULL;
3184
3185 vap = NULL;
3186 bvap = NULL;
3187 avap = NULL;
3188 dvp = NULL;
3189
3190 vp = nfs3_fhtovp(&args->file, exi);
3191
3192 DTRACE_NFSV3_4(op__link__start, struct svc_req *, req,
3193 cred_t *, cr, vnode_t *, vp, LINK3args *, args);
3194
3195 if (vp == NULL) {
3196 error = ESTALE;
3197 goto out;
3198 }
3199
3200 #ifdef DEBUG
3201 if (rfs3_do_pre_op_attr) {
3202 va.va_mask = AT_ALL;
3203 vap = VOP_GETATTR(vp, &va, 0, cr, NULL) ? NULL : &va;
3204 } else
3205 vap = NULL;
3206 #else
3207 va.va_mask = AT_ALL;
3208 vap = VOP_GETATTR(vp, &va, 0, cr, NULL) ? NULL : &va;
3209 #endif
3210
3211 fh3 = &args->link.dir;
3212 to_exi = checkexport(&fh3->fh3_fsid, FH3TOXFIDP(fh3));
3213 if (to_exi == NULL) {
3214 resp->status = NFS3ERR_ACCES;
3215 goto out1;
3216 }
3217 exi_rele(to_exi);
3218
3219 if (to_exi != exi) {
3220 resp->status = NFS3ERR_XDEV;
3221 goto out1;
3222 }
3223
3224 if (is_system_labeled()) {
3225 clabel = req->rq_label;
3226
3227 ASSERT(clabel != NULL);
3228 DTRACE_PROBE2(tx__rfs3__log__info__oplink__clabel, char *,
3229 "got client label from request(1)", struct svc_req *, req);
3230
3231 if (!blequal(&l_admin_low->tsl_label, clabel)) {
3232 if (!do_rfs_label_check(clabel, vp, DOMINANCE_CHECK,
3233 exi)) {
3234 resp->status = NFS3ERR_ACCES;
3235 goto out1;
3236 }
3237 }
3238 }
3239
3240 dvp = nfs3_fhtovp(&args->link.dir, exi);
3241 if (dvp == NULL) {
3242 error = ESTALE;
3243 goto out;
3244 }
3245
3246 #ifdef DEBUG
3247 if (rfs3_do_pre_op_attr) {
3248 bva.va_mask = AT_ALL;
3249 bvap = VOP_GETATTR(dvp, &bva, 0, cr, NULL) ? NULL : &bva;
3250 } else
3251 bvap = NULL;
3252 #else
3253 bva.va_mask = AT_ALL;
3254 bvap = VOP_GETATTR(dvp, &bva, 0, cr, NULL) ? NULL : &bva;
3255 #endif
3256
3257 if (dvp->v_type != VDIR) {
3258 resp->status = NFS3ERR_NOTDIR;
3259 goto out1;
3260 }
3261
3262 if (args->link.name == nfs3nametoolong) {
3263 resp->status = NFS3ERR_NAMETOOLONG;
3264 goto out1;
3265 }
3266
3267 if (args->link.name == NULL || *(args->link.name) == '\0') {
3268 resp->status = NFS3ERR_ACCES;
3269 goto out1;
3270 }
3271
3272 if (rdonly(exi, req)) {
3273 resp->status = NFS3ERR_ROFS;
3274 goto out1;
3275 }
3276
3277 if (is_system_labeled()) {
3278 DTRACE_PROBE2(tx__rfs3__log__info__oplinkdir__clabel, char *,
3279 "got client label from request(1)", struct svc_req *, req);
3280
3281 if (!blequal(&l_admin_low->tsl_label, clabel)) {
3282 if (!do_rfs_label_check(clabel, dvp, EQUALITY_CHECK,
3283 exi)) {
3284 resp->status = NFS3ERR_ACCES;
3285 goto out1;
3286 }
3287 }
3288 }
3289
3290 ca = (struct sockaddr *)svc_getrpccaller(req->rq_xprt)->buf;
3291 name = nfscmd_convname(ca, exi, args->link.name,
3292 NFSCMD_CONV_INBOUND, MAXPATHLEN + 1);
3293
3294 if (name == NULL) {
3295 resp->status = NFS3ERR_SERVERFAULT;
3296 goto out1;
3297 }
3298
3299 error = VOP_LINK(dvp, vp, name, cr, NULL, 0);
3300
3301 #ifdef DEBUG
3302 if (rfs3_do_post_op_attr) {
3303 va.va_mask = AT_ALL;
3304 vap = VOP_GETATTR(vp, &va, 0, cr, NULL) ? NULL : &va;
3305 ava.va_mask = AT_ALL;
3306 avap = VOP_GETATTR(dvp, &ava, 0, cr, NULL) ? NULL : &ava;
3307 } else {
3308 vap = NULL;
3309 avap = NULL;
3310 }
3311 #else
3312 va.va_mask = AT_ALL;
3313 vap = VOP_GETATTR(vp, &va, 0, cr, NULL) ? NULL : &va;
3314 ava.va_mask = AT_ALL;
3315 avap = VOP_GETATTR(dvp, &ava, 0, cr, NULL) ? NULL : &ava;
3316 #endif
3317
3318 /*
3319 * Force modified data and metadata out to stable storage.
3320 */
3321 (void) VOP_FSYNC(vp, FNODSYNC, cr, NULL);
3322 (void) VOP_FSYNC(dvp, 0, cr, NULL);
3323
3324 if (error)
3325 goto out;
3326
3327 VN_RELE(dvp);
3328
3329 resp->status = NFS3_OK;
3330 vattr_to_post_op_attr(vap, &resp->resok.file_attributes);
3331 vattr_to_wcc_data(bvap, avap, &resp->resok.linkdir_wcc);
3332
3333 DTRACE_NFSV3_4(op__link__done, struct svc_req *, req,
3334 cred_t *, cr, vnode_t *, vp, LINK3res *, resp);
3335
3336 VN_RELE(vp);
3337
3338 return;
3339
3340 out:
3341 if (curthread->t_flag & T_WOULDBLOCK) {
3342 curthread->t_flag &= ~T_WOULDBLOCK;
3343 resp->status = NFS3ERR_JUKEBOX;
3344 } else
3345 resp->status = puterrno3(error);
3346 out1:
3347 if (name != NULL && name != args->link.name)
3348 kmem_free(name, MAXPATHLEN + 1);
3349
3350 DTRACE_NFSV3_4(op__link__done, struct svc_req *, req,
3351 cred_t *, cr, vnode_t *, vp, LINK3res *, resp);
3352
3353 if (vp != NULL)
3354 VN_RELE(vp);
3355 if (dvp != NULL)
3356 VN_RELE(dvp);
3357 vattr_to_post_op_attr(vap, &resp->resfail.file_attributes);
3358 vattr_to_wcc_data(bvap, avap, &resp->resfail.linkdir_wcc);
3359 }
3360
3361 void *
3362 rfs3_link_getfh(LINK3args *args)
3363 {
3364
3365 return (&args->file);
3366 }
3367
3368 /*
3369 * This macro defines the size of a response which contains attribute
3370 * information and one directory entry (whose length is specified by
3371 * the macro parameter). If the incoming request is larger than this,
3372 * then we are guaranteed to be able to return at one directory entry
3373 * if one exists. Therefore, we do not need to check for
3374 * NFS3ERR_TOOSMALL if the requested size is larger then this. If it
3375 * is not, then we need to check to make sure that this error does not
3376 * need to be returned.
3377 *
3378 * NFS3_READDIR_MIN_COUNT is comprised of following :
3379 *
3380 * status - 1 * BYTES_PER_XDR_UNIT
3381 * attr. flag - 1 * BYTES_PER_XDR_UNIT
3382 * cookie verifier - 2 * BYTES_PER_XDR_UNIT
3383 * attributes - NFS3_SIZEOF_FATTR3 * BYTES_PER_XDR_UNIT
3384 * boolean - 1 * BYTES_PER_XDR_UNIT
3385 * file id - 2 * BYTES_PER_XDR_UNIT
3386 * directory name length - 1 * BYTES_PER_XDR_UNIT
3387 * cookie - 2 * BYTES_PER_XDR_UNIT
3388 * end of list - 1 * BYTES_PER_XDR_UNIT
3389 * end of file - 1 * BYTES_PER_XDR_UNIT
3390 * Name length of directory to the nearest byte
3391 */
3392
3393 #define NFS3_READDIR_MIN_COUNT(length) \
3394 ((1 + 1 + 2 + NFS3_SIZEOF_FATTR3 + 1 + 2 + 1 + 2 + 1 + 1) * \
3395 BYTES_PER_XDR_UNIT + roundup((length), BYTES_PER_XDR_UNIT))
3396
3397 /* ARGSUSED */
3398 void
3399 rfs3_readdir(READDIR3args *args, READDIR3res *resp, struct exportinfo *exi,
3400 struct svc_req *req, cred_t *cr)
3401 {
3402 int error;
3403 vnode_t *vp;
3404 struct vattr *vap;
3405 struct vattr va;
3406 struct iovec iov;
3407 struct uio uio;
3408 char *data;
3409 int iseof;
3410 int bufsize;
3411 int namlen;
3412 uint_t count;
3413 struct sockaddr *ca;
3414
3415 vap = NULL;
3416
3417 vp = nfs3_fhtovp(&args->dir, exi);
3418
3419 DTRACE_NFSV3_4(op__readdir__start, struct svc_req *, req,
3420 cred_t *, cr, vnode_t *, vp, READDIR3args *, args);
3421
3422 if (vp == NULL) {
3423 error = ESTALE;
3424 goto out;
3425 }
3426
3427 if (is_system_labeled()) {
3428 bslabel_t *clabel = req->rq_label;
3429
3430 ASSERT(clabel != NULL);
3431 DTRACE_PROBE2(tx__rfs3__log__info__opreaddir__clabel, char *,
3432 "got client label from request(1)", struct svc_req *, req);
3433
3434 if (!blequal(&l_admin_low->tsl_label, clabel)) {
3435 if (!do_rfs_label_check(clabel, vp, DOMINANCE_CHECK,
3436 exi)) {
3437 resp->status = NFS3ERR_ACCES;
3438 goto out1;
3439 }
3440 }
3441 }
3442
3443 (void) VOP_RWLOCK(vp, V_WRITELOCK_FALSE, NULL);
3444
3445 #ifdef DEBUG
3446 if (rfs3_do_pre_op_attr) {
3447 va.va_mask = AT_ALL;
3448 vap = VOP_GETATTR(vp, &va, 0, cr, NULL) ? NULL : &va;
3449 } else
3450 vap = NULL;
3451 #else
3452 va.va_mask = AT_ALL;
3453 vap = VOP_GETATTR(vp, &va, 0, cr, NULL) ? NULL : &va;
3454 #endif
3455
3456 if (vp->v_type != VDIR) {
3457 resp->status = NFS3ERR_NOTDIR;
3458 goto out1;
3459 }
3460
3461 error = VOP_ACCESS(vp, VREAD, 0, cr, NULL);
3462 if (error)
3463 goto out;
3464
3465 /*
3466 * Now don't allow arbitrary count to alloc;
3467 * allow the maximum not to exceed rfs3_tsize()
3468 */
3469 if (args->count > rfs3_tsize(req))
3470 args->count = rfs3_tsize(req);
3471
3472 /*
3473 * Make sure that there is room to read at least one entry
3474 * if any are available.
3475 */
3476 if (args->count < DIRENT64_RECLEN(MAXNAMELEN))
3477 count = DIRENT64_RECLEN(MAXNAMELEN);
3478 else
3479 count = args->count;
3480
3481 data = kmem_alloc(count, KM_SLEEP);
3482
3483 iov.iov_base = data;
3484 iov.iov_len = count;
3485 uio.uio_iov = &iov;
3486 uio.uio_iovcnt = 1;
3487 uio.uio_segflg = UIO_SYSSPACE;
3488 uio.uio_extflg = UIO_COPY_CACHED;
3489 uio.uio_loffset = (offset_t)args->cookie;
3490 uio.uio_resid = count;
3491
3492 error = VOP_READDIR(vp, &uio, cr, &iseof, NULL, 0);
3493
3494 #ifdef DEBUG
3495 if (rfs3_do_post_op_attr) {
3496 va.va_mask = AT_ALL;
3497 vap = VOP_GETATTR(vp, &va, 0, cr, NULL) ? NULL : &va;
3498 } else
3499 vap = NULL;
3500 #else
3501 va.va_mask = AT_ALL;
3502 vap = VOP_GETATTR(vp, &va, 0, cr, NULL) ? NULL : &va;
3503 #endif
3504
3505 if (error) {
3506 kmem_free(data, count);
3507 goto out;
3508 }
3509
3510 /*
3511 * If the count was not large enough to be able to guarantee
3512 * to be able to return at least one entry, then need to
3513 * check to see if NFS3ERR_TOOSMALL should be returned.
3514 */
3515 if (args->count < NFS3_READDIR_MIN_COUNT(MAXNAMELEN)) {
3516 /*
3517 * bufsize is used to keep track of the size of the response.
3518 * It is primed with:
3519 * 1 for the status +
3520 * 1 for the dir_attributes.attributes boolean +
3521 * 2 for the cookie verifier
3522 * all times BYTES_PER_XDR_UNIT to convert from XDR units
3523 * to bytes. If there are directory attributes to be
3524 * returned, then:
3525 * NFS3_SIZEOF_FATTR3 for the dir_attributes.attr fattr3
3526 * time BYTES_PER_XDR_UNIT is added to account for them.
3527 */
3528 bufsize = (1 + 1 + 2) * BYTES_PER_XDR_UNIT;
3529 if (vap != NULL)
3530 bufsize += NFS3_SIZEOF_FATTR3 * BYTES_PER_XDR_UNIT;
3531 /*
3532 * An entry is composed of:
3533 * 1 for the true/false list indicator +
3534 * 2 for the fileid +
3535 * 1 for the length of the name +
3536 * 2 for the cookie +
3537 * all times BYTES_PER_XDR_UNIT to convert from
3538 * XDR units to bytes, plus the length of the name
3539 * rounded up to the nearest BYTES_PER_XDR_UNIT.
3540 */
3541 if (count != uio.uio_resid) {
3542 namlen = strlen(((struct dirent64 *)data)->d_name);
3543 bufsize += (1 + 2 + 1 + 2) * BYTES_PER_XDR_UNIT +
3544 roundup(namlen, BYTES_PER_XDR_UNIT);
3545 }
3546 /*
3547 * We need to check to see if the number of bytes left
3548 * to go into the buffer will actually fit into the
3549 * buffer. This is calculated as the size of this
3550 * entry plus:
3551 * 1 for the true/false list indicator +
3552 * 1 for the eof indicator
3553 * times BYTES_PER_XDR_UNIT to convert from from
3554 * XDR units to bytes.
3555 */
3556 bufsize += (1 + 1) * BYTES_PER_XDR_UNIT;
3557 if (bufsize > args->count) {
3558 kmem_free(data, count);
3559 resp->status = NFS3ERR_TOOSMALL;
3560 goto out1;
3561 }
3562 }
3563
3564 /*
3565 * Have a valid readir buffer for the native character
3566 * set. Need to check if a conversion is necessary and
3567 * potentially rewrite the whole buffer. Note that if the
3568 * conversion expands names enough, the structure may not
3569 * fit. In this case, we need to drop entries until if fits
3570 * and patch the counts in order that the next readdir will
3571 * get the correct entries.
3572 */
3573 ca = (struct sockaddr *)svc_getrpccaller(req->rq_xprt)->buf;
3574 data = nfscmd_convdirent(ca, exi, data, count, &resp->status);
3575
3576
3577 VOP_RWUNLOCK(vp, V_WRITELOCK_FALSE, NULL);
3578
3579 #if 0 /* notyet */
3580 /*
3581 * Don't do this. It causes local disk writes when just
3582 * reading the file and the overhead is deemed larger
3583 * than the benefit.
3584 */
3585 /*
3586 * Force modified metadata out to stable storage.
3587 */
3588 (void) VOP_FSYNC(vp, FNODSYNC, cr, NULL);
3589 #endif
3590
3591 resp->status = NFS3_OK;
3592 vattr_to_post_op_attr(vap, &resp->resok.dir_attributes);
3593 resp->resok.cookieverf = 0;
3594 resp->resok.reply.entries = (entry3 *)data;
3595 resp->resok.reply.eof = iseof;
3596 resp->resok.size = count - uio.uio_resid;
3597 resp->resok.count = args->count;
3598 resp->resok.freecount = count;
3599
3600 DTRACE_NFSV3_4(op__readdir__done, struct svc_req *, req,
3601 cred_t *, cr, vnode_t *, vp, READDIR3res *, resp);
3602
3603 VN_RELE(vp);
3604
3605 return;
3606
3607 out:
3608 if (curthread->t_flag & T_WOULDBLOCK) {
3609 curthread->t_flag &= ~T_WOULDBLOCK;
3610 resp->status = NFS3ERR_JUKEBOX;
3611 } else
3612 resp->status = puterrno3(error);
3613 out1:
3614 DTRACE_NFSV3_4(op__readdir__done, struct svc_req *, req,
3615 cred_t *, cr, vnode_t *, vp, READDIR3res *, resp);
3616
3617 if (vp != NULL) {
3618 VOP_RWUNLOCK(vp, V_WRITELOCK_FALSE, NULL);
3619 VN_RELE(vp);
3620 }
3621 vattr_to_post_op_attr(vap, &resp->resfail.dir_attributes);
3622 }
3623
3624 void *
3625 rfs3_readdir_getfh(READDIR3args *args)
3626 {
3627
3628 return (&args->dir);
3629 }
3630
3631 void
3632 rfs3_readdir_free(READDIR3res *resp)
3633 {
3634
3635 if (resp->status == NFS3_OK)
3636 kmem_free(resp->resok.reply.entries, resp->resok.freecount);
3637 }
3638
3639 #ifdef nextdp
3640 #undef nextdp
3641 #endif
3642 #define nextdp(dp) ((struct dirent64 *)((char *)(dp) + (dp)->d_reclen))
3643
3644 /*
3645 * This macro computes the size of a response which contains
3646 * one directory entry including the attributes as well as file handle.
3647 * If the incoming request is larger than this, then we are guaranteed to be
3648 * able to return at least one more directory entry if one exists.
3649 *
3650 * NFS3_READDIRPLUS_ENTRY is made up of the following:
3651 *
3652 * boolean - 1 * BYTES_PER_XDR_UNIT
3653 * file id - 2 * BYTES_PER_XDR_UNIT
3654 * directory name length - 1 * BYTES_PER_XDR_UNIT
3655 * cookie - 2 * BYTES_PER_XDR_UNIT
3656 * attribute flag - 1 * BYTES_PER_XDR_UNIT
3657 * attributes - NFS3_SIZEOF_FATTR3 * BYTES_PER_XDR_UNIT
3658 * status byte for file handle - 1 * BYTES_PER_XDR_UNIT
3659 * length of a file handle - 1 * BYTES_PER_XDR_UNIT
3660 * Maximum length of a file handle (NFS3_MAXFHSIZE)
3661 * name length of the entry to the nearest bytes
3662 */
3663 #define NFS3_READDIRPLUS_ENTRY(namelen) \
3664 ((1 + 2 + 1 + 2 + 1 + NFS3_SIZEOF_FATTR3 + 1 + 1) * \
3665 BYTES_PER_XDR_UNIT + \
3666 NFS3_MAXFHSIZE + roundup(namelen, BYTES_PER_XDR_UNIT))
3667
3668 static int rfs3_readdir_unit = MAXBSIZE;
3669
3670 /* ARGSUSED */
3671 void
3672 rfs3_readdirplus(READDIRPLUS3args *args, READDIRPLUS3res *resp,
3673 struct exportinfo *exi, struct svc_req *req, cred_t *cr)
3674 {
3675 int error;
3676 vnode_t *vp;
3677 struct vattr *vap;
3678 struct vattr va;
3679 struct iovec iov;
3680 struct uio uio;
3681 char *data;
3682 int iseof;
3683 struct dirent64 *dp;
3684 vnode_t *nvp;
3685 struct vattr *nvap;
3686 struct vattr nva;
3687 entryplus3_info *infop = NULL;
3688 int size = 0;
3689 int nents = 0;
3690 int bufsize = 0;
3691 int entrysize = 0;
3692 int tofit = 0;
3693 int rd_unit = rfs3_readdir_unit;
3694 int prev_len;
3695 int space_left;
3696 int i;
3697 uint_t *namlen = NULL;
3698 char *ndata = NULL;
3699 struct sockaddr *ca;
3700 size_t ret;
3701
3702 vap = NULL;
3703
3704 vp = nfs3_fhtovp(&args->dir, exi);
3705
3706 DTRACE_NFSV3_4(op__readdirplus__start, struct svc_req *, req,
3707 cred_t *, cr, vnode_t *, vp, READDIRPLUS3args *, args);
3708
3709 if (vp == NULL) {
3710 error = ESTALE;
3711 goto out;
3712 }
3713
3714 if (is_system_labeled()) {
3715 bslabel_t *clabel = req->rq_label;
3716
3717 ASSERT(clabel != NULL);
3718 DTRACE_PROBE2(tx__rfs3__log__info__opreaddirplus__clabel,
3719 char *, "got client label from request(1)",
3720 struct svc_req *, req);
3721
3722 if (!blequal(&l_admin_low->tsl_label, clabel)) {
3723 if (!do_rfs_label_check(clabel, vp, DOMINANCE_CHECK,
3724 exi)) {
3725 resp->status = NFS3ERR_ACCES;
3726 goto out1;
3727 }
3728 }
3729 }
3730
3731 (void) VOP_RWLOCK(vp, V_WRITELOCK_FALSE, NULL);
3732
3733 #ifdef DEBUG
3734 if (rfs3_do_pre_op_attr) {
3735 va.va_mask = AT_ALL;
3736 vap = VOP_GETATTR(vp, &va, 0, cr, NULL) ? NULL : &va;
3737 } else
3738 vap = NULL;
3739 #else
3740 va.va_mask = AT_ALL;
3741 vap = VOP_GETATTR(vp, &va, 0, cr, NULL) ? NULL : &va;
3742 #endif
3743
3744 if (vp->v_type != VDIR) {
3745 error = ENOTDIR;
3746 goto out;
3747 }
3748
3749 error = VOP_ACCESS(vp, VREAD, 0, cr, NULL);
3750 if (error)
3751 goto out;
3752
3753 /*
3754 * Don't allow arbitrary counts for allocation
3755 */
3756 if (args->maxcount > rfs3_tsize(req))
3757 args->maxcount = rfs3_tsize(req);
3758
3759 /*
3760 * Make sure that there is room to read at least one entry
3761 * if any are available
3762 */
3763 args->dircount = MIN(args->dircount, args->maxcount);
3764
3765 if (args->dircount < DIRENT64_RECLEN(MAXNAMELEN))
3766 args->dircount = DIRENT64_RECLEN(MAXNAMELEN);
3767
3768 /*
3769 * This allocation relies on a minimum directory entry
3770 * being roughly 24 bytes. Therefore, the namlen array
3771 * will have enough space based on the maximum number of
3772 * entries to read.
3773 */
3774 namlen = kmem_alloc(args->dircount, KM_SLEEP);
3775
3776 space_left = args->dircount;
3777 data = kmem_alloc(args->dircount, KM_SLEEP);
3778 dp = (struct dirent64 *)data;
3779 uio.uio_iov = &iov;
3780 uio.uio_iovcnt = 1;
3781 uio.uio_segflg = UIO_SYSSPACE;
3782 uio.uio_extflg = UIO_COPY_CACHED;
3783 uio.uio_loffset = (offset_t)args->cookie;
3784
3785 /*
3786 * bufsize is used to keep track of the size of the response as we
3787 * get post op attributes and filehandles for each entry. This is
3788 * an optimization as the server may have read more entries than will
3789 * fit in the buffer specified by maxcount. We stop calculating
3790 * post op attributes and filehandles once we have exceeded maxcount.
3791 * This will minimize the effect of truncation.
3792 *
3793 * It is primed with:
3794 * 1 for the status +
3795 * 1 for the dir_attributes.attributes boolean +
3796 * 2 for the cookie verifier
3797 * all times BYTES_PER_XDR_UNIT to convert from XDR units
3798 * to bytes. If there are directory attributes to be
3799 * returned, then:
3800 * NFS3_SIZEOF_FATTR3 for the dir_attributes.attr fattr3
3801 * time BYTES_PER_XDR_UNIT is added to account for them.
3802 */
3803 bufsize = (1 + 1 + 2) * BYTES_PER_XDR_UNIT;
3804 if (vap != NULL)
3805 bufsize += NFS3_SIZEOF_FATTR3 * BYTES_PER_XDR_UNIT;
3806
3807 getmoredents:
3808 /*
3809 * Here we make a check so that our read unit is not larger than
3810 * the space left in the buffer.
3811 */
3812 rd_unit = MIN(rd_unit, space_left);
3813 iov.iov_base = (char *)dp;
3814 iov.iov_len = rd_unit;
3815 uio.uio_resid = rd_unit;
3816 prev_len = rd_unit;
3817
3818 error = VOP_READDIR(vp, &uio, cr, &iseof, NULL, 0);
3819
3820 if (error) {
3821 kmem_free(data, args->dircount);
3822 goto out;
3823 }
3824
3825 if (uio.uio_resid == prev_len && !iseof) {
3826 if (nents == 0) {
3827 kmem_free(data, args->dircount);
3828 resp->status = NFS3ERR_TOOSMALL;
3829 goto out1;
3830 }
3831
3832 /*
3833 * We could not get any more entries, so get the attributes
3834 * and filehandle for the entries already obtained.
3835 */
3836 goto good;
3837 }
3838
3839 /*
3840 * We estimate the size of the response by assuming the
3841 * entry exists and attributes and filehandle are also valid
3842 */
3843 for (size = prev_len - uio.uio_resid;
3844 size > 0;
3845 size -= dp->d_reclen, dp = nextdp(dp)) {
3846
3847 if (dp->d_ino == 0) {
3848 nents++;
3849 continue;
3850 }
3851
3852 namlen[nents] = strlen(dp->d_name);
3853 entrysize = NFS3_READDIRPLUS_ENTRY(namlen[nents]);
3854
3855 /*
3856 * We need to check to see if the number of bytes left
3857 * to go into the buffer will actually fit into the
3858 * buffer. This is calculated as the size of this
3859 * entry plus:
3860 * 1 for the true/false list indicator +
3861 * 1 for the eof indicator
3862 * times BYTES_PER_XDR_UNIT to convert from XDR units
3863 * to bytes.
3864 *
3865 * Also check the dircount limit against the first entry read
3866 *
3867 */
3868 tofit = entrysize + (1 + 1) * BYTES_PER_XDR_UNIT;
3869 if (bufsize + tofit > args->maxcount) {
3870 /*
3871 * We make a check here to see if this was the
3872 * first entry being measured. If so, then maxcount
3873 * was too small to begin with and so we need to
3874 * return with NFS3ERR_TOOSMALL.
3875 */
3876 if (nents == 0) {
3877 kmem_free(data, args->dircount);
3878 resp->status = NFS3ERR_TOOSMALL;
3879 goto out1;
3880 }
3881 iseof = FALSE;
3882 goto good;
3883 }
3884 bufsize += entrysize;
3885 nents++;
3886 }
3887
3888 /*
3889 * If there is enough room to fit at least 1 more entry including
3890 * post op attributes and filehandle in the buffer AND that we haven't
3891 * exceeded dircount then go back and get some more.
3892 */
3893 if (!iseof &&
3894 (args->maxcount - bufsize) >= NFS3_READDIRPLUS_ENTRY(MAXNAMELEN)) {
3895 space_left -= (prev_len - uio.uio_resid);
3896 if (space_left >= DIRENT64_RECLEN(MAXNAMELEN))
3897 goto getmoredents;
3898
3899 /* else, fall through */
3900 }
3901
3902 good:
3903
3904 #ifdef DEBUG
3905 if (rfs3_do_post_op_attr) {
3906 va.va_mask = AT_ALL;
3907 vap = VOP_GETATTR(vp, &va, 0, cr, NULL) ? NULL : &va;
3908 } else
3909 vap = NULL;
3910 #else
3911 va.va_mask = AT_ALL;
3912 vap = VOP_GETATTR(vp, &va, 0, cr, NULL) ? NULL : &va;
3913 #endif
3914
3915 VOP_RWUNLOCK(vp, V_WRITELOCK_FALSE, NULL);
3916
3917 infop = kmem_alloc(nents * sizeof (struct entryplus3_info), KM_SLEEP);
3918 resp->resok.infop = infop;
3919
3920 dp = (struct dirent64 *)data;
3921 for (i = 0; i < nents; i++) {
3922
3923 if (dp->d_ino == 0) {
3924 infop[i].attr.attributes = FALSE;
3925 infop[i].fh.handle_follows = FALSE;
3926 dp = nextdp(dp);
3927 continue;
3928 }
3929
3930 infop[i].namelen = namlen[i];
3931
3932 error = VOP_LOOKUP(vp, dp->d_name, &nvp, NULL, 0, NULL, cr,
3933 NULL, NULL, NULL);
3934 if (error) {
3935 infop[i].attr.attributes = FALSE;
3936 infop[i].fh.handle_follows = FALSE;
3937 dp = nextdp(dp);
3938 continue;
3939 }
3940
3941 #ifdef DEBUG
3942 if (rfs3_do_post_op_attr) {
3943 nva.va_mask = AT_ALL;
3944 nvap = rfs4_delegated_getattr(nvp, &nva, 0, cr) ?
3945 NULL : &nva;
3946 } else
3947 nvap = NULL;
3948 #else
3949 nva.va_mask = AT_ALL;
3950 nvap = rfs4_delegated_getattr(nvp, &nva, 0, cr) ? NULL : &nva;
3951 #endif
3952 /* Lie about the object type for a referral */
3953 if (vn_is_nfs_reparse(nvp, cr))
3954 nvap->va_type = VLNK;
3955
3956 vattr_to_post_op_attr(nvap, &infop[i].attr);
3957
3958 #ifdef DEBUG
3959 if (!rfs3_do_post_op_fh3)
3960 infop[i].fh.handle_follows = FALSE;
3961 else {
3962 #endif
3963 error = makefh3(&infop[i].fh.handle, nvp, exi);
3964 if (!error)
3965 infop[i].fh.handle_follows = TRUE;
3966 else
3967 infop[i].fh.handle_follows = FALSE;
3968 #ifdef DEBUG
3969 }
3970 #endif
3971
3972 VN_RELE(nvp);
3973 dp = nextdp(dp);
3974 }
3975
3976 ca = (struct sockaddr *)svc_getrpccaller(req->rq_xprt)->buf;
3977 ret = nfscmd_convdirplus(ca, exi, data, nents, args->dircount, &ndata);
3978 if (ndata == NULL)
3979 ndata = data;
3980
3981 if (ret > 0) {
3982 /*
3983 * We had to drop one or more entries in order to fit
3984 * during the character conversion. We need to patch
3985 * up the size and eof info.
3986 */
3987 if (iseof)
3988 iseof = FALSE;
3989
3990 ret = nfscmd_dropped_entrysize((struct dirent64 *)data,
3991 nents, ret);
3992 }
3993
3994
3995 #if 0 /* notyet */
3996 /*
3997 * Don't do this. It causes local disk writes when just
3998 * reading the file and the overhead is deemed larger
3999 * than the benefit.
4000 */
4001 /*
4002 * Force modified metadata out to stable storage.
4003 */
4004 (void) VOP_FSYNC(vp, FNODSYNC, cr, NULL);
4005 #endif
4006
4007 kmem_free(namlen, args->dircount);
4008
4009 resp->status = NFS3_OK;
4010 vattr_to_post_op_attr(vap, &resp->resok.dir_attributes);
4011 resp->resok.cookieverf = 0;
4012 resp->resok.reply.entries = (entryplus3 *)ndata;
4013 resp->resok.reply.eof = iseof;
4014 resp->resok.size = nents;
4015 resp->resok.count = args->dircount - ret;
4016 resp->resok.maxcount = args->maxcount;
4017
4018 DTRACE_NFSV3_4(op__readdirplus__done, struct svc_req *, req,
4019 cred_t *, cr, vnode_t *, vp, READDIRPLUS3res *, resp);
4020 if (ndata != data)
4021 kmem_free(data, args->dircount);
4022
4023
4024 VN_RELE(vp);
4025
4026 return;
4027
4028 out:
4029 if (curthread->t_flag & T_WOULDBLOCK) {
4030 curthread->t_flag &= ~T_WOULDBLOCK;
4031 resp->status = NFS3ERR_JUKEBOX;
4032 } else {
4033 resp->status = puterrno3(error);
4034 }
4035 out1:
4036 DTRACE_NFSV3_4(op__readdirplus__done, struct svc_req *, req,
4037 cred_t *, cr, vnode_t *, vp, READDIRPLUS3res *, resp);
4038
4039 if (vp != NULL) {
4040 VOP_RWUNLOCK(vp, V_WRITELOCK_FALSE, NULL);
4041 VN_RELE(vp);
4042 }
4043
4044 if (namlen != NULL)
4045 kmem_free(namlen, args->dircount);
4046
4047 vattr_to_post_op_attr(vap, &resp->resfail.dir_attributes);
4048 }
4049
4050 void *
4051 rfs3_readdirplus_getfh(READDIRPLUS3args *args)
4052 {
4053
4054 return (&args->dir);
4055 }
4056
4057 void
4058 rfs3_readdirplus_free(READDIRPLUS3res *resp)
4059 {
4060
4061 if (resp->status == NFS3_OK) {
4062 kmem_free(resp->resok.reply.entries, resp->resok.count);
4063 kmem_free(resp->resok.infop,
4064 resp->resok.size * sizeof (struct entryplus3_info));
4065 }
4066 }
4067
4068 /* ARGSUSED */
4069 void
4070 rfs3_fsstat(FSSTAT3args *args, FSSTAT3res *resp, struct exportinfo *exi,
4071 struct svc_req *req, cred_t *cr)
4072 {
4073 int error;
4074 vnode_t *vp;
4075 struct vattr *vap;
4076 struct vattr va;
4077 struct statvfs64 sb;
4078
4079 vap = NULL;
4080
4081 vp = nfs3_fhtovp(&args->fsroot, exi);
4082
4083 DTRACE_NFSV3_4(op__fsstat__start, struct svc_req *, req,
4084 cred_t *, cr, vnode_t *, vp, FSSTAT3args *, args);
4085
4086 if (vp == NULL) {
4087 error = ESTALE;
4088 goto out;
4089 }
4090
4091 if (is_system_labeled()) {
4092 bslabel_t *clabel = req->rq_label;
4093
4094 ASSERT(clabel != NULL);
4095 DTRACE_PROBE2(tx__rfs3__log__info__opfsstat__clabel, char *,
4096 "got client label from request(1)", struct svc_req *, req);
4097
4098 if (!blequal(&l_admin_low->tsl_label, clabel)) {
4099 if (!do_rfs_label_check(clabel, vp, DOMINANCE_CHECK,
4100 exi)) {
4101 resp->status = NFS3ERR_ACCES;
4102 goto out1;
4103 }
4104 }
4105 }
4106
4107 error = VFS_STATVFS(vp->v_vfsp, &sb);
4108
4109 #ifdef DEBUG
4110 if (rfs3_do_post_op_attr) {
4111 va.va_mask = AT_ALL;
4112 vap = VOP_GETATTR(vp, &va, 0, cr, NULL) ? NULL : &va;
4113 } else
4114 vap = NULL;
4115 #else
4116 va.va_mask = AT_ALL;
4117 vap = VOP_GETATTR(vp, &va, 0, cr, NULL) ? NULL : &va;
4118 #endif
4119
4120 if (error)
4121 goto out;
4122
4123 resp->status = NFS3_OK;
4124 vattr_to_post_op_attr(vap, &resp->resok.obj_attributes);
4125 if (sb.f_blocks != (fsblkcnt64_t)-1)
4126 resp->resok.tbytes = (size3)sb.f_frsize * (size3)sb.f_blocks;
4127 else
4128 resp->resok.tbytes = (size3)sb.f_blocks;
4129 if (sb.f_bfree != (fsblkcnt64_t)-1)
4130 resp->resok.fbytes = (size3)sb.f_frsize * (size3)sb.f_bfree;
4131 else
4132 resp->resok.fbytes = (size3)sb.f_bfree;
4133 if (sb.f_bavail != (fsblkcnt64_t)-1)
4134 resp->resok.abytes = (size3)sb.f_frsize * (size3)sb.f_bavail;
4135 else
4136 resp->resok.abytes = (size3)sb.f_bavail;
4137 resp->resok.tfiles = (size3)sb.f_files;
4138 resp->resok.ffiles = (size3)sb.f_ffree;
4139 resp->resok.afiles = (size3)sb.f_favail;
4140 resp->resok.invarsec = 0;
4141
4142 DTRACE_NFSV3_4(op__fsstat__done, struct svc_req *, req,
4143 cred_t *, cr, vnode_t *, vp, FSSTAT3res *, resp);
4144 VN_RELE(vp);
4145
4146 return;
4147
4148 out:
4149 if (curthread->t_flag & T_WOULDBLOCK) {
4150 curthread->t_flag &= ~T_WOULDBLOCK;
4151 resp->status = NFS3ERR_JUKEBOX;
4152 } else
4153 resp->status = puterrno3(error);
4154 out1:
4155 DTRACE_NFSV3_4(op__fsstat__done, struct svc_req *, req,
4156 cred_t *, cr, vnode_t *, vp, FSSTAT3res *, resp);
4157
4158 if (vp != NULL)
4159 VN_RELE(vp);
4160 vattr_to_post_op_attr(vap, &resp->resfail.obj_attributes);
4161 }
4162
4163 void *
4164 rfs3_fsstat_getfh(FSSTAT3args *args)
4165 {
4166
4167 return (&args->fsroot);
4168 }
4169
4170 void
4171 rfs3_fsinfo(FSINFO3args *args, FSINFO3res *resp, struct exportinfo *exi,
4172 struct svc_req *req, cred_t *cr)
4173 {
4174 vnode_t *vp;
4175 struct vattr *vap;
4176 struct vattr va;
4177 uint32_t xfer_size;
4178 ulong_t l = 0;
4179 int error;
4180
4181 vp = nfs3_fhtovp(&args->fsroot, exi);
4182
4183 DTRACE_NFSV3_4(op__fsinfo__start, struct svc_req *, req,
4184 cred_t *, cr, vnode_t *, vp, FSINFO3args *, args);
4185
4186 if (vp == NULL) {
4187 if (curthread->t_flag & T_WOULDBLOCK) {
4188 curthread->t_flag &= ~T_WOULDBLOCK;
4189 resp->status = NFS3ERR_JUKEBOX;
4190 } else
4191 resp->status = NFS3ERR_STALE;
4192 vattr_to_post_op_attr(NULL, &resp->resfail.obj_attributes);
4193 goto out;
4194 }
4195
4196 if (is_system_labeled()) {
4197 bslabel_t *clabel = req->rq_label;
4198
4199 ASSERT(clabel != NULL);
4200 DTRACE_PROBE2(tx__rfs3__log__info__opfsinfo__clabel, char *,
4201 "got client label from request(1)", struct svc_req *, req);
4202
4203 if (!blequal(&l_admin_low->tsl_label, clabel)) {
4204 if (!do_rfs_label_check(clabel, vp, DOMINANCE_CHECK,
4205 exi)) {
4206 resp->status = NFS3ERR_STALE;
4207 vattr_to_post_op_attr(NULL,
4208 &resp->resfail.obj_attributes);
4209 goto out;
4210 }
4211 }
4212 }
4213
4214 #ifdef DEBUG
4215 if (rfs3_do_post_op_attr) {
4216 va.va_mask = AT_ALL;
4217 vap = VOP_GETATTR(vp, &va, 0, cr, NULL) ? NULL : &va;
4218 } else
4219 vap = NULL;
4220 #else
4221 va.va_mask = AT_ALL;
4222 vap = VOP_GETATTR(vp, &va, 0, cr, NULL) ? NULL : &va;
4223 #endif
4224
4225 resp->status = NFS3_OK;
4226 vattr_to_post_op_attr(vap, &resp->resok.obj_attributes);
4227 xfer_size = rfs3_tsize(req);
4228 resp->resok.rtmax = xfer_size;
4229 resp->resok.rtpref = xfer_size;
4230 resp->resok.rtmult = DEV_BSIZE;
4231 resp->resok.wtmax = xfer_size;
4232 resp->resok.wtpref = xfer_size;
4233 resp->resok.wtmult = DEV_BSIZE;
4234 resp->resok.dtpref = MAXBSIZE;
4235
4236 /*
4237 * Large file spec: want maxfilesize based on limit of
4238 * underlying filesystem. We can guess 2^31-1 if need be.
4239 */
4240 error = VOP_PATHCONF(vp, _PC_FILESIZEBITS, &l, cr, NULL);
4241 if (error) {
4242 resp->status = puterrno3(error);
4243 goto out;
4244 }
4245
4246 /*
4247 * If the underlying file system does not support _PC_FILESIZEBITS,
4248 * return a reasonable default. Note that error code on VOP_PATHCONF
4249 * will be 0, even if the underlying file system does not support
4250 * _PC_FILESIZEBITS.
4251 */
4252 if (l == (ulong_t)-1) {
4253 resp->resok.maxfilesize = MAXOFF32_T;
4254 } else {
4255 if (l >= (sizeof (uint64_t) * 8))
4256 resp->resok.maxfilesize = INT64_MAX;
4257 else
4258 resp->resok.maxfilesize = (1LL << (l-1)) - 1;
4259 }
4260
4261 resp->resok.time_delta.seconds = 0;
4262 resp->resok.time_delta.nseconds = 1000;
4263 resp->resok.properties = FSF3_LINK | FSF3_SYMLINK |
4264 FSF3_HOMOGENEOUS | FSF3_CANSETTIME;
4265
4266 DTRACE_NFSV3_4(op__fsinfo__done, struct svc_req *, req,
4267 cred_t *, cr, vnode_t *, vp, FSINFO3res *, resp);
4268
4269 VN_RELE(vp);
4270
4271 return;
4272
4273 out:
4274 DTRACE_NFSV3_4(op__fsinfo__done, struct svc_req *, req,
4275 cred_t *, cr, vnode_t *, NULL, FSINFO3res *, resp);
4276 if (vp != NULL)
4277 VN_RELE(vp);
4278 }
4279
4280 void *
4281 rfs3_fsinfo_getfh(FSINFO3args *args)
4282 {
4283
4284 return (&args->fsroot);
4285 }
4286
4287 /* ARGSUSED */
4288 void
4289 rfs3_pathconf(PATHCONF3args *args, PATHCONF3res *resp, struct exportinfo *exi,
4290 struct svc_req *req, cred_t *cr)
4291 {
4292 int error;
4293 vnode_t *vp;
4294 struct vattr *vap;
4295 struct vattr va;
4296 ulong_t val;
4297
4298 vap = NULL;
4299
4300 vp = nfs3_fhtovp(&args->object, exi);
4301
4302 DTRACE_NFSV3_4(op__pathconf__start, struct svc_req *, req,
4303 cred_t *, cr, vnode_t *, vp, PATHCONF3args *, args);
4304
4305 if (vp == NULL) {
4306 error = ESTALE;
4307 goto out;
4308 }
4309
4310 if (is_system_labeled()) {
4311 bslabel_t *clabel = req->rq_label;
4312
4313 ASSERT(clabel != NULL);
4314 DTRACE_PROBE2(tx__rfs3__log__info__oppathconf__clabel, char *,
4315 "got client label from request(1)", struct svc_req *, req);
4316
4317 if (!blequal(&l_admin_low->tsl_label, clabel)) {
4318 if (!do_rfs_label_check(clabel, vp, DOMINANCE_CHECK,
4319 exi)) {
4320 resp->status = NFS3ERR_ACCES;
4321 goto out1;
4322 }
4323 }
4324 }
4325
4326 #ifdef DEBUG
4327 if (rfs3_do_post_op_attr) {
4328 va.va_mask = AT_ALL;
4329 vap = VOP_GETATTR(vp, &va, 0, cr, NULL) ? NULL : &va;
4330 } else
4331 vap = NULL;
4332 #else
4333 va.va_mask = AT_ALL;
4334 vap = VOP_GETATTR(vp, &va, 0, cr, NULL) ? NULL : &va;
4335 #endif
4336
4337 error = VOP_PATHCONF(vp, _PC_LINK_MAX, &val, cr, NULL);
4338 if (error)
4339 goto out;
4340 resp->resok.info.link_max = (uint32)val;
4341
4342 error = VOP_PATHCONF(vp, _PC_NAME_MAX, &val, cr, NULL);
4343 if (error)
4344 goto out;
4345 resp->resok.info.name_max = (uint32)val;
4346
4347 error = VOP_PATHCONF(vp, _PC_NO_TRUNC, &val, cr, NULL);
4348 if (error)
4349 goto out;
4350 if (val == 1)
4351 resp->resok.info.no_trunc = TRUE;
4352 else
4353 resp->resok.info.no_trunc = FALSE;
4354
4355 error = VOP_PATHCONF(vp, _PC_CHOWN_RESTRICTED, &val, cr, NULL);
4356 if (error)
4357 goto out;
4358 if (val == 1)
4359 resp->resok.info.chown_restricted = TRUE;
4360 else
4361 resp->resok.info.chown_restricted = FALSE;
4362
4363 resp->status = NFS3_OK;
4364 vattr_to_post_op_attr(vap, &resp->resok.obj_attributes);
4365 resp->resok.info.case_insensitive = FALSE;
4366 resp->resok.info.case_preserving = TRUE;
4367 DTRACE_NFSV3_4(op__pathconf__done, struct svc_req *, req,
4368 cred_t *, cr, vnode_t *, vp, PATHCONF3res *, resp);
4369 VN_RELE(vp);
4370 return;
4371
4372 out:
4373 if (curthread->t_flag & T_WOULDBLOCK) {
4374 curthread->t_flag &= ~T_WOULDBLOCK;
4375 resp->status = NFS3ERR_JUKEBOX;
4376 } else
4377 resp->status = puterrno3(error);
4378 out1:
4379 DTRACE_NFSV3_4(op__pathconf__done, struct svc_req *, req,
4380 cred_t *, cr, vnode_t *, vp, PATHCONF3res *, resp);
4381 if (vp != NULL)
4382 VN_RELE(vp);
4383 vattr_to_post_op_attr(vap, &resp->resfail.obj_attributes);
4384 }
4385
4386 void *
4387 rfs3_pathconf_getfh(PATHCONF3args *args)
4388 {
4389
4390 return (&args->object);
4391 }
4392
4393 void
4394 rfs3_commit(COMMIT3args *args, COMMIT3res *resp, struct exportinfo *exi,
4395 struct svc_req *req, cred_t *cr)
4396 {
4397 int error;
4398 vnode_t *vp;
4399 struct vattr *bvap;
4400 struct vattr bva;
4401 struct vattr *avap;
4402 struct vattr ava;
4403
4404 bvap = NULL;
4405 avap = NULL;
4406
4407 vp = nfs3_fhtovp(&args->file, exi);
4408
4409 DTRACE_NFSV3_4(op__commit__start, struct svc_req *, req,
4410 cred_t *, cr, vnode_t *, vp, COMMIT3args *, args);
4411
4412 if (vp == NULL) {
4413 error = ESTALE;
4414 goto out;
4415 }
4416
4417 bva.va_mask = AT_ALL;
4418 error = VOP_GETATTR(vp, &bva, 0, cr, NULL);
4419
4420 /*
4421 * If we can't get the attributes, then we can't do the
4422 * right access checking. So, we'll fail the request.
4423 */
4424 if (error)
4425 goto out;
4426
4427 #ifdef DEBUG
4428 if (rfs3_do_pre_op_attr)
4429 bvap = &bva;
4430 else
4431 bvap = NULL;
4432 #else
4433 bvap = &bva;
4434 #endif
4435
4436 if (rdonly(exi, req)) {
4437 resp->status = NFS3ERR_ROFS;
4438 goto out1;
4439 }
4440
4441 if (vp->v_type != VREG) {
4442 resp->status = NFS3ERR_INVAL;
4443 goto out1;
4444 }
4445
4446 if (is_system_labeled()) {
4447 bslabel_t *clabel = req->rq_label;
4448
4449 ASSERT(clabel != NULL);
4450 DTRACE_PROBE2(tx__rfs3__log__info__opcommit__clabel, char *,
4451 "got client label from request(1)", struct svc_req *, req);
4452
4453 if (!blequal(&l_admin_low->tsl_label, clabel)) {
4454 if (!do_rfs_label_check(clabel, vp, EQUALITY_CHECK,
4455 exi)) {
4456 resp->status = NFS3ERR_ACCES;
4457 goto out1;
4458 }
4459 }
4460 }
4461
4462 if (crgetuid(cr) != bva.va_uid &&
4463 (error = VOP_ACCESS(vp, VWRITE, 0, cr, NULL)))
4464 goto out;
4465
4466 error = VOP_FSYNC(vp, FSYNC, cr, NULL);
4467
4468 #ifdef DEBUG
4469 if (rfs3_do_post_op_attr) {
4470 ava.va_mask = AT_ALL;
4471 avap = VOP_GETATTR(vp, &ava, 0, cr, NULL) ? NULL : &ava;
4472 } else
4473 avap = NULL;
4474 #else
4475 ava.va_mask = AT_ALL;
4476 avap = VOP_GETATTR(vp, &ava, 0, cr, NULL) ? NULL : &ava;
4477 #endif
4478
4479 if (error)
4480 goto out;
4481
4482 resp->status = NFS3_OK;
4483 vattr_to_wcc_data(bvap, avap, &resp->resok.file_wcc);
4484 resp->resok.verf = write3verf;
4485
4486 DTRACE_NFSV3_4(op__commit__done, struct svc_req *, req,
4487 cred_t *, cr, vnode_t *, vp, COMMIT3res *, resp);
4488
4489 VN_RELE(vp);
4490
4491 return;
4492
4493 out:
4494 if (curthread->t_flag & T_WOULDBLOCK) {
4495 curthread->t_flag &= ~T_WOULDBLOCK;
4496 resp->status = NFS3ERR_JUKEBOX;
4497 } else
4498 resp->status = puterrno3(error);
4499 out1:
4500 DTRACE_NFSV3_4(op__commit__done, struct svc_req *, req,
4501 cred_t *, cr, vnode_t *, vp, COMMIT3res *, resp);
4502
4503 if (vp != NULL)
4504 VN_RELE(vp);
4505 vattr_to_wcc_data(bvap, avap, &resp->resfail.file_wcc);
4506 }
4507
4508 void *
4509 rfs3_commit_getfh(COMMIT3args *args)
4510 {
4511
4512 return (&args->file);
4513 }
4514
4515 static int
4516 sattr3_to_vattr(sattr3 *sap, struct vattr *vap)
4517 {
4518
4519 vap->va_mask = 0;
4520
4521 if (sap->mode.set_it) {
4522 vap->va_mode = (mode_t)sap->mode.mode;
4523 vap->va_mask |= AT_MODE;
4524 }
4525 if (sap->uid.set_it) {
4526 vap->va_uid = (uid_t)sap->uid.uid;
4527 vap->va_mask |= AT_UID;
4528 }
4529 if (sap->gid.set_it) {
4530 vap->va_gid = (gid_t)sap->gid.gid;
4531 vap->va_mask |= AT_GID;
4532 }
4533 if (sap->size.set_it) {
4534 if (sap->size.size > (size3)((u_longlong_t)-1))
4535 return (EINVAL);
4536 vap->va_size = sap->size.size;
4537 vap->va_mask |= AT_SIZE;
4538 }
4539 if (sap->atime.set_it == SET_TO_CLIENT_TIME) {
4540 #ifndef _LP64
4541 /* check time validity */
4542 if (!NFS3_TIME_OK(sap->atime.atime.seconds))
4543 return (EOVERFLOW);
4544 #endif
4545 /*
4546 * nfs protocol defines times as unsigned so don't extend sign,
4547 * unless sysadmin set nfs_allow_preepoch_time.
4548 */
4549 NFS_TIME_T_CONVERT(vap->va_atime.tv_sec,
4550 sap->atime.atime.seconds);
4551 vap->va_atime.tv_nsec = (uint32_t)sap->atime.atime.nseconds;
4552 vap->va_mask |= AT_ATIME;
4553 } else if (sap->atime.set_it == SET_TO_SERVER_TIME) {
4554 gethrestime(&vap->va_atime);
4555 vap->va_mask |= AT_ATIME;
4556 }
4557 if (sap->mtime.set_it == SET_TO_CLIENT_TIME) {
4558 #ifndef _LP64
4559 /* check time validity */
4560 if (!NFS3_TIME_OK(sap->mtime.mtime.seconds))
4561 return (EOVERFLOW);
4562 #endif
4563 /*
4564 * nfs protocol defines times as unsigned so don't extend sign,
4565 * unless sysadmin set nfs_allow_preepoch_time.
4566 */
4567 NFS_TIME_T_CONVERT(vap->va_mtime.tv_sec,
4568 sap->mtime.mtime.seconds);
4569 vap->va_mtime.tv_nsec = (uint32_t)sap->mtime.mtime.nseconds;
4570 vap->va_mask |= AT_MTIME;
4571 } else if (sap->mtime.set_it == SET_TO_SERVER_TIME) {
4572 gethrestime(&vap->va_mtime);
4573 vap->va_mask |= AT_MTIME;
4574 }
4575
4576 return (0);
4577 }
4578
4579 static ftype3 vt_to_nf3[] = {
4580 0, NF3REG, NF3DIR, NF3BLK, NF3CHR, NF3LNK, NF3FIFO, 0, 0, NF3SOCK, 0
4581 };
4582
4583 static int
4584 vattr_to_fattr3(struct vattr *vap, fattr3 *fap)
4585 {
4586
4587 ASSERT(vap->va_type >= VNON && vap->va_type <= VBAD);
4588 /* Return error if time or size overflow */
4589 if (! (NFS_VAP_TIME_OK(vap) && NFS3_SIZE_OK(vap->va_size))) {
4590 return (EOVERFLOW);
4591 }
4592 fap->type = vt_to_nf3[vap->va_type];
4593 fap->mode = (mode3)(vap->va_mode & MODEMASK);
4594 fap->nlink = (uint32)vap->va_nlink;
4595 if (vap->va_uid == UID_NOBODY)
4596 fap->uid = (uid3)NFS_UID_NOBODY;
4597 else
4598 fap->uid = (uid3)vap->va_uid;
4599 if (vap->va_gid == GID_NOBODY)
4600 fap->gid = (gid3)NFS_GID_NOBODY;
4601 else
4602 fap->gid = (gid3)vap->va_gid;
4603 fap->size = (size3)vap->va_size;
4604 fap->used = (size3)DEV_BSIZE * (size3)vap->va_nblocks;
4605 fap->rdev.specdata1 = (uint32)getmajor(vap->va_rdev);
4606 fap->rdev.specdata2 = (uint32)getminor(vap->va_rdev);
4607 fap->fsid = (uint64)vap->va_fsid;
4608 fap->fileid = (fileid3)vap->va_nodeid;
4609 fap->atime.seconds = vap->va_atime.tv_sec;
4610 fap->atime.nseconds = vap->va_atime.tv_nsec;
4611 fap->mtime.seconds = vap->va_mtime.tv_sec;
4612 fap->mtime.nseconds = vap->va_mtime.tv_nsec;
4613 fap->ctime.seconds = vap->va_ctime.tv_sec;
4614 fap->ctime.nseconds = vap->va_ctime.tv_nsec;
4615 return (0);
4616 }
4617
4618 static int
4619 vattr_to_wcc_attr(struct vattr *vap, wcc_attr *wccap)
4620 {
4621
4622 /* Return error if time or size overflow */
4623 if (!(NFS_TIME_T_OK(vap->va_mtime.tv_sec) &&
4624 NFS_TIME_T_OK(vap->va_ctime.tv_sec) &&
4625 NFS3_SIZE_OK(vap->va_size))) {
4626 return (EOVERFLOW);
4627 }
4628 wccap->size = (size3)vap->va_size;
4629 wccap->mtime.seconds = vap->va_mtime.tv_sec;
4630 wccap->mtime.nseconds = vap->va_mtime.tv_nsec;
4631 wccap->ctime.seconds = vap->va_ctime.tv_sec;
4632 wccap->ctime.nseconds = vap->va_ctime.tv_nsec;
4633 return (0);
4634 }
4635
4636 static void
4637 vattr_to_pre_op_attr(struct vattr *vap, pre_op_attr *poap)
4638 {
4639
4640 /* don't return attrs if time overflow */
4641 if ((vap != NULL) && !vattr_to_wcc_attr(vap, &poap->attr)) {
4642 poap->attributes = TRUE;
4643 } else
4644 poap->attributes = FALSE;
4645 }
4646
4647 void
4648 vattr_to_post_op_attr(struct vattr *vap, post_op_attr *poap)
4649 {
4650
4651 /* don't return attrs if time overflow */
4652 if ((vap != NULL) && !vattr_to_fattr3(vap, &poap->attr)) {
4653 poap->attributes = TRUE;
4654 } else
4655 poap->attributes = FALSE;
4656 }
4657
4658 static void
4659 vattr_to_wcc_data(struct vattr *bvap, struct vattr *avap, wcc_data *wccp)
4660 {
4661
4662 vattr_to_pre_op_attr(bvap, &wccp->before);
4663 vattr_to_post_op_attr(avap, &wccp->after);
4664 }
4665
4666 void
4667 rfs3_srvrinit(void)
4668 {
4669 struct rfs3_verf_overlay {
4670 uint_t id; /* a "unique" identifier */
4671 int ts; /* a unique timestamp */
4672 } *verfp;
4673 timestruc_t now;
4674
4675 /*
4676 * The following algorithm attempts to find a unique verifier
4677 * to be used as the write verifier returned from the server
4678 * to the client. It is important that this verifier change
4679 * whenever the server reboots. Of secondary importance, it
4680 * is important for the verifier to be unique between two
4681 * different servers.
4682 *
4683 * Thus, an attempt is made to use the system hostid and the
4684 * current time in seconds when the nfssrv kernel module is
4685 * loaded. It is assumed that an NFS server will not be able
4686 * to boot and then to reboot in less than a second. If the
4687 * hostid has not been set, then the current high resolution
4688 * time is used. This will ensure different verifiers each
4689 * time the server reboots and minimize the chances that two
4690 * different servers will have the same verifier.
4691 */
4692
4693 #ifndef lint
4694 /*
4695 * We ASSERT that this constant logic expression is
4696 * always true because in the past, it wasn't.
4697 */
4698 ASSERT(sizeof (*verfp) <= sizeof (write3verf));
4699 #endif
4700
4701 gethrestime(&now);
4702 verfp = (struct rfs3_verf_overlay *)&write3verf;
4703 verfp->ts = (int)now.tv_sec;
4704 verfp->id = zone_get_hostid(NULL);
4705
4706 if (verfp->id == 0)
4707 verfp->id = (uint_t)now.tv_nsec;
4708
4709 nfs3_srv_caller_id = fs_new_caller_id();
4710
4711 }
4712
4713 static int
4714 rdma_setup_read_data3(READ3args *args, READ3resok *rok)
4715 {
4716 struct clist *wcl;
4717 int wlist_len;
4718 count3 count = rok->count;
4719
4720 wcl = args->wlist;
4721 if (rdma_setup_read_chunks(wcl, count, &wlist_len) == FALSE) {
4722 return (FALSE);
4723 }
4724
4725 wcl = args->wlist;
4726 rok->wlist_len = wlist_len;
4727 rok->wlist = wcl;
4728 return (TRUE);
4729 }
4730
4731 void
4732 rfs3_srvrfini(void)
4733 {
4734 /* Nothing to do */
4735 }