Lines Matching refs:np
455 nfs_node_access_slot(nfsnode_t np, uid_t uid, int add)
460 if (np->n_accessuid[slot] == uid)
465 slot = np->n_access[NFS_ACCESS_CACHE_SIZE];
466 np->n_access[NFS_ACCESS_CACHE_SIZE] = (slot + 1) % NFS_ACCESS_CACHE_SIZE;
472 nfs3_access_rpc(nfsnode_t np, u_int32_t *access, vfs_context_t ctx)
485 nfsm_chain_add_fh(error, &nmreq, NFS_VER3, np->n_fhp, np->n_fhsize);
489 error = nfs_request(np, NULL, &nmreq, NFSPROC_ACCESS, ctx, NULL, &nmrep, &xid, &status);
490 if ((lockerror = nfs_node_lock(np)))
492 nfsm_chain_postop_attr_update(error, &nmrep, np, &xid);
499 slot = nfs_node_access_slot(np, uid, 1);
500 np->n_accessuid[slot] = uid;
502 np->n_accessstamp[slot] = now.tv_sec;
503 np->n_access[slot] = access_result;
513 !(np->n_access[slot] & NFS_ACCESS_DELETE))
514 np->n_access[slot] |= NFS_ACCESS_DELETE;
516 if (nfs_access_dotzfs && (np->n_flag & NISDOTZFSCHILD))
517 np->n_access[slot] |= (NFS_ACCESS_MODIFY|NFS_ACCESS_EXTEND|NFS_ACCESS_DELETE);
519 *access = np->n_access[slot];
522 nfs_node_unlock(np);
547 nfsnode_t np = VTONFS(vp);
626 if ((error = nfs_node_lock(np)))
634 slot = nfs_node_access_slot(np, uid, 0);
641 } else if (NACCESSVALID(np, slot)) {
643 if ((now.tv_sec < (np->n_accessstamp[slot] + nfs_access_cache_timeout)) &&
644 ((np->n_access[slot] & access) == access)) {
647 waccess = np->n_access[slot];
650 nfs_node_unlock(np);
654 error = nmp->nm_funcs->nf_access_rpc(np, &waccess, ctx);
681 nfsnode_t np = VTONFS(vp);
694 if (np->n_flag & NREVOKE)
702 if (ISSET(np->n_flag, NUPDATESIZE))
703 nfs_data_update_size(np, 0);
704 if ((error = nfs_node_lock(np)))
706 if (np->n_flag & NNEEDINVALIDATE) {
707 np->n_flag &= ~NNEEDINVALIDATE;
709 nfs_invaldir(np);
710 nfs_node_unlock(np);
712 if ((error = nfs_node_lock(np)))
716 np->n_lastrahead = -1;
717 if (np->n_flag & NMODIFIED) {
719 nfs_invaldir(np);
720 nfs_node_unlock(np);
724 nfs_node_unlock(np);
728 if ((error = nfs_getattr(np, NULL, ctx, NGA_UNCACHED)))
733 lck_mtx_lock(&np->n_openlock);
734 np->n_openrefcnt++;
735 lck_mtx_unlock(&np->n_openlock);
764 if (np->n_flag & NREVOKE) {
771 error = nfs_open_file_find(np, noop, &nofp, accessMode, denyMode, 1);
773 NP(np, "nfs_vnop_open: LOST %d", kauth_cred_getuid(nofp->nof_owner->noo_cred));
810 error = nfs4_open(np, nofp, accessMode, denyMode, ctx);
823 NP(np, "nfs_vnop_open: deny mode foregone on create, %d", kauth_cred_getuid(nofp->nof_owner->noo_cred));
837 error = nfs_close(np, nofp, NFS_OPEN_SHARE_ACCESS_BOTH, NFS_OPEN_SHARE_DENY_NONE, ctx);
839 NP(np, "nfs_vnop_open: create close error %d, %d", error, kauth_cred_getuid(nofp->nof_owner->noo_cred));
855 NP(np, "nfs_vnop_open: error %d, %d", error, kauth_cred_getuid(noop->noo_cred));
872 nfs_no_of_open_file_writers(nfsnode_t np)
877 TAILQ_FOREACH(nofp, &np->n_opens, nof_link) {
921 nfsnode_t np = VTONFS(vp);
937 if (ISSET(np->n_flag, NUPDATESIZE))
938 nfs_data_update_size(np, 0);
939 nfs_node_lock_force(np);
940 if (np->n_flag & NNEEDINVALIDATE) {
941 np->n_flag &= ~NNEEDINVALIDATE;
942 nfs_node_unlock(np);
944 nfs_node_lock_force(np);
946 if ((vtype == VREG) && (np->n_flag & NMODIFIED) && (fflag & FWRITE)) {
948 nfs_node_unlock(np);
950 error = nfs_flush(np, MNT_WAIT, vfs_context_thread(ctx), 0);
953 nfs_node_lock_force(np);
954 NATTRINVALIDATE(np);
956 if (np->n_flag & NWRITEERR) {
957 np->n_flag &= ~NWRITEERR;
958 error = np->n_error;
960 nfs_node_unlock(np);
964 lck_mtx_lock(&np->n_openlock);
965 if (np->n_openrefcnt == 0) {
967 NP(np, "nfs_vnop_close: open reference underrun");
971 np->n_openrefcnt--;
974 np->n_openrefcnt = 0;
976 lck_mtx_unlock(&np->n_openlock);
1022 writers = nfs_no_of_open_file_writers(np);
1023 nfs_release_open_state_for_node(np, force);
1027 NP(np, "nfs_vnop_close: number of write opens for mount underrun. Node has %d"
1041 NP(np, "nfs_vnop_close: removing open writer from mount, but mount has no files open for writing");
1062 error = nfs_open_file_find(np, noop, &nofp, 0, 0, 0);
1071 NP(np, "nfs_vnop_close: no open file for owner, error %d, %d", error, kauth_cred_getuid(noop->noo_cred));
1081 error = nfs_close(np, nofp, accessMode, denyMode, ctx);
1083 NP(np, "nfs_vnop_close: close error %d, %d", error, kauth_cred_getuid(noop->noo_cred));
1095 NP(np, "nfs_vnop_close: error %d, %d", error, kauth_cred_getuid(noop->noo_cred));
1109 nfsnode_t np,
1121 NP(np, "nfs_close: mode mismatch %d %d, current %d %d, %d",
1152 if (NFSTONMP(np)->nm_vers < NFS_VER4) /* NFS v2/v3 closes simply need to remove the open. */
1160 nfs_wait_bufs(np);
1163 error = nfs4_close_rpc(np, nofp, vfs_context_thread(ctx), vfs_context_ucred(ctx), 0);
1169 nlop = nfs_lock_owner_find(np, vfs_context_proc(ctx), 0);
1171 nfs4_unlock_rpc(np, nlop, F_WRLCK, 0, UINT64_MAX,
1175 error = nfs4_close_rpc(np, nofp, vfs_context_thread(ctx), vfs_context_ucred(ctx), 0);
1194 error = nfs4_open_downgrade_rpc(np, nofp, ctx);
1201 NP(np, "nfs_close: error %d, %d", error, kauth_cred_getuid(nofp->nof_owner->noo_cred));
1216 NP(np, "nfs_close: unexpected count: %u.%u %u.%u %u.%u dw %u.%u %u.%u %u.%u drw %u.%u %u.%u %u.%u flags 0x%x, %d",
1241 NP(np, "nfs_close: LOST%s, %d", !nofp->nof_opencnt ? " (last)" : "",
1253 nfsnode_t np,
1262 struct nfsmount *nmp = mp ? VFSTONFS(mp) : NFSTONMP(np);
1282 error = nfs_request2(np, mp, &nmreq, NFSPROC_GETATTR,
1297 nfs_getattr(nfsnode_t np, struct nfs_vattr *nvap, vfs_context_t ctx, int flags)
1305 FSDBG_TOP(513, np->n_size, np, np->n_vattr.nva_size, np->n_flag);
1307 if (!(nmp = NFSTONMP(np)))
1316 if (np->n_flag & (NACC | NUPD)) {
1317 nfs_node_lock_force(np);
1318 np->n_flag |= NCHG;
1319 nfs_node_unlock(np);
1322 if (ISSET(np->n_flag, NUPDATESIZE))
1323 nfs_data_update_size(np, 0);
1325 error = nfs_node_lock(np);
1327 if (!(flags & (NGA_UNCACHED|NGA_MONITOR)) || ((nfsvers >= NFS_VER4) && (np->n_openflags & N_DELEG_MASK))) {
1334 error = nfs_getattrcache(np, nvap, flags);
1336 nfs_node_unlock(np);
1340 if (!ISSET(np->n_flag, NGETATTRINPROG))
1345 nfs_node_unlock(np);
1348 SET(np->n_flag, NGETATTRWANT);
1349 msleep(np, &np->n_lock, PZERO-1, "nfsgetattrwant", &ts);
1350 if ((error = nfs_sigintr(NFSTONMP(np), NULL, vfs_context_thread(ctx), 0))) {
1351 nfs_node_unlock(np);
1355 SET(np->n_flag, NGETATTRINPROG);
1357 } else if (!ISSET(np->n_flag, NGETATTRINPROG)) {
1358 SET(np->n_flag, NGETATTRINPROG);
1364 nfs_node_unlock(np);
1366 nmp = NFSTONMP(np);
1379 if (nfs_attrcachetimeout(np) > 0) {
1382 error = nmp->nm_funcs->nf_access_rpc(np, &access, ctx);
1385 nfs_node_lock_force(np);
1386 error = nfs_getattrcache(np, nvap, flags);
1387 nfs_node_unlock(np);
1397 error = nmp->nm_funcs->nf_getattr_rpc(np, NULL, np->n_fhp, np->n_fhsize, flags, ctx, nvap, &xid);
1399 nfs_node_lock_force(np);
1400 error = nfs_loadattrcache(np, nvap, &xid, 0);
1401 nfs_node_unlock(np);
1405 FSDBG(513, -1, np, np->n_xid >> 32, np->n_xid);
1412 nfs_node_lock_force(np);
1414 wanted = ISSET(np->n_flag, NGETATTRWANT);
1415 CLR(np->n_flag, (NGETATTRINPROG | NGETATTRWANT));
1419 vnode_t vp = NFSTOV(np);
1421 if ((vtype == VDIR) && NFS_CHANGED_NC(nfsvers, np, nvap)) {
1422 FSDBG(513, -1, np, 0, np);
1423 np->n_flag &= ~NNEGNCENTRIES;
1425 np->n_ncgen++;
1426 NFS_CHANGED_UPDATE_NC(nfsvers, np, nvap);
1428 if (NFS_CHANGED(nfsvers, np, nvap)) {
1429 FSDBG(513, -1, np, -1, np);
1431 nfs_invaldir(np);
1432 nfs_node_unlock(np);
1434 wakeup(np);
1436 FSDBG(513, -1, np, -2, error);
1438 nfs_node_lock_force(np);
1439 NFS_CHANGED_UPDATE(nfsvers, np, nvap);
1440 nfs_node_unlock(np);
1443 nfs_node_unlock(np);
1445 wakeup(np);
1448 nfs_node_unlock(np);
1450 wakeup(np);
1463 FSDBG_BOT(513, np->n_size, error, np->n_vattr.nva_size, np->n_flag);
1528 nfsnode_t np = VTONFS(vp);
1552 origsize = np->n_size;
1577 FSDBG_TOP(512, np->n_size, vap->va_data_size,
1578 np->n_vattr.nva_size, np->n_flag);
1580 if ((error = nfs_node_lock(np)))
1582 if (np->n_flag & NNEEDINVALIDATE)
1583 np->n_flag &= ~NNEEDINVALIDATE;
1584 nfs_node_unlock(np);
1588 NP(np, "nfs_setattr: nfs_vinvalbuf %d", error);
1589 FSDBG_BOT(512, np->n_size, vap->va_data_size, np->n_vattr.nva_size, -1);
1594 if (np->n_flag & NREVOKE)
1603 if (np->n_flag & NREVOKE) {
1607 error = nfs_open_file_find(np, noop, &nofp, 0, 0, 1);
1625 error = nfs4_open(np, nofp, NFS_OPEN_SHARE_ACCESS_WRITE, NFS_OPEN_SHARE_DENY_NONE, ctx);
1636 nfs_data_lock(np, NFS_DATA_LOCK_EXCLUSIVE);
1637 if (np->n_size > vap->va_data_size) { /* shrinking? */
1642 obn = (np->n_size - 1) / biosize;
1645 if (!nfs_buf_is_incore(np, obn))
1647 error = nfs_buf_get(np, obn, biosize, NULL, NBLK_READ, &bp);
1692 nfs_node_lock_force(np);
1693 np->n_error = error;
1694 np->n_flag |= NWRITEERR;
1702 NATTRINVALIDATE(np);
1703 nfs_node_unlock(np);
1704 nfs_data_unlock(np);
1706 nfs_data_lock(np, NFS_DATA_LOCK_EXCLUSIVE);
1711 if (vap->va_data_size != np->n_size)
1713 origsize = np->n_size;
1714 np->n_size = np->n_vattr.nva_size = vap->va_data_size;
1715 nfs_node_lock_force(np);
1716 CLR(np->n_flag, NUPDATESIZE);
1717 nfs_node_unlock(np);
1718 FSDBG(512, np, np->n_size, np->n_vattr.nva_size, 0xf00d0001);
1723 if ((error = nfs_node_lock(np)))
1725 if ((np->n_flag & NMODIFIED) && (vnode_vtype(vp) == VREG)) {
1726 nfs_node_unlock(np);
1731 nfs_node_unlock(np);
1736 !(error = nfs_node_lock(np))) {
1737 NACCESSINVALIDATE(np);
1738 nfs_node_unlock(np);
1758 error = nmp->nm_funcs->nf_setattr_rpc(np, vap, ctx);
1774 FSDBG_BOT(512, np->n_size, vap->va_data_size, np->n_vattr.nva_size, error);
1776 if (error && (origsize != np->n_size) &&
1781 np->n_size = np->n_vattr.nva_size = origsize;
1782 nfs_node_lock_force(np);
1783 CLR(np->n_flag, NUPDATESIZE);
1784 nfs_node_unlock(np);
1785 FSDBG(512, np, np->n_size, np->n_vattr.nva_size, 0xf00d0002);
1786 ubc_setsize(vp, (off_t)np->n_size); /* XXX check error */
1789 err = nmp->nm_funcs->nf_setattr_rpc(np, vap, ctx);
1791 NP(np, "nfs_vnop_setattr: nfs%d_setattr_rpc %d %d", nfsvers, error, err);
1794 nfs_node_lock_force(np);
1801 if (ISSET(np->n_flag, NUPDATESIZE)) {
1802 CLR(np->n_flag, NUPDATESIZE);
1803 NATTRINVALIDATE(np);
1804 nfs_node_unlock(np);
1805 nfs_getattr(np, NULL, ctx, NGA_UNCACHED);
1807 nfs_node_unlock(np);
1809 nfs_data_unlock(np);
1815 int err = nfs_close(np, nofp, NFS_OPEN_SHARE_ACCESS_WRITE, NFS_OPEN_SHARE_DENY_NONE, ctx);
1817 NP(np, "nfs_vnop_setattr: close error: %d", err);
1836 nfsnode_t np,
1840 struct nfsmount *nmp = NFSTONMP(np);
1873 nfsm_chain_add_fh(error, &nmreq, nfsvers, np->n_fhp, np->n_fhsize);
1921 vtonfsv2_mode(vnode_vtype(NFSTOV(np)), vap->va_mode) : -1);
1947 error = nfs_request(np, NULL, &nmreq, NFSPROC_SETATTR, ctx, NULL, &nmrep, &xid, &status);
1948 if ((lockerror = nfs_node_lock(np)))
1952 nfsm_chain_get_wcc_data(error, &nmrep, np, &premtime, &wccpostattr, &xid);
1955 if (nfstimespeccmp(&np->n_mtime, &premtime, ==))
1956 NFS_CHANGED_UPDATE(nfsvers, np, &np->n_vattr);
1958 if ((vnode_vtype(NFSTOV(np)) == VDIR) &&
1959 nfstimespeccmp(&np->n_ncmtime, &premtime, ==))
1960 NFS_CHANGED_UPDATE_NC(nfsvers, np, &np->n_vattr);
1962 NATTRINVALIDATE(np);
1967 nfsm_chain_loadattr(error, &nmrep, np, nfsvers, &xid);
1981 np->n_xid = nextxid;
1982 NATTRINVALIDATE(np);
1986 nfs_node_unlock(np);
2013 nfsnode_t dnp, np;
2053 error = nfs_dir_buf_cache_lookup(dnp, &np, cnp, ctx, 0);
2054 if (!error && np) {
2056 *vpp = NFSTOV(np);
2160 error = nfs_nget(mp, dnp, cnp, fh.fh_data, fh.fh_len, &nvattr, &xid, rq.r_auth, ngflags, &np);
2163 newvp = NFSTOV(np);
2164 nfs_node_unlock(np);
2210 nfsnode_t np = VTONFS(ap->a_vp);
2231 if ((error = nfs_getattr(np, NULL, ctx, NGA_CACHED))) {
2232 FSDBG(531, np, 0xd1e0001, 0, error);
2237 error = nfs_buf_get(np, 0, NFS_MAXPATHLEN, vfs_context_thread(ctx), NBLK_READ, &bp);
2239 FSDBG(531, np, 0xd1e0002, 0, error);
2245 error = nmp->nm_funcs->nf_readlink_rpc(np, bp->nb_data, &buflen, ctx);
2256 FSDBG(531, np, bp->nb_validend, 0, error);
2265 nfs3_readlink_rpc(nfsnode_t np, char *buf, uint32_t *buflenp, vfs_context_t ctx)
2273 nmp = NFSTONMP(np);
2281 nfsm_chain_add_fh(error, &nmreq, nfsvers, np->n_fhp, np->n_fhsize);
2284 error = nfs_request(np, NULL, &nmreq, NFSPROC_READLINK, ctx, NULL, &nmrep, &xid, &status);
2285 if ((lockerror = nfs_node_lock(np)))
2288 nfsm_chain_postop_attr_update(error, &nmrep, np, &xid);
2298 if (np->n_size && (np->n_size < *buflenp))
2299 len = np->n_size;
2308 nfs_node_unlock(np);
2319 nfs_read_rpc(nfsnode_t np, uio_t uio, vfs_context_t ctx)
2329 FSDBG_TOP(536, np, uio_offset(uio), uio_resid(uio), 0);
2330 nmp = NFSTONMP(np);
2339 FSDBG_BOT(536, np, uio_offset(uio), uio_resid(uio), EFBIG);
2345 FSDBG(536, np, txoffset, len, 0);
2346 if (np->n_flag & NREVOKE) {
2352 error = nmp->nm_funcs->nf_read_rpc_async(np, txoffset, len,
2355 error = nmp->nm_funcs->nf_read_rpc_async_finish(np, req, uio, &retlen, &eof);
2360 NP(np, "nfs_read_rpc: error %d, initiating recovery", error);
2364 if (np->n_flag & NREVOKE) {
2384 FSDBG_BOT(536, np, eof, uio_resid(uio), error);
2390 nfsnode_t np,
2402 nmp = NFSTONMP(np);
2409 nfsm_chain_add_fh(error, &nmreq, nfsvers, np->n_fhp, np->n_fhsize);
2420 error = nfs_request_async(np, NULL, &nmreq, NFSPROC_READ, thd, cred, NULL, 0, cb, reqp);
2428 nfsnode_t np,
2440 nmp = NFSTONMP(np);
2453 if ((lockerror = nfs_node_lock(np)))
2456 nfsm_chain_postop_attr_update(error, &nmrep, np, &xid);
2463 nfsm_chain_loadattr(error, &nmrep, np, nfsvers, &xid);
2466 nfs_node_unlock(np);
2503 nfsnode_t np = VTONFS(vp);
2516 FSDBG_TOP(515, np, uio_offset(uio), uio_resid(uio), ioflag);
2519 FSDBG_BOT(515, np, uio_offset(uio), uio_resid(uio), EIO);
2526 nfs_data_lock(np, NFS_DATA_LOCK_SHARED);
2528 if ((error = nfs_node_lock(np))) {
2529 nfs_data_unlock(np);
2530 FSDBG_BOT(515, np, uio_offset(uio), uio_resid(uio), error);
2533 np->n_wrbusy++;
2535 if (np->n_flag & NWRITEERR) {
2536 error = np->n_error;
2537 np->n_flag &= ~NWRITEERR;
2539 if (np->n_flag & NNEEDINVALIDATE) {
2540 np->n_flag &= ~NNEEDINVALIDATE;
2541 nfs_node_unlock(np);
2542 nfs_data_unlock(np);
2544 nfs_data_lock(np, NFS_DATA_LOCK_SHARED);
2546 nfs_node_unlock(np);
2554 nfs_node_lock_force(np);
2555 if (np->n_flag & NMODIFIED) {
2556 NATTRINVALIDATE(np);
2557 nfs_node_unlock(np);
2558 nfs_data_unlock(np);
2560 nfs_data_lock(np, NFS_DATA_LOCK_SHARED);
2562 FSDBG(515, np, uio_offset(uio), 0x10bad01, error);
2566 nfs_node_unlock(np);
2569 nfs_data_unlock(np);
2571 error = nfs_getattr(np, NULL, ctx, NGA_UNCACHED);
2573 nfs_data_lock(np, NFS_DATA_LOCK_EXCLUSIVE);
2575 FSDBG(515, np, uio_offset(uio), 0x10bad02, error);
2578 uio_setoffset(uio, np->n_size);
2583 FSDBG_BOT(515, np, uio_offset(uio), 0xbad0ff, error);
2589 if (((uio_offset(uio) + uio_resid(uio)) > (off_t)np->n_size) && !(ioflag & IO_APPEND)) {
2591 nfs_data_unlock(np);
2592 nfs_data_lock(np, NFS_DATA_LOCK_EXCLUSIVE);
2609 error = nfs_buf_get(np, lbn, biosize, thd, NBLK_WRITE, &bp);
2638 FSDBG(515, np, uio_offset(uio), bp, 0xd15c001);
2657 FSDBG(515, np, uio_offset(uio), bp, 0xd15c002);
2670 FSDBG(515, np, uio_offset(uio), bp, 0xd15c003);
2675 if (NBOFF(bp) + bp->nb_dirtyend > (off_t)np->n_size) {
2676 bp->nb_dirtyend = np->n_size - NBOFF(bp);
2691 if ((uio_offset(uio) + n) > (off_t)np->n_size) {
2693 daddr64_t eofbn = np->n_size / biosize;
2694 int eofoff = np->n_size % biosize;
2700 ((error = nfs_buf_get(np, eofbn, biosize, thd, NBLK_WRITE|NBLK_ONLYVALID, &eofbp))))
2732 np->n_size = uio_offset(uio) + n;
2733 nfs_node_lock_force(np);
2734 CLR(np->n_flag, NUPDATESIZE);
2735 np->n_flag |= NMODIFIED;
2736 nfs_node_unlock(np);
2737 FSDBG(516, np, np->n_size, np->n_vattr.nva_size, 0xf00d0001);
2738 ubc_setsize(vp, (off_t)np->n_size); /* XXX errors */
2776 if (NBOFF(bp) + bp->nb_dirtyend > (off_t)np->n_size) {
2777 bp->nb_dirtyend = np->n_size - NBOFF(bp);
2869 error = nfs_read_rpc(np, auio, ctx);
2885 if ((off_t)np->n_size > boff + bp->nb_validend)
2886 bp->nb_validend = min(np->n_size - (boff + start), biosize);
2904 if (((boff+start) >= (off_t)np->n_size) ||
2905 ((start >= on) && ((boff + on + n) >= (off_t)np->n_size))) {
2920 error = nfs_read_rpc(np, auio, ctx);
2937 if ((off_t)np->n_size > boff + bp->nb_validend)
2938 bp->nb_validend = min(np->n_size - (boff + start), biosize);
2957 nfs_node_lock_force(np);
2958 np->n_flag |= NMODIFIED;
2959 nfs_node_unlock(np);
2999 nfs_buf_normalize_valid_range(np, bp);
3006 nfs_node_lock_force(np);
3008 np->n_needcommitcnt--;
3009 CHECK_NEEDCOMMITCNT(np);
3012 nfs_node_unlock(np);
3034 if (np->n_needcommitcnt >= NFS_A_LOT_OF_NEEDCOMMITS)
3035 nfs_flushcommits(np, 1);
3040 nfs_node_lock_force(np);
3041 np->n_wrbusy--;
3042 nfs_node_unlock(np);
3043 nfs_data_unlock(np);
3044 FSDBG_BOT(515, np, uio_offset(uio), uio_resid(uio), error);
3054 nfsnode_t np,
3060 return nfs_write_rpc2(np, uio, vfs_context_thread(ctx), vfs_context_ucred(ctx), iomodep, wverfp);
3065 nfsnode_t np,
3085 FSDBG_TOP(537, np, uio_offset(uio), uio_resid(uio), *iomodep);
3086 nmp = NFSTONMP(np);
3097 FSDBG_BOT(537, np, uio_offset(uio), uio_resid(uio), EFBIG);
3103 FSDBG(537, np, uio_offset(uio), len, 0);
3104 if (np->n_flag & NREVOKE) {
3110 error = nmp->nm_funcs->nf_write_rpc_async(np, uio, len, thd, cred, *iomodep, NULL, &req);
3112 error = nmp->nm_funcs->nf_write_rpc_async_finish(np, req, &commit, &rlen, &wverf2);
3113 nmp = NFSTONMP(np);
3120 NP(np, "nfs_write_rpc: error %d, initiating recovery", error);
3124 if (np->n_flag & NREVOKE) {
3176 FSDBG_BOT(537, np, committed, uio_resid(uio), error);
3182 nfsnode_t np,
3196 nmp = NFSTONMP(np);
3203 ((mp = NFSTOMP(np))) && (vfs_flags(mp) & MNT_ASYNC))
3209 nfsm_chain_add_fh(error, &nmreq, nfsvers, np->n_fhp, np->n_fhsize);
3224 error = nfs_request_async(np, NULL, &nmreq, NFSPROC_WRITE, thd, cred, NULL, 0, cb, reqp);
3232 nfsnode_t np,
3245 nmp = NFSTONMP(np);
3257 nmp = NFSTONMP(np);
3260 if (!error && (lockerror = nfs_node_lock(np)))
3264 nfsm_chain_get_wcc_data(error, &nmrep, np, &premtime, &wccpostattr, &xid);
3265 if (nfstimespeccmp(&np->n_mtime, &premtime, ==))
3290 nfsm_chain_loadattr(error, &nmrep, np, nfsvers, &xid);
3294 NFS_CHANGED_UPDATE(nfsvers, np, &np->n_vattr);
3297 nfs_node_unlock(np);
3300 ((mp = NFSTOMP(np))) && (vfs_flags(mp) & MNT_ASYNC))
3329 nfsnode_t np = NULL;
3430 error = nfs_nget(NFSTOMP(dnp), dnp, cnp, fh.fh_data, fh.fh_len, &nvattr, &xid, rq.r_auth, NG_MAKEENTRY, &np);
3431 if (!error && !np)
3432 error = nfs_lookitup(dnp, cnp->cn_nameptr, cnp->cn_namelen, ctx, &np);
3433 if (!error && np)
3434 newvp = NFSTOV(np);
3439 (!newvp || nfs_getattrcache(np, &nvattr, 0) ||
3448 nfs_node_unlock(np);
3453 nfs_node_unlock(np);
3479 nfsnode_t np = NULL;
3587 error = nfs_nget(NFSTOMP(dnp), dnp, cnp, fh.fh_data, fh.fh_len, &nvattr, &xid, rq.r_auth, NG_MAKEENTRY, &np);
3588 if (!error && !np)
3589 error = nfs_lookitup(dnp, cnp->cn_nameptr, cnp->cn_namelen, ctx, &np);
3590 if (!error && np)
3591 newvp = NFSTOV(np);
3603 nfs_node_unlock(np);
3607 nfs_node_unlock(np);
3608 error = nfs3_setattr_rpc(np, vap, ctx);
3614 error = nfs3_setattr_rpc(np, vap, ctx);
3619 nfs_node_lock_force(np);
3624 (!newvp || nfs_getattrcache(np, &nvattr, 0) ||
3632 nfs_node_unlock(np);
3663 nfsnode_t np = VTONFS(vp);
3678 error = nfs_node_set_busy2(dnp, np, vfs_context_thread(ctx));
3684 while (np->n_hflag & NHLOCKED) {
3685 np->n_hflag |= NHLOCKWANT;
3686 msleep(np, nfs_node_hash_mutex, PINOD, "nfs_remove", NULL);
3688 np->n_hflag |= NHLOCKED;
3701 if (nfs_getattr(np, &nvattr, ctx, NGA_CACHED))
3706 if (!inuse || (np->n_sillyrename && (nvattr.nva_nlink > 1))) {
3711 np->n_hflag &= ~NHLOCKED;
3712 if (np->n_hflag & NHLOCKWANT) {
3713 np->n_hflag &= ~NHLOCKWANT;
3714 wakeup(np);
3717 nfs_node_clear_busy2(dnp, np);
3719 FSDBG(260, np, np->n_size, np->n_vattr.nva_size, 0xf00d0011);
3722 nfs_node_lock_force(np);
3723 NATTRINVALIDATE(np);
3724 nfs_node_unlock(np);
3732 if ((nmp->nm_vers >= NFS_VER4) && (np->n_openflags & N_DELEG_MASK))
3733 nfs4_delegation_return(np, 0, vfs_context_thread(ctx), vfs_context_ucred(ctx));
3740 nfs_name_cache_purge(dnp, np, cnp, ctx);
3758 if (!error && !inuse && !np->n_sillyrename) {
3766 if (np->n_hflag & NHHASHED) {
3767 LIST_REMOVE(np, n_hash);
3768 np->n_hflag &= ~NHHASHED;
3769 FSDBG(266, 0, np, np->n_flag, 0xb1eb1e);
3774 nfs_node_lock_force(np);
3775 np->n_flag &= (NMODIFIED);
3776 NATTRINVALIDATE(np);
3777 nfs_node_unlock(np);
3781 nfs_node_lock_force(np);
3782 NATTRINVALIDATE(np);
3783 nfs_node_unlock(np);
3785 } else if (!np->n_sillyrename) {
3788 error = nfs_sillyrename(dnp, np, cnp, ctx);
3789 nfs_node_lock_force(np);
3790 NATTRINVALIDATE(np);
3791 nfs_node_unlock(np);
3793 nfs_node_lock_force(np);
3794 NATTRINVALIDATE(np);
3795 nfs_node_unlock(np);
3807 np->n_hflag &= ~NHLOCKED;
3808 if (np->n_hflag & NHLOCKWANT) {
3809 np->n_hflag &= ~NHLOCKWANT;
3810 wakeup(np);
3813 nfs_node_clear_busy2(dnp, np);
4155 nfsnode_t np = VTONFS(vp);
4176 nfs_flush(np, MNT_WAIT, vfs_context_thread(ctx), V_IGNORE_WRITEERR);
4178 error = nfs_node_set_busy2(tdnp, np, vfs_context_thread(ctx));
4187 nfsm_chain_add_fh(error, &nmreq, nfsvers, np->n_fhp, np->n_fhsize);
4192 error = nfs_request(np, NULL, &nmreq, NFSPROC_LINK, ctx, NULL, &nmrep, &xid, &status);
4194 if ((lockerror = nfs_node_lock2(tdnp, np))) {
4200 nfsm_chain_postop_attr_update_flag(error, &nmrep, np, attrflag, &xid);
4210 NATTRINVALIDATE(np);
4221 nfs_node_unlock2(tdnp, np);
4223 nfs_node_clear_busy2(tdnp, np);
4258 nfsnode_t np = NULL;
4344 error = nfs_nget(NFSTOMP(dnp), dnp, cnp, fh.fh_data, fh.fh_len, &nvattr, &xid, rq.r_auth, NG_MAKEENTRY, &np);
4345 if (!error && np)
4346 newvp = NFSTOV(np);
4356 nfs_node_unlock(np);
4360 error = nfs_lookitup(dnp, cnp->cn_nameptr, cnp->cn_namelen, ctx, &np);
4362 newvp = NFSTOV(np);
4370 (!newvp || nfs_getattrcache(np, &nvattr, 0) ||
4379 nfs_node_unlock(np);
4383 nfs_node_unlock(np);
4408 nfsnode_t np = NULL;
4493 error = nfs_nget(NFSTOMP(dnp), dnp, cnp, fh.fh_data, fh.fh_len, &nvattr, &xid, rq.r_auth, NG_MAKEENTRY, &np);
4494 if (!error && np)
4495 newvp = NFSTOV(np);
4505 nfs_node_unlock(np);
4509 error = nfs_lookitup(dnp, cnp->cn_nameptr, cnp->cn_namelen, ctx, &np);
4511 newvp = NFSTOV(np);
4519 (!newvp || nfs_getattrcache(np, &nvattr, 0) ||
4528 nfs_node_unlock(np);
4532 nfs_node_unlock(np);
4558 nfsnode_t np = VTONFS(vp);
4573 if ((error = nfs_node_set_busy2(dnp, np, vfs_context_thread(ctx))))
4611 nfs_name_cache_purge(dnp, np, cnp, ctx);
4616 nfs_node_clear_busy2(dnp, np);
4630 if (np->n_hflag & NHHASHED) {
4631 LIST_REMOVE(np, n_hash);
4632 np->n_hflag &= ~NHHASHED;
4633 FSDBG(266, 0, np, np->n_flag, 0xb1eb1e);
5334 nfs_name_cache_purge(nfsnode_t dnp, nfsnode_t np, struct componentname *cnp, vfs_context_t ctx)
5338 cache_purge(NFSTOV(np));
5635 nfsnode_t np,
5650 nfs_name_cache_purge(dnp, np, cnp, ctx);
5696 FSDBG(267, dnp, np, num, error);
5699 error = nfs_lookitup(dnp, nsp->nsr_name, nsp->nsr_namlen, ctx, &np);
5700 nfs_node_lock_force(np);
5701 np->n_sillyrename = nsp;
5702 nfs_node_unlock(np);
5817 nfsnode_t np, newnp = NULL;
5848 np = *npp;
5849 if (fh.fh_len != np->n_fhsize) {
5850 u_char *oldbuf = (np->n_fhsize > NFS_SMALLFH) ? np->n_fhp : NULL;
5852 MALLOC_ZONE(np->n_fhp, u_char *, fh.fh_len, M_NFSBIGFH, M_WAITOK);
5853 if (!np->n_fhp) {
5854 np->n_fhp = oldbuf;
5859 np->n_fhp = &np->n_fh[0];
5862 FREE_ZONE(oldbuf, np->n_fhsize, M_NFSBIGFH);
5864 bcopy(fh.fh_data, np->n_fhp, fh.fh_len);
5865 np->n_fhsize = fh.fh_len;
5866 nfs_node_lock_force(np);
5867 error = nfs_loadattrcache(np, &nvattr, &xid, 0);
5868 nfs_node_unlock(np);
5870 newnp = np;
5884 &nvattr, &xid, rq.r_auth, NG_MAKEENTRY, &np);
5886 newnp = np;
6011 nfsnode_t np,
6024 nmp = NFSTONMP(np);
6025 FSDBG(521, np, offset, count, nmp ? nmp->nm_state : 0);
6041 nfsm_chain_add_fh(error, &nmreq, nfsvers, np->n_fhp, np->n_fhsize);
6046 error = nfs_request2(np, NULL, &nmreq, NFSPROC_COMMIT,
6048 if ((lockerror = nfs_node_lock(np)))
6051 nfsm_chain_get_wcc_data(error, &nmrep, np, &premtime, &wccpostattr, &xid);
6053 nfs_node_unlock(np);
6110 nfsnode_t np,
6117 struct nfsmount *nmp = NFSTONMP(np);
6129 nfsm_chain_add_fh(error, &nmreq, nfsvers, np->n_fhp, np->n_fhsize);
6132 error = nfs_request(np, NULL, &nmreq, NFSPROC_PATHCONF, ctx, NULL, &nmrep, &xid, &status);
6133 if ((lockerror = nfs_node_lock(np)))
6135 nfsm_chain_postop_attr_update(error, &nmrep, np, &xid);
6137 nfs_node_unlock(np);
6203 nfsnode_t np = VTONFS(vp);
6248 error = nfs3_pathconf_rpc(np, &nfsa, ap->a_context);
6268 error = nfs4_pathconf_rpc(np, &nfsa, ap->a_context);
6284 else if ((nmp->nm_vers == NFS_VER4) && NFS_BITMAP_ISSET(np->n_vattr.nva_bitmap, NFS_FATTR_MAXLINK))
6285 *ap->a_retval = np->n_vattr.nva_maxlink;
6375 nfsnode_t np = VTONFS(ap->a_vp);
6382 if ((error = nfs_node_lock(np)))
6384 np->n_flag |= NACC;
6386 np->n_atim.tv_sec = now.tv_sec;
6387 np->n_atim.tv_nsec = now.tv_usec * 1000;
6388 nfs_node_unlock(np);
6405 nfsnode_t np = VTONFS(ap->a_vp);
6412 if ((error = nfs_node_lock(np)))
6414 np->n_flag |= NUPD;
6416 np->n_mtim.tv_sec = now.tv_sec;
6417 np->n_mtim.tv_nsec = now.tv_usec * 1000;
6418 nfs_node_unlock(np);
6437 nfsnode_t np = VTONFS(vp);
6442 if ((error = nfs_node_lock(np)))
6444 if (np->n_flag & (NACC | NUPD)) {
6445 np->n_flag |= NCHG;
6448 if (np->n_flag & NACC) {
6449 vattr.va_access_time = np->n_atim;
6452 if (np->n_flag & NUPD) {
6453 vattr.va_modify_time = np->n_mtim;
6456 nfs_node_unlock(np);
6459 nfs_node_unlock(np);
6462 nfs_node_unlock(np);
6483 nfsnode_t np = VTONFS(ap->a_vp);
6490 if ((error = nfs_node_lock(np)))
6492 np->n_flag |= NACC;
6494 np->n_atim.tv_sec = now.tv_sec;
6495 np->n_atim.tv_nsec = now.tv_usec * 1000;
6496 nfs_node_unlock(np);
6513 nfsnode_t np = VTONFS(ap->a_vp);
6520 if ((error = nfs_node_lock(np)))
6522 np->n_flag |= NUPD;
6524 np->n_mtim.tv_sec = now.tv_sec;
6525 np->n_mtim.tv_nsec = now.tv_usec * 1000;
6526 nfs_node_unlock(np);
6545 nfsnode_t np = VTONFS(vp);
6551 if ((error = nfs_node_lock(np)))
6553 if (np->n_flag & (NACC | NUPD)) {
6555 if (np->n_flag & NACC) {
6556 np->n_atim.tv_sec = now.tv_sec;
6557 np->n_atim.tv_nsec = now.tv_usec * 1000;
6559 if (np->n_flag & NUPD) {
6560 np->n_mtim.tv_sec = now.tv_sec;
6561 np->n_mtim.tv_nsec = now.tv_usec * 1000;
6563 np->n_flag |= NCHG;
6566 if (np->n_flag & NACC) {
6567 vattr.va_access_time = np->n_atim;
6570 if (np->n_flag & NUPD) {
6571 vattr.va_modify_time = np->n_mtim;
6574 nfs_node_unlock(np);
6577 nfs_node_unlock(np);
6580 nfs_node_unlock(np);
6662 nfsnode_t np = VTONFS(vp);
6678 FSDBG(322, np, f_offset, size, flags);
6688 if (f_offset < 0 || f_offset >= (off_t)np->n_size || (f_offset & PAGE_MASK_64)) {
6728 if (np->n_flag & NREVOKE) {
6735 if ((error = nmp->nm_funcs->nf_read_rpc_async(np, txoffset, iosize, thd, cred, NULL, &req[nextsend]))) {
6753 error = nmp->nm_funcs->nf_read_rpc_async_finish(np, req[nextwait], uio, &retsize, NULL);
6759 NP(np, "nfs_vnop_pagein: error %d, initiating recovery", error);
6794 if (np->n_flag & NREVOKE) {
6803 NP(np, "nfs_pagein: too many restarts, aborting");
6971 nfsnode_t np = VTONFS(vp);
7010 nfs_data_lock_noupdate(np, NFS_DATA_LOCK_SHARED);
7024 if ((bp = nfs_buf_incore(np, lbn))) {
7028 nfs_data_unlock_noupdate(np);
7055 if (end > (off_t)np->n_size)
7056 end = np->n_size;
7069 FSDBG(323, np, bp, 0xd00deebc, EBUSY);
7076 nfs_data_unlock_noupdate(np);
7098 nfs_node_lock_force(np);
7101 np->n_needcommitcnt--;
7102 CHECK_NEEDCOMMITCNT(np);
7104 nfs_node_unlock(np);
7116 nfs_node_lock_force(np);
7117 if (np->n_flag & NWRITEERR) {
7118 error = np->n_error;
7119 nfs_node_unlock(np);
7120 nfs_data_unlock_noupdate(np);
7126 nfs_node_unlock(np);
7128 if (f_offset < 0 || f_offset >= (off_t)np->n_size ||
7130 nfs_data_unlock_noupdate(np);
7142 if ((u_quad_t)f_offset + size > np->n_size)
7143 xsize = np->n_size - f_offset;
7157 if ((u_quad_t)f_offset < np->n_size && (u_quad_t)f_offset + size > np->n_size) {
7158 size_t io = np->n_size - f_offset;
7160 FSDBG(321, np->n_size, f_offset, f_offset + io, size - io);
7162 nfs_data_unlock_noupdate(np);
7179 if (np->n_flag & NREVOKE) {
7190 nfs_node_lock_force(np);
7191 np->n_numoutput++;
7192 nfs_node_unlock(np);
7195 if ((error = nmp->nm_funcs->nf_write_rpc_async(np, auio, iosize, thd, cred, iomode, NULL, &req[nextsend]))) {
7198 nfs_node_lock_force(np);
7199 np->n_numoutput--;
7200 nfs_node_unlock(np);
7211 error = nmp->nm_funcs->nf_write_rpc_async_finish(np, req[nextwait], &iomode, &iosize, &wverf2);
7215 nfs_node_lock_force(np);
7216 np->n_numoutput--;
7217 nfs_node_unlock(np);
7221 NP(np, "nfs_vnop_pageout: error %d, initiating recovery", error);
7253 error = nfs_write_rpc2(np, auio, thd, cred, &iomode, &wverf2);
7255 NP(np, "nfs_vnop_pageout: restart: error %d", error);
7258 NP(np, "nfs_vnop_pageout: error %d, initiating recovery", error);
7288 error = nmp->nm_funcs->nf_commit_rpc(np, f_offset, xsize, cred, wverf);
7303 nfs_node_lock_force(np);
7304 np->n_numoutput--;
7305 nfs_node_unlock(np);
7307 if (np->n_flag & NREVOKE) {
7313 NP(np, "nfs_pageout: too many restarts, aborting");
7323 NP(np, "nfs_pageout: too many restarts, aborting");
7368 NP(np, "nfs_pageout: unexpected error %d. dumping vm page", error);
7382 NP(np, "nfs_pageout: action %d not expected", action);
7457 nfsnode_t np = VTONFS(ap->a_vp);
7468 if (np->n_monlink.le_next == NFSNOLIST) {
7469 LIST_INSERT_HEAD(&nmp->nm_monlist, np, n_monlink);
7475 while (np->n_mflag & NMMONSCANINPROG) {
7477 np->n_mflag |= NMMONSCANWANT;
7478 msleep(&np->n_mflag, &nmp->nm_lock, PZERO-1, "nfswaitmonscan", &ts);
7480 if (np->n_monlink.le_next != NFSNOLIST) {
7481 LIST_REMOVE(np, n_monlink);
7482 np->n_monlink.le_next = NFSNOLIST;
7494 nfs_vnode_notify(nfsnode_t np, uint32_t events)
7496 struct nfsmount *nmp = NFSTONMP(np);
7502 if ((np->n_evtstamp == now.tv_sec) || !nmp) {
7504 np->n_events |= events;
7507 events |= np->n_events;
7508 np->n_events = 0;
7509 np->n_evtstamp = now.tv_sec;
7512 if (!nfs_getattrcache(np, &nvattr, 0)) {
7522 vnode_notify(NFSTOV(np), events, vap);