+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
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;
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;
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;
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;
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;
* 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;
}
if (ctx->blkid)
blkid_put_cache(ctx->blkid);
- ext2fs_free_mem((void **) &ctx);
+ ext2fs_free_mem(&ctx);
}
/*
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)
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));
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);
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;
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)
#ifdef USE_INODE_IO
if (j_inode)
- ext2fs_free_mem((void **)&j_inode);
+ ext2fs_free_mem(&j_inode);
#endif
*ret_journal = 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;
}
#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);
}
/*
fputs("???", stdout);
else {
safe_print(path, -1);
- ext2fs_free_mem((void **) &path);
+ ext2fs_free_mem(&path);
}
}
*/
static void unwind_pass1(ext2_filsys fs)
{
- ext2fs_free_mem((void **) &inodes_to_process);
+ ext2fs_free_mem(&inodes_to_process);
inodes_to_process = 0;
}
}
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) {
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);
if (pctx.errcode)
fix_problem(ctx, PR_1_RELOC_WRITE_ERR, &pctx);
}
- ext2fs_free_mem((void **) &buf);
+ ext2fs_free_mem(&buf);
}
/*
else
ext2fs_unmark_valid(fs);
}
- ext2fs_free_mem((void **) &shared);
+ ext2fs_free_mem(&shared);
}
/*
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;
}
retval = 0;
errout:
- ext2fs_free_mem((void **) &cs.buf);
+ ext2fs_free_mem(&cs.buf);
return retval;
}
#endif
}
#endif
- ext2fs_free_mem((void **) &buf);
+ ext2fs_free_mem(&buf);
ext2fs_free_dblist(fs->dblist);
if (ctx->inode_bad_map) {
}
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);
ctx->flags |= E2F_FLAG_ABORT;
return;
}
- ext2fs_free_mem((void **) &block);
+ ext2fs_free_mem(&block);
/*
* Set up the inode structure
}
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);
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;
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);
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);
} else
ext2fs_unmark_valid(fs);
}
- ext2fs_free_mem((void **) &free_array);
+ ext2fs_free_mem(&free_array);
}
static void check_inode_bitmaps(e2fsck_t ctx)
} 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)
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;
}
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"));
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);
}
+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
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;
fail:
if (buf)
- ext2fs_free_mem((void **) &buf);
+ ext2fs_free_mem(&buf);
return retval;
}
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)
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;
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;
return;
iter->bb = 0;
- ext2fs_free_mem((void **) &iter);
+ ext2fs_free_mem(&iter);
}
void ext2fs_badblocks_list_iterate_end(ext2_badblocks_iterate iter)
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);
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;
}
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;
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;
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);
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;
}
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;
}
}
if (!block_buf)
- ext2fs_free_mem((void **) &ctx.ind_buf);
+ ext2fs_free_mem(&ctx.ind_buf);
return (ret & BLOCK_ERROR) ? ctx.errcode : 0;
}
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;
&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);
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;
* 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));
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);
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;
}
#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 *
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;
}
(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));
}
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;
return 0;
cleanup:
if (dblist)
- ext2fs_free_mem((void **) &dblist);
+ ext2fs_free_mem(&dblist);
return retval;
}
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;
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;
}
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;
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;
}
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;
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);
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;
#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);
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;
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,
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;
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++;
/* 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);
/*
* 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;
}
/*
* 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;
}
* 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 */
#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;
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;
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;
errout:
if (buf)
- ext2fs_free_mem((void **) &buf);
+ ext2fs_free_mem(&buf);
return retval;
}
!(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;
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;
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;
}
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;
}
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)
fs->magic = 0;
- ext2fs_free_mem((void **) &fs);
+ ext2fs_free_mem(&fs);
}
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)
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);
}
/*
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)
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);
}
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;
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) ? "/" : ".");
}
if (!dir || (maxdepth < 0)) {
- retval = ext2fs_get_mem(4, (void **)name);
+ retval = ext2fs_get_mem(4, name);
if (retval)
return retval;
strcpy(*name, "...");
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;
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;
}
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;
}
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,
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));
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);
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;
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;
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;
* 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;
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;
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;
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);
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));
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)
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;
}
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++);
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;
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;
}
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;
}
* 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);
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;
}
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);
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;
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;
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;
}
cleanup:
if (block)
- ext2fs_free_mem((void **) &block);
+ ext2fs_free_mem(&block);
return retval;
}
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);
retval = 0;
errout:
- ext2fs_free_mem((void **) &buf);
+ ext2fs_free_mem(&buf);
return retval;
}
retval = 0;
errout:
- ext2fs_free_mem((void **) &buf);
+ ext2fs_free_mem(&buf);
return retval;
}
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;
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;
}
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;
}
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;
}
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;
}
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);
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;
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,
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;
}
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)
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;
}
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);
inode_bitmap += nbytes;
}
fs->flags &= ~EXT2_FLAG_IB_DIRTY;
- ext2fs_free_mem((void **) &bitmap_block);
+ ext2fs_free_mem(&bitmap_block);
return 0;
}
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);
block_bitmap += nbytes;
}
fs->flags &= ~EXT2_FLAG_BB_DIRTY;
- ext2fs_free_mem((void **) &bitmap_block);
+ ext2fs_free_mem(&bitmap_block);
return 0;
}
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) {
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) {
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;
}
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;
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;
}
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;
}
cache->dirty = 0;
cache->in_use = 0;
if ((retval = ext2fs_get_mem(channel->block_size,
- (void **) &cache->buf)))
+ &cache->buf)))
return retval;
}
return 0;
cache->dirty = 0;
cache->in_use = 0;
if (cache->buf)
- ext2fs_free_mem((void **) &cache->buf);
+ ext2fs_free_mem(&cache->buf);
cache->buf = 0;
}
}
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;
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;
}
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;
}
+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
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));
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,
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);
}
/*
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;
/*
* 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));
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;
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;
}
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;
}
* 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;
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;
}
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 *
if (scan)
ext2fs_close_inode_scan(scan);
if (block_buf)
- ext2fs_free_mem((void **) &block_buf);
+ ext2fs_free_mem(&block_buf);
return retval;
}
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;
}
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));
{
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;
}
git://git.whamcloud.com / tools / e2fsprogs.git / commitdiff