X-Git-Url: https://git.subgeniuskitty.com/unix-history/.git/blobdiff_plain/6994bf5df1eeba8c3cf826dc403501425c06908a..620b32904718b0941fb8b24e31e4c49188f825c1:/usr/src/sys/ufs/lfs/lfs_alloc.c diff --git a/usr/src/sys/ufs/lfs/lfs_alloc.c b/usr/src/sys/ufs/lfs/lfs_alloc.c index a334aa26f8..44b7fb5a53 100644 --- a/usr/src/sys/ufs/lfs/lfs_alloc.c +++ b/usr/src/sys/ufs/lfs/lfs_alloc.c @@ -1,8 +1,4 @@ -/* Copyright (c) 1981 Regents of the University of California */ - -static char vers[] = "@(#)lfs_alloc.c 1.15 %G%"; - -/* alloc.c 4.8 81/03/08 */ +/* lfs_alloc.c 2.22 83/02/10 */ #include "../h/param.h" #include "../h/systm.h" @@ -13,6 +9,8 @@ static char vers[] = "@(#)lfs_alloc.c 1.15 %G%"; #include "../h/inode.h" #include "../h/dir.h" #include "../h/user.h" +#include "../h/quota.h" +#include "../h/kernel.h" extern u_long hashalloc(); extern ino_t ialloccg(); @@ -44,8 +42,7 @@ extern unsigned char *fragtbl[]; * available block is located. */ struct buf * -alloc(dev, ip, bpref, size) - dev_t dev; +alloc(ip, bpref, size) register struct inode *ip; daddr_t bpref; int size; @@ -55,25 +52,33 @@ alloc(dev, ip, bpref, size) register struct buf *bp; int cg; - fs = getfs(dev); - if ((unsigned)size > fs->fs_bsize || size % fs->fs_fsize != 0) + fs = ip->i_fs; + if ((unsigned)size > fs->fs_bsize || fragoff(fs, size) != 0) { + printf("dev = 0x%x, bsize = %d, size = %d, fs = %s\n", + ip->i_dev, fs->fs_bsize, size, fs->fs_fsmnt); panic("alloc: bad size"); + } if (size == fs->fs_bsize && fs->fs_cstotal.cs_nbfree == 0) goto nospace; if (u.u_uid != 0 && fs->fs_cstotal.cs_nbfree * fs->fs_frag + fs->fs_cstotal.cs_nffree < fs->fs_dsize * fs->fs_minfree / 100) goto nospace; +#ifdef QUOTA + if (chkdq(ip, (long)((unsigned)size/DEV_BSIZE), 0)) + return(NULL); +#endif if (bpref >= fs->fs_size) bpref = 0; if (bpref == 0) cg = itog(fs, ip->i_number); else cg = dtog(fs, bpref); - bno = (daddr_t)hashalloc(dev, fs, cg, (long)bpref, size, alloccg); - if (bno == 0) + bno = (daddr_t)hashalloc(ip, cg, (long)bpref, size, + (u_long (*)())alloccg); + if (bno <= 0) goto nospace; - bp = getblk(dev, fsbtodb(fs, bno), size); + bp = getblk(ip->i_dev, fsbtodb(fs, bno), size); clrbuf(bp); return (bp); nospace: @@ -92,57 +97,66 @@ nospace: * invoked to get an appropriate block. */ struct buf * -realloccg(dev, bprev, bpref, osize, nsize) - dev_t dev; +realloccg(ip, bprev, bpref, osize, nsize) + register struct inode *ip; daddr_t bprev, bpref; int osize, nsize; { daddr_t bno; register struct fs *fs; register struct buf *bp, *obp; - caddr_t cp; int cg; - fs = getfs(dev); - if ((unsigned)osize > fs->fs_bsize || osize % fs->fs_fsize != 0 || - (unsigned)nsize > fs->fs_bsize || nsize % fs->fs_fsize != 0) + fs = ip->i_fs; + if ((unsigned)osize > fs->fs_bsize || fragoff(fs, osize) != 0 || + (unsigned)nsize > fs->fs_bsize || fragoff(fs, nsize) != 0) { + printf("dev = 0x%x, bsize = %d, osize = %d, nsize = %d, fs = %s\n", + ip->i_dev, fs->fs_bsize, osize, nsize, fs->fs_fsmnt); panic("realloccg: bad size"); + } if (u.u_uid != 0 && fs->fs_cstotal.cs_nbfree * fs->fs_frag + fs->fs_cstotal.cs_nffree < fs->fs_dsize * fs->fs_minfree / 100) goto nospace; - if (bprev != 0) - cg = dtog(fs, bprev); - else + if (bprev == 0) { + printf("dev = 0x%x, bsize = %d, bprev = %d, fs = %s\n", + ip->i_dev, fs->fs_bsize, bprev, fs->fs_fsmnt); panic("realloccg: bad bprev"); - bno = fragextend(dev, fs, cg, (long)bprev, osize, nsize); + } +#ifdef QUOTA + if (chkdq(ip, (long)((unsigned)(nsize-osize)/DEV_BSIZE), 0)) + return(NULL); +#endif + cg = dtog(fs, bprev); + bno = fragextend(ip, cg, (long)bprev, osize, nsize); if (bno != 0) { - bp = bread(dev, fsbtodb(fs, bno), osize); - if (bp->b_flags & B_ERROR) - return (0); - bp->b_bcount = nsize; - blkclr(bp->b_un.b_addr + osize, nsize - osize); + do { + bp = bread(ip->i_dev, fsbtodb(fs, bno), osize); + if (bp->b_flags & B_ERROR) { + brelse(bp); + return (NULL); + } + } while (brealloc(bp, nsize) == 0); + bp->b_flags |= B_DONE; + bzero(bp->b_un.b_addr + osize, (unsigned)nsize - osize); return (bp); } if (bpref >= fs->fs_size) bpref = 0; - bno = (daddr_t)hashalloc(dev, fs, cg, (long)bpref, nsize, alloccg); - if (bno != 0) { - /* - * make a new copy - */ - obp = bread(dev, fsbtodb(fs, bprev), osize); - if (obp->b_flags & B_ERROR) - return (0); - bp = getblk(dev, fsbtodb(fs, bno), nsize); - cp = bp->b_un.b_addr; - bp->b_un.b_addr = obp->b_un.b_addr; - obp->b_un.b_addr = cp; - obp->b_flags |= B_INVAL; + bno = (daddr_t)hashalloc(ip, cg, (long)bpref, nsize, + (u_long (*)())alloccg); + if (bno > 0) { + obp = bread(ip->i_dev, fsbtodb(fs, bprev), osize); + if (obp->b_flags & B_ERROR) { + brelse(obp); + return (NULL); + } + bp = getblk(ip->i_dev, fsbtodb(fs, bno), nsize); + bcopy(obp->b_un.b_addr, bp->b_un.b_addr, (u_int)osize); + bzero(bp->b_un.b_addr + osize, (unsigned)nsize - osize); brelse(obp); - fre(dev, bprev, (off_t)osize); - blkclr(bp->b_un.b_addr + osize, nsize - osize); - return(bp); + free(ip, bprev, (off_t)osize); + return (bp); } nospace: /* @@ -170,8 +184,8 @@ nospace: * available inode is located. */ struct inode * -ialloc(dev, ipref, mode) - dev_t dev; +ialloc(pip, ipref, mode) + register struct inode *pip; ino_t ipref; int mode; { @@ -180,26 +194,33 @@ ialloc(dev, ipref, mode) register struct inode *ip; int cg; - fs = getfs(dev); + fs = pip->i_fs; if (fs->fs_cstotal.cs_nifree == 0) goto noinodes; +#ifdef QUOTA + if (chkiq(pip->i_dev, (struct inode *)NULL, u.u_uid, 0)) + return(NULL); +#endif if (ipref >= fs->fs_ncg * fs->fs_ipg) ipref = 0; cg = itog(fs, ipref); - ino = (ino_t)hashalloc(dev, fs, cg, (long)ipref, mode, ialloccg); + ino = (ino_t)hashalloc(pip, cg, (long)ipref, mode, ialloccg); if (ino == 0) goto noinodes; - ip = iget(dev, ino); + ip = iget(pip->i_dev, pip->i_fs, ino); if (ip == NULL) { - ifree(dev, ino, 0); + ifree(ip, ino, 0); return (NULL); } - if (ip->i_mode) + if (ip->i_mode) { + printf("mode = 0%o, inum = %d, fs = %s\n", + ip->i_mode, ip->i_number, fs->fs_fsmnt); panic("ialloc: dup alloc"); + } return (ip); noinodes: fserr(fs, "out of inodes"); - uprintf("\n%s: create failed, no inodes free\n", fs->fs_fsmnt); + uprintf("\n%s: create/symlink failed, no inodes free\n", fs->fs_fsmnt); u.u_error = ENOSPC; return (NULL); } @@ -211,13 +232,12 @@ noinodes: * among those cylinder groups with above the average number of * free inodes, the one with the smallest number of directories. */ -dirpref(dev) - dev_t dev; -{ +ino_t +dirpref(fs) register struct fs *fs; +{ int cg, minndir, mincg, avgifree; - fs = getfs(dev); avgifree = fs->fs_cstotal.cs_nifree / fs->fs_ncg; minndir = fs->fs_ipg; mincg = 0; @@ -227,37 +247,85 @@ dirpref(dev) mincg = cg; minndir = fs->fs_cs(fs, cg).cs_ndir; } - return (fs->fs_ipg * mincg); + return ((ino_t)(fs->fs_ipg * mincg)); } /* - * Select a cylinder to place a large block of data. - * - * The policy implemented by this algorithm is to maintain a - * rotor that sweeps the cylinder groups. When a block is - * needed, the rotor is advanced until a cylinder group with - * greater than the average number of free blocks is found. + * Select the desired position for the next block in a file. The file is + * logically divided into sections. The first section is composed of the + * direct blocks. Each additional section contains fs_maxbpg blocks. + * + * If no blocks have been allocated in the first section, the policy is to + * request a block in the same cylinder group as the inode that describes + * the file. If no blocks have been allocated in any other section, the + * policy is to place the section in a cylinder group with a greater than + * average number of free blocks. An appropriate cylinder group is found + * by maintaining a rotor that sweeps the cylinder groups. When a new + * group of blocks is needed, the rotor is advanced until a cylinder group + * with greater than the average number of free blocks is found. + * + * If a section is already partially allocated, the policy is to + * contiguously allocate fs_maxcontig blocks. The end of one of these + * contiguous blocks and the beginning of the next is physically separated + * so that the disk head will be in transit between them for at least + * fs_rotdelay milliseconds. This is to allow time for the processor to + * schedule another I/O transfer. */ daddr_t -blkpref(dev) - dev_t dev; +blkpref(ip, lbn, indx, bap) + struct inode *ip; + daddr_t lbn; + int indx; + daddr_t *bap; { register struct fs *fs; int cg, avgbfree; + daddr_t nextblk; - fs = getfs(dev); - avgbfree = fs->fs_cstotal.cs_nbfree / fs->fs_ncg; - for (cg = fs->fs_cgrotor + 1; cg < fs->fs_ncg; cg++) - if (fs->fs_cs(fs, cg).cs_nbfree >= avgbfree) { - fs->fs_cgrotor = cg; + fs = ip->i_fs; + if (indx % fs->fs_maxbpg == 0 || bap[indx - 1] == 0) { + if (lbn < NDADDR) { + cg = itog(fs, ip->i_number); return (fs->fs_fpg * cg + fs->fs_frag); } - for (cg = 0; cg <= fs->fs_cgrotor; cg++) - if (fs->fs_cs(fs, cg).cs_nbfree >= avgbfree) { - fs->fs_cgrotor = cg; - return (fs->fs_fpg * cg + fs->fs_frag); - } - return (0); + /* + * Find a cylinder with greater than average number of + * unused data blocks. + */ + avgbfree = fs->fs_cstotal.cs_nbfree / fs->fs_ncg; + for (cg = fs->fs_cgrotor + 1; cg < fs->fs_ncg; cg++) + if (fs->fs_cs(fs, cg).cs_nbfree >= avgbfree) { + fs->fs_cgrotor = cg; + return (fs->fs_fpg * cg + fs->fs_frag); + } + for (cg = 0; cg <= fs->fs_cgrotor; cg++) + if (fs->fs_cs(fs, cg).cs_nbfree >= avgbfree) { + fs->fs_cgrotor = cg; + return (fs->fs_fpg * cg + fs->fs_frag); + } + return (NULL); + } + /* + * One or more previous blocks have been laid out. If less + * than fs_maxcontig previous blocks are contiguous, the + * next block is requested contiguously, otherwise it is + * requested rotationally delayed by fs_rotdelay milliseconds. + */ + nextblk = bap[indx - 1] + fs->fs_frag; + if (indx > fs->fs_maxcontig && + bap[indx - fs->fs_maxcontig] + fs->fs_frag * fs->fs_maxcontig + != nextblk) + return (nextblk); + if (fs->fs_rotdelay != 0) + /* + * Here we convert ms of delay to frags as: + * (frags) = (ms) * (rev/sec) * (sect/rev) / + * ((sect/frag) * (ms/sec)) + * then round up to the next block. + */ + nextblk += roundup(fs->fs_rotdelay * fs->fs_rps * fs->fs_nsect / + (NSPF(fs) * 1000), fs->fs_frag); + return (nextblk); } /* @@ -270,21 +338,22 @@ blkpref(dev) */ /*VARARGS5*/ u_long -hashalloc(dev, fs, cg, pref, size, allocator) - dev_t dev; - register struct fs *fs; +hashalloc(ip, cg, pref, size, allocator) + struct inode *ip; int cg; long pref; int size; /* size for data blocks, mode for inodes */ u_long (*allocator)(); { + register struct fs *fs; long result; int i, icg = cg; + fs = ip->i_fs; /* * 1: preferred cylinder group */ - result = (*allocator)(dev, fs, cg, pref, size); + result = (*allocator)(ip, cg, pref, size); if (result) return (result); /* @@ -294,23 +363,25 @@ hashalloc(dev, fs, cg, pref, size, allocator) cg += i; if (cg >= fs->fs_ncg) cg -= fs->fs_ncg; - result = (*allocator)(dev, fs, cg, 0, size); + result = (*allocator)(ip, cg, 0, size); if (result) return (result); } /* * 3: brute force search + * Note that we start at i == 2, since 0 was checked initially, + * and 1 is always checked in the quadratic rehash. */ cg = icg; - for (i = 0; i < fs->fs_ncg; i++) { - result = (*allocator)(dev, fs, cg, 0, size); + for (i = 2; i < fs->fs_ncg; i++) { + result = (*allocator)(ip, cg, 0, size); if (result) return (result); cg++; if (cg == fs->fs_ncg) cg = 0; } - return (0); + return (NULL); } /* @@ -320,34 +391,40 @@ hashalloc(dev, fs, cg, pref, size, allocator) * if they are, allocate them. */ daddr_t -fragextend(dev, fs, cg, bprev, osize, nsize) - dev_t dev; - register struct fs *fs; +fragextend(ip, cg, bprev, osize, nsize) + struct inode *ip; int cg; long bprev; int osize, nsize; { + register struct fs *fs; register struct buf *bp; register struct cg *cgp; long bno; int frags, bbase; int i; - frags = nsize / fs->fs_fsize; - bbase = bprev % fs->fs_frag; + fs = ip->i_fs; + if (fs->fs_cs(fs, cg).cs_nffree < nsize - osize) + return (NULL); + frags = numfrags(fs, nsize); + bbase = fragoff(fs, bprev); if (bbase > (bprev + frags - 1) % fs->fs_frag) { /* cannot extend across a block boundry */ - return (0); + return (NULL); } - bp = bread(dev, fsbtodb(fs, cgtod(fs, cg)), fs->fs_bsize); - if (bp->b_flags & B_ERROR) - return (0); + bp = bread(ip->i_dev, fsbtodb(fs, cgtod(fs, cg)), (int)fs->fs_cgsize); cgp = bp->b_un.b_cg; + if (bp->b_flags & B_ERROR || cgp->cg_magic != CG_MAGIC) { + brelse(bp); + return (NULL); + } + cgp->cg_time = time.tv_sec; bno = dtogd(fs, bprev); - for (i = osize / fs->fs_fsize; i < frags; i++) + for (i = numfrags(fs, osize); i < frags; i++) if (isclr(cgp->cg_free, bno + i)) { brelse(bp); - return (0); + return (NULL); } /* * the current fragment can be extended @@ -358,10 +435,10 @@ fragextend(dev, fs, cg, bprev, osize, nsize) for (i = frags; i < fs->fs_frag - bbase; i++) if (isclr(cgp->cg_free, bno + i)) break; - cgp->cg_frsum[i - osize / fs->fs_fsize]--; + cgp->cg_frsum[i - numfrags(fs, osize)]--; if (i != frags) cgp->cg_frsum[i - frags]++; - for (i = osize / fs->fs_fsize; i < frags; i++) { + for (i = numfrags(fs, osize); i < frags; i++) { clrbit(cgp->cg_free, bno + i); cgp->cg_cs.cs_nffree--; fs->fs_cstotal.cs_nffree--; @@ -379,25 +456,31 @@ fragextend(dev, fs, cg, bprev, osize, nsize) * and if it is, allocate it. */ daddr_t -alloccg(dev, fs, cg, bpref, size) - dev_t dev; - register struct fs *fs; +alloccg(ip, cg, bpref, size) + struct inode *ip; int cg; daddr_t bpref; int size; { + register struct fs *fs; register struct buf *bp; register struct cg *cgp; int bno, frags; int allocsiz; register int i; + fs = ip->i_fs; if (fs->fs_cs(fs, cg).cs_nbfree == 0 && size == fs->fs_bsize) - return (0); - bp = bread(dev, fsbtodb(fs, cgtod(fs, cg)), fs->fs_bsize); - if (bp->b_flags & B_ERROR) - return (0); + return (NULL); + bp = bread(ip->i_dev, fsbtodb(fs, cgtod(fs, cg)), (int)fs->fs_cgsize); cgp = bp->b_un.b_cg; + if (bp->b_flags & B_ERROR || cgp->cg_magic != CG_MAGIC) { + brelse(bp); + return (NULL); + } + if (cgp->cg_cs.cs_nbfree == 0 && size == fs->fs_bsize) + return (NULL); + cgp->cg_time = time.tv_sec; if (size == fs->fs_bsize) { bno = alloccgblk(fs, cgp, bpref); bdwrite(bp); @@ -408,7 +491,7 @@ alloccg(dev, fs, cg, bpref, size) * allocsiz is the size which will be allocated, hacking * it down to a smaller size if necessary */ - frags = size / fs->fs_fsize; + frags = numfrags(fs, size); for (allocsiz = frags; allocsiz < fs->fs_frag; allocsiz++) if (cgp->cg_frsum[allocsiz] != 0) break; @@ -419,7 +502,7 @@ alloccg(dev, fs, cg, bpref, size) */ if (cgp->cg_cs.cs_nbfree == 0) { brelse(bp); - return (0); + return (NULL); } bno = alloccgblk(fs, cgp, bpref); bpref = dtogd(fs, bno); @@ -429,18 +512,20 @@ alloccg(dev, fs, cg, bpref, size) cgp->cg_cs.cs_nffree += i; fs->fs_cstotal.cs_nffree += i; fs->fs_cs(fs, cg).cs_nffree += i; + fs->fs_fmod++; cgp->cg_frsum[i]++; bdwrite(bp); return (bno); } bno = mapsearch(fs, cgp, bpref, allocsiz); - if (bno == 0) - return (0); + if (bno < 0) + return (NULL); for (i = 0; i < frags; i++) clrbit(cgp->cg_free, bno + i); cgp->cg_cs.cs_nffree -= frags; fs->fs_cstotal.cs_nffree -= frags; fs->fs_cs(fs, cg).cs_nffree -= frags; + fs->fs_fmod++; cgp->cg_frsum[allocsiz]--; if (frags != allocsiz) cgp->cg_frsum[allocsiz - frags]++; @@ -461,12 +546,12 @@ alloccg(dev, fs, cg, bpref, size) */ daddr_t alloccgblk(fs, cgp, bpref) - struct fs *fs; + register struct fs *fs; register struct cg *cgp; daddr_t bpref; { daddr_t bno; - int cylno, pos; + int cylno, pos, delta; short *cylbp; register int i; @@ -497,29 +582,13 @@ alloccgblk(fs, cgp, bpref) bpref = howmany(fs->fs_spc * cylno, NSPF(fs)); goto norot; } - /* - * find a block that is rotationally optimal - */ - cylbp = cgp->cg_b[cylno]; - if (fs->fs_rotdelay == 0) { - pos = cbtorpos(fs, bpref); - } else { - /* - * here we convert ms of delay to frags as: - * (frags) = (ms) * (rev/sec) * (sect/rev) / - * ((sect/frag) * (ms/sec)) - * then round up to the next rotational position - */ - bpref += fs->fs_rotdelay * fs->fs_rps * fs->fs_nsect / - (NSPF(fs) * 1000); - pos = cbtorpos(fs, bpref); - pos = (pos + 1) % NRPOS; - } /* * check the summary information to see if a block is * available in the requested cylinder starting at the - * optimal rotational position and proceeding around. + * requested rotational position and proceeding around. */ + cylbp = cgp->cg_b[cylno]; + pos = cbtorpos(fs, bpref); for (i = pos; i < NRPOS; i++) if (cylbp[i] > 0) break; @@ -534,16 +603,22 @@ alloccgblk(fs, cgp, bpref) */ pos = cylno % fs->fs_cpc; bno = (cylno - pos) * fs->fs_spc / NSPB(fs); - if (fs->fs_postbl[pos][i] == -1) + if (fs->fs_postbl[pos][i] == -1) { + printf("pos = %d, i = %d, fs = %s\n", + pos, i, fs->fs_fsmnt); panic("alloccgblk: cyl groups corrupted"); - for (i = fs->fs_postbl[pos][i]; ; i += fs->fs_rotbl[i]) { + } + for (i = fs->fs_postbl[pos][i];; ) { if (isblock(fs, cgp->cg_free, bno + i)) { bno = (bno + i) * fs->fs_frag; goto gotit; } - if (fs->fs_rotbl[i] == 0) + delta = fs->fs_rotbl[i]; + if (delta <= 0 || delta > MAXBPC - i) break; + i += delta; } + printf("pos = %d, i = %d, fs = %s\n", pos, i, fs->fs_fsmnt); panic("alloccgblk: can't find blk in cyl"); } norot: @@ -551,12 +626,12 @@ norot: * no blocks in the requested cylinder, so take next * available one in this cylinder group. */ - bno = mapsearch(fs, cgp, bpref, fs->fs_frag); - if (bno == 0) - return (0); + bno = mapsearch(fs, cgp, bpref, (int)fs->fs_frag); + if (bno < 0) + return (NULL); cgp->cg_rotor = bno; gotit: - clrblock(fs, cgp->cg_free, bno/fs->fs_frag); + clrblock(fs, cgp->cg_free, (long)(bno/fs->fs_frag)); cgp->cg_cs.cs_nbfree--; fs->fs_cstotal.cs_nbfree--; fs->fs_cs(fs, cgp->cg_cgx).cs_nbfree--; @@ -577,23 +652,29 @@ gotit: * inode in the specified cylinder group. */ ino_t -ialloccg(dev, fs, cg, ipref, mode) - dev_t dev; - register struct fs *fs; +ialloccg(ip, cg, ipref, mode) + struct inode *ip; int cg; daddr_t ipref; int mode; { + register struct fs *fs; register struct buf *bp; register struct cg *cgp; int i; + fs = ip->i_fs; if (fs->fs_cs(fs, cg).cs_nifree == 0) - return (0); - bp = bread(dev, fsbtodb(fs, cgtod(fs, cg)), fs->fs_bsize); - if (bp->b_flags & B_ERROR) - return (0); + return (NULL); + bp = bread(ip->i_dev, fsbtodb(fs, cgtod(fs, cg)), (int)fs->fs_cgsize); cgp = bp->b_un.b_cg; + if (bp->b_flags & B_ERROR || cgp->cg_magic != CG_MAGIC) { + brelse(bp); + return (NULL); + } + if (cgp->cg_cs.cs_nifree == 0) + return (NULL); + cgp->cg_time = time.tv_sec; if (ipref) { ipref %= fs->fs_ipg; if (isclr(cgp->cg_iused, ipref)) @@ -610,7 +691,7 @@ ialloccg(dev, fs, cg, ipref, mode) } } brelse(bp); - return (0); + return (NULL); gotit: setbit(cgp->cg_iused, ipref); cgp->cg_cs.cs_nifree--; @@ -633,8 +714,8 @@ gotit: * free map. If a fragment is deallocated, a possible * block reassembly is checked. */ -fre(dev, bno, size) - dev_t dev; +free(ip, bno, size) + register struct inode *ip; daddr_t bno; off_t size; { @@ -644,20 +725,31 @@ fre(dev, bno, size) int cg, blk, frags, bbase; register int i; - fs = getfs(dev); - if ((unsigned)size > fs->fs_bsize || size % fs->fs_fsize != 0) + fs = ip->i_fs; + if ((unsigned)size > fs->fs_bsize || fragoff(fs, size) != 0) { + printf("dev = 0x%x, bsize = %d, size = %d, fs = %s\n", + ip->i_dev, fs->fs_bsize, size, fs->fs_fsmnt); panic("free: bad size"); + } cg = dtog(fs, bno); - if (badblock(fs, bno)) - return; - bp = bread(dev, fsbtodb(fs, cgtod(fs, cg)), fs->fs_bsize); - if (bp->b_flags & B_ERROR) + if (badblock(fs, bno)) { + printf("bad block %d, ino %d\n", bno, ip->i_number); return; + } + bp = bread(ip->i_dev, fsbtodb(fs, cgtod(fs, cg)), (int)fs->fs_cgsize); cgp = bp->b_un.b_cg; + if (bp->b_flags & B_ERROR || cgp->cg_magic != CG_MAGIC) { + brelse(bp); + return; + } + cgp->cg_time = time.tv_sec; bno = dtogd(fs, bno); if (size == fs->fs_bsize) { - if (isblock(fs, cgp->cg_free, bno/fs->fs_frag)) + if (isblock(fs, cgp->cg_free, bno/fs->fs_frag)) { + printf("dev = 0x%x, block = %d, fs = %s\n", + ip->i_dev, bno, fs->fs_fsmnt); panic("free: freeing free block"); + } setblock(fs, cgp->cg_free, bno/fs->fs_frag); cgp->cg_cs.cs_nbfree++; fs->fs_cstotal.cs_nbfree++; @@ -670,26 +762,27 @@ fre(dev, bno, size) /* * decrement the counts associated with the old frags */ - blk = ((cgp->cg_free[bbase / NBBY] >> (bbase % NBBY)) & - (0xff >> (NBBY - fs->fs_frag))); + blk = blkmap(fs, cgp->cg_free, bbase); fragacct(fs, blk, cgp->cg_frsum, -1); /* * deallocate the fragment */ - frags = size / fs->fs_fsize; + frags = numfrags(fs, size); for (i = 0; i < frags; i++) { - if (isset(cgp->cg_free, bno + i)) + if (isset(cgp->cg_free, bno + i)) { + printf("dev = 0x%x, block = %d, fs = %s\n", + ip->i_dev, bno + i, fs->fs_fsmnt); panic("free: freeing free frag"); + } setbit(cgp->cg_free, bno + i); - cgp->cg_cs.cs_nffree++; - fs->fs_cstotal.cs_nffree++; - fs->fs_cs(fs, cg).cs_nffree++; } + cgp->cg_cs.cs_nffree += i; + fs->fs_cstotal.cs_nffree += i; + fs->fs_cs(fs, cg).cs_nffree += i; /* * add back in counts associated with the new frags */ - blk = ((cgp->cg_free[bbase / NBBY] >> (bbase % NBBY)) & - (0xff >> (NBBY - fs->fs_frag))); + blk = blkmap(fs, cgp->cg_free, bbase); fragacct(fs, blk, cgp->cg_frsum, 1); /* * if a complete block has been reassembled, account for it @@ -715,8 +808,8 @@ fre(dev, bno, size) * * The specified inode is placed back in the free map. */ -ifree(dev, ino, mode) - dev_t dev; +ifree(ip, ino, mode) + struct inode *ip; ino_t ino; int mode; { @@ -725,17 +818,26 @@ ifree(dev, ino, mode) register struct buf *bp; int cg; - fs = getfs(dev); - if ((unsigned)ino >= fs->fs_ipg*fs->fs_ncg) + fs = ip->i_fs; + if ((unsigned)ino >= fs->fs_ipg*fs->fs_ncg) { + printf("dev = 0x%x, ino = %d, fs = %s\n", + ip->i_dev, ino, fs->fs_fsmnt); panic("ifree: range"); + } cg = itog(fs, ino); - bp = bread(dev, fsbtodb(fs, cgtod(fs, cg)), fs->fs_bsize); - if (bp->b_flags & B_ERROR) - return; + bp = bread(ip->i_dev, fsbtodb(fs, cgtod(fs, cg)), (int)fs->fs_cgsize); cgp = bp->b_un.b_cg; + if (bp->b_flags & B_ERROR || cgp->cg_magic != CG_MAGIC) { + brelse(bp); + return; + } + cgp->cg_time = time.tv_sec; ino %= fs->fs_ipg; - if (isclr(cgp->cg_iused, ino)) + if (isclr(cgp->cg_iused, ino)) { + printf("dev = 0x%x, ino = %d, fs = %s\n", + ip->i_dev, ino, fs->fs_fsmnt); panic("ifree: freeing free inode"); + } clrbit(cgp->cg_iused, ino); cgp->cg_cs.cs_nifree++; fs->fs_cstotal.cs_nifree++; @@ -774,18 +876,16 @@ mapsearch(fs, cgp, bpref, allocsiz) start = dtogd(fs, bpref) / NBBY; else start = cgp->cg_frotor / NBBY; - len = roundup(fs->fs_fpg - 1, NBBY) / NBBY - start; + len = howmany(fs->fs_fpg, NBBY) - start; loc = scanc(len, &cgp->cg_free[start], fragtbl[fs->fs_frag], - 1 << (allocsiz - 1)); + 1 << (allocsiz - 1 + (fs->fs_frag % NBBY))); if (loc == 0) { - len = start - 1; - start = fs->fs_dblkno / NBBY; + len = start + 1; + start = 0; loc = scanc(len, &cgp->cg_free[start], fragtbl[fs->fs_frag], - 1 << (allocsiz - 1)); - if (loc == 0) { - panic("alloccg: map corrupted"); - return (0); - } + 1 << (allocsiz - 1 + (fs->fs_frag % NBBY))); + if (loc == 0) + return (-1); } bno = (start + len - loc) * NBBY; cgp->cg_frotor = bno; @@ -793,98 +893,21 @@ mapsearch(fs, cgp, bpref, allocsiz) * found the byte in the map * sift through the bits to find the selected frag */ - for (i = 0; i < NBBY; i += fs->fs_frag) { - blk = (cgp->cg_free[bno / NBBY] >> i) & - (0xff >> NBBY - fs->fs_frag); + for (i = bno + NBBY; bno < i; bno += fs->fs_frag) { + blk = blkmap(fs, cgp->cg_free, bno); blk <<= 1; field = around[allocsiz]; subfield = inside[allocsiz]; for (pos = 0; pos <= fs->fs_frag - allocsiz; pos++) { - if ((blk & field) == subfield) { - return (bno + i + pos); - } + if ((blk & field) == subfield) + return (bno + pos); field <<= 1; subfield <<= 1; } } + printf("bno = %d, fs = %s\n", bno, fs->fs_fsmnt); panic("alloccg: block not in map"); - return (0); -} - -/* - * Update the frsum fields to reflect addition or deletion - * of some frags. - */ -fragacct(fs, fragmap, fraglist, cnt) - struct fs *fs; - int fragmap; - long fraglist[]; - int cnt; -{ - int inblk; - register int field, subfield; - register int siz, pos; - - inblk = (int)(fragtbl[fs->fs_frag][fragmap]) << 1; - fragmap <<= 1; - for (siz = 1; siz < fs->fs_frag; siz++) { - if (((1 << siz) & inblk) == 0) - continue; - field = around[siz]; - subfield = inside[siz]; - for (pos = siz; pos <= fs->fs_frag; pos++) { - if ((fragmap & field) == subfield) { - fraglist[siz] += cnt; - pos += siz; - field <<= siz; - subfield <<= siz; - } - field <<= 1; - subfield <<= 1; - } - } -} - -/* - * Check that a specified block number is in range. - */ -badblock(fs, bn) - register struct fs *fs; - daddr_t bn; -{ - - if ((unsigned)bn >= fs->fs_size || bn < cgdmin(fs, dtog(fs, bn))) { - fserr(fs, "bad block"); - return (1); - } - return (0); -} - -/* - * Getfs maps a device number into a pointer to the incore super block. - * - * The algorithm is a linear search through the mount table. A - * consistency check of the super block magic number is performed. - * - * panic: no fs -- the device is not mounted. - * this "cannot happen" - */ -struct fs * -getfs(dev) - dev_t dev; -{ - register struct mount *mp; - register struct fs *fs; - - for (mp = &mount[0]; mp < &mount[NMOUNT]; mp++) - if (mp->m_bufp != NULL && mp->m_dev == dev) { - fs = mp->m_bufp->b_un.b_fs; - if (fs->fs_magic != FS_MAGIC) - panic("getfs: bad magic"); - return (fs); - } - panic("getfs: no fs"); - return (NULL); + return (-1); } /* @@ -900,175 +923,3 @@ fserr(fs, cp) printf("%s: %s\n", fs->fs_fsmnt, cp); } - -/* - * Getfsx returns the index in the file system - * table of the specified device. The swap device - * is also assigned a pseudo-index. The index may - * be used as a compressed indication of the location - * of a block, recording - * - * rather than - * - * provided the information need remain valid only - * as long as the file system is mounted. - */ -getfsx(dev) - dev_t dev; -{ - register struct mount *mp; - - if (dev == swapdev) - return (MSWAPX); - for(mp = &mount[0]; mp < &mount[NMOUNT]; mp++) - if (mp->m_dev == dev) - return (mp - &mount[0]); - return (-1); -} - -/* - * Update is the internal name of 'sync'. It goes through the disk - * queues to initiate sandbagged IO; goes through the inodes to write - * modified nodes; and it goes through the mount table to initiate - * the writing of the modified super blocks. - */ -update() -{ - register struct inode *ip; - register struct mount *mp; - register struct buf *bp; - struct fs *fs; - time_t tim; - int i, blks; - - if (updlock) - return; - updlock++; - /* - * Write back modified superblocks. - * Consistency check that the superblock - * of each file system is still in the buffer cache. - */ - for (mp = &mount[0]; mp < &mount[NMOUNT]; mp++) - if (mp->m_bufp != NULL) { - fs = mp->m_bufp->b_un.b_fs; - if (fs->fs_fmod == 0) - continue; - if (fs->fs_ronly != 0) - panic("update: rofs mod"); - bp = getblk(mp->m_dev, SBLOCK, SBSIZE); - fs->fs_fmod = 0; - fs->fs_time = TIME; - if (bp->b_un.b_fs != fs) - panic("update: bad b_fs"); - bwrite(bp); - blks = howmany(fs->fs_cssize, fs->fs_bsize); - for (i = 0; i < blks; i++) { - bp = getblk(mp->m_dev, - fsbtodb(fs, fs->fs_csaddr + (i * fs->fs_frag)), - fs->fs_bsize); - bwrite(bp); - } - } - /* - * Write back each (modified) inode. - */ - for (ip = inode; ip < inodeNINODE; ip++) - if((ip->i_flag&ILOCK)==0 && ip->i_count) { - ip->i_flag |= ILOCK; - ip->i_count++; - tim = TIME; - iupdat(ip, &tim, &tim, 0); - iput(ip); - } - updlock = 0; - /* - * Force stale buffer cache information to be flushed, - * for all devices. - */ - bflush(NODEV); -} - -/* - * block operations - * - * check if a block is available - */ -isblock(fs, cp, h) - struct fs *fs; - unsigned char *cp; - int h; -{ - unsigned char mask; - - switch (fs->fs_frag) { - case 8: - return (cp[h] == 0xff); - case 4: - mask = 0x0f << ((h & 0x1) << 2); - return ((cp[h >> 1] & mask) == mask); - case 2: - mask = 0x03 << ((h & 0x3) << 1); - return ((cp[h >> 2] & mask) == mask); - case 1: - mask = 0x01 << (h & 0x7); - return ((cp[h >> 3] & mask) == mask); - default: - panic("isblock bad fs_frag"); - return; - } -} - -/* - * take a block out of the map - */ -clrblock(fs, cp, h) - struct fs *fs; - unsigned char *cp; - int h; -{ - switch ((fs)->fs_frag) { - case 8: - cp[h] = 0; - return; - case 4: - cp[h >> 1] &= ~(0x0f << ((h & 0x1) << 2)); - return; - case 2: - cp[h >> 2] &= ~(0x03 << ((h & 0x3) << 1)); - return; - case 1: - cp[h >> 3] &= ~(0x01 << (h & 0x7)); - return; - default: - panic("clrblock bad fs_frag"); - return; - } -} - -/* - * put a block into the map - */ -setblock(fs, cp, h) - struct fs *fs; - unsigned char *cp; - int h; -{ - switch (fs->fs_frag) { - case 8: - cp[h] = 0xff; - return; - case 4: - cp[h >> 1] |= (0x0f << ((h & 0x1) << 2)); - return; - case 2: - cp[h >> 2] |= (0x03 << ((h & 0x3) << 1)); - return; - case 1: - cp[h >> 3] |= (0x01 << (h & 0x7)); - return; - default: - panic("setblock bad fs_frag"); - return; - } -}