1 /* FS-Cache 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 fscache
13 
14 #if !defined(_TRACE_FSCACHE_H) || defined(TRACE_HEADER_MULTI_READ)
15 #define _TRACE_FSCACHE_H
16 
17 #include <linux/fscache.h>
18 #include <linux/tracepoint.h>
19 
20 /*
21  * Define enums for tracing information.
22  */
23 #ifndef __FSCACHE_DECLARE_TRACE_ENUMS_ONCE_ONLY
24 #define __FSCACHE_DECLARE_TRACE_ENUMS_ONCE_ONLY
25 
26 enum fscache_cookie_trace {
27 	fscache_cookie_collision,
28 	fscache_cookie_discard,
29 	fscache_cookie_get_acquire_parent,
30 	fscache_cookie_get_attach_object,
31 	fscache_cookie_get_reacquire,
32 	fscache_cookie_get_register_netfs,
33 	fscache_cookie_put_acquire_nobufs,
34 	fscache_cookie_put_dup_netfs,
35 	fscache_cookie_put_relinquish,
36 	fscache_cookie_put_object,
37 	fscache_cookie_put_parent,
38 };
39 
40 enum fscache_page_trace {
41 	fscache_page_cached,
42 	fscache_page_inval,
43 	fscache_page_maybe_release,
44 	fscache_page_radix_clear_store,
45 	fscache_page_radix_delete,
46 	fscache_page_radix_insert,
47 	fscache_page_radix_pend2store,
48 	fscache_page_radix_set_pend,
49 	fscache_page_uncache,
50 	fscache_page_write,
51 	fscache_page_write_end,
52 	fscache_page_write_end_pend,
53 	fscache_page_write_end_noc,
54 	fscache_page_write_wait,
55 	fscache_page_trace__nr
56 };
57 
58 enum fscache_op_trace {
59 	fscache_op_cancel,
60 	fscache_op_cancel_all,
61 	fscache_op_cancelled,
62 	fscache_op_completed,
63 	fscache_op_enqueue_async,
64 	fscache_op_enqueue_mythread,
65 	fscache_op_gc,
66 	fscache_op_init,
67 	fscache_op_put,
68 	fscache_op_run,
69 	fscache_op_signal,
70 	fscache_op_submit,
71 	fscache_op_submit_ex,
72 	fscache_op_work,
73 	fscache_op_trace__nr
74 };
75 
76 enum fscache_page_op_trace {
77 	fscache_page_op_alloc_one,
78 	fscache_page_op_attr_changed,
79 	fscache_page_op_check_consistency,
80 	fscache_page_op_invalidate,
81 	fscache_page_op_retr_multi,
82 	fscache_page_op_retr_one,
83 	fscache_page_op_write_one,
84 	fscache_page_op_trace__nr
85 };
86 
87 #endif
88 
89 /*
90  * Declare tracing information enums and their string mappings for display.
91  */
92 #define fscache_cookie_traces						\
93 	EM(fscache_cookie_collision,		"*COLLISION*")		\
94 	EM(fscache_cookie_discard,		"DISCARD")		\
95 	EM(fscache_cookie_get_acquire_parent,	"GET prn")		\
96 	EM(fscache_cookie_get_attach_object,	"GET obj")		\
97 	EM(fscache_cookie_get_reacquire,	"GET raq")		\
98 	EM(fscache_cookie_get_register_netfs,	"GET net")		\
99 	EM(fscache_cookie_put_acquire_nobufs,	"PUT nbf")		\
100 	EM(fscache_cookie_put_dup_netfs,	"PUT dnt")		\
101 	EM(fscache_cookie_put_relinquish,	"PUT rlq")		\
102 	EM(fscache_cookie_put_object,		"PUT obj")		\
103 	E_(fscache_cookie_put_parent,		"PUT prn")
104 
105 #define fscache_page_traces						\
106 	EM(fscache_page_cached,			"Cached ")		\
107 	EM(fscache_page_inval,			"InvalPg")		\
108 	EM(fscache_page_maybe_release,		"MayRels")		\
109 	EM(fscache_page_uncache,		"Uncache")		\
110 	EM(fscache_page_radix_clear_store,	"RxCStr ")		\
111 	EM(fscache_page_radix_delete,		"RxDel  ")		\
112 	EM(fscache_page_radix_insert,		"RxIns  ")		\
113 	EM(fscache_page_radix_pend2store,	"RxP2S  ")		\
114 	EM(fscache_page_radix_set_pend,		"RxSPend ")		\
115 	EM(fscache_page_write,			"WritePg")		\
116 	EM(fscache_page_write_end,		"EndPgWr")		\
117 	EM(fscache_page_write_end_pend,		"EndPgWP")		\
118 	EM(fscache_page_write_end_noc,		"EndPgNC")		\
119 	E_(fscache_page_write_wait,		"WtOnWrt")
120 
121 #define fscache_op_traces						\
122 	EM(fscache_op_cancel,			"Cancel1")		\
123 	EM(fscache_op_cancel_all,		"CancelA")		\
124 	EM(fscache_op_cancelled,		"Canclld")		\
125 	EM(fscache_op_completed,		"Complet")		\
126 	EM(fscache_op_enqueue_async,		"EnqAsyn")		\
127 	EM(fscache_op_enqueue_mythread,		"EnqMyTh")		\
128 	EM(fscache_op_gc,			"GC     ")		\
129 	EM(fscache_op_init,			"Init   ")		\
130 	EM(fscache_op_put,			"Put    ")		\
131 	EM(fscache_op_run,			"Run    ")		\
132 	EM(fscache_op_signal,			"Signal ")		\
133 	EM(fscache_op_submit,			"Submit ")		\
134 	EM(fscache_op_submit_ex,		"SubmitX")		\
135 	E_(fscache_op_work,			"Work   ")
136 
137 #define fscache_page_op_traces						\
138 	EM(fscache_page_op_alloc_one,		"Alloc1 ")		\
139 	EM(fscache_page_op_attr_changed,	"AttrChg")		\
140 	EM(fscache_page_op_check_consistency,	"CheckCn")		\
141 	EM(fscache_page_op_invalidate,		"Inval  ")		\
142 	EM(fscache_page_op_retr_multi,		"RetrMul")		\
143 	EM(fscache_page_op_retr_one,		"Retr1  ")		\
144 	E_(fscache_page_op_write_one,		"Write1 ")
145 
146 /*
147  * Export enum symbols via userspace.
148  */
149 #undef EM
150 #undef E_
151 #define EM(a, b) TRACE_DEFINE_ENUM(a);
152 #define E_(a, b) TRACE_DEFINE_ENUM(a);
153 
154 fscache_cookie_traces;
155 
156 /*
157  * Now redefine the EM() and E_() macros to map the enums to the strings that
158  * will be printed in the output.
159  */
160 #undef EM
161 #undef E_
162 #define EM(a, b)	{ a, b },
163 #define E_(a, b)	{ a, b }
164 
165 
166 TRACE_EVENT(fscache_cookie,
167 	    TP_PROTO(struct fscache_cookie *cookie,
168 		     enum fscache_cookie_trace where,
169 		     int usage),
170 
171 	    TP_ARGS(cookie, where, usage),
172 
173 	    TP_STRUCT__entry(
174 		    __field(struct fscache_cookie *,	cookie		)
175 		    __field(struct fscache_cookie *,	parent		)
176 		    __field(enum fscache_cookie_trace,	where		)
177 		    __field(int,			usage		)
178 		    __field(int,			n_children	)
179 		    __field(int,			n_active	)
180 		    __field(u8,				flags		)
181 			     ),
182 
183 	    TP_fast_assign(
184 		    __entry->cookie	= cookie;
185 		    __entry->parent	= cookie->parent;
186 		    __entry->where	= where;
187 		    __entry->usage	= usage;
188 		    __entry->n_children	= atomic_read(&cookie->n_children);
189 		    __entry->n_active	= atomic_read(&cookie->n_active);
190 		    __entry->flags	= cookie->flags;
191 			   ),
192 
193 	    TP_printk("%s c=%p u=%d p=%p Nc=%d Na=%d f=%02x",
194 		      __print_symbolic(__entry->where, fscache_cookie_traces),
195 		      __entry->cookie, __entry->usage,
196 		      __entry->parent, __entry->n_children, __entry->n_active,
197 		      __entry->flags)
198 	    );
199 
200 TRACE_EVENT(fscache_netfs,
201 	    TP_PROTO(struct fscache_netfs *netfs),
202 
203 	    TP_ARGS(netfs),
204 
205 	    TP_STRUCT__entry(
206 		    __field(struct fscache_cookie *,	cookie		)
207 		    __array(char,			name, 8		)
208 			     ),
209 
210 	    TP_fast_assign(
211 		    __entry->cookie		= netfs->primary_index;
212 		    strncpy(__entry->name, netfs->name, 8);
213 		    __entry->name[7]		= 0;
214 			   ),
215 
216 	    TP_printk("c=%p n=%s",
217 		      __entry->cookie, __entry->name)
218 	    );
219 
220 TRACE_EVENT(fscache_acquire,
221 	    TP_PROTO(struct fscache_cookie *cookie),
222 
223 	    TP_ARGS(cookie),
224 
225 	    TP_STRUCT__entry(
226 		    __field(struct fscache_cookie *,	cookie		)
227 		    __field(struct fscache_cookie *,	parent		)
228 		    __array(char,			name, 8		)
229 		    __field(int,			p_usage		)
230 		    __field(int,			p_n_children	)
231 		    __field(u8,				p_flags		)
232 			     ),
233 
234 	    TP_fast_assign(
235 		    __entry->cookie		= cookie;
236 		    __entry->parent		= cookie->parent;
237 		    __entry->p_usage		= atomic_read(&cookie->parent->usage);
238 		    __entry->p_n_children	= atomic_read(&cookie->parent->n_children);
239 		    __entry->p_flags		= cookie->parent->flags;
240 		    memcpy(__entry->name, cookie->def->name, 8);
241 		    __entry->name[7]		= 0;
242 			   ),
243 
244 	    TP_printk("c=%p p=%p pu=%d pc=%d pf=%02x n=%s",
245 		      __entry->cookie, __entry->parent, __entry->p_usage,
246 		      __entry->p_n_children, __entry->p_flags, __entry->name)
247 	    );
248 
249 TRACE_EVENT(fscache_relinquish,
250 	    TP_PROTO(struct fscache_cookie *cookie, bool retire),
251 
252 	    TP_ARGS(cookie, retire),
253 
254 	    TP_STRUCT__entry(
255 		    __field(struct fscache_cookie *,	cookie		)
256 		    __field(struct fscache_cookie *,	parent		)
257 		    __field(int,			usage		)
258 		    __field(int,			n_children	)
259 		    __field(int,			n_active	)
260 		    __field(u8,				flags		)
261 		    __field(bool,			retire		)
262 			     ),
263 
264 	    TP_fast_assign(
265 		    __entry->cookie	= cookie;
266 		    __entry->parent	= cookie->parent;
267 		    __entry->usage	= atomic_read(&cookie->usage);
268 		    __entry->n_children	= atomic_read(&cookie->n_children);
269 		    __entry->n_active	= atomic_read(&cookie->n_active);
270 		    __entry->flags	= cookie->flags;
271 		    __entry->retire	= retire;
272 			   ),
273 
274 	    TP_printk("c=%p u=%d p=%p Nc=%d Na=%d f=%02x r=%u",
275 		      __entry->cookie, __entry->usage,
276 		      __entry->parent, __entry->n_children, __entry->n_active,
277 		      __entry->flags, __entry->retire)
278 	    );
279 
280 TRACE_EVENT(fscache_enable,
281 	    TP_PROTO(struct fscache_cookie *cookie),
282 
283 	    TP_ARGS(cookie),
284 
285 	    TP_STRUCT__entry(
286 		    __field(struct fscache_cookie *,	cookie		)
287 		    __field(int,			usage		)
288 		    __field(int,			n_children	)
289 		    __field(int,			n_active	)
290 		    __field(u8,				flags		)
291 			     ),
292 
293 	    TP_fast_assign(
294 		    __entry->cookie	= cookie;
295 		    __entry->usage	= atomic_read(&cookie->usage);
296 		    __entry->n_children	= atomic_read(&cookie->n_children);
297 		    __entry->n_active	= atomic_read(&cookie->n_active);
298 		    __entry->flags	= cookie->flags;
299 			   ),
300 
301 	    TP_printk("c=%p u=%d Nc=%d Na=%d f=%02x",
302 		      __entry->cookie, __entry->usage,
303 		      __entry->n_children, __entry->n_active, __entry->flags)
304 	    );
305 
306 TRACE_EVENT(fscache_disable,
307 	    TP_PROTO(struct fscache_cookie *cookie),
308 
309 	    TP_ARGS(cookie),
310 
311 	    TP_STRUCT__entry(
312 		    __field(struct fscache_cookie *,	cookie		)
313 		    __field(int,			usage		)
314 		    __field(int,			n_children	)
315 		    __field(int,			n_active	)
316 		    __field(u8,				flags		)
317 			     ),
318 
319 	    TP_fast_assign(
320 		    __entry->cookie	= cookie;
321 		    __entry->usage	= atomic_read(&cookie->usage);
322 		    __entry->n_children	= atomic_read(&cookie->n_children);
323 		    __entry->n_active	= atomic_read(&cookie->n_active);
324 		    __entry->flags	= cookie->flags;
325 			   ),
326 
327 	    TP_printk("c=%p u=%d Nc=%d Na=%d f=%02x",
328 		      __entry->cookie, __entry->usage,
329 		      __entry->n_children, __entry->n_active, __entry->flags)
330 	    );
331 
332 TRACE_EVENT(fscache_osm,
333 	    TP_PROTO(struct fscache_object *object,
334 		     const struct fscache_state *state,
335 		     bool wait, bool oob, s8 event_num),
336 
337 	    TP_ARGS(object, state, wait, oob, event_num),
338 
339 	    TP_STRUCT__entry(
340 		    __field(struct fscache_cookie *,	cookie		)
341 		    __field(struct fscache_object *,	object		)
342 		    __array(char,			state, 8	)
343 		    __field(bool,			wait		)
344 		    __field(bool,			oob		)
345 		    __field(s8,				event_num	)
346 			     ),
347 
348 	    TP_fast_assign(
349 		    __entry->cookie		= object->cookie;
350 		    __entry->object		= object;
351 		    __entry->wait		= wait;
352 		    __entry->oob		= oob;
353 		    __entry->event_num		= event_num;
354 		    memcpy(__entry->state, state->short_name, 8);
355 			   ),
356 
357 	    TP_printk("c=%p o=%p %s %s%sev=%d",
358 		      __entry->cookie,
359 		      __entry->object,
360 		      __entry->state,
361 		      __print_symbolic(__entry->wait,
362 				       { true,  "WAIT" },
363 				       { false, "WORK" }),
364 		      __print_symbolic(__entry->oob,
365 				       { true,  " OOB " },
366 				       { false, " " }),
367 		      __entry->event_num)
368 	    );
369 
370 TRACE_EVENT(fscache_page,
371 	    TP_PROTO(struct fscache_cookie *cookie, struct page *page,
372 		     enum fscache_page_trace why),
373 
374 	    TP_ARGS(cookie, page, why),
375 
376 	    TP_STRUCT__entry(
377 		    __field(struct fscache_cookie *,	cookie		)
378 		    __field(pgoff_t,			page		)
379 		    __field(enum fscache_page_trace,	why		)
380 			     ),
381 
382 	    TP_fast_assign(
383 		    __entry->cookie		= cookie;
384 		    __entry->page		= page->index;
385 		    __entry->why		= why;
386 			   ),
387 
388 	    TP_printk("c=%p %s pg=%lx",
389 		      __entry->cookie,
390 		      __print_symbolic(__entry->why, fscache_page_traces),
391 		      __entry->page)
392 	    );
393 
394 TRACE_EVENT(fscache_check_page,
395 	    TP_PROTO(struct fscache_cookie *cookie, struct page *page,
396 		     void *val, int n),
397 
398 	    TP_ARGS(cookie, page, val, n),
399 
400 	    TP_STRUCT__entry(
401 		    __field(struct fscache_cookie *,	cookie		)
402 		    __field(void *,			page		)
403 		    __field(void *,			val		)
404 		    __field(int,			n		)
405 			     ),
406 
407 	    TP_fast_assign(
408 		    __entry->cookie		= cookie;
409 		    __entry->page		= page;
410 		    __entry->val		= val;
411 		    __entry->n			= n;
412 			   ),
413 
414 	    TP_printk("c=%p pg=%p val=%p n=%d",
415 		      __entry->cookie, __entry->page, __entry->val, __entry->n)
416 	    );
417 
418 TRACE_EVENT(fscache_wake_cookie,
419 	    TP_PROTO(struct fscache_cookie *cookie),
420 
421 	    TP_ARGS(cookie),
422 
423 	    TP_STRUCT__entry(
424 		    __field(struct fscache_cookie *,	cookie		)
425 			     ),
426 
427 	    TP_fast_assign(
428 		    __entry->cookie		= cookie;
429 			   ),
430 
431 	    TP_printk("c=%p", __entry->cookie)
432 	    );
433 
434 TRACE_EVENT(fscache_op,
435 	    TP_PROTO(struct fscache_cookie *cookie, struct fscache_operation *op,
436 		     enum fscache_op_trace why),
437 
438 	    TP_ARGS(cookie, op, why),
439 
440 	    TP_STRUCT__entry(
441 		    __field(struct fscache_cookie *,	cookie		)
442 		    __field(struct fscache_operation *,	op		)
443 		    __field(enum fscache_op_trace,	why		)
444 			     ),
445 
446 	    TP_fast_assign(
447 		    __entry->cookie		= cookie;
448 		    __entry->op			= op;
449 		    __entry->why		= why;
450 			   ),
451 
452 	    TP_printk("c=%p op=%p %s",
453 		      __entry->cookie, __entry->op,
454 		      __print_symbolic(__entry->why, fscache_op_traces))
455 	    );
456 
457 TRACE_EVENT(fscache_page_op,
458 	    TP_PROTO(struct fscache_cookie *cookie, struct page *page,
459 		     struct fscache_operation *op, enum fscache_page_op_trace what),
460 
461 	    TP_ARGS(cookie, page, op, what),
462 
463 	    TP_STRUCT__entry(
464 		    __field(struct fscache_cookie *,	cookie		)
465 		    __field(pgoff_t,			page		)
466 		    __field(struct fscache_operation *,	op		)
467 		    __field(enum fscache_page_op_trace,	what		)
468 			     ),
469 
470 	    TP_fast_assign(
471 		    __entry->cookie		= cookie;
472 		    __entry->page		= page ? page->index : 0;
473 		    __entry->op			= op;
474 		    __entry->what		= what;
475 			   ),
476 
477 	    TP_printk("c=%p %s pg=%lx op=%p",
478 		      __entry->cookie,
479 		      __print_symbolic(__entry->what, fscache_page_op_traces),
480 		      __entry->page, __entry->op)
481 	    );
482 
483 TRACE_EVENT(fscache_wrote_page,
484 	    TP_PROTO(struct fscache_cookie *cookie, struct page *page,
485 		     struct fscache_operation *op, int ret),
486 
487 	    TP_ARGS(cookie, page, op, ret),
488 
489 	    TP_STRUCT__entry(
490 		    __field(struct fscache_cookie *,	cookie		)
491 		    __field(pgoff_t,			page		)
492 		    __field(struct fscache_operation *,	op		)
493 		    __field(int,			ret		)
494 			     ),
495 
496 	    TP_fast_assign(
497 		    __entry->cookie		= cookie;
498 		    __entry->page		= page->index;
499 		    __entry->op			= op;
500 		    __entry->ret		= ret;
501 			   ),
502 
503 	    TP_printk("c=%p pg=%lx op=%p ret=%d",
504 		      __entry->cookie, __entry->page, __entry->op, __entry->ret)
505 	    );
506 
507 TRACE_EVENT(fscache_gang_lookup,
508 	    TP_PROTO(struct fscache_cookie *cookie, struct fscache_operation *op,
509 		     void **results, int n, pgoff_t store_limit),
510 
511 	    TP_ARGS(cookie, op, results, n, store_limit),
512 
513 	    TP_STRUCT__entry(
514 		    __field(struct fscache_cookie *,	cookie		)
515 		    __field(struct fscache_operation *,	op		)
516 		    __field(pgoff_t,			results0	)
517 		    __field(int,			n		)
518 		    __field(pgoff_t,			store_limit	)
519 			     ),
520 
521 	    TP_fast_assign(
522 		    __entry->cookie		= cookie;
523 		    __entry->op			= op;
524 		    __entry->results0		= results[0] ? ((struct page *)results[0])->index : (pgoff_t)-1;
525 		    __entry->n			= n;
526 		    __entry->store_limit	= store_limit;
527 			   ),
528 
529 	    TP_printk("c=%p op=%p r0=%lx n=%d sl=%lx",
530 		      __entry->cookie, __entry->op, __entry->results0, __entry->n,
531 		      __entry->store_limit)
532 	    );
533 
534 #endif /* _TRACE_FSCACHE_H */
535 
536 /* This part must be outside protection */
537 #include <trace/define_trace.h>
538