From c4e3d3f374b409500e3dd05c0b0eca6ac98a6b4e Mon Sep 17 00:00:00 2001 From: Theodore Ts'o Date: Fri, 1 Aug 2003 09:41:07 -0400 Subject: ext2fs_getmem(), ext2fs_free_mem(), and ext2fs_resize_mem() all now take a 'void *' instead of a 'void **' in order to avoid pointer aliasing problems with GCC 3.x. --- e2fsck/ChangeLog | 9 +++++++++ e2fsck/dirinfo.c | 4 ++-- e2fsck/dx_dirinfo.c | 6 +++--- e2fsck/e2fsck.c | 11 +++++------ e2fsck/ea_refcount.c | 11 +++++------ e2fsck/journal.c | 16 ++++++++-------- e2fsck/message.c | 2 +- e2fsck/pass1.c | 10 +++++----- e2fsck/pass1b.c | 6 +++--- e2fsck/pass2.c | 4 ++-- e2fsck/pass3.c | 8 ++++---- e2fsck/pass4.c | 2 +- e2fsck/pass5.c | 6 +++--- e2fsck/super.c | 4 ++-- e2fsck/swapfs.c | 6 +++--- lib/ext2fs/ChangeLog | 13 +++++++++++++ lib/ext2fs/alloc.c | 4 ++-- lib/ext2fs/badblocks.c | 14 ++++++-------- lib/ext2fs/bb_inode.c | 10 +++++----- lib/ext2fs/bitmaps.c | 15 +++++++-------- lib/ext2fs/block.c | 5 ++--- lib/ext2fs/bmap.c | 4 ++-- lib/ext2fs/bmove.c | 2 +- lib/ext2fs/brel_ma.c | 16 ++++++++-------- lib/ext2fs/closefs.c | 9 ++++----- lib/ext2fs/dblist.c | 9 ++++----- lib/ext2fs/dblist_dir.c | 5 ++--- lib/ext2fs/dir_iterate.c | 4 ++-- lib/ext2fs/dirblock.c | 6 +++--- lib/ext2fs/dupfs.c | 10 ++++------ lib/ext2fs/expanddir.c | 4 ++-- lib/ext2fs/ext2fs.h | 29 +++++++++++++++++------------ lib/ext2fs/ext_attr.c | 8 ++++---- lib/ext2fs/fileio.c | 12 ++++++------ lib/ext2fs/freefs.c | 30 +++++++++++++++--------------- lib/ext2fs/get_pathname.c | 19 +++++++++---------- lib/ext2fs/icount.c | 10 +++++----- lib/ext2fs/initialize.c | 14 ++++++-------- lib/ext2fs/inode.c | 33 +++++++++++++++------------------ lib/ext2fs/inode_io.c | 17 ++++++++--------- lib/ext2fs/irel_ma.c | 35 +++++++++++++++++------------------ lib/ext2fs/mkdir.c | 2 +- lib/ext2fs/mkjournal.c | 6 +++--- lib/ext2fs/namei.c | 18 +++++++++--------- lib/ext2fs/newdir.c | 2 +- lib/ext2fs/openfs.c | 14 ++++++-------- lib/ext2fs/rs_bitmap.c | 3 +-- lib/ext2fs/rw_bitmaps.c | 18 +++++++++--------- lib/ext2fs/test_io.c | 18 ++++++++---------- lib/ext2fs/unix_io.c | 22 ++++++++++------------ resize/ChangeLog | 7 +++++++ resize/extent.c | 13 ++++++------- resize/resize2fs.c | 24 +++++++++++------------- resize/sim_progress.c | 7 +++---- 54 files changed, 300 insertions(+), 296 deletions(-) diff --git a/e2fsck/ChangeLog b/e2fsck/ChangeLog index c5cbff00..c5223d2f 100644 --- a/e2fsck/ChangeLog +++ b/e2fsck/ChangeLog @@ -1,3 +1,12 @@ +2003-08-01 Philipp Thomas + + * dirinfo.c, dx_dirinfo.c, e2fsck.c, ea_refcount.c, journal.c, + message.c, pass1.c, pass1b.c, pass2.c, pass3.c, pass4.c, + pass5.c, super.c, swapfs.c: ext2fs_getmem(), + ext2fs_free_mem(), and ext2fs_resize_mem() all now take a + 'void *' instead of a 'void **' in order to avoid pointer + aliasing problems with GCC 3.x. + 2003-07-25 Theodore Ts'o * Release of E2fsprogs 1.34 diff --git a/e2fsck/dirinfo.c b/e2fsck/dirinfo.c index b3289c43..516c4613 100644 --- a/e2fsck/dirinfo.c +++ b/e2fsck/dirinfo.c @@ -40,7 +40,7 @@ void e2fsck_add_dir_info(e2fsck_t ctx, ext2_ino_t ino, ext2_ino_t parent) ctx->dir_info_size += 10; retval = ext2fs_resize_mem(old_size, ctx->dir_info_size * sizeof(struct dir_info), - (void **) &ctx->dir_info); + &ctx->dir_info); if (retval) { ctx->dir_info_size -= 10; return; @@ -110,7 +110,7 @@ struct dir_info *e2fsck_get_dir_info(e2fsck_t ctx, ext2_ino_t ino) void e2fsck_free_dir_info(e2fsck_t ctx) { if (ctx->dir_info) { - ext2fs_free_mem((void **) &ctx->dir_info); + ext2fs_free_mem(&ctx->dir_info); ctx->dir_info = 0; } ctx->dir_info_size = 0; diff --git a/e2fsck/dx_dirinfo.c b/e2fsck/dx_dirinfo.c index ff90e99f..322f5167 100644 --- a/e2fsck/dx_dirinfo.c +++ b/e2fsck/dx_dirinfo.c @@ -37,7 +37,7 @@ void e2fsck_add_dx_dir(e2fsck_t ctx, ext2_ino_t ino, int num_blocks) ctx->dx_dir_info_size += 10; retval = ext2fs_resize_mem(old_size, ctx->dx_dir_info_size * sizeof(struct dx_dir_info), - (void **) &ctx->dx_dir_info); + &ctx->dx_dir_info); if (retval) { ctx->dx_dir_info_size -= 10; return; @@ -117,11 +117,11 @@ void e2fsck_free_dx_dir_info(e2fsck_t ctx) dir = ctx->dx_dir_info; for (i=0; i < ctx->dx_dir_info_count; i++) { if (dir->dx_block) { - ext2fs_free_mem((void **) &dir->dx_block); + ext2fs_free_mem(&dir->dx_block); dir->dx_block = 0; } } - ext2fs_free_mem((void **) &ctx->dx_dir_info); + ext2fs_free_mem(&ctx->dx_dir_info); ctx->dx_dir_info = 0; } ctx->dx_dir_info_size = 0; diff --git a/e2fsck/e2fsck.c b/e2fsck/e2fsck.c index 5a21bd5e..4c593f37 100644 --- a/e2fsck/e2fsck.c +++ b/e2fsck/e2fsck.c @@ -22,8 +22,7 @@ errcode_t e2fsck_allocate_context(e2fsck_t *ret) e2fsck_t context; errcode_t retval; - retval = ext2fs_get_mem(sizeof(struct e2fsck_struct), - (void **) &context); + retval = ext2fs_get_mem(sizeof(struct e2fsck_struct), &context); if (retval) return retval; @@ -115,15 +114,15 @@ errcode_t e2fsck_reset_context(e2fsck_t ctx) * Clear the array of invalid meta-data flags */ if (ctx->invalid_inode_bitmap_flag) { - ext2fs_free_mem((void **) &ctx->invalid_inode_bitmap_flag); + ext2fs_free_mem(&ctx->invalid_inode_bitmap_flag); ctx->invalid_inode_bitmap_flag = 0; } if (ctx->invalid_block_bitmap_flag) { - ext2fs_free_mem((void **) &ctx->invalid_block_bitmap_flag); + ext2fs_free_mem(&ctx->invalid_block_bitmap_flag); ctx->invalid_block_bitmap_flag = 0; } if (ctx->invalid_inode_table_flag) { - ext2fs_free_mem((void **) &ctx->invalid_inode_table_flag); + ext2fs_free_mem(&ctx->invalid_inode_table_flag); ctx->invalid_inode_table_flag = 0; } @@ -160,7 +159,7 @@ void e2fsck_free_context(e2fsck_t ctx) if (ctx->blkid) blkid_put_cache(ctx->blkid); - ext2fs_free_mem((void **) &ctx); + ext2fs_free_mem(&ctx); } /* diff --git a/e2fsck/ea_refcount.c b/e2fsck/ea_refcount.c index 04ba47c5..de13316e 100644 --- a/e2fsck/ea_refcount.c +++ b/e2fsck/ea_refcount.c @@ -38,8 +38,8 @@ void ea_refcount_free(ext2_refcount_t refcount) return; if (refcount->list) - ext2fs_free_mem((void **) &refcount->list); - ext2fs_free_mem((void **) &refcount); + ext2fs_free_mem(&refcount->list); + ext2fs_free_mem(&refcount); } errcode_t ea_refcount_create(int size, ext2_refcount_t *ret) @@ -48,8 +48,7 @@ errcode_t ea_refcount_create(int size, ext2_refcount_t *ret) errcode_t retval; size_t bytes; - retval = ext2fs_get_mem(sizeof(struct ea_refcount), - (void **) &refcount); + retval = ext2fs_get_mem(sizeof(struct ea_refcount), &refcount); if (retval) return retval; memset(refcount, 0, sizeof(struct ea_refcount)); @@ -62,7 +61,7 @@ errcode_t ea_refcount_create(int size, ext2_refcount_t *ret) printf("Refcount allocated %d entries, %d bytes.\n", refcount->size, bytes); #endif - retval = ext2fs_get_mem(bytes, (void **) &refcount->list); + retval = ext2fs_get_mem(bytes, &refcount->list); if (retval) goto errout; memset(refcount->list, 0, bytes); @@ -124,7 +123,7 @@ static struct ea_refcount_el *insert_refcount_el(ext2_refcount_t refcount, sizeof(struct ea_refcount_el), (size_t) new_size * sizeof(struct ea_refcount_el), - (void **) &refcount->list); + &refcount->list); if (retval) return 0; refcount->size = new_size; diff --git a/e2fsck/journal.c b/e2fsck/journal.c index 87256198..1ca73663 100644 --- a/e2fsck/journal.c +++ b/e2fsck/journal.c @@ -145,7 +145,7 @@ void brelse(struct buffer_head *bh) ll_rw_block(WRITE, 1, &bh); jfs_debug(3, "freeing block %lu/%p (total %d)\n", (unsigned long) bh->b_blocknr, (void *) bh, --bh_count); - ext2fs_free_mem((void **) &bh); + ext2fs_free_mem(&bh); } int buffer_uptodate(struct buffer_head *bh) @@ -338,7 +338,7 @@ static errcode_t e2fsck_get_journal(e2fsck_t ctx, journal_t **ret_journal) #ifdef USE_INODE_IO if (j_inode) - ext2fs_free_mem((void **)&j_inode); + ext2fs_free_mem(&j_inode); #endif *ret_journal = journal; @@ -346,11 +346,11 @@ static errcode_t e2fsck_get_journal(e2fsck_t ctx, journal_t **ret_journal) errout: if (dev_fs) - ext2fs_free_mem((void **)&dev_fs); + ext2fs_free_mem(&dev_fs); if (j_inode) - ext2fs_free_mem((void **)&j_inode); + ext2fs_free_mem(&j_inode); if (journal) - ext2fs_free_mem((void **)&journal); + ext2fs_free_mem(&journal); return retval; } @@ -588,11 +588,11 @@ static void e2fsck_journal_release(e2fsck_t ctx, journal_t *journal, #ifndef USE_INODE_IO if (journal->j_inode) - ext2fs_free_mem((void **)&journal->j_inode); + ext2fs_free_mem(&journal->j_inode); #endif if (journal->j_fs_dev) - ext2fs_free_mem((void **)&journal->j_fs_dev); - ext2fs_free_mem((void **)&journal); + ext2fs_free_mem(&journal->j_fs_dev); + ext2fs_free_mem(&journal); } /* diff --git a/e2fsck/message.c b/e2fsck/message.c index 059e2949..6c19f575 100644 --- a/e2fsck/message.c +++ b/e2fsck/message.c @@ -197,7 +197,7 @@ static void print_pathname(ext2_filsys fs, ext2_ino_t dir, ext2_ino_t ino) fputs("???", stdout); else { safe_print(path, -1); - ext2fs_free_mem((void **) &path); + ext2fs_free_mem(&path); } } diff --git a/e2fsck/pass1.c b/e2fsck/pass1.c index 989641b6..a585cfff 100644 --- a/e2fsck/pass1.c +++ b/e2fsck/pass1.c @@ -114,7 +114,7 @@ static __u64 ext2_max_sizes[EXT2_MAX_BLOCK_LOG_SIZE - */ static void unwind_pass1(ext2_filsys fs) { - ext2fs_free_mem((void **) &inodes_to_process); + ext2fs_free_mem(&inodes_to_process); inodes_to_process = 0; } @@ -724,11 +724,11 @@ void e2fsck_pass1(e2fsck_t ctx) } e2fsck_pass1_dupblocks(ctx, block_buf); } - ext2fs_free_mem((void **) &inodes_to_process); + ext2fs_free_mem(&inodes_to_process); endit: e2fsck_use_inode_shortcuts(ctx, 0); - ext2fs_free_mem((void **) &block_buf); + ext2fs_free_mem(&block_buf); #ifdef RESOURCE_TRACK if (ctx->options & E2F_OPT_TIME2) { @@ -1710,7 +1710,7 @@ static void new_table_block(e2fsck_t ctx, blk_t first_block, int group, ext2fs_unmark_valid(fs); return; } - pctx.errcode = ext2fs_get_mem(fs->blocksize, (void **) &buf); + pctx.errcode = ext2fs_get_mem(fs->blocksize, &buf); if (pctx.errcode) { fix_problem(ctx, PR_1_RELOC_MEMORY_ALLOCATE, &pctx); ext2fs_unmark_valid(fs); @@ -1739,7 +1739,7 @@ static void new_table_block(e2fsck_t ctx, blk_t first_block, int group, if (pctx.errcode) fix_problem(ctx, PR_1_RELOC_WRITE_ERR, &pctx); } - ext2fs_free_mem((void **) &buf); + ext2fs_free_mem(&buf); } /* diff --git a/e2fsck/pass1b.c b/e2fsck/pass1b.c index 9a061776..c5ad8ba9 100644 --- a/e2fsck/pass1b.c +++ b/e2fsck/pass1b.c @@ -496,7 +496,7 @@ static void pass1d(e2fsck_t ctx, char *block_buf) else ext2fs_unmark_valid(fs); } - ext2fs_free_mem((void **) &shared); + ext2fs_free_mem(&shared); } /* @@ -696,7 +696,7 @@ static int clone_file(e2fsck_t ctx, ext2_ino_t ino, cs.errcode = 0; cs.dir = 0; cs.ctx = ctx; - retval = ext2fs_get_mem(fs->blocksize, (void **) &cs.buf); + retval = ext2fs_get_mem(fs->blocksize, &cs.buf); if (retval) return retval; @@ -749,7 +749,7 @@ static int clone_file(e2fsck_t ctx, ext2_ino_t ino, } retval = 0; errout: - ext2fs_free_mem((void **) &cs.buf); + ext2fs_free_mem(&cs.buf); return retval; } diff --git a/e2fsck/pass2.c b/e2fsck/pass2.c index 0385c761..6f2ac937 100644 --- a/e2fsck/pass2.c +++ b/e2fsck/pass2.c @@ -251,7 +251,7 @@ void e2fsck_pass2(e2fsck_t ctx) #endif } #endif - ext2fs_free_mem((void **) &buf); + ext2fs_free_mem(&buf); ext2fs_free_dblist(fs->dblist); if (ctx->inode_bad_map) { @@ -1332,7 +1332,7 @@ static int allocate_dir_block(e2fsck_t ctx, } pctx->errcode = ext2fs_write_dir_block(fs, blk, block); - ext2fs_free_mem((void **) &block); + ext2fs_free_mem(&block); if (pctx->errcode) { pctx->str = "ext2fs_write_dir_block"; fix_problem(ctx, PR_2_ALLOC_DIRBOCK, pctx); diff --git a/e2fsck/pass3.c b/e2fsck/pass3.c index 86f2e621..bafcb4cc 100644 --- a/e2fsck/pass3.c +++ b/e2fsck/pass3.c @@ -214,7 +214,7 @@ static void check_root(e2fsck_t ctx) ctx->flags |= E2F_FLAG_ABORT; return; } - ext2fs_free_mem((void **) &block); + ext2fs_free_mem(&block); /* * Set up the inode structure @@ -456,7 +456,7 @@ ext2_ino_t e2fsck_get_lost_and_found(e2fsck_t ctx, int fix) } retval = ext2fs_write_dir_block(fs, blk, block); - ext2fs_free_mem((void **) &block); + ext2fs_free_mem(&block); if (retval) { pctx.errcode = retval; fix_problem(ctx, PR_3_ERR_LPF_WRITE_BLOCK, &pctx); @@ -728,7 +728,7 @@ static int expand_dir_proc(ext2_filsys fs, es->num--; retval = ext2fs_write_dir_block(fs, new_blk, block); } else { - retval = ext2fs_get_mem(fs->blocksize, (void **) &block); + retval = ext2fs_get_mem(fs->blocksize, &block); if (retval) { es->err = retval; return BLOCK_ABORT; @@ -740,7 +740,7 @@ static int expand_dir_proc(ext2_filsys fs, es->err = retval; return BLOCK_ABORT; } - ext2fs_free_mem((void **) &block); + ext2fs_free_mem(&block); *blocknr = new_blk; ext2fs_mark_block_bitmap(ctx->block_found_map, new_blk); ext2fs_block_alloc_stats(fs, new_blk, +1); diff --git a/e2fsck/pass4.c b/e2fsck/pass4.c index d1ffd82e..a9e49f17 100644 --- a/e2fsck/pass4.c +++ b/e2fsck/pass4.c @@ -167,7 +167,7 @@ void e2fsck_pass4(e2fsck_t ctx) ext2fs_free_inode_bitmap(ctx->inode_imagic_map); ctx->inode_imagic_map = 0; if (buf) - ext2fs_free_mem((void **) &buf); + ext2fs_free_mem(&buf); #ifdef RESOURCE_TRACK if (ctx->options & E2F_OPT_TIME2) { e2fsck_clear_progbar(ctx); diff --git a/e2fsck/pass5.c b/e2fsck/pass5.c index 7fe7c6df..862b7e04 100644 --- a/e2fsck/pass5.c +++ b/e2fsck/pass5.c @@ -268,7 +268,7 @@ redo_counts: } else ext2fs_unmark_valid(fs); } - ext2fs_free_mem((void **) &free_array); + ext2fs_free_mem(&free_array); } static void check_inode_bitmaps(e2fsck_t ctx) @@ -452,8 +452,8 @@ do_counts: } else ext2fs_unmark_valid(fs); } - ext2fs_free_mem((void **) &free_array); - ext2fs_free_mem((void **) &dir_array); + ext2fs_free_mem(&free_array); + ext2fs_free_mem(&dir_array); } static void check_inode_end(e2fsck_t ctx) diff --git a/e2fsck/super.c b/e2fsck/super.c index 9210739a..b6c5e746 100644 --- a/e2fsck/super.c +++ b/e2fsck/super.c @@ -303,10 +303,10 @@ static int release_orphan_inodes(e2fsck_t ctx) e2fsck_write_inode(ctx, ino, &inode, "delete_file"); ino = next_ino; } - ext2fs_free_mem((void **) &block_buf); + ext2fs_free_mem(&block_buf); return 0; return_abort: - ext2fs_free_mem((void **) &block_buf); + ext2fs_free_mem(&block_buf); return 1; } diff --git a/e2fsck/swapfs.c b/e2fsck/swapfs.c index de71369f..8e9a134f 100644 --- a/e2fsck/swapfs.c +++ b/e2fsck/swapfs.c @@ -119,7 +119,7 @@ static void swap_inodes(e2fsck_t ctx) e2fsck_use_inode_shortcuts(ctx, 1); retval = ext2fs_get_mem(fs->blocksize * fs->inode_blocks_per_group, - (void **) &buf); + &buf); if (retval) { com_err("swap_inodes", retval, _("while allocating inode buffer")); @@ -178,8 +178,8 @@ static void swap_inodes(e2fsck_t ctx) return; } } - ext2fs_free_mem((void **) &buf); - ext2fs_free_mem((void **) &block_buf); + ext2fs_free_mem(&buf); + ext2fs_free_mem(&block_buf); e2fsck_use_inode_shortcuts(ctx, 0); } diff --git a/lib/ext2fs/ChangeLog b/lib/ext2fs/ChangeLog index 701c0428..7181f98d 100644 --- a/lib/ext2fs/ChangeLog +++ b/lib/ext2fs/ChangeLog @@ -1,3 +1,16 @@ +2003-08-01 Philipp Thomas + + * alloc.c, badblocks.c, bb_inode.c, bitmaps.c, block.c, bmap.c, + bmove.c, brel_ma.c, closefs.c, dblist.c, dblist_dir.c, + dir_iterate.c, dirblock.c, dupfs.c, expanddir.c, ext2fs.h, + ext_attr.c, fileio.c, freefs.c, get_pathname.c, icount.c, + initialize.c, inode.c, inode_io.c, irel_ma.c, mkdir.c, + mkjournal.c, namei.c, newdir.c, openfs.c, rs_bitmap.c, + rw_bitmaps.c, test_io.c, unix_io.c: ext2fs_getmem(), + ext2fs_free_mem(), and ext2fs_resize_mem() all now take a + 'void *' instead of a 'void **' in order to avoid pointer + aliasing problems with GCC 3.x. + 2003-07-25 Theodore Ts'o * Release of E2fsprogs 1.34 diff --git a/lib/ext2fs/alloc.c b/lib/ext2fs/alloc.c index 2dc4fc7d..3356006f 100644 --- a/lib/ext2fs/alloc.c +++ b/lib/ext2fs/alloc.c @@ -110,7 +110,7 @@ errcode_t ext2fs_alloc_block(ext2_filsys fs, blk_t goal, char *buf = 0; if (!block_buf) { - retval = ext2fs_get_mem(fs->blocksize, (void **) &buf); + retval = ext2fs_get_mem(fs->blocksize, &buf); if (retval) return retval; block_buf = buf; @@ -137,7 +137,7 @@ errcode_t ext2fs_alloc_block(ext2_filsys fs, blk_t goal, fail: if (buf) - ext2fs_free_mem((void **) &buf); + ext2fs_free_mem(&buf); return retval; } diff --git a/lib/ext2fs/badblocks.c b/lib/ext2fs/badblocks.c index 9fda70cc..4b76ef03 100644 --- a/lib/ext2fs/badblocks.c +++ b/lib/ext2fs/badblocks.c @@ -35,17 +35,16 @@ static errcode_t make_u32_list(int size, int num, __u32 *list, ext2_u32_list bb; errcode_t retval; - retval = ext2fs_get_mem(sizeof(struct ext2_struct_u32_list), - (void **) &bb); + retval = ext2fs_get_mem(sizeof(struct ext2_struct_u32_list), &bb); if (retval) return retval; memset(bb, 0, sizeof(struct ext2_struct_u32_list)); bb->magic = EXT2_ET_MAGIC_BADBLOCKS_LIST; bb->size = size ? size : 10; bb->num = num; - retval = ext2fs_get_mem(bb->size * sizeof(blk_t), (void **) &bb->list); + retval = ext2fs_get_mem(bb->size * sizeof(blk_t), &bb->list); if (!bb->list) { - ext2fs_free_mem((void **) &bb); + ext2fs_free_mem(&bb); return retval; } if (list) @@ -117,7 +116,7 @@ errcode_t ext2fs_u32_list_add(ext2_u32_list bb, __u32 blk) old_size = bb->size * sizeof(__u32); bb->size += 100; retval = ext2fs_resize_mem(old_size, bb->size * sizeof(__u32), - (void **) &bb->list); + &bb->list); if (retval) { bb->size -= 100; return retval; @@ -242,8 +241,7 @@ errcode_t ext2fs_u32_list_iterate_begin(ext2_u32_list bb, EXT2_CHECK_MAGIC(bb, EXT2_ET_MAGIC_BADBLOCKS_LIST); - retval = ext2fs_get_mem(sizeof(struct ext2_struct_u32_iterate), - (void **) &iter); + retval = ext2fs_get_mem(sizeof(struct ext2_struct_u32_iterate), &iter); if (retval) return retval; @@ -295,7 +293,7 @@ void ext2fs_u32_list_iterate_end(ext2_u32_iterate iter) return; iter->bb = 0; - ext2fs_free_mem((void **) &iter); + ext2fs_free_mem(&iter); } void ext2fs_badblocks_list_iterate_end(ext2_badblocks_iterate iter) diff --git a/lib/ext2fs/bb_inode.c b/lib/ext2fs/bb_inode.c index 4c575cf8..f601787d 100644 --- a/lib/ext2fs/bb_inode.c +++ b/lib/ext2fs/bb_inode.c @@ -69,11 +69,11 @@ errcode_t ext2fs_update_bb_inode(ext2_filsys fs, ext2_badblocks_list bb_list) rec.ind_blocks_size = rec.ind_blocks_ptr = 0; rec.max_ind_blocks = 10; retval = ext2fs_get_mem(rec.max_ind_blocks * sizeof(blk_t), - (void **) &rec.ind_blocks); + &rec.ind_blocks); if (retval) return retval; memset(rec.ind_blocks, 0, rec.max_ind_blocks * sizeof(blk_t)); - retval = ext2fs_get_mem(fs->blocksize, (void **) &rec.block_buf); + retval = ext2fs_get_mem(fs->blocksize, &rec.block_buf); if (retval) goto cleanup; memset(rec.block_buf, 0, fs->blocksize); @@ -135,8 +135,8 @@ errcode_t ext2fs_update_bb_inode(ext2_filsys fs, ext2_badblocks_list bb_list) goto cleanup; cleanup: - ext2fs_free_mem((void **) &rec.ind_blocks); - ext2fs_free_mem((void **) &rec.block_buf); + ext2fs_free_mem(&rec.ind_blocks); + ext2fs_free_mem(&rec.block_buf); return retval; } @@ -177,7 +177,7 @@ static int clear_bad_block_proc(ext2_filsys fs, blk_t *block_nr, rec->max_ind_blocks += 10; retval = ext2fs_resize_mem(old_size, rec->max_ind_blocks * sizeof(blk_t), - (void **) &rec->ind_blocks); + &rec->ind_blocks); if (retval) { rec->max_ind_blocks -= 10; rec->err = retval; diff --git a/lib/ext2fs/bitmaps.c b/lib/ext2fs/bitmaps.c index 44f16a9d..7edd28d7 100644 --- a/lib/ext2fs/bitmaps.c +++ b/lib/ext2fs/bitmaps.c @@ -35,8 +35,8 @@ static errcode_t make_bitmap(__u32 start, __u32 end, __u32 real_end, errcode_t retval; size_t size; - retval = ext2fs_get_mem(sizeof(struct ext2fs_struct_generic_bitmap), - (void **) &bitmap); + retval = ext2fs_get_mem(sizeof(struct ext2fs_struct_generic_bitmap), + &bitmap); if (retval) return retval; @@ -47,10 +47,9 @@ static errcode_t make_bitmap(__u32 start, __u32 end, __u32 real_end, bitmap->real_end = real_end; bitmap->base_error_code = EXT2_ET_BAD_GENERIC_MARK; if (descr) { - retval = ext2fs_get_mem(strlen(descr)+1, - (void **) &bitmap->description); + retval = ext2fs_get_mem(strlen(descr)+1, &bitmap->description); if (retval) { - ext2fs_free_mem((void **) &bitmap); + ext2fs_free_mem(&bitmap); return retval; } strcpy(bitmap->description, descr); @@ -58,10 +57,10 @@ static errcode_t make_bitmap(__u32 start, __u32 end, __u32 real_end, bitmap->description = 0; size = (size_t) (((bitmap->real_end - bitmap->start) / 8) + 1); - retval = ext2fs_get_mem(size, (void **) &bitmap->bitmap); + retval = ext2fs_get_mem(size, &bitmap->bitmap); if (retval) { - ext2fs_free_mem((void **) &bitmap->description); - ext2fs_free_mem((void **) &bitmap); + ext2fs_free_mem(&bitmap->description); + ext2fs_free_mem(&bitmap); return retval; } diff --git a/lib/ext2fs/block.c b/lib/ext2fs/block.c index a0bf7382..338b9180 100644 --- a/lib/ext2fs/block.c +++ b/lib/ext2fs/block.c @@ -373,8 +373,7 @@ errcode_t ext2fs_block_iterate2(ext2_filsys fs, if (block_buf) { ctx.ind_buf = block_buf; } else { - retval = ext2fs_get_mem(fs->blocksize * 3, - (void **) &ctx.ind_buf); + retval = ext2fs_get_mem(fs->blocksize * 3, &ctx.ind_buf); if (retval) return retval; } @@ -447,7 +446,7 @@ abort_exit: } if (!block_buf) - ext2fs_free_mem((void **) &ctx.ind_buf); + ext2fs_free_mem(&ctx.ind_buf); return (ret & BLOCK_ERROR) ? ctx.errcode : 0; } diff --git a/lib/ext2fs/bmap.c b/lib/ext2fs/bmap.c index 0fb56d66..45053dc1 100644 --- a/lib/ext2fs/bmap.c +++ b/lib/ext2fs/bmap.c @@ -146,7 +146,7 @@ errcode_t ext2fs_bmap(ext2_filsys fs, ext2_ino_t ino, struct ext2_inode *inode, addr_per_block = (blk_t) fs->blocksize >> 2; if (!block_buf) { - retval = ext2fs_get_mem(fs->blocksize * 2, (void **) &buf); + retval = ext2fs_get_mem(fs->blocksize * 2, &buf); if (retval) return retval; block_buf = buf; @@ -225,7 +225,7 @@ errcode_t ext2fs_bmap(ext2_filsys fs, ext2_ino_t ino, struct ext2_inode *inode, &blocks_alloc, block, phys_blk); done: if (buf) - ext2fs_free_mem((void **) &buf); + ext2fs_free_mem(&buf); if ((retval == 0) && blocks_alloc) { inode->i_blocks += (blocks_alloc * fs->blocksize) / 512; retval = ext2fs_write_inode(fs, ino, inode); diff --git a/lib/ext2fs/bmove.c b/lib/ext2fs/bmove.c index c0205ca8..0b2ebb18 100644 --- a/lib/ext2fs/bmove.c +++ b/lib/ext2fs/bmove.c @@ -108,7 +108,7 @@ errcode_t ext2fs_move_blocks(ext2_filsys fs, pb.alloc_map = alloc_map ? alloc_map : fs->block_map; pb.flags = flags; - retval = ext2fs_get_mem(fs->blocksize * 4, (void **) &block_buf); + retval = ext2fs_get_mem(fs->blocksize * 4, &block_buf); if (retval) return retval; pb.buf = block_buf + fs->blocksize * 3; diff --git a/lib/ext2fs/brel_ma.c b/lib/ext2fs/brel_ma.c index 8ad8e9fa..d422bb2e 100644 --- a/lib/ext2fs/brel_ma.c +++ b/lib/ext2fs/brel_ma.c @@ -57,17 +57,17 @@ errcode_t ext2fs_brel_memarray_create(char *name, blk_t max_block, * Allocate memory structures */ retval = ext2fs_get_mem(sizeof(struct ext2_block_relocation_table), - (void **) &brel); + &brel); if (retval) goto errout; memset(brel, 0, sizeof(struct ext2_block_relocation_table)); - retval = ext2fs_get_mem(strlen(name)+1, (void **) &brel->name); + retval = ext2fs_get_mem(strlen(name)+1, &brel->name); if (retval) goto errout; strcpy(brel->name, name); - retval = ext2fs_get_mem(sizeof(struct brel_ma), (void **) &ma); + retval = ext2fs_get_mem(sizeof(struct brel_ma), &ma); if (retval) goto errout; memset(ma, 0, sizeof(struct brel_ma)); @@ -75,7 +75,7 @@ errcode_t ext2fs_brel_memarray_create(char *name, blk_t max_block, size = (size_t) (sizeof(struct ext2_block_relocate_entry) * (max_block+1)); - retval = ext2fs_get_mem(size, (void **) &ma->entries); + retval = ext2fs_get_mem(size, &ma->entries); if (retval) goto errout; memset(ma->entries, 0, size); @@ -187,11 +187,11 @@ static errcode_t bma_free(ext2_brel brel) if (ma) { if (ma->entries) - ext2fs_free_mem((void **) &ma->entries); - ext2fs_free_mem((void **) &ma); + ext2fs_free_mem(&ma->entries); + ext2fs_free_mem(&ma); } if (brel->name) - ext2fs_free_mem((void **) &brel->name); - ext2fs_free_mem((void **) &brel); + ext2fs_free_mem(&brel->name); + ext2fs_free_mem(&brel); return 0; } diff --git a/lib/ext2fs/closefs.c b/lib/ext2fs/closefs.c index 02e04a14..74acbeab 100644 --- a/lib/ext2fs/closefs.c +++ b/lib/ext2fs/closefs.c @@ -199,13 +199,12 @@ errcode_t ext2fs_flush(ext2_filsys fs) #ifdef EXT2FS_ENABLE_SWAPFS if (fs->flags & EXT2_FLAG_SWAP_BYTES) { retval = EXT2_ET_NO_MEMORY; - retval = ext2fs_get_mem(SUPERBLOCK_SIZE, - (void **) &super_shadow); + retval = ext2fs_get_mem(SUPERBLOCK_SIZE, &super_shadow); if (retval) goto errout; retval = ext2fs_get_mem((size_t)(fs->blocksize * fs->desc_blocks), - (void **) &group_shadow); + &group_shadow); if (retval) goto errout; memset(group_shadow, 0, (size_t) fs->blocksize * @@ -306,9 +305,9 @@ errout: fs->super->s_state = fs_state; if (fs->flags & EXT2_FLAG_SWAP_BYTES) { if (super_shadow) - ext2fs_free_mem((void **) &super_shadow); + ext2fs_free_mem(&super_shadow); if (group_shadow) - ext2fs_free_mem((void **) &group_shadow); + ext2fs_free_mem(&group_shadow); } return retval; } diff --git a/lib/ext2fs/dblist.c b/lib/ext2fs/dblist.c index a3f99ebe..d5833d72 100644 --- a/lib/ext2fs/dblist.c +++ b/lib/ext2fs/dblist.c @@ -68,8 +68,7 @@ static errcode_t make_dblist(ext2_filsys fs, ext2_ino_t size, ext2_ino_t count, (fs->dblist->magic == EXT2_ET_MAGIC_DBLIST)) return 0; - retval = ext2fs_get_mem(sizeof(struct ext2_struct_dblist), - (void **) &dblist); + retval = ext2fs_get_mem(sizeof(struct ext2_struct_dblist), &dblist); if (retval) return retval; memset(dblist, 0, sizeof(struct ext2_struct_dblist)); @@ -86,7 +85,7 @@ static errcode_t make_dblist(ext2_filsys fs, ext2_ino_t size, ext2_ino_t count, } len = (size_t) sizeof(struct ext2_db_entry) * dblist->size; dblist->count = count; - retval = ext2fs_get_mem(len, (void **) &dblist->list); + retval = ext2fs_get_mem(len, &dblist->list); if (retval) goto cleanup; @@ -101,7 +100,7 @@ static errcode_t make_dblist(ext2_filsys fs, ext2_ino_t size, ext2_ino_t count, return 0; cleanup: if (dblist) - ext2fs_free_mem((void **) &dblist); + ext2fs_free_mem(&dblist); return retval; } @@ -167,7 +166,7 @@ errcode_t ext2fs_add_dir_block(ext2_dblist dblist, ext2_ino_t ino, blk_t blk, dblist->size += 100; retval = ext2fs_resize_mem(old_size, (size_t) dblist->size * sizeof(struct ext2_db_entry), - (void **) &dblist->list); + &dblist->list); if (retval) { dblist->size -= 100; return retval; diff --git a/lib/ext2fs/dblist_dir.c b/lib/ext2fs/dblist_dir.c index f0e4a26f..f2e17a61 100644 --- a/lib/ext2fs/dblist_dir.c +++ b/lib/ext2fs/dblist_dir.c @@ -45,8 +45,7 @@ errcode_t ext2fs_dblist_dir_iterate(ext2_dblist dblist, if (block_buf) ctx.buf = block_buf; else { - retval = ext2fs_get_mem(dblist->fs->blocksize, - (void **) &ctx.buf); + retval = ext2fs_get_mem(dblist->fs->blocksize, &ctx.buf); if (retval) return retval; } @@ -57,7 +56,7 @@ errcode_t ext2fs_dblist_dir_iterate(ext2_dblist dblist, retval = ext2fs_dblist_iterate(dblist, db_dir_proc, &ctx); if (!block_buf) - ext2fs_free_mem((void **) &ctx.buf); + ext2fs_free_mem(&ctx.buf); if (retval) return retval; return ctx.errcode; diff --git a/lib/ext2fs/dir_iterate.c b/lib/ext2fs/dir_iterate.c index 35fae073..9a6ac915 100644 --- a/lib/ext2fs/dir_iterate.c +++ b/lib/ext2fs/dir_iterate.c @@ -71,7 +71,7 @@ errcode_t ext2fs_dir_iterate2(ext2_filsys fs, if (block_buf) ctx.buf = block_buf; else { - retval = ext2fs_get_mem(fs->blocksize, (void **) &ctx.buf); + retval = ext2fs_get_mem(fs->blocksize, &ctx.buf); if (retval) return retval; } @@ -81,7 +81,7 @@ errcode_t ext2fs_dir_iterate2(ext2_filsys fs, retval = ext2fs_block_iterate2(fs, dir, 0, 0, ext2fs_process_dir_block, &ctx); if (!block_buf) - ext2fs_free_mem((void **) &ctx.buf); + ext2fs_free_mem(&ctx.buf); if (retval) return retval; return ctx.errcode; diff --git a/lib/ext2fs/dirblock.c b/lib/ext2fs/dirblock.c index 185384b1..0cb07c72 100644 --- a/lib/ext2fs/dirblock.c +++ b/lib/ext2fs/dirblock.c @@ -89,7 +89,7 @@ errcode_t ext2fs_write_dir_block2(ext2_filsys fs, blk_t block, return io_channel_write_blk(fs->io, block, 1, (char *) inbuf); #endif - retval = ext2fs_get_mem(fs->blocksize, (void **) &buf); + retval = ext2fs_get_mem(fs->blocksize, &buf); if (retval) return retval; memcpy(buf, inbuf, fs->blocksize); @@ -99,7 +99,7 @@ errcode_t ext2fs_write_dir_block2(ext2_filsys fs, blk_t block, dirent = (struct ext2_dir_entry *) p; if ((dirent->rec_len < 8) || (dirent->rec_len % 4)) { - ext2fs_free_mem((void **) &buf); + ext2fs_free_mem(&buf); return (EXT2_ET_DIR_CORRUPTED); } p += dirent->rec_len; @@ -114,7 +114,7 @@ errcode_t ext2fs_write_dir_block2(ext2_filsys fs, blk_t block, #endif } retval = io_channel_write_blk(fs->io, block, 1, buf); - ext2fs_free_mem((void **) &buf); + ext2fs_free_mem(&buf); return retval; #else return io_channel_write_blk(fs->io, block, 1, (char *) inbuf); diff --git a/lib/ext2fs/dupfs.c b/lib/ext2fs/dupfs.c index 31579a4a..5c1c6f3e 100644 --- a/lib/ext2fs/dupfs.c +++ b/lib/ext2fs/dupfs.c @@ -26,8 +26,7 @@ errcode_t ext2fs_dup_handle(ext2_filsys src, ext2_filsys *dest) EXT2_CHECK_MAGIC(src, EXT2_ET_MAGIC_EXT2FS_FILSYS); - retval = ext2fs_get_mem(sizeof(struct struct_ext2_filsys), - (void **) &fs); + retval = ext2fs_get_mem(sizeof(struct struct_ext2_filsys), &fs); if (retval) return retval; @@ -44,19 +43,18 @@ errcode_t ext2fs_dup_handle(ext2_filsys src, ext2_filsys *dest) if (fs->icache) fs->icache->refcount++; - retval = ext2fs_get_mem(strlen(src->device_name)+1, - (void **) &fs->device_name); + retval = ext2fs_get_mem(strlen(src->device_name)+1, &fs->device_name); if (retval) goto errout; strcpy(fs->device_name, src->device_name); - retval = ext2fs_get_mem(SUPERBLOCK_SIZE, (void **) &fs->super); + retval = ext2fs_get_mem(SUPERBLOCK_SIZE, &fs->super); if (retval) goto errout; memcpy(fs->super, src->super, SUPERBLOCK_SIZE); retval = ext2fs_get_mem((size_t) fs->desc_blocks * fs->blocksize, - (void **) &fs->group_desc); + &fs->group_desc); if (retval) goto errout; memcpy(fs->group_desc, src->group_desc, diff --git a/lib/ext2fs/expanddir.c b/lib/ext2fs/expanddir.c index efc2b22e..3c2c8037 100644 --- a/lib/ext2fs/expanddir.c +++ b/lib/ext2fs/expanddir.c @@ -55,7 +55,7 @@ static int expand_dir_proc(ext2_filsys fs, es->done = 1; retval = ext2fs_write_dir_block(fs, new_blk, block); } else { - retval = ext2fs_get_mem(fs->blocksize, (void **) &block); + retval = ext2fs_get_mem(fs->blocksize, &block); if (retval) { es->err = retval; return BLOCK_ABORT; @@ -67,7 +67,7 @@ static int expand_dir_proc(ext2_filsys fs, es->err = retval; return BLOCK_ABORT; } - ext2fs_free_mem((void **) &block); + ext2fs_free_mem(&block); *blocknr = new_blk; ext2fs_block_alloc_stats(fs, new_blk, +1); es->newblocks++; diff --git a/lib/ext2fs/ext2fs.h b/lib/ext2fs/ext2fs.h index d15d08a8..8087fa22 100644 --- a/lib/ext2fs/ext2fs.h +++ b/lib/ext2fs/ext2fs.h @@ -886,10 +886,10 @@ extern errcode_t ext2fs_write_bb_FILE(ext2_badblocks_list bb_list, /* inline functions */ -extern errcode_t ext2fs_get_mem(unsigned long size, void **ptr); -extern errcode_t ext2fs_free_mem(void **ptr); +extern errcode_t ext2fs_get_mem(unsigned long size, void *ptr); +extern errcode_t ext2fs_free_mem(void *ptr); extern errcode_t ext2fs_resize_mem(unsigned long old_size, - unsigned long size, void **ptr); + unsigned long size, void *ptr); extern void ext2fs_mark_super_dirty(ext2_filsys fs); extern void ext2fs_mark_changed(ext2_filsys fs); extern int ext2fs_test_changed(ext2_filsys fs); @@ -926,10 +926,12 @@ extern blk_t ext2fs_inode_data_blocks(ext2_filsys fs, /* * Allocate memory */ -_INLINE_ errcode_t ext2fs_get_mem(unsigned long size, void **ptr) +_INLINE_ errcode_t ext2fs_get_mem(unsigned long size, void *ptr) { - *ptr = malloc(size); - if (!*ptr) + void **pp = (void **)ptr; + + *pp = malloc(size); + if (!*pp) return EXT2_ET_NO_MEMORY; return 0; } @@ -937,10 +939,12 @@ _INLINE_ errcode_t ext2fs_get_mem(unsigned long size, void **ptr) /* * Free memory */ -_INLINE_ errcode_t ext2fs_free_mem(void **ptr) +_INLINE_ errcode_t ext2fs_free_mem(void *ptr) { - free(*ptr); - *ptr = 0; + void **pp = (void **)ptr; + + free(*pp); + *pp = 0; return 0; } @@ -948,14 +952,15 @@ _INLINE_ errcode_t ext2fs_free_mem(void **ptr) * Resize memory */ _INLINE_ errcode_t ext2fs_resize_mem(unsigned long old_size, - unsigned long size, void **ptr) + unsigned long size, void *ptr) { void *p; + void **pp = (void **)ptr; - p = realloc(*ptr, size); + p = realloc(*pp, size); if (!p) return EXT2_ET_NO_MEMORY; - *ptr = p; + *pp = p; return 0; } #endif /* Custom memory routines */ diff --git a/lib/ext2fs/ext_attr.c b/lib/ext2fs/ext_attr.c index 5ebb22bb..9aa092fc 100644 --- a/lib/ext2fs/ext_attr.c +++ b/lib/ext2fs/ext_attr.c @@ -83,7 +83,7 @@ errcode_t ext2fs_write_ext_attr(ext2_filsys fs, blk_t block, void *inbuf) #ifdef EXT2FS_ENABLE_SWAPFS if ((fs->flags & EXT2_FLAG_SWAP_BYTES) || (fs->flags & EXT2_FLAG_SWAP_BYTES_WRITE)) { - retval = ext2fs_get_mem(fs->blocksize, (void **) &buf); + retval = ext2fs_get_mem(fs->blocksize, &buf); if (retval) return retval; write_buf = buf; @@ -93,7 +93,7 @@ errcode_t ext2fs_write_ext_attr(ext2_filsys fs, blk_t block, void *inbuf) write_buf = (char *) inbuf; retval = io_channel_write_blk(fs->io, block, 1, write_buf); if (buf) - ext2fs_free_mem((void **) &buf); + ext2fs_free_mem(&buf); if (!retval) ext2fs_mark_changed(fs); return retval; @@ -115,7 +115,7 @@ errcode_t ext2fs_adjust_ea_refcount(ext2_filsys fs, blk_t blk, return EXT2_ET_BAD_EA_BLOCK_NUM; if (!block_buf) { - retval = ext2fs_get_mem(fs->blocksize, (void **) &buf); + retval = ext2fs_get_mem(fs->blocksize, &buf); if (retval) return retval; block_buf = buf; @@ -136,6 +136,6 @@ errcode_t ext2fs_adjust_ea_refcount(ext2_filsys fs, blk_t blk, errout: if (buf) - ext2fs_free_mem((void **) &buf); + ext2fs_free_mem(&buf); return retval; } diff --git a/lib/ext2fs/fileio.c b/lib/ext2fs/fileio.c index 3db41023..39455b9a 100644 --- a/lib/ext2fs/fileio.c +++ b/lib/ext2fs/fileio.c @@ -46,7 +46,7 @@ errcode_t ext2fs_file_open(ext2_filsys fs, ext2_ino_t ino, !(fs->flags & EXT2_FLAG_RW)) return EXT2_ET_RO_FILSYS; - retval = ext2fs_get_mem(sizeof(struct ext2_file), (void **) &file); + retval = ext2fs_get_mem(sizeof(struct ext2_file), &file); if (retval) return retval; @@ -60,7 +60,7 @@ errcode_t ext2fs_file_open(ext2_filsys fs, ext2_ino_t ino, if (retval) goto fail; - retval = ext2fs_get_mem(fs->blocksize * 3, (void **) &file->buf); + retval = ext2fs_get_mem(fs->blocksize * 3, &file->buf); if (retval) goto fail; @@ -69,8 +69,8 @@ errcode_t ext2fs_file_open(ext2_filsys fs, ext2_ino_t ino, fail: if (file->buf) - ext2fs_free_mem((void **) &file->buf); - ext2fs_free_mem((void **) &file); + ext2fs_free_mem(&file->buf); + ext2fs_free_mem(&file); return retval; } @@ -187,8 +187,8 @@ errcode_t ext2fs_file_close(ext2_file_t file) retval = ext2fs_file_flush(file); if (file->buf) - ext2fs_free_mem((void **) &file->buf); - ext2fs_free_mem((void **) &file); + ext2fs_free_mem(&file->buf); + ext2fs_free_mem(&file); return retval; } diff --git a/lib/ext2fs/freefs.c b/lib/ext2fs/freefs.c index 37de8692..78c64bf5 100644 --- a/lib/ext2fs/freefs.c +++ b/lib/ext2fs/freefs.c @@ -27,13 +27,13 @@ void ext2fs_free(ext2_filsys fs) io_channel_close(fs->io); } if (fs->device_name) - ext2fs_free_mem((void **) &fs->device_name); + ext2fs_free_mem(&fs->device_name); if (fs->super) - ext2fs_free_mem((void **) &fs->super); + ext2fs_free_mem(&fs->super); if (fs->orig_super) - ext2fs_free_mem((void **) &fs->orig_super); + ext2fs_free_mem(&fs->orig_super); if (fs->group_desc) - ext2fs_free_mem((void **) &fs->group_desc); + ext2fs_free_mem(&fs->group_desc); if (fs->block_map) ext2fs_free_block_bitmap(fs->block_map); if (fs->inode_map) @@ -51,7 +51,7 @@ void ext2fs_free(ext2_filsys fs) fs->magic = 0; - ext2fs_free_mem((void **) &fs); + ext2fs_free_mem(&fs); } void ext2fs_free_generic_bitmap(ext2fs_inode_bitmap bitmap) @@ -61,14 +61,14 @@ void ext2fs_free_generic_bitmap(ext2fs_inode_bitmap bitmap) bitmap->magic = 0; if (bitmap->description) { - ext2fs_free_mem((void **) &bitmap->description); + ext2fs_free_mem(&bitmap->description); bitmap->description = 0; } if (bitmap->bitmap) { - ext2fs_free_mem((void **) &bitmap->bitmap); + ext2fs_free_mem(&bitmap->bitmap); bitmap->bitmap = 0; } - ext2fs_free_mem((void **) &bitmap); + ext2fs_free_mem(&bitmap); } void ext2fs_free_inode_bitmap(ext2fs_inode_bitmap bitmap) @@ -97,11 +97,11 @@ static void ext2fs_free_inode_cache(struct ext2_inode_cache *icache) if (--icache->refcount) return; if (icache->buffer) - ext2fs_free_mem((void **) &icache->buffer); + ext2fs_free_mem(&icache->buffer); if (icache->cache) - ext2fs_free_mem((void **) &icache->cache); + ext2fs_free_mem(&icache->cache); icache->buffer_blk = 0; - ext2fs_free_mem((void **) &icache); + ext2fs_free_mem(&icache); } /* @@ -113,9 +113,9 @@ void ext2fs_u32_list_free(ext2_u32_list bb) return; if (bb->list) - ext2fs_free_mem((void **) &bb->list); + ext2fs_free_mem(&bb->list); bb->list = 0; - ext2fs_free_mem((void **) &bb); + ext2fs_free_mem(&bb); } void ext2fs_badblocks_list_free(ext2_badblocks_list bb) @@ -133,11 +133,11 @@ void ext2fs_free_dblist(ext2_dblist dblist) return; if (dblist->list) - ext2fs_free_mem((void **) &dblist->list); + ext2fs_free_mem(&dblist->list); dblist->list = 0; if (dblist->fs && dblist->fs->dblist == dblist) dblist->fs->dblist = 0; dblist->magic = 0; - ext2fs_free_mem((void **) &dblist); + ext2fs_free_mem(&dblist); } diff --git a/lib/ext2fs/get_pathname.c b/lib/ext2fs/get_pathname.c index e218f2e9..a8449c64 100644 --- a/lib/ext2fs/get_pathname.c +++ b/lib/ext2fs/get_pathname.c @@ -53,7 +53,7 @@ static int get_pathname_proc(struct ext2_dir_entry *dirent, gp->parent = dirent->inode; if (dirent->inode == gp->search_ino) { retval = ext2fs_get_mem((dirent->name_len & 0xFF) + 1, - (void **) &gp->name); + &gp->name); if (retval) { gp->errcode = retval; return DIRENT_ABORT; @@ -74,7 +74,7 @@ static errcode_t ext2fs_get_pathname_int(ext2_filsys fs, ext2_ino_t dir, errcode_t retval; if (dir == ino) { - retval = ext2fs_get_mem(2, (void **)name); + retval = ext2fs_get_mem(2, name); if (retval) return retval; strcpy(*name, (dir == EXT2_ROOT_INO) ? "/" : "."); @@ -82,7 +82,7 @@ static errcode_t ext2fs_get_pathname_int(ext2_filsys fs, ext2_ino_t dir, } if (!dir || (maxdepth < 0)) { - retval = ext2fs_get_mem(4, (void **)name); + retval = ext2fs_get_mem(4, name); if (retval) return retval; strcpy(*name, "..."); @@ -113,10 +113,9 @@ static errcode_t ext2fs_get_pathname_int(ext2_filsys fs, ext2_ino_t dir, if (gp.name) retval = ext2fs_get_mem(strlen(parent_name)+strlen(gp.name)+2, - (void **) &ret); + &ret); else - retval = ext2fs_get_mem(strlen(parent_name)+5, - (void **) &ret); + retval = ext2fs_get_mem(strlen(parent_name)+5, &ret); if (retval) goto cleanup; @@ -129,12 +128,12 @@ static errcode_t ext2fs_get_pathname_int(ext2_filsys fs, ext2_ino_t dir, else strcat(ret, "???"); *name = ret; - ext2fs_free_mem((void **) &parent_name); + ext2fs_free_mem(&parent_name); retval = 0; cleanup: if (gp.name) - ext2fs_free_mem((void **) &gp.name); + ext2fs_free_mem(&gp.name); return retval; } @@ -146,13 +145,13 @@ errcode_t ext2fs_get_pathname(ext2_filsys fs, ext2_ino_t dir, ext2_ino_t ino, EXT2_CHECK_MAGIC(fs, EXT2_ET_MAGIC_EXT2FS_FILSYS); - retval = ext2fs_get_mem(fs->blocksize, (void **) &buf); + retval = ext2fs_get_mem(fs->blocksize, &buf); if (retval) return retval; if (dir == ino) ino = 0; retval = ext2fs_get_pathname_int(fs, dir, ino, 32, buf, name); - ext2fs_free_mem((void **) &buf); + ext2fs_free_mem(&buf); return retval; } diff --git a/lib/ext2fs/icount.c b/lib/ext2fs/icount.c index 1ad39402..e08b3356 100644 --- a/lib/ext2fs/icount.c +++ b/lib/ext2fs/icount.c @@ -60,12 +60,12 @@ void ext2fs_free_icount(ext2_icount_t icount) icount->magic = 0; if (icount->list) - ext2fs_free_mem((void **) &icount->list); + ext2fs_free_mem(&icount->list); if (icount->single) ext2fs_free_inode_bitmap(icount->single); if (icount->multiple) ext2fs_free_inode_bitmap(icount->multiple); - ext2fs_free_mem((void **) &icount); + ext2fs_free_mem(&icount); } errcode_t ext2fs_create_icount2(ext2_filsys fs, int flags, int size, @@ -82,7 +82,7 @@ errcode_t ext2fs_create_icount2(ext2_filsys fs, int flags, int size, size = (size_t) hint->size; } - retval = ext2fs_get_mem(sizeof(struct ext2_icount), (void **) &icount); + retval = ext2fs_get_mem(sizeof(struct ext2_icount), &icount); if (retval) return retval; memset(icount, 0, sizeof(struct ext2_icount)); @@ -119,7 +119,7 @@ errcode_t ext2fs_create_icount2(ext2_filsys fs, int flags, int size, printf("Icount allocated %d entries, %d bytes.\n", icount->size, bytes); #endif - retval = ext2fs_get_mem(bytes, (void **) &icount->list); + retval = ext2fs_get_mem(bytes, &icount->list); if (retval) goto errout; memset(icount->list, 0, bytes); @@ -181,7 +181,7 @@ static struct ext2_icount_el *insert_icount_el(ext2_icount_t icount, sizeof(struct ext2_icount_el), (size_t) new_size * sizeof(struct ext2_icount_el), - (void **) &icount->list); + &icount->list); if (retval) return 0; icount->size = new_size; diff --git a/lib/ext2fs/initialize.c b/lib/ext2fs/initialize.c index 0e2b8d49..843afff0 100644 --- a/lib/ext2fs/initialize.c +++ b/lib/ext2fs/initialize.c @@ -78,8 +78,7 @@ errcode_t ext2fs_initialize(const char *name, int flags, if (!param || !param->s_blocks_count) return EXT2_ET_INVALID_ARGUMENT; - retval = ext2fs_get_mem(sizeof(struct struct_ext2_filsys), - (void **) &fs); + retval = ext2fs_get_mem(sizeof(struct struct_ext2_filsys), &fs); if (retval) return retval; @@ -94,12 +93,12 @@ errcode_t ext2fs_initialize(const char *name, int flags, if (retval) goto cleanup; fs->io->app_data = fs; - retval = ext2fs_get_mem(strlen(name)+1, (void **) &fs->device_name); + retval = ext2fs_get_mem(strlen(name)+1, &fs->device_name); if (retval) goto cleanup; strcpy(fs->device_name, name); - retval = ext2fs_get_mem(SUPERBLOCK_SIZE, (void **) &super); + retval = ext2fs_get_mem(SUPERBLOCK_SIZE, &super); if (retval) goto cleanup; fs->super = super; @@ -279,8 +278,7 @@ retry: * count. */ - retval = ext2fs_get_mem(strlen(fs->device_name) + 80, - (void **) &buf); + retval = ext2fs_get_mem(strlen(fs->device_name) + 80, &buf); if (retval) goto cleanup; @@ -294,10 +292,10 @@ retry: if (retval) goto cleanup; - ext2fs_free_mem((void **) &buf); + ext2fs_free_mem(&buf); retval = ext2fs_get_mem((size_t) fs->desc_blocks * fs->blocksize, - (void **) &fs->group_desc); + &fs->group_desc); if (retval) goto cleanup; diff --git a/lib/ext2fs/inode.c b/lib/ext2fs/inode.c index 2da328c1..d80f6c01 100644 --- a/lib/ext2fs/inode.c +++ b/lib/ext2fs/inode.c @@ -72,15 +72,14 @@ static errcode_t create_icache(ext2_filsys fs) if (fs->icache) return 0; - retval = ext2fs_get_mem(sizeof(struct ext2_inode_cache), - (void **) &fs->icache); + retval = ext2fs_get_mem(sizeof(struct ext2_inode_cache), &fs->icache); if (retval) return retval; memset(fs->icache, 0, sizeof(struct ext2_inode_cache)); - retval = ext2fs_get_mem(fs->blocksize, (void **) &fs->icache->buffer); + retval = ext2fs_get_mem(fs->blocksize, &fs->icache->buffer); if (retval) { - ext2fs_free_mem((void **) &fs->icache); + ext2fs_free_mem(&fs->icache); return retval; } fs->icache->buffer_blk = 0; @@ -89,10 +88,10 @@ static errcode_t create_icache(ext2_filsys fs) fs->icache->refcount = 1; retval = ext2fs_get_mem(sizeof(struct ext2_inode_cache_ent) * fs->icache->cache_size, - (void **) &fs->icache->cache); + &fs->icache->cache); if (retval) { - ext2fs_free_mem((void **) &fs->icache->buffer); - ext2fs_free_mem((void **) &fs->icache); + ext2fs_free_mem(&fs->icache->buffer); + ext2fs_free_mem(&fs->icache); return retval; } ext2fs_flush_icache(fs); @@ -127,8 +126,7 @@ errcode_t ext2fs_open_inode_scan(ext2_filsys fs, int buffer_blocks, fs->get_blocks = save_get_blocks; } - retval = ext2fs_get_mem(sizeof(struct ext2_struct_inode_scan), - (void **) &scan); + retval = ext2fs_get_mem(sizeof(struct ext2_struct_inode_scan), &scan); if (retval) return retval; memset(scan, 0, sizeof(struct ext2_struct_inode_scan)); @@ -146,19 +144,18 @@ errcode_t ext2fs_open_inode_scan(ext2_filsys fs, int buffer_blocks, scan->blocks_left = scan->fs->inode_blocks_per_group; retval = ext2fs_get_mem((size_t) (scan->inode_buffer_blocks * fs->blocksize), - (void **) &scan->inode_buffer); + &scan->inode_buffer); scan->done_group = 0; scan->done_group_data = 0; scan->bad_block_ptr = 0; if (retval) { - ext2fs_free_mem((void **) &scan); + ext2fs_free_mem(&scan); return retval; } - retval = ext2fs_get_mem(scan->inode_size, - (void **) &scan->temp_buffer); + retval = ext2fs_get_mem(scan->inode_size, &scan->temp_buffer); if (retval) { - ext2fs_free_mem((void **) &scan->inode_buffer); - ext2fs_free_mem((void **) &scan); + ext2fs_free_mem(&scan->inode_buffer); + ext2fs_free_mem(&scan); return retval; } if (scan->fs->badblocks && scan->fs->badblocks->num) @@ -172,11 +169,11 @@ void ext2fs_close_inode_scan(ext2_inode_scan scan) if (!scan || (scan->magic != EXT2_ET_MAGIC_INODE_SCAN)) return; - ext2fs_free_mem((void **) &scan->inode_buffer); + ext2fs_free_mem(&scan->inode_buffer); scan->inode_buffer = NULL; - ext2fs_free_mem((void **) &scan->temp_buffer); + ext2fs_free_mem(&scan->temp_buffer); scan->temp_buffer = NULL; - ext2fs_free_mem((void **) &scan); + ext2fs_free_mem(&scan); return; } diff --git a/lib/ext2fs/inode_io.c b/lib/ext2fs/inode_io.c index cdd0f217..5126bae1 100644 --- a/lib/ext2fs/inode_io.c +++ b/lib/ext2fs/inode_io.c @@ -75,7 +75,7 @@ errcode_t ext2fs_inode_io_intern(ext2_filsys fs, ext2_ino_t ino, errcode_t retval; if ((retval = ext2fs_get_mem(sizeof(struct inode_private_data), - (void **) &data))) + &data))) return retval; data->magic = EXT2_ET_MAGIC_INODE_IO_CHANNEL; sprintf(data->name, "%u:%d", ino, ino_unique++); @@ -111,15 +111,14 @@ static errcode_t inode_open(const char *name, int flags, io_channel *channel) else top_intern = data->next; - retval = ext2fs_get_mem(sizeof(struct struct_io_channel), - (void **) &io); + retval = ext2fs_get_mem(sizeof(struct struct_io_channel), &io); if (retval) goto cleanup; memset(io, 0, sizeof(struct struct_io_channel)); io->magic = EXT2_ET_MAGIC_IO_CHANNEL; io->manager = inode_io_manager; - retval = ext2fs_get_mem(strlen(name)+1, (void **) &io->name); + retval = ext2fs_get_mem(strlen(name)+1, &io->name); if (retval) goto cleanup; @@ -141,10 +140,10 @@ static errcode_t inode_open(const char *name, int flags, io_channel *channel) cleanup: if (data) { - ext2fs_free_mem((void **) &data); + ext2fs_free_mem(&data); } if (io) - ext2fs_free_mem((void **) &io); + ext2fs_free_mem(&io); return retval; } @@ -162,10 +161,10 @@ static errcode_t inode_close(io_channel channel) retval = ext2fs_file_close(data->file); - ext2fs_free_mem((void **) &channel->private_data); + ext2fs_free_mem(&channel->private_data); if (channel->name) - ext2fs_free_mem((void **) &channel->name); - ext2fs_free_mem((void **) &channel); + ext2fs_free_mem(&channel->name); + ext2fs_free_mem(&channel); return retval; } diff --git a/lib/ext2fs/irel_ma.c b/lib/ext2fs/irel_ma.c index 437c06f2..eedbe55c 100644 --- a/lib/ext2fs/irel_ma.c +++ b/lib/ext2fs/irel_ma.c @@ -73,38 +73,38 @@ errcode_t ext2fs_irel_memarray_create(char *name, ext2_ino_t max_inode, * Allocate memory structures */ retval = ext2fs_get_mem(sizeof(struct ext2_inode_relocation_table), - (void **) &irel); + &irel); if (retval) goto errout; memset(irel, 0, sizeof(struct ext2_inode_relocation_table)); - retval = ext2fs_get_mem(strlen(name)+1, (void **) &irel->name); + retval = ext2fs_get_mem(strlen(name)+1, &irel->name); if (retval) goto errout; strcpy(irel->name, name); - retval = ext2fs_get_mem(sizeof(struct irel_ma), (void **) &ma); + retval = ext2fs_get_mem(sizeof(struct irel_ma), &ma); if (retval) goto errout; memset(ma, 0, sizeof(struct irel_ma)); irel->priv_data = ma; size = (size_t) (sizeof(ext2_ino_t) * (max_inode+1)); - retval = ext2fs_get_mem(size, (void **) &ma->orig_map); + retval = ext2fs_get_mem(size, &ma->orig_map); if (retval) goto errout; memset(ma->orig_map, 0, size); size = (size_t) (sizeof(struct ext2_inode_relocate_entry) * (max_inode+1)); - retval = ext2fs_get_mem(size, (void **) &ma->entries); + retval = ext2fs_get_mem(size, &ma->entries); if (retval) goto errout; memset(ma->entries, 0, size); size = (size_t) (sizeof(struct inode_reference_entry) * (max_inode+1)); - retval = ext2fs_get_mem(size, (void **) &ma->ref_entries); + retval = ext2fs_get_mem(size, &ma->ref_entries); if (retval) goto errout; memset(ma->ref_entries, 0, size); @@ -163,8 +163,7 @@ static errcode_t ima_put(ext2_irel irel, ext2_ino_t old, size = (sizeof(struct ext2_inode_reference) * ent->max_refs); old_size = (sizeof(struct ext2_inode_reference) * ma->entries[(unsigned) old].max_refs); - retval = ext2fs_resize_mem(old_size, size, - (void **) &ref_ent->refs); + retval = ext2fs_resize_mem(old_size, size, &ref_ent->refs); if (retval) return retval; } @@ -250,7 +249,7 @@ static errcode_t ima_add_ref(ext2_irel irel, ext2_ino_t ino, if (ref_ent->refs == 0) { size = (size_t) ((sizeof(struct ext2_inode_reference) * ent->max_refs)); - retval = ext2fs_get_mem(size, (void **) &ref_ent->refs); + retval = ext2fs_get_mem(size, &ref_ent->refs); if (retval) return retval; memset(ref_ent->refs, 0, size); @@ -311,7 +310,7 @@ static errcode_t ima_move(ext2_irel irel, ext2_ino_t old, ext2_ino_t new) ma->entries[(unsigned) new] = ma->entries[(unsigned) old]; if (ma->ref_entries[(unsigned) new].refs) - ext2fs_free_mem((void **) &ma->ref_entries[(unsigned) new].refs); + ext2fs_free_mem(&ma->ref_entries[(unsigned) new].refs); ma->ref_entries[(unsigned) new] = ma->ref_entries[(unsigned) old]; ma->entries[(unsigned) old].new = 0; @@ -334,7 +333,7 @@ static errcode_t ima_delete(ext2_irel irel, ext2_ino_t old) ma->entries[old].new = 0; if (ma->ref_entries[(unsigned) old].refs) - ext2fs_free_mem((void **) &ma->ref_entries[(unsigned) old].refs); + ext2fs_free_mem(&ma->ref_entries[(unsigned) old].refs); ma->orig_map[ma->entries[(unsigned) old].orig] = 0; ma->ref_entries[(unsigned) old].num = 0; @@ -354,20 +353,20 @@ static errcode_t ima_free(ext2_irel irel) if (ma) { if (ma->orig_map) - ext2fs_free_mem((void **) &ma->orig_map); + ext2fs_free_mem(&ma->orig_map); if (ma->entries) - ext2fs_free_mem((void **) &ma->entries); + ext2fs_free_mem(&ma->entries); if (ma->ref_entries) { for (ino = 0; ino <= ma->max_inode; ino++) { if (ma->ref_entries[(unsigned) ino].refs) - ext2fs_free_mem((void **) &ma->ref_entries[(unsigned) ino].refs); + ext2fs_free_mem(&ma->ref_entries[(unsigned) ino].refs); } - ext2fs_free_mem((void **) &ma->ref_entries); + ext2fs_free_mem(&ma->ref_entries); } - ext2fs_free_mem((void **) &ma); + ext2fs_free_mem(&ma); } if (irel->name) - ext2fs_free_mem((void **) &irel->name); - ext2fs_free_mem((void **) &irel); + ext2fs_free_mem(&irel->name); + ext2fs_free_mem(&irel); return 0; } diff --git a/lib/ext2fs/mkdir.c b/lib/ext2fs/mkdir.c index ea189d9c..b9129e3c 100644 --- a/lib/ext2fs/mkdir.c +++ b/lib/ext2fs/mkdir.c @@ -134,7 +134,7 @@ errcode_t ext2fs_mkdir(ext2_filsys fs, ext2_ino_t parent, ext2_ino_t inum, cleanup: if (block) - ext2fs_free_mem((void **) &block); + ext2fs_free_mem(&block); return retval; } diff --git a/lib/ext2fs/mkjournal.c b/lib/ext2fs/mkjournal.c index eb35ba80..8a440710 100644 --- a/lib/ext2fs/mkjournal.c +++ b/lib/ext2fs/mkjournal.c @@ -51,7 +51,7 @@ errcode_t ext2fs_create_journal_superblock(ext2_filsys fs, if (size < 1024) return EXT2_ET_JOURNAL_TOO_SMALL; - if ((retval = ext2fs_get_mem(fs->blocksize, (void **) &jsb))) + if ((retval = ext2fs_get_mem(fs->blocksize, &jsb))) return retval; memset (jsb, 0, fs->blocksize); @@ -129,7 +129,7 @@ static errcode_t write_journal_file(ext2_filsys fs, char *filename, retval = 0; errout: - ext2fs_free_mem((void **) &buf); + ext2fs_free_mem(&buf); return retval; } @@ -237,7 +237,7 @@ static errcode_t write_journal_inode(ext2_filsys fs, ext2_ino_t journal_ino, retval = 0; errout: - ext2fs_free_mem((void **) &buf); + ext2fs_free_mem(&buf); return retval; } diff --git a/lib/ext2fs/namei.c b/lib/ext2fs/namei.c index 18be0f15..be719a26 100644 --- a/lib/ext2fs/namei.c +++ b/lib/ext2fs/namei.c @@ -48,12 +48,12 @@ static errcode_t follow_link(ext2_filsys fs, ext2_ino_t root, ext2_ino_t dir, return EXT2_ET_SYMLINK_LOOP; } if (ei.i_blocks) { - retval = ext2fs_get_mem(fs->blocksize, (void **) &buffer); + retval = ext2fs_get_mem(fs->blocksize, &buffer); if (retval) return retval; retval = io_channel_read_blk(fs->io, ei.i_block[0], 1, buffer); if (retval) { - ext2fs_free_mem((void **) &buffer); + ext2fs_free_mem(&buffer); return retval; } pathname = buffer; @@ -62,7 +62,7 @@ static errcode_t follow_link(ext2_filsys fs, ext2_ino_t root, ext2_ino_t dir, retval = open_namei(fs, root, dir, pathname, ei.i_size, 1, link_count, buf, res_inode); if (buffer) - ext2fs_free_mem((void **) &buffer); + ext2fs_free_mem(&buffer); return retval; } @@ -155,14 +155,14 @@ errcode_t ext2fs_namei(ext2_filsys fs, ext2_ino_t root, ext2_ino_t cwd, EXT2_CHECK_MAGIC(fs, EXT2_ET_MAGIC_EXT2FS_FILSYS); - retval = ext2fs_get_mem(fs->blocksize, (void **) &buf); + retval = ext2fs_get_mem(fs->blocksize, &buf); if (retval) return retval; retval = open_namei(fs, root, cwd, name, strlen(name), 0, 0, buf, inode); - ext2fs_free_mem((void **) &buf); + ext2fs_free_mem(&buf); return retval; } @@ -174,14 +174,14 @@ errcode_t ext2fs_namei_follow(ext2_filsys fs, ext2_ino_t root, ext2_ino_t cwd, EXT2_CHECK_MAGIC(fs, EXT2_ET_MAGIC_EXT2FS_FILSYS); - retval = ext2fs_get_mem(fs->blocksize, (void **) &buf); + retval = ext2fs_get_mem(fs->blocksize, &buf); if (retval) return retval; retval = open_namei(fs, root, cwd, name, strlen(name), 1, 0, buf, inode); - ext2fs_free_mem((void **) &buf); + ext2fs_free_mem(&buf); return retval; } @@ -193,13 +193,13 @@ errcode_t ext2fs_follow_link(ext2_filsys fs, ext2_ino_t root, ext2_ino_t cwd, EXT2_CHECK_MAGIC(fs, EXT2_ET_MAGIC_EXT2FS_FILSYS); - retval = ext2fs_get_mem(fs->blocksize, (void **) &buf); + retval = ext2fs_get_mem(fs->blocksize, &buf); if (retval) return retval; retval = follow_link(fs, root, cwd, inode, 0, buf, res_inode); - ext2fs_free_mem((void **) &buf); + ext2fs_free_mem(&buf); return retval; } diff --git a/lib/ext2fs/newdir.c b/lib/ext2fs/newdir.c index b8e593ee..3904d911 100644 --- a/lib/ext2fs/newdir.c +++ b/lib/ext2fs/newdir.c @@ -36,7 +36,7 @@ errcode_t ext2fs_new_dir_block(ext2_filsys fs, ext2_ino_t dir_ino, EXT2_CHECK_MAGIC(fs, EXT2_ET_MAGIC_EXT2FS_FILSYS); - retval = ext2fs_get_mem(fs->blocksize, (void **) &buf); + retval = ext2fs_get_mem(fs->blocksize, &buf); if (retval) return retval; memset(buf, 0, fs->blocksize); diff --git a/lib/ext2fs/openfs.c b/lib/ext2fs/openfs.c index eb5a7dc0..7dd5737e 100644 --- a/lib/ext2fs/openfs.c +++ b/lib/ext2fs/openfs.c @@ -82,8 +82,7 @@ errcode_t ext2fs_open(const char *name, int flags, int superblock, EXT2_CHECK_MAGIC(manager, EXT2_ET_MAGIC_IO_MANAGER); - retval = ext2fs_get_mem(sizeof(struct struct_ext2_filsys), - (void **) &fs); + retval = ext2fs_get_mem(sizeof(struct struct_ext2_filsys), &fs); if (retval) return retval; @@ -96,16 +95,16 @@ errcode_t ext2fs_open(const char *name, int flags, int superblock, if (retval) goto cleanup; fs->io->app_data = fs; - retval = ext2fs_get_mem(strlen(name)+1, (void **) &fs->device_name); + retval = ext2fs_get_mem(strlen(name)+1, &fs->device_name); if (retval) goto cleanup; strcpy(fs->device_name, name); - retval = ext2fs_get_mem(SUPERBLOCK_SIZE, (void **) &fs->super); + retval = ext2fs_get_mem(SUPERBLOCK_SIZE, &fs->super); if (retval) goto cleanup; if (flags & EXT2_FLAG_IMAGE_FILE) { retval = ext2fs_get_mem(sizeof(struct ext2_image_hdr), - (void **) &fs->image_header); + &fs->image_header); if (retval) goto cleanup; retval = io_channel_read_blk(fs->io, 0, @@ -140,8 +139,7 @@ errcode_t ext2fs_open(const char *name, int flags, int superblock, io_channel_set_blksize(fs->io, SUPERBLOCK_OFFSET); superblock = 1; group_block = 0; - retval = ext2fs_get_mem(SUPERBLOCK_SIZE, - (void **) &fs->orig_super); + retval = ext2fs_get_mem(SUPERBLOCK_SIZE, &fs->orig_super); if (retval) goto cleanup; } @@ -242,7 +240,7 @@ errcode_t ext2fs_open(const char *name, int flags, int superblock, EXT2_DESC_PER_BLOCK(fs->super) - 1) / EXT2_DESC_PER_BLOCK(fs->super); retval = ext2fs_get_mem(fs->desc_blocks * fs->blocksize, - (void **) &fs->group_desc); + &fs->group_desc); if (retval) goto cleanup; if (!group_block) diff --git a/lib/ext2fs/rs_bitmap.c b/lib/ext2fs/rs_bitmap.c index 30a9ef91..46653f0e 100644 --- a/lib/ext2fs/rs_bitmap.c +++ b/lib/ext2fs/rs_bitmap.c @@ -58,8 +58,7 @@ errcode_t ext2fs_resize_generic_bitmap(__u32 new_end, __u32 new_real_end, new_size = ((new_real_end - bmap->start) / 8) + 1; if (size != new_size) { - retval = ext2fs_resize_mem(size, new_size, - (void **) &bmap->bitmap); + retval = ext2fs_resize_mem(size, new_size, &bmap->bitmap); if (retval) return retval; } diff --git a/lib/ext2fs/rw_bitmaps.c b/lib/ext2fs/rw_bitmaps.c index 4d47da41..2c5f3976 100644 --- a/lib/ext2fs/rw_bitmaps.c +++ b/lib/ext2fs/rw_bitmaps.c @@ -68,7 +68,7 @@ errcode_t ext2fs_write_inode_bitmap(ext2_filsys fs) return 0; nbytes = (size_t) ((EXT2_INODES_PER_GROUP(fs->super)+7) / 8); - retval = ext2fs_get_mem(fs->blocksize, (void **) &bitmap_block); + retval = ext2fs_get_mem(fs->blocksize, &bitmap_block); if (retval) return retval; memset(bitmap_block, 0xff, fs->blocksize); @@ -89,7 +89,7 @@ errcode_t ext2fs_write_inode_bitmap(ext2_filsys fs) inode_bitmap += nbytes; } fs->flags &= ~EXT2_FLAG_IB_DIRTY; - ext2fs_free_mem((void **) &bitmap_block); + ext2fs_free_mem(&bitmap_block); return 0; } @@ -111,7 +111,7 @@ errcode_t ext2fs_write_block_bitmap (ext2_filsys fs) if (!block_bitmap) return 0; nbytes = EXT2_BLOCKS_PER_GROUP(fs->super) / 8; - retval = ext2fs_get_mem(fs->blocksize, (void **) &bitmap_block); + retval = ext2fs_get_mem(fs->blocksize, &bitmap_block); if (retval) return retval; memset(bitmap_block, 0xff, fs->blocksize); @@ -141,7 +141,7 @@ errcode_t ext2fs_write_block_bitmap (ext2_filsys fs) block_bitmap += nbytes; } fs->flags &= ~EXT2_FLAG_BB_DIRTY; - ext2fs_free_mem((void **) &bitmap_block); + ext2fs_free_mem(&bitmap_block); return 0; } @@ -159,7 +159,7 @@ static errcode_t read_bitmaps(ext2_filsys fs, int do_inode, int do_block) fs->write_bitmaps = ext2fs_write_bitmaps; - retval = ext2fs_get_mem(strlen(fs->device_name) + 80, (void **) &buf); + retval = ext2fs_get_mem(strlen(fs->device_name) + 80, &buf); if (retval) return retval; if (do_block) { @@ -180,7 +180,7 @@ static errcode_t read_bitmaps(ext2_filsys fs, int do_inode, int do_block) goto cleanup; inode_bitmap = fs->inode_map->bitmap; } - ext2fs_free_mem((void **) &buf); + ext2fs_free_mem(&buf); if (fs->flags & EXT2_FLAG_IMAGE_FILE) { if (inode_bitmap) { @@ -246,15 +246,15 @@ static errcode_t read_bitmaps(ext2_filsys fs, int do_inode, int do_block) cleanup: if (do_block) { - ext2fs_free_mem((void **) &fs->block_map); + ext2fs_free_mem(&fs->block_map); fs->block_map = 0; } if (do_inode) { - ext2fs_free_mem((void **) &fs->inode_map); + ext2fs_free_mem(&fs->inode_map); fs->inode_map = 0; } if (buf) - ext2fs_free_mem((void **) &buf); + ext2fs_free_mem(&buf); return retval; } diff --git a/lib/ext2fs/test_io.c b/lib/ext2fs/test_io.c index 9ce8334f..4cf33bd7 100644 --- a/lib/ext2fs/test_io.c +++ b/lib/ext2fs/test_io.c @@ -121,20 +121,18 @@ static errcode_t test_open(const char *name, int flags, io_channel *channel) if (name == 0) return EXT2_ET_BAD_DEVICE_NAME; - retval = ext2fs_get_mem(sizeof(struct struct_io_channel), - (void **) &io); + retval = ext2fs_get_mem(sizeof(struct struct_io_channel), &io); if (retval) return retval; memset(io, 0, sizeof(struct struct_io_channel)); io->magic = EXT2_ET_MAGIC_IO_CHANNEL; - retval = ext2fs_get_mem(sizeof(struct test_private_data), - (void **) &data); + retval = ext2fs_get_mem(sizeof(struct test_private_data), &data); if (retval) { retval = EXT2_ET_NO_MEMORY; goto cleanup; } io->manager = test_io_manager; - retval = ext2fs_get_mem(strlen(name)+1, (void **) &io->name); + retval = ext2fs_get_mem(strlen(name)+1, &io->name); if (retval) goto cleanup; @@ -178,9 +176,9 @@ static errcode_t test_open(const char *name, int flags, io_channel *channel) cleanup: if (io) - ext2fs_free_mem((void **) &io); + ext2fs_free_mem(&io); if (data) - ext2fs_free_mem((void **) &data); + ext2fs_free_mem(&data); return retval; } @@ -202,10 +200,10 @@ static errcode_t test_close(io_channel channel) if (data->outfile && data->outfile != stderr) fclose(data->outfile); - ext2fs_free_mem((void **) &channel->private_data); + ext2fs_free_mem(&channel->private_data); if (channel->name) - ext2fs_free_mem((void **) &channel->name); - ext2fs_free_mem((void **) &channel); + ext2fs_free_mem(&channel->name); + ext2fs_free_mem(&channel); return retval; } diff --git a/lib/ext2fs/unix_io.c b/lib/ext2fs/unix_io.c index b2deb70e..2c732e9c 100644 --- a/lib/ext2fs/unix_io.c +++ b/lib/ext2fs/unix_io.c @@ -253,7 +253,7 @@ static errcode_t alloc_cache(io_channel channel, cache->dirty = 0; cache->in_use = 0; if ((retval = ext2fs_get_mem(channel->block_size, - (void **) &cache->buf))) + &cache->buf))) return retval; } return 0; @@ -273,7 +273,7 @@ static void free_cache(io_channel channel, cache->dirty = 0; cache->in_use = 0; if (cache->buf) - ext2fs_free_mem((void **) &cache->buf); + ext2fs_free_mem(&cache->buf); cache->buf = 0; } } @@ -374,19 +374,17 @@ static errcode_t unix_open(const char *name, int flags, io_channel *channel) if (name == 0) return EXT2_ET_BAD_DEVICE_NAME; - retval = ext2fs_get_mem(sizeof(struct struct_io_channel), - (void **) &io); + retval = ext2fs_get_mem(sizeof(struct struct_io_channel), &io); if (retval) return retval; memset(io, 0, sizeof(struct struct_io_channel)); io->magic = EXT2_ET_MAGIC_IO_CHANNEL; - retval = ext2fs_get_mem(sizeof(struct unix_private_data), - (void **) &data); + retval = ext2fs_get_mem(sizeof(struct unix_private_data), &data); if (retval) goto cleanup; io->manager = unix_io_manager; - retval = ext2fs_get_mem(strlen(name)+1, (void **) &io->name); + retval = ext2fs_get_mem(strlen(name)+1, &io->name); if (retval) goto cleanup; @@ -454,10 +452,10 @@ static errcode_t unix_open(const char *name, int flags, io_channel *channel) cleanup: if (data) { free_cache(io, data); - ext2fs_free_mem((void **) &data); + ext2fs_free_mem(&data); } if (io) - ext2fs_free_mem((void **) &io); + ext2fs_free_mem(&io); return retval; } @@ -481,10 +479,10 @@ static errcode_t unix_close(io_channel channel) retval = errno; free_cache(channel, data); - ext2fs_free_mem((void **) &channel->private_data); + ext2fs_free_mem(&channel->private_data); if (channel->name) - ext2fs_free_mem((void **) &channel->name); - ext2fs_free_mem((void **) &channel); + ext2fs_free_mem(&channel->name); + ext2fs_free_mem(&channel); return retval; } diff --git a/resize/ChangeLog b/resize/ChangeLog index 4003b666..04f60f20 100644 --- a/resize/ChangeLog +++ b/resize/ChangeLog @@ -1,3 +1,10 @@ +2003-08-01 Philipp Thomas + + * extent.c, resize2fs.c, sim_progress.c: ext2fs_getmem(), + ext2fs_free_mem(), and ext2fs_resize_mem() all now take a + 'void *' instead of a 'void **' in order to avoid pointer + aliasing problems with GCC 3.x. + 2003-07-25 Theodore Ts'o * Release of E2fsprogs 1.34 diff --git a/resize/extent.c b/resize/extent.c index 34846fa1..bf53d129 100644 --- a/resize/extent.c +++ b/resize/extent.c @@ -39,8 +39,7 @@ errcode_t ext2fs_create_extent_table(ext2_extent *ret_extent, int size) ext2_extent extent; errcode_t retval; - retval = ext2fs_get_mem(sizeof(struct _ext2_extent), - (void **) &extent); + retval = ext2fs_get_mem(sizeof(struct _ext2_extent), &extent); if (retval) return retval; memset(extent, 0, sizeof(struct _ext2_extent)); @@ -51,9 +50,9 @@ errcode_t ext2fs_create_extent_table(ext2_extent *ret_extent, int size) extent->sorted = 1; retval = ext2fs_get_mem(sizeof(struct ext2_extent_entry) * - extent->size, (void **) &extent->list); + extent->size, &extent->list); if (retval) { - ext2fs_free_mem((void **) &extent); + ext2fs_free_mem(&extent); return retval; } memset(extent->list, 0, @@ -68,11 +67,11 @@ errcode_t ext2fs_create_extent_table(ext2_extent *ret_extent, int size) void ext2fs_free_extent_table(ext2_extent extent) { if (extent->list) - ext2fs_free_mem((void **) &extent->list); + ext2fs_free_mem(&extent->list); extent->list = 0; extent->size = 0; extent->num = 0; - ext2fs_free_mem((void **) &extent); + ext2fs_free_mem(&extent); } /* @@ -90,7 +89,7 @@ errcode_t ext2fs_add_extent_entry(ext2_extent extent, __u32 old_loc, __u32 new_l retval = ext2fs_resize_mem(sizeof(struct ext2_extent_entry) * extent->size, sizeof(struct ext2_extent_entry) * - newsize, (void **) &extent->list); + newsize, &extent->list); if (retval) return retval; extent->size = newsize; diff --git a/resize/resize2fs.c b/resize/resize2fs.c index 6f60cfcd..c7970d0e 100644 --- a/resize/resize2fs.c +++ b/resize/resize2fs.c @@ -81,8 +81,7 @@ errcode_t resize_fs(ext2_filsys fs, blk_t *new_size, int flags, /* * Create the data structure */ - retval = ext2fs_get_mem(sizeof(struct ext2_resize_struct), - (void **) &rfs); + retval = ext2fs_get_mem(sizeof(struct ext2_resize_struct), &rfs); if (retval) return retval; memset(rfs, 0, sizeof(struct ext2_resize_struct)); @@ -141,8 +140,8 @@ errcode_t resize_fs(ext2_filsys fs, blk_t *new_size, int flags, ext2fs_free(rfs->old_fs); if (rfs->itable_buf) - ext2fs_free_mem((void **) &rfs->itable_buf); - ext2fs_free_mem((void **) &rfs); + ext2fs_free_mem(&rfs->itable_buf); + ext2fs_free_mem(&rfs); return 0; @@ -150,8 +149,8 @@ errout: if (rfs->new_fs) ext2fs_free(rfs->new_fs); if (rfs->itable_buf) - ext2fs_free_mem((void **) &rfs->itable_buf); - ext2fs_free_mem((void **) &rfs); + ext2fs_free_mem(&rfs->itable_buf); + ext2fs_free_mem(&rfs); return retval; } @@ -271,7 +270,7 @@ retry: retval = ext2fs_resize_mem(rfs->old_fs->desc_blocks * fs->blocksize, fs->desc_blocks * fs->blocksize, - (void **) &fs->group_desc); + &fs->group_desc); if (retval) goto errout; } @@ -326,7 +325,7 @@ retry: * Initialize the new block group descriptors */ retval = ext2fs_get_mem(fs->blocksize * fs->inode_blocks_per_group, - (void **) &rfs->itable_buf); + &rfs->itable_buf); if (retval) goto errout; @@ -848,7 +847,7 @@ static errcode_t block_mover(ext2_resize_t rfs) if (!rfs->itable_buf) { retval = ext2fs_get_mem(fs->blocksize * fs->inode_blocks_per_group, - (void **) &rfs->itable_buf); + &rfs->itable_buf); if (retval) return retval; } @@ -1065,8 +1064,7 @@ static errcode_t inode_scan_and_fix(ext2_resize_t rfs) retval = ext2fs_init_dblist(rfs->old_fs, 0); if (retval) goto errout; - retval = ext2fs_get_mem(rfs->old_fs->blocksize * 3, - (void **) &block_buf); + retval = ext2fs_get_mem(rfs->old_fs->blocksize * 3, &block_buf); if (retval) goto errout; start_to_move = (rfs->new_fs->group_desc_count * @@ -1176,7 +1174,7 @@ errout: if (scan) ext2fs_close_inode_scan(scan); if (block_buf) - ext2fs_free_mem((void **) &block_buf); + ext2fs_free_mem(&block_buf); return retval; } @@ -1314,7 +1312,7 @@ static errcode_t move_itables(ext2_resize_t rfs) size = fs->blocksize * fs->inode_blocks_per_group; if (!rfs->itable_buf) { - retval = ext2fs_get_mem(size, (void **) &rfs->itable_buf); + retval = ext2fs_get_mem(size, &rfs->itable_buf); if (retval) return retval; } diff --git a/resize/sim_progress.c b/resize/sim_progress.c index b3ec589b..103a727f 100644 --- a/resize/sim_progress.c +++ b/resize/sim_progress.c @@ -82,8 +82,7 @@ errcode_t ext2fs_progress_init(ext2_sim_progmeter *ret_prog, ext2_sim_progmeter prog; errcode_t retval; - retval = ext2fs_get_mem(sizeof(struct ext2_sim_progress), - (void **) &prog); + retval = ext2fs_get_mem(sizeof(struct ext2_sim_progress), &prog); if (!prog) return retval; memset(prog, 0, sizeof(struct ext2_sim_progress)); @@ -111,8 +110,8 @@ void ext2fs_progress_close(ext2_sim_progmeter prog) { if (prog->label) - ext2fs_free_mem((void **) &prog->label); - ext2fs_free_mem((void **) &prog); + ext2fs_free_mem(&prog->label); + ext2fs_free_mem(&prog); printf("\n"); return; } -- cgit v1.2.3