1 /* SPDX-License-Identifier: GPL-2.0 */ 1 /* SPDX-License-Identifier: GPL-2.0 */ 2 /* 2 /* 3 * Copyright (c) 2013 Trond Myklebust <Trond.M 3 * Copyright (c) 2013 Trond Myklebust <Trond.Myklebust@netapp.com> 4 */ 4 */ 5 #undef TRACE_SYSTEM 5 #undef TRACE_SYSTEM 6 #define TRACE_SYSTEM nfs 6 #define TRACE_SYSTEM nfs 7 7 8 #if !defined(_TRACE_NFS_H) || defined(TRACE_HE 8 #if !defined(_TRACE_NFS_H) || defined(TRACE_HEADER_MULTI_READ) 9 #define _TRACE_NFS_H 9 #define _TRACE_NFS_H 10 10 11 #include <linux/tracepoint.h> 11 #include <linux/tracepoint.h> 12 #include <linux/iversion.h> 12 #include <linux/iversion.h> 13 13 14 #include <trace/misc/fs.h> !! 14 TRACE_DEFINE_ENUM(DT_UNKNOWN); 15 #include <trace/misc/nfs.h> !! 15 TRACE_DEFINE_ENUM(DT_FIFO); 16 #include <trace/misc/sunrpc.h> !! 16 TRACE_DEFINE_ENUM(DT_CHR); >> 17 TRACE_DEFINE_ENUM(DT_DIR); >> 18 TRACE_DEFINE_ENUM(DT_BLK); >> 19 TRACE_DEFINE_ENUM(DT_REG); >> 20 TRACE_DEFINE_ENUM(DT_LNK); >> 21 TRACE_DEFINE_ENUM(DT_SOCK); >> 22 TRACE_DEFINE_ENUM(DT_WHT); >> 23 >> 24 #define nfs_show_file_type(ftype) \ >> 25 __print_symbolic(ftype, \ >> 26 { DT_UNKNOWN, "UNKNOWN" }, \ >> 27 { DT_FIFO, "FIFO" }, \ >> 28 { DT_CHR, "CHR" }, \ >> 29 { DT_DIR, "DIR" }, \ >> 30 { DT_BLK, "BLK" }, \ >> 31 { DT_REG, "REG" }, \ >> 32 { DT_LNK, "LNK" }, \ >> 33 { DT_SOCK, "SOCK" }, \ >> 34 { DT_WHT, "WHT" }) >> 35 >> 36 TRACE_DEFINE_ENUM(NFS_INO_INVALID_DATA); >> 37 TRACE_DEFINE_ENUM(NFS_INO_INVALID_ATIME); >> 38 TRACE_DEFINE_ENUM(NFS_INO_INVALID_ACCESS); >> 39 TRACE_DEFINE_ENUM(NFS_INO_INVALID_ACL); >> 40 TRACE_DEFINE_ENUM(NFS_INO_REVAL_PAGECACHE); >> 41 TRACE_DEFINE_ENUM(NFS_INO_REVAL_FORCED); >> 42 TRACE_DEFINE_ENUM(NFS_INO_INVALID_LABEL); >> 43 TRACE_DEFINE_ENUM(NFS_INO_INVALID_CHANGE); >> 44 TRACE_DEFINE_ENUM(NFS_INO_INVALID_CTIME); >> 45 TRACE_DEFINE_ENUM(NFS_INO_INVALID_MTIME); >> 46 TRACE_DEFINE_ENUM(NFS_INO_INVALID_SIZE); >> 47 TRACE_DEFINE_ENUM(NFS_INO_INVALID_OTHER); 17 48 18 #define nfs_show_cache_validity(v) \ 49 #define nfs_show_cache_validity(v) \ 19 __print_flags(v, "|", \ 50 __print_flags(v, "|", \ 20 { NFS_INO_INVALID_DATA 51 { NFS_INO_INVALID_DATA, "INVALID_DATA" }, \ 21 { NFS_INO_INVALID_ATIM 52 { NFS_INO_INVALID_ATIME, "INVALID_ATIME" }, \ 22 { NFS_INO_INVALID_ACCE 53 { NFS_INO_INVALID_ACCESS, "INVALID_ACCESS" }, \ 23 { NFS_INO_INVALID_ACL, 54 { NFS_INO_INVALID_ACL, "INVALID_ACL" }, \ >> 55 { NFS_INO_REVAL_PAGECACHE, "REVAL_PAGECACHE" }, \ 24 { NFS_INO_REVAL_FORCED 56 { NFS_INO_REVAL_FORCED, "REVAL_FORCED" }, \ 25 { NFS_INO_INVALID_LABE 57 { NFS_INO_INVALID_LABEL, "INVALID_LABEL" }, \ 26 { NFS_INO_INVALID_CHAN 58 { NFS_INO_INVALID_CHANGE, "INVALID_CHANGE" }, \ 27 { NFS_INO_INVALID_CTIM 59 { NFS_INO_INVALID_CTIME, "INVALID_CTIME" }, \ 28 { NFS_INO_INVALID_MTIM 60 { NFS_INO_INVALID_MTIME, "INVALID_MTIME" }, \ 29 { NFS_INO_INVALID_SIZE 61 { NFS_INO_INVALID_SIZE, "INVALID_SIZE" }, \ 30 { NFS_INO_INVALID_OTHE !! 62 { NFS_INO_INVALID_OTHER, "INVALID_OTHER" }) 31 { NFS_INO_DATA_INVAL_D !! 63 32 { NFS_INO_INVALID_BLOC !! 64 TRACE_DEFINE_ENUM(NFS_INO_ADVISE_RDPLUS); 33 { NFS_INO_INVALID_XATT !! 65 TRACE_DEFINE_ENUM(NFS_INO_STALE); 34 { NFS_INO_INVALID_NLIN !! 66 TRACE_DEFINE_ENUM(NFS_INO_ACL_LRU_SET); 35 { NFS_INO_INVALID_MODE !! 67 TRACE_DEFINE_ENUM(NFS_INO_INVALIDATING); >> 68 TRACE_DEFINE_ENUM(NFS_INO_FSCACHE); >> 69 TRACE_DEFINE_ENUM(NFS_INO_FSCACHE_LOCK); >> 70 TRACE_DEFINE_ENUM(NFS_INO_LAYOUTCOMMIT); >> 71 TRACE_DEFINE_ENUM(NFS_INO_LAYOUTCOMMITTING); >> 72 TRACE_DEFINE_ENUM(NFS_INO_LAYOUTSTATS); >> 73 TRACE_DEFINE_ENUM(NFS_INO_ODIRECT); 36 74 37 #define nfs_show_nfsi_flags(v) \ 75 #define nfs_show_nfsi_flags(v) \ 38 __print_flags(v, "|", \ 76 __print_flags(v, "|", \ >> 77 { BIT(NFS_INO_ADVISE_RDPLUS), "ADVISE_RDPLUS" }, \ 39 { BIT(NFS_INO_STALE), 78 { BIT(NFS_INO_STALE), "STALE" }, \ 40 { BIT(NFS_INO_ACL_LRU_ 79 { BIT(NFS_INO_ACL_LRU_SET), "ACL_LRU_SET" }, \ 41 { BIT(NFS_INO_INVALIDA 80 { BIT(NFS_INO_INVALIDATING), "INVALIDATING" }, \ >> 81 { BIT(NFS_INO_FSCACHE), "FSCACHE" }, \ >> 82 { BIT(NFS_INO_FSCACHE_LOCK), "FSCACHE_LOCK" }, \ 42 { BIT(NFS_INO_LAYOUTCO 83 { BIT(NFS_INO_LAYOUTCOMMIT), "NEED_LAYOUTCOMMIT" }, \ 43 { BIT(NFS_INO_LAYOUTCO 84 { BIT(NFS_INO_LAYOUTCOMMITTING), "LAYOUTCOMMIT" }, \ 44 { BIT(NFS_INO_LAYOUTST 85 { BIT(NFS_INO_LAYOUTSTATS), "LAYOUTSTATS" }, \ 45 { BIT(NFS_INO_ODIRECT) 86 { BIT(NFS_INO_ODIRECT), "ODIRECT" }) 46 87 47 DECLARE_EVENT_CLASS(nfs_inode_event, 88 DECLARE_EVENT_CLASS(nfs_inode_event, 48 TP_PROTO( 89 TP_PROTO( 49 const struct inode *in 90 const struct inode *inode 50 ), 91 ), 51 92 52 TP_ARGS(inode), 93 TP_ARGS(inode), 53 94 54 TP_STRUCT__entry( 95 TP_STRUCT__entry( 55 __field(dev_t, dev) 96 __field(dev_t, dev) 56 __field(u32, fhandle) 97 __field(u32, fhandle) 57 __field(u64, fileid) 98 __field(u64, fileid) 58 __field(u64, version) 99 __field(u64, version) 59 ), 100 ), 60 101 61 TP_fast_assign( 102 TP_fast_assign( 62 const struct nfs_inode 103 const struct nfs_inode *nfsi = NFS_I(inode); 63 __entry->dev = inode-> 104 __entry->dev = inode->i_sb->s_dev; 64 __entry->fileid = nfsi 105 __entry->fileid = nfsi->fileid; 65 __entry->fhandle = nfs 106 __entry->fhandle = nfs_fhandle_hash(&nfsi->fh); 66 __entry->version = ino 107 __entry->version = inode_peek_iversion_raw(inode); 67 ), 108 ), 68 109 69 TP_printk( 110 TP_printk( 70 "fileid=%02x:%02x:%llu 111 "fileid=%02x:%02x:%llu fhandle=0x%08x version=%llu ", 71 MAJOR(__entry->dev), M 112 MAJOR(__entry->dev), MINOR(__entry->dev), 72 (unsigned long long)__ 113 (unsigned long long)__entry->fileid, 73 __entry->fhandle, 114 __entry->fhandle, 74 (unsigned long long)__ 115 (unsigned long long)__entry->version 75 ) 116 ) 76 ); 117 ); 77 118 78 DECLARE_EVENT_CLASS(nfs_inode_event_done, 119 DECLARE_EVENT_CLASS(nfs_inode_event_done, 79 TP_PROTO( 120 TP_PROTO( 80 const struct inode *in 121 const struct inode *inode, 81 int error 122 int error 82 ), 123 ), 83 124 84 TP_ARGS(inode, error), 125 TP_ARGS(inode, error), 85 126 86 TP_STRUCT__entry( 127 TP_STRUCT__entry( 87 __field(unsigned long, 128 __field(unsigned long, error) 88 __field(dev_t, dev) 129 __field(dev_t, dev) 89 __field(u32, fhandle) 130 __field(u32, fhandle) 90 __field(unsigned char, 131 __field(unsigned char, type) 91 __field(u64, fileid) 132 __field(u64, fileid) 92 __field(u64, version) 133 __field(u64, version) 93 __field(loff_t, size) 134 __field(loff_t, size) 94 __field(unsigned long, 135 __field(unsigned long, nfsi_flags) 95 __field(unsigned long, 136 __field(unsigned long, cache_validity) 96 ), 137 ), 97 138 98 TP_fast_assign( 139 TP_fast_assign( 99 const struct nfs_inode 140 const struct nfs_inode *nfsi = NFS_I(inode); 100 __entry->error = error 141 __entry->error = error < 0 ? -error : 0; 101 __entry->dev = inode-> 142 __entry->dev = inode->i_sb->s_dev; 102 __entry->fileid = nfsi 143 __entry->fileid = nfsi->fileid; 103 __entry->fhandle = nfs 144 __entry->fhandle = nfs_fhandle_hash(&nfsi->fh); 104 __entry->type = nfs_um 145 __entry->type = nfs_umode_to_dtype(inode->i_mode); 105 __entry->version = ino 146 __entry->version = inode_peek_iversion_raw(inode); 106 __entry->size = i_size 147 __entry->size = i_size_read(inode); 107 __entry->nfsi_flags = 148 __entry->nfsi_flags = nfsi->flags; 108 __entry->cache_validit 149 __entry->cache_validity = nfsi->cache_validity; 109 ), 150 ), 110 151 111 TP_printk( 152 TP_printk( 112 "error=%ld (%s) fileid 153 "error=%ld (%s) fileid=%02x:%02x:%llu fhandle=0x%08x " 113 "type=%u (%s) version= 154 "type=%u (%s) version=%llu size=%lld " 114 "cache_validity=0x%lx 155 "cache_validity=0x%lx (%s) nfs_flags=0x%lx (%s)", 115 -__entry->error, show_ !! 156 -__entry->error, nfs_show_status(__entry->error), 116 MAJOR(__entry->dev), M 157 MAJOR(__entry->dev), MINOR(__entry->dev), 117 (unsigned long long)__ 158 (unsigned long long)__entry->fileid, 118 __entry->fhandle, 159 __entry->fhandle, 119 __entry->type, 160 __entry->type, 120 show_fs_dirent_type(__ !! 161 nfs_show_file_type(__entry->type), 121 (unsigned long long)__ 162 (unsigned long long)__entry->version, 122 (long long)__entry->si 163 (long long)__entry->size, 123 __entry->cache_validit 164 __entry->cache_validity, 124 nfs_show_cache_validit 165 nfs_show_cache_validity(__entry->cache_validity), 125 __entry->nfsi_flags, 166 __entry->nfsi_flags, 126 nfs_show_nfsi_flags(__ 167 nfs_show_nfsi_flags(__entry->nfsi_flags) 127 ) 168 ) 128 ); 169 ); 129 170 130 #define DEFINE_NFS_INODE_EVENT(name) \ 171 #define DEFINE_NFS_INODE_EVENT(name) \ 131 DEFINE_EVENT(nfs_inode_event, name, \ 172 DEFINE_EVENT(nfs_inode_event, name, \ 132 TP_PROTO( \ 173 TP_PROTO( \ 133 const struct i 174 const struct inode *inode \ 134 ), \ 175 ), \ 135 TP_ARGS(inode)) 176 TP_ARGS(inode)) 136 #define DEFINE_NFS_INODE_EVENT_DONE(name) \ 177 #define DEFINE_NFS_INODE_EVENT_DONE(name) \ 137 DEFINE_EVENT(nfs_inode_event_done, nam 178 DEFINE_EVENT(nfs_inode_event_done, name, \ 138 TP_PROTO( \ 179 TP_PROTO( \ 139 const struct i 180 const struct inode *inode, \ 140 int error \ 181 int error \ 141 ), \ 182 ), \ 142 TP_ARGS(inode, error)) 183 TP_ARGS(inode, error)) 143 DEFINE_NFS_INODE_EVENT(nfs_set_inode_stale); << 144 DEFINE_NFS_INODE_EVENT(nfs_refresh_inode_enter 184 DEFINE_NFS_INODE_EVENT(nfs_refresh_inode_enter); 145 DEFINE_NFS_INODE_EVENT_DONE(nfs_refresh_inode_ 185 DEFINE_NFS_INODE_EVENT_DONE(nfs_refresh_inode_exit); 146 DEFINE_NFS_INODE_EVENT(nfs_revalidate_inode_en 186 DEFINE_NFS_INODE_EVENT(nfs_revalidate_inode_enter); 147 DEFINE_NFS_INODE_EVENT_DONE(nfs_revalidate_ino 187 DEFINE_NFS_INODE_EVENT_DONE(nfs_revalidate_inode_exit); 148 DEFINE_NFS_INODE_EVENT(nfs_invalidate_mapping_ 188 DEFINE_NFS_INODE_EVENT(nfs_invalidate_mapping_enter); 149 DEFINE_NFS_INODE_EVENT_DONE(nfs_invalidate_map 189 DEFINE_NFS_INODE_EVENT_DONE(nfs_invalidate_mapping_exit); 150 DEFINE_NFS_INODE_EVENT(nfs_getattr_enter); 190 DEFINE_NFS_INODE_EVENT(nfs_getattr_enter); 151 DEFINE_NFS_INODE_EVENT_DONE(nfs_getattr_exit); 191 DEFINE_NFS_INODE_EVENT_DONE(nfs_getattr_exit); 152 DEFINE_NFS_INODE_EVENT(nfs_setattr_enter); 192 DEFINE_NFS_INODE_EVENT(nfs_setattr_enter); 153 DEFINE_NFS_INODE_EVENT_DONE(nfs_setattr_exit); 193 DEFINE_NFS_INODE_EVENT_DONE(nfs_setattr_exit); >> 194 DEFINE_NFS_INODE_EVENT(nfs_writeback_page_enter); >> 195 DEFINE_NFS_INODE_EVENT_DONE(nfs_writeback_page_exit); 154 DEFINE_NFS_INODE_EVENT(nfs_writeback_inode_ent 196 DEFINE_NFS_INODE_EVENT(nfs_writeback_inode_enter); 155 DEFINE_NFS_INODE_EVENT_DONE(nfs_writeback_inod 197 DEFINE_NFS_INODE_EVENT_DONE(nfs_writeback_inode_exit); 156 DEFINE_NFS_INODE_EVENT(nfs_fsync_enter); 198 DEFINE_NFS_INODE_EVENT(nfs_fsync_enter); 157 DEFINE_NFS_INODE_EVENT_DONE(nfs_fsync_exit); 199 DEFINE_NFS_INODE_EVENT_DONE(nfs_fsync_exit); 158 DEFINE_NFS_INODE_EVENT(nfs_access_enter); 200 DEFINE_NFS_INODE_EVENT(nfs_access_enter); 159 DEFINE_NFS_INODE_EVENT_DONE(nfs_set_cache_inva !! 201 DEFINE_NFS_INODE_EVENT_DONE(nfs_access_exit); 160 DEFINE_NFS_INODE_EVENT(nfs_readdir_force_readd << 161 DEFINE_NFS_INODE_EVENT_DONE(nfs_readdir_cache_ << 162 DEFINE_NFS_INODE_EVENT_DONE(nfs_readdir_uncach << 163 << 164 TRACE_EVENT(nfs_access_exit, << 165 TP_PROTO( << 166 const struct inode *in << 167 unsigned int mask, << 168 unsigned int permitted << 169 int error << 170 ), << 171 << 172 TP_ARGS(inode, mask, permitted << 173 << 174 TP_STRUCT__entry( << 175 __field(unsigned long, << 176 __field(dev_t, dev) << 177 __field(u32, fhandle) << 178 __field(unsigned char, << 179 __field(u64, fileid) << 180 __field(u64, version) << 181 __field(loff_t, size) << 182 __field(unsigned long, << 183 __field(unsigned long, << 184 __field(unsigned int, << 185 __field(unsigned int, << 186 ), << 187 << 188 TP_fast_assign( << 189 const struct nfs_inode << 190 __entry->error = error << 191 __entry->dev = inode-> << 192 __entry->fileid = nfsi << 193 __entry->fhandle = nfs << 194 __entry->type = nfs_um << 195 __entry->version = ino << 196 __entry->size = i_size << 197 __entry->nfsi_flags = << 198 __entry->cache_validit << 199 __entry->mask = mask; << 200 __entry->permitted = p << 201 ), << 202 << 203 TP_printk( << 204 "error=%ld (%s) fileid << 205 "type=%u (%s) version= << 206 "cache_validity=0x%lx << 207 "mask=0x%x permitted=0 << 208 -__entry->error, show_ << 209 MAJOR(__entry->dev), M << 210 (unsigned long long)__ << 211 __entry->fhandle, << 212 __entry->type, << 213 show_fs_dirent_type(__ << 214 (unsigned long long)__ << 215 (long long)__entry->si << 216 __entry->cache_validit << 217 nfs_show_cache_validit << 218 __entry->nfsi_flags, << 219 nfs_show_nfsi_flags(__ << 220 __entry->mask, __entry << 221 ) << 222 ); << 223 << 224 DECLARE_EVENT_CLASS(nfs_update_size_class, << 225 TP_PROTO( << 226 const struct inode *in << 227 loff_t new_size << 228 ), << 229 << 230 TP_ARGS(inode, new_size), << 231 << 232 TP_STRUCT__entry( << 233 __field(dev_t, dev) << 234 __field(u32, fhandle) << 235 __field(u64, fileid) << 236 __field(u64, version) << 237 __field(loff_t, cur_si << 238 __field(loff_t, new_si << 239 ), << 240 << 241 TP_fast_assign( << 242 const struct nfs_inode << 243 << 244 __entry->dev = inode-> << 245 __entry->fhandle = nfs << 246 __entry->fileid = nfsi << 247 __entry->version = ino << 248 __entry->cur_size = i_ << 249 __entry->new_size = ne << 250 ), << 251 << 252 TP_printk( << 253 "fileid=%02x:%02x:%llu << 254 MAJOR(__entry->dev), M << 255 (unsigned long long)__ << 256 __entry->fhandle, __en << 257 __entry->cur_size, __e << 258 ) << 259 ); << 260 << 261 #define DEFINE_NFS_UPDATE_SIZE_EVENT(name) \ << 262 DEFINE_EVENT(nfs_update_size_class, nf << 263 TP_PROTO( \ << 264 const struct i << 265 loff_t new_siz << 266 ), \ << 267 TP_ARGS(inode, new_siz << 268 << 269 DEFINE_NFS_UPDATE_SIZE_EVENT(truncate); << 270 DEFINE_NFS_UPDATE_SIZE_EVENT(wcc); << 271 DEFINE_NFS_UPDATE_SIZE_EVENT(update); << 272 DEFINE_NFS_UPDATE_SIZE_EVENT(grow); << 273 << 274 DECLARE_EVENT_CLASS(nfs_inode_range_event, << 275 TP_PROTO( << 276 const struct inode *in << 277 loff_t range_start, << 278 loff_t range_end << 279 ), << 280 << 281 TP_ARGS(inode, range_start, ra << 282 << 283 TP_STRUCT__entry( << 284 __field(dev_t, dev) << 285 __field(u32, fhandle) << 286 __field(u64, fileid) << 287 __field(u64, version) << 288 __field(loff_t, range_ << 289 __field(loff_t, range_ << 290 ), << 291 << 292 TP_fast_assign( << 293 const struct nfs_inode << 294 << 295 __entry->dev = inode-> << 296 __entry->fhandle = nfs << 297 __entry->fileid = nfsi << 298 __entry->version = ino << 299 __entry->range_start = << 300 __entry->range_end = r << 301 ), << 302 << 303 TP_printk( << 304 "fileid=%02x:%02x:%llu << 305 "range=[%lld, %lld]", << 306 MAJOR(__entry->dev), M << 307 (unsigned long long)__ << 308 __entry->fhandle, __en << 309 __entry->range_start, << 310 ) << 311 ); << 312 202 313 #define DEFINE_NFS_INODE_RANGE_EVENT(name) \ !! 203 TRACE_DEFINE_ENUM(LOOKUP_FOLLOW); 314 DEFINE_EVENT(nfs_inode_range_event, na !! 204 TRACE_DEFINE_ENUM(LOOKUP_DIRECTORY); 315 TP_PROTO( \ !! 205 TRACE_DEFINE_ENUM(LOOKUP_AUTOMOUNT); 316 const struct i !! 206 TRACE_DEFINE_ENUM(LOOKUP_PARENT); 317 loff_t range_s !! 207 TRACE_DEFINE_ENUM(LOOKUP_REVAL); 318 loff_t range_e !! 208 TRACE_DEFINE_ENUM(LOOKUP_RCU); 319 ), \ !! 209 TRACE_DEFINE_ENUM(LOOKUP_NO_REVAL); 320 TP_ARGS(inode, range_s !! 210 TRACE_DEFINE_ENUM(LOOKUP_NO_EVAL); 321 !! 211 TRACE_DEFINE_ENUM(LOOKUP_OPEN); 322 DEFINE_NFS_INODE_RANGE_EVENT(nfs_readdir_inval !! 212 TRACE_DEFINE_ENUM(LOOKUP_CREATE); 323 !! 213 TRACE_DEFINE_ENUM(LOOKUP_EXCL); 324 DECLARE_EVENT_CLASS(nfs_readdir_event, !! 214 TRACE_DEFINE_ENUM(LOOKUP_RENAME_TARGET); 325 TP_PROTO( !! 215 TRACE_DEFINE_ENUM(LOOKUP_JUMPED); 326 const struct file *fil !! 216 TRACE_DEFINE_ENUM(LOOKUP_ROOT); 327 const __be32 *verifier !! 217 TRACE_DEFINE_ENUM(LOOKUP_EMPTY); 328 u64 cookie, !! 218 TRACE_DEFINE_ENUM(LOOKUP_DOWN); 329 pgoff_t page_index, !! 219 330 unsigned int dtsize !! 220 #define show_lookup_flags(flags) \ 331 ), !! 221 __print_flags(flags, "|", \ 332 !! 222 { LOOKUP_FOLLOW, "FOLLOW" }, \ 333 TP_ARGS(file, verifier, cookie !! 223 { LOOKUP_DIRECTORY, "DIRECTORY" }, \ 334 !! 224 { LOOKUP_AUTOMOUNT, "AUTOMOUNT" }, \ 335 TP_STRUCT__entry( !! 225 { LOOKUP_PARENT, "PARENT" }, \ 336 __field(dev_t, dev) !! 226 { LOOKUP_REVAL, "REVAL" }, \ 337 __field(u32, fhandle) !! 227 { LOOKUP_RCU, "RCU" }, \ 338 __field(u64, fileid) !! 228 { LOOKUP_NO_REVAL, "NO_REVAL" }, \ 339 __field(u64, version) !! 229 { LOOKUP_NO_EVAL, "NO_EVAL" }, \ 340 __array(char, verifier !! 230 { LOOKUP_OPEN, "OPEN" }, \ 341 __field(u64, cookie) !! 231 { LOOKUP_CREATE, "CREATE" }, \ 342 __field(pgoff_t, index !! 232 { LOOKUP_EXCL, "EXCL" }, \ 343 __field(unsigned int, !! 233 { LOOKUP_RENAME_TARGET, "RENAME_TARGET" }, \ 344 ), !! 234 { LOOKUP_JUMPED, "JUMPED" }, \ 345 !! 235 { LOOKUP_ROOT, "ROOT" }, \ 346 TP_fast_assign( !! 236 { LOOKUP_EMPTY, "EMPTY" }, \ 347 const struct inode *di !! 237 { LOOKUP_DOWN, "DOWN" }) 348 const struct nfs_inode << 349 << 350 __entry->dev = dir->i_ << 351 __entry->fileid = nfsi << 352 __entry->fhandle = nfs << 353 __entry->version = ino << 354 if (cookie != 0) << 355 memcpy(__entry << 356 NFS4_VE << 357 else << 358 memset(__entry << 359 NFS4_VE << 360 __entry->cookie = cook << 361 __entry->index = page_ << 362 __entry->dtsize = dtsi << 363 ), << 364 << 365 TP_printk( << 366 "fileid=%02x:%02x:%llu << 367 "cookie=%s:0x%llx cach << 368 MAJOR(__entry->dev), M << 369 (unsigned long long)__ << 370 __entry->version, show << 371 (unsigned long long)__ << 372 __entry->dtsize << 373 ) << 374 ); << 375 << 376 #define DEFINE_NFS_READDIR_EVENT(name) \ << 377 DEFINE_EVENT(nfs_readdir_event, name, << 378 TP_PROTO( \ << 379 const struct f << 380 const __be32 * << 381 u64 cookie, \ << 382 pgoff_t page_i << 383 unsigned int d << 384 ), \ << 385 TP_ARGS(file, verifier << 386 << 387 DEFINE_NFS_READDIR_EVENT(nfs_readdir_cache_fil << 388 DEFINE_NFS_READDIR_EVENT(nfs_readdir_uncached) << 389 238 390 DECLARE_EVENT_CLASS(nfs_lookup_event, 239 DECLARE_EVENT_CLASS(nfs_lookup_event, 391 TP_PROTO( 240 TP_PROTO( 392 const struct inode *di 241 const struct inode *dir, 393 const struct dentry *d 242 const struct dentry *dentry, 394 unsigned int flags 243 unsigned int flags 395 ), 244 ), 396 245 397 TP_ARGS(dir, dentry, flags), 246 TP_ARGS(dir, dentry, flags), 398 247 399 TP_STRUCT__entry( 248 TP_STRUCT__entry( 400 __field(unsigned long, 249 __field(unsigned long, flags) 401 __field(dev_t, dev) 250 __field(dev_t, dev) 402 __field(u64, dir) 251 __field(u64, dir) 403 __field(u64, fileid) << 404 __string(name, dentry- 252 __string(name, dentry->d_name.name) 405 ), 253 ), 406 254 407 TP_fast_assign( 255 TP_fast_assign( 408 __entry->dev = dir->i_ 256 __entry->dev = dir->i_sb->s_dev; 409 __entry->dir = NFS_FIL 257 __entry->dir = NFS_FILEID(dir); 410 __entry->flags = flags 258 __entry->flags = flags; 411 __entry->fileid = d_is !! 259 __assign_str(name, dentry->d_name.name); 412 __assign_str(name); << 413 ), 260 ), 414 261 415 TP_printk( 262 TP_printk( 416 "flags=0x%lx (%s) name !! 263 "flags=0x%lx (%s) name=%02x:%02x:%llu/%s", 417 __entry->flags, 264 __entry->flags, 418 show_fs_lookup_flags(_ !! 265 show_lookup_flags(__entry->flags), 419 MAJOR(__entry->dev), M 266 MAJOR(__entry->dev), MINOR(__entry->dev), 420 (unsigned long long)__ 267 (unsigned long long)__entry->dir, 421 __get_str(name), !! 268 __get_str(name) 422 __entry->fileid << 423 ) 269 ) 424 ); 270 ); 425 271 426 #define DEFINE_NFS_LOOKUP_EVENT(name) \ 272 #define DEFINE_NFS_LOOKUP_EVENT(name) \ 427 DEFINE_EVENT(nfs_lookup_event, name, \ 273 DEFINE_EVENT(nfs_lookup_event, name, \ 428 TP_PROTO( \ 274 TP_PROTO( \ 429 const struct i 275 const struct inode *dir, \ 430 const struct d 276 const struct dentry *dentry, \ 431 unsigned int f 277 unsigned int flags \ 432 ), \ 278 ), \ 433 TP_ARGS(dir, dentry, f 279 TP_ARGS(dir, dentry, flags)) 434 280 435 DECLARE_EVENT_CLASS(nfs_lookup_event_done, 281 DECLARE_EVENT_CLASS(nfs_lookup_event_done, 436 TP_PROTO( 282 TP_PROTO( 437 const struct inode *di 283 const struct inode *dir, 438 const struct dentry *d 284 const struct dentry *dentry, 439 unsigned int flags, 285 unsigned int flags, 440 int error 286 int error 441 ), 287 ), 442 288 443 TP_ARGS(dir, dentry, flags, er 289 TP_ARGS(dir, dentry, flags, error), 444 290 445 TP_STRUCT__entry( 291 TP_STRUCT__entry( 446 __field(unsigned long, 292 __field(unsigned long, error) 447 __field(unsigned long, 293 __field(unsigned long, flags) 448 __field(dev_t, dev) 294 __field(dev_t, dev) 449 __field(u64, dir) 295 __field(u64, dir) 450 __field(u64, fileid) << 451 __string(name, dentry- 296 __string(name, dentry->d_name.name) 452 ), 297 ), 453 298 454 TP_fast_assign( 299 TP_fast_assign( 455 __entry->dev = dir->i_ 300 __entry->dev = dir->i_sb->s_dev; 456 __entry->dir = NFS_FIL 301 __entry->dir = NFS_FILEID(dir); 457 __entry->error = error 302 __entry->error = error < 0 ? -error : 0; 458 __entry->flags = flags 303 __entry->flags = flags; 459 __entry->fileid = d_is !! 304 __assign_str(name, dentry->d_name.name); 460 __assign_str(name); << 461 ), 305 ), 462 306 463 TP_printk( 307 TP_printk( 464 "error=%ld (%s) flags= !! 308 "error=%ld (%s) flags=0x%lx (%s) name=%02x:%02x:%llu/%s", 465 -__entry->error, show_ !! 309 -__entry->error, nfs_show_status(__entry->error), 466 __entry->flags, 310 __entry->flags, 467 show_fs_lookup_flags(_ !! 311 show_lookup_flags(__entry->flags), 468 MAJOR(__entry->dev), M 312 MAJOR(__entry->dev), MINOR(__entry->dev), 469 (unsigned long long)__ 313 (unsigned long long)__entry->dir, 470 __get_str(name), !! 314 __get_str(name) 471 __entry->fileid << 472 ) 315 ) 473 ); 316 ); 474 317 475 #define DEFINE_NFS_LOOKUP_EVENT_DONE(name) \ 318 #define DEFINE_NFS_LOOKUP_EVENT_DONE(name) \ 476 DEFINE_EVENT(nfs_lookup_event_done, na 319 DEFINE_EVENT(nfs_lookup_event_done, name, \ 477 TP_PROTO( \ 320 TP_PROTO( \ 478 const struct i 321 const struct inode *dir, \ 479 const struct d 322 const struct dentry *dentry, \ 480 unsigned int f 323 unsigned int flags, \ 481 int error \ 324 int error \ 482 ), \ 325 ), \ 483 TP_ARGS(dir, dentry, f 326 TP_ARGS(dir, dentry, flags, error)) 484 327 485 DEFINE_NFS_LOOKUP_EVENT(nfs_lookup_enter); 328 DEFINE_NFS_LOOKUP_EVENT(nfs_lookup_enter); 486 DEFINE_NFS_LOOKUP_EVENT_DONE(nfs_lookup_exit); 329 DEFINE_NFS_LOOKUP_EVENT_DONE(nfs_lookup_exit); 487 DEFINE_NFS_LOOKUP_EVENT(nfs_lookup_revalidate_ 330 DEFINE_NFS_LOOKUP_EVENT(nfs_lookup_revalidate_enter); 488 DEFINE_NFS_LOOKUP_EVENT_DONE(nfs_lookup_revali 331 DEFINE_NFS_LOOKUP_EVENT_DONE(nfs_lookup_revalidate_exit); 489 DEFINE_NFS_LOOKUP_EVENT(nfs_readdir_lookup); !! 332 490 DEFINE_NFS_LOOKUP_EVENT(nfs_readdir_lookup_rev !! 333 TRACE_DEFINE_ENUM(O_WRONLY); 491 DEFINE_NFS_LOOKUP_EVENT_DONE(nfs_readdir_looku !! 334 TRACE_DEFINE_ENUM(O_RDWR); >> 335 TRACE_DEFINE_ENUM(O_CREAT); >> 336 TRACE_DEFINE_ENUM(O_EXCL); >> 337 TRACE_DEFINE_ENUM(O_NOCTTY); >> 338 TRACE_DEFINE_ENUM(O_TRUNC); >> 339 TRACE_DEFINE_ENUM(O_APPEND); >> 340 TRACE_DEFINE_ENUM(O_NONBLOCK); >> 341 TRACE_DEFINE_ENUM(O_DSYNC); >> 342 TRACE_DEFINE_ENUM(O_DIRECT); >> 343 TRACE_DEFINE_ENUM(O_LARGEFILE); >> 344 TRACE_DEFINE_ENUM(O_DIRECTORY); >> 345 TRACE_DEFINE_ENUM(O_NOFOLLOW); >> 346 TRACE_DEFINE_ENUM(O_NOATIME); >> 347 TRACE_DEFINE_ENUM(O_CLOEXEC); >> 348 >> 349 #define show_open_flags(flags) \ >> 350 __print_flags(flags, "|", \ >> 351 { O_WRONLY, "O_WRONLY" }, \ >> 352 { O_RDWR, "O_RDWR" }, \ >> 353 { O_CREAT, "O_CREAT" }, \ >> 354 { O_EXCL, "O_EXCL" }, \ >> 355 { O_NOCTTY, "O_NOCTTY" }, \ >> 356 { O_TRUNC, "O_TRUNC" }, \ >> 357 { O_APPEND, "O_APPEND" }, \ >> 358 { O_NONBLOCK, "O_NONBLOCK" }, \ >> 359 { O_DSYNC, "O_DSYNC" }, \ >> 360 { O_DIRECT, "O_DIRECT" }, \ >> 361 { O_LARGEFILE, "O_LARGEFILE" }, \ >> 362 { O_DIRECTORY, "O_DIRECTORY" }, \ >> 363 { O_NOFOLLOW, "O_NOFOLLOW" }, \ >> 364 { O_NOATIME, "O_NOATIME" }, \ >> 365 { O_CLOEXEC, "O_CLOEXEC" }) >> 366 >> 367 TRACE_DEFINE_ENUM(FMODE_READ); >> 368 TRACE_DEFINE_ENUM(FMODE_WRITE); >> 369 TRACE_DEFINE_ENUM(FMODE_EXEC); >> 370 >> 371 #define show_fmode_flags(mode) \ >> 372 __print_flags(mode, "|", \ >> 373 { ((__force unsigned long)FMODE_READ), "READ" }, \ >> 374 { ((__force unsigned long)FMODE_WRITE), "WRITE" }, \ >> 375 { ((__force unsigned long)FMODE_EXEC), "EXEC" }) 492 376 493 TRACE_EVENT(nfs_atomic_open_enter, 377 TRACE_EVENT(nfs_atomic_open_enter, 494 TP_PROTO( 378 TP_PROTO( 495 const struct inode *di 379 const struct inode *dir, 496 const struct nfs_open_ 380 const struct nfs_open_context *ctx, 497 unsigned int flags 381 unsigned int flags 498 ), 382 ), 499 383 500 TP_ARGS(dir, ctx, flags), 384 TP_ARGS(dir, ctx, flags), 501 385 502 TP_STRUCT__entry( 386 TP_STRUCT__entry( 503 __field(unsigned long, 387 __field(unsigned long, flags) 504 __field(unsigned long, !! 388 __field(unsigned int, fmode) 505 __field(dev_t, dev) 389 __field(dev_t, dev) 506 __field(u64, dir) 390 __field(u64, dir) 507 __string(name, ctx->de 391 __string(name, ctx->dentry->d_name.name) 508 ), 392 ), 509 393 510 TP_fast_assign( 394 TP_fast_assign( 511 __entry->dev = dir->i_ 395 __entry->dev = dir->i_sb->s_dev; 512 __entry->dir = NFS_FIL 396 __entry->dir = NFS_FILEID(dir); 513 __entry->flags = flags 397 __entry->flags = flags; 514 __entry->fmode = (__fo !! 398 __entry->fmode = (__force unsigned int)ctx->mode; 515 __assign_str(name); !! 399 __assign_str(name, ctx->dentry->d_name.name); 516 ), 400 ), 517 401 518 TP_printk( 402 TP_printk( 519 "flags=0x%lx (%s) fmod 403 "flags=0x%lx (%s) fmode=%s name=%02x:%02x:%llu/%s", 520 __entry->flags, 404 __entry->flags, 521 show_fs_fcntl_open_fla !! 405 show_open_flags(__entry->flags), 522 show_fs_fmode_flags(__ !! 406 show_fmode_flags(__entry->fmode), 523 MAJOR(__entry->dev), M 407 MAJOR(__entry->dev), MINOR(__entry->dev), 524 (unsigned long long)__ 408 (unsigned long long)__entry->dir, 525 __get_str(name) 409 __get_str(name) 526 ) 410 ) 527 ); 411 ); 528 412 529 TRACE_EVENT(nfs_atomic_open_exit, 413 TRACE_EVENT(nfs_atomic_open_exit, 530 TP_PROTO( 414 TP_PROTO( 531 const struct inode *di 415 const struct inode *dir, 532 const struct nfs_open_ 416 const struct nfs_open_context *ctx, 533 unsigned int flags, 417 unsigned int flags, 534 int error 418 int error 535 ), 419 ), 536 420 537 TP_ARGS(dir, ctx, flags, error 421 TP_ARGS(dir, ctx, flags, error), 538 422 539 TP_STRUCT__entry( 423 TP_STRUCT__entry( 540 __field(unsigned long, 424 __field(unsigned long, error) 541 __field(unsigned long, 425 __field(unsigned long, flags) 542 __field(unsigned long, !! 426 __field(unsigned int, fmode) 543 __field(dev_t, dev) 427 __field(dev_t, dev) 544 __field(u64, dir) 428 __field(u64, dir) 545 __string(name, ctx->de 429 __string(name, ctx->dentry->d_name.name) 546 ), 430 ), 547 431 548 TP_fast_assign( 432 TP_fast_assign( 549 __entry->error = -erro 433 __entry->error = -error; 550 __entry->dev = dir->i_ 434 __entry->dev = dir->i_sb->s_dev; 551 __entry->dir = NFS_FIL 435 __entry->dir = NFS_FILEID(dir); 552 __entry->flags = flags 436 __entry->flags = flags; 553 __entry->fmode = (__fo !! 437 __entry->fmode = (__force unsigned int)ctx->mode; 554 __assign_str(name); !! 438 __assign_str(name, ctx->dentry->d_name.name); 555 ), 439 ), 556 440 557 TP_printk( 441 TP_printk( 558 "error=%ld (%s) flags= 442 "error=%ld (%s) flags=0x%lx (%s) fmode=%s " 559 "name=%02x:%02x:%llu/% 443 "name=%02x:%02x:%llu/%s", 560 -__entry->error, show_ !! 444 -__entry->error, nfs_show_status(__entry->error), 561 __entry->flags, 445 __entry->flags, 562 show_fs_fcntl_open_fla !! 446 show_open_flags(__entry->flags), 563 show_fs_fmode_flags(__ !! 447 show_fmode_flags(__entry->fmode), 564 MAJOR(__entry->dev), M 448 MAJOR(__entry->dev), MINOR(__entry->dev), 565 (unsigned long long)__ 449 (unsigned long long)__entry->dir, 566 __get_str(name) 450 __get_str(name) 567 ) 451 ) 568 ); 452 ); 569 453 570 TRACE_EVENT(nfs_create_enter, 454 TRACE_EVENT(nfs_create_enter, 571 TP_PROTO( 455 TP_PROTO( 572 const struct inode *di 456 const struct inode *dir, 573 const struct dentry *d 457 const struct dentry *dentry, 574 unsigned int flags 458 unsigned int flags 575 ), 459 ), 576 460 577 TP_ARGS(dir, dentry, flags), 461 TP_ARGS(dir, dentry, flags), 578 462 579 TP_STRUCT__entry( 463 TP_STRUCT__entry( 580 __field(unsigned long, 464 __field(unsigned long, flags) 581 __field(dev_t, dev) 465 __field(dev_t, dev) 582 __field(u64, dir) 466 __field(u64, dir) 583 __string(name, dentry- 467 __string(name, dentry->d_name.name) 584 ), 468 ), 585 469 586 TP_fast_assign( 470 TP_fast_assign( 587 __entry->dev = dir->i_ 471 __entry->dev = dir->i_sb->s_dev; 588 __entry->dir = NFS_FIL 472 __entry->dir = NFS_FILEID(dir); 589 __entry->flags = flags 473 __entry->flags = flags; 590 __assign_str(name); !! 474 __assign_str(name, dentry->d_name.name); 591 ), 475 ), 592 476 593 TP_printk( 477 TP_printk( 594 "flags=0x%lx (%s) name 478 "flags=0x%lx (%s) name=%02x:%02x:%llu/%s", 595 __entry->flags, 479 __entry->flags, 596 show_fs_fcntl_open_fla !! 480 show_open_flags(__entry->flags), 597 MAJOR(__entry->dev), M 481 MAJOR(__entry->dev), MINOR(__entry->dev), 598 (unsigned long long)__ 482 (unsigned long long)__entry->dir, 599 __get_str(name) 483 __get_str(name) 600 ) 484 ) 601 ); 485 ); 602 486 603 TRACE_EVENT(nfs_create_exit, 487 TRACE_EVENT(nfs_create_exit, 604 TP_PROTO( 488 TP_PROTO( 605 const struct inode *di 489 const struct inode *dir, 606 const struct dentry *d 490 const struct dentry *dentry, 607 unsigned int flags, 491 unsigned int flags, 608 int error 492 int error 609 ), 493 ), 610 494 611 TP_ARGS(dir, dentry, flags, er 495 TP_ARGS(dir, dentry, flags, error), 612 496 613 TP_STRUCT__entry( 497 TP_STRUCT__entry( 614 __field(unsigned long, 498 __field(unsigned long, error) 615 __field(unsigned long, 499 __field(unsigned long, flags) 616 __field(dev_t, dev) 500 __field(dev_t, dev) 617 __field(u64, dir) 501 __field(u64, dir) 618 __string(name, dentry- 502 __string(name, dentry->d_name.name) 619 ), 503 ), 620 504 621 TP_fast_assign( 505 TP_fast_assign( 622 __entry->error = -erro 506 __entry->error = -error; 623 __entry->dev = dir->i_ 507 __entry->dev = dir->i_sb->s_dev; 624 __entry->dir = NFS_FIL 508 __entry->dir = NFS_FILEID(dir); 625 __entry->flags = flags 509 __entry->flags = flags; 626 __assign_str(name); !! 510 __assign_str(name, dentry->d_name.name); 627 ), 511 ), 628 512 629 TP_printk( 513 TP_printk( 630 "error=%ld (%s) flags= 514 "error=%ld (%s) flags=0x%lx (%s) name=%02x:%02x:%llu/%s", 631 -__entry->error, show_ !! 515 -__entry->error, nfs_show_status(__entry->error), 632 __entry->flags, 516 __entry->flags, 633 show_fs_fcntl_open_fla !! 517 show_open_flags(__entry->flags), 634 MAJOR(__entry->dev), M 518 MAJOR(__entry->dev), MINOR(__entry->dev), 635 (unsigned long long)__ 519 (unsigned long long)__entry->dir, 636 __get_str(name) 520 __get_str(name) 637 ) 521 ) 638 ); 522 ); 639 523 640 DECLARE_EVENT_CLASS(nfs_directory_event, 524 DECLARE_EVENT_CLASS(nfs_directory_event, 641 TP_PROTO( 525 TP_PROTO( 642 const struct inode *di 526 const struct inode *dir, 643 const struct dentry *d 527 const struct dentry *dentry 644 ), 528 ), 645 529 646 TP_ARGS(dir, dentry), 530 TP_ARGS(dir, dentry), 647 531 648 TP_STRUCT__entry( 532 TP_STRUCT__entry( 649 __field(dev_t, dev) 533 __field(dev_t, dev) 650 __field(u64, dir) 534 __field(u64, dir) 651 __string(name, dentry- 535 __string(name, dentry->d_name.name) 652 ), 536 ), 653 537 654 TP_fast_assign( 538 TP_fast_assign( 655 __entry->dev = dir->i_ 539 __entry->dev = dir->i_sb->s_dev; 656 __entry->dir = NFS_FIL 540 __entry->dir = NFS_FILEID(dir); 657 __assign_str(name); !! 541 __assign_str(name, dentry->d_name.name); 658 ), 542 ), 659 543 660 TP_printk( 544 TP_printk( 661 "name=%02x:%02x:%llu/% 545 "name=%02x:%02x:%llu/%s", 662 MAJOR(__entry->dev), M 546 MAJOR(__entry->dev), MINOR(__entry->dev), 663 (unsigned long long)__ 547 (unsigned long long)__entry->dir, 664 __get_str(name) 548 __get_str(name) 665 ) 549 ) 666 ); 550 ); 667 551 668 #define DEFINE_NFS_DIRECTORY_EVENT(name) \ 552 #define DEFINE_NFS_DIRECTORY_EVENT(name) \ 669 DEFINE_EVENT(nfs_directory_event, name 553 DEFINE_EVENT(nfs_directory_event, name, \ 670 TP_PROTO( \ 554 TP_PROTO( \ 671 const struct i 555 const struct inode *dir, \ 672 const struct d 556 const struct dentry *dentry \ 673 ), \ 557 ), \ 674 TP_ARGS(dir, dentry)) 558 TP_ARGS(dir, dentry)) 675 559 676 DECLARE_EVENT_CLASS(nfs_directory_event_done, 560 DECLARE_EVENT_CLASS(nfs_directory_event_done, 677 TP_PROTO( 561 TP_PROTO( 678 const struct inode *di 562 const struct inode *dir, 679 const struct dentry *d 563 const struct dentry *dentry, 680 int error 564 int error 681 ), 565 ), 682 566 683 TP_ARGS(dir, dentry, error), 567 TP_ARGS(dir, dentry, error), 684 568 685 TP_STRUCT__entry( 569 TP_STRUCT__entry( 686 __field(unsigned long, 570 __field(unsigned long, error) 687 __field(dev_t, dev) 571 __field(dev_t, dev) 688 __field(u64, dir) 572 __field(u64, dir) 689 __string(name, dentry- 573 __string(name, dentry->d_name.name) 690 ), 574 ), 691 575 692 TP_fast_assign( 576 TP_fast_assign( 693 __entry->dev = dir->i_ 577 __entry->dev = dir->i_sb->s_dev; 694 __entry->dir = NFS_FIL 578 __entry->dir = NFS_FILEID(dir); 695 __entry->error = error 579 __entry->error = error < 0 ? -error : 0; 696 __assign_str(name); !! 580 __assign_str(name, dentry->d_name.name); 697 ), 581 ), 698 582 699 TP_printk( 583 TP_printk( 700 "error=%ld (%s) name=% 584 "error=%ld (%s) name=%02x:%02x:%llu/%s", 701 -__entry->error, show_ !! 585 -__entry->error, nfs_show_status(__entry->error), 702 MAJOR(__entry->dev), M 586 MAJOR(__entry->dev), MINOR(__entry->dev), 703 (unsigned long long)__ 587 (unsigned long long)__entry->dir, 704 __get_str(name) 588 __get_str(name) 705 ) 589 ) 706 ); 590 ); 707 591 708 #define DEFINE_NFS_DIRECTORY_EVENT_DONE(name) 592 #define DEFINE_NFS_DIRECTORY_EVENT_DONE(name) \ 709 DEFINE_EVENT(nfs_directory_event_done, 593 DEFINE_EVENT(nfs_directory_event_done, name, \ 710 TP_PROTO( \ 594 TP_PROTO( \ 711 const struct i 595 const struct inode *dir, \ 712 const struct d 596 const struct dentry *dentry, \ 713 int error \ 597 int error \ 714 ), \ 598 ), \ 715 TP_ARGS(dir, dentry, e 599 TP_ARGS(dir, dentry, error)) 716 600 717 DEFINE_NFS_DIRECTORY_EVENT(nfs_mknod_enter); 601 DEFINE_NFS_DIRECTORY_EVENT(nfs_mknod_enter); 718 DEFINE_NFS_DIRECTORY_EVENT_DONE(nfs_mknod_exit 602 DEFINE_NFS_DIRECTORY_EVENT_DONE(nfs_mknod_exit); 719 DEFINE_NFS_DIRECTORY_EVENT(nfs_mkdir_enter); 603 DEFINE_NFS_DIRECTORY_EVENT(nfs_mkdir_enter); 720 DEFINE_NFS_DIRECTORY_EVENT_DONE(nfs_mkdir_exit 604 DEFINE_NFS_DIRECTORY_EVENT_DONE(nfs_mkdir_exit); 721 DEFINE_NFS_DIRECTORY_EVENT(nfs_rmdir_enter); 605 DEFINE_NFS_DIRECTORY_EVENT(nfs_rmdir_enter); 722 DEFINE_NFS_DIRECTORY_EVENT_DONE(nfs_rmdir_exit 606 DEFINE_NFS_DIRECTORY_EVENT_DONE(nfs_rmdir_exit); 723 DEFINE_NFS_DIRECTORY_EVENT(nfs_remove_enter); 607 DEFINE_NFS_DIRECTORY_EVENT(nfs_remove_enter); 724 DEFINE_NFS_DIRECTORY_EVENT_DONE(nfs_remove_exi 608 DEFINE_NFS_DIRECTORY_EVENT_DONE(nfs_remove_exit); 725 DEFINE_NFS_DIRECTORY_EVENT(nfs_unlink_enter); 609 DEFINE_NFS_DIRECTORY_EVENT(nfs_unlink_enter); 726 DEFINE_NFS_DIRECTORY_EVENT_DONE(nfs_unlink_exi 610 DEFINE_NFS_DIRECTORY_EVENT_DONE(nfs_unlink_exit); 727 DEFINE_NFS_DIRECTORY_EVENT(nfs_symlink_enter); 611 DEFINE_NFS_DIRECTORY_EVENT(nfs_symlink_enter); 728 DEFINE_NFS_DIRECTORY_EVENT_DONE(nfs_symlink_ex 612 DEFINE_NFS_DIRECTORY_EVENT_DONE(nfs_symlink_exit); 729 613 730 TRACE_EVENT(nfs_link_enter, 614 TRACE_EVENT(nfs_link_enter, 731 TP_PROTO( 615 TP_PROTO( 732 const struct inode *in 616 const struct inode *inode, 733 const struct inode *di 617 const struct inode *dir, 734 const struct dentry *d 618 const struct dentry *dentry 735 ), 619 ), 736 620 737 TP_ARGS(inode, dir, dentry), 621 TP_ARGS(inode, dir, dentry), 738 622 739 TP_STRUCT__entry( 623 TP_STRUCT__entry( 740 __field(dev_t, dev) 624 __field(dev_t, dev) 741 __field(u64, fileid) 625 __field(u64, fileid) 742 __field(u64, dir) 626 __field(u64, dir) 743 __string(name, dentry- 627 __string(name, dentry->d_name.name) 744 ), 628 ), 745 629 746 TP_fast_assign( 630 TP_fast_assign( 747 __entry->dev = inode-> 631 __entry->dev = inode->i_sb->s_dev; 748 __entry->fileid = NFS_ 632 __entry->fileid = NFS_FILEID(inode); 749 __entry->dir = NFS_FIL 633 __entry->dir = NFS_FILEID(dir); 750 __assign_str(name); !! 634 __assign_str(name, dentry->d_name.name); 751 ), 635 ), 752 636 753 TP_printk( 637 TP_printk( 754 "fileid=%02x:%02x:%llu 638 "fileid=%02x:%02x:%llu name=%02x:%02x:%llu/%s", 755 MAJOR(__entry->dev), M 639 MAJOR(__entry->dev), MINOR(__entry->dev), 756 __entry->fileid, 640 __entry->fileid, 757 MAJOR(__entry->dev), M 641 MAJOR(__entry->dev), MINOR(__entry->dev), 758 (unsigned long long)__ 642 (unsigned long long)__entry->dir, 759 __get_str(name) 643 __get_str(name) 760 ) 644 ) 761 ); 645 ); 762 646 763 TRACE_EVENT(nfs_link_exit, 647 TRACE_EVENT(nfs_link_exit, 764 TP_PROTO( 648 TP_PROTO( 765 const struct inode *in 649 const struct inode *inode, 766 const struct inode *di 650 const struct inode *dir, 767 const struct dentry *d 651 const struct dentry *dentry, 768 int error 652 int error 769 ), 653 ), 770 654 771 TP_ARGS(inode, dir, dentry, er 655 TP_ARGS(inode, dir, dentry, error), 772 656 773 TP_STRUCT__entry( 657 TP_STRUCT__entry( 774 __field(unsigned long, 658 __field(unsigned long, error) 775 __field(dev_t, dev) 659 __field(dev_t, dev) 776 __field(u64, fileid) 660 __field(u64, fileid) 777 __field(u64, dir) 661 __field(u64, dir) 778 __string(name, dentry- 662 __string(name, dentry->d_name.name) 779 ), 663 ), 780 664 781 TP_fast_assign( 665 TP_fast_assign( 782 __entry->dev = inode-> 666 __entry->dev = inode->i_sb->s_dev; 783 __entry->fileid = NFS_ 667 __entry->fileid = NFS_FILEID(inode); 784 __entry->dir = NFS_FIL 668 __entry->dir = NFS_FILEID(dir); 785 __entry->error = error 669 __entry->error = error < 0 ? -error : 0; 786 __assign_str(name); !! 670 __assign_str(name, dentry->d_name.name); 787 ), 671 ), 788 672 789 TP_printk( 673 TP_printk( 790 "error=%ld (%s) fileid 674 "error=%ld (%s) fileid=%02x:%02x:%llu name=%02x:%02x:%llu/%s", 791 -__entry->error, show_ !! 675 -__entry->error, nfs_show_status(__entry->error), 792 MAJOR(__entry->dev), M 676 MAJOR(__entry->dev), MINOR(__entry->dev), 793 __entry->fileid, 677 __entry->fileid, 794 MAJOR(__entry->dev), M 678 MAJOR(__entry->dev), MINOR(__entry->dev), 795 (unsigned long long)__ 679 (unsigned long long)__entry->dir, 796 __get_str(name) 680 __get_str(name) 797 ) 681 ) 798 ); 682 ); 799 683 800 DECLARE_EVENT_CLASS(nfs_rename_event, 684 DECLARE_EVENT_CLASS(nfs_rename_event, 801 TP_PROTO( 685 TP_PROTO( 802 const struct inode *ol 686 const struct inode *old_dir, 803 const struct dentry *o 687 const struct dentry *old_dentry, 804 const struct inode *ne 688 const struct inode *new_dir, 805 const struct dentry *n 689 const struct dentry *new_dentry 806 ), 690 ), 807 691 808 TP_ARGS(old_dir, old_dentry, n 692 TP_ARGS(old_dir, old_dentry, new_dir, new_dentry), 809 693 810 TP_STRUCT__entry( 694 TP_STRUCT__entry( 811 __field(dev_t, dev) 695 __field(dev_t, dev) 812 __field(u64, old_dir) 696 __field(u64, old_dir) 813 __field(u64, new_dir) 697 __field(u64, new_dir) 814 __string(old_name, old 698 __string(old_name, old_dentry->d_name.name) 815 __string(new_name, new 699 __string(new_name, new_dentry->d_name.name) 816 ), 700 ), 817 701 818 TP_fast_assign( 702 TP_fast_assign( 819 __entry->dev = old_dir 703 __entry->dev = old_dir->i_sb->s_dev; 820 __entry->old_dir = NFS 704 __entry->old_dir = NFS_FILEID(old_dir); 821 __entry->new_dir = NFS 705 __entry->new_dir = NFS_FILEID(new_dir); 822 __assign_str(old_name) !! 706 __assign_str(old_name, old_dentry->d_name.name); 823 __assign_str(new_name) !! 707 __assign_str(new_name, new_dentry->d_name.name); 824 ), 708 ), 825 709 826 TP_printk( 710 TP_printk( 827 "old_name=%02x:%02x:%l 711 "old_name=%02x:%02x:%llu/%s new_name=%02x:%02x:%llu/%s", 828 MAJOR(__entry->dev), M 712 MAJOR(__entry->dev), MINOR(__entry->dev), 829 (unsigned long long)__ 713 (unsigned long long)__entry->old_dir, 830 __get_str(old_name), 714 __get_str(old_name), 831 MAJOR(__entry->dev), M 715 MAJOR(__entry->dev), MINOR(__entry->dev), 832 (unsigned long long)__ 716 (unsigned long long)__entry->new_dir, 833 __get_str(new_name) 717 __get_str(new_name) 834 ) 718 ) 835 ); 719 ); 836 #define DEFINE_NFS_RENAME_EVENT(name) \ 720 #define DEFINE_NFS_RENAME_EVENT(name) \ 837 DEFINE_EVENT(nfs_rename_event, name, \ 721 DEFINE_EVENT(nfs_rename_event, name, \ 838 TP_PROTO( \ 722 TP_PROTO( \ 839 const struct i 723 const struct inode *old_dir, \ 840 const struct d 724 const struct dentry *old_dentry, \ 841 const struct i 725 const struct inode *new_dir, \ 842 const struct d 726 const struct dentry *new_dentry \ 843 ), \ 727 ), \ 844 TP_ARGS(old_dir, old_d 728 TP_ARGS(old_dir, old_dentry, new_dir, new_dentry)) 845 729 846 DECLARE_EVENT_CLASS(nfs_rename_event_done, 730 DECLARE_EVENT_CLASS(nfs_rename_event_done, 847 TP_PROTO( 731 TP_PROTO( 848 const struct inode *ol 732 const struct inode *old_dir, 849 const struct dentry *o 733 const struct dentry *old_dentry, 850 const struct inode *ne 734 const struct inode *new_dir, 851 const struct dentry *n 735 const struct dentry *new_dentry, 852 int error 736 int error 853 ), 737 ), 854 738 855 TP_ARGS(old_dir, old_dentry, n 739 TP_ARGS(old_dir, old_dentry, new_dir, new_dentry, error), 856 740 857 TP_STRUCT__entry( 741 TP_STRUCT__entry( 858 __field(dev_t, dev) 742 __field(dev_t, dev) 859 __field(unsigned long, 743 __field(unsigned long, error) 860 __field(u64, old_dir) 744 __field(u64, old_dir) 861 __string(old_name, old 745 __string(old_name, old_dentry->d_name.name) 862 __field(u64, new_dir) 746 __field(u64, new_dir) 863 __string(new_name, new 747 __string(new_name, new_dentry->d_name.name) 864 ), 748 ), 865 749 866 TP_fast_assign( 750 TP_fast_assign( 867 __entry->dev = old_dir 751 __entry->dev = old_dir->i_sb->s_dev; 868 __entry->error = -erro 752 __entry->error = -error; 869 __entry->old_dir = NFS 753 __entry->old_dir = NFS_FILEID(old_dir); 870 __entry->new_dir = NFS 754 __entry->new_dir = NFS_FILEID(new_dir); 871 __assign_str(old_name) !! 755 __assign_str(old_name, old_dentry->d_name.name); 872 __assign_str(new_name) !! 756 __assign_str(new_name, new_dentry->d_name.name); 873 ), 757 ), 874 758 875 TP_printk( 759 TP_printk( 876 "error=%ld (%s) old_na 760 "error=%ld (%s) old_name=%02x:%02x:%llu/%s " 877 "new_name=%02x:%02x:%l 761 "new_name=%02x:%02x:%llu/%s", 878 -__entry->error, show_ !! 762 -__entry->error, nfs_show_status(__entry->error), 879 MAJOR(__entry->dev), M 763 MAJOR(__entry->dev), MINOR(__entry->dev), 880 (unsigned long long)__ 764 (unsigned long long)__entry->old_dir, 881 __get_str(old_name), 765 __get_str(old_name), 882 MAJOR(__entry->dev), M 766 MAJOR(__entry->dev), MINOR(__entry->dev), 883 (unsigned long long)__ 767 (unsigned long long)__entry->new_dir, 884 __get_str(new_name) 768 __get_str(new_name) 885 ) 769 ) 886 ); 770 ); 887 #define DEFINE_NFS_RENAME_EVENT_DONE(name) \ 771 #define DEFINE_NFS_RENAME_EVENT_DONE(name) \ 888 DEFINE_EVENT(nfs_rename_event_done, na 772 DEFINE_EVENT(nfs_rename_event_done, name, \ 889 TP_PROTO( \ 773 TP_PROTO( \ 890 const struct i 774 const struct inode *old_dir, \ 891 const struct d 775 const struct dentry *old_dentry, \ 892 const struct i 776 const struct inode *new_dir, \ 893 const struct d 777 const struct dentry *new_dentry, \ 894 int error \ 778 int error \ 895 ), \ 779 ), \ 896 TP_ARGS(old_dir, old_d 780 TP_ARGS(old_dir, old_dentry, new_dir, \ 897 new_dentry, er 781 new_dentry, error)) 898 782 899 DEFINE_NFS_RENAME_EVENT(nfs_rename_enter); 783 DEFINE_NFS_RENAME_EVENT(nfs_rename_enter); 900 DEFINE_NFS_RENAME_EVENT_DONE(nfs_rename_exit); 784 DEFINE_NFS_RENAME_EVENT_DONE(nfs_rename_exit); 901 785 902 DEFINE_NFS_RENAME_EVENT_DONE(nfs_async_rename_ !! 786 DEFINE_NFS_RENAME_EVENT_DONE(nfs_sillyrename_rename); 903 787 904 TRACE_EVENT(nfs_sillyrename_unlink, 788 TRACE_EVENT(nfs_sillyrename_unlink, 905 TP_PROTO( 789 TP_PROTO( 906 const struct nfs_unlin 790 const struct nfs_unlinkdata *data, 907 int error 791 int error 908 ), 792 ), 909 793 910 TP_ARGS(data, error), 794 TP_ARGS(data, error), 911 795 912 TP_STRUCT__entry( 796 TP_STRUCT__entry( 913 __field(dev_t, dev) 797 __field(dev_t, dev) 914 __field(unsigned long, 798 __field(unsigned long, error) 915 __field(u64, dir) 799 __field(u64, dir) 916 __dynamic_array(char, 800 __dynamic_array(char, name, data->args.name.len + 1) 917 ), 801 ), 918 802 919 TP_fast_assign( 803 TP_fast_assign( 920 struct inode *dir = d_ 804 struct inode *dir = d_inode(data->dentry->d_parent); 921 size_t len = data->arg 805 size_t len = data->args.name.len; 922 __entry->dev = dir->i_ 806 __entry->dev = dir->i_sb->s_dev; 923 __entry->dir = NFS_FIL 807 __entry->dir = NFS_FILEID(dir); 924 __entry->error = -erro 808 __entry->error = -error; 925 memcpy(__get_str(name) 809 memcpy(__get_str(name), 926 data->args.nam 810 data->args.name.name, len); 927 __get_str(name)[len] = 811 __get_str(name)[len] = 0; 928 ), 812 ), 929 813 930 TP_printk( 814 TP_printk( 931 "error=%ld (%s) name=% 815 "error=%ld (%s) name=%02x:%02x:%llu/%s", 932 -__entry->error, show_ !! 816 -__entry->error, nfs_show_status(__entry->error), 933 MAJOR(__entry->dev), M 817 MAJOR(__entry->dev), MINOR(__entry->dev), 934 (unsigned long long)__ 818 (unsigned long long)__entry->dir, 935 __get_str(name) 819 __get_str(name) 936 ) 820 ) 937 ); 821 ); 938 822 939 DECLARE_EVENT_CLASS(nfs_folio_event, !! 823 TRACE_EVENT(nfs_initiate_read, 940 TP_PROTO( 824 TP_PROTO( 941 const struct inode *in 825 const struct inode *inode, 942 loff_t offset, !! 826 loff_t offset, unsigned long count 943 size_t count << 944 ), 827 ), 945 828 946 TP_ARGS(inode, offset, count), 829 TP_ARGS(inode, offset, count), 947 830 948 TP_STRUCT__entry( 831 TP_STRUCT__entry( 949 __field(dev_t, dev) << 950 __field(u32, fhandle) << 951 __field(u64, fileid) << 952 __field(u64, version) << 953 __field(loff_t, offset 832 __field(loff_t, offset) 954 __field(size_t, count) !! 833 __field(unsigned long, count) 955 ), << 956 << 957 TP_fast_assign( << 958 const struct nfs_inode << 959 << 960 __entry->dev = inode-> << 961 __entry->fileid = nfsi << 962 __entry->fhandle = nfs << 963 __entry->version = ino << 964 __entry->offset = offs << 965 __entry->count = count << 966 ), << 967 << 968 TP_printk( << 969 "fileid=%02x:%02x:%llu << 970 "offset=%lld count=%zu << 971 MAJOR(__entry->dev), M << 972 (unsigned long long)__ << 973 __entry->fhandle, __en << 974 __entry->offset, __ent << 975 ) << 976 ); << 977 << 978 #define DEFINE_NFS_FOLIO_EVENT(name) \ << 979 DEFINE_EVENT(nfs_folio_event, name, \ << 980 TP_PROTO( \ << 981 const struct i << 982 loff_t offset, << 983 size_t count \ << 984 ), \ << 985 TP_ARGS(inode, offset, << 986 << 987 DECLARE_EVENT_CLASS(nfs_folio_event_done, << 988 TP_PROTO( << 989 const struct inode *in << 990 loff_t offset, << 991 size_t count, << 992 int ret << 993 ), << 994 << 995 TP_ARGS(inode, offset, count, << 996 << 997 TP_STRUCT__entry( << 998 __field(dev_t, dev) 834 __field(dev_t, dev) 999 __field(u32, fhandle) 835 __field(u32, fhandle) 1000 __field(int, ret) << 1001 __field(u64, fileid) 836 __field(u64, fileid) 1002 __field(u64, version) << 1003 __field(loff_t, offse << 1004 __field(size_t, count << 1005 ), << 1006 << 1007 TP_fast_assign( << 1008 const struct nfs_inod << 1009 << 1010 __entry->dev = inode- << 1011 __entry->fileid = nfs << 1012 __entry->fhandle = nf << 1013 __entry->version = in << 1014 __entry->offset = off << 1015 __entry->count = coun << 1016 __entry->ret = ret; << 1017 ), << 1018 << 1019 TP_printk( << 1020 "fileid=%02x:%02x:%ll << 1021 "offset=%lld count=%z << 1022 MAJOR(__entry->dev), << 1023 (unsigned long long)_ << 1024 __entry->fhandle, __e << 1025 __entry->offset, __en << 1026 ) << 1027 ); << 1028 << 1029 #define DEFINE_NFS_FOLIO_EVENT_DONE(name) \ << 1030 DEFINE_EVENT(nfs_folio_event_done, na << 1031 TP_PROTO( \ << 1032 const struct << 1033 loff_t offset << 1034 size_t count, << 1035 int ret \ << 1036 ), \ << 1037 TP_ARGS(inode, offset << 1038 << 1039 DEFINE_NFS_FOLIO_EVENT(nfs_aop_readpage); << 1040 DEFINE_NFS_FOLIO_EVENT_DONE(nfs_aop_readpage_ << 1041 << 1042 DEFINE_NFS_FOLIO_EVENT(nfs_writeback_folio); << 1043 DEFINE_NFS_FOLIO_EVENT_DONE(nfs_writeback_fol << 1044 << 1045 DEFINE_NFS_FOLIO_EVENT(nfs_invalidate_folio); << 1046 DEFINE_NFS_FOLIO_EVENT_DONE(nfs_launder_folio << 1047 << 1048 TRACE_EVENT(nfs_aop_readahead, << 1049 TP_PROTO( << 1050 const struct inode *i << 1051 loff_t pos, << 1052 unsigned int nr_pages << 1053 ), << 1054 << 1055 TP_ARGS(inode, pos, nr_pages) << 1056 << 1057 TP_STRUCT__entry( << 1058 __field(dev_t, dev) << 1059 __field(u32, fhandle) << 1060 __field(u64, fileid) << 1061 __field(u64, version) << 1062 __field(loff_t, offse << 1063 __field(unsigned int, << 1064 ), << 1065 << 1066 TP_fast_assign( << 1067 const struct nfs_inod << 1068 << 1069 __entry->dev = inode- << 1070 __entry->fileid = nfs << 1071 __entry->fhandle = nf << 1072 __entry->version = in << 1073 __entry->offset = pos << 1074 __entry->nr_pages = n << 1075 ), << 1076 << 1077 TP_printk( << 1078 "fileid=%02x:%02x:%ll << 1079 MAJOR(__entry->dev), << 1080 (unsigned long long)_ << 1081 __entry->fhandle, __e << 1082 __entry->offset, __en << 1083 ) << 1084 ); << 1085 << 1086 TRACE_EVENT(nfs_aop_readahead_done, << 1087 TP_PROTO( << 1088 const struct inode *i << 1089 unsigned int nr_pages << 1090 int ret << 1091 ), << 1092 << 1093 TP_ARGS(inode, nr_pages, ret) << 1094 << 1095 TP_STRUCT__entry( << 1096 __field(dev_t, dev) << 1097 __field(u32, fhandle) << 1098 __field(int, ret) << 1099 __field(u64, fileid) << 1100 __field(u64, version) << 1101 __field(loff_t, offse << 1102 __field(unsigned int, << 1103 ), 837 ), 1104 838 1105 TP_fast_assign( 839 TP_fast_assign( 1106 const struct nfs_inod 840 const struct nfs_inode *nfsi = NFS_I(inode); 1107 841 >> 842 __entry->offset = offset; >> 843 __entry->count = count; 1108 __entry->dev = inode- 844 __entry->dev = inode->i_sb->s_dev; 1109 __entry->fileid = nfs 845 __entry->fileid = nfsi->fileid; 1110 __entry->fhandle = nf 846 __entry->fhandle = nfs_fhandle_hash(&nfsi->fh); 1111 __entry->version = in << 1112 __entry->nr_pages = n << 1113 __entry->ret = ret; << 1114 ), << 1115 << 1116 TP_printk( << 1117 "fileid=%02x:%02x:%ll << 1118 MAJOR(__entry->dev), << 1119 (unsigned long long)_ << 1120 __entry->fhandle, __e << 1121 __entry->nr_pages, __ << 1122 ) << 1123 ); << 1124 << 1125 TRACE_EVENT(nfs_initiate_read, << 1126 TP_PROTO( << 1127 const struct nfs_pgio << 1128 ), << 1129 << 1130 TP_ARGS(hdr), << 1131 << 1132 TP_STRUCT__entry( << 1133 __field(dev_t, dev) << 1134 __field(u32, fhandle) << 1135 __field(u64, fileid) << 1136 __field(loff_t, offse << 1137 __field(u32, count) << 1138 ), << 1139 << 1140 TP_fast_assign( << 1141 const struct inode *i << 1142 const struct nfs_inod << 1143 const struct nfs_fh * << 1144 << 1145 << 1146 __entry->offset = hdr << 1147 __entry->count = hdr- << 1148 __entry->dev = inode- << 1149 __entry->fileid = nfs << 1150 __entry->fhandle = nf << 1151 ), 847 ), 1152 848 1153 TP_printk( 849 TP_printk( 1154 "fileid=%02x:%02x:%ll 850 "fileid=%02x:%02x:%llu fhandle=0x%08x " 1155 "offset=%lld count=%u !! 851 "offset=%lld count=%lu", 1156 MAJOR(__entry->dev), 852 MAJOR(__entry->dev), MINOR(__entry->dev), 1157 (unsigned long long)_ 853 (unsigned long long)__entry->fileid, 1158 __entry->fhandle, 854 __entry->fhandle, 1159 (long long)__entry->o !! 855 __entry->offset, __entry->count 1160 ) 856 ) 1161 ); 857 ); 1162 858 1163 TRACE_EVENT(nfs_readpage_done, 859 TRACE_EVENT(nfs_readpage_done, 1164 TP_PROTO( 860 TP_PROTO( 1165 const struct rpc_task !! 861 const struct inode *inode, 1166 const struct nfs_pgio !! 862 int status, loff_t offset, bool eof 1167 ), 863 ), 1168 864 1169 TP_ARGS(task, hdr), !! 865 TP_ARGS(inode, status, offset, eof), 1170 866 1171 TP_STRUCT__entry( 867 TP_STRUCT__entry( 1172 __field(dev_t, dev) !! 868 __field(int, status) 1173 __field(u32, fhandle) << 1174 __field(u64, fileid) << 1175 __field(loff_t, offse 869 __field(loff_t, offset) 1176 __field(u32, arg_coun << 1177 __field(u32, res_coun << 1178 __field(bool, eof) 870 __field(bool, eof) 1179 __field(int, error) << 1180 ), << 1181 << 1182 TP_fast_assign( << 1183 const struct inode *i << 1184 const struct nfs_inod << 1185 const struct nfs_fh * << 1186 << 1187 << 1188 __entry->error = task << 1189 __entry->offset = hdr << 1190 __entry->arg_count = << 1191 __entry->res_count = << 1192 __entry->eof = hdr->r << 1193 __entry->dev = inode- << 1194 __entry->fileid = nfs << 1195 __entry->fhandle = nf << 1196 ), << 1197 << 1198 TP_printk( << 1199 "error=%d fileid=%02x << 1200 "offset=%lld count=%u << 1201 MAJOR(__entry->dev), << 1202 (unsigned long long)_ << 1203 __entry->fhandle, << 1204 (long long)__entry->o << 1205 __entry->res_count, _ << 1206 ) << 1207 ); << 1208 << 1209 TRACE_EVENT(nfs_readpage_short, << 1210 TP_PROTO( << 1211 const struct rpc_task << 1212 const struct nfs_pgio << 1213 ), << 1214 << 1215 TP_ARGS(task, hdr), << 1216 << 1217 TP_STRUCT__entry( << 1218 __field(dev_t, dev) 871 __field(dev_t, dev) 1219 __field(u32, fhandle) 872 __field(u32, fhandle) 1220 __field(u64, fileid) 873 __field(u64, fileid) 1221 __field(loff_t, offse << 1222 __field(u32, arg_coun << 1223 __field(u32, res_coun << 1224 __field(bool, eof) << 1225 __field(int, error) << 1226 ), 874 ), 1227 875 1228 TP_fast_assign( 876 TP_fast_assign( 1229 const struct inode *i << 1230 const struct nfs_inod 877 const struct nfs_inode *nfsi = NFS_I(inode); 1231 const struct nfs_fh * << 1232 << 1233 878 1234 __entry->error = task !! 879 __entry->status = status; 1235 __entry->offset = hdr !! 880 __entry->offset = offset; 1236 __entry->arg_count = !! 881 __entry->eof = eof; 1237 __entry->res_count = << 1238 __entry->eof = hdr->r << 1239 __entry->dev = inode- 882 __entry->dev = inode->i_sb->s_dev; 1240 __entry->fileid = nfs 883 __entry->fileid = nfsi->fileid; 1241 __entry->fhandle = nf !! 884 __entry->fhandle = nfs_fhandle_hash(&nfsi->fh); 1242 ), 885 ), 1243 886 1244 TP_printk( 887 TP_printk( 1245 "error=%d fileid=%02x !! 888 "fileid=%02x:%02x:%llu fhandle=0x%08x " 1246 "offset=%lld count=%u !! 889 "offset=%lld status=%d%s", 1247 MAJOR(__entry->dev), 890 MAJOR(__entry->dev), MINOR(__entry->dev), 1248 (unsigned long long)_ 891 (unsigned long long)__entry->fileid, 1249 __entry->fhandle, 892 __entry->fhandle, 1250 (long long)__entry->o !! 893 __entry->offset, __entry->status, 1251 __entry->res_count, _ !! 894 __entry->eof ? " eof" : "" 1252 ) 895 ) 1253 ); 896 ); 1254 897 >> 898 TRACE_DEFINE_ENUM(NFS_UNSTABLE); >> 899 TRACE_DEFINE_ENUM(NFS_DATA_SYNC); >> 900 TRACE_DEFINE_ENUM(NFS_FILE_SYNC); 1255 901 1256 TRACE_EVENT(nfs_pgio_error, !! 902 #define nfs_show_stable(stable) \ 1257 TP_PROTO( !! 903 __print_symbolic(stable, \ 1258 const struct nfs_pgio_header !! 904 { NFS_UNSTABLE, "UNSTABLE" }, \ 1259 int error, !! 905 { NFS_DATA_SYNC, "DATA_SYNC" }, \ 1260 loff_t pos !! 906 { NFS_FILE_SYNC, "FILE_SYNC" }) 1261 ), << 1262 << 1263 TP_ARGS(hdr, error, pos), << 1264 << 1265 TP_STRUCT__entry( << 1266 __field(dev_t, dev) << 1267 __field(u32, fhandle) << 1268 __field(u64, fileid) << 1269 __field(loff_t, offset) << 1270 __field(u32, arg_count) << 1271 __field(u32, res_count) << 1272 __field(loff_t, pos) << 1273 __field(int, error) << 1274 ), << 1275 << 1276 TP_fast_assign( << 1277 const struct inode *inode = h << 1278 const struct nfs_inode *nfsi << 1279 const struct nfs_fh *fh = hdr << 1280 hdr << 1281 << 1282 __entry->error = error; << 1283 __entry->offset = hdr->args.o << 1284 __entry->arg_count = hdr->arg << 1285 __entry->res_count = hdr->res << 1286 __entry->dev = inode->i_sb->s << 1287 __entry->fileid = nfsi->filei << 1288 __entry->fhandle = nfs_fhandl << 1289 ), << 1290 << 1291 TP_printk("error=%d fileid=%02x:%02x: << 1292 "offset=%lld count=%u res=% << 1293 MAJOR(__entry->dev), MINOR(__ << 1294 (unsigned long long)__entry-> << 1295 (long long)__entry->offset, _ << 1296 __entry->pos << 1297 ) << 1298 ); << 1299 907 1300 TRACE_EVENT(nfs_initiate_write, 908 TRACE_EVENT(nfs_initiate_write, 1301 TP_PROTO( 909 TP_PROTO( 1302 const struct nfs_pgio !! 910 const struct inode *inode, >> 911 loff_t offset, unsigned long count, >> 912 enum nfs3_stable_how stable 1303 ), 913 ), 1304 914 1305 TP_ARGS(hdr), !! 915 TP_ARGS(inode, offset, count, stable), 1306 916 1307 TP_STRUCT__entry( 917 TP_STRUCT__entry( >> 918 __field(loff_t, offset) >> 919 __field(unsigned long, count) >> 920 __field(enum nfs3_stable_how, stable) 1308 __field(dev_t, dev) 921 __field(dev_t, dev) 1309 __field(u32, fhandle) 922 __field(u32, fhandle) 1310 __field(u64, fileid) 923 __field(u64, fileid) 1311 __field(loff_t, offse << 1312 __field(u32, count) << 1313 __field(unsigned long << 1314 ), 924 ), 1315 925 1316 TP_fast_assign( 926 TP_fast_assign( 1317 const struct inode *i << 1318 const struct nfs_inod 927 const struct nfs_inode *nfsi = NFS_I(inode); 1319 const struct nfs_fh * << 1320 << 1321 928 1322 __entry->offset = hdr !! 929 __entry->offset = offset; 1323 __entry->count = hdr- !! 930 __entry->count = count; 1324 __entry->stable = hdr !! 931 __entry->stable = stable; 1325 __entry->dev = inode- 932 __entry->dev = inode->i_sb->s_dev; 1326 __entry->fileid = nfs 933 __entry->fileid = nfsi->fileid; 1327 __entry->fhandle = nf !! 934 __entry->fhandle = nfs_fhandle_hash(&nfsi->fh); 1328 ), 935 ), 1329 936 1330 TP_printk( 937 TP_printk( 1331 "fileid=%02x:%02x:%ll 938 "fileid=%02x:%02x:%llu fhandle=0x%08x " 1332 "offset=%lld count=%u !! 939 "offset=%lld count=%lu stable=%s", 1333 MAJOR(__entry->dev), 940 MAJOR(__entry->dev), MINOR(__entry->dev), 1334 (unsigned long long)_ 941 (unsigned long long)__entry->fileid, 1335 __entry->fhandle, 942 __entry->fhandle, 1336 (long long)__entry->o !! 943 __entry->offset, __entry->count, 1337 show_nfs_stable_how(_ !! 944 nfs_show_stable(__entry->stable) 1338 ) 945 ) 1339 ); 946 ); 1340 947 1341 TRACE_EVENT(nfs_writeback_done, 948 TRACE_EVENT(nfs_writeback_done, 1342 TP_PROTO( 949 TP_PROTO( 1343 const struct rpc_task << 1344 const struct nfs_pgio << 1345 ), << 1346 << 1347 TP_ARGS(task, hdr), << 1348 << 1349 TP_STRUCT__entry( << 1350 __field(dev_t, dev) << 1351 __field(u32, fhandle) << 1352 __field(u64, fileid) << 1353 __field(loff_t, offse << 1354 __field(u32, arg_coun << 1355 __field(u32, res_coun << 1356 __field(int, error) << 1357 __field(unsigned long << 1358 __array(char, verifie << 1359 ), << 1360 << 1361 TP_fast_assign( << 1362 const struct inode *i << 1363 const struct nfs_inod << 1364 const struct nfs_fh * << 1365 << 1366 const struct nfs_writ << 1367 << 1368 __entry->error = task << 1369 __entry->offset = hdr << 1370 __entry->arg_count = << 1371 __entry->res_count = << 1372 __entry->stable = ver << 1373 memcpy(__entry->verif << 1374 &verf->verifi << 1375 NFS4_VERIFIER << 1376 __entry->dev = inode- << 1377 __entry->fileid = nfs << 1378 __entry->fhandle = nf << 1379 ), << 1380 << 1381 TP_printk( << 1382 "error=%d fileid=%02x << 1383 "offset=%lld count=%u << 1384 "verifier=%s", __entr << 1385 MAJOR(__entry->dev), << 1386 (unsigned long long)_ << 1387 __entry->fhandle, << 1388 (long long)__entry->o << 1389 __entry->res_count, << 1390 show_nfs_stable_how(_ << 1391 show_nfs4_verifier(__ << 1392 ) << 1393 ); << 1394 << 1395 DECLARE_EVENT_CLASS(nfs_page_error_class, << 1396 TP_PROTO( << 1397 const struct inode *i 950 const struct inode *inode, 1398 const struct nfs_page !! 951 int status, 1399 int error !! 952 loff_t offset, >> 953 struct nfs_writeverf *writeverf 1400 ), 954 ), 1401 955 1402 TP_ARGS(inode, req, error), !! 956 TP_ARGS(inode, status, offset, writeverf), 1403 957 1404 TP_STRUCT__entry( 958 TP_STRUCT__entry( >> 959 __field(int, status) >> 960 __field(loff_t, offset) >> 961 __field(enum nfs3_stable_how, stable) >> 962 __field(unsigned long long, verifier) 1405 __field(dev_t, dev) 963 __field(dev_t, dev) 1406 __field(u32, fhandle) 964 __field(u32, fhandle) 1407 __field(u64, fileid) 965 __field(u64, fileid) 1408 __field(loff_t, offse << 1409 __field(unsigned int, << 1410 __field(int, error) << 1411 ), 966 ), 1412 967 1413 TP_fast_assign( 968 TP_fast_assign( 1414 const struct nfs_inod 969 const struct nfs_inode *nfsi = NFS_I(inode); >> 970 >> 971 __entry->status = status; >> 972 __entry->offset = offset; >> 973 __entry->stable = writeverf->committed; >> 974 memcpy(&__entry->verifier, &writeverf->verifier, >> 975 sizeof(__entry->verifier)); 1415 __entry->dev = inode- 976 __entry->dev = inode->i_sb->s_dev; 1416 __entry->fileid = nfs 977 __entry->fileid = nfsi->fileid; 1417 __entry->fhandle = nf 978 __entry->fhandle = nfs_fhandle_hash(&nfsi->fh); 1418 __entry->offset = req << 1419 __entry->count = req- << 1420 __entry->error = erro << 1421 ), 979 ), 1422 980 1423 TP_printk( 981 TP_printk( 1424 "error=%d fileid=%02x !! 982 "fileid=%02x:%02x:%llu fhandle=0x%08x " 1425 "offset=%lld count=%u !! 983 "offset=%lld status=%d stable=%s " >> 984 "verifier 0x%016llx", 1426 MAJOR(__entry->dev), 985 MAJOR(__entry->dev), MINOR(__entry->dev), 1427 (unsigned long long)_ 986 (unsigned long long)__entry->fileid, 1428 __entry->fhandle, __e !! 987 __entry->fhandle, 1429 __entry->count !! 988 __entry->offset, __entry->status, >> 989 nfs_show_stable(__entry->stable), >> 990 __entry->verifier 1430 ) 991 ) 1431 ); 992 ); 1432 993 1433 #define DEFINE_NFS_PAGEERR_EVENT(name) \ << 1434 DEFINE_EVENT(nfs_page_error_class, na << 1435 TP_PROTO( \ << 1436 const struct << 1437 const struct << 1438 int error \ << 1439 ), \ << 1440 TP_ARGS(inode, req, e << 1441 << 1442 DEFINE_NFS_PAGEERR_EVENT(nfs_write_error); << 1443 DEFINE_NFS_PAGEERR_EVENT(nfs_comp_error); << 1444 DEFINE_NFS_PAGEERR_EVENT(nfs_commit_error); << 1445 << 1446 TRACE_EVENT(nfs_initiate_commit, 994 TRACE_EVENT(nfs_initiate_commit, 1447 TP_PROTO( 995 TP_PROTO( 1448 const struct nfs_comm 996 const struct nfs_commit_data *data 1449 ), 997 ), 1450 998 1451 TP_ARGS(data), 999 TP_ARGS(data), 1452 1000 1453 TP_STRUCT__entry( 1001 TP_STRUCT__entry( >> 1002 __field(loff_t, offset) >> 1003 __field(unsigned long, count) 1454 __field(dev_t, dev) 1004 __field(dev_t, dev) 1455 __field(u32, fhandle) 1005 __field(u32, fhandle) 1456 __field(u64, fileid) 1006 __field(u64, fileid) 1457 __field(loff_t, offse << 1458 __field(u32, count) << 1459 ), 1007 ), 1460 1008 1461 TP_fast_assign( 1009 TP_fast_assign( 1462 const struct inode *i 1010 const struct inode *inode = data->inode; 1463 const struct nfs_inod 1011 const struct nfs_inode *nfsi = NFS_I(inode); 1464 const struct nfs_fh * << 1465 << 1466 1012 1467 __entry->offset = dat 1013 __entry->offset = data->args.offset; 1468 __entry->count = data 1014 __entry->count = data->args.count; 1469 __entry->dev = inode- 1015 __entry->dev = inode->i_sb->s_dev; 1470 __entry->fileid = nfs 1016 __entry->fileid = nfsi->fileid; 1471 __entry->fhandle = nf !! 1017 __entry->fhandle = nfs_fhandle_hash(&nfsi->fh); 1472 ), 1018 ), 1473 1019 1474 TP_printk( 1020 TP_printk( 1475 "fileid=%02x:%02x:%ll 1021 "fileid=%02x:%02x:%llu fhandle=0x%08x " 1476 "offset=%lld count=%u !! 1022 "offset=%lld count=%lu", 1477 MAJOR(__entry->dev), 1023 MAJOR(__entry->dev), MINOR(__entry->dev), 1478 (unsigned long long)_ 1024 (unsigned long long)__entry->fileid, 1479 __entry->fhandle, 1025 __entry->fhandle, 1480 (long long)__entry->o !! 1026 __entry->offset, __entry->count 1481 ) 1027 ) 1482 ); 1028 ); 1483 1029 1484 TRACE_EVENT(nfs_commit_done, 1030 TRACE_EVENT(nfs_commit_done, 1485 TP_PROTO( 1031 TP_PROTO( 1486 const struct rpc_task << 1487 const struct nfs_comm 1032 const struct nfs_commit_data *data 1488 ), 1033 ), 1489 1034 1490 TP_ARGS(task, data), !! 1035 TP_ARGS(data), 1491 1036 1492 TP_STRUCT__entry( 1037 TP_STRUCT__entry( >> 1038 __field(int, status) >> 1039 __field(loff_t, offset) >> 1040 __field(unsigned long long, verifier) 1493 __field(dev_t, dev) 1041 __field(dev_t, dev) 1494 __field(u32, fhandle) 1042 __field(u32, fhandle) 1495 __field(u64, fileid) 1043 __field(u64, fileid) 1496 __field(loff_t, offse << 1497 __field(int, error) << 1498 __field(unsigned long << 1499 __array(char, verifie << 1500 ), 1044 ), 1501 1045 1502 TP_fast_assign( 1046 TP_fast_assign( 1503 const struct inode *i 1047 const struct inode *inode = data->inode; 1504 const struct nfs_inod 1048 const struct nfs_inode *nfsi = NFS_I(inode); 1505 const struct nfs_fh * << 1506 << 1507 const struct nfs_writ << 1508 1049 1509 __entry->error = task !! 1050 __entry->status = data->res.op_status; 1510 __entry->offset = dat 1051 __entry->offset = data->args.offset; 1511 __entry->stable = ver !! 1052 memcpy(&__entry->verifier, &data->verf.verifier, 1512 memcpy(__entry->verif !! 1053 sizeof(__entry->verifier)); 1513 &verf->verifi << 1514 NFS4_VERIFIER << 1515 __entry->dev = inode- 1054 __entry->dev = inode->i_sb->s_dev; 1516 __entry->fileid = nfs 1055 __entry->fileid = nfsi->fileid; 1517 __entry->fhandle = nf !! 1056 __entry->fhandle = nfs_fhandle_hash(&nfsi->fh); 1518 ), 1057 ), 1519 1058 1520 TP_printk( 1059 TP_printk( 1521 "error=%d fileid=%02x !! 1060 "fileid=%02x:%02x:%llu fhandle=0x%08x " 1522 "offset=%lld stable=% !! 1061 "offset=%lld status=%d verifier 0x%016llx", 1523 MAJOR(__entry->dev), 1062 MAJOR(__entry->dev), MINOR(__entry->dev), 1524 (unsigned long long)_ 1063 (unsigned long long)__entry->fileid, 1525 __entry->fhandle, 1064 __entry->fhandle, 1526 (long long)__entry->o !! 1065 __entry->offset, __entry->status, 1527 show_nfs_stable_how(_ !! 1066 __entry->verifier 1528 show_nfs4_verifier(__ << 1529 ) 1067 ) 1530 ); 1068 ); 1531 1069 1532 #define nfs_show_direct_req_flags(v) \ !! 1070 TRACE_DEFINE_ENUM(NFS_OK); 1533 __print_flags(v, "|", \ !! 1071 TRACE_DEFINE_ENUM(NFSERR_PERM); 1534 { NFS_ODIRECT_DO_COMM !! 1072 TRACE_DEFINE_ENUM(NFSERR_NOENT); 1535 { NFS_ODIRECT_RESCHED !! 1073 TRACE_DEFINE_ENUM(NFSERR_IO); 1536 { NFS_ODIRECT_SHOULD_ !! 1074 TRACE_DEFINE_ENUM(NFSERR_NXIO); 1537 { NFS_ODIRECT_DONE, " !! 1075 TRACE_DEFINE_ENUM(ECHILD); >> 1076 TRACE_DEFINE_ENUM(NFSERR_EAGAIN); >> 1077 TRACE_DEFINE_ENUM(NFSERR_ACCES); >> 1078 TRACE_DEFINE_ENUM(NFSERR_EXIST); >> 1079 TRACE_DEFINE_ENUM(NFSERR_XDEV); >> 1080 TRACE_DEFINE_ENUM(NFSERR_NODEV); >> 1081 TRACE_DEFINE_ENUM(NFSERR_NOTDIR); >> 1082 TRACE_DEFINE_ENUM(NFSERR_ISDIR); >> 1083 TRACE_DEFINE_ENUM(NFSERR_INVAL); >> 1084 TRACE_DEFINE_ENUM(NFSERR_FBIG); >> 1085 TRACE_DEFINE_ENUM(NFSERR_NOSPC); >> 1086 TRACE_DEFINE_ENUM(NFSERR_ROFS); >> 1087 TRACE_DEFINE_ENUM(NFSERR_MLINK); >> 1088 TRACE_DEFINE_ENUM(NFSERR_OPNOTSUPP); >> 1089 TRACE_DEFINE_ENUM(NFSERR_NAMETOOLONG); >> 1090 TRACE_DEFINE_ENUM(NFSERR_NOTEMPTY); >> 1091 TRACE_DEFINE_ENUM(NFSERR_DQUOT); >> 1092 TRACE_DEFINE_ENUM(NFSERR_STALE); >> 1093 TRACE_DEFINE_ENUM(NFSERR_REMOTE); >> 1094 TRACE_DEFINE_ENUM(NFSERR_WFLUSH); >> 1095 TRACE_DEFINE_ENUM(NFSERR_BADHANDLE); >> 1096 TRACE_DEFINE_ENUM(NFSERR_NOT_SYNC); >> 1097 TRACE_DEFINE_ENUM(NFSERR_BAD_COOKIE); >> 1098 TRACE_DEFINE_ENUM(NFSERR_NOTSUPP); >> 1099 TRACE_DEFINE_ENUM(NFSERR_TOOSMALL); >> 1100 TRACE_DEFINE_ENUM(NFSERR_SERVERFAULT); >> 1101 TRACE_DEFINE_ENUM(NFSERR_BADTYPE); >> 1102 TRACE_DEFINE_ENUM(NFSERR_JUKEBOX); >> 1103 >> 1104 #define nfs_show_status(x) \ >> 1105 __print_symbolic(x, \ >> 1106 { NFS_OK, "OK" }, \ >> 1107 { NFSERR_PERM, "PERM" }, \ >> 1108 { NFSERR_NOENT, "NOENT" }, \ >> 1109 { NFSERR_IO, "IO" }, \ >> 1110 { NFSERR_NXIO, "NXIO" }, \ >> 1111 { ECHILD, "CHILD" }, \ >> 1112 { NFSERR_EAGAIN, "AGAIN" }, \ >> 1113 { NFSERR_ACCES, "ACCES" }, \ >> 1114 { NFSERR_EXIST, "EXIST" }, \ >> 1115 { NFSERR_XDEV, "XDEV" }, \ >> 1116 { NFSERR_NODEV, "NODEV" }, \ >> 1117 { NFSERR_NOTDIR, "NOTDIR" }, \ >> 1118 { NFSERR_ISDIR, "ISDIR" }, \ >> 1119 { NFSERR_INVAL, "INVAL" }, \ >> 1120 { NFSERR_FBIG, "FBIG" }, \ >> 1121 { NFSERR_NOSPC, "NOSPC" }, \ >> 1122 { NFSERR_ROFS, "ROFS" }, \ >> 1123 { NFSERR_MLINK, "MLINK" }, \ >> 1124 { NFSERR_OPNOTSUPP, "OPNOTSUPP" }, \ >> 1125 { NFSERR_NAMETOOLONG, "NAMETOOLONG" }, \ >> 1126 { NFSERR_NOTEMPTY, "NOTEMPTY" }, \ >> 1127 { NFSERR_DQUOT, "DQUOT" }, \ >> 1128 { NFSERR_STALE, "STALE" }, \ >> 1129 { NFSERR_REMOTE, "REMOTE" }, \ >> 1130 { NFSERR_WFLUSH, "WFLUSH" }, \ >> 1131 { NFSERR_BADHANDLE, "BADHANDLE" }, \ >> 1132 { NFSERR_NOT_SYNC, "NOTSYNC" }, \ >> 1133 { NFSERR_BAD_COOKIE, "BADCOOKIE" }, \ >> 1134 { NFSERR_NOTSUPP, "NOTSUPP" }, \ >> 1135 { NFSERR_TOOSMALL, "TOOSMALL" }, \ >> 1136 { NFSERR_SERVERFAULT, "REMOTEIO" }, \ >> 1137 { NFSERR_BADTYPE, "BADTYPE" }, \ >> 1138 { NFSERR_JUKEBOX, "JUKEBOX" }) 1538 1139 1539 DECLARE_EVENT_CLASS(nfs_direct_req_class, !! 1140 TRACE_EVENT(nfs_xdr_status, 1540 TP_PROTO( << 1541 const struct nfs_dire << 1542 ), << 1543 << 1544 TP_ARGS(dreq), << 1545 << 1546 TP_STRUCT__entry( << 1547 __field(dev_t, dev) << 1548 __field(u64, fileid) << 1549 __field(u32, fhandle) << 1550 __field(loff_t, offse << 1551 __field(ssize_t, coun << 1552 __field(ssize_t, erro << 1553 __field(int, flags) << 1554 ), << 1555 << 1556 TP_fast_assign( << 1557 const struct inode *i << 1558 const struct nfs_inod << 1559 const struct nfs_fh * << 1560 << 1561 __entry->dev = inode- << 1562 __entry->fileid = nfs << 1563 __entry->fhandle = nf << 1564 __entry->offset = dre << 1565 __entry->count = dreq << 1566 __entry->error = dreq << 1567 __entry->flags = dreq << 1568 ), << 1569 << 1570 TP_printk( << 1571 "error=%zd fileid=%02 << 1572 "offset=%lld count=%z << 1573 __entry->error, MAJOR << 1574 MINOR(__entry->dev), << 1575 (unsigned long long)_ << 1576 __entry->fhandle, __e << 1577 __entry->count, << 1578 nfs_show_direct_req_f << 1579 ) << 1580 ); << 1581 << 1582 #define DEFINE_NFS_DIRECT_REQ_EVENT(name) \ << 1583 DEFINE_EVENT(nfs_direct_req_class, na << 1584 TP_PROTO( \ << 1585 const struct << 1586 ), \ << 1587 TP_ARGS(dreq)) << 1588 << 1589 DEFINE_NFS_DIRECT_REQ_EVENT(nfs_direct_commit << 1590 DEFINE_NFS_DIRECT_REQ_EVENT(nfs_direct_resche << 1591 DEFINE_NFS_DIRECT_REQ_EVENT(nfs_direct_write_ << 1592 DEFINE_NFS_DIRECT_REQ_EVENT(nfs_direct_write_ << 1593 DEFINE_NFS_DIRECT_REQ_EVENT(nfs_direct_write_ << 1594 DEFINE_NFS_DIRECT_REQ_EVENT(nfs_direct_write_ << 1595 << 1596 TRACE_EVENT(nfs_fh_to_dentry, << 1597 TP_PROTO( << 1598 const struct super_bl << 1599 const struct nfs_fh * << 1600 u64 fileid, << 1601 int error << 1602 ), << 1603 << 1604 TP_ARGS(sb, fh, fileid, error << 1605 << 1606 TP_STRUCT__entry( << 1607 __field(int, error) << 1608 __field(dev_t, dev) << 1609 __field(u32, fhandle) << 1610 __field(u64, fileid) << 1611 ), << 1612 << 1613 TP_fast_assign( << 1614 __entry->error = erro << 1615 __entry->dev = sb->s_ << 1616 __entry->fileid = fil << 1617 __entry->fhandle = nf << 1618 ), << 1619 << 1620 TP_printk( << 1621 "error=%d fileid=%02x << 1622 __entry->error, << 1623 MAJOR(__entry->dev), << 1624 (unsigned long long)_ << 1625 __entry->fhandle << 1626 ) << 1627 ); << 1628 << 1629 TRACE_EVENT(nfs_mount_assign, << 1630 TP_PROTO( << 1631 const char *option, << 1632 const char *value << 1633 ), << 1634 << 1635 TP_ARGS(option, value), << 1636 << 1637 TP_STRUCT__entry( << 1638 __string(option, option) << 1639 __string(value, value) << 1640 ), << 1641 << 1642 TP_fast_assign( << 1643 __assign_str(option); << 1644 __assign_str(value); << 1645 ), << 1646 << 1647 TP_printk("option %s=%s", << 1648 __get_str(option), __get_str( << 1649 ) << 1650 ); << 1651 << 1652 TRACE_EVENT(nfs_mount_option, << 1653 TP_PROTO( << 1654 const struct fs_parameter *pa << 1655 ), << 1656 << 1657 TP_ARGS(param), << 1658 << 1659 TP_STRUCT__entry( << 1660 __string(option, param->key) << 1661 ), << 1662 << 1663 TP_fast_assign( << 1664 __assign_str(option); << 1665 ), << 1666 << 1667 TP_printk("option %s", __get_str(opti << 1668 ); << 1669 << 1670 TRACE_EVENT(nfs_mount_path, << 1671 TP_PROTO( << 1672 const char *path << 1673 ), << 1674 << 1675 TP_ARGS(path), << 1676 << 1677 TP_STRUCT__entry( << 1678 __string(path, path) << 1679 ), << 1680 << 1681 TP_fast_assign( << 1682 __assign_str(path); << 1683 ), << 1684 << 1685 TP_printk("path='%s'", __get_str(path << 1686 ); << 1687 << 1688 DECLARE_EVENT_CLASS(nfs_xdr_event, << 1689 TP_PROTO( 1141 TP_PROTO( 1690 const struct xdr_stre 1142 const struct xdr_stream *xdr, 1691 int error 1143 int error 1692 ), 1144 ), 1693 1145 1694 TP_ARGS(xdr, error), 1146 TP_ARGS(xdr, error), 1695 1147 1696 TP_STRUCT__entry( 1148 TP_STRUCT__entry( 1697 __field(unsigned int, 1149 __field(unsigned int, task_id) 1698 __field(unsigned int, 1150 __field(unsigned int, client_id) 1699 __field(u32, xid) 1151 __field(u32, xid) 1700 __field(int, version) << 1701 __field(unsigned long 1152 __field(unsigned long, error) 1702 __string(program, << 1703 xdr->rqst->r << 1704 __string(procedure, << 1705 xdr->rqst->r << 1706 ), 1153 ), 1707 1154 1708 TP_fast_assign( 1155 TP_fast_assign( 1709 const struct rpc_rqst 1156 const struct rpc_rqst *rqstp = xdr->rqst; 1710 const struct rpc_task 1157 const struct rpc_task *task = rqstp->rq_task; 1711 1158 1712 __entry->task_id = ta 1159 __entry->task_id = task->tk_pid; 1713 __entry->client_id = 1160 __entry->client_id = task->tk_client->cl_clid; 1714 __entry->xid = be32_t 1161 __entry->xid = be32_to_cpu(rqstp->rq_xid); 1715 __entry->version = ta << 1716 __entry->error = erro 1162 __entry->error = error; 1717 __assign_str(program) << 1718 __assign_str(procedur << 1719 ), 1163 ), 1720 1164 1721 TP_printk(SUNRPC_TRACE_TASK_S !! 1165 TP_printk( 1722 " xid=0x%08x %sv%d !! 1166 "task:%u@%d xid=0x%08x error=%ld (%s)", 1723 __entry->task_id, __e 1167 __entry->task_id, __entry->client_id, __entry->xid, 1724 __get_str(program), _ !! 1168 -__entry->error, nfs_show_status(__entry->error) 1725 __get_str(procedure), << 1726 show_nfs_status(__ent << 1727 ) 1169 ) 1728 ); 1170 ); 1729 #define DEFINE_NFS_XDR_EVENT(name) \ << 1730 DEFINE_EVENT(nfs_xdr_event, name, \ << 1731 TP_PROTO( \ << 1732 const struct << 1733 int error \ << 1734 ), \ << 1735 TP_ARGS(xdr, error)) << 1736 DEFINE_NFS_XDR_EVENT(nfs_xdr_status); << 1737 DEFINE_NFS_XDR_EVENT(nfs_xdr_bad_filehandle); << 1738 1171 1739 #endif /* _TRACE_NFS_H */ 1172 #endif /* _TRACE_NFS_H */ 1740 1173 1741 #undef TRACE_INCLUDE_PATH 1174 #undef TRACE_INCLUDE_PATH 1742 #define TRACE_INCLUDE_PATH . 1175 #define TRACE_INCLUDE_PATH . 1743 #define TRACE_INCLUDE_FILE nfstrace 1176 #define TRACE_INCLUDE_FILE nfstrace 1744 /* This part must be outside protection */ 1177 /* This part must be outside protection */ 1745 #include <trace/define_trace.h> 1178 #include <trace/define_trace.h> 1746 1179
Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.