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.

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 <pthomas@suse.de>
+
+	* 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  <tytso@mit.edu>
 
 	* 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 <pthomas@suse.de>
+
+	* 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  <tytso@mit.edu>
 
 	* 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 <pthomas@suse.de>
+
+	* 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  <tytso@mit.edu>
 
 	* 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;
 }