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