diff options
author | peter <peter@FreeBSD.org> | 1996-03-11 19:47:21 +0000 |
---|---|---|
committer | peter <peter@FreeBSD.org> | 1996-03-11 19:47:21 +0000 |
commit | e68f37c99a71bdc8513e41b7bd4bff8b8f99eed6 (patch) | |
tree | 57cf0305b3edba23195d4887dafbe7d19c0b7500 | |
parent | 73a498e93ef77f792f958b4a1ea0d9ad0490888a (diff) | |
download | FreeBSD-src-e68f37c99a71bdc8513e41b7bd4bff8b8f99eed6.zip FreeBSD-src-e68f37c99a71bdc8513e41b7bd4bff8b8f99eed6.tar.gz |
Import 4.4BSD-Lite2 onto the vendor branch, note that in the kernel, all
files are off the vendor branch, so this should not change anything.
A "U" marker generally means that the file was not changed in between
the 4.4Lite and Lite-2 releases, and does not need a merge. "C" generally
means that there was a change.
40 files changed, 2276 insertions, 1746 deletions
diff --git a/sys/ufs/ffs/ffs_alloc.c b/sys/ufs/ffs/ffs_alloc.c index cdd2e4b..35509e6 100644 --- a/sys/ufs/ffs/ffs_alloc.c +++ b/sys/ufs/ffs/ffs_alloc.c @@ -30,7 +30,7 @@ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. * - * @(#)ffs_alloc.c 8.8 (Berkeley) 2/21/94 + * @(#)ffs_alloc.c 8.18 (Berkeley) 5/26/95 */ #include <sys/param.h> @@ -52,16 +52,18 @@ extern u_long nextgennumber; -static daddr_t ffs_alloccg __P((struct inode *, int, daddr_t, int)); -static daddr_t ffs_alloccgblk __P((struct fs *, struct cg *, daddr_t)); -static daddr_t ffs_clusteralloc __P((struct inode *, int, daddr_t, int)); +static ufs_daddr_t ffs_alloccg __P((struct inode *, int, ufs_daddr_t, int)); +static ufs_daddr_t ffs_alloccgblk __P((struct fs *, struct cg *, ufs_daddr_t)); +static ufs_daddr_t ffs_clusteralloc __P((struct inode *, int, ufs_daddr_t, + int)); static ino_t ffs_dirpref __P((struct fs *)); -static daddr_t ffs_fragextend __P((struct inode *, int, long, int, int)); +static ufs_daddr_t ffs_fragextend __P((struct inode *, int, long, int, int)); static void ffs_fserr __P((struct fs *, u_int, char *)); static u_long ffs_hashalloc - __P((struct inode *, int, long, int, u_long (*)())); -static ino_t ffs_nodealloccg __P((struct inode *, int, daddr_t, int)); -static daddr_t ffs_mapsearch __P((struct fs *, struct cg *, daddr_t, int)); + __P((struct inode *, int, long, int, u_int32_t (*)())); +static ino_t ffs_nodealloccg __P((struct inode *, int, ufs_daddr_t, int)); +static ufs_daddr_t ffs_mapsearch __P((struct fs *, struct cg *, ufs_daddr_t, + int)); /* * Allocate a block in the file system. @@ -84,13 +86,13 @@ static daddr_t ffs_mapsearch __P((struct fs *, struct cg *, daddr_t, int)); */ ffs_alloc(ip, lbn, bpref, size, cred, bnp) register struct inode *ip; - daddr_t lbn, bpref; + ufs_daddr_t lbn, bpref; int size; struct ucred *cred; - daddr_t *bnp; + ufs_daddr_t *bnp; { register struct fs *fs; - daddr_t bno; + ufs_daddr_t bno; int cg, error; *bnp = 0; @@ -118,8 +120,8 @@ ffs_alloc(ip, lbn, bpref, size, cred, bnp) cg = ino_to_cg(fs, ip->i_number); else cg = dtog(fs, bpref); - bno = (daddr_t)ffs_hashalloc(ip, cg, (long)bpref, size, - (u_long (*)())ffs_alloccg); + bno = (ufs_daddr_t)ffs_hashalloc(ip, cg, (long)bpref, size, + (u_int32_t (*)())ffs_alloccg); if (bno > 0) { ip->i_blocks += btodb(size); ip->i_flag |= IN_CHANGE | IN_UPDATE; @@ -148,8 +150,8 @@ nospace: */ ffs_realloccg(ip, lbprev, bpref, osize, nsize, cred, bpp) register struct inode *ip; - daddr_t lbprev; - daddr_t bpref; + ufs_daddr_t lbprev; + ufs_daddr_t bpref; int osize, nsize; struct ucred *cred; struct buf **bpp; @@ -157,7 +159,7 @@ ffs_realloccg(ip, lbprev, bpref, osize, nsize, cred, bpp) register struct fs *fs; struct buf *bp; int cg, request, error; - daddr_t bprev, bno; + ufs_daddr_t bprev, bno; *bpp = 0; fs = ip->i_fs; @@ -255,8 +257,8 @@ ffs_realloccg(ip, lbprev, bpref, osize, nsize, cred, bpp) panic("ffs_realloccg: bad optim"); /* NOTREACHED */ } - bno = (daddr_t)ffs_hashalloc(ip, cg, (long)bpref, request, - (u_long (*)())ffs_alloccg); + bno = (ufs_daddr_t)ffs_hashalloc(ip, cg, (long)bpref, request, + (u_int32_t (*)())ffs_alloccg); if (bno > 0) { bp->b_blkno = fsbtodb(fs, bno); (void) vnode_pager_uncache(ITOV(ip)); @@ -302,9 +304,10 @@ nospace: * Note that the error return is not reflected back to the user. Rather * the previous block allocation will be used. */ -#include <sys/sysctl.h> int doasyncfree = 1; -struct ctldebug debug14 = { "doasyncfree", &doasyncfree }; +int doreallocblks = 1; +int prtrealloc = 0; + int ffs_reallocblks(ap) struct vop_reallocblks_args /* { @@ -316,12 +319,14 @@ ffs_reallocblks(ap) struct inode *ip; struct vnode *vp; struct buf *sbp, *ebp; - daddr_t *bap, *sbap, *ebap; + ufs_daddr_t *bap, *sbap, *ebap; struct cluster_save *buflist; - daddr_t start_lbn, end_lbn, soff, eoff, newblk, blkno; + ufs_daddr_t start_lbn, end_lbn, soff, eoff, newblk, blkno; struct indir start_ap[NIADDR + 1], end_ap[NIADDR + 1], *idp; int i, len, start_lvl, end_lvl, pref, ssize; + if (doreallocblks == 0) + return (ENOSPC); vp = ap->a_vp; ip = VTOI(vp); fs = ip->i_fs; @@ -332,9 +337,18 @@ ffs_reallocblks(ap) start_lbn = buflist->bs_children[0]->b_lblkno; end_lbn = start_lbn + len - 1; #ifdef DIAGNOSTIC + for (i = 0; i < len; i++) + if (!ffs_checkblk(ip, + dbtofsb(fs, buflist->bs_children[i]->b_blkno), fs->fs_bsize)) + panic("ffs_reallocblks: unallocated block 1"); for (i = 1; i < len; i++) if (buflist->bs_children[i]->b_lblkno != start_lbn + i) - panic("ffs_reallocblks: non-cluster"); + panic("ffs_reallocblks: non-logical cluster"); + blkno = buflist->bs_children[0]->b_blkno; + ssize = fsbtodb(fs, fs->fs_frag); + for (i = 1; i < len - 1; i++) + if (buflist->bs_children[i]->b_blkno != blkno + (i * ssize)) + panic("ffs_reallocblks: non-physical cluster %d", i); #endif /* * If the latest allocation is in a new cylinder group, assume that @@ -359,7 +373,7 @@ ffs_reallocblks(ap) brelse(sbp); return (ENOSPC); } - sbap = (daddr_t *)sbp->b_data; + sbap = (ufs_daddr_t *)sbp->b_data; soff = idp->in_off; } /* @@ -379,13 +393,13 @@ ffs_reallocblks(ap) ssize = len - (idp->in_off + 1); if (bread(vp, idp->in_lbn, (int)fs->fs_bsize, NOCRED, &ebp)) goto fail; - ebap = (daddr_t *)ebp->b_data; + ebap = (ufs_daddr_t *)ebp->b_data; } /* * Search the block map looking for an allocation of the desired size. */ - if ((newblk = (daddr_t)ffs_hashalloc(ip, dtog(fs, pref), (long)pref, - len, (u_long (*)())ffs_clusteralloc)) == 0) + if ((newblk = (ufs_daddr_t)ffs_hashalloc(ip, dtog(fs, pref), (long)pref, + len, (u_int32_t (*)())ffs_clusteralloc)) == 0) goto fail; /* * We have found a new contiguous block. @@ -394,14 +408,26 @@ ffs_reallocblks(ap) * block pointers in the inode and indirect blocks associated * with the file. */ +#ifdef DEBUG + if (prtrealloc) + printf("realloc: ino %d, lbns %d-%d\n\told:", ip->i_number, + start_lbn, end_lbn); +#endif blkno = newblk; for (bap = &sbap[soff], i = 0; i < len; i++, blkno += fs->fs_frag) { if (i == ssize) bap = ebap; #ifdef DIAGNOSTIC - if (buflist->bs_children[i]->b_blkno != fsbtodb(fs, *bap)) + if (!ffs_checkblk(ip, + dbtofsb(fs, buflist->bs_children[i]->b_blkno), fs->fs_bsize)) + panic("ffs_reallocblks: unallocated block 2"); + if (dbtofsb(fs, buflist->bs_children[i]->b_blkno) != *bap) panic("ffs_reallocblks: alloc mismatch"); #endif +#ifdef DEBUG + if (prtrealloc) + printf(" %d,", *bap); +#endif *bap++ = blkno; } /* @@ -436,11 +462,28 @@ ffs_reallocblks(ap) /* * Last, free the old blocks and assign the new blocks to the buffers. */ +#ifdef DEBUG + if (prtrealloc) + printf("\n\tnew:"); +#endif for (blkno = newblk, i = 0; i < len; i++, blkno += fs->fs_frag) { ffs_blkfree(ip, dbtofsb(fs, buflist->bs_children[i]->b_blkno), fs->fs_bsize); buflist->bs_children[i]->b_blkno = fsbtodb(fs, blkno); +#ifdef DEBUG + if (!ffs_checkblk(ip, + dbtofsb(fs, buflist->bs_children[i]->b_blkno), fs->fs_bsize)) + panic("ffs_reallocblks: unallocated block 3"); + if (prtrealloc) + printf(" %d,", blkno); +#endif } +#ifdef DEBUG + if (prtrealloc) { + prtrealloc--; + printf("\n"); + } +#endif return (0); fail: @@ -579,17 +622,17 @@ ffs_dirpref(fs) * fs_rotdelay milliseconds. This is to allow time for the processor to * schedule another I/O transfer. */ -daddr_t +ufs_daddr_t ffs_blkpref(ip, lbn, indx, bap) struct inode *ip; - daddr_t lbn; + ufs_daddr_t lbn; int indx; - daddr_t *bap; + ufs_daddr_t *bap; { register struct fs *fs; register int cg; int avgbfree, startcg; - daddr_t nextblk; + ufs_daddr_t nextblk; fs = ip->i_fs; if (indx % fs->fs_maxbpg == 0 || bap[indx - 1] == 0) { @@ -657,7 +700,7 @@ ffs_hashalloc(ip, cg, pref, size, allocator) int cg; long pref; int size; /* size for data blocks, mode for inodes */ - u_long (*allocator)(); + u_int32_t (*allocator)(); { register struct fs *fs; long result; @@ -704,7 +747,7 @@ ffs_hashalloc(ip, cg, pref, size, allocator) * Check to see if the necessary fragments are available, and * if they are, allocate them. */ -static daddr_t +static ufs_daddr_t ffs_fragextend(ip, cg, bprev, osize, nsize) struct inode *ip; int cg; @@ -774,11 +817,11 @@ ffs_fragextend(ip, cg, bprev, osize, nsize) * Check to see if a block of the appropriate size is available, * and if it is, allocate it. */ -static daddr_t +static ufs_daddr_t ffs_alloccg(ip, cg, bpref, size) struct inode *ip; int cg; - daddr_t bpref; + ufs_daddr_t bpref; int size; { register struct fs *fs; @@ -868,13 +911,13 @@ ffs_alloccg(ip, cg, bpref, size) * Note that this routine only allocates fs_bsize blocks; these * blocks may be fragmented by the routine that allocates them. */ -static daddr_t +static ufs_daddr_t ffs_alloccgblk(fs, cgp, bpref) register struct fs *fs; register struct cg *cgp; - daddr_t bpref; + ufs_daddr_t bpref; { - daddr_t bno, blkno; + ufs_daddr_t bno, blkno; int cylno, pos, delta; short *cylbp; register int i; @@ -892,13 +935,7 @@ ffs_alloccgblk(fs, cgp, bpref) bno = bpref; goto gotit; } - /* - * check for a block available on the same cylinder - */ - cylno = cbtocylno(fs, bpref); - if (cg_blktot(cgp)[cylno] == 0) - goto norot; - if (fs->fs_cpc == 0) { + if (fs->fs_nrpos <= 1 || fs->fs_cpc == 0) { /* * Block layout information is not available. * Leaving bpref unchanged means we take the @@ -910,6 +947,12 @@ ffs_alloccgblk(fs, cgp, bpref) goto norot; } /* + * check for a block available on the same cylinder + */ + cylno = cbtocylno(fs, bpref); + if (cg_blktot(cgp)[cylno] == 0) + goto norot; + /* * check the summary information to see if a block is * available in the requested cylinder starting at the * requested rotational position and proceeding around. @@ -979,21 +1022,22 @@ gotit: * are multiple choices in the same cylinder group. Instead we just * take the first one that we find following bpref. */ -static daddr_t +static ufs_daddr_t ffs_clusteralloc(ip, cg, bpref, len) struct inode *ip; int cg; - daddr_t bpref; + ufs_daddr_t bpref; int len; { register struct fs *fs; register struct cg *cgp; struct buf *bp; - int i, run, bno, bit, map; + int i, got, run, bno, bit, map; u_char *mapp; + int32_t *lp; fs = ip->i_fs; - if (fs->fs_cs(fs, cg).cs_nbfree < len) + if (fs->fs_maxcluster[cg] < len) return (NULL); if (bread(ip->i_devvp, fsbtodb(fs, cgtod(fs, cg)), (int)fs->fs_cgsize, NOCRED, &bp)) @@ -1005,11 +1049,25 @@ ffs_clusteralloc(ip, cg, bpref, len) * Check to see if a cluster of the needed size (or bigger) is * available in this cylinder group. */ + lp = &cg_clustersum(cgp)[len]; for (i = len; i <= fs->fs_contigsumsize; i++) - if (cg_clustersum(cgp)[i] > 0) + if (*lp++ > 0) break; - if (i > fs->fs_contigsumsize) + if (i > fs->fs_contigsumsize) { + /* + * This is the first time looking for a cluster in this + * cylinder group. Update the cluster summary information + * to reflect the true maximum sized cluster so that + * future cluster allocation requests can avoid reading + * the cylinder group map only to find no clusters. + */ + lp = &cg_clustersum(cgp)[len - 1]; + for (i = len - 1; i > 0; i--) + if (*lp-- > 0) + break; + fs->fs_maxcluster[cg] = i; goto fail; + } /* * Search the cluster map to find a big enough cluster. * We take the first one that we find, even if it is larger @@ -1028,7 +1086,7 @@ ffs_clusteralloc(ip, cg, bpref, len) mapp = &cg_clustersfree(cgp)[bpref / NBBY]; map = *mapp++; bit = 1 << (bpref % NBBY); - for (run = 0, i = bpref; i < cgp->cg_nclusterblks; i++) { + for (run = 0, got = bpref; got < cgp->cg_nclusterblks; got++) { if ((map & bit) == 0) { run = 0; } else { @@ -1036,22 +1094,27 @@ ffs_clusteralloc(ip, cg, bpref, len) if (run == len) break; } - if ((i & (NBBY - 1)) != (NBBY - 1)) { + if ((got & (NBBY - 1)) != (NBBY - 1)) { bit <<= 1; } else { map = *mapp++; bit = 1; } } - if (i == cgp->cg_nclusterblks) + if (got == cgp->cg_nclusterblks) goto fail; /* * Allocate the cluster that we have found. */ - bno = cg * fs->fs_fpg + blkstofrags(fs, i - run + 1); + for (i = 1; i <= len; i++) + if (!ffs_isblock(fs, cg_blksfree(cgp), got - run + i)) + panic("ffs_clusteralloc: map mismatch"); + bno = cg * fs->fs_fpg + blkstofrags(fs, got - run + 1); + if (dtog(fs, bno) != cg) + panic("ffs_clusteralloc: allocated out of group"); len = blkstofrags(fs, len); for (i = 0; i < len; i += fs->fs_frag) - if (ffs_alloccgblk(fs, cgp, bno + i) != bno + i) + if ((got = ffs_alloccgblk(fs, cgp, bno + i)) != bno + i) panic("ffs_clusteralloc: lost block"); brelse(bp); return (bno); @@ -1074,7 +1137,7 @@ static ino_t ffs_nodealloccg(ip, cg, ipref, mode) struct inode *ip; int cg; - daddr_t ipref; + ufs_daddr_t ipref; int mode; { register struct fs *fs; @@ -1152,13 +1215,13 @@ gotit: */ ffs_blkfree(ip, bno, size) register struct inode *ip; - daddr_t bno; + ufs_daddr_t bno; long size; { register struct fs *fs; register struct cg *cgp; struct buf *bp; - daddr_t blkno; + ufs_daddr_t blkno; int i, error, cg, blk, frags, bbase; fs = ip->i_fs; @@ -1249,6 +1312,56 @@ ffs_blkfree(ip, bno, size) bdwrite(bp); } +#ifdef DIAGNOSTIC +/* + * Verify allocation of a block or fragment. Returns true if block or + * fragment is allocated, false if it is free. + */ +ffs_checkblk(ip, bno, size) + struct inode *ip; + ufs_daddr_t bno; + long size; +{ + struct fs *fs; + struct cg *cgp; + struct buf *bp; + int i, error, frags, free; + + fs = ip->i_fs; + if ((u_int)size > fs->fs_bsize || fragoff(fs, size) != 0) { + printf("bsize = %d, size = %d, fs = %s\n", + fs->fs_bsize, size, fs->fs_fsmnt); + panic("checkblk: bad size"); + } + if ((u_int)bno >= fs->fs_size) + panic("checkblk: bad block %d", bno); + error = bread(ip->i_devvp, fsbtodb(fs, cgtod(fs, dtog(fs, bno))), + (int)fs->fs_cgsize, NOCRED, &bp); + if (error) { + brelse(bp); + return; + } + cgp = (struct cg *)bp->b_data; + if (!cg_chkmagic(cgp)) { + brelse(bp); + return; + } + bno = dtogd(fs, bno); + if (size == fs->fs_bsize) { + free = ffs_isblock(fs, cg_blksfree(cgp), fragstoblks(fs, bno)); + } else { + frags = numfrags(fs, size); + for (free = 0, i = 0; i < frags; i++) + if (isset(cg_blksfree(cgp), bno + i)) + free++; + if (free != 0 && free != frags) + panic("checkblk: partially free fragment"); + } + brelse(bp); + return (!free); +} +#endif /* DIAGNOSTIC */ + /* * Free an inode. * @@ -1316,14 +1429,14 @@ ffs_vfree(ap) * It is a panic if a request is made to find a block if none are * available. */ -static daddr_t +static ufs_daddr_t ffs_mapsearch(fs, cgp, bpref, allocsiz) register struct fs *fs; register struct cg *cgp; - daddr_t bpref; + ufs_daddr_t bpref; int allocsiz; { - daddr_t bno; + ufs_daddr_t bno; int start, len, loc, i; int blk, field, subfield, pos; @@ -1383,10 +1496,11 @@ ffs_mapsearch(fs, cgp, bpref, allocsiz) ffs_clusteracct(fs, cgp, blkno, cnt) struct fs *fs; struct cg *cgp; - daddr_t blkno; + ufs_daddr_t blkno; int cnt; { - long *sump; + int32_t *sump; + int32_t *lp; u_char *freemapp, *mapp; int i, start, end, forw, back, map, bit; @@ -1455,6 +1569,14 @@ ffs_clusteracct(fs, cgp, blkno, cnt) sump[back] -= cnt; if (forw > 0) sump[forw] -= cnt; + /* + * Update cluster summary information. + */ + lp = &sump[fs->fs_contigsumsize]; + for (i = fs->fs_contigsumsize; i > 0; i--) + if (*lp-- > 0) + break; + fs->fs_maxcluster[cgp->cg_cgx] = i; } /* diff --git a/sys/ufs/ffs/ffs_balloc.c b/sys/ufs/ffs/ffs_balloc.c index 752feec..1319b2e 100644 --- a/sys/ufs/ffs/ffs_balloc.c +++ b/sys/ufs/ffs/ffs_balloc.c @@ -30,7 +30,7 @@ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. * - * @(#)ffs_balloc.c 8.4 (Berkeley) 9/23/93 + * @(#)ffs_balloc.c 8.8 (Berkeley) 6/16/95 */ #include <sys/param.h> @@ -54,27 +54,27 @@ * by allocating the physical blocks on a device given * the inode and the logical block number in a file. */ -ffs_balloc(ip, bn, size, cred, bpp, flags) +ffs_balloc(ip, lbn, size, cred, bpp, flags) register struct inode *ip; - register daddr_t bn; + register ufs_daddr_t lbn; int size; struct ucred *cred; struct buf **bpp; int flags; { register struct fs *fs; - register daddr_t nb; + register ufs_daddr_t nb; struct buf *bp, *nbp; struct vnode *vp = ITOV(ip); struct indir indirs[NIADDR + 2]; - daddr_t newb, lbn, *bap, pref; - int osize, nsize, num, i, error; + ufs_daddr_t newb, *bap, pref; + int deallocated, osize, nsize, num, i, error; + ufs_daddr_t *allocib, *blkp, *allocblk, allociblk[NIADDR + 1]; *bpp = NULL; - if (bn < 0) + if (lbn < 0) return (EFBIG); fs = ip->i_fs; - lbn = bn; /* * If the next write will extend the file into a new block, @@ -82,7 +82,7 @@ ffs_balloc(ip, bn, size, cred, bpp, flags) * this fragment has to be extended to be a full block. */ nb = lblkno(fs, ip->i_size); - if (nb < NDADDR && nb < bn) { + if (nb < NDADDR && nb < lbn) { osize = blksize(fs, ip, nb); if (osize < fs->fs_bsize && osize > 0) { error = ffs_realloccg(ip, nb, @@ -103,10 +103,10 @@ ffs_balloc(ip, bn, size, cred, bpp, flags) /* * The first NDADDR blocks are direct blocks */ - if (bn < NDADDR) { - nb = ip->i_db[bn]; - if (nb != 0 && ip->i_size >= (bn + 1) * fs->fs_bsize) { - error = bread(vp, bn, fs->fs_bsize, NOCRED, &bp); + if (lbn < NDADDR) { + nb = ip->i_db[lbn]; + if (nb != 0 && ip->i_size >= (lbn + 1) * fs->fs_bsize) { + error = bread(vp, lbn, fs->fs_bsize, NOCRED, &bp); if (error) { brelse(bp); return (error); @@ -121,34 +121,34 @@ ffs_balloc(ip, bn, size, cred, bpp, flags) osize = fragroundup(fs, blkoff(fs, ip->i_size)); nsize = fragroundup(fs, size); if (nsize <= osize) { - error = bread(vp, bn, osize, NOCRED, &bp); + error = bread(vp, lbn, osize, NOCRED, &bp); if (error) { brelse(bp); return (error); } } else { - error = ffs_realloccg(ip, bn, - ffs_blkpref(ip, bn, (int)bn, &ip->i_db[0]), - osize, nsize, cred, &bp); + error = ffs_realloccg(ip, lbn, + ffs_blkpref(ip, lbn, (int)lbn, + &ip->i_db[0]), osize, nsize, cred, &bp); if (error) return (error); } } else { - if (ip->i_size < (bn + 1) * fs->fs_bsize) + if (ip->i_size < (lbn + 1) * fs->fs_bsize) nsize = fragroundup(fs, size); else nsize = fs->fs_bsize; - error = ffs_alloc(ip, bn, - ffs_blkpref(ip, bn, (int)bn, &ip->i_db[0]), + error = ffs_alloc(ip, lbn, + ffs_blkpref(ip, lbn, (int)lbn, &ip->i_db[0]), nsize, cred, &newb); if (error) return (error); - bp = getblk(vp, bn, nsize, 0, 0); + bp = getblk(vp, lbn, nsize, 0, 0); bp->b_blkno = fsbtodb(fs, newb); if (flags & B_CLRBUF) clrbuf(bp); } - ip->i_db[bn] = dbtofsb(fs, bp->b_blkno); + ip->i_db[lbn] = dbtofsb(fs, bp->b_blkno); ip->i_flag |= IN_CHANGE | IN_UPDATE; *bpp = bp; return (0); @@ -157,7 +157,7 @@ ffs_balloc(ip, bn, size, cred, bpp, flags) * Determine the number of levels of indirection. */ pref = 0; - if (error = ufs_getlbns(vp, bn, indirs, &num)) + if (error = ufs_getlbns(vp, lbn, indirs, &num)) return(error); #ifdef DIAGNOSTIC if (num < 1) @@ -168,24 +168,26 @@ ffs_balloc(ip, bn, size, cred, bpp, flags) */ --num; nb = ip->i_ib[indirs[0].in_off]; + allocib = NULL; + allocblk = allociblk; if (nb == 0) { - pref = ffs_blkpref(ip, lbn, 0, (daddr_t *)0); + pref = ffs_blkpref(ip, lbn, 0, (ufs_daddr_t *)0); if (error = ffs_alloc(ip, lbn, pref, (int)fs->fs_bsize, cred, &newb)) return (error); nb = newb; + *allocblk++ = nb; bp = getblk(vp, indirs[1].in_lbn, fs->fs_bsize, 0, 0); - bp->b_blkno = fsbtodb(fs, newb); + bp->b_blkno = fsbtodb(fs, nb); clrbuf(bp); /* * Write synchronously so that indirect blocks * never point at garbage. */ - if (error = bwrite(bp)) { - ffs_blkfree(ip, nb, fs->fs_bsize); - return (error); - } - ip->i_ib[indirs[0].in_off] = newb; + if (error = bwrite(bp)) + goto fail; + allocib = &ip->i_ib[indirs[0].in_off]; + *allocib = nb; ip->i_flag |= IN_CHANGE | IN_UPDATE; } /* @@ -196,9 +198,9 @@ ffs_balloc(ip, bn, size, cred, bpp, flags) indirs[i].in_lbn, (int)fs->fs_bsize, NOCRED, &bp); if (error) { brelse(bp); - return (error); + goto fail; } - bap = (daddr_t *)bp->b_data; + bap = (ufs_daddr_t *)bp->b_data; nb = bap[indirs[i].in_off]; if (i == num) break; @@ -208,13 +210,14 @@ ffs_balloc(ip, bn, size, cred, bpp, flags) continue; } if (pref == 0) - pref = ffs_blkpref(ip, lbn, 0, (daddr_t *)0); + pref = ffs_blkpref(ip, lbn, 0, (ufs_daddr_t *)0); if (error = ffs_alloc(ip, lbn, pref, (int)fs->fs_bsize, cred, &newb)) { brelse(bp); - return (error); + goto fail; } nb = newb; + *allocblk++ = nb; nbp = getblk(vp, indirs[i].in_lbn, fs->fs_bsize, 0, 0); nbp->b_blkno = fsbtodb(fs, nb); clrbuf(nbp); @@ -223,9 +226,8 @@ ffs_balloc(ip, bn, size, cred, bpp, flags) * never point at garbage. */ if (error = bwrite(nbp)) { - ffs_blkfree(ip, nb, fs->fs_bsize); brelse(bp); - return (error); + goto fail; } bap[indirs[i - 1].in_off] = nb; /* @@ -246,9 +248,10 @@ ffs_balloc(ip, bn, size, cred, bpp, flags) if (error = ffs_alloc(ip, lbn, pref, (int)fs->fs_bsize, cred, &newb)) { brelse(bp); - return (error); + goto fail; } nb = newb; + *allocblk++ = nb; nbp = getblk(vp, lbn, fs->fs_bsize, 0, 0); nbp->b_blkno = fsbtodb(fs, nb); if (flags & B_CLRBUF) @@ -271,7 +274,7 @@ ffs_balloc(ip, bn, size, cred, bpp, flags) error = bread(vp, lbn, (int)fs->fs_bsize, NOCRED, &nbp); if (error) { brelse(nbp); - return (error); + goto fail; } } else { nbp = getblk(vp, lbn, fs->fs_bsize, 0, 0); @@ -279,4 +282,26 @@ ffs_balloc(ip, bn, size, cred, bpp, flags) } *bpp = nbp; return (0); +fail: + /* + * If we have failed part way through block allocation, we + * have to deallocate any indirect blocks that we have allocated. + */ + for (deallocated = 0, blkp = allociblk; blkp < allocblk; blkp++) { + ffs_blkfree(ip, *blkp, fs->fs_bsize); + deallocated += fs->fs_bsize; + } + if (allocib != NULL) + *allocib = 0; + if (deallocated) { +#ifdef QUOTA + /* + * Restore user's disk quota because allocation failed. + */ + (void) chkdq(ip, (long)-btodb(deallocated), cred, FORCE); +#endif + ip->i_blocks -= btodb(deallocated); + ip->i_flag |= IN_CHANGE | IN_UPDATE; + } + return (error); } diff --git a/sys/ufs/ffs/ffs_extern.h b/sys/ufs/ffs/ffs_extern.h index ab467a2..9548e34 100644 --- a/sys/ufs/ffs/ffs_extern.h +++ b/sys/ufs/ffs/ffs_extern.h @@ -30,9 +30,26 @@ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. * - * @(#)ffs_extern.h 8.3 (Berkeley) 4/16/94 + * @(#)ffs_extern.h 8.6 (Berkeley) 3/30/95 */ +/* + * Sysctl values for the fast filesystem. + */ +#define FFS_CLUSTERREAD 1 /* cluster reading enabled */ +#define FFS_CLUSTERWRITE 2 /* cluster writing enabled */ +#define FFS_REALLOCBLKS 3 /* block reallocation enabled */ +#define FFS_ASYNCFREE 4 /* asynchronous block freeing enabled */ +#define FFS_MAXID 5 /* number of valid ffs ids */ + +#define FFS_NAMES { \ + { 0, 0 }, \ + { "doclusterread", CTLTYPE_INT }, \ + { "doclusterwrite", CTLTYPE_INT }, \ + { "doreallocblks", CTLTYPE_INT }, \ + { "doasyncfree", CTLTYPE_INT }, \ +} + struct buf; struct fid; struct fs; @@ -46,23 +63,24 @@ struct ucred; struct uio; struct vnode; struct mbuf; +struct vfsconf; __BEGIN_DECLS int ffs_alloc __P((struct inode *, - daddr_t, daddr_t, int, struct ucred *, daddr_t *)); + ufs_daddr_t, ufs_daddr_t, int, struct ucred *, ufs_daddr_t *)); int ffs_balloc __P((struct inode *, - daddr_t, int, struct ucred *, struct buf **, int)); + ufs_daddr_t, int, struct ucred *, struct buf **, int)); int ffs_blkatoff __P((struct vop_blkatoff_args *)); -int ffs_blkfree __P((struct inode *, daddr_t, long)); -daddr_t ffs_blkpref __P((struct inode *, daddr_t, int, daddr_t *)); +int ffs_blkfree __P((struct inode *, ufs_daddr_t, long)); +ufs_daddr_t ffs_blkpref __P((struct inode *, ufs_daddr_t, int, ufs_daddr_t *)); int ffs_bmap __P((struct vop_bmap_args *)); -void ffs_clrblock __P((struct fs *, u_char *, daddr_t)); +void ffs_clrblock __P((struct fs *, u_char *, ufs_daddr_t)); int ffs_fhtovp __P((struct mount *, struct fid *, struct mbuf *, struct vnode **, int *, struct ucred **)); -void ffs_fragacct __P((struct fs *, int, long [], int)); +void ffs_fragacct __P((struct fs *, int, int32_t [], int)); int ffs_fsync __P((struct vop_fsync_args *)); -int ffs_init __P((void)); -int ffs_isblock __P((struct fs *, u_char *, daddr_t)); +int ffs_init __P((struct vfsconf *)); +int ffs_isblock __P((struct fs *, u_char *, ufs_daddr_t)); int ffs_mount __P((struct mount *, char *, caddr_t, struct nameidata *, struct proc *)); int ffs_mountfs __P((struct vnode *, struct mount *, struct proc *)); @@ -70,11 +88,13 @@ int ffs_mountroot __P((void)); int ffs_read __P((struct vop_read_args *)); int ffs_reallocblks __P((struct vop_reallocblks_args *)); int ffs_realloccg __P((struct inode *, - daddr_t, daddr_t, int, int, struct ucred *, struct buf **)); + ufs_daddr_t, ufs_daddr_t, int, int, struct ucred *, struct buf **)); int ffs_reclaim __P((struct vop_reclaim_args *)); -void ffs_setblock __P((struct fs *, u_char *, daddr_t)); +void ffs_setblock __P((struct fs *, u_char *, ufs_daddr_t)); int ffs_statfs __P((struct mount *, struct statfs *, struct proc *)); int ffs_sync __P((struct mount *, int, struct ucred *, struct proc *)); +int ffs_sysctl __P((int *, u_int, void *, size_t *, void *, size_t, + struct proc *)); int ffs_truncate __P((struct vop_truncate_args *)); int ffs_unmount __P((struct mount *, int, struct proc *)); int ffs_update __P((struct vop_update_args *)); diff --git a/sys/ufs/ffs/ffs_inode.c b/sys/ufs/ffs/ffs_inode.c index b45aee5..bd2052e 100644 --- a/sys/ufs/ffs/ffs_inode.c +++ b/sys/ufs/ffs/ffs_inode.c @@ -30,7 +30,7 @@ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. * - * @(#)ffs_inode.c 8.5 (Berkeley) 12/30/93 + * @(#)ffs_inode.c 8.13 (Berkeley) 4/21/95 */ #include <sys/param.h> @@ -55,14 +55,8 @@ #include <ufs/ffs/fs.h> #include <ufs/ffs/ffs_extern.h> -static int ffs_indirtrunc __P((struct inode *, daddr_t, daddr_t, daddr_t, int, - long *)); - -int -ffs_init() -{ - return (ufs_init()); -} +static int ffs_indirtrunc __P((struct inode *, ufs_daddr_t, ufs_daddr_t, + ufs_daddr_t, int, long *)); /* * Update the access, modified, and inode change times as specified by the @@ -97,13 +91,13 @@ ffs_update(ap) (IN_ACCESS | IN_CHANGE | IN_MODIFIED | IN_UPDATE)) == 0) return (0); if (ip->i_flag & IN_ACCESS) - ip->i_atime.ts_sec = ap->a_access->tv_sec; + ip->i_atime = ap->a_access->tv_sec; if (ip->i_flag & IN_UPDATE) { - ip->i_mtime.ts_sec = ap->a_modify->tv_sec; + ip->i_mtime = ap->a_modify->tv_sec; ip->i_modrev++; } if (ip->i_flag & IN_CHANGE) - ip->i_ctime.ts_sec = time.tv_sec; + ip->i_ctime = time.tv_sec; ip->i_flag &= ~(IN_ACCESS | IN_CHANGE | IN_MODIFIED | IN_UPDATE); fs = ip->i_fs; /* @@ -122,7 +116,7 @@ ffs_update(ap) } *((struct dinode *)bp->b_data + ino_to_fsbo(fs, ip->i_number)) = ip->i_din; - if (ap->a_waitfor) + if (ap->a_waitfor && (ap->a_vp->v_mount->mnt_flag & MNT_ASYNC) == 0) return (bwrite(bp)); else { bdwrite(bp); @@ -147,10 +141,10 @@ ffs_truncate(ap) } */ *ap; { register struct vnode *ovp = ap->a_vp; - register daddr_t lastblock; + ufs_daddr_t lastblock; register struct inode *oip; - daddr_t bn, lbn, lastiblock[NIADDR], indir_lbn[NIADDR]; - daddr_t oldblks[NDADDR + NIADDR], newblks[NDADDR + NIADDR]; + ufs_daddr_t bn, lbn, lastiblock[NIADDR], indir_lbn[NIADDR]; + ufs_daddr_t oldblks[NDADDR + NIADDR], newblks[NDADDR + NIADDR]; off_t length = ap->a_length; register struct fs *fs; struct buf *bp; @@ -161,6 +155,8 @@ ffs_truncate(ap) int aflags, error, allerror; off_t osize; + if (length < 0) + return (EINVAL); oip = VTOI(ovp); tv = time; if (ovp->v_type == VLNK && @@ -182,15 +178,16 @@ ffs_truncate(ap) if (error = getinoquota(oip)) return (error); #endif - vnode_pager_setsize(ovp, (u_long)length); fs = oip->i_fs; osize = oip->i_size; /* * Lengthen the size of the file. We must ensure that the * last byte of the file is allocated. Since the smallest - * value of oszie is 0, length will be at least 1. + * value of osize is 0, length will be at least 1. */ if (osize < length) { + if (length > fs->fs_maxfilesize) + return (EFBIG); offset = blkoff(fs, length - 1); lbn = lblkno(fs, length - 1); aflags = B_CLRBUF; @@ -200,8 +197,9 @@ ffs_truncate(ap) aflags)) return (error); oip->i_size = length; + vnode_pager_setsize(ovp, (u_long)length); (void) vnode_pager_uncache(ovp); - if (aflags & IO_SYNC) + if (aflags & B_SYNC) bwrite(bp); else bawrite(bp); @@ -231,11 +229,12 @@ ffs_truncate(ap) (void) vnode_pager_uncache(ovp); bzero((char *)bp->b_data + offset, (u_int)(size - offset)); allocbuf(bp, size); - if (aflags & IO_SYNC) + if (aflags & B_SYNC) bwrite(bp); else bawrite(bp); } + vnode_pager_setsize(ovp, (u_long)length); /* * Calculate index into inode's block list of * last direct and indirect blocks (if any) @@ -383,17 +382,17 @@ done: static int ffs_indirtrunc(ip, lbn, dbn, lastbn, level, countp) register struct inode *ip; - daddr_t lbn, lastbn; - daddr_t dbn; + ufs_daddr_t lbn, lastbn; + ufs_daddr_t dbn; int level; long *countp; { register int i; struct buf *bp; register struct fs *fs = ip->i_fs; - register daddr_t *bap; + register ufs_daddr_t *bap; struct vnode *vp; - daddr_t *copy, nb, nlbn, last; + ufs_daddr_t *copy, nb, nlbn, last; long blkcount, factor; int nblocks, blocksreleased = 0; int error = 0, allerror = 0; @@ -439,11 +438,11 @@ ffs_indirtrunc(ip, lbn, dbn, lastbn, level, countp) return (error); } - bap = (daddr_t *)bp->b_data; - MALLOC(copy, daddr_t *, fs->fs_bsize, M_TEMP, M_WAITOK); + bap = (ufs_daddr_t *)bp->b_data; + MALLOC(copy, ufs_daddr_t *, fs->fs_bsize, M_TEMP, M_WAITOK); bcopy((caddr_t)bap, (caddr_t)copy, (u_int)fs->fs_bsize); bzero((caddr_t)&bap[last + 1], - (u_int)(NINDIR(fs) - (last + 1)) * sizeof (daddr_t)); + (u_int)(NINDIR(fs) - (last + 1)) * sizeof (ufs_daddr_t)); if (last == -1) bp->b_flags |= B_INVAL; error = bwrite(bp); @@ -460,8 +459,8 @@ ffs_indirtrunc(ip, lbn, dbn, lastbn, level, countp) if (nb == 0) continue; if (level > SINGLE) { - if (error = ffs_indirtrunc(ip, nlbn, - fsbtodb(fs, nb), (daddr_t)-1, level - 1, &blkcount)) + if (error = ffs_indirtrunc(ip, nlbn, fsbtodb(fs, nb), + (ufs_daddr_t)-1, level - 1, &blkcount)) allerror = error; blocksreleased += blkcount; } diff --git a/sys/ufs/ffs/ffs_subr.c b/sys/ufs/ffs/ffs_subr.c index c251b16..27d6bb0 100644 --- a/sys/ufs/ffs/ffs_subr.c +++ b/sys/ufs/ffs/ffs_subr.c @@ -30,19 +30,22 @@ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. * - * @(#)ffs_subr.c 8.2 (Berkeley) 9/21/93 + * @(#)ffs_subr.c 8.5 (Berkeley) 3/21/95 */ #include <sys/param.h> +#ifndef KERNEL +#include <ufs/ufs/dinode.h> #include <ufs/ffs/fs.h> +#else -#ifdef KERNEL #include <sys/systm.h> #include <sys/vnode.h> -#include <ufs/ffs/ffs_extern.h> #include <sys/buf.h> #include <ufs/ufs/quota.h> #include <ufs/ufs/inode.h> +#include <ufs/ffs/fs.h> +#include <ufs/ffs/ffs_extern.h> /* * Return buffer with the contents of block "offset" from the beginning of @@ -61,7 +64,7 @@ ffs_blkatoff(ap) struct inode *ip; register struct fs *fs; struct buf *bp; - daddr_t lbn; + ufs_daddr_t lbn; int bsize, error; ip = VTOI(ap->a_vp); @@ -89,7 +92,7 @@ void ffs_fragacct(fs, fragmap, fraglist, cnt) struct fs *fs; int fragmap; - long fraglist[]; + int32_t fraglist[]; int cnt; { int inblk; @@ -123,7 +126,7 @@ ffs_checkoverlap(bp, ip) struct inode *ip; { register struct buf *ebp, *ep; - register daddr_t start, last; + register ufs_daddr_t start, last; struct vnode *vp; ebp = &buf[nbuf]; @@ -133,7 +136,8 @@ ffs_checkoverlap(bp, ip) if (ep == bp || (ep->b_flags & B_INVAL) || ep->b_vp == NULLVP) continue; - if (VOP_BMAP(ep->b_vp, (daddr_t)0, &vp, (daddr_t)0, NULL)) + if (VOP_BMAP(ep->b_vp, (ufs_daddr_t)0, &vp, (ufs_daddr_t)0, + NULL)) continue; if (vp != ip->i_devvp) continue; @@ -159,7 +163,7 @@ int ffs_isblock(fs, cp, h) struct fs *fs; unsigned char *cp; - daddr_t h; + ufs_daddr_t h; { unsigned char mask; @@ -187,7 +191,7 @@ void ffs_clrblock(fs, cp, h) struct fs *fs; u_char *cp; - daddr_t h; + ufs_daddr_t h; { switch ((int)fs->fs_frag) { @@ -215,7 +219,7 @@ void ffs_setblock(fs, cp, h) struct fs *fs; unsigned char *cp; - daddr_t h; + ufs_daddr_t h; { switch ((int)fs->fs_frag) { diff --git a/sys/ufs/ffs/ffs_vfsops.c b/sys/ufs/ffs/ffs_vfsops.c index 505dd5d..1fd5951 100644 --- a/sys/ufs/ffs/ffs_vfsops.c +++ b/sys/ufs/ffs/ffs_vfsops.c @@ -30,7 +30,7 @@ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. * - * @(#)ffs_vfsops.c 8.8 (Berkeley) 4/18/94 + * @(#)ffs_vfsops.c 8.31 (Berkeley) 5/20/95 */ #include <sys/param.h> @@ -73,22 +73,19 @@ struct vfsops ufs_vfsops = { ffs_fhtovp, ffs_vptofh, ffs_init, + ffs_sysctl, }; extern u_long nextgennumber; /* * Called by main() when ufs is going to be mounted as root. - * - * Name is updated by mount(8) after booting. */ -#define ROOTNAME "root_device" - ffs_mountroot() { extern struct vnode *rootvp; - register struct fs *fs; - register struct mount *mp; + struct fs *fs; + struct mount *mp; struct proc *p = curproc; /* XXX */ struct ufsmount *ump; u_int size; @@ -97,36 +94,27 @@ ffs_mountroot() /* * Get vnodes for swapdev and rootdev. */ - if (bdevvp(swapdev, &swapdev_vp) || bdevvp(rootdev, &rootvp)) - panic("ffs_mountroot: can't setup bdevvp's"); - - mp = malloc((u_long)sizeof(struct mount), M_MOUNT, M_WAITOK); - bzero((char *)mp, (u_long)sizeof(struct mount)); - mp->mnt_op = &ufs_vfsops; - mp->mnt_flag = MNT_RDONLY; - if (error = ffs_mountfs(rootvp, mp, p)) { - free(mp, M_MOUNT); + if ((error = bdevvp(swapdev, &swapdev_vp)) || + (error = bdevvp(rootdev, &rootvp))) { + printf("ffs_mountroot: can't setup bdevvp's"); return (error); } - if (error = vfs_lock(mp)) { - (void)ffs_unmount(mp, 0, p); + if (error = vfs_rootmountalloc("ufs", "root_device", &mp)) + return (error); + if (error = ffs_mountfs(rootvp, mp, p)) { + mp->mnt_vfc->vfc_refcount--; + vfs_unbusy(mp, p); free(mp, M_MOUNT); return (error); } - TAILQ_INSERT_TAIL(&mountlist, mp, mnt_list); - mp->mnt_flag |= MNT_ROOTFS; - mp->mnt_vnodecovered = NULLVP; + simple_lock(&mountlist_slock); + CIRCLEQ_INSERT_TAIL(&mountlist, mp, mnt_list); + simple_unlock(&mountlist_slock); ump = VFSTOUFS(mp); fs = ump->um_fs; - bzero(fs->fs_fsmnt, sizeof(fs->fs_fsmnt)); - fs->fs_fsmnt[0] = '/'; - bcopy((caddr_t)fs->fs_fsmnt, (caddr_t)mp->mnt_stat.f_mntonname, - MNAMELEN); - (void) copystr(ROOTNAME, mp->mnt_stat.f_mntfromname, MNAMELEN - 1, - &size); - bzero(mp->mnt_stat.f_mntfromname + size, MNAMELEN - size); + (void) copystr(mp->mnt_stat.f_mntonname, fs->fs_fsmnt, MNAMELEN - 1, 0); (void)ffs_statfs(mp, &mp->mnt_stat, p); - vfs_unlock(mp); + vfs_unbusy(mp, p); inittodr(fs->fs_time); return (0); } @@ -150,6 +138,7 @@ ffs_mount(mp, path, data, ndp, p) register struct fs *fs; u_int size; int error, flags; + mode_t accessmode; if (error = copyin(data, (caddr_t)&args, sizeof (struct ufs_args))) return (error); @@ -160,22 +149,42 @@ ffs_mount(mp, path, data, ndp, p) if (mp->mnt_flag & MNT_UPDATE) { ump = VFSTOUFS(mp); fs = ump->um_fs; - error = 0; if (fs->fs_ronly == 0 && (mp->mnt_flag & MNT_RDONLY)) { flags = WRITECLOSE; if (mp->mnt_flag & MNT_FORCE) flags |= FORCECLOSE; - if (vfs_busy(mp)) - return (EBUSY); - error = ffs_flushfiles(mp, flags, p); - vfs_unbusy(mp); + if (error = ffs_flushfiles(mp, flags, p)) + return (error); + fs->fs_clean = 1; + fs->fs_ronly = 1; + if (error = ffs_sbupdate(ump, MNT_WAIT)) { + fs->fs_clean = 0; + fs->fs_ronly = 0; + return (error); + } } - if (!error && (mp->mnt_flag & MNT_RELOAD)) - error = ffs_reload(mp, ndp->ni_cnd.cn_cred, p); - if (error) + if ((mp->mnt_flag & MNT_RELOAD) && + (error = ffs_reload(mp, ndp->ni_cnd.cn_cred, p))) return (error); - if (fs->fs_ronly && (mp->mnt_flag & MNT_WANTRDWR)) + if (fs->fs_ronly && (mp->mnt_flag & MNT_WANTRDWR)) { + /* + * If upgrade to read-write by non-root, then verify + * that user has necessary permissions on the device. + */ + if (p->p_ucred->cr_uid != 0) { + devvp = ump->um_devvp; + vn_lock(devvp, LK_EXCLUSIVE | LK_RETRY, p); + if (error = VOP_ACCESS(devvp, VREAD | VWRITE, + p->p_ucred, p)) { + VOP_UNLOCK(devvp, 0, p); + return (error); + } + VOP_UNLOCK(devvp, 0, p); + } fs->fs_ronly = 0; + fs->fs_clean = 0; + (void) ffs_sbupdate(ump, MNT_WAIT); + } if (args.fspec == 0) { /* * Process export requests. @@ -200,6 +209,21 @@ ffs_mount(mp, path, data, ndp, p) vrele(devvp); return (ENXIO); } + /* + * If mount by non-root, then verify that user has necessary + * permissions on the device. + */ + if (p->p_ucred->cr_uid != 0) { + accessmode = VREAD; + if ((mp->mnt_flag & MNT_RDONLY) == 0) + accessmode |= VWRITE; + vn_lock(devvp, LK_EXCLUSIVE | LK_RETRY, p); + if (error = VOP_ACCESS(devvp, accessmode, p->p_ucred, p)) { + vput(devvp); + return (error); + } + VOP_UNLOCK(devvp, 0, p); + } if ((mp->mnt_flag & MNT_UPDATE) == 0) error = ffs_mountfs(devvp, mp, p); else { @@ -247,8 +271,10 @@ ffs_reload(mountp, cred, p) struct inode *ip; struct csum *space; struct buf *bp; - struct fs *fs; + struct fs *fs, *newfs; + struct partinfo dpart; int i, blks, size, error; + int32_t *lp; if ((mountp->mnt_flag & MNT_RDONLY) == 0) return (EINVAL); @@ -261,21 +287,31 @@ ffs_reload(mountp, cred, p) /* * Step 2: re-read superblock from disk. */ - if (error = bread(devvp, SBLOCK, SBSIZE, NOCRED, &bp)) + if (VOP_IOCTL(devvp, DIOCGPART, (caddr_t)&dpart, FREAD, NOCRED, p) != 0) + size = DEV_BSIZE; + else + size = dpart.disklab->d_secsize; + if (error = bread(devvp, (ufs_daddr_t)(SBOFF/size), SBSIZE, NOCRED,&bp)) return (error); - fs = (struct fs *)bp->b_data; - if (fs->fs_magic != FS_MAGIC || fs->fs_bsize > MAXBSIZE || - fs->fs_bsize < sizeof(struct fs)) { + newfs = (struct fs *)bp->b_data; + if (newfs->fs_magic != FS_MAGIC || newfs->fs_bsize > MAXBSIZE || + newfs->fs_bsize < sizeof(struct fs)) { brelse(bp); return (EIO); /* XXX needs translation */ } fs = VFSTOUFS(mountp)->um_fs; - bcopy(&fs->fs_csp[0], &((struct fs *)bp->b_data)->fs_csp[0], - sizeof(fs->fs_csp)); - bcopy(bp->b_data, fs, (u_int)fs->fs_sbsize); + /* + * Copy pointer fields back into superblock before copying in XXX + * new superblock. These should really be in the ufsmount. XXX + * Note that important parameters (eg fs_ncg) are unchanged. + */ + bcopy(&fs->fs_csp[0], &newfs->fs_csp[0], sizeof(fs->fs_csp)); + newfs->fs_maxcluster = fs->fs_maxcluster; + bcopy(newfs, fs, (u_int)fs->fs_sbsize); if (fs->fs_sbsize < SBSIZE) bp->b_flags |= B_INVAL; brelse(bp); + mountp->mnt_maxsymlinklen = fs->fs_maxsymlinklen; ffs_oldfscompat(fs); /* * Step 3: re-read summary information from disk. @@ -292,21 +328,36 @@ ffs_reload(mountp, cred, p) bcopy(bp->b_data, fs->fs_csp[fragstoblks(fs, i)], (u_int)size); brelse(bp); } + /* + * We no longer know anything about clusters per cylinder group. + */ + if (fs->fs_contigsumsize > 0) { + lp = fs->fs_maxcluster; + for (i = 0; i < fs->fs_ncg; i++) + *lp++ = fs->fs_contigsumsize; + } + loop: + simple_lock(&mntvnode_slock); for (vp = mountp->mnt_vnodelist.lh_first; vp != NULL; vp = nvp) { + if (vp->v_mount != mountp) { + simple_unlock(&mntvnode_slock); + goto loop; + } nvp = vp->v_mntvnodes.le_next; /* * Step 4: invalidate all inactive vnodes. */ - if (vp->v_usecount == 0) { - vgone(vp); - continue; - } + if (vrecycle(vp, &mntvnode_slock, p)) + goto loop; /* * Step 5: invalidate all cached file data. */ - if (vget(vp, 1)) + simple_lock(&vp->v_interlock); + simple_unlock(&mntvnode_slock); + if (vget(vp, LK_EXCLUSIVE | LK_INTERLOCK, p)) { goto loop; + } if (vinvalbuf(vp, 0, cred, p, 0, 0)) panic("ffs_reload: dirty2"); /* @@ -323,9 +374,9 @@ loop: ino_to_fsbo(fs, ip->i_number)); brelse(bp); vput(vp); - if (vp->v_mount != mountp) - goto loop; + simple_lock(&mntvnode_slock); } + simple_unlock(&mntvnode_slock); return (0); } @@ -341,14 +392,17 @@ ffs_mountfs(devvp, mp, p) register struct ufsmount *ump; struct buf *bp; register struct fs *fs; - dev_t dev = devvp->v_rdev; + dev_t dev; struct partinfo dpart; caddr_t base, space; - int havepart = 0, blks; - int error, i, size; - int ronly; + int error, i, blks, size, ronly; + int32_t *lp; + struct ucred *cred; extern struct vnode *rootvp; + u_int64_t maxfilesize; /* XXX */ + dev = devvp->v_rdev; + cred = p ? p->p_ucred : NOCRED; /* * Disallow multiple mounts of the same device. * Disallow mounting of a device that is currently in use @@ -359,22 +413,20 @@ ffs_mountfs(devvp, mp, p) return (error); if (vcount(devvp) > 1 && devvp != rootvp) return (EBUSY); - if (error = vinvalbuf(devvp, V_SAVE, p->p_ucred, p, 0, 0)) + if (error = vinvalbuf(devvp, V_SAVE, cred, p, 0, 0)) return (error); ronly = (mp->mnt_flag & MNT_RDONLY) != 0; if (error = VOP_OPEN(devvp, ronly ? FREAD : FREAD|FWRITE, FSCRED, p)) return (error); - if (VOP_IOCTL(devvp, DIOCGPART, (caddr_t)&dpart, FREAD, NOCRED, p) != 0) + if (VOP_IOCTL(devvp, DIOCGPART, (caddr_t)&dpart, FREAD, cred, p) != 0) size = DEV_BSIZE; - else { - havepart = 1; + else size = dpart.disklab->d_secsize; - } bp = NULL; ump = NULL; - if (error = bread(devvp, SBLOCK, SBSIZE, NOCRED, &bp)) + if (error = bread(devvp, (ufs_daddr_t)(SBOFF/size), SBSIZE, cred, &bp)) goto out; fs = (struct fs *)bp->b_data; if (fs->fs_magic != FS_MAGIC || fs->fs_bsize > MAXBSIZE || @@ -382,6 +434,11 @@ ffs_mountfs(devvp, mp, p) error = EINVAL; /* XXX needs translation */ goto out; } + /* XXX updating 4.2 FFS superblocks trashes rotational layout tables */ + if (fs->fs_postblformat == FS_42POSTBLFMT && !ronly) { + error = EROFS; /* needs translation */ + goto out; + } ump = malloc(sizeof *ump, M_UFSMNT, M_WAITOK); bzero((caddr_t)ump, sizeof *ump); ump->um_fs = malloc((u_long)fs->fs_sbsize, M_UFSMNT, @@ -393,18 +450,17 @@ ffs_mountfs(devvp, mp, p) bp = NULL; fs = ump->um_fs; fs->fs_ronly = ronly; - if (ronly == 0) - fs->fs_fmod = 1; - blks = howmany(fs->fs_cssize, fs->fs_fsize); - base = space = malloc((u_long)fs->fs_cssize, M_UFSMNT, - M_WAITOK); + size = fs->fs_cssize; + blks = howmany(size, fs->fs_fsize); + if (fs->fs_contigsumsize > 0) + size += fs->fs_ncg * sizeof(int32_t); + base = space = malloc((u_long)size, M_UFSMNT, M_WAITOK); for (i = 0; i < blks; i += fs->fs_frag) { size = fs->fs_bsize; if (i + fs->fs_frag > blks) size = (blks - i) * fs->fs_fsize; - error = bread(devvp, fsbtodb(fs, fs->fs_csaddr + i), size, - NOCRED, &bp); - if (error) { + if (error = bread(devvp, fsbtodb(fs, fs->fs_csaddr + i), size, + cred, &bp)) { free(base, M_UFSMNT); goto out; } @@ -414,11 +470,15 @@ ffs_mountfs(devvp, mp, p) brelse(bp); bp = NULL; } + if (fs->fs_contigsumsize > 0) { + fs->fs_maxcluster = lp = (int32_t *)space; + for (i = 0; i < fs->fs_ncg; i++) + *lp++ = fs->fs_contigsumsize; + } mp->mnt_data = (qaddr_t)ump; mp->mnt_stat.f_fsid.val[0] = (long)dev; - mp->mnt_stat.f_fsid.val[1] = MOUNT_UFS; + mp->mnt_stat.f_fsid.val[1] = mp->mnt_vfc->vfc_typenum; mp->mnt_maxsymlinklen = fs->fs_maxsymlinklen; - mp->mnt_flag |= MNT_LOCAL; ump->um_mountp = mp; ump->um_dev = dev; ump->um_devvp = devvp; @@ -429,11 +489,19 @@ ffs_mountfs(devvp, mp, p) ump->um_quotas[i] = NULLVP; devvp->v_specflags |= SI_MOUNTEDON; ffs_oldfscompat(fs); + ump->um_savedmaxfilesize = fs->fs_maxfilesize; /* XXX */ + maxfilesize = (u_int64_t)0x40000000 * fs->fs_bsize - 1; /* XXX */ + if (fs->fs_maxfilesize > maxfilesize) /* XXX */ + fs->fs_maxfilesize = maxfilesize; /* XXX */ + if (ronly == 0) { + fs->fs_clean = 0; + (void) ffs_sbupdate(ump, MNT_WAIT); + } return (0); out: if (bp) brelse(bp); - (void)VOP_CLOSE(devvp, ronly ? FREAD : FREAD|FWRITE, NOCRED, p); + (void)VOP_CLOSE(devvp, ronly ? FREAD : FREAD|FWRITE, cred, p); if (ump) { free(ump->um_fs, M_UFSMNT); free(ump, M_UFSMNT); @@ -457,7 +525,7 @@ ffs_oldfscompat(fs) if (fs->fs_postblformat == FS_42POSTBLFMT) /* XXX */ fs->fs_nrpos = 8; /* XXX */ if (fs->fs_inodefmt < FS_44INODEFMT) { /* XXX */ - quad_t sizepb = fs->fs_bsize; /* XXX */ + u_int64_t sizepb = fs->fs_bsize; /* XXX */ /* XXX */ fs->fs_maxfilesize = fs->fs_bsize * NDADDR - 1; /* XXX */ for (i = 0; i < NIADDR; i++) { /* XXX */ @@ -481,28 +549,30 @@ ffs_unmount(mp, mntflags, p) { register struct ufsmount *ump; register struct fs *fs; - int error, flags, ronly; + int error, flags; flags = 0; - if (mntflags & MNT_FORCE) { - if (mp->mnt_flag & MNT_ROOTFS) - return (EINVAL); + if (mntflags & MNT_FORCE) flags |= FORCECLOSE; - } if (error = ffs_flushfiles(mp, flags, p)) return (error); ump = VFSTOUFS(mp); fs = ump->um_fs; - ronly = !fs->fs_ronly; + if (fs->fs_ronly == 0) { + fs->fs_clean = 1; + if (error = ffs_sbupdate(ump, MNT_WAIT)) { + fs->fs_clean = 0; + return (error); + } + } ump->um_devvp->v_specflags &= ~SI_MOUNTEDON; - error = VOP_CLOSE(ump->um_devvp, ronly ? FREAD : FREAD|FWRITE, + error = VOP_CLOSE(ump->um_devvp, fs->fs_ronly ? FREAD : FREAD|FWRITE, NOCRED, p); vrele(ump->um_devvp); free(fs->fs_csp[0], M_UFSMNT); free(fs, M_UFSMNT); free(ump, M_UFSMNT); mp->mnt_data = (qaddr_t)0; - mp->mnt_flag &= ~MNT_LOCAL; return (error); } @@ -514,12 +584,9 @@ ffs_flushfiles(mp, flags, p) int flags; struct proc *p; { - extern int doforce; register struct ufsmount *ump; int i, error; - if (!doforce) - flags &= ~FORCECLOSE; ump = VFSTOUFS(mp); #ifdef QUOTA if (mp->mnt_flag & MNT_QUOTA) { @@ -556,7 +623,6 @@ ffs_statfs(mp, sbp, p) fs = ump->um_fs; if (fs->fs_magic != FS_MAGIC) panic("ffs_statfs"); - sbp->f_type = MOUNT_UFS; sbp->f_bsize = fs->fs_fsize; sbp->f_iosize = fs->fs_bsize; sbp->f_blocks = fs->fs_dsize; @@ -567,6 +633,7 @@ ffs_statfs(mp, sbp, p) sbp->f_files = fs->fs_ncg * fs->fs_ipg - ROOTINO; sbp->f_ffree = fs->fs_cstotal.cs_nifree; if (sbp != &mp->mnt_stat) { + sbp->f_type = mp->mnt_vfc->vfc_typenum; bcopy((caddr_t)mp->mnt_stat.f_mntonname, (caddr_t)&sbp->f_mntonname[0], MNAMELEN); bcopy((caddr_t)mp->mnt_stat.f_mntfromname, @@ -589,53 +656,55 @@ ffs_sync(mp, waitfor, cred, p) struct ucred *cred; struct proc *p; { - register struct vnode *vp; - register struct inode *ip; - register struct ufsmount *ump = VFSTOUFS(mp); - register struct fs *fs; + struct vnode *nvp, *vp; + struct inode *ip; + struct ufsmount *ump = VFSTOUFS(mp); + struct fs *fs; int error, allerror = 0; fs = ump->um_fs; - /* - * Write back modified superblock. - * Consistency check that the superblock - * is still in the buffer cache. - */ - if (fs->fs_fmod != 0) { - if (fs->fs_ronly != 0) { /* XXX */ - printf("fs = %s\n", fs->fs_fsmnt); - panic("update: rofs mod"); - } - fs->fs_fmod = 0; - fs->fs_time = time.tv_sec; - allerror = ffs_sbupdate(ump, waitfor); + if (fs->fs_fmod != 0 && fs->fs_ronly != 0) { /* XXX */ + printf("fs = %s\n", fs->fs_fsmnt); + panic("update: rofs mod"); } /* * Write back each (modified) inode. */ + simple_lock(&mntvnode_slock); loop: for (vp = mp->mnt_vnodelist.lh_first; vp != NULL; - vp = vp->v_mntvnodes.le_next) { + vp = nvp) { /* * If the vnode that we are about to sync is no longer * associated with this mount point, start over. */ if (vp->v_mount != mp) goto loop; - if (VOP_ISLOCKED(vp)) - continue; + simple_lock(&vp->v_interlock); + nvp = vp->v_mntvnodes.le_next; ip = VTOI(vp); if ((ip->i_flag & (IN_ACCESS | IN_CHANGE | IN_MODIFIED | IN_UPDATE)) == 0 && - vp->v_dirtyblkhd.lh_first == NULL) + vp->v_dirtyblkhd.lh_first == NULL) { + simple_unlock(&vp->v_interlock); continue; - if (vget(vp, 1)) - goto loop; + } + simple_unlock(&mntvnode_slock); + error = vget(vp, LK_EXCLUSIVE | LK_NOWAIT | LK_INTERLOCK, p); + if (error) { + simple_lock(&mntvnode_slock); + if (error == ENOENT) + goto loop; + continue; + } if (error = VOP_FSYNC(vp, cred, waitfor, p)) allerror = error; - vput(vp); + VOP_UNLOCK(vp, 0, p); + vrele(vp); + simple_lock(&mntvnode_slock); } + simple_unlock(&mntvnode_slock); /* * Force stale file system control information to be flushed. */ @@ -644,6 +713,15 @@ loop: #ifdef QUOTA qsync(mp); #endif + /* + * Write back modified superblock. + */ + if (fs->fs_fmod != 0) { + fs->fs_fmod = 0; + fs->fs_time = time.tv_sec; + if (error = ffs_sbupdate(ump, waitfor)) + allerror = error; + } return (allerror); } @@ -659,8 +737,9 @@ ffs_vget(mp, ino, vpp) ino_t ino; struct vnode **vpp; { - register struct fs *fs; - register struct inode *ip; + struct proc *p = curproc; /* XXX */ + struct fs *fs; + struct inode *ip; struct ufsmount *ump; struct buf *bp; struct vnode *vp; @@ -680,6 +759,7 @@ ffs_vget(mp, ino, vpp) type = ump->um_devvp->v_tag == VT_MFS ? M_MFSNODE : M_FFSNODE; /* XXX */ MALLOC(ip, struct inode *, sizeof(struct inode), type, M_WAITOK); bzero((caddr_t)ip, sizeof(struct inode)); + lockinit(&ip->i_lock, PINOD, "inode", 0, 0); vp->v_data = ip; ip->i_vnode = vp; ip->i_fs = fs = ump->um_fs; @@ -802,6 +882,53 @@ ffs_vptofh(vp, fhp) } /* + * Initialize the filesystem; just use ufs_init. + */ +int +ffs_init(vfsp) + struct vfsconf *vfsp; +{ + + return (ufs_init(vfsp)); +} + +/* + * fast filesystem related variables. + */ +ffs_sysctl(name, namelen, oldp, oldlenp, newp, newlen, p) + int *name; + u_int namelen; + void *oldp; + size_t *oldlenp; + void *newp; + size_t newlen; + struct proc *p; +{ + extern int doclusterread, doclusterwrite, doreallocblks, doasyncfree; + + /* all sysctl names at this level are terminal */ + if (namelen != 1) + return (ENOTDIR); /* overloaded */ + + switch (name[0]) { + case FFS_CLUSTERREAD: + return (sysctl_int(oldp, oldlenp, newp, newlen, + &doclusterread)); + case FFS_CLUSTERWRITE: + return (sysctl_int(oldp, oldlenp, newp, newlen, + &doclusterwrite)); + case FFS_REALLOCBLKS: + return (sysctl_int(oldp, oldlenp, newp, newlen, + &doreallocblks)); + case FFS_ASYNCFREE: + return (sysctl_int(oldp, oldlenp, newp, newlen, &doasyncfree)); + default: + return (EOPNOTSUPP); + } + /* NOTREACHED */ +} + +/* * Write a superblock and associated information back to disk. */ int @@ -809,21 +936,15 @@ ffs_sbupdate(mp, waitfor) struct ufsmount *mp; int waitfor; { - register struct fs *fs = mp->um_fs; + register struct fs *dfs, *fs = mp->um_fs; register struct buf *bp; int blks; caddr_t space; - int i, size, error = 0; + int i, size, error, allerror = 0; - bp = getblk(mp->um_devvp, SBLOCK, (int)fs->fs_sbsize, 0, 0); - bcopy((caddr_t)fs, bp->b_data, (u_int)fs->fs_sbsize); - /* Restore compatibility to old file systems. XXX */ - if (fs->fs_postblformat == FS_42POSTBLFMT) /* XXX */ - ((struct fs *)bp->b_data)->fs_nrpos = -1; /* XXX */ - if (waitfor == MNT_WAIT) - error = bwrite(bp); - else - bawrite(bp); + /* + * First write back the summary information. + */ blks = howmany(fs->fs_cssize, fs->fs_fsize); space = (caddr_t)fs->fs_csp[0]; for (i = 0; i < blks; i += fs->fs_frag) { @@ -834,10 +955,37 @@ ffs_sbupdate(mp, waitfor) size, 0, 0); bcopy(space, bp->b_data, (u_int)size); space += size; - if (waitfor == MNT_WAIT) - error = bwrite(bp); - else + if (waitfor != MNT_WAIT) bawrite(bp); + else if (error = bwrite(bp)) + allerror = error; } - return (error); + /* + * Now write back the superblock itself. If any errors occurred + * up to this point, then fail so that the superblock avoids + * being written out as clean. + */ + if (allerror) + return (allerror); + bp = getblk(mp->um_devvp, SBLOCK, (int)fs->fs_sbsize, 0, 0); + bcopy((caddr_t)fs, bp->b_data, (u_int)fs->fs_sbsize); + /* Restore compatibility to old file systems. XXX */ + dfs = (struct fs *)bp->b_data; /* XXX */ + if (fs->fs_postblformat == FS_42POSTBLFMT) /* XXX */ + dfs->fs_nrpos = -1; /* XXX */ + if (fs->fs_inodefmt < FS_44INODEFMT) { /* XXX */ + int32_t *lp, tmp; /* XXX */ + /* XXX */ + lp = (int32_t *)&dfs->fs_qbmask; /* XXX */ + tmp = lp[4]; /* XXX */ + for (i = 4; i > 0; i--) /* XXX */ + lp[i] = lp[i-1]; /* XXX */ + lp[0] = tmp; /* XXX */ + } /* XXX */ + dfs->fs_maxfilesize = mp->um_savedmaxfilesize; /* XXX */ + if (waitfor != MNT_WAIT) + bawrite(bp); + else if (error = bwrite(bp)) + allerror = error; + return (allerror); } diff --git a/sys/ufs/ffs/ffs_vnops.c b/sys/ufs/ffs/ffs_vnops.c index 59814f2..532cb593 100644 --- a/sys/ufs/ffs/ffs_vnops.c +++ b/sys/ufs/ffs/ffs_vnops.c @@ -30,7 +30,7 @@ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. * - * @(#)ffs_vnops.c 8.7 (Berkeley) 2/3/94 + * @(#)ffs_vnops.c 8.15 (Berkeley) 5/14/95 */ #include <sys/param.h> @@ -55,6 +55,7 @@ #include <ufs/ufs/quota.h> #include <ufs/ufs/inode.h> #include <ufs/ufs/dir.h> +#include <ufs/ufs/ufsmount.h> #include <ufs/ufs/ufs_extern.h> #include <ufs/ffs/fs.h> @@ -66,6 +67,7 @@ struct vnodeopv_entry_desc ffs_vnodeop_entries[] = { { &vop_default_desc, vn_default_error }, { &vop_lookup_desc, ufs_lookup }, /* lookup */ { &vop_create_desc, ufs_create }, /* create */ + { &vop_whiteout_desc, ufs_whiteout }, /* whiteout */ { &vop_mknod_desc, ufs_mknod }, /* mknod */ { &vop_open_desc, ufs_open }, /* open */ { &vop_close_desc, ufs_close }, /* close */ @@ -74,8 +76,10 @@ struct vnodeopv_entry_desc ffs_vnodeop_entries[] = { { &vop_setattr_desc, ufs_setattr }, /* setattr */ { &vop_read_desc, ffs_read }, /* read */ { &vop_write_desc, ffs_write }, /* write */ + { &vop_lease_desc, ufs_lease_check }, /* lease */ { &vop_ioctl_desc, ufs_ioctl }, /* ioctl */ { &vop_select_desc, ufs_select }, /* select */ + { &vop_revoke_desc, ufs_revoke }, /* revoke */ { &vop_mmap_desc, ufs_mmap }, /* mmap */ { &vop_fsync_desc, ffs_fsync }, /* fsync */ { &vop_seek_desc, ufs_seek }, /* seek */ @@ -89,7 +93,7 @@ struct vnodeopv_entry_desc ffs_vnodeop_entries[] = { { &vop_readlink_desc, ufs_readlink }, /* readlink */ { &vop_abortop_desc, ufs_abortop }, /* abortop */ { &vop_inactive_desc, ufs_inactive }, /* inactive */ - { &vop_reclaim_desc, ufs_reclaim }, /* reclaim */ + { &vop_reclaim_desc, ffs_reclaim }, /* reclaim */ { &vop_lock_desc, ufs_lock }, /* lock */ { &vop_unlock_desc, ufs_unlock }, /* unlock */ { &vop_bmap_desc, ufs_bmap }, /* bmap */ @@ -123,8 +127,10 @@ struct vnodeopv_entry_desc ffs_specop_entries[] = { { &vop_setattr_desc, ufs_setattr }, /* setattr */ { &vop_read_desc, ufsspec_read }, /* read */ { &vop_write_desc, ufsspec_write }, /* write */ + { &vop_lease_desc, spec_lease_check }, /* lease */ { &vop_ioctl_desc, spec_ioctl }, /* ioctl */ { &vop_select_desc, spec_select }, /* select */ + { &vop_revoke_desc, spec_revoke }, /* revoke */ { &vop_mmap_desc, spec_mmap }, /* mmap */ { &vop_fsync_desc, ffs_fsync }, /* fsync */ { &vop_seek_desc, spec_seek }, /* seek */ @@ -138,7 +144,7 @@ struct vnodeopv_entry_desc ffs_specop_entries[] = { { &vop_readlink_desc, spec_readlink }, /* readlink */ { &vop_abortop_desc, spec_abortop }, /* abortop */ { &vop_inactive_desc, ufs_inactive }, /* inactive */ - { &vop_reclaim_desc, ufs_reclaim }, /* reclaim */ + { &vop_reclaim_desc, ffs_reclaim }, /* reclaim */ { &vop_lock_desc, ufs_lock }, /* lock */ { &vop_unlock_desc, ufs_unlock }, /* unlock */ { &vop_bmap_desc, spec_bmap }, /* bmap */ @@ -173,8 +179,10 @@ struct vnodeopv_entry_desc ffs_fifoop_entries[] = { { &vop_setattr_desc, ufs_setattr }, /* setattr */ { &vop_read_desc, ufsfifo_read }, /* read */ { &vop_write_desc, ufsfifo_write }, /* write */ + { &vop_lease_desc, fifo_lease_check }, /* lease */ { &vop_ioctl_desc, fifo_ioctl }, /* ioctl */ { &vop_select_desc, fifo_select }, /* select */ + { &vop_revoke_desc, fifo_revoke }, /* revoke */ { &vop_mmap_desc, fifo_mmap }, /* mmap */ { &vop_fsync_desc, ffs_fsync }, /* fsync */ { &vop_seek_desc, fifo_seek }, /* seek */ @@ -188,7 +196,7 @@ struct vnodeopv_entry_desc ffs_fifoop_entries[] = { { &vop_readlink_desc, fifo_readlink }, /* readlink */ { &vop_abortop_desc, fifo_abortop }, /* abortop */ { &vop_inactive_desc, ufs_inactive }, /* inactive */ - { &vop_reclaim_desc, ufs_reclaim }, /* reclaim */ + { &vop_reclaim_desc, ffs_reclaim }, /* reclaim */ { &vop_lock_desc, ufs_lock }, /* lock */ { &vop_unlock_desc, ufs_unlock }, /* unlock */ { &vop_bmap_desc, fifo_bmap }, /* bmap */ @@ -210,20 +218,11 @@ struct vnodeopv_desc ffs_fifoop_opv_desc = { &ffs_fifoop_p, ffs_fifoop_entries }; #endif /* FIFO */ -#ifdef DEBUG /* * Enabling cluster read/write operations. */ -#include <sys/sysctl.h> int doclusterread = 1; -struct ctldebug debug11 = { "doclusterread", &doclusterread }; int doclusterwrite = 1; -struct ctldebug debug12 = { "doclusterwrite", &doclusterwrite }; -#else -/* XXX for ufs_readwrite */ -#define doclusterread 1 -#define doclusterwrite 1 -#endif #include <ufs/ufs/ufs_readwrite.c> @@ -286,3 +285,24 @@ loop: tv = time; return (VOP_UPDATE(ap->a_vp, &tv, &tv, ap->a_waitfor == MNT_WAIT)); } + +/* + * Reclaim an inode so that it can be used for other purposes. + */ +int +ffs_reclaim(ap) + struct vop_reclaim_args /* { + struct vnode *a_vp; + struct proc *a_p; + } */ *ap; +{ + register struct vnode *vp = ap->a_vp; + int error; + + if (error = ufs_reclaim(vp, ap->a_p)) + return (error); + FREE(vp->v_data, VFSTOUFS(vp->v_mount)->um_devvp->v_tag == VT_MFS ? + M_MFSNODE : M_FFSNODE); + vp->v_data = NULL; + return (0); +} diff --git a/sys/ufs/ffs/fs.h b/sys/ufs/ffs/fs.h index bef052f..043b980 100644 --- a/sys/ufs/ffs/fs.h +++ b/sys/ufs/ffs/fs.h @@ -30,7 +30,7 @@ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. * - * @(#)fs.h 8.7 (Berkeley) 4/19/94 + * @(#)fs.h 8.13 (Berkeley) 3/21/95 */ /* @@ -61,8 +61,8 @@ #define SBSIZE 8192 #define BBOFF ((off_t)(0)) #define SBOFF ((off_t)(BBOFF + BBSIZE)) -#define BBLOCK ((daddr_t)(0)) -#define SBLOCK ((daddr_t)(BBLOCK + BBSIZE / DEV_BSIZE)) +#define BBLOCK ((ufs_daddr_t)(0)) +#define SBLOCK ((ufs_daddr_t)(BBLOCK + BBSIZE / DEV_BSIZE)) /* * Addresses stored in inodes are capable of addressing fragments @@ -98,12 +98,18 @@ * The path name on which the file system is mounted is maintained * in fs_fsmnt. MAXMNTLEN defines the amount of space allocated in * the super block for this name. + */ +#define MAXMNTLEN 512 + +/* * The limit on the amount of summary information per file system * is defined by MAXCSBUFS. It is currently parameterized for a - * maximum of two million cylinders. + * size of 128 bytes (2 million cylinder groups on machines with + * 32-bit pointers, and 1 million on 64-bit machines). One pointer + * is taken away to point to an array of cluster sizes that is + * computed as cylinder groups are inspected. */ -#define MAXMNTLEN 512 -#define MAXCSBUFS 32 +#define MAXCSBUFS ((128 / sizeof(void *)) - 1) /* * A summary of contiguous blocks of various sizes is maintained @@ -138,105 +144,107 @@ * the ``fs_cs'' macro to work (see below). */ struct csum { - long cs_ndir; /* number of directories */ - long cs_nbfree; /* number of free blocks */ - long cs_nifree; /* number of free inodes */ - long cs_nffree; /* number of free frags */ + int32_t cs_ndir; /* number of directories */ + int32_t cs_nbfree; /* number of free blocks */ + int32_t cs_nifree; /* number of free inodes */ + int32_t cs_nffree; /* number of free frags */ }; /* - * Super block for a file system. + * Super block for an FFS file system. */ struct fs { - struct fs *fs_link; /* linked list of file systems */ - struct fs *fs_rlink; /* used for incore super blocks */ - daddr_t fs_sblkno; /* addr of super-block in filesys */ - daddr_t fs_cblkno; /* offset of cyl-block in filesys */ - daddr_t fs_iblkno; /* offset of inode-blocks in filesys */ - daddr_t fs_dblkno; /* offset of first data after cg */ - long fs_cgoffset; /* cylinder group offset in cylinder */ - long fs_cgmask; /* used to calc mod fs_ntrak */ - time_t fs_time; /* last time written */ - long fs_size; /* number of blocks in fs */ - long fs_dsize; /* number of data blocks in fs */ - long fs_ncg; /* number of cylinder groups */ - long fs_bsize; /* size of basic blocks in fs */ - long fs_fsize; /* size of frag blocks in fs */ - long fs_frag; /* number of frags in a block in fs */ + int32_t fs_firstfield; /* historic file system linked list, */ + int32_t fs_unused_1; /* used for incore super blocks */ + ufs_daddr_t fs_sblkno; /* addr of super-block in filesys */ + ufs_daddr_t fs_cblkno; /* offset of cyl-block in filesys */ + ufs_daddr_t fs_iblkno; /* offset of inode-blocks in filesys */ + ufs_daddr_t fs_dblkno; /* offset of first data after cg */ + int32_t fs_cgoffset; /* cylinder group offset in cylinder */ + int32_t fs_cgmask; /* used to calc mod fs_ntrak */ + time_t fs_time; /* last time written */ + int32_t fs_size; /* number of blocks in fs */ + int32_t fs_dsize; /* number of data blocks in fs */ + int32_t fs_ncg; /* number of cylinder groups */ + int32_t fs_bsize; /* size of basic blocks in fs */ + int32_t fs_fsize; /* size of frag blocks in fs */ + int32_t fs_frag; /* number of frags in a block in fs */ /* these are configuration parameters */ - long fs_minfree; /* minimum percentage of free blocks */ - long fs_rotdelay; /* num of ms for optimal next block */ - long fs_rps; /* disk revolutions per second */ + int32_t fs_minfree; /* minimum percentage of free blocks */ + int32_t fs_rotdelay; /* num of ms for optimal next block */ + int32_t fs_rps; /* disk revolutions per second */ /* these fields can be computed from the others */ - long fs_bmask; /* ``blkoff'' calc of blk offsets */ - long fs_fmask; /* ``fragoff'' calc of frag offsets */ - long fs_bshift; /* ``lblkno'' calc of logical blkno */ - long fs_fshift; /* ``numfrags'' calc number of frags */ + int32_t fs_bmask; /* ``blkoff'' calc of blk offsets */ + int32_t fs_fmask; /* ``fragoff'' calc of frag offsets */ + int32_t fs_bshift; /* ``lblkno'' calc of logical blkno */ + int32_t fs_fshift; /* ``numfrags'' calc number of frags */ /* these are configuration parameters */ - long fs_maxcontig; /* max number of contiguous blks */ - long fs_maxbpg; /* max number of blks per cyl group */ + int32_t fs_maxcontig; /* max number of contiguous blks */ + int32_t fs_maxbpg; /* max number of blks per cyl group */ /* these fields can be computed from the others */ - long fs_fragshift; /* block to frag shift */ - long fs_fsbtodb; /* fsbtodb and dbtofsb shift constant */ - long fs_sbsize; /* actual size of super block */ - long fs_csmask; /* csum block offset */ - long fs_csshift; /* csum block number */ - long fs_nindir; /* value of NINDIR */ - long fs_inopb; /* value of INOPB */ - long fs_nspf; /* value of NSPF */ + int32_t fs_fragshift; /* block to frag shift */ + int32_t fs_fsbtodb; /* fsbtodb and dbtofsb shift constant */ + int32_t fs_sbsize; /* actual size of super block */ + int32_t fs_csmask; /* csum block offset */ + int32_t fs_csshift; /* csum block number */ + int32_t fs_nindir; /* value of NINDIR */ + int32_t fs_inopb; /* value of INOPB */ + int32_t fs_nspf; /* value of NSPF */ /* yet another configuration parameter */ - long fs_optim; /* optimization preference, see below */ + int32_t fs_optim; /* optimization preference, see below */ /* these fields are derived from the hardware */ - long fs_npsect; /* # sectors/track including spares */ - long fs_interleave; /* hardware sector interleave */ - long fs_trackskew; /* sector 0 skew, per track */ - long fs_headswitch; /* head switch time, usec */ - long fs_trkseek; /* track-to-track seek, usec */ + int32_t fs_npsect; /* # sectors/track including spares */ + int32_t fs_interleave; /* hardware sector interleave */ + int32_t fs_trackskew; /* sector 0 skew, per track */ + int32_t fs_headswitch; /* head switch time, usec */ + int32_t fs_trkseek; /* track-to-track seek, usec */ /* sizes determined by number of cylinder groups and their sizes */ - daddr_t fs_csaddr; /* blk addr of cyl grp summary area */ - long fs_cssize; /* size of cyl grp summary area */ - long fs_cgsize; /* cylinder group size */ + ufs_daddr_t fs_csaddr; /* blk addr of cyl grp summary area */ + int32_t fs_cssize; /* size of cyl grp summary area */ + int32_t fs_cgsize; /* cylinder group size */ /* these fields are derived from the hardware */ - long fs_ntrak; /* tracks per cylinder */ - long fs_nsect; /* sectors per track */ - long fs_spc; /* sectors per cylinder */ + int32_t fs_ntrak; /* tracks per cylinder */ + int32_t fs_nsect; /* sectors per track */ + int32_t fs_spc; /* sectors per cylinder */ /* this comes from the disk driver partitioning */ - long fs_ncyl; /* cylinders in file system */ + int32_t fs_ncyl; /* cylinders in file system */ /* these fields can be computed from the others */ - long fs_cpg; /* cylinders per group */ - long fs_ipg; /* inodes per group */ - long fs_fpg; /* blocks per group * fs_frag */ + int32_t fs_cpg; /* cylinders per group */ + int32_t fs_ipg; /* inodes per group */ + int32_t fs_fpg; /* blocks per group * fs_frag */ /* this data must be re-computed after crashes */ struct csum fs_cstotal; /* cylinder summary information */ /* these fields are cleared at mount time */ - char fs_fmod; /* super block modified flag */ - char fs_clean; /* file system is clean flag */ - char fs_ronly; /* mounted read-only flag */ - char fs_flags; /* currently unused flag */ - char fs_fsmnt[MAXMNTLEN]; /* name mounted on */ + int8_t fs_fmod; /* super block modified flag */ + int8_t fs_clean; /* file system is clean flag */ + int8_t fs_ronly; /* mounted read-only flag */ + int8_t fs_flags; /* currently unused flag */ + u_char fs_fsmnt[MAXMNTLEN]; /* name mounted on */ /* these fields retain the current block allocation info */ - long fs_cgrotor; /* last cg searched */ + int32_t fs_cgrotor; /* last cg searched */ struct csum *fs_csp[MAXCSBUFS];/* list of fs_cs info buffers */ - long fs_cpc; /* cyl per cycle in postbl */ - short fs_opostbl[16][8]; /* old rotation block list head */ - long fs_sparecon[50]; /* reserved for future constants */ - long fs_contigsumsize; /* size of cluster summary array */ - long fs_maxsymlinklen; /* max length of an internal symlink */ - long fs_inodefmt; /* format of on-disk inodes */ - u_quad_t fs_maxfilesize; /* maximum representable file size */ - quad_t fs_qbmask; /* ~fs_bmask - for use with quad size */ - quad_t fs_qfmask; /* ~fs_fmask - for use with quad size */ - long fs_state; /* validate fs_clean field */ - long fs_postblformat; /* format of positional layout tables */ - long fs_nrpos; /* number of rotational positions */ - long fs_postbloff; /* (short) rotation block list head */ - long fs_rotbloff; /* (u_char) blocks for each rotation */ - long fs_magic; /* magic number */ - u_char fs_space[1]; /* list of blocks for each rotation */ + int32_t *fs_maxcluster; /* max cluster in each cyl group */ + int32_t fs_cpc; /* cyl per cycle in postbl */ + int16_t fs_opostbl[16][8]; /* old rotation block list head */ + int32_t fs_sparecon[50]; /* reserved for future constants */ + int32_t fs_contigsumsize; /* size of cluster summary array */ + int32_t fs_maxsymlinklen; /* max length of an internal symlink */ + int32_t fs_inodefmt; /* format of on-disk inodes */ + u_int64_t fs_maxfilesize; /* maximum representable file size */ + int64_t fs_qbmask; /* ~fs_bmask for use with 64-bit size */ + int64_t fs_qfmask; /* ~fs_fmask for use with 64-bit size */ + int32_t fs_state; /* validate fs_clean field */ + int32_t fs_postblformat; /* format of positional layout tables */ + int32_t fs_nrpos; /* number of rotational positions */ + int32_t fs_postbloff; /* (u_int16) rotation block list head */ + int32_t fs_rotbloff; /* (u_int8) blocks for each rotation */ + int32_t fs_magic; /* magic number */ + u_int8_t fs_space[1]; /* list of blocks for each rotation */ /* actually longer */ }; + /* - * Filesystem idetification + * Filesystem identification */ #define FS_MAGIC 0x011954 /* the fast filesystem magic number */ #define FS_OKAY 0x7c269d38 /* superblock checksum */ @@ -259,11 +267,12 @@ struct fs { #define fs_postbl(fs, cylno) \ (((fs)->fs_postblformat == FS_42POSTBLFMT) \ ? ((fs)->fs_opostbl[cylno]) \ - : ((short *)((char *)(fs) + (fs)->fs_postbloff) + (cylno) * (fs)->fs_nrpos)) + : ((int16_t *)((u_int8_t *)(fs) + \ + (fs)->fs_postbloff) + (cylno) * (fs)->fs_nrpos)) #define fs_rotbl(fs) \ (((fs)->fs_postblformat == FS_42POSTBLFMT) \ ? ((fs)->fs_space) \ - : ((u_char *)((char *)(fs) + (fs)->fs_rotbloff))) + : ((u_int8_t *)((u_int8_t *)(fs) + (fs)->fs_rotbloff))) /* * The size of a cylinder group is calculated by CGSIZE. The maximum size @@ -272,13 +281,13 @@ struct fs { * cylinder group and the (struct cg) size. */ #define CGSIZE(fs) \ - /* base cg */ (sizeof(struct cg) + sizeof(long) + \ - /* blktot size */ (fs)->fs_cpg * sizeof(long) + \ - /* blks size */ (fs)->fs_cpg * (fs)->fs_nrpos * sizeof(short) + \ + /* base cg */ (sizeof(struct cg) + sizeof(int32_t) + \ + /* blktot size */ (fs)->fs_cpg * sizeof(int32_t) + \ + /* blks size */ (fs)->fs_cpg * (fs)->fs_nrpos * sizeof(int16_t) + \ /* inode map */ howmany((fs)->fs_ipg, NBBY) + \ /* block map */ howmany((fs)->fs_cpg * (fs)->fs_spc / NSPF(fs), NBBY) +\ /* if present */ ((fs)->fs_contigsumsize <= 0 ? 0 : \ - /* cluster sum */ (fs)->fs_contigsumsize * sizeof(long) + \ + /* cluster sum */ (fs)->fs_contigsumsize * sizeof(int32_t) + \ /* cluster map */ howmany((fs)->fs_cpg * (fs)->fs_spc / NSPB(fs), NBBY))) /* @@ -293,79 +302,81 @@ struct fs { * Cylinder group block for a file system. */ #define CG_MAGIC 0x090255 -struct cg { - struct cg *cg_link; /* linked list of cyl groups */ - long cg_magic; /* magic number */ - time_t cg_time; /* time last written */ - long cg_cgx; /* we are the cgx'th cylinder group */ - short cg_ncyl; /* number of cyl's this cg */ - short cg_niblk; /* number of inode blocks this cg */ - long cg_ndblk; /* number of data blocks this cg */ +struct cg { + int32_t cg_firstfield; /* historic cyl groups linked list */ + int32_t cg_magic; /* magic number */ + time_t cg_time; /* time last written */ + int32_t cg_cgx; /* we are the cgx'th cylinder group */ + int16_t cg_ncyl; /* number of cyl's this cg */ + int16_t cg_niblk; /* number of inode blocks this cg */ + int32_t cg_ndblk; /* number of data blocks this cg */ struct csum cg_cs; /* cylinder summary information */ - long cg_rotor; /* position of last used block */ - long cg_frotor; /* position of last used frag */ - long cg_irotor; /* position of last used inode */ - long cg_frsum[MAXFRAG]; /* counts of available frags */ - long cg_btotoff; /* (long) block totals per cylinder */ - long cg_boff; /* (short) free block positions */ - long cg_iusedoff; /* (char) used inode map */ - long cg_freeoff; /* (u_char) free block map */ - long cg_nextfreeoff; /* (u_char) next available space */ - long cg_clustersumoff; /* (long) counts of avail clusters */ - long cg_clusteroff; /* (char) free cluster map */ - long cg_nclusterblks; /* number of clusters this cg */ - long cg_sparecon[13]; /* reserved for future use */ - u_char cg_space[1]; /* space for cylinder group maps */ + int32_t cg_rotor; /* position of last used block */ + int32_t cg_frotor; /* position of last used frag */ + int32_t cg_irotor; /* position of last used inode */ + int32_t cg_frsum[MAXFRAG]; /* counts of available frags */ + int32_t cg_btotoff; /* (int32) block totals per cylinder */ + int32_t cg_boff; /* (u_int16) free block positions */ + int32_t cg_iusedoff; /* (u_int8) used inode map */ + int32_t cg_freeoff; /* (u_int8) free block map */ + int32_t cg_nextfreeoff; /* (u_int8) next available space */ + int32_t cg_clustersumoff; /* (u_int32) counts of avail clusters */ + int32_t cg_clusteroff; /* (u_int8) free cluster map */ + int32_t cg_nclusterblks; /* number of clusters this cg */ + int32_t cg_sparecon[13]; /* reserved for future use */ + u_int8_t cg_space[1]; /* space for cylinder group maps */ /* actually longer */ }; + /* * Macros for access to cylinder group array structures */ #define cg_blktot(cgp) \ (((cgp)->cg_magic != CG_MAGIC) \ ? (((struct ocg *)(cgp))->cg_btot) \ - : ((long *)((char *)(cgp) + (cgp)->cg_btotoff))) + : ((int32_t *)((u_int8_t *)(cgp) + (cgp)->cg_btotoff))) #define cg_blks(fs, cgp, cylno) \ (((cgp)->cg_magic != CG_MAGIC) \ ? (((struct ocg *)(cgp))->cg_b[cylno]) \ - : ((short *)((char *)(cgp) + (cgp)->cg_boff) + (cylno) * (fs)->fs_nrpos)) + : ((int16_t *)((u_int8_t *)(cgp) + \ + (cgp)->cg_boff) + (cylno) * (fs)->fs_nrpos)) #define cg_inosused(cgp) \ (((cgp)->cg_magic != CG_MAGIC) \ ? (((struct ocg *)(cgp))->cg_iused) \ - : ((char *)((char *)(cgp) + (cgp)->cg_iusedoff))) + : ((u_int8_t *)((u_int8_t *)(cgp) + (cgp)->cg_iusedoff))) #define cg_blksfree(cgp) \ (((cgp)->cg_magic != CG_MAGIC) \ ? (((struct ocg *)(cgp))->cg_free) \ - : ((u_char *)((char *)(cgp) + (cgp)->cg_freeoff))) + : ((u_int8_t *)((u_int8_t *)(cgp) + (cgp)->cg_freeoff))) #define cg_chkmagic(cgp) \ ((cgp)->cg_magic == CG_MAGIC || ((struct ocg *)(cgp))->cg_magic == CG_MAGIC) #define cg_clustersfree(cgp) \ - ((u_char *)((char *)(cgp) + (cgp)->cg_clusteroff)) + ((u_int8_t *)((u_int8_t *)(cgp) + (cgp)->cg_clusteroff)) #define cg_clustersum(cgp) \ - ((long *)((char *)(cgp) + (cgp)->cg_clustersumoff)) + ((int32_t *)((u_int8_t *)(cgp) + (cgp)->cg_clustersumoff)) /* * The following structure is defined * for compatibility with old file systems. */ -struct ocg { - struct ocg *cg_link; /* linked list of cyl groups */ - struct ocg *cg_rlink; /* used for incore cyl groups */ - time_t cg_time; /* time last written */ - long cg_cgx; /* we are the cgx'th cylinder group */ - short cg_ncyl; /* number of cyl's this cg */ - short cg_niblk; /* number of inode blocks this cg */ - long cg_ndblk; /* number of data blocks this cg */ +struct ocg { + int32_t cg_firstfield; /* historic linked list of cyl groups */ + int32_t cg_unused_1; /* used for incore cyl groups */ + time_t cg_time; /* time last written */ + int32_t cg_cgx; /* we are the cgx'th cylinder group */ + int16_t cg_ncyl; /* number of cyl's this cg */ + int16_t cg_niblk; /* number of inode blocks this cg */ + int32_t cg_ndblk; /* number of data blocks this cg */ struct csum cg_cs; /* cylinder summary information */ - long cg_rotor; /* position of last used block */ - long cg_frotor; /* position of last used frag */ - long cg_irotor; /* position of last used inode */ - long cg_frsum[8]; /* counts of available frags */ - long cg_btot[32]; /* block totals per cylinder */ - short cg_b[32][8]; /* positions of free blocks */ - char cg_iused[256]; /* used inode map */ - long cg_magic; /* magic number */ - u_char cg_free[1]; /* free block map */ + int32_t cg_rotor; /* position of last used block */ + int32_t cg_frotor; /* position of last used frag */ + int32_t cg_irotor; /* position of last used inode */ + int32_t cg_frsum[8]; /* counts of available frags */ + int32_t cg_btot[32]; /* block totals per cylinder */ + int16_t cg_b[32][8]; /* positions of free blocks */ + u_int8_t cg_iused[256]; /* used inode map */ + int32_t cg_magic; /* magic number */ + u_int8_t cg_free[1]; /* free block map */ /* actually longer */ }; @@ -380,7 +391,7 @@ struct ocg { * Cylinder group macros to locate things in cylinder groups. * They calc file system addresses of cylinder group data structures. */ -#define cgbase(fs, c) ((daddr_t)((fs)->fs_fpg * (c))) +#define cgbase(fs, c) ((ufs_daddr_t)((fs)->fs_fpg * (c))) #define cgdmin(fs, c) (cgstart(fs, c) + (fs)->fs_dblkno) /* 1st data */ #define cgimin(fs, c) (cgstart(fs, c) + (fs)->fs_iblkno) /* inode blk */ #define cgsblock(fs, c) (cgstart(fs, c) + (fs)->fs_sblkno) /* super blk */ @@ -396,7 +407,7 @@ struct ocg { */ #define ino_to_cg(fs, x) ((x) / (fs)->fs_ipg) #define ino_to_fsba(fs, x) \ - ((daddr_t)(cgimin(fs, ino_to_cg(fs, x)) + \ + ((ufs_daddr_t)(cgimin(fs, ino_to_cg(fs, x)) + \ (blkstofrags((fs), (((x) % (fs)->fs_ipg) / INOPB(fs)))))) #define ino_to_fsbo(fs, x) ((x) % INOPB(fs)) @@ -450,7 +461,7 @@ struct ocg { /* * Determine the number of available frags given a - * percentage to hold in reserve + * percentage to hold in reserve. */ #define freespace(fs, percentreserved) \ (blkstofrags((fs), (fs)->fs_cstotal.cs_nbfree) + \ @@ -469,19 +480,20 @@ struct ocg { : (fragroundup(fs, blkoff(fs, (dip)->di_size)))) /* - * Number of disk sectors per block; assumes DEV_BSIZE byte sector size. + * Number of disk sectors per block/fragment; assumes DEV_BSIZE byte + * sector size. */ #define NSPB(fs) ((fs)->fs_nspf << (fs)->fs_fragshift) #define NSPF(fs) ((fs)->fs_nspf) /* - * INOPB is the number of inodes in a secondary storage block. + * Number of inodes in a secondary storage block/fragment. */ #define INOPB(fs) ((fs)->fs_inopb) #define INOPF(fs) ((fs)->fs_inopb >> (fs)->fs_fragshift) /* - * NINDIR is the number of indirects in a file system block. + * Number of indirects in a file system block. */ #define NINDIR(fs) ((fs)->fs_nindir) diff --git a/sys/ufs/lfs/lfs.h b/sys/ufs/lfs/lfs.h index 87b8c22..855b331 100644 --- a/sys/ufs/lfs/lfs.h +++ b/sys/ufs/lfs/lfs.h @@ -30,7 +30,7 @@ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. * - * @(#)lfs.h 8.3 (Berkeley) 9/23/93 + * @(#)lfs.h 8.9 (Berkeley) 5/8/95 */ #define LFS_LABELPAD 8192 /* LFS label size */ @@ -55,14 +55,15 @@ /* On-disk and in-memory checkpoint segment usage structure. */ typedef struct segusage SEGUSE; struct segusage { - u_long su_nbytes; /* number of live bytes */ - u_long su_lastmod; /* SEGUSE last modified timestamp */ - u_short su_nsums; /* number of summaries in segment */ - u_short su_ninos; /* number of inode blocks in seg */ -#define SEGUSE_ACTIVE 0x1 /* segment is currently being written */ -#define SEGUSE_DIRTY 0x2 /* segment has data in it */ -#define SEGUSE_SUPERBLOCK 0x4 /* segment contains a superblock */ - u_long su_flags; + u_int32_t su_nbytes; /* number of live bytes */ + u_int32_t su_lastmod; /* SEGUSE last modified timestamp */ + u_int16_t su_nsums; /* number of summaries in segment */ + u_int16_t su_ninos; /* number of inode blocks in seg */ + +#define SEGUSE_ACTIVE 0x01 /* segment is currently being written */ +#define SEGUSE_DIRTY 0x02 /* segment has data in it */ +#define SEGUSE_SUPERBLOCK 0x04 /* segment contains a superblock */ + u_int32_t su_flags; }; #define SEGUPB(fs) (1 << (fs)->lfs_sushift) @@ -72,98 +73,102 @@ struct segusage { /* On-disk file information. One per file with data blocks in the segment. */ typedef struct finfo FINFO; struct finfo { - u_long fi_nblocks; /* number of blocks */ - u_long fi_version; /* version number */ - u_long fi_ino; /* inode number */ - long fi_blocks[1]; /* array of logical block numbers */ + u_int32_t fi_nblocks; /* number of blocks */ + u_int32_t fi_version; /* version number */ + u_int32_t fi_ino; /* inode number */ + u_int32_t fi_lastlength; /* length of last block in array */ + ufs_daddr_t fi_blocks[1]; /* array of logical block numbers */ }; /* On-disk and in-memory super block. */ struct lfs { #define LFS_MAGIC 0x070162 - u_long lfs_magic; /* magic number */ + u_int32_t lfs_magic; /* magic number */ #define LFS_VERSION 1 - u_long lfs_version; /* version number */ + u_int32_t lfs_version; /* version number */ - u_long lfs_size; /* number of blocks in fs */ - u_long lfs_ssize; /* number of blocks per segment */ - u_long lfs_dsize; /* number of disk blocks in fs */ - u_long lfs_bsize; /* file system block size */ - u_long lfs_fsize; /* size of frag blocks in fs */ - u_long lfs_frag; /* number of frags in a block in fs */ + u_int32_t lfs_size; /* number of blocks in fs */ + u_int32_t lfs_ssize; /* number of blocks per segment */ + u_int32_t lfs_dsize; /* number of disk blocks in fs */ + u_int32_t lfs_bsize; /* file system block size */ + u_int32_t lfs_fsize; /* size of frag blocks in fs */ + u_int32_t lfs_frag; /* number of frags in a block in fs */ /* Checkpoint region. */ - ino_t lfs_free; /* start of the free list */ - u_long lfs_bfree; /* number of free disk blocks */ - u_long lfs_nfiles; /* number of allocated inodes */ - long lfs_avail; /* blocks available for writing */ - u_long lfs_uinodes; /* inodes in cache not yet on disk */ - daddr_t lfs_idaddr; /* inode file disk address */ - ino_t lfs_ifile; /* inode file inode number */ - daddr_t lfs_lastseg; /* address of last segment written */ - daddr_t lfs_nextseg; /* address of next segment to write */ - daddr_t lfs_curseg; /* current segment being written */ - daddr_t lfs_offset; /* offset in curseg for next partial */ - daddr_t lfs_lastpseg; /* address of last partial written */ - u_long lfs_tstamp; /* time stamp */ + ino_t lfs_free; /* start of the free list */ + u_int32_t lfs_bfree; /* number of free disk blocks */ + u_int32_t lfs_nfiles; /* number of allocated inodes */ + int32_t lfs_avail; /* blocks available for writing */ + u_int32_t lfs_uinodes; /* inodes in cache not yet on disk */ + ufs_daddr_t lfs_idaddr; /* inode file disk address */ + ino_t lfs_ifile; /* inode file inode number */ + ufs_daddr_t lfs_lastseg; /* address of last segment written */ + ufs_daddr_t lfs_nextseg; /* address of next segment to write */ + ufs_daddr_t lfs_curseg; /* current segment being written */ + ufs_daddr_t lfs_offset; /* offset in curseg for next partial */ + ufs_daddr_t lfs_lastpseg; /* address of last partial written */ + u_int32_t lfs_tstamp; /* time stamp */ /* These are configuration parameters. */ - u_long lfs_minfree; /* minimum percentage of free blocks */ + u_int32_t lfs_minfree; /* minimum percentage of free blocks */ /* These fields can be computed from the others. */ - u_quad_t lfs_maxfilesize; /* maximum representable file size */ - u_long lfs_dbpseg; /* disk blocks per segment */ - u_long lfs_inopb; /* inodes per block */ - u_long lfs_ifpb; /* IFILE entries per block */ - u_long lfs_sepb; /* SEGUSE entries per block */ - u_long lfs_nindir; /* indirect pointers per block */ - u_long lfs_nseg; /* number of segments */ - u_long lfs_nspf; /* number of sectors per fragment */ - u_long lfs_cleansz; /* cleaner info size in blocks */ - u_long lfs_segtabsz; /* segment table size in blocks */ - - u_long lfs_segmask; /* calculate offset within a segment */ - u_long lfs_segshift; /* fast mult/div for segments */ - u_long lfs_bmask; /* calc block offset from file offset */ - u_long lfs_bshift; /* calc block number from file offset */ - u_long lfs_ffmask; /* calc frag offset from file offset */ - u_long lfs_ffshift; /* fast mult/div for frag from file */ - u_long lfs_fbmask; /* calc frag offset from block offset */ - u_long lfs_fbshift; /* fast mult/div for frag from block */ - u_long lfs_fsbtodb; /* fsbtodb and dbtofsb shift constant */ - u_long lfs_sushift; /* fast mult/div for segusage table */ + u_int64_t lfs_maxfilesize; /* maximum representable file size */ + u_int32_t lfs_dbpseg; /* disk blocks per segment */ + u_int32_t lfs_inopb; /* inodes per block */ + u_int32_t lfs_ifpb; /* IFILE entries per block */ + u_int32_t lfs_sepb; /* SEGUSE entries per block */ + u_int32_t lfs_nindir; /* indirect pointers per block */ + u_int32_t lfs_nseg; /* number of segments */ + u_int32_t lfs_nspf; /* number of sectors per fragment */ + u_int32_t lfs_cleansz; /* cleaner info size in blocks */ + u_int32_t lfs_segtabsz; /* segment table size in blocks */ + + u_int32_t lfs_segmask; /* calculate offset within a segment */ + u_int32_t lfs_segshift; /* fast mult/div for segments */ + u_int64_t lfs_bmask; /* calc block offset from file offset */ + u_int32_t lfs_bshift; /* calc block number from file offset */ + u_int64_t lfs_ffmask; /* calc frag offset from file offset */ + u_int32_t lfs_ffshift; /* fast mult/div for frag from file */ + u_int64_t lfs_fbmask; /* calc frag offset from block offset */ + u_int32_t lfs_fbshift; /* fast mult/div for frag from block */ + u_int32_t lfs_fsbtodb; /* fsbtodb and dbtofsb shift constant */ + u_int32_t lfs_sushift; /* fast mult/div for segusage table */ + + int32_t lfs_maxsymlinklen; /* max length of an internal symlink */ #define LFS_MIN_SBINTERVAL 5 /* minimum superblock segment spacing */ #define LFS_MAXNUMSB 10 /* superblock disk offsets */ - daddr_t lfs_sboffs[LFS_MAXNUMSB]; + ufs_daddr_t lfs_sboffs[LFS_MAXNUMSB]; + +/* Checksum -- last valid disk field. */ + u_int32_t lfs_cksum; /* checksum for superblock checking */ /* These fields are set at mount time and are meaningless on disk. */ - struct segment *lfs_sp; /* current segment being written */ - struct vnode *lfs_ivnode; /* vnode for the ifile */ - u_long lfs_seglock; /* single-thread the segment writer */ - pid_t lfs_lockpid; /* pid of lock holder */ - u_long lfs_iocount; /* number of ios pending */ - u_long lfs_writer; /* don't allow any dirops to start */ - u_long lfs_dirops; /* count of active directory ops */ - u_long lfs_doifile; /* Write ifile blocks on next write */ - u_long lfs_nactive; /* Number of segments since last ckp */ - u_char lfs_fmod; /* super block modified flag */ - u_char lfs_clean; /* file system is clean flag */ - u_char lfs_ronly; /* mounted read-only flag */ - u_char lfs_flags; /* currently unused flag */ - u_char lfs_fsmnt[MNAMELEN]; /* name mounted on */ - u_char pad[3]; /* long-align */ - -/* Checksum; valid on disk. */ - u_long lfs_cksum; /* checksum for superblock checking */ + struct segment *lfs_sp; /* current segment being written */ + struct vnode *lfs_ivnode; /* vnode for the ifile */ + u_long lfs_seglock; /* single-thread the segment writer */ + pid_t lfs_lockpid; /* pid of lock holder */ + u_long lfs_iocount; /* number of ios pending */ + u_long lfs_writer; /* don't allow any dirops to start */ + u_long lfs_dirops; /* count of active directory ops */ + u_long lfs_doifile; /* Write ifile blocks on next write */ + u_long lfs_nactive; /* Number of segments since last ckp */ + int8_t lfs_fmod; /* super block modified flag */ + int8_t lfs_clean; /* file system is clean flag */ + int8_t lfs_ronly; /* mounted read-only flag */ + int8_t lfs_flags; /* currently unused flag */ + u_char lfs_fsmnt[MNAMELEN]; /* name mounted on */ + + int32_t lfs_pad[40]; /* round to 512 bytes */ }; /* - * Inode 0 is the out-of-band inode number, inode 1 is the inode number for - * the IFILE, the root inode is 2 and the lost+found inode is 3. + * Inode 0: out-of-band inode number + * Inode 1: IFILE inode number + * Inode 2: root inode + * Inode 3: lost+found inode number */ - -/* Fixed inode numbers. */ #define LFS_UNUSED_INUM 0 /* out of band inode number */ #define LFS_IFILE_INUM 1 /* IFILE inode number */ #define LOSTFOUNDINO 3 /* lost+found inode number */ @@ -182,10 +187,10 @@ struct lfs { typedef struct ifile IFILE; struct ifile { - u_long if_version; /* inode version number */ + u_int32_t if_version; /* inode version number */ #define LFS_UNUSED_DADDR 0 /* out-of-band daddr */ - daddr_t if_daddr; /* inode disk address */ - ino_t if_nextfree; /* next-unallocated inode */ + ufs_daddr_t if_daddr; /* inode disk address */ + ino_t if_nextfree; /* next-unallocated inode */ }; /* @@ -193,8 +198,8 @@ struct ifile { * to pass information between the cleaner and the kernel. */ typedef struct _cleanerinfo { - u_long clean; /* K: number of clean segments */ - u_long dirty; /* K: number of dirty segments */ + u_int32_t clean; /* K: number of clean segments */ + u_int32_t dirty; /* K: number of dirty segments */ } CLEANERINFO; #define CLEANSIZE_SU(fs) \ @@ -209,16 +214,19 @@ typedef struct _cleanerinfo { /* On-disk segment summary information */ typedef struct segsum SEGSUM; struct segsum { - u_long ss_sumsum; /* check sum of summary block */ - u_long ss_datasum; /* check sum of data */ - daddr_t ss_next; /* next segment */ - u_long ss_create; /* creation time stamp */ - u_short ss_nfinfo; /* number of file info structures */ - u_short ss_ninos; /* number of inodes in summary */ + u_int32_t ss_sumsum; /* check sum of summary block */ + u_int32_t ss_datasum; /* check sum of data */ + u_int32_t ss_magic; /* segment summary magic number */ +#define SS_MAGIC 0x061561 + ufs_daddr_t ss_next; /* next segment */ + u_int32_t ss_create; /* creation time stamp */ + u_int16_t ss_nfinfo; /* number of file info structures */ + u_int16_t ss_ninos; /* number of inodes in summary */ + #define SS_DIROP 0x01 /* segment begins a dirop */ #define SS_CONT 0x02 /* more partials to finish this write*/ - u_short ss_flags; /* used for directory operations */ - u_short ss_pad; /* extra space */ + u_int16_t ss_flags; /* used for directory operations */ + u_int16_t ss_pad; /* extra space */ /* FINFO's and inode daddr's... */ }; @@ -228,26 +236,48 @@ struct segsum { /* INOPB is the number of inodes in a secondary storage block. */ #define INOPB(fs) ((fs)->lfs_inopb) -#define blksize(fs) ((fs)->lfs_bsize) -#define blkoff(fs, loc) ((loc) & (fs)->lfs_bmask) +#define blksize(fs, ip, lbn) \ + (((lbn) >= NDADDR || (ip)->i_size >= ((lbn) + 1) << (fs)->lfs_bshift) \ + ? (fs)->lfs_bsize \ + : (fragroundup(fs, blkoff(fs, (ip)->i_size)))) +#define blkoff(fs, loc) ((int)((loc) & (fs)->lfs_bmask)) +#define fragoff(fs, loc) /* calculates (loc % fs->lfs_fsize) */ \ + ((int)((loc) & (fs)->lfs_ffmask)) #define fsbtodb(fs, b) ((b) << (fs)->lfs_fsbtodb) #define dbtofsb(fs, b) ((b) >> (fs)->lfs_fsbtodb) +#define fragstodb(fs, b) ((b) << (fs)->lfs_fsbtodb - (fs)->lfs_fbshift) +#define dbtofrags(fs, b) ((b) >> (fs)->lfs_fsbtodb - (fs)->lfs_fbshift) #define lblkno(fs, loc) ((loc) >> (fs)->lfs_bshift) #define lblktosize(fs, blk) ((blk) << (fs)->lfs_bshift) -#define numfrags(fs, loc) /* calculates (loc / fs->fs_fsize) */ \ - ((loc) >> (fs)->lfs_bshift) - +#define numfrags(fs, loc) /* calculates (loc / fs->lfs_fsize) */ \ + ((loc) >> (fs)->lfs_ffshift) +#define blkroundup(fs, size) /* calculates roundup(size, fs->lfs_bsize) */ \ + ((int)(((size) + (fs)->lfs_bmask) & (~(fs)->lfs_bmask))) +#define fragroundup(fs, size) /* calculates roundup(size, fs->lfs_fsize) */ \ + ((int)(((size) + (fs)->lfs_ffmask) & (~(fs)->lfs_ffmask))) +#define fragstoblks(fs, frags) /* calculates (frags / fs->lfs_frag) */ \ + ((frags) >> (fs)->lfs_fbshift) +#define blkstofrags(fs, blks) /* calculates (blks * fs->lfs_frag) */ \ + ((blks) << (fs)->lfs_fbshift) +#define fragnum(fs, fsb) /* calculates (fsb % fs->lfs_frag) */ \ + ((fsb) & ((fs)->lfs_frag - 1)) +#define blknum(fs, fsb) /* calculates rounddown(fsb, fs->lfs_frag) */ \ + ((fsb) &~ ((fs)->lfs_frag - 1)) +#define dblksize(fs, dip, lbn) \ + (((lbn) >= NDADDR || (dip)->di_size >= ((lbn) + 1) << (fs)->lfs_bshift)\ + ? (fs)->lfs_bsize \ + : (fragroundup(fs, blkoff(fs, (dip)->di_size)))) #define datosn(fs, daddr) /* disk address to segment number */ \ (((daddr) - (fs)->lfs_sboffs[0]) / fsbtodb((fs), (fs)->lfs_ssize)) #define sntoda(fs, sn) /* segment number to disk address */ \ - ((daddr_t)((sn) * ((fs)->lfs_ssize << (fs)->lfs_fsbtodb) + \ + ((ufs_daddr_t)((sn) * ((fs)->lfs_ssize << (fs)->lfs_fsbtodb) + \ (fs)->lfs_sboffs[0])) /* Read in the block with the cleaner info from the ifile. */ #define LFS_CLEANERINFO(CP, F, BP) { \ VTOI((F)->lfs_ivnode)->i_flag |= IN_ACCESS; \ if (bread((F)->lfs_ivnode, \ - (daddr_t)0, (F)->lfs_bsize, NOCRED, &(BP))) \ + (ufs_daddr_t)0, (F)->lfs_bsize, NOCRED, &(BP))) \ panic("lfs: ifile read"); \ (CP) = (CLEANERINFO *)(BP)->b_data; \ } @@ -281,8 +311,8 @@ struct segsum { * the segment usage table, plus an ifile page. */ #define LFS_FITS(fs, db) \ - ((long)((db + ((fs)->lfs_uinodes + INOPB((fs))) / INOPB((fs)) + \ - fsbtodb(fs, 1) + LFS_SUMMARY_SIZE / DEV_BSIZE + \ + ((int32_t)((db + ((fs)->lfs_uinodes + INOPB((fs))) / \ + INOPB((fs)) + fsbtodb(fs, 1) + LFS_SUMMARY_SIZE / DEV_BSIZE + \ (fs)->lfs_segtabsz)) < (fs)->lfs_avail) /* Determine if a buffer belongs to the ifile */ @@ -294,32 +324,34 @@ struct segsum { */ typedef struct block_info { ino_t bi_inode; /* inode # */ - daddr_t bi_lbn; /* logical block w/in file */ - daddr_t bi_daddr; /* disk address of block */ + ufs_daddr_t bi_lbn; /* logical block w/in file */ + ufs_daddr_t bi_daddr; /* disk address of block */ time_t bi_segcreate; /* origin segment create time */ int bi_version; /* file version number */ void *bi_bp; /* data buffer */ + int bi_size; /* size of the block (if fragment) */ } BLOCK_INFO; /* In-memory description of a segment about to be written. */ struct segment { - struct lfs *fs; /* file system pointer */ + struct lfs *fs; /* file system pointer */ struct buf **bpp; /* pointer to buffer array */ struct buf **cbpp; /* pointer to next available bp */ struct buf **start_bpp; /* pointer to first bp in this set */ - struct buf *ibp; /* buffer pointer to inode page */ - struct finfo *fip; /* current fileinfo pointer */ - struct vnode *vp; /* vnode being gathered */ - void *segsum; /* segment summary info */ - u_long ninodes; /* number of inodes in this segment */ - u_long seg_bytes_left; /* bytes left in segment */ - u_long sum_bytes_left; /* bytes left in summary block */ - u_long seg_number; /* number of this segment */ - daddr_t *start_lbp; /* beginning lbn for this set */ + struct buf *ibp; /* buffer pointer to inode page */ + struct finfo *fip; /* current fileinfo pointer */ + struct vnode *vp; /* vnode being gathered */ + void *segsum; /* segment summary info */ + u_int32_t ninodes; /* number of inodes in this segment */ + u_int32_t seg_bytes_left; /* bytes left in segment */ + u_int32_t sum_bytes_left; /* bytes left in summary block */ + u_int32_t seg_number; /* number of this segment */ + ufs_daddr_t *start_lbp; /* beginning lbn for this set */ + #define SEGM_CKP 0x01 /* doing a checkpoint */ #define SEGM_CLEAN 0x02 /* cleaner call; don't sort */ #define SEGM_SYNC 0x04 /* wait for segment */ - u_long seg_flags; /* run-time flags for this segment */ + u_int16_t seg_flags; /* run-time flags for this segment */ }; #define ISSPACE(F, BB, C) \ @@ -336,18 +368,18 @@ struct segment { #ifdef DOSTATS /* Statistics Counters */ struct lfs_stats { - int segsused; - int psegwrites; - int psyncwrites; - int pcleanwrites; - int blocktot; - int cleanblocks; - int ncheckpoints; - int nwrites; - int nsync_writes; - int wait_exceeded; - int write_exceeded; - int flush_invoked; + u_int segsused; + u_int psegwrites; + u_int psyncwrites; + u_int pcleanwrites; + u_int blocktot; + u_int cleanblocks; + u_int ncheckpoints; + u_int nwrites; + u_int nsync_writes; + u_int wait_exceeded; + u_int write_exceeded; + u_int flush_invoked; }; extern struct lfs_stats lfs_stats; #endif diff --git a/sys/ufs/lfs/lfs_alloc.c b/sys/ufs/lfs/lfs_alloc.c index 3f06c81..837d2ea 100644 --- a/sys/ufs/lfs/lfs_alloc.c +++ b/sys/ufs/lfs/lfs_alloc.c @@ -1,5 +1,5 @@ /* - * Copyright (c) 1991, 1993 + * Copyright (c) 1991, 1993, 1995 * The Regents of the University of California. All rights reserved. * * Redistribution and use in source and binary forms, with or without @@ -30,7 +30,7 @@ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. * - * @(#)lfs_alloc.c 8.4 (Berkeley) 1/4/94 + * @(#)lfs_alloc.c 8.7 (Berkeley) 5/14/95 */ #include <sys/param.h> @@ -46,6 +46,7 @@ #include <ufs/ufs/quota.h> #include <ufs/ufs/inode.h> #include <ufs/ufs/ufsmount.h> +#include <ufs/ufs/ufs_extern.h> #include <ufs/lfs/lfs.h> #include <ufs/lfs/lfs_extern.h> @@ -68,7 +69,7 @@ lfs_valloc(ap) struct ifile *ifp; struct inode *ip; struct vnode *vp; - daddr_t blkno; + ufs_daddr_t blkno; ino_t new_ino; u_long i, max; int error; @@ -95,7 +96,7 @@ lfs_valloc(ap) vp = fs->lfs_ivnode; ip = VTOI(vp); blkno = lblkno(fs, ip->i_size); - lfs_balloc(vp, fs->lfs_bsize, blkno, &bp); + lfs_balloc(vp, 0, fs->lfs_bsize, blkno, &bp); ip->i_size += fs->lfs_bsize; vnode_pager_setsize(vp, (u_long)ip->i_size); vnode_pager_uncache(vp); @@ -172,14 +173,13 @@ lfs_vcreate(mp, ino, vpp) /* Initialize the inode. */ MALLOC(ip, struct inode *, sizeof(struct inode), M_LFSNODE, M_WAITOK); + lockinit(&ip->i_lock, PINOD, "lfsinode", 0, 0); (*vpp)->v_data = ip; ip->i_vnode = *vpp; ip->i_devvp = ump->um_devvp; ip->i_flag = IN_MODIFIED; ip->i_dev = ump->um_dev; ip->i_number = ip->i_din.di_inumber = ino; -ip->i_din.di_spare[0] = 0xdeadbeef; -ip->i_din.di_spare[1] = 0xdeadbeef; ip->i_lfs = ump->um_lfs; #ifdef QUOTA for (i = 0; i < MAXQUOTAS; i++) @@ -209,7 +209,7 @@ lfs_vfree(ap) struct ifile *ifp; struct inode *ip; struct lfs *fs; - daddr_t old_iaddr; + ufs_daddr_t old_iaddr; ino_t ino; /* Get the inode number and file system. */ diff --git a/sys/ufs/lfs/lfs_balloc.c b/sys/ufs/lfs/lfs_balloc.c index b56bc9e..ec0c027 100644 --- a/sys/ufs/lfs/lfs_balloc.c +++ b/sys/ufs/lfs/lfs_balloc.c @@ -30,7 +30,7 @@ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. * - * @(#)lfs_balloc.c 8.1 (Berkeley) 6/11/93 + * @(#)lfs_balloc.c 8.4 (Berkeley) 5/8/95 */ #include <sys/param.h> #include <sys/buf.h> @@ -50,18 +50,20 @@ #include <ufs/lfs/lfs_extern.h> int -lfs_balloc(vp, iosize, lbn, bpp) +lfs_balloc(vp, offset, iosize, lbn, bpp) struct vnode *vp; + int offset; u_long iosize; - daddr_t lbn; + ufs_daddr_t lbn; struct buf **bpp; { struct buf *ibp, *bp; struct inode *ip; struct lfs *fs; struct indir indirs[NIADDR+2]; - daddr_t daddr; - int bb, error, i, num; + ufs_daddr_t daddr, lastblock; + int bb; /* number of disk blocks in a block disk blocks */ + int error, frags, i, nsize, osize, num; ip = VTOI(vp); fs = ip->i_lfs; @@ -74,43 +76,90 @@ lfs_balloc(vp, iosize, lbn, bpp) * or written earlier). If it did, make sure we don't count it as a * new block or zero out its contents. If it did not, make sure * we allocate any necessary indirect blocks. + * If we are writing a block beyond the end of the file, we need to + * check if the old last block was a fragment. If it was, we need + * to rewrite it. */ *bpp = NULL; if (error = ufs_bmaparray(vp, lbn, &daddr, &indirs[0], &num, NULL )) return (error); - *bpp = bp = getblk(vp, lbn, fs->lfs_bsize, 0, 0); + /* Check for block beyond end of file and fragment extension needed. */ + lastblock = lblkno(fs, ip->i_size); + if (lastblock < NDADDR && lastblock < lbn) { + osize = blksize(fs, ip, lastblock); + if (osize < fs->lfs_bsize && osize > 0) { + if (error = lfs_fragextend(vp, osize, fs->lfs_bsize, + lastblock, &bp)) + return(error); + ip->i_size = (lastblock + 1) * fs->lfs_bsize; + vnode_pager_setsize(vp, (u_long)ip->i_size); + ip->i_flag |= IN_CHANGE | IN_UPDATE; + VOP_BWRITE(bp); + } + } + bb = VFSTOUFS(vp->v_mount)->um_seqinc; if (daddr == UNASSIGNED) /* May need to allocate indirect blocks */ for (i = 1; i < num; ++i) if (!indirs[i].in_exists) { - ibp = - getblk(vp, indirs[i].in_lbn, fs->lfs_bsize, - 0, 0); - if (!(ibp->b_flags & (B_DONE | B_DELWRI))) { - if (!ISSPACE(fs, bb, curproc->p_ucred)){ - ibp->b_flags |= B_INVAL; - brelse(ibp); - error = ENOSPC; - } else { - ip->i_blocks += bb; - ip->i_lfs->lfs_bfree -= bb; - clrbuf(ibp); - error = VOP_BWRITE(ibp); - } - } else + ibp = getblk(vp, indirs[i].in_lbn, fs->lfs_bsize, + 0, 0); + if ((ibp->b_flags & (B_DONE | B_DELWRI))) panic ("Indirect block should not exist"); + + if (!ISSPACE(fs, bb, curproc->p_ucred)){ + ibp->b_flags |= B_INVAL; + brelse(ibp); + return(ENOSPC); + } else { + ip->i_blocks += bb; + ip->i_lfs->lfs_bfree -= bb; + clrbuf(ibp); + if(error = VOP_BWRITE(ibp)) + return(error); + } } - if (error) { - if (bp) - brelse(bp); - return(error); - } + /* + * If the block we are writing is a direct block, it's the last + * block in the file, and offset + iosize is less than a full + * block, we can write one or more fragments. There are two cases: + * the block is brand new and we should allocate it the correct + * size or it already exists and contains some fragments and + * may need to extend it. + */ + if (lbn < NDADDR && lblkno(fs, ip->i_size) == lbn) { + nsize = fragroundup(fs, offset + iosize); + frags = numfrags(fs, nsize); + bb = fragstodb(fs, frags); + if (lblktosize(fs, lbn) == ip->i_size) + /* Brand new block or fragment */ + *bpp = bp = getblk(vp, lbn, nsize, 0, 0); + else { + /* Extend existing block */ + if (error = lfs_fragextend(vp, (int)blksize(fs, ip, lbn), + nsize, lbn, &bp)) + return(error); + *bpp = bp; + } + } else { + /* + * Get the existing block from the cache either because the + * block is 1) not a direct block or because it's not the last + * block in the file. + */ + frags = dbtofrags(fs, bb); + *bpp = bp = getblk(vp, lbn, blksize(fs, ip, lbn), 0, 0); + } - /* Now, we may need to allocate the data block */ + /* + * The block we are writing may be a brand new block + * in which case we need to do accounting (i.e. check + * for free space and update the inode number of blocks. + */ if (!(bp->b_flags & (B_CACHE | B_DONE | B_DELWRI))) { if (daddr == UNASSIGNED) if (!ISSPACE(fs, bb, curproc->p_ucred)) { @@ -124,13 +173,55 @@ lfs_balloc(vp, iosize, lbn, bpp) clrbuf(bp); } else if (iosize == fs->lfs_bsize) - bp->b_blkno = daddr; /* Skip the I/O */ + /* Optimization: I/O is unnecessary. */ + bp->b_blkno = daddr; else { + /* + * We need to read the block to preserve the + * existing bytes. + */ bp->b_blkno = daddr; bp->b_flags |= B_READ; VOP_STRATEGY(bp); return(biowait(bp)); } } - return (error); + return (0); +} + +lfs_fragextend(vp, osize, nsize, lbn, bpp) + struct vnode *vp; + int osize; + int nsize; + daddr_t lbn; + struct buf **bpp; +{ + struct inode *ip; + struct lfs *fs; + long bb; + int error; + + ip = VTOI(vp); + fs = ip->i_lfs; + bb = (long)fragstodb(fs, numfrags(fs, nsize - osize)); + if (!ISSPACE(fs, bb, curproc->p_ucred)) { + return(ENOSPC); + } + + if (error = bread(vp, lbn, osize, NOCRED, bpp)) { + brelse(*bpp); + return(error); + } +#ifdef QUOTA + if (error = chkdq(ip, bb, curproc->p_ucred, 0)) { + brelse(*bpp); + return (error); + } +#endif + ip->i_blocks += bb; + ip->i_flag |= IN_CHANGE | IN_UPDATE; + fs->lfs_bfree -= fragstodb(fs, numfrags(fs, (nsize - osize))); + allocbuf(*bpp, nsize); + bzero((char *)((*bpp)->b_data) + osize, (u_int)(nsize - osize)); + return(0); } diff --git a/sys/ufs/lfs/lfs_bio.c b/sys/ufs/lfs/lfs_bio.c index 0f021f1..837e8aa 100644 --- a/sys/ufs/lfs/lfs_bio.c +++ b/sys/ufs/lfs/lfs_bio.c @@ -30,7 +30,7 @@ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. * - * @(#)lfs_bio.c 8.4 (Berkeley) 12/30/93 + * @(#)lfs_bio.c 8.10 (Berkeley) 6/10/95 */ #include <sys/param.h> @@ -76,7 +76,7 @@ lfs_bwrite(ap) register struct buf *bp = ap->a_bp; struct lfs *fs; struct inode *ip; - int error, s; + int db, error, s; /* * Set the delayed write flag and use reassignbuf to move the buffer @@ -94,10 +94,12 @@ lfs_bwrite(ap) */ if (!(bp->b_flags & B_LOCKED)) { fs = VFSTOUFS(bp->b_vp->v_mount)->um_lfs; - while (!LFS_FITS(fs, fsbtodb(fs, 1)) && !IS_IFILE(bp) && + db = fragstodb(fs, numfrags(fs, bp->b_bcount)); + while (!LFS_FITS(fs, db) && !IS_IFILE(bp) && bp->b_lblkno > 0) { /* Out of space, need cleaner to run */ wakeup(&lfs_allclean_wakeup); + wakeup(&fs->lfs_nextseg); if (error = tsleep(&fs->lfs_avail, PCATCH | PUSER, "cleaner", NULL)) { brelse(bp); @@ -108,7 +110,7 @@ lfs_bwrite(ap) if (!(ip->i_flag & IN_MODIFIED)) ++fs->lfs_uinodes; ip->i_flag |= IN_CHANGE | IN_MODIFIED | IN_UPDATE; - fs->lfs_avail -= fsbtodb(fs, 1); + fs->lfs_avail -= db; ++locked_queue_count; bp->b_flags |= B_DELWRI | B_LOCKED; bp->b_flags &= ~(B_READ | B_ERROR); @@ -131,7 +133,8 @@ lfs_bwrite(ap) void lfs_flush() { - register struct mount *mp; + register struct mount *mp, *nmp; + struct proc *p = curproc; /* XXX */ #ifdef DOSTATS ++lfs_stats.write_exceeded; @@ -139,10 +142,14 @@ lfs_flush() if (lfs_writing) return; lfs_writing = 1; - for (mp = mountlist.tqh_first; mp != NULL; mp = mp->mnt_list.tqe_next) { - /* The lock check below is to avoid races with unmount. */ - if (mp->mnt_stat.f_type == MOUNT_LFS && - (mp->mnt_flag & (MNT_MLOCK|MNT_RDONLY|MNT_UNMOUNT)) == 0 && + simple_lock(&mountlist_slock); + for (mp = mountlist.cqh_first; mp != (void *)&mountlist; mp = nmp) { + if (vfs_busy(mp, LK_NOWAIT, &mountlist_slock, p)) { + nmp = mp->mnt_list.cqe_next; + continue; + } + if (mp->mnt_stat.f_type == lfs_mount_type && + (mp->mnt_flag & MNT_RDONLY) == 0 && !((((struct ufsmount *)mp->mnt_data))->ufsmount_u.lfs)->lfs_dirops ) { /* * We set the queue to 0 here because we are about to @@ -156,14 +163,18 @@ lfs_flush() #endif lfs_segwrite(mp, 0); } + simple_lock(&mountlist_slock); + nmp = mp->mnt_list.cqe_next; + vfs_unbusy(mp, p); } + simple_unlock(&mountlist_slock); lfs_writing = 0; } int lfs_check(vp, blkno) struct vnode *vp; - daddr_t blkno; + ufs_daddr_t blkno; { extern int lfs_allclean_wakeup; int error; diff --git a/sys/ufs/lfs/lfs_cksum.c b/sys/ufs/lfs/lfs_cksum.c index 77b011a..cd513fd 100644 --- a/sys/ufs/lfs/lfs_cksum.c +++ b/sys/ufs/lfs/lfs_cksum.c @@ -30,7 +30,7 @@ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. * - * @(#)lfs_cksum.c 8.1 (Berkeley) 6/11/93 + * @(#)lfs_cksum.c 8.2 (Berkeley) 10/9/94 */ #include <sys/types.h> @@ -52,7 +52,7 @@ cksum(str, len) len &= ~(sizeof(u_short) - 1); for (sum = 0; len; len -= sizeof(u_short)) { sum ^= *(u_short *)str; - ++(u_short *)str; + str = (void *)((u_short *)str + 1); } return (sum); } diff --git a/sys/ufs/lfs/lfs_extern.h b/sys/ufs/lfs/lfs_extern.h index c1157ad..1841146 100644 --- a/sys/ufs/lfs/lfs_extern.h +++ b/sys/ufs/lfs/lfs_extern.h @@ -30,7 +30,7 @@ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. * - * @(#)lfs_extern.h 8.2 (Berkeley) 4/16/94 + * @(#)lfs_extern.h 8.6 (Berkeley) 5/8/95 */ struct fid; @@ -45,10 +45,10 @@ struct mbuf; __BEGIN_DECLS u_long cksum __P((void *, size_t)); /* XXX */ -int lfs_balloc __P((struct vnode *, u_long, daddr_t, struct buf **)); +int lfs_balloc __P((struct vnode *, int, u_long, ufs_daddr_t, struct buf **)); int lfs_blkatoff __P((struct vop_blkatoff_args *)); int lfs_bwrite __P((struct vop_bwrite_args *)); -int lfs_check __P((struct vnode *, daddr_t)); +int lfs_check __P((struct vnode *, ufs_daddr_t)); int lfs_close __P((struct vop_close_args *)); int lfs_create __P((struct vop_create_args *)); int lfs_fhtovp __P((struct mount *, struct fid *, struct mbuf *, @@ -58,7 +58,7 @@ int lfs_getattr __P((struct vop_getattr_args *)); struct dinode * lfs_ifind __P((struct lfs *, ino_t, struct dinode *)); int lfs_inactive __P((struct vop_inactive_args *)); -int lfs_init __P((void)); +int lfs_init __P((struct vfsconf *)); int lfs_initseg __P((struct lfs *)); int lfs_link __P((struct vop_link_args *)); int lfs_makeinode __P((int, struct nameidata *, struct inode **)); @@ -68,8 +68,9 @@ int lfs_mount __P((struct mount *, char *, caddr_t, struct nameidata *, struct proc *)); int lfs_mountroot __P((void)); struct buf * - lfs_newbuf __P((struct vnode *, daddr_t, size_t)); + lfs_newbuf __P((struct vnode *, ufs_daddr_t, size_t)); int lfs_read __P((struct vop_read_args *)); +int lfs_reclaim __P((struct vop_reclaim_args *)); int lfs_remove __P((struct vop_remove_args *)); int lfs_rmdir __P((struct vop_rmdir_args *)); int lfs_rename __P((struct vop_rename_args *)); @@ -79,6 +80,8 @@ int lfs_segwrite __P((struct mount *, int)); int lfs_statfs __P((struct mount *, struct statfs *, struct proc *)); int lfs_symlink __P((struct vop_symlink_args *)); int lfs_sync __P((struct mount *, int, struct ucred *, struct proc *)); +#define lfs_sysctl ((int (*) __P((int *, u_int, void *, size_t *, void *, \ + size_t, struct proc *)))eopnotsupp) int lfs_truncate __P((struct vop_truncate_args *)); int lfs_unmount __P((struct mount *, int, struct proc *)); int lfs_update __P((struct vop_update_args *)); @@ -96,6 +99,7 @@ void lfs_dump_dinode __P((struct dinode *)); void lfs_dump_super __P((struct lfs *)); #endif __END_DECLS +extern int lfs_mount_type; extern int (**lfs_vnodeop_p)(); extern int (**lfs_specop_p)(); #ifdef FIFO diff --git a/sys/ufs/lfs/lfs_inode.c b/sys/ufs/lfs/lfs_inode.c index 1a06aa2..be7d37f 100644 --- a/sys/ufs/lfs/lfs_inode.c +++ b/sys/ufs/lfs/lfs_inode.c @@ -30,7 +30,7 @@ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. * - * @(#)lfs_inode.c 8.5 (Berkeley) 12/30/93 + * @(#)lfs_inode.c 8.9 (Berkeley) 5/8/95 */ #include <sys/param.h> @@ -53,12 +53,6 @@ #include <ufs/lfs/lfs.h> #include <ufs/lfs/lfs_extern.h> -int -lfs_init() -{ - return (ufs_init()); -} - /* Search a block for a specific dinode. */ struct dinode * lfs_ifind(fs, ino, dip) @@ -96,13 +90,13 @@ lfs_update(ap) (IN_ACCESS | IN_CHANGE | IN_MODIFIED | IN_UPDATE)) == 0) return (0); if (ip->i_flag & IN_ACCESS) - ip->i_atime.ts_sec = ap->a_access->tv_sec; + ip->i_atime = ap->a_access->tv_sec; if (ip->i_flag & IN_UPDATE) { - ip->i_mtime.ts_sec = ap->a_modify->tv_sec; + ip->i_mtime = ap->a_modify->tv_sec; (ip)->i_modrev++; } if (ip->i_flag & IN_CHANGE) - ip->i_ctime.ts_sec = time.tv_sec; + ip->i_ctime = time.tv_sec; ip->i_flag &= ~(IN_ACCESS | IN_CHANGE | IN_UPDATE); if (!(ip->i_flag & IN_MODIFIED)) @@ -117,22 +111,22 @@ lfs_update(ap) #define UPDATE_SEGUSE \ if (lastseg != -1) { \ LFS_SEGENTRY(sup, fs, lastseg, sup_bp); \ - if ((num << fs->lfs_bshift) > sup->su_nbytes) \ + if (num > sup->su_nbytes) \ panic("lfs_truncate: negative bytes in segment %d\n", \ lastseg); \ - sup->su_nbytes -= num << fs->lfs_bshift; \ + sup->su_nbytes -= num; \ e1 = VOP_BWRITE(sup_bp); \ - blocksreleased += num; \ + fragsreleased += numfrags(fs, num); \ } -#define SEGDEC { \ +#define SEGDEC(S) { \ if (daddr != 0) { \ if (lastseg != (seg = datosn(fs, daddr))) { \ UPDATE_SEGUSE; \ - num = 1; \ + num = (S); \ lastseg = seg; \ } else \ - ++num; \ + num += (S); \ } \ } @@ -153,7 +147,7 @@ lfs_truncate(ap) { register struct indir *inp; register int i; - register daddr_t *daddrp; + register ufs_daddr_t *daddrp; register struct vnode *vp = ap->a_vp; off_t length = ap->a_length; struct buf *bp, *sup_bp; @@ -163,9 +157,10 @@ lfs_truncate(ap) struct lfs *fs; struct indir a[NIADDR + 2], a_end[NIADDR + 2]; SEGUSE *sup; - daddr_t daddr, lastblock, lbn, olastblock; - long off, a_released, blocksreleased, i_released; - int e1, e2, depth, lastseg, num, offset, seg, size; + ufs_daddr_t daddr, lastblock, lbn, olastblock; + ufs_daddr_t oldsize_lastblock, oldsize_newlast, newsize; + long off, a_released, fragsreleased, i_released; + int e1, e2, depth, lastseg, num, offset, seg, freesize; ip = VTOI(vp); tv = time; @@ -201,24 +196,29 @@ lfs_truncate(ap) * Update the size of the file. If the file is not being truncated to * a block boundry, the contents of the partial block following the end * of the file must be zero'ed in case it ever become accessable again - * because of subsequent file growth. + * because of subsequent file growth. For this part of the code, + * oldsize_newlast refers to the old size of the new last block in the file. */ offset = blkoff(fs, length); + lbn = lblkno(fs, length); + oldsize_newlast = blksize(fs, ip, lbn); + + /* Now set oldsize to the current size of the current last block */ + oldsize_lastblock = blksize(fs, ip, olastblock); if (offset == 0) ip->i_size = length; else { - lbn = lblkno(fs, length); #ifdef QUOTA if (e1 = getinoquota(ip)) return (e1); #endif - if (e1 = bread(vp, lbn, fs->lfs_bsize, NOCRED, &bp)) + if (e1 = bread(vp, lbn, oldsize_newlast, NOCRED, &bp)) return (e1); ip->i_size = length; - size = blksize(fs); (void)vnode_pager_uncache(vp); - bzero((char *)bp->b_data + offset, (u_int)(size - offset)); - allocbuf(bp, size); + newsize = blksize(fs, ip, lbn); + bzero((char *)bp->b_data + offset, (u_int)(newsize - offset)); + allocbuf(bp, newsize); if (e1 = VOP_BWRITE(bp)) return (e1); } @@ -226,20 +226,24 @@ lfs_truncate(ap) * Modify sup->su_nbyte counters for each deleted block; keep track * of number of blocks removed for ip->i_blocks. */ - blocksreleased = 0; + fragsreleased = 0; num = 0; lastseg = -1; for (lbn = olastblock; lbn >= lastblock;) { /* XXX use run length from bmap array to make this faster */ ufs_bmaparray(vp, lbn, &daddr, a, &depth, NULL); - if (lbn == olastblock) + if (lbn == olastblock) { for (i = NIADDR + 2; i--;) a_end[i] = a[i]; + freesize = oldsize_lastblock; + } else + freesize = fs->lfs_bsize; + switch (depth) { case 0: /* Direct block. */ daddr = ip->i_db[lbn]; - SEGDEC; + SEGDEC(freesize); ip->i_db[lbn] = 0; --lbn; break; @@ -261,19 +265,20 @@ lfs_truncate(ap) inp->in_lbn, fs->lfs_bsize, NOCRED, &bp)) panic("lfs_truncate: bread bno %d", inp->in_lbn); - daddrp = (daddr_t *)bp->b_data + inp->in_off; + daddrp = (ufs_daddr_t *)bp->b_data + + inp->in_off; for (i = inp->in_off; i++ <= a_end[depth].in_off;) { daddr = *daddrp++; - SEGDEC; + SEGDEC(freesize); } a_end[depth].in_off = NINDIR(fs) - 1; if (inp->in_off == 0) brelse (bp); else { - bzero((daddr_t *)bp->b_data + + bzero((ufs_daddr_t *)bp->b_data + inp->in_off, fs->lfs_bsize - - inp->in_off * sizeof(daddr_t)); + inp->in_off * sizeof(ufs_daddr_t)); if (e1 = VOP_BWRITE(bp)) return (e1); } @@ -281,7 +286,7 @@ lfs_truncate(ap) if (depth == 0 && a[1].in_off == 0) { off = a[0].in_off; daddr = ip->i_ib[off]; - SEGDEC; + SEGDEC(freesize); ip->i_ib[off] = 0; } if (lbn == lastblock || lbn <= NDADDR) @@ -303,13 +308,14 @@ lfs_truncate(ap) } #ifdef DIAGNOSTIC - if (ip->i_blocks < fsbtodb(fs, blocksreleased)) { - printf("lfs_truncate: block count < 0\n"); - blocksreleased = ip->i_blocks; + if (ip->i_blocks < fragstodb(fs, fragsreleased)) { + printf("lfs_truncate: frag count < 0\n"); + fragsreleased = dbtofrags(fs, ip->i_blocks); + panic("lfs_truncate: frag count < 0\n"); } #endif - ip->i_blocks -= fsbtodb(fs, blocksreleased); - fs->lfs_bfree += fsbtodb(fs, blocksreleased); + ip->i_blocks -= fragstodb(fs, fragsreleased); + fs->lfs_bfree += fragstodb(fs, fragsreleased); ip->i_flag |= IN_CHANGE | IN_UPDATE; /* * Traverse dirty block list counting number of dirty buffers @@ -320,7 +326,7 @@ lfs_truncate(ap) i_released = 0; for (bp = vp->v_dirtyblkhd.lh_first; bp; bp = bp->b_vnbufs.le_next) if (bp->b_flags & B_LOCKED) { - ++a_released; + a_released += numfrags(fs, bp->b_bcount); /* * XXX * When buffers are created in the cache, their block @@ -333,25 +339,28 @@ lfs_truncate(ap) * here. */ if (bp->b_blkno == bp->b_lblkno) - ++i_released; + i_released += numfrags(fs, bp->b_bcount); } - blocksreleased = fsbtodb(fs, i_released); + fragsreleased = i_released; #ifdef DIAGNOSTIC - if (blocksreleased > ip->i_blocks) { + if (fragsreleased > dbtofrags(fs, ip->i_blocks)) { printf("lfs_inode: Warning! %s\n", - "more blocks released from inode than are in inode"); - blocksreleased = ip->i_blocks; + "more frags released from inode than are in inode"); + fragsreleased = dbtofrags(fs, ip->i_blocks); + panic("lfs_inode: Warning. More frags released\n"); } #endif - fs->lfs_bfree += blocksreleased; - ip->i_blocks -= blocksreleased; + fs->lfs_bfree += fragstodb(fs, fragsreleased); + ip->i_blocks -= fragstodb(fs, fragsreleased); #ifdef DIAGNOSTIC - if (length == 0 && ip->i_blocks != 0) + if (length == 0 && ip->i_blocks != 0) { printf("lfs_inode: Warning! %s%d%s\n", "Truncation to zero, but ", ip->i_blocks, " blocks left on inode"); + panic("lfs_inode"); + } #endif - fs->lfs_avail += fsbtodb(fs, a_released); + fs->lfs_avail += fragstodb(fs, a_released); e1 = vinvalbuf(vp, (length > 0) ? V_SAVE : 0, ap->a_cred, ap->a_p, 0, 0); e2 = VOP_UPDATE(vp, &tv, &tv, 0); diff --git a/sys/ufs/lfs/lfs_segment.c b/sys/ufs/lfs/lfs_segment.c index 249d59d..5e43695 100644 --- a/sys/ufs/lfs/lfs_segment.c +++ b/sys/ufs/lfs/lfs_segment.c @@ -30,7 +30,7 @@ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. * - * @(#)lfs_segment.c 8.5 (Berkeley) 1/4/94 + * @(#)lfs_segment.c 8.10 (Berkeley) 6/10/95 */ #include <sys/param.h> @@ -74,13 +74,13 @@ void lfs_callback __P((struct buf *)); void lfs_gather __P((struct lfs *, struct segment *, struct vnode *, int (*) __P((struct lfs *, struct buf *)))); int lfs_gatherblock __P((struct segment *, struct buf *, int *)); -void lfs_iset __P((struct inode *, daddr_t, time_t)); +void lfs_iset __P((struct inode *, ufs_daddr_t, time_t)); int lfs_match_data __P((struct lfs *, struct buf *)); int lfs_match_dindir __P((struct lfs *, struct buf *)); int lfs_match_indir __P((struct lfs *, struct buf *)); int lfs_match_tindir __P((struct lfs *, struct buf *)); void lfs_newseg __P((struct lfs *)); -void lfs_shellsort __P((struct buf **, daddr_t *, register int)); +void lfs_shellsort __P((struct buf **, ufs_daddr_t *, register int)); void lfs_supercallback __P((struct buf *)); void lfs_updatemeta __P((struct segment *)); int lfs_vref __P((struct vnode *)); @@ -158,10 +158,23 @@ lfs_writevnodes(fs, mp, sp, op) struct inode *ip; struct vnode *vp; +/* BEGIN HACK */ +#define VN_OFFSET (((void *)&vp->v_mntvnodes.le_next) - (void *)vp) +#define BACK_VP(VP) ((struct vnode *)(((void *)VP->v_mntvnodes.le_prev) - VN_OFFSET)) +#define BEG_OF_VLIST ((struct vnode *)(((void *)&mp->mnt_vnodelist.lh_first) - VN_OFFSET)) + +/* Find last vnode. */ +loop: for (vp = mp->mnt_vnodelist.lh_first; + vp && vp->v_mntvnodes.le_next != NULL; + vp = vp->v_mntvnodes.le_next); + for (; vp && vp != BEG_OF_VLIST; vp = BACK_VP(vp)) { +/* END HACK */ +/* loop: for (vp = mp->mnt_vnodelist.lh_first; vp != NULL; vp = vp->v_mntvnodes.le_next) { +*/ /* * If the vnode that we are about to sync is no longer * associated with this mount point, start over. @@ -207,13 +220,14 @@ lfs_segwrite(mp, flags) struct mount *mp; int flags; /* Do a checkpoint. */ { + struct proc *p = curproc; /* XXX */ struct buf *bp; struct inode *ip; struct lfs *fs; struct segment *sp; struct vnode *vp; SEGUSE *segusep; - daddr_t ibno; + ufs_daddr_t ibno; CLEANERINFO *cip; int clean, do_ckp, error, i; @@ -227,14 +241,15 @@ lfs_segwrite(mp, flags) LFS_CLEANERINFO(cip, fs, bp); clean = cip->clean; brelse(bp); - if (clean <= 2) { - printf ("segs clean: %d\n", clean); + if (clean <= 2 || fs->lfs_avail <= 0) { + /* printf ("segs clean: %d\n", clean); */ wakeup(&lfs_allclean_wakeup); + wakeup(&fs->lfs_nextseg); if (error = tsleep(&fs->lfs_avail, PRIBIO + 1, "lfs writer", 0)) return (error); } - } while (clean <= 2 ); + } while (clean <= 2 || fs->lfs_avail <= 0); /* * Allocate a segment structure and enough space to hold pointers to @@ -282,7 +297,8 @@ lfs_segwrite(mp, flags) if (do_ckp || fs->lfs_doifile) { redo: vp = fs->lfs_ivnode; - while (vget(vp, 1)); + while (vget(vp, LK_EXCLUSIVE, p)) + continue; ip = VTOI(vp); if (vp->v_dirtyblkhd.lh_first != NULL) lfs_writefile(fs, sp, vp); @@ -331,7 +347,7 @@ lfs_writefile(fs, sp, vp) sp->sum_bytes_left < sizeof(struct finfo)) (void) lfs_writeseg(fs, sp); - sp->sum_bytes_left -= sizeof(struct finfo) - sizeof(daddr_t); + sp->sum_bytes_left -= sizeof(struct finfo) - sizeof(ufs_daddr_t); ++((SEGSUM *)(sp->segsum))->ss_nfinfo; fip = sp->fip; @@ -357,10 +373,10 @@ lfs_writefile(fs, sp, vp) if (fip->fi_nblocks != 0) { sp->fip = (struct finfo *)((caddr_t)fip + sizeof(struct finfo) + - sizeof(daddr_t) * (fip->fi_nblocks - 1)); + sizeof(ufs_daddr_t) * (fip->fi_nblocks - 1)); sp->start_lbp = &sp->fip->fi_blocks[0]; } else { - sp->sum_bytes_left += sizeof(struct finfo) - sizeof(daddr_t); + sp->sum_bytes_left += sizeof(struct finfo) - sizeof(ufs_daddr_t); --((SEGSUM *)(sp->segsum))->ss_nfinfo; } } @@ -374,7 +390,7 @@ lfs_writeinode(fs, sp, ip) struct buf *bp, *ibp; IFILE *ifp; SEGUSE *sup; - daddr_t daddr; + ufs_daddr_t daddr; ino_t ino; int error, i, ndx; int redo_ifile = 0; @@ -386,7 +402,7 @@ lfs_writeinode(fs, sp, ip) if (sp->ibp == NULL) { /* Allocate a new segment if necessary. */ if (sp->seg_bytes_left < fs->lfs_bsize || - sp->sum_bytes_left < sizeof(daddr_t)) + sp->sum_bytes_left < sizeof(ufs_daddr_t)) (void) lfs_writeseg(fs, sp); /* Get next inode block. */ @@ -402,10 +418,10 @@ lfs_writeinode(fs, sp, ip) fs->lfs_avail -= fsbtodb(fs, 1); /* Set remaining space counters. */ sp->seg_bytes_left -= fs->lfs_bsize; - sp->sum_bytes_left -= sizeof(daddr_t); - ndx = LFS_SUMMARY_SIZE / sizeof(daddr_t) - + sp->sum_bytes_left -= sizeof(ufs_daddr_t); + ndx = LFS_SUMMARY_SIZE / sizeof(ufs_daddr_t) - sp->ninodes / INOPB(fs) - 1; - ((daddr_t *)(sp->segsum))[ndx] = daddr; + ((ufs_daddr_t *)(sp->segsum))[ndx] = daddr; } /* Update the inode times and copy the inode onto the inode page. */ @@ -478,8 +494,8 @@ lfs_gatherblock(sp, bp, sptr) panic ("lfs_gatherblock: Null vp in segment"); #endif fs = sp->fs; - if (sp->sum_bytes_left < sizeof(daddr_t) || - sp->seg_bytes_left < fs->lfs_bsize) { + if (sp->sum_bytes_left < sizeof(ufs_daddr_t) || + sp->seg_bytes_left < bp->b_bcount) { if (sptr) splx(*sptr); lfs_updatemeta(sp); @@ -492,7 +508,7 @@ lfs_gatherblock(sp, bp, sptr) /* Add the current file to the segment summary. */ ++((SEGSUM *)(sp->segsum))->ss_nfinfo; sp->sum_bytes_left -= - sizeof(struct finfo) - sizeof(daddr_t); + sizeof(struct finfo) - sizeof(ufs_daddr_t); if (sptr) *sptr = splbio(); @@ -504,8 +520,8 @@ lfs_gatherblock(sp, bp, sptr) *sp->cbpp++ = bp; sp->fip->fi_blocks[sp->fip->fi_nblocks++] = bp->b_lblkno; - sp->sum_bytes_left -= sizeof(daddr_t); - sp->seg_bytes_left -= fs->lfs_bsize; + sp->sum_bytes_left -= sizeof(ufs_daddr_t); + sp->seg_bytes_left -= bp->b_bcount; return(0); } @@ -521,7 +537,19 @@ lfs_gather(fs, sp, vp, match) sp->vp = vp; s = splbio(); -loop: for (bp = vp->v_dirtyblkhd.lh_first; bp; bp = bp->b_vnbufs.le_next) { +/* This is a hack to see if ordering the blocks in LFS makes a difference. */ +/* BEGIN HACK */ +#define BUF_OFFSET (((void *)&bp->b_vnbufs.le_next) - (void *)bp) +#define BACK_BUF(BP) ((struct buf *)(((void *)BP->b_vnbufs.le_prev) - BUF_OFFSET)) +#define BEG_OF_LIST ((struct buf *)(((void *)&vp->v_dirtyblkhd.lh_first) - BUF_OFFSET)) + + +/*loop: for (bp = vp->v_dirtyblkhd.lh_first; bp; bp = bp->b_vnbufs.le_next) {*/ +/* Find last buffer. */ +loop: for (bp = vp->v_dirtyblkhd.lh_first; bp && bp->b_vnbufs.le_next != NULL; + bp = bp->b_vnbufs.le_next); + for (; bp && bp != BEG_OF_LIST; bp = BACK_BUF(bp)) { +/* END HACK */ if (bp->b_flags & B_BUSY || !match(fs, bp) || bp->b_flags & B_GATHERED) continue; @@ -554,11 +582,13 @@ lfs_updatemeta(sp) struct vnode *vp; struct indir a[NIADDR + 2], *ap; struct inode *ip; - daddr_t daddr, lbn, off; - int db_per_fsb, error, i, nblocks, num; + ufs_daddr_t daddr, lbn, off; + int error, i, nblocks, num; vp = sp->vp; nblocks = &sp->fip->fi_blocks[sp->fip->fi_nblocks] - sp->start_lbp; + if (nblocks < 0) + panic("This is a bad thing\n"); if (vp == NULL || nblocks == 0) return; @@ -567,15 +597,23 @@ lfs_updatemeta(sp) lfs_shellsort(sp->start_bpp, sp->start_lbp, nblocks); /* + * Record the length of the last block in case it's a fragment. + * If there are indirect blocks present, they sort last. An + * indirect block will be lfs_bsize and its presence indicates + * that you cannot have fragments. + */ + sp->fip->fi_lastlength = sp->start_bpp[nblocks - 1]->b_bcount; + + /* * Assign disk addresses, and update references to the logical * block and the segment usage information. */ fs = sp->fs; - db_per_fsb = fsbtodb(fs, 1); for (i = nblocks; i--; ++sp->start_bpp) { lbn = *sp->start_lbp++; (*sp->start_bpp)->b_blkno = off = fs->lfs_offset; - fs->lfs_offset += db_per_fsb; + fs->lfs_offset += + fragstodb(fs, numfrags(fs, (*sp->start_bpp)->b_bcount)); if (error = ufs_bmaparray(vp, lbn, &daddr, a, &num, NULL)) panic("lfs_updatemeta: ufs_bmaparray %d", error); @@ -597,11 +635,10 @@ lfs_updatemeta(sp) * to get counted for the inode. */ if (bp->b_blkno == -1 && !(bp->b_flags & B_CACHE)) { -printf ("Updatemeta allocating indirect block: shouldn't happen\n"); - ip->i_blocks += btodb(fs->lfs_bsize); - fs->lfs_bfree -= btodb(fs->lfs_bsize); + ip->i_blocks += fsbtodb(fs, 1); + fs->lfs_bfree -= fragstodb(fs, fs->lfs_frag); } - ((daddr_t *)bp->b_data)[ap->in_off] = off; + ((ufs_daddr_t *)bp->b_data)[ap->in_off] = off; VOP_BWRITE(bp); } @@ -610,14 +647,16 @@ printf ("Updatemeta allocating indirect block: shouldn't happen\n"); !(daddr >= fs->lfs_lastpseg && daddr <= off)) { LFS_SEGENTRY(sup, fs, datosn(fs, daddr), bp); #ifdef DIAGNOSTIC - if (sup->su_nbytes < fs->lfs_bsize) { + if (sup->su_nbytes < (*sp->start_bpp)->b_bcount) { /* XXX -- Change to a panic. */ printf("lfs: negative bytes (segment %d)\n", datosn(fs, daddr)); + printf("lfs: bp = 0x%x, addr = 0x%x\n", + bp, bp->b_un.b_addr); panic ("Negative Bytes"); } #endif - sup->su_nbytes -= fs->lfs_bsize; + sup->su_nbytes -= (*sp->start_bpp)->b_bcount; error = VOP_BWRITE(bp); } } @@ -643,6 +682,7 @@ lfs_initseg(fs) if (!LFS_PARTIAL_FITS(fs)) { /* Wake up any cleaning procs waiting on this file system. */ wakeup(&lfs_allclean_wakeup); + wakeup(&fs->lfs_nextseg); lfs_newseg(fs); repeat = 1; @@ -684,11 +724,13 @@ lfs_initseg(fs) ssp = sp->segsum; ssp->ss_next = fs->lfs_nextseg; ssp->ss_nfinfo = ssp->ss_ninos = 0; + ssp->ss_magic = SS_MAGIC; /* Set pointer to first FINFO, initialize it. */ - sp->fip = (struct finfo *)(sp->segsum + sizeof(SEGSUM)); + sp->fip = (struct finfo *)((caddr_t)sp->segsum + sizeof(SEGSUM)); sp->fip->fi_nblocks = 0; sp->start_lbp = &sp->fip->fi_blocks[0]; + sp->fip->fi_lastlength = 0; sp->seg_bytes_left -= LFS_SUMMARY_SIZE; sp->sum_bytes_left = LFS_SUMMARY_SIZE - sizeof(SEGSUM); @@ -750,9 +792,8 @@ lfs_writeseg(fs, sp) SEGUSE *sup; SEGSUM *ssp; dev_t i_dev; - size_t size; u_long *datap, *dp; - int ch_per_blk, do_again, i, nblocks, num, s; + int do_again, i, nblocks, s; int (*strategy)__P((struct vop_strategy_args *)); struct vop_strategy_args vop_strategy_a; u_short ninos; @@ -766,12 +807,16 @@ lfs_writeseg(fs, sp) if ((nblocks = sp->cbpp - sp->bpp) == 1) return (0); - ssp = (SEGSUM *)sp->segsum; - /* Update the segment usage information. */ LFS_SEGENTRY(sup, fs, sp->seg_number, bp); + + /* Loop through all blocks, except the segment summary. */ + for (bpp = sp->bpp; ++bpp < sp->cbpp; ) + sup->su_nbytes += (*bpp)->b_bcount; + + ssp = (SEGSUM *)sp->segsum; + ninos = (ssp->ss_ninos + INOPB(fs) - 1) / INOPB(fs); - sup->su_nbytes += nblocks - 1 - ninos << fs->lfs_bshift; sup->su_nbytes += ssp->ss_ninos * sizeof(struct dinode); sup->su_nbytes += LFS_SUMMARY_SIZE; sup->su_lastmod = time.tv_sec; @@ -824,23 +869,21 @@ lfs_writeseg(fs, sp) * easily make the buffers contiguous in kernel memory and if that's * fast enough. */ - ch_per_blk = MAXPHYS / fs->lfs_bsize; for (bpp = sp->bpp, i = nblocks; i;) { - num = ch_per_blk; - if (num > i) - num = i; - i -= num; - size = num * fs->lfs_bsize; - cbp = lfs_newbuf(VTOI(fs->lfs_ivnode)->i_devvp, - (*bpp)->b_blkno, size); + (*bpp)->b_blkno, MAXPHYS); cbp->b_dev = i_dev; cbp->b_flags |= B_ASYNC | B_BUSY; + cbp->b_bcount = 0; s = splbio(); ++fs->lfs_iocount; - for (p = cbp->b_data; num--;) { - bp = *bpp++; + for (p = cbp->b_data; i && cbp->b_bcount < MAXPHYS; i--) { + bp = *bpp; + if (bp->b_bcount > (MAXPHYS - cbp->b_bcount)) + break; + bpp++; + /* * Fake buffers from the cleaner are marked as B_INVAL. * We need to copy the data from user space rather than @@ -853,6 +896,7 @@ lfs_writeseg(fs, sp) } else bcopy(bp->b_data, p, bp->b_bcount); p += bp->b_bcount; + cbp->b_bcount += bp->b_bcount; if (bp->b_flags & B_LOCKED) --locked_queue_count; bp->b_flags &= ~(B_ERROR | B_READ | B_DELWRI | @@ -872,7 +916,6 @@ lfs_writeseg(fs, sp) } ++cbp->b_vp->v_numoutput; splx(s); - cbp->b_bcount = p - (char *)cbp->b_data; /* * XXXX This is a gross and disgusting hack. Since these * buffers are physically addressed, they hang off the @@ -992,7 +1035,7 @@ lfs_match_tindir(fs, bp) struct buf * lfs_newbuf(vp, daddr, size) struct vnode *vp; - daddr_t daddr; + ufs_daddr_t daddr; size_t size; { struct buf *bp; @@ -1059,7 +1102,7 @@ lfs_supercallback(bp) void lfs_shellsort(bp_array, lb_array, nmemb) struct buf **bp_array; - daddr_t *lb_array; + ufs_daddr_t *lb_array; register int nmemb; { static int __rsshell_increments[] = { 4, 1, 0 }; @@ -1088,24 +1131,36 @@ lfs_shellsort(bp_array, lb_array, nmemb) lfs_vref(vp) register struct vnode *vp; { + struct proc *p = curproc; /* XXX */ - if (vp->v_flag & VXLOCK) + if (vp->v_flag & VXLOCK) /* XXX */ return(1); - return (vget(vp, 0)); + return (vget(vp, 0, p)); } +/* + * This is vrele except that we do not want to VOP_INACTIVE this vnode. We + * inline vrele here to avoid the vn_lock and VOP_INACTIVE call at the end. + */ void lfs_vunref(vp) register struct vnode *vp; { - extern int lfs_no_inactive; - + struct proc *p = curproc; /* XXX */ + extern struct simplelock vnode_free_list_slock; /* XXX */ + extern TAILQ_HEAD(freelst, vnode) vnode_free_list; /* XXX */ + + simple_lock(&vp->v_interlock); + vp->v_usecount--; + if (vp->v_usecount > 0) { + simple_unlock(&vp->v_interlock); + return; + } /* - * This is vrele except that we do not want to VOP_INACTIVE - * this vnode. Rather than inline vrele here, we use a global - * flag to tell lfs_inactive not to run. Yes, its gross. + * insert at tail of LRU list */ - lfs_no_inactive = 1; - vrele(vp); - lfs_no_inactive = 0; + simple_lock(&vnode_free_list_slock); + TAILQ_INSERT_TAIL(&vnode_free_list, vp, v_freelist); + simple_unlock(&vnode_free_list_slock); + simple_unlock(&vp->v_interlock); } diff --git a/sys/ufs/lfs/lfs_subr.c b/sys/ufs/lfs/lfs_subr.c index afcd8c2..c839622 100644 --- a/sys/ufs/lfs/lfs_subr.c +++ b/sys/ufs/lfs/lfs_subr.c @@ -30,7 +30,7 @@ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. * - * @(#)lfs_subr.c 8.2 (Berkeley) 9/21/93 + * @(#)lfs_subr.c 8.4 (Berkeley) 5/8/95 */ #include <sys/param.h> @@ -63,13 +63,13 @@ lfs_blkatoff(ap) register struct lfs *fs; struct inode *ip; struct buf *bp; - daddr_t lbn; + ufs_daddr_t lbn; int bsize, error; ip = VTOI(ap->a_vp); fs = ip->i_lfs; lbn = lblkno(fs, ap->a_offset); - bsize = blksize(fs); + bsize = blksize(fs, ip, lbn); *ap->a_bpp = NULL; if (error = bread(ap->a_vp, lbn, bsize, NOCRED, &bp)) { @@ -109,7 +109,8 @@ lfs_seglock(fs, flags) sp = fs->lfs_sp = malloc(sizeof(struct segment), M_SEGMENT, M_WAITOK); sp->bpp = malloc(((LFS_SUMMARY_SIZE - sizeof(SEGSUM)) / - sizeof(daddr_t) + 1) * sizeof(struct buf *), M_SEGMENT, M_WAITOK); + sizeof(ufs_daddr_t) + 1) * sizeof(struct buf *), + M_SEGMENT, M_WAITOK); sp->seg_flags = flags; sp->vp = NULL; (void) lfs_initseg(fs); diff --git a/sys/ufs/lfs/lfs_syscalls.c b/sys/ufs/lfs/lfs_syscalls.c index 666595e..c6034e2 100644 --- a/sys/ufs/lfs/lfs_syscalls.c +++ b/sys/ufs/lfs/lfs_syscalls.c @@ -30,7 +30,7 @@ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. * - * @(#)lfs_syscalls.c 8.5 (Berkeley) 4/20/94 + * @(#)lfs_syscalls.c 8.10 (Berkeley) 5/14/95 */ #include <sys/param.h> @@ -64,6 +64,10 @@ if (sp->sum_bytes_left < (s)) { \ } struct buf *lfs_fakebuf __P((struct vnode *, int, size_t, caddr_t)); +int debug_cleaner = 0; +int clean_vnlocked = 0; +int clean_inlocked = 0; + /* * lfs_markv: * @@ -99,7 +103,7 @@ lfs_markv(p, uap, retval) fsid_t fsid; void *start; ino_t lastino; - daddr_t b_daddr, v_daddr; + ufs_daddr_t b_daddr, v_daddr; u_long bsize; int cnt, error; @@ -108,7 +112,7 @@ lfs_markv(p, uap, retval) if (error = copyin(uap->fsidp, &fsid, sizeof(fsid_t))) return (error); - if ((mntp = getvfs(&fsid)) == NULL) + if ((mntp = vfs_getvfs(&fsid)) == NULL) return (EINVAL); cnt = uap->blkcnt; @@ -135,7 +139,7 @@ lfs_markv(p, uap, retval) if (sp->fip->fi_nblocks == 0) { DEC_FINFO(sp); sp->sum_bytes_left += - sizeof(FINFO) - sizeof(daddr_t); + sizeof(FINFO) - sizeof(ufs_daddr_t); } else { lfs_updatemeta(sp); BUMP_FIP(sp); @@ -147,7 +151,7 @@ lfs_markv(p, uap, retval) /* Start a new file */ CHECK_SEG(sizeof(FINFO)); - sp->sum_bytes_left -= sizeof(FINFO) - sizeof(daddr_t); + sp->sum_bytes_left -= sizeof(FINFO) - sizeof(ufs_daddr_t); INC_FINFO(sp); sp->start_lbp = &sp->fip->fi_blocks[0]; sp->vp = NULL; @@ -172,6 +176,7 @@ lfs_markv(p, uap, retval) #ifdef DIAGNOSTIC printf("lfs_markv: VFS_VGET failed (%d)\n", blkp->bi_inode); + panic("lfs_markv VFS_VGET FAILED"); #endif lastino = LFS_UNUSED_INUM; v_daddr = LFS_UNUSED_DADDR; @@ -202,7 +207,7 @@ lfs_markv(p, uap, retval) bp = getblk(vp, blkp->bi_lbn, bsize, 0, 0); if (!(bp->b_flags & (B_DELWRI | B_DONE | B_CACHE)) && (error = copyin(blkp->bi_bp, bp->b_data, - bsize))) + blkp->bi_size))) goto err2; if (error = VOP_BWRITE(bp)) goto err2; @@ -213,7 +218,7 @@ lfs_markv(p, uap, retval) if (sp->fip->fi_nblocks == 0) { DEC_FINFO(sp); sp->sum_bytes_left += - sizeof(FINFO) - sizeof(daddr_t); + sizeof(FINFO) - sizeof(ufs_daddr_t); } else lfs_updatemeta(sp); @@ -267,10 +272,11 @@ lfs_bmapv(p, uap, retval) { BLOCK_INFO *blkp; struct mount *mntp; + struct ufsmount *ump; struct vnode *vp; fsid_t fsid; void *start; - daddr_t daddr; + ufs_daddr_t daddr; int cnt, error, step; if (error = suser(p->p_ucred, &p->p_acflag)) @@ -278,7 +284,7 @@ lfs_bmapv(p, uap, retval) if (error = copyin(uap->fsidp, &fsid, sizeof(fsid_t))) return (error); - if ((mntp = getvfs(&fsid)) == NULL) + if ((mntp = vfs_getvfs(&fsid)) == NULL) return (EINVAL); cnt = uap->blkcnt; @@ -291,10 +297,18 @@ lfs_bmapv(p, uap, retval) for (step = cnt; step--; ++blkp) { if (blkp->bi_lbn == LFS_UNUSED_LBN) continue; - /* Could be a deadlock ? */ - if (VFS_VGET(mntp, blkp->bi_inode, &vp)) + /* + * A regular call to VFS_VGET could deadlock + * here. Instead, we try an unlocked access. + */ + ump = VFSTOUFS(mntp); + if ((vp = + ufs_ihashlookup(ump->um_dev, blkp->bi_inode)) != NULL) { + if (VOP_BMAP(vp, blkp->bi_lbn, NULL, &daddr, NULL)) + daddr = LFS_UNUSED_DADDR; + } else if (VFS_VGET(mntp, blkp->bi_inode, &vp)) daddr = LFS_UNUSED_DADDR; - else { + else { if (VOP_BMAP(vp, blkp->bi_lbn, NULL, &daddr, NULL)) daddr = LFS_UNUSED_DADDR; vput(vp); @@ -337,7 +351,7 @@ lfs_segclean(p, uap, retval) if (error = copyin(uap->fsidp, &fsid, sizeof(fsid_t))) return (error); - if ((mntp = getvfs(&fsid)) == NULL) + if ((mntp = vfs_getvfs(&fsid)) == NULL) return (EINVAL); fs = VFSTOUFS(mntp)->um_lfs; @@ -402,14 +416,14 @@ lfs_segwait(p, uap, retval) if (fsid == (fsid_t)-1) addr = &lfs_allclean_wakeup; else { - if ((mntp = getvfs(&fsid)) == NULL) + if ((mntp = vfs_getvfs(&fsid)) == NULL) return (EINVAL); addr = &VFSTOUFS(mntp)->um_lfs->lfs_nextseg; } #else if (error = copyin(uap->fsidp, &fsid, sizeof(fsid_t))) return (error); - if ((mntp = getvfs(&fsid)) == NULL) + if ((mntp = vfs_getvfs(&fsid)) == NULL) addr = &lfs_allclean_wakeup; else addr = &VFSTOUFS(mntp)->um_lfs->lfs_nextseg; @@ -441,7 +455,7 @@ int lfs_fastvget(mp, ino, daddr, vpp, dinp) struct mount *mp; ino_t ino; - daddr_t daddr; + ufs_daddr_t daddr; struct vnode **vpp; struct dinode *dinp; { @@ -462,14 +476,12 @@ lfs_fastvget(mp, ino, daddr, vpp, dinp) if ((*vpp = ufs_ihashlookup(dev, ino)) != NULL) { lfs_vref(*vpp); if ((*vpp)->v_flag & VXLOCK) - printf ("Cleaned vnode VXLOCKED\n"); + clean_vnlocked++; ip = VTOI(*vpp); - if (ip->i_flags & IN_LOCKED) - printf("cleaned vnode locked\n"); - if (!(ip->i_flag & IN_MODIFIED)) { + if (lockstatus(&ip->i_lock)) + clean_inlocked++; + if (!(ip->i_flag & IN_MODIFIED)) ++ump->um_lfs->lfs_uinodes; - ip->i_flag |= IN_MODIFIED; - } ip->i_flag |= IN_MODIFIED; return (0); } @@ -522,9 +534,6 @@ lfs_fastvget(mp, ino, daddr, vpp, dinp) brelse(bp); } - /* Inode was just read from user space or disk, make sure it's locked */ - ip->i_flag |= IN_LOCKED; - /* * Initialize the vnode from the inode, check for aliases. In all * cases re-init ip, the underlying vnode/inode may have changed. diff --git a/sys/ufs/lfs/lfs_vfsops.c b/sys/ufs/lfs/lfs_vfsops.c index 0c8186e..6f61ef8 100644 --- a/sys/ufs/lfs/lfs_vfsops.c +++ b/sys/ufs/lfs/lfs_vfsops.c @@ -30,7 +30,7 @@ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. * - * @(#)lfs_vfsops.c 8.7 (Berkeley) 4/16/94 + * @(#)lfs_vfsops.c 8.20 (Berkeley) 6/10/95 */ #include <sys/param.h> @@ -73,12 +73,42 @@ struct vfsops lfs_vfsops = { lfs_fhtovp, lfs_vptofh, lfs_init, + lfs_sysctl, }; -int +/* + * Called by main() when ufs is going to be mounted as root. + */ lfs_mountroot() { - panic("lfs_mountroot"); /* XXX -- implement */ + extern struct vnode *rootvp; + struct fs *fs; + struct mount *mp; + struct proc *p = curproc; /* XXX */ + int error; + + /* + * Get vnodes for swapdev and rootdev. + */ + if ((error = bdevvp(swapdev, &swapdev_vp)) || + (error = bdevvp(rootdev, &rootvp))) { + printf("lfs_mountroot: can't setup bdevvp's"); + return (error); + } + if (error = vfs_rootmountalloc("lfs", "root_device", &mp)) + return (error); + if (error = lfs_mountfs(rootvp, mp, p)) { + mp->mnt_vfc->vfc_refcount--; + vfs_unbusy(mp, p); + free(mp, M_MOUNT); + return (error); + } + simple_lock(&mountlist_slock); + CIRCLEQ_INSERT_TAIL(&mountlist, mp, mnt_list); + simple_unlock(&mountlist_slock); + (void)lfs_statfs(mp, &mp->mnt_stat, p); + vfs_unbusy(mp, p); + return (0); } /* @@ -99,6 +129,7 @@ lfs_mount(mp, path, data, ndp, p) register struct lfs *fs; /* LFS */ u_int size; int error; + mode_t accessmode; if (error = copyin(data, (caddr_t)&args, sizeof (struct ufs_args))) return (error); @@ -113,15 +144,23 @@ lfs_mount(mp, path, data, ndp, p) */ if (mp->mnt_flag & MNT_UPDATE) { ump = VFSTOUFS(mp); -#ifdef NOTLFS /* LFS */ - fs = ump->um_fs; - if (fs->fs_ronly && (mp->mnt_flag & MNT_RDONLY) == 0) - fs->fs_ronly = 0; -#else - fs = ump->um_lfs; - if (fs->lfs_ronly && (mp->mnt_flag & MNT_RDONLY) == 0) + if (fs->lfs_ronly && (mp->mnt_flag & MNT_WANTRDWR)) { + /* + * If upgrade to read-write by non-root, then verify + * that user has necessary permissions on the device. + */ + if (p->p_ucred->cr_uid != 0) { + vn_lock(ump->um_devvp, LK_EXCLUSIVE | LK_RETRY, + p); + if (error = VOP_ACCESS(ump->um_devvp, + VREAD | VWRITE, p->p_ucred, p)) { + VOP_UNLOCK(ump->um_devvp, 0, p); + return (error); + } + VOP_UNLOCK(ump->um_devvp, 0, p); + } fs->lfs_ronly = 0; -#endif + } if (args.fspec == 0) { /* * Process export requests. @@ -145,6 +184,21 @@ lfs_mount(mp, path, data, ndp, p) vrele(devvp); return (ENXIO); } + /* + * If mount by non-root, then verify that user has necessary + * permissions on the device. + */ + if (p->p_ucred->cr_uid != 0) { + accessmode = VREAD; + if ((mp->mnt_flag & MNT_RDONLY) == 0) + accessmode |= VWRITE; + vn_lock(devvp, LK_EXCLUSIVE | LK_RETRY, p); + if (error = VOP_ACCESS(devvp, accessmode, p->p_ucred, p)) { + vput(devvp); + return (error); + } + VOP_UNLOCK(devvp, 0, p); + } if ((mp->mnt_flag & MNT_UPDATE) == 0) error = lfs_mountfs(devvp, mp, p); /* LFS */ else { @@ -199,7 +253,9 @@ lfs_mountfs(devvp, mp, p) struct partinfo dpart; dev_t dev; int error, i, ronly, size; + struct ucred *cred; + cred = p ? p->p_ucred : NOCRED; /* * Disallow multiple mounts of the same device. * Disallow mounting of a device that is currently in use @@ -210,14 +266,14 @@ lfs_mountfs(devvp, mp, p) return (error); if (vcount(devvp) > 1 && devvp != rootvp) return (EBUSY); - if (error = vinvalbuf(devvp, V_SAVE, p->p_ucred, p, 0, 0)) + if (error = vinvalbuf(devvp, V_SAVE, cred, p, 0, 0)) return (error); ronly = (mp->mnt_flag & MNT_RDONLY) != 0; if (error = VOP_OPEN(devvp, ronly ? FREAD : FREAD|FWRITE, FSCRED, p)) return (error); - if (VOP_IOCTL(devvp, DIOCGPART, (caddr_t)&dpart, FREAD, NOCRED, p) != 0) + if (VOP_IOCTL(devvp, DIOCGPART, (caddr_t)&dpart, FREAD, cred, p) != 0) size = DEV_BSIZE; else { size = dpart.disklab->d_secsize; @@ -234,7 +290,7 @@ lfs_mountfs(devvp, mp, p) ump = NULL; /* Read in the superblock. */ - if (error = bread(devvp, LFS_LABELPAD / size, LFS_SBPAD, NOCRED, &bp)) + if (error = bread(devvp, LFS_LABELPAD / size, LFS_SBPAD, cred, &bp)) goto out; fs = (struct lfs *)bp->b_data; @@ -272,7 +328,8 @@ lfs_mountfs(devvp, mp, p) dev = devvp->v_rdev; mp->mnt_data = (qaddr_t)ump; mp->mnt_stat.f_fsid.val[0] = (long)dev; - mp->mnt_stat.f_fsid.val[1] = MOUNT_LFS; + mp->mnt_stat.f_fsid.val[1] = lfs_mount_type; + mp->mnt_maxsymlinklen = fs->lfs_maxsymlinklen; mp->mnt_flag |= MNT_LOCAL; ump->um_mountp = mp; ump->um_dev = dev; @@ -300,7 +357,7 @@ lfs_mountfs(devvp, mp, p) out: if (bp) brelse(bp); - (void)VOP_CLOSE(devvp, ronly ? FREAD : FREAD|FWRITE, NOCRED, p); + (void)VOP_CLOSE(devvp, ronly ? FREAD : FREAD|FWRITE, cred, p); if (ump) { free(ump->um_lfs, M_UFSMNT); free(ump, M_UFSMNT); @@ -323,11 +380,8 @@ lfs_unmount(mp, mntflags, p) int i, error, flags, ronly; flags = 0; - if (mntflags & MNT_FORCE) { - if (!doforce || (mp->mnt_flag & MNT_ROOTFS)) - return (EINVAL); + if (mntflags & MNT_FORCE) flags |= FORCECLOSE; - } ump = VFSTOUFS(mp); fs = ump->um_lfs; @@ -383,17 +437,23 @@ lfs_statfs(mp, sbp, p) fs = ump->um_lfs; if (fs->lfs_magic != LFS_MAGIC) panic("lfs_statfs: magic"); - sbp->f_type = MOUNT_LFS; - sbp->f_bsize = fs->lfs_bsize; + sbp->f_bsize = fs->lfs_fsize; sbp->f_iosize = fs->lfs_bsize; - sbp->f_blocks = dbtofsb(fs,fs->lfs_dsize); - sbp->f_bfree = dbtofsb(fs, fs->lfs_bfree); - sbp->f_bavail = (fs->lfs_dsize * (100 - fs->lfs_minfree) / 100) - - (fs->lfs_dsize - fs->lfs_bfree); - sbp->f_bavail = dbtofsb(fs, sbp->f_bavail); + sbp->f_blocks = dbtofrags(fs,fs->lfs_dsize); + sbp->f_bfree = dbtofrags(fs, fs->lfs_bfree); + /* + * To compute the available space. Subtract the minimum free + * from the total number of blocks in the file system. Set avail + * to the smaller of this number and fs->lfs_bfree. + */ + sbp->f_bavail = fs->lfs_dsize * (100 - fs->lfs_minfree) / 100; + sbp->f_bavail = + sbp->f_bavail > fs->lfs_bfree ? fs->lfs_bfree : sbp->f_bavail; + sbp->f_bavail = dbtofrags(fs, sbp->f_bavail); sbp->f_files = fs->lfs_nfiles; sbp->f_ffree = sbp->f_bfree * INOPB(fs); if (sbp != &mp->mnt_stat) { + sbp->f_type = mp->mnt_vfc->vfc_typenum; bcopy((caddr_t)mp->mnt_stat.f_mntonname, (caddr_t)&sbp->f_mntonname[0], MNAMELEN); bcopy((caddr_t)mp->mnt_stat.f_mntfromname, @@ -442,7 +502,7 @@ lfs_vget(mp, ino, vpp) struct ifile *ifp; struct vnode *vp; struct ufsmount *ump; - daddr_t daddr; + ufs_daddr_t daddr; dev_t dev; int error; @@ -571,3 +631,17 @@ lfs_vptofh(vp, fhp) ufhp->ufid_gen = ip->i_gen; return (0); } + +/* + * Initialize the filesystem, most work done by ufs_init. + */ +int lfs_mount_type; + +int +lfs_init(vfsp) + struct vfsconf *vfsp; +{ + + lfs_mount_type = vfsp->vfc_typenum; + return (ufs_init(vfsp)); +} diff --git a/sys/ufs/lfs/lfs_vnops.c b/sys/ufs/lfs/lfs_vnops.c index fc6bd48..721d6f2 100644 --- a/sys/ufs/lfs/lfs_vnops.c +++ b/sys/ufs/lfs/lfs_vnops.c @@ -1,5 +1,5 @@ /* - * Copyright (c) 1986, 1989, 1991, 1993 + * Copyright (c) 1986, 1989, 1991, 1993, 1995 * The Regents of the University of California. All rights reserved. * * Redistribution and use in source and binary forms, with or without @@ -30,7 +30,7 @@ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. * - * @(#)lfs_vnops.c 8.5 (Berkeley) 12/30/93 + * @(#)lfs_vnops.c 8.13 (Berkeley) 6/10/95 */ #include <sys/param.h> @@ -67,6 +67,7 @@ struct vnodeopv_entry_desc lfs_vnodeop_entries[] = { { &vop_default_desc, vn_default_error }, { &vop_lookup_desc, ufs_lookup }, /* lookup */ { &vop_create_desc, ufs_create }, /* create */ + { &vop_whiteout_desc, ufs_whiteout }, /* whiteout */ { &vop_mknod_desc, ufs_mknod }, /* mknod */ { &vop_open_desc, ufs_open }, /* open */ { &vop_close_desc, lfs_close }, /* close */ @@ -75,8 +76,10 @@ struct vnodeopv_entry_desc lfs_vnodeop_entries[] = { { &vop_setattr_desc, ufs_setattr }, /* setattr */ { &vop_read_desc, lfs_read }, /* read */ { &vop_write_desc, lfs_write }, /* write */ + { &vop_lease_desc, ufs_lease_check }, /* lease */ { &vop_ioctl_desc, ufs_ioctl }, /* ioctl */ { &vop_select_desc, ufs_select }, /* select */ + { &vop_revoke_desc, ufs_revoke }, /* revoke */ { &vop_mmap_desc, ufs_mmap }, /* mmap */ { &vop_fsync_desc, lfs_fsync }, /* fsync */ { &vop_seek_desc, ufs_seek }, /* seek */ @@ -89,8 +92,8 @@ struct vnodeopv_entry_desc lfs_vnodeop_entries[] = { { &vop_readdir_desc, ufs_readdir }, /* readdir */ { &vop_readlink_desc, ufs_readlink }, /* readlink */ { &vop_abortop_desc, ufs_abortop }, /* abortop */ - { &vop_inactive_desc, lfs_inactive }, /* inactive */ - { &vop_reclaim_desc, ufs_reclaim }, /* reclaim */ + { &vop_inactive_desc, ufs_inactive }, /* inactive */ + { &vop_reclaim_desc, lfs_reclaim }, /* reclaim */ { &vop_lock_desc, ufs_lock }, /* lock */ { &vop_unlock_desc, ufs_unlock }, /* unlock */ { &vop_bmap_desc, ufs_bmap }, /* bmap */ @@ -123,8 +126,10 @@ struct vnodeopv_entry_desc lfs_specop_entries[] = { { &vop_setattr_desc, ufs_setattr }, /* setattr */ { &vop_read_desc, ufsspec_read }, /* read */ { &vop_write_desc, ufsspec_write }, /* write */ + { &vop_lease_desc, spec_lease_check }, /* lease */ { &vop_ioctl_desc, spec_ioctl }, /* ioctl */ { &vop_select_desc, spec_select }, /* select */ + { &vop_revoke_desc, spec_revoke }, /* revoke */ { &vop_mmap_desc, spec_mmap }, /* mmap */ { &vop_fsync_desc, spec_fsync }, /* fsync */ { &vop_seek_desc, spec_seek }, /* seek */ @@ -137,8 +142,8 @@ struct vnodeopv_entry_desc lfs_specop_entries[] = { { &vop_readdir_desc, spec_readdir }, /* readdir */ { &vop_readlink_desc, spec_readlink }, /* readlink */ { &vop_abortop_desc, spec_abortop }, /* abortop */ - { &vop_inactive_desc, lfs_inactive }, /* inactive */ - { &vop_reclaim_desc, ufs_reclaim }, /* reclaim */ + { &vop_inactive_desc, ufs_inactive }, /* inactive */ + { &vop_reclaim_desc, lfs_reclaim }, /* reclaim */ { &vop_lock_desc, ufs_lock }, /* lock */ { &vop_unlock_desc, ufs_unlock }, /* unlock */ { &vop_bmap_desc, spec_bmap }, /* bmap */ @@ -172,8 +177,10 @@ struct vnodeopv_entry_desc lfs_fifoop_entries[] = { { &vop_setattr_desc, ufs_setattr }, /* setattr */ { &vop_read_desc, ufsfifo_read }, /* read */ { &vop_write_desc, ufsfifo_write }, /* write */ + { &vop_lease_desc, fifo_lease_check }, /* lease */ { &vop_ioctl_desc, fifo_ioctl }, /* ioctl */ { &vop_select_desc, fifo_select }, /* select */ + { &vop_revoke_desc, fifo_revoke }, /* revoke */ { &vop_mmap_desc, fifo_mmap }, /* mmap */ { &vop_fsync_desc, fifo_fsync }, /* fsync */ { &vop_seek_desc, fifo_seek }, /* seek */ @@ -186,8 +193,8 @@ struct vnodeopv_entry_desc lfs_fifoop_entries[] = { { &vop_readdir_desc, fifo_readdir }, /* readdir */ { &vop_readlink_desc, fifo_readlink }, /* readlink */ { &vop_abortop_desc, fifo_abortop }, /* abortop */ - { &vop_inactive_desc, lfs_inactive }, /* inactive */ - { &vop_reclaim_desc, ufs_reclaim }, /* reclaim */ + { &vop_inactive_desc, ufs_inactive }, /* inactive */ + { &vop_reclaim_desc, lfs_reclaim }, /* reclaim */ { &vop_lock_desc, ufs_lock }, /* lock */ { &vop_unlock_desc, ufs_unlock }, /* unlock */ { &vop_bmap_desc, fifo_bmap }, /* bmap */ @@ -371,10 +378,10 @@ lfs_link(ap) { int ret; - SET_DIROP(VTOI(ap->a_vp)->i_lfs); - MARK_VNODE(ap->a_vp); + SET_DIROP(VTOI(ap->a_tdvp)->i_lfs); + MARK_VNODE(ap->a_tdvp); ret = ufs_link(ap); - SET_ENDOP(VTOI(ap->a_vp)->i_lfs); + SET_ENDOP(VTOI(ap->a_tdvp)->i_lfs); return (ret); } @@ -422,9 +429,12 @@ lfs_getattr(ap) vap->va_gid = ip->i_gid; vap->va_rdev = (dev_t)ip->i_rdev; vap->va_size = ip->i_din.di_size; - vap->va_atime = ip->i_atime; - vap->va_mtime = ip->i_mtime; - vap->va_ctime = ip->i_ctime; + vap->va_atime.ts_sec = ip->i_atime; + vap->va_atime.ts_nsec = ip->i_atimensec; + vap->va_mtime.ts_sec = ip->i_mtime; + vap->va_mtime.ts_nsec = ip->i_mtimensec; + vap->va_ctime.ts_sec = ip->i_ctime; + vap->va_ctime.ts_nsec = ip->i_ctimensec; vap->va_flags = ip->i_flags; vap->va_gen = ip->i_gen; /* this doesn't belong here */ @@ -460,28 +470,33 @@ lfs_close(ap) register struct inode *ip = VTOI(vp); int mod; - if (vp->v_usecount > 1 && !(ip->i_flag & IN_LOCKED)) { + simple_lock(&vp->v_interlock); + if (vp->v_usecount > 1) { mod = ip->i_flag & IN_MODIFIED; ITIMES(ip, &time, &time); if (!mod && ip->i_flag & IN_MODIFIED) ip->i_lfs->lfs_uinodes++; } + simple_unlock(&vp->v_interlock); return (0); } /* - * Stub inactive routine that avoid calling ufs_inactive in some cases. + * Reclaim an inode so that it can be used for other purposes. */ -int lfs_no_inactive = 0; - int -lfs_inactive(ap) - struct vop_inactive_args /* { +lfs_reclaim(ap) + struct vop_reclaim_args /* { struct vnode *a_vp; + struct proc *a_p; } */ *ap; { - - if (lfs_no_inactive) - return (0); - return (ufs_inactive(ap)); + register struct vnode *vp = ap->a_vp; + int error; + + if (error = ufs_reclaim(vp, ap->a_p)) + return (error); + FREE(vp->v_data, M_LFSNODE); + vp->v_data = NULL; + return (0); } diff --git a/sys/ufs/mfs/mfs_extern.h b/sys/ufs/mfs/mfs_extern.h index e357faf6..51cf8da 100644 --- a/sys/ufs/mfs/mfs_extern.h +++ b/sys/ufs/mfs/mfs_extern.h @@ -30,7 +30,7 @@ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. * - * @(#)mfs_extern.h 8.1 (Berkeley) 6/11/93 + * @(#)mfs_extern.h 8.4 (Berkeley) 3/30/95 */ struct buf; @@ -40,6 +40,7 @@ struct proc; struct statfs; struct ucred; struct vnode; +struct vfsconf; __BEGIN_DECLS int mfs_badop __P((void)); @@ -47,13 +48,14 @@ int mfs_bmap __P((struct vop_bmap_args *)); int mfs_close __P((struct vop_close_args *)); void mfs_doio __P((struct buf *bp, caddr_t base)); int mfs_inactive __P((struct vop_inactive_args *)); /* XXX */ -int mfs_reclaim __P((struct vop_reclaim_args *)); /* XXX */ -int mfs_init __P((void)); +int mfs_reclaim __P((struct vop_reclaim_args *)); +int mfs_init __P((struct vfsconf *)); int mfs_ioctl __P((struct vop_ioctl_args *)); int mfs_mount __P((struct mount *mp, char *path, caddr_t data, struct nameidata *ndp, struct proc *p)); int mfs_open __P((struct vop_open_args *)); int mfs_print __P((struct vop_print_args *)); /* XXX */ +#define mfs_revoke vop_revoke int mfs_start __P((struct mount *mp, int flags, struct proc *p)); int mfs_statfs __P((struct mount *mp, struct statfs *sbp, struct proc *p)); int mfs_strategy __P((struct vop_strategy_args *)); /* XXX */ diff --git a/sys/ufs/mfs/mfs_vfsops.c b/sys/ufs/mfs/mfs_vfsops.c index 3fcbdf3..15a4be2 100644 --- a/sys/ufs/mfs/mfs_vfsops.c +++ b/sys/ufs/mfs/mfs_vfsops.c @@ -30,7 +30,7 @@ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. * - * @(#)mfs_vfsops.c 8.4 (Berkeley) 4/16/94 + * @(#)mfs_vfsops.c 8.11 (Berkeley) 6/19/95 */ #include <sys/param.h> @@ -77,36 +77,32 @@ struct vfsops mfs_vfsops = { ffs_fhtovp, ffs_vptofh, mfs_init, + ffs_sysctl, }; /* * Called by main() when mfs is going to be mounted as root. - * - * Name is updated by mount(8) after booting. */ -#define ROOTNAME "mfs_root" - mfs_mountroot() { extern struct vnode *rootvp; - register struct fs *fs; - register struct mount *mp; + struct fs *fs; + struct mount *mp; struct proc *p = curproc; /* XXX */ struct ufsmount *ump; struct mfsnode *mfsp; - u_int size; int error; /* * Get vnodes for swapdev and rootdev. */ - if (bdevvp(swapdev, &swapdev_vp) || bdevvp(rootdev, &rootvp)) - panic("mfs_mountroot: can't setup bdevvp's"); - - mp = malloc((u_long)sizeof(struct mount), M_MOUNT, M_WAITOK); - bzero((char *)mp, (u_long)sizeof(struct mount)); - mp->mnt_op = &mfs_vfsops; - mp->mnt_flag = MNT_RDONLY; + if ((error = bdevvp(swapdev, &swapdev_vp)) || + (error = bdevvp(rootdev, &rootvp))) { + printf("mfs_mountroot: can't setup bdevvp's"); + return (error); + } + if (error = vfs_rootmountalloc("mfs", "mfs_root", &mp)) + return (error); mfsp = malloc(sizeof *mfsp, M_MFSNODE, M_WAITOK); rootvp->v_data = mfsp; rootvp->v_op = mfs_vnodeop_p; @@ -117,30 +113,20 @@ mfs_mountroot() mfsp->mfs_pid = p->p_pid; mfsp->mfs_buflist = (struct buf *)0; if (error = ffs_mountfs(rootvp, mp, p)) { + mp->mnt_vfc->vfc_refcount--; + vfs_unbusy(mp, p); free(mp, M_MOUNT); free(mfsp, M_MFSNODE); return (error); } - if (error = vfs_lock(mp)) { - (void)ffs_unmount(mp, 0, p); - free(mp, M_MOUNT); - free(mfsp, M_MFSNODE); - return (error); - } - TAILQ_INSERT_TAIL(&mountlist, mp, mnt_list); - mp->mnt_flag |= MNT_ROOTFS; - mp->mnt_vnodecovered = NULLVP; + simple_lock(&mountlist_slock); + CIRCLEQ_INSERT_TAIL(&mountlist, mp, mnt_list); + simple_unlock(&mountlist_slock); ump = VFSTOUFS(mp); fs = ump->um_fs; - bzero(fs->fs_fsmnt, sizeof(fs->fs_fsmnt)); - fs->fs_fsmnt[0] = '/'; - bcopy((caddr_t)fs->fs_fsmnt, (caddr_t)mp->mnt_stat.f_mntonname, - MNAMELEN); - (void) copystr(ROOTNAME, mp->mnt_stat.f_mntfromname, MNAMELEN - 1, - &size); - bzero(mp->mnt_stat.f_mntfromname + size, MNAMELEN - size); + (void) copystr(mp->mnt_stat.f_mntonname, fs->fs_fsmnt, MNAMELEN - 1, 0); (void)ffs_statfs(mp, &mp->mnt_stat, p); - vfs_unlock(mp); + vfs_unbusy(mp, p); inittodr((time_t)0); return (0); } @@ -202,11 +188,7 @@ mfs_mount(mp, path, data, ndp, p) flags = WRITECLOSE; if (mp->mnt_flag & MNT_FORCE) flags |= FORCECLOSE; - if (vfs_busy(mp)) - return (EBUSY); - error = ffs_flushfiles(mp, flags, p); - vfs_unbusy(mp); - if (error) + if (error = ffs_flushfiles(mp, flags, p)) return (error); } if (fs->fs_ronly && (mp->mnt_flag & MNT_WANTRDWR)) @@ -269,7 +251,6 @@ mfs_start(mp, flags, p) register struct mfsnode *mfsp = VTOMFS(vp); register struct buf *bp; register caddr_t base; - int error = 0; base = mfsp->mfs_baseoff; while (mfsp->mfs_buflist != (struct buf *)(-1)) { @@ -284,11 +265,11 @@ mfs_start(mp, flags, p) * otherwise we will loop here, as tsleep will always return * EINTR/ERESTART. */ - if (error = tsleep((caddr_t)vp, mfs_pri, "mfsidl", 0)) - if (dounmount(mp, 0, p) != 0) - CLRSIG(p, CURSIG(p)); + if (tsleep((caddr_t)vp, mfs_pri, "mfsidl", 0) && + dounmount(mp, 0, p) != 0) + CLRSIG(p, CURSIG(p)); } - return (error); + return (0); } /* @@ -302,6 +283,6 @@ mfs_statfs(mp, sbp, p) int error; error = ffs_statfs(mp, sbp, p); - sbp->f_type = MOUNT_MFS; + sbp->f_type = mp->mnt_vfc->vfc_typenum; return (error); } diff --git a/sys/ufs/mfs/mfs_vnops.c b/sys/ufs/mfs/mfs_vnops.c index 71adf06..4a0a28b 100644 --- a/sys/ufs/mfs/mfs_vnops.c +++ b/sys/ufs/mfs/mfs_vnops.c @@ -30,7 +30,7 @@ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. * - * @(#)mfs_vnops.c 8.3 (Berkeley) 9/21/93 + * @(#)mfs_vnops.c 8.11 (Berkeley) 5/22/95 */ #include <sys/param.h> @@ -51,12 +51,6 @@ #include <ufs/mfs/mfsiom.h> #include <ufs/mfs/mfs_extern.h> -#if !defined(hp300) && !defined(i386) && !defined(mips) && !defined(sparc) && !defined(luna68k) -static int mfsmap_want; /* 1 => need kernel I/O resources */ -struct map mfsmap[MFS_MAPSIZE]; -extern char mfsiobuf[]; -#endif - /* * mfs vnode operations. */ @@ -75,6 +69,7 @@ struct vnodeopv_entry_desc mfs_vnodeop_entries[] = { { &vop_write_desc, mfs_write }, /* write */ { &vop_ioctl_desc, mfs_ioctl }, /* ioctl */ { &vop_select_desc, mfs_select }, /* select */ + { &vop_revoke_desc, mfs_revoke }, /* revoke */ { &vop_mmap_desc, mfs_mmap }, /* mmap */ { &vop_fsync_desc, spec_fsync }, /* fsync */ { &vop_seek_desc, mfs_seek }, /* seek */ @@ -189,85 +184,6 @@ mfs_strategy(ap) return (0); } -#if defined(vax) || defined(tahoe) -/* - * Memory file system I/O. - * - * Essentially play ubasetup() and disk interrupt service routine by - * doing the copies to or from the memfs process. If doing physio - * (i.e. pagein), we must map the I/O through the kernel virtual - * address space. - */ -void -mfs_doio(bp, base) - register struct buf *bp; - caddr_t base; -{ - register struct pte *pte, *ppte; - register caddr_t vaddr; - int off, npf, npf2, reg; - caddr_t kernaddr, offset; - - /* - * For phys I/O, map the b_data into kernel virtual space using - * the Mfsiomap pte's. - */ - if ((bp->b_flags & B_PHYS) == 0) { - kernaddr = bp->b_data; - } else { - if (bp->b_flags & (B_PAGET | B_UAREA | B_DIRTY)) - panic("swap on memfs?"); - off = (int)bp->b_data & PGOFSET; - npf = btoc(bp->b_bcount + off); - /* - * Get some mapping page table entries - */ - while ((reg = rmalloc(mfsmap, (long)npf)) == 0) { - mfsmap_want++; - sleep((caddr_t)&mfsmap_want, PZERO-1); - } - reg--; - pte = vtopte(bp->b_proc, btop(bp->b_data)); - /* - * Do vmaccess() but with the Mfsiomap page table. - */ - ppte = &Mfsiomap[reg]; - vaddr = &mfsiobuf[reg * NBPG]; - kernaddr = vaddr + off; - for (npf2 = npf; npf2; npf2--) { - mapin(ppte, (u_int)vaddr, pte->pg_pfnum, - (int)(PG_V|PG_KW)); -#if defined(tahoe) - if ((bp->b_flags & B_READ) == 0) - mtpr(P1DC, vaddr); -#endif - ppte++; - pte++; - vaddr += NBPG; - } - } - offset = base + (bp->b_blkno << DEV_BSHIFT); - if (bp->b_flags & B_READ) - bp->b_error = copyin(offset, kernaddr, bp->b_bcount); - else - bp->b_error = copyout(kernaddr, offset, bp->b_bcount); - if (bp->b_error) - bp->b_flags |= B_ERROR; - /* - * Release pte's used by physical I/O. - */ - if (bp->b_flags & B_PHYS) { - rmfree(mfsmap, (long)npf, (long)++reg); - if (mfsmap_want) { - mfsmap_want = 0; - wakeup((caddr_t)&mfsmap_want); - } - } - biodone(bp); -} -#endif /* vax || tahoe */ - -#if defined(hp300) || defined(i386) || defined(mips) || defined(sparc) || defined(luna68k) /* * Memory file system I/O. * @@ -288,7 +204,6 @@ mfs_doio(bp, base) bp->b_flags |= B_ERROR; biodone(bp); } -#endif /* * This is a noop, simply returning what one has been given. @@ -297,9 +212,9 @@ int mfs_bmap(ap) struct vop_bmap_args /* { struct vnode *a_vp; - daddr_t a_bn; + ufs_daddr_t a_bn; struct vnode **a_vpp; - daddr_t *a_bnp; + ufs_daddr_t *a_bnp; int *a_runp; } */ *ap; { @@ -308,6 +223,8 @@ mfs_bmap(ap) *ap->a_vpp = ap->a_vp; if (ap->a_bnp != NULL) *ap->a_bnp = ap->a_bn; + if (ap->a_runp != NULL) + *ap->a_runp = 0; return (0); } @@ -368,13 +285,16 @@ int mfs_inactive(ap) struct vop_inactive_args /* { struct vnode *a_vp; + struct proc *a_p; } */ *ap; { - register struct mfsnode *mfsp = VTOMFS(ap->a_vp); + struct vnode *vp = ap->a_vp; + struct mfsnode *mfsp = VTOMFS(vp); if (mfsp->mfs_buflist && mfsp->mfs_buflist != (struct buf *)(-1)) panic("mfs_inactive: not inactive (mfs_buflist %x)", mfsp->mfs_buflist); + VOP_UNLOCK(vp, 0, ap->a_p); return (0); } @@ -387,9 +307,10 @@ mfs_reclaim(ap) struct vnode *a_vp; } */ *ap; { + register struct vnode *vp = ap->a_vp; - FREE(ap->a_vp->v_data, M_MFSNODE); - ap->a_vp->v_data = NULL; + FREE(vp->v_data, M_MFSNODE); + vp->v_data = NULL; return (0); } @@ -423,10 +344,9 @@ mfs_badop() /* * Memory based filesystem initialization. */ -mfs_init() +mfs_init(vfsp) + struct vfsconf *vfsp; { -#if !defined(hp300) && !defined(i386) && !defined(mips) && !defined(sparc) && !defined(luna68k) - rminit(mfsmap, (long)MFS_MAPREG, (long)1, "mfs mapreg", MFS_MAPSIZE); -#endif + return; } diff --git a/sys/ufs/mfs/mfsnode.h b/sys/ufs/mfs/mfsnode.h index 4480ab0..3d8a3b6 100644 --- a/sys/ufs/mfs/mfsnode.h +++ b/sys/ufs/mfs/mfsnode.h @@ -30,7 +30,7 @@ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. * - * @(#)mfsnode.h 8.2 (Berkeley) 8/11/93 + * @(#)mfsnode.h 8.3 (Berkeley) 5/19/95 */ /* @@ -73,9 +73,9 @@ struct mfsnode { #define mfs_readdir ((int (*) __P((struct vop_readdir_args *)))mfs_badop) #define mfs_readlink ((int (*) __P((struct vop_readlink_args *)))mfs_badop) #define mfs_abortop ((int (*) __P((struct vop_abortop_args *)))mfs_badop) -#define mfs_lock ((int (*) __P((struct vop_lock_args *)))nullop) -#define mfs_unlock ((int (*) __P((struct vop_unlock_args *)))nullop) -#define mfs_islocked ((int (*) __P((struct vop_islocked_args *)))nullop) +#define mfs_lock ((int (*) __P((struct vop_lock_args *)))vop_nolock) +#define mfs_unlock ((int (*) __P((struct vop_unlock_args *)))vop_nounlock) +#define mfs_islocked ((int(*) __P((struct vop_islocked_args *)))vop_noislocked) #define mfs_pathconf ((int (*) __P((struct vop_pathconf_args *)))mfs_badop) #define mfs_advlock ((int (*) __P((struct vop_advlock_args *)))mfs_badop) #define mfs_blkatoff ((int (*) __P((struct vop_blkatoff_args *)))mfs_badop) diff --git a/sys/ufs/ufs/dinode.h b/sys/ufs/ufs/dinode.h index 5b9915d..ad3da97 100644 --- a/sys/ufs/ufs/dinode.h +++ b/sys/ufs/ufs/dinode.h @@ -35,7 +35,7 @@ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. * - * @(#)dinode.h 8.3 (Berkeley) 1/21/94 + * @(#)dinode.h 8.9 (Berkeley) 3/29/95 */ /* @@ -47,32 +47,46 @@ #define ROOTINO ((ino_t)2) /* + * The Whiteout inode# is a dummy non-zero inode number which will + * never be allocated to a real file. It is used as a place holder + * in the directory entry which has been tagged as a DT_W entry. + * See the comments about ROOTINO above. + */ +#define WINO ((ino_t)1) + +/* * A dinode contains all the meta-data associated with a UFS file. - * This structure defines the on-disk format of a dinode. + * This structure defines the on-disk format of a dinode. Since + * this structure describes an on-disk structure, all its fields + * are defined by types with precise widths. */ +typedef int32_t ufs_daddr_t; #define NDADDR 12 /* Direct addresses in inode. */ #define NIADDR 3 /* Indirect addresses in inode. */ struct dinode { - u_short di_mode; /* 0: IFMT and permissions. */ - short di_nlink; /* 2: File link count. */ + u_int16_t di_mode; /* 0: IFMT, permissions; see below. */ + int16_t di_nlink; /* 2: File link count. */ union { - u_short oldids[2]; /* 4: Ffs: old user and group ids. */ - ino_t inumber; /* 4: Lfs: inode number. */ + u_int16_t oldids[2]; /* 4: Ffs: old user and group ids. */ + int32_t inumber; /* 4: Lfs: inode number. */ } di_u; - u_quad_t di_size; /* 8: File byte count. */ - struct timespec di_atime; /* 16: Last access time. */ - struct timespec di_mtime; /* 24: Last modified time. */ - struct timespec di_ctime; /* 32: Last inode change time. */ - daddr_t di_db[NDADDR]; /* 40: Direct disk blocks. */ - daddr_t di_ib[NIADDR]; /* 88: Indirect disk blocks. */ - u_long di_flags; /* 100: Status flags (chflags). */ - long di_blocks; /* 104: Blocks actually held. */ - long di_gen; /* 108: Generation number. */ - u_long di_uid; /* 112: File owner. */ - u_long di_gid; /* 116: File group. */ - long di_spare[2]; /* 120: Reserved; currently unused */ + u_int64_t di_size; /* 8: File byte count. */ + int32_t di_atime; /* 16: Last access time. */ + int32_t di_atimensec; /* 20: Last access time. */ + int32_t di_mtime; /* 24: Last modified time. */ + int32_t di_mtimensec; /* 28: Last modified time. */ + int32_t di_ctime; /* 32: Last inode change time. */ + int32_t di_ctimensec; /* 36: Last inode change time. */ + ufs_daddr_t di_db[NDADDR]; /* 40: Direct disk blocks. */ + ufs_daddr_t di_ib[NIADDR]; /* 88: Indirect disk blocks. */ + u_int32_t di_flags; /* 100: Status flags (chflags). */ + u_int32_t di_blocks; /* 104: Blocks actually held. */ + int32_t di_gen; /* 108: Generation number. */ + u_int32_t di_uid; /* 112: File owner. */ + u_int32_t di_gid; /* 116: File group. */ + int32_t di_spare[2]; /* 120: Reserved; currently unused */ }; /* @@ -87,9 +101,9 @@ struct dinode { #define di_ouid di_u.oldids[0] #define di_rdev di_db[0] #define di_shortlink di_db -#define MAXSYMLINKLEN ((NDADDR + NIADDR) * sizeof(daddr_t)) +#define MAXSYMLINKLEN ((NDADDR + NIADDR) * sizeof(ufs_daddr_t)) -/* File modes. */ +/* File permissions. */ #define IEXEC 0000100 /* Executable. */ #define IWRITE 0000200 /* Writeable. */ #define IREAD 0000400 /* Readable. */ @@ -106,3 +120,4 @@ struct dinode { #define IFREG 0100000 /* Regular file. */ #define IFLNK 0120000 /* Symbolic link. */ #define IFSOCK 0140000 /* UNIX domain socket. */ +#define IFWHT 0160000 /* Whiteout. */ diff --git a/sys/ufs/ufs/dir.h b/sys/ufs/ufs/dir.h index c51bd1c..62bd871 100644 --- a/sys/ufs/ufs/dir.h +++ b/sys/ufs/ufs/dir.h @@ -35,13 +35,21 @@ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. * - * @(#)dir.h 8.2 (Berkeley) 1/21/94 + * @(#)dir.h 8.5 (Berkeley) 4/27/95 */ #ifndef _DIR_H_ #define _DIR_H_ /* + * Theoretically, directories can be more than 2Gb in length, however, in + * practice this seems unlikely. So, we define the type doff_t as a 32-bit + * quantity to keep down the cost of doing lookup on a 32-bit machine. + */ +#define doff_t int32_t +#define MAXDIRSIZE (0x7fffffff) + +/* * A directory consists of some number of blocks of DIRBLKSIZ * bytes, where DIRBLKSIZ is chosen such that it can be transferred * to disk in a single atomic operation (e.g. 512 bytes on most machines). @@ -70,11 +78,11 @@ #define MAXNAMLEN 255 struct direct { - u_long d_ino; /* inode number of entry */ - u_short d_reclen; /* length of this record */ - u_char d_type; /* file type, see below */ - u_char d_namlen; /* length of string in d_name */ - char d_name[MAXNAMLEN + 1]; /* name with length <= MAXNAMLEN */ + u_int32_t d_ino; /* inode number of entry */ + u_int16_t d_reclen; /* length of this record */ + u_int8_t d_type; /* file type, see below */ + u_int8_t d_namlen; /* length of string in d_name */ + char d_name[MAXNAMLEN + 1];/* name with length <= MAXNAMLEN */ }; /* @@ -88,6 +96,7 @@ struct direct { #define DT_REG 8 #define DT_LNK 10 #define DT_SOCK 12 +#define DT_WHT 14 /* * Convert between stat structure types and directory types. @@ -104,44 +113,43 @@ struct direct { #if (BYTE_ORDER == LITTLE_ENDIAN) #define DIRSIZ(oldfmt, dp) \ ((oldfmt) ? \ - ((sizeof (struct direct) - (MAXNAMLEN+1)) + (((dp)->d_type+1 + 3) &~ 3)) : \ - ((sizeof (struct direct) - (MAXNAMLEN+1)) + (((dp)->d_namlen+1 + 3) &~ 3))) + ((sizeof(struct direct) - (MAXNAMLEN+1)) + (((dp)->d_type+1 + 3) &~ 3)) : \ + ((sizeof(struct direct) - (MAXNAMLEN+1)) + (((dp)->d_namlen+1 + 3) &~ 3))) #else #define DIRSIZ(oldfmt, dp) \ - ((sizeof (struct direct) - (MAXNAMLEN+1)) + (((dp)->d_namlen+1 + 3) &~ 3)) + ((sizeof(struct direct) - (MAXNAMLEN+1)) + (((dp)->d_namlen+1 + 3) &~ 3)) #endif #define OLDDIRFMT 1 #define NEWDIRFMT 0 /* - * Template for manipulating directories. - * Should use struct direct's, but the name field - * is MAXNAMLEN - 1, and this just won't do. + * Template for manipulating directories. Should use struct direct's, + * but the name field is MAXNAMLEN - 1, and this just won't do. */ struct dirtemplate { - u_long dot_ino; - short dot_reclen; - u_char dot_type; - u_char dot_namlen; - char dot_name[4]; /* must be multiple of 4 */ - u_long dotdot_ino; - short dotdot_reclen; - u_char dotdot_type; - u_char dotdot_namlen; - char dotdot_name[4]; /* ditto */ + u_int32_t dot_ino; + int16_t dot_reclen; + u_int8_t dot_type; + u_int8_t dot_namlen; + char dot_name[4]; /* must be multiple of 4 */ + u_int32_t dotdot_ino; + int16_t dotdot_reclen; + u_int8_t dotdot_type; + u_int8_t dotdot_namlen; + char dotdot_name[4]; /* ditto */ }; /* * This is the old format of directories, sanz type element. */ struct odirtemplate { - u_long dot_ino; - short dot_reclen; - u_short dot_namlen; - char dot_name[4]; /* must be multiple of 4 */ - u_long dotdot_ino; - short dotdot_reclen; - u_short dotdot_namlen; - char dotdot_name[4]; /* ditto */ + u_int32_t dot_ino; + int16_t dot_reclen; + u_int16_t dot_namlen; + char dot_name[4]; /* must be multiple of 4 */ + u_int32_t dotdot_ino; + int16_t dotdot_reclen; + u_int16_t dotdot_namlen; + char dotdot_name[4]; /* ditto */ }; #endif /* !_DIR_H_ */ diff --git a/sys/ufs/ufs/inode.h b/sys/ufs/ufs/inode.h index df15596..96378fd 100644 --- a/sys/ufs/ufs/inode.h +++ b/sys/ufs/ufs/inode.h @@ -35,59 +35,49 @@ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. * - * @(#)inode.h 8.4 (Berkeley) 1/21/94 + * @(#)inode.h 8.9 (Berkeley) 5/14/95 */ +#include <ufs/ufs/dir.h> #include <ufs/ufs/dinode.h> /* - * Theoretically, directories can be more than 2Gb in length, however, in - * practice this seems unlikely. So, we define the type doff_t as a long - * to keep down the cost of doing lookup on a 32-bit machine. If you are - * porting to a 64-bit architecture, you should make doff_t the same as off_t. - */ -#define doff_t long - -/* - * The inode is used to describe each active (or recently active) - * file in the UFS filesystem. It is composed of two types of - * information. The first part is the information that is needed - * only while the file is active (such as the identity of the file - * and linkage to speed its lookup). The second part is the - * permannent meta-data associated with the file which is read - * in from the permanent dinode from long term storage when the - * file becomes active, and is put back when the file is no longer - * being used. + * The inode is used to describe each active (or recently active) file in the + * UFS filesystem. It is composed of two types of information. The first part + * is the information that is needed only while the file is active (such as + * the identity of the file and linkage to speed its lookup). The second part + * is * the permanent meta-data associated with the file which is read in + * from the permanent dinode from long term storage when the file becomes + * active, and is put back when the file is no longer being used. */ struct inode { - struct inode *i_next; /* Hash chain forward. */ - struct inode **i_prev; /* Hash chain back. */ - struct vnode *i_vnode; /* Vnode associated with this inode. */ - struct vnode *i_devvp; /* Vnode for block I/O. */ - u_long i_flag; /* I* flags. */ - dev_t i_dev; /* Device associated with the inode. */ - ino_t i_number; /* The identity of the inode. */ + LIST_ENTRY(inode) i_hash;/* Hash chain. */ + struct vnode *i_vnode;/* Vnode associated with this inode. */ + struct vnode *i_devvp;/* Vnode for block I/O. */ + u_int32_t i_flag; /* flags, see below */ + dev_t i_dev; /* Device associated with the inode. */ + ino_t i_number; /* The identity of the inode. */ + union { /* Associated filesystem. */ struct fs *fs; /* FFS */ struct lfs *lfs; /* LFS */ } inode_u; #define i_fs inode_u.fs #define i_lfs inode_u.lfs - struct dquot *i_dquot[MAXQUOTAS]; /* Dquot structures. */ - u_quad_t i_modrev; /* Revision level for lease. */ - struct lockf *i_lockf; /* Head of byte-level lock list. */ - pid_t i_lockholder; /* DEBUG: holder of inode lock. */ - pid_t i_lockwaiter; /* DEBUG: latest blocked for inode lock. */ + + struct dquot *i_dquot[MAXQUOTAS]; /* Dquot structures. */ + u_quad_t i_modrev; /* Revision level for NFS lease. */ + struct lockf *i_lockf;/* Head of byte-level lock list. */ + struct lock i_lock; /* Inode lock. */ /* * Side effects; used during directory lookup. */ - long i_count; /* Size of free slot in directory. */ - doff_t i_endoff; /* End of useful stuff in directory. */ - doff_t i_diroff; /* Offset in dir, where we found last entry. */ - doff_t i_offset; /* Offset of free space in directory. */ - ino_t i_ino; /* Inode number of found directory. */ - u_long i_reclen; /* Size of found directory entry. */ - long i_spare[11]; /* Spares to round up to 128 bytes. */ + int32_t i_count; /* Size of free slot in directory. */ + doff_t i_endoff; /* End of useful stuff in directory. */ + doff_t i_diroff; /* Offset in dir, where we found last entry. */ + doff_t i_offset; /* Offset of free space in directory. */ + ino_t i_ino; /* Inode number of found directory. */ + u_int32_t i_reclen; /* Size of found directory entry. */ /* * The on-disk dinode itself. */ @@ -95,8 +85,10 @@ struct inode { }; #define i_atime i_din.di_atime +#define i_atimensec i_din.di_atimensec #define i_blocks i_din.di_blocks #define i_ctime i_din.di_ctime +#define i_ctimensec i_din.di_ctimensec #define i_db i_din.di_db #define i_flags i_din.di_flags #define i_gen i_din.di_gen @@ -104,6 +96,7 @@ struct inode { #define i_ib i_din.di_ib #define i_mode i_din.di_mode #define i_mtime i_din.di_mtime +#define i_mtimensec i_din.di_mtimensec #define i_nlink i_din.di_nlink #define i_rdev i_din.di_rdev #define i_shortlink i_din.di_shortlink @@ -113,14 +106,11 @@ struct inode { /* These flags are kept in i_flag. */ #define IN_ACCESS 0x0001 /* Access time update request. */ #define IN_CHANGE 0x0002 /* Inode change time update request. */ -#define IN_EXLOCK 0x0004 /* File has exclusive lock. */ -#define IN_LOCKED 0x0008 /* Inode lock. */ -#define IN_LWAIT 0x0010 /* Process waiting on file lock. */ -#define IN_MODIFIED 0x0020 /* Inode has been modified. */ -#define IN_RENAME 0x0040 /* Inode is being renamed. */ -#define IN_SHLOCK 0x0080 /* File has shared lock. */ -#define IN_UPDATE 0x0100 /* Modification time update request. */ -#define IN_WANTED 0x0200 /* Inode is wanted by a process. */ +#define IN_UPDATE 0x0004 /* Modification time update request. */ +#define IN_MODIFIED 0x0008 /* Inode has been modified. */ +#define IN_RENAME 0x0010 /* Inode is being renamed. */ +#define IN_SHLOCK 0x0020 /* File has shared lock. */ +#define IN_EXLOCK 0x0040 /* File has exclusive lock. */ #ifdef KERNEL /* @@ -128,7 +118,7 @@ struct inode { * ufs_getlbns and used by truncate and bmap code. */ struct indir { - daddr_t in_lbn; /* Logical block number. */ + ufs_daddr_t in_lbn; /* Logical block number. */ int in_off; /* Offset in buffer. */ int in_exists; /* Flag if the block exists. */ }; @@ -141,22 +131,22 @@ struct indir { if ((ip)->i_flag & (IN_ACCESS | IN_CHANGE | IN_UPDATE)) { \ (ip)->i_flag |= IN_MODIFIED; \ if ((ip)->i_flag & IN_ACCESS) \ - (ip)->i_atime.ts_sec = (t1)->tv_sec; \ + (ip)->i_atime = (t1)->tv_sec; \ if ((ip)->i_flag & IN_UPDATE) { \ - (ip)->i_mtime.ts_sec = (t2)->tv_sec; \ + (ip)->i_mtime = (t2)->tv_sec; \ (ip)->i_modrev++; \ } \ if ((ip)->i_flag & IN_CHANGE) \ - (ip)->i_ctime.ts_sec = time.tv_sec; \ + (ip)->i_ctime = time.tv_sec; \ (ip)->i_flag &= ~(IN_ACCESS | IN_CHANGE | IN_UPDATE); \ } \ } /* This overlays the fid structure (see mount.h). */ struct ufid { - u_short ufid_len; /* Length of structure. */ - u_short ufid_pad; /* Force long alignment. */ - ino_t ufid_ino; /* File number (ino). */ - long ufid_gen; /* Generation number. */ + u_int16_t ufid_len; /* Length of structure. */ + u_int16_t ufid_pad; /* Force 32-bit alignment. */ + ino_t ufid_ino; /* File number (ino). */ + int32_t ufid_gen; /* Generation number. */ }; #endif /* KERNEL */ diff --git a/sys/ufs/ufs/lockf.h b/sys/ufs/ufs/lockf.h index 0ec61db..a70913d 100644 --- a/sys/ufs/ufs/lockf.h +++ b/sys/ufs/ufs/lockf.h @@ -33,7 +33,7 @@ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. * - * @(#)lockf.h 8.1 (Berkeley) 6/11/93 + * @(#)lockf.h 8.2 (Berkeley) 10/26/94 */ /* @@ -42,15 +42,18 @@ * the inode structure. Locks are sorted by the starting byte of the lock for * efficiency. */ +TAILQ_HEAD(locklist, lockf); + struct lockf { - short lf_flags; /* Lock semantics: F_POSIX, F_FLOCK, F_WAIT */ - short lf_type; /* Lock type: F_RDLCK, F_WRLCK */ - off_t lf_start; /* The byte # of the start of the lock */ - off_t lf_end; /* The byte # of the end of the lock (-1=EOF)*/ - caddr_t lf_id; /* The id of the resource holding the lock */ - struct inode *lf_inode; /* Back pointer to the inode */ - struct lockf *lf_next; /* A pointer to the next lock on this inode */ - struct lockf *lf_block; /* The list of blocked locks */ + short lf_flags; /* Semantics: F_POSIX, F_FLOCK, F_WAIT */ + short lf_type; /* Lock type: F_RDLCK, F_WRLCK */ + off_t lf_start; /* Byte # of the start of the lock */ + off_t lf_end; /* Byte # of the end of the lock (-1=EOF) */ + caddr_t lf_id; /* Id of the resource holding the lock */ + struct inode *lf_inode; /* Back pointer to the inode */ + struct lockf *lf_next; /* Pointer to the next lock on this inode */ + struct locklist lf_blkhd; /* List of requests blocked on this lock */ + TAILQ_ENTRY(lockf) lf_block;/* A request waiting for a lock */ }; /* Maximum length of sleep chains to traverse to try and detect deadlock. */ diff --git a/sys/ufs/ufs/quota.h b/sys/ufs/ufs/quota.h index 11efb40..12f2b8b 100644 --- a/sys/ufs/ufs/quota.h +++ b/sys/ufs/ufs/quota.h @@ -33,7 +33,7 @@ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. * - * @(#)quota.h 8.1 (Berkeley) 6/11/93 + * @(#)quota.h 8.3 (Berkeley) 8/19/94 */ #ifndef _QUOTA_ @@ -48,8 +48,8 @@ * failure). The timer is started when the user crosses their soft limit, it * is reset when they go below their soft limit. */ -#define MAX_IQ_TIME (7*24*60*60) /* 1 week */ -#define MAX_DQ_TIME (7*24*60*60) /* 1 week */ +#define MAX_IQ_TIME (7*24*60*60) /* seconds in 1 week */ +#define MAX_DQ_TIME (7*24*60*60) /* seconds in 1 week */ /* * The following constants define the usage of the quota file array in the @@ -96,15 +96,15 @@ * the vnode for each quota file (a pointer is retained in the ufsmount * structure). */ -struct dqblk { - u_long dqb_bhardlimit; /* absolute limit on disk blks alloc */ - u_long dqb_bsoftlimit; /* preferred limit on disk blks */ - u_long dqb_curblocks; /* current block count */ - u_long dqb_ihardlimit; /* maximum # allocated inodes + 1 */ - u_long dqb_isoftlimit; /* preferred inode limit */ - u_long dqb_curinodes; /* current # allocated inodes */ - time_t dqb_btime; /* time limit for excessive disk use */ - time_t dqb_itime; /* time limit for excessive files */ +struct dqblk { + u_int32_t dqb_bhardlimit; /* absolute limit on disk blks alloc */ + u_int32_t dqb_bsoftlimit; /* preferred limit on disk blks */ + u_int32_t dqb_curblocks; /* current block count */ + u_int32_t dqb_ihardlimit; /* maximum # allocated inodes + 1 */ + u_int32_t dqb_isoftlimit; /* preferred inode limit */ + u_int32_t dqb_curinodes; /* current # allocated inodes */ + time_t dqb_btime; /* time limit for excessive disk use */ + time_t dqb_itime; /* time limit for excessive files */ }; /* @@ -113,14 +113,14 @@ struct dqblk { * filesystem for the current user or group. A cache is kept of recently * used entries. */ -struct dquot { - struct dquot *dq_forw, **dq_back; /* hash list */ - struct dquot *dq_freef, **dq_freeb; /* free list */ - short dq_flags; /* flags, see below */ - short dq_cnt; /* count of active references */ - short dq_spare; /* unused spare padding */ - short dq_type; /* quota type of this dquot */ - u_long dq_id; /* identifier this applies to */ +struct dquot { + LIST_ENTRY(dquot) dq_hash; /* hash list */ + TAILQ_ENTRY(dquot) dq_freelist; /* free list */ + u_int16_t dq_flags; /* flags, see below */ + u_int16_t dq_cnt; /* count of active references */ + u_int16_t dq_spare; /* unused spare padding */ + u_int16_t dq_type; /* quota type of this dquot */ + u_int32_t dq_id; /* identifier this applies to */ struct ufsmount *dq_ump; /* filesystem that this is taken from */ struct dqblk dq_dqb; /* actual usage & quotas */ }; @@ -146,11 +146,11 @@ struct dquot { #define dq_itime dq_dqb.dqb_itime /* - * If the system has never checked for a quota for this file, then it is set - * to NODQUOT. Once a write attempt is made the inode pointer is set to - * reference a dquot structure. + * If the system has never checked for a quota for this file, then it is + * set to NODQUOT. Once a write attempt is made the inode pointer is set + * to reference a dquot structure. */ -#define NODQUOT ((struct dquot *) 0) +#define NODQUOT NULL /* * Flags to chkdq() and chkiq() diff --git a/sys/ufs/ufs/ufs_bmap.c b/sys/ufs/ufs/ufs_bmap.c index bcd838d..eb28996 100644 --- a/sys/ufs/ufs/ufs_bmap.c +++ b/sys/ufs/ufs/ufs_bmap.c @@ -35,7 +35,7 @@ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. * - * @(#)ufs_bmap.c 8.6 (Berkeley) 1/21/94 + * @(#)ufs_bmap.c 8.7 (Berkeley) 3/21/95 */ #include <sys/param.h> @@ -62,9 +62,9 @@ int ufs_bmap(ap) struct vop_bmap_args /* { struct vnode *a_vp; - daddr_t a_bn; + ufs_daddr_t a_bn; struct vnode **a_vpp; - daddr_t *a_bnp; + ufs_daddr_t *a_bnp; int *a_runp; } */ *ap; { @@ -98,8 +98,8 @@ ufs_bmap(ap) int ufs_bmaparray(vp, bn, bnp, ap, nump, runp) struct vnode *vp; - register daddr_t bn; - daddr_t *bnp; + ufs_daddr_t bn; + ufs_daddr_t *bnp; struct indir *ap; int *nump; int *runp; @@ -110,7 +110,7 @@ ufs_bmaparray(vp, bn, bnp, ap, nump, runp) struct mount *mp; struct vnode *devvp; struct indir a[NIADDR], *xap; - daddr_t daddr; + ufs_daddr_t daddr; long metalbn; int error, maxrun, num; @@ -194,12 +194,13 @@ ufs_bmaparray(vp, bn, bnp, ap, nump, runp) } } - daddr = ((daddr_t *)bp->b_data)[xap->in_off]; + daddr = ((ufs_daddr_t *)bp->b_data)[xap->in_off]; if (num == 1 && daddr && runp) for (bn = xap->in_off + 1; bn < MNINDIR(ump) && *runp < maxrun && - is_sequential(ump, ((daddr_t *)bp->b_data)[bn - 1], - ((daddr_t *)bp->b_data)[bn]); + is_sequential(ump, + ((ufs_daddr_t *)bp->b_data)[bn - 1], + ((ufs_daddr_t *)bp->b_data)[bn]); ++bn, ++*runp); } if (bp) @@ -222,7 +223,7 @@ ufs_bmaparray(vp, bn, bnp, ap, nump, runp) int ufs_getlbns(vp, bn, ap, nump) struct vnode *vp; - register daddr_t bn; + ufs_daddr_t bn; struct indir *ap; int *nump; { diff --git a/sys/ufs/ufs/ufs_extern.h b/sys/ufs/ufs/ufs_extern.h index e25923e..9cd79aa 100644 --- a/sys/ufs/ufs/ufs_extern.h +++ b/sys/ufs/ufs/ufs_extern.h @@ -30,7 +30,7 @@ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. * - * @(#)ufs_extern.h 8.3 (Berkeley) 4/16/94 + * @(#)ufs_extern.h 8.10 (Berkeley) 5/14/95 */ struct buf; @@ -44,10 +44,11 @@ struct mount; struct nameidata; struct proc; struct ucred; +struct ufs_args; struct uio; struct vattr; +struct vfsconf; struct vnode; -struct ufs_args; __BEGIN_DECLS void diskerr @@ -75,7 +76,7 @@ int ufs_dirremove __P((struct vnode *, struct componentname*)); int ufs_dirrewrite __P((struct inode *, struct inode *, struct componentname *)); int ufs_getattr __P((struct vop_getattr_args *)); -int ufs_getlbns __P((struct vnode *, daddr_t, struct indir *, int *)); +int ufs_getlbns __P((struct vnode *, ufs_daddr_t, struct indir *, int *)); struct vnode * ufs_ihashget __P((dev_t, ino_t)); void ufs_ihashinit __P((void)); @@ -84,9 +85,15 @@ struct vnode * ufs_ihashlookup __P((dev_t, ino_t)); void ufs_ihashrem __P((struct inode *)); int ufs_inactive __P((struct vop_inactive_args *)); -int ufs_init __P((void)); +int ufs_init __P((struct vfsconf *)); int ufs_ioctl __P((struct vop_ioctl_args *)); int ufs_islocked __P((struct vop_islocked_args *)); +#ifdef NFS +int lease_check __P((struct vop_lease_args *)); +#define ufs_lease_check lease_check +#else +#define ufs_lease_check ((int (*) __P((struct vop_lease_args *)))nullop) +#endif int ufs_link __P((struct vop_link_args *)); int ufs_lock __P((struct vop_lock_args *)); int ufs_lookup __P((struct vop_lookup_args *)); @@ -99,9 +106,10 @@ int ufs_pathconf __P((struct vop_pathconf_args *)); int ufs_print __P((struct vop_print_args *)); int ufs_readdir __P((struct vop_readdir_args *)); int ufs_readlink __P((struct vop_readlink_args *)); -int ufs_reclaim __P((struct vop_reclaim_args *)); +int ufs_reclaim __P((struct vnode *, struct proc *)); int ufs_remove __P((struct vop_remove_args *)); int ufs_rename __P((struct vop_rename_args *)); +#define ufs_revoke vop_revoke int ufs_rmdir __P((struct vop_rmdir_args *)); int ufs_root __P((struct mount *, struct vnode **)); int ufs_seek __P((struct vop_seek_args *)); @@ -111,6 +119,7 @@ int ufs_start __P((struct mount *, int, struct proc *)); int ufs_strategy __P((struct vop_strategy_args *)); int ufs_symlink __P((struct vop_symlink_args *)); int ufs_unlock __P((struct vop_unlock_args *)); +int ufs_whiteout __P((struct vop_whiteout_args *)); int ufs_vinit __P((struct mount *, int (**)(), int (**)(), struct vnode **)); int ufsspec_close __P((struct vop_close_args *)); diff --git a/sys/ufs/ufs/ufs_ihash.c b/sys/ufs/ufs/ufs_ihash.c index 4a37c90..1d14d7a 100644 --- a/sys/ufs/ufs/ufs_ihash.c +++ b/sys/ufs/ufs/ufs_ihash.c @@ -1,5 +1,5 @@ /* - * Copyright (c) 1982, 1986, 1989, 1991, 1993 + * Copyright (c) 1982, 1986, 1989, 1991, 1993, 1995 * The Regents of the University of California. All rights reserved. * * Redistribution and use in source and binary forms, with or without @@ -30,7 +30,7 @@ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. * - * @(#)ufs_ihash.c 8.4 (Berkeley) 12/30/93 + * @(#)ufs_ihash.c 8.7 (Berkeley) 5/17/95 */ #include <sys/param.h> @@ -46,9 +46,10 @@ /* * Structures associated with inode cacheing. */ -struct inode **ihashtbl; +LIST_HEAD(ihashhead, inode) *ihashtbl; u_long ihash; /* size of hash table - 1 */ -#define INOHASH(device, inum) (((device) + (inum)) & ihash) +#define INOHASH(device, inum) (&ihashtbl[((device) + (inum)) & ihash]) +struct simplelock ufs_ihash_slock; /* * Initialize inode hash table. @@ -58,6 +59,7 @@ ufs_ihashinit() { ihashtbl = hashinit(desiredvnodes, M_UFSMNT, &ihash); + simple_lock_init(&ufs_ihash_slock); } /* @@ -65,19 +67,21 @@ ufs_ihashinit() * to it. If it is in core, return it, even if it is locked. */ struct vnode * -ufs_ihashlookup(device, inum) - dev_t device; +ufs_ihashlookup(dev, inum) + dev_t dev; ino_t inum; { - register struct inode *ip; + struct inode *ip; - for (ip = ihashtbl[INOHASH(device, inum)];; ip = ip->i_next) { - if (ip == NULL) - return (NULL); - if (inum == ip->i_number && device == ip->i_dev) - return (ITOV(ip)); - } - /* NOTREACHED */ + simple_lock(&ufs_ihash_slock); + for (ip = INOHASH(dev, inum)->lh_first; ip; ip = ip->i_hash.le_next) + if (inum == ip->i_number && dev == ip->i_dev) + break; + simple_unlock(&ufs_ihash_slock); + + if (ip) + return (ITOV(ip)); + return (NULLVP); } /* @@ -85,54 +89,47 @@ ufs_ihashlookup(device, inum) * to it. If it is in core, but locked, wait for it. */ struct vnode * -ufs_ihashget(device, inum) - dev_t device; +ufs_ihashget(dev, inum) + dev_t dev; ino_t inum; { - register struct inode *ip; + struct proc *p = curproc; /* XXX */ + struct inode *ip; struct vnode *vp; - for (;;) - for (ip = ihashtbl[INOHASH(device, inum)];; ip = ip->i_next) { - if (ip == NULL) - return (NULL); - if (inum == ip->i_number && device == ip->i_dev) { - if (ip->i_flag & IN_LOCKED) { - ip->i_flag |= IN_WANTED; - sleep(ip, PINOD); - break; - } - vp = ITOV(ip); - if (!vget(vp, 1)) - return (vp); - break; - } +loop: + simple_lock(&ufs_ihash_slock); + for (ip = INOHASH(dev, inum)->lh_first; ip; ip = ip->i_hash.le_next) { + if (inum == ip->i_number && dev == ip->i_dev) { + vp = ITOV(ip); + simple_lock(&vp->v_interlock); + simple_unlock(&ufs_ihash_slock); + if (vget(vp, LK_EXCLUSIVE | LK_INTERLOCK, p)) + goto loop; + return (vp); } - /* NOTREACHED */ + } + simple_unlock(&ufs_ihash_slock); + return (NULL); } /* - * Insert the inode into the hash table, and return it locked. +* Insert the inode into the hash table, and return it locked. */ void ufs_ihashins(ip) struct inode *ip; { - struct inode **ipp, *iq; + struct proc *p = curproc; /* XXX */ + struct ihashhead *ipp; + + /* lock the inode, then put it on the appropriate hash list */ + lockmgr(&ip->i_lock, LK_EXCLUSIVE, (struct simplelock *)0, p); - ipp = &ihashtbl[INOHASH(ip->i_dev, ip->i_number)]; - if (iq = *ipp) - iq->i_prev = &ip->i_next; - ip->i_next = iq; - ip->i_prev = ipp; - *ipp = ip; - if (ip->i_flag & IN_LOCKED) - panic("ufs_ihashins: already locked"); - if (curproc) - ip->i_lockholder = curproc->p_pid; - else - ip->i_lockholder = -1; - ip->i_flag |= IN_LOCKED; + simple_lock(&ufs_ihash_slock); + ipp = INOHASH(ip->i_dev, ip->i_number); + LIST_INSERT_HEAD(ipp, ip, i_hash); + simple_unlock(&ufs_ihash_slock); } /* @@ -140,15 +137,15 @@ ufs_ihashins(ip) */ void ufs_ihashrem(ip) - register struct inode *ip; + struct inode *ip; { - register struct inode *iq; + struct inode *iq; - if (iq = ip->i_next) - iq->i_prev = ip->i_prev; - *ip->i_prev = iq; + simple_lock(&ufs_ihash_slock); + LIST_REMOVE(ip, i_hash); #ifdef DIAGNOSTIC - ip->i_next = NULL; - ip->i_prev = NULL; + ip->i_hash.le_next = NULL; + ip->i_hash.le_prev = NULL; #endif + simple_unlock(&ufs_ihash_slock); } diff --git a/sys/ufs/ufs/ufs_inode.c b/sys/ufs/ufs/ufs_inode.c index ac876f9..4519ee2 100644 --- a/sys/ufs/ufs/ufs_inode.c +++ b/sys/ufs/ufs/ufs_inode.c @@ -1,5 +1,5 @@ /* - * Copyright (c) 1991, 1993 + * Copyright (c) 1991, 1993, 1995 * The Regents of the University of California. All rights reserved. * (c) UNIX System Laboratories, Inc. * All or some portions of this file are derived from material licensed @@ -35,7 +35,7 @@ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. * - * @(#)ufs_inode.c 8.4 (Berkeley) 1/21/94 + * @(#)ufs_inode.c 8.9 (Berkeley) 5/14/95 */ #include <sys/param.h> @@ -54,24 +54,6 @@ u_long nextgennumber; /* Next generation number to assign. */ int prtactive = 0; /* 1 => print out reclaim of active vnodes */ -int -ufs_init() -{ - static int first = 1; - - if (!first) - return (0); - first = 0; - -#ifdef DIAGNOSTIC - if ((sizeof(struct inode) - 1) & sizeof(struct inode)) - printf("ufs_init: bad size %d\n", sizeof(struct inode)); -#endif - ufs_ihashinit(); - dqinit(); - return (0); -} - /* * Last reference to an inode. If necessary, write or delete it. */ @@ -79,40 +61,30 @@ int ufs_inactive(ap) struct vop_inactive_args /* { struct vnode *a_vp; + struct proc *a_p; } */ *ap; { - register struct vnode *vp = ap->a_vp; - register struct inode *ip = VTOI(vp); + struct vnode *vp = ap->a_vp; + struct inode *ip = VTOI(vp); + struct proc *p = ap->a_p; struct timeval tv; - int mode, error; + int mode, error = 0; extern int prtactive; if (prtactive && vp->v_usecount != 0) vprint("ffs_inactive: pushing active", vp); - /* Get rid of inodes related to stale file handles. */ - if (ip->i_mode == 0) { - if ((vp->v_flag & VXLOCK) == 0) - vgone(vp); - return (0); - } - - error = 0; -#ifdef DIAGNOSTIC - if (VOP_ISLOCKED(vp)) - panic("ffs_inactive: locked inode"); - if (curproc) - ip->i_lockholder = curproc->p_pid; - else - ip->i_lockholder = -1; -#endif - ip->i_flag |= IN_LOCKED; + /* + * Ignore inodes related to stale file handles. + */ + if (ip->i_mode == 0) + goto out; if (ip->i_nlink <= 0 && (vp->v_mount->mnt_flag & MNT_RDONLY) == 0) { #ifdef QUOTA if (!getinoquota(ip)) (void)chkiq(ip, -1, NOCRED, 0); #endif - error = VOP_TRUNCATE(vp, (off_t)0, 0, NOCRED, NULL); + error = VOP_TRUNCATE(vp, (off_t)0, 0, NOCRED, p); ip->i_rdev = 0; mode = ip->i_mode; ip->i_mode = 0; @@ -123,13 +95,14 @@ ufs_inactive(ap) tv = time; VOP_UPDATE(vp, &tv, &tv, 0); } - VOP_UNLOCK(vp); +out: + VOP_UNLOCK(vp, 0, p); /* * If we are done with the inode, reclaim it * so that it can be reused immediately. */ - if (vp->v_usecount == 0 && ip->i_mode == 0) - vgone(vp); + if (ip->i_mode == 0) + vrecycle(vp, (struct simplelock *)0, p); return (error); } @@ -137,14 +110,13 @@ ufs_inactive(ap) * Reclaim an inode so that it can be used for other purposes. */ int -ufs_reclaim(ap) - struct vop_reclaim_args /* { - struct vnode *a_vp; - } */ *ap; +ufs_reclaim(vp, p) + struct vnode *vp; + struct proc *p; { - register struct vnode *vp = ap->a_vp; register struct inode *ip; - int i, type; + int i; + extern int prtactive; if (prtactive && vp->v_usecount != 0) vprint("ufs_reclaim: pushing active", vp); @@ -169,20 +141,5 @@ ufs_reclaim(ap) } } #endif - switch (vp->v_mount->mnt_stat.f_type) { - case MOUNT_UFS: - type = M_FFSNODE; - break; - case MOUNT_MFS: - type = M_MFSNODE; - break; - case MOUNT_LFS: - type = M_LFSNODE; - break; - default: - panic("ufs_reclaim: not ufs file"); - } - FREE(vp->v_data, type); - vp->v_data = NULL; return (0); } diff --git a/sys/ufs/ufs/ufs_lockf.c b/sys/ufs/ufs/ufs_lockf.c index cb9a737..e2a93c8 100644 --- a/sys/ufs/ufs/ufs_lockf.c +++ b/sys/ufs/ufs/ufs_lockf.c @@ -33,7 +33,7 @@ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. * - * @(#)ufs_lockf.c 8.3 (Berkeley) 1/6/94 + * @(#)ufs_lockf.c 8.4 (Berkeley) 10/26/94 */ #include <sys/param.h> @@ -57,7 +57,10 @@ int maxlockdepth = MAXDEPTH; #ifdef LOCKF_DEBUG +#include <vm/vm.h> +#include <sys/sysctl.h> int lockf_debug = 0; +struct ctldebug debug4 = { "lockf_debug", &lockf_debug }; #endif #define NOLOCKF (struct lockf *)0 @@ -149,7 +152,7 @@ lf_setlock(lock) * Remember who blocked us (for deadlock detection). */ lock->lf_next = block; - lf_addblock(block, lock); + TAILQ_INSERT_TAIL(&block->lf_blkhd, lock, lf_block); #ifdef LOCKF_DEBUG if (lockf_debug & 1) { lf_print("lf_setlock: blocking on", block); @@ -158,23 +161,16 @@ lf_setlock(lock) #endif /* LOCKF_DEBUG */ if (error = tsleep((caddr_t)lock, priority, lockstr, 0)) { /* - * Delete ourselves from the waiting to lock list. + * We may have been awakened by a signal (in + * which case we must remove ourselves from the + * blocked list) and/or by another process + * releasing a lock (in which case we have already + * been removed from the blocked list and our + * lf_next field set to NOLOCKF). */ - for (block = lock->lf_next; - block != NOLOCKF; - block = block->lf_block) { - if (block->lf_block != lock) - continue; - block->lf_block = block->lf_block->lf_block; - break; - } - /* - * If we did not find ourselves on the list, but - * are still linked onto a lock list, then something - * is very wrong. - */ - if (block == NOLOCKF && lock->lf_next != NOLOCKF) - panic("lf_setlock: lost lock"); + if (lock->lf_next) + TAILQ_REMOVE(&lock->lf_next->lf_blkhd, lock, + lf_block); free(lock, M_LOCKF); return (error); } @@ -250,9 +246,12 @@ lf_setlock(lock) overlap->lf_type == F_WRLCK) { lf_wakelock(overlap); } else { - ltmp = lock->lf_block; - lock->lf_block = overlap->lf_block; - lf_addblock(lock, ltmp); + while (ltmp = overlap->lf_blkhd.tqh_first) { + TAILQ_REMOVE(&overlap->lf_blkhd, ltmp, + lf_block); + TAILQ_INSERT_TAIL(&lock->lf_blkhd, + ltmp, lf_block); + } } /* * Add the new lock if necessary and delete the overlap. @@ -548,34 +547,6 @@ lf_findoverlap(lf, lock, type, prev, overlap) } /* - * Add a lock to the end of the blocked list. - */ -void -lf_addblock(lock, blocked) - struct lockf *lock; - struct lockf *blocked; -{ - register struct lockf *lf; - - if (blocked == NOLOCKF) - return; -#ifdef LOCKF_DEBUG - if (lockf_debug & 2) { - lf_print("addblock: adding", blocked); - lf_print("to blocked list of", lock); - } -#endif /* LOCKF_DEBUG */ - if ((lf = lock->lf_block) == NOLOCKF) { - lock->lf_block = blocked; - return; - } - while (lf->lf_block != NOLOCKF) - lf = lf->lf_block; - lf->lf_block = blocked; - return; -} - -/* * Split a lock and a contained region into * two or three locks as necessary. */ @@ -613,7 +584,7 @@ lf_split(lock1, lock2) MALLOC(splitlock, struct lockf *, sizeof *splitlock, M_LOCKF, M_WAITOK); bcopy((caddr_t)lock1, (caddr_t)splitlock, sizeof *splitlock); splitlock->lf_start = lock2->lf_end + 1; - splitlock->lf_block = NOLOCKF; + TAILQ_INIT(&splitlock->lf_blkhd); lock1->lf_end = lock2->lf_start - 1; /* * OK, now link it in @@ -630,28 +601,23 @@ void lf_wakelock(listhead) struct lockf *listhead; { - register struct lockf *blocklist, *wakelock; - - blocklist = listhead->lf_block; - listhead->lf_block = NOLOCKF; - while (blocklist != NOLOCKF) { - wakelock = blocklist; - blocklist = blocklist->lf_block; - wakelock->lf_block = NOLOCKF; + register struct lockf *wakelock; + + while (wakelock = listhead->lf_blkhd.tqh_first) { + TAILQ_REMOVE(&listhead->lf_blkhd, wakelock, lf_block); wakelock->lf_next = NOLOCKF; #ifdef LOCKF_DEBUG if (lockf_debug & 2) lf_print("lf_wakelock: awakening", wakelock); #endif /* LOCKF_DEBUG */ - wakeup((caddr_t)wakelock); - } + wakeup((caddr_t)wakelock); + } } #ifdef LOCKF_DEBUG /* * Print out a lock. */ -void lf_print(tag, lock) char *tag; register struct lockf *lock; @@ -670,18 +636,17 @@ lf_print(tag, lock) lock->lf_type == F_WRLCK ? "exclusive" : lock->lf_type == F_UNLCK ? "unlock" : "unknown", lock->lf_start, lock->lf_end); - if (lock->lf_block) - printf(" block 0x%x\n", lock->lf_block); + if (lock->lf_blkhd.tqh_first) + printf(" block 0x%x\n", lock->lf_blkhd.tqh_first); else printf("\n"); } -void lf_printlist(tag, lock) char *tag; struct lockf *lock; { - register struct lockf *lf; + register struct lockf *lf, *blk; printf("%s: Lock list for ino %d on dev <%d, %d>:\n", tag, lock->lf_inode->i_number, @@ -698,10 +663,23 @@ lf_printlist(tag, lock) lf->lf_type == F_WRLCK ? "exclusive" : lf->lf_type == F_UNLCK ? "unlock" : "unknown", lf->lf_start, lf->lf_end); - if (lf->lf_block) - printf(" block 0x%x\n", lf->lf_block); - else - printf("\n"); + for (blk = lf->lf_blkhd.tqh_first; blk; + blk = blk->lf_block.tqe_next) { + printf("\n\t\tlock request 0x%lx for ", blk); + if (blk->lf_flags & F_POSIX) + printf("proc %d", + ((struct proc *)(blk->lf_id))->p_pid); + else + printf("id 0x%x", blk->lf_id); + printf(", %s, start %d, end %d", + blk->lf_type == F_RDLCK ? "shared" : + blk->lf_type == F_WRLCK ? "exclusive" : + blk->lf_type == F_UNLCK ? "unlock" : + "unknown", blk->lf_start, blk->lf_end); + if (blk->lf_blkhd.tqh_first) + panic("lf_printlist: bad list"); + } + printf("\n"); } } #endif /* LOCKF_DEBUG */ diff --git a/sys/ufs/ufs/ufs_lookup.c b/sys/ufs/ufs/ufs_lookup.c index 87c6802..25afa1c 100644 --- a/sys/ufs/ufs/ufs_lookup.c +++ b/sys/ufs/ufs/ufs_lookup.c @@ -35,7 +35,7 @@ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. * - * @(#)ufs_lookup.c 8.6 (Berkeley) 4/1/94 + * @(#)ufs_lookup.c 8.15 (Berkeley) 6/16/95 */ #include <sys/param.h> @@ -126,6 +126,7 @@ ufs_lookup(ap) struct ucred *cred = cnp->cn_cred; int flags = cnp->cn_flags; int nameiop = cnp->cn_nameiop; + struct proc *p = cnp->cn_proc; bp = NULL; slotoffset = -1; @@ -142,6 +143,9 @@ ufs_lookup(ap) return (ENOTDIR); if (error = VOP_ACCESS(vdp, VEXEC, cred, cnp->cn_proc)) return (error); + if ((flags & ISLASTCN) && (vdp->v_mount->mnt_flag & MNT_RDONLY) && + (cnp->cn_nameiop == DELETE || cnp->cn_nameiop == RENAME)) + return (EROFS); /* * We now have a segment name to search for, and a directory to search. @@ -168,14 +172,14 @@ ufs_lookup(ap) VREF(vdp); error = 0; } else if (flags & ISDOTDOT) { - VOP_UNLOCK(pdp); - error = vget(vdp, 1); + VOP_UNLOCK(pdp, 0, p); + error = vget(vdp, LK_EXCLUSIVE, p); if (!error && lockparent && (flags & ISLASTCN)) - error = VOP_LOCK(pdp); + error = vn_lock(pdp, LK_EXCLUSIVE, p); } else { - error = vget(vdp, 1); + error = vget(vdp, LK_EXCLUSIVE, p); if (!lockparent || error || !(flags & ISLASTCN)) - VOP_UNLOCK(pdp); + VOP_UNLOCK(pdp, 0, p); } /* * Check that the capability number did not change @@ -186,9 +190,9 @@ ufs_lookup(ap) return (0); vput(vdp); if (lockparent && pdp != vdp && (flags & ISLASTCN)) - VOP_UNLOCK(pdp); + VOP_UNLOCK(pdp, 0, p); } - if (error = VOP_LOCK(pdp)) + if (error = vn_lock(pdp, LK_EXCLUSIVE, p)) return (error); vdp = pdp; dp = VTOI(pdp); @@ -329,6 +333,17 @@ searchloop: * reclen in ndp->ni_ufs area, and release * directory buffer. */ + if (vdp->v_mount->mnt_maxsymlinklen > 0 && + ep->d_type == DT_WHT) { + slotstatus = FOUND; + slotoffset = dp->i_offset; + slotsize = ep->d_reclen; + dp->i_reclen = slotsize; + enduseful = dp->i_size; + ap->a_cnp->cn_flags |= ISWHITEOUT; + numdirpasses--; + goto notfound; + } dp->i_ino = ep->d_ino; dp->i_reclen = ep->d_reclen; brelse(bp); @@ -341,7 +356,7 @@ searchloop: if (ep->d_ino) enduseful = dp->i_offset; } -/* notfound: */ +notfound: /* * If we started in the middle of the directory and failed * to find our target, we must check the beginning as well. @@ -359,7 +374,10 @@ searchloop: * directory has not been removed, then can consider * allowing file to be created. */ - if ((nameiop == CREATE || nameiop == RENAME) && + if ((nameiop == CREATE || nameiop == RENAME || + (nameiop == DELETE && + (ap->a_cnp->cn_flags & DOWHITEOUT) && + (ap->a_cnp->cn_flags & ISWHITEOUT))) && (flags & ISLASTCN) && dp->i_nlink != 0) { /* * Access for write is interpreted as allowing @@ -380,6 +398,12 @@ searchloop: dp->i_offset = roundup(dp->i_size, DIRBLKSIZ); dp->i_count = 0; enduseful = dp->i_offset; + } else if (nameiop == DELETE) { + dp->i_offset = slotoffset; + if ((dp->i_offset & (DIRBLKSIZ - 1)) == 0) + dp->i_count = 0; + else + dp->i_count = dp->i_offset - prevoff; } else { dp->i_offset = slotoffset; dp->i_count = slotsize; @@ -403,7 +427,7 @@ searchloop: */ cnp->cn_flags |= SAVENAME; if (!lockparent) - VOP_UNLOCK(vdp); + VOP_UNLOCK(vdp, 0, p); return (EJUSTRETURN); } /* @@ -473,13 +497,14 @@ found: if ((dp->i_mode & ISVTX) && cred->cr_uid != 0 && cred->cr_uid != dp->i_uid && + tdp->v_type != VLNK && VTOI(tdp)->i_uid != cred->cr_uid) { vput(tdp); return (EPERM); } *vpp = tdp; if (!lockparent) - VOP_UNLOCK(vdp); + VOP_UNLOCK(vdp, 0, p); return (0); } @@ -489,8 +514,7 @@ found: * Must get inode of directory entry to verify it's a * regular file, or empty directory. */ - if (nameiop == RENAME && wantparent && - (flags & ISLASTCN)) { + if (nameiop == RENAME && wantparent && (flags & ISLASTCN)) { if (error = VOP_ACCESS(vdp, VWRITE, cred, cnp->cn_proc)) return (error); /* @@ -504,7 +528,7 @@ found: *vpp = tdp; cnp->cn_flags |= SAVENAME; if (!lockparent) - VOP_UNLOCK(vdp); + VOP_UNLOCK(vdp, 0, p); return (0); } @@ -529,13 +553,13 @@ found: */ pdp = vdp; if (flags & ISDOTDOT) { - VOP_UNLOCK(pdp); /* race to get the inode */ + VOP_UNLOCK(pdp, 0, p); /* race to get the inode */ if (error = VFS_VGET(vdp->v_mount, dp->i_ino, &tdp)) { - VOP_LOCK(pdp); + vn_lock(pdp, LK_EXCLUSIVE | LK_RETRY, p); return (error); } if (lockparent && (flags & ISLASTCN) && - (error = VOP_LOCK(pdp))) { + (error = vn_lock(pdp, LK_EXCLUSIVE, p))) { vput(tdp); return (error); } @@ -547,7 +571,7 @@ found: if (error = VFS_VGET(vdp->v_mount, dp->i_ino, &tdp)) return (error); if (!lockparent || !(flags & ISLASTCN)) - VOP_UNLOCK(pdp); + VOP_UNLOCK(pdp, 0, p); *vpp = tdp; } @@ -606,6 +630,8 @@ ufs_dirbadentry(dp, ep, entryoffsetinblock) printf("First bad\n"); goto bad; } + if (ep->d_ino == 0) + return (0); for (i = 0; i < namlen; i++) if (ep->d_name[i] == '\0') { /*return (1); */ @@ -614,9 +640,9 @@ ufs_dirbadentry(dp, ep, entryoffsetinblock) } if (ep->d_name[i]) goto bad; - return (ep->d_name[i]); + return (0); bad: - return(1); + return (1); } /* @@ -633,15 +659,8 @@ ufs_direnter(ip, dvp, cnp) struct vnode *dvp; register struct componentname *cnp; { - register struct direct *ep, *nep; register struct inode *dp; - struct buf *bp; struct direct newdir; - struct iovec aiov; - struct uio auio; - u_int dsize; - int error, loc, newentrysize, spacefree; - char *dirbuf; #ifdef DIAGNOSTIC if ((cnp->cn_flags & SAVENAME) == 0) @@ -661,7 +680,32 @@ ufs_direnter(ip, dvp, cnp) newdir.d_type = tmp; } # endif } - newentrysize = DIRSIZ(FSFMT(dvp), &newdir); + return (ufs_direnter2(dvp, &newdir, cnp->cn_cred, cnp->cn_proc)); +} + +/* + * Common entry point for directory entry removal used by ufs_direnter + * and ufs_whiteout + */ +ufs_direnter2(dvp, dirp, cr, p) + struct vnode *dvp; + struct direct *dirp; + struct ucred *cr; + struct proc *p; +{ + int newentrysize; + struct inode *dp; + struct buf *bp; + struct iovec aiov; + struct uio auio; + u_int dsize; + struct direct *ep, *nep; + int error, loc, spacefree; + char *dirbuf; + + dp = VTOI(dvp); + newentrysize = DIRSIZ(FSFMT(dvp), dirp); + if (dp->i_count == 0) { /* * If dp->i_count is 0, then namei could find no @@ -670,22 +714,22 @@ ufs_direnter(ip, dvp, cnp) * new entry into a fresh block. */ if (dp->i_offset & (DIRBLKSIZ - 1)) - panic("ufs_direnter: newblk"); + panic("ufs_direnter2: newblk"); auio.uio_offset = dp->i_offset; - newdir.d_reclen = DIRBLKSIZ; + dirp->d_reclen = DIRBLKSIZ; auio.uio_resid = newentrysize; aiov.iov_len = newentrysize; - aiov.iov_base = (caddr_t)&newdir; + aiov.iov_base = (caddr_t)dirp; auio.uio_iov = &aiov; auio.uio_iovcnt = 1; auio.uio_rw = UIO_WRITE; auio.uio_segflg = UIO_SYSSPACE; auio.uio_procp = (struct proc *)0; - error = VOP_WRITE(dvp, &auio, IO_SYNC, cnp->cn_cred); + error = VOP_WRITE(dvp, &auio, IO_SYNC, cr); if (DIRBLKSIZ > VFSTOUFS(dvp->v_mount)->um_mountp->mnt_stat.f_bsize) /* XXX should grow with balloc() */ - panic("ufs_direnter: frag size"); + panic("ufs_direnter2: frag size"); else if (!error) { dp->i_size = roundup(dp->i_size, DIRBLKSIZ); dp->i_flag |= IN_CHANGE; @@ -745,23 +789,24 @@ ufs_direnter(ip, dvp, cnp) * Update the pointer fields in the previous entry (if any), * copy in the new entry, and write out the block. */ - if (ep->d_ino == 0) { + if (ep->d_ino == 0 || + (ep->d_ino == WINO && + bcmp(ep->d_name, dirp->d_name, dirp->d_namlen) == 0)) { if (spacefree + dsize < newentrysize) - panic("ufs_direnter: compact1"); - newdir.d_reclen = spacefree + dsize; + panic("ufs_direnter2: compact1"); + dirp->d_reclen = spacefree + dsize; } else { if (spacefree < newentrysize) - panic("ufs_direnter: compact2"); - newdir.d_reclen = spacefree; + panic("ufs_direnter2: compact2"); + dirp->d_reclen = spacefree; ep->d_reclen = dsize; ep = (struct direct *)((char *)ep + dsize); } - bcopy((caddr_t)&newdir, (caddr_t)ep, (u_int)newentrysize); + bcopy((caddr_t)dirp, (caddr_t)ep, (u_int)newentrysize); error = VOP_BWRITE(bp); dp->i_flag |= IN_CHANGE | IN_UPDATE; if (!error && dp->i_endoff && dp->i_endoff < dp->i_size) - error = VOP_TRUNCATE(dvp, (off_t)dp->i_endoff, IO_SYNC, - cnp->cn_cred, cnp->cn_proc); + error = VOP_TRUNCATE(dvp, (off_t)dp->i_endoff, IO_SYNC, cr, p); return (error); } @@ -788,6 +833,21 @@ ufs_dirremove(dvp, cnp) int error; dp = VTOI(dvp); + + if (cnp->cn_flags & DOWHITEOUT) { + /* + * Whiteout entry: set d_ino to WINO. + */ + if (error = + VOP_BLKATOFF(dvp, (off_t)dp->i_offset, (char **)&ep, &bp)) + return (error); + ep->d_ino = WINO; + ep->d_type = DT_WHT; + error = VOP_BWRITE(bp); + dp->i_flag |= IN_CHANGE | IN_UPDATE; + return (error); + } + if (dp->i_count == 0) { /* * First entry in block: set d_ino to zero. @@ -871,7 +931,7 @@ ufs_dirempty(ip, parentino, cred) if (dp->d_reclen == 0) return (0); /* skip empty entries */ - if (dp->d_ino == 0) + if (dp->d_ino == 0 || dp->d_ino == WINO) continue; /* accept only "." and ".." */ # if (BYTE_ORDER == LITTLE_ENDIAN) diff --git a/sys/ufs/ufs/ufs_quota.c b/sys/ufs/ufs/ufs_quota.c index 15cb1cf..6ba0557 100644 --- a/sys/ufs/ufs/ufs_quota.c +++ b/sys/ufs/ufs/ufs_quota.c @@ -1,5 +1,5 @@ /* - * Copyright (c) 1982, 1986, 1990, 1993 + * Copyright (c) 1982, 1986, 1990, 1993, 1995 * The Regents of the University of California. All rights reserved. * * This code is derived from software contributed to Berkeley by @@ -33,7 +33,7 @@ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. * - * @(#)ufs_quota.c 8.2 (Berkeley) 12/30/93 + * @(#)ufs_quota.c 8.5 (Berkeley) 5/20/95 */ #include <sys/param.h> #include <sys/kernel.h> @@ -361,8 +361,8 @@ quotaon(p, mp, type, fname) register int type; caddr_t fname; { - register struct ufsmount *ump = VFSTOUFS(mp); - register struct vnode *vp, **vpp; + struct ufsmount *ump = VFSTOUFS(mp); + struct vnode *vp, **vpp; struct vnode *nextvp; struct dquot *dq; int error; @@ -373,15 +373,11 @@ quotaon(p, mp, type, fname) if (error = vn_open(&nd, FREAD|FWRITE, 0)) return (error); vp = nd.ni_vp; - VOP_UNLOCK(vp); + VOP_UNLOCK(vp, 0, p); if (vp->v_type != VREG) { (void) vn_close(vp, FREAD|FWRITE, p->p_ucred, p); return (EACCES); } - if (vfs_busy(mp)) { - (void) vn_close(vp, FREAD|FWRITE, p->p_ucred, p); - return (EBUSY); - } if (*vpp != vp) quotaoff(p, mp, type); ump->um_qflags[type] |= QTF_OPENING; @@ -413,7 +409,7 @@ again: nextvp = vp->v_mntvnodes.le_next; if (vp->v_writecount == 0) continue; - if (vget(vp, 1)) + if (vget(vp, LK_EXCLUSIVE, p)) goto again; if (error = getinoquota(VTOI(vp))) { vput(vp); @@ -426,7 +422,6 @@ again: ump->um_qflags[type] &= ~QTF_OPENING; if (error) quotaoff(p, mp, type); - vfs_unbusy(mp); return (error); } @@ -439,15 +434,13 @@ quotaoff(p, mp, type) struct mount *mp; register int type; { - register struct vnode *vp; + struct vnode *vp; struct vnode *qvp, *nextvp; struct ufsmount *ump = VFSTOUFS(mp); - register struct dquot *dq; - register struct inode *ip; + struct dquot *dq; + struct inode *ip; int error; - if ((mp->mnt_flag & MNT_MPBUSY) == 0) - panic("quotaoff: not busy"); if ((qvp = ump->um_quotas[type]) == NULLVP) return (0); ump->um_qflags[type] |= QTF_CLOSING; @@ -458,7 +451,7 @@ quotaoff(p, mp, type) again: for (vp = mp->mnt_vnodelist.lh_first; vp != NULL; vp = nextvp) { nextvp = vp->v_mntvnodes.le_next; - if (vget(vp, 1)) + if (vget(vp, LK_EXCLUSIVE, p)) goto again; ip = VTOI(vp); dq = ip->i_dquot[type]; @@ -616,16 +609,15 @@ qsync(mp) struct mount *mp; { struct ufsmount *ump = VFSTOUFS(mp); - register struct vnode *vp, *nextvp; - register struct dquot *dq; - register int i; + struct proc *p = curproc; /* XXX */ + struct vnode *vp, *nextvp; + struct dquot *dq; + int i, error; /* * Check if the mount point has any quotas. * If not, simply return. */ - if ((mp->mnt_flag & MNT_MPBUSY) == 0) - panic("qsync: not busy"); for (i = 0; i < MAXQUOTAS; i++) if (ump->um_quotas[i] != NULLVP) break; @@ -635,36 +627,48 @@ qsync(mp) * Search vnodes associated with this mount point, * synchronizing any modified dquot structures. */ + simple_lock(&mntvnode_slock); again: for (vp = mp->mnt_vnodelist.lh_first; vp != NULL; vp = nextvp) { + if (vp->v_mount != mp) + goto again; nextvp = vp->v_mntvnodes.le_next; - if (VOP_ISLOCKED(vp)) + simple_lock(&vp->v_interlock); + simple_unlock(&mntvnode_slock); + error = vget(vp, LK_EXCLUSIVE | LK_NOWAIT | LK_INTERLOCK, p); + if (error) { + simple_lock(&mntvnode_slock); + if (error == ENOENT) + goto again; continue; - if (vget(vp, 1)) - goto again; + } for (i = 0; i < MAXQUOTAS; i++) { dq = VTOI(vp)->i_dquot[i]; if (dq != NODQUOT && (dq->dq_flags & DQ_MOD)) dqsync(vp, dq); } vput(vp); - if (vp->v_mntvnodes.le_next != nextvp || vp->v_mount != mp) + simple_lock(&mntvnode_slock); + if (vp->v_mntvnodes.le_next != nextvp) goto again; } + simple_unlock(&mntvnode_slock); return (0); } /* * Code pertaining to management of the in-core dquot data structures. */ -struct dquot **dqhashtbl; +#define DQHASH(dqvp, id) \ + (&dqhashtbl[((((int)(dqvp)) >> 8) + id) & dqhash]) +LIST_HEAD(dqhash, dquot) *dqhashtbl; u_long dqhash; /* * Dquot free list. */ #define DQUOTINC 5 /* minimum free dquots desired */ -struct dquot *dqfreel, **dqback = &dqfreel; +TAILQ_HEAD(dqfreelist, dquot) dqfreelist; long numdquot, desireddquot = DQUOTINC; /* @@ -675,6 +679,7 @@ dqinit() { dqhashtbl = hashinit(desiredvnodes, M_DQUOT, &dqhash); + TAILQ_INIT(&dqfreelist); } /* @@ -689,8 +694,10 @@ dqget(vp, id, ump, type, dqp) register int type; struct dquot **dqp; { - register struct dquot *dq, *dp, **dpp; - register struct vnode *dqvp; + struct proc *p = curproc; /* XXX */ + struct dquot *dq; + struct dqhash *dqh; + struct vnode *dqvp; struct iovec aiov; struct uio auio; int error; @@ -703,8 +710,8 @@ dqget(vp, id, ump, type, dqp) /* * Check the cache first. */ - dpp = &dqhashtbl[((((int)(dqvp)) >> 8) + id) & dqhash]; - for (dq = *dpp; dq; dq = dq->dq_forw) { + dqh = DQHASH(dqvp, id); + for (dq = dqh->lh_first; dq; dq = dq->dq_hash.le_next) { if (dq->dq_id != id || dq->dq_ump->um_quotas[dq->dq_type] != dqvp) continue; @@ -712,13 +719,8 @@ dqget(vp, id, ump, type, dqp) * Cache hit with no references. Take * the structure off the free list. */ - if (dq->dq_cnt == 0) { - if ((dp = dq->dq_freef) != NODQUOT) - dp->dq_freeb = dq->dq_freeb; - else - dqback = dq->dq_freeb; - *dq->dq_freeb = dp; - } + if (dq->dq_cnt == 0) + TAILQ_REMOVE(&dqfreelist, dq, dq_freelist); DQREF(dq); *dqp = dq; return (0); @@ -726,41 +728,30 @@ dqget(vp, id, ump, type, dqp) /* * Not in cache, allocate a new one. */ - if (dqfreel == NODQUOT && numdquot < MAXQUOTAS * desiredvnodes) + if (dqfreelist.tqh_first == NODQUOT && + numdquot < MAXQUOTAS * desiredvnodes) desireddquot += DQUOTINC; if (numdquot < desireddquot) { dq = (struct dquot *)malloc(sizeof *dq, M_DQUOT, M_WAITOK); bzero((char *)dq, sizeof *dq); numdquot++; } else { - if ((dq = dqfreel) == NULL) { + if ((dq = dqfreelist.tqh_first) == NULL) { tablefull("dquot"); *dqp = NODQUOT; return (EUSERS); } if (dq->dq_cnt || (dq->dq_flags & DQ_MOD)) panic("free dquot isn't"); - if ((dp = dq->dq_freef) != NODQUOT) - dp->dq_freeb = &dqfreel; - else - dqback = &dqfreel; - dqfreel = dp; - dq->dq_freef = NULL; - dq->dq_freeb = NULL; - if (dp = dq->dq_forw) - dp->dq_back = dq->dq_back; - *dq->dq_back = dp; + TAILQ_REMOVE(&dqfreelist, dq, dq_freelist); + LIST_REMOVE(dq, dq_hash); } /* * Initialize the contents of the dquot structure. */ if (vp != dqvp) - VOP_LOCK(dqvp); - if (dp = *dpp) - dp->dq_back = &dq->dq_forw; - dq->dq_forw = dp; - dq->dq_back = dpp; - *dpp = dq; + vn_lock(dqvp, LK_EXCLUSIVE | LK_RETRY, p); + LIST_INSERT_HEAD(dqh, dq, dq_hash); DQREF(dq); dq->dq_flags = DQ_LOCK; dq->dq_id = id; @@ -779,7 +770,7 @@ dqget(vp, id, ump, type, dqp) if (auio.uio_resid == sizeof(struct dqblk) && error == 0) bzero((caddr_t)&dq->dq_dqb, sizeof(struct dqblk)); if (vp != dqvp) - VOP_UNLOCK(dqvp); + VOP_UNLOCK(dqvp, 0, p); if (dq->dq_flags & DQ_WANT) wakeup((caddr_t)dq); dq->dq_flags = 0; @@ -788,11 +779,7 @@ dqget(vp, id, ump, type, dqp) * quota structure and reflect problem to caller. */ if (error) { - if (dp = dq->dq_forw) - dp->dq_back = dq->dq_back; - *dq->dq_back = dp; - dq->dq_forw = NULL; - dq->dq_back = NULL; + LIST_REMOVE(dq, dq_hash); dqrele(vp, dq); *dqp = NODQUOT; return (error); @@ -844,15 +831,7 @@ dqrele(vp, dq) (void) dqsync(vp, dq); if (--dq->dq_cnt > 0) return; - if (dqfreel != NODQUOT) { - *dqback = dq; - dq->dq_freeb = dqback; - } else { - dqfreel = dq; - dq->dq_freeb = &dqfreel; - } - dq->dq_freef = NODQUOT; - dqback = &dq->dq_freef; + TAILQ_INSERT_TAIL(&dqfreelist, dq, dq_freelist); } /* @@ -861,8 +840,9 @@ dqrele(vp, dq) int dqsync(vp, dq) struct vnode *vp; - register struct dquot *dq; + struct dquot *dq; { + struct proc *p = curproc; /* XXX */ struct vnode *dqvp; struct iovec aiov; struct uio auio; @@ -875,13 +855,13 @@ dqsync(vp, dq) if ((dqvp = dq->dq_ump->um_quotas[dq->dq_type]) == NULLVP) panic("dqsync: file"); if (vp != dqvp) - VOP_LOCK(dqvp); + vn_lock(dqvp, LK_EXCLUSIVE | LK_RETRY, p); while (dq->dq_flags & DQ_LOCK) { dq->dq_flags |= DQ_WANT; sleep((caddr_t)dq, PINOD+2); if ((dq->dq_flags & DQ_MOD) == 0) { if (vp != dqvp) - VOP_UNLOCK(dqvp); + VOP_UNLOCK(dqvp, 0, p); return (0); } } @@ -902,7 +882,7 @@ dqsync(vp, dq) wakeup((caddr_t)dq); dq->dq_flags &= ~(DQ_MOD|DQ_LOCK|DQ_WANT); if (vp != dqvp) - VOP_UNLOCK(dqvp); + VOP_UNLOCK(dqvp, 0, p); return (error); } @@ -913,25 +893,22 @@ void dqflush(vp) register struct vnode *vp; { - register struct dquot *dq, *dp, **dpp, *nextdq; + register struct dquot *dq, *nextdq; + struct dqhash *dqh; /* * Move all dquot's that used to refer to this quota * file off their hash chains (they will eventually * fall off the head of the free list and be re-used). */ - for (dpp = &dqhashtbl[dqhash]; dpp >= dqhashtbl; dpp--) { - for (dq = *dpp; dq; dq = nextdq) { - nextdq = dq->dq_forw; + for (dqh = &dqhashtbl[dqhash]; dqh >= dqhashtbl; dqh--) { + for (dq = dqh->lh_first; dq; dq = nextdq) { + nextdq = dq->dq_hash.le_next; if (dq->dq_ump->um_quotas[dq->dq_type] != vp) continue; if (dq->dq_cnt) panic("dqflush: stray dquot"); - if (dp = dq->dq_forw) - dp->dq_back = dq->dq_back; - *dq->dq_back = dp; - dq->dq_forw = NULL; - dq->dq_back = NULL; + LIST_REMOVE(dq, dq_hash); dq->dq_ump = (struct ufsmount *)0; } } diff --git a/sys/ufs/ufs/ufs_readwrite.c b/sys/ufs/ufs/ufs_readwrite.c index 5ead2c1..c88cad2 100644 --- a/sys/ufs/ufs/ufs_readwrite.c +++ b/sys/ufs/ufs/ufs_readwrite.c @@ -30,11 +30,11 @@ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. * - * @(#)ufs_readwrite.c 8.7 (Berkeley) 1/21/94 + * @(#)ufs_readwrite.c 8.11 (Berkeley) 5/8/95 */ #ifdef LFS_READWRITE -#define BLKSIZE(a, b, c) blksize(a) +#define BLKSIZE(a, b, c) blksize(a, b, c) #define FS struct lfs #define I_FS i_lfs #define READ lfs_read @@ -70,7 +70,7 @@ READ(ap) register struct uio *uio; register FS *fs; struct buf *bp; - daddr_t lbn, nextlbn; + ufs_daddr_t lbn, nextlbn; off_t bytesinfile; long size, xfersize, blkoffset; int error; @@ -92,7 +92,7 @@ READ(ap) panic("%s: type %d", READ_S, vp->v_type); #endif fs = ip->I_FS; - if ((u_quad_t)uio->uio_offset > fs->fs_maxfilesize) + if ((u_int64_t)uio->uio_offset > fs->fs_maxfilesize) return (EFBIG); for (error = 0, bp = NULL; uio->uio_resid > 0; bp = NULL) { @@ -112,7 +112,7 @@ READ(ap) (void)lfs_check(vp, lbn); error = cluster_read(vp, ip->i_size, lbn, size, NOCRED, &bp); #else - if (lblktosize(fs, nextlbn) > ip->i_size) + if (lblktosize(fs, nextlbn) >= ip->i_size) error = bread(vp, lbn, size, NOCRED, &bp); else if (doclusterread) error = cluster_read(vp, @@ -173,7 +173,7 @@ WRITE(ap) register FS *fs; struct buf *bp; struct proc *p; - daddr_t lbn; + ufs_daddr_t lbn; off_t osize; int blkoffset, error, flags, ioflag, resid, size, xfersize; @@ -206,7 +206,7 @@ WRITE(ap) fs = ip->I_FS; if (uio->uio_offset < 0 || - (u_quad_t)uio->uio_offset + uio->uio_resid > fs->fs_maxfilesize) + (u_int64_t)uio->uio_offset + uio->uio_resid > fs->fs_maxfilesize) return (EFBIG); /* * Maybe this should be above the vnode op call, but so long as @@ -232,7 +232,7 @@ WRITE(ap) xfersize = uio->uio_resid; #ifdef LFS_READWRITE (void)lfs_check(vp, lbn); - error = lfs_balloc(vp, xfersize, lbn, &bp); + error = lfs_balloc(vp, blkoffset, xfersize, lbn, &bp); #else if (fs->fs_bsize > xfersize) flags |= B_CLRBUF; diff --git a/sys/ufs/ufs/ufs_vfsops.c b/sys/ufs/ufs/ufs_vfsops.c index f806e0b..afac207 100644 --- a/sys/ufs/ufs/ufs_vfsops.c +++ b/sys/ufs/ufs/ufs_vfsops.c @@ -35,7 +35,7 @@ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. * - * @(#)ufs_vfsops.c 8.4 (Berkeley) 4/16/94 + * @(#)ufs_vfsops.c 8.8 (Berkeley) 5/20/95 */ #include <sys/param.h> @@ -54,11 +54,6 @@ #include <ufs/ufs/ufs_extern.h> /* - * Flag to permit forcible unmounting. - */ -int doforce = 1; - -/* * Make a filesystem operational. * Nothing to do at the moment. */ @@ -111,8 +106,9 @@ ufs_quotactl(mp, cmds, uid, arg, p) cmd = cmds >> SUBCMDSHIFT; switch (cmd) { - case Q_GETQUOTA: case Q_SYNC: + break; + case Q_GETQUOTA: if (uid == p->p_cred->p_ruid) break; /* fall through */ @@ -121,46 +117,67 @@ ufs_quotactl(mp, cmds, uid, arg, p) return (error); } - type = cmd & SUBCMDMASK; + type = cmds & SUBCMDMASK; if ((u_int)type >= MAXQUOTAS) return (EINVAL); + if (vfs_busy(mp, LK_NOWAIT, 0, p)) + return (0); switch (cmd) { case Q_QUOTAON: - return (quotaon(p, mp, type, arg)); + error = quotaon(p, mp, type, arg); + break; case Q_QUOTAOFF: - if (vfs_busy(mp)) - return (0); error = quotaoff(p, mp, type); - vfs_unbusy(mp); - return (error); + break; case Q_SETQUOTA: - return (setquota(mp, uid, type, arg)); + error = setquota(mp, uid, type, arg); + break; case Q_SETUSE: - return (setuse(mp, uid, type, arg)); + error = setuse(mp, uid, type, arg); + break; case Q_GETQUOTA: - return (getquota(mp, uid, type, arg)); + error = getquota(mp, uid, type, arg); + break; case Q_SYNC: - if (vfs_busy(mp)) - return (0); error = qsync(mp); - vfs_unbusy(mp); - return (error); + break; default: - return (EINVAL); + error = EINVAL; + break; } - /* NOTREACHED */ + vfs_unbusy(mp, p); + return (error); #endif } /* + * Initial UFS filesystems, done only once. + */ +int +ufs_init(vfsp) + struct vfsconf *vfsp; +{ + static int done; + + if (done) + return (0); + done = 1; + ufs_ihashinit(); +#ifdef QUOTA + dqinit(); +#endif + return (0); +} + +/* * This is the generic part of fhtovp called after the underlying * filesystem has validated the file handle. * diff --git a/sys/ufs/ufs/ufs_vnops.c b/sys/ufs/ufs/ufs_vnops.c index 7b7c883..89d4ae5 100644 --- a/sys/ufs/ufs/ufs_vnops.c +++ b/sys/ufs/ufs/ufs_vnops.c @@ -1,5 +1,5 @@ /* - * Copyright (c) 1982, 1986, 1989, 1993 + * Copyright (c) 1982, 1986, 1989, 1993, 1995 * The Regents of the University of California. All rights reserved. * (c) UNIX System Laboratories, Inc. * All or some portions of this file are derived from material licensed @@ -35,7 +35,7 @@ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. * - * @(#)ufs_vnops.c 8.10 (Berkeley) 4/1/94 + * @(#)ufs_vnops.c 8.27 (Berkeley) 5/27/95 */ #include <sys/param.h> @@ -69,8 +69,8 @@ static int ufs_chown __P((struct vnode *, uid_t, gid_t, struct ucred *, struct proc *)); union _qcvt { - quad_t qcvt; - long val[2]; + int64_t qcvt; + int32_t val[2]; }; #define SETHIGH(q, h) { \ union _qcvt tmp; \ @@ -119,9 +119,9 @@ ufs_mknod(ap) struct vattr *a_vap; } */ *ap; { - register struct vattr *vap = ap->a_vap; - register struct vnode **vpp = ap->a_vpp; - register struct inode *ip; + struct vattr *vap = ap->a_vap; + struct vnode **vpp = ap->a_vpp; + struct inode *ip; int error; if (error = @@ -192,8 +192,10 @@ ufs_close(ap) register struct vnode *vp = ap->a_vp; register struct inode *ip = VTOI(vp); - if (vp->v_usecount > 1 && !(ip->i_flag & IN_LOCKED)) + simple_lock(&vp->v_interlock); + if (vp->v_usecount > 1) ITIMES(ip, &time, &time); + simple_unlock(&vp->v_interlock); return (0); } @@ -206,30 +208,32 @@ ufs_access(ap) struct proc *a_p; } */ *ap; { - register struct vnode *vp = ap->a_vp; - register struct inode *ip = VTOI(vp); - register struct ucred *cred = ap->a_cred; + struct vnode *vp = ap->a_vp; + struct inode *ip = VTOI(vp); + struct ucred *cred = ap->a_cred; mode_t mask, mode = ap->a_mode; register gid_t *gp; int i, error; -#ifdef DIAGNOSTIC - if (!VOP_ISLOCKED(vp)) { - vprint("ufs_access: not locked", vp); - panic("ufs_access: not locked"); - } -#endif -#ifdef QUOTA - if (mode & VWRITE) + /* + * Disallow write attempts on read-only file systems; + * unless the file is a socket, fifo, or a block or + * character device resident on the file system. + */ + if (mode & VWRITE) { switch (vp->v_type) { case VDIR: case VLNK: case VREG: + if (vp->v_mount->mnt_flag & MNT_RDONLY) + return (EROFS); +#ifdef QUOTA if (error = getinoquota(ip)) return (error); +#endif break; } -#endif + } /* If immutable bit set, nobody gets to write it. */ if ((mode & VWRITE) && (ip->i_flags & IMMUTABLE)) @@ -300,9 +304,12 @@ ufs_getattr(ap) vap->va_gid = ip->i_gid; vap->va_rdev = (dev_t)ip->i_rdev; vap->va_size = ip->i_din.di_size; - vap->va_atime = ip->i_atime; - vap->va_mtime = ip->i_mtime; - vap->va_ctime = ip->i_ctime; + vap->va_atime.ts_sec = ip->i_atime; + vap->va_atime.ts_nsec = ip->i_atimensec; + vap->va_mtime.ts_sec = ip->i_mtime; + vap->va_mtime.ts_nsec = ip->i_mtimensec; + vap->va_ctime.ts_sec = ip->i_ctime; + vap->va_ctime.ts_nsec = ip->i_ctimensec; vap->va_flags = ip->i_flags; vap->va_gen = ip->i_gen; /* this doesn't belong here */ @@ -312,7 +319,7 @@ ufs_getattr(ap) vap->va_blocksize = MAXBSIZE; else vap->va_blocksize = vp->v_mount->mnt_stat.f_iosize; - vap->va_bytes = dbtob(ip->i_blocks); + vap->va_bytes = dbtob((u_quad_t)ip->i_blocks); vap->va_type = vp->v_type; vap->va_filerev = ip->i_modrev; return (0); @@ -330,11 +337,11 @@ ufs_setattr(ap) struct proc *a_p; } */ *ap; { - register struct vattr *vap = ap->a_vap; - register struct vnode *vp = ap->a_vp; - register struct inode *ip = VTOI(vp); - register struct ucred *cred = ap->a_cred; - register struct proc *p = ap->a_p; + struct vattr *vap = ap->a_vap; + struct vnode *vp = ap->a_vp; + struct inode *ip = VTOI(vp); + struct ucred *cred = ap->a_cred; + struct proc *p = ap->a_p; struct timeval atimeval, mtimeval; int error; @@ -348,6 +355,8 @@ ufs_setattr(ap) return (EINVAL); } if (vap->va_flags != VNOVAL) { + if (vp->v_mount->mnt_flag & MNT_RDONLY) + return (EROFS); if (cred->cr_uid != ip->i_uid && (error = suser(cred, &p->p_acflag))) return (error); @@ -357,7 +366,8 @@ ufs_setattr(ap) return (EPERM); ip->i_flags = vap->va_flags; } else { - if (ip->i_flags & (SF_IMMUTABLE | SF_APPEND)) + if (ip->i_flags & (SF_IMMUTABLE | SF_APPEND) || + (vap->va_flags & UF_SETTABLE) != vap->va_flags) return (EPERM); ip->i_flags &= SF_SETTABLE; ip->i_flags |= (vap->va_flags & UF_SETTABLE); @@ -371,17 +381,34 @@ ufs_setattr(ap) /* * Go through the fields and update iff not VNOVAL. */ - if (vap->va_uid != (uid_t)VNOVAL || vap->va_gid != (gid_t)VNOVAL) + if (vap->va_uid != (uid_t)VNOVAL || vap->va_gid != (gid_t)VNOVAL) { + if (vp->v_mount->mnt_flag & MNT_RDONLY) + return (EROFS); if (error = ufs_chown(vp, vap->va_uid, vap->va_gid, cred, p)) return (error); + } if (vap->va_size != VNOVAL) { - if (vp->v_type == VDIR) + /* + * Disallow write attempts on read-only file systems; + * unless the file is a socket, fifo, or a block or + * character device resident on the file system. + */ + switch (vp->v_type) { + case VDIR: return (EISDIR); + case VLNK: + case VREG: + if (vp->v_mount->mnt_flag & MNT_RDONLY) + return (EROFS); + break; + } if (error = VOP_TRUNCATE(vp, vap->va_size, 0, cred, p)) return (error); } ip = VTOI(vp); if (vap->va_atime.ts_sec != VNOVAL || vap->va_mtime.ts_sec != VNOVAL) { + if (vp->v_mount->mnt_flag & MNT_RDONLY) + return (EROFS); if (cred->cr_uid != ip->i_uid && (error = suser(cred, &p->p_acflag)) && ((vap->va_vaflags & VA_UTIMES_NULL) == 0 || @@ -399,8 +426,11 @@ ufs_setattr(ap) return (error); } error = 0; - if (vap->va_mode != (mode_t)VNOVAL) + if (vap->va_mode != (mode_t)VNOVAL) { + if (vp->v_mount->mnt_flag & MNT_RDONLY) + return (EROFS); error = ufs_chmod(vp, (int)vap->va_mode, cred, p); + } return (error); } @@ -466,7 +496,7 @@ ufs_chown(vp, uid, gid, cred, p) * the caller must be superuser or the call fails. */ if ((cred->cr_uid != ip->i_uid || uid != ip->i_uid || - !groupmember((gid_t)gid, cred)) && + (gid != ip->i_gid && !groupmember((gid_t)gid, cred))) && (error = suser(cred, &p->p_acflag))) return (error); ogid = ip->i_gid; @@ -622,9 +652,9 @@ ufs_remove(ap) struct componentname *a_cnp; } */ *ap; { - register struct inode *ip; - register struct vnode *vp = ap->a_vp; - register struct vnode *dvp = ap->a_dvp; + struct inode *ip; + struct vnode *vp = ap->a_vp; + struct vnode *dvp = ap->a_dvp; int error; ip = VTOI(vp); @@ -657,10 +687,11 @@ ufs_link(ap) struct componentname *a_cnp; } */ *ap; { - register struct vnode *vp = ap->a_vp; - register struct vnode *tdvp = ap->a_tdvp; - register struct componentname *cnp = ap->a_cnp; - register struct inode *ip; + struct vnode *vp = ap->a_vp; + struct vnode *tdvp = ap->a_tdvp; + struct componentname *cnp = ap->a_cnp; + struct proc *p = cnp->cn_proc; + struct inode *ip; struct timeval tv; int error; @@ -668,196 +699,99 @@ ufs_link(ap) if ((cnp->cn_flags & HASBUF) == 0) panic("ufs_link: no name"); #endif - if (vp->v_mount != tdvp->v_mount) { - VOP_ABORTOP(vp, cnp); + if (tdvp->v_mount != vp->v_mount) { + VOP_ABORTOP(tdvp, cnp); error = EXDEV; goto out2; } - if (vp != tdvp && (error = VOP_LOCK(tdvp))) { - VOP_ABORTOP(vp, cnp); + if (tdvp != vp && (error = vn_lock(vp, LK_EXCLUSIVE, p))) { + VOP_ABORTOP(tdvp, cnp); goto out2; } - ip = VTOI(tdvp); + ip = VTOI(vp); if ((nlink_t)ip->i_nlink >= LINK_MAX) { - VOP_ABORTOP(vp, cnp); + VOP_ABORTOP(tdvp, cnp); error = EMLINK; goto out1; } if (ip->i_flags & (IMMUTABLE | APPEND)) { - VOP_ABORTOP(vp, cnp); + VOP_ABORTOP(tdvp, cnp); error = EPERM; goto out1; } ip->i_nlink++; ip->i_flag |= IN_CHANGE; tv = time; - error = VOP_UPDATE(tdvp, &tv, &tv, 1); + error = VOP_UPDATE(vp, &tv, &tv, 1); if (!error) - error = ufs_direnter(ip, vp, cnp); + error = ufs_direnter(ip, tdvp, cnp); if (error) { ip->i_nlink--; ip->i_flag |= IN_CHANGE; } FREE(cnp->cn_pnbuf, M_NAMEI); out1: - if (vp != tdvp) - VOP_UNLOCK(tdvp); + if (tdvp != vp) + VOP_UNLOCK(vp, 0, p); out2: - vput(vp); + vput(tdvp); return (error); } - - /* - * relookup - lookup a path name component - * Used by lookup to re-aquire things. + * whiteout vnode call */ int -relookup(dvp, vpp, cnp) - struct vnode *dvp, **vpp; - struct componentname *cnp; +ufs_whiteout(ap) + struct vop_whiteout_args /* { + struct vnode *a_dvp; + struct componentname *a_cnp; + int a_flags; + } */ *ap; { - register struct vnode *dp = 0; /* the directory we are searching */ - int docache; /* == 0 do not cache last component */ - int wantparent; /* 1 => wantparent or lockparent flag */ - int rdonly; /* lookup read-only flag bit */ - int error = 0; -#ifdef NAMEI_DIAGNOSTIC - int newhash; /* DEBUG: check name hash */ - char *cp; /* DEBUG: check name ptr/len */ -#endif - - /* - * Setup: break out flag bits into variables. - */ - wantparent = cnp->cn_flags & (LOCKPARENT|WANTPARENT); - docache = (cnp->cn_flags & NOCACHE) ^ NOCACHE; - if (cnp->cn_nameiop == DELETE || - (wantparent && cnp->cn_nameiop != CREATE)) - docache = 0; - rdonly = cnp->cn_flags & RDONLY; - cnp->cn_flags &= ~ISSYMLINK; - dp = dvp; - VOP_LOCK(dp); - -/* dirloop: */ - /* - * Search a new directory. - * - * The cn_hash value is for use by vfs_cache. - * The last component of the filename is left accessible via - * cnp->cn_nameptr for callers that need the name. Callers needing - * the name set the SAVENAME flag. When done, they assume - * responsibility for freeing the pathname buffer. - */ -#ifdef NAMEI_DIAGNOSTIC - for (newhash = 0, cp = cnp->cn_nameptr; *cp != 0 && *cp != '/'; cp++) - newhash += (unsigned char)*cp; - if (newhash != cnp->cn_hash) - panic("relookup: bad hash"); - if (cnp->cn_namelen != cp - cnp->cn_nameptr) - panic ("relookup: bad len"); - if (*cp != 0) - panic("relookup: not last component"); - printf("{%s}: ", cnp->cn_nameptr); -#endif - - /* - * Check for degenerate name (e.g. / or "") - * which is a way of talking about a directory, - * e.g. like "/." or ".". - */ - if (cnp->cn_nameptr[0] == '\0') { - if (cnp->cn_nameiop != LOOKUP || wantparent) { - error = EISDIR; - goto bad; - } - if (dp->v_type != VDIR) { - error = ENOTDIR; - goto bad; - } - if (!(cnp->cn_flags & LOCKLEAF)) - VOP_UNLOCK(dp); - *vpp = dp; - if (cnp->cn_flags & SAVESTART) - panic("lookup: SAVESTART"); - return (0); - } + struct vnode *dvp = ap->a_dvp; + struct componentname *cnp = ap->a_cnp; + struct direct newdir; + int error; - if (cnp->cn_flags & ISDOTDOT) - panic ("relookup: lookup on dot-dot"); + switch (ap->a_flags) { + case LOOKUP: + /* 4.4 format directories support whiteout operations */ + if (dvp->v_mount->mnt_maxsymlinklen > 0) + return (0); + return (EOPNOTSUPP); - /* - * We now have a segment name to search for, and a directory to search. - */ - if (error = VOP_LOOKUP(dp, vpp, cnp)) { + case CREATE: + /* create a new directory whiteout */ #ifdef DIAGNOSTIC - if (*vpp != NULL) - panic("leaf should be empty"); + if ((cnp->cn_flags & SAVENAME) == 0) + panic("ufs_whiteout: missing name"); + if (dvp->v_mount->mnt_maxsymlinklen <= 0) + panic("ufs_whiteout: old format filesystem"); #endif - if (error != EJUSTRETURN) - goto bad; - /* - * If creating and at end of pathname, then can consider - * allowing file to be created. - */ - if (rdonly || (dvp->v_mount->mnt_flag & MNT_RDONLY)) { - error = EROFS; - goto bad; - } - /* ASSERT(dvp == ndp->ni_startdir) */ - if (cnp->cn_flags & SAVESTART) - VREF(dvp); - /* - * We return with ni_vp NULL to indicate that the entry - * doesn't currently exist, leaving a pointer to the - * (possibly locked) directory inode in ndp->ni_dvp. - */ - return (0); - } - dp = *vpp; + newdir.d_ino = WINO; + newdir.d_namlen = cnp->cn_namelen; + bcopy(cnp->cn_nameptr, newdir.d_name, (unsigned)cnp->cn_namelen + 1); + newdir.d_type = DT_WHT; + error = ufs_direnter2(dvp, &newdir, cnp->cn_cred, cnp->cn_proc); + break; + + case DELETE: + /* remove an existing directory whiteout */ #ifdef DIAGNOSTIC - /* - * Check for symbolic link - */ - if (dp->v_type == VLNK && (cnp->cn_flags & FOLLOW)) - panic ("relookup: symlink found.\n"); + if (dvp->v_mount->mnt_maxsymlinklen <= 0) + panic("ufs_whiteout: old format filesystem"); #endif - /* - * Check for read-only file systems. - */ - if (cnp->cn_nameiop == DELETE || cnp->cn_nameiop == RENAME) { - /* - * Disallow directory write attempts on read-only - * file systems. - */ - if (rdonly || (dp->v_mount->mnt_flag & MNT_RDONLY) || - (wantparent && - (dvp->v_mount->mnt_flag & MNT_RDONLY))) { - error = EROFS; - goto bad2; - } + cnp->cn_flags &= ~DOWHITEOUT; + error = ufs_dirremove(dvp, cnp); + break; + } + if (cnp->cn_flags & HASBUF) { + FREE(cnp->cn_pnbuf, M_NAMEI); + cnp->cn_flags &= ~HASBUF; } - /* ASSERT(dvp == ndp->ni_startdir) */ - if (cnp->cn_flags & SAVESTART) - VREF(dvp); - - if (!wantparent) - vrele(dvp); - if ((cnp->cn_flags & LOCKLEAF) == 0) - VOP_UNLOCK(dp); - return (0); - -bad2: - if ((cnp->cn_flags & LOCKPARENT) && (cnp->cn_flags & ISLASTCN)) - VOP_UNLOCK(dvp); - vrele(dvp); -bad: - vput(dp); - *vpp = NULL; return (error); } @@ -900,10 +834,11 @@ ufs_rename(ap) struct vnode *tvp = ap->a_tvp; register struct vnode *tdvp = ap->a_tdvp; struct vnode *fvp = ap->a_fvp; - register struct vnode *fdvp = ap->a_fdvp; - register struct componentname *tcnp = ap->a_tcnp; - register struct componentname *fcnp = ap->a_fcnp; - register struct inode *ip, *xp, *dp; + struct vnode *fdvp = ap->a_fdvp; + struct componentname *tcnp = ap->a_tcnp; + struct componentname *fcnp = ap->a_fcnp; + struct proc *p = fcnp->cn_proc; + struct inode *ip, *xp, *dp; struct dirtemplate dirbuf; struct timeval tv; int doingdirectory = 0, oldparent = 0, newparent = 0; @@ -948,25 +883,29 @@ abortit: error = EINVAL; goto abortit; } - VOP_ABORTOP(fdvp, fcnp); - vrele(fdvp); - vrele(fvp); + + /* Release destination completely. */ + VOP_ABORTOP(tdvp, tcnp); vput(tdvp); vput(tvp); - tcnp->cn_flags &= ~MODMASK; - tcnp->cn_flags |= LOCKPARENT | LOCKLEAF; - if ((tcnp->cn_flags & SAVESTART) == 0) + + /* Delete source. */ + vrele(fdvp); + vrele(fvp); + fcnp->cn_flags &= ~MODMASK; + fcnp->cn_flags |= LOCKPARENT | LOCKLEAF; + if ((fcnp->cn_flags & SAVESTART) == 0) panic("ufs_rename: lost from startdir"); - tcnp->cn_nameiop = DELETE; - (void) relookup(tdvp, &tvp, tcnp); - return (VOP_REMOVE(tdvp, tvp, tcnp)); + fcnp->cn_nameiop = DELETE; + (void) relookup(fdvp, &fvp, fcnp); + return (VOP_REMOVE(fdvp, fvp, fcnp)); } - if (error = VOP_LOCK(fvp)) + if (error = vn_lock(fvp, LK_EXCLUSIVE, p)) goto abortit; dp = VTOI(fdvp); ip = VTOI(fvp); if ((ip->i_flags & (IMMUTABLE | APPEND)) || (dp->i_flags & APPEND)) { - VOP_UNLOCK(fvp); + VOP_UNLOCK(fvp, 0, p); error = EPERM; goto abortit; } @@ -977,7 +916,7 @@ abortit: if ((fcnp->cn_namelen == 1 && fcnp->cn_nameptr[0] == '.') || dp == ip || (fcnp->cn_flags&ISDOTDOT) || (ip->i_flag & IN_RENAME)) { - VOP_UNLOCK(fvp); + VOP_UNLOCK(fvp, 0, p); error = EINVAL; goto abortit; } @@ -1006,7 +945,7 @@ abortit: ip->i_flag |= IN_CHANGE; tv = time; if (error = VOP_UPDATE(fvp, &tv, &tv, 1)) { - VOP_UNLOCK(fvp); + VOP_UNLOCK(fvp, 0, p); goto bad; } @@ -1021,7 +960,7 @@ abortit: * call to checkpath(). */ error = VOP_ACCESS(fvp, VWRITE, tcnp->cn_cred, tcnp->cn_proc); - VOP_UNLOCK(fvp); + VOP_UNLOCK(fvp, 0, p); if (oldparent != dp->i_number) newparent = dp->i_number; if (doingdirectory && newparent) { @@ -1242,7 +1181,9 @@ bad: vput(ITOV(xp)); vput(ITOV(dp)); out: - if (VOP_LOCK(fvp) == 0) { + if (doingdirectory) + ip->i_flag &= ~IN_RENAME; + if (vn_lock(fvp, LK_EXCLUSIVE, p) == 0) { ip->i_nlink--; ip->i_flag |= IN_CHANGE; vput(fvp); @@ -1319,6 +1260,8 @@ ufs_mkdir(ap) ip->i_mode = dmode; tvp->v_type = VDIR; /* Rest init'd in getnewvnode(). */ ip->i_nlink = 2; + if (cnp->cn_flags & ISWHITEOUT) + ip->i_flags |= UF_OPAQUE; tv = time; error = VOP_UPDATE(tvp, &tv, &tv, 1); @@ -1389,10 +1332,10 @@ ufs_rmdir(ap) struct componentname *a_cnp; } */ *ap; { - register struct vnode *vp = ap->a_vp; - register struct vnode *dvp = ap->a_dvp; - register struct componentname *cnp = ap->a_cnp; - register struct inode *ip, *dp; + struct vnode *vp = ap->a_vp; + struct vnode *dvp = ap->a_dvp; + struct componentname *cnp = ap->a_cnp; + struct inode *ip, *dp; int error; ip = VTOI(vp); @@ -1506,16 +1449,22 @@ ufs_readdir(ap) struct vnode *a_vp; struct uio *a_uio; struct ucred *a_cred; + int *a_eofflag; + int *ncookies; + u_long **a_cookies; } */ *ap; { register struct uio *uio = ap->a_uio; - int count, lost, error; + int error; + size_t count, lost; + off_t off = uio->uio_offset; count = uio->uio_resid; - count &= ~(DIRBLKSIZ - 1); - lost = uio->uio_resid - count; - if (count < DIRBLKSIZ || (uio->uio_offset & (DIRBLKSIZ -1))) + /* Make sure we don't return partial entries. */ + count -= (uio->uio_offset + count) & (DIRBLKSIZ -1); + if (count <= 0) return (EINVAL); + lost = uio->uio_resid - count; uio->uio_resid = count; uio->uio_iov->iov_len = count; # if (BYTE_ORDER == LITTLE_ENDIAN) @@ -1560,7 +1509,43 @@ ufs_readdir(ap) # else error = VOP_READ(ap->a_vp, uio, 0, ap->a_cred); # endif + if (!error && ap->a_ncookies) { + struct dirent *dp, *dpstart; + off_t offstart; + u_long *cookies; + int ncookies; + + /* + * Only the NFS server uses cookies, and it loads the + * directory block into system space, so we can just look at + * it directly. + */ + if (uio->uio_segflg != UIO_SYSSPACE || uio->uio_iovcnt != 1) + panic("ufs_readdir: lost in space"); + dpstart = (struct dirent *) + (uio->uio_iov->iov_base - (uio->uio_offset - off)); + offstart = off; + for (dp = dpstart, ncookies = 0; off < uio->uio_offset; ) { + if (dp->d_reclen == 0) + break; + off += dp->d_reclen; + ncookies++; + dp = (struct dirent *)((caddr_t)dp + dp->d_reclen); + } + lost += uio->uio_offset - off; + uio->uio_offset = off; + MALLOC(cookies, u_long *, ncookies * sizeof(u_long), M_TEMP, + M_WAITOK); + *ap->a_ncookies = ncookies; + *ap->a_cookies = cookies; + for (off = offstart, dp = dpstart; off < uio->uio_offset; ) { + *(cookies++) = off; + off += dp->d_reclen; + dp = (struct dirent *)((caddr_t)dp + dp->d_reclen); + } + } uio->uio_resid += lost; + *ap->a_eofflag = VTOI(ap->a_vp)->i_size <= uio->uio_offset; return (error); } @@ -1611,78 +1596,31 @@ int ufs_lock(ap) struct vop_lock_args /* { struct vnode *a_vp; + int a_flags; + struct proc *a_p; } */ *ap; { - register struct vnode *vp = ap->a_vp; - register struct inode *ip; - struct proc *p = curproc; /* XXX */ + struct vnode *vp = ap->a_vp; -start: - while (vp->v_flag & VXLOCK) { - vp->v_flag |= VXWANT; - sleep((caddr_t)vp, PINOD); - } - if (vp->v_tag == VT_NON) - return (ENOENT); - ip = VTOI(vp); - if (ip->i_flag & IN_LOCKED) { - ip->i_flag |= IN_WANTED; -#ifdef DIAGNOSTIC - if (p) { - if (p->p_pid == ip->i_lockholder) - panic("locking against myself"); - ip->i_lockwaiter = p->p_pid; - } else - ip->i_lockwaiter = -1; -#endif - (void) sleep((caddr_t)ip, PINOD); - goto start; - } -#ifdef DIAGNOSTIC - ip->i_lockwaiter = 0; - if (ip->i_lockholder != 0) - panic("lockholder (%d) != 0", ip->i_lockholder); - if (p && p->p_pid == 0) - printf("locking by process 0\n"); - if (p) - ip->i_lockholder = p->p_pid; - else - ip->i_lockholder = -1; -#endif - ip->i_flag |= IN_LOCKED; - return (0); + return (lockmgr(&VTOI(vp)->i_lock, ap->a_flags, &vp->v_interlock, + ap->a_p)); } /* - * Unlock an inode. If WANT bit is on, wakeup. + * Unlock an inode. */ -int lockcount = 90; int ufs_unlock(ap) struct vop_unlock_args /* { struct vnode *a_vp; + int a_flags; + struct proc *a_p; } */ *ap; { - register struct inode *ip = VTOI(ap->a_vp); - struct proc *p = curproc; /* XXX */ + struct vnode *vp = ap->a_vp; -#ifdef DIAGNOSTIC - if ((ip->i_flag & IN_LOCKED) == 0) { - vprint("ufs_unlock: unlocked inode", ap->a_vp); - panic("ufs_unlock NOT LOCKED"); - } - if (p && p->p_pid != ip->i_lockholder && p->p_pid > -1 && - ip->i_lockholder > -1 && lockcount++ < 100) - panic("unlocker (%d) != lock holder (%d)", - p->p_pid, ip->i_lockholder); - ip->i_lockholder = 0; -#endif - ip->i_flag &= ~IN_LOCKED; - if (ip->i_flag & IN_WANTED) { - ip->i_flag &= ~IN_WANTED; - wakeup((caddr_t)ip); - } - return (0); + return (lockmgr(&VTOI(vp)->i_lock, ap->a_flags | LK_RELEASE, + &vp->v_interlock, ap->a_p)); } /* @@ -1695,9 +1633,7 @@ ufs_islocked(ap) } */ *ap; { - if (VTOI(ap->a_vp)->i_flag & IN_LOCKED) - return (1); - return (0); + return (lockstatus(&VTOI(ap->a_vp)->i_lock)); } /* @@ -1757,12 +1693,7 @@ ufs_print(ap) if (vp->v_type == VFIFO) fifo_printinfo(vp); #endif /* FIFO */ - printf("%s\n", (ip->i_flag & IN_LOCKED) ? " (LOCKED)" : ""); - if (ip->i_lockholder == 0) - return (0); - printf("\towner pid %d", ip->i_lockholder); - if (ip->i_lockwaiter) - printf(" waiting pid %d", ip->i_lockwaiter); + lockmgr_printinfo(&ip->i_lock); printf("\n"); return (0); } @@ -1821,10 +1752,13 @@ ufsspec_close(ap) struct proc *a_p; } */ *ap; { - register struct inode *ip = VTOI(ap->a_vp); + struct vnode *vp = ap->a_vp; + struct inode *ip = VTOI(vp); - if (ap->a_vp->v_usecount > 1 && !(ip->i_flag & IN_LOCKED)) + simple_lock(&vp->v_interlock); + if (ap->a_vp->v_usecount > 1) ITIMES(ip, &time, &time); + simple_unlock(&vp->v_interlock); return (VOCALL (spec_vnodeop_p, VOFFSET(vop_close), ap)); } @@ -1885,10 +1819,13 @@ ufsfifo_close(ap) } */ *ap; { extern int (**fifo_vnodeop_p)(); - register struct inode *ip = VTOI(ap->a_vp); + struct vnode *vp = ap->a_vp; + struct inode *ip = VTOI(vp); - if (ap->a_vp->v_usecount > 1 && !(ip->i_flag & IN_LOCKED)) + simple_lock(&vp->v_interlock); + if (ap->a_vp->v_usecount > 1) ITIMES(ip, &time, &time); + simple_unlock(&vp->v_interlock); return (VOCALL (fifo_vnodeop_p, VOFFSET(vop_close), ap)); } #endif /* FIFO */ @@ -1994,7 +1931,7 @@ ufs_advlock(ap) lock->lf_inode = ip; lock->lf_type = fl->l_type; lock->lf_next = (struct lockf *)0; - lock->lf_block = (struct lockf *)0; + TAILQ_INIT(&lock->lf_blkhd); lock->lf_flags = ap->a_flags; /* * Do the requested operation. @@ -2031,6 +1968,7 @@ ufs_vinit(mntp, specops, fifoops, vpp) int (**fifoops)(); struct vnode **vpp; { + struct proc *p = curproc; /* XXX */ struct inode *ip; struct vnode *vp, *nvp; @@ -2043,9 +1981,9 @@ ufs_vinit(mntp, specops, fifoops, vpp) if (nvp = checkalias(vp, ip->i_rdev, mntp)) { /* * Discard unneeded vnode, but save its inode. + * Note that the lock is carried over in the inode + * to the replacement vnode. */ - ufs_ihashrem(ip); - VOP_UNLOCK(vp); nvp->v_data = vp->v_data; vp->v_data = NULL; vp->v_op = spec_vnodeop_p; @@ -2056,7 +1994,6 @@ ufs_vinit(mntp, specops, fifoops, vpp) */ vp = nvp; ip->i_vnode = vp; - ufs_ihashins(ip); } break; case VFIFO: @@ -2131,6 +2068,9 @@ ufs_makeinode(mode, dvp, vpp, cnp) suser(cnp->cn_cred, NULL)) ip->i_mode &= ~ISGID; + if (cnp->cn_flags & ISWHITEOUT) + ip->i_flags |= UF_OPAQUE; + /* * Make sure inode goes to disk before directory entry. */ diff --git a/sys/ufs/ufs/ufsmount.h b/sys/ufs/ufs/ufsmount.h index 237871f..ecb3e85 100644 --- a/sys/ufs/ufs/ufsmount.h +++ b/sys/ufs/ufs/ufsmount.h @@ -30,9 +30,30 @@ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. * - * @(#)ufsmount.h 8.2 (Berkeley) 1/12/94 + * @(#)ufsmount.h 8.6 (Berkeley) 3/30/95 */ +/* + * Arguments to mount UFS-based filesystems + */ +struct ufs_args { + char *fspec; /* block special device to mount */ + struct export_args export; /* network export information */ +}; + +#ifdef MFS +/* + * Arguments to mount MFS + */ +struct mfs_args { + char *fspec; /* name to export for statfs */ + struct export_args export; /* if exported MFSes are supported */ + caddr_t base; /* base of file system in memory */ + u_long size; /* size of file system */ +}; +#endif /* MFS */ + +#ifdef KERNEL struct buf; struct inode; struct nameidata; @@ -47,12 +68,14 @@ struct ufsmount { struct mount *um_mountp; /* filesystem vfs structure */ dev_t um_dev; /* device mounted */ struct vnode *um_devvp; /* block device mounted vnode */ + union { /* pointer to superblock */ struct lfs *lfs; /* LFS */ struct fs *fs; /* FFS */ } ufsmount_u; #define um_fs ufsmount_u.fs #define um_lfs ufsmount_u.lfs + struct vnode *um_quotas[MAXQUOTAS]; /* pointer to quota files */ struct ucred *um_cred[MAXQUOTAS]; /* quota file access cred */ u_long um_nindir; /* indirect ptrs per block */ @@ -62,7 +85,9 @@ struct ufsmount { time_t um_itime[MAXQUOTAS]; /* inode quota time limit */ char um_qflags[MAXQUOTAS]; /* quota specific flags */ struct netexport um_export; /* export information */ + int64_t um_savedmaxfilesize; /* XXX - limit maxfilesize */ }; + /* * Flags describing the state of quotas. */ @@ -76,8 +101,7 @@ struct ufsmount { * Macros to access file system parameters in the ufsmount structure. * Used by ufs_bmap. */ -#define blkptrtodb(ump, b) ((b) << (ump)->um_bptrtodb) -#define is_sequential(ump, a, b) ((b) == (a) + ump->um_seqinc) -#define MNINDIR(ump) ((ump)->um_nindir) - - +#define MNINDIR(ump) ((ump)->um_nindir) +#define blkptrtodb(ump, b) ((b) << (ump)->um_bptrtodb) +#define is_sequential(ump, a, b) ((b) == (a) + ump->um_seqinc) +#endif /* KERNEL */ |