1 /* 2 * linux/fs/nfs/iostat.h 3 * 4 * Declarations for NFS client per-mount statistics 5 * 6 * Copyright (C) 2005, 2006 Chuck Lever <cel@netapp.com> 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, 106 NFSIOS_DELAY, 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 120 static inline void nfs_inc_server_stats(struct nfs_server *server, enum nfs_stat_eventcounters stat) 121 { 122 struct nfs_iostats *iostats; 123 int cpu; 124 125 cpu = get_cpu(); 126 iostats = per_cpu_ptr(server->io_stats, cpu); 127 iostats->events[stat] ++; 128 put_cpu_no_resched(); 129 } 130 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) 137 { 138 struct nfs_iostats *iostats; 139 int cpu; 140 141 cpu = get_cpu(); 142 iostats = per_cpu_ptr(server->io_stats, cpu); 143 iostats->bytes[stat] += addend; 144 put_cpu_no_resched(); 145 } 146 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 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 { 159 if (stats != NULL) 160 free_percpu(stats); 161 } 162 163 #endif 164 #endif 165