From: Theodore Ts'o <tytso@mit.edu>
Date: Sun, 26 Oct 1997 03:41:24 +0000 (+0000)
Subject: Many files:
X-Git-Tag: PQ_SNAPSHOT_971103~9
X-Git-Url: https://git.whamcloud.com/?a=commitdiff_plain;h=7b4e4534f9361b21d3fafdd88a58f133decee38c;p=tools%2Fe2fsprogs.git

Many files:
  Added definition of ext2fs_get_mem, ext2fs_free_mem, and
  ext2fs_resize_mem in ext2fs.h, and changed all library routines to use
  these wrapper functions.
---

diff --git a/lib/ext2fs/ChangeLog b/lib/ext2fs/ChangeLog
index a06a79f..9102d0b 100644
--- a/lib/ext2fs/ChangeLog
+++ b/lib/ext2fs/ChangeLog
@@ -1,5 +1,9 @@
 Sat Oct 25 00:06:58 1997  Theodore Ts'o  <tytso@rsts-11.mit.edu>
 
+	* [all files, basically]: Added definition of ext2fs_get_mem, 
+		ext2fs_free_mem, and ext2fs_resize_mem in ext2fs.h, and
+		changed all library routines to use these wrapper functions.
+
 	* dblist.c, mkdir.c: use EXT2_DIR_EXISTS and EXT2_DB_NOT_FOUND
 		instead of the system error messages.
 	
diff --git a/lib/ext2fs/alloc.c b/lib/ext2fs/alloc.c
index ecff171..104d468 100644
--- a/lib/ext2fs/alloc.c
+++ b/lib/ext2fs/alloc.c
@@ -113,9 +113,9 @@ errcode_t ext2fs_alloc_block(ext2_filsys fs, blk_t goal,
 	char		*buf = 0;
 
 	if (!block_buf) {
-		buf = malloc(fs->blocksize);
-		if (!buf)
-			return EXT2_NO_MEMORY;
+		retval = ext2fs_get_mem(fs->blocksize, (void **) &buf);
+		if (retval)
+			return retval;
 		block_buf = buf;
 	}
 	memset(block_buf, 0, fs->blocksize);
@@ -145,7 +145,7 @@ errcode_t ext2fs_alloc_block(ext2_filsys fs, blk_t goal,
 
 fail:
 	if (buf)
-		free(buf);
+		ext2fs_free_mem((void **) &buf);
 	return retval;
 }
 
diff --git a/lib/ext2fs/badblocks.c b/lib/ext2fs/badblocks.c
index 0b9bbff..ab1404d 100644
--- a/lib/ext2fs/badblocks.c
+++ b/lib/ext2fs/badblocks.c
@@ -35,18 +35,20 @@ static errcode_t make_badblocks_list(int size, int num, blk_t *list,
 				     ext2_badblocks_list *ret)
 {
 	ext2_badblocks_list	bb;
+	errcode_t		retval;
 	
-	bb = malloc(sizeof(struct ext2_struct_badblocks_list));
-	if (!bb)
-		return EXT2_NO_MEMORY;
+	retval = ext2fs_get_mem(sizeof(struct ext2_struct_badblocks_list),
+				(void **) &bb);
+	if (retval)
+		return retval;
 	memset(bb, 0, sizeof(struct ext2_struct_badblocks_list));
 	bb->magic = EXT2_ET_MAGIC_BADBLOCKS_LIST;
 	bb->size = size ? size : 10;
 	bb->num = num;
-	bb->list = malloc(bb->size * sizeof(blk_t));
+	retval = ext2fs_get_mem(bb->size * sizeof(blk_t), (void **) &bb->list);
 	if (!bb->list) {
-		free(bb);
-		return EXT2_NO_MEMORY;
+		ext2fs_free_mem((void **) &bb);
+		return retval;
 	}
 	if (list)
 		memcpy(bb->list, list, bb->size * sizeof(blk_t));
@@ -94,17 +96,17 @@ errcode_t ext2fs_badblocks_copy(ext2_badblocks_list src,
  */
 errcode_t ext2fs_badblocks_list_add(ext2_badblocks_list bb, blk_t blk)
 {
-	int	i, j;
-	blk_t	*new_list;
+	errcode_t	retval;
+	int		i, j;
 
 	EXT2_CHECK_MAGIC(bb, EXT2_ET_MAGIC_BADBLOCKS_LIST);
 
 	if (bb->num >= bb->size) {
 		bb->size += 10;
-		new_list = realloc(bb->list, bb->size * sizeof(blk_t));
-		if (!new_list)
-			return EXT2_NO_MEMORY;
-		bb->list = new_list;
+		retval = ext2fs_resize_mem(bb->size * sizeof(blk_t),
+					   (void **) &bb->list);
+		if (retval)
+			return retval;
 	}
 
 	j = bb->num;
@@ -162,12 +164,14 @@ errcode_t ext2fs_badblocks_list_iterate_begin(ext2_badblocks_list bb,
 					      ext2_badblocks_iterate *ret)
 {
 	ext2_badblocks_iterate iter;
+	errcode_t		retval;
 
 	EXT2_CHECK_MAGIC(bb, EXT2_ET_MAGIC_BADBLOCKS_LIST);
 
-	iter = malloc(sizeof(struct ext2_struct_badblocks_iterate));
-	if (!iter)
-		return EXT2_NO_MEMORY;
+	retval = ext2fs_get_mem(sizeof(struct ext2_struct_badblocks_iterate),
+			      (void **) &iter);
+	if (retval)
+		return retval;
 
 	iter->magic = EXT2_ET_MAGIC_BADBLOCKS_ITERATE;
 	iter->bb = bb;
@@ -202,7 +206,7 @@ void ext2fs_badblocks_list_iterate_end(ext2_badblocks_iterate iter)
 		return;
 
 	iter->bb = 0;
-	free(iter);
+	ext2fs_free_mem((void **) &iter);
 }
 
 
diff --git a/lib/ext2fs/bb_inode.c b/lib/ext2fs/bb_inode.c
index fdcebc4..abad675 100644
--- a/lib/ext2fs/bb_inode.c
+++ b/lib/ext2fs/bb_inode.c
@@ -68,15 +68,14 @@ errcode_t ext2fs_update_bb_inode(ext2_filsys fs, ext2_badblocks_list bb_list)
 	rec.bad_block_count = 0;
 	rec.ind_blocks_size = rec.ind_blocks_ptr = 0;
 	rec.max_ind_blocks = 10;
-	rec.ind_blocks = malloc(rec.max_ind_blocks * sizeof(blk_t));
-	if (!rec.ind_blocks)
-		return EXT2_NO_MEMORY;
+	retval = ext2fs_get_mem(rec.max_ind_blocks * sizeof(blk_t),
+				(void **) &rec.ind_blocks);
+	if (retval)
+		return retval;
 	memset(rec.ind_blocks, 0, rec.max_ind_blocks * sizeof(blk_t));
-	rec.block_buf = malloc(fs->blocksize);
-	if (!rec.block_buf) {
-		retval = EXT2_NO_MEMORY;
+	retval = ext2fs_get_mem(fs->blocksize, (void **) &rec.block_buf);
+	if (retval)
 		goto cleanup;
-	}
 	memset(rec.block_buf, 0, fs->blocksize);
 	rec.err = 0;
 	
@@ -146,8 +145,8 @@ errcode_t ext2fs_update_bb_inode(ext2_filsys fs, ext2_badblocks_list bb_list)
 		goto cleanup;
 	
 cleanup:
-	free(rec.ind_blocks);
-	free(rec.block_buf);
+	ext2fs_free_mem((void **) &rec.ind_blocks);
+	ext2fs_free_mem((void **) &rec.block_buf);
 	return retval;
 }
 
@@ -165,7 +164,8 @@ static int clear_bad_block_proc(ext2_filsys fs, blk_t *block_nr, int blockcnt,
 {
 	struct set_badblock_record *rec = (struct set_badblock_record *)
 		private;
-	int	group;
+	errcode_t	retval;
+	int		group;
 
 	if (!*block_nr)
 		return 0;
@@ -182,11 +182,11 @@ static int clear_bad_block_proc(ext2_filsys fs, blk_t *block_nr, int blockcnt,
 	if (blockcnt < 0) {
 		if (rec->ind_blocks_size >= rec->max_ind_blocks) {
 			rec->max_ind_blocks += 10;
-			rec->ind_blocks = realloc(rec->ind_blocks,
-						  rec->max_ind_blocks *
-						  sizeof(blk_t));
-			if (!rec->ind_blocks) {
-				rec->err = EXT2_NO_MEMORY;
+			retval = ext2fs_resize_mem(rec->max_ind_blocks
+						   * sizeof(blk_t),
+						   (void **) &rec->ind_blocks);
+			if (retval) {
+				rec->err = retval;
 				return BLOCK_ABORT;
 			}
 		}
diff --git a/lib/ext2fs/bitmaps.c b/lib/ext2fs/bitmaps.c
index 76dbc1c..0887e57 100644
--- a/lib/ext2fs/bitmaps.c
+++ b/lib/ext2fs/bitmaps.c
@@ -33,12 +33,14 @@ static errcode_t make_bitmap(__u32 start, __u32 end, __u32 real_end,
 			     const char *descr, char *init_map,
 			     ext2fs_generic_bitmap *ret)
 {
-	ext2fs_generic_bitmap bitmap;
-	size_t	size;
+	ext2fs_generic_bitmap	bitmap;
+	errcode_t		retval;
+	size_t			size;
 
-	bitmap = malloc(sizeof(struct ext2fs_struct_generic_bitmap));
-	if (!bitmap)
-		return EXT2_NO_MEMORY;
+	retval = ext2fs_get_mem(sizeof(struct ext2fs_struct_generic_bitmap),
+				(void **) &bitmap);
+	if (retval)
+		return retval;
 
 	bitmap->magic = EXT2_ET_MAGIC_GENERIC_BITMAP;
 	bitmap->fs = NULL;
@@ -47,21 +49,22 @@ 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) {
-		bitmap->description = malloc(strlen(descr)+1);
-		if (!bitmap->description) {
-			free(bitmap);
-			return EXT2_NO_MEMORY;
+		retval = ext2fs_get_mem(strlen(descr)+1,
+					(void **) &bitmap->description);
+		if (retval) {
+			ext2fs_free_mem((void **) &bitmap);
+			return retval;
 		}
 		strcpy(bitmap->description, descr);
 	} else
 		bitmap->description = 0;
 
 	size = (size_t) (((bitmap->real_end - bitmap->start) / 8) + 1);
-	bitmap->bitmap = malloc(size);
-	if (!bitmap->bitmap) {
-		free(bitmap->description);
-		free(bitmap);
-		return EXT2_NO_MEMORY;
+	retval = ext2fs_get_mem(size, (void **) &bitmap->bitmap);
+	if (retval) {
+		ext2fs_free_mem((void **) &bitmap->description);
+		ext2fs_free_mem((void **) &bitmap);
+		return retval;
 	}
 
 	if (init_map)
diff --git a/lib/ext2fs/block.c b/lib/ext2fs/block.c
index f938380..2946003 100644
--- a/lib/ext2fs/block.c
+++ b/lib/ext2fs/block.c
@@ -332,9 +332,10 @@ errcode_t ext2fs_block_iterate2(ext2_filsys fs,
 	if (block_buf) {
 		ctx.ind_buf = block_buf;
 	} else {
-		ctx.ind_buf = malloc(fs->blocksize * 3);
-		if (!ctx.ind_buf)
-			return EXT2_NO_MEMORY;
+		retval = ext2fs_get_mem(fs->blocksize * 3,
+					(void **) &ctx.ind_buf);
+		if (retval)
+			return retval;
 	}
 	ctx.dind_buf = ctx.ind_buf + fs->blocksize;
 	ctx.tind_buf = ctx.dind_buf + fs->blocksize;
@@ -403,7 +404,7 @@ abort:
 	}
 
 	if (!block_buf)
-		free(ctx.ind_buf);
+		ext2fs_free_mem((void **) &ctx.ind_buf);
 
 	return (ret & BLOCK_ERROR) ? ctx.errcode : 0;
 }
diff --git a/lib/ext2fs/bmap.c b/lib/ext2fs/bmap.c
index b2d3eac..43f9f31 100644
--- a/lib/ext2fs/bmap.c
+++ b/lib/ext2fs/bmap.c
@@ -157,9 +157,9 @@ errcode_t ext2fs_bmap(ext2_filsys fs, ino_t ino, struct ext2_inode *inode,
 	addr_per_block = fs->blocksize >> 2;
 
 	if (!block_buf) {
-		buf = malloc(fs->blocksize * 2);
-		if (!buf)
-			return EXT2_NO_MEMORY;
+		retval = ext2fs_get_mem(fs->blocksize * 2, (void **) &buf);
+		if (retval)
+			return retval;
 		block_buf = buf;
 	}
 
@@ -236,7 +236,7 @@ errcode_t ext2fs_bmap(ext2_filsys fs, ino_t ino, struct ext2_inode *inode,
 				 &blocks_alloc, block, phys_blk);
 done:
 	if (buf)
-		free(buf);
+		ext2fs_free_mem((void **) &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 61bc790..4840821 100644
--- a/lib/ext2fs/bmove.c
+++ b/lib/ext2fs/bmove.c
@@ -108,9 +108,9 @@ errcode_t ext2fs_move_blocks(ext2_filsys fs,
 	pb.alloc_map = alloc_map ? alloc_map : fs->block_map;
 	pb.flags = flags;
 	
-	block_buf = malloc(fs->blocksize * 4);
-	if (!block_buf)
-		return EXT2_NO_MEMORY;
+	retval = ext2fs_get_mem(fs->blocksize * 4, (void **) &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 8913688..ba44ce2 100644
--- a/lib/ext2fs/brel_ma.c
+++ b/lib/ext2fs/brel_ma.c
@@ -58,27 +58,27 @@ errcode_t ext2fs_brel_memarray_create(char *name, blk_t max_block,
 	/*
 	 * Allocate memory structures
 	 */
-	retval = EXT2_NO_MEMORY;
-	brel = malloc(sizeof(struct ext2_block_relocation_table));
-	if (!brel)
+	retval = ext2fs_get_mem(sizeof(struct ext2_block_relocation_table),
+				(void **) &brel);
+	if (retval)
 		goto errout;
 	memset(brel, 0, sizeof(struct ext2_block_relocation_table));
 	
-	brel->name = malloc(strlen(name)+1);
-	if (!brel->name)
+	retval = ext2fs_get_mem(strlen(name)+1, (void **) &brel->name);
+	if (retval)
 		goto errout;
 	strcpy(brel->name, name);
 	
-	ma = malloc(sizeof(struct brel_ma));
-	if (!ma)
+	retval = ext2fs_get_mem(sizeof(struct brel_ma), (void **) &ma);
+	if (retval)
 		goto errout;
 	memset(ma, 0, sizeof(struct brel_ma));
 	brel->private = ma;
 	
 	size = (size_t) (sizeof(struct ext2_block_relocate_entry) *
 			 (max_block+1));
-	ma->entries = malloc(size);
-	if (!ma->entries)
+	retval = ext2fs_get_mem(size, (void **) &ma->entries);
+	if (retval)
 		goto errout;
 	memset(ma->entries, 0, size);
 	ma->max_block = max_block;
@@ -189,11 +189,11 @@ static errcode_t bma_free(ext2_brel brel)
 
 	if (ma) {
 		if (ma->entries)
-			free (ma->entries);
-		free(ma);
+			ext2fs_free_mem((void **) &ma->entries);
+		ext2fs_free_mem((void **) &ma);
 	}
 	if (brel->name)
-		free(brel->name);
-	free (brel);
+		ext2fs_free_mem((void **) &brel->name);
+	ext2fs_free_mem((void **) &brel);
 	return 0;
 }
diff --git a/lib/ext2fs/closefs.c b/lib/ext2fs/closefs.c
index 4016a7c..6ef9706 100644
--- a/lib/ext2fs/closefs.c
+++ b/lib/ext2fs/closefs.c
@@ -71,10 +71,14 @@ errcode_t ext2fs_flush(ext2_filsys fs)
 	fs->super->s_wtime = time(NULL);
 	if (fs->flags & EXT2_FLAG_SWAP_BYTES) {
 		retval = EXT2_NO_MEMORY;
-		if (!(super_shadow = malloc(SUPERBLOCK_SIZE)))
+		retval = ext2fs_get_mem(SUPERBLOCK_SIZE,
+					(void **) &super_shadow);
+		if (retval)
 			goto errout;
-		if (!(group_shadow = malloc((size_t) fs->blocksize *
-					    fs->desc_blocks)))
+		retval = ext2fs_get_mem((size_t)(fs->blocksize *
+						 fs->desc_blocks),
+					(void **) &group_shadow);
+		if (retval)
 			goto errout;
 		memset(group_shadow, 0, (size_t) fs->blocksize *
 		       fs->desc_blocks);
@@ -164,9 +168,9 @@ errout:
 	fs->super->s_state = fs_state;
 	if (fs->flags & EXT2_FLAG_SWAP_BYTES) {
 		if (super_shadow)
-			free(super_shadow);
+			ext2fs_free_mem((void **) &super_shadow);
 		if (group_shadow)
-			free(group_shadow);
+			ext2fs_free_mem((void **) &group_shadow);
 	}
 	return retval;
 }
diff --git a/lib/ext2fs/dblist.c b/lib/ext2fs/dblist.c
index 1a4c5dc..dd4993a 100644
--- a/lib/ext2fs/dblist.c
+++ b/lib/ext2fs/dblist.c
@@ -63,9 +63,10 @@ static errcode_t make_dblist(ext2_filsys fs, ino_t size, ino_t count,
 	    (fs->dblist->magic == EXT2_ET_MAGIC_DBLIST))
 		return 0;
 
-	dblist = malloc(sizeof(struct ext2_struct_dblist));
-	if (!dblist)
-		return EXT2_NO_MEMORY;
+	retval = ext2fs_get_mem(sizeof(struct ext2_struct_dblist),
+				(void **) &dblist);
+	if (retval)
+		return retval;
 	memset(dblist, 0, sizeof(struct ext2_struct_dblist));
 
 	dblist->magic = EXT2_ET_MAGIC_DBLIST;
@@ -80,11 +81,10 @@ static errcode_t make_dblist(ext2_filsys fs, ino_t size, ino_t count,
 	}
 	len = (size_t) sizeof(struct ext2_db_entry) * dblist->size;
 	dblist->count = count;
-	dblist->list = malloc(len);
-	if (dblist->list == NULL) {
-		retval = EXT2_NO_MEMORY;
+	retval = ext2fs_get_mem(len, (void **) &dblist->list);
+	if (retval)
 		goto cleanup;
-	}
+	
 	if (list)
 		memcpy(dblist->list, list, len);
 	else
@@ -93,7 +93,7 @@ static errcode_t make_dblist(ext2_filsys fs, ino_t size, ino_t count,
 	return 0;
 cleanup:
 	if (dblist)
-		free(dblist);
+		ext2fs_free_mem((void **) &dblist);
 	return retval;
 }
 
@@ -148,19 +148,20 @@ errcode_t ext2fs_copy_dblist(ext2_dblist src, ext2_dblist *dest)
 errcode_t ext2fs_add_dir_block(ext2_dblist dblist, ino_t ino, blk_t blk,
 			       int blockcnt)
 {
-	struct ext2_db_entry 	*nlist, *new;
+	struct ext2_db_entry 	*new;
+	errcode_t		retval;
 	
 	EXT2_CHECK_MAGIC(dblist, EXT2_ET_MAGIC_DBLIST);
 
 	if (dblist->count >= dblist->size) {
 		dblist->size += 100;
-		nlist = realloc(dblist->list, (size_t) dblist->size *
-				sizeof(struct ext2_db_entry));
-		if (nlist == 0) {
+		retval = ext2fs_resize_mem((size_t) dblist->size *
+					   sizeof(struct ext2_db_entry),
+					   (void **) &dblist->list);
+		if (retval) {
 			dblist->size -= 100;
-			return EXT2_NO_MEMORY;
+			return retval;
 		}
-		dblist->list = nlist;
 	}
 	new = dblist->list + ( (int) dblist->count++);
 	new->blk = blk;
diff --git a/lib/ext2fs/dblist_dir.c b/lib/ext2fs/dblist_dir.c
index 131f965..2c8b8a1 100644
--- a/lib/ext2fs/dblist_dir.c
+++ b/lib/ext2fs/dblist_dir.c
@@ -48,9 +48,10 @@ extern errcode_t
 	if (block_buf)
 		ctx.buf = block_buf;
 	else {
-		ctx.buf = malloc(dblist->fs->blocksize);
-		if (!ctx.buf)
-			return EXT2_NO_MEMORY;
+		retval = ext2fs_get_mem(dblist->fs->blocksize,
+					(void **) &ctx.buf);
+		if (retval)
+			return retval;
 	}
 	ctx.func = 0;
 	ctx.func2 = func;
@@ -60,7 +61,7 @@ extern errcode_t
 	retval = ext2fs_dblist_iterate(dblist, db_dir_proc, &ctx);
 	
 	if (!block_buf)
-		free(ctx.buf);
+		ext2fs_free_mem((void **) &ctx.buf);
 	if (retval)
 		return retval;
 	return ctx.errcode;
diff --git a/lib/ext2fs/dir_iterate.c b/lib/ext2fs/dir_iterate.c
index 8d8de57..0784ef2 100644
--- a/lib/ext2fs/dir_iterate.c
+++ b/lib/ext2fs/dir_iterate.c
@@ -48,9 +48,9 @@ errcode_t ext2fs_dir_iterate(ext2_filsys fs,
 	if (block_buf)
 		ctx.buf = block_buf;
 	else {
-		ctx.buf = malloc(fs->blocksize);
-		if (!ctx.buf)
-			return EXT2_NO_MEMORY;
+		retval = ext2fs_get_mem(fs->blocksize, (void **) &ctx.buf);
+		if (retval)
+			return retval;
 	}
 	ctx.func = func;
 	ctx.func2 = 0;
@@ -59,7 +59,7 @@ errcode_t ext2fs_dir_iterate(ext2_filsys fs,
 	retval = ext2fs_block_iterate(fs, dir, 0, 0,
 				      ext2fs_process_dir_block, &ctx);
 	if (!block_buf)
-		free(ctx.buf);
+		ext2fs_free_mem((void **) &ctx.buf);
 	if (retval)
 		return retval;
 	return ctx.errcode;
diff --git a/lib/ext2fs/dirblock.c b/lib/ext2fs/dirblock.c
index 6958bee..0bb7cc5 100644
--- a/lib/ext2fs/dirblock.c
+++ b/lib/ext2fs/dirblock.c
@@ -56,9 +56,10 @@ errcode_t ext2fs_write_dir_block(ext2_filsys fs, blk_t block,
 
 	if ((fs->flags & EXT2_FLAG_SWAP_BYTES) ||
 	    (fs->flags & EXT2_FLAG_SWAP_BYTES_WRITE)) {
-		write_buf = buf = malloc(fs->blocksize);
-		if (!buf)
-			return EXT2_NO_MEMORY;
+		retval = ext2fs_get_mem(fs->blocksize, (void **) &buf);
+		if (retval)
+			return retval;
+		write_buf = buf;
 		memcpy(buf, inbuf, fs->blocksize);
 		p = buf;
 		end = buf + fs->blocksize;
@@ -73,7 +74,7 @@ errcode_t ext2fs_write_dir_block(ext2_filsys fs, blk_t block,
 		write_buf = inbuf;
  	retval = io_channel_write_blk(fs->io, block, 1, write_buf);
 	if (buf)
-		free(buf);
+		ext2fs_free_mem((void **) &buf);
 	return retval;
 }
 
diff --git a/lib/ext2fs/dupfs.c b/lib/ext2fs/dupfs.c
index 8c6f159..f358eca 100644
--- a/lib/ext2fs/dupfs.c
+++ b/lib/ext2fs/dupfs.c
@@ -28,9 +28,10 @@ errcode_t ext2fs_dup_handle(ext2_filsys src, ext2_filsys *dest)
 
 	EXT2_CHECK_MAGIC(src, EXT2_ET_MAGIC_EXT2FS_FILSYS);
 	
-	fs = (ext2_filsys) malloc(sizeof(struct struct_ext2_filsys));
-	if (!fs)
-		return EXT2_NO_MEMORY;
+	retval = ext2fs_get_mem(sizeof(struct struct_ext2_filsys),
+				(void **) &fs);
+	if (retval)
+		return retval;
 
 	*fs = *src;
 	fs->device_name = 0;
@@ -45,19 +46,20 @@ errcode_t ext2fs_dup_handle(ext2_filsys src, ext2_filsys *dest)
 	if (fs->icache)
 		fs->icache->refcount++;
 
-	retval = EXT2_NO_MEMORY;
-	fs->device_name = malloc(strlen(src->device_name)+1);
-	if (!fs->device_name)
+	retval = ext2fs_get_mem(strlen(src->device_name)+1,
+				(void **) &fs->device_name);
+	if (retval)
 		goto errout;
 	strcpy(fs->device_name, src->device_name);
 
-	fs->super = malloc(SUPERBLOCK_SIZE);
-	if (!fs->super)
+	retval = ext2fs_get_mem(SUPERBLOCK_SIZE, (void **) &fs->super);
+	if (retval)
 		goto errout;
 	memcpy(fs->super, src->super, SUPERBLOCK_SIZE);
 
-	fs->group_desc = malloc((size_t) fs->desc_blocks * fs->blocksize);
-	if (!fs->group_desc)
+	retval = ext2fs_get_mem((size_t) fs->desc_blocks * fs->blocksize,
+				(void **) &fs->group_desc);
+	if (retval)
 		goto errout;
 	memcpy(fs->group_desc, src->group_desc,
 	       (size_t) fs->desc_blocks * fs->blocksize);
diff --git a/lib/ext2fs/expanddir.c b/lib/ext2fs/expanddir.c
index 46ada20..1da5143 100644
--- a/lib/ext2fs/expanddir.c
+++ b/lib/ext2fs/expanddir.c
@@ -54,9 +54,9 @@ static int expand_dir_proc(ext2_filsys fs,
 		}
 		es->done = 1;
 	} else {
-		block = malloc(fs->blocksize);
-		if (!block) {
-			es->err = EXT2_NO_MEMORY;
+		retval = ext2fs_get_mem(fs->blocksize, (void **) &block);
+		if (retval) {
+			es->err = retval;
 			return BLOCK_ABORT;
 		}
 		memset(block, 0, fs->blocksize);
@@ -66,7 +66,7 @@ static int expand_dir_proc(ext2_filsys fs,
 		es->err = retval;
 		return BLOCK_ABORT;
 	}
-	free(block);
+	ext2fs_free_mem((void **) &block);
 	*blocknr = new_blk;
 	ext2fs_mark_block_bitmap(fs->block_map, new_blk);
 	ext2fs_mark_bb_dirty(fs);
diff --git a/lib/ext2fs/ext2fs.h b/lib/ext2fs/ext2fs.h
index 5b30b12..f06f6dc 100644
--- a/lib/ext2fs/ext2fs.h
+++ b/lib/ext2fs/ext2fs.h
@@ -721,6 +721,9 @@ extern int ext2fs_get_library_version(const char **ver_string,
 				      const char **date_string);
 
 /* inline functions */
+extern errcode_t ext2fs_get_mem(long size, void **ptr);
+extern errcode_t ext2fs_free_mem(void **ptr);
+extern errcode_t ext2fs_resize_mem(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);
@@ -747,6 +750,43 @@ extern int ext2fs_group_of_ino(ext2_filsys fs, ino_t ino);
 #define _INLINE_ extern __inline__
 #endif
 
+#ifndef EXT2_CUSTOM_MEMORY_ROUTINES
+/*
+ *  Allocate memory
+ */
+_INLINE_ errcode_t ext2fs_get_mem(long size, void **ptr)
+{
+	*ptr = malloc(size);
+	if (!*ptr)
+		return EXT2_NO_MEMORY;
+	return 0;
+}
+
+/*
+ * Free memory
+ */
+_INLINE_ errcode_t ext2fs_free_mem(void **ptr)
+{
+	free(*ptr);
+	*ptr = 0;
+	return 0;
+}
+	
+/*
+ *  Resize memory
+ */
+_INLINE_ errcode_t ext2fs_resize_mem(long size, void **ptr)
+{
+	void *p;
+
+	p = realloc(*ptr, size);
+	if (!p)
+		return EXT2_NO_MEMORY;
+	*ptr = p;
+	return 0;
+}
+#endif	/* Custom memory routines */
+
 /*
  * Mark a filesystem superblock as dirty
  */
diff --git a/lib/ext2fs/fileio.c b/lib/ext2fs/fileio.c
index fa7acb0..9165826 100644
--- a/lib/ext2fs/fileio.c
+++ b/lib/ext2fs/fileio.c
@@ -49,9 +49,9 @@ errcode_t ext2fs_file_open(ext2_filsys fs, ino_t ino,
 	    !(fs->flags & EXT2_FLAG_RW))
 		return EXT2_ET_RO_FILSYS;
 
-	file = (ext2_file_t) malloc(sizeof(struct ext2_file));
-	if (!file)
-		return EXT2_NO_MEMORY;
+	retval = ext2fs_get_mem(sizeof(struct ext2_file), (void **) &file);
+	if (retval)
+		return retval;
 	
 	memset(file, 0, sizeof(struct ext2_file));
 	file->magic = EXT2_ET_MAGIC_EXT2_FILE;
@@ -63,19 +63,17 @@ errcode_t ext2fs_file_open(ext2_filsys fs, ino_t ino,
 	if (retval)
 		goto fail;
 	
-	file->buf = malloc(fs->blocksize);
-	if (!file->buf) {
-		retval = EXT2_NO_MEMORY;
+	retval = ext2fs_get_mem(fs->blocksize, (void **) &file->buf);
+	if (retval)
 		goto fail;
-	}
 
 	*ret = file;
 	return 0;
 	
 fail:
 	if (file->buf)
-		free(file->buf);
-	free(file);
+		ext2fs_free_mem((void **) &file->buf);
+	ext2fs_free_mem((void **) &file);
 	return retval;
 }
 
@@ -124,8 +122,8 @@ errcode_t ext2fs_file_close(ext2_file_t file)
 	retval = ext2fs_file_flush(file);
 	
 	if (file->buf)
-		free(file->buf);
-	free(file);
+		ext2fs_free_mem((void **) &file->buf);
+	ext2fs_free_mem((void **) &file);
 
 	return retval;
 }
diff --git a/lib/ext2fs/freefs.c b/lib/ext2fs/freefs.c
index 8d1da19..71d1ef7 100644
--- a/lib/ext2fs/freefs.c
+++ b/lib/ext2fs/freefs.c
@@ -29,11 +29,11 @@ void ext2fs_free(ext2_filsys fs)
 		io_channel_close(fs->io);
 	}
 	if (fs->device_name)
-		free(fs->device_name);
+		ext2fs_free_mem((void **) &fs->device_name);
 	if (fs->super)
-		free(fs->super);
+		ext2fs_free_mem((void **) &fs->super);
 	if (fs->group_desc)
-		free(fs->group_desc);
+		ext2fs_free_mem((void **) &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;
 
-	free(fs);
+	ext2fs_free_mem((void **) &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) {
-		free(bitmap->description);
+		ext2fs_free_mem((void **) &bitmap->description);
 		bitmap->description = 0;
 	}
 	if (bitmap->bitmap) {
-		free(bitmap->bitmap);
+		ext2fs_free_mem((void **) &bitmap->bitmap);
 		bitmap->bitmap = 0;
 	}
-	free(bitmap);
+	ext2fs_free_mem((void **) &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)
-		free(icache->buffer);
+		ext2fs_free_mem((void **) &icache->buffer);
 	if (icache->cache)
-		free(icache->cache);
+		ext2fs_free_mem((void **) &icache->cache);
 	icache->buffer_blk = 0;
-	free(icache);
+	ext2fs_free_mem((void **) &icache);
 }
 
 /*
@@ -113,9 +113,9 @@ void ext2fs_badblocks_list_free(ext2_badblocks_list bb)
 		return;
 
 	if (bb->list)
-		free(bb->list);
+		ext2fs_free_mem((void **) &bb->list);
 	bb->list = 0;
-	free(bb);
+	ext2fs_free_mem((void **) &bb);
 }
 
 /*
@@ -127,11 +127,11 @@ void ext2fs_free_dblist(ext2_dblist dblist)
 		return;
 
 	if (dblist->list)
-		free(dblist->list);
+		ext2fs_free_mem((void **) &dblist->list);
 	dblist->list = 0;
 	if (dblist->fs && dblist->fs->dblist == dblist)
 		dblist->fs->dblist = 0;
 	dblist->magic = 0;
-	free(dblist);
+	ext2fs_free_mem((void **) &dblist);
 }
 
diff --git a/lib/ext2fs/get_pathname.c b/lib/ext2fs/get_pathname.c
index f4f6db7..9b5ce26 100644
--- a/lib/ext2fs/get_pathname.c
+++ b/lib/ext2fs/get_pathname.c
@@ -46,6 +46,7 @@ static int get_pathname_proc(struct ext2_dir_entry *dirent,
 			     void	*private)
 {
 	struct get_pathname_struct	*gp;
+	errcode_t			retval;
 
 	gp = (struct get_pathname_struct *) private;
 
@@ -53,7 +54,8 @@ static int get_pathname_proc(struct ext2_dir_entry *dirent,
 	    !strncmp(dirent->name, "..", 2))
 		gp->parent = dirent->inode;
 	if (dirent->inode == gp->search_ino) {
-		gp->name = malloc(dirent->name_len + 1);
+		retval = ext2fs_get_mem(dirent->name_len + 1,
+					(void **) &gp->name);
 		if (!gp->name) {
 			gp->errcode = EXT2_NO_MEMORY;
 			return DIRENT_ABORT;
@@ -73,17 +75,17 @@ static errcode_t ext2fs_get_pathname_int(ext2_filsys fs, ino_t dir, ino_t ino,
 	errcode_t	retval;
 
 	if (dir == ino) {
-		*name = malloc(2);
-		if (!*name)
-			return EXT2_NO_MEMORY;
+		retval = ext2fs_get_mem(2, (void **)name);
+		if (retval)
+			return retval;
 		strcpy(*name, (dir == EXT2_ROOT_INO) ? "/" : ".");
 		return 0;
 	}
 
 	if (!dir || (maxdepth < 0)) {
-		*name = malloc(4);
-		if (!*name)
-			return EXT2_NO_MEMORY;
+		retval = ext2fs_get_mem(4, (void **)name);
+		if (retval)
+			return retval;
 		strcpy(*name, "...");
 		return 0;
 	}
@@ -111,14 +113,14 @@ static errcode_t ext2fs_get_pathname_int(ext2_filsys fs, ino_t dir, ino_t ino,
 	}
 	
 	if (gp.name) 
-		ret = malloc(strlen(parent_name)+strlen(gp.name)+2);
+		retval = ext2fs_get_mem(strlen(parent_name)+strlen(gp.name)+2,
+					(void **) &ret);
 	else
-		ret = malloc(strlen(parent_name)+5); /* strlen("???") + 2 */
-		
-	if (!ret) {
-		retval = EXT2_NO_MEMORY;
+		retval = ext2fs_get_mem(strlen(parent_name)+5,
+					(void **) &ret);
+	if (retval)
 		goto cleanup;
-	}
+	
 	ret[0] = 0;
 	if (parent_name[1])
 		strcat(ret, parent_name);
@@ -128,12 +130,12 @@ static errcode_t ext2fs_get_pathname_int(ext2_filsys fs, ino_t dir, ino_t ino,
 	else
 		strcat(ret, "???");
 	*name = ret;
-	free(parent_name);
+	ext2fs_free_mem((void **) &parent_name);
 	retval = 0;
 	
 cleanup:
 	if (gp.name)
-		free(gp.name);
+		ext2fs_free_mem((void **) &gp.name);
 	return retval;
 }
 
@@ -145,13 +147,13 @@ errcode_t ext2fs_get_pathname(ext2_filsys fs, ino_t dir, ino_t ino,
 
 	EXT2_CHECK_MAGIC(fs, EXT2_ET_MAGIC_EXT2FS_FILSYS);
 
-	buf = malloc(fs->blocksize);
-	if (!buf)
-		return EXT2_NO_MEMORY;
+	retval = ext2fs_get_mem(fs->blocksize, (void **) &buf);
+	if (retval)
+		return retval;
 	if (dir == ino)
 		ino = 0;
 	retval = ext2fs_get_pathname_int(fs, dir, ino, 32, buf, name);
-	free(buf);
+	ext2fs_free_mem((void **) &buf);
 	return retval;
 	
 }
diff --git a/lib/ext2fs/icount.c b/lib/ext2fs/icount.c
index 84d0a97..f321e68 100644
--- a/lib/ext2fs/icount.c
+++ b/lib/ext2fs/icount.c
@@ -62,12 +62,12 @@ void ext2fs_free_icount(ext2_icount_t icount)
 
 	icount->magic = 0;
 	if (icount->list)
-		free(icount->list);
+		ext2fs_free_mem((void **) &icount->list);
 	if (icount->single)
 		ext2fs_free_inode_bitmap(icount->single);
 	if (icount->multiple)
 		ext2fs_free_inode_bitmap(icount->multiple);
-	free(icount);
+	ext2fs_free_mem((void **) &icount);
 }
 
 errcode_t ext2fs_create_icount2(ext2_filsys fs, int flags, int size,
@@ -84,9 +84,9 @@ errcode_t ext2fs_create_icount2(ext2_filsys fs, int flags, int size,
 			size = (size_t) hint->size;
 	}
 	
-	icount = malloc(sizeof(struct ext2_icount));
-	if (!icount)
-		return EXT2_NO_MEMORY;
+	retval = ext2fs_get_mem(sizeof(struct ext2_icount), (void **) &icount);
+	if (retval)
+		return retval;
 	memset(icount, 0, sizeof(struct ext2_icount));
 
 	retval = ext2fs_allocate_inode_bitmap(fs, 0, 
@@ -121,8 +121,8 @@ errcode_t ext2fs_create_icount2(ext2_filsys fs, int flags, int size,
 	printf("Icount allocated %d entries, %d bytes.\n",
 	       icount->size, bytes);
 #endif
-	icount->list = malloc(bytes);
-	if (!icount->list)
+	retval = ext2fs_get_mem(bytes, (void **) &icount->list);
+	if (retval)
 		goto errout;
 	memset(icount->list, 0, bytes);
 
@@ -163,7 +163,8 @@ errcode_t ext2fs_create_icount(ext2_filsys fs, int flags, int size,
 static struct ext2_icount_el *insert_icount_el(ext2_icount_t icount,
 					    ino_t ino, int pos)
 {
-	struct ext2_icount_el *el, *new_list;
+	struct ext2_icount_el 	*el;
+	errcode_t		retval;
 	ino_t			new_size = 0;
 	int			num;
 
@@ -178,12 +179,12 @@ static struct ext2_icount_el *insert_icount_el(ext2_icount_t icount,
 #if 0
 		printf("Reallocating icount %d entries...\n", new_size);
 #endif	
-		new_list = realloc(icount->list, (size_t) new_size *
-				   sizeof(struct ext2_icount_el));
-		if (!new_list)
+		retval = ext2fs_resize_mem((size_t) new_size *
+					   sizeof(struct ext2_icount_el),
+					   (void **) &icount->list);
+		if (retval)
 			return 0;
 		icount->size = new_size;
-		icount->list = new_list;
 	}
 	num = (int) icount->count - pos;
 	if (num < 0)
diff --git a/lib/ext2fs/initialize.c b/lib/ext2fs/initialize.c
index f1fa7d7..5c7fb32 100644
--- a/lib/ext2fs/initialize.c
+++ b/lib/ext2fs/initialize.c
@@ -72,9 +72,10 @@ errcode_t ext2fs_initialize(const char *name, int flags,
 	if (!param || !param->s_blocks_count)
 		return EXT2_INVALID_ARGUMENT;
 	
-	fs = (ext2_filsys) malloc(sizeof(struct struct_ext2_filsys));
-	if (!fs)
-		return EXT2_NO_MEMORY;
+	retval = ext2fs_get_mem(sizeof(struct struct_ext2_filsys),
+				(void **) &fs);
+	if (retval)
+		return retval;
 	
 	memset(fs, 0, sizeof(struct struct_ext2_filsys));
 	fs->magic = EXT2_ET_MAGIC_EXT2FS_FILSYS;
@@ -83,17 +84,16 @@ errcode_t ext2fs_initialize(const char *name, int flags,
 	if (retval)
 		goto cleanup;
 	fs->io->app_data = fs;
-	fs->device_name = malloc(strlen(name)+1);
-	if (!fs->device_name) {
-		retval = EXT2_NO_MEMORY;
+	retval = ext2fs_get_mem(strlen(name)+1, (void **) &fs->device_name);
+	if (retval)
 		goto cleanup;
-	}
+
 	strcpy(fs->device_name, name);
-	fs->super = super = malloc(SUPERBLOCK_SIZE);
-	if (!super) {
-		retval = EXT2_NO_MEMORY;
+	retval = ext2fs_get_mem(SUPERBLOCK_SIZE, (void **) &super);
+	if (retval)
 		goto cleanup;
-	}
+	fs->super = super;
+
 	memset(super, 0, SUPERBLOCK_SIZE);
 
 #define set_field(field, default) (super->field = param->field ? \
@@ -229,11 +229,10 @@ retry:
 	 * count.
 	 */
 
-	buf = malloc(strlen(fs->device_name) + 80);
-	if (!buf) {
-		retval = EXT2_NO_MEMORY;
+	retval = ext2fs_get_mem(strlen(fs->device_name) + 80,
+				(void **) &buf);
+	if (retval)
 		goto cleanup;
-	}
 	
 	sprintf(buf, "block bitmap for %s", fs->device_name);
 	retval = ext2fs_allocate_block_bitmap(fs, buf, &fs->block_map);
@@ -245,13 +244,13 @@ retry:
 	if (retval)
 		goto cleanup;
 
-	free(buf);
+	ext2fs_free_mem((void **) &buf);
 
-	fs->group_desc = malloc((size_t) fs->desc_blocks * fs->blocksize);
-	if (!fs->group_desc) {
-		retval = EXT2_NO_MEMORY;
+	retval = ext2fs_get_mem((size_t) fs->desc_blocks * fs->blocksize,
+				(void **) &fs->group_desc);
+	if (retval)
 		goto cleanup;
-	}
+
 	memset(fs->group_desc, 0, (size_t) fs->desc_blocks * fs->blocksize);
 
 	/*
diff --git a/lib/ext2fs/inode.c b/lib/ext2fs/inode.c
index fe26b3f..cec4341 100644
--- a/lib/ext2fs/inode.c
+++ b/lib/ext2fs/inode.c
@@ -53,27 +53,33 @@ struct ext2_struct_inode_scan {
 
 static errcode_t create_icache(ext2_filsys fs)
 {
-	int	i;
+	errcode_t	retval;
+	int		i;
 	
 	if (fs->icache)
 		return 0;
-	fs->icache = malloc(sizeof(struct ext2_inode_cache));
+	retval = ext2fs_get_mem(sizeof(struct ext2_inode_cache), 
+				(void **) &fs->icache);
+	if (retval)
+		return retval;
+
 	memset(fs->icache, 0, sizeof(struct ext2_inode_cache));
-	fs->icache->buffer = malloc(fs->blocksize);
-	if (!fs->icache->buffer) {
-		free(fs->icache);
-		return EXT2_NO_MEMORY;
+	retval = ext2fs_get_mem(fs->blocksize, (void **) &fs->icache->buffer);
+	if (retval) {
+		ext2fs_free_mem((void **) &fs->icache);
+		return retval;
 	}
 	fs->icache->buffer_blk = 0;
 	fs->icache->cache_last = -1;
 	fs->icache->cache_size = 4;
 	fs->icache->refcount = 1;
-	fs->icache->cache = malloc(sizeof(struct ext2_inode_cache_ent)
-				   * fs->icache->cache_size);
-	if (!fs->icache->cache) {
-		free(fs->icache->buffer);
-		free(fs->icache);
-		return EXT2_NO_MEMORY;
+	retval = ext2fs_get_mem(sizeof(struct ext2_inode_cache_ent)
+				* fs->icache->cache_size,
+				(void **) &fs->icache->cache);
+	if (retval) {
+		ext2fs_free_mem((void **) &fs->icache->buffer);
+		ext2fs_free_mem((void **) &fs->icache);
+		return retval;
 	}
 	for (i=0; i < fs->icache->cache_size; i++)
 		fs->icache->cache[i].ino = 0;
@@ -108,9 +114,10 @@ errcode_t ext2fs_open_inode_scan(ext2_filsys fs, int buffer_blocks,
 		fs->get_blocks = save_get_blocks;
 	}
 
-	scan = (ext2_inode_scan) malloc(sizeof(struct ext2_struct_inode_scan));
-	if (!scan)
-		return EXT2_NO_MEMORY;
+	retval = ext2fs_get_mem(sizeof(struct ext2_struct_inode_scan),
+				(void **) &scan);
+	if (retval)
+		return retval;
 	memset(scan, 0, sizeof(struct ext2_struct_inode_scan));
 
 	scan->magic = EXT2_ET_MAGIC_INODE_SCAN;
@@ -120,20 +127,22 @@ errcode_t ext2fs_open_inode_scan(ext2_filsys fs, int buffer_blocks,
 	scan->current_group = -1;
 	scan->inode_buffer_blocks = buffer_blocks ? buffer_blocks : 8;
 	scan->groups_left = fs->group_desc_count;
-	scan->inode_buffer = malloc((size_t) (scan->inode_buffer_blocks * 
-					      fs->blocksize));
+	retval = ext2fs_get_mem((size_t) (scan->inode_buffer_blocks * 
+					  fs->blocksize),
+				(void **) &scan->inode_buffer);
 	scan->done_group = 0;
 	scan->done_group_data = 0;
 	scan->bad_block_ptr = 0;
-	if (!scan->inode_buffer) {
-		free(scan);
-		return EXT2_NO_MEMORY;
+	if (retval) {
+		ext2fs_free_mem((void **) &scan);
+		return retval;
 	}
-	scan->temp_buffer = malloc(scan->inode_size);
-	if (!scan->temp_buffer) {
-		free(scan->inode_buffer);
-		free(scan);
-		return EXT2_NO_MEMORY;
+	retval = ext2fs_get_mem(scan->inode_size,
+				(void **) &scan->temp_buffer);
+	if (retval) {
+		ext2fs_free_mem((void **) &scan->inode_buffer);
+		ext2fs_free_mem((void **) &scan);
+		return retval;
 	}
 	if (scan->fs->badblocks && scan->fs->badblocks->num)
 		scan->scan_flags |= EXT2_SF_CHK_BADBLOCKS;
@@ -146,11 +155,11 @@ void ext2fs_close_inode_scan(ext2_inode_scan scan)
 	if (!scan || (scan->magic != EXT2_ET_MAGIC_INODE_SCAN))
 		return;
 	
-	free(scan->inode_buffer);
+	ext2fs_free_mem((void **) &scan->inode_buffer);
 	scan->inode_buffer = NULL;
-	free(scan->temp_buffer);
+	ext2fs_free_mem((void **) &scan->temp_buffer);
 	scan->temp_buffer = NULL;
-	free(scan);
+	ext2fs_free_mem((void **) &scan);
 	return;
 }
 
diff --git a/lib/ext2fs/irel_ma.c b/lib/ext2fs/irel_ma.c
index 86055e2..be29853 100644
--- a/lib/ext2fs/irel_ma.c
+++ b/lib/ext2fs/irel_ma.c
@@ -74,40 +74,40 @@ errcode_t ext2fs_irel_memarray_create(char *name, ino_t max_inode,
 	/*
 	 * Allocate memory structures
 	 */
-	retval = EXT2_NO_MEMORY;
-	irel = malloc(sizeof(struct ext2_inode_relocation_table));
-	if (!irel)
+	retval = ext2fs_get_mem(sizeof(struct ext2_inode_relocation_table),
+		  (void **) &irel);
+	if (retval)
 		goto errout;
 	memset(irel, 0, sizeof(struct ext2_inode_relocation_table));
 	
-	irel->name = malloc(strlen(name)+1);
-	if (!irel->name)
+	retval = ext2fs_get_mem(strlen(name)+1, (void **) &irel->name);
+	if (retval)
 		goto errout;
 	strcpy(irel->name, name);
 	
-	ma = malloc(sizeof(struct irel_ma));
-	if (!ma)
+	retval = ext2fs_get_mem(sizeof(struct irel_ma), (void **) &ma);
+	if (retval)
 		goto errout;
 	memset(ma, 0, sizeof(struct irel_ma));
 	irel->private = ma;
 	
 	size = (size_t) (sizeof(ino_t) * (max_inode+1));
-	ma->orig_map = malloc(size);
-	if (!ma->orig_map)
+	retval = ext2fs_get_mem(size, (void **) &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));
-	ma->entries = malloc(size);
-	if (!ma->entries)
+	retval = ext2fs_get_mem(size, (void **) &ma->entries);
+	if (retval)
 		goto errout;
 	memset(ma->entries, 0, size);
 
 	size = (size_t) (sizeof(struct inode_reference_entry) *
 			 (max_inode+1));
-	ma->ref_entries = malloc(size);
-	if (!ma->ref_entries)
+	retval = ext2fs_get_mem(size, (void **) &ma->ref_entries);
+	if (retval)
 		goto errout;
 	memset(ma->ref_entries, 0, size);
 	ma->max_inode = max_inode;
@@ -138,10 +138,10 @@ errout:
 static errcode_t ima_put(ext2_irel irel, ino_t old,
 			struct ext2_inode_relocate_entry *ent)
 {
-	struct irel_ma 	*ma;
-	struct inode_reference_entry *ref_ent;
-	struct ext2_inode_reference *new_refs;
-	int size;
+	struct inode_reference_entry	*ref_ent;
+	struct irel_ma 			*ma;
+	errcode_t			retval;
+	int				size;
 
 	ma = irel->private;
 	if (old > ma->max_inode)
@@ -163,10 +163,9 @@ static errcode_t ima_put(ext2_irel irel, ino_t old,
 	if (ref_ent->refs && ent->max_refs !=
 	    ma->entries[(unsigned) old].max_refs) {
 		size = (sizeof(struct ext2_inode_reference) * ent->max_refs);
-		new_refs = realloc(ref_ent->refs, size);
-		if (!new_refs)
-			return EXT2_NO_MEMORY;
-		ref_ent->refs = new_refs;
+		retval = ext2fs_resize_mem(size, (void **) &ref_ent->refs);
+		if (retval)
+			return retval;
 	}
 
 	ma->entries[(unsigned) old] = *ent;
@@ -235,6 +234,7 @@ static errcode_t ima_add_ref(ext2_irel irel, ino_t ino,
 	size_t		size;
 	struct inode_reference_entry *ref_ent;
 	struct ext2_inode_relocate_entry *ent;
+	errcode_t		retval;
 
 	ma = irel->private;
 	if (ino > ma->max_inode)
@@ -249,9 +249,9 @@ static errcode_t ima_add_ref(ext2_irel irel, ino_t ino,
 	if (ref_ent->refs == 0) {
 		size = (size_t) ((sizeof(struct ext2_inode_reference) * 
 				  ent->max_refs));
-		ref_ent->refs = malloc(size);
-		if (ref_ent->refs == 0)
-			return EXT2_NO_MEMORY;
+		retval = ext2fs_get_mem(size, (void **) &ref_ent->refs);
+		if (retval)
+			return retval;
 		memset(ref_ent->refs, 0, size);
 		ref_ent->num = 0;
 	}
@@ -310,7 +310,7 @@ static errcode_t ima_move(ext2_irel irel, ino_t old, ino_t new)
 	
 	ma->entries[(unsigned) new] = ma->entries[(unsigned) old];
 	if (ma->ref_entries[(unsigned) new].refs)
-		free(ma->ref_entries[(unsigned) new].refs);
+		ext2fs_free_mem((void **) &ma->ref_entries[(unsigned) new].refs);
 	ma->ref_entries[(unsigned) new] = ma->ref_entries[(unsigned) old];
 	
 	ma->entries[(unsigned) old].new = 0;
@@ -333,7 +333,7 @@ static errcode_t ima_delete(ext2_irel irel, ino_t old)
 	
 	ma->entries[old].new = 0;
 	if (ma->ref_entries[(unsigned) old].refs)
-		free(ma->ref_entries[(unsigned) old].refs);
+		ext2fs_free_mem((void **) &ma->ref_entries[(unsigned) old].refs);
 	ma->orig_map[ma->entries[(unsigned) old].orig] = 0;
 	
 	ma->ref_entries[(unsigned) old].num = 0;
@@ -353,20 +353,20 @@ static errcode_t ima_free(ext2_irel irel)
 
 	if (ma) {
 		if (ma->orig_map)
-			free (ma->orig_map);
+			ext2fs_free_mem((void **) &ma->orig_map);
 		if (ma->entries)
-			free (ma->entries);
+			ext2fs_free_mem((void **) &ma->entries);
 		if (ma->ref_entries) {
 			for (ino = 0; ino <= ma->max_inode; ino++) {
 				if (ma->ref_entries[(unsigned) ino].refs)
-					free(ma->ref_entries[(unsigned) ino].refs);
+					ext2fs_free_mem((void **) &ma->ref_entries[(unsigned) ino].refs);
 			}
-			free(ma->ref_entries);
+			ext2fs_free_mem((void **) &ma->ref_entries);
 		}
-		free(ma);
+		ext2fs_free_mem((void **) &ma);
 	}
 	if (irel->name)
-		free(irel->name);
-	free (irel);
+		ext2fs_free_mem((void **) &irel->name);
+	ext2fs_free_mem((void **) &irel);
 	return 0;
 }
diff --git a/lib/ext2fs/mkdir.c b/lib/ext2fs/mkdir.c
index e4524a8..72d1942 100644
--- a/lib/ext2fs/mkdir.c
+++ b/lib/ext2fs/mkdir.c
@@ -137,7 +137,7 @@ errcode_t ext2fs_mkdir(ext2_filsys fs, ino_t parent, ino_t inum,
 	
 cleanup:
 	if (block)
-		free(block);
+		ext2fs_free_mem((void **) &block);
 	return retval;
 
 }
diff --git a/lib/ext2fs/namei.c b/lib/ext2fs/namei.c
index 9b718fe..576a99f 100644
--- a/lib/ext2fs/namei.c
+++ b/lib/ext2fs/namei.c
@@ -50,12 +50,12 @@ static errcode_t follow_link(ext2_filsys fs, ino_t root, ino_t dir,
 		return EXT2_ET_SYMLINK_LOOP;
 	}
 	if (ei.i_blocks) {
-		buffer = malloc (fs->blocksize);
-		if (!buffer)
-			return EXT2_NO_MEMORY;
+		retval = ext2fs_get_mem(fs->blocksize, (void **) &buffer);
+		if (retval)
+			return retval;
 		retval = io_channel_read_blk(fs->io, ei.i_block[0], 1, buffer);
 		if (retval) {
-			free(buffer);
+			ext2fs_free_mem((void **) &buffer);
 			return retval;
 		}
 		pathname = buffer;
@@ -64,7 +64,7 @@ static errcode_t follow_link(ext2_filsys fs, ino_t root, ino_t dir,
 	retval = open_namei(fs, root, dir, pathname, ei.i_size, 1,
 			    link_count, buf, res_inode);
 	if (buffer)
-		free (buffer);
+		ext2fs_free_mem((void **) &buffer);
 	return retval;
 }
 
@@ -156,14 +156,14 @@ errcode_t ext2fs_namei(ext2_filsys fs, ino_t root, ino_t cwd,
 	
 	EXT2_CHECK_MAGIC(fs, EXT2_ET_MAGIC_EXT2FS_FILSYS);
 
-	buf = malloc(fs->blocksize);
-	if (!buf)
-		return EXT2_NO_MEMORY;
+	retval = ext2fs_get_mem(fs->blocksize, (void **) &buf);
+	if (retval)
+		return retval;
 	
 	retval = open_namei(fs, root, cwd, name, strlen(name), 0, 0,
 			    buf, inode);
 
-	free(buf);
+	ext2fs_free_mem((void **) &buf);
 	return retval;
 }
 
@@ -175,14 +175,14 @@ errcode_t ext2fs_namei_follow(ext2_filsys fs, ino_t root, ino_t cwd,
 	
 	EXT2_CHECK_MAGIC(fs, EXT2_ET_MAGIC_EXT2FS_FILSYS);
 
-	buf = malloc(fs->blocksize);
-	if (!buf)
-		return EXT2_NO_MEMORY;
+	retval = ext2fs_get_mem(fs->blocksize, (void **) &buf);
+	if (retval)
+		return retval;
 	
 	retval = open_namei(fs, root, cwd, name, strlen(name), 1, 0,
 			    buf, inode);
 
-	free(buf);
+	ext2fs_free_mem((void **) &buf);
 	return retval;
 }
 
@@ -194,13 +194,13 @@ extern errcode_t ext2fs_follow_link(ext2_filsys fs, ino_t root, ino_t cwd,
 	
 	EXT2_CHECK_MAGIC(fs, EXT2_ET_MAGIC_EXT2FS_FILSYS);
 
-	buf = malloc(fs->blocksize);
-	if (!buf)
-		return EXT2_NO_MEMORY;
-	
+	retval = ext2fs_get_mem(fs->blocksize, (void **) &buf);
+	if (retval)
+		return retval;
+
 	retval = follow_link(fs, root, cwd, inode, 0, buf, res_inode);
 
-	free(buf);
+	ext2fs_free_mem((void **) &buf);
 	return retval;
 }
 
diff --git a/lib/ext2fs/newdir.c b/lib/ext2fs/newdir.c
index e9fdc29..8e90a7a 100644
--- a/lib/ext2fs/newdir.c
+++ b/lib/ext2fs/newdir.c
@@ -26,15 +26,16 @@
 errcode_t ext2fs_new_dir_block(ext2_filsys fs, ino_t dir_ino, ino_t parent_ino,
 			       char **block)
 {
-	char	*buf;
-	struct ext2_dir_entry *dir = NULL;
-	int	rec_len;
+	struct ext2_dir_entry 	*dir = NULL;
+	errcode_t		retval;
+	char			*buf;
+	int			rec_len;
 
 	EXT2_CHECK_MAGIC(fs, EXT2_ET_MAGIC_EXT2FS_FILSYS);
 
-	buf = malloc(fs->blocksize);
-	if (!buf)
-		return EXT2_NO_MEMORY;
+	retval = ext2fs_get_mem(fs->blocksize, (void **) &buf);
+	if (retval)
+		return retval;
 	memset(buf, 0, fs->blocksize);
 	dir = (struct ext2_dir_entry *) buf;
 	dir->rec_len = fs->blocksize;
diff --git a/lib/ext2fs/openfs.c b/lib/ext2fs/openfs.c
index 07f47a5..582af19 100644
--- a/lib/ext2fs/openfs.c
+++ b/lib/ext2fs/openfs.c
@@ -52,10 +52,11 @@ errcode_t ext2fs_open(const char *name, int flags, int superblock,
 	struct ext2fs_sb	*s;
 	
 	EXT2_CHECK_MAGIC(manager, EXT2_ET_MAGIC_IO_MANAGER);
-	
-	fs = (ext2_filsys) malloc(sizeof(struct struct_ext2_filsys));
-	if (!fs)
-		return EXT2_NO_MEMORY;
+
+	retval = ext2fs_get_mem(sizeof(struct struct_ext2_filsys),
+				(void **) &fs);
+	if (retval)
+		return retval;
 	
 	memset(fs, 0, sizeof(struct struct_ext2_filsys));
 	fs->magic = EXT2_ET_MAGIC_EXT2FS_FILSYS;
@@ -65,17 +66,13 @@ errcode_t ext2fs_open(const char *name, int flags, int superblock,
 	if (retval)
 		goto cleanup;
 	fs->io->app_data = fs;
-	fs->device_name = malloc(strlen(name)+1);
-	if (!fs->device_name) {
-		retval = EXT2_NO_MEMORY;
+	retval = ext2fs_get_mem(strlen(name)+1, (void **) &fs->device_name);
+	if (retval)
 		goto cleanup;
-	}
 	strcpy(fs->device_name, name);
-	fs->super = malloc(SUPERBLOCK_SIZE);
-	if (!fs->super) {
-		retval = EXT2_NO_MEMORY;
+	retval = ext2fs_get_mem(SUPERBLOCK_SIZE, (void **) &fs->super);
+	if (retval)
 		goto cleanup;
-	}
 
 	/*
 	 * If the user specifies a specific block # for the
@@ -172,11 +169,10 @@ errcode_t ext2fs_open(const char *name, int flags, int superblock,
 	fs->desc_blocks = (fs->group_desc_count +
 			   EXT2_DESC_PER_BLOCK(fs->super) - 1)
 		/ EXT2_DESC_PER_BLOCK(fs->super);
-	fs->group_desc = malloc((size_t) (fs->desc_blocks * fs->blocksize));
-	if (!fs->group_desc) {
-		retval = EXT2_NO_MEMORY;
+	retval = ext2fs_get_mem(fs->desc_blocks * fs->blocksize,
+				(void **) &fs->group_desc);
+	if (retval)
 		goto cleanup;
-	}
 	if (!group_block)
 		group_block = fs->super->s_first_data_block + 1;
 	dest = (char *) fs->group_desc;
diff --git a/lib/ext2fs/rs_bitmap.c b/lib/ext2fs/rs_bitmap.c
index 843482c..60d0307 100644
--- a/lib/ext2fs/rs_bitmap.c
+++ b/lib/ext2fs/rs_bitmap.c
@@ -31,9 +31,9 @@
 errcode_t ext2fs_resize_generic_bitmap(__u32 new_end, __u32 new_real_end,
 				       ext2fs_generic_bitmap bmap)
 {
-	size_t	size, new_size;
-	char 	*new_bitmap;
-	__u32	bitno;
+	errcode_t	retval;
+	size_t		size, new_size;
+	__u32		bitno;
 
 	if (!bmap)
 		return EXT2_INVALID_ARGUMENT;
@@ -59,13 +59,12 @@ errcode_t ext2fs_resize_generic_bitmap(__u32 new_end, __u32 new_real_end,
 	size = ((bmap->real_end - bmap->start) / 8) + 1;
 	new_size = ((new_real_end - bmap->start) / 8) + 1;
 
-	new_bitmap = realloc(bmap->bitmap, new_size);
-	if (!new_bitmap)
-		return EXT2_NO_MEMORY;
+	retval = ext2fs_resize_mem(new_size, (void **) &bmap->bitmap);
+	if (retval)
+		return retval;
 	if (new_size > size)
-		memset(new_bitmap + size, 0, new_size - size);
+		memset(bmap->bitmap + size, 0, new_size - size);
 
-	bmap->bitmap = new_bitmap;
 	bmap->end = new_end;
 	bmap->real_end = new_real_end;
 	return 0;
diff --git a/lib/ext2fs/rw_bitmaps.c b/lib/ext2fs/rw_bitmaps.c
index a473d17..7909fff 100644
--- a/lib/ext2fs/rw_bitmaps.c
+++ b/lib/ext2fs/rw_bitmaps.c
@@ -69,9 +69,9 @@ errcode_t ext2fs_write_inode_bitmap(ext2_filsys fs)
 		return 0;
 	nbytes = (size_t) ((EXT2_INODES_PER_GROUP(fs->super)+7) / 8);
 	
-	bitmap_block = malloc(fs->blocksize);
-	if (!bitmap_block)
-		return EXT2_NO_MEMORY;
+	retval = ext2fs_get_mem(fs->blocksize, (void **) &bitmap_block);
+	if (retval)
+		return retval;
 	memset(bitmap_block, 0xff, fs->blocksize);
 	for (i = 0; i < fs->group_desc_count; i++) {
 		memcpy(bitmap_block, inode_bitmap, nbytes);
@@ -91,7 +91,7 @@ errcode_t ext2fs_write_inode_bitmap(ext2_filsys fs)
 	}
 	fs->flags |= EXT2_FLAG_CHANGED;
 	fs->flags &= ~EXT2_FLAG_IB_DIRTY;
-	free(bitmap_block);
+	ext2fs_free_mem((void **) &bitmap_block);
 	return 0;
 }
 
@@ -113,9 +113,9 @@ errcode_t ext2fs_write_block_bitmap (ext2_filsys fs)
 	if (!block_bitmap)
 		return 0;
 	nbytes = EXT2_BLOCKS_PER_GROUP(fs->super) / 8;
-	bitmap_block = malloc(fs->blocksize);
-	if (!bitmap_block)
-		return EXT2_NO_MEMORY;
+	retval = ext2fs_get_mem(fs->blocksize, (void **) &bitmap_block);
+	if (retval)
+		return retval;
 	memset(bitmap_block, 0xff, fs->blocksize);
 	for (i = 0; i < fs->group_desc_count; i++) {
 		memcpy(bitmap_block, block_bitmap, nbytes);
@@ -144,7 +144,7 @@ errcode_t ext2fs_write_block_bitmap (ext2_filsys fs)
 	}
 	fs->flags |= EXT2_FLAG_CHANGED;
 	fs->flags &= ~EXT2_FLAG_BB_DIRTY;
-	free(bitmap_block);
+	ext2fs_free_mem((void **) &bitmap_block);
 	return 0;
 }
 
@@ -162,7 +162,9 @@ static errcode_t read_bitmaps(ext2_filsys fs, int do_inode, int do_block)
 
 	fs->write_bitmaps = ext2fs_write_bitmaps;
 
-	buf = malloc(strlen(fs->device_name) + 80);
+	retval = ext2fs_get_mem(strlen(fs->device_name) + 80, (void **) &buf);
+	if (retval)
+		return retval;
 	if (do_block) {
 		if (fs->block_map)
 			ext2fs_free_block_bitmap(fs->block_map);
@@ -181,7 +183,7 @@ static errcode_t read_bitmaps(ext2_filsys fs, int do_inode, int do_block)
 			goto cleanup;
 		inode_bitmap = fs->inode_map->bitmap;
 	}
-	free(buf);
+	ext2fs_free_mem((void **) &buf);
 
 	for (i = 0; i < fs->group_desc_count; i++) {
 		if (block_bitmap) {
@@ -225,15 +227,15 @@ static errcode_t read_bitmaps(ext2_filsys fs, int do_inode, int do_block)
 	
 cleanup:
 	if (do_block) {
-		free(fs->block_map);
+		ext2fs_free_mem((void **) &fs->block_map);
 		fs->block_map = 0;
 	}
 	if (do_inode) {
-		free(fs->inode_map);
+		ext2fs_free_mem((void **) &fs->inode_map);
 		fs->inode_map = 0;
 	}
 	if (buf)
-		free(buf);
+		ext2fs_free_mem((void **) &buf);
 	return retval;
 }
 
diff --git a/lib/ext2fs/test_io.c b/lib/ext2fs/test_io.c
index 7467815..9c1126c 100644
--- a/lib/ext2fs/test_io.c
+++ b/lib/ext2fs/test_io.c
@@ -24,9 +24,9 @@
 #include <sys/types.h>
 #endif
 
-#include "et/com_err.h"
-#include "ext2fs/ext2_err.h"
-#include "ext2fs/ext2_io.h"
+#include <linux/ext2_fs.h>
+
+#include "ext2fs.h"
 
 /*
  * For checking structure magic numbers...
@@ -85,23 +85,23 @@ static errcode_t test_open(const char *name, int flags, io_channel *channel)
 
 	if (name == 0)
 		return EXT2_ET_BAD_DEVICE_NAME;
-	io = (io_channel) malloc(sizeof(struct struct_io_channel));
-	if (!io)
-		return EXT2_NO_MEMORY;
+	retval = ext2fs_get_mem(sizeof(struct struct_io_channel),
+				(void **) &io);
+	if (retval)
+		return retval;
 	memset(io, 0, sizeof(struct struct_io_channel));
 	io->magic = EXT2_ET_MAGIC_IO_CHANNEL;
-	data = (struct test_private_data *)
-		malloc(sizeof(struct test_private_data));
-	if (!data) {
+	retval = ext2fs_get_mem(sizeof(struct test_private_data),
+				(void **) &data);
+	if (retval) {
 		retval = EXT2_NO_MEMORY;
 		goto cleanup;
 	}
 	io->manager = test_io_manager;
-	io->name = malloc(strlen(name)+1);
-	if (!io->name) {
-		retval = EXT2_NO_MEMORY;
+	retval = ext2fs_get_mem(strlen(name)+1, (void **) &io->name);
+	if (retval)
 		goto cleanup;
-	}
+
 	strcpy(io->name, name);
 	io->private_data = data;
 	io->block_size = 1024;
@@ -127,9 +127,9 @@ static errcode_t test_open(const char *name, int flags, io_channel *channel)
 
 cleanup:
 	if (io)
-		free(io);
+		ext2fs_free_mem((void **) &io);
 	if (data)
-		free(data);
+		ext2fs_free_mem((void **) &data);
 	return retval;
 }
 
@@ -149,10 +149,10 @@ static errcode_t test_close(io_channel channel)
 		retval = io_channel_close(data->real);
 	
 	if (channel->private_data)
-		free(channel->private_data);
+		ext2fs_free_mem((void **) &channel->private_data);
 	if (channel->name)
-		free(channel->name);
-	free(channel);
+		ext2fs_free_mem((void **) &channel->name);
+	ext2fs_free_mem((void **) &channel);
 	return retval;
 }
 
diff --git a/lib/ext2fs/unix_io.c b/lib/ext2fs/unix_io.c
index f1d37b5..53bedb9 100644
--- a/lib/ext2fs/unix_io.c
+++ b/lib/ext2fs/unix_io.c
@@ -26,9 +26,9 @@
 #include <sys/types.h>
 #endif
 
-#include "et/com_err.h"
-#include "ext2fs/ext2_err.h"
-#include "ext2fs/ext2_io.h"
+#include <linux/ext2_fs.h>
+
+#include "ext2fs.h"
 
 /*
  * For checking structure magic numbers...
@@ -75,23 +75,22 @@ static errcode_t unix_open(const char *name, int flags, io_channel *channel)
 
 	if (name == 0)
 		return EXT2_ET_BAD_DEVICE_NAME;
-	io = (io_channel) malloc(sizeof(struct struct_io_channel));
-	if (!io)
-		return EXT2_NO_MEMORY;
+	retval = ext2fs_get_mem(sizeof(struct struct_io_channel),
+				(void **) &io);
+	if (retval)
+		return retval;
 	memset(io, 0, sizeof(struct struct_io_channel));
 	io->magic = EXT2_ET_MAGIC_IO_CHANNEL;
-	data = (struct unix_private_data *)
-		malloc(sizeof(struct unix_private_data));
-	if (!data) {
-		retval = EXT2_NO_MEMORY;
+	retval = ext2fs_get_mem(sizeof(struct unix_private_data),
+				(void **) &data);
+	if (retval)
 		goto cleanup;
-	}
+
 	io->manager = unix_io_manager;
-	io->name = malloc(strlen(name)+1);
-	if (!io->name) {
-		retval = EXT2_NO_MEMORY;
+	retval = ext2fs_get_mem(strlen(name)+1, (void **) &io->name);
+	if (retval)
 		goto cleanup;
-	}
+
 	strcpy(io->name, name);
 	io->private_data = data;
 	io->block_size = 1024;
@@ -101,12 +100,11 @@ static errcode_t unix_open(const char *name, int flags, io_channel *channel)
 
 	memset(data, 0, sizeof(struct unix_private_data));
 	data->magic = EXT2_ET_MAGIC_UNIX_IO_CHANNEL;
-	data->buf = malloc(io->block_size);
+	retval = ext2fs_get_mem(io->block_size, (void **) &data->buf);
 	data->buf_block_nr = -1;
-	if (!data->buf) {
-		retval = EXT2_NO_MEMORY;
+	if (retval)
 		goto cleanup;
-	}
+
 	data->dev = open(name, (flags & IO_FLAG_RW) ? O_RDWR : O_RDONLY);
 	if (data->dev < 0) {
 		retval = errno;
@@ -117,11 +115,11 @@ static errcode_t unix_open(const char *name, int flags, io_channel *channel)
 
 cleanup:
 	if (io)
-		free(io);
+		ext2fs_free_mem((void **) &io);
 	if (data) {
 		if (data->buf)
-			free(data->buf);
-		free(data);
+			ext2fs_free_mem((void **) &data->buf);
+		ext2fs_free_mem((void **) &data);
 	}
 	return retval;
 }
@@ -141,18 +139,19 @@ static errcode_t unix_close(io_channel channel)
 	if (close(data->dev) < 0)
 		retval = errno;
 	if (data->buf)
-		free(data->buf);
+		ext2fs_free_mem((void **) &data->buf);
 	if (channel->private_data)
-		free(channel->private_data);
+		ext2fs_free_mem((void **) &channel->private_data);
 	if (channel->name)
-		free(channel->name);
-	free(channel);
+		ext2fs_free_mem((void **) &channel->name);
+	ext2fs_free_mem((void **) &channel);
 	return retval;
 }
 
 static errcode_t unix_set_blksize(io_channel channel, int blksize)
 {
 	struct unix_private_data *data;
+	errcode_t		retval;
 
 	EXT2_CHECK_MAGIC(channel, EXT2_ET_MAGIC_IO_CHANNEL);
 	data = (struct unix_private_data *) channel->private_data;
@@ -160,10 +159,10 @@ static errcode_t unix_set_blksize(io_channel channel, int blksize)
 
 	if (channel->block_size != blksize) {
 		channel->block_size = blksize;
-		free(data->buf);
-		data->buf = malloc(blksize);
-		if (!data->buf)
-			return EXT2_NO_MEMORY;
+		ext2fs_free_mem((void **) &data->buf);
+		retval = ext2fs_get_mem(blksize, (void **) &data->buf);
+		if (retval)
+			return retval;
 		data->buf_block_nr = -1;
 	}
 	return 0;