Lines Matching refs:fs
54 #include <sys/fs/ufs_fs.h>
55 #include <sys/fs/ufs_inode.h>
56 #include <sys/fs/ufs_acl.h>
57 #include <sys/fs/ufs_bio.h>
58 #include <sys/fs/ufs_quota.h>
60 #include <sys/fs/ufs_trans.h>
61 #include <sys/fs/ufs_panic.h>
68 #include <fs/fs_subr.h>
71 #include <sys/fs/ufs_log.h>
107 struct fs *fs;
117 fs = ufsvfsp->vfs_fs;
118 if ((unsigned)size > fs->fs_bsize || fragoff(fs, size) != 0) {
120 " bsize = %d, size = %d, fs = %s\n",
121 ip->i_dev, fs->fs_bsize, size, fs->fs_fsmnt);
124 if (size == fs->fs_bsize && fs->fs_cstotal.cs_nbfree == 0)
126 if (freespace(fs, ufsvfsp) <= 0 &&
138 if (bpref >= fs->fs_size)
141 cg = (int)itog(fs, ip->i_number);
143 cg = dtog(fs, bpref);
167 cmn_err(CE_NOTE, "alloc: %s: file system full", fs->fs_fsmnt);
186 struct fs *fs;
195 fs = ufsvfsp->vfs_fs;
196 if ((unsigned)osize > fs->fs_bsize || fragoff(fs, osize) != 0 ||
197 (unsigned)nsize > fs->fs_bsize || fragoff(fs, nsize) != 0) {
200 "osize=%d, nsize=%d, fs=%s\n",
201 ip->i_dev, fs->fs_bsize, osize, nsize, fs->fs_fsmnt);
204 if (freespace(fs, ufsvfsp) <= 0 &&
210 " bprev = %ld, fs = %s\n", ip->i_dev, fs->fs_bsize, bprev,
211 fs->fs_fsmnt);
223 cg = dtog(fs, bprev);
229 if (bpref >= fs->fs_size)
245 request = (fs->fs_optim == FS_OPTTIME) ? fs->fs_bsize : nsize;
251 (void) free(ip, bno + numfrags(fs, nsize),
272 "realloccg %s: file system full", fs->fs_fsmnt);
298 struct fs *fs;
308 fs = pip->i_fs;
310 nifree = fs->fs_cstotal.cs_nifree;
335 if (ipref >= (ulong_t)(fs->fs_ncg * fs->fs_ipg))
337 cg = (int)itog(fs, ipref);
385 fs->fs_fsmnt, (int)ino,
410 fs->fs_fsmnt, (int)ino, ip->i_size,
435 * Access times are not really defined if the fs is mounted
449 cmn_err(CE_NOTE, "%s: out of inodes\n", fs->fs_fsmnt);
478 struct fs *fs = dp->i_fs;
480 cg = itog(fs, dp->i_number);
481 mininode = fs->fs_ipg >> 2;
482 minbpg = fs->fs_maxbpg >> 2;
484 (fs->fs_cs(fs, cg).cs_nifree > mininode) &&
485 (fs->fs_cs(fs, cg).cs_nbfree > minbpg)) {
489 avgifree = fs->fs_cstotal.cs_nifree / fs->fs_ncg;
490 minndir = fs->fs_ipg;
492 for (cg = 0; cg < fs->fs_ncg; cg++) {
493 ifree = fs->fs_cs(fs, cg).cs_nifree;
496 (fs->fs_cs(fs, cg).cs_nbfree > minbpg)) {
497 return ((ino_t)(fs->fs_ipg * cg));
499 if ((fs->fs_cs(fs, cg).cs_ndir < minndir) &&
502 minndir = fs->fs_cs(fs, cg).cs_ndir;
505 return ((ino_t)(fs->fs_ipg * mincg));
537 struct fs *fs;
544 fs = ip->i_fs;
545 if (indx % fs->fs_maxbpg == 0 || bap[indx - 1] == 0) {
547 cg = itog(fs, ip->i_number);
548 return (fs->fs_fpg * cg + fs->fs_frag);
555 startcg = itog(fs, ip->i_number) + lbn / fs->fs_maxbpg;
557 startcg = dtog(fs, bap[indx - 1]) + 1;
558 startcg %= fs->fs_ncg;
561 avgbfree = fs->fs_cstotal.cs_nbfree / fs->fs_ncg;
566 for (cg = startcg; cg < fs->fs_ncg; cg++)
567 if (fs->fs_cs(fs, cg).cs_nbfree >= avgbfree) {
568 fs->fs_cgrotor = cg;
570 return (fs->fs_fpg * cg + fs->fs_frag);
573 if (fs->fs_cs(fs, cg).cs_nbfree >= avgbfree) {
574 fs->fs_cgrotor = cg;
576 return (fs->fs_fpg * cg + fs->fs_frag);
594 nextblk = (-bap[indx - 1]) + fs->fs_frag;
596 nextblk = bap[indx - 1] + fs->fs_frag;
599 if (indx > fs->fs_maxcontig && bap[indx - fs->fs_maxcontig] +
600 blkstofrags(fs, fs->fs_maxcontig) != nextblk) {
603 if (fs->fs_rotdelay != 0)
610 nextblk += roundup(fs->fs_rotdelay * fs->fs_rps * fs->fs_nsect /
611 (NSPF(fs) * 1000), fs->fs_frag);
625 struct fs *fs = ip->i_fs;
642 if (bno < 0 && (bno % fs->fs_frag == 0) && bno != UFS_HOLE) {
646 if ((unsigned long)size > fs->fs_bsize || fragoff(fs, size) != 0) {
649 "fs = %s\n", ip->i_dev, fs->fs_bsize,
650 (int)size, fs->fs_fsmnt);
653 cg = dtog(fs, bno);
655 bp = UFS_BREAD(ufsvfsp, ip->i_dev, (daddr_t)fsbtodb(fs, cgtod(fs, cg)),
656 (int)fs->fs_cgsize);
665 TRANS_CANCEL(ufsvfsp, ldbtob(fsbtodb(fs, bno)), size, flags);
667 TRANS_MATA_FREE(ufsvfsp, ldbtob(fsbtodb(fs, bno)), size);
673 bno = dtogd(fs, bno);
674 if (size == fs->fs_bsize) {
675 blkno = fragstoblks(fs, bno);
676 cylno = cbtocylno(fs, bno);
679 if (!isclrblock(fs, blksfree, blkno)) {
683 "dev:0x%lx, block:%ld, ino:%lu, fs:%s",
684 ip->i_dev, bno, ip->i_number, fs->fs_fsmnt);
687 setblock(fs, blksfree, blkno);
691 fs->fs_cstotal.cs_nbfree++;
692 fs->fs_cs(fs, cg).cs_nbfree++;
696 btodb(fs->fs_bsize);
700 bbase = bno - fragnum(fs, bno);
704 bmap = blkmap(fs, blksfree, bbase);
705 fragacct(fs, bmap, cgp->cg_frsum, -1);
709 for (i = 0; i < numfrags(fs, size); i++) {
716 "ino:%lu, fs:%s",
721 fs->fs_fsmnt);
727 fs->fs_cstotal.cs_nffree += i;
728 fs->fs_cs(fs, cg).cs_nffree += i;
732 btodb(i * fs->fs_fsize);
738 bmap = blkmap(fs, blksfree, bbase);
739 fragacct(fs, bmap, cgp->cg_frsum, 1);
743 blkno = fragstoblks(fs, bbase);
744 if (isblock(fs, blksfree, blkno)) {
745 cylno = cbtocylno(fs, bbase);
750 cgp->cg_cs.cs_nffree -= fs->fs_frag;
751 fs->fs_cstotal.cs_nffree -= fs->fs_frag;
752 fs->fs_cs(fs, cg).cs_nffree -= fs->fs_frag;
754 fs->fs_cstotal.cs_nbfree++;
755 fs->fs_cs(fs, cg).cs_nbfree++;
758 fs->fs_fmod = 1;
760 TRANS_BUF(ufsvfsp, 0, fs->fs_cgsize, bp, DT_CG);
761 TRANS_SI(ufsvfsp, fs, cg);
773 struct fs *fs = ip->i_fs;
784 "fs = %s\n",
785 ip->i_mode, mode, (int)ip->i_number, fs->fs_fsmnt);
788 if (ino >= fs->fs_ipg * fs->fs_ncg) {
790 "ifree: range, dev = 0x%x, ino = %d, fs = %s\n",
791 (int)ip->i_dev, (int)ino, fs->fs_fsmnt);
794 cg = (int)itog(fs, ino);
795 bp = UFS_BREAD(ufsvfsp, ip->i_dev, (daddr_t)fsbtodb(fs, cgtod(fs, cg)),
796 (int)fs->fs_cgsize);
806 inot = (unsigned int)(ino % (ulong_t)fs->fs_ipg);
812 "fs:%s",
813 ip->i_mode, mode, (int)ino, fs->fs_fsmnt);
821 fs->fs_cstotal.cs_nifree++;
822 fs->fs_cs(fs, cg).cs_nifree++;
825 fs->fs_cstotal.cs_ndir--;
826 fs->fs_cs(fs, cg).cs_ndir--;
828 fs->fs_fmod = 1;
830 TRANS_BUF(ufsvfsp, 0, fs->fs_cgsize, bp, DT_CG);
831 TRANS_SI(ufsvfsp, fs, cg);
847 struct fs *fs;
852 fs = ip->i_fs;
862 for (i = 1; i < fs->fs_ncg; i *= 2) {
864 if (cg >= fs->fs_ncg)
865 cg -= fs->fs_ncg;
875 cg = (icg + 2) % fs->fs_ncg;
876 for (i = 2; i < fs->fs_ncg; i++) {
881 if (cg == fs->fs_ncg)
897 struct fs *fs = ip->i_fs;
905 if (fs->fs_cs(fs, cg).cs_nffree < numfrags(fs, nsize - osize))
907 frags = numfrags(fs, nsize);
908 bbase = (int)fragnum(fs, bprev);
909 if (bbase > fragnum(fs, (bprev + frags - 1))) {
914 bp = UFS_BREAD(ufsvfsp, ip->i_dev, (daddr_t)fsbtodb(fs, cgtod(fs, cg)),
915 (int)fs->fs_cgsize);
924 bno = dtogd(fs, bprev);
925 for (i = numfrags(fs, osize); i < frags; i++) {
931 if ((TRANS_ISCANCEL(ufsvfsp, ldbtob(fsbtodb(fs, bprev + i)),
932 fs->fs_fsize))) {
946 for (i = frags; i < fs->fs_frag - bbase; i++)
949 j = i - numfrags(fs, osize);
954 for (i = numfrags(fs, osize); i < frags; i++) {
957 fs->fs_cs(fs, cg).cs_nffree--;
958 fs->fs_cstotal.cs_nffree--;
960 fs->fs_fmod = 1;
962 TRANS_BUF(ufsvfsp, 0, fs->fs_cgsize, bp, DT_CG);
963 TRANS_SI(ufsvfsp, fs, cg);
978 struct fs *fs = ip->i_fs;
991 if (fs->fs_cs(fs, cg).cs_nbfree == 0) {
992 if (size == fs->fs_bsize)
998 if (fs->fs_cs(fs, cg).cs_nffree < numfrags(fs, size))
1002 bp = UFS_BREAD(ufsvfsp, ip->i_dev, (daddr_t)fsbtodb(fs, cgtod(fs, cg)),
1003 (int)fs->fs_cgsize);
1007 (cgp->cg_cs.cs_nbfree == 0 && size == fs->fs_bsize)) {
1014 if (size == fs->fs_bsize) {
1017 fs->fs_fmod = 1;
1019 TRANS_SI(ufsvfsp, fs, cg);
1030 frags = numfrags(fs, size);
1033 for (; allocsiz < fs->fs_frag; allocsiz++)
1037 if (allocsiz != fs->fs_frag) {
1039 if (bno < 0 && allocsiz < (fs->fs_frag - 1)) {
1045 if (allocsiz == fs->fs_frag || bno < 0) {
1054 bpref = dtogd(fs, bno);
1055 for (i = frags; i < fs->fs_frag; i++)
1057 i = fs->fs_frag - frags;
1059 fs->fs_cstotal.cs_nffree += i;
1060 fs->fs_cs(fs, cg).cs_nffree += i;
1062 fs->fs_fmod = 1;
1064 TRANS_SI(ufsvfsp, fs, cg);
1072 fs->fs_cstotal.cs_nffree -= frags;
1073 fs->fs_cs(fs, cg).cs_nffree -= frags;
1079 fs->fs_fmod = 1;
1081 TRANS_BUF(ufsvfsp, 0, fs->fs_cgsize, bp, DT_CG);
1082 TRANS_SI(ufsvfsp, fs, cg);
1084 return (cg * fs->fs_fpg + bno);
1113 struct fs *fs;
1120 fs = ufsvfsp->vfs_fs;
1126 bpref = blknum(fs, bpref);
1127 bpref = dtogd(fs, bpref);
1131 if (isblock(fs, blksfree, (daddr_t)fragstoblks(fs, bpref))) {
1138 cylno = cbtocylno(fs, bpref);
1141 if (fs->fs_cpc == 0) {
1146 bpref = howmany(fs->fs_spc * cylno, NSPF(fs));
1181 pos = cylno % fs->fs_cpc;
1182 bno = (cylno - pos) * fs->fs_spc / NSPB(fs);
1212 "i = %d, fs = %s\n", pos, i, fs->fs_fsmnt);
1221 rotbl_size = (fs->fs_cpc * fs->fs_spc) >>
1222 (fs->fs_fragshift + fs->fs_fsbtodb);
1234 if (isblock(fs, blksfree, (daddr_t)(bno + i))) {
1235 bno = blkstofrags(fs, (bno + i));
1238 delta = fs_rotbl(fs)[i];
1246 "fs:%s bno: %x\n", pos, i, fs->fs_fsmnt, (int)bno);
1254 bno = mapsearch(ufsvfsp, cgp, bpref, (int)fs->fs_frag);
1259 blkno = fragstoblks(fs, bno);
1260 frag = (cgp->cg_cgx * fs->fs_fpg) + bno;
1261 if (TRANS_ISCANCEL(ufsvfsp, ldbtob(fsbtodb(fs, frag)), fs->fs_bsize))
1263 clrblock(fs, blksfree, (long)blkno);
1268 fs->fs_cstotal.cs_nbfree--;
1269 fs->fs_cs(fs, cgp->cg_cgx).cs_nbfree--;
1270 cylno = cbtocylno(fs, bno);
1276 TRANS_BUF(ufsvfsp, 0, fs->fs_cgsize, bp, DT_CG);
1277 fs->fs_fmod = 1;
1294 struct fs *fs = ip->i_fs;
1300 if (fs->fs_cs(fs, cg).cs_nifree == 0)
1302 bp = UFS_BREAD(ufsvfsp, ip->i_dev, (daddr_t)fsbtodb(fs, cgtod(fs, cg)),
1303 (int)fs->fs_cgsize);
1325 ipref %= fs->fs_ipg;
1330 len = howmany(fs->fs_ipg - cgp->cg_irotor, NBBY);
1340 "fs = %s\n", cg, (int)cgp->cg_irotor, fs->fs_fsmnt);
1356 fs->fs_fsmnt);
1361 fs->fs_cstotal.cs_nifree--;
1362 fs->fs_cs(fs, cg).cs_nifree--;
1365 fs->fs_cstotal.cs_ndir++;
1366 fs->fs_cs(fs, cg).cs_ndir++;
1368 fs->fs_fmod = 1;
1370 TRANS_BUF(ufsvfsp, 0, fs->fs_cgsize, bp, DT_CG);
1371 TRANS_SI(ufsvfsp, fs, cg);
1373 return (cg * fs->fs_ipg + ipref);
1386 struct fs *fs = ufsvfsp->vfs_fs;
1400 start = dtogd(fs, bpref) / NBBY;
1410 last = howmany(fs->fs_fpg, NBBY);
1412 cfrag = cgp->cg_cgx * fs->fs_fpg;
1419 (uchar_t *)fragtbl[fs->fs_frag],
1420 (int)(1 << (allocsiz - 1 + (fs->fs_frag % NBBY))));
1433 for (i = bno + NBBY; bno < i; bno += fs->fs_frag) {
1434 blk = blkmap(fs, cg_blksfree(cgp), bno);
1439 pos <= fs->fs_frag - allocsiz;
1458 ldbtob(fsbtodb(fs, (cfrag+bno))),
1459 allocsiz * fs->fs_fsize))
1558 struct fs *fs;
1577 fs = ip->i_fs;
1583 istart = blkroundup(fs, (lp->l_start));
1584 len = blkroundup(fs, (lp->l_len));
1585 chunkblks = blkroundup(fs, ufsvfsp->vfs_iotransz) / fs->fs_bsize;
1592 if (lblkno(fs, len) > fs->fs_cstotal.cs_nbfree) {
1595 if (lblkno(fs, len) > fs->fs_cstotal.cs_nbfree)
1625 if (lblkno(fs, lp->l_start) < NDADDR) {
1626 ufs_trans_trunc_resv(ip, ip->i_size + (NDADDR * fs->fs_bsize),
1635 (lblkno(fs, lp->l_start + done_len) < NDADDR)) {
1637 offsetn = (int)blkoff(fs, uoff);
1638 nbytes = (int)MIN(fs->fs_bsize - offsetn,
1673 blkroundup(fs, ufsvfsp->vfs_iotransz), &resv, &resid);
1680 for (i = istart; i < (lp->l_start + lp->l_len); i += fs->fs_bsize) {
1681 berr = bmap_write(ip, i, fs->fs_bsize, BI_FALLOCATE,
1705 ip->i_size += fs->fs_bsize;
1712 * If there are waiters or the fs is hard locked,
1755 ip->i_size + blkroundup(fs, ufsvfsp->vfs_iotransz),
1773 /* Release locks, end log transaction and unlock fs */
1782 * @ exit label, we should no longer be holding the fs write lock, and
1793 !(fs->fs_flags & FSLARGEFILES)) {
1796 fs->fs_flags |= FSLARGEFILES;
1805 ufs_trans_trunc_resv(ip, totblks * fs->fs_bsize, &resv, &resid);
1819 free(ip, ip->i_db[i], fs->fs_bsize, 0);
1832 free(ip, undo->blk, fs->fs_bsize, I_IBLK);
1955 struct fs *fs = ufsvfsp->vfs_fs;
1956 daddr_t nblk = lblkno(fs, blkroundup(fs, nb));
1957 daddr_t minblk = lblkno(fs, blkroundup(fs, minb));
1968 if ((startcg = findlogstartcg(fs, nblk, minblk)) == -1)
1973 for (; cg < fs->fs_ncg; ++cg) {
1978 (daddr_t)fsbtodb(fs, cgtod(fs, cg)),
1979 (int)fs->fs_cgsize);
1986 cgblks = fragstoblks(fs, fs->fs_fpg); /* blks in free array */
1991 if (isblock(fs, blksfree, cgbno)) {
2004 if (!isblock(fs, blksfree, cgbno))
2023 savebno = blkstofrags(fs, savebno);
2025 /* convert frag offset in cg to frag offset in fs */
2026 savebno += (savecg * fs->fs_fpg);
2048 findlogstartcg(struct fs *fs, daddr_t requested, daddr_t minblk)
2061 ncgs = fs->fs_ncg;
2064 max_extents = ((fs->fs_bsize)-header) / sizeof (extent_t);
2072 ctotal += fs->fs_cs(fs, e).cs_nbfree;
2091 ctotal -= fs->fs_cs(fs, s).cs_nbfree;