Merge tag 'device-for-3.4' of git://git.kernel.org/pub/scm/linux/kernel/git/paulg...
[linux-2.6.git] / include / trace / events / writeback.h
1 #undef TRACE_SYSTEM
2 #define TRACE_SYSTEM writeback
3
4 #if !defined(_TRACE_WRITEBACK_H) || defined(TRACE_HEADER_MULTI_READ)
5 #define _TRACE_WRITEBACK_H
6
7 #include <linux/backing-dev.h>
8 #include <linux/writeback.h>
9
10 #define show_inode_state(state)                                 \
11         __print_flags(state, "|",                               \
12                 {I_DIRTY_SYNC,          "I_DIRTY_SYNC"},        \
13                 {I_DIRTY_DATASYNC,      "I_DIRTY_DATASYNC"},    \
14                 {I_DIRTY_PAGES,         "I_DIRTY_PAGES"},       \
15                 {I_NEW,                 "I_NEW"},               \
16                 {I_WILL_FREE,           "I_WILL_FREE"},         \
17                 {I_FREEING,             "I_FREEING"},           \
18                 {I_CLEAR,               "I_CLEAR"},             \
19                 {I_SYNC,                "I_SYNC"},              \
20                 {I_REFERENCED,          "I_REFERENCED"}         \
21         )
22
23 #define WB_WORK_REASON                                                  \
24                 {WB_REASON_BACKGROUND,          "background"},          \
25                 {WB_REASON_TRY_TO_FREE_PAGES,   "try_to_free_pages"},   \
26                 {WB_REASON_SYNC,                "sync"},                \
27                 {WB_REASON_PERIODIC,            "periodic"},            \
28                 {WB_REASON_LAPTOP_TIMER,        "laptop_timer"},        \
29                 {WB_REASON_FREE_MORE_MEM,       "free_more_memory"},    \
30                 {WB_REASON_FS_FREE_SPACE,       "fs_free_space"},       \
31                 {WB_REASON_FORKER_THREAD,       "forker_thread"}
32
33 struct wb_writeback_work;
34
35 DECLARE_EVENT_CLASS(writeback_work_class,
36         TP_PROTO(struct backing_dev_info *bdi, struct wb_writeback_work *work),
37         TP_ARGS(bdi, work),
38         TP_STRUCT__entry(
39                 __array(char, name, 32)
40                 __field(long, nr_pages)
41                 __field(dev_t, sb_dev)
42                 __field(int, sync_mode)
43                 __field(int, for_kupdate)
44                 __field(int, range_cyclic)
45                 __field(int, for_background)
46                 __field(int, reason)
47         ),
48         TP_fast_assign(
49                 struct device *dev = bdi->dev;
50                 if (!dev)
51                         dev = default_backing_dev_info.dev;
52                 strncpy(__entry->name, dev_name(dev), 32);
53                 __entry->nr_pages = work->nr_pages;
54                 __entry->sb_dev = work->sb ? work->sb->s_dev : 0;
55                 __entry->sync_mode = work->sync_mode;
56                 __entry->for_kupdate = work->for_kupdate;
57                 __entry->range_cyclic = work->range_cyclic;
58                 __entry->for_background = work->for_background;
59                 __entry->reason = work->reason;
60         ),
61         TP_printk("bdi %s: sb_dev %d:%d nr_pages=%ld sync_mode=%d "
62                   "kupdate=%d range_cyclic=%d background=%d reason=%s",
63                   __entry->name,
64                   MAJOR(__entry->sb_dev), MINOR(__entry->sb_dev),
65                   __entry->nr_pages,
66                   __entry->sync_mode,
67                   __entry->for_kupdate,
68                   __entry->range_cyclic,
69                   __entry->for_background,
70                   __print_symbolic(__entry->reason, WB_WORK_REASON)
71         )
72 );
73 #define DEFINE_WRITEBACK_WORK_EVENT(name) \
74 DEFINE_EVENT(writeback_work_class, name, \
75         TP_PROTO(struct backing_dev_info *bdi, struct wb_writeback_work *work), \
76         TP_ARGS(bdi, work))
77 DEFINE_WRITEBACK_WORK_EVENT(writeback_nothread);
78 DEFINE_WRITEBACK_WORK_EVENT(writeback_queue);
79 DEFINE_WRITEBACK_WORK_EVENT(writeback_exec);
80 DEFINE_WRITEBACK_WORK_EVENT(writeback_start);
81 DEFINE_WRITEBACK_WORK_EVENT(writeback_written);
82 DEFINE_WRITEBACK_WORK_EVENT(writeback_wait);
83
84 TRACE_EVENT(writeback_pages_written,
85         TP_PROTO(long pages_written),
86         TP_ARGS(pages_written),
87         TP_STRUCT__entry(
88                 __field(long,           pages)
89         ),
90         TP_fast_assign(
91                 __entry->pages          = pages_written;
92         ),
93         TP_printk("%ld", __entry->pages)
94 );
95
96 DECLARE_EVENT_CLASS(writeback_class,
97         TP_PROTO(struct backing_dev_info *bdi),
98         TP_ARGS(bdi),
99         TP_STRUCT__entry(
100                 __array(char, name, 32)
101         ),
102         TP_fast_assign(
103                 strncpy(__entry->name, dev_name(bdi->dev), 32);
104         ),
105         TP_printk("bdi %s",
106                   __entry->name
107         )
108 );
109 #define DEFINE_WRITEBACK_EVENT(name) \
110 DEFINE_EVENT(writeback_class, name, \
111         TP_PROTO(struct backing_dev_info *bdi), \
112         TP_ARGS(bdi))
113
114 DEFINE_WRITEBACK_EVENT(writeback_nowork);
115 DEFINE_WRITEBACK_EVENT(writeback_wake_background);
116 DEFINE_WRITEBACK_EVENT(writeback_wake_thread);
117 DEFINE_WRITEBACK_EVENT(writeback_wake_forker_thread);
118 DEFINE_WRITEBACK_EVENT(writeback_bdi_register);
119 DEFINE_WRITEBACK_EVENT(writeback_bdi_unregister);
120 DEFINE_WRITEBACK_EVENT(writeback_thread_start);
121 DEFINE_WRITEBACK_EVENT(writeback_thread_stop);
122
123 DECLARE_EVENT_CLASS(wbc_class,
124         TP_PROTO(struct writeback_control *wbc, struct backing_dev_info *bdi),
125         TP_ARGS(wbc, bdi),
126         TP_STRUCT__entry(
127                 __array(char, name, 32)
128                 __field(long, nr_to_write)
129                 __field(long, pages_skipped)
130                 __field(int, sync_mode)
131                 __field(int, for_kupdate)
132                 __field(int, for_background)
133                 __field(int, for_reclaim)
134                 __field(int, range_cyclic)
135                 __field(long, range_start)
136                 __field(long, range_end)
137         ),
138
139         TP_fast_assign(
140                 strncpy(__entry->name, dev_name(bdi->dev), 32);
141                 __entry->nr_to_write    = wbc->nr_to_write;
142                 __entry->pages_skipped  = wbc->pages_skipped;
143                 __entry->sync_mode      = wbc->sync_mode;
144                 __entry->for_kupdate    = wbc->for_kupdate;
145                 __entry->for_background = wbc->for_background;
146                 __entry->for_reclaim    = wbc->for_reclaim;
147                 __entry->range_cyclic   = wbc->range_cyclic;
148                 __entry->range_start    = (long)wbc->range_start;
149                 __entry->range_end      = (long)wbc->range_end;
150         ),
151
152         TP_printk("bdi %s: towrt=%ld skip=%ld mode=%d kupd=%d "
153                 "bgrd=%d reclm=%d cyclic=%d "
154                 "start=0x%lx end=0x%lx",
155                 __entry->name,
156                 __entry->nr_to_write,
157                 __entry->pages_skipped,
158                 __entry->sync_mode,
159                 __entry->for_kupdate,
160                 __entry->for_background,
161                 __entry->for_reclaim,
162                 __entry->range_cyclic,
163                 __entry->range_start,
164                 __entry->range_end)
165 )
166
167 #define DEFINE_WBC_EVENT(name) \
168 DEFINE_EVENT(wbc_class, name, \
169         TP_PROTO(struct writeback_control *wbc, struct backing_dev_info *bdi), \
170         TP_ARGS(wbc, bdi))
171 DEFINE_WBC_EVENT(wbc_writepage);
172
173 TRACE_EVENT(writeback_queue_io,
174         TP_PROTO(struct bdi_writeback *wb,
175                  struct wb_writeback_work *work,
176                  int moved),
177         TP_ARGS(wb, work, moved),
178         TP_STRUCT__entry(
179                 __array(char,           name, 32)
180                 __field(unsigned long,  older)
181                 __field(long,           age)
182                 __field(int,            moved)
183                 __field(int,            reason)
184         ),
185         TP_fast_assign(
186                 unsigned long *older_than_this = work->older_than_this;
187                 strncpy(__entry->name, dev_name(wb->bdi->dev), 32);
188                 __entry->older  = older_than_this ?  *older_than_this : 0;
189                 __entry->age    = older_than_this ?
190                                   (jiffies - *older_than_this) * 1000 / HZ : -1;
191                 __entry->moved  = moved;
192                 __entry->reason = work->reason;
193         ),
194         TP_printk("bdi %s: older=%lu age=%ld enqueue=%d reason=%s",
195                 __entry->name,
196                 __entry->older, /* older_than_this in jiffies */
197                 __entry->age,   /* older_than_this in relative milliseconds */
198                 __entry->moved,
199                 __print_symbolic(__entry->reason, WB_WORK_REASON)
200         )
201 );
202
203 TRACE_EVENT(global_dirty_state,
204
205         TP_PROTO(unsigned long background_thresh,
206                  unsigned long dirty_thresh
207         ),
208
209         TP_ARGS(background_thresh,
210                 dirty_thresh
211         ),
212
213         TP_STRUCT__entry(
214                 __field(unsigned long,  nr_dirty)
215                 __field(unsigned long,  nr_writeback)
216                 __field(unsigned long,  nr_unstable)
217                 __field(unsigned long,  background_thresh)
218                 __field(unsigned long,  dirty_thresh)
219                 __field(unsigned long,  dirty_limit)
220                 __field(unsigned long,  nr_dirtied)
221                 __field(unsigned long,  nr_written)
222         ),
223
224         TP_fast_assign(
225                 __entry->nr_dirty       = global_page_state(NR_FILE_DIRTY);
226                 __entry->nr_writeback   = global_page_state(NR_WRITEBACK);
227                 __entry->nr_unstable    = global_page_state(NR_UNSTABLE_NFS);
228                 __entry->nr_dirtied     = global_page_state(NR_DIRTIED);
229                 __entry->nr_written     = global_page_state(NR_WRITTEN);
230                 __entry->background_thresh = background_thresh;
231                 __entry->dirty_thresh   = dirty_thresh;
232                 __entry->dirty_limit = global_dirty_limit;
233         ),
234
235         TP_printk("dirty=%lu writeback=%lu unstable=%lu "
236                   "bg_thresh=%lu thresh=%lu limit=%lu "
237                   "dirtied=%lu written=%lu",
238                   __entry->nr_dirty,
239                   __entry->nr_writeback,
240                   __entry->nr_unstable,
241                   __entry->background_thresh,
242                   __entry->dirty_thresh,
243                   __entry->dirty_limit,
244                   __entry->nr_dirtied,
245                   __entry->nr_written
246         )
247 );
248
249 #define KBps(x)                 ((x) << (PAGE_SHIFT - 10))
250
251 TRACE_EVENT(bdi_dirty_ratelimit,
252
253         TP_PROTO(struct backing_dev_info *bdi,
254                  unsigned long dirty_rate,
255                  unsigned long task_ratelimit),
256
257         TP_ARGS(bdi, dirty_rate, task_ratelimit),
258
259         TP_STRUCT__entry(
260                 __array(char,           bdi, 32)
261                 __field(unsigned long,  write_bw)
262                 __field(unsigned long,  avg_write_bw)
263                 __field(unsigned long,  dirty_rate)
264                 __field(unsigned long,  dirty_ratelimit)
265                 __field(unsigned long,  task_ratelimit)
266                 __field(unsigned long,  balanced_dirty_ratelimit)
267         ),
268
269         TP_fast_assign(
270                 strlcpy(__entry->bdi, dev_name(bdi->dev), 32);
271                 __entry->write_bw       = KBps(bdi->write_bandwidth);
272                 __entry->avg_write_bw   = KBps(bdi->avg_write_bandwidth);
273                 __entry->dirty_rate     = KBps(dirty_rate);
274                 __entry->dirty_ratelimit = KBps(bdi->dirty_ratelimit);
275                 __entry->task_ratelimit = KBps(task_ratelimit);
276                 __entry->balanced_dirty_ratelimit =
277                                           KBps(bdi->balanced_dirty_ratelimit);
278         ),
279
280         TP_printk("bdi %s: "
281                   "write_bw=%lu awrite_bw=%lu dirty_rate=%lu "
282                   "dirty_ratelimit=%lu task_ratelimit=%lu "
283                   "balanced_dirty_ratelimit=%lu",
284                   __entry->bdi,
285                   __entry->write_bw,            /* write bandwidth */
286                   __entry->avg_write_bw,        /* avg write bandwidth */
287                   __entry->dirty_rate,          /* bdi dirty rate */
288                   __entry->dirty_ratelimit,     /* base ratelimit */
289                   __entry->task_ratelimit, /* ratelimit with position control */
290                   __entry->balanced_dirty_ratelimit /* the balanced ratelimit */
291         )
292 );
293
294 TRACE_EVENT(balance_dirty_pages,
295
296         TP_PROTO(struct backing_dev_info *bdi,
297                  unsigned long thresh,
298                  unsigned long bg_thresh,
299                  unsigned long dirty,
300                  unsigned long bdi_thresh,
301                  unsigned long bdi_dirty,
302                  unsigned long dirty_ratelimit,
303                  unsigned long task_ratelimit,
304                  unsigned long dirtied,
305                  unsigned long period,
306                  long pause,
307                  unsigned long start_time),
308
309         TP_ARGS(bdi, thresh, bg_thresh, dirty, bdi_thresh, bdi_dirty,
310                 dirty_ratelimit, task_ratelimit,
311                 dirtied, period, pause, start_time),
312
313         TP_STRUCT__entry(
314                 __array(         char,  bdi, 32)
315                 __field(unsigned long,  limit)
316                 __field(unsigned long,  setpoint)
317                 __field(unsigned long,  dirty)
318                 __field(unsigned long,  bdi_setpoint)
319                 __field(unsigned long,  bdi_dirty)
320                 __field(unsigned long,  dirty_ratelimit)
321                 __field(unsigned long,  task_ratelimit)
322                 __field(unsigned int,   dirtied)
323                 __field(unsigned int,   dirtied_pause)
324                 __field(unsigned long,  paused)
325                 __field(         long,  pause)
326                 __field(unsigned long,  period)
327                 __field(         long,  think)
328         ),
329
330         TP_fast_assign(
331                 unsigned long freerun = (thresh + bg_thresh) / 2;
332                 strlcpy(__entry->bdi, dev_name(bdi->dev), 32);
333
334                 __entry->limit          = global_dirty_limit;
335                 __entry->setpoint       = (global_dirty_limit + freerun) / 2;
336                 __entry->dirty          = dirty;
337                 __entry->bdi_setpoint   = __entry->setpoint *
338                                                 bdi_thresh / (thresh + 1);
339                 __entry->bdi_dirty      = bdi_dirty;
340                 __entry->dirty_ratelimit = KBps(dirty_ratelimit);
341                 __entry->task_ratelimit = KBps(task_ratelimit);
342                 __entry->dirtied        = dirtied;
343                 __entry->dirtied_pause  = current->nr_dirtied_pause;
344                 __entry->think          = current->dirty_paused_when == 0 ? 0 :
345                          (long)(jiffies - current->dirty_paused_when) * 1000/HZ;
346                 __entry->period         = period * 1000 / HZ;
347                 __entry->pause          = pause * 1000 / HZ;
348                 __entry->paused         = (jiffies - start_time) * 1000 / HZ;
349         ),
350
351
352         TP_printk("bdi %s: "
353                   "limit=%lu setpoint=%lu dirty=%lu "
354                   "bdi_setpoint=%lu bdi_dirty=%lu "
355                   "dirty_ratelimit=%lu task_ratelimit=%lu "
356                   "dirtied=%u dirtied_pause=%u "
357                   "paused=%lu pause=%ld period=%lu think=%ld",
358                   __entry->bdi,
359                   __entry->limit,
360                   __entry->setpoint,
361                   __entry->dirty,
362                   __entry->bdi_setpoint,
363                   __entry->bdi_dirty,
364                   __entry->dirty_ratelimit,
365                   __entry->task_ratelimit,
366                   __entry->dirtied,
367                   __entry->dirtied_pause,
368                   __entry->paused,      /* ms */
369                   __entry->pause,       /* ms */
370                   __entry->period,      /* ms */
371                   __entry->think        /* ms */
372           )
373 );
374
375 DECLARE_EVENT_CLASS(writeback_congest_waited_template,
376
377         TP_PROTO(unsigned int usec_timeout, unsigned int usec_delayed),
378
379         TP_ARGS(usec_timeout, usec_delayed),
380
381         TP_STRUCT__entry(
382                 __field(        unsigned int,   usec_timeout    )
383                 __field(        unsigned int,   usec_delayed    )
384         ),
385
386         TP_fast_assign(
387                 __entry->usec_timeout   = usec_timeout;
388                 __entry->usec_delayed   = usec_delayed;
389         ),
390
391         TP_printk("usec_timeout=%u usec_delayed=%u",
392                         __entry->usec_timeout,
393                         __entry->usec_delayed)
394 );
395
396 DEFINE_EVENT(writeback_congest_waited_template, writeback_congestion_wait,
397
398         TP_PROTO(unsigned int usec_timeout, unsigned int usec_delayed),
399
400         TP_ARGS(usec_timeout, usec_delayed)
401 );
402
403 DEFINE_EVENT(writeback_congest_waited_template, writeback_wait_iff_congested,
404
405         TP_PROTO(unsigned int usec_timeout, unsigned int usec_delayed),
406
407         TP_ARGS(usec_timeout, usec_delayed)
408 );
409
410 DECLARE_EVENT_CLASS(writeback_single_inode_template,
411
412         TP_PROTO(struct inode *inode,
413                  struct writeback_control *wbc,
414                  unsigned long nr_to_write
415         ),
416
417         TP_ARGS(inode, wbc, nr_to_write),
418
419         TP_STRUCT__entry(
420                 __array(char, name, 32)
421                 __field(unsigned long, ino)
422                 __field(unsigned long, state)
423                 __field(unsigned long, dirtied_when)
424                 __field(unsigned long, writeback_index)
425                 __field(long, nr_to_write)
426                 __field(unsigned long, wrote)
427         ),
428
429         TP_fast_assign(
430                 strncpy(__entry->name,
431                         dev_name(inode_to_bdi(inode)->dev), 32);
432                 __entry->ino            = inode->i_ino;
433                 __entry->state          = inode->i_state;
434                 __entry->dirtied_when   = inode->dirtied_when;
435                 __entry->writeback_index = inode->i_mapping->writeback_index;
436                 __entry->nr_to_write    = nr_to_write;
437                 __entry->wrote          = nr_to_write - wbc->nr_to_write;
438         ),
439
440         TP_printk("bdi %s: ino=%lu state=%s dirtied_when=%lu age=%lu "
441                   "index=%lu to_write=%ld wrote=%lu",
442                   __entry->name,
443                   __entry->ino,
444                   show_inode_state(__entry->state),
445                   __entry->dirtied_when,
446                   (jiffies - __entry->dirtied_when) / HZ,
447                   __entry->writeback_index,
448                   __entry->nr_to_write,
449                   __entry->wrote
450         )
451 );
452
453 DEFINE_EVENT(writeback_single_inode_template, writeback_single_inode_requeue,
454         TP_PROTO(struct inode *inode,
455                  struct writeback_control *wbc,
456                  unsigned long nr_to_write),
457         TP_ARGS(inode, wbc, nr_to_write)
458 );
459
460 DEFINE_EVENT(writeback_single_inode_template, writeback_single_inode,
461         TP_PROTO(struct inode *inode,
462                  struct writeback_control *wbc,
463                  unsigned long nr_to_write),
464         TP_ARGS(inode, wbc, nr_to_write)
465 );
466
467 #endif /* _TRACE_WRITEBACK_H */
468
469 /* This part must be outside protection */
470 #include <trace/define_trace.h>