View | Details | Raw Unified
Collapse All | Expand All

(-) a/lib/ext2fs/badblocks.c (-1 / +1 lines)
 Lines 42-48   static errcode_t make_u32_list(int size, int num, __u32 *list, Link Here  
	bb->magic = EXT2_ET_MAGIC_BADBLOCKS_LIST;
	bb->magic = EXT2_ET_MAGIC_BADBLOCKS_LIST;
	bb->size = size ? size : 10;
	bb->size = size ? size : 10;
	bb->num = num;
	bb->num = num;
	retval = ext2fs_get_mem(bb->size * sizeof(blk_t), &bb->list);
 
	retval = ext2fs_get_array(bb->size, sizeof(blk_t), &bb->list);
 
	if (retval) {
	if (retval) {
		ext2fs_free_mem(&bb);
		ext2fs_free_mem(&bb);
		return retval;
		return retval;
(-) a/lib/ext2fs/bb_inode.c (-1 / +1 lines)
 Lines 68-74   errcode_t ext2fs_update_bb_inode(ext2_filsys fs, ext2_badblocks_list bb_list) Link Here  
	rec.bad_block_count = 0;
	rec.bad_block_count = 0;
	rec.ind_blocks_size = rec.ind_blocks_ptr = 0;
	rec.ind_blocks_size = rec.ind_blocks_ptr = 0;
	rec.max_ind_blocks = 10;
	rec.max_ind_blocks = 10;
	retval = ext2fs_get_mem(rec.max_ind_blocks * sizeof(blk_t),
 
	retval = ext2fs_get_array(rec.max_ind_blocks, sizeof(blk_t),
 
				&rec.ind_blocks);
				&rec.ind_blocks);
	if (retval)
	if (retval)
		return retval;
		return retval;
(-) a/lib/ext2fs/block.c (-1 / +1 lines)
 Lines 313-319   errcode_t ext2fs_block_iterate2(ext2_filsys fs, Link Here  
	if (block_buf) {
	if (block_buf) {
		ctx.ind_buf = block_buf;
		ctx.ind_buf = block_buf;
	} else {
	} else {
		retval = ext2fs_get_mem(fs->blocksize * 3, &ctx.ind_buf);
 
		retval = ext2fs_get_array(3, fs->blocksize, &ctx.ind_buf);
 
		if (retval)
		if (retval)
			return retval;
			return retval;
	}
	}
(-) a/lib/ext2fs/bmap.c (-1 / +1 lines)
 Lines 158-164   errcode_t ext2fs_bmap(ext2_filsys fs, ext2_ino_t ino, struct ext2_inode *inode, Link Here  
	addr_per_block = (blk_t) fs->blocksize >> 2;
	addr_per_block = (blk_t) fs->blocksize >> 2;

        
	if (!block_buf) {
	if (!block_buf) {

            

              
		retval = ext2fs_get_mem(fs->blocksize * 2, &buf);

              
		retval = ext2fs_get_array(2, fs->blocksize, &buf);

            

        
		if (retval)
		if (retval)

        
			return retval;
			return retval;

        
		block_buf = buf;
		block_buf = buf;



(-) a/lib/ext2fs/bmove.c
      (-1 / +1 lines)




  

    

    

       Lines 108-114
      errcode_t ext2fs_move_blocks(ext2_filsys fs, 
    
  Link Here 
    

  

        
	pb.alloc_map = alloc_map ? alloc_map : fs->block_map;
	pb.alloc_map = alloc_map ? alloc_map : fs->block_map;

        
	pb.flags = flags;
	pb.flags = flags;

        
	
	

            

              
	retval = ext2fs_get_mem(fs->blocksize * 4, &block_buf);

              
	retval = ext2fs_get_array(4, fs->blocksize, &block_buf);

            

        
	if (retval)
	if (retval)

        
		return retval;
		return retval;

        
	pb.buf = block_buf + fs->blocksize * 3;
	pb.buf = block_buf + fs->blocksize * 3;



(-) a/lib/ext2fs/brel_ma.c
      (-1 / +2 lines)




  

    

    

       Lines 75-81
      errcode_t ext2fs_brel_memarray_create(char *name, blk_t max_block, 
    
  Link Here 
    

  

        
	
	

        
	size = (size_t) (sizeof(struct ext2_block_relocate_entry) *
	size = (size_t) (sizeof(struct ext2_block_relocate_entry) *

        
			 (max_block+1));
			 (max_block+1));

            

              
	retval = ext2fs_get_mem(size, &ma->entries);

              
	retval = ext2fs_get_array(max_block+1,

            

            

              

              
		sizeof(struct ext2_block_relocate_entry), &ma->entries);

            

        
	if (retval)
	if (retval)

        
		goto errout;
		goto errout;

        
	memset(ma->entries, 0, size);
	memset(ma->entries, 0, size);



(-) a/lib/ext2fs/closefs.c
      (-2 / +1 lines)




  

    

    

       Lines 226-233
      errcode_t ext2fs_flush(ext2_filsys fs) 
    
  Link Here 
    

  

        
		retval = ext2fs_get_mem(SUPERBLOCK_SIZE, &super_shadow);
		retval = ext2fs_get_mem(SUPERBLOCK_SIZE, &super_shadow);

        
		if (retval)
		if (retval)

        
			goto errout;
			goto errout;

            

              
		retval = ext2fs_get_mem((size_t)(fs->blocksize *

              
		retval = ext2fs_get_array(fs->blocksize, fs->desc_blocks,

            

            

              
						 fs->desc_blocks),

              

            

        
					&group_shadow);
					&group_shadow);

        
		if (retval)
		if (retval)

        
			goto errout;
			goto errout;



(-) a/lib/ext2fs/dblist.c
      (-1 / +2 lines)




  

    

    

       Lines 85-91
      static errcode_t make_dblist(ext2_filsys fs, ext2_ino_t size, ext2_ino_t count, 
    
  Link Here 
    

  

        
	}
	}

        
	len = (size_t) sizeof(struct ext2_db_entry) * dblist->size;
	len = (size_t) sizeof(struct ext2_db_entry) * dblist->size;

        
	dblist->count = count;
	dblist->count = count;

            

              
	retval = ext2fs_get_mem(len, &dblist->list);

              
	retval = ext2fs_get_array(dblist->size, sizeof(struct ext2_db_entry),

            

            

              

              
		&dblist->list);

            

        
	if (retval)
	if (retval)

        
		goto cleanup;
		goto cleanup;

        
	
	



(-) a/lib/ext2fs/dupfs.c
      (-1 / +1 lines)




  

    

    

       Lines 59-65
      errcode_t ext2fs_dup_handle(ext2_filsys src, ext2_filsys *dest) 
    
  Link Here 
    

  

        
		goto errout;
		goto errout;

        
	memcpy(fs->orig_super, src->orig_super, SUPERBLOCK_SIZE);
	memcpy(fs->orig_super, src->orig_super, SUPERBLOCK_SIZE);

        

            

              
	retval = ext2fs_get_mem((size_t) fs->desc_blocks * fs->blocksize,

              
	retval = ext2fs_get_array(fs->desc_blocks, fs->blocksize,

            

        
				&fs->group_desc);
				&fs->group_desc);

        
	if (retval)
	if (retval)

        
		goto errout;
		goto errout;



(-) a/lib/ext2fs/ext2fs.h
      (+7 lines)




  

    

    

       Lines 965-970
      extern errcode_t ext2fs_write_bb_FILE(ext2_badblocks_list bb_list, 
    
  Link Here 
    

  

        

        
/* inline functions */
/* inline functions */

        
extern errcode_t ext2fs_get_mem(unsigned long size, void *ptr);
extern errcode_t ext2fs_get_mem(unsigned long size, void *ptr);

            

              
              
extern errcode_t ext2fs_get_array(unsigned long count, unsigned long size, void *ptr);

            

        
extern errcode_t ext2fs_free_mem(void *ptr);
extern errcode_t ext2fs_free_mem(void *ptr);

        
extern errcode_t ext2fs_resize_mem(unsigned long old_size,
extern errcode_t ext2fs_resize_mem(unsigned long old_size,

        
				   unsigned long size, void *ptr);
				   unsigned long size, void *ptr);

  

    

    

       Lines 1018-1023
      _INLINE_ errcode_t ext2fs_get_mem(unsigned long size, void *ptr) 
    
  Link Here 
    

  

        
	memcpy(ptr, &pp, sizeof (pp));
	memcpy(ptr, &pp, sizeof (pp));

        
	return 0;
	return 0;

        
}
}

            

              
              
_INLINE_ errcode_t ext2fs_get_array(unsigned long count, unsigned long size, void *ptr)

            

            

              
              
{

            

            

              
              
	if (count && (-1UL)/count<size)

            

            

              
              
		return EXT2_ET_NO_MEMORY; //maybe define EXT2_ET_OVERFLOW ?

            

            

              
              
	return ext2fs_get_mem(count*size, ptr);

            

            

              
              
}

            

        

        
/*
/*

        
 * Free memory
 * Free memory



(-) a/lib/ext2fs/fileio.c
      (-1 / +1 lines)




  

    

    

       Lines 65-71
      errcode_t ext2fs_file_open2(ext2_filsys fs, ext2_ino_t ino, 
    
  Link Here 
    

  

        
			goto fail;
			goto fail;

        
	}
	}

        
	
	

            

              
	retval = ext2fs_get_mem(fs->blocksize * 3, &file->buf);

              
	retval = ext2fs_get_array(3, fs->blocksize, &file->buf);

            

        
	if (retval)
	if (retval)

        
		goto fail;
		goto fail;

        



(-) a/lib/ext2fs/icount.c
      (-1 / +2 lines)




  

    

    

       Lines 237-243
      errcode_t ext2fs_create_icount2(ext2_filsys fs, int flags, unsigned int size, 
    
  Link Here 
    

  

        
	printf("Icount allocated %u entries, %d bytes.\n",
	printf("Icount allocated %u entries, %d bytes.\n",

        
	       icount->size, bytes);
	       icount->size, bytes);

        
#endif
#endif

            

              
	retval = ext2fs_get_mem(bytes, &icount->list);

              
	retval = ext2fs_get_array(icount->size, sizeof(struct ext2_icount_el),

            

            

              

              
			 &icount->list);

            

        
	if (retval)
	if (retval)

        
		goto errout;
		goto errout;

        
	memset(icount->list, 0, bytes);
	memset(icount->list, 0, bytes);



(-) a/lib/ext2fs/initialize.c
      (-1 / +1 lines)




  

    

    

       Lines 351-357
      ipg_retry: 
    
  Link Here 
    

  

        

        
	ext2fs_free_mem(&buf);
	ext2fs_free_mem(&buf);

        

            

              
	retval = ext2fs_get_mem((size_t) fs->desc_blocks * fs->blocksize,

              
	retval = ext2fs_get_array(fs->desc_blocks, fs->blocksize,

            

        
				&fs->group_desc);
				&fs->group_desc);

        
	if (retval)
	if (retval)

        
		goto cleanup;
		goto cleanup;



(-) a/lib/ext2fs/inode.c
      (-5 / +5 lines)




  

    

    

       Lines 90-98
      static errcode_t create_icache(ext2_filsys fs) 
    
  Link Here 
    

  

        
	fs->icache->cache_last = -1;
	fs->icache->cache_last = -1;

        
	fs->icache->cache_size = 4;
	fs->icache->cache_size = 4;

        
	fs->icache->refcount = 1;
	fs->icache->refcount = 1;

            

              
	retval = ext2fs_get_mem(sizeof(struct ext2_inode_cache_ent)

              
	retval = ext2fs_get_array(fs->icache->cache_size,

            

            

              
				* fs->icache->cache_size,

              
				  sizeof(struct ext2_inode_cache_ent),

            

            

              
				&fs->icache->cache);

              
				  &fs->icache->cache);

            

        
	if (retval) {
	if (retval) {

        
		ext2fs_free_mem(&fs->icache->buffer);
		ext2fs_free_mem(&fs->icache->buffer);

        
		ext2fs_free_mem(&fs->icache);
		ext2fs_free_mem(&fs->icache);

  

    

    

       Lines 146-153
      errcode_t ext2fs_open_inode_scan(ext2_filsys fs, int buffer_blocks, 
    
  Link Here 
    

  

        
		group_desc[scan->current_group].bg_inode_table;
		group_desc[scan->current_group].bg_inode_table;

        
	scan->inodes_left = EXT2_INODES_PER_GROUP(scan->fs->super);
	scan->inodes_left = EXT2_INODES_PER_GROUP(scan->fs->super);

        
	scan->blocks_left = scan->fs->inode_blocks_per_group;
	scan->blocks_left = scan->fs->inode_blocks_per_group;

            

              
	retval = ext2fs_get_mem((size_t) (scan->inode_buffer_blocks * 

              
	retval = ext2fs_get_array(scan->inode_buffer_blocks,

            

            

              
					  fs->blocksize),

              
					  fs->blocksize,

            

        
				&scan->inode_buffer);
				&scan->inode_buffer);

        
	scan->done_group = 0;
	scan->done_group = 0;

        
	scan->done_group_data = 0;
	scan->done_group_data = 0;



(-) a/lib/ext2fs/irel_ma.c
      (-4 / +8 lines)




  

    

    

       Lines 90-110
      errcode_t ext2fs_irel_memarray_create(char *name, ext2_ino_t max_inode, 
    
  Link Here 
    

  

        
	irel->priv_data = ma;
	irel->priv_data = ma;

        
	
	

        
	size = (size_t) (sizeof(ext2_ino_t) * (max_inode+1));
	size = (size_t) (sizeof(ext2_ino_t) * (max_inode+1));

            

              
	retval = ext2fs_get_mem(size, &ma->orig_map);

              
	retval = ext2fs_get_array(max_inode+1, sizeof(ext2_ino_t),

            

            

              

              
		&ma->orig_map);

            

        
	if (retval)
	if (retval)

        
		goto errout;
		goto errout;

        
	memset(ma->orig_map, 0, size);
	memset(ma->orig_map, 0, size);

        

        
	size = (size_t) (sizeof(struct ext2_inode_relocate_entry) *
	size = (size_t) (sizeof(struct ext2_inode_relocate_entry) *

        
			 (max_inode+1));
			 (max_inode+1));

            

              
	retval = ext2fs_get_mem(size, &ma->entries);

              
	retval = ext2fs_get_array((max_inode+1,

            

            

              

              
		sizeof(struct ext2_inode_relocate_entry), &ma->entries);

            

        
	if (retval)
	if (retval)

        
		goto errout;
		goto errout;

        
	memset(ma->entries, 0, size);
	memset(ma->entries, 0, size);

        

        
	size = (size_t) (sizeof(struct inode_reference_entry) *
	size = (size_t) (sizeof(struct inode_reference_entry) *

        
			 (max_inode+1));
			 (max_inode+1));

            

              
	retval = ext2fs_get_mem(size, &ma->ref_entries);

              
	retval = ext2fs_get_mem(max_inode+1,

            

            

              

              
		sizeof(struct inode_reference_entry), &ma->ref_entries);

            

        
	if (retval)
	if (retval)

        
		goto errout;
		goto errout;

        
	memset(ma->ref_entries, 0, size);
	memset(ma->ref_entries, 0, size);

  

    

    

       Lines 249-255
      static errcode_t ima_add_ref(ext2_irel irel, ext2_ino_t ino, 
    
  Link Here 
    

  

        
	if (ref_ent->refs == 0) {
	if (ref_ent->refs == 0) {

        
		size = (size_t) ((sizeof(struct ext2_inode_reference) * 
		size = (size_t) ((sizeof(struct ext2_inode_reference) * 

        
				  ent->max_refs));
				  ent->max_refs));

            

              
		retval = ext2fs_get_mem(size, &ref_ent->refs);

              
		retval = ext2fs_get_array(ent->max_refs,

            

            

              

              
			sizeof(struct ext2_inode_reference), &ref_ent->refs);

            

        
		if (retval)
		if (retval)

        
			return retval;
			return retval;

        
		memset(ref_ent->refs, 0, size);
		memset(ref_ent->refs, 0, size);



(-) a/lib/ext2fs/openfs.c
      (-1 / +1 lines)




  

    

    

       Lines 280-286
      errcode_t ext2fs_open2(const char *name, const char *io_options, 
    
  Link Here 
    

  

        
					       blocks_per_group);
					       blocks_per_group);

        
	fs->desc_blocks = ext2fs_div_ceil(fs->group_desc_count,
	fs->desc_blocks = ext2fs_div_ceil(fs->group_desc_count,

        
					  EXT2_DESC_PER_BLOCK(fs->super));
					  EXT2_DESC_PER_BLOCK(fs->super));

            

              
	retval = ext2fs_get_mem(fs->desc_blocks * fs->blocksize,

              
	retval = ext2fs_get_array(fs->desc_blocks, fs->blocksize,

            

        
				&fs->group_desc);
				&fs->group_desc);

        
	if (retval)
	if (retval)

        
		goto cleanup;
		goto cleanup;



(-) a/lib/ext2fs/res_gdt.c
      (-1 / +1 lines)




  

    

    

       Lines 73-79
      errcode_t ext2fs_create_resize_inode(ext2_filsys fs) 
    
  Link Here 
    

  

        

        
	sb = fs->super;
	sb = fs->super;

        

            

              
	retval = ext2fs_get_mem(2 * fs->blocksize, &dindir_buf);

              
	retval = ext2fs_get_array(2, fs->blocksize, &dindir_buf);

            

        
	if (retval)
	if (retval)

        
		goto out_free;
		goto out_free;

        
	gdt_buf = (__u32 *)((char *)dindir_buf + fs->blocksize);
	gdt_buf = (__u32 *)((char *)dindir_buf + fs->blocksize);