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