Attachment #137932 for bug #201546

View | Details | Raw Unified | Return to bug 201546
Collapse All | Expand All

Lines 42-48 static errcode_t make_u32_list(int size, int num, __u32 *list, Link Here

(-)a/lib/ext2fs/badblocks.c (-1 / +1 lines)
42	bb->magic = EXT2_ET_MAGIC_BADBLOCKS_LIST;	42	bb->magic = EXT2_ET_MAGIC_BADBLOCKS_LIST;
43	bb->size = size ? size : 10;	43	bb->size = size ? size : 10;
44	bb->num = num;	44	bb->num = num;
45	retval = ext2fs_get_mem(bb->size * sizeof(blk_t), &bb->list);	45	retval = ext2fs_get_array(bb->size, sizeof(blk_t), &bb->list);
46	if (retval) {	46	if (retval) {
47	ext2fs_free_mem(&bb);	47	ext2fs_free_mem(&bb);
48	return retval;	48	return retval;

Lines 68-74 errcode_t ext2fs_update_bb_inode(ext2_filsys fs, ext2_badblocks_list bb_list) Link Here

(-)a/lib/ext2fs/bb_inode.c (-1 / +1 lines)
68	rec.bad_block_count = 0;	68	rec.bad_block_count = 0;
69	rec.ind_blocks_size = rec.ind_blocks_ptr = 0;	69	rec.ind_blocks_size = rec.ind_blocks_ptr = 0;
70	rec.max_ind_blocks = 10;	70	rec.max_ind_blocks = 10;
71	retval = ext2fs_get_mem(rec.max_ind_blocks * sizeof(blk_t),	71	retval = ext2fs_get_array(rec.max_ind_blocks, sizeof(blk_t),
72	&rec.ind_blocks);	72	&rec.ind_blocks);
73	if (retval)	73	if (retval)
74	return retval;	74	return retval;

Lines 313-319 errcode_t ext2fs_block_iterate2(ext2_filsys fs, Link Here

(-)a/lib/ext2fs/block.c (-1 / +1 lines)
313	if (block_buf) {	313	if (block_buf) {
314	ctx.ind_buf = block_buf;	314	ctx.ind_buf = block_buf;
315	} else {	315	} else {
316	retval = ext2fs_get_mem(fs->blocksize * 3, &ctx.ind_buf);	316	retval = ext2fs_get_array(3, fs->blocksize, &ctx.ind_buf);
317	if (retval)	317	if (retval)
318	return retval;	318	return retval;
319	}	319	}

Lines 158-164 errcode_t ext2fs_bmap(ext2_filsys fs, ext2_ino_t ino, struct ext2_inode *inode, Link Here

(-)a/lib/ext2fs/bmap.c (-1 / +1 lines)
158	addr_per_block = (blk_t) fs->blocksize >> 2;	158	addr_per_block = (blk_t) fs->blocksize >> 2;
159		159
160	if (!block_buf) {	160	if (!block_buf) {
161	retval = ext2fs_get_mem(fs->blocksize * 2, &buf);	161	retval = ext2fs_get_array(2, fs->blocksize, &buf);
162	if (retval)	162	if (retval)
163	return retval;	163	return retval;
164	block_buf = buf;	164	block_buf = buf;

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

(-)a/lib/ext2fs/bmove.c (-1 / +1 lines)
108	pb.alloc_map = alloc_map ? alloc_map : fs->block_map;	108	pb.alloc_map = alloc_map ? alloc_map : fs->block_map;
109	pb.flags = flags;	109	pb.flags = flags;
110		110
111	retval = ext2fs_get_mem(fs->blocksize * 4, &block_buf);	111	retval = ext2fs_get_array(4, fs->blocksize, &block_buf);
112	if (retval)	112	if (retval)
113	return retval;	113	return retval;
114	pb.buf = block_buf + fs->blocksize * 3;	114	pb.buf = block_buf + fs->blocksize * 3;

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

(-)a/lib/ext2fs/brel_ma.c (-1 / +2 lines)
75		75
76	size = (size_t) (sizeof(struct ext2_block_relocate_entry) *	76	size = (size_t) (sizeof(struct ext2_block_relocate_entry) *
77	(max_block+1));	77	(max_block+1));
78	retval = ext2fs_get_mem(size, &ma->entries);	78	retval = ext2fs_get_array(max_block+1,
		79	sizeof(struct ext2_block_relocate_entry), &ma->entries);
79	if (retval)	80	if (retval)
80	goto errout;	81	goto errout;
81	memset(ma->entries, 0, size);	82	memset(ma->entries, 0, size);

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

(-)a/lib/ext2fs/closefs.c (-2 / +1 lines)
226	retval = ext2fs_get_mem(SUPERBLOCK_SIZE, &super_shadow);	226	retval = ext2fs_get_mem(SUPERBLOCK_SIZE, &super_shadow);
227	if (retval)	227	if (retval)
228	goto errout;	228	goto errout;
229	retval = ext2fs_get_mem((size_t)(fs->blocksize *	229	retval = ext2fs_get_array(fs->blocksize, fs->desc_blocks,
230	fs->desc_blocks),
231	&group_shadow);	230	&group_shadow);
232	if (retval)	231	if (retval)
233	goto errout;	232	goto errout;

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

(-)a/lib/ext2fs/dblist.c (-1 / +2 lines)
85	}	85	}
86	len = (size_t) sizeof(struct ext2_db_entry) * dblist->size;	86	len = (size_t) sizeof(struct ext2_db_entry) * dblist->size;
87	dblist->count = count;	87	dblist->count = count;
88	retval = ext2fs_get_mem(len, &dblist->list);	88	retval = ext2fs_get_array(dblist->size, sizeof(struct ext2_db_entry),
		89	&dblist->list);
89	if (retval)	90	if (retval)
90	goto cleanup;	91	goto cleanup;
91		92

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

(-)a/lib/ext2fs/dupfs.c (-1 / +1 lines)
59	goto errout;	59	goto errout;
60	memcpy(fs->orig_super, src->orig_super, SUPERBLOCK_SIZE);	60	memcpy(fs->orig_super, src->orig_super, SUPERBLOCK_SIZE);
61		61
62	retval = ext2fs_get_mem((size_t) fs->desc_blocks * fs->blocksize,	62	retval = ext2fs_get_array(fs->desc_blocks, fs->blocksize,
63	&fs->group_desc);	63	&fs->group_desc);
64	if (retval)	64	if (retval)
65	goto errout;	65	goto errout;

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

(-)a/lib/ext2fs/ext2fs.h (+7 lines)
965		965
966	/* inline functions */	966	/* inline functions */
967	extern errcode_t ext2fs_get_mem(unsigned long size, void *ptr);	967	extern errcode_t ext2fs_get_mem(unsigned long size, void *ptr);
		968	extern errcode_t ext2fs_get_array(unsigned long count, unsigned long size, void *ptr);
968	extern errcode_t ext2fs_free_mem(void *ptr);	969	extern errcode_t ext2fs_free_mem(void *ptr);
969	extern errcode_t ext2fs_resize_mem(unsigned long old_size,	970	extern errcode_t ext2fs_resize_mem(unsigned long old_size,
970	unsigned long size, void *ptr);	971	unsigned long size, void *ptr);
Lines 1018-1023 _INLINE_ errcode_t ext2fs_get_mem(unsigned long size, void *ptr) Link Here
1018	memcpy(ptr, &pp, sizeof (pp));	1019	memcpy(ptr, &pp, sizeof (pp));
1019	return 0;	1020	return 0;
1020	}	1021	}
		1022	_INLINE_ errcode_t ext2fs_get_array(unsigned long count, unsigned long size, void *ptr)
		1023	{
		1024	if (count && (-1UL)/count<size)
		1025	return EXT2_ET_NO_MEMORY; //maybe define EXT2_ET_OVERFLOW ?
		1026	return ext2fs_get_mem(count*size, ptr);
		1027	}
1021		1028
1022	/*	1029	/*
1023	* Free memory	1030	* Free memory

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

(-)a/lib/ext2fs/fileio.c (-1 / +1 lines)
65	goto fail;	65	goto fail;
66	}	66	}
67		67
68	retval = ext2fs_get_mem(fs->blocksize * 3, &file->buf);	68	retval = ext2fs_get_array(3, fs->blocksize, &file->buf);
69	if (retval)	69	if (retval)
70	goto fail;	70	goto fail;
71		71

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

(-)a/lib/ext2fs/icount.c (-1 / +2 lines)
237	printf("Icount allocated %u entries, %d bytes.\n",	237	printf("Icount allocated %u entries, %d bytes.\n",
238	icount->size, bytes);	238	icount->size, bytes);
239	#endif	239	#endif
240	retval = ext2fs_get_mem(bytes, &icount->list);	240	retval = ext2fs_get_array(icount->size, sizeof(struct ext2_icount_el),
		241	&icount->list);
241	if (retval)	242	if (retval)
242	goto errout;	243	goto errout;
243	memset(icount->list, 0, bytes);	244	memset(icount->list, 0, bytes);

Lines 351-357 ipg_retry: Link Here

(-)a/lib/ext2fs/initialize.c (-1 / +1 lines)
351		351
352	ext2fs_free_mem(&buf);	352	ext2fs_free_mem(&buf);
353		353
354	retval = ext2fs_get_mem((size_t) fs->desc_blocks * fs->blocksize,	354	retval = ext2fs_get_array(fs->desc_blocks, fs->blocksize,
355	&fs->group_desc);	355	&fs->group_desc);
356	if (retval)	356	if (retval)
357	goto cleanup;	357	goto cleanup;




	fs->icache->cache_last = -1;
	fs->icache->cache_size = 4;
	fs->icache->refcount = 1;
	retval = ext2fs_get_array(fs->icache->cache_size,
				  sizeof(struct ext2_inode_cache_ent),
				  &fs->icache->cache);
	if (retval) {
		ext2fs_free_mem(&fs->icache->buffer);
		ext2fs_free_mem(&fs->icache);

		group_desc[scan->current_group].bg_inode_table;
	scan->inodes_left = EXT2_INODES_PER_GROUP(scan->fs->super);
	scan->blocks_left = scan->fs->inode_blocks_per_group;
	retval = ext2fs_get_array(scan->inode_buffer_blocks,
					  fs->blocksize,
				&scan->inode_buffer);
	scan->done_group = 0;
	scan->done_group_data = 0;




	irel->priv_data = ma;
	
	size = (size_t) (sizeof(ext2_ino_t) * (max_inode+1));
	retval = ext2fs_get_array(max_inode+1, sizeof(ext2_ino_t),
		&ma->orig_map);
	if (retval)
		goto errout;
	memset(ma->orig_map, 0, size);

	size = (size_t) (sizeof(struct ext2_inode_relocate_entry) *
			 (max_inode+1));
	retval = ext2fs_get_array((max_inode+1,
		sizeof(struct ext2_inode_relocate_entry), &ma->entries);
	if (retval)
		goto errout;
	memset(ma->entries, 0, size);

	size = (size_t) (sizeof(struct inode_reference_entry) *
			 (max_inode+1));
	retval = ext2fs_get_mem(max_inode+1,
		sizeof(struct inode_reference_entry), &ma->ref_entries);
	if (retval)
		goto errout;
	memset(ma->ref_entries, 0, size);

	if (ref_ent->refs == 0) {
		size = (size_t) ((sizeof(struct ext2_inode_reference) * 
				  ent->max_refs));
		retval = ext2fs_get_array(ent->max_refs,
			sizeof(struct ext2_inode_reference), &ref_ent->refs);
		if (retval)
			return retval;
		memset(ref_ent->refs, 0, size);

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

(-)a/lib/ext2fs/openfs.c (-1 / +1 lines)
280	blocks_per_group);	280	blocks_per_group);
281	fs->desc_blocks = ext2fs_div_ceil(fs->group_desc_count,	281	fs->desc_blocks = ext2fs_div_ceil(fs->group_desc_count,
282	EXT2_DESC_PER_BLOCK(fs->super));	282	EXT2_DESC_PER_BLOCK(fs->super));
283	retval = ext2fs_get_mem(fs->desc_blocks * fs->blocksize,	283	retval = ext2fs_get_array(fs->desc_blocks, fs->blocksize,
284	&fs->group_desc);	284	&fs->group_desc);
285	if (retval)	285	if (retval)
286	goto cleanup;	286	goto cleanup;

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

(-)a/lib/ext2fs/res_gdt.c (-2 / +1 lines)
73		73
74	sb = fs->super;	74	sb = fs->super;
75		75
76	retval = ext2fs_get_mem(2 * fs->blocksize, &dindir_buf);	76	retval = ext2fs_get_array(2, fs->blocksize, &dindir_buf);
77	if (retval)	77	if (retval)
78	goto out_free;	78	goto out_free;
79	gdt_buf = (__u32 )((char )dindir_buf + fs->blocksize);	79	gdt_buf = (__u32 )((char )dindir_buf + fs->blocksize);
80	-

Return to bug 201546

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

(-)a/lib/ext2fs/inode.c (-5 / +5 lines)
90	fs->icache->cache_last = -1;	90	fs->icache->cache_last = -1;
91	fs->icache->cache_size = 4;	91	fs->icache->cache_size = 4;
92	fs->icache->refcount = 1;	92	fs->icache->refcount = 1;
93	retval = ext2fs_get_mem(sizeof(struct ext2_inode_cache_ent)	93	retval = ext2fs_get_array(fs->icache->cache_size,
94	* fs->icache->cache_size,	94	sizeof(struct ext2_inode_cache_ent),
95	&fs->icache->cache);	95	&fs->icache->cache);
96	if (retval) {	96	if (retval) {
97	ext2fs_free_mem(&fs->icache->buffer);	97	ext2fs_free_mem(&fs->icache->buffer);
98	ext2fs_free_mem(&fs->icache);	98	ext2fs_free_mem(&fs->icache);
Lines 146-153 errcode_t ext2fs_open_inode_scan(ext2_filsys fs, int buffer_blocks, Link Here
146	group_desc[scan->current_group].bg_inode_table;	146	group_desc[scan->current_group].bg_inode_table;
147	scan->inodes_left = EXT2_INODES_PER_GROUP(scan->fs->super);	147	scan->inodes_left = EXT2_INODES_PER_GROUP(scan->fs->super);
148	scan->blocks_left = scan->fs->inode_blocks_per_group;	148	scan->blocks_left = scan->fs->inode_blocks_per_group;
149	retval = ext2fs_get_mem((size_t) (scan->inode_buffer_blocks *	149	retval = ext2fs_get_array(scan->inode_buffer_blocks,
150	fs->blocksize),	150	fs->blocksize,
151	&scan->inode_buffer);	151	&scan->inode_buffer);
152	scan->done_group = 0;	152	scan->done_group = 0;
153	scan->done_group_data = 0;	153	scan->done_group_data = 0;

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

(-)a/lib/ext2fs/irel_ma.c (-4 / +8 lines)
90	irel->priv_data = ma;	90	irel->priv_data = ma;
91		91
92	size = (size_t) (sizeof(ext2_ino_t) * (max_inode+1));	92	size = (size_t) (sizeof(ext2_ino_t) * (max_inode+1));
93	retval = ext2fs_get_mem(size, &ma->orig_map);	93	retval = ext2fs_get_array(max_inode+1, sizeof(ext2_ino_t),
		94	&ma->orig_map);
94	if (retval)	95	if (retval)
95	goto errout;	96	goto errout;
96	memset(ma->orig_map, 0, size);	97	memset(ma->orig_map, 0, size);
97		98
98	size = (size_t) (sizeof(struct ext2_inode_relocate_entry) *	99	size = (size_t) (sizeof(struct ext2_inode_relocate_entry) *
99	(max_inode+1));	100	(max_inode+1));
100	retval = ext2fs_get_mem(size, &ma->entries);	101	retval = ext2fs_get_array((max_inode+1,
		102	sizeof(struct ext2_inode_relocate_entry), &ma->entries);
101	if (retval)	103	if (retval)
102	goto errout;	104	goto errout;
103	memset(ma->entries, 0, size);	105	memset(ma->entries, 0, size);
104		106
105	size = (size_t) (sizeof(struct inode_reference_entry) *	107	size = (size_t) (sizeof(struct inode_reference_entry) *
106	(max_inode+1));	108	(max_inode+1));
107	retval = ext2fs_get_mem(size, &ma->ref_entries);	109	retval = ext2fs_get_mem(max_inode+1,
		110	sizeof(struct inode_reference_entry), &ma->ref_entries);
108	if (retval)	111	if (retval)
109	goto errout;	112	goto errout;
110	memset(ma->ref_entries, 0, size);	113	memset(ma->ref_entries, 0, size);
Lines 249-255 static errcode_t ima_add_ref(ext2_irel irel, ext2_ino_t ino, Link Here
249	if (ref_ent->refs == 0) {	252	if (ref_ent->refs == 0) {
250	size = (size_t) ((sizeof(struct ext2_inode_reference) *	253	size = (size_t) ((sizeof(struct ext2_inode_reference) *
251	ent->max_refs));	254	ent->max_refs));
252	retval = ext2fs_get_mem(size, &ref_ent->refs);	255	retval = ext2fs_get_array(ent->max_refs,
		256	sizeof(struct ext2_inode_reference), &ref_ent->refs);
253	if (retval)	257	if (retval)
254	return retval;	258	return retval;
255	memset(ref_ent->refs, 0, size);	259	memset(ref_ent->refs, 0, size);