Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 347c53dc authored by Linus Torvalds's avatar Linus Torvalds
Browse files

Merge branch 'for-linus' of git://oss.sgi.com:8090/xfs/xfs-2.6 

* 'for-linus' of git://oss.sgi.com:8090/xfs/xfs-2.6: (59 commits)
  [XFS] eagerly remove vmap mappings to avoid upsetting Xen
  [XFS] simplify validata_fields
  [XFS] no longer using io_vnode, as was remaining from 23 cherrypick
  [XFS] Remove STATIC which was missing from prior manual merge
  [XFS] Put back the QUEUE_ORDERED_NONE test in the barrier check.
  [XFS] Turn off XBF_ASYNC flag before re-reading superblock.
  [XFS] avoid race in sync_inodes() that can fail to write out all dirty data
  [XFS] This fix prevents bulkstat from spinning in an infinite loop.
  [XFS] simplify xfs_create/mknod/symlink prototype
  [XFS] avoid xfs_getattr in XFS_IOC_FSGETXATTR ioctl
  [XFS] get_bulkall() could return incorrect inode state
  [XFS] Kill unused IOMAP_EOF flag
  [XFS] fix when DMAPI mount option processing happens
  [XFS] ensure file size is logged on synchronous writes
  [XFS] growlock should be a mutex
  [XFS] replace some large xfs_log_priv.h macros by proper functions
  [XFS] kill struct bhv_vfs
  [XFS] move syncing related members from struct bhv_vfs to struct xfs_mount
  [XFS] kill the vfs_flags member in struct bhv_vfs
  [XFS] kill the vfs_fsid and vfs_altfsid members in struct bhv_vfs
  ...
parents 5c8e191e 7f015072

fs/xfs/Makefile-linux-2.6

+0 −3
Original line number Diff line number Diff line
@@ -49,7 +49,6 @@ xfs-y += xfs_alloc.o \ 
				   xfs_alloc_btree.o \

				   xfs_attr.o \

				   xfs_attr_leaf.o \

				   xfs_behavior.o \

				   xfs_bit.o \

				   xfs_bmap.o \

				   xfs_bmap_btree.o \
@@ -108,13 +107,11 @@ xfs-y += $(addprefix $(XFS_LINUX)/, \ 
				   xfs_iops.o \

				   xfs_lrw.o \

				   xfs_super.o \

				   xfs_vfs.o \

				   xfs_vnode.o)



# Objects in support/

xfs-y				+= $(addprefix support/, \

				   debug.o \

				   move.o \

				   uuid.o)



xfs-$(CONFIG_XFS_TRACE)		+= support/ktrace.o

fs/xfs/linux-2.6/xfs_aops.c

+27 −30
Original line number Diff line number Diff line
@@ -37,6 +37,7 @@ 
#include "xfs_error.h"

#include "xfs_rw.h"

#include "xfs_iomap.h"

#include "xfs_vnodeops.h"

#include <linux/mpage.h>

#include <linux/pagevec.h>

#include <linux/writeback.h>
@@ -139,9 +140,11 @@ xfs_destroy_ioend( 
		next = bh->b_private;

		bh->b_end_io(bh, !ioend->io_error);

	}

	if (unlikely(ioend->io_error))

		vn_ioerror(ioend->io_vnode, ioend->io_error, __FILE__,__LINE__);

	vn_iowake(ioend->io_vnode);

	if (unlikely(ioend->io_error)) {

		vn_ioerror(XFS_I(ioend->io_inode), ioend->io_error,

				__FILE__,__LINE__);

	}

	vn_iowake(XFS_I(ioend->io_inode));

	mempool_free(ioend, xfs_ioend_pool);

}
@@ -156,14 +159,10 @@ STATIC void 
xfs_setfilesize(

	xfs_ioend_t		*ioend)

{

	xfs_inode_t		*ip;

	xfs_inode_t		*ip = XFS_I(ioend->io_inode);

	xfs_fsize_t		isize;

	xfs_fsize_t		bsize;



	ip = xfs_vtoi(ioend->io_vnode);

	if (!ip)

		return;



	ASSERT((ip->i_d.di_mode & S_IFMT) == S_IFREG);

	ASSERT(ioend->io_type != IOMAP_READ);
@@ -181,7 +180,7 @@ xfs_setfilesize( 
		ip->i_d.di_size = isize;

		ip->i_update_core = 1;

		ip->i_update_size = 1;

		mark_inode_dirty_sync(vn_to_inode(ioend->io_vnode));

		mark_inode_dirty_sync(ioend->io_inode);

	}



	xfs_iunlock(ip, XFS_ILOCK_EXCL);
@@ -227,12 +226,12 @@ xfs_end_bio_unwritten( 
{

	xfs_ioend_t		*ioend =

		container_of(work, xfs_ioend_t, io_work);

	bhv_vnode_t		*vp = ioend->io_vnode;

	xfs_off_t		offset = ioend->io_offset;

	size_t			size = ioend->io_size;



	if (likely(!ioend->io_error)) {

		bhv_vop_bmap(vp, offset, size, BMAPI_UNWRITTEN, NULL, NULL);

		xfs_bmap(XFS_I(ioend->io_inode), offset, size,

				BMAPI_UNWRITTEN, NULL, NULL);

		xfs_setfilesize(ioend);

	}

	xfs_destroy_ioend(ioend);
@@ -275,10 +274,10 @@ xfs_alloc_ioend( 
	ioend->io_error = 0;

	ioend->io_list = NULL;

	ioend->io_type = type;

	ioend->io_vnode = vn_from_inode(inode);

	ioend->io_inode = inode;

	ioend->io_buffer_head = NULL;

	ioend->io_buffer_tail = NULL;

	atomic_inc(&ioend->io_vnode->v_iocount);

	atomic_inc(&XFS_I(ioend->io_inode)->i_iocount);

	ioend->io_offset = 0;

	ioend->io_size = 0;
@@ -302,12 +301,13 @@ xfs_map_blocks( 
	xfs_iomap_t		*mapp,

	int			flags)

{

	bhv_vnode_t		*vp = vn_from_inode(inode);

	xfs_inode_t		*ip = XFS_I(inode);

	int			error, nmaps = 1;



	error = bhv_vop_bmap(vp, offset, count, flags, mapp, &nmaps);

	error = xfs_bmap(ip, offset, count,

				flags, mapp, &nmaps);

	if (!error && (flags & (BMAPI_WRITE|BMAPI_ALLOCATE)))

		VMODIFY(vp);

		xfs_iflags_set(ip, XFS_IMODIFIED);

	return -error;

}
@@ -497,7 +497,7 @@ xfs_cancel_ioend( 
			unlock_buffer(bh);

		} while ((bh = next_bh) != NULL);



		vn_iowake(ioend->io_vnode);

		vn_iowake(XFS_I(ioend->io_inode));

		mempool_free(ioend, xfs_ioend_pool);

	} while ((ioend = next) != NULL);

}
@@ -1237,10 +1237,7 @@ xfs_vm_writepages( 
	struct address_space	*mapping,

	struct writeback_control *wbc)

{

	struct bhv_vnode	*vp = vn_from_inode(mapping->host);



	if (VN_TRUNC(vp))

		VUNTRUNCATE(vp);

	xfs_iflags_clear(XFS_I(mapping->host), XFS_ITRUNCATED);

	return generic_writepages(mapping, wbc);

}
@@ -1317,7 +1314,6 @@ __xfs_get_blocks( 
	int			direct,

	bmapi_flags_t		flags)

{

	bhv_vnode_t		*vp = vn_from_inode(inode);

	xfs_iomap_t		iomap;

	xfs_off_t		offset;

	ssize_t			size;
@@ -1327,7 +1323,7 @@ __xfs_get_blocks( 
	offset = (xfs_off_t)iblock << inode->i_blkbits;

	ASSERT(bh_result->b_size >= (1 << inode->i_blkbits));

	size = bh_result->b_size;

	error = bhv_vop_bmap(vp, offset, size,

	error = xfs_bmap(XFS_I(inode), offset, size,

			     create ? flags : BMAPI_READ, &iomap, &niomap);

	if (error)

		return -error;
@@ -1475,13 +1471,13 @@ xfs_vm_direct_IO( 
{

	struct file	*file = iocb->ki_filp;

	struct inode	*inode = file->f_mapping->host;

	bhv_vnode_t	*vp = vn_from_inode(inode);

	xfs_iomap_t	iomap;

	int		maps = 1;

	int		error;

	ssize_t		ret;



	error = bhv_vop_bmap(vp, offset, 0, BMAPI_DEVICE, &iomap, &maps);

	error = xfs_bmap(XFS_I(inode), offset, 0,

				BMAPI_DEVICE, &iomap, &maps);

	if (error)

		return -error;
@@ -1527,12 +1523,13 @@ xfs_vm_bmap( 
	sector_t		block)

{

	struct inode		*inode = (struct inode *)mapping->host;

	bhv_vnode_t		*vp = vn_from_inode(inode);

	struct xfs_inode	*ip = XFS_I(inode);



	vn_trace_entry(vp, __FUNCTION__, (inst_t *)__return_address);

	bhv_vop_rwlock(vp, VRWLOCK_READ);

	bhv_vop_flush_pages(vp, (xfs_off_t)0, -1, 0, FI_REMAPF);

	bhv_vop_rwunlock(vp, VRWLOCK_READ);

	vn_trace_entry(XFS_I(inode), __FUNCTION__,

			(inst_t *)__return_address);

	xfs_rwlock(ip, VRWLOCK_READ);

	xfs_flush_pages(ip, (xfs_off_t)0, -1, 0, FI_REMAPF);

	xfs_rwunlock(ip, VRWLOCK_READ);

	return generic_block_bmap(mapping, block, xfs_get_blocks);

}

fs/xfs/linux-2.6/xfs_aops.h

+1 −1
Original line number Diff line number Diff line
@@ -32,7 +32,7 @@ typedef struct xfs_ioend { 
	unsigned int		io_type;	/* delalloc / unwritten */

	int			io_error;	/* I/O error code */

	atomic_t		io_remaining;	/* hold count */

	struct bhv_vnode	*io_vnode;	/* file being written to */

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

	size_t			io_size;	/* size of the extent */

fs/xfs/linux-2.6/xfs_buf.c

+25 −1
Original line number Diff line number Diff line
@@ -187,6 +187,19 @@ free_address( 
{

	a_list_t	*aentry;



#ifdef CONFIG_XEN

	/*

	 * Xen needs to be able to make sure it can get an exclusive

	 * RO mapping of pages it wants to turn into a pagetable.  If

	 * a newly allocated page is also still being vmap()ed by xfs,

	 * it will cause pagetable construction to fail.  This is a

	 * quick workaround to always eagerly unmap pages so that Xen

	 * is happy.

	 */

	vunmap(addr);

	return;

#endif



	aentry = kmalloc(sizeof(a_list_t), GFP_NOWAIT);

	if (likely(aentry)) {

		spin_lock(&as_lock);
@@ -997,7 +1010,18 @@ xfs_buf_iodone_work( 
	xfs_buf_t		*bp =

		container_of(work, xfs_buf_t, b_iodone_work);



	if (bp->b_iodone)

	/*

	 * We can get an EOPNOTSUPP to ordered writes.  Here we clear the

	 * ordered flag and reissue them.  Because we can't tell the higher

	 * layers directly that they should not issue ordered I/O anymore, they

	 * need to check if the ordered flag was cleared during I/O completion.

	 */

	if ((bp->b_error == EOPNOTSUPP) &&

	    (bp->b_flags & (XBF_ORDERED|XBF_ASYNC)) == (XBF_ORDERED|XBF_ASYNC)) {

		XB_TRACE(bp, "ordered_retry", bp->b_iodone);

		bp->b_flags &= ~XBF_ORDERED;

		xfs_buf_iorequest(bp);

	} else if (bp->b_iodone)

		(*(bp->b_iodone))(bp);

	else if (bp->b_flags & XBF_ASYNC)

		xfs_buf_relse(bp);

fs/xfs/linux-2.6/xfs_export.c

+11 −9
Original line number Diff line number Diff line
@@ -17,12 +17,18 @@ 
 */

#include "xfs.h"

#include "xfs_types.h"

#include "xfs_dmapi.h"

#include "xfs_inum.h"

#include "xfs_log.h"

#include "xfs_trans.h"

#include "xfs_sb.h"

#include "xfs_ag.h"

#include "xfs_dmapi.h"

#include "xfs_mount.h"

#include "xfs_export.h"

#include "xfs_vnodeops.h"

#include "xfs_bmap_btree.h"

#include "xfs_inode.h"

#include "xfs_vfsops.h"



static struct dentry dotdot = { .d_name.name = "..", .d_name.len = 2, };
@@ -96,9 +102,7 @@ xfs_fs_encode_fh( 
	int			len;

	int			is64 = 0;

#if XFS_BIG_INUMS

	bhv_vfs_t		*vfs = vfs_from_sb(inode->i_sb);



	if (!(vfs->vfs_flag & VFS_32BITINODES)) {

	if (!(XFS_M(inode->i_sb)->m_flags & XFS_MOUNT_SMALL_INUMS)) {

		/* filesystem may contain 64bit inode numbers */

		is64 = XFS_FILEID_TYPE_64FLAG;

	}
@@ -138,10 +142,9 @@ xfs_fs_get_dentry( 
	bhv_vnode_t		*vp;

	struct inode		*inode;

	struct dentry		*result;

	bhv_vfs_t		*vfsp = vfs_from_sb(sb);

	int			error;



	error = bhv_vfs_vget(vfsp, &vp, (fid_t *)data);

	error = xfs_vget(XFS_M(sb), &vp, (fid_t *)data);

	if (error || vp == NULL)

		return ERR_PTR(-ESTALE) ;
@@ -159,12 +162,11 @@ xfs_fs_get_parent( 
	struct dentry		*child)

{

	int			error;

	bhv_vnode_t		*vp, *cvp;

	bhv_vnode_t		*cvp;

	struct dentry		*parent;



	cvp = NULL;

	vp = vn_from_inode(child->d_inode);

	error = bhv_vop_lookup(vp, &dotdot, &cvp, 0, NULL, NULL);

	error = xfs_lookup(XFS_I(child->d_inode), &dotdot, &cvp);

	if (unlikely(error))

		return ERR_PTR(-error);