From adcaff07f8f074c7d559f94cfab869054e34b58a Mon Sep 17 00:00:00 2001 From: Thomas-Henning von Kamptz Date: Thu, 7 Jun 2001 20:43:00 +0000 Subject: [PATCH] cleanup to get rid of most warnings on alpha and yes now it also works on alpha Reviewed by: chm MFC after: 3 weeks --- sbin/ffsinfo/ffsinfo.c | 89 +++++++++++---------- sbin/growfs/debug.c | 19 ++--- sbin/growfs/growfs.c | 178 ++++++++++++++++++++++------------------- 3 files changed, 152 insertions(+), 134 deletions(-) diff --git a/sbin/ffsinfo/ffsinfo.c b/sbin/ffsinfo/ffsinfo.c index 7d6e9359507f..8adada34f1d5 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_cscdi_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 eb836e58fa05..53ec674c76b3 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; jfs_cpg; j++) { - fprintf(dbg_log, "%2d: %5ld = ", j, *lp++); + fprintf(dbg_log, "%2d: %5d = ", j, *ip++); for(k=0; kfs_nrpos; k++) { fprintf(dbg_log, "%4d", cg_blks(sb, cgr, j)[k]); if(kfs_nrpos-1) { diff --git a/sbin/growfs/growfs.c b/sbin/growfs/growfs.c index 370344ae2040..1e8e85f7bd4c 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= 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_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; ictrdi_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,