← 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/btrfs.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/btrfs.h
 
1
#undef TRACE_SYSTEM
 
2
#define TRACE_SYSTEM btrfs
 
3
 
 
4
#if !defined(_TRACE_BTRFS_H) || defined(TRACE_HEADER_MULTI_READ)
 
5
#define _TRACE_BTRFS_H
 
6
 
 
7
#include <linux/writeback.h>
 
8
#include <linux/tracepoint.h>
 
9
 
 
10
struct btrfs_root;
 
11
struct btrfs_fs_info;
 
12
struct btrfs_inode;
 
13
struct extent_map;
 
14
struct btrfs_ordered_extent;
 
15
struct btrfs_delayed_ref_node;
 
16
struct btrfs_delayed_tree_ref;
 
17
struct btrfs_delayed_data_ref;
 
18
struct btrfs_delayed_ref_head;
 
19
struct map_lookup;
 
20
struct extent_buffer;
 
21
 
 
22
#define show_ref_type(type)                                             \
 
23
        __print_symbolic(type,                                          \
 
24
                { BTRFS_TREE_BLOCK_REF_KEY,     "TREE_BLOCK_REF" },     \
 
25
                { BTRFS_EXTENT_DATA_REF_KEY,    "EXTENT_DATA_REF" },    \
 
26
                { BTRFS_EXTENT_REF_V0_KEY,      "EXTENT_REF_V0" },      \
 
27
                { BTRFS_SHARED_BLOCK_REF_KEY,   "SHARED_BLOCK_REF" },   \
 
28
                { BTRFS_SHARED_DATA_REF_KEY,    "SHARED_DATA_REF" })
 
29
 
 
30
#define __show_root_type(obj)                                           \
 
31
        __print_symbolic(obj,                                           \
 
32
                { BTRFS_ROOT_TREE_OBJECTID,     "ROOT_TREE"     },      \
 
33
                { BTRFS_EXTENT_TREE_OBJECTID,   "EXTENT_TREE"   },      \
 
34
                { BTRFS_CHUNK_TREE_OBJECTID,    "CHUNK_TREE"    },      \
 
35
                { BTRFS_DEV_TREE_OBJECTID,      "DEV_TREE"      },      \
 
36
                { BTRFS_FS_TREE_OBJECTID,       "FS_TREE"       },      \
 
37
                { BTRFS_ROOT_TREE_DIR_OBJECTID, "ROOT_TREE_DIR" },      \
 
38
                { BTRFS_CSUM_TREE_OBJECTID,     "CSUM_TREE"     },      \
 
39
                { BTRFS_TREE_LOG_OBJECTID,      "TREE_LOG"      },      \
 
40
                { BTRFS_TREE_RELOC_OBJECTID,    "TREE_RELOC"    },      \
 
41
                { BTRFS_DATA_RELOC_TREE_OBJECTID, "DATA_RELOC_TREE" })
 
42
 
 
43
#define show_root_type(obj)                                             \
 
44
        obj, ((obj >= BTRFS_DATA_RELOC_TREE_OBJECTID) ||                \
 
45
              (obj <= BTRFS_CSUM_TREE_OBJECTID )) ? __show_root_type(obj) : "-"
 
46
 
 
47
TRACE_EVENT(btrfs_transaction_commit,
 
48
 
 
49
        TP_PROTO(struct btrfs_root *root),
 
50
 
 
51
        TP_ARGS(root),
 
52
 
 
53
        TP_STRUCT__entry(
 
54
                __field(        u64,  generation                )
 
55
                __field(        u64,  root_objectid             )
 
56
        ),
 
57
 
 
58
        TP_fast_assign(
 
59
                __entry->generation     = root->fs_info->generation;
 
60
                __entry->root_objectid  = root->root_key.objectid;
 
61
        ),
 
62
 
 
63
        TP_printk("root = %llu(%s), gen = %llu",
 
64
                  show_root_type(__entry->root_objectid),
 
65
                  (unsigned long long)__entry->generation)
 
66
);
 
67
 
 
68
DECLARE_EVENT_CLASS(btrfs__inode,
 
69
 
 
70
        TP_PROTO(struct inode *inode),
 
71
 
 
72
        TP_ARGS(inode),
 
73
 
 
74
        TP_STRUCT__entry(
 
75
                __field(        ino_t,  ino                     )
 
76
                __field(        blkcnt_t,  blocks               )
 
77
                __field(        u64,  disk_i_size               )
 
78
                __field(        u64,  generation                )
 
79
                __field(        u64,  last_trans                )
 
80
                __field(        u64,  logged_trans              )
 
81
                __field(        u64,  root_objectid             )
 
82
        ),
 
83
 
 
84
        TP_fast_assign(
 
85
                __entry->ino    = inode->i_ino;
 
86
                __entry->blocks = inode->i_blocks;
 
87
                __entry->disk_i_size  = BTRFS_I(inode)->disk_i_size;
 
88
                __entry->generation = BTRFS_I(inode)->generation;
 
89
                __entry->last_trans = BTRFS_I(inode)->last_trans;
 
90
                __entry->logged_trans = BTRFS_I(inode)->logged_trans;
 
91
                __entry->root_objectid =
 
92
                                BTRFS_I(inode)->root->root_key.objectid;
 
93
        ),
 
94
 
 
95
        TP_printk("root = %llu(%s), gen = %llu, ino = %lu, blocks = %llu, "
 
96
                  "disk_i_size = %llu, last_trans = %llu, logged_trans = %llu",
 
97
                  show_root_type(__entry->root_objectid),
 
98
                  (unsigned long long)__entry->generation,
 
99
                  (unsigned long)__entry->ino,
 
100
                  (unsigned long long)__entry->blocks,
 
101
                  (unsigned long long)__entry->disk_i_size,
 
102
                  (unsigned long long)__entry->last_trans,
 
103
                  (unsigned long long)__entry->logged_trans)
 
104
);
 
105
 
 
106
DEFINE_EVENT(btrfs__inode, btrfs_inode_new,
 
107
 
 
108
        TP_PROTO(struct inode *inode),
 
109
 
 
110
        TP_ARGS(inode)
 
111
);
 
112
 
 
113
DEFINE_EVENT(btrfs__inode, btrfs_inode_request,
 
114
 
 
115
        TP_PROTO(struct inode *inode),
 
116
 
 
117
        TP_ARGS(inode)
 
118
);
 
119
 
 
120
DEFINE_EVENT(btrfs__inode, btrfs_inode_evict,
 
121
 
 
122
        TP_PROTO(struct inode *inode),
 
123
 
 
124
        TP_ARGS(inode)
 
125
);
 
126
 
 
127
#define __show_map_type(type)                                           \
 
128
        __print_symbolic(type,                                          \
 
129
                { EXTENT_MAP_LAST_BYTE, "LAST_BYTE"     },              \
 
130
                { EXTENT_MAP_HOLE,      "HOLE"          },              \
 
131
                { EXTENT_MAP_INLINE,    "INLINE"        },              \
 
132
                { EXTENT_MAP_DELALLOC,  "DELALLOC"      })
 
133
 
 
134
#define show_map_type(type)                     \
 
135
        type, (type >= EXTENT_MAP_LAST_BYTE) ? "-" :  __show_map_type(type)
 
136
 
 
137
#define show_map_flags(flag)                                            \
 
138
        __print_flags(flag, "|",                                        \
 
139
                { EXTENT_FLAG_PINNED,           "PINNED"        },      \
 
140
                { EXTENT_FLAG_COMPRESSED,       "COMPRESSED"    },      \
 
141
                { EXTENT_FLAG_VACANCY,          "VACANCY"       },      \
 
142
                { EXTENT_FLAG_PREALLOC,         "PREALLOC"      })
 
143
 
 
144
TRACE_EVENT(btrfs_get_extent,
 
145
 
 
146
        TP_PROTO(struct btrfs_root *root, struct extent_map *map),
 
147
 
 
148
        TP_ARGS(root, map),
 
149
 
 
150
        TP_STRUCT__entry(
 
151
                __field(        u64,  root_objectid     )
 
152
                __field(        u64,  start             )
 
153
                __field(        u64,  len               )
 
154
                __field(        u64,  orig_start        )
 
155
                __field(        u64,  block_start       )
 
156
                __field(        u64,  block_len         )
 
157
                __field(        unsigned long,  flags   )
 
158
                __field(        int,  refs              )
 
159
                __field(        unsigned int,  compress_type    )
 
160
        ),
 
161
 
 
162
        TP_fast_assign(
 
163
                __entry->root_objectid  = root->root_key.objectid;
 
164
                __entry->start          = map->start;
 
165
                __entry->len            = map->len;
 
166
                __entry->orig_start     = map->orig_start;
 
167
                __entry->block_start    = map->block_start;
 
168
                __entry->block_len      = map->block_len;
 
169
                __entry->flags          = map->flags;
 
170
                __entry->refs           = atomic_read(&map->refs);
 
171
                __entry->compress_type  = map->compress_type;
 
172
        ),
 
173
 
 
174
        TP_printk("root = %llu(%s), start = %llu, len = %llu, "
 
175
                  "orig_start = %llu, block_start = %llu(%s), "
 
176
                  "block_len = %llu, flags = %s, refs = %u, "
 
177
                  "compress_type = %u",
 
178
                  show_root_type(__entry->root_objectid),
 
179
                  (unsigned long long)__entry->start,
 
180
                  (unsigned long long)__entry->len,
 
181
                  (unsigned long long)__entry->orig_start,
 
182
                  show_map_type(__entry->block_start),
 
183
                  (unsigned long long)__entry->block_len,
 
184
                  show_map_flags(__entry->flags),
 
185
                  __entry->refs, __entry->compress_type)
 
186
);
 
187
 
 
188
#define show_ordered_flags(flags)                                       \
 
189
        __print_symbolic(flags,                                 \
 
190
                { BTRFS_ORDERED_IO_DONE,        "IO_DONE"       },      \
 
191
                { BTRFS_ORDERED_COMPLETE,       "COMPLETE"      },      \
 
192
                { BTRFS_ORDERED_NOCOW,          "NOCOW"         },      \
 
193
                { BTRFS_ORDERED_COMPRESSED,     "COMPRESSED"    },      \
 
194
                { BTRFS_ORDERED_PREALLOC,       "PREALLOC"      },      \
 
195
                { BTRFS_ORDERED_DIRECT,         "DIRECT"        })
 
196
 
 
197
DECLARE_EVENT_CLASS(btrfs__ordered_extent,
 
198
 
 
199
        TP_PROTO(struct inode *inode, struct btrfs_ordered_extent *ordered),
 
200
 
 
201
        TP_ARGS(inode, ordered),
 
202
 
 
203
        TP_STRUCT__entry(
 
204
                __field(        ino_t,  ino             )
 
205
                __field(        u64,  file_offset       )
 
206
                __field(        u64,  start             )
 
207
                __field(        u64,  len               )
 
208
                __field(        u64,  disk_len          )
 
209
                __field(        u64,  bytes_left        )
 
210
                __field(        unsigned long,  flags   )
 
211
                __field(        int,  compress_type     )
 
212
                __field(        int,  refs              )
 
213
                __field(        u64,  root_objectid     )
 
214
        ),
 
215
 
 
216
        TP_fast_assign(
 
217
                __entry->ino            = inode->i_ino;
 
218
                __entry->file_offset    = ordered->file_offset;
 
219
                __entry->start          = ordered->start;
 
220
                __entry->len            = ordered->len;
 
221
                __entry->disk_len       = ordered->disk_len;
 
222
                __entry->bytes_left     = ordered->bytes_left;
 
223
                __entry->flags          = ordered->flags;
 
224
                __entry->compress_type  = ordered->compress_type;
 
225
                __entry->refs           = atomic_read(&ordered->refs);
 
226
                __entry->root_objectid  =
 
227
                                BTRFS_I(inode)->root->root_key.objectid;
 
228
        ),
 
229
 
 
230
        TP_printk("root = %llu(%s), ino = %llu, file_offset = %llu, "
 
231
                  "start = %llu, len = %llu, disk_len = %llu, "
 
232
                  "bytes_left = %llu, flags = %s, compress_type = %d, "
 
233
                  "refs = %d",
 
234
                  show_root_type(__entry->root_objectid),
 
235
                  (unsigned long long)__entry->ino,
 
236
                  (unsigned long long)__entry->file_offset,
 
237
                  (unsigned long long)__entry->start,
 
238
                  (unsigned long long)__entry->len,
 
239
                  (unsigned long long)__entry->disk_len,
 
240
                  (unsigned long long)__entry->bytes_left,
 
241
                  show_ordered_flags(__entry->flags),
 
242
                  __entry->compress_type, __entry->refs)
 
243
);
 
244
 
 
245
DEFINE_EVENT(btrfs__ordered_extent, btrfs_ordered_extent_add,
 
246
 
 
247
        TP_PROTO(struct inode *inode, struct btrfs_ordered_extent *ordered),
 
248
 
 
249
        TP_ARGS(inode, ordered)
 
250
);
 
251
 
 
252
DEFINE_EVENT(btrfs__ordered_extent, btrfs_ordered_extent_remove,
 
253
 
 
254
        TP_PROTO(struct inode *inode, struct btrfs_ordered_extent *ordered),
 
255
 
 
256
        TP_ARGS(inode, ordered)
 
257
);
 
258
 
 
259
DEFINE_EVENT(btrfs__ordered_extent, btrfs_ordered_extent_start,
 
260
 
 
261
        TP_PROTO(struct inode *inode, struct btrfs_ordered_extent *ordered),
 
262
 
 
263
        TP_ARGS(inode, ordered)
 
264
);
 
265
 
 
266
DEFINE_EVENT(btrfs__ordered_extent, btrfs_ordered_extent_put,
 
267
 
 
268
        TP_PROTO(struct inode *inode, struct btrfs_ordered_extent *ordered),
 
269
 
 
270
        TP_ARGS(inode, ordered)
 
271
);
 
272
 
 
273
DECLARE_EVENT_CLASS(btrfs__writepage,
 
274
 
 
275
        TP_PROTO(struct page *page, struct inode *inode,
 
276
                 struct writeback_control *wbc),
 
277
 
 
278
        TP_ARGS(page, inode, wbc),
 
279
 
 
280
        TP_STRUCT__entry(
 
281
                __field(        ino_t,  ino                     )
 
282
                __field(        pgoff_t,  index                 )
 
283
                __field(        long,   nr_to_write             )
 
284
                __field(        long,   pages_skipped           )
 
285
                __field(        loff_t, range_start             )
 
286
                __field(        loff_t, range_end               )
 
287
                __field(        char,   nonblocking             )
 
288
                __field(        char,   for_kupdate             )
 
289
                __field(        char,   for_reclaim             )
 
290
                __field(        char,   range_cyclic            )
 
291
                __field(        pgoff_t,  writeback_index       )
 
292
                __field(        u64,    root_objectid           )
 
293
        ),
 
294
 
 
295
        TP_fast_assign(
 
296
                __entry->ino            = inode->i_ino;
 
297
                __entry->index          = page->index;
 
298
                __entry->nr_to_write    = wbc->nr_to_write;
 
299
                __entry->pages_skipped  = wbc->pages_skipped;
 
300
                __entry->range_start    = wbc->range_start;
 
301
                __entry->range_end      = wbc->range_end;
 
302
                __entry->nonblocking    = wbc->nonblocking;
 
303
                __entry->for_kupdate    = wbc->for_kupdate;
 
304
                __entry->for_reclaim    = wbc->for_reclaim;
 
305
                __entry->range_cyclic   = wbc->range_cyclic;
 
306
                __entry->writeback_index = inode->i_mapping->writeback_index;
 
307
                __entry->root_objectid  =
 
308
                                 BTRFS_I(inode)->root->root_key.objectid;
 
309
        ),
 
310
 
 
311
        TP_printk("root = %llu(%s), ino = %lu, page_index = %lu, "
 
312
                  "nr_to_write = %ld, pages_skipped = %ld, range_start = %llu, "
 
313
                  "range_end = %llu, nonblocking = %d, for_kupdate = %d, "
 
314
                  "for_reclaim = %d, range_cyclic = %d, writeback_index = %lu",
 
315
                  show_root_type(__entry->root_objectid),
 
316
                  (unsigned long)__entry->ino, __entry->index,
 
317
                  __entry->nr_to_write, __entry->pages_skipped,
 
318
                  __entry->range_start, __entry->range_end,
 
319
                  __entry->nonblocking, __entry->for_kupdate,
 
320
                  __entry->for_reclaim, __entry->range_cyclic,
 
321
                  (unsigned long)__entry->writeback_index)
 
322
);
 
323
 
 
324
DEFINE_EVENT(btrfs__writepage, __extent_writepage,
 
325
 
 
326
        TP_PROTO(struct page *page, struct inode *inode,
 
327
                 struct writeback_control *wbc),
 
328
 
 
329
        TP_ARGS(page, inode, wbc)
 
330
);
 
331
 
 
332
TRACE_EVENT(btrfs_writepage_end_io_hook,
 
333
 
 
334
        TP_PROTO(struct page *page, u64 start, u64 end, int uptodate),
 
335
 
 
336
        TP_ARGS(page, start, end, uptodate),
 
337
 
 
338
        TP_STRUCT__entry(
 
339
                __field(        ino_t,   ino            )
 
340
                __field(        pgoff_t, index          )
 
341
                __field(        u64,     start          )
 
342
                __field(        u64,     end            )
 
343
                __field(        int,     uptodate       )
 
344
                __field(        u64,    root_objectid   )
 
345
        ),
 
346
 
 
347
        TP_fast_assign(
 
348
                __entry->ino    = page->mapping->host->i_ino;
 
349
                __entry->index  = page->index;
 
350
                __entry->start  = start;
 
351
                __entry->end    = end;
 
352
                __entry->uptodate = uptodate;
 
353
                __entry->root_objectid  =
 
354
                         BTRFS_I(page->mapping->host)->root->root_key.objectid;
 
355
        ),
 
356
 
 
357
        TP_printk("root = %llu(%s), ino = %lu, page_index = %lu, start = %llu, "
 
358
                  "end = %llu, uptodate = %d",
 
359
                  show_root_type(__entry->root_objectid),
 
360
                  (unsigned long)__entry->ino, (unsigned long)__entry->index,
 
361
                  (unsigned long long)__entry->start,
 
362
                  (unsigned long long)__entry->end, __entry->uptodate)
 
363
);
 
364
 
 
365
TRACE_EVENT(btrfs_sync_file,
 
366
 
 
367
        TP_PROTO(struct file *file, int datasync),
 
368
 
 
369
        TP_ARGS(file, datasync),
 
370
 
 
371
        TP_STRUCT__entry(
 
372
                __field(        ino_t,  ino             )
 
373
                __field(        ino_t,  parent          )
 
374
                __field(        int,    datasync        )
 
375
                __field(        u64,    root_objectid   )
 
376
        ),
 
377
 
 
378
        TP_fast_assign(
 
379
                struct dentry *dentry = file->f_path.dentry;
 
380
                struct inode *inode = dentry->d_inode;
 
381
 
 
382
                __entry->ino            = inode->i_ino;
 
383
                __entry->parent         = dentry->d_parent->d_inode->i_ino;
 
384
                __entry->datasync       = datasync;
 
385
                __entry->root_objectid  =
 
386
                                 BTRFS_I(inode)->root->root_key.objectid;
 
387
        ),
 
388
 
 
389
        TP_printk("root = %llu(%s), ino = %ld, parent = %ld, datasync = %d",
 
390
                  show_root_type(__entry->root_objectid),
 
391
                  (unsigned long)__entry->ino, (unsigned long)__entry->parent,
 
392
                  __entry->datasync)
 
393
);
 
394
 
 
395
TRACE_EVENT(btrfs_sync_fs,
 
396
 
 
397
        TP_PROTO(int wait),
 
398
 
 
399
        TP_ARGS(wait),
 
400
 
 
401
        TP_STRUCT__entry(
 
402
                __field(        int,  wait              )
 
403
        ),
 
404
 
 
405
        TP_fast_assign(
 
406
                __entry->wait   = wait;
 
407
        ),
 
408
 
 
409
        TP_printk("wait = %d", __entry->wait)
 
410
);
 
411
 
 
412
#define show_ref_action(action)                                         \
 
413
        __print_symbolic(action,                                        \
 
414
                { BTRFS_ADD_DELAYED_REF,    "ADD_DELAYED_REF" },        \
 
415
                { BTRFS_DROP_DELAYED_REF,   "DROP_DELAYED_REF" },       \
 
416
                { BTRFS_ADD_DELAYED_EXTENT, "ADD_DELAYED_EXTENT" },     \
 
417
                { BTRFS_UPDATE_DELAYED_HEAD, "UPDATE_DELAYED_HEAD" })
 
418
                        
 
419
 
 
420
TRACE_EVENT(btrfs_delayed_tree_ref,
 
421
 
 
422
        TP_PROTO(struct btrfs_delayed_ref_node *ref,
 
423
                 struct btrfs_delayed_tree_ref *full_ref,
 
424
                 int action),
 
425
 
 
426
        TP_ARGS(ref, full_ref, action),
 
427
 
 
428
        TP_STRUCT__entry(
 
429
                __field(        u64,  bytenr            )
 
430
                __field(        u64,  num_bytes         )
 
431
                __field(        int,  action            ) 
 
432
                __field(        u64,  parent            )
 
433
                __field(        u64,  ref_root          )
 
434
                __field(        int,  level             )
 
435
                __field(        int,  type              )
 
436
        ),
 
437
 
 
438
        TP_fast_assign(
 
439
                __entry->bytenr         = ref->bytenr;
 
440
                __entry->num_bytes      = ref->num_bytes;
 
441
                __entry->action         = action;
 
442
                __entry->parent         = full_ref->parent;
 
443
                __entry->ref_root       = full_ref->root;
 
444
                __entry->level          = full_ref->level;
 
445
                __entry->type           = ref->type;
 
446
        ),
 
447
 
 
448
        TP_printk("bytenr = %llu, num_bytes = %llu, action = %s, "
 
449
                  "parent = %llu(%s), ref_root = %llu(%s), level = %d, "
 
450
                  "type = %s",
 
451
                  (unsigned long long)__entry->bytenr,
 
452
                  (unsigned long long)__entry->num_bytes,
 
453
                  show_ref_action(__entry->action),
 
454
                  show_root_type(__entry->parent),
 
455
                  show_root_type(__entry->ref_root),
 
456
                  __entry->level, show_ref_type(__entry->type))
 
457
);
 
458
 
 
459
TRACE_EVENT(btrfs_delayed_data_ref,
 
460
 
 
461
        TP_PROTO(struct btrfs_delayed_ref_node *ref,
 
462
                 struct btrfs_delayed_data_ref *full_ref,
 
463
                 int action),
 
464
 
 
465
        TP_ARGS(ref, full_ref, action),
 
466
 
 
467
        TP_STRUCT__entry(
 
468
                __field(        u64,  bytenr            )
 
469
                __field(        u64,  num_bytes         )
 
470
                __field(        int,  action            ) 
 
471
                __field(        u64,  parent            )
 
472
                __field(        u64,  ref_root          )
 
473
                __field(        u64,  owner             )
 
474
                __field(        u64,  offset            )
 
475
                __field(        int,  type              )
 
476
        ),
 
477
 
 
478
        TP_fast_assign(
 
479
                __entry->bytenr         = ref->bytenr;
 
480
                __entry->num_bytes      = ref->num_bytes;
 
481
                __entry->action         = action;
 
482
                __entry->parent         = full_ref->parent;
 
483
                __entry->ref_root       = full_ref->root;
 
484
                __entry->owner          = full_ref->objectid;
 
485
                __entry->offset         = full_ref->offset;
 
486
                __entry->type           = ref->type;
 
487
        ),
 
488
 
 
489
        TP_printk("bytenr = %llu, num_bytes = %llu, action = %s, "
 
490
                  "parent = %llu(%s), ref_root = %llu(%s), owner = %llu, "
 
491
                  "offset = %llu, type = %s",
 
492
                  (unsigned long long)__entry->bytenr,
 
493
                  (unsigned long long)__entry->num_bytes,
 
494
                  show_ref_action(__entry->action),
 
495
                  show_root_type(__entry->parent),
 
496
                  show_root_type(__entry->ref_root),
 
497
                  (unsigned long long)__entry->owner,
 
498
                  (unsigned long long)__entry->offset,
 
499
                  show_ref_type(__entry->type))
 
500
);
 
501
 
 
502
TRACE_EVENT(btrfs_delayed_ref_head,
 
503
 
 
504
        TP_PROTO(struct btrfs_delayed_ref_node *ref,
 
505
                 struct btrfs_delayed_ref_head *head_ref,
 
506
                 int action),
 
507
 
 
508
        TP_ARGS(ref, head_ref, action),
 
509
 
 
510
        TP_STRUCT__entry(
 
511
                __field(        u64,  bytenr            )
 
512
                __field(        u64,  num_bytes         )
 
513
                __field(        int,  action            ) 
 
514
                __field(        int,  is_data           )
 
515
        ),
 
516
 
 
517
        TP_fast_assign(
 
518
                __entry->bytenr         = ref->bytenr;
 
519
                __entry->num_bytes      = ref->num_bytes;
 
520
                __entry->action         = action;
 
521
                __entry->is_data        = head_ref->is_data;
 
522
        ),
 
523
 
 
524
        TP_printk("bytenr = %llu, num_bytes = %llu, action = %s, is_data = %d",
 
525
                  (unsigned long long)__entry->bytenr,
 
526
                  (unsigned long long)__entry->num_bytes,
 
527
                  show_ref_action(__entry->action),
 
528
                  __entry->is_data)
 
529
);
 
530
 
 
531
#define show_chunk_type(type)                                   \
 
532
        __print_flags(type, "|",                                \
 
533
                { BTRFS_BLOCK_GROUP_DATA,       "DATA"  },      \
 
534
                { BTRFS_BLOCK_GROUP_SYSTEM,     "SYSTEM"},      \
 
535
                { BTRFS_BLOCK_GROUP_METADATA,   "METADATA"},    \
 
536
                { BTRFS_BLOCK_GROUP_RAID0,      "RAID0" },      \
 
537
                { BTRFS_BLOCK_GROUP_RAID1,      "RAID1" },      \
 
538
                { BTRFS_BLOCK_GROUP_DUP,        "DUP"   },      \
 
539
                { BTRFS_BLOCK_GROUP_RAID10,     "RAID10"})
 
540
 
 
541
DECLARE_EVENT_CLASS(btrfs__chunk,
 
542
 
 
543
        TP_PROTO(struct btrfs_root *root, struct map_lookup *map,
 
544
                 u64 offset, u64 size),
 
545
 
 
546
        TP_ARGS(root, map, offset, size),
 
547
 
 
548
        TP_STRUCT__entry(
 
549
                __field(        int,  num_stripes               )
 
550
                __field(        u64,  type                      )
 
551
                __field(        int,  sub_stripes               )
 
552
                __field(        u64,  offset                    )
 
553
                __field(        u64,  size                      )
 
554
                __field(        u64,  root_objectid             )
 
555
        ),
 
556
 
 
557
        TP_fast_assign(
 
558
                __entry->num_stripes    = map->num_stripes;
 
559
                __entry->type           = map->type;
 
560
                __entry->sub_stripes    = map->sub_stripes;
 
561
                __entry->offset         = offset;
 
562
                __entry->size           = size;
 
563
                __entry->root_objectid  = root->root_key.objectid;
 
564
        ),
 
565
 
 
566
        TP_printk("root = %llu(%s), offset = %llu, size = %llu, "
 
567
                  "num_stripes = %d, sub_stripes = %d, type = %s",
 
568
                  show_root_type(__entry->root_objectid),
 
569
                  (unsigned long long)__entry->offset,
 
570
                  (unsigned long long)__entry->size,
 
571
                  __entry->num_stripes, __entry->sub_stripes,
 
572
                  show_chunk_type(__entry->type))
 
573
);
 
574
 
 
575
DEFINE_EVENT(btrfs__chunk,  btrfs_chunk_alloc,
 
576
 
 
577
        TP_PROTO(struct btrfs_root *root, struct map_lookup *map,
 
578
                 u64 offset, u64 size),
 
579
 
 
580
        TP_ARGS(root, map, offset, size)
 
581
);
 
582
 
 
583
DEFINE_EVENT(btrfs__chunk,  btrfs_chunk_free,
 
584
 
 
585
        TP_PROTO(struct btrfs_root *root, struct map_lookup *map,
 
586
                 u64 offset, u64 size),
 
587
 
 
588
        TP_ARGS(root, map, offset, size)
 
589
);
 
590
 
 
591
TRACE_EVENT(btrfs_cow_block,
 
592
 
 
593
        TP_PROTO(struct btrfs_root *root, struct extent_buffer *buf,
 
594
                 struct extent_buffer *cow),
 
595
 
 
596
        TP_ARGS(root, buf, cow),
 
597
 
 
598
        TP_STRUCT__entry(
 
599
                __field(        u64,  root_objectid             )
 
600
                __field(        u64,  buf_start                 )
 
601
                __field(        int,  refs                      )
 
602
                __field(        u64,  cow_start                 )
 
603
                __field(        int,  buf_level                 )
 
604
                __field(        int,  cow_level                 )
 
605
        ),
 
606
 
 
607
        TP_fast_assign(
 
608
                __entry->root_objectid  = root->root_key.objectid;
 
609
                __entry->buf_start      = buf->start;
 
610
                __entry->refs           = atomic_read(&buf->refs);
 
611
                __entry->cow_start      = cow->start;
 
612
                __entry->buf_level      = btrfs_header_level(buf);
 
613
                __entry->cow_level      = btrfs_header_level(cow);
 
614
        ),
 
615
 
 
616
        TP_printk("root = %llu(%s), refs = %d, orig_buf = %llu "
 
617
                  "(orig_level = %d), cow_buf = %llu (cow_level = %d)",
 
618
                  show_root_type(__entry->root_objectid),
 
619
                  __entry->refs,
 
620
                  (unsigned long long)__entry->buf_start,
 
621
                  __entry->buf_level,
 
622
                  (unsigned long long)__entry->cow_start,
 
623
                  __entry->cow_level)
 
624
);
 
625
 
 
626
DECLARE_EVENT_CLASS(btrfs__reserved_extent,
 
627
 
 
628
        TP_PROTO(struct btrfs_root *root, u64 start, u64 len),
 
629
 
 
630
        TP_ARGS(root, start, len),
 
631
 
 
632
        TP_STRUCT__entry(
 
633
                __field(        u64,  root_objectid             )
 
634
                __field(        u64,  start                     )
 
635
                __field(        u64,  len                       )
 
636
        ),
 
637
 
 
638
        TP_fast_assign(
 
639
                __entry->root_objectid  = root->root_key.objectid;
 
640
                __entry->start          = start;
 
641
                __entry->len            = len;
 
642
        ),
 
643
 
 
644
        TP_printk("root = %llu(%s), start = %llu, len = %llu",
 
645
                  show_root_type(__entry->root_objectid),
 
646
                  (unsigned long long)__entry->start,
 
647
                  (unsigned long long)__entry->len)
 
648
);
 
649
 
 
650
DEFINE_EVENT(btrfs__reserved_extent,  btrfs_reserved_extent_alloc,
 
651
 
 
652
        TP_PROTO(struct btrfs_root *root, u64 start, u64 len),
 
653
 
 
654
        TP_ARGS(root, start, len)
 
655
);
 
656
 
 
657
DEFINE_EVENT(btrfs__reserved_extent,  btrfs_reserved_extent_free,
 
658
 
 
659
        TP_PROTO(struct btrfs_root *root, u64 start, u64 len),
 
660
 
 
661
        TP_ARGS(root, start, len)
 
662
);
 
663
 
 
664
#endif /* _TRACE_BTRFS_H */
 
665
 
 
666
/* This part must be outside protection */
 
667
#include <trace/define_trace.h>