[Ext2resize-cvs] ext2resize/src ext2_block_relocator.c,1.20,1.21

SourceForge Headquarters 225 Broadway Suite 1600 San Diego, CA 92101 +1 (858) 422-6466

Update of /cvsroot/ext2resize/ext2resize/src
In directory sc8-pr-cvs1.sourceforge.net:/tmp/cvs-serv13416

Modified Files:
	ext2_block_relocator.c 
Log Message:
Do some s/foobar/foo_bar renamings, some s/%d/%u/ fix and tidy.

Index: ext2_block_relocator.c
===================================================================
RCS file: /cvsroot/ext2resize/ext2resize/src/ext2_block_relocator.c,v
retrieving revision 1.20
retrieving revision 1.21
diff -C2 -d -r1.20 -r1.21
*** ext2_block_relocator.c	30 Sep 2004 14:05:55 -0000	1.20
--- ext2_block_relocator.c	18 Feb 2006 06:04:32 -0000	1.21
***************
*** 40,47 ****
  struct ext2_block_relocator_state
  {
! 	blk_t			 newallocoffset;
! 	blk_t			 allocentries;
! 	blk_t			 usedentries;
! 	blk_t			 resolvedentries;
  	struct ext2_block_entry *block;

--- 40,47 ----
  struct ext2_block_relocator_state
  {
! 	blk_t			 new_alloc_offset;
! 	blk_t			 alloc_entries;
! 	blk_t			 used_entries;
! 	blk_t			 resolved_entries;
  	struct ext2_block_entry *block;

***************
*** 105,109 ****
  }

! struct ext2_block_entry *findit(struct ext2_block_relocator_state *state, blk_t block)
  {
  	int			 min_e;
--- 105,110 ----
  }

! struct ext2_block_entry *findit(struct ext2_block_relocator_state *state,
! 				blk_t block)
  {
  	int			 min_e;
***************
*** 113,117 ****
  	blk_t			 tval;

! 	max_e = state->usedentries - 1;
  	min_e = 0;
  	retv = NULL;
--- 114,118 ----
  	blk_t			 tval;

! 	max_e = state->used_entries - 1;
  	min_e = 0;
  	retv = NULL;
***************
*** 157,161 ****
  	ent->isindirectblock = indirect;

! 	state->resolvedentries++;
  	state->start[indirect].num++;

--- 158,162 ----
  	ent->isindirectblock = indirect;

! 	state->resolved_entries++;
  	state->start[indirect].num++;

***************
*** 325,329 ****
  				}

! 				if (state->resolvedentries == state->usedentries)
  					break;
  			}
--- 326,330 ----
  				}

! 				if (state->resolved_entries == state->used_entries)
  					break;
  			}
***************
*** 333,342 ****
  		if (fs->flags & FL_VERBOSE) {
  			printf("%i/%i blocks resolved\r",
! 			       state->resolvedentries,
! 			       state->usedentries);
  			fflush(stdout);
  		}

! 		if (state->resolvedentries == state->usedentries)
  			break;
  	}
--- 334,343 ----
  		if (fs->flags & FL_VERBOSE) {
  			printf("%i/%i blocks resolved\r",
! 			       state->resolved_entries,
! 			       state->used_entries);
  			fflush(stdout);
  		}

! 		if (state->resolved_entries == state->used_entries)
  			break;
  	}
***************
*** 350,354 ****
  	state->start[0].dst = state->start[1].dst + state->start[1].num;

! 	return (state->resolvedentries == state->usedentries);
  }

--- 351,355 ----
  	state->start[0].dst = state->start[1].dst + state->start[1].num;

! 	return (state->resolved_entries == state->used_entries);
  }

***************
*** 368,372 ****
  		struct ext2_block_entry *ptr;

! 		numleft = state->usedentries;
  		ptr = state->block;
  		while (numleft && ret) {
--- 369,373 ----
  		struct ext2_block_entry *ptr;

! 		numleft = state->used_entries;
  		ptr = state->block;
  		while (numleft && ret) {
***************
*** 391,396 ****
  			if (fs->flags & FL_VERBOSE) {
  				printf("copied %i/%i blocks\r",
! 				       state->usedentries - numleft,
! 				       state->usedentries);
  				fflush(stdout);
  			}
--- 392,397 ----
  			if (fs->flags & FL_VERBOSE) {
  				printf("copied %i/%i blocks\r",
! 				       state->used_entries - numleft,
! 				       state->used_entries);
  				fflush(stdout);
  			}
***************
*** 408,412 ****
  		int ret = 1;

! 		for (i = 0; i < state->usedentries && ret; i++) {
  			struct ext2_block_entry *block;

--- 409,413 ----
  		int ret = 1;

! 		for (i = 0; i < state->used_entries && ret; i++) {
  			struct ext2_block_entry *block;

***************
*** 495,499 ****
  			int bpg;
  			int raid_bb, raid_ib;
! 			int itend = state->newallocoffset;

  			bpg = fs->sb.s_blocks_per_group;
--- 496,500 ----
  			int bpg;
  			int raid_bb, raid_ib;
! 			int itend = state->new_alloc_offset;

  			bpg = fs->sb.s_blocks_per_group;
***************
*** 515,519 ****
  					state->block[ptr++].dest = start + j;

! 					if (ptr == state->usedentries) {
  						ext2_brelse(bh, 0);
  						return 1;
--- 516,520 ----
  					state->block[ptr++].dest = start + j;

! 					if (ptr == state->used_entries) {
  						ext2_brelse(bh, 0);
  						return 1;
***************
*** 535,539 ****
  	int i;

! 	if (!state->usedentries)
  		return 1;

--- 536,540 ----
  	int i;

! 	if (!state->used_entries)
  		return 1;

***************
*** 541,545 ****
  		printf("%s\n", __FUNCTION__);

! 	qsort(state->block, state->usedentries, sizeof(struct ext2_block_entry),
  	      compare_block_entries);

--- 542,546 ----
  		printf("%s\n", __FUNCTION__);

! 	qsort(state->block, state->used_entries, sizeof(struct ext2_block_entry),
  	      compare_block_entries);

***************
*** 552,556 ****
  	ext2_block_relocator_copy(fs, state);

! 	qsort(state->block, state->usedentries, sizeof(struct ext2_block_entry),
  	      compare_block_entries_ind);

--- 553,557 ----
  	ext2_block_relocator_copy(fs, state);

! 	qsort(state->block, state->used_entries, sizeof(struct ext2_block_entry),
  	      compare_block_entries_ind);

***************
*** 586,591 ****
  	}

! 	state->usedentries = 0;
! 	state->resolvedentries = 0;

  	return 1;
--- 587,592 ----
  	}

! 	state->used_entries = 0;
! 	state->resolved_entries = 0;

  	return 1;
***************
*** 611,619 ****
  	}

! 	if (state->usedentries == state->allocentries - 1)
  		if (!ext2_block_relocator_flush(fs, state))
  			return 0;

! 	i = state->usedentries;
  	state->block[i].num = block;
  	state->block[i].dest = 0;
--- 612,620 ----
  	}

! 	if (state->used_entries == state->alloc_entries - 1)
  		if (!ext2_block_relocator_flush(fs, state))
  			return 0;

! 	i = state->used_entries;
  	state->block[i].num = block;
  	state->block[i].dest = 0;
***************
*** 621,625 ****
  	state->block[i].refoffset = 0;

! 	state->usedentries++;
  	return 1;
  }
--- 622,626 ----
  	state->block[i].refoffset = 0;

! 	state->used_entries++;
  	return 1;
  }
***************
*** 643,652 ****
  	ext2_read_inode(fs, EXT2_RESIZE_INO, inode);
  	inode->i_mtime = 0;
! 	state->newallocoffset = newitoffset + fs->inodeblocks;
  	if (fs->flags & FL_DEBUG)
! 		printf("moving data (oldgdblocks %d+%d, newgdblocks %d, "
! 		       "olditoffset %d, newitoffset %d, newallocoffset %d)\n",
  		       fs->gdblocks, fs->resgdblocks, fs->newgdblocks,
! 		       fs->itoffset, newitoffset, state->newallocoffset);

  	for (group = 0, start = fs->sb.s_first_data_block;
--- 644,653 ----
  	ext2_read_inode(fs, EXT2_RESIZE_INO, inode);
  	inode->i_mtime = 0;
! 	state->new_alloc_offset = newitoffset + fs->inodeblocks;
  	if (fs->flags & FL_DEBUG)
! 		printf("moving data (oldgdblocks %u+%u, newgdblocks %u, "
! 		       "olditoffset %d, newitoffset %d, new_alloc_offset %u)\n",
  		       fs->gdblocks, fs->resgdblocks, fs->newgdblocks,
! 		       fs->itoffset, newitoffset, state->new_alloc_offset);

  	for (group = 0, start = fs->sb.s_first_data_block;
***************
*** 786,789 ****
--- 787,791 ----
  	if (inode->i_mtime)
  		ext2_write_inode(fs, EXT2_RESIZE_INO, inode);
+ 
  	return ext2_block_relocator_flush(fs, state);
  }
***************
*** 800,804 ****
  		printf("%s\n", __FUNCTION__);

! 	state->newallocoffset = fs->itoffset + fs->inodeblocks;
  	ext2_read_inode(fs, EXT2_RESIZE_INO, inode);
  	inode->i_mtime = 0;
--- 802,806 ----
  		printf("%s\n", __FUNCTION__);

! 	state->new_alloc_offset = fs->itoffset + fs->inodeblocks;
  	ext2_read_inode(fs, EXT2_RESIZE_INO, inode);
  	inode->i_mtime = 0;
***************
*** 913,921 ****
  		printf("relocating blocks....\n");

! 	state.newallocoffset = 0;
! 	state.allocentries = (ext2_relocator_pool_size << 10) /
! 		sizeof(struct ext2_block_entry);
! 	state.usedentries = 0;
! 	state.resolvedentries = 0;
  	state.block = (struct ext2_block_entry *)fs->relocator_pool;

--- 915,923 ----
  		printf("relocating blocks....\n");

! 	state.new_alloc_offset = 0;
! 	state.alloc_entries = (ext2_relocator_pool_size << 10) /
! 				sizeof(struct ext2_block_entry);
! 	state.used_entries = 0;
! 	state.resolved_entries = 0;
  	state.block = (struct ext2_block_entry *)fs->relocator_pool;