← Back to branch summary

~ubuntu-branches/debian/wheezy/linux-2.6/wheezy

« back to all changes in this revision

Viewing changes to include/trace/events/ext4.h

  • Committer: Bazaar Package Importer
  • Author(s): Ben Hutchings, Ben Hutchings, Aurelien Jarno
  • Date: 2011-06-07 12:14:05 UTC
  • mfrom: (43.1.9 sid)
  • Revision ID: james.westby@ubuntu.com-20110607121405-i3h1rd7nrnd2b73h
Tags: 2.6.39-2
http://bugs.debian.org/627492
http://bugs.debian.org/596626
http://bugs.debian.org/628932
http://bugs.debian.org/628191
http://bugs.debian.org/627837
http://bugs.debian.org/622997
http://bugs.debian.org/622745
http://bugs.debian.org/619827
http://bugs.debian.org/629401
[ Ben Hutchings ]
* [x86] Enable BACKLIGHT_APPLE, replacing BACKLIGHT_MBP_NVIDIA
  (Closes: #627492)
* cgroups: Disable memory resource controller by default. Allow it
  to be enabled using kernel parameter 'cgroup_enable=memory'.
* rt2800usb: Enable support for more USB devices including
  Linksys WUSB600N (Closes: #596626) (this change was accidentally
  omitted from 2.6.39-1)
* [x86] Remove Celeron from list of processors supporting PAE. Most
  'Celeron M' models do not.
* Update debconf template translations:
  - Swedish (Martin Bagge) (Closes: #628932)
  - French (David Prévot) (Closes: #628191)
* aufs: Update for 2.6.39 (Closes: #627837)
* Add stable 2.6.39.1, including:
  - ext4: dont set PageUptodate in ext4_end_bio()
  - pata_cmd64x: fix boot crash on parisc (Closes: #622997, #622745)
  - ext3: Fix fs corruption when make_indexed_dir() fails
  - netfilter: nf_ct_sip: validate Content-Length in TCP SIP messages
  - sctp: fix race between sctp_bind_addr_free() and
    sctp_bind_addr_conflict()
  - sctp: fix memory leak of the ASCONF queue when free asoc
  - md/bitmap: fix saving of events_cleared and other state
  - cdc_acm: Fix oops when Droids MuIn LCD is connected
  - cx88: Fix conversion from BKL to fine-grained locks (Closes: #619827)
  - keys: Set cred->user_ns in key_replace_session_keyring (CVE-2011-2184)
  - tmpfs: fix race between truncate and writepage
  - nfs41: Correct offset for LAYOUTCOMMIT
  - xen/mmu: fix a race window causing leave_mm BUG()
  - ext4: fix possible use-after-free in ext4_remove_li_request()
  For the complete list of changes, see:
   http://www.kernel.org/pub/linux/kernel/v2.6/ChangeLog-2.6.39.1
* Bump ABI to 2
* netfilter: Enable IP_SET, IP_SET_BITMAP_IP, IP_SET_BITMAP_IPMAC,
  IP_SET_BITMAP_PORT, IP_SET_HASH_IP, IP_SET_HASH_IPPORT,
  IP_SET_HASH_IPPORTIP, IP_SET_HASH_IPPORTNET, IP_SET_HASH_NET,
  IP_SET_HASH_NETPORT, IP_SET_LIST_SET, NETFILTER_XT_SET as modules
  (Closes: #629401)

[ Aurelien Jarno ]
* [mipsel/loongson-2f] Disable_SCSI_LPFC to workaround GCC ICE.

Show diffs side-by-side

added added

removed removed

Lines of Context:
include/trace/events/ext4.h
21
21
        TP_ARGS(inode),
22
22
 
23
23
        TP_STRUCT__entry(
24
 
                __field(        int,   dev_major                )
25
 
                __field(        int,   dev_minor                )
 
24
                __field(        dev_t,  dev                     )
26
25
                __field(        ino_t,  ino                     )
27
26
                __field(        umode_t, mode                   )
28
27
                __field(        uid_t,  uid                     )
31
30
        ),
32
31
 
33
32
        TP_fast_assign(
34
 
                __entry->dev_major = MAJOR(inode->i_sb->s_dev);
35
 
                __entry->dev_minor = MINOR(inode->i_sb->s_dev);
 
33
                __entry->dev    = inode->i_sb->s_dev;
36
34
                __entry->ino    = inode->i_ino;
37
35
                __entry->mode   = inode->i_mode;
38
36
                __entry->uid    = inode->i_uid;
41
39
        ),
42
40
 
43
41
        TP_printk("dev %d,%d ino %lu mode 0%o uid %u gid %u blocks %llu",
44
 
                  __entry->dev_major, __entry->dev_minor,
45
 
                  (unsigned long) __entry->ino, __entry->mode,
46
 
                  __entry->uid, __entry->gid,
 
42
                  MAJOR(__entry->dev), MINOR(__entry->dev),
 
43
                  (unsigned long) __entry->ino,
 
44
                  __entry->mode, __entry->uid, __entry->gid,
47
45
                  (unsigned long long) __entry->blocks)
48
46
);
49
47
 
53
51
        TP_ARGS(dir, mode),
54
52
 
55
53
        TP_STRUCT__entry(
56
 
                __field(        int,   dev_major                )
57
 
                __field(        int,   dev_minor                )
 
54
                __field(        dev_t,  dev                     )
58
55
                __field(        ino_t,  dir                     )
59
56
                __field(        umode_t, mode                   )
60
57
        ),
61
58
 
62
59
        TP_fast_assign(
63
 
                __entry->dev_major = MAJOR(dir->i_sb->s_dev);
64
 
                __entry->dev_minor = MINOR(dir->i_sb->s_dev);
 
60
                __entry->dev    = dir->i_sb->s_dev;
65
61
                __entry->dir    = dir->i_ino;
66
62
                __entry->mode   = mode;
67
63
        ),
68
64
 
69
65
        TP_printk("dev %d,%d dir %lu mode 0%o",
70
 
                  __entry->dev_major, __entry->dev_minor,
 
66
                  MAJOR(__entry->dev), MINOR(__entry->dev),
71
67
                  (unsigned long) __entry->dir, __entry->mode)
72
68
);
73
69
 
77
73
        TP_ARGS(inode, dir, mode),
78
74
 
79
75
        TP_STRUCT__entry(
80
 
                __field(        int,   dev_major                )
81
 
                __field(        int,   dev_minor                )
 
76
                __field(        dev_t,  dev                     )
82
77
                __field(        ino_t,  ino                     )
83
78
                __field(        ino_t,  dir                     )
84
79
                __field(        umode_t, mode                   )
85
80
        ),
86
81
 
87
82
        TP_fast_assign(
88
 
                __entry->dev_major = MAJOR(inode->i_sb->s_dev);
89
 
                __entry->dev_minor = MINOR(inode->i_sb->s_dev);
 
83
                __entry->dev    = inode->i_sb->s_dev;
90
84
                __entry->ino    = inode->i_ino;
91
85
                __entry->dir    = dir->i_ino;
92
86
                __entry->mode   = mode;
93
87
        ),
94
88
 
95
89
        TP_printk("dev %d,%d ino %lu dir %lu mode 0%o",
96
 
                  __entry->dev_major, __entry->dev_minor,
 
90
                  MAJOR(__entry->dev), MINOR(__entry->dev),
97
91
                  (unsigned long) __entry->ino,
98
92
                  (unsigned long) __entry->dir, __entry->mode)
99
93
);
104
98
        TP_ARGS(inode),
105
99
 
106
100
        TP_STRUCT__entry(
107
 
                __field(        int,   dev_major                )
108
 
                __field(        int,   dev_minor                )
 
101
                __field(        dev_t,  dev                     )
109
102
                __field(        ino_t,  ino                     )
110
103
                __field(        int,    nlink                   )
111
104
        ),
112
105
 
113
106
        TP_fast_assign(
114
 
                __entry->dev_major = MAJOR(inode->i_sb->s_dev);
115
 
                __entry->dev_minor = MINOR(inode->i_sb->s_dev);
 
107
                __entry->dev    = inode->i_sb->s_dev;
116
108
                __entry->ino    = inode->i_ino;
117
109
                __entry->nlink  = inode->i_nlink;
118
110
        ),
119
111
 
120
112
        TP_printk("dev %d,%d ino %lu nlink %d",
121
 
                  __entry->dev_major, __entry->dev_minor,
 
113
                  MAJOR(__entry->dev), MINOR(__entry->dev),
122
114
                  (unsigned long) __entry->ino, __entry->nlink)
123
115
);
124
116
 
128
120
        TP_ARGS(inode, drop),
129
121
 
130
122
        TP_STRUCT__entry(
131
 
                __field(        int,    dev_major               )
132
 
                __field(        int,    dev_minor               )
 
123
                __field(        dev_t,  dev                     )
133
124
                __field(        ino_t,  ino                     )
134
125
                __field(        int,    drop                    )
135
126
        ),
136
127
 
137
128
        TP_fast_assign(
138
 
                __entry->dev_major = MAJOR(inode->i_sb->s_dev);
139
 
                __entry->dev_minor = MINOR(inode->i_sb->s_dev);
 
129
                __entry->dev    = inode->i_sb->s_dev;
140
130
                __entry->ino    = inode->i_ino;
141
131
                __entry->drop   = drop;
142
132
        ),
143
133
 
144
134
        TP_printk("dev %d,%d ino %lu drop %d",
145
 
                  __entry->dev_major, __entry->dev_minor,
 
135
                  MAJOR(__entry->dev), MINOR(__entry->dev),
146
136
                  (unsigned long) __entry->ino, __entry->drop)
147
137
);
148
138
 
152
142
        TP_ARGS(inode, IP),
153
143
 
154
144
        TP_STRUCT__entry(
155
 
                __field(        int,    dev_major               )
156
 
                __field(        int,    dev_minor               )
 
145
                __field(        dev_t,  dev                     )
157
146
                __field(        ino_t,  ino                     )
158
147
                __field(unsigned long,  ip                      )
159
148
        ),
160
149
 
161
150
        TP_fast_assign(
162
 
                __entry->dev_major = MAJOR(inode->i_sb->s_dev);
163
 
                __entry->dev_minor = MINOR(inode->i_sb->s_dev);
 
151
                __entry->dev    = inode->i_sb->s_dev;
164
152
                __entry->ino    = inode->i_ino;
165
153
                __entry->ip     = IP;
166
154
        ),
167
155
 
168
156
        TP_printk("dev %d,%d ino %lu caller %pF",
169
 
                  __entry->dev_major, __entry->dev_minor,
 
157
                  MAJOR(__entry->dev), MINOR(__entry->dev),
170
158
                  (unsigned long) __entry->ino, (void *)__entry->ip)
171
159
);
172
160
 
176
164
        TP_ARGS(inode, new_size),
177
165
 
178
166
        TP_STRUCT__entry(
179
 
                __field(        int,    dev_major               )
180
 
                __field(        int,    dev_minor               )
 
167
                __field(        dev_t,  dev                     )
181
168
                __field(        ino_t,  ino                     )
182
169
                __field(        loff_t, new_size                )
183
170
        ),
184
171
 
185
172
        TP_fast_assign(
186
 
                __entry->dev_major      = MAJOR(inode->i_sb->s_dev);
187
 
                __entry->dev_minor      = MINOR(inode->i_sb->s_dev);
 
173
                __entry->dev            = inode->i_sb->s_dev;
188
174
                __entry->ino            = inode->i_ino;
189
175
                __entry->new_size       = new_size;
190
176
        ),
191
177
 
192
178
        TP_printk("dev %d,%d ino %lu new_size %lld",
193
 
                  __entry->dev_major, __entry->dev_minor,
 
179
                  MAJOR(__entry->dev), MINOR(__entry->dev),
194
180
                  (unsigned long) __entry->ino,
195
181
                  (long long) __entry->new_size)
196
182
);
203
189
        TP_ARGS(inode, pos, len, flags),
204
190
 
205
191
        TP_STRUCT__entry(
206
 
                __field(        int,   dev_major                )
207
 
                __field(        int,   dev_minor                )
 
192
                __field(        dev_t,  dev                     )
208
193
                __field(        ino_t,  ino                     )
209
194
                __field(        loff_t, pos                     )
210
195
                __field(        unsigned int, len               )
212
197
        ),
213
198
 
214
199
        TP_fast_assign(
215
 
                __entry->dev_major = MAJOR(inode->i_sb->s_dev);
216
 
                __entry->dev_minor = MINOR(inode->i_sb->s_dev);
 
200
                __entry->dev    = inode->i_sb->s_dev;
217
201
                __entry->ino    = inode->i_ino;
218
202
                __entry->pos    = pos;
219
203
                __entry->len    = len;
221
205
        ),
222
206
 
223
207
        TP_printk("dev %d,%d ino %lu pos %llu len %u flags %u",
224
 
                  __entry->dev_major, __entry->dev_minor,
 
208
                  MAJOR(__entry->dev), MINOR(__entry->dev),
225
209
                  (unsigned long) __entry->ino,
226
210
                  __entry->pos, __entry->len, __entry->flags)
227
211
);
249
233
        TP_ARGS(inode, pos, len, copied),
250
234
 
251
235
        TP_STRUCT__entry(
252
 
                __field(        int,   dev_major                )
253
 
                __field(        int,   dev_minor                )
 
236
                __field(        dev_t,  dev                     )
254
237
                __field(        ino_t,  ino                     )
255
238
                __field(        loff_t, pos                     )
256
239
                __field(        unsigned int, len               )
258
241
        ),
259
242
 
260
243
        TP_fast_assign(
261
 
                __entry->dev_major = MAJOR(inode->i_sb->s_dev);
262
 
                __entry->dev_minor = MINOR(inode->i_sb->s_dev);
 
244
                __entry->dev    = inode->i_sb->s_dev;
263
245
                __entry->ino    = inode->i_ino;
264
246
                __entry->pos    = pos;
265
247
                __entry->len    = len;
267
249
        ),
268
250
 
269
251
        TP_printk("dev %d,%d ino %lu pos %llu len %u copied %u",
270
 
                  __entry->dev_major, __entry->dev_minor,
271
 
                  (unsigned long) __entry->ino, __entry->pos,
272
 
                  __entry->len, __entry->copied)
 
252
                  MAJOR(__entry->dev), MINOR(__entry->dev),
 
253
                  (unsigned long) __entry->ino,
 
254
                  __entry->pos, __entry->len, __entry->copied)
273
255
);
274
256
 
275
257
DEFINE_EVENT(ext4__write_end, ext4_ordered_write_end,
310
292
        TP_ARGS(inode, page),
311
293
 
312
294
        TP_STRUCT__entry(
313
 
                __field(        int,   dev_major                )
314
 
                __field(        int,   dev_minor                )
 
295
                __field(        dev_t,  dev                     )
315
296
                __field(        ino_t,  ino                     )
316
297
                __field(        pgoff_t, index                  )
317
298
 
318
299
        ),
319
300
 
320
301
        TP_fast_assign(
321
 
                __entry->dev_major = MAJOR(inode->i_sb->s_dev);
322
 
                __entry->dev_minor = MINOR(inode->i_sb->s_dev);
 
302
                __entry->dev    = inode->i_sb->s_dev;
323
303
                __entry->ino    = inode->i_ino;
324
304
                __entry->index  = page->index;
325
305
        ),
326
306
 
327
307
        TP_printk("dev %d,%d ino %lu page_index %lu",
328
 
                  __entry->dev_major, __entry->dev_minor,
 
308
                  MAJOR(__entry->dev), MINOR(__entry->dev),
329
309
                  (unsigned long) __entry->ino, __entry->index)
330
310
);
331
311
 
335
315
        TP_ARGS(inode, wbc),
336
316
 
337
317
        TP_STRUCT__entry(
338
 
                __field(        int,   dev_major                )
339
 
                __field(        int,   dev_minor                )
 
318
                __field(        dev_t,  dev                     )
340
319
                __field(        ino_t,  ino                     )
341
320
                __field(        long,   nr_to_write             )
342
321
                __field(        long,   pages_skipped           )
343
322
                __field(        loff_t, range_start             )
344
323
                __field(        loff_t, range_end               )
 
324
                __field(        int,    sync_mode               )
345
325
                __field(        char,   for_kupdate             )
346
 
                __field(        char,   for_reclaim             )
347
326
                __field(        char,   range_cyclic            )
348
327
                __field(       pgoff_t, writeback_index         )
349
328
        ),
350
329
 
351
330
        TP_fast_assign(
352
 
                __entry->dev_major      = MAJOR(inode->i_sb->s_dev);
353
 
                __entry->dev_minor      = MINOR(inode->i_sb->s_dev);
 
331
                __entry->dev            = inode->i_sb->s_dev;
354
332
                __entry->ino            = inode->i_ino;
355
333
                __entry->nr_to_write    = wbc->nr_to_write;
356
334
                __entry->pages_skipped  = wbc->pages_skipped;
357
335
                __entry->range_start    = wbc->range_start;
358
336
                __entry->range_end      = wbc->range_end;
 
337
                __entry->sync_mode      = wbc->sync_mode;
359
338
                __entry->for_kupdate    = wbc->for_kupdate;
360
 
                __entry->for_reclaim    = wbc->for_reclaim;
361
339
                __entry->range_cyclic   = wbc->range_cyclic;
362
340
                __entry->writeback_index = inode->i_mapping->writeback_index;
363
341
        ),
364
342
 
365
343
        TP_printk("dev %d,%d ino %lu nr_to_write %ld pages_skipped %ld "
366
 
                  "range_start %llu range_end %llu "
367
 
                  "for_kupdate %d for_reclaim %d "
368
 
                  "range_cyclic %d writeback_index %lu",
369
 
                  __entry->dev_major, __entry->dev_minor,
 
344
                  "range_start %llu range_end %llu sync_mode %d"
 
345
                  "for_kupdate %d range_cyclic %d writeback_index %lu",
 
346
                  MAJOR(__entry->dev), MINOR(__entry->dev),
370
347
                  (unsigned long) __entry->ino, __entry->nr_to_write,
371
348
                  __entry->pages_skipped, __entry->range_start,
372
 
                  __entry->range_end,
373
 
                  __entry->for_kupdate, __entry->for_reclaim,
374
 
                  __entry->range_cyclic,
 
349
                  __entry->range_end, __entry->sync_mode,
 
350
                  __entry->for_kupdate, __entry->range_cyclic,
375
351
                  (unsigned long) __entry->writeback_index)
376
352
);
377
353
 
381
357
        TP_ARGS(inode, mpd),
382
358
 
383
359
        TP_STRUCT__entry(
384
 
                __field(        int,   dev_major                )
385
 
                __field(        int,   dev_minor                )
 
360
                __field(        dev_t,  dev                     )
386
361
                __field(        ino_t,  ino                     )
387
362
                __field(        __u64,  b_blocknr               )
388
363
                __field(        __u32,  b_size                  )
390
365
                __field(        unsigned long,  first_page      )
391
366
                __field(        int,    io_done                 )
392
367
                __field(        int,    pages_written           )
 
368
                __field(        int,    sync_mode               )
393
369
        ),
394
370
 
395
371
        TP_fast_assign(
396
 
                __entry->dev_major      = MAJOR(inode->i_sb->s_dev);
397
 
                __entry->dev_minor      = MINOR(inode->i_sb->s_dev);
 
372
                __entry->dev            = inode->i_sb->s_dev;
398
373
                __entry->ino            = inode->i_ino;
399
374
                __entry->b_blocknr      = mpd->b_blocknr;
400
375
                __entry->b_size         = mpd->b_size;
402
377
                __entry->first_page     = mpd->first_page;
403
378
                __entry->io_done        = mpd->io_done;
404
379
                __entry->pages_written  = mpd->pages_written;
 
380
                __entry->sync_mode      = mpd->wbc->sync_mode;
405
381
        ),
406
382
 
407
 
        TP_printk("dev %d,%d ino %lu b_blocknr %llu b_size %u b_state 0x%04x first_page %lu io_done %d pages_written %d",
408
 
                  __entry->dev_major, __entry->dev_minor,
 
383
        TP_printk("dev %d,%d ino %lu b_blocknr %llu b_size %u b_state 0x%04x "
 
384
                  "first_page %lu io_done %d pages_written %d sync_mode %d",
 
385
                  MAJOR(__entry->dev), MINOR(__entry->dev),
409
386
                  (unsigned long) __entry->ino,
410
387
                  __entry->b_blocknr, __entry->b_size,
411
388
                  __entry->b_state, __entry->first_page,
412
 
                  __entry->io_done, __entry->pages_written)
 
389
                  __entry->io_done, __entry->pages_written,
 
390
                  __entry->sync_mode
 
391
                  )
413
392
);
414
393
 
415
394
TRACE_EVENT(ext4_da_writepages_result,
419
398
        TP_ARGS(inode, wbc, ret, pages_written),
420
399
 
421
400
        TP_STRUCT__entry(
422
 
                __field(        int,   dev_major                )
423
 
                __field(        int,   dev_minor                )
 
401
                __field(        dev_t,  dev                     )
424
402
                __field(        ino_t,  ino                     )
425
403
                __field(        int,    ret                     )
426
404
                __field(        int,    pages_written           )
427
405
                __field(        long,   pages_skipped           )
 
406
                __field(        int,    sync_mode               )
428
407
                __field(        char,   more_io                 )       
429
408
                __field(       pgoff_t, writeback_index         )
430
409
        ),
431
410
 
432
411
        TP_fast_assign(
433
 
                __entry->dev_major      = MAJOR(inode->i_sb->s_dev);
434
 
                __entry->dev_minor      = MINOR(inode->i_sb->s_dev);
 
412
                __entry->dev            = inode->i_sb->s_dev;
435
413
                __entry->ino            = inode->i_ino;
436
414
                __entry->ret            = ret;
437
415
                __entry->pages_written  = pages_written;
438
416
                __entry->pages_skipped  = wbc->pages_skipped;
 
417
                __entry->sync_mode      = wbc->sync_mode;
439
418
                __entry->more_io        = wbc->more_io;
440
419
                __entry->writeback_index = inode->i_mapping->writeback_index;
441
420
        ),
442
421
 
443
 
        TP_printk("dev %d,%d ino %lu ret %d pages_written %d pages_skipped %ld more_io %d writeback_index %lu",
444
 
                  __entry->dev_major, __entry->dev_minor,
 
422
        TP_printk("dev %d,%d ino %lu ret %d pages_written %d pages_skipped %ld "
 
423
                  " more_io %d sync_mode %d writeback_index %lu",
 
424
                  MAJOR(__entry->dev), MINOR(__entry->dev),
445
425
                  (unsigned long) __entry->ino, __entry->ret,
446
426
                  __entry->pages_written, __entry->pages_skipped,
447
 
                  __entry->more_io,
 
427
                  __entry->more_io, __entry->sync_mode,
448
428
                  (unsigned long) __entry->writeback_index)
449
429
);
450
430
 
 
431
DECLARE_EVENT_CLASS(ext4__page_op,
 
432
        TP_PROTO(struct page *page),
 
433
 
 
434
        TP_ARGS(page),
 
435
 
 
436
        TP_STRUCT__entry(
 
437
                __field(        pgoff_t, index                  )
 
438
                __field(        ino_t,  ino                     )
 
439
                __field(        dev_t,  dev                     )
 
440
 
 
441
        ),
 
442
 
 
443
        TP_fast_assign(
 
444
                __entry->index  = page->index;
 
445
                __entry->ino    = page->mapping->host->i_ino;
 
446
                __entry->dev    = page->mapping->host->i_sb->s_dev;
 
447
        ),
 
448
 
 
449
        TP_printk("dev %d,%d ino %lu page_index %lu",
 
450
                  MAJOR(__entry->dev), MINOR(__entry->dev),
 
451
                  (unsigned long) __entry->ino,
 
452
                  __entry->index)
 
453
);
 
454
 
 
455
DEFINE_EVENT(ext4__page_op, ext4_readpage,
 
456
 
 
457
        TP_PROTO(struct page *page),
 
458
 
 
459
        TP_ARGS(page)
 
460
);
 
461
 
 
462
DEFINE_EVENT(ext4__page_op, ext4_releasepage,
 
463
 
 
464
        TP_PROTO(struct page *page),
 
465
 
 
466
        TP_ARGS(page)
 
467
);
 
468
 
 
469
TRACE_EVENT(ext4_invalidatepage,
 
470
        TP_PROTO(struct page *page, unsigned long offset),
 
471
 
 
472
        TP_ARGS(page, offset),
 
473
 
 
474
        TP_STRUCT__entry(
 
475
                __field(        pgoff_t, index                  )
 
476
                __field(        unsigned long, offset           )
 
477
                __field(        ino_t,  ino                     )
 
478
                __field(        dev_t,  dev                     )
 
479
 
 
480
        ),
 
481
 
 
482
        TP_fast_assign(
 
483
                __entry->index  = page->index;
 
484
                __entry->offset = offset;
 
485
                __entry->ino    = page->mapping->host->i_ino;
 
486
                __entry->dev    = page->mapping->host->i_sb->s_dev;
 
487
        ),
 
488
 
 
489
        TP_printk("dev %d,%d ino %lu page_index %lu offset %lu",
 
490
                  MAJOR(__entry->dev), MINOR(__entry->dev),
 
491
                  (unsigned long) __entry->ino,
 
492
                  __entry->index, __entry->offset)
 
493
);
 
494
 
451
495
TRACE_EVENT(ext4_discard_blocks,
452
496
        TP_PROTO(struct super_block *sb, unsigned long long blk,
453
497
                        unsigned long long count),
455
499
        TP_ARGS(sb, blk, count),
456
500
 
457
501
        TP_STRUCT__entry(
458
 
                __field(        int,   dev_major                )
459
 
                __field(        int,   dev_minor                )
 
502
                __field(        dev_t,  dev                     )
460
503
                __field(        __u64,  blk                     )
461
504
                __field(        __u64,  count                   )
462
505
 
463
506
        ),
464
507
 
465
508
        TP_fast_assign(
466
 
                __entry->dev_major = MAJOR(sb->s_dev);
467
 
                __entry->dev_minor = MINOR(sb->s_dev);
 
509
                __entry->dev    = sb->s_dev;
468
510
                __entry->blk    = blk;
469
511
                __entry->count  = count;
470
512
        ),
471
513
 
472
514
        TP_printk("dev %d,%d blk %llu count %llu",
473
 
                  __entry->dev_major, __entry->dev_minor,
 
515
                  MAJOR(__entry->dev), MINOR(__entry->dev),
474
516
                  __entry->blk, __entry->count)
475
517
);
476
518
 
481
523
        TP_ARGS(ac, pa),
482
524
 
483
525
        TP_STRUCT__entry(
484
 
                __field(        int,   dev_major                )
485
 
                __field(        int,   dev_minor                )
 
526
                __field(        dev_t,  dev                     )
486
527
                __field(        ino_t,  ino                     )
487
528
                __field(        __u64,  pa_pstart               )
488
529
                __field(        __u32,  pa_len                  )
491
532
        ),
492
533
 
493
534
        TP_fast_assign(
494
 
                __entry->dev_major      = MAJOR(ac->ac_sb->s_dev);
495
 
                __entry->dev_minor      = MINOR(ac->ac_sb->s_dev);
 
535
                __entry->dev            = ac->ac_sb->s_dev;
496
536
                __entry->ino            = ac->ac_inode->i_ino;
497
537
                __entry->pa_pstart      = pa->pa_pstart;
498
538
                __entry->pa_len         = pa->pa_len;
500
540
        ),
501
541
 
502
542
        TP_printk("dev %d,%d ino %lu pstart %llu len %u lstart %llu",
503
 
                  __entry->dev_major, __entry->dev_minor,
504
 
                  (unsigned long) __entry->ino, __entry->pa_pstart,
505
 
                  __entry->pa_len, __entry->pa_lstart)
 
543
                  MAJOR(__entry->dev), MINOR(__entry->dev),
 
544
                  (unsigned long) __entry->ino,
 
545
                  __entry->pa_pstart, __entry->pa_len, __entry->pa_lstart)
506
546
);
507
547
 
508
548
DEFINE_EVENT(ext4__mb_new_pa, ext4_mb_new_inode_pa,
530
570
        TP_ARGS(sb, inode, pa, block, count),
531
571
 
532
572
        TP_STRUCT__entry(
533
 
                __field(        int,   dev_major                )
534
 
                __field(        int,   dev_minor                )
 
573
                __field(        dev_t,  dev                     )
535
574
                __field(        ino_t,  ino                     )
536
575
                __field(        __u64,  block                   )
537
576
                __field(        __u32,  count                   )
539
578
        ),
540
579
 
541
580
        TP_fast_assign(
542
 
                __entry->dev_major      = MAJOR(sb->s_dev);
543
 
                __entry->dev_minor      = MINOR(sb->s_dev);
 
581
                __entry->dev            = sb->s_dev;
544
582
                __entry->ino            = inode->i_ino;
545
583
                __entry->block          = block;
546
584
                __entry->count          = count;
547
585
        ),
548
586
 
549
587
        TP_printk("dev %d,%d ino %lu block %llu count %u",
550
 
                  __entry->dev_major, __entry->dev_minor,
551
 
                  (unsigned long) __entry->ino, __entry->block, __entry->count)
 
588
                  MAJOR(__entry->dev), MINOR(__entry->dev),
 
589
                  (unsigned long) __entry->ino,
 
590
                  __entry->block, __entry->count)
552
591
);
553
592
 
554
593
TRACE_EVENT(ext4_mb_release_group_pa,
558
597
        TP_ARGS(sb, pa),
559
598
 
560
599
        TP_STRUCT__entry(
561
 
                __field(        int,   dev_major                )
562
 
                __field(        int,   dev_minor                )
 
600
                __field(        dev_t,  dev                     )
563
601
                __field(        __u64,  pa_pstart               )
564
602
                __field(        __u32,  pa_len                  )
565
603
 
566
604
        ),
567
605
 
568
606
        TP_fast_assign(
569
 
                __entry->dev_major      = MAJOR(sb->s_dev);
570
 
                __entry->dev_minor      = MINOR(sb->s_dev);
 
607
                __entry->dev            = sb->s_dev;
571
608
                __entry->pa_pstart      = pa->pa_pstart;
572
609
                __entry->pa_len         = pa->pa_len;
573
610
        ),
574
611
 
575
612
        TP_printk("dev %d,%d pstart %llu len %u",
576
 
                  __entry->dev_major, __entry->dev_minor,
 
613
                  MAJOR(__entry->dev), MINOR(__entry->dev),
577
614
                  __entry->pa_pstart, __entry->pa_len)
578
615
);
579
616
 
583
620
        TP_ARGS(inode),
584
621
 
585
622
        TP_STRUCT__entry(
586
 
                __field(        int,   dev_major                )
587
 
                __field(        int,   dev_minor                )
 
623
                __field(        dev_t,  dev                     )
588
624
                __field(        ino_t,  ino                     )
589
625
 
590
626
        ),
591
627
 
592
628
        TP_fast_assign(
593
 
                __entry->dev_major = MAJOR(inode->i_sb->s_dev);
594
 
                __entry->dev_minor = MINOR(inode->i_sb->s_dev);
 
629
                __entry->dev    = inode->i_sb->s_dev;
595
630
                __entry->ino    = inode->i_ino;
596
631
        ),
597
632
 
598
633
        TP_printk("dev %d,%d ino %lu",
599
 
                  __entry->dev_major, __entry->dev_minor,
 
634
                  MAJOR(__entry->dev), MINOR(__entry->dev),
600
635
                  (unsigned long) __entry->ino)
601
636
);
602
637
 
606
641
        TP_ARGS(sb, needed),
607
642
 
608
643
        TP_STRUCT__entry(
609
 
                __field(        int,   dev_major                )
610
 
                __field(        int,   dev_minor                )
 
644
                __field(        dev_t,  dev                     )
611
645
                __field(        int,    needed                  )
612
646
 
613
647
        ),
614
648
 
615
649
        TP_fast_assign(
616
 
                __entry->dev_major = MAJOR(sb->s_dev);
617
 
                __entry->dev_minor = MINOR(sb->s_dev);
 
650
                __entry->dev    = sb->s_dev;
618
651
                __entry->needed = needed;
619
652
        ),
620
653
 
621
654
        TP_printk("dev %d,%d needed %d",
622
 
                  __entry->dev_major, __entry->dev_minor, __entry->needed)
 
655
                  MAJOR(__entry->dev), MINOR(__entry->dev),
 
656
                  __entry->needed)
623
657
);
624
658
 
625
659
TRACE_EVENT(ext4_request_blocks,
628
662
        TP_ARGS(ar),
629
663
 
630
664
        TP_STRUCT__entry(
631
 
                __field(        int,   dev_major                )
632
 
                __field(        int,   dev_minor                )
 
665
                __field(        dev_t,  dev                     )
633
666
                __field(        ino_t,  ino                     )
634
667
                __field(        unsigned int, flags             )
635
668
                __field(        unsigned int, len               )
642
675
        ),
643
676
 
644
677
        TP_fast_assign(
645
 
                __entry->dev_major = MAJOR(ar->inode->i_sb->s_dev);
646
 
                __entry->dev_minor = MINOR(ar->inode->i_sb->s_dev);
 
678
                __entry->dev    = ar->inode->i_sb->s_dev;
647
679
                __entry->ino    = ar->inode->i_ino;
648
680
                __entry->flags  = ar->flags;
649
681
                __entry->len    = ar->len;
655
687
                __entry->pright = ar->pright;
656
688
        ),
657
689
 
658
 
        TP_printk("dev %d,%d ino %lu flags %u len %u lblk %llu goal %llu lleft %llu lright %llu pleft %llu pright %llu ",
659
 
                  __entry->dev_major, __entry->dev_minor,
 
690
        TP_printk("dev %d,%d ino %lu flags %u len %u lblk %llu goal %llu "
 
691
                  "lleft %llu lright %llu pleft %llu pright %llu ",
 
692
                  MAJOR(__entry->dev), MINOR(__entry->dev),
660
693
                  (unsigned long) __entry->ino,
661
694
                  __entry->flags, __entry->len,
662
695
                  (unsigned long long) __entry->logical,
673
706
        TP_ARGS(ar, block),
674
707
 
675
708
        TP_STRUCT__entry(
676
 
                __field(        int,   dev_major                )
677
 
                __field(        int,   dev_minor                )
 
709
                __field(        dev_t,  dev                     )
678
710
                __field(        ino_t,  ino                     )
679
711
                __field(        __u64,  block                   )
680
712
                __field(        unsigned int, flags             )
688
720
        ),
689
721
 
690
722
        TP_fast_assign(
691
 
                __entry->dev_major = MAJOR(ar->inode->i_sb->s_dev);
692
 
                __entry->dev_minor = MINOR(ar->inode->i_sb->s_dev);
 
723
                __entry->dev    = ar->inode->i_sb->s_dev;
693
724
                __entry->ino    = ar->inode->i_ino;
694
725
                __entry->block  = block;
695
726
                __entry->flags  = ar->flags;
702
733
                __entry->pright = ar->pright;
703
734
        ),
704
735
 
705
 
        TP_printk("dev %d,%d ino %lu flags %u len %u block %llu lblk %llu goal %llu lleft %llu lright %llu pleft %llu pright %llu ",
706
 
                  __entry->dev_major, __entry->dev_minor,
707
 
                  (unsigned long) __entry->ino, __entry->flags,
708
 
                  __entry->len, __entry->block,
 
736
        TP_printk("dev %d,%d ino %lu flags %u len %u block %llu lblk %llu "
 
737
                  "goal %llu lleft %llu lright %llu pleft %llu pright %llu",
 
738
                  MAJOR(__entry->dev), MINOR(__entry->dev),
 
739
                  (unsigned long) __entry->ino,
 
740
                  __entry->flags, __entry->len, __entry->block,
709
741
                  (unsigned long long) __entry->logical,
710
742
                  (unsigned long long) __entry->goal,
711
743
                  (unsigned long long) __entry->lleft,
721
753
        TP_ARGS(inode, block, count, flags),
722
754
 
723
755
        TP_STRUCT__entry(
724
 
                __field(        int,   dev_major                )
725
 
                __field(        int,   dev_minor                )
 
756
                __field(        dev_t,  dev                     )
726
757
                __field(        ino_t,  ino                     )
727
758
                __field(      umode_t, mode                     )
728
759
                __field(        __u64,  block                   )
731
762
        ),
732
763
 
733
764
        TP_fast_assign(
734
 
                __entry->dev_major      = MAJOR(inode->i_sb->s_dev);
735
 
                __entry->dev_minor      = MINOR(inode->i_sb->s_dev);
 
765
                __entry->dev            = inode->i_sb->s_dev;
736
766
                __entry->ino            = inode->i_ino;
737
767
                __entry->mode           = inode->i_mode;
738
768
                __entry->block          = block;
741
771
        ),
742
772
 
743
773
        TP_printk("dev %d,%d ino %lu mode 0%o block %llu count %lu flags %d",
744
 
                  __entry->dev_major, __entry->dev_minor,
 
774
                  MAJOR(__entry->dev), MINOR(__entry->dev),
745
775
                  (unsigned long) __entry->ino,
746
776
                  __entry->mode, __entry->block, __entry->count,
747
777
                  __entry->flags)
748
778
);
749
779
 
750
 
TRACE_EVENT(ext4_sync_file,
 
780
TRACE_EVENT(ext4_sync_file_enter,
751
781
        TP_PROTO(struct file *file, int datasync),
752
782
 
753
783
        TP_ARGS(file, datasync),
754
784
 
755
785
        TP_STRUCT__entry(
756
 
                __field(        int,   dev_major                )
757
 
                __field(        int,   dev_minor                )
 
786
                __field(        dev_t,  dev                     )
758
787
                __field(        ino_t,  ino                     )
759
788
                __field(        ino_t,  parent                  )
760
789
                __field(        int,    datasync                )
763
792
        TP_fast_assign(
764
793
                struct dentry *dentry = file->f_path.dentry;
765
794
 
766
 
                __entry->dev_major      = MAJOR(dentry->d_inode->i_sb->s_dev);
767
 
                __entry->dev_minor      = MINOR(dentry->d_inode->i_sb->s_dev);
 
795
                __entry->dev            = dentry->d_inode->i_sb->s_dev;
768
796
                __entry->ino            = dentry->d_inode->i_ino;
769
797
                __entry->datasync       = datasync;
770
798
                __entry->parent         = dentry->d_parent->d_inode->i_ino;
771
799
        ),
772
800
 
773
801
        TP_printk("dev %d,%d ino %ld parent %ld datasync %d ",
774
 
                  __entry->dev_major, __entry->dev_minor,
 
802
                  MAJOR(__entry->dev), MINOR(__entry->dev),
775
803
                  (unsigned long) __entry->ino,
776
804
                  (unsigned long) __entry->parent, __entry->datasync)
777
805
);
778
806
 
 
807
TRACE_EVENT(ext4_sync_file_exit,
 
808
        TP_PROTO(struct inode *inode, int ret),
 
809
 
 
810
        TP_ARGS(inode, ret),
 
811
 
 
812
        TP_STRUCT__entry(
 
813
                __field(        int,    ret                     )
 
814
                __field(        ino_t,  ino                     )
 
815
                __field(        dev_t,  dev                     )
 
816
        ),
 
817
 
 
818
        TP_fast_assign(
 
819
                __entry->ret            = ret;
 
820
                __entry->ino            = inode->i_ino;
 
821
                __entry->dev            = inode->i_sb->s_dev;
 
822
        ),
 
823
 
 
824
        TP_printk("dev %d,%d ino %ld ret %d",
 
825
                  MAJOR(__entry->dev), MINOR(__entry->dev),
 
826
                  (unsigned long) __entry->ino,
 
827
                  __entry->ret)
 
828
);
 
829
 
779
830
TRACE_EVENT(ext4_sync_fs,
780
831
        TP_PROTO(struct super_block *sb, int wait),
781
832
 
782
833
        TP_ARGS(sb, wait),
783
834
 
784
835
        TP_STRUCT__entry(
785
 
                __field(        int,   dev_major                )
786
 
                __field(        int,   dev_minor                )
 
836
                __field(        dev_t,  dev                     )
787
837
                __field(        int,    wait                    )
788
838
 
789
839
        ),
790
840
 
791
841
        TP_fast_assign(
792
 
                __entry->dev_major = MAJOR(sb->s_dev);
793
 
                __entry->dev_minor = MINOR(sb->s_dev);
 
842
                __entry->dev    = sb->s_dev;
794
843
                __entry->wait   = wait;
795
844
        ),
796
845
 
797
 
        TP_printk("dev %d,%d wait %d", __entry->dev_major,
798
 
                  __entry->dev_minor, __entry->wait)
 
846
        TP_printk("dev %d,%d wait %d",
 
847
                  MAJOR(__entry->dev), MINOR(__entry->dev),
 
848
                  __entry->wait)
799
849
);
800
850
 
801
851
TRACE_EVENT(ext4_alloc_da_blocks,
804
854
        TP_ARGS(inode),
805
855
 
806
856
        TP_STRUCT__entry(
807
 
                __field(        int,   dev_major                )
808
 
                __field(        int,   dev_minor                )
 
857
                __field(        dev_t,  dev                     )
809
858
                __field(        ino_t,  ino                     )
810
859
                __field( unsigned int,  data_blocks     )
811
860
                __field( unsigned int,  meta_blocks     )
812
861
        ),
813
862
 
814
863
        TP_fast_assign(
815
 
                __entry->dev_major = MAJOR(inode->i_sb->s_dev);
816
 
                __entry->dev_minor = MINOR(inode->i_sb->s_dev);
 
864
                __entry->dev    = inode->i_sb->s_dev;
817
865
                __entry->ino    = inode->i_ino;
818
866
                __entry->data_blocks = EXT4_I(inode)->i_reserved_data_blocks;
819
867
                __entry->meta_blocks = EXT4_I(inode)->i_reserved_meta_blocks;
820
868
        ),
821
869
 
822
870
        TP_printk("dev %d,%d ino %lu data_blocks %u meta_blocks %u",
823
 
                  __entry->dev_major, __entry->dev_minor,
 
871
                  MAJOR(__entry->dev), MINOR(__entry->dev),
824
872
                  (unsigned long) __entry->ino,
825
873
                  __entry->data_blocks, __entry->meta_blocks)
826
874
);
831
879
        TP_ARGS(ac),
832
880
 
833
881
        TP_STRUCT__entry(
834
 
                __field(        int,   dev_major                )
835
 
                __field(        int,   dev_minor                )
 
882
                __field(        dev_t,  dev                     )
836
883
                __field(        ino_t,  ino                     )
837
884
                __field(        __u16,  found                   )
838
885
                __field(        __u16,  groups                  )
855
902
        ),
856
903
 
857
904
        TP_fast_assign(
858
 
                __entry->dev_major      = MAJOR(ac->ac_inode->i_sb->s_dev);
859
 
                __entry->dev_minor      = MINOR(ac->ac_inode->i_sb->s_dev);
 
905
                __entry->dev            = ac->ac_inode->i_sb->s_dev;
860
906
                __entry->ino            = ac->ac_inode->i_ino;
861
907
                __entry->found          = ac->ac_found;
862
908
                __entry->flags          = ac->ac_flags;
881
927
        TP_printk("dev %d,%d inode %lu orig %u/%d/%u@%u goal %u/%d/%u@%u "
882
928
                  "result %u/%d/%u@%u blks %u grps %u cr %u flags 0x%04x "
883
929
                  "tail %u broken %u",
884
 
                  __entry->dev_major, __entry->dev_minor,
 
930
                  MAJOR(__entry->dev), MINOR(__entry->dev),
885
931
                  (unsigned long) __entry->ino,
886
932
                  __entry->orig_group, __entry->orig_start,
887
933
                  __entry->orig_len, __entry->orig_logical,
900
946
        TP_ARGS(ac),
901
947
 
902
948
        TP_STRUCT__entry(
903
 
                __field(        int,   dev_major                )
904
 
                __field(        int,   dev_minor                )
 
949
                __field(        dev_t,  dev                     )
905
950
                __field(        ino_t,  ino                     )
906
951
                __field(        __u32,  orig_logical            )
907
952
                __field(          int,  orig_start              )
914
959
        ),
915
960
 
916
961
        TP_fast_assign(
917
 
                __entry->dev_major      = MAJOR(ac->ac_inode->i_sb->s_dev);
918
 
                __entry->dev_minor      = MINOR(ac->ac_inode->i_sb->s_dev);
 
962
                __entry->dev            = ac->ac_inode->i_sb->s_dev;
919
963
                __entry->ino            = ac->ac_inode->i_ino;
920
964
                __entry->orig_logical   = ac->ac_o_ex.fe_logical;
921
965
                __entry->orig_start     = ac->ac_o_ex.fe_start;
928
972
        ),
929
973
 
930
974
        TP_printk("dev %d,%d inode %lu orig %u/%d/%u@%u result %u/%d/%u@%u",
931
 
                  __entry->dev_major, __entry->dev_minor,
 
975
                  MAJOR(__entry->dev), MINOR(__entry->dev),
932
976
                  (unsigned long) __entry->ino,
933
977
                  __entry->orig_group, __entry->orig_start,
934
978
                  __entry->orig_len, __entry->orig_logical,
946
990
        TP_ARGS(sb, inode, group, start, len),
947
991
 
948
992
        TP_STRUCT__entry(
949
 
                __field(        int,   dev_major                )
950
 
                __field(        int,   dev_minor                )
 
993
                __field(        dev_t,  dev                     )
951
994
                __field(        ino_t,  ino                     )
952
995
                __field(          int,  result_start            )
953
996
                __field(        __u32,  result_group            )
955
998
        ),
956
999
 
957
1000
        TP_fast_assign(
958
 
                __entry->dev_major      = MAJOR(sb->s_dev);
959
 
                __entry->dev_minor      = MINOR(sb->s_dev);
 
1001
                __entry->dev            = sb->s_dev;
960
1002
                __entry->ino            = inode ? inode->i_ino : 0;
961
1003
                __entry->result_start   = start;
962
1004
                __entry->result_group   = group;
964
1006
        ),
965
1007
 
966
1008
        TP_printk("dev %d,%d inode %lu extent %u/%d/%u ",
967
 
                  __entry->dev_major, __entry->dev_minor,
 
1009
                  MAJOR(__entry->dev), MINOR(__entry->dev),
968
1010
                  (unsigned long) __entry->ino,
969
1011
                  __entry->result_group, __entry->result_start,
970
1012
                  __entry->result_len)
998
1040
        TP_ARGS(inode, is_metadata, block),
999
1041
 
1000
1042
        TP_STRUCT__entry(
1001
 
                __field(        int,   dev_major                )
1002
 
                __field(        int,   dev_minor                )
 
1043
                __field(        dev_t,  dev                     )
1003
1044
                __field(        ino_t,  ino                     )
1004
1045
                __field(        umode_t, mode                   )
1005
1046
                __field(        int,    is_metadata             )
1007
1048
        ),
1008
1049
 
1009
1050
        TP_fast_assign(
1010
 
                __entry->dev_major = MAJOR(inode->i_sb->s_dev);
1011
 
                __entry->dev_minor = MINOR(inode->i_sb->s_dev);
 
1051
                __entry->dev    = inode->i_sb->s_dev;
1012
1052
                __entry->ino    = inode->i_ino;
1013
1053
                __entry->mode   = inode->i_mode;
1014
1054
                __entry->is_metadata = is_metadata;
1016
1056
        ),
1017
1057
 
1018
1058
        TP_printk("dev %d,%d ino %lu mode 0%o is_metadata %d block %llu",
1019
 
                  __entry->dev_major, __entry->dev_minor,
1020
 
                  (unsigned long) __entry->ino, __entry->mode,
1021
 
                  __entry->is_metadata, __entry->block)
 
1059
                  MAJOR(__entry->dev), MINOR(__entry->dev),
 
1060
                  (unsigned long) __entry->ino,
 
1061
                  __entry->mode, __entry->is_metadata, __entry->block)
1022
1062
);
1023
1063
 
1024
1064
TRACE_EVENT(ext4_da_update_reserve_space,
1027
1067
        TP_ARGS(inode, used_blocks),
1028
1068
 
1029
1069
        TP_STRUCT__entry(
1030
 
                __field(        int,   dev_major                )
1031
 
                __field(        int,   dev_minor                )
 
1070
                __field(        dev_t,  dev                     )
1032
1071
                __field(        ino_t,  ino                     )
1033
1072
                __field(        umode_t, mode                   )
1034
1073
                __field(        __u64,  i_blocks                )
1039
1078
        ),
1040
1079
 
1041
1080
        TP_fast_assign(
1042
 
                __entry->dev_major = MAJOR(inode->i_sb->s_dev);
1043
 
                __entry->dev_minor = MINOR(inode->i_sb->s_dev);
 
1081
                __entry->dev    = inode->i_sb->s_dev;
1044
1082
                __entry->ino    = inode->i_ino;
1045
1083
                __entry->mode   = inode->i_mode;
1046
1084
                __entry->i_blocks = inode->i_blocks;
1050
1088
                __entry->allocated_meta_blocks = EXT4_I(inode)->i_allocated_meta_blocks;
1051
1089
        ),
1052
1090
 
1053
 
        TP_printk("dev %d,%d ino %lu mode 0%o i_blocks %llu used_blocks %d reserved_data_blocks %d reserved_meta_blocks %d allocated_meta_blocks %d",
1054
 
                  __entry->dev_major, __entry->dev_minor,
1055
 
                  (unsigned long) __entry->ino, __entry->mode,
1056
 
                  (unsigned long long) __entry->i_blocks,
 
1091
        TP_printk("dev %d,%d ino %lu mode 0%o i_blocks %llu used_blocks %d "
 
1092
                  "reserved_data_blocks %d reserved_meta_blocks %d "
 
1093
                  "allocated_meta_blocks %d",
 
1094
                  MAJOR(__entry->dev), MINOR(__entry->dev),
 
1095
                  (unsigned long) __entry->ino,
 
1096
                  __entry->mode,  (unsigned long long) __entry->i_blocks,
1057
1097
                  __entry->used_blocks, __entry->reserved_data_blocks,
1058
1098
                  __entry->reserved_meta_blocks, __entry->allocated_meta_blocks)
1059
1099
);
1064
1104
        TP_ARGS(inode, md_needed),
1065
1105
 
1066
1106
        TP_STRUCT__entry(
1067
 
                __field(        int,   dev_major                )
1068
 
                __field(        int,   dev_minor                )
 
1107
                __field(        dev_t,  dev                     )
1069
1108
                __field(        ino_t,  ino                     )
1070
1109
                __field(        umode_t, mode                   )
1071
1110
                __field(        __u64,  i_blocks                )
1075
1114
        ),
1076
1115
 
1077
1116
        TP_fast_assign(
1078
 
                __entry->dev_major = MAJOR(inode->i_sb->s_dev);
1079
 
                __entry->dev_minor = MINOR(inode->i_sb->s_dev);
 
1117
                __entry->dev    = inode->i_sb->s_dev;
1080
1118
                __entry->ino    = inode->i_ino;
1081
1119
                __entry->mode   = inode->i_mode;
1082
1120
                __entry->i_blocks = inode->i_blocks;
1085
1123
                __entry->reserved_meta_blocks = EXT4_I(inode)->i_reserved_meta_blocks;
1086
1124
        ),
1087
1125
 
1088
 
        TP_printk("dev %d,%d ino %lu mode 0%o i_blocks %llu md_needed %d reserved_data_blocks %d reserved_meta_blocks %d",
1089
 
                  __entry->dev_major, __entry->dev_minor,
 
1126
        TP_printk("dev %d,%d ino %lu mode 0%o i_blocks %llu md_needed %d "
 
1127
                  "reserved_data_blocks %d reserved_meta_blocks %d",
 
1128
                  MAJOR(__entry->dev), MINOR(__entry->dev),
1090
1129
                  (unsigned long) __entry->ino,
1091
1130
                  __entry->mode, (unsigned long long) __entry->i_blocks,
1092
1131
                  __entry->md_needed, __entry->reserved_data_blocks,
1099
1138
        TP_ARGS(inode, freed_blocks),
1100
1139
 
1101
1140
        TP_STRUCT__entry(
1102
 
                __field(        int,   dev_major                )
1103
 
                __field(        int,   dev_minor                )
 
1141
                __field(        dev_t,  dev                     )
1104
1142
                __field(        ino_t,  ino                     )
1105
1143
                __field(        umode_t, mode                   )
1106
1144
                __field(        __u64,  i_blocks                )
1111
1149
        ),
1112
1150
 
1113
1151
        TP_fast_assign(
1114
 
                __entry->dev_major = MAJOR(inode->i_sb->s_dev);
1115
 
                __entry->dev_minor = MINOR(inode->i_sb->s_dev);
 
1152
                __entry->dev    = inode->i_sb->s_dev;
1116
1153
                __entry->ino    = inode->i_ino;
1117
1154
                __entry->mode   = inode->i_mode;
1118
1155
                __entry->i_blocks = inode->i_blocks;
1122
1159
                __entry->allocated_meta_blocks = EXT4_I(inode)->i_allocated_meta_blocks;
1123
1160
        ),
1124
1161
 
1125
 
        TP_printk("dev %d,%d ino %lu mode 0%o i_blocks %llu freed_blocks %d reserved_data_blocks %d reserved_meta_blocks %d allocated_meta_blocks %d",
1126
 
                  __entry->dev_major, __entry->dev_minor,
 
1162
        TP_printk("dev %d,%d ino %lu mode 0%o i_blocks %llu freed_blocks %d "
 
1163
                  "reserved_data_blocks %d reserved_meta_blocks %d "
 
1164
                  "allocated_meta_blocks %d",
 
1165
                  MAJOR(__entry->dev), MINOR(__entry->dev),
1127
1166
                  (unsigned long) __entry->ino,
1128
1167
                  __entry->mode, (unsigned long long) __entry->i_blocks,
1129
1168
                  __entry->freed_blocks, __entry->reserved_data_blocks,
1136
1175
        TP_ARGS(sb, group),
1137
1176
 
1138
1177
        TP_STRUCT__entry(
1139
 
                __field(        int,   dev_major                )
1140
 
                __field(        int,   dev_minor                )
 
1178
                __field(        dev_t,  dev                     )
1141
1179
                __field(        __u32,  group                   )
1142
1180
 
1143
1181
        ),
1144
1182
 
1145
1183
        TP_fast_assign(
1146
 
                __entry->dev_major = MAJOR(sb->s_dev);
1147
 
                __entry->dev_minor = MINOR(sb->s_dev);
 
1184
                __entry->dev    = sb->s_dev;
1148
1185
                __entry->group  = group;
1149
1186
        ),
1150
1187
 
1151
1188
        TP_printk("dev %d,%d group %u",
1152
 
                  __entry->dev_major, __entry->dev_minor, __entry->group)
 
1189
                  MAJOR(__entry->dev), MINOR(__entry->dev),
 
1190
                  __entry->group)
1153
1191
);
1154
1192
 
1155
1193
DEFINE_EVENT(ext4__bitmap_load, ext4_mb_bitmap_load,
1166
1204
        TP_ARGS(sb, group)
1167
1205
);
1168
1206
 
 
1207
DEFINE_EVENT(ext4__bitmap_load, ext4_read_block_bitmap_load,
 
1208
 
 
1209
        TP_PROTO(struct super_block *sb, unsigned long group),
 
1210
 
 
1211
        TP_ARGS(sb, group)
 
1212
);
 
1213
 
 
1214
DEFINE_EVENT(ext4__bitmap_load, ext4_load_inode_bitmap,
 
1215
 
 
1216
        TP_PROTO(struct super_block *sb, unsigned long group),
 
1217
 
 
1218
        TP_ARGS(sb, group)
 
1219
);
 
1220
 
 
1221
TRACE_EVENT(ext4_direct_IO_enter,
 
1222
        TP_PROTO(struct inode *inode, loff_t offset, unsigned long len, int rw),
 
1223
 
 
1224
        TP_ARGS(inode, offset, len, rw),
 
1225
 
 
1226
        TP_STRUCT__entry(
 
1227
                __field(        ino_t,  ino                     )
 
1228
                __field(        dev_t,  dev                     )
 
1229
                __field(        loff_t, pos                     )
 
1230
                __field(        unsigned long,  len             )
 
1231
                __field(        int,    rw                      )
 
1232
        ),
 
1233
 
 
1234
        TP_fast_assign(
 
1235
                __entry->ino    = inode->i_ino;
 
1236
                __entry->dev    = inode->i_sb->s_dev;
 
1237
                __entry->pos    = offset;
 
1238
                __entry->len    = len;
 
1239
                __entry->rw     = rw;
 
1240
        ),
 
1241
 
 
1242
        TP_printk("dev %d,%d ino %lu pos %llu len %lu rw %d",
 
1243
                  MAJOR(__entry->dev), MINOR(__entry->dev),
 
1244
                  (unsigned long) __entry->ino,
 
1245
                  (unsigned long long) __entry->pos, __entry->len, __entry->rw)
 
1246
);
 
1247
 
 
1248
TRACE_EVENT(ext4_direct_IO_exit,
 
1249
        TP_PROTO(struct inode *inode, loff_t offset, unsigned long len, int rw, int ret),
 
1250
 
 
1251
        TP_ARGS(inode, offset, len, rw, ret),
 
1252
 
 
1253
        TP_STRUCT__entry(
 
1254
                __field(        ino_t,  ino                     )
 
1255
                __field(        dev_t,  dev                     )
 
1256
                __field(        loff_t, pos                     )
 
1257
                __field(        unsigned long,  len             )
 
1258
                __field(        int,    rw                      )
 
1259
                __field(        int,    ret                     )
 
1260
        ),
 
1261
 
 
1262
        TP_fast_assign(
 
1263
                __entry->ino    = inode->i_ino;
 
1264
                __entry->dev    = inode->i_sb->s_dev;
 
1265
                __entry->pos    = offset;
 
1266
                __entry->len    = len;
 
1267
                __entry->rw     = rw;
 
1268
                __entry->ret    = ret;
 
1269
        ),
 
1270
 
 
1271
        TP_printk("dev %d,%d ino %lu pos %llu len %lu rw %d ret %d",
 
1272
                  MAJOR(__entry->dev), MINOR(__entry->dev),
 
1273
                  (unsigned long) __entry->ino,
 
1274
                  (unsigned long long) __entry->pos, __entry->len,
 
1275
                  __entry->rw, __entry->ret)
 
1276
);
 
1277
 
 
1278
TRACE_EVENT(ext4_fallocate_enter,
 
1279
        TP_PROTO(struct inode *inode, loff_t offset, loff_t len, int mode),
 
1280
 
 
1281
        TP_ARGS(inode, offset, len, mode),
 
1282
 
 
1283
        TP_STRUCT__entry(
 
1284
                __field(        ino_t,  ino                     )
 
1285
                __field(        dev_t,  dev                     )
 
1286
                __field(        loff_t, pos                     )
 
1287
                __field(        loff_t, len                     )
 
1288
                __field(        int,    mode                    )
 
1289
        ),
 
1290
 
 
1291
        TP_fast_assign(
 
1292
                __entry->ino    = inode->i_ino;
 
1293
                __entry->dev    = inode->i_sb->s_dev;
 
1294
                __entry->pos    = offset;
 
1295
                __entry->len    = len;
 
1296
                __entry->mode   = mode;
 
1297
        ),
 
1298
 
 
1299
        TP_printk("dev %d,%d ino %ld pos %llu len %llu mode %d",
 
1300
                  MAJOR(__entry->dev), MINOR(__entry->dev),
 
1301
                  (unsigned long) __entry->ino,
 
1302
                  (unsigned long long) __entry->pos,
 
1303
                  (unsigned long long) __entry->len, __entry->mode)
 
1304
);
 
1305
 
 
1306
TRACE_EVENT(ext4_fallocate_exit,
 
1307
        TP_PROTO(struct inode *inode, loff_t offset, unsigned int max_blocks, int ret),
 
1308
 
 
1309
        TP_ARGS(inode, offset, max_blocks, ret),
 
1310
 
 
1311
        TP_STRUCT__entry(
 
1312
                __field(        ino_t,  ino                     )
 
1313
                __field(        dev_t,  dev                     )
 
1314
                __field(        loff_t, pos                     )
 
1315
                __field(        unsigned,       blocks          )
 
1316
                __field(        int,    ret                     )
 
1317
        ),
 
1318
 
 
1319
        TP_fast_assign(
 
1320
                __entry->ino    = inode->i_ino;
 
1321
                __entry->dev    = inode->i_sb->s_dev;
 
1322
                __entry->pos    = offset;
 
1323
                __entry->blocks = max_blocks;
 
1324
                __entry->ret    = ret;
 
1325
        ),
 
1326
 
 
1327
        TP_printk("dev %d,%d ino %ld pos %llu blocks %d ret %d",
 
1328
                  MAJOR(__entry->dev), MINOR(__entry->dev),
 
1329
                  (unsigned long) __entry->ino,
 
1330
                  (unsigned long long) __entry->pos, __entry->blocks,
 
1331
                  __entry->ret)
 
1332
);
 
1333
 
 
1334
TRACE_EVENT(ext4_unlink_enter,
 
1335
        TP_PROTO(struct inode *parent, struct dentry *dentry),
 
1336
 
 
1337
        TP_ARGS(parent, dentry),
 
1338
 
 
1339
        TP_STRUCT__entry(
 
1340
                __field(        ino_t,  parent                  )
 
1341
                __field(        ino_t,  ino                     )
 
1342
                __field(        loff_t, size                    )
 
1343
                __field(        dev_t,  dev                     )
 
1344
        ),
 
1345
 
 
1346
        TP_fast_assign(
 
1347
                __entry->parent         = parent->i_ino;
 
1348
                __entry->ino            = dentry->d_inode->i_ino;
 
1349
                __entry->size           = dentry->d_inode->i_size;
 
1350
                __entry->dev            = dentry->d_inode->i_sb->s_dev;
 
1351
        ),
 
1352
 
 
1353
        TP_printk("dev %d,%d ino %ld size %lld parent %ld",
 
1354
                  MAJOR(__entry->dev), MINOR(__entry->dev),
 
1355
                  (unsigned long) __entry->ino, __entry->size,
 
1356
                  (unsigned long) __entry->parent)
 
1357
);
 
1358
 
 
1359
TRACE_EVENT(ext4_unlink_exit,
 
1360
        TP_PROTO(struct dentry *dentry, int ret),
 
1361
 
 
1362
        TP_ARGS(dentry, ret),
 
1363
 
 
1364
        TP_STRUCT__entry(
 
1365
                __field(        ino_t,  ino                     )
 
1366
                __field(        dev_t,  dev                     )
 
1367
                __field(        int,    ret                     )
 
1368
        ),
 
1369
 
 
1370
        TP_fast_assign(
 
1371
                __entry->ino            = dentry->d_inode->i_ino;
 
1372
                __entry->dev            = dentry->d_inode->i_sb->s_dev;
 
1373
                __entry->ret            = ret;
 
1374
        ),
 
1375
 
 
1376
        TP_printk("dev %d,%d ino %ld ret %d",
 
1377
                  MAJOR(__entry->dev), MINOR(__entry->dev),
 
1378
                  (unsigned long) __entry->ino,
 
1379
                  __entry->ret)
 
1380
);
 
1381
 
 
1382
DECLARE_EVENT_CLASS(ext4__truncate,
 
1383
        TP_PROTO(struct inode *inode),
 
1384
 
 
1385
        TP_ARGS(inode),
 
1386
 
 
1387
        TP_STRUCT__entry(
 
1388
                __field(        ino_t,          ino             )
 
1389
                __field(        dev_t,          dev             )
 
1390
                __field(        blkcnt_t,       blocks          )
 
1391
        ),
 
1392
 
 
1393
        TP_fast_assign(
 
1394
                __entry->ino    = inode->i_ino;
 
1395
                __entry->dev    = inode->i_sb->s_dev;
 
1396
                __entry->blocks = inode->i_blocks;
 
1397
        ),
 
1398
 
 
1399
        TP_printk("dev %d,%d ino %lu blocks %lu",
 
1400
                  MAJOR(__entry->dev), MINOR(__entry->dev),
 
1401
                  (unsigned long) __entry->ino, (unsigned long) __entry->blocks)
 
1402
);
 
1403
 
 
1404
DEFINE_EVENT(ext4__truncate, ext4_truncate_enter,
 
1405
 
 
1406
        TP_PROTO(struct inode *inode),
 
1407
 
 
1408
        TP_ARGS(inode)
 
1409
);
 
1410
 
 
1411
DEFINE_EVENT(ext4__truncate, ext4_truncate_exit,
 
1412
 
 
1413
        TP_PROTO(struct inode *inode),
 
1414
 
 
1415
        TP_ARGS(inode)
 
1416
);
 
1417
 
 
1418
DECLARE_EVENT_CLASS(ext4__map_blocks_enter,
 
1419
        TP_PROTO(struct inode *inode, ext4_lblk_t lblk,
 
1420
                 unsigned len, unsigned flags),
 
1421
 
 
1422
        TP_ARGS(inode, lblk, len, flags),
 
1423
 
 
1424
        TP_STRUCT__entry(
 
1425
                __field(        ino_t,          ino             )
 
1426
                __field(        dev_t,          dev             )
 
1427
                __field(        ext4_lblk_t,    lblk            )
 
1428
                __field(        unsigned,       len             )
 
1429
                __field(        unsigned,       flags           )
 
1430
        ),
 
1431
 
 
1432
        TP_fast_assign(
 
1433
                __entry->ino    = inode->i_ino;
 
1434
                __entry->dev    = inode->i_sb->s_dev;
 
1435
                __entry->lblk   = lblk;
 
1436
                __entry->len    = len;
 
1437
                __entry->flags  = flags;
 
1438
        ),
 
1439
 
 
1440
        TP_printk("dev %d,%d ino %lu lblk %u len %u flags %u",
 
1441
                  MAJOR(__entry->dev), MINOR(__entry->dev),
 
1442
                  (unsigned long) __entry->ino,
 
1443
                  (unsigned) __entry->lblk, __entry->len, __entry->flags)
 
1444
);
 
1445
 
 
1446
DEFINE_EVENT(ext4__map_blocks_enter, ext4_ext_map_blocks_enter,
 
1447
        TP_PROTO(struct inode *inode, ext4_lblk_t lblk,
 
1448
                 unsigned len, unsigned flags),
 
1449
 
 
1450
        TP_ARGS(inode, lblk, len, flags)
 
1451
);
 
1452
 
 
1453
DEFINE_EVENT(ext4__map_blocks_enter, ext4_ind_map_blocks_enter,
 
1454
        TP_PROTO(struct inode *inode, ext4_lblk_t lblk,
 
1455
                 unsigned len, unsigned flags),
 
1456
 
 
1457
        TP_ARGS(inode, lblk, len, flags)
 
1458
);
 
1459
 
 
1460
DECLARE_EVENT_CLASS(ext4__map_blocks_exit,
 
1461
        TP_PROTO(struct inode *inode, ext4_lblk_t lblk,
 
1462
                 ext4_fsblk_t pblk, unsigned len, int ret),
 
1463
 
 
1464
        TP_ARGS(inode, lblk, pblk, len, ret),
 
1465
 
 
1466
        TP_STRUCT__entry(
 
1467
                __field(        ino_t,          ino             )
 
1468
                __field(        dev_t,          dev             )
 
1469
                __field(        ext4_lblk_t,    lblk            )
 
1470
                __field(        ext4_fsblk_t,   pblk            )
 
1471
                __field(        unsigned,       len             )
 
1472
                __field(        int,            ret             )
 
1473
        ),
 
1474
 
 
1475
        TP_fast_assign(
 
1476
                __entry->ino    = inode->i_ino;
 
1477
                __entry->dev    = inode->i_sb->s_dev;
 
1478
                __entry->lblk   = lblk;
 
1479
                __entry->pblk   = pblk;
 
1480
                __entry->len    = len;
 
1481
                __entry->ret    = ret;
 
1482
        ),
 
1483
 
 
1484
        TP_printk("dev %d,%d ino %lu lblk %u pblk %llu len %u ret %d",
 
1485
                  MAJOR(__entry->dev), MINOR(__entry->dev),
 
1486
                  (unsigned long) __entry->ino,
 
1487
                  (unsigned) __entry->lblk, (unsigned long long) __entry->pblk,
 
1488
                  __entry->len, __entry->ret)
 
1489
);
 
1490
 
 
1491
DEFINE_EVENT(ext4__map_blocks_exit, ext4_ext_map_blocks_exit,
 
1492
        TP_PROTO(struct inode *inode, ext4_lblk_t lblk,
 
1493
                 ext4_fsblk_t pblk, unsigned len, int ret),
 
1494
 
 
1495
        TP_ARGS(inode, lblk, pblk, len, ret)
 
1496
);
 
1497
 
 
1498
DEFINE_EVENT(ext4__map_blocks_exit, ext4_ind_map_blocks_exit,
 
1499
        TP_PROTO(struct inode *inode, ext4_lblk_t lblk,
 
1500
                 ext4_fsblk_t pblk, unsigned len, int ret),
 
1501
 
 
1502
        TP_ARGS(inode, lblk, pblk, len, ret)
 
1503
);
 
1504
 
 
1505
TRACE_EVENT(ext4_ext_load_extent,
 
1506
        TP_PROTO(struct inode *inode, ext4_lblk_t lblk, ext4_fsblk_t pblk),
 
1507
 
 
1508
        TP_ARGS(inode, lblk, pblk),
 
1509
 
 
1510
        TP_STRUCT__entry(
 
1511
                __field(        ino_t,          ino             )
 
1512
                __field(        dev_t,          dev             )
 
1513
                __field(        ext4_lblk_t,    lblk            )
 
1514
                __field(        ext4_fsblk_t,   pblk            )
 
1515
        ),
 
1516
 
 
1517
        TP_fast_assign(
 
1518
                __entry->ino    = inode->i_ino;
 
1519
                __entry->dev    = inode->i_sb->s_dev;
 
1520
                __entry->lblk   = lblk;
 
1521
                __entry->pblk   = pblk;
 
1522
        ),
 
1523
 
 
1524
        TP_printk("dev %d,%d ino %lu lblk %u pblk %llu",
 
1525
                  MAJOR(__entry->dev), MINOR(__entry->dev),
 
1526
                  (unsigned long) __entry->ino,
 
1527
                  (unsigned) __entry->lblk, (unsigned long long) __entry->pblk)
 
1528
);
 
1529
 
 
1530
TRACE_EVENT(ext4_load_inode,
 
1531
        TP_PROTO(struct inode *inode),
 
1532
 
 
1533
        TP_ARGS(inode),
 
1534
 
 
1535
        TP_STRUCT__entry(
 
1536
                __field(        ino_t,  ino             )
 
1537
                __field(        dev_t,  dev             )
 
1538
        ),
 
1539
 
 
1540
        TP_fast_assign(
 
1541
                __entry->ino            = inode->i_ino;
 
1542
                __entry->dev            = inode->i_sb->s_dev;
 
1543
        ),
 
1544
 
 
1545
        TP_printk("dev %d,%d ino %ld",
 
1546
                  MAJOR(__entry->dev), MINOR(__entry->dev),
 
1547
                  (unsigned long) __entry->ino)
 
1548
);
 
1549
 
1169
1550
#endif /* _TRACE_EXT4_H */
1170
1551
 
1171
1552
/* This part must be outside protection */