Merge branch 'xfs-generic-sb-counters' into for-next (4225441a) · Commits · e / devices / android_kernel_oneplus_sm8150

fs/xfs/libxfs/xfs_bmap.c

+16 −24

Original line number	Diff line number	Diff line
		@@ -2215,9 +2215,8 @@ xfs_bmap_add_extent_delay_real(
		diff = (int)(temp + temp2 - startblockval(PREV.br_startblock) -
		(bma->cur ? bma->cur->bc_private.b.allocated : 0));
		if (diff > 0) {
		error = xfs_icsb_modify_counters(bma->ip->i_mount,
		XFS_SBS_FDBLOCKS,
		-((int64_t)diff), 0);
		error = xfs_mod_fdblocks(bma->ip->i_mount,
		-((int64_t)diff), false);
		ASSERT(!error);
		if (error)
		goto done;
		@@ -2268,9 +2267,8 @@ xfs_bmap_add_extent_delay_real(
		temp += bma->cur->bc_private.b.allocated;
		ASSERT(temp <= da_old);
		if (temp < da_old)
		xfs_icsb_modify_counters(bma->ip->i_mount,
		XFS_SBS_FDBLOCKS,
		(int64_t)(da_old - temp), 0);
		xfs_mod_fdblocks(bma->ip->i_mount,
		(int64_t)(da_old - temp), false);
		}

		/* clear out the allocated field, done with it now in any case. */
		@@ -2948,8 +2946,8 @@ xfs_bmap_add_extent_hole_delay(
		}
		if (oldlen != newlen) {
		ASSERT(oldlen > newlen);
		xfs_icsb_modify_counters(ip->i_mount, XFS_SBS_FDBLOCKS,
		(int64_t)(oldlen - newlen), 0);
		xfs_mod_fdblocks(ip->i_mount, (int64_t)(oldlen - newlen),
		false);
		/*
		* Nothing to do for disk quota accounting here.
		*/
		@@ -4166,18 +4164,15 @@ xfs_bmapi_reserve_delalloc(
		ASSERT(indlen > 0);

		if (rt) {
		error = xfs_mod_incore_sb(mp, XFS_SBS_FREXTENTS,
		-((int64_t)extsz), 0);
		error = xfs_mod_frextents(mp, -((int64_t)extsz));
		} else {
		error = xfs_icsb_modify_counters(mp, XFS_SBS_FDBLOCKS,
		-((int64_t)alen), 0);
		error = xfs_mod_fdblocks(mp, -((int64_t)alen), false);
		}

		if (error)
		goto out_unreserve_quota;

		error = xfs_icsb_modify_counters(mp, XFS_SBS_FDBLOCKS,
		-((int64_t)indlen), 0);
		error = xfs_mod_fdblocks(mp, -((int64_t)indlen), false);
		if (error)
		goto out_unreserve_blocks;

		@@ -4204,9 +4199,9 @@ xfs_bmapi_reserve_delalloc(

		out_unreserve_blocks:
		if (rt)
		xfs_mod_incore_sb(mp, XFS_SBS_FREXTENTS, extsz, 0);
		xfs_mod_frextents(mp, extsz);
		else
		xfs_icsb_modify_counters(mp, XFS_SBS_FDBLOCKS, alen, 0);
		xfs_mod_fdblocks(mp, alen, false);
		out_unreserve_quota:
		if (XFS_IS_QUOTA_ON(mp))
		xfs_trans_unreserve_quota_nblks(NULL, ip, (long)alen, 0, rt ?
		@@ -5019,10 +5014,8 @@ xfs_bmap_del_extent(
		* Nothing to do for disk quota accounting here.
		*/
		ASSERT(da_old >= da_new);
		if (da_old > da_new) {
		xfs_icsb_modify_counters(mp, XFS_SBS_FDBLOCKS,
		(int64_t)(da_old - da_new), 0);
		}
		if (da_old > da_new)
		xfs_mod_fdblocks(mp, (int64_t)(da_old - da_new), false);
		done:
		*logflagsp = flags;
		return error;
		@@ -5291,14 +5284,13 @@ xfs_bunmapi(

		rtexts = XFS_FSB_TO_B(mp, del.br_blockcount);
		do_div(rtexts, mp->m_sb.sb_rextsize);
		xfs_mod_incore_sb(mp, XFS_SBS_FREXTENTS,
		(int64_t)rtexts, 0);
		xfs_mod_frextents(mp, (int64_t)rtexts);
		(void)xfs_trans_reserve_quota_nblks(NULL,
		ip, -((long)del.br_blockcount), 0,
		XFS_QMOPT_RES_RTBLKS);
		} else {
		xfs_icsb_modify_counters(mp, XFS_SBS_FDBLOCKS,
		(int64_t)del.br_blockcount, 0);
		xfs_mod_fdblocks(mp, (int64_t)del.br_blockcount,
		false);
		(void)xfs_trans_reserve_quota_nblks(NULL,
		ip, -((long)del.br_blockcount), 0,
		XFS_QMOPT_RES_REGBLKS);

fs/xfs/libxfs/xfs_format.h

+0 −62

Original line number	Diff line number	Diff line
		@@ -264,68 +264,6 @@ typedef struct xfs_dsb {
		/* must be padded to 64 bit alignment */
		} xfs_dsb_t;

		/*
		* Sequence number values for the fields.
		*/
		typedef enum {
		XFS_SBS_MAGICNUM, XFS_SBS_BLOCKSIZE, XFS_SBS_DBLOCKS, XFS_SBS_RBLOCKS,
		XFS_SBS_REXTENTS, XFS_SBS_UUID, XFS_SBS_LOGSTART, XFS_SBS_ROOTINO,
		XFS_SBS_RBMINO, XFS_SBS_RSUMINO, XFS_SBS_REXTSIZE, XFS_SBS_AGBLOCKS,
		XFS_SBS_AGCOUNT, XFS_SBS_RBMBLOCKS, XFS_SBS_LOGBLOCKS,
		XFS_SBS_VERSIONNUM, XFS_SBS_SECTSIZE, XFS_SBS_INODESIZE,
		XFS_SBS_INOPBLOCK, XFS_SBS_FNAME, XFS_SBS_BLOCKLOG,
		XFS_SBS_SECTLOG, XFS_SBS_INODELOG, XFS_SBS_INOPBLOG, XFS_SBS_AGBLKLOG,
		XFS_SBS_REXTSLOG, XFS_SBS_INPROGRESS, XFS_SBS_IMAX_PCT, XFS_SBS_ICOUNT,
		XFS_SBS_IFREE, XFS_SBS_FDBLOCKS, XFS_SBS_FREXTENTS, XFS_SBS_UQUOTINO,
		XFS_SBS_GQUOTINO, XFS_SBS_QFLAGS, XFS_SBS_FLAGS, XFS_SBS_SHARED_VN,
		XFS_SBS_INOALIGNMT, XFS_SBS_UNIT, XFS_SBS_WIDTH, XFS_SBS_DIRBLKLOG,
		XFS_SBS_LOGSECTLOG, XFS_SBS_LOGSECTSIZE, XFS_SBS_LOGSUNIT,
		XFS_SBS_FEATURES2, XFS_SBS_BAD_FEATURES2, XFS_SBS_FEATURES_COMPAT,
		XFS_SBS_FEATURES_RO_COMPAT, XFS_SBS_FEATURES_INCOMPAT,
		XFS_SBS_FEATURES_LOG_INCOMPAT, XFS_SBS_CRC, XFS_SBS_PAD,
		XFS_SBS_PQUOTINO, XFS_SBS_LSN,
		XFS_SBS_FIELDCOUNT
		} xfs_sb_field_t;

		/*
		* Mask values, defined based on the xfs_sb_field_t values.
		* Only define the ones we're using.
		*/
		#define XFS_SB_MVAL(x) (1LL << XFS_SBS_ ## x)
		#define XFS_SB_UUID XFS_SB_MVAL(UUID)
		#define XFS_SB_FNAME XFS_SB_MVAL(FNAME)
		#define XFS_SB_ROOTINO XFS_SB_MVAL(ROOTINO)
		#define XFS_SB_RBMINO XFS_SB_MVAL(RBMINO)
		#define XFS_SB_RSUMINO XFS_SB_MVAL(RSUMINO)
		#define XFS_SB_VERSIONNUM XFS_SB_MVAL(VERSIONNUM)
		#define XFS_SB_UQUOTINO XFS_SB_MVAL(UQUOTINO)
		#define XFS_SB_GQUOTINO XFS_SB_MVAL(GQUOTINO)
		#define XFS_SB_QFLAGS XFS_SB_MVAL(QFLAGS)
		#define XFS_SB_SHARED_VN XFS_SB_MVAL(SHARED_VN)
		#define XFS_SB_UNIT XFS_SB_MVAL(UNIT)
		#define XFS_SB_WIDTH XFS_SB_MVAL(WIDTH)
		#define XFS_SB_ICOUNT XFS_SB_MVAL(ICOUNT)
		#define XFS_SB_IFREE XFS_SB_MVAL(IFREE)
		#define XFS_SB_FDBLOCKS XFS_SB_MVAL(FDBLOCKS)
		#define XFS_SB_FEATURES2 (XFS_SB_MVAL(FEATURES2) \| \
		XFS_SB_MVAL(BAD_FEATURES2))
		#define XFS_SB_FEATURES_COMPAT XFS_SB_MVAL(FEATURES_COMPAT)
		#define XFS_SB_FEATURES_RO_COMPAT XFS_SB_MVAL(FEATURES_RO_COMPAT)
		#define XFS_SB_FEATURES_INCOMPAT XFS_SB_MVAL(FEATURES_INCOMPAT)
		#define XFS_SB_FEATURES_LOG_INCOMPAT XFS_SB_MVAL(FEATURES_LOG_INCOMPAT)
		#define XFS_SB_CRC XFS_SB_MVAL(CRC)
		#define XFS_SB_PQUOTINO XFS_SB_MVAL(PQUOTINO)
		#define XFS_SB_NUM_BITS ((int)XFS_SBS_FIELDCOUNT)
		#define XFS_SB_ALL_BITS ((1LL << XFS_SB_NUM_BITS) - 1)
		#define XFS_SB_MOD_BITS \
		(XFS_SB_UUID \| XFS_SB_ROOTINO \| XFS_SB_RBMINO \| XFS_SB_RSUMINO \| \
		XFS_SB_VERSIONNUM \| XFS_SB_UQUOTINO \| XFS_SB_GQUOTINO \| \
		XFS_SB_QFLAGS \| XFS_SB_SHARED_VN \| XFS_SB_UNIT \| XFS_SB_WIDTH \| \
		XFS_SB_ICOUNT \| XFS_SB_IFREE \| XFS_SB_FDBLOCKS \| XFS_SB_FEATURES2 \| \
		XFS_SB_FEATURES_COMPAT \| XFS_SB_FEATURES_RO_COMPAT \| \
		XFS_SB_FEATURES_INCOMPAT \| XFS_SB_FEATURES_LOG_INCOMPAT \| \
		XFS_SB_PQUOTINO)


		/*
		* Misc. Flags - warning - these will be cleared by xfs_repair unless

fs/xfs/libxfs/xfs_ialloc.c

+4 −2

Original line number	Diff line number	Diff line
		@@ -376,7 +376,8 @@ xfs_ialloc_ag_alloc(
		*/
		newlen = args.mp->m_ialloc_inos;
		if (args.mp->m_maxicount &&
		args.mp->m_sb.sb_icount + newlen > args.mp->m_maxicount)
		percpu_counter_read(&args.mp->m_icount) + newlen >
		args.mp->m_maxicount)
		return -ENOSPC;
		args.minlen = args.maxlen = args.mp->m_ialloc_blks;
		/*
		@@ -1340,7 +1341,8 @@ xfs_dialloc(
		* inode.
		*/
		if (mp->m_maxicount &&
		mp->m_sb.sb_icount + mp->m_ialloc_inos > mp->m_maxicount) {
		percpu_counter_read(&mp->m_icount) + mp->m_ialloc_inos >
		mp->m_maxicount) {
		noroom = 1;
		okalloc = 0;
		}

fs/xfs/libxfs/xfs_sb.c

+7 −5

Original line number	Diff line number	Diff line
		@@ -735,17 +735,15 @@ xfs_initialize_perag_data(
		btree += pag->pagf_btreeblks;
		xfs_perag_put(pag);
		}
		/*
		* Overwrite incore superblock counters with just-read data
		*/

		/* Overwrite incore superblock counters with just-read data */
		spin_lock(&mp->m_sb_lock);
		sbp->sb_ifree = ifree;
		sbp->sb_icount = ialloc;
		sbp->sb_fdblocks = bfree + bfreelst + btree;
		spin_unlock(&mp->m_sb_lock);

		/* Fixup the per-cpu counters as well. */
		xfs_icsb_reinit_counters(mp);
		xfs_reinit_percpu_counters(mp);

		return 0;
		}
		@@ -763,6 +761,10 @@ xfs_log_sb(
		struct xfs_mount *mp = tp->t_mountp;
		struct xfs_buf *bp = xfs_trans_getsb(tp, mp, 0);

		mp->m_sb.sb_icount = percpu_counter_sum(&mp->m_icount);
		mp->m_sb.sb_ifree = percpu_counter_sum(&mp->m_ifree);
		mp->m_sb.sb_fdblocks = percpu_counter_sum(&mp->m_fdblocks);

		xfs_sb_to_disk(XFS_BUF_TO_SBP(bp), &mp->m_sb);
		xfs_trans_buf_set_type(tp, bp, XFS_BLFT_SB_BUF);
		xfs_trans_log_buf(tp, bp, 0, sizeof(struct xfs_dsb));

fs/xfs/xfs_fsops.c

+8 −12

Original line number	Diff line number	Diff line
		@@ -637,12 +637,13 @@ xfs_fs_counts(
		xfs_mount_t *mp,
		xfs_fsop_counts_t *cnt)
		{
		xfs_icsb_sync_counters(mp, XFS_ICSB_LAZY_COUNT);
		cnt->allocino = percpu_counter_read_positive(&mp->m_icount);
		cnt->freeino = percpu_counter_read_positive(&mp->m_ifree);
		cnt->freedata = percpu_counter_read_positive(&mp->m_fdblocks) -
		XFS_ALLOC_SET_ASIDE(mp);

		spin_lock(&mp->m_sb_lock);
		cnt->freedata = mp->m_sb.sb_fdblocks - XFS_ALLOC_SET_ASIDE(mp);
		cnt->freertx = mp->m_sb.sb_frextents;
		cnt->freeino = mp->m_sb.sb_ifree;
		cnt->allocino = mp->m_sb.sb_icount;
		spin_unlock(&mp->m_sb_lock);
		return 0;
		}
		@@ -692,14 +693,9 @@ xfs_reserve_blocks(
		* what to do. This means that the amount of free space can
		* change while we do this, so we need to retry if we end up
		* trying to reserve more space than is available.
		*
		* We also use the xfs_mod_incore_sb() interface so that we
		* don't have to care about whether per cpu counter are
		* enabled, disabled or even compiled in....
		*/
		retry:
		spin_lock(&mp->m_sb_lock);
		xfs_icsb_sync_counters_locked(mp, 0);

		/*
		* If our previous reservation was larger than the current value,
		@@ -716,7 +712,8 @@ xfs_reserve_blocks(
		} else {
		__int64_t free;

		free = mp->m_sb.sb_fdblocks - XFS_ALLOC_SET_ASIDE(mp);
		free = percpu_counter_sum(&mp->m_fdblocks) -
		XFS_ALLOC_SET_ASIDE(mp);
		if (!free)
		goto out; /* ENOSPC and fdblks_delta = 0 */

		@@ -755,8 +752,7 @@ xfs_reserve_blocks(
		* the extra reserve blocks from the reserve.....
		*/
		int error;
		error = xfs_icsb_modify_counters(mp, XFS_SBS_FDBLOCKS,
		fdblks_delta, 0);
		error = xfs_mod_fdblocks(mp, fdblks_delta, 0);
		if (error == -ENOSPC)
		goto retry;
		}