250f6715a4
"[RFC PATCH 0/2] audit of linux/device.h users in include/*" https://lkml.org/lkml/2012/3/4/159 -- Nearly every subsystem has some kind of header with a proto like: void foo(struct device *dev); and yet there is no reason for most of these guys to care about the sub fields within the device struct. This allows us to significantly reduce the scope of headers including headers. For this instance, a reduction of about 40% is achieved by replacing the include with the simple fact that the device is some kind of a struct. Unlike the much larger module.h cleanup, this one is simply two commits. One to fix the implicit <linux/device.h> users, and then one to delete the device.h includes from the linux/include/ dir wherever possible. -----BEGIN PGP SIGNATURE----- Version: GnuPG v1.4.11 (GNU/Linux) iQIcBAABAgAGBQJPbNxLAAoJEOvOhAQsB9HWR6QQAMRUZ94O2069/nW9h4TO/xTr Hq/80lo/TBBiRmob3iWBP76lzgeeMPPVEX1I6N7YYlhL3IL7HsaJH1DvpIPPHXQP GFKcBsZ5ZLV8c4CBDSr+/HFNdhXc0bw0awBjBvR7gAsWuZpNFn4WbhizJi4vWAoE 4ydhPu55G1G8TkBtYLJQ8xavxsmiNBSDhd2i+0vn6EVpgmXynjOMG8qXyaS97Jvg pZLwnN5Wu21coj6+xH3QUKCl1mJ+KGyamWX5gFBVIfsDB3k5H4neijVm7t1en4b0 cWxmXeR/JE3VLEl/17yN2dodD8qw1QzmTWzz1vmwJl2zK+rRRAByBrL0DP7QCwCZ ppeJbdhkMBwqjtknwrmMwsuAzUdJd79GXA+6Vm+xSEkr6FEPK1M0kGbvaqV9Usgd ohMewewbO6ddgR9eF7Kw2FAwo0hwkPNEplXIym9rZzFG1h+T0STGSHvkn7LV765E ul1FapSV3GCxEVRwWTwD28FLU2+0zlkOZ5sxXwNPTT96cNmW+R7TGuslZKNaMNjX q7eBZxo8DtVt/jqJTntR8bs8052c8g1Ac1IKmlW8VSmFwT1M6VBGRn1/JWAhuUgv dBK/FF+I1GJTAJWIhaFcKXLHvmV9uhS6JaIhLMDOetoOkpqSptJ42hDG+89WkFRk o55GQ5TFdoOpqxVzGbvE =3j4+ -----END PGP SIGNATURE----- Merge tag 'device-for-3.4' of git://git.kernel.org/pub/scm/linux/kernel/git/paulg/linux Pull <linux/device.h> avoidance patches from Paul Gortmaker: "Nearly every subsystem has some kind of header with a proto like: void foo(struct device *dev); and yet there is no reason for most of these guys to care about the sub fields within the device struct. This allows us to significantly reduce the scope of headers including headers. For this instance, a reduction of about 40% is achieved by replacing the include with the simple fact that the device is some kind of a struct. Unlike the much larger module.h cleanup, this one is simply two commits. One to fix the implicit <linux/device.h> users, and then one to delete the device.h includes from the linux/include/ dir wherever possible." * tag 'device-for-3.4' of git://git.kernel.org/pub/scm/linux/kernel/git/paulg/linux: device.h: audit and cleanup users in main include dir device.h: cleanup users outside of linux/include (C files)
470 lines
13 KiB
C
470 lines
13 KiB
C
#undef TRACE_SYSTEM
|
|
#define TRACE_SYSTEM writeback
|
|
|
|
#if !defined(_TRACE_WRITEBACK_H) || defined(TRACE_HEADER_MULTI_READ)
|
|
#define _TRACE_WRITEBACK_H
|
|
|
|
#include <linux/backing-dev.h>
|
|
#include <linux/writeback.h>
|
|
|
|
#define show_inode_state(state) \
|
|
__print_flags(state, "|", \
|
|
{I_DIRTY_SYNC, "I_DIRTY_SYNC"}, \
|
|
{I_DIRTY_DATASYNC, "I_DIRTY_DATASYNC"}, \
|
|
{I_DIRTY_PAGES, "I_DIRTY_PAGES"}, \
|
|
{I_NEW, "I_NEW"}, \
|
|
{I_WILL_FREE, "I_WILL_FREE"}, \
|
|
{I_FREEING, "I_FREEING"}, \
|
|
{I_CLEAR, "I_CLEAR"}, \
|
|
{I_SYNC, "I_SYNC"}, \
|
|
{I_REFERENCED, "I_REFERENCED"} \
|
|
)
|
|
|
|
#define WB_WORK_REASON \
|
|
{WB_REASON_BACKGROUND, "background"}, \
|
|
{WB_REASON_TRY_TO_FREE_PAGES, "try_to_free_pages"}, \
|
|
{WB_REASON_SYNC, "sync"}, \
|
|
{WB_REASON_PERIODIC, "periodic"}, \
|
|
{WB_REASON_LAPTOP_TIMER, "laptop_timer"}, \
|
|
{WB_REASON_FREE_MORE_MEM, "free_more_memory"}, \
|
|
{WB_REASON_FS_FREE_SPACE, "fs_free_space"}, \
|
|
{WB_REASON_FORKER_THREAD, "forker_thread"}
|
|
|
|
struct wb_writeback_work;
|
|
|
|
DECLARE_EVENT_CLASS(writeback_work_class,
|
|
TP_PROTO(struct backing_dev_info *bdi, struct wb_writeback_work *work),
|
|
TP_ARGS(bdi, work),
|
|
TP_STRUCT__entry(
|
|
__array(char, name, 32)
|
|
__field(long, nr_pages)
|
|
__field(dev_t, sb_dev)
|
|
__field(int, sync_mode)
|
|
__field(int, for_kupdate)
|
|
__field(int, range_cyclic)
|
|
__field(int, for_background)
|
|
__field(int, reason)
|
|
),
|
|
TP_fast_assign(
|
|
struct device *dev = bdi->dev;
|
|
if (!dev)
|
|
dev = default_backing_dev_info.dev;
|
|
strncpy(__entry->name, dev_name(dev), 32);
|
|
__entry->nr_pages = work->nr_pages;
|
|
__entry->sb_dev = work->sb ? work->sb->s_dev : 0;
|
|
__entry->sync_mode = work->sync_mode;
|
|
__entry->for_kupdate = work->for_kupdate;
|
|
__entry->range_cyclic = work->range_cyclic;
|
|
__entry->for_background = work->for_background;
|
|
__entry->reason = work->reason;
|
|
),
|
|
TP_printk("bdi %s: sb_dev %d:%d nr_pages=%ld sync_mode=%d "
|
|
"kupdate=%d range_cyclic=%d background=%d reason=%s",
|
|
__entry->name,
|
|
MAJOR(__entry->sb_dev), MINOR(__entry->sb_dev),
|
|
__entry->nr_pages,
|
|
__entry->sync_mode,
|
|
__entry->for_kupdate,
|
|
__entry->range_cyclic,
|
|
__entry->for_background,
|
|
__print_symbolic(__entry->reason, WB_WORK_REASON)
|
|
)
|
|
);
|
|
#define DEFINE_WRITEBACK_WORK_EVENT(name) \
|
|
DEFINE_EVENT(writeback_work_class, name, \
|
|
TP_PROTO(struct backing_dev_info *bdi, struct wb_writeback_work *work), \
|
|
TP_ARGS(bdi, work))
|
|
DEFINE_WRITEBACK_WORK_EVENT(writeback_nothread);
|
|
DEFINE_WRITEBACK_WORK_EVENT(writeback_queue);
|
|
DEFINE_WRITEBACK_WORK_EVENT(writeback_exec);
|
|
DEFINE_WRITEBACK_WORK_EVENT(writeback_start);
|
|
DEFINE_WRITEBACK_WORK_EVENT(writeback_written);
|
|
DEFINE_WRITEBACK_WORK_EVENT(writeback_wait);
|
|
|
|
TRACE_EVENT(writeback_pages_written,
|
|
TP_PROTO(long pages_written),
|
|
TP_ARGS(pages_written),
|
|
TP_STRUCT__entry(
|
|
__field(long, pages)
|
|
),
|
|
TP_fast_assign(
|
|
__entry->pages = pages_written;
|
|
),
|
|
TP_printk("%ld", __entry->pages)
|
|
);
|
|
|
|
DECLARE_EVENT_CLASS(writeback_class,
|
|
TP_PROTO(struct backing_dev_info *bdi),
|
|
TP_ARGS(bdi),
|
|
TP_STRUCT__entry(
|
|
__array(char, name, 32)
|
|
),
|
|
TP_fast_assign(
|
|
strncpy(__entry->name, dev_name(bdi->dev), 32);
|
|
),
|
|
TP_printk("bdi %s",
|
|
__entry->name
|
|
)
|
|
);
|
|
#define DEFINE_WRITEBACK_EVENT(name) \
|
|
DEFINE_EVENT(writeback_class, name, \
|
|
TP_PROTO(struct backing_dev_info *bdi), \
|
|
TP_ARGS(bdi))
|
|
|
|
DEFINE_WRITEBACK_EVENT(writeback_nowork);
|
|
DEFINE_WRITEBACK_EVENT(writeback_wake_background);
|
|
DEFINE_WRITEBACK_EVENT(writeback_wake_thread);
|
|
DEFINE_WRITEBACK_EVENT(writeback_wake_forker_thread);
|
|
DEFINE_WRITEBACK_EVENT(writeback_bdi_register);
|
|
DEFINE_WRITEBACK_EVENT(writeback_bdi_unregister);
|
|
DEFINE_WRITEBACK_EVENT(writeback_thread_start);
|
|
DEFINE_WRITEBACK_EVENT(writeback_thread_stop);
|
|
|
|
DECLARE_EVENT_CLASS(wbc_class,
|
|
TP_PROTO(struct writeback_control *wbc, struct backing_dev_info *bdi),
|
|
TP_ARGS(wbc, bdi),
|
|
TP_STRUCT__entry(
|
|
__array(char, name, 32)
|
|
__field(long, nr_to_write)
|
|
__field(long, pages_skipped)
|
|
__field(int, sync_mode)
|
|
__field(int, for_kupdate)
|
|
__field(int, for_background)
|
|
__field(int, for_reclaim)
|
|
__field(int, range_cyclic)
|
|
__field(long, range_start)
|
|
__field(long, range_end)
|
|
),
|
|
|
|
TP_fast_assign(
|
|
strncpy(__entry->name, dev_name(bdi->dev), 32);
|
|
__entry->nr_to_write = wbc->nr_to_write;
|
|
__entry->pages_skipped = wbc->pages_skipped;
|
|
__entry->sync_mode = wbc->sync_mode;
|
|
__entry->for_kupdate = wbc->for_kupdate;
|
|
__entry->for_background = wbc->for_background;
|
|
__entry->for_reclaim = wbc->for_reclaim;
|
|
__entry->range_cyclic = wbc->range_cyclic;
|
|
__entry->range_start = (long)wbc->range_start;
|
|
__entry->range_end = (long)wbc->range_end;
|
|
),
|
|
|
|
TP_printk("bdi %s: towrt=%ld skip=%ld mode=%d kupd=%d "
|
|
"bgrd=%d reclm=%d cyclic=%d "
|
|
"start=0x%lx end=0x%lx",
|
|
__entry->name,
|
|
__entry->nr_to_write,
|
|
__entry->pages_skipped,
|
|
__entry->sync_mode,
|
|
__entry->for_kupdate,
|
|
__entry->for_background,
|
|
__entry->for_reclaim,
|
|
__entry->range_cyclic,
|
|
__entry->range_start,
|
|
__entry->range_end)
|
|
)
|
|
|
|
#define DEFINE_WBC_EVENT(name) \
|
|
DEFINE_EVENT(wbc_class, name, \
|
|
TP_PROTO(struct writeback_control *wbc, struct backing_dev_info *bdi), \
|
|
TP_ARGS(wbc, bdi))
|
|
DEFINE_WBC_EVENT(wbc_writepage);
|
|
|
|
TRACE_EVENT(writeback_queue_io,
|
|
TP_PROTO(struct bdi_writeback *wb,
|
|
struct wb_writeback_work *work,
|
|
int moved),
|
|
TP_ARGS(wb, work, moved),
|
|
TP_STRUCT__entry(
|
|
__array(char, name, 32)
|
|
__field(unsigned long, older)
|
|
__field(long, age)
|
|
__field(int, moved)
|
|
__field(int, reason)
|
|
),
|
|
TP_fast_assign(
|
|
unsigned long *older_than_this = work->older_than_this;
|
|
strncpy(__entry->name, dev_name(wb->bdi->dev), 32);
|
|
__entry->older = older_than_this ? *older_than_this : 0;
|
|
__entry->age = older_than_this ?
|
|
(jiffies - *older_than_this) * 1000 / HZ : -1;
|
|
__entry->moved = moved;
|
|
__entry->reason = work->reason;
|
|
),
|
|
TP_printk("bdi %s: older=%lu age=%ld enqueue=%d reason=%s",
|
|
__entry->name,
|
|
__entry->older, /* older_than_this in jiffies */
|
|
__entry->age, /* older_than_this in relative milliseconds */
|
|
__entry->moved,
|
|
__print_symbolic(__entry->reason, WB_WORK_REASON)
|
|
)
|
|
);
|
|
|
|
TRACE_EVENT(global_dirty_state,
|
|
|
|
TP_PROTO(unsigned long background_thresh,
|
|
unsigned long dirty_thresh
|
|
),
|
|
|
|
TP_ARGS(background_thresh,
|
|
dirty_thresh
|
|
),
|
|
|
|
TP_STRUCT__entry(
|
|
__field(unsigned long, nr_dirty)
|
|
__field(unsigned long, nr_writeback)
|
|
__field(unsigned long, nr_unstable)
|
|
__field(unsigned long, background_thresh)
|
|
__field(unsigned long, dirty_thresh)
|
|
__field(unsigned long, dirty_limit)
|
|
__field(unsigned long, nr_dirtied)
|
|
__field(unsigned long, nr_written)
|
|
),
|
|
|
|
TP_fast_assign(
|
|
__entry->nr_dirty = global_page_state(NR_FILE_DIRTY);
|
|
__entry->nr_writeback = global_page_state(NR_WRITEBACK);
|
|
__entry->nr_unstable = global_page_state(NR_UNSTABLE_NFS);
|
|
__entry->nr_dirtied = global_page_state(NR_DIRTIED);
|
|
__entry->nr_written = global_page_state(NR_WRITTEN);
|
|
__entry->background_thresh = background_thresh;
|
|
__entry->dirty_thresh = dirty_thresh;
|
|
__entry->dirty_limit = global_dirty_limit;
|
|
),
|
|
|
|
TP_printk("dirty=%lu writeback=%lu unstable=%lu "
|
|
"bg_thresh=%lu thresh=%lu limit=%lu "
|
|
"dirtied=%lu written=%lu",
|
|
__entry->nr_dirty,
|
|
__entry->nr_writeback,
|
|
__entry->nr_unstable,
|
|
__entry->background_thresh,
|
|
__entry->dirty_thresh,
|
|
__entry->dirty_limit,
|
|
__entry->nr_dirtied,
|
|
__entry->nr_written
|
|
)
|
|
);
|
|
|
|
#define KBps(x) ((x) << (PAGE_SHIFT - 10))
|
|
|
|
TRACE_EVENT(bdi_dirty_ratelimit,
|
|
|
|
TP_PROTO(struct backing_dev_info *bdi,
|
|
unsigned long dirty_rate,
|
|
unsigned long task_ratelimit),
|
|
|
|
TP_ARGS(bdi, dirty_rate, task_ratelimit),
|
|
|
|
TP_STRUCT__entry(
|
|
__array(char, bdi, 32)
|
|
__field(unsigned long, write_bw)
|
|
__field(unsigned long, avg_write_bw)
|
|
__field(unsigned long, dirty_rate)
|
|
__field(unsigned long, dirty_ratelimit)
|
|
__field(unsigned long, task_ratelimit)
|
|
__field(unsigned long, balanced_dirty_ratelimit)
|
|
),
|
|
|
|
TP_fast_assign(
|
|
strlcpy(__entry->bdi, dev_name(bdi->dev), 32);
|
|
__entry->write_bw = KBps(bdi->write_bandwidth);
|
|
__entry->avg_write_bw = KBps(bdi->avg_write_bandwidth);
|
|
__entry->dirty_rate = KBps(dirty_rate);
|
|
__entry->dirty_ratelimit = KBps(bdi->dirty_ratelimit);
|
|
__entry->task_ratelimit = KBps(task_ratelimit);
|
|
__entry->balanced_dirty_ratelimit =
|
|
KBps(bdi->balanced_dirty_ratelimit);
|
|
),
|
|
|
|
TP_printk("bdi %s: "
|
|
"write_bw=%lu awrite_bw=%lu dirty_rate=%lu "
|
|
"dirty_ratelimit=%lu task_ratelimit=%lu "
|
|
"balanced_dirty_ratelimit=%lu",
|
|
__entry->bdi,
|
|
__entry->write_bw, /* write bandwidth */
|
|
__entry->avg_write_bw, /* avg write bandwidth */
|
|
__entry->dirty_rate, /* bdi dirty rate */
|
|
__entry->dirty_ratelimit, /* base ratelimit */
|
|
__entry->task_ratelimit, /* ratelimit with position control */
|
|
__entry->balanced_dirty_ratelimit /* the balanced ratelimit */
|
|
)
|
|
);
|
|
|
|
TRACE_EVENT(balance_dirty_pages,
|
|
|
|
TP_PROTO(struct backing_dev_info *bdi,
|
|
unsigned long thresh,
|
|
unsigned long bg_thresh,
|
|
unsigned long dirty,
|
|
unsigned long bdi_thresh,
|
|
unsigned long bdi_dirty,
|
|
unsigned long dirty_ratelimit,
|
|
unsigned long task_ratelimit,
|
|
unsigned long dirtied,
|
|
unsigned long period,
|
|
long pause,
|
|
unsigned long start_time),
|
|
|
|
TP_ARGS(bdi, thresh, bg_thresh, dirty, bdi_thresh, bdi_dirty,
|
|
dirty_ratelimit, task_ratelimit,
|
|
dirtied, period, pause, start_time),
|
|
|
|
TP_STRUCT__entry(
|
|
__array( char, bdi, 32)
|
|
__field(unsigned long, limit)
|
|
__field(unsigned long, setpoint)
|
|
__field(unsigned long, dirty)
|
|
__field(unsigned long, bdi_setpoint)
|
|
__field(unsigned long, bdi_dirty)
|
|
__field(unsigned long, dirty_ratelimit)
|
|
__field(unsigned long, task_ratelimit)
|
|
__field(unsigned int, dirtied)
|
|
__field(unsigned int, dirtied_pause)
|
|
__field(unsigned long, paused)
|
|
__field( long, pause)
|
|
__field(unsigned long, period)
|
|
__field( long, think)
|
|
),
|
|
|
|
TP_fast_assign(
|
|
unsigned long freerun = (thresh + bg_thresh) / 2;
|
|
strlcpy(__entry->bdi, dev_name(bdi->dev), 32);
|
|
|
|
__entry->limit = global_dirty_limit;
|
|
__entry->setpoint = (global_dirty_limit + freerun) / 2;
|
|
__entry->dirty = dirty;
|
|
__entry->bdi_setpoint = __entry->setpoint *
|
|
bdi_thresh / (thresh + 1);
|
|
__entry->bdi_dirty = bdi_dirty;
|
|
__entry->dirty_ratelimit = KBps(dirty_ratelimit);
|
|
__entry->task_ratelimit = KBps(task_ratelimit);
|
|
__entry->dirtied = dirtied;
|
|
__entry->dirtied_pause = current->nr_dirtied_pause;
|
|
__entry->think = current->dirty_paused_when == 0 ? 0 :
|
|
(long)(jiffies - current->dirty_paused_when) * 1000/HZ;
|
|
__entry->period = period * 1000 / HZ;
|
|
__entry->pause = pause * 1000 / HZ;
|
|
__entry->paused = (jiffies - start_time) * 1000 / HZ;
|
|
),
|
|
|
|
|
|
TP_printk("bdi %s: "
|
|
"limit=%lu setpoint=%lu dirty=%lu "
|
|
"bdi_setpoint=%lu bdi_dirty=%lu "
|
|
"dirty_ratelimit=%lu task_ratelimit=%lu "
|
|
"dirtied=%u dirtied_pause=%u "
|
|
"paused=%lu pause=%ld period=%lu think=%ld",
|
|
__entry->bdi,
|
|
__entry->limit,
|
|
__entry->setpoint,
|
|
__entry->dirty,
|
|
__entry->bdi_setpoint,
|
|
__entry->bdi_dirty,
|
|
__entry->dirty_ratelimit,
|
|
__entry->task_ratelimit,
|
|
__entry->dirtied,
|
|
__entry->dirtied_pause,
|
|
__entry->paused, /* ms */
|
|
__entry->pause, /* ms */
|
|
__entry->period, /* ms */
|
|
__entry->think /* ms */
|
|
)
|
|
);
|
|
|
|
DECLARE_EVENT_CLASS(writeback_congest_waited_template,
|
|
|
|
TP_PROTO(unsigned int usec_timeout, unsigned int usec_delayed),
|
|
|
|
TP_ARGS(usec_timeout, usec_delayed),
|
|
|
|
TP_STRUCT__entry(
|
|
__field( unsigned int, usec_timeout )
|
|
__field( unsigned int, usec_delayed )
|
|
),
|
|
|
|
TP_fast_assign(
|
|
__entry->usec_timeout = usec_timeout;
|
|
__entry->usec_delayed = usec_delayed;
|
|
),
|
|
|
|
TP_printk("usec_timeout=%u usec_delayed=%u",
|
|
__entry->usec_timeout,
|
|
__entry->usec_delayed)
|
|
);
|
|
|
|
DEFINE_EVENT(writeback_congest_waited_template, writeback_congestion_wait,
|
|
|
|
TP_PROTO(unsigned int usec_timeout, unsigned int usec_delayed),
|
|
|
|
TP_ARGS(usec_timeout, usec_delayed)
|
|
);
|
|
|
|
DEFINE_EVENT(writeback_congest_waited_template, writeback_wait_iff_congested,
|
|
|
|
TP_PROTO(unsigned int usec_timeout, unsigned int usec_delayed),
|
|
|
|
TP_ARGS(usec_timeout, usec_delayed)
|
|
);
|
|
|
|
DECLARE_EVENT_CLASS(writeback_single_inode_template,
|
|
|
|
TP_PROTO(struct inode *inode,
|
|
struct writeback_control *wbc,
|
|
unsigned long nr_to_write
|
|
),
|
|
|
|
TP_ARGS(inode, wbc, nr_to_write),
|
|
|
|
TP_STRUCT__entry(
|
|
__array(char, name, 32)
|
|
__field(unsigned long, ino)
|
|
__field(unsigned long, state)
|
|
__field(unsigned long, dirtied_when)
|
|
__field(unsigned long, writeback_index)
|
|
__field(long, nr_to_write)
|
|
__field(unsigned long, wrote)
|
|
),
|
|
|
|
TP_fast_assign(
|
|
strncpy(__entry->name,
|
|
dev_name(inode_to_bdi(inode)->dev), 32);
|
|
__entry->ino = inode->i_ino;
|
|
__entry->state = inode->i_state;
|
|
__entry->dirtied_when = inode->dirtied_when;
|
|
__entry->writeback_index = inode->i_mapping->writeback_index;
|
|
__entry->nr_to_write = nr_to_write;
|
|
__entry->wrote = nr_to_write - wbc->nr_to_write;
|
|
),
|
|
|
|
TP_printk("bdi %s: ino=%lu state=%s dirtied_when=%lu age=%lu "
|
|
"index=%lu to_write=%ld wrote=%lu",
|
|
__entry->name,
|
|
__entry->ino,
|
|
show_inode_state(__entry->state),
|
|
__entry->dirtied_when,
|
|
(jiffies - __entry->dirtied_when) / HZ,
|
|
__entry->writeback_index,
|
|
__entry->nr_to_write,
|
|
__entry->wrote
|
|
)
|
|
);
|
|
|
|
DEFINE_EVENT(writeback_single_inode_template, writeback_single_inode_requeue,
|
|
TP_PROTO(struct inode *inode,
|
|
struct writeback_control *wbc,
|
|
unsigned long nr_to_write),
|
|
TP_ARGS(inode, wbc, nr_to_write)
|
|
);
|
|
|
|
DEFINE_EVENT(writeback_single_inode_template, writeback_single_inode,
|
|
TP_PROTO(struct inode *inode,
|
|
struct writeback_control *wbc,
|
|
unsigned long nr_to_write),
|
|
TP_ARGS(inode, wbc, nr_to_write)
|
|
);
|
|
|
|
#endif /* _TRACE_WRITEBACK_H */
|
|
|
|
/* This part must be outside protection */
|
|
#include <trace/define_trace.h>
|