Merge tag 'xfs-for-linus-4.1-rc6' of git://git.kernel.org/pub/scm/linux/kernel/git/dgc/linux-xfs (1be44e23) · Commits · 戴 / test

fs/xfs/libxfs/xfs_attr_leaf.c

+4 −4

Original line number	Diff line number	Diff line
		@@ -574,8 +574,8 @@ xfs_attr_shortform_add(xfs_da_args_t *args, int forkoff)
		* After the last attribute is removed revert to original inode format,
		* making all literal area available to the data fork once more.
		*/
		STATIC void
		xfs_attr_fork_reset(
		void
		xfs_attr_fork_remove(
		struct xfs_inode *ip,
		struct xfs_trans *tp)
		{
		@@ -641,7 +641,7 @@ xfs_attr_shortform_remove(xfs_da_args_t *args)
		(mp->m_flags & XFS_MOUNT_ATTR2) &&
		(dp->i_d.di_format != XFS_DINODE_FMT_BTREE) &&
		!(args->op_flags & XFS_DA_OP_ADDNAME)) {
		xfs_attr_fork_reset(dp, args->trans);
		xfs_attr_fork_remove(dp, args->trans);
		} else {
		xfs_idata_realloc(dp, -size, XFS_ATTR_FORK);
		dp->i_d.di_forkoff = xfs_attr_shortform_bytesfit(dp, totsize);
		@@ -905,7 +905,7 @@ xfs_attr3_leaf_to_shortform(
		if (forkoff == -1) {
		ASSERT(dp->i_mount->m_flags & XFS_MOUNT_ATTR2);
		ASSERT(dp->i_d.di_format != XFS_DINODE_FMT_BTREE);
		xfs_attr_fork_reset(dp, args->trans);
		xfs_attr_fork_remove(dp, args->trans);
		goto out;
		}

fs/xfs/libxfs/xfs_attr_leaf.h

+1 −1

Original line number	Diff line number	Diff line
		@@ -53,7 +53,7 @@ int xfs_attr_shortform_remove(struct xfs_da_args *args);
		int xfs_attr_shortform_list(struct xfs_attr_list_context *context);
		int xfs_attr_shortform_allfit(struct xfs_buf bp, struct xfs_inode dp);
		int xfs_attr_shortform_bytesfit(xfs_inode_t *dp, int bytes);

		void xfs_attr_fork_remove(struct xfs_inode ip, struct xfs_trans tp);

		/*
		* Internal routines when attribute fork size == XFS_LBSIZE(mp).

fs/xfs/libxfs/xfs_bmap.c

+19 −12

Original line number	Diff line number	Diff line
		@@ -3224,12 +3224,24 @@ xfs_bmap_extsize_align(
		align_alen += temp;
		align_off -= temp;
		}

		/* Same adjustment for the end of the requested area. */
		temp = (align_alen % extsz);
		if (temp)
		align_alen += extsz - temp;

		/*
		* Same adjustment for the end of the requested area.
		* For large extent hint sizes, the aligned extent might be larger than
		* MAXEXTLEN. In that case, reduce the size by an extsz so that it pulls
		* the length back under MAXEXTLEN. The outer allocation loops handle
		* short allocation just fine, so it is safe to do this. We only want to
		* do it when we are forced to, though, because it means more allocation
		* operations are required.
		*/
		if ((temp = (align_alen % extsz))) {
		align_alen += extsz - temp;
		}
		while (align_alen > MAXEXTLEN)
		align_alen -= extsz;
		ASSERT(align_alen <= MAXEXTLEN);

		/*
		* If the previous block overlaps with this proposed allocation
		* then move the start forward without adjusting the length.
		@@ -3318,7 +3330,9 @@ xfs_bmap_extsize_align(
		return -EINVAL;
		} else {
		ASSERT(orig_off >= align_off);
		ASSERT(orig_end <= align_off + align_alen);
		/* see MAXEXTLEN handling above */
		ASSERT(orig_end <= align_off + align_alen \|\|
		align_alen + extsz > MAXEXTLEN);
		}

		#ifdef DEBUG
		@@ -4099,13 +4113,6 @@ xfs_bmapi_reserve_delalloc(
		/* Figure out the extent size, adjust alen */
		extsz = xfs_get_extsz_hint(ip);
		if (extsz) {
		/*
		* Make sure we don't exceed a single extent length when we
		* align the extent by reducing length we are going to
		* allocate by the maximum amount extent size aligment may
		* require.
		*/
		alen = XFS_FILBLKS_MIN(len, MAXEXTLEN - (2 * extsz - 1));
		error = xfs_bmap_extsize_align(mp, got, prev, extsz, rt, eof,
		1, 0, &aoff, &alen);
		ASSERT(!error);

fs/xfs/libxfs/xfs_ialloc.c

+6 −3

Original line number	Diff line number	Diff line
		@@ -376,7 +376,7 @@ xfs_ialloc_ag_alloc(
		*/
		newlen = args.mp->m_ialloc_inos;
		if (args.mp->m_maxicount &&
		percpu_counter_read(&args.mp->m_icount) + newlen >
		percpu_counter_read_positive(&args.mp->m_icount) + newlen >
		args.mp->m_maxicount)
		return -ENOSPC;
		args.minlen = args.maxlen = args.mp->m_ialloc_blks;
		@@ -1339,10 +1339,13 @@ xfs_dialloc(
		* If we have already hit the ceiling of inode blocks then clear
		* okalloc so we scan all available agi structures for a free
		* inode.
		*
		* Read rough value of mp->m_icount by percpu_counter_read_positive,
		* which will sacrifice the preciseness but improve the performance.
		*/
		if (mp->m_maxicount &&
		percpu_counter_read(&mp->m_icount) + mp->m_ialloc_inos >
		mp->m_maxicount) {
		percpu_counter_read_positive(&mp->m_icount) + mp->m_ialloc_inos
		> mp->m_maxicount) {
		noroom = 1;
		okalloc = 0;
		}

fs/xfs/xfs_attr_inactive.c

+49 −34

Original line number	Diff line number	Diff line
		@@ -380,23 +380,31 @@ xfs_attr3_root_inactive(
		return error;
		}

		/*
		* xfs_attr_inactive kills all traces of an attribute fork on an inode. It
		* removes both the on-disk and in-memory inode fork. Note that this also has to
		* handle the condition of inodes without attributes but with an attribute fork
		* configured, so we can't use xfs_inode_hasattr() here.
		*
		* The in-memory attribute fork is removed even on error.
		*/
		int
		xfs_attr_inactive(xfs_inode_t *dp)
		xfs_attr_inactive(
		struct xfs_inode *dp)
		{
		xfs_trans_t *trans;
		xfs_mount_t *mp;
		int error;
		struct xfs_trans *trans;
		struct xfs_mount *mp;
		int cancel_flags = 0;
		int lock_mode = XFS_ILOCK_SHARED;
		int error = 0;

		mp = dp->i_mount;
		ASSERT(! XFS_NOT_DQATTACHED(mp, dp));

		xfs_ilock(dp, XFS_ILOCK_SHARED);
		if (!xfs_inode_hasattr(dp) \|\|
		dp->i_d.di_aformat == XFS_DINODE_FMT_LOCAL) {
		xfs_iunlock(dp, XFS_ILOCK_SHARED);
		return 0;
		}
		xfs_iunlock(dp, XFS_ILOCK_SHARED);
		xfs_ilock(dp, lock_mode);
		if (!XFS_IFORK_Q(dp))
		goto out_destroy_fork;
		xfs_iunlock(dp, lock_mode);

		/*
		* Start our first transaction of the day.
		@@ -408,13 +416,18 @@ xfs_attr_inactive(xfs_inode_t *dp)
		* the inode in every transaction to let it float upward through
		* the log.
		*/
		lock_mode = 0;
		trans = xfs_trans_alloc(mp, XFS_TRANS_ATTRINVAL);
		error = xfs_trans_reserve(trans, &M_RES(mp)->tr_attrinval, 0, 0);
		if (error) {
		xfs_trans_cancel(trans, 0);
		return error;
		}
		xfs_ilock(dp, XFS_ILOCK_EXCL);
		if (error)
		goto out_cancel;

		lock_mode = XFS_ILOCK_EXCL;
		cancel_flags = XFS_TRANS_RELEASE_LOG_RES \| XFS_TRANS_ABORT;
		xfs_ilock(dp, lock_mode);

		if (!XFS_IFORK_Q(dp))
		goto out_cancel;

		/*
		* No need to make quota reservations here. We expect to release some
		@@ -422,29 +435,31 @@ xfs_attr_inactive(xfs_inode_t *dp)
		*/
		xfs_trans_ijoin(trans, dp, 0);

		/*
		* Decide on what work routines to call based on the inode size.
		*/
		if (!xfs_inode_hasattr(dp) \|\|
		dp->i_d.di_aformat == XFS_DINODE_FMT_LOCAL) {
		error = 0;
		goto out;
		}
		/* invalidate and truncate the attribute fork extents */
		if (dp->i_d.di_aformat != XFS_DINODE_FMT_LOCAL) {
		error = xfs_attr3_root_inactive(&trans, dp);
		if (error)
		goto out;
		goto out_cancel;

		error = xfs_itruncate_extents(&trans, dp, XFS_ATTR_FORK, 0);
		if (error)
		goto out;
		goto out_cancel;
		}

		error = xfs_trans_commit(trans, XFS_TRANS_RELEASE_LOG_RES);
		xfs_iunlock(dp, XFS_ILOCK_EXCL);
		/* Reset the attribute fork - this also destroys the in-core fork */
		xfs_attr_fork_remove(dp, trans);

		error = xfs_trans_commit(trans, XFS_TRANS_RELEASE_LOG_RES);
		xfs_iunlock(dp, lock_mode);
		return error;

		out:
		xfs_trans_cancel(trans, XFS_TRANS_RELEASE_LOG_RES\|XFS_TRANS_ABORT);
		xfs_iunlock(dp, XFS_ILOCK_EXCL);
		out_cancel:
		xfs_trans_cancel(trans, cancel_flags);
		out_destroy_fork:
		/* kill the in-core attr fork before we drop the inode lock */
		if (dp->i_afp)
		xfs_idestroy_fork(dp, XFS_ATTR_FORK);
		if (lock_mode)
		xfs_iunlock(dp, lock_mode);
		return error;
		}

Admin message