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