projects / lttng-modules.git / blob
? search:


79f84b76559f92d72b3d34440c74c23205b900f3
[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(3,2,0))
61 #define WB_WORK_REASON \
62 {WB_REASON_BACKGROUND, "background"}, \
63 {WB_REASON_TRY_TO_FREE_PAGES, "try_to_free_pages"}, \
64 {WB_REASON_SYNC, "sync"}, \
65 {WB_REASON_PERIODIC, "periodic"}, \
66 {WB_REASON_LAPTOP_TIMER, "laptop_timer"}, \
67 {WB_REASON_FREE_MORE_MEM, "free_more_memory"}, \
68 {WB_REASON_FS_FREE_SPACE, "fs_free_space"}, \
69 {WB_REASON_FORKER_THREAD, "forker_thread"}
70 #endif
71
72 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(4,0,0))
73
74 LTTNG_TRACEPOINT_EVENT(writeback_dirty_page,
75 TP_PROTO(struct page *page, struct address_space *mapping),
76 TP_ARGS(page, mapping),
77 TP_STRUCT__entry (
78 __array_text(char, name, 32)
79 __field(unsigned long, ino)
80 __field(pgoff_t, index)
81 ),
82 TP_fast_assign(
83 tp_memcpy(name,
84 mapping ? dev_name(inode_to_bdi(mapping->host)->dev) : "(unknown)", 32)
85 tp_assign(ino, mapping ? mapping->host->i_ino : 0)
86 tp_assign(index, page->index)
87 ),
88 TP_printk("bdi %s: ino=%lu index=%lu",
89 __entry->name,
90 __entry->ino,
91 __entry->index
92 )
93 )
94
95 LTTNG_TRACEPOINT_EVENT_CLASS(writeback_dirty_inode_template,
96 TP_PROTO(struct inode *inode, int flags),
97 TP_ARGS(inode, flags),
98 TP_STRUCT__entry (
99 __array_text(char, name, 32)
100 __field(unsigned long, ino)
101 __field(unsigned long, state)
102 __field(unsigned long, flags)
103 ),
104 TP_fast_assign(
105 /* may be called for files on pseudo FSes w/ unregistered bdi */
106 tp_memcpy(name,
107 inode_to_bdi(inode)->dev ?
108 dev_name(inode_to_bdi(inode)->dev) : "(unknown)", 32)
109 tp_assign(ino, inode->i_ino)
110 tp_assign(state, inode->i_state)
111 tp_assign(flags, flags)
112 ),
113 TP_printk("bdi %s: ino=%lu flags=%s",
114 __entry->name,
115 __entry->ino,
116 show_inode_state(__entry->flags)
117 )
118 )
119 #define LTTNG_TRACEPOINT_EVENT_WRITEBACK_DIRTY_INODE_TEMPLATE(name) \
120 LTTNG_TRACEPOINT_EVENT_INSTANCE(writeback_dirty_inode_template, name, \
121 TP_PROTO(struct inode *inode, int flags), \
122 TP_ARGS(inode, flags))
123 LTTNG_TRACEPOINT_EVENT_WRITEBACK_DIRTY_INODE_TEMPLATE(writeback_dirty_inode_start)
124 LTTNG_TRACEPOINT_EVENT_WRITEBACK_DIRTY_INODE_TEMPLATE(writeback_dirty_inode)
125 LTTNG_TRACEPOINT_EVENT_WRITEBACK_DIRTY_INODE_TEMPLATE(writeback_mark_inode_dirty)
126
127 LTTNG_TRACEPOINT_EVENT_CLASS(writeback_write_inode_template,
128 TP_PROTO(struct inode *inode, struct writeback_control *wbc),
129 TP_ARGS(inode, wbc),
130 TP_STRUCT__entry (
131 __array_text(char, name, 32)
132 __field(unsigned long, ino)
133 __field(int, sync_mode)
134 ),
135 TP_fast_assign(
136 tp_memcpy(name,
137 dev_name(inode_to_bdi(inode)->dev), 32)
138 tp_assign(ino, inode->i_ino)
139 tp_assign(sync_mode, wbc->sync_mode)
140 ),
141 TP_printk("bdi %s: ino=%lu sync_mode=%d",
142 __entry->name,
143 __entry->ino,
144 __entry->sync_mode
145 )
146 )
147
148 #define LTTNG_TRACEPOINT_EVENT_WRITEBACK_WRITE_INODE(name) \
149 LTTNG_TRACEPOINT_EVENT_INSTANCE(writeback_write_inode_template, name, \
150 TP_PROTO(struct inode *inode, struct writeback_control *wbc), \
151 TP_ARGS(inode, wbc))
152 LTTNG_TRACEPOINT_EVENT_WRITEBACK_WRITE_INODE(writeback_write_inode_start)
153 LTTNG_TRACEPOINT_EVENT_WRITEBACK_WRITE_INODE(writeback_write_inode)
154
155 #elif (LINUX_VERSION_CODE >= KERNEL_VERSION(3,9,0))
156
157 LTTNG_TRACEPOINT_EVENT(writeback_dirty_page,
158 TP_PROTO(struct page *page, struct address_space *mapping),
159 TP_ARGS(page, mapping),
160 TP_STRUCT__entry (
161 __array_text(char, name, 32)
162 __field(unsigned long, ino)
163 __field(pgoff_t, index)
164 ),
165 TP_fast_assign(
166 tp_memcpy(name,
167 mapping ? dev_name(mapping->backing_dev_info->dev) : "(unknown)", 32)
168 tp_assign(ino, mapping ? mapping->host->i_ino : 0)
169 tp_assign(index, page->index)
170 ),
171 TP_printk("bdi %s: ino=%lu index=%lu",
172 __entry->name,
173 __entry->ino,
174 __entry->index
175 )
176 )
177
178 LTTNG_TRACEPOINT_EVENT_CLASS(writeback_dirty_inode_template,
179 TP_PROTO(struct inode *inode, int flags),
180 TP_ARGS(inode, flags),
181 TP_STRUCT__entry (
182 __array_text(char, name, 32)
183 __field(unsigned long, ino)
184 __field(unsigned long, flags)
185 ),
186 TP_fast_assign(
187 /* may be called for files on pseudo FSes w/ unregistered bdi */
188 tp_memcpy(name,
189 inode->i_mapping->backing_dev_info->dev ?
190 dev_name(inode->i_mapping->backing_dev_info->dev) : "(unknown)", 32)
191 tp_assign(ino, inode->i_ino)
192 tp_assign(flags, flags)
193 ),
194 TP_printk("bdi %s: ino=%lu flags=%s",
195 __entry->name,
196 __entry->ino,
197 show_inode_state(__entry->flags)
198 )
199 )
200 #define LTTNG_TRACEPOINT_EVENT_WRITEBACK_DIRTY_INODE_TEMPLATE(name) \
201 LTTNG_TRACEPOINT_EVENT_INSTANCE(writeback_dirty_inode_template, name, \
202 TP_PROTO(struct inode *inode, int flags), \
203 TP_ARGS(inode, flags))
204 LTTNG_TRACEPOINT_EVENT_WRITEBACK_DIRTY_INODE_TEMPLATE(writeback_dirty_inode_start)
205 LTTNG_TRACEPOINT_EVENT_WRITEBACK_DIRTY_INODE_TEMPLATE(writeback_dirty_inode)
206
207 LTTNG_TRACEPOINT_EVENT_CLASS(writeback_write_inode_template,
208 TP_PROTO(struct inode *inode, struct writeback_control *wbc),
209 TP_ARGS(inode, wbc),
210 TP_STRUCT__entry (
211 __array_text(char, name, 32)
212 __field(unsigned long, ino)
213 __field(int, sync_mode)
214 ),
215 TP_fast_assign(
216 tp_memcpy(name,
217 dev_name(inode->i_mapping->backing_dev_info->dev), 32)
218 tp_assign(ino, inode->i_ino)
219 tp_assign(sync_mode, wbc->sync_mode)
220 ),
221 TP_printk("bdi %s: ino=%lu sync_mode=%d",
222 __entry->name,
223 __entry->ino,
224 __entry->sync_mode
225 )
226 )
227
228 #define LTTNG_TRACEPOINT_EVENT_WRITEBACK_WRITE_INODE(name) \
229 LTTNG_TRACEPOINT_EVENT_INSTANCE(writeback_write_inode_template, name, \
230 TP_PROTO(struct inode *inode, struct writeback_control *wbc), \
231 TP_ARGS(inode, wbc))
232 LTTNG_TRACEPOINT_EVENT_WRITEBACK_WRITE_INODE(writeback_write_inode_start)
233 LTTNG_TRACEPOINT_EVENT_WRITEBACK_WRITE_INODE(writeback_write_inode)
234
235 #endif /* (LINUX_VERSION_CODE >= KERNEL_VERSION(3,9,0)) */
236
237 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(4,0,0))
238
239 LTTNG_TRACEPOINT_EVENT_CLASS(writeback_work_class,
240 TP_PROTO(struct backing_dev_info *bdi, struct wb_writeback_work *work),
241 TP_ARGS(bdi, work),
242 TP_STRUCT__entry(
243 __array_text(char, name, 32)
244 ),
245 TP_fast_assign(
246 tp_memcpy(name, bdi->dev ? dev_name(bdi->dev) :
247 "(unknown)", 32)
248 ),
249 TP_printk("bdi %s",
250 __entry->name
251 )
252 )
253
254 #else /* #if (LINUX_VERSION_CODE >= KERNEL_VERSION(4,0,0)) */
255
256 LTTNG_TRACEPOINT_EVENT_CLASS(writeback_work_class,
257 TP_PROTO(struct backing_dev_info *bdi, struct wb_writeback_work *work),
258 TP_ARGS(bdi, work),
259 TP_STRUCT__entry(
260 __array_text(char, name, 32)
261 ),
262 TP_fast_assign(
263 tp_memcpy(name, dev_name(bdi->dev ? bdi->dev :
264 default_backing_dev_info.dev), 32)
265 ),
266 TP_printk("bdi %s",
267 __entry->name
268 )
269 )
270
271 #endif /* #else #if (LINUX_VERSION_CODE >= KERNEL_VERSION(4,0,0)) */
272
273 #define LTTNG_TRACEPOINT_EVENT_WRITEBACK_WORK_INSTANCE(name) \
274 LTTNG_TRACEPOINT_EVENT_INSTANCE(writeback_work_class, name, \
275 TP_PROTO(struct backing_dev_info *bdi, struct wb_writeback_work *work), \
276 TP_ARGS(bdi, work))
277 LTTNG_TRACEPOINT_EVENT_WRITEBACK_WORK_INSTANCE(writeback_nothread)
278 LTTNG_TRACEPOINT_EVENT_WRITEBACK_WORK_INSTANCE(writeback_queue)
279 LTTNG_TRACEPOINT_EVENT_WRITEBACK_WORK_INSTANCE(writeback_exec)
280 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,1,0))
281 LTTNG_TRACEPOINT_EVENT_WRITEBACK_WORK_INSTANCE(writeback_start)
282 LTTNG_TRACEPOINT_EVENT_WRITEBACK_WORK_INSTANCE(writeback_written)
283 LTTNG_TRACEPOINT_EVENT_WRITEBACK_WORK_INSTANCE(writeback_wait)
284 #endif
285
286 LTTNG_TRACEPOINT_EVENT(writeback_pages_written,
287 TP_PROTO(long pages_written),
288 TP_ARGS(pages_written),
289 TP_STRUCT__entry(
290 __field(long, pages)
291 ),
292 TP_fast_assign(
293 tp_assign(pages, pages_written)
294 ),
295 TP_printk("%ld", __entry->pages)
296 )
297
298 LTTNG_TRACEPOINT_EVENT_CLASS(writeback_class,
299 TP_PROTO(struct backing_dev_info *bdi),
300 TP_ARGS(bdi),
301 TP_STRUCT__entry(
302 __array_text(char, name, 32)
303 ),
304 TP_fast_assign(
305 tp_memcpy(name, dev_name(bdi->dev), 32)
306 ),
307 TP_printk("bdi %s",
308 __entry->name
309 )
310 )
311 #undef DEFINE_WRITEBACK_EVENT
312 #define DEFINE_WRITEBACK_EVENT(name) \
313 LTTNG_TRACEPOINT_EVENT_INSTANCE(writeback_class, name, \
314 TP_PROTO(struct backing_dev_info *bdi), \
315 TP_ARGS(bdi))
316
317 #define DEFINE_WRITEBACK_EVENT_MAP(name, map) \
318 LTTNG_TRACEPOINT_EVENT_INSTANCE_MAP(writeback_class, name, map, \
319 TP_PROTO(struct backing_dev_info *bdi), \
320 TP_ARGS(bdi))
321
322 DEFINE_WRITEBACK_EVENT(writeback_nowork)
323 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,38))
324 DEFINE_WRITEBACK_EVENT(writeback_wake_background)
325 #endif
326 DEFINE_WRITEBACK_EVENT(writeback_wake_thread)
327 DEFINE_WRITEBACK_EVENT(writeback_wake_forker_thread)
328 DEFINE_WRITEBACK_EVENT(writeback_bdi_register)
329 DEFINE_WRITEBACK_EVENT(writeback_bdi_unregister)
330 DEFINE_WRITEBACK_EVENT(writeback_thread_start)
331 DEFINE_WRITEBACK_EVENT(writeback_thread_stop)
332 #if (LTTNG_KERNEL_RANGE(3,1,0, 3,2,0))
333 DEFINE_WRITEBACK_EVENT_MAP(balance_dirty_start, writeback_balance_dirty_start)
334 DEFINE_WRITEBACK_EVENT_MAP(balance_dirty_wait, writeback_balance_dirty_wait)
335
336 LTTNG_TRACEPOINT_EVENT_MAP(balance_dirty_written,
337
338 writeback_balance_dirty_written,
339
340 TP_PROTO(struct backing_dev_info *bdi, int written),
341
342 TP_ARGS(bdi, written),
343
344 TP_STRUCT__entry(
345 __array(char, name, 32)
346 __field(int, written)
347 ),
348
349 TP_fast_assign(
350 tp_memcpy(name, dev_name(bdi->dev), 32)
351 tp_assign(written, written)
352 ),
353
354 TP_printk("bdi %s written %d",
355 __entry->name,
356 __entry->written
357 )
358 )
359 #endif
360
361 LTTNG_TRACEPOINT_EVENT_CLASS(writeback_wbc_class,
362 TP_PROTO(struct writeback_control *wbc, struct backing_dev_info *bdi),
363 TP_ARGS(wbc, bdi),
364 TP_STRUCT__entry(
365 __array_text(char, name, 32)
366 __field(long, nr_to_write)
367 __field(long, pages_skipped)
368 __field(int, sync_mode)
369 __field(int, for_kupdate)
370 __field(int, for_background)
371 __field(int, for_reclaim)
372 __field(int, range_cyclic)
373 #if (LINUX_VERSION_CODE < KERNEL_VERSION(3,1,0))
374 __field(int, more_io)
375 __field(unsigned long, older_than_this)
376 #endif
377 __field(long, range_start)
378 __field(long, range_end)
379 ),
380
381 TP_fast_assign(
382 tp_memcpy(name, dev_name(bdi->dev), 32)
383 tp_assign(nr_to_write, wbc->nr_to_write)
384 tp_assign(pages_skipped, wbc->pages_skipped)
385 tp_assign(sync_mode, wbc->sync_mode)
386 tp_assign(for_kupdate, wbc->for_kupdate)
387 tp_assign(for_background, wbc->for_background)
388 tp_assign(for_reclaim, wbc->for_reclaim)
389 tp_assign(range_cyclic, wbc->range_cyclic)
390 #if (LINUX_VERSION_CODE < KERNEL_VERSION(3,1,0))
391 tp_assign(more_io, wbc->more_io)
392 tp_assign(older_than_this, wbc->older_than_this ?
393 *wbc->older_than_this : 0)
394 #endif
395 tp_assign(range_start, (long)wbc->range_start)
396 tp_assign(range_end, (long)wbc->range_end)
397 ),
398
399 TP_printk("bdi %s: towrt=%ld skip=%ld mode=%d kupd=%d "
400 #if (LINUX_VERSION_CODE < KERNEL_VERSION(3,1,0))
401 "bgrd=%d reclm=%d cyclic=%d more=%d older=0x%lx "
402 #else
403 "bgrd=%d reclm=%d cyclic=%d "
404 #endif
405 "start=0x%lx end=0x%lx",
406 __entry->name,
407 __entry->nr_to_write,
408 __entry->pages_skipped,
409 __entry->sync_mode,
410 __entry->for_kupdate,
411 __entry->for_background,
412 __entry->for_reclaim,
413 __entry->range_cyclic,
414 #if (LINUX_VERSION_CODE < KERNEL_VERSION(3,1,0))
415 __entry->more_io,
416 __entry->older_than_this,
417 #endif
418 __entry->range_start,
419 __entry->range_end)
420 )
421
422 #undef DEFINE_WBC_EVENT
423 #define LTTNG_TRACEPOINT_EVENT_WBC_INSTANCE(name, map) \
424 LTTNG_TRACEPOINT_EVENT_INSTANCE_MAP(writeback_wbc_class, name, map, \
425 TP_PROTO(struct writeback_control *wbc, struct backing_dev_info *bdi), \
426 TP_ARGS(wbc, bdi))
427 #if (LINUX_VERSION_CODE < KERNEL_VERSION(3,1,0))
428 LTTNG_TRACEPOINT_EVENT_WBC_INSTANCE(wbc_writeback_start, writeback_wbc_writeback_start)
429 LTTNG_TRACEPOINT_EVENT_WBC_INSTANCE(wbc_writeback_written, writeback_wbc_writeback_written)
430 LTTNG_TRACEPOINT_EVENT_WBC_INSTANCE(wbc_writeback_wait, writeback_wbc_writeback_wait)
431 LTTNG_TRACEPOINT_EVENT_WBC_INSTANCE(wbc_balance_dirty_start, writeback_wbc_balance_dirty_start)
432 LTTNG_TRACEPOINT_EVENT_WBC_INSTANCE(wbc_balance_dirty_written, writeback_wbc_balance_dirty_written)
433 LTTNG_TRACEPOINT_EVENT_WBC_INSTANCE(wbc_balance_dirty_wait, writeback_wbc_balance_dirty_wait)
434 #endif
435 LTTNG_TRACEPOINT_EVENT_WBC_INSTANCE(wbc_writepage, writeback_wbc_writepage)
436
437 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,1,0))
438 LTTNG_TRACEPOINT_EVENT(writeback_queue_io,
439 TP_PROTO(struct bdi_writeback *wb,
440 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,2,0))
441 struct wb_writeback_work *work,
442 #else
443 unsigned long *older_than_this,
444 #endif
445 int moved),
446 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,2,0))
447 TP_ARGS(wb, work, moved),
448 #else
449 TP_ARGS(wb, older_than_this, moved),
450 #endif
451 TP_STRUCT__entry(
452 __array(char, name, 32)
453 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,2,0))
454 #else
455 __field(unsigned long, older)
456 __field(long, age)
457 #endif
458 __field(int, moved)
459 ),
460 TP_fast_assign(
461 tp_memcpy(name, dev_name(wb->bdi->dev), 32)
462 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,2,0))
463 #else
464 tp_assign(older, older_than_this ? *older_than_this : 0)
465 tp_assign(age, older_than_this ?
466 (jiffies - *older_than_this) * 1000 / HZ : -1)
467 #endif
468 tp_assign(moved, moved)
469 ),
470 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,2,0))
471 TP_printk("bdi %s: enqueue=%d",
472 __entry->name,
473 __entry->moved,
474 )
475 #else
476 TP_printk("bdi %s: older=%lu age=%ld enqueue=%d",
477 __entry->name,
478 __entry->older, /* older_than_this in jiffies */
479 __entry->age, /* older_than_this in relative milliseconds */
480 __entry->moved
481 )
482 #endif
483 )
484
485 LTTNG_TRACEPOINT_EVENT_MAP(global_dirty_state,
486
487 writeback_global_dirty_state,
488
489 TP_PROTO(unsigned long background_thresh,
490 unsigned long dirty_thresh
491 ),
492
493 TP_ARGS(background_thresh,
494 dirty_thresh
495 ),
496
497 TP_STRUCT__entry(
498 __field(unsigned long, nr_dirty)
499 __field(unsigned long, nr_writeback)
500 __field(unsigned long, nr_unstable)
501 __field(unsigned long, background_thresh)
502 __field(unsigned long, dirty_thresh)
503 __field(unsigned long, dirty_limit)
504 __field(unsigned long, nr_dirtied)
505 __field(unsigned long, nr_written)
506 ),
507
508 TP_fast_assign(
509 tp_assign(nr_dirty, global_page_state(NR_FILE_DIRTY))
510 tp_assign(nr_writeback, global_page_state(NR_WRITEBACK))
511 tp_assign(nr_unstable, global_page_state(NR_UNSTABLE_NFS))
512 tp_assign(nr_dirtied, global_page_state(NR_DIRTIED))
513 tp_assign(nr_written, global_page_state(NR_WRITTEN))
514 tp_assign(background_thresh, background_thresh)
515 tp_assign(dirty_thresh, dirty_thresh)
516 tp_assign(dirty_limit, global_dirty_limit)
517 ),
518
519 TP_printk("dirty=%lu writeback=%lu unstable=%lu "
520 "bg_thresh=%lu thresh=%lu limit=%lu "
521 "dirtied=%lu written=%lu",
522 __entry->nr_dirty,
523 __entry->nr_writeback,
524 __entry->nr_unstable,
525 __entry->background_thresh,
526 __entry->dirty_thresh,
527 __entry->dirty_limit,
528 __entry->nr_dirtied,
529 __entry->nr_written
530 )
531 )
532 #endif
533
534 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,2,0))
535
536 #define KBps(x) ((x) << (PAGE_SHIFT - 10))
537
538 LTTNG_TRACEPOINT_EVENT_MAP(bdi_dirty_ratelimit,
539
540 writeback_bdi_dirty_ratelimit,
541
542 TP_PROTO(struct backing_dev_info *bdi,
543 unsigned long dirty_rate,
544 unsigned long task_ratelimit),
545
546 TP_ARGS(bdi, dirty_rate, task_ratelimit),
547
548 TP_STRUCT__entry(
549 __array(char, bdi, 32)
550 __field(unsigned long, write_bw)
551 __field(unsigned long, avg_write_bw)
552 __field(unsigned long, dirty_rate)
553 __field(unsigned long, dirty_ratelimit)
554 __field(unsigned long, task_ratelimit)
555 __field(unsigned long, balanced_dirty_ratelimit)
556 ),
557
558 TP_fast_assign(
559 tp_memcpy(bdi, dev_name(bdi->dev), 32)
560 tp_assign(write_bw, KBps(bdi->write_bandwidth))
561 tp_assign(avg_write_bw, KBps(bdi->avg_write_bandwidth))
562 tp_assign(dirty_rate, KBps(dirty_rate))
563 tp_assign(dirty_ratelimit, KBps(bdi->dirty_ratelimit))
564 tp_assign(task_ratelimit, KBps(task_ratelimit))
565 tp_assign(balanced_dirty_ratelimit,
566 KBps(bdi->balanced_dirty_ratelimit))
567 ),
568
569 TP_printk("bdi %s: "
570 "write_bw=%lu awrite_bw=%lu dirty_rate=%lu "
571 "dirty_ratelimit=%lu task_ratelimit=%lu "
572 "balanced_dirty_ratelimit=%lu",
573 __entry->bdi,
574 __entry->write_bw, /* write bandwidth */
575 __entry->avg_write_bw, /* avg write bandwidth */
576 __entry->dirty_rate, /* bdi dirty rate */
577 __entry->dirty_ratelimit, /* base ratelimit */
578 __entry->task_ratelimit, /* ratelimit with position control */
579 __entry->balanced_dirty_ratelimit /* the balanced ratelimit */
580 )
581 )
582
583 LTTNG_TRACEPOINT_EVENT_MAP(balance_dirty_pages,
584
585 writeback_balance_dirty_pages,
586
587 TP_PROTO(struct backing_dev_info *bdi,
588 unsigned long thresh,
589 unsigned long bg_thresh,
590 unsigned long dirty,
591 unsigned long bdi_thresh,
592 unsigned long bdi_dirty,
593 unsigned long dirty_ratelimit,
594 unsigned long task_ratelimit,
595 unsigned long dirtied,
596 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,3,0))
597 unsigned long period,
598 #endif
599 long pause,
600 unsigned long start_time),
601
602 TP_ARGS(bdi, thresh, bg_thresh, dirty, bdi_thresh, bdi_dirty,
603 dirty_ratelimit, task_ratelimit,
604 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,3,0))
605 dirtied, period, pause, start_time),
606 #else
607 dirtied, pause, start_time),
608 #endif
609 TP_STRUCT__entry(
610 __array( char, bdi, 32)
611 __field(unsigned long, limit)
612 __field(unsigned long, setpoint)
613 __field(unsigned long, dirty)
614 __field(unsigned long, bdi_setpoint)
615 __field(unsigned long, bdi_dirty)
616 __field(unsigned long, dirty_ratelimit)
617 __field(unsigned long, task_ratelimit)
618 __field(unsigned int, dirtied)
619 __field(unsigned int, dirtied_pause)
620 __field(unsigned long, paused)
621 __field( long, pause)
622 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,3,0))
623 __field(unsigned long, period)
624 __field( long, think)
625 #endif
626 ),
627
628 TP_fast_assign(
629 tp_memcpy(bdi, dev_name(bdi->dev), 32)
630 tp_assign(limit, global_dirty_limit)
631 tp_assign(setpoint,
632 (global_dirty_limit + (thresh + bg_thresh) / 2) / 2)
633 tp_assign(dirty, dirty)
634 tp_assign(bdi_setpoint,
635 ((global_dirty_limit + (thresh + bg_thresh) / 2) / 2) *
636 bdi_thresh / (thresh + 1))
637 tp_assign(bdi_dirty, bdi_dirty)
638 tp_assign(dirty_ratelimit, KBps(dirty_ratelimit))
639 tp_assign(task_ratelimit, KBps(task_ratelimit))
640 tp_assign(dirtied, dirtied)
641 tp_assign(dirtied_pause, current->nr_dirtied_pause)
642 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,3,0))
643 tp_assign(think, current->dirty_paused_when == 0 ? 0 :
644 (long)(jiffies - current->dirty_paused_when) * 1000/HZ)
645 tp_assign(period, period * 1000 / HZ)
646 #endif
647 tp_assign(pause, pause * 1000 / HZ)
648 tp_assign(paused, (jiffies - start_time) * 1000 / HZ)
649 ),
650
651
652 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,3,0))
653 TP_printk("bdi %s: "
654 "limit=%lu setpoint=%lu dirty=%lu "
655 "bdi_setpoint=%lu bdi_dirty=%lu "
656 "dirty_ratelimit=%lu task_ratelimit=%lu "
657 "dirtied=%u dirtied_pause=%u "
658 "paused=%lu pause=%ld period=%lu think=%ld",
659 __entry->bdi,
660 __entry->limit,
661 __entry->setpoint,
662 __entry->dirty,
663 __entry->bdi_setpoint,
664 __entry->bdi_dirty,
665 __entry->dirty_ratelimit,
666 __entry->task_ratelimit,
667 __entry->dirtied,
668 __entry->dirtied_pause,
669 __entry->paused, /* ms */
670 __entry->pause, /* ms */
671 __entry->period, /* ms */
672 __entry->think /* ms */
673 )
674 #else
675 TP_printk("bdi %s: "
676 "limit=%lu setpoint=%lu dirty=%lu "
677 "bdi_setpoint=%lu bdi_dirty=%lu "
678 "dirty_ratelimit=%lu task_ratelimit=%lu "
679 "dirtied=%u dirtied_pause=%u "
680 "paused=%lu pause=%ld",
681 __entry->bdi,
682 __entry->limit,
683 __entry->setpoint,
684 __entry->dirty,
685 __entry->bdi_setpoint,
686 __entry->bdi_dirty,
687 __entry->dirty_ratelimit,
688 __entry->task_ratelimit,
689 __entry->dirtied,
690 __entry->dirtied_pause,
691 __entry->paused, /* ms */
692 __entry->pause /* ms */
693 )
694 #endif
695 )
696 #endif
697
698 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,5,0))
699 LTTNG_TRACEPOINT_EVENT(writeback_sb_inodes_requeue,
700
701 TP_PROTO(struct inode *inode),
702 TP_ARGS(inode),
703
704 TP_STRUCT__entry(
705 __array_text(char, name, 32)
706 __field(unsigned long, ino)
707 __field(unsigned long, state)
708 __field(unsigned long, dirtied_when)
709 ),
710
711 TP_fast_assign(
712 tp_memcpy(name, dev_name(inode_to_bdi(inode)->dev), 32)
713 tp_assign(ino, inode->i_ino)
714 tp_assign(state, inode->i_state)
715 tp_assign(dirtied_when, inode->dirtied_when)
716 ),
717
718 TP_printk("bdi %s: ino=%lu state=%s dirtied_when=%lu age=%lu",
719 __entry->name,
720 __entry->ino,
721 show_inode_state(__entry->state),
722 __entry->dirtied_when,
723 (jiffies - __entry->dirtied_when) / HZ
724 )
725 )
726 #endif
727
728 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,37))
729 LTTNG_TRACEPOINT_EVENT_CLASS(writeback_congest_waited_template,
730
731 TP_PROTO(unsigned int usec_timeout, unsigned int usec_delayed),
732
733 TP_ARGS(usec_timeout, usec_delayed),
734
735 TP_STRUCT__entry(
736 __field( unsigned int, usec_timeout )
737 __field( unsigned int, usec_delayed )
738 ),
739
740 TP_fast_assign(
741 tp_assign(usec_timeout, usec_timeout)
742 tp_assign(usec_delayed, usec_delayed)
743 ),
744
745 TP_printk("usec_timeout=%u usec_delayed=%u",
746 __entry->usec_timeout,
747 __entry->usec_delayed)
748 )
749
750 LTTNG_TRACEPOINT_EVENT_INSTANCE(writeback_congest_waited_template, writeback_congestion_wait,
751
752 TP_PROTO(unsigned int usec_timeout, unsigned int usec_delayed),
753
754 TP_ARGS(usec_timeout, usec_delayed)
755 )
756
757 LTTNG_TRACEPOINT_EVENT_INSTANCE(writeback_congest_waited_template, writeback_wait_iff_congested,
758
759 TP_PROTO(unsigned int usec_timeout, unsigned int usec_delayed),
760
761 TP_ARGS(usec_timeout, usec_delayed)
762 )
763 #endif
764
765 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,1,0))
766 LTTNG_TRACEPOINT_EVENT_CLASS(writeback_single_inode_template,
767
768 TP_PROTO(struct inode *inode,
769 struct writeback_control *wbc,
770 unsigned long nr_to_write
771 ),
772
773 TP_ARGS(inode, wbc, nr_to_write),
774
775 TP_STRUCT__entry(
776 __array_text(char, name, 32)
777 __field(unsigned long, ino)
778 __field(unsigned long, state)
779 __field(unsigned long, dirtied_when)
780 __field(unsigned long, writeback_index)
781 __field(long, nr_to_write)
782 __field(unsigned long, wrote)
783 ),
784
785 TP_fast_assign(
786 tp_memcpy(name, dev_name(inode_to_bdi(inode)->dev), 32)
787 tp_assign(ino, inode->i_ino)
788 tp_assign(state, inode->i_state)
789 tp_assign(dirtied_when, inode->dirtied_when)
790 tp_assign(writeback_index, inode->i_mapping->writeback_index)
791 tp_assign(nr_to_write, nr_to_write)
792 tp_assign(wrote, nr_to_write - wbc->nr_to_write)
793 ),
794
795 TP_printk("bdi %s: ino=%lu state=%s dirtied_when=%lu age=%lu "
796 "index=%lu to_write=%ld wrote=%lu",
797 __entry->name,
798 __entry->ino,
799 show_inode_state(__entry->state),
800 __entry->dirtied_when,
801 (jiffies - __entry->dirtied_when) / HZ,
802 __entry->writeback_index,
803 __entry->nr_to_write,
804 __entry->wrote
805 )
806 )
807
808 #if (LINUX_VERSION_CODE < KERNEL_VERSION(3,5,0))
809 LTTNG_TRACEPOINT_EVENT_INSTANCE(writeback_single_inode_template, writeback_single_inode_requeue,
810 TP_PROTO(struct inode *inode,
811 struct writeback_control *wbc,
812 unsigned long nr_to_write),
813 TP_ARGS(inode, wbc, nr_to_write)
814 )
815 #endif
816
817 LTTNG_TRACEPOINT_EVENT_INSTANCE(writeback_single_inode_template, writeback_single_inode,
818 TP_PROTO(struct inode *inode,
819 struct writeback_control *wbc,
820 unsigned long nr_to_write),
821 TP_ARGS(inode, wbc, nr_to_write)
822 )
823 #endif
824
825 #endif /* LTTNG_TRACE_WRITEBACK_H */
826
827 /* This part must be outside protection */
828 #include "../../../probes/define_trace.h"
LTTng 2.0/0.x modules
This page took 0.045326 seconds and 3 git commands to generate.