Merge branch 'for-linus' of git://oss.sgi.com/xfs/xfs (8cb280c9) · Commits · e / devices / android_kernel_xiaomi_markw

fs/xfs/linux-2.6/xfs_aops.c

+40 −54

Original line number	Diff line number	Diff line
		@@ -934,7 +934,6 @@ xfs_aops_discard_page(
		struct xfs_inode *ip = XFS_I(inode);
		struct buffer_head bh, head;
		loff_t offset = page_offset(page);
		ssize_t len = 1 << inode->i_blkbits;

		if (!xfs_is_delayed_page(page, IO_DELAY))
		goto out_invalidate;
		@@ -949,58 +948,14 @@ xfs_aops_discard_page(
		xfs_ilock(ip, XFS_ILOCK_EXCL);
		bh = head = page_buffers(page);
		do {
		int done;
		xfs_fileoff_t offset_fsb;
		xfs_bmbt_irec_t imap;
		int nimaps = 1;
		int error;
		xfs_fsblock_t firstblock;
		xfs_bmap_free_t flist;
		xfs_fileoff_t start_fsb;

		if (!buffer_delay(bh))
		goto next_buffer;

		offset_fsb = XFS_B_TO_FSBT(ip->i_mount, offset);

		/*
		* Map the range first and check that it is a delalloc extent
		* before trying to unmap the range. Otherwise we will be
		* trying to remove a real extent (which requires a
		* transaction) or a hole, which is probably a bad idea...
		*/
		error = xfs_bmapi(NULL, ip, offset_fsb, 1,
		XFS_BMAPI_ENTIRE, NULL, 0, &imap,
		&nimaps, NULL);

		if (error) {
		/* something screwed, just bail */
		if (!XFS_FORCED_SHUTDOWN(ip->i_mount)) {
		xfs_fs_cmn_err(CE_ALERT, ip->i_mount,
		"page discard failed delalloc mapping lookup.");
		}
		break;
		}
		if (!nimaps) {
		/* nothing there */
		goto next_buffer;
		}
		if (imap.br_startblock != DELAYSTARTBLOCK) {
		/* been converted, ignore */
		goto next_buffer;
		}
		WARN_ON(imap.br_blockcount == 0);

		/*
		* Note: while we initialise the firstblock/flist pair, they
		* should never be used because blocks should never be
		* allocated or freed for a delalloc extent and hence we need
		* don't cancel or finish them after the xfs_bunmapi() call.
		*/
		xfs_bmap_init(&flist, &firstblock);
		error = xfs_bunmapi(NULL, ip, offset_fsb, 1, 0, 1, &firstblock,
		&flist, &done);

		ASSERT(!flist.xbf_count && !flist.xbf_first);
		start_fsb = XFS_B_TO_FSBT(ip->i_mount, offset);
		error = xfs_bmap_punch_delalloc_range(ip, start_fsb, 1);
		if (error) {
		/* something screwed, just bail */
		if (!XFS_FORCED_SHUTDOWN(ip->i_mount)) {
		@@ -1010,7 +965,7 @@ xfs_aops_discard_page(
		break;
		}
		next_buffer:
		offset += len;
		offset += 1 << inode->i_blkbits;

		} while ((bh = bh->b_this_page) != head);

		@@ -1505,11 +1460,42 @@ xfs_vm_write_failed(
		struct inode *inode = mapping->host;

		if (to > inode->i_size) {
		struct iattr ia = {
		.ia_valid = ATTR_SIZE \| ATTR_FORCE,
		.ia_size = inode->i_size,
		};
		xfs_setattr(XFS_I(inode), &ia, XFS_ATTR_NOLOCK);
		/*
		* punch out the delalloc blocks we have already allocated. We
		* don't call xfs_setattr() to do this as we may be in the
		* middle of a multi-iovec write and so the vfs inode->i_size
		* will not match the xfs ip->i_size and so it will zero too
		* much. Hence we jus truncate the page cache to zero what is
		* necessary and punch the delalloc blocks directly.
		*/
		struct xfs_inode *ip = XFS_I(inode);
		xfs_fileoff_t start_fsb;
		xfs_fileoff_t end_fsb;
		int error;

		truncate_pagecache(inode, to, inode->i_size);

		/*
		* Check if there are any blocks that are outside of i_size
		* that need to be trimmed back.
		*/
		start_fsb = XFS_B_TO_FSB(ip->i_mount, inode->i_size) + 1;
		end_fsb = XFS_B_TO_FSB(ip->i_mount, to);
		if (end_fsb <= start_fsb)
		return;

		xfs_ilock(ip, XFS_ILOCK_EXCL);
		error = xfs_bmap_punch_delalloc_range(ip, start_fsb,
		end_fsb - start_fsb);
		if (error) {
		/* something screwed, just bail */
		if (!XFS_FORCED_SHUTDOWN(ip->i_mount)) {
		xfs_fs_cmn_err(CE_ALERT, ip->i_mount,
		"xfs_vm_write_failed: unable to clean up ino %lld",
		ip->i_ino);
		}
		}
		xfs_iunlock(ip, XFS_ILOCK_EXCL);
		}
		}

fs/xfs/linux-2.6/xfs_buf.c

+16 −19

Original line number	Diff line number	Diff line
		@@ -488,29 +488,16 @@ found:
		spin_unlock(&pag->pag_buf_lock);
		xfs_perag_put(pag);

		/* Attempt to get the semaphore without sleeping,
		* if this does not work then we need to drop the
		* spinlock and do a hard attempt on the semaphore.
		*/
		if (down_trylock(&bp->b_sema)) {
		if (xfs_buf_cond_lock(bp)) {
		/* failed, so wait for the lock if requested. */
		if (!(flags & XBF_TRYLOCK)) {
		/* wait for buffer ownership */
		xfs_buf_lock(bp);
		XFS_STATS_INC(xb_get_locked_waited);
		} else {
		/* We asked for a trylock and failed, no need
		* to look at file offset and length here, we
		* know that this buffer at least overlaps our
		* buffer and is locked, therefore our buffer
		* either does not exist, or is this buffer.
		*/
		xfs_buf_rele(bp);
		XFS_STATS_INC(xb_busy_locked);
		return NULL;
		}
		} else {
		/* trylock worked */
		XB_SET_OWNER(bp);
		}

		if (bp->b_flags & XBF_STALE) {
		@@ -876,10 +863,18 @@ xfs_buf_rele(
		*/

		/*
		* Locks a buffer object, if it is not already locked.
		* Note that this in no way locks the underlying pages, so it is only
		* useful for synchronizing concurrent use of buffer objects, not for
		* synchronizing independent access to the underlying pages.
		* Locks a buffer object, if it is not already locked. Note that this in
		* no way locks the underlying pages, so it is only useful for
		* synchronizing concurrent use of buffer objects, not for synchronizing
		* independent access to the underlying pages.
		*
		* If we come across a stale, pinned, locked buffer, we know that we are
		* being asked to lock a buffer that has been reallocated. Because it is
		* pinned, we know that the log has not been pushed to disk and hence it
		* will still be locked. Rather than continuing to have trylock attempts
		* fail until someone else pushes the log, push it ourselves before
		* returning. This means that the xfsaild will not get stuck trying
		* to push on stale inode buffers.
		*/
		int
		xfs_buf_cond_lock(
		@@ -890,6 +885,8 @@ xfs_buf_cond_lock(
		locked = down_trylock(&bp->b_sema) == 0;
		if (locked)
		XB_SET_OWNER(bp);
		else if (atomic_read(&bp->b_pin_count) && (bp->b_flags & XBF_STALE))
		xfs_log_force(bp->b_target->bt_mount, 0);

		trace_xfs_buf_cond_lock(bp, _RET_IP_);
		return locked ? 0 : -EBUSY;

fs/xfs/xfs_bmap.c

+83 −2

Original line number	Diff line number	Diff line
		@@ -5471,8 +5471,13 @@ xfs_getbmap(
		if (error)
		goto out_unlock_iolock;
		}

		ASSERT(ip->i_delayed_blks == 0);
		/*
		* even after flushing the inode, there can still be delalloc
		* blocks on the inode beyond EOF due to speculative
		* preallocation. These are not removed until the release
		* function is called or the inode is inactivated. Hence we
		* cannot assert here that ip->i_delayed_blks == 0.
		*/
		}

		lock = xfs_ilock_map_shared(ip);
		@@ -6070,3 +6075,79 @@ xfs_bmap_disk_count_leaves(
		*count += xfs_bmbt_disk_get_blockcount(frp);
		}
		}

		/*
		* dead simple method of punching delalyed allocation blocks from a range in
		* the inode. Walks a block at a time so will be slow, but is only executed in
		* rare error cases so the overhead is not critical. This will alays punch out
		* both the start and end blocks, even if the ranges only partially overlap
		* them, so it is up to the caller to ensure that partial blocks are not
		* passed in.
		*/
		int
		xfs_bmap_punch_delalloc_range(
		struct xfs_inode *ip,
		xfs_fileoff_t start_fsb,
		xfs_fileoff_t length)
		{
		xfs_fileoff_t remaining = length;
		int error = 0;

		ASSERT(xfs_isilocked(ip, XFS_ILOCK_EXCL));

		do {
		int done;
		xfs_bmbt_irec_t imap;
		int nimaps = 1;
		xfs_fsblock_t firstblock;
		xfs_bmap_free_t flist;

		/*
		* Map the range first and check that it is a delalloc extent
		* before trying to unmap the range. Otherwise we will be
		* trying to remove a real extent (which requires a
		* transaction) or a hole, which is probably a bad idea...
		*/
		error = xfs_bmapi(NULL, ip, start_fsb, 1,
		XFS_BMAPI_ENTIRE, NULL, 0, &imap,
		&nimaps, NULL);

		if (error) {
		/* something screwed, just bail */
		if (!XFS_FORCED_SHUTDOWN(ip->i_mount)) {
		xfs_fs_cmn_err(CE_ALERT, ip->i_mount,
		"Failed delalloc mapping lookup ino %lld fsb %lld.",
		ip->i_ino, start_fsb);
		}
		break;
		}
		if (!nimaps) {
		/* nothing there */
		goto next_block;
		}
		if (imap.br_startblock != DELAYSTARTBLOCK) {
		/* been converted, ignore */
		goto next_block;
		}
		WARN_ON(imap.br_blockcount == 0);

		/*
		* Note: while we initialise the firstblock/flist pair, they
		* should never be used because blocks should never be
		* allocated or freed for a delalloc extent and hence we need
		* don't cancel or finish them after the xfs_bunmapi() call.
		*/
		xfs_bmap_init(&flist, &firstblock);
		error = xfs_bunmapi(NULL, ip, start_fsb, 1, 0, 1, &firstblock,
		&flist, &done);
		if (error)
		break;

		ASSERT(!flist.xbf_count && !flist.xbf_first);
		next_block:
		start_fsb++;
		remaining--;
		} while(remaining > 0);

		return error;
		}

fs/xfs/xfs_bmap.h

+5 −0

Original line number	Diff line number	Diff line
		@@ -394,6 +394,11 @@ xfs_bmap_count_blocks(
		int whichfork,
		int *count);

		int
		xfs_bmap_punch_delalloc_range(
		struct xfs_inode *ip,
		xfs_fileoff_t start_fsb,
		xfs_fileoff_t length);
		#endif /* __KERNEL__ */

		#endif /* __XFS_BMAP_H__ */

fs/xfs/xfs_dfrag.c

+13 −0

Original line number	Diff line number	Diff line
		@@ -377,6 +377,19 @@ xfs_swap_extents(
		ip->i_d.di_format = tip->i_d.di_format;
		tip->i_d.di_format = tmp;

		/*
		* The extents in the source inode could still contain speculative
		* preallocation beyond EOF (e.g. the file is open but not modified
		* while defrag is in progress). In that case, we need to copy over the
		* number of delalloc blocks the data fork in the source inode is
		* tracking beyond EOF so that when the fork is truncated away when the
		* temporary inode is unlinked we don't underrun the i_delayed_blks
		* counter on that inode.
		*/
		ASSERT(tip->i_delayed_blks == 0);
		tip->i_delayed_blks = ip->i_delayed_blks;
		ip->i_delayed_blks = 0;

		ilf_fields = XFS_ILOG_CORE;

		switch(ip->i_d.di_format) {