diff options
Diffstat (limited to 'include/trace')
-rw-r--r-- | include/trace/events/asoc.h | 45 | ||||
-rw-r--r-- | include/trace/events/block.h | 20 | ||||
-rw-r--r-- | include/trace/events/btrfs.h | 6 | ||||
-rw-r--r-- | include/trace/events/ext3.h | 864 | ||||
-rw-r--r-- | include/trace/events/ext4.h | 93 | ||||
-rw-r--r-- | include/trace/events/jbd.h | 203 | ||||
-rw-r--r-- | include/trace/events/jbd2.h | 36 | ||||
-rw-r--r-- | include/trace/events/nvhost.h | 438 | ||||
-rw-r--r-- | include/trace/events/regmap.h | 145 | ||||
-rw-r--r-- | include/trace/events/sock.h | 68 | ||||
-rw-r--r-- | include/trace/events/udp.h | 32 | ||||
-rw-r--r-- | include/trace/events/vmscan.h | 77 | ||||
-rw-r--r-- | include/trace/events/writeback.h | 183 | ||||
-rw-r--r-- | include/trace/events/xen.h | 506 |
14 files changed, 2660 insertions, 56 deletions
diff --git a/include/trace/events/asoc.h b/include/trace/events/asoc.h index ae973d2e27a..603f5a0f036 100644 --- a/include/trace/events/asoc.h +++ b/include/trace/events/asoc.h | |||
@@ -9,6 +9,7 @@ | |||
9 | 9 | ||
10 | struct snd_soc_jack; | 10 | struct snd_soc_jack; |
11 | struct snd_soc_codec; | 11 | struct snd_soc_codec; |
12 | struct snd_soc_platform; | ||
12 | struct snd_soc_card; | 13 | struct snd_soc_card; |
13 | struct snd_soc_dapm_widget; | 14 | struct snd_soc_dapm_widget; |
14 | 15 | ||
@@ -59,6 +60,50 @@ DEFINE_EVENT(snd_soc_reg, snd_soc_reg_read, | |||
59 | 60 | ||
60 | ); | 61 | ); |
61 | 62 | ||
63 | DECLARE_EVENT_CLASS(snd_soc_preg, | ||
64 | |||
65 | TP_PROTO(struct snd_soc_platform *platform, unsigned int reg, | ||
66 | unsigned int val), | ||
67 | |||
68 | TP_ARGS(platform, reg, val), | ||
69 | |||
70 | TP_STRUCT__entry( | ||
71 | __string( name, platform->name ) | ||
72 | __field( int, id ) | ||
73 | __field( unsigned int, reg ) | ||
74 | __field( unsigned int, val ) | ||
75 | ), | ||
76 | |||
77 | TP_fast_assign( | ||
78 | __assign_str(name, platform->name); | ||
79 | __entry->id = platform->id; | ||
80 | __entry->reg = reg; | ||
81 | __entry->val = val; | ||
82 | ), | ||
83 | |||
84 | TP_printk("platform=%s.%d reg=%x val=%x", __get_str(name), | ||
85 | (int)__entry->id, (unsigned int)__entry->reg, | ||
86 | (unsigned int)__entry->val) | ||
87 | ); | ||
88 | |||
89 | DEFINE_EVENT(snd_soc_preg, snd_soc_preg_write, | ||
90 | |||
91 | TP_PROTO(struct snd_soc_platform *platform, unsigned int reg, | ||
92 | unsigned int val), | ||
93 | |||
94 | TP_ARGS(platform, reg, val) | ||
95 | |||
96 | ); | ||
97 | |||
98 | DEFINE_EVENT(snd_soc_preg, snd_soc_preg_read, | ||
99 | |||
100 | TP_PROTO(struct snd_soc_platform *platform, unsigned int reg, | ||
101 | unsigned int val), | ||
102 | |||
103 | TP_ARGS(platform, reg, val) | ||
104 | |||
105 | ); | ||
106 | |||
62 | DECLARE_EVENT_CLASS(snd_soc_card, | 107 | DECLARE_EVENT_CLASS(snd_soc_card, |
63 | 108 | ||
64 | TP_PROTO(struct snd_soc_card *card, int val), | 109 | TP_PROTO(struct snd_soc_card *card, int val), |
diff --git a/include/trace/events/block.h b/include/trace/events/block.h index bf366547da2..05c5e61f0a7 100644 --- a/include/trace/events/block.h +++ b/include/trace/events/block.h | |||
@@ -8,6 +8,8 @@ | |||
8 | #include <linux/blkdev.h> | 8 | #include <linux/blkdev.h> |
9 | #include <linux/tracepoint.h> | 9 | #include <linux/tracepoint.h> |
10 | 10 | ||
11 | #define RWBS_LEN 8 | ||
12 | |||
11 | DECLARE_EVENT_CLASS(block_rq_with_error, | 13 | DECLARE_EVENT_CLASS(block_rq_with_error, |
12 | 14 | ||
13 | TP_PROTO(struct request_queue *q, struct request *rq), | 15 | TP_PROTO(struct request_queue *q, struct request *rq), |
@@ -19,7 +21,7 @@ DECLARE_EVENT_CLASS(block_rq_with_error, | |||
19 | __field( sector_t, sector ) | 21 | __field( sector_t, sector ) |
20 | __field( unsigned int, nr_sector ) | 22 | __field( unsigned int, nr_sector ) |
21 | __field( int, errors ) | 23 | __field( int, errors ) |
22 | __array( char, rwbs, 6 ) | 24 | __array( char, rwbs, RWBS_LEN ) |
23 | __dynamic_array( char, cmd, blk_cmd_buf_len(rq) ) | 25 | __dynamic_array( char, cmd, blk_cmd_buf_len(rq) ) |
24 | ), | 26 | ), |
25 | 27 | ||
@@ -104,7 +106,7 @@ DECLARE_EVENT_CLASS(block_rq, | |||
104 | __field( sector_t, sector ) | 106 | __field( sector_t, sector ) |
105 | __field( unsigned int, nr_sector ) | 107 | __field( unsigned int, nr_sector ) |
106 | __field( unsigned int, bytes ) | 108 | __field( unsigned int, bytes ) |
107 | __array( char, rwbs, 6 ) | 109 | __array( char, rwbs, RWBS_LEN ) |
108 | __array( char, comm, TASK_COMM_LEN ) | 110 | __array( char, comm, TASK_COMM_LEN ) |
109 | __dynamic_array( char, cmd, blk_cmd_buf_len(rq) ) | 111 | __dynamic_array( char, cmd, blk_cmd_buf_len(rq) ) |
110 | ), | 112 | ), |
@@ -183,7 +185,7 @@ TRACE_EVENT(block_bio_bounce, | |||
183 | __field( dev_t, dev ) | 185 | __field( dev_t, dev ) |
184 | __field( sector_t, sector ) | 186 | __field( sector_t, sector ) |
185 | __field( unsigned int, nr_sector ) | 187 | __field( unsigned int, nr_sector ) |
186 | __array( char, rwbs, 6 ) | 188 | __array( char, rwbs, RWBS_LEN ) |
187 | __array( char, comm, TASK_COMM_LEN ) | 189 | __array( char, comm, TASK_COMM_LEN ) |
188 | ), | 190 | ), |
189 | 191 | ||
@@ -222,7 +224,7 @@ TRACE_EVENT(block_bio_complete, | |||
222 | __field( sector_t, sector ) | 224 | __field( sector_t, sector ) |
223 | __field( unsigned, nr_sector ) | 225 | __field( unsigned, nr_sector ) |
224 | __field( int, error ) | 226 | __field( int, error ) |
225 | __array( char, rwbs, 6 ) | 227 | __array( char, rwbs, RWBS_LEN) |
226 | ), | 228 | ), |
227 | 229 | ||
228 | TP_fast_assign( | 230 | TP_fast_assign( |
@@ -249,7 +251,7 @@ DECLARE_EVENT_CLASS(block_bio, | |||
249 | __field( dev_t, dev ) | 251 | __field( dev_t, dev ) |
250 | __field( sector_t, sector ) | 252 | __field( sector_t, sector ) |
251 | __field( unsigned int, nr_sector ) | 253 | __field( unsigned int, nr_sector ) |
252 | __array( char, rwbs, 6 ) | 254 | __array( char, rwbs, RWBS_LEN ) |
253 | __array( char, comm, TASK_COMM_LEN ) | 255 | __array( char, comm, TASK_COMM_LEN ) |
254 | ), | 256 | ), |
255 | 257 | ||
@@ -321,7 +323,7 @@ DECLARE_EVENT_CLASS(block_get_rq, | |||
321 | __field( dev_t, dev ) | 323 | __field( dev_t, dev ) |
322 | __field( sector_t, sector ) | 324 | __field( sector_t, sector ) |
323 | __field( unsigned int, nr_sector ) | 325 | __field( unsigned int, nr_sector ) |
324 | __array( char, rwbs, 6 ) | 326 | __array( char, rwbs, RWBS_LEN ) |
325 | __array( char, comm, TASK_COMM_LEN ) | 327 | __array( char, comm, TASK_COMM_LEN ) |
326 | ), | 328 | ), |
327 | 329 | ||
@@ -456,7 +458,7 @@ TRACE_EVENT(block_split, | |||
456 | __field( dev_t, dev ) | 458 | __field( dev_t, dev ) |
457 | __field( sector_t, sector ) | 459 | __field( sector_t, sector ) |
458 | __field( sector_t, new_sector ) | 460 | __field( sector_t, new_sector ) |
459 | __array( char, rwbs, 6 ) | 461 | __array( char, rwbs, RWBS_LEN ) |
460 | __array( char, comm, TASK_COMM_LEN ) | 462 | __array( char, comm, TASK_COMM_LEN ) |
461 | ), | 463 | ), |
462 | 464 | ||
@@ -498,7 +500,7 @@ TRACE_EVENT(block_bio_remap, | |||
498 | __field( unsigned int, nr_sector ) | 500 | __field( unsigned int, nr_sector ) |
499 | __field( dev_t, old_dev ) | 501 | __field( dev_t, old_dev ) |
500 | __field( sector_t, old_sector ) | 502 | __field( sector_t, old_sector ) |
501 | __array( char, rwbs, 6 ) | 503 | __array( char, rwbs, RWBS_LEN) |
502 | ), | 504 | ), |
503 | 505 | ||
504 | TP_fast_assign( | 506 | TP_fast_assign( |
@@ -542,7 +544,7 @@ TRACE_EVENT(block_rq_remap, | |||
542 | __field( unsigned int, nr_sector ) | 544 | __field( unsigned int, nr_sector ) |
543 | __field( dev_t, old_dev ) | 545 | __field( dev_t, old_dev ) |
544 | __field( sector_t, old_sector ) | 546 | __field( sector_t, old_sector ) |
545 | __array( char, rwbs, 6 ) | 547 | __array( char, rwbs, RWBS_LEN) |
546 | ), | 548 | ), |
547 | 549 | ||
548 | TP_fast_assign( | 550 | TP_fast_assign( |
diff --git a/include/trace/events/btrfs.h b/include/trace/events/btrfs.h index 4114129f079..b31702ac15b 100644 --- a/include/trace/events/btrfs.h +++ b/include/trace/events/btrfs.h | |||
@@ -284,7 +284,6 @@ DECLARE_EVENT_CLASS(btrfs__writepage, | |||
284 | __field( long, pages_skipped ) | 284 | __field( long, pages_skipped ) |
285 | __field( loff_t, range_start ) | 285 | __field( loff_t, range_start ) |
286 | __field( loff_t, range_end ) | 286 | __field( loff_t, range_end ) |
287 | __field( char, nonblocking ) | ||
288 | __field( char, for_kupdate ) | 287 | __field( char, for_kupdate ) |
289 | __field( char, for_reclaim ) | 288 | __field( char, for_reclaim ) |
290 | __field( char, range_cyclic ) | 289 | __field( char, range_cyclic ) |
@@ -299,7 +298,6 @@ DECLARE_EVENT_CLASS(btrfs__writepage, | |||
299 | __entry->pages_skipped = wbc->pages_skipped; | 298 | __entry->pages_skipped = wbc->pages_skipped; |
300 | __entry->range_start = wbc->range_start; | 299 | __entry->range_start = wbc->range_start; |
301 | __entry->range_end = wbc->range_end; | 300 | __entry->range_end = wbc->range_end; |
302 | __entry->nonblocking = wbc->nonblocking; | ||
303 | __entry->for_kupdate = wbc->for_kupdate; | 301 | __entry->for_kupdate = wbc->for_kupdate; |
304 | __entry->for_reclaim = wbc->for_reclaim; | 302 | __entry->for_reclaim = wbc->for_reclaim; |
305 | __entry->range_cyclic = wbc->range_cyclic; | 303 | __entry->range_cyclic = wbc->range_cyclic; |
@@ -310,13 +308,13 @@ DECLARE_EVENT_CLASS(btrfs__writepage, | |||
310 | 308 | ||
311 | TP_printk("root = %llu(%s), ino = %lu, page_index = %lu, " | 309 | TP_printk("root = %llu(%s), ino = %lu, page_index = %lu, " |
312 | "nr_to_write = %ld, pages_skipped = %ld, range_start = %llu, " | 310 | "nr_to_write = %ld, pages_skipped = %ld, range_start = %llu, " |
313 | "range_end = %llu, nonblocking = %d, for_kupdate = %d, " | 311 | "range_end = %llu, for_kupdate = %d, " |
314 | "for_reclaim = %d, range_cyclic = %d, writeback_index = %lu", | 312 | "for_reclaim = %d, range_cyclic = %d, writeback_index = %lu", |
315 | show_root_type(__entry->root_objectid), | 313 | show_root_type(__entry->root_objectid), |
316 | (unsigned long)__entry->ino, __entry->index, | 314 | (unsigned long)__entry->ino, __entry->index, |
317 | __entry->nr_to_write, __entry->pages_skipped, | 315 | __entry->nr_to_write, __entry->pages_skipped, |
318 | __entry->range_start, __entry->range_end, | 316 | __entry->range_start, __entry->range_end, |
319 | __entry->nonblocking, __entry->for_kupdate, | 317 | __entry->for_kupdate, |
320 | __entry->for_reclaim, __entry->range_cyclic, | 318 | __entry->for_reclaim, __entry->range_cyclic, |
321 | (unsigned long)__entry->writeback_index) | 319 | (unsigned long)__entry->writeback_index) |
322 | ); | 320 | ); |
diff --git a/include/trace/events/ext3.h b/include/trace/events/ext3.h new file mode 100644 index 00000000000..7b53c0573dc --- /dev/null +++ b/include/trace/events/ext3.h | |||
@@ -0,0 +1,864 @@ | |||
1 | #undef TRACE_SYSTEM | ||
2 | #define TRACE_SYSTEM ext3 | ||
3 | |||
4 | #if !defined(_TRACE_EXT3_H) || defined(TRACE_HEADER_MULTI_READ) | ||
5 | #define _TRACE_EXT3_H | ||
6 | |||
7 | #include <linux/tracepoint.h> | ||
8 | |||
9 | TRACE_EVENT(ext3_free_inode, | ||
10 | TP_PROTO(struct inode *inode), | ||
11 | |||
12 | TP_ARGS(inode), | ||
13 | |||
14 | TP_STRUCT__entry( | ||
15 | __field( dev_t, dev ) | ||
16 | __field( ino_t, ino ) | ||
17 | __field( umode_t, mode ) | ||
18 | __field( uid_t, uid ) | ||
19 | __field( gid_t, gid ) | ||
20 | __field( blkcnt_t, blocks ) | ||
21 | ), | ||
22 | |||
23 | TP_fast_assign( | ||
24 | __entry->dev = inode->i_sb->s_dev; | ||
25 | __entry->ino = inode->i_ino; | ||
26 | __entry->mode = inode->i_mode; | ||
27 | __entry->uid = inode->i_uid; | ||
28 | __entry->gid = inode->i_gid; | ||
29 | __entry->blocks = inode->i_blocks; | ||
30 | ), | ||
31 | |||
32 | TP_printk("dev %d,%d ino %lu mode 0%o uid %u gid %u blocks %lu", | ||
33 | MAJOR(__entry->dev), MINOR(__entry->dev), | ||
34 | (unsigned long) __entry->ino, | ||
35 | __entry->mode, __entry->uid, __entry->gid, | ||
36 | (unsigned long) __entry->blocks) | ||
37 | ); | ||
38 | |||
39 | TRACE_EVENT(ext3_request_inode, | ||
40 | TP_PROTO(struct inode *dir, int mode), | ||
41 | |||
42 | TP_ARGS(dir, mode), | ||
43 | |||
44 | TP_STRUCT__entry( | ||
45 | __field( dev_t, dev ) | ||
46 | __field( ino_t, dir ) | ||
47 | __field( umode_t, mode ) | ||
48 | ), | ||
49 | |||
50 | TP_fast_assign( | ||
51 | __entry->dev = dir->i_sb->s_dev; | ||
52 | __entry->dir = dir->i_ino; | ||
53 | __entry->mode = mode; | ||
54 | ), | ||
55 | |||
56 | TP_printk("dev %d,%d dir %lu mode 0%o", | ||
57 | MAJOR(__entry->dev), MINOR(__entry->dev), | ||
58 | (unsigned long) __entry->dir, __entry->mode) | ||
59 | ); | ||
60 | |||
61 | TRACE_EVENT(ext3_allocate_inode, | ||
62 | TP_PROTO(struct inode *inode, struct inode *dir, int mode), | ||
63 | |||
64 | TP_ARGS(inode, dir, mode), | ||
65 | |||
66 | TP_STRUCT__entry( | ||
67 | __field( dev_t, dev ) | ||
68 | __field( ino_t, ino ) | ||
69 | __field( ino_t, dir ) | ||
70 | __field( umode_t, mode ) | ||
71 | ), | ||
72 | |||
73 | TP_fast_assign( | ||
74 | __entry->dev = inode->i_sb->s_dev; | ||
75 | __entry->ino = inode->i_ino; | ||
76 | __entry->dir = dir->i_ino; | ||
77 | __entry->mode = mode; | ||
78 | ), | ||
79 | |||
80 | TP_printk("dev %d,%d ino %lu dir %lu mode 0%o", | ||
81 | MAJOR(__entry->dev), MINOR(__entry->dev), | ||
82 | (unsigned long) __entry->ino, | ||
83 | (unsigned long) __entry->dir, __entry->mode) | ||
84 | ); | ||
85 | |||
86 | TRACE_EVENT(ext3_evict_inode, | ||
87 | TP_PROTO(struct inode *inode), | ||
88 | |||
89 | TP_ARGS(inode), | ||
90 | |||
91 | TP_STRUCT__entry( | ||
92 | __field( dev_t, dev ) | ||
93 | __field( ino_t, ino ) | ||
94 | __field( int, nlink ) | ||
95 | ), | ||
96 | |||
97 | TP_fast_assign( | ||
98 | __entry->dev = inode->i_sb->s_dev; | ||
99 | __entry->ino = inode->i_ino; | ||
100 | __entry->nlink = inode->i_nlink; | ||
101 | ), | ||
102 | |||
103 | TP_printk("dev %d,%d ino %lu nlink %d", | ||
104 | MAJOR(__entry->dev), MINOR(__entry->dev), | ||
105 | (unsigned long) __entry->ino, __entry->nlink) | ||
106 | ); | ||
107 | |||
108 | TRACE_EVENT(ext3_drop_inode, | ||
109 | TP_PROTO(struct inode *inode, int drop), | ||
110 | |||
111 | TP_ARGS(inode, drop), | ||
112 | |||
113 | TP_STRUCT__entry( | ||
114 | __field( dev_t, dev ) | ||
115 | __field( ino_t, ino ) | ||
116 | __field( int, drop ) | ||
117 | ), | ||
118 | |||
119 | TP_fast_assign( | ||
120 | __entry->dev = inode->i_sb->s_dev; | ||
121 | __entry->ino = inode->i_ino; | ||
122 | __entry->drop = drop; | ||
123 | ), | ||
124 | |||
125 | TP_printk("dev %d,%d ino %lu drop %d", | ||
126 | MAJOR(__entry->dev), MINOR(__entry->dev), | ||
127 | (unsigned long) __entry->ino, __entry->drop) | ||
128 | ); | ||
129 | |||
130 | TRACE_EVENT(ext3_mark_inode_dirty, | ||
131 | TP_PROTO(struct inode *inode, unsigned long IP), | ||
132 | |||
133 | TP_ARGS(inode, IP), | ||
134 | |||
135 | TP_STRUCT__entry( | ||
136 | __field( dev_t, dev ) | ||
137 | __field( ino_t, ino ) | ||
138 | __field(unsigned long, ip ) | ||
139 | ), | ||
140 | |||
141 | TP_fast_assign( | ||
142 | __entry->dev = inode->i_sb->s_dev; | ||
143 | __entry->ino = inode->i_ino; | ||
144 | __entry->ip = IP; | ||
145 | ), | ||
146 | |||
147 | TP_printk("dev %d,%d ino %lu caller %pF", | ||
148 | MAJOR(__entry->dev), MINOR(__entry->dev), | ||
149 | (unsigned long) __entry->ino, (void *)__entry->ip) | ||
150 | ); | ||
151 | |||
152 | TRACE_EVENT(ext3_write_begin, | ||
153 | TP_PROTO(struct inode *inode, loff_t pos, unsigned int len, | ||
154 | unsigned int flags), | ||
155 | |||
156 | TP_ARGS(inode, pos, len, flags), | ||
157 | |||
158 | TP_STRUCT__entry( | ||
159 | __field( dev_t, dev ) | ||
160 | __field( ino_t, ino ) | ||
161 | __field( loff_t, pos ) | ||
162 | __field( unsigned int, len ) | ||
163 | __field( unsigned int, flags ) | ||
164 | ), | ||
165 | |||
166 | TP_fast_assign( | ||
167 | __entry->dev = inode->i_sb->s_dev; | ||
168 | __entry->ino = inode->i_ino; | ||
169 | __entry->pos = pos; | ||
170 | __entry->len = len; | ||
171 | __entry->flags = flags; | ||
172 | ), | ||
173 | |||
174 | TP_printk("dev %d,%d ino %lu pos %llu len %u flags %u", | ||
175 | MAJOR(__entry->dev), MINOR(__entry->dev), | ||
176 | (unsigned long) __entry->ino, | ||
177 | (unsigned long long) __entry->pos, __entry->len, | ||
178 | __entry->flags) | ||
179 | ); | ||
180 | |||
181 | DECLARE_EVENT_CLASS(ext3__write_end, | ||
182 | TP_PROTO(struct inode *inode, loff_t pos, unsigned int len, | ||
183 | unsigned int copied), | ||
184 | |||
185 | TP_ARGS(inode, pos, len, copied), | ||
186 | |||
187 | TP_STRUCT__entry( | ||
188 | __field( dev_t, dev ) | ||
189 | __field( ino_t, ino ) | ||
190 | __field( loff_t, pos ) | ||
191 | __field( unsigned int, len ) | ||
192 | __field( unsigned int, copied ) | ||
193 | ), | ||
194 | |||
195 | TP_fast_assign( | ||
196 | __entry->dev = inode->i_sb->s_dev; | ||
197 | __entry->ino = inode->i_ino; | ||
198 | __entry->pos = pos; | ||
199 | __entry->len = len; | ||
200 | __entry->copied = copied; | ||
201 | ), | ||
202 | |||
203 | TP_printk("dev %d,%d ino %lu pos %llu len %u copied %u", | ||
204 | MAJOR(__entry->dev), MINOR(__entry->dev), | ||
205 | (unsigned long) __entry->ino, | ||
206 | (unsigned long long) __entry->pos, __entry->len, | ||
207 | __entry->copied) | ||
208 | ); | ||
209 | |||
210 | DEFINE_EVENT(ext3__write_end, ext3_ordered_write_end, | ||
211 | |||
212 | TP_PROTO(struct inode *inode, loff_t pos, unsigned int len, | ||
213 | unsigned int copied), | ||
214 | |||
215 | TP_ARGS(inode, pos, len, copied) | ||
216 | ); | ||
217 | |||
218 | DEFINE_EVENT(ext3__write_end, ext3_writeback_write_end, | ||
219 | |||
220 | TP_PROTO(struct inode *inode, loff_t pos, unsigned int len, | ||
221 | unsigned int copied), | ||
222 | |||
223 | TP_ARGS(inode, pos, len, copied) | ||
224 | ); | ||
225 | |||
226 | DEFINE_EVENT(ext3__write_end, ext3_journalled_write_end, | ||
227 | |||
228 | TP_PROTO(struct inode *inode, loff_t pos, unsigned int len, | ||
229 | unsigned int copied), | ||
230 | |||
231 | TP_ARGS(inode, pos, len, copied) | ||
232 | ); | ||
233 | |||
234 | DECLARE_EVENT_CLASS(ext3__page_op, | ||
235 | TP_PROTO(struct page *page), | ||
236 | |||
237 | TP_ARGS(page), | ||
238 | |||
239 | TP_STRUCT__entry( | ||
240 | __field( dev_t, dev ) | ||
241 | __field( ino_t, ino ) | ||
242 | __field( pgoff_t, index ) | ||
243 | |||
244 | ), | ||
245 | |||
246 | TP_fast_assign( | ||
247 | __entry->index = page->index; | ||
248 | __entry->ino = page->mapping->host->i_ino; | ||
249 | __entry->dev = page->mapping->host->i_sb->s_dev; | ||
250 | ), | ||
251 | |||
252 | TP_printk("dev %d,%d ino %lu page_index %lu", | ||
253 | MAJOR(__entry->dev), MINOR(__entry->dev), | ||
254 | (unsigned long) __entry->ino, __entry->index) | ||
255 | ); | ||
256 | |||
257 | DEFINE_EVENT(ext3__page_op, ext3_ordered_writepage, | ||
258 | |||
259 | TP_PROTO(struct page *page), | ||
260 | |||
261 | TP_ARGS(page) | ||
262 | ); | ||
263 | |||
264 | DEFINE_EVENT(ext3__page_op, ext3_writeback_writepage, | ||
265 | |||
266 | TP_PROTO(struct page *page), | ||
267 | |||
268 | TP_ARGS(page) | ||
269 | ); | ||
270 | |||
271 | DEFINE_EVENT(ext3__page_op, ext3_journalled_writepage, | ||
272 | |||
273 | TP_PROTO(struct page *page), | ||
274 | |||
275 | TP_ARGS(page) | ||
276 | ); | ||
277 | |||
278 | DEFINE_EVENT(ext3__page_op, ext3_readpage, | ||
279 | |||
280 | TP_PROTO(struct page *page), | ||
281 | |||
282 | TP_ARGS(page) | ||
283 | ); | ||
284 | |||
285 | DEFINE_EVENT(ext3__page_op, ext3_releasepage, | ||
286 | |||
287 | TP_PROTO(struct page *page), | ||
288 | |||
289 | TP_ARGS(page) | ||
290 | ); | ||
291 | |||
292 | TRACE_EVENT(ext3_invalidatepage, | ||
293 | TP_PROTO(struct page *page, unsigned long offset), | ||
294 | |||
295 | TP_ARGS(page, offset), | ||
296 | |||
297 | TP_STRUCT__entry( | ||
298 | __field( pgoff_t, index ) | ||
299 | __field( unsigned long, offset ) | ||
300 | __field( ino_t, ino ) | ||
301 | __field( dev_t, dev ) | ||
302 | |||
303 | ), | ||
304 | |||
305 | TP_fast_assign( | ||
306 | __entry->index = page->index; | ||
307 | __entry->offset = offset; | ||
308 | __entry->ino = page->mapping->host->i_ino; | ||
309 | __entry->dev = page->mapping->host->i_sb->s_dev; | ||
310 | ), | ||
311 | |||
312 | TP_printk("dev %d,%d ino %lu page_index %lu offset %lu", | ||
313 | MAJOR(__entry->dev), MINOR(__entry->dev), | ||
314 | (unsigned long) __entry->ino, | ||
315 | __entry->index, __entry->offset) | ||
316 | ); | ||
317 | |||
318 | TRACE_EVENT(ext3_discard_blocks, | ||
319 | TP_PROTO(struct super_block *sb, unsigned long blk, | ||
320 | unsigned long count), | ||
321 | |||
322 | TP_ARGS(sb, blk, count), | ||
323 | |||
324 | TP_STRUCT__entry( | ||
325 | __field( dev_t, dev ) | ||
326 | __field( unsigned long, blk ) | ||
327 | __field( unsigned long, count ) | ||
328 | |||
329 | ), | ||
330 | |||
331 | TP_fast_assign( | ||
332 | __entry->dev = sb->s_dev; | ||
333 | __entry->blk = blk; | ||
334 | __entry->count = count; | ||
335 | ), | ||
336 | |||
337 | TP_printk("dev %d,%d blk %lu count %lu", | ||
338 | MAJOR(__entry->dev), MINOR(__entry->dev), | ||
339 | __entry->blk, __entry->count) | ||
340 | ); | ||
341 | |||
342 | TRACE_EVENT(ext3_request_blocks, | ||
343 | TP_PROTO(struct inode *inode, unsigned long goal, | ||
344 | unsigned long count), | ||
345 | |||
346 | TP_ARGS(inode, goal, count), | ||
347 | |||
348 | TP_STRUCT__entry( | ||
349 | __field( dev_t, dev ) | ||
350 | __field( ino_t, ino ) | ||
351 | __field( unsigned long, count ) | ||
352 | __field( unsigned long, goal ) | ||
353 | ), | ||
354 | |||
355 | TP_fast_assign( | ||
356 | __entry->dev = inode->i_sb->s_dev; | ||
357 | __entry->ino = inode->i_ino; | ||
358 | __entry->count = count; | ||
359 | __entry->goal = goal; | ||
360 | ), | ||
361 | |||
362 | TP_printk("dev %d,%d ino %lu count %lu goal %lu ", | ||
363 | MAJOR(__entry->dev), MINOR(__entry->dev), | ||
364 | (unsigned long) __entry->ino, | ||
365 | __entry->count, __entry->goal) | ||
366 | ); | ||
367 | |||
368 | TRACE_EVENT(ext3_allocate_blocks, | ||
369 | TP_PROTO(struct inode *inode, unsigned long goal, | ||
370 | unsigned long count, unsigned long block), | ||
371 | |||
372 | TP_ARGS(inode, goal, count, block), | ||
373 | |||
374 | TP_STRUCT__entry( | ||
375 | __field( dev_t, dev ) | ||
376 | __field( ino_t, ino ) | ||
377 | __field( unsigned long, block ) | ||
378 | __field( unsigned long, count ) | ||
379 | __field( unsigned long, goal ) | ||
380 | ), | ||
381 | |||
382 | TP_fast_assign( | ||
383 | __entry->dev = inode->i_sb->s_dev; | ||
384 | __entry->ino = inode->i_ino; | ||
385 | __entry->block = block; | ||
386 | __entry->count = count; | ||
387 | __entry->goal = goal; | ||
388 | ), | ||
389 | |||
390 | TP_printk("dev %d,%d ino %lu count %lu block %lu goal %lu", | ||
391 | MAJOR(__entry->dev), MINOR(__entry->dev), | ||
392 | (unsigned long) __entry->ino, | ||
393 | __entry->count, __entry->block, | ||
394 | __entry->goal) | ||
395 | ); | ||
396 | |||
397 | TRACE_EVENT(ext3_free_blocks, | ||
398 | TP_PROTO(struct inode *inode, unsigned long block, | ||
399 | unsigned long count), | ||
400 | |||
401 | TP_ARGS(inode, block, count), | ||
402 | |||
403 | TP_STRUCT__entry( | ||
404 | __field( dev_t, dev ) | ||
405 | __field( ino_t, ino ) | ||
406 | __field( umode_t, mode ) | ||
407 | __field( unsigned long, block ) | ||
408 | __field( unsigned long, count ) | ||
409 | ), | ||
410 | |||
411 | TP_fast_assign( | ||
412 | __entry->dev = inode->i_sb->s_dev; | ||
413 | __entry->ino = inode->i_ino; | ||
414 | __entry->mode = inode->i_mode; | ||
415 | __entry->block = block; | ||
416 | __entry->count = count; | ||
417 | ), | ||
418 | |||
419 | TP_printk("dev %d,%d ino %lu mode 0%o block %lu count %lu", | ||
420 | MAJOR(__entry->dev), MINOR(__entry->dev), | ||
421 | (unsigned long) __entry->ino, | ||
422 | __entry->mode, __entry->block, __entry->count) | ||
423 | ); | ||
424 | |||
425 | TRACE_EVENT(ext3_sync_file_enter, | ||
426 | TP_PROTO(struct file *file, int datasync), | ||
427 | |||
428 | TP_ARGS(file, datasync), | ||
429 | |||
430 | TP_STRUCT__entry( | ||
431 | __field( dev_t, dev ) | ||
432 | __field( ino_t, ino ) | ||
433 | __field( ino_t, parent ) | ||
434 | __field( int, datasync ) | ||
435 | ), | ||
436 | |||
437 | TP_fast_assign( | ||
438 | struct dentry *dentry = file->f_path.dentry; | ||
439 | |||
440 | __entry->dev = dentry->d_inode->i_sb->s_dev; | ||
441 | __entry->ino = dentry->d_inode->i_ino; | ||
442 | __entry->datasync = datasync; | ||
443 | __entry->parent = dentry->d_parent->d_inode->i_ino; | ||
444 | ), | ||
445 | |||
446 | TP_printk("dev %d,%d ino %lu parent %ld datasync %d ", | ||
447 | MAJOR(__entry->dev), MINOR(__entry->dev), | ||
448 | (unsigned long) __entry->ino, | ||
449 | (unsigned long) __entry->parent, __entry->datasync) | ||
450 | ); | ||
451 | |||
452 | TRACE_EVENT(ext3_sync_file_exit, | ||
453 | TP_PROTO(struct inode *inode, int ret), | ||
454 | |||
455 | TP_ARGS(inode, ret), | ||
456 | |||
457 | TP_STRUCT__entry( | ||
458 | __field( int, ret ) | ||
459 | __field( ino_t, ino ) | ||
460 | __field( dev_t, dev ) | ||
461 | ), | ||
462 | |||
463 | TP_fast_assign( | ||
464 | __entry->ret = ret; | ||
465 | __entry->ino = inode->i_ino; | ||
466 | __entry->dev = inode->i_sb->s_dev; | ||
467 | ), | ||
468 | |||
469 | TP_printk("dev %d,%d ino %lu ret %d", | ||
470 | MAJOR(__entry->dev), MINOR(__entry->dev), | ||
471 | (unsigned long) __entry->ino, | ||
472 | __entry->ret) | ||
473 | ); | ||
474 | |||
475 | TRACE_EVENT(ext3_sync_fs, | ||
476 | TP_PROTO(struct super_block *sb, int wait), | ||
477 | |||
478 | TP_ARGS(sb, wait), | ||
479 | |||
480 | TP_STRUCT__entry( | ||
481 | __field( dev_t, dev ) | ||
482 | __field( int, wait ) | ||
483 | |||
484 | ), | ||
485 | |||
486 | TP_fast_assign( | ||
487 | __entry->dev = sb->s_dev; | ||
488 | __entry->wait = wait; | ||
489 | ), | ||
490 | |||
491 | TP_printk("dev %d,%d wait %d", | ||
492 | MAJOR(__entry->dev), MINOR(__entry->dev), | ||
493 | __entry->wait) | ||
494 | ); | ||
495 | |||
496 | TRACE_EVENT(ext3_rsv_window_add, | ||
497 | TP_PROTO(struct super_block *sb, | ||
498 | struct ext3_reserve_window_node *rsv_node), | ||
499 | |||
500 | TP_ARGS(sb, rsv_node), | ||
501 | |||
502 | TP_STRUCT__entry( | ||
503 | __field( unsigned long, start ) | ||
504 | __field( unsigned long, end ) | ||
505 | __field( dev_t, dev ) | ||
506 | ), | ||
507 | |||
508 | TP_fast_assign( | ||
509 | __entry->dev = sb->s_dev; | ||
510 | __entry->start = rsv_node->rsv_window._rsv_start; | ||
511 | __entry->end = rsv_node->rsv_window._rsv_end; | ||
512 | ), | ||
513 | |||
514 | TP_printk("dev %d,%d start %lu end %lu", | ||
515 | MAJOR(__entry->dev), MINOR(__entry->dev), | ||
516 | __entry->start, __entry->end) | ||
517 | ); | ||
518 | |||
519 | TRACE_EVENT(ext3_discard_reservation, | ||
520 | TP_PROTO(struct inode *inode, | ||
521 | struct ext3_reserve_window_node *rsv_node), | ||
522 | |||
523 | TP_ARGS(inode, rsv_node), | ||
524 | |||
525 | TP_STRUCT__entry( | ||
526 | __field( unsigned long, start ) | ||
527 | __field( unsigned long, end ) | ||
528 | __field( ino_t, ino ) | ||
529 | __field( dev_t, dev ) | ||
530 | ), | ||
531 | |||
532 | TP_fast_assign( | ||
533 | __entry->start = rsv_node->rsv_window._rsv_start; | ||
534 | __entry->end = rsv_node->rsv_window._rsv_end; | ||
535 | __entry->ino = inode->i_ino; | ||
536 | __entry->dev = inode->i_sb->s_dev; | ||
537 | ), | ||
538 | |||
539 | TP_printk("dev %d,%d ino %lu start %lu end %lu", | ||
540 | MAJOR(__entry->dev), MINOR(__entry->dev), | ||
541 | (unsigned long)__entry->ino, __entry->start, | ||
542 | __entry->end) | ||
543 | ); | ||
544 | |||
545 | TRACE_EVENT(ext3_alloc_new_reservation, | ||
546 | TP_PROTO(struct super_block *sb, unsigned long goal), | ||
547 | |||
548 | TP_ARGS(sb, goal), | ||
549 | |||
550 | TP_STRUCT__entry( | ||
551 | __field( dev_t, dev ) | ||
552 | __field( unsigned long, goal ) | ||
553 | ), | ||
554 | |||
555 | TP_fast_assign( | ||
556 | __entry->dev = sb->s_dev; | ||
557 | __entry->goal = goal; | ||
558 | ), | ||
559 | |||
560 | TP_printk("dev %d,%d goal %lu", | ||
561 | MAJOR(__entry->dev), MINOR(__entry->dev), | ||
562 | __entry->goal) | ||
563 | ); | ||
564 | |||
565 | TRACE_EVENT(ext3_reserved, | ||
566 | TP_PROTO(struct super_block *sb, unsigned long block, | ||
567 | struct ext3_reserve_window_node *rsv_node), | ||
568 | |||
569 | TP_ARGS(sb, block, rsv_node), | ||
570 | |||
571 | TP_STRUCT__entry( | ||
572 | __field( unsigned long, block ) | ||
573 | __field( unsigned long, start ) | ||
574 | __field( unsigned long, end ) | ||
575 | __field( dev_t, dev ) | ||
576 | ), | ||
577 | |||
578 | TP_fast_assign( | ||
579 | __entry->block = block; | ||
580 | __entry->start = rsv_node->rsv_window._rsv_start; | ||
581 | __entry->end = rsv_node->rsv_window._rsv_end; | ||
582 | __entry->dev = sb->s_dev; | ||
583 | ), | ||
584 | |||
585 | TP_printk("dev %d,%d block %lu, start %lu end %lu", | ||
586 | MAJOR(__entry->dev), MINOR(__entry->dev), | ||
587 | __entry->block, __entry->start, __entry->end) | ||
588 | ); | ||
589 | |||
590 | TRACE_EVENT(ext3_forget, | ||
591 | TP_PROTO(struct inode *inode, int is_metadata, unsigned long block), | ||
592 | |||
593 | TP_ARGS(inode, is_metadata, block), | ||
594 | |||
595 | TP_STRUCT__entry( | ||
596 | __field( dev_t, dev ) | ||
597 | __field( ino_t, ino ) | ||
598 | __field( umode_t, mode ) | ||
599 | __field( int, is_metadata ) | ||
600 | __field( unsigned long, block ) | ||
601 | ), | ||
602 | |||
603 | TP_fast_assign( | ||
604 | __entry->dev = inode->i_sb->s_dev; | ||
605 | __entry->ino = inode->i_ino; | ||
606 | __entry->mode = inode->i_mode; | ||
607 | __entry->is_metadata = is_metadata; | ||
608 | __entry->block = block; | ||
609 | ), | ||
610 | |||
611 | TP_printk("dev %d,%d ino %lu mode 0%o is_metadata %d block %lu", | ||
612 | MAJOR(__entry->dev), MINOR(__entry->dev), | ||
613 | (unsigned long) __entry->ino, | ||
614 | __entry->mode, __entry->is_metadata, __entry->block) | ||
615 | ); | ||
616 | |||
617 | TRACE_EVENT(ext3_read_block_bitmap, | ||
618 | TP_PROTO(struct super_block *sb, unsigned int group), | ||
619 | |||
620 | TP_ARGS(sb, group), | ||
621 | |||
622 | TP_STRUCT__entry( | ||
623 | __field( dev_t, dev ) | ||
624 | __field( __u32, group ) | ||
625 | |||
626 | ), | ||
627 | |||
628 | TP_fast_assign( | ||
629 | __entry->dev = sb->s_dev; | ||
630 | __entry->group = group; | ||
631 | ), | ||
632 | |||
633 | TP_printk("dev %d,%d group %u", | ||
634 | MAJOR(__entry->dev), MINOR(__entry->dev), | ||
635 | __entry->group) | ||
636 | ); | ||
637 | |||
638 | TRACE_EVENT(ext3_direct_IO_enter, | ||
639 | TP_PROTO(struct inode *inode, loff_t offset, unsigned long len, int rw), | ||
640 | |||
641 | TP_ARGS(inode, offset, len, rw), | ||
642 | |||
643 | TP_STRUCT__entry( | ||
644 | __field( ino_t, ino ) | ||
645 | __field( dev_t, dev ) | ||
646 | __field( loff_t, pos ) | ||
647 | __field( unsigned long, len ) | ||
648 | __field( int, rw ) | ||
649 | ), | ||
650 | |||
651 | TP_fast_assign( | ||
652 | __entry->ino = inode->i_ino; | ||
653 | __entry->dev = inode->i_sb->s_dev; | ||
654 | __entry->pos = offset; | ||
655 | __entry->len = len; | ||
656 | __entry->rw = rw; | ||
657 | ), | ||
658 | |||
659 | TP_printk("dev %d,%d ino %lu pos %llu len %lu rw %d", | ||
660 | MAJOR(__entry->dev), MINOR(__entry->dev), | ||
661 | (unsigned long) __entry->ino, | ||
662 | (unsigned long long) __entry->pos, __entry->len, | ||
663 | __entry->rw) | ||
664 | ); | ||
665 | |||
666 | TRACE_EVENT(ext3_direct_IO_exit, | ||
667 | TP_PROTO(struct inode *inode, loff_t offset, unsigned long len, | ||
668 | int rw, int ret), | ||
669 | |||
670 | TP_ARGS(inode, offset, len, rw, ret), | ||
671 | |||
672 | TP_STRUCT__entry( | ||
673 | __field( ino_t, ino ) | ||
674 | __field( dev_t, dev ) | ||
675 | __field( loff_t, pos ) | ||
676 | __field( unsigned long, len ) | ||
677 | __field( int, rw ) | ||
678 | __field( int, ret ) | ||
679 | ), | ||
680 | |||
681 | TP_fast_assign( | ||
682 | __entry->ino = inode->i_ino; | ||
683 | __entry->dev = inode->i_sb->s_dev; | ||
684 | __entry->pos = offset; | ||
685 | __entry->len = len; | ||
686 | __entry->rw = rw; | ||
687 | __entry->ret = ret; | ||
688 | ), | ||
689 | |||
690 | TP_printk("dev %d,%d ino %lu pos %llu len %lu rw %d ret %d", | ||
691 | MAJOR(__entry->dev), MINOR(__entry->dev), | ||
692 | (unsigned long) __entry->ino, | ||
693 | (unsigned long long) __entry->pos, __entry->len, | ||
694 | __entry->rw, __entry->ret) | ||
695 | ); | ||
696 | |||
697 | TRACE_EVENT(ext3_unlink_enter, | ||
698 | TP_PROTO(struct inode *parent, struct dentry *dentry), | ||
699 | |||
700 | TP_ARGS(parent, dentry), | ||
701 | |||
702 | TP_STRUCT__entry( | ||
703 | __field( ino_t, parent ) | ||
704 | __field( ino_t, ino ) | ||
705 | __field( loff_t, size ) | ||
706 | __field( dev_t, dev ) | ||
707 | ), | ||
708 | |||
709 | TP_fast_assign( | ||
710 | __entry->parent = parent->i_ino; | ||
711 | __entry->ino = dentry->d_inode->i_ino; | ||
712 | __entry->size = dentry->d_inode->i_size; | ||
713 | __entry->dev = dentry->d_inode->i_sb->s_dev; | ||
714 | ), | ||
715 | |||
716 | TP_printk("dev %d,%d ino %lu size %lld parent %ld", | ||
717 | MAJOR(__entry->dev), MINOR(__entry->dev), | ||
718 | (unsigned long) __entry->ino, | ||
719 | (unsigned long long)__entry->size, | ||
720 | (unsigned long) __entry->parent) | ||
721 | ); | ||
722 | |||
723 | TRACE_EVENT(ext3_unlink_exit, | ||
724 | TP_PROTO(struct dentry *dentry, int ret), | ||
725 | |||
726 | TP_ARGS(dentry, ret), | ||
727 | |||
728 | TP_STRUCT__entry( | ||
729 | __field( ino_t, ino ) | ||
730 | __field( dev_t, dev ) | ||
731 | __field( int, ret ) | ||
732 | ), | ||
733 | |||
734 | TP_fast_assign( | ||
735 | __entry->ino = dentry->d_inode->i_ino; | ||
736 | __entry->dev = dentry->d_inode->i_sb->s_dev; | ||
737 | __entry->ret = ret; | ||
738 | ), | ||
739 | |||
740 | TP_printk("dev %d,%d ino %lu ret %d", | ||
741 | MAJOR(__entry->dev), MINOR(__entry->dev), | ||
742 | (unsigned long) __entry->ino, | ||
743 | __entry->ret) | ||
744 | ); | ||
745 | |||
746 | DECLARE_EVENT_CLASS(ext3__truncate, | ||
747 | TP_PROTO(struct inode *inode), | ||
748 | |||
749 | TP_ARGS(inode), | ||
750 | |||
751 | TP_STRUCT__entry( | ||
752 | __field( ino_t, ino ) | ||
753 | __field( dev_t, dev ) | ||
754 | __field( blkcnt_t, blocks ) | ||
755 | ), | ||
756 | |||
757 | TP_fast_assign( | ||
758 | __entry->ino = inode->i_ino; | ||
759 | __entry->dev = inode->i_sb->s_dev; | ||
760 | __entry->blocks = inode->i_blocks; | ||
761 | ), | ||
762 | |||
763 | TP_printk("dev %d,%d ino %lu blocks %lu", | ||
764 | MAJOR(__entry->dev), MINOR(__entry->dev), | ||
765 | (unsigned long) __entry->ino, (unsigned long) __entry->blocks) | ||
766 | ); | ||
767 | |||
768 | DEFINE_EVENT(ext3__truncate, ext3_truncate_enter, | ||
769 | |||
770 | TP_PROTO(struct inode *inode), | ||
771 | |||
772 | TP_ARGS(inode) | ||
773 | ); | ||
774 | |||
775 | DEFINE_EVENT(ext3__truncate, ext3_truncate_exit, | ||
776 | |||
777 | TP_PROTO(struct inode *inode), | ||
778 | |||
779 | TP_ARGS(inode) | ||
780 | ); | ||
781 | |||
782 | TRACE_EVENT(ext3_get_blocks_enter, | ||
783 | TP_PROTO(struct inode *inode, unsigned long lblk, | ||
784 | unsigned long len, int create), | ||
785 | |||
786 | TP_ARGS(inode, lblk, len, create), | ||
787 | |||
788 | TP_STRUCT__entry( | ||
789 | __field( ino_t, ino ) | ||
790 | __field( dev_t, dev ) | ||
791 | __field( unsigned long, lblk ) | ||
792 | __field( unsigned long, len ) | ||
793 | __field( int, create ) | ||
794 | ), | ||
795 | |||
796 | TP_fast_assign( | ||
797 | __entry->ino = inode->i_ino; | ||
798 | __entry->dev = inode->i_sb->s_dev; | ||
799 | __entry->lblk = lblk; | ||
800 | __entry->len = len; | ||
801 | __entry->create = create; | ||
802 | ), | ||
803 | |||
804 | TP_printk("dev %d,%d ino %lu lblk %lu len %lu create %u", | ||
805 | MAJOR(__entry->dev), MINOR(__entry->dev), | ||
806 | (unsigned long) __entry->ino, | ||
807 | __entry->lblk, __entry->len, __entry->create) | ||
808 | ); | ||
809 | |||
810 | TRACE_EVENT(ext3_get_blocks_exit, | ||
811 | TP_PROTO(struct inode *inode, unsigned long lblk, | ||
812 | unsigned long pblk, unsigned long len, int ret), | ||
813 | |||
814 | TP_ARGS(inode, lblk, pblk, len, ret), | ||
815 | |||
816 | TP_STRUCT__entry( | ||
817 | __field( ino_t, ino ) | ||
818 | __field( dev_t, dev ) | ||
819 | __field( unsigned long, lblk ) | ||
820 | __field( unsigned long, pblk ) | ||
821 | __field( unsigned long, len ) | ||
822 | __field( int, ret ) | ||
823 | ), | ||
824 | |||
825 | TP_fast_assign( | ||
826 | __entry->ino = inode->i_ino; | ||
827 | __entry->dev = inode->i_sb->s_dev; | ||
828 | __entry->lblk = lblk; | ||
829 | __entry->pblk = pblk; | ||
830 | __entry->len = len; | ||
831 | __entry->ret = ret; | ||
832 | ), | ||
833 | |||
834 | TP_printk("dev %d,%d ino %lu lblk %lu pblk %lu len %lu ret %d", | ||
835 | MAJOR(__entry->dev), MINOR(__entry->dev), | ||
836 | (unsigned long) __entry->ino, | ||
837 | __entry->lblk, __entry->pblk, | ||
838 | __entry->len, __entry->ret) | ||
839 | ); | ||
840 | |||
841 | TRACE_EVENT(ext3_load_inode, | ||
842 | TP_PROTO(struct inode *inode), | ||
843 | |||
844 | TP_ARGS(inode), | ||
845 | |||
846 | TP_STRUCT__entry( | ||
847 | __field( ino_t, ino ) | ||
848 | __field( dev_t, dev ) | ||
849 | ), | ||
850 | |||
851 | TP_fast_assign( | ||
852 | __entry->ino = inode->i_ino; | ||
853 | __entry->dev = inode->i_sb->s_dev; | ||
854 | ), | ||
855 | |||
856 | TP_printk("dev %d,%d ino %lu", | ||
857 | MAJOR(__entry->dev), MINOR(__entry->dev), | ||
858 | (unsigned long) __entry->ino) | ||
859 | ); | ||
860 | |||
861 | #endif /* _TRACE_EXT3_H */ | ||
862 | |||
863 | /* This part must be outside protection */ | ||
864 | #include <trace/define_trace.h> | ||
diff --git a/include/trace/events/ext4.h b/include/trace/events/ext4.h index 5ce2b2f5f52..b50a5473624 100644 --- a/include/trace/events/ext4.h +++ b/include/trace/events/ext4.h | |||
@@ -23,7 +23,7 @@ TRACE_EVENT(ext4_free_inode, | |||
23 | TP_STRUCT__entry( | 23 | TP_STRUCT__entry( |
24 | __field( dev_t, dev ) | 24 | __field( dev_t, dev ) |
25 | __field( ino_t, ino ) | 25 | __field( ino_t, ino ) |
26 | __field( umode_t, mode ) | 26 | __field( __u16, mode ) |
27 | __field( uid_t, uid ) | 27 | __field( uid_t, uid ) |
28 | __field( gid_t, gid ) | 28 | __field( gid_t, gid ) |
29 | __field( __u64, blocks ) | 29 | __field( __u64, blocks ) |
@@ -52,7 +52,7 @@ TRACE_EVENT(ext4_request_inode, | |||
52 | TP_STRUCT__entry( | 52 | TP_STRUCT__entry( |
53 | __field( dev_t, dev ) | 53 | __field( dev_t, dev ) |
54 | __field( ino_t, dir ) | 54 | __field( ino_t, dir ) |
55 | __field( umode_t, mode ) | 55 | __field( __u16, mode ) |
56 | ), | 56 | ), |
57 | 57 | ||
58 | TP_fast_assign( | 58 | TP_fast_assign( |
@@ -75,7 +75,7 @@ TRACE_EVENT(ext4_allocate_inode, | |||
75 | __field( dev_t, dev ) | 75 | __field( dev_t, dev ) |
76 | __field( ino_t, ino ) | 76 | __field( ino_t, ino ) |
77 | __field( ino_t, dir ) | 77 | __field( ino_t, dir ) |
78 | __field( umode_t, mode ) | 78 | __field( __u16, mode ) |
79 | ), | 79 | ), |
80 | 80 | ||
81 | TP_fast_assign( | 81 | TP_fast_assign( |
@@ -380,7 +380,6 @@ TRACE_EVENT(ext4_da_writepages_result, | |||
380 | __field( int, pages_written ) | 380 | __field( int, pages_written ) |
381 | __field( long, pages_skipped ) | 381 | __field( long, pages_skipped ) |
382 | __field( int, sync_mode ) | 382 | __field( int, sync_mode ) |
383 | __field( char, more_io ) | ||
384 | __field( pgoff_t, writeback_index ) | 383 | __field( pgoff_t, writeback_index ) |
385 | ), | 384 | ), |
386 | 385 | ||
@@ -391,16 +390,15 @@ TRACE_EVENT(ext4_da_writepages_result, | |||
391 | __entry->pages_written = pages_written; | 390 | __entry->pages_written = pages_written; |
392 | __entry->pages_skipped = wbc->pages_skipped; | 391 | __entry->pages_skipped = wbc->pages_skipped; |
393 | __entry->sync_mode = wbc->sync_mode; | 392 | __entry->sync_mode = wbc->sync_mode; |
394 | __entry->more_io = wbc->more_io; | ||
395 | __entry->writeback_index = inode->i_mapping->writeback_index; | 393 | __entry->writeback_index = inode->i_mapping->writeback_index; |
396 | ), | 394 | ), |
397 | 395 | ||
398 | TP_printk("dev %d,%d ino %lu ret %d pages_written %d pages_skipped %ld " | 396 | TP_printk("dev %d,%d ino %lu ret %d pages_written %d pages_skipped %ld " |
399 | " more_io %d sync_mode %d writeback_index %lu", | 397 | "sync_mode %d writeback_index %lu", |
400 | MAJOR(__entry->dev), MINOR(__entry->dev), | 398 | MAJOR(__entry->dev), MINOR(__entry->dev), |
401 | (unsigned long) __entry->ino, __entry->ret, | 399 | (unsigned long) __entry->ino, __entry->ret, |
402 | __entry->pages_written, __entry->pages_skipped, | 400 | __entry->pages_written, __entry->pages_skipped, |
403 | __entry->more_io, __entry->sync_mode, | 401 | __entry->sync_mode, |
404 | (unsigned long) __entry->writeback_index) | 402 | (unsigned long) __entry->writeback_index) |
405 | ); | 403 | ); |
406 | 404 | ||
@@ -727,7 +725,7 @@ TRACE_EVENT(ext4_free_blocks, | |||
727 | TP_STRUCT__entry( | 725 | TP_STRUCT__entry( |
728 | __field( dev_t, dev ) | 726 | __field( dev_t, dev ) |
729 | __field( ino_t, ino ) | 727 | __field( ino_t, ino ) |
730 | __field( umode_t, mode ) | 728 | __field( __u16, mode ) |
731 | __field( __u64, block ) | 729 | __field( __u64, block ) |
732 | __field( unsigned long, count ) | 730 | __field( unsigned long, count ) |
733 | __field( int, flags ) | 731 | __field( int, flags ) |
@@ -1014,7 +1012,7 @@ TRACE_EVENT(ext4_forget, | |||
1014 | TP_STRUCT__entry( | 1012 | TP_STRUCT__entry( |
1015 | __field( dev_t, dev ) | 1013 | __field( dev_t, dev ) |
1016 | __field( ino_t, ino ) | 1014 | __field( ino_t, ino ) |
1017 | __field( umode_t, mode ) | 1015 | __field( __u16, mode ) |
1018 | __field( int, is_metadata ) | 1016 | __field( int, is_metadata ) |
1019 | __field( __u64, block ) | 1017 | __field( __u64, block ) |
1020 | ), | 1018 | ), |
@@ -1041,7 +1039,7 @@ TRACE_EVENT(ext4_da_update_reserve_space, | |||
1041 | TP_STRUCT__entry( | 1039 | TP_STRUCT__entry( |
1042 | __field( dev_t, dev ) | 1040 | __field( dev_t, dev ) |
1043 | __field( ino_t, ino ) | 1041 | __field( ino_t, ino ) |
1044 | __field( umode_t, mode ) | 1042 | __field( __u16, mode ) |
1045 | __field( __u64, i_blocks ) | 1043 | __field( __u64, i_blocks ) |
1046 | __field( int, used_blocks ) | 1044 | __field( int, used_blocks ) |
1047 | __field( int, reserved_data_blocks ) | 1045 | __field( int, reserved_data_blocks ) |
@@ -1078,7 +1076,7 @@ TRACE_EVENT(ext4_da_reserve_space, | |||
1078 | TP_STRUCT__entry( | 1076 | TP_STRUCT__entry( |
1079 | __field( dev_t, dev ) | 1077 | __field( dev_t, dev ) |
1080 | __field( ino_t, ino ) | 1078 | __field( ino_t, ino ) |
1081 | __field( umode_t, mode ) | 1079 | __field( __u16, mode ) |
1082 | __field( __u64, i_blocks ) | 1080 | __field( __u64, i_blocks ) |
1083 | __field( int, md_needed ) | 1081 | __field( int, md_needed ) |
1084 | __field( int, reserved_data_blocks ) | 1082 | __field( int, reserved_data_blocks ) |
@@ -1112,7 +1110,7 @@ TRACE_EVENT(ext4_da_release_space, | |||
1112 | TP_STRUCT__entry( | 1110 | TP_STRUCT__entry( |
1113 | __field( dev_t, dev ) | 1111 | __field( dev_t, dev ) |
1114 | __field( ino_t, ino ) | 1112 | __field( ino_t, ino ) |
1115 | __field( umode_t, mode ) | 1113 | __field( __u16, mode ) |
1116 | __field( __u64, i_blocks ) | 1114 | __field( __u64, i_blocks ) |
1117 | __field( int, freed_blocks ) | 1115 | __field( int, freed_blocks ) |
1118 | __field( int, reserved_data_blocks ) | 1116 | __field( int, reserved_data_blocks ) |
@@ -1520,6 +1518,77 @@ TRACE_EVENT(ext4_load_inode, | |||
1520 | (unsigned long) __entry->ino) | 1518 | (unsigned long) __entry->ino) |
1521 | ); | 1519 | ); |
1522 | 1520 | ||
1521 | TRACE_EVENT(ext4_journal_start, | ||
1522 | TP_PROTO(struct super_block *sb, int nblocks, unsigned long IP), | ||
1523 | |||
1524 | TP_ARGS(sb, nblocks, IP), | ||
1525 | |||
1526 | TP_STRUCT__entry( | ||
1527 | __field( dev_t, dev ) | ||
1528 | __field( int, nblocks ) | ||
1529 | __field(unsigned long, ip ) | ||
1530 | ), | ||
1531 | |||
1532 | TP_fast_assign( | ||
1533 | __entry->dev = sb->s_dev; | ||
1534 | __entry->nblocks = nblocks; | ||
1535 | __entry->ip = IP; | ||
1536 | ), | ||
1537 | |||
1538 | TP_printk("dev %d,%d nblocks %d caller %pF", | ||
1539 | MAJOR(__entry->dev), MINOR(__entry->dev), | ||
1540 | __entry->nblocks, (void *)__entry->ip) | ||
1541 | ); | ||
1542 | |||
1543 | DECLARE_EVENT_CLASS(ext4__trim, | ||
1544 | TP_PROTO(struct super_block *sb, | ||
1545 | ext4_group_t group, | ||
1546 | ext4_grpblk_t start, | ||
1547 | ext4_grpblk_t len), | ||
1548 | |||
1549 | TP_ARGS(sb, group, start, len), | ||
1550 | |||
1551 | TP_STRUCT__entry( | ||
1552 | __field( int, dev_major ) | ||
1553 | __field( int, dev_minor ) | ||
1554 | __field( __u32, group ) | ||
1555 | __field( int, start ) | ||
1556 | __field( int, len ) | ||
1557 | ), | ||
1558 | |||
1559 | TP_fast_assign( | ||
1560 | __entry->dev_major = MAJOR(sb->s_dev); | ||
1561 | __entry->dev_minor = MINOR(sb->s_dev); | ||
1562 | __entry->group = group; | ||
1563 | __entry->start = start; | ||
1564 | __entry->len = len; | ||
1565 | ), | ||
1566 | |||
1567 | TP_printk("dev %d,%d group %u, start %d, len %d", | ||
1568 | __entry->dev_major, __entry->dev_minor, | ||
1569 | __entry->group, __entry->start, __entry->len) | ||
1570 | ); | ||
1571 | |||
1572 | DEFINE_EVENT(ext4__trim, ext4_trim_extent, | ||
1573 | |||
1574 | TP_PROTO(struct super_block *sb, | ||
1575 | ext4_group_t group, | ||
1576 | ext4_grpblk_t start, | ||
1577 | ext4_grpblk_t len), | ||
1578 | |||
1579 | TP_ARGS(sb, group, start, len) | ||
1580 | ); | ||
1581 | |||
1582 | DEFINE_EVENT(ext4__trim, ext4_trim_all_free, | ||
1583 | |||
1584 | TP_PROTO(struct super_block *sb, | ||
1585 | ext4_group_t group, | ||
1586 | ext4_grpblk_t start, | ||
1587 | ext4_grpblk_t len), | ||
1588 | |||
1589 | TP_ARGS(sb, group, start, len) | ||
1590 | ); | ||
1591 | |||
1523 | #endif /* _TRACE_EXT4_H */ | 1592 | #endif /* _TRACE_EXT4_H */ |
1524 | 1593 | ||
1525 | /* This part must be outside protection */ | 1594 | /* This part must be outside protection */ |
diff --git a/include/trace/events/jbd.h b/include/trace/events/jbd.h new file mode 100644 index 00000000000..aff64d82d71 --- /dev/null +++ b/include/trace/events/jbd.h | |||
@@ -0,0 +1,203 @@ | |||
1 | #undef TRACE_SYSTEM | ||
2 | #define TRACE_SYSTEM jbd | ||
3 | |||
4 | #if !defined(_TRACE_JBD_H) || defined(TRACE_HEADER_MULTI_READ) | ||
5 | #define _TRACE_JBD_H | ||
6 | |||
7 | #include <linux/jbd.h> | ||
8 | #include <linux/tracepoint.h> | ||
9 | |||
10 | TRACE_EVENT(jbd_checkpoint, | ||
11 | |||
12 | TP_PROTO(journal_t *journal, int result), | ||
13 | |||
14 | TP_ARGS(journal, result), | ||
15 | |||
16 | TP_STRUCT__entry( | ||
17 | __field( dev_t, dev ) | ||
18 | __field( int, result ) | ||
19 | ), | ||
20 | |||
21 | TP_fast_assign( | ||
22 | __entry->dev = journal->j_fs_dev->bd_dev; | ||
23 | __entry->result = result; | ||
24 | ), | ||
25 | |||
26 | TP_printk("dev %d,%d result %d", | ||
27 | MAJOR(__entry->dev), MINOR(__entry->dev), | ||
28 | __entry->result) | ||
29 | ); | ||
30 | |||
31 | DECLARE_EVENT_CLASS(jbd_commit, | ||
32 | |||
33 | TP_PROTO(journal_t *journal, transaction_t *commit_transaction), | ||
34 | |||
35 | TP_ARGS(journal, commit_transaction), | ||
36 | |||
37 | TP_STRUCT__entry( | ||
38 | __field( dev_t, dev ) | ||
39 | __field( char, sync_commit ) | ||
40 | __field( int, transaction ) | ||
41 | ), | ||
42 | |||
43 | TP_fast_assign( | ||
44 | __entry->dev = journal->j_fs_dev->bd_dev; | ||
45 | __entry->sync_commit = commit_transaction->t_synchronous_commit; | ||
46 | __entry->transaction = commit_transaction->t_tid; | ||
47 | ), | ||
48 | |||
49 | TP_printk("dev %d,%d transaction %d sync %d", | ||
50 | MAJOR(__entry->dev), MINOR(__entry->dev), | ||
51 | __entry->transaction, __entry->sync_commit) | ||
52 | ); | ||
53 | |||
54 | DEFINE_EVENT(jbd_commit, jbd_start_commit, | ||
55 | |||
56 | TP_PROTO(journal_t *journal, transaction_t *commit_transaction), | ||
57 | |||
58 | TP_ARGS(journal, commit_transaction) | ||
59 | ); | ||
60 | |||
61 | DEFINE_EVENT(jbd_commit, jbd_commit_locking, | ||
62 | |||
63 | TP_PROTO(journal_t *journal, transaction_t *commit_transaction), | ||
64 | |||
65 | TP_ARGS(journal, commit_transaction) | ||
66 | ); | ||
67 | |||
68 | DEFINE_EVENT(jbd_commit, jbd_commit_flushing, | ||
69 | |||
70 | TP_PROTO(journal_t *journal, transaction_t *commit_transaction), | ||
71 | |||
72 | TP_ARGS(journal, commit_transaction) | ||
73 | ); | ||
74 | |||
75 | DEFINE_EVENT(jbd_commit, jbd_commit_logging, | ||
76 | |||
77 | TP_PROTO(journal_t *journal, transaction_t *commit_transaction), | ||
78 | |||
79 | TP_ARGS(journal, commit_transaction) | ||
80 | ); | ||
81 | |||
82 | TRACE_EVENT(jbd_drop_transaction, | ||
83 | |||
84 | TP_PROTO(journal_t *journal, transaction_t *commit_transaction), | ||
85 | |||
86 | TP_ARGS(journal, commit_transaction), | ||
87 | |||
88 | TP_STRUCT__entry( | ||
89 | __field( dev_t, dev ) | ||
90 | __field( char, sync_commit ) | ||
91 | __field( int, transaction ) | ||
92 | ), | ||
93 | |||
94 | TP_fast_assign( | ||
95 | __entry->dev = journal->j_fs_dev->bd_dev; | ||
96 | __entry->sync_commit = commit_transaction->t_synchronous_commit; | ||
97 | __entry->transaction = commit_transaction->t_tid; | ||
98 | ), | ||
99 | |||
100 | TP_printk("dev %d,%d transaction %d sync %d", | ||
101 | MAJOR(__entry->dev), MINOR(__entry->dev), | ||
102 | __entry->transaction, __entry->sync_commit) | ||
103 | ); | ||
104 | |||
105 | TRACE_EVENT(jbd_end_commit, | ||
106 | TP_PROTO(journal_t *journal, transaction_t *commit_transaction), | ||
107 | |||
108 | TP_ARGS(journal, commit_transaction), | ||
109 | |||
110 | TP_STRUCT__entry( | ||
111 | __field( dev_t, dev ) | ||
112 | __field( char, sync_commit ) | ||
113 | __field( int, transaction ) | ||
114 | __field( int, head ) | ||
115 | ), | ||
116 | |||
117 | TP_fast_assign( | ||
118 | __entry->dev = journal->j_fs_dev->bd_dev; | ||
119 | __entry->sync_commit = commit_transaction->t_synchronous_commit; | ||
120 | __entry->transaction = commit_transaction->t_tid; | ||
121 | __entry->head = journal->j_tail_sequence; | ||
122 | ), | ||
123 | |||
124 | TP_printk("dev %d,%d transaction %d sync %d head %d", | ||
125 | MAJOR(__entry->dev), MINOR(__entry->dev), | ||
126 | __entry->transaction, __entry->sync_commit, __entry->head) | ||
127 | ); | ||
128 | |||
129 | TRACE_EVENT(jbd_do_submit_data, | ||
130 | TP_PROTO(journal_t *journal, transaction_t *commit_transaction), | ||
131 | |||
132 | TP_ARGS(journal, commit_transaction), | ||
133 | |||
134 | TP_STRUCT__entry( | ||
135 | __field( dev_t, dev ) | ||
136 | __field( char, sync_commit ) | ||
137 | __field( int, transaction ) | ||
138 | ), | ||
139 | |||
140 | TP_fast_assign( | ||
141 | __entry->dev = journal->j_fs_dev->bd_dev; | ||
142 | __entry->sync_commit = commit_transaction->t_synchronous_commit; | ||
143 | __entry->transaction = commit_transaction->t_tid; | ||
144 | ), | ||
145 | |||
146 | TP_printk("dev %d,%d transaction %d sync %d", | ||
147 | MAJOR(__entry->dev), MINOR(__entry->dev), | ||
148 | __entry->transaction, __entry->sync_commit) | ||
149 | ); | ||
150 | |||
151 | TRACE_EVENT(jbd_cleanup_journal_tail, | ||
152 | |||
153 | TP_PROTO(journal_t *journal, tid_t first_tid, | ||
154 | unsigned long block_nr, unsigned long freed), | ||
155 | |||
156 | TP_ARGS(journal, first_tid, block_nr, freed), | ||
157 | |||
158 | TP_STRUCT__entry( | ||
159 | __field( dev_t, dev ) | ||
160 | __field( tid_t, tail_sequence ) | ||
161 | __field( tid_t, first_tid ) | ||
162 | __field(unsigned long, block_nr ) | ||
163 | __field(unsigned long, freed ) | ||
164 | ), | ||
165 | |||
166 | TP_fast_assign( | ||
167 | __entry->dev = journal->j_fs_dev->bd_dev; | ||
168 | __entry->tail_sequence = journal->j_tail_sequence; | ||
169 | __entry->first_tid = first_tid; | ||
170 | __entry->block_nr = block_nr; | ||
171 | __entry->freed = freed; | ||
172 | ), | ||
173 | |||
174 | TP_printk("dev %d,%d from %u to %u offset %lu freed %lu", | ||
175 | MAJOR(__entry->dev), MINOR(__entry->dev), | ||
176 | __entry->tail_sequence, __entry->first_tid, | ||
177 | __entry->block_nr, __entry->freed) | ||
178 | ); | ||
179 | |||
180 | TRACE_EVENT(jbd_update_superblock_end, | ||
181 | TP_PROTO(journal_t *journal, int wait), | ||
182 | |||
183 | TP_ARGS(journal, wait), | ||
184 | |||
185 | TP_STRUCT__entry( | ||
186 | __field( dev_t, dev ) | ||
187 | __field( int, wait ) | ||
188 | ), | ||
189 | |||
190 | TP_fast_assign( | ||
191 | __entry->dev = journal->j_fs_dev->bd_dev; | ||
192 | __entry->wait = wait; | ||
193 | ), | ||
194 | |||
195 | TP_printk("dev %d,%d wait %d", | ||
196 | MAJOR(__entry->dev), MINOR(__entry->dev), | ||
197 | __entry->wait) | ||
198 | ); | ||
199 | |||
200 | #endif /* _TRACE_JBD_H */ | ||
201 | |||
202 | /* This part must be outside protection */ | ||
203 | #include <trace/define_trace.h> | ||
diff --git a/include/trace/events/jbd2.h b/include/trace/events/jbd2.h index bf16545cc97..75964412ddb 100644 --- a/include/trace/events/jbd2.h +++ b/include/trace/events/jbd2.h | |||
@@ -26,8 +26,8 @@ TRACE_EVENT(jbd2_checkpoint, | |||
26 | __entry->result = result; | 26 | __entry->result = result; |
27 | ), | 27 | ), |
28 | 28 | ||
29 | TP_printk("dev %s result %d", | 29 | TP_printk("dev %d,%d result %d", |
30 | jbd2_dev_to_name(__entry->dev), __entry->result) | 30 | MAJOR(__entry->dev), MINOR(__entry->dev), __entry->result) |
31 | ); | 31 | ); |
32 | 32 | ||
33 | DECLARE_EVENT_CLASS(jbd2_commit, | 33 | DECLARE_EVENT_CLASS(jbd2_commit, |
@@ -48,9 +48,9 @@ DECLARE_EVENT_CLASS(jbd2_commit, | |||
48 | __entry->transaction = commit_transaction->t_tid; | 48 | __entry->transaction = commit_transaction->t_tid; |
49 | ), | 49 | ), |
50 | 50 | ||
51 | TP_printk("dev %s transaction %d sync %d", | 51 | TP_printk("dev %d,%d transaction %d sync %d", |
52 | jbd2_dev_to_name(__entry->dev), __entry->transaction, | 52 | MAJOR(__entry->dev), MINOR(__entry->dev), |
53 | __entry->sync_commit) | 53 | __entry->transaction, __entry->sync_commit) |
54 | ); | 54 | ); |
55 | 55 | ||
56 | DEFINE_EVENT(jbd2_commit, jbd2_start_commit, | 56 | DEFINE_EVENT(jbd2_commit, jbd2_start_commit, |
@@ -100,9 +100,9 @@ TRACE_EVENT(jbd2_end_commit, | |||
100 | __entry->head = journal->j_tail_sequence; | 100 | __entry->head = journal->j_tail_sequence; |
101 | ), | 101 | ), |
102 | 102 | ||
103 | TP_printk("dev %s transaction %d sync %d head %d", | 103 | TP_printk("dev %d,%d transaction %d sync %d head %d", |
104 | jbd2_dev_to_name(__entry->dev), __entry->transaction, | 104 | MAJOR(__entry->dev), MINOR(__entry->dev), |
105 | __entry->sync_commit, __entry->head) | 105 | __entry->transaction, __entry->sync_commit, __entry->head) |
106 | ); | 106 | ); |
107 | 107 | ||
108 | TRACE_EVENT(jbd2_submit_inode_data, | 108 | TRACE_EVENT(jbd2_submit_inode_data, |
@@ -120,8 +120,9 @@ TRACE_EVENT(jbd2_submit_inode_data, | |||
120 | __entry->ino = inode->i_ino; | 120 | __entry->ino = inode->i_ino; |
121 | ), | 121 | ), |
122 | 122 | ||
123 | TP_printk("dev %s ino %lu", | 123 | TP_printk("dev %d,%d ino %lu", |
124 | jbd2_dev_to_name(__entry->dev), (unsigned long) __entry->ino) | 124 | MAJOR(__entry->dev), MINOR(__entry->dev), |
125 | (unsigned long) __entry->ino) | ||
125 | ); | 126 | ); |
126 | 127 | ||
127 | TRACE_EVENT(jbd2_run_stats, | 128 | TRACE_EVENT(jbd2_run_stats, |
@@ -156,9 +157,9 @@ TRACE_EVENT(jbd2_run_stats, | |||
156 | __entry->blocks_logged = stats->rs_blocks_logged; | 157 | __entry->blocks_logged = stats->rs_blocks_logged; |
157 | ), | 158 | ), |
158 | 159 | ||
159 | TP_printk("dev %s tid %lu wait %u running %u locked %u flushing %u " | 160 | TP_printk("dev %d,%d tid %lu wait %u running %u locked %u flushing %u " |
160 | "logging %u handle_count %u blocks %u blocks_logged %u", | 161 | "logging %u handle_count %u blocks %u blocks_logged %u", |
161 | jbd2_dev_to_name(__entry->dev), __entry->tid, | 162 | MAJOR(__entry->dev), MINOR(__entry->dev), __entry->tid, |
162 | jiffies_to_msecs(__entry->wait), | 163 | jiffies_to_msecs(__entry->wait), |
163 | jiffies_to_msecs(__entry->running), | 164 | jiffies_to_msecs(__entry->running), |
164 | jiffies_to_msecs(__entry->locked), | 165 | jiffies_to_msecs(__entry->locked), |
@@ -192,9 +193,9 @@ TRACE_EVENT(jbd2_checkpoint_stats, | |||
192 | __entry->dropped = stats->cs_dropped; | 193 | __entry->dropped = stats->cs_dropped; |
193 | ), | 194 | ), |
194 | 195 | ||
195 | TP_printk("dev %s tid %lu chp_time %u forced_to_close %u " | 196 | TP_printk("dev %d,%d tid %lu chp_time %u forced_to_close %u " |
196 | "written %u dropped %u", | 197 | "written %u dropped %u", |
197 | jbd2_dev_to_name(__entry->dev), __entry->tid, | 198 | MAJOR(__entry->dev), MINOR(__entry->dev), __entry->tid, |
198 | jiffies_to_msecs(__entry->chp_time), | 199 | jiffies_to_msecs(__entry->chp_time), |
199 | __entry->forced_to_close, __entry->written, __entry->dropped) | 200 | __entry->forced_to_close, __entry->written, __entry->dropped) |
200 | ); | 201 | ); |
@@ -222,9 +223,10 @@ TRACE_EVENT(jbd2_cleanup_journal_tail, | |||
222 | __entry->freed = freed; | 223 | __entry->freed = freed; |
223 | ), | 224 | ), |
224 | 225 | ||
225 | TP_printk("dev %s from %u to %u offset %lu freed %lu", | 226 | TP_printk("dev %d,%d from %u to %u offset %lu freed %lu", |
226 | jbd2_dev_to_name(__entry->dev), __entry->tail_sequence, | 227 | MAJOR(__entry->dev), MINOR(__entry->dev), |
227 | __entry->first_tid, __entry->block_nr, __entry->freed) | 228 | __entry->tail_sequence, __entry->first_tid, |
229 | __entry->block_nr, __entry->freed) | ||
228 | ); | 230 | ); |
229 | 231 | ||
230 | #endif /* _TRACE_JBD2_H */ | 232 | #endif /* _TRACE_JBD2_H */ |
diff --git a/include/trace/events/nvhost.h b/include/trace/events/nvhost.h new file mode 100644 index 00000000000..4c44cdc99f9 --- /dev/null +++ b/include/trace/events/nvhost.h | |||
@@ -0,0 +1,438 @@ | |||
1 | /* | ||
2 | * include/trace/events/nvhost.h | ||
3 | * | ||
4 | * Nvhost event logging to ftrace. | ||
5 | * | ||
6 | * Copyright (c) 2010-2012, NVIDIA Corporation. | ||
7 | * | ||
8 | * This program is free software; you can redistribute it and/or modify | ||
9 | * it under the terms of the GNU General Public License as published by | ||
10 | * the Free Software Foundation; either version 2 of the License, or | ||
11 | * (at your option) any later version. | ||
12 | * | ||
13 | * This program is distributed in the hope that it will be useful, but WITHOUT | ||
14 | * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or | ||
15 | * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for | ||
16 | * more details. | ||
17 | * | ||
18 | * You should have received a copy of the GNU General Public License along | ||
19 | * with this program; if not, write to the Free Software Foundation, Inc., | ||
20 | * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. | ||
21 | */ | ||
22 | |||
23 | #undef TRACE_SYSTEM | ||
24 | #define TRACE_SYSTEM nvhost | ||
25 | |||
26 | #if !defined(_TRACE_NVHOST_H) || defined(TRACE_HEADER_MULTI_READ) | ||
27 | #define _TRACE_NVHOST_H | ||
28 | |||
29 | #include <linux/ktime.h> | ||
30 | #include <linux/tracepoint.h> | ||
31 | |||
32 | DECLARE_EVENT_CLASS(nvhost, | ||
33 | TP_PROTO(const char *name), | ||
34 | TP_ARGS(name), | ||
35 | TP_STRUCT__entry(__field(const char *, name)), | ||
36 | TP_fast_assign(__entry->name = name;), | ||
37 | TP_printk("name=%s", __entry->name) | ||
38 | ); | ||
39 | |||
40 | DEFINE_EVENT(nvhost, nvhost_channel_open, | ||
41 | TP_PROTO(const char *name), | ||
42 | TP_ARGS(name) | ||
43 | ); | ||
44 | |||
45 | DEFINE_EVENT(nvhost, nvhost_channel_release, | ||
46 | TP_PROTO(const char *name), | ||
47 | TP_ARGS(name) | ||
48 | ); | ||
49 | |||
50 | DEFINE_EVENT(nvhost, nvhost_ioctl_channel_flush, | ||
51 | TP_PROTO(const char *name), | ||
52 | TP_ARGS(name) | ||
53 | ); | ||
54 | |||
55 | TRACE_EVENT(nvhost_channel_write_submit, | ||
56 | TP_PROTO(const char *name, ssize_t count, u32 cmdbufs, u32 relocs, | ||
57 | u32 syncpt_id, u32 syncpt_incrs), | ||
58 | |||
59 | TP_ARGS(name, count, cmdbufs, relocs, syncpt_id, syncpt_incrs), | ||
60 | |||
61 | TP_STRUCT__entry( | ||
62 | __field(const char *, name) | ||
63 | __field(ssize_t, count) | ||
64 | __field(u32, cmdbufs) | ||
65 | __field(u32, relocs) | ||
66 | __field(u32, syncpt_id) | ||
67 | __field(u32, syncpt_incrs) | ||
68 | ), | ||
69 | |||
70 | TP_fast_assign( | ||
71 | __entry->name = name; | ||
72 | __entry->count = count; | ||
73 | __entry->cmdbufs = cmdbufs; | ||
74 | __entry->relocs = relocs; | ||
75 | __entry->syncpt_id = syncpt_id; | ||
76 | __entry->syncpt_incrs = syncpt_incrs; | ||
77 | ), | ||
78 | |||
79 | TP_printk("name=%s, count=%d, cmdbufs=%u, relocs=%u, syncpt_id=%u, syncpt_incrs=%u", | ||
80 | __entry->name, __entry->count, __entry->cmdbufs, __entry->relocs, | ||
81 | __entry->syncpt_id, __entry->syncpt_incrs) | ||
82 | ); | ||
83 | |||
84 | TRACE_EVENT(nvhost_ioctl_channel_submit, | ||
85 | TP_PROTO(const char *name, u32 version, u32 cmdbufs, u32 relocs, | ||
86 | u32 waitchks, u32 syncpt_id, u32 syncpt_incrs), | ||
87 | |||
88 | TP_ARGS(name, version, cmdbufs, relocs, waitchks, | ||
89 | syncpt_id, syncpt_incrs), | ||
90 | |||
91 | TP_STRUCT__entry( | ||
92 | __field(const char *, name) | ||
93 | __field(u32, version) | ||
94 | __field(u32, cmdbufs) | ||
95 | __field(u32, relocs) | ||
96 | __field(u32, waitchks) | ||
97 | __field(u32, syncpt_id) | ||
98 | __field(u32, syncpt_incrs) | ||
99 | ), | ||
100 | |||
101 | TP_fast_assign( | ||
102 | __entry->name = name; | ||
103 | __entry->version = version; | ||
104 | __entry->cmdbufs = cmdbufs; | ||
105 | __entry->relocs = relocs; | ||
106 | __entry->waitchks = waitchks; | ||
107 | __entry->syncpt_id = syncpt_id; | ||
108 | __entry->syncpt_incrs = syncpt_incrs; | ||
109 | ), | ||
110 | |||
111 | TP_printk("name=%s, version=%u, cmdbufs=%u, relocs=%u, waitchks=%u, syncpt_id=%u, syncpt_incrs=%u", | ||
112 | __entry->name, __entry->version, __entry->cmdbufs, __entry->relocs, | ||
113 | __entry->waitchks, __entry->syncpt_id, __entry->syncpt_incrs) | ||
114 | ); | ||
115 | |||
116 | TRACE_EVENT(nvhost_channel_write_cmdbuf, | ||
117 | TP_PROTO(const char *name, u32 mem_id, | ||
118 | u32 words, u32 offset), | ||
119 | |||
120 | TP_ARGS(name, mem_id, words, offset), | ||
121 | |||
122 | TP_STRUCT__entry( | ||
123 | __field(const char *, name) | ||
124 | __field(u32, mem_id) | ||
125 | __field(u32, words) | ||
126 | __field(u32, offset) | ||
127 | ), | ||
128 | |||
129 | TP_fast_assign( | ||
130 | __entry->name = name; | ||
131 | __entry->mem_id = mem_id; | ||
132 | __entry->words = words; | ||
133 | __entry->offset = offset; | ||
134 | ), | ||
135 | |||
136 | TP_printk("name=%s, mem_id=%08x, words=%u, offset=%d", | ||
137 | __entry->name, __entry->mem_id, | ||
138 | __entry->words, __entry->offset) | ||
139 | ); | ||
140 | |||
141 | TRACE_EVENT(nvhost_channel_write_cmdbuf_data, | ||
142 | TP_PROTO(const char *name, u32 mem_id, | ||
143 | u32 words, u32 offset, void *cmdbuf), | ||
144 | |||
145 | TP_ARGS(name, mem_id, words, offset, cmdbuf), | ||
146 | |||
147 | TP_STRUCT__entry( | ||
148 | __field(const char *, name) | ||
149 | __field(u32, mem_id) | ||
150 | __field(u32, words) | ||
151 | __field(u32, offset) | ||
152 | __field(bool, cmdbuf) | ||
153 | __dynamic_array(u32, cmdbuf, words) | ||
154 | ), | ||
155 | |||
156 | TP_fast_assign( | ||
157 | if (cmdbuf) { | ||
158 | memcpy(__get_dynamic_array(cmdbuf), cmdbuf+offset, | ||
159 | words * sizeof(u32)); | ||
160 | } | ||
161 | __entry->cmdbuf = cmdbuf; | ||
162 | __entry->name = name; | ||
163 | __entry->mem_id = mem_id; | ||
164 | __entry->words = words; | ||
165 | __entry->offset = offset; | ||
166 | ), | ||
167 | |||
168 | TP_printk("name=%s, mem_id=%08x, words=%u, offset=%d, contents=[%s]", | ||
169 | __entry->name, __entry->mem_id, | ||
170 | __entry->words, __entry->offset, | ||
171 | __print_hex(__get_dynamic_array(cmdbuf), | ||
172 | __entry->cmdbuf ? __entry->words * 4 : 0)) | ||
173 | ); | ||
174 | |||
175 | TRACE_EVENT(nvhost_channel_write_reloc, | ||
176 | TP_PROTO(const char *name), | ||
177 | |||
178 | TP_ARGS(name), | ||
179 | |||
180 | TP_STRUCT__entry( | ||
181 | __field(const char *, name) | ||
182 | ), | ||
183 | |||
184 | TP_fast_assign( | ||
185 | __entry->name = name; | ||
186 | ), | ||
187 | |||
188 | TP_printk("name=%s", | ||
189 | __entry->name) | ||
190 | ); | ||
191 | |||
192 | TRACE_EVENT(nvhost_channel_write_waitchks, | ||
193 | TP_PROTO(const char *name, u32 waitchks, u32 waitmask), | ||
194 | |||
195 | TP_ARGS(name, waitchks, waitmask), | ||
196 | |||
197 | TP_STRUCT__entry( | ||
198 | __field(const char *, name) | ||
199 | __field(u32, waitchks) | ||
200 | __field(u32, waitmask) | ||
201 | ), | ||
202 | |||
203 | TP_fast_assign( | ||
204 | __entry->name = name; | ||
205 | __entry->waitchks = waitchks; | ||
206 | __entry->waitmask = waitmask; | ||
207 | ), | ||
208 | |||
209 | TP_printk("name=%s, waitchks=%u, waitmask=%08x", | ||
210 | __entry->name, __entry->waitchks, __entry->waitmask) | ||
211 | ); | ||
212 | |||
213 | TRACE_EVENT(nvhost_channel_context_save, | ||
214 | TP_PROTO(const char *name, void *ctx), | ||
215 | |||
216 | TP_ARGS(name, ctx), | ||
217 | |||
218 | TP_STRUCT__entry( | ||
219 | __field(const char *, name) | ||
220 | __field(void*, ctx) | ||
221 | ), | ||
222 | |||
223 | TP_fast_assign( | ||
224 | __entry->name = name; | ||
225 | __entry->ctx = ctx; | ||
226 | ), | ||
227 | |||
228 | TP_printk("name=%s, ctx=%p", | ||
229 | __entry->name, __entry->ctx) | ||
230 | ); | ||
231 | |||
232 | TRACE_EVENT(nvhost_channel_context_restore, | ||
233 | TP_PROTO(const char *name, void *ctx), | ||
234 | |||
235 | TP_ARGS(name, ctx), | ||
236 | |||
237 | TP_STRUCT__entry( | ||
238 | __field(const char *, name) | ||
239 | __field(void*, ctx) | ||
240 | ), | ||
241 | |||
242 | TP_fast_assign( | ||
243 | __entry->name = name; | ||
244 | __entry->ctx = ctx; | ||
245 | ), | ||
246 | |||
247 | TP_printk("name=%s, ctx=%p", | ||
248 | __entry->name, __entry->ctx) | ||
249 | ); | ||
250 | |||
251 | TRACE_EVENT(nvhost_ctrlopen, | ||
252 | TP_PROTO(const char *name), | ||
253 | TP_ARGS(name), | ||
254 | TP_STRUCT__entry( | ||
255 | __field(const char *, name) | ||
256 | ), | ||
257 | TP_fast_assign( | ||
258 | __entry->name = name | ||
259 | ), | ||
260 | TP_printk("name=%s", __entry->name) | ||
261 | ); | ||
262 | |||
263 | TRACE_EVENT(nvhost_ctrlrelease, | ||
264 | TP_PROTO(const char *name), | ||
265 | TP_ARGS(name), | ||
266 | TP_STRUCT__entry( | ||
267 | __field(const char *, name) | ||
268 | ), | ||
269 | TP_fast_assign( | ||
270 | __entry->name = name | ||
271 | ), | ||
272 | TP_printk("name=%s", __entry->name) | ||
273 | ); | ||
274 | |||
275 | TRACE_EVENT(nvhost_ioctl_ctrl_module_mutex, | ||
276 | TP_PROTO(u32 lock, u32 id), | ||
277 | |||
278 | TP_ARGS(lock, id), | ||
279 | |||
280 | TP_STRUCT__entry( | ||
281 | __field(u32, lock); | ||
282 | __field(u32, id); | ||
283 | ), | ||
284 | |||
285 | TP_fast_assign( | ||
286 | __entry->lock = lock; | ||
287 | __entry->id = id; | ||
288 | ), | ||
289 | |||
290 | TP_printk("lock=%u, id=%d", | ||
291 | __entry->lock, __entry->id) | ||
292 | ); | ||
293 | |||
294 | TRACE_EVENT(nvhost_ioctl_ctrl_syncpt_incr, | ||
295 | TP_PROTO(u32 id), | ||
296 | |||
297 | TP_ARGS(id), | ||
298 | |||
299 | TP_STRUCT__entry( | ||
300 | __field(u32, id); | ||
301 | ), | ||
302 | |||
303 | TP_fast_assign( | ||
304 | __entry->id = id; | ||
305 | ), | ||
306 | |||
307 | TP_printk("id=%d", __entry->id) | ||
308 | ); | ||
309 | |||
310 | TRACE_EVENT(nvhost_ioctl_ctrl_syncpt_read, | ||
311 | TP_PROTO(u32 id, u32 value), | ||
312 | |||
313 | TP_ARGS(id, value), | ||
314 | |||
315 | TP_STRUCT__entry( | ||
316 | __field(u32, id); | ||
317 | __field(u32, value); | ||
318 | ), | ||
319 | |||
320 | TP_fast_assign( | ||
321 | __entry->id = id; | ||
322 | __entry->value = value; | ||
323 | ), | ||
324 | |||
325 | TP_printk("id=%d, value=%d", __entry->id, __entry->value) | ||
326 | ); | ||
327 | |||
328 | TRACE_EVENT(nvhost_ioctl_ctrl_syncpt_wait, | ||
329 | TP_PROTO(u32 id, u32 threshold, s32 timeout, u32 value, int err), | ||
330 | |||
331 | TP_ARGS(id, threshold, timeout, value, err), | ||
332 | |||
333 | TP_STRUCT__entry( | ||
334 | __field(u32, id) | ||
335 | __field(u32, threshold) | ||
336 | __field(s32, timeout) | ||
337 | __field(u32, value) | ||
338 | __field(int, err) | ||
339 | ), | ||
340 | |||
341 | TP_fast_assign( | ||
342 | __entry->id = id; | ||
343 | __entry->threshold = threshold; | ||
344 | __entry->timeout = timeout; | ||
345 | __entry->value = value; | ||
346 | __entry->err = err; | ||
347 | ), | ||
348 | |||
349 | TP_printk("id=%u, threshold=%u, timeout=%d, value=%u, err=%d", | ||
350 | __entry->id, __entry->threshold, __entry->timeout, | ||
351 | __entry->value, __entry->err) | ||
352 | ); | ||
353 | |||
354 | TRACE_EVENT(nvhost_ioctl_ctrl_module_regrdwr, | ||
355 | TP_PROTO(u32 id, u32 num_offsets, bool write), | ||
356 | |||
357 | TP_ARGS(id, num_offsets, write), | ||
358 | |||
359 | TP_STRUCT__entry( | ||
360 | __field(u32, id) | ||
361 | __field(u32, num_offsets) | ||
362 | __field(bool, write) | ||
363 | ), | ||
364 | |||
365 | TP_fast_assign( | ||
366 | __entry->id = id; | ||
367 | __entry->num_offsets = num_offsets; | ||
368 | __entry->write = write; | ||
369 | ), | ||
370 | |||
371 | TP_printk("id=%u, num_offsets=%u, write=%d", | ||
372 | __entry->id, __entry->num_offsets, __entry->write) | ||
373 | ); | ||
374 | |||
375 | TRACE_EVENT(nvhost_channel_submitted, | ||
376 | TP_PROTO(const char *name, u32 syncpt_base, u32 syncpt_max), | ||
377 | |||
378 | TP_ARGS(name, syncpt_base, syncpt_max), | ||
379 | |||
380 | TP_STRUCT__entry( | ||
381 | __field(const char *, name) | ||
382 | __field(u32, syncpt_base) | ||
383 | __field(u32, syncpt_max) | ||
384 | ), | ||
385 | |||
386 | TP_fast_assign( | ||
387 | __entry->name = name; | ||
388 | __entry->syncpt_base = syncpt_base; | ||
389 | __entry->syncpt_max = syncpt_max; | ||
390 | ), | ||
391 | |||
392 | TP_printk("name=%s, syncpt_base=%d, syncpt_max=%d", | ||
393 | __entry->name, __entry->syncpt_base, __entry->syncpt_max) | ||
394 | ); | ||
395 | |||
396 | TRACE_EVENT(nvhost_channel_submit_complete, | ||
397 | TP_PROTO(const char *name, int count, u32 thresh), | ||
398 | |||
399 | TP_ARGS(name, count, thresh), | ||
400 | |||
401 | TP_STRUCT__entry( | ||
402 | __field(const char *, name) | ||
403 | __field(int, count) | ||
404 | __field(u32, thresh) | ||
405 | ), | ||
406 | |||
407 | TP_fast_assign( | ||
408 | __entry->name = name; | ||
409 | __entry->count = count; | ||
410 | __entry->thresh = thresh; | ||
411 | ), | ||
412 | |||
413 | TP_printk("name=%s, count=%d, thresh=%d", | ||
414 | __entry->name, __entry->count, __entry->thresh) | ||
415 | ); | ||
416 | |||
417 | TRACE_EVENT(nvhost_wait_cdma, | ||
418 | TP_PROTO(const char *name, u32 eventid), | ||
419 | |||
420 | TP_ARGS(name, eventid), | ||
421 | |||
422 | TP_STRUCT__entry( | ||
423 | __field(const char *, name) | ||
424 | __field(u32, eventid) | ||
425 | ), | ||
426 | |||
427 | TP_fast_assign( | ||
428 | __entry->name = name; | ||
429 | __entry->eventid = eventid; | ||
430 | ), | ||
431 | |||
432 | TP_printk("name=%s, event=%d", __entry->name, __entry->eventid) | ||
433 | ); | ||
434 | |||
435 | #endif /* _TRACE_NVHOST_H */ | ||
436 | |||
437 | /* This part must be outside protection */ | ||
438 | #include <trace/define_trace.h> | ||
diff --git a/include/trace/events/regmap.h b/include/trace/events/regmap.h new file mode 100644 index 00000000000..12fbf43524e --- /dev/null +++ b/include/trace/events/regmap.h | |||
@@ -0,0 +1,145 @@ | |||
1 | #undef TRACE_SYSTEM | ||
2 | #define TRACE_SYSTEM regmap | ||
3 | |||
4 | #if !defined(_TRACE_REGMAP_H) || defined(TRACE_HEADER_MULTI_READ) | ||
5 | #define _TRACE_REGMAP_H | ||
6 | |||
7 | #include <linux/device.h> | ||
8 | #include <linux/ktime.h> | ||
9 | #include <linux/tracepoint.h> | ||
10 | |||
11 | struct regmap; | ||
12 | |||
13 | /* | ||
14 | * Log register events | ||
15 | */ | ||
16 | DECLARE_EVENT_CLASS(regmap_reg, | ||
17 | |||
18 | TP_PROTO(struct device *dev, unsigned int reg, | ||
19 | unsigned int val), | ||
20 | |||
21 | TP_ARGS(dev, reg, val), | ||
22 | |||
23 | TP_STRUCT__entry( | ||
24 | __string( name, dev_name(dev) ) | ||
25 | __field( unsigned int, reg ) | ||
26 | __field( unsigned int, val ) | ||
27 | ), | ||
28 | |||
29 | TP_fast_assign( | ||
30 | __assign_str(name, dev_name(dev)); | ||
31 | __entry->reg = reg; | ||
32 | __entry->val = val; | ||
33 | ), | ||
34 | |||
35 | TP_printk("%s reg=%x val=%x", __get_str(name), | ||
36 | (unsigned int)__entry->reg, | ||
37 | (unsigned int)__entry->val) | ||
38 | ); | ||
39 | |||
40 | DEFINE_EVENT(regmap_reg, regmap_reg_write, | ||
41 | |||
42 | TP_PROTO(struct device *dev, unsigned int reg, | ||
43 | unsigned int val), | ||
44 | |||
45 | TP_ARGS(dev, reg, val) | ||
46 | |||
47 | ); | ||
48 | |||
49 | DEFINE_EVENT(regmap_reg, regmap_reg_read, | ||
50 | |||
51 | TP_PROTO(struct device *dev, unsigned int reg, | ||
52 | unsigned int val), | ||
53 | |||
54 | TP_ARGS(dev, reg, val) | ||
55 | |||
56 | ); | ||
57 | |||
58 | DEFINE_EVENT(regmap_reg, regmap_reg_read_cache, | ||
59 | |||
60 | TP_PROTO(struct device *dev, unsigned int reg, | ||
61 | unsigned int val), | ||
62 | |||
63 | TP_ARGS(dev, reg, val) | ||
64 | |||
65 | ); | ||
66 | |||
67 | DECLARE_EVENT_CLASS(regmap_block, | ||
68 | |||
69 | TP_PROTO(struct device *dev, unsigned int reg, int count), | ||
70 | |||
71 | TP_ARGS(dev, reg, count), | ||
72 | |||
73 | TP_STRUCT__entry( | ||
74 | __string( name, dev_name(dev) ) | ||
75 | __field( unsigned int, reg ) | ||
76 | __field( int, count ) | ||
77 | ), | ||
78 | |||
79 | TP_fast_assign( | ||
80 | __assign_str(name, dev_name(dev)); | ||
81 | __entry->reg = reg; | ||
82 | __entry->count = count; | ||
83 | ), | ||
84 | |||
85 | TP_printk("%s reg=%x count=%d", __get_str(name), | ||
86 | (unsigned int)__entry->reg, | ||
87 | (int)__entry->count) | ||
88 | ); | ||
89 | |||
90 | DEFINE_EVENT(regmap_block, regmap_hw_read_start, | ||
91 | |||
92 | TP_PROTO(struct device *dev, unsigned int reg, int count), | ||
93 | |||
94 | TP_ARGS(dev, reg, count) | ||
95 | ); | ||
96 | |||
97 | DEFINE_EVENT(regmap_block, regmap_hw_read_done, | ||
98 | |||
99 | TP_PROTO(struct device *dev, unsigned int reg, int count), | ||
100 | |||
101 | TP_ARGS(dev, reg, count) | ||
102 | ); | ||
103 | |||
104 | DEFINE_EVENT(regmap_block, regmap_hw_write_start, | ||
105 | |||
106 | TP_PROTO(struct device *dev, unsigned int reg, int count), | ||
107 | |||
108 | TP_ARGS(dev, reg, count) | ||
109 | ); | ||
110 | |||
111 | DEFINE_EVENT(regmap_block, regmap_hw_write_done, | ||
112 | |||
113 | TP_PROTO(struct device *dev, unsigned int reg, int count), | ||
114 | |||
115 | TP_ARGS(dev, reg, count) | ||
116 | ); | ||
117 | |||
118 | TRACE_EVENT(regcache_sync, | ||
119 | |||
120 | TP_PROTO(struct device *dev, const char *type, | ||
121 | const char *status), | ||
122 | |||
123 | TP_ARGS(dev, type, status), | ||
124 | |||
125 | TP_STRUCT__entry( | ||
126 | __string( name, dev_name(dev) ) | ||
127 | __string( status, status ) | ||
128 | __string( type, type ) | ||
129 | __field( int, type ) | ||
130 | ), | ||
131 | |||
132 | TP_fast_assign( | ||
133 | __assign_str(name, dev_name(dev)); | ||
134 | __assign_str(status, status); | ||
135 | __assign_str(type, type); | ||
136 | ), | ||
137 | |||
138 | TP_printk("%s type=%s status=%s", __get_str(name), | ||
139 | __get_str(type), __get_str(status)) | ||
140 | ); | ||
141 | |||
142 | #endif /* _TRACE_REGMAP_H */ | ||
143 | |||
144 | /* This part must be outside protection */ | ||
145 | #include <trace/define_trace.h> | ||
diff --git a/include/trace/events/sock.h b/include/trace/events/sock.h new file mode 100644 index 00000000000..779abb91df8 --- /dev/null +++ b/include/trace/events/sock.h | |||
@@ -0,0 +1,68 @@ | |||
1 | #undef TRACE_SYSTEM | ||
2 | #define TRACE_SYSTEM sock | ||
3 | |||
4 | #if !defined(_TRACE_SOCK_H) || defined(TRACE_HEADER_MULTI_READ) | ||
5 | #define _TRACE_SOCK_H | ||
6 | |||
7 | #include <net/sock.h> | ||
8 | #include <linux/tracepoint.h> | ||
9 | |||
10 | TRACE_EVENT(sock_rcvqueue_full, | ||
11 | |||
12 | TP_PROTO(struct sock *sk, struct sk_buff *skb), | ||
13 | |||
14 | TP_ARGS(sk, skb), | ||
15 | |||
16 | TP_STRUCT__entry( | ||
17 | __field(int, rmem_alloc) | ||
18 | __field(unsigned int, truesize) | ||
19 | __field(int, sk_rcvbuf) | ||
20 | ), | ||
21 | |||
22 | TP_fast_assign( | ||
23 | __entry->rmem_alloc = atomic_read(&sk->sk_rmem_alloc); | ||
24 | __entry->truesize = skb->truesize; | ||
25 | __entry->sk_rcvbuf = sk->sk_rcvbuf; | ||
26 | ), | ||
27 | |||
28 | TP_printk("rmem_alloc=%d truesize=%u sk_rcvbuf=%d", | ||
29 | __entry->rmem_alloc, __entry->truesize, __entry->sk_rcvbuf) | ||
30 | ); | ||
31 | |||
32 | TRACE_EVENT(sock_exceed_buf_limit, | ||
33 | |||
34 | TP_PROTO(struct sock *sk, struct proto *prot, long allocated), | ||
35 | |||
36 | TP_ARGS(sk, prot, allocated), | ||
37 | |||
38 | TP_STRUCT__entry( | ||
39 | __array(char, name, 32) | ||
40 | __field(long *, sysctl_mem) | ||
41 | __field(long, allocated) | ||
42 | __field(int, sysctl_rmem) | ||
43 | __field(int, rmem_alloc) | ||
44 | ), | ||
45 | |||
46 | TP_fast_assign( | ||
47 | strncpy(__entry->name, prot->name, 32); | ||
48 | __entry->sysctl_mem = prot->sysctl_mem; | ||
49 | __entry->allocated = allocated; | ||
50 | __entry->sysctl_rmem = prot->sysctl_rmem[0]; | ||
51 | __entry->rmem_alloc = atomic_read(&sk->sk_rmem_alloc); | ||
52 | ), | ||
53 | |||
54 | TP_printk("proto:%s sysctl_mem=%ld,%ld,%ld allocated=%ld " | ||
55 | "sysctl_rmem=%d rmem_alloc=%d", | ||
56 | __entry->name, | ||
57 | __entry->sysctl_mem[0], | ||
58 | __entry->sysctl_mem[1], | ||
59 | __entry->sysctl_mem[2], | ||
60 | __entry->allocated, | ||
61 | __entry->sysctl_rmem, | ||
62 | __entry->rmem_alloc) | ||
63 | ); | ||
64 | |||
65 | #endif /* _TRACE_SOCK_H */ | ||
66 | |||
67 | /* This part must be outside protection */ | ||
68 | #include <trace/define_trace.h> | ||
diff --git a/include/trace/events/udp.h b/include/trace/events/udp.h new file mode 100644 index 00000000000..a664bb94097 --- /dev/null +++ b/include/trace/events/udp.h | |||
@@ -0,0 +1,32 @@ | |||
1 | #undef TRACE_SYSTEM | ||
2 | #define TRACE_SYSTEM udp | ||
3 | |||
4 | #if !defined(_TRACE_UDP_H) || defined(TRACE_HEADER_MULTI_READ) | ||
5 | #define _TRACE_UDP_H | ||
6 | |||
7 | #include <linux/udp.h> | ||
8 | #include <linux/tracepoint.h> | ||
9 | |||
10 | TRACE_EVENT(udp_fail_queue_rcv_skb, | ||
11 | |||
12 | TP_PROTO(int rc, struct sock *sk), | ||
13 | |||
14 | TP_ARGS(rc, sk), | ||
15 | |||
16 | TP_STRUCT__entry( | ||
17 | __field(int, rc) | ||
18 | __field(__u16, lport) | ||
19 | ), | ||
20 | |||
21 | TP_fast_assign( | ||
22 | __entry->rc = rc; | ||
23 | __entry->lport = inet_sk(sk)->inet_num; | ||
24 | ), | ||
25 | |||
26 | TP_printk("rc=%d port=%hu", __entry->rc, __entry->lport) | ||
27 | ); | ||
28 | |||
29 | #endif /* _TRACE_UDP_H */ | ||
30 | |||
31 | /* This part must be outside protection */ | ||
32 | #include <trace/define_trace.h> | ||
diff --git a/include/trace/events/vmscan.h b/include/trace/events/vmscan.h index b2c33bd955f..36851f7f13d 100644 --- a/include/trace/events/vmscan.h +++ b/include/trace/events/vmscan.h | |||
@@ -179,6 +179,83 @@ DEFINE_EVENT(mm_vmscan_direct_reclaim_end_template, mm_vmscan_memcg_softlimit_re | |||
179 | TP_ARGS(nr_reclaimed) | 179 | TP_ARGS(nr_reclaimed) |
180 | ); | 180 | ); |
181 | 181 | ||
182 | TRACE_EVENT(mm_shrink_slab_start, | ||
183 | TP_PROTO(struct shrinker *shr, struct shrink_control *sc, | ||
184 | long nr_objects_to_shrink, unsigned long pgs_scanned, | ||
185 | unsigned long lru_pgs, unsigned long cache_items, | ||
186 | unsigned long long delta, unsigned long total_scan), | ||
187 | |||
188 | TP_ARGS(shr, sc, nr_objects_to_shrink, pgs_scanned, lru_pgs, | ||
189 | cache_items, delta, total_scan), | ||
190 | |||
191 | TP_STRUCT__entry( | ||
192 | __field(struct shrinker *, shr) | ||
193 | __field(void *, shrink) | ||
194 | __field(long, nr_objects_to_shrink) | ||
195 | __field(gfp_t, gfp_flags) | ||
196 | __field(unsigned long, pgs_scanned) | ||
197 | __field(unsigned long, lru_pgs) | ||
198 | __field(unsigned long, cache_items) | ||
199 | __field(unsigned long long, delta) | ||
200 | __field(unsigned long, total_scan) | ||
201 | ), | ||
202 | |||
203 | TP_fast_assign( | ||
204 | __entry->shr = shr; | ||
205 | __entry->shrink = shr->shrink; | ||
206 | __entry->nr_objects_to_shrink = nr_objects_to_shrink; | ||
207 | __entry->gfp_flags = sc->gfp_mask; | ||
208 | __entry->pgs_scanned = pgs_scanned; | ||
209 | __entry->lru_pgs = lru_pgs; | ||
210 | __entry->cache_items = cache_items; | ||
211 | __entry->delta = delta; | ||
212 | __entry->total_scan = total_scan; | ||
213 | ), | ||
214 | |||
215 | TP_printk("%pF %p: objects to shrink %ld gfp_flags %s pgs_scanned %ld lru_pgs %ld cache items %ld delta %lld total_scan %ld", | ||
216 | __entry->shrink, | ||
217 | __entry->shr, | ||
218 | __entry->nr_objects_to_shrink, | ||
219 | show_gfp_flags(__entry->gfp_flags), | ||
220 | __entry->pgs_scanned, | ||
221 | __entry->lru_pgs, | ||
222 | __entry->cache_items, | ||
223 | __entry->delta, | ||
224 | __entry->total_scan) | ||
225 | ); | ||
226 | |||
227 | TRACE_EVENT(mm_shrink_slab_end, | ||
228 | TP_PROTO(struct shrinker *shr, int shrinker_retval, | ||
229 | long unused_scan_cnt, long new_scan_cnt), | ||
230 | |||
231 | TP_ARGS(shr, shrinker_retval, unused_scan_cnt, new_scan_cnt), | ||
232 | |||
233 | TP_STRUCT__entry( | ||
234 | __field(struct shrinker *, shr) | ||
235 | __field(void *, shrink) | ||
236 | __field(long, unused_scan) | ||
237 | __field(long, new_scan) | ||
238 | __field(int, retval) | ||
239 | __field(long, total_scan) | ||
240 | ), | ||
241 | |||
242 | TP_fast_assign( | ||
243 | __entry->shr = shr; | ||
244 | __entry->shrink = shr->shrink; | ||
245 | __entry->unused_scan = unused_scan_cnt; | ||
246 | __entry->new_scan = new_scan_cnt; | ||
247 | __entry->retval = shrinker_retval; | ||
248 | __entry->total_scan = new_scan_cnt - unused_scan_cnt; | ||
249 | ), | ||
250 | |||
251 | TP_printk("%pF %p: unused scan count %ld new scan count %ld total_scan %ld last shrinker return val %d", | ||
252 | __entry->shrink, | ||
253 | __entry->shr, | ||
254 | __entry->unused_scan, | ||
255 | __entry->new_scan, | ||
256 | __entry->total_scan, | ||
257 | __entry->retval) | ||
258 | ); | ||
182 | 259 | ||
183 | DECLARE_EVENT_CLASS(mm_vmscan_lru_isolate_template, | 260 | DECLARE_EVENT_CLASS(mm_vmscan_lru_isolate_template, |
184 | 261 | ||
diff --git a/include/trace/events/writeback.h b/include/trace/events/writeback.h index 4e249b927ea..5f172703eb4 100644 --- a/include/trace/events/writeback.h +++ b/include/trace/events/writeback.h | |||
@@ -8,6 +8,19 @@ | |||
8 | #include <linux/device.h> | 8 | #include <linux/device.h> |
9 | #include <linux/writeback.h> | 9 | #include <linux/writeback.h> |
10 | 10 | ||
11 | #define show_inode_state(state) \ | ||
12 | __print_flags(state, "|", \ | ||
13 | {I_DIRTY_SYNC, "I_DIRTY_SYNC"}, \ | ||
14 | {I_DIRTY_DATASYNC, "I_DIRTY_DATASYNC"}, \ | ||
15 | {I_DIRTY_PAGES, "I_DIRTY_PAGES"}, \ | ||
16 | {I_NEW, "I_NEW"}, \ | ||
17 | {I_WILL_FREE, "I_WILL_FREE"}, \ | ||
18 | {I_FREEING, "I_FREEING"}, \ | ||
19 | {I_CLEAR, "I_CLEAR"}, \ | ||
20 | {I_SYNC, "I_SYNC"}, \ | ||
21 | {I_REFERENCED, "I_REFERENCED"} \ | ||
22 | ) | ||
23 | |||
11 | struct wb_writeback_work; | 24 | struct wb_writeback_work; |
12 | 25 | ||
13 | DECLARE_EVENT_CLASS(writeback_work_class, | 26 | DECLARE_EVENT_CLASS(writeback_work_class, |
@@ -49,6 +62,9 @@ DEFINE_EVENT(writeback_work_class, name, \ | |||
49 | DEFINE_WRITEBACK_WORK_EVENT(writeback_nothread); | 62 | DEFINE_WRITEBACK_WORK_EVENT(writeback_nothread); |
50 | DEFINE_WRITEBACK_WORK_EVENT(writeback_queue); | 63 | DEFINE_WRITEBACK_WORK_EVENT(writeback_queue); |
51 | DEFINE_WRITEBACK_WORK_EVENT(writeback_exec); | 64 | DEFINE_WRITEBACK_WORK_EVENT(writeback_exec); |
65 | DEFINE_WRITEBACK_WORK_EVENT(writeback_start); | ||
66 | DEFINE_WRITEBACK_WORK_EVENT(writeback_written); | ||
67 | DEFINE_WRITEBACK_WORK_EVENT(writeback_wait); | ||
52 | 68 | ||
53 | TRACE_EVENT(writeback_pages_written, | 69 | TRACE_EVENT(writeback_pages_written, |
54 | TP_PROTO(long pages_written), | 70 | TP_PROTO(long pages_written), |
@@ -88,6 +104,30 @@ DEFINE_WRITEBACK_EVENT(writeback_bdi_register); | |||
88 | DEFINE_WRITEBACK_EVENT(writeback_bdi_unregister); | 104 | DEFINE_WRITEBACK_EVENT(writeback_bdi_unregister); |
89 | DEFINE_WRITEBACK_EVENT(writeback_thread_start); | 105 | DEFINE_WRITEBACK_EVENT(writeback_thread_start); |
90 | DEFINE_WRITEBACK_EVENT(writeback_thread_stop); | 106 | DEFINE_WRITEBACK_EVENT(writeback_thread_stop); |
107 | DEFINE_WRITEBACK_EVENT(balance_dirty_start); | ||
108 | DEFINE_WRITEBACK_EVENT(balance_dirty_wait); | ||
109 | |||
110 | TRACE_EVENT(balance_dirty_written, | ||
111 | |||
112 | TP_PROTO(struct backing_dev_info *bdi, int written), | ||
113 | |||
114 | TP_ARGS(bdi, written), | ||
115 | |||
116 | TP_STRUCT__entry( | ||
117 | __array(char, name, 32) | ||
118 | __field(int, written) | ||
119 | ), | ||
120 | |||
121 | TP_fast_assign( | ||
122 | strncpy(__entry->name, dev_name(bdi->dev), 32); | ||
123 | __entry->written = written; | ||
124 | ), | ||
125 | |||
126 | TP_printk("bdi %s written %d", | ||
127 | __entry->name, | ||
128 | __entry->written | ||
129 | ) | ||
130 | ); | ||
91 | 131 | ||
92 | DECLARE_EVENT_CLASS(wbc_class, | 132 | DECLARE_EVENT_CLASS(wbc_class, |
93 | TP_PROTO(struct writeback_control *wbc, struct backing_dev_info *bdi), | 133 | TP_PROTO(struct writeback_control *wbc, struct backing_dev_info *bdi), |
@@ -101,8 +141,6 @@ DECLARE_EVENT_CLASS(wbc_class, | |||
101 | __field(int, for_background) | 141 | __field(int, for_background) |
102 | __field(int, for_reclaim) | 142 | __field(int, for_reclaim) |
103 | __field(int, range_cyclic) | 143 | __field(int, range_cyclic) |
104 | __field(int, more_io) | ||
105 | __field(unsigned long, older_than_this) | ||
106 | __field(long, range_start) | 144 | __field(long, range_start) |
107 | __field(long, range_end) | 145 | __field(long, range_end) |
108 | ), | 146 | ), |
@@ -116,15 +154,12 @@ DECLARE_EVENT_CLASS(wbc_class, | |||
116 | __entry->for_background = wbc->for_background; | 154 | __entry->for_background = wbc->for_background; |
117 | __entry->for_reclaim = wbc->for_reclaim; | 155 | __entry->for_reclaim = wbc->for_reclaim; |
118 | __entry->range_cyclic = wbc->range_cyclic; | 156 | __entry->range_cyclic = wbc->range_cyclic; |
119 | __entry->more_io = wbc->more_io; | ||
120 | __entry->older_than_this = wbc->older_than_this ? | ||
121 | *wbc->older_than_this : 0; | ||
122 | __entry->range_start = (long)wbc->range_start; | 157 | __entry->range_start = (long)wbc->range_start; |
123 | __entry->range_end = (long)wbc->range_end; | 158 | __entry->range_end = (long)wbc->range_end; |
124 | ), | 159 | ), |
125 | 160 | ||
126 | TP_printk("bdi %s: towrt=%ld skip=%ld mode=%d kupd=%d " | 161 | TP_printk("bdi %s: towrt=%ld skip=%ld mode=%d kupd=%d " |
127 | "bgrd=%d reclm=%d cyclic=%d more=%d older=0x%lx " | 162 | "bgrd=%d reclm=%d cyclic=%d " |
128 | "start=0x%lx end=0x%lx", | 163 | "start=0x%lx end=0x%lx", |
129 | __entry->name, | 164 | __entry->name, |
130 | __entry->nr_to_write, | 165 | __entry->nr_to_write, |
@@ -134,8 +169,6 @@ DECLARE_EVENT_CLASS(wbc_class, | |||
134 | __entry->for_background, | 169 | __entry->for_background, |
135 | __entry->for_reclaim, | 170 | __entry->for_reclaim, |
136 | __entry->range_cyclic, | 171 | __entry->range_cyclic, |
137 | __entry->more_io, | ||
138 | __entry->older_than_this, | ||
139 | __entry->range_start, | 172 | __entry->range_start, |
140 | __entry->range_end) | 173 | __entry->range_end) |
141 | ) | 174 | ) |
@@ -144,14 +177,79 @@ DECLARE_EVENT_CLASS(wbc_class, | |||
144 | DEFINE_EVENT(wbc_class, name, \ | 177 | DEFINE_EVENT(wbc_class, name, \ |
145 | TP_PROTO(struct writeback_control *wbc, struct backing_dev_info *bdi), \ | 178 | TP_PROTO(struct writeback_control *wbc, struct backing_dev_info *bdi), \ |
146 | TP_ARGS(wbc, bdi)) | 179 | TP_ARGS(wbc, bdi)) |
147 | DEFINE_WBC_EVENT(wbc_writeback_start); | ||
148 | DEFINE_WBC_EVENT(wbc_writeback_written); | ||
149 | DEFINE_WBC_EVENT(wbc_writeback_wait); | ||
150 | DEFINE_WBC_EVENT(wbc_balance_dirty_start); | ||
151 | DEFINE_WBC_EVENT(wbc_balance_dirty_written); | ||
152 | DEFINE_WBC_EVENT(wbc_balance_dirty_wait); | ||
153 | DEFINE_WBC_EVENT(wbc_writepage); | 180 | DEFINE_WBC_EVENT(wbc_writepage); |
154 | 181 | ||
182 | TRACE_EVENT(writeback_queue_io, | ||
183 | TP_PROTO(struct bdi_writeback *wb, | ||
184 | unsigned long *older_than_this, | ||
185 | int moved), | ||
186 | TP_ARGS(wb, older_than_this, moved), | ||
187 | TP_STRUCT__entry( | ||
188 | __array(char, name, 32) | ||
189 | __field(unsigned long, older) | ||
190 | __field(long, age) | ||
191 | __field(int, moved) | ||
192 | ), | ||
193 | TP_fast_assign( | ||
194 | strncpy(__entry->name, dev_name(wb->bdi->dev), 32); | ||
195 | __entry->older = older_than_this ? *older_than_this : 0; | ||
196 | __entry->age = older_than_this ? | ||
197 | (jiffies - *older_than_this) * 1000 / HZ : -1; | ||
198 | __entry->moved = moved; | ||
199 | ), | ||
200 | TP_printk("bdi %s: older=%lu age=%ld enqueue=%d", | ||
201 | __entry->name, | ||
202 | __entry->older, /* older_than_this in jiffies */ | ||
203 | __entry->age, /* older_than_this in relative milliseconds */ | ||
204 | __entry->moved) | ||
205 | ); | ||
206 | |||
207 | TRACE_EVENT(global_dirty_state, | ||
208 | |||
209 | TP_PROTO(unsigned long background_thresh, | ||
210 | unsigned long dirty_thresh | ||
211 | ), | ||
212 | |||
213 | TP_ARGS(background_thresh, | ||
214 | dirty_thresh | ||
215 | ), | ||
216 | |||
217 | TP_STRUCT__entry( | ||
218 | __field(unsigned long, nr_dirty) | ||
219 | __field(unsigned long, nr_writeback) | ||
220 | __field(unsigned long, nr_unstable) | ||
221 | __field(unsigned long, background_thresh) | ||
222 | __field(unsigned long, dirty_thresh) | ||
223 | __field(unsigned long, dirty_limit) | ||
224 | __field(unsigned long, nr_dirtied) | ||
225 | __field(unsigned long, nr_written) | ||
226 | ), | ||
227 | |||
228 | TP_fast_assign( | ||
229 | __entry->nr_dirty = global_page_state(NR_FILE_DIRTY); | ||
230 | __entry->nr_writeback = global_page_state(NR_WRITEBACK); | ||
231 | __entry->nr_unstable = global_page_state(NR_UNSTABLE_NFS); | ||
232 | __entry->nr_dirtied = global_page_state(NR_DIRTIED); | ||
233 | __entry->nr_written = global_page_state(NR_WRITTEN); | ||
234 | __entry->background_thresh = background_thresh; | ||
235 | __entry->dirty_thresh = dirty_thresh; | ||
236 | __entry->dirty_limit = global_dirty_limit; | ||
237 | ), | ||
238 | |||
239 | TP_printk("dirty=%lu writeback=%lu unstable=%lu " | ||
240 | "bg_thresh=%lu thresh=%lu limit=%lu " | ||
241 | "dirtied=%lu written=%lu", | ||
242 | __entry->nr_dirty, | ||
243 | __entry->nr_writeback, | ||
244 | __entry->nr_unstable, | ||
245 | __entry->background_thresh, | ||
246 | __entry->dirty_thresh, | ||
247 | __entry->dirty_limit, | ||
248 | __entry->nr_dirtied, | ||
249 | __entry->nr_written | ||
250 | ) | ||
251 | ); | ||
252 | |||
155 | DECLARE_EVENT_CLASS(writeback_congest_waited_template, | 253 | DECLARE_EVENT_CLASS(writeback_congest_waited_template, |
156 | 254 | ||
157 | TP_PROTO(unsigned int usec_timeout, unsigned int usec_delayed), | 255 | TP_PROTO(unsigned int usec_timeout, unsigned int usec_delayed), |
@@ -187,6 +285,63 @@ DEFINE_EVENT(writeback_congest_waited_template, writeback_wait_iff_congested, | |||
187 | TP_ARGS(usec_timeout, usec_delayed) | 285 | TP_ARGS(usec_timeout, usec_delayed) |
188 | ); | 286 | ); |
189 | 287 | ||
288 | DECLARE_EVENT_CLASS(writeback_single_inode_template, | ||
289 | |||
290 | TP_PROTO(struct inode *inode, | ||
291 | struct writeback_control *wbc, | ||
292 | unsigned long nr_to_write | ||
293 | ), | ||
294 | |||
295 | TP_ARGS(inode, wbc, nr_to_write), | ||
296 | |||
297 | TP_STRUCT__entry( | ||
298 | __array(char, name, 32) | ||
299 | __field(unsigned long, ino) | ||
300 | __field(unsigned long, state) | ||
301 | __field(unsigned long, dirtied_when) | ||
302 | __field(unsigned long, writeback_index) | ||
303 | __field(long, nr_to_write) | ||
304 | __field(unsigned long, wrote) | ||
305 | ), | ||
306 | |||
307 | TP_fast_assign( | ||
308 | strncpy(__entry->name, | ||
309 | dev_name(inode->i_mapping->backing_dev_info->dev), 32); | ||
310 | __entry->ino = inode->i_ino; | ||
311 | __entry->state = inode->i_state; | ||
312 | __entry->dirtied_when = inode->dirtied_when; | ||
313 | __entry->writeback_index = inode->i_mapping->writeback_index; | ||
314 | __entry->nr_to_write = nr_to_write; | ||
315 | __entry->wrote = nr_to_write - wbc->nr_to_write; | ||
316 | ), | ||
317 | |||
318 | TP_printk("bdi %s: ino=%lu state=%s dirtied_when=%lu age=%lu " | ||
319 | "index=%lu to_write=%ld wrote=%lu", | ||
320 | __entry->name, | ||
321 | __entry->ino, | ||
322 | show_inode_state(__entry->state), | ||
323 | __entry->dirtied_when, | ||
324 | (jiffies - __entry->dirtied_when) / HZ, | ||
325 | __entry->writeback_index, | ||
326 | __entry->nr_to_write, | ||
327 | __entry->wrote | ||
328 | ) | ||
329 | ); | ||
330 | |||
331 | DEFINE_EVENT(writeback_single_inode_template, writeback_single_inode_requeue, | ||
332 | TP_PROTO(struct inode *inode, | ||
333 | struct writeback_control *wbc, | ||
334 | unsigned long nr_to_write), | ||
335 | TP_ARGS(inode, wbc, nr_to_write) | ||
336 | ); | ||
337 | |||
338 | DEFINE_EVENT(writeback_single_inode_template, writeback_single_inode, | ||
339 | TP_PROTO(struct inode *inode, | ||
340 | struct writeback_control *wbc, | ||
341 | unsigned long nr_to_write), | ||
342 | TP_ARGS(inode, wbc, nr_to_write) | ||
343 | ); | ||
344 | |||
190 | #endif /* _TRACE_WRITEBACK_H */ | 345 | #endif /* _TRACE_WRITEBACK_H */ |
191 | 346 | ||
192 | /* This part must be outside protection */ | 347 | /* This part must be outside protection */ |
diff --git a/include/trace/events/xen.h b/include/trace/events/xen.h new file mode 100644 index 00000000000..92f1a796829 --- /dev/null +++ b/include/trace/events/xen.h | |||
@@ -0,0 +1,506 @@ | |||
1 | #undef TRACE_SYSTEM | ||
2 | #define TRACE_SYSTEM xen | ||
3 | |||
4 | #if !defined(_TRACE_XEN_H) || defined(TRACE_HEADER_MULTI_READ) | ||
5 | #define _TRACE_XEN_H | ||
6 | |||
7 | #include <linux/tracepoint.h> | ||
8 | #include <asm/paravirt_types.h> | ||
9 | #include <asm/xen/trace_types.h> | ||
10 | |||
11 | struct multicall_entry; | ||
12 | |||
13 | /* Multicalls */ | ||
14 | DECLARE_EVENT_CLASS(xen_mc__batch, | ||
15 | TP_PROTO(enum paravirt_lazy_mode mode), | ||
16 | TP_ARGS(mode), | ||
17 | TP_STRUCT__entry( | ||
18 | __field(enum paravirt_lazy_mode, mode) | ||
19 | ), | ||
20 | TP_fast_assign(__entry->mode = mode), | ||
21 | TP_printk("start batch LAZY_%s", | ||
22 | (__entry->mode == PARAVIRT_LAZY_MMU) ? "MMU" : | ||
23 | (__entry->mode == PARAVIRT_LAZY_CPU) ? "CPU" : "NONE") | ||
24 | ); | ||
25 | #define DEFINE_XEN_MC_BATCH(name) \ | ||
26 | DEFINE_EVENT(xen_mc__batch, name, \ | ||
27 | TP_PROTO(enum paravirt_lazy_mode mode), \ | ||
28 | TP_ARGS(mode)) | ||
29 | |||
30 | DEFINE_XEN_MC_BATCH(xen_mc_batch); | ||
31 | DEFINE_XEN_MC_BATCH(xen_mc_issue); | ||
32 | |||
33 | TRACE_EVENT(xen_mc_entry, | ||
34 | TP_PROTO(struct multicall_entry *mc, unsigned nargs), | ||
35 | TP_ARGS(mc, nargs), | ||
36 | TP_STRUCT__entry( | ||
37 | __field(unsigned int, op) | ||
38 | __field(unsigned int, nargs) | ||
39 | __array(unsigned long, args, 6) | ||
40 | ), | ||
41 | TP_fast_assign(__entry->op = mc->op; | ||
42 | __entry->nargs = nargs; | ||
43 | memcpy(__entry->args, mc->args, sizeof(unsigned long) * nargs); | ||
44 | memset(__entry->args + nargs, 0, sizeof(unsigned long) * (6 - nargs)); | ||
45 | ), | ||
46 | TP_printk("op %u%s args [%lx, %lx, %lx, %lx, %lx, %lx]", | ||
47 | __entry->op, xen_hypercall_name(__entry->op), | ||
48 | __entry->args[0], __entry->args[1], __entry->args[2], | ||
49 | __entry->args[3], __entry->args[4], __entry->args[5]) | ||
50 | ); | ||
51 | |||
52 | TRACE_EVENT(xen_mc_entry_alloc, | ||
53 | TP_PROTO(size_t args), | ||
54 | TP_ARGS(args), | ||
55 | TP_STRUCT__entry( | ||
56 | __field(size_t, args) | ||
57 | ), | ||
58 | TP_fast_assign(__entry->args = args), | ||
59 | TP_printk("alloc entry %zu arg bytes", __entry->args) | ||
60 | ); | ||
61 | |||
62 | TRACE_EVENT(xen_mc_callback, | ||
63 | TP_PROTO(xen_mc_callback_fn_t fn, void *data), | ||
64 | TP_ARGS(fn, data), | ||
65 | TP_STRUCT__entry( | ||
66 | __field(xen_mc_callback_fn_t, fn) | ||
67 | __field(void *, data) | ||
68 | ), | ||
69 | TP_fast_assign( | ||
70 | __entry->fn = fn; | ||
71 | __entry->data = data; | ||
72 | ), | ||
73 | TP_printk("callback %pf, data %p", | ||
74 | __entry->fn, __entry->data) | ||
75 | ); | ||
76 | |||
77 | TRACE_EVENT(xen_mc_flush_reason, | ||
78 | TP_PROTO(enum xen_mc_flush_reason reason), | ||
79 | TP_ARGS(reason), | ||
80 | TP_STRUCT__entry( | ||
81 | __field(enum xen_mc_flush_reason, reason) | ||
82 | ), | ||
83 | TP_fast_assign(__entry->reason = reason), | ||
84 | TP_printk("flush reason %s", | ||
85 | (__entry->reason == XEN_MC_FL_NONE) ? "NONE" : | ||
86 | (__entry->reason == XEN_MC_FL_BATCH) ? "BATCH" : | ||
87 | (__entry->reason == XEN_MC_FL_ARGS) ? "ARGS" : | ||
88 | (__entry->reason == XEN_MC_FL_CALLBACK) ? "CALLBACK" : "??") | ||
89 | ); | ||
90 | |||
91 | TRACE_EVENT(xen_mc_flush, | ||
92 | TP_PROTO(unsigned mcidx, unsigned argidx, unsigned cbidx), | ||
93 | TP_ARGS(mcidx, argidx, cbidx), | ||
94 | TP_STRUCT__entry( | ||
95 | __field(unsigned, mcidx) | ||
96 | __field(unsigned, argidx) | ||
97 | __field(unsigned, cbidx) | ||
98 | ), | ||
99 | TP_fast_assign(__entry->mcidx = mcidx; | ||
100 | __entry->argidx = argidx; | ||
101 | __entry->cbidx = cbidx), | ||
102 | TP_printk("flushing %u hypercalls, %u arg bytes, %u callbacks", | ||
103 | __entry->mcidx, __entry->argidx, __entry->cbidx) | ||
104 | ); | ||
105 | |||
106 | TRACE_EVENT(xen_mc_extend_args, | ||
107 | TP_PROTO(unsigned long op, size_t args, enum xen_mc_extend_args res), | ||
108 | TP_ARGS(op, args, res), | ||
109 | TP_STRUCT__entry( | ||
110 | __field(unsigned int, op) | ||
111 | __field(size_t, args) | ||
112 | __field(enum xen_mc_extend_args, res) | ||
113 | ), | ||
114 | TP_fast_assign(__entry->op = op; | ||
115 | __entry->args = args; | ||
116 | __entry->res = res), | ||
117 | TP_printk("extending op %u%s by %zu bytes res %s", | ||
118 | __entry->op, xen_hypercall_name(__entry->op), | ||
119 | __entry->args, | ||
120 | __entry->res == XEN_MC_XE_OK ? "OK" : | ||
121 | __entry->res == XEN_MC_XE_BAD_OP ? "BAD_OP" : | ||
122 | __entry->res == XEN_MC_XE_NO_SPACE ? "NO_SPACE" : "???") | ||
123 | ); | ||
124 | |||
125 | /* mmu */ | ||
126 | DECLARE_EVENT_CLASS(xen_mmu__set_pte, | ||
127 | TP_PROTO(pte_t *ptep, pte_t pteval), | ||
128 | TP_ARGS(ptep, pteval), | ||
129 | TP_STRUCT__entry( | ||
130 | __field(pte_t *, ptep) | ||
131 | __field(pteval_t, pteval) | ||
132 | ), | ||
133 | TP_fast_assign(__entry->ptep = ptep; | ||
134 | __entry->pteval = pteval.pte), | ||
135 | TP_printk("ptep %p pteval %0*llx (raw %0*llx)", | ||
136 | __entry->ptep, | ||
137 | (int)sizeof(pteval_t) * 2, (unsigned long long)pte_val(native_make_pte(__entry->pteval)), | ||
138 | (int)sizeof(pteval_t) * 2, (unsigned long long)__entry->pteval) | ||
139 | ); | ||
140 | |||
141 | #define DEFINE_XEN_MMU_SET_PTE(name) \ | ||
142 | DEFINE_EVENT(xen_mmu__set_pte, name, \ | ||
143 | TP_PROTO(pte_t *ptep, pte_t pteval), \ | ||
144 | TP_ARGS(ptep, pteval)) | ||
145 | |||
146 | DEFINE_XEN_MMU_SET_PTE(xen_mmu_set_pte); | ||
147 | DEFINE_XEN_MMU_SET_PTE(xen_mmu_set_pte_atomic); | ||
148 | |||
149 | TRACE_EVENT(xen_mmu_set_domain_pte, | ||
150 | TP_PROTO(pte_t *ptep, pte_t pteval, unsigned domid), | ||
151 | TP_ARGS(ptep, pteval, domid), | ||
152 | TP_STRUCT__entry( | ||
153 | __field(pte_t *, ptep) | ||
154 | __field(pteval_t, pteval) | ||
155 | __field(unsigned, domid) | ||
156 | ), | ||
157 | TP_fast_assign(__entry->ptep = ptep; | ||
158 | __entry->pteval = pteval.pte; | ||
159 | __entry->domid = domid), | ||
160 | TP_printk("ptep %p pteval %0*llx (raw %0*llx) domid %u", | ||
161 | __entry->ptep, | ||
162 | (int)sizeof(pteval_t) * 2, (unsigned long long)pte_val(native_make_pte(__entry->pteval)), | ||
163 | (int)sizeof(pteval_t) * 2, (unsigned long long)__entry->pteval, | ||
164 | __entry->domid) | ||
165 | ); | ||
166 | |||
167 | TRACE_EVENT(xen_mmu_set_pte_at, | ||
168 | TP_PROTO(struct mm_struct *mm, unsigned long addr, | ||
169 | pte_t *ptep, pte_t pteval), | ||
170 | TP_ARGS(mm, addr, ptep, pteval), | ||
171 | TP_STRUCT__entry( | ||
172 | __field(struct mm_struct *, mm) | ||
173 | __field(unsigned long, addr) | ||
174 | __field(pte_t *, ptep) | ||
175 | __field(pteval_t, pteval) | ||
176 | ), | ||
177 | TP_fast_assign(__entry->mm = mm; | ||
178 | __entry->addr = addr; | ||
179 | __entry->ptep = ptep; | ||
180 | __entry->pteval = pteval.pte), | ||
181 | TP_printk("mm %p addr %lx ptep %p pteval %0*llx (raw %0*llx)", | ||
182 | __entry->mm, __entry->addr, __entry->ptep, | ||
183 | (int)sizeof(pteval_t) * 2, (unsigned long long)pte_val(native_make_pte(__entry->pteval)), | ||
184 | (int)sizeof(pteval_t) * 2, (unsigned long long)__entry->pteval) | ||
185 | ); | ||
186 | |||
187 | TRACE_EVENT(xen_mmu_pte_clear, | ||
188 | TP_PROTO(struct mm_struct *mm, unsigned long addr, pte_t *ptep), | ||
189 | TP_ARGS(mm, addr, ptep), | ||
190 | TP_STRUCT__entry( | ||
191 | __field(struct mm_struct *, mm) | ||
192 | __field(unsigned long, addr) | ||
193 | __field(pte_t *, ptep) | ||
194 | ), | ||
195 | TP_fast_assign(__entry->mm = mm; | ||
196 | __entry->addr = addr; | ||
197 | __entry->ptep = ptep), | ||
198 | TP_printk("mm %p addr %lx ptep %p", | ||
199 | __entry->mm, __entry->addr, __entry->ptep) | ||
200 | ); | ||
201 | |||
202 | TRACE_EVENT(xen_mmu_set_pmd, | ||
203 | TP_PROTO(pmd_t *pmdp, pmd_t pmdval), | ||
204 | TP_ARGS(pmdp, pmdval), | ||
205 | TP_STRUCT__entry( | ||
206 | __field(pmd_t *, pmdp) | ||
207 | __field(pmdval_t, pmdval) | ||
208 | ), | ||
209 | TP_fast_assign(__entry->pmdp = pmdp; | ||
210 | __entry->pmdval = pmdval.pmd), | ||
211 | TP_printk("pmdp %p pmdval %0*llx (raw %0*llx)", | ||
212 | __entry->pmdp, | ||
213 | (int)sizeof(pmdval_t) * 2, (unsigned long long)pmd_val(native_make_pmd(__entry->pmdval)), | ||
214 | (int)sizeof(pmdval_t) * 2, (unsigned long long)__entry->pmdval) | ||
215 | ); | ||
216 | |||
217 | TRACE_EVENT(xen_mmu_pmd_clear, | ||
218 | TP_PROTO(pmd_t *pmdp), | ||
219 | TP_ARGS(pmdp), | ||
220 | TP_STRUCT__entry( | ||
221 | __field(pmd_t *, pmdp) | ||
222 | ), | ||
223 | TP_fast_assign(__entry->pmdp = pmdp), | ||
224 | TP_printk("pmdp %p", __entry->pmdp) | ||
225 | ); | ||
226 | |||
227 | #if PAGETABLE_LEVELS >= 4 | ||
228 | |||
229 | TRACE_EVENT(xen_mmu_set_pud, | ||
230 | TP_PROTO(pud_t *pudp, pud_t pudval), | ||
231 | TP_ARGS(pudp, pudval), | ||
232 | TP_STRUCT__entry( | ||
233 | __field(pud_t *, pudp) | ||
234 | __field(pudval_t, pudval) | ||
235 | ), | ||
236 | TP_fast_assign(__entry->pudp = pudp; | ||
237 | __entry->pudval = native_pud_val(pudval)), | ||
238 | TP_printk("pudp %p pudval %0*llx (raw %0*llx)", | ||
239 | __entry->pudp, | ||
240 | (int)sizeof(pudval_t) * 2, (unsigned long long)pud_val(native_make_pud(__entry->pudval)), | ||
241 | (int)sizeof(pudval_t) * 2, (unsigned long long)__entry->pudval) | ||
242 | ); | ||
243 | |||
244 | TRACE_EVENT(xen_mmu_set_pgd, | ||
245 | TP_PROTO(pgd_t *pgdp, pgd_t *user_pgdp, pgd_t pgdval), | ||
246 | TP_ARGS(pgdp, user_pgdp, pgdval), | ||
247 | TP_STRUCT__entry( | ||
248 | __field(pgd_t *, pgdp) | ||
249 | __field(pgd_t *, user_pgdp) | ||
250 | __field(pgdval_t, pgdval) | ||
251 | ), | ||
252 | TP_fast_assign(__entry->pgdp = pgdp; | ||
253 | __entry->user_pgdp = user_pgdp; | ||
254 | __entry->pgdval = pgdval.pgd), | ||
255 | TP_printk("pgdp %p user_pgdp %p pgdval %0*llx (raw %0*llx)", | ||
256 | __entry->pgdp, __entry->user_pgdp, | ||
257 | (int)sizeof(pgdval_t) * 2, (unsigned long long)pgd_val(native_make_pgd(__entry->pgdval)), | ||
258 | (int)sizeof(pgdval_t) * 2, (unsigned long long)__entry->pgdval) | ||
259 | ); | ||
260 | |||
261 | TRACE_EVENT(xen_mmu_pud_clear, | ||
262 | TP_PROTO(pud_t *pudp), | ||
263 | TP_ARGS(pudp), | ||
264 | TP_STRUCT__entry( | ||
265 | __field(pud_t *, pudp) | ||
266 | ), | ||
267 | TP_fast_assign(__entry->pudp = pudp), | ||
268 | TP_printk("pudp %p", __entry->pudp) | ||
269 | ); | ||
270 | #else | ||
271 | |||
272 | TRACE_EVENT(xen_mmu_set_pud, | ||
273 | TP_PROTO(pud_t *pudp, pud_t pudval), | ||
274 | TP_ARGS(pudp, pudval), | ||
275 | TP_STRUCT__entry( | ||
276 | __field(pud_t *, pudp) | ||
277 | __field(pudval_t, pudval) | ||
278 | ), | ||
279 | TP_fast_assign(__entry->pudp = pudp; | ||
280 | __entry->pudval = native_pud_val(pudval)), | ||
281 | TP_printk("pudp %p pudval %0*llx (raw %0*llx)", | ||
282 | __entry->pudp, | ||
283 | (int)sizeof(pudval_t) * 2, (unsigned long long)pgd_val(native_make_pgd(__entry->pudval)), | ||
284 | (int)sizeof(pudval_t) * 2, (unsigned long long)__entry->pudval) | ||
285 | ); | ||
286 | |||
287 | #endif | ||
288 | |||
289 | TRACE_EVENT(xen_mmu_pgd_clear, | ||
290 | TP_PROTO(pgd_t *pgdp), | ||
291 | TP_ARGS(pgdp), | ||
292 | TP_STRUCT__entry( | ||
293 | __field(pgd_t *, pgdp) | ||
294 | ), | ||
295 | TP_fast_assign(__entry->pgdp = pgdp), | ||
296 | TP_printk("pgdp %p", __entry->pgdp) | ||
297 | ); | ||
298 | |||
299 | DECLARE_EVENT_CLASS(xen_mmu_ptep_modify_prot, | ||
300 | TP_PROTO(struct mm_struct *mm, unsigned long addr, | ||
301 | pte_t *ptep, pte_t pteval), | ||
302 | TP_ARGS(mm, addr, ptep, pteval), | ||
303 | TP_STRUCT__entry( | ||
304 | __field(struct mm_struct *, mm) | ||
305 | __field(unsigned long, addr) | ||
306 | __field(pte_t *, ptep) | ||
307 | __field(pteval_t, pteval) | ||
308 | ), | ||
309 | TP_fast_assign(__entry->mm = mm; | ||
310 | __entry->addr = addr; | ||
311 | __entry->ptep = ptep; | ||
312 | __entry->pteval = pteval.pte), | ||
313 | TP_printk("mm %p addr %lx ptep %p pteval %0*llx (raw %0*llx)", | ||
314 | __entry->mm, __entry->addr, __entry->ptep, | ||
315 | (int)sizeof(pteval_t) * 2, (unsigned long long)pte_val(native_make_pte(__entry->pteval)), | ||
316 | (int)sizeof(pteval_t) * 2, (unsigned long long)__entry->pteval) | ||
317 | ); | ||
318 | #define DEFINE_XEN_MMU_PTEP_MODIFY_PROT(name) \ | ||
319 | DEFINE_EVENT(xen_mmu_ptep_modify_prot, name, \ | ||
320 | TP_PROTO(struct mm_struct *mm, unsigned long addr, \ | ||
321 | pte_t *ptep, pte_t pteval), \ | ||
322 | TP_ARGS(mm, addr, ptep, pteval)) | ||
323 | |||
324 | DEFINE_XEN_MMU_PTEP_MODIFY_PROT(xen_mmu_ptep_modify_prot_start); | ||
325 | DEFINE_XEN_MMU_PTEP_MODIFY_PROT(xen_mmu_ptep_modify_prot_commit); | ||
326 | |||
327 | TRACE_EVENT(xen_mmu_alloc_ptpage, | ||
328 | TP_PROTO(struct mm_struct *mm, unsigned long pfn, unsigned level, bool pinned), | ||
329 | TP_ARGS(mm, pfn, level, pinned), | ||
330 | TP_STRUCT__entry( | ||
331 | __field(struct mm_struct *, mm) | ||
332 | __field(unsigned long, pfn) | ||
333 | __field(unsigned, level) | ||
334 | __field(bool, pinned) | ||
335 | ), | ||
336 | TP_fast_assign(__entry->mm = mm; | ||
337 | __entry->pfn = pfn; | ||
338 | __entry->level = level; | ||
339 | __entry->pinned = pinned), | ||
340 | TP_printk("mm %p pfn %lx level %d %spinned", | ||
341 | __entry->mm, __entry->pfn, __entry->level, | ||
342 | __entry->pinned ? "" : "un") | ||
343 | ); | ||
344 | |||
345 | TRACE_EVENT(xen_mmu_release_ptpage, | ||
346 | TP_PROTO(unsigned long pfn, unsigned level, bool pinned), | ||
347 | TP_ARGS(pfn, level, pinned), | ||
348 | TP_STRUCT__entry( | ||
349 | __field(unsigned long, pfn) | ||
350 | __field(unsigned, level) | ||
351 | __field(bool, pinned) | ||
352 | ), | ||
353 | TP_fast_assign(__entry->pfn = pfn; | ||
354 | __entry->level = level; | ||
355 | __entry->pinned = pinned), | ||
356 | TP_printk("pfn %lx level %d %spinned", | ||
357 | __entry->pfn, __entry->level, | ||
358 | __entry->pinned ? "" : "un") | ||
359 | ); | ||
360 | |||
361 | DECLARE_EVENT_CLASS(xen_mmu_pgd, | ||
362 | TP_PROTO(struct mm_struct *mm, pgd_t *pgd), | ||
363 | TP_ARGS(mm, pgd), | ||
364 | TP_STRUCT__entry( | ||
365 | __field(struct mm_struct *, mm) | ||
366 | __field(pgd_t *, pgd) | ||
367 | ), | ||
368 | TP_fast_assign(__entry->mm = mm; | ||
369 | __entry->pgd = pgd), | ||
370 | TP_printk("mm %p pgd %p", __entry->mm, __entry->pgd) | ||
371 | ); | ||
372 | #define DEFINE_XEN_MMU_PGD_EVENT(name) \ | ||
373 | DEFINE_EVENT(xen_mmu_pgd, name, \ | ||
374 | TP_PROTO(struct mm_struct *mm, pgd_t *pgd), \ | ||
375 | TP_ARGS(mm, pgd)) | ||
376 | |||
377 | DEFINE_XEN_MMU_PGD_EVENT(xen_mmu_pgd_pin); | ||
378 | DEFINE_XEN_MMU_PGD_EVENT(xen_mmu_pgd_unpin); | ||
379 | |||
380 | TRACE_EVENT(xen_mmu_flush_tlb, | ||
381 | TP_PROTO(int x), | ||
382 | TP_ARGS(x), | ||
383 | TP_STRUCT__entry(__array(char, x, 0)), | ||
384 | TP_fast_assign((void)x), | ||
385 | TP_printk("%s", "") | ||
386 | ); | ||
387 | |||
388 | TRACE_EVENT(xen_mmu_flush_tlb_single, | ||
389 | TP_PROTO(unsigned long addr), | ||
390 | TP_ARGS(addr), | ||
391 | TP_STRUCT__entry( | ||
392 | __field(unsigned long, addr) | ||
393 | ), | ||
394 | TP_fast_assign(__entry->addr = addr), | ||
395 | TP_printk("addr %lx", __entry->addr) | ||
396 | ); | ||
397 | |||
398 | TRACE_EVENT(xen_mmu_flush_tlb_others, | ||
399 | TP_PROTO(const struct cpumask *cpus, struct mm_struct *mm, | ||
400 | unsigned long addr), | ||
401 | TP_ARGS(cpus, mm, addr), | ||
402 | TP_STRUCT__entry( | ||
403 | __field(unsigned, ncpus) | ||
404 | __field(struct mm_struct *, mm) | ||
405 | __field(unsigned long, addr) | ||
406 | ), | ||
407 | TP_fast_assign(__entry->ncpus = cpumask_weight(cpus); | ||
408 | __entry->mm = mm; | ||
409 | __entry->addr = addr), | ||
410 | TP_printk("ncpus %d mm %p addr %lx", | ||
411 | __entry->ncpus, __entry->mm, __entry->addr) | ||
412 | ); | ||
413 | |||
414 | TRACE_EVENT(xen_mmu_write_cr3, | ||
415 | TP_PROTO(bool kernel, unsigned long cr3), | ||
416 | TP_ARGS(kernel, cr3), | ||
417 | TP_STRUCT__entry( | ||
418 | __field(bool, kernel) | ||
419 | __field(unsigned long, cr3) | ||
420 | ), | ||
421 | TP_fast_assign(__entry->kernel = kernel; | ||
422 | __entry->cr3 = cr3), | ||
423 | TP_printk("%s cr3 %lx", | ||
424 | __entry->kernel ? "kernel" : "user", __entry->cr3) | ||
425 | ); | ||
426 | |||
427 | |||
428 | /* CPU */ | ||
429 | TRACE_EVENT(xen_cpu_write_ldt_entry, | ||
430 | TP_PROTO(struct desc_struct *dt, int entrynum, u64 desc), | ||
431 | TP_ARGS(dt, entrynum, desc), | ||
432 | TP_STRUCT__entry( | ||
433 | __field(struct desc_struct *, dt) | ||
434 | __field(int, entrynum) | ||
435 | __field(u64, desc) | ||
436 | ), | ||
437 | TP_fast_assign(__entry->dt = dt; | ||
438 | __entry->entrynum = entrynum; | ||
439 | __entry->desc = desc; | ||
440 | ), | ||
441 | TP_printk("dt %p entrynum %d entry %016llx", | ||
442 | __entry->dt, __entry->entrynum, | ||
443 | (unsigned long long)__entry->desc) | ||
444 | ); | ||
445 | |||
446 | TRACE_EVENT(xen_cpu_write_idt_entry, | ||
447 | TP_PROTO(gate_desc *dt, int entrynum, const gate_desc *ent), | ||
448 | TP_ARGS(dt, entrynum, ent), | ||
449 | TP_STRUCT__entry( | ||
450 | __field(gate_desc *, dt) | ||
451 | __field(int, entrynum) | ||
452 | ), | ||
453 | TP_fast_assign(__entry->dt = dt; | ||
454 | __entry->entrynum = entrynum; | ||
455 | ), | ||
456 | TP_printk("dt %p entrynum %d", | ||
457 | __entry->dt, __entry->entrynum) | ||
458 | ); | ||
459 | |||
460 | TRACE_EVENT(xen_cpu_load_idt, | ||
461 | TP_PROTO(const struct desc_ptr *desc), | ||
462 | TP_ARGS(desc), | ||
463 | TP_STRUCT__entry( | ||
464 | __field(unsigned long, addr) | ||
465 | ), | ||
466 | TP_fast_assign(__entry->addr = desc->address), | ||
467 | TP_printk("addr %lx", __entry->addr) | ||
468 | ); | ||
469 | |||
470 | TRACE_EVENT(xen_cpu_write_gdt_entry, | ||
471 | TP_PROTO(struct desc_struct *dt, int entrynum, const void *desc, int type), | ||
472 | TP_ARGS(dt, entrynum, desc, type), | ||
473 | TP_STRUCT__entry( | ||
474 | __field(u64, desc) | ||
475 | __field(struct desc_struct *, dt) | ||
476 | __field(int, entrynum) | ||
477 | __field(int, type) | ||
478 | ), | ||
479 | TP_fast_assign(__entry->dt = dt; | ||
480 | __entry->entrynum = entrynum; | ||
481 | __entry->desc = *(u64 *)desc; | ||
482 | __entry->type = type; | ||
483 | ), | ||
484 | TP_printk("dt %p entrynum %d type %d desc %016llx", | ||
485 | __entry->dt, __entry->entrynum, __entry->type, | ||
486 | (unsigned long long)__entry->desc) | ||
487 | ); | ||
488 | |||
489 | TRACE_EVENT(xen_cpu_set_ldt, | ||
490 | TP_PROTO(const void *addr, unsigned entries), | ||
491 | TP_ARGS(addr, entries), | ||
492 | TP_STRUCT__entry( | ||
493 | __field(const void *, addr) | ||
494 | __field(unsigned, entries) | ||
495 | ), | ||
496 | TP_fast_assign(__entry->addr = addr; | ||
497 | __entry->entries = entries), | ||
498 | TP_printk("addr %p entries %u", | ||
499 | __entry->addr, __entry->entries) | ||
500 | ); | ||
501 | |||
502 | |||
503 | #endif /* _TRACE_XEN_H */ | ||
504 | |||
505 | /* This part must be outside protection */ | ||
506 | #include <trace/define_trace.h> | ||