aboutsummaryrefslogtreecommitdiffstats
path: root/include/trace
diff options
context:
space:
mode:
Diffstat (limited to 'include/trace')
-rw-r--r--include/trace/events/asoc.h45
-rw-r--r--include/trace/events/block.h20
-rw-r--r--include/trace/events/btrfs.h6
-rw-r--r--include/trace/events/ext3.h864
-rw-r--r--include/trace/events/ext4.h93
-rw-r--r--include/trace/events/jbd.h203
-rw-r--r--include/trace/events/jbd2.h36
-rw-r--r--include/trace/events/nvhost.h438
-rw-r--r--include/trace/events/regmap.h145
-rw-r--r--include/trace/events/sock.h68
-rw-r--r--include/trace/events/udp.h32
-rw-r--r--include/trace/events/vmscan.h77
-rw-r--r--include/trace/events/writeback.h183
-rw-r--r--include/trace/events/xen.h506
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
10struct snd_soc_jack; 10struct snd_soc_jack;
11struct snd_soc_codec; 11struct snd_soc_codec;
12struct snd_soc_platform;
12struct snd_soc_card; 13struct snd_soc_card;
13struct snd_soc_dapm_widget; 14struct 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
63DECLARE_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
89DEFINE_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
98DEFINE_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
62DECLARE_EVENT_CLASS(snd_soc_card, 107DECLARE_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
11DECLARE_EVENT_CLASS(block_rq_with_error, 13DECLARE_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
9TRACE_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
39TRACE_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
61TRACE_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
86TRACE_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
108TRACE_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
130TRACE_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
152TRACE_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
181DECLARE_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
210DEFINE_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
218DEFINE_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
226DEFINE_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
234DECLARE_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
257DEFINE_EVENT(ext3__page_op, ext3_ordered_writepage,
258
259 TP_PROTO(struct page *page),
260
261 TP_ARGS(page)
262);
263
264DEFINE_EVENT(ext3__page_op, ext3_writeback_writepage,
265
266 TP_PROTO(struct page *page),
267
268 TP_ARGS(page)
269);
270
271DEFINE_EVENT(ext3__page_op, ext3_journalled_writepage,
272
273 TP_PROTO(struct page *page),
274
275 TP_ARGS(page)
276);
277
278DEFINE_EVENT(ext3__page_op, ext3_readpage,
279
280 TP_PROTO(struct page *page),
281
282 TP_ARGS(page)
283);
284
285DEFINE_EVENT(ext3__page_op, ext3_releasepage,
286
287 TP_PROTO(struct page *page),
288
289 TP_ARGS(page)
290);
291
292TRACE_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
318TRACE_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
342TRACE_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
368TRACE_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
397TRACE_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
425TRACE_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
452TRACE_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
475TRACE_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
496TRACE_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
519TRACE_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
545TRACE_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
565TRACE_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
590TRACE_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
617TRACE_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
638TRACE_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
666TRACE_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
697TRACE_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
723TRACE_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
746DECLARE_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
768DEFINE_EVENT(ext3__truncate, ext3_truncate_enter,
769
770 TP_PROTO(struct inode *inode),
771
772 TP_ARGS(inode)
773);
774
775DEFINE_EVENT(ext3__truncate, ext3_truncate_exit,
776
777 TP_PROTO(struct inode *inode),
778
779 TP_ARGS(inode)
780);
781
782TRACE_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
810TRACE_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
841TRACE_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
1521TRACE_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
1543DECLARE_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
1572DEFINE_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
1582DEFINE_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
10TRACE_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
31DECLARE_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
54DEFINE_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
61DEFINE_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
68DEFINE_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
75DEFINE_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
82TRACE_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
105TRACE_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
129TRACE_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
151TRACE_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
180TRACE_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
33DECLARE_EVENT_CLASS(jbd2_commit, 33DECLARE_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
56DEFINE_EVENT(jbd2_commit, jbd2_start_commit, 56DEFINE_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
108TRACE_EVENT(jbd2_submit_inode_data, 108TRACE_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
127TRACE_EVENT(jbd2_run_stats, 128TRACE_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
32DECLARE_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
40DEFINE_EVENT(nvhost, nvhost_channel_open,
41 TP_PROTO(const char *name),
42 TP_ARGS(name)
43);
44
45DEFINE_EVENT(nvhost, nvhost_channel_release,
46 TP_PROTO(const char *name),
47 TP_ARGS(name)
48);
49
50DEFINE_EVENT(nvhost, nvhost_ioctl_channel_flush,
51 TP_PROTO(const char *name),
52 TP_ARGS(name)
53);
54
55TRACE_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
84TRACE_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
116TRACE_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
141TRACE_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
175TRACE_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
192TRACE_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
213TRACE_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
232TRACE_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
251TRACE_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
263TRACE_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
275TRACE_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
294TRACE_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
310TRACE_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
328TRACE_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
354TRACE_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
375TRACE_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
396TRACE_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
417TRACE_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
11struct regmap;
12
13/*
14 * Log register events
15 */
16DECLARE_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
40DEFINE_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
49DEFINE_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
58DEFINE_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
67DECLARE_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
90DEFINE_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
97DEFINE_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
104DEFINE_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
111DEFINE_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
118TRACE_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
10TRACE_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
32TRACE_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
10TRACE_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
182TRACE_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
227TRACE_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
183DECLARE_EVENT_CLASS(mm_vmscan_lru_isolate_template, 260DECLARE_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
11struct wb_writeback_work; 24struct wb_writeback_work;
12 25
13DECLARE_EVENT_CLASS(writeback_work_class, 26DECLARE_EVENT_CLASS(writeback_work_class,
@@ -49,6 +62,9 @@ DEFINE_EVENT(writeback_work_class, name, \
49DEFINE_WRITEBACK_WORK_EVENT(writeback_nothread); 62DEFINE_WRITEBACK_WORK_EVENT(writeback_nothread);
50DEFINE_WRITEBACK_WORK_EVENT(writeback_queue); 63DEFINE_WRITEBACK_WORK_EVENT(writeback_queue);
51DEFINE_WRITEBACK_WORK_EVENT(writeback_exec); 64DEFINE_WRITEBACK_WORK_EVENT(writeback_exec);
65DEFINE_WRITEBACK_WORK_EVENT(writeback_start);
66DEFINE_WRITEBACK_WORK_EVENT(writeback_written);
67DEFINE_WRITEBACK_WORK_EVENT(writeback_wait);
52 68
53TRACE_EVENT(writeback_pages_written, 69TRACE_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);
88DEFINE_WRITEBACK_EVENT(writeback_bdi_unregister); 104DEFINE_WRITEBACK_EVENT(writeback_bdi_unregister);
89DEFINE_WRITEBACK_EVENT(writeback_thread_start); 105DEFINE_WRITEBACK_EVENT(writeback_thread_start);
90DEFINE_WRITEBACK_EVENT(writeback_thread_stop); 106DEFINE_WRITEBACK_EVENT(writeback_thread_stop);
107DEFINE_WRITEBACK_EVENT(balance_dirty_start);
108DEFINE_WRITEBACK_EVENT(balance_dirty_wait);
109
110TRACE_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
92DECLARE_EVENT_CLASS(wbc_class, 132DECLARE_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,
144DEFINE_EVENT(wbc_class, name, \ 177DEFINE_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))
147DEFINE_WBC_EVENT(wbc_writeback_start);
148DEFINE_WBC_EVENT(wbc_writeback_written);
149DEFINE_WBC_EVENT(wbc_writeback_wait);
150DEFINE_WBC_EVENT(wbc_balance_dirty_start);
151DEFINE_WBC_EVENT(wbc_balance_dirty_written);
152DEFINE_WBC_EVENT(wbc_balance_dirty_wait);
153DEFINE_WBC_EVENT(wbc_writepage); 180DEFINE_WBC_EVENT(wbc_writepage);
154 181
182TRACE_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
207TRACE_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
155DECLARE_EVENT_CLASS(writeback_congest_waited_template, 253DECLARE_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
288DECLARE_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
331DEFINE_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
338DEFINE_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
11struct multicall_entry;
12
13/* Multicalls */
14DECLARE_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
30DEFINE_XEN_MC_BATCH(xen_mc_batch);
31DEFINE_XEN_MC_BATCH(xen_mc_issue);
32
33TRACE_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
52TRACE_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
62TRACE_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
77TRACE_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
91TRACE_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
106TRACE_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 */
126DECLARE_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
146DEFINE_XEN_MMU_SET_PTE(xen_mmu_set_pte);
147DEFINE_XEN_MMU_SET_PTE(xen_mmu_set_pte_atomic);
148
149TRACE_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
167TRACE_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
187TRACE_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
202TRACE_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
217TRACE_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
229TRACE_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
244TRACE_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
261TRACE_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
272TRACE_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
289TRACE_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
299DECLARE_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
324DEFINE_XEN_MMU_PTEP_MODIFY_PROT(xen_mmu_ptep_modify_prot_start);
325DEFINE_XEN_MMU_PTEP_MODIFY_PROT(xen_mmu_ptep_modify_prot_commit);
326
327TRACE_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
345TRACE_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
361DECLARE_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
377DEFINE_XEN_MMU_PGD_EVENT(xen_mmu_pgd_pin);
378DEFINE_XEN_MMU_PGD_EVENT(xen_mmu_pgd_unpin);
379
380TRACE_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
388TRACE_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
398TRACE_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
414TRACE_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 */
429TRACE_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
446TRACE_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
460TRACE_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
470TRACE_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
489TRACE_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>
generated by cgit v1.2.2 (git 2.25.0) at 2025-06-11 19:25:00 -0400