2 * Copyright (c) 2009, Christoph Hellwig
5 * This program is free software; you can redistribute it and/or
6 * modify it under the terms of the GNU General Public License as
7 * published by the Free Software Foundation.
9 * This program is distributed in the hope that it would be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 * GNU General Public License for more details.
14 * You should have received a copy of the GNU General Public License
15 * along with this program; if not, write the Free Software Foundation,
16 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
19 #define TRACE_SYSTEM xfs
21 #if !defined(_TRACE_XFS_H) || defined(TRACE_HEADER_MULTI_READ)
24 #include <linux/tracepoint.h>
28 struct xfs_attr_list_context
;
29 struct xfs_buf_log_item
;
31 struct xfs_da_node_entry
;
36 #define DEFINE_ATTR_LIST_EVENT(name) \
38 TP_PROTO(struct xfs_attr_list_context *ctx), \
42 __field(xfs_ino_t, ino) \
43 __field(u32, hashval) \
45 __field(u32, offset) \
46 __field(void *, alist) \
47 __field(int, bufsize) \
49 __field(int, firstu) \
50 __field(int, dupcnt) \
54 __entry->dev = VFS_I(ctx->dp)->i_sb->s_dev; \
55 __entry->ino = ctx->dp->i_ino; \
56 __entry->hashval = ctx->cursor->hashval; \
57 __entry->blkno = ctx->cursor->blkno; \
58 __entry->offset = ctx->cursor->offset; \
59 __entry->alist = ctx->alist; \
60 __entry->bufsize = ctx->bufsize; \
61 __entry->count = ctx->count; \
62 __entry->firstu = ctx->firstu; \
63 __entry->flags = ctx->flags; \
65 TP_printk("dev %d:%d ino 0x%llx cursor h/b/o 0x%x/0x%x/%u dupcnt %u " \
66 "alist 0x%p size %u count %u firstu %u flags %d %s", \
67 MAJOR(__entry->dev), MINOR(__entry->dev), \
78 __print_flags(__entry->flags, "|", XFS_ATTR_FLAGS) \
81 DEFINE_ATTR_LIST_EVENT(xfs_attr_list_sf
);
82 DEFINE_ATTR_LIST_EVENT(xfs_attr_list_sf_all
);
83 DEFINE_ATTR_LIST_EVENT(xfs_attr_list_leaf
);
84 DEFINE_ATTR_LIST_EVENT(xfs_attr_list_leaf_end
);
85 DEFINE_ATTR_LIST_EVENT(xfs_attr_list_full
);
86 DEFINE_ATTR_LIST_EVENT(xfs_attr_list_add
);
87 DEFINE_ATTR_LIST_EVENT(xfs_attr_list_wrong_blk
);
88 DEFINE_ATTR_LIST_EVENT(xfs_attr_list_notfound
);
90 TRACE_EVENT(xfs_attr_list_node_descend
,
91 TP_PROTO(struct xfs_attr_list_context
*ctx
,
92 struct xfs_da_node_entry
*btree
),
96 __field(xfs_ino_t
, ino
)
100 __field(void *, alist
)
101 __field(int, bufsize
)
106 __field(u32
, bt_hashval
)
107 __field(u32
, bt_before
)
110 __entry
->dev
= VFS_I(ctx
->dp
)->i_sb
->s_dev
;
111 __entry
->ino
= ctx
->dp
->i_ino
;
112 __entry
->hashval
= ctx
->cursor
->hashval
;
113 __entry
->blkno
= ctx
->cursor
->blkno
;
114 __entry
->offset
= ctx
->cursor
->offset
;
115 __entry
->alist
= ctx
->alist
;
116 __entry
->bufsize
= ctx
->bufsize
;
117 __entry
->count
= ctx
->count
;
118 __entry
->firstu
= ctx
->firstu
;
119 __entry
->flags
= ctx
->flags
;
120 __entry
->bt_hashval
= be32_to_cpu(btree
->hashval
);
121 __entry
->bt_before
= be32_to_cpu(btree
->before
);
123 TP_printk("dev %d:%d ino 0x%llx cursor h/b/o 0x%x/0x%x/%u dupcnt %u "
124 "alist 0x%p size %u count %u firstu %u flags %d %s "
125 "node hashval %u, node before %u",
126 MAJOR(__entry
->dev
), MINOR(__entry
->dev
),
137 __print_flags(__entry
->flags
, "|", XFS_ATTR_FLAGS
),
142 TRACE_EVENT(xfs_iext_insert
,
143 TP_PROTO(struct xfs_inode
*ip
, xfs_extnum_t idx
,
144 struct xfs_bmbt_irec
*r
, int state
, unsigned long caller_ip
),
145 TP_ARGS(ip
, idx
, r
, state
, caller_ip
),
148 __field(xfs_ino_t
, ino
)
149 __field(xfs_extnum_t
, idx
)
150 __field(xfs_fileoff_t
, startoff
)
151 __field(xfs_fsblock_t
, startblock
)
152 __field(xfs_filblks_t
, blockcount
)
153 __field(xfs_exntst_t
, state
)
154 __field(int, bmap_state
)
155 __field(unsigned long, caller_ip
)
158 __entry
->dev
= VFS_I(ip
)->i_sb
->s_dev
;
159 __entry
->ino
= ip
->i_ino
;
161 __entry
->startoff
= r
->br_startoff
;
162 __entry
->startblock
= r
->br_startblock
;
163 __entry
->blockcount
= r
->br_blockcount
;
164 __entry
->state
= r
->br_state
;
165 __entry
->bmap_state
= state
;
166 __entry
->caller_ip
= caller_ip
;
168 TP_printk("dev %d:%d ino 0x%llx state %s idx %ld "
169 "offset %lld block %s count %lld flag %d caller %pf",
170 MAJOR(__entry
->dev
), MINOR(__entry
->dev
),
172 __print_flags(__entry
->bmap_state
, "|", XFS_BMAP_EXT_FLAGS
),
175 xfs_fmtfsblock(__entry
->startblock
),
178 (char *)__entry
->caller_ip
)
181 #define DEFINE_BMAP_EVENT(name) \
183 TP_PROTO(struct xfs_inode *ip, xfs_extnum_t idx, int state, \
184 unsigned long caller_ip), \
185 TP_ARGS(ip, idx, state, caller_ip), \
187 __field(dev_t, dev) \
188 __field(xfs_ino_t, ino) \
189 __field(xfs_extnum_t, idx) \
190 __field(xfs_fileoff_t, startoff) \
191 __field(xfs_fsblock_t, startblock) \
192 __field(xfs_filblks_t, blockcount) \
193 __field(xfs_exntst_t, state) \
194 __field(int, bmap_state) \
195 __field(unsigned long, caller_ip) \
198 struct xfs_ifork *ifp = (state & BMAP_ATTRFORK) ? \
199 ip->i_afp : &ip->i_df; \
200 struct xfs_bmbt_irec r; \
202 xfs_bmbt_get_all(xfs_iext_get_ext(ifp, idx), &r); \
203 __entry->dev = VFS_I(ip)->i_sb->s_dev; \
204 __entry->ino = ip->i_ino; \
205 __entry->idx = idx; \
206 __entry->startoff = r.br_startoff; \
207 __entry->startblock = r.br_startblock; \
208 __entry->blockcount = r.br_blockcount; \
209 __entry->state = r.br_state; \
210 __entry->bmap_state = state; \
211 __entry->caller_ip = caller_ip; \
213 TP_printk("dev %d:%d ino 0x%llx state %s idx %ld " \
214 "offset %lld block %s count %lld flag %d caller %pf", \
215 MAJOR(__entry->dev), MINOR(__entry->dev), \
217 __print_flags(__entry->bmap_state, "|", XFS_BMAP_EXT_FLAGS), \
218 (long)__entry->idx, \
220 xfs_fmtfsblock(__entry->startblock), \
221 __entry->blockcount, \
223 (char *)__entry->caller_ip) \
226 DEFINE_BMAP_EVENT(xfs_iext_remove
);
227 DEFINE_BMAP_EVENT(xfs_bmap_pre_update
);
228 DEFINE_BMAP_EVENT(xfs_bmap_post_update
);
229 DEFINE_BMAP_EVENT(xfs_extlist
);
231 #define DEFINE_BUF_EVENT(tname) \
233 TP_PROTO(struct xfs_buf *bp, unsigned long caller_ip), \
234 TP_ARGS(bp, caller_ip), \
236 __field(dev_t, dev) \
237 __field(xfs_daddr_t, bno) \
238 __field(size_t, buffer_length) \
240 __field(int, pincount) \
241 __field(unsigned, lockval) \
242 __field(unsigned, flags) \
243 __field(unsigned long, caller_ip) \
246 __entry->dev = bp->b_target->bt_dev; \
247 __entry->bno = bp->b_bn; \
248 __entry->buffer_length = bp->b_buffer_length; \
249 __entry->hold = atomic_read(&bp->b_hold); \
250 __entry->pincount = atomic_read(&bp->b_pin_count); \
251 __entry->lockval = xfs_buf_lock_value(bp); \
252 __entry->flags = bp->b_flags; \
253 __entry->caller_ip = caller_ip; \
255 TP_printk("dev %d:%d bno 0x%llx len 0x%zx hold %d pincount %d " \
256 "lock %d flags %s caller %pf", \
257 MAJOR(__entry->dev), MINOR(__entry->dev), \
258 (unsigned long long)__entry->bno, \
259 __entry->buffer_length, \
263 __print_flags(__entry->flags, "|", XFS_BUF_FLAGS), \
264 (void *)__entry->caller_ip) \
266 DEFINE_BUF_EVENT(xfs_buf_init
);
267 DEFINE_BUF_EVENT(xfs_buf_free
);
268 DEFINE_BUF_EVENT(xfs_buf_hold
);
269 DEFINE_BUF_EVENT(xfs_buf_rele
);
270 DEFINE_BUF_EVENT(xfs_buf_pin
);
271 DEFINE_BUF_EVENT(xfs_buf_unpin
);
272 DEFINE_BUF_EVENT(xfs_buf_iodone
);
273 DEFINE_BUF_EVENT(xfs_buf_iorequest
);
274 DEFINE_BUF_EVENT(xfs_buf_bawrite
);
275 DEFINE_BUF_EVENT(xfs_buf_bdwrite
);
276 DEFINE_BUF_EVENT(xfs_buf_lock
);
277 DEFINE_BUF_EVENT(xfs_buf_lock_done
);
278 DEFINE_BUF_EVENT(xfs_buf_cond_lock
);
279 DEFINE_BUF_EVENT(xfs_buf_unlock
);
280 DEFINE_BUF_EVENT(xfs_buf_ordered_retry
);
281 DEFINE_BUF_EVENT(xfs_buf_iowait
);
282 DEFINE_BUF_EVENT(xfs_buf_iowait_done
);
283 DEFINE_BUF_EVENT(xfs_buf_delwri_queue
);
284 DEFINE_BUF_EVENT(xfs_buf_delwri_dequeue
);
285 DEFINE_BUF_EVENT(xfs_buf_delwri_split
);
286 DEFINE_BUF_EVENT(xfs_buf_get_noaddr
);
287 DEFINE_BUF_EVENT(xfs_bdstrat_shut
);
288 DEFINE_BUF_EVENT(xfs_buf_item_relse
);
289 DEFINE_BUF_EVENT(xfs_buf_item_iodone
);
290 DEFINE_BUF_EVENT(xfs_buf_item_iodone_async
);
291 DEFINE_BUF_EVENT(xfs_buf_error_relse
);
292 DEFINE_BUF_EVENT(xfs_trans_read_buf_io
);
293 DEFINE_BUF_EVENT(xfs_trans_read_buf_shut
);
295 /* not really buffer traces, but the buf provides useful information */
296 DEFINE_BUF_EVENT(xfs_btree_corrupt
);
297 DEFINE_BUF_EVENT(xfs_da_btree_corrupt
);
298 DEFINE_BUF_EVENT(xfs_reset_dqcounts
);
299 DEFINE_BUF_EVENT(xfs_inode_item_push
);
301 /* pass flags explicitly */
302 #define DEFINE_BUF_FLAGS_EVENT(tname) \
304 TP_PROTO(struct xfs_buf *bp, unsigned flags, unsigned long caller_ip), \
305 TP_ARGS(bp, flags, caller_ip), \
307 __field(dev_t, dev) \
308 __field(xfs_daddr_t, bno) \
309 __field(size_t, buffer_length) \
311 __field(int, pincount) \
312 __field(unsigned, lockval) \
313 __field(unsigned, flags) \
314 __field(unsigned long, caller_ip) \
317 __entry->dev = bp->b_target->bt_dev; \
318 __entry->bno = bp->b_bn; \
319 __entry->buffer_length = bp->b_buffer_length; \
320 __entry->flags = flags; \
321 __entry->hold = atomic_read(&bp->b_hold); \
322 __entry->pincount = atomic_read(&bp->b_pin_count); \
323 __entry->lockval = xfs_buf_lock_value(bp); \
324 __entry->caller_ip = caller_ip; \
326 TP_printk("dev %d:%d bno 0x%llx len 0x%zx hold %d pincount %d " \
327 "lock %d flags %s caller %pf", \
328 MAJOR(__entry->dev), MINOR(__entry->dev), \
329 (unsigned long long)__entry->bno, \
330 __entry->buffer_length, \
334 __print_flags(__entry->flags, "|", XFS_BUF_FLAGS), \
335 (void *)__entry->caller_ip) \
337 DEFINE_BUF_FLAGS_EVENT(xfs_buf_find
);
338 DEFINE_BUF_FLAGS_EVENT(xfs_buf_get
);
339 DEFINE_BUF_FLAGS_EVENT(xfs_buf_read
);
341 TRACE_EVENT(xfs_buf_ioerror
,
342 TP_PROTO(struct xfs_buf
*bp
, int error
, unsigned long caller_ip
),
343 TP_ARGS(bp
, error
, caller_ip
),
346 __field(xfs_daddr_t
, bno
)
347 __field(size_t, buffer_length
)
348 __field(unsigned, flags
)
350 __field(int, pincount
)
351 __field(unsigned, lockval
)
353 __field(unsigned long, caller_ip
)
356 __entry
->dev
= bp
->b_target
->bt_dev
;
357 __entry
->bno
= bp
->b_bn
;
358 __entry
->buffer_length
= bp
->b_buffer_length
;
359 __entry
->hold
= atomic_read(&bp
->b_hold
);
360 __entry
->pincount
= atomic_read(&bp
->b_pin_count
);
361 __entry
->lockval
= xfs_buf_lock_value(bp
);
362 __entry
->error
= error
;
363 __entry
->flags
= bp
->b_flags
;
364 __entry
->caller_ip
= caller_ip
;
366 TP_printk("dev %d:%d bno 0x%llx len 0x%zx hold %d pincount %d "
367 "lock %d error %d flags %s caller %pf",
368 MAJOR(__entry
->dev
), MINOR(__entry
->dev
),
369 (unsigned long long)__entry
->bno
,
370 __entry
->buffer_length
,
375 __print_flags(__entry
->flags
, "|", XFS_BUF_FLAGS
),
376 (void *)__entry
->caller_ip
)
379 #define DEFINE_BUF_ITEM_EVENT(tname) \
381 TP_PROTO(struct xfs_buf_log_item *bip), \
384 __field(dev_t, dev) \
385 __field(xfs_daddr_t, buf_bno) \
386 __field(size_t, buf_len) \
387 __field(int, buf_hold) \
388 __field(int, buf_pincount) \
389 __field(int, buf_lockval) \
390 __field(unsigned, buf_flags) \
391 __field(unsigned, bli_recur) \
392 __field(int, bli_refcount) \
393 __field(unsigned, bli_flags) \
394 __field(void *, li_desc) \
395 __field(unsigned, li_flags) \
398 __entry->dev = bip->bli_buf->b_target->bt_dev; \
399 __entry->bli_flags = bip->bli_flags; \
400 __entry->bli_recur = bip->bli_recur; \
401 __entry->bli_refcount = atomic_read(&bip->bli_refcount); \
402 __entry->buf_bno = bip->bli_buf->b_bn; \
403 __entry->buf_len = bip->bli_buf->b_buffer_length; \
404 __entry->buf_flags = bip->bli_buf->b_flags; \
405 __entry->buf_hold = atomic_read(&bip->bli_buf->b_hold); \
406 __entry->buf_pincount = \
407 atomic_read(&bip->bli_buf->b_pin_count); \
408 __entry->buf_lockval = xfs_buf_lock_value(bip->bli_buf); \
409 __entry->li_desc = bip->bli_item.li_desc; \
410 __entry->li_flags = bip->bli_item.li_flags; \
412 TP_printk("dev %d:%d bno 0x%llx len 0x%zx hold %d pincount %d " \
413 "lock %d flags %s recur %d refcount %d bliflags %s " \
414 "lidesc 0x%p liflags %s", \
415 MAJOR(__entry->dev), MINOR(__entry->dev), \
416 (unsigned long long)__entry->buf_bno, \
419 __entry->buf_pincount, \
420 __entry->buf_lockval, \
421 __print_flags(__entry->buf_flags, "|", XFS_BUF_FLAGS), \
422 __entry->bli_recur, \
423 __entry->bli_refcount, \
424 __print_flags(__entry->bli_flags, "|", XFS_BLI_FLAGS), \
426 __print_flags(__entry->li_flags, "|", XFS_LI_FLAGS)) \
428 DEFINE_BUF_ITEM_EVENT(xfs_buf_item_size
);
429 DEFINE_BUF_ITEM_EVENT(xfs_buf_item_size_stale
);
430 DEFINE_BUF_ITEM_EVENT(xfs_buf_item_format
);
431 DEFINE_BUF_ITEM_EVENT(xfs_buf_item_format_stale
);
432 DEFINE_BUF_ITEM_EVENT(xfs_buf_item_pin
);
433 DEFINE_BUF_ITEM_EVENT(xfs_buf_item_unpin
);
434 DEFINE_BUF_ITEM_EVENT(xfs_buf_item_unpin_stale
);
435 DEFINE_BUF_ITEM_EVENT(xfs_buf_item_trylock
);
436 DEFINE_BUF_ITEM_EVENT(xfs_buf_item_unlock
);
437 DEFINE_BUF_ITEM_EVENT(xfs_buf_item_unlock_stale
);
438 DEFINE_BUF_ITEM_EVENT(xfs_buf_item_committed
);
439 DEFINE_BUF_ITEM_EVENT(xfs_buf_item_push
);
440 DEFINE_BUF_ITEM_EVENT(xfs_trans_get_buf
);
441 DEFINE_BUF_ITEM_EVENT(xfs_trans_get_buf_recur
);
442 DEFINE_BUF_ITEM_EVENT(xfs_trans_getsb
);
443 DEFINE_BUF_ITEM_EVENT(xfs_trans_getsb_recur
);
444 DEFINE_BUF_ITEM_EVENT(xfs_trans_read_buf
);
445 DEFINE_BUF_ITEM_EVENT(xfs_trans_read_buf_recur
);
446 DEFINE_BUF_ITEM_EVENT(xfs_trans_log_buf
);
447 DEFINE_BUF_ITEM_EVENT(xfs_trans_brelse
);
448 DEFINE_BUF_ITEM_EVENT(xfs_trans_bjoin
);
449 DEFINE_BUF_ITEM_EVENT(xfs_trans_bhold
);
450 DEFINE_BUF_ITEM_EVENT(xfs_trans_bhold_release
);
451 DEFINE_BUF_ITEM_EVENT(xfs_trans_binval
);
453 #define DEFINE_LOCK_EVENT(name) \
455 TP_PROTO(struct xfs_inode *ip, unsigned lock_flags, \
456 unsigned long caller_ip), \
457 TP_ARGS(ip, lock_flags, caller_ip), \
459 __field(dev_t, dev) \
460 __field(xfs_ino_t, ino) \
461 __field(int, lock_flags) \
462 __field(unsigned long, caller_ip) \
465 __entry->dev = VFS_I(ip)->i_sb->s_dev; \
466 __entry->ino = ip->i_ino; \
467 __entry->lock_flags = lock_flags; \
468 __entry->caller_ip = caller_ip; \
470 TP_printk("dev %d:%d ino 0x%llx flags %s caller %pf", \
471 MAJOR(__entry->dev), MINOR(__entry->dev), \
473 __print_flags(__entry->lock_flags, "|", XFS_LOCK_FLAGS), \
474 (void *)__entry->caller_ip) \
477 DEFINE_LOCK_EVENT(xfs_ilock
);
478 DEFINE_LOCK_EVENT(xfs_ilock_nowait
);
479 DEFINE_LOCK_EVENT(xfs_ilock_demote
);
480 DEFINE_LOCK_EVENT(xfs_iunlock
);
482 #define DEFINE_IGET_EVENT(name) \
484 TP_PROTO(struct xfs_inode *ip), \
487 __field(dev_t, dev) \
488 __field(xfs_ino_t, ino) \
491 __entry->dev = VFS_I(ip)->i_sb->s_dev; \
492 __entry->ino = ip->i_ino; \
494 TP_printk("dev %d:%d ino 0x%llx", \
495 MAJOR(__entry->dev), MINOR(__entry->dev), \
498 DEFINE_IGET_EVENT(xfs_iget_skip
);
499 DEFINE_IGET_EVENT(xfs_iget_reclaim
);
500 DEFINE_IGET_EVENT(xfs_iget_found
);
501 DEFINE_IGET_EVENT(xfs_iget_alloc
);
503 #define DEFINE_INODE_EVENT(name) \
505 TP_PROTO(struct xfs_inode *ip, unsigned long caller_ip), \
506 TP_ARGS(ip, caller_ip), \
508 __field(dev_t, dev) \
509 __field(xfs_ino_t, ino) \
510 __field(int, count) \
511 __field(unsigned long, caller_ip) \
514 __entry->dev = VFS_I(ip)->i_sb->s_dev; \
515 __entry->ino = ip->i_ino; \
516 __entry->count = atomic_read(&VFS_I(ip)->i_count); \
517 __entry->caller_ip = caller_ip; \
519 TP_printk("dev %d:%d ino 0x%llx count %d caller %pf", \
520 MAJOR(__entry->dev), MINOR(__entry->dev), \
523 (char *)__entry->caller_ip) \
525 DEFINE_INODE_EVENT(xfs_ihold
);
526 DEFINE_INODE_EVENT(xfs_irele
);
527 /* the old xfs_itrace_entry tracer - to be replaced by s.th. in the VFS */
528 DEFINE_INODE_EVENT(xfs_inode
);
529 #define xfs_itrace_entry(ip) \
530 trace_xfs_inode(ip, _THIS_IP_)
532 #define DEFINE_DQUOT_EVENT(tname) \
534 TP_PROTO(struct xfs_dquot *dqp), \
537 __field(dev_t, dev) \
538 __field(__be32, id) \
539 __field(unsigned, flags) \
540 __field(unsigned, nrefs) \
541 __field(unsigned long long, res_bcount) \
542 __field(unsigned long long, bcount) \
543 __field(unsigned long long, icount) \
544 __field(unsigned long long, blk_hardlimit) \
545 __field(unsigned long long, blk_softlimit) \
546 __field(unsigned long long, ino_hardlimit) \
547 __field(unsigned long long, ino_softlimit) \
550 __entry->dev = dqp->q_mount->m_super->s_dev; \
551 __entry->id = dqp->q_core.d_id; \
552 __entry->flags = dqp->dq_flags; \
553 __entry->nrefs = dqp->q_nrefs; \
554 __entry->res_bcount = dqp->q_res_bcount; \
555 __entry->bcount = be64_to_cpu(dqp->q_core.d_bcount); \
556 __entry->icount = be64_to_cpu(dqp->q_core.d_icount); \
557 __entry->blk_hardlimit = \
558 be64_to_cpu(dqp->q_core.d_blk_hardlimit); \
559 __entry->blk_softlimit = \
560 be64_to_cpu(dqp->q_core.d_blk_softlimit); \
561 __entry->ino_hardlimit = \
562 be64_to_cpu(dqp->q_core.d_ino_hardlimit); \
563 __entry->ino_softlimit = \
564 be64_to_cpu(dqp->q_core.d_ino_softlimit); \
566 TP_printk("dev %d:%d id 0x%x flags %s nrefs %u res_bc 0x%llx " \
567 "bcnt 0x%llx [hard 0x%llx | soft 0x%llx] " \
568 "icnt 0x%llx [hard 0x%llx | soft 0x%llx]", \
569 MAJOR(__entry->dev), MINOR(__entry->dev), \
570 be32_to_cpu(__entry->id), \
571 __print_flags(__entry->flags, "|", XFS_DQ_FLAGS), \
573 __entry->res_bcount, \
575 __entry->blk_hardlimit, \
576 __entry->blk_softlimit, \
578 __entry->ino_hardlimit, \
579 __entry->ino_softlimit) \
581 DEFINE_DQUOT_EVENT(xfs_dqadjust
);
582 DEFINE_DQUOT_EVENT(xfs_dqshake_dirty
);
583 DEFINE_DQUOT_EVENT(xfs_dqshake_unlink
);
584 DEFINE_DQUOT_EVENT(xfs_dqreclaim_want
);
585 DEFINE_DQUOT_EVENT(xfs_dqreclaim_dirty
);
586 DEFINE_DQUOT_EVENT(xfs_dqreclaim_unlink
);
587 DEFINE_DQUOT_EVENT(xfs_dqattach_found
);
588 DEFINE_DQUOT_EVENT(xfs_dqattach_get
);
589 DEFINE_DQUOT_EVENT(xfs_dqinit
);
590 DEFINE_DQUOT_EVENT(xfs_dqreuse
);
591 DEFINE_DQUOT_EVENT(xfs_dqalloc
);
592 DEFINE_DQUOT_EVENT(xfs_dqtobp_read
);
593 DEFINE_DQUOT_EVENT(xfs_dqread
);
594 DEFINE_DQUOT_EVENT(xfs_dqread_fail
);
595 DEFINE_DQUOT_EVENT(xfs_dqlookup_found
);
596 DEFINE_DQUOT_EVENT(xfs_dqlookup_want
);
597 DEFINE_DQUOT_EVENT(xfs_dqlookup_freelist
);
598 DEFINE_DQUOT_EVENT(xfs_dqlookup_move
);
599 DEFINE_DQUOT_EVENT(xfs_dqlookup_done
);
600 DEFINE_DQUOT_EVENT(xfs_dqget_hit
);
601 DEFINE_DQUOT_EVENT(xfs_dqget_miss
);
602 DEFINE_DQUOT_EVENT(xfs_dqput
);
603 DEFINE_DQUOT_EVENT(xfs_dqput_wait
);
604 DEFINE_DQUOT_EVENT(xfs_dqput_free
);
605 DEFINE_DQUOT_EVENT(xfs_dqrele
);
606 DEFINE_DQUOT_EVENT(xfs_dqflush
);
607 DEFINE_DQUOT_EVENT(xfs_dqflush_force
);
608 DEFINE_DQUOT_EVENT(xfs_dqflush_done
);
609 /* not really iget events, but we re-use the format */
610 DEFINE_IGET_EVENT(xfs_dquot_dqalloc
);
611 DEFINE_IGET_EVENT(xfs_dquot_dqdetach
);
614 #define DEFINE_LOGGRANT_EVENT(tname) \
616 TP_PROTO(struct log *log, struct xlog_ticket *tic), \
619 __field(dev_t, dev) \
620 __field(unsigned, trans_type) \
621 __field(char, ocnt) \
623 __field(int, curr_res) \
624 __field(int, unit_res) \
625 __field(unsigned int, flags) \
626 __field(void *, reserve_headq) \
627 __field(void *, write_headq) \
628 __field(int, grant_reserve_cycle) \
629 __field(int, grant_reserve_bytes) \
630 __field(int, grant_write_cycle) \
631 __field(int, grant_write_bytes) \
632 __field(int, curr_cycle) \
633 __field(int, curr_block) \
634 __field(xfs_lsn_t, tail_lsn) \
637 __entry->dev = log->l_mp->m_super->s_dev; \
638 __entry->trans_type = tic->t_trans_type; \
639 __entry->ocnt = tic->t_ocnt; \
640 __entry->cnt = tic->t_cnt; \
641 __entry->curr_res = tic->t_curr_res; \
642 __entry->unit_res = tic->t_unit_res; \
643 __entry->flags = tic->t_flags; \
644 __entry->reserve_headq = log->l_reserve_headq; \
645 __entry->write_headq = log->l_write_headq; \
646 __entry->grant_reserve_cycle = log->l_grant_reserve_cycle; \
647 __entry->grant_reserve_bytes = log->l_grant_reserve_bytes; \
648 __entry->grant_write_cycle = log->l_grant_write_cycle; \
649 __entry->grant_write_bytes = log->l_grant_write_bytes; \
650 __entry->curr_cycle = log->l_curr_cycle; \
651 __entry->curr_block = log->l_curr_block; \
652 __entry->tail_lsn = log->l_tail_lsn; \
654 TP_printk("dev %d:%d type %s t_ocnt %u t_cnt %u t_curr_res %u " \
655 "t_unit_res %u t_flags %s reserve_headq 0x%p " \
656 "write_headq 0x%p grant_reserve_cycle %d " \
657 "grant_reserve_bytes %d grant_write_cycle %d " \
658 "grant_write_bytes %d curr_cycle %d curr_block %d " \
659 "tail_cycle %d tail_block %d", \
660 MAJOR(__entry->dev), MINOR(__entry->dev), \
661 __print_symbolic(__entry->trans_type, XFS_TRANS_TYPES), \
666 __print_flags(__entry->flags, "|", XLOG_TIC_FLAGS), \
667 __entry->reserve_headq, \
668 __entry->write_headq, \
669 __entry->grant_reserve_cycle, \
670 __entry->grant_reserve_bytes, \
671 __entry->grant_write_cycle, \
672 __entry->grant_write_bytes, \
673 __entry->curr_cycle, \
674 __entry->curr_block, \
675 CYCLE_LSN(__entry->tail_lsn), \
676 BLOCK_LSN(__entry->tail_lsn) \
679 DEFINE_LOGGRANT_EVENT(xfs_log_done_nonperm
);
680 DEFINE_LOGGRANT_EVENT(xfs_log_done_perm
);
681 DEFINE_LOGGRANT_EVENT(xfs_log_reserve
);
682 DEFINE_LOGGRANT_EVENT(xfs_log_umount_write
);
683 DEFINE_LOGGRANT_EVENT(xfs_log_grant_enter
);
684 DEFINE_LOGGRANT_EVENT(xfs_log_grant_exit
);
685 DEFINE_LOGGRANT_EVENT(xfs_log_grant_error
);
686 DEFINE_LOGGRANT_EVENT(xfs_log_grant_sleep1
);
687 DEFINE_LOGGRANT_EVENT(xfs_log_grant_wake1
);
688 DEFINE_LOGGRANT_EVENT(xfs_log_grant_sleep2
);
689 DEFINE_LOGGRANT_EVENT(xfs_log_grant_wake2
);
690 DEFINE_LOGGRANT_EVENT(xfs_log_regrant_write_enter
);
691 DEFINE_LOGGRANT_EVENT(xfs_log_regrant_write_exit
);
692 DEFINE_LOGGRANT_EVENT(xfs_log_regrant_write_error
);
693 DEFINE_LOGGRANT_EVENT(xfs_log_regrant_write_sleep1
);
694 DEFINE_LOGGRANT_EVENT(xfs_log_regrant_write_wake1
);
695 DEFINE_LOGGRANT_EVENT(xfs_log_regrant_write_sleep2
);
696 DEFINE_LOGGRANT_EVENT(xfs_log_regrant_write_wake2
);
697 DEFINE_LOGGRANT_EVENT(xfs_log_regrant_reserve_enter
);
698 DEFINE_LOGGRANT_EVENT(xfs_log_regrant_reserve_exit
);
699 DEFINE_LOGGRANT_EVENT(xfs_log_regrant_reserve_sub
);
700 DEFINE_LOGGRANT_EVENT(xfs_log_ungrant_enter
);
701 DEFINE_LOGGRANT_EVENT(xfs_log_ungrant_exit
);
702 DEFINE_LOGGRANT_EVENT(xfs_log_ungrant_sub
);
704 #define DEFINE_RW_EVENT(name) \
706 TP_PROTO(struct xfs_inode *ip, size_t count, loff_t offset, int flags), \
707 TP_ARGS(ip, count, offset, flags), \
709 __field(dev_t, dev) \
710 __field(xfs_ino_t, ino) \
711 __field(xfs_fsize_t, size) \
712 __field(xfs_fsize_t, new_size) \
713 __field(loff_t, offset) \
714 __field(size_t, count) \
715 __field(int, flags) \
718 __entry->dev = VFS_I(ip)->i_sb->s_dev; \
719 __entry->ino = ip->i_ino; \
720 __entry->size = ip->i_d.di_size; \
721 __entry->new_size = ip->i_new_size; \
722 __entry->offset = offset; \
723 __entry->count = count; \
724 __entry->flags = flags; \
726 TP_printk("dev %d:%d ino 0x%llx size 0x%llx new_size 0x%llx " \
727 "offset 0x%llx count 0x%zx ioflags %s", \
728 MAJOR(__entry->dev), MINOR(__entry->dev), \
734 __print_flags(__entry->flags, "|", XFS_IO_FLAGS)) \
736 DEFINE_RW_EVENT(xfs_file_read
);
737 DEFINE_RW_EVENT(xfs_file_buffered_write
);
738 DEFINE_RW_EVENT(xfs_file_direct_write
);
739 DEFINE_RW_EVENT(xfs_file_splice_read
);
740 DEFINE_RW_EVENT(xfs_file_splice_write
);
743 #define DEFINE_PAGE_EVENT(name) \
745 TP_PROTO(struct inode *inode, struct page *page, unsigned long off), \
746 TP_ARGS(inode, page, off), \
748 __field(dev_t, dev) \
749 __field(xfs_ino_t, ino) \
750 __field(pgoff_t, pgoff) \
751 __field(loff_t, size) \
752 __field(unsigned long, offset) \
753 __field(int, delalloc) \
754 __field(int, unmapped) \
755 __field(int, unwritten) \
758 int delalloc = -1, unmapped = -1, unwritten = -1; \
760 if (page_has_buffers(page)) \
761 xfs_count_page_state(page, &delalloc, \
762 &unmapped, &unwritten); \
763 __entry->dev = inode->i_sb->s_dev; \
764 __entry->ino = XFS_I(inode)->i_ino; \
765 __entry->pgoff = page_offset(page); \
766 __entry->size = i_size_read(inode); \
767 __entry->offset = off; \
768 __entry->delalloc = delalloc; \
769 __entry->unmapped = unmapped; \
770 __entry->unwritten = unwritten; \
772 TP_printk("dev %d:%d ino 0x%llx pgoff 0x%lx size 0x%llx offset %lx " \
773 "delalloc %d unmapped %d unwritten %d", \
774 MAJOR(__entry->dev), MINOR(__entry->dev), \
781 __entry->unwritten) \
783 DEFINE_PAGE_EVENT(xfs_writepage
);
784 DEFINE_PAGE_EVENT(xfs_releasepage
);
785 DEFINE_PAGE_EVENT(xfs_invalidatepage
);
787 #define DEFINE_IOMAP_EVENT(name) \
789 TP_PROTO(struct xfs_inode *ip, xfs_off_t offset, ssize_t count, \
790 int flags, struct xfs_bmbt_irec *irec), \
791 TP_ARGS(ip, offset, count, flags, irec), \
793 __field(dev_t, dev) \
794 __field(xfs_ino_t, ino) \
795 __field(loff_t, size) \
796 __field(loff_t, new_size) \
797 __field(loff_t, offset) \
798 __field(size_t, count) \
799 __field(int, flags) \
800 __field(xfs_fileoff_t, startoff) \
801 __field(xfs_fsblock_t, startblock) \
802 __field(xfs_filblks_t, blockcount) \
805 __entry->dev = VFS_I(ip)->i_sb->s_dev; \
806 __entry->ino = ip->i_ino; \
807 __entry->size = ip->i_d.di_size; \
808 __entry->new_size = ip->i_new_size; \
809 __entry->offset = offset; \
810 __entry->count = count; \
811 __entry->flags = flags; \
812 __entry->startoff = irec ? irec->br_startoff : 0; \
813 __entry->startblock = irec ? irec->br_startblock : 0; \
814 __entry->blockcount = irec ? irec->br_blockcount : 0; \
816 TP_printk("dev %d:%d ino 0x%llx size 0x%llx new_size 0x%llx " \
817 "offset 0x%llx count %zd flags %s " \
818 "startoff 0x%llx startblock 0x%llx blockcount 0x%llx", \
819 MAJOR(__entry->dev), MINOR(__entry->dev), \
825 __print_flags(__entry->flags, "|", BMAPI_FLAGS), \
827 __entry->startblock, \
828 __entry->blockcount) \
830 DEFINE_IOMAP_EVENT(xfs_iomap_enter
);
831 DEFINE_IOMAP_EVENT(xfs_iomap_found
);
832 DEFINE_IOMAP_EVENT(xfs_iomap_alloc
);
834 #define DEFINE_SIMPLE_IO_EVENT(name) \
836 TP_PROTO(struct xfs_inode *ip, xfs_off_t offset, ssize_t count), \
837 TP_ARGS(ip, offset, count), \
839 __field(dev_t, dev) \
840 __field(xfs_ino_t, ino) \
841 __field(loff_t, size) \
842 __field(loff_t, new_size) \
843 __field(loff_t, offset) \
844 __field(size_t, count) \
847 __entry->dev = VFS_I(ip)->i_sb->s_dev; \
848 __entry->ino = ip->i_ino; \
849 __entry->size = ip->i_d.di_size; \
850 __entry->new_size = ip->i_new_size; \
851 __entry->offset = offset; \
852 __entry->count = count; \
854 TP_printk("dev %d:%d ino 0x%llx size 0x%llx new_size 0x%llx " \
855 "offset 0x%llx count %zd", \
856 MAJOR(__entry->dev), MINOR(__entry->dev), \
863 DEFINE_SIMPLE_IO_EVENT(xfs_delalloc_enospc
);
864 DEFINE_SIMPLE_IO_EVENT(xfs_unwritten_convert
);
867 TRACE_EVENT(xfs_itruncate_start
,
868 TP_PROTO(struct xfs_inode
*ip
, xfs_fsize_t new_size
, int flag
,
869 xfs_off_t toss_start
, xfs_off_t toss_finish
),
870 TP_ARGS(ip
, new_size
, flag
, toss_start
, toss_finish
),
873 __field(xfs_ino_t
, ino
)
874 __field(xfs_fsize_t
, size
)
875 __field(xfs_fsize_t
, new_size
)
876 __field(xfs_off_t
, toss_start
)
877 __field(xfs_off_t
, toss_finish
)
881 __entry
->dev
= VFS_I(ip
)->i_sb
->s_dev
;
882 __entry
->ino
= ip
->i_ino
;
883 __entry
->size
= ip
->i_d
.di_size
;
884 __entry
->new_size
= new_size
;
885 __entry
->toss_start
= toss_start
;
886 __entry
->toss_finish
= toss_finish
;
887 __entry
->flag
= flag
;
889 TP_printk("dev %d:%d ino 0x%llx %s size 0x%llx new_size 0x%llx "
890 "toss start 0x%llx toss finish 0x%llx",
891 MAJOR(__entry
->dev
), MINOR(__entry
->dev
),
893 __print_flags(__entry
->flag
, "|", XFS_ITRUNC_FLAGS
),
897 __entry
->toss_finish
)
900 #define DEFINE_ITRUNC_EVENT(name) \
902 TP_PROTO(struct xfs_inode *ip, xfs_fsize_t new_size), \
903 TP_ARGS(ip, new_size), \
905 __field(dev_t, dev) \
906 __field(xfs_ino_t, ino) \
907 __field(xfs_fsize_t, size) \
908 __field(xfs_fsize_t, new_size) \
911 __entry->dev = VFS_I(ip)->i_sb->s_dev; \
912 __entry->ino = ip->i_ino; \
913 __entry->size = ip->i_d.di_size; \
914 __entry->new_size = new_size; \
916 TP_printk("dev %d:%d ino 0x%llx size 0x%llx new_size 0x%llx", \
917 MAJOR(__entry->dev), MINOR(__entry->dev), \
922 DEFINE_ITRUNC_EVENT(xfs_itruncate_finish_start
);
923 DEFINE_ITRUNC_EVENT(xfs_itruncate_finish_end
);
925 TRACE_EVENT(xfs_pagecache_inval
,
926 TP_PROTO(struct xfs_inode
*ip
, xfs_off_t start
, xfs_off_t finish
),
927 TP_ARGS(ip
, start
, finish
),
930 __field(xfs_ino_t
, ino
)
931 __field(xfs_fsize_t
, size
)
932 __field(xfs_off_t
, start
)
933 __field(xfs_off_t
, finish
)
936 __entry
->dev
= VFS_I(ip
)->i_sb
->s_dev
;
937 __entry
->ino
= ip
->i_ino
;
938 __entry
->size
= ip
->i_d
.di_size
;
939 __entry
->start
= start
;
940 __entry
->finish
= finish
;
942 TP_printk("dev %d:%d ino 0x%llx size 0x%llx start 0x%llx finish 0x%llx",
943 MAJOR(__entry
->dev
), MINOR(__entry
->dev
),
950 TRACE_EVENT(xfs_bunmap
,
951 TP_PROTO(struct xfs_inode
*ip
, xfs_fileoff_t bno
, xfs_filblks_t len
,
952 int flags
, unsigned long caller_ip
),
953 TP_ARGS(ip
, bno
, len
, flags
, caller_ip
),
956 __field(xfs_ino_t
, ino
)
957 __field(xfs_fsize_t
, size
)
958 __field(xfs_fileoff_t
, bno
)
959 __field(xfs_filblks_t
, len
)
960 __field(unsigned long, caller_ip
)
964 __entry
->dev
= VFS_I(ip
)->i_sb
->s_dev
;
965 __entry
->ino
= ip
->i_ino
;
966 __entry
->size
= ip
->i_d
.di_size
;
969 __entry
->caller_ip
= caller_ip
;
970 __entry
->flags
= flags
;
972 TP_printk("dev %d:%d ino 0x%llx size 0x%llx bno 0x%llx len 0x%llx"
973 "flags %s caller %pf",
974 MAJOR(__entry
->dev
), MINOR(__entry
->dev
),
979 __print_flags(__entry
->flags
, "|", XFS_BMAPI_FLAGS
),
980 (void *)__entry
->caller_ip
)
984 TRACE_EVENT(xfs_alloc_busy
,
985 TP_PROTO(struct xfs_mount
*mp
, xfs_agnumber_t agno
, xfs_agblock_t agbno
,
986 xfs_extlen_t len
, int slot
),
987 TP_ARGS(mp
, agno
, agbno
, len
, slot
),
990 __field(xfs_agnumber_t
, agno
)
991 __field(xfs_agblock_t
, agbno
)
992 __field(xfs_extlen_t
, len
)
996 __entry
->dev
= mp
->m_super
->s_dev
;
997 __entry
->agno
= agno
;
998 __entry
->agbno
= agbno
;
1000 __entry
->slot
= slot
;
1002 TP_printk("dev %d:%d agno %u agbno %u len %u slot %d",
1003 MAJOR(__entry
->dev
), MINOR(__entry
->dev
),
1011 #define XFS_BUSY_STATES \
1015 TRACE_EVENT(xfs_alloc_unbusy
,
1016 TP_PROTO(struct xfs_mount
*mp
, xfs_agnumber_t agno
,
1017 int slot
, int found
),
1018 TP_ARGS(mp
, agno
, slot
, found
),
1021 __field(xfs_agnumber_t
, agno
)
1026 __entry
->dev
= mp
->m_super
->s_dev
;
1027 __entry
->agno
= agno
;
1028 __entry
->slot
= slot
;
1029 __entry
->found
= found
;
1031 TP_printk("dev %d:%d agno %u slot %d %s",
1032 MAJOR(__entry
->dev
), MINOR(__entry
->dev
),
1035 __print_symbolic(__entry
->found
, XFS_BUSY_STATES
))
1038 TRACE_EVENT(xfs_alloc_busysearch
,
1039 TP_PROTO(struct xfs_mount
*mp
, xfs_agnumber_t agno
, xfs_agblock_t agbno
,
1040 xfs_extlen_t len
, int found
),
1041 TP_ARGS(mp
, agno
, agbno
, len
, found
),
1044 __field(xfs_agnumber_t
, agno
)
1045 __field(xfs_agblock_t
, agbno
)
1046 __field(xfs_extlen_t
, len
)
1050 __entry
->dev
= mp
->m_super
->s_dev
;
1051 __entry
->agno
= agno
;
1052 __entry
->agbno
= agbno
;
1054 __entry
->found
= found
;
1056 TP_printk("dev %d:%d agno %u agbno %u len %u %s",
1057 MAJOR(__entry
->dev
), MINOR(__entry
->dev
),
1061 __print_symbolic(__entry
->found
, XFS_BUSY_STATES
))
1064 TRACE_EVENT(xfs_agf
,
1065 TP_PROTO(struct xfs_mount
*mp
, struct xfs_agf
*agf
, int flags
,
1066 unsigned long caller_ip
),
1067 TP_ARGS(mp
, agf
, flags
, caller_ip
),
1070 __field(xfs_agnumber_t
, agno
)
1072 __field(__u32
, length
)
1073 __field(__u32
, bno_root
)
1074 __field(__u32
, cnt_root
)
1075 __field(__u32
, bno_level
)
1076 __field(__u32
, cnt_level
)
1077 __field(__u32
, flfirst
)
1078 __field(__u32
, fllast
)
1079 __field(__u32
, flcount
)
1080 __field(__u32
, freeblks
)
1081 __field(__u32
, longest
)
1082 __field(unsigned long, caller_ip
)
1085 __entry
->dev
= mp
->m_super
->s_dev
;
1086 __entry
->agno
= be32_to_cpu(agf
->agf_seqno
),
1087 __entry
->flags
= flags
;
1088 __entry
->length
= be32_to_cpu(agf
->agf_length
),
1089 __entry
->bno_root
= be32_to_cpu(agf
->agf_roots
[XFS_BTNUM_BNO
]),
1090 __entry
->cnt_root
= be32_to_cpu(agf
->agf_roots
[XFS_BTNUM_CNT
]),
1091 __entry
->bno_level
=
1092 be32_to_cpu(agf
->agf_levels
[XFS_BTNUM_BNO
]),
1093 __entry
->cnt_level
=
1094 be32_to_cpu(agf
->agf_levels
[XFS_BTNUM_CNT
]),
1095 __entry
->flfirst
= be32_to_cpu(agf
->agf_flfirst
),
1096 __entry
->fllast
= be32_to_cpu(agf
->agf_fllast
),
1097 __entry
->flcount
= be32_to_cpu(agf
->agf_flcount
),
1098 __entry
->freeblks
= be32_to_cpu(agf
->agf_freeblks
),
1099 __entry
->longest
= be32_to_cpu(agf
->agf_longest
);
1100 __entry
->caller_ip
= caller_ip
;
1102 TP_printk("dev %d:%d agno %u flags %s length %u roots b %u c %u "
1103 "levels b %u c %u flfirst %u fllast %u flcount %u "
1104 "freeblks %u longest %u caller %pf",
1105 MAJOR(__entry
->dev
), MINOR(__entry
->dev
),
1107 __print_flags(__entry
->flags
, "|", XFS_AGF_FLAGS
),
1118 (void *)__entry
->caller_ip
)
1121 TRACE_EVENT(xfs_free_extent
,
1122 TP_PROTO(struct xfs_mount
*mp
, xfs_agnumber_t agno
, xfs_agblock_t agbno
,
1123 xfs_extlen_t len
, bool isfl
, int haveleft
, int haveright
),
1124 TP_ARGS(mp
, agno
, agbno
, len
, isfl
, haveleft
, haveright
),
1127 __field(xfs_agnumber_t
, agno
)
1128 __field(xfs_agblock_t
, agbno
)
1129 __field(xfs_extlen_t
, len
)
1131 __field(int, haveleft
)
1132 __field(int, haveright
)
1135 __entry
->dev
= mp
->m_super
->s_dev
;
1136 __entry
->agno
= agno
;
1137 __entry
->agbno
= agbno
;
1139 __entry
->isfl
= isfl
;
1140 __entry
->haveleft
= haveleft
;
1141 __entry
->haveright
= haveright
;
1143 TP_printk("dev %d:%d agno %u agbno %u len %u isfl %d %s",
1144 MAJOR(__entry
->dev
), MINOR(__entry
->dev
),
1150 (__entry
->haveright
? "both" : "left") :
1151 (__entry
->haveright
? "right" : "none"))
1155 #define DEFINE_ALLOC_EVENT(name) \
1157 TP_PROTO(struct xfs_alloc_arg *args), \
1160 __field(dev_t, dev) \
1161 __field(xfs_agnumber_t, agno) \
1162 __field(xfs_agblock_t, agbno) \
1163 __field(xfs_extlen_t, minlen) \
1164 __field(xfs_extlen_t, maxlen) \
1165 __field(xfs_extlen_t, mod) \
1166 __field(xfs_extlen_t, prod) \
1167 __field(xfs_extlen_t, minleft) \
1168 __field(xfs_extlen_t, total) \
1169 __field(xfs_extlen_t, alignment) \
1170 __field(xfs_extlen_t, minalignslop) \
1171 __field(xfs_extlen_t, len) \
1172 __field(short, type) \
1173 __field(short, otype) \
1174 __field(char, wasdel) \
1175 __field(char, wasfromfl) \
1176 __field(char, isfl) \
1177 __field(char, userdata) \
1178 __field(xfs_fsblock_t, firstblock) \
1181 __entry->dev = args->mp->m_super->s_dev; \
1182 __entry->agno = args->agno; \
1183 __entry->agbno = args->agbno; \
1184 __entry->minlen = args->minlen; \
1185 __entry->maxlen = args->maxlen; \
1186 __entry->mod = args->mod; \
1187 __entry->prod = args->prod; \
1188 __entry->minleft = args->minleft; \
1189 __entry->total = args->total; \
1190 __entry->alignment = args->alignment; \
1191 __entry->minalignslop = args->minalignslop; \
1192 __entry->len = args->len; \
1193 __entry->type = args->type; \
1194 __entry->otype = args->otype; \
1195 __entry->wasdel = args->wasdel; \
1196 __entry->wasfromfl = args->wasfromfl; \
1197 __entry->isfl = args->isfl; \
1198 __entry->userdata = args->userdata; \
1199 __entry->firstblock = args->firstblock; \
1201 TP_printk("dev %d:%d agno %u agbno %u minlen %u maxlen %u mod %u " \
1202 "prod %u minleft %u total %u alignment %u minalignslop %u " \
1203 "len %u type %s otype %s wasdel %d wasfromfl %d isfl %d " \
1204 "userdata %d firstblock 0x%llx", \
1205 MAJOR(__entry->dev), MINOR(__entry->dev), \
1214 __entry->alignment, \
1215 __entry->minalignslop, \
1217 __print_symbolic(__entry->type, XFS_ALLOC_TYPES), \
1218 __print_symbolic(__entry->otype, XFS_ALLOC_TYPES), \
1220 __entry->wasfromfl, \
1222 __entry->userdata, \
1223 __entry->firstblock) \
1226 DEFINE_ALLOC_EVENT(xfs_alloc_exact_done
);
1227 DEFINE_ALLOC_EVENT(xfs_alloc_exact_error
);
1228 DEFINE_ALLOC_EVENT(xfs_alloc_near_nominleft
);
1229 DEFINE_ALLOC_EVENT(xfs_alloc_near_first
);
1230 DEFINE_ALLOC_EVENT(xfs_alloc_near_greater
);
1231 DEFINE_ALLOC_EVENT(xfs_alloc_near_lesser
);
1232 DEFINE_ALLOC_EVENT(xfs_alloc_near_error
);
1233 DEFINE_ALLOC_EVENT(xfs_alloc_size_neither
);
1234 DEFINE_ALLOC_EVENT(xfs_alloc_size_noentry
);
1235 DEFINE_ALLOC_EVENT(xfs_alloc_size_nominleft
);
1236 DEFINE_ALLOC_EVENT(xfs_alloc_size_done
);
1237 DEFINE_ALLOC_EVENT(xfs_alloc_size_error
);
1238 DEFINE_ALLOC_EVENT(xfs_alloc_small_freelist
);
1239 DEFINE_ALLOC_EVENT(xfs_alloc_small_notenough
);
1240 DEFINE_ALLOC_EVENT(xfs_alloc_small_done
);
1241 DEFINE_ALLOC_EVENT(xfs_alloc_small_error
);
1242 DEFINE_ALLOC_EVENT(xfs_alloc_vextent_badargs
);
1243 DEFINE_ALLOC_EVENT(xfs_alloc_vextent_nofix
);
1244 DEFINE_ALLOC_EVENT(xfs_alloc_vextent_noagbp
);
1245 DEFINE_ALLOC_EVENT(xfs_alloc_vextent_loopfailed
);
1246 DEFINE_ALLOC_EVENT(xfs_alloc_vextent_allfailed
);
1248 #define DEFINE_DIR2_TRACE(tname) \
1249 TRACE_EVENT(tname, \
1250 TP_PROTO(struct xfs_da_args *args), \
1253 __field(dev_t, dev) \
1254 __field(xfs_ino_t, ino) \
1255 __dynamic_array(char, name, args->namelen) \
1256 __field(int, namelen) \
1257 __field(xfs_dahash_t, hashval) \
1258 __field(xfs_ino_t, inumber) \
1259 __field(int, op_flags) \
1262 __entry->dev = VFS_I(args->dp)->i_sb->s_dev; \
1263 __entry->ino = args->dp->i_ino; \
1264 if (args->namelen) \
1265 memcpy(__get_str(name), args->name, args->namelen); \
1266 __entry->namelen = args->namelen; \
1267 __entry->hashval = args->hashval; \
1268 __entry->inumber = args->inumber; \
1269 __entry->op_flags = args->op_flags; \
1271 TP_printk("dev %d:%d ino 0x%llx name %.*s namelen %d hashval 0x%x " \
1272 "inumber 0x%llx op_flags %s", \
1273 MAJOR(__entry->dev), MINOR(__entry->dev), \
1276 __entry->namelen ? __get_str(name) : NULL, \
1280 __print_flags(__entry->op_flags, "|", XFS_DA_OP_FLAGS)) \
1282 DEFINE_DIR2_TRACE(xfs_dir2_sf_addname
);
1283 DEFINE_DIR2_TRACE(xfs_dir2_sf_create
);
1284 DEFINE_DIR2_TRACE(xfs_dir2_sf_lookup
);
1285 DEFINE_DIR2_TRACE(xfs_dir2_sf_replace
);
1286 DEFINE_DIR2_TRACE(xfs_dir2_sf_removename
);
1287 DEFINE_DIR2_TRACE(xfs_dir2_sf_toino4
);
1288 DEFINE_DIR2_TRACE(xfs_dir2_sf_toino8
);
1289 DEFINE_DIR2_TRACE(xfs_dir2_sf_to_block
);
1290 DEFINE_DIR2_TRACE(xfs_dir2_block_addname
);
1291 DEFINE_DIR2_TRACE(xfs_dir2_block_lookup
);
1292 DEFINE_DIR2_TRACE(xfs_dir2_block_replace
);
1293 DEFINE_DIR2_TRACE(xfs_dir2_block_removename
);
1294 DEFINE_DIR2_TRACE(xfs_dir2_block_to_sf
);
1295 DEFINE_DIR2_TRACE(xfs_dir2_block_to_leaf
);
1296 DEFINE_DIR2_TRACE(xfs_dir2_leaf_addname
);
1297 DEFINE_DIR2_TRACE(xfs_dir2_leaf_lookup
);
1298 DEFINE_DIR2_TRACE(xfs_dir2_leaf_replace
);
1299 DEFINE_DIR2_TRACE(xfs_dir2_leaf_removename
);
1300 DEFINE_DIR2_TRACE(xfs_dir2_leaf_to_block
);
1301 DEFINE_DIR2_TRACE(xfs_dir2_leaf_to_node
);
1302 DEFINE_DIR2_TRACE(xfs_dir2_node_addname
);
1303 DEFINE_DIR2_TRACE(xfs_dir2_node_lookup
);
1304 DEFINE_DIR2_TRACE(xfs_dir2_node_replace
);
1305 DEFINE_DIR2_TRACE(xfs_dir2_node_removename
);
1306 DEFINE_DIR2_TRACE(xfs_dir2_node_to_leaf
);
1308 #define DEFINE_DIR2_SPACE_TRACE(tname) \
1309 TRACE_EVENT(tname, \
1310 TP_PROTO(struct xfs_da_args *args, int idx), \
1311 TP_ARGS(args, idx), \
1313 __field(dev_t, dev) \
1314 __field(xfs_ino_t, ino) \
1315 __field(int, op_flags) \
1319 __entry->dev = VFS_I(args->dp)->i_sb->s_dev; \
1320 __entry->ino = args->dp->i_ino; \
1321 __entry->op_flags = args->op_flags; \
1322 __entry->idx = idx; \
1324 TP_printk("dev %d:%d ino 0x%llx op_flags %s index %d", \
1325 MAJOR(__entry->dev), MINOR(__entry->dev), \
1327 __print_flags(__entry->op_flags, "|", XFS_DA_OP_FLAGS), \
1330 DEFINE_DIR2_SPACE_TRACE(xfs_dir2_leafn_add
);
1331 DEFINE_DIR2_SPACE_TRACE(xfs_dir2_leafn_remove
);
1332 DEFINE_DIR2_SPACE_TRACE(xfs_dir2_grow_inode
);
1333 DEFINE_DIR2_SPACE_TRACE(xfs_dir2_shrink_inode
);
1335 TRACE_EVENT(xfs_dir2_leafn_moveents
,
1336 TP_PROTO(struct xfs_da_args
*args
, int src_idx
, int dst_idx
, int count
),
1337 TP_ARGS(args
, src_idx
, dst_idx
, count
),
1340 __field(xfs_ino_t
, ino
)
1341 __field(int, op_flags
)
1342 __field(int, src_idx
)
1343 __field(int, dst_idx
)
1347 __entry
->dev
= VFS_I(args
->dp
)->i_sb
->s_dev
;
1348 __entry
->ino
= args
->dp
->i_ino
;
1349 __entry
->op_flags
= args
->op_flags
;
1350 __entry
->src_idx
= src_idx
;
1351 __entry
->dst_idx
= dst_idx
;
1352 __entry
->count
= count
;
1354 TP_printk("dev %d:%d ino 0x%llx op_flags %s "
1355 "src_idx %d dst_idx %d count %d",
1356 MAJOR(__entry
->dev
), MINOR(__entry
->dev
),
1358 __print_flags(__entry
->op_flags
, "|", XFS_DA_OP_FLAGS
),
1364 #endif /* _TRACE_XFS_H */
1366 #undef TRACE_INCLUDE_PATH
1367 #define TRACE_INCLUDE_PATH .
1368 #define TRACE_INCLUDE_FILE xfs_trace
1369 #include <trace/define_trace.h>