1// SPDX-License-Identifier: GPL-2.0
2/*
3 * Copyright (c) 2009, Christoph Hellwig
4 * All Rights Reserved.
5 *
6 * NOTE: none of these tracepoints shall be considered a stable kernel ABI
7 * as they can change at any time.
8 *
9 * Current conventions for printing numbers measuring specific units:
10 *
11 * agno: allocation group number
12 *
13 * agino: per-AG inode number
14 * ino: filesystem inode number
15 *
16 * agbno: per-AG block number in fs blocks
17 * rgbno: per-rtgroup block number in fs blocks
18 * startblock: physical block number for file mappings. This is either a
19 * segmented fsblock for data device mappings, or a rfsblock
20 * for realtime device mappings
21 * fsbcount: number of blocks in an extent, in fs blocks
22 *
23 * gbno: generic allocation group block number. This is an agbno for
24 * space in a per-AG or a rgbno for space in a realtime group.
25 *
26 * daddr: physical block number in 512b blocks
27 * bbcount: number of blocks in a physical extent, in 512b blocks
28 *
29 * rtx: physical rt extent number for extent mappings
30 * rtxcount: number of rt extents in an extent mapping
31 *
32 * owner: reverse-mapping owner, usually inodes
33 *
34 * fileoff: file offset, in fs blocks
35 * pos: file offset, in bytes
36 * bytecount: number of bytes
37 *
38 * dablk: directory or xattr block offset, in filesystem blocks
39 *
40 * disize: ondisk file size, in bytes
41 * isize: incore file size, in bytes
42 *
43 * forkoff: inode fork offset, in bytes
44 *
45 * ireccount: number of inode records
46 *
47 * Numbers describing space allocations (blocks, extents, inodes) should be
48 * formatted in hexadecimal.
49 */
50#undef TRACE_SYSTEM
51#define TRACE_SYSTEM xfs
52
53#if !defined(_TRACE_XFS_H) || defined(TRACE_HEADER_MULTI_READ)
54#define _TRACE_XFS_H
55
56#include <linux/tracepoint.h>
57
58struct xfs_agf;
59struct xfs_alloc_arg;
60struct xfs_attr_list_context;
61struct xfs_buf_log_item;
62struct xfs_da_args;
63struct xfs_da_node_entry;
64struct xfs_dquot;
65struct xfs_log_item;
66struct xlog;
67struct xlog_ticket;
68struct xlog_recover;
69struct xlog_recover_item;
70struct xlog_rec_header;
71struct xlog_in_core;
72struct xfs_buf_log_format;
73struct xfs_inode_log_format;
74struct xfs_bmbt_irec;
75struct xfs_btree_cur;
76struct xfs_defer_op_type;
77struct xfs_refcount_irec;
78struct xfs_fsmap;
79struct xfs_fsmap_irec;
80struct xfs_group;
81struct xfs_rmap_irec;
82struct xfs_icreate_log;
83struct xfs_iunlink_item;
84struct xfs_owner_info;
85struct xfs_trans_res;
86struct xfs_inobt_rec_incore;
87union xfs_btree_ptr;
88struct xfs_dqtrx;
89struct xfs_icwalk;
90struct xfs_perag;
91struct xfbtree;
92struct xfs_btree_ops;
93struct xfs_bmap_intent;
94struct xfs_exchmaps_intent;
95struct xfs_exchmaps_req;
96struct xfs_exchrange;
97struct xfs_getparents;
98struct xfs_parent_irec;
99struct xfs_attrlist_cursor_kern;
100struct xfs_extent_free_item;
101struct xfs_rmap_intent;
102struct xfs_refcount_intent;
103struct xfs_metadir_update;
104struct xfs_rtgroup;
105struct xfs_open_zone;
106
107#define XFS_ATTR_FILTER_FLAGS \
108 { XFS_ATTR_ROOT, "ROOT" }, \
109 { XFS_ATTR_SECURE, "SECURE" }, \
110 { XFS_ATTR_INCOMPLETE, "INCOMPLETE" }, \
111 { XFS_ATTR_PARENT, "PARENT" }
112
113DECLARE_EVENT_CLASS(xfs_attr_list_class,
114 TP_PROTO(struct xfs_attr_list_context *ctx),
115 TP_ARGS(ctx),
116 TP_STRUCT__entry(
117 __field(dev_t, dev)
118 __field(xfs_ino_t, ino)
119 __field(u32, hashval)
120 __field(u32, blkno)
121 __field(u32, offset)
122 __field(void *, buffer)
123 __field(int, bufsize)
124 __field(int, count)
125 __field(int, firstu)
126 __field(int, dupcnt)
127 __field(unsigned int, attr_filter)
128 ),
129 TP_fast_assign(
130 __entry->dev = VFS_I(ctx->dp)->i_sb->s_dev;
131 __entry->ino = ctx->dp->i_ino;
132 __entry->hashval = ctx->cursor.hashval;
133 __entry->blkno = ctx->cursor.blkno;
134 __entry->offset = ctx->cursor.offset;
135 __entry->buffer = ctx->buffer;
136 __entry->bufsize = ctx->bufsize;
137 __entry->count = ctx->count;
138 __entry->firstu = ctx->firstu;
139 __entry->attr_filter = ctx->attr_filter;
140 ),
141 TP_printk("dev %d:%d ino 0x%llx cursor h/b/o 0x%x/0x%x/%u dupcnt %u "
142 "buffer %p size %u count %u firstu %u filter %s",
143 MAJOR(__entry->dev), MINOR(__entry->dev),
144 __entry->ino,
145 __entry->hashval,
146 __entry->blkno,
147 __entry->offset,
148 __entry->dupcnt,
149 __entry->buffer,
150 __entry->bufsize,
151 __entry->count,
152 __entry->firstu,
153 __print_flags(__entry->attr_filter, "|",
154 XFS_ATTR_FILTER_FLAGS)
155 )
156)
157
158#define DEFINE_ATTR_LIST_EVENT(name) \
159DEFINE_EVENT(xfs_attr_list_class, name, \
160 TP_PROTO(struct xfs_attr_list_context *ctx), \
161 TP_ARGS(ctx))
162DEFINE_ATTR_LIST_EVENT(xfs_attr_list_sf);
163DEFINE_ATTR_LIST_EVENT(xfs_attr_list_sf_all);
164DEFINE_ATTR_LIST_EVENT(xfs_attr_list_leaf);
165DEFINE_ATTR_LIST_EVENT(xfs_attr_list_leaf_end);
166DEFINE_ATTR_LIST_EVENT(xfs_attr_list_full);
167DEFINE_ATTR_LIST_EVENT(xfs_attr_list_add);
168DEFINE_ATTR_LIST_EVENT(xfs_attr_list_wrong_blk);
169DEFINE_ATTR_LIST_EVENT(xfs_attr_list_notfound);
170DEFINE_ATTR_LIST_EVENT(xfs_attr_leaf_list);
171DEFINE_ATTR_LIST_EVENT(xfs_attr_node_list);
172
173TRACE_EVENT(xfs_calc_atomic_write_unit_max,
174 TP_PROTO(struct xfs_mount *mp, enum xfs_group_type type,
175 unsigned int max_write, unsigned int max_ioend,
176 unsigned int max_gsize, unsigned int awu_max),
177 TP_ARGS(mp, type, max_write, max_ioend, max_gsize, awu_max),
178 TP_STRUCT__entry(
179 __field(dev_t, dev)
180 __field(enum xfs_group_type, type)
181 __field(unsigned int, max_write)
182 __field(unsigned int, max_ioend)
183 __field(unsigned int, max_gsize)
184 __field(unsigned int, awu_max)
185 ),
186 TP_fast_assign(
187 __entry->dev = mp->m_super->s_dev;
188 __entry->type = type;
189 __entry->max_write = max_write;
190 __entry->max_ioend = max_ioend;
191 __entry->max_gsize = max_gsize;
192 __entry->awu_max = awu_max;
193 ),
194 TP_printk("dev %d:%d %s max_write %u max_ioend %u max_gsize %u awu_max %u",
195 MAJOR(__entry->dev), MINOR(__entry->dev),
196 __print_symbolic(__entry->type, XG_TYPE_STRINGS),
197 __entry->max_write,
198 __entry->max_ioend,
199 __entry->max_gsize,
200 __entry->awu_max)
201);
202
203TRACE_EVENT(xfs_calc_max_atomic_write_fsblocks,
204 TP_PROTO(struct xfs_mount *mp, unsigned int per_intent,
205 unsigned int step_size, unsigned int logres,
206 unsigned int blockcount),
207 TP_ARGS(mp, per_intent, step_size, logres, blockcount),
208 TP_STRUCT__entry(
209 __field(dev_t, dev)
210 __field(unsigned int, per_intent)
211 __field(unsigned int, step_size)
212 __field(unsigned int, logres)
213 __field(unsigned int, blockcount)
214 ),
215 TP_fast_assign(
216 __entry->dev = mp->m_super->s_dev;
217 __entry->per_intent = per_intent;
218 __entry->step_size = step_size;
219 __entry->logres = logres;
220 __entry->blockcount = blockcount;
221 ),
222 TP_printk("dev %d:%d per_intent %u step_size %u logres %u blockcount %u",
223 MAJOR(__entry->dev), MINOR(__entry->dev),
224 __entry->per_intent,
225 __entry->step_size,
226 __entry->logres,
227 __entry->blockcount)
228);
229
230TRACE_EVENT(xfs_calc_max_atomic_write_log_geometry,
231 TP_PROTO(struct xfs_mount *mp, unsigned int per_intent,
232 unsigned int step_size, unsigned int blockcount,
233 unsigned int min_logblocks, unsigned int logres),
234 TP_ARGS(mp, per_intent, step_size, blockcount, min_logblocks, logres),
235 TP_STRUCT__entry(
236 __field(dev_t, dev)
237 __field(unsigned int, per_intent)
238 __field(unsigned int, step_size)
239 __field(unsigned int, blockcount)
240 __field(unsigned int, min_logblocks)
241 __field(unsigned int, cur_logblocks)
242 __field(unsigned int, logres)
243 ),
244 TP_fast_assign(
245 __entry->dev = mp->m_super->s_dev;
246 __entry->per_intent = per_intent;
247 __entry->step_size = step_size;
248 __entry->blockcount = blockcount;
249 __entry->min_logblocks = min_logblocks;
250 __entry->cur_logblocks = mp->m_sb.sb_logblocks;
251 __entry->logres = logres;
252 ),
253 TP_printk("dev %d:%d per_intent %u step_size %u blockcount %u min_logblocks %u logblocks %u logres %u",
254 MAJOR(__entry->dev), MINOR(__entry->dev),
255 __entry->per_intent,
256 __entry->step_size,
257 __entry->blockcount,
258 __entry->min_logblocks,
259 __entry->cur_logblocks,
260 __entry->logres)
261);
262
263TRACE_EVENT(xlog_intent_recovery_failed,
264 TP_PROTO(struct xfs_mount *mp, const struct xfs_defer_op_type *ops,
265 int error),
266 TP_ARGS(mp, ops, error),
267 TP_STRUCT__entry(
268 __field(dev_t, dev)
269 __string(name, ops->name)
270 __field(int, error)
271 ),
272 TP_fast_assign(
273 __entry->dev = mp->m_super->s_dev;
274 __assign_str(name);
275 __entry->error = error;
276 ),
277 TP_printk("dev %d:%d optype %s error %d",
278 MAJOR(__entry->dev), MINOR(__entry->dev),
279 __get_str(name),
280 __entry->error)
281);
282
283DECLARE_EVENT_CLASS(xfs_perag_class,
284 TP_PROTO(const struct xfs_perag *pag, unsigned long caller_ip),
285 TP_ARGS(pag, caller_ip),
286 TP_STRUCT__entry(
287 __field(dev_t, dev)
288 __field(xfs_agnumber_t, agno)
289 __field(int, refcount)
290 __field(int, active_refcount)
291 __field(unsigned long, caller_ip)
292 ),
293 TP_fast_assign(
294 __entry->dev = pag_mount(pag)->m_super->s_dev;
295 __entry->agno = pag_agno(pag);
296 __entry->refcount = atomic_read(&pag->pag_group.xg_ref);
297 __entry->active_refcount =
298 atomic_read(&pag->pag_group.xg_active_ref);
299 __entry->caller_ip = caller_ip;
300 ),
301 TP_printk("dev %d:%d agno 0x%x passive refs %d active refs %d caller %pS",
302 MAJOR(__entry->dev), MINOR(__entry->dev),
303 __entry->agno,
304 __entry->refcount,
305 __entry->active_refcount,
306 (char *)__entry->caller_ip)
307);
308
309#define DEFINE_PERAG_REF_EVENT(name) \
310DEFINE_EVENT(xfs_perag_class, name, \
311 TP_PROTO(const struct xfs_perag *pag, unsigned long caller_ip), \
312 TP_ARGS(pag, caller_ip))
313DEFINE_PERAG_REF_EVENT(xfs_perag_set_inode_tag);
314DEFINE_PERAG_REF_EVENT(xfs_perag_clear_inode_tag);
315DEFINE_PERAG_REF_EVENT(xfs_reclaim_inodes_count);
316
317TRACE_DEFINE_ENUM(XG_TYPE_AG);
318TRACE_DEFINE_ENUM(XG_TYPE_RTG);
319
320DECLARE_EVENT_CLASS(xfs_group_class,
321 TP_PROTO(struct xfs_group *xg, unsigned long caller_ip),
322 TP_ARGS(xg, caller_ip),
323 TP_STRUCT__entry(
324 __field(dev_t, dev)
325 __field(enum xfs_group_type, type)
326 __field(xfs_agnumber_t, agno)
327 __field(int, refcount)
328 __field(int, active_refcount)
329 __field(unsigned long, caller_ip)
330 ),
331 TP_fast_assign(
332 __entry->dev = xg->xg_mount->m_super->s_dev;
333 __entry->type = xg->xg_type;
334 __entry->agno = xg->xg_gno;
335 __entry->refcount = atomic_read(&xg->xg_ref);
336 __entry->active_refcount = atomic_read(&xg->xg_active_ref);
337 __entry->caller_ip = caller_ip;
338 ),
339 TP_printk("dev %d:%d %sno 0x%x passive refs %d active refs %d caller %pS",
340 MAJOR(__entry->dev), MINOR(__entry->dev),
341 __print_symbolic(__entry->type, XG_TYPE_STRINGS),
342 __entry->agno,
343 __entry->refcount,
344 __entry->active_refcount,
345 (char *)__entry->caller_ip)
346);
347
348#define DEFINE_GROUP_REF_EVENT(name) \
349DEFINE_EVENT(xfs_group_class, name, \
350 TP_PROTO(struct xfs_group *xg, unsigned long caller_ip), \
351 TP_ARGS(xg, caller_ip))
352DEFINE_GROUP_REF_EVENT(xfs_group_get);
353DEFINE_GROUP_REF_EVENT(xfs_group_hold);
354DEFINE_GROUP_REF_EVENT(xfs_group_put);
355DEFINE_GROUP_REF_EVENT(xfs_group_grab);
356DEFINE_GROUP_REF_EVENT(xfs_group_grab_next_tag);
357DEFINE_GROUP_REF_EVENT(xfs_group_rele);
358
359#ifdef CONFIG_XFS_RT
360DECLARE_EVENT_CLASS(xfs_zone_class,
361 TP_PROTO(struct xfs_rtgroup *rtg),
362 TP_ARGS(rtg),
363 TP_STRUCT__entry(
364 __field(dev_t, dev)
365 __field(xfs_rgnumber_t, rgno)
366 __field(xfs_rgblock_t, used)
367 __field(unsigned int, nr_open)
368 ),
369 TP_fast_assign(
370 struct xfs_mount *mp = rtg_mount(rtg);
371
372 __entry->dev = mp->m_super->s_dev;
373 __entry->rgno = rtg_rgno(rtg);
374 __entry->used = rtg_rmap(rtg)->i_used_blocks;
375 __entry->nr_open = mp->m_zone_info->zi_nr_open_zones;
376 ),
377 TP_printk("dev %d:%d rgno 0x%x used 0x%x nr_open %u",
378 MAJOR(__entry->dev), MINOR(__entry->dev),
379 __entry->rgno,
380 __entry->used,
381 __entry->nr_open)
382);
383
384#define DEFINE_ZONE_EVENT(name) \
385DEFINE_EVENT(xfs_zone_class, name, \
386 TP_PROTO(struct xfs_rtgroup *rtg), \
387 TP_ARGS(rtg))
388DEFINE_ZONE_EVENT(xfs_zone_emptied);
389DEFINE_ZONE_EVENT(xfs_zone_full);
390DEFINE_ZONE_EVENT(xfs_zone_opened);
391DEFINE_ZONE_EVENT(xfs_zone_reset);
392DEFINE_ZONE_EVENT(xfs_zone_gc_target_opened);
393
394TRACE_EVENT(xfs_zone_free_blocks,
395 TP_PROTO(struct xfs_rtgroup *rtg, xfs_rgblock_t rgbno,
396 xfs_extlen_t len),
397 TP_ARGS(rtg, rgbno, len),
398 TP_STRUCT__entry(
399 __field(dev_t, dev)
400 __field(xfs_rgnumber_t, rgno)
401 __field(xfs_rgblock_t, used)
402 __field(xfs_rgblock_t, rgbno)
403 __field(xfs_extlen_t, len)
404 ),
405 TP_fast_assign(
406 __entry->dev = rtg_mount(rtg)->m_super->s_dev;
407 __entry->rgno = rtg_rgno(rtg);
408 __entry->used = rtg_rmap(rtg)->i_used_blocks;
409 __entry->rgbno = rgbno;
410 __entry->len = len;
411 ),
412 TP_printk("dev %d:%d rgno 0x%x used 0x%x rgbno 0x%x len 0x%x",
413 MAJOR(__entry->dev), MINOR(__entry->dev),
414 __entry->rgno,
415 __entry->used,
416 __entry->rgbno,
417 __entry->len)
418);
419
420DECLARE_EVENT_CLASS(xfs_zone_alloc_class,
421 TP_PROTO(struct xfs_open_zone *oz, xfs_rgblock_t rgbno,
422 xfs_extlen_t len),
423 TP_ARGS(oz, rgbno, len),
424 TP_STRUCT__entry(
425 __field(dev_t, dev)
426 __field(xfs_rgnumber_t, rgno)
427 __field(xfs_rgblock_t, used)
428 __field(xfs_rgblock_t, allocated)
429 __field(xfs_rgblock_t, written)
430 __field(xfs_rgblock_t, rgbno)
431 __field(xfs_extlen_t, len)
432 ),
433 TP_fast_assign(
434 __entry->dev = rtg_mount(oz->oz_rtg)->m_super->s_dev;
435 __entry->rgno = rtg_rgno(oz->oz_rtg);
436 __entry->used = rtg_rmap(oz->oz_rtg)->i_used_blocks;
437 __entry->allocated = oz->oz_allocated;
438 __entry->written = oz->oz_written;
439 __entry->rgbno = rgbno;
440 __entry->len = len;
441 ),
442 TP_printk("dev %d:%d rgno 0x%x used 0x%x alloced 0x%x written 0x%x rgbno 0x%x len 0x%x",
443 MAJOR(__entry->dev), MINOR(__entry->dev),
444 __entry->rgno,
445 __entry->used,
446 __entry->allocated,
447 __entry->written,
448 __entry->rgbno,
449 __entry->len)
450);
451
452#define DEFINE_ZONE_ALLOC_EVENT(name) \
453DEFINE_EVENT(xfs_zone_alloc_class, name, \
454 TP_PROTO(struct xfs_open_zone *oz, xfs_rgblock_t rgbno, \
455 xfs_extlen_t len), \
456 TP_ARGS(oz, rgbno, len))
457DEFINE_ZONE_ALLOC_EVENT(xfs_zone_record_blocks);
458DEFINE_ZONE_ALLOC_EVENT(xfs_zone_skip_blocks);
459DEFINE_ZONE_ALLOC_EVENT(xfs_zone_alloc_blocks);
460
461TRACE_EVENT(xfs_zone_gc_select_victim,
462 TP_PROTO(struct xfs_rtgroup *rtg, unsigned int bucket),
463 TP_ARGS(rtg, bucket),
464 TP_STRUCT__entry(
465 __field(dev_t, dev)
466 __field(xfs_rgnumber_t, rgno)
467 __field(xfs_rgblock_t, used)
468 __field(unsigned int, bucket)
469 ),
470 TP_fast_assign(
471 __entry->dev = rtg_mount(rtg)->m_super->s_dev;
472 __entry->rgno = rtg_rgno(rtg);
473 __entry->used = rtg_rmap(rtg)->i_used_blocks;
474 __entry->bucket = bucket;
475 ),
476 TP_printk("dev %d:%d rgno 0x%x used 0x%x bucket %u",
477 MAJOR(__entry->dev), MINOR(__entry->dev),
478 __entry->rgno,
479 __entry->used,
480 __entry->bucket)
481);
482
483TRACE_EVENT(xfs_zones_mount,
484 TP_PROTO(struct xfs_mount *mp),
485 TP_ARGS(mp),
486 TP_STRUCT__entry(
487 __field(dev_t, dev)
488 __field(xfs_rgnumber_t, rgcount)
489 __field(uint32_t, blocks)
490 __field(unsigned int, max_open_zones)
491 ),
492 TP_fast_assign(
493 __entry->dev = mp->m_super->s_dev;
494 __entry->rgcount = mp->m_sb.sb_rgcount;
495 __entry->blocks = mp->m_groups[XG_TYPE_RTG].blocks;
496 __entry->max_open_zones = mp->m_max_open_zones;
497 ),
498 TP_printk("dev %d:%d zoned %u blocks_per_zone %u, max_open %u",
499 MAJOR(__entry->dev), MINOR(__entry->dev),
500 __entry->rgcount,
501 __entry->blocks,
502 __entry->max_open_zones)
503);
504#endif /* CONFIG_XFS_RT */
505
506TRACE_EVENT(xfs_inodegc_worker,
507 TP_PROTO(struct xfs_mount *mp, unsigned int shrinker_hits),
508 TP_ARGS(mp, shrinker_hits),
509 TP_STRUCT__entry(
510 __field(dev_t, dev)
511 __field(unsigned int, shrinker_hits)
512 ),
513 TP_fast_assign(
514 __entry->dev = mp->m_super->s_dev;
515 __entry->shrinker_hits = shrinker_hits;
516 ),
517 TP_printk("dev %d:%d shrinker_hits %u",
518 MAJOR(__entry->dev), MINOR(__entry->dev),
519 __entry->shrinker_hits)
520);
521
522DECLARE_EVENT_CLASS(xfs_fs_class,
523 TP_PROTO(struct xfs_mount *mp, void *caller_ip),
524 TP_ARGS(mp, caller_ip),
525 TP_STRUCT__entry(
526 __field(dev_t, dev)
527 __field(unsigned long long, mflags)
528 __field(unsigned long, opstate)
529 __field(unsigned long, sbflags)
530 __field(void *, caller_ip)
531 ),
532 TP_fast_assign(
533 if (mp) {
534 __entry->dev = mp->m_super->s_dev;
535 __entry->mflags = mp->m_features;
536 __entry->opstate = mp->m_opstate;
537 __entry->sbflags = mp->m_super->s_flags;
538 }
539 __entry->caller_ip = caller_ip;
540 ),
541 TP_printk("dev %d:%d m_features 0x%llx opstate (%s) s_flags 0x%lx caller %pS",
542 MAJOR(__entry->dev), MINOR(__entry->dev),
543 __entry->mflags,
544 __print_flags(__entry->opstate, "|", XFS_OPSTATE_STRINGS),
545 __entry->sbflags,
546 __entry->caller_ip)
547);
548
549#define DEFINE_FS_EVENT(name) \
550DEFINE_EVENT(xfs_fs_class, name, \
551 TP_PROTO(struct xfs_mount *mp, void *caller_ip), \
552 TP_ARGS(mp, caller_ip))
553DEFINE_FS_EVENT(xfs_inodegc_flush);
554DEFINE_FS_EVENT(xfs_inodegc_push);
555DEFINE_FS_EVENT(xfs_inodegc_start);
556DEFINE_FS_EVENT(xfs_inodegc_stop);
557DEFINE_FS_EVENT(xfs_inodegc_queue);
558DEFINE_FS_EVENT(xfs_inodegc_throttle);
559DEFINE_FS_EVENT(xfs_fs_sync_fs);
560DEFINE_FS_EVENT(xfs_blockgc_start);
561DEFINE_FS_EVENT(xfs_blockgc_stop);
562DEFINE_FS_EVENT(xfs_blockgc_worker);
563DEFINE_FS_EVENT(xfs_blockgc_flush_all);
564
565TRACE_EVENT(xfs_inodegc_shrinker_scan,
566 TP_PROTO(struct xfs_mount *mp, struct shrink_control *sc,
567 void *caller_ip),
568 TP_ARGS(mp, sc, caller_ip),
569 TP_STRUCT__entry(
570 __field(dev_t, dev)
571 __field(unsigned long, nr_to_scan)
572 __field(void *, caller_ip)
573 ),
574 TP_fast_assign(
575 __entry->dev = mp->m_super->s_dev;
576 __entry->nr_to_scan = sc->nr_to_scan;
577 __entry->caller_ip = caller_ip;
578 ),
579 TP_printk("dev %d:%d nr_to_scan %lu caller %pS",
580 MAJOR(__entry->dev), MINOR(__entry->dev),
581 __entry->nr_to_scan,
582 __entry->caller_ip)
583);
584
585DECLARE_EVENT_CLASS(xfs_ag_class,
586 TP_PROTO(const struct xfs_perag *pag),
587 TP_ARGS(pag),
588 TP_STRUCT__entry(
589 __field(dev_t, dev)
590 __field(xfs_agnumber_t, agno)
591 ),
592 TP_fast_assign(
593 __entry->dev = pag_mount(pag)->m_super->s_dev;
594 __entry->agno = pag_agno(pag);
595 ),
596 TP_printk("dev %d:%d agno 0x%x",
597 MAJOR(__entry->dev), MINOR(__entry->dev),
598 __entry->agno)
599);
600#define DEFINE_AG_EVENT(name) \
601DEFINE_EVENT(xfs_ag_class, name, \
602 TP_PROTO(const struct xfs_perag *pag), \
603 TP_ARGS(pag))
604
605DEFINE_AG_EVENT(xfs_read_agf);
606DEFINE_AG_EVENT(xfs_alloc_read_agf);
607DEFINE_AG_EVENT(xfs_read_agi);
608DEFINE_AG_EVENT(xfs_ialloc_read_agi);
609
610TRACE_EVENT(xfs_attr_list_node_descend,
611 TP_PROTO(struct xfs_attr_list_context *ctx,
612 struct xfs_da_node_entry *btree),
613 TP_ARGS(ctx, btree),
614 TP_STRUCT__entry(
615 __field(dev_t, dev)
616 __field(xfs_ino_t, ino)
617 __field(u32, hashval)
618 __field(u32, blkno)
619 __field(u32, offset)
620 __field(void *, buffer)
621 __field(int, bufsize)
622 __field(int, count)
623 __field(int, firstu)
624 __field(int, dupcnt)
625 __field(unsigned int, attr_filter)
626 __field(u32, bt_hashval)
627 __field(u32, bt_before)
628 ),
629 TP_fast_assign(
630 __entry->dev = VFS_I(ctx->dp)->i_sb->s_dev;
631 __entry->ino = ctx->dp->i_ino;
632 __entry->hashval = ctx->cursor.hashval;
633 __entry->blkno = ctx->cursor.blkno;
634 __entry->offset = ctx->cursor.offset;
635 __entry->buffer = ctx->buffer;
636 __entry->bufsize = ctx->bufsize;
637 __entry->count = ctx->count;
638 __entry->firstu = ctx->firstu;
639 __entry->attr_filter = ctx->attr_filter;
640 __entry->bt_hashval = be32_to_cpu(btree->hashval);
641 __entry->bt_before = be32_to_cpu(btree->before);
642 ),
643 TP_printk("dev %d:%d ino 0x%llx cursor h/b/o 0x%x/0x%x/%u dupcnt %u "
644 "buffer %p size %u count %u firstu %u filter %s "
645 "node hashval %u, node before %u",
646 MAJOR(__entry->dev), MINOR(__entry->dev),
647 __entry->ino,
648 __entry->hashval,
649 __entry->blkno,
650 __entry->offset,
651 __entry->dupcnt,
652 __entry->buffer,
653 __entry->bufsize,
654 __entry->count,
655 __entry->firstu,
656 __print_flags(__entry->attr_filter, "|",
657 XFS_ATTR_FILTER_FLAGS),
658 __entry->bt_hashval,
659 __entry->bt_before)
660);
661
662DECLARE_EVENT_CLASS(xfs_bmap_class,
663 TP_PROTO(struct xfs_inode *ip, struct xfs_iext_cursor *cur, int state,
664 unsigned long caller_ip),
665 TP_ARGS(ip, cur, state, caller_ip),
666 TP_STRUCT__entry(
667 __field(dev_t, dev)
668 __field(xfs_ino_t, ino)
669 __field(void *, leaf)
670 __field(int, pos)
671 __field(xfs_fileoff_t, startoff)
672 __field(xfs_fsblock_t, startblock)
673 __field(xfs_filblks_t, blockcount)
674 __field(xfs_exntst_t, state)
675 __field(int, bmap_state)
676 __field(unsigned long, caller_ip)
677 ),
678 TP_fast_assign(
679 struct xfs_ifork *ifp;
680 struct xfs_bmbt_irec r;
681
682 ifp = xfs_iext_state_to_fork(ip, state);
683 xfs_iext_get_extent(ifp, cur, &r);
684 __entry->dev = VFS_I(ip)->i_sb->s_dev;
685 __entry->ino = ip->i_ino;
686 __entry->leaf = cur->leaf;
687 __entry->pos = cur->pos;
688 __entry->startoff = r.br_startoff;
689 __entry->startblock = r.br_startblock;
690 __entry->blockcount = r.br_blockcount;
691 __entry->state = r.br_state;
692 __entry->bmap_state = state;
693 __entry->caller_ip = caller_ip;
694 ),
695 TP_printk("dev %d:%d ino 0x%llx state %s cur %p/%d "
696 "fileoff 0x%llx startblock 0x%llx fsbcount 0x%llx flag %d caller %pS",
697 MAJOR(__entry->dev), MINOR(__entry->dev),
698 __entry->ino,
699 __print_flags(__entry->bmap_state, "|", XFS_BMAP_EXT_FLAGS),
700 __entry->leaf,
701 __entry->pos,
702 __entry->startoff,
703 (int64_t)__entry->startblock,
704 __entry->blockcount,
705 __entry->state,
706 (char *)__entry->caller_ip)
707)
708
709#define DEFINE_BMAP_EVENT(name) \
710DEFINE_EVENT(xfs_bmap_class, name, \
711 TP_PROTO(struct xfs_inode *ip, struct xfs_iext_cursor *cur, int state, \
712 unsigned long caller_ip), \
713 TP_ARGS(ip, cur, state, caller_ip))
714DEFINE_BMAP_EVENT(xfs_iext_insert);
715DEFINE_BMAP_EVENT(xfs_iext_remove);
716DEFINE_BMAP_EVENT(xfs_bmap_pre_update);
717DEFINE_BMAP_EVENT(xfs_bmap_post_update);
718DEFINE_BMAP_EVENT(xfs_read_extent);
719DEFINE_BMAP_EVENT(xfs_write_extent);
720
721DECLARE_EVENT_CLASS(xfs_buf_class,
722 TP_PROTO(struct xfs_buf *bp, unsigned long caller_ip),
723 TP_ARGS(bp, caller_ip),
724 TP_STRUCT__entry(
725 __field(dev_t, dev)
726 __field(xfs_daddr_t, bno)
727 __field(int, nblks)
728 __field(int, hold)
729 __field(int, pincount)
730 __field(unsigned, lockval)
731 __field(unsigned, flags)
732 __field(unsigned long, caller_ip)
733 __field(const void *, buf_ops)
734 ),
735 TP_fast_assign(
736 __entry->dev = bp->b_target->bt_dev;
737 __entry->bno = xfs_buf_daddr(bp);
738 __entry->nblks = bp->b_length;
739 __entry->hold = bp->b_hold;
740 __entry->pincount = atomic_read(&bp->b_pin_count);
741 __entry->lockval = bp->b_sema.count;
742 __entry->flags = bp->b_flags;
743 __entry->caller_ip = caller_ip;
744 __entry->buf_ops = bp->b_ops;
745 ),
746 TP_printk("dev %d:%d daddr 0x%llx bbcount 0x%x hold %d pincount %d "
747 "lock %d flags %s bufops %pS caller %pS",
748 MAJOR(__entry->dev), MINOR(__entry->dev),
749 (unsigned long long)__entry->bno,
750 __entry->nblks,
751 __entry->hold,
752 __entry->pincount,
753 __entry->lockval,
754 __print_flags(__entry->flags, "|", XFS_BUF_FLAGS),
755 __entry->buf_ops,
756 (void *)__entry->caller_ip)
757)
758
759#define DEFINE_BUF_EVENT(name) \
760DEFINE_EVENT(xfs_buf_class, name, \
761 TP_PROTO(struct xfs_buf *bp, unsigned long caller_ip), \
762 TP_ARGS(bp, caller_ip))
763DEFINE_BUF_EVENT(xfs_buf_init);
764DEFINE_BUF_EVENT(xfs_buf_free);
765DEFINE_BUF_EVENT(xfs_buf_hold);
766DEFINE_BUF_EVENT(xfs_buf_rele);
767DEFINE_BUF_EVENT(xfs_buf_iodone);
768DEFINE_BUF_EVENT(xfs_buf_submit);
769DEFINE_BUF_EVENT(xfs_buf_lock);
770DEFINE_BUF_EVENT(xfs_buf_lock_done);
771DEFINE_BUF_EVENT(xfs_buf_trylock_fail);
772DEFINE_BUF_EVENT(xfs_buf_trylock);
773DEFINE_BUF_EVENT(xfs_buf_unlock);
774DEFINE_BUF_EVENT(xfs_buf_iowait);
775DEFINE_BUF_EVENT(xfs_buf_iowait_done);
776DEFINE_BUF_EVENT(xfs_buf_delwri_queue);
777DEFINE_BUF_EVENT(xfs_buf_delwri_queued);
778DEFINE_BUF_EVENT(xfs_buf_delwri_split);
779DEFINE_BUF_EVENT(xfs_buf_get_uncached);
780DEFINE_BUF_EVENT(xfs_buf_item_relse);
781DEFINE_BUF_EVENT(xfs_buf_iodone_async);
782DEFINE_BUF_EVENT(xfs_buf_error_relse);
783DEFINE_BUF_EVENT(xfs_buf_drain_buftarg);
784DEFINE_BUF_EVENT(xfs_trans_read_buf_shut);
785DEFINE_BUF_EVENT(xfs_buf_backing_folio);
786DEFINE_BUF_EVENT(xfs_buf_backing_kmem);
787DEFINE_BUF_EVENT(xfs_buf_backing_vmalloc);
788DEFINE_BUF_EVENT(xfs_buf_backing_fallback);
789
790/* not really buffer traces, but the buf provides useful information */
791DEFINE_BUF_EVENT(xfs_btree_corrupt);
792DEFINE_BUF_EVENT(xfs_reset_dqcounts);
793
794/* pass flags explicitly */
795DECLARE_EVENT_CLASS(xfs_buf_flags_class,
796 TP_PROTO(struct xfs_buf *bp, unsigned flags, unsigned long caller_ip),
797 TP_ARGS(bp, flags, caller_ip),
798 TP_STRUCT__entry(
799 __field(dev_t, dev)
800 __field(xfs_daddr_t, bno)
801 __field(unsigned int, length)
802 __field(int, hold)
803 __field(int, pincount)
804 __field(unsigned, lockval)
805 __field(unsigned, flags)
806 __field(unsigned long, caller_ip)
807 ),
808 TP_fast_assign(
809 __entry->dev = bp->b_target->bt_dev;
810 __entry->bno = xfs_buf_daddr(bp);
811 __entry->length = bp->b_length;
812 __entry->flags = flags;
813 __entry->hold = bp->b_hold;
814 __entry->pincount = atomic_read(&bp->b_pin_count);
815 __entry->lockval = bp->b_sema.count;
816 __entry->caller_ip = caller_ip;
817 ),
818 TP_printk("dev %d:%d daddr 0x%llx bbcount 0x%x hold %d pincount %d "
819 "lock %d flags %s caller %pS",
820 MAJOR(__entry->dev), MINOR(__entry->dev),
821 (unsigned long long)__entry->bno,
822 __entry->length,
823 __entry->hold,
824 __entry->pincount,
825 __entry->lockval,
826 __print_flags(__entry->flags, "|", XFS_BUF_FLAGS),
827 (void *)__entry->caller_ip)
828)
829
830#define DEFINE_BUF_FLAGS_EVENT(name) \
831DEFINE_EVENT(xfs_buf_flags_class, name, \
832 TP_PROTO(struct xfs_buf *bp, unsigned flags, unsigned long caller_ip), \
833 TP_ARGS(bp, flags, caller_ip))
834DEFINE_BUF_FLAGS_EVENT(xfs_buf_find);
835DEFINE_BUF_FLAGS_EVENT(xfs_buf_get);
836DEFINE_BUF_FLAGS_EVENT(xfs_buf_read);
837DEFINE_BUF_FLAGS_EVENT(xfs_buf_readahead);
838
839TRACE_EVENT(xfs_buf_ioerror,
840 TP_PROTO(struct xfs_buf *bp, int error, xfs_failaddr_t caller_ip),
841 TP_ARGS(bp, error, caller_ip),
842 TP_STRUCT__entry(
843 __field(dev_t, dev)
844 __field(xfs_daddr_t, bno)
845 __field(unsigned int, length)
846 __field(unsigned, flags)
847 __field(int, hold)
848 __field(int, pincount)
849 __field(unsigned, lockval)
850 __field(int, error)
851 __field(xfs_failaddr_t, caller_ip)
852 ),
853 TP_fast_assign(
854 __entry->dev = bp->b_target->bt_dev;
855 __entry->bno = xfs_buf_daddr(bp);
856 __entry->length = bp->b_length;
857 __entry->hold = bp->b_hold;
858 __entry->pincount = atomic_read(&bp->b_pin_count);
859 __entry->lockval = bp->b_sema.count;
860 __entry->error = error;
861 __entry->flags = bp->b_flags;
862 __entry->caller_ip = caller_ip;
863 ),
864 TP_printk("dev %d:%d daddr 0x%llx bbcount 0x%x hold %d pincount %d "
865 "lock %d error %d flags %s caller %pS",
866 MAJOR(__entry->dev), MINOR(__entry->dev),
867 (unsigned long long)__entry->bno,
868 __entry->length,
869 __entry->hold,
870 __entry->pincount,
871 __entry->lockval,
872 __entry->error,
873 __print_flags(__entry->flags, "|", XFS_BUF_FLAGS),
874 (void *)__entry->caller_ip)
875);
876
877DECLARE_EVENT_CLASS(xfs_buf_item_class,
878 TP_PROTO(struct xfs_buf_log_item *bip),
879 TP_ARGS(bip),
880 TP_STRUCT__entry(
881 __field(dev_t, dev)
882 __field(xfs_daddr_t, buf_bno)
883 __field(unsigned int, buf_len)
884 __field(int, buf_hold)
885 __field(int, buf_pincount)
886 __field(int, buf_lockval)
887 __field(unsigned, buf_flags)
888 __field(unsigned, bli_recur)
889 __field(int, bli_refcount)
890 __field(unsigned, bli_flags)
891 __field(unsigned long, li_flags)
892 ),
893 TP_fast_assign(
894 __entry->dev = bip->bli_buf->b_target->bt_dev;
895 __entry->bli_flags = bip->bli_flags;
896 __entry->bli_recur = bip->bli_recur;
897 __entry->bli_refcount = atomic_read(&bip->bli_refcount);
898 __entry->buf_bno = xfs_buf_daddr(bip->bli_buf);
899 __entry->buf_len = bip->bli_buf->b_length;
900 __entry->buf_flags = bip->bli_buf->b_flags;
901 __entry->buf_hold = bip->bli_buf->b_hold;
902 __entry->buf_pincount = atomic_read(&bip->bli_buf->b_pin_count);
903 __entry->buf_lockval = bip->bli_buf->b_sema.count;
904 __entry->li_flags = bip->bli_item.li_flags;
905 ),
906 TP_printk("dev %d:%d daddr 0x%llx bbcount 0x%x hold %d pincount %d "
907 "lock %d flags %s recur %d refcount %d bliflags %s "
908 "liflags %s",
909 MAJOR(__entry->dev), MINOR(__entry->dev),
910 (unsigned long long)__entry->buf_bno,
911 __entry->buf_len,
912 __entry->buf_hold,
913 __entry->buf_pincount,
914 __entry->buf_lockval,
915 __print_flags(__entry->buf_flags, "|", XFS_BUF_FLAGS),
916 __entry->bli_recur,
917 __entry->bli_refcount,
918 __print_flags(__entry->bli_flags, "|", XFS_BLI_FLAGS),
919 __print_flags(__entry->li_flags, "|", XFS_LI_FLAGS))
920)
921
922#define DEFINE_BUF_ITEM_EVENT(name) \
923DEFINE_EVENT(xfs_buf_item_class, name, \
924 TP_PROTO(struct xfs_buf_log_item *bip), \
925 TP_ARGS(bip))
926DEFINE_BUF_ITEM_EVENT(xfs_buf_item_size);
927DEFINE_BUF_ITEM_EVENT(xfs_buf_item_size_ordered);
928DEFINE_BUF_ITEM_EVENT(xfs_buf_item_size_stale);
929DEFINE_BUF_ITEM_EVENT(xfs_buf_item_format);
930DEFINE_BUF_ITEM_EVENT(xfs_buf_item_format_stale);
931DEFINE_BUF_ITEM_EVENT(xfs_buf_item_ordered);
932DEFINE_BUF_ITEM_EVENT(xfs_buf_item_pin);
933DEFINE_BUF_ITEM_EVENT(xfs_buf_item_unpin);
934DEFINE_BUF_ITEM_EVENT(xfs_buf_item_unpin_stale);
935DEFINE_BUF_ITEM_EVENT(xfs_buf_item_release);
936DEFINE_BUF_ITEM_EVENT(xfs_buf_item_committed);
937DEFINE_BUF_ITEM_EVENT(xfs_buf_item_push);
938DEFINE_BUF_ITEM_EVENT(xfs_trans_get_buf);
939DEFINE_BUF_ITEM_EVENT(xfs_trans_get_buf_recur);
940DEFINE_BUF_ITEM_EVENT(xfs_trans_getsb);
941DEFINE_BUF_ITEM_EVENT(xfs_trans_getsb_recur);
942DEFINE_BUF_ITEM_EVENT(xfs_trans_read_buf);
943DEFINE_BUF_ITEM_EVENT(xfs_trans_read_buf_recur);
944DEFINE_BUF_ITEM_EVENT(xfs_trans_log_buf);
945DEFINE_BUF_ITEM_EVENT(xfs_trans_brelse);
946DEFINE_BUF_ITEM_EVENT(xfs_trans_bdetach);
947DEFINE_BUF_ITEM_EVENT(xfs_trans_bjoin);
948DEFINE_BUF_ITEM_EVENT(xfs_trans_bhold);
949DEFINE_BUF_ITEM_EVENT(xfs_trans_bhold_release);
950DEFINE_BUF_ITEM_EVENT(xfs_trans_binval);
951
952DECLARE_EVENT_CLASS(xfs_filestream_class,
953 TP_PROTO(const struct xfs_perag *pag, xfs_ino_t ino),
954 TP_ARGS(pag, ino),
955 TP_STRUCT__entry(
956 __field(dev_t, dev)
957 __field(xfs_ino_t, ino)
958 __field(xfs_agnumber_t, agno)
959 __field(int, streams)
960 ),
961 TP_fast_assign(
962 __entry->dev = pag_mount(pag)->m_super->s_dev;
963 __entry->ino = ino;
964 __entry->agno = pag_agno(pag);
965 __entry->streams = atomic_read(&pag->pagf_fstrms);
966 ),
967 TP_printk("dev %d:%d ino 0x%llx agno 0x%x streams %d",
968 MAJOR(__entry->dev), MINOR(__entry->dev),
969 __entry->ino,
970 __entry->agno,
971 __entry->streams)
972)
973#define DEFINE_FILESTREAM_EVENT(name) \
974DEFINE_EVENT(xfs_filestream_class, name, \
975 TP_PROTO(const struct xfs_perag *pag, xfs_ino_t ino), \
976 TP_ARGS(pag, ino))
977DEFINE_FILESTREAM_EVENT(xfs_filestream_free);
978DEFINE_FILESTREAM_EVENT(xfs_filestream_lookup);
979DEFINE_FILESTREAM_EVENT(xfs_filestream_scan);
980
981TRACE_EVENT(xfs_filestream_pick,
982 TP_PROTO(const struct xfs_perag *pag, xfs_ino_t ino),
983 TP_ARGS(pag, ino),
984 TP_STRUCT__entry(
985 __field(dev_t, dev)
986 __field(xfs_ino_t, ino)
987 __field(xfs_agnumber_t, agno)
988 __field(int, streams)
989 __field(xfs_extlen_t, free)
990 ),
991 TP_fast_assign(
992 __entry->dev = pag_mount(pag)->m_super->s_dev;
993 __entry->ino = ino;
994 __entry->agno = pag_agno(pag);
995 __entry->streams = atomic_read(&pag->pagf_fstrms);
996 __entry->free = pag->pagf_freeblks;
997 ),
998 TP_printk("dev %d:%d ino 0x%llx agno 0x%x streams %d free %d",
999 MAJOR(__entry->dev), MINOR(__entry->dev),
1000 __entry->ino,
1001 __entry->agno,
1002 __entry->streams,
1003 __entry->free)
1004);
1005
1006DECLARE_EVENT_CLASS(xfs_lock_class,
1007 TP_PROTO(struct xfs_inode *ip, unsigned lock_flags,
1008 unsigned long caller_ip),
1009 TP_ARGS(ip, lock_flags, caller_ip),
1010 TP_STRUCT__entry(
1011 __field(dev_t, dev)
1012 __field(xfs_ino_t, ino)
1013 __field(int, lock_flags)
1014 __field(unsigned long, caller_ip)
1015 ),
1016 TP_fast_assign(
1017 __entry->dev = VFS_I(ip)->i_sb->s_dev;
1018 __entry->ino = ip->i_ino;
1019 __entry->lock_flags = lock_flags;
1020 __entry->caller_ip = caller_ip;
1021 ),
1022 TP_printk("dev %d:%d ino 0x%llx flags %s caller %pS",
1023 MAJOR(__entry->dev), MINOR(__entry->dev),
1024 __entry->ino,
1025 __print_flags(__entry->lock_flags, "|", XFS_LOCK_FLAGS),
1026 (void *)__entry->caller_ip)
1027)
1028
1029#define DEFINE_LOCK_EVENT(name) \
1030DEFINE_EVENT(xfs_lock_class, name, \
1031 TP_PROTO(struct xfs_inode *ip, unsigned lock_flags, \
1032 unsigned long caller_ip), \
1033 TP_ARGS(ip, lock_flags, caller_ip))
1034DEFINE_LOCK_EVENT(xfs_ilock);
1035DEFINE_LOCK_EVENT(xfs_ilock_nowait);
1036DEFINE_LOCK_EVENT(xfs_ilock_demote);
1037DEFINE_LOCK_EVENT(xfs_iunlock);
1038
1039DECLARE_EVENT_CLASS(xfs_inode_class,
1040 TP_PROTO(struct xfs_inode *ip),
1041 TP_ARGS(ip),
1042 TP_STRUCT__entry(
1043 __field(dev_t, dev)
1044 __field(xfs_ino_t, ino)
1045 __field(unsigned long, iflags)
1046 ),
1047 TP_fast_assign(
1048 __entry->dev = VFS_I(ip)->i_sb->s_dev;
1049 __entry->ino = ip->i_ino;
1050 __entry->iflags = ip->i_flags;
1051 ),
1052 TP_printk("dev %d:%d ino 0x%llx iflags 0x%lx",
1053 MAJOR(__entry->dev), MINOR(__entry->dev),
1054 __entry->ino,
1055 __entry->iflags)
1056)
1057
1058#define DEFINE_INODE_EVENT(name) \
1059DEFINE_EVENT(xfs_inode_class, name, \
1060 TP_PROTO(struct xfs_inode *ip), \
1061 TP_ARGS(ip))
1062DEFINE_INODE_EVENT(xfs_iget_skip);
1063DEFINE_INODE_EVENT(xfs_iget_recycle);
1064DEFINE_INODE_EVENT(xfs_iget_recycle_fail);
1065DEFINE_INODE_EVENT(xfs_iget_hit);
1066DEFINE_INODE_EVENT(xfs_iget_miss);
1067
1068DEFINE_INODE_EVENT(xfs_getattr);
1069DEFINE_INODE_EVENT(xfs_setattr);
1070DEFINE_INODE_EVENT(xfs_readlink);
1071DEFINE_INODE_EVENT(xfs_inactive_symlink);
1072DEFINE_INODE_EVENT(xfs_alloc_file_space);
1073DEFINE_INODE_EVENT(xfs_free_file_space);
1074DEFINE_INODE_EVENT(xfs_zero_file_space);
1075DEFINE_INODE_EVENT(xfs_collapse_file_space);
1076DEFINE_INODE_EVENT(xfs_insert_file_space);
1077DEFINE_INODE_EVENT(xfs_readdir);
1078#ifdef CONFIG_XFS_POSIX_ACL
1079DEFINE_INODE_EVENT(xfs_get_acl);
1080#endif
1081DEFINE_INODE_EVENT(xfs_vm_bmap);
1082DEFINE_INODE_EVENT(xfs_file_ioctl);
1083#ifdef CONFIG_COMPAT
1084DEFINE_INODE_EVENT(xfs_file_compat_ioctl);
1085#endif
1086DEFINE_INODE_EVENT(xfs_ioctl_setattr);
1087DEFINE_INODE_EVENT(xfs_dir_fsync);
1088DEFINE_INODE_EVENT(xfs_file_fsync);
1089DEFINE_INODE_EVENT(xfs_destroy_inode);
1090DEFINE_INODE_EVENT(xfs_update_time);
1091
1092DEFINE_INODE_EVENT(xfs_dquot_dqalloc);
1093DEFINE_INODE_EVENT(xfs_dquot_dqdetach);
1094
1095DEFINE_INODE_EVENT(xfs_inode_set_eofblocks_tag);
1096DEFINE_INODE_EVENT(xfs_inode_clear_eofblocks_tag);
1097DEFINE_INODE_EVENT(xfs_inode_free_eofblocks_invalid);
1098DEFINE_INODE_EVENT(xfs_inode_set_cowblocks_tag);
1099DEFINE_INODE_EVENT(xfs_inode_clear_cowblocks_tag);
1100DEFINE_INODE_EVENT(xfs_inode_free_cowblocks_invalid);
1101DEFINE_INODE_EVENT(xfs_inode_set_reclaimable);
1102DEFINE_INODE_EVENT(xfs_inode_reclaiming);
1103DEFINE_INODE_EVENT(xfs_inode_set_need_inactive);
1104DEFINE_INODE_EVENT(xfs_inode_inactivating);
1105
1106/*
1107 * ftrace's __print_symbolic requires that all enum values be wrapped in the
1108 * TRACE_DEFINE_ENUM macro so that the enum value can be encoded in the ftrace
1109 * ring buffer. Somehow this was only worth mentioning in the ftrace sample
1110 * code.
1111 */
1112TRACE_DEFINE_ENUM(XFS_REFC_DOMAIN_SHARED);
1113TRACE_DEFINE_ENUM(XFS_REFC_DOMAIN_COW);
1114
1115DECLARE_EVENT_CLASS(xfs_fault_class,
1116 TP_PROTO(struct xfs_inode *ip, unsigned int order),
1117 TP_ARGS(ip, order),
1118 TP_STRUCT__entry(
1119 __field(dev_t, dev)
1120 __field(xfs_ino_t, ino)
1121 __field(unsigned int, order)
1122 ),
1123 TP_fast_assign(
1124 __entry->dev = VFS_I(ip)->i_sb->s_dev;
1125 __entry->ino = ip->i_ino;
1126 __entry->order = order;
1127 ),
1128 TP_printk("dev %d:%d ino 0x%llx order %u",
1129 MAJOR(__entry->dev), MINOR(__entry->dev),
1130 __entry->ino,
1131 __entry->order)
1132)
1133
1134#define DEFINE_FAULT_EVENT(name) \
1135DEFINE_EVENT(xfs_fault_class, name, \
1136 TP_PROTO(struct xfs_inode *ip, unsigned int order), \
1137 TP_ARGS(ip, order))
1138DEFINE_FAULT_EVENT(xfs_read_fault);
1139DEFINE_FAULT_EVENT(xfs_write_fault);
1140
1141DECLARE_EVENT_CLASS(xfs_iref_class,
1142 TP_PROTO(struct xfs_inode *ip, unsigned long caller_ip),
1143 TP_ARGS(ip, caller_ip),
1144 TP_STRUCT__entry(
1145 __field(dev_t, dev)
1146 __field(xfs_ino_t, ino)
1147 __field(int, count)
1148 __field(int, pincount)
1149 __field(unsigned long, iflags)
1150 __field(unsigned long, caller_ip)
1151 ),
1152 TP_fast_assign(
1153 __entry->dev = VFS_I(ip)->i_sb->s_dev;
1154 __entry->ino = ip->i_ino;
1155 __entry->count = icount_read(VFS_I(ip));
1156 __entry->pincount = atomic_read(&ip->i_pincount);
1157 __entry->iflags = ip->i_flags;
1158 __entry->caller_ip = caller_ip;
1159 ),
1160 TP_printk("dev %d:%d ino 0x%llx count %d pincount %d iflags 0x%lx caller %pS",
1161 MAJOR(__entry->dev), MINOR(__entry->dev),
1162 __entry->ino,
1163 __entry->count,
1164 __entry->pincount,
1165 __entry->iflags,
1166 (char *)__entry->caller_ip)
1167)
1168
1169TRACE_EVENT(xfs_iomap_prealloc_size,
1170 TP_PROTO(struct xfs_inode *ip, xfs_fsblock_t blocks, int shift,
1171 unsigned int writeio_blocks),
1172 TP_ARGS(ip, blocks, shift, writeio_blocks),
1173 TP_STRUCT__entry(
1174 __field(dev_t, dev)
1175 __field(xfs_ino_t, ino)
1176 __field(xfs_fsblock_t, blocks)
1177 __field(int, shift)
1178 __field(unsigned int, writeio_blocks)
1179 ),
1180 TP_fast_assign(
1181 __entry->dev = VFS_I(ip)->i_sb->s_dev;
1182 __entry->ino = ip->i_ino;
1183 __entry->blocks = blocks;
1184 __entry->shift = shift;
1185 __entry->writeio_blocks = writeio_blocks;
1186 ),
1187 TP_printk("dev %d:%d ino 0x%llx prealloc blocks %llu shift %d "
1188 "m_allocsize_blocks %u",
1189 MAJOR(__entry->dev), MINOR(__entry->dev), __entry->ino,
1190 __entry->blocks, __entry->shift, __entry->writeio_blocks)
1191)
1192
1193TRACE_EVENT(xfs_irec_merge_pre,
1194 TP_PROTO(const struct xfs_perag *pag,
1195 const struct xfs_inobt_rec_incore *rec,
1196 const struct xfs_inobt_rec_incore *nrec),
1197 TP_ARGS(pag, rec, nrec),
1198 TP_STRUCT__entry(
1199 __field(dev_t, dev)
1200 __field(xfs_agnumber_t, agno)
1201 __field(xfs_agino_t, agino)
1202 __field(uint16_t, holemask)
1203 __field(xfs_agino_t, nagino)
1204 __field(uint16_t, nholemask)
1205 ),
1206 TP_fast_assign(
1207 __entry->dev = pag_mount(pag)->m_super->s_dev;
1208 __entry->agno = pag_agno(pag);
1209 __entry->agino = rec->ir_startino;
1210 __entry->holemask = rec->ir_holemask;
1211 __entry->nagino = nrec->ir_startino;
1212 __entry->nholemask = nrec->ir_holemask;
1213 ),
1214 TP_printk("dev %d:%d agno 0x%x agino 0x%x holemask 0x%x new_agino 0x%x new_holemask 0x%x",
1215 MAJOR(__entry->dev), MINOR(__entry->dev),
1216 __entry->agno,
1217 __entry->agino,
1218 __entry->holemask,
1219 __entry->nagino,
1220 __entry->nholemask)
1221)
1222
1223TRACE_EVENT(xfs_irec_merge_post,
1224 TP_PROTO(const struct xfs_perag *pag,
1225 const struct xfs_inobt_rec_incore *nrec),
1226 TP_ARGS(pag, nrec),
1227 TP_STRUCT__entry(
1228 __field(dev_t, dev)
1229 __field(xfs_agnumber_t, agno)
1230 __field(xfs_agino_t, agino)
1231 __field(uint16_t, holemask)
1232 ),
1233 TP_fast_assign(
1234 __entry->dev = pag_mount(pag)->m_super->s_dev;
1235 __entry->agno = pag_agno(pag);
1236 __entry->agino = nrec->ir_startino;
1237 __entry->holemask = nrec->ir_holemask;
1238 ),
1239 TP_printk("dev %d:%d agno 0x%x agino 0x%x holemask 0x%x",
1240 MAJOR(__entry->dev),
1241 MINOR(__entry->dev),
1242 __entry->agno,
1243 __entry->agino,
1244 __entry->holemask)
1245)
1246
1247#define DEFINE_IREF_EVENT(name) \
1248DEFINE_EVENT(xfs_iref_class, name, \
1249 TP_PROTO(struct xfs_inode *ip, unsigned long caller_ip), \
1250 TP_ARGS(ip, caller_ip))
1251DEFINE_IREF_EVENT(xfs_irele);
1252DEFINE_IREF_EVENT(xfs_inode_pin);
1253DEFINE_IREF_EVENT(xfs_inode_unpin);
1254DEFINE_IREF_EVENT(xfs_inode_unpin_nowait);
1255DEFINE_IREF_EVENT(xfs_inode_push_pinned);
1256DEFINE_IREF_EVENT(xfs_inode_push_stale);
1257
1258DECLARE_EVENT_CLASS(xfs_namespace_class,
1259 TP_PROTO(struct xfs_inode *dp, const struct xfs_name *name),
1260 TP_ARGS(dp, name),
1261 TP_STRUCT__entry(
1262 __field(dev_t, dev)
1263 __field(xfs_ino_t, dp_ino)
1264 __field(int, namelen)
1265 __dynamic_array(char, name, name->len)
1266 ),
1267 TP_fast_assign(
1268 __entry->dev = VFS_I(dp)->i_sb->s_dev;
1269 __entry->dp_ino = dp->i_ino;
1270 __entry->namelen = name->len;
1271 memcpy(__get_str(name), name->name, name->len);
1272 ),
1273 TP_printk("dev %d:%d dp ino 0x%llx name %.*s",
1274 MAJOR(__entry->dev), MINOR(__entry->dev),
1275 __entry->dp_ino,
1276 __entry->namelen,
1277 __get_str(name))
1278)
1279
1280#define DEFINE_NAMESPACE_EVENT(name) \
1281DEFINE_EVENT(xfs_namespace_class, name, \
1282 TP_PROTO(struct xfs_inode *dp, const struct xfs_name *name), \
1283 TP_ARGS(dp, name))
1284DEFINE_NAMESPACE_EVENT(xfs_remove);
1285DEFINE_NAMESPACE_EVENT(xfs_link);
1286DEFINE_NAMESPACE_EVENT(xfs_lookup);
1287DEFINE_NAMESPACE_EVENT(xfs_create);
1288DEFINE_NAMESPACE_EVENT(xfs_symlink);
1289
1290TRACE_EVENT(xfs_rename,
1291 TP_PROTO(struct xfs_inode *src_dp, struct xfs_inode *target_dp,
1292 struct xfs_name *src_name, struct xfs_name *target_name),
1293 TP_ARGS(src_dp, target_dp, src_name, target_name),
1294 TP_STRUCT__entry(
1295 __field(dev_t, dev)
1296 __field(xfs_ino_t, src_dp_ino)
1297 __field(xfs_ino_t, target_dp_ino)
1298 __field(int, src_namelen)
1299 __field(int, target_namelen)
1300 __dynamic_array(char, src_name, src_name->len)
1301 __dynamic_array(char, target_name, target_name->len)
1302 ),
1303 TP_fast_assign(
1304 __entry->dev = VFS_I(src_dp)->i_sb->s_dev;
1305 __entry->src_dp_ino = src_dp->i_ino;
1306 __entry->target_dp_ino = target_dp->i_ino;
1307 __entry->src_namelen = src_name->len;
1308 __entry->target_namelen = target_name->len;
1309 memcpy(__get_str(src_name), src_name->name, src_name->len);
1310 memcpy(__get_str(target_name), target_name->name,
1311 target_name->len);
1312 ),
1313 TP_printk("dev %d:%d src dp ino 0x%llx target dp ino 0x%llx"
1314 " src name %.*s target name %.*s",
1315 MAJOR(__entry->dev), MINOR(__entry->dev),
1316 __entry->src_dp_ino,
1317 __entry->target_dp_ino,
1318 __entry->src_namelen,
1319 __get_str(src_name),
1320 __entry->target_namelen,
1321 __get_str(target_name))
1322)
1323
1324DECLARE_EVENT_CLASS(xfs_dquot_class,
1325 TP_PROTO(struct xfs_dquot *dqp),
1326 TP_ARGS(dqp),
1327 TP_STRUCT__entry(
1328 __field(dev_t, dev)
1329 __field(u32, id)
1330 __field(xfs_dqtype_t, type)
1331 __field(unsigned, flags)
1332 __field(unsigned, nrefs)
1333 __field(unsigned long long, res_bcount)
1334 __field(unsigned long long, res_rtbcount)
1335 __field(unsigned long long, res_icount)
1336
1337 __field(unsigned long long, bcount)
1338 __field(unsigned long long, rtbcount)
1339 __field(unsigned long long, icount)
1340
1341 __field(unsigned long long, blk_hardlimit)
1342 __field(unsigned long long, blk_softlimit)
1343 __field(unsigned long long, rtb_hardlimit)
1344 __field(unsigned long long, rtb_softlimit)
1345 __field(unsigned long long, ino_hardlimit)
1346 __field(unsigned long long, ino_softlimit)
1347 ),
1348 TP_fast_assign(
1349 __entry->dev = dqp->q_mount->m_super->s_dev;
1350 __entry->id = dqp->q_id;
1351 __entry->type = dqp->q_type;
1352 __entry->flags = dqp->q_flags;
1353 __entry->nrefs = data_race(dqp->q_lockref.count);
1354
1355 __entry->res_bcount = dqp->q_blk.reserved;
1356 __entry->res_rtbcount = dqp->q_rtb.reserved;
1357 __entry->res_icount = dqp->q_ino.reserved;
1358
1359 __entry->bcount = dqp->q_blk.count;
1360 __entry->rtbcount = dqp->q_rtb.count;
1361 __entry->icount = dqp->q_ino.count;
1362
1363 __entry->blk_hardlimit = dqp->q_blk.hardlimit;
1364 __entry->blk_softlimit = dqp->q_blk.softlimit;
1365 __entry->rtb_hardlimit = dqp->q_rtb.hardlimit;
1366 __entry->rtb_softlimit = dqp->q_rtb.softlimit;
1367 __entry->ino_hardlimit = dqp->q_ino.hardlimit;
1368 __entry->ino_softlimit = dqp->q_ino.softlimit;
1369 ),
1370 TP_printk("dev %d:%d id 0x%x type %s flags %s nrefs %u "
1371 "res_bc 0x%llx res_rtbc 0x%llx res_ic 0x%llx "
1372 "bcnt 0x%llx bhardlimit 0x%llx bsoftlimit 0x%llx "
1373 "rtbcnt 0x%llx rtbhardlimit 0x%llx rtbsoftlimit 0x%llx "
1374 "icnt 0x%llx ihardlimit 0x%llx isoftlimit 0x%llx]",
1375 MAJOR(__entry->dev), MINOR(__entry->dev),
1376 __entry->id,
1377 __print_flags(__entry->type, "|", XFS_DQTYPE_STRINGS),
1378 __print_flags(__entry->flags, "|", XFS_DQFLAG_STRINGS),
1379 __entry->nrefs,
1380 __entry->res_bcount,
1381 __entry->res_rtbcount,
1382 __entry->res_icount,
1383 __entry->bcount,
1384 __entry->blk_hardlimit,
1385 __entry->blk_softlimit,
1386 __entry->rtbcount,
1387 __entry->rtb_hardlimit,
1388 __entry->rtb_softlimit,
1389 __entry->icount,
1390 __entry->ino_hardlimit,
1391 __entry->ino_softlimit)
1392)
1393
1394#define DEFINE_DQUOT_EVENT(name) \
1395DEFINE_EVENT(xfs_dquot_class, name, \
1396 TP_PROTO(struct xfs_dquot *dqp), \
1397 TP_ARGS(dqp))
1398DEFINE_DQUOT_EVENT(xfs_dqadjust);
1399DEFINE_DQUOT_EVENT(xfs_dqreclaim_want);
1400DEFINE_DQUOT_EVENT(xfs_dqreclaim_busy);
1401DEFINE_DQUOT_EVENT(xfs_dqreclaim_done);
1402DEFINE_DQUOT_EVENT(xfs_dqattach_get);
1403DEFINE_DQUOT_EVENT(xfs_dqalloc);
1404DEFINE_DQUOT_EVENT(xfs_dqtobp_read);
1405DEFINE_DQUOT_EVENT(xfs_dqread);
1406DEFINE_DQUOT_EVENT(xfs_dqread_fail);
1407DEFINE_DQUOT_EVENT(xfs_dqget_hit);
1408DEFINE_DQUOT_EVENT(xfs_dqget_miss);
1409DEFINE_DQUOT_EVENT(xfs_dqget_freeing);
1410DEFINE_DQUOT_EVENT(xfs_dqget_dup);
1411DEFINE_DQUOT_EVENT(xfs_dqrele);
1412DEFINE_DQUOT_EVENT(xfs_dqrele_free);
1413DEFINE_DQUOT_EVENT(xfs_dqflush);
1414DEFINE_DQUOT_EVENT(xfs_dqflush_force);
1415DEFINE_DQUOT_EVENT(xfs_dqflush_done);
1416DEFINE_DQUOT_EVENT(xfs_trans_apply_dquot_deltas_before);
1417DEFINE_DQUOT_EVENT(xfs_trans_apply_dquot_deltas_after);
1418
1419TRACE_EVENT(xfs_trans_mod_dquot,
1420 TP_PROTO(struct xfs_trans *tp, struct xfs_dquot *dqp,
1421 unsigned int field, int64_t delta),
1422 TP_ARGS(tp, dqp, field, delta),
1423 TP_STRUCT__entry(
1424 __field(dev_t, dev)
1425 __field(xfs_dqtype_t, type)
1426 __field(unsigned int, flags)
1427 __field(unsigned int, dqid)
1428 __field(unsigned int, field)
1429 __field(int64_t, delta)
1430 ),
1431 TP_fast_assign(
1432 __entry->dev = tp->t_mountp->m_super->s_dev;
1433 __entry->type = dqp->q_type;
1434 __entry->flags = dqp->q_flags;
1435 __entry->dqid = dqp->q_id;
1436 __entry->field = field;
1437 __entry->delta = delta;
1438 ),
1439 TP_printk("dev %d:%d dquot id 0x%x type %s flags %s field %s delta %lld",
1440 MAJOR(__entry->dev), MINOR(__entry->dev),
1441 __entry->dqid,
1442 __print_flags(__entry->type, "|", XFS_DQTYPE_STRINGS),
1443 __print_flags(__entry->flags, "|", XFS_DQFLAG_STRINGS),
1444 __print_flags(__entry->field, "|", XFS_QMOPT_FLAGS),
1445 __entry->delta)
1446);
1447
1448DECLARE_EVENT_CLASS(xfs_dqtrx_class,
1449 TP_PROTO(struct xfs_dqtrx *qtrx),
1450 TP_ARGS(qtrx),
1451 TP_STRUCT__entry(
1452 __field(dev_t, dev)
1453 __field(xfs_dqtype_t, type)
1454 __field(unsigned int, flags)
1455 __field(u32, dqid)
1456
1457 __field(uint64_t, blk_res)
1458 __field(int64_t, bcount_delta)
1459 __field(int64_t, delbcnt_delta)
1460
1461 __field(uint64_t, rtblk_res)
1462 __field(uint64_t, rtblk_res_used)
1463 __field(int64_t, rtbcount_delta)
1464 __field(int64_t, delrtb_delta)
1465
1466 __field(uint64_t, ino_res)
1467 __field(uint64_t, ino_res_used)
1468 __field(int64_t, icount_delta)
1469 ),
1470 TP_fast_assign(
1471 __entry->dev = qtrx->qt_dquot->q_mount->m_super->s_dev;
1472 __entry->type = qtrx->qt_dquot->q_type;
1473 __entry->flags = qtrx->qt_dquot->q_flags;
1474 __entry->dqid = qtrx->qt_dquot->q_id;
1475
1476 __entry->blk_res = qtrx->qt_blk_res;
1477 __entry->bcount_delta = qtrx->qt_bcount_delta;
1478 __entry->delbcnt_delta = qtrx->qt_delbcnt_delta;
1479
1480 __entry->rtblk_res = qtrx->qt_rtblk_res;
1481 __entry->rtblk_res_used = qtrx->qt_rtblk_res_used;
1482 __entry->rtbcount_delta = qtrx->qt_rtbcount_delta;
1483 __entry->delrtb_delta = qtrx->qt_delrtb_delta;
1484
1485 __entry->ino_res = qtrx->qt_ino_res;
1486 __entry->ino_res_used = qtrx->qt_ino_res_used;
1487 __entry->icount_delta = qtrx->qt_icount_delta;
1488 ),
1489 TP_printk("dev %d:%d dquot id 0x%x type %s flags %s "
1490 "blk_res %llu bcount_delta %lld delbcnt_delta %lld "
1491 "rtblk_res %llu rtblk_res_used %llu rtbcount_delta %lld delrtb_delta %lld "
1492 "ino_res %llu ino_res_used %llu icount_delta %lld",
1493 MAJOR(__entry->dev), MINOR(__entry->dev),
1494 __entry->dqid,
1495 __print_flags(__entry->type, "|", XFS_DQTYPE_STRINGS),
1496 __print_flags(__entry->flags, "|", XFS_DQFLAG_STRINGS),
1497
1498 __entry->blk_res,
1499 __entry->bcount_delta,
1500 __entry->delbcnt_delta,
1501
1502 __entry->rtblk_res,
1503 __entry->rtblk_res_used,
1504 __entry->rtbcount_delta,
1505 __entry->delrtb_delta,
1506
1507 __entry->ino_res,
1508 __entry->ino_res_used,
1509 __entry->icount_delta)
1510)
1511
1512#define DEFINE_DQTRX_EVENT(name) \
1513DEFINE_EVENT(xfs_dqtrx_class, name, \
1514 TP_PROTO(struct xfs_dqtrx *qtrx), \
1515 TP_ARGS(qtrx))
1516DEFINE_DQTRX_EVENT(xfs_trans_apply_dquot_deltas);
1517DEFINE_DQTRX_EVENT(xfs_trans_mod_dquot_before);
1518DEFINE_DQTRX_EVENT(xfs_trans_mod_dquot_after);
1519
1520DECLARE_EVENT_CLASS(xfs_loggrant_class,
1521 TP_PROTO(struct xlog *log, struct xlog_ticket *tic),
1522 TP_ARGS(log, tic),
1523 TP_STRUCT__entry(
1524 __field(dev_t, dev)
1525 __field(unsigned long, tic)
1526 __field(char, ocnt)
1527 __field(char, cnt)
1528 __field(int, curr_res)
1529 __field(int, unit_res)
1530 __field(unsigned int, flags)
1531 __field(int, reserveq)
1532 __field(int, writeq)
1533 __field(uint64_t, grant_reserve_bytes)
1534 __field(uint64_t, grant_write_bytes)
1535 __field(uint64_t, tail_space)
1536 __field(int, curr_cycle)
1537 __field(int, curr_block)
1538 __field(xfs_lsn_t, tail_lsn)
1539 ),
1540 TP_fast_assign(
1541 __entry->dev = log->l_mp->m_super->s_dev;
1542 __entry->tic = (unsigned long)tic;
1543 __entry->ocnt = tic->t_ocnt;
1544 __entry->cnt = tic->t_cnt;
1545 __entry->curr_res = tic->t_curr_res;
1546 __entry->unit_res = tic->t_unit_res;
1547 __entry->flags = tic->t_flags;
1548 __entry->reserveq = list_empty(&log->l_reserve_head.waiters);
1549 __entry->writeq = list_empty(&log->l_write_head.waiters);
1550 __entry->tail_space = READ_ONCE(log->l_tail_space);
1551 __entry->grant_reserve_bytes = __entry->tail_space +
1552 atomic64_read(&log->l_reserve_head.grant);
1553 __entry->grant_write_bytes = __entry->tail_space +
1554 atomic64_read(&log->l_write_head.grant);
1555 __entry->curr_cycle = log->l_curr_cycle;
1556 __entry->curr_block = log->l_curr_block;
1557 __entry->tail_lsn = atomic64_read(&log->l_tail_lsn);
1558 ),
1559 TP_printk("dev %d:%d tic 0x%lx t_ocnt %u t_cnt %u t_curr_res %u "
1560 "t_unit_res %u t_flags %s reserveq %s writeq %s "
1561 "tail space %llu grant_reserve_bytes %llu "
1562 "grant_write_bytes %llu curr_cycle %d curr_block %d "
1563 "tail_cycle %d tail_block %d",
1564 MAJOR(__entry->dev), MINOR(__entry->dev),
1565 __entry->tic,
1566 __entry->ocnt,
1567 __entry->cnt,
1568 __entry->curr_res,
1569 __entry->unit_res,
1570 __print_flags(__entry->flags, "|", XLOG_TIC_FLAGS),
1571 __entry->reserveq ? "empty" : "active",
1572 __entry->writeq ? "empty" : "active",
1573 __entry->tail_space,
1574 __entry->grant_reserve_bytes,
1575 __entry->grant_write_bytes,
1576 __entry->curr_cycle,
1577 __entry->curr_block,
1578 CYCLE_LSN(__entry->tail_lsn),
1579 BLOCK_LSN(__entry->tail_lsn)
1580 )
1581)
1582
1583#define DEFINE_LOGGRANT_EVENT(name) \
1584DEFINE_EVENT(xfs_loggrant_class, name, \
1585 TP_PROTO(struct xlog *log, struct xlog_ticket *tic), \
1586 TP_ARGS(log, tic))
1587DEFINE_LOGGRANT_EVENT(xfs_log_umount_write);
1588DEFINE_LOGGRANT_EVENT(xfs_log_grant_sleep);
1589DEFINE_LOGGRANT_EVENT(xfs_log_grant_wake);
1590DEFINE_LOGGRANT_EVENT(xfs_log_grant_wake_up);
1591DEFINE_LOGGRANT_EVENT(xfs_log_reserve);
1592DEFINE_LOGGRANT_EVENT(xfs_log_reserve_exit);
1593DEFINE_LOGGRANT_EVENT(xfs_log_regrant);
1594DEFINE_LOGGRANT_EVENT(xfs_log_regrant_exit);
1595DEFINE_LOGGRANT_EVENT(xfs_log_ticket_regrant);
1596DEFINE_LOGGRANT_EVENT(xfs_log_ticket_regrant_exit);
1597DEFINE_LOGGRANT_EVENT(xfs_log_ticket_regrant_sub);
1598DEFINE_LOGGRANT_EVENT(xfs_log_ticket_ungrant);
1599DEFINE_LOGGRANT_EVENT(xfs_log_ticket_ungrant_sub);
1600DEFINE_LOGGRANT_EVENT(xfs_log_ticket_ungrant_exit);
1601DEFINE_LOGGRANT_EVENT(xfs_log_cil_wait);
1602
1603DECLARE_EVENT_CLASS(xfs_log_item_class,
1604 TP_PROTO(struct xfs_log_item *lip),
1605 TP_ARGS(lip),
1606 TP_STRUCT__entry(
1607 __field(dev_t, dev)
1608 __field(void *, lip)
1609 __field(uint, type)
1610 __field(unsigned long, flags)
1611 __field(xfs_lsn_t, lsn)
1612 ),
1613 TP_fast_assign(
1614 __entry->dev = lip->li_log->l_mp->m_super->s_dev;
1615 __entry->lip = lip;
1616 __entry->type = lip->li_type;
1617 __entry->flags = lip->li_flags;
1618 __entry->lsn = lip->li_lsn;
1619 ),
1620 TP_printk("dev %d:%d lip %p lsn %d/%d type %s flags %s",
1621 MAJOR(__entry->dev), MINOR(__entry->dev),
1622 __entry->lip,
1623 CYCLE_LSN(__entry->lsn), BLOCK_LSN(__entry->lsn),
1624 __print_symbolic(__entry->type, XFS_LI_TYPE_DESC),
1625 __print_flags(__entry->flags, "|", XFS_LI_FLAGS))
1626)
1627
1628TRACE_EVENT(xfs_log_force,
1629 TP_PROTO(struct xfs_mount *mp, xfs_lsn_t lsn, unsigned long caller_ip),
1630 TP_ARGS(mp, lsn, caller_ip),
1631 TP_STRUCT__entry(
1632 __field(dev_t, dev)
1633 __field(xfs_lsn_t, lsn)
1634 __field(unsigned long, caller_ip)
1635 ),
1636 TP_fast_assign(
1637 __entry->dev = mp->m_super->s_dev;
1638 __entry->lsn = lsn;
1639 __entry->caller_ip = caller_ip;
1640 ),
1641 TP_printk("dev %d:%d lsn 0x%llx caller %pS",
1642 MAJOR(__entry->dev), MINOR(__entry->dev),
1643 __entry->lsn, (void *)__entry->caller_ip)
1644)
1645
1646#define DEFINE_LOG_ITEM_EVENT(name) \
1647DEFINE_EVENT(xfs_log_item_class, name, \
1648 TP_PROTO(struct xfs_log_item *lip), \
1649 TP_ARGS(lip))
1650DEFINE_LOG_ITEM_EVENT(xfs_ail_push);
1651DEFINE_LOG_ITEM_EVENT(xfs_ail_pinned);
1652DEFINE_LOG_ITEM_EVENT(xfs_ail_locked);
1653DEFINE_LOG_ITEM_EVENT(xfs_ail_flushing);
1654DEFINE_LOG_ITEM_EVENT(xfs_cil_whiteout_mark);
1655DEFINE_LOG_ITEM_EVENT(xfs_cil_whiteout_skip);
1656DEFINE_LOG_ITEM_EVENT(xfs_cil_whiteout_unpin);
1657DEFINE_LOG_ITEM_EVENT(xlog_ail_insert_abort);
1658DEFINE_LOG_ITEM_EVENT(xfs_trans_free_abort);
1659
1660DECLARE_EVENT_CLASS(xfs_ail_class,
1661 TP_PROTO(struct xfs_log_item *lip, xfs_lsn_t old_lsn, xfs_lsn_t new_lsn),
1662 TP_ARGS(lip, old_lsn, new_lsn),
1663 TP_STRUCT__entry(
1664 __field(dev_t, dev)
1665 __field(void *, lip)
1666 __field(uint, type)
1667 __field(unsigned long, flags)
1668 __field(xfs_lsn_t, old_lsn)
1669 __field(xfs_lsn_t, new_lsn)
1670 ),
1671 TP_fast_assign(
1672 __entry->dev = lip->li_log->l_mp->m_super->s_dev;
1673 __entry->lip = lip;
1674 __entry->type = lip->li_type;
1675 __entry->flags = lip->li_flags;
1676 __entry->old_lsn = old_lsn;
1677 __entry->new_lsn = new_lsn;
1678 ),
1679 TP_printk("dev %d:%d lip %p old lsn %d/%d new lsn %d/%d type %s flags %s",
1680 MAJOR(__entry->dev), MINOR(__entry->dev),
1681 __entry->lip,
1682 CYCLE_LSN(__entry->old_lsn), BLOCK_LSN(__entry->old_lsn),
1683 CYCLE_LSN(__entry->new_lsn), BLOCK_LSN(__entry->new_lsn),
1684 __print_symbolic(__entry->type, XFS_LI_TYPE_DESC),
1685 __print_flags(__entry->flags, "|", XFS_LI_FLAGS))
1686)
1687
1688#define DEFINE_AIL_EVENT(name) \
1689DEFINE_EVENT(xfs_ail_class, name, \
1690 TP_PROTO(struct xfs_log_item *lip, xfs_lsn_t old_lsn, xfs_lsn_t new_lsn), \
1691 TP_ARGS(lip, old_lsn, new_lsn))
1692DEFINE_AIL_EVENT(xfs_ail_insert);
1693DEFINE_AIL_EVENT(xfs_ail_move);
1694DEFINE_AIL_EVENT(xfs_ail_delete);
1695
1696TRACE_EVENT(xfs_log_assign_tail_lsn,
1697 TP_PROTO(struct xlog *log, xfs_lsn_t new_lsn),
1698 TP_ARGS(log, new_lsn),
1699 TP_STRUCT__entry(
1700 __field(dev_t, dev)
1701 __field(xfs_lsn_t, new_lsn)
1702 __field(xfs_lsn_t, old_lsn)
1703 __field(xfs_lsn_t, head_lsn)
1704 ),
1705 TP_fast_assign(
1706 __entry->dev = log->l_mp->m_super->s_dev;
1707 __entry->new_lsn = new_lsn;
1708 __entry->old_lsn = atomic64_read(&log->l_tail_lsn);
1709 __entry->head_lsn = log->l_ailp->ail_head_lsn;
1710 ),
1711 TP_printk("dev %d:%d new tail lsn %d/%d, old lsn %d/%d, head lsn %d/%d",
1712 MAJOR(__entry->dev), MINOR(__entry->dev),
1713 CYCLE_LSN(__entry->new_lsn), BLOCK_LSN(__entry->new_lsn),
1714 CYCLE_LSN(__entry->old_lsn), BLOCK_LSN(__entry->old_lsn),
1715 CYCLE_LSN(__entry->head_lsn), BLOCK_LSN(__entry->head_lsn))
1716)
1717
1718DECLARE_EVENT_CLASS(xfs_file_class,
1719 TP_PROTO(struct kiocb *iocb, struct iov_iter *iter),
1720 TP_ARGS(iocb, iter),
1721 TP_STRUCT__entry(
1722 __field(dev_t, dev)
1723 __field(xfs_ino_t, ino)
1724 __field(xfs_fsize_t, size)
1725 __field(loff_t, offset)
1726 __field(size_t, count)
1727 ),
1728 TP_fast_assign(
1729 __entry->dev = file_inode(iocb->ki_filp)->i_sb->s_dev;
1730 __entry->ino = XFS_I(file_inode(iocb->ki_filp))->i_ino;
1731 __entry->size = XFS_I(file_inode(iocb->ki_filp))->i_disk_size;
1732 __entry->offset = iocb->ki_pos;
1733 __entry->count = iov_iter_count(iter);
1734 ),
1735 TP_printk("dev %d:%d ino 0x%llx disize 0x%llx pos 0x%llx bytecount 0x%zx",
1736 MAJOR(__entry->dev), MINOR(__entry->dev),
1737 __entry->ino,
1738 __entry->size,
1739 __entry->offset,
1740 __entry->count)
1741)
1742
1743#define DEFINE_RW_EVENT(name) \
1744DEFINE_EVENT(xfs_file_class, name, \
1745 TP_PROTO(struct kiocb *iocb, struct iov_iter *iter), \
1746 TP_ARGS(iocb, iter))
1747DEFINE_RW_EVENT(xfs_file_buffered_read);
1748DEFINE_RW_EVENT(xfs_file_direct_read);
1749DEFINE_RW_EVENT(xfs_file_dax_read);
1750DEFINE_RW_EVENT(xfs_file_buffered_write);
1751DEFINE_RW_EVENT(xfs_file_direct_write);
1752DEFINE_RW_EVENT(xfs_file_dax_write);
1753DEFINE_RW_EVENT(xfs_reflink_bounce_dio_write);
1754
1755TRACE_EVENT(xfs_iomap_atomic_write_cow,
1756 TP_PROTO(struct xfs_inode *ip, xfs_off_t offset, ssize_t count),
1757 TP_ARGS(ip, offset, count),
1758 TP_STRUCT__entry(
1759 __field(dev_t, dev)
1760 __field(xfs_ino_t, ino)
1761 __field(xfs_off_t, offset)
1762 __field(ssize_t, count)
1763 ),
1764 TP_fast_assign(
1765 __entry->dev = VFS_I(ip)->i_sb->s_dev;
1766 __entry->ino = ip->i_ino;
1767 __entry->offset = offset;
1768 __entry->count = count;
1769 ),
1770 TP_printk("dev %d:%d ino 0x%llx pos 0x%llx bytecount 0x%zx",
1771 MAJOR(__entry->dev), MINOR(__entry->dev),
1772 __entry->ino,
1773 __entry->offset,
1774 __entry->count)
1775)
1776
1777DECLARE_EVENT_CLASS(xfs_imap_class,
1778 TP_PROTO(struct xfs_inode *ip, xfs_off_t offset, ssize_t count,
1779 int whichfork, struct xfs_bmbt_irec *irec),
1780 TP_ARGS(ip, offset, count, whichfork, irec),
1781 TP_STRUCT__entry(
1782 __field(dev_t, dev)
1783 __field(xfs_ino_t, ino)
1784 __field(loff_t, size)
1785 __field(loff_t, offset)
1786 __field(size_t, count)
1787 __field(int, whichfork)
1788 __field(xfs_fileoff_t, startoff)
1789 __field(xfs_fsblock_t, startblock)
1790 __field(xfs_filblks_t, blockcount)
1791 ),
1792 TP_fast_assign(
1793 __entry->dev = VFS_I(ip)->i_sb->s_dev;
1794 __entry->ino = ip->i_ino;
1795 __entry->size = ip->i_disk_size;
1796 __entry->offset = offset;
1797 __entry->count = count;
1798 __entry->whichfork = whichfork;
1799 __entry->startoff = irec ? irec->br_startoff : 0;
1800 __entry->startblock = irec ? irec->br_startblock : 0;
1801 __entry->blockcount = irec ? irec->br_blockcount : 0;
1802 ),
1803 TP_printk("dev %d:%d ino 0x%llx disize 0x%llx pos 0x%llx bytecount 0x%zx "
1804 "fork %s startoff 0x%llx startblock 0x%llx fsbcount 0x%llx",
1805 MAJOR(__entry->dev), MINOR(__entry->dev),
1806 __entry->ino,
1807 __entry->size,
1808 __entry->offset,
1809 __entry->count,
1810 __print_symbolic(__entry->whichfork, XFS_WHICHFORK_STRINGS),
1811 __entry->startoff,
1812 (int64_t)__entry->startblock,
1813 __entry->blockcount)
1814)
1815
1816#define DEFINE_IMAP_EVENT(name) \
1817DEFINE_EVENT(xfs_imap_class, name, \
1818 TP_PROTO(struct xfs_inode *ip, xfs_off_t offset, ssize_t count, \
1819 int whichfork, struct xfs_bmbt_irec *irec), \
1820 TP_ARGS(ip, offset, count, whichfork, irec))
1821DEFINE_IMAP_EVENT(xfs_map_blocks_found);
1822DEFINE_IMAP_EVENT(xfs_map_blocks_alloc);
1823DEFINE_IMAP_EVENT(xfs_iomap_alloc);
1824DEFINE_IMAP_EVENT(xfs_iomap_found);
1825
1826DECLARE_EVENT_CLASS(xfs_simple_io_class,
1827 TP_PROTO(struct xfs_inode *ip, xfs_off_t offset, ssize_t count),
1828 TP_ARGS(ip, offset, count),
1829 TP_STRUCT__entry(
1830 __field(dev_t, dev)
1831 __field(xfs_ino_t, ino)
1832 __field(loff_t, isize)
1833 __field(loff_t, disize)
1834 __field(loff_t, offset)
1835 __field(size_t, count)
1836 ),
1837 TP_fast_assign(
1838 __entry->dev = VFS_I(ip)->i_sb->s_dev;
1839 __entry->ino = ip->i_ino;
1840 __entry->isize = VFS_I(ip)->i_size;
1841 __entry->disize = ip->i_disk_size;
1842 __entry->offset = offset;
1843 __entry->count = count;
1844 ),
1845 TP_printk("dev %d:%d ino 0x%llx isize 0x%llx disize 0x%llx "
1846 "pos 0x%llx bytecount 0x%zx",
1847 MAJOR(__entry->dev), MINOR(__entry->dev),
1848 __entry->ino,
1849 __entry->isize,
1850 __entry->disize,
1851 __entry->offset,
1852 __entry->count)
1853);
1854
1855#define DEFINE_SIMPLE_IO_EVENT(name) \
1856DEFINE_EVENT(xfs_simple_io_class, name, \
1857 TP_PROTO(struct xfs_inode *ip, xfs_off_t offset, ssize_t count), \
1858 TP_ARGS(ip, offset, count))
1859DEFINE_SIMPLE_IO_EVENT(xfs_delalloc_enospc);
1860DEFINE_SIMPLE_IO_EVENT(xfs_unwritten_convert);
1861DEFINE_SIMPLE_IO_EVENT(xfs_setfilesize);
1862DEFINE_SIMPLE_IO_EVENT(xfs_zero_eof);
1863DEFINE_SIMPLE_IO_EVENT(xfs_end_io_direct_write);
1864DEFINE_SIMPLE_IO_EVENT(xfs_file_splice_read);
1865DEFINE_SIMPLE_IO_EVENT(xfs_zoned_map_blocks);
1866
1867DECLARE_EVENT_CLASS(xfs_itrunc_class,
1868 TP_PROTO(struct xfs_inode *ip, xfs_fsize_t new_size),
1869 TP_ARGS(ip, new_size),
1870 TP_STRUCT__entry(
1871 __field(dev_t, dev)
1872 __field(xfs_ino_t, ino)
1873 __field(xfs_fsize_t, size)
1874 __field(xfs_fsize_t, new_size)
1875 ),
1876 TP_fast_assign(
1877 __entry->dev = VFS_I(ip)->i_sb->s_dev;
1878 __entry->ino = ip->i_ino;
1879 __entry->size = ip->i_disk_size;
1880 __entry->new_size = new_size;
1881 ),
1882 TP_printk("dev %d:%d ino 0x%llx disize 0x%llx new_size 0x%llx",
1883 MAJOR(__entry->dev), MINOR(__entry->dev),
1884 __entry->ino,
1885 __entry->size,
1886 __entry->new_size)
1887)
1888
1889#define DEFINE_ITRUNC_EVENT(name) \
1890DEFINE_EVENT(xfs_itrunc_class, name, \
1891 TP_PROTO(struct xfs_inode *ip, xfs_fsize_t new_size), \
1892 TP_ARGS(ip, new_size))
1893DEFINE_ITRUNC_EVENT(xfs_itruncate_extents_start);
1894DEFINE_ITRUNC_EVENT(xfs_itruncate_extents_end);
1895
1896TRACE_EVENT(xfs_bunmap,
1897 TP_PROTO(struct xfs_inode *ip, xfs_fileoff_t fileoff, xfs_filblks_t len,
1898 int flags, unsigned long caller_ip),
1899 TP_ARGS(ip, fileoff, len, flags, caller_ip),
1900 TP_STRUCT__entry(
1901 __field(dev_t, dev)
1902 __field(xfs_ino_t, ino)
1903 __field(xfs_fsize_t, size)
1904 __field(xfs_fileoff_t, fileoff)
1905 __field(xfs_filblks_t, len)
1906 __field(unsigned long, caller_ip)
1907 __field(int, flags)
1908 ),
1909 TP_fast_assign(
1910 __entry->dev = VFS_I(ip)->i_sb->s_dev;
1911 __entry->ino = ip->i_ino;
1912 __entry->size = ip->i_disk_size;
1913 __entry->fileoff = fileoff;
1914 __entry->len = len;
1915 __entry->caller_ip = caller_ip;
1916 __entry->flags = flags;
1917 ),
1918 TP_printk("dev %d:%d ino 0x%llx disize 0x%llx fileoff 0x%llx fsbcount 0x%llx "
1919 "flags %s caller %pS",
1920 MAJOR(__entry->dev), MINOR(__entry->dev),
1921 __entry->ino,
1922 __entry->size,
1923 __entry->fileoff,
1924 __entry->len,
1925 __print_flags(__entry->flags, "|", XFS_BMAPI_FLAGS),
1926 (void *)__entry->caller_ip)
1927
1928);
1929
1930DECLARE_EVENT_CLASS(xfs_extent_busy_class,
1931 TP_PROTO(const struct xfs_group *xg, xfs_agblock_t agbno,
1932 xfs_extlen_t len),
1933 TP_ARGS(xg, agbno, len),
1934 TP_STRUCT__entry(
1935 __field(dev_t, dev)
1936 __field(enum xfs_group_type, type)
1937 __field(xfs_agnumber_t, agno)
1938 __field(xfs_agblock_t, agbno)
1939 __field(xfs_extlen_t, len)
1940 ),
1941 TP_fast_assign(
1942 __entry->dev = xg->xg_mount->m_super->s_dev;
1943 __entry->type = xg->xg_type;
1944 __entry->agno = xg->xg_gno;
1945 __entry->agbno = agbno;
1946 __entry->len = len;
1947 ),
1948 TP_printk("dev %d:%d %sno 0x%x %sbno 0x%x fsbcount 0x%x",
1949 MAJOR(__entry->dev), MINOR(__entry->dev),
1950 __print_symbolic(__entry->type, XG_TYPE_STRINGS),
1951 __entry->agno,
1952 __print_symbolic(__entry->type, XG_TYPE_STRINGS),
1953 __entry->agbno,
1954 __entry->len)
1955);
1956#define DEFINE_BUSY_EVENT(name) \
1957DEFINE_EVENT(xfs_extent_busy_class, name, \
1958 TP_PROTO(const struct xfs_group *xg, xfs_agblock_t agbno, \
1959 xfs_extlen_t len), \
1960 TP_ARGS(xg, agbno, len))
1961DEFINE_BUSY_EVENT(xfs_extent_busy);
1962DEFINE_BUSY_EVENT(xfs_extent_busy_force);
1963DEFINE_BUSY_EVENT(xfs_extent_busy_reuse);
1964DEFINE_BUSY_EVENT(xfs_extent_busy_clear);
1965
1966TRACE_EVENT(xfs_extent_busy_trim,
1967 TP_PROTO(const struct xfs_group *xg, xfs_agblock_t agbno,
1968 xfs_extlen_t len, xfs_agblock_t tbno, xfs_extlen_t tlen),
1969 TP_ARGS(xg, agbno, len, tbno, tlen),
1970 TP_STRUCT__entry(
1971 __field(dev_t, dev)
1972 __field(enum xfs_group_type, type)
1973 __field(xfs_agnumber_t, agno)
1974 __field(xfs_agblock_t, agbno)
1975 __field(xfs_extlen_t, len)
1976 __field(xfs_agblock_t, tbno)
1977 __field(xfs_extlen_t, tlen)
1978 ),
1979 TP_fast_assign(
1980 __entry->dev = xg->xg_mount->m_super->s_dev;
1981 __entry->type = xg->xg_type;
1982 __entry->agno = xg->xg_gno;
1983 __entry->agbno = agbno;
1984 __entry->len = len;
1985 __entry->tbno = tbno;
1986 __entry->tlen = tlen;
1987 ),
1988 TP_printk("dev %d:%d %sno 0x%x %sbno 0x%x fsbcount 0x%x found_agbno 0x%x found_fsbcount 0x%x",
1989 MAJOR(__entry->dev), MINOR(__entry->dev),
1990 __print_symbolic(__entry->type, XG_TYPE_STRINGS),
1991 __entry->agno,
1992 __print_symbolic(__entry->type, XG_TYPE_STRINGS),
1993 __entry->agbno,
1994 __entry->len,
1995 __entry->tbno,
1996 __entry->tlen)
1997);
1998
1999#ifdef CONFIG_XFS_RT
2000TRACE_EVENT(xfs_rtalloc_extent_busy,
2001 TP_PROTO(struct xfs_rtgroup *rtg, xfs_rtxnum_t start,
2002 xfs_rtxlen_t minlen, xfs_rtxlen_t maxlen,
2003 xfs_rtxlen_t len, xfs_rtxlen_t prod, xfs_rtxnum_t rtx,
2004 unsigned busy_gen),
2005 TP_ARGS(rtg, start, minlen, maxlen, len, prod, rtx, busy_gen),
2006 TP_STRUCT__entry(
2007 __field(dev_t, dev)
2008 __field(xfs_rgnumber_t, rgno)
2009 __field(xfs_rtxnum_t, start)
2010 __field(xfs_rtxlen_t, minlen)
2011 __field(xfs_rtxlen_t, maxlen)
2012 __field(xfs_rtxlen_t, mod)
2013 __field(xfs_rtxlen_t, prod)
2014 __field(xfs_rtxlen_t, len)
2015 __field(xfs_rtxnum_t, rtx)
2016 __field(unsigned, busy_gen)
2017 ),
2018 TP_fast_assign(
2019 __entry->dev = rtg_mount(rtg)->m_super->s_dev;
2020 __entry->rgno = rtg_rgno(rtg);
2021 __entry->start = start;
2022 __entry->minlen = minlen;
2023 __entry->maxlen = maxlen;
2024 __entry->prod = prod;
2025 __entry->len = len;
2026 __entry->rtx = rtx;
2027 __entry->busy_gen = busy_gen;
2028 ),
2029 TP_printk("dev %d:%d rgno 0x%x startrtx 0x%llx minlen %u maxlen %u "
2030 "prod %u len %u rtx 0%llx busy_gen 0x%x",
2031 MAJOR(__entry->dev), MINOR(__entry->dev),
2032 __entry->rgno,
2033 __entry->start,
2034 __entry->minlen,
2035 __entry->maxlen,
2036 __entry->prod,
2037 __entry->len,
2038 __entry->rtx,
2039 __entry->busy_gen)
2040)
2041
2042TRACE_EVENT(xfs_rtalloc_extent_busy_trim,
2043 TP_PROTO(struct xfs_rtgroup *rtg, xfs_rtxnum_t old_rtx,
2044 xfs_rtxlen_t old_len, xfs_rtxnum_t new_rtx,
2045 xfs_rtxlen_t new_len),
2046 TP_ARGS(rtg, old_rtx, old_len, new_rtx, new_len),
2047 TP_STRUCT__entry(
2048 __field(dev_t, dev)
2049 __field(xfs_rgnumber_t, rgno)
2050 __field(xfs_rtxnum_t, old_rtx)
2051 __field(xfs_rtxnum_t, new_rtx)
2052 __field(xfs_rtxlen_t, old_len)
2053 __field(xfs_rtxlen_t, new_len)
2054 ),
2055 TP_fast_assign(
2056 __entry->dev = rtg_mount(rtg)->m_super->s_dev;
2057 __entry->rgno = rtg_rgno(rtg);
2058 __entry->old_rtx = old_rtx;
2059 __entry->old_len = old_len;
2060 __entry->new_rtx = new_rtx;
2061 __entry->new_len = new_len;
2062 ),
2063 TP_printk("dev %d:%d rgno 0x%x rtx 0x%llx rtxcount 0x%x -> rtx 0x%llx rtxcount 0x%x",
2064 MAJOR(__entry->dev), MINOR(__entry->dev),
2065 __entry->rgno,
2066 __entry->old_rtx,
2067 __entry->old_len,
2068 __entry->new_rtx,
2069 __entry->new_len)
2070);
2071#endif /* CONFIG_XFS_RT */
2072
2073DECLARE_EVENT_CLASS(xfs_agf_class,
2074 TP_PROTO(struct xfs_mount *mp, struct xfs_agf *agf, int flags,
2075 unsigned long caller_ip),
2076 TP_ARGS(mp, agf, flags, caller_ip),
2077 TP_STRUCT__entry(
2078 __field(dev_t, dev)
2079 __field(xfs_agnumber_t, agno)
2080 __field(int, flags)
2081 __field(__u32, length)
2082 __field(__u32, bno_root)
2083 __field(__u32, cnt_root)
2084 __field(__u32, bno_level)
2085 __field(__u32, cnt_level)
2086 __field(__u32, flfirst)
2087 __field(__u32, fllast)
2088 __field(__u32, flcount)
2089 __field(__u32, freeblks)
2090 __field(__u32, longest)
2091 __field(unsigned long, caller_ip)
2092 ),
2093 TP_fast_assign(
2094 __entry->dev = mp->m_super->s_dev;
2095 __entry->agno = be32_to_cpu(agf->agf_seqno),
2096 __entry->flags = flags;
2097 __entry->length = be32_to_cpu(agf->agf_length),
2098 __entry->bno_root = be32_to_cpu(agf->agf_bno_root),
2099 __entry->cnt_root = be32_to_cpu(agf->agf_cnt_root),
2100 __entry->bno_level = be32_to_cpu(agf->agf_bno_level),
2101 __entry->cnt_level = be32_to_cpu(agf->agf_cnt_level),
2102 __entry->flfirst = be32_to_cpu(agf->agf_flfirst),
2103 __entry->fllast = be32_to_cpu(agf->agf_fllast),
2104 __entry->flcount = be32_to_cpu(agf->agf_flcount),
2105 __entry->freeblks = be32_to_cpu(agf->agf_freeblks),
2106 __entry->longest = be32_to_cpu(agf->agf_longest);
2107 __entry->caller_ip = caller_ip;
2108 ),
2109 TP_printk("dev %d:%d agno 0x%x flags %s length %u roots b %u c %u "
2110 "levels b %u c %u flfirst %u fllast %u flcount %u "
2111 "freeblks %u longest %u caller %pS",
2112 MAJOR(__entry->dev), MINOR(__entry->dev),
2113 __entry->agno,
2114 __print_flags(__entry->flags, "|", XFS_AGF_FLAGS),
2115 __entry->length,
2116 __entry->bno_root,
2117 __entry->cnt_root,
2118 __entry->bno_level,
2119 __entry->cnt_level,
2120 __entry->flfirst,
2121 __entry->fllast,
2122 __entry->flcount,
2123 __entry->freeblks,
2124 __entry->longest,
2125 (void *)__entry->caller_ip)
2126);
2127#define DEFINE_AGF_EVENT(name) \
2128DEFINE_EVENT(xfs_agf_class, name, \
2129 TP_PROTO(struct xfs_mount *mp, struct xfs_agf *agf, int flags, \
2130 unsigned long caller_ip), \
2131 TP_ARGS(mp, agf, flags, caller_ip))
2132DEFINE_AGF_EVENT(xfs_agf);
2133DEFINE_AGF_EVENT(xfs_agfl_reset);
2134
2135TRACE_EVENT(xfs_free_extent,
2136 TP_PROTO(const struct xfs_perag *pag, xfs_agblock_t agbno,
2137 xfs_extlen_t len, enum xfs_ag_resv_type resv, int haveleft,
2138 int haveright),
2139 TP_ARGS(pag, agbno, len, resv, haveleft, haveright),
2140 TP_STRUCT__entry(
2141 __field(dev_t, dev)
2142 __field(xfs_agnumber_t, agno)
2143 __field(xfs_agblock_t, agbno)
2144 __field(xfs_extlen_t, len)
2145 __field(int, resv)
2146 __field(int, haveleft)
2147 __field(int, haveright)
2148 ),
2149 TP_fast_assign(
2150 __entry->dev = pag_mount(pag)->m_super->s_dev;
2151 __entry->agno = pag_agno(pag);
2152 __entry->agbno = agbno;
2153 __entry->len = len;
2154 __entry->resv = resv;
2155 __entry->haveleft = haveleft;
2156 __entry->haveright = haveright;
2157 ),
2158 TP_printk("dev %d:%d agno 0x%x agbno 0x%x fsbcount 0x%x resv %d %s",
2159 MAJOR(__entry->dev), MINOR(__entry->dev),
2160 __entry->agno,
2161 __entry->agbno,
2162 __entry->len,
2163 __entry->resv,
2164 __entry->haveleft ?
2165 (__entry->haveright ? "both" : "left") :
2166 (__entry->haveright ? "right" : "none"))
2167
2168);
2169
2170DECLARE_EVENT_CLASS(xfs_alloc_class,
2171 TP_PROTO(struct xfs_alloc_arg *args),
2172 TP_ARGS(args),
2173 TP_STRUCT__entry(
2174 __field(dev_t, dev)
2175 __field(xfs_agnumber_t, agno)
2176 __field(xfs_agblock_t, agbno)
2177 __field(xfs_extlen_t, minlen)
2178 __field(xfs_extlen_t, maxlen)
2179 __field(xfs_extlen_t, mod)
2180 __field(xfs_extlen_t, prod)
2181 __field(xfs_extlen_t, minleft)
2182 __field(xfs_extlen_t, total)
2183 __field(xfs_extlen_t, alignment)
2184 __field(xfs_extlen_t, minalignslop)
2185 __field(xfs_extlen_t, len)
2186 __field(char, wasdel)
2187 __field(char, wasfromfl)
2188 __field(int, resv)
2189 __field(int, datatype)
2190 __field(xfs_agnumber_t, highest_agno)
2191 ),
2192 TP_fast_assign(
2193 __entry->dev = args->mp->m_super->s_dev;
2194 __entry->agno = args->agno;
2195 __entry->agbno = args->agbno;
2196 __entry->minlen = args->minlen;
2197 __entry->maxlen = args->maxlen;
2198 __entry->mod = args->mod;
2199 __entry->prod = args->prod;
2200 __entry->minleft = args->minleft;
2201 __entry->total = args->total;
2202 __entry->alignment = args->alignment;
2203 __entry->minalignslop = args->minalignslop;
2204 __entry->len = args->len;
2205 __entry->wasdel = args->wasdel;
2206 __entry->wasfromfl = args->wasfromfl;
2207 __entry->resv = args->resv;
2208 __entry->datatype = args->datatype;
2209 __entry->highest_agno = args->tp->t_highest_agno;
2210 ),
2211 TP_printk("dev %d:%d agno 0x%x agbno 0x%x minlen %u maxlen %u mod %u "
2212 "prod %u minleft %u total %u alignment %u minalignslop %u "
2213 "len %u wasdel %d wasfromfl %d resv %d "
2214 "datatype 0x%x highest_agno 0x%x",
2215 MAJOR(__entry->dev), MINOR(__entry->dev),
2216 __entry->agno,
2217 __entry->agbno,
2218 __entry->minlen,
2219 __entry->maxlen,
2220 __entry->mod,
2221 __entry->prod,
2222 __entry->minleft,
2223 __entry->total,
2224 __entry->alignment,
2225 __entry->minalignslop,
2226 __entry->len,
2227 __entry->wasdel,
2228 __entry->wasfromfl,
2229 __entry->resv,
2230 __entry->datatype,
2231 __entry->highest_agno)
2232)
2233
2234#define DEFINE_ALLOC_EVENT(name) \
2235DEFINE_EVENT(xfs_alloc_class, name, \
2236 TP_PROTO(struct xfs_alloc_arg *args), \
2237 TP_ARGS(args))
2238DEFINE_ALLOC_EVENT(xfs_alloc_exact_done);
2239DEFINE_ALLOC_EVENT(xfs_alloc_exact_notfound);
2240DEFINE_ALLOC_EVENT(xfs_alloc_exact_error);
2241DEFINE_ALLOC_EVENT(xfs_alloc_near_first);
2242DEFINE_ALLOC_EVENT(xfs_alloc_cur);
2243DEFINE_ALLOC_EVENT(xfs_alloc_cur_right);
2244DEFINE_ALLOC_EVENT(xfs_alloc_cur_left);
2245DEFINE_ALLOC_EVENT(xfs_alloc_cur_lookup);
2246DEFINE_ALLOC_EVENT(xfs_alloc_cur_lookup_done);
2247DEFINE_ALLOC_EVENT(xfs_alloc_near_noentry);
2248DEFINE_ALLOC_EVENT(xfs_alloc_near_busy);
2249DEFINE_ALLOC_EVENT(xfs_alloc_size_neither);
2250DEFINE_ALLOC_EVENT(xfs_alloc_size_noentry);
2251DEFINE_ALLOC_EVENT(xfs_alloc_size_nominleft);
2252DEFINE_ALLOC_EVENT(xfs_alloc_size_done);
2253DEFINE_ALLOC_EVENT(xfs_alloc_size_error);
2254DEFINE_ALLOC_EVENT(xfs_alloc_size_busy);
2255DEFINE_ALLOC_EVENT(xfs_alloc_small_freelist);
2256DEFINE_ALLOC_EVENT(xfs_alloc_small_notenough);
2257DEFINE_ALLOC_EVENT(xfs_alloc_small_done);
2258DEFINE_ALLOC_EVENT(xfs_alloc_small_error);
2259DEFINE_ALLOC_EVENT(xfs_alloc_vextent_badargs);
2260DEFINE_ALLOC_EVENT(xfs_alloc_vextent_skip_deadlock);
2261DEFINE_ALLOC_EVENT(xfs_alloc_vextent_nofix);
2262DEFINE_ALLOC_EVENT(xfs_alloc_vextent_noagbp);
2263DEFINE_ALLOC_EVENT(xfs_alloc_vextent_loopfailed);
2264DEFINE_ALLOC_EVENT(xfs_alloc_vextent_allfailed);
2265
2266DEFINE_ALLOC_EVENT(xfs_alloc_vextent_this_ag);
2267DEFINE_ALLOC_EVENT(xfs_alloc_vextent_start_ag);
2268DEFINE_ALLOC_EVENT(xfs_alloc_vextent_first_ag);
2269DEFINE_ALLOC_EVENT(xfs_alloc_vextent_exact_bno);
2270DEFINE_ALLOC_EVENT(xfs_alloc_vextent_near_bno);
2271DEFINE_ALLOC_EVENT(xfs_alloc_vextent_finish);
2272
2273TRACE_EVENT(xfs_alloc_cur_check,
2274 TP_PROTO(struct xfs_btree_cur *cur, xfs_agblock_t bno,
2275 xfs_extlen_t len, xfs_extlen_t diff, bool new),
2276 TP_ARGS(cur, bno, len, diff, new),
2277 TP_STRUCT__entry(
2278 __field(dev_t, dev)
2279 __string(name, cur->bc_ops->name)
2280 __field(xfs_agblock_t, bno)
2281 __field(xfs_extlen_t, len)
2282 __field(xfs_extlen_t, diff)
2283 __field(bool, new)
2284 ),
2285 TP_fast_assign(
2286 __entry->dev = cur->bc_mp->m_super->s_dev;
2287 __assign_str(name);
2288 __entry->bno = bno;
2289 __entry->len = len;
2290 __entry->diff = diff;
2291 __entry->new = new;
2292 ),
2293 TP_printk("dev %d:%d %sbt agbno 0x%x fsbcount 0x%x diff 0x%x new %d",
2294 MAJOR(__entry->dev), MINOR(__entry->dev),
2295 __get_str(name),
2296 __entry->bno, __entry->len, __entry->diff, __entry->new)
2297)
2298
2299DECLARE_EVENT_CLASS(xfs_da_class,
2300 TP_PROTO(struct xfs_da_args *args),
2301 TP_ARGS(args),
2302 TP_STRUCT__entry(
2303 __field(dev_t, dev)
2304 __field(xfs_ino_t, ino)
2305 __dynamic_array(char, name, args->namelen)
2306 __field(int, namelen)
2307 __field(xfs_dahash_t, hashval)
2308 __field(xfs_ino_t, inumber)
2309 __field(uint32_t, op_flags)
2310 __field(xfs_ino_t, owner)
2311 ),
2312 TP_fast_assign(
2313 __entry->dev = VFS_I(args->dp)->i_sb->s_dev;
2314 __entry->ino = args->dp->i_ino;
2315 if (args->namelen)
2316 memcpy(__get_str(name), args->name, args->namelen);
2317 __entry->namelen = args->namelen;
2318 __entry->hashval = args->hashval;
2319 __entry->inumber = args->inumber;
2320 __entry->op_flags = args->op_flags;
2321 __entry->owner = args->owner;
2322 ),
2323 TP_printk("dev %d:%d ino 0x%llx name %.*s namelen %d hashval 0x%x "
2324 "inumber 0x%llx op_flags %s owner 0x%llx",
2325 MAJOR(__entry->dev), MINOR(__entry->dev),
2326 __entry->ino,
2327 __entry->namelen,
2328 __entry->namelen ? __get_str(name) : NULL,
2329 __entry->namelen,
2330 __entry->hashval,
2331 __entry->inumber,
2332 __print_flags(__entry->op_flags, "|", XFS_DA_OP_FLAGS),
2333 __entry->owner)
2334)
2335
2336#define DEFINE_DIR2_EVENT(name) \
2337DEFINE_EVENT(xfs_da_class, name, \
2338 TP_PROTO(struct xfs_da_args *args), \
2339 TP_ARGS(args))
2340DEFINE_DIR2_EVENT(xfs_dir2_sf_addname);
2341DEFINE_DIR2_EVENT(xfs_dir2_sf_create);
2342DEFINE_DIR2_EVENT(xfs_dir2_sf_lookup);
2343DEFINE_DIR2_EVENT(xfs_dir2_sf_replace);
2344DEFINE_DIR2_EVENT(xfs_dir2_sf_removename);
2345DEFINE_DIR2_EVENT(xfs_dir2_sf_toino4);
2346DEFINE_DIR2_EVENT(xfs_dir2_sf_toino8);
2347DEFINE_DIR2_EVENT(xfs_dir2_sf_to_block);
2348DEFINE_DIR2_EVENT(xfs_dir2_block_addname);
2349DEFINE_DIR2_EVENT(xfs_dir2_block_lookup);
2350DEFINE_DIR2_EVENT(xfs_dir2_block_replace);
2351DEFINE_DIR2_EVENT(xfs_dir2_block_removename);
2352DEFINE_DIR2_EVENT(xfs_dir2_block_to_sf);
2353DEFINE_DIR2_EVENT(xfs_dir2_block_to_leaf);
2354DEFINE_DIR2_EVENT(xfs_dir2_leaf_addname);
2355DEFINE_DIR2_EVENT(xfs_dir2_leaf_lookup);
2356DEFINE_DIR2_EVENT(xfs_dir2_leaf_replace);
2357DEFINE_DIR2_EVENT(xfs_dir2_leaf_removename);
2358DEFINE_DIR2_EVENT(xfs_dir2_leaf_to_block);
2359DEFINE_DIR2_EVENT(xfs_dir2_leaf_to_node);
2360DEFINE_DIR2_EVENT(xfs_dir2_node_addname);
2361DEFINE_DIR2_EVENT(xfs_dir2_node_lookup);
2362DEFINE_DIR2_EVENT(xfs_dir2_node_replace);
2363DEFINE_DIR2_EVENT(xfs_dir2_node_removename);
2364DEFINE_DIR2_EVENT(xfs_dir2_node_to_leaf);
2365
2366DECLARE_EVENT_CLASS(xfs_attr_class,
2367 TP_PROTO(struct xfs_da_args *args),
2368 TP_ARGS(args),
2369 TP_STRUCT__entry(
2370 __field(dev_t, dev)
2371 __field(xfs_ino_t, ino)
2372 __dynamic_array(char, name, args->namelen)
2373 __field(int, namelen)
2374 __field(int, valuelen)
2375 __field(xfs_dahash_t, hashval)
2376 __field(unsigned int, attr_filter)
2377 __field(uint32_t, op_flags)
2378 ),
2379 TP_fast_assign(
2380 __entry->dev = VFS_I(args->dp)->i_sb->s_dev;
2381 __entry->ino = args->dp->i_ino;
2382 if (args->namelen)
2383 memcpy(__get_str(name), args->name, args->namelen);
2384 __entry->namelen = args->namelen;
2385 __entry->valuelen = args->valuelen;
2386 __entry->hashval = args->hashval;
2387 __entry->attr_filter = args->attr_filter;
2388 __entry->op_flags = args->op_flags;
2389 ),
2390 TP_printk("dev %d:%d ino 0x%llx name %.*s namelen %d valuelen %d "
2391 "hashval 0x%x filter %s op_flags %s",
2392 MAJOR(__entry->dev), MINOR(__entry->dev),
2393 __entry->ino,
2394 __entry->namelen,
2395 __entry->namelen ? __get_str(name) : NULL,
2396 __entry->namelen,
2397 __entry->valuelen,
2398 __entry->hashval,
2399 __print_flags(__entry->attr_filter, "|",
2400 XFS_ATTR_FILTER_FLAGS),
2401 __print_flags(__entry->op_flags, "|", XFS_DA_OP_FLAGS))
2402)
2403
2404#define DEFINE_ATTR_EVENT(name) \
2405DEFINE_EVENT(xfs_attr_class, name, \
2406 TP_PROTO(struct xfs_da_args *args), \
2407 TP_ARGS(args))
2408DEFINE_ATTR_EVENT(xfs_attr_sf_add);
2409DEFINE_ATTR_EVENT(xfs_attr_sf_addname);
2410DEFINE_ATTR_EVENT(xfs_attr_sf_create);
2411DEFINE_ATTR_EVENT(xfs_attr_sf_lookup);
2412DEFINE_ATTR_EVENT(xfs_attr_sf_remove);
2413DEFINE_ATTR_EVENT(xfs_attr_sf_to_leaf);
2414
2415DEFINE_ATTR_EVENT(xfs_attr_leaf_add);
2416DEFINE_ATTR_EVENT(xfs_attr_leaf_add_old);
2417DEFINE_ATTR_EVENT(xfs_attr_leaf_add_new);
2418DEFINE_ATTR_EVENT(xfs_attr_leaf_add_work);
2419DEFINE_ATTR_EVENT(xfs_attr_leaf_create);
2420DEFINE_ATTR_EVENT(xfs_attr_leaf_compact);
2421DEFINE_ATTR_EVENT(xfs_attr_leaf_get);
2422DEFINE_ATTR_EVENT(xfs_attr_leaf_lookup);
2423DEFINE_ATTR_EVENT(xfs_attr_leaf_replace);
2424DEFINE_ATTR_EVENT(xfs_attr_leaf_remove);
2425DEFINE_ATTR_EVENT(xfs_attr_leaf_removename);
2426DEFINE_ATTR_EVENT(xfs_attr_leaf_split);
2427DEFINE_ATTR_EVENT(xfs_attr_leaf_split_before);
2428DEFINE_ATTR_EVENT(xfs_attr_leaf_split_after);
2429DEFINE_ATTR_EVENT(xfs_attr_leaf_clearflag);
2430DEFINE_ATTR_EVENT(xfs_attr_leaf_setflag);
2431DEFINE_ATTR_EVENT(xfs_attr_leaf_flipflags);
2432DEFINE_ATTR_EVENT(xfs_attr_leaf_to_sf);
2433DEFINE_ATTR_EVENT(xfs_attr_leaf_to_node);
2434DEFINE_ATTR_EVENT(xfs_attr_leaf_rebalance);
2435DEFINE_ATTR_EVENT(xfs_attr_leaf_unbalance);
2436DEFINE_ATTR_EVENT(xfs_attr_leaf_toosmall);
2437
2438DEFINE_ATTR_EVENT(xfs_attr_node_addname);
2439DEFINE_ATTR_EVENT(xfs_attr_node_get);
2440DEFINE_ATTR_EVENT(xfs_attr_node_replace);
2441
2442DEFINE_ATTR_EVENT(xfs_attr_rmtval_get);
2443
2444#define DEFINE_DA_EVENT(name) \
2445DEFINE_EVENT(xfs_da_class, name, \
2446 TP_PROTO(struct xfs_da_args *args), \
2447 TP_ARGS(args))
2448DEFINE_DA_EVENT(xfs_da_split);
2449DEFINE_DA_EVENT(xfs_da_join);
2450DEFINE_DA_EVENT(xfs_da_link_before);
2451DEFINE_DA_EVENT(xfs_da_link_after);
2452DEFINE_DA_EVENT(xfs_da_unlink_back);
2453DEFINE_DA_EVENT(xfs_da_unlink_forward);
2454DEFINE_DA_EVENT(xfs_da_root_split);
2455DEFINE_DA_EVENT(xfs_da_root_join);
2456DEFINE_DA_EVENT(xfs_da_node_add);
2457DEFINE_DA_EVENT(xfs_da_node_create);
2458DEFINE_DA_EVENT(xfs_da_node_split);
2459DEFINE_DA_EVENT(xfs_da_node_remove);
2460DEFINE_DA_EVENT(xfs_da_node_rebalance);
2461DEFINE_DA_EVENT(xfs_da_node_unbalance);
2462DEFINE_DA_EVENT(xfs_da_node_toosmall);
2463DEFINE_DA_EVENT(xfs_da_swap_lastblock);
2464DEFINE_DA_EVENT(xfs_da_grow_inode);
2465DEFINE_DA_EVENT(xfs_da_shrink_inode);
2466DEFINE_DA_EVENT(xfs_da_fixhashpath);
2467DEFINE_DA_EVENT(xfs_da_path_shift);
2468
2469DECLARE_EVENT_CLASS(xfs_dir2_space_class,
2470 TP_PROTO(struct xfs_da_args *args, int idx),
2471 TP_ARGS(args, idx),
2472 TP_STRUCT__entry(
2473 __field(dev_t, dev)
2474 __field(xfs_ino_t, ino)
2475 __field(uint32_t, op_flags)
2476 __field(int, idx)
2477 ),
2478 TP_fast_assign(
2479 __entry->dev = VFS_I(args->dp)->i_sb->s_dev;
2480 __entry->ino = args->dp->i_ino;
2481 __entry->op_flags = args->op_flags;
2482 __entry->idx = idx;
2483 ),
2484 TP_printk("dev %d:%d ino 0x%llx op_flags %s index %d",
2485 MAJOR(__entry->dev), MINOR(__entry->dev),
2486 __entry->ino,
2487 __print_flags(__entry->op_flags, "|", XFS_DA_OP_FLAGS),
2488 __entry->idx)
2489)
2490
2491#define DEFINE_DIR2_SPACE_EVENT(name) \
2492DEFINE_EVENT(xfs_dir2_space_class, name, \
2493 TP_PROTO(struct xfs_da_args *args, int idx), \
2494 TP_ARGS(args, idx))
2495DEFINE_DIR2_SPACE_EVENT(xfs_dir2_leafn_add);
2496DEFINE_DIR2_SPACE_EVENT(xfs_dir2_leafn_remove);
2497DEFINE_DIR2_SPACE_EVENT(xfs_dir2_grow_inode);
2498DEFINE_DIR2_SPACE_EVENT(xfs_dir2_shrink_inode);
2499
2500TRACE_EVENT(xfs_dir2_leafn_moveents,
2501 TP_PROTO(struct xfs_da_args *args, int src_idx, int dst_idx, int count),
2502 TP_ARGS(args, src_idx, dst_idx, count),
2503 TP_STRUCT__entry(
2504 __field(dev_t, dev)
2505 __field(xfs_ino_t, ino)
2506 __field(uint32_t, op_flags)
2507 __field(int, src_idx)
2508 __field(int, dst_idx)
2509 __field(int, count)
2510 ),
2511 TP_fast_assign(
2512 __entry->dev = VFS_I(args->dp)->i_sb->s_dev;
2513 __entry->ino = args->dp->i_ino;
2514 __entry->op_flags = args->op_flags;
2515 __entry->src_idx = src_idx;
2516 __entry->dst_idx = dst_idx;
2517 __entry->count = count;
2518 ),
2519 TP_printk("dev %d:%d ino 0x%llx op_flags %s "
2520 "src_idx %d dst_idx %d count %d",
2521 MAJOR(__entry->dev), MINOR(__entry->dev),
2522 __entry->ino,
2523 __print_flags(__entry->op_flags, "|", XFS_DA_OP_FLAGS),
2524 __entry->src_idx,
2525 __entry->dst_idx,
2526 __entry->count)
2527);
2528
2529#define XFS_SWAPEXT_INODES \
2530 { 0, "target" }, \
2531 { 1, "temp" }
2532
2533TRACE_DEFINE_ENUM(XFS_DINODE_FMT_DEV);
2534TRACE_DEFINE_ENUM(XFS_DINODE_FMT_LOCAL);
2535TRACE_DEFINE_ENUM(XFS_DINODE_FMT_EXTENTS);
2536TRACE_DEFINE_ENUM(XFS_DINODE_FMT_BTREE);
2537TRACE_DEFINE_ENUM(XFS_DINODE_FMT_UUID);
2538TRACE_DEFINE_ENUM(XFS_DINODE_FMT_META_BTREE);
2539
2540DECLARE_EVENT_CLASS(xfs_swap_extent_class,
2541 TP_PROTO(struct xfs_inode *ip, int which),
2542 TP_ARGS(ip, which),
2543 TP_STRUCT__entry(
2544 __field(dev_t, dev)
2545 __field(int, which)
2546 __field(xfs_ino_t, ino)
2547 __field(int, format)
2548 __field(xfs_extnum_t, nex)
2549 __field(int, broot_size)
2550 __field(int, fork_off)
2551 ),
2552 TP_fast_assign(
2553 __entry->dev = VFS_I(ip)->i_sb->s_dev;
2554 __entry->which = which;
2555 __entry->ino = ip->i_ino;
2556 __entry->format = ip->i_df.if_format;
2557 __entry->nex = ip->i_df.if_nextents;
2558 __entry->broot_size = ip->i_df.if_broot_bytes;
2559 __entry->fork_off = xfs_inode_fork_boff(ip);
2560 ),
2561 TP_printk("dev %d:%d ino 0x%llx (%s), %s format, num_extents %llu, "
2562 "broot size %d, forkoff 0x%x",
2563 MAJOR(__entry->dev), MINOR(__entry->dev),
2564 __entry->ino,
2565 __print_symbolic(__entry->which, XFS_SWAPEXT_INODES),
2566 __print_symbolic(__entry->format, XFS_INODE_FORMAT_STR),
2567 __entry->nex,
2568 __entry->broot_size,
2569 __entry->fork_off)
2570)
2571
2572#define DEFINE_SWAPEXT_EVENT(name) \
2573DEFINE_EVENT(xfs_swap_extent_class, name, \
2574 TP_PROTO(struct xfs_inode *ip, int which), \
2575 TP_ARGS(ip, which))
2576
2577DEFINE_SWAPEXT_EVENT(xfs_swap_extent_before);
2578DEFINE_SWAPEXT_EVENT(xfs_swap_extent_after);
2579
2580TRACE_EVENT(xfs_log_recover,
2581 TP_PROTO(struct xlog *log, xfs_daddr_t headblk, xfs_daddr_t tailblk),
2582 TP_ARGS(log, headblk, tailblk),
2583 TP_STRUCT__entry(
2584 __field(dev_t, dev)
2585 __field(xfs_daddr_t, headblk)
2586 __field(xfs_daddr_t, tailblk)
2587 ),
2588 TP_fast_assign(
2589 __entry->dev = log->l_mp->m_super->s_dev;
2590 __entry->headblk = headblk;
2591 __entry->tailblk = tailblk;
2592 ),
2593 TP_printk("dev %d:%d headblk 0x%llx tailblk 0x%llx",
2594 MAJOR(__entry->dev), MINOR(__entry->dev), __entry->headblk,
2595 __entry->tailblk)
2596)
2597
2598TRACE_EVENT(xfs_log_recover_record,
2599 TP_PROTO(struct xlog *log, struct xlog_rec_header *rhead, int pass),
2600 TP_ARGS(log, rhead, pass),
2601 TP_STRUCT__entry(
2602 __field(dev_t, dev)
2603 __field(xfs_lsn_t, lsn)
2604 __field(int, len)
2605 __field(int, num_logops)
2606 __field(int, pass)
2607 ),
2608 TP_fast_assign(
2609 __entry->dev = log->l_mp->m_super->s_dev;
2610 __entry->lsn = be64_to_cpu(rhead->h_lsn);
2611 __entry->len = be32_to_cpu(rhead->h_len);
2612 __entry->num_logops = be32_to_cpu(rhead->h_num_logops);
2613 __entry->pass = pass;
2614 ),
2615 TP_printk("dev %d:%d lsn 0x%llx len 0x%x num_logops 0x%x pass %d",
2616 MAJOR(__entry->dev), MINOR(__entry->dev),
2617 __entry->lsn, __entry->len, __entry->num_logops,
2618 __entry->pass)
2619)
2620
2621DECLARE_EVENT_CLASS(xfs_log_recover_item_class,
2622 TP_PROTO(struct xlog *log, struct xlog_recover *trans,
2623 struct xlog_recover_item *item, int pass),
2624 TP_ARGS(log, trans, item, pass),
2625 TP_STRUCT__entry(
2626 __field(dev_t, dev)
2627 __field(unsigned long, item)
2628 __field(xlog_tid_t, tid)
2629 __field(xfs_lsn_t, lsn)
2630 __field(int, type)
2631 __field(int, pass)
2632 __field(int, count)
2633 __field(int, total)
2634 ),
2635 TP_fast_assign(
2636 __entry->dev = log->l_mp->m_super->s_dev;
2637 __entry->item = (unsigned long)item;
2638 __entry->tid = trans->r_log_tid;
2639 __entry->lsn = trans->r_lsn;
2640 __entry->type = ITEM_TYPE(item);
2641 __entry->pass = pass;
2642 __entry->count = item->ri_cnt;
2643 __entry->total = item->ri_total;
2644 ),
2645 TP_printk("dev %d:%d tid 0x%x lsn 0x%llx, pass %d, item %p, "
2646 "item type %s item region count/total %d/%d",
2647 MAJOR(__entry->dev), MINOR(__entry->dev),
2648 __entry->tid,
2649 __entry->lsn,
2650 __entry->pass,
2651 (void *)__entry->item,
2652 __print_symbolic(__entry->type, XFS_LI_TYPE_DESC),
2653 __entry->count,
2654 __entry->total)
2655)
2656
2657#define DEFINE_LOG_RECOVER_ITEM(name) \
2658DEFINE_EVENT(xfs_log_recover_item_class, name, \
2659 TP_PROTO(struct xlog *log, struct xlog_recover *trans, \
2660 struct xlog_recover_item *item, int pass), \
2661 TP_ARGS(log, trans, item, pass))
2662
2663DEFINE_LOG_RECOVER_ITEM(xfs_log_recover_item_add);
2664DEFINE_LOG_RECOVER_ITEM(xfs_log_recover_item_add_cont);
2665DEFINE_LOG_RECOVER_ITEM(xfs_log_recover_item_reorder_head);
2666DEFINE_LOG_RECOVER_ITEM(xfs_log_recover_item_reorder_tail);
2667DEFINE_LOG_RECOVER_ITEM(xfs_log_recover_item_recover);
2668
2669DECLARE_EVENT_CLASS(xfs_log_recover_buf_item_class,
2670 TP_PROTO(struct xlog *log, struct xfs_buf_log_format *buf_f),
2671 TP_ARGS(log, buf_f),
2672 TP_STRUCT__entry(
2673 __field(dev_t, dev)
2674 __field(int64_t, blkno)
2675 __field(unsigned short, len)
2676 __field(unsigned short, flags)
2677 __field(unsigned short, size)
2678 __field(unsigned int, map_size)
2679 ),
2680 TP_fast_assign(
2681 __entry->dev = log->l_mp->m_super->s_dev;
2682 __entry->blkno = buf_f->blf_blkno;
2683 __entry->len = buf_f->blf_len;
2684 __entry->flags = buf_f->blf_flags;
2685 __entry->size = buf_f->blf_size;
2686 __entry->map_size = buf_f->blf_map_size;
2687 ),
2688 TP_printk("dev %d:%d daddr 0x%llx, bbcount 0x%x, flags 0x%x, size %d, "
2689 "map_size %d",
2690 MAJOR(__entry->dev), MINOR(__entry->dev),
2691 __entry->blkno,
2692 __entry->len,
2693 __entry->flags,
2694 __entry->size,
2695 __entry->map_size)
2696)
2697
2698#define DEFINE_LOG_RECOVER_BUF_ITEM(name) \
2699DEFINE_EVENT(xfs_log_recover_buf_item_class, name, \
2700 TP_PROTO(struct xlog *log, struct xfs_buf_log_format *buf_f), \
2701 TP_ARGS(log, buf_f))
2702
2703DEFINE_LOG_RECOVER_BUF_ITEM(xfs_log_recover_buf_not_cancel);
2704DEFINE_LOG_RECOVER_BUF_ITEM(xfs_log_recover_buf_cancel);
2705DEFINE_LOG_RECOVER_BUF_ITEM(xfs_log_recover_buf_cancel_add);
2706DEFINE_LOG_RECOVER_BUF_ITEM(xfs_log_recover_buf_cancel_ref_inc);
2707DEFINE_LOG_RECOVER_BUF_ITEM(xfs_log_recover_buf_recover);
2708DEFINE_LOG_RECOVER_BUF_ITEM(xfs_log_recover_buf_skip);
2709DEFINE_LOG_RECOVER_BUF_ITEM(xfs_log_recover_buf_inode_buf);
2710DEFINE_LOG_RECOVER_BUF_ITEM(xfs_log_recover_buf_reg_buf);
2711DEFINE_LOG_RECOVER_BUF_ITEM(xfs_log_recover_buf_dquot_buf);
2712
2713DECLARE_EVENT_CLASS(xfs_log_recover_ino_item_class,
2714 TP_PROTO(struct xlog *log, struct xfs_inode_log_format *in_f),
2715 TP_ARGS(log, in_f),
2716 TP_STRUCT__entry(
2717 __field(dev_t, dev)
2718 __field(xfs_ino_t, ino)
2719 __field(unsigned short, size)
2720 __field(int, fields)
2721 __field(unsigned short, asize)
2722 __field(unsigned short, dsize)
2723 __field(int64_t, blkno)
2724 __field(int, len)
2725 __field(int, boffset)
2726 ),
2727 TP_fast_assign(
2728 __entry->dev = log->l_mp->m_super->s_dev;
2729 __entry->ino = in_f->ilf_ino;
2730 __entry->size = in_f->ilf_size;
2731 __entry->fields = in_f->ilf_fields;
2732 __entry->asize = in_f->ilf_asize;
2733 __entry->dsize = in_f->ilf_dsize;
2734 __entry->blkno = in_f->ilf_blkno;
2735 __entry->len = in_f->ilf_len;
2736 __entry->boffset = in_f->ilf_boffset;
2737 ),
2738 TP_printk("dev %d:%d ino 0x%llx, size %u, fields 0x%x, asize %d, "
2739 "dsize %d, daddr 0x%llx, bbcount 0x%x, boffset %d",
2740 MAJOR(__entry->dev), MINOR(__entry->dev),
2741 __entry->ino,
2742 __entry->size,
2743 __entry->fields,
2744 __entry->asize,
2745 __entry->dsize,
2746 __entry->blkno,
2747 __entry->len,
2748 __entry->boffset)
2749)
2750#define DEFINE_LOG_RECOVER_INO_ITEM(name) \
2751DEFINE_EVENT(xfs_log_recover_ino_item_class, name, \
2752 TP_PROTO(struct xlog *log, struct xfs_inode_log_format *in_f), \
2753 TP_ARGS(log, in_f))
2754
2755DEFINE_LOG_RECOVER_INO_ITEM(xfs_log_recover_inode_recover);
2756DEFINE_LOG_RECOVER_INO_ITEM(xfs_log_recover_inode_cancel);
2757DEFINE_LOG_RECOVER_INO_ITEM(xfs_log_recover_inode_skip);
2758
2759DECLARE_EVENT_CLASS(xfs_log_recover_icreate_item_class,
2760 TP_PROTO(struct xlog *log, struct xfs_icreate_log *in_f),
2761 TP_ARGS(log, in_f),
2762 TP_STRUCT__entry(
2763 __field(dev_t, dev)
2764 __field(xfs_agnumber_t, agno)
2765 __field(xfs_agblock_t, agbno)
2766 __field(unsigned int, count)
2767 __field(unsigned int, isize)
2768 __field(xfs_agblock_t, length)
2769 __field(unsigned int, gen)
2770 ),
2771 TP_fast_assign(
2772 __entry->dev = log->l_mp->m_super->s_dev;
2773 __entry->agno = be32_to_cpu(in_f->icl_ag);
2774 __entry->agbno = be32_to_cpu(in_f->icl_agbno);
2775 __entry->count = be32_to_cpu(in_f->icl_count);
2776 __entry->isize = be32_to_cpu(in_f->icl_isize);
2777 __entry->length = be32_to_cpu(in_f->icl_length);
2778 __entry->gen = be32_to_cpu(in_f->icl_gen);
2779 ),
2780 TP_printk("dev %d:%d agno 0x%x agbno 0x%x fsbcount 0x%x ireccount %u isize %u gen 0x%x",
2781 MAJOR(__entry->dev), MINOR(__entry->dev),
2782 __entry->agno,
2783 __entry->agbno,
2784 __entry->length,
2785 __entry->count,
2786 __entry->isize,
2787 __entry->gen)
2788)
2789#define DEFINE_LOG_RECOVER_ICREATE_ITEM(name) \
2790DEFINE_EVENT(xfs_log_recover_icreate_item_class, name, \
2791 TP_PROTO(struct xlog *log, struct xfs_icreate_log *in_f), \
2792 TP_ARGS(log, in_f))
2793
2794DEFINE_LOG_RECOVER_ICREATE_ITEM(xfs_log_recover_icreate_cancel);
2795DEFINE_LOG_RECOVER_ICREATE_ITEM(xfs_log_recover_icreate_recover);
2796
2797DECLARE_EVENT_CLASS(xfs_discard_class,
2798 TP_PROTO(const struct xfs_group *xg, xfs_agblock_t agbno,
2799 xfs_extlen_t len),
2800 TP_ARGS(xg, agbno, len),
2801 TP_STRUCT__entry(
2802 __field(dev_t, dev)
2803 __field(enum xfs_group_type, type)
2804 __field(xfs_agnumber_t, agno)
2805 __field(xfs_agblock_t, agbno)
2806 __field(xfs_extlen_t, len)
2807 ),
2808 TP_fast_assign(
2809 __entry->dev = xg->xg_mount->m_super->s_dev;
2810 __entry->type = xg->xg_type;
2811 __entry->agno = xg->xg_gno;
2812 __entry->agbno = agbno;
2813 __entry->len = len;
2814 ),
2815 TP_printk("dev %d:%d %sno 0x%x gbno 0x%x fsbcount 0x%x",
2816 MAJOR(__entry->dev), MINOR(__entry->dev),
2817 __print_symbolic(__entry->type, XG_TYPE_STRINGS),
2818 __entry->agno,
2819 __entry->agbno,
2820 __entry->len)
2821)
2822
2823#define DEFINE_DISCARD_EVENT(name) \
2824DEFINE_EVENT(xfs_discard_class, name, \
2825 TP_PROTO(const struct xfs_group *xg, xfs_agblock_t