svn commit: r204419 - in stable/7: lib/libufs sbin/growfs
sbin/newfs sbin/tunefs sys/ufs/ffs
Kirk McKusick
mckusick at FreeBSD.org
Sat Feb 27 17:55:29 UTC 2010
Author: mckusick
Date: Sat Feb 27 17:55:29 2010
New Revision: 204419
URL: http://svn.freebsd.org/changeset/base/204419
Log:
MFC of 203763, 203764, 203768, 203769, 203770, 203782, and 203784.
These fixes correct a problem in the file system that treats large
inode numbers as negative rather than unsigned. For a default
(16K block) file system, this bug began to show up at a file system
size above about 16Tb.
These fixes also update newfs to ensure that it will never create a
filesystem with more than 2^32 inodes.
They also update libufs, tunefs, and growfs so that they properly
handle inode numbers as unsigned.
Reported by: Scott Burns, John Kilburg, and Bruce Evans
Followup by: Jeff Roberson
PR: 133980
Modified:
stable/7/lib/libufs/cgroup.c
stable/7/lib/libufs/sblock.c
stable/7/sbin/growfs/growfs.c
stable/7/sbin/newfs/mkfs.c
stable/7/sbin/newfs/newfs.c
stable/7/sbin/newfs/newfs.h
stable/7/sbin/tunefs/tunefs.c
stable/7/sys/ufs/ffs/ffs_alloc.c
stable/7/sys/ufs/ffs/fs.h
Directory Properties:
stable/7/lib/libufs/ (props changed)
stable/7/sbin/growfs/ (props changed)
stable/7/sbin/newfs/ (props changed)
stable/7/sbin/tunefs/ (props changed)
stable/7/sys/ (props changed)
stable/7/sys/cddl/contrib/opensolaris/ (props changed)
stable/7/sys/contrib/dev/acpica/ (props changed)
stable/7/sys/contrib/pf/ (props changed)
Modified: stable/7/lib/libufs/cgroup.c
==============================================================================
--- stable/7/lib/libufs/cgroup.c Sat Feb 27 17:36:13 2010 (r204418)
+++ stable/7/lib/libufs/cgroup.c Sat Feb 27 17:55:29 2010 (r204419)
@@ -59,7 +59,7 @@ cgread1(struct uufsd *disk, int c)
fs = &disk->d_fs;
- if (c >= fs->fs_ncg) {
+ if ((unsigned)c >= fs->fs_ncg) {
return (0);
}
ccg = fsbtodb(fs, cgtod(fs, c)) * disk->d_bsize;
Modified: stable/7/lib/libufs/sblock.c
==============================================================================
--- stable/7/lib/libufs/sblock.c Sat Feb 27 17:36:13 2010 (r204418)
+++ stable/7/lib/libufs/sblock.c Sat Feb 27 17:55:29 2010 (r204419)
@@ -93,7 +93,7 @@ int
sbwrite(struct uufsd *disk, int all)
{
struct fs *fs;
- int i;
+ unsigned i;
ERROR(disk, NULL);
Modified: stable/7/sbin/growfs/growfs.c
==============================================================================
--- stable/7/sbin/growfs/growfs.c Sat Feb 27 17:36:13 2010 (r204418)
+++ stable/7/sbin/growfs/growfs.c Sat Feb 27 17:55:29 2010 (r204419)
@@ -174,10 +174,9 @@ static void
growfs(int fsi, int fso, unsigned int Nflag)
{
DBG_FUNC("growfs")
- int i;
- int cylno, j;
time_t utime;
- int width;
+ uint cylno;
+ int i, j, width;
char tmpbuf[100];
#ifdef FSIRAND
static int randinit=0;
@@ -373,11 +372,12 @@ initcg(int cylno, time_t utime, int fso,
{
DBG_FUNC("initcg")
static void *iobuf;
- long d, dlower, dupper, blkno, start;
+ long blkno, start;
ufs2_daddr_t i, cbase, dmax;
struct ufs1_dinode *dp1;
struct ufs2_dinode *dp2;
struct csum *cs;
+ uint d, dupper, dlower;
if (iobuf == NULL && (iobuf = malloc(sblock.fs_bsize)) == NULL) {
errx(37, "panic: cannot allocate I/O buffer");
@@ -432,7 +432,7 @@ initcg(int cylno, time_t utime, int fso,
acg.cg_nextfreeoff = acg.cg_clusteroff +
howmany(fragstoblks(&sblock, sblock.fs_fpg), CHAR_BIT);
}
- if (acg.cg_nextfreeoff > sblock.fs_cgsize) {
+ if (acg.cg_nextfreeoff > (unsigned)sblock.fs_cgsize) {
/*
* This should never happen as we would have had that panic
* already on file system creation
@@ -752,7 +752,7 @@ updjcg(int cylno, time_t utime, int fsi,
* needed, update the free space in the superblock.
*/
acg.cg_time = utime;
- if (cylno == sblock.fs_ncg - 1) {
+ if ((unsigned)cylno == sblock.fs_ncg - 1) {
/*
* This is still the last cylinder group.
*/
@@ -946,8 +946,8 @@ updcsloc(time_t utime, int fsi, int fso,
int ocscg, ncscg;
int blocks;
ufs2_daddr_t cbase, dupper, odupper, d, f, g;
- int ind;
- int cylno, inc;
+ int ind, inc;
+ uint cylno;
struct gfs_bpp *bp;
int i, l;
int lcs=0;
Modified: stable/7/sbin/newfs/mkfs.c
==============================================================================
--- stable/7/sbin/newfs/mkfs.c Sat Feb 27 17:36:13 2010 (r204418)
+++ stable/7/sbin/newfs/mkfs.c Sat Feb 27 17:55:29 2010 (r204419)
@@ -105,10 +105,13 @@ void
mkfs(struct partition *pp, char *fsys)
{
int fragsperinode, optimalfpg, origdensity, minfpg, lastminfpg;
- long i, j, cylno, csfrags;
+ long i, j, csfrags;
+ uint cg;
time_t utime;
quad_t sizepb;
int width;
+ ino_t maxinum;
+ int minfragsperinode; /* minimum ratio of frags to inodes */
char tmpbuf[100]; /* XXX this will break in about 2,500 years */
union {
struct fs fdummy;
@@ -161,6 +164,8 @@ mkfs(struct partition *pp, char *fsys)
if (sblock.fs_avgfpdir <= 0)
printf("illegal expected number of files per directory %d\n",
sblock.fs_avgfpdir), exit(15);
+
+restart:
/*
* collect and verify the block and fragment sizes
*/
@@ -207,6 +212,8 @@ mkfs(struct partition *pp, char *fsys)
sblock.fs_fsize, MAXFRAG, sblock.fs_bsize / MAXFRAG);
sblock.fs_fsize = sblock.fs_bsize / MAXFRAG;
}
+ if (maxbsize == 0)
+ maxbsize = bsize;
if (maxbsize < bsize || !POWEROF2(maxbsize)) {
sblock.fs_maxbsize = sblock.fs_bsize;
printf("Extent size set to %d\n", sblock.fs_maxbsize);
@@ -216,6 +223,14 @@ mkfs(struct partition *pp, char *fsys)
} else {
sblock.fs_maxbsize = maxbsize;
}
+ /*
+ * Maxcontig sets the default for the maximum number of blocks
+ * that may be allocated sequentially. With file system clustering
+ * it is possible to allocate contiguous blocks up to the maximum
+ * transfer size permitted by the controller or buffering.
+ */
+ if (maxcontig == 0)
+ maxcontig = MAX(1, MAXPHYS / bsize);
sblock.fs_maxcontig = maxcontig;
if (sblock.fs_maxcontig < sblock.fs_maxbsize / sblock.fs_bsize) {
sblock.fs_maxcontig = sblock.fs_maxbsize / sblock.fs_bsize;
@@ -306,9 +321,26 @@ mkfs(struct partition *pp, char *fsys)
* can put into each cylinder group. If this is too big, we reduce
* the density until it fits.
*/
+ maxinum = (((int64_t)(1)) << 32) - INOPB(&sblock);
+ minfragsperinode = 1 + fssize / maxinum;
+ if (density == 0) {
+ density = MAX(NFPI, minfragsperinode) * fsize;
+ } else if (density < minfragsperinode * fsize) {
+ origdensity = density;
+ density = minfragsperinode * fsize;
+ fprintf(stderr, "density increased from %d to %d\n",
+ origdensity, density);
+ }
origdensity = density;
for (;;) {
fragsperinode = MAX(numfrags(&sblock, density), 1);
+ if (fragsperinode < minfragsperinode) {
+ bsize <<= 1;
+ fsize <<= 1;
+ printf("Block size too small for a file system %s %d\n",
+ "of this size. Increasing blocksize to", bsize);
+ goto restart;
+ }
minfpg = fragsperinode * INOPB(&sblock);
if (minfpg > sblock.fs_size)
minfpg = sblock.fs_size;
@@ -397,7 +429,10 @@ mkfs(struct partition *pp, char *fsys)
if (sblock.fs_sbsize > SBLOCKSIZE)
sblock.fs_sbsize = SBLOCKSIZE;
sblock.fs_minfree = minfree;
- sblock.fs_maxbpg = maxbpg;
+ if (maxbpg == 0)
+ sblock.fs_maxbpg = MAXBLKPG(sblock.fs_bsize);
+ else
+ sblock.fs_maxbpg = maxbpg;
sblock.fs_optim = opt;
sblock.fs_cgrotor = 0;
sblock.fs_pendingblocks = 0;
@@ -459,9 +494,9 @@ mkfs(struct partition *pp, char *fsys)
if (fsdummy.fs_magic == FS_UFS1_MAGIC) {
fsdummy.fs_magic = 0;
bwrite(&disk, SBLOCK_UFS1 / disk.d_bsize, chdummy, SBLOCKSIZE);
- for (i = 0; i < fsdummy.fs_ncg; i++)
- bwrite(&disk, fsbtodb(&fsdummy, cgsblock(&fsdummy, i)),
- chdummy, SBLOCKSIZE);
+ for (cg = 0; cg < fsdummy.fs_ncg; cg++)
+ bwrite(&disk, fsbtodb(&fsdummy,
+ cgsblock(&fsdummy, cg)), chdummy, SBLOCKSIZE);
}
}
if (!Nflag)
@@ -500,11 +535,11 @@ mkfs(struct partition *pp, char *fsys)
* writing out in each cylinder group.
*/
bcopy((char *)&sblock, iobuf, SBLOCKSIZE);
- for (cylno = 0; cylno < sblock.fs_ncg; cylno++) {
- initcg(cylno, utime);
+ for (cg = 0; cg < sblock.fs_ncg; cg++) {
+ initcg(cg, utime);
j = snprintf(tmpbuf, sizeof(tmpbuf), " %jd%s",
- (intmax_t)fsbtodb(&sblock, cgsblock(&sblock, cylno)),
- cylno < (sblock.fs_ncg-1) ? "," : "");
+ (intmax_t)fsbtodb(&sblock, cgsblock(&sblock, cg)),
+ cg < (sblock.fs_ncg-1) ? "," : "");
if (j < 0)
tmpbuf[j = 0] = '\0';
if (i + j >= width) {
@@ -558,7 +593,8 @@ mkfs(struct partition *pp, char *fsys)
void
initcg(int cylno, time_t utime)
{
- long i, j, d, dlower, dupper, blkno, start;
+ long blkno, start;
+ uint i, j, d, dlower, dupper;
ufs2_daddr_t cbase, dmax;
struct ufs1_dinode *dp1;
struct ufs2_dinode *dp2;
@@ -615,7 +651,7 @@ initcg(int cylno, time_t utime)
acg.cg_nextfreeoff = acg.cg_clusteroff +
howmany(fragstoblks(&sblock, sblock.fs_fpg), CHAR_BIT);
}
- if (acg.cg_nextfreeoff > sblock.fs_cgsize) {
+ if (acg.cg_nextfreeoff > (unsigned)sblock.fs_cgsize) {
printf("Panic: cylinder group too big\n");
exit(37);
}
@@ -864,7 +900,8 @@ makedir(struct direct *protodir, int ent
ufs2_daddr_t
alloc(int size, int mode)
{
- int i, d, blkno, frag;
+ int i, blkno, frag;
+ uint d;
bread(&disk, fsbtodb(&sblock, cgtod(&sblock, 0)), (char *)&acg,
sblock.fs_cgsize);
Modified: stable/7/sbin/newfs/newfs.c
==============================================================================
--- stable/7/sbin/newfs/newfs.c Sat Feb 27 17:36:13 2010 (r204418)
+++ stable/7/sbin/newfs/newfs.c Sat Feb 27 17:55:29 2010 (r204419)
@@ -79,38 +79,6 @@ __FBSDID("$FreeBSD$");
#include "newfs.h"
-/*
- * The following two constants set the default block and fragment sizes.
- * Both constants must be a power of 2 and meet the following constraints:
- * MINBSIZE <= DESBLKSIZE <= MAXBSIZE
- * sectorsize <= DESFRAGSIZE <= DESBLKSIZE
- * DESBLKSIZE / DESFRAGSIZE <= 8
- */
-#define DFL_FRAGSIZE 2048
-#define DFL_BLKSIZE 16384
-
-/*
- * Cylinder groups may have up to MAXBLKSPERCG blocks. The actual
- * number used depends upon how much information can be stored
- * in a cylinder group map which must fit in a single file system
- * block. The default is to use as many as possible blocks per group.
- */
-#define MAXBLKSPERCG 0x7fffffff /* desired fs_fpg ("infinity") */
-
-/*
- * MAXBLKPG determines the maximum number of data blocks which are
- * placed in a single cylinder group. The default is one indirect
- * block worth of data blocks.
- */
-#define MAXBLKPG(bsize) ((bsize) / sizeof(ufs2_daddr_t))
-
-/*
- * Each file system has a number of inodes statically allocated.
- * We allocate one inode slot per NFPI fragments, expecting this
- * to be far more than we will ever need.
- */
-#define NFPI 4
-
int Lflag; /* add a volume label */
int Nflag; /* run without writing file system */
int Oflag = 2; /* file system format (1 => UFS1, 2 => UFS2) */
@@ -346,25 +314,11 @@ main(int argc, char *argv[])
fsize = MAX(DFL_FRAGSIZE, sectorsize);
if (bsize <= 0)
bsize = MIN(DFL_BLKSIZE, 8 * fsize);
- if (maxbsize == 0)
- maxbsize = bsize;
- /*
- * Maxcontig sets the default for the maximum number of blocks
- * that may be allocated sequentially. With file system clustering
- * it is possible to allocate contiguous blocks up to the maximum
- * transfer size permitted by the controller or buffering.
- */
- if (maxcontig == 0)
- maxcontig = MAX(1, MAXPHYS / bsize);
- if (density == 0)
- density = NFPI * fsize;
if (minfree < MINFREE && opt != FS_OPTSPACE) {
fprintf(stderr, "Warning: changing optimization to space ");
fprintf(stderr, "because minfree is less than %d%%\n", MINFREE);
opt = FS_OPTSPACE;
}
- if (maxbpg == 0)
- maxbpg = MAXBLKPG(bsize);
realsectorsize = sectorsize;
if (sectorsize != DEV_BSIZE) { /* XXX */
int secperblk = sectorsize / DEV_BSIZE;
Modified: stable/7/sbin/newfs/newfs.h
==============================================================================
--- stable/7/sbin/newfs/newfs.h Sat Feb 27 17:36:13 2010 (r204418)
+++ stable/7/sbin/newfs/newfs.h Sat Feb 27 17:55:29 2010 (r204419)
@@ -41,6 +41,38 @@
#include <libufs.h>
/*
+ * The following two constants set the default block and fragment sizes.
+ * Both constants must be a power of 2 and meet the following constraints:
+ * MINBSIZE <= DESBLKSIZE <= MAXBSIZE
+ * sectorsize <= DESFRAGSIZE <= DESBLKSIZE
+ * DESBLKSIZE / DESFRAGSIZE <= 8
+ */
+#define DFL_FRAGSIZE 2048
+#define DFL_BLKSIZE 16384
+
+/*
+ * Cylinder groups may have up to MAXBLKSPERCG blocks. The actual
+ * number used depends upon how much information can be stored
+ * in a cylinder group map which must fit in a single file system
+ * block. The default is to use as many as possible blocks per group.
+ */
+#define MAXBLKSPERCG 0x7fffffff /* desired fs_fpg ("infinity") */
+
+/*
+ * MAXBLKPG determines the maximum number of data blocks which are
+ * placed in a single cylinder group. The default is one indirect
+ * block worth of data blocks.
+ */
+#define MAXBLKPG(bsize) ((bsize) / sizeof(ufs2_daddr_t))
+
+/*
+ * Each file system has a number of inodes statically allocated.
+ * We allocate one inode slot per NFPI fragments, expecting this
+ * to be far more than we will ever need.
+ */
+#define NFPI 4
+
+/*
* variables set up by front end.
*/
extern int Lflag; /* add a volume label */
Modified: stable/7/sbin/tunefs/tunefs.c
==============================================================================
--- stable/7/sbin/tunefs/tunefs.c Sat Feb 27 17:36:13 2010 (r204418)
+++ stable/7/sbin/tunefs/tunefs.c Sat Feb 27 17:55:29 2010 (r204419)
@@ -286,7 +286,7 @@ main(int argc, char *argv[])
}
if (fflag) {
name = "average file size";
- if (sblock.fs_avgfilesize == fvalue) {
+ if (sblock.fs_avgfilesize == (unsigned)fvalue) {
warnx("%s remains unchanged as %d", name, fvalue);
}
else {
@@ -389,7 +389,7 @@ main(int argc, char *argv[])
}
if (sflag) {
name = "expected number of files per directory";
- if (sblock.fs_avgfpdir == svalue) {
+ if (sblock.fs_avgfpdir == (unsigned)svalue) {
warnx("%s remains unchanged as %d", name, svalue);
}
else {
Modified: stable/7/sys/ufs/ffs/ffs_alloc.c
==============================================================================
--- stable/7/sys/ufs/ffs/ffs_alloc.c Sat Feb 27 17:36:13 2010 (r204418)
+++ stable/7/sys/ufs/ffs/ffs_alloc.c Sat Feb 27 17:55:29 2010 (r204419)
@@ -88,24 +88,25 @@ __FBSDID("$FreeBSD$");
#include <ufs/ffs/fs.h>
#include <ufs/ffs/ffs_extern.h>
-typedef ufs2_daddr_t allocfcn_t(struct inode *ip, int cg, ufs2_daddr_t bpref,
+typedef ufs2_daddr_t allocfcn_t(struct inode *ip, u_int cg, ufs2_daddr_t bpref,
int size);
-static ufs2_daddr_t ffs_alloccg(struct inode *, int, ufs2_daddr_t, int);
+static ufs2_daddr_t ffs_alloccg(struct inode *, u_int, ufs2_daddr_t, int);
static ufs2_daddr_t
ffs_alloccgblk(struct inode *, struct buf *, ufs2_daddr_t);
#ifdef INVARIANTS
static int ffs_checkblk(struct inode *, ufs2_daddr_t, long);
#endif
-static ufs2_daddr_t ffs_clusteralloc(struct inode *, int, ufs2_daddr_t, int);
+static ufs2_daddr_t ffs_clusteralloc(struct inode *, u_int, ufs2_daddr_t, int);
static void ffs_clusteracct(struct ufsmount *, struct fs *, struct cg *,
ufs1_daddr_t, int);
static ino_t ffs_dirpref(struct inode *);
-static ufs2_daddr_t ffs_fragextend(struct inode *, int, ufs2_daddr_t, int, int);
+static ufs2_daddr_t ffs_fragextend(struct inode *, u_int, ufs2_daddr_t,
+ int, int);
static void ffs_fserr(struct fs *, ino_t, char *);
static ufs2_daddr_t ffs_hashalloc
- (struct inode *, int, ufs2_daddr_t, int, allocfcn_t *);
-static ufs2_daddr_t ffs_nodealloccg(struct inode *, int, ufs2_daddr_t, int);
+ (struct inode *, u_int, ufs2_daddr_t, int, allocfcn_t *);
+static ufs2_daddr_t ffs_nodealloccg(struct inode *, u_int, ufs2_daddr_t, int);
static ufs1_daddr_t ffs_mapsearch(struct fs *, struct cg *, ufs2_daddr_t, int);
static int ffs_reallocblks_ufs1(struct vop_reallocblks_args *);
static int ffs_reallocblks_ufs2(struct vop_reallocblks_args *);
@@ -140,7 +141,7 @@ ffs_alloc(ip, lbn, bpref, size, flags, c
struct fs *fs;
struct ufsmount *ump;
ufs2_daddr_t bno;
- int cg, reclaimed;
+ u_int cg, reclaimed;
static struct timeval lastfail;
static int curfail;
int64_t delta;
@@ -243,7 +244,8 @@ ffs_realloccg(ip, lbprev, bprev, bpref,
struct fs *fs;
struct buf *bp;
struct ufsmount *ump;
- int cg, request, error, reclaimed;
+ u_int cg, request, reclaimed;
+ int error;
ufs2_daddr_t bno;
static struct timeval lastfail;
static int curfail;
@@ -932,7 +934,8 @@ ffs_valloc(pvp, mode, cred, vpp)
struct timespec ts;
struct ufsmount *ump;
ino_t ino, ipref;
- int cg, error, error1;
+ u_int cg;
+ int error, error1;
static struct timeval lastfail;
static int curfail;
@@ -1042,11 +1045,11 @@ ffs_dirpref(pip)
struct inode *pip;
{
struct fs *fs;
- int cg, prefcg, dirsize, cgsize;
- int avgifree, avgbfree, avgndir, curdirsize;
- int minifree, minbfree, maxndir;
- int mincg, minndir;
- int maxcontigdirs;
+ u_int cg, prefcg, dirsize, cgsize;
+ u_int avgifree, avgbfree, avgndir, curdirsize;
+ u_int minifree, minbfree, maxndir;
+ u_int mincg, minndir;
+ u_int maxcontigdirs;
mtx_assert(UFS_MTX(pip->i_ump), MA_OWNED);
fs = pip->i_fs;
@@ -1170,8 +1173,8 @@ ffs_blkpref_ufs1(ip, lbn, indx, bap)
ufs1_daddr_t *bap;
{
struct fs *fs;
- int cg;
- int avgbfree, startcg;
+ u_int cg;
+ u_int avgbfree, startcg;
mtx_assert(UFS_MTX(ip->i_ump), MA_OWNED);
fs = ip->i_fs;
@@ -1220,8 +1223,8 @@ ffs_blkpref_ufs2(ip, lbn, indx, bap)
ufs2_daddr_t *bap;
{
struct fs *fs;
- int cg;
- int avgbfree, startcg;
+ u_int cg;
+ u_int avgbfree, startcg;
mtx_assert(UFS_MTX(ip->i_ump), MA_OWNED);
fs = ip->i_fs;
@@ -1274,14 +1277,14 @@ ffs_blkpref_ufs2(ip, lbn, indx, bap)
static ufs2_daddr_t
ffs_hashalloc(ip, cg, pref, size, allocator)
struct inode *ip;
- int cg;
+ u_int cg;
ufs2_daddr_t pref;
int size; /* size for data blocks, mode for inodes */
allocfcn_t *allocator;
{
struct fs *fs;
ufs2_daddr_t result;
- int i, icg = cg;
+ u_int i, icg = cg;
mtx_assert(UFS_MTX(ip->i_ump), MA_OWNED);
#ifdef INVARIANTS
@@ -1332,7 +1335,7 @@ ffs_hashalloc(ip, cg, pref, size, alloca
static ufs2_daddr_t
ffs_fragextend(ip, cg, bprev, osize, nsize)
struct inode *ip;
- int cg;
+ u_int cg;
ufs2_daddr_t bprev;
int osize, nsize;
{
@@ -1415,7 +1418,7 @@ fail:
static ufs2_daddr_t
ffs_alloccg(ip, cg, bpref, size)
struct inode *ip;
- int cg;
+ u_int cg;
ufs2_daddr_t bpref;
int size;
{
@@ -1585,7 +1588,7 @@ gotit:
static ufs2_daddr_t
ffs_clusteralloc(ip, cg, bpref, len)
struct inode *ip;
- int cg;
+ u_int cg;
ufs2_daddr_t bpref;
int len;
{
@@ -1709,7 +1712,7 @@ fail:
static ufs2_daddr_t
ffs_nodealloccg(ip, cg, ipref, mode)
struct inode *ip;
- int cg;
+ u_int cg;
ufs2_daddr_t ipref;
int mode;
{
@@ -1810,7 +1813,7 @@ gotit:
bdwrite(bp);
if (ibp != NULL)
bawrite(ibp);
- return (cg * fs->fs_ipg + ipref);
+ return ((ino_t)(cg * fs->fs_ipg + ipref));
}
/*
@@ -1855,7 +1858,8 @@ ffs_blkfree(ump, fs, devvp, bno, size, i
struct buf *bp;
ufs1_daddr_t fragno, cgbno;
ufs2_daddr_t cgblkno;
- int i, cg, blk, frags, bbase;
+ int i, blk, frags, bbase;
+ u_int cg;
u_int8_t *blksfree;
struct cdev *dev;
@@ -2053,7 +2057,8 @@ ffs_freefile(ump, fs, devvp, ino, mode)
struct cg *cgp;
struct buf *bp;
ufs2_daddr_t cgbno;
- int error, cg;
+ int error;
+ u_int cg;
u_int8_t *inosused;
struct cdev *dev;
@@ -2067,7 +2072,7 @@ ffs_freefile(ump, fs, devvp, ino, mode)
dev = devvp->v_rdev;
cgbno = fsbtodb(fs, cgtod(fs, cg));
}
- if ((u_int)ino >= fs->fs_ipg * fs->fs_ncg)
+ if (ino >= fs->fs_ipg * fs->fs_ncg)
panic("ffs_freefile: range: dev = %s, ino = %lu, fs = %s",
devtoname(dev), (u_long)ino, fs->fs_fsmnt);
if ((error = bread(devvp, cgbno, (int)fs->fs_cgsize, NOCRED, &bp))) {
@@ -2084,8 +2089,8 @@ ffs_freefile(ump, fs, devvp, ino, mode)
inosused = cg_inosused(cgp);
ino %= fs->fs_ipg;
if (isclr(inosused, ino)) {
- printf("dev = %s, ino = %lu, fs = %s\n", devtoname(dev),
- (u_long)ino + cg * fs->fs_ipg, fs->fs_fsmnt);
+ printf("dev = %s, ino = %u, fs = %s\n", devtoname(dev),
+ ino + cg * fs->fs_ipg, fs->fs_fsmnt);
if (fs->fs_ronly == 0)
panic("ffs_freefile: freeing free inode");
}
@@ -2120,7 +2125,8 @@ ffs_checkfreefile(fs, devvp, ino)
struct cg *cgp;
struct buf *bp;
ufs2_daddr_t cgbno;
- int ret, cg;
+ int ret;
+ u_int cg;
u_int8_t *inosused;
cg = ino_to_cg(fs, ino);
@@ -2131,7 +2137,7 @@ ffs_checkfreefile(fs, devvp, ino)
/* devvp is a normal disk device */
cgbno = fsbtodb(fs, cgtod(fs, cg));
}
- if ((u_int)ino >= fs->fs_ipg * fs->fs_ncg)
+ if (ino >= fs->fs_ipg * fs->fs_ncg)
return (1);
if (bread(devvp, cgbno, (int)fs->fs_cgsize, NOCRED, &bp)) {
brelse(bp);
Modified: stable/7/sys/ufs/ffs/fs.h
==============================================================================
--- stable/7/sys/ufs/ffs/fs.h Sat Feb 27 17:36:13 2010 (r204418)
+++ stable/7/sys/ufs/ffs/fs.h Sat Feb 27 17:55:29 2010 (r204419)
@@ -261,7 +261,7 @@ struct fs {
int32_t fs_old_time; /* last time written */
int32_t fs_old_size; /* number of blocks in fs */
int32_t fs_old_dsize; /* number of data blocks in fs */
- int32_t fs_ncg; /* number of cylinder groups */
+ u_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 */
@@ -301,7 +301,7 @@ struct fs {
int32_t fs_old_spc; /* sectors per cylinder */
int32_t fs_old_ncyl; /* cylinders in filesystem */
int32_t fs_old_cpg; /* cylinders per group */
- int32_t fs_ipg; /* inodes per group */
+ u_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_old_cstotal; /* cylinder summary information */
@@ -332,10 +332,10 @@ struct fs {
int64_t fs_dsize; /* number of data blocks in fs */
ufs2_daddr_t fs_csaddr; /* blk addr of cyl grp summary area */
int64_t fs_pendingblocks; /* (u) blocks being freed */
- int32_t fs_pendinginodes; /* (u) inodes being freed */
- int32_t fs_snapinum[FSMAXSNAP];/* list of snapshot inode numbers */
- int32_t fs_avgfilesize; /* expected average file size */
- int32_t fs_avgfpdir; /* expected # of files per directory */
+ u_int32_t fs_pendinginodes; /* (u) inodes being freed */
+ ino_t fs_snapinum[FSMAXSNAP];/* list of snapshot inode numbers */
+ u_int32_t fs_avgfilesize; /* expected average file size */
+ u_int32_t fs_avgfpdir; /* expected # of files per directory */
int32_t fs_save_cgsize; /* save real cg size to use fs_bsize */
int32_t fs_sparecon32[26]; /* reserved for future constants */
int32_t fs_flags; /* see FS_ flags below */
@@ -458,26 +458,26 @@ struct cg {
int32_t cg_firstfield; /* historic cyl groups linked list */
int32_t cg_magic; /* magic number */
int32_t cg_old_time; /* time last written */
- int32_t cg_cgx; /* we are the cgx'th cylinder group */
+ u_int32_t cg_cgx; /* we are the cgx'th cylinder group */
int16_t cg_old_ncyl; /* number of cyl's this cg */
int16_t cg_old_niblk; /* number of inode blocks this cg */
- int32_t cg_ndblk; /* number of data blocks this cg */
- struct csum cg_cs; /* cylinder summary information */
- 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 */
+ u_int32_t cg_ndblk; /* number of data blocks this cg */
+ struct csum cg_cs; /* cylinder summary information */
+ u_int32_t cg_rotor; /* position of last used block */
+ u_int32_t cg_frotor; /* position of last used frag */
+ u_int32_t cg_irotor; /* position of last used inode */
+ u_int32_t cg_frsum[MAXFRAG]; /* counts of available frags */
int32_t cg_old_btotoff; /* (int32) block totals per cylinder */
int32_t cg_old_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_niblk; /* number of inode blocks this cg */
- int32_t cg_initediblk; /* last initialized inode */
- int32_t cg_unrefs; /* number of unreferenced inodes */
+ u_int32_t cg_iusedoff; /* (u_int8) used inode map */
+ u_int32_t cg_freeoff; /* (u_int8) free block map */
+ u_int32_t cg_nextfreeoff; /* (u_int8) next available space */
+ u_int32_t cg_clustersumoff; /* (u_int32) counts of avail clusters */
+ u_int32_t cg_clusteroff; /* (u_int8) free cluster map */
+ u_int32_t cg_nclusterblks; /* number of clusters this cg */
+ u_int32_t cg_niblk; /* number of inode blocks this cg */
+ u_int32_t cg_initediblk; /* last initialized inode */
+ u_int32_t cg_unrefs; /* number of unreferenced inodes */
int32_t cg_sparecon32[2]; /* reserved for future use */
ufs_time_t cg_time; /* time last written */
int64_t cg_sparecon64[3]; /* reserved for future use */
@@ -524,11 +524,11 @@ struct cg {
* inode number to cylinder group number.
* inode number to filesystem block address.
*/
-#define ino_to_cg(fs, x) ((x) / (fs)->fs_ipg)
+#define ino_to_cg(fs, x) (((ino_t)(x)) / (fs)->fs_ipg)
#define ino_to_fsba(fs, x) \
- ((ufs2_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))
+ ((ufs2_daddr_t)(cgimin(fs, ino_to_cg(fs, (ino_t)(x))) + \
+ (blkstofrags((fs), ((((ino_t)(x)) % (fs)->fs_ipg) / INOPB(fs))))))
+#define ino_to_fsbo(fs, x) (((ino_t)(x)) % INOPB(fs))
/*
* Give cylinder group number for a filesystem block.
More information about the svn-src-all
mailing list