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 } 4348