?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Linux 4.19.168
[linux/fpc-iii.git] / include / trace / events / afs.h
blob5bc2e30c0d75ca950c90f0a8ca04d02d0f3d52eb
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, "QUEUE")
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 TRACE_EVENT(afs_cm_no_server,
579 TP_PROTO(struct afs_call *call, struct sockaddr_rxrpc *srx),
580
581 TP_ARGS(call, srx),
582
583 TP_STRUCT__entry(
584 __field(unsigned int, call )
585 __field(unsigned int, op_id )
586 __field_struct(struct sockaddr_rxrpc, srx )
587 ),
588
589 TP_fast_assign(
590 __entry->call = call->debug_id;
591 __entry->op_id = call->operation_ID;
592 memcpy(&__entry->srx, srx, sizeof(__entry->srx));
593 ),
594
595 TP_printk("c=%08x op=%u %pISpc",
596 __entry->call, __entry->op_id, &__entry->srx.transport)
597 );
598
599 TRACE_EVENT(afs_cm_no_server_u,
600 TP_PROTO(struct afs_call *call, const uuid_t *uuid),
601
602 TP_ARGS(call, uuid),
603
604 TP_STRUCT__entry(
605 __field(unsigned int, call )
606 __field(unsigned int, op_id )
607 __field_struct(uuid_t, uuid )
608 ),
609
610 TP_fast_assign(
611 __entry->call = call->debug_id;
612 __entry->op_id = call->operation_ID;
613 memcpy(&__entry->uuid, uuid, sizeof(__entry->uuid));
614 ),
615
616 TP_printk("c=%08x op=%u %pU",
617 __entry->call, __entry->op_id, &__entry->uuid)
618 );
619
620 #endif /* _TRACE_AFS_H */
621
622 /* This part must be outside protection */
623 #include <trace/define_trace.h>
Linux with added FPC-III support