d/freebsd-dev
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

cleanup to get rid of most warnings on alpha

Browse Source 
and yes now it also works on alpha

Reviewed by:	chm
MFC after:	3 weeks
This commit is contained in:
Thomas-Henning von Kamptz 2001-06-07 20:43:00 +00:00
parent 7dd8ff09db
commit adcaff07f8
Notes: svn2git 2020-12-20 02:59:44 +00:00 
svn path=/head/; revision=77885
3 changed files with 152 additions and 134 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

89
sbin/ffsinfo/ffsinfo.c
View File

@ -94,7 +94,7 @@ static char i3blk[MAXBSIZE];
static struct csum *fscs; static struct csum *fscs;
/* ******************************************************** PROTOTYPES ***** */ /* ******************************************************** PROTOTYPES ***** */
static void rdfs(daddr_t, int, char *, int); static void rdfs(daddr_t, size_t, void *, int);
static void usage(void); static void usage(void);
static struct disklabel *get_disklabel(int); static struct disklabel *get_disklabel(int);
static struct dinode *ginode(ino_t, 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. * Here we read some block(s) from disk.
*/ */
void 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") DBG_FUNC("rdfs")
int n; ssize_t n;
DBG_ENTER; DBG_ENTER;
if (lseek(fsi, (off_t)bno * DEV_BSIZE, 0) < 0) { if (lseek(fsi, (off_t)bno * DEV_BSIZE, 0) < 0) {
err(33, "rdfs: seek error: %ld", (long)bno); err(33, "rdfs: seek error: %ld", (long)bno);
} }
n = read(fsi, bf, (size_t)size); n = read(fsi, bf, size);
if (n != size) { if (n != (ssize_t)size) {
err(34, "rdfs: read error: %ld", (long)bno); err(34, "rdfs: read error: %ld", (long)bno);
} }
@ -296,7 +296,7 @@ main(int argc, char **argv)
/* /*
* Read the current superblock. * 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) { if (sblock.fs_magic != FS_MAGIC) {
errx(1, "superblock not recognized"); errx(1, "superblock not recognized");
} }
@ -326,7 +326,8 @@ main(int argc, char **argv)
} }
if (cfg_lv & 0x004) { 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) { if(fscs == NULL) {
errx(1, "calloc failed"); errx(1, "calloc failed");
} }
@ -336,9 +337,9 @@ main(int argc, char **argv)
*/ */
for (i = 0; i < sblock.fs_cssize; i += sblock.fs_bsize) { for (i = 0; i < sblock.fs_cssize; i += sblock.fs_bsize) {
rdfs(fsbtodb(&sblock, sblock.fs_csaddr + 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 ? sblock.fs_cssize - i :
sblock.fs_bsize, ((char *)fscs) + i, fsi); sblock.fs_bsize), (void *)(((char *)fscs)+i), fsi);
} }
dbg_csp=fscs; dbg_csp=fscs;
@ -346,8 +347,8 @@ main(int argc, char **argv)
* ... and dump it. * ... and dump it.
*/ */
for(dbg_csc=0; dbg_csc<sblock.fs_ncg; dbg_csc++) { for(dbg_csc=0; dbg_csc<sblock.fs_ncg; dbg_csc++) {
snprintf(dbg_line, 80, "%d. csum in fscs", snprintf(dbg_line, sizeof(dbg_line),
dbg_csc); "%d. csum in fscs", dbg_csc);
DBG_DUMP_CSUM(&sblock, DBG_DUMP_CSUM(&sblock,
dbg_line, dbg_line,
dbg_csp++); dbg_csp++);
@ -358,21 +359,21 @@ main(int argc, char **argv)
* For each requested cylinder group ... * For each requested cylinder group ...
*/ */
for(cylno=cg_start; cylno<cg_stop; cylno++) { 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) { if(cfg_lv & 0x002) {
/* /*
* ... dump the superblock copies ... * ... dump the superblock copies ...
*/ */
rdfs(fsbtodb(&sblock, cgsblock(&sblock, cylno)), rdfs(fsbtodb(&sblock, cgsblock(&sblock, cylno)),
SBSIZE, (char *)&osblock, fsi); (size_t)SBSIZE, (void *)&osblock, fsi);
DBG_DUMP_FS(&osblock, DBG_DUMP_FS(&osblock,
dbg_line); dbg_line);
} }
/* /*
* ... read the cylinder group and dump whatever was requested. * ... read the cylinder group and dump whatever was requested.
*/ */
rdfs(fsbtodb(&sblock, cgtod(&sblock, cylno)), sblock.fs_cgsize, rdfs(fsbtodb(&sblock, cgtod(&sblock, cylno)),
(char *)&acg, fsi); (size_t)sblock.fs_cgsize, (void *)&acg, fsi);
if(cfg_lv & 0x008) { if(cfg_lv & 0x008) {
DBG_DUMP_CG(&sblock, DBG_DUMP_CG(&sblock,
dbg_line, dbg_line,
@ -452,7 +453,7 @@ dump_whole_inode(ino_t inode, int fsi, int level)
/* /*
* Dump the main inode structure. * Dump the main inode structure.
*/ */
snprintf(comment, 80, "Inode 0x%08x", inode); snprintf(comment, sizeof(comment), "Inode 0x%08x", inode);
if (level & 0x100) { if (level & 0x100) {
DBG_DUMP_INO(&sblock, DBG_DUMP_INO(&sblock,
comment, comment,
@ -472,9 +473,10 @@ dump_whole_inode(ino_t inode, int fsi, int level)
/* /*
* Dump single indirect block. * Dump single indirect block.
*/ */
rdfs(fsbtodb(&sblock, ino->di_ib[0]), sblock.fs_bsize, i1blk, rdfs(fsbtodb(&sblock, ino->di_ib[0]), (size_t)sblock.fs_bsize,
fsi); (void *)&i1blk, fsi);
snprintf(comment, 80, "Inode 0x%08x: indirect 0", inode); snprintf(comment, sizeof(comment), "Inode 0x%08x: indirect 0",
inode);
DBG_DUMP_IBLK(&sblock, DBG_DUMP_IBLK(&sblock,
comment, comment,
i1blk, i1blk,
@ -485,21 +487,22 @@ dump_whole_inode(ino_t inode, int fsi, int level)
/* /*
* Dump double indirect blocks. * Dump double indirect blocks.
*/ */
rdfs(fsbtodb(&sblock, ino->di_ib[1]), sblock.fs_bsize, i2blk, rdfs(fsbtodb(&sblock, ino->di_ib[1]), (size_t)sblock.fs_bsize,
fsi); (void *)&i2blk, fsi);
snprintf(comment, 80, "Inode 0x%08x: indirect 1", inode); snprintf(comment, sizeof(comment), "Inode 0x%08x: indirect 1",
inode);
DBG_DUMP_IBLK(&sblock, DBG_DUMP_IBLK(&sblock,
comment, comment,
i2blk, i2blk,
howmany(rb, howmany(sblock.fs_bsize, sizeof(ufs_daddr_t)))); howmany(rb, howmany(sblock.fs_bsize, sizeof(ufs_daddr_t))));
for(ind2ctr=0; ((ind2ctr < howmany(sblock.fs_bsize, for(ind2ctr=0; ((ind2ctr < howmany(sblock.fs_bsize,
sizeof(ufs_daddr_t)))&&(rb>0)); ind2ctr++) { 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, rdfs(fsbtodb(&sblock, *ind2ptr),
i1blk, fsi); (size_t)sblock.fs_bsize, (void *)&i1blk, fsi);
snprintf(comment, 80, "Inode 0x%08x: indirect 1->%d", snprintf(comment, sizeof(comment),
inode, ind2ctr); "Inode 0x%08x: indirect 1->%d", inode, ind2ctr);
DBG_DUMP_IBLK(&sblock, DBG_DUMP_IBLK(&sblock,
comment, comment,
i1blk, i1blk,
@ -511,9 +514,10 @@ dump_whole_inode(ino_t inode, int fsi, int level)
/* /*
* Dump triple indirect blocks. * Dump triple indirect blocks.
*/ */
rdfs(fsbtodb(&sblock, ino->di_ib[2]), sblock.fs_bsize, i3blk, rdfs(fsbtodb(&sblock, ino->di_ib[2]), (size_t)sblock.fs_bsize,
fsi); (void *)&i3blk, fsi);
snprintf(comment, 80, "Inode 0x%08x: indirect 2", inode); snprintf(comment, sizeof(comment), "Inode 0x%08x: indirect 2",
inode);
#define SQUARE(a) ((a)*(a)) #define SQUARE(a) ((a)*(a))
DBG_DUMP_IBLK(&sblock, DBG_DUMP_IBLK(&sblock,
comment, comment,
@ -523,12 +527,12 @@ dump_whole_inode(ino_t inode, int fsi, int level)
#undef SQUARE #undef SQUARE
for(ind3ctr=0; ((ind3ctr < howmany(sblock.fs_bsize, for(ind3ctr=0; ((ind3ctr < howmany(sblock.fs_bsize,
sizeof(ufs_daddr_t)))&&(rb>0)); ind3ctr ++) { 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, rdfs(fsbtodb(&sblock, *ind3ptr),
i2blk, fsi); (size_t)sblock.fs_bsize, (void *)&i2blk, fsi);
snprintf(comment, 80, "Inode 0x%08x: indirect 2->%d", snprintf(comment, sizeof(comment),
inode, ind3ctr); "Inode 0x%08x: indirect 2->%d", inode, ind3ctr);
DBG_DUMP_IBLK(&sblock, DBG_DUMP_IBLK(&sblock,
comment, comment,
i2blk, i2blk,
@ -536,11 +540,12 @@ dump_whole_inode(ino_t inode, int fsi, int level)
howmany(sblock.fs_bsize, sizeof(ufs_daddr_t)))); howmany(sblock.fs_bsize, sizeof(ufs_daddr_t))));
for(ind2ctr=0; ((ind2ctr < howmany(sblock.fs_bsize, for(ind2ctr=0; ((ind2ctr < howmany(sblock.fs_bsize,
sizeof(ufs_daddr_t)))&&(rb>0)); ind2ctr ++) { sizeof(ufs_daddr_t)))&&(rb>0)); ind2ctr ++) {
ind2ptr=&((ufs_daddr_t *)&i2blk)[ind2ctr]; ind2ptr=&((ufs_daddr_t *)(void *)&i2blk)
[ind2ctr];
rdfs(fsbtodb(&sblock, *ind2ptr), rdfs(fsbtodb(&sblock, *ind2ptr),
sblock.fs_bsize, i1blk, fsi); (size_t)sblock.fs_bsize, (void *)&i1blk,
snprintf(comment, 80, fsi);
snprintf(comment, sizeof(comment),
"Inode 0x%08x: indirect 2->%d->%d", inode, "Inode 0x%08x: indirect 2->%d->%d", inode,
ind3ctr, ind3ctr); ind3ctr, ind3ctr);
DBG_DUMP_IBLK(&sblock, DBG_DUMP_IBLK(&sblock,
@ -621,7 +626,7 @@ ginode(ino_t inumber, int fsi)
DBG_ENTER; DBG_ENTER;
pi=(struct dinode *)ablk; pi=(struct dinode *)(void *)ablk;
if (startinum == 0 || inumber < startinum || if (startinum == 0 || inumber < startinum ||
inumber >= startinum + INOPB(&sblock)) { inumber >= startinum + INOPB(&sblock)) {
/* /*
@ -629,8 +634,8 @@ ginode(ino_t inumber, int fsi)
* disk now. * disk now.
*/ */
iblk = ino_to_fsba(&sblock, inumber); iblk = ino_to_fsba(&sblock, inumber);
rdfs(fsbtodb(&sblock, iblk), sblock.fs_bsize, (char *)&ablk, rdfs(fsbtodb(&sblock, iblk), (size_t)sblock.fs_bsize,
fsi); (void *)&ablk, fsi);
startinum = (inumber / INOPB(&sblock)) * INOPB(&sblock); startinum = (inumber / INOPB(&sblock)) * INOPB(&sblock);
} }

19
sbin/growfs/debug.c
View File

@ -155,8 +155,8 @@ dbg_dump_fs(struct fs *sb, const char *comment)
sb->fs_cgoffset); sb->fs_cgoffset);
fprintf(dbg_log, "cgmask int32_t 0x%08x\n", fprintf(dbg_log, "cgmask int32_t 0x%08x\n",
sb->fs_cgmask); sb->fs_cgmask);
fprintf(dbg_log, "time time_t %10lu\n", fprintf(dbg_log, "time time_t %10u\n",
sb->fs_time); (unsigned int)sb->fs_time);
fprintf(dbg_log, "size int32_t 0x%08x\n", fprintf(dbg_log, "size int32_t 0x%08x\n",
sb->fs_size); sb->fs_size);
fprintf(dbg_log, "dsize int32_t 0x%08x\n", fprintf(dbg_log, "dsize int32_t 0x%08x\n",
@ -330,7 +330,8 @@ dbg_dump_cg(const char *comment, struct cg *cgr)
indent++; indent++;
fprintf(dbg_log, "magic int32_t 0x%08x\n", cgr->cg_magic); 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, "cgx int32_t 0x%08x\n", cgr->cg_cgx);
fprintf(dbg_log, "ncyl int16_t 0x%04x\n", cgr->cg_ncyl); fprintf(dbg_log, "ncyl int16_t 0x%04x\n", cgr->cg_ncyl);
fprintf(dbg_log, "niblk int16_t 0x%04x\n", cgr->cg_niblk); 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) dbg_dump_clsum(struct fs *sb, const char *comment, struct cg *cgr)
{ {
int j; int j;
long *lp; int *ip;
if(!dbg_log) { if(!dbg_log) {
return; 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); fprintf(dbg_log, "# %d@%lx: %s\n", indent, (unsigned long)cgr, comment);
indent++; indent++;
lp=(long *)cg_clustersum(cgr); ip=(int *)cg_clustersum(cgr);
for(j=0; j<=sb->fs_contigsumsize; j++) { 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--; indent--;
@ -559,7 +560,7 @@ void
dbg_dump_sptbl(struct fs *sb, const char *comment, struct cg *cgr) dbg_dump_sptbl(struct fs *sb, const char *comment, struct cg *cgr)
{ {
int j,k; int j,k;
long *lp; int *ip;
if(!dbg_log) { if(!dbg_log) {
return; 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); fprintf(dbg_log, "# %d@%lx: %s\n", indent, (unsigned long)cgr, comment);
indent++; indent++;
lp=(long *)cg_blktot(cgr); ip=(int *)cg_blktot(cgr);
for(j=0; j<sb->fs_cpg; j++) { 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++) { for(k=0; k<sb->fs_nrpos; k++) {
fprintf(dbg_log, "%4d", cg_blks(sb, cgr, j)[k]); fprintf(dbg_log, "%4d", cg_blks(sb, cgr, j)[k]);
if(k<sb->fs_nrpos-1) { if(k<sb->fs_nrpos-1) {

178
sbin/growfs/growfs.c
View File

@ -120,30 +120,31 @@ struct gfs_bpp {
daddr_t new; /* new block number */ daddr_t new; /* new block number */
#define GFS_FL_FIRST 1 #define GFS_FL_FIRST 1
#define GFS_FL_LAST 2 #define GFS_FL_LAST 2
unsigned long flags; /* special handling required */ unsigned int flags; /* special handling required */
int found; /* how many references were updated */ int found; /* how many references were updated */
}; };
/* ******************************************************** PROTOTYPES ***** */ /* ******************************************************** PROTOTYPES ***** */
static void rdfs(daddr_t, int, char *, int); static void growfs(int, int, unsigned int);
static void wtfs(daddr_t, int, char *, int, 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 daddr_t alloc(void);
static int charsperline(void); static int charsperline(void);
static void usage(void); static void usage(void);
static int isblock(struct fs *, unsigned char *, int); static int isblock(struct fs *, unsigned char *, int);
static void clrblock(struct fs *, unsigned char *, int); static void clrblock(struct fs *, unsigned char *, int);
static void setblock(struct fs *, unsigned char *, int); static void setblock(struct fs *, unsigned char *, int);
static void initcg(int, time_t, int, int); static void initcg(int, time_t, int, unsigned int);
static void updjcg(int, time_t, int, int, int); static void updjcg(int, time_t, int, int, unsigned int);
static void updcsloc(time_t, int, int, int); static void updcsloc(time_t, int, int, unsigned int);
static struct disklabel *get_disklabel(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 struct dinode *ginode(ino_t, int, int);
static void frag_adjust(daddr_t, int); static void frag_adjust(daddr_t, int);
static void cond_bl_upd(ufs_daddr_t *, struct gfs_bpp *, 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 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 ***** */ /* ************************************************************ growfs ***** */
/* /*
@ -158,11 +159,11 @@ static void updrefs(int, ino_t, struct gfs_bpp *, int, int, int);
* copies. * copies.
*/ */
static void static void
growfs(int fsi, int fso, int Nflag) growfs(int fsi, int fso, unsigned int Nflag)
{ {
DBG_FUNC("growfs") DBG_FUNC("growfs")
long i; int i;
long cylno, j; int cylno, j;
time_t utime; time_t utime;
int width; int width;
char tmpbuf[100]; char tmpbuf[100];
@ -185,14 +186,14 @@ growfs(int fsi, int fso, int Nflag)
/* /*
* Get the cylinder summary into the memory. * 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) { if(fscs == NULL) {
errx(1, "calloc failed"); errx(1, "calloc failed");
} }
for (i = 0; i < osblock.fs_cssize; i += osblock.fs_bsize) { for (i = 0; i < osblock.fs_cssize; i += osblock.fs_bsize) {
rdfs(fsbtodb(&osblock, osblock.fs_csaddr + rdfs(fsbtodb(&osblock, osblock.fs_csaddr +
numfrags(&osblock, i)), MIN(osblock.fs_cssize - i, numfrags(&osblock, i)), (size_t)MIN(osblock.fs_cssize - i,
osblock.fs_bsize), ((char *)fscs) + i, fsi); osblock.fs_bsize), (void *)(((char *)fscs)+i), fsi);
} }
#ifdef FS_DEBUG #ifdef FS_DEBUG
@ -203,7 +204,8 @@ growfs(int fsi, int fso, int Nflag)
dbg_csp=fscs; dbg_csp=fscs;
for(dbg_csc=0; dbg_csc<osblock.fs_ncg; dbg_csc++) { 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_DUMP_CSUM(&osblock,
dbg_line, dbg_line,
dbg_csp++); dbg_csp++);
@ -244,8 +246,8 @@ growfs(int fsi, int fso, int Nflag)
*/ */
for (cylno = osblock.fs_ncg; cylno < sblock.fs_ncg; cylno++) { for (cylno = osblock.fs_ncg; cylno < sblock.fs_ncg; cylno++) {
initcg(cylno, utime, fso, Nflag); initcg(cylno, utime, fso, Nflag);
j = sprintf(tmpbuf, " %ld%s", j = sprintf(tmpbuf, " %d%s",
fsbtodb(&sblock, cgsblock(&sblock, cylno)), (int)fsbtodb(&sblock, cgsblock(&sblock, cylno)),
cylno < (sblock.fs_ncg-1) ? "," : "" ); cylno < (sblock.fs_ncg-1) ? "," : "" );
if (i + j >= width) { if (i + j >= width) {
printf("\n"); printf("\n");
@ -268,8 +270,8 @@ growfs(int fsi, int fso, int Nflag)
*/ */
for (i = 0; i < sblock.fs_cssize; i += sblock.fs_bsize) { for (i = 0; i < sblock.fs_cssize; i += sblock.fs_bsize) {
wtfs(fsbtodb(&sblock, sblock.fs_csaddr + numfrags(&sblock, i)), wtfs(fsbtodb(&sblock, sblock.fs_csaddr + numfrags(&sblock, i)),
MIN(sblock.fs_cssize - i, sblock.fs_bsize), (size_t)MIN(sblock.fs_cssize - i, sblock.fs_bsize),
((char *)fscs) + i, fso, Nflag); (void *)(((char *)fscs) + i), fso, Nflag);
} }
DBG_PRINT0("fscs written\n"); DBG_PRINT0("fscs written\n");
@ -281,7 +283,8 @@ growfs(int fsi, int fso, int Nflag)
dbg_csp=fscs; dbg_csp=fscs;
for(dbg_csc=0; dbg_csc<sblock.fs_ncg; dbg_csc++) { 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_DUMP_CSUM(&sblock,
dbg_line, dbg_line,
dbg_csp++); dbg_csp++);
@ -293,7 +296,8 @@ growfs(int fsi, int fso, int Nflag)
* Now write the new superblock back to disk. * Now write the new superblock back to disk.
*/ */
sblock.fs_time = utime; 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_PRINT0("sblock written\n");
DBG_DUMP_FS(&sblock, DBG_DUMP_FS(&sblock,
"new initial sblock"); "new initial sblock");
@ -335,7 +339,7 @@ growfs(int fsi, int fso, int Nflag)
*/ */
for (cylno = 0; cylno < sblock.fs_ncg; cylno++) { for (cylno = 0; cylno < sblock.fs_ncg; cylno++) {
wtfs(fsbtodb(&sblock, cgsblock(&sblock, 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_PRINT0("sblock copies written\n");
DBG_DUMP_FS(&sblock, DBG_DUMP_FS(&sblock,
@ -353,14 +357,14 @@ growfs(int fsi, int fso, int Nflag)
* provisions for that case are removed here. * provisions for that case are removed here.
*/ */
static void 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") DBG_FUNC("initcg")
daddr_t cbase, d, dlower, dupper, dmax, blkno; daddr_t cbase, d, dlower, dupper, dmax, blkno;
long i; int i;
register struct csum *cs; register struct csum *cs;
#ifdef FSIRAND #ifdef FSIRAND
long j; int j;
#endif #endif
DBG_ENTER; DBG_ENTER;
@ -375,7 +379,7 @@ initcg(int cylno, time_t utime, int fso, int Nflag)
} }
dlower = cgsblock(&sblock, cylno) - cbase; dlower = cgsblock(&sblock, cylno) - cbase;
dupper = cgdmin(&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); dupper += howmany(sblock.fs_cssize, sblock.fs_fsize);
} }
cs = fscs + cylno; cs = fscs + cylno;
@ -412,7 +416,7 @@ initcg(int cylno, time_t utime, int fso, int Nflag)
acg.cg_nextfreeoff = acg.cg_clusteroff + howmany acg.cg_nextfreeoff = acg.cg_clusteroff + howmany
(sblock.fs_cpg * sblock.fs_spc / NSPB(&sblock), NBBY); (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 * XXX This should never happen as we would have had that panic
* already on filesystem creation * already on filesystem creation
@ -432,7 +436,7 @@ initcg(int cylno, time_t utime, int fso, int Nflag)
} }
#endif #endif
wtfs(fsbtodb(&sblock, cgimin(&sblock, cylno) + i), 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) { for (d = 0; d < dlower; d += sblock.fs_frag) {
blkno = 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; sblock.fs_cstotal.cs_nifree += acg.cg_cs.cs_nifree;
*cs = acg.cg_cs; *cs = acg.cg_cs;
wtfs(fsbtodb(&sblock, cgtod(&sblock, cylno)), 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, DBG_DUMP_CG(&sblock,
"new cg", "new cg",
&acg); &acg);
@ -589,7 +593,7 @@ frag_adjust(daddr_t frag, int sign)
*/ */
static void static void
cond_bl_upd(ufs_daddr_t *block, struct gfs_bpp *field, 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") DBG_FUNC("cond_bl_upd")
struct gfs_bpp *f; 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 * implement copy on write here in case
* of active snapshots. * 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. * tables and cluster summary during all those operations.
*/ */
static void 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") DBG_FUNC("updjcg")
daddr_t cbase, dmax, dupper; 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 * Read the former last (joining) cylinder group from disk, and make
* a copy. * a copy.
*/ */
rdfs(fsbtodb(&osblock, cgtod(&osblock, cylno)), osblock.fs_cgsize, rdfs(fsbtodb(&osblock, cgtod(&osblock, cylno)),
(char *)&aocg, fsi); (size_t)osblock.fs_cgsize, (void *)&aocg, fsi);
DBG_PRINT0("jcg read\n"); DBG_PRINT0("jcg read\n");
DBG_DUMP_CG(&sblock, DBG_DUMP_CG(&sblock,
"old joining cg", "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) { if(cgbase(&osblock, cylno+1) == osblock.fs_size) {
acg.cg_ncyl=sblock.fs_cpg; acg.cg_ncyl=sblock.fs_cpg;
wtfs(fsbtodb(&sblock, cgtod(&sblock, cylno)), sblock.fs_cgsize, wtfs(fsbtodb(&sblock, cgtod(&sblock, cylno)),
(char *)&acg, fso, Nflag); (size_t)sblock.fs_cgsize, (void *)&acg, fso, Nflag);
DBG_PRINT0("jcg written\n"); DBG_PRINT0("jcg written\n");
DBG_DUMP_CG(&sblock, DBG_DUMP_CG(&sblock,
"new joining cg", "new joining cg",
@ -720,7 +725,7 @@ updjcg(int cylno, time_t utime, int fsi, int fso, int Nflag)
if (dmax > sblock.fs_size) if (dmax > sblock.fs_size)
dmax = sblock.fs_size; dmax = sblock.fs_size;
dupper = cgdmin(&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); 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. * Write the updated "joining" cylinder group back to disk.
*/ */
wtfs(fsbtodb(&sblock, cgtod(&sblock, cylno)), sblock.fs_cgsize, wtfs(fsbtodb(&sblock, cgtod(&sblock, cylno)), (size_t)sblock.fs_cgsize,
(char *)&acg, fso, Nflag); (void *)&acg, fso, Nflag);
DBG_PRINT0("jcg written\n"); DBG_PRINT0("jcg written\n");
DBG_DUMP_CG(&sblock, DBG_DUMP_CG(&sblock,
"new joining cg", "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. * completely avoid implementing copy on write if we stick to method (2) only.
*/ */
static void 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") DBG_FUNC("updcsloc")
struct csum *cs; 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. * Read original cylinder group from disk, and make a copy.
*/ */
rdfs(fsbtodb(&osblock, cgtod(&osblock, ocscg)), osblock.fs_cgsize, rdfs(fsbtodb(&osblock, cgtod(&osblock, ocscg)),
(char *)&aocg, fsi); (size_t)osblock.fs_cgsize, (void *)&aocg, fsi);
DBG_PRINT0("oscg read\n"); DBG_PRINT0("oscg read\n");
DBG_DUMP_CG(&sblock, DBG_DUMP_CG(&sblock,
"old summary cg", "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 * Now write the former cylinder group containing the cylinder
* summary back to disk. * summary back to disk.
*/ */
wtfs(fsbtodb(&sblock, cgtod(&sblock, ocscg)), sblock.fs_cgsize, wtfs(fsbtodb(&sblock, cgtod(&sblock, ocscg)),
(char *)&acg, fso, Nflag); (size_t)sblock.fs_cgsize, (void *)&acg, fso, Nflag);
DBG_PRINT0("oscg written\n"); DBG_PRINT0("oscg written\n");
DBG_DUMP_CG(&sblock, DBG_DUMP_CG(&sblock,
"old summary cg", "old summary cg",
@ -1136,7 +1141,7 @@ updcsloc(time_t utime, int fsi, int fso, int Nflag)
* summary from disk, and make a copy. * summary from disk, and make a copy.
*/ */
rdfs(fsbtodb(&sblock, cgtod(&sblock, ncscg)), 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_PRINT0("nscg read\n");
DBG_DUMP_CG(&sblock, DBG_DUMP_CG(&sblock,
"new summary cg", "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 * Write the new cylinder group containing the cylinder summary
* back to disk. * back to disk.
*/ */
wtfs(fsbtodb(&sblock, cgtod(&sblock, ncscg)), sblock.fs_cgsize, wtfs(fsbtodb(&sblock, cgtod(&sblock, ncscg)),
(char *)&acg, fso, Nflag); (size_t)sblock.fs_cgsize, (void *)&acg, fso, Nflag);
DBG_PRINT0("nscg written\n"); DBG_PRINT0("nscg written\n");
DBG_DUMP_CG(&sblock, DBG_DUMP_CG(&sblock,
"new summary cg", "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. * in the case we have any active snapshots.
*/ */
rdfs(fsbtodb(&sblock, bp[i].old*sblock.fs_frag), 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), 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, DBG_DUMP_HEX(&sblock,
"copied full block", "copied full block",
(unsigned char *)&ablk); (unsigned char *)&ablk);
@ -1524,8 +1529,8 @@ updcsloc(time_t utime, int fsi, int fso, int Nflag)
/* /*
* Write summary cylinder group back to disk. * Write summary cylinder group back to disk.
*/ */
wtfs(fsbtodb(&sblock, cgtod(&sblock, ocscg)), sblock.fs_cgsize, wtfs(fsbtodb(&sblock, cgtod(&sblock, ocscg)), (size_t)sblock.fs_cgsize,
(char *)&acg, fso, Nflag); (void *)&acg, fso, Nflag);
DBG_PRINT0("scg written\n"); DBG_PRINT0("scg written\n");
DBG_DUMP_CG(&sblock, DBG_DUMP_CG(&sblock,
"new summary cg", "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. * Here we read some block(s) from disk.
*/ */
static void 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") DBG_FUNC("rdfs")
int n; ssize_t n;
DBG_ENTER; DBG_ENTER;
if (lseek(fsi, (off_t)bno * DEV_BSIZE, 0) < 0) { if (lseek(fsi, (off_t)bno * DEV_BSIZE, 0) < 0) {
err(33, "rdfs: seek error: %ld", (long)bno); err(33, "rdfs: seek error: %ld", (long)bno);
} }
n = read(fsi, bf, (size_t)size); n = read(fsi, bf, size);
if (n != size) { if (n != (ssize_t)size) {
err(34, "rdfs: read error: %ld", (long)bno); 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. * Here we write some block(s) to disk.
*/ */
static void 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") DBG_FUNC("wtfs")
int n; ssize_t n;
DBG_ENTER; 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) { if (lseek(fso, (off_t)bno * DEV_BSIZE, SEEK_SET) < 0) {
err(35, "wtfs: seek error: %ld", (long)bno); err(35, "wtfs: seek error: %ld", (long)bno);
} }
n = write(fso, bf, (size_t)size); n = write(fso, bf, size);
if (n != size) { if (n != (ssize_t)size) {
err(36, "wtfs: write error: %ld", (long)bno); err(36, "wtfs: write error: %ld", (long)bno);
} }
@ -1848,7 +1853,7 @@ ginode(ino_t inumber, int fsi, int cg)
DBG_ENTER; DBG_ENTER;
pi=(struct dinode *)ablk; pi=(struct dinode *)(void *)ablk;
inumber+=(cg * sblock.fs_ipg); inumber+=(cg * sblock.fs_ipg);
if (startinum == 0 || inumber < startinum || if (startinum == 0 || inumber < startinum ||
inumber >= startinum + INOPB(&sblock)) { inumber >= startinum + INOPB(&sblock)) {
@ -1858,7 +1863,7 @@ ginode(ino_t inumber, int fsi, int cg)
*/ */
iblk = ino_to_fsba(&sblock, inumber); iblk = ino_to_fsba(&sblock, inumber);
in_src=fsbtodb(&sblock, iblk); 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); startinum = (inumber / INOPB(&sblock)) * INOPB(&sblock);
} }
@ -1926,9 +1931,9 @@ main(int argc, char **argv)
DBG_FUNC("main") DBG_FUNC("main")
char *device, *special, *cp; char *device, *special, *cp;
char ch; char ch;
unsigned long size=0; unsigned int size=0;
size_t len; size_t len;
int Nflag=0; unsigned int Nflag=0;
int ExpertFlag=0; int ExpertFlag=0;
struct stat st; struct stat st;
struct disklabel *lp; struct disklabel *lp;
@ -2056,7 +2061,8 @@ main(int argc, char **argv)
/* /*
* Read the current superblock, and take a backup. * 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) { if (osblock.fs_magic != FS_MAGIC) {
errx(1, "superblock not recognized"); errx(1, "superblock not recognized");
} }
@ -2073,7 +2079,7 @@ main(int argc, char **argv)
sblock.fs_size = dbtofsb(&osblock, pp->p_size); sblock.fs_size = dbtofsb(&osblock, pp->p_size);
if (size != 0) { if (size != 0) {
if (size > pp->p_size){ 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); pp->p_size, size);
} }
sblock.fs_size = dbtofsb(&osblock, 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 " printf("We strongly recommend you to make a backup "
"before growing the Filesystem\n\n" "before growing the Filesystem\n\n"
" Did you backup your data (Yes/No) ? "); " Did you backup your data (Yes/No) ? ");
fgets(reply, sizeof(reply), stdin); fgets(reply, (int)sizeof(reply), stdin);
if (strcmp(reply, "Yes\n")){ if (strcmp(reply, "Yes\n")){
printf("\n Nothing done \n"); printf("\n Nothing done \n");
exit (0); exit (0);
@ -2124,7 +2130,8 @@ main(int argc, char **argv)
* later on realize we have to abort our operation, on that block * later on realize we have to abort our operation, on that block
* there should be no data, so we can't destroy something yet. * 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 * 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. * Write the updated disklabel back to disk.
*/ */
static void 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") DBG_FUNC("return_disklabel")
u_short sum; u_short sum;
@ -2345,7 +2352,8 @@ updclst(int block)
* cylinder group. * cylinder group.
*/ */
static void 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") DBG_FUNC("updrefs")
unsigned int ictr, ind2ctr, ind3ctr; 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); cond_bl_upd(&(ino->di_ib[0]), bp, GFS_PS_INODE, fso, Nflag);
i1_src=fsbtodb(&sblock, ino->di_ib[0]); 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, for(ictr=0; ictr < MIN(howmany(sblock.fs_bsize,
sizeof(ufs_daddr_t)), (unsigned int)remaining_blocks); sizeof(ufs_daddr_t)), (unsigned int)remaining_blocks);
ictr++) { ictr++) {
iptr=&((ufs_daddr_t *)&i1blk)[ictr]; iptr=&((ufs_daddr_t *)(void *)&i1blk)[ictr];
if(*iptr) { if(*iptr) {
cond_bl_upd(iptr, bp, GFS_PS_IND_BLK_LVL1, cond_bl_upd(iptr, bp, GFS_PS_IND_BLK_LVL1,
fso, Nflag); 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); cond_bl_upd(&(ino->di_ib[1]), bp, GFS_PS_INODE, fso, Nflag);
i2_src=fsbtodb(&sblock, ino->di_ib[1]); 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, for(ind2ctr=0; ind2ctr < howmany(sblock.fs_bsize,
sizeof(ufs_daddr_t)); ind2ctr++) { sizeof(ufs_daddr_t)); ind2ctr++) {
ind2ptr=&((ufs_daddr_t *)&i2blk)[ind2ctr]; ind2ptr=&((ufs_daddr_t *)(void *)&i2blk)[ind2ctr];
if(!*ind2ptr) { if(!*ind2ptr) {
continue; continue;
} }
cond_bl_upd(ind2ptr, bp, GFS_PS_IND_BLK_LVL2, fso, cond_bl_upd(ind2ptr, bp, GFS_PS_IND_BLK_LVL2, fso,
Nflag); Nflag);
i1_src=fsbtodb(&sblock, *ind2ptr); 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) for(ictr=0; ictr<MIN(howmany((unsigned int)
sblock.fs_bsize, sizeof(ufs_daddr_t)), sblock.fs_bsize, sizeof(ufs_daddr_t)),
(unsigned int)remaining_blocks); ictr++) { (unsigned int)remaining_blocks); ictr++) {
iptr=&((ufs_daddr_t *)&i1blk)[ictr]; iptr=&((ufs_daddr_t *)(void *)&i1blk)[ictr];
if(*iptr) { if(*iptr) {
cond_bl_upd(iptr, bp, cond_bl_upd(iptr, bp,
GFS_PS_IND_BLK_LVL1, fso, Nflag); 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); cond_bl_upd(&(ino->di_ib[2]), bp, GFS_PS_INODE, fso, Nflag);
i3_src=fsbtodb(&sblock, ino->di_ib[2]); 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, for(ind3ctr=0; ind3ctr < howmany(sblock.fs_bsize,
sizeof(ufs_daddr_t)); ind3ctr ++) { sizeof(ufs_daddr_t)); ind3ctr ++) {
ind3ptr=&((ufs_daddr_t *)&i3blk)[ind3ctr]; ind3ptr=&((ufs_daddr_t *)(void *)&i3blk)[ind3ctr];
if(!*ind3ptr) { if(!*ind3ptr) {
continue; continue;
} }
cond_bl_upd(ind3ptr, bp, GFS_PS_IND_BLK_LVL3, fso, cond_bl_upd(ind3ptr, bp, GFS_PS_IND_BLK_LVL3, fso,
Nflag); Nflag);
i2_src=fsbtodb(&sblock, *ind3ptr); 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, for(ind2ctr=0; ind2ctr < howmany(sblock.fs_bsize,
sizeof(ufs_daddr_t)); ind2ctr ++) { sizeof(ufs_daddr_t)); ind2ctr ++) {
ind2ptr=&((ufs_daddr_t *)&i2blk)[ind2ctr]; ind2ptr=&((ufs_daddr_t *)(void *)&i2blk)
[ind2ctr];
if(!*ind2ptr) { if(!*ind2ptr) {
continue; continue;
} }
cond_bl_upd(ind2ptr, bp, GFS_PS_IND_BLK_LVL2, cond_bl_upd(ind2ptr, bp, GFS_PS_IND_BLK_LVL2,
fso, Nflag); fso, Nflag);
i1_src=fsbtodb(&sblock, *ind2ptr); i1_src=fsbtodb(&sblock, *ind2ptr);
rdfs(i1_src, sblock.fs_bsize, (char *)&i1blk, rdfs(i1_src, (size_t)sblock.fs_bsize,
fsi); (void *)&i1blk, fsi);
for(ictr=0; ictr < MIN(howmany(sblock.fs_bsize, for(ictr=0; ictr < MIN(howmany(sblock.fs_bsize,
sizeof(ufs_daddr_t)), sizeof(ufs_daddr_t)),
(unsigned int)remaining_blocks); ictr++) { (unsigned int)remaining_blocks); ictr++) {
iptr=&((ufs_daddr_t *)&i1blk)[ictr]; iptr=&((ufs_daddr_t *)(void *)&i1blk)
[ictr];
if(*iptr) { if(*iptr) {
cond_bl_upd(iptr, bp, cond_bl_upd(iptr, bp,
GFS_PS_IND_BLK_LVL1, fso, GFS_PS_IND_BLK_LVL1, fso,