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> << 13 12 14 #include <trace/misc/fs.h> !! 13 #define nfs_show_file_type(ftype) \ 15 #include <trace/misc/nfs.h> !! 14 __print_symbolic(ftype, \ 16 #include <trace/misc/sunrpc.h> !! 15 { DT_UNKNOWN, "UNKNOWN" }, \ >> 16 { DT_FIFO, "FIFO" }, \ >> 17 { DT_CHR, "CHR" }, \ >> 18 { DT_DIR, "DIR" }, \ >> 19 { DT_BLK, "BLK" }, \ >> 20 { DT_REG, "REG" }, \ >> 21 { DT_LNK, "LNK" }, \ >> 22 { DT_SOCK, "SOCK" }, \ >> 23 { DT_WHT, "WHT" }) 17 24 18 #define nfs_show_cache_validity(v) \ 25 #define nfs_show_cache_validity(v) \ 19 __print_flags(v, "|", \ 26 __print_flags(v, "|", \ >> 27 { NFS_INO_INVALID_ATTR, "INVALID_ATTR" }, \ 20 { NFS_INO_INVALID_DATA 28 { NFS_INO_INVALID_DATA, "INVALID_DATA" }, \ 21 { NFS_INO_INVALID_ATIM 29 { NFS_INO_INVALID_ATIME, "INVALID_ATIME" }, \ 22 { NFS_INO_INVALID_ACCE 30 { NFS_INO_INVALID_ACCESS, "INVALID_ACCESS" }, \ 23 { NFS_INO_INVALID_ACL, 31 { NFS_INO_INVALID_ACL, "INVALID_ACL" }, \ >> 32 { NFS_INO_REVAL_PAGECACHE, "REVAL_PAGECACHE" }, \ 24 { NFS_INO_REVAL_FORCED 33 { NFS_INO_REVAL_FORCED, "REVAL_FORCED" }, \ 25 { NFS_INO_INVALID_LABE !! 34 { NFS_INO_INVALID_LABEL, "INVALID_LABEL" }) 26 { NFS_INO_INVALID_CHAN << 27 { NFS_INO_INVALID_CTIM << 28 { NFS_INO_INVALID_MTIM << 29 { NFS_INO_INVALID_SIZE << 30 { NFS_INO_INVALID_OTHE << 31 { NFS_INO_DATA_INVAL_D << 32 { NFS_INO_INVALID_BLOC << 33 { NFS_INO_INVALID_XATT << 34 { NFS_INO_INVALID_NLIN << 35 { NFS_INO_INVALID_MODE << 36 35 37 #define nfs_show_nfsi_flags(v) \ 36 #define nfs_show_nfsi_flags(v) \ 38 __print_flags(v, "|", \ 37 __print_flags(v, "|", \ 39 { BIT(NFS_INO_STALE), !! 38 { 1 << NFS_INO_ADVISE_RDPLUS, "ADVISE_RDPLUS" }, \ 40 { BIT(NFS_INO_ACL_LRU_ !! 39 { 1 << NFS_INO_STALE, "STALE" }, \ 41 { BIT(NFS_INO_INVALIDA !! 40 { 1 << NFS_INO_INVALIDATING, "INVALIDATING" }, \ 42 { BIT(NFS_INO_LAYOUTCO !! 41 { 1 << NFS_INO_FSCACHE, "FSCACHE" }, \ 43 { BIT(NFS_INO_LAYOUTCO !! 42 { 1 << NFS_INO_LAYOUTCOMMIT, "NEED_LAYOUTCOMMIT" }, \ 44 { BIT(NFS_INO_LAYOUTST !! 43 { 1 << NFS_INO_LAYOUTCOMMITTING, "LAYOUTCOMMIT" }) 45 { BIT(NFS_INO_ODIRECT) << 46 44 47 DECLARE_EVENT_CLASS(nfs_inode_event, 45 DECLARE_EVENT_CLASS(nfs_inode_event, 48 TP_PROTO( 46 TP_PROTO( 49 const struct inode *in 47 const struct inode *inode 50 ), 48 ), 51 49 52 TP_ARGS(inode), 50 TP_ARGS(inode), 53 51 54 TP_STRUCT__entry( 52 TP_STRUCT__entry( 55 __field(dev_t, dev) 53 __field(dev_t, dev) 56 __field(u32, fhandle) 54 __field(u32, fhandle) 57 __field(u64, fileid) 55 __field(u64, fileid) 58 __field(u64, version) 56 __field(u64, version) 59 ), 57 ), 60 58 61 TP_fast_assign( 59 TP_fast_assign( 62 const struct nfs_inode 60 const struct nfs_inode *nfsi = NFS_I(inode); 63 __entry->dev = inode-> 61 __entry->dev = inode->i_sb->s_dev; 64 __entry->fileid = nfsi 62 __entry->fileid = nfsi->fileid; 65 __entry->fhandle = nfs 63 __entry->fhandle = nfs_fhandle_hash(&nfsi->fh); 66 __entry->version = ino !! 64 __entry->version = inode->i_version; 67 ), 65 ), 68 66 69 TP_printk( 67 TP_printk( 70 "fileid=%02x:%02x:%llu 68 "fileid=%02x:%02x:%llu fhandle=0x%08x version=%llu ", 71 MAJOR(__entry->dev), M 69 MAJOR(__entry->dev), MINOR(__entry->dev), 72 (unsigned long long)__ 70 (unsigned long long)__entry->fileid, 73 __entry->fhandle, 71 __entry->fhandle, 74 (unsigned long long)__ 72 (unsigned long long)__entry->version 75 ) 73 ) 76 ); 74 ); 77 75 78 DECLARE_EVENT_CLASS(nfs_inode_event_done, 76 DECLARE_EVENT_CLASS(nfs_inode_event_done, 79 TP_PROTO( 77 TP_PROTO( 80 const struct inode *in 78 const struct inode *inode, 81 int error 79 int error 82 ), 80 ), 83 81 84 TP_ARGS(inode, error), 82 TP_ARGS(inode, error), 85 83 86 TP_STRUCT__entry( 84 TP_STRUCT__entry( 87 __field(unsigned long, !! 85 __field(int, error) 88 __field(dev_t, dev) 86 __field(dev_t, dev) 89 __field(u32, fhandle) 87 __field(u32, fhandle) 90 __field(unsigned char, 88 __field(unsigned char, type) 91 __field(u64, fileid) 89 __field(u64, fileid) 92 __field(u64, version) 90 __field(u64, version) 93 __field(loff_t, size) 91 __field(loff_t, size) 94 __field(unsigned long, 92 __field(unsigned long, nfsi_flags) 95 __field(unsigned long, 93 __field(unsigned long, cache_validity) 96 ), 94 ), 97 95 98 TP_fast_assign( 96 TP_fast_assign( 99 const struct nfs_inode 97 const struct nfs_inode *nfsi = NFS_I(inode); 100 __entry->error = error !! 98 __entry->error = error; 101 __entry->dev = inode-> 99 __entry->dev = inode->i_sb->s_dev; 102 __entry->fileid = nfsi 100 __entry->fileid = nfsi->fileid; 103 __entry->fhandle = nfs 101 __entry->fhandle = nfs_fhandle_hash(&nfsi->fh); 104 __entry->type = nfs_um 102 __entry->type = nfs_umode_to_dtype(inode->i_mode); 105 __entry->version = ino !! 103 __entry->version = inode->i_version; 106 __entry->size = i_size 104 __entry->size = i_size_read(inode); 107 __entry->nfsi_flags = 105 __entry->nfsi_flags = nfsi->flags; 108 __entry->cache_validit 106 __entry->cache_validity = nfsi->cache_validity; 109 ), 107 ), 110 108 111 TP_printk( 109 TP_printk( 112 "error=%ld (%s) fileid !! 110 "error=%d fileid=%02x:%02x:%llu fhandle=0x%08x " 113 "type=%u (%s) version= 111 "type=%u (%s) version=%llu size=%lld " 114 "cache_validity=0x%lx !! 112 "cache_validity=%lu (%s) nfs_flags=%ld (%s)", 115 -__entry->error, show_ !! 113 __entry->error, 116 MAJOR(__entry->dev), M 114 MAJOR(__entry->dev), MINOR(__entry->dev), 117 (unsigned long long)__ 115 (unsigned long long)__entry->fileid, 118 __entry->fhandle, 116 __entry->fhandle, 119 __entry->type, 117 __entry->type, 120 show_fs_dirent_type(__ !! 118 nfs_show_file_type(__entry->type), 121 (unsigned long long)__ 119 (unsigned long long)__entry->version, 122 (long long)__entry->si 120 (long long)__entry->size, 123 __entry->cache_validit 121 __entry->cache_validity, 124 nfs_show_cache_validit 122 nfs_show_cache_validity(__entry->cache_validity), 125 __entry->nfsi_flags, 123 __entry->nfsi_flags, 126 nfs_show_nfsi_flags(__ 124 nfs_show_nfsi_flags(__entry->nfsi_flags) 127 ) 125 ) 128 ); 126 ); 129 127 130 #define DEFINE_NFS_INODE_EVENT(name) \ 128 #define DEFINE_NFS_INODE_EVENT(name) \ 131 DEFINE_EVENT(nfs_inode_event, name, \ 129 DEFINE_EVENT(nfs_inode_event, name, \ 132 TP_PROTO( \ 130 TP_PROTO( \ 133 const struct i 131 const struct inode *inode \ 134 ), \ 132 ), \ 135 TP_ARGS(inode)) 133 TP_ARGS(inode)) 136 #define DEFINE_NFS_INODE_EVENT_DONE(name) \ 134 #define DEFINE_NFS_INODE_EVENT_DONE(name) \ 137 DEFINE_EVENT(nfs_inode_event_done, nam 135 DEFINE_EVENT(nfs_inode_event_done, name, \ 138 TP_PROTO( \ 136 TP_PROTO( \ 139 const struct i 137 const struct inode *inode, \ 140 int error \ 138 int error \ 141 ), \ 139 ), \ 142 TP_ARGS(inode, error)) 140 TP_ARGS(inode, error)) 143 DEFINE_NFS_INODE_EVENT(nfs_set_inode_stale); << 144 DEFINE_NFS_INODE_EVENT(nfs_refresh_inode_enter 141 DEFINE_NFS_INODE_EVENT(nfs_refresh_inode_enter); 145 DEFINE_NFS_INODE_EVENT_DONE(nfs_refresh_inode_ 142 DEFINE_NFS_INODE_EVENT_DONE(nfs_refresh_inode_exit); 146 DEFINE_NFS_INODE_EVENT(nfs_revalidate_inode_en 143 DEFINE_NFS_INODE_EVENT(nfs_revalidate_inode_enter); 147 DEFINE_NFS_INODE_EVENT_DONE(nfs_revalidate_ino 144 DEFINE_NFS_INODE_EVENT_DONE(nfs_revalidate_inode_exit); 148 DEFINE_NFS_INODE_EVENT(nfs_invalidate_mapping_ 145 DEFINE_NFS_INODE_EVENT(nfs_invalidate_mapping_enter); 149 DEFINE_NFS_INODE_EVENT_DONE(nfs_invalidate_map 146 DEFINE_NFS_INODE_EVENT_DONE(nfs_invalidate_mapping_exit); 150 DEFINE_NFS_INODE_EVENT(nfs_getattr_enter); 147 DEFINE_NFS_INODE_EVENT(nfs_getattr_enter); 151 DEFINE_NFS_INODE_EVENT_DONE(nfs_getattr_exit); 148 DEFINE_NFS_INODE_EVENT_DONE(nfs_getattr_exit); 152 DEFINE_NFS_INODE_EVENT(nfs_setattr_enter); 149 DEFINE_NFS_INODE_EVENT(nfs_setattr_enter); 153 DEFINE_NFS_INODE_EVENT_DONE(nfs_setattr_exit); 150 DEFINE_NFS_INODE_EVENT_DONE(nfs_setattr_exit); >> 151 DEFINE_NFS_INODE_EVENT(nfs_writeback_page_enter); >> 152 DEFINE_NFS_INODE_EVENT_DONE(nfs_writeback_page_exit); 154 DEFINE_NFS_INODE_EVENT(nfs_writeback_inode_ent 153 DEFINE_NFS_INODE_EVENT(nfs_writeback_inode_enter); 155 DEFINE_NFS_INODE_EVENT_DONE(nfs_writeback_inod 154 DEFINE_NFS_INODE_EVENT_DONE(nfs_writeback_inode_exit); 156 DEFINE_NFS_INODE_EVENT(nfs_fsync_enter); 155 DEFINE_NFS_INODE_EVENT(nfs_fsync_enter); 157 DEFINE_NFS_INODE_EVENT_DONE(nfs_fsync_exit); 156 DEFINE_NFS_INODE_EVENT_DONE(nfs_fsync_exit); 158 DEFINE_NFS_INODE_EVENT(nfs_access_enter); 157 DEFINE_NFS_INODE_EVENT(nfs_access_enter); 159 DEFINE_NFS_INODE_EVENT_DONE(nfs_set_cache_inva !! 158 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 << 313 #define DEFINE_NFS_INODE_RANGE_EVENT(name) \ << 314 DEFINE_EVENT(nfs_inode_range_event, na << 315 TP_PROTO( \ << 316 const struct i << 317 loff_t range_s << 318 loff_t range_e << 319 ), \ << 320 TP_ARGS(inode, range_s << 321 << 322 DEFINE_NFS_INODE_RANGE_EVENT(nfs_readdir_inval << 323 << 324 DECLARE_EVENT_CLASS(nfs_readdir_event, << 325 TP_PROTO( << 326 const struct file *fil << 327 const __be32 *verifier << 328 u64 cookie, << 329 pgoff_t page_index, << 330 unsigned int dtsize << 331 ), << 332 << 333 TP_ARGS(file, verifier, cookie << 334 << 335 TP_STRUCT__entry( << 336 __field(dev_t, dev) << 337 __field(u32, fhandle) << 338 __field(u64, fileid) << 339 __field(u64, version) << 340 __array(char, verifier << 341 __field(u64, cookie) << 342 __field(pgoff_t, index << 343 __field(unsigned int, << 344 ), << 345 159 346 TP_fast_assign( !! 160 #define show_lookup_flags(flags) \ 347 const struct inode *di !! 161 __print_flags((unsigned long)flags, "|", \ 348 const struct nfs_inode !! 162 { LOOKUP_AUTOMOUNT, "AUTOMOUNT" }, \ 349 !! 163 { LOOKUP_DIRECTORY, "DIRECTORY" }, \ 350 __entry->dev = dir->i_ !! 164 { LOOKUP_OPEN, "OPEN" }, \ 351 __entry->fileid = nfsi !! 165 { LOOKUP_CREATE, "CREATE" }, \ 352 __entry->fhandle = nfs !! 166 { LOOKUP_EXCL, "EXCL" }) 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 167 390 DECLARE_EVENT_CLASS(nfs_lookup_event, 168 DECLARE_EVENT_CLASS(nfs_lookup_event, 391 TP_PROTO( 169 TP_PROTO( 392 const struct inode *di 170 const struct inode *dir, 393 const struct dentry *d 171 const struct dentry *dentry, 394 unsigned int flags 172 unsigned int flags 395 ), 173 ), 396 174 397 TP_ARGS(dir, dentry, flags), 175 TP_ARGS(dir, dentry, flags), 398 176 399 TP_STRUCT__entry( 177 TP_STRUCT__entry( 400 __field(unsigned long, !! 178 __field(unsigned int, flags) 401 __field(dev_t, dev) 179 __field(dev_t, dev) 402 __field(u64, dir) 180 __field(u64, dir) 403 __field(u64, fileid) << 404 __string(name, dentry- 181 __string(name, dentry->d_name.name) 405 ), 182 ), 406 183 407 TP_fast_assign( 184 TP_fast_assign( 408 __entry->dev = dir->i_ 185 __entry->dev = dir->i_sb->s_dev; 409 __entry->dir = NFS_FIL 186 __entry->dir = NFS_FILEID(dir); 410 __entry->flags = flags 187 __entry->flags = flags; 411 __entry->fileid = d_is !! 188 __assign_str(name, dentry->d_name.name); 412 __assign_str(name); << 413 ), 189 ), 414 190 415 TP_printk( 191 TP_printk( 416 "flags=0x%lx (%s) name !! 192 "flags=%u (%s) name=%02x:%02x:%llu/%s", 417 __entry->flags, 193 __entry->flags, 418 show_fs_lookup_flags(_ !! 194 show_lookup_flags(__entry->flags), 419 MAJOR(__entry->dev), M 195 MAJOR(__entry->dev), MINOR(__entry->dev), 420 (unsigned long long)__ 196 (unsigned long long)__entry->dir, 421 __get_str(name), !! 197 __get_str(name) 422 __entry->fileid << 423 ) 198 ) 424 ); 199 ); 425 200 426 #define DEFINE_NFS_LOOKUP_EVENT(name) \ 201 #define DEFINE_NFS_LOOKUP_EVENT(name) \ 427 DEFINE_EVENT(nfs_lookup_event, name, \ 202 DEFINE_EVENT(nfs_lookup_event, name, \ 428 TP_PROTO( \ 203 TP_PROTO( \ 429 const struct i 204 const struct inode *dir, \ 430 const struct d 205 const struct dentry *dentry, \ 431 unsigned int f 206 unsigned int flags \ 432 ), \ 207 ), \ 433 TP_ARGS(dir, dentry, f 208 TP_ARGS(dir, dentry, flags)) 434 209 435 DECLARE_EVENT_CLASS(nfs_lookup_event_done, 210 DECLARE_EVENT_CLASS(nfs_lookup_event_done, 436 TP_PROTO( 211 TP_PROTO( 437 const struct inode *di 212 const struct inode *dir, 438 const struct dentry *d 213 const struct dentry *dentry, 439 unsigned int flags, 214 unsigned int flags, 440 int error 215 int error 441 ), 216 ), 442 217 443 TP_ARGS(dir, dentry, flags, er 218 TP_ARGS(dir, dentry, flags, error), 444 219 445 TP_STRUCT__entry( 220 TP_STRUCT__entry( 446 __field(unsigned long, !! 221 __field(int, error) 447 __field(unsigned long, !! 222 __field(unsigned int, flags) 448 __field(dev_t, dev) 223 __field(dev_t, dev) 449 __field(u64, dir) 224 __field(u64, dir) 450 __field(u64, fileid) << 451 __string(name, dentry- 225 __string(name, dentry->d_name.name) 452 ), 226 ), 453 227 454 TP_fast_assign( 228 TP_fast_assign( 455 __entry->dev = dir->i_ 229 __entry->dev = dir->i_sb->s_dev; 456 __entry->dir = NFS_FIL 230 __entry->dir = NFS_FILEID(dir); 457 __entry->error = error !! 231 __entry->error = error; 458 __entry->flags = flags 232 __entry->flags = flags; 459 __entry->fileid = d_is !! 233 __assign_str(name, dentry->d_name.name); 460 __assign_str(name); << 461 ), 234 ), 462 235 463 TP_printk( 236 TP_printk( 464 "error=%ld (%s) flags= !! 237 "error=%d flags=%u (%s) name=%02x:%02x:%llu/%s", 465 -__entry->error, show_ !! 238 __entry->error, 466 __entry->flags, 239 __entry->flags, 467 show_fs_lookup_flags(_ !! 240 show_lookup_flags(__entry->flags), 468 MAJOR(__entry->dev), M 241 MAJOR(__entry->dev), MINOR(__entry->dev), 469 (unsigned long long)__ 242 (unsigned long long)__entry->dir, 470 __get_str(name), !! 243 __get_str(name) 471 __entry->fileid << 472 ) 244 ) 473 ); 245 ); 474 246 475 #define DEFINE_NFS_LOOKUP_EVENT_DONE(name) \ 247 #define DEFINE_NFS_LOOKUP_EVENT_DONE(name) \ 476 DEFINE_EVENT(nfs_lookup_event_done, na 248 DEFINE_EVENT(nfs_lookup_event_done, name, \ 477 TP_PROTO( \ 249 TP_PROTO( \ 478 const struct i 250 const struct inode *dir, \ 479 const struct d 251 const struct dentry *dentry, \ 480 unsigned int f 252 unsigned int flags, \ 481 int error \ 253 int error \ 482 ), \ 254 ), \ 483 TP_ARGS(dir, dentry, f 255 TP_ARGS(dir, dentry, flags, error)) 484 256 485 DEFINE_NFS_LOOKUP_EVENT(nfs_lookup_enter); 257 DEFINE_NFS_LOOKUP_EVENT(nfs_lookup_enter); 486 DEFINE_NFS_LOOKUP_EVENT_DONE(nfs_lookup_exit); 258 DEFINE_NFS_LOOKUP_EVENT_DONE(nfs_lookup_exit); 487 DEFINE_NFS_LOOKUP_EVENT(nfs_lookup_revalidate_ 259 DEFINE_NFS_LOOKUP_EVENT(nfs_lookup_revalidate_enter); 488 DEFINE_NFS_LOOKUP_EVENT_DONE(nfs_lookup_revali 260 DEFINE_NFS_LOOKUP_EVENT_DONE(nfs_lookup_revalidate_exit); 489 DEFINE_NFS_LOOKUP_EVENT(nfs_readdir_lookup); !! 261 490 DEFINE_NFS_LOOKUP_EVENT(nfs_readdir_lookup_rev !! 262 #define show_open_flags(flags) \ 491 DEFINE_NFS_LOOKUP_EVENT_DONE(nfs_readdir_looku !! 263 __print_flags((unsigned long)flags, "|", \ >> 264 { O_CREAT, "O_CREAT" }, \ >> 265 { O_EXCL, "O_EXCL" }, \ >> 266 { O_TRUNC, "O_TRUNC" }, \ >> 267 { O_APPEND, "O_APPEND" }, \ >> 268 { O_DSYNC, "O_DSYNC" }, \ >> 269 { O_DIRECT, "O_DIRECT" }, \ >> 270 { O_DIRECTORY, "O_DIRECTORY" }) >> 271 >> 272 #define show_fmode_flags(mode) \ >> 273 __print_flags(mode, "|", \ >> 274 { ((__force unsigned long)FMODE_READ), "READ" }, \ >> 275 { ((__force unsigned long)FMODE_WRITE), "WRITE" }, \ >> 276 { ((__force unsigned long)FMODE_EXEC), "EXEC" }) 492 277 493 TRACE_EVENT(nfs_atomic_open_enter, 278 TRACE_EVENT(nfs_atomic_open_enter, 494 TP_PROTO( 279 TP_PROTO( 495 const struct inode *di 280 const struct inode *dir, 496 const struct nfs_open_ 281 const struct nfs_open_context *ctx, 497 unsigned int flags 282 unsigned int flags 498 ), 283 ), 499 284 500 TP_ARGS(dir, ctx, flags), 285 TP_ARGS(dir, ctx, flags), 501 286 502 TP_STRUCT__entry( 287 TP_STRUCT__entry( 503 __field(unsigned long, !! 288 __field(unsigned int, flags) 504 __field(unsigned long, !! 289 __field(unsigned int, fmode) 505 __field(dev_t, dev) 290 __field(dev_t, dev) 506 __field(u64, dir) 291 __field(u64, dir) 507 __string(name, ctx->de 292 __string(name, ctx->dentry->d_name.name) 508 ), 293 ), 509 294 510 TP_fast_assign( 295 TP_fast_assign( 511 __entry->dev = dir->i_ 296 __entry->dev = dir->i_sb->s_dev; 512 __entry->dir = NFS_FIL 297 __entry->dir = NFS_FILEID(dir); 513 __entry->flags = flags 298 __entry->flags = flags; 514 __entry->fmode = (__fo !! 299 __entry->fmode = (__force unsigned int)ctx->mode; 515 __assign_str(name); !! 300 __assign_str(name, ctx->dentry->d_name.name); 516 ), 301 ), 517 302 518 TP_printk( 303 TP_printk( 519 "flags=0x%lx (%s) fmod !! 304 "flags=%u (%s) fmode=%s name=%02x:%02x:%llu/%s", 520 __entry->flags, 305 __entry->flags, 521 show_fs_fcntl_open_fla !! 306 show_open_flags(__entry->flags), 522 show_fs_fmode_flags(__ !! 307 show_fmode_flags(__entry->fmode), 523 MAJOR(__entry->dev), M 308 MAJOR(__entry->dev), MINOR(__entry->dev), 524 (unsigned long long)__ 309 (unsigned long long)__entry->dir, 525 __get_str(name) 310 __get_str(name) 526 ) 311 ) 527 ); 312 ); 528 313 529 TRACE_EVENT(nfs_atomic_open_exit, 314 TRACE_EVENT(nfs_atomic_open_exit, 530 TP_PROTO( 315 TP_PROTO( 531 const struct inode *di 316 const struct inode *dir, 532 const struct nfs_open_ 317 const struct nfs_open_context *ctx, 533 unsigned int flags, 318 unsigned int flags, 534 int error 319 int error 535 ), 320 ), 536 321 537 TP_ARGS(dir, ctx, flags, error 322 TP_ARGS(dir, ctx, flags, error), 538 323 539 TP_STRUCT__entry( 324 TP_STRUCT__entry( 540 __field(unsigned long, !! 325 __field(int, error) 541 __field(unsigned long, !! 326 __field(unsigned int, flags) 542 __field(unsigned long, !! 327 __field(unsigned int, fmode) 543 __field(dev_t, dev) 328 __field(dev_t, dev) 544 __field(u64, dir) 329 __field(u64, dir) 545 __string(name, ctx->de 330 __string(name, ctx->dentry->d_name.name) 546 ), 331 ), 547 332 548 TP_fast_assign( 333 TP_fast_assign( 549 __entry->error = -erro !! 334 __entry->error = error; 550 __entry->dev = dir->i_ 335 __entry->dev = dir->i_sb->s_dev; 551 __entry->dir = NFS_FIL 336 __entry->dir = NFS_FILEID(dir); 552 __entry->flags = flags 337 __entry->flags = flags; 553 __entry->fmode = (__fo !! 338 __entry->fmode = (__force unsigned int)ctx->mode; 554 __assign_str(name); !! 339 __assign_str(name, ctx->dentry->d_name.name); 555 ), 340 ), 556 341 557 TP_printk( 342 TP_printk( 558 "error=%ld (%s) flags= !! 343 "error=%d flags=%u (%s) fmode=%s " 559 "name=%02x:%02x:%llu/% 344 "name=%02x:%02x:%llu/%s", 560 -__entry->error, show_ !! 345 __entry->error, 561 __entry->flags, 346 __entry->flags, 562 show_fs_fcntl_open_fla !! 347 show_open_flags(__entry->flags), 563 show_fs_fmode_flags(__ !! 348 show_fmode_flags(__entry->fmode), 564 MAJOR(__entry->dev), M 349 MAJOR(__entry->dev), MINOR(__entry->dev), 565 (unsigned long long)__ 350 (unsigned long long)__entry->dir, 566 __get_str(name) 351 __get_str(name) 567 ) 352 ) 568 ); 353 ); 569 354 570 TRACE_EVENT(nfs_create_enter, 355 TRACE_EVENT(nfs_create_enter, 571 TP_PROTO( 356 TP_PROTO( 572 const struct inode *di 357 const struct inode *dir, 573 const struct dentry *d 358 const struct dentry *dentry, 574 unsigned int flags 359 unsigned int flags 575 ), 360 ), 576 361 577 TP_ARGS(dir, dentry, flags), 362 TP_ARGS(dir, dentry, flags), 578 363 579 TP_STRUCT__entry( 364 TP_STRUCT__entry( 580 __field(unsigned long, !! 365 __field(unsigned int, flags) 581 __field(dev_t, dev) 366 __field(dev_t, dev) 582 __field(u64, dir) 367 __field(u64, dir) 583 __string(name, dentry- 368 __string(name, dentry->d_name.name) 584 ), 369 ), 585 370 586 TP_fast_assign( 371 TP_fast_assign( 587 __entry->dev = dir->i_ 372 __entry->dev = dir->i_sb->s_dev; 588 __entry->dir = NFS_FIL 373 __entry->dir = NFS_FILEID(dir); 589 __entry->flags = flags 374 __entry->flags = flags; 590 __assign_str(name); !! 375 __assign_str(name, dentry->d_name.name); 591 ), 376 ), 592 377 593 TP_printk( 378 TP_printk( 594 "flags=0x%lx (%s) name !! 379 "flags=%u (%s) name=%02x:%02x:%llu/%s", 595 __entry->flags, 380 __entry->flags, 596 show_fs_fcntl_open_fla !! 381 show_open_flags(__entry->flags), 597 MAJOR(__entry->dev), M 382 MAJOR(__entry->dev), MINOR(__entry->dev), 598 (unsigned long long)__ 383 (unsigned long long)__entry->dir, 599 __get_str(name) 384 __get_str(name) 600 ) 385 ) 601 ); 386 ); 602 387 603 TRACE_EVENT(nfs_create_exit, 388 TRACE_EVENT(nfs_create_exit, 604 TP_PROTO( 389 TP_PROTO( 605 const struct inode *di 390 const struct inode *dir, 606 const struct dentry *d 391 const struct dentry *dentry, 607 unsigned int flags, 392 unsigned int flags, 608 int error 393 int error 609 ), 394 ), 610 395 611 TP_ARGS(dir, dentry, flags, er 396 TP_ARGS(dir, dentry, flags, error), 612 397 613 TP_STRUCT__entry( 398 TP_STRUCT__entry( 614 __field(unsigned long, !! 399 __field(int, error) 615 __field(unsigned long, !! 400 __field(unsigned int, flags) 616 __field(dev_t, dev) 401 __field(dev_t, dev) 617 __field(u64, dir) 402 __field(u64, dir) 618 __string(name, dentry- 403 __string(name, dentry->d_name.name) 619 ), 404 ), 620 405 621 TP_fast_assign( 406 TP_fast_assign( 622 __entry->error = -erro !! 407 __entry->error = error; 623 __entry->dev = dir->i_ 408 __entry->dev = dir->i_sb->s_dev; 624 __entry->dir = NFS_FIL 409 __entry->dir = NFS_FILEID(dir); 625 __entry->flags = flags 410 __entry->flags = flags; 626 __assign_str(name); !! 411 __assign_str(name, dentry->d_name.name); 627 ), 412 ), 628 413 629 TP_printk( 414 TP_printk( 630 "error=%ld (%s) flags= !! 415 "error=%d flags=%u (%s) name=%02x:%02x:%llu/%s", 631 -__entry->error, show_ !! 416 __entry->error, 632 __entry->flags, 417 __entry->flags, 633 show_fs_fcntl_open_fla !! 418 show_open_flags(__entry->flags), 634 MAJOR(__entry->dev), M 419 MAJOR(__entry->dev), MINOR(__entry->dev), 635 (unsigned long long)__ 420 (unsigned long long)__entry->dir, 636 __get_str(name) 421 __get_str(name) 637 ) 422 ) 638 ); 423 ); 639 424 640 DECLARE_EVENT_CLASS(nfs_directory_event, 425 DECLARE_EVENT_CLASS(nfs_directory_event, 641 TP_PROTO( 426 TP_PROTO( 642 const struct inode *di 427 const struct inode *dir, 643 const struct dentry *d 428 const struct dentry *dentry 644 ), 429 ), 645 430 646 TP_ARGS(dir, dentry), 431 TP_ARGS(dir, dentry), 647 432 648 TP_STRUCT__entry( 433 TP_STRUCT__entry( 649 __field(dev_t, dev) 434 __field(dev_t, dev) 650 __field(u64, dir) 435 __field(u64, dir) 651 __string(name, dentry- 436 __string(name, dentry->d_name.name) 652 ), 437 ), 653 438 654 TP_fast_assign( 439 TP_fast_assign( 655 __entry->dev = dir->i_ 440 __entry->dev = dir->i_sb->s_dev; 656 __entry->dir = NFS_FIL 441 __entry->dir = NFS_FILEID(dir); 657 __assign_str(name); !! 442 __assign_str(name, dentry->d_name.name); 658 ), 443 ), 659 444 660 TP_printk( 445 TP_printk( 661 "name=%02x:%02x:%llu/% 446 "name=%02x:%02x:%llu/%s", 662 MAJOR(__entry->dev), M 447 MAJOR(__entry->dev), MINOR(__entry->dev), 663 (unsigned long long)__ 448 (unsigned long long)__entry->dir, 664 __get_str(name) 449 __get_str(name) 665 ) 450 ) 666 ); 451 ); 667 452 668 #define DEFINE_NFS_DIRECTORY_EVENT(name) \ 453 #define DEFINE_NFS_DIRECTORY_EVENT(name) \ 669 DEFINE_EVENT(nfs_directory_event, name 454 DEFINE_EVENT(nfs_directory_event, name, \ 670 TP_PROTO( \ 455 TP_PROTO( \ 671 const struct i 456 const struct inode *dir, \ 672 const struct d 457 const struct dentry *dentry \ 673 ), \ 458 ), \ 674 TP_ARGS(dir, dentry)) 459 TP_ARGS(dir, dentry)) 675 460 676 DECLARE_EVENT_CLASS(nfs_directory_event_done, 461 DECLARE_EVENT_CLASS(nfs_directory_event_done, 677 TP_PROTO( 462 TP_PROTO( 678 const struct inode *di 463 const struct inode *dir, 679 const struct dentry *d 464 const struct dentry *dentry, 680 int error 465 int error 681 ), 466 ), 682 467 683 TP_ARGS(dir, dentry, error), 468 TP_ARGS(dir, dentry, error), 684 469 685 TP_STRUCT__entry( 470 TP_STRUCT__entry( 686 __field(unsigned long, !! 471 __field(int, error) 687 __field(dev_t, dev) 472 __field(dev_t, dev) 688 __field(u64, dir) 473 __field(u64, dir) 689 __string(name, dentry- 474 __string(name, dentry->d_name.name) 690 ), 475 ), 691 476 692 TP_fast_assign( 477 TP_fast_assign( 693 __entry->dev = dir->i_ 478 __entry->dev = dir->i_sb->s_dev; 694 __entry->dir = NFS_FIL 479 __entry->dir = NFS_FILEID(dir); 695 __entry->error = error !! 480 __entry->error = error; 696 __assign_str(name); !! 481 __assign_str(name, dentry->d_name.name); 697 ), 482 ), 698 483 699 TP_printk( 484 TP_printk( 700 "error=%ld (%s) name=% !! 485 "error=%d name=%02x:%02x:%llu/%s", 701 -__entry->error, show_ !! 486 __entry->error, 702 MAJOR(__entry->dev), M 487 MAJOR(__entry->dev), MINOR(__entry->dev), 703 (unsigned long long)__ 488 (unsigned long long)__entry->dir, 704 __get_str(name) 489 __get_str(name) 705 ) 490 ) 706 ); 491 ); 707 492 708 #define DEFINE_NFS_DIRECTORY_EVENT_DONE(name) 493 #define DEFINE_NFS_DIRECTORY_EVENT_DONE(name) \ 709 DEFINE_EVENT(nfs_directory_event_done, 494 DEFINE_EVENT(nfs_directory_event_done, name, \ 710 TP_PROTO( \ 495 TP_PROTO( \ 711 const struct i 496 const struct inode *dir, \ 712 const struct d 497 const struct dentry *dentry, \ 713 int error \ 498 int error \ 714 ), \ 499 ), \ 715 TP_ARGS(dir, dentry, e 500 TP_ARGS(dir, dentry, error)) 716 501 717 DEFINE_NFS_DIRECTORY_EVENT(nfs_mknod_enter); 502 DEFINE_NFS_DIRECTORY_EVENT(nfs_mknod_enter); 718 DEFINE_NFS_DIRECTORY_EVENT_DONE(nfs_mknod_exit 503 DEFINE_NFS_DIRECTORY_EVENT_DONE(nfs_mknod_exit); 719 DEFINE_NFS_DIRECTORY_EVENT(nfs_mkdir_enter); 504 DEFINE_NFS_DIRECTORY_EVENT(nfs_mkdir_enter); 720 DEFINE_NFS_DIRECTORY_EVENT_DONE(nfs_mkdir_exit 505 DEFINE_NFS_DIRECTORY_EVENT_DONE(nfs_mkdir_exit); 721 DEFINE_NFS_DIRECTORY_EVENT(nfs_rmdir_enter); 506 DEFINE_NFS_DIRECTORY_EVENT(nfs_rmdir_enter); 722 DEFINE_NFS_DIRECTORY_EVENT_DONE(nfs_rmdir_exit 507 DEFINE_NFS_DIRECTORY_EVENT_DONE(nfs_rmdir_exit); 723 DEFINE_NFS_DIRECTORY_EVENT(nfs_remove_enter); 508 DEFINE_NFS_DIRECTORY_EVENT(nfs_remove_enter); 724 DEFINE_NFS_DIRECTORY_EVENT_DONE(nfs_remove_exi 509 DEFINE_NFS_DIRECTORY_EVENT_DONE(nfs_remove_exit); 725 DEFINE_NFS_DIRECTORY_EVENT(nfs_unlink_enter); 510 DEFINE_NFS_DIRECTORY_EVENT(nfs_unlink_enter); 726 DEFINE_NFS_DIRECTORY_EVENT_DONE(nfs_unlink_exi 511 DEFINE_NFS_DIRECTORY_EVENT_DONE(nfs_unlink_exit); 727 DEFINE_NFS_DIRECTORY_EVENT(nfs_symlink_enter); 512 DEFINE_NFS_DIRECTORY_EVENT(nfs_symlink_enter); 728 DEFINE_NFS_DIRECTORY_EVENT_DONE(nfs_symlink_ex 513 DEFINE_NFS_DIRECTORY_EVENT_DONE(nfs_symlink_exit); 729 514 730 TRACE_EVENT(nfs_link_enter, 515 TRACE_EVENT(nfs_link_enter, 731 TP_PROTO( 516 TP_PROTO( 732 const struct inode *in 517 const struct inode *inode, 733 const struct inode *di 518 const struct inode *dir, 734 const struct dentry *d 519 const struct dentry *dentry 735 ), 520 ), 736 521 737 TP_ARGS(inode, dir, dentry), 522 TP_ARGS(inode, dir, dentry), 738 523 739 TP_STRUCT__entry( 524 TP_STRUCT__entry( 740 __field(dev_t, dev) 525 __field(dev_t, dev) 741 __field(u64, fileid) 526 __field(u64, fileid) 742 __field(u64, dir) 527 __field(u64, dir) 743 __string(name, dentry- 528 __string(name, dentry->d_name.name) 744 ), 529 ), 745 530 746 TP_fast_assign( 531 TP_fast_assign( 747 __entry->dev = inode-> 532 __entry->dev = inode->i_sb->s_dev; 748 __entry->fileid = NFS_ 533 __entry->fileid = NFS_FILEID(inode); 749 __entry->dir = NFS_FIL 534 __entry->dir = NFS_FILEID(dir); 750 __assign_str(name); !! 535 __assign_str(name, dentry->d_name.name); 751 ), 536 ), 752 537 753 TP_printk( 538 TP_printk( 754 "fileid=%02x:%02x:%llu 539 "fileid=%02x:%02x:%llu name=%02x:%02x:%llu/%s", 755 MAJOR(__entry->dev), M 540 MAJOR(__entry->dev), MINOR(__entry->dev), 756 __entry->fileid, 541 __entry->fileid, 757 MAJOR(__entry->dev), M 542 MAJOR(__entry->dev), MINOR(__entry->dev), 758 (unsigned long long)__ 543 (unsigned long long)__entry->dir, 759 __get_str(name) 544 __get_str(name) 760 ) 545 ) 761 ); 546 ); 762 547 763 TRACE_EVENT(nfs_link_exit, 548 TRACE_EVENT(nfs_link_exit, 764 TP_PROTO( 549 TP_PROTO( 765 const struct inode *in 550 const struct inode *inode, 766 const struct inode *di 551 const struct inode *dir, 767 const struct dentry *d 552 const struct dentry *dentry, 768 int error 553 int error 769 ), 554 ), 770 555 771 TP_ARGS(inode, dir, dentry, er 556 TP_ARGS(inode, dir, dentry, error), 772 557 773 TP_STRUCT__entry( 558 TP_STRUCT__entry( 774 __field(unsigned long, !! 559 __field(int, error) 775 __field(dev_t, dev) 560 __field(dev_t, dev) 776 __field(u64, fileid) 561 __field(u64, fileid) 777 __field(u64, dir) 562 __field(u64, dir) 778 __string(name, dentry- 563 __string(name, dentry->d_name.name) 779 ), 564 ), 780 565 781 TP_fast_assign( 566 TP_fast_assign( 782 __entry->dev = inode-> 567 __entry->dev = inode->i_sb->s_dev; 783 __entry->fileid = NFS_ 568 __entry->fileid = NFS_FILEID(inode); 784 __entry->dir = NFS_FIL 569 __entry->dir = NFS_FILEID(dir); 785 __entry->error = error !! 570 __entry->error = error; 786 __assign_str(name); !! 571 __assign_str(name, dentry->d_name.name); 787 ), 572 ), 788 573 789 TP_printk( 574 TP_printk( 790 "error=%ld (%s) fileid !! 575 "error=%d fileid=%02x:%02x:%llu name=%02x:%02x:%llu/%s", 791 -__entry->error, show_ !! 576 __entry->error, 792 MAJOR(__entry->dev), M 577 MAJOR(__entry->dev), MINOR(__entry->dev), 793 __entry->fileid, 578 __entry->fileid, 794 MAJOR(__entry->dev), M 579 MAJOR(__entry->dev), MINOR(__entry->dev), 795 (unsigned long long)__ 580 (unsigned long long)__entry->dir, 796 __get_str(name) 581 __get_str(name) 797 ) 582 ) 798 ); 583 ); 799 584 800 DECLARE_EVENT_CLASS(nfs_rename_event, 585 DECLARE_EVENT_CLASS(nfs_rename_event, 801 TP_PROTO( 586 TP_PROTO( 802 const struct inode *ol 587 const struct inode *old_dir, 803 const struct dentry *o 588 const struct dentry *old_dentry, 804 const struct inode *ne 589 const struct inode *new_dir, 805 const struct dentry *n 590 const struct dentry *new_dentry 806 ), 591 ), 807 592 808 TP_ARGS(old_dir, old_dentry, n 593 TP_ARGS(old_dir, old_dentry, new_dir, new_dentry), 809 594 810 TP_STRUCT__entry( 595 TP_STRUCT__entry( 811 __field(dev_t, dev) 596 __field(dev_t, dev) 812 __field(u64, old_dir) 597 __field(u64, old_dir) 813 __field(u64, new_dir) 598 __field(u64, new_dir) 814 __string(old_name, old 599 __string(old_name, old_dentry->d_name.name) 815 __string(new_name, new 600 __string(new_name, new_dentry->d_name.name) 816 ), 601 ), 817 602 818 TP_fast_assign( 603 TP_fast_assign( 819 __entry->dev = old_dir 604 __entry->dev = old_dir->i_sb->s_dev; 820 __entry->old_dir = NFS 605 __entry->old_dir = NFS_FILEID(old_dir); 821 __entry->new_dir = NFS 606 __entry->new_dir = NFS_FILEID(new_dir); 822 __assign_str(old_name) !! 607 __assign_str(old_name, old_dentry->d_name.name); 823 __assign_str(new_name) !! 608 __assign_str(new_name, new_dentry->d_name.name); 824 ), 609 ), 825 610 826 TP_printk( 611 TP_printk( 827 "old_name=%02x:%02x:%l 612 "old_name=%02x:%02x:%llu/%s new_name=%02x:%02x:%llu/%s", 828 MAJOR(__entry->dev), M 613 MAJOR(__entry->dev), MINOR(__entry->dev), 829 (unsigned long long)__ 614 (unsigned long long)__entry->old_dir, 830 __get_str(old_name), 615 __get_str(old_name), 831 MAJOR(__entry->dev), M 616 MAJOR(__entry->dev), MINOR(__entry->dev), 832 (unsigned long long)__ 617 (unsigned long long)__entry->new_dir, 833 __get_str(new_name) 618 __get_str(new_name) 834 ) 619 ) 835 ); 620 ); 836 #define DEFINE_NFS_RENAME_EVENT(name) \ 621 #define DEFINE_NFS_RENAME_EVENT(name) \ 837 DEFINE_EVENT(nfs_rename_event, name, \ 622 DEFINE_EVENT(nfs_rename_event, name, \ 838 TP_PROTO( \ 623 TP_PROTO( \ 839 const struct i 624 const struct inode *old_dir, \ 840 const struct d 625 const struct dentry *old_dentry, \ 841 const struct i 626 const struct inode *new_dir, \ 842 const struct d 627 const struct dentry *new_dentry \ 843 ), \ 628 ), \ 844 TP_ARGS(old_dir, old_d 629 TP_ARGS(old_dir, old_dentry, new_dir, new_dentry)) 845 630 846 DECLARE_EVENT_CLASS(nfs_rename_event_done, 631 DECLARE_EVENT_CLASS(nfs_rename_event_done, 847 TP_PROTO( 632 TP_PROTO( 848 const struct inode *ol 633 const struct inode *old_dir, 849 const struct dentry *o 634 const struct dentry *old_dentry, 850 const struct inode *ne 635 const struct inode *new_dir, 851 const struct dentry *n 636 const struct dentry *new_dentry, 852 int error 637 int error 853 ), 638 ), 854 639 855 TP_ARGS(old_dir, old_dentry, n 640 TP_ARGS(old_dir, old_dentry, new_dir, new_dentry, error), 856 641 857 TP_STRUCT__entry( 642 TP_STRUCT__entry( 858 __field(dev_t, dev) 643 __field(dev_t, dev) 859 __field(unsigned long, !! 644 __field(int, error) 860 __field(u64, old_dir) 645 __field(u64, old_dir) 861 __string(old_name, old 646 __string(old_name, old_dentry->d_name.name) 862 __field(u64, new_dir) 647 __field(u64, new_dir) 863 __string(new_name, new 648 __string(new_name, new_dentry->d_name.name) 864 ), 649 ), 865 650 866 TP_fast_assign( 651 TP_fast_assign( 867 __entry->dev = old_dir 652 __entry->dev = old_dir->i_sb->s_dev; 868 __entry->error = -erro << 869 __entry->old_dir = NFS 653 __entry->old_dir = NFS_FILEID(old_dir); 870 __entry->new_dir = NFS 654 __entry->new_dir = NFS_FILEID(new_dir); 871 __assign_str(old_name) !! 655 __entry->error = error; 872 __assign_str(new_name) !! 656 __assign_str(old_name, old_dentry->d_name.name); >> 657 __assign_str(new_name, new_dentry->d_name.name); 873 ), 658 ), 874 659 875 TP_printk( 660 TP_printk( 876 "error=%ld (%s) old_na !! 661 "error=%d old_name=%02x:%02x:%llu/%s " 877 "new_name=%02x:%02x:%l 662 "new_name=%02x:%02x:%llu/%s", 878 -__entry->error, show_ !! 663 __entry->error, 879 MAJOR(__entry->dev), M 664 MAJOR(__entry->dev), MINOR(__entry->dev), 880 (unsigned long long)__ 665 (unsigned long long)__entry->old_dir, 881 __get_str(old_name), 666 __get_str(old_name), 882 MAJOR(__entry->dev), M 667 MAJOR(__entry->dev), MINOR(__entry->dev), 883 (unsigned long long)__ 668 (unsigned long long)__entry->new_dir, 884 __get_str(new_name) 669 __get_str(new_name) 885 ) 670 ) 886 ); 671 ); 887 #define DEFINE_NFS_RENAME_EVENT_DONE(name) \ 672 #define DEFINE_NFS_RENAME_EVENT_DONE(name) \ 888 DEFINE_EVENT(nfs_rename_event_done, na 673 DEFINE_EVENT(nfs_rename_event_done, name, \ 889 TP_PROTO( \ 674 TP_PROTO( \ 890 const struct i 675 const struct inode *old_dir, \ 891 const struct d 676 const struct dentry *old_dentry, \ 892 const struct i 677 const struct inode *new_dir, \ 893 const struct d 678 const struct dentry *new_dentry, \ 894 int error \ 679 int error \ 895 ), \ 680 ), \ 896 TP_ARGS(old_dir, old_d 681 TP_ARGS(old_dir, old_dentry, new_dir, \ 897 new_dentry, er 682 new_dentry, error)) 898 683 899 DEFINE_NFS_RENAME_EVENT(nfs_rename_enter); 684 DEFINE_NFS_RENAME_EVENT(nfs_rename_enter); 900 DEFINE_NFS_RENAME_EVENT_DONE(nfs_rename_exit); 685 DEFINE_NFS_RENAME_EVENT_DONE(nfs_rename_exit); 901 686 902 DEFINE_NFS_RENAME_EVENT_DONE(nfs_async_rename_ !! 687 DEFINE_NFS_RENAME_EVENT_DONE(nfs_sillyrename_rename); 903 688 904 TRACE_EVENT(nfs_sillyrename_unlink, 689 TRACE_EVENT(nfs_sillyrename_unlink, 905 TP_PROTO( 690 TP_PROTO( 906 const struct nfs_unlin 691 const struct nfs_unlinkdata *data, 907 int error 692 int error 908 ), 693 ), 909 694 910 TP_ARGS(data, error), 695 TP_ARGS(data, error), 911 696 912 TP_STRUCT__entry( 697 TP_STRUCT__entry( 913 __field(dev_t, dev) 698 __field(dev_t, dev) 914 __field(unsigned long, !! 699 __field(int, error) 915 __field(u64, dir) 700 __field(u64, dir) 916 __dynamic_array(char, 701 __dynamic_array(char, name, data->args.name.len + 1) 917 ), 702 ), 918 703 919 TP_fast_assign( 704 TP_fast_assign( 920 struct inode *dir = d_ 705 struct inode *dir = d_inode(data->dentry->d_parent); 921 size_t len = data->arg 706 size_t len = data->args.name.len; 922 __entry->dev = dir->i_ 707 __entry->dev = dir->i_sb->s_dev; 923 __entry->dir = NFS_FIL 708 __entry->dir = NFS_FILEID(dir); 924 __entry->error = -erro !! 709 __entry->error = error; 925 memcpy(__get_str(name) 710 memcpy(__get_str(name), 926 data->args.nam 711 data->args.name.name, len); 927 __get_str(name)[len] = 712 __get_str(name)[len] = 0; 928 ), 713 ), 929 714 930 TP_printk( 715 TP_printk( 931 "error=%ld (%s) name=% !! 716 "error=%d name=%02x:%02x:%llu/%s", 932 -__entry->error, show_ !! 717 __entry->error, 933 MAJOR(__entry->dev), M 718 MAJOR(__entry->dev), MINOR(__entry->dev), 934 (unsigned long long)__ 719 (unsigned long long)__entry->dir, 935 __get_str(name) 720 __get_str(name) 936 ) 721 ) 937 ); 722 ); 938 723 939 DECLARE_EVENT_CLASS(nfs_folio_event, !! 724 TRACE_EVENT(nfs_initiate_read, 940 TP_PROTO( 725 TP_PROTO( 941 const struct inode *in 726 const struct inode *inode, 942 loff_t offset, !! 727 loff_t offset, unsigned long count 943 size_t count << 944 ), 728 ), 945 729 946 TP_ARGS(inode, offset, count), 730 TP_ARGS(inode, offset, count), 947 731 948 TP_STRUCT__entry( 732 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 << 954 __field(size_t, 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) << 999 __field(u32, fhandle) << 1000 __field(int, ret) << 1001 __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 733 __field(loff_t, offset) 1063 __field(unsigned int, !! 734 __field(unsigned long, count) 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) 735 __field(dev_t, dev) 1097 __field(u32, fhandle) 736 __field(u32, fhandle) 1098 __field(int, ret) << 1099 __field(u64, fileid) 737 __field(u64, fileid) 1100 __field(u64, version) << 1101 __field(loff_t, offse << 1102 __field(unsigned int, << 1103 ), 738 ), 1104 739 1105 TP_fast_assign( 740 TP_fast_assign( 1106 const struct nfs_inod 741 const struct nfs_inode *nfsi = NFS_I(inode); 1107 742 >> 743 __entry->offset = offset; >> 744 __entry->count = count; 1108 __entry->dev = inode- 745 __entry->dev = inode->i_sb->s_dev; 1109 __entry->fileid = nfs 746 __entry->fileid = nfsi->fileid; 1110 __entry->fhandle = nf 747 __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 ), 748 ), 1152 749 1153 TP_printk( 750 TP_printk( 1154 "fileid=%02x:%02x:%ll 751 "fileid=%02x:%02x:%llu fhandle=0x%08x " 1155 "offset=%lld count=%u !! 752 "offset=%lld count=%lu", 1156 MAJOR(__entry->dev), 753 MAJOR(__entry->dev), MINOR(__entry->dev), 1157 (unsigned long long)_ 754 (unsigned long long)__entry->fileid, 1158 __entry->fhandle, 755 __entry->fhandle, 1159 (long long)__entry->o !! 756 __entry->offset, __entry->count 1160 ) 757 ) 1161 ); 758 ); 1162 759 1163 TRACE_EVENT(nfs_readpage_done, 760 TRACE_EVENT(nfs_readpage_done, 1164 TP_PROTO( 761 TP_PROTO( 1165 const struct rpc_task !! 762 const struct inode *inode, 1166 const struct nfs_pgio !! 763 int status, loff_t offset, bool eof 1167 ), 764 ), 1168 765 1169 TP_ARGS(task, hdr), !! 766 TP_ARGS(inode, status, offset, eof), 1170 767 1171 TP_STRUCT__entry( 768 TP_STRUCT__entry( 1172 __field(dev_t, dev) !! 769 __field(int, status) 1173 __field(u32, fhandle) << 1174 __field(u64, fileid) << 1175 __field(loff_t, offse 770 __field(loff_t, offset) 1176 __field(u32, arg_coun << 1177 __field(u32, res_coun << 1178 __field(bool, eof) 771 __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) 772 __field(dev_t, dev) 1219 __field(u32, fhandle) 773 __field(u32, fhandle) 1220 __field(u64, fileid) 774 __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 ), 775 ), 1227 776 1228 TP_fast_assign( 777 TP_fast_assign( 1229 const struct inode *i << 1230 const struct nfs_inod 778 const struct nfs_inode *nfsi = NFS_I(inode); 1231 const struct nfs_fh * << 1232 << 1233 779 1234 __entry->error = task !! 780 __entry->status = status; 1235 __entry->offset = hdr !! 781 __entry->offset = offset; 1236 __entry->arg_count = !! 782 __entry->eof = eof; 1237 __entry->res_count = << 1238 __entry->eof = hdr->r << 1239 __entry->dev = inode- 783 __entry->dev = inode->i_sb->s_dev; 1240 __entry->fileid = nfs 784 __entry->fileid = nfsi->fileid; 1241 __entry->fhandle = nf !! 785 __entry->fhandle = nfs_fhandle_hash(&nfsi->fh); 1242 ), 786 ), 1243 787 1244 TP_printk( 788 TP_printk( 1245 "error=%d fileid=%02x !! 789 "fileid=%02x:%02x:%llu fhandle=0x%08x " 1246 "offset=%lld count=%u !! 790 "offset=%lld status=%d%s", 1247 MAJOR(__entry->dev), 791 MAJOR(__entry->dev), MINOR(__entry->dev), 1248 (unsigned long long)_ 792 (unsigned long long)__entry->fileid, 1249 __entry->fhandle, 793 __entry->fhandle, 1250 (long long)__entry->o !! 794 __entry->offset, __entry->status, 1251 __entry->res_count, _ !! 795 __entry->eof ? " eof" : "" 1252 ) 796 ) 1253 ); 797 ); 1254 798 1255 !! 799 /* 1256 TRACE_EVENT(nfs_pgio_error, !! 800 * XXX: I tried using NFS_UNSTABLE and friends in this table, but they 1257 TP_PROTO( !! 801 * all evaluate to 0 for some reason, even if I include linux/nfs.h. 1258 const struct nfs_pgio_header !! 802 */ 1259 int error, !! 803 #define nfs_show_stable(stable) \ 1260 loff_t pos !! 804 __print_symbolic(stable, \ 1261 ), !! 805 { 0, " (UNSTABLE)" }, \ 1262 !! 806 { 1, " (DATA_SYNC)" }, \ 1263 TP_ARGS(hdr, error, pos), !! 807 { 2, " (FILE_SYNC)" }) 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 808 1300 TRACE_EVENT(nfs_initiate_write, 809 TRACE_EVENT(nfs_initiate_write, 1301 TP_PROTO( 810 TP_PROTO( 1302 const struct nfs_pgio !! 811 const struct inode *inode, >> 812 loff_t offset, unsigned long count, >> 813 enum nfs3_stable_how stable 1303 ), 814 ), 1304 815 1305 TP_ARGS(hdr), !! 816 TP_ARGS(inode, offset, count, stable), 1306 817 1307 TP_STRUCT__entry( 818 TP_STRUCT__entry( >> 819 __field(loff_t, offset) >> 820 __field(unsigned long, count) >> 821 __field(enum nfs3_stable_how, stable) 1308 __field(dev_t, dev) 822 __field(dev_t, dev) 1309 __field(u32, fhandle) 823 __field(u32, fhandle) 1310 __field(u64, fileid) 824 __field(u64, fileid) 1311 __field(loff_t, offse << 1312 __field(u32, count) << 1313 __field(unsigned long << 1314 ), 825 ), 1315 826 1316 TP_fast_assign( 827 TP_fast_assign( 1317 const struct inode *i << 1318 const struct nfs_inod 828 const struct nfs_inode *nfsi = NFS_I(inode); 1319 const struct nfs_fh * << 1320 << 1321 829 1322 __entry->offset = hdr !! 830 __entry->offset = offset; 1323 __entry->count = hdr- !! 831 __entry->count = count; 1324 __entry->stable = hdr !! 832 __entry->stable = stable; 1325 __entry->dev = inode- 833 __entry->dev = inode->i_sb->s_dev; 1326 __entry->fileid = nfs 834 __entry->fileid = nfsi->fileid; 1327 __entry->fhandle = nf !! 835 __entry->fhandle = nfs_fhandle_hash(&nfsi->fh); 1328 ), 836 ), 1329 837 1330 TP_printk( 838 TP_printk( 1331 "fileid=%02x:%02x:%ll 839 "fileid=%02x:%02x:%llu fhandle=0x%08x " 1332 "offset=%lld count=%u !! 840 "offset=%lld count=%lu stable=%d%s", 1333 MAJOR(__entry->dev), 841 MAJOR(__entry->dev), MINOR(__entry->dev), 1334 (unsigned long long)_ 842 (unsigned long long)__entry->fileid, 1335 __entry->fhandle, 843 __entry->fhandle, 1336 (long long)__entry->o !! 844 __entry->offset, __entry->count, 1337 show_nfs_stable_how(_ !! 845 __entry->stable, nfs_show_stable(__entry->stable) 1338 ) 846 ) 1339 ); 847 ); 1340 848 1341 TRACE_EVENT(nfs_writeback_done, 849 TRACE_EVENT(nfs_writeback_done, 1342 TP_PROTO( 850 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 851 const struct inode *inode, 1398 const struct nfs_page !! 852 int status, 1399 int error !! 853 loff_t offset, >> 854 struct nfs_writeverf *writeverf 1400 ), 855 ), 1401 856 1402 TP_ARGS(inode, req, error), !! 857 TP_ARGS(inode, status, offset, writeverf), 1403 858 1404 TP_STRUCT__entry( 859 TP_STRUCT__entry( >> 860 __field(int, status) >> 861 __field(loff_t, offset) >> 862 __field(enum nfs3_stable_how, stable) >> 863 __field(unsigned long long, verifier) 1405 __field(dev_t, dev) 864 __field(dev_t, dev) 1406 __field(u32, fhandle) 865 __field(u32, fhandle) 1407 __field(u64, fileid) 866 __field(u64, fileid) 1408 __field(loff_t, offse << 1409 __field(unsigned int, << 1410 __field(int, error) << 1411 ), 867 ), 1412 868 1413 TP_fast_assign( 869 TP_fast_assign( 1414 const struct nfs_inod 870 const struct nfs_inode *nfsi = NFS_I(inode); >> 871 >> 872 __entry->status = status; >> 873 __entry->offset = offset; >> 874 __entry->stable = writeverf->committed; >> 875 memcpy(&__entry->verifier, &writeverf->verifier, >> 876 sizeof(__entry->verifier)); 1415 __entry->dev = inode- 877 __entry->dev = inode->i_sb->s_dev; 1416 __entry->fileid = nfs 878 __entry->fileid = nfsi->fileid; 1417 __entry->fhandle = nf 879 __entry->fhandle = nfs_fhandle_hash(&nfsi->fh); 1418 __entry->offset = req << 1419 __entry->count = req- << 1420 __entry->error = erro << 1421 ), 880 ), 1422 881 1423 TP_printk( 882 TP_printk( 1424 "error=%d fileid=%02x !! 883 "fileid=%02x:%02x:%llu fhandle=0x%08x " 1425 "offset=%lld count=%u !! 884 "offset=%lld status=%d stable=%d%s " >> 885 "verifier 0x%016llx", 1426 MAJOR(__entry->dev), 886 MAJOR(__entry->dev), MINOR(__entry->dev), 1427 (unsigned long long)_ 887 (unsigned long long)__entry->fileid, 1428 __entry->fhandle, __e !! 888 __entry->fhandle, 1429 __entry->count !! 889 __entry->offset, __entry->status, >> 890 __entry->stable, nfs_show_stable(__entry->stable), >> 891 __entry->verifier 1430 ) 892 ) 1431 ); 893 ); 1432 894 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, 895 TRACE_EVENT(nfs_initiate_commit, 1447 TP_PROTO( 896 TP_PROTO( 1448 const struct nfs_comm 897 const struct nfs_commit_data *data 1449 ), 898 ), 1450 899 1451 TP_ARGS(data), 900 TP_ARGS(data), 1452 901 1453 TP_STRUCT__entry( 902 TP_STRUCT__entry( >> 903 __field(loff_t, offset) >> 904 __field(unsigned long, count) 1454 __field(dev_t, dev) 905 __field(dev_t, dev) 1455 __field(u32, fhandle) 906 __field(u32, fhandle) 1456 __field(u64, fileid) 907 __field(u64, fileid) 1457 __field(loff_t, offse << 1458 __field(u32, count) << 1459 ), 908 ), 1460 909 1461 TP_fast_assign( 910 TP_fast_assign( 1462 const struct inode *i 911 const struct inode *inode = data->inode; 1463 const struct nfs_inod 912 const struct nfs_inode *nfsi = NFS_I(inode); 1464 const struct nfs_fh * << 1465 << 1466 913 1467 __entry->offset = dat 914 __entry->offset = data->args.offset; 1468 __entry->count = data 915 __entry->count = data->args.count; 1469 __entry->dev = inode- 916 __entry->dev = inode->i_sb->s_dev; 1470 __entry->fileid = nfs 917 __entry->fileid = nfsi->fileid; 1471 __entry->fhandle = nf !! 918 __entry->fhandle = nfs_fhandle_hash(&nfsi->fh); 1472 ), 919 ), 1473 920 1474 TP_printk( 921 TP_printk( 1475 "fileid=%02x:%02x:%ll 922 "fileid=%02x:%02x:%llu fhandle=0x%08x " 1476 "offset=%lld count=%u !! 923 "offset=%lld count=%lu", 1477 MAJOR(__entry->dev), 924 MAJOR(__entry->dev), MINOR(__entry->dev), 1478 (unsigned long long)_ 925 (unsigned long long)__entry->fileid, 1479 __entry->fhandle, 926 __entry->fhandle, 1480 (long long)__entry->o !! 927 __entry->offset, __entry->count 1481 ) 928 ) 1482 ); 929 ); 1483 930 1484 TRACE_EVENT(nfs_commit_done, 931 TRACE_EVENT(nfs_commit_done, 1485 TP_PROTO( 932 TP_PROTO( 1486 const struct rpc_task << 1487 const struct nfs_comm 933 const struct nfs_commit_data *data 1488 ), 934 ), 1489 935 1490 TP_ARGS(task, data), !! 936 TP_ARGS(data), 1491 937 1492 TP_STRUCT__entry( 938 TP_STRUCT__entry( >> 939 __field(int, status) >> 940 __field(loff_t, offset) >> 941 __field(unsigned long long, verifier) 1493 __field(dev_t, dev) 942 __field(dev_t, dev) 1494 __field(u32, fhandle) 943 __field(u32, fhandle) 1495 __field(u64, fileid) 944 __field(u64, fileid) 1496 __field(loff_t, offse << 1497 __field(int, error) << 1498 __field(unsigned long << 1499 __array(char, verifie << 1500 ), 945 ), 1501 946 1502 TP_fast_assign( 947 TP_fast_assign( 1503 const struct inode *i 948 const struct inode *inode = data->inode; 1504 const struct nfs_inod 949 const struct nfs_inode *nfsi = NFS_I(inode); 1505 const struct nfs_fh * << 1506 << 1507 const struct nfs_writ << 1508 950 1509 __entry->error = task !! 951 __entry->status = data->res.op_status; 1510 __entry->offset = dat 952 __entry->offset = data->args.offset; 1511 __entry->stable = ver !! 953 memcpy(&__entry->verifier, &data->verf.verifier, 1512 memcpy(__entry->verif !! 954 sizeof(__entry->verifier)); 1513 &verf->verifi << 1514 NFS4_VERIFIER << 1515 __entry->dev = inode- 955 __entry->dev = inode->i_sb->s_dev; 1516 __entry->fileid = nfs 956 __entry->fileid = nfsi->fileid; 1517 __entry->fhandle = nf !! 957 __entry->fhandle = nfs_fhandle_hash(&nfsi->fh); 1518 ), 958 ), 1519 959 1520 TP_printk( 960 TP_printk( 1521 "error=%d fileid=%02x !! 961 "fileid=%02x:%02x:%llu fhandle=0x%08x " 1522 "offset=%lld stable=% !! 962 "offset=%lld status=%d verifier 0x%016llx", 1523 MAJOR(__entry->dev), 963 MAJOR(__entry->dev), MINOR(__entry->dev), 1524 (unsigned long long)_ 964 (unsigned long long)__entry->fileid, 1525 __entry->fhandle, 965 __entry->fhandle, 1526 (long long)__entry->o !! 966 __entry->offset, __entry->status, 1527 show_nfs_stable_how(_ !! 967 __entry->verifier 1528 show_nfs4_verifier(__ << 1529 ) << 1530 ); << 1531 << 1532 #define nfs_show_direct_req_flags(v) \ << 1533 __print_flags(v, "|", \ << 1534 { NFS_ODIRECT_DO_COMM << 1535 { NFS_ODIRECT_RESCHED << 1536 { NFS_ODIRECT_SHOULD_ << 1537 { NFS_ODIRECT_DONE, " << 1538 << 1539 DECLARE_EVENT_CLASS(nfs_direct_req_class, << 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( << 1690 const struct xdr_stre << 1691 int error << 1692 ), << 1693 << 1694 TP_ARGS(xdr, error), << 1695 << 1696 TP_STRUCT__entry( << 1697 __field(unsigned int, << 1698 __field(unsigned int, << 1699 __field(u32, xid) << 1700 __field(int, version) << 1701 __field(unsigned long << 1702 __string(program, << 1703 xdr->rqst->r << 1704 __string(procedure, << 1705 xdr->rqst->r << 1706 ), << 1707 << 1708 TP_fast_assign( << 1709 const struct rpc_rqst << 1710 const struct rpc_task << 1711 << 1712 __entry->task_id = ta << 1713 __entry->client_id = << 1714 __entry->xid = be32_t << 1715 __entry->version = ta << 1716 __entry->error = erro << 1717 __assign_str(program) << 1718 __assign_str(procedur << 1719 ), << 1720 << 1721 TP_printk(SUNRPC_TRACE_TASK_S << 1722 " xid=0x%08x %sv%d << 1723 __entry->task_id, __e << 1724 __get_str(program), _ << 1725 __get_str(procedure), << 1726 show_nfs_status(__ent << 1727 ) 968 ) 1728 ); 969 ); 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 970 1739 #endif /* _TRACE_NFS_H */ 971 #endif /* _TRACE_NFS_H */ 1740 972 1741 #undef TRACE_INCLUDE_PATH 973 #undef TRACE_INCLUDE_PATH 1742 #define TRACE_INCLUDE_PATH . 974 #define TRACE_INCLUDE_PATH . 1743 #define TRACE_INCLUDE_FILE nfstrace 975 #define TRACE_INCLUDE_FILE nfstrace 1744 /* This part must be outside protection */ 976 /* This part must be outside protection */ 1745 #include <trace/define_trace.h> 977 #include <trace/define_trace.h> 1746 978
Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.