1/* SPDX-License-Identifier: GPL-2.0 */
2#undef TRACE_SYSTEM
3#define TRACE_SYSTEM writeback
4
5#if !defined(_TRACE_WRITEBACK_H) || defined(TRACE_HEADER_MULTI_READ)
6#define _TRACE_WRITEBACK_H
7
8#include <linux/tracepoint.h>
9#include <linux/backing-dev.h>
10#include <linux/writeback.h>
11
12#define show_inode_state(state) \
13 __print_flags(state, "|", \
14 {I_DIRTY_SYNC, "I_DIRTY_SYNC"}, \
15 {I_DIRTY_DATASYNC, "I_DIRTY_DATASYNC"}, \
16 {I_DIRTY_PAGES, "I_DIRTY_PAGES"}, \
17 {I_NEW, "I_NEW"}, \
18 {I_WILL_FREE, "I_WILL_FREE"}, \
19 {I_FREEING, "I_FREEING"}, \
20 {I_CLEAR, "I_CLEAR"}, \
21 {I_SYNC, "I_SYNC"}, \
22 {I_DIRTY_TIME, "I_DIRTY_TIME"}, \
23 {I_REFERENCED, "I_REFERENCED"}, \
24 {I_LINKABLE, "I_LINKABLE"}, \
25 {I_WB_SWITCH, "I_WB_SWITCH"}, \
26 {I_OVL_INUSE, "I_OVL_INUSE"}, \
27 {I_CREATING, "I_CREATING"}, \
28 {I_DONTCACHE, "I_DONTCACHE"}, \
29 {I_SYNC_QUEUED, "I_SYNC_QUEUED"}, \
30 {I_PINNING_NETFS_WB, "I_PINNING_NETFS_WB"}, \
31 {I_LRU_ISOLATING, "I_LRU_ISOLATING"} \
32 )
33
34/* enums need to be exported to user space */
35#undef EM
36#undef EMe
37#define EM(a,b) TRACE_DEFINE_ENUM(a);
38#define EMe(a,b) TRACE_DEFINE_ENUM(a);
39
40#define WB_WORK_REASON \
41 EM( WB_REASON_BACKGROUND, "background") \
42 EM( WB_REASON_VMSCAN, "vmscan") \
43 EM( WB_REASON_SYNC, "sync") \
44 EM( WB_REASON_PERIODIC, "periodic") \
45 EM( WB_REASON_LAPTOP_TIMER, "laptop_timer") \
46 EM( WB_REASON_FS_FREE_SPACE, "fs_free_space") \
47 EM( WB_REASON_FORKER_THREAD, "forker_thread") \
48 EMe(WB_REASON_FOREIGN_FLUSH, "foreign_flush")
49
50WB_WORK_REASON
51
52/*
53 * Now redefine the EM() and EMe() macros to map the enums to the strings
54 * that will be printed in the output.
55 */
56#undef EM
57#undef EMe
58#define EM(a,b) { a, b },
59#define EMe(a,b) { a, b }
60
61struct wb_writeback_work;
62
63DECLARE_EVENT_CLASS(writeback_folio_template,
64
65 TP_PROTO(struct folio *folio, struct address_space *mapping),
66
67 TP_ARGS(folio, mapping),
68
69 TP_STRUCT__entry (
70 __array(char, name, 32)
71 __field(ino_t, ino)
72 __field(pgoff_t, index)
73 ),
74
75 TP_fast_assign(
76 strscpy_pad(__entry->name,
77 bdi_dev_name(mapping ? inode_to_bdi(mapping->host) :
78 NULL), 32);
79 __entry->ino = (mapping && mapping->host) ? mapping->host->i_ino : 0;
80 __entry->index = folio->index;
81 ),
82
83 TP_printk("bdi %s: ino=%lu index=%lu",
84 __entry->name,
85 (unsigned long)__entry->ino,
86 __entry->index
87 )
88);
89
90DEFINE_EVENT(writeback_folio_template, writeback_dirty_folio,
91
92 TP_PROTO(struct folio *folio, struct address_space *mapping),
93
94 TP_ARGS(folio, mapping)
95);
96
97DEFINE_EVENT(writeback_folio_template, folio_wait_writeback,
98
99 TP_PROTO(struct folio *folio, struct address_space *mapping),
100
101 TP_ARGS(folio, mapping)
102);
103
104DECLARE_EVENT_CLASS(writeback_dirty_inode_template,
105
106 TP_PROTO(struct inode *inode, int flags),
107
108 TP_ARGS(inode, flags),
109
110 TP_STRUCT__entry (
111 __array(char, name, 32)
112 __field(ino_t, ino)
113 __field(unsigned long, state)
114 __field(unsigned long, flags)
115 ),
116
117 TP_fast_assign(
118 struct backing_dev_info *bdi = inode_to_bdi(inode);
119
120 /* may be called for files on pseudo FSes w/ unregistered bdi */
121 strscpy_pad(__entry->name, bdi_dev_name(bdi), 32);
122 __entry->ino = inode->i_ino;
123 __entry->state = inode_state_read_once(inode);
124 __entry->flags = flags;
125 ),
126
127 TP_printk("bdi %s: ino=%lu state=%s flags=%s",
128 __entry->name,
129 (unsigned long)__entry->ino,
130 show_inode_state(__entry->state),
131 show_inode_state(__entry->flags)
132 )
133);
134
135DEFINE_EVENT(writeback_dirty_inode_template, writeback_mark_inode_dirty,
136
137 TP_PROTO(struct inode *inode, int flags),
138
139 TP_ARGS(inode, flags)
140);
141
142DEFINE_EVENT(writeback_dirty_inode_template, writeback_dirty_inode_start,
143
144 TP_PROTO(struct inode *inode, int flags),
145
146 TP_ARGS(inode, flags)
147);
148
149DEFINE_EVENT(writeback_dirty_inode_template, writeback_dirty_inode,
150
151 TP_PROTO(struct inode *inode, int flags),
152
153 TP_ARGS(inode, flags)
154);
155
156#ifdef CREATE_TRACE_POINTS
157#ifdef CONFIG_CGROUP_WRITEBACK
158
159static inline ino_t __trace_wb_assign_cgroup(struct bdi_writeback *wb)
160{
161 return cgroup_ino(cgrp: wb->memcg_css->cgroup);
162}
163
164static inline ino_t __trace_wbc_assign_cgroup(struct writeback_control *wbc)
165{
166 if (wbc->wb)
167 return __trace_wb_assign_cgroup(wb: wbc->wb);
168 else
169 return 1;
170}
171#else /* CONFIG_CGROUP_WRITEBACK */
172
173static inline ino_t __trace_wb_assign_cgroup(struct bdi_writeback *wb)
174{
175 return 1;
176}
177
178static inline ino_t __trace_wbc_assign_cgroup(struct writeback_control *wbc)
179{
180 return 1;
181}
182
183#endif /* CONFIG_CGROUP_WRITEBACK */
184#endif /* CREATE_TRACE_POINTS */
185
186#ifdef CONFIG_CGROUP_WRITEBACK
187TRACE_EVENT(inode_foreign_history,
188
189 TP_PROTO(struct inode *inode, struct writeback_control *wbc,
190 unsigned int history),
191
192 TP_ARGS(inode, wbc, history),
193
194 TP_STRUCT__entry(
195 __array(char, name, 32)
196 __field(ino_t, ino)
197 __field(ino_t, cgroup_ino)
198 __field(unsigned int, history)
199 ),
200
201 TP_fast_assign(
202 strscpy_pad(__entry->name, bdi_dev_name(inode_to_bdi(inode)), 32);
203 __entry->ino = inode->i_ino;
204 __entry->cgroup_ino = __trace_wbc_assign_cgroup(wbc);
205 __entry->history = history;
206 ),
207
208 TP_printk("bdi %s: ino=%lu cgroup_ino=%lu history=0x%x",
209 __entry->name,
210 (unsigned long)__entry->ino,
211 (unsigned long)__entry->cgroup_ino,
212 __entry->history
213 )
214);
215
216TRACE_EVENT(inode_switch_wbs_queue,
217
218 TP_PROTO(struct bdi_writeback *old_wb, struct bdi_writeback *new_wb,
219 unsigned int count),
220
221 TP_ARGS(old_wb, new_wb, count),
222
223 TP_STRUCT__entry(
224 __array(char, name, 32)
225 __field(ino_t, old_cgroup_ino)
226 __field(ino_t, new_cgroup_ino)
227 __field(unsigned int, count)
228 ),
229
230 TP_fast_assign(
231 strscpy_pad(__entry->name, bdi_dev_name(old_wb->bdi), 32);
232 __entry->old_cgroup_ino = __trace_wb_assign_cgroup(old_wb);
233 __entry->new_cgroup_ino = __trace_wb_assign_cgroup(new_wb);
234 __entry->count = count;
235 ),
236
237 TP_printk("bdi %s: old_cgroup_ino=%lu new_cgroup_ino=%lu count=%u",
238 __entry->name,
239 (unsigned long)__entry->old_cgroup_ino,
240 (unsigned long)__entry->new_cgroup_ino,
241 __entry->count
242 )
243);
244
245TRACE_EVENT(inode_switch_wbs,
246
247 TP_PROTO(struct inode *inode, struct bdi_writeback *old_wb,
248 struct bdi_writeback *new_wb),
249
250 TP_ARGS(inode, old_wb, new_wb),
251
252 TP_STRUCT__entry(
253 __array(char, name, 32)
254 __field(ino_t, ino)
255 __field(ino_t, old_cgroup_ino)
256 __field(ino_t, new_cgroup_ino)
257 ),
258
259 TP_fast_assign(
260 strscpy_pad(__entry->name, bdi_dev_name(old_wb->bdi), 32);
261 __entry->ino = inode->i_ino;
262 __entry->old_cgroup_ino = __trace_wb_assign_cgroup(old_wb);
263 __entry->new_cgroup_ino = __trace_wb_assign_cgroup(new_wb);
264 ),
265
266 TP_printk("bdi %s: ino=%lu old_cgroup_ino=%lu new_cgroup_ino=%lu",
267 __entry->name,
268 (unsigned long)__entry->ino,
269 (unsigned long)__entry->old_cgroup_ino,
270 (unsigned long)__entry->new_cgroup_ino
271 )
272);
273
274TRACE_EVENT(track_foreign_dirty,
275
276 TP_PROTO(struct folio *folio, struct bdi_writeback *wb),
277
278 TP_ARGS(folio, wb),
279
280 TP_STRUCT__entry(
281 __array(char, name, 32)
282 __field(u64, bdi_id)
283 __field(ino_t, ino)
284 __field(unsigned int, memcg_id)
285 __field(ino_t, cgroup_ino)
286 __field(ino_t, page_cgroup_ino)
287 ),
288
289 TP_fast_assign(
290 struct address_space *mapping = folio_mapping(folio);
291 struct inode *inode = mapping ? mapping->host : NULL;
292
293 strscpy_pad(__entry->name, bdi_dev_name(wb->bdi), 32);
294 __entry->bdi_id = wb->bdi->id;
295 __entry->ino = inode ? inode->i_ino : 0;
296 __entry->memcg_id = wb->memcg_css->id;
297 __entry->cgroup_ino = __trace_wb_assign_cgroup(wb);
298 __entry->page_cgroup_ino = cgroup_ino(folio_memcg(folio)->css.cgroup);
299 ),
300
301 TP_printk("bdi %s[%llu]: ino=%lu memcg_id=%u cgroup_ino=%lu page_cgroup_ino=%lu",
302 __entry->name,
303 __entry->bdi_id,
304 (unsigned long)__entry->ino,
305 __entry->memcg_id,
306 (unsigned long)__entry->cgroup_ino,
307 (unsigned long)__entry->page_cgroup_ino
308 )
309);
310
311TRACE_EVENT(flush_foreign,
312
313 TP_PROTO(struct bdi_writeback *wb, unsigned int frn_bdi_id,
314 unsigned int frn_memcg_id),
315
316 TP_ARGS(wb, frn_bdi_id, frn_memcg_id),
317
318 TP_STRUCT__entry(
319 __array(char, name, 32)
320 __field(ino_t, cgroup_ino)
321 __field(unsigned int, frn_bdi_id)
322 __field(unsigned int, frn_memcg_id)
323 ),
324
325 TP_fast_assign(
326 strscpy_pad(__entry->name, bdi_dev_name(wb->bdi), 32);
327 __entry->cgroup_ino = __trace_wb_assign_cgroup(wb);
328 __entry->frn_bdi_id = frn_bdi_id;
329 __entry->frn_memcg_id = frn_memcg_id;
330 ),
331
332 TP_printk("bdi %s: cgroup_ino=%lu frn_bdi_id=%u frn_memcg_id=%u",
333 __entry->name,
334 (unsigned long)__entry->cgroup_ino,
335 __entry->frn_bdi_id,
336 __entry->frn_memcg_id
337 )
338);
339#endif
340
341DECLARE_EVENT_CLASS(writeback_write_inode_template,
342
343 TP_PROTO(struct inode *inode, struct writeback_control *wbc),
344
345 TP_ARGS(inode, wbc),
346
347 TP_STRUCT__entry (
348 __array(char, name, 32)
349 __field(ino_t, ino)
350 __field(int, sync_mode)
351 __field(ino_t, cgroup_ino)
352 ),
353
354 TP_fast_assign(
355 strscpy_pad(__entry->name,
356 bdi_dev_name(inode_to_bdi(inode)), 32);
357 __entry->ino = inode->i_ino;
358 __entry->sync_mode = wbc->sync_mode;
359 __entry->cgroup_ino = __trace_wbc_assign_cgroup(wbc);
360 ),
361
362 TP_printk("bdi %s: ino=%lu sync_mode=%d cgroup_ino=%lu",
363 __entry->name,
364 (unsigned long)__entry->ino,
365 __entry->sync_mode,
366 (unsigned long)__entry->cgroup_ino
367 )
368);
369
370DEFINE_EVENT(writeback_write_inode_template, writeback_write_inode_start,
371
372 TP_PROTO(struct inode *inode, struct writeback_control *wbc),
373
374 TP_ARGS(inode, wbc)
375);
376
377DEFINE_EVENT(writeback_write_inode_template, writeback_write_inode,
378
379 TP_PROTO(struct inode *inode, struct writeback_control *wbc),
380
381 TP_ARGS(inode, wbc)
382);
383
384DECLARE_EVENT_CLASS(writeback_work_class,
385 TP_PROTO(struct bdi_writeback *wb, struct wb_writeback_work *work),
386 TP_ARGS(wb, work),
387 TP_STRUCT__entry(
388 __array(char, name, 32)
389 __field(long, nr_pages)
390 __field(dev_t, sb_dev)
391 __field(int, sync_mode)
392 __field(int, for_kupdate)
393 __field(int, range_cyclic)
394 __field(int, for_background)
395 __field(int, reason)
396 __field(ino_t, cgroup_ino)
397 ),
398 TP_fast_assign(
399 strscpy_pad(__entry->name, bdi_dev_name(wb->bdi), 32);
400 __entry->nr_pages = work->nr_pages;
401 __entry->sb_dev = work->sb ? work->sb->s_dev : 0;
402 __entry->sync_mode = work->sync_mode;
403 __entry->for_kupdate = work->for_kupdate;
404 __entry->range_cyclic = work->range_cyclic;
405 __entry->for_background = work->for_background;
406 __entry->reason = work->reason;
407 __entry->cgroup_ino = __trace_wb_assign_cgroup(wb);
408 ),
409 TP_printk("bdi %s: sb_dev %d:%d nr_pages=%ld sync_mode=%d "
410 "kupdate=%d range_cyclic=%d background=%d reason=%s cgroup_ino=%lu",
411 __entry->name,
412 MAJOR(__entry->sb_dev), MINOR(__entry->sb_dev),
413 __entry->nr_pages,
414 __entry->sync_mode,
415 __entry->for_kupdate,
416 __entry->range_cyclic,
417 __entry->for_background,
418 __print_symbolic(__entry->reason, WB_WORK_REASON),
419 (unsigned long)__entry->cgroup_ino
420 )
421);
422#define DEFINE_WRITEBACK_WORK_EVENT(name) \
423DEFINE_EVENT(writeback_work_class, name, \
424 TP_PROTO(struct bdi_writeback *wb, struct wb_writeback_work *work), \
425 TP_ARGS(wb, work))
426DEFINE_WRITEBACK_WORK_EVENT(writeback_queue);
427DEFINE_WRITEBACK_WORK_EVENT(writeback_exec);
428DEFINE_WRITEBACK_WORK_EVENT(writeback_start);
429DEFINE_WRITEBACK_WORK_EVENT(writeback_written);
430DEFINE_WRITEBACK_WORK_EVENT(writeback_wait);
431
432TRACE_EVENT(writeback_pages_written,
433 TP_PROTO(long pages_written),
434 TP_ARGS(pages_written),
435 TP_STRUCT__entry(
436 __field(long, pages)
437 ),
438 TP_fast_assign(
439 __entry->pages = pages_written;
440 ),
441 TP_printk("%ld", __entry->pages)
442);
443
444DECLARE_EVENT_CLASS(writeback_class,
445 TP_PROTO(struct bdi_writeback *wb),
446 TP_ARGS(wb),
447 TP_STRUCT__entry(
448 __array(char, name, 32)
449 __field(ino_t, cgroup_ino)
450 ),
451 TP_fast_assign(
452 strscpy_pad(__entry->name, bdi_dev_name(wb->bdi), 32);
453 __entry->cgroup_ino = __trace_wb_assign_cgroup(wb);
454 ),
455 TP_printk("bdi %s: cgroup_ino=%lu",
456 __entry->name,
457 (unsigned long)__entry->cgroup_ino
458 )
459);
460#define DEFINE_WRITEBACK_EVENT(name) \
461DEFINE_EVENT(writeback_class, name, \
462 TP_PROTO(struct bdi_writeback *wb), \
463 TP_ARGS(wb))
464
465DEFINE_WRITEBACK_EVENT(writeback_wake_background);
466
467TRACE_EVENT(writeback_bdi_register,
468 TP_PROTO(struct backing_dev_info *bdi),
469 TP_ARGS(bdi),
470 TP_STRUCT__entry(
471 __array(char, name, 32)
472 ),
473 TP_fast_assign(
474 strscpy_pad(__entry->name, bdi_dev_name(bdi), 32);
475 ),
476 TP_printk("bdi %s",
477 __entry->name
478 )
479);
480
481DECLARE_EVENT_CLASS(wbc_class,
482 TP_PROTO(struct writeback_control *wbc, struct backing_dev_info *bdi),
483 TP_ARGS(wbc, bdi),
484 TP_STRUCT__entry(
485 __array(char, name, 32)
486 __field(long, nr_to_write)
487 __field(long, pages_skipped)
488 __field(int, sync_mode)
489 __field(int, for_kupdate)
490 __field(int, for_background)
491 __field(int, range_cyclic)
492 __field(long, range_start)
493 __field(long, range_end)
494 __field(ino_t, cgroup_ino)
495 ),
496
497 TP_fast_assign(
498 strscpy_pad(__entry->name, bdi_dev_name(bdi), 32);
499 __entry->nr_to_write = wbc->nr_to_write;
500 __entry->pages_skipped = wbc->pages_skipped;
501 __entry->sync_mode = wbc->sync_mode;
502 __entry->for_kupdate = wbc->for_kupdate;
503 __entry->for_background = wbc->for_background;
504 __entry->range_cyclic = wbc->range_cyclic;
505 __entry->range_start = (long)wbc->range_start;
506 __entry->range_end = (long)wbc->range_end;
507 __entry->cgroup_ino = __trace_wbc_assign_cgroup(wbc);
508 ),
509
510 TP_printk("bdi %s: towrt=%ld skip=%ld mode=%d kupd=%d bgrd=%d "
511 "cyclic=%d start=0x%lx end=0x%lx cgroup_ino=%lu",
512 __entry->name,
513 __entry->nr_to_write,
514 __entry->pages_skipped,
515 __entry->sync_mode,
516 __entry->for_kupdate,
517 __entry->for_background,
518 __entry->range_cyclic,
519 __entry->range_start,
520 __entry->range_end,
521 (unsigned long)__entry->cgroup_ino
522 )
523)
524
525#define DEFINE_WBC_EVENT(name) \
526DEFINE_EVENT(wbc_class, name, \
527 TP_PROTO(struct writeback_control *wbc, struct backing_dev_info *bdi), \
528 TP_ARGS(wbc, bdi))
529DEFINE_WBC_EVENT(wbc_writepage);
530
531TRACE_EVENT(writeback_queue_io,
532 TP_PROTO(struct bdi_writeback *wb,
533 struct wb_writeback_work *work,
534 unsigned long dirtied_before,
535 int moved),
536 TP_ARGS(wb, work, dirtied_before, moved),
537 TP_STRUCT__entry(
538 __array(char, name, 32)
539 __field(unsigned long, older)
540 __field(long, age)
541 __field(int, moved)
542 __field(int, reason)
543 __field(ino_t, cgroup_ino)
544 ),
545 TP_fast_assign(
546 strscpy_pad(__entry->name, bdi_dev_name(wb->bdi), 32);
547 __entry->older = dirtied_before;
548 __entry->age = (jiffies - dirtied_before) * 1000 / HZ;
549 __entry->moved = moved;
550 __entry->reason = work->reason;
551 __entry->cgroup_ino = __trace_wb_assign_cgroup(wb);
552 ),
553 TP_printk("bdi %s: older=%lu age=%ld enqueue=%d reason=%s cgroup_ino=%lu",
554 __entry->name,
555 __entry->older, /* dirtied_before in jiffies */
556 __entry->age, /* dirtied_before in relative milliseconds */
557 __entry->moved,
558 __print_symbolic(__entry->reason, WB_WORK_REASON),
559 (unsigned long)__entry->cgroup_ino
560 )
561);
562
563TRACE_EVENT(global_dirty_state,
564
565 TP_PROTO(unsigned long background_thresh,
566 unsigned long dirty_thresh
567 ),
568
569 TP_ARGS(background_thresh,
570 dirty_thresh
571 ),
572
573 TP_STRUCT__entry(
574 __field(unsigned long, nr_dirty)
575 __field(unsigned long, nr_writeback)
576 __field(unsigned long, background_thresh)
577 __field(unsigned long, dirty_thresh)
578 __field(unsigned long, dirty_limit)
579 __field(unsigned long, nr_dirtied)
580 __field(unsigned long, nr_written)
581 ),
582
583 TP_fast_assign(
584 __entry->nr_dirty = global_node_page_state(NR_FILE_DIRTY);
585 __entry->nr_writeback = global_node_page_state(NR_WRITEBACK);
586 __entry->nr_dirtied = global_node_page_state(NR_DIRTIED);
587 __entry->nr_written = global_node_page_state(NR_WRITTEN);
588 __entry->background_thresh = background_thresh;
589 __entry->dirty_thresh = dirty_thresh;
590 __entry->dirty_limit = global_wb_domain.dirty_limit;
591 ),
592
593 TP_printk("dirty=%lu writeback=%lu "
594 "bg_thresh=%lu thresh=%lu limit=%lu "
595 "dirtied=%lu written=%lu",
596 __entry->nr_dirty,
597 __entry->nr_writeback,
598 __entry->background_thresh,
599 __entry->dirty_thresh,
600 __entry->dirty_limit,
601 __entry->nr_dirtied,
602 __entry->nr_written
603 )
604);
605
606#define KBps(x) ((x) << (PAGE_SHIFT - 10))
607
608TRACE_EVENT(bdi_dirty_ratelimit,
609
610 TP_PROTO(struct bdi_writeback *wb,
611 unsigned long dirty_rate,
612 unsigned long task_ratelimit),
613
614 TP_ARGS(wb, dirty_rate, task_ratelimit),
615
616 TP_STRUCT__entry(
617 __array(char, bdi, 32)
618 __field(unsigned long, write_bw)
619 __field(unsigned long, avg_write_bw)
620 __field(unsigned long, dirty_rate)
621 __field(unsigned long, dirty_ratelimit)
622 __field(unsigned long, task_ratelimit)
623 __field(unsigned long, balanced_dirty_ratelimit)
624 __field(ino_t, cgroup_ino)
625 ),
626
627 TP_fast_assign(
628 strscpy_pad(__entry->bdi, bdi_dev_name(wb->bdi), 32);
629 __entry->write_bw = KBps(wb->write_bandwidth);
630 __entry->avg_write_bw = KBps(wb->avg_write_bandwidth);
631 __entry->dirty_rate = KBps(dirty_rate);
632 __entry->dirty_ratelimit = KBps(wb->dirty_ratelimit);
633 __entry->task_ratelimit = KBps(task_ratelimit);
634 __entry->balanced_dirty_ratelimit =
635 KBps(wb->balanced_dirty_ratelimit);
636 __entry->cgroup_ino = __trace_wb_assign_cgroup(wb);
637 ),
638
639 TP_printk("bdi %s: "
640 "write_bw=%lu awrite_bw=%lu dirty_rate=%lu "
641 "dirty_ratelimit=%lu task_ratelimit=%lu "
642 "balanced_dirty_ratelimit=%lu cgroup_ino=%lu",
643 __entry->bdi,
644 __entry->write_bw, /* write bandwidth */
645 __entry->avg_write_bw, /* avg write bandwidth */
646 __entry->dirty_rate, /* bdi dirty rate */
647 __entry->dirty_ratelimit, /* base ratelimit */
648 __entry->task_ratelimit, /* ratelimit with position control */
649 __entry->balanced_dirty_ratelimit, /* the balanced ratelimit */
650 (unsigned long)__entry->cgroup_ino
651 )
652);
653
654TRACE_EVENT(balance_dirty_pages,
655
656 TP_PROTO(struct bdi_writeback *wb,
657 struct dirty_throttle_control *dtc,
658 unsigned long dirty_ratelimit,
659 unsigned long task_ratelimit,
660 unsigned long dirtied,
661 unsigned long period,
662 long pause,
663 unsigned long start_time),
664
665 TP_ARGS(wb, dtc,
666 dirty_ratelimit, task_ratelimit,
667 dirtied, period, pause, start_time),
668
669 TP_STRUCT__entry(
670 __array( char, bdi, 32)
671 __field(unsigned long, limit)
672 __field(unsigned long, setpoint)
673 __field(unsigned long, dirty)
674 __field(unsigned long, wb_setpoint)
675 __field(unsigned long, wb_dirty)
676 __field(unsigned long, dirty_ratelimit)
677 __field(unsigned long, task_ratelimit)
678 __field(unsigned int, dirtied)
679 __field(unsigned int, dirtied_pause)
680 __field(unsigned long, paused)
681 __field( long, pause)
682 __field(unsigned long, period)
683 __field( long, think)
684 __field(ino_t, cgroup_ino)
685 ),
686
687 TP_fast_assign(
688 unsigned long freerun = (dtc->thresh + dtc->bg_thresh) / 2;
689 strscpy_pad(__entry->bdi, bdi_dev_name(wb->bdi), 32);
690
691 __entry->limit = dtc->limit;
692 __entry->setpoint = (dtc->limit + freerun) / 2;
693 __entry->dirty = dtc->dirty;
694 __entry->wb_setpoint = __entry->setpoint *
695 dtc->wb_thresh / (dtc->thresh + 1);
696 __entry->wb_dirty = dtc->wb_dirty;
697 __entry->dirty_ratelimit = KBps(dirty_ratelimit);
698 __entry->task_ratelimit = KBps(task_ratelimit);
699 __entry->dirtied = dirtied;
700 __entry->dirtied_pause = current->nr_dirtied_pause;
701 __entry->think = current->dirty_paused_when == 0 ? 0 :
702 (long)(jiffies - current->dirty_paused_when) * 1000/HZ;
703 __entry->period = period * 1000 / HZ;
704 __entry->pause = pause * 1000 / HZ;
705 __entry->paused = (jiffies - start_time) * 1000 / HZ;
706 __entry->cgroup_ino = __trace_wb_assign_cgroup(wb);
707 ),
708
709
710 TP_printk("bdi %s: "
711 "limit=%lu setpoint=%lu dirty=%lu "
712 "wb_setpoint=%lu wb_dirty=%lu "
713 "dirty_ratelimit=%lu task_ratelimit=%lu "
714 "dirtied=%u dirtied_pause=%u "
715 "paused=%lu pause=%ld period=%lu think=%ld cgroup_ino=%lu",
716 __entry->bdi,
717 __entry->limit,
718 __entry->setpoint,
719 __entry->dirty,
720 __entry->wb_setpoint,
721 __entry->wb_dirty,
722 __entry->dirty_ratelimit,
723 __entry->task_ratelimit,
724 __entry->dirtied,
725 __entry->dirtied_pause,
726 __entry->paused, /* ms */
727 __entry->pause, /* ms */
728 __entry->period, /* ms */
729 __entry->think, /* ms */
730 (unsigned long)__entry->cgroup_ino
731 )
732);
733
734TRACE_EVENT(writeback_sb_inodes_requeue,
735
736 TP_PROTO(struct inode *inode),
737 TP_ARGS(inode),
738
739 TP_STRUCT__entry(
740 __array(char, name, 32)
741 __field(ino_t, ino)
742 __field(unsigned long, state)
743 __field(unsigned long, dirtied_when)
744 __field(ino_t, cgroup_ino)
745 ),
746
747 TP_fast_assign(
748 strscpy_pad(__entry->name,
749 bdi_dev_name(inode_to_bdi(inode)), 32);
750 __entry->ino = inode->i_ino;
751 __entry->state = inode_state_read_once(inode);
752 __entry->dirtied_when = inode->dirtied_when;
753 __entry->cgroup_ino = __trace_wb_assign_cgroup(inode_to_wb(inode));
754 ),
755
756 TP_printk("bdi %s: ino=%lu state=%s dirtied_when=%lu age=%lu cgroup_ino=%lu",
757 __entry->name,
758 (unsigned long)__entry->ino,
759 show_inode_state(__entry->state),
760 __entry->dirtied_when,
761 (jiffies - __entry->dirtied_when) / HZ,
762 (unsigned long)__entry->cgroup_ino
763 )
764);
765
766DECLARE_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(char, name, 32)
777 __field(ino_t, 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 __field(ino_t, cgroup_ino)
784 ),
785
786 TP_fast_assign(
787 strscpy_pad(__entry->name,
788 bdi_dev_name(inode_to_bdi(inode)), 32);
789 __entry->ino = inode->i_ino;
790 __entry->state = inode_state_read_once(inode);
791 __entry->dirtied_when = inode->dirtied_when;
792 __entry->writeback_index = inode->i_mapping->writeback_index;
793 __entry->nr_to_write = nr_to_write;
794 __entry->wrote = nr_to_write - wbc->nr_to_write;
795 __entry->cgroup_ino = __trace_wbc_assign_cgroup(wbc);
796 ),
797
798 TP_printk("bdi %s: ino=%lu state=%s dirtied_when=%lu age=%lu "
799 "index=%lu to_write=%ld wrote=%lu cgroup_ino=%lu",
800 __entry->name,
801 (unsigned long)__entry->ino,
802 show_inode_state(__entry->state),
803 __entry->dirtied_when,
804 (jiffies - __entry->dirtied_when) / HZ,
805 __entry->writeback_index,
806 __entry->nr_to_write,
807 __entry->wrote,
808 (unsigned long)__entry->cgroup_ino
809 )
810);
811
812DEFINE_EVENT(writeback_single_inode_template, writeback_single_inode_start,
813 TP_PROTO(struct inode *inode,
814 struct writeback_control *wbc,
815 unsigned long nr_to_write),
816 TP_ARGS(inode, wbc, nr_to_write)
817);
818
819DEFINE_EVENT(writeback_single_inode_template, writeback_single_inode,
820 TP_PROTO(struct inode *inode,
821 struct writeback_control *wbc,
822 unsigned long nr_to_write),
823 TP_ARGS(inode, wbc, nr_to_write)
824);
825
826DECLARE_EVENT_CLASS(writeback_inode_template,
827 TP_PROTO(struct inode *inode),
828
829 TP_ARGS(inode),
830
831 TP_STRUCT__entry(
832 __field( dev_t, dev )
833 __field( ino_t, ino )
834 __field(unsigned long, state )
835 __field( __u16, mode )
836 __field(unsigned long, dirtied_when )
837 ),
838
839 TP_fast_assign(
840 __entry->dev = inode->i_sb->s_dev;
841 __entry->ino = inode->i_ino;
842 __entry->state = inode_state_read_once(inode);
843 __entry->mode = inode->i_mode;
844 __entry->dirtied_when = inode->dirtied_when;
845 ),
846
847 TP_printk("dev %d,%d ino %lu dirtied %lu state %s mode 0%o",
848 MAJOR(__entry->dev), MINOR(__entry->dev),
849 (unsigned long)__entry->ino, __entry->dirtied_when,
850 show_inode_state(__entry->state), __entry->mode)
851);
852
853DEFINE_EVENT(writeback_inode_template, writeback_lazytime,
854 TP_PROTO(struct inode *inode),
855
856 TP_ARGS(inode)
857);
858
859DEFINE_EVENT(writeback_inode_template, writeback_lazytime_iput,
860 TP_PROTO(struct inode *inode),
861
862 TP_ARGS(inode)
863);
864
865DEFINE_EVENT(writeback_inode_template, writeback_dirty_inode_enqueue,
866
867 TP_PROTO(struct inode *inode),
868
869 TP_ARGS(inode)
870);
871
872/*
873 * Inode writeback list tracking.
874 */
875
876DEFINE_EVENT(writeback_inode_template, sb_mark_inode_writeback,
877 TP_PROTO(struct inode *inode),
878 TP_ARGS(inode)
879);
880
881DEFINE_EVENT(writeback_inode_template, sb_clear_inode_writeback,
882 TP_PROTO(struct inode *inode),
883 TP_ARGS(inode)
884);
885
886#endif /* _TRACE_WRITEBACK_H */
887
888/* This part must be outside protection */
889#include <trace/define_trace.h>
890

source code of linux/include/trace/events/writeback.h