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 (file)
--- 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 (file)
--- 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 (file)
--- 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 (file)
--- 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 (file)
--- 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 (file)
--- 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 (file)
--- 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 (file)
--- 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 (file)
--- 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 (file)
--- 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 (file)
--- 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 (file)
--- 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 (file)
--- 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 (file)
--- 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 (file)
--- 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 (file)
--- 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 (file)
--- 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 (file)
--- 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 (file)
--- 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 (file)
--- 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 (file)
--- 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 (file)
--- 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 (file)
--- 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 (file)
--- 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 (file)
--- 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 (file)
--- 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 (file)
--- 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 (file)
--- 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 (file)
--- 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 (file)
--- 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 (file)
--- 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 (file)
--- 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;