[XFS] Re-work xfs stats macros to support per-cpu data

SGI Modid: 2.5.x-xfs:slinx:156453a

fs/xfs/linux/xfs_iomap.c

@@ -598,7 +598,7 @@ xfs_iomap_write_allocate(
 	count_fsb = map->br_blockcount;
 	map_start_fsb = offset_fsb;
 
-	XFS_STATS_ADD(xfsstats.xs_xstrat_bytes, XFS_FSB_TO_B(mp, count_fsb));
+	XFS_STATS_ADD(xs_xstrat_bytes, XFS_FSB_TO_B(mp, count_fsb));
 
 	while (count_fsb != 0) {
 		/*
@@ -689,7 +689,7 @@ xfs_iomap_write_allocate(
 						 imap[i].br_blockcount))) {
 				*map = imap[i];
 				*retmap = 1;
-				XFS_STATS_INC(xfsstats.xs_xstrat_quick);
+				XFS_STATS_INC(xs_xstrat_quick);
 				return 0;
 			}
 			count_fsb -= imap[i].br_blockcount;

fs/xfs/linux/xfs_lrw.c

@@ -167,7 +167,7 @@ xfs_read(
 	mp = ip->i_mount;
 	vn_trace_entry(vp, "xfs_read", (inst_t *)__return_address);
 
-	XFS_STATS_INC(xfsstats.xs_read_calls);
+	XFS_STATS_INC(xs_read_calls);
 
 	/* START copy & waste from filemap.c */
 	for (seg = 0; seg < segs; seg++) {
@@ -231,7 +231,7 @@ xfs_read(
 	xfs_iunlock(ip, XFS_IOLOCK_SHARED);
 
 	if (ret > 0)
-		XFS_STATS_ADD(xfsstats.xs_read_bytes, ret);
+		XFS_STATS_ADD(xs_read_bytes, ret);
 
 	if (!invisible)
 		xfs_ichgtime(ip, XFS_ICHGTIME_ACC);
@@ -261,7 +261,7 @@ xfs_sendfile(
 	mp = ip->i_mount;
 	vn_trace_entry(vp, "xfs_sendfile", (inst_t *)__return_address);
 
-	XFS_STATS_INC(xfsstats.xs_read_calls);
+	XFS_STATS_INC(xs_read_calls);
 
 	n = XFS_MAXIOFFSET(mp) - *offset;
 	if ((n <= 0) || (count == 0))
@@ -288,7 +288,7 @@ xfs_sendfile(
 	ret = generic_file_sendfile(filp, offset, count, actor, target);
 	xfs_iunlock(ip, XFS_IOLOCK_SHARED);
 
-	XFS_STATS_ADD(xfsstats.xs_read_bytes, ret);
+	XFS_STATS_ADD(xs_read_bytes, ret);
 	if (!invisible)
 		xfs_ichgtime(ip, XFS_ICHGTIME_ACC);
 	return ret;
@@ -537,7 +537,7 @@ xfs_write(
 	int			eventsent = 0;
 	vrwlock_t		locktype;
 
-	XFS_STATS_INC(xfsstats.xs_write_calls);
+	XFS_STATS_INC(xs_write_calls);
 
 	vp = BHV_TO_VNODE(bdp);
 	vn_trace_entry(vp, "xfs_write", (inst_t *)__return_address);
@@ -722,7 +722,7 @@ xfs_write(
 		return ret;
 	}
 
-	XFS_STATS_ADD(xfsstats.xs_write_bytes, ret);
+	XFS_STATS_ADD(xs_write_bytes, ret);
 
 	/* Handle various SYNC-type writes */
 	if ((file->f_flags & O_SYNC) || IS_SYNC(file->f_dentry->d_inode)) {

fs/xfs/linux/xfs_stats.h

@@ -128,9 +128,9 @@ struct xfsstats {
 
 extern struct xfsstats xfsstats;
 
-# define XFS_STATS_INC(count)		( (count)++ )
-# define XFS_STATS_DEC(count)		( (count)-- )
-# define XFS_STATS_ADD(count, inc)	( (count) += (inc) )
+# define XFS_STATS_INC(count)		( xfsstats.count++ )
+# define XFS_STATS_DEC(count)		( xfsstats.count-- )
+# define XFS_STATS_ADD(count, inc)	( xfsstats.count += (inc) )
 
 extern void xfs_init_procfs(void);
 extern void xfs_cleanup_procfs(void);

fs/xfs/linux/xfs_vnode.c

@@ -77,7 +77,7 @@ vn_reclaim(
 {
 	int		error;
 
-	XFS_STATS_INC(xfsstats.vn_reclaim);
+	XFS_STATS_INC(vn_reclaim);
 	vn_trace_entry(vp, "vn_reclaim", (inst_t *)__return_address);
 
 	/*
@@ -137,8 +137,8 @@ vn_initialize(
 {
 	struct vnode	*vp = LINVFS_GET_VP(inode);
 
-	XFS_STATS_INC(xfsstats.vn_active);
-	XFS_STATS_INC(xfsstats.vn_alloc);
+	XFS_STATS_INC(vn_active);
+	XFS_STATS_INC(vn_alloc);
 
 	vp->v_flag = VMODIFIED;
 	spinlock_init(&vp->v_lock, "v_lock");
@@ -172,7 +172,7 @@ vn_get(
 {
 	struct inode	*inode;
 
-	XFS_STATS_INC(xfsstats.vn_get);
+	XFS_STATS_INC(vn_get);
 	inode = LINVFS_GET_IP(vp);
 	if (inode->i_state & I_FREEING)
 		return NULL;
@@ -280,7 +280,7 @@ vn_purge(
 		return;
 	}
 
-	XFS_STATS_DEC(xfsstats.vn_active);
+	XFS_STATS_DEC(vn_active);
 	vp->v_flag |= VRECLM;
 	VN_UNLOCK(vp, 0);
 
@@ -308,7 +308,7 @@ vn_hold(
 {
 	struct inode	*inode;
 
-	XFS_STATS_INC(xfsstats.vn_hold);
+	XFS_STATS_INC(vn_hold);
 
 	VN_LOCK(vp);
 	inode = igrab(LINVFS_GET_IP(vp));
@@ -328,7 +328,7 @@ vn_rele(
 	int		vcnt;
 	int		cache;
 
-	XFS_STATS_INC(xfsstats.vn_rele);
+	XFS_STATS_INC(vn_rele);
 
 	VN_LOCK(vp);
 
@@ -380,7 +380,7 @@ vn_remove(
 	if (!(vp->v_fbhv))
 		return;
 
-	XFS_STATS_INC(xfsstats.vn_remove);
+	XFS_STATS_INC(vn_remove);
 	vn_trace_exit(vp, "vn_remove", (inst_t *)__return_address);
 
 	/*

fs/xfs/xfs_alloc.c

@@ -636,8 +636,8 @@ xfs_alloc_ag_vextent(
 			xfs_trans_mod_sb(args->tp,
 				args->wasdel ? XFS_TRANS_SB_RES_FDBLOCKS :
 					XFS_TRANS_SB_FDBLOCKS, -slen);
-		XFS_STATS_INC(xfsstats.xs_allocx);
-		XFS_STATS_ADD(xfsstats.xs_allocb, args->len);
+		XFS_STATS_INC(xs_allocx);
+		XFS_STATS_ADD(xs_allocb, args->len);
 	}
 	return 0;
 }
@@ -1781,8 +1781,8 @@ xfs_free_ag_extent(
 		xfs_alloc_log_agf(tp, agbp, XFS_AGF_FREEBLKS);
 		if (!isfl)
 			xfs_trans_mod_sb(tp, XFS_TRANS_SB_FDBLOCKS, (long)len);
-		XFS_STATS_INC(xfsstats.xs_freex);
-		XFS_STATS_ADD(xfsstats.xs_freeb, len);
+		XFS_STATS_INC(xs_freex);
+		XFS_STATS_ADD(xs_freeb, len);
 	}
 	TRACE_FREE(haveleft ?
 			(haveright ? "both" : "left") :

fs/xfs/xfs_alloc_btree.c

@@ -133,7 +133,7 @@ xfs_alloc_delrec(
 		*stat = 0;
 		return 0;
 	}
-	XFS_STATS_INC(xfsstats.xs_abt_delrec);
+	XFS_STATS_INC(xs_abt_delrec);
 	/*
 	 * It's a nonleaf.  Excise the key and ptr being deleted, by
 	 * sliding the entries past them down one.
@@ -631,7 +631,7 @@ xfs_alloc_insrec(
 	 * and we're done.
 	 */
 	if (level >= cur->bc_nlevels) {
-		XFS_STATS_INC(xfsstats.xs_abt_insrec);
+		XFS_STATS_INC(xs_abt_insrec);
 		if ((error = xfs_alloc_newroot(cur, &i)))
 			return error;
 		*bnop = NULLAGBLOCK;
@@ -651,7 +651,7 @@ xfs_alloc_insrec(
 		*stat = 0;
 		return 0;
 	}
-	XFS_STATS_INC(xfsstats.xs_abt_insrec);
+	XFS_STATS_INC(xs_abt_insrec);
 	/*
 	 * Get pointers to the btree buffer and block.
 	 */
@@ -951,7 +951,7 @@ xfs_alloc_lookup(
 	int			level;	/* level in the btree */
 	xfs_mount_t		*mp;	/* file system mount point */
 
-	XFS_STATS_INC(xfsstats.xs_abt_lookup);
+	XFS_STATS_INC(xs_abt_lookup);
 	/*
 	 * Get the allocation group header, and the root block number.
 	 */
@@ -1046,7 +1046,7 @@ xfs_alloc_lookup(
 				xfs_extlen_t	blockcount;	/* key value */
 				xfs_agblock_t	startblock;	/* key value */
 
-				XFS_STATS_INC(xfsstats.xs_abt_compare);
+				XFS_STATS_INC(xs_abt_compare);
 				/*
 				 * keyno is average of low and high.
 				 */

fs/xfs/xfs_attr.c

@@ -131,7 +131,7 @@ xfs_attr_get(bhv_desc_t *bdp, char *name, char *value, int *valuelenp,
 	namelen = strlen(name);
 	if (namelen >= MAXNAMELEN)
 		return EFAULT;		/* match IRIX behaviour */
-	XFS_STATS_INC(xfsstats.xs_attr_get);
+	XFS_STATS_INC(xs_attr_get);
 
 	if (XFS_IFORK_Q(ip) == 0)
 		return ENOATTR;
@@ -210,7 +210,7 @@ xfs_attr_set(bhv_desc_t *bdp, char *name, char *value, int valuelen, int flags,
 	if (namelen >= MAXNAMELEN)
 		return EFAULT; /* match irix behaviour */
 
-	XFS_STATS_INC(xfsstats.xs_attr_set);
+	XFS_STATS_INC(xs_attr_set);
 	/*
 	 * Do we answer them, or ignore them?
 	 */
@@ -468,7 +468,7 @@ xfs_attr_remove(bhv_desc_t *bdp, char *name, int flags, struct cred *cred)
 	if (namelen>=MAXNAMELEN)
 		return EFAULT; /* match irix behaviour */
 
-	XFS_STATS_INC(xfsstats.xs_attr_remove);
+	XFS_STATS_INC(xs_attr_remove);
 
 	/*
 	 * Do we answer them, or ignore them?
@@ -620,7 +620,7 @@ xfs_attr_list(bhv_desc_t *bdp, char *buffer, int bufsize, int flags,
 	xfs_inode_t *dp;
 	int error;
 
-	XFS_STATS_INC(xfsstats.xs_attr_list);
+	XFS_STATS_INC(xs_attr_list);
 
 	/*
 	 * Validate the cursor.

fs/xfs/xfs_bmap.c

@@ -564,7 +564,7 @@ xfs_bmap_add_extent(
 	int			logflags; /* returned value */
 	xfs_extnum_t		nextents; /* number of extents in file now */
 
-	XFS_STATS_INC(xfsstats.xs_add_exlist);
+	XFS_STATS_INC(xs_add_exlist);
 	cur = *curp;
 	ifp = XFS_IFORK_PTR(ip, whichfork);
 	nextents = ifp->if_bytes / (uint)sizeof(xfs_bmbt_rec_t);
@@ -2836,7 +2836,7 @@ xfs_bmap_del_extent(
 	xfs_filblks_t		temp;	/* for indirect length calculations */
 	xfs_filblks_t		temp2;	/* for indirect length calculations */
 
-	XFS_STATS_INC(xfsstats.xs_del_exlist);
+	XFS_STATS_INC(xs_del_exlist);
 	mp = ip->i_mount;
 	ifp = XFS_IFORK_PTR(ip, whichfork);
 	nextents = ifp->if_bytes / (uint)sizeof(xfs_bmbt_rec_t);
@@ -3461,7 +3461,7 @@ xfs_bmap_do_search_extents(
 		low = 0;
 		high = nextents - 1;
 		while (low <= high) {
-			XFS_STATS_INC(xfsstats.xs_cmp_exlist);
+			XFS_STATS_INC(xs_cmp_exlist);
 			lastx = (low + high) >> 1;
 			ep = base + lastx;
 			got.br_startoff = xfs_bmbt_get_startoff(ep);
@@ -3531,7 +3531,7 @@ xfs_bmap_search_extents(
 	xfs_extnum_t    lastx;          /* last extent index used */
 	xfs_extnum_t    nextents;       /* extent list size */
 
-	XFS_STATS_INC(xfsstats.xs_look_exlist);
+	XFS_STATS_INC(xs_look_exlist);
 	ifp = XFS_IFORK_PTR(ip, whichfork);
 	lastx = ifp->if_lastex;
 	nextents = ifp->if_bytes / (uint)sizeof(xfs_bmbt_rec_t);
@@ -4629,9 +4629,9 @@ xfs_bmapi(
 	ASSERT(ifp->if_ext_max ==
 	       XFS_IFORK_SIZE(ip, whichfork) / (uint)sizeof(xfs_bmbt_rec_t));
 	if ((wr = (flags & XFS_BMAPI_WRITE)) != 0)
-		XFS_STATS_INC(xfsstats.xs_blk_mapw);
+		XFS_STATS_INC(xs_blk_mapw);
 	else
-		XFS_STATS_INC(xfsstats.xs_blk_mapr);
+		XFS_STATS_INC(xs_blk_mapr);
 	delay = (flags & XFS_BMAPI_DELAY) != 0;
 	trim = (flags & XFS_BMAPI_ENTIRE) == 0;
 	userdata = (flags & XFS_BMAPI_METADATA) == 0;
@@ -5115,7 +5115,7 @@ xfs_bmapi_single(
 	}
 	if (XFS_FORCED_SHUTDOWN(ip->i_mount))
 		return XFS_ERROR(EIO);
-	XFS_STATS_INC(xfsstats.xs_blk_mapr);
+	XFS_STATS_INC(xs_blk_mapr);
 	if (!(ifp->if_flags & XFS_IFEXTENTS) &&
 	    (error = xfs_iread_extents(tp, ip, whichfork)))
 		return error;
@@ -5204,7 +5204,7 @@ xfs_bunmapi(
 		*done = 1;
 		return 0;
 	}
-	XFS_STATS_INC(xfsstats.xs_blk_unmap);
+	XFS_STATS_INC(xs_blk_unmap);
 	isrt = (whichfork == XFS_DATA_FORK) &&
 	       (ip->i_d.di_flags & XFS_DIFLAG_REALTIME);
 	start = bno;

fs/xfs/xfs_bmap_btree.c

@@ -392,7 +392,7 @@ xfs_bmbt_delrec(
 		*stat = 0;
 		return 0;
 	}
-	XFS_STATS_INC(xfsstats.xs_bmbt_delrec);
+	XFS_STATS_INC(xs_bmbt_delrec);
 	if (level > 0) {
 		kp = XFS_BMAP_KEY_IADDR(block, 1, cur);
 		pp = XFS_BMAP_PTR_IADDR(block, 1, cur);
@@ -784,7 +784,7 @@ xfs_bmbt_insrec(
 		*stat = 0;
 		return 0;
 	}
-	XFS_STATS_INC(xfsstats.xs_bmbt_insrec);
+	XFS_STATS_INC(xs_bmbt_insrec);
 	block = xfs_bmbt_get_block(cur, level, &bp);
 	numrecs = INT_GET(block->bb_numrecs, ARCH_CONVERT);
 #ifdef DEBUG
@@ -1137,7 +1137,7 @@ xfs_bmbt_lookup(
 	xfs_fileoff_t		startoff;
 	xfs_trans_t		*tp;
 
-	XFS_STATS_INC(xfsstats.xs_bmbt_lookup);
+	XFS_STATS_INC(xs_bmbt_lookup);
 	XFS_BMBT_TRACE_CURSOR(cur, ENTRY);
 	XFS_BMBT_TRACE_ARGI(cur, (int)dir);
 	tp = cur->bc_tp;
@@ -1182,7 +1182,7 @@ xfs_bmbt_lookup(
 				return 0;
 			}
 			while (low <= high) {
-				XFS_STATS_INC(xfsstats.xs_bmbt_compare);
+				XFS_STATS_INC(xs_bmbt_compare);
 				keyno = (low + high) >> 1;
 				if (level > 0) {
 					kkp = kkbase + keyno - 1;

fs/xfs/xfs_dir.c

@@ -262,7 +262,7 @@ xfs_dir_createname(xfs_trans_t *trans, xfs_inode_t *dp, char *name,
 	if ((retval = xfs_dir_ino_validate(trans->t_mountp, inum)))
 		return (retval);
 
-	XFS_STATS_INC(xfsstats.xs_dir_create);
+	XFS_STATS_INC(xs_dir_create);
 	/*
 	 * Fill in the arg structure for this request.
 	 */
@@ -367,7 +367,7 @@ xfs_dir_removename(xfs_trans_t *trans, xfs_inode_t *dp, char *name,
 	int count, totallen, newsize, retval;
 
 	ASSERT((dp->i_d.di_mode & IFMT) == IFDIR);
-	XFS_STATS_INC(xfsstats.xs_dir_remove);
+	XFS_STATS_INC(xs_dir_remove);
 	/*
 	 * Fill in the arg structure for this request.
 	 */
@@ -411,7 +411,7 @@ xfs_dir_lookup(xfs_trans_t *trans, xfs_inode_t *dp, char *name, int namelen,
 
 	ASSERT((dp->i_d.di_mode & IFMT) == IFDIR);
 
-	XFS_STATS_INC(xfsstats.xs_dir_lookup);
+	XFS_STATS_INC(xs_dir_lookup);
 	/*
 	 * Fill in the arg structure for this request.
 	 */
@@ -454,7 +454,7 @@ xfs_dir_getdents(xfs_trans_t *trans, xfs_inode_t *dp, uio_t *uio, int *eofp)
 	int  alignment, retval;
 	xfs_dir_put_t put;
 
-	XFS_STATS_INC(xfsstats.xs_dir_getdents);
+	XFS_STATS_INC(xs_dir_getdents);
 	ASSERT((dp->i_d.di_mode & IFMT) == IFDIR);
 
 	/*

fs/xfs/xfs_dir2.c

@@ -212,7 +212,7 @@ xfs_dir2_createname(
 	if ((rval = xfs_dir_ino_validate(tp->t_mountp, inum))) {
 		return rval;
 	}
-	XFS_STATS_INC(xfsstats.xs_dir_create);
+	XFS_STATS_INC(xs_dir_create);
 	/*
 	 * Fill in the arg structure for this request.
 	 */
@@ -262,7 +262,7 @@ xfs_dir2_lookup(
 	int		v;		/* type-checking value */
 
 	ASSERT((dp->i_d.di_mode & IFMT) == IFDIR);
-	XFS_STATS_INC(xfsstats.xs_dir_lookup);
+	XFS_STATS_INC(xs_dir_lookup);
 
 	/*
 	 * Fill in the arg structure for this request.
@@ -320,7 +320,7 @@ xfs_dir2_removename(
 	int		v;		/* type-checking value */
 
 	ASSERT((dp->i_d.di_mode & IFMT) == IFDIR);
-	XFS_STATS_INC(xfsstats.xs_dir_remove);
+	XFS_STATS_INC(xs_dir_remove);
 	/*
 	 * Fill in the arg structure for this request.
 	 */
@@ -370,7 +370,7 @@ xfs_dir2_getdents(
 	int		v;		/* type-checking value */
 
 	ASSERT((dp->i_d.di_mode & IFMT) == IFDIR);
-	XFS_STATS_INC(xfsstats.xs_dir_getdents);
+	XFS_STATS_INC(xs_dir_getdents);
 	/*
 	 * If our caller has given us a single contiguous aligned memory buffer,
 	 * just work directly within that buffer.  If it's in user memory,

fs/xfs/xfs_iget.c

@@ -204,7 +204,7 @@ xfs_iget_core(
 				if (ip->i_flags & XFS_IRECLAIM) {
 					read_unlock(&ih->ih_lock);
 					delay(1);
-					XFS_STATS_INC(xfsstats.xs_ig_frecycle);
+					XFS_STATS_INC(xs_ig_frecycle);
 
 					goto again;
 				}
@@ -212,7 +212,7 @@ xfs_iget_core(
 				vn_trace_exit(vp, "xfs_iget.alloc",
 					(inst_t *)__return_address);
 
-				XFS_STATS_INC(xfsstats.xs_ig_found);
+				XFS_STATS_INC(xs_ig_found);
 
 				ip->i_flags &= ~XFS_IRECLAIMABLE;
 				read_unlock(&ih->ih_lock);
@@ -232,7 +232,7 @@ xfs_iget_core(
 				if (inode->i_state & (I_FREEING | I_CLEAR)) {
 					read_unlock(&ih->ih_lock);
 					delay(1);
-					XFS_STATS_INC(xfsstats.xs_ig_frecycle);
+					XFS_STATS_INC(xs_ig_frecycle);
 
 					goto again;
 				}
@@ -247,7 +247,7 @@ xfs_iget_core(
 
 			read_unlock(&ih->ih_lock);
 
-			XFS_STATS_INC(xfsstats.xs_ig_found);
+			XFS_STATS_INC(xs_ig_found);
 
 finish_inode:
 			if (lock_flags != 0) {
@@ -269,7 +269,7 @@ xfs_iget_core(
 	 * Inode cache miss: save the hash chain version stamp and unlock
 	 * the chain, so we don't deadlock in vn_alloc.
 	 */
-	XFS_STATS_INC(xfsstats.xs_ig_missed);
+	XFS_STATS_INC(xs_ig_missed);
 
 	version = ih->ih_version;
 
@@ -305,7 +305,7 @@ xfs_iget_core(
 				write_unlock(&ih->ih_lock);
 				xfs_idestroy(ip);
 
-				XFS_STATS_INC(xfsstats.xs_ig_dup);
+				XFS_STATS_INC(xs_ig_dup);
 				goto again;
 			}
 		}
@@ -442,7 +442,7 @@ xfs_iget(
 	int		error;
 
 retry:
-	XFS_STATS_INC(xfsstats.xs_ig_attempts);
+	XFS_STATS_INC(xs_ig_attempts);
 
 	if ((inode = iget_locked(XFS_MTOVFS(mp)->vfs_super, ino))) {
 		bhv_desc_t	*bdp;
@@ -475,7 +475,7 @@ xfs_iget(
 
 			bdp = vn_bhv_lookup(VN_BHV_HEAD(vp), &xfs_vnodeops);
 			if (bdp == NULL) {
-				XFS_STATS_INC(xfsstats.xs_ig_dup);
+				XFS_STATS_INC(xs_ig_dup);
 				goto inode_allocate;
 			}
 			ip = XFS_BHVTOI(bdp);
@@ -484,7 +484,7 @@ xfs_iget(
 			newnode = (ip->i_d.di_mode == 0);
 			if (newnode)
 				xfs_iocore_inode_reinit(ip);
-			XFS_STATS_INC(xfsstats.xs_ig_found);
+			XFS_STATS_INC(xs_ig_found);
 			*ipp = ip;
 			error = 0;
 		}
@@ -604,7 +604,7 @@ xfs_ireclaim(xfs_inode_t *ip)
 	/*
 	 * Remove from old hash list and mount list.
 	 */
-	XFS_STATS_INC(xfsstats.xs_ig_reclaims);
+	XFS_STATS_INC(xs_ig_reclaims);
 
 	xfs_iextract(ip);
 

fs/xfs/xfs_inode.c

@@ -2888,7 +2888,7 @@ xfs_iflush(
 	enum { INT_DELWRI = (1 << 0), INT_ASYNC = (1 << 1) };
 	SPLDECL(s);
 
-	XFS_STATS_INC(xfsstats.xs_iflush_count);
+	XFS_STATS_INC(xs_iflush_count);
 
 	ASSERT(ismrlocked(&ip->i_lock, MR_UPDATE|MR_ACCESS));
 	ASSERT(valusema(&ip->i_flock) <= 0);
@@ -3061,8 +3061,8 @@ xfs_iflush(
 	mutex_spinunlock(&ch->ch_lock, s);
 
 	if (clcount) {
-		XFS_STATS_INC(xfsstats.xs_icluster_flushcnt);
-		XFS_STATS_ADD(xfsstats.xs_icluster_flushinode, clcount);
+		XFS_STATS_INC(xs_icluster_flushcnt);
+		XFS_STATS_ADD(xs_icluster_flushinode, clcount);
 	}
 
 	/*

fs/xfs/xfs_log.c

@@ -345,7 +345,7 @@ xfs_log_force(xfs_mount_t *mp,
 
 	ASSERT(flags & XFS_LOG_FORCE);
 
-	XFS_STATS_INC(xfsstats.xs_log_force);
+	XFS_STATS_INC(xs_log_force);
 
 	if ((log->l_flags & XLOG_IO_ERROR) == 0) {
 		if (lsn == 0)
@@ -446,7 +446,7 @@ xfs_log_reserve(xfs_mount_t	 *mp,
 	if (XLOG_FORCED_SHUTDOWN(log))
 		return XFS_ERROR(EIO);
 
-	XFS_STATS_INC(xfsstats.xs_try_logspace);
+	XFS_STATS_INC(xs_try_logspace);
 
 	if (*ticket != NULL) {
 		ASSERT(flags & XFS_LOG_PERM_RESERV);
@@ -1428,7 +1428,7 @@ xlog_sync(xlog_t		*log,
 	int		split = 0;	/* split write into two regions */
 	int		error;
 
-	XFS_STATS_INC(xfsstats.xs_log_writes);
+	XFS_STATS_INC(xs_log_writes);
 	ASSERT(iclog->ic_refcnt == 0);
 
 	/* Round out the log write size */
@@ -1477,7 +1477,7 @@ xlog_sync(xlog_t		*log,
 
 	/* Add for LR header */
 	count += log->l_iclog_hsize;
-	XFS_STATS_ADD(xfsstats.xs_log_blocks, BTOBB(count));
+	XFS_STATS_ADD(xs_log_blocks, BTOBB(count));
 
 	/* Do we need to split this write into 2 parts? */
 	if (XFS_BUF_ADDR(bp) + BTOBB(count) > log->l_logBBsize) {
@@ -2308,7 +2308,7 @@ xlog_state_get_iclog_space(xlog_t	  *log,
 		log->l_flushcnt++;
 		LOG_UNLOCK(log, s);
 		xlog_trace_iclog(iclog, XLOG_TRACE_SLEEP_FLUSH);
-		XFS_STATS_INC(xfsstats.xs_log_noiclogs);
+		XFS_STATS_INC(xs_log_noiclogs);
 		/* Ensure that log writes happen */
 		psema(&log->l_flushsema, PINOD);
 		goto restart;
@@ -2421,7 +2421,7 @@ xlog_grant_log_space(xlog_t	   *log,
 		if (XLOG_FORCED_SHUTDOWN(log))
 			goto error_return;
 
-		XFS_STATS_INC(xfsstats.xs_sleep_logspace);
+		XFS_STATS_INC(xs_sleep_logspace);
 		sv_wait(&tic->t_sema, PINOD|PLTWAIT, &log->l_grant_lock, s);
 		/*
 		 * If we got an error, and the filesystem is shutting down,
@@ -2447,7 +2447,7 @@ xlog_grant_log_space(xlog_t	   *log,
 			XLOG_INS_TICKETQ(log->l_reserve_headq, tic);
 		xlog_trace_loggrant(log, tic,
 				    "xlog_grant_log_space: sleep 2");
-		XFS_STATS_INC(xfsstats.xs_sleep_logspace);
+		XFS_STATS_INC(xs_sleep_logspace);
 		sv_wait(&tic->t_sema, PINOD|PLTWAIT, &log->l_grant_lock, s);
 
 		if (XLOG_FORCED_SHUTDOWN(log)) {
@@ -2558,7 +2558,7 @@ xlog_regrant_write_log_space(xlog_t	   *log,
 
 			xlog_trace_loggrant(log, tic,
 				    "xlog_regrant_write_log_space: sleep 1");
-			XFS_STATS_INC(xfsstats.xs_sleep_logspace);
+			XFS_STATS_INC(xs_sleep_logspace);
 			sv_wait(&tic->t_sema, PINOD|PLTWAIT,
 				&log->l_grant_lock, s);
 
@@ -2587,7 +2587,7 @@ xlog_regrant_write_log_space(xlog_t	   *log,
 	if (free_bytes < need_bytes) {
 		if ((tic->t_flags & XLOG_TIC_IN_Q) == 0)
 			XLOG_INS_TICKETQ(log->l_write_headq, tic);
-		XFS_STATS_INC(xfsstats.xs_sleep_logspace);
+		XFS_STATS_INC(xs_sleep_logspace);
 		sv_wait(&tic->t_sema, PINOD|PLTWAIT, &log->l_grant_lock, s);
 
 		/* If we're shutting down, this tic is already off the queue */
@@ -2952,7 +2952,7 @@ xlog_state_sync_all(xlog_t *log, uint flags)
 			LOG_UNLOCK(log, s);
 			return XFS_ERROR(EIO);
 		}
-		XFS_STATS_INC(xfsstats.xs_log_force_sleep);
+		XFS_STATS_INC(xs_log_force_sleep);
 		sv_wait(&iclog->ic_forcesema, PINOD, &log->l_icloglock, s);
 		/*
 		 * No need to grab the log lock here since we're
@@ -3035,7 +3035,7 @@ xlog_state_sync(xlog_t	  *log,
 		    (iclog->ic_prev->ic_state & (XLOG_STATE_WANT_SYNC |
 						 XLOG_STATE_SYNCING))) {
 			ASSERT(!(iclog->ic_state & XLOG_STATE_IOERROR));
-			XFS_STATS_INC(xfsstats.xs_log_force_sleep);
+			XFS_STATS_INC(xs_log_force_sleep);
 			sv_wait(&iclog->ic_prev->ic_writesema, PSWP,
 				&log->l_icloglock, s);
 			already_slept = 1;
@@ -3061,7 +3061,7 @@ xlog_state_sync(xlog_t	  *log,
 			LOG_UNLOCK(log, s);
 			return XFS_ERROR(EIO);
 		}
-		XFS_STATS_INC(xfsstats.xs_log_force_sleep);
+		XFS_STATS_INC(xs_log_force_sleep);
 		sv_wait(&iclog->ic_forcesema, PSWP, &log->l_icloglock, s);
 		/*
 		 * No need to grab the log lock here since we're

fs/xfs/xfs_trans.c

@@ -739,7 +739,7 @@ xfs_trans_commit(
 		xfs_trans_free_items(tp, shutdown? XFS_TRANS_ABORT : 0);
 		xfs_trans_free_busy(tp);
 		xfs_trans_free(tp);
-		XFS_STATS_INC(xfsstats.xs_trans_empty);
+		XFS_STATS_INC(xs_trans_empty);
 		if (commit_lsn_p)
 			*commit_lsn_p = commit_lsn;
 		return (shutdown);
@@ -895,9 +895,9 @@ xfs_trans_commit(
 		if (!error)
 			error = xfs_log_force(mp, commit_lsn,
 				      XFS_LOG_FORCE | XFS_LOG_SYNC);
-		XFS_STATS_INC(xfsstats.xs_trans_sync);
+		XFS_STATS_INC(xs_trans_sync);
 	} else {
-		XFS_STATS_INC(xfsstats.xs_trans_async);
+		XFS_STATS_INC(xs_trans_async);
 	}
 
 	return (error);

fs/xfs/xfs_trans_ail.c

@@ -118,7 +118,7 @@ xfs_trans_push_ail(
 		return (xfs_lsn_t)0;
 	}
 
-	XFS_STATS_INC(xfsstats.xs_push_ail);
+	XFS_STATS_INC(xs_push_ail);
 
 	/*
 	 * While the item we are looking at is below the given threshold
@@ -152,14 +152,14 @@ xfs_trans_push_ail(
 		switch (lock_result) {
 		      case XFS_ITEM_SUCCESS:
 			AIL_UNLOCK(mp, s);
-			XFS_STATS_INC(xfsstats.xs_push_ail_success);
+			XFS_STATS_INC(xs_push_ail_success);
 			IOP_PUSH(lip);
 			AIL_LOCK(mp,s);
 			break;
 
 		      case XFS_ITEM_PUSHBUF:
 			AIL_UNLOCK(mp, s);
-			XFS_STATS_INC(xfsstats.xs_push_ail_pushbuf);
+			XFS_STATS_INC(xs_push_ail_pushbuf);
 #ifdef XFSRACEDEBUG
 			delay_for_intr();
 			delay(300);
@@ -171,16 +171,16 @@ xfs_trans_push_ail(
 			break;
 
 		      case XFS_ITEM_PINNED:
-			XFS_STATS_INC(xfsstats.xs_push_ail_pinned);
+			XFS_STATS_INC(xs_push_ail_pinned);
 			flush_log = 1;
 			break;
 
 		      case XFS_ITEM_LOCKED:
-			XFS_STATS_INC(xfsstats.xs_push_ail_locked);
+			XFS_STATS_INC(xs_push_ail_locked);
 			break;
 
 		      case XFS_ITEM_FLUSHING:
-			XFS_STATS_INC(xfsstats.xs_push_ail_flushing);
+			XFS_STATS_INC(xs_push_ail_flushing);
 			break;
 
 		      default:
@@ -209,7 +209,7 @@ xfs_trans_push_ail(
 		 * move forward in the AIL.
 		 */
 		AIL_UNLOCK(mp, s);
-		XFS_STATS_INC(xfsstats.xs_push_ail_flush);
+		XFS_STATS_INC(xs_push_ail_flush);
 		xfs_log_force(mp, (xfs_lsn_t)0, XFS_LOG_FORCE);
 		AIL_LOCK(mp, s);
 	}
@@ -428,7 +428,7 @@ xfs_trans_next_ail(
 		nlip = xfs_ail_min(&(mp->m_ail));
 		*gen = (int)mp->m_ail_gen;
 		if (restarts != NULL) {
-			XFS_STATS_INC(xfsstats.xs_push_ail_restarts);
+			XFS_STATS_INC(xs_push_ail_restarts);
 			(*restarts)++;
 		}
 	}

fs/xfs/xfs_vnodeops.c

@@ -891,7 +891,7 @@ xfs_setattr(
 	if (timeflags && !(flags & ATTR_DMI))
 		xfs_ichgtime(ip, timeflags);
 
-	XFS_STATS_INC(xfsstats.xs_ig_attrchg);
+	XFS_STATS_INC(xs_ig_attrchg);
 
 	/*
 	 * If this is a synchronous mount, make sure that the