Merge branch 'for-linus' of git://oss.sgi.com/xfs/xfs (5619a693) · Commits · 戴 / test

fs/xfs/xfs_alloc.c

+2 −2

Original line number	Diff line number	Diff line
		@@ -452,7 +452,7 @@ xfs_alloc_read_agfl(
		if (error)
		return error;
		ASSERT(!xfs_buf_geterror(bp));
		XFS_BUF_SET_VTYPE_REF(bp, B_FS_AGFL, XFS_AGFL_REF);
		xfs_buf_set_ref(bp, XFS_AGFL_REF);
		*bpp = bp;
		return 0;
		}
		@@ -2139,7 +2139,7 @@ xfs_read_agf(
		xfs_trans_brelse(tp, *bpp);
		return XFS_ERROR(EFSCORRUPTED);
		}
		XFS_BUF_SET_VTYPE_REF(*bpp, B_FS_AGF, XFS_AGF_REF);
		xfs_buf_set_ref(*bpp, XFS_AGF_REF);
		return 0;
		}

fs/xfs/xfs_aops.c

+42 −77

Original line number	Diff line number	Diff line
		@@ -38,40 +38,6 @@
		#include <linux/pagevec.h>
		#include <linux/writeback.h>


		/*
		* Prime number of hash buckets since address is used as the key.
		*/
		#define NVSYNC 37
		#define to_ioend_wq(v) (&xfs_ioend_wq[((unsigned long)v) % NVSYNC])
		static wait_queue_head_t xfs_ioend_wq[NVSYNC];

		void __init
		xfs_ioend_init(void)
		{
		int i;

		for (i = 0; i < NVSYNC; i++)
		init_waitqueue_head(&xfs_ioend_wq[i]);
		}

		void
		xfs_ioend_wait(
		xfs_inode_t *ip)
		{
		wait_queue_head_t *wq = to_ioend_wq(ip);

		wait_event(*wq, (atomic_read(&ip->i_iocount) == 0));
		}

		STATIC void
		xfs_ioend_wake(
		xfs_inode_t *ip)
		{
		if (atomic_dec_and_test(&ip->i_iocount))
		wake_up(to_ioend_wq(ip));
		}

		void
		xfs_count_page_state(
		struct page *page,
		@@ -115,25 +81,20 @@ xfs_destroy_ioend(
		xfs_ioend_t *ioend)
		{
		struct buffer_head bh, next;
		struct xfs_inode *ip = XFS_I(ioend->io_inode);

		for (bh = ioend->io_buffer_head; bh; bh = next) {
		next = bh->b_private;
		bh->b_end_io(bh, !ioend->io_error);
		}

		/*
		* Volume managers supporting multiple paths can send back ENODEV
		* when the final path disappears. In this case continuing to fill
		* the page cache with dirty data which cannot be written out is
		* evil, so prevent that.
		*/
		if (unlikely(ioend->io_error == -ENODEV)) {
		xfs_do_force_shutdown(ip->i_mount, SHUTDOWN_DEVICE_REQ,
		__FILE__, __LINE__);
		if (ioend->io_iocb) {
		if (ioend->io_isasync) {
		aio_complete(ioend->io_iocb, ioend->io_error ?
		ioend->io_error : ioend->io_result, 0);
		}
		inode_dio_done(ioend->io_inode);
		}

		xfs_ioend_wake(ip);
		mempool_free(ioend, xfs_ioend_pool);
		}

		@@ -155,6 +116,15 @@ xfs_ioend_new_eof(
		return isize > ip->i_d.di_size ? isize : 0;
		}

		/*
		* Fast and loose check if this write could update the on-disk inode size.
		*/
		static inline bool xfs_ioend_is_append(struct xfs_ioend *ioend)
		{
		return ioend->io_offset + ioend->io_size >
		XFS_I(ioend->io_inode)->i_d.di_size;
		}

		/*
		* Update on-disk file size now that data has been written to disk. The
		* current in-memory file size is i_size. If a write is beyond eof i_new_size
		@@ -173,9 +143,6 @@ xfs_setfilesize(
		xfs_inode_t *ip = XFS_I(ioend->io_inode);
		xfs_fsize_t isize;

		if (unlikely(ioend->io_error))
		return 0;

		if (!xfs_ilock_nowait(ip, XFS_ILOCK_EXCL))
		return EAGAIN;

		@@ -192,6 +159,9 @@ xfs_setfilesize(

		/*
		* Schedule IO completion handling on the final put of an ioend.
		*
		* If there is no work to do we might as well call it a day and free the
		* ioend right now.
		*/
		STATIC void
		xfs_finish_ioend(
		@@ -200,8 +170,10 @@ xfs_finish_ioend(
		if (atomic_dec_and_test(&ioend->io_remaining)) {
		if (ioend->io_type == IO_UNWRITTEN)
		queue_work(xfsconvertd_workqueue, &ioend->io_work);
		else
		else if (xfs_ioend_is_append(ioend))
		queue_work(xfsdatad_workqueue, &ioend->io_work);
		else
		xfs_destroy_ioend(ioend);
		}
		}

		@@ -216,17 +188,24 @@ xfs_end_io(
		struct xfs_inode *ip = XFS_I(ioend->io_inode);
		int error = 0;

		if (XFS_FORCED_SHUTDOWN(ip->i_mount)) {
		error = -EIO;
		goto done;
		}
		if (ioend->io_error)
		goto done;

		/*
		* For unwritten extents we need to issue transactions to convert a
		* range to normal written extens after the data I/O has finished.
		*/
		if (ioend->io_type == IO_UNWRITTEN &&
		likely(!ioend->io_error && !XFS_FORCED_SHUTDOWN(ip->i_mount))) {

		if (ioend->io_type == IO_UNWRITTEN) {
		error = xfs_iomap_write_unwritten(ip, ioend->io_offset,
		ioend->io_size);
		if (error)
		ioend->io_error = error;
		if (error) {
		ioend->io_error = -error;
		goto done;
		}
		}

		/*
		@@ -236,6 +215,7 @@ xfs_end_io(
		error = xfs_setfilesize(ioend);
		ASSERT(!error \|\| error == EAGAIN);

		done:
		/*
		* If we didn't complete processing of the ioend, requeue it to the
		* tail of the workqueue for another attempt later. Otherwise destroy
		@@ -247,8 +227,6 @@ xfs_end_io(
		/* ensure we don't spin on blocked ioends */
		delay(1);
		} else {
		if (ioend->io_iocb)
		aio_complete(ioend->io_iocb, ioend->io_result, 0);
		xfs_destroy_ioend(ioend);
		}
		}
		@@ -285,13 +263,13 @@ xfs_alloc_ioend(
		* all the I/O from calling the completion routine too early.
		*/
		atomic_set(&ioend->io_remaining, 1);
		ioend->io_isasync = 0;
		ioend->io_error = 0;
		ioend->io_list = NULL;
		ioend->io_type = type;
		ioend->io_inode = inode;
		ioend->io_buffer_head = NULL;
		ioend->io_buffer_tail = NULL;
		atomic_inc(&XFS_I(ioend->io_inode)->i_iocount);
		ioend->io_offset = 0;
		ioend->io_size = 0;
		ioend->io_iocb = NULL;
		@@ -337,8 +315,8 @@ xfs_map_blocks(
		count = mp->m_maxioffset - offset;
		end_fsb = XFS_B_TO_FSB(mp, (xfs_ufsize_t)offset + count);
		offset_fsb = XFS_B_TO_FSBT(mp, offset);
		error = xfs_bmapi(NULL, ip, offset_fsb, end_fsb - offset_fsb,
		bmapi_flags, NULL, 0, imap, &nimaps, NULL);
		error = xfs_bmapi_read(ip, offset_fsb, end_fsb - offset_fsb,
		imap, &nimaps, bmapi_flags);
		xfs_iunlock(ip, XFS_ILOCK_SHARED);

		if (error)
		@@ -551,7 +529,6 @@ xfs_cancel_ioend(
		unlock_buffer(bh);
		} while ((bh = next_bh) != NULL);

		xfs_ioend_wake(XFS_I(ioend->io_inode));
		mempool_free(ioend, xfs_ioend_pool);
		} while ((ioend = next) != NULL);
		}
		@@ -1161,8 +1138,8 @@ __xfs_get_blocks(
		end_fsb = XFS_B_TO_FSB(mp, (xfs_ufsize_t)offset + size);
		offset_fsb = XFS_B_TO_FSBT(mp, offset);

		error = xfs_bmapi(NULL, ip, offset_fsb, end_fsb - offset_fsb,
		XFS_BMAPI_ENTIRE, NULL, 0, &imap, &nimaps, NULL);
		error = xfs_bmapi_read(ip, offset_fsb, end_fsb - offset_fsb,
		&imap, &nimaps, XFS_BMAPI_ENTIRE);
		if (error)
		goto out_unlock;

		@@ -1300,7 +1277,6 @@ xfs_end_io_direct_write(
		bool is_async)
		{
		struct xfs_ioend *ioend = iocb->private;
		struct inode *inode = ioend->io_inode;

		/*
		* blockdev_direct_IO can return an error even after the I/O
		@@ -1311,28 +1287,17 @@ xfs_end_io_direct_write(

		ioend->io_offset = offset;
		ioend->io_size = size;
		ioend->io_iocb = iocb;
		ioend->io_result = ret;
		if (private && size > 0)
		ioend->io_type = IO_UNWRITTEN;

		if (is_async) {
		/*
		* If we are converting an unwritten extent we need to delay
		* the AIO completion until after the unwrittent extent
		* conversion has completed, otherwise do it ASAP.
		*/
		if (ioend->io_type == IO_UNWRITTEN) {
		ioend->io_iocb = iocb;
		ioend->io_result = ret;
		} else {
		aio_complete(iocb, ret, 0);
		}
		ioend->io_isasync = 1;
		xfs_finish_ioend(ioend);
		} else {
		xfs_finish_ioend_sync(ioend);
		}

		/* XXX: probably should move into the real I/O completion handler */
		inode_dio_done(inode);
		}

		STATIC ssize_t

fs/xfs/xfs_aops.h

+1 −3

Original line number	Diff line number	Diff line
		@@ -47,6 +47,7 @@ typedef struct xfs_ioend {
		unsigned int io_type; /* delalloc / unwritten */
		int io_error; /* I/O error code */
		atomic_t io_remaining; /* hold count */
		unsigned int io_isasync : 1; /* needs aio_complete */
		struct inode io_inode; / file being written to */
		struct buffer_head io_buffer_head;/ buffer linked list head */
		struct buffer_head io_buffer_tail;/ buffer linked list tail */
		@@ -60,9 +61,6 @@ typedef struct xfs_ioend {
		extern const struct address_space_operations xfs_address_space_operations;
		extern int xfs_get_blocks(struct inode , sector_t, struct buffer_head , int);

		extern void xfs_ioend_init(void);
		extern void xfs_ioend_wait(struct xfs_inode *);

		extern void xfs_count_page_state(struct page , int , int *);

		#endif /* __XFS_AOPS_H__ */

fs/xfs/xfs_attr.c

+34 −55

Original line number	Diff line number	Diff line
		@@ -319,7 +319,7 @@ xfs_attr_set_int(
		return (error);
		}

		xfs_trans_ijoin(args.trans, dp);
		xfs_trans_ijoin(args.trans, dp, 0);

		/*
		* If the attribute list is non-existent or a shortform list,
		@@ -389,7 +389,7 @@ xfs_attr_set_int(
		* a new one. We need the inode to be in all transactions.
		*/
		if (committed)
		xfs_trans_ijoin(args.trans, dp);
		xfs_trans_ijoin(args.trans, dp, 0);

		/*
		* Commit the leaf transformation. We'll need another (linked)
		@@ -537,7 +537,7 @@ xfs_attr_remove_int(xfs_inode_t dp, struct xfs_name name, int flags)
		* No need to make quota reservations here. We expect to release some
		* blocks not allocate in the common case.
		*/
		xfs_trans_ijoin(args.trans, dp);
		xfs_trans_ijoin(args.trans, dp, 0);

		/*
		* Decide on what work routines to call based on the inode size.
		@@ -809,7 +809,7 @@ xfs_attr_inactive(xfs_inode_t *dp)
		* No need to make quota reservations here. We expect to release some
		* blocks, not allocate, in the common case.
		*/
		xfs_trans_ijoin(trans, dp);
		xfs_trans_ijoin(trans, dp, 0);

		/*
		* Decide on what work routines to call based on the inode size.
		@@ -823,18 +823,6 @@ xfs_attr_inactive(xfs_inode_t *dp)
		if (error)
		goto out;

		/*
		* Signal synchronous inactive transactions unless this is a
		* synchronous mount filesystem in which case we know that we're here
		* because we've been called out of xfs_inactive which means that the
		* last reference is gone and the unlink transaction has already hit
		* the disk so async inactive transactions are safe.
		*/
		if (!(mp->m_flags & XFS_MOUNT_WSYNC)) {
		if (dp->i_d.di_anextents > 0)
		xfs_trans_set_sync(trans);
		}

		error = xfs_itruncate_extents(&trans, dp, XFS_ATTR_FORK, 0);
		if (error)
		goto out;
		@@ -973,7 +961,7 @@ xfs_attr_leaf_addname(xfs_da_args_t *args)
		* a new one. We need the inode to be in all transactions.
		*/
		if (committed)
		xfs_trans_ijoin(args->trans, dp);
		xfs_trans_ijoin(args->trans, dp, 0);

		/*
		* Commit the current trans (including the inode) and start
		@@ -1075,7 +1063,7 @@ xfs_attr_leaf_addname(xfs_da_args_t *args)
		* in all transactions.
		*/
		if (committed)
		xfs_trans_ijoin(args->trans, dp);
		xfs_trans_ijoin(args->trans, dp, 0);
		} else
		xfs_da_buf_done(bp);

		@@ -1149,7 +1137,7 @@ xfs_attr_leaf_removename(xfs_da_args_t *args)
		* a new one. We need the inode to be in all transactions.
		*/
		if (committed)
		xfs_trans_ijoin(args->trans, dp);
		xfs_trans_ijoin(args->trans, dp, 0);
		} else
		xfs_da_buf_done(bp);
		return(0);
		@@ -1303,7 +1291,7 @@ restart:
		* in all transactions.
		*/
		if (committed)
		xfs_trans_ijoin(args->trans, dp);
		xfs_trans_ijoin(args->trans, dp, 0);

		/*
		* Commit the node conversion and start the next
		@@ -1340,7 +1328,7 @@ restart:
		* a new one. We need the inode to be in all transactions.
		*/
		if (committed)
		xfs_trans_ijoin(args->trans, dp);
		xfs_trans_ijoin(args->trans, dp, 0);
		} else {
		/*
		* Addition succeeded, update Btree hashvals.
		@@ -1452,7 +1440,7 @@ restart:
		* in all transactions.
		*/
		if (committed)
		xfs_trans_ijoin(args->trans, dp);
		xfs_trans_ijoin(args->trans, dp, 0);
		}

		/*
		@@ -1584,7 +1572,7 @@ xfs_attr_node_removename(xfs_da_args_t *args)
		* a new one. We need the inode to be in all transactions.
		*/
		if (committed)
		xfs_trans_ijoin(args->trans, dp);
		xfs_trans_ijoin(args->trans, dp, 0);

		/*
		* Commit the Btree join operation and start a new trans.
		@@ -1635,7 +1623,7 @@ xfs_attr_node_removename(xfs_da_args_t *args)
		* in all transactions.
		*/
		if (committed)
		xfs_trans_ijoin(args->trans, dp);
		xfs_trans_ijoin(args->trans, dp, 0);
		} else
		xfs_da_brelse(args->trans, bp);
		}
		@@ -1975,10 +1963,9 @@ xfs_attr_rmtval_get(xfs_da_args_t *args)
		lblkno = args->rmtblkno;
		while (valuelen > 0) {
		nmap = ATTR_RMTVALUE_MAPSIZE;
		error = xfs_bmapi(args->trans, args->dp, (xfs_fileoff_t)lblkno,
		args->rmtblkcnt,
		XFS_BMAPI_ATTRFORK \| XFS_BMAPI_METADATA,
		NULL, 0, map, &nmap, NULL);
		error = xfs_bmapi_read(args->dp, (xfs_fileoff_t)lblkno,
		args->rmtblkcnt, map, &nmap,
		XFS_BMAPI_ATTRFORK);
		if (error)
		return(error);
		ASSERT(nmap >= 1);
		@@ -2052,10 +2039,9 @@ xfs_attr_rmtval_set(xfs_da_args_t *args)
		*/
		xfs_bmap_init(args->flist, args->firstblock);
		nmap = 1;
		error = xfs_bmapi(args->trans, dp, (xfs_fileoff_t)lblkno,
		error = xfs_bmapi_write(args->trans, dp, (xfs_fileoff_t)lblkno,
		blkcnt,
		XFS_BMAPI_ATTRFORK \| XFS_BMAPI_METADATA \|
		XFS_BMAPI_WRITE,
		XFS_BMAPI_ATTRFORK \| XFS_BMAPI_METADATA,
		args->firstblock, args->total, &map, &nmap,
		args->flist);
		if (!error) {
		@@ -2074,7 +2060,7 @@ xfs_attr_rmtval_set(xfs_da_args_t *args)
		* a new one. We need the inode to be in all transactions.
		*/
		if (committed)
		xfs_trans_ijoin(args->trans, dp);
		xfs_trans_ijoin(args->trans, dp, 0);

		ASSERT(nmap == 1);
		ASSERT((map.br_startblock != DELAYSTARTBLOCK) &&
		@@ -2104,14 +2090,11 @@ xfs_attr_rmtval_set(xfs_da_args_t *args)
		*/
		xfs_bmap_init(args->flist, args->firstblock);
		nmap = 1;
		error = xfs_bmapi(NULL, dp, (xfs_fileoff_t)lblkno,
		args->rmtblkcnt,
		XFS_BMAPI_ATTRFORK \| XFS_BMAPI_METADATA,
		args->firstblock, 0, &map, &nmap,
		NULL);
		if (error) {
		error = xfs_bmapi_read(dp, (xfs_fileoff_t)lblkno,
		args->rmtblkcnt, &map, &nmap,
		XFS_BMAPI_ATTRFORK);
		if (error)
		return(error);
		}
		ASSERT(nmap == 1);
		ASSERT((map.br_startblock != DELAYSTARTBLOCK) &&
		(map.br_startblock != HOLESTARTBLOCK));
		@@ -2121,16 +2104,17 @@ xfs_attr_rmtval_set(xfs_da_args_t *args)

		bp = xfs_buf_get(mp->m_ddev_targp, dblkno, blkcnt,
		XBF_LOCK \| XBF_DONT_BLOCK);
		ASSERT(!xfs_buf_geterror(bp));

		if (!bp)
		return ENOMEM;
		tmp = (valuelen < XFS_BUF_SIZE(bp)) ? valuelen :
		XFS_BUF_SIZE(bp);
		xfs_buf_iomove(bp, 0, tmp, src, XBRW_WRITE);
		if (tmp < XFS_BUF_SIZE(bp))
		xfs_buf_zero(bp, tmp, XFS_BUF_SIZE(bp) - tmp);
		if ((error = xfs_bwrite(mp, bp))) {/* GROT: NOTE: synchronous write */
		return (error);
		}
		error = xfs_bwrite(bp); /* GROT: NOTE: synchronous write */
		xfs_buf_relse(bp);
		if (error)
		return error;
		src += tmp;
		valuelen -= tmp;

		@@ -2166,16 +2150,12 @@ xfs_attr_rmtval_remove(xfs_da_args_t *args)
		/*
		* Try to remember where we decided to put the value.
		*/
		xfs_bmap_init(args->flist, args->firstblock);
		nmap = 1;
		error = xfs_bmapi(NULL, args->dp, (xfs_fileoff_t)lblkno,
		args->rmtblkcnt,
		XFS_BMAPI_ATTRFORK \| XFS_BMAPI_METADATA,
		args->firstblock, 0, &map, &nmap,
		args->flist);
		if (error) {
		error = xfs_bmapi_read(args->dp, (xfs_fileoff_t)lblkno,
		args->rmtblkcnt, &map, &nmap,
		XFS_BMAPI_ATTRFORK);
		if (error)
		return(error);
		}
		ASSERT(nmap == 1);
		ASSERT((map.br_startblock != DELAYSTARTBLOCK) &&
		(map.br_startblock != HOLESTARTBLOCK));
		@@ -2188,8 +2168,7 @@ xfs_attr_rmtval_remove(xfs_da_args_t *args)
		*/
		bp = xfs_incore(mp->m_ddev_targp, dblkno, blkcnt, XBF_TRYLOCK);
		if (bp) {
		XFS_BUF_STALE(bp);
		XFS_BUF_UNDELAYWRITE(bp);
		xfs_buf_stale(bp);
		xfs_buf_relse(bp);
		bp = NULL;
		}
		@@ -2227,7 +2206,7 @@ xfs_attr_rmtval_remove(xfs_da_args_t *args)
		* a new one. We need the inode to be in all transactions.
		*/
		if (committed)
		xfs_trans_ijoin(args->trans, args->dp);
		xfs_trans_ijoin(args->trans, args->dp, 0);

		/*
		* Close out trans and start the next one in the chain.

fs/xfs/xfs_attr_leaf.c

+4 −3

Original line number	Diff line number	Diff line
		@@ -2926,9 +2926,8 @@ xfs_attr_leaf_freextent(xfs_trans_t *trans, xfs_inode_t dp,
		* Try to remember where we decided to put the value.
		*/
		nmap = 1;
		error = xfs_bmapi(*trans, dp, (xfs_fileoff_t)tblkno, tblkcnt,
		XFS_BMAPI_ATTRFORK \| XFS_BMAPI_METADATA,
		NULL, 0, &map, &nmap, NULL);
		error = xfs_bmapi_read(dp, (xfs_fileoff_t)tblkno, tblkcnt,
		&map, &nmap, XFS_BMAPI_ATTRFORK);
		if (error) {
		return(error);
		}
		@@ -2948,6 +2947,8 @@ xfs_attr_leaf_freextent(xfs_trans_t *trans, xfs_inode_t dp,
		bp = xfs_trans_get_buf(*trans,
		dp->i_mount->m_ddev_targp,
		dblkno, dblkcnt, XBF_LOCK);
		if (!bp)
		return ENOMEM;
		xfs_trans_binval(*trans, bp);
		/*
		* Roll to next transaction.

Admin message