1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /*
3 * Copyright (C) 2017-2023 Oracle. All Rights Reserved.
4 * Author: Darrick J. Wong <djwong@kernel.org>
5 *
6 * NOTE: none of these tracepoints shall be considered a stable kernel ABI
7 * as they can change at any time. See xfs_trace.h for documentation of
8 * specific units found in tracepoint output.
9 */
10 #undef TRACE_SYSTEM
11 #define TRACE_SYSTEM xfs_scrub
12
13 #if !defined(_TRACE_XFS_SCRUB_TRACE_H) || defined(TRACE_HEADER_MULTI_READ)
14 #define _TRACE_XFS_SCRUB_TRACE_H
15
16 #include <linux/tracepoint.h>
17 #include "xfs_bit.h"
18 #include "xfs_quota_defs.h"
19
20 struct xfs_scrub;
21 struct xfile;
22 struct xfarray;
23 struct xfarray_sortinfo;
24 struct xchk_dqiter;
25 struct xchk_iscan;
26 struct xchk_nlink;
27 struct xchk_fscounters;
28 struct xfs_rmap_update_params;
29 struct xfs_parent_rec;
30 enum xchk_dirpath_outcome;
31 struct xchk_dirtree;
32 struct xchk_dirtree_outcomes;
33
34 /*
35 * ftrace's __print_symbolic requires that all enum values be wrapped in the
36 * TRACE_DEFINE_ENUM macro so that the enum value can be encoded in the ftrace
37 * ring buffer. Somehow this was only worth mentioning in the ftrace sample
38 * code.
39 */
40 TRACE_DEFINE_ENUM(XFS_REFC_DOMAIN_SHARED);
41 TRACE_DEFINE_ENUM(XFS_REFC_DOMAIN_COW);
42
43 TRACE_DEFINE_ENUM(XFS_SCRUB_TYPE_PROBE);
44 TRACE_DEFINE_ENUM(XFS_SCRUB_TYPE_SB);
45 TRACE_DEFINE_ENUM(XFS_SCRUB_TYPE_AGF);
46 TRACE_DEFINE_ENUM(XFS_SCRUB_TYPE_AGFL);
47 TRACE_DEFINE_ENUM(XFS_SCRUB_TYPE_AGI);
48 TRACE_DEFINE_ENUM(XFS_SCRUB_TYPE_BNOBT);
49 TRACE_DEFINE_ENUM(XFS_SCRUB_TYPE_CNTBT);
50 TRACE_DEFINE_ENUM(XFS_SCRUB_TYPE_INOBT);
51 TRACE_DEFINE_ENUM(XFS_SCRUB_TYPE_FINOBT);
52 TRACE_DEFINE_ENUM(XFS_SCRUB_TYPE_RMAPBT);
53 TRACE_DEFINE_ENUM(XFS_SCRUB_TYPE_REFCNTBT);
54 TRACE_DEFINE_ENUM(XFS_SCRUB_TYPE_INODE);
55 TRACE_DEFINE_ENUM(XFS_SCRUB_TYPE_BMBTD);
56 TRACE_DEFINE_ENUM(XFS_SCRUB_TYPE_BMBTA);
57 TRACE_DEFINE_ENUM(XFS_SCRUB_TYPE_BMBTC);
58 TRACE_DEFINE_ENUM(XFS_SCRUB_TYPE_DIR);
59 TRACE_DEFINE_ENUM(XFS_SCRUB_TYPE_XATTR);
60 TRACE_DEFINE_ENUM(XFS_SCRUB_TYPE_SYMLINK);
61 TRACE_DEFINE_ENUM(XFS_SCRUB_TYPE_PARENT);
62 TRACE_DEFINE_ENUM(XFS_SCRUB_TYPE_RTBITMAP);
63 TRACE_DEFINE_ENUM(XFS_SCRUB_TYPE_RTSUM);
64 TRACE_DEFINE_ENUM(XFS_SCRUB_TYPE_UQUOTA);
65 TRACE_DEFINE_ENUM(XFS_SCRUB_TYPE_GQUOTA);
66 TRACE_DEFINE_ENUM(XFS_SCRUB_TYPE_PQUOTA);
67 TRACE_DEFINE_ENUM(XFS_SCRUB_TYPE_FSCOUNTERS);
68 TRACE_DEFINE_ENUM(XFS_SCRUB_TYPE_QUOTACHECK);
69 TRACE_DEFINE_ENUM(XFS_SCRUB_TYPE_NLINKS);
70 TRACE_DEFINE_ENUM(XFS_SCRUB_TYPE_HEALTHY);
71 TRACE_DEFINE_ENUM(XFS_SCRUB_TYPE_DIRTREE);
72 TRACE_DEFINE_ENUM(XFS_SCRUB_TYPE_BARRIER);
73
74 #define XFS_SCRUB_TYPE_STRINGS \
75 { XFS_SCRUB_TYPE_PROBE, "probe" }, \
76 { XFS_SCRUB_TYPE_SB, "sb" }, \
77 { XFS_SCRUB_TYPE_AGF, "agf" }, \
78 { XFS_SCRUB_TYPE_AGFL, "agfl" }, \
79 { XFS_SCRUB_TYPE_AGI, "agi" }, \
80 { XFS_SCRUB_TYPE_BNOBT, "bnobt" }, \
81 { XFS_SCRUB_TYPE_CNTBT, "cntbt" }, \
82 { XFS_SCRUB_TYPE_INOBT, "inobt" }, \
83 { XFS_SCRUB_TYPE_FINOBT, "finobt" }, \
84 { XFS_SCRUB_TYPE_RMAPBT, "rmapbt" }, \
85 { XFS_SCRUB_TYPE_REFCNTBT, "refcountbt" }, \
86 { XFS_SCRUB_TYPE_INODE, "inode" }, \
87 { XFS_SCRUB_TYPE_BMBTD, "bmapbtd" }, \
88 { XFS_SCRUB_TYPE_BMBTA, "bmapbta" }, \
89 { XFS_SCRUB_TYPE_BMBTC, "bmapbtc" }, \
90 { XFS_SCRUB_TYPE_DIR, "directory" }, \
91 { XFS_SCRUB_TYPE_XATTR, "xattr" }, \
92 { XFS_SCRUB_TYPE_SYMLINK, "symlink" }, \
93 { XFS_SCRUB_TYPE_PARENT, "parent" }, \
94 { XFS_SCRUB_TYPE_RTBITMAP, "rtbitmap" }, \
95 { XFS_SCRUB_TYPE_RTSUM, "rtsummary" }, \
96 { XFS_SCRUB_TYPE_UQUOTA, "usrquota" }, \
97 { XFS_SCRUB_TYPE_GQUOTA, "grpquota" }, \
98 { XFS_SCRUB_TYPE_PQUOTA, "prjquota" }, \
99 { XFS_SCRUB_TYPE_FSCOUNTERS, "fscounters" }, \
100 { XFS_SCRUB_TYPE_QUOTACHECK, "quotacheck" }, \
101 { XFS_SCRUB_TYPE_NLINKS, "nlinks" }, \
102 { XFS_SCRUB_TYPE_HEALTHY, "healthy" }, \
103 { XFS_SCRUB_TYPE_DIRTREE, "dirtree" }, \
104 { XFS_SCRUB_TYPE_BARRIER, "barrier" }
105
106 #define XFS_SCRUB_FLAG_STRINGS \
107 { XFS_SCRUB_IFLAG_REPAIR, "repair" }, \
108 { XFS_SCRUB_OFLAG_CORRUPT, "corrupt" }, \
109 { XFS_SCRUB_OFLAG_PREEN, "preen" }, \
110 { XFS_SCRUB_OFLAG_XFAIL, "xfail" }, \
111 { XFS_SCRUB_OFLAG_XCORRUPT, "xcorrupt" }, \
112 { XFS_SCRUB_OFLAG_INCOMPLETE, "incomplete" }, \
113 { XFS_SCRUB_OFLAG_WARNING, "warning" }, \
114 { XFS_SCRUB_OFLAG_NO_REPAIR_NEEDED, "norepair" }, \
115 { XFS_SCRUB_IFLAG_FORCE_REBUILD, "rebuild" }
116
117 #define XFS_SCRUB_STATE_STRINGS \
118 { XCHK_TRY_HARDER, "try_harder" }, \
119 { XCHK_HAVE_FREEZE_PROT, "nofreeze" }, \
120 { XCHK_FSGATES_DRAIN, "fsgates_drain" }, \
121 { XCHK_NEED_DRAIN, "need_drain" }, \
122 { XCHK_FSGATES_QUOTA, "fsgates_quota" }, \
123 { XCHK_FSGATES_DIRENTS, "fsgates_dirents" }, \
124 { XCHK_FSGATES_RMAP, "fsgates_rmap" }, \
125 { XREP_RESET_PERAG_RESV, "reset_perag_resv" }, \
126 { XREP_ALREADY_FIXED, "already_fixed" }
127
128 TRACE_DEFINE_ENUM(XFS_RMAP_MAP);
129 TRACE_DEFINE_ENUM(XFS_RMAP_MAP_SHARED);
130 TRACE_DEFINE_ENUM(XFS_RMAP_UNMAP);
131 TRACE_DEFINE_ENUM(XFS_RMAP_UNMAP_SHARED);
132 TRACE_DEFINE_ENUM(XFS_RMAP_CONVERT);
133 TRACE_DEFINE_ENUM(XFS_RMAP_CONVERT_SHARED);
134 TRACE_DEFINE_ENUM(XFS_RMAP_ALLOC);
135 TRACE_DEFINE_ENUM(XFS_RMAP_FREE);
136
137 DECLARE_EVENT_CLASS(xchk_class,
138 TP_PROTO(struct xfs_inode *ip, struct xfs_scrub_metadata *sm,
139 int error),
140 TP_ARGS(ip, sm, error),
141 TP_STRUCT__entry(
142 __field(dev_t, dev)
143 __field(xfs_ino_t, ino)
144 __field(unsigned int, type)
145 __field(xfs_agnumber_t, agno)
146 __field(xfs_ino_t, inum)
147 __field(unsigned int, gen)
148 __field(unsigned int, flags)
149 __field(int, error)
150 ),
151 TP_fast_assign(
152 __entry->dev = ip->i_mount->m_super->s_dev;
153 __entry->ino = ip->i_ino;
154 __entry->type = sm->sm_type;
155 __entry->agno = sm->sm_agno;
156 __entry->inum = sm->sm_ino;
157 __entry->gen = sm->sm_gen;
158 __entry->flags = sm->sm_flags;
159 __entry->error = error;
160 ),
161 TP_printk("dev %d:%d ino 0x%llx type %s agno 0x%x inum 0x%llx gen 0x%x flags (%s) error %d",
162 MAJOR(__entry->dev), MINOR(__entry->dev),
163 __entry->ino,
164 __print_symbolic(__entry->type, XFS_SCRUB_TYPE_STRINGS),
165 __entry->agno,
166 __entry->inum,
167 __entry->gen,
168 __print_flags(__entry->flags, "|", XFS_SCRUB_FLAG_STRINGS),
169 __entry->error)
170 )
171 #define DEFINE_SCRUB_EVENT(name) \
172 DEFINE_EVENT(xchk_class, name, \
173 TP_PROTO(struct xfs_inode *ip, struct xfs_scrub_metadata *sm, \
174 int error), \
175 TP_ARGS(ip, sm, error))
176
177 DEFINE_SCRUB_EVENT(xchk_start);
178 DEFINE_SCRUB_EVENT(xchk_done);
179 DEFINE_SCRUB_EVENT(xchk_deadlock_retry);
180 DEFINE_SCRUB_EVENT(xchk_dirtree_start);
181 DEFINE_SCRUB_EVENT(xchk_dirtree_done);
182 DEFINE_SCRUB_EVENT(xrep_attempt);
183 DEFINE_SCRUB_EVENT(xrep_done);
184
185 DECLARE_EVENT_CLASS(xchk_fsgate_class,
186 TP_PROTO(struct xfs_scrub *sc, unsigned int fsgate_flags),
187 TP_ARGS(sc, fsgate_flags),
188 TP_STRUCT__entry(
189 __field(dev_t, dev)
190 __field(unsigned int, type)
191 __field(unsigned int, fsgate_flags)
192 ),
193 TP_fast_assign(
194 __entry->dev = sc->mp->m_super->s_dev;
195 __entry->type = sc->sm->sm_type;
196 __entry->fsgate_flags = fsgate_flags;
197 ),
198 TP_printk("dev %d:%d type %s fsgates '%s'",
199 MAJOR(__entry->dev), MINOR(__entry->dev),
200 __print_symbolic(__entry->type, XFS_SCRUB_TYPE_STRINGS),
201 __print_flags(__entry->fsgate_flags, "|", XFS_SCRUB_STATE_STRINGS))
202 )
203
204 #define DEFINE_SCRUB_FSHOOK_EVENT(name) \
205 DEFINE_EVENT(xchk_fsgate_class, name, \
206 TP_PROTO(struct xfs_scrub *sc, unsigned int fsgates_flags), \
207 TP_ARGS(sc, fsgates_flags))
208
209 DEFINE_SCRUB_FSHOOK_EVENT(xchk_fsgates_enable);
210 DEFINE_SCRUB_FSHOOK_EVENT(xchk_fsgates_disable);
211
212 DECLARE_EVENT_CLASS(xchk_vector_head_class,
213 TP_PROTO(struct xfs_inode *ip, struct xfs_scrub_vec_head *vhead),
214 TP_ARGS(ip, vhead),
215 TP_STRUCT__entry(
216 __field(dev_t, dev)
217 __field(xfs_ino_t, ino)
218 __field(xfs_agnumber_t, agno)
219 __field(xfs_ino_t, inum)
220 __field(unsigned int, gen)
221 __field(unsigned int, flags)
222 __field(unsigned short, rest_us)
223 __field(unsigned short, nr_vecs)
224 ),
225 TP_fast_assign(
226 __entry->dev = ip->i_mount->m_super->s_dev;
227 __entry->ino = ip->i_ino;
228 __entry->agno = vhead->svh_agno;
229 __entry->inum = vhead->svh_ino;
230 __entry->gen = vhead->svh_gen;
231 __entry->flags = vhead->svh_flags;
232 __entry->rest_us = vhead->svh_rest_us;
233 __entry->nr_vecs = vhead->svh_nr;
234 ),
235 TP_printk("dev %d:%d ino 0x%llx agno 0x%x inum 0x%llx gen 0x%x flags 0x%x rest_us %u nr_vecs %u",
236 MAJOR(__entry->dev), MINOR(__entry->dev),
237 __entry->ino,
238 __entry->agno,
239 __entry->inum,
240 __entry->gen,
241 __entry->flags,
242 __entry->rest_us,
243 __entry->nr_vecs)
244 )
245 #define DEFINE_SCRUBV_HEAD_EVENT(name) \
246 DEFINE_EVENT(xchk_vector_head_class, name, \
247 TP_PROTO(struct xfs_inode *ip, struct xfs_scrub_vec_head *vhead), \
248 TP_ARGS(ip, vhead))
249
250 DEFINE_SCRUBV_HEAD_EVENT(xchk_scrubv_start);
251
252 DECLARE_EVENT_CLASS(xchk_vector_class,
253 TP_PROTO(struct xfs_mount *mp, struct xfs_scrub_vec_head *vhead,
254 unsigned int vec_nr, struct xfs_scrub_vec *v),
255 TP_ARGS(mp, vhead, vec_nr, v),
256 TP_STRUCT__entry(
257 __field(dev_t, dev)
258 __field(unsigned int, vec_nr)
259 __field(unsigned int, vec_type)
260 __field(unsigned int, vec_flags)
261 __field(int, vec_ret)
262 ),
263 TP_fast_assign(
264 __entry->dev = mp->m_super->s_dev;
265 __entry->vec_nr = vec_nr;
266 __entry->vec_type = v->sv_type;
267 __entry->vec_flags = v->sv_flags;
268 __entry->vec_ret = v->sv_ret;
269 ),
270 TP_printk("dev %d:%d vec[%u] type %s flags %s ret %d",
271 MAJOR(__entry->dev), MINOR(__entry->dev),
272 __entry->vec_nr,
273 __print_symbolic(__entry->vec_type, XFS_SCRUB_TYPE_STRINGS),
274 __print_flags(__entry->vec_flags, "|", XFS_SCRUB_FLAG_STRINGS),
275 __entry->vec_ret)
276 )
277 #define DEFINE_SCRUBV_EVENT(name) \
278 DEFINE_EVENT(xchk_vector_class, name, \
279 TP_PROTO(struct xfs_mount *mp, struct xfs_scrub_vec_head *vhead, \
280 unsigned int vec_nr, struct xfs_scrub_vec *v), \
281 TP_ARGS(mp, vhead, vec_nr, v))
282
283 DEFINE_SCRUBV_EVENT(xchk_scrubv_barrier_fail);
284 DEFINE_SCRUBV_EVENT(xchk_scrubv_item);
285 DEFINE_SCRUBV_EVENT(xchk_scrubv_outcome);
286
287 TRACE_EVENT(xchk_op_error,
288 TP_PROTO(struct xfs_scrub *sc, xfs_agnumber_t agno,
289 xfs_agblock_t bno, int error, void *ret_ip),
290 TP_ARGS(sc, agno, bno, error, ret_ip),
291 TP_STRUCT__entry(
292 __field(dev_t, dev)
293 __field(unsigned int, type)
294 __field(xfs_agnumber_t, agno)
295 __field(xfs_agblock_t, bno)
296 __field(int, error)
297 __field(void *, ret_ip)
298 ),
299 TP_fast_assign(
300 __entry->dev = sc->mp->m_super->s_dev;
301 __entry->type = sc->sm->sm_type;
302 __entry->agno = agno;
303 __entry->bno = bno;
304 __entry->error = error;
305 __entry->ret_ip = ret_ip;
306 ),
307 TP_printk("dev %d:%d type %s agno 0x%x agbno 0x%x error %d ret_ip %pS",
308 MAJOR(__entry->dev), MINOR(__entry->dev),
309 __print_symbolic(__entry->type, XFS_SCRUB_TYPE_STRINGS),
310 __entry->agno,
311 __entry->bno,
312 __entry->error,
313 __entry->ret_ip)
314 );
315
316 TRACE_EVENT(xchk_file_op_error,
317 TP_PROTO(struct xfs_scrub *sc, int whichfork,
318 xfs_fileoff_t offset, int error, void *ret_ip),
319 TP_ARGS(sc, whichfork, offset, error, ret_ip),
320 TP_STRUCT__entry(
321 __field(dev_t, dev)
322 __field(xfs_ino_t, ino)
323 __field(int, whichfork)
324 __field(unsigned int, type)
325 __field(xfs_fileoff_t, offset)
326 __field(int, error)
327 __field(void *, ret_ip)
328 ),
329 TP_fast_assign(
330 __entry->dev = sc->ip->i_mount->m_super->s_dev;
331 __entry->ino = sc->ip->i_ino;
332 __entry->whichfork = whichfork;
333 __entry->type = sc->sm->sm_type;
334 __entry->offset = offset;
335 __entry->error = error;
336 __entry->ret_ip = ret_ip;
337 ),
338 TP_printk("dev %d:%d ino 0x%llx fork %s type %s fileoff 0x%llx error %d ret_ip %pS",
339 MAJOR(__entry->dev), MINOR(__entry->dev),
340 __entry->ino,
341 __print_symbolic(__entry->whichfork, XFS_WHICHFORK_STRINGS),
342 __print_symbolic(__entry->type, XFS_SCRUB_TYPE_STRINGS),
343 __entry->offset,
344 __entry->error,
345 __entry->ret_ip)
346 );
347
348 DECLARE_EVENT_CLASS(xchk_block_error_class,
349 TP_PROTO(struct xfs_scrub *sc, xfs_daddr_t daddr, void *ret_ip),
350 TP_ARGS(sc, daddr, ret_ip),
351 TP_STRUCT__entry(
352 __field(dev_t, dev)
353 __field(unsigned int, type)
354 __field(xfs_agnumber_t, agno)
355 __field(xfs_agblock_t, agbno)
356 __field(void *, ret_ip)
357 ),
358 TP_fast_assign(
359 __entry->dev = sc->mp->m_super->s_dev;
360 __entry->type = sc->sm->sm_type;
361 __entry->agno = xfs_daddr_to_agno(sc->mp, daddr);
362 __entry->agbno = xfs_daddr_to_agbno(sc->mp, daddr);
363 __entry->ret_ip = ret_ip;
364 ),
365 TP_printk("dev %d:%d type %s agno 0x%x agbno 0x%x ret_ip %pS",
366 MAJOR(__entry->dev), MINOR(__entry->dev),
367 __print_symbolic(__entry->type, XFS_SCRUB_TYPE_STRINGS),
368 __entry->agno,
369 __entry->agbno,
370 __entry->ret_ip)
371 )
372
373 #define DEFINE_SCRUB_BLOCK_ERROR_EVENT(name) \
374 DEFINE_EVENT(xchk_block_error_class, name, \
375 TP_PROTO(struct xfs_scrub *sc, xfs_daddr_t daddr, \
376 void *ret_ip), \
377 TP_ARGS(sc, daddr, ret_ip))
378
379 DEFINE_SCRUB_BLOCK_ERROR_EVENT(xchk_fs_error);
380 DEFINE_SCRUB_BLOCK_ERROR_EVENT(xchk_block_error);
381 DEFINE_SCRUB_BLOCK_ERROR_EVENT(xchk_block_preen);
382
383 DECLARE_EVENT_CLASS(xchk_ino_error_class,
384 TP_PROTO(struct xfs_scrub *sc, xfs_ino_t ino, void *ret_ip),
385 TP_ARGS(sc, ino, ret_ip),
386 TP_STRUCT__entry(
387 __field(dev_t, dev)
388 __field(xfs_ino_t, ino)
389 __field(unsigned int, type)
390 __field(void *, ret_ip)
391 ),
392 TP_fast_assign(
393 __entry->dev = sc->mp->m_super->s_dev;
394 __entry->ino = ino;
395 __entry->type = sc->sm->sm_type;
396 __entry->ret_ip = ret_ip;
397 ),
398 TP_printk("dev %d:%d ino 0x%llx type %s ret_ip %pS",
399 MAJOR(__entry->dev), MINOR(__entry->dev),
400 __entry->ino,
401 __print_symbolic(__entry->type, XFS_SCRUB_TYPE_STRINGS),
402 __entry->ret_ip)
403 )
404
405 #define DEFINE_SCRUB_INO_ERROR_EVENT(name) \
406 DEFINE_EVENT(xchk_ino_error_class, name, \
407 TP_PROTO(struct xfs_scrub *sc, xfs_ino_t ino, \
408 void *ret_ip), \
409 TP_ARGS(sc, ino, ret_ip))
410
411 DEFINE_SCRUB_INO_ERROR_EVENT(xchk_ino_error);
412 DEFINE_SCRUB_INO_ERROR_EVENT(xchk_ino_preen);
413 DEFINE_SCRUB_INO_ERROR_EVENT(xchk_ino_warning);
414
415 DECLARE_EVENT_CLASS(xchk_fblock_error_class,
416 TP_PROTO(struct xfs_scrub *sc, int whichfork,
417 xfs_fileoff_t offset, void *ret_ip),
418 TP_ARGS(sc, whichfork, offset, ret_ip),
419 TP_STRUCT__entry(
420 __field(dev_t, dev)
421 __field(xfs_ino_t, ino)
422 __field(int, whichfork)
423 __field(unsigned int, type)
424 __field(xfs_fileoff_t, offset)
425 __field(void *, ret_ip)
426 ),
427 TP_fast_assign(
428 __entry->dev = sc->ip->i_mount->m_super->s_dev;
429 __entry->ino = sc->ip->i_ino;
430 __entry->whichfork = whichfork;
431 __entry->type = sc->sm->sm_type;
432 __entry->offset = offset;
433 __entry->ret_ip = ret_ip;
434 ),
435 TP_printk("dev %d:%d ino 0x%llx fork %s type %s fileoff 0x%llx ret_ip %pS",
436 MAJOR(__entry->dev), MINOR(__entry->dev),
437 __entry->ino,
438 __print_symbolic(__entry->whichfork, XFS_WHICHFORK_STRINGS),
439 __print_symbolic(__entry->type, XFS_SCRUB_TYPE_STRINGS),
440 __entry->offset,
441 __entry->ret_ip)
442 );
443
444 #define DEFINE_SCRUB_FBLOCK_ERROR_EVENT(name) \
445 DEFINE_EVENT(xchk_fblock_error_class, name, \
446 TP_PROTO(struct xfs_scrub *sc, int whichfork, \
447 xfs_fileoff_t offset, void *ret_ip), \
448 TP_ARGS(sc, whichfork, offset, ret_ip))
449
450 DEFINE_SCRUB_FBLOCK_ERROR_EVENT(xchk_fblock_error);
451 DEFINE_SCRUB_FBLOCK_ERROR_EVENT(xchk_fblock_warning);
452 DEFINE_SCRUB_FBLOCK_ERROR_EVENT(xchk_fblock_preen);
453
454 #ifdef CONFIG_XFS_QUOTA
455 DECLARE_EVENT_CLASS(xchk_dqiter_class,
456 TP_PROTO(struct xchk_dqiter *cursor, uint64_t id),
457 TP_ARGS(cursor, id),
458 TP_STRUCT__entry(
459 __field(dev_t, dev)
460 __field(xfs_dqtype_t, dqtype)
461 __field(xfs_ino_t, ino)
462 __field(unsigned long long, cur_id)
463 __field(unsigned long long, id)
464 __field(xfs_fileoff_t, startoff)
465 __field(xfs_fsblock_t, startblock)
466 __field(xfs_filblks_t, blockcount)
467 __field(xfs_exntst_t, state)
468 ),
469 TP_fast_assign(
470 __entry->dev = cursor->sc->ip->i_mount->m_super->s_dev;
471 __entry->dqtype = cursor->dqtype;
472 __entry->ino = cursor->quota_ip->i_ino;
473 __entry->cur_id = cursor->id;
474 __entry->startoff = cursor->bmap.br_startoff;
475 __entry->startblock = cursor->bmap.br_startblock;
476 __entry->blockcount = cursor->bmap.br_blockcount;
477 __entry->state = cursor->bmap.br_state;
478 __entry->id = id;
479 ),
480 TP_printk("dev %d:%d dquot type %s ino 0x%llx cursor_id 0x%llx startoff 0x%llx startblock 0x%llx blockcount 0x%llx state %u id 0x%llx",
481 MAJOR(__entry->dev), MINOR(__entry->dev),
482 __print_symbolic(__entry->dqtype, XFS_DQTYPE_STRINGS),
483 __entry->ino,
484 __entry->cur_id,
485 __entry->startoff,
486 __entry->startblock,
487 __entry->blockcount,
488 __entry->state,
489 __entry->id)
490 );
491
492 #define DEFINE_SCRUB_DQITER_EVENT(name) \
493 DEFINE_EVENT(xchk_dqiter_class, name, \
494 TP_PROTO(struct xchk_dqiter *cursor, uint64_t id), \
495 TP_ARGS(cursor, id))
496 DEFINE_SCRUB_DQITER_EVENT(xchk_dquot_iter_revalidate_bmap);
497 DEFINE_SCRUB_DQITER_EVENT(xchk_dquot_iter_advance_bmap);
498 DEFINE_SCRUB_DQITER_EVENT(xchk_dquot_iter_advance_incore);
499 DEFINE_SCRUB_DQITER_EVENT(xchk_dquot_iter);
500
501 TRACE_EVENT(xchk_qcheck_error,
502 TP_PROTO(struct xfs_scrub *sc, xfs_dqtype_t dqtype, xfs_dqid_t id,
503 void *ret_ip),
504 TP_ARGS(sc, dqtype, id, ret_ip),
505 TP_STRUCT__entry(
506 __field(dev_t, dev)
507 __field(xfs_dqtype_t, dqtype)
508 __field(xfs_dqid_t, id)
509 __field(void *, ret_ip)
510 ),
511 TP_fast_assign(
512 __entry->dev = sc->mp->m_super->s_dev;
513 __entry->dqtype = dqtype;
514 __entry->id = id;
515 __entry->ret_ip = ret_ip;
516 ),
517 TP_printk("dev %d:%d dquot type %s id 0x%x ret_ip %pS",
518 MAJOR(__entry->dev), MINOR(__entry->dev),
519 __print_symbolic(__entry->dqtype, XFS_DQTYPE_STRINGS),
520 __entry->id,
521 __entry->ret_ip)
522 );
523 #endif /* CONFIG_XFS_QUOTA */
524
525 TRACE_EVENT(xchk_incomplete,
526 TP_PROTO(struct xfs_scrub *sc, void *ret_ip),
527 TP_ARGS(sc, ret_ip),
528 TP_STRUCT__entry(
529 __field(dev_t, dev)
530 __field(unsigned int, type)
531 __field(void *, ret_ip)
532 ),
533 TP_fast_assign(
534 __entry->dev = sc->mp->m_super->s_dev;
535 __entry->type = sc->sm->sm_type;
536 __entry->ret_ip = ret_ip;
537 ),
538 TP_printk("dev %d:%d type %s ret_ip %pS",
539 MAJOR(__entry->dev), MINOR(__entry->dev),
540 __print_symbolic(__entry->type, XFS_SCRUB_TYPE_STRINGS),
541 __entry->ret_ip)
542 );
543
544 TRACE_EVENT(xchk_btree_op_error,
545 TP_PROTO(struct xfs_scrub *sc, struct xfs_btree_cur *cur,
546 int level, int error, void *ret_ip),
547 TP_ARGS(sc, cur, level, error, ret_ip),
548 TP_STRUCT__entry(
549 __field(dev_t, dev)
550 __field(unsigned int, type)
551 __string(name, cur->bc_ops->name)
552 __field(int, level)
553 __field(xfs_agnumber_t, agno)
554 __field(xfs_agblock_t, bno)
555 __field(int, ptr)
556 __field(int, error)
557 __field(void *, ret_ip)
558 ),
559 TP_fast_assign(
560 xfs_fsblock_t fsbno = xchk_btree_cur_fsbno(cur, level);
561
562 __entry->dev = sc->mp->m_super->s_dev;
563 __entry->type = sc->sm->sm_type;
564 __assign_str(name);
565 __entry->level = level;
566 __entry->agno = XFS_FSB_TO_AGNO(cur->bc_mp, fsbno);
567 __entry->bno = XFS_FSB_TO_AGBNO(cur->bc_mp, fsbno);
568 __entry->ptr = cur->bc_levels[level].ptr;
569 __entry->error = error;
570 __entry->ret_ip = ret_ip;
571 ),
572 TP_printk("dev %d:%d type %s %sbt level %d ptr %d agno 0x%x agbno 0x%x error %d ret_ip %pS",
573 MAJOR(__entry->dev), MINOR(__entry->dev),
574 __print_symbolic(__entry->type, XFS_SCRUB_TYPE_STRINGS),
575 __get_str(name),
576 __entry->level,
577 __entry->ptr,
578 __entry->agno,
579 __entry->bno,
580 __entry->error,
581 __entry->ret_ip)
582 );
583
584 TRACE_EVENT(xchk_ifork_btree_op_error,
585 TP_PROTO(struct xfs_scrub *sc, struct xfs_btree_cur *cur,
586 int level, int error, void *ret_ip),
587 TP_ARGS(sc, cur, level, error, ret_ip),
588 TP_STRUCT__entry(
589 __field(dev_t, dev)
590 __field(xfs_ino_t, ino)
591 __field(int, whichfork)
592 __field(unsigned int, type)
593 __string(name, cur->bc_ops->name)
594 __field(int, level)
595 __field(int, ptr)
596 __field(xfs_agnumber_t, agno)
597 __field(xfs_agblock_t, bno)
598 __field(int, error)
599 __field(void *, ret_ip)
600 ),
601 TP_fast_assign(
602 xfs_fsblock_t fsbno = xchk_btree_cur_fsbno(cur, level);
603 __entry->dev = sc->mp->m_super->s_dev;
604 __entry->ino = sc->ip->i_ino;
605 __entry->whichfork = cur->bc_ino.whichfork;
606 __entry->type = sc->sm->sm_type;
607 __assign_str(name);
608 __entry->level = level;
609 __entry->ptr = cur->bc_levels[level].ptr;
610 __entry->agno = XFS_FSB_TO_AGNO(cur->bc_mp, fsbno);
611 __entry->bno = XFS_FSB_TO_AGBNO(cur->bc_mp, fsbno);
612 __entry->error = error;
613 __entry->ret_ip = ret_ip;
614 ),
615 TP_printk("dev %d:%d ino 0x%llx fork %s type %s %sbt level %d ptr %d agno 0x%x agbno 0x%x error %d ret_ip %pS",
616 MAJOR(__entry->dev), MINOR(__entry->dev),
617 __entry->ino,
618 __print_symbolic(__entry->whichfork, XFS_WHICHFORK_STRINGS),
619 __print_symbolic(__entry->type, XFS_SCRUB_TYPE_STRINGS),
620 __get_str(name),
621 __entry->level,
622 __entry->ptr,
623 __entry->agno,
624 __entry->bno,
625 __entry->error,
626 __entry->ret_ip)
627 );
628
629 TRACE_EVENT(xchk_btree_error,
630 TP_PROTO(struct xfs_scrub *sc, struct xfs_btree_cur *cur,
631 int level, void *ret_ip),
632 TP_ARGS(sc, cur, level, ret_ip),
633 TP_STRUCT__entry(
634 __field(dev_t, dev)
635 __field(unsigned int, type)
636 __string(name, cur->bc_ops->name)
637 __field(int, level)
638 __field(xfs_agnumber_t, agno)
639 __field(xfs_agblock_t, bno)
640 __field(int, ptr)
641 __field(void *, ret_ip)
642 ),
643 TP_fast_assign(
644 xfs_fsblock_t fsbno = xchk_btree_cur_fsbno(cur, level);
645 __entry->dev = sc->mp->m_super->s_dev;
646 __entry->type = sc->sm->sm_type;
647 __assign_str(name);
648 __entry->level = level;
649 __entry->agno = XFS_FSB_TO_AGNO(cur->bc_mp, fsbno);
650 __entry->bno = XFS_FSB_TO_AGBNO(cur->bc_mp, fsbno);
651 __entry->ptr = cur->bc_levels[level].ptr;
652 __entry->ret_ip = ret_ip;
653 ),
654 TP_printk("dev %d:%d type %s %sbt level %d ptr %d agno 0x%x agbno 0x%x ret_ip %pS",
655 MAJOR(__entry->dev), MINOR(__entry->dev),
656 __print_symbolic(__entry->type, XFS_SCRUB_TYPE_STRINGS),
657 __get_str(name),
658 __entry->level,
659 __entry->ptr,
660 __entry->agno,
661 __entry->bno,
662 __entry->ret_ip)
663 );
664
665 TRACE_EVENT(xchk_ifork_btree_error,
666 TP_PROTO(struct xfs_scrub *sc, struct xfs_btree_cur *cur,
667 int level, void *ret_ip),
668 TP_ARGS(sc, cur, level, ret_ip),
669 TP_STRUCT__entry(
670 __field(dev_t, dev)
671 __field(xfs_ino_t, ino)
672 __field(int, whichfork)
673 __field(unsigned int, type)
674 __string(name, cur->bc_ops->name)
675 __field(int, level)
676 __field(xfs_agnumber_t, agno)
677 __field(xfs_agblock_t, bno)
678 __field(int, ptr)
679 __field(void *, ret_ip)
680 ),
681 TP_fast_assign(
682 xfs_fsblock_t fsbno = xchk_btree_cur_fsbno(cur, level);
683 __entry->dev = sc->mp->m_super->s_dev;
684 __entry->ino = sc->ip->i_ino;
685 __entry->whichfork = cur->bc_ino.whichfork;
686 __entry->type = sc->sm->sm_type;
687 __assign_str(name);
688 __entry->level = level;
689 __entry->agno = XFS_FSB_TO_AGNO(cur->bc_mp, fsbno);
690 __entry->bno = XFS_FSB_TO_AGBNO(cur->bc_mp, fsbno);
691 __entry->ptr = cur->bc_levels[level].ptr;
692 __entry->ret_ip = ret_ip;
693 ),
694 TP_printk("dev %d:%d ino 0x%llx fork %s type %s %sbt level %d ptr %d agno 0x%x agbno 0x%x ret_ip %pS",
695 MAJOR(__entry->dev), MINOR(__entry->dev),
696 __entry->ino,
697 __print_symbolic(__entry->whichfork, XFS_WHICHFORK_STRINGS),
698 __print_symbolic(__entry->type, XFS_SCRUB_TYPE_STRINGS),
699 __get_str(name),
700 __entry->level,
701 __entry->ptr,
702 __entry->agno,
703 __entry->bno,
704 __entry->ret_ip)
705 );
706
707 DECLARE_EVENT_CLASS(xchk_sbtree_class,
708 TP_PROTO(struct xfs_scrub *sc, struct xfs_btree_cur *cur,
709 int level),
710 TP_ARGS(sc, cur, level),
711 TP_STRUCT__entry(
712 __field(dev_t, dev)
713 __field(int, type)
714 __string(name, cur->bc_ops->name)
715 __field(xfs_agnumber_t, agno)
716 __field(xfs_agblock_t, bno)
717 __field(int, level)
718 __field(int, nlevels)
719 __field(int, ptr)
720 ),
721 TP_fast_assign(
722 xfs_fsblock_t fsbno = xchk_btree_cur_fsbno(cur, level);
723
724 __entry->dev = sc->mp->m_super->s_dev;
725 __entry->type = sc->sm->sm_type;
726 __assign_str(name);
727 __entry->agno = XFS_FSB_TO_AGNO(cur->bc_mp, fsbno);
728 __entry->bno = XFS_FSB_TO_AGBNO(cur->bc_mp, fsbno);
729 __entry->level = level;
730 __entry->nlevels = cur->bc_nlevels;
731 __entry->ptr = cur->bc_levels[level].ptr;
732 ),
733 TP_printk("dev %d:%d type %s %sbt agno 0x%x agbno 0x%x level %d nlevels %d ptr %d",
734 MAJOR(__entry->dev), MINOR(__entry->dev),
735 __print_symbolic(__entry->type, XFS_SCRUB_TYPE_STRINGS),
736 __get_str(name),
737 __entry->agno,
738 __entry->bno,
739 __entry->level,
740 __entry->nlevels,
741 __entry->ptr)
742 )
743 #define DEFINE_SCRUB_SBTREE_EVENT(name) \
744 DEFINE_EVENT(xchk_sbtree_class, name, \
745 TP_PROTO(struct xfs_scrub *sc, struct xfs_btree_cur *cur, \
746 int level), \
747 TP_ARGS(sc, cur, level))
748
749 DEFINE_SCRUB_SBTREE_EVENT(xchk_btree_rec);
750 DEFINE_SCRUB_SBTREE_EVENT(xchk_btree_key);
751
752 TRACE_EVENT(xchk_xref_error,
753 TP_PROTO(struct xfs_scrub *sc, int error, void *ret_ip),
754 TP_ARGS(sc, error, ret_ip),
755 TP_STRUCT__entry(
756 __field(dev_t, dev)
757 __field(int, type)
758 __field(int, error)
759 __field(void *, ret_ip)
760 ),
761 TP_fast_assign(
762 __entry->dev = sc->mp->m_super->s_dev;
763 __entry->type = sc->sm->sm_type;
764 __entry->error = error;
765 __entry->ret_ip = ret_ip;
766 ),
767 TP_printk("dev %d:%d type %s xref error %d ret_ip %pS",
768 MAJOR(__entry->dev), MINOR(__entry->dev),
769 __print_symbolic(__entry->type, XFS_SCRUB_TYPE_STRINGS),
770 __entry->error,
771 __entry->ret_ip)
772 );
773
774 TRACE_EVENT(xchk_iallocbt_check_cluster,
775 TP_PROTO(struct xfs_mount *mp, xfs_agnumber_t agno,
776 xfs_agino_t startino, xfs_daddr_t map_daddr,
777 unsigned short map_len, unsigned int chunk_ino,
778 unsigned int nr_inodes, uint16_t cluster_mask,
779 uint16_t holemask, unsigned int cluster_ino),
780 TP_ARGS(mp, agno, startino, map_daddr, map_len, chunk_ino, nr_inodes,
781 cluster_mask, holemask, cluster_ino),
782 TP_STRUCT__entry(
783 __field(dev_t, dev)
784 __field(xfs_agnumber_t, agno)
785 __field(xfs_agino_t, startino)
786 __field(xfs_daddr_t, map_daddr)
787 __field(unsigned short, map_len)
788 __field(unsigned int, chunk_ino)
789 __field(unsigned int, nr_inodes)
790 __field(unsigned int, cluster_ino)
791 __field(uint16_t, cluster_mask)
792 __field(uint16_t, holemask)
793 ),
794 TP_fast_assign(
795 __entry->dev = mp->m_super->s_dev;
796 __entry->agno = agno;
797 __entry->startino = startino;
798 __entry->map_daddr = map_daddr;
799 __entry->map_len = map_len;
800 __entry->chunk_ino = chunk_ino;
801 __entry->nr_inodes = nr_inodes;
802 __entry->cluster_mask = cluster_mask;
803 __entry->holemask = holemask;
804 __entry->cluster_ino = cluster_ino;
805 ),
806 TP_printk("dev %d:%d agno 0x%x startino 0x%x daddr 0x%llx bbcount 0x%x chunkino 0x%x nr_inodes %u cluster_mask 0x%x holemask 0x%x cluster_ino 0x%x",
807 MAJOR(__entry->dev), MINOR(__entry->dev),
808 __entry->agno,
809 __entry->startino,
810 __entry->map_daddr,
811 __entry->map_len,
812 __entry->chunk_ino,
813 __entry->nr_inodes,
814 __entry->cluster_mask,
815 __entry->holemask,
816 __entry->cluster_ino)
817 )
818
819 TRACE_EVENT(xchk_inode_is_allocated,
820 TP_PROTO(struct xfs_inode *ip),
821 TP_ARGS(ip),
822 TP_STRUCT__entry(
823 __field(dev_t, dev)
824 __field(xfs_ino_t, ino)
825 __field(unsigned long, iflags)
826 __field(umode_t, mode)
827 ),
828 TP_fast_assign(
829 __entry->dev = VFS_I(ip)->i_sb->s_dev;
830 __entry->ino = ip->i_ino;
831 __entry->iflags = ip->i_flags;
832 __entry->mode = VFS_I(ip)->i_mode;
833 ),
834 TP_printk("dev %d:%d ino 0x%llx iflags 0x%lx mode 0x%x",
835 MAJOR(__entry->dev), MINOR(__entry->dev),
836 __entry->ino,
837 __entry->iflags,
838 __entry->mode)
839 );
840
841 TRACE_EVENT(xchk_fscounters_calc,
842 TP_PROTO(struct xfs_mount *mp, uint64_t icount, uint64_t ifree,
843 uint64_t fdblocks, uint64_t delalloc),
844 TP_ARGS(mp, icount, ifree, fdblocks, delalloc),
845 TP_STRUCT__entry(
846 __field(dev_t, dev)
847 __field(int64_t, icount_sb)
848 __field(uint64_t, icount_calculated)
849 __field(int64_t, ifree_sb)
850 __field(uint64_t, ifree_calculated)
851 __field(int64_t, fdblocks_sb)
852 __field(uint64_t, fdblocks_calculated)
853 __field(uint64_t, delalloc)
854 ),
855 TP_fast_assign(
856 __entry->dev = mp->m_super->s_dev;
857 __entry->icount_sb = mp->m_sb.sb_icount;
858 __entry->icount_calculated = icount;
859 __entry->ifree_sb = mp->m_sb.sb_ifree;
860 __entry->ifree_calculated = ifree;
861 __entry->fdblocks_sb = mp->m_sb.sb_fdblocks;
862 __entry->fdblocks_calculated = fdblocks;
863 __entry->delalloc = delalloc;
864 ),
865 TP_printk("dev %d:%d icount %lld:%llu ifree %lld::%llu fdblocks %lld::%llu delalloc %llu",
866 MAJOR(__entry->dev), MINOR(__entry->dev),
867 __entry->icount_sb,
868 __entry->icount_calculated,
869 __entry->ifree_sb,
870 __entry->ifree_calculated,
871 __entry->fdblocks_sb,
872 __entry->fdblocks_calculated,
873 __entry->delalloc)
874 )
875
876 TRACE_EVENT(xchk_fscounters_within_range,
877 TP_PROTO(struct xfs_mount *mp, uint64_t expected, int64_t curr_value,
878 int64_t old_value),
879 TP_ARGS(mp, expected, curr_value, old_value),
880 TP_STRUCT__entry(
881 __field(dev_t, dev)
882 __field(uint64_t, expected)
883 __field(int64_t, curr_value)
884 __field(int64_t, old_value)
885 ),
886 TP_fast_assign(
887 __entry->dev = mp->m_super->s_dev;
888 __entry->expected = expected;
889 __entry->curr_value = curr_value;
890 __entry->old_value = old_value;
891 ),
892 TP_printk("dev %d:%d expected %llu curr_value %lld old_value %lld",
893 MAJOR(__entry->dev), MINOR(__entry->dev),
894 __entry->expected,
895 __entry->curr_value,
896 __entry->old_value)
897 )
898
899 DECLARE_EVENT_CLASS(xchk_fsfreeze_class,
900 TP_PROTO(struct xfs_scrub *sc, int error),
901 TP_ARGS(sc, error),
902 TP_STRUCT__entry(
903 __field(dev_t, dev)
904 __field(unsigned int, type)
905 __field(int, error)
906 ),
907 TP_fast_assign(
908 __entry->dev = sc->mp->m_super->s_dev;
909 __entry->type = sc->sm->sm_type;
910 __entry->error = error;
911 ),
912 TP_printk("dev %d:%d type %s error %d",
913 MAJOR(__entry->dev), MINOR(__entry->dev),
914 __print_symbolic(__entry->type, XFS_SCRUB_TYPE_STRINGS),
915 __entry->error)
916 );
917 #define DEFINE_XCHK_FSFREEZE_EVENT(name) \
918 DEFINE_EVENT(xchk_fsfreeze_class, name, \
919 TP_PROTO(struct xfs_scrub *sc, int error), \
920 TP_ARGS(sc, error))
921 DEFINE_XCHK_FSFREEZE_EVENT(xchk_fsfreeze);
922 DEFINE_XCHK_FSFREEZE_EVENT(xchk_fsthaw);
923
924 TRACE_EVENT(xchk_refcount_incorrect,
925 TP_PROTO(struct xfs_perag *pag, const struct xfs_refcount_irec *irec,
926 xfs_nlink_t seen),
927 TP_ARGS(pag, irec, seen),
928 TP_STRUCT__entry(
929 __field(dev_t, dev)
930 __field(xfs_agnumber_t, agno)
931 __field(enum xfs_refc_domain, domain)
932 __field(xfs_agblock_t, startblock)
933 __field(xfs_extlen_t, blockcount)
934 __field(xfs_nlink_t, refcount)
935 __field(xfs_nlink_t, seen)
936 ),
937 TP_fast_assign(
938 __entry->dev = pag->pag_mount->m_super->s_dev;
939 __entry->agno = pag->pag_agno;
940 __entry->domain = irec->rc_domain;
941 __entry->startblock = irec->rc_startblock;
942 __entry->blockcount = irec->rc_blockcount;
943 __entry->refcount = irec->rc_refcount;
944 __entry->seen = seen;
945 ),
946 TP_printk("dev %d:%d agno 0x%x dom %s agbno 0x%x fsbcount 0x%x refcount %u seen %u",
947 MAJOR(__entry->dev), MINOR(__entry->dev),
948 __entry->agno,
949 __print_symbolic(__entry->domain, XFS_REFC_DOMAIN_STRINGS),
950 __entry->startblock,
951 __entry->blockcount,
952 __entry->refcount,
953 __entry->seen)
954 )
955
956 TRACE_EVENT(xfile_create,
957 TP_PROTO(struct xfile *xf),
958 TP_ARGS(xf),
959 TP_STRUCT__entry(
960 __field(dev_t, dev)
961 __field(unsigned long, ino)
962 __array(char, pathname, MAXNAMELEN)
963 ),
964 TP_fast_assign(
965 char *path;
966
967 __entry->ino = file_inode(xf->file)->i_ino;
968 path = file_path(xf->file, __entry->pathname, MAXNAMELEN);
969 if (IS_ERR(path))
970 strncpy(__entry->pathname, "(unknown)",
971 sizeof(__entry->pathname));
972 ),
973 TP_printk("xfino 0x%lx path '%s'",
974 __entry->ino,
975 __entry->pathname)
976 );
977
978 TRACE_EVENT(xfile_destroy,
979 TP_PROTO(struct xfile *xf),
980 TP_ARGS(xf),
981 TP_STRUCT__entry(
982 __field(unsigned long, ino)
983 __field(unsigned long long, bytes)
984 __field(loff_t, size)
985 ),
986 TP_fast_assign(
987 struct inode *inode = file_inode(xf->file);
988
989 __entry->ino = inode->i_ino;
990 __entry->bytes = inode->i_blocks << SECTOR_SHIFT;
991 __entry->size = i_size_read(inode);
992 ),
993 TP_printk("xfino 0x%lx mem_bytes 0x%llx isize 0x%llx",
994 __entry->ino,
995 __entry->bytes,
996 __entry->size)
997 );
998
999 DECLARE_EVENT_CLASS(xfile_class,
1000 TP_PROTO(struct xfile *xf, loff_t pos, unsigned long long bytecount),
1001 TP_ARGS(xf, pos, bytecount),
1002 TP_STRUCT__entry(
1003 __field(unsigned long, ino)
1004 __field(unsigned long long, bytes_used)
1005 __field(loff_t, pos)
1006 __field(loff_t, size)
1007 __field(unsigned long long, bytecount)
1008 ),
1009 TP_fast_assign(
1010 struct inode *inode = file_inode(xf->file);
1011
1012 __entry->ino = inode->i_ino;
1013 __entry->bytes_used = inode->i_blocks << SECTOR_SHIFT;
1014 __entry->pos = pos;
1015 __entry->size = i_size_read(inode);
1016 __entry->bytecount = bytecount;
1017 ),
1018 TP_printk("xfino 0x%lx mem_bytes 0x%llx pos 0x%llx bytecount 0x%llx isize 0x%llx",
1019 __entry->ino,
1020 __entry->bytes_used,
1021 __entry->pos,
1022 __entry->bytecount,
1023 __entry->size)
1024 );
1025 #define DEFINE_XFILE_EVENT(name) \
1026 DEFINE_EVENT(xfile_class, name, \
1027 TP_PROTO(struct xfile *xf, loff_t pos, unsigned long long bytecount), \
1028 TP_ARGS(xf, pos, bytecount))
1029 DEFINE_XFILE_EVENT(xfile_load);
1030 DEFINE_XFILE_EVENT(xfile_store);
1031 DEFINE_XFILE_EVENT(xfile_seek_data);
1032 DEFINE_XFILE_EVENT(xfile_get_folio);
1033 DEFINE_XFILE_EVENT(xfile_put_folio);
1034 DEFINE_XFILE_EVENT(xfile_discard);
1035
1036 TRACE_EVENT(xfarray_create,
1037 TP_PROTO(struct xfarray *xfa, unsigned long long required_capacity),
1038 TP_ARGS(xfa, required_capacity),
1039 TP_STRUCT__entry(
1040 __field(unsigned long, ino)
1041 __field(uint64_t, max_nr)
1042 __field(size_t, obj_size)
1043 __field(int, obj_size_log)
1044 __field(unsigned long long, required_capacity)
1045 ),
1046 TP_fast_assign(
1047 __entry->max_nr = xfa->max_nr;
1048 __entry->obj_size = xfa->obj_size;
1049 __entry->obj_size_log = xfa->obj_size_log;
1050 __entry->ino = file_inode(xfa->xfile->file)->i_ino;
1051 __entry->required_capacity = required_capacity;
1052 ),
1053 TP_printk("xfino 0x%lx max_nr %llu reqd_nr %llu objsz %zu objszlog %d",
1054 __entry->ino,
1055 __entry->max_nr,
1056 __entry->required_capacity,
1057 __entry->obj_size,
1058 __entry->obj_size_log)
1059 );
1060
1061 TRACE_EVENT(xfarray_isort,
1062 TP_PROTO(struct xfarray_sortinfo *si, uint64_t lo, uint64_t hi),
1063 TP_ARGS(si, lo, hi),
1064 TP_STRUCT__entry(
1065 __field(unsigned long, ino)
1066 __field(unsigned long long, lo)
1067 __field(unsigned long long, hi)
1068 ),
1069 TP_fast_assign(
1070 __entry->ino = file_inode(si->array->xfile->file)->i_ino;
1071 __entry->lo = lo;
1072 __entry->hi = hi;
1073 ),
1074 TP_printk("xfino 0x%lx lo %llu hi %llu elts %llu",
1075 __entry->ino,
1076 __entry->lo,
1077 __entry->hi,
1078 __entry->hi - __entry->lo)
1079 );
1080
1081 TRACE_EVENT(xfarray_foliosort,
1082 TP_PROTO(struct xfarray_sortinfo *si, uint64_t lo, uint64_t hi),
1083 TP_ARGS(si, lo, hi),
1084 TP_STRUCT__entry(
1085 __field(unsigned long, ino)
1086 __field(unsigned long long, lo)
1087 __field(unsigned long long, hi)
1088 ),
1089 TP_fast_assign(
1090 __entry->ino = file_inode(si->array->xfile->file)->i_ino;
1091 __entry->lo = lo;
1092 __entry->hi = hi;
1093 ),
1094 TP_printk("xfino 0x%lx lo %llu hi %llu elts %llu",
1095 __entry->ino,
1096 __entry->lo,
1097 __entry->hi,
1098 __entry->hi - __entry->lo)
1099 );
1100
1101 TRACE_EVENT(xfarray_qsort,
1102 TP_PROTO(struct xfarray_sortinfo *si, uint64_t lo, uint64_t hi),
1103 TP_ARGS(si, lo, hi),
1104 TP_STRUCT__entry(
1105 __field(unsigned long, ino)
1106 __field(unsigned long long, lo)
1107 __field(unsigned long long, hi)
1108 __field(int, stack_depth)
1109 __field(int, max_stack_depth)
1110 ),
1111 TP_fast_assign(
1112 __entry->ino = file_inode(si->array->xfile->file)->i_ino;
1113 __entry->lo = lo;
1114 __entry->hi = hi;
1115 __entry->stack_depth = si->stack_depth;
1116 __entry->max_stack_depth = si->max_stack_depth;
1117 ),
1118 TP_printk("xfino 0x%lx lo %llu hi %llu elts %llu stack %d/%d",
1119 __entry->ino,
1120 __entry->lo,
1121 __entry->hi,
1122 __entry->hi - __entry->lo,
1123 __entry->stack_depth,
1124 __entry->max_stack_depth)
1125 );
1126
1127 TRACE_EVENT(xfarray_sort,
1128 TP_PROTO(struct xfarray_sortinfo *si, size_t bytes),
1129 TP_ARGS(si, bytes),
1130 TP_STRUCT__entry(
1131 __field(unsigned long, ino)
1132 __field(unsigned long long, nr)
1133 __field(size_t, obj_size)
1134 __field(size_t, bytes)
1135 __field(unsigned int, max_stack_depth)
1136 ),
1137 TP_fast_assign(
1138 __entry->nr = si->array->nr;
1139 __entry->obj_size = si->array->obj_size;
1140 __entry->ino = file_inode(si->array->xfile->file)->i_ino;
1141 __entry->bytes = bytes;
1142 __entry->max_stack_depth = si->max_stack_depth;
1143 ),
1144 TP_printk("xfino 0x%lx nr %llu objsz %zu stack %u bytes %zu",
1145 __entry->ino,
1146 __entry->nr,
1147 __entry->obj_size,
1148 __entry->max_stack_depth,
1149 __entry->bytes)
1150 );
1151
1152 TRACE_EVENT(xfarray_sort_scan,
1153 TP_PROTO(struct xfarray_sortinfo *si, unsigned long long idx),
1154 TP_ARGS(si, idx),
1155 TP_STRUCT__entry(
1156 __field(unsigned long, ino)
1157 __field(unsigned long long, nr)
1158 __field(size_t, obj_size)
1159 __field(unsigned long long, idx)
1160 __field(unsigned long long, folio_pos)
1161 __field(unsigned long, folio_bytes)
1162 __field(unsigned long long, first_idx)
1163 __field(unsigned long long, last_idx)
1164 ),
1165 TP_fast_assign(
1166 __entry->nr = si->array->nr;
1167 __entry->obj_size = si->array->obj_size;
1168 __entry->ino = file_inode(si->array->xfile->file)->i_ino;
1169 __entry->idx = idx;
1170 if (si->folio) {
1171 __entry->folio_pos = folio_pos(si->folio);
1172 __entry->folio_bytes = folio_size(si->folio);
1173 __entry->first_idx = si->first_folio_idx;
1174 __entry->last_idx = si->last_folio_idx;
1175 } else {
1176 __entry->folio_pos = 0;
1177 __entry->folio_bytes = 0;
1178 __entry->first_idx = 0;
1179 __entry->last_idx = 0;
1180 }
1181 ),
1182 TP_printk("xfino 0x%lx nr %llu objsz %zu idx %llu folio_pos 0x%llx folio_bytes 0x%lx first_idx %llu last_idx %llu",
1183 __entry->ino,
1184 __entry->nr,
1185 __entry->obj_size,
1186 __entry->idx,
1187 __entry->folio_pos,
1188 __entry->folio_bytes,
1189 __entry->first_idx,
1190 __entry->last_idx)
1191 );
1192
1193 TRACE_EVENT(xfarray_sort_stats,
1194 TP_PROTO(struct xfarray_sortinfo *si, int error),
1195 TP_ARGS(si, error),
1196 TP_STRUCT__entry(
1197 __field(unsigned long, ino)
1198 #ifdef DEBUG
1199 __field(unsigned long long, loads)
1200 __field(unsigned long long, stores)
1201 __field(unsigned long long, compares)
1202 __field(unsigned long long, heapsorts)
1203 #endif
1204 __field(unsigned int, max_stack_depth)
1205 __field(unsigned int, max_stack_used)
1206 __field(int, error)
1207 ),
1208 TP_fast_assign(
1209 __entry->ino = file_inode(si->array->xfile->file)->i_ino;
1210 #ifdef DEBUG
1211 __entry->loads = si->loads;
1212 __entry->stores = si->stores;
1213 __entry->compares = si->compares;
1214 __entry->heapsorts = si->heapsorts;
1215 #endif
1216 __entry->max_stack_depth = si->max_stack_depth;
1217 __entry->max_stack_used = si->max_stack_used;
1218 __entry->error = error;
1219 ),
1220 TP_printk(
1221 #ifdef DEBUG
1222 "xfino 0x%lx loads %llu stores %llu compares %llu heapsorts %llu stack_depth %u/%u error %d",
1223 #else
1224 "xfino 0x%lx stack_depth %u/%u error %d",
1225 #endif
1226 __entry->ino,
1227 #ifdef DEBUG
1228 __entry->loads,
1229 __entry->stores,
1230 __entry->compares,
1231 __entry->heapsorts,
1232 #endif
1233 __entry->max_stack_used,
1234 __entry->max_stack_depth,
1235 __entry->error)
1236 );
1237
1238 #ifdef CONFIG_XFS_RT
1239 TRACE_EVENT(xchk_rtsum_record_free,
1240 TP_PROTO(struct xfs_mount *mp, xfs_rtxnum_t start,
1241 xfs_rtbxlen_t len, unsigned int log, loff_t pos,
1242 xfs_suminfo_t value),
1243 TP_ARGS(mp, start, len, log, pos, value),
1244 TP_STRUCT__entry(
1245 __field(dev_t, dev)
1246 __field(dev_t, rtdev)
1247 __field(xfs_rtxnum_t, start)
1248 __field(unsigned long long, len)
1249 __field(unsigned int, log)
1250 __field(loff_t, pos)
1251 __field(xfs_suminfo_t, value)
1252 ),
1253 TP_fast_assign(
1254 __entry->dev = mp->m_super->s_dev;
1255 __entry->rtdev = mp->m_rtdev_targp->bt_dev;
1256 __entry->start = start;
1257 __entry->len = len;
1258 __entry->log = log;
1259 __entry->pos = pos;
1260 __entry->value = value;
1261 ),
1262 TP_printk("dev %d:%d rtdev %d:%d rtx 0x%llx rtxcount 0x%llx log %u rsumpos 0x%llx sumcount %u",
1263 MAJOR(__entry->dev), MINOR(__entry->dev),
1264 MAJOR(__entry->rtdev), MINOR(__entry->rtdev),
1265 __entry->start,
1266 __entry->len,
1267 __entry->log,
1268 __entry->pos,
1269 __entry->value)
1270 );
1271 #endif /* CONFIG_XFS_RT */
1272
1273 DECLARE_EVENT_CLASS(xchk_iscan_class,
1274 TP_PROTO(struct xchk_iscan *iscan),
1275 TP_ARGS(iscan),
1276 TP_STRUCT__entry(
1277 __field(dev_t, dev)
1278 __field(xfs_ino_t, cursor)
1279 __field(xfs_ino_t, visited)
1280 ),
1281 TP_fast_assign(
1282 __entry->dev = iscan->sc->mp->m_super->s_dev;
1283 __entry->cursor = iscan->cursor_ino;
1284 __entry->visited = iscan->__visited_ino;
1285 ),
1286 TP_printk("dev %d:%d iscan cursor 0x%llx visited 0x%llx",
1287 MAJOR(__entry->dev), MINOR(__entry->dev),
1288 __entry->cursor,
1289 __entry->visited)
1290 )
1291 #define DEFINE_ISCAN_EVENT(name) \
1292 DEFINE_EVENT(xchk_iscan_class, name, \
1293 TP_PROTO(struct xchk_iscan *iscan), \
1294 TP_ARGS(iscan))
1295 DEFINE_ISCAN_EVENT(xchk_iscan_move_cursor);
1296 DEFINE_ISCAN_EVENT(xchk_iscan_visit);
1297 DEFINE_ISCAN_EVENT(xchk_iscan_skip);
1298 DEFINE_ISCAN_EVENT(xchk_iscan_advance_ag);
1299
1300 DECLARE_EVENT_CLASS(xchk_iscan_ino_class,
1301 TP_PROTO(struct xchk_iscan *iscan, xfs_ino_t ino),
1302 TP_ARGS(iscan, ino),
1303 TP_STRUCT__entry(
1304 __field(dev_t, dev)
1305 __field(xfs_ino_t, startino)
1306 __field(xfs_ino_t, cursor)
1307 __field(xfs_ino_t, visited)
1308 __field(xfs_ino_t, ino)
1309 ),
1310 TP_fast_assign(
1311 __entry->dev = iscan->sc->mp->m_super->s_dev;
1312 __entry->startino = iscan->scan_start_ino;
1313 __entry->cursor = iscan->cursor_ino;
1314 __entry->visited = iscan->__visited_ino;
1315 __entry->ino = ino;
1316 ),
1317 TP_printk("dev %d:%d iscan start 0x%llx cursor 0x%llx visited 0x%llx ino 0x%llx",
1318 MAJOR(__entry->dev), MINOR(__entry->dev),
1319 __entry->startino,
1320 __entry->cursor,
1321 __entry->visited,
1322 __entry->ino)
1323 )
1324 #define DEFINE_ISCAN_INO_EVENT(name) \
1325 DEFINE_EVENT(xchk_iscan_ino_class, name, \
1326 TP_PROTO(struct xchk_iscan *iscan, xfs_ino_t ino), \
1327 TP_ARGS(iscan, ino))
1328 DEFINE_ISCAN_INO_EVENT(xchk_iscan_want_live_update);
1329 DEFINE_ISCAN_INO_EVENT(xchk_iscan_start);
1330
1331 TRACE_EVENT(xchk_iscan_iget,
1332 TP_PROTO(struct xchk_iscan *iscan, int error),
1333 TP_ARGS(iscan, error),
1334 TP_STRUCT__entry(
1335 __field(dev_t, dev)
1336 __field(xfs_ino_t, cursor)
1337 __field(xfs_ino_t, visited)
1338 __field(int, error)
1339 ),
1340 TP_fast_assign(
1341 __entry->dev = iscan->sc->mp->m_super->s_dev;
1342 __entry->cursor = iscan->cursor_ino;
1343 __entry->visited = iscan->__visited_ino;
1344 __entry->error = error;
1345 ),
1346 TP_printk("dev %d:%d iscan cursor 0x%llx visited 0x%llx error %d",
1347 MAJOR(__entry->dev), MINOR(__entry->dev),
1348 __entry->cursor,
1349 __entry->visited,
1350 __entry->error)
1351 );
1352
1353 TRACE_EVENT(xchk_iscan_iget_batch,
1354 TP_PROTO(struct xfs_mount *mp, struct xchk_iscan *iscan,
1355 unsigned int nr, unsigned int avail),
1356 TP_ARGS(mp, iscan, nr, avail),
1357 TP_STRUCT__entry(
1358 __field(dev_t, dev)
1359 __field(xfs_ino_t, cursor)
1360 __field(xfs_ino_t, visited)
1361 __field(unsigned int, nr)
1362 __field(unsigned int, avail)
1363 __field(unsigned int, unavail)
1364 __field(xfs_ino_t, batch_ino)
1365 __field(unsigned long long, skipmask)
1366 ),
1367 TP_fast_assign(
1368 __entry->dev = mp->m_super->s_dev;
1369 __entry->cursor = iscan->cursor_ino;
1370 __entry->visited = iscan->__visited_ino;
1371 __entry->nr = nr;
1372 __entry->avail = avail;
1373 __entry->unavail = hweight64(iscan->__skipped_inomask);
1374 __entry->batch_ino = iscan->__batch_ino;
1375 __entry->skipmask = iscan->__skipped_inomask;
1376 ),
1377 TP_printk("dev %d:%d iscan cursor 0x%llx visited 0x%llx batchino 0x%llx skipmask 0x%llx nr %u avail %u unavail %u",
1378 MAJOR(__entry->dev), MINOR(__entry->dev),
1379 __entry->cursor,
1380 __entry->visited,
1381 __entry->batch_ino,
1382 __entry->skipmask,
1383 __entry->nr,
1384 __entry->avail,
1385 __entry->unavail)
1386 );
1387
1388 DECLARE_EVENT_CLASS(xchk_iscan_retry_wait_class,
1389 TP_PROTO(struct xchk_iscan *iscan),
1390 TP_ARGS(iscan),
1391 TP_STRUCT__entry(
1392 __field(dev_t, dev)
1393 __field(xfs_ino_t, cursor)
1394 __field(xfs_ino_t, visited)
1395 __field(unsigned int, retry_delay)
1396 __field(unsigned long, remaining)
1397 __field(unsigned int, iget_timeout)
1398 ),
1399 TP_fast_assign(
1400 __entry->dev = iscan->sc->mp->m_super->s_dev;
1401 __entry->cursor = iscan->cursor_ino;
1402 __entry->visited = iscan->__visited_ino;
1403 __entry->retry_delay = iscan->iget_retry_delay;
1404 __entry->remaining = jiffies_to_msecs(iscan->__iget_deadline - jiffies);
1405 __entry->iget_timeout = iscan->iget_timeout;
1406 ),
1407 TP_printk("dev %d:%d iscan cursor 0x%llx visited 0x%llx remaining %lu timeout %u delay %u",
1408 MAJOR(__entry->dev), MINOR(__entry->dev),
1409 __entry->cursor,
1410 __entry->visited,
1411 __entry->remaining,
1412 __entry->iget_timeout,
1413 __entry->retry_delay)
1414 )
1415 #define DEFINE_ISCAN_RETRY_WAIT_EVENT(name) \
1416 DEFINE_EVENT(xchk_iscan_retry_wait_class, name, \
1417 TP_PROTO(struct xchk_iscan *iscan), \
1418 TP_ARGS(iscan))
1419 DEFINE_ISCAN_RETRY_WAIT_EVENT(xchk_iscan_iget_retry_wait);
1420 DEFINE_ISCAN_RETRY_WAIT_EVENT(xchk_iscan_agi_retry_wait);
1421
1422 TRACE_EVENT(xchk_nlinks_collect_dirent,
1423 TP_PROTO(struct xfs_mount *mp, struct xfs_inode *dp,
1424 xfs_ino_t ino, const struct xfs_name *name),
1425 TP_ARGS(mp, dp, ino, name),
1426 TP_STRUCT__entry(
1427 __field(dev_t, dev)
1428 __field(xfs_ino_t, dir)
1429 __field(xfs_ino_t, ino)
1430 __field(unsigned int, namelen)
1431 __dynamic_array(char, name, name->len)
1432 ),
1433 TP_fast_assign(
1434 __entry->dev = mp->m_super->s_dev;
1435 __entry->dir = dp->i_ino;
1436 __entry->ino = ino;
1437 __entry->namelen = name->len;
1438 memcpy(__get_str(name), name->name, name->len);
1439 ),
1440 TP_printk("dev %d:%d dir 0x%llx -> ino 0x%llx name '%.*s'",
1441 MAJOR(__entry->dev), MINOR(__entry->dev),
1442 __entry->dir,
1443 __entry->ino,
1444 __entry->namelen,
1445 __get_str(name))
1446 );
1447
1448 TRACE_EVENT(xchk_nlinks_collect_pptr,
1449 TP_PROTO(struct xfs_mount *mp, struct xfs_inode *dp,
1450 const struct xfs_name *name,
1451 const struct xfs_parent_rec *pptr),
1452 TP_ARGS(mp, dp, name, pptr),
1453 TP_STRUCT__entry(
1454 __field(dev_t, dev)
1455 __field(xfs_ino_t, dir)
1456 __field(xfs_ino_t, ino)
1457 __field(unsigned int, namelen)
1458 __dynamic_array(char, name, name->len)
1459 ),
1460 TP_fast_assign(
1461 __entry->dev = mp->m_super->s_dev;
1462 __entry->dir = dp->i_ino;
1463 __entry->ino = be64_to_cpu(pptr->p_ino);
1464 __entry->namelen = name->len;
1465 memcpy(__get_str(name), name->name, name->len);
1466 ),
1467 TP_printk("dev %d:%d dir 0x%llx -> ino 0x%llx name '%.*s'",
1468 MAJOR(__entry->dev), MINOR(__entry->dev),
1469 __entry->dir,
1470 __entry->ino,
1471 __entry->namelen,
1472 __get_str(name))
1473 );
1474
1475 TRACE_EVENT(xchk_nlinks_collect_metafile,
1476 TP_PROTO(struct xfs_mount *mp, xfs_ino_t ino),
1477 TP_ARGS(mp, ino),
1478 TP_STRUCT__entry(
1479 __field(dev_t, dev)
1480 __field(xfs_ino_t, ino)
1481 ),
1482 TP_fast_assign(
1483 __entry->dev = mp->m_super->s_dev;
1484 __entry->ino = ino;
1485 ),
1486 TP_printk("dev %d:%d ino 0x%llx",
1487 MAJOR(__entry->dev), MINOR(__entry->dev),
1488 __entry->ino)
1489 );
1490
1491 TRACE_EVENT(xchk_nlinks_live_update,
1492 TP_PROTO(struct xfs_mount *mp, const struct xfs_inode *dp,
1493 int action, xfs_ino_t ino, int delta,
1494 const char *name, unsigned int namelen),
1495 TP_ARGS(mp, dp, action, ino, delta, name, namelen),
1496 TP_STRUCT__entry(
1497 __field(dev_t, dev)
1498 __field(xfs_ino_t, dir)
1499 __field(int, action)
1500 __field(xfs_ino_t, ino)
1501 __field(int, delta)
1502 __field(unsigned int, namelen)
1503 __dynamic_array(char, name, namelen)
1504 ),
1505 TP_fast_assign(
1506 __entry->dev = mp->m_super->s_dev;
1507 __entry->dir = dp ? dp->i_ino : NULLFSINO;
1508 __entry->action = action;
1509 __entry->ino = ino;
1510 __entry->delta = delta;
1511 __entry->namelen = namelen;
1512 memcpy(__get_str(name), name, namelen);
1513 ),
1514 TP_printk("dev %d:%d dir 0x%llx ino 0x%llx nlink_delta %d name '%.*s'",
1515 MAJOR(__entry->dev), MINOR(__entry->dev),
1516 __entry->dir,
1517 __entry->ino,
1518 __entry->delta,
1519 __entry->namelen,
1520 __get_str(name))
1521 );
1522
1523 TRACE_EVENT(xchk_nlinks_check_zero,
1524 TP_PROTO(struct xfs_mount *mp, xfs_ino_t ino,
1525 const struct xchk_nlink *live),
1526 TP_ARGS(mp, ino, live),
1527 TP_STRUCT__entry(
1528 __field(dev_t, dev)
1529 __field(xfs_ino_t, ino)
1530 __field(xfs_nlink_t, parents)
1531 __field(xfs_nlink_t, backrefs)
1532 __field(xfs_nlink_t, children)
1533 ),
1534 TP_fast_assign(
1535 __entry->dev = mp->m_super->s_dev;
1536 __entry->ino = ino;
1537 __entry->parents = live->parents;
1538 __entry->backrefs = live->backrefs;
1539 __entry->children = live->children;
1540 ),
1541 TP_printk("dev %d:%d ino 0x%llx parents %u backrefs %u children %u",
1542 MAJOR(__entry->dev), MINOR(__entry->dev),
1543 __entry->ino,
1544 __entry->parents,
1545 __entry->backrefs,
1546 __entry->children)
1547 );
1548
1549 TRACE_EVENT(xchk_nlinks_update_incore,
1550 TP_PROTO(struct xfs_mount *mp, xfs_ino_t ino,
1551 const struct xchk_nlink *live, int parents_delta,
1552 int backrefs_delta, int children_delta),
1553 TP_ARGS(mp, ino, live, parents_delta, backrefs_delta, children_delta),
1554 TP_STRUCT__entry(
1555 __field(dev_t, dev)
1556 __field(xfs_ino_t, ino)
1557 __field(xfs_nlink_t, parents)
1558 __field(xfs_nlink_t, backrefs)
1559 __field(xfs_nlink_t, children)
1560 __field(int, parents_delta)
1561 __field(int, backrefs_delta)
1562 __field(int, children_delta)
1563 ),
1564 TP_fast_assign(
1565 __entry->dev = mp->m_super->s_dev;
1566 __entry->ino = ino;
1567 __entry->parents = live->parents;
1568 __entry->backrefs = live->backrefs;
1569 __entry->children = live->children;
1570 __entry->parents_delta = parents_delta;
1571 __entry->backrefs_delta = backrefs_delta;
1572 __entry->children_delta = children_delta;
1573 ),
1574 TP_printk("dev %d:%d ino 0x%llx parents %d:%u backrefs %d:%u children %d:%u",
1575 MAJOR(__entry->dev), MINOR(__entry->dev),
1576 __entry->ino,
1577 __entry->parents_delta,
1578 __entry->parents,
1579 __entry->backrefs_delta,
1580 __entry->backrefs,
1581 __entry->children_delta,
1582 __entry->children)
1583 );
1584
1585 DECLARE_EVENT_CLASS(xchk_nlinks_diff_class,
1586 TP_PROTO(struct xfs_mount *mp, struct xfs_inode *ip,
1587 const struct xchk_nlink *live),
1588 TP_ARGS(mp, ip, live),
1589 TP_STRUCT__entry(
1590 __field(dev_t, dev)
1591 __field(xfs_ino_t, ino)
1592 __field(uint8_t, ftype)
1593 __field(xfs_nlink_t, nlink)
1594 __field(xfs_nlink_t, parents)
1595 __field(xfs_nlink_t, backrefs)
1596 __field(xfs_nlink_t, children)
1597 ),
1598 TP_fast_assign(
1599 __entry->dev = mp->m_super->s_dev;
1600 __entry->ino = ip->i_ino;
1601 __entry->ftype = xfs_mode_to_ftype(VFS_I(ip)->i_mode);
1602 __entry->nlink = VFS_I(ip)->i_nlink;
1603 __entry->parents = live->parents;
1604 __entry->backrefs = live->backrefs;
1605 __entry->children = live->children;
1606 ),
1607 TP_printk("dev %d:%d ino 0x%llx ftype %s nlink %u parents %u backrefs %u children %u",
1608 MAJOR(__entry->dev), MINOR(__entry->dev),
1609 __entry->ino,
1610 __print_symbolic(__entry->ftype, XFS_DIR3_FTYPE_STR),
1611 __entry->nlink,
1612 __entry->parents,
1613 __entry->backrefs,
1614 __entry->children)
1615 );
1616 #define DEFINE_SCRUB_NLINKS_DIFF_EVENT(name) \
1617 DEFINE_EVENT(xchk_nlinks_diff_class, name, \
1618 TP_PROTO(struct xfs_mount *mp, struct xfs_inode *ip, \
1619 const struct xchk_nlink *live), \
1620 TP_ARGS(mp, ip, live))
1621 DEFINE_SCRUB_NLINKS_DIFF_EVENT(xchk_nlinks_compare_inode);
1622
1623 DECLARE_EVENT_CLASS(xchk_pptr_class,
1624 TP_PROTO(struct xfs_inode *ip, const struct xfs_name *name,
1625 xfs_ino_t far_ino),
1626 TP_ARGS(ip, name, far_ino),
1627 TP_STRUCT__entry(
1628 __field(dev_t, dev)
1629 __field(xfs_ino_t, ino)
1630 __field(unsigned int, namelen)
1631 __dynamic_array(char, name, name->len)
1632 __field(xfs_ino_t, far_ino)
1633 ),
1634 TP_fast_assign(
1635 __entry->dev = ip->i_mount->m_super->s_dev;
1636 __entry->ino = ip->i_ino;
1637 __entry->namelen = name->len;
1638 memcpy(__get_str(name), name, name->len);
1639 __entry->far_ino = far_ino;
1640 ),
1641 TP_printk("dev %d:%d ino 0x%llx name '%.*s' far_ino 0x%llx",
1642 MAJOR(__entry->dev), MINOR(__entry->dev),
1643 __entry->ino,
1644 __entry->namelen,
1645 __get_str(name),
1646 __entry->far_ino)
1647 )
1648 #define DEFINE_XCHK_PPTR_EVENT(name) \
1649 DEFINE_EVENT(xchk_pptr_class, name, \
1650 TP_PROTO(struct xfs_inode *ip, const struct xfs_name *name, \
1651 xfs_ino_t far_ino), \
1652 TP_ARGS(ip, name, far_ino))
1653 DEFINE_XCHK_PPTR_EVENT(xchk_dir_defer);
1654 DEFINE_XCHK_PPTR_EVENT(xchk_dir_slowpath);
1655 DEFINE_XCHK_PPTR_EVENT(xchk_dir_ultraslowpath);
1656 DEFINE_XCHK_PPTR_EVENT(xchk_parent_defer);
1657 DEFINE_XCHK_PPTR_EVENT(xchk_parent_slowpath);
1658 DEFINE_XCHK_PPTR_EVENT(xchk_parent_ultraslowpath);
1659
1660 DECLARE_EVENT_CLASS(xchk_dirtree_class,
1661 TP_PROTO(struct xfs_scrub *sc, struct xfs_inode *ip,
1662 unsigned int path_nr, const struct xfs_name *name,
1663 const struct xfs_parent_rec *pptr),
1664 TP_ARGS(sc, ip, path_nr, name, pptr),
1665 TP_STRUCT__entry(
1666 __field(dev_t, dev)
1667 __field(unsigned int, path_nr)
1668 __field(xfs_ino_t, child_ino)
1669 __field(unsigned int, child_gen)
1670 __field(xfs_ino_t, parent_ino)
1671 __field(unsigned int, parent_gen)
1672 __field(unsigned int, namelen)
1673 __dynamic_array(char, name, name->len)
1674 ),
1675 TP_fast_assign(
1676 __entry->dev = sc->mp->m_super->s_dev;
1677 __entry->path_nr = path_nr;
1678 __entry->child_ino = ip->i_ino;
1679 __entry->child_gen = VFS_I(ip)->i_generation;
1680 __entry->parent_ino = be64_to_cpu(pptr->p_ino);
1681 __entry->parent_gen = be32_to_cpu(pptr->p_gen);
1682 __entry->namelen = name->len;
1683 memcpy(__get_str(name), name->name, name->len);
1684 ),
1685 TP_printk("dev %d:%d path %u child_ino 0x%llx child_gen 0x%x parent_ino 0x%llx parent_gen 0x%x name '%.*s'",
1686 MAJOR(__entry->dev), MINOR(__entry->dev),
1687 __entry->path_nr,
1688 __entry->child_ino,
1689 __entry->child_gen,
1690 __entry->parent_ino,
1691 __entry->parent_gen,
1692 __entry->namelen,
1693 __get_str(name))
1694 );
1695 #define DEFINE_XCHK_DIRTREE_EVENT(name) \
1696 DEFINE_EVENT(xchk_dirtree_class, name, \
1697 TP_PROTO(struct xfs_scrub *sc, struct xfs_inode *ip, \
1698 unsigned int path_nr, const struct xfs_name *name, \
1699 const struct xfs_parent_rec *pptr), \
1700 TP_ARGS(sc, ip, path_nr, name, pptr))
1701 DEFINE_XCHK_DIRTREE_EVENT(xchk_dirtree_create_path);
1702 DEFINE_XCHK_DIRTREE_EVENT(xchk_dirpath_walk_upwards);
1703
1704 DECLARE_EVENT_CLASS(xchk_dirpath_class,
1705 TP_PROTO(struct xfs_scrub *sc, struct xfs_inode *ip,
1706 unsigned int path_nr, unsigned int step_nr,
1707 const struct xfs_name *name,
1708 const struct xfs_parent_rec *pptr),
1709 TP_ARGS(sc, ip, path_nr, step_nr, name, pptr),
1710 TP_STRUCT__entry(
1711 __field(dev_t, dev)
1712 __field(unsigned int, path_nr)
1713 __field(unsigned int, step_nr)
1714 __field(xfs_ino_t, child_ino)
1715 __field(unsigned int, child_gen)
1716 __field(xfs_ino_t, parent_ino)
1717 __field(unsigned int, parent_gen)
1718 __field(unsigned int, namelen)
1719 __dynamic_array(char, name, name->len)
1720 ),
1721 TP_fast_assign(
1722 __entry->dev = sc->mp->m_super->s_dev;
1723 __entry->path_nr = path_nr;
1724 __entry->step_nr = step_nr;
1725 __entry->child_ino = ip->i_ino;
1726 __entry->child_gen = VFS_I(ip)->i_generation;
1727 __entry->parent_ino = be64_to_cpu(pptr->p_ino);
1728 __entry->parent_gen = be32_to_cpu(pptr->p_gen);
1729 __entry->namelen = name->len;
1730 memcpy(__get_str(name), name->name, name->len);
1731 ),
1732 TP_printk("dev %d:%d path %u step %u child_ino 0x%llx child_gen 0x%x parent_ino 0x%llx parent_gen 0x%x name '%.*s'",
1733 MAJOR(__entry->dev), MINOR(__entry->dev),
1734 __entry->path_nr,
1735 __entry->step_nr,
1736 __entry->child_ino,
1737 __entry->child_gen,
1738 __entry->parent_ino,
1739 __entry->parent_gen,
1740 __entry->namelen,
1741 __get_str(name))
1742 );
1743 #define DEFINE_XCHK_DIRPATH_EVENT(name) \
1744 DEFINE_EVENT(xchk_dirpath_class, name, \
1745 TP_PROTO(struct xfs_scrub *sc, struct xfs_inode *ip, \
1746 unsigned int path_nr, unsigned int step_nr, \
1747 const struct xfs_name *name, \
1748 const struct xfs_parent_rec *pptr), \
1749 TP_ARGS(sc, ip, path_nr, step_nr, name, pptr))
1750 DEFINE_XCHK_DIRPATH_EVENT(xchk_dirpath_disappeared);
1751 DEFINE_XCHK_DIRPATH_EVENT(xchk_dirpath_badgen);
1752 DEFINE_XCHK_DIRPATH_EVENT(xchk_dirpath_nondir_parent);
1753 DEFINE_XCHK_DIRPATH_EVENT(xchk_dirpath_unlinked_parent);
1754 DEFINE_XCHK_DIRPATH_EVENT(xchk_dirpath_found_next_step);
1755
1756 TRACE_DEFINE_ENUM(XCHK_DIRPATH_SCANNING);
1757 TRACE_DEFINE_ENUM(XCHK_DIRPATH_DELETE);
1758 TRACE_DEFINE_ENUM(XCHK_DIRPATH_CORRUPT);
1759 TRACE_DEFINE_ENUM(XCHK_DIRPATH_LOOP);
1760 TRACE_DEFINE_ENUM(XCHK_DIRPATH_STALE);
1761 TRACE_DEFINE_ENUM(XCHK_DIRPATH_OK);
1762 TRACE_DEFINE_ENUM(XREP_DIRPATH_DELETING);
1763 TRACE_DEFINE_ENUM(XREP_DIRPATH_DELETED);
1764 TRACE_DEFINE_ENUM(XREP_DIRPATH_ADOPTING);
1765 TRACE_DEFINE_ENUM(XREP_DIRPATH_ADOPTED);
1766
1767 #define XCHK_DIRPATH_OUTCOME_STRINGS \
1768 { XCHK_DIRPATH_SCANNING, "scanning" }, \
1769 { XCHK_DIRPATH_DELETE, "delete" }, \
1770 { XCHK_DIRPATH_CORRUPT, "corrupt" }, \
1771 { XCHK_DIRPATH_LOOP, "loop" }, \
1772 { XCHK_DIRPATH_STALE, "stale" }, \
1773 { XCHK_DIRPATH_OK, "ok" }, \
1774 { XREP_DIRPATH_DELETING, "deleting" }, \
1775 { XREP_DIRPATH_DELETED, "deleted" }, \
1776 { XREP_DIRPATH_ADOPTING, "adopting" }, \
1777 { XREP_DIRPATH_ADOPTED, "adopted" }
1778
1779 DECLARE_EVENT_CLASS(xchk_dirpath_outcome_class,
1780 TP_PROTO(struct xfs_scrub *sc, unsigned long long path_nr,
1781 unsigned int nr_steps, \
1782 unsigned int outcome),
1783 TP_ARGS(sc, path_nr, nr_steps, outcome),
1784 TP_STRUCT__entry(
1785 __field(dev_t, dev)
1786 __field(unsigned long long, path_nr)
1787 __field(unsigned int, nr_steps)
1788 __field(unsigned int, outcome)
1789 ),
1790 TP_fast_assign(
1791 __entry->dev = sc->mp->m_super->s_dev;
1792 __entry->path_nr = path_nr;
1793 __entry->nr_steps = nr_steps;
1794 __entry->outcome = outcome;
1795 ),
1796 TP_printk("dev %d:%d path %llu steps %u outcome %s",
1797 MAJOR(__entry->dev), MINOR(__entry->dev),
1798 __entry->path_nr,
1799 __entry->nr_steps,
1800 __print_symbolic(__entry->outcome, XCHK_DIRPATH_OUTCOME_STRINGS))
1801 );
1802 #define DEFINE_XCHK_DIRPATH_OUTCOME_EVENT(name) \
1803 DEFINE_EVENT(xchk_dirpath_outcome_class, name, \
1804 TP_PROTO(struct xfs_scrub *sc, unsigned long long path_nr, \
1805 unsigned int nr_steps, \
1806 unsigned int outcome), \
1807 TP_ARGS(sc, path_nr, nr_steps, outcome))
1808 DEFINE_XCHK_DIRPATH_OUTCOME_EVENT(xchk_dirpath_set_outcome);
1809 DEFINE_XCHK_DIRPATH_OUTCOME_EVENT(xchk_dirpath_evaluate_path);
1810
1811 DECLARE_EVENT_CLASS(xchk_dirtree_evaluate_class,
1812 TP_PROTO(const struct xchk_dirtree *dl,
1813 const struct xchk_dirtree_outcomes *oc),
1814 TP_ARGS(dl, oc),
1815 TP_STRUCT__entry(
1816 __field(dev_t, dev)
1817 __field(xfs_ino_t, ino)
1818 __field(xfs_ino_t, rootino)
1819 __field(unsigned int, nr_paths)
1820 __field(unsigned int, bad)
1821 __field(unsigned int, suspect)
1822 __field(unsigned int, good)
1823 __field(bool, needs_adoption)
1824 ),
1825 TP_fast_assign(
1826 __entry->dev = dl->sc->mp->m_super->s_dev;
1827 __entry->ino = dl->sc->ip->i_ino;
1828 __entry->rootino = dl->root_ino;
1829 __entry->nr_paths = dl->nr_paths;
1830 __entry->bad = oc->bad;
1831 __entry->suspect = oc->suspect;
1832 __entry->good = oc->good;
1833 __entry->needs_adoption = oc->needs_adoption ? 1 : 0;
1834 ),
1835 TP_printk("dev %d:%d ino 0x%llx rootino 0x%llx nr_paths %u bad %u suspect %u good %u adopt? %d",
1836 MAJOR(__entry->dev), MINOR(__entry->dev),
1837 __entry->ino,
1838 __entry->rootino,
1839 __entry->nr_paths,
1840 __entry->bad,
1841 __entry->suspect,
1842 __entry->good,
1843 __entry->needs_adoption)
1844 );
1845 #define DEFINE_XCHK_DIRTREE_EVALUATE_EVENT(name) \
1846 DEFINE_EVENT(xchk_dirtree_evaluate_class, name, \
1847 TP_PROTO(const struct xchk_dirtree *dl, \
1848 const struct xchk_dirtree_outcomes *oc), \
1849 TP_ARGS(dl, oc))
1850 DEFINE_XCHK_DIRTREE_EVALUATE_EVENT(xchk_dirtree_evaluate);
1851
1852 TRACE_EVENT(xchk_dirpath_changed,
1853 TP_PROTO(struct xfs_scrub *sc, unsigned int path_nr,
1854 unsigned int step_nr, const struct xfs_inode *dp,
1855 const struct xfs_inode *ip, const struct xfs_name *xname),
1856 TP_ARGS(sc, path_nr, step_nr, dp, ip, xname),
1857 TP_STRUCT__entry(
1858 __field(dev_t, dev)
1859 __field(unsigned int, path_nr)
1860 __field(unsigned int, step_nr)
1861 __field(xfs_ino_t, child_ino)
1862 __field(xfs_ino_t, parent_ino)
1863 __field(unsigned int, namelen)
1864 __dynamic_array(char, name, xname->len)
1865 ),
1866 TP_fast_assign(
1867 __entry->dev = sc->mp->m_super->s_dev;
1868 __entry->path_nr = path_nr;
1869 __entry->step_nr = step_nr;
1870 __entry->child_ino = ip->i_ino;
1871 __entry->parent_ino = dp->i_ino;
1872 __entry->namelen = xname->len;
1873 memcpy(__get_str(name), xname->name, xname->len);
1874 ),
1875 TP_printk("dev %d:%d path %u step %u child_ino 0x%llx parent_ino 0x%llx name '%.*s'",
1876 MAJOR(__entry->dev), MINOR(__entry->dev),
1877 __entry->path_nr,
1878 __entry->step_nr,
1879 __entry->child_ino,
1880 __entry->parent_ino,
1881 __entry->namelen,
1882 __get_str(name))
1883 );
1884
1885 TRACE_EVENT(xchk_dirtree_live_update,
1886 TP_PROTO(struct xfs_scrub *sc, const struct xfs_inode *dp,
1887 int action, const struct xfs_inode *ip, int delta,
1888 const struct xfs_name *xname),
1889 TP_ARGS(sc, dp, action, ip, delta, xname),
1890 TP_STRUCT__entry(
1891 __field(dev_t, dev)
1892 __field(xfs_ino_t, parent_ino)
1893 __field(int, action)
1894 __field(xfs_ino_t, child_ino)
1895 __field(int, delta)
1896 __field(unsigned int, namelen)
1897 __dynamic_array(char, name, xname->len)
1898 ),
1899 TP_fast_assign(
1900 __entry->dev = sc->mp->m_super->s_dev;
1901 __entry->parent_ino = dp->i_ino;
1902 __entry->action = action;
1903 __entry->child_ino = ip->i_ino;
1904 __entry->delta = delta;
1905 __entry->namelen = xname->len;
1906 memcpy(__get_str(name), xname->name, xname->len);
1907 ),
1908 TP_printk("dev %d:%d parent_ino 0x%llx child_ino 0x%llx nlink_delta %d name '%.*s'",
1909 MAJOR(__entry->dev), MINOR(__entry->dev),
1910 __entry->parent_ino,
1911 __entry->child_ino,
1912 __entry->delta,
1913 __entry->namelen,
1914 __get_str(name))
1915 );
1916
1917 /* repair tracepoints */
1918 #if IS_ENABLED(CONFIG_XFS_ONLINE_REPAIR)
1919
1920 DECLARE_EVENT_CLASS(xrep_extent_class,
1921 TP_PROTO(struct xfs_perag *pag, xfs_agblock_t agbno, xfs_extlen_t len),
1922 TP_ARGS(pag, agbno, len),
1923 TP_STRUCT__entry(
1924 __field(dev_t, dev)
1925 __field(xfs_agnumber_t, agno)
1926 __field(xfs_agblock_t, agbno)
1927 __field(xfs_extlen_t, len)
1928 ),
1929 TP_fast_assign(
1930 __entry->dev = pag->pag_mount->m_super->s_dev;
1931 __entry->agno = pag->pag_agno;
1932 __entry->agbno = agbno;
1933 __entry->len = len;
1934 ),
1935 TP_printk("dev %d:%d agno 0x%x agbno 0x%x fsbcount 0x%x",
1936 MAJOR(__entry->dev), MINOR(__entry->dev),
1937 __entry->agno,
1938 __entry->agbno,
1939 __entry->len)
1940 );
1941 #define DEFINE_REPAIR_EXTENT_EVENT(name) \
1942 DEFINE_EVENT(xrep_extent_class, name, \
1943 TP_PROTO(struct xfs_perag *pag, xfs_agblock_t agbno, xfs_extlen_t len), \
1944 TP_ARGS(pag, agbno, len))
1945 DEFINE_REPAIR_EXTENT_EVENT(xreap_dispose_unmap_extent);
1946 DEFINE_REPAIR_EXTENT_EVENT(xreap_dispose_free_extent);
1947 DEFINE_REPAIR_EXTENT_EVENT(xreap_agextent_binval);
1948 DEFINE_REPAIR_EXTENT_EVENT(xreap_bmapi_binval);
1949 DEFINE_REPAIR_EXTENT_EVENT(xrep_agfl_insert);
1950
1951 DECLARE_EVENT_CLASS(xrep_reap_find_class,
1952 TP_PROTO(struct xfs_perag *pag, xfs_agblock_t agbno, xfs_extlen_t len,
1953 bool crosslinked),
1954 TP_ARGS(pag, agbno, len, crosslinked),
1955 TP_STRUCT__entry(
1956 __field(dev_t, dev)
1957 __field(xfs_agnumber_t, agno)
1958 __field(xfs_agblock_t, agbno)
1959 __field(xfs_extlen_t, len)
1960 __field(bool, crosslinked)
1961 ),
1962 TP_fast_assign(
1963 __entry->dev = pag->pag_mount->m_super->s_dev;
1964 __entry->agno = pag->pag_agno;
1965 __entry->agbno = agbno;
1966 __entry->len = len;
1967 __entry->crosslinked = crosslinked;
1968 ),
1969 TP_printk("dev %d:%d agno 0x%x agbno 0x%x fsbcount 0x%x crosslinked %d",
1970 MAJOR(__entry->dev), MINOR(__entry->dev),
1971 __entry->agno,
1972 __entry->agbno,
1973 __entry->len,
1974 __entry->crosslinked ? 1 : 0)
1975 );
1976 #define DEFINE_REPAIR_REAP_FIND_EVENT(name) \
1977 DEFINE_EVENT(xrep_reap_find_class, name, \
1978 TP_PROTO(struct xfs_perag *pag, xfs_agblock_t agbno, xfs_extlen_t len, \
1979 bool crosslinked), \
1980 TP_ARGS(pag, agbno, len, crosslinked))
1981 DEFINE_REPAIR_REAP_FIND_EVENT(xreap_agextent_select);
1982 DEFINE_REPAIR_REAP_FIND_EVENT(xreap_bmapi_select);
1983
1984 DECLARE_EVENT_CLASS(xrep_rmap_class,
1985 TP_PROTO(struct xfs_mount *mp, xfs_agnumber_t agno,
1986 xfs_agblock_t agbno, xfs_extlen_t len,
1987 uint64_t owner, uint64_t offset, unsigned int flags),
1988 TP_ARGS(mp, agno, agbno, len, owner, offset, flags),
1989 TP_STRUCT__entry(
1990 __field(dev_t, dev)
1991 __field(xfs_agnumber_t, agno)
1992 __field(xfs_agblock_t, agbno)
1993 __field(xfs_extlen_t, len)
1994 __field(uint64_t, owner)
1995 __field(uint64_t, offset)
1996 __field(unsigned int, flags)
1997 ),
1998 TP_fast_assign(
1999 __entry->dev = mp->m_super->s_dev;
2000 __entry->agno = agno;
2001 __entry->agbno = agbno;
2002 __entry->len = len;
2003 __entry->owner = owner;
2004 __entry->offset = offset;
2005 __entry->flags = flags;
2006 ),
2007 TP_printk("dev %d:%d agno 0x%x agbno 0x%x fsbcount 0x%x owner 0x%llx fileoff 0x%llx flags 0x%x",
2008 MAJOR(__entry->dev), MINOR(__entry->dev),
2009 __entry->agno,
2010 __entry->agbno,
2011 __entry->len,
2012 __entry->owner,
2013 __entry->offset,
2014 __entry->flags)
2015 );
2016 #define DEFINE_REPAIR_RMAP_EVENT(name) \
2017 DEFINE_EVENT(xrep_rmap_class, name, \
2018 TP_PROTO(struct xfs_mount *mp, xfs_agnumber_t agno, \
2019 xfs_agblock_t agbno, xfs_extlen_t len, \
2020 uint64_t owner, uint64_t offset, unsigned int flags), \
2021 TP_ARGS(mp, agno, agbno, len, owner, offset, flags))
2022 DEFINE_REPAIR_RMAP_EVENT(xrep_ibt_walk_rmap);
2023 DEFINE_REPAIR_RMAP_EVENT(xrep_bmap_walk_rmap);
2024
2025 TRACE_EVENT(xrep_abt_found,
2026 TP_PROTO(struct xfs_mount *mp, xfs_agnumber_t agno,
2027 const struct xfs_alloc_rec_incore *rec),
2028 TP_ARGS(mp, agno, rec),
2029 TP_STRUCT__entry(
2030 __field(dev_t, dev)
2031 __field(xfs_agnumber_t, agno)
2032 __field(xfs_agblock_t, startblock)
2033 __field(xfs_extlen_t, blockcount)
2034 ),
2035 TP_fast_assign(
2036 __entry->dev = mp->m_super->s_dev;
2037 __entry->agno = agno;
2038 __entry->startblock = rec->ar_startblock;
2039 __entry->blockcount = rec->ar_blockcount;
2040 ),
2041 TP_printk("dev %d:%d agno 0x%x agbno 0x%x fsbcount 0x%x",
2042 MAJOR(__entry->dev), MINOR(__entry->dev),
2043 __entry->agno,
2044 __entry->startblock,
2045 __entry->blockcount)
2046 )
2047
2048 TRACE_EVENT(xrep_ibt_found,
2049 TP_PROTO(struct xfs_mount *mp, xfs_agnumber_t agno,
2050 const struct xfs_inobt_rec_incore *rec),
2051 TP_ARGS(mp, agno, rec),
2052 TP_STRUCT__entry(
2053 __field(dev_t, dev)
2054 __field(xfs_agnumber_t, agno)
2055 __field(xfs_agino_t, startino)
2056 __field(uint16_t, holemask)
2057 __field(uint8_t, count)
2058 __field(uint8_t, freecount)
2059 __field(uint64_t, freemask)
2060 ),
2061 TP_fast_assign(
2062 __entry->dev = mp->m_super->s_dev;
2063 __entry->agno = agno;
2064 __entry->startino = rec->ir_startino;
2065 __entry->holemask = rec->ir_holemask;
2066 __entry->count = rec->ir_count;
2067 __entry->freecount = rec->ir_freecount;
2068 __entry->freemask = rec->ir_free;
2069 ),
2070 TP_printk("dev %d:%d agno 0x%x agino 0x%x holemask 0x%x count 0x%x freecount 0x%x freemask 0x%llx",
2071 MAJOR(__entry->dev), MINOR(__entry->dev),
2072 __entry->agno,
2073 __entry->startino,
2074 __entry->holemask,
2075 __entry->count,
2076 __entry->freecount,
2077 __entry->freemask)
2078 )
2079
2080 TRACE_EVENT(xrep_refc_found,
2081 TP_PROTO(struct xfs_perag *pag, const struct xfs_refcount_irec *rec),
2082 TP_ARGS(pag, rec),
2083 TP_STRUCT__entry(
2084 __field(dev_t, dev)
2085 __field(xfs_agnumber_t, agno)
2086 __field(enum xfs_refc_domain, domain)
2087 __field(xfs_agblock_t, startblock)
2088 __field(xfs_extlen_t, blockcount)
2089 __field(xfs_nlink_t, refcount)
2090 ),
2091 TP_fast_assign(
2092 __entry->dev = pag->pag_mount->m_super->s_dev;
2093 __entry->agno = pag->pag_agno;
2094 __entry->domain = rec->rc_domain;
2095 __entry->startblock = rec->rc_startblock;
2096 __entry->blockcount = rec->rc_blockcount;
2097 __entry->refcount = rec->rc_refcount;
2098 ),
2099 TP_printk("dev %d:%d agno 0x%x dom %s agbno 0x%x fsbcount 0x%x refcount %u",
2100 MAJOR(__entry->dev), MINOR(__entry->dev),
2101 __entry->agno,
2102 __print_symbolic(__entry->domain, XFS_REFC_DOMAIN_STRINGS),
2103 __entry->startblock,
2104 __entry->blockcount,
2105 __entry->refcount)
2106 )
2107
2108 TRACE_EVENT(xrep_bmap_found,
2109 TP_PROTO(struct xfs_inode *ip, int whichfork,
2110 struct xfs_bmbt_irec *irec),
2111 TP_ARGS(ip, whichfork, irec),
2112 TP_STRUCT__entry(
2113 __field(dev_t, dev)
2114 __field(xfs_ino_t, ino)
2115 __field(int, whichfork)
2116 __field(xfs_fileoff_t, lblk)
2117 __field(xfs_filblks_t, len)
2118 __field(xfs_fsblock_t, pblk)
2119 __field(int, state)
2120 ),
2121 TP_fast_assign(
2122 __entry->dev = VFS_I(ip)->i_sb->s_dev;
2123 __entry->ino = ip->i_ino;
2124 __entry->whichfork = whichfork;
2125 __entry->lblk = irec->br_startoff;
2126 __entry->len = irec->br_blockcount;
2127 __entry->pblk = irec->br_startblock;
2128 __entry->state = irec->br_state;
2129 ),
2130 TP_printk("dev %d:%d ino 0x%llx whichfork %s fileoff 0x%llx fsbcount 0x%llx startblock 0x%llx state %d",
2131 MAJOR(__entry->dev), MINOR(__entry->dev),
2132 __entry->ino,
2133 __print_symbolic(__entry->whichfork, XFS_WHICHFORK_STRINGS),
2134 __entry->lblk,
2135 __entry->len,
2136 __entry->pblk,
2137 __entry->state)
2138 );
2139
2140 TRACE_EVENT(xrep_rmap_found,
2141 TP_PROTO(struct xfs_mount *mp, xfs_agnumber_t agno,
2142 const struct xfs_rmap_irec *rec),
2143 TP_ARGS(mp, agno, rec),
2144 TP_STRUCT__entry(
2145 __field(dev_t, dev)
2146 __field(xfs_agnumber_t, agno)
2147 __field(xfs_agblock_t, agbno)
2148 __field(xfs_extlen_t, len)
2149 __field(uint64_t, owner)
2150 __field(uint64_t, offset)
2151 __field(unsigned int, flags)
2152 ),
2153 TP_fast_assign(
2154 __entry->dev = mp->m_super->s_dev;
2155 __entry->agno = agno;
2156 __entry->agbno = rec->rm_startblock;
2157 __entry->len = rec->rm_blockcount;
2158 __entry->owner = rec->rm_owner;
2159 __entry->offset = rec->rm_offset;
2160 __entry->flags = rec->rm_flags;
2161 ),
2162 TP_printk("dev %d:%d agno 0x%x agbno 0x%x fsbcount 0x%x owner 0x%llx fileoff 0x%llx flags 0x%x",
2163 MAJOR(__entry->dev), MINOR(__entry->dev),
2164 __entry->agno,
2165 __entry->agbno,
2166 __entry->len,
2167 __entry->owner,
2168 __entry->offset,
2169 __entry->flags)
2170 );
2171
2172 TRACE_EVENT(xrep_findroot_block,
2173 TP_PROTO(struct xfs_mount *mp, xfs_agnumber_t agno, xfs_agblock_t agbno,
2174 uint32_t magic, uint16_t level),
2175 TP_ARGS(mp, agno, agbno, magic, level),
2176 TP_STRUCT__entry(
2177 __field(dev_t, dev)
2178 __field(xfs_agnumber_t, agno)
2179 __field(xfs_agblock_t, agbno)
2180 __field(uint32_t, magic)
2181 __field(uint16_t, level)
2182 ),
2183 TP_fast_assign(
2184 __entry->dev = mp->m_super->s_dev;
2185 __entry->agno = agno;
2186 __entry->agbno = agbno;
2187 __entry->magic = magic;
2188 __entry->level = level;
2189 ),
2190 TP_printk("dev %d:%d agno 0x%x agbno 0x%x magic 0x%x level %u",
2191 MAJOR(__entry->dev), MINOR(__entry->dev),
2192 __entry->agno,
2193 __entry->agbno,
2194 __entry->magic,
2195 __entry->level)
2196 )
2197 TRACE_EVENT(xrep_calc_ag_resblks,
2198 TP_PROTO(struct xfs_mount *mp, xfs_agnumber_t agno,
2199 xfs_agino_t icount, xfs_agblock_t aglen, xfs_agblock_t freelen,
2200 xfs_agblock_t usedlen),
2201 TP_ARGS(mp, agno, icount, aglen, freelen, usedlen),
2202 TP_STRUCT__entry(
2203 __field(dev_t, dev)
2204 __field(xfs_agnumber_t, agno)
2205 __field(xfs_agino_t, icount)
2206 __field(xfs_agblock_t, aglen)
2207 __field(xfs_agblock_t, freelen)
2208 __field(xfs_agblock_t, usedlen)
2209 ),
2210 TP_fast_assign(
2211 __entry->dev = mp->m_super->s_dev;
2212 __entry->agno = agno;
2213 __entry->icount = icount;
2214 __entry->aglen = aglen;
2215 __entry->freelen = freelen;
2216 __entry->usedlen = usedlen;
2217 ),
2218 TP_printk("dev %d:%d agno 0x%x icount %u aglen %u freelen %u usedlen %u",
2219 MAJOR(__entry->dev), MINOR(__entry->dev),
2220 __entry->agno,
2221 __entry->icount,
2222 __entry->aglen,
2223 __entry->freelen,
2224 __entry->usedlen)
2225 )
2226 TRACE_EVENT(xrep_calc_ag_resblks_btsize,
2227 TP_PROTO(struct xfs_mount *mp, xfs_agnumber_t agno,
2228 xfs_agblock_t bnobt_sz, xfs_agblock_t inobt_sz,
2229 xfs_agblock_t rmapbt_sz, xfs_agblock_t refcbt_sz),
2230 TP_ARGS(mp, agno, bnobt_sz, inobt_sz, rmapbt_sz, refcbt_sz),
2231 TP_STRUCT__entry(
2232 __field(dev_t, dev)
2233 __field(xfs_agnumber_t, agno)
2234 __field(xfs_agblock_t, bnobt_sz)
2235 __field(xfs_agblock_t, inobt_sz)
2236 __field(xfs_agblock_t, rmapbt_sz)
2237 __field(xfs_agblock_t, refcbt_sz)
2238 ),
2239 TP_fast_assign(
2240 __entry->dev = mp->m_super->s_dev;
2241 __entry->agno = agno;
2242 __entry->bnobt_sz = bnobt_sz;
2243 __entry->inobt_sz = inobt_sz;
2244 __entry->rmapbt_sz = rmapbt_sz;
2245 __entry->refcbt_sz = refcbt_sz;
2246 ),
2247 TP_printk("dev %d:%d agno 0x%x bnobt %u inobt %u rmapbt %u refcountbt %u",
2248 MAJOR(__entry->dev), MINOR(__entry->dev),
2249 __entry->agno,
2250 __entry->bnobt_sz,
2251 __entry->inobt_sz,
2252 __entry->rmapbt_sz,
2253 __entry->refcbt_sz)
2254 )
2255 TRACE_EVENT(xrep_reset_counters,
2256 TP_PROTO(struct xfs_mount *mp, struct xchk_fscounters *fsc),
2257 TP_ARGS(mp, fsc),
2258 TP_STRUCT__entry(
2259 __field(dev_t, dev)
2260 __field(uint64_t, icount)
2261 __field(uint64_t, ifree)
2262 __field(uint64_t, fdblocks)
2263 __field(uint64_t, frextents)
2264 ),
2265 TP_fast_assign(
2266 __entry->dev = mp->m_super->s_dev;
2267 __entry->icount = fsc->icount;
2268 __entry->ifree = fsc->ifree;
2269 __entry->fdblocks = fsc->fdblocks;
2270 __entry->frextents = fsc->frextents;
2271 ),
2272 TP_printk("dev %d:%d icount %llu ifree %llu fdblocks %llu frextents %llu",
2273 MAJOR(__entry->dev), MINOR(__entry->dev),
2274 __entry->icount,
2275 __entry->ifree,
2276 __entry->fdblocks,
2277 __entry->frextents)
2278 )
2279
2280 DECLARE_EVENT_CLASS(xrep_newbt_extent_class,
2281 TP_PROTO(struct xfs_mount *mp, xfs_agnumber_t agno,
2282 xfs_agblock_t agbno, xfs_extlen_t len,
2283 int64_t owner),
2284 TP_ARGS(mp, agno, agbno, len, owner),
2285 TP_STRUCT__entry(
2286 __field(dev_t, dev)
2287 __field(xfs_agnumber_t, agno)
2288 __field(xfs_agblock_t, agbno)
2289 __field(xfs_extlen_t, len)
2290 __field(int64_t, owner)
2291 ),
2292 TP_fast_assign(
2293 __entry->dev = mp->m_super->s_dev;
2294 __entry->agno = agno;
2295 __entry->agbno = agbno;
2296 __entry->len = len;
2297 __entry->owner = owner;
2298 ),
2299 TP_printk("dev %d:%d agno 0x%x agbno 0x%x fsbcount 0x%x owner 0x%llx",
2300 MAJOR(__entry->dev), MINOR(__entry->dev),
2301 __entry->agno,
2302 __entry->agbno,
2303 __entry->len,
2304 __entry->owner)
2305 );
2306 #define DEFINE_NEWBT_EXTENT_EVENT(name) \
2307 DEFINE_EVENT(xrep_newbt_extent_class, name, \
2308 TP_PROTO(struct xfs_mount *mp, xfs_agnumber_t agno, \
2309 xfs_agblock_t agbno, xfs_extlen_t len, \
2310 int64_t owner), \
2311 TP_ARGS(mp, agno, agbno, len, owner))
2312 DEFINE_NEWBT_EXTENT_EVENT(xrep_newbt_alloc_ag_blocks);
2313 DEFINE_NEWBT_EXTENT_EVENT(xrep_newbt_alloc_file_blocks);
2314 DEFINE_NEWBT_EXTENT_EVENT(xrep_newbt_free_blocks);
2315 DEFINE_NEWBT_EXTENT_EVENT(xrep_newbt_claim_block);
2316
2317 DECLARE_EVENT_CLASS(xrep_dinode_class,
2318 TP_PROTO(struct xfs_scrub *sc, struct xfs_dinode *dip),
2319 TP_ARGS(sc, dip),
2320 TP_STRUCT__entry(
2321 __field(dev_t, dev)
2322 __field(xfs_ino_t, ino)
2323 __field(uint16_t, mode)
2324 __field(uint8_t, version)
2325 __field(uint8_t, format)
2326 __field(uint32_t, uid)
2327 __field(uint32_t, gid)
2328 __field(uint64_t, size)
2329 __field(uint64_t, nblocks)
2330 __field(uint32_t, extsize)
2331 __field(uint32_t, nextents)
2332 __field(uint16_t, anextents)
2333 __field(uint8_t, forkoff)
2334 __field(uint8_t, aformat)
2335 __field(uint16_t, flags)
2336 __field(uint32_t, gen)
2337 __field(uint64_t, flags2)
2338 __field(uint32_t, cowextsize)
2339 ),
2340 TP_fast_assign(
2341 __entry->dev = sc->mp->m_super->s_dev;
2342 __entry->ino = sc->sm->sm_ino;
2343 __entry->mode = be16_to_cpu(dip->di_mode);
2344 __entry->version = dip->di_version;
2345 __entry->format = dip->di_format;
2346 __entry->uid = be32_to_cpu(dip->di_uid);
2347 __entry->gid = be32_to_cpu(dip->di_gid);
2348 __entry->size = be64_to_cpu(dip->di_size);
2349 __entry->nblocks = be64_to_cpu(dip->di_nblocks);
2350 __entry->extsize = be32_to_cpu(dip->di_extsize);
2351 __entry->nextents = be32_to_cpu(dip->di_nextents);
2352 __entry->anextents = be16_to_cpu(dip->di_anextents);
2353 __entry->forkoff = dip->di_forkoff;
2354 __entry->aformat = dip->di_aformat;
2355 __entry->flags = be16_to_cpu(dip->di_flags);
2356 __entry->gen = be32_to_cpu(dip->di_gen);
2357 __entry->flags2 = be64_to_cpu(dip->di_flags2);
2358 __entry->cowextsize = be32_to_cpu(dip->di_cowextsize);
2359 ),
2360 TP_printk("dev %d:%d ino 0x%llx mode 0x%x version %u format %u uid %u gid %u disize 0x%llx nblocks 0x%llx extsize %u nextents %u anextents %u forkoff 0x%x aformat %u flags 0x%x gen 0x%x flags2 0x%llx cowextsize %u",
2361 MAJOR(__entry->dev), MINOR(__entry->dev),
2362 __entry->ino,
2363 __entry->mode,
2364 __entry->version,
2365 __entry->format,
2366 __entry->uid,
2367 __entry->gid,
2368 __entry->size,
2369 __entry->nblocks,
2370 __entry->extsize,
2371 __entry->nextents,
2372 __entry->anextents,
2373 __entry->forkoff,
2374 __entry->aformat,
2375 __entry->flags,
2376 __entry->gen,
2377 __entry->flags2,
2378 __entry->cowextsize)
2379 )
2380
2381 #define DEFINE_REPAIR_DINODE_EVENT(name) \
2382 DEFINE_EVENT(xrep_dinode_class, name, \
2383 TP_PROTO(struct xfs_scrub *sc, struct xfs_dinode *dip), \
2384 TP_ARGS(sc, dip))
2385 DEFINE_REPAIR_DINODE_EVENT(xrep_dinode_header);
2386 DEFINE_REPAIR_DINODE_EVENT(xrep_dinode_mode);
2387 DEFINE_REPAIR_DINODE_EVENT(xrep_dinode_flags);
2388 DEFINE_REPAIR_DINODE_EVENT(xrep_dinode_size);
2389 DEFINE_REPAIR_DINODE_EVENT(xrep_dinode_extsize_hints);
2390 DEFINE_REPAIR_DINODE_EVENT(xrep_dinode_zap_symlink);
2391 DEFINE_REPAIR_DINODE_EVENT(xrep_dinode_zap_dir);
2392 DEFINE_REPAIR_DINODE_EVENT(xrep_dinode_fixed);
2393 DEFINE_REPAIR_DINODE_EVENT(xrep_dinode_zap_forks);
2394 DEFINE_REPAIR_DINODE_EVENT(xrep_dinode_zap_dfork);
2395 DEFINE_REPAIR_DINODE_EVENT(xrep_dinode_zap_afork);
2396 DEFINE_REPAIR_DINODE_EVENT(xrep_dinode_ensure_forkoff);
2397
2398 DECLARE_EVENT_CLASS(xrep_inode_class,
2399 TP_PROTO(struct xfs_scrub *sc),
2400 TP_ARGS(sc),
2401 TP_STRUCT__entry(
2402 __field(dev_t, dev)
2403 __field(xfs_ino_t, ino)
2404 __field(xfs_fsize_t, size)
2405 __field(xfs_rfsblock_t, nblocks)
2406 __field(uint16_t, flags)
2407 __field(uint64_t, flags2)
2408 __field(uint32_t, nextents)
2409 __field(uint8_t, format)
2410 __field(uint32_t, anextents)
2411 __field(uint8_t, aformat)
2412 ),
2413 TP_fast_assign(
2414 __entry->dev = sc->mp->m_super->s_dev;
2415 __entry->ino = sc->sm->sm_ino;
2416 __entry->size = sc->ip->i_disk_size;
2417 __entry->nblocks = sc->ip->i_nblocks;
2418 __entry->flags = sc->ip->i_diflags;
2419 __entry->flags2 = sc->ip->i_diflags2;
2420 __entry->nextents = sc->ip->i_df.if_nextents;
2421 __entry->format = sc->ip->i_df.if_format;
2422 __entry->anextents = sc->ip->i_af.if_nextents;
2423 __entry->aformat = sc->ip->i_af.if_format;
2424 ),
2425 TP_printk("dev %d:%d ino 0x%llx disize 0x%llx nblocks 0x%llx flags 0x%x flags2 0x%llx nextents %u format %u anextents %u aformat %u",
2426 MAJOR(__entry->dev), MINOR(__entry->dev),
2427 __entry->ino,
2428 __entry->size,
2429 __entry->nblocks,
2430 __entry->flags,
2431 __entry->flags2,
2432 __entry->nextents,
2433 __entry->format,
2434 __entry->anextents,
2435 __entry->aformat)
2436 )
2437
2438 #define DEFINE_REPAIR_INODE_EVENT(name) \
2439 DEFINE_EVENT(xrep_inode_class, name, \
2440 TP_PROTO(struct xfs_scrub *sc), \
2441 TP_ARGS(sc))
2442 DEFINE_REPAIR_INODE_EVENT(xrep_inode_blockcounts);
2443 DEFINE_REPAIR_INODE_EVENT(xrep_inode_ids);
2444 DEFINE_REPAIR_INODE_EVENT(xrep_inode_flags);
2445 DEFINE_REPAIR_INODE_EVENT(xrep_inode_blockdir_size);
2446 DEFINE_REPAIR_INODE_EVENT(xrep_inode_sfdir_size);
2447 DEFINE_REPAIR_INODE_EVENT(xrep_inode_dir_size);
2448 DEFINE_REPAIR_INODE_EVENT(xrep_inode_fixed);
2449
2450 TRACE_EVENT(xrep_dinode_count_rmaps,
2451 TP_PROTO(struct xfs_scrub *sc, xfs_rfsblock_t data_blocks,
2452 xfs_rfsblock_t rt_blocks, xfs_rfsblock_t attr_blocks,
2453 xfs_extnum_t data_extents, xfs_extnum_t rt_extents,
2454 xfs_aextnum_t attr_extents),
2455 TP_ARGS(sc, data_blocks, rt_blocks, attr_blocks, data_extents,
2456 rt_extents, attr_extents),
2457 TP_STRUCT__entry(
2458 __field(dev_t, dev)
2459 __field(xfs_ino_t, ino)
2460 __field(xfs_rfsblock_t, data_blocks)
2461 __field(xfs_rfsblock_t, rt_blocks)
2462 __field(xfs_rfsblock_t, attr_blocks)
2463 __field(xfs_extnum_t, data_extents)
2464 __field(xfs_extnum_t, rt_extents)
2465 __field(xfs_aextnum_t, attr_extents)
2466 ),
2467 TP_fast_assign(
2468 __entry->dev = sc->mp->m_super->s_dev;
2469 __entry->ino = sc->sm->sm_ino;
2470 __entry->data_blocks = data_blocks;
2471 __entry->rt_blocks = rt_blocks;
2472 __entry->attr_blocks = attr_blocks;
2473 __entry->data_extents = data_extents;
2474 __entry->rt_extents = rt_extents;
2475 __entry->attr_extents = attr_extents;
2476 ),
2477 TP_printk("dev %d:%d ino 0x%llx dblocks 0x%llx rtblocks 0x%llx ablocks 0x%llx dextents %llu rtextents %llu aextents %u",
2478 MAJOR(__entry->dev), MINOR(__entry->dev),
2479 __entry->ino,
2480 __entry->data_blocks,
2481 __entry->rt_blocks,
2482 __entry->attr_blocks,
2483 __entry->data_extents,
2484 __entry->rt_extents,
2485 __entry->attr_extents)
2486 );
2487
2488 TRACE_EVENT(xrep_dinode_findmode_dirent,
2489 TP_PROTO(struct xfs_scrub *sc, struct xfs_inode *dp,
2490 unsigned int ftype),
2491 TP_ARGS(sc, dp, ftype),
2492 TP_STRUCT__entry(
2493 __field(dev_t, dev)
2494 __field(xfs_ino_t, ino)
2495 __field(xfs_ino_t, parent_ino)
2496 __field(unsigned int, ftype)
2497 ),
2498 TP_fast_assign(
2499 __entry->dev = sc->mp->m_super->s_dev;
2500 __entry->ino = sc->sm->sm_ino;
2501 __entry->parent_ino = dp->i_ino;
2502 __entry->ftype = ftype;
2503 ),
2504 TP_printk("dev %d:%d ino 0x%llx parent_ino 0x%llx ftype '%s'",
2505 MAJOR(__entry->dev), MINOR(__entry->dev),
2506 __entry->ino,
2507 __entry->parent_ino,
2508 __print_symbolic(__entry->ftype, XFS_DIR3_FTYPE_STR))
2509 );
2510
2511 TRACE_EVENT(xrep_dinode_findmode_dirent_inval,
2512 TP_PROTO(struct xfs_scrub *sc, struct xfs_inode *dp,
2513 unsigned int ftype, unsigned int found_ftype),
2514 TP_ARGS(sc, dp, ftype, found_ftype),
2515 TP_STRUCT__entry(
2516 __field(dev_t, dev)
2517 __field(xfs_ino_t, ino)
2518 __field(xfs_ino_t, parent_ino)
2519 __field(unsigned int, ftype)
2520 __field(unsigned int, found_ftype)
2521 ),
2522 TP_fast_assign(
2523 __entry->dev = sc->mp->m_super->s_dev;
2524 __entry->ino = sc->sm->sm_ino;
2525 __entry->parent_ino = dp->i_ino;
2526 __entry->ftype = ftype;
2527 __entry->found_ftype = found_ftype;
2528 ),
2529 TP_printk("dev %d:%d ino 0x%llx parent_ino 0x%llx ftype '%s' found_ftype '%s'",
2530 MAJOR(__entry->dev), MINOR(__entry->dev),
2531 __entry->ino,
2532 __entry->parent_ino,
2533 __print_symbolic(__entry->ftype, XFS_DIR3_FTYPE_STR),
2534 __print_symbolic(__entry->found_ftype, XFS_DIR3_FTYPE_STR))
2535 );
2536
2537 TRACE_EVENT(xrep_cow_mark_file_range,
2538 TP_PROTO(struct xfs_inode *ip, xfs_fsblock_t startblock,
2539 xfs_fileoff_t startoff, xfs_filblks_t blockcount),
2540 TP_ARGS(ip, startblock, startoff, blockcount),
2541 TP_STRUCT__entry(
2542 __field(dev_t, dev)
2543 __field(xfs_ino_t, ino)
2544 __field(xfs_fsblock_t, startblock)
2545 __field(xfs_fileoff_t, startoff)
2546 __field(xfs_filblks_t, blockcount)
2547 ),
2548 TP_fast_assign(
2549 __entry->dev = ip->i_mount->m_super->s_dev;
2550 __entry->ino = ip->i_ino;
2551 __entry->startoff = startoff;
2552 __entry->startblock = startblock;
2553 __entry->blockcount = blockcount;
2554 ),
2555 TP_printk("dev %d:%d ino 0x%llx fileoff 0x%llx startblock 0x%llx fsbcount 0x%llx",
2556 MAJOR(__entry->dev), MINOR(__entry->dev),
2557 __entry->ino,
2558 __entry->startoff,
2559 __entry->startblock,
2560 __entry->blockcount)
2561 );
2562
2563 TRACE_EVENT(xrep_cow_replace_mapping,
2564 TP_PROTO(struct xfs_inode *ip, const struct xfs_bmbt_irec *irec,
2565 xfs_fsblock_t new_startblock, xfs_extlen_t new_blockcount),
2566 TP_ARGS(ip, irec, new_startblock, new_blockcount),
2567 TP_STRUCT__entry(
2568 __field(dev_t, dev)
2569 __field(xfs_ino_t, ino)
2570 __field(xfs_fsblock_t, startblock)
2571 __field(xfs_fileoff_t, startoff)
2572 __field(xfs_filblks_t, blockcount)
2573 __field(xfs_exntst_t, state)
2574 __field(xfs_fsblock_t, new_startblock)
2575 __field(xfs_extlen_t, new_blockcount)
2576 ),
2577 TP_fast_assign(
2578 __entry->dev = ip->i_mount->m_super->s_dev;
2579 __entry->ino = ip->i_ino;
2580 __entry->startoff = irec->br_startoff;
2581 __entry->startblock = irec->br_startblock;
2582 __entry->blockcount = irec->br_blockcount;
2583 __entry->state = irec->br_state;
2584 __entry->new_startblock = new_startblock;
2585 __entry->new_blockcount = new_blockcount;
2586 ),
2587 TP_printk("dev %d:%d ino 0x%llx startoff 0x%llx startblock 0x%llx fsbcount 0x%llx state 0x%x new_startblock 0x%llx new_fsbcount 0x%x",
2588 MAJOR(__entry->dev), MINOR(__entry->dev),
2589 __entry->ino,
2590 __entry->startoff,
2591 __entry->startblock,
2592 __entry->blockcount,
2593 __entry->state,
2594 __entry->new_startblock,
2595 __entry->new_blockcount)
2596 );
2597
2598 TRACE_EVENT(xrep_cow_free_staging,
2599 TP_PROTO(struct xfs_perag *pag, xfs_agblock_t agbno,
2600 xfs_extlen_t blockcount),
2601 TP_ARGS(pag, agbno, blockcount),
2602 TP_STRUCT__entry(
2603 __field(dev_t, dev)
2604 __field(xfs_agnumber_t, agno)
2605 __field(xfs_agblock_t, agbno)
2606 __field(xfs_extlen_t, blockcount)
2607 ),
2608 TP_fast_assign(
2609 __entry->dev = pag->pag_mount->m_super->s_dev;
2610 __entry->agno = pag->pag_agno;
2611 __entry->agbno = agbno;
2612 __entry->blockcount = blockcount;
2613 ),
2614 TP_printk("dev %d:%d agno 0x%x agbno 0x%x fsbcount 0x%x",
2615 MAJOR(__entry->dev), MINOR(__entry->dev),
2616 __entry->agno,
2617 __entry->agbno,
2618 __entry->blockcount)
2619 );
2620
2621 #ifdef CONFIG_XFS_QUOTA
2622 DECLARE_EVENT_CLASS(xrep_dquot_class,
2623 TP_PROTO(struct xfs_mount *mp, uint8_t type, uint32_t id),
2624 TP_ARGS(mp, type, id),
2625 TP_STRUCT__entry(
2626 __field(dev_t, dev)
2627 __field(uint8_t, type)
2628 __field(uint32_t, id)
2629 ),
2630 TP_fast_assign(
2631 __entry->dev = mp->m_super->s_dev;
2632 __entry->id = id;
2633 __entry->type = type;
2634 ),
2635 TP_printk("dev %d:%d type %s id 0x%x",
2636 MAJOR(__entry->dev), MINOR(__entry->dev),
2637 __print_flags(__entry->type, "|", XFS_DQTYPE_STRINGS),
2638 __entry->id)
2639 );
2640
2641 #define DEFINE_XREP_DQUOT_EVENT(name) \
2642 DEFINE_EVENT(xrep_dquot_class, name, \
2643 TP_PROTO(struct xfs_mount *mp, uint8_t type, uint32_t id), \
2644 TP_ARGS(mp, type, id))
2645 DEFINE_XREP_DQUOT_EVENT(xrep_dquot_item);
2646 DEFINE_XREP_DQUOT_EVENT(xrep_disk_dquot);
2647 DEFINE_XREP_DQUOT_EVENT(xrep_dquot_item_fill_bmap_hole);
2648 DEFINE_XREP_DQUOT_EVENT(xrep_quotacheck_dquot);
2649 #endif /* CONFIG_XFS_QUOTA */
2650
2651 DEFINE_SCRUB_NLINKS_DIFF_EVENT(xrep_nlinks_update_inode);
2652 DEFINE_SCRUB_NLINKS_DIFF_EVENT(xrep_nlinks_unfixable_inode);
2653
2654 TRACE_EVENT(xrep_rmap_live_update,
2655 TP_PROTO(struct xfs_mount *mp, xfs_agnumber_t agno, unsigned int op,
2656 const struct xfs_rmap_update_params *p),
2657 TP_ARGS(mp, agno, op, p),
2658 TP_STRUCT__entry(
2659 __field(dev_t, dev)
2660 __field(xfs_agnumber_t, agno)
2661 __field(unsigned int, op)
2662 __field(xfs_agblock_t, agbno)
2663 __field(xfs_extlen_t, len)
2664 __field(uint64_t, owner)
2665 __field(uint64_t, offset)
2666 __field(unsigned int, flags)
2667 ),
2668 TP_fast_assign(
2669 __entry->dev = mp->m_super->s_dev;
2670 __entry->agno = agno;
2671 __entry->op = op;
2672 __entry->agbno = p->startblock;
2673 __entry->len = p->blockcount;
2674 xfs_owner_info_unpack(&p->oinfo, &__entry->owner,
2675 &__entry->offset, &__entry->flags);
2676 if (p->unwritten)
2677 __entry->flags |= XFS_RMAP_UNWRITTEN;
2678 ),
2679 TP_printk("dev %d:%d agno 0x%x op %d agbno 0x%x fsbcount 0x%x owner 0x%llx fileoff 0x%llx flags 0x%x",
2680 MAJOR(__entry->dev), MINOR(__entry->dev),
2681 __entry->agno,
2682 __entry->op,
2683 __entry->agbno,
2684 __entry->len,
2685 __entry->owner,
2686 __entry->offset,
2687 __entry->flags)
2688 );
2689
2690 TRACE_EVENT(xrep_tempfile_create,
2691 TP_PROTO(struct xfs_scrub *sc),
2692 TP_ARGS(sc),
2693 TP_STRUCT__entry(
2694 __field(dev_t, dev)
2695 __field(xfs_ino_t, ino)
2696 __field(unsigned int, type)
2697 __field(xfs_agnumber_t, agno)
2698 __field(xfs_ino_t, inum)
2699 __field(unsigned int, gen)
2700 __field(unsigned int, flags)
2701 __field(xfs_ino_t, temp_inum)
2702 ),
2703 TP_fast_assign(
2704 __entry->dev = sc->mp->m_super->s_dev;
2705 __entry->ino = sc->file ? XFS_I(file_inode(sc->file))->i_ino : 0;
2706 __entry->type = sc->sm->sm_type;
2707 __entry->agno = sc->sm->sm_agno;
2708 __entry->inum = sc->sm->sm_ino;
2709 __entry->gen = sc->sm->sm_gen;
2710 __entry->flags = sc->sm->sm_flags;
2711 __entry->temp_inum = sc->tempip->i_ino;
2712 ),
2713 TP_printk("dev %d:%d ino 0x%llx type %s inum 0x%llx gen 0x%x flags 0x%x temp_inum 0x%llx",
2714 MAJOR(__entry->dev), MINOR(__entry->dev),
2715 __entry->ino,
2716 __print_symbolic(__entry->type, XFS_SCRUB_TYPE_STRINGS),
2717 __entry->inum,
2718 __entry->gen,
2719 __entry->flags,
2720 __entry->temp_inum)
2721 );
2722
2723 DECLARE_EVENT_CLASS(xrep_tempfile_class,
2724 TP_PROTO(struct xfs_scrub *sc, int whichfork,
2725 struct xfs_bmbt_irec *irec),
2726 TP_ARGS(sc, whichfork, irec),
2727 TP_STRUCT__entry(
2728 __field(dev_t, dev)
2729 __field(xfs_ino_t, ino)
2730 __field(int, whichfork)
2731 __field(xfs_fileoff_t, lblk)
2732 __field(xfs_filblks_t, len)
2733 __field(xfs_fsblock_t, pblk)
2734 __field(int, state)
2735 ),
2736 TP_fast_assign(
2737 __entry->dev = sc->mp->m_super->s_dev;
2738 __entry->ino = sc->tempip->i_ino;
2739 __entry->whichfork = whichfork;
2740 __entry->lblk = irec->br_startoff;
2741 __entry->len = irec->br_blockcount;
2742 __entry->pblk = irec->br_startblock;
2743 __entry->state = irec->br_state;
2744 ),
2745 TP_printk("dev %d:%d ino 0x%llx whichfork %s fileoff 0x%llx fsbcount 0x%llx startblock 0x%llx state %d",
2746 MAJOR(__entry->dev), MINOR(__entry->dev),
2747 __entry->ino,
2748 __print_symbolic(__entry->whichfork, XFS_WHICHFORK_STRINGS),
2749 __entry->lblk,
2750 __entry->len,
2751 __entry->pblk,
2752 __entry->state)
2753 );
2754 #define DEFINE_XREP_TEMPFILE_EVENT(name) \
2755 DEFINE_EVENT(xrep_tempfile_class, name, \
2756 TP_PROTO(struct xfs_scrub *sc, int whichfork, \
2757 struct xfs_bmbt_irec *irec), \
2758 TP_ARGS(sc, whichfork, irec))
2759 DEFINE_XREP_TEMPFILE_EVENT(xrep_tempfile_prealloc);
2760 DEFINE_XREP_TEMPFILE_EVENT(xrep_tempfile_copyin);
2761
2762 TRACE_EVENT(xreap_ifork_extent,
2763 TP_PROTO(struct xfs_scrub *sc, struct xfs_inode *ip, int whichfork,
2764 const struct xfs_bmbt_irec *irec),
2765 TP_ARGS(sc, ip, whichfork, irec),
2766 TP_STRUCT__entry(
2767 __field(dev_t, dev)
2768 __field(xfs_ino_t, ino)
2769 __field(int, whichfork)
2770 __field(xfs_fileoff_t, fileoff)
2771 __field(xfs_filblks_t, len)
2772 __field(xfs_agnumber_t, agno)
2773 __field(xfs_agblock_t, agbno)
2774 __field(int, state)
2775 ),
2776 TP_fast_assign(
2777 __entry->dev = sc->mp->m_super->s_dev;
2778 __entry->ino = ip->i_ino;
2779 __entry->whichfork = whichfork;
2780 __entry->fileoff = irec->br_startoff;
2781 __entry->len = irec->br_blockcount;
2782 __entry->agno = XFS_FSB_TO_AGNO(sc->mp, irec->br_startblock);
2783 __entry->agbno = XFS_FSB_TO_AGBNO(sc->mp, irec->br_startblock);
2784 __entry->state = irec->br_state;
2785 ),
2786 TP_printk("dev %d:%d ip 0x%llx whichfork %s agno 0x%x agbno 0x%x fileoff 0x%llx fsbcount 0x%llx state 0x%x",
2787 MAJOR(__entry->dev), MINOR(__entry->dev),
2788 __entry->ino,
2789 __print_symbolic(__entry->whichfork, XFS_WHICHFORK_STRINGS),
2790 __entry->agno,
2791 __entry->agbno,
2792 __entry->fileoff,
2793 __entry->len,
2794 __entry->state)
2795 );
2796
2797 TRACE_EVENT(xreap_bmapi_binval_scan,
2798 TP_PROTO(struct xfs_scrub *sc, const struct xfs_bmbt_irec *irec,
2799 xfs_extlen_t scan_blocks),
2800 TP_ARGS(sc, irec, scan_blocks),
2801 TP_STRUCT__entry(
2802 __field(dev_t, dev)
2803 __field(xfs_filblks_t, len)
2804 __field(xfs_agnumber_t, agno)
2805 __field(xfs_agblock_t, agbno)
2806 __field(xfs_extlen_t, scan_blocks)
2807 ),
2808 TP_fast_assign(
2809 __entry->dev = sc->mp->m_super->s_dev;
2810 __entry->len = irec->br_blockcount;
2811 __entry->agno = XFS_FSB_TO_AGNO(sc->mp, irec->br_startblock);
2812 __entry->agbno = XFS_FSB_TO_AGBNO(sc->mp, irec->br_startblock);
2813 __entry->scan_blocks = scan_blocks;
2814 ),
2815 TP_printk("dev %d:%d agno 0x%x agbno 0x%x fsbcount 0x%llx scan_blocks 0x%x",
2816 MAJOR(__entry->dev), MINOR(__entry->dev),
2817 __entry->agno,
2818 __entry->agbno,
2819 __entry->len,
2820 __entry->scan_blocks)
2821 );
2822
2823 TRACE_EVENT(xrep_xattr_recover_leafblock,
2824 TP_PROTO(struct xfs_inode *ip, xfs_dablk_t dabno, uint16_t magic),
2825 TP_ARGS(ip, dabno, magic),
2826 TP_STRUCT__entry(
2827 __field(dev_t, dev)
2828 __field(xfs_ino_t, ino)
2829 __field(xfs_dablk_t, dabno)
2830 __field(uint16_t, magic)
2831 ),
2832 TP_fast_assign(
2833 __entry->dev = ip->i_mount->m_super->s_dev;
2834 __entry->ino = ip->i_ino;
2835 __entry->dabno = dabno;
2836 __entry->magic = magic;
2837 ),
2838 TP_printk("dev %d:%d ino 0x%llx dablk 0x%x magic 0x%x",
2839 MAJOR(__entry->dev), MINOR(__entry->dev),
2840 __entry->ino,
2841 __entry->dabno,
2842 __entry->magic)
2843 );
2844
2845 DECLARE_EVENT_CLASS(xrep_xattr_salvage_class,
2846 TP_PROTO(struct xfs_inode *ip, unsigned int flags, char *name,
2847 unsigned int namelen, unsigned int valuelen),
2848 TP_ARGS(ip, flags, name, namelen, valuelen),
2849 TP_STRUCT__entry(
2850 __field(dev_t, dev)
2851 __field(xfs_ino_t, ino)
2852 __field(unsigned int, flags)
2853 __field(unsigned int, namelen)
2854 __dynamic_array(char, name, namelen)
2855 __field(unsigned int, valuelen)
2856 ),
2857 TP_fast_assign(
2858 __entry->dev = ip->i_mount->m_super->s_dev;
2859 __entry->ino = ip->i_ino;
2860 __entry->flags = flags;
2861 __entry->namelen = namelen;
2862 memcpy(__get_str(name), name, namelen);
2863 __entry->valuelen = valuelen;
2864 ),
2865 TP_printk("dev %d:%d ino 0x%llx flags %s name '%.*s' valuelen 0x%x",
2866 MAJOR(__entry->dev), MINOR(__entry->dev),
2867 __entry->ino,
2868 __print_flags(__entry->flags, "|", XFS_ATTR_NAMESPACE_STR),
2869 __entry->namelen,
2870 __get_str(name),
2871 __entry->valuelen)
2872 );
2873 #define DEFINE_XREP_XATTR_SALVAGE_EVENT(name) \
2874 DEFINE_EVENT(xrep_xattr_salvage_class, name, \
2875 TP_PROTO(struct xfs_inode *ip, unsigned int flags, char *name, \
2876 unsigned int namelen, unsigned int valuelen), \
2877 TP_ARGS(ip, flags, name, namelen, valuelen))
2878 DEFINE_XREP_XATTR_SALVAGE_EVENT(xrep_xattr_salvage_rec);
2879 DEFINE_XREP_XATTR_SALVAGE_EVENT(xrep_xattr_insert_rec);
2880 DEFINE_XREP_XATTR_SALVAGE_EVENT(xrep_parent_stash_xattr);
2881 DEFINE_XREP_XATTR_SALVAGE_EVENT(xrep_parent_insert_xattr);
2882
2883 DECLARE_EVENT_CLASS(xrep_pptr_salvage_class,
2884 TP_PROTO(struct xfs_inode *ip, unsigned int flags, const void *name,
2885 unsigned int namelen, const void *value, unsigned int valuelen),
2886 TP_ARGS(ip, flags, name, namelen, value, valuelen),
2887 TP_STRUCT__entry(
2888 __field(dev_t, dev)
2889 __field(xfs_ino_t, ino)
2890 __field(xfs_ino_t, parent_ino)
2891 __field(unsigned int, parent_gen)
2892 __field(unsigned int, namelen)
2893 __dynamic_array(char, name, namelen)
2894 ),
2895 TP_fast_assign(
2896 const struct xfs_parent_rec *rec = value;
2897
2898 __entry->dev = ip->i_mount->m_super->s_dev;
2899 __entry->ino = ip->i_ino;
2900 __entry->parent_ino = be64_to_cpu(rec->p_ino);
2901 __entry->parent_gen = be32_to_cpu(rec->p_gen);
2902 __entry->namelen = namelen;
2903 memcpy(__get_str(name), name, namelen);
2904 ),
2905 TP_printk("dev %d:%d ino 0x%llx parent_ino 0x%llx parent_gen 0x%x name '%.*s'",
2906 MAJOR(__entry->dev), MINOR(__entry->dev),
2907 __entry->ino,
2908 __entry->parent_ino,
2909 __entry->parent_gen,
2910 __entry->namelen,
2911 __get_str(name))
2912 )
2913 #define DEFINE_XREP_PPTR_SALVAGE_EVENT(name) \
2914 DEFINE_EVENT(xrep_pptr_salvage_class, name, \
2915 TP_PROTO(struct xfs_inode *ip, unsigned int flags, const void *name, \
2916 unsigned int namelen, const void *value, unsigned int valuelen), \
2917 TP_ARGS(ip, flags, name, namelen, value, valuelen))
2918 DEFINE_XREP_PPTR_SALVAGE_EVENT(xrep_xattr_salvage_pptr);
2919 DEFINE_XREP_PPTR_SALVAGE_EVENT(xrep_xattr_insert_pptr);
2920
2921 TRACE_EVENT(xrep_xattr_class,
2922 TP_PROTO(struct xfs_inode *ip, struct xfs_inode *arg_ip),
2923 TP_ARGS(ip, arg_ip),
2924 TP_STRUCT__entry(
2925 __field(dev_t, dev)
2926 __field(xfs_ino_t, ino)
2927 __field(xfs_ino_t, src_ino)
2928 ),
2929 TP_fast_assign(
2930 __entry->dev = ip->i_mount->m_super->s_dev;
2931 __entry->ino = ip->i_ino;
2932 __entry->src_ino = arg_ip->i_ino;
2933 ),
2934 TP_printk("dev %d:%d ino 0x%llx src 0x%llx",
2935 MAJOR(__entry->dev), MINOR(__entry->dev),
2936 __entry->ino,
2937 __entry->src_ino)
2938 )
2939 #define DEFINE_XREP_XATTR_EVENT(name) \
2940 DEFINE_EVENT(xrep_xattr_class, name, \
2941 TP_PROTO(struct xfs_inode *ip, struct xfs_inode *arg_ip), \
2942 TP_ARGS(ip, arg_ip))
2943 DEFINE_XREP_XATTR_EVENT(xrep_xattr_rebuild_tree);
2944 DEFINE_XREP_XATTR_EVENT(xrep_xattr_reset_fork);
2945 DEFINE_XREP_XATTR_EVENT(xrep_xattr_full_reset);
2946
2947 DECLARE_EVENT_CLASS(xrep_xattr_pptr_scan_class,
2948 TP_PROTO(struct xfs_inode *ip, const struct xfs_inode *dp,
2949 const struct xfs_name *name),
2950 TP_ARGS(ip, dp, name),
2951 TP_STRUCT__entry(
2952 __field(dev_t, dev)
2953 __field(xfs_ino_t, ino)
2954 __field(xfs_ino_t, parent_ino)
2955 __field(unsigned int, parent_gen)
2956 __field(unsigned int, namelen)
2957 __dynamic_array(char, name, name->len)
2958 ),
2959 TP_fast_assign(
2960 __entry->dev = ip->i_mount->m_super->s_dev;
2961 __entry->ino = ip->i_ino;
2962 __entry->parent_ino = dp->i_ino;
2963 __entry->parent_gen = VFS_IC(dp)->i_generation;
2964 __entry->namelen = name->len;
2965 memcpy(__get_str(name), name->name, name->len);
2966 ),
2967 TP_printk("dev %d:%d ino 0x%llx parent_ino 0x%llx parent_gen 0x%x name '%.*s'",
2968 MAJOR(__entry->dev), MINOR(__entry->dev),
2969 __entry->ino,
2970 __entry->parent_ino,
2971 __entry->parent_gen,
2972 __entry->namelen,
2973 __get_str(name))
2974 )
2975 #define DEFINE_XREP_XATTR_PPTR_SCAN_EVENT(name) \
2976 DEFINE_EVENT(xrep_xattr_pptr_scan_class, name, \
2977 TP_PROTO(struct xfs_inode *ip, const struct xfs_inode *dp, \
2978 const struct xfs_name *name), \
2979 TP_ARGS(ip, dp, name))
2980 DEFINE_XREP_XATTR_PPTR_SCAN_EVENT(xrep_xattr_stash_parentadd);
2981 DEFINE_XREP_XATTR_PPTR_SCAN_EVENT(xrep_xattr_stash_parentremove);
2982
2983 TRACE_EVENT(xrep_dir_recover_dirblock,
2984 TP_PROTO(struct xfs_inode *dp, xfs_dablk_t dabno, uint32_t magic,
2985 uint32_t magic_guess),
2986 TP_ARGS(dp, dabno, magic, magic_guess),
2987 TP_STRUCT__entry(
2988 __field(dev_t, dev)
2989 __field(xfs_ino_t, dir_ino)
2990 __field(xfs_dablk_t, dabno)
2991 __field(uint32_t, magic)
2992 __field(uint32_t, magic_guess)
2993 ),
2994 TP_fast_assign(
2995 __entry->dev = dp->i_mount->m_super->s_dev;
2996 __entry->dir_ino = dp->i_ino;
2997 __entry->dabno = dabno;
2998 __entry->magic = magic;
2999 __entry->magic_guess = magic_guess;
3000 ),
3001 TP_printk("dev %d:%d dir 0x%llx dablk 0x%x magic 0x%x magic_guess 0x%x",
3002 MAJOR(__entry->dev), MINOR(__entry->dev),
3003 __entry->dir_ino,
3004 __entry->dabno,
3005 __entry->magic,
3006 __entry->magic_guess)
3007 );
3008
3009 DECLARE_EVENT_CLASS(xrep_dir_class,
3010 TP_PROTO(struct xfs_inode *dp, xfs_ino_t parent_ino),
3011 TP_ARGS(dp, parent_ino),
3012 TP_STRUCT__entry(
3013 __field(dev_t, dev)
3014 __field(xfs_ino_t, dir_ino)
3015 __field(xfs_ino_t, parent_ino)
3016 ),
3017 TP_fast_assign(
3018 __entry->dev = dp->i_mount->m_super->s_dev;
3019 __entry->dir_ino = dp->i_ino;
3020 __entry->parent_ino = parent_ino;
3021 ),
3022 TP_printk("dev %d:%d dir 0x%llx parent 0x%llx",
3023 MAJOR(__entry->dev), MINOR(__entry->dev),
3024 __entry->dir_ino,
3025 __entry->parent_ino)
3026 )
3027 #define DEFINE_XREP_DIR_EVENT(name) \
3028 DEFINE_EVENT(xrep_dir_class, name, \
3029 TP_PROTO(struct xfs_inode *dp, xfs_ino_t parent_ino), \
3030 TP_ARGS(dp, parent_ino))
3031 DEFINE_XREP_DIR_EVENT(xrep_dir_rebuild_tree);
3032 DEFINE_XREP_DIR_EVENT(xrep_dir_reset_fork);
3033 DEFINE_XREP_DIR_EVENT(xrep_parent_reset_dotdot);
3034
3035 DECLARE_EVENT_CLASS(xrep_dirent_class,
3036 TP_PROTO(struct xfs_inode *dp, const struct xfs_name *name,
3037 xfs_ino_t ino),
3038 TP_ARGS(dp, name, ino),
3039 TP_STRUCT__entry(
3040 __field(dev_t, dev)
3041 __field(xfs_ino_t, dir_ino)
3042 __field(unsigned int, namelen)
3043 __dynamic_array(char, name, name->len)
3044 __field(xfs_ino_t, ino)
3045 __field(uint8_t, ftype)
3046 ),
3047 TP_fast_assign(
3048 __entry->dev = dp->i_mount->m_super->s_dev;
3049 __entry->dir_ino = dp->i_ino;
3050 __entry->namelen = name->len;
3051 memcpy(__get_str(name), name->name, name->len);
3052 __entry->ino = ino;
3053 __entry->ftype = name->type;
3054 ),
3055 TP_printk("dev %d:%d dir 0x%llx ftype %s name '%.*s' ino 0x%llx",
3056 MAJOR(__entry->dev), MINOR(__entry->dev),
3057 __entry->dir_ino,
3058 __print_symbolic(__entry->ftype, XFS_DIR3_FTYPE_STR),
3059 __entry->namelen,
3060 __get_str(name),
3061 __entry->ino)
3062 )
3063 #define DEFINE_XREP_DIRENT_EVENT(name) \
3064 DEFINE_EVENT(xrep_dirent_class, name, \
3065 TP_PROTO(struct xfs_inode *dp, const struct xfs_name *name, \
3066 xfs_ino_t ino), \
3067 TP_ARGS(dp, name, ino))
3068 DEFINE_XREP_DIRENT_EVENT(xrep_dir_salvage_entry);
3069 DEFINE_XREP_DIRENT_EVENT(xrep_dir_stash_createname);
3070 DEFINE_XREP_DIRENT_EVENT(xrep_dir_replay_createname);
3071 DEFINE_XREP_DIRENT_EVENT(xrep_adoption_reparent);
3072 DEFINE_XREP_DIRENT_EVENT(xrep_dir_stash_removename);
3073 DEFINE_XREP_DIRENT_EVENT(xrep_dir_replay_removename);
3074
3075 DECLARE_EVENT_CLASS(xrep_adoption_class,
3076 TP_PROTO(struct xfs_inode *dp, struct xfs_inode *ip, bool moved),
3077 TP_ARGS(dp, ip, moved),
3078 TP_STRUCT__entry(
3079 __field(dev_t, dev)
3080 __field(xfs_ino_t, dir_ino)
3081 __field(xfs_ino_t, child_ino)
3082 __field(bool, moved)
3083 ),
3084 TP_fast_assign(
3085 __entry->dev = dp->i_mount->m_super->s_dev;
3086 __entry->dir_ino = dp->i_ino;
3087 __entry->child_ino = ip->i_ino;
3088 __entry->moved = moved;
3089 ),
3090 TP_printk("dev %d:%d dir 0x%llx child 0x%llx moved? %d",
3091 MAJOR(__entry->dev), MINOR(__entry->dev),
3092 __entry->dir_ino,
3093 __entry->child_ino,
3094 __entry->moved)
3095 );
3096 #define DEFINE_XREP_ADOPTION_EVENT(name) \
3097 DEFINE_EVENT(xrep_adoption_class, name, \
3098 TP_PROTO(struct xfs_inode *dp, struct xfs_inode *ip, bool moved), \
3099 TP_ARGS(dp, ip, moved))
3100 DEFINE_XREP_ADOPTION_EVENT(xrep_adoption_trans_roll);
3101
3102 DECLARE_EVENT_CLASS(xrep_parent_salvage_class,
3103 TP_PROTO(struct xfs_inode *dp, xfs_ino_t ino),
3104 TP_ARGS(dp, ino),
3105 TP_STRUCT__entry(
3106 __field(dev_t, dev)
3107 __field(xfs_ino_t, dir_ino)
3108 __field(xfs_ino_t, ino)
3109 ),
3110 TP_fast_assign(
3111 __entry->dev = dp->i_mount->m_super->s_dev;
3112 __entry->dir_ino = dp->i_ino;
3113 __entry->ino = ino;
3114 ),
3115 TP_printk("dev %d:%d dir 0x%llx parent 0x%llx",
3116 MAJOR(__entry->dev), MINOR(__entry->dev),
3117 __entry->dir_ino,
3118 __entry->ino)
3119 )
3120 #define DEFINE_XREP_PARENT_SALVAGE_EVENT(name) \
3121 DEFINE_EVENT(xrep_parent_salvage_class, name, \
3122 TP_PROTO(struct xfs_inode *dp, xfs_ino_t ino), \
3123 TP_ARGS(dp, ino))
3124 DEFINE_XREP_PARENT_SALVAGE_EVENT(xrep_dir_salvaged_parent);
3125 DEFINE_XREP_PARENT_SALVAGE_EVENT(xrep_findparent_dirent);
3126 DEFINE_XREP_PARENT_SALVAGE_EVENT(xrep_findparent_from_dcache);
3127
3128 DECLARE_EVENT_CLASS(xrep_pptr_class,
3129 TP_PROTO(struct xfs_inode *ip, const struct xfs_name *name,
3130 const struct xfs_parent_rec *pptr),
3131 TP_ARGS(ip, name, pptr),
3132 TP_STRUCT__entry(
3133 __field(dev_t, dev)
3134 __field(xfs_ino_t, ino)
3135 __field(xfs_ino_t, parent_ino)
3136 __field(unsigned int, parent_gen)
3137 __field(unsigned int, namelen)
3138 __dynamic_array(char, name, name->len)
3139 ),
3140 TP_fast_assign(
3141 __entry->dev = ip->i_mount->m_super->s_dev;
3142 __entry->ino = ip->i_ino;
3143 __entry->parent_ino = be64_to_cpu(pptr->p_ino);
3144 __entry->parent_gen = be32_to_cpu(pptr->p_gen);
3145 __entry->namelen = name->len;
3146 memcpy(__get_str(name), name->name, name->len);
3147 ),
3148 TP_printk("dev %d:%d ino 0x%llx parent_ino 0x%llx parent_gen 0x%x name '%.*s'",
3149 MAJOR(__entry->dev), MINOR(__entry->dev),
3150 __entry->ino,
3151 __entry->parent_ino,
3152 __entry->parent_gen,
3153 __entry->namelen,
3154 __get_str(name))
3155 )
3156 #define DEFINE_XREP_PPTR_EVENT(name) \
3157 DEFINE_EVENT(xrep_pptr_class, name, \
3158 TP_PROTO(struct xfs_inode *ip, const struct xfs_name *name, \
3159 const struct xfs_parent_rec *pptr), \
3160 TP_ARGS(ip, name, pptr))
3161 DEFINE_XREP_PPTR_EVENT(xrep_xattr_replay_parentadd);
3162 DEFINE_XREP_PPTR_EVENT(xrep_xattr_replay_parentremove);
3163 DEFINE_XREP_PPTR_EVENT(xrep_parent_replay_parentadd);
3164 DEFINE_XREP_PPTR_EVENT(xrep_parent_replay_parentremove);
3165
3166 DECLARE_EVENT_CLASS(xrep_pptr_scan_class,
3167 TP_PROTO(struct xfs_inode *ip, const struct xfs_inode *dp,
3168 const struct xfs_name *name),
3169 TP_ARGS(ip, dp, name),
3170 TP_STRUCT__entry(
3171 __field(dev_t, dev)
3172 __field(xfs_ino_t, ino)
3173 __field(xfs_ino_t, parent_ino)
3174 __field(unsigned int, parent_gen)
3175 __field(unsigned int, namelen)
3176 __dynamic_array(char, name, name->len)
3177 ),
3178 TP_fast_assign(
3179 __entry->dev = ip->i_mount->m_super->s_dev;
3180 __entry->ino = ip->i_ino;
3181 __entry->parent_ino = dp->i_ino;
3182 __entry->parent_gen = VFS_IC(dp)->i_generation;
3183 __entry->namelen = name->len;
3184 memcpy(__get_str(name), name->name, name->len);
3185 ),
3186 TP_printk("dev %d:%d ino 0x%llx parent_ino 0x%llx parent_gen 0x%x name '%.*s'",
3187 MAJOR(__entry->dev), MINOR(__entry->dev),
3188 __entry->ino,
3189 __entry->parent_ino,
3190 __entry->parent_gen,
3191 __entry->namelen,
3192 __get_str(name))
3193 )
3194 #define DEFINE_XREP_PPTR_SCAN_EVENT(name) \
3195 DEFINE_EVENT(xrep_pptr_scan_class, name, \
3196 TP_PROTO(struct xfs_inode *ip, const struct xfs_inode *dp, \
3197 const struct xfs_name *name), \
3198 TP_ARGS(ip, dp, name))
3199 DEFINE_XREP_PPTR_SCAN_EVENT(xrep_parent_stash_parentadd);
3200 DEFINE_XREP_PPTR_SCAN_EVENT(xrep_parent_stash_parentremove);
3201
3202 TRACE_EVENT(xrep_nlinks_set_record,
3203 TP_PROTO(struct xfs_mount *mp, xfs_ino_t ino,
3204 const struct xchk_nlink *obs),
3205 TP_ARGS(mp, ino, obs),
3206 TP_STRUCT__entry(
3207 __field(dev_t, dev)
3208 __field(xfs_ino_t, ino)
3209 __field(xfs_nlink_t, parents)
3210 __field(xfs_nlink_t, backrefs)
3211 __field(xfs_nlink_t, children)
3212 ),
3213 TP_fast_assign(
3214 __entry->dev = mp->m_super->s_dev;
3215 __entry->ino = ino;
3216 __entry->parents = obs->parents;
3217 __entry->backrefs = obs->backrefs;
3218 __entry->children = obs->children;
3219 ),
3220 TP_printk("dev %d:%d ino 0x%llx parents %u backrefs %u children %u",
3221 MAJOR(__entry->dev), MINOR(__entry->dev),
3222 __entry->ino,
3223 __entry->parents,
3224 __entry->backrefs,
3225 __entry->children)
3226 );
3227
3228 DECLARE_EVENT_CLASS(xrep_dentry_class,
3229 TP_PROTO(struct xfs_mount *mp, const struct dentry *dentry),
3230 TP_ARGS(mp, dentry),
3231 TP_STRUCT__entry(
3232 __field(dev_t, dev)
3233 __field(unsigned int, flags)
3234 __field(unsigned long, ino)
3235 __field(bool, positive)
3236 __field(unsigned long, parent_ino)
3237 __field(unsigned int, namelen)
3238 __dynamic_array(char, name, dentry->d_name.len)
3239 ),
3240 TP_fast_assign(
3241 __entry->dev = mp->m_super->s_dev;
3242 __entry->flags = dentry->d_flags;
3243 __entry->positive = d_is_positive(dentry);
3244 if (dentry->d_parent && d_inode(dentry->d_parent))
3245 __entry->parent_ino = d_inode(dentry->d_parent)->i_ino;
3246 else
3247 __entry->parent_ino = -1UL;
3248 __entry->ino = d_inode(dentry) ? d_inode(dentry)->i_ino : 0;
3249 __entry->namelen = dentry->d_name.len;
3250 memcpy(__get_str(name), dentry->d_name.name, dentry->d_name.len);
3251 ),
3252 TP_printk("dev %d:%d flags 0x%x positive? %d parent_ino 0x%lx ino 0x%lx name '%.*s'",
3253 MAJOR(__entry->dev), MINOR(__entry->dev),
3254 __entry->flags,
3255 __entry->positive,
3256 __entry->parent_ino,
3257 __entry->ino,
3258 __entry->namelen,
3259 __get_str(name))
3260 );
3261 #define DEFINE_REPAIR_DENTRY_EVENT(name) \
3262 DEFINE_EVENT(xrep_dentry_class, name, \
3263 TP_PROTO(struct xfs_mount *mp, const struct dentry *dentry), \
3264 TP_ARGS(mp, dentry))
3265 DEFINE_REPAIR_DENTRY_EVENT(xrep_adoption_check_child);
3266 DEFINE_REPAIR_DENTRY_EVENT(xrep_adoption_invalidate_child);
3267 DEFINE_REPAIR_DENTRY_EVENT(xrep_dirtree_delete_child);
3268
3269 TRACE_EVENT(xrep_symlink_salvage_target,
3270 TP_PROTO(struct xfs_inode *ip, char *target, unsigned int targetlen),
3271 TP_ARGS(ip, target, targetlen),
3272 TP_STRUCT__entry(
3273 __field(dev_t, dev)
3274 __field(xfs_ino_t, ino)
3275 __field(unsigned int, targetlen)
3276 __dynamic_array(char, target, targetlen + 1)
3277 ),
3278 TP_fast_assign(
3279 __entry->dev = ip->i_mount->m_super->s_dev;
3280 __entry->ino = ip->i_ino;
3281 __entry->targetlen = targetlen;
3282 memcpy(__get_str(target), target, targetlen);
3283 __get_str(target)[targetlen] = 0;
3284 ),
3285 TP_printk("dev %d:%d ip 0x%llx target '%.*s'",
3286 MAJOR(__entry->dev), MINOR(__entry->dev),
3287 __entry->ino,
3288 __entry->targetlen,
3289 __get_str(target))
3290 );
3291
3292 DECLARE_EVENT_CLASS(xrep_symlink_class,
3293 TP_PROTO(struct xfs_inode *ip),
3294 TP_ARGS(ip),
3295 TP_STRUCT__entry(
3296 __field(dev_t, dev)
3297 __field(xfs_ino_t, ino)
3298 ),
3299 TP_fast_assign(
3300 __entry->dev = ip->i_mount->m_super->s_dev;
3301 __entry->ino = ip->i_ino;
3302 ),
3303 TP_printk("dev %d:%d ip 0x%llx",
3304 MAJOR(__entry->dev), MINOR(__entry->dev),
3305 __entry->ino)
3306 );
3307
3308 #define DEFINE_XREP_SYMLINK_EVENT(name) \
3309 DEFINE_EVENT(xrep_symlink_class, name, \
3310 TP_PROTO(struct xfs_inode *ip), \
3311 TP_ARGS(ip))
3312 DEFINE_XREP_SYMLINK_EVENT(xrep_symlink_rebuild);
3313 DEFINE_XREP_SYMLINK_EVENT(xrep_symlink_reset_fork);
3314
3315 TRACE_EVENT(xrep_iunlink_visit,
3316 TP_PROTO(struct xfs_perag *pag, unsigned int bucket,
3317 xfs_agino_t bucket_agino, struct xfs_inode *ip),
3318 TP_ARGS(pag, bucket, bucket_agino, ip),
3319 TP_STRUCT__entry(
3320 __field(dev_t, dev)
3321 __field(xfs_agnumber_t, agno)
3322 __field(xfs_agino_t, agino)
3323 __field(unsigned int, bucket)
3324 __field(xfs_agino_t, bucket_agino)
3325 __field(xfs_agino_t, prev_agino)
3326 __field(xfs_agino_t, next_agino)
3327 ),
3328 TP_fast_assign(
3329 __entry->dev = pag->pag_mount->m_super->s_dev;
3330 __entry->agno = pag->pag_agno;
3331 __entry->agino = XFS_INO_TO_AGINO(pag->pag_mount, ip->i_ino);
3332 __entry->bucket = bucket;
3333 __entry->bucket_agino = bucket_agino;
3334 __entry->prev_agino = ip->i_prev_unlinked;
3335 __entry->next_agino = ip->i_next_unlinked;
3336 ),
3337 TP_printk("dev %d:%d agno 0x%x bucket %u agino 0x%x bucket_agino 0x%x prev_agino 0x%x next_agino 0x%x",
3338 MAJOR(__entry->dev), MINOR(__entry->dev),
3339 __entry->agno,
3340 __entry->bucket,
3341 __entry->agino,
3342 __entry->bucket_agino,
3343 __entry->prev_agino,
3344 __entry->next_agino)
3345 );
3346
3347 TRACE_EVENT(xrep_iunlink_reload_next,
3348 TP_PROTO(struct xfs_inode *ip, xfs_agino_t prev_agino),
3349 TP_ARGS(ip, prev_agino),
3350 TP_STRUCT__entry(
3351 __field(dev_t, dev)
3352 __field(xfs_agnumber_t, agno)
3353 __field(xfs_agino_t, agino)
3354 __field(xfs_agino_t, old_prev_agino)
3355 __field(xfs_agino_t, prev_agino)
3356 __field(xfs_agino_t, next_agino)
3357 __field(unsigned int, nlink)
3358 ),
3359 TP_fast_assign(
3360 __entry->dev = ip->i_mount->m_super->s_dev;
3361 __entry->agno = XFS_INO_TO_AGNO(ip->i_mount, ip->i_ino);
3362 __entry->agino = XFS_INO_TO_AGINO(ip->i_mount, ip->i_ino);
3363 __entry->old_prev_agino = ip->i_prev_unlinked;
3364 __entry->prev_agino = prev_agino;
3365 __entry->next_agino = ip->i_next_unlinked;
3366 __entry->nlink = VFS_I(ip)->i_nlink;
3367 ),
3368 TP_printk("dev %d:%d agno 0x%x bucket %u agino 0x%x nlink %u old_prev_agino %u prev_agino 0x%x next_agino 0x%x",
3369 MAJOR(__entry->dev), MINOR(__entry->dev),
3370 __entry->agno,
3371 __entry->agino % XFS_AGI_UNLINKED_BUCKETS,
3372 __entry->agino,
3373 __entry->nlink,
3374 __entry->old_prev_agino,
3375 __entry->prev_agino,
3376 __entry->next_agino)
3377 );
3378
3379 TRACE_EVENT(xrep_iunlink_reload_ondisk,
3380 TP_PROTO(struct xfs_inode *ip),
3381 TP_ARGS(ip),
3382 TP_STRUCT__entry(
3383 __field(dev_t, dev)
3384 __field(xfs_agnumber_t, agno)
3385 __field(xfs_agino_t, agino)
3386 __field(unsigned int, nlink)
3387 __field(xfs_agino_t, next_agino)
3388 ),
3389 TP_fast_assign(
3390 __entry->dev = ip->i_mount->m_super->s_dev;
3391 __entry->agno = XFS_INO_TO_AGNO(ip->i_mount, ip->i_ino);
3392 __entry->agino = XFS_INO_TO_AGINO(ip->i_mount, ip->i_ino);
3393 __entry->nlink = VFS_I(ip)->i_nlink;
3394 __entry->next_agino = ip->i_next_unlinked;
3395 ),
3396 TP_printk("dev %d:%d agno 0x%x bucket %u agino 0x%x nlink %u next_agino 0x%x",
3397 MAJOR(__entry->dev), MINOR(__entry->dev),
3398 __entry->agno,
3399 __entry->agino % XFS_AGI_UNLINKED_BUCKETS,
3400 __entry->agino,
3401 __entry->nlink,
3402 __entry->next_agino)
3403 );
3404
3405 TRACE_EVENT(xrep_iunlink_walk_ondisk_bucket,
3406 TP_PROTO(struct xfs_perag *pag, unsigned int bucket,
3407 xfs_agino_t prev_agino, xfs_agino_t next_agino),
3408 TP_ARGS(pag, bucket, prev_agino, next_agino),
3409 TP_STRUCT__entry(
3410 __field(dev_t, dev)
3411 __field(xfs_agnumber_t, agno)
3412 __field(unsigned int, bucket)
3413 __field(xfs_agino_t, prev_agino)
3414 __field(xfs_agino_t, next_agino)
3415 ),
3416 TP_fast_assign(
3417 __entry->dev = pag->pag_mount->m_super->s_dev;
3418 __entry->agno = pag->pag_agno;
3419 __entry->bucket = bucket;
3420 __entry->prev_agino = prev_agino;
3421 __entry->next_agino = next_agino;
3422 ),
3423 TP_printk("dev %d:%d agno 0x%x bucket %u prev_agino 0x%x next_agino 0x%x",
3424 MAJOR(__entry->dev), MINOR(__entry->dev),
3425 __entry->agno,
3426 __entry->bucket,
3427 __entry->prev_agino,
3428 __entry->next_agino)
3429 );
3430
3431 DECLARE_EVENT_CLASS(xrep_iunlink_resolve_class,
3432 TP_PROTO(struct xfs_perag *pag, unsigned int bucket,
3433 xfs_agino_t prev_agino, xfs_agino_t next_agino),
3434 TP_ARGS(pag, bucket, prev_agino, next_agino),
3435 TP_STRUCT__entry(
3436 __field(dev_t, dev)
3437 __field(xfs_agnumber_t, agno)
3438 __field(unsigned int, bucket)
3439 __field(xfs_agino_t, prev_agino)
3440 __field(xfs_agino_t, next_agino)
3441 ),
3442 TP_fast_assign(
3443 __entry->dev = pag->pag_mount->m_super->s_dev;
3444 __entry->agno = pag->pag_agno;
3445 __entry->bucket = bucket;
3446 __entry->prev_agino = prev_agino;
3447 __entry->next_agino = next_agino;
3448 ),
3449 TP_printk("dev %d:%d agno 0x%x bucket %u prev_agino 0x%x next_agino 0x%x",
3450 MAJOR(__entry->dev), MINOR(__entry->dev),
3451 __entry->agno,
3452 __entry->bucket,
3453 __entry->prev_agino,
3454 __entry->next_agino)
3455 );
3456 #define DEFINE_REPAIR_IUNLINK_RESOLVE_EVENT(name) \
3457 DEFINE_EVENT(xrep_iunlink_resolve_class, name, \
3458 TP_PROTO(struct xfs_perag *pag, unsigned int bucket, \
3459 xfs_agino_t prev_agino, xfs_agino_t next_agino), \
3460 TP_ARGS(pag, bucket, prev_agino, next_agino))
3461 DEFINE_REPAIR_IUNLINK_RESOLVE_EVENT(xrep_iunlink_resolve_uncached);
3462 DEFINE_REPAIR_IUNLINK_RESOLVE_EVENT(xrep_iunlink_resolve_wronglist);
3463 DEFINE_REPAIR_IUNLINK_RESOLVE_EVENT(xrep_iunlink_resolve_nolist);
3464 DEFINE_REPAIR_IUNLINK_RESOLVE_EVENT(xrep_iunlink_resolve_ok);
3465
3466 TRACE_EVENT(xrep_iunlink_relink_next,
3467 TP_PROTO(struct xfs_inode *ip, xfs_agino_t next_agino),
3468 TP_ARGS(ip, next_agino),
3469 TP_STRUCT__entry(
3470 __field(dev_t, dev)
3471 __field(xfs_agnumber_t, agno)
3472 __field(xfs_agino_t, agino)
3473 __field(xfs_agino_t, next_agino)
3474 __field(xfs_agino_t, new_next_agino)
3475 ),
3476 TP_fast_assign(
3477 __entry->dev = ip->i_mount->m_super->s_dev;
3478 __entry->agno = XFS_INO_TO_AGNO(ip->i_mount, ip->i_ino);
3479 __entry->agino = XFS_INO_TO_AGINO(ip->i_mount, ip->i_ino);
3480 __entry->next_agino = ip->i_next_unlinked;
3481 __entry->new_next_agino = next_agino;
3482 ),
3483 TP_printk("dev %d:%d agno 0x%x bucket %u agino 0x%x next_agino 0x%x -> 0x%x",
3484 MAJOR(__entry->dev), MINOR(__entry->dev),
3485 __entry->agno,
3486 __entry->agino % XFS_AGI_UNLINKED_BUCKETS,
3487 __entry->agino,
3488 __entry->next_agino,
3489 __entry->new_next_agino)
3490 );
3491
3492 TRACE_EVENT(xrep_iunlink_relink_prev,
3493 TP_PROTO(struct xfs_inode *ip, xfs_agino_t prev_agino),
3494 TP_ARGS(ip, prev_agino),
3495 TP_STRUCT__entry(
3496 __field(dev_t, dev)
3497 __field(xfs_agnumber_t, agno)
3498 __field(xfs_agino_t, agino)
3499 __field(xfs_agino_t, prev_agino)
3500 __field(xfs_agino_t, new_prev_agino)
3501 ),
3502 TP_fast_assign(
3503 __entry->dev = ip->i_mount->m_super->s_dev;
3504 __entry->agno = XFS_INO_TO_AGNO(ip->i_mount, ip->i_ino);
3505 __entry->agino = XFS_INO_TO_AGINO(ip->i_mount, ip->i_ino);
3506 __entry->prev_agino = ip->i_prev_unlinked;
3507 __entry->new_prev_agino = prev_agino;
3508 ),
3509 TP_printk("dev %d:%d agno 0x%x bucket %u agino 0x%x prev_agino 0x%x -> 0x%x",
3510 MAJOR(__entry->dev), MINOR(__entry->dev),
3511 __entry->agno,
3512 __entry->agino % XFS_AGI_UNLINKED_BUCKETS,
3513 __entry->agino,
3514 __entry->prev_agino,
3515 __entry->new_prev_agino)
3516 );
3517
3518 TRACE_EVENT(xrep_iunlink_add_to_bucket,
3519 TP_PROTO(struct xfs_perag *pag, unsigned int bucket,
3520 xfs_agino_t agino, xfs_agino_t curr_head),
3521 TP_ARGS(pag, bucket, agino, curr_head),
3522 TP_STRUCT__entry(
3523 __field(dev_t, dev)
3524 __field(xfs_agnumber_t, agno)
3525 __field(unsigned int, bucket)
3526 __field(xfs_agino_t, agino)
3527 __field(xfs_agino_t, next_agino)
3528 ),
3529 TP_fast_assign(
3530 __entry->dev = pag->pag_mount->m_super->s_dev;
3531 __entry->agno = pag->pag_agno;
3532 __entry->bucket = bucket;
3533 __entry->agino = agino;
3534 __entry->next_agino = curr_head;
3535 ),
3536 TP_printk("dev %d:%d agno 0x%x bucket %u agino 0x%x next_agino 0x%x",
3537 MAJOR(__entry->dev), MINOR(__entry->dev),
3538 __entry->agno,
3539 __entry->bucket,
3540 __entry->agino,
3541 __entry->next_agino)
3542 );
3543
3544 TRACE_EVENT(xrep_iunlink_commit_bucket,
3545 TP_PROTO(struct xfs_perag *pag, unsigned int bucket,
3546 xfs_agino_t old_agino, xfs_agino_t agino),
3547 TP_ARGS(pag, bucket, old_agino, agino),
3548 TP_STRUCT__entry(
3549 __field(dev_t, dev)
3550 __field(xfs_agnumber_t, agno)
3551 __field(unsigned int, bucket)
3552 __field(xfs_agino_t, old_agino)
3553 __field(xfs_agino_t, agino)
3554 ),
3555 TP_fast_assign(
3556 __entry->dev = pag->pag_mount->m_super->s_dev;
3557 __entry->agno = pag->pag_agno;
3558 __entry->bucket = bucket;
3559 __entry->old_agino = old_agino;
3560 __entry->agino = agino;
3561 ),
3562 TP_printk("dev %d:%d agno 0x%x bucket %u agino 0x%x -> 0x%x",
3563 MAJOR(__entry->dev), MINOR(__entry->dev),
3564 __entry->agno,
3565 __entry->bucket,
3566 __entry->old_agino,
3567 __entry->agino)
3568 );
3569
3570 DEFINE_XCHK_DIRPATH_OUTCOME_EVENT(xrep_dirpath_set_outcome);
3571 DEFINE_XCHK_DIRTREE_EVENT(xrep_dirtree_delete_path);
3572 DEFINE_XCHK_DIRTREE_EVENT(xrep_dirtree_create_adoption);
3573 DEFINE_XCHK_DIRTREE_EVALUATE_EVENT(xrep_dirtree_decided_fate);
3574
3575 #endif /* IS_ENABLED(CONFIG_XFS_ONLINE_REPAIR) */
3576
3577 #endif /* _TRACE_XFS_SCRUB_TRACE_H */
3578
3579 #undef TRACE_INCLUDE_PATH
3580 #define TRACE_INCLUDE_PATH .
3581 #define TRACE_INCLUDE_FILE scrub/trace
3582 #include <trace/define_trace.h>
3583
Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.