[linux.git] / fs / nfs / iostat.h

/*
 *  linux/fs/nfs/iostat.h
 *
 *  Declarations for NFS client per-mount statistics
 *
 *  Copyright (C) 2005, 2006 Chuck Lever <[email protected]>
 *
 *  NFS client per-mount statistics provide information about the health of
 *  the NFS client and the health of each NFS mount point.  Generally these
 *  are not for detailed problem diagnosis, but simply to indicate that there
 *  is a problem.
 *
 *  These counters are not meant to be human-readable, but are meant to be
 *  integrated into system monitoring tools such as "sar" and "iostat".  As
 *  such, the counters are sampled by the tools over time, and are never
 *  zeroed after a file system is mounted.  Moving averages can be computed
 *  by the tools by taking the difference between two instantaneous samples
 *  and dividing that by the time between the samples.
 */

#ifndef _NFS_IOSTAT
#define _NFS_IOSTAT

#define NFS_IOSTAT_VERS		"1.0"

/*
 * NFS byte counters
 *
 * 1.  SERVER - the number of payload bytes read from or written to the
 *     server by the NFS client via an NFS READ or WRITE request.
 *
 * 2.  NORMAL - the number of bytes read or written by applications via
 *     the read(2) and write(2) system call interfaces.
 *
 * 3.  DIRECT - the number of bytes read or written from files opened
 *     with the O_DIRECT flag.
 *
 * These counters give a view of the data throughput into and out of the NFS
 * client.  Comparing the number of bytes requested by an application with the
 * number of bytes the client requests from the server can provide an
 * indication of client efficiency (per-op, cache hits, etc).
 *
 * These counters can also help characterize which access methods are in
 * use.  DIRECT by itself shows whether there is any O_DIRECT traffic.
 * NORMAL + DIRECT shows how much data is going through the system call
 * interface.  A large amount of SERVER traffic without much NORMAL or
 * DIRECT traffic shows that applications are using mapped files.
 *
 * NFS page counters
 *
 * These count the number of pages read or written via nfs_readpage(),
 * nfs_readpages(), or their write equivalents.
 */
enum nfs_stat_bytecounters {
	NFSIOS_NORMALREADBYTES = 0,
	NFSIOS_NORMALWRITTENBYTES,
	NFSIOS_DIRECTREADBYTES,
	NFSIOS_DIRECTWRITTENBYTES,
	NFSIOS_SERVERREADBYTES,
	NFSIOS_SERVERWRITTENBYTES,
	NFSIOS_READPAGES,
	NFSIOS_WRITEPAGES,
	__NFSIOS_BYTESMAX,
};

/*
 * NFS event counters
 *
 * These counters provide a low-overhead way of monitoring client activity
 * without enabling NFS trace debugging.  The counters show the rate at
 * which VFS requests are made, and how often the client invalidates its
 * data and attribute caches.  This allows system administrators to monitor
 * such things as how close-to-open is working, and answer questions such
 * as "why are there so many GETATTR requests on the wire?"
 *
 * They also count anamolous events such as short reads and writes, silly
 * renames due to close-after-delete, and operations that change the size
 * of a file (such operations can often be the source of data corruption
 * if applications aren't using file locking properly).
 */
enum nfs_stat_eventcounters {
	NFSIOS_INODEREVALIDATE = 0,
	NFSIOS_DENTRYREVALIDATE,
	NFSIOS_DATAINVALIDATE,
	NFSIOS_ATTRINVALIDATE,
	NFSIOS_VFSOPEN,
	NFSIOS_VFSLOOKUP,
	NFSIOS_VFSACCESS,
	NFSIOS_VFSUPDATEPAGE,
	NFSIOS_VFSREADPAGE,
	NFSIOS_VFSREADPAGES,
	NFSIOS_VFSWRITEPAGE,
	NFSIOS_VFSWRITEPAGES,
	NFSIOS_VFSGETDENTS,
	NFSIOS_VFSSETATTR,
	NFSIOS_VFSFLUSH,
	NFSIOS_VFSFSYNC,
	NFSIOS_VFSLOCK,
	NFSIOS_VFSRELEASE,
	NFSIOS_CONGESTIONWAIT,
	NFSIOS_SETATTRTRUNC,
	NFSIOS_EXTENDWRITE,
	NFSIOS_SILLYRENAME,
	NFSIOS_SHORTREAD,
	NFSIOS_SHORTWRITE,
	NFSIOS_DELAY,
	__NFSIOS_COUNTSMAX,
};

#ifdef __KERNEL__

#include <linux/percpu.h>
#include <linux/cache.h>

struct nfs_iostats {
	unsigned long long	bytes[__NFSIOS_BYTESMAX];
	unsigned long		events[__NFSIOS_COUNTSMAX];
} ____cacheline_aligned;

static inline void nfs_inc_server_stats(struct nfs_server *server, enum nfs_stat_eventcounters stat)
{
	struct nfs_iostats *iostats;
	int cpu;

	cpu = get_cpu();
	iostats = per_cpu_ptr(server->io_stats, cpu);
	iostats->events[stat] ++;
	put_cpu_no_resched();
}

static inline void nfs_inc_stats(struct inode *inode, enum nfs_stat_eventcounters stat)
{
	nfs_inc_server_stats(NFS_SERVER(inode), stat);
}

static inline void nfs_add_server_stats(struct nfs_server *server, enum nfs_stat_bytecounters stat, unsigned long addend)
{
	struct nfs_iostats *iostats;
	int cpu;

	cpu = get_cpu();
	iostats = per_cpu_ptr(server->io_stats, cpu);
	iostats->bytes[stat] += addend;
	put_cpu_no_resched();
}

static inline void nfs_add_stats(struct inode *inode, enum nfs_stat_bytecounters stat, unsigned long addend)
{
	nfs_add_server_stats(NFS_SERVER(inode), stat, addend);
}

static inline struct nfs_iostats *nfs_alloc_iostats(void)
{
	return alloc_percpu(struct nfs_iostats);
}

static inline void nfs_free_iostats(struct nfs_iostats *stats)
{
	if (stats != NULL)
		free_percpu(stats);
}

#endif
#endif
Commit	Line	Data
d9ef5a8c CL	1	/*
	2	* linux/fs/nfs/iostat.h
	3	*
	4	* Declarations for NFS client per-mount statistics
	5	*
	6	* Copyright (C) 2005, 2006 Chuck Lever <[email protected]>
	7	*
	8	* NFS client per-mount statistics provide information about the health of
	9	* the NFS client and the health of each NFS mount point. Generally these
	10	* are not for detailed problem diagnosis, but simply to indicate that there
	11	* is a problem.
	12	*
	13	* These counters are not meant to be human-readable, but are meant to be
	14	* integrated into system monitoring tools such as "sar" and "iostat". As
	15	* such, the counters are sampled by the tools over time, and are never
	16	* zeroed after a file system is mounted. Moving averages can be computed
	17	* by the tools by taking the difference between two instantaneous samples
	18	* and dividing that by the time between the samples.
	19	*/
	20
	21	#ifndef _NFS_IOSTAT
	22	#define _NFS_IOSTAT
	23
	24	#define NFS_IOSTAT_VERS "1.0"
	25
	26	/*
	27	* NFS byte counters
	28	*
	29	* 1. SERVER - the number of payload bytes read from or written to the
	30	* server by the NFS client via an NFS READ or WRITE request.
	31	*
	32	* 2. NORMAL - the number of bytes read or written by applications via
	33	* the read(2) and write(2) system call interfaces.
	34	*
	35	* 3. DIRECT - the number of bytes read or written from files opened
	36	* with the O_DIRECT flag.
	37	*
	38	* These counters give a view of the data throughput into and out of the NFS
	39	* client. Comparing the number of bytes requested by an application with the
	40	* number of bytes the client requests from the server can provide an
	41	* indication of client efficiency (per-op, cache hits, etc).
	42	*
	43	* These counters can also help characterize which access methods are in
	44	* use. DIRECT by itself shows whether there is any O_DIRECT traffic.
	45	* NORMAL + DIRECT shows how much data is going through the system call
	46	* interface. A large amount of SERVER traffic without much NORMAL or
	47	* DIRECT traffic shows that applications are using mapped files.
	48	*
	49	* NFS page counters
	50	*
	51	* These count the number of pages read or written via nfs_readpage(),
	52	* nfs_readpages(), or their write equivalents.
	53	*/
	54	enum nfs_stat_bytecounters {
	55	NFSIOS_NORMALREADBYTES = 0,
	56	NFSIOS_NORMALWRITTENBYTES,
	57	NFSIOS_DIRECTREADBYTES,
	58	NFSIOS_DIRECTWRITTENBYTES,
	59	NFSIOS_SERVERREADBYTES,
	60	NFSIOS_SERVERWRITTENBYTES,
	61	NFSIOS_READPAGES,
	62	NFSIOS_WRITEPAGES,
	63	__NFSIOS_BYTESMAX,
	64	};
65
66	/*
67	* NFS event counters
68	*
69	* These counters provide a low-overhead way of monitoring client activity
70	* without enabling NFS trace debugging. The counters show the rate at
71	* which VFS requests are made, and how often the client invalidates its
72	* data and attribute caches. This allows system administrators to monitor
73	* such things as how close-to-open is working, and answer questions such
74	* as "why are there so many GETATTR requests on the wire?"
75	*
76	* They also count anamolous events such as short reads and writes, silly
77	* renames due to close-after-delete, and operations that change the size
78	* of a file (such operations can often be the source of data corruption
79	* if applications aren't using file locking properly).
80	*/
81	enum nfs_stat_eventcounters {
82	NFSIOS_INODEREVALIDATE = 0,
83	NFSIOS_DENTRYREVALIDATE,
84	NFSIOS_DATAINVALIDATE,
85	NFSIOS_ATTRINVALIDATE,
86	NFSIOS_VFSOPEN,
87	NFSIOS_VFSLOOKUP,
88	NFSIOS_VFSACCESS,
89	NFSIOS_VFSUPDATEPAGE,
90	NFSIOS_VFSREADPAGE,
91	NFSIOS_VFSREADPAGES,
92	NFSIOS_VFSWRITEPAGE,
93	NFSIOS_VFSWRITEPAGES,
94	NFSIOS_VFSGETDENTS,
95	NFSIOS_VFSSETATTR,
96	NFSIOS_VFSFLUSH,
97	NFSIOS_VFSFSYNC,
98	NFSIOS_VFSLOCK,
99	NFSIOS_VFSRELEASE,
100	NFSIOS_CONGESTIONWAIT,
101	NFSIOS_SETATTRTRUNC,
102	NFSIOS_EXTENDWRITE,
103	NFSIOS_SILLYRENAME,
104	NFSIOS_SHORTREAD,
105	NFSIOS_SHORTWRITE,
006ea73e	106	NFSIOS_DELAY,
d9ef5a8c CL	107	__NFSIOS_COUNTSMAX,
	108	};
	109
	110	#ifdef __KERNEL__
	111
	112	#include <linux/percpu.h>
	113	#include <linux/cache.h>
	114
	115	struct nfs_iostats {
	116	unsigned long long bytes[__NFSIOS_BYTESMAX];
	117	unsigned long events[__NFSIOS_COUNTSMAX];
	118	} ____cacheline_aligned;
	119
006ea73e	120	static inline void nfs_inc_server_stats(struct nfs_server *server, enum nfs_stat_eventcounters stat)
d9ef5a8c CL	121	{
	122	struct nfs_iostats *iostats;
	123	int cpu;
	124
	125	cpu = get_cpu();
006ea73e	126	iostats = per_cpu_ptr(server->io_stats, cpu);
d9ef5a8c CL	127	iostats->events[stat] ++;
	128	put_cpu_no_resched();
	129	}
	130
006ea73e CL	131	static inline void nfs_inc_stats(struct inode *inode, enum nfs_stat_eventcounters stat)
	132	{
	133	nfs_inc_server_stats(NFS_SERVER(inode), stat);
	134	}
	135
	136	static inline void nfs_add_server_stats(struct nfs_server *server, enum nfs_stat_bytecounters stat, unsigned long addend)
d9ef5a8c CL	137	{
	138	struct nfs_iostats *iostats;
	139	int cpu;
	140
	141	cpu = get_cpu();
006ea73e	142	iostats = per_cpu_ptr(server->io_stats, cpu);
d9ef5a8c CL	143	iostats->bytes[stat] += addend;
	144	put_cpu_no_resched();
	145	}
	146
006ea73e CL	147	static inline void nfs_add_stats(struct inode *inode, enum nfs_stat_bytecounters stat, unsigned long addend)
	148	{
	149	nfs_add_server_stats(NFS_SERVER(inode), stat, addend);
	150	}
	151
d9ef5a8c CL	152	static inline struct nfs_iostats *nfs_alloc_iostats(void)
	153	{
	154	return alloc_percpu(struct nfs_iostats);
	155	}
	156
	157	static inline void nfs_free_iostats(struct nfs_iostats *stats)
	158	{
01d0ae8b TM	159	if (stats != NULL)
01d0ae8b TM	160	free_percpu(stats);
d9ef5a8c CL	161	}
	162
	163	#endif
	164	#endif