~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/include/trace/events/writeback.h

Version: ~ [ linux-5.18 ] ~ [ linux-5.17.9 ] ~ [ linux-5.16.20 ] ~ [ linux-5.15.41 ] ~ [ linux-5.14.21 ] ~ [ linux-5.13.19 ] ~ [ linux-5.12.19 ] ~ [ linux-5.11.22 ] ~ [ linux-5.10.117 ] ~ [ linux-5.9.16 ] ~ [ linux-5.8.18 ] ~ [ linux-5.7.19 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.195 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.244 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.280 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.315 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.302 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.10.108 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.9 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

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

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp