projects / lttng-modules.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Fix: make writeback instrumentation build for 4.3 kernel
[lttng-modules.git] / instrumentation / events / lttng-module / writeback.h
1 #undef TRACE_SYSTEM
2 #define TRACE_SYSTEM writeback
3
4 #if !defined(LTTNG_TRACE_WRITEBACK_H) || defined(TRACE_HEADER_MULTI_READ)
5 #define LTTNG_TRACE_WRITEBACK_H
6
7 #include "../../../probes/lttng-tracepoint-event.h"
8 #include <linux/tracepoint.h>
9 #include <linux/backing-dev.h>
10 #include <linux/writeback.h>
11 #include <linux/version.h>
12
13 #ifndef _TRACE_WRITEBACK_DEF_
14 #define _TRACE_WRITEBACK_DEF_
15
16 #if (LINUX_VERSION_CODE < KERNEL_VERSION(4,0,0))
17 static inline struct backing_dev_info *inode_to_bdi(struct inode *inode)
18 {
19 struct super_block *sb = inode->i_sb;
20
21 if (strcmp(sb->s_type->name, "bdev") == 0)
22 return inode->i_mapping->backing_dev_info;
23
24 return sb->s_bdi;
25 }
26 #endif /* #if (LINUX_VERSION_CODE < KERNEL_VERSION(4,0,0)) */
27
28 #endif
29
30 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(4,0,0))
31 #define show_inode_state(state) \
32 __print_flags(state, "|", \
33 {I_DIRTY_SYNC, "I_DIRTY_SYNC"}, \
34 {I_DIRTY_DATASYNC, "I_DIRTY_DATASYNC"}, \
35 {I_DIRTY_PAGES, "I_DIRTY_PAGES"}, \
36 {I_NEW, "I_NEW"}, \
37 {I_WILL_FREE, "I_WILL_FREE"}, \
38 {I_FREEING, "I_FREEING"}, \
39 {I_CLEAR, "I_CLEAR"}, \
40 {I_SYNC, "I_SYNC"}, \
41 {I_DIRTY_TIME, "I_DIRTY_TIME"}, \
42 {I_DIRTY_TIME_EXPIRED, "I_DIRTY_TIME_EXPIRED"}, \
43 {I_REFERENCED, "I_REFERENCED"} \
44 )
45 #else /* #if (LINUX_VERSION_CODE >= KERNEL_VERSION(4,0,0)) */
46 #define show_inode_state(state) \
47 __print_flags(state, "|", \
48 {I_DIRTY_SYNC, "I_DIRTY_SYNC"}, \
49 {I_DIRTY_DATASYNC, "I_DIRTY_DATASYNC"}, \
50 {I_DIRTY_PAGES, "I_DIRTY_PAGES"}, \
51 {I_NEW, "I_NEW"}, \
52 {I_WILL_FREE, "I_WILL_FREE"}, \
53 {I_FREEING, "I_FREEING"}, \
54 {I_CLEAR, "I_CLEAR"}, \
55 {I_SYNC, "I_SYNC"}, \
56 {I_REFERENCED, "I_REFERENCED"} \
57 )
58 #endif /* #else #if (LINUX_VERSION_CODE >= KERNEL_VERSION(4,0,0)) */
59
60 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(4,0,0))
61
62 LTTNG_TRACEPOINT_EVENT(writeback_dirty_page,
63 TP_PROTO(struct page *page, struct address_space *mapping),
64 TP_ARGS(page, mapping),
65 TP_STRUCT__entry (
66 __array_text(char, name, 32)
67 __field(unsigned long, ino)
68 __field(pgoff_t, index)
69 ),
70 TP_fast_assign(
71 tp_memcpy(name,
72 mapping ? dev_name(inode_to_bdi(mapping->host)->dev) : "(unknown)", 32)
73 tp_assign(ino, mapping ? mapping->host->i_ino : 0)
74 tp_assign(index, page->index)
75 ),
76 TP_printk("bdi %s: ino=%lu index=%lu",
77 __entry->name,
78 __entry->ino,
79 __entry->index
80 )
81 )
82
83 LTTNG_TRACEPOINT_EVENT_CLASS(writeback_dirty_inode_template,
84 TP_PROTO(struct inode *inode, int flags),
85 TP_ARGS(inode, flags),
86 TP_STRUCT__entry (
87 __array_text(char, name, 32)
88 __field(unsigned long, ino)
89 __field(unsigned long, state)
90 __field(unsigned long, flags)
91 ),
92 TP_fast_assign(
93 /* may be called for files on pseudo FSes w/ unregistered bdi */
94 tp_memcpy(name,
95 inode_to_bdi(inode)->dev ?
96 dev_name(inode_to_bdi(inode)->dev) : "(unknown)", 32)
97 tp_assign(ino, inode->i_ino)
98 tp_assign(state, inode->i_state)
99 tp_assign(flags, flags)
100 ),
101 TP_printk("bdi %s: ino=%lu flags=%s",
102 __entry->name,
103 __entry->ino,
104 show_inode_state(__entry->flags)
105 )
106 )
107 #define LTTNG_TRACEPOINT_EVENT_WRITEBACK_DIRTY_INODE_TEMPLATE(name) \
108 LTTNG_TRACEPOINT_EVENT_INSTANCE(writeback_dirty_inode_template, name, \
109 TP_PROTO(struct inode *inode, int flags), \
110 TP_ARGS(inode, flags))
111 LTTNG_TRACEPOINT_EVENT_WRITEBACK_DIRTY_INODE_TEMPLATE(writeback_dirty_inode_start)
112 LTTNG_TRACEPOINT_EVENT_WRITEBACK_DIRTY_INODE_TEMPLATE(writeback_dirty_inode)
113 LTTNG_TRACEPOINT_EVENT_WRITEBACK_DIRTY_INODE_TEMPLATE(writeback_mark_inode_dirty)
114
115 LTTNG_TRACEPOINT_EVENT_CLASS(writeback_write_inode_template,
116 TP_PROTO(struct inode *inode, struct writeback_control *wbc),
117 TP_ARGS(inode, wbc),
118 TP_STRUCT__entry (
119 __array_text(char, name, 32)
120 __field(unsigned long, ino)
121 __field(int, sync_mode)
122 ),
123 TP_fast_assign(
124 tp_memcpy(name,
125 dev_name(inode_to_bdi(inode)->dev), 32)
126 tp_assign(ino, inode->i_ino)
127 tp_assign(sync_mode, wbc->sync_mode)
128 ),
129 TP_printk("bdi %s: ino=%lu sync_mode=%d",
130 __entry->name,
131 __entry->ino,
132 __entry->sync_mode
133 )
134 )
135
136 #define LTTNG_TRACEPOINT_EVENT_WRITEBACK_WRITE_INODE(name) \
137 LTTNG_TRACEPOINT_EVENT_INSTANCE(writeback_write_inode_template, name, \
138 TP_PROTO(struct inode *inode, struct writeback_control *wbc), \
139 TP_ARGS(inode, wbc))
140 LTTNG_TRACEPOINT_EVENT_WRITEBACK_WRITE_INODE(writeback_write_inode_start)
141 LTTNG_TRACEPOINT_EVENT_WRITEBACK_WRITE_INODE(writeback_write_inode)
142
143 #elif (LINUX_VERSION_CODE >= KERNEL_VERSION(3,9,0))
144
145 LTTNG_TRACEPOINT_EVENT(writeback_dirty_page,
146 TP_PROTO(struct page *page, struct address_space *mapping),
147 TP_ARGS(page, mapping),
148 TP_STRUCT__entry (
149 __array_text(char, name, 32)
150 __field(unsigned long, ino)
151 __field(pgoff_t, index)
152 ),
153 TP_fast_assign(
154 tp_memcpy(name,
155 mapping ? dev_name(mapping->backing_dev_info->dev) : "(unknown)", 32)
156 tp_assign(ino, mapping ? mapping->host->i_ino : 0)
157 tp_assign(index, page->index)
158 ),
159 TP_printk("bdi %s: ino=%lu index=%lu",
160 __entry->name,
161 __entry->ino,
162 __entry->index
163 )
164 )
165
166 LTTNG_TRACEPOINT_EVENT_CLASS(writeback_dirty_inode_template,
167 TP_PROTO(struct inode *inode, int flags),
168 TP_ARGS(inode, flags),
169 TP_STRUCT__entry (
170 __array_text(char, name, 32)
171 __field(unsigned long, ino)
172 __field(unsigned long, flags)
173 ),
174 TP_fast_assign(
175 /* may be called for files on pseudo FSes w/ unregistered bdi */
176 tp_memcpy(name,
177 inode->i_mapping->backing_dev_info->dev ?
178 dev_name(inode->i_mapping->backing_dev_info->dev) : "(unknown)", 32)
179 tp_assign(ino, inode->i_ino)
180 tp_assign(flags, flags)
181 ),
182 TP_printk("bdi %s: ino=%lu flags=%s",
183 __entry->name,
184 __entry->ino,
185 show_inode_state(__entry->flags)
186 )
187 )
188 #define LTTNG_TRACEPOINT_EVENT_WRITEBACK_DIRTY_INODE_TEMPLATE(name) \
189 LTTNG_TRACEPOINT_EVENT_INSTANCE(writeback_dirty_inode_template, name, \
190 TP_PROTO(struct inode *inode, int flags), \
191 TP_ARGS(inode, flags))
192 LTTNG_TRACEPOINT_EVENT_WRITEBACK_DIRTY_INODE_TEMPLATE(writeback_dirty_inode_start)
193 LTTNG_TRACEPOINT_EVENT_WRITEBACK_DIRTY_INODE_TEMPLATE(writeback_dirty_inode)
194
195 LTTNG_TRACEPOINT_EVENT_CLASS(writeback_write_inode_template,
196 TP_PROTO(struct inode *inode, struct writeback_control *wbc),
197 TP_ARGS(inode, wbc),
198 TP_STRUCT__entry (
199 __array_text(char, name, 32)
200 __field(unsigned long, ino)
201 __field(int, sync_mode)
202 ),
203 TP_fast_assign(
204 tp_memcpy(name,
205 dev_name(inode->i_mapping->backing_dev_info->dev), 32)
206 tp_assign(ino, inode->i_ino)
207 tp_assign(sync_mode, wbc->sync_mode)
208 ),
209 TP_printk("bdi %s: ino=%lu sync_mode=%d",
210 __entry->name,
211 __entry->ino,
212 __entry->sync_mode
213 )
214 )
215
216 #define LTTNG_TRACEPOINT_EVENT_WRITEBACK_WRITE_INODE(name) \
217 LTTNG_TRACEPOINT_EVENT_INSTANCE(writeback_write_inode_template, name, \
218 TP_PROTO(struct inode *inode, struct writeback_control *wbc), \
219 TP_ARGS(inode, wbc))
220 LTTNG_TRACEPOINT_EVENT_WRITEBACK_WRITE_INODE(writeback_write_inode_start)
221 LTTNG_TRACEPOINT_EVENT_WRITEBACK_WRITE_INODE(writeback_write_inode)
222
223 #endif /* (LINUX_VERSION_CODE >= KERNEL_VERSION(3,9,0)) */
224
225 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(4,3,0))
226
227 LTTNG_TRACEPOINT_EVENT_CLASS(writeback_work_class,
228 TP_PROTO(struct bdi_writeback *wb, struct wb_writeback_work *work),
229 TP_ARGS(wb, work),
230 TP_STRUCT__entry(
231 __array_text(char, name, 32)
232 ),
233 TP_fast_assign(
234 tp_memcpy(name, wb->bdi->dev ? dev_name(wb->bdi->dev) :
235 "(unknown)", 32)
236 ),
237 TP_printk("bdi %s",
238 __entry->name
239 )
240 )
241
242 #elif (LINUX_VERSION_CODE >= KERNEL_VERSION(4,0,0))
243
244 LTTNG_TRACEPOINT_EVENT_CLASS(writeback_work_class,
245 TP_PROTO(struct backing_dev_info *bdi, struct wb_writeback_work *work),
246 TP_ARGS(bdi, work),
247 TP_STRUCT__entry(
248 __array_text(char, name, 32)
249 ),
250 TP_fast_assign(
251 tp_memcpy(name, bdi->dev ? dev_name(bdi->dev) :
252 "(unknown)", 32)
253 ),
254 TP_printk("bdi %s",
255 __entry->name
256 )
257 )
258
259 #else /* #if (LINUX_VERSION_CODE >= KERNEL_VERSION(4,0,0)) */
260
261 LTTNG_TRACEPOINT_EVENT_CLASS(writeback_work_class,
262 TP_PROTO(struct backing_dev_info *bdi, struct wb_writeback_work *work),
263 TP_ARGS(bdi, work),
264 TP_STRUCT__entry(
265 __array_text(char, name, 32)
266 ),
267 TP_fast_assign(
268 tp_memcpy(name, dev_name(bdi->dev ? bdi->dev :
269 default_backing_dev_info.dev), 32)
270 ),
271 TP_printk("bdi %s",
272 __entry->name
273 )
274 )
275
276 #endif /* #else #if (LINUX_VERSION_CODE >= KERNEL_VERSION(4,0,0)) */
277
278 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(4,3,0))
279
280 #define LTTNG_TRACEPOINT_EVENT_WRITEBACK_WORK_INSTANCE(name) \
281 LTTNG_TRACEPOINT_EVENT_INSTANCE(writeback_work_class, name, \
282 TP_PROTO(struct bdi_writeback *wb, struct wb_writeback_work *work), \
283 TP_ARGS(wb, work))
284
285 #else /* #if (LINUX_VERSION_CODE >= KERNEL_VERSION(4,3,0)) */
286
287 #define LTTNG_TRACEPOINT_EVENT_WRITEBACK_WORK_INSTANCE(name) \
288 LTTNG_TRACEPOINT_EVENT_INSTANCE(writeback_work_class, name, \
289 TP_PROTO(struct backing_dev_info *bdi, struct wb_writeback_work *work), \
290 TP_ARGS(bdi, work))
291
292 #endif /* #else #if (LINUX_VERSION_CODE >= KERNEL_VERSION(4,3,0)) */
293
294 LTTNG_TRACEPOINT_EVENT_WRITEBACK_WORK_INSTANCE(writeback_nothread)
295 LTTNG_TRACEPOINT_EVENT_WRITEBACK_WORK_INSTANCE(writeback_queue)
296 LTTNG_TRACEPOINT_EVENT_WRITEBACK_WORK_INSTANCE(writeback_exec)
297 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,1,0))
298 LTTNG_TRACEPOINT_EVENT_WRITEBACK_WORK_INSTANCE(writeback_start)
299 LTTNG_TRACEPOINT_EVENT_WRITEBACK_WORK_INSTANCE(writeback_written)
300 LTTNG_TRACEPOINT_EVENT_WRITEBACK_WORK_INSTANCE(writeback_wait)
301 #endif
302
303 LTTNG_TRACEPOINT_EVENT(writeback_pages_written,
304 TP_PROTO(long pages_written),
305 TP_ARGS(pages_written),
306 TP_STRUCT__entry(
307 __field(long, pages)
308 ),
309 TP_fast_assign(
310 tp_assign(pages, pages_written)
311 ),
312 TP_printk("%ld", __entry->pages)
313 )
314
315 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(4,3,0))
316
317 LTTNG_TRACEPOINT_EVENT_CLASS(writeback_class,
318 TP_PROTO(struct bdi_writeback *wb),
319 TP_ARGS(wb),
320 TP_STRUCT__entry(
321 __array_text(char, name, 32)
322 ),
323 TP_fast_assign(
324 tp_memcpy(name, dev_name(wb->bdi->dev), 32)
325 ),
326 TP_printk("bdi %s",
327 __entry->name
328 )
329 )
330
331 #undef DEFINE_WRITEBACK_EVENT
332 #define DEFINE_WRITEBACK_EVENT(name) \
333 LTTNG_TRACEPOINT_EVENT_INSTANCE(writeback_class, name, \
334 TP_PROTO(struct bdi_writeback *wb), \
335 TP_ARGS(wb))
336
337 #define DEFINE_WRITEBACK_EVENT_MAP(name, map) \
338 LTTNG_TRACEPOINT_EVENT_INSTANCE_MAP(writeback_class, name, map, \
339 TP_PROTO(struct bdi_writeback *wb), \
340 TP_ARGS(wb))
341
342 LTTNG_TRACEPOINT_EVENT(writeback_bdi_register,
343 TP_PROTO(struct backing_dev_info *bdi),
344 TP_ARGS(bdi),
345 TP_STRUCT__entry(
346 __array_text(char, name, 32)
347 ),
348 TP_fast_assign(
349 tp_memcpy(name, dev_name(bdi->dev), 32)
350 ),
351 TP_printk("bdi %s",
352 __entry->name
353 )
354 )
355
356 #else /* #if (LINUX_VERSION_CODE >= KERNEL_VERSION(4,3,0)) */
357
358 LTTNG_TRACEPOINT_EVENT_CLASS(writeback_class,
359 TP_PROTO(struct backing_dev_info *bdi),
360 TP_ARGS(bdi),
361 TP_STRUCT__entry(
362 __array_text(char, name, 32)
363 ),
364 TP_fast_assign(
365 tp_memcpy(name, dev_name(bdi->dev), 32)
366 ),
367 TP_printk("bdi %s",
368 __entry->name
369 )
370 )
371
372 #undef DEFINE_WRITEBACK_EVENT
373 #define DEFINE_WRITEBACK_EVENT(name) \
374 LTTNG_TRACEPOINT_EVENT_INSTANCE(writeback_class, name, \
375 TP_PROTO(struct backing_dev_info *bdi), \
376 TP_ARGS(bdi))
377
378 #define DEFINE_WRITEBACK_EVENT_MAP(name, map) \
379 LTTNG_TRACEPOINT_EVENT_INSTANCE_MAP(writeback_class, name, map, \
380 TP_PROTO(struct backing_dev_info *bdi), \
381 TP_ARGS(bdi))
382
383 DEFINE_WRITEBACK_EVENT(writeback_bdi_register)
384
385 #endif /* #else #if (LINUX_VERSION_CODE >= KERNEL_VERSION(4,3,0)) */
386
387 DEFINE_WRITEBACK_EVENT(writeback_nowork)
388 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,38))
389 DEFINE_WRITEBACK_EVENT(writeback_wake_background)
390 #endif
391 DEFINE_WRITEBACK_EVENT(writeback_wake_thread)
392 DEFINE_WRITEBACK_EVENT(writeback_wake_forker_thread)
393 DEFINE_WRITEBACK_EVENT(writeback_bdi_unregister)
394 DEFINE_WRITEBACK_EVENT(writeback_thread_start)
395 DEFINE_WRITEBACK_EVENT(writeback_thread_stop)
396 #if (LTTNG_KERNEL_RANGE(3,1,0, 3,2,0))
397 DEFINE_WRITEBACK_EVENT_MAP(balance_dirty_start, writeback_balance_dirty_start)
398 DEFINE_WRITEBACK_EVENT_MAP(balance_dirty_wait, writeback_balance_dirty_wait)
399
400 LTTNG_TRACEPOINT_EVENT_MAP(balance_dirty_written,
401
402 writeback_balance_dirty_written,
403
404 TP_PROTO(struct backing_dev_info *bdi, int written),
405
406 TP_ARGS(bdi, written),
407
408 TP_STRUCT__entry(
409 __array(char, name, 32)
410 __field(int, written)
411 ),
412
413 TP_fast_assign(
414 tp_memcpy(name, dev_name(bdi->dev), 32)
415 tp_assign(written, written)
416 ),
417
418 TP_printk("bdi %s written %d",
419 __entry->name,
420 __entry->written
421 )
422 )
423 #endif
424
425 LTTNG_TRACEPOINT_EVENT_CLASS(writeback_wbc_class,
426 TP_PROTO(struct writeback_control *wbc, struct backing_dev_info *bdi),
427 TP_ARGS(wbc, bdi),
428 TP_STRUCT__entry(
429 __array_text(char, name, 32)
430 __field(long, nr_to_write)
431 __field(long, pages_skipped)
432 __field(int, sync_mode)
433 __field(int, for_kupdate)
434 __field(int, for_background)
435 __field(int, for_reclaim)
436 __field(int, range_cyclic)
437 #if (LINUX_VERSION_CODE < KERNEL_VERSION(3,1,0))
438 __field(int, more_io)
439 __field(unsigned long, older_than_this)
440 #endif
441 __field(long, range_start)
442 __field(long, range_end)
443 ),
444
445 TP_fast_assign(
446 tp_memcpy(name, dev_name(bdi->dev), 32)
447 tp_assign(nr_to_write, wbc->nr_to_write)
448 tp_assign(pages_skipped, wbc->pages_skipped)
449 tp_assign(sync_mode, wbc->sync_mode)
450 tp_assign(for_kupdate, wbc->for_kupdate)
451 tp_assign(for_background, wbc->for_background)
452 tp_assign(for_reclaim, wbc->for_reclaim)
453 tp_assign(range_cyclic, wbc->range_cyclic)
454 #if (LINUX_VERSION_CODE < KERNEL_VERSION(3,1,0))
455 tp_assign(more_io, wbc->more_io)
456 tp_assign(older_than_this, wbc->older_than_this ?
457 *wbc->older_than_this : 0)
458 #endif
459 tp_assign(range_start, (long)wbc->range_start)
460 tp_assign(range_end, (long)wbc->range_end)
461 ),
462
463 TP_printk("bdi %s: towrt=%ld skip=%ld mode=%d kupd=%d "
464 #if (LINUX_VERSION_CODE < KERNEL_VERSION(3,1,0))
465 "bgrd=%d reclm=%d cyclic=%d more=%d older=0x%lx "
466 #else
467 "bgrd=%d reclm=%d cyclic=%d "
468 #endif
469 "start=0x%lx end=0x%lx",
470 __entry->name,
471 __entry->nr_to_write,
472 __entry->pages_skipped,
473 __entry->sync_mode,
474 __entry->for_kupdate,
475 __entry->for_background,
476 __entry->for_reclaim,
477 __entry->range_cyclic,
478 #if (LINUX_VERSION_CODE < KERNEL_VERSION(3,1,0))
479 __entry->more_io,
480 __entry->older_than_this,
481 #endif
482 __entry->range_start,
483 __entry->range_end)
484 )
485
486 #undef DEFINE_WBC_EVENT
487 #define LTTNG_TRACEPOINT_EVENT_WBC_INSTANCE(name, map) \
488 LTTNG_TRACEPOINT_EVENT_INSTANCE_MAP(writeback_wbc_class, name, map, \
489 TP_PROTO(struct writeback_control *wbc, struct backing_dev_info *bdi), \
490 TP_ARGS(wbc, bdi))
491 #if (LINUX_VERSION_CODE < KERNEL_VERSION(3,1,0))
492 LTTNG_TRACEPOINT_EVENT_WBC_INSTANCE(wbc_writeback_start, writeback_wbc_writeback_start)
493 LTTNG_TRACEPOINT_EVENT_WBC_INSTANCE(wbc_writeback_written, writeback_wbc_writeback_written)
494 LTTNG_TRACEPOINT_EVENT_WBC_INSTANCE(wbc_writeback_wait, writeback_wbc_writeback_wait)
495 LTTNG_TRACEPOINT_EVENT_WBC_INSTANCE(wbc_balance_dirty_start, writeback_wbc_balance_dirty_start)
496 LTTNG_TRACEPOINT_EVENT_WBC_INSTANCE(wbc_balance_dirty_written, writeback_wbc_balance_dirty_written)
497 LTTNG_TRACEPOINT_EVENT_WBC_INSTANCE(wbc_balance_dirty_wait, writeback_wbc_balance_dirty_wait)
498 #endif
499 LTTNG_TRACEPOINT_EVENT_WBC_INSTANCE(wbc_writepage, writeback_wbc_writepage)
500
501 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,1,0))
502 LTTNG_TRACEPOINT_EVENT(writeback_queue_io,
503 TP_PROTO(struct bdi_writeback *wb,
504 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,2,0))
505 struct wb_writeback_work *work,
506 #else
507 unsigned long *older_than_this,
508 #endif
509 int moved),
510 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,2,0))
511 TP_ARGS(wb, work, moved),
512 #else
513 TP_ARGS(wb, older_than_this, moved),
514 #endif
515 TP_STRUCT__entry(
516 __array(char, name, 32)
517 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,2,0))
518 #else
519 __field(unsigned long, older)
520 __field(long, age)
521 #endif
522 __field(int, moved)
523 ),
524 TP_fast_assign(
525 tp_memcpy(name, dev_name(wb->bdi->dev), 32)
526 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,2,0))
527 #else
528 tp_assign(older, older_than_this ? *older_than_this : 0)
529 tp_assign(age, older_than_this ?
530 (jiffies - *older_than_this) * 1000 / HZ : -1)
531 #endif
532 tp_assign(moved, moved)
533 ),
534 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,2,0))
535 TP_printk("bdi %s: enqueue=%d",
536 __entry->name,
537 __entry->moved,
538 )
539 #else
540 TP_printk("bdi %s: older=%lu age=%ld enqueue=%d",
541 __entry->name,
542 __entry->older, /* older_than_this in jiffies */
543 __entry->age, /* older_than_this in relative milliseconds */
544 __entry->moved
545 )
546 #endif
547 )
548
549 LTTNG_TRACEPOINT_EVENT_MAP(global_dirty_state,
550
551 writeback_global_dirty_state,
552
553 TP_PROTO(unsigned long background_thresh,
554 unsigned long dirty_thresh
555 ),
556
557 TP_ARGS(background_thresh,
558 dirty_thresh
559 ),
560
561 TP_STRUCT__entry(
562 __field(unsigned long, nr_dirty)
563 __field(unsigned long, nr_writeback)
564 __field(unsigned long, nr_unstable)
565 __field(unsigned long, background_thresh)
566 __field(unsigned long, dirty_thresh)
567 __field(unsigned long, dirty_limit)
568 __field(unsigned long, nr_dirtied)
569 __field(unsigned long, nr_written)
570 ),
571
572 TP_fast_assign(
573 tp_assign(nr_dirty, global_page_state(NR_FILE_DIRTY))
574 tp_assign(nr_writeback, global_page_state(NR_WRITEBACK))
575 tp_assign(nr_unstable, global_page_state(NR_UNSTABLE_NFS))
576 tp_assign(nr_dirtied, global_page_state(NR_DIRTIED))
577 tp_assign(nr_written, global_page_state(NR_WRITTEN))
578 tp_assign(background_thresh, background_thresh)
579 tp_assign(dirty_thresh, dirty_thresh)
580 tp_assign(dirty_limit, global_dirty_limit)
581 ),
582
583 TP_printk("dirty=%lu writeback=%lu unstable=%lu "
584 "bg_thresh=%lu thresh=%lu limit=%lu "
585 "dirtied=%lu written=%lu",
586 __entry->nr_dirty,
587 __entry->nr_writeback,
588 __entry->nr_unstable,
589 __entry->background_thresh,
590 __entry->dirty_thresh,
591 __entry->dirty_limit,
592 __entry->nr_dirtied,
593 __entry->nr_written
594 )
595 )
596 #endif
597
598 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,2,0))
599
600 #define KBps(x) ((x) << (PAGE_SHIFT - 10))
601
602 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(4,3,0))
603
604 LTTNG_TRACEPOINT_EVENT_MAP(bdi_dirty_ratelimit,
605
606 writeback_bdi_dirty_ratelimit,
607
608 TP_PROTO(struct bdi_writeback *wb,
609 unsigned long dirty_rate,
610 unsigned long task_ratelimit),
611
612 TP_ARGS(wb, dirty_rate, task_ratelimit),
613
614 TP_STRUCT__entry(
615 __array(char, bdi, 32)
616 __field(unsigned long, write_bw)
617 __field(unsigned long, avg_write_bw)
618 __field(unsigned long, dirty_rate)
619 __field(unsigned long, dirty_ratelimit)
620 __field(unsigned long, task_ratelimit)
621 __field(unsigned long, balanced_dirty_ratelimit)
622 ),
623
624 TP_fast_assign(
625 tp_memcpy(bdi, dev_name(wb->bdi->dev), 32)
626 tp_assign(write_bw, KBps(wb->bdi->wb.write_bandwidth))
627 tp_assign(avg_write_bw, KBps(wb->bdi->wb.avg_write_bandwidth))
628 tp_assign(dirty_rate, KBps(dirty_rate))
629 tp_assign(dirty_ratelimit, KBps(wb->bdi->wb.dirty_ratelimit))
630 tp_assign(task_ratelimit, KBps(task_ratelimit))
631 tp_assign(balanced_dirty_ratelimit,
632 KBps(wb->bdi->wb.balanced_dirty_ratelimit))
633 ),
634
635 TP_printk("bdi %s: "
636 "write_bw=%lu awrite_bw=%lu dirty_rate=%lu "
637 "dirty_ratelimit=%lu task_ratelimit=%lu "
638 "balanced_dirty_ratelimit=%lu",
639 __entry->bdi,
640 __entry->write_bw, /* write bandwidth */
641 __entry->avg_write_bw, /* avg write bandwidth */
642 __entry->dirty_rate, /* bdi dirty rate */
643 __entry->dirty_ratelimit, /* base ratelimit */
644 __entry->task_ratelimit, /* ratelimit with position control */
645 __entry->balanced_dirty_ratelimit /* the balanced ratelimit */
646 )
647 )
648
649 #elif (LINUX_VERSION_CODE >= KERNEL_VERSION(4,2,0))
650
651 LTTNG_TRACEPOINT_EVENT_MAP(bdi_dirty_ratelimit,
652
653 writeback_bdi_dirty_ratelimit,
654
655 TP_PROTO(struct backing_dev_info *bdi,
656 unsigned long dirty_rate,
657 unsigned long task_ratelimit),
658
659 TP_ARGS(bdi, dirty_rate, task_ratelimit),
660
661 TP_STRUCT__entry(
662 __array(char, bdi, 32)
663 __field(unsigned long, write_bw)
664 __field(unsigned long, avg_write_bw)
665 __field(unsigned long, dirty_rate)
666 __field(unsigned long, dirty_ratelimit)
667 __field(unsigned long, task_ratelimit)
668 __field(unsigned long, balanced_dirty_ratelimit)
669 ),
670
671 TP_fast_assign(
672 tp_memcpy(bdi, dev_name(bdi->dev), 32)
673 tp_assign(write_bw, KBps(bdi->wb.write_bandwidth))
674 tp_assign(avg_write_bw, KBps(bdi->wb.avg_write_bandwidth))
675 tp_assign(dirty_rate, KBps(dirty_rate))
676 tp_assign(dirty_ratelimit, KBps(bdi->wb.dirty_ratelimit))
677 tp_assign(task_ratelimit, KBps(task_ratelimit))
678 tp_assign(balanced_dirty_ratelimit,
679 KBps(bdi->wb.balanced_dirty_ratelimit))
680 ),
681
682 TP_printk("bdi %s: "
683 "write_bw=%lu awrite_bw=%lu dirty_rate=%lu "
684 "dirty_ratelimit=%lu task_ratelimit=%lu "
685 "balanced_dirty_ratelimit=%lu",
686 __entry->bdi,
687 __entry->write_bw, /* write bandwidth */
688 __entry->avg_write_bw, /* avg write bandwidth */
689 __entry->dirty_rate, /* bdi dirty rate */
690 __entry->dirty_ratelimit, /* base ratelimit */
691 __entry->task_ratelimit, /* ratelimit with position control */
692 __entry->balanced_dirty_ratelimit /* the balanced ratelimit */
693 )
694 )
695
696 #else
697
698 LTTNG_TRACEPOINT_EVENT_MAP(bdi_dirty_ratelimit,
699
700 writeback_bdi_dirty_ratelimit,
701
702 TP_PROTO(struct backing_dev_info *bdi,
703 unsigned long dirty_rate,
704 unsigned long task_ratelimit),
705
706 TP_ARGS(bdi, dirty_rate, task_ratelimit),
707
708 TP_STRUCT__entry(
709 __array(char, bdi, 32)
710 __field(unsigned long, write_bw)
711 __field(unsigned long, avg_write_bw)
712 __field(unsigned long, dirty_rate)
713 __field(unsigned long, dirty_ratelimit)
714 __field(unsigned long, task_ratelimit)
715 __field(unsigned long, balanced_dirty_ratelimit)
716 ),
717
718 TP_fast_assign(
719 tp_memcpy(bdi, dev_name(bdi->dev), 32)
720 tp_assign(write_bw, KBps(bdi->write_bandwidth))
721 tp_assign(avg_write_bw, KBps(bdi->avg_write_bandwidth))
722 tp_assign(dirty_rate, KBps(dirty_rate))
723 tp_assign(dirty_ratelimit, KBps(bdi->dirty_ratelimit))
724 tp_assign(task_ratelimit, KBps(task_ratelimit))
725 tp_assign(balanced_dirty_ratelimit,
726 KBps(bdi->balanced_dirty_ratelimit))
727 ),
728
729 TP_printk("bdi %s: "
730 "write_bw=%lu awrite_bw=%lu dirty_rate=%lu "
731 "dirty_ratelimit=%lu task_ratelimit=%lu "
732 "balanced_dirty_ratelimit=%lu",
733 __entry->bdi,
734 __entry->write_bw, /* write bandwidth */
735 __entry->avg_write_bw, /* avg write bandwidth */
736 __entry->dirty_rate, /* bdi dirty rate */
737 __entry->dirty_ratelimit, /* base ratelimit */
738 __entry->task_ratelimit, /* ratelimit with position control */
739 __entry->balanced_dirty_ratelimit /* the balanced ratelimit */
740 )
741 )
742
743 #endif
744
745 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(4,3,0))
746
747 LTTNG_TRACEPOINT_EVENT_MAP(balance_dirty_pages,
748
749 writeback_balance_dirty_pages,
750
751 TP_PROTO(struct bdi_writeback *wb,
752 unsigned long thresh,
753 unsigned long bg_thresh,
754 unsigned long dirty,
755 unsigned long bdi_thresh,
756 unsigned long bdi_dirty,
757 unsigned long dirty_ratelimit,
758 unsigned long task_ratelimit,
759 unsigned long dirtied,
760 unsigned long period,
761 long pause,
762 unsigned long start_time),
763
764 TP_ARGS(wb, thresh, bg_thresh, dirty, bdi_thresh, bdi_dirty,
765 dirty_ratelimit, task_ratelimit,
766 dirtied, period, pause, start_time
767 ),
768
769 TP_STRUCT__entry(
770 __array( char, bdi, 32)
771 __field(unsigned long, limit)
772 __field(unsigned long, setpoint)
773 __field(unsigned long, dirty)
774 __field(unsigned long, bdi_setpoint)
775 __field(unsigned long, bdi_dirty)
776 __field(unsigned long, dirty_ratelimit)
777 __field(unsigned long, task_ratelimit)
778 __field(unsigned int, dirtied)
779 __field(unsigned int, dirtied_pause)
780 __field(unsigned long, paused)
781 __field( long, pause)
782 __field(unsigned long, period)
783 __field( long, think)
784 ),
785
786 TP_fast_assign(
787 tp_memcpy(bdi, dev_name(wb->bdi->dev), 32)
788 tp_assign(limit, global_dirty_limit)
789 tp_assign(setpoint,
790 (global_dirty_limit + (thresh + bg_thresh) / 2) / 2)
791 tp_assign(dirty, dirty)
792 tp_assign(bdi_setpoint,
793 ((global_dirty_limit + (thresh + bg_thresh) / 2) / 2) *
794 bdi_thresh / (thresh + 1))
795 tp_assign(bdi_dirty, bdi_dirty)
796 tp_assign(dirty_ratelimit, KBps(dirty_ratelimit))
797 tp_assign(task_ratelimit, KBps(task_ratelimit))
798 tp_assign(dirtied, dirtied)
799 tp_assign(dirtied_pause, current->nr_dirtied_pause)
800 tp_assign(think, current->dirty_paused_when == 0 ? 0 :
801 (long)(jiffies - current->dirty_paused_when) * 1000/HZ)
802 tp_assign(period, period * 1000 / HZ)
803 tp_assign(pause, pause * 1000 / HZ)
804 tp_assign(paused, (jiffies - start_time) * 1000 / HZ)
805 ),
806
807
808 TP_printk("bdi %s: "
809 "limit=%lu setpoint=%lu dirty=%lu "
810 "bdi_setpoint=%lu bdi_dirty=%lu "
811 "dirty_ratelimit=%lu task_ratelimit=%lu "
812 "dirtied=%u dirtied_pause=%u "
813 "paused=%lu pause=%ld period=%lu think=%ld",
814 __entry->bdi,
815 __entry->limit,
816 __entry->setpoint,
817 __entry->dirty,
818 __entry->bdi_setpoint,
819 __entry->bdi_dirty,
820 __entry->dirty_ratelimit,
821 __entry->task_ratelimit,
822 __entry->dirtied,
823 __entry->dirtied_pause,
824 __entry->paused, /* ms */
825 __entry->pause, /* ms */
826 __entry->period, /* ms */
827 __entry->think /* ms */
828 )
829 )
830
831 #else /* #if LINUX_VERSION_CODE >= KERNEL_VERSION(4,3,0)) */
832
833 LTTNG_TRACEPOINT_EVENT_MAP(balance_dirty_pages,
834
835 writeback_balance_dirty_pages,
836
837 TP_PROTO(struct backing_dev_info *bdi,
838 unsigned long thresh,
839 unsigned long bg_thresh,
840 unsigned long dirty,
841 unsigned long bdi_thresh,
842 unsigned long bdi_dirty,
843 unsigned long dirty_ratelimit,
844 unsigned long task_ratelimit,
845 unsigned long dirtied,
846 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,3,0))
847 unsigned long period,
848 #endif
849 long pause,
850 unsigned long start_time),
851
852 TP_ARGS(bdi, thresh, bg_thresh, dirty, bdi_thresh, bdi_dirty,
853 dirty_ratelimit, task_ratelimit,
854 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,3,0))
855 dirtied, period, pause, start_time),
856 #else
857 dirtied, pause, start_time),
858 #endif
859 TP_STRUCT__entry(
860 __array( char, bdi, 32)
861 __field(unsigned long, limit)
862 __field(unsigned long, setpoint)
863 __field(unsigned long, dirty)
864 __field(unsigned long, bdi_setpoint)
865 __field(unsigned long, bdi_dirty)
866 __field(unsigned long, dirty_ratelimit)
867 __field(unsigned long, task_ratelimit)
868 __field(unsigned int, dirtied)
869 __field(unsigned int, dirtied_pause)
870 __field(unsigned long, paused)
871 __field( long, pause)
872 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,3,0))
873 __field(unsigned long, period)
874 __field( long, think)
875 #endif
876 ),
877
878 TP_fast_assign(
879 tp_memcpy(bdi, dev_name(bdi->dev), 32)
880 tp_assign(limit, global_dirty_limit)
881 tp_assign(setpoint,
882 (global_dirty_limit + (thresh + bg_thresh) / 2) / 2)
883 tp_assign(dirty, dirty)
884 tp_assign(bdi_setpoint,
885 ((global_dirty_limit + (thresh + bg_thresh) / 2) / 2) *
886 bdi_thresh / (thresh + 1))
887 tp_assign(bdi_dirty, bdi_dirty)
888 tp_assign(dirty_ratelimit, KBps(dirty_ratelimit))
889 tp_assign(task_ratelimit, KBps(task_ratelimit))
890 tp_assign(dirtied, dirtied)
891 tp_assign(dirtied_pause, current->nr_dirtied_pause)
892 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,3,0))
893 tp_assign(think, current->dirty_paused_when == 0 ? 0 :
894 (long)(jiffies - current->dirty_paused_when) * 1000/HZ)
895 tp_assign(period, period * 1000 / HZ)
896 #endif
897 tp_assign(pause, pause * 1000 / HZ)
898 tp_assign(paused, (jiffies - start_time) * 1000 / HZ)
899 ),
900
901
902 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,3,0))
903 TP_printk("bdi %s: "
904 "limit=%lu setpoint=%lu dirty=%lu "
905 "bdi_setpoint=%lu bdi_dirty=%lu "
906 "dirty_ratelimit=%lu task_ratelimit=%lu "
907 "dirtied=%u dirtied_pause=%u "
908 "paused=%lu pause=%ld period=%lu think=%ld",
909 __entry->bdi,
910 __entry->limit,
911 __entry->setpoint,
912 __entry->dirty,
913 __entry->bdi_setpoint,
914 __entry->bdi_dirty,
915 __entry->dirty_ratelimit,
916 __entry->task_ratelimit,
917 __entry->dirtied,
918 __entry->dirtied_pause,
919 __entry->paused, /* ms */
920 __entry->pause, /* ms */
921 __entry->period, /* ms */
922 __entry->think /* ms */
923 )
924 #else
925 TP_printk("bdi %s: "
926 "limit=%lu setpoint=%lu dirty=%lu "
927 "bdi_setpoint=%lu bdi_dirty=%lu "
928 "dirty_ratelimit=%lu task_ratelimit=%lu "
929 "dirtied=%u dirtied_pause=%u "
930 "paused=%lu pause=%ld",
931 __entry->bdi,
932 __entry->limit,
933 __entry->setpoint,
934 __entry->dirty,
935 __entry->bdi_setpoint,
936 __entry->bdi_dirty,
937 __entry->dirty_ratelimit,
938 __entry->task_ratelimit,
939 __entry->dirtied,
940 __entry->dirtied_pause,
941 __entry->paused, /* ms */
942 __entry->pause /* ms */
943 )
944 #endif
945 )
946 #endif /* #else #if LINUX_VERSION_CODE >= KERNEL_VERSION(4,3,0)) */
947
948 #endif /* #if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,2,0)) */
949
950 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,5,0))
951 LTTNG_TRACEPOINT_EVENT(writeback_sb_inodes_requeue,
952
953 TP_PROTO(struct inode *inode),
954 TP_ARGS(inode),
955
956 TP_STRUCT__entry(
957 __array_text(char, name, 32)
958 __field(unsigned long, ino)
959 __field(unsigned long, state)
960 __field(unsigned long, dirtied_when)
961 ),
962
963 TP_fast_assign(
964 tp_memcpy(name, dev_name(inode_to_bdi(inode)->dev), 32)
965 tp_assign(ino, inode->i_ino)
966 tp_assign(state, inode->i_state)
967 tp_assign(dirtied_when, inode->dirtied_when)
968 ),
969
970 TP_printk("bdi %s: ino=%lu state=%s dirtied_when=%lu age=%lu",
971 __entry->name,
972 __entry->ino,
973 show_inode_state(__entry->state),
974 __entry->dirtied_when,
975 (jiffies - __entry->dirtied_when) / HZ
976 )
977 )
978 #endif
979
980 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,37))
981 LTTNG_TRACEPOINT_EVENT_CLASS(writeback_congest_waited_template,
982
983 TP_PROTO(unsigned int usec_timeout, unsigned int usec_delayed),
984
985 TP_ARGS(usec_timeout, usec_delayed),
986
987 TP_STRUCT__entry(
988 __field( unsigned int, usec_timeout )
989 __field( unsigned int, usec_delayed )
990 ),
991
992 TP_fast_assign(
993 tp_assign(usec_timeout, usec_timeout)
994 tp_assign(usec_delayed, usec_delayed)
995 ),
996
997 TP_printk("usec_timeout=%u usec_delayed=%u",
998 __entry->usec_timeout,
999 __entry->usec_delayed)
1000 )
1001
1002 LTTNG_TRACEPOINT_EVENT_INSTANCE(writeback_congest_waited_template, writeback_congestion_wait,
1003
1004 TP_PROTO(unsigned int usec_timeout, unsigned int usec_delayed),
1005
1006 TP_ARGS(usec_timeout, usec_delayed)
1007 )
1008
1009 LTTNG_TRACEPOINT_EVENT_INSTANCE(writeback_congest_waited_template, writeback_wait_iff_congested,
1010
1011 TP_PROTO(unsigned int usec_timeout, unsigned int usec_delayed),
1012
1013 TP_ARGS(usec_timeout, usec_delayed)
1014 )
1015 #endif
1016
1017 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,1,0))
1018 LTTNG_TRACEPOINT_EVENT_CLASS(writeback_single_inode_template,
1019
1020 TP_PROTO(struct inode *inode,
1021 struct writeback_control *wbc,
1022 unsigned long nr_to_write
1023 ),
1024
1025 TP_ARGS(inode, wbc, nr_to_write),
1026
1027 TP_STRUCT__entry(
1028 __array_text(char, name, 32)
1029 __field(unsigned long, ino)
1030 __field(unsigned long, state)
1031 __field(unsigned long, dirtied_when)
1032 __field(unsigned long, writeback_index)
1033 __field(long, nr_to_write)
1034 __field(unsigned long, wrote)
1035 ),
1036
1037 TP_fast_assign(
1038 tp_memcpy(name, dev_name(inode_to_bdi(inode)->dev), 32)
1039 tp_assign(ino, inode->i_ino)
1040 tp_assign(state, inode->i_state)
1041 tp_assign(dirtied_when, inode->dirtied_when)
1042 tp_assign(writeback_index, inode->i_mapping->writeback_index)
1043 tp_assign(nr_to_write, nr_to_write)
1044 tp_assign(wrote, nr_to_write - wbc->nr_to_write)
1045 ),
1046
1047 TP_printk("bdi %s: ino=%lu state=%s dirtied_when=%lu age=%lu "
1048 "index=%lu to_write=%ld wrote=%lu",
1049 __entry->name,
1050 __entry->ino,
1051 show_inode_state(__entry->state),
1052 __entry->dirtied_when,
1053 (jiffies - __entry->dirtied_when) / HZ,
1054 __entry->writeback_index,
1055 __entry->nr_to_write,
1056 __entry->wrote
1057 )
1058 )
1059
1060 #if (LINUX_VERSION_CODE < KERNEL_VERSION(3,5,0))
1061 LTTNG_TRACEPOINT_EVENT_INSTANCE(writeback_single_inode_template, writeback_single_inode_requeue,
1062 TP_PROTO(struct inode *inode,
1063 struct writeback_control *wbc,
1064 unsigned long nr_to_write),
1065 TP_ARGS(inode, wbc, nr_to_write)
1066 )
1067 #endif
1068
1069 LTTNG_TRACEPOINT_EVENT_INSTANCE(writeback_single_inode_template, writeback_single_inode,
1070 TP_PROTO(struct inode *inode,
1071 struct writeback_control *wbc,
1072 unsigned long nr_to_write),
1073 TP_ARGS(inode, wbc, nr_to_write)
1074 )
1075 #endif
1076
1077 #endif /* LTTNG_TRACE_WRITEBACK_H */
1078
1079 /* This part must be outside protection */
1080 #include "../../../probes/define_trace.h"
LTTng 2.0/0.x modules
This page took 0.05185 seconds and 4 git commands to generate.