Lines Matching refs:fs
111 static void ffs_blkfree_cg(struct ufsmount *, struct fs *,
125 static ufs1_daddr_t ffs_mapsearch(struct fs *, struct cg *, ufs2_daddr_t, int);
157 struct fs *fs; local
168 fs = ump->um_fs;
171 if ((u_int)size > fs->fs_bsize || fragoff(fs, size) != 0) {
173 devtoname(ump->um_dev), (long)fs->fs_bsize, size,
174 fs->fs_fsmnt);
189 if (size == fs->fs_bsize && fs->fs_cstotal.cs_nbfree == 0)
192 freespace(fs, fs->fs_minfree) - numfrags(fs, size) < 0)
194 if (bpref >= fs->fs_size)
197 cg = ino_to_cg(fs, ip->i_number);
199 cg = dtog(fs, bpref);
222 softdep_request_cleanup(fs, ITOV(ip), cred, FLUSH_BLOCKS_WAIT);
228 ffs_fserr(fs, ip->i_number, "filesystem full");
230 fs->fs_fsmnt);
256 struct fs *fs; local
266 fs = ump->um_fs;
274 if ((u_int)osize > fs->fs_bsize || fragoff(fs, osize) != 0 ||
275 (u_int)nsize > fs->fs_bsize || fragoff(fs, nsize) != 0) {
278 devtoname(ump->um_dev), (long)fs->fs_bsize, osize,
279 nsize, fs->fs_fsmnt);
288 freespace(fs, fs->fs_minfree) - numfrags(fs, nsize - osize) < 0) {
293 devtoname(ump->um_dev), (long)fs->fs_bsize, (intmax_t)bprev,
294 fs->fs_fsmnt);
310 bp->b_blkno = fsbtodb(fs, bprev);
324 cg = dtog(fs, bprev);
328 if (bp->b_blkno != fsbtodb(fs, bno))
347 if (bpref >= fs->fs_size)
349 switch ((int)fs->fs_optim) {
359 if (fs->fs_minfree <= 5 ||
360 fs->fs_cstotal.cs_nffree >
361 (off_t)fs->fs_dsize * fs->fs_minfree / (2 * 100))
364 fs->fs_fsmnt);
365 fs->fs_optim = FS_OPTTIME;
378 request = fs->fs_bsize;
379 if (fs->fs_cstotal.cs_nffree <
380 (off_t)fs->fs_dsize * (fs->fs_minfree - 2) / 100)
383 fs->fs_fsmnt);
384 fs->fs_optim = FS_OPTSPACE;
388 devtoname(ump->um_dev), (long)fs->fs_optim, fs->fs_fsmnt);
394 bp->b_blkno = fsbtodb(fs, bno);
410 ffs_blkfree(ump, fs, ump->um_devvp, bprev, (long)osize,
448 softdep_request_cleanup(fs, vp, cred, FLUSH_BLOCKS_WAIT);
454 ffs_fserr(fs, ip->i_number, "filesystem full");
456 fs->fs_fsmnt);
551 struct fs *fs; local
567 fs = ump->um_fs;
574 if (fs->fs_contigsumsize <= 0 || freespace(fs, 4) < 0)
583 dbtofsb(fs, buflist->bs_children[i]->b_blkno), fs->fs_bsize))
589 ssize = fsbtodb(fs, fs->fs_frag);
611 if (dtog(fs, dbtofsb(fs, buflist->bs_children[0]->b_blkno)) !=
612 dtog(fs, dbtofsb(fs, buflist->bs_children[len - 1]->b_blkno)))
625 if (bread(vp, idp->in_lbn, (int)fs->fs_bsize, NOCRED, &sbp)) {
645 if (bread(vp, idp->in_lbn, (int)fs->fs_bsize, NOCRED, &ebp))
659 pref = cgdata(fs, ip->i_nextclustercg);
665 cg = dtog(fs, pref);
666 for (i = min(maxclustersearch, fs->fs_ncg); i > 0; i--) {
670 if (cg >= fs->fs_ncg)
697 for (bap = &sbap[soff], i = 0; i < len; i++, blkno += fs->fs_frag) {
704 dbtofsb(fs, buflist->bs_children[i]->b_blkno), fs->fs_bsize))
706 if (dbtofsb(fs, buflist->bs_children[i]->b_blkno) != *bap)
716 blkno, *bap, fs->fs_bsize, fs->fs_bsize,
762 for (blkno = newblk, i = 0; i < len; i++, blkno += fs->fs_frag) {
779 ffs_blkfree(ump, fs, ump->um_devvp,
780 dbtofsb(fs, bp->b_blkno),
781 fs->fs_bsize, ip->i_number, vp->v_type, NULL,
784 bp->b_blkno = fsbtodb(fs, blkno);
786 if (!ffs_checkblk(ip, dbtofsb(fs, bp->b_blkno), fs->fs_bsize))
817 struct fs *fs; local
832 fs = ump->um_fs;
839 if (fs->fs_contigsumsize <= 0 || freespace(fs, 4) < 0)
848 dbtofsb(fs, buflist->bs_children[i]->b_blkno), fs->fs_bsize))
854 ssize = fsbtodb(fs, fs->fs_frag);
876 if (dtog(fs, dbtofsb(fs, buflist->bs_children[0]->b_blkno)) !=
877 dtog(fs, dbtofsb(fs, buflist->bs_children[len - 1]->b_blkno)))
890 if (bread(vp, idp->in_lbn, (int)fs->fs_bsize, NOCRED, &sbp)) {
910 if (bread(vp, idp->in_lbn, (int)fs->fs_bsize, NOCRED, &ebp))
924 pref = cgdata(fs, ip->i_nextclustercg);
930 cg = dtog(fs, pref);
931 for (i = min(maxclustersearch, fs->fs_ncg); i > 0; i--) {
935 if (cg >= fs->fs_ncg)
961 for (bap = &sbap[soff], i = 0; i < len; i++, blkno += fs->fs_frag) {
968 dbtofsb(fs, buflist->bs_children[i]->b_blkno), fs->fs_bsize))
970 if (dbtofsb(fs, buflist->bs_children[i]->b_blkno) != *bap)
980 blkno, *bap, fs->fs_bsize, fs->fs_bsize,
1026 for (blkno = newblk, i = 0; i < len; i++, blkno += fs->fs_frag) {
1043 ffs_blkfree(ump, fs, ump->um_devvp,
1044 dbtofsb(fs, bp->b_blkno),
1045 fs->fs_bsize, ip->i_number, vp->v_type, NULL,
1048 bp->b_blkno = fsbtodb(fs, blkno);
1050 if (!ffs_checkblk(ip, dbtofsb(fs, bp->b_blkno), fs->fs_bsize))
1097 struct fs *fs; local
1108 fs = ump->um_fs;
1113 if (fs->fs_cstotal.cs_nifree == 0)
1120 if (ipref >= fs->fs_ncg * fs->fs_ipg)
1122 cg = ino_to_cg(fs, ipref);
1128 if (fs->fs_contigdirs[cg] < 255)
1129 fs->fs_contigdirs[cg]++;
1131 if (fs->fs_contigdirs[cg] > 0)
1132 fs->fs_contigdirs[cg]--;
1156 ip->i_mode, (uintmax_t)ip->i_number, fs->fs_fsmnt);
1159 if (DIP(ip, i_blocks) && (fs->fs_flags & FS_UNCLEAN) == 0) { /* XXX */
1161 fs->fs_fsmnt, (u_long)ino, (long)DIP(ip, i_blocks));
1172 if (fs->fs_magic == FS_UFS2_MAGIC) {
1181 if (fs->fs_magic == FS_UFS2_MAGIC) {
1191 softdep_request_cleanup(fs, pvp, cred, FLUSH_INODES_WAIT);
1196 ffs_fserr(fs, pip->i_number, "out of inodes");
1198 fs->fs_fsmnt);
1222 struct fs *fs; local
1230 fs = ITOFS(pip);
1232 avgifree = fs->fs_cstotal.cs_nifree / fs->fs_ncg;
1233 avgbfree = fs->fs_cstotal.cs_nbfree / fs->fs_ncg;
1234 avgndir = fs->fs_cstotal.cs_ndir / fs->fs_ncg;
1241 prefcg = arc4random() % fs->fs_ncg;
1243 minndir = fs->fs_ipg;
1244 for (cg = prefcg; cg < fs->fs_ncg; cg++)
1245 if (fs->fs_cs(fs, cg).cs_ndir < minndir &&
1246 fs->fs_cs(fs, cg).cs_nifree >= avgifree &&
1247 fs->fs_cs(fs, cg).cs_nbfree >= avgbfree) {
1249 minndir = fs->fs_cs(fs, cg).cs_ndir;
1252 if (fs->fs_cs(fs, cg).cs_ndir < minndir &&
1253 fs->fs_cs(fs, cg).cs_nifree >= avgifree &&
1254 fs->fs_cs(fs, cg).cs_nbfree >= avgbfree) {
1256 minndir = fs->fs_cs(fs, cg).cs_ndir;
1258 return ((ino_t)(fs->fs_ipg * mincg));
1265 maxndir = min(avgndir + fs->fs_ipg / 16, fs->fs_ipg);
1272 cgsize = fs->fs_fsize * fs->fs_fpg;
1273 dirsize = fs->fs_avgfilesize * fs->fs_avgfpdir;
1274 curdirsize = avgndir ? (cgsize - avgbfree * fs->fs_bsize) / avgndir : 0;
1280 maxcontigdirs = min((avgbfree * fs->fs_bsize) / dirsize, 255);
1281 if (fs->fs_avgfpdir > 0)
1283 fs->fs_ipg / fs->fs_avgfpdir);
1309 prefcg = ino_to_cg(fs, pip->i_number);
1310 for (cg = prefcg; cg < fs->fs_ncg; cg++)
1311 if (fs->fs_cs(fs, cg).cs_ndir < maxndir &&
1312 fs->fs_cs(fs, cg).cs_nifree >= minifree &&
1313 fs->fs_cs(fs, cg).cs_nbfree >= minbfree) {
1314 if (fs->fs_contigdirs[cg] < maxcontigdirs)
1315 return ((ino_t)(fs->fs_ipg * cg));
1318 if (fs->fs_cs(fs, cg).cs_ndir < maxndir &&
1319 fs->fs_cs(fs, cg).cs_nifree >= minifree &&
1320 fs->fs_cs(fs, cg).cs_nbfree >= minbfree) {
1321 if (fs->fs_contigdirs[cg] < maxcontigdirs)
1322 return ((ino_t)(fs->fs_ipg * cg));
1327 for (cg = prefcg; cg < fs->fs_ncg; cg++)
1328 if (fs->fs_cs(fs, cg).cs_nifree >= avgifree)
1329 return ((ino_t)(fs->fs_ipg * cg));
1331 if (fs->fs_cs(fs, cg).cs_nifree >= avgifree)
1333 return ((ino_t)(fs->fs_ipg * cg));
1372 struct fs *fs; local
1379 fs = ITOFS(ip);
1391 inocg = ino_to_cg(fs, ip->i_number);
1398 pref = cgmeta(fs, inocg);
1403 if (indx == -1 && lbn < UFS_NDADDR + NINDIR(fs) &&
1405 pref = ip->i_din1->di_db[UFS_NDADDR - 1] + fs->fs_frag;
1415 if (pref != 0 && pref >= cgdata(fs, inocg) &&
1416 pref < cgbase(fs, inocg + 1))
1417 return (pref + fs->fs_frag);
1430 fs->fs_bsize) != 0)
1433 if (indx % fs->fs_maxbpg == 0 || prevbn == 0) {
1439 return (cgmeta(fs, inocg));
1445 if (lbn < UFS_NDADDR + NINDIR(fs))
1446 return (cgdata(fs, inocg));
1452 startcg = inocg + lbn / fs->fs_maxbpg;
1454 startcg = dtog(fs, prevbn) + 1;
1455 startcg %= fs->fs_ncg;
1456 avgbfree = fs->fs_cstotal.cs_nbfree / fs->fs_ncg;
1457 for (cg = startcg; cg < fs->fs_ncg; cg++)
1458 if (fs->fs_cs(fs, cg).cs_nbfree >= avgbfree) {
1459 fs->fs_cgrotor = cg;
1460 return (cgdata(fs, cg));
1463 if (fs->fs_cs(fs, cg).cs_nbfree >= avgbfree) {
1464 fs->fs_cgrotor = cg;
1465 return (cgdata(fs, cg));
1472 return (prevbn + fs->fs_frag);
1485 struct fs *fs; local
1492 fs = ITOFS(ip);
1504 inocg = ino_to_cg(fs, ip->i_number);
1511 pref = cgmeta(fs, inocg);
1516 if (indx == -1 && lbn < UFS_NDADDR + NINDIR(fs) &&
1518 pref = ip->i_din2->di_db[UFS_NDADDR - 1] + fs->fs_frag;
1528 if (pref != 0 && pref >= cgdata(fs, inocg) &&
1529 pref < cgbase(fs, inocg + 1))
1530 return (pref + fs->fs_frag);
1543 fs->fs_bsize) != 0)
1546 if (indx % fs->fs_maxbpg == 0 || prevbn == 0) {
1552 return (cgmeta(fs, inocg));
1558 if (lbn < UFS_NDADDR + NINDIR(fs))
1559 return (cgdata(fs, inocg));
1565 startcg = inocg + lbn / fs->fs_maxbpg;
1567 startcg = dtog(fs, prevbn) + 1;
1568 startcg %= fs->fs_ncg;
1569 avgbfree = fs->fs_cstotal.cs_nbfree / fs->fs_ncg;
1570 for (cg = startcg; cg < fs->fs_ncg; cg++)
1571 if (fs->fs_cs(fs, cg).cs_nbfree >= avgbfree) {
1572 fs->fs_cgrotor = cg;
1573 return (cgdata(fs, cg));
1576 if (fs->fs_cs(fs, cg).cs_nbfree >= avgbfree) {
1577 fs->fs_cgrotor = cg;
1578 return (cgdata(fs, cg));
1585 return (prevbn + fs->fs_frag);
1609 struct fs *fs; local
1618 fs = ITOFS(ip);
1628 for (i = 1; i < fs->fs_ncg; i *= 2) {
1630 if (cg >= fs->fs_ncg)
1631 cg -= fs->fs_ncg;
1641 cg = (icg + 2) % fs->fs_ncg;
1642 for (i = 2; i < fs->fs_ncg; i++) {
1647 if (cg == fs->fs_ncg)
1666 struct fs *fs; local
1677 fs = ump->um_fs;
1678 if (fs->fs_cs(fs, cg).cs_nffree < numfrags(fs, nsize - osize))
1680 frags = numfrags(fs, nsize);
1681 bbase = fragnum(fs, bprev);
1682 if (bbase > fragnum(fs, (bprev + frags - 1))) {
1687 if ((error = ffs_getcg(fs, ump->um_devvp, cg, &bp, &cgp)) != 0)
1689 bno = dtogd(fs, bprev);
1691 for (i = numfrags(fs, osize); i < frags; i++)
1700 for (i = frags; i < fs->fs_frag - bbase; i++)
1703 cgp->cg_frsum[i - numfrags(fs, osize)]--;
1706 for (i = numfrags(fs, osize), nffree = 0; i < frags; i++) {
1712 fs->fs_cstotal.cs_nffree -= nffree;
1713 fs->fs_cs(fs, cg).cs_nffree -= nffree;
1714 fs->fs_fmod = 1;
1715 ACTIVECLEAR(fs, cg);
1719 frags, numfrags(fs, osize));
1744 struct fs *fs; local
1754 fs = ump->um_fs;
1755 if (fs->fs_cs(fs, cg).cs_nbfree == 0 && size == fs->fs_bsize)
1758 if ((error = ffs_getcg(fs, ump->um_devvp, cg, &bp, &cgp)) != 0 ||
1759 (cgp->cg_cs.cs_nbfree == 0 && size == fs->fs_bsize))
1761 if (size == fs->fs_bsize) {
1764 ACTIVECLEAR(fs, cg);
1775 frags = numfrags(fs, size);
1776 for (allocsiz = frags; allocsiz < fs->fs_frag; allocsiz++)
1779 if (allocsiz == fs->fs_frag) {
1788 ACTIVECLEAR(fs, cg);
1795 bno = ffs_mapsearch(fs, cgp, bpref, allocsiz);
1805 fs->fs_cstotal.cs_nffree -= frags;
1806 fs->fs_cs(fs, cg).cs_nffree -= frags;
1807 fs->fs_fmod = 1;
1808 blkno = cgbase(fs, cg) + bno;
1809 ACTIVECLEAR(fs, cg);
1840 struct fs *fs; local
1849 fs = ump->um_fs;
1854 bpref = cgbase(fs, cgp->cg_cgx) + cgp->cg_rotor + fs->fs_frag;
1855 } else if ((cgbpref = dtog(fs, bpref)) != cgp->cg_cgx) {
1857 if (bpref < cgdata(fs, cgbpref))
1858 bpref = cgmeta(fs, cgp->cg_cgx);
1860 bpref = cgdata(fs, cgp->cg_cgx);
1865 bno = dtogd(fs, blknum(fs, bpref));
1866 if (ffs_isblock(fs, blksfree, fragstoblks(fs, bno)))
1871 bno = ffs_mapsearch(fs, cgp, bpref, (int)fs->fs_frag);
1875 if (bno >= dtogd(fs, cgdata(fs, cgp->cg_cgx)))
1878 blkno = fragstoblks(fs, bno);
1879 ffs_clrblock(fs, blksfree, (long)blkno);
1880 ffs_clusteracct(fs, cgp, blkno, -1);
1882 fs->fs_cstotal.cs_nbfree--;
1883 fs->fs_cs(fs, cgp->cg_cgx).cs_nbfree--;
1884 fs->fs_fmod = 1;
1885 blkno = cgbase(fs, cgp->cg_cgx) + bno;
1889 size = numfrags(fs, size);
1890 if (size != fs->fs_frag) {
1891 bno = dtogd(fs, blkno);
1892 for (i = size; i < fs->fs_frag; i++)
1894 i = fs->fs_frag - size;
1896 fs->fs_cstotal.cs_nffree += i;
1897 fs->fs_cs(fs, cgp->cg_cgx).cs_nffree += i;
1898 fs->fs_fmod = 1;
1923 struct fs *fs; local
1934 fs = ump->um_fs;
1935 if (fs->fs_maxcluster[cg] < len)
1938 if ((error = ffs_getcg(fs, ump->um_devvp, cg, &bp, &cgp)) != 0) {
1947 for (i = len; i <= fs->fs_contigsumsize; i++)
1950 if (i > fs->fs_contigsumsize) {
1963 fs->fs_maxcluster[cg] = i;
1978 if (dtog(fs, bpref) != cg)
1979 bpref = cgdata(fs, cg);
1981 bpref = blknum(fs, bpref);
1982 bpref = fragstoblks(fs, dtogd(fs, bpref));
2011 if (!ffs_isblock(fs, blksfree, got - run + i))
2013 bno = cgbase(fs, cg) + blkstofrags(fs, got - run + 1);
2014 if (dtog(fs, bno) != cg)
2016 len = blkstofrags(fs, len);
2018 for (i = 0; i < len; i += fs->fs_frag)
2019 if (ffs_alloccgblk(ip, bp, bno + i, fs->fs_bsize) != bno + i)
2021 ACTIVECLEAR(fs, cg);
2030 struct fs *fs; in getinobuf() local
2032 fs = ITOFS(ip); in getinobuf()
2033 return (getblk(ITODEVVP(ip), fsbtodb(fs, ino_to_fsba(fs, in getinobuf()
2034 cg * fs->fs_ipg + cginoblk)), (int)fs->fs_bsize, 0, 0, in getinobuf()
2065 struct fs *fs; local
2075 fs = ump->um_fs;
2077 if (fs->fs_cs(fs, cg).cs_nifree == 0)
2080 if ((error = ffs_getcg(fs, ump->um_devvp, cg, &bp, &cgp)) != 0) {
2092 ipref %= fs->fs_ipg;
2097 len = howmany(fs->fs_ipg - cgp->cg_irotor, NBBY);
2105 cg, (long)cgp->cg_irotor, fs->fs_fsmnt);
2115 if (fs->fs_magic == FS_UFS2_MAGIC &&
2116 ipref + INOPB(fs) > cgp->cg_initediblk &&
2149 bzero(ibp->b_data, (int)fs->fs_bsize);
2151 for (i = 0; i < INOPB(fs); i++) {
2177 error = ffs_getcg(fs, ump->um_devvp, cg, &bp, &cgp);
2179 ACTIVECLEAR(fs, cg);
2184 cgp->cg_initediblk += INOPB(fs);
2189 ACTIVECLEAR(fs, cg);
2192 fs->fs_cstotal.cs_nifree--;
2193 fs->fs_cs(fs, cg).cs_nifree--;
2194 fs->fs_fmod = 1;
2197 fs->fs_cstotal.cs_ndir++;
2198 fs->fs_cs(fs, cg).cs_ndir++;
2202 softdep_setup_inomapdep(bp, ip, cg * fs->fs_ipg + ipref, mode);
2204 return ((ino_t)(cg * fs->fs_ipg + ipref));
2215 ffs_blkfree_cg(ump, fs, devvp, bno, size, inum, dephd) in ffs_blkfree_cg() argument
2217 struct fs *fs;
2233 cg = dtog(fs, bno);
2245 if ((u_int)size > fs->fs_bsize || fragoff(fs, size) != 0 ||
2246 fragnum(fs, bno) + numfrags(fs, size) > fs->fs_frag) {
2248 devtoname(dev), (intmax_t)bno, (long)fs->fs_bsize,
2249 size, fs->fs_fsmnt);
2253 if ((u_int)bno >= fs->fs_size) {
2256 ffs_fserr(fs, inum, "bad block");
2259 if ((error = ffs_getcg(fs, devvp, cg, &bp, &cgp)) != 0)
2261 cgbno = dtogd(fs, bno);
2264 if (size == fs->fs_bsize) {
2265 fragno = fragstoblks(fs, cgbno);
2266 if (!ffs_isfreeblock(fs, blksfree, fragno)) {
2274 devtoname(dev), (intmax_t)bno, fs->fs_fsmnt);
2277 ffs_setblock(fs, blksfree, fragno);
2278 ffs_clusteracct(fs, cgp, fragno, 1);
2280 fs->fs_cstotal.cs_nbfree++;
2281 fs->fs_cs(fs, cg).cs_nbfree++;
2283 bbase = cgbno - fragnum(fs, cgbno);
2287 blk = blkmap(fs, blksfree, bbase);
2288 ffs_fragacct(fs, blk, cgp->cg_frsum, -1);
2292 frags = numfrags(fs, size);
2297 fs->fs_fsmnt);
2303 fs->fs_cstotal.cs_nffree += i;
2304 fs->fs_cs(fs, cg).cs_nffree += i;
2308 blk = blkmap(fs, blksfree, bbase);
2309 ffs_fragacct(fs, blk, cgp->cg_frsum, 1);
2313 fragno = fragstoblks(fs, bbase);
2314 if (ffs_isblock(fs, blksfree, fragno)) {
2315 cgp->cg_cs.cs_nffree -= fs->fs_frag;
2316 fs->fs_cstotal.cs_nffree -= fs->fs_frag;
2317 fs->fs_cs(fs, cg).cs_nffree -= fs->fs_frag;
2318 ffs_clusteracct(fs, cgp, fragno, 1);
2320 fs->fs_cstotal.cs_nbfree++;
2321 fs->fs_cs(fs, cg).cs_nbfree++;
2324 fs->fs_fmod = 1;
2325 ACTIVECLEAR(fs, cg);
2330 numfrags(fs, size), dephd);
2581 ffs_blkfree(ump, fs, devvp, bno, size, inum, vtype, dephd, key) in ffs_blkfree() argument
2583 struct fs *fs;
2603 ffs_snapblkfree(fs, devvp, bno, size, inum, vtype, dephd)) {
2612 ffs_blkfree_cg(ump, fs, devvp, bno, size, inum, dephd);
2668 if (bno + numfrags(fs, size) == tp->bno) {
2673 } else if (bno == tp->bno + numfrags(fs, tp->size)) {
2694 struct fs *fs; local
2701 fs = ITOFS(ip);
2702 if ((u_int)size > fs->fs_bsize || fragoff(fs, size) != 0) {
2704 (long)fs->fs_bsize, size, fs->fs_fsmnt);
2707 if ((u_int)bno >= fs->fs_size)
2709 error = ffs_getcg(fs, ITODEVVP(ip), dtog(fs, bno), &bp, &cgp);
2713 cgbno = dtogd(fs, bno);
2714 if (size == fs->fs_bsize) {
2715 free = ffs_isblock(fs, blksfree, fragstoblks(fs, cgbno));
2717 frags = numfrags(fs, size);
2753 ffs_freefile(ump, fs, devvp, ino, mode, wkhd) in ffs_freefile() argument
2755 struct fs *fs;
2768 cg = ino_to_cg(fs, ino);
2780 if (ino >= fs->fs_ipg * fs->fs_ncg)
2782 devtoname(dev), (uintmax_t)ino, fs->fs_fsmnt);
2783 if ((error = ffs_getcg(fs, devvp, cg, &bp, &cgp)) != 0)
2786 ino %= fs->fs_ipg;
2789 (uintmax_t)(ino + cg * fs->fs_ipg), fs->fs_fsmnt);
2790 if (fs->fs_ronly == 0)
2798 fs->fs_cstotal.cs_nifree++;
2799 fs->fs_cs(fs, cg).cs_nifree++;
2802 fs->fs_cstotal.cs_ndir--;
2803 fs->fs_cs(fs, cg).cs_ndir--;
2805 fs->fs_fmod = 1;
2806 ACTIVECLEAR(fs, cg);
2810 ino + cg * fs->fs_ipg, wkhd);
2820 ffs_checkfreefile(fs, devvp, ino) in ffs_checkfreefile() argument
2821 struct fs *fs; in ffs_checkfreefile()
2831 cg = ino_to_cg(fs, ino);
2834 if (ino >= fs->fs_ipg * fs->fs_ncg)
2836 if ((error = ffs_getcg(fs, devvp, cg, &bp, &cgp)) != 0)
2839 ino %= fs->fs_ipg;
2852 ffs_mapsearch(fs, cgp, bpref, allocsiz) in ffs_mapsearch() argument
2853 struct fs *fs; in ffs_mapsearch()
2868 start = dtogd(fs, bpref) / NBBY;
2872 len = howmany(fs->fs_fpg, NBBY) - start;
2874 fragtbl[fs->fs_frag],
2875 (u_char)(1 << (allocsiz - 1 + (fs->fs_frag % NBBY))));
2880 fragtbl[fs->fs_frag],
2881 (u_char)(1 << (allocsiz - 1 + (fs->fs_frag % NBBY))));
2884 start, len, fs->fs_fsmnt);
2895 for (i = bno + NBBY; bno < i; bno += fs->fs_frag) {
2896 blk = blkmap(fs, blksfree, bno);
2900 for (pos = 0; pos <= fs->fs_frag - allocsiz; pos++) {
2907 printf("bno = %lu, fs = %s\n", (u_long)bno, fs->fs_fsmnt);
2925 ffs_getcg(fs, devvp, cg, bpp, cgpp) in ffs_getcg() argument
2926 struct fs *fs; in ffs_getcg()
2940 if ((fs->fs_metackhash & CK_CYLGRP) != 0)
2943 fragstoblks(fs, cgtod(fs, cg)) : fsbtodb(fs, cgtod(fs, cg)),
2944 (int)fs->fs_cgsize, NULL, NULL, 0, NOCRED, flags,
2949 if ((fs->fs_metackhash & CK_CYLGRP) != 0 &&
2989 if ((fs->fs_metackhash & CK_CYLGRP) != 0)
3019 ffs_fserr(fs, inum, cp) in ffs_fserr() argument
3020 struct fs *fs; in ffs_fserr()
3029 fs->fs_fsmnt, cp);
3148 struct fs *fs; in sysctl_ffs_fsck() local
3185 fs = ump->um_fs; in sysctl_ffs_fsck()
3197 fs->fs_flags |= (long)cmd.value; in sysctl_ffs_fsck()
3199 fs->fs_flags &= ~(long)cmd.value; in sysctl_ffs_fsck()
3278 if ((error = ffs_freefile(ump, fs, ump->um_devvp, in sysctl_ffs_fsck()
3302 blksize = fs->fs_frag - (blkno % fs->fs_frag); in sysctl_ffs_fsck()
3307 ffs_blkfree(ump, fs, ump->um_devvp, blkno, in sysctl_ffs_fsck()
3308 blksize * fs->fs_fsize, UFS_ROOTINO, in sysctl_ffs_fsck()
3312 blksize = fs->fs_frag; in sysctl_ffs_fsck()
3328 fs->fs_cstotal.cs_ndir += cmd.value; in sysctl_ffs_fsck()
3338 fs->fs_cstotal.cs_nbfree += cmd.value; in sysctl_ffs_fsck()
3348 fs->fs_cstotal.cs_nifree += cmd.value; in sysctl_ffs_fsck()
3358 fs->fs_cstotal.cs_nffree += cmd.value; in sysctl_ffs_fsck()
3368 fs->fs_cstotal.cs_numclusters += cmd.value; in sysctl_ffs_fsck()
3549 struct fs *fs; local
3582 fs = ITOFS(ip);
3589 fs->fs_fsmnt, (intmax_t)btodb(uio->uio_offset));
3596 if (uio->uio_resid > fs->fs_bsize - (uio->uio_offset % fs->fs_bsize) ||
3597 fragoff(fs, uio->uio_offset) != 0 ||
3598 fragoff(fs, uio->uio_resid) != 0) {
3602 lbn = numfrags(fs, uio->uio_offset);