1 /* AFS tracepoints 2 * 3 * Copyright (C) 2016 Red Hat, Inc. All Rights Reserved. 4 * Written by David Howells (dhowells@redhat.com) 5 * 6 * This program is free software; you can redistribute it and/or 7 * modify it under the terms of the GNU General Public Licence 8 * as published by the Free Software Foundation; either version 9 * 2 of the Licence, or (at your option) any later version. 10 */ 11 #undef TRACE_SYSTEM 12 #define TRACE_SYSTEM afs 13 14 #if !defined(_TRACE_AFS_H) || defined(TRACE_HEADER_MULTI_READ) 15 #define _TRACE_AFS_H 16 17 #include <linux/tracepoint.h> 18 19 /* 20 * Define enums for tracing information. 21 */ 22 #ifndef __AFS_DECLARE_TRACE_ENUMS_ONCE_ONLY 23 #define __AFS_DECLARE_TRACE_ENUMS_ONCE_ONLY 24 25 enum afs_call_trace { 26 afs_call_trace_alloc, 27 afs_call_trace_free, 28 afs_call_trace_put, 29 afs_call_trace_wake, 30 afs_call_trace_work, 31 }; 32 33 enum afs_fs_operation { 34 afs_FS_FetchData = 130, /* AFS Fetch file data */ 35 afs_FS_FetchStatus = 132, /* AFS Fetch file status */ 36 afs_FS_StoreData = 133, /* AFS Store file data */ 37 afs_FS_StoreStatus = 135, /* AFS Store file status */ 38 afs_FS_RemoveFile = 136, /* AFS Remove a file */ 39 afs_FS_CreateFile = 137, /* AFS Create a file */ 40 afs_FS_Rename = 138, /* AFS Rename or move a file or directory */ 41 afs_FS_Symlink = 139, /* AFS Create a symbolic link */ 42 afs_FS_Link = 140, /* AFS Create a hard link */ 43 afs_FS_MakeDir = 141, /* AFS Create a directory */ 44 afs_FS_RemoveDir = 142, /* AFS Remove a directory */ 45 afs_FS_GetVolumeInfo = 148, /* AFS Get information about a volume */ 46 afs_FS_GetVolumeStatus = 149, /* AFS Get volume status information */ 47 afs_FS_GetRootVolume = 151, /* AFS Get root volume name */ 48 afs_FS_SetLock = 156, /* AFS Request a file lock */ 49 afs_FS_ExtendLock = 157, /* AFS Extend a file lock */ 50 afs_FS_ReleaseLock = 158, /* AFS Release a file lock */ 51 afs_FS_Lookup = 161, /* AFS lookup file in directory */ 52 afs_FS_InlineBulkStatus = 65536, /* AFS Fetch multiple file statuses with errors */ 53 afs_FS_FetchData64 = 65537, /* AFS Fetch file data */ 54 afs_FS_StoreData64 = 65538, /* AFS Store file data */ 55 afs_FS_GiveUpAllCallBacks = 65539, /* AFS Give up all our callbacks on a server */ 56 afs_FS_GetCapabilities = 65540, /* AFS Get FS server capabilities */ 57 }; 58 59 enum afs_vl_operation { 60 afs_VL_GetEntryByNameU = 527, /* AFS Get Vol Entry By Name operation ID */ 61 afs_VL_GetAddrsU = 533, /* AFS Get FS server addresses */ 62 afs_YFSVL_GetEndpoints = 64002, /* YFS Get FS & Vol server addresses */ 63 afs_VL_GetCapabilities = 65537, /* AFS Get VL server capabilities */ 64 }; 65 66 enum afs_edit_dir_op { 67 afs_edit_dir_create, 68 afs_edit_dir_create_error, 69 afs_edit_dir_create_inval, 70 afs_edit_dir_create_nospc, 71 afs_edit_dir_delete, 72 afs_edit_dir_delete_error, 73 afs_edit_dir_delete_inval, 74 afs_edit_dir_delete_noent, 75 }; 76 77 enum afs_edit_dir_reason { 78 afs_edit_dir_for_create, 79 afs_edit_dir_for_link, 80 afs_edit_dir_for_mkdir, 81 afs_edit_dir_for_rename, 82 afs_edit_dir_for_rmdir, 83 afs_edit_dir_for_symlink, 84 afs_edit_dir_for_unlink, 85 }; 86 87 #endif /* end __AFS_DECLARE_TRACE_ENUMS_ONCE_ONLY */ 88 89 /* 90 * Declare tracing information enums and their string mappings for display. 91 */ 92 #define afs_call_traces \ 93 EM(afs_call_trace_alloc, "ALLOC") \ 94 EM(afs_call_trace_free, "FREE ") \ 95 EM(afs_call_trace_put, "PUT ") \ 96 EM(afs_call_trace_wake, "WAKE ") \ 97 E_(afs_call_trace_work, "WORK ") 98 99 #define afs_fs_operations \ 100 EM(afs_FS_FetchData, "FS.FetchData") \ 101 EM(afs_FS_FetchStatus, "FS.FetchStatus") \ 102 EM(afs_FS_StoreData, "FS.StoreData") \ 103 EM(afs_FS_StoreStatus, "FS.StoreStatus") \ 104 EM(afs_FS_RemoveFile, "FS.RemoveFile") \ 105 EM(afs_FS_CreateFile, "FS.CreateFile") \ 106 EM(afs_FS_Rename, "FS.Rename") \ 107 EM(afs_FS_Symlink, "FS.Symlink") \ 108 EM(afs_FS_Link, "FS.Link") \ 109 EM(afs_FS_MakeDir, "FS.MakeDir") \ 110 EM(afs_FS_RemoveDir, "FS.RemoveDir") \ 111 EM(afs_FS_GetVolumeInfo, "FS.GetVolumeInfo") \ 112 EM(afs_FS_GetVolumeStatus, "FS.GetVolumeStatus") \ 113 EM(afs_FS_GetRootVolume, "FS.GetRootVolume") \ 114 EM(afs_FS_SetLock, "FS.SetLock") \ 115 EM(afs_FS_ExtendLock, "FS.ExtendLock") \ 116 EM(afs_FS_ReleaseLock, "FS.ReleaseLock") \ 117 EM(afs_FS_Lookup, "FS.Lookup") \ 118 EM(afs_FS_InlineBulkStatus, "FS.InlineBulkStatus") \ 119 EM(afs_FS_FetchData64, "FS.FetchData64") \ 120 EM(afs_FS_StoreData64, "FS.StoreData64") \ 121 EM(afs_FS_GiveUpAllCallBacks, "FS.GiveUpAllCallBacks") \ 122 E_(afs_FS_GetCapabilities, "FS.GetCapabilities") 123 124 #define afs_vl_operations \ 125 EM(afs_VL_GetEntryByNameU, "VL.GetEntryByNameU") \ 126 EM(afs_VL_GetAddrsU, "VL.GetAddrsU") \ 127 EM(afs_YFSVL_GetEndpoints, "YFSVL.GetEndpoints") \ 128 E_(afs_VL_GetCapabilities, "VL.GetCapabilities") 129 130 #define afs_edit_dir_ops \ 131 EM(afs_edit_dir_create, "create") \ 132 EM(afs_edit_dir_create_error, "c_fail") \ 133 EM(afs_edit_dir_create_inval, "c_invl") \ 134 EM(afs_edit_dir_create_nospc, "c_nspc") \ 135 EM(afs_edit_dir_delete, "delete") \ 136 EM(afs_edit_dir_delete_error, "d_err ") \ 137 EM(afs_edit_dir_delete_inval, "d_invl") \ 138 E_(afs_edit_dir_delete_noent, "d_nent") 139 140 #define afs_edit_dir_reasons \ 141 EM(afs_edit_dir_for_create, "Create") \ 142 EM(afs_edit_dir_for_link, "Link ") \ 143 EM(afs_edit_dir_for_mkdir, "MkDir ") \ 144 EM(afs_edit_dir_for_rename, "Rename") \ 145 EM(afs_edit_dir_for_rmdir, "RmDir ") \ 146 EM(afs_edit_dir_for_symlink, "Symlnk") \ 147 E_(afs_edit_dir_for_unlink, "Unlink") 148 149 150 /* 151 * Export enum symbols via userspace. 152 */ 153 #undef EM 154 #undef E_ 155 #define EM(a, b) TRACE_DEFINE_ENUM(a); 156 #define E_(a, b) TRACE_DEFINE_ENUM(a); 157 158 afs_call_traces; 159 afs_fs_operations; 160 afs_vl_operations; 161 afs_edit_dir_ops; 162 afs_edit_dir_reasons; 163 164 /* 165 * Now redefine the EM() and E_() macros to map the enums to the strings that 166 * will be printed in the output. 167 */ 168 #undef EM 169 #undef E_ 170 #define EM(a, b) { a, b }, 171 #define E_(a, b) { a, b } 172 173 TRACE_EVENT(afs_recv_data, 174 TP_PROTO(struct afs_call *call, unsigned count, unsigned offset, 175 bool want_more, int ret), 176 177 TP_ARGS(call, count, offset, want_more, ret), 178 179 TP_STRUCT__entry( 180 __field(unsigned int, call ) 181 __field(enum afs_call_state, state ) 182 __field(unsigned int, count ) 183 __field(unsigned int, offset ) 184 __field(unsigned short, unmarshall ) 185 __field(bool, want_more ) 186 __field(int, ret ) 187 ), 188 189 TP_fast_assign( 190 __entry->call = call->debug_id; 191 __entry->state = call->state; 192 __entry->unmarshall = call->unmarshall; 193 __entry->count = count; 194 __entry->offset = offset; 195 __entry->want_more = want_more; 196 __entry->ret = ret; 197 ), 198 199 TP_printk("c=%08x s=%u u=%u %u/%u wm=%u ret=%d", 200 __entry->call, 201 __entry->state, __entry->unmarshall, 202 __entry->offset, __entry->count, 203 __entry->want_more, __entry->ret) 204 ); 205 206 TRACE_EVENT(afs_notify_call, 207 TP_PROTO(struct rxrpc_call *rxcall, struct afs_call *call), 208 209 TP_ARGS(rxcall, call), 210 211 TP_STRUCT__entry( 212 __field(unsigned int, call ) 213 __field(enum afs_call_state, state ) 214 __field(unsigned short, unmarshall ) 215 ), 216 217 TP_fast_assign( 218 __entry->call = call->debug_id; 219 __entry->state = call->state; 220 __entry->unmarshall = call->unmarshall; 221 ), 222 223 TP_printk("c=%08x s=%u u=%u", 224 __entry->call, 225 __entry->state, __entry->unmarshall) 226 ); 227 228 TRACE_EVENT(afs_cb_call, 229 TP_PROTO(struct afs_call *call), 230 231 TP_ARGS(call), 232 233 TP_STRUCT__entry( 234 __field(unsigned int, call ) 235 __field(const char *, name ) 236 __field(u32, op ) 237 ), 238 239 TP_fast_assign( 240 __entry->call = call->debug_id; 241 __entry->name = call->type->name; 242 __entry->op = call->operation_ID; 243 ), 244 245 TP_printk("c=%08x %s o=%u", 246 __entry->call, 247 __entry->name, 248 __entry->op) 249 ); 250 251 TRACE_EVENT(afs_call, 252 TP_PROTO(struct afs_call *call, enum afs_call_trace op, 253 int usage, int outstanding, const void *where), 254 255 TP_ARGS(call, op, usage, outstanding, where), 256 257 TP_STRUCT__entry( 258 __field(unsigned int, call ) 259 __field(int, op ) 260 __field(int, usage ) 261 __field(int, outstanding ) 262 __field(const void *, where ) 263 ), 264 265 TP_fast_assign( 266 __entry->call = call->debug_id; 267 __entry->op = op; 268 __entry->usage = usage; 269 __entry->outstanding = outstanding; 270 __entry->where = where; 271 ), 272 273 TP_printk("c=%08x %s u=%d o=%d sp=%pSR", 274 __entry->call, 275 __print_symbolic(__entry->op, afs_call_traces), 276 __entry->usage, 277 __entry->outstanding, 278 __entry->where) 279 ); 280 281 TRACE_EVENT(afs_make_fs_call, 282 TP_PROTO(struct afs_call *call, const struct afs_fid *fid), 283 284 TP_ARGS(call, fid), 285 286 TP_STRUCT__entry( 287 __field(unsigned int, call ) 288 __field(enum afs_fs_operation, op ) 289 __field_struct(struct afs_fid, fid ) 290 ), 291 292 TP_fast_assign( 293 __entry->call = call->debug_id; 294 __entry->op = call->operation_ID; 295 if (fid) { 296 __entry->fid = *fid; 297 } else { 298 __entry->fid.vid = 0; 299 __entry->fid.vnode = 0; 300 __entry->fid.unique = 0; 301 } 302 ), 303 304 TP_printk("c=%08x %06x:%06x:%06x %s", 305 __entry->call, 306 __entry->fid.vid, 307 __entry->fid.vnode, 308 __entry->fid.unique, 309 __print_symbolic(__entry->op, afs_fs_operations)) 310 ); 311 312 TRACE_EVENT(afs_make_vl_call, 313 TP_PROTO(struct afs_call *call), 314 315 TP_ARGS(call), 316 317 TP_STRUCT__entry( 318 __field(unsigned int, call ) 319 __field(enum afs_vl_operation, op ) 320 ), 321 322 TP_fast_assign( 323 __entry->call = call->debug_id; 324 __entry->op = call->operation_ID; 325 ), 326 327 TP_printk("c=%08x %s", 328 __entry->call, 329 __print_symbolic(__entry->op, afs_vl_operations)) 330 ); 331 332 TRACE_EVENT(afs_call_done, 333 TP_PROTO(struct afs_call *call), 334 335 TP_ARGS(call), 336 337 TP_STRUCT__entry( 338 __field(unsigned int, call ) 339 __field(struct rxrpc_call *, rx_call ) 340 __field(int, ret ) 341 __field(u32, abort_code ) 342 ), 343 344 TP_fast_assign( 345 __entry->call = call->debug_id; 346 __entry->rx_call = call->rxcall; 347 __entry->ret = call->error; 348 __entry->abort_code = call->abort_code; 349 ), 350 351 TP_printk(" c=%08x ret=%d ab=%d [%p]", 352 __entry->call, 353 __entry->ret, 354 __entry->abort_code, 355 __entry->rx_call) 356 ); 357 358 TRACE_EVENT(afs_send_pages, 359 TP_PROTO(struct afs_call *call, struct msghdr *msg, 360 pgoff_t first, pgoff_t last, unsigned int offset), 361 362 TP_ARGS(call, msg, first, last, offset), 363 364 TP_STRUCT__entry( 365 __field(unsigned int, call ) 366 __field(pgoff_t, first ) 367 __field(pgoff_t, last ) 368 __field(unsigned int, nr ) 369 __field(unsigned int, bytes ) 370 __field(unsigned int, offset ) 371 __field(unsigned int, flags ) 372 ), 373 374 TP_fast_assign( 375 __entry->call = call->debug_id; 376 __entry->first = first; 377 __entry->last = last; 378 __entry->nr = msg->msg_iter.nr_segs; 379 __entry->bytes = msg->msg_iter.count; 380 __entry->offset = offset; 381 __entry->flags = msg->msg_flags; 382 ), 383 384 TP_printk(" c=%08x %lx-%lx-%lx b=%x o=%x f=%x", 385 __entry->call, 386 __entry->first, __entry->first + __entry->nr - 1, __entry->last, 387 __entry->bytes, __entry->offset, 388 __entry->flags) 389 ); 390 391 TRACE_EVENT(afs_sent_pages, 392 TP_PROTO(struct afs_call *call, pgoff_t first, pgoff_t last, 393 pgoff_t cursor, int ret), 394 395 TP_ARGS(call, first, last, cursor, ret), 396 397 TP_STRUCT__entry( 398 __field(unsigned int, call ) 399 __field(pgoff_t, first ) 400 __field(pgoff_t, last ) 401 __field(pgoff_t, cursor ) 402 __field(int, ret ) 403 ), 404 405 TP_fast_assign( 406 __entry->call = call->debug_id; 407 __entry->first = first; 408 __entry->last = last; 409 __entry->cursor = cursor; 410 __entry->ret = ret; 411 ), 412 413 TP_printk(" c=%08x %lx-%lx c=%lx r=%d", 414 __entry->call, 415 __entry->first, __entry->last, 416 __entry->cursor, __entry->ret) 417 ); 418 419 TRACE_EVENT(afs_dir_check_failed, 420 TP_PROTO(struct afs_vnode *vnode, loff_t off, loff_t i_size), 421 422 TP_ARGS(vnode, off, i_size), 423 424 TP_STRUCT__entry( 425 __field(struct afs_vnode *, vnode ) 426 __field(loff_t, off ) 427 __field(loff_t, i_size ) 428 ), 429 430 TP_fast_assign( 431 __entry->vnode = vnode; 432 __entry->off = off; 433 __entry->i_size = i_size; 434 ), 435 436 TP_printk("vn=%p %llx/%llx", 437 __entry->vnode, __entry->off, __entry->i_size) 438 ); 439 440 /* 441 * We use page->private to hold the amount of the page that we've written to, 442 * splitting the field into two parts. However, we need to represent a range 443 * 0...PAGE_SIZE inclusive, so we can't support 64K pages on a 32-bit system. 444 */ 445 #if PAGE_SIZE > 32768 446 #define AFS_PRIV_MAX 0xffffffff 447 #define AFS_PRIV_SHIFT 32 448 #else 449 #define AFS_PRIV_MAX 0xffff 450 #define AFS_PRIV_SHIFT 16 451 #endif 452 453 TRACE_EVENT(afs_page_dirty, 454 TP_PROTO(struct afs_vnode *vnode, const char *where, 455 pgoff_t page, unsigned long priv), 456 457 TP_ARGS(vnode, where, page, priv), 458 459 TP_STRUCT__entry( 460 __field(struct afs_vnode *, vnode ) 461 __field(const char *, where ) 462 __field(pgoff_t, page ) 463 __field(unsigned long, priv ) 464 ), 465 466 TP_fast_assign( 467 __entry->vnode = vnode; 468 __entry->where = where; 469 __entry->page = page; 470 __entry->priv = priv; 471 ), 472 473 TP_printk("vn=%p %lx %s %lu-%lu", 474 __entry->vnode, __entry->page, __entry->where, 475 __entry->priv & AFS_PRIV_MAX, 476 __entry->priv >> AFS_PRIV_SHIFT) 477 ); 478 479 TRACE_EVENT(afs_call_state, 480 TP_PROTO(struct afs_call *call, 481 enum afs_call_state from, 482 enum afs_call_state to, 483 int ret, u32 remote_abort), 484 485 TP_ARGS(call, from, to, ret, remote_abort), 486 487 TP_STRUCT__entry( 488 __field(unsigned int, call ) 489 __field(enum afs_call_state, from ) 490 __field(enum afs_call_state, to ) 491 __field(int, ret ) 492 __field(u32, abort ) 493 ), 494 495 TP_fast_assign( 496 __entry->call = call->debug_id; 497 __entry->from = from; 498 __entry->to = to; 499 __entry->ret = ret; 500 __entry->abort = remote_abort; 501 ), 502 503 TP_printk("c=%08x %u->%u r=%d ab=%d", 504 __entry->call, 505 __entry->from, __entry->to, 506 __entry->ret, __entry->abort) 507 ); 508 509 TRACE_EVENT(afs_edit_dir, 510 TP_PROTO(struct afs_vnode *dvnode, 511 enum afs_edit_dir_reason why, 512 enum afs_edit_dir_op op, 513 unsigned int block, 514 unsigned int slot, 515 unsigned int f_vnode, 516 unsigned int f_unique, 517 const char *name), 518 519 TP_ARGS(dvnode, why, op, block, slot, f_vnode, f_unique, name), 520 521 TP_STRUCT__entry( 522 __field(unsigned int, vnode ) 523 __field(unsigned int, unique ) 524 __field(enum afs_edit_dir_reason, why ) 525 __field(enum afs_edit_dir_op, op ) 526 __field(unsigned int, block ) 527 __field(unsigned short, slot ) 528 __field(unsigned int, f_vnode ) 529 __field(unsigned int, f_unique ) 530 __array(char, name, 18 ) 531 ), 532 533 TP_fast_assign( 534 int __len = strlen(name); 535 __len = min(__len, 17); 536 __entry->vnode = dvnode->fid.vnode; 537 __entry->unique = dvnode->fid.unique; 538 __entry->why = why; 539 __entry->op = op; 540 __entry->block = block; 541 __entry->slot = slot; 542 __entry->f_vnode = f_vnode; 543 __entry->f_unique = f_unique; 544 memcpy(__entry->name, name, __len); 545 __entry->name[__len] = 0; 546 ), 547 548 TP_printk("d=%x:%x %s %s %u[%u] f=%x:%x %s", 549 __entry->vnode, __entry->unique, 550 __print_symbolic(__entry->why, afs_edit_dir_reasons), 551 __print_symbolic(__entry->op, afs_edit_dir_ops), 552 __entry->block, __entry->slot, 553 __entry->f_vnode, __entry->f_unique, 554 __entry->name) 555 ); 556 557 TRACE_EVENT(afs_protocol_error, 558 TP_PROTO(struct afs_call *call, int error, const void *where), 559 560 TP_ARGS(call, error, where), 561 562 TP_STRUCT__entry( 563 __field(unsigned int, call ) 564 __field(int, error ) 565 __field(const void *, where ) 566 ), 567 568 TP_fast_assign( 569 __entry->call = call ? call->debug_id : 0; 570 __entry->error = error; 571 __entry->where = where; 572 ), 573 574 TP_printk("c=%08x r=%d sp=%pSR", 575 __entry->call, __entry->error, __entry->where) 576 ); 577 578 #endif /* _TRACE_AFS_H */ 579 580 /* This part must be outside protection */ 581 #include <trace/define_trace.h> 582