reiserfs: cleanup, reformat comments to normal kernel style

				   unsigned int *bmap_nr,

				   unsigned int *offset)

{

	/* It is in the bitmap block number equal to the block

	 * number divided by the number of bits in a block. */

	/*

	 * It is in the bitmap block number equal to the block

	 * number divided by the number of bits in a block.

	 */

	*bmap_nr = block >> (s->s_blocksize_bits + 3);

	/* Within that bitmap block it is located at bit offset *offset. */

	*offset = block & ((s->s_blocksize << 3) - 1);

	get_bit_address(s, block, &bmap, &offset);

	/* Old format filesystem? Unlikely, but the bitmaps are all up front so

	 * we need to account for it. */

	/*

	 * Old format filesystem? Unlikely, but the bitmaps are all

	 * up front so we need to account for it.

	 */

	if (unlikely(test_bit(REISERFS_OLD_FORMAT,

			      &(REISERFS_SB(s)->s_properties)))) {

		b_blocknr_t bmap1 = REISERFS_SB(s)->s_sbh->b_blocknr + 1;

	return 1;

}

/* searches in journal structures for a given block number (bmap, off). If block

   is found in reiserfs journal it suggests next free block candidate to test. */

/*

 * Searches in journal structures for a given block number (bmap, off).

 * If block is found in reiserfs journal it suggests next free block

 * candidate to test.

 */

static inline int is_block_in_journal(struct super_block *s, unsigned int bmap,

				      int off, int *next)

{

	return 0;

}

/* it searches for a window of zero bits with given minimum and maximum lengths in one bitmap

 * block; */

/*

 * 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,

			     unsigned int bmap_n, int *beg, int boundary,

			     int min, int max, int unfm)

	RFALSE(bmap_n >= reiserfs_bmap_count(s), "Bitmap %u is out of "

	       "range (0..%u)", bmap_n, reiserfs_bmap_count(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

   is a window? */

/* - I mean `a window of zero bits' as in description of this function - Zam. */

	if (!bi) {

		reiserfs_error(s, "jdm-4055", "NULL bitmap info pointer "

	      cont:

		if (bi->free_count < min) {

			brelse(bh);

			return 0;	// No free blocks in this bitmap

			return 0;	/* No free blocks in this bitmap */

		}

		/* search for a first zero bit -- beginning of a window */

		*beg = reiserfs_find_next_zero_le_bit

		    ((unsigned long *)(bh->b_data), boundary, *beg);

		if (*beg + min > boundary) {	/* search for a zero bit fails or the rest of bitmap block

						 * cannot contain a zero window of minimum size */

		/*

		 * search for a zero bit fails or the rest of bitmap block

		 * cannot contain a zero window of minimum size

		 */

		if (*beg + min > boundary) {

			brelse(bh);

			return 0;

		}

				next = end;

				break;

			}

			/* finding the other end of zero bit window requires looking into journal structures (in

			 * case of searching for free blocks for unformatted nodes) */

			/*

			 * finding the other end of zero bit window requires

			 * looking into journal structures (in case of

			 * searching for free blocks for unformatted nodes)

			 */

			if (unfm && is_block_in_journal(s, bmap_n, end, &next))

				break;

		}

		/* now (*beg) points to beginning of zero bits window,

		 * (end) points to one bit after the window end */

		if (end - *beg >= min) {	/* it seems we have found window of proper size */

		/*

		 * now (*beg) points to beginning of zero bits window,

		 * (end) points to one bit after the window end

		 */

		/* found window of proper size */

		if (end - *beg >= min) {

			int i;

			reiserfs_prepare_for_journal(s, bh, 1);

			/* try to set all blocks used checking are they still free */

			/*

			 * 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. */

				/* Don't check in journal again. */

				if (reiserfs_test_and_set_le_bit

				    (i, bh->b_data)) {

					/* bit was set by another process

					 * while we slept in prepare_for_journal() */

					/*

					 * bit was set by another process while

					 * we slept in prepare_for_journal()

					 */

					PROC_INFO_INC(s, scan_bitmap.stolen);

					if (i >= *beg + min) {	/* we can continue with smaller set of allocated blocks,

								 * if length of this set is more or equal to `min' */

					/*

					 * we can continue with smaller set

					 * of allocated blocks, if length of

					 * this set is more or equal to `min'

					 */

					if (i >= *beg + min) {

						end = i;

						break;

					}

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

					/*

					 * otherwise we clear all bit

					 * were set ...

					 */

					while (--i >= *beg)

						reiserfs_clear_le_bit

						    (i, bh->b_data);

					reiserfs_restore_prepared_buffer(s, bh);

					*beg = org;

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

					/*

					 * Search again in current block

					 * from beginning

					 */

					goto cont;

				}

			}

	int bm = bmap_hash_id(s, id);

	struct reiserfs_bitmap_info *info = &SB_AP_BITMAP(s)[bm];

	/* If we don't have cached information on this bitmap block, we're

	/*

	 * If we don't have cached information on this bitmap block, we're

	 * going to have to load it later anyway. Loading it here allows us

	 * to make a better decision. This favors long-term performance gain

	 * with a better on-disk layout vs. a short term gain of skipping the

	 * read and potentially having a bad placement. */

	 * read and potentially having a bad placement.

	 */

	if (info->free_count == UINT_MAX) {

		struct buffer_head *bh = reiserfs_read_bitmap_block(s, bm);

		brelse(bh);

	return packing;

}

/* Tries to find contiguous zero bit window (given size) in given region of

 * bitmap and place new blocks there. Returns number of allocated blocks. */

/*

 * Tries to find contiguous zero bit window (given size) in given region of

 * bitmap and place new blocks there. Returns number of allocated blocks.

 */

static int scan_bitmap(struct reiserfs_transaction_handle *th,

		       b_blocknr_t * start, b_blocknr_t finish,

		       int min, int max, int unfm, sector_t file_block)

{

	int nr_allocated = 0;

	struct super_block *s = th->t_super;

	/* find every bm and bmap and bmap_nr in this file, and change them all to bitmap_blocknr

	 * - Hans, it is not a block number - Zam. */

	unsigned int bm, off;

	unsigned int end_bm, end_off;

	unsigned int off_max = s->s_blocksize << 3;

	BUG_ON(!th->t_trans_id);

	PROC_INFO_INC(s, scan_bitmap.call);

	/* No point in looking for more free blocks */

	if (SB_FREE_BLOCKS(s) <= 0)

		return 0;	// No point in looking for more free blocks

		return 0;

	get_bit_address(s, *start, &bm, &off);

	get_bit_address(s, finish, &end_bm, &end_off);

	if (end_bm > reiserfs_bmap_count(s))

		end_bm = reiserfs_bmap_count(s);

	/* When the bitmap is more than 10% free, anyone can allocate.

	/*

	 * When the bitmap is more than 10% free, anyone can allocate.

	 * When it's less than 10% free, only files that already use the

	 * bitmap are allowed. Once we pass 80% full, this restriction

	 * is lifted.

{

	char *this_char, *value;

	REISERFS_SB(s)->s_alloc_options.bits = 0;	/* clear default settings */

	/* clear default settings */

	REISERFS_SB(s)->s_alloc_options.bits = 0;

	while ((this_char = strsep(&options, ":")) != NULL) {

		if ((value = strchr(this_char, '=')) != NULL)

		hash_in = (char *)&hint->key.k_dir_id;

	} else {

		if (!hint->inode) {

			//hint->search_start = hint->beg;

			/*hint->search_start = hint->beg;*/

			hash_in = (char *)&hint->key.k_dir_id;

		} else

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

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

		/* keep the root dir and it's first set of subdirs close to

		/*

		 * keep the root dir and it's first set of subdirs close to

		 * the start of the disk

		 */

		if (dirid <= 2)

	}

}

/* returns 1 if it finds an indirect item and gets valid hint info

/*

 * returns 1 if it finds an indirect item and gets valid hint info

 * from it, otherwise 0

 */

static int get_left_neighbor(reiserfs_blocknr_hint_t * hint)

	__le32 *item;

	int ret = 0;

	if (!hint->path)	/* reiserfs code can call this function w/o pointer to path

				 * structure supplied; then we rely on supplied search_start */

	/*

	 * reiserfs code can call this function w/o pointer to path

	 * structure supplied; then we rely on supplied search_start

	 */

	if (!hint->path)

		return 0;

	path = hint->path;

	hint->search_start = bh->b_blocknr;

	/*

	 * for indirect item: go to left and look for the first non-hole entry

	 * in the indirect item

	 */

	if (!hint->formatted_node && is_indirect_le_ih(ih)) {

		/* for indirect item: go to left and look for the first non-hole entry

		   in the indirect item */

		if (pos_in_item == I_UNFM_NUM(ih))

			pos_in_item--;

//          pos_in_item = I_UNFM_NUM (ih) - 1;

		while (pos_in_item >= 0) {

			int t = get_block_num(item, pos_in_item);

			if (t) {

	return ret;

}

/* should be, if formatted node, then try to put on first part of the device

   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.  */

/*

 * should be, if formatted node, then try to put on first part of the device

 * 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)

{

		set_border_in_hint(s, hint);

#ifdef DISPLACE_NEW_PACKING_LOCALITIES

	/* whenever we create a new directory, we displace it.  At first we will

	   hash for location, later we might look for a moderately empty place for

	   it */

	/*

	 * whenever we create a new directory, we displace it.  At first

	 * we will hash for location, later we might look for a moderately

	 * empty place for it

	 */

	if (displacing_new_packing_localities(s)

	    && hint->th->displace_new_blocks) {

		displace_new_packing_locality(hint);

		/* we do not continue determine_search_start,

		 * if new packing locality is being displaced */

		/*

		 * we do not continue determine_search_start,

		 * if new packing locality is being displaced

		 */

		return;

	}

#endif

	/* all persons should feel encouraged to add more special cases here and

	 * test them */

	/*

	 * all persons should feel encouraged to add more special cases

	 * here and test them

	 */

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

	    && this_blocknr_allocation_would_make_it_a_large_file(hint)) {

		return;

	}

	/* if none of our special cases is relevant, use the left neighbor in the

	   tree order of the new node we are allocating for */

	/*

	 * if none of our special cases is relevant, use the left

	 * neighbor in the tree order of the new node we are allocating for

	 */

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

		hash_formatted_node(hint);

		return;

	unfm_hint = get_left_neighbor(hint);

	/* Mimic old block allocator behaviour, that is if VFS allowed for preallocation,

	   new blocks are displaced based on directory ID. Also, if suggested search_start

	   is less than last preallocated block, we start searching from it, assuming that

	   HDD dataflow is faster in forward direction */

	/*

	 * Mimic old block allocator behaviour, that is if VFS allowed for

	 * preallocation, new blocks are displaced based on directory ID.

	 * Also, if suggested search_start is less than last preallocated

	 * block, we start searching from it, assuming that HDD dataflow

	 * is faster in forward direction

	 */

	if (TEST_OPTION(old_way, s)) {

		if (!hint->formatted_node) {

			if (!reiserfs_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)) {

		new_hashed_relocation(hint);

	}

	/* dirid grouping works only on unformatted nodes */

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

		dirid_groups(hint);

	return CARRY_ON;

}

/* XXX I know it could be merged with upper-level function;

   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,

		/* 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 */

			/*

			 * 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);

			start = 0;

			finish = hint->beg;

			break;

		default:	/* We've tried searching everywhere, not enough space */

		default:

			/* We've tried searching everywhere, not enough space */

			/* Free the blocks */

			if (!hint->formatted_node) {

#ifdef REISERQUOTA_DEBUG

	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

																	   already reserved */ )

int reiserfs_allocate_blocknrs(reiserfs_blocknr_hint_t *hint,

			       b_blocknr_t *new_blocknrs,

			       int amount_needed,

			       /* Amount of blocks we have already reserved */

			       int reserved_by_us)

{

	int initial_amount_needed = amount_needed;

	int ret;

		return NO_DISK_SPACE;

	/* should this be if !hint->inode &&  hint->preallocate? */

	/* do you mean hint->formatted_node can be removed ? - Zam */

	/* hint->formatted_node cannot be removed because we try to access

	   inode information here, and there is often no inode assotiated with

	   metadata allocations - green */

	/*

	 * hint->formatted_node cannot be removed because we try to access

	 * inode information here, and there is often no inode associated with

	 * metadata allocations - green

	 */

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

		amount_needed = use_preallocated_list_if_available

		    (hint, new_blocknrs, amount_needed);

		if (amount_needed == 0)	/* all blocknrs we need we got from

					   prealloc. list */

		/*

		 * We have all the block numbers we need from the

		 * prealloc list

		 */

		if (amount_needed == 0)

			return CARRY_ON;

		new_blocknrs += (initial_amount_needed - amount_needed);

	}

	ret = blocknrs_and_prealloc_arrays_from_search_start

	    (hint, new_blocknrs, amount_needed);

	/* we used prealloc. list to fill (partially) new_blocknrs array. If final allocation fails we

	 * need to return blocks back to prealloc. list or just free them. -- Zam (I chose second

	 * variant) */

	/*

	 * We used prealloc. list to fill (partially) new_blocknrs array.

	 * If final allocation fails we need to return blocks back to

	 * prealloc. list or just free them. -- Zam (I chose second

	 * variant)

	 */

	if (ret != CARRY_ON) {

		while (amount_needed++ < initial_amount_needed) {

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

	struct reiserfs_bitmap_info *info = SB_AP_BITMAP(sb) + bitmap;

	struct buffer_head *bh;

	/* Way old format filesystems had the bitmaps packed up front.

	 * I doubt there are any of these left, but just in case... */

	/*

	 * Way old format filesystems had the bitmaps packed up front.

	 * I doubt there are any of these left, but just in case...

	 */

	if (unlikely(test_bit(REISERFS_OLD_FORMAT,

	                      &(REISERFS_SB(sb)->s_properties))))

		block = REISERFS_SB(sb)->s_sbh->b_blocknr + 1 + bitmap;

int reiserfs_readdir_inode(struct inode *inode, struct dir_context *ctx)

{

	struct cpu_key pos_key;	/* key of current position in the directory (key of directory entry) */

	/* key of current position in the directory (key of directory entry) */

	struct cpu_key pos_key;

	INITIALIZE_PATH(path_to_entry);

	struct buffer_head *bh;

	int item_num, entry_num;

	reiserfs_check_lock_depth(inode->i_sb, "readdir");

	/* form key for search the next directory entry using f_pos field of

	   file structure */

	/*

	 * form key for search the next directory entry using

	 * f_pos field of file structure

	 */

	make_cpu_key(&pos_key, inode, ctx->pos ?: DOT_OFFSET, TYPE_DIRENTRY, 3);

	next_pos = cpu_key_k_offset(&pos_key);

	path_to_entry.reada = PATH_READA;

	while (1) {

	      research:

		/* search the directory item, containing entry with specified key */

		/*

		 * search the directory item, containing entry with

		 * specified key

		 */

		search_res =

		    search_by_entry_key(inode->i_sb, &pos_key, &path_to_entry,

					&de);

		if (search_res == IO_ERROR) {

			// FIXME: we could just skip part of directory which could

			// not be read

			/*

			 * FIXME: we could just skip part of directory

			 * which could not be read

			 */

			ret = -EIO;

			goto out;

		}

		       "vs-9005 item_num == %d, item amount == %d",

		       item_num, B_NR_ITEMS(bh));

		/* and entry must be not more than number of entries in the item */

		/*

		 * and entry must be not more than number of entries

		 * in the item

		 */

		RFALSE(ih_entry_count(ih) < entry_num,

		       "vs-9010: entry number is too big %d (%d)",

		       entry_num, ih_entry_count(ih));

		/*

		 * go through all entries in the directory item beginning

		 * from the entry, that has been found

		 */

		if (search_res == POSITION_FOUND

		    || entry_num < ih_entry_count(ih)) {

			/* go through all entries in the directory item beginning from the entry, that has been found */

			struct reiserfs_de_head *deh =

			    B_I_DEH(bh, ih) + entry_num;

				ino_t d_ino;

				loff_t cur_pos = deh_offset(deh);

				if (!de_visible(deh))

				/* it is hidden entry */

				if (!de_visible(deh))

					continue;

				d_reclen = entry_length(bh, ih, entry_num);

				d_name = B_I_DEH_ENTRY_FILE_NAME(bh, ih, deh);

				if (d_reclen <= 0 ||

				    d_name + d_reclen > bh->b_data + bh->b_size) {

					/* There is corrupted data in entry,

					 * We'd better stop here */

					/*

					 * There is corrupted data in entry,

					 * We'd better stop here

					 */

					pathrelse(&path_to_entry);

					ret = -EIO;

					goto out;

				if (!d_name[d_reclen - 1])

					d_reclen = strlen(d_name);

				/* too big to send back to VFS */

				if (d_reclen >

				    REISERFS_MAX_NAME(inode->i_sb->

						      s_blocksize)) {

					/* too big to send back to VFS */

					continue;

				}

						goto research;

					}

				}

				// Note, that we copy name to user space via temporary

				// buffer (local_buf) because filldir will block if

				// user space buffer is swapped out. At that time

				// entry can move to somewhere else

				/*

				 * Note, that we copy name to user space via

				 * temporary buffer (local_buf) because

				 * filldir will block if user space buffer is

				 * swapped out. At that time entry can move to

				 * somewhere else

				 */

				memcpy(local_buf, d_name, d_reclen);

				/*

			}	/* for */

		}

		/* end of directory has been reached */

		if (item_num != B_NR_ITEMS(bh) - 1)

			// end of directory has been reached

			goto end;

		/* item we went through is last item of node. Using right

		   delimiting key check is it directory end */

		/*

		 * item we went through is last item of node. Using right

		 * delimiting key check is it directory end

		 */

		rkey = get_rkey(&path_to_entry, inode->i_sb);

		if (!comp_le_keys(rkey, &MIN_KEY)) {

			/* set pos_key to key, that is the smallest and greater

			   that key of the last entry in the item */

			/*

			 * set pos_key to key, that is the smallest and greater

			 * that key of the last entry in the item

			 */

			set_cpu_key_k_offset(&pos_key, next_pos);

			continue;

		}

		/* end of directory has been reached */

		if (COMP_SHORT_KEYS(rkey, &pos_key)) {

			// end of directory has been reached

			goto end;

		}

	return reiserfs_readdir_inode(file_inode(file), ctx);

}

/* compose directory item containing "." and ".." entries (entries are

   not aligned to 4 byte boundary) */

/* the last four params are LE */

/*

 * compose directory item containing "." and ".." entries (entries are

 * not aligned to 4 byte boundary)

 */

void make_empty_dir_item_v1(char *body, __le32 dirid, __le32 objid,

			    __le32 par_dirid, __le32 par_objid)

{

#include <linux/quotaops.h>

/*

** We pack the tails of files on file close, not at the time they are written.

** This implies an unnecessary copy of the tail and an unnecessary indirect item

** insertion/balancing, for files that are written in one write.

** It avoids unnecessary tail packings (balances) for files that are written in

** multiple writes and are small enough to have tails.

**

** file_release is called by the VFS layer when the file is closed.  If

** this is the last open file descriptor, and the file

** small enough to have a tail, and the tail is currently in an

** unformatted node, the tail is converted back into a direct item.

**

** We use reiserfs_truncate_file to pack the tail, since it already has

** all the conditions coded.

 * We pack the tails of files on file close, not at the time they are written.

 * This implies an unnecessary copy of the tail and an unnecessary indirect item

 * insertion/balancing, for files that are written in one write.

 * It avoids unnecessary tail packings (balances) for files that are written in

 * multiple writes and are small enough to have tails.

 *

 * file_release is called by the VFS layer when the file is closed.  If

 * this is the last open file descriptor, and the file

 * small enough to have a tail, and the tail is currently in an

 * unformatted node, the tail is converted back into a direct item.

 *

 * We use reiserfs_truncate_file to pack the tail, since it already has

 * all the conditions coded.

 */

static int reiserfs_file_release(struct inode *inode, struct file *filp)

{

	}

	reiserfs_write_lock(inode->i_sb);

	/* freeing preallocation only involves relogging blocks that

	/*

	 * freeing preallocation only involves relogging blocks that

	 * are already in the current transaction.  preallocation gets

	 * freed at the end of each transaction, so it is impossible for

	 * us to log any additional blocks (including quota blocks)

	 */

	err = journal_begin(&th, inode->i_sb, 1);

	if (err) {

		/* uh oh, we can't allow the inode to go away while there

		/*

		 * uh oh, we can't allow the inode to go away while there

		 * is still preallocation blocks pending.  Try to join the

		 * aborted transaction

		 */

		err = journal_join_abort(&th, inode->i_sb, 1);

		if (err) {

			/* hmpf, our choices here aren't good.  We can pin the inode

			 * which will disallow unmount from every happening, we can

			 * do nothing, which will corrupt random memory on unmount,

			 * or we can forcibly remove the file from the preallocation

			 * list, which will leak blocks on disk.  Lets pin the inode

			/*