Lines Matching refs:bp
282 nfs_buf_remfree(struct nfsbuf *bp)
284 if (bp->nb_free.tqe_next == NFSNOLIST)
286 if (ISSET(bp->nb_flags, NB_DELWRI)) {
288 TAILQ_REMOVE(&nfsbufdelwri, bp, nb_free);
289 } else if (ISSET(bp->nb_flags, NB_META)) {
291 TAILQ_REMOVE(&nfsbuffreemeta, bp, nb_free);
294 TAILQ_REMOVE(&nfsbuffree, bp, nb_free);
296 bp->nb_free.tqe_next = NFSNOLIST;
323 struct nfsbuf * bp = NFSBUFHASH(np, blkno)->lh_first;
324 for (; bp != NULL; bp = bp->nb_hash.le_next)
325 if ((bp->nb_lblkno == blkno) && (bp->nb_np == np)) {
326 if (!ISSET(bp->nb_flags, NB_INVAL)) {
327 FSDBG(547, bp, blkno, bp->nb_flags, bp->nb_np);
328 return (bp);
346 struct nfsbuf *bp;
353 bp = nfs_buf_incore(VTONFS(vp), (daddr64_t)(offset / nmp->nm_biosize));
354 if (!bp)
356 FSDBG(325, bp, bp->nb_flags, bp->nb_dirtyoff, bp->nb_dirtyend);
357 if (ISSET(bp->nb_lflags, NBL_BUSY)) {
366 if (bp->nb_dirtyend > 0) {
367 int start = offset - NBOFF(bp);
368 if ((bp->nb_dirtyend > start) &&
369 (bp->nb_dirtyoff < (start + PAGE_SIZE))) {
377 nfs_buf_remfree(bp);
378 TAILQ_INSERT_HEAD(&nfsbufdelwri, bp, nb_free);
393 nfs_buf_upl_setup(struct nfsbuf *bp)
399 if (ISSET(bp->nb_flags, NB_PAGELIST))
403 if (!ISSET(bp->nb_flags, NB_READ)) {
410 kret = ubc_create_upl(NFSTOV(bp->nb_np), NBOFF(bp), bp->nb_bufsize,
414 bp->nb_pagelist = NULL;
419 bp->nb_pagelist = NULL;
423 FSDBG(538, bp, NBOFF(bp), bp->nb_bufsize, bp->nb_np);
425 bp->nb_pagelist = upl;
426 SET(bp->nb_flags, NB_PAGELIST);
435 nfs_buf_upl_check(struct nfsbuf *bp)
441 if (!ISSET(bp->nb_flags, NB_PAGELIST))
444 npages = round_page_32(bp->nb_bufsize) / PAGE_SIZE;
445 filesize = ubc_getsize(NFSTOV(bp->nb_np));
446 fileoffset = NBOFF(bp);
448 SET(bp->nb_flags, NB_CACHE);
450 CLR(bp->nb_flags, NB_CACHE);
452 pl = ubc_upl_pageinfo(bp->nb_pagelist);
453 bp->nb_valid = bp->nb_dirty = 0;
460 CLR(bp->nb_flags, NB_CACHE);
463 NBPGVALID_SET(bp,i);
465 NBPGDIRTY_SET(bp, i);
467 fileoffset = NBOFF(bp);
468 if (ISSET(bp->nb_flags, NB_CACHE)) {
469 bp->nb_validoff = 0;
470 bp->nb_validend = bp->nb_bufsize;
471 if (fileoffset + bp->nb_validend > filesize)
472 bp->nb_validend = filesize - fileoffset;
474 bp->nb_validoff = bp->nb_validend = -1;
476 FSDBG(539, bp, fileoffset, bp->nb_valid, bp->nb_dirty);
477 FSDBG(539, bp->nb_validoff, bp->nb_validend, bp->nb_dirtyoff, bp->nb_dirtyend);
485 nfs_buf_map(struct nfsbuf *bp)
489 if (bp->nb_data)
491 if (!ISSET(bp->nb_flags, NB_PAGELIST))
494 kret = ubc_upl_map(bp->nb_pagelist, (vm_offset_t *)&(bp->nb_data));
497 if (bp->nb_data == 0)
499 FSDBG(540, bp, bp->nb_flags, NBOFF(bp), bp->nb_data);
513 nfs_buf_normalize_valid_range(nfsnode_t np, struct nfsbuf *bp)
517 pg = bp->nb_validoff/PAGE_SIZE;
518 while (pg >= 0 && NBPGVALID(bp,pg))
520 bp->nb_validoff = (pg+1) * PAGE_SIZE;
522 npg = bp->nb_bufsize/PAGE_SIZE;
523 pg = bp->nb_validend/PAGE_SIZE;
524 while (pg < npg && NBPGVALID(bp,pg))
526 bp->nb_validend = pg * PAGE_SIZE;
528 if (NBOFF(bp) + bp->nb_validend > (off_t)np->n_size)
529 bp->nb_validend = np->n_size % bp->nb_bufsize;
539 struct nfsbuf *bp;
543 while (i < 8 && (bp = TAILQ_FIRST(&nfsbufdelwri)) != NULL) {
544 np = bp->nb_np;
545 nfs_buf_remfree(bp);
546 nfs_buf_refget(bp);
547 while ((error = nfs_buf_acquire(bp, 0, 0, 0)) == EAGAIN);
548 nfs_buf_refrele(bp);
551 if (!bp->nb_np) {
553 nfs_buf_drop(bp);
556 if (ISSET(bp->nb_flags, NB_NEEDCOMMIT))
557 nfs_buf_check_write_verifier(np, bp);
558 if (ISSET(bp->nb_flags, NB_NEEDCOMMIT)) {
560 TAILQ_INSERT_TAIL(&nfsbufdelwri, bp, nb_free);
562 nfs_buf_drop(bp);
566 SET(bp->nb_flags, NB_ASYNC);
568 nfs_buf_write(bp);
647 struct nfsbuf *bp;
704 if ((bp = nfs_buf_incore(np, blkno))) {
706 if (ISSET(bp->nb_lflags, NBL_BUSY)) {
709 FSDBG_BOT(541, np, blkno, bp, 0xbcbcbcbc);
712 FSDBG_TOP(543, np, blkno, bp, bp->nb_flags);
713 SET(bp->nb_lflags, NBL_WANTED);
717 msleep(bp, nfs_buf_mutex, slpflag|(PRIBIO+1)|PDROP,
720 FSDBG_BOT(543, np, blkno, bp, bp->nb_flags);
727 if (bp->nb_bufsize != bufsize)
729 SET(bp->nb_lflags, NBL_BUSY);
730 SET(bp->nb_flags, NB_CACHE);
731 nfs_buf_remfree(bp);
733 if (ISSET(bp->nb_flags, NB_PAGELIST))
758 bp = TAILQ_FIRST(&nfsbuffreemeta);
770 bp = lrubp;
772 if (!bp && metabp && (!NBUFSTAMPVALID(metabp) ||
774 bp = metabp;
776 if (!bp && (nfsbufcnt >= nfsbufmax)) {
780 bp = lrubp;
782 bp = metabp;
788 bp = lrubp;
790 bp = metabp;
795 if (bp) {
797 FSDBG(544, np, blkno, bp, bp->nb_flags);
798 nfs_buf_remfree(bp);
799 if (ISSET(bp->nb_flags, NB_DELWRI))
801 SET(bp->nb_lflags, NBL_BUSY);
803 if (bp->nb_np) {
804 if (bp->nb_vnbufs.le_next != NFSNOLIST) {
805 LIST_REMOVE(bp, nb_vnbufs);
806 bp->nb_vnbufs.le_next = NFSNOLIST;
808 bp->nb_np = NULL;
810 LIST_REMOVE(bp, nb_hash);
812 if (IS_VALID_CRED(bp->nb_rcred))
813 kauth_cred_unref(&bp->nb_rcred);
814 if (IS_VALID_CRED(bp->nb_wcred))
815 kauth_cred_unref(&bp->nb_wcred);
818 if (!ISSET(bp->nb_flags, NB_META))
820 } else if (ISSET(bp->nb_flags, NB_META)) {
821 if (bp->nb_data) {
822 kfree(bp->nb_data, bp->nb_bufsize);
823 bp->nb_data = NULL;
828 bp->nb_error = 0;
829 bp->nb_validoff = bp->nb_validend = -1;
830 bp->nb_dirtyoff = bp->nb_dirtyend = 0;
831 bp->nb_valid = 0;
832 bp->nb_dirty = 0;
833 bp->nb_verf = 0;
839 MALLOC(bp, struct nfsbuf *, sizeof(struct nfsbuf), M_TEMP, M_WAITOK);
840 if (!bp) {
861 bzero(bp, sizeof(*bp));
862 bp->nb_free.tqe_next = NFSNOLIST;
863 bp->nb_validoff = bp->nb_validend = -1;
864 FSDBG(545, np, blkno, bp, 0);
884 SET(bp->nb_lflags, NBL_BUSY);
885 bp->nb_flags = 0;
886 bp->nb_lblkno = blkno;
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);
900 SET(bp->nb_flags, NB_META);
901 if ((bp->nb_bufsize != bufsize) && bp->nb_data) {
902 kfree(bp->nb_data, bp->nb_bufsize);
903 bp->nb_data = NULL;
904 bp->nb_validoff = bp->nb_validend = -1;
905 bp->nb_dirtyoff = bp->nb_dirtyend = 0;
906 bp->nb_valid = 0;
907 bp->nb_dirty = 0;
908 CLR(bp->nb_flags, NB_CACHE);
910 if (!bp->nb_data)
911 bp->nb_data = kalloc(bufsize);
912 if (!bp->nb_data) {
916 LIST_REMOVE(bp, nb_vnbufs);
917 bp->nb_vnbufs.le_next = NFSNOLIST;
918 bp->nb_np = NULL;
920 NBUFSTAMPINVALIDATE(bp);
921 if (bp->nb_free.tqe_next != NFSNOLIST)
923 TAILQ_INSERT_HEAD(&nfsbuffree, bp, nb_free);
929 bp->nb_bufsize = bufsize;
939 SET(bp->nb_flags, NB_READ);
941 CLR(bp->nb_flags, NB_READ);
945 bp->nb_bufsize = bufsize;
946 bp->nb_validoff = bp->nb_validend = -1;
950 if (nfs_buf_upl_setup(bp)) {
955 LIST_REMOVE(bp, nb_vnbufs);
956 bp->nb_vnbufs.le_next = NFSNOLIST;
957 bp->nb_np = NULL;
959 NBUFSTAMPINVALIDATE(bp);
960 if (bp->nb_free.tqe_next != NFSNOLIST)
962 TAILQ_INSERT_HEAD(&nfsbuffree, bp, nb_free);
968 nfs_buf_upl_check(bp);
976 *bpp = bp;
978 FSDBG_BOT(541, np, blkno, bp, bp->nb_flags);
984 nfs_buf_release(struct nfsbuf *bp, int freeup)
986 nfsnode_t np = bp->nb_np;
991 FSDBG_TOP(548, bp, NBOFF(bp), bp->nb_flags, bp->nb_data);
992 FSDBG(548, bp->nb_validoff, bp->nb_validend, bp->nb_dirtyoff, bp->nb_dirtyend);
993 FSDBG(548, bp->nb_valid, 0, bp->nb_dirty, 0);
996 if (vp && UBCINFOEXISTS(vp) && bp->nb_bufsize) {
1001 if (!ISSET(bp->nb_flags, NB_PAGELIST) && !ISSET(bp->nb_flags, NB_INVAL)) {
1002 rv = nfs_buf_upl_setup(bp);
1006 nfs_buf_upl_check(bp);
1008 upl = bp->nb_pagelist;
1011 if (bp->nb_data) {
1014 bp->nb_data = NULL;
1020 if (ISSET(bp->nb_flags, NB_ERROR) || (!bp->nb_dirty && (ISSET(bp->nb_flags, NB_INVAL) ||
1021 (ISSET(bp->nb_flags, NB_NOCACHE) && !ISSET(bp->nb_flags, (NB_NEEDCOMMIT | NB_DELWRI)))))) {
1022 if (ISSET(bp->nb_flags, (NB_READ | NB_INVAL | NB_NOCACHE)))
1029 for (i=0; i <= (bp->nb_bufsize - 1)/PAGE_SIZE; i++) {
1030 if (!NBPGVALID(bp,i))
1036 if (NBPGDIRTY(bp,i))
1041 if (!ISSET(bp->nb_flags, (NB_NEEDCOMMIT | NB_DELWRI)))
1053 if (NBOFF(bp) + bp->nb_bufsize > (off_t)(np->n_size)) {
1056 end = trunc_page_64(NBOFF(bp) + bp->nb_bufsize);
1057 if (start < NBOFF(bp))
1058 start = NBOFF(bp);
1064 CLR(bp->nb_flags, NB_PAGELIST);
1065 bp->nb_pagelist = NULL;
1078 if (ISSET(bp->nb_lflags, NBL_WANTED)) {
1079 CLR(bp->nb_lflags, NBL_WANTED);
1084 if (ISSET(bp->nb_flags, NB_ERROR) ||
1085 (ISSET(bp->nb_flags, NB_NOCACHE) && !ISSET(bp->nb_flags, (NB_NEEDCOMMIT | NB_DELWRI))))
1086 SET(bp->nb_flags, NB_INVAL);
1088 if ((bp->nb_bufsize <= 0) || ISSET(bp->nb_flags, NB_INVAL)) {
1090 if (bp->nb_vnbufs.le_next != NFSNOLIST) {
1091 LIST_REMOVE(bp, nb_vnbufs);
1092 bp->nb_vnbufs.le_next = NFSNOLIST;
1094 bp->nb_np = NULL;
1097 if (ISSET(bp->nb_flags, NB_DELWRI)) {
1098 CLR(bp->nb_flags, NB_DELWRI);
1104 NBUFSTAMPINVALIDATE(bp);
1106 if (bp->nb_free.tqe_next != NFSNOLIST)
1108 SET(bp->nb_flags, NB_INVAL);
1109 if (ISSET(bp->nb_flags, NB_META)) {
1110 TAILQ_INSERT_HEAD(&nfsbuffreemeta, bp, nb_free);
1113 TAILQ_INSERT_HEAD(&nfsbuffree, bp, nb_free);
1116 } else if (ISSET(bp->nb_flags, NB_DELWRI)) {
1118 if (bp->nb_free.tqe_next != NFSNOLIST)
1120 TAILQ_INSERT_TAIL(&nfsbufdelwri, bp, nb_free);
1126 bp->nb_timestamp = now.tv_sec;
1128 if (bp->nb_free.tqe_next != NFSNOLIST)
1130 if (ISSET(bp->nb_flags, NB_META)) {
1131 TAILQ_INSERT_TAIL(&nfsbuffreemeta, bp, nb_free);
1134 TAILQ_INSERT_TAIL(&nfsbuffree, bp, nb_free);
1142 CLR(bp->nb_flags, (NB_ASYNC | NB_STABLE));
1143 CLR(bp->nb_lflags, NBL_BUSY);
1145 FSDBG_BOT(548, bp, NBOFF(bp), bp->nb_flags, bp->nb_data);
1152 wakeup(bp);
1164 nfs_buf_iowait(struct nfsbuf *bp)
1166 FSDBG_TOP(549, bp, NBOFF(bp), bp->nb_flags, bp->nb_error);
1170 while (!ISSET(bp->nb_flags, NB_DONE))
1171 msleep(bp, nfs_buf_mutex, PRIBIO + 1, "nfs_buf_iowait", NULL);
1175 FSDBG_BOT(549, bp, NBOFF(bp), bp->nb_flags, bp->nb_error);
1178 if (ISSET(bp->nb_flags, NB_EINTR)) {
1179 CLR(bp->nb_flags, NB_EINTR);
1181 } else if (ISSET(bp->nb_flags, NB_ERROR))
1182 return (bp->nb_error ? bp->nb_error : EIO);
1190 nfs_buf_iodone(struct nfsbuf *bp)
1193 FSDBG_TOP(550, bp, NBOFF(bp), bp->nb_flags, bp->nb_error);
1195 if (ISSET(bp->nb_flags, NB_DONE))
1198 if (!ISSET(bp->nb_flags, NB_READ)) {
1199 CLR(bp->nb_flags, NB_WRITEINPROG);
1204 vnode_writedone(NFSTOV(bp->nb_np));
1205 nfs_node_lock_force(bp->nb_np);
1206 bp->nb_np->n_numoutput--;
1207 nfs_node_unlock(bp->nb_np);
1209 if (ISSET(bp->nb_flags, NB_ASYNC)) { /* if async, release it */
1210 SET(bp->nb_flags, NB_DONE); /* note that it's done */
1211 nfs_buf_release(bp, 1);
1214 SET(bp->nb_flags, NB_DONE); /* note that it's done */
1215 CLR(bp->nb_lflags, NBL_WANTED);
1217 wakeup(bp);
1220 FSDBG_BOT(550, bp, NBOFF(bp), bp->nb_flags, bp->nb_error);
1224 nfs_buf_write_delayed(struct nfsbuf *bp)
1226 nfsnode_t np = bp->nb_np;
1228 FSDBG_TOP(551, bp, NBOFF(bp), bp->nb_flags, 0);
1229 FSDBG(551, bp, bp->nb_dirtyoff, bp->nb_dirtyend, bp->nb_dirty);
1236 if (!ISSET(bp->nb_flags, NB_DELWRI)) {
1237 SET(bp->nb_flags, NB_DELWRI);
1242 if (bp->nb_vnbufs.le_next != NFSNOLIST)
1243 LIST_REMOVE(bp, nb_vnbufs);
1244 LIST_INSERT_HEAD(&np->n_dirtyblkhd, bp, nb_vnbufs);
1267 SET(bp->nb_flags, NB_ASYNC);
1268 nfs_buf_write(bp);
1269 FSDBG_BOT(551, bp, NBOFF(bp), bp->nb_flags, bp->nb_error);
1274 SET(bp->nb_flags, NB_DONE);
1275 nfs_buf_release(bp, 1);
1276 FSDBG_BOT(551, bp, NBOFF(bp), bp->nb_flags, 0);
1286 nfs_buf_check_write_verifier(nfsnode_t np, struct nfsbuf *bp)
1290 if (!ISSET(bp->nb_flags, NB_NEEDCOMMIT))
1296 if (!ISSET(bp->nb_flags, NB_STALEWVERF) && (bp->nb_verf == nmp->nm_verf))
1300 CLR(bp->nb_flags, (NB_NEEDCOMMIT | NB_STALEWVERF));
1301 bp->nb_verf = 0;
1313 nfs_buf_refget(struct nfsbuf *bp)
1315 bp->nb_refs++;
1322 nfs_buf_refrele(struct nfsbuf *bp)
1324 bp->nb_refs--;
1332 nfs_buf_acquire(struct nfsbuf *bp, int flags, int slpflag, int slptimeo)
1337 if (ISSET(bp->nb_lflags, NBL_BUSY)) {
1345 SET(bp->nb_lflags, NBL_WANTED);
1351 error = msleep(bp, nfs_buf_mutex, slpflag | (PRIBIO + 1),
1358 nfs_buf_remfree(bp);
1359 SET(bp->nb_lflags, NBL_BUSY);
1369 nfs_buf_drop(struct nfsbuf *bp)
1373 if (!ISSET(bp->nb_lflags, NBL_BUSY))
1375 if (ISSET(bp->nb_lflags, NBL_WANTED)) {
1380 CLR(bp->nb_lflags, (NBL_BUSY | NBL_WANTED));
1383 wakeup(bp);
1432 struct nfsbuf *bp;
1440 bp = LIST_FIRST(iterheadp);
1441 LIST_REMOVE(bp, nb_vnbufs);
1442 LIST_INSERT_HEAD(listheadp, bp, nb_vnbufs);
1457 nfs_buf_read(struct nfsbuf *bp)
1464 np = bp->nb_np;
1465 cred = bp->nb_rcred;
1468 thd = ISSET(bp->nb_flags, NB_ASYNC) ? NULL : current_thread();
1471 if (!ISSET(bp->nb_flags, NB_READ))
1473 if (ISSET(bp->nb_flags, NB_DONE))
1474 CLR(bp->nb_flags, NB_DONE);
1476 NFS_BUF_MAP(bp);
1480 error = nfs_buf_read_rpc(bp, thd, cred);
1495 nfs_buf_read_finish(struct nfsbuf *bp)
1497 nfsnode_t np = bp->nb_np;
1500 if (!ISSET(bp->nb_flags, NB_ERROR)) {
1502 bp->nb_validoff = 0;
1503 bp->nb_validend = bp->nb_endio;
1504 if (bp->nb_endio < (int)bp->nb_bufsize) {
1513 off_t boff = NBOFF(bp);
1514 if ((off_t)np->n_size >= (boff + bp->nb_bufsize))
1515 bp->nb_validend = bp->nb_bufsize;
1517 bp->nb_validend = np->n_size - boff;
1519 bp->nb_validend = 0;
1522 ((NBOFF(bp) + bp->nb_validend) > 0x100000000LL))
1523 bp->nb_validend = 0x100000000LL - NBOFF(bp);
1524 bp->nb_valid = (1 << (round_page_32(bp->nb_validend) / PAGE_SIZE)) - 1;
1525 if (bp->nb_validend & PAGE_MASK) {
1527 bzero(bp->nb_data + bp->nb_validend, PAGE_SIZE - (bp->nb_validend & PAGE_MASK));
1530 nfs_buf_iodone(bp);
1537 nfs_buf_read_rpc(struct nfsbuf *bp, thread_t thd, kauth_cred_t cred)
1540 nfsnode_t np = bp->nb_np;
1550 bp->nb_error = error = ENXIO;
1551 SET(bp->nb_flags, NB_ERROR);
1552 nfs_buf_iodone(bp);
1558 boff = NBOFF(bp);
1560 length = bp->nb_bufsize;
1564 bp->nb_error = error = EFBIG;
1565 SET(bp->nb_flags, NB_ERROR);
1566 nfs_buf_iodone(bp);
1574 async = (bp->nb_flags & NB_ASYNC);
1576 cb.rcb_bp = bp;
1578 bp->nb_offio = bp->nb_endio = 0;
1579 bp->nb_rpcs = nrpcs = (length + nmrsize - 1) / nmrsize;
1581 SET(bp->nb_flags, NB_MULTASYNCRPC);
1583 CLR(bp->nb_flags, NB_MULTASYNCRPC);
1587 if (ISSET(bp->nb_flags, NB_ERROR)) {
1588 error = bp->nb_error;
1605 if (ISSET(bp->nb_flags, NB_ERROR)) {
1606 error = bp->nb_error;
1616 bp->nb_error = error;
1617 SET(bp->nb_flags, NB_ERROR);
1618 if (ISSET(bp->nb_flags, NB_MULTASYNCRPC)) {
1621 bp->nb_rpcs -= nrpcs;
1622 if (bp->nb_rpcs == 0) {
1625 nfs_buf_iodone(bp);
1628 while (bp->nb_rpcs > 0)
1629 msleep(&bp->nb_rpcs, nfs_buf_mutex, 0,
1634 nfs_buf_iodone(bp);
1650 struct nfsbuf *bp;
1667 bp = cb.rcb_bp;
1673 SET(bp->nb_flags, NB_ERROR);
1674 bp->nb_error = error = ENXIO;
1676 if (error || ISSET(bp->nb_flags, NB_ERROR)) {
1686 auio = uio_createwithbuffer(1, NBOFF(bp) + offset, UIO_SYSSPACE,
1688 uio_addiov(auio, CAST_USER_ADDR_T(bp->nb_data + offset), length);
1700 if ((nmp->nm_vers >= NFS_VER4) && nfs_mount_state_error_should_restart(error) && !ISSET(bp->nb_flags, NB_ERROR)) {
1704 error, NBOFF(bp)+offset, cb.rcb_args[2], nmp->nm_stategenid);
1746 SET(bp->nb_flags, NB_ERROR);
1747 bp->nb_error = error;
1751 if ((rlen > 0) && (bp->nb_endio < (offset + (int)rlen)))
1752 bp->nb_endio = offset + rlen;
1758 eofrem = np->n_size - (NBOFF(bp) + offset + rlen);
1761 bzero(bp->nb_data + offset + rlen, rem);
1762 } else if (((int)rlen < length) && !ISSET(bp->nb_flags, NB_ERROR)) {
1777 error = nmp->nm_funcs->nf_read_rpc_async(np, NBOFF(bp) + offset, length, thd, cred, &cb, &rreq);
1795 SET(bp->nb_flags, NB_ERROR);
1796 bp->nb_error = error;
1814 multasyncrpc = ISSET(bp->nb_flags, NB_MULTASYNCRPC);
1818 bp->nb_rpcs--;
1819 finished = (bp->nb_rpcs == 0);
1826 wakeme = &bp->nb_rpcs;
1827 nfs_buf_read_finish(bp);
1841 struct nfsbuf *bp;
1859 error = nfs_buf_get(np, *rabnp, nmp->nm_biosize, thd, NBLK_READ|NBLK_NOWAIT, &bp);
1865 if (!bp)
1867 if ((ioflag & IO_NOCACHE) && ISSET(bp->nb_flags, NB_CACHE) &&
1868 !bp->nb_dirty && !ISSET(bp->nb_flags, (NB_DELWRI|NB_NCRDAHEAD))) {
1869 CLR(bp->nb_flags, NB_CACHE);
1870 bp->nb_valid = 0;
1871 bp->nb_validoff = bp->nb_validend = -1;
1873 if ((bp->nb_dirtyend <= 0) && !bp->nb_dirty &&
1874 !ISSET(bp->nb_flags, (NB_CACHE|NB_DELWRI))) {
1875 SET(bp->nb_flags, (NB_READ|NB_ASYNC));
1877 SET(bp->nb_flags, NB_NCRDAHEAD);
1878 if (!IS_VALID_CRED(bp->nb_rcred) && IS_VALID_CRED(cred)) {
1880 bp->nb_rcred = cred;
1882 if ((error = nfs_buf_read(bp)))
1886 nfs_buf_release(bp, 1);
1898 struct nfsbuf *bp = NULL;
2077 error = nfs_buf_get(np, lbn, biosize, thd, NBLK_READ, &bp);
2084 if ((ioflag & IO_NOCACHE) && ISSET(bp->nb_flags, NB_CACHE)) {
2091 if (bp->nb_dirty || (bp->nb_dirtyend > 0)) {
2093 SET(bp->nb_flags, NB_NOCACHE);
2096 if (ISSET(bp->nb_flags, NB_NCRDAHEAD)) {
2097 CLR(bp->nb_flags, NB_NCRDAHEAD);
2098 SET(bp->nb_flags, NB_NOCACHE);
2103 if (bp->nb_valid) {
2109 if (!NBPGVALID(bp,pg)) {
2113 } else if (firstpg >= 0 && dirtypg < 0 && NBPGDIRTY(bp,pg))
2120 if (bp->nb_validoff < 0) {
2123 bp->nb_validoff = trunc_page(on);
2124 bp->nb_validend = round_page(on+n);
2125 nfs_buf_normalize_valid_range(np, bp);
2132 (((firstpg*PAGE_SIZE) < bp->nb_dirtyend) && (((lastpg+1)*PAGE_SIZE) > bp->nb_dirtyoff))) {
2136 CLR(bp->nb_flags, (NB_DONE | NB_ERROR | NB_INVAL));
2137 SET(bp->nb_flags, NB_ASYNC);
2138 if (!IS_VALID_CRED(bp->nb_wcred)) {
2140 bp->nb_wcred = cred;
2142 error = nfs_buf_write(bp);
2150 if (!bp->nb_dirty && bp->nb_dirtyend <= 0 &&
2154 bp->nb_valid = 0;
2160 NFS_BUF_MAP(bp);
2161 auio = uio_createwithbuffer(1, (NBOFF(bp) + firstpg * PAGE_SIZE_64),
2166 uio_addiov(auio, CAST_USER_ADDR_T(bp->nb_data + (firstpg * PAGE_SIZE)),
2172 SET(bp->nb_flags, NB_NOCACHE);
2173 nfs_buf_release(bp, 1);
2179 bp->nb_validoff = trunc_page_32(on);
2180 bp->nb_validend = round_page_32(on+n);
2181 nfs_buf_normalize_valid_range(np, bp);
2189 NBPGVALID_SET(bp,pg);
2193 if (!bp->nb_valid) {
2194 if (!IS_VALID_CRED(bp->nb_rcred) && IS_VALID_CRED(cred)) {
2196 bp->nb_rcred = cred;
2198 SET(bp->nb_flags, NB_READ);
2199 CLR(bp->nb_flags, (NB_DONE | NB_ERROR | NB_INVAL));
2200 error = nfs_buf_read(bp);
2202 SET(bp->nb_flags, NB_NOCACHE);
2205 nfs_buf_release(bp, 1);
2212 if (bp->nb_validend > 0) {
2213 diff = (on >= bp->nb_validend) ? 0 : (bp->nb_validend - on);
2218 NFS_BUF_MAP(bp);
2219 error = uiomove(bp->nb_data + on, n, uio);
2222 nfs_buf_release(bp, 1);
2278 nfs_buf_write(struct nfsbuf *bp)
2288 FSDBG_TOP(553, bp, NBOFF(bp), bp->nb_flags, 0);
2290 if (!ISSET(bp->nb_lflags, NBL_BUSY))
2293 np = bp->nb_np;
2294 async = ISSET(bp->nb_flags, NB_ASYNC);
2295 oldflags = bp->nb_flags;
2297 CLR(bp->nb_flags, (NB_READ|NB_DONE|NB_ERROR|NB_DELWRI));
2309 if (bp->nb_vnbufs.le_next != NFSNOLIST)
2310 LIST_REMOVE(bp, nb_vnbufs);
2311 LIST_INSERT_HEAD(&np->n_cleanblkhd, bp, nb_vnbufs);
2322 cred = bp->nb_wcred;
2323 if (!IS_VALID_CRED(cred) && ISSET(bp->nb_flags, NB_READ))
2324 cred = bp->nb_rcred; /* shouldn't really happen, but... */
2330 if (!ISSET(bp->nb_flags, NB_META) && UBCINFOEXISTS(NFSTOV(np))) {
2331 if (!ISSET(bp->nb_flags, NB_PAGELIST)) {
2332 error = nfs_buf_upl_setup(bp);
2335 SET(bp->nb_flags, NB_ERROR);
2336 bp->nb_error = error = EIO;
2337 nfs_buf_iodone(bp);
2340 nfs_buf_upl_check(bp);
2345 if (ISSET(bp->nb_flags, NB_NEEDCOMMIT))
2346 nfs_buf_check_write_verifier(np, bp);
2347 if (ISSET(bp->nb_flags, NB_NEEDCOMMIT)) {
2350 SET(bp->nb_flags, NB_ERROR);
2351 bp->nb_error = error = EIO;
2352 nfs_buf_iodone(bp);
2355 SET(bp->nb_flags, NB_WRITEINPROG);
2356 error = nmp->nm_funcs->nf_commit_rpc(np, NBOFF(bp) + bp->nb_dirtyoff,
2357 bp->nb_dirtyend - bp->nb_dirtyoff, bp->nb_wcred, bp->nb_verf);
2358 CLR(bp->nb_flags, NB_WRITEINPROG);
2361 SET(bp->nb_flags, NB_ERROR);
2362 bp->nb_error = error;
2364 nfs_buf_iodone(bp);
2367 bp->nb_dirtyoff = bp->nb_dirtyend = 0;
2368 CLR(bp->nb_flags, NB_NEEDCOMMIT);
2374 if (!error && (bp->nb_dirtyend > 0)) {
2376 if (NBOFF(bp) + bp->nb_dirtyend > (off_t) np->n_size) {
2377 bp->nb_dirtyend = np->n_size - NBOFF(bp);
2378 if (bp->nb_dirtyoff >= bp->nb_dirtyend)
2379 bp->nb_dirtyoff = bp->nb_dirtyend = 0;
2382 if (!error && (bp->nb_dirtyend > 0)) {
2384 NFS_BUF_MAP(bp);
2386 doff = bp->nb_dirtyoff;
2387 dend = bp->nb_dirtyend;
2390 if (NBPGDIRTY(bp, doff / PAGE_SIZE))
2394 while ((doff > 0) && NBPGDIRTY(bp, (doff - 1) / PAGE_SIZE))
2397 if ((dend & PAGE_MASK) && NBPGDIRTY(bp, dend / PAGE_SIZE))
2401 while ((dend < (int)bp->nb_bufsize) && NBPGDIRTY(bp, dend / PAGE_SIZE))
2404 if ((NBOFF(bp) + dend) > (off_t) np->n_size)
2405 dend = np->n_size - NBOFF(bp);
2417 if (bp->nb_dirty & ~pagemask)
2419 else if ((bp->nb_flags & (NB_ASYNC | NB_NEEDCOMMIT | NB_STABLE)) == NB_ASYNC)
2425 bp->nb_offio = doff;
2426 bp->nb_endio = dend;
2430 SET(bp->nb_flags, NB_WRITEINPROG);
2431 error = nfs_buf_write_rpc(bp, iomode, thd, cred);
2439 if (!error && bp->nb_dirty) /* write out any dirty pages */
2440 error = nfs_buf_write_dirty_pages(bp, thd, cred);
2441 nfs_buf_iodone(bp);
2443 /* note: bp is still valid only for !async case */
2446 error = nfs_buf_iowait(bp);
2450 if (bp->nb_vnbufs.le_next != NFSNOLIST)
2451 LIST_REMOVE(bp, nb_vnbufs);
2452 LIST_INSERT_HEAD(&np->n_cleanblkhd, bp, nb_vnbufs);
2455 FSDBG_BOT(553, bp, NBOFF(bp), bp->nb_flags, error);
2456 nfs_buf_release(bp, 1);
2493 nfs_buf_write_finish(struct nfsbuf *bp, thread_t thd, kauth_cred_t cred)
2495 nfsnode_t np = bp->nb_np;
2496 int error = (bp->nb_flags & NB_ERROR) ? bp->nb_error : 0;
2501 CLR(bp->nb_flags, NB_ERROR);
2502 SET(bp->nb_flags, NB_EINTR);
2507 firstpg = round_page_32(bp->nb_offio) / PAGE_SIZE;
2508 lastpg = (trunc_page_32(bp->nb_endio) - 1) / PAGE_SIZE;
2512 bp->nb_dirty &= ~pagemask;
2516 if (!error && (bp->nb_commitlevel == NFS_WRITE_UNSTABLE)) {
2517 if (!ISSET(bp->nb_flags, NB_NEEDCOMMIT)) {
2521 SET(bp->nb_flags, NB_NEEDCOMMIT);
2524 bp->nb_dirtyoff = bp->nb_offio;
2525 bp->nb_dirtyend = bp->nb_endio;
2526 } else if (ISSET(bp->nb_flags, NB_NEEDCOMMIT)) {
2531 CLR(bp->nb_flags, NB_NEEDCOMMIT);
2534 CLR(bp->nb_flags, NB_WRITEINPROG);
2545 if ((error == EINTR) || (error == ERESTART) || (!error && (bp->nb_flags & NB_NEEDCOMMIT))) {
2546 CLR(bp->nb_flags, NB_INVAL);
2547 if (!ISSET(bp->nb_flags, NB_DELWRI)) {
2548 SET(bp->nb_flags, NB_DELWRI);
2558 if (ISSET(bp->nb_flags, NB_ASYNC)) {
2561 if (bp->nb_vnbufs.le_next != NFSNOLIST)
2562 LIST_REMOVE(bp, nb_vnbufs);
2563 LIST_INSERT_HEAD(&np->n_dirtyblkhd, bp, nb_vnbufs);
2586 bp->nb_dirtyoff = bp->nb_dirtyend = 0;
2589 if (!error && bp->nb_dirty)
2590 nfs_buf_write_dirty_pages(bp, thd, cred);
2591 nfs_buf_iodone(bp);
2602 nfs_buf_write_dirty_pages(struct nfsbuf *bp, thread_t thd, kauth_cred_t cred)
2604 nfsnode_t np = bp->nb_np;
2607 uint32_t dirty = bp->nb_dirty;
2612 if (!bp->nb_dirty)
2617 NFS_BUF_MAP(bp);
2618 SET(bp->nb_flags, NB_WRITEINPROG);
2619 npages = bp->nb_bufsize / PAGE_SIZE;
2626 dirty = bp->nb_dirty;
2627 wverf = bp->nb_verf;
2630 if (!NBPGDIRTY(bp, pg))
2633 while (((pg + count) < npages) && NBPGDIRTY(bp, pg + count))
2639 if (NBOFF(bp) + off + len > (off_t) np->n_size)
2640 len -= (NBOFF(bp) + off + len) - np->n_size;
2643 uio_reset(auio, NBOFF(bp) + off, UIO_SYSSPACE, UIO_WRITE);
2644 uio_addiov(auio, CAST_USER_ADDR_T(bp->nb_data + off), len);
2645 error = nfs_write_rpc2(np, auio, thd, cred, &iomode2, &bp->nb_verf);
2650 if ((commit != NFS_WRITE_FILESYNC) && (wverf != bp->nb_verf)) {
2663 CLR(bp->nb_flags, NB_WRITEINPROG);
2666 error = nmp->nm_funcs->nf_commit_rpc(np, NBOFF(bp), bp->nb_bufsize, cred, wverf);
2674 bp->nb_dirty = dirty;
2676 SET(bp->nb_flags, NB_ERROR);
2677 bp->nb_error = error;
2686 nfs_buf_write_rpc(struct nfsbuf *bp, int iomode, thread_t thd, kauth_cred_t cred)
2689 nfsnode_t np = bp->nb_np;
2700 bp->nb_error = error = ENXIO;
2701 SET(bp->nb_flags, NB_ERROR);
2702 nfs_buf_iodone(bp);
2708 offset = bp->nb_offio;
2709 length = bp->nb_endio - bp->nb_offio;
2712 async = (bp->nb_flags & NB_ASYNC) && (NFSIOD_MAX > 0);
2713 bp->nb_commitlevel = NFS_WRITE_FILESYNC;
2715 cb.rcb_bp = bp;
2717 if ((nfsvers == NFS_VER2) && ((NBOFF(bp) + bp->nb_endio) > 0xffffffffLL)) {
2718 bp->nb_error = error = EFBIG;
2719 SET(bp->nb_flags, NB_ERROR);
2720 nfs_buf_iodone(bp);
2724 auio = uio_createwithbuffer(1, NBOFF(bp) + offset, UIO_SYSSPACE,
2726 uio_addiov(auio, CAST_USER_ADDR_T(bp->nb_data + offset), length);
2728 bp->nb_rpcs = nrpcs = (length + nmwsize - 1) / nmwsize;
2730 SET(bp->nb_flags, NB_MULTASYNCRPC);
2732 CLR(bp->nb_flags, NB_MULTASYNCRPC);
2736 if (ISSET(bp->nb_flags, NB_ERROR)) {
2737 error = bp->nb_error;
2767 bp->nb_error = error;
2768 SET(bp->nb_flags, NB_ERROR);
2769 if (ISSET(bp->nb_flags, NB_MULTASYNCRPC)) {
2772 bp->nb_rpcs -= nrpcs;
2773 if (bp->nb_rpcs == 0) {
2776 nfs_buf_write_finish(bp, thd, cred);
2779 while (bp->nb_rpcs > 0)
2780 msleep(&bp->nb_rpcs, nfs_buf_mutex, 0,
2785 nfs_buf_write_finish(bp, thd, cred);
2788 if (!ISSET(bp->nb_flags, NB_ERROR))
2808 struct nfsbuf *bp;
2823 bp = cb.rcb_bp;
2829 SET(bp->nb_flags, NB_ERROR);
2830 bp->nb_error = error = ENXIO;
2832 if (error || ISSET(bp->nb_flags, NB_ERROR)) {
2852 if ((nmp->nm_vers >= NFS_VER4) && nfs_mount_state_error_should_restart(error) && !ISSET(bp->nb_flags, NB_ERROR)) {
2856 error, NBOFF(bp)+offset, cb.rcb_args[2], nmp->nm_stategenid);
2898 SET(bp->nb_flags, NB_ERROR);
2899 bp->nb_error = error;
2904 SET(bp->nb_flags, NB_ERROR);
2905 bp->nb_error = error = EIO;
2910 if (committed < bp->nb_commitlevel)
2911 bp->nb_commitlevel = committed;
2914 if (!bp->nb_verf) {
2915 bp->nb_verf = wverf;
2916 } else if (bp->nb_verf != wverf) {
2918 bp->nb_flags |= NB_STALEWVERF;
2919 bp->nb_commitlevel = NFS_WRITE_UNSTABLE;
2920 bp->nb_verf = wverf;
2930 if (((int)rlen < length) && !(bp->nb_flags & (NB_STALEWVERF|NB_ERROR))) {
2935 auio = uio_createwithbuffer(1, NBOFF(bp) + offset, UIO_SYSSPACE,
2937 uio_addiov(auio, CAST_USER_ADDR_T(bp->nb_data + offset), length);
2964 SET(bp->nb_flags, NB_ERROR);
2965 bp->nb_error = error;
2981 multasyncrpc = ISSET(bp->nb_flags, NB_MULTASYNCRPC);
2985 bp->nb_rpcs--;
2986 finished = (bp->nb_rpcs == 0);
2993 wakeme = &bp->nb_rpcs;
2994 nfs_buf_write_finish(bp, thd, cred);
3010 struct nfsbuf *bp, *prevlbp, *lbp;
3055 while ((bp = LIST_FIRST(&blist))) {
3056 LIST_REMOVE(bp, nb_vnbufs);
3057 LIST_INSERT_HEAD(&np->n_dirtyblkhd, bp, nb_vnbufs);
3058 error = nfs_buf_acquire(bp, NBAC_NOWAIT, 0, 0);
3061 if (ISSET(bp->nb_flags, NB_NEEDCOMMIT))
3062 nfs_buf_check_write_verifier(np, bp);
3063 if (((bp->nb_flags & (NB_DELWRI | NB_NEEDCOMMIT)) != (NB_DELWRI | NB_NEEDCOMMIT)) ||
3064 (bp->nb_verf != wverf)) {
3065 nfs_buf_drop(bp);
3068 nfs_buf_remfree(bp);
3072 FSDBG(557, bp, bp->nb_flags, bp->nb_valid, bp->nb_dirty);
3073 FSDBG(557, bp->nb_validoff, bp->nb_validend,
3074 bp->nb_dirtyoff, bp->nb_dirtyend);
3080 * Note: creds in bp's must be obtained by kauth_cred_ref
3084 wcred = bp->nb_wcred;
3088 } else if ((wcred_set == 1) && wcred != bp->nb_wcred) {
3091 SET(bp->nb_flags, NB_WRITEINPROG);
3100 if (bp->nb_lblkno < lbp->nb_lblkno)
3104 LIST_REMOVE(bp, nb_vnbufs);
3106 LIST_INSERT_AFTER(prevlbp, bp, nb_vnbufs);
3108 LIST_INSERT_HEAD(&commitlist, bp, nb_vnbufs);
3111 toff = NBOFF(bp) + bp->nb_dirtyoff;
3114 toff += (u_quad_t)(bp->nb_dirtyend - bp->nb_dirtyoff);
3137 LIST_FOREACH(bp, &commitlist, nb_vnbufs) {
3138 if (!ISSET(bp->nb_flags, NB_PAGELIST)) {
3139 retv = nfs_buf_upl_setup(bp);
3143 bp->nb_valid = bp->nb_dirty = 0;
3146 nfs_buf_upl_check(bp);
3167 LIST_FOREACH(bp, &commitlist, nb_vnbufs) {
3168 toff = NBOFF(bp) + bp->nb_dirtyoff;
3169 count = bp->nb_dirtyend - bp->nb_dirtyoff;
3170 retv = nmp->nm_funcs->nf_commit_rpc(np, toff, count, bp->nb_wcred, wverf);
3181 while ((bp = LIST_FIRST(&commitlist))) {
3182 LIST_REMOVE(bp, nb_vnbufs);
3183 FSDBG(557, bp, retv, bp->nb_flags, bp->nb_dirty);
3185 CLR(bp->nb_flags, (NB_NEEDCOMMIT | NB_WRITEINPROG));
3193 LIST_INSERT_HEAD(&np->n_dirtyblkhd, bp, nb_vnbufs);
3195 nfs_buf_release(bp, 1);
3203 if (ISSET(bp->nb_flags, NB_DELWRI)) {
3210 CLR(bp->nb_flags, (NB_READ|NB_DONE|NB_ERROR|NB_DELWRI));
3213 if (!(dirty = bp->nb_dirty))
3214 SET(bp->nb_flags, NB_ASYNC);
3216 CLR(bp->nb_flags, NB_ASYNC);
3220 LIST_INSERT_HEAD(&np->n_cleanblkhd, bp, nb_vnbufs);
3223 bp->nb_dirtyoff = bp->nb_dirtyend = 0;
3225 nfs_buf_iodone(bp);
3228 CLR(bp->nb_flags, NB_DONE);
3229 nfs_buf_write_delayed(bp);
3246 struct nfsbuf *bp;
3297 while ((bp = LIST_FIRST(&blist))) {
3298 LIST_REMOVE(bp, nb_vnbufs);
3299 LIST_INSERT_HEAD(&np->n_dirtyblkhd, bp, nb_vnbufs);
3302 nfs_buf_refget(bp);
3303 while ((error = nfs_buf_acquire(bp, flags, slpflag, slptimeo))) {
3304 FSDBG(524, bp, flags, bp->nb_lflags, bp->nb_flags);
3311 nfs_buf_refrele(bp);
3324 nfs_buf_refrele(bp);
3327 if (!bp->nb_np) {
3329 nfs_buf_drop(bp);
3332 if (ISSET(bp->nb_flags, NB_NEEDCOMMIT))
3333 nfs_buf_check_write_verifier(np, bp);
3334 if (!ISSET(bp->nb_flags, NB_DELWRI)) {
3336 nfs_buf_drop(bp);
3339 FSDBG(525, bp, passone, bp->nb_lflags, bp->nb_flags);
3341 ISSET(bp->nb_flags, NB_NEEDCOMMIT)) {
3342 nfs_buf_drop(bp);
3345 nfs_buf_remfree(bp);
3347 if (ISSET(bp->nb_flags, NB_ERROR)) {
3349 np->n_error = bp->nb_error ? bp->nb_error : EIO;
3352 nfs_buf_release(bp, 1);
3356 SET(bp->nb_flags, NB_ASYNC);
3359 SET(bp->nb_flags, NB_STABLE);
3361 nfs_buf_write(bp);
3465 struct nfsbuf *bp;
3482 while ((bp = LIST_FIRST(&blist))) {
3483 LIST_REMOVE(bp, nb_vnbufs);
3485 LIST_INSERT_HEAD(&np->n_cleanblkhd, bp, nb_vnbufs);
3487 LIST_INSERT_HEAD(&np->n_dirtyblkhd, bp, nb_vnbufs);
3488 nfs_buf_refget(bp);
3489 while ((error = nfs_buf_acquire(bp, NBAC_REMOVE, slpflag, slptimeo))) {
3490 FSDBG(556, np, bp, NBOFF(bp), bp->nb_flags);
3492 FSDBG(554, np, bp, -1, error);
3493 nfs_buf_refrele(bp);
3499 nfs_buf_refrele(bp);
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;
3509 if (!ISSET(bp->nb_flags, NB_PAGELIST)) {
3510 error = nfs_buf_upl_setup(bp);
3517 bp->nb_valid = bp->nb_dirty = 0;
3519 nfs_buf_upl_check(bp);
3521 if ((bp->nb_dirtyend > 0) && (bp->nb_dirtyoff < end)) {
3523 if (bp->nb_dirtyend > end) {
3524 bp->nb_dirtyend = end;
3525 if (bp->nb_dirtyoff >= bp->nb_dirtyend)
3526 bp->nb_dirtyoff = bp->nb_dirtyend = 0;
3528 if ((bp->nb_dirtyend > 0) && (bp->nb_dirtyoff < end))
3531 bp->nb_dirty &= (1 << (round_page_32(end)/PAGE_SIZE)) - 1;
3532 if (bp->nb_dirty)
3535 if (mustwrite && !IS_VALID_CRED(bp->nb_wcred) && !IS_VALID_CRED(cred)) {
3540 FSDBG(554, np, bp, 0xd00dee, bp->nb_flags);
3541 if (!ISSET(bp->nb_flags, NB_PAGELIST))
3546 CLR(bp->nb_flags, (NB_DONE | NB_ERROR | NB_INVAL | NB_ASYNC));
3547 SET(bp->nb_flags, NB_STABLE | NB_NOCACHE);
3548 if (!IS_VALID_CRED(bp->nb_wcred)) {
3550 bp->nb_wcred = cred;
3552 error = nfs_buf_write(bp);
3553 // Note: bp has been released
3555 FSDBG(554, bp, 0xd00dee, 0xbad, error);
3586 SET(bp->nb_flags, NB_INVAL);
3588 nfs_buf_release(bp, 0);
3692 struct nfsbuf *bp;
3698 while ((bp = LIST_FIRST(&blist))) {
3699 LIST_REMOVE(bp, nb_vnbufs);
3700 LIST_INSERT_HEAD(&np->n_cleanblkhd, bp, nb_vnbufs);
3701 nfs_buf_refget(bp);
3702 while ((error = nfs_buf_acquire(bp, 0, 0, 0))) {
3704 nfs_buf_refrele(bp);
3710 nfs_buf_refrele(bp);
3711 nfs_buf_drop(bp);
3716 while ((bp = LIST_FIRST(&blist))) {
3717 LIST_REMOVE(bp, nb_vnbufs);
3718 LIST_INSERT_HEAD(&np->n_dirtyblkhd, bp, nb_vnbufs);
3719 nfs_buf_refget(bp);
3720 while ((error = nfs_buf_acquire(bp, 0, 0, 0))) {
3722 nfs_buf_refrele(bp);
3728 nfs_buf_refrele(bp);
3729 nfs_buf_drop(bp);
3830 nfs_buf_readdir(struct nfsbuf *bp, vfs_context_t ctx)
3832 nfsnode_t np = bp->nb_np;
3840 error = nfs3_readdir_rpc(np, bp, ctx);
3842 error = nfs4_readdir_rpc(np, bp, ctx);
3845 SET(bp->nb_flags, NB_ERROR);
3846 bp->nb_error = error;