Lines Matching refs:error
85 int error = 0, lockerror = ENOENT, status, numops, slot;
104 nfsm_chain_build_alloc_init(error, &nmreq, 17 * NFSX_UNSIGNED);
105 nfsm_chain_add_compound_header(error, &nmreq, "access", numops);
107 nfsm_chain_add_32(error, &nmreq, NFS_OP_PUTFH);
108 nfsm_chain_add_fh(error, &nmreq, nfsvers, np->n_fhp, np->n_fhsize);
110 nfsm_chain_add_32(error, &nmreq, NFS_OP_ACCESS);
111 nfsm_chain_add_32(error, &nmreq, *access);
113 nfsm_chain_add_32(error, &nmreq, NFS_OP_GETATTR);
114 nfsm_chain_add_bitmap_supported(error, &nmreq, nfs_getattr_bitmap, nmp, np);
115 nfsm_chain_build_done(error, &nmreq);
116 nfsm_assert(error, (numops == 0), EPROTO);
117 nfsmout_if(error);
118 error = nfs_request2(np, NULL, &nmreq, NFSPROC4_COMPOUND,
123 error = lockerror;
124 nfsm_chain_skip_tag(error, &nmrep);
125 nfsm_chain_get_32(error, &nmrep, numops);
126 nfsm_chain_op_check(error, &nmrep, NFS_OP_PUTFH);
127 nfsm_chain_op_check(error, &nmrep, NFS_OP_ACCESS);
128 nfsm_chain_get_32(error, &nmrep, supported);
129 nfsm_chain_get_32(error, &nmrep, access_result);
130 nfsmout_if(error);
156 nfsm_chain_op_check(error, &nmrep, NFS_OP_GETATTR);
157 nfsm_chain_loadattr(error, &nmrep, np, nfsvers, &xid);
158 nfsmout_if(error);
174 return (error);
189 int error = 0, status, nfsvers, numops, rpcflags = 0, acls;
216 nfsm_chain_build_alloc_init(error, &nmreq, 15 * NFSX_UNSIGNED);
217 nfsm_chain_add_compound_header(error, &nmreq, "getattr", numops);
219 nfsm_chain_add_32(error, &nmreq, NFS_OP_PUTFH);
220 nfsm_chain_add_fh(error, &nmreq, nfsvers, fhp, fhsize);
222 nfsm_chain_add_32(error, &nmreq, NFS_OP_GETATTR);
226 nfsm_chain_add_bitmap_supported(error, &nmreq, bitmap, nmp, np);
227 nfsm_chain_build_done(error, &nmreq);
228 nfsm_assert(error, (numops == 0), EPROTO);
229 nfsmout_if(error);
230 error = nfs_request2(np, mp, &nmreq, NFSPROC4_COMPOUND,
234 nfsm_chain_skip_tag(error, &nmrep);
235 nfsm_chain_get_32(error, &nmrep, numops);
236 nfsm_chain_op_check(error, &nmrep, NFS_OP_PUTFH);
237 nfsm_chain_op_check(error, &nmrep, NFS_OP_GETATTR);
238 nfsmout_if(error);
239 error = nfs4_parsefattr(&nmrep, NULL, nvap, NULL, NULL, NULL);
240 nfsmout_if(error);
249 return (error);
256 int error = 0, lockerror = ENOENT, status, numops;
273 nfsm_chain_build_alloc_init(error, &nmreq, 16 * NFSX_UNSIGNED);
274 nfsm_chain_add_compound_header(error, &nmreq, "readlink", numops);
276 nfsm_chain_add_32(error, &nmreq, NFS_OP_PUTFH);
277 nfsm_chain_add_fh(error, &nmreq, NFS_VER4, np->n_fhp, np->n_fhsize);
279 nfsm_chain_add_32(error, &nmreq, NFS_OP_GETATTR);
280 nfsm_chain_add_bitmap_supported(error, &nmreq, nfs_getattr_bitmap, nmp, np);
282 nfsm_chain_add_32(error, &nmreq, NFS_OP_READLINK);
283 nfsm_chain_build_done(error, &nmreq);
284 nfsm_assert(error, (numops == 0), EPROTO);
285 nfsmout_if(error);
286 error = nfs_request(np, NULL, &nmreq, NFSPROC4_COMPOUND, ctx, &si, &nmrep, &xid, &status);
289 error = lockerror;
290 nfsm_chain_skip_tag(error, &nmrep);
291 nfsm_chain_get_32(error, &nmrep, numops);
292 nfsm_chain_op_check(error, &nmrep, NFS_OP_PUTFH);
293 nfsm_chain_op_check(error, &nmrep, NFS_OP_GETATTR);
294 nfsm_chain_loadattr(error, &nmrep, np, NFS_VER4, &xid);
295 nfsm_chain_op_check(error, &nmrep, NFS_OP_READLINK);
296 nfsm_chain_get_32(error, &nmrep, len);
297 nfsmout_if(error);
304 nfsm_chain_get_opaque(error, &nmrep, len, buf);
305 if (!error)
312 return (error);
326 int error = 0, nfsvers, numops;
343 nfsm_chain_build_alloc_init(error, &nmreq, 22 * NFSX_UNSIGNED);
344 nfsm_chain_add_compound_header(error, &nmreq, "read", numops);
346 nfsm_chain_add_32(error, &nmreq, NFS_OP_PUTFH);
347 nfsm_chain_add_fh(error, &nmreq, nfsvers, np->n_fhp, np->n_fhsize);
349 nfsm_chain_add_32(error, &nmreq, NFS_OP_READ);
351 nfsm_chain_add_stateid(error, &nmreq, &stateid);
352 nfsm_chain_add_64(error, &nmreq, offset);
353 nfsm_chain_add_32(error, &nmreq, len);
355 nfsm_chain_add_32(error, &nmreq, NFS_OP_GETATTR);
356 nfsm_chain_add_bitmap_supported(error, &nmreq, nfs_getattr_bitmap, nmp, np);
357 nfsm_chain_build_done(error, &nmreq);
358 nfsm_assert(error, (numops == 0), EPROTO);
359 nfsmout_if(error);
360 error = nfs_request_async(np, NULL, &nmreq, NFSPROC4_COMPOUND, thd, cred, &si, 0, cb, reqp);
363 return (error);
375 int error = 0, lockerror, nfsvers, numops, status, eof = 0;
389 error = nfs_request_async_finish(req, &nmrep, &xid, &status);
390 if (error == EINPROGRESS) /* async request restarted */
391 return (error);
394 error = lockerror;
395 nfsm_chain_skip_tag(error, &nmrep);
396 nfsm_chain_get_32(error, &nmrep, numops);
397 nfsm_chain_op_check(error, &nmrep, NFS_OP_PUTFH);
398 nfsm_chain_op_check(error, &nmrep, NFS_OP_READ);
399 nfsm_chain_get_32(error, &nmrep, eof);
400 nfsm_chain_get_32(error, &nmrep, retlen);
401 if (!error) {
403 error = nfsm_chain_get_uio(&nmrep, *lenp, uio);
405 nfsm_chain_op_check(error, &nmrep, NFS_OP_GETATTR);
406 nfsm_chain_loadattr(error, &nmrep, np, nfsvers, &xid);
417 return (error);
433 int error = 0, nfsvers, numops;
455 nfsm_chain_build_alloc_init(error, &nmreq, 25 * NFSX_UNSIGNED + len);
456 nfsm_chain_add_compound_header(error, &nmreq, "write", numops);
458 nfsm_chain_add_32(error, &nmreq, NFS_OP_PUTFH);
459 nfsm_chain_add_fh(error, &nmreq, nfsvers, np->n_fhp, np->n_fhsize);
461 nfsm_chain_add_32(error, &nmreq, NFS_OP_WRITE);
463 nfsm_chain_add_stateid(error, &nmreq, &stateid);
464 nfsm_chain_add_64(error, &nmreq, uio_offset(uio));
465 nfsm_chain_add_32(error, &nmreq, iomode);
466 nfsm_chain_add_32(error, &nmreq, len);
467 if (!error)
468 error = nfsm_chain_add_uio(&nmreq, uio, len);
470 nfsm_chain_add_32(error, &nmreq, NFS_OP_GETATTR);
471 nfsm_chain_add_bitmap_supported(error, &nmreq, nfs_getattr_bitmap, nmp, np);
472 nfsm_chain_build_done(error, &nmreq);
473 nfsm_assert(error, (numops == 0), EPROTO);
474 nfsmout_if(error);
476 error = nfs_request_async(np, NULL, &nmreq, NFSPROC4_COMPOUND, thd, cred, &si, 0, cb, reqp);
479 return (error);
491 int error = 0, lockerror = ENOENT, nfsvers, numops, status;
507 error = nfs_request_async_finish(req, &nmrep, &xid, &status);
508 if (error == EINPROGRESS) /* async request restarted */
509 return (error);
512 error = ENXIO;
513 if (!error && (lockerror = nfs_node_lock(np)))
514 error = lockerror;
515 nfsm_chain_skip_tag(error, &nmrep);
516 nfsm_chain_get_32(error, &nmrep, numops);
517 nfsm_chain_op_check(error, &nmrep, NFS_OP_PUTFH);
518 nfsm_chain_op_check(error, &nmrep, NFS_OP_WRITE);
519 nfsm_chain_get_32(error, &nmrep, rlen);
520 nfsmout_if(error);
523 error = NFSERR_IO;
524 nfsm_chain_get_32(error, &nmrep, committed);
525 nfsm_chain_get_64(error, &nmrep, wverf);
526 nfsmout_if(error);
537 nfsm_chain_op_check(error, &nmrep, NFS_OP_GETATTR);
538 nfsm_chain_loadattr(error, &nmrep, np, nfsvers, &xid);
549 return (error);
560 int error = 0, lockerror = ENOENT, remove_error = 0, status;
580 nfsm_chain_build_alloc_init(error, &nmreq, 17 * NFSX_UNSIGNED + namelen);
581 nfsm_chain_add_compound_header(error, &nmreq, "remove", numops);
583 nfsm_chain_add_32(error, &nmreq, NFS_OP_PUTFH);
584 nfsm_chain_add_fh(error, &nmreq, nfsvers, dnp->n_fhp, dnp->n_fhsize);
586 nfsm_chain_add_32(error, &nmreq, NFS_OP_REMOVE);
587 nfsm_chain_add_name(error, &nmreq, name, namelen, nmp);
589 nfsm_chain_add_32(error, &nmreq, NFS_OP_GETATTR);
590 nfsm_chain_add_bitmap_supported(error, &nmreq, nfs_getattr_bitmap, nmp, dnp);
591 nfsm_chain_build_done(error, &nmreq);
592 nfsm_assert(error, (numops == 0), EPROTO);
593 nfsmout_if(error);
595 error = nfs_request2(dnp, NULL, &nmreq, NFSPROC4_COMPOUND, thd, cred, &si, 0, &nmrep, &xid, &status);
598 error = lockerror;
599 nfsm_chain_skip_tag(error, &nmrep);
600 nfsm_chain_get_32(error, &nmrep, numops);
601 nfsm_chain_op_check(error, &nmrep, NFS_OP_PUTFH);
602 nfsm_chain_op_check(error, &nmrep, NFS_OP_REMOVE);
603 remove_error = error;
604 nfsm_chain_check_change_info(error, &nmrep, dnp);
605 nfsm_chain_op_check(error, &nmrep, NFS_OP_GETATTR);
606 nfsm_chain_loadattr(error, &nmrep, dnp, nfsvers, &xid);
607 if (error && !lockerror)
617 if (error == NFSERR_GRACE) {
635 int error = 0, lockerror = ENOENT, status, nfsvers, numops;
656 nfsm_chain_build_alloc_init(error, &nmreq, 30 * NFSX_UNSIGNED + fnamelen + tnamelen);
657 nfsm_chain_add_compound_header(error, &nmreq, "rename", numops);
659 nfsm_chain_add_32(error, &nmreq, NFS_OP_PUTFH);
660 nfsm_chain_add_fh(error, &nmreq, nfsvers, fdnp->n_fhp, fdnp->n_fhsize);
662 nfsm_chain_add_32(error, &nmreq, NFS_OP_SAVEFH);
664 nfsm_chain_add_32(error, &nmreq, NFS_OP_PUTFH);
665 nfsm_chain_add_fh(error, &nmreq, nfsvers, tdnp->n_fhp, tdnp->n_fhsize);
667 nfsm_chain_add_32(error, &nmreq, NFS_OP_RENAME);
668 nfsm_chain_add_name(error, &nmreq, fnameptr, fnamelen, nmp);
669 nfsm_chain_add_name(error, &nmreq, tnameptr, tnamelen, nmp);
671 nfsm_chain_add_32(error, &nmreq, NFS_OP_GETATTR);
672 nfsm_chain_add_bitmap_supported(error, &nmreq, nfs_getattr_bitmap, nmp, tdnp);
674 nfsm_chain_add_32(error, &nmreq, NFS_OP_RESTOREFH);
676 nfsm_chain_add_32(error, &nmreq, NFS_OP_GETATTR);
677 nfsm_chain_add_bitmap_supported(error, &nmreq, nfs_getattr_bitmap, nmp, fdnp);
678 nfsm_chain_build_done(error, &nmreq);
679 nfsm_assert(error, (numops == 0), EPROTO);
680 nfsmout_if(error);
682 error = nfs_request(fdnp, NULL, &nmreq, NFSPROC4_COMPOUND, ctx, &si, &nmrep, &xid, &status);
685 error = lockerror;
686 nfsm_chain_skip_tag(error, &nmrep);
687 nfsm_chain_get_32(error, &nmrep, numops);
688 nfsm_chain_op_check(error, &nmrep, NFS_OP_PUTFH);
689 nfsm_chain_op_check(error, &nmrep, NFS_OP_SAVEFH);
690 nfsm_chain_op_check(error, &nmrep, NFS_OP_PUTFH);
691 nfsm_chain_op_check(error, &nmrep, NFS_OP_RENAME);
692 nfsm_chain_check_change_info(error, &nmrep, fdnp);
693 nfsm_chain_check_change_info(error, &nmrep, tdnp);
695 nfsm_chain_op_check(error, &nmrep, NFS_OP_GETATTR);
697 nfsm_chain_loadattr(error, &nmrep, tdnp, nfsvers, &xid);
698 if (error && !lockerror)
700 nfsm_chain_op_check(error, &nmrep, NFS_OP_RESTOREFH);
701 nfsm_chain_op_check(error, &nmrep, NFS_OP_GETATTR);
703 nfsm_chain_loadattr(error, &nmrep, fdnp, nfsvers, &xid);
704 if (error && !lockerror)
714 return (error);
724 int error = 0, lockerror, nfsvers, namedattr, rdirplus, bigcookies, numops;
856 nfsm_chain_build_alloc_init(error, &nmreq, 26 * NFSX_UNSIGNED);
857 nfsm_chain_add_compound_header(error, &nmreq, tag, numops);
859 nfsm_chain_add_32(error, &nmreq, NFS_OP_PUTFH);
860 nfsm_chain_add_fh(error, &nmreq, nfsvers, dnp->n_fhp, dnp->n_fhsize);
862 nfsm_chain_add_32(error, &nmreq, NFS_OP_GETATTR);
863 nfsm_chain_add_bitmap_supported(error, &nmreq, nfs_getattr_bitmap, nmp, dnp);
865 nfsm_chain_add_32(error, &nmreq, NFS_OP_READDIR);
866 nfsm_chain_add_64(error, &nmreq, (cookie <= 2) ? 0 : cookie);
867 nfsm_chain_add_64(error, &nmreq, dnp->n_cookieverf);
868 nfsm_chain_add_32(error, &nmreq, nmreaddirsize);
869 nfsm_chain_add_32(error, &nmreq, nmrsize);
870 nfsm_chain_add_bitmap_supported(error, &nmreq, entry_attrs, nmp, dnp);
871 nfsm_chain_build_done(error, &nmreq);
872 nfsm_assert(error, (numops == 0), EPROTO);
874 nfsmout_if(error);
875 error = nfs_request(dnp, NULL, &nmreq, NFSPROC4_COMPOUND, ctx, &si, &nmrep, &xid, &status);
878 error = lockerror;
881 nfsm_chain_skip_tag(error, &nmrep);
882 nfsm_chain_get_32(error, &nmrep, numops);
883 nfsm_chain_op_check(error, &nmrep, NFS_OP_PUTFH);
884 nfsm_chain_op_check(error, &nmrep, NFS_OP_GETATTR);
885 nfsm_chain_loadattr(error, &nmrep, dnp, nfsvers, &xid);
886 nfsm_chain_op_check(error, &nmrep, NFS_OP_READDIR);
887 nfsm_chain_get_64(error, &nmrep, dnp->n_cookieverf);
888 nfsm_chain_get_32(error, &nmrep, more_entries);
894 nfsmout_if(error);
902 nfsm_chain_get_64(error, &nmrep, cookie);
903 nfsm_chain_get_32(error, &nmrep, namlen);
904 nfsmout_if(error);
914 error = EBADRPC;
943 error = nfs_buf_get(dnp, lastcookie, NFS_DIRBLKSIZ, vfs_context_thread(ctx), NBLK_READ, &bp);
944 nfsmout_if(error);
962 nfsm_chain_get_opaque(error, &nmrep, namlen, dp->d_name);
963 nfsmout_if(error);
966 nfsm_chain_adv(error, &nmrep,
968 nfsmout_if(error);
970 error = nfs4_parsefattr(&nmrep, NULL, nvattrp, &fh, NULL, NULL);
971 if (!error && NFS_BITMAP_ISSET(nvattrp->nva_bitmap, NFS_FATTR_ACL)) {
979 if (error && NFS_BITMAP_ISSET(nvattrp->nva_bitmap, NFS_FATTR_RDATTR_ERROR)) {
981 if ((error == NFSERR_MOVED) || (error == NFSERR_INVAL)) {
985 error = 0;
988 nfsm_chain_get_32(error, &nmrep, more_entries);
989 nfsmout_if(error);
1043 nfsm_chain_get_32(error, &nmrep, eof);
1044 nfsmout_if(error);
1059 error = lockerror;
1060 nfsmout_if(error);
1071 return (bp_dropped ? NFSERR_DIRBUFDROPPED : error);
1082 int error = 0, isdotdot = 0, nfsvers, numops;
1106 nfsm_chain_build_alloc_init(error, &nmreq, 20 * NFSX_UNSIGNED + namelen);
1107 nfsm_chain_add_compound_header(error, &nmreq, "lookup", numops);
1109 nfsm_chain_add_32(error, &nmreq, NFS_OP_PUTFH);
1110 nfsm_chain_add_fh(error, &nmreq, nfsvers, dnp->n_fhp, dnp->n_fhsize);
1112 nfsm_chain_add_32(error, &nmreq, NFS_OP_GETATTR);
1113 nfsm_chain_add_bitmap_supported(error, &nmreq, nfs_getattr_bitmap, nmp, dnp);
1116 nfsm_chain_add_32(error, &nmreq, NFS_OP_LOOKUPP);
1118 nfsm_chain_add_32(error, &nmreq, NFS_OP_LOOKUP);
1119 nfsm_chain_add_name(error, &nmreq, name, namelen, nmp);
1122 nfsm_chain_add_32(error, &nmreq, NFS_OP_GETFH);
1124 nfsm_chain_add_32(error, &nmreq, NFS_OP_GETATTR);
1133 nfsm_chain_add_bitmap_supported(error, &nmreq, bitmap, nmp, NULL);
1134 nfsm_chain_build_done(error, &nmreq);
1135 nfsm_assert(error, (numops == 0), EPROTO);
1136 nfsmout_if(error);
1137 error = nfs_request_async(dnp, NULL, &nmreq, NFSPROC4_COMPOUND,
1141 return (error);
1156 int error = 0, lockerror = ENOENT, status, nfsvers, numops, isdotdot = 0;
1169 error = nfs_request_async_finish(req, &nmrep, &xid, &status);
1172 error = lockerror;
1173 nfsm_chain_skip_tag(error, &nmrep);
1174 nfsm_chain_get_32(error, &nmrep, numops);
1175 nfsm_chain_op_check(error, &nmrep, NFS_OP_PUTFH);
1176 nfsm_chain_op_check(error, &nmrep, NFS_OP_GETATTR);
1179 nfsm_chain_loadattr(error, &nmrep, dnp, nfsvers, &xid);
1181 nfsm_chain_op_check(error, &nmrep, (isdotdot ? NFS_OP_LOOKUPP : NFS_OP_LOOKUP));
1182 nfsmout_if(error || !fhp || !nvap);
1183 nfsm_chain_op_check(error, &nmrep, NFS_OP_GETFH);
1184 nfsm_chain_get_32(error, &nmrep, fhp->fh_len);
1185 nfsm_chain_get_opaque(error, &nmrep, fhp->fh_len, fhp->fh_data);
1186 nfsm_chain_op_check(error, &nmrep, NFS_OP_GETATTR);
1187 if ((error == NFSERR_MOVED) || (error == NFSERR_INVAL)) {
1190 error = 0;
1192 nfsmout_if(error);
1193 error = nfs4_parsefattr(&nmrep, NULL, nvap, NULL, NULL, NULL);
1199 if (!error && (op == NFS_OP_LOOKUP) && (nmp->nm_state & NFSSTA_NEEDSECINFO)) {
1205 error = nfs4_secinfo_rpc(nmp, &req->r_secinfo, vfs_context_ucred(ctx), sec.flavors, &sec.count);
1206 /* [sigh] some implementations return "illegal" error for unsupported ops */
1207 if (error == NFSERR_OP_ILLEGAL)
1208 error = 0;
1209 if (!error) {
1218 return (error);
1230 int error = 0, lockerror, status, nfsvers, numops;
1257 nfsm_chain_build_alloc_init(error, &nmreq, 19 * NFSX_UNSIGNED);
1258 nfsm_chain_add_compound_header(error, &nmreq, "commit", numops);
1260 nfsm_chain_add_32(error, &nmreq, NFS_OP_PUTFH);
1261 nfsm_chain_add_fh(error, &nmreq, nfsvers, np->n_fhp, np->n_fhsize);
1263 nfsm_chain_add_32(error, &nmreq, NFS_OP_COMMIT);
1264 nfsm_chain_add_64(error, &nmreq, offset);
1265 nfsm_chain_add_32(error, &nmreq, count32);
1267 nfsm_chain_add_32(error, &nmreq, NFS_OP_GETATTR);
1268 nfsm_chain_add_bitmap_supported(error, &nmreq, nfs_getattr_bitmap, nmp, np);
1269 nfsm_chain_build_done(error, &nmreq);
1270 nfsm_assert(error, (numops == 0), EPROTO);
1271 nfsmout_if(error);
1272 error = nfs_request2(np, NULL, &nmreq, NFSPROC4_COMPOUND,
1276 error = lockerror;
1277 nfsm_chain_skip_tag(error, &nmrep);
1278 nfsm_chain_get_32(error, &nmrep, numops);
1279 nfsm_chain_op_check(error, &nmrep, NFS_OP_PUTFH);
1280 nfsm_chain_op_check(error, &nmrep, NFS_OP_COMMIT);
1281 nfsm_chain_get_64(error, &nmrep, newwverf);
1282 nfsm_chain_op_check(error, &nmrep, NFS_OP_GETATTR);
1283 nfsm_chain_loadattr(error, &nmrep, np, nfsvers, &xid);
1286 nfsmout_if(error);
1291 error = NFSERR_STALEWRITEVERF;
1296 return (error);
1306 int error = 0, lockerror, status, nfsvers, numops;
1327 nfsm_chain_build_alloc_init(error, &nmreq, 16 * NFSX_UNSIGNED);
1328 nfsm_chain_add_compound_header(error, &nmreq, "pathconf", numops);
1330 nfsm_chain_add_32(error, &nmreq, NFS_OP_PUTFH);
1331 nfsm_chain_add_fh(error, &nmreq, nfsvers, np->n_fhp, np->n_fhsize);
1333 nfsm_chain_add_32(error, &nmreq, NFS_OP_GETATTR);
1341 nfsm_chain_add_bitmap_supported(error, &nmreq, bitmap, nmp, np);
1342 nfsm_chain_build_done(error, &nmreq);
1343 nfsm_assert(error, (numops == 0), EPROTO);
1344 nfsmout_if(error);
1345 error = nfs_request(np, NULL, &nmreq, NFSPROC4_COMPOUND, ctx, &si, &nmrep, &xid, &status);
1347 nfsm_chain_skip_tag(error, &nmrep);
1348 nfsm_chain_get_32(error, &nmrep, numops);
1349 nfsm_chain_op_check(error, &nmrep, NFS_OP_PUTFH);
1350 nfsm_chain_op_check(error, &nmrep, NFS_OP_GETATTR);
1351 nfsmout_if(error);
1352 error = nfs4_parsefattr(&nmrep, nfsap, &nvattr, NULL, NULL, NULL);
1353 nfsmout_if(error);
1355 error = lockerror;
1356 if (!error)
1364 return (error);
1379 int error, acls, ngaflags;
1389 error = nfs_getattr(VTONFS(ap->a_vp), &nva, ap->a_context, ngaflags);
1390 if (error)
1391 return (error);
1474 return (error);
1484 int error = 0, setattr_error = 0, lockerror = ENOENT, status, nfsvers, numops;
1542 nfsm_chain_build_alloc_init(error, &nmreq, 40 * NFSX_UNSIGNED);
1543 nfsm_chain_add_compound_header(error, &nmreq, "setattr", numops);
1545 nfsm_chain_add_32(error, &nmreq, NFS_OP_PUTFH);
1546 nfsm_chain_add_fh(error, &nmreq, nfsvers, np->n_fhp, np->n_fhsize);
1548 nfsm_chain_add_32(error, &nmreq, NFS_OP_SETATTR);
1553 nfsm_chain_add_stateid(error, &nmreq, &stateid);
1554 nfsm_chain_add_fattr4(error, &nmreq, vap, nmp);
1556 nfsm_chain_add_32(error, &nmreq, NFS_OP_GETATTR);
1557 nfsm_chain_add_bitmap_supported(error, &nmreq, getbitmap, nmp, np);
1558 nfsm_chain_build_done(error, &nmreq);
1559 nfsm_assert(error, (numops == 0), EPROTO);
1560 nfsmout_if(error);
1561 error = nfs_request(np, NULL, &nmreq, NFSPROC4_COMPOUND, ctx, &si, &nmrep, &xid, &status);
1564 error = lockerror;
1565 nfsm_chain_skip_tag(error, &nmrep);
1566 nfsm_chain_get_32(error, &nmrep, numops);
1567 nfsm_chain_op_check(error, &nmrep, NFS_OP_PUTFH);
1568 nfsmout_if(error);
1569 nfsm_chain_op_check(error, &nmrep, NFS_OP_SETATTR);
1570 nfsmout_if(error == EBADRPC);
1571 setattr_error = error;
1572 error = 0;
1574 nfsm_chain_get_bitmap(error, &nmrep, setbitmap, bmlen);
1575 if (!error) {
1579 error = setattr_error;
1581 nfsm_chain_op_check(error, &nmrep, NFS_OP_GETATTR);
1582 nfsm_chain_loadattr(error, &nmrep, np, nfsvers, &xid);
1583 if (error)
1615 error = 0;
1619 return (error);
1629 int error = 0, slpflag = NMFLAG(nmp, INTR) ? PCATCH : 0;
1633 if ((error = nfs_sigintr(nmp, NULL, current_thread(), 1)))
1641 return (error);
1654 int error = 0, slpflag = (NMFLAG(nmp, INTR) && thd) ? PCATCH : 0;
1664 if ((error = nfs_sigintr(nmp, NULL, thd, 1)))
1670 if (!error)
1674 return (error);
1679 * state. If the given error indicates that recovery should
1683 nfs_mount_state_in_use_end(struct nfsmount *nmp, int error)
1685 int restart = nfs_mount_state_error_should_restart(error);
1690 if (restart && (error != NFSERR_OLD_STATEID) && (error != NFSERR_GRACE)) {
1691 printf("nfs_mount_state_in_use_end: error %d, initiating recovery for %s, 0x%x\n",
1692 error, vfs_statfs(nmp->nm_mountp)->f_mntfromname, nmp->nm_stategenid);
1693 nfs_need_recover(nmp, error);
1702 if (error == NFSERR_GRACE)
1709 * Does the error mean we should restart/redo a state-related operation?
1712 nfs_mount_state_error_should_restart(int error)
1714 switch (error) {
1739 * Does the error mean we probably lost a delegation?
1742 nfs_mount_state_error_delegation_lost(int error)
1744 switch (error) {
1765 int error = 0, slpflag;
1774 if ((error = nfs_sigintr(nmp, NULL, thd, 0)))
1780 if (!error)
1784 return (error);
1908 int error = 0, slpflag;
1917 if ((error = nfs_sigintr(nmp, NULL, thd, 0)))
1923 if (!error)
1927 return (error);
1950 * Given an open/lock owner and an error code, increment the
1954 nfs_owner_seqid_increment(struct nfs_open_owner *noop, struct nfs_lock_owner *nlop, int error)
1956 switch (error) {
2089 int error = 0, slpflag;
2098 if ((error = nfs_sigintr(nmp, NULL, thd, 0)))
2104 if (!error)
2108 return (error);
2481 int error = 0, ismember, readtoo = 0, authorized = 0;
2510 error = kauth_cred_ismember_gid(cred, np->n_vattr.nva_gid, &ismember);
2511 if (!error && ismember)
2519 error = kauth_acl_evaluate(cred, &eval);
2521 if (!error && (eval.ae_result == KAUTH_RESULT_ALLOW))
2532 if (!(error = nfs_vnop_access(&naa)))
2543 return (error ? error : EACCES);
2577 int error = 0, readtoo = 0;
2586 if ((error = nfs_open_state_set_busy(np, vfs_context_thread(ctx))))
2587 return (error);
2591 error = nfs4_open_delegated(np, nofp, accessMode, denyMode, ctx);
2593 return (error);
2605 (((dvp = np->n_parent)) && (error = vnode_get(dvp))))
2611 if (!error)
2612 error = EIO;
2620 error = ENOMEM;
2638 error = nfs4_open_rpc(nofp, ctx, &cn, NULL, dvp, &vp, NFS_OPEN_NOCREATE, accessMode, denyMode);
2639 if (error) {
2640 if (!nfs_mount_state_error_should_restart(error) &&
2641 (error != EINTR) && (error != ERESTART) && readtoo) {
2657 return (error);
2672 int error = 0, accessMode, denyMode, delegated;
2701 error = nfs_mount_state_in_use_start(nmp, NULL);
2702 if (error) {
2704 return (error);
2707 error = EIO;
2710 return (error);
2713 error = nfs_open_file_find(np, noop, &nofp, 0, 0, 1);
2714 if (error || (!error && (nofp->nof_flags & NFS_OPEN_FILE_LOST))) {
2715 NP(np, "nfs_vnop_mmap: no open file for owner, error %d, %d", error, kauth_cred_getuid(noop->noo_cred));
2716 error = EPERM;
2718 if (!error && (nofp->nof_flags & NFS_OPEN_FILE_REOPEN)) {
2720 error = nfs4_reopen(nofp, NULL);
2722 if (!error)
2725 if (!error)
2726 error = nfs_open_file_set_busy(nofp, NULL);
2727 if (error) {
2743 error = EPERM;
2750 error = 0;
2752 error = nfs4_open(np, nofp, NFS_OPEN_SHARE_ACCESS_READ, NFS_OPEN_SHARE_DENY_NONE, ctx);
2754 if (!error)
2756 if (error)
2779 error = EPERM;
2799 error = EPERM;
2802 if (error) /* mmap mode without proper open mode */
2816 error = nfs_close(np, nofp, nofp->nof_mmap_access, nofp->nof_mmap_deny, ctx);
2817 if (error) {
2818 if (!nfs_mount_state_error_should_restart(error))
2819 NP(np, "nfs_vnop_mmap: close of previous mmap mode failed: %d, %d", error, kauth_cred_getuid(nofp->nof_owner->noo_cred));
2820 NP(np, "nfs_vnop_mmap: update, close error %d, %d", error, kauth_cred_getuid(nofp->nof_owner->noo_cred));
2833 if (nfs_mount_state_in_use_end(nmp, error)) {
2840 if (!error) {
2859 return (error);
2877 int error;
2906 error = nfs_mount_state_in_use_start(nmp, NULL);
2907 if (error)
2908 return (error);
2916 error = nfs4_reopen(nofp, NULL);
2917 if (!error)
2920 if (!error)
2921 error = nfs_open_file_set_busy(nofp, NULL);
2922 if (error) {
2927 error = nfs_close(np, nofp, nofp->nof_mmap_access, nofp->nof_mmap_deny, ctx);
2928 if (!nfs_mount_state_error_should_restart(error)) {
2929 if (error) /* not a state-operation-restarting error, so just clear the access */
2930 NP(np, "nfs_vnop_mnomap: close of mmap mode failed: %d, %d", error, kauth_cred_getuid(nofp->nof_owner->noo_cred));
2933 if (error)
2934 NP(np, "nfs_vnop_mnomap: error %d, %d", error, kauth_cred_getuid(nofp->nof_owner->noo_cred));
2937 nfs_mount_state_in_use_end(nmp, error);
2941 nfs_mount_state_in_use_end(nmp, error);
2942 return (error);
3061 int error = 0, slpflag;
3070 if ((error = nfs_sigintr(nmp, NULL, thd, 0)))
3076 if (!error)
3080 return (error);
3220 int error = 0, lockerror = ENOENT, newlocker, numops, status;
3238 error = nfs_open_file_set_busy(nofp, thd);
3239 if (error)
3240 return (error);
3241 error = nfs_open_owner_set_busy(nofp->nof_owner, thd);
3242 if (error) {
3244 return (error);
3251 error = nfs_lock_owner_set_busy(nlop, thd);
3252 if (error) {
3257 return (error);
3266 nfsm_chain_build_alloc_init(error, &nmreq, 33 * NFSX_UNSIGNED);
3267 nfsm_chain_add_compound_header(error, &nmreq, "lock", numops);
3269 nfsm_chain_add_32(error, &nmreq, NFS_OP_PUTFH);
3270 nfsm_chain_add_fh(error, &nmreq, NFS_VER4, np->n_fhp, np->n_fhsize);
3272 nfsm_chain_add_32(error, &nmreq, NFS_OP_GETATTR);
3273 nfsm_chain_add_bitmap_supported(error, &nmreq, nfs_getattr_bitmap, nmp, np);
3275 nfsm_chain_add_32(error, &nmreq, NFS_OP_LOCK);
3276 nfsm_chain_add_32(error, &nmreq, locktype);
3277 nfsm_chain_add_32(error, &nmreq, reclaim);
3278 nfsm_chain_add_64(error, &nmreq, nflp->nfl_start);
3279 nfsm_chain_add_64(error, &nmreq, NFS_LOCK_LENGTH(nflp->nfl_start, nflp->nfl_end));
3280 nfsm_chain_add_32(error, &nmreq, newlocker);
3282 nfsm_chain_add_32(error, &nmreq, nofp->nof_owner->noo_seqid);
3283 nfsm_chain_add_stateid(error, &nmreq, &nofp->nof_stateid);
3284 nfsm_chain_add_32(error, &nmreq, nlop->nlo_seqid);
3285 nfsm_chain_add_lock_owner4(error, &nmreq, nmp, nlop);
3287 nfsm_chain_add_stateid(error, &nmreq, &nlop->nlo_stateid);
3288 nfsm_chain_add_32(error, &nmreq, nlop->nlo_seqid);
3290 nfsm_chain_build_done(error, &nmreq);
3291 nfsm_assert(error, (numops == 0), EPROTO);
3292 nfsmout_if(error);
3294 error = nfs_request2(np, NULL, &nmreq, NFSPROC4_COMPOUND, thd, cred, &si, flags|R_NOINTR, &nmrep, &xid, &status);
3297 error = lockerror;
3298 nfsm_chain_skip_tag(error, &nmrep);
3299 nfsm_chain_get_32(error, &nmrep, numops);
3300 nfsm_chain_op_check(error, &nmrep, NFS_OP_PUTFH);
3301 nfsmout_if(error);
3302 nfsm_chain_op_check(error, &nmrep, NFS_OP_GETATTR);
3303 nfsm_chain_loadattr(error, &nmrep, np, NFS_VER4, &xid);
3304 nfsmout_if(error);
3305 nfsm_chain_op_check(error, &nmrep, NFS_OP_LOCK);
3306 nfs_owner_seqid_increment(newlocker ? nofp->nof_owner : NULL, nlop, error);
3307 nfsm_chain_get_stateid(error, &nmrep, &nlop->nlo_stateid);
3311 if (newlocker && !error)
3323 return (error);
3343 int error = 0, lockerror = ENOENT, numops, status;
3352 error = nfs_lock_owner_set_busy(nlop, NULL);
3353 if (error)
3354 return (error);
3362 nfsm_chain_build_alloc_init(error, &nmreq, 26 * NFSX_UNSIGNED);
3363 nfsm_chain_add_compound_header(error, &nmreq, "unlock", numops);
3365 nfsm_chain_add_32(error, &nmreq, NFS_OP_PUTFH);
3366 nfsm_chain_add_fh(error, &nmreq, NFS_VER4, np->n_fhp, np->n_fhsize);
3368 nfsm_chain_add_32(error, &nmreq, NFS_OP_GETATTR);
3369 nfsm_chain_add_bitmap_supported(error, &nmreq, nfs_getattr_bitmap, nmp, np);
3371 nfsm_chain_add_32(error, &nmreq, NFS_OP_LOCKU);
3372 nfsm_chain_add_32(error, &nmreq, (type == F_WRLCK) ? NFS_LOCK_TYPE_WRITE : NFS_LOCK_TYPE_READ);
3373 nfsm_chain_add_32(error, &nmreq, nlop->nlo_seqid);
3374 nfsm_chain_add_stateid(error, &nmreq, &nlop->nlo_stateid);
3375 nfsm_chain_add_64(error, &nmreq, start);
3376 nfsm_chain_add_64(error, &nmreq, NFS_LOCK_LENGTH(start, end));
3377 nfsm_chain_build_done(error, &nmreq);
3378 nfsm_assert(error, (numops == 0), EPROTO);
3379 nfsmout_if(error);
3381 error = nfs_request2(np, NULL, &nmreq, NFSPROC4_COMPOUND, thd, cred, &si, flags|R_NOINTR, &nmrep, &xid, &status);
3384 error = lockerror;
3385 nfsm_chain_skip_tag(error, &nmrep);
3386 nfsm_chain_get_32(error, &nmrep, numops);
3387 nfsm_chain_op_check(error, &nmrep, NFS_OP_PUTFH);
3388 nfsmout_if(error);
3389 nfsm_chain_op_check(error, &nmrep, NFS_OP_GETATTR);
3390 nfsm_chain_loadattr(error, &nmrep, np, NFS_VER4, &xid);
3391 nfsmout_if(error);
3392 nfsm_chain_op_check(error, &nmrep, NFS_OP_LOCKU);
3393 nfs_owner_seqid_increment(NULL, nlop, error);
3394 nfsm_chain_get_stateid(error, &nmrep, &nlop->nlo_stateid);
3401 return (error);
3420 int error = 0, lockerror, numops, status;
3436 nfsm_chain_build_alloc_init(error, &nmreq, 26 * NFSX_UNSIGNED);
3437 nfsm_chain_add_compound_header(error, &nmreq, "locktest", numops);
3439 nfsm_chain_add_32(error, &nmreq, NFS_OP_PUTFH);
3440 nfsm_chain_add_fh(error, &nmreq, NFS_VER4, np->n_fhp, np->n_fhsize);
3442 nfsm_chain_add_32(error, &nmreq, NFS_OP_GETATTR);
3443 nfsm_chain_add_bitmap_supported(error, &nmreq, nfs_getattr_bitmap, nmp, np);
3445 nfsm_chain_add_32(error, &nmreq, NFS_OP_LOCKT);
3446 nfsm_chain_add_32(error, &nmreq, (fl->l_type == F_WRLCK) ? NFS_LOCK_TYPE_WRITE : NFS_LOCK_TYPE_READ);
3447 nfsm_chain_add_64(error, &nmreq, start);
3448 nfsm_chain_add_64(error, &nmreq, NFS_LOCK_LENGTH(start, end));
3449 nfsm_chain_add_lock_owner4(error, &nmreq, nmp, nlop);
3450 nfsm_chain_build_done(error, &nmreq);
3451 nfsm_assert(error, (numops == 0), EPROTO);
3452 nfsmout_if(error);
3454 error = nfs_request(np, NULL, &nmreq, NFSPROC4_COMPOUND, ctx, &si, &nmrep, &xid, &status);
3457 error = lockerror;
3458 nfsm_chain_skip_tag(error, &nmrep);
3459 nfsm_chain_get_32(error, &nmrep, numops);
3460 nfsm_chain_op_check(error, &nmrep, NFS_OP_PUTFH);
3461 nfsmout_if(error);
3462 nfsm_chain_op_check(error, &nmrep, NFS_OP_GETATTR);
3463 nfsm_chain_loadattr(error, &nmrep, np, NFS_VER4, &xid);
3464 nfsmout_if(error);
3465 nfsm_chain_op_check(error, &nmrep, NFS_OP_LOCKT);
3466 if (error == NFSERR_DENIED) {
3467 error = 0;
3468 nfsm_chain_get_64(error, &nmrep, fl->l_start);
3469 nfsm_chain_get_64(error, &nmrep, val64);
3471 nfsm_chain_get_32(error, &nmrep, val);
3475 } else if (!error) {
3483 return (error);
3505 int error = 0, answered = 0;
3512 if ((error = nfs_mount_state_in_use_start(nmp, vfs_context_thread(ctx))))
3513 return (error);
3547 error = nmp->nm_funcs->nf_getlock_rpc(np, nlop, fl, start, end, ctx);
3549 if (nfs_mount_state_in_use_end(nmp, error))
3551 return (error);
3559 * If a conflict is found, block or return an error.
3580 int error = 0, error2, willsplit = 0, delay, slpflag, busy = 0, inuse = 0, restart, inqueue = 0;
3620 error = nfs_mount_state_in_use_start(nmp, vfs_context_thread(ctx));
3621 if (error)
3625 error = EIO;
3633 error = nfs4_reopen(nofp, vfs_context_thread(ctx));
3634 if (error)
3653 error = EAGAIN;
3658 error = ENOLCK;
3668 error = nfs_advlock_unlock(np, nofp, nlop, 0, UINT64_MAX, NFS_FILE_LOCK_STYLE_FLOCK, ctx);
3670 if (!error)
3671 error = nfs_mount_state_in_use_start(nmp, vfs_context_thread(ctx));
3672 if (error) {
3684 error = nfs_sigintr(NFSTONMP(np), NULL, vfs_context_thread(ctx), 0);
3685 if (!error && (nmp->nm_state & NFSSTA_RECOVER)) {
3694 if (!error && (np->n_flag & NREVOKE))
3695 error = EIO;
3696 } while (!error && nfs_file_lock_conflict(newnflp, nflp, NULL));
3702 if (error || restart)
3711 if (error)
3722 error = ENOLCK;
3728 if ((error = nfs_open_state_set_busy(np, vfs_context_thread(ctx))))
3738 error = 0;
3758 error = nfs4_claim_delegated_state_for_open_file(nofp, 0);
3759 if (error)
3765 error = EIO;
3766 if (!error)
3767 error = nmp->nm_funcs->nf_setlock_rpc(np, nofp, newnflp, 0, 0, vfs_context_thread(ctx), vfs_context_ucred(ctx));
3768 if (!error || ((error != NFSERR_DENIED) && (error != NFSERR_GRACE)))
3771 if ((error == NFSERR_DENIED) && !(newnflp->nfl_flags & NFS_FILE_LOCK_WAIT)) {
3772 error = EAGAIN;
3790 error = error2;
3799 if ((nmp->nm_vers >= NFS_VER4) || (error == NFSERR_GRACE)) {
3800 if (error == NFSERR_GRACE)
3807 error = nfs_sigintr(NFSTONMP(np), NULL, vfs_context_thread(ctx), 0);
3808 if (!error && (nmp->nm_state & NFSSTA_RECOVER)) {
3816 if (!error && (np->n_flag & NREVOKE))
3817 error = EIO;
3818 } while (!error);
3821 if (nfs_mount_state_error_should_restart(error)) {
3828 nfs_mount_state_in_use_end(nmp, error);
3835 if (error) {
3850 nfs_mount_state_in_use_end(nmp, error);
3853 return (error);
3971 nfs_mount_state_in_use_end(nmp, error);
3975 return (error);
3993 int error = 0, willsplit = 0, send_unlock_rpcs = 1;
4000 if ((error = nfs_mount_state_in_use_start(nmp, NULL)))
4001 return (error);
4004 error = nfs4_reopen(nofp, NULL);
4005 if (error)
4006 return (error);
4009 if ((error = nfs_open_state_set_busy(np, NULL))) {
4010 nfs_mount_state_in_use_end(nmp, error);
4011 return (error);
4078 error = nmp->nm_funcs->nf_unlock_rpc(np, nlop, type, s, nflp->nfl_start-1, 0,
4080 if (nfs_mount_state_error_should_restart(error)) {
4082 nfs_mount_state_in_use_end(nmp, error);
4086 if (error)
4094 error = nmp->nm_funcs->nf_unlock_rpc(np, nlop, type, s, end, 0,
4096 if (nfs_mount_state_error_should_restart(error)) {
4098 nfs_mount_state_in_use_end(nmp, error);
4102 if (error)
4122 error = nmp->nm_funcs->nf_unlock_rpc(np, nlop, nflp->nfl_type, nflp->nfl_start, nflp->nfl_end, 0,
4124 if (nfs_mount_state_error_should_restart(error)) {
4126 nfs_mount_state_in_use_end(nmp, error);
4132 if (error)
4144 error = nmp->nm_funcs->nf_unlock_rpc(np, nlop, nflp->nfl_type, start, end, 0,
4146 if (nfs_mount_state_error_should_restart(error)) {
4148 nfs_mount_state_in_use_end(nmp, error);
4153 if (error)
4169 error = nmp->nm_funcs->nf_unlock_rpc(np, nlop, nflp->nfl_type, start, nflp->nfl_end, 0,
4171 if (nfs_mount_state_error_should_restart(error)) {
4173 nfs_mount_state_in_use_end(nmp, error);
4179 if (error)
4186 error = nmp->nm_funcs->nf_unlock_rpc(np, nlop, nflp->nfl_type, nflp->nfl_start, end, 0,
4188 if (nfs_mount_state_error_should_restart(error)) {
4190 nfs_mount_state_in_use_end(nmp, error);
4196 if (error)
4216 return (error);
4246 int error = 0, modified, style;
4281 if ((error = nfs_node_lock(np)))
4282 return (error);
4285 if (modified && ((error = nfs_vinvalbuf(vp, V_SAVE, ctx, 1))))
4286 return (error);
4287 if ((error = nfs_getattr(np, NULL, ctx, NGA_UNCACHED)))
4288 return (error);
4292 error = EOVERFLOW;
4295 if (error)
4296 return (error);
4326 error = (op == F_UNLCK) ? 0 : ENOMEM;
4327 if (error)
4328 NP(np, "nfs_vnop_advlock: no lock owner, error %d", error);
4333 error = nfs_advlock_getlock(np, nlop, fl, start, end, ctx);
4339 error = EPERM;
4344 error = nfs_open_file_find(np, noop, &nofp, 0, 0, 0);
4345 if (error)
4346 error = EBADF;
4347 if (!error && (nofp->nof_flags & NFS_OPEN_FILE_LOST)) {
4349 error = EIO;
4351 if (!error && (nofp->nof_flags & NFS_OPEN_FILE_REOPEN)) {
4352 error = nfs4_reopen(nofp, ((op == F_UNLCK) ? NULL : vfs_context_thread(ctx)));
4354 if (!error)
4357 if (error) {
4358 NP(np, "nfs_vnop_advlock: no open file %d, %d", error, kauth_cred_getuid(noop->noo_cred));
4362 error = nfs_advlock_unlock(np, nofp, nlop, start, end, style, ctx);
4366 error = nfs_advlock_setlock(np, nofp, nlop, op, start, end, style, fl->l_type, ctx);
4369 error = EINVAL;
4378 return (error);
4415 int error = 0, done = 0, slpflag = NMFLAG(nmp, INTR) ? PCATCH : 0;
4420 if ((error = nfs_sigintr(nmp, NULL, thd, 0)))
4425 if (error || !(nofp->nof_flags & NFS_OPEN_FILE_REOPEN)) {
4427 return (error);
4440 if ((error = vnode_get(dvp))) {
4453 (((dvp = np->n_parent)) && (error = vnode_get(dvp))))
4459 if (!error)
4460 error = EIO;
4471 error = ENOMEM;
4483 if ((error = nfs_mount_state_in_use_start(nmp, thd)))
4487 error = nfs4_open_reopen_rpc(nofp, thd, noop->noo_cred, &cn, dvp, &vp, NFS_OPEN_SHARE_ACCESS_BOTH, NFS_OPEN_SHARE_DENY_NONE);
4488 if (!error && nofp->nof_w)
4489 error = nfs4_open_reopen_rpc(nofp, thd, noop->noo_cred, &cn, dvp, &vp, NFS_OPEN_SHARE_ACCESS_WRITE, NFS_OPEN_SHARE_DENY_NONE);
4490 if (!error && nofp->nof_r)
4491 error = nfs4_open_reopen_rpc(nofp, thd, noop->noo_cred, &cn, dvp, &vp, NFS_OPEN_SHARE_ACCESS_READ, NFS_OPEN_SHARE_DENY_NONE);
4493 if (nfs_mount_state_in_use_end(nmp, error)) {
4494 if (error == NFSERR_GRACE)
4496 printf("nfs4_reopen: RPC failed, error %d, lost %d, %s\n", error,
4498 error = 0;
4503 if (error && (error != EINTR) && (error != ERESTART))
4509 else if (error)
4510 printf("nfs4_reopen: failed, error %d, lost %d, %s\n", error,
4519 return (error);
4575 int error = 0, status, numops;
4584 nfsm_chain_build_alloc_init(error, &nmreq, 23 * NFSX_UNSIGNED);
4585 nfsm_chain_add_compound_header(error, &nmreq, "open_confirm", numops);
4587 nfsm_chain_add_32(error, &nmreq, NFS_OP_PUTFH);
4588 nfsm_chain_add_fh(error, &nmreq, nmp->nm_vers, fhp, fhlen);
4590 nfsm_chain_add_32(error, &nmreq, NFS_OP_OPEN_CONFIRM);
4591 nfsm_chain_add_stateid(error, &nmreq, sid);
4592 nfsm_chain_add_32(error, &nmreq, noop->noo_seqid);
4594 nfsm_chain_add_32(error, &nmreq, NFS_OP_GETATTR);
4595 nfsm_chain_add_bitmap_supported(error, &nmreq, nfs_getattr_bitmap, nmp, dnp);
4596 nfsm_chain_build_done(error, &nmreq);
4597 nfsm_assert(error, (numops == 0), EPROTO);
4598 nfsmout_if(error);
4599 error = nfs_request2(dnp, NULL, &nmreq, NFSPROC4_COMPOUND, thd, cred, &si, R_NOINTR, &nmrep, xidp, &status);
4601 nfsm_chain_skip_tag(error, &nmrep);
4602 nfsm_chain_get_32(error, &nmrep, numops);
4603 nfsm_chain_op_check(error, &nmrep, NFS_OP_PUTFH);
4604 nfsmout_if(error);
4605 nfsm_chain_op_check(error, &nmrep, NFS_OP_OPEN_CONFIRM);
4606 nfs_owner_seqid_increment(noop, NULL, error);
4607 nfsm_chain_get_stateid(error, &nmrep, sid);
4608 nfsm_chain_op_check(error, &nmrep, NFS_OP_GETATTR);
4609 nfsmout_if(error);
4610 error = nfs4_parsefattr(&nmrep, NULL, nvap, NULL, NULL, NULL);
4614 return (error);
4640 int error = 0, open_error = EIO, lockerror = ENOENT, busyerror = ENOENT, status;
4687 if ((error = nfs_open_owner_set_busy(noop, thd)))
4688 return (error);
4702 nfsm_chain_build_alloc_init(error, &nmreq, 53 * NFSX_UNSIGNED + cnp->cn_namelen);
4703 nfsm_chain_add_compound_header(error, &nmreq, create ? "create" : "open", numops);
4705 nfsm_chain_add_32(error, &nmreq, NFS_OP_PUTFH);
4706 nfsm_chain_add_fh(error, &nmreq, nfsvers, dnp->n_fhp, dnp->n_fhsize);
4708 nfsm_chain_add_32(error, &nmreq, NFS_OP_SAVEFH);
4710 nfsm_chain_add_32(error, &nmreq, NFS_OP_OPEN);
4711 nfsm_chain_add_32(error, &nmreq, noop->noo_seqid);
4712 nfsm_chain_add_32(error, &nmreq, share_access);
4713 nfsm_chain_add_32(error, &nmreq, share_deny);
4714 nfsm_chain_add_64(error, &nmreq, nmp->nm_clientid);
4715 nfsm_chain_add_32(error, &nmreq, NFSX_UNSIGNED);
4716 nfsm_chain_add_32(error, &nmreq, kauth_cred_getuid(noop->noo_cred));
4717 nfsm_chain_add_32(error, &nmreq, create);
4722 nfsm_chain_add_32(error, &nmreq, NFS_CREATE_EXCLUSIVE);
4724 nfsm_chain_add_32(error, &nmreq, create_verf);
4725 nfsm_chain_add_32(error, &nmreq, create_verf);
4727 nfsm_chain_add_32(error, &nmreq, NFS_CREATE_UNCHECKED);
4728 nfsm_chain_add_fattr4(error, &nmreq, vap, nmp);
4731 nfsm_chain_add_32(error, &nmreq, NFS_CLAIM_NULL);
4732 nfsm_chain_add_name(error, &nmreq, cnp->cn_nameptr, cnp->cn_namelen, nmp);
4734 nfsm_chain_add_32(error, &nmreq, NFS_OP_GETATTR);
4737 nfsm_chain_add_bitmap_supported(error, &nmreq, bitmap, nmp, np);
4739 nfsm_chain_add_32(error, &nmreq, NFS_OP_RESTOREFH);
4741 nfsm_chain_add_32(error, &nmreq, NFS_OP_GETATTR);
4742 nfsm_chain_add_bitmap_supported(error, &nmreq, nfs_getattr_bitmap, nmp, dnp);
4743 nfsm_chain_build_done(error, &nmreq);
4744 nfsm_assert(error, (numops == 0), EPROTO);
4745 if (!error)
4746 error = busyerror = nfs_node_set_busy(dnp, thd);
4747 nfsmout_if(error);
4752 error = nfs_request_async(dnp, NULL, &nmreq, NFSPROC4_COMPOUND, thd, cred, &si, R_NOINTR, NULL, &req);
4753 if (!error) {
4756 error = nfs_request_async_finish(req, &nmrep, &xid, &status);
4764 error = lockerror;
4765 nfsm_chain_skip_tag(error, &nmrep);
4766 nfsm_chain_get_32(error, &nmrep, numops);
4767 nfsm_chain_op_check(error, &nmrep, NFS_OP_PUTFH);
4768 nfsm_chain_op_check(error, &nmrep, NFS_OP_SAVEFH);
4769 nfsmout_if(error);
4770 nfsm_chain_op_check(error, &nmrep, NFS_OP_OPEN);
4771 nfs_owner_seqid_increment(noop, NULL, error);
4772 nfsm_chain_get_stateid(error, &nmrep, sid);
4773 nfsm_chain_check_change_info(error, &nmrep, dnp);
4774 nfsm_chain_get_32(error, &nmrep, rflags);
4776 nfsm_chain_get_bitmap(error, &nmrep, bitmap, bmlen);
4777 nfsm_chain_get_32(error, &nmrep, delegation);
4778 if (!error)
4784 nfsm_chain_get_stateid(error, &nmrep, &dstateid);
4785 nfsm_chain_get_32(error, &nmrep, recall);
4787 nfsm_chain_adv(error, &nmrep, 3 * NFSX_UNSIGNED);
4790 nfsm_chain_get_32(error, &nmrep, ace_type);
4791 nfsm_chain_get_32(error, &nmrep, ace_flags);
4792 nfsm_chain_get_32(error, &nmrep, ace_mask);
4793 nfsm_chain_get_32(error, &nmrep, len);
4794 ace.ace_flags = nfs4_ace_nfstype_to_vfstype(ace_type, &error);
4797 if (!error && (len >= slen)) {
4805 nfsm_chain_get_opaque(error, &nmrep, len, s);
4807 nfsm_chain_adv(error, &nmrep, nfsm_rndup(len));
4808 if (!error && s) {
4813 if (error || !s)
4819 error = EBADRPC;
4822 /* At this point if we have no error, the object was created/opened. */
4823 open_error = error;
4824 nfsmout_if(error);
4827 nfsm_chain_op_check(error, &nmrep, NFS_OP_GETATTR);
4828 nfsmout_if(error);
4829 error = nfs4_parsefattr(&nmrep, NULL, &nvattr, &fh, NULL, NULL);
4830 nfsmout_if(error);
4833 error = EBADRPC;
4843 nfsm_chain_op_check(error, &nmrep, NFS_OP_RESTOREFH);
4844 nfsm_chain_op_check(error, &nmrep, NFS_OP_GETATTR);
4845 nfsm_chain_loadattr(error, &nmrep, dnp, nfsvers, &xid);
4846 if (error)
4848 nfsmout_if(error);
4857 error = nfs4_open_confirm_rpc(nmp, dnp, fh.fh_data, fh.fh_len, noop, sid, thd, cred, &nvattr, &xid);
4858 nfsmout_if(error);
4861 error = lockerror;
4880 if (!error && !np && fh.fh_len) {
4883 error = nfs_nget(NFSTOMP(dnp), dnp, cnp, fh.fh_data, fh.fh_len, &nvattr, &xid, rq.r_auth, NG_MAKEENTRY, &newnp);
4884 if (!error)
4893 if (!error && np && !recall) {
4934 if (error) {
4935 if (exclusive && (error == NFSERR_NOTSUPP)) {
4946 error = nfs4_setattr_rpc(newnp, vap, ctx);
4947 if (error && (gotuid || gotgid)) {
4952 error = nfs4_setattr_rpc(newnp, vap, ctx);
4955 if (error)
4961 return (error);
4978 int error = 0, lockerror = ENOENT, status;
5011 if ((error = vnode_get(dvp))) {
5024 (((dvp = np->n_parent)) && (error = vnode_get(dvp))))
5030 if (!error)
5031 error = EIO;
5042 error = ENOMEM;
5049 if ((error = nfs_open_owner_set_busy(noop, NULL)))
5050 return (error);
5062 nfsm_chain_build_alloc_init(error, &nmreq, 48 * NFSX_UNSIGNED);
5063 nfsm_chain_add_compound_header(error, &nmreq, "open_claim_d", numops);
5065 nfsm_chain_add_32(error, &nmreq, NFS_OP_PUTFH);
5066 nfsm_chain_add_fh(error, &nmreq, nfsvers, VTONFS(dvp)->n_fhp, VTONFS(dvp)->n_fhsize);
5068 nfsm_chain_add_32(error, &nmreq, NFS_OP_OPEN);
5069 nfsm_chain_add_32(error, &nmreq, noop->noo_seqid);
5070 nfsm_chain_add_32(error, &nmreq, share_access);
5071 nfsm_chain_add_32(error, &nmreq, share_deny);
5073 nfsm_chain_add_64(error, &nmreq, nmp->nm_clientid); // open_owner4.clientid
5074 nfsm_chain_add_32(error, &nmreq, NFSX_UNSIGNED);
5075 nfsm_chain_add_32(error, &nmreq, kauth_cred_getuid(noop->noo_cred)); // open_owner4.owner
5077 nfsm_chain_add_32(error, &nmreq, NFS_OPEN_NOCREATE);
5079 nfsm_chain_add_32(error, &nmreq, NFS_CLAIM_DELEGATE_CUR);
5080 nfsm_chain_add_stateid(error, &nmreq, &np->n_dstateid);
5081 nfsm_chain_add_name(error, &nmreq, filename, namelen, nmp);
5083 nfsm_chain_add_32(error, &nmreq, NFS_OP_GETATTR);
5086 nfsm_chain_add_bitmap_supported(error, &nmreq, bitmap, nmp, np);
5087 nfsm_chain_build_done(error, &nmreq);
5088 nfsm_assert(error, (numops == 0), EPROTO);
5089 nfsmout_if(error);
5091 error = nfs_request2(np, nmp->nm_mountp, &nmreq, NFSPROC4_COMPOUND, current_thread(),
5095 error = lockerror;
5096 nfsm_chain_skip_tag(error, &nmrep);
5097 nfsm_chain_get_32(error, &nmrep, numops);
5098 nfsm_chain_op_check(error, &nmrep, NFS_OP_PUTFH);
5099 nfsmout_if(error);
5100 nfsm_chain_op_check(error, &nmrep, NFS_OP_OPEN);
5101 nfs_owner_seqid_increment(noop, NULL, error);
5102 nfsm_chain_get_stateid(error, &nmrep, &nofp->nof_stateid);
5103 nfsm_chain_check_change_info(error, &nmrep, np);
5104 nfsm_chain_get_32(error, &nmrep, rflags);
5106 nfsm_chain_get_bitmap(error, &nmrep, bitmap, bmlen);
5107 nfsm_chain_get_32(error, &nmrep, delegation);
5108 if (!error)
5123 nfsm_chain_get_stateid(error, &nmrep, &dstateid);
5124 nfsm_chain_get_32(error, &nmrep, recall);
5126 nfsm_chain_adv(error, &nmrep, 3 * NFSX_UNSIGNED);
5129 nfsm_chain_get_32(error, &nmrep, ace_type);
5130 nfsm_chain_get_32(error, &nmrep, ace_flags);
5131 nfsm_chain_get_32(error, &nmrep, ace_mask);
5132 nfsm_chain_get_32(error, &nmrep, len);
5133 ace.ace_flags = nfs4_ace_nfstype_to_vfstype(ace_type, &error);
5136 if (!error && (len >= slen)) {
5144 nfsm_chain_get_opaque(error, &nmrep, len, s);
5146 nfsm_chain_adv(error, &nmrep, nfsm_rndup(len));
5147 if (!error && s) {
5152 if (error || !s)
5156 if (!error) {
5173 error = EBADRPC;
5176 nfsmout_if(error);
5177 nfsm_chain_op_check(error, &nmrep, NFS_OP_GETATTR);
5178 error = nfs4_parsefattr(&nmrep, NULL, &nvattr, &fh, NULL, NULL);
5179 nfsmout_if(error);
5182 error = EBADRPC;
5191 error = nfs_loadattrcache(np, &nvattr, &xid, 1);
5192 nfsmout_if(error);
5213 // if (!error)
5221 return (error);
5236 int error = 0, lockerror = ENOENT, status;
5255 if ((error = nfs_open_owner_set_busy(noop, NULL)))
5256 return (error);
5268 nfsm_chain_build_alloc_init(error, &nmreq, 48 * NFSX_UNSIGNED);
5269 nfsm_chain_add_compound_header(error, &nmreq, "open_reclaim", numops);
5271 nfsm_chain_add_32(error, &nmreq, NFS_OP_PUTFH);
5272 nfsm_chain_add_fh(error, &nmreq, nfsvers, np->n_fhp, np->n_fhsize);
5274 nfsm_chain_add_32(error, &nmreq, NFS_OP_OPEN);
5275 nfsm_chain_add_32(error, &nmreq, noop->noo_seqid);
5276 nfsm_chain_add_32(error, &nmreq, share_access);
5277 nfsm_chain_add_32(error, &nmreq, share_deny);
5279 nfsm_chain_add_64(error, &nmreq, nmp->nm_clientid); // open_owner4.clientid
5280 nfsm_chain_add_32(error, &nmreq, NFSX_UNSIGNED);
5281 nfsm_chain_add_32(error, &nmreq, kauth_cred_getuid(noop->noo_cred)); // open_owner4.owner
5283 nfsm_chain_add_32(error, &nmreq, NFS_OPEN_NOCREATE);
5285 nfsm_chain_add_32(error, &nmreq, NFS_CLAIM_PREVIOUS);
5289 nfsm_chain_add_32(error, &nmreq, delegation);
5292 nfsm_chain_add_32(error, &nmreq, NFS_OP_GETATTR);
5295 nfsm_chain_add_bitmap_supported(error, &nmreq, bitmap, nmp, np);
5296 nfsm_chain_build_done(error, &nmreq);
5297 nfsm_assert(error, (numops == 0), EPROTO);
5298 nfsmout_if(error);
5300 error = nfs_request2(np, nmp->nm_mountp, &nmreq, NFSPROC4_COMPOUND, current_thread(),
5304 error = lockerror;
5305 nfsm_chain_skip_tag(error, &nmrep);
5306 nfsm_chain_get_32(error, &nmrep, numops);
5307 nfsm_chain_op_check(error, &nmrep, NFS_OP_PUTFH);
5308 nfsmout_if(error);
5309 nfsm_chain_op_check(error, &nmrep, NFS_OP_OPEN);
5310 nfs_owner_seqid_increment(noop, NULL, error);
5311 nfsm_chain_get_stateid(error, &nmrep, &nofp->nof_stateid);
5312 nfsm_chain_check_change_info(error, &nmrep, np);
5313 nfsm_chain_get_32(error, &nmrep, rflags);
5315 nfsm_chain_get_bitmap(error, &nmrep, bitmap, bmlen);
5316 nfsm_chain_get_32(error, &nmrep, delegation);
5317 if (!error)
5334 nfsm_chain_get_stateid(error, &nmrep, &dstateid);
5335 nfsm_chain_get_32(error, &nmrep, recall);
5337 nfsm_chain_adv(error, &nmrep, 3 * NFSX_UNSIGNED);
5340 nfsm_chain_get_32(error, &nmrep, ace_type);
5341 nfsm_chain_get_32(error, &nmrep, ace_flags);
5342 nfsm_chain_get_32(error, &nmrep, ace_mask);
5343 nfsm_chain_get_32(error, &nmrep, len);
5344 ace.ace_flags = nfs4_ace_nfstype_to_vfstype(ace_type, &error);
5347 if (!error && (len >= slen)) {
5355 nfsm_chain_get_opaque(error, &nmrep, len, s);
5357 nfsm_chain_adv(error, &nmrep, nfsm_rndup(len));
5358 if (!error && s) {
5363 if (error || !s)
5367 if (!error) {
5384 error = EBADRPC;
5387 nfsmout_if(error);
5388 nfsm_chain_op_check(error, &nmrep, NFS_OP_GETATTR);
5389 error = nfs4_parsefattr(&nmrep, NULL, &nvattr, &fh, NULL, NULL);
5390 nfsmout_if(error);
5393 error = EBADRPC;
5404 error = nfs_loadattrcache(np, &nvattr, &xid, 1);
5405 nfsmout_if(error);
5409 // if (!error)
5421 return (error);
5432 int error, lockerror = ENOENT, status, nfsvers, numops;
5442 if ((error = nfs_open_owner_set_busy(noop, NULL)))
5443 return (error);
5451 nfsm_chain_build_alloc_init(error, &nmreq, 23 * NFSX_UNSIGNED);
5452 nfsm_chain_add_compound_header(error, &nmreq, "open_downgrd", numops);
5454 nfsm_chain_add_32(error, &nmreq, NFS_OP_PUTFH);
5455 nfsm_chain_add_fh(error, &nmreq, nfsvers, np->n_fhp, np->n_fhsize);
5457 nfsm_chain_add_32(error, &nmreq, NFS_OP_OPEN_DOWNGRADE);
5458 nfsm_chain_add_stateid(error, &nmreq, &nofp->nof_stateid);
5459 nfsm_chain_add_32(error, &nmreq, noop->noo_seqid);
5460 nfsm_chain_add_32(error, &nmreq, nofp->nof_access);
5461 nfsm_chain_add_32(error, &nmreq, nofp->nof_deny);
5463 nfsm_chain_add_32(error, &nmreq, NFS_OP_GETATTR);
5464 nfsm_chain_add_bitmap_supported(error, &nmreq, nfs_getattr_bitmap, nmp, np);
5465 nfsm_chain_build_done(error, &nmreq);
5466 nfsm_assert(error, (numops == 0), EPROTO);
5467 nfsmout_if(error);
5468 error = nfs_request2(np, NULL, &nmreq, NFSPROC4_COMPOUND,
5473 error = lockerror;
5474 nfsm_chain_skip_tag(error, &nmrep);
5475 nfsm_chain_get_32(error, &nmrep, numops);
5476 nfsm_chain_op_check(error, &nmrep, NFS_OP_PUTFH);
5477 nfsmout_if(error);
5478 nfsm_chain_op_check(error, &nmrep, NFS_OP_OPEN_DOWNGRADE);
5479 nfs_owner_seqid_increment(noop, NULL, error);
5480 nfsm_chain_get_stateid(error, &nmrep, &nofp->nof_stateid);
5481 nfsm_chain_op_check(error, &nmrep, NFS_OP_GETATTR);
5482 nfsm_chain_loadattr(error, &nmrep, np, nfsvers, &xid);
5489 return (error);
5502 int error, lockerror = ENOENT, status, nfsvers, numops;
5512 if ((error = nfs_open_owner_set_busy(noop, NULL)))
5513 return (error);
5521 nfsm_chain_build_alloc_init(error, &nmreq, 23 * NFSX_UNSIGNED);
5522 nfsm_chain_add_compound_header(error, &nmreq, "close", numops);
5524 nfsm_chain_add_32(error, &nmreq, NFS_OP_PUTFH);
5525 nfsm_chain_add_fh(error, &nmreq, nfsvers, np->n_fhp, np->n_fhsize);
5527 nfsm_chain_add_32(error, &nmreq, NFS_OP_CLOSE);
5528 nfsm_chain_add_32(error, &nmreq, noop->noo_seqid);
5529 nfsm_chain_add_stateid(error, &nmreq, &nofp->nof_stateid);
5531 nfsm_chain_add_32(error, &nmreq, NFS_OP_GETATTR);
5532 nfsm_chain_add_bitmap_supported(error, &nmreq, nfs_getattr_bitmap, nmp, np);
5533 nfsm_chain_build_done(error, &nmreq);
5534 nfsm_assert(error, (numops == 0), EPROTO);
5535 nfsmout_if(error);
5536 error = nfs_request2(np, NULL, &nmreq, NFSPROC4_COMPOUND, thd, cred, &si, flags|R_NOINTR, &nmrep, &xid, &status);
5539 error = lockerror;
5540 nfsm_chain_skip_tag(error, &nmrep);
5541 nfsm_chain_get_32(error, &nmrep, numops);
5542 nfsm_chain_op_check(error, &nmrep, NFS_OP_PUTFH);
5543 nfsmout_if(error);
5544 nfsm_chain_op_check(error, &nmrep, NFS_OP_CLOSE);
5545 nfs_owner_seqid_increment(noop, NULL, error);
5546 nfsm_chain_get_stateid(error, &nmrep, &nofp->nof_stateid);
5547 nfsm_chain_op_check(error, &nmrep, NFS_OP_GETATTR);
5548 nfsm_chain_loadattr(error, &nmrep, np, nfsvers, &xid);
5555 return (error);
5569 int error = 0, reopen = 0;
5572 error = nfs4_claim_delegated_open_rpc(nofp, NFS_OPEN_SHARE_ACCESS_BOTH, NFS_OPEN_SHARE_DENY_BOTH, flags);
5573 if (!error) {
5580 if (!error && nofp->nof_d_w_drw) {
5581 error = nfs4_claim_delegated_open_rpc(nofp, NFS_OPEN_SHARE_ACCESS_WRITE, NFS_OPEN_SHARE_DENY_BOTH, flags);
5582 if (!error) {
5589 if (!error && nofp->nof_d_r_drw) {
5590 error = nfs4_claim_delegated_open_rpc(nofp, NFS_OPEN_SHARE_ACCESS_READ, NFS_OPEN_SHARE_DENY_BOTH, flags);
5591 if (!error) {
5598 if (!error && nofp->nof_d_rw_dw) {
5599 error = nfs4_claim_delegated_open_rpc(nofp, NFS_OPEN_SHARE_ACCESS_BOTH, NFS_OPEN_SHARE_DENY_WRITE, flags);
5600 if (!error) {
5607 if (!error && nofp->nof_d_w_dw) {
5608 error = nfs4_claim_delegated_open_rpc(nofp, NFS_OPEN_SHARE_ACCESS_WRITE, NFS_OPEN_SHARE_DENY_WRITE, flags);
5609 if (!error) {
5616 if (!error && nofp->nof_d_r_dw) {
5617 error = nfs4_claim_delegated_open_rpc(nofp, NFS_OPEN_SHARE_ACCESS_READ, NFS_OPEN_SHARE_DENY_WRITE, flags);
5618 if (!error) {
5626 if (!error && nofp->nof_d_rw) {
5627 error = nfs4_claim_delegated_open_rpc(nofp, NFS_OPEN_SHARE_ACCESS_BOTH, NFS_OPEN_SHARE_DENY_NONE, flags);
5629 if (nfs_mount_state_error_delegation_lost(error))
5630 reopen = error;
5631 if (!error || reopen) {
5639 if ((!error || reopen) && nofp->nof_d_w) {
5640 if (!error) {
5641 error = nfs4_claim_delegated_open_rpc(nofp, NFS_OPEN_SHARE_ACCESS_WRITE, NFS_OPEN_SHARE_DENY_NONE, flags);
5643 if (nfs_mount_state_error_delegation_lost(error))
5644 reopen = error;
5646 if (!error || reopen) {
5653 if ((!error || reopen) && nofp->nof_d_r) {
5654 if (!error) {
5655 error = nfs4_claim_delegated_open_rpc(nofp, NFS_OPEN_SHARE_ACCESS_READ, NFS_OPEN_SHARE_DENY_NONE, flags);
5657 if (nfs_mount_state_error_delegation_lost(error))
5658 reopen = error;
5660 if (!error || reopen) {
5693 if (!error && ((nmp = NFSTONMP(nofp->nof_np)))) {
5705 error = nmp->nm_funcs->nf_setlock_rpc(nofp->nof_np, nofp, nflp, 0, flags, current_thread(), noop->noo_cred);
5706 if (error) {
5708 nflp->nfl_start, nflp->nfl_end, error, kauth_cred_getuid(nofp->nof_owner->noo_cred));
5716 if (error)
5721 if (!error) /* all state claimed successfully! */
5725 if (!nfs_mount_state_error_delegation_lost(error) &&
5726 ((error == ETIMEDOUT) || nfs_mount_state_error_should_restart(error))) {
5727 NP(nofp->nof_np, "nfs delegated lock claim error %d, %d", error, kauth_cred_getuid(nofp->nof_owner->noo_cred));
5728 if ((error == ETIMEDOUT) && ((nmp = NFSTONMP(nofp->nof_np))))
5730 return (error);
5734 NP(nofp->nof_np, "nfs delegated state claim error %d, state lost, %d", error, kauth_cred_getuid(nofp->nof_owner->noo_cred));
5750 return (error);
5848 int error = 0;
5860 error = nfs4_claim_delegated_state_for_open_file(nofp, flags);
5862 if (error)
5869 return (error);
5906 int error;
5918 if ((error = nfs_open_state_set_busy(np, NULL)))
5922 if ((error = nfs4_claim_delegated_state_for_node(np, flags)))
5931 error = nfs4_delegreturn_rpc(NFSTONMP(np), fh.fh_data, fh.fh_len, &dstateid, flags, thd, cred);
5933 if ((error != ETIMEDOUT) && (error != NFSERR_MOVED) && (error != NFSERR_LEASE_MOVED)) {
5957 if (error) {
5958 NP(np, "nfs4_delegation_return, error %d", error);
5959 if (error == ETIMEDOUT)
5961 if (nfs_mount_state_error_should_restart(error)) {
5964 nfs_need_recover(nmp, nfs_mount_state_error_delegation_lost(error) ? NFSERR_EXPIRED : 0);
5971 return (error);
5980 int error = 0, status, numops;
5991 nfsm_chain_build_alloc_init(error, &nmreq, 16 * NFSX_UNSIGNED);
5992 nfsm_chain_add_compound_header(error, &nmreq, "delegreturn", numops);
5994 nfsm_chain_add_32(error, &nmreq, NFS_OP_PUTFH);
5995 nfsm_chain_add_fh(error, &nmreq, nmp->nm_vers, fhp, fhlen);
5997 nfsm_chain_add_32(error, &nmreq, NFS_OP_DELEGRETURN);
5998 nfsm_chain_add_stateid(error, &nmreq, sid);
5999 nfsm_chain_build_done(error, &nmreq);
6000 nfsm_assert(error, (numops == 0), EPROTO);
6001 nfsmout_if(error);
6002 error = nfs_request2(NULL, nmp->nm_mountp, &nmreq, NFSPROC4_COMPOUND, thd, cred, &si, flags, &nmrep, &xid, &status);
6003 nfsm_chain_skip_tag(error, &nmrep);
6004 nfsm_chain_get_32(error, &nmrep, numops);
6005 nfsm_chain_op_check(error, &nmrep, NFS_OP_PUTFH);
6006 nfsm_chain_op_check(error, &nmrep, NFS_OP_DELEGRETURN);
6010 return (error);
6037 int error;
6053 error = nfs_open_file_find(np, noop, &nofp, 0, 0, 1);
6054 if (!error && (nofp->nof_flags & NFS_OPEN_FILE_LOST)) {
6056 error = EIO;
6058 if (!error && (nofp->nof_flags & NFS_OPEN_FILE_REOPEN)) {
6059 error = nfs4_reopen(nofp, vfs_context_thread(ctx));
6061 if (!error)
6064 if (error) {
6066 return (error);
6070 error = nfs_mount_state_in_use_start(nmp, vfs_context_thread(ctx));
6071 if (error) {
6073 return (error);
6076 error = EIO;
6079 return (error);
6081 error = nfs_open_file_set_busy(nofp, vfs_context_thread(ctx));
6082 if (error)
6084 if (!error) {
6089 error = nfs4_open(np, nofp, NFS_OPEN_SHARE_ACCESS_READ, NFS_OPEN_SHARE_DENY_NONE, ctx);
6092 if (!error)
6096 if (nfs_mount_state_in_use_end(nmp, error)) {
6102 if (error)
6103 return (error);
6130 int error = 0, busyerror = 0, accessMode, denyMode;
6146 error = nfs_mount_state_in_use_start(nmp, vfs_context_thread(ctx));
6147 if (error) {
6149 return (error);
6153 error = nfs_open_file_find(NULL, noop, &newnofp, 0, 0, 1);
6154 if (!error && (newnofp->nof_flags & NFS_OPEN_FILE_LOST)) {
6156 error = EIO;
6158 if (!error && (newnofp->nof_flags & NFS_OPEN_FILE_REOPEN)) {
6161 error = nfs4_reopen(newnofp, vfs_context_thread(ctx));
6164 if (!error)
6167 if (!error)
6168 error = nfs_open_file_set_busy(newnofp, vfs_context_thread(ctx));
6169 if (error) {
6184 error = nfs4_open_rpc(newnofp, ctx, cnp, vap, dvp, vpp, NFS_OPEN_CREATE, accessMode, denyMode);
6185 if ((error == EACCES) && vap && !(vap->va_vaflags & VA_EXCLUSIVE) &&
6212 error = 0;
6215 if (error) {
6221 if (!error && !*vpp) {
6224 error = EIO;
6226 if (error) {
6237 error = nfs_open_file_find_internal(np, noop, &nofp, 0, 0, 0);
6238 if (error) {
6240 printf("nfs_open_file_find_internal failed! %d\n", error);
6265 if (nfs_mount_state_in_use_end(nmp, error)) {
6272 return (error);
6290 int error = 0, create_error = EIO, lockerror = ENOENT, busyerror = ENOENT, status;
6339 error = busyerror = nfs_node_set_busy(dnp, vfs_context_thread(ctx));
6350 nfsm_chain_build_alloc_init(error, &nmreq, 66 * NFSX_UNSIGNED);
6351 nfsm_chain_add_compound_header(error, &nmreq, tag, numops);
6353 nfsm_chain_add_32(error, &nmreq, NFS_OP_PUTFH);
6354 nfsm_chain_add_fh(error, &nmreq, nfsvers, dnp->n_fhp, dnp->n_fhsize);
6356 nfsm_chain_add_32(error, &nmreq, NFS_OP_SAVEFH);
6358 nfsm_chain_add_32(error, &nmreq, NFS_OP_CREATE);
6359 nfsm_chain_add_32(error, &nmreq, type);
6361 nfsm_chain_add_name(error, &nmreq, link, strlen(link), nmp);
6363 nfsm_chain_add_32(error, &nmreq, sd.specdata1);
6364 nfsm_chain_add_32(error, &nmreq, sd.specdata2);
6366 nfsm_chain_add_name(error, &nmreq, cnp->cn_nameptr, cnp->cn_namelen, nmp);
6367 nfsm_chain_add_fattr4(error, &nmreq, vap, nmp);
6369 nfsm_chain_add_32(error, &nmreq, NFS_OP_GETATTR);
6372 nfsm_chain_add_bitmap_supported(error, &nmreq, bitmap, nmp, NULL);
6374 nfsm_chain_add_32(error, &nmreq, NFS_OP_RESTOREFH);
6376 nfsm_chain_add_32(error, &nmreq, NFS_OP_GETATTR);
6377 nfsm_chain_add_bitmap_supported(error, &nmreq, nfs_getattr_bitmap, nmp, dnp);
6378 nfsm_chain_build_done(error, &nmreq);
6379 nfsm_assert(error, (numops == 0), EPROTO);
6380 nfsmout_if(error);
6382 error = nfs_request_async(dnp, NULL, &nmreq, NFSPROC4_COMPOUND,
6384 if (!error) {
6387 error = nfs_request_async_finish(req, &nmrep, &xid, &status);
6391 error = lockerror;
6392 nfsm_chain_skip_tag(error, &nmrep);
6393 nfsm_chain_get_32(error, &nmrep, numops);
6394 nfsm_chain_op_check(error, &nmrep, NFS_OP_PUTFH);
6395 nfsm_chain_op_check(error, &nmrep, NFS_OP_SAVEFH);
6396 nfsmout_if(error);
6397 nfsm_chain_op_check(error, &nmrep, NFS_OP_CREATE);
6398 nfsm_chain_check_change_info(error, &nmrep, dnp);
6400 nfsm_chain_get_bitmap(error, &nmrep, bitmap, bmlen);
6401 /* At this point if we have no error, the object was created. */
6403 create_error = error;
6404 nfsmout_if(error);
6406 nfsm_chain_op_check(error, &nmrep, NFS_OP_GETATTR);
6407 nfsmout_if(error);
6408 error = nfs4_parsefattr(&nmrep, NULL, &nvattr, &fh, NULL, NULL);
6409 nfsmout_if(error);
6412 error = EBADRPC;
6416 nfsm_chain_op_check(error, &nmrep, NFS_OP_RESTOREFH);
6417 nfsm_chain_op_check(error, &nmrep, NFS_OP_GETATTR);
6419 nfsm_chain_loadattr(error, &nmrep, dnp, nfsvers, &xid);
6420 if (error)
6438 if (!error && fh.fh_len) {
6441 error = nfs_nget(NFSTOMP(dnp), dnp, cnp, fh.fh_data, fh.fh_len, &nvattr, &xid, rq.r_auth, NG_MAKEENTRY, &np);
6442 if (!error)
6455 error = nfs_lookitup(dnp, cnp->cn_nameptr, cnp->cn_namelen, ctx, &np);
6456 if (!error) {
6459 error = EEXIST;
6464 if (error) {
6473 return (error);
6489 int error;
6507 error = nfs4_create_rpc(ap->a_context, VTONFS(ap->a_dvp), ap->a_cnp, ap->a_vap,
6509 if (!error)
6511 return (error);
6526 int error;
6528 error = nfs4_create_rpc(ap->a_context, VTONFS(ap->a_dvp), ap->a_cnp, ap->a_vap,
6530 if (!error)
6532 return (error);
6548 int error;
6550 error = nfs4_create_rpc(ap->a_context, VTONFS(ap->a_dvp), ap->a_cnp, ap->a_vap,
6552 if (!error)
6554 return (error);
6571 int error = 0, lockerror = ENOENT, status;
6599 if ((error = nfs_node_set_busy2(tdnp, np, vfs_context_thread(ctx))))
6600 return (error);
6608 nfsm_chain_build_alloc_init(error, &nmreq, 29 * NFSX_UNSIGNED + cnp->cn_namelen);
6609 nfsm_chain_add_compound_header(error, &nmreq, "link", numops);
6611 nfsm_chain_add_32(error, &nmreq, NFS_OP_PUTFH);
6612 nfsm_chain_add_fh(error, &nmreq, nfsvers, np->n_fhp, np->n_fhsize);
6614 nfsm_chain_add_32(error, &nmreq, NFS_OP_SAVEFH);
6616 nfsm_chain_add_32(error, &nmreq, NFS_OP_PUTFH);
6617 nfsm_chain_add_fh(error, &nmreq, nfsvers, tdnp->n_fhp, tdnp->n_fhsize);
6619 nfsm_chain_add_32(error, &nmreq, NFS_OP_LINK);
6620 nfsm_chain_add_name(error, &nmreq, cnp->cn_nameptr, cnp->cn_namelen, nmp);
6622 nfsm_chain_add_32(error, &nmreq, NFS_OP_GETATTR);
6623 nfsm_chain_add_bitmap_supported(error, &nmreq, nfs_getattr_bitmap, nmp, tdnp);
6625 nfsm_chain_add_32(error, &nmreq, NFS_OP_RESTOREFH);
6627 nfsm_chain_add_32(error, &nmreq, NFS_OP_GETATTR);
6628 nfsm_chain_add_bitmap_supported(error, &nmreq, nfs_getattr_bitmap, nmp, np);
6629 nfsm_chain_build_done(error, &nmreq);
6630 nfsm_assert(error, (numops == 0), EPROTO);
6631 nfsmout_if(error);
6632 error = nfs_request(tdnp, NULL, &nmreq, NFSPROC4_COMPOUND, ctx, &si, &nmrep, &xid, &status);
6635 error = lockerror;
6638 nfsm_chain_skip_tag(error, &nmrep);
6639 nfsm_chain_get_32(error, &nmrep, numops);
6640 nfsm_chain_op_check(error, &nmrep, NFS_OP_PUTFH);
6641 nfsm_chain_op_check(error, &nmrep, NFS_OP_SAVEFH);
6642 nfsm_chain_op_check(error, &nmrep, NFS_OP_PUTFH);
6643 nfsm_chain_op_check(error, &nmrep, NFS_OP_LINK);
6644 nfsm_chain_check_change_info(error, &nmrep, tdnp);
6646 nfsm_chain_op_check(error, &nmrep, NFS_OP_GETATTR);
6648 nfsm_chain_loadattr(error, &nmrep, tdnp, nfsvers, &xid);
6649 if (error)
6652 nfsm_chain_op_check(error, &nmrep, NFS_OP_RESTOREFH);
6653 nfsm_chain_op_check(error, &nmrep, NFS_OP_GETATTR);
6655 nfsm_chain_loadattr(error, &nmrep, np, nfsvers, &xid);
6656 if (error)
6664 if (error == EEXIST)
6665 error = 0;
6666 if (!error && (tdnp->n_flag & NNEGNCENTRIES)) {
6673 return (error);
6691 int error = 0, namedattrs;
6704 if ((error = nfs_node_set_busy2(dnp, np, vfs_context_thread(ctx))))
6705 return (error);
6712 error = nfs4_remove_rpc(dnp, cnp->cn_nameptr, cnp->cn_namelen,
6725 if (error == ENOENT)
6726 error = 0;
6727 if (!error) {
6741 return (error);
6773 int error = 0, status, numops;
6801 error = nfs_nget(nmp->nm_mountp, NULL, &cn, np->n_attrdirfh+1, *np->n_attrdirfh,
6807 error = ENOENT;
6813 nfsm_chain_build_alloc_init(error, &nmreq, 22 * NFSX_UNSIGNED);
6814 nfsm_chain_add_compound_header(error, &nmreq, "openattr", numops);
6816 nfsm_chain_add_32(error, &nmreq, NFS_OP_PUTFH);
6817 nfsm_chain_add_fh(error, &nmreq, nmp->nm_vers, np->n_fhp, np->n_fhsize);
6819 nfsm_chain_add_32(error, &nmreq, NFS_OP_OPENATTR);
6820 nfsm_chain_add_32(error, &nmreq, 0);
6822 nfsm_chain_add_32(error, &nmreq, NFS_OP_GETATTR);
6825 nfsm_chain_add_bitmap_masked(error, &nmreq, bitmap,
6827 nfsm_chain_build_done(error, &nmreq);
6828 nfsm_assert(error, (numops == 0), EPROTO);
6829 nfsmout_if(error);
6830 error = nfs_request_async(np, NULL, &nmreq, NFSPROC4_COMPOUND,
6832 if (!error)
6833 error = nfs_request_async_finish(req, &nmrep, &xid, &status);
6835 nfsm_chain_skip_tag(error, &nmrep);
6836 nfsm_chain_get_32(error, &nmrep, numops);
6837 nfsm_chain_op_check(error, &nmrep, NFS_OP_PUTFH);
6838 nfsm_chain_op_check(error, &nmrep, NFS_OP_OPENATTR);
6839 nfsm_chain_op_check(error, &nmrep, NFS_OP_GETATTR);
6840 nfsmout_if(error);
6841 error = nfs4_parsefattr(&nmrep, NULL, &nvattr, &fh, NULL, NULL);
6842 nfsmout_if(error);
6844 error = ENOENT;
6854 error = ENOMEM;
6862 error = nfs_nget(NFSTOMP(np), NULL, &cn, fh.fh_data, fh.fh_len, &nvattr, &xid, rq.r_auth, 0, &adnp);
6871 error = EINVAL;
6873 error = EINVAL;
6875 if (error)
6878 return (error ? NULL : adnp);
6918 int error = 0, open_error = EIO;
6964 error = nfs_getattr(np, &nvattr, ctx, NGA_CACHED);
6965 if (error)
6966 return (error);
6991 if ((error = busyerror = nfs_node_set_busy(np, vfs_context_thread(ctx))))
6992 return (error);
7007 if ((error = adbusyerror = nfs_node_set_busy(adnp, vfs_context_thread(ctx))))
7010 error = nfs_getattr(adnp, NULL, ctx, NGA_CACHED);
7011 nfsmout_if(error);
7012 error = cache_lookup(NFSTOV(adnp), &avp, cnp);
7013 switch (error) {
7020 error = nfs_dir_buf_cache_lookup(adnp, &anp, cnp, ctx, 0);
7021 if (!error && anp) {
7024 error = -1;
7026 if (error != -1) /* cache miss */
7030 /* cache hit, not really an error */
7045 error = nfs_vnop_access(&naa);
7048 /* we either found it, or hit an error */
7049 if (!error && guarded) {
7051 error = EEXIST;
7055 /* we're done if error or we don't need to open */
7056 if (error || !open)
7058 /* no error and we need to open... */
7064 error = nfs_mount_state_in_use_start(nmp, vfs_context_thread(ctx));
7065 if (error) {
7073 error = nfs_open_file_find(anp, noop, &newnofp, 0, 0, 1);
7074 if (!error && (newnofp->nof_flags & NFS_OPEN_FILE_LOST)) {
7076 error = EIO;
7078 if (!error && (newnofp->nof_flags & NFS_OPEN_FILE_REOPEN)) {
7080 error = nfs4_reopen(newnofp, vfs_context_thread(ctx));
7083 if (!error)
7086 if (!error)
7087 error = nfs_open_file_set_busy(newnofp, vfs_context_thread(ctx));
7088 if (error) {
7099 open_error = error = nfs4_open(anp, newnofp, accessMode, denyMode, ctx);
7100 if (!error) {
7125 if ((error = nfs_open_owner_set_busy(noop, thd)))
7143 nfsm_chain_build_alloc_init(error, &nmreq, 64 * NFSX_UNSIGNED + cnp->cn_namelen);
7144 nfsm_chain_add_compound_header(error, &nmreq, "getnamedattr", numops);
7147 nfsm_chain_add_32(error, &nmreq, NFS_OP_PUTFH);
7148 nfsm_chain_add_fh(error, &nmreq, nmp->nm_vers, adnp->n_fhp, adnp->n_fhsize);
7151 nfsm_chain_add_32(error, &nmreq, NFS_OP_PUTFH);
7152 nfsm_chain_add_fh(error, &nmreq, nmp->nm_vers, np->n_fhp, np->n_fhsize);
7154 nfsm_chain_add_32(error, &nmreq, NFS_OP_OPENATTR);
7155 nfsm_chain_add_32(error, &nmreq, create ? 1 : 0);
7157 nfsm_chain_add_32(error, &nmreq, NFS_OP_GETATTR);
7160 nfsm_chain_add_bitmap_masked(error, &nmreq, bitmap,
7165 nfsm_chain_add_32(error, &nmreq, NFS_OP_OPEN);
7166 nfsm_chain_add_32(error, &nmreq, noop->noo_seqid);
7167 nfsm_chain_add_32(error, &nmreq, accessMode);
7168 nfsm_chain_add_32(error, &nmreq, denyMode);
7169 nfsm_chain_add_64(error, &nmreq, nmp->nm_clientid);
7170 nfsm_chain_add_32(error, &nmreq, NFSX_UNSIGNED);
7171 nfsm_chain_add_32(error, &nmreq, kauth_cred_getuid(noop->noo_cred));
7172 nfsm_chain_add_32(error, &nmreq, create);
7174 nfsm_chain_add_32(error, &nmreq, guarded);
7178 nfsm_chain_add_fattr4(error, &nmreq, &vattr, nmp);
7180 nfsm_chain_add_32(error, &nmreq, NFS_CLAIM_NULL);
7181 nfsm_chain_add_name(error, &nmreq, cnp->cn_nameptr, cnp->cn_namelen, nmp);
7184 nfsm_chain_add_32(error, &nmreq, NFS_OP_LOOKUP);
7185 nfsm_chain_add_name(error, &nmreq, cnp->cn_nameptr, cnp->cn_namelen, nmp);
7188 nfsm_chain_add_32(error, &nmreq, NFS_OP_GETATTR);
7191 nfsm_chain_add_bitmap_masked(error, &nmreq, bitmap,
7195 nfsm_chain_add_32(error, &nmreq, NFS_OP_SAVEFH);
7199 nfsm_chain_add_32(error, &nmreq, NFS_OP_PUTFH);
7200 nfsm_chain_add_fh(error, &nmreq, nmp->nm_vers, adnp->n_fhp, adnp->n_fhsize);
7203 nfsm_chain_add_32(error, &nmreq, NFS_OP_PUTFH);
7204 nfsm_chain_add_fh(error, &nmreq, nmp->nm_vers, np->n_fhp, np->n_fhsize);
7206 nfsm_chain_add_32(error, &nmreq, NFS_OP_OPENATTR);
7207 nfsm_chain_add_32(error, &nmreq, 0);
7210 nfsm_chain_add_32(error, &nmreq, NFS_OP_GETATTR);
7211 nfsm_chain_add_bitmap_masked(error, &nmreq, nfs_getattr_bitmap,
7215 nfsm_chain_add_32(error, &nmreq, NFS_OP_RESTOREFH);
7217 nfsm_chain_add_32(error, &nmreq, NFS_OP_NVERIFY);
7220 nfsm_chain_add_fattr4(error, &nmreq, &vattr, nmp);
7222 nfsm_chain_add_32(error, &nmreq, NFS_OP_READ);
7223 nfsm_chain_add_stateid(error, &nmreq, &stateid);
7224 nfsm_chain_add_64(error, &nmreq, 0);
7225 nfsm_chain_add_32(error, &nmreq, rlen);
7227 nfsm_chain_build_done(error, &nmreq);
7228 nfsm_assert(error, (numops == 0), EPROTO);
7229 nfsmout_if(error);
7230 error = nfs_request_async(hadattrdir ? adnp : np, NULL, &nmreq, NFSPROC4_COMPOUND,
7232 if (!error)
7233 error = nfs_request_async_finish(req, &nmrep, &xid, &status);
7236 error = adlockerror;
7238 nfsm_chain_skip_tag(error, &nmrep);
7239 nfsm_chain_get_32(error, &nmrep, numops);
7240 nfsm_chain_op_check(error, &nmrep, NFS_OP_PUTFH);
7242 nfsm_chain_op_check(error, &nmrep, NFS_OP_OPENATTR);
7243 nfsm_chain_op_check(error, &nmrep, NFS_OP_GETATTR);
7244 nfsmout_if(error);
7245 error = nfs4_parsefattr(&nmrep, NULL, &nvattr, &fh, NULL, NULL);
7246 nfsmout_if(error);
7265 error = nfs_nget(NFSTOMP(np), NULL, &cn, fh.fh_data, fh.fh_len, &nvattr, &xid, rq.r_auth, 0, &adnp);
7266 if (!error) {
7273 error = 0;
7280 nfsm_chain_op_check(error, &nmrep, NFS_OP_OPEN);
7281 nfs_owner_seqid_increment(noop, NULL, error);
7282 nfsm_chain_get_stateid(error, &nmrep, &newnofp->nof_stateid);
7283 nfsm_chain_check_change_info(error, &nmrep, adnp);
7284 nfsm_chain_get_32(error, &nmrep, rflags);
7286 nfsm_chain_get_bitmap(error, &nmrep, bitmap, bmlen);
7287 nfsm_chain_get_32(error, &nmrep, delegation);
7288 if (!error)
7294 nfsm_chain_get_stateid(error, &nmrep, &dstateid);
7295 nfsm_chain_get_32(error, &nmrep, recall);
7297 nfsm_chain_adv(error, &nmrep, 3 * NFSX_UNSIGNED);
7300 nfsm_chain_get_32(error, &nmrep, ace_type);
7301 nfsm_chain_get_32(error, &nmrep, ace_flags);
7302 nfsm_chain_get_32(error, &nmrep, ace_mask);
7303 nfsm_chain_get_32(error, &nmrep, len);
7304 ace.ace_flags = nfs4_ace_nfstype_to_vfstype(ace_type, &error);
7307 if (!error && (len >= slen)) {
7315 nfsm_chain_get_opaque(error, &nmrep, len, s);
7317 nfsm_chain_adv(error, &nmrep, nfsm_rndup(len));
7318 if (!error && s) {
7323 if (error || !s)
7329 error = EBADRPC;
7332 /* At this point if we have no error, the object was created/opened. */
7333 open_error = error;
7335 nfsm_chain_op_check(error, &nmrep, NFS_OP_LOOKUP);
7337 nfsm_chain_op_check(error, &nmrep, NFS_OP_GETATTR);
7338 nfsmout_if(error);
7339 error = nfs4_parsefattr(&nmrep, NULL, &nvattr, &fh, NULL, NULL);
7340 nfsmout_if(error);
7342 error = EIO;
7346 nfsm_chain_op_check(error, &nmrep, NFS_OP_SAVEFH);
7347 nfsm_chain_op_check(error, &nmrep, NFS_OP_PUTFH);
7349 nfsm_chain_op_check(error, &nmrep, NFS_OP_OPENATTR);
7350 nfsm_chain_op_check(error, &nmrep, NFS_OP_GETATTR);
7351 nfsmout_if(error);
7353 nfsm_chain_loadattr(error, &nmrep, adnp, nmp->nm_vers, &xid);
7354 nfsmout_if(error);
7365 error = nfs4_open_confirm_rpc(nmp, adnp ? adnp : np, fh.fh_data, fh.fh_len, noop, &newnofp->nof_stateid, thd, cred, &nvattr, &xid);
7366 nfsmout_if(error);
7369 error = adlockerror;
7384 if (adnp && !adlockerror && (error == ENOENT) &&
7394 if (!error && !anp && fh.fh_len) {
7397 error = nfs_nget(NFSTOMP(np), adnp, cnp, fh.fh_data, fh.fh_len, &nvattr, &xid, rq.r_auth, NG_MAKEENTRY, &anp);
7398 if (!error) {
7402 if (!error && open) {
7406 error = nfs_open_file_find_internal(anp, noop, &nofp, 0, 0, 0);
7407 if (error) {
7409 printf("nfs_open_file_find_internal failed! %d\n", error);
7428 if (!error) {
7441 if (!error && anp && !recall) {
7492 if (inuse && nfs_mount_state_in_use_end(nmp, error)) {
7520 if (!error && prefetch && nmrep.nmc_mhead) {
7521 nfsm_chain_op_check(error, &nmrep, NFS_OP_RESTOREFH);
7522 nfsm_chain_op_check(error, &nmrep, NFS_OP_NVERIFY);
7523 nfsm_chain_op_check(error, &nmrep, NFS_OP_READ);
7524 nfsm_chain_get_32(error, &nmrep, eof);
7525 nfsm_chain_get_32(error, &nmrep, retlen);
7526 if (!error && anp) {
7550 if (!(error = nfs_node_lock(anp))) {
7554 error = nfs_vinvalbuf(NFSTOV(anp), V_SAVE|V_IGNORE_WRITEERR, ctx, 1);
7555 if (!error) /* lets play it safe and just drop the data */
7556 error = EIO;
7566 if (!error)
7567 error = nfs_buf_get(anp, 0, nmp->nm_biosize, thd, NBLK_READ|NBLK_NOWAIT, &bp);
7569 if (!error && bp && !bp->nb_dirtyoff && !(bp->nb_dirty & pagemask) &&
7575 nfsm_chain_get_opaque(error, &nmrep, retlen, bp->nb_data);
7576 if (error) {
7577 bp->nb_error = error;
7603 error = 0; /* ignore any transient error in processing the prefetch */
7615 if (error && *anpp) {
7621 return (error);
7634 int error, putanp = 0;
7647 error = nfs4_named_attr_get(np, &cn, NFS_OPEN_SHARE_ACCESS_NONE,
7649 if ((!error && !anp) || (error == ENOATTR))
7650 error = ENOENT;
7651 if (error) {
7661 if ((error = nfs_node_set_busy(np, vfs_context_thread(ctx))))
7666 error = ENOENT;
7676 error = nfs_vnop_remove(&vra);
7682 return (error);
7702 int error = 0, isrsrcfork;
7710 error = nfs_getattr(VTONFS(ap->a_vp), &nvattr, ctx, NGA_CACHED);
7711 if (error)
7712 return (error);
7726 error = nfs4_named_attr_get(VTONFS(ap->a_vp), &cn, NFS_OPEN_SHARE_ACCESS_NONE,
7728 if ((!error && !anp) || (error == ENOENT))
7729 error = ENOATTR;
7730 if (!error) {
7732 error = nfs_bioread(anp, ap->a_uio, 0, ctx);
7738 return (error);
7759 int error = 0, closeerror = 0, flags, isrsrcfork, isfinderinfo, empty = 0, i;
7797 error = uiomove((char*)&finfo, sizeof(finfo), uio);
7798 if (error)
7799 return (error);
7808 error = nfs4_named_attr_remove(VTONFS(ap->a_vp), anp, name, ctx);
7809 if (error == ENOENT)
7810 error = 0;
7811 return (error);
7813 /* first, let's see if we get a create/replace error */
7832 error = nfs4_named_attr_get(VTONFS(ap->a_vp), &cn, NFS_OPEN_SHARE_ACCESS_BOTH,
7834 if (!error && !anp)
7835 error = ENOATTR;
7836 if (error)
7839 if (nofp && !(error = nfs_open_file_set_busy(nofp, NULL))) {
7867 error = nfs_vnop_write(&vwa);
7868 if (!error)
7869 error = nfs_flush(anp, MNT_WAIT, vfs_context_thread(ctx), 0);
7879 if (!error && isfinderinfo && empty) { /* Setting an empty FinderInfo really means remove it */
7880 error = nfs4_named_attr_remove(VTONFS(ap->a_vp), anp, name, ctx);
7881 if (error == ENOENT)
7882 error = 0;
7884 if (!error)
7885 error = closeerror;
7889 if (error == ENOENT)
7890 error = ENOATTR;
7891 return (error);
7905 int error;
7912 error = nfs4_named_attr_remove(VTONFS(ap->a_vp), NULL, ap->a_name, ap->a_context);
7913 if (error == ENOENT)
7914 error = ENOATTR;
7915 return (error);
7934 int error, done, i;
7948 error = nfs_getattr(np, &nvattr, ctx, NGA_CACHED);
7949 if (error)
7950 return (error);
7955 if ((error = nfs_node_set_busy(np, vfs_context_thread(ctx))))
7956 return (error);
7962 if ((error = nfs_node_lock(adnp)))
7969 error = nfs_vinvalbuf(NFSTOV(adnp), 0, ctx, 1);
7970 if (!error)
7971 error = nfs_node_lock(adnp);
7972 if (error)
7982 if ((error = nfs_vinvalbuf(NFSTOV(adnp), 0, ctx, 1)))
7988 if ((error = nfs_getattr(adnp, &nvattr, ctx, NGA_UNCACHED)))
7997 while (!error && !done) {
8001 error = nfs_buf_get(adnp, lbn, NFS_DIRBLKSIZ, vfs_context_thread(ctx), NBLK_READ, &bp);
8002 if (error)
8012 error = nfs_buf_readdir(bp, ctx);
8013 if (error == NFSERR_DIRBUFDROPPED)
8015 if (error)
8017 if (error && (error != ENXIO) && (error != ETIMEDOUT) && (error != EINTR) && (error != ERESTART)) {
8023 if (error == NFSERR_BAD_COOKIE)
8024 error = ENOENT;
8026 if (error)
8037 error = ERANGE;
8039 error = uiomove(dp->d_name, dp->d_namlen+1, uio);
8040 if (error && (error != EFAULT))
8041 error = ERANGE;
8055 if (!error && !done && (nextcookie == cookie)) {
8057 error = EIO;
8064 return (error);
8085 int error = 0;
8093 error = nfs_getattr(VTONFS(ap->a_vp), &nvattr, ctx, NGA_CACHED);
8094 if (error)
8095 return (error);
8106 error = nfs4_named_attr_get(VTONFS(ap->a_vp), &cn, NFS_OPEN_SHARE_ACCESS_NONE,
8108 if ((!error && !anp) || (error == ENOENT))
8109 error = ENOATTR;
8110 if (!error && anp)
8114 return (error);
8132 int error = 0;
8147 error = nfs4_named_attr_get(VTONFS(ap->a_vp), &cn, NFS_OPEN_SHARE_ACCESS_BOTH,
8149 if ((!error && !anp) || (error == ENOENT))
8150 error = ENOATTR;
8151 if (!error && anp)
8155 return (error);