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 = I_INO(ip); 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 = I_INO(ip); 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 = I_INO(sc->ip); 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 = I_INO(sc->ip); 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->mp->m_super->s_dev; 483 __entry->dqtype = cursor->dqtype; 484 __entry->ino = I_INO(cursor->quota_ip); 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 = I_INO(cur->bc_ino.ip); 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 = I_INO(sc->ip); 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_agblock_t map_agblock, 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_agblock, 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_agblock_t, map_agblock) 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_agblock = map_agblock; 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 agblock 0x%x 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_agblock, 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 = I_INO(ip); 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 ), 976 TP_fast_assign( 977 __entry->ino = file_inode(xf->file)->i_ino; 978 ), 979 TP_printk("xfino 0x%lx", 980 __entry->ino) 981 ); 982 983 TRACE_EVENT(xfile_destroy, 984 TP_PROTO(struct xfile *xf), 985 TP_ARGS(xf), 986 TP_STRUCT__entry( 987 __field(unsigned long, ino) 988 __field(unsigned long long, bytes) 989 __field(loff_t, size) 990 ), 991 TP_fast_assign( 992 struct inode *inode = file_inode(xf->file); 993 994 __entry->ino = inode->i_ino; 995 __entry->bytes = inode->i_blocks << SECTOR_SHIFT; 996 __entry->size = i_size_read(inode); 997 ), 998 TP_printk("xfino 0x%lx mem_bytes 0x%llx isize 0x%llx", 999 __entry->ino, 1000 __entry->bytes, 1001 __entry->size) 1002 ); 1003 1004 DECLARE_EVENT_CLASS(xfile_class, 1005 TP_PROTO(struct xfile *xf, loff_t pos, unsigned long long bytecount), 1006 TP_ARGS(xf, pos, bytecount), 1007 TP_STRUCT__entry( 1008 __field(unsigned long, ino) 1009 __field(unsigned long long, bytes_used) 1010 __field(loff_t, pos) 1011 __field(loff_t, size) 1012 __field(unsigned long long, bytecount) 1013 ), 1014 TP_fast_assign( 1015 struct inode *inode = file_inode(xf->file); 1016 1017 __entry->ino = inode->i_ino; 1018 __entry->bytes_used = inode->i_blocks << SECTOR_SHIFT; 1019 __entry->pos = pos; 1020 __entry->size = i_size_read(inode); 1021 __entry->bytecount = bytecount; 1022 ), 1023 TP_printk("xfino 0x%lx mem_bytes 0x%llx pos 0x%llx bytecount 0x%llx isize 0x%llx", 1024 __entry->ino, 1025 __entry->bytes_used, 1026 __entry->pos, 1027 __entry->bytecount, 1028 __entry->size) 1029 ); 1030 #define DEFINE_XFILE_EVENT(name) \ 1031 DEFINE_EVENT(xfile_class, name, \ 1032 TP_PROTO(struct xfile *xf, loff_t pos, unsigned long long bytecount), \ 1033 TP_ARGS(xf, pos, bytecount)) 1034 DEFINE_XFILE_EVENT(xfile_load); 1035 DEFINE_XFILE_EVENT(xfile_store); 1036 DEFINE_XFILE_EVENT(xfile_seek_data); 1037 DEFINE_XFILE_EVENT(xfile_get_folio); 1038 DEFINE_XFILE_EVENT(xfile_put_folio); 1039 DEFINE_XFILE_EVENT(xfile_discard); 1040 1041 TRACE_EVENT(xfarray_create, 1042 TP_PROTO(struct xfarray *xfa, unsigned long long required_capacity), 1043 TP_ARGS(xfa, required_capacity), 1044 TP_STRUCT__entry( 1045 __field(unsigned long, ino) 1046 __field(uint64_t, max_nr) 1047 __field(size_t, obj_size) 1048 __field(int, obj_size_log) 1049 __field(unsigned long long, required_capacity) 1050 ), 1051 TP_fast_assign( 1052 __entry->max_nr = xfa->max_nr; 1053 __entry->obj_size = xfa->obj_size; 1054 __entry->obj_size_log = xfa->obj_size_log; 1055 __entry->ino = file_inode(xfa->xfile->file)->i_ino; 1056 __entry->required_capacity = required_capacity; 1057 ), 1058 TP_printk("xfino 0x%lx max_nr %llu reqd_nr %llu objsz %zu objszlog %d", 1059 __entry->ino, 1060 __entry->max_nr, 1061 __entry->required_capacity, 1062 __entry->obj_size, 1063 __entry->obj_size_log) 1064 ); 1065 1066 TRACE_EVENT(xfarray_isort, 1067 TP_PROTO(struct xfarray_sortinfo *si, uint64_t lo, uint64_t hi), 1068 TP_ARGS(si, lo, hi), 1069 TP_STRUCT__entry( 1070 __field(unsigned long, ino) 1071 __field(unsigned long long, lo) 1072 __field(unsigned long long, hi) 1073 ), 1074 TP_fast_assign( 1075 __entry->ino = file_inode(si->array->xfile->file)->i_ino; 1076 __entry->lo = lo; 1077 __entry->hi = hi; 1078 ), 1079 TP_printk("xfino 0x%lx lo %llu hi %llu elts %llu", 1080 __entry->ino, 1081 __entry->lo, 1082 __entry->hi, 1083 __entry->hi - __entry->lo) 1084 ); 1085 1086 TRACE_EVENT(xfarray_foliosort, 1087 TP_PROTO(struct xfarray_sortinfo *si, uint64_t lo, uint64_t hi), 1088 TP_ARGS(si, lo, hi), 1089 TP_STRUCT__entry( 1090 __field(unsigned long, ino) 1091 __field(unsigned long long, lo) 1092 __field(unsigned long long, hi) 1093 ), 1094 TP_fast_assign( 1095 __entry->ino = file_inode(si->array->xfile->file)->i_ino; 1096 __entry->lo = lo; 1097 __entry->hi = hi; 1098 ), 1099 TP_printk("xfino 0x%lx lo %llu hi %llu elts %llu", 1100 __entry->ino, 1101 __entry->lo, 1102 __entry->hi, 1103 __entry->hi - __entry->lo) 1104 ); 1105 1106 TRACE_EVENT(xfarray_qsort, 1107 TP_PROTO(struct xfarray_sortinfo *si, uint64_t lo, uint64_t hi), 1108 TP_ARGS(si, lo, hi), 1109 TP_STRUCT__entry( 1110 __field(unsigned long, ino) 1111 __field(unsigned long long, lo) 1112 __field(unsigned long long, hi) 1113 __field(int, stack_depth) 1114 __field(int, max_stack_depth) 1115 ), 1116 TP_fast_assign( 1117 __entry->ino = file_inode(si->array->xfile->file)->i_ino; 1118 __entry->lo = lo; 1119 __entry->hi = hi; 1120 __entry->stack_depth = si->stack_depth; 1121 __entry->max_stack_depth = si->max_stack_depth; 1122 ), 1123 TP_printk("xfino 0x%lx lo %llu hi %llu elts %llu stack %d/%d", 1124 __entry->ino, 1125 __entry->lo, 1126 __entry->hi, 1127 __entry->hi - __entry->lo, 1128 __entry->stack_depth, 1129 __entry->max_stack_depth) 1130 ); 1131 1132 TRACE_EVENT(xfarray_sort, 1133 TP_PROTO(struct xfarray_sortinfo *si, size_t bytes), 1134 TP_ARGS(si, bytes), 1135 TP_STRUCT__entry( 1136 __field(unsigned long, ino) 1137 __field(unsigned long long, nr) 1138 __field(size_t, obj_size) 1139 __field(size_t, bytes) 1140 __field(unsigned int, max_stack_depth) 1141 ), 1142 TP_fast_assign( 1143 __entry->nr = si->array->nr; 1144 __entry->obj_size = si->array->obj_size; 1145 __entry->ino = file_inode(si->array->xfile->file)->i_ino; 1146 __entry->bytes = bytes; 1147 __entry->max_stack_depth = si->max_stack_depth; 1148 ), 1149 TP_printk("xfino 0x%lx nr %llu objsz %zu stack %u bytes %zu", 1150 __entry->ino, 1151 __entry->nr, 1152 __entry->obj_size, 1153 __entry->max_stack_depth, 1154 __entry->bytes) 1155 ); 1156 1157 TRACE_EVENT(xfarray_sort_scan, 1158 TP_PROTO(struct xfarray_sortinfo *si, unsigned long long idx), 1159 TP_ARGS(si, idx), 1160 TP_STRUCT__entry( 1161 __field(unsigned long, ino) 1162 __field(unsigned long long, nr) 1163 __field(size_t, obj_size) 1164 __field(unsigned long long, idx) 1165 __field(unsigned long long, folio_pos) 1166 __field(unsigned long, folio_bytes) 1167 __field(unsigned long long, first_idx) 1168 __field(unsigned long long, last_idx) 1169 ), 1170 TP_fast_assign( 1171 __entry->nr = si->array->nr; 1172 __entry->obj_size = si->array->obj_size; 1173 __entry->ino = file_inode(si->array->xfile->file)->i_ino; 1174 __entry->idx = idx; 1175 if (si->folio) { 1176 __entry->folio_pos = folio_pos(si->folio); 1177 __entry->folio_bytes = folio_size(si->folio); 1178 __entry->first_idx = si->first_folio_idx; 1179 __entry->last_idx = si->last_folio_idx; 1180 } else { 1181 __entry->folio_pos = 0; 1182 __entry->folio_bytes = 0; 1183 __entry->first_idx = 0; 1184 __entry->last_idx = 0; 1185 } 1186 ), 1187 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", 1188 __entry->ino, 1189 __entry->nr, 1190 __entry->obj_size, 1191 __entry->idx, 1192 __entry->folio_pos, 1193 __entry->folio_bytes, 1194 __entry->first_idx, 1195 __entry->last_idx) 1196 ); 1197 1198 TRACE_EVENT(xfarray_sort_stats, 1199 TP_PROTO(struct xfarray_sortinfo *si, int error), 1200 TP_ARGS(si, error), 1201 TP_STRUCT__entry( 1202 __field(unsigned long, ino) 1203 #ifdef DEBUG 1204 __field(unsigned long long, loads) 1205 __field(unsigned long long, stores) 1206 __field(unsigned long long, compares) 1207 __field(unsigned long long, heapsorts) 1208 #endif 1209 __field(unsigned int, max_stack_depth) 1210 __field(unsigned int, max_stack_used) 1211 __field(int, error) 1212 ), 1213 TP_fast_assign( 1214 __entry->ino = file_inode(si->array->xfile->file)->i_ino; 1215 #ifdef DEBUG 1216 __entry->loads = si->loads; 1217 __entry->stores = si->stores; 1218 __entry->compares = si->compares; 1219 __entry->heapsorts = si->heapsorts; 1220 #endif 1221 __entry->max_stack_depth = si->max_stack_depth; 1222 __entry->max_stack_used = si->max_stack_used; 1223 __entry->error = error; 1224 ), 1225 TP_printk( 1226 #ifdef DEBUG 1227 "xfino 0x%lx loads %llu stores %llu compares %llu heapsorts %llu stack_depth %u/%u error %d", 1228 #else 1229 "xfino 0x%lx stack_depth %u/%u error %d", 1230 #endif 1231 __entry->ino, 1232 #ifdef DEBUG 1233 __entry->loads, 1234 __entry->stores, 1235 __entry->compares, 1236 __entry->heapsorts, 1237 #endif 1238 __entry->max_stack_used, 1239 __entry->max_stack_depth, 1240 __entry->error) 1241 ); 1242 1243 #ifdef CONFIG_XFS_RT 1244 TRACE_EVENT(xchk_rtsum_record_free, 1245 TP_PROTO(struct xfs_mount *mp, xfs_rtxnum_t start, 1246 xfs_rtbxlen_t len, unsigned int log, loff_t pos, 1247 xfs_suminfo_t value), 1248 TP_ARGS(mp, start, len, log, pos, value), 1249 TP_STRUCT__entry( 1250 __field(dev_t, dev) 1251 __field(dev_t, rtdev) 1252 __field(xfs_rtxnum_t, start) 1253 __field(unsigned long long, len) 1254 __field(unsigned int, log) 1255 __field(loff_t, pos) 1256 __field(xfs_suminfo_t, value) 1257 ), 1258 TP_fast_assign( 1259 __entry->dev = mp->m_super->s_dev; 1260 __entry->rtdev = mp->m_rtdev_targp->bt_dev; 1261 __entry->start = start; 1262 __entry->len = len; 1263 __entry->log = log; 1264 __entry->pos = pos; 1265 __entry->value = value; 1266 ), 1267 TP_printk("dev %d:%d rtdev %d:%d rtx 0x%llx rtxcount 0x%llx log %u rsumpos 0x%llx sumcount %u", 1268 MAJOR(__entry->dev), MINOR(__entry->dev), 1269 MAJOR(__entry->rtdev), MINOR(__entry->rtdev), 1270 __entry->start, 1271 __entry->len, 1272 __entry->log, 1273 __entry->pos, 1274 __entry->value) 1275 ); 1276 #endif /* CONFIG_XFS_RT */ 1277 1278 DECLARE_EVENT_CLASS(xchk_iscan_class, 1279 TP_PROTO(struct xchk_iscan *iscan), 1280 TP_ARGS(iscan), 1281 TP_STRUCT__entry( 1282 __field(dev_t, dev) 1283 __field(xfs_ino_t, cursor) 1284 __field(xfs_ino_t, visited) 1285 ), 1286 TP_fast_assign( 1287 __entry->dev = iscan->sc->mp->m_super->s_dev; 1288 __entry->cursor = iscan->cursor_ino; 1289 __entry->visited = iscan->__visited_ino; 1290 ), 1291 TP_printk("dev %d:%d iscan cursor 0x%llx visited 0x%llx", 1292 MAJOR(__entry->dev), MINOR(__entry->dev), 1293 __entry->cursor, 1294 __entry->visited) 1295 ) 1296 #define DEFINE_ISCAN_EVENT(name) \ 1297 DEFINE_EVENT(xchk_iscan_class, name, \ 1298 TP_PROTO(struct xchk_iscan *iscan), \ 1299 TP_ARGS(iscan)) 1300 DEFINE_ISCAN_EVENT(xchk_iscan_move_cursor); 1301 DEFINE_ISCAN_EVENT(xchk_iscan_visit); 1302 DEFINE_ISCAN_EVENT(xchk_iscan_skip); 1303 DEFINE_ISCAN_EVENT(xchk_iscan_advance_ag); 1304 1305 DECLARE_EVENT_CLASS(xchk_iscan_ino_class, 1306 TP_PROTO(struct xchk_iscan *iscan, xfs_ino_t ino), 1307 TP_ARGS(iscan, ino), 1308 TP_STRUCT__entry( 1309 __field(dev_t, dev) 1310 __field(xfs_ino_t, startino) 1311 __field(xfs_ino_t, cursor) 1312 __field(xfs_ino_t, visited) 1313 __field(xfs_ino_t, ino) 1314 ), 1315 TP_fast_assign( 1316 __entry->dev = iscan->sc->mp->m_super->s_dev; 1317 __entry->startino = iscan->scan_start_ino; 1318 __entry->cursor = iscan->cursor_ino; 1319 __entry->visited = iscan->__visited_ino; 1320 __entry->ino = ino; 1321 ), 1322 TP_printk("dev %d:%d iscan start 0x%llx cursor 0x%llx visited 0x%llx ino 0x%llx", 1323 MAJOR(__entry->dev), MINOR(__entry->dev), 1324 __entry->startino, 1325 __entry->cursor, 1326 __entry->visited, 1327 __entry->ino) 1328 ) 1329 #define DEFINE_ISCAN_INO_EVENT(name) \ 1330 DEFINE_EVENT(xchk_iscan_ino_class, name, \ 1331 TP_PROTO(struct xchk_iscan *iscan, xfs_ino_t ino), \ 1332 TP_ARGS(iscan, ino)) 1333 DEFINE_ISCAN_INO_EVENT(xchk_iscan_want_live_update); 1334 DEFINE_ISCAN_INO_EVENT(xchk_iscan_start); 1335 1336 TRACE_EVENT(xchk_iscan_iget, 1337 TP_PROTO(struct xchk_iscan *iscan, int error), 1338 TP_ARGS(iscan, error), 1339 TP_STRUCT__entry( 1340 __field(dev_t, dev) 1341 __field(xfs_ino_t, cursor) 1342 __field(xfs_ino_t, visited) 1343 __field(int, error) 1344 ), 1345 TP_fast_assign( 1346 __entry->dev = iscan->sc->mp->m_super->s_dev; 1347 __entry->cursor = iscan->cursor_ino; 1348 __entry->visited = iscan->__visited_ino; 1349 __entry->error = error; 1350 ), 1351 TP_printk("dev %d:%d iscan cursor 0x%llx visited 0x%llx error %d", 1352 MAJOR(__entry->dev), MINOR(__entry->dev), 1353 __entry->cursor, 1354 __entry->visited, 1355 __entry->error) 1356 ); 1357 1358 TRACE_EVENT(xchk_iscan_iget_batch, 1359 TP_PROTO(struct xfs_mount *mp, struct xchk_iscan *iscan, 1360 unsigned int nr, unsigned int avail), 1361 TP_ARGS(mp, iscan, nr, avail), 1362 TP_STRUCT__entry( 1363 __field(dev_t, dev) 1364 __field(xfs_ino_t, cursor) 1365 __field(xfs_ino_t, visited) 1366 __field(unsigned int, nr) 1367 __field(unsigned int, avail) 1368 __field(unsigned int, unavail) 1369 __field(xfs_ino_t, batch_ino) 1370 __field(unsigned long long, skipmask) 1371 ), 1372 TP_fast_assign( 1373 __entry->dev = mp->m_super->s_dev; 1374 __entry->cursor = iscan->cursor_ino; 1375 __entry->visited = iscan->__visited_ino; 1376 __entry->nr = nr; 1377 __entry->avail = avail; 1378 __entry->unavail = hweight64(iscan->__skipped_inomask); 1379 __entry->batch_ino = iscan->__batch_ino; 1380 __entry->skipmask = iscan->__skipped_inomask; 1381 ), 1382 TP_printk("dev %d:%d iscan cursor 0x%llx visited 0x%llx batchino 0x%llx skipmask 0x%llx nr %u avail %u unavail %u", 1383 MAJOR(__entry->dev), MINOR(__entry->dev), 1384 __entry->cursor, 1385 __entry->visited, 1386 __entry->batch_ino, 1387 __entry->skipmask, 1388 __entry->nr, 1389 __entry->avail, 1390 __entry->unavail) 1391 ); 1392 1393 DECLARE_EVENT_CLASS(xchk_iscan_retry_wait_class, 1394 TP_PROTO(struct xchk_iscan *iscan), 1395 TP_ARGS(iscan), 1396 TP_STRUCT__entry( 1397 __field(dev_t, dev) 1398 __field(xfs_ino_t, cursor) 1399 __field(xfs_ino_t, visited) 1400 __field(unsigned int, retry_delay) 1401 __field(unsigned long, remaining) 1402 __field(unsigned int, iget_timeout) 1403 ), 1404 TP_fast_assign( 1405 __entry->dev = iscan->sc->mp->m_super->s_dev; 1406 __entry->cursor = iscan->cursor_ino; 1407 __entry->visited = iscan->__visited_ino; 1408 __entry->retry_delay = iscan->iget_retry_delay; 1409 __entry->remaining = jiffies_to_msecs(iscan->__iget_deadline - jiffies); 1410 __entry->iget_timeout = iscan->iget_timeout; 1411 ), 1412 TP_printk("dev %d:%d iscan cursor 0x%llx visited 0x%llx remaining %lu timeout %u delay %u", 1413 MAJOR(__entry->dev), MINOR(__entry->dev), 1414 __entry->cursor, 1415 __entry->visited, 1416 __entry->remaining, 1417 __entry->iget_timeout, 1418 __entry->retry_delay) 1419 ) 1420 #define DEFINE_ISCAN_RETRY_WAIT_EVENT(name) \ 1421 DEFINE_EVENT(xchk_iscan_retry_wait_class, name, \ 1422 TP_PROTO(struct xchk_iscan *iscan), \ 1423 TP_ARGS(iscan)) 1424 DEFINE_ISCAN_RETRY_WAIT_EVENT(xchk_iscan_iget_retry_wait); 1425 DEFINE_ISCAN_RETRY_WAIT_EVENT(xchk_iscan_agi_retry_wait); 1426 1427 TRACE_EVENT(xchk_nlinks_collect_dirent, 1428 TP_PROTO(struct xfs_mount *mp, struct xfs_inode *dp, 1429 xfs_ino_t ino, const struct xfs_name *name), 1430 TP_ARGS(mp, dp, ino, name), 1431 TP_STRUCT__entry( 1432 __field(dev_t, dev) 1433 __field(xfs_ino_t, dir) 1434 __field(xfs_ino_t, ino) 1435 __field(unsigned int, namelen) 1436 __dynamic_array(char, name, name->len) 1437 ), 1438 TP_fast_assign( 1439 __entry->dev = mp->m_super->s_dev; 1440 __entry->dir = I_INO(dp); 1441 __entry->ino = ino; 1442 __entry->namelen = name->len; 1443 memcpy(__get_str(name), name->name, name->len); 1444 ), 1445 TP_printk("dev %d:%d dir 0x%llx -> ino 0x%llx name '%.*s'", 1446 MAJOR(__entry->dev), MINOR(__entry->dev), 1447 __entry->dir, 1448 __entry->ino, 1449 __entry->namelen, 1450 __get_str(name)) 1451 ); 1452 1453 TRACE_EVENT(xchk_nlinks_collect_pptr, 1454 TP_PROTO(struct xfs_mount *mp, struct xfs_inode *dp, 1455 const struct xfs_name *name, 1456 const struct xfs_parent_rec *pptr), 1457 TP_ARGS(mp, dp, name, pptr), 1458 TP_STRUCT__entry( 1459 __field(dev_t, dev) 1460 __field(xfs_ino_t, dir) 1461 __field(xfs_ino_t, ino) 1462 __field(unsigned int, namelen) 1463 __dynamic_array(char, name, name->len) 1464 ), 1465 TP_fast_assign( 1466 __entry->dev = mp->m_super->s_dev; 1467 __entry->dir = I_INO(dp); 1468 __entry->ino = be64_to_cpu(pptr->p_ino); 1469 __entry->namelen = name->len; 1470 memcpy(__get_str(name), name->name, name->len); 1471 ), 1472 TP_printk("dev %d:%d dir 0x%llx -> ino 0x%llx name '%.*s'", 1473 MAJOR(__entry->dev), MINOR(__entry->dev), 1474 __entry->dir, 1475 __entry->ino, 1476 __entry->namelen, 1477 __get_str(name)) 1478 ); 1479 1480 TRACE_EVENT(xchk_nlinks_collect_metafile, 1481 TP_PROTO(struct xfs_mount *mp, xfs_ino_t ino), 1482 TP_ARGS(mp, ino), 1483 TP_STRUCT__entry( 1484 __field(dev_t, dev) 1485 __field(xfs_ino_t, ino) 1486 ), 1487 TP_fast_assign( 1488 __entry->dev = mp->m_super->s_dev; 1489 __entry->ino = ino; 1490 ), 1491 TP_printk("dev %d:%d ino 0x%llx", 1492 MAJOR(__entry->dev), MINOR(__entry->dev), 1493 __entry->ino) 1494 ); 1495 1496 TRACE_EVENT(xchk_nlinks_live_update, 1497 TP_PROTO(struct xfs_mount *mp, const struct xfs_inode *dp, 1498 int action, xfs_ino_t ino, int delta, 1499 const char *name, unsigned int namelen), 1500 TP_ARGS(mp, dp, action, ino, delta, name, namelen), 1501 TP_STRUCT__entry( 1502 __field(dev_t, dev) 1503 __field(xfs_ino_t, dir) 1504 __field(int, action) 1505 __field(xfs_ino_t, ino) 1506 __field(int, delta) 1507 __field(unsigned int, namelen) 1508 __dynamic_array(char, name, namelen) 1509 ), 1510 TP_fast_assign( 1511 __entry->dev = mp->m_super->s_dev; 1512 __entry->dir = dp ? I_INO(dp) : NULLFSINO; 1513 __entry->action = action; 1514 __entry->ino = ino; 1515 __entry->delta = delta; 1516 __entry->namelen = namelen; 1517 memcpy(__get_str(name), name, namelen); 1518 ), 1519 TP_printk("dev %d:%d dir 0x%llx ino 0x%llx nlink_delta %d name '%.*s'", 1520 MAJOR(__entry->dev), MINOR(__entry->dev), 1521 __entry->dir, 1522 __entry->ino, 1523 __entry->delta, 1524 __entry->namelen, 1525 __get_str(name)) 1526 ); 1527 1528 TRACE_EVENT(xchk_nlinks_check_zero, 1529 TP_PROTO(struct xfs_mount *mp, xfs_ino_t ino, 1530 const struct xchk_nlink *live), 1531 TP_ARGS(mp, ino, live), 1532 TP_STRUCT__entry( 1533 __field(dev_t, dev) 1534 __field(xfs_ino_t, ino) 1535 __field(xfs_nlink_t, parents) 1536 __field(xfs_nlink_t, backrefs) 1537 __field(xfs_nlink_t, children) 1538 ), 1539 TP_fast_assign( 1540 __entry->dev = mp->m_super->s_dev; 1541 __entry->ino = ino; 1542 __entry->parents = live->parents; 1543 __entry->backrefs = live->backrefs; 1544 __entry->children = live->children; 1545 ), 1546 TP_printk("dev %d:%d ino 0x%llx parents %u backrefs %u children %u", 1547 MAJOR(__entry->dev), MINOR(__entry->dev), 1548 __entry->ino, 1549 __entry->parents, 1550 __entry->backrefs, 1551 __entry->children) 1552 ); 1553 1554 TRACE_EVENT(xchk_nlinks_update_incore, 1555 TP_PROTO(struct xfs_mount *mp, xfs_ino_t ino, 1556 const struct xchk_nlink *live, int parents_delta, 1557 int backrefs_delta, int children_delta), 1558 TP_ARGS(mp, ino, live, parents_delta, backrefs_delta, children_delta), 1559 TP_STRUCT__entry( 1560 __field(dev_t, dev) 1561 __field(xfs_ino_t, ino) 1562 __field(xfs_nlink_t, parents) 1563 __field(xfs_nlink_t, backrefs) 1564 __field(xfs_nlink_t, children) 1565 __field(int, parents_delta) 1566 __field(int, backrefs_delta) 1567 __field(int, children_delta) 1568 ), 1569 TP_fast_assign( 1570 __entry->dev = mp->m_super->s_dev; 1571 __entry->ino = ino; 1572 __entry->parents = live->parents; 1573 __entry->backrefs = live->backrefs; 1574 __entry->children = live->children; 1575 __entry->parents_delta = parents_delta; 1576 __entry->backrefs_delta = backrefs_delta; 1577 __entry->children_delta = children_delta; 1578 ), 1579 TP_printk("dev %d:%d ino 0x%llx parents %d:%u backrefs %d:%u children %d:%u", 1580 MAJOR(__entry->dev), MINOR(__entry->dev), 1581 __entry->ino, 1582 __entry->parents_delta, 1583 __entry->parents, 1584 __entry->backrefs_delta, 1585 __entry->backrefs, 1586 __entry->children_delta, 1587 __entry->children) 1588 ); 1589 1590 DECLARE_EVENT_CLASS(xchk_nlinks_diff_class, 1591 TP_PROTO(struct xfs_mount *mp, struct xfs_inode *ip, 1592 const struct xchk_nlink *live), 1593 TP_ARGS(mp, ip, live), 1594 TP_STRUCT__entry( 1595 __field(dev_t, dev) 1596 __field(xfs_ino_t, ino) 1597 __field(uint8_t, ftype) 1598 __field(xfs_nlink_t, nlink) 1599 __field(xfs_nlink_t, parents) 1600 __field(xfs_nlink_t, backrefs) 1601 __field(xfs_nlink_t, children) 1602 ), 1603 TP_fast_assign( 1604 __entry->dev = mp->m_super->s_dev; 1605 __entry->ino = I_INO(ip); 1606 __entry->ftype = xfs_mode_to_ftype(VFS_I(ip)->i_mode); 1607 __entry->nlink = VFS_I(ip)->i_nlink; 1608 __entry->parents = live->parents; 1609 __entry->backrefs = live->backrefs; 1610 __entry->children = live->children; 1611 ), 1612 TP_printk("dev %d:%d ino 0x%llx ftype %s nlink %u parents %u backrefs %u children %u", 1613 MAJOR(__entry->dev), MINOR(__entry->dev), 1614 __entry->ino, 1615 __print_symbolic(__entry->ftype, XFS_DIR3_FTYPE_STR), 1616 __entry->nlink, 1617 __entry->parents, 1618 __entry->backrefs, 1619 __entry->children) 1620 ); 1621 #define DEFINE_SCRUB_NLINKS_DIFF_EVENT(name) \ 1622 DEFINE_EVENT(xchk_nlinks_diff_class, name, \ 1623 TP_PROTO(struct xfs_mount *mp, struct xfs_inode *ip, \ 1624 const struct xchk_nlink *live), \ 1625 TP_ARGS(mp, ip, live)) 1626 DEFINE_SCRUB_NLINKS_DIFF_EVENT(xchk_nlinks_compare_inode); 1627 1628 DECLARE_EVENT_CLASS(xchk_pptr_class, 1629 TP_PROTO(struct xfs_inode *ip, const struct xfs_name *name, 1630 xfs_ino_t far_ino), 1631 TP_ARGS(ip, name, far_ino), 1632 TP_STRUCT__entry( 1633 __field(dev_t, dev) 1634 __field(xfs_ino_t, ino) 1635 __field(unsigned int, namelen) 1636 __dynamic_array(char, name, name->len) 1637 __field(xfs_ino_t, far_ino) 1638 ), 1639 TP_fast_assign( 1640 __entry->dev = ip->i_mount->m_super->s_dev; 1641 __entry->ino = I_INO(ip); 1642 __entry->namelen = name->len; 1643 memcpy(__get_str(name), name->name, name->len); 1644 __entry->far_ino = far_ino; 1645 ), 1646 TP_printk("dev %d:%d ino 0x%llx name '%.*s' far_ino 0x%llx", 1647 MAJOR(__entry->dev), MINOR(__entry->dev), 1648 __entry->ino, 1649 __entry->namelen, 1650 __get_str(name), 1651 __entry->far_ino) 1652 ) 1653 #define DEFINE_XCHK_PPTR_EVENT(name) \ 1654 DEFINE_EVENT(xchk_pptr_class, name, \ 1655 TP_PROTO(struct xfs_inode *ip, const struct xfs_name *name, \ 1656 xfs_ino_t far_ino), \ 1657 TP_ARGS(ip, name, far_ino)) 1658 DEFINE_XCHK_PPTR_EVENT(xchk_dir_defer); 1659 DEFINE_XCHK_PPTR_EVENT(xchk_dir_slowpath); 1660 DEFINE_XCHK_PPTR_EVENT(xchk_dir_ultraslowpath); 1661 DEFINE_XCHK_PPTR_EVENT(xchk_parent_defer); 1662 DEFINE_XCHK_PPTR_EVENT(xchk_parent_slowpath); 1663 DEFINE_XCHK_PPTR_EVENT(xchk_parent_ultraslowpath); 1664 1665 DECLARE_EVENT_CLASS(xchk_dirtree_class, 1666 TP_PROTO(struct xfs_scrub *sc, struct xfs_inode *ip, 1667 unsigned int path_nr, const struct xfs_name *name, 1668 const struct xfs_parent_rec *pptr), 1669 TP_ARGS(sc, ip, path_nr, name, pptr), 1670 TP_STRUCT__entry( 1671 __field(dev_t, dev) 1672 __field(unsigned int, path_nr) 1673 __field(xfs_ino_t, child_ino) 1674 __field(unsigned int, child_gen) 1675 __field(xfs_ino_t, parent_ino) 1676 __field(unsigned int, parent_gen) 1677 __field(unsigned int, namelen) 1678 __dynamic_array(char, name, name->len) 1679 ), 1680 TP_fast_assign( 1681 __entry->dev = sc->mp->m_super->s_dev; 1682 __entry->path_nr = path_nr; 1683 __entry->child_ino = I_INO(ip); 1684 __entry->child_gen = VFS_I(ip)->i_generation; 1685 __entry->parent_ino = be64_to_cpu(pptr->p_ino); 1686 __entry->parent_gen = be32_to_cpu(pptr->p_gen); 1687 __entry->namelen = name->len; 1688 memcpy(__get_str(name), name->name, name->len); 1689 ), 1690 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'", 1691 MAJOR(__entry->dev), MINOR(__entry->dev), 1692 __entry->path_nr, 1693 __entry->child_ino, 1694 __entry->child_gen, 1695 __entry->parent_ino, 1696 __entry->parent_gen, 1697 __entry->namelen, 1698 __get_str(name)) 1699 ); 1700 #define DEFINE_XCHK_DIRTREE_EVENT(name) \ 1701 DEFINE_EVENT(xchk_dirtree_class, name, \ 1702 TP_PROTO(struct xfs_scrub *sc, struct xfs_inode *ip, \ 1703 unsigned int path_nr, const struct xfs_name *name, \ 1704 const struct xfs_parent_rec *pptr), \ 1705 TP_ARGS(sc, ip, path_nr, name, pptr)) 1706 DEFINE_XCHK_DIRTREE_EVENT(xchk_dirtree_create_path); 1707 DEFINE_XCHK_DIRTREE_EVENT(xchk_dirpath_walk_upwards); 1708 1709 TRACE_EVENT(xchk_dirpath_badino, 1710 TP_PROTO(struct xfs_scrub *sc, unsigned int path_nr, 1711 unsigned int step_nr, const struct xfs_name *name, 1712 const struct xfs_parent_rec *pptr), 1713 TP_ARGS(sc, path_nr, step_nr, name, pptr), 1714 TP_STRUCT__entry( 1715 __field(dev_t, dev) 1716 __field(unsigned int, path_nr) 1717 __field(unsigned int, step_nr) 1718 __field(xfs_ino_t, parent_ino) 1719 __field(unsigned int, parent_gen) 1720 __field(unsigned int, namelen) 1721 __dynamic_array(char, name, name->len) 1722 ), 1723 TP_fast_assign( 1724 __entry->dev = sc->mp->m_super->s_dev; 1725 __entry->path_nr = path_nr; 1726 __entry->step_nr = step_nr; 1727 __entry->parent_ino = be64_to_cpu(pptr->p_ino); 1728 __entry->parent_gen = be32_to_cpu(pptr->p_gen); 1729 __entry->namelen = name->len; 1730 memcpy(__get_str(name), name->name, name->len); 1731 ), 1732 TP_printk("dev %d:%d path %u step %u parent_ino 0x%llx parent_gen 0x%x name '%.*s'", 1733 MAJOR(__entry->dev), MINOR(__entry->dev), 1734 __entry->path_nr, 1735 __entry->step_nr, 1736 __entry->parent_ino, 1737 __entry->parent_gen, 1738 __entry->namelen, 1739 __get_str(name)) 1740 ); 1741 1742 DECLARE_EVENT_CLASS(xchk_dirpath_class, 1743 TP_PROTO(struct xfs_scrub *sc, struct xfs_inode *ip, 1744 unsigned int path_nr, unsigned int step_nr, 1745 const struct xfs_name *name, 1746 const struct xfs_parent_rec *pptr), 1747 TP_ARGS(sc, ip, path_nr, step_nr, name, pptr), 1748 TP_STRUCT__entry( 1749 __field(dev_t, dev) 1750 __field(unsigned int, path_nr) 1751 __field(unsigned int, step_nr) 1752 __field(xfs_ino_t, child_ino) 1753 __field(unsigned int, child_gen) 1754 __field(xfs_ino_t, parent_ino) 1755 __field(unsigned int, parent_gen) 1756 __field(unsigned int, namelen) 1757 __dynamic_array(char, name, name->len) 1758 ), 1759 TP_fast_assign( 1760 __entry->dev = sc->mp->m_super->s_dev; 1761 __entry->path_nr = path_nr; 1762 __entry->step_nr = step_nr; 1763 __entry->child_ino = I_INO(ip); 1764 __entry->child_gen = VFS_I(ip)->i_generation; 1765 __entry->parent_ino = be64_to_cpu(pptr->p_ino); 1766 __entry->parent_gen = be32_to_cpu(pptr->p_gen); 1767 __entry->namelen = name->len; 1768 memcpy(__get_str(name), name->name, name->len); 1769 ), 1770 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'", 1771 MAJOR(__entry->dev), MINOR(__entry->dev), 1772 __entry->path_nr, 1773 __entry->step_nr, 1774 __entry->child_ino, 1775 __entry->child_gen, 1776 __entry->parent_ino, 1777 __entry->parent_gen, 1778 __entry->namelen, 1779 __get_str(name)) 1780 ); 1781 #define DEFINE_XCHK_DIRPATH_EVENT(name) \ 1782 DEFINE_EVENT(xchk_dirpath_class, name, \ 1783 TP_PROTO(struct xfs_scrub *sc, struct xfs_inode *ip, \ 1784 unsigned int path_nr, unsigned int step_nr, \ 1785 const struct xfs_name *name, \ 1786 const struct xfs_parent_rec *pptr), \ 1787 TP_ARGS(sc, ip, path_nr, step_nr, name, pptr)) 1788 DEFINE_XCHK_DIRPATH_EVENT(xchk_dirpath_disappeared); 1789 DEFINE_XCHK_DIRPATH_EVENT(xchk_dirpath_badgen); 1790 DEFINE_XCHK_DIRPATH_EVENT(xchk_dirpath_nondir_parent); 1791 DEFINE_XCHK_DIRPATH_EVENT(xchk_dirpath_unlinked_parent); 1792 DEFINE_XCHK_DIRPATH_EVENT(xchk_dirpath_found_next_step); 1793 DEFINE_XCHK_DIRPATH_EVENT(xchk_dirpath_crosses_tree); 1794 1795 TRACE_DEFINE_ENUM(XCHK_DIRPATH_SCANNING); 1796 TRACE_DEFINE_ENUM(XCHK_DIRPATH_DELETE); 1797 TRACE_DEFINE_ENUM(XCHK_DIRPATH_CORRUPT); 1798 TRACE_DEFINE_ENUM(XCHK_DIRPATH_LOOP); 1799 TRACE_DEFINE_ENUM(XCHK_DIRPATH_STALE); 1800 TRACE_DEFINE_ENUM(XCHK_DIRPATH_OK); 1801 TRACE_DEFINE_ENUM(XREP_DIRPATH_DELETING); 1802 TRACE_DEFINE_ENUM(XREP_DIRPATH_DELETED); 1803 TRACE_DEFINE_ENUM(XREP_DIRPATH_ADOPTING); 1804 TRACE_DEFINE_ENUM(XREP_DIRPATH_ADOPTED); 1805 1806 #define XCHK_DIRPATH_OUTCOME_STRINGS \ 1807 { XCHK_DIRPATH_SCANNING, "scanning" }, \ 1808 { XCHK_DIRPATH_DELETE, "delete" }, \ 1809 { XCHK_DIRPATH_CORRUPT, "corrupt" }, \ 1810 { XCHK_DIRPATH_LOOP, "loop" }, \ 1811 { XCHK_DIRPATH_STALE, "stale" }, \ 1812 { XCHK_DIRPATH_OK, "ok" }, \ 1813 { XREP_DIRPATH_DELETING, "deleting" }, \ 1814 { XREP_DIRPATH_DELETED, "deleted" }, \ 1815 { XREP_DIRPATH_ADOPTING, "adopting" }, \ 1816 { XREP_DIRPATH_ADOPTED, "adopted" } 1817 1818 DECLARE_EVENT_CLASS(xchk_dirpath_outcome_class, 1819 TP_PROTO(struct xfs_scrub *sc, unsigned long long path_nr, 1820 unsigned int nr_steps, \ 1821 unsigned int outcome), 1822 TP_ARGS(sc, path_nr, nr_steps, outcome), 1823 TP_STRUCT__entry( 1824 __field(dev_t, dev) 1825 __field(unsigned long long, path_nr) 1826 __field(unsigned int, nr_steps) 1827 __field(unsigned int, outcome) 1828 ), 1829 TP_fast_assign( 1830 __entry->dev = sc->mp->m_super->s_dev; 1831 __entry->path_nr = path_nr; 1832 __entry->nr_steps = nr_steps; 1833 __entry->outcome = outcome; 1834 ), 1835 TP_printk("dev %d:%d path %llu steps %u outcome %s", 1836 MAJOR(__entry->dev), MINOR(__entry->dev), 1837 __entry->path_nr, 1838 __entry->nr_steps, 1839 __print_symbolic(__entry->outcome, XCHK_DIRPATH_OUTCOME_STRINGS)) 1840 ); 1841 #define DEFINE_XCHK_DIRPATH_OUTCOME_EVENT(name) \ 1842 DEFINE_EVENT(xchk_dirpath_outcome_class, name, \ 1843 TP_PROTO(struct xfs_scrub *sc, unsigned long long path_nr, \ 1844 unsigned int nr_steps, \ 1845 unsigned int outcome), \ 1846 TP_ARGS(sc, path_nr, nr_steps, outcome)) 1847 DEFINE_XCHK_DIRPATH_OUTCOME_EVENT(xchk_dirpath_set_outcome); 1848 DEFINE_XCHK_DIRPATH_OUTCOME_EVENT(xchk_dirpath_evaluate_path); 1849 1850 DECLARE_EVENT_CLASS(xchk_dirtree_evaluate_class, 1851 TP_PROTO(const struct xchk_dirtree *dl, 1852 const struct xchk_dirtree_outcomes *oc), 1853 TP_ARGS(dl, oc), 1854 TP_STRUCT__entry( 1855 __field(dev_t, dev) 1856 __field(xfs_ino_t, ino) 1857 __field(xfs_ino_t, rootino) 1858 __field(unsigned int, nr_paths) 1859 __field(unsigned int, bad) 1860 __field(unsigned int, suspect) 1861 __field(unsigned int, good) 1862 __field(bool, needs_adoption) 1863 ), 1864 TP_fast_assign( 1865 __entry->dev = dl->sc->mp->m_super->s_dev; 1866 __entry->ino = I_INO(dl->sc->ip); 1867 __entry->rootino = dl->root_ino; 1868 __entry->nr_paths = dl->nr_paths; 1869 __entry->bad = oc->bad; 1870 __entry->suspect = oc->suspect; 1871 __entry->good = oc->good; 1872 __entry->needs_adoption = oc->needs_adoption ? 1 : 0; 1873 ), 1874 TP_printk("dev %d:%d ino 0x%llx rootino 0x%llx nr_paths %u bad %u suspect %u good %u adopt? %d", 1875 MAJOR(__entry->dev), MINOR(__entry->dev), 1876 __entry->ino, 1877 __entry->rootino, 1878 __entry->nr_paths, 1879 __entry->bad, 1880 __entry->suspect, 1881 __entry->good, 1882 __entry->needs_adoption) 1883 ); 1884 #define DEFINE_XCHK_DIRTREE_EVALUATE_EVENT(name) \ 1885 DEFINE_EVENT(xchk_dirtree_evaluate_class, name, \ 1886 TP_PROTO(const struct xchk_dirtree *dl, \ 1887 const struct xchk_dirtree_outcomes *oc), \ 1888 TP_ARGS(dl, oc)) 1889 DEFINE_XCHK_DIRTREE_EVALUATE_EVENT(xchk_dirtree_evaluate); 1890 1891 TRACE_EVENT(xchk_dirpath_changed, 1892 TP_PROTO(struct xfs_scrub *sc, unsigned int path_nr, 1893 unsigned int step_nr, const struct xfs_inode *dp, 1894 const struct xfs_inode *ip, const struct xfs_name *xname), 1895 TP_ARGS(sc, path_nr, step_nr, dp, ip, xname), 1896 TP_STRUCT__entry( 1897 __field(dev_t, dev) 1898 __field(unsigned int, path_nr) 1899 __field(unsigned int, step_nr) 1900 __field(xfs_ino_t, child_ino) 1901 __field(xfs_ino_t, parent_ino) 1902 __field(unsigned int, namelen) 1903 __dynamic_array(char, name, xname->len) 1904 ), 1905 TP_fast_assign( 1906 __entry->dev = sc->mp->m_super->s_dev; 1907 __entry->path_nr = path_nr; 1908 __entry->step_nr = step_nr; 1909 __entry->child_ino = I_INO(ip); 1910 __entry->parent_ino = I_INO(dp); 1911 __entry->namelen = xname->len; 1912 memcpy(__get_str(name), xname->name, xname->len); 1913 ), 1914 TP_printk("dev %d:%d path %u step %u child_ino 0x%llx parent_ino 0x%llx name '%.*s'", 1915 MAJOR(__entry->dev), MINOR(__entry->dev), 1916 __entry->path_nr, 1917 __entry->step_nr, 1918 __entry->child_ino, 1919 __entry->parent_ino, 1920 __entry->namelen, 1921 __get_str(name)) 1922 ); 1923 1924 TRACE_EVENT(xchk_dirtree_live_update, 1925 TP_PROTO(struct xfs_scrub *sc, const struct xfs_inode *dp, 1926 int action, const struct xfs_inode *ip, int delta, 1927 const struct xfs_name *xname), 1928 TP_ARGS(sc, dp, action, ip, delta, xname), 1929 TP_STRUCT__entry( 1930 __field(dev_t, dev) 1931 __field(xfs_ino_t, parent_ino) 1932 __field(int, action) 1933 __field(xfs_ino_t, child_ino) 1934 __field(int, delta) 1935 __field(unsigned int, namelen) 1936 __dynamic_array(char, name, xname->len) 1937 ), 1938 TP_fast_assign( 1939 __entry->dev = sc->mp->m_super->s_dev; 1940 __entry->parent_ino = I_INO(dp); 1941 __entry->action = action; 1942 __entry->child_ino = I_INO(ip); 1943 __entry->delta = delta; 1944 __entry->namelen = xname->len; 1945 memcpy(__get_str(name), xname->name, xname->len); 1946 ), 1947 TP_printk("dev %d:%d parent_ino 0x%llx child_ino 0x%llx nlink_delta %d name '%.*s'", 1948 MAJOR(__entry->dev), MINOR(__entry->dev), 1949 __entry->parent_ino, 1950 __entry->child_ino, 1951 __entry->delta, 1952 __entry->namelen, 1953 __get_str(name)) 1954 ); 1955 1956 DECLARE_EVENT_CLASS(xchk_metapath_class, 1957 TP_PROTO(struct xfs_scrub *sc, const char *path, 1958 struct xfs_inode *dp, xfs_ino_t ino), 1959 TP_ARGS(sc, path, dp, ino), 1960 TP_STRUCT__entry( 1961 __field(dev_t, dev) 1962 __field(xfs_ino_t, scrub_ino) 1963 __field(xfs_ino_t, parent_ino) 1964 __field(xfs_ino_t, ino) 1965 __string(name, path) 1966 ), 1967 TP_fast_assign( 1968 __entry->dev = sc->mp->m_super->s_dev; 1969 __entry->scrub_ino = sc->ip ? I_INO(sc->ip) : NULLFSINO; 1970 __entry->parent_ino = dp ? I_INO(dp) : NULLFSINO; 1971 __entry->ino = ino; 1972 __assign_str(name); 1973 ), 1974 TP_printk("dev %d:%d ino 0x%llx parent_ino 0x%llx name '%s' ino 0x%llx", 1975 MAJOR(__entry->dev), MINOR(__entry->dev), 1976 __entry->scrub_ino, 1977 __entry->parent_ino, 1978 __get_str(name), 1979 __entry->ino) 1980 ); 1981 #define DEFINE_XCHK_METAPATH_EVENT(name) \ 1982 DEFINE_EVENT(xchk_metapath_class, name, \ 1983 TP_PROTO(struct xfs_scrub *sc, const char *path, \ 1984 struct xfs_inode *dp, xfs_ino_t ino), \ 1985 TP_ARGS(sc, path, dp, ino)) 1986 DEFINE_XCHK_METAPATH_EVENT(xchk_metapath_lookup); 1987 1988 /* repair tracepoints */ 1989 #if IS_ENABLED(CONFIG_XFS_ONLINE_REPAIR) 1990 1991 DECLARE_EVENT_CLASS(xrep_extent_class, 1992 TP_PROTO(const struct xfs_group *xg, xfs_agblock_t agbno, 1993 xfs_extlen_t len), 1994 TP_ARGS(xg, agbno, len), 1995 TP_STRUCT__entry( 1996 __field(dev_t, dev) 1997 __field(enum xfs_group_type, type) 1998 __field(xfs_agnumber_t, agno) 1999 __field(xfs_agblock_t, agbno) 2000 __field(xfs_extlen_t, len) 2001 ), 2002 TP_fast_assign( 2003 __entry->dev = xg->xg_mount->m_super->s_dev; 2004 __entry->type = xg->xg_type; 2005 __entry->agno = xg->xg_gno; 2006 __entry->agbno = agbno; 2007 __entry->len = len; 2008 ), 2009 TP_printk("dev %d:%d %sno 0x%x %sbno 0x%x fsbcount 0x%x", 2010 MAJOR(__entry->dev), MINOR(__entry->dev), 2011 __print_symbolic(__entry->type, XG_TYPE_STRINGS), 2012 __entry->agno, 2013 __print_symbolic(__entry->type, XG_TYPE_STRINGS), 2014 __entry->agbno, 2015 __entry->len) 2016 ); 2017 #define DEFINE_REPAIR_EXTENT_EVENT(name) \ 2018 DEFINE_EVENT(xrep_extent_class, name, \ 2019 TP_PROTO(const struct xfs_group *xg, xfs_agblock_t agbno, \ 2020 xfs_extlen_t len), \ 2021 TP_ARGS(xg, agbno, len)) 2022 DEFINE_REPAIR_EXTENT_EVENT(xreap_dispose_unmap_extent); 2023 DEFINE_REPAIR_EXTENT_EVENT(xreap_dispose_free_extent); 2024 DEFINE_REPAIR_EXTENT_EVENT(xreap_agextent_binval); 2025 DEFINE_REPAIR_EXTENT_EVENT(xreap_bmapi_binval); 2026 DEFINE_REPAIR_EXTENT_EVENT(xrep_agfl_insert); 2027 2028 DECLARE_EVENT_CLASS(xrep_reap_limits_class, 2029 TP_PROTO(const struct xfs_trans *tp, unsigned int per_binval, 2030 unsigned int max_binval, unsigned int step_size, 2031 unsigned int per_intent, 2032 unsigned int max_deferred), 2033 TP_ARGS(tp, per_binval, max_binval, step_size, per_intent, max_deferred), 2034 TP_STRUCT__entry( 2035 __field(dev_t, dev) 2036 __field(unsigned int, log_res) 2037 __field(unsigned int, per_binval) 2038 __field(unsigned int, max_binval) 2039 __field(unsigned int, step_size) 2040 __field(unsigned int, per_intent) 2041 __field(unsigned int, max_deferred) 2042 ), 2043 TP_fast_assign( 2044 __entry->dev = tp->t_mountp->m_super->s_dev; 2045 __entry->log_res = tp->t_log_res; 2046 __entry->per_binval = per_binval; 2047 __entry->max_binval = max_binval; 2048 __entry->step_size = step_size; 2049 __entry->per_intent = per_intent; 2050 __entry->max_deferred = max_deferred; 2051 ), 2052 TP_printk("dev %d:%d logres %u per_binval %u max_binval %u step_size %u per_intent %u max_deferred %u", 2053 MAJOR(__entry->dev), MINOR(__entry->dev), 2054 __entry->log_res, 2055 __entry->per_binval, 2056 __entry->max_binval, 2057 __entry->step_size, 2058 __entry->per_intent, 2059 __entry->max_deferred) 2060 ); 2061 #define DEFINE_REPAIR_REAP_LIMITS_EVENT(name) \ 2062 DEFINE_EVENT(xrep_reap_limits_class, name, \ 2063 TP_PROTO(const struct xfs_trans *tp, unsigned int per_binval, \ 2064 unsigned int max_binval, unsigned int step_size, \ 2065 unsigned int per_intent, \ 2066 unsigned int max_deferred), \ 2067 TP_ARGS(tp, per_binval, max_binval, step_size, per_intent, max_deferred)) 2068 DEFINE_REPAIR_REAP_LIMITS_EVENT(xreap_agextent_limits); 2069 DEFINE_REPAIR_REAP_LIMITS_EVENT(xreap_agcow_limits); 2070 DEFINE_REPAIR_REAP_LIMITS_EVENT(xreap_rgcow_limits); 2071 DEFINE_REPAIR_REAP_LIMITS_EVENT(xreap_bmapi_limits); 2072 2073 DECLARE_EVENT_CLASS(xrep_reap_find_class, 2074 TP_PROTO(const struct xfs_group *xg, xfs_agblock_t agbno, 2075 xfs_extlen_t len, bool crosslinked), 2076 TP_ARGS(xg, agbno, len, crosslinked), 2077 TP_STRUCT__entry( 2078 __field(dev_t, dev) 2079 __field(enum xfs_group_type, type) 2080 __field(xfs_agnumber_t, agno) 2081 __field(xfs_agblock_t, agbno) 2082 __field(xfs_extlen_t, len) 2083 __field(bool, crosslinked) 2084 ), 2085 TP_fast_assign( 2086 __entry->dev = xg->xg_mount->m_super->s_dev; 2087 __entry->type = xg->xg_type; 2088 __entry->agno = xg->xg_gno; 2089 __entry->agbno = agbno; 2090 __entry->len = len; 2091 __entry->crosslinked = crosslinked; 2092 ), 2093 TP_printk("dev %d:%d %sno 0x%x %sbno 0x%x fsbcount 0x%x crosslinked %d", 2094 MAJOR(__entry->dev), MINOR(__entry->dev), 2095 __print_symbolic(__entry->type, XG_TYPE_STRINGS), 2096 __entry->agno, 2097 __print_symbolic(__entry->type, XG_TYPE_STRINGS), 2098 __entry->agbno, 2099 __entry->len, 2100 __entry->crosslinked ? 1 : 0) 2101 ); 2102 #define DEFINE_REPAIR_REAP_FIND_EVENT(name) \ 2103 DEFINE_EVENT(xrep_reap_find_class, name, \ 2104 TP_PROTO(const struct xfs_group *xg, xfs_agblock_t agbno, \ 2105 xfs_extlen_t len, bool crosslinked), \ 2106 TP_ARGS(xg, agbno, len, crosslinked)) 2107 DEFINE_REPAIR_REAP_FIND_EVENT(xreap_agextent_select); 2108 DEFINE_REPAIR_REAP_FIND_EVENT(xreap_bmapi_select); 2109 2110 TRACE_EVENT(xrep_ibt_walk_rmap, 2111 TP_PROTO(const struct xfs_perag *pag, const struct xfs_rmap_irec *rec), 2112 TP_ARGS(pag, rec), 2113 TP_STRUCT__entry( 2114 __field(dev_t, dev) 2115 __field(xfs_agnumber_t, agno) 2116 __field(xfs_agblock_t, agbno) 2117 __field(xfs_extlen_t, len) 2118 __field(uint64_t, owner) 2119 __field(uint64_t, offset) 2120 __field(unsigned int, flags) 2121 ), 2122 TP_fast_assign( 2123 __entry->dev = pag_mount(pag)->m_super->s_dev; 2124 __entry->agno = pag_agno(pag); 2125 __entry->agbno = rec->rm_startblock; 2126 __entry->len = rec->rm_blockcount; 2127 __entry->owner = rec->rm_owner; 2128 __entry->offset = rec->rm_offset; 2129 __entry->flags = rec->rm_flags; 2130 ), 2131 TP_printk("dev %d:%d agno 0x%x agbno 0x%x fsbcount 0x%x owner 0x%llx fileoff 0x%llx flags 0x%x", 2132 MAJOR(__entry->dev), MINOR(__entry->dev), 2133 __entry->agno, 2134 __entry->agbno, 2135 __entry->len, 2136 __entry->owner, 2137 __entry->offset, 2138 __entry->flags) 2139 ); 2140 2141 TRACE_EVENT(xrep_abt_found, 2142 TP_PROTO(const struct xfs_perag *pag, 2143 const struct xfs_alloc_rec_incore *rec), 2144 TP_ARGS(pag, rec), 2145 TP_STRUCT__entry( 2146 __field(dev_t, dev) 2147 __field(xfs_agnumber_t, agno) 2148 __field(xfs_agblock_t, startblock) 2149 __field(xfs_extlen_t, blockcount) 2150 ), 2151 TP_fast_assign( 2152 __entry->dev = pag_mount(pag)->m_super->s_dev; 2153 __entry->agno = pag_agno(pag); 2154 __entry->startblock = rec->ar_startblock; 2155 __entry->blockcount = rec->ar_blockcount; 2156 ), 2157 TP_printk("dev %d:%d agno 0x%x agbno 0x%x fsbcount 0x%x", 2158 MAJOR(__entry->dev), MINOR(__entry->dev), 2159 __entry->agno, 2160 __entry->startblock, 2161 __entry->blockcount) 2162 ) 2163 2164 TRACE_EVENT(xrep_ibt_found, 2165 TP_PROTO(const struct xfs_perag *pag, 2166 const struct xfs_inobt_rec_incore *rec), 2167 TP_ARGS(pag, rec), 2168 TP_STRUCT__entry( 2169 __field(dev_t, dev) 2170 __field(xfs_agnumber_t, agno) 2171 __field(xfs_agino_t, startino) 2172 __field(uint16_t, holemask) 2173 __field(uint8_t, count) 2174 __field(uint8_t, freecount) 2175 __field(uint64_t, freemask) 2176 ), 2177 TP_fast_assign( 2178 __entry->dev = pag_mount(pag)->m_super->s_dev; 2179 __entry->agno = pag_agno(pag); 2180 __entry->startino = rec->ir_startino; 2181 __entry->holemask = rec->ir_holemask; 2182 __entry->count = rec->ir_count; 2183 __entry->freecount = rec->ir_freecount; 2184 __entry->freemask = rec->ir_free; 2185 ), 2186 TP_printk("dev %d:%d agno 0x%x agino 0x%x holemask 0x%x count 0x%x freecount 0x%x freemask 0x%llx", 2187 MAJOR(__entry->dev), MINOR(__entry->dev), 2188 __entry->agno, 2189 __entry->startino, 2190 __entry->holemask, 2191 __entry->count, 2192 __entry->freecount, 2193 __entry->freemask) 2194 ) 2195 2196 TRACE_EVENT(xrep_refc_found, 2197 TP_PROTO(const struct xfs_group *xg, 2198 const struct xfs_refcount_irec *rec), 2199 TP_ARGS(xg, rec), 2200 TP_STRUCT__entry( 2201 __field(dev_t, dev) 2202 __field(xfs_agnumber_t, agno) 2203 __field(enum xfs_refc_domain, domain) 2204 __field(enum xfs_group_type, type) 2205 __field(xfs_agblock_t, startblock) 2206 __field(xfs_extlen_t, blockcount) 2207 __field(xfs_nlink_t, refcount) 2208 ), 2209 TP_fast_assign( 2210 __entry->dev = xg->xg_mount->m_super->s_dev; 2211 __entry->agno = xg->xg_gno; 2212 __entry->type = xg->xg_type; 2213 __entry->domain = rec->rc_domain; 2214 __entry->startblock = rec->rc_startblock; 2215 __entry->blockcount = rec->rc_blockcount; 2216 __entry->refcount = rec->rc_refcount; 2217 ), 2218 TP_printk("dev %d:%d %sno 0x%x dom %s %sbno 0x%x fsbcount 0x%x refcount %u", 2219 MAJOR(__entry->dev), MINOR(__entry->dev), 2220 __print_symbolic(__entry->type, XG_TYPE_STRINGS), 2221 __entry->agno, 2222 __print_symbolic(__entry->domain, XFS_REFC_DOMAIN_STRINGS), 2223 __print_symbolic(__entry->type, XG_TYPE_STRINGS), 2224 __entry->startblock, 2225 __entry->blockcount, 2226 __entry->refcount) 2227 ) 2228 2229 TRACE_EVENT(xrep_bmap_found, 2230 TP_PROTO(struct xfs_inode *ip, int whichfork, 2231 struct xfs_bmbt_irec *irec), 2232 TP_ARGS(ip, whichfork, irec), 2233 TP_STRUCT__entry( 2234 __field(dev_t, dev) 2235 __field(xfs_ino_t, ino) 2236 __field(int, whichfork) 2237 __field(xfs_fileoff_t, lblk) 2238 __field(xfs_filblks_t, len) 2239 __field(xfs_fsblock_t, pblk) 2240 __field(int, state) 2241 ), 2242 TP_fast_assign( 2243 __entry->dev = VFS_I(ip)->i_sb->s_dev; 2244 __entry->ino = I_INO(ip); 2245 __entry->whichfork = whichfork; 2246 __entry->lblk = irec->br_startoff; 2247 __entry->len = irec->br_blockcount; 2248 __entry->pblk = irec->br_startblock; 2249 __entry->state = irec->br_state; 2250 ), 2251 TP_printk("dev %d:%d ino 0x%llx whichfork %s fileoff 0x%llx fsbcount 0x%llx startblock 0x%llx state %d", 2252 MAJOR(__entry->dev), MINOR(__entry->dev), 2253 __entry->ino, 2254 __print_symbolic(__entry->whichfork, XFS_WHICHFORK_STRINGS), 2255 __entry->lblk, 2256 __entry->len, 2257 __entry->pblk, 2258 __entry->state) 2259 ); 2260 2261 TRACE_EVENT(xrep_rmap_found, 2262 TP_PROTO(const struct xfs_perag *pag, const struct xfs_rmap_irec *rec), 2263 TP_ARGS(pag, rec), 2264 TP_STRUCT__entry( 2265 __field(dev_t, dev) 2266 __field(xfs_agnumber_t, agno) 2267 __field(xfs_agblock_t, agbno) 2268 __field(xfs_extlen_t, len) 2269 __field(uint64_t, owner) 2270 __field(uint64_t, offset) 2271 __field(unsigned int, flags) 2272 ), 2273 TP_fast_assign( 2274 __entry->dev = pag_mount(pag)->m_super->s_dev; 2275 __entry->agno = pag_agno(pag); 2276 __entry->agbno = rec->rm_startblock; 2277 __entry->len = rec->rm_blockcount; 2278 __entry->owner = rec->rm_owner; 2279 __entry->offset = rec->rm_offset; 2280 __entry->flags = rec->rm_flags; 2281 ), 2282 TP_printk("dev %d:%d agno 0x%x agbno 0x%x fsbcount 0x%x owner 0x%llx fileoff 0x%llx flags 0x%x", 2283 MAJOR(__entry->dev), MINOR(__entry->dev), 2284 __entry->agno, 2285 __entry->agbno, 2286 __entry->len, 2287 __entry->owner, 2288 __entry->offset, 2289 __entry->flags) 2290 ); 2291 2292 TRACE_EVENT(xrep_findroot_block, 2293 TP_PROTO(const struct xfs_perag *pag, xfs_agblock_t agbno, 2294 uint32_t magic, uint16_t level), 2295 TP_ARGS(pag, agbno, magic, level), 2296 TP_STRUCT__entry( 2297 __field(dev_t, dev) 2298 __field(xfs_agnumber_t, agno) 2299 __field(xfs_agblock_t, agbno) 2300 __field(uint32_t, magic) 2301 __field(uint16_t, level) 2302 ), 2303 TP_fast_assign( 2304 __entry->dev = pag_mount(pag)->m_super->s_dev; 2305 __entry->agno = pag_agno(pag); 2306 __entry->agbno = agbno; 2307 __entry->magic = magic; 2308 __entry->level = level; 2309 ), 2310 TP_printk("dev %d:%d agno 0x%x agbno 0x%x magic 0x%x level %u", 2311 MAJOR(__entry->dev), MINOR(__entry->dev), 2312 __entry->agno, 2313 __entry->agbno, 2314 __entry->magic, 2315 __entry->level) 2316 ) 2317 TRACE_EVENT(xrep_calc_ag_resblks, 2318 TP_PROTO(const struct xfs_perag *pag, xfs_agino_t icount, 2319 xfs_agblock_t aglen, xfs_agblock_t freelen, 2320 xfs_agblock_t usedlen), 2321 TP_ARGS(pag, icount, aglen, freelen, usedlen), 2322 TP_STRUCT__entry( 2323 __field(dev_t, dev) 2324 __field(xfs_agnumber_t, agno) 2325 __field(xfs_agino_t, icount) 2326 __field(xfs_agblock_t, aglen) 2327 __field(xfs_agblock_t, freelen) 2328 __field(xfs_agblock_t, usedlen) 2329 ), 2330 TP_fast_assign( 2331 __entry->dev = pag_mount(pag)->m_super->s_dev; 2332 __entry->agno = pag_agno(pag); 2333 __entry->icount = icount; 2334 __entry->aglen = aglen; 2335 __entry->freelen = freelen; 2336 __entry->usedlen = usedlen; 2337 ), 2338 TP_printk("dev %d:%d agno 0x%x icount %u aglen %u freelen %u usedlen %u", 2339 MAJOR(__entry->dev), MINOR(__entry->dev), 2340 __entry->agno, 2341 __entry->icount, 2342 __entry->aglen, 2343 __entry->freelen, 2344 __entry->usedlen) 2345 ) 2346 TRACE_EVENT(xrep_calc_ag_resblks_btsize, 2347 TP_PROTO(const struct xfs_perag *pag, xfs_agblock_t bnobt_sz, 2348 xfs_agblock_t inobt_sz, xfs_agblock_t rmapbt_sz, 2349 xfs_agblock_t refcbt_sz), 2350 TP_ARGS(pag, bnobt_sz, inobt_sz, rmapbt_sz, refcbt_sz), 2351 TP_STRUCT__entry( 2352 __field(dev_t, dev) 2353 __field(xfs_agnumber_t, agno) 2354 __field(xfs_agblock_t, bnobt_sz) 2355 __field(xfs_agblock_t, inobt_sz) 2356 __field(xfs_agblock_t, rmapbt_sz) 2357 __field(xfs_agblock_t, refcbt_sz) 2358 ), 2359 TP_fast_assign( 2360 __entry->dev = pag_mount(pag)->m_super->s_dev; 2361 __entry->agno = pag_agno(pag); 2362 __entry->bnobt_sz = bnobt_sz; 2363 __entry->inobt_sz = inobt_sz; 2364 __entry->rmapbt_sz = rmapbt_sz; 2365 __entry->refcbt_sz = refcbt_sz; 2366 ), 2367 TP_printk("dev %d:%d agno 0x%x bnobt %u inobt %u rmapbt %u refcountbt %u", 2368 MAJOR(__entry->dev), MINOR(__entry->dev), 2369 __entry->agno, 2370 __entry->bnobt_sz, 2371 __entry->inobt_sz, 2372 __entry->rmapbt_sz, 2373 __entry->refcbt_sz) 2374 ) 2375 2376 #ifdef CONFIG_XFS_RT 2377 TRACE_EVENT(xrep_calc_rtgroup_resblks_btsize, 2378 TP_PROTO(struct xfs_mount *mp, xfs_rgnumber_t rgno, 2379 xfs_rgblock_t usedlen, xfs_rgblock_t rmapbt_sz, 2380 xfs_rgblock_t refcbt_sz), 2381 TP_ARGS(mp, rgno, usedlen, rmapbt_sz, refcbt_sz), 2382 TP_STRUCT__entry( 2383 __field(dev_t, dev) 2384 __field(xfs_rgnumber_t, rgno) 2385 __field(xfs_rgblock_t, usedlen) 2386 __field(xfs_rgblock_t, rmapbt_sz) 2387 __field(xfs_rgblock_t, refcbt_sz) 2388 ), 2389 TP_fast_assign( 2390 __entry->dev = mp->m_super->s_dev; 2391 __entry->rgno = rgno; 2392 __entry->usedlen = usedlen; 2393 __entry->rmapbt_sz = rmapbt_sz; 2394 __entry->refcbt_sz = refcbt_sz; 2395 ), 2396 TP_printk("dev %d:%d rgno 0x%x usedlen %u rmapbt %u refcountbt %u", 2397 MAJOR(__entry->dev), MINOR(__entry->dev), 2398 __entry->rgno, 2399 __entry->usedlen, 2400 __entry->rmapbt_sz, 2401 __entry->refcbt_sz) 2402 ); 2403 #endif /* CONFIG_XFS_RT */ 2404 2405 TRACE_EVENT(xrep_reset_counters, 2406 TP_PROTO(struct xfs_mount *mp, struct xchk_fscounters *fsc), 2407 TP_ARGS(mp, fsc), 2408 TP_STRUCT__entry( 2409 __field(dev_t, dev) 2410 __field(uint64_t, icount) 2411 __field(uint64_t, ifree) 2412 __field(uint64_t, fdblocks) 2413 __field(uint64_t, frextents) 2414 ), 2415 TP_fast_assign( 2416 __entry->dev = mp->m_super->s_dev; 2417 __entry->icount = fsc->icount; 2418 __entry->ifree = fsc->ifree; 2419 __entry->fdblocks = fsc->fdblocks; 2420 __entry->frextents = fsc->frextents; 2421 ), 2422 TP_printk("dev %d:%d icount %llu ifree %llu fdblocks %llu frextents %llu", 2423 MAJOR(__entry->dev), MINOR(__entry->dev), 2424 __entry->icount, 2425 __entry->ifree, 2426 __entry->fdblocks, 2427 __entry->frextents) 2428 ) 2429 2430 DECLARE_EVENT_CLASS(xrep_newbt_extent_class, 2431 TP_PROTO(const struct xfs_perag *pag, xfs_agblock_t agbno, 2432 xfs_extlen_t len, int64_t owner), 2433 TP_ARGS(pag, agbno, len, owner), 2434 TP_STRUCT__entry( 2435 __field(dev_t, dev) 2436 __field(xfs_agnumber_t, agno) 2437 __field(xfs_agblock_t, agbno) 2438 __field(xfs_extlen_t, len) 2439 __field(int64_t, owner) 2440 ), 2441 TP_fast_assign( 2442 __entry->dev = pag_mount(pag)->m_super->s_dev; 2443 __entry->agno = pag_agno(pag); 2444 __entry->agbno = agbno; 2445 __entry->len = len; 2446 __entry->owner = owner; 2447 ), 2448 TP_printk("dev %d:%d agno 0x%x agbno 0x%x fsbcount 0x%x owner 0x%llx", 2449 MAJOR(__entry->dev), MINOR(__entry->dev), 2450 __entry->agno, 2451 __entry->agbno, 2452 __entry->len, 2453 __entry->owner) 2454 ); 2455 #define DEFINE_NEWBT_EXTENT_EVENT(name) \ 2456 DEFINE_EVENT(xrep_newbt_extent_class, name, \ 2457 TP_PROTO(const struct xfs_perag *pag, xfs_agblock_t agbno, \ 2458 xfs_extlen_t len, int64_t owner), \ 2459 TP_ARGS(pag, agbno, len, owner)) 2460 DEFINE_NEWBT_EXTENT_EVENT(xrep_newbt_alloc_ag_blocks); 2461 DEFINE_NEWBT_EXTENT_EVENT(xrep_newbt_alloc_file_blocks); 2462 DEFINE_NEWBT_EXTENT_EVENT(xrep_newbt_free_blocks); 2463 DEFINE_NEWBT_EXTENT_EVENT(xrep_newbt_claim_block); 2464 2465 DECLARE_EVENT_CLASS(xrep_dinode_class, 2466 TP_PROTO(struct xfs_scrub *sc, struct xfs_dinode *dip), 2467 TP_ARGS(sc, dip), 2468 TP_STRUCT__entry( 2469 __field(dev_t, dev) 2470 __field(xfs_ino_t, ino) 2471 __field(uint16_t, mode) 2472 __field(uint8_t, version) 2473 __field(uint8_t, format) 2474 __field(uint32_t, uid) 2475 __field(uint32_t, gid) 2476 __field(uint64_t, size) 2477 __field(uint64_t, nblocks) 2478 __field(uint32_t, extsize) 2479 __field(uint32_t, nextents) 2480 __field(uint16_t, anextents) 2481 __field(uint8_t, forkoff) 2482 __field(uint8_t, aformat) 2483 __field(uint16_t, flags) 2484 __field(uint32_t, gen) 2485 __field(uint64_t, flags2) 2486 __field(uint32_t, cowextsize) 2487 ), 2488 TP_fast_assign( 2489 __entry->dev = sc->mp->m_super->s_dev; 2490 __entry->ino = sc->sm->sm_ino; 2491 __entry->mode = be16_to_cpu(dip->di_mode); 2492 __entry->version = dip->di_version; 2493 __entry->format = dip->di_format; 2494 __entry->uid = be32_to_cpu(dip->di_uid); 2495 __entry->gid = be32_to_cpu(dip->di_gid); 2496 __entry->size = be64_to_cpu(dip->di_size); 2497 __entry->nblocks = be64_to_cpu(dip->di_nblocks); 2498 __entry->extsize = be32_to_cpu(dip->di_extsize); 2499 __entry->nextents = be32_to_cpu(dip->di_nextents); 2500 __entry->anextents = be16_to_cpu(dip->di_anextents); 2501 __entry->forkoff = dip->di_forkoff; 2502 __entry->aformat = dip->di_aformat; 2503 __entry->flags = be16_to_cpu(dip->di_flags); 2504 __entry->gen = be32_to_cpu(dip->di_gen); 2505 __entry->flags2 = be64_to_cpu(dip->di_flags2); 2506 __entry->cowextsize = be32_to_cpu(dip->di_cowextsize); 2507 ), 2508 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", 2509 MAJOR(__entry->dev), MINOR(__entry->dev), 2510 __entry->ino, 2511 __entry->mode, 2512 __entry->version, 2513 __entry->format, 2514 __entry->uid, 2515 __entry->gid, 2516 __entry->size, 2517 __entry->nblocks, 2518 __entry->extsize, 2519 __entry->nextents, 2520 __entry->anextents, 2521 __entry->forkoff, 2522 __entry->aformat, 2523 __entry->flags, 2524 __entry->gen, 2525 __entry->flags2, 2526 __entry->cowextsize) 2527 ) 2528 2529 #define DEFINE_REPAIR_DINODE_EVENT(name) \ 2530 DEFINE_EVENT(xrep_dinode_class, name, \ 2531 TP_PROTO(struct xfs_scrub *sc, struct xfs_dinode *dip), \ 2532 TP_ARGS(sc, dip)) 2533 DEFINE_REPAIR_DINODE_EVENT(xrep_dinode_header); 2534 DEFINE_REPAIR_DINODE_EVENT(xrep_dinode_mode); 2535 DEFINE_REPAIR_DINODE_EVENT(xrep_dinode_flags); 2536 DEFINE_REPAIR_DINODE_EVENT(xrep_dinode_size); 2537 DEFINE_REPAIR_DINODE_EVENT(xrep_dinode_extsize_hints); 2538 DEFINE_REPAIR_DINODE_EVENT(xrep_dinode_zap_symlink); 2539 DEFINE_REPAIR_DINODE_EVENT(xrep_dinode_zap_dir); 2540 DEFINE_REPAIR_DINODE_EVENT(xrep_dinode_fixed); 2541 DEFINE_REPAIR_DINODE_EVENT(xrep_dinode_zap_forks); 2542 DEFINE_REPAIR_DINODE_EVENT(xrep_dinode_zap_dfork); 2543 DEFINE_REPAIR_DINODE_EVENT(xrep_dinode_zap_afork); 2544 DEFINE_REPAIR_DINODE_EVENT(xrep_dinode_ensure_forkoff); 2545 2546 DECLARE_EVENT_CLASS(xrep_inode_class, 2547 TP_PROTO(struct xfs_scrub *sc), 2548 TP_ARGS(sc), 2549 TP_STRUCT__entry( 2550 __field(dev_t, dev) 2551 __field(xfs_ino_t, ino) 2552 __field(xfs_fsize_t, size) 2553 __field(xfs_rfsblock_t, nblocks) 2554 __field(uint16_t, flags) 2555 __field(uint64_t, flags2) 2556 __field(uint32_t, nextents) 2557 __field(uint8_t, format) 2558 __field(uint32_t, anextents) 2559 __field(uint8_t, aformat) 2560 ), 2561 TP_fast_assign( 2562 __entry->dev = sc->mp->m_super->s_dev; 2563 __entry->ino = sc->sm->sm_ino; 2564 __entry->size = sc->ip->i_disk_size; 2565 __entry->nblocks = sc->ip->i_nblocks; 2566 __entry->flags = sc->ip->i_diflags; 2567 __entry->flags2 = sc->ip->i_diflags2; 2568 __entry->nextents = sc->ip->i_df.if_nextents; 2569 __entry->format = sc->ip->i_df.if_format; 2570 __entry->anextents = sc->ip->i_af.if_nextents; 2571 __entry->aformat = sc->ip->i_af.if_format; 2572 ), 2573 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", 2574 MAJOR(__entry->dev), MINOR(__entry->dev), 2575 __entry->ino, 2576 __entry->size, 2577 __entry->nblocks, 2578 __entry->flags, 2579 __entry->flags2, 2580 __entry->nextents, 2581 __entry->format, 2582 __entry->anextents, 2583 __entry->aformat) 2584 ) 2585 2586 #define DEFINE_REPAIR_INODE_EVENT(name) \ 2587 DEFINE_EVENT(xrep_inode_class, name, \ 2588 TP_PROTO(struct xfs_scrub *sc), \ 2589 TP_ARGS(sc)) 2590 DEFINE_REPAIR_INODE_EVENT(xrep_inode_blockcounts); 2591 DEFINE_REPAIR_INODE_EVENT(xrep_inode_ids); 2592 DEFINE_REPAIR_INODE_EVENT(xrep_inode_flags); 2593 DEFINE_REPAIR_INODE_EVENT(xrep_inode_blockdir_size); 2594 DEFINE_REPAIR_INODE_EVENT(xrep_inode_sfdir_size); 2595 DEFINE_REPAIR_INODE_EVENT(xrep_inode_dir_size); 2596 DEFINE_REPAIR_INODE_EVENT(xrep_inode_fixed); 2597 2598 TRACE_EVENT(xrep_dinode_count_rmaps, 2599 TP_PROTO(struct xfs_scrub *sc, xfs_rfsblock_t data_blocks, 2600 xfs_rfsblock_t rt_blocks, xfs_rfsblock_t attr_blocks, 2601 xfs_extnum_t data_extents, xfs_extnum_t rt_extents, 2602 xfs_aextnum_t attr_extents), 2603 TP_ARGS(sc, data_blocks, rt_blocks, attr_blocks, data_extents, 2604 rt_extents, attr_extents), 2605 TP_STRUCT__entry( 2606 __field(dev_t, dev) 2607 __field(xfs_ino_t, ino) 2608 __field(xfs_rfsblock_t, data_blocks) 2609 __field(xfs_rfsblock_t, rt_blocks) 2610 __field(xfs_rfsblock_t, attr_blocks) 2611 __field(xfs_extnum_t, data_extents) 2612 __field(xfs_extnum_t, rt_extents) 2613 __field(xfs_aextnum_t, attr_extents) 2614 ), 2615 TP_fast_assign( 2616 __entry->dev = sc->mp->m_super->s_dev; 2617 __entry->ino = sc->sm->sm_ino; 2618 __entry->data_blocks = data_blocks; 2619 __entry->rt_blocks = rt_blocks; 2620 __entry->attr_blocks = attr_blocks; 2621 __entry->data_extents = data_extents; 2622 __entry->rt_extents = rt_extents; 2623 __entry->attr_extents = attr_extents; 2624 ), 2625 TP_printk("dev %d:%d ino 0x%llx dblocks 0x%llx rtblocks 0x%llx ablocks 0x%llx dextents %llu rtextents %llu aextents %u", 2626 MAJOR(__entry->dev), MINOR(__entry->dev), 2627 __entry->ino, 2628 __entry->data_blocks, 2629 __entry->rt_blocks, 2630 __entry->attr_blocks, 2631 __entry->data_extents, 2632 __entry->rt_extents, 2633 __entry->attr_extents) 2634 ); 2635 2636 TRACE_EVENT(xrep_dinode_findmode_dirent, 2637 TP_PROTO(struct xfs_scrub *sc, struct xfs_inode *dp, 2638 unsigned int ftype), 2639 TP_ARGS(sc, dp, ftype), 2640 TP_STRUCT__entry( 2641 __field(dev_t, dev) 2642 __field(xfs_ino_t, ino) 2643 __field(xfs_ino_t, parent_ino) 2644 __field(unsigned int, ftype) 2645 ), 2646 TP_fast_assign( 2647 __entry->dev = sc->mp->m_super->s_dev; 2648 __entry->ino = sc->sm->sm_ino; 2649 __entry->parent_ino = I_INO(dp); 2650 __entry->ftype = ftype; 2651 ), 2652 TP_printk("dev %d:%d ino 0x%llx parent_ino 0x%llx ftype '%s'", 2653 MAJOR(__entry->dev), MINOR(__entry->dev), 2654 __entry->ino, 2655 __entry->parent_ino, 2656 __print_symbolic(__entry->ftype, XFS_DIR3_FTYPE_STR)) 2657 ); 2658 2659 TRACE_EVENT(xrep_dinode_findmode_dirent_inval, 2660 TP_PROTO(struct xfs_scrub *sc, struct xfs_inode *dp, 2661 unsigned int ftype, unsigned int found_ftype), 2662 TP_ARGS(sc, dp, ftype, found_ftype), 2663 TP_STRUCT__entry( 2664 __field(dev_t, dev) 2665 __field(xfs_ino_t, ino) 2666 __field(xfs_ino_t, parent_ino) 2667 __field(unsigned int, ftype) 2668 __field(unsigned int, found_ftype) 2669 ), 2670 TP_fast_assign( 2671 __entry->dev = sc->mp->m_super->s_dev; 2672 __entry->ino = sc->sm->sm_ino; 2673 __entry->parent_ino = I_INO(dp); 2674 __entry->ftype = ftype; 2675 __entry->found_ftype = found_ftype; 2676 ), 2677 TP_printk("dev %d:%d ino 0x%llx parent_ino 0x%llx ftype '%s' found_ftype '%s'", 2678 MAJOR(__entry->dev), MINOR(__entry->dev), 2679 __entry->ino, 2680 __entry->parent_ino, 2681 __print_symbolic(__entry->ftype, XFS_DIR3_FTYPE_STR), 2682 __print_symbolic(__entry->found_ftype, XFS_DIR3_FTYPE_STR)) 2683 ); 2684 2685 TRACE_EVENT(xrep_cow_mark_file_range, 2686 TP_PROTO(struct xfs_inode *ip, xfs_fsblock_t startblock, 2687 xfs_fileoff_t startoff, xfs_filblks_t blockcount), 2688 TP_ARGS(ip, startblock, startoff, blockcount), 2689 TP_STRUCT__entry( 2690 __field(dev_t, dev) 2691 __field(xfs_ino_t, ino) 2692 __field(xfs_fsblock_t, startblock) 2693 __field(xfs_fileoff_t, startoff) 2694 __field(xfs_filblks_t, blockcount) 2695 ), 2696 TP_fast_assign( 2697 __entry->dev = ip->i_mount->m_super->s_dev; 2698 __entry->ino = I_INO(ip); 2699 __entry->startoff = startoff; 2700 __entry->startblock = startblock; 2701 __entry->blockcount = blockcount; 2702 ), 2703 TP_printk("dev %d:%d ino 0x%llx fileoff 0x%llx startblock 0x%llx fsbcount 0x%llx", 2704 MAJOR(__entry->dev), MINOR(__entry->dev), 2705 __entry->ino, 2706 __entry->startoff, 2707 __entry->startblock, 2708 __entry->blockcount) 2709 ); 2710 2711 TRACE_EVENT(xrep_cow_free_staging, 2712 TP_PROTO(const struct xfs_perag *pag, xfs_agblock_t agbno, 2713 xfs_extlen_t blockcount), 2714 TP_ARGS(pag, agbno, blockcount), 2715 TP_STRUCT__entry( 2716 __field(dev_t, dev) 2717 __field(xfs_agnumber_t, agno) 2718 __field(xfs_agblock_t, agbno) 2719 __field(xfs_extlen_t, blockcount) 2720 ), 2721 TP_fast_assign( 2722 __entry->dev = pag_mount(pag)->m_super->s_dev; 2723 __entry->agno = pag_agno(pag); 2724 __entry->agbno = agbno; 2725 __entry->blockcount = blockcount; 2726 ), 2727 TP_printk("dev %d:%d agno 0x%x agbno 0x%x fsbcount 0x%x", 2728 MAJOR(__entry->dev), MINOR(__entry->dev), 2729 __entry->agno, 2730 __entry->agbno, 2731 __entry->blockcount) 2732 ); 2733 2734 #ifdef CONFIG_XFS_QUOTA 2735 DECLARE_EVENT_CLASS(xrep_dquot_class, 2736 TP_PROTO(struct xfs_mount *mp, uint8_t type, uint32_t id), 2737 TP_ARGS(mp, type, id), 2738 TP_STRUCT__entry( 2739 __field(dev_t, dev) 2740 __field(uint8_t, type) 2741 __field(uint32_t, id) 2742 ), 2743 TP_fast_assign( 2744 __entry->dev = mp->m_super->s_dev; 2745 __entry->id = id; 2746 __entry->type = type; 2747 ), 2748 TP_printk("dev %d:%d type %s id 0x%x", 2749 MAJOR(__entry->dev), MINOR(__entry->dev), 2750 __print_flags(__entry->type, "|", XFS_DQTYPE_STRINGS), 2751 __entry->id) 2752 ); 2753 2754 #define DEFINE_XREP_DQUOT_EVENT(name) \ 2755 DEFINE_EVENT(xrep_dquot_class, name, \ 2756 TP_PROTO(struct xfs_mount *mp, uint8_t type, uint32_t id), \ 2757 TP_ARGS(mp, type, id)) 2758 DEFINE_XREP_DQUOT_EVENT(xrep_dquot_item); 2759 DEFINE_XREP_DQUOT_EVENT(xrep_disk_dquot); 2760 DEFINE_XREP_DQUOT_EVENT(xrep_dquot_item_fill_bmap_hole); 2761 DEFINE_XREP_DQUOT_EVENT(xrep_quotacheck_dquot); 2762 #endif /* CONFIG_XFS_QUOTA */ 2763 2764 DEFINE_SCRUB_NLINKS_DIFF_EVENT(xrep_nlinks_update_inode); 2765 DEFINE_SCRUB_NLINKS_DIFF_EVENT(xrep_nlinks_unfixable_inode); 2766 2767 TRACE_EVENT(xrep_rmap_live_update, 2768 TP_PROTO(const struct xfs_group *xg, unsigned int op, 2769 const struct xfs_rmap_update_params *p), 2770 TP_ARGS(xg, op, p), 2771 TP_STRUCT__entry( 2772 __field(dev_t, dev) 2773 __field(enum xfs_group_type, type) 2774 __field(xfs_agnumber_t, agno) 2775 __field(unsigned int, op) 2776 __field(xfs_agblock_t, agbno) 2777 __field(xfs_extlen_t, len) 2778 __field(uint64_t, owner) 2779 __field(uint64_t, offset) 2780 __field(unsigned int, flags) 2781 ), 2782 TP_fast_assign( 2783 __entry->dev = xg->xg_mount->m_super->s_dev; 2784 __entry->type = xg->xg_type; 2785 __entry->agno = xg->xg_gno; 2786 __entry->op = op; 2787 __entry->agbno = p->startblock; 2788 __entry->len = p->blockcount; 2789 xfs_owner_info_unpack(&p->oinfo, &__entry->owner, 2790 &__entry->offset, &__entry->flags); 2791 if (p->unwritten) 2792 __entry->flags |= XFS_RMAP_UNWRITTEN; 2793 ), 2794 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", 2795 MAJOR(__entry->dev), MINOR(__entry->dev), 2796 __print_symbolic(__entry->type, XG_TYPE_STRINGS), 2797 __entry->agno, 2798 __entry->op, 2799 __print_symbolic(__entry->type, XG_TYPE_STRINGS), 2800 __entry->agbno, 2801 __entry->len, 2802 __entry->owner, 2803 __entry->offset, 2804 __entry->flags) 2805 ); 2806 2807 TRACE_EVENT(xrep_tempfile_create, 2808 TP_PROTO(struct xfs_scrub *sc), 2809 TP_ARGS(sc), 2810 TP_STRUCT__entry( 2811 __field(dev_t, dev) 2812 __field(xfs_ino_t, ino) 2813 __field(unsigned int, type) 2814 __field(xfs_agnumber_t, agno) 2815 __field(xfs_ino_t, inum) 2816 __field(unsigned int, gen) 2817 __field(unsigned int, flags) 2818 __field(xfs_ino_t, temp_inum) 2819 ), 2820 TP_fast_assign( 2821 __entry->dev = sc->mp->m_super->s_dev; 2822 __entry->ino = sc->file ? file_inode(sc->file)->i_ino : 0; 2823 __entry->type = sc->sm->sm_type; 2824 __entry->agno = sc->sm->sm_agno; 2825 __entry->inum = sc->sm->sm_ino; 2826 __entry->gen = sc->sm->sm_gen; 2827 __entry->flags = sc->sm->sm_flags; 2828 __entry->temp_inum = I_INO(sc->tempip); 2829 ), 2830 TP_printk("dev %d:%d ino 0x%llx type %s inum 0x%llx gen 0x%x flags 0x%x temp_inum 0x%llx", 2831 MAJOR(__entry->dev), MINOR(__entry->dev), 2832 __entry->ino, 2833 __print_symbolic(__entry->type, XFS_SCRUB_TYPE_STRINGS), 2834 __entry->inum, 2835 __entry->gen, 2836 __entry->flags, 2837 __entry->temp_inum) 2838 ); 2839 2840 DECLARE_EVENT_CLASS(xrep_tempfile_class, 2841 TP_PROTO(struct xfs_scrub *sc, int whichfork, 2842 struct xfs_bmbt_irec *irec), 2843 TP_ARGS(sc, 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, lblk) 2849 __field(xfs_filblks_t, len) 2850 __field(xfs_fsblock_t, pblk) 2851 __field(int, state) 2852 ), 2853 TP_fast_assign( 2854 __entry->dev = sc->mp->m_super->s_dev; 2855 __entry->ino = I_INO(sc->tempip); 2856 __entry->whichfork = whichfork; 2857 __entry->lblk = irec->br_startoff; 2858 __entry->len = irec->br_blockcount; 2859 __entry->pblk = irec->br_startblock; 2860 __entry->state = irec->br_state; 2861 ), 2862 TP_printk("dev %d:%d ino 0x%llx whichfork %s fileoff 0x%llx fsbcount 0x%llx startblock 0x%llx state %d", 2863 MAJOR(__entry->dev), MINOR(__entry->dev), 2864 __entry->ino, 2865 __print_symbolic(__entry->whichfork, XFS_WHICHFORK_STRINGS), 2866 __entry->lblk, 2867 __entry->len, 2868 __entry->pblk, 2869 __entry->state) 2870 ); 2871 #define DEFINE_XREP_TEMPFILE_EVENT(name) \ 2872 DEFINE_EVENT(xrep_tempfile_class, name, \ 2873 TP_PROTO(struct xfs_scrub *sc, int whichfork, \ 2874 struct xfs_bmbt_irec *irec), \ 2875 TP_ARGS(sc, whichfork, irec)) 2876 DEFINE_XREP_TEMPFILE_EVENT(xrep_tempfile_prealloc); 2877 DEFINE_XREP_TEMPFILE_EVENT(xrep_tempfile_copyin); 2878 2879 TRACE_EVENT(xreap_ifork_extent, 2880 TP_PROTO(struct xfs_scrub *sc, struct xfs_inode *ip, int whichfork, 2881 const struct xfs_bmbt_irec *irec), 2882 TP_ARGS(sc, ip, whichfork, irec), 2883 TP_STRUCT__entry( 2884 __field(dev_t, dev) 2885 __field(xfs_ino_t, ino) 2886 __field(int, whichfork) 2887 __field(xfs_fileoff_t, fileoff) 2888 __field(xfs_filblks_t, len) 2889 __field(xfs_agnumber_t, agno) 2890 __field(xfs_agblock_t, agbno) 2891 __field(int, state) 2892 ), 2893 TP_fast_assign( 2894 __entry->dev = sc->mp->m_super->s_dev; 2895 __entry->ino = I_INO(ip); 2896 __entry->whichfork = whichfork; 2897 __entry->fileoff = irec->br_startoff; 2898 __entry->len = irec->br_blockcount; 2899 __entry->agno = XFS_FSB_TO_AGNO(sc->mp, irec->br_startblock); 2900 __entry->agbno = XFS_FSB_TO_AGBNO(sc->mp, irec->br_startblock); 2901 __entry->state = irec->br_state; 2902 ), 2903 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", 2904 MAJOR(__entry->dev), MINOR(__entry->dev), 2905 __entry->ino, 2906 __print_symbolic(__entry->whichfork, XFS_WHICHFORK_STRINGS), 2907 __entry->agno, 2908 __entry->agbno, 2909 __entry->fileoff, 2910 __entry->len, 2911 __entry->state) 2912 ); 2913 2914 TRACE_EVENT(xreap_bmapi_binval_scan, 2915 TP_PROTO(struct xfs_scrub *sc, const struct xfs_bmbt_irec *irec, 2916 xfs_extlen_t scan_blocks), 2917 TP_ARGS(sc, irec, scan_blocks), 2918 TP_STRUCT__entry( 2919 __field(dev_t, dev) 2920 __field(xfs_filblks_t, len) 2921 __field(xfs_agnumber_t, agno) 2922 __field(xfs_agblock_t, agbno) 2923 __field(xfs_extlen_t, scan_blocks) 2924 ), 2925 TP_fast_assign( 2926 __entry->dev = sc->mp->m_super->s_dev; 2927 __entry->len = irec->br_blockcount; 2928 __entry->agno = XFS_FSB_TO_AGNO(sc->mp, irec->br_startblock); 2929 __entry->agbno = XFS_FSB_TO_AGBNO(sc->mp, irec->br_startblock); 2930 __entry->scan_blocks = scan_blocks; 2931 ), 2932 TP_printk("dev %d:%d agno 0x%x agbno 0x%x fsbcount 0x%llx scan_blocks 0x%x", 2933 MAJOR(__entry->dev), MINOR(__entry->dev), 2934 __entry->agno, 2935 __entry->agbno, 2936 __entry->len, 2937 __entry->scan_blocks) 2938 ); 2939 2940 TRACE_EVENT(xrep_xattr_recover_leafblock, 2941 TP_PROTO(struct xfs_inode *ip, xfs_dablk_t dabno, uint16_t magic), 2942 TP_ARGS(ip, dabno, magic), 2943 TP_STRUCT__entry( 2944 __field(dev_t, dev) 2945 __field(xfs_ino_t, ino) 2946 __field(xfs_dablk_t, dabno) 2947 __field(uint16_t, magic) 2948 ), 2949 TP_fast_assign( 2950 __entry->dev = ip->i_mount->m_super->s_dev; 2951 __entry->ino = I_INO(ip); 2952 __entry->dabno = dabno; 2953 __entry->magic = magic; 2954 ), 2955 TP_printk("dev %d:%d ino 0x%llx dablk 0x%x magic 0x%x", 2956 MAJOR(__entry->dev), MINOR(__entry->dev), 2957 __entry->ino, 2958 __entry->dabno, 2959 __entry->magic) 2960 ); 2961 2962 DECLARE_EVENT_CLASS(xrep_xattr_salvage_class, 2963 TP_PROTO(struct xfs_inode *ip, unsigned int flags, char *name, 2964 unsigned int namelen, unsigned int valuelen), 2965 TP_ARGS(ip, flags, name, namelen, valuelen), 2966 TP_STRUCT__entry( 2967 __field(dev_t, dev) 2968 __field(xfs_ino_t, ino) 2969 __field(unsigned int, flags) 2970 __field(unsigned int, namelen) 2971 __dynamic_array(char, name, namelen) 2972 __field(unsigned int, valuelen) 2973 ), 2974 TP_fast_assign( 2975 __entry->dev = ip->i_mount->m_super->s_dev; 2976 __entry->ino = I_INO(ip); 2977 __entry->flags = flags; 2978 __entry->namelen = namelen; 2979 memcpy(__get_str(name), name, namelen); 2980 __entry->valuelen = valuelen; 2981 ), 2982 TP_printk("dev %d:%d ino 0x%llx flags %s name '%.*s' valuelen 0x%x", 2983 MAJOR(__entry->dev), MINOR(__entry->dev), 2984 __entry->ino, 2985 __print_flags(__entry->flags, "|", XFS_ATTR_NAMESPACE_STR), 2986 __entry->namelen, 2987 __get_str(name), 2988 __entry->valuelen) 2989 ); 2990 #define DEFINE_XREP_XATTR_SALVAGE_EVENT(name) \ 2991 DEFINE_EVENT(xrep_xattr_salvage_class, name, \ 2992 TP_PROTO(struct xfs_inode *ip, unsigned int flags, char *name, \ 2993 unsigned int namelen, unsigned int valuelen), \ 2994 TP_ARGS(ip, flags, name, namelen, valuelen)) 2995 DEFINE_XREP_XATTR_SALVAGE_EVENT(xrep_xattr_salvage_rec); 2996 DEFINE_XREP_XATTR_SALVAGE_EVENT(xrep_xattr_insert_rec); 2997 DEFINE_XREP_XATTR_SALVAGE_EVENT(xrep_parent_stash_xattr); 2998 DEFINE_XREP_XATTR_SALVAGE_EVENT(xrep_parent_insert_xattr); 2999 3000 DECLARE_EVENT_CLASS(xrep_pptr_salvage_class, 3001 TP_PROTO(struct xfs_inode *ip, unsigned int flags, const void *name, 3002 unsigned int namelen, const void *value, unsigned int valuelen), 3003 TP_ARGS(ip, flags, name, namelen, value, valuelen), 3004 TP_STRUCT__entry( 3005 __field(dev_t, dev) 3006 __field(xfs_ino_t, ino) 3007 __field(xfs_ino_t, parent_ino) 3008 __field(unsigned int, parent_gen) 3009 __field(unsigned int, namelen) 3010 __dynamic_array(char, name, namelen) 3011 ), 3012 TP_fast_assign( 3013 const struct xfs_parent_rec *rec = value; 3014 3015 __entry->dev = ip->i_mount->m_super->s_dev; 3016 __entry->ino = I_INO(ip); 3017 __entry->parent_ino = be64_to_cpu(rec->p_ino); 3018 __entry->parent_gen = be32_to_cpu(rec->p_gen); 3019 __entry->namelen = namelen; 3020 memcpy(__get_str(name), name, namelen); 3021 ), 3022 TP_printk("dev %d:%d ino 0x%llx parent_ino 0x%llx parent_gen 0x%x name '%.*s'", 3023 MAJOR(__entry->dev), MINOR(__entry->dev), 3024 __entry->ino, 3025 __entry->parent_ino, 3026 __entry->parent_gen, 3027 __entry->namelen, 3028 __get_str(name)) 3029 ) 3030 #define DEFINE_XREP_PPTR_SALVAGE_EVENT(name) \ 3031 DEFINE_EVENT(xrep_pptr_salvage_class, name, \ 3032 TP_PROTO(struct xfs_inode *ip, unsigned int flags, const void *name, \ 3033 unsigned int namelen, const void *value, unsigned int valuelen), \ 3034 TP_ARGS(ip, flags, name, namelen, value, valuelen)) 3035 DEFINE_XREP_PPTR_SALVAGE_EVENT(xrep_xattr_salvage_pptr); 3036 DEFINE_XREP_PPTR_SALVAGE_EVENT(xrep_xattr_insert_pptr); 3037 3038 DECLARE_EVENT_CLASS(xrep_xattr_class, 3039 TP_PROTO(struct xfs_inode *ip, struct xfs_inode *arg_ip), 3040 TP_ARGS(ip, arg_ip), 3041 TP_STRUCT__entry( 3042 __field(dev_t, dev) 3043 __field(xfs_ino_t, ino) 3044 __field(xfs_ino_t, src_ino) 3045 ), 3046 TP_fast_assign( 3047 __entry->dev = ip->i_mount->m_super->s_dev; 3048 __entry->ino = I_INO(ip); 3049 __entry->src_ino = I_INO(arg_ip); 3050 ), 3051 TP_printk("dev %d:%d ino 0x%llx src 0x%llx", 3052 MAJOR(__entry->dev), MINOR(__entry->dev), 3053 __entry->ino, 3054 __entry->src_ino) 3055 ) 3056 #define DEFINE_XREP_XATTR_EVENT(name) \ 3057 DEFINE_EVENT(xrep_xattr_class, name, \ 3058 TP_PROTO(struct xfs_inode *ip, struct xfs_inode *arg_ip), \ 3059 TP_ARGS(ip, arg_ip)) 3060 DEFINE_XREP_XATTR_EVENT(xrep_xattr_rebuild_tree); 3061 DEFINE_XREP_XATTR_EVENT(xrep_xattr_reset_fork); 3062 DEFINE_XREP_XATTR_EVENT(xrep_xattr_full_reset); 3063 3064 DECLARE_EVENT_CLASS(xrep_xattr_pptr_scan_class, 3065 TP_PROTO(struct xfs_inode *ip, const struct xfs_inode *dp, 3066 const struct xfs_name *name), 3067 TP_ARGS(ip, dp, name), 3068 TP_STRUCT__entry( 3069 __field(dev_t, dev) 3070 __field(xfs_ino_t, ino) 3071 __field(xfs_ino_t, parent_ino) 3072 __field(unsigned int, parent_gen) 3073 __field(unsigned int, namelen) 3074 __dynamic_array(char, name, name->len) 3075 ), 3076 TP_fast_assign( 3077 __entry->dev = ip->i_mount->m_super->s_dev; 3078 __entry->ino = I_INO(ip); 3079 __entry->parent_ino = I_INO(dp); 3080 __entry->parent_gen = VFS_IC(dp)->i_generation; 3081 __entry->namelen = name->len; 3082 memcpy(__get_str(name), name->name, name->len); 3083 ), 3084 TP_printk("dev %d:%d ino 0x%llx parent_ino 0x%llx parent_gen 0x%x name '%.*s'", 3085 MAJOR(__entry->dev), MINOR(__entry->dev), 3086 __entry->ino, 3087 __entry->parent_ino, 3088 __entry->parent_gen, 3089 __entry->namelen, 3090 __get_str(name)) 3091 ) 3092 #define DEFINE_XREP_XATTR_PPTR_SCAN_EVENT(name) \ 3093 DEFINE_EVENT(xrep_xattr_pptr_scan_class, name, \ 3094 TP_PROTO(struct xfs_inode *ip, const struct xfs_inode *dp, \ 3095 const struct xfs_name *name), \ 3096 TP_ARGS(ip, dp, name)) 3097 DEFINE_XREP_XATTR_PPTR_SCAN_EVENT(xrep_xattr_stash_parentadd); 3098 DEFINE_XREP_XATTR_PPTR_SCAN_EVENT(xrep_xattr_stash_parentremove); 3099 3100 TRACE_EVENT(xrep_dir_recover_dirblock, 3101 TP_PROTO(struct xfs_inode *dp, xfs_dablk_t dabno, uint32_t magic, 3102 uint32_t magic_guess), 3103 TP_ARGS(dp, dabno, magic, magic_guess), 3104 TP_STRUCT__entry( 3105 __field(dev_t, dev) 3106 __field(xfs_ino_t, dir_ino) 3107 __field(xfs_dablk_t, dabno) 3108 __field(uint32_t, magic) 3109 __field(uint32_t, magic_guess) 3110 ), 3111 TP_fast_assign( 3112 __entry->dev = dp->i_mount->m_super->s_dev; 3113 __entry->dir_ino = I_INO(dp); 3114 __entry->dabno = dabno; 3115 __entry->magic = magic; 3116 __entry->magic_guess = magic_guess; 3117 ), 3118 TP_printk("dev %d:%d dir 0x%llx dablk 0x%x magic 0x%x magic_guess 0x%x", 3119 MAJOR(__entry->dev), MINOR(__entry->dev), 3120 __entry->dir_ino, 3121 __entry->dabno, 3122 __entry->magic, 3123 __entry->magic_guess) 3124 ); 3125 3126 DECLARE_EVENT_CLASS(xrep_dir_class, 3127 TP_PROTO(struct xfs_inode *dp, xfs_ino_t parent_ino), 3128 TP_ARGS(dp, parent_ino), 3129 TP_STRUCT__entry( 3130 __field(dev_t, dev) 3131 __field(xfs_ino_t, dir_ino) 3132 __field(xfs_ino_t, parent_ino) 3133 ), 3134 TP_fast_assign( 3135 __entry->dev = dp->i_mount->m_super->s_dev; 3136 __entry->dir_ino = I_INO(dp); 3137 __entry->parent_ino = parent_ino; 3138 ), 3139 TP_printk("dev %d:%d dir 0x%llx parent 0x%llx", 3140 MAJOR(__entry->dev), MINOR(__entry->dev), 3141 __entry->dir_ino, 3142 __entry->parent_ino) 3143 ) 3144 #define DEFINE_XREP_DIR_EVENT(name) \ 3145 DEFINE_EVENT(xrep_dir_class, name, \ 3146 TP_PROTO(struct xfs_inode *dp, xfs_ino_t parent_ino), \ 3147 TP_ARGS(dp, parent_ino)) 3148 DEFINE_XREP_DIR_EVENT(xrep_dir_rebuild_tree); 3149 DEFINE_XREP_DIR_EVENT(xrep_dir_reset_fork); 3150 DEFINE_XREP_DIR_EVENT(xrep_parent_reset_dotdot); 3151 3152 DECLARE_EVENT_CLASS(xrep_dirent_class, 3153 TP_PROTO(struct xfs_inode *dp, const struct xfs_name *name, 3154 xfs_ino_t ino), 3155 TP_ARGS(dp, name, ino), 3156 TP_STRUCT__entry( 3157 __field(dev_t, dev) 3158 __field(xfs_ino_t, dir_ino) 3159 __field(unsigned int, namelen) 3160 __dynamic_array(char, name, name->len) 3161 __field(xfs_ino_t, ino) 3162 __field(uint8_t, ftype) 3163 ), 3164 TP_fast_assign( 3165 __entry->dev = dp->i_mount->m_super->s_dev; 3166 __entry->dir_ino = I_INO(dp); 3167 __entry->namelen = name->len; 3168 memcpy(__get_str(name), name->name, name->len); 3169 __entry->ino = ino; 3170 __entry->ftype = name->type; 3171 ), 3172 TP_printk("dev %d:%d dir 0x%llx ftype %s name '%.*s' ino 0x%llx", 3173 MAJOR(__entry->dev), MINOR(__entry->dev), 3174 __entry->dir_ino, 3175 __print_symbolic(__entry->ftype, XFS_DIR3_FTYPE_STR), 3176 __entry->namelen, 3177 __get_str(name), 3178 __entry->ino) 3179 ) 3180 #define DEFINE_XREP_DIRENT_EVENT(name) \ 3181 DEFINE_EVENT(xrep_dirent_class, name, \ 3182 TP_PROTO(struct xfs_inode *dp, const struct xfs_name *name, \ 3183 xfs_ino_t ino), \ 3184 TP_ARGS(dp, name, ino)) 3185 DEFINE_XREP_DIRENT_EVENT(xrep_dir_salvage_entry); 3186 DEFINE_XREP_DIRENT_EVENT(xrep_dir_stash_createname); 3187 DEFINE_XREP_DIRENT_EVENT(xrep_dir_replay_createname); 3188 DEFINE_XREP_DIRENT_EVENT(xrep_adoption_reparent); 3189 DEFINE_XREP_DIRENT_EVENT(xrep_dir_stash_removename); 3190 DEFINE_XREP_DIRENT_EVENT(xrep_dir_replay_removename); 3191 3192 DECLARE_EVENT_CLASS(xrep_adoption_class, 3193 TP_PROTO(struct xfs_inode *dp, struct xfs_inode *ip, bool moved), 3194 TP_ARGS(dp, ip, moved), 3195 TP_STRUCT__entry( 3196 __field(dev_t, dev) 3197 __field(xfs_ino_t, dir_ino) 3198 __field(xfs_ino_t, child_ino) 3199 __field(bool, moved) 3200 ), 3201 TP_fast_assign( 3202 __entry->dev = dp->i_mount->m_super->s_dev; 3203 __entry->dir_ino = I_INO(dp); 3204 __entry->child_ino = I_INO(ip); 3205 __entry->moved = moved; 3206 ), 3207 TP_printk("dev %d:%d dir 0x%llx child 0x%llx moved? %d", 3208 MAJOR(__entry->dev), MINOR(__entry->dev), 3209 __entry->dir_ino, 3210 __entry->child_ino, 3211 __entry->moved) 3212 ); 3213 #define DEFINE_XREP_ADOPTION_EVENT(name) \ 3214 DEFINE_EVENT(xrep_adoption_class, name, \ 3215 TP_PROTO(struct xfs_inode *dp, struct xfs_inode *ip, bool moved), \ 3216 TP_ARGS(dp, ip, moved)) 3217 DEFINE_XREP_ADOPTION_EVENT(xrep_adoption_trans_roll); 3218 3219 DECLARE_EVENT_CLASS(xrep_parent_salvage_class, 3220 TP_PROTO(struct xfs_inode *dp, xfs_ino_t ino), 3221 TP_ARGS(dp, ino), 3222 TP_STRUCT__entry( 3223 __field(dev_t, dev) 3224 __field(xfs_ino_t, dir_ino) 3225 __field(xfs_ino_t, ino) 3226 ), 3227 TP_fast_assign( 3228 __entry->dev = dp->i_mount->m_super->s_dev; 3229 __entry->dir_ino = I_INO(dp); 3230 __entry->ino = ino; 3231 ), 3232 TP_printk("dev %d:%d dir 0x%llx parent 0x%llx", 3233 MAJOR(__entry->dev), MINOR(__entry->dev), 3234 __entry->dir_ino, 3235 __entry->ino) 3236 ) 3237 #define DEFINE_XREP_PARENT_SALVAGE_EVENT(name) \ 3238 DEFINE_EVENT(xrep_parent_salvage_class, name, \ 3239 TP_PROTO(struct xfs_inode *dp, xfs_ino_t ino), \ 3240 TP_ARGS(dp, ino)) 3241 DEFINE_XREP_PARENT_SALVAGE_EVENT(xrep_dir_salvaged_parent); 3242 DEFINE_XREP_PARENT_SALVAGE_EVENT(xrep_findparent_dirent); 3243 DEFINE_XREP_PARENT_SALVAGE_EVENT(xrep_findparent_from_dcache); 3244 3245 DECLARE_EVENT_CLASS(xrep_pptr_class, 3246 TP_PROTO(struct xfs_inode *ip, const struct xfs_name *name, 3247 const struct xfs_parent_rec *pptr), 3248 TP_ARGS(ip, name, pptr), 3249 TP_STRUCT__entry( 3250 __field(dev_t, dev) 3251 __field(xfs_ino_t, ino) 3252 __field(xfs_ino_t, parent_ino) 3253 __field(unsigned int, parent_gen) 3254 __field(unsigned int, namelen) 3255 __dynamic_array(char, name, name->len) 3256 ), 3257 TP_fast_assign( 3258 __entry->dev = ip->i_mount->m_super->s_dev; 3259 __entry->ino = I_INO(ip); 3260 __entry->parent_ino = be64_to_cpu(pptr->p_ino); 3261 __entry->parent_gen = be32_to_cpu(pptr->p_gen); 3262 __entry->namelen = name->len; 3263 memcpy(__get_str(name), name->name, name->len); 3264 ), 3265 TP_printk("dev %d:%d ino 0x%llx parent_ino 0x%llx parent_gen 0x%x name '%.*s'", 3266 MAJOR(__entry->dev), MINOR(__entry->dev), 3267 __entry->ino, 3268 __entry->parent_ino, 3269 __entry->parent_gen, 3270 __entry->namelen, 3271 __get_str(name)) 3272 ) 3273 #define DEFINE_XREP_PPTR_EVENT(name) \ 3274 DEFINE_EVENT(xrep_pptr_class, name, \ 3275 TP_PROTO(struct xfs_inode *ip, const struct xfs_name *name, \ 3276 const struct xfs_parent_rec *pptr), \ 3277 TP_ARGS(ip, name, pptr)) 3278 DEFINE_XREP_PPTR_EVENT(xrep_xattr_replay_parentadd); 3279 DEFINE_XREP_PPTR_EVENT(xrep_xattr_replay_parentremove); 3280 DEFINE_XREP_PPTR_EVENT(xrep_parent_replay_parentadd); 3281 DEFINE_XREP_PPTR_EVENT(xrep_parent_replay_parentremove); 3282 3283 DECLARE_EVENT_CLASS(xrep_pptr_scan_class, 3284 TP_PROTO(struct xfs_inode *ip, const struct xfs_inode *dp, 3285 const struct xfs_name *name), 3286 TP_ARGS(ip, dp, name), 3287 TP_STRUCT__entry( 3288 __field(dev_t, dev) 3289 __field(xfs_ino_t, ino) 3290 __field(xfs_ino_t, parent_ino) 3291 __field(unsigned int, parent_gen) 3292 __field(unsigned int, namelen) 3293 __dynamic_array(char, name, name->len) 3294 ), 3295 TP_fast_assign( 3296 __entry->dev = ip->i_mount->m_super->s_dev; 3297 __entry->ino = I_INO(ip); 3298 __entry->parent_ino = I_INO(dp); 3299 __entry->parent_gen = VFS_IC(dp)->i_generation; 3300 __entry->namelen = name->len; 3301 memcpy(__get_str(name), name->name, name->len); 3302 ), 3303 TP_printk("dev %d:%d ino 0x%llx parent_ino 0x%llx parent_gen 0x%x name '%.*s'", 3304 MAJOR(__entry->dev), MINOR(__entry->dev), 3305 __entry->ino, 3306 __entry->parent_ino, 3307 __entry->parent_gen, 3308 __entry->namelen, 3309 __get_str(name)) 3310 ) 3311 #define DEFINE_XREP_PPTR_SCAN_EVENT(name) \ 3312 DEFINE_EVENT(xrep_pptr_scan_class, name, \ 3313 TP_PROTO(struct xfs_inode *ip, const struct xfs_inode *dp, \ 3314 const struct xfs_name *name), \ 3315 TP_ARGS(ip, dp, name)) 3316 DEFINE_XREP_PPTR_SCAN_EVENT(xrep_parent_stash_parentadd); 3317 DEFINE_XREP_PPTR_SCAN_EVENT(xrep_parent_stash_parentremove); 3318 3319 TRACE_EVENT(xrep_nlinks_set_record, 3320 TP_PROTO(struct xfs_mount *mp, xfs_ino_t ino, 3321 const struct xchk_nlink *obs), 3322 TP_ARGS(mp, ino, obs), 3323 TP_STRUCT__entry( 3324 __field(dev_t, dev) 3325 __field(xfs_ino_t, ino) 3326 __field(xfs_nlink_t, parents) 3327 __field(xfs_nlink_t, backrefs) 3328 __field(xfs_nlink_t, children) 3329 ), 3330 TP_fast_assign( 3331 __entry->dev = mp->m_super->s_dev; 3332 __entry->ino = ino; 3333 __entry->parents = obs->parents; 3334 __entry->backrefs = obs->backrefs; 3335 __entry->children = obs->children; 3336 ), 3337 TP_printk("dev %d:%d ino 0x%llx parents %u backrefs %u children %u", 3338 MAJOR(__entry->dev), MINOR(__entry->dev), 3339 __entry->ino, 3340 __entry->parents, 3341 __entry->backrefs, 3342 __entry->children) 3343 ); 3344 3345 DECLARE_EVENT_CLASS(xrep_dentry_class, 3346 TP_PROTO(struct xfs_mount *mp, const struct dentry *dentry), 3347 TP_ARGS(mp, dentry), 3348 TP_STRUCT__entry( 3349 __field(dev_t, dev) 3350 __field(unsigned int, flags) 3351 __field(unsigned long, ino) 3352 __field(bool, positive) 3353 __field(unsigned long, parent_ino) 3354 __field(unsigned int, namelen) 3355 __dynamic_array(char, name, dentry->d_name.len) 3356 ), 3357 TP_fast_assign( 3358 __entry->dev = mp->m_super->s_dev; 3359 __entry->flags = dentry->d_flags; 3360 __entry->positive = d_is_positive(dentry); 3361 if (dentry->d_parent && d_inode(dentry->d_parent)) 3362 __entry->parent_ino = d_inode(dentry->d_parent)->i_ino; 3363 else 3364 __entry->parent_ino = -1UL; 3365 __entry->ino = d_inode(dentry) ? d_inode(dentry)->i_ino : 0; 3366 __entry->namelen = dentry->d_name.len; 3367 memcpy(__get_str(name), dentry->d_name.name, dentry->d_name.len); 3368 ), 3369 TP_printk("dev %d:%d flags 0x%x positive? %d parent_ino 0x%lx ino 0x%lx name '%.*s'", 3370 MAJOR(__entry->dev), MINOR(__entry->dev), 3371 __entry->flags, 3372 __entry->positive, 3373 __entry->parent_ino, 3374 __entry->ino, 3375 __entry->namelen, 3376 __get_str(name)) 3377 ); 3378 #define DEFINE_REPAIR_DENTRY_EVENT(name) \ 3379 DEFINE_EVENT(xrep_dentry_class, name, \ 3380 TP_PROTO(struct xfs_mount *mp, const struct dentry *dentry), \ 3381 TP_ARGS(mp, dentry)) 3382 DEFINE_REPAIR_DENTRY_EVENT(xrep_adoption_check_child); 3383 DEFINE_REPAIR_DENTRY_EVENT(xrep_adoption_invalidate_child); 3384 DEFINE_REPAIR_DENTRY_EVENT(xrep_dirtree_delete_child); 3385 3386 TRACE_EVENT(xrep_symlink_salvage_target, 3387 TP_PROTO(struct xfs_inode *ip, char *target, unsigned int targetlen), 3388 TP_ARGS(ip, target, targetlen), 3389 TP_STRUCT__entry( 3390 __field(dev_t, dev) 3391 __field(xfs_ino_t, ino) 3392 __field(unsigned int, targetlen) 3393 __dynamic_array(char, target, targetlen + 1) 3394 ), 3395 TP_fast_assign( 3396 __entry->dev = ip->i_mount->m_super->s_dev; 3397 __entry->ino = I_INO(ip); 3398 __entry->targetlen = targetlen; 3399 memcpy(__get_str(target), target, targetlen); 3400 __get_str(target)[targetlen] = 0; 3401 ), 3402 TP_printk("dev %d:%d ip 0x%llx target '%.*s'", 3403 MAJOR(__entry->dev), MINOR(__entry->dev), 3404 __entry->ino, 3405 __entry->targetlen, 3406 __get_str(target)) 3407 ); 3408 3409 DECLARE_EVENT_CLASS(xrep_symlink_class, 3410 TP_PROTO(struct xfs_inode *ip), 3411 TP_ARGS(ip), 3412 TP_STRUCT__entry( 3413 __field(dev_t, dev) 3414 __field(xfs_ino_t, ino) 3415 ), 3416 TP_fast_assign( 3417 __entry->dev = ip->i_mount->m_super->s_dev; 3418 __entry->ino = I_INO(ip); 3419 ), 3420 TP_printk("dev %d:%d ip 0x%llx", 3421 MAJOR(__entry->dev), MINOR(__entry->dev), 3422 __entry->ino) 3423 ); 3424 3425 #define DEFINE_XREP_SYMLINK_EVENT(name) \ 3426 DEFINE_EVENT(xrep_symlink_class, name, \ 3427 TP_PROTO(struct xfs_inode *ip), \ 3428 TP_ARGS(ip)) 3429 DEFINE_XREP_SYMLINK_EVENT(xrep_symlink_rebuild); 3430 DEFINE_XREP_SYMLINK_EVENT(xrep_symlink_reset_fork); 3431 3432 TRACE_EVENT(xrep_iunlink_visit, 3433 TP_PROTO(const struct xfs_perag *pag, unsigned int bucket, 3434 xfs_agino_t bucket_agino, struct xfs_inode *ip), 3435 TP_ARGS(pag, bucket, bucket_agino, ip), 3436 TP_STRUCT__entry( 3437 __field(dev_t, dev) 3438 __field(xfs_agnumber_t, agno) 3439 __field(xfs_agino_t, agino) 3440 __field(unsigned int, bucket) 3441 __field(xfs_agino_t, bucket_agino) 3442 __field(xfs_agino_t, prev_agino) 3443 __field(xfs_agino_t, next_agino) 3444 ), 3445 TP_fast_assign( 3446 __entry->dev = pag_mount(pag)->m_super->s_dev; 3447 __entry->agno = pag_agno(pag); 3448 __entry->agino = XFS_INODE_TO_AGINO(ip); 3449 __entry->bucket = bucket; 3450 __entry->bucket_agino = bucket_agino; 3451 __entry->prev_agino = ip->i_prev_unlinked; 3452 __entry->next_agino = ip->i_next_unlinked; 3453 ), 3454 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", 3455 MAJOR(__entry->dev), MINOR(__entry->dev), 3456 __entry->agno, 3457 __entry->bucket, 3458 __entry->agino, 3459 __entry->bucket_agino, 3460 __entry->prev_agino, 3461 __entry->next_agino) 3462 ); 3463 3464 TRACE_EVENT(xrep_iunlink_reload_next, 3465 TP_PROTO(struct xfs_inode *ip, xfs_agino_t prev_agino), 3466 TP_ARGS(ip, prev_agino), 3467 TP_STRUCT__entry( 3468 __field(dev_t, dev) 3469 __field(xfs_agnumber_t, agno) 3470 __field(xfs_agino_t, agino) 3471 __field(xfs_agino_t, old_prev_agino) 3472 __field(xfs_agino_t, prev_agino) 3473 __field(xfs_agino_t, next_agino) 3474 __field(unsigned int, nlink) 3475 ), 3476 TP_fast_assign( 3477 __entry->dev = ip->i_mount->m_super->s_dev; 3478 __entry->agno = XFS_INODE_TO_AGNO(ip); 3479 __entry->agino = XFS_INODE_TO_AGINO(ip); 3480 __entry->old_prev_agino = ip->i_prev_unlinked; 3481 __entry->prev_agino = prev_agino; 3482 __entry->next_agino = ip->i_next_unlinked; 3483 __entry->nlink = VFS_I(ip)->i_nlink; 3484 ), 3485 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", 3486 MAJOR(__entry->dev), MINOR(__entry->dev), 3487 __entry->agno, 3488 __entry->agino % XFS_AGI_UNLINKED_BUCKETS, 3489 __entry->agino, 3490 __entry->nlink, 3491 __entry->old_prev_agino, 3492 __entry->prev_agino, 3493 __entry->next_agino) 3494 ); 3495 3496 TRACE_EVENT(xrep_iunlink_reload_ondisk, 3497 TP_PROTO(struct xfs_inode *ip), 3498 TP_ARGS(ip), 3499 TP_STRUCT__entry( 3500 __field(dev_t, dev) 3501 __field(xfs_agnumber_t, agno) 3502 __field(xfs_agino_t, agino) 3503 __field(unsigned int, nlink) 3504 __field(xfs_agino_t, next_agino) 3505 ), 3506 TP_fast_assign( 3507 __entry->dev = ip->i_mount->m_super->s_dev; 3508 __entry->agno = XFS_INODE_TO_AGNO(ip); 3509 __entry->agino = XFS_INODE_TO_AGINO(ip); 3510 __entry->nlink = VFS_I(ip)->i_nlink; 3511 __entry->next_agino = ip->i_next_unlinked; 3512 ), 3513 TP_printk("dev %d:%d agno 0x%x bucket %u agino 0x%x nlink %u next_agino 0x%x", 3514 MAJOR(__entry->dev), MINOR(__entry->dev), 3515 __entry->agno, 3516 __entry->agino % XFS_AGI_UNLINKED_BUCKETS, 3517 __entry->agino, 3518 __entry->nlink, 3519 __entry->next_agino) 3520 ); 3521 3522 TRACE_EVENT(xrep_iunlink_walk_ondisk_bucket, 3523 TP_PROTO(const struct xfs_perag *pag, unsigned int bucket, 3524 xfs_agino_t prev_agino, xfs_agino_t next_agino), 3525 TP_ARGS(pag, bucket, prev_agino, next_agino), 3526 TP_STRUCT__entry( 3527 __field(dev_t, dev) 3528 __field(xfs_agnumber_t, agno) 3529 __field(unsigned int, bucket) 3530 __field(xfs_agino_t, prev_agino) 3531 __field(xfs_agino_t, next_agino) 3532 ), 3533 TP_fast_assign( 3534 __entry->dev = pag_mount(pag)->m_super->s_dev; 3535 __entry->agno = pag_agno(pag); 3536 __entry->bucket = bucket; 3537 __entry->prev_agino = prev_agino; 3538 __entry->next_agino = next_agino; 3539 ), 3540 TP_printk("dev %d:%d agno 0x%x bucket %u prev_agino 0x%x next_agino 0x%x", 3541 MAJOR(__entry->dev), MINOR(__entry->dev), 3542 __entry->agno, 3543 __entry->bucket, 3544 __entry->prev_agino, 3545 __entry->next_agino) 3546 ); 3547 3548 DECLARE_EVENT_CLASS(xrep_iunlink_resolve_class, 3549 TP_PROTO(const struct xfs_perag *pag, unsigned int bucket, 3550 xfs_agino_t prev_agino, xfs_agino_t next_agino), 3551 TP_ARGS(pag, bucket, prev_agino, next_agino), 3552 TP_STRUCT__entry( 3553 __field(dev_t, dev) 3554 __field(xfs_agnumber_t, agno) 3555 __field(unsigned int, bucket) 3556 __field(xfs_agino_t, prev_agino) 3557 __field(xfs_agino_t, next_agino) 3558 ), 3559 TP_fast_assign( 3560 __entry->dev = pag_mount(pag)->m_super->s_dev; 3561 __entry->agno = pag_agno(pag); 3562 __entry->bucket = bucket; 3563 __entry->prev_agino = prev_agino; 3564 __entry->next_agino = next_agino; 3565 ), 3566 TP_printk("dev %d:%d agno 0x%x bucket %u prev_agino 0x%x next_agino 0x%x", 3567 MAJOR(__entry->dev), MINOR(__entry->dev), 3568 __entry->agno, 3569 __entry->bucket, 3570 __entry->prev_agino, 3571 __entry->next_agino) 3572 ); 3573 #define DEFINE_REPAIR_IUNLINK_RESOLVE_EVENT(name) \ 3574 DEFINE_EVENT(xrep_iunlink_resolve_class, name, \ 3575 TP_PROTO(const struct xfs_perag *pag, unsigned int bucket, \ 3576 xfs_agino_t prev_agino, xfs_agino_t next_agino), \ 3577 TP_ARGS(pag, bucket, prev_agino, next_agino)) 3578 DEFINE_REPAIR_IUNLINK_RESOLVE_EVENT(xrep_iunlink_resolve_infinite_loop); 3579 DEFINE_REPAIR_IUNLINK_RESOLVE_EVENT(xrep_iunlink_resolve_uncached); 3580 DEFINE_REPAIR_IUNLINK_RESOLVE_EVENT(xrep_iunlink_resolve_wronglist); 3581 DEFINE_REPAIR_IUNLINK_RESOLVE_EVENT(xrep_iunlink_resolve_nolist); 3582 DEFINE_REPAIR_IUNLINK_RESOLVE_EVENT(xrep_iunlink_resolve_ok); 3583 DEFINE_REPAIR_IUNLINK_RESOLVE_EVENT(xrep_iunlink_resolve_allocated); 3584 3585 TRACE_EVENT(xrep_iunlink_relink_next, 3586 TP_PROTO(struct xfs_inode *ip, xfs_agino_t next_agino), 3587 TP_ARGS(ip, next_agino), 3588 TP_STRUCT__entry( 3589 __field(dev_t, dev) 3590 __field(xfs_agnumber_t, agno) 3591 __field(xfs_agino_t, agino) 3592 __field(xfs_agino_t, next_agino) 3593 __field(xfs_agino_t, new_next_agino) 3594 ), 3595 TP_fast_assign( 3596 __entry->dev = ip->i_mount->m_super->s_dev; 3597 __entry->agno = XFS_INODE_TO_AGNO(ip); 3598 __entry->agino = XFS_INODE_TO_AGINO(ip); 3599 __entry->next_agino = ip->i_next_unlinked; 3600 __entry->new_next_agino = next_agino; 3601 ), 3602 TP_printk("dev %d:%d agno 0x%x bucket %u agino 0x%x next_agino 0x%x -> 0x%x", 3603 MAJOR(__entry->dev), MINOR(__entry->dev), 3604 __entry->agno, 3605 __entry->agino % XFS_AGI_UNLINKED_BUCKETS, 3606 __entry->agino, 3607 __entry->next_agino, 3608 __entry->new_next_agino) 3609 ); 3610 3611 TRACE_EVENT(xrep_iunlink_relink_prev, 3612 TP_PROTO(struct xfs_inode *ip, xfs_agino_t prev_agino), 3613 TP_ARGS(ip, prev_agino), 3614 TP_STRUCT__entry( 3615 __field(dev_t, dev) 3616 __field(xfs_agnumber_t, agno) 3617 __field(xfs_agino_t, agino) 3618 __field(xfs_agino_t, prev_agino) 3619 __field(xfs_agino_t, new_prev_agino) 3620 ), 3621 TP_fast_assign( 3622 __entry->dev = ip->i_mount->m_super->s_dev; 3623 __entry->agno = XFS_INODE_TO_AGNO(ip); 3624 __entry->agino = XFS_INODE_TO_AGINO(ip); 3625 __entry->prev_agino = ip->i_prev_unlinked; 3626 __entry->new_prev_agino = prev_agino; 3627 ), 3628 TP_printk("dev %d:%d agno 0x%x bucket %u agino 0x%x prev_agino 0x%x -> 0x%x", 3629 MAJOR(__entry->dev), MINOR(__entry->dev), 3630 __entry->agno, 3631 __entry->agino % XFS_AGI_UNLINKED_BUCKETS, 3632 __entry->agino, 3633 __entry->prev_agino, 3634 __entry->new_prev_agino) 3635 ); 3636 3637 TRACE_EVENT(xrep_iunlink_add_to_bucket, 3638 TP_PROTO(const struct xfs_perag *pag, unsigned int bucket, 3639 xfs_agino_t agino, xfs_agino_t curr_head), 3640 TP_ARGS(pag, bucket, agino, curr_head), 3641 TP_STRUCT__entry( 3642 __field(dev_t, dev) 3643 __field(xfs_agnumber_t, agno) 3644 __field(unsigned int, bucket) 3645 __field(xfs_agino_t, agino) 3646 __field(xfs_agino_t, next_agino) 3647 ), 3648 TP_fast_assign( 3649 __entry->dev = pag_mount(pag)->m_super->s_dev; 3650 __entry->agno = pag_agno(pag); 3651 __entry->bucket = bucket; 3652 __entry->agino = agino; 3653 __entry->next_agino = curr_head; 3654 ), 3655 TP_printk("dev %d:%d agno 0x%x bucket %u agino 0x%x next_agino 0x%x", 3656 MAJOR(__entry->dev), MINOR(__entry->dev), 3657 __entry->agno, 3658 __entry->bucket, 3659 __entry->agino, 3660 __entry->next_agino) 3661 ); 3662 3663 TRACE_EVENT(xrep_iunlink_commit_bucket, 3664 TP_PROTO(const struct xfs_perag *pag, unsigned int bucket, 3665 xfs_agino_t old_agino, xfs_agino_t agino), 3666 TP_ARGS(pag, bucket, old_agino, agino), 3667 TP_STRUCT__entry( 3668 __field(dev_t, dev) 3669 __field(xfs_agnumber_t, agno) 3670 __field(unsigned int, bucket) 3671 __field(xfs_agino_t, old_agino) 3672 __field(xfs_agino_t, agino) 3673 ), 3674 TP_fast_assign( 3675 __entry->dev = pag_mount(pag)->m_super->s_dev; 3676 __entry->agno = pag_agno(pag); 3677 __entry->bucket = bucket; 3678 __entry->old_agino = old_agino; 3679 __entry->agino = agino; 3680 ), 3681 TP_printk("dev %d:%d agno 0x%x bucket %u agino 0x%x -> 0x%x", 3682 MAJOR(__entry->dev), MINOR(__entry->dev), 3683 __entry->agno, 3684 __entry->bucket, 3685 __entry->old_agino, 3686 __entry->agino) 3687 ); 3688 3689 DEFINE_XCHK_DIRPATH_OUTCOME_EVENT(xrep_dirpath_set_outcome); 3690 DEFINE_XCHK_DIRTREE_EVENT(xrep_dirtree_delete_path); 3691 DEFINE_XCHK_DIRTREE_EVENT(xrep_dirtree_create_adoption); 3692 DEFINE_XCHK_DIRTREE_EVALUATE_EVENT(xrep_dirtree_decided_fate); 3693 3694 DEFINE_XCHK_METAPATH_EVENT(xrep_metapath_lookup); 3695 DEFINE_XCHK_METAPATH_EVENT(xrep_metapath_try_unlink); 3696 DEFINE_XCHK_METAPATH_EVENT(xrep_metapath_unlink); 3697 DEFINE_XCHK_METAPATH_EVENT(xrep_metapath_link); 3698 3699 #ifdef CONFIG_XFS_RT 3700 DECLARE_EVENT_CLASS(xrep_rtbitmap_class, 3701 TP_PROTO(struct xfs_mount *mp, xfs_rtxnum_t start, xfs_rtxnum_t end), 3702 TP_ARGS(mp, start, end), 3703 TP_STRUCT__entry( 3704 __field(dev_t, dev) 3705 __field(dev_t, rtdev) 3706 __field(xfs_rtxnum_t, start) 3707 __field(xfs_rtxnum_t, end) 3708 ), 3709 TP_fast_assign( 3710 __entry->dev = mp->m_super->s_dev; 3711 __entry->rtdev = mp->m_rtdev_targp->bt_dev; 3712 __entry->start = start; 3713 __entry->end = end; 3714 ), 3715 TP_printk("dev %d:%d rtdev %d:%d startrtx 0x%llx endrtx 0x%llx", 3716 MAJOR(__entry->dev), MINOR(__entry->dev), 3717 MAJOR(__entry->rtdev), MINOR(__entry->rtdev), 3718 __entry->start, 3719 __entry->end) 3720 ); 3721 #define DEFINE_REPAIR_RGBITMAP_EVENT(name) \ 3722 DEFINE_EVENT(xrep_rtbitmap_class, name, \ 3723 TP_PROTO(struct xfs_mount *mp, xfs_rtxnum_t start, \ 3724 xfs_rtxnum_t end), \ 3725 TP_ARGS(mp, start, end)) 3726 DEFINE_REPAIR_RGBITMAP_EVENT(xrep_rtbitmap_record_free); 3727 DEFINE_REPAIR_RGBITMAP_EVENT(xrep_rtbitmap_record_free_bulk); 3728 3729 TRACE_EVENT(xrep_rtbitmap_or, 3730 TP_PROTO(struct xfs_mount *mp, unsigned long long wordoff, 3731 xfs_rtword_t mask, xfs_rtword_t word), 3732 TP_ARGS(mp, wordoff, mask, word), 3733 TP_STRUCT__entry( 3734 __field(dev_t, dev) 3735 __field(dev_t, rtdev) 3736 __field(unsigned long long, wordoff) 3737 __field(unsigned int, mask) 3738 __field(unsigned int, word) 3739 ), 3740 TP_fast_assign( 3741 __entry->dev = mp->m_super->s_dev; 3742 __entry->rtdev = mp->m_rtdev_targp->bt_dev; 3743 __entry->wordoff = wordoff; 3744 __entry->mask = mask; 3745 __entry->word = word; 3746 ), 3747 TP_printk("dev %d:%d rtdev %d:%d wordoff 0x%llx mask 0x%x word 0x%x", 3748 MAJOR(__entry->dev), MINOR(__entry->dev), 3749 MAJOR(__entry->rtdev), MINOR(__entry->rtdev), 3750 __entry->wordoff, 3751 __entry->mask, 3752 __entry->word) 3753 ); 3754 3755 TRACE_EVENT(xrep_rtbitmap_load, 3756 TP_PROTO(struct xfs_rtgroup *rtg, xfs_fileoff_t rbmoff, 3757 xfs_rtxnum_t rtx, xfs_rtxnum_t len), 3758 TP_ARGS(rtg, rbmoff, rtx, len), 3759 TP_STRUCT__entry( 3760 __field(dev_t, dev) 3761 __field(dev_t, rtdev) 3762 __field(xfs_rgnumber_t, rgno) 3763 __field(xfs_fileoff_t, rbmoff) 3764 __field(xfs_rtxnum_t, rtx) 3765 __field(xfs_rtxnum_t, len) 3766 ), 3767 TP_fast_assign( 3768 __entry->dev = rtg_mount(rtg)->m_super->s_dev; 3769 __entry->rtdev = rtg_mount(rtg)->m_rtdev_targp->bt_dev; 3770 __entry->rgno = rtg_rgno(rtg); 3771 __entry->rbmoff = rbmoff; 3772 __entry->rtx = rtx; 3773 __entry->len = len; 3774 ), 3775 TP_printk("dev %d:%d rtdev %d:%d rgno 0x%x rbmoff 0x%llx rtx 0x%llx rtxcount 0x%llx", 3776 MAJOR(__entry->dev), MINOR(__entry->dev), 3777 MAJOR(__entry->rtdev), MINOR(__entry->rtdev), 3778 __entry->rgno, 3779 __entry->rbmoff, 3780 __entry->rtx, 3781 __entry->len) 3782 ); 3783 3784 TRACE_EVENT(xrep_rtbitmap_load_words, 3785 TP_PROTO(struct xfs_mount *mp, xfs_fileoff_t rbmoff, 3786 unsigned long long wordoff, unsigned int wordcnt), 3787 TP_ARGS(mp, rbmoff, wordoff, wordcnt), 3788 TP_STRUCT__entry( 3789 __field(dev_t, dev) 3790 __field(dev_t, rtdev) 3791 __field(xfs_fileoff_t, rbmoff) 3792 __field(unsigned long long, wordoff) 3793 __field(unsigned int, wordcnt) 3794 ), 3795 TP_fast_assign( 3796 __entry->dev = mp->m_super->s_dev; 3797 __entry->rtdev = mp->m_rtdev_targp->bt_dev; 3798 __entry->rbmoff = rbmoff; 3799 __entry->wordoff = wordoff; 3800 __entry->wordcnt = wordcnt; 3801 ), 3802 TP_printk("dev %d:%d rtdev %d:%d rbmoff 0x%llx wordoff 0x%llx wordcnt 0x%x", 3803 MAJOR(__entry->dev), MINOR(__entry->dev), 3804 MAJOR(__entry->rtdev), MINOR(__entry->rtdev), 3805 __entry->rbmoff, 3806 __entry->wordoff, 3807 __entry->wordcnt) 3808 ); 3809 3810 TRACE_EVENT(xrep_rtbitmap_load_word, 3811 TP_PROTO(struct xfs_mount *mp, unsigned long long wordoff, 3812 unsigned int bit, xfs_rtword_t ondisk_word, 3813 xfs_rtword_t xfile_word, xfs_rtword_t word_mask), 3814 TP_ARGS(mp, wordoff, bit, ondisk_word, xfile_word, word_mask), 3815 TP_STRUCT__entry( 3816 __field(dev_t, dev) 3817 __field(dev_t, rtdev) 3818 __field(unsigned long long, wordoff) 3819 __field(unsigned int, bit) 3820 __field(xfs_rtword_t, ondisk_word) 3821 __field(xfs_rtword_t, xfile_word) 3822 __field(xfs_rtword_t, word_mask) 3823 ), 3824 TP_fast_assign( 3825 __entry->dev = mp->m_super->s_dev; 3826 __entry->rtdev = mp->m_rtdev_targp->bt_dev; 3827 __entry->wordoff = wordoff; 3828 __entry->bit = bit; 3829 __entry->ondisk_word = ondisk_word; 3830 __entry->xfile_word = xfile_word; 3831 __entry->word_mask = word_mask; 3832 ), 3833 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", 3834 MAJOR(__entry->dev), MINOR(__entry->dev), 3835 MAJOR(__entry->rtdev), MINOR(__entry->rtdev), 3836 __entry->wordoff, 3837 __entry->bit, 3838 __entry->ondisk_word, 3839 __entry->ondisk_word & __entry->word_mask, 3840 __entry->xfile_word, 3841 __entry->xfile_word & ~__entry->word_mask, 3842 (__entry->xfile_word & ~__entry->word_mask) | 3843 (__entry->ondisk_word & __entry->word_mask), 3844 __entry->word_mask) 3845 ); 3846 3847 TRACE_EVENT(xrep_rtrmap_found, 3848 TP_PROTO(struct xfs_mount *mp, const struct xfs_rmap_irec *rec), 3849 TP_ARGS(mp, rec), 3850 TP_STRUCT__entry( 3851 __field(dev_t, dev) 3852 __field(dev_t, rtdev) 3853 __field(xfs_rgblock_t, rgbno) 3854 __field(xfs_extlen_t, len) 3855 __field(uint64_t, owner) 3856 __field(uint64_t, offset) 3857 __field(unsigned int, flags) 3858 ), 3859 TP_fast_assign( 3860 __entry->dev = mp->m_super->s_dev; 3861 __entry->rtdev = mp->m_rtdev_targp->bt_dev; 3862 __entry->rgbno = rec->rm_startblock; 3863 __entry->len = rec->rm_blockcount; 3864 __entry->owner = rec->rm_owner; 3865 __entry->offset = rec->rm_offset; 3866 __entry->flags = rec->rm_flags; 3867 ), 3868 TP_printk("dev %d:%d rtdev %d:%d rgbno 0x%x fsbcount 0x%x owner 0x%llx fileoff 0x%llx flags 0x%x", 3869 MAJOR(__entry->dev), MINOR(__entry->dev), 3870 MAJOR(__entry->rtdev), MINOR(__entry->rtdev), 3871 __entry->rgbno, 3872 __entry->len, 3873 __entry->owner, 3874 __entry->offset, 3875 __entry->flags) 3876 ); 3877 #endif /* CONFIG_XFS_RT */ 3878 3879 #endif /* IS_ENABLED(CONFIG_XFS_ONLINE_REPAIR) */ 3880 3881 #endif /* _TRACE_XFS_SCRUB_TRACE_H */ 3882 3883 #undef TRACE_INCLUDE_PATH 3884 #define TRACE_INCLUDE_PATH . 3885 #define TRACE_INCLUDE_FILE scrub/trace 3886 #include <trace/define_trace.h> 3887