Merge branch 'for-linus' of git://oss.sgi.com:8090/xfs/xfs-2.6 (6483d152) · Commits · e / devices / android_kernel_fairphone_FP3

fs/xfs/linux-2.6/xfs_buf.c

+20 −4

Original line number	Diff line number	Diff line
		@@ -387,6 +387,8 @@ _xfs_buf_lookup_pages(
		if (unlikely(page == NULL)) {
		if (flags & XBF_READ_AHEAD) {
		bp->b_page_count = i;
		for (i = 0; i < bp->b_page_count; i++)
		unlock_page(bp->b_pages[i]);
		return -ENOMEM;
		}

		@@ -416,17 +418,24 @@ _xfs_buf_lookup_pages(
		ASSERT(!PagePrivate(page));
		if (!PageUptodate(page)) {
		page_count--;
		if (blocksize < PAGE_CACHE_SIZE && !PagePrivate(page)) {
		if (blocksize >= PAGE_CACHE_SIZE) {
		if (flags & XBF_READ)
		bp->b_flags \|= _XBF_PAGE_LOCKED;
		} else if (!PagePrivate(page)) {
		if (test_page_region(page, offset, nbytes))
		page_count++;
		}
		}

		unlock_page(page);
		bp->b_pages[i] = page;
		offset = 0;
		}

		if (!(bp->b_flags & _XBF_PAGE_LOCKED)) {
		for (i = 0; i < bp->b_page_count; i++)
		unlock_page(bp->b_pages[i]);
		}

		if (page_count == bp->b_page_count)
		bp->b_flags \|= XBF_DONE;

		@@ -746,6 +755,7 @@ xfs_buf_associate_memory(
		bp->b_count_desired = len;
		bp->b_buffer_length = buflen;
		bp->b_flags \|= XBF_MAPPED;
		bp->b_flags &= ~_XBF_PAGE_LOCKED;

		return 0;
		}
		@@ -1093,9 +1103,11 @@ _xfs_buf_ioend(
		xfs_buf_t *bp,
		int schedule)
		{
		if (atomic_dec_and_test(&bp->b_io_remaining) == 1)
		if (atomic_dec_and_test(&bp->b_io_remaining) == 1) {
		bp->b_flags &= ~_XBF_PAGE_LOCKED;
		xfs_buf_ioend(bp, schedule);
		}
		}

		STATIC void
		xfs_buf_bio_end_io(
		@@ -1125,6 +1137,9 @@ xfs_buf_bio_end_io(

		if (--bvec >= bio->bi_io_vec)
		prefetchw(&bvec->bv_page->flags);

		if (bp->b_flags & _XBF_PAGE_LOCKED)
		unlock_page(page);
		} while (bvec >= bio->bi_io_vec);

		_xfs_buf_ioend(bp, 1);
		@@ -1163,7 +1178,8 @@ _xfs_buf_ioapply(
		* filesystem block size is not smaller than the page size.
		*/
		if ((bp->b_buffer_length < PAGE_CACHE_SIZE) &&
		(bp->b_flags & XBF_READ) &&
		((bp->b_flags & (XBF_READ\|_XBF_PAGE_LOCKED)) ==
		(XBF_READ\|_XBF_PAGE_LOCKED)) &&
		(blocksize >= PAGE_CACHE_SIZE)) {
		bio = bio_alloc(GFP_NOIO, 1);

fs/xfs/linux-2.6/xfs_buf.h

+19 −0

Original line number	Diff line number	Diff line
		@@ -66,6 +66,25 @@ typedef enum {
		_XBF_PAGES = (1 << 18), /* backed by refcounted pages */
		_XBF_RUN_QUEUES = (1 << 19),/* run block device task queue */
		_XBF_DELWRI_Q = (1 << 21), /* buffer on delwri queue */

		/*
		* Special flag for supporting metadata blocks smaller than a FSB.
		*
		* In this case we can have multiple xfs_buf_t on a single page and
		* need to lock out concurrent xfs_buf_t readers as they only
		* serialise access to the buffer.
		*
		* If the FSB size >= PAGE_CACHE_SIZE case, we have no serialisation
		* between reads of the page. Hence we can have one thread read the
		* page and modify it, but then race with another thread that thinks
		* the page is not up-to-date and hence reads it again.
		*
		* The result is that the first modifcation to the page is lost.
		* This sort of AGF/AGI reading race can happen when unlinking inodes
		* that require truncation and results in the AGI unlinked list
		* modifications being lost.
		*/
		_XBF_PAGE_LOCKED = (1 << 22),
		} xfs_buf_flags_t;

		typedef enum {

fs/xfs/linux-2.6/xfs_file.c

+11 −6

Original line number	Diff line number	Diff line
		@@ -184,19 +184,24 @@ xfs_file_release(
		return -xfs_release(XFS_I(inode));
		}

		/*
		* We ignore the datasync flag here because a datasync is effectively
		* identical to an fsync. That is, datasync implies that we need to write
		* only the metadata needed to be able to access the data that is written
		* if we crash after the call completes. Hence if we are writing beyond
		* EOF we have to log the inode size change as well, which makes it a
		* full fsync. If we don't write beyond EOF, the inode core will be
		* clean in memory and so we don't need to log the inode, just like
		* fsync.
		*/
		STATIC int
		xfs_file_fsync(
		struct file *filp,
		struct dentry *dentry,
		int datasync)
		{
		int flags = FSYNC_WAIT;

		if (datasync)
		flags \|= FSYNC_DATA;
		xfs_iflags_clear(XFS_I(dentry->d_inode), XFS_ITRUNCATED);
		return -xfs_fsync(XFS_I(dentry->d_inode), flags,
		(xfs_off_t)0, (xfs_off_t)-1);
		return -xfs_fsync(XFS_I(dentry->d_inode));
		}

		/*

fs/xfs/linux-2.6/xfs_vnode.h

+0 −8

Original line number	Diff line number	Diff line
		@@ -229,14 +229,6 @@ static inline void vn_atime_to_time_t(bhv_vnode_t vp, time_t tt)
		#define ATTR_NOLOCK 0x200 /* Don't grab any conflicting locks */
		#define ATTR_NOSIZETOK 0x400 /* Don't get the SIZE token */

		/*
		* Flags to vop_fsync/reclaim.
		*/
		#define FSYNC_NOWAIT 0 /* asynchronous flush */
		#define FSYNC_WAIT 0x1 /* synchronous fsync or forced reclaim */
		#define FSYNC_INVAL 0x2 /* flush and invalidate cached data */
		#define FSYNC_DATA 0x4 /* synchronous fsync of data only */

		/*
		* Tracking vnode activity.
		*/

fs/xfs/xfs_inode.c

+5 −4

Original line number	Diff line number	Diff line
		@@ -2974,6 +2974,7 @@ xfs_iflush_cluster(
		xfs_mount_t *mp = ip->i_mount;
		xfs_perag_t *pag = xfs_get_perag(mp, ip->i_ino);
		unsigned long first_index, mask;
		unsigned long inodes_per_cluster;
		int ilist_size;
		xfs_inode_t **ilist;
		xfs_inode_t *iq;
		@@ -2985,8 +2986,9 @@ xfs_iflush_cluster(
		ASSERT(pag->pagi_inodeok);
		ASSERT(pag->pag_ici_init);

		ilist_size = XFS_INODE_CLUSTER_SIZE(mp) * sizeof(xfs_inode_t *);
		ilist = kmem_alloc(ilist_size, KM_MAYFAIL);
		inodes_per_cluster = XFS_INODE_CLUSTER_SIZE(mp) >> mp->m_sb.sb_inodelog;
		ilist_size = inodes_per_cluster * sizeof(xfs_inode_t *);
		ilist = kmem_alloc(ilist_size, KM_MAYFAIL\|KM_NOFS);
		if (!ilist)
		return 0;

		@@ -2995,8 +2997,7 @@ xfs_iflush_cluster(
		read_lock(&pag->pag_ici_lock);
		/* really need a gang lookup range call here */
		nr_found = radix_tree_gang_lookup(&pag->pag_ici_root, (void**)ilist,
		first_index,
		XFS_INODE_CLUSTER_SIZE(mp));
		first_index, inodes_per_cluster);
		if (nr_found == 0)
		goto out_free;