]>
Commit | Line | Data |
---|---|---|
8e8d7f13 DH |
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 | ||
341f741f DH |
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 | ||
025db80c DH |
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 | ||
341f741f DH |
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 | ||
025db80c DH |
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 | ||
341f741f DH |
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; | |
025db80c DH |
117 | afs_fs_operations; |
118 | afs_vl_operations; | |
341f741f DH |
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 | ||
8e8d7f13 DH |
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 | ||
341f741f DH |
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 | ||
025db80c DH |
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 | ||
2c099014 DH |
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 | ||
dab17c1a DH |
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 | ||
13524ab3 DH |
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 | ||
98bf40cd DH |
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 | ||
8e8d7f13 DH |
474 | #endif /* _TRACE_AFS_H */ |
475 | ||
476 | /* This part must be outside protection */ | |
477 | #include <trace/define_trace.h> |