Lines Matching refs:fs
120 #define LFS_PARTIAL_FITS(fs) \
121 (lfs_sb_getfsbpseg(fs) - \
122 (lfs_sb_getoffset(fs) - lfs_sb_getcurseg(fs)) > \
123 lfs_sb_getfrag(fs))
129 #define LFS_SHOULD_CHECKPOINT(fs, flags) \
131 ((fs->lfs_nactive > LFS_MAX_ACTIVE || \
133 lfs_sb_getnclean(fs) < LFS_MAX_ACTIVE)))
139 int lfs_writevnodes(struct lfs *fs, struct mount *mp,
165 * read the fs mod time off of it. We don't set IN_UPDATE here,
170 lfs_imtime(struct lfs *fs)
175 ASSERT_MAYBE_SEGLOCK(fs);
177 ip = VTOI(fs->lfs_ivnode);
178 lfs_dino_setmtime(fs, ip->i_din, ts.tv_sec);
179 lfs_dino_setmtimensec(fs, ip->i_din, ts.tv_nsec);
189 #define IS_FLUSHING(fs,vp) ((fs)->lfs_flushvp == (vp))
195 struct lfs *fs;
203 fs = VFSTOULFS(vp->v_mount)->um_lfs;
207 ASSERT_NO_SEGLOCK(fs);
224 lfs_seglock(fs, SEGM_SYNC | ((error != 0) ? SEGM_RECLAIM : 0));
226 fs->lfs_reclino = ip->i_number;
249 lfs_sb_addavail(fs, lfs_btofsb(fs, bp->b_bcount));
250 wakeup(&fs->lfs_availsleep);
274 lfs_segunlock(fs);
281 fs->lfs_flushvp = vp;
282 if (LFS_SHOULD_CHECKPOINT(fs, fs->lfs_sp->seg_flags)) {
284 fs->lfs_flushvp = NULL;
285 KASSERT(fs->lfs_flushvp_fakevref == 0);
286 lfs_segunlock(fs);
299 sp = fs->lfs_sp;
303 lfs_writevnodes(fs, vp->v_mount, sp, VN_EMPTY);
324 relock = lfs_writefile(fs, sp, vp);
325 if (relock && vp != fs->lfs_ivnode) {
333 lfs_writeinode(fs, sp, ip);
337 lfs_writeseg(fs, sp);
338 lfs_segunlock(fs);
339 lfs_segunlock_relock(fs);
356 if (vp == fs->lfs_ivnode) {
357 lfs_writefile(fs, sp, vp);
358 lfs_writefile(fs, sp, vp);
364 } while (lfs_writeinode(fs, sp, ip));
365 } while (lfs_writeseg(fs, sp) && ip->i_number == LFS_IFILE_INUM);
385 if (fs->lfs_seglock > 1) {
386 while (fs->lfs_iocount > 1)
387 (void)mtsleep(&fs->lfs_iocount, PRIBIO + 1,
392 lfs_segunlock(fs);
403 fs->lfs_flushvp = NULL;
404 KASSERT(fs->lfs_flushvp_fakevref == 0);
411 struct lfs *fs;
435 vp != c->fs->lfs_flushvp && !(ip->i_state & IN_CLEANING)) {
440 if (vp == c->fs->lfs_unlockvp) {
450 lfs_writevnodes(struct lfs *fs, struct mount *mp, struct segment *sp, int op)
465 ASSERT_SEGLOCK(fs);
468 ctx.fs = fs;
478 error = lfs_writefile(fs, sp, vp);
489 lfs_writeinode(fs, sp, ip);
490 lfs_writeseg(fs, sp);
513 (void) lfs_writeinode(fs, sp, ip);
530 struct lfs *fs;
542 fs = VFSTOULFS(mp)->um_lfs;
543 DLOG((DLOG_SEG, "lfs_segwrite(fs=%p, flags=%x)\n", fs, flags));
544 ASSERT_MAYBE_SEGLOCK(fs);
546 if (fs->lfs_ronly)
549 lfs_imtime(fs);
556 do_ckp = LFS_SHOULD_CHECKPOINT(fs, flags);
563 lfs_writer_enter(fs, "ckpwriter");
571 lfs_seglock(fs, flags | (do_ckp ? SEGM_CKP : 0));
572 sp = fs->lfs_sp;
587 lfs_writevnodes(fs, mp, sp, VN_CLEAN);
590 um_error = lfs_writevnodes(fs, mp, sp, VN_REG);
592 lfs_sb_getcurseg(fs) != fs->lfs_startseg) {
593 DLOG((DLOG_SEG, "lfs_segwrite: breaking out of segment write at daddr 0x%jx\n", (uintmax_t)lfs_sb_getoffset(fs)));
598 (writer_set = lfs_writer_tryenter(fs)) != 0) {
600 KASSERT(fs->lfs_writer);
601 error = lfs_writevnodes(fs, mp, sp, VN_DIROP);
609 lfs_flush_dirops(fs);
611 lfs_ss_setflags(fs, ssp,
612 lfs_ss_getflags(fs, ssp) & ~(SS_CONT));
613 lfs_finalize_fs_seguse(fs);
616 lfs_segunlock_relock(fs);
617 sp = fs->lfs_sp;
626 if (do_ckp || fs->lfs_doifile) {
627 segleft = lfs_sb_getnseg(fs);
629 for (n = 0; n < lfs_sb_getsegtabsz(fs); n++) {
633 bread_error = bread(fs->lfs_ivnode,
634 lfs_sb_getcleansz(fs) + n,
635 lfs_sb_getbsize(fs), B_MODIFY, &bp);
641 maxseg = uimin(segleft, lfs_sb_getsepb(fs));
644 if (sn != lfs_dtosn(fs, lfs_sb_getcurseg(fs)) &&
647 --fs->lfs_nactive;
650 if (lfs_sb_getversion(fs) > 1)
661 segleft -= lfs_sb_getsepb(fs);
662 curseg += lfs_sb_getsepb(fs);
666 KASSERT(LFS_SEGLOCK_HELD(fs));
669 if (do_ckp || fs->lfs_doifile) {
670 vp = fs->lfs_ivnode;
679 fs->lfs_flags &= ~LFS_IFDIRTY;
689 lfs_writefile(fs, sp, vp);
694 lfs_writefile(fs, sp, vp);
695 lfs_writefile(fs, sp, vp);
701 redo = (do_ckp ? lfs_writeinode(fs, sp, ip) : 0);
703 redo = lfs_writeinode(fs, sp, ip);
705 redo += lfs_writeseg(fs, sp);
707 redo += (fs->lfs_flags & LFS_IFDIRTY);
731 if (bp->b_lblkno < lfs_sb_getcleansz(fs) +
732 lfs_sb_getsegtabsz(fs) &&
746 (void) lfs_writeseg(fs, sp);
750 fs->lfs_doifile = 0;
752 lfs_writer_leave(fs);
773 lfs_segunlock(fs);
783 lfs_writefile(struct lfs *fs, struct segment *sp, struct vnode *vp)
790 ASSERT_SEGLOCK(fs);
794 lfs_acquire_finfo(fs, ip->i_number, ip->i_gen);
798 lfs_ss_setflags(fs, ssp,
799 lfs_ss_getflags(fs, ssp) | (SS_DIROP|SS_CONT));
802 if ((fs->lfs_flags & LFS_NOTYET) && curproc->p_pid == fs->lfs_rfpid) {
807 if (vp == fs->lfs_ivnode)
808 lfs_gather(fs, sp, vp, lfs_match_data);
810 lfs_ungather(fs, sp, vp, lfs_match_data);
812 lfs_gather(fs, sp, vp, lfs_match_fake);
820 if (IS_FLUSHING(fs, vp) || vp == fs->lfs_ivnode) {
821 lfs_gather(fs, sp, vp, lfs_match_data);
829 lfs_gather(fs, sp, vp, lfs_match_data);
835 if (!IS_FLUSHING(fs, vp)) {
862 ip->i_lfs_fragsize[i] < lfs_sb_getbsize(fs))
867 if (IS_FLUSHING(fs, vp) ||
869 lfs_gather(fs, sp, vp, lfs_match_indir);
870 lfs_gather(fs, sp, vp, lfs_match_dindir);
871 lfs_gather(fs, sp, vp, lfs_match_tindir);
873 lfs_release_finfo(fs);
882 lfs_update_iaddr(struct lfs *fs, struct segment *sp, struct inode *ip, daddr_t ndaddr)
900 daddr = lfs_sb_getidaddr(fs);
901 lfs_sb_setidaddr(fs, LFS_DBTOFSB(fs, ndaddr));
903 LFS_IENTRY(ifp, fs, ino, bp);
904 daddr = lfs_if_getdaddr(fs, ifp);
905 lfs_if_setdaddr(fs, ifp, LFS_DBTOFSB(fs, ndaddr));
915 sn = lfs_dtosn(fs, lfs_sb_getoffset(fs));
916 if (lfs_sntod(fs, sn) + lfs_btofsb(fs, lfs_sb_getsumsize(fs)) ==
917 lfs_sb_getoffset(fs)) {
918 LFS_SEGENTRY(sup, fs, sn, bp);
920 LFS_WRITESEGENTRY(sup, fs, sn, bp);
921 /* fs->lfs_flags |= LFS_IFDIRTY; */
936 if (daddr >= lfs_sb_getlastpseg(fs) && daddr <= lfs_sb_getoffset(fs)) {
948 u_int32_t oldsn = lfs_dtosn(fs, daddr);
951 LFS_SEGENTRY(sup, fs, oldsn, bp);
952 KASSERTMSG(((sup->su_nbytes + DINOSIZE(fs)*ndupino)
953 >= DINOSIZE(fs)),
959 lfs_dtosn(fs, daddr),
960 (int)DINOSIZE(fs) * (1 - sp->ndupino) - sup->su_nbytes,
965 lfs_dtosn(fs, daddr), DINOSIZE(fs), ino));
966 sup->su_nbytes -= DINOSIZE(fs);
971 fs->lfs_flags |= LFS_IFDIRTY;
974 lfs_sb_setidaddr(fs, 0x0);
976 LFS_WRITESEGENTRY(sup, fs, oldsn, bp); /* Ifile */
983 lfs_writeinode(struct lfs *fs, struct segment *sp, struct inode *ip)
996 ASSERT_SEGLOCK(fs);
1001 KASSERT(ip->i_number != LFS_IFILE_INUM || fs->lfs_writer > 0 ||
1011 while (vp == fs->lfs_ivnode) {
1015 (sp->seg_bytes_left < lfs_sb_getibsize(fs) ||
1016 sp->sum_bytes_left < sizeof(IINFOSIZE(fs)))) {
1017 (void) lfs_writeseg(fs, sp);
1022 LIST_FOREACH(bp, &fs->lfs_ivnode->v_dirtyblkhd, b_vnbufs) {
1030 redo = lfs_update_iaddr(fs, sp, ip, 0x0);
1035 lfs_dino_setinumber(fs, sp->idp, 0);
1045 lfs_writefile(fs, sp, fs->lfs_ivnode);
1052 if (sp->seg_bytes_left < lfs_sb_getibsize(fs) ||
1053 sp->sum_bytes_left < sizeof(IINFOSIZE(fs)))
1054 (void) lfs_writeseg(fs, sp);
1057 daddr = lfs_sb_getoffset(fs);
1058 lfs_sb_addoffset(fs, lfs_btofsb(fs, lfs_sb_getibsize(fs)));
1060 getblk(VTOI(fs->lfs_ivnode)->i_devvp,
1061 LFS_FSBTODB(fs, daddr), lfs_sb_getibsize(fs), 0, 0);
1065 for (i = 0; i < LFS_INOPB(fs); ++i) {
1069 DINOSIZE(fs) * i);
1070 lfs_dino_setinumber(fs, tmpdi, 0);
1074 lfs_sb_subavail(fs, lfs_btofsb(fs, lfs_sb_getibsize(fs)));
1076 sp->seg_bytes_left -= lfs_sb_getibsize(fs);
1077 sp->sum_bytes_left -= sizeof(IINFOSIZE(fs));
1080 iip = NTH_IINFO(fs, sp->segsum, sp->ninodes / LFS_INOPB(fs));
1081 lfs_ii_setblock(fs, iip, daddr);
1087 lfs_ss_setflags(fs, ssp,
1088 lfs_ss_getflags(fs, ssp) | (SS_DIROP|SS_CONT));
1105 lfs_copy_dinode(fs, sp->idp, ip->i_din);
1111 cdp = DINO_IN_BLOCK(fs, bp->b_data, sp->ninodes % LFS_INOPB(fs));
1112 lfs_copy_dinode(fs, cdp, ip->i_din);
1135 lfs_dino_setnlink(fs, cdp, ip->i_lfs_odnlink);
1137 lfs_dino_setsize(fs, cdp, ip->i_lfs_osize);
1140 ip->i_lfs_odnlink = lfs_dino_getnlink(fs, cdp);
1146 lfs_finalize_ino_seguse(fs, ip);
1162 if (((lfs_dino_getmode(fs, ip->i_din) & LFS_IFMT) == LFS_IFREG ||
1163 (lfs_dino_getmode(fs, ip->i_din) & LFS_IFMT) == LFS_IFDIR) &&
1164 ip->i_size > ((ip->i_lfs_hiblk + 1) << lfs_sb_getbshift(fs))) {
1165 lfs_dino_setsize(fs, cdp, (ip->i_lfs_hiblk + 1) << lfs_sb_getbshift(fs));
1167 PRId64 "\n", (int)ip->i_number, ip->i_size, lfs_dino_getsize(fs, cdp)));
1169 if (ip->i_lfs_effnblks != lfs_dino_getblocks(fs, ip->i_din)) {
1172 lfs_dino_getblocks(fs, ip->i_din), (uintmax_t)lfs_sb_getoffset(fs)));
1174 if (lfs_dino_getdb(fs, cdp, i) == UNWRITTEN) {
1176 lfs_dino_setdb(fs, cdp, i, 0);
1180 if (lfs_dino_getib(fs, cdp, i) == UNWRITTEN) {
1182 lfs_dino_setib(fs, cdp, i, 0);
1192 for (i = (lfs_dino_getsize(fs, cdp) + lfs_sb_getbsize(fs) - 1) >> lfs_sb_getbshift(fs);
1195 if ((lfs_dino_getmode(fs, cdp) & LFS_IFMT) == LFS_IFLNK)
1197 if (((lfs_dino_getmode(fs, cdp) & LFS_IFMT) == LFS_IFBLK ||
1198 (lfs_dino_getmode(fs, cdp) & LFS_IFMT) == LFS_IFCHR) && i == 0)
1200 if (lfs_dino_getdb(fs, cdp, i) != 0) {
1202 lfs_dump_dinode(fs, cdp);
1213 if (ip->i_lfs_effnblks == lfs_dino_getblocks(fs, ip->i_din))
1218 lfs_dino_getblocks(fs, ip->i_din), (intmax_t)ip->i_lfs_effnblks));
1224 sp->idp = DINO_IN_BLOCK(fs, bp, sp->ninodes % LFS_INOPB(fs));
1228 fs->lfs_flags &= ~LFS_IFDIRTY;
1242 lfs_ss_setninos(fs, ssp, lfs_ss_getninos(fs, ssp) + 1);
1245 if (++sp->ninodes % LFS_INOPB(fs) == 0)
1248 redo_ifile = lfs_update_iaddr(fs, sp, ip, bp->b_blkno);
1257 struct lfs *fs;
1261 ASSERT_SEGLOCK(sp->fs);
1277 fs = sp->fs;
1278 blksinblk = howmany(bp->b_bcount, lfs_sb_getbsize(fs));
1279 if (sp->sum_bytes_left < LFS_BLKPTRSIZE(fs) * blksinblk ||
1286 vers = lfs_fi_getversion(fs, sp->fip);
1287 (void) lfs_writeseg(fs, sp);
1290 lfs_acquire_finfo(fs, VTOI(sp->vp)->i_number, vers);
1301 (uintmax_t)lfs_fi_getino(fs, sp->fip), bp->b_lblkno));
1312 bn = lfs_fi_getnblocks(fs, sp->fip);
1313 lfs_fi_setnblocks(fs, sp->fip, bn+1);
1314 lfs_fi_setblock(fs, sp->fip, bn, bp->b_lblkno + j);
1319 sp->sum_bytes_left -= LFS_BLKPTRSIZE(fs) * blksinblk;
1329 lfs_ungather(struct lfs *fs, struct segment *sp, struct vnode *vp,
1343 if (!match(fs, bp))
1361 lfs_gather(struct lfs *fs, struct segment *sp, struct vnode *vp,
1367 ASSERT_SEGLOCK(fs);
1398 (bp->b_flags & B_GATHERED) != 0 || !match(fs, bp)) {
1400 if (vp == fs->lfs_ivnode &&
1406 (uintmax_t)lfs_sb_getoffset(fs));
1424 LFS_DBTOFSB(fs, bp->b_blkno)));
1465 lfs_update_single(struct lfs *fs, struct segment *sp,
1476 ASSERT_SEGLOCK(fs);
1480 KASSERTMSG(sp == NULL || lfs_dtosn(fs, ndaddr)
1481 == lfs_dtosn(fs, lfs_sb_getoffset(fs)),
1488 KASSERT(daddr <= LFS_MAX_DADDR(fs));
1490 daddr = LFS_DBTOFSB(fs, daddr);
1492 bb = lfs_numfrags(fs, size);
1495 ooff = lfs_dino_getdb(fs, ip->i_din, lbn);
1498 lfs_dino_setblocks(fs, ip->i_din,
1499 lfs_dino_getblocks(fs, ip->i_din) + bb);
1502 obb = lfs_btofsb(fs, ip->i_lfs_fragsize[lbn]);
1503 lfs_dino_setblocks(fs, ip->i_din,
1504 lfs_dino_getblocks(fs, ip->i_din) + (bb-obb));
1506 lfs_dino_setdb(fs, ip->i_din, lbn, ndaddr);
1509 ooff = lfs_dino_getib(fs, ip->i_din, a[0].in_off);
1512 lfs_dino_setblocks(fs, ip->i_din,
1513 lfs_dino_getblocks(fs, ip->i_din) + bb);
1514 lfs_dino_setib(fs, ip->i_din, a[0].in_off, ndaddr);
1518 if (bread(vp, ap->in_lbn, lfs_sb_getbsize(fs),
1523 ooff = lfs_iblock_get(fs, bp->b_data, ap->in_off);
1526 lfs_dino_setblocks(fs, ip->i_din,
1527 lfs_dino_getblocks(fs, ip->i_din) + bb);
1528 lfs_iblock_set(fs, bp->b_data, ap->in_off, ndaddr);
1542 /* KASSERT(daddr < fs->lfs_lastpseg || daddr > ndaddr); */
1549 u_int32_t oldsn = lfs_dtosn(fs, daddr);
1553 KASSERT(oldsn < lfs_sb_getnseg(fs));
1557 osize = lfs_sb_getbsize(fs);
1558 LFS_SEGENTRY(sup, fs, oldsn, bp);
1559 KASSERTMSG(((sup->su_nbytes + DINOSIZE(fs)*ndupino) >= osize),
1566 lfs_dtosn(fs, daddr),
1567 (int64_t)osize - (DINOSIZE(fs) * ndupino + sup->su_nbytes),
1572 lfs_dtosn(fs, daddr), osize,
1577 fs->lfs_flags |= LFS_IFDIRTY;
1580 LFS_WRITESEGENTRY(sup, fs, oldsn, bp);
1599 struct lfs *fs;
1609 fs = sp->fs;
1611 ASSERT_SEGLOCK(fs);
1637 lfs_blocks_fromvoid(fs, &tmpptr, (void *)NEXT_FINFO(fs, sp->fip));
1638 nblocks = lfs_blocks_sub(fs, &tmpptr, &sp->start_lbp);
1656 num = howmany(sp->start_bpp[i]->b_bcount, lfs_sb_getbsize(fs));
1678 lfs_shellsort(fs, sp->start_bpp, &sp->start_lbp, nblocks, lfs_sb_getbsize(fs));
1692 lfs_sb_getbmask(fs)) + 1;
1693 lfs_fi_setlastlength(fs, sp->fip, lastlength);
1701 lbn = lfs_blocks_get(fs, &sp->start_lbp, 0);
1704 sbp->b_blkno = LFS_FSBTODB(fs, lfs_sb_getoffset(fs));
1713 if ((sbp->b_bcount & lfs_sb_getbmask(fs)) && i != 0)
1720 KASSERT(lbn >= 0 || sbp->b_bcount == lfs_sb_getbsize(fs));
1724 bytesleft -= lfs_sb_getbsize(fs)) {
1725 size = MIN(bytesleft, lfs_sb_getbsize(fs));
1726 bb = lfs_numfrags(fs, size);
1727 lbn = lfs_blocks_get(fs, &sp->start_lbp, 0);
1728 lfs_blocks_inc(fs, &sp->start_lbp);
1729 lfs_update_single(fs, sp, sp->vp, lbn, lfs_sb_getoffset(fs),
1731 lfs_sb_addoffset(fs, bb);
1744 lfs_rewind(struct lfs *fs, int newsn)
1750 ASSERT_SEGLOCK(fs);
1752 osn = lfs_dtosn(fs, lfs_sb_getoffset(fs));
1757 lfs_sb_subavail(fs, lfs_sb_getfsbpseg(fs) - (lfs_sb_getoffset(fs) - lfs_sb_getcurseg(fs)));
1760 for (sn = 0; sn < lfs_sb_getnseg(fs); ++sn) {
1761 LFS_SEGENTRY(sup, fs, sn, bp);
1768 if (sn == lfs_sb_getnseg(fs))
1772 lfs_sb_setnextseg(fs, lfs_sntod(fs, sn));
1773 lfs_newseg(fs);
1774 lfs_sb_setoffset(fs, lfs_sb_getcurseg(fs));
1786 lfs_initseg(struct lfs *fs, uint16_t flags)
1788 struct segment *sp = fs->lfs_sp;
1795 ASSERT_SEGLOCK(fs);
1797 if (!LFS_PARTIAL_FITS(fs)) {
1799 lfs_sb_subavail(fs, lfs_sb_getfsbpseg(fs) - (lfs_sb_getoffset(fs) -
1800 lfs_sb_getcurseg(fs)));
1802 lfs_wakeup_cleaner(fs);
1803 lfs_newseg(fs);
1805 lfs_sb_setoffset(fs, lfs_sb_getcurseg(fs));
1807 sp->seg_number = lfs_dtosn(fs, lfs_sb_getcurseg(fs));
1808 sp->seg_bytes_left = lfs_fsbtob(fs, lfs_sb_getfsbpseg(fs));
1814 LFS_SEGENTRY(sup, fs, sp->seg_number, bp);
1816 lfs_sb_addoffset(fs, lfs_btofsb(fs, LFS_SBPAD));
1821 if (lfs_sb_getversion(fs) > 1 && sp->seg_number == 0 &&
1822 lfs_sb_gets0addr(fs) < lfs_btofsb(fs, LFS_LABELPAD)) {
1823 lfs_sb_addoffset(fs,
1824 lfs_btofsb(fs, LFS_LABELPAD) - lfs_sb_gets0addr(fs));
1826 LFS_LABELPAD - lfs_fsbtob(fs, lfs_sb_gets0addr(fs));
1829 sp->seg_number = lfs_dtosn(fs, lfs_sb_getcurseg(fs));
1830 sp->seg_bytes_left = lfs_fsbtob(fs, lfs_sb_getfsbpseg(fs) -
1831 (lfs_sb_getoffset(fs) - lfs_sb_getcurseg(fs)));
1833 lfs_sb_setlastpseg(fs, lfs_sb_getoffset(fs));
1837 fs->lfs_cleanint[fs->lfs_cleanind] = lfs_sb_getoffset(fs);
1838 if (++fs->lfs_cleanind >= LFS_MAX_CLEANIND) {
1841 while (fs->lfs_iocount > 1) {
1842 mtsleep(&fs->lfs_iocount, PRIBIO + 1,
1846 fs->lfs_cleanind = 0;
1850 sp->fs = fs;
1859 sbp = lfs_newbuf(fs, VTOI(fs->lfs_ivnode)->i_devvp,
1860 LFS_FSBTODB(fs, lfs_sb_getoffset(fs)), lfs_sb_getsumsize(fs), LFS_NB_SUMMARY);
1865 lfs_sb_addoffset(fs, lfs_btofsb(fs, lfs_sb_getsumsize(fs)));
1869 if ((fs->lfs_flags & LFS_NOTYET) && curproc->p_pid == fs->lfs_rfpid)
1874 memset(ssp, 0, lfs_sb_getsumsize(fs));
1875 lfs_ss_setnext(fs, ssp, lfs_sb_getnextseg(fs));
1876 lfs_ss_setnfinfo(fs, ssp, 0);
1877 lfs_ss_setninos(fs, ssp, 0);
1878 lfs_ss_setmagic(fs, ssp, SS_MAGIC);
1879 lfs_ss_setflags(fs, ssp, flags);
1882 sp->fip = SEGSUM_FINFOBASE(fs, sp->segsum);
1883 lfs_fi_setnblocks(fs, sp->fip, 0);
1884 lfs_fi_setlastlength(fs, sp->fip, 0);
1885 lfs_blocks_fromfinfo(fs, &sp->start_lbp, sp->fip);
1887 sp->seg_bytes_left -= lfs_sb_getsumsize(fs);
1888 sp->sum_bytes_left = lfs_sb_getsumsize(fs) - SEGSUM_SIZE(fs);
1894 lfs_invalidate(struct lfs *fs, int sn)
1899 LFS_SEGENTRY(sup, fs, sn, bp);
1902 lfs_seguse_clrflag_all(fs, SEGUSE_INVAL);
1914 lfs_newseg(struct lfs *fs)
1921 ASSERT_SEGLOCK(fs);
1925 while (lfs_sb_getnextseg(fs) < lfs_sb_getcurseg(fs) && fs->lfs_nowrap) {
1926 if (fs->lfs_wrappass) {
1928 lfs_sb_getfsmnt(fs), fs->lfs_wrappass);
1929 fs->lfs_wrappass = 0;
1932 fs->lfs_wrapstatus = LFS_WRAP_WAITING;
1933 wakeup(&fs->lfs_nowrap);
1934 log(LOG_NOTICE, "%s: waiting at log wrap\n", lfs_sb_getfsmnt(fs));
1935 mtsleep(&fs->lfs_wrappass, PVFS, "newseg", 10 * hz,
1938 fs->lfs_wrapstatus = LFS_WRAP_GOING;
1941 LFS_SEGENTRY(sup, fs, lfs_dtosn(fs, lfs_sb_getnextseg(fs)), bp);
1943 lfs_dtosn(fs, lfs_sb_getnextseg(fs))));
1950 LFS_WRITESEGENTRY(sup, fs, lfs_dtosn(fs, lfs_sb_getnextseg(fs)), bp);
1952 LFS_CLEANERINFO(cip, fs, bp);
1953 lfs_ci_shiftcleantodirty(fs, cip, 1);
1954 lfs_sb_setnclean(fs, lfs_ci_getclean(fs, cip));
1955 LFS_SYNC_CLEANERINFO(cip, fs, bp, 1);
1957 lfs_sb_setlastseg(fs, lfs_sb_getcurseg(fs));
1958 lfs_sb_setcurseg(fs, lfs_sb_getnextseg(fs));
1960 for (sn = curseg = lfs_dtosn(fs, lfs_sb_getcurseg(fs)) + lfs_sb_getinterleave(fs);;) {
1961 sn = (sn + 1) % lfs_sb_getnseg(fs);
1969 LFS_SEGENTRY(sup, fs, sn, bp);
1977 lfs_seguse_clrflag_all(fs, SEGUSE_INVAL);
1979 ++fs->lfs_nactive;
1980 lfs_sb_setnextseg(fs, lfs_sntod(fs, sn));
1987 lfs_newclusterbuf(struct lfs *fs, struct vnode *vp, daddr_t addr,
1993 ASSERT_SEGLOCK(fs);
1994 cl = (struct lfs_cluster *)pool_get(&fs->lfs_clpool, PR_WAITOK);
1995 bpp = (struct buf **)pool_get(&fs->lfs_bpppool, PR_WAITOK);
1997 cl->fs = fs;
2003 if (fs->lfs_sp->seg_flags & SEGM_SYNC) {
2005 cl->seg = fs->lfs_sp;
2020 lfs_writeseg(struct lfs *fs, struct segment *sp)
2043 ASSERT_SEGLOCK(fs);
2054 if ((lfs_ss_getflags(fs, ssp) & (SS_DIROP | SS_CONT)) != SS_DIROP)
2060 lfs_ss_setflags(fs, ssp, lfs_ss_getflags(fs, ssp) | SS_CLEAN);
2064 lfs_ss_setflags(fs, ssp, lfs_ss_getflags(fs, ssp) | SS_RECLAIM);
2065 lfs_ss_setreclino(fs, ssp, fs->lfs_reclino);
2068 oflags = lfs_ss_getflags(fs, ssp);
2070 devvp = VTOI(fs->lfs_ivnode)->i_devvp;
2073 LFS_SEGENTRY(sup, fs, sp->seg_number, bp);
2089 fip = SEGSUM_FINFOBASE(fs, ssp);
2090 for (findex = 0; findex < lfs_ss_getnfinfo(fs, ssp); findex++) {
2091 KDASSERT(lfs_fi_getnblocks(fs, fip) > 0);
2092 KDASSERT(lfs_fi_getversion(fs, fip) > 0);
2093 fip = NEXT_FINFO(fs, fip);
2097 ninos = (lfs_ss_getninos(fs, ssp) + LFS_INOPB(fs) - 1) / LFS_INOPB(fs);
2100 lfs_ss_getninos(fs, ssp) * DINOSIZE(fs),
2101 lfs_ss_getninos(fs, ssp)));
2102 sup->su_nbytes += lfs_ss_getninos(fs, ssp) * DINOSIZE(fs);
2103 /* sup->su_nbytes += lfs_sb_getsumsize(fs); */
2104 if (lfs_sb_getversion(fs) == 1)
2110 lfs_sb_subavail(fs, lfs_btofsb(fs, lfs_sb_getsumsize(fs)));
2113 LFS_WRITESEGENTRY(sup, fs, sp->seg_number, bp); /* Ifile */
2149 lfs_dino_getblocks(fs, VTOI(bp->b_vp)->i_din) !=
2154 lfs_dino_getblocks(fs, VTOI(bp->b_vp)->i_din)));
2156 newbp = lfs_newbuf(fs, bp->b_vp, bp->b_lblkno,
2163 iblimit = newbp->b_bcount / LFS_BLKPTRSIZE(fs);
2165 if (lfs_iblock_get(fs, newbp->b_data, ibindex) == UNWRITTEN) {
2167 lfs_iblock_set(fs, newbp->b_data,
2196 lfs_sb_subavail(fs,
2197 lfs_btofsb(fs, bp->b_bcount));
2200 lfs_freebuf(fs, newbp);
2218 if (lfs_sb_getversion(fs) == 1)
2226 byteoffset += lfs_sb_getbsize(fs)) {
2245 if (lfs_sb_getversion(fs) == 1)
2246 lfs_ss_setocreate(fs, ssp, time_second);
2248 lfs_ss_setcreate(fs, ssp, time_second);
2249 lfs_sb_addserial(fs, 1);
2250 lfs_ss_setserial(fs, ssp, lfs_sb_getserial(fs));
2251 lfs_ss_setident(fs, ssp, lfs_sb_getident(fs));
2253 lfs_ss_setdatasum(fs, ssp, lfs_cksum_fold(sum));
2254 sumstart = lfs_ss_getsumstart(fs);
2255 lfs_ss_setsumsum(fs, ssp, cksum((char *)ssp + sumstart,
2256 lfs_sb_getsumsize(fs) - sumstart));
2259 lfs_sb_subbfree(fs, (lfs_btofsb(fs, ninos * lfs_sb_getibsize(fs)) +
2260 lfs_btofsb(fs, lfs_sb_getsumsize(fs))));
2261 lfs_sb_adddmeta(fs, (lfs_btofsb(fs, ninos * lfs_sb_getibsize(fs)) +
2262 lfs_btofsb(fs, lfs_sb_getsumsize(fs))));
2280 cbp = lfs_newclusterbuf(fs, devvp, (*bpp)->b_blkno, i);
2288 (lfs_sb_getsumsize(fs) - SEGSUM_SIZE(fs))
2289 / LFS_BLKPTRSIZE(fs)),
2292 lfs_segsize(fs) / lfs_sb_getfsize(fs)),
2299 ++fs->lfs_iocount;
2310 if (bp->b_bcount > lfs_sb_getbsize(fs)) {
2318 p = cbp->b_data = lfs_malloc(fs, CHUNKSIZE,
2322 KASSERTMSG((lfs_dtosn(fs, LFS_DBTOFSB(fs, bp->b_blkno +
2369 if (fs->lfs_sp->seg_flags & SEGM_SYNC)
2384 if (fs->lfs_sp->seg_flags & SEGM_SYNC)
2386 if (fs->lfs_sp->seg_flags & SEGM_CLEAN) {
2392 return (lfs_initseg(fs, oflags) || do_again);
2396 lfs_writesuper(struct lfs *fs, daddr_t daddr)
2399 struct vnode *devvp = VTOI(fs->lfs_ivnode)->i_devvp;
2401 ASSERT_MAYBE_SEGLOCK(fs);
2402 if (fs->lfs_is64) {
2403 KASSERT(fs->lfs_dlfs_u.u_64.dlfs_magic == LFS64_MAGIC);
2405 KASSERT(fs->lfs_dlfs_u.u_32.dlfs_magic == LFS_MAGIC);
2413 while (fs->lfs_sbactive) {
2414 mtsleep(&fs->lfs_sbactive, PRIBIO+1, "lfs sb", 0,
2417 fs->lfs_sbactive = daddr;
2421 if (lfs_sb_getversion(fs) == 1)
2422 lfs_sb_setotstamp(fs, time_second);
2423 lfs_sb_settstamp(fs, time_second);
2429 lfs_sb_setcksum(fs, lfs_sb_cksum(fs));
2430 bp = lfs_newbuf(fs, devvp,
2431 LFS_FSBTODB(fs, daddr), LFS_SBPAD, LFS_NB_SBLOCK);
2432 memcpy(bp->b_data, &fs->lfs_dlfs_u, sizeof(struct dlfs));
2442 if (fs->lfs_sp != NULL && fs->lfs_sp->seg_flags & SEGM_SYNC)
2453 ++fs->lfs_iocount;
2463 lfs_match_fake(struct lfs *fs, struct buf *bp)
2466 ASSERT_SEGLOCK(fs);
2472 lfs_match_real(struct lfs *fs, struct buf *bp)
2475 ASSERT_SEGLOCK(fs);
2476 return (lfs_match_data(fs, bp) && !lfs_match_fake(fs, bp));
2481 lfs_match_data(struct lfs *fs, struct buf *bp)
2484 ASSERT_SEGLOCK(fs);
2489 lfs_match_indir(struct lfs *fs, struct buf *bp)
2493 ASSERT_SEGLOCK(fs);
2495 return (lbn < 0 && (-lbn - ULFS_NDADDR) % LFS_NINDIR(fs) == 0);
2499 lfs_match_dindir(struct lfs *fs, struct buf *bp)
2503 ASSERT_SEGLOCK(fs);
2505 return (lbn < 0 && (-lbn - ULFS_NDADDR) % LFS_NINDIR(fs) == 1);
2509 lfs_match_tindir(struct lfs *fs, struct buf *bp)
2513 ASSERT_SEGLOCK(fs);
2515 return (lbn < 0 && (-lbn - ULFS_NDADDR) % LFS_NINDIR(fs) == 2);
2521 struct lfs *fs;
2523 fs = bp->b_private;
2524 ASSERT_NO_SEGLOCK(fs);
2525 lfs_freebuf(fs, bp);
2538 struct lfs *fs;
2540 fs = bp->b_private;
2541 ASSERT_NO_SEGLOCK(fs);
2543 fs->lfs_sbactive = 0;
2544 if (--fs->lfs_iocount <= 1)
2545 wakeup(&fs->lfs_iocount);
2546 wakeup(&fs->lfs_sbactive);
2548 lfs_freebuf(fs, bp);
2562 struct lfs *fs;
2570 fs = cl->fs;
2571 devvp = VTOI(fs->lfs_ivnode)->i_devvp;
2572 ASSERT_NO_SEGLOCK(fs);
2592 if ((tbp)->b_vp == (fs)->lfs_ivnode)
2679 lfs_free(fs, bp->b_data, LFS_NB_CLUSTER);
2688 KASSERTMSG((fs->lfs_iocount != 0),
2690 if (--fs->lfs_iocount <= 1)
2691 wakeup(&fs->lfs_iocount);
2694 pool_put(&fs->lfs_bpppool, cl->bpp);
2696 pool_put(&fs->lfs_clpool, cl);
2714 lfs_shellsort(struct lfs *fs,
2726 if (lfs_blocks_get(fs, lb_array, incr++) != bp_array[t1]->b_lblkno + t2) {
2742 (intmax_t)lfs_blocks_get(fs, lb_array, incr++));
2768 lfs_blocks_set(fs, lb_array, incr++,
2779 lfs_acquire_finfo(struct lfs *fs, ino_t ino, int vers)
2781 struct segment *sp = fs->lfs_sp;
2786 if (sp->seg_bytes_left < lfs_sb_getbsize(fs) ||
2787 sp->sum_bytes_left < FINFOSIZE(fs) + LFS_BLKPTRSIZE(fs))
2788 (void) lfs_writeseg(fs, fs->lfs_sp);
2790 sp->sum_bytes_left -= FINFOSIZE(fs);
2792 lfs_ss_setnfinfo(fs, ssp, lfs_ss_getnfinfo(fs, ssp) + 1);
2793 lfs_fi_setnblocks(fs, sp->fip, 0);
2794 lfs_fi_setino(fs, sp->fip, ino);
2795 lfs_fi_setversion(fs, sp->fip, vers);
2803 lfs_release_finfo(struct lfs *fs)
2805 struct segment *sp = fs->lfs_sp;
2808 if (lfs_fi_getnblocks(fs, sp->fip) != 0) {
2809 sp->fip = NEXT_FINFO(fs, sp->fip);
2810 lfs_blocks_fromfinfo(fs, &sp->start_lbp, sp->fip);
2813 sp->sum_bytes_left += FINFOSIZE(fs);
2815 lfs_ss_setnfinfo(fs, ssp, lfs_ss_getnfinfo(fs, ssp) - 1);