Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit bd4c625c authored by Linus Torvalds's avatar Linus Torvalds
Browse files

reiserfs: run scripts/Lindent on reiserfs code 



This was a pure indentation change, using:

	scripts/Lindent fs/reiserfs/*.c include/linux/reiserfs_*.h

to make reiserfs match the regular Linux indentation style.  As Jeff
Mahoney <jeffm@suse.com> writes:

 The ReiserFS code is a mix of a number of different coding styles, sometimes
 different even from line-to-line. Since the code has been relatively stable
 for quite some time and there are few outstanding patches to be applied, it
 is time to reformat the code to conform to the Linux style standard outlined
 in Documentation/CodingStyle.

 This patch contains the result of running scripts/Lindent against
 fs/reiserfs/*.c and include/linux/reiserfs_*.h. There are places where the
 code can be made to look better, but I'd rather keep those patches separate
 so that there isn't a subtle by-hand hand accident in the middle of a huge
 patch. To be clear: This patch is reformatting *only*.

 A number of patches may follow that continue to make the code more consistent
 with the Linux coding style.

 Hans wasn't particularly enthusiastic about these patches, but said he
 wouldn't really oppose them either.

Signed-off-by: default avatarLinus Torvalds <torvalds@osdl.org>
parent 7fa94c88

fs/reiserfs/bitmap.c

+969 −873
Original line number Diff line number Diff line
@@ -63,7 +63,8 @@ int is_reusable (struct super_block * s, b_blocknr_t block, int bit_value) 
	int i, j;



	if (block == 0 || block >= SB_BLOCK_COUNT(s)) {

	reiserfs_warning (s, "vs-4010: is_reusable: block number is out of range %lu (%u)",

		reiserfs_warning(s,

				 "vs-4010: is_reusable: block number is out of range %lu (%u)",

				 block, SB_BLOCK_COUNT(s));

		return 0;

	}
@@ -80,7 +81,8 @@ int is_reusable (struct super_block * s, b_blocknr_t block, int bit_value) 
	get_bit_address(s, block, &i, &j);



	if (i >= SB_BMAP_NR(s)) {

	reiserfs_warning (s, "vs-4030: is_reusable: there is no so many bitmap blocks: "

		reiserfs_warning(s,

				 "vs-4030: is_reusable: there is no so many bitmap blocks: "

				 "block=%lu, bitmap_nr=%d", block, i);

		return 0;

	}
@@ -89,15 +91,20 @@ int is_reusable (struct super_block * s, b_blocknr_t block, int bit_value) 
	     reiserfs_test_le_bit(j, SB_AP_BITMAP(s)[i].bh->b_data)) ||

	    (bit_value == 1 &&

	     reiserfs_test_le_bit(j, SB_AP_BITMAP(s)[i].bh->b_data) == 0)) {

	reiserfs_warning (s, "vs-4040: is_reusable: corresponding bit of block %lu does not "

		reiserfs_warning(s,

				 "vs-4040: is_reusable: corresponding bit of block %lu does not "

				 "match required value (i==%d, j==%d) test_bit==%d",

		block, i, j, reiserfs_test_le_bit (j, SB_AP_BITMAP (s)[i].bh->b_data));

				 block, i, j, reiserfs_test_le_bit(j,

								   SB_AP_BITMAP

								   (s)[i].bh->

								   b_data));



		return 0;

	}



	if (bit_value == 0 && block == SB_ROOT_BLOCK(s)) {

	reiserfs_warning (s, "vs-4050: is_reusable: this is root block (%u), "

		reiserfs_warning(s,

				 "vs-4050: is_reusable: this is root block (%u), "

				 "it must be busy", SB_ROOT_BLOCK(s));

		return 0;

	}
@@ -130,7 +137,8 @@ off, int *next) 
/* it searches for a window of zero bits with given minimum and maximum lengths in one bitmap

 * block; */

static int scan_bitmap_block(struct reiserfs_transaction_handle *th,

			      int bmap_n, int *beg, int boundary, int min, int max, int unfm)

			     int bmap_n, int *beg, int boundary, int min,

			     int max, int unfm)

{

	struct super_block *s = th->t_super;

	struct reiserfs_bitmap_info *bi = &SB_AP_BITMAP(s)[bmap_n];
@@ -139,7 +147,8 @@ static int scan_bitmap_block (struct reiserfs_transaction_handle *th, 


	BUG_ON(!th->t_trans_id);



    RFALSE(bmap_n >= SB_BMAP_NR (s), "Bitmap %d is out of range (0..%d)",bmap_n, SB_BMAP_NR (s) - 1);

	RFALSE(bmap_n >= SB_BMAP_NR(s), "Bitmap %d is out of range (0..%d)",

	       bmap_n, SB_BMAP_NR(s) - 1);

	PROC_INFO_INC(s, scan_bitmap.bmap);

/* this is unclear and lacks comments, explain how journal bitmaps

   work here for the reader.  Convey a sense of the design here. What
@@ -147,7 +156,8 @@ static int scan_bitmap_block (struct reiserfs_transaction_handle *th, 
/* - I mean `a window of zero bits' as in description of this function - Zam. */



	if (!bi) {

	reiserfs_warning (s, "NULL bitmap info pointer for bitmap %d", bmap_n);

		reiserfs_warning(s, "NULL bitmap info pointer for bitmap %d",

				 bmap_n);

		return 0;

	}

	if (buffer_locked(bi->bh)) {
@@ -173,7 +183,8 @@ static int scan_bitmap_block (struct reiserfs_transaction_handle *th, 
			continue;

		/* first zero bit found; we check next bits */

		for (end = *beg + 1;; end++) {

	    if (end >= *beg + max || end >= boundary || reiserfs_test_le_bit (end, bi->bh->b_data)) {

			if (end >= *beg + max || end >= boundary

			    || reiserfs_test_le_bit(end, bi->bh->b_data)) {

				next = end;

				break;

			}
@@ -191,7 +202,8 @@ static int scan_bitmap_block (struct reiserfs_transaction_handle *th, 
			/* try to set all blocks used checking are they still free */

			for (i = *beg; i < end; i++) {

				/* It seems that we should not check in journal again. */

		if (reiserfs_test_and_set_le_bit (i, bi->bh->b_data)) {

				if (reiserfs_test_and_set_le_bit

				    (i, bi->bh->b_data)) {

					/* bit was set by another process

					 * while we slept in prepare_for_journal() */

					PROC_INFO_INC(s, scan_bitmap.stolen);
@@ -202,8 +214,11 @@ static int scan_bitmap_block (struct reiserfs_transaction_handle *th, 
					}

					/* otherwise we clear all bit were set ... */

					while (--i >= *beg)

			reiserfs_test_and_clear_le_bit (i, bi->bh->b_data);

		    reiserfs_restore_prepared_buffer (s, bi->bh);

						reiserfs_test_and_clear_le_bit

						    (i, bi->bh->b_data);

					reiserfs_restore_prepared_buffer(s,

									 bi->

									 bh);

					*beg = org;

					/* ... and search again in current block from beginning */

					goto cont;
@@ -213,7 +228,8 @@ static int scan_bitmap_block (struct reiserfs_transaction_handle *th, 
			journal_mark_dirty(th, s, bi->bh);



			/* free block count calculation */

	    reiserfs_prepare_for_journal (s, SB_BUFFER_WITH_SB(s), 1);

			reiserfs_prepare_for_journal(s, SB_BUFFER_WITH_SB(s),

						     1);

			PUT_SB_FREE_BLOCKS(s, SB_FREE_BLOCKS(s) - (end - *beg));

			journal_mark_dirty(th, s, SB_BUFFER_WITH_SB(s));
@@ -224,7 +240,8 @@ static int scan_bitmap_block (struct reiserfs_transaction_handle *th, 
	}

}



static int bmap_hash_id(struct super_block *s, u32 id) {

static int bmap_hash_id(struct super_block *s, u32 id)

{

	char *hash_in = NULL;

	unsigned long hash;

	unsigned bm;
@@ -248,7 +265,8 @@ static int bmap_hash_id(struct super_block *s, u32 id) { 
 * hashes the id and then returns > 0 if the block group for the

 * corresponding hash is full

 */

static inline int block_group_used(struct super_block *s, u32 id) {

static inline int block_group_used(struct super_block *s, u32 id)

{

	int bm;

	bm = bmap_hash_id(s, id);

	if (SB_AP_BITMAP(s)[bm].free_count > ((s->s_blocksize << 3) * 60 / 100)) {
@@ -318,10 +336,15 @@ static int scan_bitmap (struct reiserfs_transaction_handle *th, 
	 * This is only an allocation policy and does not make up for getting a

	 * bad hint. Decent hinting must be implemented for this to work well.

	 */

    if ( TEST_OPTION(skip_busy, s) && SB_FREE_BLOCKS(s) > SB_BLOCK_COUNT(s)/20 ) {

	if (TEST_OPTION(skip_busy, s)

	    && SB_FREE_BLOCKS(s) > SB_BLOCK_COUNT(s) / 20) {

		for (; bm < end_bm; bm++, off = 0) {

	    if ( ( off && (!unfm || (file_block != 0))) || SB_AP_BITMAP(s)[bm].free_count > (s->s_blocksize << 3) / 10 )

		nr_allocated = scan_bitmap_block(th, bm, &off, off_max, min, max, unfm);

			if ((off && (!unfm || (file_block != 0)))

			    || SB_AP_BITMAP(s)[bm].free_count >

			    (s->s_blocksize << 3) / 10)

				nr_allocated =

				    scan_bitmap_block(th, bm, &off, off_max,

						      min, max, unfm);

			if (nr_allocated)

				goto ret;

		}
@@ -330,12 +353,14 @@ static int scan_bitmap (struct reiserfs_transaction_handle *th, 
	}



	for (; bm < end_bm; bm++, off = 0) {

	nr_allocated = scan_bitmap_block(th, bm, &off, off_max, min, max, unfm);

		nr_allocated =

		    scan_bitmap_block(th, bm, &off, off_max, min, max, unfm);

		if (nr_allocated)

			goto ret;

	}



    nr_allocated = scan_bitmap_block(th, bm, &off, end_off + 1, min, max, unfm);

	nr_allocated =

	    scan_bitmap_block(th, bm, &off, end_off + 1, min, max, unfm);



      ret:

	*start = bm * off_max + off;
@@ -399,7 +424,8 @@ void reiserfs_free_block (struct reiserfs_transaction_handle *th, 
	BUG_ON(!th->t_trans_id);



	RFALSE(!s, "vs-4061: trying to free block on nonexistent device");

    RFALSE(is_reusable (s, block, 1) == 0, "vs-4071: can not free such block");

	RFALSE(is_reusable(s, block, 1) == 0,

	       "vs-4071: can not free such block");

	/* mark it before we clear it, just in case */

	journal_mark_freed(th, s, block);

	_reiserfs_free_block(th, inode, block, for_unformatted);
@@ -407,9 +433,12 @@ void reiserfs_free_block (struct reiserfs_transaction_handle *th, 


/* preallocated blocks don't need to be run through journal_mark_freed */

static void reiserfs_free_prealloc_block(struct reiserfs_transaction_handle *th,

			  struct inode *inode, b_blocknr_t block) {

    RFALSE(!th->t_super, "vs-4060: trying to free block on nonexistent device");

    RFALSE(is_reusable (th->t_super, block, 1) == 0, "vs-4070: can not free such block");

					 struct inode *inode, b_blocknr_t block)

{

	RFALSE(!th->t_super,

	       "vs-4060: trying to free block on nonexistent device");

	RFALSE(is_reusable(th->t_super, block, 1) == 0,

	       "vs-4070: can not free such block");

	BUG_ON(!th->t_trans_id);

	_reiserfs_free_block(th, inode, block, 1);

}
@@ -423,7 +452,9 @@ static void __discard_prealloc (struct reiserfs_transaction_handle * th, 
	BUG_ON(!th->t_trans_id);

#ifdef CONFIG_REISERFS_CHECK

	if (ei->i_prealloc_count < 0)

	reiserfs_warning (th->t_super, "zam-4001:%s: inode has negative prealloc blocks count.", __FUNCTION__ );

		reiserfs_warning(th->t_super,

				 "zam-4001:%s: inode has negative prealloc blocks count.",

				 __FUNCTION__);

#endif

	while (ei->i_prealloc_count > 0) {

		reiserfs_free_prealloc_block(th, inode, ei->i_prealloc_block);
@@ -455,10 +486,13 @@ void reiserfs_discard_all_prealloc (struct reiserfs_transaction_handle *th) 


	while (!list_empty(plist)) {

		struct reiserfs_inode_info *ei;

	ei = list_entry(plist->next, struct reiserfs_inode_info, i_prealloc_list);

		ei = list_entry(plist->next, struct reiserfs_inode_info,

				i_prealloc_list);

#ifdef CONFIG_REISERFS_CHECK

		if (!ei->i_prealloc_count) {

	    reiserfs_warning (th->t_super, "zam-4001:%s: inode is in prealloc list but has no preallocated blocks.", __FUNCTION__);

			reiserfs_warning(th->t_super,

					 "zam-4001:%s: inode is in prealloc list but has no preallocated blocks.",

					 __FUNCTION__);

		}

#endif

		__discard_prealloc(th, ei);
@@ -486,18 +520,22 @@ int reiserfs_parse_alloc_options(struct super_block * s, char * options) 
		if (!strcmp(this_char, "concentrating_formatted_nodes")) {

			int temp;

			SET_OPTION(concentrating_formatted_nodes);

	    temp = (value && *value) ? simple_strtoul (value, &value, 0) : 10;

			temp = (value

				&& *value) ? simple_strtoul(value, &value,

							    0) : 10;

			if (temp <= 0 || temp > 100) {

				REISERFS_SB(s)->s_alloc_options.border = 10;

			} else {

		REISERFS_SB(s)->s_alloc_options.border = 100 / temp;

				REISERFS_SB(s)->s_alloc_options.border =

				    100 / temp;

			}

			continue;

		}

		if (!strcmp(this_char, "displacing_large_files")) {

			SET_OPTION(displacing_large_files);

			REISERFS_SB(s)->s_alloc_options.large_file_size =

		(value && *value) ? simple_strtoul (value, &value, 0) : 16;

			    (value

			     && *value) ? simple_strtoul(value, &value, 0) : 16;

			continue;

		}

		if (!strcmp(this_char, "displacing_new_packing_localities")) {
@@ -554,13 +592,17 @@ int reiserfs_parse_alloc_options(struct super_block * s, char * options) 


		if (!strcmp(this_char, "preallocmin")) {

			REISERFS_SB(s)->s_alloc_options.preallocmin =

		(value && *value) ? simple_strtoul (value, &value, 0) : 4;

			    (value

			     && *value) ? simple_strtoul(value, &value, 0) : 4;

			continue;

		}



		if (!strcmp(this_char, "preallocsize")) {

			REISERFS_SB(s)->s_alloc_options.preallocsize =

		(value && *value) ? simple_strtoul (value, &value, 0) : PREALLOCATION_SIZE;

			    (value

			     && *value) ? simple_strtoul(value, &value,

							 0) :

			    PREALLOCATION_SIZE;

			continue;

		}
@@ -586,18 +628,19 @@ static inline void new_hashed_relocation (reiserfs_blocknr_hint_t * hint) 
		    if (TEST_OPTION(displace_based_on_dirid, hint->th->t_super))

			hash_in = (char *)(&INODE_PKEY(hint->inode)->k_dir_id);

		else

		hash_in = (char *)(&INODE_PKEY(hint->inode)->k_objectid);

			hash_in =

			    (char *)(&INODE_PKEY(hint->inode)->k_objectid);

	}



    hint->search_start = hint->beg + keyed_hash(hash_in, 4) % (hint->end - hint->beg);

	hint->search_start =

	    hint->beg + keyed_hash(hash_in, 4) % (hint->end - hint->beg);

}



/*

 * Relocation based on dirid, hashing them into a given bitmap block

 * files. Formatted nodes are unaffected, a seperate policy covers them

 */

static void

dirid_groups (reiserfs_blocknr_hint_t *hint)

static void dirid_groups(reiserfs_blocknr_hint_t * hint)

{

	unsigned long hash;

	__u32 dirid = 0;
@@ -622,8 +665,7 @@ dirid_groups (reiserfs_blocknr_hint_t *hint) 
 * Relocation based on oid, hashing them into a given bitmap block

 * files. Formatted nodes are unaffected, a seperate policy covers them

 */

static void

oid_groups (reiserfs_blocknr_hint_t *hint)

static void oid_groups(reiserfs_blocknr_hint_t * hint)

{

	if (hint->inode) {

		unsigned long hash;
@@ -697,9 +739,11 @@ static int get_left_neighbor(reiserfs_blocknr_hint_t *hint) 
   specified as number of percent with mount option device, else try to put

   on last of device.  This is not to say it is good code to do so,

   but the effect should be measured.  */

static inline void set_border_in_hint(struct super_block *s, reiserfs_blocknr_hint_t *hint)

static inline void set_border_in_hint(struct super_block *s,

				      reiserfs_blocknr_hint_t * hint)

{

    b_blocknr_t border = SB_BLOCK_COUNT(s) / REISERFS_SB(s)->s_alloc_options.border;

	b_blocknr_t border =

	    SB_BLOCK_COUNT(s) / REISERFS_SB(s)->s_alloc_options.border;



	if (hint->formatted_node)

		hint->end = border - 1;
@@ -710,9 +754,15 @@ static inline void set_border_in_hint(struct super_block *s, reiserfs_blocknr_hi 
static inline void displace_large_file(reiserfs_blocknr_hint_t * hint)

{

	if (TEST_OPTION(displace_based_on_dirid, hint->th->t_super))

	hint->search_start = hint->beg + keyed_hash((char *)(&INODE_PKEY(hint->inode)->k_dir_id), 4) % (hint->end - hint->beg);

		hint->search_start =

		    hint->beg +

		    keyed_hash((char *)(&INODE_PKEY(hint->inode)->k_dir_id),

			       4) % (hint->end - hint->beg);

	else

	hint->search_start = hint->beg + keyed_hash((char *)(&INODE_PKEY(hint->inode)->k_objectid), 4) % (hint->end - hint->beg);

		hint->search_start =

		    hint->beg +

		    keyed_hash((char *)(&INODE_PKEY(hint->inode)->k_objectid),

			       4) % (hint->end - hint->beg);

}



static inline void hash_formatted_node(reiserfs_blocknr_hint_t * hint)
@@ -726,12 +776,16 @@ static inline void hash_formatted_node(reiserfs_blocknr_hint_t *hint) 
	else

		hash_in = (char *)(&INODE_PKEY(hint->inode)->k_objectid);



	hint->search_start = hint->beg + keyed_hash(hash_in, 4) % (hint->end - hint->beg);

	hint->search_start =

	    hint->beg + keyed_hash(hash_in, 4) % (hint->end - hint->beg);

}



static inline int this_blocknr_allocation_would_make_it_a_large_file(reiserfs_blocknr_hint_t *hint)

static inline int

this_blocknr_allocation_would_make_it_a_large_file(reiserfs_blocknr_hint_t *

						   hint)

{

    return hint->block == REISERFS_SB(hint->th->t_super)->s_alloc_options.large_file_size;

	return hint->block ==

	    REISERFS_SB(hint->th->t_super)->s_alloc_options.large_file_size;

}



#ifdef DISPLACE_NEW_PACKING_LOCALITIES
@@ -740,7 +794,9 @@ static inline void displace_new_packing_locality (reiserfs_blocknr_hint_t *hint) 
	struct in_core_key *key = &hint->key;



	hint->th->displace_new_blocks = 0;

    hint->search_start = hint->beg + keyed_hash((char*)(&key->k_objectid),4) % (hint->end - hint->beg);

	hint->search_start =

	    hint->beg + keyed_hash((char *)(&key->k_objectid),

				   4) % (hint->end - hint->beg);

}

#endif
@@ -754,7 +810,9 @@ static inline int old_hashed_relocation (reiserfs_blocknr_hint_t * hint) 
	}



	hash_in = le32_to_cpu((INODE_PKEY(hint->inode))->k_dir_id);

    border = hint->beg + (u32) keyed_hash(((char *) (&hash_in)), 4) % (hint->end - hint->beg - 1);

	border =

	    hint->beg + (u32) keyed_hash(((char *)(&hash_in)),

					 4) % (hint->end - hint->beg - 1);

	if (border > hint->search_start)

		hint->search_start = border;
@@ -769,7 +827,10 @@ static inline int old_way (reiserfs_blocknr_hint_t * hint) 
		return 0;

	}



      border = hint->beg + le32_to_cpu(INODE_PKEY(hint->inode)->k_dir_id) % (hint->end  - hint->beg);

	border =

	    hint->beg +

	    le32_to_cpu(INODE_PKEY(hint->inode)->k_dir_id) % (hint->end -

							      hint->beg);

	if (border > hint->search_start)

		hint->search_start = border;
@@ -781,8 +842,10 @@ static inline void hundredth_slices (reiserfs_blocknr_hint_t * hint) 
	struct in_core_key *key = &hint->key;

	b_blocknr_t slice_start;



    slice_start = (keyed_hash((char*)(&key->k_dir_id),4) % 100) * (hint->end / 100);

    if ( slice_start > hint->search_start || slice_start + (hint->end / 100) <= hint->search_start) {

	slice_start =

	    (keyed_hash((char *)(&key->k_dir_id), 4) % 100) * (hint->end / 100);

	if (slice_start > hint->search_start

	    || slice_start + (hint->end / 100) <= hint->search_start) {

		hint->search_start = slice_start;

	}

}
@@ -843,46 +906,44 @@ static void determine_search_start(reiserfs_blocknr_hint_t *hint, 
			else if (!reiserfs_no_unhashed_relocation(s))

				old_hashed_relocation(hint);



	    if ( hint->inode && hint->search_start < REISERFS_I(hint->inode)->i_prealloc_block)

		hint->search_start = REISERFS_I(hint->inode)->i_prealloc_block;

			if (hint->inode

			    && hint->search_start <

			    REISERFS_I(hint->inode)->i_prealloc_block)

				hint->search_start =

				    REISERFS_I(hint->inode)->i_prealloc_block;

		}

		return;

	}



	/* This is an approach proposed by Hans */

    if ( TEST_OPTION(hundredth_slices, s) && ! (displacing_large_files(s) && !hint->formatted_node)) {

	if (TEST_OPTION(hundredth_slices, s)

	    && !(displacing_large_files(s) && !hint->formatted_node)) {

		hundredth_slices(hint);

		return;

	}



	/* old_hashed_relocation only works on unformatted */

	if (!unfm_hint && !hint->formatted_node &&

        TEST_OPTION(old_hashed_relocation, s))

    {

	    TEST_OPTION(old_hashed_relocation, s)) {

		old_hashed_relocation(hint);

	}

	/* new_hashed_relocation works with both formatted/unformatted nodes */

	if ((!unfm_hint || hint->formatted_node) &&

        TEST_OPTION(new_hashed_relocation, s))

    {

	    TEST_OPTION(new_hashed_relocation, s)) {

		new_hashed_relocation(hint);

	}

	/* dirid grouping works only on unformatted nodes */

    if (!unfm_hint && !hint->formatted_node && TEST_OPTION(dirid_groups,s))

    {

	if (!unfm_hint && !hint->formatted_node && TEST_OPTION(dirid_groups, s)) {

		dirid_groups(hint);

	}



#ifdef DISPLACE_NEW_PACKING_LOCALITIES

    if (hint->formatted_node && TEST_OPTION(dirid_groups,s))

    {

	if (hint->formatted_node && TEST_OPTION(dirid_groups, s)) {

		dirid_groups(hint);

	}

#endif



	/* oid grouping works only on unformatted nodes */

    if (!unfm_hint && !hint->formatted_node && TEST_OPTION(oid_groups,s))

    {

	if (!unfm_hint && !hint->formatted_node && TEST_OPTION(oid_groups, s)) {

		oid_groups(hint);

	}

	return;
@@ -898,8 +959,12 @@ static int determine_prealloc_size(reiserfs_blocknr_hint_t * hint) 


	if (!hint->formatted_node && hint->preallocate) {

		if (S_ISREG(hint->inode->i_mode)

	    && hint->inode->i_size >= REISERFS_SB(hint->th->t_super)->s_alloc_options.preallocmin * hint->inode->i_sb->s_blocksize)

	    hint->prealloc_size = REISERFS_SB(hint->th->t_super)->s_alloc_options.preallocsize - 1;

		    && hint->inode->i_size >=

		    REISERFS_SB(hint->th->t_super)->s_alloc_options.

		    preallocmin * hint->inode->i_sb->s_blocksize)

			hint->prealloc_size =

			    REISERFS_SB(hint->th->t_super)->s_alloc_options.

			    preallocsize - 1;

	}

	return CARRY_ON;

}
@@ -908,17 +973,18 @@ static int determine_prealloc_size(reiserfs_blocknr_hint_t * hint) 
   but may be result function would be too complex. */

static inline int allocate_without_wrapping_disk(reiserfs_blocknr_hint_t * hint,

						 b_blocknr_t * new_blocknrs,

					 b_blocknr_t start, b_blocknr_t finish,

					 int min,

					 int amount_needed, int prealloc_size)

						 b_blocknr_t start,

						 b_blocknr_t finish, int min,

						 int amount_needed,

						 int prealloc_size)

{

	int rest = amount_needed;

	int nr_allocated;



	while (rest > 0 && start <= finish) {

		nr_allocated = scan_bitmap(hint->th, &start, finish, min,

				    rest + prealloc_size, !hint->formatted_node,

				    hint->block);

					   rest + prealloc_size,

					   !hint->formatted_node, hint->block);



		if (nr_allocated == 0)	/* no new blocks allocated, return */

			break;
@@ -926,16 +992,19 @@ static inline int allocate_without_wrapping_disk (reiserfs_blocknr_hint_t * hint 
		/* fill free_blocknrs array first */

		while (rest > 0 && nr_allocated > 0) {

			*new_blocknrs++ = start++;

	    rest --; nr_allocated --;

			rest--;

			nr_allocated--;

		}



		/* do we have something to fill prealloc. array also ? */

		if (nr_allocated > 0) {

			/* it means prealloc_size was greater that 0 and we do preallocation */

			list_add(&REISERFS_I(hint->inode)->i_prealloc_list,

		     &SB_JOURNAL(hint->th->t_super)->j_prealloc_list);

				 &SB_JOURNAL(hint->th->t_super)->

				 j_prealloc_list);

			REISERFS_I(hint->inode)->i_prealloc_block = start;

	    REISERFS_I(hint->inode)->i_prealloc_count = nr_allocated;

			REISERFS_I(hint->inode)->i_prealloc_count =

			    nr_allocated;

			break;

		}

	}
@@ -944,8 +1013,8 @@ static inline int allocate_without_wrapping_disk (reiserfs_blocknr_hint_t * hint 
}



static inline int blocknrs_and_prealloc_arrays_from_search_start

    (reiserfs_blocknr_hint_t *hint, b_blocknr_t *new_blocknrs, int amount_needed)

{

    (reiserfs_blocknr_hint_t * hint, b_blocknr_t * new_blocknrs,

     int amount_needed) {

	struct super_block *s = hint->th->t_super;

	b_blocknr_t start = hint->search_start;

	b_blocknr_t finish = SB_BLOCK_COUNT(s) - 1;
@@ -957,16 +1026,23 @@ static inline int blocknrs_and_prealloc_arrays_from_search_start 
	if (!hint->formatted_node) {

		int quota_ret;

#ifdef REISERQUOTA_DEBUG

	reiserfs_debug (s, REISERFS_DEBUG_CODE, "reiserquota: allocating %d blocks id=%u", amount_needed, hint->inode->i_uid);

		reiserfs_debug(s, REISERFS_DEBUG_CODE,

			       "reiserquota: allocating %d blocks id=%u",

			       amount_needed, hint->inode->i_uid);

#endif

	quota_ret = DQUOT_ALLOC_BLOCK_NODIRTY(hint->inode, amount_needed);

		quota_ret =

		    DQUOT_ALLOC_BLOCK_NODIRTY(hint->inode, amount_needed);

		if (quota_ret)	/* Quota exceeded? */

			return QUOTA_EXCEEDED;

		if (hint->preallocate && hint->prealloc_size) {

#ifdef REISERQUOTA_DEBUG

	    reiserfs_debug (s, REISERFS_DEBUG_CODE, "reiserquota: allocating (prealloc) %d blocks id=%u", hint->prealloc_size, hint->inode->i_uid);

			reiserfs_debug(s, REISERFS_DEBUG_CODE,

				       "reiserquota: allocating (prealloc) %d blocks id=%u",

				       hint->prealloc_size, hint->inode->i_uid);

#endif

	    quota_ret = DQUOT_PREALLOC_BLOCK_NODIRTY(hint->inode, hint->prealloc_size);

			quota_ret =

			    DQUOT_PREALLOC_BLOCK_NODIRTY(hint->inode,

							 hint->prealloc_size);

			if (quota_ret)

				hint->preallocate = hint->prealloc_size = 0;

		}
@@ -1010,31 +1086,49 @@ static inline int blocknrs_and_prealloc_arrays_from_search_start 
			/* Free the blocks */

			if (!hint->formatted_node) {

#ifdef REISERQUOTA_DEBUG

		reiserfs_debug (s, REISERFS_DEBUG_CODE, "reiserquota: freeing (nospace) %d blocks id=%u", amount_needed + hint->prealloc_size - nr_allocated, hint->inode->i_uid);

				reiserfs_debug(s, REISERFS_DEBUG_CODE,

					       "reiserquota: freeing (nospace) %d blocks id=%u",

					       amount_needed +

					       hint->prealloc_size -

					       nr_allocated,

					       hint->inode->i_uid);

#endif

				DQUOT_FREE_BLOCK_NODIRTY(hint->inode, amount_needed + hint->prealloc_size - nr_allocated);	/* Free not allocated blocks */

			}

			while (nr_allocated--)

		reiserfs_free_block(hint->th, hint->inode, new_blocknrs[nr_allocated], !hint->formatted_node);

				reiserfs_free_block(hint->th, hint->inode,

						    new_blocknrs[nr_allocated],

						    !hint->formatted_node);



			return NO_DISK_SPACE;

		}

	} while ((nr_allocated += allocate_without_wrapping_disk(hint,

			    new_blocknrs + nr_allocated, start, finish,

			    bigalloc ? bigalloc : 1,

			    amount_needed - nr_allocated,

			    hint->prealloc_size))

								 new_blocknrs +

								 nr_allocated,

								 start, finish,

								 bigalloc ?

								 bigalloc : 1,

								 amount_needed -

								 nr_allocated,

								 hint->

								 prealloc_size))

		 < amount_needed);

	if (!hint->formatted_node &&

	    amount_needed + hint->prealloc_size >

	    nr_allocated + REISERFS_I(hint->inode)->i_prealloc_count) {

		/* Some of preallocation blocks were not allocated */

#ifdef REISERQUOTA_DEBUG

	reiserfs_debug (s, REISERFS_DEBUG_CODE, "reiserquota: freeing (failed prealloc) %d blocks id=%u", amount_needed + hint->prealloc_size - nr_allocated - REISERFS_I(hint->inode)->i_prealloc_count, hint->inode->i_uid);

		reiserfs_debug(s, REISERFS_DEBUG_CODE,

			       "reiserquota: freeing (failed prealloc) %d blocks id=%u",

			       amount_needed + hint->prealloc_size -

			       nr_allocated -

			       REISERFS_I(hint->inode)->i_prealloc_count,

			       hint->inode->i_uid);

#endif

		DQUOT_FREE_BLOCK_NODIRTY(hint->inode, amount_needed +

					 hint->prealloc_size - nr_allocated -

				 REISERFS_I(hint->inode)->i_prealloc_count);

					 REISERFS_I(hint->inode)->

					 i_prealloc_count);

	}



	return CARRY_ON;
@@ -1043,7 +1137,8 @@ static inline int blocknrs_and_prealloc_arrays_from_search_start 
/* grab new blocknrs from preallocated list */

/* return amount still needed after using them */

static int use_preallocated_list_if_available(reiserfs_blocknr_hint_t * hint,

					       b_blocknr_t *new_blocknrs, int amount_needed)

					      b_blocknr_t * new_blocknrs,

					      int amount_needed)

{

	struct inode *inode = hint->inode;
@@ -1065,9 +1160,7 @@ static int use_preallocated_list_if_available (reiserfs_blocknr_hint_t *hint, 
	return amount_needed;

}



int reiserfs_allocate_blocknrs(reiserfs_blocknr_hint_t *hint,

			       b_blocknr_t * new_blocknrs, int amount_needed,

			       int reserved_by_us /* Amount of blocks we have

int reiserfs_allocate_blocknrs(reiserfs_blocknr_hint_t * hint, b_blocknr_t * new_blocknrs, int amount_needed, int reserved_by_us	/* Amount of blocks we have

																	   already reserved */ )

{

	int initial_amount_needed = amount_needed;
@@ -1108,7 +1201,8 @@ int reiserfs_allocate_blocknrs(reiserfs_blocknr_hint_t *hint, 


	if (ret != CARRY_ON) {

		while (amount_needed++ < initial_amount_needed) {

	    reiserfs_free_block(hint->th, hint->inode, *(--new_blocknrs), 1);

			reiserfs_free_block(hint->th, hint->inode,

					    *(--new_blocknrs), 1);

		}

	}

	return ret;
@@ -1117,8 +1211,7 @@ int reiserfs_allocate_blocknrs(reiserfs_blocknr_hint_t *hint, 
/* These 2 functions are here to provide blocks reservation to the rest of kernel */

/* Reserve @blocks amount of blocks in fs pointed by @sb. Caller must make sure

   there are actually this much blocks on the FS available */

void reiserfs_claim_blocks_to_be_allocated( 

				      struct super_block *sb, /* super block of

void reiserfs_claim_blocks_to_be_allocated(struct super_block *sb,	/* super block of

									   filesystem where

									   blocks should be

									   reserved */
@@ -1136,8 +1229,7 @@ void reiserfs_claim_blocks_to_be_allocated( 
}



/* Unreserve @blocks amount of blocks in fs pointed by @sb */

void reiserfs_release_claimed_blocks( 

				struct super_block *sb, /* super block of

void reiserfs_release_claimed_blocks(struct super_block *sb,	/* super block of

								   filesystem where

								   blocks should be

								   reserved */
@@ -1152,7 +1244,8 @@ void reiserfs_release_claimed_blocks( 
	spin_lock(&REISERFS_SB(sb)->bitmap_lock);

	REISERFS_SB(sb)->reserved_blocks -= blocks;

	spin_unlock(&REISERFS_SB(sb)->bitmap_lock);

    RFALSE( REISERFS_SB(sb)->reserved_blocks < 0, "amount of blocks reserved became zero?");

	RFALSE(REISERFS_SB(sb)->reserved_blocks < 0,

	       "amount of blocks reserved became zero?");

}



/* This function estimates how much pages we will be able to write to FS
@@ -1163,7 +1256,10 @@ int reiserfs_can_fit_pages ( struct super_block *sb /* superblock of filesystem 
	int space;



	spin_lock(&REISERFS_SB(sb)->bitmap_lock);

	space = (SB_FREE_BLOCKS(sb) - REISERFS_SB(sb)->reserved_blocks) >> ( PAGE_CACHE_SHIFT - sb->s_blocksize_bits);

	space =

	    (SB_FREE_BLOCKS(sb) -

	     REISERFS_SB(sb)->reserved_blocks) >> (PAGE_CACHE_SHIFT -

						   sb->s_blocksize_bits);

	spin_unlock(&REISERFS_SB(sb)->bitmap_lock);



	return space > 0 ? space : 0;

fs/reiserfs/dir.c

+255 −233

File changed.

Preview size limit exceeded, changes collapsed.

fs/reiserfs/do_balan.c

+1888 −1348

File changed.

Preview size limit exceeded, changes collapsed.

fs/reiserfs/file.c

+1362 −1202

File changed.

Preview size limit exceeded, changes collapsed.

fs/reiserfs/fix_node.c

+2079 −1972

File changed.

Preview size limit exceeded, changes collapsed.