Lines Matching refs:fs
122 #define LFS_PARTIAL_FITS(fs) \
123 (lfs_sb_getfsbpseg(fs) - \
124 (lfs_sb_getoffset(fs) - lfs_sb_getcurseg(fs)) > \
125 lfs_sb_getfrag(fs))
131 #define LFS_SHOULD_CHECKPOINT(fs, flags) \
133 ((fs->lfs_nactive > LFS_MAX_ACTIVE || \
135 lfs_sb_getnclean(fs) < LFS_MAX_ACTIVE)))
141 int lfs_writevnodes(struct lfs *fs, struct mount *mp,
167 * read the fs mod time off of it. We don't set IN_UPDATE here,
172 lfs_imtime(struct lfs *fs)
177 ASSERT_MAYBE_SEGLOCK(fs);
179 ip = VTOI(fs->lfs_ivnode);
180 lfs_dino_setmtime(fs, ip->i_din, ts.tv_sec);
181 lfs_dino_setmtimensec(fs, ip->i_din, ts.tv_nsec);
191 #define IS_FLUSHING(fs,vp) ((fs)->lfs_flushvp == (vp))
197 struct lfs *fs;
205 fs = VFSTOULFS(vp->v_mount)->um_lfs;
212 ASSERT_NO_SEGLOCK(fs);
236 vp != fs->lfs_ivnode) {
240 for (off = lfs_lblktosize(fs, bp->b_lblkno);
241 off < lfs_lblktosize(fs, bp->b_lblkno + 1);
249 lfs_sb_addavail(fs,
250 lfs_btofsb(fs,
252 wakeup(&fs->lfs_availsleep);
254 lfs_freebuf(fs, bp);
269 lfs_sb_addavail(fs, lfs_btofsb(fs,
271 wakeup(&fs->lfs_availsleep);
273 lfs_freebuf(fs, bp);
293 lfs_seglock(fs, SEGM_SYNC | ((error != 0) ? SEGM_RECLAIM : 0));
295 fs->lfs_reclino = ip->i_number;
316 lfs_sb_addavail(fs, lfs_btofsb(fs, bp->b_bcount));
317 wakeup(&fs->lfs_availsleep);
342 lfs_segunlock(fs);
349 fs->lfs_flushvp = vp;
350 if (LFS_SHOULD_CHECKPOINT(fs, fs->lfs_sp->seg_flags)) {
352 fs->lfs_flushvp = NULL;
353 KASSERT(fs->lfs_flushvp_fakevref == 0);
354 lfs_segunlock(fs);
367 sp = fs->lfs_sp;
371 lfs_writevnodes(fs, vp->v_mount, sp, VN_EMPTY);
374 (fs->lfs_sp->seg_flags & SEGM_CLEAN)) {
376 lfs_writevnodes(fs, vp->v_mount, sp, VN_CLEAN);
397 relock = lfs_writefile(fs, sp, vp);
398 if (relock && vp != fs->lfs_ivnode) {
406 lfs_writeinode(fs, sp, ip);
410 lfs_writeseg(fs, sp);
411 lfs_segunlock(fs);
412 lfs_segunlock_relock(fs);
429 if (vp == fs->lfs_ivnode) {
430 lfs_writefile(fs, sp, vp);
431 lfs_writefile(fs, sp, vp);
437 } while (lfs_writeinode(fs, sp, ip));
438 } while (lfs_writeseg(fs, sp) && ip->i_number == LFS_IFILE_INUM);
458 if (fs->lfs_seglock > 1) {
459 while (fs->lfs_iocount > 1)
460 (void)mtsleep(&fs->lfs_iocount, PRIBIO + 1,
465 lfs_segunlock(fs);
476 fs->lfs_flushvp = NULL;
477 KASSERT(fs->lfs_flushvp_fakevref == 0);
484 struct lfs *fs;
508 vp != c->fs->lfs_flushvp && !(ip->i_state & IN_CLEANING)) {
513 if (vp == c->fs->lfs_unlockvp) {
523 lfs_writevnodes(struct lfs *fs, struct mount *mp, struct segment *sp, int op)
538 fs);
541 ctx.fs = fs;
551 error = lfs_writefile(fs, sp, vp);
562 lfs_writeinode(fs, sp, ip);
563 lfs_writeseg(fs, sp);
586 (void) lfs_writeinode(fs, sp, ip);
603 struct lfs *fs;
615 fs = VFSTOULFS(mp)->um_lfs;
616 DLOG((DLOG_SEG, "lfs_segwrite(fs=%p, flags=%x)\n", fs, flags));
617 ASSERT_MAYBE_SEGLOCK(fs);
619 if (fs->lfs_ronly)
622 lfs_imtime(fs);
629 do_ckp = LFS_SHOULD_CHECKPOINT(fs, flags);
636 lfs_writer_enter(fs, "ckpwriter");
644 lfs_seglock(fs, flags | (do_ckp ? SEGM_CKP : 0));
645 sp = fs->lfs_sp;
660 lfs_writevnodes(fs, mp, sp, VN_CLEAN);
663 um_error = lfs_writevnodes(fs, mp, sp, VN_REG);
665 lfs_sb_getcurseg(fs) != fs->lfs_startseg) {
666 DLOG((DLOG_SEG, "lfs_segwrite: breaking out of segment write at daddr 0x%jx\n", (uintmax_t)lfs_sb_getoffset(fs)));
671 (writer_set = lfs_writer_tryenter(fs)) != 0) {
673 KASSERT(fs->lfs_writer);
674 error = lfs_writevnodes(fs, mp, sp, VN_DIROP);
682 lfs_flush_dirops(fs);
684 lfs_ss_setflags(fs, ssp,
685 lfs_ss_getflags(fs, ssp) & ~(SS_CONT));
686 lfs_finalize_fs_seguse(fs);
689 lfs_segunlock_relock(fs);
690 sp = fs->lfs_sp;
699 if (do_ckp || fs->lfs_doifile) {
700 segleft = lfs_sb_getnseg(fs);
702 for (n = 0; n < lfs_sb_getsegtabsz(fs); n++) {
706 bread_error = bread(fs->lfs_ivnode,
707 lfs_sb_getcleansz(fs) + n,
708 lfs_sb_getbsize(fs), B_MODIFY, &bp);
714 maxseg = uimin(segleft, lfs_sb_getsepb(fs));
717 if (sn != lfs_dtosn(fs, lfs_sb_getcurseg(fs)) &&
720 --fs->lfs_nactive;
723 fs->lfs_suflags[fs->lfs_activesb][sn] =
725 if (lfs_sb_getversion(fs) > 1)
736 segleft -= lfs_sb_getsepb(fs);
737 curseg += lfs_sb_getsepb(fs);
741 KASSERT(LFS_SEGLOCK_HELD(fs));
744 if (do_ckp || fs->lfs_doifile) {
745 vp = fs->lfs_ivnode;
754 fs->lfs_flags &= ~LFS_IFDIRTY;
764 lfs_writefile(fs, sp, vp);
769 lfs_writefile(fs, sp, vp);
770 lfs_writefile(fs, sp, vp);
776 redo = (do_ckp ? lfs_writeinode(fs, sp, ip) : 0);
778 redo = lfs_writeinode(fs, sp, ip);
780 redo += lfs_writeseg(fs, sp);
782 redo += (fs->lfs_flags & LFS_IFDIRTY);
806 if (bp->b_lblkno < lfs_sb_getcleansz(fs) +
807 lfs_sb_getsegtabsz(fs) &&
821 (void) lfs_writeseg(fs, sp);
825 fs->lfs_doifile = 0;
827 lfs_writer_leave(fs);
848 lfs_segunlock(fs);
857 lfs_writefile(struct lfs *fs, struct segment *sp, struct vnode *vp)
864 ASSERT_SEGLOCK(fs);
868 lfs_acquire_finfo(fs, ip->i_number, ip->i_gen);
872 lfs_ss_setflags(fs, ssp,
873 lfs_ss_getflags(fs, ssp) | (SS_DIROP|SS_CONT));
876 if ((fs->lfs_flags & LFS_NOTYET) && curproc->p_pid == fs->lfs_rfpid) {
881 if (vp == fs->lfs_ivnode)
882 lfs_gather(fs, sp, vp, lfs_match_data);
884 lfs_ungather(fs, sp, vp, lfs_match_data);
886 lfs_gather(fs, sp, vp, lfs_match_fake);
894 if (IS_FLUSHING(fs, vp) || vp == fs->lfs_ivnode) {
895 lfs_gather(fs, sp, vp, lfs_match_data);
903 lfs_gather(fs, sp, vp, lfs_match_data);
909 if (!IS_FLUSHING(fs, vp)) {
936 ip->i_lfs_fragsize[i] < lfs_sb_getbsize(fs))
941 if (IS_FLUSHING(fs, vp) ||
943 lfs_gather(fs, sp, vp, lfs_match_indir);
944 lfs_gather(fs, sp, vp, lfs_match_dindir);
945 lfs_gather(fs, sp, vp, lfs_match_tindir);
947 lfs_release_finfo(fs);
956 lfs_update_iaddr(struct lfs *fs, struct segment *sp, struct inode *ip, daddr_t ndaddr)
974 daddr = lfs_sb_getidaddr(fs);
975 lfs_sb_setidaddr(fs, LFS_DBTOFSB(fs, ndaddr));
977 LFS_IENTRY(ifp, fs, ino, bp);
978 daddr = lfs_if_getdaddr(fs, ifp);
979 lfs_if_setdaddr(fs, ifp, LFS_DBTOFSB(fs, ndaddr));
989 sn = lfs_dtosn(fs, lfs_sb_getoffset(fs));
990 if (lfs_sntod(fs, sn) + lfs_btofsb(fs, lfs_sb_getsumsize(fs)) ==
991 lfs_sb_getoffset(fs)) {
992 LFS_SEGENTRY(sup, fs, sn, bp);
994 LFS_WRITESEGENTRY(sup, fs, sn, bp);
995 /* fs->lfs_flags |= LFS_IFDIRTY; */
1010 if (daddr >= lfs_sb_getlastpseg(fs) && daddr <= lfs_sb_getoffset(fs)) {
1022 u_int32_t oldsn = lfs_dtosn(fs, daddr);
1025 LFS_SEGENTRY(sup, fs, oldsn, bp);
1026 KASSERTMSG(((sup->su_nbytes + DINOSIZE(fs)*ndupino)
1027 >= DINOSIZE(fs)),
1033 lfs_dtosn(fs, daddr),
1034 (int)DINOSIZE(fs) * (1 - sp->ndupino) - sup->su_nbytes,
1039 lfs_dtosn(fs, daddr), DINOSIZE(fs), ino));
1040 sup->su_nbytes -= DINOSIZE(fs);
1045 fs->lfs_flags |= LFS_IFDIRTY;
1048 lfs_sb_setidaddr(fs, 0x0);
1050 LFS_WRITESEGENTRY(sup, fs, oldsn, bp); /* Ifile */
1057 lfs_writeinode(struct lfs *fs, struct segment *sp, struct inode *ip)
1070 ASSERT_SEGLOCK(fs);
1075 KASSERT(ip->i_number != LFS_IFILE_INUM || fs->lfs_writer > 0 ||
1085 while (vp == fs->lfs_ivnode) {
1089 (sp->seg_bytes_left < lfs_sb_getibsize(fs) ||
1091 (void) lfs_writeseg(fs, sp);
1096 LIST_FOREACH(bp, &fs->lfs_ivnode->v_dirtyblkhd, b_vnbufs) {
1104 redo = lfs_update_iaddr(fs, sp, ip, 0x0);
1109 lfs_dino_setinumber(fs, sp->idp, 0);
1115 lfs_writefile(fs, sp, fs->lfs_ivnode);
1122 if (sp->seg_bytes_left < lfs_sb_getibsize(fs) ||
1124 (void) lfs_writeseg(fs, sp);
1127 daddr = lfs_sb_getoffset(fs);
1128 lfs_sb_addoffset(fs, lfs_btofsb(fs, lfs_sb_getibsize(fs)));
1130 getblk(VTOI(fs->lfs_ivnode)->i_devvp,
1131 LFS_FSBTODB(fs, daddr), lfs_sb_getibsize(fs), 0, 0);
1135 for (i = 0; i < LFS_INOPB(fs); ++i) {
1139 DINOSIZE(fs) * i);
1140 lfs_dino_setinumber(fs, tmpdi, 0);
1144 lfs_sb_subavail(fs, lfs_btofsb(fs, lfs_sb_getibsize(fs)));
1146 sp->seg_bytes_left -= lfs_sb_getibsize(fs);
1150 iip = NTH_IINFO(fs, sp->segsum, sp->ninodes / LFS_INOPB(fs));
1151 lfs_ii_setblock(fs, iip, daddr);
1157 lfs_ss_setflags(fs, ssp,
1158 lfs_ss_getflags(fs, ssp) | (SS_DIROP|SS_CONT));
1175 lfs_copy_dinode(fs, sp->idp, ip->i_din);
1181 cdp = DINO_IN_BLOCK(fs, bp->b_data, sp->ninodes % LFS_INOPB(fs));
1182 lfs_copy_dinode(fs, cdp, ip->i_din);
1205 lfs_dino_setnlink(fs, cdp, ip->i_lfs_odnlink);
1207 lfs_dino_setsize(fs, cdp, ip->i_lfs_osize);
1210 ip->i_lfs_odnlink = lfs_dino_getnlink(fs, cdp);
1216 lfs_finalize_ino_seguse(fs, ip);
1232 if (((lfs_dino_getmode(fs, ip->i_din) & LFS_IFMT) == LFS_IFREG ||
1233 (lfs_dino_getmode(fs, ip->i_din) & LFS_IFMT) == LFS_IFDIR) &&
1234 ip->i_size > ((ip->i_lfs_hiblk + 1) << lfs_sb_getbshift(fs))) {
1235 lfs_dino_setsize(fs, cdp, (ip->i_lfs_hiblk + 1) << lfs_sb_getbshift(fs));
1237 PRId64 "\n", (int)ip->i_number, ip->i_size, lfs_dino_getsize(fs, cdp)));
1239 if (ip->i_lfs_effnblks != lfs_dino_getblocks(fs, ip->i_din)) {
1242 lfs_dino_getblocks(fs, ip->i_din), (uintmax_t)lfs_sb_getoffset(fs)));
1244 if (lfs_dino_getdb(fs, cdp, i) == UNWRITTEN) {
1246 lfs_dino_setdb(fs, cdp, i, 0);
1250 if (lfs_dino_getib(fs, cdp, i) == UNWRITTEN) {
1252 lfs_dino_setib(fs, cdp, i, 0);
1262 for (i = (lfs_dino_getsize(fs, cdp) + lfs_sb_getbsize(fs) - 1) >> lfs_sb_getbshift(fs);
1265 if ((lfs_dino_getmode(fs, cdp) & LFS_IFMT) == LFS_IFLNK)
1267 if (((lfs_dino_getmode(fs, cdp) & LFS_IFMT) == LFS_IFBLK ||
1268 (lfs_dino_getmode(fs, cdp) & LFS_IFMT) == LFS_IFCHR) && i == 0)
1270 if (lfs_dino_getdb(fs, cdp, i) != 0) {
1272 lfs_dump_dinode(fs, cdp);
1285 if (ip->i_lfs_effnblks == lfs_dino_getblocks(fs, ip->i_din))
1290 lfs_dino_getblocks(fs, ip->i_din), (intmax_t)ip->i_lfs_effnblks));
1296 sp->idp = DINO_IN_BLOCK(fs, bp, sp->ninodes % LFS_INOPB(fs));
1300 fs->lfs_flags &= ~LFS_IFDIRTY;
1314 lfs_ss_setninos(fs, ssp, lfs_ss_getninos(fs, ssp) + 1);
1317 if (++sp->ninodes % LFS_INOPB(fs) == 0)
1320 redo_ifile = lfs_update_iaddr(fs, sp, ip, bp->b_blkno);
1329 struct lfs *fs;
1333 ASSERT_SEGLOCK(sp->fs);
1338 fs = sp->fs;
1339 blksinblk = howmany(bp->b_bcount, lfs_sb_getbsize(fs));
1346 vers = lfs_fi_getversion(fs, sp->fip);
1347 (void) lfs_writeseg(fs, sp);
1350 lfs_acquire_finfo(fs, VTOI(sp->vp)->i_number, vers);
1360 (uintmax_t)lfs_fi_getino(fs, sp->fip), bp->b_lblkno));
1371 bn = lfs_fi_getnblocks(fs, sp->fip);
1372 lfs_fi_setnblocks(fs, sp->fip, bn+1);
1373 lfs_fi_setblock(fs, sp->fip, bn, bp->b_lblkno + j);
1385 lfs_ungather(struct lfs *fs, struct segment *sp, struct vnode *vp,
1391 ASSERT_SEGLOCK(fs);
1402 if (!match(fs, bp))
1421 lfs_gather(struct lfs *fs, struct segment *sp, struct vnode *vp,
1427 ASSERT_SEGLOCK(fs);
1458 (bp->b_flags & B_GATHERED) != 0 || !match(fs, bp)) {
1460 if (vp == fs->lfs_ivnode &&
1466 (uintmax_t)lfs_sb_getoffset(fs));
1484 LFS_DBTOFSB(fs, bp->b_blkno)));
1525 lfs_update_single(struct lfs *fs, struct segment *sp,
1536 ASSERT_SEGLOCK(fs);
1544 KASSERT(daddr <= LFS_MAX_DADDR(fs));
1546 daddr = LFS_DBTOFSB(fs, daddr);
1548 bb = lfs_numfrags(fs, size);
1551 ooff = lfs_dino_getdb(fs, ip->i_din, lbn);
1554 lfs_dino_setblocks(fs, ip->i_din,
1555 lfs_dino_getblocks(fs, ip->i_din) + bb);
1558 obb = lfs_btofsb(fs, ip->i_lfs_fragsize[lbn]);
1559 lfs_dino_setblocks(fs, ip->i_din,
1560 lfs_dino_getblocks(fs, ip->i_din) + (bb-obb));
1562 lfs_dino_setdb(fs, ip->i_din, lbn, ndaddr);
1565 ooff = lfs_dino_getib(fs, ip->i_din, a[0].in_off);
1568 lfs_dino_setblocks(fs, ip->i_din,
1569 lfs_dino_getblocks(fs, ip->i_din) + bb);
1570 lfs_dino_setib(fs, ip->i_din, a[0].in_off, ndaddr);
1574 if (bread(vp, ap->in_lbn, lfs_sb_getbsize(fs),
1579 ooff = lfs_iblock_get(fs, bp->b_data, ap->in_off);
1582 lfs_dino_setblocks(fs, ip->i_din,
1583 lfs_dino_getblocks(fs, ip->i_din) + bb);
1584 lfs_iblock_set(fs, bp->b_data, ap->in_off, ndaddr);
1598 /* KASSERT(daddr < fs->lfs_lastpseg || daddr > ndaddr); */
1605 u_int32_t oldsn = lfs_dtosn(fs, daddr);
1609 KASSERT(oldsn < lfs_sb_getnseg(fs));
1613 osize = lfs_sb_getbsize(fs);
1614 LFS_SEGENTRY(sup, fs, oldsn, bp);
1615 KASSERTMSG(((sup->su_nbytes + DINOSIZE(fs)*ndupino) >= osize),
1622 lfs_dtosn(fs, daddr),
1623 (int64_t)osize - (DINOSIZE(fs) * ndupino + sup->su_nbytes),
1628 lfs_dtosn(fs, daddr), osize,
1633 fs->lfs_flags |= LFS_IFDIRTY;
1636 LFS_WRITESEGENTRY(sup, fs, oldsn, bp);
1655 struct lfs *fs;
1665 fs = sp->fs;
1667 ASSERT_SEGLOCK(fs);
1693 lfs_blocks_fromvoid(fs, &tmpptr, (void *)NEXT_FINFO(fs, sp->fip));
1694 nblocks = lfs_blocks_sub(fs, &tmpptr, &sp->start_lbp);
1712 num = howmany(sp->start_bpp[i]->b_bcount, lfs_sb_getbsize(fs));
1734 lfs_shellsort(fs, sp->start_bpp, &sp->start_lbp, nblocks, lfs_sb_getbsize(fs));
1748 lfs_sb_getbmask(fs)) + 1;
1749 lfs_fi_setlastlength(fs, sp->fip, lastlength);
1757 lbn = lfs_blocks_get(fs, &sp->start_lbp, 0);
1760 sbp->b_blkno = LFS_FSBTODB(fs, lfs_sb_getoffset(fs));
1769 if ((sbp->b_bcount & lfs_sb_getbmask(fs)) && i != 0)
1776 KASSERT(lbn >= 0 || sbp->b_bcount == lfs_sb_getbsize(fs));
1779 bytesleft -= lfs_sb_getbsize(fs)) {
1780 size = MIN(bytesleft, lfs_sb_getbsize(fs));
1781 bb = lfs_numfrags(fs, size);
1782 lbn = lfs_blocks_get(fs, &sp->start_lbp, 0);
1783 lfs_blocks_inc(fs, &sp->start_lbp);
1784 lfs_update_single(fs, sp, sp->vp, lbn, lfs_sb_getoffset(fs),
1786 lfs_sb_addoffset(fs, bb);
1799 lfs_rewind(struct lfs *fs, int newsn)
1805 ASSERT_SEGLOCK(fs);
1807 osn = lfs_dtosn(fs, lfs_sb_getoffset(fs));
1812 lfs_sb_subavail(fs, lfs_sb_getfsbpseg(fs) - (lfs_sb_getoffset(fs) - lfs_sb_getcurseg(fs)));
1815 for (sn = 0; sn < lfs_sb_getnseg(fs); ++sn) {
1816 LFS_SEGENTRY(sup, fs, sn, bp);
1823 if (sn == lfs_sb_getnseg(fs))
1827 lfs_sb_setnextseg(fs, lfs_sntod(fs, sn));
1828 lfs_newseg(fs);
1829 lfs_sb_setoffset(fs, lfs_sb_getcurseg(fs));
1841 lfs_initseg(struct lfs *fs, uint16_t flags)
1843 struct segment *sp = fs->lfs_sp;
1848 ASSERT_SEGLOCK(fs);
1850 if (!LFS_PARTIAL_FITS(fs)) {
1855 lfs_sb_subavail(fs, lfs_sb_getfsbpseg(fs) - (lfs_sb_getoffset(fs) -
1856 lfs_sb_getcurseg(fs)));
1858 lfs_wakeup_cleaner(fs);
1859 lfs_newseg(fs);
1861 lfs_sb_setoffset(fs, lfs_sb_getcurseg(fs));
1863 sp->seg_number = lfs_dtosn(fs, lfs_sb_getcurseg(fs));
1864 sp->seg_bytes_left = lfs_fsbtob(fs, lfs_sb_getfsbpseg(fs));
1870 LFS_SEGENTRY(sup, fs, sp->seg_number, bp);
1872 lfs_sb_addoffset(fs, lfs_btofsb(fs, LFS_SBPAD));
1877 if (lfs_sb_getversion(fs) > 1 && sp->seg_number == 0 &&
1878 lfs_sb_gets0addr(fs) < lfs_btofsb(fs, LFS_LABELPAD)) {
1879 lfs_sb_addoffset(fs,
1880 lfs_btofsb(fs, LFS_LABELPAD) - lfs_sb_gets0addr(fs));
1882 LFS_LABELPAD - lfs_fsbtob(fs, lfs_sb_gets0addr(fs));
1885 sp->seg_number = lfs_dtosn(fs, lfs_sb_getcurseg(fs));
1886 sp->seg_bytes_left = lfs_fsbtob(fs, lfs_sb_getfsbpseg(fs) -
1887 (lfs_sb_getoffset(fs) - lfs_sb_getcurseg(fs)));
1889 lfs_sb_setlastpseg(fs, lfs_sb_getoffset(fs));
1893 fs->lfs_cleanint[fs->lfs_cleanind] = lfs_sb_getoffset(fs);
1894 if (++fs->lfs_cleanind >= LFS_MAX_CLEANIND) {
1897 while (fs->lfs_iocount > 1) {
1898 mtsleep(&fs->lfs_iocount, PRIBIO + 1,
1902 fs->lfs_cleanind = 0;
1906 sp->fs = fs;
1915 sbp = lfs_newbuf(fs, VTOI(fs->lfs_ivnode)->i_devvp,
1916 LFS_FSBTODB(fs, lfs_sb_getoffset(fs)), lfs_sb_getsumsize(fs), LFS_NB_SUMMARY);
1921 lfs_sb_addoffset(fs, lfs_btofsb(fs, lfs_sb_getsumsize(fs)));
1925 if ((fs->lfs_flags & LFS_NOTYET) && curproc->p_pid == fs->lfs_rfpid)
1930 memset(ssp, 0, lfs_sb_getsumsize(fs));
1931 lfs_ss_setnext(fs, ssp, lfs_sb_getnextseg(fs));
1932 lfs_ss_setnfinfo(fs, ssp, 0);
1933 lfs_ss_setninos(fs, ssp, 0);
1934 lfs_ss_setmagic(fs, ssp, SS_MAGIC);
1935 lfs_ss_setflags(fs, ssp, flags);
1938 sp->fip = SEGSUM_FINFOBASE(fs, sp->segsum);
1939 lfs_fi_setnblocks(fs, sp->fip, 0);
1940 lfs_fi_setlastlength(fs, sp->fip, 0);
1941 lfs_blocks_fromfinfo(fs, &sp->start_lbp, sp->fip);
1943 sp->seg_bytes_left -= lfs_sb_getsumsize(fs);
1944 sp->sum_bytes_left = lfs_sb_getsumsize(fs) - SEGSUM_SIZE(fs);
1953 lfs_unset_inval_all(struct lfs *fs)
1959 for (i = 0; i < lfs_sb_getnseg(fs); i++) {
1960 LFS_SEGENTRY(sup, fs, i, bp);
1963 LFS_WRITESEGENTRY(sup, fs, i, bp);
1973 lfs_newseg(struct lfs *fs)
1980 ASSERT_SEGLOCK(fs);
1984 while (lfs_sb_getnextseg(fs) < lfs_sb_getcurseg(fs) && fs->lfs_nowrap) {
1985 if (fs->lfs_wrappass) {
1987 lfs_sb_getfsmnt(fs), fs->lfs_wrappass);
1988 fs->lfs_wrappass = 0;
1991 fs->lfs_wrapstatus = LFS_WRAP_WAITING;
1992 wakeup(&fs->lfs_nowrap);
1993 log(LOG_NOTICE, "%s: waiting at log wrap\n", lfs_sb_getfsmnt(fs));
1994 mtsleep(&fs->lfs_wrappass, PVFS, "newseg", 10 * hz,
1997 fs->lfs_wrapstatus = LFS_WRAP_GOING;
2000 LFS_SEGENTRY(sup, fs, lfs_dtosn(fs, lfs_sb_getnextseg(fs)), bp);
2002 lfs_dtosn(fs, lfs_sb_getnextseg(fs))));
2007 LFS_WRITESEGENTRY(sup, fs, lfs_dtosn(fs, lfs_sb_getnextseg(fs)), bp);
2009 LFS_CLEANERINFO(cip, fs, bp);
2010 lfs_ci_shiftcleantodirty(fs, cip, 1);
2011 lfs_sb_setnclean(fs, lfs_ci_getclean(fs, cip));
2012 LFS_SYNC_CLEANERINFO(cip, fs, bp, 1);
2014 lfs_sb_setlastseg(fs, lfs_sb_getcurseg(fs));
2015 lfs_sb_setcurseg(fs, lfs_sb_getnextseg(fs));
2017 for (sn = curseg = lfs_dtosn(fs, lfs_sb_getcurseg(fs)) + lfs_sb_getinterleave(fs);;) {
2018 sn = (sn + 1) % lfs_sb_getnseg(fs);
2026 LFS_SEGENTRY(sup, fs, sn, bp);
2031 LFS_WRITESEGENTRY(sup, fs, sn, bp);
2039 lfs_unset_inval_all(fs);
2041 ++fs->lfs_nactive;
2042 lfs_sb_setnextseg(fs, lfs_sntod(fs, sn));
2049 lfs_newclusterbuf(struct lfs *fs, struct vnode *vp, daddr_t addr,
2055 ASSERT_SEGLOCK(fs);
2056 cl = (struct lfs_cluster *)pool_get(&fs->lfs_clpool, PR_WAITOK);
2057 bpp = (struct buf **)pool_get(&fs->lfs_bpppool, PR_WAITOK);
2059 cl->fs = fs;
2065 if (fs->lfs_sp->seg_flags & SEGM_SYNC) {
2067 cl->seg = fs->lfs_sp;
2082 lfs_writeseg(struct lfs *fs, struct segment *sp)
2105 ASSERT_SEGLOCK(fs);
2116 if ((lfs_ss_getflags(fs, ssp) & (SS_DIROP | SS_CONT)) != SS_DIROP)
2122 lfs_ss_setflags(fs, ssp, lfs_ss_getflags(fs, ssp) | SS_CLEAN);
2126 lfs_ss_setflags(fs, ssp, lfs_ss_getflags(fs, ssp) | SS_RECLAIM);
2127 lfs_ss_setreclino(fs, ssp, fs->lfs_reclino);
2130 oflags = lfs_ss_getflags(fs, ssp);
2132 devvp = VTOI(fs->lfs_ivnode)->i_devvp;
2135 LFS_SEGENTRY(sup, fs, sp->seg_number, bp);
2151 fip = SEGSUM_FINFOBASE(fs, ssp);
2152 for (findex = 0; findex < lfs_ss_getnfinfo(fs, ssp); findex++) {
2153 KDASSERT(lfs_fi_getnblocks(fs, fip) > 0);
2154 KDASSERT(lfs_fi_getversion(fs, fip) > 0);
2155 fip = NEXT_FINFO(fs, fip);
2159 ninos = (lfs_ss_getninos(fs, ssp) + LFS_INOPB(fs) - 1) / LFS_INOPB(fs);
2162 lfs_ss_getninos(fs, ssp) * DINOSIZE(fs),
2163 lfs_ss_getninos(fs, ssp)));
2164 sup->su_nbytes += lfs_ss_getninos(fs, ssp) * DINOSIZE(fs);
2165 /* sup->su_nbytes += lfs_sb_getsumsize(fs); */
2166 if (lfs_sb_getversion(fs) == 1)
2172 lfs_sb_subavail(fs, lfs_btofsb(fs, lfs_sb_getsumsize(fs)));
2175 LFS_WRITESEGENTRY(sup, fs, sp->seg_number, bp); /* Ifile */
2211 lfs_dino_getblocks(fs, VTOI(bp->b_vp)->i_din) !=
2216 lfs_dino_getblocks(fs, VTOI(bp->b_vp)->i_din)));
2218 newbp = lfs_newbuf(fs, bp->b_vp, bp->b_lblkno,
2225 iblimit = newbp->b_bcount / LFS_BLKPTRSIZE(fs);
2227 if (lfs_iblock_get(fs, newbp->b_data, ibindex) == UNWRITTEN) {
2229 lfs_iblock_set(fs, newbp->b_data,
2258 lfs_sb_subavail(fs,
2259 lfs_btofsb(fs, bp->b_bcount));
2262 lfs_freebuf(fs, newbp);
2280 if (lfs_sb_getversion(fs) == 1)
2288 byteoffset += lfs_sb_getbsize(fs)) {
2307 if (lfs_sb_getversion(fs) == 1)
2308 lfs_ss_setocreate(fs, ssp, time_second);
2310 lfs_ss_setcreate(fs, ssp, time_second);
2311 lfs_sb_addserial(fs, 1);
2312 lfs_ss_setserial(fs, ssp, lfs_sb_getserial(fs));
2313 lfs_ss_setident(fs, ssp, lfs_sb_getident(fs));
2315 lfs_ss_setdatasum(fs, ssp, lfs_cksum_fold(sum));
2316 sumstart = lfs_ss_getsumstart(fs);
2317 lfs_ss_setsumsum(fs, ssp, cksum((char *)ssp + sumstart,
2318 lfs_sb_getsumsize(fs) - sumstart));
2321 lfs_sb_subbfree(fs, (lfs_btofsb(fs, ninos * lfs_sb_getibsize(fs)) +
2322 lfs_btofsb(fs, lfs_sb_getsumsize(fs))));
2323 lfs_sb_adddmeta(fs, (lfs_btofsb(fs, ninos * lfs_sb_getibsize(fs)) +
2324 lfs_btofsb(fs, lfs_sb_getsumsize(fs))));
2342 cbp = lfs_newclusterbuf(fs, devvp, (*bpp)->b_blkno, i);
2350 (lfs_sb_getsumsize(fs) - SEGSUM_SIZE(fs))
2354 lfs_segsize(fs) / lfs_sb_getfsize(fs)),
2361 ++fs->lfs_iocount;
2372 if (bp->b_bcount > lfs_sb_getbsize(fs)) {
2380 p = cbp->b_data = lfs_malloc(fs, CHUNKSIZE,
2384 KASSERTMSG((lfs_dtosn(fs, LFS_DBTOFSB(fs, bp->b_blkno +
2431 if (fs->lfs_sp->seg_flags & SEGM_SYNC)
2445 if (fs->lfs_sp->seg_flags & SEGM_SYNC)
2447 if (fs->lfs_sp->seg_flags & SEGM_CLEAN) {
2453 return (lfs_initseg(fs, oflags) || do_again);
2457 lfs_writesuper(struct lfs *fs, daddr_t daddr)
2460 struct vnode *devvp = VTOI(fs->lfs_ivnode)->i_devvp;
2462 ASSERT_MAYBE_SEGLOCK(fs);
2463 if (fs->lfs_is64) {
2464 KASSERT(fs->lfs_dlfs_u.u_64.dlfs_magic == LFS64_MAGIC);
2466 KASSERT(fs->lfs_dlfs_u.u_32.dlfs_magic == LFS_MAGIC);
2474 while (fs->lfs_sbactive) {
2475 mtsleep(&fs->lfs_sbactive, PRIBIO+1, "lfs sb", 0,
2478 fs->lfs_sbactive = daddr;
2482 if (lfs_sb_getversion(fs) == 1)
2483 lfs_sb_setotstamp(fs, time_second);
2484 lfs_sb_settstamp(fs, time_second);
2490 lfs_sb_setcksum(fs, lfs_sb_cksum(fs));
2491 bp = lfs_newbuf(fs, devvp,
2492 LFS_FSBTODB(fs, daddr), LFS_SBPAD, LFS_NB_SBLOCK);
2493 memcpy(bp->b_data, &fs->lfs_dlfs_u, sizeof(struct dlfs));
2503 if (fs->lfs_sp != NULL && fs->lfs_sp->seg_flags & SEGM_SYNC)
2514 ++fs->lfs_iocount;
2524 lfs_match_fake(struct lfs *fs, struct buf *bp)
2527 ASSERT_SEGLOCK(fs);
2533 lfs_match_real(struct lfs *fs, struct buf *bp)
2536 ASSERT_SEGLOCK(fs);
2537 return (lfs_match_data(fs, bp) && !lfs_match_fake(fs, bp));
2542 lfs_match_data(struct lfs *fs, struct buf *bp)
2545 ASSERT_SEGLOCK(fs);
2550 lfs_match_indir(struct lfs *fs, struct buf *bp)
2554 ASSERT_SEGLOCK(fs);
2556 return (lbn < 0 && (-lbn - ULFS_NDADDR) % LFS_NINDIR(fs) == 0);
2560 lfs_match_dindir(struct lfs *fs, struct buf *bp)
2564 ASSERT_SEGLOCK(fs);
2566 return (lbn < 0 && (-lbn - ULFS_NDADDR) % LFS_NINDIR(fs) == 1);
2570 lfs_match_tindir(struct lfs *fs, struct buf *bp)
2574 ASSERT_SEGLOCK(fs);
2576 return (lbn < 0 && (-lbn - ULFS_NDADDR) % LFS_NINDIR(fs) == 2);
2582 struct lfs *fs;
2584 fs = bp->b_private;
2585 ASSERT_NO_SEGLOCK(fs);
2586 lfs_freebuf(fs, bp);
2599 struct lfs *fs;
2601 fs = bp->b_private;
2602 ASSERT_NO_SEGLOCK(fs);
2604 fs->lfs_sbactive = 0;
2605 if (--fs->lfs_iocount <= 1)
2606 wakeup(&fs->lfs_iocount);
2607 wakeup(&fs->lfs_sbactive);
2609 lfs_freebuf(fs, bp);
2623 struct lfs *fs;
2631 fs = cl->fs;
2632 devvp = VTOI(fs->lfs_ivnode)->i_devvp;
2633 ASSERT_NO_SEGLOCK(fs);
2653 if ((tbp)->b_vp == (fs)->lfs_ivnode)
2732 lfs_free(fs, bp->b_data, LFS_NB_CLUSTER);
2741 KASSERTMSG((fs->lfs_iocount != 0),
2743 if (--fs->lfs_iocount <= 1)
2744 wakeup(&fs->lfs_iocount);
2747 pool_put(&fs->lfs_bpppool, cl->bpp);
2749 pool_put(&fs->lfs_clpool, cl);
2767 lfs_shellsort(struct lfs *fs,
2779 if (lfs_blocks_get(fs, lb_array, incr++) != bp_array[t1]->b_lblkno + t2) {
2795 (intmax_t)lfs_blocks_get(fs, lb_array, incr++));
2821 lfs_blocks_set(fs, lb_array, incr++,
2832 lfs_acquire_finfo(struct lfs *fs, ino_t ino, int vers)
2834 struct segment *sp = fs->lfs_sp;
2839 if (sp->seg_bytes_left < lfs_sb_getbsize(fs) ||
2840 sp->sum_bytes_left < FINFOSIZE(fs) + LFS_BLKPTRSIZE(fs))
2841 (void) lfs_writeseg(fs, fs->lfs_sp);
2843 sp->sum_bytes_left -= FINFOSIZE(fs);
2845 lfs_ss_setnfinfo(fs, ssp, lfs_ss_getnfinfo(fs, ssp) + 1);
2846 lfs_fi_setnblocks(fs, sp->fip, 0);
2847 lfs_fi_setino(fs, sp->fip, ino);
2848 lfs_fi_setversion(fs, sp->fip, vers);
2856 lfs_release_finfo(struct lfs *fs)
2858 struct segment *sp = fs->lfs_sp;
2861 if (lfs_fi_getnblocks(fs, sp->fip) != 0) {
2862 sp->fip = NEXT_FINFO(fs, sp->fip);
2863 lfs_blocks_fromfinfo(fs, &sp->start_lbp, sp->fip);
2866 sp->sum_bytes_left += FINFOSIZE(fs);
2868 lfs_ss_setnfinfo(fs, ssp, lfs_ss_getnfinfo(fs, ssp) - 1);
Indexes created Fri Oct 17 23:09:53 GMT 2025