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 30 /* 31 * ftrace's __print_symbolic requires that all enum values be wrapped in the 32 * TRACE_DEFINE_ENUM macro so that the enum value can be encoded in the ftrace 33 * ring buffer. Somehow this was only worth mentioning in the ftrace sample 34 * code. 35 */ 36 TRACE_DEFINE_ENUM(XFS_REFC_DOMAIN_SHARED); 37 TRACE_DEFINE_ENUM(XFS_REFC_DOMAIN_COW); 38 39 TRACE_DEFINE_ENUM(XFS_SCRUB_TYPE_PROBE); 40 TRACE_DEFINE_ENUM(XFS_SCRUB_TYPE_SB); 41 TRACE_DEFINE_ENUM(XFS_SCRUB_TYPE_AGF); 42 TRACE_DEFINE_ENUM(XFS_SCRUB_TYPE_AGFL); 43 TRACE_DEFINE_ENUM(XFS_SCRUB_TYPE_AGI); 44 TRACE_DEFINE_ENUM(XFS_SCRUB_TYPE_BNOBT); 45 TRACE_DEFINE_ENUM(XFS_SCRUB_TYPE_CNTBT); 46 TRACE_DEFINE_ENUM(XFS_SCRUB_TYPE_INOBT); 47 TRACE_DEFINE_ENUM(XFS_SCRUB_TYPE_FINOBT); 48 TRACE_DEFINE_ENUM(XFS_SCRUB_TYPE_RMAPBT); 49 TRACE_DEFINE_ENUM(XFS_SCRUB_TYPE_REFCNTBT); 50 TRACE_DEFINE_ENUM(XFS_SCRUB_TYPE_INODE); 51 TRACE_DEFINE_ENUM(XFS_SCRUB_TYPE_BMBTD); 52 TRACE_DEFINE_ENUM(XFS_SCRUB_TYPE_BMBTA); 53 TRACE_DEFINE_ENUM(XFS_SCRUB_TYPE_BMBTC); 54 TRACE_DEFINE_ENUM(XFS_SCRUB_TYPE_DIR); 55 TRACE_DEFINE_ENUM(XFS_SCRUB_TYPE_XATTR); 56 TRACE_DEFINE_ENUM(XFS_SCRUB_TYPE_SYMLINK); 57 TRACE_DEFINE_ENUM(XFS_SCRUB_TYPE_PARENT); 58 TRACE_DEFINE_ENUM(XFS_SCRUB_TYPE_RTBITMAP); 59 TRACE_DEFINE_ENUM(XFS_SCRUB_TYPE_RTSUM); 60 TRACE_DEFINE_ENUM(XFS_SCRUB_TYPE_UQUOTA); 61 TRACE_DEFINE_ENUM(XFS_SCRUB_TYPE_GQUOTA); 62 TRACE_DEFINE_ENUM(XFS_SCRUB_TYPE_PQUOTA); 63 TRACE_DEFINE_ENUM(XFS_SCRUB_TYPE_FSCOUNTERS); 64 TRACE_DEFINE_ENUM(XFS_SCRUB_TYPE_QUOTACHECK); 65 TRACE_DEFINE_ENUM(XFS_SCRUB_TYPE_NLINKS); 66 TRACE_DEFINE_ENUM(XFS_SCRUB_TYPE_HEALTHY); 67 68 #define XFS_SCRUB_TYPE_STRINGS \ 69 { XFS_SCRUB_TYPE_PROBE, "probe" }, \ 70 { XFS_SCRUB_TYPE_SB, "sb" }, \ 71 { XFS_SCRUB_TYPE_AGF, "agf" }, \ 72 { XFS_SCRUB_TYPE_AGFL, "agfl" }, \ 73 { XFS_SCRUB_TYPE_AGI, "agi" }, \ 74 { XFS_SCRUB_TYPE_BNOBT, "bnobt" }, \ 75 { XFS_SCRUB_TYPE_CNTBT, "cntbt" }, \ 76 { XFS_SCRUB_TYPE_INOBT, "inobt" }, \ 77 { XFS_SCRUB_TYPE_FINOBT, "finobt" }, \ 78 { XFS_SCRUB_TYPE_RMAPBT, "rmapbt" }, \ 79 { XFS_SCRUB_TYPE_REFCNTBT, "refcountbt" }, \ 80 { XFS_SCRUB_TYPE_INODE, "inode" }, \ 81 { XFS_SCRUB_TYPE_BMBTD, "bmapbtd" }, \ 82 { XFS_SCRUB_TYPE_BMBTA, "bmapbta" }, \ 83 { XFS_SCRUB_TYPE_BMBTC, "bmapbtc" }, \ 84 { XFS_SCRUB_TYPE_DIR, "directory" }, \ 85 { XFS_SCRUB_TYPE_XATTR, "xattr" }, \ 86 { XFS_SCRUB_TYPE_SYMLINK, "symlink" }, \ 87 { XFS_SCRUB_TYPE_PARENT, "parent" }, \ 88 { XFS_SCRUB_TYPE_RTBITMAP, "rtbitmap" }, \ 89 { XFS_SCRUB_TYPE_RTSUM, "rtsummary" }, \ 90 { XFS_SCRUB_TYPE_UQUOTA, "usrquota" }, \ 91 { XFS_SCRUB_TYPE_GQUOTA, "grpquota" }, \ 92 { XFS_SCRUB_TYPE_PQUOTA, "prjquota" }, \ 93 { XFS_SCRUB_TYPE_FSCOUNTERS, "fscounters" }, \ 94 { XFS_SCRUB_TYPE_QUOTACHECK, "quotacheck" }, \ 95 { XFS_SCRUB_TYPE_NLINKS, "nlinks" }, \ 96 { XFS_SCRUB_TYPE_HEALTHY, "healthy" } 97 98 #define XFS_SCRUB_FLAG_STRINGS \ 99 { XFS_SCRUB_IFLAG_REPAIR, "repair" }, \ 100 { XFS_SCRUB_OFLAG_CORRUPT, "corrupt" }, \ 101 { XFS_SCRUB_OFLAG_PREEN, "preen" }, \ 102 { XFS_SCRUB_OFLAG_XFAIL, "xfail" }, \ 103 { XFS_SCRUB_OFLAG_XCORRUPT, "xcorrupt" }, \ 104 { XFS_SCRUB_OFLAG_INCOMPLETE, "incomplete" }, \ 105 { XFS_SCRUB_OFLAG_WARNING, "warning" }, \ 106 { XFS_SCRUB_OFLAG_NO_REPAIR_NEEDED, "norepair" }, \ 107 { XFS_SCRUB_IFLAG_FORCE_REBUILD, "rebuild" } 108 109 #define XFS_SCRUB_STATE_STRINGS \ 110 { XCHK_TRY_HARDER, "try_harder" }, \ 111 { XCHK_HAVE_FREEZE_PROT, "nofreeze" }, \ 112 { XCHK_FSGATES_DRAIN, "fsgates_drain" }, \ 113 { XCHK_NEED_DRAIN, "need_drain" }, \ 114 { XCHK_FSGATES_QUOTA, "fsgates_quota" }, \ 115 { XCHK_FSGATES_DIRENTS, "fsgates_dirents" }, \ 116 { XCHK_FSGATES_RMAP, "fsgates_rmap" }, \ 117 { XREP_FSGATES_EXCHANGE_RANGE, "fsgates_exchrange" }, \ 118 { XREP_RESET_PERAG_RESV, "reset_perag_resv" }, \ 119 { XREP_ALREADY_FIXED, "already_fixed" } 120 121 TRACE_DEFINE_ENUM(XFS_RMAP_MAP); 122 TRACE_DEFINE_ENUM(XFS_RMAP_MAP_SHARED); 123 TRACE_DEFINE_ENUM(XFS_RMAP_UNMAP); 124 TRACE_DEFINE_ENUM(XFS_RMAP_UNMAP_SHARED); 125 TRACE_DEFINE_ENUM(XFS_RMAP_CONVERT); 126 TRACE_DEFINE_ENUM(XFS_RMAP_CONVERT_SHARED); 127 TRACE_DEFINE_ENUM(XFS_RMAP_ALLOC); 128 TRACE_DEFINE_ENUM(XFS_RMAP_FREE); 129 130 DECLARE_EVENT_CLASS(xchk_class, 131 TP_PROTO(struct xfs_inode *ip, struct xfs_scrub_metadata *sm, 132 int error), 133 TP_ARGS(ip, sm, error), 134 TP_STRUCT__entry( 135 __field(dev_t, dev) 136 __field(xfs_ino_t, ino) 137 __field(unsigned int, type) 138 __field(xfs_agnumber_t, agno) 139 __field(xfs_ino_t, inum) 140 __field(unsigned int, gen) 141 __field(unsigned int, flags) 142 __field(int, error) 143 ), 144 TP_fast_assign( 145 __entry->dev = ip->i_mount->m_super->s_dev; 146 __entry->ino = ip->i_ino; 147 __entry->type = sm->sm_type; 148 __entry->agno = sm->sm_agno; 149 __entry->inum = sm->sm_ino; 150 __entry->gen = sm->sm_gen; 151 __entry->flags = sm->sm_flags; 152 __entry->error = error; 153 ), 154 TP_printk("dev %d:%d ino 0x%llx type %s agno 0x%x inum 0x%llx gen 0x%x flags (%s) error %d", 155 MAJOR(__entry->dev), MINOR(__entry->dev), 156 __entry->ino, 157 __print_symbolic(__entry->type, XFS_SCRUB_TYPE_STRINGS), 158 __entry->agno, 159 __entry->inum, 160 __entry->gen, 161 __print_flags(__entry->flags, "|", XFS_SCRUB_FLAG_STRINGS), 162 __entry->error) 163 ) 164 #define DEFINE_SCRUB_EVENT(name) \ 165 DEFINE_EVENT(xchk_class, name, \ 166 TP_PROTO(struct xfs_inode *ip, struct xfs_scrub_metadata *sm, \ 167 int error), \ 168 TP_ARGS(ip, sm, error)) 169 170 DEFINE_SCRUB_EVENT(xchk_start); 171 DEFINE_SCRUB_EVENT(xchk_done); 172 DEFINE_SCRUB_EVENT(xchk_deadlock_retry); 173 DEFINE_SCRUB_EVENT(xrep_attempt); 174 DEFINE_SCRUB_EVENT(xrep_done); 175 176 DECLARE_EVENT_CLASS(xchk_fsgate_class, 177 TP_PROTO(struct xfs_scrub *sc, unsigned int fsgate_flags), 178 TP_ARGS(sc, fsgate_flags), 179 TP_STRUCT__entry( 180 __field(dev_t, dev) 181 __field(unsigned int, type) 182 __field(unsigned int, fsgate_flags) 183 ), 184 TP_fast_assign( 185 __entry->dev = sc->mp->m_super->s_dev; 186 __entry->type = sc->sm->sm_type; 187 __entry->fsgate_flags = fsgate_flags; 188 ), 189 TP_printk("dev %d:%d type %s fsgates '%s'", 190 MAJOR(__entry->dev), MINOR(__entry->dev), 191 __print_symbolic(__entry->type, XFS_SCRUB_TYPE_STRINGS), 192 __print_flags(__entry->fsgate_flags, "|", XFS_SCRUB_STATE_STRINGS)) 193 ) 194 195 #define DEFINE_SCRUB_FSHOOK_EVENT(name) \ 196 DEFINE_EVENT(xchk_fsgate_class, name, \ 197 TP_PROTO(struct xfs_scrub *sc, unsigned int fsgates_flags), \ 198 TP_ARGS(sc, fsgates_flags)) 199 200 DEFINE_SCRUB_FSHOOK_EVENT(xchk_fsgates_enable); 201 DEFINE_SCRUB_FSHOOK_EVENT(xchk_fsgates_disable); 202 203 TRACE_EVENT(xchk_op_error, 204 TP_PROTO(struct xfs_scrub *sc, xfs_agnumber_t agno, 205 xfs_agblock_t bno, int error, void *ret_ip), 206 TP_ARGS(sc, agno, bno, error, ret_ip), 207 TP_STRUCT__entry( 208 __field(dev_t, dev) 209 __field(unsigned int, type) 210 __field(xfs_agnumber_t, agno) 211 __field(xfs_agblock_t, bno) 212 __field(int, error) 213 __field(void *, ret_ip) 214 ), 215 TP_fast_assign( 216 __entry->dev = sc->mp->m_super->s_dev; 217 __entry->type = sc->sm->sm_type; 218 __entry->agno = agno; 219 __entry->bno = bno; 220 __entry->error = error; 221 __entry->ret_ip = ret_ip; 222 ), 223 TP_printk("dev %d:%d type %s agno 0x%x agbno 0x%x error %d ret_ip %pS", 224 MAJOR(__entry->dev), MINOR(__entry->dev), 225 __print_symbolic(__entry->type, XFS_SCRUB_TYPE_STRINGS), 226 __entry->agno, 227 __entry->bno, 228 __entry->error, 229 __entry->ret_ip) 230 ); 231 232 TRACE_EVENT(xchk_file_op_error, 233 TP_PROTO(struct xfs_scrub *sc, int whichfork, 234 xfs_fileoff_t offset, int error, void *ret_ip), 235 TP_ARGS(sc, whichfork, offset, error, ret_ip), 236 TP_STRUCT__entry( 237 __field(dev_t, dev) 238 __field(xfs_ino_t, ino) 239 __field(int, whichfork) 240 __field(unsigned int, type) 241 __field(xfs_fileoff_t, offset) 242 __field(int, error) 243 __field(void *, ret_ip) 244 ), 245 TP_fast_assign( 246 __entry->dev = sc->ip->i_mount->m_super->s_dev; 247 __entry->ino = sc->ip->i_ino; 248 __entry->whichfork = whichfork; 249 __entry->type = sc->sm->sm_type; 250 __entry->offset = offset; 251 __entry->error = error; 252 __entry->ret_ip = ret_ip; 253 ), 254 TP_printk("dev %d:%d ino 0x%llx fork %s type %s fileoff 0x%llx error %d ret_ip %pS", 255 MAJOR(__entry->dev), MINOR(__entry->dev), 256 __entry->ino, 257 __print_symbolic(__entry->whichfork, XFS_WHICHFORK_STRINGS), 258 __print_symbolic(__entry->type, XFS_SCRUB_TYPE_STRINGS), 259 __entry->offset, 260 __entry->error, 261 __entry->ret_ip) 262 ); 263 264 DECLARE_EVENT_CLASS(xchk_block_error_class, 265 TP_PROTO(struct xfs_scrub *sc, xfs_daddr_t daddr, void *ret_ip), 266 TP_ARGS(sc, daddr, ret_ip), 267 TP_STRUCT__entry( 268 __field(dev_t, dev) 269 __field(unsigned int, type) 270 __field(xfs_agnumber_t, agno) 271 __field(xfs_agblock_t, agbno) 272 __field(void *, ret_ip) 273 ), 274 TP_fast_assign( 275 __entry->dev = sc->mp->m_super->s_dev; 276 __entry->type = sc->sm->sm_type; 277 __entry->agno = xfs_daddr_to_agno(sc->mp, daddr); 278 __entry->agbno = xfs_daddr_to_agbno(sc->mp, daddr); 279 __entry->ret_ip = ret_ip; 280 ), 281 TP_printk("dev %d:%d type %s agno 0x%x agbno 0x%x ret_ip %pS", 282 MAJOR(__entry->dev), MINOR(__entry->dev), 283 __print_symbolic(__entry->type, XFS_SCRUB_TYPE_STRINGS), 284 __entry->agno, 285 __entry->agbno, 286 __entry->ret_ip) 287 ) 288 289 #define DEFINE_SCRUB_BLOCK_ERROR_EVENT(name) \ 290 DEFINE_EVENT(xchk_block_error_class, name, \ 291 TP_PROTO(struct xfs_scrub *sc, xfs_daddr_t daddr, \ 292 void *ret_ip), \ 293 TP_ARGS(sc, daddr, ret_ip)) 294 295 DEFINE_SCRUB_BLOCK_ERROR_EVENT(xchk_fs_error); 296 DEFINE_SCRUB_BLOCK_ERROR_EVENT(xchk_block_error); 297 DEFINE_SCRUB_BLOCK_ERROR_EVENT(xchk_block_preen); 298 299 DECLARE_EVENT_CLASS(xchk_ino_error_class, 300 TP_PROTO(struct xfs_scrub *sc, xfs_ino_t ino, void *ret_ip), 301 TP_ARGS(sc, ino, ret_ip), 302 TP_STRUCT__entry( 303 __field(dev_t, dev) 304 __field(xfs_ino_t, ino) 305 __field(unsigned int, type) 306 __field(void *, ret_ip) 307 ), 308 TP_fast_assign( 309 __entry->dev = sc->mp->m_super->s_dev; 310 __entry->ino = ino; 311 __entry->type = sc->sm->sm_type; 312 __entry->ret_ip = ret_ip; 313 ), 314 TP_printk("dev %d:%d ino 0x%llx type %s ret_ip %pS", 315 MAJOR(__entry->dev), MINOR(__entry->dev), 316 __entry->ino, 317 __print_symbolic(__entry->type, XFS_SCRUB_TYPE_STRINGS), 318 __entry->ret_ip) 319 ) 320 321 #define DEFINE_SCRUB_INO_ERROR_EVENT(name) \ 322 DEFINE_EVENT(xchk_ino_error_class, name, \ 323 TP_PROTO(struct xfs_scrub *sc, xfs_ino_t ino, \ 324 void *ret_ip), \ 325 TP_ARGS(sc, ino, ret_ip)) 326 327 DEFINE_SCRUB_INO_ERROR_EVENT(xchk_ino_error); 328 DEFINE_SCRUB_INO_ERROR_EVENT(xchk_ino_preen); 329 DEFINE_SCRUB_INO_ERROR_EVENT(xchk_ino_warning); 330 331 DECLARE_EVENT_CLASS(xchk_fblock_error_class, 332 TP_PROTO(struct xfs_scrub *sc, int whichfork, 333 xfs_fileoff_t offset, void *ret_ip), 334 TP_ARGS(sc, whichfork, offset, ret_ip), 335 TP_STRUCT__entry( 336 __field(dev_t, dev) 337 __field(xfs_ino_t, ino) 338 __field(int, whichfork) 339 __field(unsigned int, type) 340 __field(xfs_fileoff_t, offset) 341 __field(void *, ret_ip) 342 ), 343 TP_fast_assign( 344 __entry->dev = sc->ip->i_mount->m_super->s_dev; 345 __entry->ino = sc->ip->i_ino; 346 __entry->whichfork = whichfork; 347 __entry->type = sc->sm->sm_type; 348 __entry->offset = offset; 349 __entry->ret_ip = ret_ip; 350 ), 351 TP_printk("dev %d:%d ino 0x%llx fork %s type %s fileoff 0x%llx ret_ip %pS", 352 MAJOR(__entry->dev), MINOR(__entry->dev), 353 __entry->ino, 354 __print_symbolic(__entry->whichfork, XFS_WHICHFORK_STRINGS), 355 __print_symbolic(__entry->type, XFS_SCRUB_TYPE_STRINGS), 356 __entry->offset, 357 __entry->ret_ip) 358 ); 359 360 #define DEFINE_SCRUB_FBLOCK_ERROR_EVENT(name) \ 361 DEFINE_EVENT(xchk_fblock_error_class, name, \ 362 TP_PROTO(struct xfs_scrub *sc, int whichfork, \ 363 xfs_fileoff_t offset, void *ret_ip), \ 364 TP_ARGS(sc, whichfork, offset, ret_ip)) 365 366 DEFINE_SCRUB_FBLOCK_ERROR_EVENT(xchk_fblock_error); 367 DEFINE_SCRUB_FBLOCK_ERROR_EVENT(xchk_fblock_warning); 368 DEFINE_SCRUB_FBLOCK_ERROR_EVENT(xchk_fblock_preen); 369 370 #ifdef CONFIG_XFS_QUOTA 371 DECLARE_EVENT_CLASS(xchk_dqiter_class, 372 TP_PROTO(struct xchk_dqiter *cursor, uint64_t id), 373 TP_ARGS(cursor, id), 374 TP_STRUCT__entry( 375 __field(dev_t, dev) 376 __field(xfs_dqtype_t, dqtype) 377 __field(xfs_ino_t, ino) 378 __field(unsigned long long, cur_id) 379 __field(unsigned long long, id) 380 __field(xfs_fileoff_t, startoff) 381 __field(xfs_fsblock_t, startblock) 382 __field(xfs_filblks_t, blockcount) 383 __field(xfs_exntst_t, state) 384 ), 385 TP_fast_assign( 386 __entry->dev = cursor->sc->ip->i_mount->m_super->s_dev; 387 __entry->dqtype = cursor->dqtype; 388 __entry->ino = cursor->quota_ip->i_ino; 389 __entry->cur_id = cursor->id; 390 __entry->startoff = cursor->bmap.br_startoff; 391 __entry->startblock = cursor->bmap.br_startblock; 392 __entry->blockcount = cursor->bmap.br_blockcount; 393 __entry->state = cursor->bmap.br_state; 394 __entry->id = id; 395 ), 396 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", 397 MAJOR(__entry->dev), MINOR(__entry->dev), 398 __print_symbolic(__entry->dqtype, XFS_DQTYPE_STRINGS), 399 __entry->ino, 400 __entry->cur_id, 401 __entry->startoff, 402 __entry->startblock, 403 __entry->blockcount, 404 __entry->state, 405 __entry->id) 406 ); 407 408 #define DEFINE_SCRUB_DQITER_EVENT(name) \ 409 DEFINE_EVENT(xchk_dqiter_class, name, \ 410 TP_PROTO(struct xchk_dqiter *cursor, uint64_t id), \ 411 TP_ARGS(cursor, id)) 412 DEFINE_SCRUB_DQITER_EVENT(xchk_dquot_iter_revalidate_bmap); 413 DEFINE_SCRUB_DQITER_EVENT(xchk_dquot_iter_advance_bmap); 414 DEFINE_SCRUB_DQITER_EVENT(xchk_dquot_iter_advance_incore); 415 DEFINE_SCRUB_DQITER_EVENT(xchk_dquot_iter); 416 417 TRACE_EVENT(xchk_qcheck_error, 418 TP_PROTO(struct xfs_scrub *sc, xfs_dqtype_t dqtype, xfs_dqid_t id, 419 void *ret_ip), 420 TP_ARGS(sc, dqtype, id, ret_ip), 421 TP_STRUCT__entry( 422 __field(dev_t, dev) 423 __field(xfs_dqtype_t, dqtype) 424 __field(xfs_dqid_t, id) 425 __field(void *, ret_ip) 426 ), 427 TP_fast_assign( 428 __entry->dev = sc->mp->m_super->s_dev; 429 __entry->dqtype = dqtype; 430 __entry->id = id; 431 __entry->ret_ip = ret_ip; 432 ), 433 TP_printk("dev %d:%d dquot type %s id 0x%x ret_ip %pS", 434 MAJOR(__entry->dev), MINOR(__entry->dev), 435 __print_symbolic(__entry->dqtype, XFS_DQTYPE_STRINGS), 436 __entry->id, 437 __entry->ret_ip) 438 ); 439 #endif /* CONFIG_XFS_QUOTA */ 440 441 TRACE_EVENT(xchk_incomplete, 442 TP_PROTO(struct xfs_scrub *sc, void *ret_ip), 443 TP_ARGS(sc, ret_ip), 444 TP_STRUCT__entry( 445 __field(dev_t, dev) 446 __field(unsigned int, type) 447 __field(void *, ret_ip) 448 ), 449 TP_fast_assign( 450 __entry->dev = sc->mp->m_super->s_dev; 451 __entry->type = sc->sm->sm_type; 452 __entry->ret_ip = ret_ip; 453 ), 454 TP_printk("dev %d:%d type %s ret_ip %pS", 455 MAJOR(__entry->dev), MINOR(__entry->dev), 456 __print_symbolic(__entry->type, XFS_SCRUB_TYPE_STRINGS), 457 __entry->ret_ip) 458 ); 459 460 TRACE_EVENT(xchk_btree_op_error, 461 TP_PROTO(struct xfs_scrub *sc, struct xfs_btree_cur *cur, 462 int level, int error, void *ret_ip), 463 TP_ARGS(sc, cur, level, error, ret_ip), 464 TP_STRUCT__entry( 465 __field(dev_t, dev) 466 __field(unsigned int, type) 467 __string(name, cur->bc_ops->name) 468 __field(int, level) 469 __field(xfs_agnumber_t, agno) 470 __field(xfs_agblock_t, bno) 471 __field(int, ptr) 472 __field(int, error) 473 __field(void *, ret_ip) 474 ), 475 TP_fast_assign( 476 xfs_fsblock_t fsbno = xchk_btree_cur_fsbno(cur, level); 477 478 __entry->dev = sc->mp->m_super->s_dev; 479 __entry->type = sc->sm->sm_type; 480 __assign_str(name, cur->bc_ops->name); 481 __entry->level = level; 482 __entry->agno = XFS_FSB_TO_AGNO(cur->bc_mp, fsbno); 483 __entry->bno = XFS_FSB_TO_AGBNO(cur->bc_mp, fsbno); 484 __entry->ptr = cur->bc_levels[level].ptr; 485 __entry->error = error; 486 __entry->ret_ip = ret_ip; 487 ), 488 TP_printk("dev %d:%d type %s %sbt level %d ptr %d agno 0x%x agbno 0x%x error %d ret_ip %pS", 489 MAJOR(__entry->dev), MINOR(__entry->dev), 490 __print_symbolic(__entry->type, XFS_SCRUB_TYPE_STRINGS), 491 __get_str(name), 492 __entry->level, 493 __entry->ptr, 494 __entry->agno, 495 __entry->bno, 496 __entry->error, 497 __entry->ret_ip) 498 ); 499 500 TRACE_EVENT(xchk_ifork_btree_op_error, 501 TP_PROTO(struct xfs_scrub *sc, struct xfs_btree_cur *cur, 502 int level, int error, void *ret_ip), 503 TP_ARGS(sc, cur, level, error, ret_ip), 504 TP_STRUCT__entry( 505 __field(dev_t, dev) 506 __field(xfs_ino_t, ino) 507 __field(int, whichfork) 508 __field(unsigned int, type) 509 __string(name, cur->bc_ops->name) 510 __field(int, level) 511 __field(int, ptr) 512 __field(xfs_agnumber_t, agno) 513 __field(xfs_agblock_t, bno) 514 __field(int, error) 515 __field(void *, ret_ip) 516 ), 517 TP_fast_assign( 518 xfs_fsblock_t fsbno = xchk_btree_cur_fsbno(cur, level); 519 __entry->dev = sc->mp->m_super->s_dev; 520 __entry->ino = sc->ip->i_ino; 521 __entry->whichfork = cur->bc_ino.whichfork; 522 __entry->type = sc->sm->sm_type; 523 __assign_str(name, cur->bc_ops->name); 524 __entry->level = level; 525 __entry->ptr = cur->bc_levels[level].ptr; 526 __entry->agno = XFS_FSB_TO_AGNO(cur->bc_mp, fsbno); 527 __entry->bno = XFS_FSB_TO_AGBNO(cur->bc_mp, fsbno); 528 __entry->error = error; 529 __entry->ret_ip = ret_ip; 530 ), 531 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", 532 MAJOR(__entry->dev), MINOR(__entry->dev), 533 __entry->ino, 534 __print_symbolic(__entry->whichfork, XFS_WHICHFORK_STRINGS), 535 __print_symbolic(__entry->type, XFS_SCRUB_TYPE_STRINGS), 536 __get_str(name), 537 __entry->level, 538 __entry->ptr, 539 __entry->agno, 540 __entry->bno, 541 __entry->error, 542 __entry->ret_ip) 543 ); 544 545 TRACE_EVENT(xchk_btree_error, 546 TP_PROTO(struct xfs_scrub *sc, struct xfs_btree_cur *cur, 547 int level, void *ret_ip), 548 TP_ARGS(sc, cur, level, ret_ip), 549 TP_STRUCT__entry( 550 __field(dev_t, dev) 551 __field(unsigned int, type) 552 __string(name, cur->bc_ops->name) 553 __field(int, level) 554 __field(xfs_agnumber_t, agno) 555 __field(xfs_agblock_t, bno) 556 __field(int, ptr) 557 __field(void *, ret_ip) 558 ), 559 TP_fast_assign( 560 xfs_fsblock_t fsbno = xchk_btree_cur_fsbno(cur, level); 561 __entry->dev = sc->mp->m_super->s_dev; 562 __entry->type = sc->sm->sm_type; 563 __assign_str(name, cur->bc_ops->name); 564 __entry->level = level; 565 __entry->agno = XFS_FSB_TO_AGNO(cur->bc_mp, fsbno); 566 __entry->bno = XFS_FSB_TO_AGBNO(cur->bc_mp, fsbno); 567 __entry->ptr = cur->bc_levels[level].ptr; 568 __entry->ret_ip = ret_ip; 569 ), 570 TP_printk("dev %d:%d type %s %sbt level %d ptr %d agno 0x%x agbno 0x%x ret_ip %pS", 571 MAJOR(__entry->dev), MINOR(__entry->dev), 572 __print_symbolic(__entry->type, XFS_SCRUB_TYPE_STRINGS), 573 __get_str(name), 574 __entry->level, 575 __entry->ptr, 576 __entry->agno, 577 __entry->bno, 578 __entry->ret_ip) 579 ); 580 581 TRACE_EVENT(xchk_ifork_btree_error, 582 TP_PROTO(struct xfs_scrub *sc, struct xfs_btree_cur *cur, 583 int level, void *ret_ip), 584 TP_ARGS(sc, cur, level, ret_ip), 585 TP_STRUCT__entry( 586 __field(dev_t, dev) 587 __field(xfs_ino_t, ino) 588 __field(int, whichfork) 589 __field(unsigned int, type) 590 __string(name, cur->bc_ops->name) 591 __field(int, level) 592 __field(xfs_agnumber_t, agno) 593 __field(xfs_agblock_t, bno) 594 __field(int, ptr) 595 __field(void *, ret_ip) 596 ), 597 TP_fast_assign( 598 xfs_fsblock_t fsbno = xchk_btree_cur_fsbno(cur, level); 599 __entry->dev = sc->mp->m_super->s_dev; 600 __entry->ino = sc->ip->i_ino; 601 __entry->whichfork = cur->bc_ino.whichfork; 602 __entry->type = sc->sm->sm_type; 603 __assign_str(name, cur->bc_ops->name); 604 __entry->level = level; 605 __entry->agno = XFS_FSB_TO_AGNO(cur->bc_mp, fsbno); 606 __entry->bno = XFS_FSB_TO_AGBNO(cur->bc_mp, fsbno); 607 __entry->ptr = cur->bc_levels[level].ptr; 608 __entry->ret_ip = ret_ip; 609 ), 610 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", 611 MAJOR(__entry->dev), MINOR(__entry->dev), 612 __entry->ino, 613 __print_symbolic(__entry->whichfork, XFS_WHICHFORK_STRINGS), 614 __print_symbolic(__entry->type, XFS_SCRUB_TYPE_STRINGS), 615 __get_str(name), 616 __entry->level, 617 __entry->ptr, 618 __entry->agno, 619 __entry->bno, 620 __entry->ret_ip) 621 ); 622 623 DECLARE_EVENT_CLASS(xchk_sbtree_class, 624 TP_PROTO(struct xfs_scrub *sc, struct xfs_btree_cur *cur, 625 int level), 626 TP_ARGS(sc, cur, level), 627 TP_STRUCT__entry( 628 __field(dev_t, dev) 629 __field(int, type) 630 __string(name, cur->bc_ops->name) 631 __field(xfs_agnumber_t, agno) 632 __field(xfs_agblock_t, bno) 633 __field(int, level) 634 __field(int, nlevels) 635 __field(int, ptr) 636 ), 637 TP_fast_assign( 638 xfs_fsblock_t fsbno = xchk_btree_cur_fsbno(cur, level); 639 640 __entry->dev = sc->mp->m_super->s_dev; 641 __entry->type = sc->sm->sm_type; 642 __assign_str(name, cur->bc_ops->name); 643 __entry->agno = XFS_FSB_TO_AGNO(cur->bc_mp, fsbno); 644 __entry->bno = XFS_FSB_TO_AGBNO(cur->bc_mp, fsbno); 645 __entry->level = level; 646 __entry->nlevels = cur->bc_nlevels; 647 __entry->ptr = cur->bc_levels[level].ptr; 648 ), 649 TP_printk("dev %d:%d type %s %sbt agno 0x%x agbno 0x%x level %d nlevels %d ptr %d", 650 MAJOR(__entry->dev), MINOR(__entry->dev), 651 __print_symbolic(__entry->type, XFS_SCRUB_TYPE_STRINGS), 652 __get_str(name), 653 __entry->agno, 654 __entry->bno, 655 __entry->level, 656 __entry->nlevels, 657 __entry->ptr) 658 ) 659 #define DEFINE_SCRUB_SBTREE_EVENT(name) \ 660 DEFINE_EVENT(xchk_sbtree_class, name, \ 661 TP_PROTO(struct xfs_scrub *sc, struct xfs_btree_cur *cur, \ 662 int level), \ 663 TP_ARGS(sc, cur, level)) 664 665 DEFINE_SCRUB_SBTREE_EVENT(xchk_btree_rec); 666 DEFINE_SCRUB_SBTREE_EVENT(xchk_btree_key); 667 668 TRACE_EVENT(xchk_xref_error, 669 TP_PROTO(struct xfs_scrub *sc, int error, void *ret_ip), 670 TP_ARGS(sc, error, ret_ip), 671 TP_STRUCT__entry( 672 __field(dev_t, dev) 673 __field(int, type) 674 __field(int, error) 675 __field(void *, ret_ip) 676 ), 677 TP_fast_assign( 678 __entry->dev = sc->mp->m_super->s_dev; 679 __entry->type = sc->sm->sm_type; 680 __entry->error = error; 681 __entry->ret_ip = ret_ip; 682 ), 683 TP_printk("dev %d:%d type %s xref error %d ret_ip %pS", 684 MAJOR(__entry->dev), MINOR(__entry->dev), 685 __print_symbolic(__entry->type, XFS_SCRUB_TYPE_STRINGS), 686 __entry->error, 687 __entry->ret_ip) 688 ); 689 690 TRACE_EVENT(xchk_iallocbt_check_cluster, 691 TP_PROTO(struct xfs_mount *mp, xfs_agnumber_t agno, 692 xfs_agino_t startino, xfs_daddr_t map_daddr, 693 unsigned short map_len, unsigned int chunk_ino, 694 unsigned int nr_inodes, uint16_t cluster_mask, 695 uint16_t holemask, unsigned int cluster_ino), 696 TP_ARGS(mp, agno, startino, map_daddr, map_len, chunk_ino, nr_inodes, 697 cluster_mask, holemask, cluster_ino), 698 TP_STRUCT__entry( 699 __field(dev_t, dev) 700 __field(xfs_agnumber_t, agno) 701 __field(xfs_agino_t, startino) 702 __field(xfs_daddr_t, map_daddr) 703 __field(unsigned short, map_len) 704 __field(unsigned int, chunk_ino) 705 __field(unsigned int, nr_inodes) 706 __field(unsigned int, cluster_ino) 707 __field(uint16_t, cluster_mask) 708 __field(uint16_t, holemask) 709 ), 710 TP_fast_assign( 711 __entry->dev = mp->m_super->s_dev; 712 __entry->agno = agno; 713 __entry->startino = startino; 714 __entry->map_daddr = map_daddr; 715 __entry->map_len = map_len; 716 __entry->chunk_ino = chunk_ino; 717 __entry->nr_inodes = nr_inodes; 718 __entry->cluster_mask = cluster_mask; 719 __entry->holemask = holemask; 720 __entry->cluster_ino = cluster_ino; 721 ), 722 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", 723 MAJOR(__entry->dev), MINOR(__entry->dev), 724 __entry->agno, 725 __entry->startino, 726 __entry->map_daddr, 727 __entry->map_len, 728 __entry->chunk_ino, 729 __entry->nr_inodes, 730 __entry->cluster_mask, 731 __entry->holemask, 732 __entry->cluster_ino) 733 ) 734 735 TRACE_EVENT(xchk_inode_is_allocated, 736 TP_PROTO(struct xfs_inode *ip), 737 TP_ARGS(ip), 738 TP_STRUCT__entry( 739 __field(dev_t, dev) 740 __field(xfs_ino_t, ino) 741 __field(unsigned long, iflags) 742 __field(umode_t, mode) 743 ), 744 TP_fast_assign( 745 __entry->dev = VFS_I(ip)->i_sb->s_dev; 746 __entry->ino = ip->i_ino; 747 __entry->iflags = ip->i_flags; 748 __entry->mode = VFS_I(ip)->i_mode; 749 ), 750 TP_printk("dev %d:%d ino 0x%llx iflags 0x%lx mode 0x%x", 751 MAJOR(__entry->dev), MINOR(__entry->dev), 752 __entry->ino, 753 __entry->iflags, 754 __entry->mode) 755 ); 756 757 TRACE_EVENT(xchk_fscounters_calc, 758 TP_PROTO(struct xfs_mount *mp, uint64_t icount, uint64_t ifree, 759 uint64_t fdblocks, uint64_t delalloc), 760 TP_ARGS(mp, icount, ifree, fdblocks, delalloc), 761 TP_STRUCT__entry( 762 __field(dev_t, dev) 763 __field(int64_t, icount_sb) 764 __field(uint64_t, icount_calculated) 765 __field(int64_t, ifree_sb) 766 __field(uint64_t, ifree_calculated) 767 __field(int64_t, fdblocks_sb) 768 __field(uint64_t, fdblocks_calculated) 769 __field(uint64_t, delalloc) 770 ), 771 TP_fast_assign( 772 __entry->dev = mp->m_super->s_dev; 773 __entry->icount_sb = mp->m_sb.sb_icount; 774 __entry->icount_calculated = icount; 775 __entry->ifree_sb = mp->m_sb.sb_ifree; 776 __entry->ifree_calculated = ifree; 777 __entry->fdblocks_sb = mp->m_sb.sb_fdblocks; 778 __entry->fdblocks_calculated = fdblocks; 779 __entry->delalloc = delalloc; 780 ), 781 TP_printk("dev %d:%d icount %lld:%llu ifree %lld::%llu fdblocks %lld::%llu delalloc %llu", 782 MAJOR(__entry->dev), MINOR(__entry->dev), 783 __entry->icount_sb, 784 __entry->icount_calculated, 785 __entry->ifree_sb, 786 __entry->ifree_calculated, 787 __entry->fdblocks_sb, 788 __entry->fdblocks_calculated, 789 __entry->delalloc) 790 ) 791 792 TRACE_EVENT(xchk_fscounters_within_range, 793 TP_PROTO(struct xfs_mount *mp, uint64_t expected, int64_t curr_value, 794 int64_t old_value), 795 TP_ARGS(mp, expected, curr_value, old_value), 796 TP_STRUCT__entry( 797 __field(dev_t, dev) 798 __field(uint64_t, expected) 799 __field(int64_t, curr_value) 800 __field(int64_t, old_value) 801 ), 802 TP_fast_assign( 803 __entry->dev = mp->m_super->s_dev; 804 __entry->expected = expected; 805 __entry->curr_value = curr_value; 806 __entry->old_value = old_value; 807 ), 808 TP_printk("dev %d:%d expected %llu curr_value %lld old_value %lld", 809 MAJOR(__entry->dev), MINOR(__entry->dev), 810 __entry->expected, 811 __entry->curr_value, 812 __entry->old_value) 813 ) 814 815 DECLARE_EVENT_CLASS(xchk_fsfreeze_class, 816 TP_PROTO(struct xfs_scrub *sc, int error), 817 TP_ARGS(sc, error), 818 TP_STRUCT__entry( 819 __field(dev_t, dev) 820 __field(unsigned int, type) 821 __field(int, error) 822 ), 823 TP_fast_assign( 824 __entry->dev = sc->mp->m_super->s_dev; 825 __entry->type = sc->sm->sm_type; 826 __entry->error = error; 827 ), 828 TP_printk("dev %d:%d type %s error %d", 829 MAJOR(__entry->dev), MINOR(__entry->dev), 830 __print_symbolic(__entry->type, XFS_SCRUB_TYPE_STRINGS), 831 __entry->error) 832 ); 833 #define DEFINE_XCHK_FSFREEZE_EVENT(name) \ 834 DEFINE_EVENT(xchk_fsfreeze_class, name, \ 835 TP_PROTO(struct xfs_scrub *sc, int error), \ 836 TP_ARGS(sc, error)) 837 DEFINE_XCHK_FSFREEZE_EVENT(xchk_fsfreeze); 838 DEFINE_XCHK_FSFREEZE_EVENT(xchk_fsthaw); 839 840 TRACE_EVENT(xchk_refcount_incorrect, 841 TP_PROTO(struct xfs_perag *pag, const struct xfs_refcount_irec *irec, 842 xfs_nlink_t seen), 843 TP_ARGS(pag, irec, seen), 844 TP_STRUCT__entry( 845 __field(dev_t, dev) 846 __field(xfs_agnumber_t, agno) 847 __field(enum xfs_refc_domain, domain) 848 __field(xfs_agblock_t, startblock) 849 __field(xfs_extlen_t, blockcount) 850 __field(xfs_nlink_t, refcount) 851 __field(xfs_nlink_t, seen) 852 ), 853 TP_fast_assign( 854 __entry->dev = pag->pag_mount->m_super->s_dev; 855 __entry->agno = pag->pag_agno; 856 __entry->domain = irec->rc_domain; 857 __entry->startblock = irec->rc_startblock; 858 __entry->blockcount = irec->rc_blockcount; 859 __entry->refcount = irec->rc_refcount; 860 __entry->seen = seen; 861 ), 862 TP_printk("dev %d:%d agno 0x%x dom %s agbno 0x%x fsbcount 0x%x refcount %u seen %u", 863 MAJOR(__entry->dev), MINOR(__entry->dev), 864 __entry->agno, 865 __print_symbolic(__entry->domain, XFS_REFC_DOMAIN_STRINGS), 866 __entry->startblock, 867 __entry->blockcount, 868 __entry->refcount, 869 __entry->seen) 870 ) 871 872 TRACE_EVENT(xfile_create, 873 TP_PROTO(struct xfile *xf), 874 TP_ARGS(xf), 875 TP_STRUCT__entry( 876 __field(dev_t, dev) 877 __field(unsigned long, ino) 878 __array(char, pathname, 256) 879 ), 880 TP_fast_assign( 881 char pathname[257]; 882 char *path; 883 884 __entry->ino = file_inode(xf->file)->i_ino; 885 memset(pathname, 0, sizeof(pathname)); 886 path = file_path(xf->file, pathname, sizeof(pathname) - 1); 887 if (IS_ERR(path)) 888 path = "(unknown)"; 889 strncpy(__entry->pathname, path, sizeof(__entry->pathname)); 890 ), 891 TP_printk("xfino 0x%lx path '%s'", 892 __entry->ino, 893 __entry->pathname) 894 ); 895 896 TRACE_EVENT(xfile_destroy, 897 TP_PROTO(struct xfile *xf), 898 TP_ARGS(xf), 899 TP_STRUCT__entry( 900 __field(unsigned long, ino) 901 __field(unsigned long long, bytes) 902 __field(loff_t, size) 903 ), 904 TP_fast_assign( 905 struct inode *inode = file_inode(xf->file); 906 907 __entry->ino = inode->i_ino; 908 __entry->bytes = inode->i_blocks << SECTOR_SHIFT; 909 __entry->size = i_size_read(inode); 910 ), 911 TP_printk("xfino 0x%lx mem_bytes 0x%llx isize 0x%llx", 912 __entry->ino, 913 __entry->bytes, 914 __entry->size) 915 ); 916 917 DECLARE_EVENT_CLASS(xfile_class, 918 TP_PROTO(struct xfile *xf, loff_t pos, unsigned long long bytecount), 919 TP_ARGS(xf, pos, bytecount), 920 TP_STRUCT__entry( 921 __field(unsigned long, ino) 922 __field(unsigned long long, bytes_used) 923 __field(loff_t, pos) 924 __field(loff_t, size) 925 __field(unsigned long long, bytecount) 926 ), 927 TP_fast_assign( 928 struct inode *inode = file_inode(xf->file); 929 930 __entry->ino = inode->i_ino; 931 __entry->bytes_used = inode->i_blocks << SECTOR_SHIFT; 932 __entry->pos = pos; 933 __entry->size = i_size_read(inode); 934 __entry->bytecount = bytecount; 935 ), 936 TP_printk("xfino 0x%lx mem_bytes 0x%llx pos 0x%llx bytecount 0x%llx isize 0x%llx", 937 __entry->ino, 938 __entry->bytes_used, 939 __entry->pos, 940 __entry->bytecount, 941 __entry->size) 942 ); 943 #define DEFINE_XFILE_EVENT(name) \ 944 DEFINE_EVENT(xfile_class, name, \ 945 TP_PROTO(struct xfile *xf, loff_t pos, unsigned long long bytecount), \ 946 TP_ARGS(xf, pos, bytecount)) 947 DEFINE_XFILE_EVENT(xfile_load); 948 DEFINE_XFILE_EVENT(xfile_store); 949 DEFINE_XFILE_EVENT(xfile_seek_data); 950 DEFINE_XFILE_EVENT(xfile_get_folio); 951 DEFINE_XFILE_EVENT(xfile_put_folio); 952 DEFINE_XFILE_EVENT(xfile_discard); 953 954 TRACE_EVENT(xfarray_create, 955 TP_PROTO(struct xfarray *xfa, unsigned long long required_capacity), 956 TP_ARGS(xfa, required_capacity), 957 TP_STRUCT__entry( 958 __field(unsigned long, ino) 959 __field(uint64_t, max_nr) 960 __field(size_t, obj_size) 961 __field(int, obj_size_log) 962 __field(unsigned long long, required_capacity) 963 ), 964 TP_fast_assign( 965 __entry->max_nr = xfa->max_nr; 966 __entry->obj_size = xfa->obj_size; 967 __entry->obj_size_log = xfa->obj_size_log; 968 __entry->ino = file_inode(xfa->xfile->file)->i_ino; 969 __entry->required_capacity = required_capacity; 970 ), 971 TP_printk("xfino 0x%lx max_nr %llu reqd_nr %llu objsz %zu objszlog %d", 972 __entry->ino, 973 __entry->max_nr, 974 __entry->required_capacity, 975 __entry->obj_size, 976 __entry->obj_size_log) 977 ); 978 979 TRACE_EVENT(xfarray_isort, 980 TP_PROTO(struct xfarray_sortinfo *si, uint64_t lo, uint64_t hi), 981 TP_ARGS(si, lo, hi), 982 TP_STRUCT__entry( 983 __field(unsigned long, ino) 984 __field(unsigned long long, lo) 985 __field(unsigned long long, hi) 986 ), 987 TP_fast_assign( 988 __entry->ino = file_inode(si->array->xfile->file)->i_ino; 989 __entry->lo = lo; 990 __entry->hi = hi; 991 ), 992 TP_printk("xfino 0x%lx lo %llu hi %llu elts %llu", 993 __entry->ino, 994 __entry->lo, 995 __entry->hi, 996 __entry->hi - __entry->lo) 997 ); 998 999 TRACE_EVENT(xfarray_foliosort, 1000 TP_PROTO(struct xfarray_sortinfo *si, uint64_t lo, uint64_t hi), 1001 TP_ARGS(si, lo, hi), 1002 TP_STRUCT__entry( 1003 __field(unsigned long, ino) 1004 __field(unsigned long long, lo) 1005 __field(unsigned long long, hi) 1006 ), 1007 TP_fast_assign( 1008 __entry->ino = file_inode(si->array->xfile->file)->i_ino; 1009 __entry->lo = lo; 1010 __entry->hi = hi; 1011 ), 1012 TP_printk("xfino 0x%lx lo %llu hi %llu elts %llu", 1013 __entry->ino, 1014 __entry->lo, 1015 __entry->hi, 1016 __entry->hi - __entry->lo) 1017 ); 1018 1019 TRACE_EVENT(xfarray_qsort, 1020 TP_PROTO(struct xfarray_sortinfo *si, uint64_t lo, uint64_t hi), 1021 TP_ARGS(si, lo, hi), 1022 TP_STRUCT__entry( 1023 __field(unsigned long, ino) 1024 __field(unsigned long long, lo) 1025 __field(unsigned long long, hi) 1026 __field(int, stack_depth) 1027 __field(int, max_stack_depth) 1028 ), 1029 TP_fast_assign( 1030 __entry->ino = file_inode(si->array->xfile->file)->i_ino; 1031 __entry->lo = lo; 1032 __entry->hi = hi; 1033 __entry->stack_depth = si->stack_depth; 1034 __entry->max_stack_depth = si->max_stack_depth; 1035 ), 1036 TP_printk("xfino 0x%lx lo %llu hi %llu elts %llu stack %d/%d", 1037 __entry->ino, 1038 __entry->lo, 1039 __entry->hi, 1040 __entry->hi - __entry->lo, 1041 __entry->stack_depth, 1042 __entry->max_stack_depth) 1043 ); 1044 1045 TRACE_EVENT(xfarray_sort, 1046 TP_PROTO(struct xfarray_sortinfo *si, size_t bytes), 1047 TP_ARGS(si, bytes), 1048 TP_STRUCT__entry( 1049 __field(unsigned long, ino) 1050 __field(unsigned long long, nr) 1051 __field(size_t, obj_size) 1052 __field(size_t, bytes) 1053 __field(unsigned int, max_stack_depth) 1054 ), 1055 TP_fast_assign( 1056 __entry->nr = si->array->nr; 1057 __entry->obj_size = si->array->obj_size; 1058 __entry->ino = file_inode(si->array->xfile->file)->i_ino; 1059 __entry->bytes = bytes; 1060 __entry->max_stack_depth = si->max_stack_depth; 1061 ), 1062 TP_printk("xfino 0x%lx nr %llu objsz %zu stack %u bytes %zu", 1063 __entry->ino, 1064 __entry->nr, 1065 __entry->obj_size, 1066 __entry->max_stack_depth, 1067 __entry->bytes) 1068 ); 1069 1070 TRACE_EVENT(xfarray_sort_scan, 1071 TP_PROTO(struct xfarray_sortinfo *si, unsigned long long idx), 1072 TP_ARGS(si, idx), 1073 TP_STRUCT__entry( 1074 __field(unsigned long, ino) 1075 __field(unsigned long long, nr) 1076 __field(size_t, obj_size) 1077 __field(unsigned long long, idx) 1078 __field(unsigned long long, folio_pos) 1079 __field(unsigned long, folio_bytes) 1080 __field(unsigned long long, first_idx) 1081 __field(unsigned long long, last_idx) 1082 ), 1083 TP_fast_assign( 1084 __entry->nr = si->array->nr; 1085 __entry->obj_size = si->array->obj_size; 1086 __entry->ino = file_inode(si->array->xfile->file)->i_ino; 1087 __entry->idx = idx; 1088 if (si->folio) { 1089 __entry->folio_pos = folio_pos(si->folio); 1090 __entry->folio_bytes = folio_size(si->folio); 1091 __entry->first_idx = si->first_folio_idx; 1092 __entry->last_idx = si->last_folio_idx; 1093 } else { 1094 __entry->folio_pos = 0; 1095 __entry->folio_bytes = 0; 1096 __entry->first_idx = 0; 1097 __entry->last_idx = 0; 1098 } 1099 ), 1100 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", 1101 __entry->ino, 1102 __entry->nr, 1103 __entry->obj_size, 1104 __entry->idx, 1105 __entry->folio_pos, 1106 __entry->folio_bytes, 1107 __entry->first_idx, 1108 __entry->last_idx) 1109 ); 1110 1111 TRACE_EVENT(xfarray_sort_stats, 1112 TP_PROTO(struct xfarray_sortinfo *si, int error), 1113 TP_ARGS(si, error), 1114 TP_STRUCT__entry( 1115 __field(unsigned long, ino) 1116 #ifdef DEBUG 1117 __field(unsigned long long, loads) 1118 __field(unsigned long long, stores) 1119 __field(unsigned long long, compares) 1120 __field(unsigned long long, heapsorts) 1121 #endif 1122 __field(unsigned int, max_stack_depth) 1123 __field(unsigned int, max_stack_used) 1124 __field(int, error) 1125 ), 1126 TP_fast_assign( 1127 __entry->ino = file_inode(si->array->xfile->file)->i_ino; 1128 #ifdef DEBUG 1129 __entry->loads = si->loads; 1130 __entry->stores = si->stores; 1131 __entry->compares = si->compares; 1132 __entry->heapsorts = si->heapsorts; 1133 #endif 1134 __entry->max_stack_depth = si->max_stack_depth; 1135 __entry->max_stack_used = si->max_stack_used; 1136 __entry->error = error; 1137 ), 1138 TP_printk( 1139 #ifdef DEBUG 1140 "xfino 0x%lx loads %llu stores %llu compares %llu heapsorts %llu stack_depth %u/%u error %d", 1141 #else 1142 "xfino 0x%lx stack_depth %u/%u error %d", 1143 #endif 1144 __entry->ino, 1145 #ifdef DEBUG 1146 __entry->loads, 1147 __entry->stores, 1148 __entry->compares, 1149 __entry->heapsorts, 1150 #endif 1151 __entry->max_stack_used, 1152 __entry->max_stack_depth, 1153 __entry->error) 1154 ); 1155 1156 #ifdef CONFIG_XFS_RT 1157 TRACE_EVENT(xchk_rtsum_record_free, 1158 TP_PROTO(struct xfs_mount *mp, xfs_rtxnum_t start, 1159 xfs_rtbxlen_t len, unsigned int log, loff_t pos, 1160 xfs_suminfo_t value), 1161 TP_ARGS(mp, start, len, log, pos, value), 1162 TP_STRUCT__entry( 1163 __field(dev_t, dev) 1164 __field(dev_t, rtdev) 1165 __field(xfs_rtxnum_t, start) 1166 __field(unsigned long long, len) 1167 __field(unsigned int, log) 1168 __field(loff_t, pos) 1169 __field(xfs_suminfo_t, value) 1170 ), 1171 TP_fast_assign( 1172 __entry->dev = mp->m_super->s_dev; 1173 __entry->rtdev = mp->m_rtdev_targp->bt_dev; 1174 __entry->start = start; 1175 __entry->len = len; 1176 __entry->log = log; 1177 __entry->pos = pos; 1178 __entry->value = value; 1179 ), 1180 TP_printk("dev %d:%d rtdev %d:%d rtx 0x%llx rtxcount 0x%llx log %u rsumpos 0x%llx sumcount %u", 1181 MAJOR(__entry->dev), MINOR(__entry->dev), 1182 MAJOR(__entry->rtdev), MINOR(__entry->rtdev), 1183 __entry->start, 1184 __entry->len, 1185 __entry->log, 1186 __entry->pos, 1187 __entry->value) 1188 ); 1189 #endif /* CONFIG_XFS_RT */ 1190 1191 DECLARE_EVENT_CLASS(xchk_iscan_class, 1192 TP_PROTO(struct xchk_iscan *iscan), 1193 TP_ARGS(iscan), 1194 TP_STRUCT__entry( 1195 __field(dev_t, dev) 1196 __field(xfs_ino_t, cursor) 1197 __field(xfs_ino_t, visited) 1198 ), 1199 TP_fast_assign( 1200 __entry->dev = iscan->sc->mp->m_super->s_dev; 1201 __entry->cursor = iscan->cursor_ino; 1202 __entry->visited = iscan->__visited_ino; 1203 ), 1204 TP_printk("dev %d:%d iscan cursor 0x%llx visited 0x%llx", 1205 MAJOR(__entry->dev), MINOR(__entry->dev), 1206 __entry->cursor, 1207 __entry->visited) 1208 ) 1209 #define DEFINE_ISCAN_EVENT(name) \ 1210 DEFINE_EVENT(xchk_iscan_class, name, \ 1211 TP_PROTO(struct xchk_iscan *iscan), \ 1212 TP_ARGS(iscan)) 1213 DEFINE_ISCAN_EVENT(xchk_iscan_move_cursor); 1214 DEFINE_ISCAN_EVENT(xchk_iscan_visit); 1215 DEFINE_ISCAN_EVENT(xchk_iscan_skip); 1216 DEFINE_ISCAN_EVENT(xchk_iscan_advance_ag); 1217 1218 DECLARE_EVENT_CLASS(xchk_iscan_ino_class, 1219 TP_PROTO(struct xchk_iscan *iscan, xfs_ino_t ino), 1220 TP_ARGS(iscan, ino), 1221 TP_STRUCT__entry( 1222 __field(dev_t, dev) 1223 __field(xfs_ino_t, startino) 1224 __field(xfs_ino_t, cursor) 1225 __field(xfs_ino_t, visited) 1226 __field(xfs_ino_t, ino) 1227 ), 1228 TP_fast_assign( 1229 __entry->dev = iscan->sc->mp->m_super->s_dev; 1230 __entry->startino = iscan->scan_start_ino; 1231 __entry->cursor = iscan->cursor_ino; 1232 __entry->visited = iscan->__visited_ino; 1233 __entry->ino = ino; 1234 ), 1235 TP_printk("dev %d:%d iscan start 0x%llx cursor 0x%llx visited 0x%llx ino 0x%llx", 1236 MAJOR(__entry->dev), MINOR(__entry->dev), 1237 __entry->startino, 1238 __entry->cursor, 1239 __entry->visited, 1240 __entry->ino) 1241 ) 1242 #define DEFINE_ISCAN_INO_EVENT(name) \ 1243 DEFINE_EVENT(xchk_iscan_ino_class, name, \ 1244 TP_PROTO(struct xchk_iscan *iscan, xfs_ino_t ino), \ 1245 TP_ARGS(iscan, ino)) 1246 DEFINE_ISCAN_INO_EVENT(xchk_iscan_want_live_update); 1247 DEFINE_ISCAN_INO_EVENT(xchk_iscan_start); 1248 1249 TRACE_EVENT(xchk_iscan_iget, 1250 TP_PROTO(struct xchk_iscan *iscan, int error), 1251 TP_ARGS(iscan, error), 1252 TP_STRUCT__entry( 1253 __field(dev_t, dev) 1254 __field(xfs_ino_t, cursor) 1255 __field(xfs_ino_t, visited) 1256 __field(int, error) 1257 ), 1258 TP_fast_assign( 1259 __entry->dev = iscan->sc->mp->m_super->s_dev; 1260 __entry->cursor = iscan->cursor_ino; 1261 __entry->visited = iscan->__visited_ino; 1262 __entry->error = error; 1263 ), 1264 TP_printk("dev %d:%d iscan cursor 0x%llx visited 0x%llx error %d", 1265 MAJOR(__entry->dev), MINOR(__entry->dev), 1266 __entry->cursor, 1267 __entry->visited, 1268 __entry->error) 1269 ); 1270 1271 TRACE_EVENT(xchk_iscan_iget_batch, 1272 TP_PROTO(struct xfs_mount *mp, struct xchk_iscan *iscan, 1273 unsigned int nr, unsigned int avail), 1274 TP_ARGS(mp, iscan, nr, avail), 1275 TP_STRUCT__entry( 1276 __field(dev_t, dev) 1277 __field(xfs_ino_t, cursor) 1278 __field(xfs_ino_t, visited) 1279 __field(unsigned int, nr) 1280 __field(unsigned int, avail) 1281 __field(unsigned int, unavail) 1282 __field(xfs_ino_t, batch_ino) 1283 __field(unsigned long long, skipmask) 1284 ), 1285 TP_fast_assign( 1286 __entry->dev = mp->m_super->s_dev; 1287 __entry->cursor = iscan->cursor_ino; 1288 __entry->visited = iscan->__visited_ino; 1289 __entry->nr = nr; 1290 __entry->avail = avail; 1291 __entry->unavail = hweight64(iscan->__skipped_inomask); 1292 __entry->batch_ino = iscan->__batch_ino; 1293 __entry->skipmask = iscan->__skipped_inomask; 1294 ), 1295 TP_printk("dev %d:%d iscan cursor 0x%llx visited 0x%llx batchino 0x%llx skipmask 0x%llx nr %u avail %u unavail %u", 1296 MAJOR(__entry->dev), MINOR(__entry->dev), 1297 __entry->cursor, 1298 __entry->visited, 1299 __entry->batch_ino, 1300 __entry->skipmask, 1301 __entry->nr, 1302 __entry->avail, 1303 __entry->unavail) 1304 ); 1305 1306 DECLARE_EVENT_CLASS(xchk_iscan_retry_wait_class, 1307 TP_PROTO(struct xchk_iscan *iscan), 1308 TP_ARGS(iscan), 1309 TP_STRUCT__entry( 1310 __field(dev_t, dev) 1311 __field(xfs_ino_t, cursor) 1312 __field(xfs_ino_t, visited) 1313 __field(unsigned int, retry_delay) 1314 __field(unsigned long, remaining) 1315 __field(unsigned int, iget_timeout) 1316 ), 1317 TP_fast_assign( 1318 __entry->dev = iscan->sc->mp->m_super->s_dev; 1319 __entry->cursor = iscan->cursor_ino; 1320 __entry->visited = iscan->__visited_ino; 1321 __entry->retry_delay = iscan->iget_retry_delay; 1322 __entry->remaining = jiffies_to_msecs(iscan->__iget_deadline - jiffies); 1323 __entry->iget_timeout = iscan->iget_timeout; 1324 ), 1325 TP_printk("dev %d:%d iscan cursor 0x%llx visited 0x%llx remaining %lu timeout %u delay %u", 1326 MAJOR(__entry->dev), MINOR(__entry->dev), 1327 __entry->cursor, 1328 __entry->visited, 1329 __entry->remaining, 1330 __entry->iget_timeout, 1331 __entry->retry_delay) 1332 ) 1333 #define DEFINE_ISCAN_RETRY_WAIT_EVENT(name) \ 1334 DEFINE_EVENT(xchk_iscan_retry_wait_class, name, \ 1335 TP_PROTO(struct xchk_iscan *iscan), \ 1336 TP_ARGS(iscan)) 1337 DEFINE_ISCAN_RETRY_WAIT_EVENT(xchk_iscan_iget_retry_wait); 1338 DEFINE_ISCAN_RETRY_WAIT_EVENT(xchk_iscan_agi_retry_wait); 1339 1340 TRACE_EVENT(xchk_nlinks_collect_dirent, 1341 TP_PROTO(struct xfs_mount *mp, struct xfs_inode *dp, 1342 xfs_ino_t ino, const struct xfs_name *name), 1343 TP_ARGS(mp, dp, ino, name), 1344 TP_STRUCT__entry( 1345 __field(dev_t, dev) 1346 __field(xfs_ino_t, dir) 1347 __field(xfs_ino_t, ino) 1348 __field(unsigned int, namelen) 1349 __dynamic_array(char, name, name->len) 1350 ), 1351 TP_fast_assign( 1352 __entry->dev = mp->m_super->s_dev; 1353 __entry->dir = dp->i_ino; 1354 __entry->ino = ino; 1355 __entry->namelen = name->len; 1356 memcpy(__get_str(name), name->name, name->len); 1357 ), 1358 TP_printk("dev %d:%d dir 0x%llx -> ino 0x%llx name '%.*s'", 1359 MAJOR(__entry->dev), MINOR(__entry->dev), 1360 __entry->dir, 1361 __entry->ino, 1362 __entry->namelen, 1363 __get_str(name)) 1364 ); 1365 1366 TRACE_EVENT(xchk_nlinks_collect_metafile, 1367 TP_PROTO(struct xfs_mount *mp, xfs_ino_t ino), 1368 TP_ARGS(mp, ino), 1369 TP_STRUCT__entry( 1370 __field(dev_t, dev) 1371 __field(xfs_ino_t, ino) 1372 ), 1373 TP_fast_assign( 1374 __entry->dev = mp->m_super->s_dev; 1375 __entry->ino = ino; 1376 ), 1377 TP_printk("dev %d:%d ino 0x%llx", 1378 MAJOR(__entry->dev), MINOR(__entry->dev), 1379 __entry->ino) 1380 ); 1381 1382 TRACE_EVENT(xchk_nlinks_live_update, 1383 TP_PROTO(struct xfs_mount *mp, const struct xfs_inode *dp, 1384 int action, xfs_ino_t ino, int delta, 1385 const char *name, unsigned int namelen), 1386 TP_ARGS(mp, dp, action, ino, delta, name, namelen), 1387 TP_STRUCT__entry( 1388 __field(dev_t, dev) 1389 __field(xfs_ino_t, dir) 1390 __field(int, action) 1391 __field(xfs_ino_t, ino) 1392 __field(int, delta) 1393 __field(unsigned int, namelen) 1394 __dynamic_array(char, name, namelen) 1395 ), 1396 TP_fast_assign( 1397 __entry->dev = mp->m_super->s_dev; 1398 __entry->dir = dp ? dp->i_ino : NULLFSINO; 1399 __entry->action = action; 1400 __entry->ino = ino; 1401 __entry->delta = delta; 1402 __entry->namelen = namelen; 1403 memcpy(__get_str(name), name, namelen); 1404 ), 1405 TP_printk("dev %d:%d dir 0x%llx ino 0x%llx nlink_delta %d name '%.*s'", 1406 MAJOR(__entry->dev), MINOR(__entry->dev), 1407 __entry->dir, 1408 __entry->ino, 1409 __entry->delta, 1410 __entry->namelen, 1411 __get_str(name)) 1412 ); 1413 1414 TRACE_EVENT(xchk_nlinks_check_zero, 1415 TP_PROTO(struct xfs_mount *mp, xfs_ino_t ino, 1416 const struct xchk_nlink *live), 1417 TP_ARGS(mp, ino, live), 1418 TP_STRUCT__entry( 1419 __field(dev_t, dev) 1420 __field(xfs_ino_t, ino) 1421 __field(xfs_nlink_t, parents) 1422 __field(xfs_nlink_t, backrefs) 1423 __field(xfs_nlink_t, children) 1424 ), 1425 TP_fast_assign( 1426 __entry->dev = mp->m_super->s_dev; 1427 __entry->ino = ino; 1428 __entry->parents = live->parents; 1429 __entry->backrefs = live->backrefs; 1430 __entry->children = live->children; 1431 ), 1432 TP_printk("dev %d:%d ino 0x%llx parents %u backrefs %u children %u", 1433 MAJOR(__entry->dev), MINOR(__entry->dev), 1434 __entry->ino, 1435 __entry->parents, 1436 __entry->backrefs, 1437 __entry->children) 1438 ); 1439 1440 TRACE_EVENT(xchk_nlinks_update_incore, 1441 TP_PROTO(struct xfs_mount *mp, xfs_ino_t ino, 1442 const struct xchk_nlink *live, int parents_delta, 1443 int backrefs_delta, int children_delta), 1444 TP_ARGS(mp, ino, live, parents_delta, backrefs_delta, children_delta), 1445 TP_STRUCT__entry( 1446 __field(dev_t, dev) 1447 __field(xfs_ino_t, ino) 1448 __field(xfs_nlink_t, parents) 1449 __field(xfs_nlink_t, backrefs) 1450 __field(xfs_nlink_t, children) 1451 __field(int, parents_delta) 1452 __field(int, backrefs_delta) 1453 __field(int, children_delta) 1454 ), 1455 TP_fast_assign( 1456 __entry->dev = mp->m_super->s_dev; 1457 __entry->ino = ino; 1458 __entry->parents = live->parents; 1459 __entry->backrefs = live->backrefs; 1460 __entry->children = live->children; 1461 __entry->parents_delta = parents_delta; 1462 __entry->backrefs_delta = backrefs_delta; 1463 __entry->children_delta = children_delta; 1464 ), 1465 TP_printk("dev %d:%d ino 0x%llx parents %d:%u backrefs %d:%u children %d:%u", 1466 MAJOR(__entry->dev), MINOR(__entry->dev), 1467 __entry->ino, 1468 __entry->parents_delta, 1469 __entry->parents, 1470 __entry->backrefs_delta, 1471 __entry->backrefs, 1472 __entry->children_delta, 1473 __entry->children) 1474 ); 1475 1476 DECLARE_EVENT_CLASS(xchk_nlinks_diff_class, 1477 TP_PROTO(struct xfs_mount *mp, struct xfs_inode *ip, 1478 const struct xchk_nlink *live), 1479 TP_ARGS(mp, ip, live), 1480 TP_STRUCT__entry( 1481 __field(dev_t, dev) 1482 __field(xfs_ino_t, ino) 1483 __field(uint8_t, ftype) 1484 __field(xfs_nlink_t, nlink) 1485 __field(xfs_nlink_t, parents) 1486 __field(xfs_nlink_t, backrefs) 1487 __field(xfs_nlink_t, children) 1488 ), 1489 TP_fast_assign( 1490 __entry->dev = mp->m_super->s_dev; 1491 __entry->ino = ip->i_ino; 1492 __entry->ftype = xfs_mode_to_ftype(VFS_I(ip)->i_mode); 1493 __entry->nlink = VFS_I(ip)->i_nlink; 1494 __entry->parents = live->parents; 1495 __entry->backrefs = live->backrefs; 1496 __entry->children = live->children; 1497 ), 1498 TP_printk("dev %d:%d ino 0x%llx ftype %s nlink %u parents %u backrefs %u children %u", 1499 MAJOR(__entry->dev), MINOR(__entry->dev), 1500 __entry->ino, 1501 __print_symbolic(__entry->ftype, XFS_DIR3_FTYPE_STR), 1502 __entry->nlink, 1503 __entry->parents, 1504 __entry->backrefs, 1505 __entry->children) 1506 ); 1507 #define DEFINE_SCRUB_NLINKS_DIFF_EVENT(name) \ 1508 DEFINE_EVENT(xchk_nlinks_diff_class, name, \ 1509 TP_PROTO(struct xfs_mount *mp, struct xfs_inode *ip, \ 1510 const struct xchk_nlink *live), \ 1511 TP_ARGS(mp, ip, live)) 1512 DEFINE_SCRUB_NLINKS_DIFF_EVENT(xchk_nlinks_compare_inode); 1513 1514 /* repair tracepoints */ 1515 #if IS_ENABLED(CONFIG_XFS_ONLINE_REPAIR) 1516 1517 DECLARE_EVENT_CLASS(xrep_extent_class, 1518 TP_PROTO(struct xfs_perag *pag, xfs_agblock_t agbno, xfs_extlen_t len), 1519 TP_ARGS(pag, agbno, len), 1520 TP_STRUCT__entry( 1521 __field(dev_t, dev) 1522 __field(xfs_agnumber_t, agno) 1523 __field(xfs_agblock_t, agbno) 1524 __field(xfs_extlen_t, len) 1525 ), 1526 TP_fast_assign( 1527 __entry->dev = pag->pag_mount->m_super->s_dev; 1528 __entry->agno = pag->pag_agno; 1529 __entry->agbno = agbno; 1530 __entry->len = len; 1531 ), 1532 TP_printk("dev %d:%d agno 0x%x agbno 0x%x fsbcount 0x%x", 1533 MAJOR(__entry->dev), MINOR(__entry->dev), 1534 __entry->agno, 1535 __entry->agbno, 1536 __entry->len) 1537 ); 1538 #define DEFINE_REPAIR_EXTENT_EVENT(name) \ 1539 DEFINE_EVENT(xrep_extent_class, name, \ 1540 TP_PROTO(struct xfs_perag *pag, xfs_agblock_t agbno, xfs_extlen_t len), \ 1541 TP_ARGS(pag, agbno, len)) 1542 DEFINE_REPAIR_EXTENT_EVENT(xreap_dispose_unmap_extent); 1543 DEFINE_REPAIR_EXTENT_EVENT(xreap_dispose_free_extent); 1544 DEFINE_REPAIR_EXTENT_EVENT(xreap_agextent_binval); 1545 DEFINE_REPAIR_EXTENT_EVENT(xreap_bmapi_binval); 1546 DEFINE_REPAIR_EXTENT_EVENT(xrep_agfl_insert); 1547 1548 DECLARE_EVENT_CLASS(xrep_reap_find_class, 1549 TP_PROTO(struct xfs_perag *pag, xfs_agblock_t agbno, xfs_extlen_t len, 1550 bool crosslinked), 1551 TP_ARGS(pag, agbno, len, crosslinked), 1552 TP_STRUCT__entry( 1553 __field(dev_t, dev) 1554 __field(xfs_agnumber_t, agno) 1555 __field(xfs_agblock_t, agbno) 1556 __field(xfs_extlen_t, len) 1557 __field(bool, crosslinked) 1558 ), 1559 TP_fast_assign( 1560 __entry->dev = pag->pag_mount->m_super->s_dev; 1561 __entry->agno = pag->pag_agno; 1562 __entry->agbno = agbno; 1563 __entry->len = len; 1564 __entry->crosslinked = crosslinked; 1565 ), 1566 TP_printk("dev %d:%d agno 0x%x agbno 0x%x fsbcount 0x%x crosslinked %d", 1567 MAJOR(__entry->dev), MINOR(__entry->dev), 1568 __entry->agno, 1569 __entry->agbno, 1570 __entry->len, 1571 __entry->crosslinked ? 1 : 0) 1572 ); 1573 #define DEFINE_REPAIR_REAP_FIND_EVENT(name) \ 1574 DEFINE_EVENT(xrep_reap_find_class, name, \ 1575 TP_PROTO(struct xfs_perag *pag, xfs_agblock_t agbno, xfs_extlen_t len, \ 1576 bool crosslinked), \ 1577 TP_ARGS(pag, agbno, len, crosslinked)) 1578 DEFINE_REPAIR_REAP_FIND_EVENT(xreap_agextent_select); 1579 DEFINE_REPAIR_REAP_FIND_EVENT(xreap_bmapi_select); 1580 1581 DECLARE_EVENT_CLASS(xrep_rmap_class, 1582 TP_PROTO(struct xfs_mount *mp, xfs_agnumber_t agno, 1583 xfs_agblock_t agbno, xfs_extlen_t len, 1584 uint64_t owner, uint64_t offset, unsigned int flags), 1585 TP_ARGS(mp, agno, agbno, len, owner, offset, flags), 1586 TP_STRUCT__entry( 1587 __field(dev_t, dev) 1588 __field(xfs_agnumber_t, agno) 1589 __field(xfs_agblock_t, agbno) 1590 __field(xfs_extlen_t, len) 1591 __field(uint64_t, owner) 1592 __field(uint64_t, offset) 1593 __field(unsigned int, flags) 1594 ), 1595 TP_fast_assign( 1596 __entry->dev = mp->m_super->s_dev; 1597 __entry->agno = agno; 1598 __entry->agbno = agbno; 1599 __entry->len = len; 1600 __entry->owner = owner; 1601 __entry->offset = offset; 1602 __entry->flags = flags; 1603 ), 1604 TP_printk("dev %d:%d agno 0x%x agbno 0x%x fsbcount 0x%x owner 0x%llx fileoff 0x%llx flags 0x%x", 1605 MAJOR(__entry->dev), MINOR(__entry->dev), 1606 __entry->agno, 1607 __entry->agbno, 1608 __entry->len, 1609 __entry->owner, 1610 __entry->offset, 1611 __entry->flags) 1612 ); 1613 #define DEFINE_REPAIR_RMAP_EVENT(name) \ 1614 DEFINE_EVENT(xrep_rmap_class, name, \ 1615 TP_PROTO(struct xfs_mount *mp, xfs_agnumber_t agno, \ 1616 xfs_agblock_t agbno, xfs_extlen_t len, \ 1617 uint64_t owner, uint64_t offset, unsigned int flags), \ 1618 TP_ARGS(mp, agno, agbno, len, owner, offset, flags)) 1619 DEFINE_REPAIR_RMAP_EVENT(xrep_ibt_walk_rmap); 1620 DEFINE_REPAIR_RMAP_EVENT(xrep_bmap_walk_rmap); 1621 1622 TRACE_EVENT(xrep_abt_found, 1623 TP_PROTO(struct xfs_mount *mp, xfs_agnumber_t agno, 1624 const struct xfs_alloc_rec_incore *rec), 1625 TP_ARGS(mp, agno, rec), 1626 TP_STRUCT__entry( 1627 __field(dev_t, dev) 1628 __field(xfs_agnumber_t, agno) 1629 __field(xfs_agblock_t, startblock) 1630 __field(xfs_extlen_t, blockcount) 1631 ), 1632 TP_fast_assign( 1633 __entry->dev = mp->m_super->s_dev; 1634 __entry->agno = agno; 1635 __entry->startblock = rec->ar_startblock; 1636 __entry->blockcount = rec->ar_blockcount; 1637 ), 1638 TP_printk("dev %d:%d agno 0x%x agbno 0x%x fsbcount 0x%x", 1639 MAJOR(__entry->dev), MINOR(__entry->dev), 1640 __entry->agno, 1641 __entry->startblock, 1642 __entry->blockcount) 1643 ) 1644 1645 TRACE_EVENT(xrep_ibt_found, 1646 TP_PROTO(struct xfs_mount *mp, xfs_agnumber_t agno, 1647 const struct xfs_inobt_rec_incore *rec), 1648 TP_ARGS(mp, agno, rec), 1649 TP_STRUCT__entry( 1650 __field(dev_t, dev) 1651 __field(xfs_agnumber_t, agno) 1652 __field(xfs_agino_t, startino) 1653 __field(uint16_t, holemask) 1654 __field(uint8_t, count) 1655 __field(uint8_t, freecount) 1656 __field(uint64_t, freemask) 1657 ), 1658 TP_fast_assign( 1659 __entry->dev = mp->m_super->s_dev; 1660 __entry->agno = agno; 1661 __entry->startino = rec->ir_startino; 1662 __entry->holemask = rec->ir_holemask; 1663 __entry->count = rec->ir_count; 1664 __entry->freecount = rec->ir_freecount; 1665 __entry->freemask = rec->ir_free; 1666 ), 1667 TP_printk("dev %d:%d agno 0x%x agino 0x%x holemask 0x%x count 0x%x freecount 0x%x freemask 0x%llx", 1668 MAJOR(__entry->dev), MINOR(__entry->dev), 1669 __entry->agno, 1670 __entry->startino, 1671 __entry->holemask, 1672 __entry->count, 1673 __entry->freecount, 1674 __entry->freemask) 1675 ) 1676 1677 TRACE_EVENT(xrep_refc_found, 1678 TP_PROTO(struct xfs_perag *pag, const struct xfs_refcount_irec *rec), 1679 TP_ARGS(pag, rec), 1680 TP_STRUCT__entry( 1681 __field(dev_t, dev) 1682 __field(xfs_agnumber_t, agno) 1683 __field(enum xfs_refc_domain, domain) 1684 __field(xfs_agblock_t, startblock) 1685 __field(xfs_extlen_t, blockcount) 1686 __field(xfs_nlink_t, refcount) 1687 ), 1688 TP_fast_assign( 1689 __entry->dev = pag->pag_mount->m_super->s_dev; 1690 __entry->agno = pag->pag_agno; 1691 __entry->domain = rec->rc_domain; 1692 __entry->startblock = rec->rc_startblock; 1693 __entry->blockcount = rec->rc_blockcount; 1694 __entry->refcount = rec->rc_refcount; 1695 ), 1696 TP_printk("dev %d:%d agno 0x%x dom %s agbno 0x%x fsbcount 0x%x refcount %u", 1697 MAJOR(__entry->dev), MINOR(__entry->dev), 1698 __entry->agno, 1699 __print_symbolic(__entry->domain, XFS_REFC_DOMAIN_STRINGS), 1700 __entry->startblock, 1701 __entry->blockcount, 1702 __entry->refcount) 1703 ) 1704 1705 TRACE_EVENT(xrep_bmap_found, 1706 TP_PROTO(struct xfs_inode *ip, int whichfork, 1707 struct xfs_bmbt_irec *irec), 1708 TP_ARGS(ip, whichfork, irec), 1709 TP_STRUCT__entry( 1710 __field(dev_t, dev) 1711 __field(xfs_ino_t, ino) 1712 __field(int, whichfork) 1713 __field(xfs_fileoff_t, lblk) 1714 __field(xfs_filblks_t, len) 1715 __field(xfs_fsblock_t, pblk) 1716 __field(int, state) 1717 ), 1718 TP_fast_assign( 1719 __entry->dev = VFS_I(ip)->i_sb->s_dev; 1720 __entry->ino = ip->i_ino; 1721 __entry->whichfork = whichfork; 1722 __entry->lblk = irec->br_startoff; 1723 __entry->len = irec->br_blockcount; 1724 __entry->pblk = irec->br_startblock; 1725 __entry->state = irec->br_state; 1726 ), 1727 TP_printk("dev %d:%d ino 0x%llx whichfork %s fileoff 0x%llx fsbcount 0x%llx startblock 0x%llx state %d", 1728 MAJOR(__entry->dev), MINOR(__entry->dev), 1729 __entry->ino, 1730 __print_symbolic(__entry->whichfork, XFS_WHICHFORK_STRINGS), 1731 __entry->lblk, 1732 __entry->len, 1733 __entry->pblk, 1734 __entry->state) 1735 ); 1736 1737 TRACE_EVENT(xrep_rmap_found, 1738 TP_PROTO(struct xfs_mount *mp, xfs_agnumber_t agno, 1739 const struct xfs_rmap_irec *rec), 1740 TP_ARGS(mp, agno, rec), 1741 TP_STRUCT__entry( 1742 __field(dev_t, dev) 1743 __field(xfs_agnumber_t, agno) 1744 __field(xfs_agblock_t, agbno) 1745 __field(xfs_extlen_t, len) 1746 __field(uint64_t, owner) 1747 __field(uint64_t, offset) 1748 __field(unsigned int, flags) 1749 ), 1750 TP_fast_assign( 1751 __entry->dev = mp->m_super->s_dev; 1752 __entry->agno = agno; 1753 __entry->agbno = rec->rm_startblock; 1754 __entry->len = rec->rm_blockcount; 1755 __entry->owner = rec->rm_owner; 1756 __entry->offset = rec->rm_offset; 1757 __entry->flags = rec->rm_flags; 1758 ), 1759 TP_printk("dev %d:%d agno 0x%x agbno 0x%x fsbcount 0x%x owner 0x%llx fileoff 0x%llx flags 0x%x", 1760 MAJOR(__entry->dev), MINOR(__entry->dev), 1761 __entry->agno, 1762 __entry->agbno, 1763 __entry->len, 1764 __entry->owner, 1765 __entry->offset, 1766 __entry->flags) 1767 ); 1768 1769 TRACE_EVENT(xrep_findroot_block, 1770 TP_PROTO(struct xfs_mount *mp, xfs_agnumber_t agno, xfs_agblock_t agbno, 1771 uint32_t magic, uint16_t level), 1772 TP_ARGS(mp, agno, agbno, magic, level), 1773 TP_STRUCT__entry( 1774 __field(dev_t, dev) 1775 __field(xfs_agnumber_t, agno) 1776 __field(xfs_agblock_t, agbno) 1777 __field(uint32_t, magic) 1778 __field(uint16_t, level) 1779 ), 1780 TP_fast_assign( 1781 __entry->dev = mp->m_super->s_dev; 1782 __entry->agno = agno; 1783 __entry->agbno = agbno; 1784 __entry->magic = magic; 1785 __entry->level = level; 1786 ), 1787 TP_printk("dev %d:%d agno 0x%x agbno 0x%x magic 0x%x level %u", 1788 MAJOR(__entry->dev), MINOR(__entry->dev), 1789 __entry->agno, 1790 __entry->agbno, 1791 __entry->magic, 1792 __entry->level) 1793 ) 1794 TRACE_EVENT(xrep_calc_ag_resblks, 1795 TP_PROTO(struct xfs_mount *mp, xfs_agnumber_t agno, 1796 xfs_agino_t icount, xfs_agblock_t aglen, xfs_agblock_t freelen, 1797 xfs_agblock_t usedlen), 1798 TP_ARGS(mp, agno, icount, aglen, freelen, usedlen), 1799 TP_STRUCT__entry( 1800 __field(dev_t, dev) 1801 __field(xfs_agnumber_t, agno) 1802 __field(xfs_agino_t, icount) 1803 __field(xfs_agblock_t, aglen) 1804 __field(xfs_agblock_t, freelen) 1805 __field(xfs_agblock_t, usedlen) 1806 ), 1807 TP_fast_assign( 1808 __entry->dev = mp->m_super->s_dev; 1809 __entry->agno = agno; 1810 __entry->icount = icount; 1811 __entry->aglen = aglen; 1812 __entry->freelen = freelen; 1813 __entry->usedlen = usedlen; 1814 ), 1815 TP_printk("dev %d:%d agno 0x%x icount %u aglen %u freelen %u usedlen %u", 1816 MAJOR(__entry->dev), MINOR(__entry->dev), 1817 __entry->agno, 1818 __entry->icount, 1819 __entry->aglen, 1820 __entry->freelen, 1821 __entry->usedlen) 1822 ) 1823 TRACE_EVENT(xrep_calc_ag_resblks_btsize, 1824 TP_PROTO(struct xfs_mount *mp, xfs_agnumber_t agno, 1825 xfs_agblock_t bnobt_sz, xfs_agblock_t inobt_sz, 1826 xfs_agblock_t rmapbt_sz, xfs_agblock_t refcbt_sz), 1827 TP_ARGS(mp, agno, bnobt_sz, inobt_sz, rmapbt_sz, refcbt_sz), 1828 TP_STRUCT__entry( 1829 __field(dev_t, dev) 1830 __field(xfs_agnumber_t, agno) 1831 __field(xfs_agblock_t, bnobt_sz) 1832 __field(xfs_agblock_t, inobt_sz) 1833 __field(xfs_agblock_t, rmapbt_sz) 1834 __field(xfs_agblock_t, refcbt_sz) 1835 ), 1836 TP_fast_assign( 1837 __entry->dev = mp->m_super->s_dev; 1838 __entry->agno = agno; 1839 __entry->bnobt_sz = bnobt_sz; 1840 __entry->inobt_sz = inobt_sz; 1841 __entry->rmapbt_sz = rmapbt_sz; 1842 __entry->refcbt_sz = refcbt_sz; 1843 ), 1844 TP_printk("dev %d:%d agno 0x%x bnobt %u inobt %u rmapbt %u refcountbt %u", 1845 MAJOR(__entry->dev), MINOR(__entry->dev), 1846 __entry->agno, 1847 __entry->bnobt_sz, 1848 __entry->inobt_sz, 1849 __entry->rmapbt_sz, 1850 __entry->refcbt_sz) 1851 ) 1852 TRACE_EVENT(xrep_reset_counters, 1853 TP_PROTO(struct xfs_mount *mp, struct xchk_fscounters *fsc), 1854 TP_ARGS(mp, fsc), 1855 TP_STRUCT__entry( 1856 __field(dev_t, dev) 1857 __field(uint64_t, icount) 1858 __field(uint64_t, ifree) 1859 __field(uint64_t, fdblocks) 1860 __field(uint64_t, frextents) 1861 ), 1862 TP_fast_assign( 1863 __entry->dev = mp->m_super->s_dev; 1864 __entry->icount = fsc->icount; 1865 __entry->ifree = fsc->ifree; 1866 __entry->fdblocks = fsc->fdblocks; 1867 __entry->frextents = fsc->frextents; 1868 ), 1869 TP_printk("dev %d:%d icount %llu ifree %llu fdblocks %llu frextents %llu", 1870 MAJOR(__entry->dev), MINOR(__entry->dev), 1871 __entry->icount, 1872 __entry->ifree, 1873 __entry->fdblocks, 1874 __entry->frextents) 1875 ) 1876 1877 DECLARE_EVENT_CLASS(xrep_newbt_extent_class, 1878 TP_PROTO(struct xfs_mount *mp, xfs_agnumber_t agno, 1879 xfs_agblock_t agbno, xfs_extlen_t len, 1880 int64_t owner), 1881 TP_ARGS(mp, agno, agbno, len, owner), 1882 TP_STRUCT__entry( 1883 __field(dev_t, dev) 1884 __field(xfs_agnumber_t, agno) 1885 __field(xfs_agblock_t, agbno) 1886 __field(xfs_extlen_t, len) 1887 __field(int64_t, owner) 1888 ), 1889 TP_fast_assign( 1890 __entry->dev = mp->m_super->s_dev; 1891 __entry->agno = agno; 1892 __entry->agbno = agbno; 1893 __entry->len = len; 1894 __entry->owner = owner; 1895 ), 1896 TP_printk("dev %d:%d agno 0x%x agbno 0x%x fsbcount 0x%x owner 0x%llx", 1897 MAJOR(__entry->dev), MINOR(__entry->dev), 1898 __entry->agno, 1899 __entry->agbno, 1900 __entry->len, 1901 __entry->owner) 1902 ); 1903 #define DEFINE_NEWBT_EXTENT_EVENT(name) \ 1904 DEFINE_EVENT(xrep_newbt_extent_class, name, \ 1905 TP_PROTO(struct xfs_mount *mp, xfs_agnumber_t agno, \ 1906 xfs_agblock_t agbno, xfs_extlen_t len, \ 1907 int64_t owner), \ 1908 TP_ARGS(mp, agno, agbno, len, owner)) 1909 DEFINE_NEWBT_EXTENT_EVENT(xrep_newbt_alloc_ag_blocks); 1910 DEFINE_NEWBT_EXTENT_EVENT(xrep_newbt_alloc_file_blocks); 1911 DEFINE_NEWBT_EXTENT_EVENT(xrep_newbt_free_blocks); 1912 DEFINE_NEWBT_EXTENT_EVENT(xrep_newbt_claim_block); 1913 1914 DECLARE_EVENT_CLASS(xrep_dinode_class, 1915 TP_PROTO(struct xfs_scrub *sc, struct xfs_dinode *dip), 1916 TP_ARGS(sc, dip), 1917 TP_STRUCT__entry( 1918 __field(dev_t, dev) 1919 __field(xfs_ino_t, ino) 1920 __field(uint16_t, mode) 1921 __field(uint8_t, version) 1922 __field(uint8_t, format) 1923 __field(uint32_t, uid) 1924 __field(uint32_t, gid) 1925 __field(uint64_t, size) 1926 __field(uint64_t, nblocks) 1927 __field(uint32_t, extsize) 1928 __field(uint32_t, nextents) 1929 __field(uint16_t, anextents) 1930 __field(uint8_t, forkoff) 1931 __field(uint8_t, aformat) 1932 __field(uint16_t, flags) 1933 __field(uint32_t, gen) 1934 __field(uint64_t, flags2) 1935 __field(uint32_t, cowextsize) 1936 ), 1937 TP_fast_assign( 1938 __entry->dev = sc->mp->m_super->s_dev; 1939 __entry->ino = sc->sm->sm_ino; 1940 __entry->mode = be16_to_cpu(dip->di_mode); 1941 __entry->version = dip->di_version; 1942 __entry->format = dip->di_format; 1943 __entry->uid = be32_to_cpu(dip->di_uid); 1944 __entry->gid = be32_to_cpu(dip->di_gid); 1945 __entry->size = be64_to_cpu(dip->di_size); 1946 __entry->nblocks = be64_to_cpu(dip->di_nblocks); 1947 __entry->extsize = be32_to_cpu(dip->di_extsize); 1948 __entry->nextents = be32_to_cpu(dip->di_nextents); 1949 __entry->anextents = be16_to_cpu(dip->di_anextents); 1950 __entry->forkoff = dip->di_forkoff; 1951 __entry->aformat = dip->di_aformat; 1952 __entry->flags = be16_to_cpu(dip->di_flags); 1953 __entry->gen = be32_to_cpu(dip->di_gen); 1954 __entry->flags2 = be64_to_cpu(dip->di_flags2); 1955 __entry->cowextsize = be32_to_cpu(dip->di_cowextsize); 1956 ), 1957 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", 1958 MAJOR(__entry->dev), MINOR(__entry->dev), 1959 __entry->ino, 1960 __entry->mode, 1961 __entry->version, 1962 __entry->format, 1963 __entry->uid, 1964 __entry->gid, 1965 __entry->size, 1966 __entry->nblocks, 1967 __entry->extsize, 1968 __entry->nextents, 1969 __entry->anextents, 1970 __entry->forkoff, 1971 __entry->aformat, 1972 __entry->flags, 1973 __entry->gen, 1974 __entry->flags2, 1975 __entry->cowextsize) 1976 ) 1977 1978 #define DEFINE_REPAIR_DINODE_EVENT(name) \ 1979 DEFINE_EVENT(xrep_dinode_class, name, \ 1980 TP_PROTO(struct xfs_scrub *sc, struct xfs_dinode *dip), \ 1981 TP_ARGS(sc, dip)) 1982 DEFINE_REPAIR_DINODE_EVENT(xrep_dinode_header); 1983 DEFINE_REPAIR_DINODE_EVENT(xrep_dinode_mode); 1984 DEFINE_REPAIR_DINODE_EVENT(xrep_dinode_flags); 1985 DEFINE_REPAIR_DINODE_EVENT(xrep_dinode_size); 1986 DEFINE_REPAIR_DINODE_EVENT(xrep_dinode_extsize_hints); 1987 DEFINE_REPAIR_DINODE_EVENT(xrep_dinode_zap_symlink); 1988 DEFINE_REPAIR_DINODE_EVENT(xrep_dinode_zap_dir); 1989 DEFINE_REPAIR_DINODE_EVENT(xrep_dinode_fixed); 1990 DEFINE_REPAIR_DINODE_EVENT(xrep_dinode_zap_forks); 1991 DEFINE_REPAIR_DINODE_EVENT(xrep_dinode_zap_dfork); 1992 DEFINE_REPAIR_DINODE_EVENT(xrep_dinode_zap_afork); 1993 DEFINE_REPAIR_DINODE_EVENT(xrep_dinode_ensure_forkoff); 1994 1995 DECLARE_EVENT_CLASS(xrep_inode_class, 1996 TP_PROTO(struct xfs_scrub *sc), 1997 TP_ARGS(sc), 1998 TP_STRUCT__entry( 1999 __field(dev_t, dev) 2000 __field(xfs_ino_t, ino) 2001 __field(xfs_fsize_t, size) 2002 __field(xfs_rfsblock_t, nblocks) 2003 __field(uint16_t, flags) 2004 __field(uint64_t, flags2) 2005 __field(uint32_t, nextents) 2006 __field(uint8_t, format) 2007 __field(uint32_t, anextents) 2008 __field(uint8_t, aformat) 2009 ), 2010 TP_fast_assign( 2011 __entry->dev = sc->mp->m_super->s_dev; 2012 __entry->ino = sc->sm->sm_ino; 2013 __entry->size = sc->ip->i_disk_size; 2014 __entry->nblocks = sc->ip->i_nblocks; 2015 __entry->flags = sc->ip->i_diflags; 2016 __entry->flags2 = sc->ip->i_diflags2; 2017 __entry->nextents = sc->ip->i_df.if_nextents; 2018 __entry->format = sc->ip->i_df.if_format; 2019 __entry->anextents = sc->ip->i_af.if_nextents; 2020 __entry->aformat = sc->ip->i_af.if_format; 2021 ), 2022 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", 2023 MAJOR(__entry->dev), MINOR(__entry->dev), 2024 __entry->ino, 2025 __entry->size, 2026 __entry->nblocks, 2027 __entry->flags, 2028 __entry->flags2, 2029 __entry->nextents, 2030 __entry->format, 2031 __entry->anextents, 2032 __entry->aformat) 2033 ) 2034 2035 #define DEFINE_REPAIR_INODE_EVENT(name) \ 2036 DEFINE_EVENT(xrep_inode_class, name, \ 2037 TP_PROTO(struct xfs_scrub *sc), \ 2038 TP_ARGS(sc)) 2039 DEFINE_REPAIR_INODE_EVENT(xrep_inode_blockcounts); 2040 DEFINE_REPAIR_INODE_EVENT(xrep_inode_ids); 2041 DEFINE_REPAIR_INODE_EVENT(xrep_inode_flags); 2042 DEFINE_REPAIR_INODE_EVENT(xrep_inode_blockdir_size); 2043 DEFINE_REPAIR_INODE_EVENT(xrep_inode_sfdir_size); 2044 DEFINE_REPAIR_INODE_EVENT(xrep_inode_dir_size); 2045 DEFINE_REPAIR_INODE_EVENT(xrep_inode_fixed); 2046 2047 TRACE_EVENT(xrep_dinode_count_rmaps, 2048 TP_PROTO(struct xfs_scrub *sc, xfs_rfsblock_t data_blocks, 2049 xfs_rfsblock_t rt_blocks, xfs_rfsblock_t attr_blocks, 2050 xfs_extnum_t data_extents, xfs_extnum_t rt_extents, 2051 xfs_aextnum_t attr_extents), 2052 TP_ARGS(sc, data_blocks, rt_blocks, attr_blocks, data_extents, 2053 rt_extents, attr_extents), 2054 TP_STRUCT__entry( 2055 __field(dev_t, dev) 2056 __field(xfs_ino_t, ino) 2057 __field(xfs_rfsblock_t, data_blocks) 2058 __field(xfs_rfsblock_t, rt_blocks) 2059 __field(xfs_rfsblock_t, attr_blocks) 2060 __field(xfs_extnum_t, data_extents) 2061 __field(xfs_extnum_t, rt_extents) 2062 __field(xfs_aextnum_t, attr_extents) 2063 ), 2064 TP_fast_assign( 2065 __entry->dev = sc->mp->m_super->s_dev; 2066 __entry->ino = sc->sm->sm_ino; 2067 __entry->data_blocks = data_blocks; 2068 __entry->rt_blocks = rt_blocks; 2069 __entry->attr_blocks = attr_blocks; 2070 __entry->data_extents = data_extents; 2071 __entry->rt_extents = rt_extents; 2072 __entry->attr_extents = attr_extents; 2073 ), 2074 TP_printk("dev %d:%d ino 0x%llx dblocks 0x%llx rtblocks 0x%llx ablocks 0x%llx dextents %llu rtextents %llu aextents %u", 2075 MAJOR(__entry->dev), MINOR(__entry->dev), 2076 __entry->ino, 2077 __entry->data_blocks, 2078 __entry->rt_blocks, 2079 __entry->attr_blocks, 2080 __entry->data_extents, 2081 __entry->rt_extents, 2082 __entry->attr_extents) 2083 ); 2084 2085 TRACE_EVENT(xrep_dinode_findmode_dirent, 2086 TP_PROTO(struct xfs_scrub *sc, struct xfs_inode *dp, 2087 unsigned int ftype), 2088 TP_ARGS(sc, dp, ftype), 2089 TP_STRUCT__entry( 2090 __field(dev_t, dev) 2091 __field(xfs_ino_t, ino) 2092 __field(xfs_ino_t, parent_ino) 2093 __field(unsigned int, ftype) 2094 ), 2095 TP_fast_assign( 2096 __entry->dev = sc->mp->m_super->s_dev; 2097 __entry->ino = sc->sm->sm_ino; 2098 __entry->parent_ino = dp->i_ino; 2099 __entry->ftype = ftype; 2100 ), 2101 TP_printk("dev %d:%d ino 0x%llx parent_ino 0x%llx ftype '%s'", 2102 MAJOR(__entry->dev), MINOR(__entry->dev), 2103 __entry->ino, 2104 __entry->parent_ino, 2105 __print_symbolic(__entry->ftype, XFS_DIR3_FTYPE_STR)) 2106 ); 2107 2108 TRACE_EVENT(xrep_dinode_findmode_dirent_inval, 2109 TP_PROTO(struct xfs_scrub *sc, struct xfs_inode *dp, 2110 unsigned int ftype, unsigned int found_ftype), 2111 TP_ARGS(sc, dp, ftype, found_ftype), 2112 TP_STRUCT__entry( 2113 __field(dev_t, dev) 2114 __field(xfs_ino_t, ino) 2115 __field(xfs_ino_t, parent_ino) 2116 __field(unsigned int, ftype) 2117 __field(unsigned int, found_ftype) 2118 ), 2119 TP_fast_assign( 2120 __entry->dev = sc->mp->m_super->s_dev; 2121 __entry->ino = sc->sm->sm_ino; 2122 __entry->parent_ino = dp->i_ino; 2123 __entry->ftype = ftype; 2124 __entry->found_ftype = found_ftype; 2125 ), 2126 TP_printk("dev %d:%d ino 0x%llx parent_ino 0x%llx ftype '%s' found_ftype '%s'", 2127 MAJOR(__entry->dev), MINOR(__entry->dev), 2128 __entry->ino, 2129 __entry->parent_ino, 2130 __print_symbolic(__entry->ftype, XFS_DIR3_FTYPE_STR), 2131 __print_symbolic(__entry->found_ftype, XFS_DIR3_FTYPE_STR)) 2132 ); 2133 2134 TRACE_EVENT(xrep_cow_mark_file_range, 2135 TP_PROTO(struct xfs_inode *ip, xfs_fsblock_t startblock, 2136 xfs_fileoff_t startoff, xfs_filblks_t blockcount), 2137 TP_ARGS(ip, startblock, startoff, blockcount), 2138 TP_STRUCT__entry( 2139 __field(dev_t, dev) 2140 __field(xfs_ino_t, ino) 2141 __field(xfs_fsblock_t, startblock) 2142 __field(xfs_fileoff_t, startoff) 2143 __field(xfs_filblks_t, blockcount) 2144 ), 2145 TP_fast_assign( 2146 __entry->dev = ip->i_mount->m_super->s_dev; 2147 __entry->ino = ip->i_ino; 2148 __entry->startoff = startoff; 2149 __entry->startblock = startblock; 2150 __entry->blockcount = blockcount; 2151 ), 2152 TP_printk("dev %d:%d ino 0x%llx fileoff 0x%llx startblock 0x%llx fsbcount 0x%llx", 2153 MAJOR(__entry->dev), MINOR(__entry->dev), 2154 __entry->ino, 2155 __entry->startoff, 2156 __entry->startblock, 2157 __entry->blockcount) 2158 ); 2159 2160 TRACE_EVENT(xrep_cow_replace_mapping, 2161 TP_PROTO(struct xfs_inode *ip, const struct xfs_bmbt_irec *irec, 2162 xfs_fsblock_t new_startblock, xfs_extlen_t new_blockcount), 2163 TP_ARGS(ip, irec, new_startblock, new_blockcount), 2164 TP_STRUCT__entry( 2165 __field(dev_t, dev) 2166 __field(xfs_ino_t, ino) 2167 __field(xfs_fsblock_t, startblock) 2168 __field(xfs_fileoff_t, startoff) 2169 __field(xfs_filblks_t, blockcount) 2170 __field(xfs_exntst_t, state) 2171 __field(xfs_fsblock_t, new_startblock) 2172 __field(xfs_extlen_t, new_blockcount) 2173 ), 2174 TP_fast_assign( 2175 __entry->dev = ip->i_mount->m_super->s_dev; 2176 __entry->ino = ip->i_ino; 2177 __entry->startoff = irec->br_startoff; 2178 __entry->startblock = irec->br_startblock; 2179 __entry->blockcount = irec->br_blockcount; 2180 __entry->state = irec->br_state; 2181 __entry->new_startblock = new_startblock; 2182 __entry->new_blockcount = new_blockcount; 2183 ), 2184 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", 2185 MAJOR(__entry->dev), MINOR(__entry->dev), 2186 __entry->ino, 2187 __entry->startoff, 2188 __entry->startblock, 2189 __entry->blockcount, 2190 __entry->state, 2191 __entry->new_startblock, 2192 __entry->new_blockcount) 2193 ); 2194 2195 TRACE_EVENT(xrep_cow_free_staging, 2196 TP_PROTO(struct xfs_perag *pag, xfs_agblock_t agbno, 2197 xfs_extlen_t blockcount), 2198 TP_ARGS(pag, agbno, blockcount), 2199 TP_STRUCT__entry( 2200 __field(dev_t, dev) 2201 __field(xfs_agnumber_t, agno) 2202 __field(xfs_agblock_t, agbno) 2203 __field(xfs_extlen_t, blockcount) 2204 ), 2205 TP_fast_assign( 2206 __entry->dev = pag->pag_mount->m_super->s_dev; 2207 __entry->agno = pag->pag_agno; 2208 __entry->agbno = agbno; 2209 __entry->blockcount = blockcount; 2210 ), 2211 TP_printk("dev %d:%d agno 0x%x agbno 0x%x fsbcount 0x%x", 2212 MAJOR(__entry->dev), MINOR(__entry->dev), 2213 __entry->agno, 2214 __entry->agbno, 2215 __entry->blockcount) 2216 ); 2217 2218 #ifdef CONFIG_XFS_QUOTA 2219 DECLARE_EVENT_CLASS(xrep_dquot_class, 2220 TP_PROTO(struct xfs_mount *mp, uint8_t type, uint32_t id), 2221 TP_ARGS(mp, type, id), 2222 TP_STRUCT__entry( 2223 __field(dev_t, dev) 2224 __field(uint8_t, type) 2225 __field(uint32_t, id) 2226 ), 2227 TP_fast_assign( 2228 __entry->dev = mp->m_super->s_dev; 2229 __entry->id = id; 2230 __entry->type = type; 2231 ), 2232 TP_printk("dev %d:%d type %s id 0x%x", 2233 MAJOR(__entry->dev), MINOR(__entry->dev), 2234 __print_flags(__entry->type, "|", XFS_DQTYPE_STRINGS), 2235 __entry->id) 2236 ); 2237 2238 #define DEFINE_XREP_DQUOT_EVENT(name) \ 2239 DEFINE_EVENT(xrep_dquot_class, name, \ 2240 TP_PROTO(struct xfs_mount *mp, uint8_t type, uint32_t id), \ 2241 TP_ARGS(mp, type, id)) 2242 DEFINE_XREP_DQUOT_EVENT(xrep_dquot_item); 2243 DEFINE_XREP_DQUOT_EVENT(xrep_disk_dquot); 2244 DEFINE_XREP_DQUOT_EVENT(xrep_dquot_item_fill_bmap_hole); 2245 DEFINE_XREP_DQUOT_EVENT(xrep_quotacheck_dquot); 2246 #endif /* CONFIG_XFS_QUOTA */ 2247 2248 DEFINE_SCRUB_NLINKS_DIFF_EVENT(xrep_nlinks_update_inode); 2249 DEFINE_SCRUB_NLINKS_DIFF_EVENT(xrep_nlinks_unfixable_inode); 2250 2251 TRACE_EVENT(xrep_rmap_live_update, 2252 TP_PROTO(struct xfs_mount *mp, xfs_agnumber_t agno, unsigned int op, 2253 const struct xfs_rmap_update_params *p), 2254 TP_ARGS(mp, agno, op, p), 2255 TP_STRUCT__entry( 2256 __field(dev_t, dev) 2257 __field(xfs_agnumber_t, agno) 2258 __field(unsigned int, op) 2259 __field(xfs_agblock_t, agbno) 2260 __field(xfs_extlen_t, len) 2261 __field(uint64_t, owner) 2262 __field(uint64_t, offset) 2263 __field(unsigned int, flags) 2264 ), 2265 TP_fast_assign( 2266 __entry->dev = mp->m_super->s_dev; 2267 __entry->agno = agno; 2268 __entry->op = op; 2269 __entry->agbno = p->startblock; 2270 __entry->len = p->blockcount; 2271 xfs_owner_info_unpack(&p->oinfo, &__entry->owner, 2272 &__entry->offset, &__entry->flags); 2273 if (p->unwritten) 2274 __entry->flags |= XFS_RMAP_UNWRITTEN; 2275 ), 2276 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", 2277 MAJOR(__entry->dev), MINOR(__entry->dev), 2278 __entry->agno, 2279 __entry->op, 2280 __entry->agbno, 2281 __entry->len, 2282 __entry->owner, 2283 __entry->offset, 2284 __entry->flags) 2285 ); 2286 2287 TRACE_EVENT(xrep_tempfile_create, 2288 TP_PROTO(struct xfs_scrub *sc), 2289 TP_ARGS(sc), 2290 TP_STRUCT__entry( 2291 __field(dev_t, dev) 2292 __field(xfs_ino_t, ino) 2293 __field(unsigned int, type) 2294 __field(xfs_agnumber_t, agno) 2295 __field(xfs_ino_t, inum) 2296 __field(unsigned int, gen) 2297 __field(unsigned int, flags) 2298 __field(xfs_ino_t, temp_inum) 2299 ), 2300 TP_fast_assign( 2301 __entry->dev = sc->mp->m_super->s_dev; 2302 __entry->ino = sc->file ? XFS_I(file_inode(sc->file))->i_ino : 0; 2303 __entry->type = sc->sm->sm_type; 2304 __entry->agno = sc->sm->sm_agno; 2305 __entry->inum = sc->sm->sm_ino; 2306 __entry->gen = sc->sm->sm_gen; 2307 __entry->flags = sc->sm->sm_flags; 2308 __entry->temp_inum = sc->tempip->i_ino; 2309 ), 2310 TP_printk("dev %d:%d ino 0x%llx type %s inum 0x%llx gen 0x%x flags 0x%x temp_inum 0x%llx", 2311 MAJOR(__entry->dev), MINOR(__entry->dev), 2312 __entry->ino, 2313 __print_symbolic(__entry->type, XFS_SCRUB_TYPE_STRINGS), 2314 __entry->inum, 2315 __entry->gen, 2316 __entry->flags, 2317 __entry->temp_inum) 2318 ); 2319 2320 DECLARE_EVENT_CLASS(xrep_tempfile_class, 2321 TP_PROTO(struct xfs_scrub *sc, int whichfork, 2322 struct xfs_bmbt_irec *irec), 2323 TP_ARGS(sc, whichfork, irec), 2324 TP_STRUCT__entry( 2325 __field(dev_t, dev) 2326 __field(xfs_ino_t, ino) 2327 __field(int, whichfork) 2328 __field(xfs_fileoff_t, lblk) 2329 __field(xfs_filblks_t, len) 2330 __field(xfs_fsblock_t, pblk) 2331 __field(int, state) 2332 ), 2333 TP_fast_assign( 2334 __entry->dev = sc->mp->m_super->s_dev; 2335 __entry->ino = sc->tempip->i_ino; 2336 __entry->whichfork = whichfork; 2337 __entry->lblk = irec->br_startoff; 2338 __entry->len = irec->br_blockcount; 2339 __entry->pblk = irec->br_startblock; 2340 __entry->state = irec->br_state; 2341 ), 2342 TP_printk("dev %d:%d ino 0x%llx whichfork %s fileoff 0x%llx fsbcount 0x%llx startblock 0x%llx state %d", 2343 MAJOR(__entry->dev), MINOR(__entry->dev), 2344 __entry->ino, 2345 __print_symbolic(__entry->whichfork, XFS_WHICHFORK_STRINGS), 2346 __entry->lblk, 2347 __entry->len, 2348 __entry->pblk, 2349 __entry->state) 2350 ); 2351 #define DEFINE_XREP_TEMPFILE_EVENT(name) \ 2352 DEFINE_EVENT(xrep_tempfile_class, name, \ 2353 TP_PROTO(struct xfs_scrub *sc, int whichfork, \ 2354 struct xfs_bmbt_irec *irec), \ 2355 TP_ARGS(sc, whichfork, irec)) 2356 DEFINE_XREP_TEMPFILE_EVENT(xrep_tempfile_prealloc); 2357 DEFINE_XREP_TEMPFILE_EVENT(xrep_tempfile_copyin); 2358 2359 TRACE_EVENT(xreap_ifork_extent, 2360 TP_PROTO(struct xfs_scrub *sc, struct xfs_inode *ip, int whichfork, 2361 const struct xfs_bmbt_irec *irec), 2362 TP_ARGS(sc, ip, whichfork, irec), 2363 TP_STRUCT__entry( 2364 __field(dev_t, dev) 2365 __field(xfs_ino_t, ino) 2366 __field(int, whichfork) 2367 __field(xfs_fileoff_t, fileoff) 2368 __field(xfs_filblks_t, len) 2369 __field(xfs_agnumber_t, agno) 2370 __field(xfs_agblock_t, agbno) 2371 __field(int, state) 2372 ), 2373 TP_fast_assign( 2374 __entry->dev = sc->mp->m_super->s_dev; 2375 __entry->ino = ip->i_ino; 2376 __entry->whichfork = whichfork; 2377 __entry->fileoff = irec->br_startoff; 2378 __entry->len = irec->br_blockcount; 2379 __entry->agno = XFS_FSB_TO_AGNO(sc->mp, irec->br_startblock); 2380 __entry->agbno = XFS_FSB_TO_AGBNO(sc->mp, irec->br_startblock); 2381 __entry->state = irec->br_state; 2382 ), 2383 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", 2384 MAJOR(__entry->dev), MINOR(__entry->dev), 2385 __entry->ino, 2386 __print_symbolic(__entry->whichfork, XFS_WHICHFORK_STRINGS), 2387 __entry->agno, 2388 __entry->agbno, 2389 __entry->fileoff, 2390 __entry->len, 2391 __entry->state) 2392 ); 2393 2394 TRACE_EVENT(xreap_bmapi_binval_scan, 2395 TP_PROTO(struct xfs_scrub *sc, const struct xfs_bmbt_irec *irec, 2396 xfs_extlen_t scan_blocks), 2397 TP_ARGS(sc, irec, scan_blocks), 2398 TP_STRUCT__entry( 2399 __field(dev_t, dev) 2400 __field(xfs_filblks_t, len) 2401 __field(xfs_agnumber_t, agno) 2402 __field(xfs_agblock_t, agbno) 2403 __field(xfs_extlen_t, scan_blocks) 2404 ), 2405 TP_fast_assign( 2406 __entry->dev = sc->mp->m_super->s_dev; 2407 __entry->len = irec->br_blockcount; 2408 __entry->agno = XFS_FSB_TO_AGNO(sc->mp, irec->br_startblock); 2409 __entry->agbno = XFS_FSB_TO_AGBNO(sc->mp, irec->br_startblock); 2410 __entry->scan_blocks = scan_blocks; 2411 ), 2412 TP_printk("dev %d:%d agno 0x%x agbno 0x%x fsbcount 0x%llx scan_blocks 0x%x", 2413 MAJOR(__entry->dev), MINOR(__entry->dev), 2414 __entry->agno, 2415 __entry->agbno, 2416 __entry->len, 2417 __entry->scan_blocks) 2418 ); 2419 2420 TRACE_EVENT(xrep_xattr_recover_leafblock, 2421 TP_PROTO(struct xfs_inode *ip, xfs_dablk_t dabno, uint16_t magic), 2422 TP_ARGS(ip, dabno, magic), 2423 TP_STRUCT__entry( 2424 __field(dev_t, dev) 2425 __field(xfs_ino_t, ino) 2426 __field(xfs_dablk_t, dabno) 2427 __field(uint16_t, magic) 2428 ), 2429 TP_fast_assign( 2430 __entry->dev = ip->i_mount->m_super->s_dev; 2431 __entry->ino = ip->i_ino; 2432 __entry->dabno = dabno; 2433 __entry->magic = magic; 2434 ), 2435 TP_printk("dev %d:%d ino 0x%llx dablk 0x%x magic 0x%x", 2436 MAJOR(__entry->dev), MINOR(__entry->dev), 2437 __entry->ino, 2438 __entry->dabno, 2439 __entry->magic) 2440 ); 2441 2442 DECLARE_EVENT_CLASS(xrep_xattr_salvage_class, 2443 TP_PROTO(struct xfs_inode *ip, unsigned int flags, char *name, 2444 unsigned int namelen, unsigned int valuelen), 2445 TP_ARGS(ip, flags, name, namelen, valuelen), 2446 TP_STRUCT__entry( 2447 __field(dev_t, dev) 2448 __field(xfs_ino_t, ino) 2449 __field(unsigned int, flags) 2450 __field(unsigned int, namelen) 2451 __dynamic_array(char, name, namelen) 2452 __field(unsigned int, valuelen) 2453 ), 2454 TP_fast_assign( 2455 __entry->dev = ip->i_mount->m_super->s_dev; 2456 __entry->ino = ip->i_ino; 2457 __entry->flags = flags; 2458 __entry->namelen = namelen; 2459 memcpy(__get_str(name), name, namelen); 2460 __entry->valuelen = valuelen; 2461 ), 2462 TP_printk("dev %d:%d ino 0x%llx flags %s name '%.*s' valuelen 0x%x", 2463 MAJOR(__entry->dev), MINOR(__entry->dev), 2464 __entry->ino, 2465 __print_flags(__entry->flags, "|", XFS_ATTR_NAMESPACE_STR), 2466 __entry->namelen, 2467 __get_str(name), 2468 __entry->valuelen) 2469 ); 2470 #define DEFINE_XREP_XATTR_SALVAGE_EVENT(name) \ 2471 DEFINE_EVENT(xrep_xattr_salvage_class, name, \ 2472 TP_PROTO(struct xfs_inode *ip, unsigned int flags, char *name, \ 2473 unsigned int namelen, unsigned int valuelen), \ 2474 TP_ARGS(ip, flags, name, namelen, valuelen)) 2475 DEFINE_XREP_XATTR_SALVAGE_EVENT(xrep_xattr_salvage_rec); 2476 DEFINE_XREP_XATTR_SALVAGE_EVENT(xrep_xattr_insert_rec); 2477 2478 TRACE_EVENT(xrep_xattr_class, 2479 TP_PROTO(struct xfs_inode *ip, struct xfs_inode *arg_ip), 2480 TP_ARGS(ip, arg_ip), 2481 TP_STRUCT__entry( 2482 __field(dev_t, dev) 2483 __field(xfs_ino_t, ino) 2484 __field(xfs_ino_t, src_ino) 2485 ), 2486 TP_fast_assign( 2487 __entry->dev = ip->i_mount->m_super->s_dev; 2488 __entry->ino = ip->i_ino; 2489 __entry->src_ino = arg_ip->i_ino; 2490 ), 2491 TP_printk("dev %d:%d ino 0x%llx src 0x%llx", 2492 MAJOR(__entry->dev), MINOR(__entry->dev), 2493 __entry->ino, 2494 __entry->src_ino) 2495 ) 2496 #define DEFINE_XREP_XATTR_EVENT(name) \ 2497 DEFINE_EVENT(xrep_xattr_class, name, \ 2498 TP_PROTO(struct xfs_inode *ip, struct xfs_inode *arg_ip), \ 2499 TP_ARGS(ip, arg_ip)) 2500 DEFINE_XREP_XATTR_EVENT(xrep_xattr_rebuild_tree); 2501 DEFINE_XREP_XATTR_EVENT(xrep_xattr_reset_fork); 2502 2503 TRACE_EVENT(xrep_dir_recover_dirblock, 2504 TP_PROTO(struct xfs_inode *dp, xfs_dablk_t dabno, uint32_t magic, 2505 uint32_t magic_guess), 2506 TP_ARGS(dp, dabno, magic, magic_guess), 2507 TP_STRUCT__entry( 2508 __field(dev_t, dev) 2509 __field(xfs_ino_t, dir_ino) 2510 __field(xfs_dablk_t, dabno) 2511 __field(uint32_t, magic) 2512 __field(uint32_t, magic_guess) 2513 ), 2514 TP_fast_assign( 2515 __entry->dev = dp->i_mount->m_super->s_dev; 2516 __entry->dir_ino = dp->i_ino; 2517 __entry->dabno = dabno; 2518 __entry->magic = magic; 2519 __entry->magic_guess = magic_guess; 2520 ), 2521 TP_printk("dev %d:%d dir 0x%llx dablk 0x%x magic 0x%x magic_guess 0x%x", 2522 MAJOR(__entry->dev), MINOR(__entry->dev), 2523 __entry->dir_ino, 2524 __entry->dabno, 2525 __entry->magic, 2526 __entry->magic_guess) 2527 ); 2528 2529 DECLARE_EVENT_CLASS(xrep_dir_class, 2530 TP_PROTO(struct xfs_inode *dp, xfs_ino_t parent_ino), 2531 TP_ARGS(dp, parent_ino), 2532 TP_STRUCT__entry( 2533 __field(dev_t, dev) 2534 __field(xfs_ino_t, dir_ino) 2535 __field(xfs_ino_t, parent_ino) 2536 ), 2537 TP_fast_assign( 2538 __entry->dev = dp->i_mount->m_super->s_dev; 2539 __entry->dir_ino = dp->i_ino; 2540 __entry->parent_ino = parent_ino; 2541 ), 2542 TP_printk("dev %d:%d dir 0x%llx parent 0x%llx", 2543 MAJOR(__entry->dev), MINOR(__entry->dev), 2544 __entry->dir_ino, 2545 __entry->parent_ino) 2546 ) 2547 #define DEFINE_XREP_DIR_EVENT(name) \ 2548 DEFINE_EVENT(xrep_dir_class, name, \ 2549 TP_PROTO(struct xfs_inode *dp, xfs_ino_t parent_ino), \ 2550 TP_ARGS(dp, parent_ino)) 2551 DEFINE_XREP_DIR_EVENT(xrep_dir_rebuild_tree); 2552 DEFINE_XREP_DIR_EVENT(xrep_dir_reset_fork); 2553 DEFINE_XREP_DIR_EVENT(xrep_parent_reset_dotdot); 2554 2555 DECLARE_EVENT_CLASS(xrep_dirent_class, 2556 TP_PROTO(struct xfs_inode *dp, const struct xfs_name *name, 2557 xfs_ino_t ino), 2558 TP_ARGS(dp, name, ino), 2559 TP_STRUCT__entry( 2560 __field(dev_t, dev) 2561 __field(xfs_ino_t, dir_ino) 2562 __field(unsigned int, namelen) 2563 __dynamic_array(char, name, name->len) 2564 __field(xfs_ino_t, ino) 2565 __field(uint8_t, ftype) 2566 ), 2567 TP_fast_assign( 2568 __entry->dev = dp->i_mount->m_super->s_dev; 2569 __entry->dir_ino = dp->i_ino; 2570 __entry->namelen = name->len; 2571 memcpy(__get_str(name), name->name, name->len); 2572 __entry->ino = ino; 2573 __entry->ftype = name->type; 2574 ), 2575 TP_printk("dev %d:%d dir 0x%llx ftype %s name '%.*s' ino 0x%llx", 2576 MAJOR(__entry->dev), MINOR(__entry->dev), 2577 __entry->dir_ino, 2578 __print_symbolic(__entry->ftype, XFS_DIR3_FTYPE_STR), 2579 __entry->namelen, 2580 __get_str(name), 2581 __entry->ino) 2582 ) 2583 #define DEFINE_XREP_DIRENT_EVENT(name) \ 2584 DEFINE_EVENT(xrep_dirent_class, name, \ 2585 TP_PROTO(struct xfs_inode *dp, const struct xfs_name *name, \ 2586 xfs_ino_t ino), \ 2587 TP_ARGS(dp, name, ino)) 2588 DEFINE_XREP_DIRENT_EVENT(xrep_dir_salvage_entry); 2589 DEFINE_XREP_DIRENT_EVENT(xrep_dir_stash_createname); 2590 DEFINE_XREP_DIRENT_EVENT(xrep_dir_replay_createname); 2591 DEFINE_XREP_DIRENT_EVENT(xrep_adoption_reparent); 2592 2593 DECLARE_EVENT_CLASS(xrep_adoption_class, 2594 TP_PROTO(struct xfs_inode *dp, struct xfs_inode *ip, bool moved), 2595 TP_ARGS(dp, ip, moved), 2596 TP_STRUCT__entry( 2597 __field(dev_t, dev) 2598 __field(xfs_ino_t, dir_ino) 2599 __field(xfs_ino_t, child_ino) 2600 __field(bool, moved) 2601 ), 2602 TP_fast_assign( 2603 __entry->dev = dp->i_mount->m_super->s_dev; 2604 __entry->dir_ino = dp->i_ino; 2605 __entry->child_ino = ip->i_ino; 2606 __entry->moved = moved; 2607 ), 2608 TP_printk("dev %d:%d dir 0x%llx child 0x%llx moved? %d", 2609 MAJOR(__entry->dev), MINOR(__entry->dev), 2610 __entry->dir_ino, 2611 __entry->child_ino, 2612 __entry->moved) 2613 ); 2614 #define DEFINE_XREP_ADOPTION_EVENT(name) \ 2615 DEFINE_EVENT(xrep_adoption_class, name, \ 2616 TP_PROTO(struct xfs_inode *dp, struct xfs_inode *ip, bool moved), \ 2617 TP_ARGS(dp, ip, moved)) 2618 DEFINE_XREP_ADOPTION_EVENT(xrep_adoption_trans_roll); 2619 2620 DECLARE_EVENT_CLASS(xrep_parent_salvage_class, 2621 TP_PROTO(struct xfs_inode *dp, xfs_ino_t ino), 2622 TP_ARGS(dp, ino), 2623 TP_STRUCT__entry( 2624 __field(dev_t, dev) 2625 __field(xfs_ino_t, dir_ino) 2626 __field(xfs_ino_t, ino) 2627 ), 2628 TP_fast_assign( 2629 __entry->dev = dp->i_mount->m_super->s_dev; 2630 __entry->dir_ino = dp->i_ino; 2631 __entry->ino = ino; 2632 ), 2633 TP_printk("dev %d:%d dir 0x%llx parent 0x%llx", 2634 MAJOR(__entry->dev), MINOR(__entry->dev), 2635 __entry->dir_ino, 2636 __entry->ino) 2637 ) 2638 #define DEFINE_XREP_PARENT_SALVAGE_EVENT(name) \ 2639 DEFINE_EVENT(xrep_parent_salvage_class, name, \ 2640 TP_PROTO(struct xfs_inode *dp, xfs_ino_t ino), \ 2641 TP_ARGS(dp, ino)) 2642 DEFINE_XREP_PARENT_SALVAGE_EVENT(xrep_dir_salvaged_parent); 2643 DEFINE_XREP_PARENT_SALVAGE_EVENT(xrep_findparent_dirent); 2644 DEFINE_XREP_PARENT_SALVAGE_EVENT(xrep_findparent_from_dcache); 2645 2646 TRACE_EVENT(xrep_nlinks_set_record, 2647 TP_PROTO(struct xfs_mount *mp, xfs_ino_t ino, 2648 const struct xchk_nlink *obs), 2649 TP_ARGS(mp, ino, obs), 2650 TP_STRUCT__entry( 2651 __field(dev_t, dev) 2652 __field(xfs_ino_t, ino) 2653 __field(xfs_nlink_t, parents) 2654 __field(xfs_nlink_t, backrefs) 2655 __field(xfs_nlink_t, children) 2656 ), 2657 TP_fast_assign( 2658 __entry->dev = mp->m_super->s_dev; 2659 __entry->ino = ino; 2660 __entry->parents = obs->parents; 2661 __entry->backrefs = obs->backrefs; 2662 __entry->children = obs->children; 2663 ), 2664 TP_printk("dev %d:%d ino 0x%llx parents %u backrefs %u children %u", 2665 MAJOR(__entry->dev), MINOR(__entry->dev), 2666 __entry->ino, 2667 __entry->parents, 2668 __entry->backrefs, 2669 __entry->children) 2670 ); 2671 2672 #endif /* IS_ENABLED(CONFIG_XFS_ONLINE_REPAIR) */ 2673 2674 #endif /* _TRACE_XFS_SCRUB_TRACE_H */ 2675 2676 #undef TRACE_INCLUDE_PATH 2677 #define TRACE_INCLUDE_PATH . 2678 #define TRACE_INCLUDE_FILE scrub/trace 2679 #include <trace/define_trace.h> 2680