Lines Matching defs:np
102 #define NFSBUFHASH(np, lbn) \
103 (&nfsbufhashtbl[((long)(np) / sizeof(*(np)) + (int)(lbn)) & nfsbufhash])
304 nfs_buf_is_incore(nfsnode_t np, daddr64_t blkno)
308 if (nfs_buf_incore(np, blkno))
320 nfs_buf_incore(nfsnode_t np, daddr64_t blkno)
323 struct nfsbuf * bp = NFSBUFHASH(np, blkno)->lh_first;
325 if ((bp->nb_lblkno == blkno) && (bp->nb_np == np)) {
513 nfs_buf_normalize_valid_range(nfsnode_t np, struct nfsbuf *bp)
528 if (NBOFF(bp) + bp->nb_validend > (off_t)np->n_size)
529 bp->nb_validend = np->n_size % bp->nb_bufsize;
540 nfsnode_t np;
544 np = bp->nb_np;
557 nfs_buf_check_write_verifier(np, bp);
564 nfs_flushcommits(np, 1);
638 nfsnode_t np,
645 vnode_t vp = NFSTOV(np);
654 FSDBG_TOP(541, np, blkno, size, flags);
662 FSDBG_BOT(541, np, blkno, 0, ENXIO);
675 FSDBG_TOP(542, np, blkno, nfs_nbdwrite, NFS_A_LOT_OF_DELAYED_WRITES);
682 FSDBG_BOT(542, np, blkno, nfs_nbdwrite, NFS_A_LOT_OF_DELAYED_WRITES);
689 while (np->n_bflag & NBINVALINPROG) {
690 np->n_bflag |= NBINVALWANT;
693 msleep(&np->n_bflag, nfs_buf_mutex, slpflag, "nfs_buf_get_invalwait", &ts);
696 FSDBG_BOT(541, np, blkno, 0, error);
699 if (np->n_bflag & NBINVALINPROG)
704 if ((bp = nfs_buf_incore(np, blkno))) {
709 FSDBG_BOT(541, np, blkno, bp, 0xbcbcbcbc);
712 FSDBG_TOP(543, np, blkno, bp, bp->nb_flags);
720 FSDBG_BOT(543, np, blkno, bp, bp->nb_flags);
722 FSDBG_BOT(541, np, blkno, 0, error);
740 FSDBG_BOT(541, np, blkno, 0, 0x0000cace);
797 FSDBG(544, np, blkno, bp, bp->nb_flags);
842 FSDBG_BOT(541, np, blkno, 0, error);
864 FSDBG(545, np, blkno, bp, 0);
867 FSDBG_TOP(546, np, blkno, nfsbufcnt, nfsbufmax);
874 FSDBG_BOT(546, np, blkno, nfsbufcnt, nfsbufmax);
876 FSDBG_BOT(541, np, blkno, 0, error);
888 LIST_INSERT_HEAD(NFSBUFHASH(np, blkno), bp, nb_hash);
890 bp->nb_np = np;
891 LIST_INSERT_HEAD(&np->n_cleanblkhd, bp, nb_vnbufs);
926 FSDBG_BOT(541, np, blkno, 0xb00, ENOMEM);
965 FSDBG_BOT(541, np, blkno, 0x2bc, EIO);
978 FSDBG_BOT(541, np, blkno, bp, bp->nb_flags);
986 nfsnode_t np = bp->nb_np;
995 vp = np ? NFSTOV(np) : NULL;
1053 if (NBOFF(bp) + bp->nb_bufsize > (off_t)(np->n_size)) {
1055 start = trunc_page_64(np->n_size) + PAGE_SIZE_64;
1226 nfsnode_t np = bp->nb_np;
1244 LIST_INSERT_HEAD(&np->n_dirtyblkhd, bp, nb_vnbufs);
1252 vnode_waitforwrites(NFSTOV(np), VNODE_ASYNC_THROTTLE, 0, 0, "nfs_buf_write_delayed");
1255 nfs_node_lock_force(np);
1256 np->n_flag |= NMODIFIED;
1257 nfs_node_unlock(np);
1286 nfs_buf_check_write_verifier(nfsnode_t np, struct nfsbuf *bp)
1293 nmp = NFSTONMP(np);
1302 nfs_node_lock_force(np);
1303 np->n_needcommitcnt--;
1304 CHECK_NEEDCOMMITCNT(np);
1305 nfs_node_unlock(np);
1392 nfs_buf_iterprepare(nfsnode_t np, struct nfsbuflists *iterheadp, int flags)
1397 listheadp = &np->n_dirtyblkhd;
1399 listheadp = &np->n_cleanblkhd;
1401 if ((flags & NBI_NOWAIT) && (np->n_bufiterflags & NBI_ITER)) {
1406 while (np->n_bufiterflags & NBI_ITER) {
1407 np->n_bufiterflags |= NBI_ITERWANT;
1408 msleep(&np->n_bufiterflags, nfs_buf_mutex, 0, "nfs_buf_iterprepare", NULL);
1414 np->n_bufiterflags |= NBI_ITER;
1429 nfs_buf_itercomplete(nfsnode_t np, struct nfsbuflists *iterheadp, int flags)
1435 listheadp = &np->n_dirtyblkhd;
1437 listheadp = &np->n_cleanblkhd;
1445 np->n_bufiterflags &= ~NBI_ITER;
1446 if (np->n_bufiterflags & NBI_ITERWANT) {
1447 np->n_bufiterflags &= ~NBI_ITERWANT;
1448 wakeup(&np->n_bufiterflags);
1460 nfsnode_t np;
1464 np = bp->nb_np;
1497 nfsnode_t np = bp->nb_np;
1514 if ((off_t)np->n_size >= (boff + bp->nb_bufsize))
1516 else if ((off_t)np->n_size >= boff)
1517 bp->nb_validend = np->n_size - boff;
1521 if ((nmp = NFSTONMP(np)) && (nmp->nm_vers == NFS_VER2) &&
1540 nfsnode_t np = bp->nb_np;
1548 nmp = NFSTONMP(np);
1597 error = nmp->nm_funcs->nf_read_rpc_async(np, boff + offset, len, thd, cred, &cb, &req);
1654 nfsnode_t np;
1661 np = req->r_np;
1671 nmp = NFSTONMP(np);
1691 error = nmp->nm_funcs->nf_read_rpc_async_finish(np, req, auio, &rlen, &eof);
1703 NP(np, "nfs_buf_read_rpc_finish: error %d @ 0x%llx, 0x%x 0x%x, initiating recovery",
1708 if (np->n_flag & NREVOKE) {
1758 eofrem = np->n_size - (NBOFF(bp) + offset + rlen);
1777 error = nmp->nm_funcs->nf_read_rpc_async(np, NBOFF(bp) + offset, length, thd, cred, &cb, &rreq);
1838 nfs_buf_readahead(nfsnode_t np, int ioflag, daddr64_t *rabnp, daddr64_t lastrabn, thread_t thd, kauth_cred_t cred)
1840 struct nfsmount *nmp = NFSTONMP(np);
1854 if ((*rabnp * nmp->nm_biosize) >= (off_t)np->n_size) {
1859 error = nfs_buf_get(np, *rabnp, nmp->nm_biosize, thd, NBLK_READ|NBLK_NOWAIT, &bp);
1862 nfs_node_lock_force(np);
1863 np->n_lastrahead = *rabnp;
1864 nfs_node_unlock(np);
1895 nfs_bioread(nfsnode_t np, uio_t uio, int ioflag, vfs_context_t ctx)
1897 vnode_t vp = NFSTOV(np);
1908 FSDBG_TOP(514, np, uio_offset(uio), uio_resid(uio), ioflag);
1917 FSDBG_BOT(514, np, 0xd1e0016, 0, EINVAL);
1936 if (ISSET(np->n_flag, NUPDATESIZE))
1937 nfs_data_update_size(np, 0);
1939 if ((error = nfs_node_lock(np))) {
1940 FSDBG_BOT(514, np, 0xd1e0222, 0, error);
1944 if (np->n_flag & NNEEDINVALIDATE) {
1945 np->n_flag &= ~NNEEDINVALIDATE;
1946 nfs_node_unlock(np);
1949 error = nfs_node_lock(np);
1951 FSDBG_BOT(514, np, 0xd1e0322, 0, error);
1956 modified = (np->n_flag & NMODIFIED);
1957 nfs_node_unlock(np);
1959 error = nfs_getattr(np, NULL, ctx, modified ? NGA_UNCACHED : NGA_CACHED);
1961 FSDBG_BOT(514, np, 0xd1e0004, 0, error);
1966 FSDBG_BOT(514, np, 0xd1e0001, 0, 0);
1970 FSDBG_BOT(514, np, 0xd1e0002, 0, EINVAL);
1982 if (end > (off_t)np->n_size)
1983 end = np->n_size;
1986 nfs_node_lock_force(np);
1988 (!rabn || (rabn == np->n_lastread) || (rabn == (np->n_lastread+1)))) {
1990 if ((maxrabn * biosize) >= (off_t)np->n_size)
1991 maxrabn = ((off_t)np->n_size - 1)/biosize;
1993 if (maxrabn < np->n_lastrahead)
1994 np->n_lastrahead = -1;
1995 if (rabn < np->n_lastrahead)
1996 rabn = np->n_lastrahead + 1;
1997 nfs_node_unlock(np);
2004 nfs_data_lock(np, NFS_DATA_LOCK_SHARED);
2017 diff = np->n_size - uio_offset(uio);
2024 nfs_data_unlock(np);
2025 FSDBG_BOT(514, np, uio_offset(uio), 0xcacefeed, error);
2032 FSDBG(514, np, 0xcacefeed, uio_offset(uio), error);
2038 nfs_node_lock_force(np);
2039 np->n_lastread = (uio_offset(uio) - 1) / biosize;
2040 nfs_node_unlock(np);
2042 if ((uio_resid(uio) <= 0) || (uio_offset(uio) >= (off_t)np->n_size)) {
2043 nfs_data_unlock(np);
2044 FSDBG_BOT(514, np, uio_offset(uio), uio_resid(uio), 0xaaaaaaaa);
2053 error = nfs_buf_readahead(np, ioflag, &rabn, lastrabn, thd, cred);
2055 nfs_data_unlock(np);
2056 FSDBG_BOT(514, np, 0xd1e000b, 1, error);
2073 diff = np->n_size - uio_offset(uio);
2077 error = nfs_buf_get(np, lbn, biosize, thd, NBLK_READ, &bp);
2079 nfs_data_unlock(np);
2080 FSDBG_BOT(514, np, 0xd1e000c, 0, error);
2125 nfs_buf_normalize_valid_range(np, bp);
2144 nfs_data_unlock(np);
2145 FSDBG_BOT(514, np, 0xd1e000d, 0, error);
2168 error = nfs_read_rpc(np, auio, ctx);
2174 nfs_data_unlock(np);
2175 FSDBG_BOT(514, np, 0xd1e000e, 0, error);
2181 nfs_buf_normalize_valid_range(np, bp);
2204 nfs_data_unlock(np);
2206 FSDBG_BOT(514, np, 0xd1e000f, 0, error);
2223 nfs_data_unlock(np);
2224 nfs_node_lock_force(np);
2225 np->n_lastread = (uio_offset(uio) - 1) / biosize;
2226 nfs_node_unlock(np);
2228 FSDBG_BOT(514, np, uio_offset(uio), uio_resid(uio), error);
2281 nfsnode_t np;
2293 np = bp->nb_np;
2311 LIST_INSERT_HEAD(&np->n_cleanblkhd, bp, nb_vnbufs);
2314 nfs_node_lock_force(np);
2315 np->n_numoutput++;
2316 nfs_node_unlock(np);
2317 vnode_startwrite(NFSTOV(np));
2330 if (!ISSET(bp->nb_flags, NB_META) && UBCINFOEXISTS(NFSTOV(np))) {
2346 nfs_buf_check_write_verifier(np, bp);
2348 struct nfsmount *nmp = NFSTONMP(np);
2356 error = nmp->nm_funcs->nf_commit_rpc(np, NBOFF(bp) + bp->nb_dirtyoff,
2369 nfs_node_lock_force(np);
2370 np->n_needcommitcnt--;
2371 CHECK_NEEDCOMMITCNT(np);
2372 nfs_node_unlock(np);
2376 if (NBOFF(bp) + bp->nb_dirtyend > (off_t) np->n_size) {
2377 bp->nb_dirtyend = np->n_size - NBOFF(bp);
2404 if ((NBOFF(bp) + dend) > (off_t) np->n_size)
2405 dend = np->n_size - NBOFF(bp);
2452 LIST_INSERT_HEAD(&np->n_cleanblkhd, bp, nb_vnbufs);
2458 if ((np->n_flag & NNEEDINVALIDATE) &&
2459 !(np->n_bflag & (NBINVALINPROG|NBFLUSHINPROG))) {
2461 nfs_node_lock_force(np);
2462 if (np->n_flag & NNEEDINVALIDATE) {
2464 np->n_flag &= ~NNEEDINVALIDATE;
2466 nfs_node_unlock(np);
2479 nfs_vinvalbuf2(NFSTOV(np), V_SAVE|V_IGNORE_WRITEERR, thd, cred, 1);
2495 nfsnode_t np = bp->nb_np;
2518 nfs_node_lock_force(np);
2519 np->n_needcommitcnt++;
2520 nfs_node_unlock(np);
2527 nfs_node_lock_force(np);
2528 np->n_needcommitcnt--;
2529 CHECK_NEEDCOMMITCNT(np);
2530 nfs_node_unlock(np);
2563 LIST_INSERT_HEAD(&np->n_dirtyblkhd, bp, nb_vnbufs);
2579 nfs_node_lock_force(np);
2580 np->n_error = error;
2581 np->n_flag |= (NWRITEERR | NNEEDINVALIDATE);
2582 NATTRINVALIDATE(np);
2583 nfs_node_unlock(np);
2604 nfsnode_t np = bp->nb_np;
2605 struct nfsmount *nmp = NFSTONMP(np);
2639 if (NBOFF(bp) + off + len > (off_t) np->n_size)
2640 len -= (NBOFF(bp) + off + len) - np->n_size;
2645 error = nfs_write_rpc2(np, auio, thd, cred, &iomode2, &bp->nb_verf);
2666 error = nmp->nm_funcs->nf_commit_rpc(np, NBOFF(bp), bp->nb_bufsize, cred, wverf);
2689 nfsnode_t np = bp->nb_np;
2698 nmp = NFSTONMP(np);
2748 error = nmp->nm_funcs->nf_write_rpc_async(np, auio, len, thd, cred,
2810 nfsnode_t np;
2817 np = req->r_np;
2827 nmp = NFSTONMP(np);
2843 error = nmp->nm_funcs->nf_write_rpc_async_finish(np, req, &committed, &rlen, &wverf);
2855 NP(np, "nfs_buf_write_rpc_finish: error %d @ 0x%llx, 0x%x 0x%x, initiating recovery",
2860 if (np->n_flag & NREVOKE) {
2945 error = nmp->nm_funcs->nf_write_rpc_async(np, auio, length, thd, cred,
3007 nfs_flushcommits(nfsnode_t np, int nowait)
3018 FSDBG_TOP(557, np, 0, 0, 0);
3026 if (!LIST_EMPTY(&np->n_dirtyblkhd)) {
3027 error = nfs_node_lock(np);
3030 np->n_flag |= NMODIFIED;
3031 nfs_node_unlock(np);
3039 nmp = NFSTONMP(np);
3054 if (!nfs_buf_iterprepare(np, &blist, flags)) {
3057 LIST_INSERT_HEAD(&np->n_dirtyblkhd, bp, nb_vnbufs);
3062 nfs_buf_check_write_verifier(np, bp);
3118 nfs_buf_itercomplete(np, &blist, NBI_DIRTY);
3164 retv = nmp->nm_funcs->nf_commit_rpc(np, off, count, wcred, wverf);
3170 retv = nmp->nm_funcs->nf_commit_rpc(np, toff, count, bp->nb_wcred, wverf);
3184 nfs_node_lock_force(np);
3186 np->n_needcommitcnt--;
3187 CHECK_NEEDCOMMITCNT(np);
3188 nfs_node_unlock(np);
3193 LIST_INSERT_HEAD(&np->n_dirtyblkhd, bp, nb_vnbufs);
3199 nfs_node_lock_force(np);
3200 np->n_numoutput++;
3201 nfs_node_unlock(np);
3202 vnode_startwrite(NFSTOV(np));
3220 LIST_INSERT_HEAD(&np->n_cleanblkhd, bp, nb_vnbufs);
3234 FSDBG_BOT(557, np, 0, 0, error);
3244 nfs_flush(nfsnode_t np, int waitfor, thread_t thd, int ignore_writeerr)
3248 struct nfsmount *nmp = NFSTONMP(np);
3252 FSDBG_TOP(517, np, waitfor, ignore_writeerr, 0);
3262 if (!LIST_EMPTY(&np->n_dirtyblkhd)) {
3263 nfs_node_lock_force(np);
3264 np->n_flag |= NMODIFIED;
3265 nfs_node_unlock(np);
3269 while (np->n_bflag & NBFLUSHINPROG) {
3270 np->n_bflag |= NBFLUSHWANT;
3271 error = msleep(&np->n_bflag, nfs_buf_mutex, slpflag, "nfs_flush", NULL);
3273 ((error = nfs_sigintr(NFSTONMP(np), NULL, thd, 0)))) {
3278 np->n_bflag |= NBFLUSHINPROG;
3288 FSDBG(518, LIST_FIRST(&np->n_dirtyblkhd), np->n_flag, 0, 0);
3289 if (!NFSTONMP(np)) {
3296 if (!nfs_buf_iterprepare(np, &blist, NBI_DIRTY)) {
3299 LIST_INSERT_HEAD(&np->n_dirtyblkhd, bp, nb_vnbufs);
3308 error2 = nfs_sigintr(NFSTONMP(np), NULL, thd, 0);
3312 nfs_buf_itercomplete(np, &blist, NBI_DIRTY);
3333 nfs_buf_check_write_verifier(np, bp);
3348 nfs_node_lock_force(np);
3349 np->n_error = bp->nb_error ? bp->nb_error : EIO;
3350 np->n_flag |= NWRITEERR;
3351 nfs_node_unlock(np);
3364 nfs_buf_itercomplete(np, &blist, NBI_DIRTY);
3369 while ((error = vnode_waitforwrites(NFSTOV(np), 0, slpflag, slptimeo, "nfsflush"))) {
3370 error2 = nfs_sigintr(NFSTONMP(np), NULL, thd, 0);
3385 while (np->n_needcommitcnt)
3386 if (nfs_flushcommits(np, 0))
3392 if (!LIST_EMPTY(&np->n_dirtyblkhd)) {
3393 nfs_node_lock_force(np);
3394 np->n_flag |= NMODIFIED;
3395 nfs_node_unlock(np);
3402 if (!LIST_EMPTY(&np->n_dirtyblkhd)) {
3403 nfs_node_lock_force(np);
3404 np->n_flag |= NMODIFIED;
3405 nfs_node_unlock(np);
3408 if (!LIST_EMPTY(&np->n_dirtyblkhd))
3411 nfs_node_lock_force(np);
3425 if (!np->n_wrbusy && !np->n_numoutput) {
3426 np->n_flag &= ~NMODIFIED;
3427 NATTRINVALIDATE(np);
3428 nfs_get_xid(&np->n_xid);
3431 nfs_node_lock_force(np);
3434 FSDBG(526, np->n_flag, np->n_error, 0, 0);
3435 if (!ignore_writeerr && (np->n_flag & NWRITEERR)) {
3436 error = np->n_error;
3437 np->n_flag &= ~NWRITEERR;
3439 nfs_node_unlock(np);
3442 flags = np->n_bflag;
3443 np->n_bflag &= ~(NBFLUSHINPROG|NBFLUSHWANT);
3446 wakeup(&np->n_bflag);
3448 FSDBG_BOT(517, np, error, ignore_writeerr, 0);
3458 nfsnode_t np,
3470 if ((error = nfs_flush(np, MNT_WAIT, thd, (flags & V_IGNORE_WRITEERR))))
3477 if (nfs_buf_iterprepare(np, &blist, list)) {
3479 if (nfs_buf_iterprepare(np, &blist, list))
3485 LIST_INSERT_HEAD(&np->n_cleanblkhd, bp, nb_vnbufs);
3487 LIST_INSERT_HEAD(&np->n_dirtyblkhd, bp, nb_vnbufs);
3490 FSDBG(556, np, bp, NBOFF(bp), bp->nb_flags);
3492 FSDBG(554, np, bp, -1, error);
3494 nfs_buf_itercomplete(np, &blist, list);
3500 FSDBG(554, np, bp, NBOFF(bp), bp->nb_flags);
3502 if ((flags & V_SAVE) && UBCINFOEXISTS(NFSTOV(np)) && bp->nb_np &&
3503 (NBOFF(bp) < (off_t)np->n_size)) {
3507 int end = (NBOFF(bp) + bp->nb_bufsize > (off_t)np->n_size) ?
3508 ((off_t)np->n_size - NBOFF(bp)) : bp->nb_bufsize;
3540 FSDBG(554, np, bp, 0xd00dee, bp->nb_flags);
3556 nfs_node_lock_force(np);
3558 np->n_error = error;
3559 np->n_flag |= NWRITEERR;
3567 NATTRINVALIDATE(np);
3568 nfs_node_unlock(np);
3576 nfs_buf_itercomplete(np, &blist, list);
3591 nfs_buf_itercomplete(np, &blist, list);
3593 if (!LIST_EMPTY(&(np)->n_dirtyblkhd) || !LIST_EMPTY(&(np)->n_cleanblkhd))
3596 nfs_node_lock_force(np);
3598 np->n_flag &= ~NMODIFIED;
3599 if (vnode_vtype(NFSTOV(np)) == VREG)
3600 np->n_lastrahead = -1;
3601 nfs_node_unlock(np);
3620 nfsnode_t np = VTONFS(vp);
3626 FSDBG_TOP(554, np, flags, intrflg, 0);
3640 while (np->n_bflag & NBINVALINPROG) {
3641 np->n_bflag |= NBINVALWANT;
3642 msleep(&np->n_bflag, nfs_buf_mutex, slpflag, "nfs_vinvalbuf", &ts);
3647 if (np->n_bflag & NBINVALINPROG)
3650 np->n_bflag |= NBINVALINPROG;
3655 error = nfs_vinvalbuf_internal(np, flags, thd, cred, slpflag, 0);
3657 FSDBG(554, np, 0, 0, error);
3660 error = nfs_vinvalbuf_internal(np, flags, thd, cred, 0, slptimeo);
3676 nflags = np->n_bflag;
3677 np->n_bflag &= ~(NBINVALINPROG|NBINVALWANT);
3680 wakeup(&np->n_bflag);
3682 FSDBG_BOT(554, np, flags, intrflg, error);
3690 nfs_wait_bufs(nfsnode_t np)
3697 if (!nfs_buf_iterprepare(np, &blist, NBI_CLEAN)) {
3700 LIST_INSERT_HEAD(&np->n_cleanblkhd, bp, nb_vnbufs);
3705 nfs_buf_itercomplete(np, &blist, NBI_CLEAN);
3713 nfs_buf_itercomplete(np, &blist, NBI_CLEAN);
3715 if (!nfs_buf_iterprepare(np, &blist, NBI_DIRTY)) {
3718 LIST_INSERT_HEAD(&np->n_dirtyblkhd, bp, nb_vnbufs);
3723 nfs_buf_itercomplete(np, &blist, NBI_DIRTY);
3731 nfs_buf_itercomplete(np, &blist, NBI_DIRTY);
3832 nfsnode_t np = bp->nb_np;
3833 struct nfsmount *nmp = NFSTONMP(np);
3840 error = nfs3_readdir_rpc(np, bp, ctx);
3842 error = nfs4_readdir_rpc(np, bp, ctx);