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

Commit 412dd3a6 authored by Linus Torvalds's avatar Linus Torvalds
Browse files

Merge tag 'xfs-for-linus-3.16-rc1' of git://oss.sgi.com/xfs/xfs 

Pull xfs updates from Dave Chinner:
 "This update contains:
   - cleanup removing unused function args
   - rework of the filestreams allocator to use dentry cache parent
     lookups
   - new on-disk free inode btree and optimised inode allocator
   - various bug fixes
   - rework of internal attribute API
   - cleanup of superblock feature bit support to remove historic cruft
   - more fixes and minor cleanups
   - added a new directory/attribute geometry abstraction
   - yet more fixes and minor cleanups"

* tag 'xfs-for-linus-3.16-rc1' of git://oss.sgi.com/xfs/xfs: (86 commits)
  xfs: fix xfs_da_args sparse warning in xfs_readdir
  xfs: Fix rounding in xfs_alloc_fix_len()
  xfs: tone down writepage/releasepage WARN_ONs
  xfs: small cleanup in xfs_lowbit64()
  xfs: kill xfs_buf_geterror()
  xfs: xfs_readsb needs to check for magic numbers
  xfs: block allocation work needs to be kswapd aware
  xfs: remove redundant geometry information from xfs_da_state
  xfs: replace attr LBSIZE with xfs_da_geometry
  xfs: pass xfs_da_args to xfs_attr_leaf_newentsize
  xfs: use xfs_da_geometry for block size in attr code
  xfs: remove mp->m_dir_geo from directory logging
  xfs: reduce direct usage of mp->m_dir_geo
  xfs: move node entry counts to xfs_da_geometry
  xfs: convert dir/attr btree threshold to xfs_da_geometry
  xfs: convert m_dirblksize to xfs_da_geometry
  xfs: convert m_dirblkfsbs to xfs_da_geometry
  xfs: convert directory segment limits to xfs_da_geometry
  xfs: convert directory db conversion to xfs_da_geometry
  xfs: convert directory dablk conversion to xfs_da_geometry
  ...
parents 23d4ed53 7691283d

fs/quota/quota.c

+13 −1
Original line number Diff line number Diff line
@@ -278,6 +278,17 @@ static int quota_getxquota(struct super_block *sb, int type, qid_t id, 
	return ret;

}



static int quota_rmxquota(struct super_block *sb, void __user *addr)

{

	__u32 flags;



	if (copy_from_user(&flags, addr, sizeof(flags)))

		return -EFAULT;

	if (!sb->s_qcop->rm_xquota)

		return -ENOSYS;

	return sb->s_qcop->rm_xquota(sb, flags);

}



/* Copy parameters and call proper function */

static int do_quotactl(struct super_block *sb, int type, int cmd, qid_t id,

		       void __user *addr, struct path *path)
@@ -316,8 +327,9 @@ static int do_quotactl(struct super_block *sb, int type, int cmd, qid_t id, 
		return sb->s_qcop->quota_sync(sb, type);

	case Q_XQUOTAON:

	case Q_XQUOTAOFF:

	case Q_XQUOTARM:

		return quota_setxstate(sb, cmd, addr);

	case Q_XQUOTARM:

		return quota_rmxquota(sb, addr);

	case Q_XGETQSTAT:

		return quota_getxstate(sb, addr);

	case Q_XGETQSTATV:

fs/xfs/xfs_ag.h

+22 −14
Original line number Diff line number Diff line
@@ -160,30 +160,38 @@ typedef struct xfs_agi { 
	 * still being referenced.

	 */

	__be32		agi_unlinked[XFS_AGI_UNLINKED_BUCKETS];



	/*

	 * This marks the end of logging region 1 and start of logging region 2.

	 */

	uuid_t		agi_uuid;	/* uuid of filesystem */

	__be32		agi_crc;	/* crc of agi sector */

	__be32		agi_pad32;

	__be64		agi_lsn;	/* last write sequence */



	__be32		agi_free_root; /* root of the free inode btree */

	__be32		agi_free_level;/* levels in free inode btree */



	/* structure must be padded to 64 bit alignment */

} xfs_agi_t;



#define XFS_AGI_CRC_OFF		offsetof(struct xfs_agi, agi_crc)



#define	XFS_AGI_MAGICNUM	0x00000001

#define	XFS_AGI_VERSIONNUM	0x00000002

#define	XFS_AGI_SEQNO		0x00000004

#define	XFS_AGI_LENGTH		0x00000008

#define	XFS_AGI_COUNT		0x00000010

#define	XFS_AGI_ROOT		0x00000020

#define	XFS_AGI_LEVEL		0x00000040

#define	XFS_AGI_FREECOUNT	0x00000080

#define	XFS_AGI_NEWINO		0x00000100

#define	XFS_AGI_DIRINO		0x00000200

#define	XFS_AGI_UNLINKED	0x00000400

#define	XFS_AGI_NUM_BITS	11

#define	XFS_AGI_ALL_BITS	((1 << XFS_AGI_NUM_BITS) - 1)

#define	XFS_AGI_MAGICNUM	(1 << 0)

#define	XFS_AGI_VERSIONNUM	(1 << 1)

#define	XFS_AGI_SEQNO		(1 << 2)

#define	XFS_AGI_LENGTH		(1 << 3)

#define	XFS_AGI_COUNT		(1 << 4)

#define	XFS_AGI_ROOT		(1 << 5)

#define	XFS_AGI_LEVEL		(1 << 6)

#define	XFS_AGI_FREECOUNT	(1 << 7)

#define	XFS_AGI_NEWINO		(1 << 8)

#define	XFS_AGI_DIRINO		(1 << 9)

#define	XFS_AGI_UNLINKED	(1 << 10)

#define	XFS_AGI_NUM_BITS_R1	11	/* end of the 1st agi logging region */

#define	XFS_AGI_ALL_BITS_R1	((1 << XFS_AGI_NUM_BITS_R1) - 1)

#define	XFS_AGI_FREE_ROOT	(1 << 11)

#define	XFS_AGI_FREE_LEVEL	(1 << 12)

#define	XFS_AGI_NUM_BITS_R2	13



/* disk block (xfs_daddr_t) in the AG */

#define XFS_AGI_DADDR(mp)	((xfs_daddr_t)(2 << (mp)->m_sectbb_log))

fs/xfs/xfs_alloc.c

+8 −11
Original line number Diff line number Diff line
@@ -257,16 +257,14 @@ xfs_alloc_fix_len( 
	k = rlen % args->prod;

	if (k == args->mod)

		return;

	if (k > args->mod) {

		if ((int)(rlen = rlen - k - args->mod) < (int)args->minlen)

			return;

	} else {

		if ((int)(rlen = rlen - args->prod - (args->mod - k)) <

		    (int)args->minlen)

	if (k > args->mod)

		rlen = rlen - (k - args->mod);

	else

		rlen = rlen - args->prod + (args->mod - k);

	if ((int)rlen < (int)args->minlen)

		return;

	}

	ASSERT(rlen >= args->minlen);

	ASSERT(rlen <= args->maxlen);

	ASSERT(rlen >= args->minlen && rlen <= args->maxlen);

	ASSERT(rlen % args->prod == args->mod);

	args->len = rlen;

}
@@ -541,7 +539,6 @@ xfs_alloc_read_agfl( 
			XFS_FSS_TO_BB(mp, 1), 0, &bp, &xfs_agfl_buf_ops);

	if (error)

		return error;

	ASSERT(!xfs_buf_geterror(bp));

	xfs_buf_set_ref(bp, XFS_AGFL_REF);

	*bpp = bp;

	return 0;

fs/xfs/xfs_alloc_btree.c

+0 −1
Original line number Diff line number Diff line
@@ -70,7 +70,6 @@ xfs_allocbt_alloc_block( 
	struct xfs_btree_cur	*cur,

	union xfs_btree_ptr	*start,

	union xfs_btree_ptr	*new,

	int			length,

	int			*stat)

{

	int			error;

fs/xfs/xfs_aops.c

+46 −9
Original line number Diff line number Diff line
@@ -975,14 +975,39 @@ xfs_vm_writepage( 
	 * Given that we do not allow direct reclaim to call us, we should

	 * never be called while in a filesystem transaction.

	 */

	if (WARN_ON(current->flags & PF_FSTRANS))

	if (WARN_ON_ONCE(current->flags & PF_FSTRANS))

		goto redirty;



	/* Is this page beyond the end of the file? */

	offset = i_size_read(inode);

	end_index = offset >> PAGE_CACHE_SHIFT;

	last_index = (offset - 1) >> PAGE_CACHE_SHIFT;

	if (page->index >= end_index) {



	/*

	 * The page index is less than the end_index, adjust the end_offset

	 * to the highest offset that this page should represent.

	 * -----------------------------------------------------

	 * |			file mapping	       | <EOF> |

	 * -----------------------------------------------------

	 * | Page ... | Page N-2 | Page N-1 |  Page N  |       |

	 * ^--------------------------------^----------|--------

	 * |     desired writeback range    |      see else    |

	 * ---------------------------------^------------------|

	 */

	if (page->index < end_index)

		end_offset = (xfs_off_t)(page->index + 1) << PAGE_CACHE_SHIFT;

	else {

		/*

		 * Check whether the page to write out is beyond or straddles

		 * i_size or not.

		 * -------------------------------------------------------

		 * |		file mapping		        | <EOF>  |

		 * -------------------------------------------------------

		 * | Page ... | Page N-2 | Page N-1 |  Page N   | Beyond |

		 * ^--------------------------------^-----------|---------

		 * |				    |      Straddles     |

		 * ---------------------------------^-----------|--------|

		 */

		unsigned offset_into_page = offset & (PAGE_CACHE_SIZE - 1);



		/*
@@ -990,8 +1015,20 @@ xfs_vm_writepage( 
		 * truncate operation that is in progress. We must redirty the

		 * page so that reclaim stops reclaiming it. Otherwise

		 * xfs_vm_releasepage() is called on it and gets confused.

		 *

		 * Note that the end_index is unsigned long, it would overflow

		 * if the given offset is greater than 16TB on 32-bit system

		 * and if we do check the page is fully outside i_size or not

		 * via "if (page->index >= end_index + 1)" as "end_index + 1"

		 * will be evaluated to 0.  Hence this page will be redirtied

		 * and be written out repeatedly which would result in an

		 * infinite loop, the user program that perform this operation

		 * will hang.  Instead, we can verify this situation by checking

		 * if the page to write is totally beyond the i_size or if it's

		 * offset is just equal to the EOF.

		 */

		if (page->index >= end_index + 1 || offset_into_page == 0)

		if (page->index > end_index ||

		    (page->index == end_index && offset_into_page == 0))

			goto redirty;



		/*
@@ -1003,11 +1040,11 @@ xfs_vm_writepage( 
		 * not written out to the file."

		 */

		zero_user_segment(page, offset_into_page, PAGE_CACHE_SIZE);



		/* Adjust the end_offset to the end of file */

		end_offset = offset;

	}



	end_offset = min_t(unsigned long long,

			(xfs_off_t)(page->index + 1) << PAGE_CACHE_SHIFT,

			offset);

	len = 1 << inode->i_blkbits;



	bh = head = page_buffers(page);
@@ -1188,9 +1225,9 @@ xfs_vm_releasepage( 


	xfs_count_page_state(page, &delalloc, &unwritten);



	if (WARN_ON(delalloc))

	if (WARN_ON_ONCE(delalloc))

		return 0;

	if (WARN_ON(unwritten))

	if (WARN_ON_ONCE(unwritten))

		return 0;



	return try_to_free_buffers(page);