Lines Matching defs:np
421 nfs_node_mode_slot(nfsnode_t np, uid_t uid, int add)
426 if (np->n_modeuid[slot] == uid)
431 slot = np->n_mode[NFS_ACCESS_CACHE_SIZE];
432 np->n_mode[NFS_ACCESS_CACHE_SIZE] = (slot + 1) % NFS_ACCESS_CACHE_SIZE;
438 nfs3_access_rpc(nfsnode_t np, u_long *mode, vfs_context_t ctx)
451 nfsm_chain_add_fh(error, &nmreq, NFS_VER3, np->n_fhp, np->n_fhsize);
455 error = nfs_request(np, NULL, &nmreq, NFSPROC_ACCESS, ctx,
457 nfsm_chain_postop_attr_update(error, &nmrep, np, &xid);
464 slot = nfs_node_mode_slot(np, uid, 1);
465 np->n_modeuid[slot] = uid;
467 np->n_modestamp[slot] = now.tv_sec;
468 np->n_mode[slot] = access;
478 !(np->n_mode[slot] & NFS_ACCESS_DELETE))
479 np->n_mode[slot] |= NFS_ACCESS_DELETE;
481 *mode = np->n_mode[slot];
507 nfsnode_t np = VTONFS(vp);
586 if ((error = nfs_lock(np, NFS_NODE_LOCK_EXCLUSIVE)))
594 slot = nfs_node_mode_slot(np, uid, 0);
596 if (NMODEVALID(np, slot)) {
598 if ((now.tv_sec < (np->n_modestamp[slot] + nfs_access_cache_timeout)) &&
599 ((np->n_mode[slot] & mode) == mode)) {
602 wmode = np->n_mode[slot];
608 error = nmp->nm_funcs->nf_access_rpc(np, &wmode, ctx);
612 nfs_unlock(np);
631 nfsnode_t np = VTONFS(vp);
645 if (ISSET(np->n_flag, NUPDATESIZE))
646 nfs_data_update_size(np, 0);
647 if ((error = nfs_lock(np, NFS_NODE_LOCK_EXCLUSIVE)))
649 if (np->n_flag & NNEEDINVALIDATE) {
650 np->n_flag &= ~NNEEDINVALIDATE;
651 nfs_unlock(np);
653 if ((error = nfs_lock(np, NFS_NODE_LOCK_EXCLUSIVE)))
656 if (np->n_flag & NMODIFIED) {
657 nfs_unlock(np);
660 if ((error = nfs_lock(np, NFS_NODE_LOCK_EXCLUSIVE)))
663 np->n_direofoffset = 0;
664 NATTRINVALIDATE(np); /* For Open/Close consistency */
665 error = nfs_getattr(np, &nvattr, ctx, 1);
667 nfs_unlock(np);
672 if (NFS_CHANGED_NC(nfsvers, np, &nvattr)) {
673 np->n_flag &= ~NNEGNCENTRIES;
676 NFS_CHANGED_UPDATE_NC(nfsvers, np, &nvattr);
678 NFS_CHANGED_UPDATE(nfsvers, np, &nvattr);
680 NATTRINVALIDATE(np); /* For Open/Close consistency */
681 error = nfs_getattr(np, &nvattr, ctx, 1);
683 nfs_unlock(np);
686 if (NFS_CHANGED(nfsvers, np, &nvattr)) {
688 np->n_direofoffset = 0;
689 nfs_invaldir(np);
691 if (NFS_CHANGED_NC(nfsvers, np, &nvattr)) {
692 np->n_flag &= ~NNEGNCENTRIES;
696 nfs_unlock(np);
699 if ((error = nfs_lock(np, NFS_NODE_LOCK_EXCLUSIVE)))
702 NFS_CHANGED_UPDATE_NC(nfsvers, np, &nvattr);
703 NFS_CHANGED_UPDATE(nfsvers, np, &nvattr);
706 nfs_unlock(np);
743 nfsnode_t np = VTONFS(vp);
755 if (ISSET(np->n_flag, NUPDATESIZE))
756 nfs_data_update_size(np, 0);
757 if ((error = nfs_lock(np, NFS_NODE_LOCK_EXCLUSIVE)))
759 if (np->n_flag & NNEEDINVALIDATE) {
760 np->n_flag &= ~NNEEDINVALIDATE;
761 nfs_unlock(np);
763 if ((error = nfs_lock(np, NFS_NODE_LOCK_EXCLUSIVE)))
766 if (np->n_flag & NMODIFIED) {
767 nfs_unlock(np);
769 error = nfs_flush(np, MNT_WAIT, vfs_context_thread(ctx), 0);
774 nfs_lock(np, NFS_NODE_LOCK_FORCE);
775 NATTRINVALIDATE(np);
777 if (np->n_flag & NWRITEERR) {
778 np->n_flag &= ~NWRITEERR;
779 error = np->n_error;
781 nfs_unlock(np);
788 nfsnode_t np,
796 struct nfsmount *nmp = mp ? VFSTONFS(mp) : NFSTONMP(np);
813 error = nfs_request(np, mp, &nmreq, NFSPROC_GETATTR, ctx,
827 nfs_getattr(nfsnode_t np, struct nfs_vattr *nvap, vfs_context_t ctx, int alreadylocked)
833 FSDBG_TOP(513, np->n_size, np, np->n_vattr.nva_size, np->n_flag);
836 if (np->n_flag & (NACC | NUPD)) {
838 nfs_lock(np, NFS_NODE_LOCK_FORCE);
839 np->n_flag |= NCHG;
841 nfs_unlock(np);
844 if (!alreadylocked && ISSET(np->n_flag, NUPDATESIZE))
845 nfs_data_update_size(np, 0);
850 if ((error = nfs_getattrcache(np, nvap, alreadylocked)) == 0)
855 nmp = NFSTONMP(np);
869 if (!alreadylocked && ((error = lockerror = nfs_lock(np, NFS_NODE_LOCK_EXCLUSIVE))))
871 if (nfs_attrcachetimeout(np) > 0) {
874 error = nmp->nm_funcs->nf_access_rpc(np, &mode, ctx);
877 if ((error = nfs_getattrcache(np, nvap, 1)) == 0)
884 error = lockerror = nfs_lock(np, NFS_NODE_LOCK_EXCLUSIVE);
889 error = nmp->nm_funcs->nf_getattr_rpc(np, NULL, np->n_fhp, np->n_fhsize, ctx, nvap, &xid);
891 error = nfs_loadattrcache(np, nvap, &xid, 0);
894 FSDBG(513, -1, np, np->n_xid >> 32, np->n_xid);
900 if (NFS_CHANGED(nfsvers, np, nvap)) {
901 vnode_t vp = NFSTOV(np);
903 FSDBG(513, -1, np, -1, np);
905 nfs_invaldir(np);
907 if (NFS_CHANGED_NC(nfsvers, np, nvap)) {
908 np->n_flag &= ~NNEGNCENTRIES;
913 nfs_unlock(np);
916 FSDBG(513, -1, np, -2, error);
918 error = lockerror = nfs_lock(np, NFS_NODE_LOCK_EXCLUSIVE);
921 NFS_CHANGED_UPDATE_NC(nfsvers, np, nvap);
922 NFS_CHANGED_UPDATE(nfsvers, np, nvap);
926 np->n_flag |= NNEEDINVALIDATE;
931 nfs_unlock(np);
932 FSDBG_BOT(513, np->n_size, error, np->n_vattr.nva_size, np->n_flag);
997 nfsnode_t np = VTONFS(vp);
1018 origsize = np->n_size;
1043 FSDBG_TOP(512, np->n_size, vap->va_data_size,
1044 np->n_vattr.nva_size, np->n_flag);
1046 if ((error = nfs_lock(np, NFS_NODE_LOCK_EXCLUSIVE)))
1048 if (np->n_flag & NNEEDINVALIDATE)
1049 np->n_flag &= ~NNEEDINVALIDATE;
1050 nfs_unlock(np);
1055 FSDBG_BOT(512, np->n_size, vap->va_data_size, np->n_vattr.nva_size, -1);
1058 nfs_data_lock(np, NFS_NODE_LOCK_EXCLUSIVE);
1059 if (np->n_size > vap->va_data_size) { /* shrinking? */
1064 obn = (np->n_size - 1) / biosize;
1067 if (!nfs_buf_is_incore(np, obn))
1069 error = nfs_buf_get(np, obn, biosize, NULL, NBLK_READ, &bp);
1114 nfs_lock(np, NFS_NODE_LOCK_FORCE);
1115 np->n_error = error;
1116 np->n_flag |= NWRITEERR;
1124 NATTRINVALIDATE(np);
1125 nfs_unlock(np);
1126 nfs_data_unlock(np);
1128 nfs_data_lock(np, NFS_NODE_LOCK_EXCLUSIVE);
1133 if (vap->va_data_size != np->n_size)
1135 origsize = np->n_size;
1136 np->n_size = np->n_vattr.nva_size = vap->va_data_size;
1137 CLR(np->n_flag, NUPDATESIZE);
1138 FSDBG(512, np, np->n_size, np->n_vattr.nva_size, 0xf00d0001);
1143 if ((error = nfs_lock(np, NFS_NODE_LOCK_SHARED)))
1145 if ((np->n_flag & NMODIFIED) && (vnode_vtype(vp) == VREG)) {
1146 nfs_unlock(np);
1151 nfs_unlock(np);
1157 if ((error = nfs_lock(np, NFS_NODE_LOCK_EXCLUSIVE))) {
1159 nfs_data_unlock(np);
1162 NMODEINVALIDATE(np);
1163 nfs_unlock(np);
1180 error = nmp->nm_funcs->nf_setattr_rpc(np, vap, ctx, 0);
1195 FSDBG_BOT(512, np->n_size, vap->va_data_size, np->n_vattr.nva_size, error);
1197 if (error && (origsize != np->n_size)) {
1200 np->n_size = np->n_vattr.nva_size = origsize;
1201 CLR(np->n_flag, NUPDATESIZE);
1202 FSDBG(512, np, np->n_size, np->n_vattr.nva_size, 0xf00d0002);
1203 ubc_setsize(vp, (off_t)np->n_size); /* XXX check error */
1205 err = nmp->nm_funcs->nf_setattr_rpc(np, vap, ctx, 0);
1209 nfs_data_unlock(np);
1219 nfsnode_t np,
1224 struct nfsmount *nmp = NFSTONMP(np);
1257 nfsm_chain_add_fh(error, &nmreq, nfsvers, np->n_fhp, np->n_fhsize);
1305 vtonfsv2_mode(vnode_vtype(NFSTOV(np)), vap->va_mode) : -1);
1331 error = nfs_request(np, NULL, &nmreq, NFSPROC_SETATTR, ctx,
1333 if (!alreadylocked && ((lockerror = nfs_lock(np, NFS_NODE_LOCK_EXCLUSIVE))))
1337 nfsm_chain_get_wcc_data(error, &nmrep, np, &premtime, &wccpostattr, &xid);
1340 if (nfstimespeccmp(&np->n_mtime, &premtime, ==))
1341 NFS_CHANGED_UPDATE(nfsvers, np, &np->n_vattr);
1343 if ((vnode_vtype(NFSTOV(np)) == VDIR) &&
1344 nfstimespeccmp(&np->n_ncmtime, &premtime, ==))
1345 NFS_CHANGED_UPDATE_NC(nfsvers, np, &np->n_vattr);
1347 NATTRINVALIDATE(np);
1352 nfsm_chain_loadattr(error, &nmrep, np, nfsvers, NULL, &xid);
1356 nfs_unlock(np);
1383 nfsnode_t dnp, np;
1522 error = nfs_nget(mp, dnp, cnp, fh.fh_data, fh.fh_len, &nvattr, &xid, ngflags, &np);
1525 newvp = NFSTOV(np);
1526 nfs_unlock(np);
1589 nfsnode_t np = VTONFS(ap->a_vp);
1610 error = lockerror = nfs_lock(np, NFS_NODE_LOCK_EXCLUSIVE);
1612 error = nfs_getattr(np, &nvattr, ctx, 1);
1615 nfs_unlock(np);
1616 FSDBG(531, np, 0xd1e0001, 0, error);
1619 if (NFS_CHANGED(nfsvers, np, &nvattr)) {
1622 NFS_CHANGED_UPDATE(nfsvers, np, &nvattr);
1624 nfs_unlock(np);
1627 error = nfs_buf_get(np, 0, NFS_MAXPATHLEN, vfs_context_thread(ctx), NBLK_READ, &bp);
1629 FSDBG(531, np, 0xd1e0002, 0, error);
1639 error = nmp->nm_funcs->nf_readlink_rpc(np, bp->nb_data, &buflen, ctx);
1655 FSDBG(531, np, bp->nb_validend, 0, error);
1664 nfs3_readlink_rpc(nfsnode_t np, char *buf, uint32_t *buflenp, vfs_context_t ctx)
1672 nmp = NFSTONMP(np);
1680 nfsm_chain_add_fh(error, &nmreq, nfsvers, np->n_fhp, np->n_fhsize);
1683 error = nfs_request(np, NULL, &nmreq, NFSPROC_READLINK, ctx,
1685 if ((lockerror = nfs_lock(np, NFS_NODE_LOCK_EXCLUSIVE)))
1688 nfsm_chain_postop_attr_update(error, &nmrep, np, &xid);
1698 if (np->n_size && (np->n_size < *buflenp))
1699 len = np->n_size;
1708 nfs_unlock(np);
1719 nfs_read_rpc(nfsnode_t np, struct uio *uiop, vfs_context_t ctx)
1727 FSDBG_TOP(536, np, uiop->uio_offset, uio_uio_resid(uiop), 0);
1728 nmp = NFSTONMP(np);
1737 FSDBG_BOT(536, np, uiop->uio_offset, uio_uio_resid(uiop), EFBIG);
1745 FSDBG(536, np, txoffset, len, 0);
1746 error = nmp->nm_funcs->nf_read_rpc_async(np, txoffset, len,
1749 error = nmp->nm_funcs->nf_read_rpc_async_finish(np, req, uiop, &retlen, &eof);
1761 FSDBG_BOT(536, np, eof, uio_uio_resid(uiop), error);
1767 nfsnode_t np,
1779 nmp = NFSTONMP(np);
1786 nfsm_chain_add_fh(error, &nmreq, nfsvers, np->n_fhp, np->n_fhsize);
1797 error = nfs_request_async(np, NULL, &nmreq, NFSPROC_READ, thd, cred, cb, reqp);
1805 nfsnode_t np,
1817 nmp = NFSTONMP(np);
1830 if ((lockerror = nfs_lock(np, NFS_NODE_LOCK_EXCLUSIVE)))
1833 nfsm_chain_postop_attr_update(error, &nmrep, np, &xid);
1840 nfsm_chain_loadattr(error, &nmrep, np, nfsvers, NULL, &xid);
1843 nfs_unlock(np);
1880 nfsnode_t np = VTONFS(vp);
1894 FSDBG_TOP(515, np, uio->uio_offset, uio_uio_resid(uio), ioflag);
1897 FSDBG_BOT(515, np, uio->uio_offset, uio_uio_resid(uio), EIO);
1904 nfs_data_lock(np, NFS_NODE_LOCK_SHARED);
1906 if ((error = nfs_lock(np, NFS_NODE_LOCK_EXCLUSIVE))) {
1907 nfs_data_unlock(np);
1908 FSDBG_BOT(515, np, uio->uio_offset, uio_uio_resid(uio), error);
1911 np->n_wrbusy++;
1913 if (np->n_flag & NWRITEERR) {
1914 error = np->n_error;
1915 np->n_flag &= ~NWRITEERR;
1917 if (np->n_flag & NNEEDINVALIDATE) {
1918 np->n_flag &= ~NNEEDINVALIDATE;
1919 nfs_unlock(np);
1920 nfs_data_unlock(np);
1922 nfs_data_lock(np, NFS_NODE_LOCK_SHARED);
1923 if (error || ((error = nfs_lock(np, NFS_NODE_LOCK_EXCLUSIVE))))
1927 nfs_unlock(np);
1934 if (np->n_flag & NMODIFIED) {
1935 NATTRINVALIDATE(np);
1936 nfs_unlock(np);
1937 nfs_data_unlock(np);
1939 nfs_data_lock(np, NFS_NODE_LOCK_SHARED);
1940 if (error || ((error = nfs_lock(np, NFS_NODE_LOCK_EXCLUSIVE)))) {
1941 FSDBG(515, np, uio->uio_offset, 0x10bad01, error);
1946 NATTRINVALIDATE(np);
1947 nfs_unlock(np);
1948 nfs_data_unlock(np);
1949 error = nfs_getattr(np, &nvattr, ctx, 0);
1951 nfs_data_lock(np, NFS_NODE_LOCK_EXCLUSIVE);
1952 if (error || ((error = nfs_lock(np, NFS_NODE_LOCK_EXCLUSIVE)))) {
1953 FSDBG(515, np, uio->uio_offset, 0x10bad02, error);
1956 uio->uio_offset = np->n_size;
1960 nfs_unlock(np);
1962 FSDBG_BOT(515, np, uio->uio_offset, 0xbad0ff, error);
1966 nfs_unlock(np);
1970 nfs_unlock(np);
1972 if (((uio->uio_offset + uio_uio_resid(uio)) > (off_t)np->n_size) && !(ioflag & IO_APPEND)) {
1974 nfs_data_unlock(np);
1975 nfs_data_lock(np, NFS_NODE_LOCK_EXCLUSIVE);
1991 error = nfs_buf_get(np, lbn, biosize, thd, NBLK_WRITE, &bp);
2020 FSDBG(515, np, uio->uio_offset, bp, 0xd15c001);
2039 FSDBG(515, np, uio->uio_offset, bp, 0xd15c002);
2052 FSDBG(515, np, uio->uio_offset, bp, 0xd15c003);
2057 if (NBOFF(bp) + bp->nb_dirtyend > (off_t)np->n_size) {
2058 bp->nb_dirtyend = np->n_size - NBOFF(bp);
2073 if ((uio->uio_offset + n) > (off_t)np->n_size) {
2075 daddr64_t eofbn = np->n_size / biosize;
2076 int eofoff = np->n_size % biosize;
2082 ((error = nfs_buf_get(np, eofbn, biosize, thd, NBLK_WRITE|NBLK_ONLYVALID, &eofbp))))
2114 np->n_size = uio->uio_offset + n;
2115 nfs_lock(np, NFS_NODE_LOCK_FORCE);
2116 CLR(np->n_flag, NUPDATESIZE);
2117 np->n_flag |= NMODIFIED;
2118 nfs_unlock(np);
2119 FSDBG(516, np, np->n_size, np->n_vattr.nva_size, 0xf00d0001);
2120 ubc_setsize(vp, (off_t)np->n_size); /* XXX errors */
2158 if (NBOFF(bp) + bp->nb_dirtyend > (off_t)np->n_size) {
2159 bp->nb_dirtyend = np->n_size - NBOFF(bp);
2241 error = nfs_read_rpc(np, &auio, ctx);
2255 if ((off_t)np->n_size > boff + bp->nb_validend)
2256 bp->nb_validend = min(np->n_size - (boff + start), biosize);
2274 if (((boff+start) >= (off_t)np->n_size) ||
2275 ((start >= on) && ((boff + on + n) >= (off_t)np->n_size))) {
2292 error = nfs_read_rpc(np, &auio, ctx);
2307 if ((off_t)np->n_size > boff + bp->nb_validend)
2308 bp->nb_validend = min(np->n_size - (boff + start), biosize);
2326 nfs_lock(np, NFS_NODE_LOCK_FORCE);
2327 np->n_flag |= NMODIFIED;
2328 nfs_unlock(np);
2368 nfs_buf_normalize_valid_range(np, bp);
2375 nfs_lock(np, NFS_NODE_LOCK_FORCE);
2377 np->n_needcommitcnt--;
2378 CHECK_NEEDCOMMITCNT(np);
2381 nfs_unlock(np);
2402 if (np->n_needcommitcnt >= NFS_A_LOT_OF_NEEDCOMMITS)
2403 nfs_flushcommits(np, 1);
2408 nfs_lock(np, NFS_NODE_LOCK_FORCE);
2409 np->n_wrbusy--;
2410 nfs_unlock(np);
2411 nfs_data_unlock(np);
2412 FSDBG_BOT(515, np, uio->uio_offset, uio_uio_resid(uio), error);
2422 nfsnode_t np,
2428 return nfs_write_rpc2(np, uiop, vfs_context_thread(ctx), vfs_context_ucred(ctx), iomodep, wverfp);
2433 nfsnode_t np,
2452 FSDBG_TOP(537, np, uiop->uio_offset, uio_uio_resid(uiop), *iomodep);
2453 nmp = NFSTONMP(np);
2465 FSDBG_BOT(537, np, uiop->uio_offset, uio_uio_resid(uiop), EFBIG);
2471 FSDBG(537, np, uiop->uio_offset, len, 0);
2472 error = nmp->nm_funcs->nf_write_rpc_async(np, uiop, len, thd, cred, *iomodep, NULL, &req);
2474 error = nmp->nm_funcs->nf_write_rpc_async_finish(np, req, &commit, &rlen, &wverf2);
2475 nmp = NFSTONMP(np);
2527 FSDBG_BOT(537, np, committed, uio_uio_resid(uiop), error);
2533 nfsnode_t np,
2547 nmp = NFSTONMP(np);
2557 nfsm_chain_add_fh(error, &nmreq, nfsvers, np->n_fhp, np->n_fhsize);
2572 error = nfs_request_async(np, NULL, &nmreq, NFSPROC_WRITE, thd, cred, cb, reqp);
2580 nfsnode_t np,
2593 nmp = NFSTONMP(np);
2605 nmp = NFSTONMP(np);
2608 if (!error && (lockerror = nfs_lock(np, NFS_NODE_LOCK_EXCLUSIVE)))
2612 nfsm_chain_get_wcc_data(error, &nmrep, np, &premtime, &wccpostattr, &xid);
2613 if (nfstimespeccmp(&np->n_mtime, &premtime, ==))
2638 nfsm_chain_loadattr(error, &nmrep, np, nfsvers, NULL, &xid);
2642 NFS_CHANGED_UPDATE(nfsvers, np, &np->n_vattr);
2645 nfs_unlock(np);
2648 ((mp = NFSTOMP(np))) && (vfs_flags(mp) & MNT_ASYNC))
2677 nfsnode_t np = NULL;
2777 error = nfs_nget(NFSTOMP(dnp), dnp, cnp, fh.fh_data, fh.fh_len, &nvattr, &xid, NG_MAKEENTRY, &np);
2778 if (!error && !np)
2779 error = nfs_lookitup(dnp, cnp->cn_nameptr, cnp->cn_namelen, ctx, &np);
2780 if (!error && np)
2781 newvp = NFSTOV(np);
2786 (!newvp || nfs_getattrcache(np, &nvattr, 1) ||
2795 nfs_unlock(np);
2800 nfs_unlock(np);
2826 nfsnode_t np = NULL;
2934 error = nfs_nget(NFSTOMP(dnp), dnp, cnp, fh.fh_data, fh.fh_len, &nvattr, &xid, NG_MAKEENTRY, &np);
2935 if (!error && !np)
2936 error = nfs_lookitup(dnp, cnp->cn_nameptr, cnp->cn_namelen, ctx, &np);
2937 if (!error && np)
2938 newvp = NFSTOV(np);
2950 nfs_unlock(np);
2954 error = nfs3_setattr_rpc(np, vap, ctx, 1);
2960 error = nfs3_setattr_rpc(np, vap, ctx, 1);
2963 nfs_unlock(np);
2970 (!newvp || nfs_getattrcache(np, &nvattr, 1) ||
2978 nfs_unlock(np);
3009 nfsnode_t np = VTONFS(vp);
3023 error = nfs_lock2(dnp, np, NFS_NODE_LOCK_EXCLUSIVE);
3029 while (np->n_hflag & NHLOCKED) {
3030 np->n_hflag |= NHLOCKWANT;
3031 msleep(np, nfs_node_hash_mutex, PINOD, "nfs_remove", NULL);
3033 np->n_hflag |= NHLOCKED;
3045 if (nfs_getattr(np, &nvattr, ctx, 1))
3050 if (!inuse || (np->n_sillyrename && (nvattr.nva_nlink > 1))) {
3055 np->n_hflag &= ~NHLOCKED;
3056 if (np->n_hflag & NHLOCKWANT) {
3057 np->n_hflag &= ~NHLOCKWANT;
3058 wakeup(np);
3061 nfs_unlock2(dnp, np);
3063 FSDBG(260, np, np->n_size, np->n_vattr.nva_size, 0xf00d0011);
3066 nfs_lock(np, NFS_NODE_LOCK_FORCE);
3067 NATTRINVALIDATE(np);
3068 nfs_unlock(np);
3096 if (!error && !inuse && !np->n_sillyrename) {
3104 if (np->n_hflag & NHHASHED) {
3105 LIST_REMOVE(np, n_hash);
3106 np->n_hflag &= ~NHHASHED;
3107 FSDBG(266, 0, np, np->n_flag, 0xb1eb1e);
3112 np->n_flag &= (NMODIFIED);
3114 NATTRINVALIDATE(np);
3117 NATTRINVALIDATE(np);
3119 } else if (!np->n_sillyrename) {
3121 error = nfs_sillyrename(dnp, np, cnp, ctx);
3122 NATTRINVALIDATE(np);
3124 NATTRINVALIDATE(np);
3139 np->n_hflag &= ~NHLOCKED;
3140 if (np->n_hflag & NHLOCKWANT) {
3141 np->n_hflag &= ~NHLOCKWANT;
3142 wakeup(np);
3145 nfs_unlock2(dnp, np);
3487 nfsnode_t np = VTONFS(vp);
3508 nfs_flush(np, MNT_WAIT, vfs_context_thread(ctx), V_IGNORE_WRITEERR);
3510 error = nfs_lock2(tdnp, np, NFS_NODE_LOCK_EXCLUSIVE);
3519 nfsm_chain_add_fh(error, &nmreq, nfsvers, np->n_fhp, np->n_fhsize);
3524 error = nfs_request(np, NULL, &nmreq, NFSPROC_LINK, ctx,
3528 nfsm_chain_postop_attr_update_flag(error, &nmrep, np, attrflag, &xid);
3538 NATTRINVALIDATE(np);
3548 nfs_unlock2(tdnp, np);
3583 nfsnode_t np = NULL;
3673 error = nfs_nget(NFSTOMP(dnp), dnp, cnp, fh.fh_data, fh.fh_len, &nvattr, &xid, NG_MAKEENTRY, &np);
3674 if (!error && np)
3675 newvp = NFSTOV(np);
3685 nfs_unlock(np);
3689 error = nfs_lookitup(dnp, cnp->cn_nameptr, cnp->cn_namelen, ctx, &np);
3691 newvp = NFSTOV(np);
3699 (!newvp || nfs_getattrcache(np, &nvattr, 1) ||
3708 nfs_unlock(np);
3712 nfs_unlock(np);
3737 nfsnode_t np = NULL;
3826 error = nfs_nget(NFSTOMP(dnp), dnp, cnp, fh.fh_data, fh.fh_len, &nvattr, &xid, NG_MAKEENTRY, &np);
3827 if (!error && np)
3828 newvp = NFSTOV(np);
3838 nfs_unlock(np);
3842 error = nfs_lookitup(dnp, cnp->cn_nameptr, cnp->cn_namelen, ctx, &np);
3844 newvp = NFSTOV(np);
3852 (!newvp || nfs_getattrcache(np, &nvattr, 1) ||
3861 nfs_unlock(np);
3865 nfs_unlock(np);
3891 nfsnode_t np = VTONFS(vp);
3909 if ((error = nfs_lock2(dnp, np, NFS_NODE_LOCK_EXCLUSIVE)))
3952 nfs_unlock2(dnp, np);
3966 if (np->n_hflag & NHHASHED) {
3967 LIST_REMOVE(np, n_hash);
3968 np->n_hflag &= ~NHHASHED;
3969 FSDBG(266, 0, np, np->n_flag, 0xb1eb1e);
3993 nfsnode_t np = VTONFS(vp);
4007 if ((error = nfs_lock(np, NFS_NODE_LOCK_EXCLUSIVE)))
4013 if (np->n_direofoffset > 0 && uio->uio_offset >= np->n_direofoffset &&
4014 (np->n_flag & NMODIFIED) == 0) {
4015 if (!nfs_getattr(np, &nvattr, ctx, 1)) {
4016 if (!NFS_CHANGED(nfsvers, np, &nvattr)) {
4017 nfs_unlock(np);
4023 if (NFS_CHANGED_NC(nfsvers, np, &nvattr)) {
4025 np->n_flag &= ~NNEGNCENTRIES;
4030 nfs_unlock(np);
4039 error = nfs_bioread(np, uio, 0, ap->a_eofflag, ctx);
4291 nfsnode_t np;
4476 np = dnp;
4497 fhp, fhsize, &nvattr, &xid, NG_MAKEENTRY, &np);
4501 newvp = NFSTOV(np);
4505 if (doit && bigenough && (np->n_xid <= savexid)) {
4507 nfs_loadattrcache(np, &nvattr, &xid, 0);
4516 nfs_unlock(np);
4601 nfsnode_t np,
4616 cache_purge(NFSTOV(np));
4654 FSDBG(267, dnp, np, num, error);
4657 error = nfs_lookitup(dnp, nsp->nsr_name, nsp->nsr_namlen, ctx, &np);
4658 np->n_sillyrename = nsp;
4767 nfsnode_t np, newnp = NULL;
4796 np = *npp;
4797 if (fh.fh_len != np->n_fhsize) {
4798 u_char *oldbuf = (np->n_fhsize > NFS_SMALLFH) ? np->n_fhp : NULL;
4800 MALLOC_ZONE(np->n_fhp, u_char *, fh.fh_len, M_NFSBIGFH, M_WAITOK);
4801 if (!np->n_fhp) {
4802 np->n_fhp = oldbuf;
4807 np->n_fhp = &np->n_fh[0];
4810 FREE_ZONE(oldbuf, np->n_fhsize, M_NFSBIGFH);
4812 bcopy(fh.fh_data, np->n_fhp, fh.fh_len);
4813 np->n_fhsize = fh.fh_len;
4814 error = nfs_loadattrcache(np, &nvattr, &xid, 0);
4816 newnp = np;
4828 &nvattr, &xid, NG_MAKEENTRY, &np);
4830 newnp = np;
4933 nfsnode_t np,
4945 nmp = NFSTONMP(np);
4946 FSDBG(521, np, offset, count, nmp ? nmp->nm_state : 0);
4962 nfsm_chain_add_fh(error, &nmreq, nfsvers, np->n_fhp, np->n_fhsize);
4967 error = nfs_request2(np, NULL, &nmreq, NFSPROC_COMMIT,
4969 if ((lockerror = nfs_lock(np, NFS_NODE_LOCK_EXCLUSIVE)))
4972 nfsm_chain_get_wcc_data(error, &nmrep, np, &premtime, &wccpostattr, &xid);
4974 nfs_unlock(np);
5048 nfsnode_t np,
5055 struct nfsmount *nmp = NFSTONMP(np);
5067 nfsm_chain_add_fh(error, &nmreq, nfsvers, np->n_fhp, np->n_fhsize);
5070 error = nfs_request(np, NULL, &nmreq, NFSPROC_PATHCONF, ctx,
5072 if ((lockerror = nfs_lock(np, NFS_NODE_LOCK_EXCLUSIVE)))
5074 nfsm_chain_postop_attr_update(error, &nmrep, np, &xid);
5076 nfs_unlock(np);
5142 nfsnode_t np = VTONFS(vp);
5181 error = nfs3_pathconf_rpc(np, &nfsa, ap->a_context);
5201 error = nfs4_pathconf_rpc(np, &nfsa, ap->a_context);
5217 else if ((nmp->nm_vers == NFS_VER4) && NFS_BITMAP_ISSET(np->n_vattr.nva_bitmap, NFS_FATTR_MAXLINK))
5218 *ap->a_retval = np->n_vattr.nva_maxlink;
5307 nfsnode_t np = VTONFS(ap->a_vp);
5314 if ((error = nfs_lock(np, NFS_NODE_LOCK_EXCLUSIVE)))
5316 np->n_flag |= NACC;
5318 np->n_atim.tv_sec = now.tv_sec;
5319 np->n_atim.tv_nsec = now.tv_usec * 1000;
5320 nfs_unlock(np);
5337 nfsnode_t np = VTONFS(ap->a_vp);
5344 if ((error = nfs_lock(np, NFS_NODE_LOCK_EXCLUSIVE)))
5346 np->n_flag |= NUPD;
5348 np->n_mtim.tv_sec = now.tv_sec;
5349 np->n_mtim.tv_nsec = now.tv_usec * 1000;
5350 nfs_unlock(np);
5369 nfsnode_t np = VTONFS(vp);
5374 if ((error = nfs_lock(np, NFS_NODE_LOCK_EXCLUSIVE)))
5376 if (np->n_flag & (NACC | NUPD)) {
5377 np->n_flag |= NCHG;
5380 if (np->n_flag & NACC) {
5381 vattr.va_access_time = np->n_atim;
5384 if (np->n_flag & NUPD) {
5385 vattr.va_modify_time = np->n_mtim;
5388 nfs_unlock(np);
5391 nfs_unlock(np);
5394 nfs_unlock(np);
5415 nfsnode_t np = VTONFS(ap->a_vp);
5422 if ((error = nfs_lock(np, NFS_NODE_LOCK_EXCLUSIVE)))
5424 np->n_flag |= NACC;
5426 np->n_atim.tv_sec = now.tv_sec;
5427 np->n_atim.tv_nsec = now.tv_usec * 1000;
5428 nfs_unlock(np);
5445 nfsnode_t np = VTONFS(ap->a_vp);
5452 if ((error = nfs_lock(np, NFS_NODE_LOCK_EXCLUSIVE)))
5454 np->n_flag |= NUPD;
5456 np->n_mtim.tv_sec = now.tv_sec;
5457 np->n_mtim.tv_nsec = now.tv_usec * 1000;
5458 nfs_unlock(np);
5477 nfsnode_t np = VTONFS(vp);
5483 if ((error = nfs_lock(np, NFS_NODE_LOCK_EXCLUSIVE)))
5485 if (np->n_flag & (NACC | NUPD)) {
5487 if (np->n_flag & NACC) {
5488 np->n_atim.tv_sec = now.tv_sec;
5489 np->n_atim.tv_nsec = now.tv_usec * 1000;
5491 if (np->n_flag & NUPD) {
5492 np->n_mtim.tv_sec = now.tv_sec;
5493 np->n_mtim.tv_nsec = now.tv_usec * 1000;
5495 np->n_flag |= NCHG;
5498 if (np->n_flag & NACC) {
5499 vattr.va_access_time = np->n_atim;
5502 if (np->n_flag & NUPD) {
5503 vattr.va_modify_time = np->n_mtim;
5506 nfs_unlock(np);
5509 nfs_unlock(np);
5512 nfs_unlock(np);
5583 nfsnode_t np = VTONFS(vp);
5598 FSDBG(322, np, f_offset, size, flags);
5608 if (f_offset < 0 || f_offset >= (off_t)np->n_size || (f_offset & PAGE_MASK_64)) {
5650 if ((error = nmp->nm_funcs->nf_read_rpc_async(np, txoffset, iosize, thd, cred, NULL, &req[nextsend]))) {
5671 error = nmp->nm_funcs->nf_read_rpc_async_finish(np, req[nextwait], uio, &retsize, NULL);
5864 nfsnode_t np = VTONFS(vp);
5901 nfs_data_lock2(np, NFS_NODE_LOCK_SHARED, 0);
5915 if ((bp = nfs_buf_incore(np, lbn))) {
5919 nfs_data_unlock2(np, 0);
5946 if (end > (off_t)np->n_size)
5947 end = np->n_size;
5953 FSDBG(323, np, bp, 0xd00deebc, EBUSY);
5956 nfs_data_unlock2(np, 0);
5978 nfs_lock(np, NFS_NODE_LOCK_FORCE);
5981 np->n_needcommitcnt--;
5982 CHECK_NEEDCOMMITCNT(np);
5984 nfs_unlock(np);
5996 nfs_lock(np, NFS_NODE_LOCK_FORCE);
5997 if (np->n_flag & NWRITEERR) {
5998 error = np->n_error;
5999 nfs_unlock(np);
6000 nfs_data_unlock2(np, 0);
6006 nfs_unlock(np);
6008 if (f_offset < 0 || f_offset >= (off_t)np->n_size ||
6010 nfs_data_unlock2(np, 0);
6020 if ((u_quad_t)f_offset + size > np->n_size)
6021 xsize = np->n_size - f_offset;
6035 if ((u_quad_t)f_offset < np->n_size && (u_quad_t)f_offset + size > np->n_size) {
6036 size_t io = np->n_size - f_offset;
6038 FSDBG(321, np->n_size, f_offset, f_offset + io, size - io);
6040 nfs_data_unlock2(np, 0);
6073 if ((error = nmp->nm_funcs->nf_write_rpc_async(np, &auio, iosize, thd, cred, iomode, NULL, &req[nextsend]))) {
6086 error = nmp->nm_funcs->nf_write_rpc_async_finish(np, req[nextwait], &iomode, &iosize, &wverf2);
6119 error = nfs_write_rpc2(np, &auio, thd, cred, &iomode, &wverf2);
6143 error = nmp->nm_funcs->nf_commit_rpc(np, f_offset, xsize, cred);