Merge branch 'for_linus' of git://git.kernel.org/pub/scm/linux/kernel/git/jack/linux-fs (2840c566) · Commits · e / devices / android_kernel_xiaomi_markw

fs/ext3/inode.c

+17 −16

Original line number	Diff line number	Diff line
		@@ -1716,17 +1716,17 @@ static int ext3_journalled_writepage(struct page *page,
		WARN_ON_ONCE(IS_RDONLY(inode) &&
		!(EXT3_SB(inode->i_sb)->s_mount_state & EXT3_ERROR_FS));

		trace_ext3_journalled_writepage(page);
		if (!page_has_buffers(page) \|\| PageChecked(page)) {
		if (ext3_journal_current_handle())
		goto no_write;

		trace_ext3_journalled_writepage(page);
		handle = ext3_journal_start(inode, ext3_writepage_trans_blocks(inode));
		handle = ext3_journal_start(inode,
		ext3_writepage_trans_blocks(inode));
		if (IS_ERR(handle)) {
		ret = PTR_ERR(handle);
		goto no_write;
		}

		if (!page_has_buffers(page) \|\| PageChecked(page)) {
		/*
		* It's mmapped pagecache. Add buffers and journal it. There
		* doesn't seem much point in redirtying the page here.
		@@ -1749,17 +1749,18 @@ static int ext3_journalled_writepage(struct page *page,
		atomic_set(&EXT3_I(inode)->i_datasync_tid,
		handle->h_transaction->t_tid);
		unlock_page(page);
		err = ext3_journal_stop(handle);
		if (!ret)
		ret = err;
		} else {
		/*
		* It may be a page full of checkpoint-mode buffers. We don't
		* really know unless we go poke around in the buffer_heads.
		* But block_write_full_page will do the right thing.
		* It is a page full of checkpoint-mode buffers. Go and write
		* them. They should have been already mapped when they went
		* to the journal so provide NULL get_block function to catch
		* errors.
		*/
		ret = block_write_full_page(page, ext3_get_block, wbc);
		ret = block_write_full_page(page, NULL, wbc);
		}
		err = ext3_journal_stop(handle);
		if (!ret)
		ret = err;
		out:
		return ret;

fs/jbd/revoke.c

+4 −8

Original line number	Diff line number	Diff line
		@@ -231,19 +231,15 @@ record_cache_failure:

		static struct jbd_revoke_table_s *journal_init_revoke_table(int hash_size)
		{
		int shift = 0;
		int tmp = hash_size;
		int i;
		struct jbd_revoke_table_s *table;

		table = kmem_cache_alloc(revoke_table_cache, GFP_KERNEL);
		if (!table)
		goto out;

		while((tmp >>= 1UL) != 0UL)
		shift++;

		table->hash_size = hash_size;
		table->hash_shift = shift;
		table->hash_shift = ilog2(hash_size);
		table->hash_table =
		kmalloc(hash_size * sizeof(struct list_head), GFP_KERNEL);
		if (!table->hash_table) {
		@@ -252,8 +248,8 @@ static struct jbd_revoke_table_s *journal_init_revoke_table(int hash_size)
		goto out;
		}

		for (tmp = 0; tmp < hash_size; tmp++)
		INIT_LIST_HEAD(&table->hash_table[tmp]);
		for (i = 0; i < hash_size; i++)
		INIT_LIST_HEAD(&table->hash_table[i]);

		out:
		return table;

fs/reiserfs/bitmap.c

+167 −92

Original line number	Diff line number	Diff line
		@@ -50,8 +50,10 @@ static inline void get_bit_address(struct super_block *s,
		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);
		@@ -71,10 +73,12 @@ int is_reusable(struct super_block *s, b_blocknr_t block, int bit_value)

		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)))) {
		&REISERFS_SB(s)->s_properties))) {
		b_blocknr_t bmap1 = REISERFS_SB(s)->s_sbh->b_blocknr + 1;
		if (block >= bmap1 &&
		block <= bmap1 + bmap_count) {
		@@ -108,8 +112,11 @@ int is_reusable(struct super_block *s, b_blocknr_t block, int bit_value)
		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)
		{
		@@ -129,8 +136,10 @@ static inline int is_block_in_journal(struct super_block *s, unsigned int bmap,
		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)
		@@ -145,10 +154,6 @@ static int scan_bitmap_block(struct reiserfs_transaction_handle *th,
		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 "
		@@ -164,15 +169,18 @@ static int scan_bitmap_block(struct reiserfs_transaction_handle *th,
		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;
		}
		@@ -186,49 +194,75 @@ static int scan_bitmap_block(struct reiserfs_transaction_handle *th,
		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;
		}
		}
		bi->free_count -= (end - *beg);
		journal_mark_dirty(th, s, bh);
		journal_mark_dirty(th, bh);
		brelse(bh);

		/* free block count calculation */
		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));
		journal_mark_dirty(th, SB_BUFFER_WITH_SB(s));

		return end - (*beg);
		} else {
		@@ -267,11 +301,13 @@ static inline int block_group_used(struct super_block *s, u32 id)
		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);
		@@ -304,25 +340,26 @@ __le32 reiserfs_choose_packing(struct inode * dir)
		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);
		@@ -331,7 +368,8 @@ static int scan_bitmap(struct reiserfs_transaction_handle *th,
		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.
		@@ -411,14 +449,14 @@ static void _reiserfs_free_block(struct reiserfs_transaction_handle *th,
		"block %lu: bit already cleared", block);
		}
		apbi[nr].free_count++;
		journal_mark_dirty(th, s, bmbh);
		journal_mark_dirty(th, bmbh);
		brelse(bmbh);

		reiserfs_prepare_for_journal(s, sbh, 1);
		/* update super block */
		set_sb_free_blocks(rs, sb_free_blocks(rs) + 1);

		journal_mark_dirty(th, s, sbh);
		journal_mark_dirty(th, sbh);
		if (for_unformatted) {
		int depth = reiserfs_write_unlock_nested(s);
		dquot_free_block_nodirty(inode, 1);
		@@ -483,7 +521,7 @@ static void __discard_prealloc(struct reiserfs_transaction_handle *th,
		if (dirty)
		reiserfs_update_sd(th, inode);
		ei->i_prealloc_block = save;
		list_del_init(&(ei->i_prealloc_list));
		list_del_init(&ei->i_prealloc_list);
		}

		/* FIXME: It should be inline function */
		@@ -529,7 +567,8 @@ int reiserfs_parse_alloc_options(struct super_block s, char options)
		{
		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)
		@@ -731,7 +770,7 @@ static inline void new_hashed_relocation(reiserfs_blocknr_hint_t * hint)
		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))
		@@ -785,7 +824,8 @@ static void oid_groups(reiserfs_blocknr_hint_t * hint)

		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)
		@@ -799,7 +839,8 @@ static void oid_groups(reiserfs_blocknr_hint_t * hint)
		}
		}

		/* 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)
		@@ -811,25 +852,29 @@ 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;
		bh = get_last_bh(path);
		RFALSE(!bh, "green-4002: Illegal path specified to get_left_neighbor");
		ih = get_ih(path);
		ih = tp_item_head(path);
		pos_in_item = path->pos_in_item;
		item = get_item(path);
		item = tp_item_body(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) {
		@@ -845,10 +890,12 @@ static int get_left_neighbor(reiserfs_blocknr_hint_t * hint)
		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)
		{
		@@ -974,21 +1021,27 @@ static void determine_search_start(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)) {
		@@ -996,8 +1049,10 @@ static void determine_search_start(reiserfs_blocknr_hint_t * 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;
		@@ -1005,10 +1060,13 @@ static void determine_search_start(reiserfs_blocknr_hint_t * hint,

		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))
		@@ -1037,11 +1095,13 @@ static void determine_search_start(reiserfs_blocknr_hint_t * hint,
		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);
		@@ -1079,8 +1139,6 @@ static int determine_prealloc_size(reiserfs_blocknr_hint_t * 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,
		@@ -1108,7 +1166,10 @@ static inline int allocate_without_wrapping_disk(reiserfs_blocknr_hint_t * hint,

		/* 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);
		@@ -1176,7 +1237,8 @@ static inline int blocknrs_and_prealloc_arrays_from_search_start
		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
		@@ -1261,8 +1323,11 @@ 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
		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;
		@@ -1274,15 +1339,21 @@ int reiserfs_allocate_blocknrs(reiserfs_blocknr_hint_t * hint, b_blocknr_t * new
		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);
		}
		@@ -1296,10 +1367,12 @@ int reiserfs_allocate_blocknrs(reiserfs_blocknr_hint_t * hint, b_blocknr_t * new
		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,
		@@ -1338,10 +1411,12 @@ struct buffer_head reiserfs_read_bitmap_block(struct super_block sb,
		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))))
		&REISERFS_SB(sb)->s_properties)))
		block = REISERFS_SB(sb)->s_sbh->b_blocknr + 1 + bitmap;
		else if (bitmap == 0)
		block = (REISERFS_DISK_OFFSET_IN_BYTES >> sb->s_blocksize_bits) + 1;