[mirror_ubuntu-zesty-kernel.git] / fs / xfs / xfs_stats.h

/*
 * Copyright (c) 2000,2005 Silicon Graphics, Inc.
 * All Rights Reserved.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License as
 * published by the Free Software Foundation.
 *
 * This program is distributed in the hope that it would be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write the Free Software Foundation,
 * Inc.,  51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 */
#ifndef __XFS_STATS_H__
#define __XFS_STATS_H__


#include <linux/percpu.h>

/*
 * The btree stats arrays have fixed offsets for the different stats. We
 * store the base index in the btree cursor via XFS_STATS_CALC_INDEX() and
 * that allows us to use fixed offsets into the stats array for each btree
 * stat. These index offsets are defined in the order they will be emitted
 * in the stats files, so it is possible to add new btree stat types by
 * appending to the enum list below.
 */
enum {
	__XBTS_lookup = 0,
	__XBTS_compare = 1,
	__XBTS_insrec = 2,
	__XBTS_delrec = 3,
	__XBTS_newroot = 4,
	__XBTS_killroot = 5,
	__XBTS_increment = 6,
	__XBTS_decrement = 7,
	__XBTS_lshift = 8,
	__XBTS_rshift = 9,
	__XBTS_split = 10,
	__XBTS_join = 11,
	__XBTS_alloc = 12,
	__XBTS_free = 13,
	__XBTS_moves = 14,

	__XBTS_MAX = 15,
};

/*
 * XFS global statistics
 */
struct __xfsstats {
# define XFSSTAT_END_EXTENT_ALLOC	4
	__uint32_t		xs_allocx;
	__uint32_t		xs_allocb;
	__uint32_t		xs_freex;
	__uint32_t		xs_freeb;
# define XFSSTAT_END_ALLOC_BTREE	(XFSSTAT_END_EXTENT_ALLOC+4)
	__uint32_t		xs_abt_lookup;
	__uint32_t		xs_abt_compare;
	__uint32_t		xs_abt_insrec;
	__uint32_t		xs_abt_delrec;
# define XFSSTAT_END_BLOCK_MAPPING	(XFSSTAT_END_ALLOC_BTREE+7)
	__uint32_t		xs_blk_mapr;
	__uint32_t		xs_blk_mapw;
	__uint32_t		xs_blk_unmap;
	__uint32_t		xs_add_exlist;
	__uint32_t		xs_del_exlist;
	__uint32_t		xs_look_exlist;
	__uint32_t		xs_cmp_exlist;
# define XFSSTAT_END_BLOCK_MAP_BTREE	(XFSSTAT_END_BLOCK_MAPPING+4)
	__uint32_t		xs_bmbt_lookup;
	__uint32_t		xs_bmbt_compare;
	__uint32_t		xs_bmbt_insrec;
	__uint32_t		xs_bmbt_delrec;
# define XFSSTAT_END_DIRECTORY_OPS	(XFSSTAT_END_BLOCK_MAP_BTREE+4)
	__uint32_t		xs_dir_lookup;
	__uint32_t		xs_dir_create;
	__uint32_t		xs_dir_remove;
	__uint32_t		xs_dir_getdents;
# define XFSSTAT_END_TRANSACTIONS	(XFSSTAT_END_DIRECTORY_OPS+3)
	__uint32_t		xs_trans_sync;
	__uint32_t		xs_trans_async;
	__uint32_t		xs_trans_empty;
# define XFSSTAT_END_INODE_OPS		(XFSSTAT_END_TRANSACTIONS+7)
	__uint32_t		xs_ig_attempts;
	__uint32_t		xs_ig_found;
	__uint32_t		xs_ig_frecycle;
	__uint32_t		xs_ig_missed;
	__uint32_t		xs_ig_dup;
	__uint32_t		xs_ig_reclaims;
	__uint32_t		xs_ig_attrchg;
# define XFSSTAT_END_LOG_OPS		(XFSSTAT_END_INODE_OPS+5)
	__uint32_t		xs_log_writes;
	__uint32_t		xs_log_blocks;
	__uint32_t		xs_log_noiclogs;
	__uint32_t		xs_log_force;
	__uint32_t		xs_log_force_sleep;
# define XFSSTAT_END_TAIL_PUSHING	(XFSSTAT_END_LOG_OPS+10)
	__uint32_t		xs_try_logspace;
	__uint32_t		xs_sleep_logspace;
	__uint32_t		xs_push_ail;
	__uint32_t		xs_push_ail_success;
	__uint32_t		xs_push_ail_pushbuf;
	__uint32_t		xs_push_ail_pinned;
	__uint32_t		xs_push_ail_locked;
	__uint32_t		xs_push_ail_flushing;
	__uint32_t		xs_push_ail_restarts;
	__uint32_t		xs_push_ail_flush;
# define XFSSTAT_END_WRITE_CONVERT	(XFSSTAT_END_TAIL_PUSHING+2)
	__uint32_t		xs_xstrat_quick;
	__uint32_t		xs_xstrat_split;
# define XFSSTAT_END_READ_WRITE_OPS	(XFSSTAT_END_WRITE_CONVERT+2)
	__uint32_t		xs_write_calls;
	__uint32_t		xs_read_calls;
# define XFSSTAT_END_ATTRIBUTE_OPS	(XFSSTAT_END_READ_WRITE_OPS+4)
	__uint32_t		xs_attr_get;
	__uint32_t		xs_attr_set;
	__uint32_t		xs_attr_remove;
	__uint32_t		xs_attr_list;
# define XFSSTAT_END_INODE_CLUSTER	(XFSSTAT_END_ATTRIBUTE_OPS+3)
	__uint32_t		xs_iflush_count;
	__uint32_t		xs_icluster_flushcnt;
	__uint32_t		xs_icluster_flushinode;
# define XFSSTAT_END_VNODE_OPS		(XFSSTAT_END_INODE_CLUSTER+8)
	__uint32_t		vn_active;	/* # vnodes not on free lists */
	__uint32_t		vn_alloc;	/* # times vn_alloc called */
	__uint32_t		vn_get;		/* # times vn_get called */
	__uint32_t		vn_hold;	/* # times vn_hold called */
	__uint32_t		vn_rele;	/* # times vn_rele called */
	__uint32_t		vn_reclaim;	/* # times vn_reclaim called */
	__uint32_t		vn_remove;	/* # times vn_remove called */
	__uint32_t		vn_free;	/* # times vn_free called */
#define XFSSTAT_END_BUF			(XFSSTAT_END_VNODE_OPS+9)
	__uint32_t		xb_get;
	__uint32_t		xb_create;
	__uint32_t		xb_get_locked;
	__uint32_t		xb_get_locked_waited;
	__uint32_t		xb_busy_locked;
	__uint32_t		xb_miss_locked;
	__uint32_t		xb_page_retries;
	__uint32_t		xb_page_found;
	__uint32_t		xb_get_read;
/* Version 2 btree counters */
#define XFSSTAT_END_ABTB_V2		(XFSSTAT_END_BUF + __XBTS_MAX)
	__uint32_t		xs_abtb_2[__XBTS_MAX];
#define XFSSTAT_END_ABTC_V2		(XFSSTAT_END_ABTB_V2 + __XBTS_MAX)
	__uint32_t		xs_abtc_2[__XBTS_MAX];
#define XFSSTAT_END_BMBT_V2		(XFSSTAT_END_ABTC_V2 + __XBTS_MAX)
	__uint32_t		xs_bmbt_2[__XBTS_MAX];
#define XFSSTAT_END_IBT_V2		(XFSSTAT_END_BMBT_V2 + __XBTS_MAX)
	__uint32_t		xs_ibt_2[__XBTS_MAX];
#define XFSSTAT_END_FIBT_V2		(XFSSTAT_END_IBT_V2 + __XBTS_MAX)
	__uint32_t		xs_fibt_2[__XBTS_MAX];
#define XFSSTAT_END_RMAP_V2		(XFSSTAT_END_FIBT_V2 + __XBTS_MAX)
	__uint32_t		xs_rmap_2[__XBTS_MAX];
#define XFSSTAT_END_REFCOUNT		(XFSSTAT_END_RMAP_V2 + __XBTS_MAX)
	__uint32_t		xs_refcbt_2[__XBTS_MAX];
#define XFSSTAT_END_XQMSTAT		(XFSSTAT_END_REFCOUNT + 6)
	__uint32_t		xs_qm_dqreclaims;
	__uint32_t		xs_qm_dqreclaim_misses;
	__uint32_t		xs_qm_dquot_dups;
	__uint32_t		xs_qm_dqcachemisses;
	__uint32_t		xs_qm_dqcachehits;
	__uint32_t		xs_qm_dqwants;
#define XFSSTAT_END_QM			(XFSSTAT_END_XQMSTAT+2)
	__uint32_t		xs_qm_dquot;
	__uint32_t		xs_qm_dquot_unused;
/* Extra precision counters */
	__uint64_t		xs_xstrat_bytes;
	__uint64_t		xs_write_bytes;
	__uint64_t		xs_read_bytes;
};

struct xfsstats {
	union {
		struct __xfsstats	s;
		uint32_t		a[XFSSTAT_END_XQMSTAT];
	};
};

/*
 * simple wrapper for getting the array index of s struct member offset
 */
#define XFS_STATS_CALC_INDEX(member)	\
	(offsetof(struct __xfsstats, member) / (int)sizeof(__uint32_t))


int xfs_stats_format(struct xfsstats __percpu *stats, char *buf);
void xfs_stats_clearall(struct xfsstats __percpu *stats);
extern struct xstats xfsstats;

#define XFS_STATS_INC(mp, v)					\
do {								\
	per_cpu_ptr(xfsstats.xs_stats, current_cpu())->s.v++;	\
	per_cpu_ptr(mp->m_stats.xs_stats, current_cpu())->s.v++;	\
} while (0)

#define XFS_STATS_DEC(mp, v)					\
do {								\
	per_cpu_ptr(xfsstats.xs_stats, current_cpu())->s.v--;	\
	per_cpu_ptr(mp->m_stats.xs_stats, current_cpu())->s.v--;	\
} while (0)

#define XFS_STATS_ADD(mp, v, inc)					\
do {									\
	per_cpu_ptr(xfsstats.xs_stats, current_cpu())->s.v += (inc);	\
	per_cpu_ptr(mp->m_stats.xs_stats, current_cpu())->s.v += (inc);	\
} while (0)

#define XFS_STATS_INC_OFF(mp, off)				\
do {								\
	per_cpu_ptr(xfsstats.xs_stats, current_cpu())->a[off]++;	\
	per_cpu_ptr(mp->m_stats.xs_stats, current_cpu())->a[off]++;	\
} while (0)

#define XFS_STATS_DEC_OFF(mp, off)					\
do {								\
	per_cpu_ptr(xfsstats.xs_stats, current_cpu())->a[off];	\
	per_cpu_ptr(mp->m_stats.xs_stats, current_cpu())->a[off];	\
} while (0)

#define XFS_STATS_ADD_OFF(mp, off, inc)					\
do {									\
	per_cpu_ptr(xfsstats.xs_stats, current_cpu())->a[off] += (inc);	\
	per_cpu_ptr(mp->m_stats.xs_stats, current_cpu())->a[off] += (inc);	\
} while (0)

#if defined(CONFIG_PROC_FS)

extern int xfs_init_procfs(void);
extern void xfs_cleanup_procfs(void);


#else	/* !CONFIG_PROC_FS */

static inline int xfs_init_procfs(void)
{
	return 0;
}

static inline void xfs_cleanup_procfs(void)
{
}

#endif	/* !CONFIG_PROC_FS */

#endif /* __XFS_STATS_H__ */
Commit	Line	Data
1da177e4	1	/*
7b718769 NS	2	* Copyright (c) 2000,2005 Silicon Graphics, Inc.
7b718769 NS	3	* All Rights Reserved.
1da177e4	4	*
7b718769 NS	5	* This program is free software; you can redistribute it and/or
7b718769 NS	6	* modify it under the terms of the GNU General Public License as
1da177e4 LT	7	* published by the Free Software Foundation.
1da177e4 LT	8	*
7b718769 NS	9	* This program is distributed in the hope that it would be useful,
	10	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	11	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	12	* GNU General Public License for more details.
1da177e4	13	*
7b718769 NS	14	* You should have received a copy of the GNU General Public License
	15	* along with this program; if not, write the Free Software Foundation,
	16	* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
1da177e4 LT	17	*/
	18	#ifndef __XFS_STATS_H__
	19	#define __XFS_STATS_H__
	20
1da177e4 LT	21
	22	#include <linux/percpu.h>
	23
11ef38af DC	24	/*
	25	* The btree stats arrays have fixed offsets for the different stats. We
	26	* store the base index in the btree cursor via XFS_STATS_CALC_INDEX() and
	27	* that allows us to use fixed offsets into the stats array for each btree
	28	* stat. These index offsets are defined in the order they will be emitted
	29	* in the stats files, so it is possible to add new btree stat types by
	30	* appending to the enum list below.
	31	*/
	32	enum {
	33	__XBTS_lookup = 0,
	34	__XBTS_compare = 1,
	35	__XBTS_insrec = 2,
	36	__XBTS_delrec = 3,
	37	__XBTS_newroot = 4,
	38	__XBTS_killroot = 5,
	39	__XBTS_increment = 6,
	40	__XBTS_decrement = 7,
	41	__XBTS_lshift = 8,
	42	__XBTS_rshift = 9,
	43	__XBTS_split = 10,
	44	__XBTS_join = 11,
	45	__XBTS_alloc = 12,
	46	__XBTS_free = 13,
	47	__XBTS_moves = 14,
	48
	49	__XBTS_MAX = 15,
	50	};
	51
1da177e4 LT	52	/*
	53	* XFS global statistics
	54	*/
11ef38af	55	struct __xfsstats {
1da177e4 LT	56	# define XFSSTAT_END_EXTENT_ALLOC 4
	57	__uint32_t xs_allocx;
	58	__uint32_t xs_allocb;
	59	__uint32_t xs_freex;
	60	__uint32_t xs_freeb;
	61	# define XFSSTAT_END_ALLOC_BTREE (XFSSTAT_END_EXTENT_ALLOC+4)
	62	__uint32_t xs_abt_lookup;
	63	__uint32_t xs_abt_compare;
	64	__uint32_t xs_abt_insrec;
	65	__uint32_t xs_abt_delrec;
	66	# define XFSSTAT_END_BLOCK_MAPPING (XFSSTAT_END_ALLOC_BTREE+7)
	67	__uint32_t xs_blk_mapr;
	68	__uint32_t xs_blk_mapw;
	69	__uint32_t xs_blk_unmap;
	70	__uint32_t xs_add_exlist;
	71	__uint32_t xs_del_exlist;
	72	__uint32_t xs_look_exlist;
	73	__uint32_t xs_cmp_exlist;
	74	# define XFSSTAT_END_BLOCK_MAP_BTREE (XFSSTAT_END_BLOCK_MAPPING+4)
	75	__uint32_t xs_bmbt_lookup;
	76	__uint32_t xs_bmbt_compare;
	77	__uint32_t xs_bmbt_insrec;
	78	__uint32_t xs_bmbt_delrec;
	79	# define XFSSTAT_END_DIRECTORY_OPS (XFSSTAT_END_BLOCK_MAP_BTREE+4)
	80	__uint32_t xs_dir_lookup;
	81	__uint32_t xs_dir_create;
	82	__uint32_t xs_dir_remove;
	83	__uint32_t xs_dir_getdents;
	84	# define XFSSTAT_END_TRANSACTIONS (XFSSTAT_END_DIRECTORY_OPS+3)
	85	__uint32_t xs_trans_sync;
	86	__uint32_t xs_trans_async;
	87	__uint32_t xs_trans_empty;
	88	# define XFSSTAT_END_INODE_OPS (XFSSTAT_END_TRANSACTIONS+7)
	89	__uint32_t xs_ig_attempts;
	90	__uint32_t xs_ig_found;
	91	__uint32_t xs_ig_frecycle;
	92	__uint32_t xs_ig_missed;
	93	__uint32_t xs_ig_dup;
	94	__uint32_t xs_ig_reclaims;
	95	__uint32_t xs_ig_attrchg;
	96	# define XFSSTAT_END_LOG_OPS (XFSSTAT_END_INODE_OPS+5)
	97	__uint32_t xs_log_writes;
	98	__uint32_t xs_log_blocks;
	99	__uint32_t xs_log_noiclogs;
	100	__uint32_t xs_log_force;
	101	__uint32_t xs_log_force_sleep;
	102	# define XFSSTAT_END_TAIL_PUSHING (XFSSTAT_END_LOG_OPS+10)
	103	__uint32_t xs_try_logspace;
	104	__uint32_t xs_sleep_logspace;
	105	__uint32_t xs_push_ail;
	106	__uint32_t xs_push_ail_success;
	107	__uint32_t xs_push_ail_pushbuf;
	108	__uint32_t xs_push_ail_pinned;
	109	__uint32_t xs_push_ail_locked;
	110	__uint32_t xs_push_ail_flushing;
	111	__uint32_t xs_push_ail_restarts;
	112	__uint32_t xs_push_ail_flush;
	113	# define XFSSTAT_END_WRITE_CONVERT (XFSSTAT_END_TAIL_PUSHING+2)
	114	__uint32_t xs_xstrat_quick;
	115	__uint32_t xs_xstrat_split;
	116	# define XFSSTAT_END_READ_WRITE_OPS (XFSSTAT_END_WRITE_CONVERT+2)
	117	__uint32_t xs_write_calls;
	118	__uint32_t xs_read_calls;
	119	# define XFSSTAT_END_ATTRIBUTE_OPS (XFSSTAT_END_READ_WRITE_OPS+4)
120	__uint32_t xs_attr_get;
121	__uint32_t xs_attr_set;
122	__uint32_t xs_attr_remove;
123	__uint32_t xs_attr_list;
124	# define XFSSTAT_END_INODE_CLUSTER (XFSSTAT_END_ATTRIBUTE_OPS+3)
125	__uint32_t xs_iflush_count;
126	__uint32_t xs_icluster_flushcnt;
127	__uint32_t xs_icluster_flushinode;
128	# define XFSSTAT_END_VNODE_OPS (XFSSTAT_END_INODE_CLUSTER+8)
129	__uint32_t vn_active; /* # vnodes not on free lists */
130	__uint32_t vn_alloc; /* # times vn_alloc called */
131	__uint32_t vn_get; /* # times vn_get called */
132	__uint32_t vn_hold; /* # times vn_hold called */
133	__uint32_t vn_rele; /* # times vn_rele called */
134	__uint32_t vn_reclaim; /* # times vn_reclaim called */
135	__uint32_t vn_remove; /* # times vn_remove called */
136	__uint32_t vn_free; /* # times vn_free called */
137	#define XFSSTAT_END_BUF (XFSSTAT_END_VNODE_OPS+9)
ce8e922c NS	138	__uint32_t xb_get;
	139	__uint32_t xb_create;
	140	__uint32_t xb_get_locked;
	141	__uint32_t xb_get_locked_waited;
	142	__uint32_t xb_busy_locked;
	143	__uint32_t xb_miss_locked;
	144	__uint32_t xb_page_retries;
	145	__uint32_t xb_page_found;
	146	__uint32_t xb_get_read;
854929f0	147	/* Version 2 btree counters */
11ef38af DC	148	#define XFSSTAT_END_ABTB_V2 (XFSSTAT_END_BUF + __XBTS_MAX)
	149	__uint32_t xs_abtb_2[__XBTS_MAX];
	150	#define XFSSTAT_END_ABTC_V2 (XFSSTAT_END_ABTB_V2 + __XBTS_MAX)
	151	__uint32_t xs_abtc_2[__XBTS_MAX];
	152	#define XFSSTAT_END_BMBT_V2 (XFSSTAT_END_ABTC_V2 + __XBTS_MAX)
	153	__uint32_t xs_bmbt_2[__XBTS_MAX];
	154	#define XFSSTAT_END_IBT_V2 (XFSSTAT_END_BMBT_V2 + __XBTS_MAX)
	155	__uint32_t xs_ibt_2[__XBTS_MAX];
	156	#define XFSSTAT_END_FIBT_V2 (XFSSTAT_END_IBT_V2 + __XBTS_MAX)
	157	__uint32_t xs_fibt_2[__XBTS_MAX];
	158	#define XFSSTAT_END_RMAP_V2 (XFSSTAT_END_FIBT_V2 + __XBTS_MAX)
	159	__uint32_t xs_rmap_2[__XBTS_MAX];
	160	#define XFSSTAT_END_REFCOUNT (XFSSTAT_END_RMAP_V2 + __XBTS_MAX)
	161	__uint32_t xs_refcbt_2[__XBTS_MAX];
46eeb521	162	#define XFSSTAT_END_XQMSTAT (XFSSTAT_END_REFCOUNT + 6)
48776fd2 CH	163	__uint32_t xs_qm_dqreclaims;
	164	__uint32_t xs_qm_dqreclaim_misses;
	165	__uint32_t xs_qm_dquot_dups;
	166	__uint32_t xs_qm_dqcachemisses;
	167	__uint32_t xs_qm_dqcachehits;
	168	__uint32_t xs_qm_dqwants;
	169	#define XFSSTAT_END_QM (XFSSTAT_END_XQMSTAT+2)
	170	__uint32_t xs_qm_dquot;
	171	__uint32_t xs_qm_dquot_unused;
1da177e4 LT	172	/* Extra precision counters */
	173	__uint64_t xs_xstrat_bytes;
	174	__uint64_t xs_write_bytes;
	175	__uint64_t xs_read_bytes;
	176	};
	177
11ef38af DC	178	struct xfsstats {
	179	union {
	180	struct __xfsstats s;
	181	uint32_t a[XFSSTAT_END_XQMSTAT];
	182	};
	183	};
	184
	185	/*
	186	* simple wrapper for getting the array index of s struct member offset
	187	*/
	188	#define XFS_STATS_CALC_INDEX(member) \
	189	(offsetof(struct __xfsstats, member) / (int)sizeof(__uint32_t))
	190
	191
80529c45 BD	192	int xfs_stats_format(struct xfsstats __percpu stats, char buf);
	193	void xfs_stats_clearall(struct xfsstats __percpu *stats);
	194	extern struct xstats xfsstats;
1da177e4	195
ff6d6af2 BD	196	#define XFS_STATS_INC(mp, v) \
ff6d6af2 BD	197	do { \
11ef38af DC	198	per_cpu_ptr(xfsstats.xs_stats, current_cpu())->s.v++; \
11ef38af DC	199	per_cpu_ptr(mp->m_stats.xs_stats, current_cpu())->s.v++; \
ff6d6af2	200	} while (0)
80529c45	201
ff6d6af2 BD	202	#define XFS_STATS_DEC(mp, v) \
ff6d6af2 BD	203	do { \
11ef38af DC	204	per_cpu_ptr(xfsstats.xs_stats, current_cpu())->s.v--; \
11ef38af DC	205	per_cpu_ptr(mp->m_stats.xs_stats, current_cpu())->s.v--; \
ff6d6af2	206	} while (0)
80529c45	207
ff6d6af2 BD	208	#define XFS_STATS_ADD(mp, v, inc) \
ff6d6af2 BD	209	do { \
11ef38af DC	210	per_cpu_ptr(xfsstats.xs_stats, current_cpu())->s.v += (inc); \
	211	per_cpu_ptr(mp->m_stats.xs_stats, current_cpu())->s.v += (inc); \
	212	} while (0)
	213
	214	#define XFS_STATS_INC_OFF(mp, off) \
	215	do { \
	216	per_cpu_ptr(xfsstats.xs_stats, current_cpu())->a[off]++; \
	217	per_cpu_ptr(mp->m_stats.xs_stats, current_cpu())->a[off]++; \
	218	} while (0)
	219
	220	#define XFS_STATS_DEC_OFF(mp, off) \
	221	do { \
	222	per_cpu_ptr(xfsstats.xs_stats, current_cpu())->a[off]; \
	223	per_cpu_ptr(mp->m_stats.xs_stats, current_cpu())->a[off]; \
	224	} while (0)
	225
	226	#define XFS_STATS_ADD_OFF(mp, off, inc) \
	227	do { \
	228	per_cpu_ptr(xfsstats.xs_stats, current_cpu())->a[off] += (inc); \
	229	per_cpu_ptr(mp->m_stats.xs_stats, current_cpu())->a[off] += (inc); \
ff6d6af2 BD	230	} while (0)
	231
	232	#if defined(CONFIG_PROC_FS)
1da177e4	233
9f8868ff	234	extern int xfs_init_procfs(void);
1da177e4 LT	235	extern void xfs_cleanup_procfs(void);
	236
	237
	238	#else /* !CONFIG_PROC_FS */
	239
9f8868ff CH	240	static inline int xfs_init_procfs(void)
9f8868ff CH	241	{
766b0925 CH	242	return 0;
	243	}
	244
9f8868ff CH	245	static inline void xfs_cleanup_procfs(void)
9f8868ff CH	246	{
766b0925	247	}
1da177e4 LT	248
	249	#endif /* !CONFIG_PROC_FS */
	250
	251	#endif /* __XFS_STATS_H__ */