Lines Matching defs:np
83 nfs4_access_rpc(nfsnode_t np, u_int32_t *access, vfs_context_t ctx)
90 struct nfsmount *nmp = NFSTONMP(np);
95 if (np->n_vattr.nva_flags & NFS_FFLAG_TRIGGER_REFERRAL)
98 NFSREQ_SECINFO_SET(&si, np, NULL, 0, NULL, 0);
108 nfsm_chain_add_fh(error, &nmreq, nfsvers, np->n_fhp, np->n_fhsize);
114 nfsm_chain_add_bitmap_supported(error, &nmreq, nfs_getattr_bitmap, nmp, np);
118 error = nfs_request(np, NULL, &nmreq, NFSPROC4_COMPOUND, ctx, &si, &nmrep, &xid, &status);
120 if ((lockerror = nfs_node_lock(np)))
144 if (np->n_flag & NISDOTZFSCHILD) /* may be able to create/delete snapshot dirs */
146 else if (((dvp = vnode_getparent(NFSTOV(np))) != NULLVP) && (VTONFS(dvp)->n_flag & NISDOTZFSCHILD))
155 nfsm_chain_loadattr(error, &nmrep, np, nfsvers, &xid);
159 slot = nfs_node_access_slot(np, uid, 1);
160 np->n_accessuid[slot] = uid;
162 np->n_accessstamp[slot] = now.tv_sec;
163 np->n_access[slot] = access_result;
166 *access = np->n_access[slot];
169 nfs_node_unlock(np);
177 nfsnode_t np,
186 struct nfsmount *nmp = mp ? VFSTONFS(mp) : NFSTONMP(np);
197 if (np && (np->n_vattr.nva_flags & NFS_FFLAG_TRIGGER_REFERRAL)) {
198 nfs4_default_attrs_for_referral_trigger(VTONFS(np->n_parent), NULL, 0, nvap, NULL);
205 NFSREQ_SECINFO_SET(&si, np, NULL, 0, NULL, 0);
221 nfsm_chain_add_bitmap_supported(error, &nmreq, bitmap, nmp, np);
225 error = nfs_request2(np, mp, &nmreq, NFSPROC4_COMPOUND,
248 nfs4_readlink_rpc(nfsnode_t np, char *buf, uint32_t *buflenp, vfs_context_t ctx)
257 nmp = NFSTONMP(np);
260 if (np->n_vattr.nva_flags & NFS_FFLAG_TRIGGER_REFERRAL)
262 NFSREQ_SECINFO_SET(&si, np, NULL, 0, NULL, 0);
272 nfsm_chain_add_fh(error, &nmreq, NFS_VER4, np->n_fhp, np->n_fhsize);
275 nfsm_chain_add_bitmap_supported(error, &nmreq, nfs_getattr_bitmap, nmp, np);
281 error = nfs_request(np, NULL, &nmreq, NFSPROC4_COMPOUND, ctx, &si, &nmrep, &xid, &status);
283 if ((lockerror = nfs_node_lock(np)))
289 nfsm_chain_loadattr(error, &nmrep, np, NFS_VER4, &xid);
294 if (np->n_size && (np->n_size < *buflenp))
295 len = np->n_size;
304 nfs_node_unlock(np);
312 nfsnode_t np,
326 nmp = NFSTONMP(np);
330 if (np->n_vattr.nva_flags & NFS_FFLAG_TRIGGER_REFERRAL)
333 NFSREQ_SECINFO_SET(&si, np, NULL, 0, NULL, 0);
342 nfsm_chain_add_fh(error, &nmreq, nfsvers, np->n_fhp, np->n_fhsize);
345 nfs_get_stateid(np, thd, cred, &stateid);
351 nfsm_chain_add_bitmap_supported(error, &nmreq, nfs_getattr_bitmap, nmp, np);
355 error = nfs_request_async(np, NULL, &nmreq, NFSPROC4_COMPOUND, thd, cred, &si, 0, cb, reqp);
363 nfsnode_t np,
375 nmp = NFSTONMP(np);
388 if ((lockerror = nfs_node_lock(np)))
401 nfsm_chain_loadattr(error, &nmrep, np, nfsvers, &xid);
403 nfs_node_unlock(np);
410 if (np->n_vattr.nva_flags & NFS_FFLAG_IS_ATTR)
411 microuptime(&np->n_lastio);
417 nfsnode_t np,
433 nmp = NFSTONMP(np);
437 if (np->n_vattr.nva_flags & NFS_FFLAG_TRIGGER_REFERRAL)
442 ((mp = NFSTOMP(np))) && (vfs_flags(mp) & MNT_ASYNC))
445 NFSREQ_SECINFO_SET(&si, np, NULL, 0, NULL, 0);
454 nfsm_chain_add_fh(error, &nmreq, nfsvers, np->n_fhp, np->n_fhsize);
457 nfs_get_stateid(np, thd, cred, &stateid);
466 nfsm_chain_add_bitmap_supported(error, &nmreq, nfs_getattr_bitmap, nmp, np);
471 error = nfs_request_async(np, NULL, &nmreq, NFSPROC4_COMPOUND, thd, cred, &si, 0, cb, reqp);
479 nfsnode_t np,
493 nmp = NFSTONMP(np);
505 nmp = NFSTONMP(np);
508 if (!error && (lockerror = nfs_node_lock(np)))
533 nfsm_chain_loadattr(error, &nmrep, np, nfsvers, &xid);
536 nfs_node_unlock(np);
539 ((mp = NFSTOMP(np))) && (vfs_flags(mp) & MNT_ASYNC))
542 if (np->n_vattr.nva_flags & NFS_FFLAG_IS_ATTR)
543 microuptime(&np->n_lastio);
1218 nfsnode_t np,
1231 nmp = NFSTONMP(np);
1232 FSDBG(521, np, offset, count, nmp ? nmp->nm_state : 0);
1235 if (np->n_vattr.nva_flags & NFS_FFLAG_TRIGGER_REFERRAL)
1246 NFSREQ_SECINFO_SET(&si, np, NULL, 0, NULL, 0);
1256 nfsm_chain_add_fh(error, &nmreq, nfsvers, np->n_fhp, np->n_fhsize);
1263 nfsm_chain_add_bitmap_supported(error, &nmreq, nfs_getattr_bitmap, nmp, np);
1267 error = nfs_request2(np, NULL, &nmreq, NFSPROC4_COMPOUND,
1270 if ((lockerror = nfs_node_lock(np)))
1278 nfsm_chain_loadattr(error, &nmrep, np, nfsvers, &xid);
1280 nfs_node_unlock(np);
1296 nfsnode_t np,
1303 struct nfsmount *nmp = NFSTONMP(np);
1311 if (np->n_vattr.nva_flags & NFS_FFLAG_TRIGGER_REFERRAL)
1314 NFSREQ_SECINFO_SET(&si, np, NULL, 0, NULL, 0);
1326 nfsm_chain_add_fh(error, &nmreq, nfsvers, np->n_fhp, np->n_fhsize);
1336 nfsm_chain_add_bitmap_supported(error, &nmreq, bitmap, nmp, np);
1340 error = nfs_request(np, NULL, &nmreq, NFSPROC4_COMPOUND, ctx, &si, &nmrep, &xid, &status);
1349 if ((lockerror = nfs_node_lock(np)))
1352 nfs_loadattrcache(np, &nvattr, &xid, 0);
1354 nfs_node_unlock(np);
1473 nfsnode_t np,
1477 struct nfsmount *nmp = NFSTONMP(np);
1490 if (np->n_vattr.nva_flags & NFS_FFLAG_TRIGGER_REFERRAL)
1502 if (VATTR_IS_ACTIVE(vap, va_uid) && (vap->va_uid == np->n_vattr.nva_uid))
1504 if (VATTR_IS_ACTIVE(vap, va_gid) && (vap->va_gid == np->n_vattr.nva_gid))
1506 if (VATTR_IS_ACTIVE(vap, va_uuuid) && kauth_guid_equal(&vap->va_uuuid, &np->n_vattr.nva_uuuid))
1508 if (VATTR_IS_ACTIVE(vap, va_guuid) && kauth_guid_equal(&vap->va_guuid, &np->n_vattr.nva_guuid))
1517 NFSREQ_SECINFO_SET(&si, np, NULL, 0, NULL, 0);
1529 if (NACLVALID(np))
1531 NACLINVALIDATE(np);
1540 nfsm_chain_add_fh(error, &nmreq, nfsvers, np->n_fhp, np->n_fhsize);
1544 nfs_get_stateid(np, vfs_context_thread(ctx), vfs_context_ucred(ctx), &stateid);
1551 nfsm_chain_add_bitmap_supported(error, &nmreq, getbitmap, nmp, np);
1555 error = nfs_request(np, NULL, &nmreq, NFSPROC4_COMPOUND, ctx, &si, &nmrep, &xid, &status);
1557 if ((lockerror = nfs_node_lock(np)))
1570 if (VATTR_IS_ACTIVE(vap, va_data_size) && (np->n_vattr.nva_flags & NFS_FFLAG_IS_ATTR))
1571 microuptime(&np->n_lastio);
1576 nfsm_chain_loadattr(error, &nmrep, np, nfsvers, &xid);
1578 NATTRINVALIDATE(np);
1591 np->n_xid = nextxid;
1592 NATTRINVALIDATE(np);
1596 nfs_node_unlock(np);
1755 nfs_open_state_set_busy(nfsnode_t np, thread_t thd)
1761 nmp = NFSTONMP(np);
1766 lck_mtx_lock(&np->n_openlock);
1767 while (np->n_openflags & N_OPENBUSY) {
1770 np->n_openflags |= N_OPENWANT;
1771 msleep(&np->n_openflags, &np->n_openlock, slpflag, "nfs_open_state_set_busy", &ts);
1775 np->n_openflags |= N_OPENBUSY;
1776 lck_mtx_unlock(&np->n_openlock);
1786 nfs_open_state_clear_busy(nfsnode_t np)
1790 lck_mtx_lock(&np->n_openlock);
1791 if (!(np->n_openflags & N_OPENBUSY))
1793 wanted = (np->n_openflags & N_OPENWANT);
1794 np->n_openflags &= ~(N_OPENBUSY|N_OPENWANT);
1795 lck_mtx_unlock(&np->n_openlock);
1797 wakeup(&np->n_openflags);
1975 nfsnode_t np,
1983 return nfs_open_file_find_internal(np, noop, nofpp, accessMode, denyMode, alloc);
1993 nfsnode_t np,
2002 if (!np)
2005 lck_mtx_lock(&np->n_openlock);
2006 TAILQ_FOREACH(nofp2, &np->n_opens, nof_link) {
2014 lck_mtx_unlock(&np->n_openlock);
2024 lck_mtx_unlock(&np->n_openlock);
2033 newnofp->nof_np = np;
2037 if (np)
2042 (*nofpp)->nof_np = np;
2047 if (nofp && np)
2048 TAILQ_INSERT_HEAD(&np->n_opens, nofp, nof_link);
2050 if (np)
2051 lck_mtx_unlock(&np->n_openlock);
2416 nfs_get_stateid(nfsnode_t np, thread_t thd, kauth_cred_t cred, nfs_stateid *sid)
2418 struct nfsmount *nmp = NFSTONMP(np);
2425 if (np->n_openflags & N_DELEG_MASK) {
2426 s = &np->n_dstateid;
2429 nlop = nfs_lock_owner_find(np, p, 0);
2434 (nfs_open_file_find(np, noop, &nofp, 0, 0, 0) == 0) &&
2452 if (!(np->n_vattr.nva_flags & NFS_FFLAG_IS_ATTR))
2453 NP(np, "nfs_get_stateid: no stateid");
2469 nfsnode_t np,
2497 if (np->n_dace.ace_flags) {
2499 eval.ae_acl = &np->n_dace;
2502 if (np->n_vattr.nva_uid == kauth_cred_getuid(cred))
2504 error = kauth_cred_ismember_gid(cred, np->n_vattr.nva_gid, &ismember);
2523 naa.a_vp = NFSTOV(np);
2558 nfsnode_t np,
2564 vnode_t vp = NFSTOV(np);
2579 if (np->n_openflags & N_DELEG_MASK) {
2580 if ((error = nfs_open_state_set_busy(np, vfs_context_thread(ctx))))
2582 if ((np->n_openflags & N_DELEG_MASK) && !(np->n_openflags & N_DELEG_RETURN) &&
2583 (((np->n_openflags & N_DELEG_MASK) == N_DELEG_WRITE) ||
2585 error = nfs4_open_delegated(np, nofp, accessMode, denyMode, ctx);
2586 nfs_open_state_clear_busy(np);
2589 nfs_open_state_clear_busy(np);
2598 if ((np->n_vattr.nva_flags & NFS_FFLAG_IS_ATTR) &&
2599 (((dvp = np->n_parent)) && (error = vnode_get(dvp))))
2665 nfsnode_t np = VTONFS(vp);
2677 if (np->n_flag & NREVOKE)
2700 if (np->n_flag & NREVOKE) {
2707 error = nfs_open_file_find(np, noop, &nofp, 0, 0, 1);
2709 NP(np, "nfs_vnop_mmap: no open file for owner, error %d, %d", error, kauth_cred_getuid(noop->noo_cred));
2746 error = nfs4_open(np, nofp, NFS_OPEN_SHARE_ACCESS_READ, NFS_OPEN_SHARE_DENY_NONE, ctx);
2810 error = nfs_close(np, nofp, nofp->nof_mmap_access, nofp->nof_mmap_deny, ctx);
2813 NP(np, "nfs_vnop_mmap: close of previous mmap mode failed: %d, %d", error, kauth_cred_getuid(nofp->nof_owner->noo_cred));
2814 NP(np, "nfs_vnop_mmap: update, close error %d, %d", error, kauth_cred_getuid(nofp->nof_owner->noo_cred));
2836 nfs_node_lock_force(np);
2837 if ((np->n_flag & NISMAPPED) == 0) {
2838 np->n_flag |= NISMAPPED;
2841 nfs_node_unlock(np);
2867 nfsnode_t np = VTONFS(vp);
2878 nfs_node_lock_force(np);
2879 if (np->n_flag & NISMAPPED) {
2881 np->n_flag &= ~NISMAPPED;
2883 nfs_node_unlock(np);
2889 NP(np, "nfs_vnop_mnomap: removing mmap reference from mount, but mount has no files mmapped");
2894 nfs_flush(np, MNT_WAIT, vfs_context_thread(ctx), V_IGNORE_WRITEERR);
2903 lck_mtx_lock(&np->n_openlock);
2904 TAILQ_FOREACH(nofp, &np->n_opens, nof_link) {
2907 lck_mtx_unlock(&np->n_openlock);
2917 lck_mtx_lock(&np->n_openlock);
2921 error = nfs_close(np, nofp, nofp->nof_mmap_access, nofp->nof_mmap_deny, ctx);
2924 NP(np, "nfs_vnop_mnomap: close of mmap mode failed: %d, %d", error, kauth_cred_getuid(nofp->nof_owner->noo_cred));
2928 NP(np, "nfs_vnop_mnomap: error %d, %d", error, kauth_cred_getuid(nofp->nof_owner->noo_cred));
2934 lck_mtx_unlock(&np->n_openlock);
2944 nfs_lock_owner_find(nfsnode_t np, proc_t p, int alloc)
2950 lck_mtx_lock(&np->n_openlock);
2951 TAILQ_FOREACH(nlop, &np->n_lock_owners, nlo_link) {
2958 TAILQ_REMOVE(&np->n_lock_owners, nlop, nlo_link);
2960 lck_mtx_unlock(&np->n_openlock);
2970 lck_mtx_unlock(&np->n_openlock);
2984 TAILQ_INSERT_HEAD(&np->n_lock_owners, newnlop, nlo_link);
2987 lck_mtx_unlock(&np->n_openlock);
3201 nfsnode_t np,
3217 nmp = NFSTONMP(np);
3220 if (np->n_vattr.nva_flags & NFS_FFLAG_TRIGGER_REFERRAL)
3254 NFSREQ_SECINFO_SET(&si, np, NULL, 0, NULL, 0);
3264 nfsm_chain_add_fh(error, &nmreq, NFS_VER4, np->n_fhp, np->n_fhsize);
3267 nfsm_chain_add_bitmap_supported(error, &nmreq, nfs_getattr_bitmap, nmp, np);
3288 error = nfs_request2(np, NULL, &nmreq, NFSPROC4_COMPOUND, thd, cred, &si, flags|R_NOINTR, &nmrep, &xid, &status);
3290 if ((lockerror = nfs_node_lock(np)))
3297 nfsm_chain_loadattr(error, &nmrep, np, NFS_VER4, &xid);
3309 nfs_node_unlock(np);
3325 nfsnode_t np,
3340 nmp = NFSTONMP(np);
3343 if (np->n_vattr.nva_flags & NFS_FFLAG_TRIGGER_REFERRAL)
3350 NFSREQ_SECINFO_SET(&si, np, NULL, 0, NULL, 0);
3360 nfsm_chain_add_fh(error, &nmreq, NFS_VER4, np->n_fhp, np->n_fhsize);
3363 nfsm_chain_add_bitmap_supported(error, &nmreq, nfs_getattr_bitmap, nmp, np);
3375 error = nfs_request2(np, NULL, &nmreq, NFSPROC4_COMPOUND, thd, cred, &si, flags|R_NOINTR, &nmrep, &xid, &status);
3377 if ((lockerror = nfs_node_lock(np)))
3384 nfsm_chain_loadattr(error, &nmrep, np, NFS_VER4, &xid);
3391 nfs_node_unlock(np);
3403 nfsnode_t np,
3417 nmp = NFSTONMP(np);
3420 if (np->n_vattr.nva_flags & NFS_FFLAG_TRIGGER_REFERRAL)
3424 NFSREQ_SECINFO_SET(&si, np, NULL, 0, NULL, 0);
3434 nfsm_chain_add_fh(error, &nmreq, NFS_VER4, np->n_fhp, np->n_fhsize);
3437 nfsm_chain_add_bitmap_supported(error, &nmreq, nfs_getattr_bitmap, nmp, np);
3448 error = nfs_request(np, NULL, &nmreq, NFSPROC4_COMPOUND, ctx, &si, &nmrep, &xid, &status);
3450 if ((lockerror = nfs_node_lock(np)))
3457 nfsm_chain_loadattr(error, &nmrep, np, NFS_VER4, &xid);
3474 nfs_node_unlock(np);
3490 nfsnode_t np,
3501 nmp = NFSTONMP(np);
3509 lck_mtx_lock(&np->n_openlock);
3511 TAILQ_FOREACH(nflp, &np->n_locks, nfl_link) {
3526 } else if ((np->n_openflags & N_DELEG_WRITE) && !(np->n_openflags & N_DELEG_RETURN)) {
3534 lck_mtx_unlock(&np->n_openlock);
3541 error = nmp->nm_funcs->nf_getlock_rpc(np, nlop, fl, start, end, ctx);
3561 nfsnode_t np,
3577 nmp = NFSTONMP(np);
3618 if (np->n_flag & NREVOKE) {
3633 lck_mtx_lock(&np->n_openlock);
3636 TAILQ_INSERT_HEAD(&np->n_locks, newnflp, nfl_link);
3659 lck_mtx_unlock(&np->n_openlock);
3662 error = nfs_advlock_unlock(np, nofp, nlop, 0, UINT64_MAX, NFS_FILE_LOCK_STYLE_FLOCK, ctx);
3667 lck_mtx_lock(&np->n_openlock);
3671 lck_mtx_lock(&np->n_openlock);
3676 msleep(nflp, &np->n_openlock, slpflag, "nfs_advlock_setlock_blocked", &ts);
3678 error = nfs_sigintr(NFSTONMP(np), NULL, vfs_context_thread(ctx), 0);
3682 lck_mtx_unlock(&np->n_openlock);
3685 lck_mtx_lock(&np->n_openlock);
3688 if (!error && (np->n_flag & NREVOKE))
3693 TAILQ_REMOVE(&np->n_locks, nflp, nfl_link);
3702 lck_mtx_unlock(&np->n_openlock);
3722 if ((error = nfs_open_state_set_busy(np, vfs_context_thread(ctx))))
3728 if ((np->n_openflags & N_DELEG_MASK) && !(np->n_openflags & N_DELEG_RETURN)) {
3729 if (np->n_openflags & N_DELEG_WRITE) {
3758 if (np->n_flag & NREVOKE)
3761 error = nmp->nm_funcs->nf_setlock_rpc(np, nofp, newnflp, 0, 0, vfs_context_thread(ctx), vfs_context_ucred(ctx));
3771 nfs_open_state_clear_busy(np);
3775 error2 = nfs_advlock_unlock(np, nofp, nlop, 0, UINT64_MAX, NFS_FILE_LOCK_STYLE_FLOCK, ctx);
3781 error2 = nfs_open_state_set_busy(np, vfs_context_thread(ctx));
3801 error = nfs_sigintr(NFSTONMP(np), NULL, vfs_context_thread(ctx), 0);
3804 nfs_open_state_clear_busy(np);
3810 if (!error && (np->n_flag & NREVOKE))
3818 nfs_open_state_clear_busy(np);
3827 lck_mtx_lock(&np->n_openlock);
3837 TAILQ_REMOVE(&np->n_locks, newnflp, nfl_link);
3840 lck_mtx_unlock(&np->n_openlock);
3842 nfs_open_state_clear_busy(np);
3859 TAILQ_FOREACH_SAFE(nflp, &np->n_locks, nfl_link, nextnflp) {
3887 TAILQ_INSERT_AFTER(&np->n_locks, nflp, nflp2, nfl_link);
3903 TAILQ_REMOVE(&np->n_locks, nflp, nfl_link);
3924 TAILQ_FOREACH_SAFE(nflp, &np->n_locks, nfl_link, nextnflp) {
3957 TAILQ_REMOVE(&np->n_locks, nflp, nfl_link);
3963 lck_mtx_unlock(&np->n_openlock);
3964 nfs_open_state_clear_busy(np);
3977 nfsnode_t np,
3989 nmp = NFSTONMP(np);
4003 if ((error = nfs_open_state_set_busy(np, NULL))) {
4008 lck_mtx_lock(&np->n_openlock);
4015 TAILQ_FOREACH_SAFE(nflp, &np->n_locks, nfl_link, nextnflp) {
4030 lck_mtx_unlock(&np->n_openlock);
4031 nfs_open_state_clear_busy(np);
4071 lck_mtx_unlock(&np->n_openlock);
4072 error = nmp->nm_funcs->nf_unlock_rpc(np, nlop, type, s, nflp->nfl_start-1, 0,
4075 nfs_open_state_clear_busy(np);
4079 lck_mtx_lock(&np->n_openlock);
4087 lck_mtx_unlock(&np->n_openlock);
4088 error = nmp->nm_funcs->nf_unlock_rpc(np, nlop, type, s, end, 0,
4091 nfs_open_state_clear_busy(np);
4095 lck_mtx_lock(&np->n_openlock);
4102 TAILQ_FOREACH_SAFE(nflp, &np->n_locks, nfl_link, nextnflp) {
4115 lck_mtx_unlock(&np->n_openlock);
4116 error = nmp->nm_funcs->nf_unlock_rpc(np, nlop, nflp->nfl_type, nflp->nfl_start, nflp->nfl_end, 0,
4119 nfs_open_state_clear_busy(np);
4123 lck_mtx_lock(&np->n_openlock);
4137 lck_mtx_unlock(&np->n_openlock);
4138 error = nmp->nm_funcs->nf_unlock_rpc(np, nlop, nflp->nfl_type, start, end, 0,
4141 nfs_open_state_clear_busy(np);
4145 lck_mtx_lock(&np->n_openlock);
4155 TAILQ_INSERT_AFTER(&np->n_locks, nflp, newnflp, nfl_link);
4162 lck_mtx_unlock(&np->n_openlock);
4163 error = nmp->nm_funcs->nf_unlock_rpc(np, nlop, nflp->nfl_type, start, nflp->nfl_end, 0,
4166 nfs_open_state_clear_busy(np);
4170 lck_mtx_lock(&np->n_openlock);
4179 lck_mtx_unlock(&np->n_openlock);
4180 error = nmp->nm_funcs->nf_unlock_rpc(np, nlop, nflp->nfl_type, nflp->nfl_start, end, 0,
4183 nfs_open_state_clear_busy(np);
4187 lck_mtx_lock(&np->n_openlock);
4199 TAILQ_REMOVE(&np->n_locks, nflp, nfl_link);
4204 lck_mtx_unlock(&np->n_openlock);
4205 nfs_open_state_clear_busy(np);
4229 nfsnode_t np = VTONFS(ap->a_vp);
4254 if (np->n_flag & NREVOKE)
4275 if ((error = nfs_node_lock(np)))
4277 modified = (np->n_flag & NMODIFIED);
4278 nfs_node_unlock(np);
4281 if ((error = nfs_getattr(np, NULL, ctx, NGA_UNCACHED)))
4283 nfs_data_lock(np, NFS_DATA_LOCK_SHARED);
4284 if ((np->n_size > OFF_MAX) ||
4285 ((fl->l_start > 0) && (np->n_size > (u_quad_t)(OFF_MAX - fl->l_start))))
4287 lstart = np->n_size + fl->l_start;
4288 nfs_data_unlock(np);
4318 nlop = nfs_lock_owner_find(np, vfs_context_proc(ctx), (op != F_UNLCK));
4322 NP(np, "nfs_vnop_advlock: no lock owner, error %d", error);
4327 error = nfs_advlock_getlock(np, nlop, fl, start, end, ctx);
4332 NP(np, "nfs_vnop_advlock: no open owner %d", kauth_cred_getuid(vfs_context_ucred(ctx)));
4338 error = nfs_open_file_find(np, noop, &nofp, 0, 0, 0);
4342 NP(np, "nfs_vnop_advlock: LOST %d", kauth_cred_getuid(nofp->nof_owner->noo_cred));
4352 NP(np, "nfs_vnop_advlock: no open file %d, %d", error, kauth_cred_getuid(noop->noo_cred));
4356 error = nfs_advlock_unlock(np, nofp, nlop, start, end, style, ctx);
4360 error = nfs_advlock_setlock(np, nofp, nlop, op, start, end, style, fl->l_type, ctx);
4400 nfsnode_t np = nofp->nof_np;
4401 vnode_t vp = NFSTOV(np);
4426 nfs_node_lock_force(np);
4427 if ((vnode_vtype(vp) != VDIR) && np->n_sillyrename) {
4432 struct nfs_sillyrename *nsp = np->n_sillyrename;
4435 nfs_node_unlock(np);
4446 if ((np->n_vattr.nva_flags & NFS_FFLAG_IS_ATTR) &&
4447 (((dvp = np->n_parent)) && (error = vnode_get(dvp))))
4455 nfs_node_unlock(np);
4470 nfs_node_unlock(np);
4498 nfs_revoke_open_state_for_node(np);
4638 nfsnode_t np, newnp = NULL;
4663 np = *vpp ? VTONFS(*vpp) : NULL;
4731 nfsm_chain_add_bitmap_supported(error, &nmreq, bitmap, nmp, np);
4830 if (!create && np && !NFS_CMPFH(np, fh.fh_data, fh.fh_len)) {
4833 if (!(np->n_vattr.nva_flags & NFS_FFLAG_IS_ATTR))
4834 NP(np, "nfs4_open_rpc: warning: file handle mismatch");
4874 if (!error && !np && fh.fh_len) {
4885 if (!np)
4886 np = newnp;
4887 if (!error && np && !recall) {
4889 lck_mtx_lock(&np->n_openlock);
4890 np->n_openflags &= ~N_DELEG_MASK;
4891 np->n_openflags |= ((delegation == NFS_OPEN_DELEGATE_READ) ? N_DELEG_READ : N_DELEG_WRITE);
4892 np->n_dstateid = dstateid;
4893 np->n_dace = ace;
4894 if (np->n_dlink.tqe_next == NFSNOLIST) {
4896 if (np->n_dlink.tqe_next == NFSNOLIST)
4897 TAILQ_INSERT_TAIL(&nmp->nm_delegations, np, n_dlink);
4900 lck_mtx_unlock(&np->n_openlock);
4903 if (np) {
4904 if (NFS_CMPFH(np, fh.fh_data, fh.fh_len)) {
4906 lck_mtx_lock(&np->n_openlock);
4907 np->n_openflags &= ~N_DELEG_MASK;
4908 np->n_openflags |= ((delegation == NFS_OPEN_DELEGATE_READ) ? N_DELEG_READ : N_DELEG_WRITE);
4909 np->n_dstateid = dstateid;
4910 np->n_dace = ace;
4911 if (np->n_dlink.tqe_next == NFSNOLIST) {
4913 if (np->n_dlink.tqe_next == NFSNOLIST)
4914 TAILQ_INSERT_TAIL(&nmp->nm_delegations, np, n_dlink);
4917 lck_mtx_unlock(&np->n_openlock);
4921 /* return np's current delegation */
4922 nfs4_delegation_return(np, 0, thd, cred);
4924 if (fh.fh_len) /* return fh's delegation if it wasn't for np */
4975 nfsnode_t np = nofp->nof_np;
4992 nmp = NFSTONMP(np);
4997 nfs_node_lock_force(np);
4998 if ((vnode_vtype(NFSTOV(np)) != VDIR) && np->n_sillyrename) {
5003 struct nfs_sillyrename *nsp = np->n_sillyrename;
5006 nfs_node_unlock(np);
5017 if ((np->n_vattr.nva_flags & NFS_FFLAG_IS_ATTR) &&
5018 (((dvp = np->n_parent)) && (error = vnode_get(dvp))))
5021 dvp = vnode_getparent(NFSTOV(np));
5022 vname = vnode_getname(NFSTOV(np));
5026 nfs_node_unlock(np);
5041 nfs_node_unlock(np);
5048 dstateid = np->n_dstateid;
5074 nfsm_chain_add_stateid(error, &nmreq, &np->n_dstateid);
5080 nfsm_chain_add_bitmap_supported(error, &nmreq, bitmap, nmp, np);
5085 error = nfs_request2(np, nmp->nm_mountp, &nmreq, NFSPROC4_COMPOUND, current_thread(),
5088 if ((lockerror = nfs_node_lock(np)))
5097 nfsm_chain_check_change_info(error, &nmrep, np);
5105 // if (!(np->n_openflags & N_DELEG_RETURN)) /* don't warn if delegation is being returned */
5110 if ((((np->n_openflags & N_DELEG_MASK) == N_DELEG_READ) &&
5112 (((np->n_openflags & N_DELEG_MASK) == N_DELEG_WRITE) &&
5115 ((np->n_openflags & N_DELEG_MASK) == N_DELEG_WRITE) ? "W" : "R",
5152 lck_mtx_lock(&np->n_openlock);
5153 np->n_openflags &= ~N_DELEG_MASK;
5154 np->n_openflags |= ((delegation == NFS_OPEN_DELEGATE_READ) ? N_DELEG_READ : N_DELEG_WRITE);
5155 np->n_dstateid = dstateid;
5156 np->n_dace = ace;
5157 if (np->n_dlink.tqe_next == NFSNOLIST) {
5159 if (np->n_dlink.tqe_next == NFSNOLIST)
5160 TAILQ_INSERT_TAIL(&nmp->nm_delegations, np, n_dlink);
5163 lck_mtx_unlock(&np->n_openlock);
5179 if (!NFS_CMPFH(np, fh.fh_data, fh.fh_len)) {
5182 if (!(np->n_vattr.nva_flags & NFS_FFLAG_IS_ATTR))
5185 error = nfs_loadattrcache(np, &nvattr, &xid, 1);
5194 nfs_node_unlock(np);
5203 nfs4_delegation_return_enqueue(np);
5233 nfsnode_t np = nofp->nof_np;
5244 nmp = NFSTONMP(np);
5254 dstateid = np->n_dstateid;
5255 NFSREQ_SECINFO_SET(&si, np, NULL, 0, NULL, 0);
5266 nfsm_chain_add_fh(error, &nmreq, nfsvers, np->n_fhp, np->n_fhsize);
5280 delegation = (np->n_openflags & N_DELEG_READ) ? NFS_OPEN_DELEGATE_READ :
5281 (np->n_openflags & N_DELEG_WRITE) ? NFS_OPEN_DELEGATE_WRITE :
5289 nfsm_chain_add_bitmap_supported(error, &nmreq, bitmap, nmp, np);
5294 error = nfs_request2(np, nmp->nm_mountp, &nmreq, NFSPROC4_COMPOUND, current_thread(),
5297 if ((lockerror = nfs_node_lock(np)))
5306 nfsm_chain_check_change_info(error, &nmrep, np);
5314 if (np->n_openflags & N_DELEG_MASK) {
5321 // NP(np, "nfs: open reclaim didn't return delegation?");
5322 delegation = (np->n_openflags & N_DELEG_WRITE) ? NFS_OPEN_DELEGATE_WRITE : NFS_OPEN_DELEGATE_READ;
5363 lck_mtx_lock(&np->n_openlock);
5364 np->n_openflags &= ~N_DELEG_MASK;
5365 np->n_openflags |= ((delegation == NFS_OPEN_DELEGATE_READ) ? N_DELEG_READ : N_DELEG_WRITE);
5366 np->n_dstateid = dstateid;
5367 np->n_dace = ace;
5368 if (np->n_dlink.tqe_next == NFSNOLIST) {
5370 if (np->n_dlink.tqe_next == NFSNOLIST)
5371 TAILQ_INSERT_TAIL(&nmp->nm_delegations, np, n_dlink);
5374 lck_mtx_unlock(&np->n_openlock);
5386 NP(np, "nfs: open reclaim didn't return filehandle?");
5390 if (!NFS_CMPFH(np, fh.fh_data, fh.fh_len)) {
5395 if (!(np->n_vattr.nva_flags & NFS_FFLAG_IS_ATTR))
5396 NP(np, "nfs4_open_reclaim_rpc: warning: file handle mismatch");
5398 error = nfs_loadattrcache(np, &nvattr, &xid, 1);
5404 // NP(np, "nfs: open reclaim (%d, %d) succeeded", share_access, share_deny);
5409 nfs_node_unlock(np);
5413 nfs4_delegation_return_enqueue(np);
5420 nfsnode_t np,
5431 nmp = NFSTONMP(np);
5439 NFSREQ_SECINFO_SET(&si, np, NULL, 0, NULL, 0);
5449 nfsm_chain_add_fh(error, &nmreq, nfsvers, np->n_fhp, np->n_fhsize);
5458 nfsm_chain_add_bitmap_supported(error, &nmreq, nfs_getattr_bitmap, nmp, np);
5462 error = nfs_request2(np, NULL, &nmreq, NFSPROC4_COMPOUND,
5466 if ((lockerror = nfs_node_lock(np)))
5476 nfsm_chain_loadattr(error, &nmrep, np, nfsvers, &xid);
5479 nfs_node_unlock(np);
5488 nfsnode_t np,
5501 nmp = NFSTONMP(np);
5509 NFSREQ_SECINFO_SET(&si, np, NULL, 0, NULL, 0);
5519 nfsm_chain_add_fh(error, &nmreq, nfsvers, np->n_fhp, np->n_fhsize);
5526 nfsm_chain_add_bitmap_supported(error, &nmreq, nfs_getattr_bitmap, nmp, np);
5530 error = nfs_request2(np, NULL, &nmreq, NFSPROC4_COMPOUND, thd, cred, &si, flags|R_NOINTR, &nmrep, &xid, &status);
5532 if ((lockerror = nfs_node_lock(np)))
5542 nfsm_chain_loadattr(error, &nmrep, np, nfsvers, &xid);
5545 nfs_node_unlock(np);
5751 nfs_release_open_state_for_node(nfsnode_t np, int force)
5753 struct nfsmount *nmp = NFSTONMP(np);
5758 TAILQ_FOREACH_SAFE(nflp, &np->n_locks, nfl_link, nextnflp) {
5764 nmp->nm_funcs->nf_unlock_rpc(np, nflp->nfl_owner, F_WRLCK, nflp->nfl_start, nflp->nfl_end, R_RECOVER,
5767 lck_mtx_lock(&np->n_openlock);
5777 TAILQ_REMOVE(&np->n_locks, nflp, nfl_link);
5780 lck_mtx_unlock(&np->n_openlock);
5783 lck_mtx_lock(&np->n_openlock);
5786 TAILQ_FOREACH(nofp, &np->n_opens, nof_link) {
5796 nfs4_close_rpc(np, nofp, NULL, nofp->nof_owner->noo_cred, R_RECOVER);
5799 lck_mtx_unlock(&np->n_openlock);
5808 nfs_revoke_open_state_for_node(nfsnode_t np)
5813 nfs_node_lock_force(np);
5814 if (np->n_flag & NREVOKE) /* already revoked? */
5816 NP(np, "nfs_revoke_open_state_for_node(): already revoked");
5817 nfs_node_unlock(np);
5820 np->n_flag |= NREVOKE;
5821 nfs_node_unlock(np);
5823 nfs_release_open_state_for_node(np, 0);
5824 NP(np, "nfs: state lost for %p 0x%x", np, np->n_flag);
5827 if ((nmp = NFSTONMP(np))) {
5839 nfs4_claim_delegated_state_for_node(nfsnode_t np, int flags)
5844 lck_mtx_lock(&np->n_openlock);
5848 TAILQ_FOREACH(nofp, &np->n_opens, nof_link) {
5853 lck_mtx_unlock(&np->n_openlock);
5855 lck_mtx_lock(&np->n_openlock);
5861 lck_mtx_unlock(&np->n_openlock);
5872 nfs4_delegation_return_enqueue(nfsnode_t np)
5876 nmp = NFSTONMP(np);
5880 lck_mtx_lock(&np->n_openlock);
5881 np->n_openflags |= N_DELEG_RETURN;
5882 lck_mtx_unlock(&np->n_openlock);
5885 if (np->n_dreturn.tqe_next == NFSNOLIST)
5886 TAILQ_INSERT_TAIL(&nmp->nm_dreturnq, np, n_dreturn);
5895 nfs4_delegation_return(nfsnode_t np, int flags, thread_t thd, kauth_cred_t cred)
5902 nmp = NFSTONMP(np);
5907 lck_mtx_lock(&np->n_openlock);
5908 np->n_openflags |= (N_DELEG_RETURN|N_DELEG_RETURNING);
5909 lck_mtx_unlock(&np->n_openlock);
5912 if ((error = nfs_open_state_set_busy(np, NULL)))
5916 if ((error = nfs4_claim_delegated_state_for_node(np, flags)))
5920 lck_mtx_lock(&np->n_openlock);
5921 dstateid = np->n_dstateid;
5922 fh.fh_len = np->n_fhsize;
5923 bcopy(np->n_fhp, &fh.fh_data, fh.fh_len);
5924 lck_mtx_unlock(&np->n_openlock);
5925 error = nfs4_delegreturn_rpc(NFSTONMP(np), fh.fh_data, fh.fh_len, &dstateid, flags, thd, cred);
5928 lck_mtx_lock(&np->n_openlock);
5929 np->n_openflags &= ~N_DELEG_MASK;
5931 if (np->n_dlink.tqe_next != NFSNOLIST) {
5932 TAILQ_REMOVE(&nmp->nm_delegations, np, n_dlink);
5933 np->n_dlink.tqe_next = NFSNOLIST;
5936 lck_mtx_unlock(&np->n_openlock);
5942 if (np->n_dreturn.tqe_next != NFSNOLIST) {
5943 TAILQ_REMOVE(&nmp->nm_dreturnq, np, n_dreturn);
5944 np->n_dreturn.tqe_next = NFSNOLIST;
5947 lck_mtx_lock(&np->n_openlock);
5948 np->n_openflags &= ~(N_DELEG_RETURN|N_DELEG_RETURNING);
5949 lck_mtx_unlock(&np->n_openlock);
5952 NP(np, "nfs4_delegation_return, error %d", error);
5963 nfs_open_state_clear_busy(np);
6027 nfsnode_t np;
6036 np = VTONFS(vp);
6037 nmp = NFSTONMP(np);
6040 if (np->n_flag & NREVOKE)
6047 error = nfs_open_file_find(np, noop, &nofp, 0, 0, 1);
6049 NP(np, "nfs_vnop_read: LOST %d", kauth_cred_getuid(noop->noo_cred));
6069 if (np->n_flag & NREVOKE) {
6083 error = nfs4_open(np, nofp, NFS_OPEN_SHARE_ACCESS_READ, NFS_OPEN_SHARE_DENY_NONE, ctx);
6123 nfsnode_t np;
6193 int error2 = nfs_lookitup(VTONFS(dvp), cnp->cn_nameptr, cnp->cn_namelen, ctx, &np);
6194 if (!error2 && np) {
6195 nfs_node_unlock(np);
6196 *vpp = NFSTOV(np);
6197 if (vnode_vtype(NFSTOV(np)) == VREG) {
6200 if (!nfs4_setattr_rpc(np, &vattr, ctx)) {
6204 nfs4_setattr_rpc(np, &vattr, ctx);
6228 np = VTONFS(*vpp);
6231 error = nfs_open_file_find_internal(np, noop, &nofp, 0, 0, 0);
6287 nfsnode_t np = NULL;
6435 error = nfs_nget(NFSTOMP(dnp), dnp, cnp, fh.fh_data, fh.fh_len, &nvattr, &xid, rq.r_auth, NG_MAKEENTRY, &np);
6437 newvp = NFSTOV(np);
6449 error = nfs_lookitup(dnp, cnp->cn_nameptr, cnp->cn_namelen, ctx, &np);
6451 newvp = NFSTOV(np);
6460 nfs_node_unlock(np);
6464 nfs_node_unlock(np);
6465 *npp = np;
6481 nfsnode_t np = NULL;
6502 vtonfs_type(ap->a_vap->va_type, nmp->nm_vers), NULL, &np);
6504 *ap->a_vpp = NFSTOV(np);
6519 nfsnode_t np = NULL;
6523 NFDIR, NULL, &np);
6525 *ap->a_vpp = NFSTOV(np);
6541 nfsnode_t np = NULL;
6545 NFLNK, ap->a_target, &np);
6547 *ap->a_vpp = NFSTOV(np);
6567 nfsnode_t np = VTONFS(vp);
6581 if (np->n_vattr.nva_flags & NFS_FFLAG_TRIGGER_REFERRAL)
6591 nfs_flush(np, MNT_WAIT, vfs_context_thread(ctx), V_IGNORE_WRITEERR);
6593 if ((error = nfs_node_set_busy2(tdnp, np, vfs_context_thread(ctx))))
6596 NFSREQ_SECINFO_SET(&si, np, NULL, 0, NULL, 0);
6606 nfsm_chain_add_fh(error, &nmreq, nfsvers, np->n_fhp, np->n_fhsize);
6622 nfsm_chain_add_bitmap_supported(error, &nmreq, nfs_getattr_bitmap, nmp, np);
6628 if ((lockerror = nfs_node_lock2(tdnp, np))) {
6649 nfsm_chain_loadattr(error, &nmrep, np, nfsvers, &xid);
6651 NATTRINVALIDATE(np);
6665 nfs_node_unlock2(tdnp, np);
6666 nfs_node_clear_busy2(tdnp, np);
6686 nfsnode_t np = VTONFS(vp);
6698 if ((error = nfs_node_set_busy2(dnp, np, vfs_context_thread(ctx))))
6709 nfs_name_cache_purge(dnp, np, cnp, ctx);
6714 nfs_node_clear_busy2(dnp, np);
6728 if (np->n_hflag & NHHASHED) {
6729 LIST_REMOVE(np, n_hash);
6730 np->n_hflag &= ~NHHASHED;
6731 FSDBG(266, 0, np, np->n_flag, 0xb1eb1e);
6763 nfs4_named_attr_dir_get(nfsnode_t np, int fetch, vfs_context_t ctx)
6777 nmp = NFSTONMP(np);
6780 if (np->n_vattr.nva_flags & NFS_FFLAG_TRIGGER_REFERRAL)
6783 NFSREQ_SECINFO_SET(&si, np, NULL, 0, NULL, 0);
6793 if (np->n_attrdirfh) {
6794 // XXX can't set parent correctly (to np) yet
6795 error = nfs_nget(nmp->nm_mountp, NULL, &cn, np->n_attrdirfh+1, *np->n_attrdirfh,
6811 nfsm_chain_add_fh(error, &nmreq, nmp->nm_vers, np->n_fhp, np->n_fhsize);
6824 error = nfs_request_async(np, NULL, &nmreq, NFSPROC4_COMPOUND,
6841 if (!np->n_attrdirfh || (*np->n_attrdirfh != fh.fh_len)) {
6843 if (np->n_attrdirfh)
6844 FREE(np->n_attrdirfh, M_TEMP);
6845 MALLOC(np->n_attrdirfh, u_char*, fh.fh_len+1, M_TEMP, M_WAITOK);
6847 if (!np->n_attrdirfh) {
6852 *np->n_attrdirfh = fh.fh_len;
6853 bcopy(fh.fh_data, np->n_attrdirfh+1, fh.fh_len);
6855 // XXX can't set parent correctly (to np) yet
6856 error = nfs_nget(NFSTOMP(np), NULL, &cn, fh.fh_data, fh.fh_len, &nvattr, &xid, rq.r_auth, 0, &adnp);
6903 nfsnode_t np,
6945 nmp = NFSTONMP(np);
6958 error = nfs_getattr(np, &nvattr, ctx, NGA_CACHED);
6985 if ((error = busyerror = nfs_node_set_busy(np, vfs_context_thread(ctx))))
6988 adnp = nfs4_named_attr_dir_get(np, 0, ctx);
6996 NFSREQ_SECINFO_SET(&si, np, NULL, 0, NULL, 0);
7146 nfsm_chain_add_fh(error, &nmreq, nmp->nm_vers, np->n_fhp, np->n_fhsize);
7198 nfsm_chain_add_fh(error, &nmreq, nmp->nm_vers, np->n_fhp, np->n_fhsize);
7224 error = nfs_request_async(hadattrdir ? adnp : np, NULL, &nmreq, NFSPROC4_COMPOUND,
7242 if (!np->n_attrdirfh || (*np->n_attrdirfh != fh.fh_len)) {
7244 if (np->n_attrdirfh)
7245 FREE(np->n_attrdirfh, M_TEMP);
7246 MALLOC(np->n_attrdirfh, u_char*, fh.fh_len+1, M_TEMP, M_WAITOK);
7248 if (np->n_attrdirfh) {
7250 *np->n_attrdirfh = fh.fh_len;
7251 bcopy(fh.fh_data, np->n_attrdirfh+1, fh.fh_len);
7258 // XXX can't set parent correctly (to np) yet
7259 error = nfs_nget(NFSTOMP(np), NULL, &cn, fh.fh_data, fh.fh_len, &nvattr, &xid, rq.r_auth, 0, &adnp);
7359 error = nfs4_open_confirm_rpc(nmp, adnp ? adnp : np, fh.fh_data, fh.fh_len, noop, &newnofp->nof_stateid, thd, cred, &nvattr, &xid);
7391 error = nfs_nget(NFSTOMP(np), adnp, cnp, fh.fh_data, fh.fh_len, &nvattr, &xid, rq.r_auth, NG_MAKEENTRY, &anp);
7604 nfs_node_clear_busy(np);
7622 nfs4_named_attr_remove(nfsnode_t np, nfsnode_t anp, const char *name, vfs_context_t ctx)
7630 nmp = NFSTONMP(np);
7641 error = nfs4_named_attr_get(np, &cn, NFS_OPEN_SHARE_ACCESS_NONE,
7655 if ((error = nfs_node_set_busy(np, vfs_context_thread(ctx))))
7657 adnp = nfs4_named_attr_dir_get(np, 1, ctx);
7658 nfs_node_clear_busy(np);
7924 nfsnode_t np = VTONFS(ap->a_vp);
7942 error = nfs_getattr(np, &nvattr, ctx, NGA_CACHED);
7949 if ((error = nfs_node_set_busy(np, vfs_context_thread(ctx))))
7951 adnp = nfs4_named_attr_dir_get(np, 1, ctx);
7952 nfs_node_clear_busy(np);
8164 nfsnode_t np = ap->a_vp ? VTONFS(ap->a_vp) : NULL;
8177 return (nfs4_named_attr_remove(np, anp, ap->a_name, ap->a_context));