summaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
Diffstat
-rw-r--r--sbin/ffsinfo/ffsinfo.c89
-rw-r--r--sbin/growfs/debug.c19
-rw-r--r--sbin/growfs/growfs.c178
3 files changed, 152 insertions, 134 deletions
diff --git a/sbin/ffsinfo/ffsinfo.c b/sbin/ffsinfo/ffsinfo.c
index 7d6e935..8adada3 100644
--- a/sbin/ffsinfo/ffsinfo.c
+++ b/sbin/ffsinfo/ffsinfo.c
@@ -94,7 +94,7 @@ static char i3blk[MAXBSIZE];
static struct csum *fscs;
/* ******************************************************** PROTOTYPES ***** */
-static void rdfs(daddr_t, int, char *, int);
+static void rdfs(daddr_t, size_t, void *, int);
static void usage(void);
static struct disklabel *get_disklabel(int);
static struct dinode *ginode(ino_t, int);
@@ -105,18 +105,18 @@ static void dump_whole_inode(ino_t, int, int);
* Here we read some block(s) from disk.
*/
void
-rdfs(daddr_t bno, int size, char *bf, int fsi)
+rdfs(daddr_t bno, size_t size, void *bf, int fsi)
{
DBG_FUNC("rdfs")
- int n;
+ ssize_t n;
DBG_ENTER;
if (lseek(fsi, (off_t)bno * DEV_BSIZE, 0) < 0) {
err(33, "rdfs: seek error: %ld", (long)bno);
}
- n = read(fsi, bf, (size_t)size);
- if (n != size) {
+ n = read(fsi, bf, size);
+ if (n != (ssize_t)size) {
err(34, "rdfs: read error: %ld", (long)bno);
}
@@ -296,7 +296,7 @@ main(int argc, char **argv)
/*
* Read the current superblock.
*/
- rdfs((daddr_t)(SBOFF/DEV_BSIZE), SBSIZE, (char *)&(sblock), fsi);
+ rdfs((daddr_t)(SBOFF/DEV_BSIZE), (size_t)SBSIZE, (void *)&sblock, fsi);
if (sblock.fs_magic != FS_MAGIC) {
errx(1, "superblock not recognized");
}
@@ -326,7 +326,8 @@ main(int argc, char **argv)
}
if (cfg_lv & 0x004) {
- fscs = (struct csum *)calloc(1, (size_t)sblock.fs_cssize);
+ fscs = (struct csum *)calloc((size_t)1,
+ (size_t)sblock.fs_cssize);
if(fscs == NULL) {
errx(1, "calloc failed");
}
@@ -336,9 +337,9 @@ main(int argc, char **argv)
*/
for (i = 0; i < sblock.fs_cssize; i += sblock.fs_bsize) {
rdfs(fsbtodb(&sblock, sblock.fs_csaddr +
- numfrags(&sblock, i)), sblock.fs_cssize - i <
+ numfrags(&sblock, i)), (size_t)(sblock.fs_cssize-i<
sblock.fs_bsize ? sblock.fs_cssize - i :
- sblock.fs_bsize, ((char *)fscs) + i, fsi);
+ sblock.fs_bsize), (void *)(((char *)fscs)+i), fsi);
}
dbg_csp=fscs;
@@ -346,8 +347,8 @@ main(int argc, char **argv)
* ... and dump it.
*/
for(dbg_csc=0; dbg_csc<sblock.fs_ncg; dbg_csc++) {
- snprintf(dbg_line, 80, "%d. csum in fscs",
- dbg_csc);
+ snprintf(dbg_line, sizeof(dbg_line),
+ "%d. csum in fscs", dbg_csc);
DBG_DUMP_CSUM(&sblock,
dbg_line,
dbg_csp++);
@@ -358,21 +359,21 @@ main(int argc, char **argv)
* For each requested cylinder group ...
*/
for(cylno=cg_start; cylno<cg_stop; cylno++) {
- snprintf(dbg_line, 80, "cgr %d", cylno);
+ snprintf(dbg_line, sizeof(dbg_line), "cgr %d", cylno);
if(cfg_lv & 0x002) {
/*
* ... dump the superblock copies ...
*/
rdfs(fsbtodb(&sblock, cgsblock(&sblock, cylno)),
- SBSIZE, (char *)&osblock, fsi);
+ (size_t)SBSIZE, (void *)&osblock, fsi);
DBG_DUMP_FS(&osblock,
dbg_line);
}
/*
* ... read the cylinder group and dump whatever was requested.
*/
- rdfs(fsbtodb(&sblock, cgtod(&sblock, cylno)), sblock.fs_cgsize,
- (char *)&acg, fsi);
+ rdfs(fsbtodb(&sblock, cgtod(&sblock, cylno)),
+ (size_t)sblock.fs_cgsize, (void *)&acg, fsi);
if(cfg_lv & 0x008) {
DBG_DUMP_CG(&sblock,
dbg_line,
@@ -452,7 +453,7 @@ dump_whole_inode(ino_t inode, int fsi, int level)
/*
* Dump the main inode structure.
*/
- snprintf(comment, 80, "Inode 0x%08x", inode);
+ snprintf(comment, sizeof(comment), "Inode 0x%08x", inode);
if (level & 0x100) {
DBG_DUMP_INO(&sblock,
comment,
@@ -472,9 +473,10 @@ dump_whole_inode(ino_t inode, int fsi, int level)
/*
* Dump single indirect block.
*/
- rdfs(fsbtodb(&sblock, ino->di_ib[0]), sblock.fs_bsize, i1blk,
- fsi);
- snprintf(comment, 80, "Inode 0x%08x: indirect 0", inode);
+ rdfs(fsbtodb(&sblock, ino->di_ib[0]), (size_t)sblock.fs_bsize,
+ (void *)&i1blk, fsi);
+ snprintf(comment, sizeof(comment), "Inode 0x%08x: indirect 0",
+ inode);
DBG_DUMP_IBLK(&sblock,
comment,
i1blk,
@@ -485,21 +487,22 @@ dump_whole_inode(ino_t inode, int fsi, int level)
/*
* Dump double indirect blocks.
*/
- rdfs(fsbtodb(&sblock, ino->di_ib[1]), sblock.fs_bsize, i2blk,
- fsi);
- snprintf(comment, 80, "Inode 0x%08x: indirect 1", inode);
+ rdfs(fsbtodb(&sblock, ino->di_ib[1]), (size_t)sblock.fs_bsize,
+ (void *)&i2blk, fsi);
+ snprintf(comment, sizeof(comment), "Inode 0x%08x: indirect 1",
+ inode);
DBG_DUMP_IBLK(&sblock,
comment,
i2blk,
howmany(rb, howmany(sblock.fs_bsize, sizeof(ufs_daddr_t))));
for(ind2ctr=0; ((ind2ctr < howmany(sblock.fs_bsize,
sizeof(ufs_daddr_t)))&&(rb>0)); ind2ctr++) {
- ind2ptr=&((ufs_daddr_t *)&i2blk)[ind2ctr];
+ ind2ptr=&((ufs_daddr_t *)(void *)&i2blk)[ind2ctr];
- rdfs(fsbtodb(&sblock, *ind2ptr), sblock.fs_bsize,
- i1blk, fsi);
- snprintf(comment, 80, "Inode 0x%08x: indirect 1->%d",
- inode, ind2ctr);
+ rdfs(fsbtodb(&sblock, *ind2ptr),
+ (size_t)sblock.fs_bsize, (void *)&i1blk, fsi);
+ snprintf(comment, sizeof(comment),
+ "Inode 0x%08x: indirect 1->%d", inode, ind2ctr);
DBG_DUMP_IBLK(&sblock,
comment,
i1blk,
@@ -511,9 +514,10 @@ dump_whole_inode(ino_t inode, int fsi, int level)
/*
* Dump triple indirect blocks.
*/
- rdfs(fsbtodb(&sblock, ino->di_ib[2]), sblock.fs_bsize, i3blk,
- fsi);
- snprintf(comment, 80, "Inode 0x%08x: indirect 2", inode);
+ rdfs(fsbtodb(&sblock, ino->di_ib[2]), (size_t)sblock.fs_bsize,
+ (void *)&i3blk, fsi);
+ snprintf(comment, sizeof(comment), "Inode 0x%08x: indirect 2",
+ inode);
#define SQUARE(a) ((a)*(a))
DBG_DUMP_IBLK(&sblock,
comment,
@@ -523,12 +527,12 @@ dump_whole_inode(ino_t inode, int fsi, int level)
#undef SQUARE
for(ind3ctr=0; ((ind3ctr < howmany(sblock.fs_bsize,
sizeof(ufs_daddr_t)))&&(rb>0)); ind3ctr ++) {
- ind3ptr=&((ufs_daddr_t *)&i3blk)[ind3ctr];
+ ind3ptr=&((ufs_daddr_t *)(void *)&i3blk)[ind3ctr];
- rdfs(fsbtodb(&sblock, *ind3ptr), sblock.fs_bsize,
- i2blk, fsi);
- snprintf(comment, 80, "Inode 0x%08x: indirect 2->%d",
- inode, ind3ctr);
+ rdfs(fsbtodb(&sblock, *ind3ptr),
+ (size_t)sblock.fs_bsize, (void *)&i2blk, fsi);
+ snprintf(comment, sizeof(comment),
+ "Inode 0x%08x: indirect 2->%d", inode, ind3ctr);
DBG_DUMP_IBLK(&sblock,
comment,
i2blk,
@@ -536,11 +540,12 @@ dump_whole_inode(ino_t inode, int fsi, int level)
howmany(sblock.fs_bsize, sizeof(ufs_daddr_t))));
for(ind2ctr=0; ((ind2ctr < howmany(sblock.fs_bsize,
sizeof(ufs_daddr_t)))&&(rb>0)); ind2ctr ++) {
- ind2ptr=&((ufs_daddr_t *)&i2blk)[ind2ctr];
-
+ ind2ptr=&((ufs_daddr_t *)(void *)&i2blk)
+ [ind2ctr];
rdfs(fsbtodb(&sblock, *ind2ptr),
- sblock.fs_bsize, i1blk, fsi);
- snprintf(comment, 80,
+ (size_t)sblock.fs_bsize, (void *)&i1blk,
+ fsi);
+ snprintf(comment, sizeof(comment),
"Inode 0x%08x: indirect 2->%d->%d", inode,
ind3ctr, ind3ctr);
DBG_DUMP_IBLK(&sblock,
@@ -621,7 +626,7 @@ ginode(ino_t inumber, int fsi)
DBG_ENTER;
- pi=(struct dinode *)ablk;
+ pi=(struct dinode *)(void *)ablk;
if (startinum == 0 || inumber < startinum ||
inumber >= startinum + INOPB(&sblock)) {
/*
@@ -629,8 +634,8 @@ ginode(ino_t inumber, int fsi)
* disk now.
*/
iblk = ino_to_fsba(&sblock, inumber);
- rdfs(fsbtodb(&sblock, iblk), sblock.fs_bsize, (char *)&ablk,
- fsi);
+ rdfs(fsbtodb(&sblock, iblk), (size_t)sblock.fs_bsize,
+ (void *)&ablk, fsi);
startinum = (inumber / INOPB(&sblock)) * INOPB(&sblock);
}
diff --git a/sbin/growfs/debug.c b/sbin/growfs/debug.c
index eb836e5..53ec674 100644
--- a/sbin/growfs/debug.c
+++ b/sbin/growfs/debug.c
@@ -155,8 +155,8 @@ dbg_dump_fs(struct fs *sb, const char *comment)
sb->fs_cgoffset);
fprintf(dbg_log, "cgmask int32_t 0x%08x\n",
sb->fs_cgmask);
- fprintf(dbg_log, "time time_t %10lu\n",
- sb->fs_time);
+ fprintf(dbg_log, "time time_t %10u\n",
+ (unsigned int)sb->fs_time);
fprintf(dbg_log, "size int32_t 0x%08x\n",
sb->fs_size);
fprintf(dbg_log, "dsize int32_t 0x%08x\n",
@@ -330,7 +330,8 @@ dbg_dump_cg(const char *comment, struct cg *cgr)
indent++;
fprintf(dbg_log, "magic int32_t 0x%08x\n", cgr->cg_magic);
- fprintf(dbg_log, "time time_t %10lu\n", cgr->cg_time);
+ fprintf(dbg_log, "time time_t %10u\n", (unsigned int)
+ cgr->cg_time);
fprintf(dbg_log, "cgx int32_t 0x%08x\n", cgr->cg_cgx);
fprintf(dbg_log, "ncyl int16_t 0x%04x\n", cgr->cg_ncyl);
fprintf(dbg_log, "niblk int16_t 0x%04x\n", cgr->cg_niblk);
@@ -530,7 +531,7 @@ void
dbg_dump_clsum(struct fs *sb, const char *comment, struct cg *cgr)
{
int j;
- long *lp;
+ int *ip;
if(!dbg_log) {
return;
@@ -540,9 +541,9 @@ dbg_dump_clsum(struct fs *sb, const char *comment, struct cg *cgr)
fprintf(dbg_log, "# %d@%lx: %s\n", indent, (unsigned long)cgr, comment);
indent++;
- lp=(long *)cg_clustersum(cgr);
+ ip=(int *)cg_clustersum(cgr);
for(j=0; j<=sb->fs_contigsumsize; j++) {
- fprintf(dbg_log, "%02d: %8ld\n", j, *lp++);
+ fprintf(dbg_log, "%02d: %8d\n", j, *ip++);
}
indent--;
@@ -559,7 +560,7 @@ void
dbg_dump_sptbl(struct fs *sb, const char *comment, struct cg *cgr)
{
int j,k;
- long *lp;
+ int *ip;
if(!dbg_log) {
return;
@@ -570,9 +571,9 @@ dbg_dump_sptbl(struct fs *sb, const char *comment, struct cg *cgr)
fprintf(dbg_log, "# %d@%lx: %s\n", indent, (unsigned long)cgr, comment);
indent++;
- lp=(long *)cg_blktot(cgr);
+ ip=(int *)cg_blktot(cgr);
for(j=0; j<sb->fs_cpg; j++) {
- fprintf(dbg_log, "%2d: %5ld = ", j, *lp++);
+ fprintf(dbg_log, "%2d: %5d = ", j, *ip++);
for(k=0; k<sb->fs_nrpos; k++) {
fprintf(dbg_log, "%4d", cg_blks(sb, cgr, j)[k]);
if(k<sb->fs_nrpos-1) {
diff --git a/sbin/growfs/growfs.c b/sbin/growfs/growfs.c
index 370344a..1e8e85f 100644
--- a/sbin/growfs/growfs.c
+++ b/sbin/growfs/growfs.c
@@ -120,30 +120,31 @@ struct gfs_bpp {
daddr_t new; /* new block number */
#define GFS_FL_FIRST 1
#define GFS_FL_LAST 2
- unsigned long flags; /* special handling required */
+ unsigned int flags; /* special handling required */
int found; /* how many references were updated */
};
/* ******************************************************** PROTOTYPES ***** */
-static void rdfs(daddr_t, int, char *, int);
-static void wtfs(daddr_t, int, char *, int, int);
+static void growfs(int, int, unsigned int);
+static void rdfs(daddr_t, size_t, void *, int);
+static void wtfs(daddr_t, size_t, void *, int, unsigned int);
static daddr_t alloc(void);
static int charsperline(void);
static void usage(void);
static int isblock(struct fs *, unsigned char *, int);
static void clrblock(struct fs *, unsigned char *, int);
static void setblock(struct fs *, unsigned char *, int);
-static void initcg(int, time_t, int, int);
-static void updjcg(int, time_t, int, int, int);
-static void updcsloc(time_t, int, int, int);
+static void initcg(int, time_t, int, unsigned int);
+static void updjcg(int, time_t, int, int, unsigned int);
+static void updcsloc(time_t, int, int, unsigned int);
static struct disklabel *get_disklabel(int);
-static void return_disklabel(int, struct disklabel *, int);
+static void return_disklabel(int, struct disklabel *, unsigned int);
static struct dinode *ginode(ino_t, int, int);
static void frag_adjust(daddr_t, int);
static void cond_bl_upd(ufs_daddr_t *, struct gfs_bpp *,
- enum pointer_source, int, int);
+ enum pointer_source, int, unsigned int);
static void updclst(int);
-static void updrefs(int, ino_t, struct gfs_bpp *, int, int, int);
+static void updrefs(int, ino_t, struct gfs_bpp *, int, int, unsigned int);
/* ************************************************************ growfs ***** */
/*
@@ -158,11 +159,11 @@ static void updrefs(int, ino_t, struct gfs_bpp *, int, int, int);
* copies.
*/
static void
-growfs(int fsi, int fso, int Nflag)
+growfs(int fsi, int fso, unsigned int Nflag)
{
DBG_FUNC("growfs")
- long i;
- long cylno, j;
+ int i;
+ int cylno, j;
time_t utime;
int width;
char tmpbuf[100];
@@ -185,14 +186,14 @@ growfs(int fsi, int fso, int Nflag)
/*
* Get the cylinder summary into the memory.
*/
- fscs = (struct csum *)calloc(1, (size_t)sblock.fs_cssize);
+ fscs = (struct csum *)calloc((size_t)1, (size_t)sblock.fs_cssize);
if(fscs == NULL) {
errx(1, "calloc failed");
}
for (i = 0; i < osblock.fs_cssize; i += osblock.fs_bsize) {
rdfs(fsbtodb(&osblock, osblock.fs_csaddr +
- numfrags(&osblock, i)), MIN(osblock.fs_cssize - i,
- osblock.fs_bsize), ((char *)fscs) + i, fsi);
+ numfrags(&osblock, i)), (size_t)MIN(osblock.fs_cssize - i,
+ osblock.fs_bsize), (void *)(((char *)fscs)+i), fsi);
}
#ifdef FS_DEBUG
@@ -203,7 +204,8 @@ growfs(int fsi, int fso, int Nflag)
dbg_csp=fscs;
for(dbg_csc=0; dbg_csc<osblock.fs_ncg; dbg_csc++) {
- snprintf(dbg_line, 80, "%d. old csum in old location", dbg_csc);
+ snprintf(dbg_line, sizeof(dbg_line),
+ "%d. old csum in old location", dbg_csc);
DBG_DUMP_CSUM(&osblock,
dbg_line,
dbg_csp++);
@@ -244,8 +246,8 @@ growfs(int fsi, int fso, int Nflag)
*/
for (cylno = osblock.fs_ncg; cylno < sblock.fs_ncg; cylno++) {
initcg(cylno, utime, fso, Nflag);
- j = sprintf(tmpbuf, " %ld%s",
- fsbtodb(&sblock, cgsblock(&sblock, cylno)),
+ j = sprintf(tmpbuf, " %d%s",
+ (int)fsbtodb(&sblock, cgsblock(&sblock, cylno)),
cylno < (sblock.fs_ncg-1) ? "," : "" );
if (i + j >= width) {
printf("\n");
@@ -268,8 +270,8 @@ growfs(int fsi, int fso, int Nflag)
*/
for (i = 0; i < sblock.fs_cssize; i += sblock.fs_bsize) {
wtfs(fsbtodb(&sblock, sblock.fs_csaddr + numfrags(&sblock, i)),
- MIN(sblock.fs_cssize - i, sblock.fs_bsize),
- ((char *)fscs) + i, fso, Nflag);
+ (size_t)MIN(sblock.fs_cssize - i, sblock.fs_bsize),
+ (void *)(((char *)fscs) + i), fso, Nflag);
}
DBG_PRINT0("fscs written\n");
@@ -281,7 +283,8 @@ growfs(int fsi, int fso, int Nflag)
dbg_csp=fscs;
for(dbg_csc=0; dbg_csc<sblock.fs_ncg; dbg_csc++) {
- snprintf(dbg_line, 80, "%d. new csum in new location", dbg_csc);
+ snprintf(dbg_line, sizeof(dbg_line),
+ "%d. new csum in new location", dbg_csc);
DBG_DUMP_CSUM(&sblock,
dbg_line,
dbg_csp++);
@@ -293,7 +296,8 @@ growfs(int fsi, int fso, int Nflag)
* Now write the new superblock back to disk.
*/
sblock.fs_time = utime;
- wtfs((int)SBOFF / DEV_BSIZE, SBSIZE, (char *)&sblock, fso, Nflag);
+ wtfs((daddr_t)(SBOFF / DEV_BSIZE), (size_t)SBSIZE, (void *)&sblock,
+ fso, Nflag);
DBG_PRINT0("sblock written\n");
DBG_DUMP_FS(&sblock,
"new initial sblock");
@@ -335,7 +339,7 @@ growfs(int fsi, int fso, int Nflag)
*/
for (cylno = 0; cylno < sblock.fs_ncg; cylno++) {
wtfs(fsbtodb(&sblock, cgsblock(&sblock, cylno)),
- SBSIZE, (char *)&sblock, fso, Nflag);
+ (size_t)SBSIZE, (void *)&sblock, fso, Nflag);
}
DBG_PRINT0("sblock copies written\n");
DBG_DUMP_FS(&sblock,
@@ -353,14 +357,14 @@ growfs(int fsi, int fso, int Nflag)
* provisions for that case are removed here.
*/
static void
-initcg(int cylno, time_t utime, int fso, int Nflag)
+initcg(int cylno, time_t utime, int fso, unsigned int Nflag)
{
DBG_FUNC("initcg")
daddr_t cbase, d, dlower, dupper, dmax, blkno;
- long i;
+ int i;
register struct csum *cs;
#ifdef FSIRAND
- long j;
+ int j;
#endif
DBG_ENTER;
@@ -375,7 +379,7 @@ initcg(int cylno, time_t utime, int fso, int Nflag)
}
dlower = cgsblock(&sblock, cylno) - cbase;
dupper = cgdmin(&sblock, cylno) - cbase;
- if (cylno == 0) {
+ if (cylno == 0) { /* XXX fscs may be relocated */
dupper += howmany(sblock.fs_cssize, sblock.fs_fsize);
}
cs = fscs + cylno;
@@ -412,7 +416,7 @@ initcg(int cylno, time_t utime, int fso, int Nflag)
acg.cg_nextfreeoff = acg.cg_clusteroff + howmany
(sblock.fs_cpg * sblock.fs_spc / NSPB(&sblock), NBBY);
}
- if (acg.cg_nextfreeoff-(long)(&acg.cg_firstfield) > sblock.fs_cgsize) {
+ if (acg.cg_nextfreeoff-(int)(&acg.cg_firstfield) > sblock.fs_cgsize) {
/*
* XXX This should never happen as we would have had that panic
* already on filesystem creation
@@ -432,7 +436,7 @@ initcg(int cylno, time_t utime, int fso, int Nflag)
}
#endif
wtfs(fsbtodb(&sblock, cgimin(&sblock, cylno) + i),
- sblock.fs_bsize, (char *)zino, fso, Nflag);
+ (size_t)sblock.fs_bsize, (void *)zino, fso, Nflag);
}
for (d = 0; d < dlower; d += sblock.fs_frag) {
blkno = d / sblock.fs_frag;
@@ -510,7 +514,7 @@ initcg(int cylno, time_t utime, int fso, int Nflag)
sblock.fs_cstotal.cs_nifree += acg.cg_cs.cs_nifree;
*cs = acg.cg_cs;
wtfs(fsbtodb(&sblock, cgtod(&sblock, cylno)),
- sblock.fs_bsize, (char *)&acg, fso, Nflag);
+ (size_t)sblock.fs_bsize, (void *)&acg, fso, Nflag);
DBG_DUMP_CG(&sblock,
"new cg",
&acg);
@@ -589,7 +593,7 @@ frag_adjust(daddr_t frag, int sign)
*/
static void
cond_bl_upd(ufs_daddr_t *block, struct gfs_bpp *field,
- enum pointer_source source, int fso, int Nflag)
+ enum pointer_source source, int fso, unsigned int Nflag)
{
DBG_FUNC("cond_bl_upd")
struct gfs_bpp *f;
@@ -639,7 +643,8 @@ cond_bl_upd(ufs_daddr_t *block, struct gfs_bpp *field,
* implement copy on write here in case
* of active snapshots.
*/
- wtfs(dst, sblock.fs_bsize, src, fso, Nflag);
+ wtfs(dst, (size_t)sblock.fs_bsize, (void *)src,
+ fso, Nflag);
}
/*
@@ -667,7 +672,7 @@ cond_bl_upd(ufs_daddr_t *block, struct gfs_bpp *field,
* tables and cluster summary during all those operations.
*/
static void
-updjcg(int cylno, time_t utime, int fsi, int fso, int Nflag)
+updjcg(int cylno, time_t utime, int fsi, int fso, unsigned int Nflag)
{
DBG_FUNC("updjcg")
daddr_t cbase, dmax, dupper;
@@ -681,8 +686,8 @@ updjcg(int cylno, time_t utime, int fsi, int fso, int Nflag)
* Read the former last (joining) cylinder group from disk, and make
* a copy.
*/
- rdfs(fsbtodb(&osblock, cgtod(&osblock, cylno)), osblock.fs_cgsize,
- (char *)&aocg, fsi);
+ rdfs(fsbtodb(&osblock, cgtod(&osblock, cylno)),
+ (size_t)osblock.fs_cgsize, (void *)&aocg, fsi);
DBG_PRINT0("jcg read\n");
DBG_DUMP_CG(&sblock,
"old joining cg",
@@ -701,8 +706,8 @@ updjcg(int cylno, time_t utime, int fsi, int fso, int Nflag)
if(cgbase(&osblock, cylno+1) == osblock.fs_size) {
acg.cg_ncyl=sblock.fs_cpg;
- wtfs(fsbtodb(&sblock, cgtod(&sblock, cylno)), sblock.fs_cgsize,
- (char *)&acg, fso, Nflag);
+ wtfs(fsbtodb(&sblock, cgtod(&sblock, cylno)),
+ (size_t)sblock.fs_cgsize, (void *)&acg, fso, Nflag);
DBG_PRINT0("jcg written\n");
DBG_DUMP_CG(&sblock,
"new joining cg",
@@ -720,7 +725,7 @@ updjcg(int cylno, time_t utime, int fsi, int fso, int Nflag)
if (dmax > sblock.fs_size)
dmax = sblock.fs_size;
dupper = cgdmin(&sblock, cylno) - cbase;
- if (cylno == 0) {
+ if (cylno == 0) { /* XXX fscs may be relocated */
dupper += howmany(sblock.fs_cssize, sblock.fs_fsize);
}
@@ -891,8 +896,8 @@ updjcg(int cylno, time_t utime, int fsi, int fso, int Nflag)
/*
* Write the updated "joining" cylinder group back to disk.
*/
- wtfs(fsbtodb(&sblock, cgtod(&sblock, cylno)), sblock.fs_cgsize,
- (char *)&acg, fso, Nflag);
+ wtfs(fsbtodb(&sblock, cgtod(&sblock, cylno)), (size_t)sblock.fs_cgsize,
+ (void *)&acg, fso, Nflag);
DBG_PRINT0("jcg written\n");
DBG_DUMP_CG(&sblock,
"new joining cg",
@@ -920,7 +925,7 @@ updjcg(int cylno, time_t utime, int fsi, int fso, int Nflag)
* completely avoid implementing copy on write if we stick to method (2) only.
*/
static void
-updcsloc(time_t utime, int fsi, int fso, int Nflag)
+updcsloc(time_t utime, int fsi, int fso, unsigned int Nflag)
{
DBG_FUNC("updcsloc")
struct csum *cs;
@@ -952,8 +957,8 @@ updcsloc(time_t utime, int fsi, int fso, int Nflag)
/*
* Read original cylinder group from disk, and make a copy.
*/
- rdfs(fsbtodb(&osblock, cgtod(&osblock, ocscg)), osblock.fs_cgsize,
- (char *)&aocg, fsi);
+ rdfs(fsbtodb(&osblock, cgtod(&osblock, ocscg)),
+ (size_t)osblock.fs_cgsize, (void *)&aocg, fsi);
DBG_PRINT0("oscg read\n");
DBG_DUMP_CG(&sblock,
"old summary cg",
@@ -1116,8 +1121,8 @@ updcsloc(time_t utime, int fsi, int fso, int Nflag)
* Now write the former cylinder group containing the cylinder
* summary back to disk.
*/
- wtfs(fsbtodb(&sblock, cgtod(&sblock, ocscg)), sblock.fs_cgsize,
- (char *)&acg, fso, Nflag);
+ wtfs(fsbtodb(&sblock, cgtod(&sblock, ocscg)),
+ (size_t)sblock.fs_cgsize, (void *)&acg, fso, Nflag);
DBG_PRINT0("oscg written\n");
DBG_DUMP_CG(&sblock,
"old summary cg",
@@ -1136,7 +1141,7 @@ updcsloc(time_t utime, int fsi, int fso, int Nflag)
* summary from disk, and make a copy.
*/
rdfs(fsbtodb(&sblock, cgtod(&sblock, ncscg)),
- sblock.fs_cgsize, (char *)&aocg, fsi);
+ (size_t)sblock.fs_cgsize, (void *)&aocg, fsi);
DBG_PRINT0("nscg read\n");
DBG_DUMP_CG(&sblock,
"new summary cg",
@@ -1211,8 +1216,8 @@ updcsloc(time_t utime, int fsi, int fso, int Nflag)
* Write the new cylinder group containing the cylinder summary
* back to disk.
*/
- wtfs(fsbtodb(&sblock, cgtod(&sblock, ncscg)), sblock.fs_cgsize,
- (char *)&acg, fso, Nflag);
+ wtfs(fsbtodb(&sblock, cgtod(&sblock, ncscg)),
+ (size_t)sblock.fs_cgsize, (void *)&acg, fso, Nflag);
DBG_PRINT0("nscg written\n");
DBG_DUMP_CG(&sblock,
"new summary cg",
@@ -1470,9 +1475,9 @@ updcsloc(time_t utime, int fsi, int fso, int Nflag)
* in the case we have any active snapshots.
*/
rdfs(fsbtodb(&sblock, bp[i].old*sblock.fs_frag),
- sblock.fs_bsize, (char *)&ablk, fsi);
+ (size_t)sblock.fs_bsize, (void *)&ablk, fsi);
wtfs(fsbtodb(&sblock, bp[i].new*sblock.fs_frag),
- sblock.fs_bsize, (char *)&ablk, fso, Nflag);
+ (size_t)sblock.fs_bsize, (void *)&ablk, fso, Nflag);
DBG_DUMP_HEX(&sblock,
"copied full block",
(unsigned char *)&ablk);
@@ -1524,8 +1529,8 @@ updcsloc(time_t utime, int fsi, int fso, int Nflag)
/*
* Write summary cylinder group back to disk.
*/
- wtfs(fsbtodb(&sblock, cgtod(&sblock, ocscg)), sblock.fs_cgsize,
- (char *)&acg, fso, Nflag);
+ wtfs(fsbtodb(&sblock, cgtod(&sblock, ocscg)), (size_t)sblock.fs_cgsize,
+ (void *)&acg, fso, Nflag);
DBG_PRINT0("scg written\n");
DBG_DUMP_CG(&sblock,
"new summary cg",
@@ -1540,18 +1545,18 @@ updcsloc(time_t utime, int fsi, int fso, int Nflag)
* Here we read some block(s) from disk.
*/
static void
-rdfs(daddr_t bno, int size, char *bf, int fsi)
+rdfs(daddr_t bno, size_t size, void *bf, int fsi)
{
DBG_FUNC("rdfs")
- int n;
+ ssize_t n;
DBG_ENTER;
if (lseek(fsi, (off_t)bno * DEV_BSIZE, 0) < 0) {
err(33, "rdfs: seek error: %ld", (long)bno);
}
- n = read(fsi, bf, (size_t)size);
- if (n != size) {
+ n = read(fsi, bf, size);
+ if (n != (ssize_t)size) {
err(34, "rdfs: read error: %ld", (long)bno);
}
@@ -1564,10 +1569,10 @@ rdfs(daddr_t bno, int size, char *bf, int fsi)
* Here we write some block(s) to disk.
*/
static void
-wtfs(daddr_t bno, int size, char *bf, int fso, int Nflag)
+wtfs(daddr_t bno, size_t size, void *bf, int fso, unsigned int Nflag)
{
DBG_FUNC("wtfs")
- int n;
+ ssize_t n;
DBG_ENTER;
@@ -1578,8 +1583,8 @@ wtfs(daddr_t bno, int size, char *bf, int fso, int Nflag)
if (lseek(fso, (off_t)bno * DEV_BSIZE, SEEK_SET) < 0) {
err(35, "wtfs: seek error: %ld", (long)bno);
}
- n = write(fso, bf, (size_t)size);
- if (n != size) {
+ n = write(fso, bf, size);
+ if (n != (ssize_t)size) {
err(36, "wtfs: write error: %ld", (long)bno);
}
@@ -1848,7 +1853,7 @@ ginode(ino_t inumber, int fsi, int cg)
DBG_ENTER;
- pi=(struct dinode *)ablk;
+ pi=(struct dinode *)(void *)ablk;
inumber+=(cg * sblock.fs_ipg);
if (startinum == 0 || inumber < startinum ||
inumber >= startinum + INOPB(&sblock)) {
@@ -1858,7 +1863,7 @@ ginode(ino_t inumber, int fsi, int cg)
*/
iblk = ino_to_fsba(&sblock, inumber);
in_src=fsbtodb(&sblock, iblk);
- rdfs(in_src, sblock.fs_bsize, (char *)&ablk, fsi);
+ rdfs(in_src, (size_t)sblock.fs_bsize, (void *)&ablk, fsi);
startinum = (inumber / INOPB(&sblock)) * INOPB(&sblock);
}
@@ -1926,9 +1931,9 @@ main(int argc, char **argv)
DBG_FUNC("main")
char *device, *special, *cp;
char ch;
- unsigned long size=0;
+ unsigned int size=0;
size_t len;
- int Nflag=0;
+ unsigned int Nflag=0;
int ExpertFlag=0;
struct stat st;
struct disklabel *lp;
@@ -2056,7 +2061,8 @@ main(int argc, char **argv)
/*
* Read the current superblock, and take a backup.
*/
- rdfs((daddr_t)(SBOFF/DEV_BSIZE), SBSIZE, (char *)&(osblock), fsi);
+ rdfs((daddr_t)(SBOFF/DEV_BSIZE), (size_t)SBSIZE, (void *)&(osblock),
+ fsi);
if (osblock.fs_magic != FS_MAGIC) {
errx(1, "superblock not recognized");
}
@@ -2073,7 +2079,7 @@ main(int argc, char **argv)
sblock.fs_size = dbtofsb(&osblock, pp->p_size);
if (size != 0) {
if (size > pp->p_size){
- errx(1, "There is not enough space (%d < %ld)",
+ errx(1, "There is not enough space (%d < %d)",
pp->p_size, size);
}
sblock.fs_size = dbtofsb(&osblock, size);
@@ -2110,7 +2116,7 @@ main(int argc, char **argv)
printf("We strongly recommend you to make a backup "
"before growing the Filesystem\n\n"
" Did you backup your data (Yes/No) ? ");
- fgets(reply, sizeof(reply), stdin);
+ fgets(reply, (int)sizeof(reply), stdin);
if (strcmp(reply, "Yes\n")){
printf("\n Nothing done \n");
exit (0);
@@ -2124,7 +2130,8 @@ main(int argc, char **argv)
* later on realize we have to abort our operation, on that block
* there should be no data, so we can't destroy something yet.
*/
- wtfs((daddr_t)pp->p_size-1, DEV_BSIZE, (char *)&sblock, fso, Nflag);
+ wtfs((daddr_t)pp->p_size-1, (size_t)DEV_BSIZE, (void *)&sblock, fso,
+ Nflag);
/*
* Now calculate new superblock values and check for reasonable
@@ -2215,7 +2222,7 @@ main(int argc, char **argv)
* Write the updated disklabel back to disk.
*/
static void
-return_disklabel(int fd, struct disklabel *lp, int Nflag)
+return_disklabel(int fd, struct disklabel *lp, unsigned int Nflag)
{
DBG_FUNC("return_disklabel")
u_short sum;
@@ -2345,7 +2352,8 @@ updclst(int block)
* cylinder group.
*/
static void
-updrefs(int cg, ino_t in, struct gfs_bpp *bp, int fsi, int fso, int Nflag)
+updrefs(int cg, ino_t in, struct gfs_bpp *bp, int fsi, int fso, unsigned int
+ Nflag)
{
DBG_FUNC("updrefs")
unsigned int ictr, ind2ctr, ind3ctr;
@@ -2405,11 +2413,11 @@ updrefs(int cg, ino_t in, struct gfs_bpp *bp, int fsi, int fso, int Nflag)
*/
cond_bl_upd(&(ino->di_ib[0]), bp, GFS_PS_INODE, fso, Nflag);
i1_src=fsbtodb(&sblock, ino->di_ib[0]);
- rdfs(i1_src, sblock.fs_bsize, (char *)&i1blk, fsi);
+ rdfs(i1_src, (size_t)sblock.fs_bsize, (void *)&i1blk, fsi);
for(ictr=0; ictr < MIN(howmany(sblock.fs_bsize,
sizeof(ufs_daddr_t)), (unsigned int)remaining_blocks);
ictr++) {
- iptr=&((ufs_daddr_t *)&i1blk)[ictr];
+ iptr=&((ufs_daddr_t *)(void *)&i1blk)[ictr];
if(*iptr) {
cond_bl_upd(iptr, bp, GFS_PS_IND_BLK_LVL1,
fso, Nflag);
@@ -2429,21 +2437,22 @@ updrefs(int cg, ino_t in, struct gfs_bpp *bp, int fsi, int fso, int Nflag)
*/
cond_bl_upd(&(ino->di_ib[1]), bp, GFS_PS_INODE, fso, Nflag);
i2_src=fsbtodb(&sblock, ino->di_ib[1]);
- rdfs(i2_src, sblock.fs_bsize, (char *)&i2blk, fsi);
+ rdfs(i2_src, (size_t)sblock.fs_bsize, (void *)&i2blk, fsi);
for(ind2ctr=0; ind2ctr < howmany(sblock.fs_bsize,
sizeof(ufs_daddr_t)); ind2ctr++) {
- ind2ptr=&((ufs_daddr_t *)&i2blk)[ind2ctr];
+ ind2ptr=&((ufs_daddr_t *)(void *)&i2blk)[ind2ctr];
if(!*ind2ptr) {
continue;
}
cond_bl_upd(ind2ptr, bp, GFS_PS_IND_BLK_LVL2, fso,
Nflag);
i1_src=fsbtodb(&sblock, *ind2ptr);
- rdfs(i1_src, sblock.fs_bsize, (char *)&i1blk, fsi);
+ rdfs(i1_src, (size_t)sblock.fs_bsize, (void *)&i1blk,
+ fsi);
for(ictr=0; ictr<MIN(howmany((unsigned int)
sblock.fs_bsize, sizeof(ufs_daddr_t)),
(unsigned int)remaining_blocks); ictr++) {
- iptr=&((ufs_daddr_t *)&i1blk)[ictr];
+ iptr=&((ufs_daddr_t *)(void *)&i1blk)[ictr];
if(*iptr) {
cond_bl_upd(iptr, bp,
GFS_PS_IND_BLK_LVL1, fso, Nflag);
@@ -2467,32 +2476,35 @@ updrefs(int cg, ino_t in, struct gfs_bpp *bp, int fsi, int fso, int Nflag)
*/
cond_bl_upd(&(ino->di_ib[2]), bp, GFS_PS_INODE, fso, Nflag);
i3_src=fsbtodb(&sblock, ino->di_ib[2]);
- rdfs(i3_src, sblock.fs_bsize, (char *)&i3blk, fsi);
+ rdfs(i3_src, (size_t)sblock.fs_bsize, (void *)&i3blk, fsi);
for(ind3ctr=0; ind3ctr < howmany(sblock.fs_bsize,
sizeof(ufs_daddr_t)); ind3ctr ++) {
- ind3ptr=&((ufs_daddr_t *)&i3blk)[ind3ctr];
+ ind3ptr=&((ufs_daddr_t *)(void *)&i3blk)[ind3ctr];
if(!*ind3ptr) {
continue;
}
cond_bl_upd(ind3ptr, bp, GFS_PS_IND_BLK_LVL3, fso,
Nflag);
i2_src=fsbtodb(&sblock, *ind3ptr);
- rdfs(i2_src, sblock.fs_bsize, (char *)&i2blk, fsi);
+ rdfs(i2_src, (size_t)sblock.fs_bsize, (void *)&i2blk,
+ fsi);
for(ind2ctr=0; ind2ctr < howmany(sblock.fs_bsize,
sizeof(ufs_daddr_t)); ind2ctr ++) {
- ind2ptr=&((ufs_daddr_t *)&i2blk)[ind2ctr];
+ ind2ptr=&((ufs_daddr_t *)(void *)&i2blk)
+ [ind2ctr];
if(!*ind2ptr) {
continue;
}
cond_bl_upd(ind2ptr, bp, GFS_PS_IND_BLK_LVL2,
fso, Nflag);
i1_src=fsbtodb(&sblock, *ind2ptr);
- rdfs(i1_src, sblock.fs_bsize, (char *)&i1blk,
- fsi);
+ rdfs(i1_src, (size_t)sblock.fs_bsize,
+ (void *)&i1blk, fsi);
for(ictr=0; ictr < MIN(howmany(sblock.fs_bsize,
sizeof(ufs_daddr_t)),
(unsigned int)remaining_blocks); ictr++) {
- iptr=&((ufs_daddr_t *)&i1blk)[ictr];
+ iptr=&((ufs_daddr_t *)(void *)&i1blk)
+ [ictr];
if(*iptr) {
cond_bl_upd(iptr, bp,
GFS_PS_IND_BLK_LVL1, fso,
OpenPOWER on IntegriCloud