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