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_FetchData64 = 65537, /* AFS Fetch file data */ 53 afs_FS_StoreData64 = 65538, /* AFS Store file data */ 54 afs_FS_GiveUpAllCallBacks = 65539, /* AFS Give up all our callbacks on a server */ 55 afs_FS_GetCapabilities = 65540, /* AFS Get FS server capabilities */ 56 }; 57 58 enum afs_vl_operation { 59 afs_VL_GetEntryByNameU = 527, /* AFS Get Vol Entry By Name operation ID */ 60 afs_VL_GetAddrsU = 533, /* AFS Get FS server addresses */ 61 afs_YFSVL_GetEndpoints = 64002, /* YFS Get FS & Vol server addresses */ 62 afs_VL_GetCapabilities = 65537, /* AFS Get VL server capabilities */ 63 }; 64 65 #endif /* end __AFS_DECLARE_TRACE_ENUMS_ONCE_ONLY */ 66 67 /* 68 * Declare tracing information enums and their string mappings for display. 69 */ 70 #define afs_call_traces \ 71 EM(afs_call_trace_alloc, "ALLOC") \ 72 EM(afs_call_trace_free, "FREE ") \ 73 EM(afs_call_trace_put, "PUT ") \ 74 EM(afs_call_trace_wake, "WAKE ") \ 75 E_(afs_call_trace_work, "WORK ") 76 77 #define afs_fs_operations \ 78 EM(afs_FS_FetchData, "FS.FetchData") \ 79 EM(afs_FS_FetchStatus, "FS.FetchStatus") \ 80 EM(afs_FS_StoreData, "FS.StoreData") \ 81 EM(afs_FS_StoreStatus, "FS.StoreStatus") \ 82 EM(afs_FS_RemoveFile, "FS.RemoveFile") \ 83 EM(afs_FS_CreateFile, "FS.CreateFile") \ 84 EM(afs_FS_Rename, "FS.Rename") \ 85 EM(afs_FS_Symlink, "FS.Symlink") \ 86 EM(afs_FS_Link, "FS.Link") \ 87 EM(afs_FS_MakeDir, "FS.MakeDir") \ 88 EM(afs_FS_RemoveDir, "FS.RemoveDir") \ 89 EM(afs_FS_GetVolumeInfo, "FS.GetVolumeInfo") \ 90 EM(afs_FS_GetVolumeStatus, "FS.GetVolumeStatus") \ 91 EM(afs_FS_GetRootVolume, "FS.GetRootVolume") \ 92 EM(afs_FS_SetLock, "FS.SetLock") \ 93 EM(afs_FS_ExtendLock, "FS.ExtendLock") \ 94 EM(afs_FS_ReleaseLock, "FS.ReleaseLock") \ 95 EM(afs_FS_Lookup, "FS.Lookup") \ 96 EM(afs_FS_FetchData64, "FS.FetchData64") \ 97 EM(afs_FS_StoreData64, "FS.StoreData64") \ 98 EM(afs_FS_GiveUpAllCallBacks, "FS.GiveUpAllCallBacks") \ 99 E_(afs_FS_GetCapabilities, "FS.GetCapabilities") 100 101 #define afs_vl_operations \ 102 EM(afs_VL_GetEntryByNameU, "VL.GetEntryByNameU") \ 103 EM(afs_VL_GetAddrsU, "VL.GetAddrsU") \ 104 EM(afs_YFSVL_GetEndpoints, "YFSVL.GetEndpoints") \ 105 E_(afs_VL_GetCapabilities, "VL.GetCapabilities") 106 107 108 /* 109 * Export enum symbols via userspace. 110 */ 111 #undef EM 112 #undef E_ 113 #define EM(a, b) TRACE_DEFINE_ENUM(a); 114 #define E_(a, b) TRACE_DEFINE_ENUM(a); 115 116 afs_call_traces; 117 afs_fs_operations; 118 afs_vl_operations; 119 120 /* 121 * Now redefine the EM() and E_() macros to map the enums to the strings that 122 * will be printed in the output. 123 */ 124 #undef EM 125 #undef E_ 126 #define EM(a, b) { a, b }, 127 #define E_(a, b) { a, b } 128 129 TRACE_EVENT(afs_recv_data, 130 TP_PROTO(struct afs_call *call, unsigned count, unsigned offset, 131 bool want_more, int ret), 132 133 TP_ARGS(call, count, offset, want_more, ret), 134 135 TP_STRUCT__entry( 136 __field(struct rxrpc_call *, rxcall ) 137 __field(struct afs_call *, call ) 138 __field(enum afs_call_state, state ) 139 __field(unsigned int, count ) 140 __field(unsigned int, offset ) 141 __field(unsigned short, unmarshall ) 142 __field(bool, want_more ) 143 __field(int, ret ) 144 ), 145 146 TP_fast_assign( 147 __entry->rxcall = call->rxcall; 148 __entry->call = call; 149 __entry->state = call->state; 150 __entry->unmarshall = call->unmarshall; 151 __entry->count = count; 152 __entry->offset = offset; 153 __entry->want_more = want_more; 154 __entry->ret = ret; 155 ), 156 157 TP_printk("c=%p ac=%p s=%u u=%u %u/%u wm=%u ret=%d", 158 __entry->rxcall, 159 __entry->call, 160 __entry->state, __entry->unmarshall, 161 __entry->offset, __entry->count, 162 __entry->want_more, __entry->ret) 163 ); 164 165 TRACE_EVENT(afs_notify_call, 166 TP_PROTO(struct rxrpc_call *rxcall, struct afs_call *call), 167 168 TP_ARGS(rxcall, call), 169 170 TP_STRUCT__entry( 171 __field(struct rxrpc_call *, rxcall ) 172 __field(struct afs_call *, call ) 173 __field(enum afs_call_state, state ) 174 __field(unsigned short, unmarshall ) 175 ), 176 177 TP_fast_assign( 178 __entry->rxcall = rxcall; 179 __entry->call = call; 180 __entry->state = call->state; 181 __entry->unmarshall = call->unmarshall; 182 ), 183 184 TP_printk("c=%p ac=%p s=%u u=%u", 185 __entry->rxcall, 186 __entry->call, 187 __entry->state, __entry->unmarshall) 188 ); 189 190 TRACE_EVENT(afs_cb_call, 191 TP_PROTO(struct afs_call *call), 192 193 TP_ARGS(call), 194 195 TP_STRUCT__entry( 196 __field(struct rxrpc_call *, rxcall ) 197 __field(struct afs_call *, call ) 198 __field(const char *, name ) 199 __field(u32, op ) 200 ), 201 202 TP_fast_assign( 203 __entry->rxcall = call->rxcall; 204 __entry->call = call; 205 __entry->name = call->type->name; 206 __entry->op = call->operation_ID; 207 ), 208 209 TP_printk("c=%p ac=%p %s o=%u", 210 __entry->rxcall, 211 __entry->call, 212 __entry->name, 213 __entry->op) 214 ); 215 216 TRACE_EVENT(afs_call, 217 TP_PROTO(struct afs_call *call, enum afs_call_trace op, 218 int usage, int outstanding, const void *where), 219 220 TP_ARGS(call, op, usage, outstanding, where), 221 222 TP_STRUCT__entry( 223 __field(struct afs_call *, call ) 224 __field(int, op ) 225 __field(int, usage ) 226 __field(int, outstanding ) 227 __field(const void *, where ) 228 ), 229 230 TP_fast_assign( 231 __entry->call = call; 232 __entry->op = op; 233 __entry->usage = usage; 234 __entry->outstanding = outstanding; 235 __entry->where = where; 236 ), 237 238 TP_printk("c=%p %s u=%d o=%d sp=%pSR", 239 __entry->call, 240 __print_symbolic(__entry->op, afs_call_traces), 241 __entry->usage, 242 __entry->outstanding, 243 __entry->where) 244 ); 245 246 TRACE_EVENT(afs_make_fs_call, 247 TP_PROTO(struct afs_call *call, const struct afs_fid *fid), 248 249 TP_ARGS(call, fid), 250 251 TP_STRUCT__entry( 252 __field(struct afs_call *, call ) 253 __field(enum afs_fs_operation, op ) 254 __field_struct(struct afs_fid, fid ) 255 ), 256 257 TP_fast_assign( 258 __entry->call = call; 259 __entry->op = call->operation_ID; 260 if (fid) { 261 __entry->fid = *fid; 262 } else { 263 __entry->fid.vid = 0; 264 __entry->fid.vnode = 0; 265 __entry->fid.unique = 0; 266 } 267 ), 268 269 TP_printk("c=%p %06x:%06x:%06x %s", 270 __entry->call, 271 __entry->fid.vid, 272 __entry->fid.vnode, 273 __entry->fid.unique, 274 __print_symbolic(__entry->op, afs_fs_operations)) 275 ); 276 277 TRACE_EVENT(afs_make_vl_call, 278 TP_PROTO(struct afs_call *call), 279 280 TP_ARGS(call), 281 282 TP_STRUCT__entry( 283 __field(struct afs_call *, call ) 284 __field(enum afs_vl_operation, op ) 285 ), 286 287 TP_fast_assign( 288 __entry->call = call; 289 __entry->op = call->operation_ID; 290 ), 291 292 TP_printk("c=%p %s", 293 __entry->call, 294 __print_symbolic(__entry->op, afs_vl_operations)) 295 ); 296 297 TRACE_EVENT(afs_call_done, 298 TP_PROTO(struct afs_call *call), 299 300 TP_ARGS(call), 301 302 TP_STRUCT__entry( 303 __field(struct afs_call *, call ) 304 __field(struct rxrpc_call *, rx_call ) 305 __field(int, ret ) 306 __field(u32, abort_code ) 307 ), 308 309 TP_fast_assign( 310 __entry->call = call; 311 __entry->rx_call = call->rxcall; 312 __entry->ret = call->error; 313 __entry->abort_code = call->abort_code; 314 ), 315 316 TP_printk(" c=%p ret=%d ab=%d [%p]", 317 __entry->call, 318 __entry->ret, 319 __entry->abort_code, 320 __entry->rx_call) 321 ); 322 323 TRACE_EVENT(afs_send_pages, 324 TP_PROTO(struct afs_call *call, struct msghdr *msg, 325 pgoff_t first, pgoff_t last, unsigned int offset), 326 327 TP_ARGS(call, msg, first, last, offset), 328 329 TP_STRUCT__entry( 330 __field(struct afs_call *, call ) 331 __field(pgoff_t, first ) 332 __field(pgoff_t, last ) 333 __field(unsigned int, nr ) 334 __field(unsigned int, bytes ) 335 __field(unsigned int, offset ) 336 __field(unsigned int, flags ) 337 ), 338 339 TP_fast_assign( 340 __entry->call = call; 341 __entry->first = first; 342 __entry->last = last; 343 __entry->nr = msg->msg_iter.nr_segs; 344 __entry->bytes = msg->msg_iter.count; 345 __entry->offset = offset; 346 __entry->flags = msg->msg_flags; 347 ), 348 349 TP_printk(" c=%p %lx-%lx-%lx b=%x o=%x f=%x", 350 __entry->call, 351 __entry->first, __entry->first + __entry->nr - 1, __entry->last, 352 __entry->bytes, __entry->offset, 353 __entry->flags) 354 ); 355 356 TRACE_EVENT(afs_sent_pages, 357 TP_PROTO(struct afs_call *call, pgoff_t first, pgoff_t last, 358 pgoff_t cursor, int ret), 359 360 TP_ARGS(call, first, last, cursor, ret), 361 362 TP_STRUCT__entry( 363 __field(struct afs_call *, call ) 364 __field(pgoff_t, first ) 365 __field(pgoff_t, last ) 366 __field(pgoff_t, cursor ) 367 __field(int, ret ) 368 ), 369 370 TP_fast_assign( 371 __entry->call = call; 372 __entry->first = first; 373 __entry->last = last; 374 __entry->cursor = cursor; 375 __entry->ret = ret; 376 ), 377 378 TP_printk(" c=%p %lx-%lx c=%lx r=%d", 379 __entry->call, 380 __entry->first, __entry->last, 381 __entry->cursor, __entry->ret) 382 ); 383 384 TRACE_EVENT(afs_dir_check_failed, 385 TP_PROTO(struct afs_vnode *vnode, loff_t off, loff_t i_size), 386 387 TP_ARGS(vnode, off, i_size), 388 389 TP_STRUCT__entry( 390 __field(struct afs_vnode *, vnode ) 391 __field(loff_t, off ) 392 __field(loff_t, i_size ) 393 ), 394 395 TP_fast_assign( 396 __entry->vnode = vnode; 397 __entry->off = off; 398 __entry->i_size = i_size; 399 ), 400 401 TP_printk("vn=%p %llx/%llx", 402 __entry->vnode, __entry->off, __entry->i_size) 403 ); 404 405 /* 406 * We use page->private to hold the amount of the page that we've written to, 407 * splitting the field into two parts. However, we need to represent a range 408 * 0...PAGE_SIZE inclusive, so we can't support 64K pages on a 32-bit system. 409 */ 410 #if PAGE_SIZE > 32768 411 #define AFS_PRIV_MAX 0xffffffff 412 #define AFS_PRIV_SHIFT 32 413 #else 414 #define AFS_PRIV_MAX 0xffff 415 #define AFS_PRIV_SHIFT 16 416 #endif 417 418 TRACE_EVENT(afs_page_dirty, 419 TP_PROTO(struct afs_vnode *vnode, const char *where, 420 pgoff_t page, unsigned long priv), 421 422 TP_ARGS(vnode, where, page, priv), 423 424 TP_STRUCT__entry( 425 __field(struct afs_vnode *, vnode ) 426 __field(const char *, where ) 427 __field(pgoff_t, page ) 428 __field(unsigned long, priv ) 429 ), 430 431 TP_fast_assign( 432 __entry->vnode = vnode; 433 __entry->where = where; 434 __entry->page = page; 435 __entry->priv = priv; 436 ), 437 438 TP_printk("vn=%p %lx %s %lu-%lu", 439 __entry->vnode, __entry->page, __entry->where, 440 __entry->priv & AFS_PRIV_MAX, 441 __entry->priv >> AFS_PRIV_SHIFT) 442 ); 443 444 TRACE_EVENT(afs_call_state, 445 TP_PROTO(struct afs_call *call, 446 enum afs_call_state from, 447 enum afs_call_state to, 448 int ret, u32 remote_abort), 449 450 TP_ARGS(call, from, to, ret, remote_abort), 451 452 TP_STRUCT__entry( 453 __field(struct afs_call *, call ) 454 __field(enum afs_call_state, from ) 455 __field(enum afs_call_state, to ) 456 __field(int, ret ) 457 __field(u32, abort ) 458 ), 459 460 TP_fast_assign( 461 __entry->call = call; 462 __entry->from = from; 463 __entry->to = to; 464 __entry->ret = ret; 465 __entry->abort = remote_abort; 466 ), 467 468 TP_printk("c=%p %u->%u r=%d ab=%d", 469 __entry->call, 470 __entry->from, __entry->to, 471 __entry->ret, __entry->abort) 472 ); 473 474 #endif /* _TRACE_AFS_H */ 475 476 /* This part must be outside protection */ 477 #include <trace/define_trace.h> 478