1/* 2 * Copyright (c) 2000-2005 Silicon Graphics, Inc. 3 * All Rights Reserved. 4 * 5 * This program is free software; you can redistribute it and/or 6 * modify it under the terms of the GNU General Public License as 7 * published by the Free Software Foundation. 8 * 9 * This program is distributed in the hope that it would be useful, 10 * but WITHOUT ANY WARRANTY; without even the implied warranty of 11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 12 * GNU General Public License for more details. 13 * 14 * You should have received a copy of the GNU General Public License 15 * along with this program; if not, write the Free Software Foundation, 16 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA 17 */ 18#include "xfs.h" 19 20#include "xfs_fs.h" 21#include "xfs_types.h" 22#include "xfs_bit.h" 23#include "xfs_log.h" 24#include "xfs_inum.h" 25#include "xfs_trans.h" 26#include "xfs_sb.h" 27#include "xfs_ag.h" 28#include "xfs_dir.h" 29#include "xfs_dir2.h" 30#include "xfs_dmapi.h" 31#include "xfs_mount.h" 32#include "xfs_alloc.h" 33#include "xfs_da_btree.h" 34#include "xfs_alloc_btree.h" 35#include "xfs_bmap_btree.h" 36#include "xfs_ialloc_btree.h" 37#include "xfs_dir_sf.h" 38#include "xfs_dir2_sf.h" 39#include "xfs_attr_sf.h" 40#include "xfs_dinode.h" 41#include "xfs_inode.h" 42#include "xfs_btree.h" 43#include "xfs_buf_item.h" 44#include "xfs_inode_item.h" 45#include "xfs_extfree_item.h" 46#include "xfs_rw.h" 47#include "xfs_bmap.h" 48#include "xfs_attr.h" 49#include "xfs_attr_leaf.h" 50#include "xfs_dir_leaf.h" 51#include "xfs_dir2_data.h" 52#include "xfs_dir2_leaf.h" 53#include "xfs_dir2_block.h" 54#include "xfs_dir2_node.h" 55#include "xfs_dir2_trace.h" 56#include "xfs_log_priv.h" 57#include "xfs_log_recover.h" 58#include "xfs_quota.h" 59#include "quota/xfs_qm.h" 60#include "xfs_iomap.h" 61 62#include <support/kdb.h> 63 64#define qprintf kdb_printf 65 66/* 67 * Command table functions. (tracing) 68 */ 69#ifdef XFS_ALLOC_TRACE 70static void xfsidbg_xalatrace(int); 71static void xfsidbg_xalbtrace(xfs_agblock_t); 72static void xfsidbg_xalgtrace(xfs_agnumber_t); 73static void xfsidbg_xalmtrace(xfs_mount_t *); 74static void xfsidbg_xalttrace(int); 75#endif 76#ifdef XFS_ATTR_TRACE 77static void xfsidbg_xattrtrace(int); 78#endif 79#ifdef XFS_BLI_TRACE 80static void xfsidbg_xblitrace(xfs_buf_log_item_t *); 81#endif 82#ifdef XFS_BMAP_TRACE 83static void xfsidbg_xbmatrace(int); 84static void xfsidbg_xbmitrace(xfs_inode_t *); 85static void xfsidbg_xbmstrace(xfs_inode_t *); 86static void xfsidbg_xbxatrace(int); 87static void xfsidbg_xbxitrace(xfs_inode_t *); 88static void xfsidbg_xbxstrace(xfs_inode_t *); 89#endif 90#ifdef XFS_ILOCK_TRACE 91static void xfsidbg_xilock_trace(xfs_inode_t *); 92static void xfsidbg_xailock_trace(int); 93#endif 94#ifdef XFS_DIR_TRACE 95static void xfsidbg_xdirtrace(int); 96#endif 97#ifdef XFS_DIR2_TRACE 98static void xfsidbg_xdir2atrace(int); 99static void xfsidbg_xdir2itrace(xfs_inode_t *); 100#endif 101#ifdef XFS_LOG_TRACE 102static void xfsidbg_xiclogtrace(xlog_in_core_t *); 103static void xfsidbg_xlog_granttrace(xlog_t *); 104#endif 105#ifdef XFS_DQUOT_TRACE 106static void xfsidbg_xqm_dqtrace(xfs_dquot_t *); 107#endif 108 109 110/* 111 * Command table functions. 112 */ 113static void xfsidbg_xagf(xfs_agf_t *); 114static void xfsidbg_xagi(xfs_agi_t *); 115static void xfsidbg_xaildump(xfs_mount_t *); 116static void xfsidbg_xalloc(xfs_alloc_arg_t *); 117static void xfsidbg_xattrcontext(xfs_attr_list_context_t *); 118static void xfsidbg_xattrleaf(xfs_attr_leafblock_t *); 119static void xfsidbg_xattrsf(xfs_attr_shortform_t *); 120static void xfsidbg_xbirec(xfs_bmbt_irec_t *r); 121static void xfsidbg_xbmalla(xfs_bmalloca_t *); 122static void xfsidbg_xbrec(xfs_bmbt_rec_64_t *); 123static void xfsidbg_xbroot(xfs_inode_t *); 124static void xfsidbg_xbroota(xfs_inode_t *); 125static void xfsidbg_xbtcur(xfs_btree_cur_t *); 126static void xfsidbg_xbuf(xfs_buf_t *); 127static void xfsidbg_xbuf_real(xfs_buf_t *, int); 128static void xfsidbg_xarg(int); 129static void xfsidbg_xchksum(uint *); 130static void xfsidbg_xchash(xfs_mount_t *mp); 131static void xfsidbg_xchashlist(xfs_chashlist_t *chl); 132static void xfsidbg_xdaargs(xfs_da_args_t *); 133static void xfsidbg_xdabuf(xfs_dabuf_t *); 134static void xfsidbg_xdanode(xfs_da_intnode_t *); 135static void xfsidbg_xdastate(xfs_da_state_t *); 136static void xfsidbg_xdirleaf(xfs_dir_leafblock_t *); 137static void xfsidbg_xdirsf(xfs_dir_shortform_t *); 138static void xfsidbg_xdir2free(xfs_dir2_free_t *); 139static void xfsidbg_xdir2sf(xfs_dir2_sf_t *); 140static void xfsidbg_xexlist(xfs_inode_t *); 141static void xfsidbg_xflist(xfs_bmap_free_t *); 142static void xfsidbg_xhelp(void); 143static void xfsidbg_xiclog(xlog_in_core_t *); 144static void xfsidbg_xiclogall(xlog_in_core_t *); 145static void xfsidbg_xiclogcb(xlog_in_core_t *); 146static void xfsidbg_xihash(xfs_mount_t *mp); 147static void xfsidbg_xinodes(xfs_mount_t *); 148static void xfsidbg_delayed_blocks(xfs_mount_t *); 149static void xfsidbg_xinodes_quiesce(xfs_mount_t *); 150static void xfsidbg_xlog(xlog_t *); 151static void xfsidbg_xlog_ritem(xlog_recover_item_t *); 152static void xfsidbg_xlog_rtrans(xlog_recover_t *); 153static void xfsidbg_xlog_rtrans_entire(xlog_recover_t *); 154static void xfsidbg_xlog_tic(xlog_ticket_t *); 155static void xfsidbg_xlogitem(xfs_log_item_t *); 156static void xfsidbg_xmount(xfs_mount_t *); 157static void xfsidbg_xnode(xfs_inode_t *ip); 158static void xfsidbg_xcore(xfs_iocore_t *io); 159static void xfsidbg_xperag(xfs_mount_t *); 160static void xfsidbg_xqm_diskdq(xfs_disk_dquot_t *); 161static void xfsidbg_xqm_dqattached_inos(xfs_mount_t *); 162static void xfsidbg_xqm_dquot(xfs_dquot_t *); 163static void xfsidbg_xqm_mplist(xfs_mount_t *); 164static void xfsidbg_xqm_qinfo(xfs_mount_t *mp); 165static void xfsidbg_xqm_tpdqinfo(xfs_trans_t *tp); 166static void xfsidbg_xsb(xfs_sb_t *); 167static void xfsidbg_xsb_convert(xfs_sb_t *); 168static void xfsidbg_xtp(xfs_trans_t *); 169static void xfsidbg_xtrans_res(xfs_mount_t *); 170#ifdef CONFIG_XFS_QUOTA 171static void xfsidbg_xqm(void); 172static void xfsidbg_xqm_htab(void); 173static void xfsidbg_xqm_freelist_print(xfs_frlist_t *qlist, char *title); 174static void xfsidbg_xqm_freelist(void); 175#endif 176 177#ifdef XFS_BMAP_TRACE 178static void xfs_convert_extent(xfs_bmbt_rec_32_t *, xfs_dfiloff_t *, 179 xfs_dfsbno_t *, xfs_dfilblks_t *, int *); 180#endif 181 182/* 183 * Prototypes for static functions. 184 */ 185#ifdef XFS_ALLOC_TRACE 186static int xfs_alloc_trace_entry(ktrace_entry_t *ktep); 187#endif 188#ifdef XFS_ATTR_TRACE 189static int xfs_attr_trace_entry(ktrace_entry_t *ktep); 190#endif 191#ifdef XFS_BMAP_TRACE 192static int xfs_bmap_trace_entry(ktrace_entry_t *ktep); 193#endif 194#ifdef XFS_BMAP_TRACE 195static int xfs_bmbt_trace_entry(ktrace_entry_t *ktep); 196#endif 197#ifdef XFS_DIR_TRACE 198static int xfs_dir_trace_entry(ktrace_entry_t *ktep); 199#endif 200#ifdef XFS_DIR2_TRACE 201static int xfs_dir2_trace_entry(ktrace_entry_t *ktep); 202#endif 203#ifdef XFS_RW_TRACE 204static void xfs_bunmap_trace_entry(ktrace_entry_t *ktep); 205static void xfs_rw_enter_trace_entry(ktrace_entry_t *ktep); 206static void xfs_page_trace_entry(ktrace_entry_t *ktep); 207static int xfs_rw_trace_entry(ktrace_entry_t *ktep); 208#endif 209static void xfs_broot(xfs_inode_t *ip, xfs_ifork_t *f); 210static void xfs_btalloc(xfs_alloc_block_t *bt, int bsz); 211static void xfs_btbmap(xfs_bmbt_block_t *bt, int bsz); 212static void xfs_btino(xfs_inobt_block_t *bt, int bsz); 213static void xfs_buf_item_print(xfs_buf_log_item_t *blip, int summary); 214static void xfs_dastate_path(xfs_da_state_path_t *p); 215static void xfs_dir2data(void *addr, int size); 216static void xfs_dir2leaf(xfs_dir2_leaf_t *leaf, int size); 217static void xfs_dquot_item_print(xfs_dq_logitem_t *lip, int summary); 218static void xfs_efd_item_print(xfs_efd_log_item_t *efdp, int summary); 219static void xfs_efi_item_print(xfs_efi_log_item_t *efip, int summary); 220static char * xfs_fmtformat(xfs_dinode_fmt_t f); 221char * xfs_fmtfsblock(xfs_fsblock_t bno, xfs_mount_t *mp); 222static char * xfs_fmtino(xfs_ino_t ino, xfs_mount_t *mp); 223static char * xfs_fmtlsn(xfs_lsn_t *lsnp); 224static char * xfs_fmtmode(int m); 225static char * xfs_fmtsize(size_t i); 226static char * xfs_fmtuuid(uuid_t *); 227static void xfs_inode_item_print(xfs_inode_log_item_t *ilip, int summary); 228static void xfs_inodebuf(xfs_buf_t *bp); 229static void xfs_prdinode_core(xfs_dinode_core_t *dip); 230static void xfs_qoff_item_print(xfs_qoff_logitem_t *lip, int summary); 231static void xfs_xexlist_fork(xfs_inode_t *ip, int whichfork); 232static void xfs_xnode_fork(char *name, xfs_ifork_t *f); 233 234 235/* kdb wrappers */ 236 237static int kdbm_xfs_xagf( 238 int argc, 239 const char **argv, 240 const char **envp, 241 struct pt_regs *regs) 242{ 243 unsigned long addr; 244 int nextarg = 1; 245 long offset = 0; 246 int diag; 247 248 if (argc != 1) 249 return KDB_ARGCOUNT; 250 diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL, regs); 251 if (diag) 252 return diag; 253 254 xfsidbg_xagf((xfs_agf_t *)addr); 255 return 0; 256} 257 258static int kdbm_xfs_xagi( 259 int argc, 260 const char **argv, 261 const char **envp, 262 struct pt_regs *regs) 263{ 264 unsigned long addr; 265 int nextarg = 1; 266 long offset = 0; 267 int diag; 268 269 if (argc != 1) 270 return KDB_ARGCOUNT; 271 diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL, regs); 272 if (diag) 273 return diag; 274 275 xfsidbg_xagi((xfs_agi_t *)addr); 276 return 0; 277} 278 279static int kdbm_xfs_xaildump( 280 int argc, 281 const char **argv, 282 const char **envp, 283 struct pt_regs *regs) 284{ 285 unsigned long addr; 286 int nextarg = 1; 287 long offset = 0; 288 int diag; 289 290 if (argc != 1) 291 return KDB_ARGCOUNT; 292 diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL, regs); 293 if (diag) 294 return diag; 295 296 xfsidbg_xaildump((xfs_mount_t *) addr); 297 return 0; 298} 299 300#ifdef XFS_ALLOC_TRACE 301static int kdbm_xfs_xalatrace( 302 int argc, 303 const char **argv, 304 const char **envp, 305 struct pt_regs *regs) 306{ 307 unsigned long addr; 308 int nextarg = 1; 309 long offset = 0; 310 int diag; 311 312 if (argc != 1) 313 return KDB_ARGCOUNT; 314 315 diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL, regs); 316 if (diag) 317 return diag; 318 319 xfsidbg_xalatrace((int) addr); 320 return 0; 321} 322 323static int kdbm_xfs_xalbtrace( 324 int argc, 325 const char **argv, 326 const char **envp, 327 struct pt_regs *regs) 328{ 329 unsigned long addr; 330 int nextarg = 1; 331 long offset = 0; 332 int diag; 333 334 if (argc != 1) 335 return KDB_ARGCOUNT; 336 337 diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL, regs); 338 if (diag) 339 return diag; 340 341 xfsidbg_xalbtrace((xfs_agblock_t) addr); 342 return 0; 343} 344 345static int kdbm_xfs_xalgtrace( 346 int argc, 347 const char **argv, 348 const char **envp, 349 struct pt_regs *regs) 350{ 351 unsigned long addr; 352 int nextarg = 1; 353 long offset = 0; 354 int diag; 355 356 if (argc != 1) 357 return KDB_ARGCOUNT; 358 359 diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL, regs); 360 if (diag) 361 return diag; 362 363 xfsidbg_xalgtrace((xfs_agnumber_t) addr); 364 return 0; 365} 366#endif 367 368#ifdef XFS_ATTR_TRACE 369static int kdbm_xfs_xattrtrace( 370 int argc, 371 const char **argv, 372 const char **envp, 373 struct pt_regs *regs) 374{ 375 unsigned long addr; 376 int nextarg = 1; 377 long offset = 0; 378 int diag; 379 380 if (argc != 1) 381 return KDB_ARGCOUNT; 382 383 diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL, regs); 384 if (diag) 385 return diag; 386 387 xfsidbg_xattrtrace((int) addr); 388 return 0; 389} 390#endif 391 392#ifdef XFS_BLI_TRACE 393static int kdbm_xfs_xblitrace( 394 int argc, 395 const char **argv, 396 const char **envp, 397 struct pt_regs *regs) 398{ 399 unsigned long addr; 400 int nextarg = 1; 401 long offset = 0; 402 int diag; 403 404 if (argc != 1) 405 return KDB_ARGCOUNT; 406 407 diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL, regs); 408 if (diag) 409 return diag; 410 411 xfsidbg_xblitrace((xfs_buf_log_item_t *) addr); 412 return 0; 413} 414#endif 415 416#ifdef XFS_BMAP_TRACE 417static int kdbm_xfs_xbmatrace( 418 int argc, 419 const char **argv, 420 const char **envp, 421 struct pt_regs *regs) 422{ 423 unsigned long addr; 424 int nextarg = 1; 425 long offset = 0; 426 int diag; 427 428 if (argc != 1) 429 return KDB_ARGCOUNT; 430 431 diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL, regs); 432 if (diag) 433 return diag; 434 435 xfsidbg_xbmatrace((int) addr); 436 return 0; 437} 438 439static int kdbm_xfs_xbmitrace( 440 int argc, 441 const char **argv, 442 const char **envp, 443 struct pt_regs *regs) 444{ 445 unsigned long addr; 446 int nextarg = 1; 447 long offset = 0; 448 int diag; 449 450 if (argc != 1) 451 return KDB_ARGCOUNT; 452 453 diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL, regs); 454 if (diag) 455 return diag; 456 457 xfsidbg_xbmitrace((xfs_inode_t *) addr); 458 return 0; 459} 460 461static int kdbm_xfs_xbmstrace( 462 int argc, 463 const char **argv, 464 const char **envp, 465 struct pt_regs *regs) 466{ 467 unsigned long addr; 468 int nextarg = 1; 469 long offset = 0; 470 int diag; 471 472 if (argc != 1) 473 return KDB_ARGCOUNT; 474 475 diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL, regs); 476 if (diag) 477 return diag; 478 479 xfsidbg_xbmstrace((xfs_inode_t *) addr); 480 return 0; 481} 482 483static int kdbm_xfs_xbxatrace( 484 int argc, 485 const char **argv, 486 const char **envp, 487 struct pt_regs *regs) 488{ 489 unsigned long addr; 490 int nextarg = 1; 491 long offset = 0; 492 int diag; 493 494 if (argc != 1) 495 return KDB_ARGCOUNT; 496 497 diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL, regs); 498 if (diag) 499 return diag; 500 501 xfsidbg_xbxatrace((int) addr); 502 return 0; 503} 504 505static int kdbm_xfs_xbxitrace( 506 int argc, 507 const char **argv, 508 const char **envp, 509 struct pt_regs *regs) 510{ 511 unsigned long addr; 512 int nextarg = 1; 513 long offset = 0; 514 int diag; 515 516 if (argc != 1) 517 return KDB_ARGCOUNT; 518 519 diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL, regs); 520 if (diag) 521 return diag; 522 523 xfsidbg_xbxitrace((xfs_inode_t *) addr); 524 return 0; 525} 526 527static int kdbm_xfs_xbxstrace( 528 int argc, 529 const char **argv, 530 const char **envp, 531 struct pt_regs *regs) 532{ 533 unsigned long addr; 534 int nextarg = 1; 535 long offset = 0; 536 int diag; 537 538 if (argc != 1) 539 return KDB_ARGCOUNT; 540 541 diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL, regs); 542 if (diag) 543 return diag; 544 545 xfsidbg_xbxstrace((xfs_inode_t *) addr); 546 return 0; 547} 548#endif 549 550#ifdef XFS_DIR2_TRACE 551static int kdbm_xfs_xdir2atrace( 552 int argc, 553 const char **argv, 554 const char **envp, 555 struct pt_regs *regs) 556{ 557 unsigned long addr; 558 int nextarg = 1; 559 long offset = 0; 560 int diag; 561 562 if (argc != 1) 563 return KDB_ARGCOUNT; 564 565 diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL, regs); 566 if (diag) 567 return diag; 568 569 xfsidbg_xdir2atrace((int) addr); 570 return 0; 571} 572 573static int kdbm_xfs_xdir2itrace( 574 int argc, 575 const char **argv, 576 const char **envp, 577 struct pt_regs *regs) 578{ 579 unsigned long addr; 580 int nextarg = 1; 581 long offset = 0; 582 int diag; 583 584 if (argc != 1) 585 return KDB_ARGCOUNT; 586 587 diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL, regs); 588 if (diag) 589 return diag; 590 591 xfsidbg_xdir2itrace((xfs_inode_t *) addr); 592 return 0; 593} 594#endif 595 596#ifdef XFS_DIR_TRACE 597static int kdbm_xfs_xdirtrace( 598 int argc, 599 const char **argv, 600 const char **envp, 601 struct pt_regs *regs) 602{ 603 unsigned long addr; 604 int nextarg = 1; 605 long offset = 0; 606 int diag; 607 608 if (argc != 1) 609 return KDB_ARGCOUNT; 610 611 diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL, regs); 612 if (diag) 613 return diag; 614 615 xfsidbg_xdirtrace((int) addr); 616 return 0; 617} 618#endif 619 620#ifdef XFS_LOG_TRACE 621static int kdbm_xfs_xiclogtrace( 622 int argc, 623 const char **argv, 624 const char **envp, 625 struct pt_regs *regs) 626{ 627 unsigned long addr; 628 int nextarg = 1; 629 long offset = 0; 630 int diag; 631 632 if (argc != 1) 633 return KDB_ARGCOUNT; 634 635 diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL, regs); 636 if (diag) 637 return diag; 638 639 xfsidbg_xiclogtrace((xlog_in_core_t *) addr); 640 return 0; 641} 642#endif 643 644#ifdef XFS_ILOCK_TRACE 645static int kdbm_xfs_xilock_trace( 646 int argc, 647 const char **argv, 648 const char **envp, 649 struct pt_regs *regs) 650{ 651 unsigned long addr; 652 int nextarg = 1; 653 long offset = 0; 654 int diag; 655 656 if (argc != 1) 657 return KDB_ARGCOUNT; 658 659 diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL, regs); 660 if (diag) 661 return diag; 662 663 xfsidbg_xilock_trace((xfs_inode_t *) addr); 664 return 0; 665} 666 667static int kdbm_xfs_xailock_trace( 668 int argc, 669 const char **argv, 670 const char **envp, 671 struct pt_regs *regs) 672{ 673 unsigned long addr; 674 int nextarg = 1; 675 long offset = 0; 676 int diag; 677 678 if (argc != 1) 679 return KDB_ARGCOUNT; 680 681 diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL, regs); 682 if (diag) 683 return diag; 684 685 xfsidbg_xailock_trace((int) addr); 686 return 0; 687} 688#endif 689 690#ifdef XFS_LOG_TRACE 691static int kdbm_xfs_xlog_granttrace( 692 int argc, 693 const char **argv, 694 const char **envp, 695 struct pt_regs *regs) 696{ 697 unsigned long addr; 698 int nextarg = 1; 699 long offset = 0; 700 int diag; 701 702 if (argc != 1) 703 return KDB_ARGCOUNT; 704 705 diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL, regs); 706 if (diag) 707 return diag; 708 709 xfsidbg_xlog_granttrace((xlog_t *) addr); 710 return 0; 711} 712#endif 713 714#ifdef XFS_DQUOT_TRACE 715static int kdbm_xfs_xqm_dqtrace( 716 int argc, 717 const char **argv, 718 const char **envp, 719 struct pt_regs *regs) 720{ 721 unsigned long addr; 722 int nextarg = 1; 723 long offset = 0; 724 int diag; 725 726 if (argc != 1) 727 return KDB_ARGCOUNT; 728 729 diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL, regs); 730 if (diag) 731 return diag; 732 733 xfsidbg_xqm_dqtrace((xfs_dquot_t *) addr); 734 return 0; 735} 736#endif 737 738#ifdef XFS_RW_TRACE 739static int kdbm_xfs_xrwtrace( 740 int argc, 741 const char **argv, 742 const char **envp, 743 struct pt_regs *regs) 744{ 745 unsigned long addr; 746 int nextarg = 1; 747 long offset = 0; 748 int diag; 749 ktrace_entry_t *ktep; 750 ktrace_snap_t kts; 751 xfs_inode_t *ip; 752 753 if (argc != 1) 754 return KDB_ARGCOUNT; 755 756 diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL, regs); 757 if (diag) 758 return diag; 759 760 ip = (xfs_inode_t *) addr; 761 if (ip->i_rwtrace == NULL) { 762 qprintf("The inode trace buffer is not initialized\n"); 763 return 0; 764 } 765 qprintf("i_rwtrace = 0x%p\n", ip->i_rwtrace); 766 ktep = ktrace_first(ip->i_rwtrace, &kts); 767 while (ktep != NULL) { 768 if (xfs_rw_trace_entry(ktep)) 769 qprintf("\n"); 770 ktep = ktrace_next(ip->i_rwtrace, &kts); 771 } 772 return 0; 773} 774#endif 775 776static int kdbm_xfs_xalloc( 777 int argc, 778 const char **argv, 779 const char **envp, 780 struct pt_regs *regs) 781{ 782 unsigned long addr; 783 int nextarg = 1; 784 long offset = 0; 785 int diag; 786 787 if (argc != 1) 788 return KDB_ARGCOUNT; 789 diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL, regs); 790 if (diag) 791 return diag; 792 793 xfsidbg_xalloc((xfs_alloc_arg_t *) addr); 794 return 0; 795} 796 797#ifdef XFS_ALLOC_TRACE 798static int kdbm_xfs_xalmtrace( 799 int argc, 800 const char **argv, 801 const char **envp, 802 struct pt_regs *regs) 803{ 804 unsigned long addr; 805 int nextarg = 1; 806 long offset = 0; 807 int diag; 808 809 if (argc != 1) 810 return KDB_ARGCOUNT; 811 diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL, regs); 812 if (diag) 813 return diag; 814 815 xfsidbg_xalmtrace((xfs_mount_t *) addr); 816 return 0; 817} 818 819static int kdbm_xfs_xalttrace( 820 int argc, 821 const char **argv, 822 const char **envp, 823 struct pt_regs *regs) 824{ 825 unsigned long addr; 826 int nextarg = 1; 827 long offset = 0; 828 int diag; 829 830 if (argc != 1) 831 return KDB_ARGCOUNT; 832 diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL, regs); 833 if (diag) 834 return diag; 835 836 xfsidbg_xalttrace((int) addr); 837 return 0; 838} 839#endif /* XFS_ALLOC_TRACE */ 840 841static int kdbm_xfs_xattrcontext( 842 int argc, 843 const char **argv, 844 const char **envp, 845 struct pt_regs *regs) 846{ 847 unsigned long addr; 848 int nextarg = 1; 849 long offset = 0; 850 int diag; 851 852 if (argc != 1) 853 return KDB_ARGCOUNT; 854 diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL, regs); 855 if (diag) 856 return diag; 857 858 xfsidbg_xattrcontext((xfs_attr_list_context_t *) addr); 859 return 0; 860} 861 862static int kdbm_xfs_xattrleaf( 863 int argc, 864 const char **argv, 865 const char **envp, 866 struct pt_regs *regs) 867{ 868 unsigned long addr; 869 int nextarg = 1; 870 long offset = 0; 871 int diag; 872 873 if (argc != 1) 874 return KDB_ARGCOUNT; 875 diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL, regs); 876 if (diag) 877 return diag; 878 879 xfsidbg_xattrleaf((xfs_attr_leafblock_t *) addr); 880 return 0; 881} 882 883static int kdbm_xfs_xattrsf( 884 int argc, 885 const char **argv, 886 const char **envp, 887 struct pt_regs *regs) 888{ 889 unsigned long addr; 890 int nextarg = 1; 891 long offset = 0; 892 int diag; 893 894 if (argc != 1) 895 return KDB_ARGCOUNT; 896 diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL, regs); 897 if (diag) 898 return diag; 899 900 xfsidbg_xattrsf((xfs_attr_shortform_t *) addr); 901 return 0; 902} 903 904static int kdbm_xfs_xbirec( 905 int argc, 906 const char **argv, 907 const char **envp, 908 struct pt_regs *regs) 909{ 910 unsigned long addr; 911 int nextarg = 1; 912 long offset = 0; 913 int diag; 914 915 if (argc != 1) 916 return KDB_ARGCOUNT; 917 diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL, regs); 918 if (diag) 919 return diag; 920 921 xfsidbg_xbirec((xfs_bmbt_irec_t *) addr); 922 return 0; 923} 924 925static int kdbm_xfs_xbmalla( 926 int argc, 927 const char **argv, 928 const char **envp, 929 struct pt_regs *regs) 930{ 931 unsigned long addr; 932 int nextarg = 1; 933 long offset = 0; 934 int diag; 935 936 if (argc != 1) 937 return KDB_ARGCOUNT; 938 diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL, regs); 939 if (diag) 940 return diag; 941 942 xfsidbg_xbmalla((xfs_bmalloca_t *)addr); 943 return 0; 944} 945 946static int kdbm_xfs_xbrec( 947 int argc, 948 const char **argv, 949 const char **envp, 950 struct pt_regs *regs) 951{ 952 unsigned long addr; 953 int nextarg = 1; 954 long offset = 0; 955 int diag; 956 957 if (argc != 1) 958 return KDB_ARGCOUNT; 959 diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL, regs); 960 if (diag) 961 return diag; 962 963 xfsidbg_xbrec((xfs_bmbt_rec_64_t *) addr); 964 return 0; 965} 966 967static int kdbm_xfs_xbroot( 968 int argc, 969 const char **argv, 970 const char **envp, 971 struct pt_regs *regs) 972{ 973 unsigned long addr; 974 int nextarg = 1; 975 long offset = 0; 976 int diag; 977 978 if (argc != 1) 979 return KDB_ARGCOUNT; 980 diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL, regs); 981 if (diag) 982 return diag; 983 984 xfsidbg_xbroot((xfs_inode_t *) addr); 985 return 0; 986} 987 988static int kdbm_xfs_xbroota( 989 int argc, 990 const char **argv, 991 const char **envp, 992 struct pt_regs *regs) 993{ 994 unsigned long addr; 995 int nextarg = 1; 996 long offset = 0; 997 int diag; 998 999 if (argc != 1) 1000 return KDB_ARGCOUNT; 1001 diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL, regs); 1002 if (diag) 1003 return diag; 1004 1005 xfsidbg_xbroota((xfs_inode_t *) addr); 1006 return 0; 1007} 1008 1009static int kdbm_xfs_xbtcur( 1010 int argc, 1011 const char **argv, 1012 const char **envp, 1013 struct pt_regs *regs) 1014{ 1015 unsigned long addr; 1016 int nextarg = 1; 1017 long offset = 0; 1018 int diag; 1019 1020 if (argc != 1) 1021 return KDB_ARGCOUNT; 1022 diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL, regs); 1023 if (diag) 1024 return diag; 1025 1026 xfsidbg_xbtcur((xfs_btree_cur_t *) addr); 1027 return 0; 1028} 1029 1030static int kdbm_xfs_xbuf( 1031 int argc, 1032 const char **argv, 1033 const char **envp, 1034 struct pt_regs *regs) 1035{ 1036 unsigned long addr; 1037 int nextarg = 1; 1038 long offset = 0; 1039 int diag; 1040 1041 if (argc != 1) 1042 return KDB_ARGCOUNT; 1043 diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL, regs); 1044 if (diag) 1045 return diag; 1046 1047 xfsidbg_xbuf((xfs_buf_t *) addr); 1048 return 0; 1049} 1050 1051 1052static int kdbm_xfs_xarg( 1053 int argc, 1054 const char **argv, 1055 const char **envp, 1056 struct pt_regs *regs) 1057{ 1058 unsigned long addr; 1059 int nextarg = 1; 1060 long offset = 0; 1061 int diag; 1062 1063 if (argc != 1) 1064 return KDB_ARGCOUNT; 1065 diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL, regs); 1066 if (diag) 1067 return diag; 1068 1069 xfsidbg_xarg((int) addr); 1070 return 0; 1071} 1072 1073static int kdbm_xfs_xchksum( 1074 int argc, 1075 const char **argv, 1076 const char **envp, 1077 struct pt_regs *regs) 1078{ 1079 unsigned long addr; 1080 int nextarg = 1; 1081 long offset = 0; 1082 int diag; 1083 1084 if (argc != 1) 1085 return KDB_ARGCOUNT; 1086 diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL, regs); 1087 if (diag) 1088 return diag; 1089 1090 xfsidbg_xchksum((uint *) addr); 1091 return 0; 1092} 1093 1094 1095static int kdbm_xfs_xchash( 1096 int argc, 1097 const char **argv, 1098 const char **envp, 1099 struct pt_regs *regs) 1100{ 1101 unsigned long addr; 1102 int nextarg = 1; 1103 long offset = 0; 1104 int diag; 1105 1106 if (argc != 1) 1107 return KDB_ARGCOUNT; 1108 diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL, regs); 1109 if (diag) 1110 return diag; 1111 1112 xfsidbg_xchash((xfs_mount_t *) addr); 1113 return 0; 1114} 1115 1116static int kdbm_xfs_xchashlist( 1117 int argc, 1118 const char **argv, 1119 const char **envp, 1120 struct pt_regs *regs) 1121{ 1122 unsigned long addr; 1123 int nextarg = 1; 1124 long offset = 0; 1125 int diag; 1126 1127 if (argc != 1) 1128 return KDB_ARGCOUNT; 1129 diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL, regs); 1130 if (diag) 1131 return diag; 1132 1133 xfsidbg_xchashlist((xfs_chashlist_t *) addr); 1134 return 0; 1135} 1136 1137 1138static int kdbm_xfs_xdaargs( 1139 int argc, 1140 const char **argv, 1141 const char **envp, 1142 struct pt_regs *regs) 1143{ 1144 unsigned long addr; 1145 int nextarg = 1; 1146 long offset = 0; 1147 int diag; 1148 1149 if (argc != 1) 1150 return KDB_ARGCOUNT; 1151 diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL, regs); 1152 if (diag) 1153 return diag; 1154 1155 xfsidbg_xdaargs((xfs_da_args_t *) addr); 1156 return 0; 1157} 1158 1159static int kdbm_xfs_xdabuf( 1160 int argc, 1161 const char **argv, 1162 const char **envp, 1163 struct pt_regs *regs) 1164{ 1165 unsigned long addr; 1166 int nextarg = 1; 1167 long offset = 0; 1168 int diag; 1169 1170 if (argc != 1) 1171 return KDB_ARGCOUNT; 1172 diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL, regs); 1173 if (diag) 1174 return diag; 1175 1176 xfsidbg_xdabuf((xfs_dabuf_t *) addr); 1177 return 0; 1178} 1179 1180static int kdbm_xfs_xdanode( 1181 int argc, 1182 const char **argv, 1183 const char **envp, 1184 struct pt_regs *regs) 1185{ 1186 unsigned long addr; 1187 int nextarg = 1; 1188 long offset = 0; 1189 int diag; 1190 1191 if (argc != 1) 1192 return KDB_ARGCOUNT; 1193 diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL, regs); 1194 if (diag) 1195 return diag; 1196 1197 xfsidbg_xdanode((xfs_da_intnode_t *) addr); 1198 return 0; 1199} 1200 1201static int kdbm_xfs_xdastate( 1202 int argc, 1203 const char **argv, 1204 const char **envp, 1205 struct pt_regs *regs) 1206{ 1207 unsigned long addr; 1208 int nextarg = 1; 1209 long offset = 0; 1210 int diag; 1211 1212 if (argc != 1) 1213 return KDB_ARGCOUNT; 1214 diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL, regs); 1215 if (diag) 1216 return diag; 1217 1218 xfsidbg_xdastate((xfs_da_state_t *) addr); 1219 return 0; 1220} 1221 1222static int kdbm_xfs_xdirleaf( 1223 int argc, 1224 const char **argv, 1225 const char **envp, 1226 struct pt_regs *regs) 1227{ 1228 unsigned long addr; 1229 int nextarg = 1; 1230 long offset = 0; 1231 int diag; 1232 1233 if (argc != 1) 1234 return KDB_ARGCOUNT; 1235 diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL, regs); 1236 if (diag) 1237 return diag; 1238 1239 xfsidbg_xdirleaf((xfs_dir_leafblock_t *) addr); 1240 return 0; 1241} 1242 1243static int kdbm_xfs_xdirsf( 1244 int argc, 1245 const char **argv, 1246 const char **envp, 1247 struct pt_regs *regs) 1248{ 1249 unsigned long addr; 1250 int nextarg = 1; 1251 long offset = 0; 1252 int diag; 1253 1254 if (argc != 1) 1255 return KDB_ARGCOUNT; 1256 diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL, regs); 1257 if (diag) 1258 return diag; 1259 1260 xfsidbg_xdirsf((xfs_dir_shortform_t *) addr); 1261 return 0; 1262} 1263 1264static int kdbm_xfs_xdir2free( 1265 int argc, 1266 const char **argv, 1267 const char **envp, 1268 struct pt_regs *regs) 1269{ 1270 unsigned long addr; 1271 int nextarg = 1; 1272 long offset = 0; 1273 int diag; 1274 1275 if (argc != 1) 1276 return KDB_ARGCOUNT; 1277 diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL, regs); 1278 if (diag) 1279 return diag; 1280 1281 xfsidbg_xdir2free((xfs_dir2_free_t *) addr); 1282 return 0; 1283} 1284 1285static int kdbm_xfs_xdir2sf( 1286 int argc, 1287 const char **argv, 1288 const char **envp, 1289 struct pt_regs *regs) 1290{ 1291 unsigned long addr; 1292 int nextarg = 1; 1293 long offset = 0; 1294 int diag; 1295 1296 if (argc != 1) 1297 return KDB_ARGCOUNT; 1298 diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL, regs); 1299 if (diag) 1300 return diag; 1301 1302 xfsidbg_xdir2sf((xfs_dir2_sf_t *) addr); 1303 return 0; 1304} 1305 1306static int kdbm_xfs_xexlist( 1307 int argc, 1308 const char **argv, 1309 const char **envp, 1310 struct pt_regs *regs) 1311{ 1312 unsigned long addr; 1313 int nextarg = 1; 1314 long offset = 0; 1315 int diag; 1316 1317 if (argc != 1) 1318 return KDB_ARGCOUNT; 1319 diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL, regs); 1320 if (diag) 1321 return diag; 1322 1323 xfsidbg_xexlist((xfs_inode_t *) addr); 1324 return 0; 1325} 1326 1327static int kdbm_xfs_xflist( 1328 int argc, 1329 const char **argv, 1330 const char **envp, 1331 struct pt_regs *regs) 1332{ 1333 unsigned long addr; 1334 int nextarg = 1; 1335 long offset = 0; 1336 int diag; 1337 1338 if (argc != 1) 1339 return KDB_ARGCOUNT; 1340 diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL, regs); 1341 if (diag) 1342 return diag; 1343 1344 xfsidbg_xflist((xfs_bmap_free_t *) addr); 1345 return 0; 1346} 1347 1348static int kdbm_xfs_xhelp( 1349 int argc, 1350 const char **argv, 1351 const char **envp, 1352 struct pt_regs *regs) 1353{ 1354 if (argc != 0) 1355 return KDB_ARGCOUNT; 1356 1357 xfsidbg_xhelp(); 1358 return 0; 1359} 1360 1361static int kdbm_xfs_xiclog( 1362 int argc, 1363 const char **argv, 1364 const char **envp, 1365 struct pt_regs *regs) 1366{ 1367 unsigned long addr; 1368 int nextarg = 1; 1369 long offset = 0; 1370 int diag; 1371 1372 if (argc != 1) 1373 return KDB_ARGCOUNT; 1374 diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL, regs); 1375 if (diag) 1376 return diag; 1377 1378 xfsidbg_xiclog((xlog_in_core_t *) addr); 1379 return 0; 1380} 1381 1382static int kdbm_xfs_xiclogall( 1383 int argc, 1384 const char **argv, 1385 const char **envp, 1386 struct pt_regs *regs) 1387{ 1388 unsigned long addr; 1389 int nextarg = 1; 1390 long offset = 0; 1391 int diag; 1392 1393 if (argc != 1) 1394 return KDB_ARGCOUNT; 1395 diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL, regs); 1396 if (diag) 1397 return diag; 1398 1399 xfsidbg_xiclogall((xlog_in_core_t *) addr); 1400 return 0; 1401} 1402 1403static int kdbm_xfs_xiclogcb( 1404 int argc, 1405 const char **argv, 1406 const char **envp, 1407 struct pt_regs *regs) 1408{ 1409 unsigned long addr; 1410 int nextarg = 1; 1411 long offset = 0; 1412 int diag; 1413 1414 if (argc != 1) 1415 return KDB_ARGCOUNT; 1416 diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL, regs); 1417 if (diag) 1418 return diag; 1419 1420 xfsidbg_xiclogcb((xlog_in_core_t *) addr); 1421 return 0; 1422} 1423 1424static int kdbm_xfs_xihash( 1425 int argc, 1426 const char **argv, 1427 const char **envp, 1428 struct pt_regs *regs) 1429{ 1430 unsigned long addr; 1431 int nextarg = 1; 1432 long offset = 0; 1433 int diag; 1434 1435 if (argc != 1) 1436 return KDB_ARGCOUNT; 1437 diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL, regs); 1438 if (diag) 1439 return diag; 1440 1441 xfsidbg_xihash((xfs_mount_t *) addr); 1442 return 0; 1443} 1444 1445static int kdbm_xfs_xinodes( 1446 int argc, 1447 const char **argv, 1448 const char **envp, 1449 struct pt_regs *regs) 1450{ 1451 unsigned long addr; 1452 int nextarg = 1; 1453 long offset = 0; 1454 int diag; 1455 1456 if (argc != 1) 1457 return KDB_ARGCOUNT; 1458 diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL, regs); 1459 if (diag) 1460 return diag; 1461 1462 xfsidbg_xinodes((xfs_mount_t *) addr); 1463 return 0; 1464} 1465 1466static int kdbm_xfs_delayed_blocks( 1467 int argc, 1468 const char **argv, 1469 const char **envp, 1470 struct pt_regs *regs) 1471{ 1472 unsigned long addr; 1473 int nextarg = 1; 1474 long offset = 0; 1475 int diag; 1476 1477 if (argc != 1) 1478 return KDB_ARGCOUNT; 1479 diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL, regs); 1480 if (diag) 1481 return diag; 1482 1483 xfsidbg_delayed_blocks((xfs_mount_t *) addr); 1484 return 0; 1485} 1486 1487 1488static int kdbm_xfs_xinodes_quiesce( 1489 int argc, 1490 const char **argv, 1491 const char **envp, 1492 struct pt_regs *regs) 1493{ 1494 unsigned long addr; 1495 int nextarg = 1; 1496 long offset = 0; 1497 int diag; 1498 1499 if (argc != 1) 1500 return KDB_ARGCOUNT; 1501 diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL, regs); 1502 if (diag) 1503 return diag; 1504 1505 xfsidbg_xinodes_quiesce((xfs_mount_t *) addr); 1506 return 0; 1507} 1508 1509static int kdbm_xfs_xlog( 1510 int argc, 1511 const char **argv, 1512 const char **envp, 1513 struct pt_regs *regs) 1514{ 1515 unsigned long addr; 1516 int nextarg = 1; 1517 long offset = 0; 1518 int diag; 1519 1520 if (argc != 1) 1521 return KDB_ARGCOUNT; 1522 diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL, regs); 1523 if (diag) 1524 return diag; 1525 1526 xfsidbg_xlog((xlog_t *) addr); 1527 return 0; 1528} 1529 1530static int kdbm_xfs_xlog_ritem( 1531 int argc, 1532 const char **argv, 1533 const char **envp, 1534 struct pt_regs *regs) 1535{ 1536 unsigned long addr; 1537 int nextarg = 1; 1538 long offset = 0; 1539 int diag; 1540 1541 if (argc != 1) 1542 return KDB_ARGCOUNT; 1543 diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL, regs); 1544 if (diag) 1545 return diag; 1546 1547 xfsidbg_xlog_ritem((xlog_recover_item_t *) addr); 1548 return 0; 1549} 1550 1551static int kdbm_xfs_xlog_rtrans( 1552 int argc, 1553 const char **argv, 1554 const char **envp, 1555 struct pt_regs *regs) 1556{ 1557 unsigned long addr; 1558 int nextarg = 1; 1559 long offset = 0; 1560 int diag; 1561 1562 if (argc != 1) 1563 return KDB_ARGCOUNT; 1564 diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL, regs); 1565 if (diag) 1566 return diag; 1567 1568 xfsidbg_xlog_rtrans((xlog_recover_t *) addr); 1569 return 0; 1570} 1571 1572static int kdbm_xfs_xlog_rtrans_entire( 1573 int argc, 1574 const char **argv, 1575 const char **envp, 1576 struct pt_regs *regs) 1577{ 1578 unsigned long addr; 1579 int nextarg = 1; 1580 long offset = 0; 1581 int diag; 1582 1583 if (argc != 1) 1584 return KDB_ARGCOUNT; 1585 diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL, regs); 1586 if (diag) 1587 return diag; 1588 1589 xfsidbg_xlog_rtrans_entire((xlog_recover_t *) addr); 1590 return 0; 1591} 1592 1593static int kdbm_xfs_xlog_tic( 1594 int argc, 1595 const char **argv, 1596 const char **envp, 1597 struct pt_regs *regs) 1598{ 1599 unsigned long addr; 1600 int nextarg = 1; 1601 long offset = 0; 1602 int diag; 1603 1604 if (argc != 1) 1605 return KDB_ARGCOUNT; 1606 diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL, regs); 1607 if (diag) 1608 return diag; 1609 1610 xfsidbg_xlog_tic((xlog_ticket_t *) addr); 1611 return 0; 1612} 1613 1614static int kdbm_xfs_xlogitem( 1615 int argc, 1616 const char **argv, 1617 const char **envp, 1618 struct pt_regs *regs) 1619{ 1620 unsigned long addr; 1621 int nextarg = 1; 1622 long offset = 0; 1623 int diag; 1624 1625 if (argc != 1) 1626 return KDB_ARGCOUNT; 1627 diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL, regs); 1628 if (diag) 1629 return diag; 1630 1631 xfsidbg_xlogitem((xfs_log_item_t *) addr); 1632 return 0; 1633} 1634 1635static int kdbm_xfs_xmount( 1636 int argc, 1637 const char **argv, 1638 const char **envp, 1639 struct pt_regs *regs) 1640{ 1641 unsigned long addr; 1642 int nextarg = 1; 1643 long offset = 0; 1644 int diag; 1645 1646 if (argc != 1) 1647 return KDB_ARGCOUNT; 1648 diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL, regs); 1649 if (diag) 1650 return diag; 1651 1652 xfsidbg_xmount((xfs_mount_t *) addr); 1653 return 0; 1654} 1655 1656static int kdbm_xfs_xnode( 1657 int argc, 1658 const char **argv, 1659 const char **envp, 1660 struct pt_regs *regs) 1661{ 1662 unsigned long addr; 1663 int nextarg = 1; 1664 long offset = 0; 1665 int diag; 1666 1667 if (argc != 1) 1668 return KDB_ARGCOUNT; 1669 diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL, regs); 1670 if (diag) 1671 return diag; 1672 1673 xfsidbg_xnode((xfs_inode_t *) addr); 1674 return 0; 1675} 1676 1677static int kdbm_xfs_xcore( 1678 int argc, 1679 const char **argv, 1680 const char **envp, 1681 struct pt_regs *regs) 1682{ 1683 unsigned long addr; 1684 int nextarg = 1; 1685 long offset = 0; 1686 int diag; 1687 1688 if (argc != 1) 1689 return KDB_ARGCOUNT; 1690 diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL, regs); 1691 if (diag) 1692 return diag; 1693 1694 xfsidbg_xcore((xfs_iocore_t *) addr); 1695 return 0; 1696} 1697 1698static int kdbm_xfs_xperag( 1699 int argc, 1700 const char **argv, 1701 const char **envp, 1702 struct pt_regs *regs) 1703{ 1704 unsigned long addr; 1705 int nextarg = 1; 1706 long offset = 0; 1707 int diag; 1708 1709 if (argc != 1) 1710 return KDB_ARGCOUNT; 1711 diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL, regs); 1712 if (diag) 1713 return diag; 1714 1715 xfsidbg_xperag((xfs_mount_t *) addr); 1716 return 0; 1717} 1718 1719static int kdbm_xfs_xqm_diskdq( 1720 int argc, 1721 const char **argv, 1722 const char **envp, 1723 struct pt_regs *regs) 1724{ 1725 unsigned long addr; 1726 int nextarg = 1; 1727 long offset = 0; 1728 int diag; 1729 1730 if (argc != 1) 1731 return KDB_ARGCOUNT; 1732 diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL, regs); 1733 if (diag) 1734 return diag; 1735 1736 xfsidbg_xqm_diskdq((xfs_disk_dquot_t *) addr); 1737 return 0; 1738} 1739 1740static int kdbm_xfs_xqm_dqattached_inos( 1741 int argc, 1742 const char **argv, 1743 const char **envp, 1744 struct pt_regs *regs) 1745{ 1746 unsigned long addr; 1747 int nextarg = 1; 1748 long offset = 0; 1749 int diag; 1750 1751 if (argc != 1) 1752 return KDB_ARGCOUNT; 1753 diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL, regs); 1754 if (diag) 1755 return diag; 1756 1757 xfsidbg_xqm_dqattached_inos((xfs_mount_t *) addr); 1758 return 0; 1759} 1760 1761static int kdbm_xfs_xqm_dquot( 1762 int argc, 1763 const char **argv, 1764 const char **envp, 1765 struct pt_regs *regs) 1766{ 1767 unsigned long addr; 1768 int nextarg = 1; 1769 long offset = 0; 1770 int diag; 1771 1772 if (argc != 1) 1773 return KDB_ARGCOUNT; 1774 diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL, regs); 1775 if (diag) 1776 return diag; 1777 1778 xfsidbg_xqm_dquot((xfs_dquot_t *) addr); 1779 return 0; 1780} 1781 1782#ifdef CONFIG_XFS_QUOTA 1783static int kdbm_xfs_xqm( 1784 int argc, 1785 const char **argv, 1786 const char **envp, 1787 struct pt_regs *regs) 1788{ 1789 if (argc != 0) 1790 return KDB_ARGCOUNT; 1791 1792 xfsidbg_xqm(); 1793 return 0; 1794} 1795 1796static int kdbm_xfs_xqm_freelist( 1797 int argc, 1798 const char **argv, 1799 const char **envp, 1800 struct pt_regs *regs) 1801{ 1802 if (argc != 0) 1803 return KDB_ARGCOUNT; 1804 1805 xfsidbg_xqm_freelist(); 1806 return 0; 1807} 1808 1809static int kdbm_xfs_xqm_htab( 1810 int argc, 1811 const char **argv, 1812 const char **envp, 1813 struct pt_regs *regs) 1814{ 1815 if (argc != 0) 1816 return KDB_ARGCOUNT; 1817 1818 xfsidbg_xqm_htab(); 1819 return 0; 1820} 1821#endif 1822 1823static int kdbm_xfs_xqm_mplist( 1824 int argc, 1825 const char **argv, 1826 const char **envp, 1827 struct pt_regs *regs) 1828{ 1829 unsigned long addr; 1830 int nextarg = 1; 1831 long offset = 0; 1832 int diag; 1833 1834 if (argc != 1) 1835 return KDB_ARGCOUNT; 1836 diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL, regs); 1837 if (diag) 1838 return diag; 1839 1840 xfsidbg_xqm_mplist((xfs_mount_t *) addr); 1841 return 0; 1842} 1843 1844static int kdbm_xfs_xqm_qinfo( 1845 int argc, 1846 const char **argv, 1847 const char **envp, 1848 struct pt_regs *regs) 1849{ 1850 unsigned long addr; 1851 int nextarg = 1; 1852 long offset = 0; 1853 int diag; 1854 1855 if (argc != 1) 1856 return KDB_ARGCOUNT; 1857 diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL, regs); 1858 if (diag) 1859 return diag; 1860 1861 xfsidbg_xqm_qinfo((xfs_mount_t *) addr); 1862 return 0; 1863} 1864 1865static int kdbm_xfs_xqm_tpdqinfo( 1866 int argc, 1867 const char **argv, 1868 const char **envp, 1869 struct pt_regs *regs) 1870{ 1871 unsigned long addr; 1872 int nextarg = 1; 1873 long offset = 0; 1874 int diag; 1875 1876 if (argc != 1) 1877 return KDB_ARGCOUNT; 1878 diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL, regs); 1879 if (diag) 1880 return diag; 1881 1882 xfsidbg_xqm_tpdqinfo((xfs_trans_t *) addr); 1883 return 0; 1884} 1885 1886static int kdbm_xfs_xsb( 1887 int argc, 1888 const char **argv, 1889 const char **envp, 1890 struct pt_regs *regs) 1891{ 1892 unsigned long addr; 1893 unsigned long convert=0; 1894 int nextarg = 1; 1895 long offset = 0; 1896 int diag; 1897 1898 if (argc != 1 && argc!=2) 1899 return KDB_ARGCOUNT; 1900 diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL, regs); 1901 if (diag) 1902 return diag; 1903 if (argc==2) { 1904 /* extra argument - conversion flag */ 1905 diag = kdbgetaddrarg(argc, argv, &nextarg, &convert, &offset, NULL, regs); 1906 if (diag) 1907 return diag; 1908 } 1909 1910 if (convert) 1911 xfsidbg_xsb_convert((xfs_sb_t *) addr); 1912 else 1913 xfsidbg_xsb((xfs_sb_t *) addr); 1914 return 0; 1915} 1916 1917static int kdbm_xfs_xtp( 1918 int argc, 1919 const char **argv, 1920 const char **envp, 1921 struct pt_regs *regs) 1922{ 1923 unsigned long addr; 1924 int nextarg = 1; 1925 long offset = 0; 1926 int diag; 1927 1928 if (argc != 1) 1929 return KDB_ARGCOUNT; 1930 diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL, regs); 1931 if (diag) 1932 return diag; 1933 1934 xfsidbg_xtp((xfs_trans_t *) addr); 1935 return 0; 1936} 1937 1938static int kdbm_xfs_xtrans_res( 1939 int argc, 1940 const char **argv, 1941 const char **envp, 1942 struct pt_regs *regs) 1943{ 1944 unsigned long addr; 1945 int nextarg = 1; 1946 long offset = 0; 1947 int diag; 1948 1949 if (argc != 1) 1950 return KDB_ARGCOUNT; 1951 diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL, regs); 1952 if (diag) 1953 return diag; 1954 1955 xfsidbg_xtrans_res((xfs_mount_t *) addr); 1956 return 0; 1957} 1958 1959/* 1960 * Vnode descriptor dump. 1961 * This table is a string version of all the flags defined in vnode.h. 1962 */ 1963char *tab_vflags[] = { 1964 /* local only flags */ 1965 "VINACT", /* 0x01 */ 1966 "VRECLM", /* 0x02 */ 1967 "VWAIT", /* 0x04 */ 1968 "VMODIFIED", /* 0x08 */ 1969 "INVALID0x10", /* 0x10 */ 1970 "INVALID0x20", /* 0x20 */ 1971 "INVALID0x40", /* 0x40 */ 1972 "INVALID0x80", /* 0x80 */ 1973 "INVALID0x100", /* 0x100 */ 1974 "INVALID0x200", /* 0x200 */ 1975 "INVALID0x400", /* 0x400 */ 1976 "INVALID0x800", /* 0x800 */ 1977 "INVALID0x1000", /* 0x1000 */ 1978 "INVALID0x2000", /* 0x2000 */ 1979 "INVALID0x4000", /* 0x4000 */ 1980 "INVALID0x8000", /* 0x8000 */ 1981 "INVALID0x10000", /* 0x10000 */ 1982 "INVALID0x20000", /* 0x20000 */ 1983 "INVALID0x40000", /* 0x40000 */ 1984 "INVALID0x80000", /* 0x80000 */ 1985 "VROOT", /* 0x100000 */ 1986 "INVALID0x200000", /* 0x200000 */ 1987 "INVALID00x400000", /* 0x400000 */ 1988 "INVALID0x800000", /* 0x800000 */ 1989 "INVALID0x1000000", /* 0x1000000 */ 1990 "INVALID0x2000000", /* 0x2000000 */ 1991 "VSHARE", /* 0x4000000 */ 1992 "INVALID0x8000000", /* 0x8000000 */ 1993 "VENF_LOCKING", /* 0x10000000 */ 1994 "VOPLOCK", /* 0x20000000 */ 1995 "VPURGE", /* 0x40000000 */ 1996 "INVALID0x80000000", /* 0x80000000 */ 1997 NULL 1998}; 1999 2000static void 2001printflags(register uint64_t flags, 2002 register char **strings, 2003 register char *name) 2004{ 2005 register uint64_t mask = 1; 2006 2007 if (name) 2008 kdb_printf("%s 0x%llx <", name, (unsigned long long)flags); 2009 2010 while (flags != 0 && *strings) { 2011 if (mask & flags) { 2012 kdb_printf("%s ", *strings); 2013 flags &= ~mask; 2014 } 2015 mask <<= 1; 2016 strings++; 2017 } 2018 2019 if (name) 2020 kdb_printf("> "); 2021 2022 return; 2023} 2024 2025 2026static void printbhv(bhv_desc_t *bdp) 2027{ 2028 int maxbhv = 20; /* if you get 20 bhvs you're in trouble already */ 2029 kdb_symtab_t symtab; 2030 2031 if (bdp == NULL) { 2032 kdb_printf("NULL bhv\n"); 2033 return; 2034 } 2035 2036 kdb_printf("bhv at 0x%p\n", bdp); 2037 while (bdp && maxbhv--) { 2038 if (kdbnearsym((unsigned long)bdp->bd_ops, &symtab)) 2039 kdb_printf(" ops %s", symtab.sym_name); 2040 else 2041 kdb_printf(" ops %s/0x%p", "???", (void *)bdp->bd_ops); 2042 2043 kdb_printf(" vobj 0x%p pdata 0x%p next 0x%p\n", 2044 bdp->bd_vobj, bdp->bd_pdata, bdp->bd_next); 2045 2046 bdp = bdp->bd_next; 2047 } 2048} 2049 2050 2051static void printvnode(xfs_vnode_t *vp, unsigned long addr) 2052{ 2053 kdb_printf("vnode: 0x%lx\n", addr); 2054 kdb_printf(" v_bh 0x%p\n", &vp->v_bh); 2055 2056 printbhv(vp->v_fbhv); 2057 2058 printflags((__psunsigned_t)vp->v_flag, tab_vflags, "flag ="); 2059 kdb_printf("\n"); 2060 2061#ifdef XFS_VNODE_TRACE 2062 kdb_printf(" v_trace 0x%p\n", vp->v_trace); 2063#endif /* XFS_VNODE_TRACE */ 2064 2065 kdb_printf(" v_vfsp 0x%p v_number 0x%llx\n", 2066 vp->v_vfsp, (unsigned long long)vp->v_number); 2067} 2068 2069static int kdbm_vnode( 2070 int argc, 2071 const char **argv, 2072 const char **envp, 2073 struct pt_regs *regs) 2074{ 2075 unsigned long addr; 2076 int nextarg = 1; 2077 long offset = 0; 2078 int diag; 2079 xfs_vnode_t vp; 2080 2081 if (argc != 1) 2082 return KDB_ARGCOUNT; 2083 2084 diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL, regs); 2085 2086 if (diag) 2087 return diag; 2088 2089 if ((diag = kdb_getarea(vp, addr))) 2090 return diag; 2091 2092 printvnode(&vp, addr); 2093 2094 return 0; 2095} 2096 2097static void 2098print_vfs(xfs_vfs_t *vfs, unsigned long addr) 2099{ 2100 kdb_printf("vfsp at 0x%lx", addr); 2101 kdb_printf(" vfs_flag 0x%x\n", vfs->vfs_flag); 2102 kdb_printf(" vfs_mp 0x%p", vfs->vfs_mp); 2103 kdb_printf(" vfs_bh 0x%p\n", &vfs->vfs_bh); 2104 2105 printbhv(vfs->vfs_fbhv); 2106} 2107 2108static int kdbm_bhv( 2109 int argc, 2110 const char **argv, 2111 const char **envp, 2112 struct pt_regs *regs) 2113{ 2114 unsigned long addr; 2115 int nextarg = 1; 2116 long offset = 0; 2117 int diag; 2118 bhv_desc_t *bh; 2119 2120 if (argc != 1) 2121 return KDB_ARGCOUNT; 2122 2123 diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL, regs); 2124 2125 if (diag) 2126 return diag; 2127 2128 bh = (bhv_desc_t *)addr; 2129 2130 printbhv(bh); 2131 2132 return 0; 2133} 2134 2135static int kdbm_vfs( 2136 int argc, 2137 const char **argv, 2138 const char **envp, 2139 struct pt_regs *regs) 2140{ 2141 unsigned long addr; 2142 int nextarg = 1; 2143 long offset = 0; 2144 int diag; 2145 xfs_vfs_t vfs; 2146 2147 if (argc != 1) 2148 return KDB_ARGCOUNT; 2149 2150 diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL, regs); 2151 2152 if (diag) 2153 return diag; 2154 2155 if ((diag = kdb_getarea(vfs, addr))) 2156 return diag; 2157 2158 print_vfs(&vfs, addr); 2159 2160 return 0; 2161} 2162 2163 2164#ifdef XFS_VNODE_TRACE 2165/* 2166 * Print a vnode trace entry. 2167 */ 2168static int 2169vn_trace_pr_entry(ktrace_entry_t *ktep) 2170{ 2171 char funcname[128]; 2172 kdb_symtab_t symtab; 2173 2174 2175 if ((__psint_t)ktep->val[0] == 0) 2176 return 0; 2177 2178 if (kdbnearsym((unsigned int)ktep->val[8], &symtab)) { 2179 unsigned long offval; 2180 2181 offval = (unsigned int)ktep->val[8] - symtab.sym_start; 2182 2183 if (offval) 2184 sprintf(funcname, "%s+0x%lx", symtab.sym_name, offval); 2185 else 2186 sprintf(funcname, "%s", symtab.sym_name); 2187 } else 2188 funcname[0] = '\0'; 2189 2190 2191 switch ((__psint_t)ktep->val[0]) { 2192 case VNODE_KTRACE_ENTRY: 2193 kdb_printf("entry to %s i_count = %d", 2194 (char *)ktep->val[1], 2195 (__psint_t)ktep->val[3]); 2196 break; 2197 2198 case VNODE_KTRACE_EXIT: 2199 kdb_printf("exit from %s i_count = %d", 2200 (char *)ktep->val[1], 2201 (__psint_t)ktep->val[3]); 2202 break; 2203 2204 case VNODE_KTRACE_HOLD: 2205 if ((__psint_t)ktep->val[3] != 1) 2206 kdb_printf("hold @%s:%d(%s) i_count %d => %d ", 2207 (char *)ktep->val[1], 2208 (__psint_t)ktep->val[2], 2209 funcname, 2210 (__psint_t)ktep->val[3] - 1, 2211 (__psint_t)ktep->val[3]); 2212 else 2213 kdb_printf("get @%s:%d(%s) i_count = %d", 2214 (char *)ktep->val[1], 2215 (__psint_t)ktep->val[2], 2216 funcname, 2217 (__psint_t)ktep->val[3]); 2218 break; 2219 2220 case VNODE_KTRACE_REF: 2221 kdb_printf("ref @%s:%d(%s) i_count = %d", 2222 (char *)ktep->val[1], 2223 (__psint_t)ktep->val[2], 2224 funcname, 2225 (__psint_t)ktep->val[3]); 2226 break; 2227 2228 case VNODE_KTRACE_RELE: 2229 if ((__psint_t)ktep->val[3] != 1) 2230 kdb_printf("rele @%s:%d(%s) i_count %d => %d ", 2231 (char *)ktep->val[1], 2232 (__psint_t)ktep->val[2], 2233 funcname, 2234 (__psint_t)ktep->val[3], 2235 (__psint_t)ktep->val[3] - 1); 2236 else 2237 kdb_printf("free @%s:%d(%s) i_count = %d", 2238 (char *)ktep->val[1], 2239 (__psint_t)ktep->val[2], 2240 funcname, 2241 (__psint_t)ktep->val[3]); 2242 break; 2243 2244 default: 2245 kdb_printf("unknown vntrace record\n"); 2246 return 1; 2247 } 2248 2249 kdb_printf("\n"); 2250 2251 kdb_printf(" cpu = %d pid = %d ", 2252 (__psint_t)ktep->val[6], (pid_t)ktep->val[7]); 2253 2254 printflags((__psunsigned_t)ktep->val[5], tab_vflags, "flag ="); 2255 2256 if (kdbnearsym((unsigned int)ktep->val[4], &symtab)) { 2257 unsigned long offval; 2258 2259 offval = (unsigned int)ktep->val[4] - symtab.sym_start; 2260 2261 if (offval) 2262 kdb_printf(" ra = %s+0x%lx", symtab.sym_name, offval); 2263 else 2264 kdb_printf(" ra = %s", symtab.sym_name); 2265 } else 2266 kdb_printf(" ra = ?? 0x%p", (void *)ktep->val[4]); 2267 2268 return 1; 2269} 2270 2271 2272/* 2273 * Print out the trace buffer attached to the given vnode. 2274 */ 2275static int kdbm_vntrace( 2276 int argc, 2277 const char **argv, 2278 const char **envp, 2279 struct pt_regs *regs) 2280{ 2281 int diag; 2282 int nextarg = 1; 2283 long offset = 0; 2284 unsigned long addr; 2285 xfs_vnode_t *vp; 2286 ktrace_entry_t *ktep; 2287 ktrace_snap_t kts; 2288 2289 2290 if (argc != 1) 2291 return KDB_ARGCOUNT; 2292 2293 diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL, regs); 2294 2295 if (diag) 2296 return diag; 2297 2298 vp = (xfs_vnode_t *)addr; 2299 2300 if (vp->v_trace == NULL) { 2301 kdb_printf("The vnode trace buffer is not initialized\n"); 2302 2303 return 0; 2304 } 2305 2306 kdb_printf("vntrace vp 0x%p\n", vp); 2307 2308 ktep = ktrace_first(vp->v_trace, &kts); 2309 2310 while (ktep != NULL) { 2311 if (vn_trace_pr_entry(ktep)) 2312 kdb_printf("\n"); 2313 2314 ktep = ktrace_next(vp->v_trace, &kts); 2315 } 2316 2317 return 0; 2318} 2319/* 2320 * Print out the trace buffer attached to the given vnode. 2321 */ 2322static int kdbm_vntraceaddr( 2323 int argc, 2324 const char **argv, 2325 const char **envp, 2326 struct pt_regs *regs) 2327{ 2328 int diag; 2329 int nextarg = 1; 2330 long offset = 0; 2331 unsigned long addr; 2332 struct ktrace *kt; 2333 ktrace_entry_t *ktep; 2334 ktrace_snap_t kts; 2335 2336 2337 if (argc != 1) 2338 return KDB_ARGCOUNT; 2339 2340 diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL, regs); 2341 2342 if (diag) 2343 return diag; 2344 2345 kt = (struct ktrace *)addr; 2346 2347 kdb_printf("vntraceaddr kt 0x%p\n", kt); 2348 2349 ktep = ktrace_first(kt, &kts); 2350 2351 while (ktep != NULL) { 2352 if (vn_trace_pr_entry(ktep)) 2353 kdb_printf("\n"); 2354 2355 ktep = ktrace_next(kt, &kts); 2356 } 2357 2358 return 0; 2359} 2360#endif /* XFS_VNODE_TRACE */ 2361 2362#ifdef __linux__ 2363static void printinode(struct inode *ip) 2364{ 2365 unsigned long addr; 2366 2367 2368 if (ip == NULL) 2369 return; 2370 2371 kdb_printf(" i_ino = %lu i_count = %u i_size %Ld\n", 2372 ip->i_ino, atomic_read(&ip->i_count), 2373 ip->i_size); 2374#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,0) 2375 kdb_printf( 2376 " i_mode = 0x%x i_nlink = %d i_rdev = 0x%x i_state = 0x%lx\n", 2377 ip->i_mode, ip->i_nlink, 2378 kdev_t_to_nr(ip->i_rdev), ip->i_state); 2379 kdb_printf(" i_hash.nxt = 0x%p i_hash.pprv = 0x%p\n", 2380 ip->i_hash.next, ip->i_hash.prev); 2381#else 2382 kdb_printf( 2383 " i_mode = 0x%x i_nlink = %d i_rdev = 0x%x i_state = 0x%lx\n", 2384 ip->i_mode, ip->i_nlink, 2385 ip->i_rdev, ip->i_state); 2386 kdb_printf(" i_hash.nxt = 0x%p i_hash.pprv = 0x%p\n", 2387 ip->i_hash.next, ip->i_hash.pprev); 2388#endif 2389 kdb_printf(" i_list.nxt = 0x%p i_list.prv = 0x%p\n", 2390 ip->i_list.next, ip->i_list.prev); 2391 kdb_printf(" i_dentry.nxt = 0x%p i_dentry.prv = 0x%p\n", 2392 ip->i_dentry.next, 2393 ip->i_dentry.prev); 2394 2395 addr = (unsigned long)ip; 2396 2397 kdb_printf(" i_sb = 0x%p i_op = 0x%p i_data = 0x%lx nrpages = %lu\n", 2398 ip->i_sb, ip->i_op, 2399 addr + offsetof(struct inode, i_data), 2400 ip->i_data.nrpages); 2401 2402 kdb_printf(" vnode ptr 0x%p\n", vn_from_inode(ip)); 2403} 2404 2405#endif 2406 2407 2408static int kdbm_vn( 2409 int argc, 2410 const char **argv, 2411 const char **envp, 2412 struct pt_regs *regs) 2413{ 2414 int diag; 2415 int nextarg = 1; 2416 long offset = 0; 2417 unsigned long addr; 2418#ifdef __linux__ 2419 struct inode *ip; 2420#endif 2421 xfs_vnode_t vp; 2422#ifdef XFS_VNODE_TRACE 2423 ktrace_entry_t *ktep; 2424 ktrace_snap_t kts; 2425#endif 2426 2427 if (argc != 1) 2428 return KDB_ARGCOUNT; 2429 2430 diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL, regs); 2431 if (diag) 2432 return diag; 2433 2434 if ((diag = kdb_getarea(vp, addr))) 2435 return diag; 2436 2437#ifdef __linux__ 2438 ip = vn_to_inode((vnode_t *)addr); 2439 kdb_printf("--> Inode @ 0x%p\n", ip); 2440 printinode(ip); 2441#endif 2442 2443 kdb_printf("--> Vnode @ 0x%lx\n", addr); 2444 printvnode(&vp, addr); 2445 2446#ifdef XFS_VNODE_TRACE 2447 kdb_printf("--> Vntrace @ 0x%lx/0x%p\n", addr, vp.v_trace); 2448 if (vp.v_trace == NULL) 2449 return 0; 2450 ktep = ktrace_first(vp.v_trace, &kts); 2451 while (ktep != NULL) { 2452 if (vn_trace_pr_entry(ktep)) 2453 kdb_printf("\n"); 2454 2455 ktep = ktrace_next(vp.v_trace, &kts); 2456 } 2457#endif /* XFS_VNODE_TRACE */ 2458 return 0; 2459} 2460 2461 2462#ifdef __linux__ 2463 2464static char *bp_flag_vals[] = { 2465/* 0 */ "READ", "WRITE", "MAPPED", "PARTIAL", "ASYNC", 2466/* 5 */ "NONE", "DELWRI", "STALE", "FS_MANAGED", "FS_DATAIOD", 2467/* 10 */ "FORCEIO", "FLUSH", "READ_AHEAD", "DIRECTIO", "LOCK", 2468/* 15 */ "TRYLOCK", "DONT_BLOCK", "PAGE_CACHE", "KMEM_ALLOC", "RUN_QUEUES", 2469/* 20 */ "PRIVATE_BH", "DELWRI_Q", 2470 NULL }; 2471 2472#endif 2473 2474static char *iomap_flag_vals[] = { 2475 "EOF", "HOLE", "DELAY", "INVALID0x08", 2476 "INVALID0x10", "UNWRITTEN", "NEW", "INVALID0x80", 2477 NULL }; 2478 2479 2480static char *map_flags(unsigned long flags, char *mapping[]) 2481{ 2482 static char buffer[256]; 2483 int index; 2484 int offset = 12; 2485 2486 buffer[0] = '\0'; 2487 2488 for (index = 0; flags && mapping[index]; flags >>= 1, index++) { 2489 if (flags & 1) { 2490 if ((offset + strlen(mapping[index]) + 1) >= 80) { 2491 strcat(buffer, "\n "); 2492 offset = 12; 2493 } else if (offset > 12) { 2494 strcat(buffer, " "); 2495 offset++; 2496 } 2497 strcat(buffer, mapping[index]); 2498 offset += strlen(mapping[index]); 2499 } 2500 } 2501 2502 return (buffer); 2503} 2504 2505#ifdef __linux__ 2506 2507static char *bp_flags(xfs_buf_flags_t bp_flag) 2508{ 2509 return(map_flags((unsigned long) bp_flag, bp_flag_vals)); 2510} 2511 2512static int 2513kdbm_bp_flags(int argc, const char **argv, const char **envp, struct pt_regs *regs) 2514{ 2515 unsigned long flags; 2516 int diag; 2517 2518 if (argc != 1) 2519 return KDB_ARGCOUNT; 2520 2521 diag = kdbgetularg(argv[1], &flags); 2522 if (diag) 2523 return diag; 2524 2525 kdb_printf("bp flags 0x%lx = %s\n", flags, bp_flags(flags)); 2526 2527 return 0; 2528} 2529 2530static void 2531print_xfs_buf( 2532 xfs_buf_t *bp, 2533 unsigned long addr) 2534{ 2535 unsigned long age = (xfs_buf_age_centisecs * HZ) / 100; 2536 2537 kdb_printf("xfs_buf_t at 0x%lx\n", addr); 2538 kdb_printf(" b_flags %s\n", bp_flags(bp->b_flags)); 2539 kdb_printf(" b_target 0x%p b_hold %d b_next 0x%p b_prev 0x%p\n", 2540 bp->b_target, bp->b_hold.counter, 2541 list_entry(bp->b_list.next, xfs_buf_t, b_list), 2542 list_entry(bp->b_list.prev, xfs_buf_t, b_list)); 2543 kdb_printf(" b_hash 0x%p b_hash_next 0x%p b_hash_prev 0x%p\n", 2544 bp->b_hash, 2545 list_entry(bp->b_hash_list.next, xfs_buf_t, b_hash_list), 2546 list_entry(bp->b_hash_list.prev, xfs_buf_t, b_hash_list)); 2547 kdb_printf(" b_file_offset 0x%llx b_buffer_length 0x%llx b_addr 0x%p\n", 2548 (unsigned long long) bp->b_file_offset, 2549 (unsigned long long) bp->b_buffer_length, 2550 bp->b_addr); 2551 kdb_printf(" b_bn 0x%llx b_count_desired 0x%lx b_locked %d\n", 2552 (unsigned long long)bp->b_bn, 2553 (unsigned long) bp->b_count_desired, (int)bp->b_locked); 2554 kdb_printf(" b_queuetime %ld (now=%ld/age=%ld) b_io_remaining %d\n", 2555 bp->b_queuetime, jiffies, bp->b_queuetime + age, 2556 bp->b_io_remaining.counter); 2557 kdb_printf(" b_page_count %u b_offset 0x%x b_pages 0x%p b_error %u\n", 2558 bp->b_page_count, bp->b_offset, 2559 bp->b_pages, bp->b_error); 2560 kdb_printf(" b_iodonesema (%d,%d) b_sema (%d,%d) b_pincount (%d)\n", 2561 bp->b_iodonesema.count.counter, 2562 bp->b_iodonesema.sleepers, 2563 bp->b_sema.count.counter, bp->b_sema.sleepers, 2564 bp->b_pin_count.counter); 2565#ifdef XFS_BUF_LOCK_TRACKING 2566 kdb_printf(" last holder %d\n", bp->b_last_holder); 2567#endif 2568 if (bp->b_fspriv || bp->b_fspriv2) { 2569 kdb_printf( " b_fspriv 0x%p b_fspriv2 0x%p\n", 2570 bp->b_fspriv, bp->b_fspriv2); 2571 } 2572} 2573 2574static int 2575kdbm_bp(int argc, const char **argv, const char **envp, struct pt_regs *regs) 2576{ 2577 xfs_buf_t bp; 2578 unsigned long addr; 2579 long offset=0; 2580 int nextarg; 2581 int diag; 2582 2583 if (argc != 1) 2584 return KDB_ARGCOUNT; 2585 2586 nextarg = 1; 2587 if ((diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL, regs)) || 2588 (diag = kdb_getarea(bp, addr))) 2589 return diag; 2590 2591 print_xfs_buf(&bp, addr); 2592 2593 return 0; 2594} 2595 2596static int 2597kdbm_bpdelay(int argc, const char **argv, const char **envp, 2598 struct pt_regs *regs) 2599{ 2600#ifdef DEBUG 2601 extern struct list_head xfs_buftarg_list; 2602 struct list_head *curr, *next; 2603 xfs_buftarg_t *tp, *n; 2604 xfs_buf_t bp; 2605 unsigned long addr, verbose = 0; 2606 int diag, count = 0; 2607 2608 if (argc > 1) 2609 return KDB_ARGCOUNT; 2610 2611 if (argc == 1) { 2612 if ((diag = kdbgetularg(argv[1], &verbose))) { 2613 return diag; 2614 } 2615 } 2616 2617 if (!verbose) { 2618 kdb_printf("index bp pin queuetime\n"); 2619 } 2620 2621 2622 list_for_each_entry_safe(tp, n, &xfs_buftarg_list, bt_list) { 2623 list_for_each_safe(curr, next, &tp->bt_delwrite_queue) { 2624 addr = (unsigned long)list_entry(curr, xfs_buf_t, b_list); 2625 if ((diag = kdb_getarea(bp, addr))) 2626 return diag; 2627 2628 if (verbose) { 2629 print_xfs_buf(&bp, addr); 2630 } else { 2631 kdb_printf("%4d 0x%lx %d %ld\n", 2632 count++, addr, 2633 bp.b_pin_count.counter, 2634 bp.b_queuetime); 2635 } 2636 } 2637 } 2638#else 2639 kdb_printf("bt_delwrite_queue inaccessible (non-debug)\n"); 2640#endif 2641 return 0; 2642} 2643#endif 2644 2645static int 2646kdbm_iomap(int argc, const char **argv, const char **envp, 2647 struct pt_regs *regs) 2648{ 2649 xfs_iomap_t iomap; 2650 unsigned long addr; 2651 long offset=0; 2652 int nextarg; 2653 int diag; 2654 2655 if (argc != 1) 2656 return KDB_ARGCOUNT; 2657 2658 nextarg = 1; 2659 if ((diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL, regs))) 2660 return diag; 2661 if ((diag = kdb_getarea(iomap, addr))) 2662 return diag; 2663 2664 kdb_printf("iomap_t at 0x%lx\n", addr); 2665 kdb_printf(" bn 0x%llx offset 0x%Lx delta 0x%lx bsize 0x%llx\n", 2666 (long long) iomap.iomap_bn, iomap.iomap_offset, 2667 (unsigned long)iomap.iomap_delta, (long long)iomap.iomap_bsize); 2668 kdb_printf(" iomap_flags %s\n", 2669 map_flags(iomap.iomap_flags, iomap_flag_vals)); 2670 2671 return 0; 2672} 2673 2674static int 2675kdbm_i2vnode(int argc, const char **argv, const char **envp, 2676 struct pt_regs *regs) 2677{ 2678 struct vnode vp; 2679 struct inode *ip; 2680 unsigned long addr; 2681 long offset=0; 2682 int nextarg; 2683 int diag; 2684 2685 if (argc != 1) 2686 return KDB_ARGCOUNT; 2687 2688 nextarg = 1; 2689 if ((diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL, regs))) 2690 return diag; 2691 ip = (struct inode *)addr; 2692 if ((diag = kdb_getarea(vp, (unsigned long)vn_from_inode(ip)))) 2693 return diag; 2694 2695 kdb_printf("--> Inode @ 0x%p\n", ip); 2696 printinode(ip); 2697 2698 kdb_printf("--> Vnode @ 0x%p\n", vn_from_inode(ip)); 2699 printvnode(&vp, (unsigned long)vn_from_inode(ip)); 2700 2701 return 0; 2702} 2703 2704#ifdef XFS_BUF_TRACE 2705static int xfs_buf_trace_entry(ktrace_entry_t *ktep) 2706{ 2707 unsigned long long daddr; 2708 2709 daddr = ((unsigned long long)(unsigned long)ktep->val[8] << 32) 2710 | ((unsigned long long)(unsigned long)ktep->val[9]); 2711 2712 kdb_printf("bp 0x%p [%s] (hold %lu lock %ld) data 0x%p", 2713 ktep->val[0], 2714 (char *)ktep->val[1], 2715 (unsigned long)ktep->val[3], 2716 (long)ktep->val[4], 2717 ktep->val[6]); 2718 kdb_symbol_print((unsigned long)ktep->val[7], NULL, 2719 KDB_SP_SPACEB|KDB_SP_PAREN|KDB_SP_NEWLINE); 2720 kdb_printf(" offset 0x%llx size 0x%lx task 0x%p\n", 2721 daddr, (long)ktep->val[10], ktep->val[5]); 2722 kdb_printf(" flags: %s\n", bp_flags((int)(long)ktep->val[2])); 2723 return 1; 2724} 2725 2726static int 2727kdbm_bptrace_offset(int argc, const char **argv, const char **envp, 2728 struct pt_regs *regs) 2729{ 2730 long mask = 0; 2731 unsigned long got_offset = 0, offset = 0; 2732 int diag; 2733 ktrace_entry_t *ktep; 2734 ktrace_snap_t kts; 2735 2736 if (argc > 2) 2737 return KDB_ARGCOUNT; 2738 2739 if (argc > 0) { 2740 diag = kdbgetularg(argv[1], &offset); 2741 if (diag) 2742 return diag; 2743 got_offset = 1; /* allows tracing offset zero */ 2744 } 2745 2746 if (argc > 1) { 2747 diag = kdbgetularg(argv[1], &mask); /* sign extent mask */ 2748 if (diag) 2749 return diag; 2750 } 2751 2752 ktep = ktrace_first(xfs_buf_trace_buf, &kts); 2753 do { 2754 unsigned long long daddr; 2755 2756 if (ktep == NULL) 2757 break; 2758 daddr = ((unsigned long long)(unsigned long)ktep->val[8] << 32) 2759 | ((unsigned long long)(unsigned long)ktep->val[9]); 2760 if (got_offset && ((daddr & ~mask) != offset)) 2761 continue; 2762 if (xfs_buf_trace_entry(ktep)) 2763 kdb_printf("\n"); 2764 } while ((ktep = ktrace_next(xfs_buf_trace_buf, &kts)) != NULL); 2765 return 0; 2766} 2767 2768static int 2769kdbm_bptrace(int argc, const char **argv, const char **envp, 2770 struct pt_regs *regs) 2771{ 2772 unsigned long addr = 0; 2773 int diag, nextarg; 2774 long offset = 0; 2775 char *event_match = NULL; 2776 ktrace_entry_t *ktep; 2777 ktrace_snap_t kts; 2778 2779 if (argc > 1) 2780 return KDB_ARGCOUNT; 2781 2782 if (argc == 1) { 2783 if (isupper(argv[1][0]) || islower(argv[1][0])) { 2784 event_match = (char *)argv[1]; 2785 kdb_printf("event match on \"%s\"\n", event_match); 2786 argc = 0; 2787 } else { 2788 nextarg = 1; 2789 diag = kdbgetaddrarg(argc, argv, 2790 &nextarg, &addr, &offset, NULL, regs); 2791 if (diag) { 2792 kdb_printf("non-numeric arg: %s\n", argv[1]); 2793 return diag; 2794 } 2795 } 2796 } 2797 2798 ktep = ktrace_first(xfs_buf_trace_buf, &kts); 2799 do { 2800 if (ktep == NULL) 2801 break; 2802 if (addr && (ktep->val[0] != (void *)addr)) 2803 continue; 2804 if (event_match && strcmp((char *)ktep->val[1], event_match)) 2805 continue; 2806 if (xfs_buf_trace_entry(ktep)) 2807 qprintf("\n"); 2808 } while ((ktep = ktrace_next(xfs_buf_trace_buf, &kts)) != NULL); 2809 2810 return 0; 2811} 2812#endif 2813 2814struct xif { 2815 char *name; 2816 int (*func)(int, const char **, const char **, struct pt_regs *); 2817 char *args; 2818 char *help; 2819}; 2820 2821static struct xif xfsidbg_funcs[] = { 2822 { "bhv", kdbm_bhv, "<bhv>", "Dump bhv chain"}, 2823 { "vn", kdbm_vn, "<vnode>", "Dump inode/vnode/trace"}, 2824 { "vnode", kdbm_vnode, "<vnode>", "Dump vnode"}, 2825 { "vfs", kdbm_vfs, "<vfs>", "Dump vfs"}, 2826#ifdef XFS_VNODE_TRACE 2827 { "vntrace", kdbm_vntrace, "<vntrace>", "Dump vnode Trace"}, 2828 { "vntraceaddr", kdbm_vntraceaddr, "<vntrace>", 2829 "Dump vnode Trace by Address"}, 2830#endif 2831 { "xagf", kdbm_xfs_xagf, "<agf>", 2832 "Dump XFS allocation group freespace" }, 2833 { "xagi", kdbm_xfs_xagi, "<agi>", 2834 "Dump XFS allocation group inode" }, 2835 { "xail", kdbm_xfs_xaildump, "<xfs_mount_t>", 2836 "Dump XFS AIL for a mountpoint" }, 2837#ifdef XFS_ALLOC_TRACE 2838 { "xalatrc", kdbm_xfs_xalatrace, "<count>", 2839 "Dump XFS alloc count trace" }, 2840 { "xalbtrc", kdbm_xfs_xalbtrace, "<xfs_agblock_t>", 2841 "Dump XFS alloc block trace" }, 2842 { "xalgtrc", kdbm_xfs_xalgtrace, "<xfs_agnumber_t>", 2843 "Dump XFS alloc alloc-group trace" }, 2844#endif 2845 2846 { "xalloc", kdbm_xfs_xalloc, "<xfs_alloc_arg_t>", 2847 "Dump XFS allocation args structure" }, 2848#ifdef XFS_ALLOC_TRACE 2849 { "xalmtrc", kdbm_xfs_xalmtrace, "<xfs_mount_t>", 2850 "Dump XFS alloc mount-point trace" }, 2851 { "xalttrc", kdbm_xfs_xalttrace, "<tag>", 2852 "Dump XFS alloc trace by tag number" }, 2853#endif 2854 { "xarg", kdbm_xfs_xarg, "<value>", 2855 "Input XFS argument for next function" }, 2856 { "xattrcx", kdbm_xfs_xattrcontext, "<xfs_attr_list_context_t>", 2857 "Dump XFS attr_list context struct"}, 2858 { "xattrlf", kdbm_xfs_xattrleaf, "<xfs_attr_leafblock_t>", 2859 "Dump XFS attribute leaf block"}, 2860 { "xattrsf", kdbm_xfs_xattrsf, "<xfs_attr_shortform_t>", 2861 "Dump XFS attribute shortform"}, 2862#ifdef XFS_ATTR_TRACE 2863 { "xattrtr", kdbm_xfs_xattrtrace, "<count>", 2864 "Dump XFS attribute attr_list() trace" }, 2865#endif 2866 { "xbirec", kdbm_xfs_xbirec, "<xfs_bmbt_irec_t", 2867 "Dump XFS bmap incore record"}, 2868#ifdef XFS_BLI_TRACE 2869 { "xblitrc", kdbm_xfs_xblitrace, "<xfs_buf_log_item_t>", 2870 "Dump XFS buf log item trace" }, 2871#endif 2872 { "xbmalla", kdbm_xfs_xbmalla, "<xfs_bmalloca_t>", 2873 "Dump XFS bmalloc args structure"}, 2874#ifdef XFS_BMAP_TRACE 2875 { "xbmatrc", kdbm_xfs_xbmatrace, "<count>", 2876 "Dump XFS bmap btree count trace" }, 2877 { "xbmitrc", kdbm_xfs_xbmitrace, "<xfs_inode_t>", 2878 "Dump XFS bmap btree per-inode trace" }, 2879 { "xbmstrc", kdbm_xfs_xbmstrace, "<xfs_inode_t>", 2880 "Dump XFS bmap btree inode trace" }, 2881#endif 2882 { "xbrec", kdbm_xfs_xbrec, "<xfs_bmbt_rec_64_t>", 2883 "Dump XFS bmap record"}, 2884 { "xbroot", kdbm_xfs_xbroot, "<xfs_inode_t>", 2885 "Dump XFS bmap btree root (data)"}, 2886 { "xbroota", kdbm_xfs_xbroota, "<xfs_inode_t>", 2887 "Dump XFS bmap btree root (attr)"}, 2888 { "xbtcur", kdbm_xfs_xbtcur, "<xfs_btree_cur_t>", 2889 "Dump XFS btree cursor"}, 2890 { "xbuf", kdbm_xfs_xbuf, "<xfs_buf_t>", 2891 "Dump XFS data from a buffer"}, 2892#ifdef XFS_BMAP_TRACE 2893 { "xbxatrc", kdbm_xfs_xbxatrace, "<count>", 2894 "Dump XFS bmap extent count trace" }, 2895 { "xbxitrc", kdbm_xfs_xbxitrace, "<xfs_inode_t>", 2896 "Dump XFS bmap extent per-inode trace" }, 2897 { "xbxstrc", kdbm_xfs_xbxstrace, "<xfs_inode_t>", 2898 "Dump XFS bmap extent inode trace" }, 2899#endif 2900 { "xchash", kdbm_xfs_xchash, "<xfs_mount_t>", 2901 "Dump XFS cluster hash"}, 2902 { "xchlist", kdbm_xfs_xchashlist, "<xfs_chashlist_t>", 2903 "Dump XFS cluster hash list"}, 2904 { "xchksum", kdbm_xfs_xchksum, "<addr>", "Dump chksum" }, 2905#ifdef XFS_DIR2_TRACE 2906 { "xd2atrc", kdbm_xfs_xdir2atrace, "<count>", 2907 "Dump XFS directory v2 count trace" }, 2908#endif 2909 { "xd2free", kdbm_xfs_xdir2free, "<xfs_dir2_free_t>", 2910 "Dump XFS directory v2 freemap"}, 2911#ifdef XFS_DIR2_TRACE 2912 { "xd2itrc", kdbm_xfs_xdir2itrace, "<xfs_inode_t>", 2913 "Dump XFS directory v2 per-inode trace" }, 2914#endif 2915 { "xdaargs", kdbm_xfs_xdaargs, "<xfs_da_args_t>", 2916 "Dump XFS dir/attr args structure"}, 2917 { "xdabuf", kdbm_xfs_xdabuf, "<xfs_dabuf_t>", 2918 "Dump XFS dir/attr buf structure"}, 2919 { "xdanode", kdbm_xfs_xdanode, "<xfs_da_intnode_t>", 2920 "Dump XFS dir/attr node block"}, 2921 { "xdastat", kdbm_xfs_xdastate, "<xfs_da_state_t>", 2922 "Dump XFS dir/attr state_blk struct"}, 2923 { "xdelay", kdbm_xfs_delayed_blocks, "<xfs_mount_t>", 2924 "Dump delayed block totals"}, 2925 { "xdirlf", kdbm_xfs_xdirleaf, "<xfs_dir_leafblock_t>", 2926 "Dump XFS directory leaf block"}, 2927 { "xdirsf", kdbm_xfs_xdirsf, "<xfs_dir_shortform_t>", 2928 "Dump XFS directory shortform"}, 2929 { "xdir2sf", kdbm_xfs_xdir2sf, "<xfs_dir2_sf_t>", 2930 "Dump XFS directory v2 shortform"}, 2931#ifdef XFS_DIR_TRACE 2932 { "xdirtrc", kdbm_xfs_xdirtrace, "<count>", 2933 "Dump XFS directory getdents() trace" }, 2934#endif 2935 { "xdiskdq", kdbm_xfs_xqm_diskdq, "<xfs_disk_dquot_t>", 2936 "Dump XFS ondisk dquot (quota) struct"}, 2937 { "xdqatt", kdbm_xfs_xqm_dqattached_inos, "<xfs_mount_t>", 2938 "All incore inodes with dquots"}, 2939 { "xdqinfo", kdbm_xfs_xqm_tpdqinfo, "<xfs_trans_t>", 2940 "Dump dqinfo structure of a trans"}, 2941#ifdef XFS_DQUOT_TRACE 2942 { "xdqtrace",kdbm_xfs_xqm_dqtrace, "<xfs_dquot_t>", 2943 "Dump trace of a given dquot" }, 2944#endif 2945 { "xdquot", kdbm_xfs_xqm_dquot, "<xfs_dquot_t>", 2946 "Dump XFS dquot (quota) structure"}, 2947 { "xexlist", kdbm_xfs_xexlist, "<xfs_inode_t>", 2948 "Dump XFS bmap extents in inode"}, 2949 { "xflist", kdbm_xfs_xflist, "<xfs_bmap_free_t>", 2950 "Dump XFS to-be-freed extent records"}, 2951 { "xhelp", kdbm_xfs_xhelp, "", 2952 "Print idbg-xfs help"}, 2953 { "xicall", kdbm_xfs_xiclogall, "<xlog_in_core_t>", 2954 "Dump All XFS in-core logs"}, 2955 { "xiclog", kdbm_xfs_xiclog, "<xlog_in_core_t>", 2956 "Dump XFS in-core log"}, 2957#ifdef XFS_LOG_TRACE 2958 { "xictrc", kdbm_xfs_xiclogtrace, "<xlog_in_core_t>", 2959 "Dump XFS in-core log trace" }, 2960#endif 2961 { "xihash", kdbm_xfs_xihash, "<xfs_mount_t>", 2962 "Dump XFS inode hash statistics"}, 2963#ifdef XFS_ILOCK_TRACE 2964 { "xilocktrc",kdbm_xfs_xilock_trace, "<xfs_inode_t>", 2965 "Dump XFS ilock trace" }, 2966 { "xailcktrc",kdbm_xfs_xailock_trace,"<count>", 2967 "Dump XFS global ilock trace" }, 2968#endif 2969 { "xinodes", kdbm_xfs_xinodes, "<xfs_mount_t>", 2970 "Dump XFS inodes per mount"}, 2971 { "xquiesce",kdbm_xfs_xinodes_quiesce, "<xfs_mount_t>", 2972 "Dump non-quiesced XFS inodes per mount"}, 2973#ifdef XFS_LOG_TRACE 2974 { "xl_grtr", kdbm_xfs_xlog_granttrace, "<xlog_t>", 2975 "Dump XFS log grant trace" }, 2976#endif 2977 { "xl_rcit", kdbm_xfs_xlog_ritem, "<xlog_recover_item_t>", 2978 "Dump XFS recovery item"}, 2979 { "xl_rctr", kdbm_xfs_xlog_rtrans, "<xlog_recover_t>", 2980 "Dump XFS recovery transaction"}, 2981 { "xl_rctr2",kdbm_xfs_xlog_rtrans_entire, "<xlog_recover_t>", 2982 "Dump entire recovery transaction"}, 2983 { "xl_tic", kdbm_xfs_xlog_tic, "<xlog_ticket_t>", 2984 "Dump XFS log ticket"}, 2985 { "xlog", kdbm_xfs_xlog, "<xlog_t>", 2986 "Dump XFS log"}, 2987 { "xlogcb", kdbm_xfs_xiclogcb, "<xlog_in_core_t>", 2988 "Dump XFS in-core log callbacks"}, 2989 { "xlogitm", kdbm_xfs_xlogitem, "<xfs_log_item_t>", 2990 "Dump XFS log item structure"}, 2991 { "xmount", kdbm_xfs_xmount, "<xfs_mount_t>", 2992 "Dump XFS mount structure"}, 2993 { "xnode", kdbm_xfs_xnode, "<xfs_inode_t>", 2994 "Dump XFS inode"}, 2995 { "xiocore", kdbm_xfs_xcore, "<xfs_iocore_t>", 2996 "Dump XFS iocore"}, 2997 { "xperag", kdbm_xfs_xperag, "<xfs_mount_t>", 2998 "Dump XFS per-allocation group data"}, 2999 { "xqinfo", kdbm_xfs_xqm_qinfo, "<xfs_mount_t>", 3000 "Dump mount->m_quotainfo structure"}, 3001#ifdef CONFIG_XFS_QUOTA 3002 { "xqm", kdbm_xfs_xqm, "", 3003 "Dump XFS quota manager structure"}, 3004 { "xqmfree", kdbm_xfs_xqm_freelist, "", 3005 "Dump XFS global freelist of dquots"}, 3006 { "xqmhtab", kdbm_xfs_xqm_htab, "", 3007 "Dump XFS hashtable of dquots"}, 3008#endif /* CONFIG_XFS_QUOTA */ 3009 { "xqmplist",kdbm_xfs_xqm_mplist, "<xfs_mount_t>", 3010 "Dump XFS all dquots of a f/s"}, 3011#ifdef XFS_RW_TRACE 3012 { "xrwtrc", kdbm_xfs_xrwtrace, "<xfs_inode_t>", 3013 "Dump XFS inode read/write trace" }, 3014#endif 3015 { "xsb", kdbm_xfs_xsb, "<xfs_sb_t> <cnv>", 3016 "Dump XFS superblock"}, 3017 { "xtp", kdbm_xfs_xtp, "<xfs_trans_t>", 3018 "Dump XFS transaction structure"}, 3019 { "xtrres", kdbm_xfs_xtrans_res, "<xfs_mount_t>", 3020 "Dump XFS reservation values"}, 3021 { NULL, NULL, NULL } 3022}; 3023 3024static struct xif xfsbuf_funcs[] = { 3025 { "bp", kdbm_bp, "<vaddr>", "Display xfs_buf_t" }, 3026 { "bpflags", kdbm_bp_flags, "<flags>", "Display xfs_buf flags" }, 3027 { "xiomap", kdbm_iomap, "<xfs_iomap_t *>", "Display IOmap" }, 3028 { "i2vnode", kdbm_i2vnode, "<inode *>", "Display Vnode" }, 3029 { "bpdelay", kdbm_bpdelay, "0|1", "Display delwri buffers" }, 3030#ifdef XFS_BUF_TRACE 3031 { "bptrace", kdbm_bptrace, "<vaddr>|<count>", "xfs_buf_t trace" }, 3032 { "bpoffset",kdbm_bptrace_offset, "<daddr> [<mask>]","xfs_buf_t trace" }, 3033#endif 3034 { NULL, NULL, NULL } 3035}; 3036 3037static int 3038xfsidbg_init(void) 3039{ 3040 struct xif *p; 3041 3042 for (p = xfsidbg_funcs; p->name; p++) 3043 kdb_register(p->name, p->func, p->args, p->help, 0); 3044 for (p = xfsbuf_funcs; p->name; p++) 3045 kdb_register(p->name, p->func, p->args, p->help, 0); 3046 return 0; 3047} 3048 3049static void 3050xfsidbg_exit(void) 3051{ 3052 struct xif *p; 3053 3054 for (p = xfsidbg_funcs; p->name; p++) 3055 kdb_unregister(p->name); 3056 for (p = xfsbuf_funcs; p->name; p++) 3057 kdb_unregister(p->name); 3058} 3059 3060/* 3061 * Argument to xfs_alloc routines, for allocation type. 3062 */ 3063static char *xfs_alloctype[] = { 3064 "any_ag", "first_ag", "start_ag", "this_ag", 3065 "start_bno", "near_bno", "this_bno" 3066}; 3067 3068/* 3069 * Static functions. 3070 */ 3071 3072#ifdef XFS_ALLOC_TRACE 3073/* 3074 * Print xfs alloc trace buffer entry. 3075 */ 3076static int 3077xfs_alloc_trace_entry(ktrace_entry_t *ktep) 3078{ 3079 static char *modagf_flags[] = { 3080 "magicnum", 3081 "versionnum", 3082 "seqno", 3083 "length", 3084 "roots", 3085 "levels", 3086 "flfirst", 3087 "fllast", 3088 "flcount", 3089 "freeblks", 3090 "longest", 3091 NULL 3092 }; 3093 3094 if (((__psint_t)ktep->val[0] & 0xffff) == 0) 3095 return 0; 3096 switch ((long)ktep->val[0] & 0xffffL) { 3097 case XFS_ALLOC_KTRACE_ALLOC: 3098 kdb_printf("alloc %s[%s %ld] mp 0x%p\n", 3099 (char *)ktep->val[1], 3100 ktep->val[2] ? (char *)ktep->val[2] : "", 3101 (long)ktep->val[0] >> 16, 3102 (xfs_mount_t *)ktep->val[3]); 3103 kdb_printf( 3104 "agno %ld agbno %ld minlen %ld maxlen %ld mod %ld prod %ld minleft %ld\n", 3105 (long)ktep->val[4], 3106 (long)ktep->val[5], 3107 (long)ktep->val[6], 3108 (long)ktep->val[7], 3109 (long)ktep->val[8], 3110 (long)ktep->val[9], 3111 (long)ktep->val[10]); 3112 kdb_printf("total %ld alignment %ld len %ld type %s otype %s\n", 3113 (long)ktep->val[11], 3114 (long)ktep->val[12], 3115 (long)ktep->val[13], 3116 xfs_alloctype[((__psint_t)ktep->val[14]) >> 16], 3117 xfs_alloctype[((__psint_t)ktep->val[14]) & 0xffff]); 3118 kdb_printf("wasdel %d wasfromfl %d isfl %d userdata %d\n", 3119 ((__psint_t)ktep->val[15] & (1 << 3)) != 0, 3120 ((__psint_t)ktep->val[15] & (1 << 2)) != 0, 3121 ((__psint_t)ktep->val[15] & (1 << 1)) != 0, 3122 ((__psint_t)ktep->val[15] & (1 << 0)) != 0); 3123 break; 3124 case XFS_ALLOC_KTRACE_FREE: 3125 kdb_printf("free %s[%s %ld] mp 0x%p\n", 3126 (char *)ktep->val[1], 3127 ktep->val[2] ? (char *)ktep->val[2] : "", 3128 (long)ktep->val[0] >> 16, 3129 (xfs_mount_t *)ktep->val[3]); 3130 kdb_printf("agno %ld agbno %ld len %ld isfl %d\n", 3131 (long)ktep->val[4], 3132 (long)ktep->val[5], 3133 (long)ktep->val[6], 3134 (__psint_t)ktep->val[7] != 0); 3135 break; 3136 case XFS_ALLOC_KTRACE_MODAGF: 3137 kdb_printf("modagf %s[%s %ld] mp 0x%p\n", 3138 (char *)ktep->val[1], 3139 ktep->val[2] ? (char *)ktep->val[2] : "", 3140 (long)ktep->val[0] >> 16, 3141 (xfs_mount_t *)ktep->val[3]); 3142 printflags((__psint_t)ktep->val[4], modagf_flags, "modified"); 3143 kdb_printf("seqno %lu length %lu roots b %lu c %lu\n", 3144 (unsigned long)ktep->val[5], 3145 (unsigned long)ktep->val[6], 3146 (unsigned long)ktep->val[7], 3147 (unsigned long)ktep->val[8]); 3148 kdb_printf("levels b %lu c %lu flfirst %lu fllast %lu flcount %lu\n", 3149 (unsigned long)ktep->val[9], 3150 (unsigned long)ktep->val[10], 3151 (unsigned long)ktep->val[11], 3152 (unsigned long)ktep->val[12], 3153 (unsigned long)ktep->val[13]); 3154 kdb_printf("freeblks %lu longest %lu\n", 3155 (unsigned long)ktep->val[14], 3156 (unsigned long)ktep->val[15]); 3157 break; 3158 3159 case XFS_ALLOC_KTRACE_UNBUSY: 3160 kdb_printf("unbusy %s [%s %ld] mp 0x%p\n", 3161 (char *)ktep->val[1], 3162 ktep->val[2] ? (char *)ktep->val[2] : "", 3163 (long)ktep->val[0] >> 16, 3164 (xfs_mount_t *)ktep->val[3]); 3165 kdb_printf(" agno %lu slot %lu tp 0x%p\n", 3166 (unsigned long)ktep->val[4], 3167 (unsigned long)ktep->val[7], 3168 (xfs_trans_t *)ktep->val[8]); 3169 break; 3170 case XFS_ALLOC_KTRACE_BUSY: 3171 kdb_printf("busy %s [%s %ld] mp 0x%p\n", 3172 (char *)ktep->val[1], 3173 ktep->val[2] ? (char *)ktep->val[2] : "", 3174 (long)ktep->val[0] >> 16, 3175 (xfs_mount_t *)ktep->val[3]); 3176 kdb_printf(" agno %lu agbno %lu len %lu slot %lu tp 0x%p\n", 3177 (unsigned long)ktep->val[4], 3178 (unsigned long)ktep->val[5], 3179 (unsigned long)ktep->val[6], 3180 (unsigned long)ktep->val[7], 3181 (xfs_trans_t *)ktep->val[8]); 3182 break; 3183 case XFS_ALLOC_KTRACE_BUSYSEARCH: 3184 kdb_printf("busy-search %s [%s %ld] mp 0x%p\n", 3185 (char *)ktep->val[1], 3186 ktep->val[2] ? (char *)ktep->val[2] : "", 3187 (long)ktep->val[0] >> 16, 3188 (xfs_mount_t *)ktep->val[3]); 3189 kdb_printf(" agno %ld agbno %ld len %ld slot %ld tp 0x%p\n", 3190 (unsigned long)ktep->val[4], 3191 (unsigned long)ktep->val[5], 3192 (unsigned long)ktep->val[6], 3193 (unsigned long)ktep->val[7], 3194 (xfs_trans_t *)ktep->val[8]); 3195 break; 3196 default: 3197 kdb_printf("unknown alloc trace record\n"); 3198 break; 3199 } 3200 return 1; 3201} 3202#endif /* XFS_ALLOC_TRACE */ 3203 3204#ifdef XFS_ATTR_TRACE 3205/* 3206 * Print an attribute trace buffer entry. 3207 */ 3208static int 3209xfs_attr_trace_entry(ktrace_entry_t *ktep) 3210{ 3211 static char *attr_arg_flags[] = { 3212 "DONTFOLLOW", /* 0x0001 */ 3213 "ROOT", /* 0x0002 */ 3214 "TRUSTED", /* 0x0004 */ 3215 "SECURE", /* 0x0008 */ 3216 "CREATE", /* 0x0010 */ 3217 "REPLACE", /* 0x0020 */ 3218 "?", /* 0x0040 */ 3219 "?", /* 0x0080 */ 3220 "SYSTEM", /* 0x0100 */ 3221 "?", /* 0x0200 */ 3222 "?", /* 0x0400 */ 3223 "?", /* 0x0800 */ 3224 "KERNOTIME", /* 0x1000 */ 3225 "KERNOVAL", /* 0x2000 */ 3226 "KERNAMELS", /* 0x4000 */ 3227 "KERNFULLS", /* 0x8000 */ 3228 NULL 3229 }; 3230 3231 if (!ktep->val[0]) 3232 return 0; 3233 3234 qprintf("-- %s: cursor h/b/o 0x%lx/0x%lx/%lu, dupcnt %lu, dp 0x%p\n", 3235 (char *)ktep->val[1], 3236 (unsigned long)ktep->val[3], 3237 (unsigned long)ktep->val[4], 3238 (unsigned long)ktep->val[5], 3239 (unsigned long)ktep->val[11], 3240 (xfs_inode_t *)ktep->val[2]); 3241 qprintf(" alist 0x%p, size %lu, count %lu, firstu %lu, Llen %lu", 3242 (attrlist_t *)ktep->val[6], 3243 (unsigned long)ktep->val[7], 3244 (unsigned long)ktep->val[8], 3245 (unsigned long)ktep->val[9], 3246 (unsigned long)ktep->val[10]); 3247 printflags((__psunsigned_t)(ktep->val[12]), attr_arg_flags, ", flags"); 3248 qprintf("\n"); 3249 3250 switch ((__psint_t)ktep->val[0]) { 3251 case XFS_ATTR_KTRACE_L_C: 3252 break; 3253 case XFS_ATTR_KTRACE_L_CN: 3254 qprintf(" node: count %lu, 1st hash 0x%lx, last hash 0x%lx\n", 3255 (unsigned long)ktep->val[13], 3256 (unsigned long)ktep->val[14], 3257 (unsigned long)ktep->val[15]); 3258 break; 3259 case XFS_ATTR_KTRACE_L_CB: 3260 qprintf(" btree: hash 0x%lx, blkno 0x%lx\n", 3261 (unsigned long)ktep->val[13], 3262 (unsigned long)ktep->val[14]); 3263 break; 3264 case XFS_ATTR_KTRACE_L_CL: 3265 qprintf(" leaf: count %ld, 1st hash 0x%lx, last hash 0x%lx\n", 3266 (unsigned long)ktep->val[13], 3267 (unsigned long)ktep->val[14], 3268 (unsigned long)ktep->val[15]); 3269 break; 3270 default: 3271 qprintf(" unknown attr trace record format\n"); 3272 break; 3273 } 3274 return 1; 3275} 3276#endif /* XFS_ATTR_TRACE */ 3277 3278#ifdef XFS_BMAP_TRACE 3279/* 3280 * Print xfs bmap extent trace buffer entry. 3281 */ 3282static int 3283xfs_bmap_trace_entry(ktrace_entry_t *ktep) 3284{ 3285 xfs_dfsbno_t b; 3286 xfs_dfilblks_t c; 3287 xfs_inode_t *ip; 3288 xfs_ino_t ino; 3289 xfs_dfiloff_t o; 3290 int flag; 3291 int opcode; 3292 static char *ops[] = { "del", "ins", "pre", "post" }; 3293 xfs_bmbt_rec_32_t r; 3294 int whichfork; 3295 3296 opcode = ((__psint_t)ktep->val[0]) & 0xffff; 3297 if (opcode == 0) 3298 return 0; 3299 whichfork = ((__psint_t)ktep->val[0]) >> 16; 3300 ip = (xfs_inode_t *)ktep->val[3]; 3301 ino = ((xfs_ino_t)(unsigned long)ktep->val[6] << 32) | 3302 ((xfs_ino_t)(unsigned long)ktep->val[7]); 3303 qprintf("%s %s:%s ip %p ino %s %cf\n", 3304 ops[opcode - 1], (char *)ktep->val[1], 3305 (char *)ktep->val[2], ip, xfs_fmtino(ino, ip->i_mount), 3306 "da"[whichfork]); 3307 r.l0 = (xfs_bmbt_rec_base_t)(unsigned long)ktep->val[8]; 3308 r.l1 = (xfs_bmbt_rec_base_t)(unsigned long)ktep->val[9]; 3309 r.l2 = (xfs_bmbt_rec_base_t)(unsigned long)ktep->val[10]; 3310 r.l3 = (xfs_bmbt_rec_base_t)(unsigned long)ktep->val[11]; 3311 xfs_convert_extent(&r, &o, &b, &c, &flag); 3312 qprintf(" idx %ld offset %lld block %s", 3313 (long)ktep->val[4], o, 3314 xfs_fmtfsblock((xfs_fsblock_t)b, ip->i_mount)); 3315 qprintf(" count %lld flag %d\n", c, flag); 3316 if ((__psint_t)ktep->val[5] != 2) 3317 return 1; 3318 r.l0 = (xfs_bmbt_rec_base_t)(unsigned long)ktep->val[12]; 3319 r.l1 = (xfs_bmbt_rec_base_t)(unsigned long)ktep->val[13]; 3320 r.l2 = (xfs_bmbt_rec_base_t)(unsigned long)ktep->val[14]; 3321 r.l3 = (xfs_bmbt_rec_base_t)(unsigned long)ktep->val[15]; 3322 xfs_convert_extent(&r, &o, &b, &c, &flag); 3323 qprintf(" offset %lld block %s", o, 3324 xfs_fmtfsblock((xfs_fsblock_t)b, ip->i_mount)); 3325 qprintf(" count %lld flag %d\n", c, flag); 3326 return 1; 3327} 3328 3329/* 3330 * Print xfs bmap btree trace buffer entry. 3331 */ 3332static int 3333xfs_bmbt_trace_entry( 3334 ktrace_entry_t *ktep) 3335{ 3336 int line; 3337 xfs_bmbt_rec_32_t r; 3338 xfs_bmbt_irec_t s; 3339 int type; 3340 int whichfork; 3341 3342 type = (__psint_t)ktep->val[0] & 0xff; 3343 if (type == 0) 3344 return 0; 3345 whichfork = ((__psint_t)ktep->val[0] >> 8) & 0xff; 3346 line = ((__psint_t)ktep->val[0] >> 16) & 0xffff; 3347 qprintf("%s[%s@%d] ip 0x%p %cf cur 0x%p\n", 3348 (char *)ktep->val[1], 3349 (char *)ktep->val[2], 3350 line, 3351 (xfs_inode_t *)ktep->val[3], 3352 "da"[whichfork], 3353 (xfs_btree_cur_t *)ktep->val[4]); 3354 switch (type) { 3355 case XFS_BMBT_KTRACE_ARGBI: 3356 qprintf(" buf 0x%p i %ld\n", 3357 (xfs_buf_t *)ktep->val[5], 3358 (long)ktep->val[6]); 3359 break; 3360 case XFS_BMBT_KTRACE_ARGBII: 3361 qprintf(" buf 0x%p i0 %ld i1 %ld\n", 3362 (xfs_buf_t *)ktep->val[5], 3363 (long)ktep->val[6], 3364 (long)ktep->val[7]); 3365 break; 3366 case XFS_BMBT_KTRACE_ARGFFFI: 3367 qprintf(" o 0x%x%08x b 0x%x%08x i 0x%x%08x j %ld\n", 3368 (unsigned int)(long)ktep->val[5], 3369 (unsigned int)(long)ktep->val[6], 3370 (unsigned int)(long)ktep->val[7], 3371 (unsigned int)(long)ktep->val[8], 3372 (unsigned int)(long)ktep->val[9], 3373 (unsigned int)(long)ktep->val[10], 3374 (long)ktep->val[11]); 3375 break; 3376 case XFS_BMBT_KTRACE_ARGI: 3377 qprintf(" i 0x%lx\n", 3378 (long)ktep->val[5]); 3379 break; 3380 case XFS_BMBT_KTRACE_ARGIFK: 3381 qprintf(" i 0x%lx f 0x%x%08x o 0x%x%08x\n", 3382 (long)ktep->val[5], 3383 (unsigned int)(long)ktep->val[6], 3384 (unsigned int)(long)ktep->val[7], 3385 (unsigned int)(long)ktep->val[8], 3386 (unsigned int)(long)ktep->val[9]); 3387 break; 3388 case XFS_BMBT_KTRACE_ARGIFR: 3389 qprintf(" i 0x%lx f 0x%x%08x ", 3390 (long)ktep->val[5], 3391 (unsigned int)(long)ktep->val[6], 3392 (unsigned int)(long)ktep->val[7]); 3393 s.br_startoff = (xfs_fileoff_t) 3394 (((xfs_dfiloff_t)(unsigned long)ktep->val[8] << 32) | 3395 (xfs_dfiloff_t)(unsigned long)ktep->val[9]); 3396 s.br_startblock = (xfs_fsblock_t) 3397 (((xfs_dfsbno_t)(unsigned long)ktep->val[10] << 32) | 3398 (xfs_dfsbno_t)(unsigned long)ktep->val[11]); 3399 s.br_blockcount = (xfs_filblks_t) 3400 (((xfs_dfilblks_t)(unsigned long)ktep->val[12] << 32) | 3401 (xfs_dfilblks_t)(unsigned long)ktep->val[13]); 3402 xfsidbg_xbirec(&s); 3403 break; 3404 case XFS_BMBT_KTRACE_ARGIK: 3405 qprintf(" i 0x%lx o 0x%x%08x\n", 3406 (long)ktep->val[5], 3407 (unsigned int)(long)ktep->val[6], 3408 (unsigned int)(long)ktep->val[7]); 3409 break; 3410 case XFS_BMBT_KTRACE_CUR: 3411 qprintf(" nlevels %ld flags %ld allocated %ld ", 3412 ((long)ktep->val[5] >> 24) & 0xff, 3413 ((long)ktep->val[5] >> 16) & 0xff, 3414 (long)ktep->val[5] & 0xffff); 3415 r.l0 = (xfs_bmbt_rec_base_t)(unsigned long)ktep->val[6]; 3416 r.l1 = (xfs_bmbt_rec_base_t)(unsigned long)ktep->val[7]; 3417 r.l2 = (xfs_bmbt_rec_base_t)(unsigned long)ktep->val[8]; 3418 r.l3 = (xfs_bmbt_rec_base_t)(unsigned long)ktep->val[9]; 3419 xfsidbg_xbrec((xfs_bmbt_rec_64_t *)&r); 3420 qprintf(" bufs 0x%p 0x%p 0x%p 0x%p ", 3421 (xfs_buf_t *)ktep->val[10], 3422 (xfs_buf_t *)ktep->val[11], 3423 (xfs_buf_t *)ktep->val[12], 3424 (xfs_buf_t *)ktep->val[13]); 3425 qprintf("ptrs %ld %ld %ld %ld\n", 3426 (long)ktep->val[14] >> 16, 3427 (long)ktep->val[14] & 0xffff, 3428 (long)ktep->val[15] >> 16, 3429 (long)ktep->val[15] & 0xffff); 3430 break; 3431 default: 3432 qprintf("unknown bmbt trace record\n"); 3433 break; 3434 } 3435 return 1; 3436} 3437#endif 3438 3439/* 3440 * Print an xfs in-inode bmap btree root. 3441 */ 3442static void 3443xfs_broot(xfs_inode_t *ip, xfs_ifork_t *f) 3444{ 3445 xfs_bmbt_block_t *broot; 3446 int format; 3447 int i; 3448 xfs_bmbt_key_t *kp; 3449 xfs_bmbt_ptr_t *pp; 3450 3451 format = f == &ip->i_df ? ip->i_d.di_format : ip->i_d.di_aformat; 3452 if ((f->if_flags & XFS_IFBROOT) == 0 || 3453 format != XFS_DINODE_FMT_BTREE) { 3454 kdb_printf("inode 0x%p not btree format\n", ip); 3455 return; 3456 } 3457 broot = f->if_broot; 3458 kdb_printf("block @0x%p magic %x level %d numrecs %d\n", 3459 broot, 3460 be32_to_cpu(broot->bb_magic), 3461 be16_to_cpu(broot->bb_level), 3462 be16_to_cpu(broot->bb_numrecs)); 3463 kp = XFS_BMAP_BROOT_KEY_ADDR(broot, 1, f->if_broot_bytes); 3464 pp = XFS_BMAP_BROOT_PTR_ADDR(broot, 1, f->if_broot_bytes); 3465 for (i = 1; i <= be16_to_cpu(broot->bb_numrecs); i++) 3466 kdb_printf("\t%d: startoff %Ld ptr %Lx %s\n", 3467 i, INT_GET(kp[i - 1].br_startoff, ARCH_CONVERT), INT_GET(pp[i - 1], ARCH_CONVERT), 3468 xfs_fmtfsblock(INT_GET(pp[i - 1], ARCH_CONVERT), ip->i_mount)); 3469} 3470 3471/* 3472 * Print allocation btree block. 3473 */ 3474static void 3475xfs_btalloc(xfs_alloc_block_t *bt, int bsz) 3476{ 3477 int i; 3478 3479 kdb_printf("magic 0x%x level %d numrecs %d leftsib 0x%x rightsib 0x%x\n", 3480 be32_to_cpu(bt->bb_magic), 3481 be16_to_cpu(bt->bb_level), 3482 be16_to_cpu(bt->bb_numrecs), 3483 be32_to_cpu(bt->bb_leftsib), 3484 be32_to_cpu(bt->bb_rightsib)); 3485 if (!bt->bb_level) { 3486 for (i = 1; i <= be16_to_cpu(bt->bb_numrecs); i++) { 3487 xfs_alloc_rec_t *r; 3488 3489 r = XFS_BTREE_REC_ADDR(bsz, xfs_alloc, bt, i, 0); 3490 kdb_printf("rec %d startblock 0x%x blockcount %d\n", 3491 i, 3492 be32_to_cpu(r->ar_startblock), 3493 be32_to_cpu(r->ar_blockcount)); 3494 } 3495 } else { 3496 int mxr; 3497 3498 mxr = XFS_BTREE_BLOCK_MAXRECS(bsz, xfs_alloc, 0); 3499 for (i = 1; i <= be16_to_cpu(bt->bb_numrecs); i++) { 3500 xfs_alloc_key_t *k; 3501 xfs_alloc_ptr_t *p; 3502 3503 k = XFS_BTREE_KEY_ADDR(bsz, xfs_alloc, bt, i, mxr); 3504 p = XFS_BTREE_PTR_ADDR(bsz, xfs_alloc, bt, i, mxr); 3505 kdb_printf("key %d startblock 0x%x blockcount %d ptr 0x%x\n", 3506 i, 3507 be32_to_cpu(k->ar_startblock), 3508 be32_to_cpu(k->ar_blockcount), 3509 be32_to_cpu(*p)); 3510 } 3511 } 3512} 3513 3514/* 3515 * Print a bmap btree block. 3516 */ 3517static void 3518xfs_btbmap(xfs_bmbt_block_t *bt, int bsz) 3519{ 3520 int i; 3521 3522 kdb_printf("magic 0x%x level %d numrecs %d leftsib %Lx rightsib %Lx\n", 3523 be32_to_cpu(bt->bb_magic), 3524 be16_to_cpu(bt->bb_level), 3525 be16_to_cpu(bt->bb_numrecs), 3526 be64_to_cpu(bt->bb_leftsib), 3527 be64_to_cpu(bt->bb_rightsib)); 3528 if (!bt->bb_level) { 3529 for (i = 1; i <= be16_to_cpu(bt->bb_numrecs); i++) { 3530 xfs_bmbt_rec_t *r; 3531 xfs_bmbt_irec_t irec; 3532 3533 r = (xfs_bmbt_rec_t *)XFS_BTREE_REC_ADDR(bsz, 3534 xfs_bmbt, bt, i, 0); 3535 3536 xfs_bmbt_disk_get_all((xfs_bmbt_rec_t *)r, &irec); 3537 kdb_printf("rec %d startoff %Ld startblock %Lx blockcount %Ld flag %d\n", 3538 i, irec.br_startoff, 3539 (__uint64_t)irec.br_startblock, 3540 irec.br_blockcount, irec.br_state); 3541 } 3542 } else { 3543 int mxr; 3544 3545 mxr = XFS_BTREE_BLOCK_MAXRECS(bsz, xfs_bmbt, 0); 3546 for (i = 1; i <= be16_to_cpu(bt->bb_numrecs); i++) { 3547 xfs_bmbt_key_t *k; 3548 xfs_bmbt_ptr_t *p; 3549 3550 k = XFS_BTREE_KEY_ADDR(bsz, xfs_bmbt, bt, i, mxr); 3551 p = XFS_BTREE_PTR_ADDR(bsz, xfs_bmbt, bt, i, mxr); 3552 kdb_printf("key %d startoff %Ld ", 3553 i, INT_GET(k->br_startoff, ARCH_CONVERT)); 3554 kdb_printf("ptr %Lx\n", INT_GET(*p, ARCH_CONVERT)); 3555 } 3556 } 3557} 3558 3559/* 3560 * Print an inode btree block. 3561 */ 3562static void 3563xfs_btino(xfs_inobt_block_t *bt, int bsz) 3564{ 3565 int i; 3566 3567 kdb_printf("magic 0x%x level %d numrecs %d leftsib 0x%x rightsib 0x%x\n", 3568 be32_to_cpu(bt->bb_magic), 3569 be16_to_cpu(bt->bb_level), 3570 be16_to_cpu(bt->bb_numrecs), 3571 be32_to_cpu(bt->bb_leftsib), 3572 be32_to_cpu(bt->bb_rightsib)); 3573 if (!bt->bb_level) { 3574 for (i = 1; i <= be16_to_cpu(bt->bb_numrecs); i++) { 3575 xfs_inobt_rec_t *r; 3576 3577 r = XFS_BTREE_REC_ADDR(bsz, xfs_inobt, bt, i, 0); 3578 kdb_printf("rec %d startino 0x%x freecount %d, free %Lx\n", 3579 i, INT_GET(r->ir_startino, ARCH_CONVERT), 3580 INT_GET(r->ir_freecount, ARCH_CONVERT), 3581 INT_GET(r->ir_free, ARCH_CONVERT)); 3582 } 3583 } else { 3584 int mxr; 3585 3586 mxr = XFS_BTREE_BLOCK_MAXRECS(bsz, xfs_inobt, 0); 3587 for (i = 1; i <= be16_to_cpu(bt->bb_numrecs); i++) { 3588 xfs_inobt_key_t *k; 3589 xfs_inobt_ptr_t *p; 3590 3591 k = XFS_BTREE_KEY_ADDR(bsz, xfs_inobt, bt, i, mxr); 3592 p = XFS_BTREE_PTR_ADDR(bsz, xfs_inobt, bt, i, mxr); 3593 kdb_printf("key %d startino 0x%x ptr 0x%x\n", 3594 i, INT_GET(k->ir_startino, ARCH_CONVERT), 3595 be32_to_cpu(*p)); 3596 } 3597 } 3598} 3599 3600/* 3601 * Print a buf log item. 3602 */ 3603static void 3604xfs_buf_item_print(xfs_buf_log_item_t *blip, int summary) 3605{ 3606 static char *bli_flags[] = { 3607 "hold", /* 0x1 */ 3608 "dirty", /* 0x2 */ 3609 "stale", /* 0x4 */ 3610 "logged", /* 0x8 */ 3611 "ialloc", /* 0x10 */ 3612 "inode_stale", /* 0x20 */ 3613 NULL 3614 }; 3615 static char *blf_flags[] = { 3616 "inode", /* 0x1 */ 3617 "cancel", /* 0x2 */ 3618 NULL 3619 }; 3620 3621 if (summary) { 3622 kdb_printf("buf 0x%p blkno 0x%Lx ", blip->bli_buf, 3623 blip->bli_format.blf_blkno); 3624 printflags(blip->bli_flags, bli_flags, "flags:"); 3625 kdb_printf("\n "); 3626 xfsidbg_xbuf_real(blip->bli_buf, 1); 3627 return; 3628 } 3629 kdb_printf("buf 0x%p recur %d refcount %d flags:", 3630 blip->bli_buf, blip->bli_recur, 3631 atomic_read(&blip->bli_refcount)); 3632 printflags(blip->bli_flags, bli_flags, NULL); 3633 kdb_printf("\n"); 3634 kdb_printf("size %d blkno 0x%Lx len 0x%x map size %d map 0x%p\n", 3635 blip->bli_format.blf_size, blip->bli_format.blf_blkno, 3636 (uint) blip->bli_format.blf_len, blip->bli_format.blf_map_size, 3637 &(blip->bli_format.blf_data_map[0])); 3638 kdb_printf("blf flags: "); 3639 printflags((uint)blip->bli_format.blf_flags, blf_flags, NULL); 3640#ifdef XFS_TRANS_DEBUG 3641 kdb_printf("orig 0x%x logged 0x%x", 3642 blip->bli_orig, blip->bli_logged); 3643#endif 3644 kdb_printf("\n"); 3645} 3646 3647#ifdef XFS_BMAP_TRACE 3648/* 3649 * Convert an external extent descriptor to internal form. 3650 */ 3651static void 3652xfs_convert_extent(xfs_bmbt_rec_32_t *rp, xfs_dfiloff_t *op, xfs_dfsbno_t *sp, 3653 xfs_dfilblks_t *cp, int *fp) 3654{ 3655 xfs_dfiloff_t o; 3656 xfs_dfsbno_t s; 3657 xfs_dfilblks_t c; 3658 int flag; 3659 3660 flag = (((xfs_dfiloff_t)rp->l0) >> 31) & 1; 3661 o = ((((xfs_dfiloff_t)rp->l0) & 0x7fffffff) << 23) | 3662 (((xfs_dfiloff_t)rp->l1) >> 9); 3663 s = (((xfs_dfsbno_t)(rp->l1 & 0x000001ff)) << 43) | 3664 (((xfs_dfsbno_t)rp->l2) << 11) | 3665 (((xfs_dfsbno_t)rp->l3) >> 21); 3666 c = (xfs_dfilblks_t)(rp->l3 & 0x001fffff); 3667 *op = o; 3668 *sp = s; 3669 *cp = c; 3670 *fp = flag; 3671} 3672#endif 3673 3674#ifdef XFS_RW_TRACE 3675/* 3676 * Print itrunc entry trace. 3677 */ 3678static void 3679xfs_ctrunc_trace_entry(ktrace_entry_t *ktep) 3680{ 3681 qprintf("ip 0x%p cpu %ld\n", 3682 (xfs_inode_t *)(unsigned long)ktep->val[1], (long)ktep->val[2]); 3683} 3684#endif 3685 3686/* 3687 * Print an xfs_da_state_path structure. 3688 */ 3689static void 3690xfs_dastate_path(xfs_da_state_path_t *p) 3691{ 3692 int i; 3693 3694 kdb_printf("active %d\n", p->active); 3695 for (i = 0; i < XFS_DA_NODE_MAXDEPTH; i++) { 3696 kdb_printf(" blk %d bp 0x%p blkno 0x%x", 3697 i, p->blk[i].bp, p->blk[i].blkno); 3698 kdb_printf(" index %d hashval 0x%x ", 3699 p->blk[i].index, (uint_t)p->blk[i].hashval); 3700 switch(p->blk[i].magic) { 3701 case XFS_DA_NODE_MAGIC: kdb_printf("NODE\n"); break; 3702 case XFS_DIR_LEAF_MAGIC: kdb_printf("DIR\n"); break; 3703 case XFS_ATTR_LEAF_MAGIC: kdb_printf("ATTR\n"); break; 3704 case XFS_DIR2_LEAFN_MAGIC: kdb_printf("DIR2\n"); break; 3705 default: kdb_printf("type ?\n"); break; 3706 } 3707 } 3708} 3709 3710#ifdef XFS_DIR_TRACE 3711/* 3712 * Print a xfs directory trace buffer entry. 3713 */ 3714static int 3715xfs_dir_trace_entry(ktrace_entry_t *ktep) 3716{ 3717 xfs_mount_t *mp; 3718 __uint32_t hash; 3719 xfs_off_t cookie; 3720 3721 if (!ktep->val[0] || !ktep->val[1]) 3722 return 0; 3723 3724 mp = (xfs_mount_t *)ktep->val[3]; 3725 cookie = (__psunsigned_t)ktep->val[4]; 3726 cookie <<= 32; 3727 cookie |= (__psunsigned_t)ktep->val[5]; 3728 qprintf("%s -- dp=0x%p b/e/h=%ld/%ld/0x%08lx resid=0x%lx ", 3729 (char *)ktep->val[1], 3730 (xfs_inode_t *)ktep->val[2], 3731 (long)XFS_DA_COOKIE_BNO(mp, cookie), 3732 (long)XFS_DA_COOKIE_ENTRY(mp, cookie), 3733 (unsigned long)XFS_DA_COOKIE_HASH(mp, cookie), 3734 (long)ktep->val[6]); 3735 3736 switch ((__psint_t)ktep->val[0]) { 3737 case XFS_DIR_KTRACE_G_DU: 3738 break; 3739 case XFS_DIR_KTRACE_G_DUB: 3740 qprintf("bno=%ld", (long)ktep->val[7]); 3741 break; 3742 case XFS_DIR_KTRACE_G_DUN: 3743 qprintf("forw=%ld, cnt=%ld, 0x%08lx - 0x%08lx", 3744 (long)ktep->val[7], 3745 (long)ktep->val[8], 3746 (unsigned long)ktep->val[9], 3747 (unsigned long)ktep->val[10]); 3748 break; 3749 case XFS_DIR_KTRACE_G_DUL: 3750 qprintf("forw=%ld, cnt=%ld, 0x%08lx - 0x%08lx", 3751 (long)ktep->val[7], 3752 (long)ktep->val[8], 3753 (unsigned long)ktep->val[9], 3754 (unsigned long)ktep->val[10]); 3755 break; 3756 case XFS_DIR_KTRACE_G_DUE: 3757 qprintf("entry hashval 0x%08lx", (unsigned long)ktep->val[7]); 3758 break; 3759 case XFS_DIR_KTRACE_G_DUC: 3760 cookie = (__psunsigned_t)ktep->val[7]; 3761 cookie <<= 32; 3762 cookie |= (__psunsigned_t)ktep->val[8]; 3763 hash = XFS_DA_COOKIE_HASH(mp, cookie); 3764 qprintf("b/e/h=%ld/%ld/0x%08x", 3765 (long)XFS_DA_COOKIE_BNO(mp, cookie), 3766 (long)XFS_DA_COOKIE_ENTRY(mp, cookie), 3767 hash); 3768 break; 3769 default: 3770 qprintf("unknown dir trace record format"); 3771 break; 3772 } 3773 return 1; 3774} 3775#endif 3776 3777#ifdef XFS_DIR2_TRACE 3778/* 3779 * Print a xfs v2 directory trace buffer entry. 3780 */ 3781static int 3782xfs_dir2_trace_entry(ktrace_entry_t *ktep) 3783{ 3784 char *cp; 3785 int i; 3786 int len; 3787 3788 if (!ktep->val[0]) 3789 return 0; 3790 cp = (char *)&ktep->val[10]; 3791 qprintf("%s: '", (char *)ktep->val[1]); 3792 len = min((__psint_t)ktep->val[9], (__psint_t)sizeof(ktep->val[10])*6); 3793 for (i = 0; i < len; i++) 3794 qprintf("%c", cp[i]); 3795 qprintf("'(%ld)", (long)ktep->val[9]); 3796 if ((__psunsigned_t)ktep->val[0] != XFS_DIR2_KTRACE_ARGS_BIBII) 3797 qprintf(" hashval 0x%llx inumber %lld dp 0x%p tp 0x%p check %d", 3798 (__uint64_t)(unsigned long)ktep->val[2], 3799 (__int64_t)(unsigned long)ktep->val[3], 3800 ktep->val[4], ktep->val[5], 3801 (int)(__psint_t)ktep->val[6]); 3802 switch ((__psunsigned_t)ktep->val[0]) { 3803 case XFS_DIR2_KTRACE_ARGS: 3804 break; 3805 case XFS_DIR2_KTRACE_ARGS_B: 3806 qprintf(" bp 0x%p", ktep->val[7]); 3807 break; 3808 case XFS_DIR2_KTRACE_ARGS_BB: 3809 qprintf(" lbp 0x%p dbp 0x%p", ktep->val[7], ktep->val[8]); 3810 break; 3811 case XFS_DIR2_KTRACE_ARGS_BIBII: 3812 qprintf(" dp 0x%p tp 0x%p srcbp 0x%p srci %d dstbp 0x%p dsti %d count %d", 3813 ktep->val[2], ktep->val[3], ktep->val[4], 3814 (int)(__psint_t)ktep->val[5], ktep->val[6], 3815 (int)(__psint_t)ktep->val[7], 3816 (int)(__psint_t)ktep->val[8]); 3817 break; 3818 case XFS_DIR2_KTRACE_ARGS_DB: 3819 qprintf(" db 0x%x bp 0x%p", 3820 (xfs_dir2_db_t)(unsigned long)ktep->val[7], 3821 ktep->val[8]); 3822 break; 3823 case XFS_DIR2_KTRACE_ARGS_I: 3824 qprintf(" i 0x%lx", (unsigned long)ktep->val[7]); 3825 break; 3826 case XFS_DIR2_KTRACE_ARGS_S: 3827 qprintf(" s 0x%x", (int)(__psint_t)ktep->val[7]); 3828 break; 3829 case XFS_DIR2_KTRACE_ARGS_SB: 3830 qprintf(" s 0x%x bp 0x%p", (int)(__psint_t)ktep->val[7], 3831 ktep->val[8]); 3832 break; 3833 default: 3834 qprintf("unknown dirv2 trace record format"); 3835 break; 3836 } 3837 return 1; 3838} 3839#endif 3840 3841/* 3842 * Print an efd log item. 3843 */ 3844static void 3845xfs_efd_item_print(xfs_efd_log_item_t *efdp, int summary) 3846{ 3847 int i; 3848 xfs_extent_t *ep; 3849 3850 if (summary) { 3851 kdb_printf("Extent Free Done: ID 0x%Lx nextents %d (at 0x%p)\n", 3852 efdp->efd_format.efd_efi_id, 3853 efdp->efd_format.efd_nextents, efdp); 3854 return; 3855 } 3856 kdb_printf("size %d nextents %d next extent %d efip 0x%p\n", 3857 efdp->efd_format.efd_size, efdp->efd_format.efd_nextents, 3858 efdp->efd_next_extent, efdp->efd_efip); 3859 kdb_printf("efi_id 0x%Lx\n", efdp->efd_format.efd_efi_id); 3860 kdb_printf("efd extents:\n"); 3861 ep = &(efdp->efd_format.efd_extents[0]); 3862 for (i = 0; i < efdp->efd_next_extent; i++, ep++) { 3863 kdb_printf(" block %Lx len %d\n", 3864 ep->ext_start, ep->ext_len); 3865 } 3866} 3867 3868/* 3869 * Print an efi log item. 3870 */ 3871static void 3872xfs_efi_item_print(xfs_efi_log_item_t *efip, int summary) 3873{ 3874 int i; 3875 xfs_extent_t *ep; 3876 static char *efi_flags[] = { 3877 "recovered", /* 0x1 */ 3878 "committed", /* 0x2 */ 3879 "cancelled", /* 0x4 */ 3880 NULL, 3881 }; 3882 3883 if (summary) { 3884 kdb_printf("Extent Free Intention: ID 0x%Lx nextents %d (at 0x%p)\n", 3885 efip->efi_format.efi_id, 3886 efip->efi_format.efi_nextents, efip); 3887 return; 3888 } 3889 kdb_printf("size %d nextents %d next extent %d\n", 3890 efip->efi_format.efi_size, efip->efi_format.efi_nextents, 3891 efip->efi_next_extent); 3892 kdb_printf("id %Lx", efip->efi_format.efi_id); 3893 printflags(efip->efi_flags, efi_flags, "flags :"); 3894 kdb_printf("\n"); 3895 kdb_printf("efi extents:\n"); 3896 ep = &(efip->efi_format.efi_extents[0]); 3897 for (i = 0; i < efip->efi_next_extent; i++, ep++) { 3898 kdb_printf(" block %Lx len %d\n", 3899 ep->ext_start, ep->ext_len); 3900 } 3901} 3902 3903/* 3904 * Format inode "format" into a static buffer & return it. 3905 */ 3906static char * 3907xfs_fmtformat(xfs_dinode_fmt_t f) 3908{ 3909 static char *t[] = { 3910 "dev", 3911 "local", 3912 "extents", 3913 "btree", 3914 "uuid" 3915 }; 3916 3917 return t[f]; 3918} 3919 3920/* 3921 * Format fsblock number into a static buffer & return it. 3922 */ 3923char * 3924xfs_fmtfsblock(xfs_fsblock_t bno, xfs_mount_t *mp) 3925{ 3926 static char rval[50]; 3927 3928 if (bno == NULLFSBLOCK) 3929 sprintf(rval, "NULLFSBLOCK"); 3930 else if (ISNULLSTARTBLOCK(bno)) 3931 sprintf(rval, "NULLSTARTBLOCK(%Ld)", STARTBLOCKVAL(bno)); 3932 else if (mp) 3933 sprintf(rval, "%Ld[%x:%x]", (xfs_dfsbno_t)bno, 3934 XFS_FSB_TO_AGNO(mp, bno), XFS_FSB_TO_AGBNO(mp, bno)); 3935 else 3936 sprintf(rval, "%Ld", (xfs_dfsbno_t)bno); 3937 return rval; 3938} 3939 3940/* 3941 * Format inode number into a static buffer & return it. 3942 */ 3943static char * 3944xfs_fmtino(xfs_ino_t ino, xfs_mount_t *mp) 3945{ 3946 static char rval[50]; 3947 3948 if (mp) 3949 sprintf(rval, "%llu[%x:%x:%x]", 3950 (unsigned long long) ino, 3951 XFS_INO_TO_AGNO(mp, ino), 3952 XFS_INO_TO_AGBNO(mp, ino), 3953 XFS_INO_TO_OFFSET(mp, ino)); 3954 else 3955 sprintf(rval, "%llu", (unsigned long long) ino); 3956 return rval; 3957} 3958 3959/* 3960 * Format an lsn for printing into a static buffer & return it. 3961 */ 3962static char * 3963xfs_fmtlsn(xfs_lsn_t *lsnp) 3964{ 3965 uint *wordp; 3966 uint *word2p; 3967 static char buf[20]; 3968 3969 wordp = (uint *)lsnp; 3970 word2p = wordp++; 3971 sprintf(buf, "[%u:%u]", *wordp, *word2p); 3972 3973 return buf; 3974} 3975 3976/* 3977 * Format file mode into a static buffer & return it. 3978 */ 3979static char * 3980xfs_fmtmode(int m) 3981{ 3982 static char rval[16]; 3983 3984 sprintf(rval, "%c%c%c%c%c%c%c%c%c%c%c%c%c", 3985 "?fc?dxb?r?l?S?m?"[(m & S_IFMT) >> 12], 3986 m & S_ISUID ? 'u' : '-', 3987 m & S_ISGID ? 'g' : '-', 3988 m & S_ISVTX ? 'v' : '-', 3989 m & S_IRUSR ? 'r' : '-', 3990 m & S_IWUSR ? 'w' : '-', 3991 m & S_IXUSR ? 'x' : '-', 3992 m & S_IRGRP ? 'r' : '-', 3993 m & S_IWGRP ? 'w' : '-', 3994 m & S_IXGRP ? 'x' : '-', 3995 m & S_IROTH ? 'r' : '-', 3996 m & S_IWOTH ? 'w' : '-', 3997 m & S_IXOTH ? 'x' : '-'); 3998 return rval; 3999} 4000 4001/* 4002 * Format a size into a static buffer & return it. 4003 */ 4004static char * 4005xfs_fmtsize(size_t i) 4006{ 4007 static char rval[20]; 4008 4009 /* size_t is 32 bits in 32-bit kernel, 64 bits in 64-bit kernel */ 4010 sprintf(rval, "0x%lx", (unsigned long) i); 4011 return rval; 4012} 4013 4014/* 4015 * Format a uuid into a static buffer & return it. 4016 */ 4017static char * 4018xfs_fmtuuid(uuid_t *uu) 4019{ 4020 static char rval[40]; 4021 char *o = rval; 4022 char *i = (unsigned char*)uu; 4023 int b; 4024 4025 for (b=0;b<16;b++) { 4026 o+=sprintf(o, "%02x", *i++); 4027 if (b==3||b==5||b==7||b==9) *o++='-'; 4028 } 4029 *o='\0'; 4030 4031 return rval; 4032} 4033 4034/* 4035 * Print an inode log item. 4036 */ 4037static void 4038xfs_inode_item_print(xfs_inode_log_item_t *ilip, int summary) 4039{ 4040 static char *ili_flags[] = { 4041 "hold", /* 0x1 */ 4042 "iolock excl", /* 0x2 */ 4043 "iolock shrd", /* 0x4 */ 4044 NULL 4045 }; 4046 static char *ilf_fields[] = { 4047 "core", /* 0x001 */ 4048 "ddata", /* 0x002 */ 4049 "dexts", /* 0x004 */ 4050 "dbroot", /* 0x008 */ 4051 "dev", /* 0x010 */ 4052 "uuid", /* 0x020 */ 4053 "adata", /* 0x040 */ 4054 "aext", /* 0x080 */ 4055 "abroot", /* 0x100 */ 4056 NULL 4057 }; 4058 4059 if (summary) { 4060 kdb_printf("inode 0x%p logged %d ", 4061 ilip->ili_inode, ilip->ili_logged); 4062 printflags(ilip->ili_flags, ili_flags, "flags:"); 4063 printflags(ilip->ili_format.ilf_fields, ilf_fields, "format:"); 4064 printflags(ilip->ili_last_fields, ilf_fields, "lastfield:"); 4065 kdb_printf("\n"); 4066 return; 4067 } 4068 kdb_printf("inode 0x%p ino 0x%llu pushbuf %d logged %d flags: ", 4069 ilip->ili_inode, (unsigned long long) ilip->ili_format.ilf_ino, 4070 ilip->ili_pushbuf_flag, ilip->ili_logged); 4071 printflags(ilip->ili_flags, ili_flags, NULL); 4072 kdb_printf("\n"); 4073 kdb_printf("ilock recur %d iolock recur %d ext buf 0x%p\n", 4074 ilip->ili_ilock_recur, ilip->ili_iolock_recur, 4075 ilip->ili_extents_buf); 4076#ifdef XFS_TRANS_DEBUG 4077 kdb_printf("root bytes %d root orig 0x%x\n", 4078 ilip->ili_root_size, ilip->ili_orig_root); 4079#endif 4080 kdb_printf("size %d ", ilip->ili_format.ilf_size); 4081 printflags(ilip->ili_format.ilf_fields, ilf_fields, "fields:"); 4082 printflags(ilip->ili_last_fields, ilf_fields, " last fields: "); 4083 kdb_printf("\n"); 4084 kdb_printf(" flush lsn %s last lsn %s\n", 4085 xfs_fmtlsn(&(ilip->ili_flush_lsn)), 4086 xfs_fmtlsn(&(ilip->ili_last_lsn))); 4087 kdb_printf("dsize %d, asize %d, rdev 0x%x\n", 4088 ilip->ili_format.ilf_dsize, 4089 ilip->ili_format.ilf_asize, 4090 ilip->ili_format.ilf_u.ilfu_rdev); 4091 kdb_printf("blkno 0x%Lx len 0x%x boffset 0x%x\n", 4092 ilip->ili_format.ilf_blkno, 4093 ilip->ili_format.ilf_len, 4094 ilip->ili_format.ilf_boffset); 4095} 4096 4097/* 4098 * Print a dquot log item. 4099 */ 4100/* ARGSUSED */ 4101static void 4102xfs_dquot_item_print(xfs_dq_logitem_t *lip, int summary) 4103{ 4104 kdb_printf("dquot 0x%p\n", 4105 lip->qli_dquot); 4106 4107} 4108 4109/* 4110 * Print a quotaoff log item. 4111 */ 4112/* ARGSUSED */ 4113static void 4114xfs_qoff_item_print(xfs_qoff_logitem_t *lip, int summary) 4115{ 4116 kdb_printf("start qoff item 0x%p flags 0x%x\n", 4117 lip->qql_start_lip, lip->qql_format.qf_flags); 4118 4119} 4120 4121/* 4122 * Print buffer full of inodes. 4123 */ 4124static void 4125xfs_inodebuf(xfs_buf_t *bp) 4126{ 4127 xfs_dinode_t *di; 4128 xfs_dinode_core_t dic; 4129 int n, i; 4130 4131 n = XFS_BUF_COUNT(bp) >> 8; 4132 for (i = 0; i < n; i++) { 4133 di = (xfs_dinode_t *)xfs_buf_offset(bp, 4134 i * 256); 4135 4136 xfs_xlate_dinode_core((xfs_caddr_t)&di->di_core, &dic, 1); 4137 xfs_prdinode_core(&dic); 4138 kdb_printf("next_unlinked 0x%x u@0x%p\n", 4139 INT_GET(di->di_next_unlinked, ARCH_CONVERT), 4140 &di->di_u); 4141 } 4142} 4143 4144#ifdef XFS_RW_TRACE 4145/* 4146 * Print iomap entry trace. 4147 */ 4148static void 4149xfs_iomap_enter_trace_entry(ktrace_entry_t *ktep) 4150{ 4151 qprintf("ip 0x%p size 0x%x%x offset 0x%x%x count 0x%x\n", 4152 ktep->val[1], 4153 (unsigned int)(long)ktep->val[2], 4154 (unsigned int)(long)ktep->val[3], 4155 (unsigned int)(long)ktep->val[4], 4156 (unsigned int)(long)ktep->val[5], 4157 (unsigned int)(long)ktep->val[6]); 4158 qprintf("io new size 0x%x%x pid=%d\n", 4159 (unsigned int)(long)ktep->val[7], 4160 (unsigned int)(long)ktep->val[8], 4161 (unsigned int)(long)ktep->val[9]); 4162} 4163 4164/* 4165 * Print iomap map trace. 4166 */ 4167static void 4168xfs_iomap_map_trace_entry(ktrace_entry_t *ktep) 4169{ 4170 static char *bmapi_flags[] = { 4171 "read", /* BMAPI_READ */ 4172 "write", /* BMAPI_WRITE */ 4173 "allocate", /* BMAPI_ALLOCATE */ 4174 "unwritten", /* BMAPI_UNWRITTEN */ 4175 "ignstate", /* BMAPI_IGNSTATE */ 4176 "direct", /* BMAPI_DIRECT */ 4177 "mmap", /* BMAPI_MMAP */ 4178 "sync", /* BMAPI_SYNC */ 4179 "trylock", /* BMAPI_TRYLOCK */ 4180 "device", /* BMAPI_DEVICE */ 4181 NULL 4182 }; 4183 4184 qprintf("ip 0x%p size 0x%x%x offset 0x%x%x count 0x%x\n", 4185 ktep->val[1], 4186 (unsigned int)(long)ktep->val[2], 4187 (unsigned int)(long)ktep->val[3], 4188 (unsigned int)(long)ktep->val[4], 4189 (unsigned int)(long)ktep->val[5], 4190 (unsigned int)(long)ktep->val[6]); 4191 printflags((__psint_t)ktep->val[7], bmapi_flags, "bmapi flags"); 4192 qprintf("iomap off 0x%x%x delta 0x%x bsize 0x%x bno 0x%x\n", 4193 (unsigned int)(long)ktep->val[8], 4194 (unsigned int)(long)ktep->val[9], 4195 (unsigned int)(long)ktep->val[10], 4196 (unsigned int)(long)ktep->val[11], 4197 (unsigned int)(long)ktep->val[12]); 4198 qprintf("imap off 0x%x count 0x%x block 0x%x\n", 4199 (unsigned int)(long)ktep->val[13], 4200 (unsigned int)(long)ktep->val[14], 4201 (unsigned int)(long)ktep->val[15]); 4202} 4203 4204/* 4205 * Print itrunc entry trace. 4206 */ 4207static void 4208xfs_itrunc_trace_entry(ktrace_entry_t *ktep) 4209{ 4210 qprintf("ip 0x%p size 0x%x%x flag %ld new size 0x%x%x\n", 4211 ktep->val[1], 4212 (unsigned int)(long)ktep->val[2], 4213 (unsigned int)(long)ktep->val[3], 4214 (long)ktep->val[4], 4215 (unsigned int)(long)ktep->val[5], 4216 (unsigned int)(long)ktep->val[6]); 4217 qprintf("toss start 0x%x%x toss finish 0x%x%x cpu id %ld pid %d\n", 4218 (unsigned int)(long)ktep->val[7], 4219 (unsigned int)(long)ktep->val[8], 4220 (unsigned int)(long)ktep->val[9], 4221 (unsigned int)(long)ktep->val[10], 4222 (long)ktep->val[11], 4223 (unsigned int)(long)ktep->val[12]); 4224} 4225 4226/* 4227 * Print bunmap entry trace. 4228 */ 4229static void 4230xfs_bunmap_trace_entry(ktrace_entry_t *ktep) 4231{ 4232 static char *bunmapi_flags[] = { 4233 "write", /* 0x01 */ 4234 "delay", /* 0x02 */ 4235 "entire", /* 0x04 */ 4236 "metadata", /* 0x08 */ 4237 "exact", /* 0x10 */ 4238 "attrfork", /* 0x20 */ 4239 "async", /* 0x40 */ 4240 "rsvblocks", /* 0x80 */ 4241 NULL 4242 }; 4243 4244 qprintf("ip 0x%p size 0x%x%x bno 0x%x%x len 0x%x cpu id %ld\n", 4245 ktep->val[1], 4246 (unsigned int)(long)ktep->val[2], 4247 (unsigned int)(long)ktep->val[3], 4248 (unsigned int)(long)ktep->val[4], 4249 (unsigned int)(long)ktep->val[5], 4250 (unsigned int)(long)ktep->val[6], 4251 (long)ktep->val[8]); 4252 qprintf("ra 0x%p pid %d ", ktep->val[9], (int)(long)ktep->val[10]); 4253 printflags((__psint_t)ktep->val[7], bunmapi_flags, "flags"); 4254} 4255 4256/* 4257 * Print inval_cached_pages entry trace. 4258 */ 4259static void 4260xfs_inval_cached_trace_entry(ktrace_entry_t *ktep) 4261{ 4262 qprintf("ip 0x%p offset 0x%x%x len 0x%x%x first 0x%x%x last 0x%x%x pid %d\n", 4263 ktep->val[1], 4264 (unsigned int)(long)ktep->val[2], 4265 (unsigned int)(long)ktep->val[3], 4266 (unsigned int)(long)ktep->val[4], 4267 (unsigned int)(long)ktep->val[5], 4268 (unsigned int)(long)ktep->val[6], 4269 (unsigned int)(long)ktep->val[7], 4270 (unsigned int)(long)ktep->val[8], 4271 (unsigned int)(long)ktep->val[9], 4272 (unsigned int)(long)ktep->val[10]); 4273} 4274#endif 4275 4276 4277/* 4278 * Print disk inode core. 4279 */ 4280static void 4281xfs_prdinode_core(xfs_dinode_core_t *dip) 4282{ 4283 static char *diflags[] = { 4284 "realtime", /* XFS_DIFLAG_REALTIME */ 4285 "prealloc", /* XFS_DIFLAG_PREALLOC */ 4286 "newrtbm", /* XFS_DIFLAG_NEWRTBM */ 4287 "immutable", /* XFS_DIFLAG_IMMUTABLE */ 4288 "append", /* XFS_DIFLAG_APPEND */ 4289 "sync", /* XFS_DIFLAG_SYNC */ 4290 "noatime", /* XFS_DIFLAG_NOATIME */ 4291 "nodump", /* XFS_DIFLAG_NODUMP */ 4292 "rtinherit", /* XFS_DIFLAG_RTINHERIT */ 4293 "projinherit", /* XFS_DIFLAG_PROJINHERIT */ 4294 "nosymlinks", /* XFS_DIFLAG_NOSYMLINKS */ 4295 "extsize", /* XFS_DIFLAG_EXTSIZE */ 4296 "extszinherit", /* XFS_DIFLAG_EXTSZINHERIT */ 4297 NULL 4298 }; 4299 4300 kdb_printf("magic 0x%x mode 0%o (%s) version 0x%x format 0x%x (%s)\n", 4301 dip->di_magic, dip->di_mode, 4302 xfs_fmtmode(dip->di_mode), 4303 dip->di_version, dip->di_format, 4304 xfs_fmtformat((xfs_dinode_fmt_t)dip->di_format)); 4305 kdb_printf("nlink %d uid %d gid %d projid %d flushiter %u\n", 4306 dip->di_nlink, 4307 dip->di_uid, 4308 dip->di_gid, 4309 (uint)dip->di_projid, 4310 (uint)dip->di_flushiter); 4311 kdb_printf("atime %u:%u mtime %ud:%u ctime %u:%u\n", 4312 dip->di_atime.t_sec, dip->di_atime.t_nsec, 4313 dip->di_mtime.t_sec, dip->di_mtime.t_nsec, 4314 dip->di_ctime.t_sec, dip->di_ctime.t_nsec); 4315 kdb_printf("size %Ld ", dip->di_size); 4316 kdb_printf("nblocks %Ld extsize 0x%x nextents 0x%x anextents 0x%x\n", 4317 dip->di_nblocks, dip->di_extsize, dip->di_nextents, 4318 dip->di_anextents); 4319 kdb_printf("forkoff %d aformat 0x%x (%s) dmevmask 0x%x dmstate 0x%x ", 4320 dip->di_forkoff, dip->di_aformat, 4321 xfs_fmtformat((xfs_dinode_fmt_t)dip->di_aformat), 4322 dip->di_dmevmask, dip->di_dmstate); 4323 printflags(dip->di_flags, diflags, "flags"); 4324 kdb_printf("gen 0x%x\n", dip->di_gen); 4325} 4326 4327#ifdef XFS_RW_TRACE 4328/* 4329 * Print read/write entry trace. 4330 */ 4331static void 4332xfs_rw_enter_trace_entry(ktrace_entry_t *ktep) 4333{ 4334 qprintf("ip 0x%p size 0x%x%x ptr 0x%p size %lu\n", 4335 ktep->val[1], 4336 (unsigned int)(long)ktep->val[2], 4337 (unsigned int)(long)ktep->val[3], 4338 ktep->val[4], 4339 (unsigned long)ktep->val[5]); 4340 qprintf("io offset 0x%x%x ioflags 0x%x new size 0x%x%x pid %d\n", 4341 (unsigned int)(long)ktep->val[6], 4342 (unsigned int)(long)ktep->val[7], 4343 (unsigned int)(long)ktep->val[8], 4344 (unsigned int)(long)ktep->val[9], 4345 (unsigned int)(long)ktep->val[10], 4346 (unsigned int)(long)ktep->val[11]); 4347} 4348 4349/* 4350 * Print page write/release trace. 4351 */ 4352static void 4353xfs_page_trace_entry(ktrace_entry_t *ktep) 4354{ 4355 qprintf("ip 0x%p inode 0x%p page 0x%p\n", 4356 ktep->val[1], ktep->val[2], ktep->val[3]); 4357 qprintf("mask 0x%x di_size 0x%x%x isize 0x%x%x offset 0x%x%x\n", 4358 (unsigned int)(long)ktep->val[4], 4359 (unsigned int)(long)ktep->val[5], 4360 (unsigned int)(long)ktep->val[6], 4361 (unsigned int)(long)ktep->val[7], 4362 (unsigned int)(long)ktep->val[8], 4363 (unsigned int)(long)ktep->val[9], 4364 (unsigned int)(long)ktep->val[10]); 4365 qprintf("delalloc %d unmapped %d unwritten %d pid %d\n", 4366 (unsigned int)(long)ktep->val[11], 4367 (unsigned int)(long)ktep->val[12], 4368 (unsigned int)(long)ktep->val[13], 4369 (unsigned int)(long)ktep->val[14]); 4370} 4371 4372/* 4373 * Print read/write trace entry. 4374 */ 4375static int 4376xfs_rw_trace_entry(ktrace_entry_t *ktep) 4377{ 4378 switch ( (long)ktep->val[0] ) { 4379 case XFS_READ_ENTER: 4380 qprintf("READ ENTER:\n"); 4381 xfs_rw_enter_trace_entry(ktep); 4382 break; 4383 case XFS_WRITE_ENTER: 4384 qprintf("WRITE ENTER:\n"); 4385 xfs_rw_enter_trace_entry(ktep); 4386 break; 4387 case XFS_SENDFILE_ENTER: 4388 qprintf("SENDFILE ENTER:\n"); 4389 xfs_rw_enter_trace_entry(ktep); 4390 break; 4391 case XFS_IOMAP_READ_ENTER: 4392 qprintf("IOMAP READ ENTER:\n"); 4393 xfs_iomap_enter_trace_entry(ktep); 4394 break; 4395 case XFS_IOMAP_WRITE_ENTER: 4396 qprintf("IOMAP WRITE ENTER:\n"); 4397 xfs_iomap_enter_trace_entry(ktep); 4398 break; 4399 case XFS_IOMAP_WRITE_NOSPACE: 4400 qprintf("IOMAP WRITE NOSPACE:\n"); 4401 xfs_iomap_enter_trace_entry(ktep); 4402 break; 4403 case XFS_IOMAP_READ_MAP: 4404 qprintf("IOMAP READ MAP:\n"); 4405 xfs_iomap_map_trace_entry(ktep); 4406 break; 4407 case XFS_IOMAP_WRITE_MAP: 4408 qprintf("IOMAP WRITE MAP:\n"); 4409 xfs_iomap_map_trace_entry(ktep); 4410 break; 4411 case XFS_ITRUNC_START: 4412 qprintf("ITRUNC START:\n"); 4413 xfs_itrunc_trace_entry(ktep); 4414 break; 4415 case XFS_ITRUNC_FINISH1: 4416 qprintf("ITRUNC FINISH1:\n"); 4417 xfs_itrunc_trace_entry(ktep); 4418 break; 4419 case XFS_ITRUNC_FINISH2: 4420 qprintf("ITRUNC FINISH2:\n"); 4421 xfs_itrunc_trace_entry(ktep); 4422 break; 4423 case XFS_CTRUNC1: 4424 qprintf("CTRUNC1:\n"); 4425 xfs_ctrunc_trace_entry(ktep); 4426 break; 4427 case XFS_CTRUNC2: 4428 qprintf("CTRUNC2:\n"); 4429 xfs_ctrunc_trace_entry(ktep); 4430 break; 4431 case XFS_CTRUNC3: 4432 qprintf("CTRUNC3:\n"); 4433 xfs_ctrunc_trace_entry(ktep); 4434 break; 4435 case XFS_CTRUNC4: 4436 qprintf("CTRUNC4:\n"); 4437 xfs_ctrunc_trace_entry(ktep); 4438 break; 4439 case XFS_CTRUNC5: 4440 qprintf("CTRUNC5:\n"); 4441 xfs_ctrunc_trace_entry(ktep); 4442 break; 4443 case XFS_CTRUNC6: 4444 qprintf("CTRUNC6:\n"); 4445 xfs_ctrunc_trace_entry(ktep); 4446 break; 4447 case XFS_BUNMAP: 4448 qprintf("BUNMAP:\n"); 4449 xfs_bunmap_trace_entry(ktep); 4450 break; 4451 case XFS_INVAL_CACHED: 4452 qprintf("INVAL CACHED:\n"); 4453 xfs_inval_cached_trace_entry(ktep); 4454 break; 4455 case XFS_DIORD_ENTER: 4456 qprintf("DIORD ENTER:\n"); 4457 xfs_rw_enter_trace_entry(ktep); 4458 break; 4459 case XFS_DIOWR_ENTER: 4460 qprintf("DIOWR ENTER:\n"); 4461 xfs_rw_enter_trace_entry(ktep); 4462 break; 4463 case XFS_WRITEPAGE_ENTER: 4464 qprintf("PAGE WRITE:\n"); 4465 xfs_page_trace_entry(ktep); 4466 break; 4467 case XFS_RELEASEPAGE_ENTER: 4468 qprintf("PAGE RELEASE:\n"); 4469 xfs_page_trace_entry(ktep); 4470 break; 4471 case XFS_INVALIDPAGE_ENTER: 4472 qprintf("PAGE INVALIDATE:\n"); 4473 xfs_page_trace_entry(ktep); 4474 break; 4475 case XFS_IOMAP_ALLOC_ENTER: 4476 qprintf("ALLOC ENTER:\n"); 4477 xfs_iomap_enter_trace_entry(ktep); 4478 break; 4479 case XFS_IOMAP_ALLOC_MAP: 4480 qprintf("ALLOC MAP:\n"); 4481 xfs_iomap_map_trace_entry(ktep); 4482 break; 4483 case XFS_IOMAP_UNWRITTEN: 4484 qprintf("UNWRITTEN:\n"); 4485 xfs_iomap_enter_trace_entry(ktep); 4486 break; 4487 4488 default: 4489 qprintf("UNKNOWN RW TRACE\n"); 4490 return 0; 4491 } 4492 4493 return 1; 4494} 4495#endif 4496 4497/* 4498 * Print xfs extent records for a fork. 4499 */ 4500static void 4501xfs_xexlist_fork(xfs_inode_t *ip, int whichfork) 4502{ 4503 int nextents, i; 4504 xfs_ifork_t *ifp; 4505 xfs_bmbt_irec_t irec; 4506 4507 ifp = XFS_IFORK_PTR(ip, whichfork); 4508 if (ifp->if_flags & XFS_IFEXTENTS) { 4509 nextents = ifp->if_bytes / (uint)sizeof(xfs_bmbt_rec_t); 4510 kdb_printf("inode 0x%p %cf extents 0x%p nextents 0x%x\n", 4511 ip, "da"[whichfork], xfs_iext_get_ext(ifp, 0), 4512 nextents); 4513 for (i = 0; i < nextents; i++) { 4514 xfs_bmbt_get_all(xfs_iext_get_ext(ifp, i), &irec); 4515 kdb_printf( 4516 "%d: startoff %Ld startblock %s blockcount %Ld flag %d\n", 4517 i, irec.br_startoff, 4518 xfs_fmtfsblock(irec.br_startblock, ip->i_mount), 4519 irec.br_blockcount, irec.br_state); 4520 } 4521 } 4522} 4523 4524static void 4525xfs_xnode_fork(char *name, xfs_ifork_t *f) 4526{ 4527 static char *tab_flags[] = { 4528 "inline", /* XFS_IFINLINE */ 4529 "extents", /* XFS_IFEXTENTS */ 4530 "broot", /* XFS_IFBROOT */ 4531 NULL 4532 }; 4533 int *p; 4534 4535 kdb_printf("%s fork", name); 4536 if (f == NULL) { 4537 kdb_printf(" empty\n"); 4538 return; 4539 } else 4540 kdb_printf("\n"); 4541 kdb_printf(" bytes %s ", xfs_fmtsize(f->if_bytes)); 4542 kdb_printf("real_bytes %s lastex 0x%x u1:%s 0x%p\n", 4543 xfs_fmtsize(f->if_real_bytes), f->if_lastex, 4544 f->if_flags & XFS_IFINLINE ? "data" : "extents", 4545 f->if_flags & XFS_IFINLINE ? 4546 f->if_u1.if_data : 4547 (char *)f->if_u1.if_extents); 4548 kdb_printf(" broot 0x%p broot_bytes %s ext_max %d ", 4549 f->if_broot, xfs_fmtsize(f->if_broot_bytes), f->if_ext_max); 4550 printflags(f->if_flags, tab_flags, "flags"); 4551 kdb_printf("\n"); 4552 kdb_printf(" u2"); 4553 for (p = (int *)&f->if_u2; 4554 p < (int *)((char *)&f->if_u2 + XFS_INLINE_DATA); 4555 p++) 4556 kdb_printf(" 0x%x", *p); 4557 kdb_printf("\n"); 4558} 4559 4560/* 4561 * Command-level xfs-idbg functions. 4562 */ 4563 4564/* 4565 * Print xfs allocation group freespace header. 4566 */ 4567static void 4568xfsidbg_xagf(xfs_agf_t *agf) 4569{ 4570 kdb_printf("magicnum 0x%x versionnum 0x%x seqno 0x%x length 0x%x\n", 4571 be32_to_cpu(agf->agf_magicnum), 4572 be32_to_cpu(agf->agf_versionnum), 4573 be32_to_cpu(agf->agf_seqno), 4574 be32_to_cpu(agf->agf_length)); 4575 kdb_printf("roots b 0x%x c 0x%x levels b %d c %d\n", 4576 be32_to_cpu(agf->agf_roots[XFS_BTNUM_BNO]), 4577 be32_to_cpu(agf->agf_roots[XFS_BTNUM_CNT]), 4578 be32_to_cpu(agf->agf_levels[XFS_BTNUM_BNO]), 4579 be32_to_cpu(agf->agf_levels[XFS_BTNUM_CNT])); 4580 kdb_printf("flfirst %d fllast %d flcount %d freeblks %d longest %d\n", 4581 be32_to_cpu(agf->agf_flfirst), 4582 be32_to_cpu(agf->agf_fllast), 4583 be32_to_cpu(agf->agf_flcount), 4584 be32_to_cpu(agf->agf_freeblks), 4585 be32_to_cpu(agf->agf_longest)); 4586} 4587 4588/* 4589 * Print xfs allocation group inode header. 4590 */ 4591static void 4592xfsidbg_xagi(xfs_agi_t *agi) 4593{ 4594 int i; 4595 int j; 4596 4597 kdb_printf("magicnum 0x%x versionnum 0x%x seqno 0x%x length 0x%x\n", 4598 be32_to_cpu(agi->agi_magicnum), 4599 be32_to_cpu(agi->agi_versionnum), 4600 be32_to_cpu(agi->agi_seqno), 4601 be32_to_cpu(agi->agi_length)); 4602 kdb_printf("count 0x%x root 0x%x level 0x%x\n", 4603 be32_to_cpu(agi->agi_count), 4604 be32_to_cpu(agi->agi_root), 4605 be32_to_cpu(agi->agi_level)); 4606 kdb_printf("freecount 0x%x newino 0x%x dirino 0x%x\n", 4607 be32_to_cpu(agi->agi_freecount), 4608 be32_to_cpu(agi->agi_newino), 4609 be32_to_cpu(agi->agi_dirino)); 4610 4611 kdb_printf("unlinked buckets\n"); 4612 for (i = 0; i < XFS_AGI_UNLINKED_BUCKETS; i++) { 4613 for (j = 0; j < 4; j++, i++) { 4614 kdb_printf("0x%08x ", 4615 be32_to_cpu(agi->agi_unlinked[i])); 4616 } 4617 kdb_printf("\n"); 4618 } 4619} 4620 4621#ifdef XFS_ALLOC_TRACE 4622/* 4623 * Print out the last "count" entries in the allocation trace buffer. 4624 */ 4625static void 4626xfsidbg_xalatrace(int count) 4627{ 4628 ktrace_entry_t *ktep; 4629 ktrace_snap_t kts; 4630 int nentries; 4631 int skip_entries; 4632 4633 if (xfs_alloc_trace_buf == NULL) { 4634 qprintf("The xfs alloc trace buffer is not initialized\n"); 4635 return; 4636 } 4637 nentries = ktrace_nentries(xfs_alloc_trace_buf); 4638 if (count == -1) { 4639 count = nentries; 4640 } 4641 if ((count <= 0) || (count > nentries)) { 4642 qprintf("Invalid count. There are %d entries.\n", nentries); 4643 return; 4644 } 4645 4646 ktep = ktrace_first(xfs_alloc_trace_buf, &kts); 4647 if (count != nentries) { 4648 /* 4649 * Skip the total minus the number to look at minus one 4650 * for the entry returned by ktrace_first(). 4651 */ 4652 skip_entries = nentries - count - 1; 4653 ktep = ktrace_skip(xfs_alloc_trace_buf, skip_entries, &kts); 4654 if (ktep == NULL) { 4655 qprintf("Skipped them all\n"); 4656 return; 4657 } 4658 } 4659 while (ktep != NULL) { 4660 if (xfs_alloc_trace_entry(ktep)) 4661 qprintf("\n"); 4662 ktep = ktrace_next(xfs_alloc_trace_buf, &kts); 4663 } 4664} 4665 4666/* 4667 * Print out all the entries in the alloc trace buf corresponding 4668 * to the given block number. 4669 */ 4670static void 4671xfsidbg_xalbtrace(xfs_agblock_t bno) 4672{ 4673 ktrace_entry_t *ktep; 4674 ktrace_snap_t kts; 4675 4676 if (xfs_alloc_trace_buf == NULL) { 4677 qprintf("The xfs alloc trace buffer is not initialized\n"); 4678 return; 4679 } 4680 4681 ktep = ktrace_first(xfs_alloc_trace_buf, &kts); 4682 while (ktep != NULL) { 4683 switch ((__psint_t)ktep->val[0]) { 4684 case XFS_ALLOC_KTRACE_ALLOC: 4685 case XFS_ALLOC_KTRACE_FREE: 4686 if (bno >= (xfs_agblock_t)((__psint_t)ktep->val[5]) && 4687 bno < (xfs_agblock_t)((__psint_t)ktep->val[5]) + 4688 (xfs_extlen_t)((__psint_t)ktep->val[13])) { 4689 (void)xfs_alloc_trace_entry(ktep); 4690 qprintf("\n"); 4691 } 4692 break; 4693 } 4694 ktep = ktrace_next(xfs_alloc_trace_buf, &kts); 4695 } 4696} 4697 4698/* 4699 * Print out all the entries in the alloc trace buf corresponding 4700 * to the given allocation group. 4701 */ 4702static void 4703xfsidbg_xalgtrace(xfs_agnumber_t agno) 4704{ 4705 ktrace_entry_t *ktep; 4706 ktrace_snap_t kts; 4707 4708 if (xfs_alloc_trace_buf == NULL) { 4709 qprintf("The xfs alloc trace buffer is not initialized\n"); 4710 return; 4711 } 4712 4713 ktep = ktrace_first(xfs_alloc_trace_buf, &kts); 4714 while (ktep != NULL) { 4715 if ( (__psint_t)ktep->val[0] && 4716 ((xfs_agnumber_t)((__psint_t)ktep->val[4])) == agno ) { 4717 (void)xfs_alloc_trace_entry(ktep); 4718 qprintf("\n"); 4719 } 4720 ktep = ktrace_next(xfs_alloc_trace_buf, &kts); 4721 } 4722} 4723#endif 4724 4725/* 4726 * Print an allocation argument structure for XFS. 4727 */ 4728static void 4729xfsidbg_xalloc(xfs_alloc_arg_t *args) 4730{ 4731 kdb_printf("tp 0x%p mp 0x%p agbp 0x%p pag 0x%p fsbno %s\n", 4732 args->tp, args->mp, args->agbp, args->pag, 4733 xfs_fmtfsblock(args->fsbno, args->mp)); 4734 kdb_printf("agno 0x%x agbno 0x%x minlen 0x%x maxlen 0x%x mod 0x%x\n", 4735 args->agno, args->agbno, args->minlen, args->maxlen, args->mod); 4736 kdb_printf("prod 0x%x minleft 0x%x total 0x%x alignment 0x%x\n", 4737 args->prod, args->minleft, args->total, args->alignment); 4738 kdb_printf("minalignslop 0x%x len 0x%x type %s otype %s wasdel %d\n", 4739 args->minalignslop, args->len, xfs_alloctype[args->type], 4740 xfs_alloctype[args->otype], args->wasdel); 4741 kdb_printf("wasfromfl %d isfl %d userdata %d\n", 4742 args->wasfromfl, args->isfl, args->userdata); 4743} 4744 4745#ifdef XFS_ALLOC_TRACE 4746/* 4747 * Print out all the entries in the alloc trace buf corresponding 4748 * to the given mount point. 4749 */ 4750static void 4751xfsidbg_xalmtrace(xfs_mount_t *mp) 4752{ 4753 ktrace_entry_t *ktep; 4754 ktrace_snap_t kts; 4755 4756 if (xfs_alloc_trace_buf == NULL) { 4757 kdb_printf("The xfs alloc trace buffer is not initialized\n"); 4758 return; 4759 } 4760 4761 ktep = ktrace_first(xfs_alloc_trace_buf, &kts); 4762 while (ktep != NULL) { 4763 if ((__psint_t)ktep->val[0] && 4764 (xfs_mount_t *)ktep->val[3] == mp) { 4765 (void)xfs_alloc_trace_entry(ktep); 4766 kdb_printf("\n"); 4767 } 4768 ktep = ktrace_next(xfs_alloc_trace_buf, &kts); 4769 } 4770} 4771 4772/* 4773 * Print out all the entries in the alloc trace buf corresponding 4774 * to the given entry type. 4775 */ 4776static void 4777xfsidbg_xalttrace(int tag) 4778{ 4779 ktrace_entry_t *ktep; 4780 ktrace_snap_t kts; 4781 4782 if (xfs_alloc_trace_buf == NULL) { 4783 qprintf("The xfs alloc trace buffer is not initialized\n"); 4784 return; 4785 } 4786 4787 ktep = ktrace_first(xfs_alloc_trace_buf, &kts); 4788 while (ktep != NULL) { 4789 if ((__psint_t)ktep->val[0] && 4790 ((long)ktep->val[0] & 0xffffL) == (long)tag) { 4791 (void)xfs_alloc_trace_entry(ktep); 4792 qprintf("\n"); 4793 } 4794 ktep = ktrace_next(xfs_alloc_trace_buf, &kts); 4795 } 4796} 4797#endif 4798 4799static int xargument = 0; 4800 4801/* 4802 * Set xtra argument, used by xchksum. 4803 */ 4804static void 4805xfsidbg_xarg(int xarg) 4806{ 4807 if (xarg == -1) 4808 qprintf("xargument: %d\n", xargument); 4809 else 4810 xargument = xarg; 4811} /* xfsidbg_xarg */ 4812 4813/* 4814 * Print an attr_list() context structure. 4815 */ 4816static void 4817xfsidbg_xattrcontext(xfs_attr_list_context_t *context) 4818{ 4819 static char *attr_arg_flags[] = { 4820 "DONTFOLLOW", /* 0x0001 */ 4821 "?", /* 0x0002 */ 4822 "?", /* 0x0004 */ 4823 "?", /* 0x0008 */ 4824 "CREATE", /* 0x0010 */ 4825 "?", /* 0x0020 */ 4826 "?", /* 0x0040 */ 4827 "?", /* 0x0080 */ 4828 "?", /* 0x0100 */ 4829 "?", /* 0x0200 */ 4830 "?", /* 0x0400 */ 4831 "?", /* 0x0800 */ 4832 "KERNOTIME", /* 0x1000 */ 4833 NULL 4834 }; 4835 4836 kdb_printf("dp 0x%p, dupcnt %d, resynch %d", 4837 context->dp, context->dupcnt, context->resynch); 4838 printflags((__psunsigned_t)context->flags, attr_arg_flags, ", flags"); 4839 kdb_printf("\ncursor h/b/o 0x%x/0x%x/%d -- p/p/i 0x%x/0x%x/0x%x\n", 4840 context->cursor->hashval, context->cursor->blkno, 4841 context->cursor->offset, context->cursor->pad1, 4842 context->cursor->pad2, context->cursor->initted); 4843 kdb_printf("alist 0x%p, bufsize 0x%x, count %d, firstu 0x%x\n", 4844 context->alist, context->bufsize, context->count, 4845 context->firstu); 4846} 4847 4848/* 4849 * Print attribute leaf block. 4850 */ 4851static void 4852xfsidbg_xattrleaf(xfs_attr_leafblock_t *leaf) 4853{ 4854 xfs_attr_leaf_hdr_t *h; 4855 xfs_da_blkinfo_t *i; 4856 xfs_attr_leaf_map_t *m; 4857 xfs_attr_leaf_entry_t *e; 4858 xfs_attr_leaf_name_local_t *l; 4859 xfs_attr_leaf_name_remote_t *r; 4860 int j, k; 4861 4862 h = &leaf->hdr; 4863 i = &h->info; 4864 kdb_printf("hdr info forw 0x%x back 0x%x magic 0x%x\n", 4865 i->forw, i->back, i->magic); 4866 kdb_printf("hdr count %d usedbytes %d firstused %d holes %d\n", 4867 INT_GET(h->count, ARCH_CONVERT), 4868 INT_GET(h->usedbytes, ARCH_CONVERT), 4869 INT_GET(h->firstused, ARCH_CONVERT), h->holes); 4870 for (j = 0, m = h->freemap; j < XFS_ATTR_LEAF_MAPSIZE; j++, m++) { 4871 kdb_printf("hdr freemap %d base %d size %d\n", 4872 j, INT_GET(m->base, ARCH_CONVERT), 4873 INT_GET(m->size, ARCH_CONVERT)); 4874 } 4875 for (j = 0, e = leaf->entries; j < INT_GET(h->count, ARCH_CONVERT); j++, e++) { 4876 kdb_printf("[%2d] hash 0x%x nameidx %d flags 0x%x", 4877 j, INT_GET(e->hashval, ARCH_CONVERT), 4878 INT_GET(e->nameidx, ARCH_CONVERT), e->flags); 4879 if (e->flags & XFS_ATTR_LOCAL) 4880 kdb_printf("LOCAL "); 4881 if (e->flags & XFS_ATTR_ROOT) 4882 kdb_printf("ROOT "); 4883 if (e->flags & XFS_ATTR_SECURE) 4884 kdb_printf("SECURE "); 4885 if (e->flags & XFS_ATTR_INCOMPLETE) 4886 kdb_printf("INCOMPLETE "); 4887 k = ~(XFS_ATTR_LOCAL | XFS_ATTR_ROOT | 4888 XFS_ATTR_SECURE | XFS_ATTR_INCOMPLETE); 4889 if ((e->flags & k) != 0) 4890 kdb_printf("0x%x", e->flags & k); 4891 kdb_printf(">\n name \""); 4892 if (e->flags & XFS_ATTR_LOCAL) { 4893 l = XFS_ATTR_LEAF_NAME_LOCAL(leaf, j); 4894 for (k = 0; k < l->namelen; k++) 4895 kdb_printf("%c", l->nameval[k]); 4896 kdb_printf("\"(%d) value \"", l->namelen); 4897 for (k = 0; (k < INT_GET(l->valuelen, ARCH_CONVERT)) && (k < 32); k++) 4898 kdb_printf("%c", l->nameval[l->namelen + k]); 4899 if (k == 32) 4900 kdb_printf("..."); 4901 kdb_printf("\"(%d)\n", 4902 INT_GET(l->valuelen, ARCH_CONVERT)); 4903 } else { 4904 r = XFS_ATTR_LEAF_NAME_REMOTE(leaf, j); 4905 for (k = 0; k < r->namelen; k++) 4906 kdb_printf("%c", r->name[k]); 4907 kdb_printf("\"(%d) value blk 0x%x len %d\n", 4908 r->namelen, 4909 INT_GET(r->valueblk, ARCH_CONVERT), 4910 INT_GET(r->valuelen, ARCH_CONVERT)); 4911 } 4912 } 4913} 4914 4915/* 4916 * Print a shortform attribute list. 4917 */ 4918static void 4919xfsidbg_xattrsf(xfs_attr_shortform_t *s) 4920{ 4921 xfs_attr_sf_hdr_t *sfh; 4922 xfs_attr_sf_entry_t *sfe; 4923 int i, j; 4924 4925 sfh = &s->hdr; 4926 kdb_printf("hdr count %d\n", INT_GET(sfh->count, ARCH_CONVERT)); 4927 for (i = 0, sfe = s->list; i < INT_GET(sfh->count, ARCH_CONVERT); i++) { 4928 kdb_printf("entry %d namelen %d name \"", i, sfe->namelen); 4929 for (j = 0; j < sfe->namelen; j++) 4930 kdb_printf("%c", sfe->nameval[j]); 4931 kdb_printf("\" valuelen %d value \"", INT_GET(sfe->valuelen, ARCH_CONVERT)); 4932 for (j = 0; (j < INT_GET(sfe->valuelen, ARCH_CONVERT)) && (j < 32); j++) 4933 kdb_printf("%c", sfe->nameval[sfe->namelen + j]); 4934 if (j == 32) 4935 kdb_printf("..."); 4936 kdb_printf("\"\n"); 4937 sfe = XFS_ATTR_SF_NEXTENTRY(sfe); 4938 } 4939} 4940 4941#ifdef XFS_ATTR_TRACE 4942/* 4943 * Print out the last "count" entries in the attribute trace buffer. 4944 */ 4945static void 4946xfsidbg_xattrtrace(int count) 4947{ 4948 ktrace_entry_t *ktep; 4949 ktrace_snap_t kts; 4950 int nentries; 4951 int skip_entries; 4952 4953 if (xfs_attr_trace_buf == NULL) { 4954 qprintf("The xfs attribute trace buffer is not initialized\n"); 4955 return; 4956 } 4957 nentries = ktrace_nentries(xfs_attr_trace_buf); 4958 if (count == -1) { 4959 count = nentries; 4960 } 4961 if ((count <= 0) || (count > nentries)) { 4962 qprintf("Invalid count. There are %d entries.\n", nentries); 4963 return; 4964 } 4965 4966 ktep = ktrace_first(xfs_attr_trace_buf, &kts); 4967 if (count != nentries) { 4968 /* 4969 * Skip the total minus the number to look at minus one 4970 * for the entry returned by ktrace_first(). 4971 */ 4972 skip_entries = nentries - count - 1; 4973 ktep = ktrace_skip(xfs_attr_trace_buf, skip_entries, &kts); 4974 if (ktep == NULL) { 4975 qprintf("Skipped them all\n"); 4976 return; 4977 } 4978 } 4979 while (ktep != NULL) { 4980 xfs_attr_trace_entry(ktep); 4981 ktep = ktrace_next(xfs_attr_trace_buf, &kts); 4982 } 4983} 4984#endif 4985 4986/* 4987 * Print xfs bmap internal record 4988 */ 4989static void 4990xfsidbg_xbirec(xfs_bmbt_irec_t *r) 4991{ 4992 kdb_printf( 4993 "startoff %Ld startblock %Lx blockcount %Ld state %Ld\n", 4994 (__uint64_t)r->br_startoff, 4995 (__uint64_t)r->br_startblock, 4996 (__uint64_t)r->br_blockcount, 4997 (__uint64_t)r->br_state); 4998} 4999 5000#ifdef XFS_BLI_TRACE 5001/* 5002 * Print out the buf log item trace for the given buf log item. 5003 */ 5004static void 5005xfsidbg_xblitrace(xfs_buf_log_item_t *bip) 5006{ 5007 ktrace_entry_t *ktep; 5008 ktrace_snap_t kts; 5009 uint64_t flags; 5010 static char *xbli_flags[] = { 5011 "hold", /* 0x01 */ 5012 "dirty", /* 0x02 */ 5013 "stale", /* 0x04 */ 5014 "logged", /* 0x08 */ 5015 NULL 5016 }; 5017 static char *xli_flags[] = { 5018 "in ail", /* 0x1 */ 5019 NULL 5020 }; 5021 5022 if (bip->bli_trace == NULL) { 5023 qprintf("The bli trace buffer is not initialized\n"); 5024 return; 5025 } 5026 5027 ktep = ktrace_first(bip->bli_trace, &kts); 5028 while (ktep != NULL) { 5029 qprintf("%s bp 0x%p flags ", 5030 (char *)ktep->val[0], ktep->val[1]); 5031 printflags((__psint_t)(ktep->val[2]), xbli_flags, "xbli"); 5032 qprintf("\n"); 5033 qprintf("recur %ld refcount %ld blkno 0x%lx bcount 0x%lx\n", 5034 (long)ktep->val[3], (long)ktep->val[4], 5035 (unsigned long)ktep->val[5], 5036 (unsigned long)ktep->val[6]); 5037 flags = (((uint64_t)(unsigned long)ktep->val[7] << 32) & 5038 0xFFFFFFFF00000000ULL) | 5039 (((uint64_t)(unsigned long)ktep->val[8]) & 5040 0x00000000FFFFFFFFULL); 5041 qprintf("bp flags "); 5042 printflags(flags, bp_flag_vals, NULL); 5043 qprintf("\n"); 5044 qprintf("fspriv 0x%p fspriv2 0x%p pincount %ld iodone 0x%p\n", 5045 ktep->val[9], ktep->val[10], 5046 (long)ktep->val[11], ktep->val[12]); 5047 qprintf("lockval %ld lid 0x%lx log item flags ", 5048 (long)ktep->val[13], (unsigned long)ktep->val[14]); 5049 printflags((__psint_t)(ktep->val[15]), xli_flags, "xli"); 5050 qprintf("\n"); 5051 5052 ktep = ktrace_next(bip->bli_trace, &kts); 5053 } 5054} 5055#endif 5056 5057/* 5058 * Print a bmap alloc argument structure for XFS. 5059 */ 5060static void 5061xfsidbg_xbmalla(xfs_bmalloca_t *a) 5062{ 5063 kdb_printf("tp 0x%p ip 0x%p eof %d prevp 0x%p\n", 5064 a->tp, a->ip, a->eof, a->prevp); 5065 kdb_printf("gotp 0x%p firstblock %s alen %d total %d\n", 5066 a->gotp, xfs_fmtfsblock(a->firstblock, a->ip->i_mount), 5067 a->alen, a->total); 5068 kdb_printf("off %s wasdel %d userdata %d minlen %d\n", 5069 xfs_fmtfsblock(a->off, a->ip->i_mount), a->wasdel, 5070 a->userdata, a->minlen); 5071 kdb_printf("minleft %d low %d rval %s aeof %d conv %d\n", 5072 a->minleft, a->low, xfs_fmtfsblock(a->rval, a->ip->i_mount), 5073 a->aeof, a->conv); 5074} 5075 5076#ifdef XFS_BMAP_TRACE 5077/* 5078 * Print out the last "count" entries in the bmap btree trace buffer. 5079 * The "a" is for "all" inodes. 5080 */ 5081static void 5082xfsidbg_xbmatrace(int count) 5083{ 5084 ktrace_entry_t *ktep; 5085 ktrace_snap_t kts; 5086 int nentries; 5087 int skip_entries; 5088 5089 if (xfs_bmbt_trace_buf == NULL) { 5090 qprintf("The xfs bmap btree trace buffer is not initialized\n"); return; 5091 } 5092 nentries = ktrace_nentries(xfs_bmbt_trace_buf); 5093 if (count == -1) { 5094 count = nentries; 5095 } 5096 if ((count <= 0) || (count > nentries)) { 5097 qprintf("Invalid count. There are %d entries.\n", nentries); 5098 return; 5099 } 5100 5101 ktep = ktrace_first(xfs_bmbt_trace_buf, &kts); 5102 if (count != nentries) { 5103 /* 5104 * Skip the total minus the number to look at minus one 5105 * for the entry returned by ktrace_first(). 5106 */ 5107 skip_entries = nentries - count - 1; 5108 ktep = ktrace_skip(xfs_bmbt_trace_buf, skip_entries, &kts); 5109 if (ktep == NULL) { 5110 qprintf("Skipped them all\n"); 5111 return; 5112 } 5113 } 5114 while (ktep != NULL) { 5115 if (xfs_bmbt_trace_entry(ktep)) 5116 qprintf("\n"); 5117 ktep = ktrace_next(xfs_bmbt_trace_buf, &kts); 5118 } 5119} 5120 5121/* 5122 * Print out the bmap btree trace buffer attached to the given inode. 5123 */ 5124static void 5125xfsidbg_xbmitrace(xfs_inode_t *ip) 5126{ 5127 ktrace_entry_t *ktep; 5128 ktrace_snap_t kts; 5129 5130 if (ip->i_btrace == NULL) { 5131 qprintf("The inode trace buffer is not initialized\n"); 5132 return; 5133 } 5134 5135 ktep = ktrace_first(ip->i_btrace, &kts); 5136 while (ktep != NULL) { 5137 if (xfs_bmbt_trace_entry(ktep)) 5138 qprintf("\n"); 5139 ktep = ktrace_next(ip->i_btrace, &kts); 5140 } 5141} 5142 5143/* 5144 * Print out all the entries in the bmap btree trace buf corresponding 5145 * to the given inode. The "s" is for "single" inode. 5146 */ 5147static void 5148xfsidbg_xbmstrace(xfs_inode_t *ip) 5149{ 5150 ktrace_entry_t *ktep; 5151 ktrace_snap_t kts; 5152 5153 if (xfs_bmbt_trace_buf == NULL) { 5154 qprintf("The xfs bmap btree trace buffer is not initialized\n"); return; 5155 } 5156 5157 ktep = ktrace_first(xfs_bmbt_trace_buf, &kts); 5158 while (ktep != NULL) { 5159 if ((xfs_inode_t *)(ktep->val[2]) == ip) { 5160 if (xfs_bmbt_trace_entry(ktep)) 5161 qprintf("\n"); 5162 } 5163 ktep = ktrace_next(xfs_bmbt_trace_buf, &kts); 5164 } 5165} 5166#endif 5167 5168/* 5169 * Print xfs bmap record 5170 */ 5171static void 5172xfsidbg_xbrec(xfs_bmbt_rec_64_t *r) 5173{ 5174 xfs_bmbt_irec_t irec; 5175 5176 xfs_bmbt_get_all((xfs_bmbt_rec_t *)r, &irec); 5177 kdb_printf("startoff %Ld startblock %Lx blockcount %Ld flag %d\n", 5178 irec.br_startoff, (__uint64_t)irec.br_startblock, 5179 irec.br_blockcount, irec.br_state); 5180} 5181 5182/* 5183 * Print an xfs in-inode bmap btree root (data fork). 5184 */ 5185static void 5186xfsidbg_xbroot(xfs_inode_t *ip) 5187{ 5188 xfs_broot(ip, &ip->i_df); 5189} 5190 5191/* 5192 * Print an xfs in-inode bmap btree root (attribute fork). 5193 */ 5194static void 5195xfsidbg_xbroota(xfs_inode_t *ip) 5196{ 5197 if (ip->i_afp) 5198 xfs_broot(ip, ip->i_afp); 5199} 5200 5201/* 5202 * Print xfs btree cursor. 5203 */ 5204static void 5205xfsidbg_xbtcur(xfs_btree_cur_t *c) 5206{ 5207 int l; 5208 5209 kdb_printf("tp 0x%p mp 0x%p\n", 5210 c->bc_tp, 5211 c->bc_mp); 5212 if (c->bc_btnum == XFS_BTNUM_BMAP) { 5213 kdb_printf("rec.b "); 5214 xfsidbg_xbirec(&c->bc_rec.b); 5215 } else if (c->bc_btnum == XFS_BTNUM_INO) { 5216 kdb_printf("rec.i startino 0x%x freecount 0x%x free %Lx\n", 5217 c->bc_rec.i.ir_startino, c->bc_rec.i.ir_freecount, 5218 c->bc_rec.i.ir_free); 5219 } else { 5220 kdb_printf("rec.a startblock 0x%x blockcount 0x%x\n", 5221 c->bc_rec.a.ar_startblock, 5222 c->bc_rec.a.ar_blockcount); 5223 } 5224 kdb_printf("bufs"); 5225 for (l = 0; l < c->bc_nlevels; l++) 5226 kdb_printf(" 0x%p", c->bc_bufs[l]); 5227 kdb_printf("\n"); 5228 kdb_printf("ptrs"); 5229 for (l = 0; l < c->bc_nlevels; l++) 5230 kdb_printf(" 0x%x", c->bc_ptrs[l]); 5231 kdb_printf(" ra"); 5232 for (l = 0; l < c->bc_nlevels; l++) 5233 kdb_printf(" %d", c->bc_ra[l]); 5234 kdb_printf("\n"); 5235 kdb_printf("nlevels %d btnum %s blocklog %d\n", 5236 c->bc_nlevels, 5237 c->bc_btnum == XFS_BTNUM_BNO ? "bno" : 5238 (c->bc_btnum == XFS_BTNUM_CNT ? "cnt" : 5239 (c->bc_btnum == XFS_BTNUM_BMAP ? "bmap" : "ino")), 5240 c->bc_blocklog); 5241 if (c->bc_btnum == XFS_BTNUM_BMAP) { 5242 kdb_printf("private forksize 0x%x whichfork %d ip 0x%p flags %d\n", 5243 c->bc_private.b.forksize, 5244 c->bc_private.b.whichfork, 5245 c->bc_private.b.ip, 5246 c->bc_private.b.flags); 5247 kdb_printf("private firstblock %s flist 0x%p allocated 0x%x\n", 5248 xfs_fmtfsblock(c->bc_private.b.firstblock, c->bc_mp), 5249 c->bc_private.b.flist, 5250 c->bc_private.b.allocated); 5251 } else if (c->bc_btnum == XFS_BTNUM_INO) { 5252 kdb_printf("private agbp 0x%p agno 0x%x\n", 5253 c->bc_private.i.agbp, 5254 c->bc_private.i.agno); 5255 } else { 5256 kdb_printf("private agbp 0x%p agno 0x%x\n", 5257 c->bc_private.a.agbp, 5258 c->bc_private.a.agno); 5259 } 5260} 5261 5262/* 5263 * Figure out what kind of xfs block the buffer contains, 5264 * and invoke a print routine. 5265 */ 5266static void 5267xfsidbg_xbuf(xfs_buf_t *bp) 5268{ 5269 xfsidbg_xbuf_real(bp, 0); 5270} 5271 5272/* 5273 * Figure out what kind of xfs block the buffer contains, 5274 * and invoke a print routine (if asked to). 5275 */ 5276static void 5277xfsidbg_xbuf_real(xfs_buf_t *bp, int summary) 5278{ 5279 void *d; 5280 xfs_agf_t *agf; 5281 xfs_agi_t *agi; 5282 xfs_sb_t *sb; 5283 xfs_alloc_block_t *bta; 5284 xfs_bmbt_block_t *btb; 5285 xfs_inobt_block_t *bti; 5286 xfs_attr_leafblock_t *aleaf; 5287 xfs_dir_leafblock_t *dleaf; 5288 xfs_da_intnode_t *node; 5289 xfs_dinode_t *di; 5290 xfs_disk_dquot_t *dqb; 5291 xfs_dir2_block_t *d2block; 5292 xfs_dir2_data_t *d2data; 5293 xfs_dir2_leaf_t *d2leaf; 5294 xfs_dir2_free_t *d2free; 5295 5296 d = XFS_BUF_PTR(bp); 5297 if (be32_to_cpu((agf = d)->agf_magicnum) == XFS_AGF_MAGIC) { 5298 if (summary) { 5299 kdb_printf("freespace hdr for AG %d (at 0x%p)\n", 5300 be32_to_cpu(agf->agf_seqno), agf); 5301 } else { 5302 kdb_printf("buf 0x%p agf 0x%p\n", bp, agf); 5303 xfsidbg_xagf(agf); 5304 } 5305 } else if (be32_to_cpu((agi = d)->agi_magicnum) == XFS_AGI_MAGIC) { 5306 if (summary) { 5307 kdb_printf("Inode hdr for AG %d (at 0x%p)\n", 5308 be32_to_cpu(agi->agi_seqno), agi); 5309 } else { 5310 kdb_printf("buf 0x%p agi 0x%p\n", bp, agi); 5311 xfsidbg_xagi(agi); 5312 } 5313 } else if (be32_to_cpu((bta = d)->bb_magic) == XFS_ABTB_MAGIC) { 5314 if (summary) { 5315 kdb_printf("Alloc BNO Btree blk, level %d (at 0x%p)\n", 5316 be16_to_cpu(bta->bb_level), bta); 5317 } else { 5318 kdb_printf("buf 0x%p abtbno 0x%p\n", bp, bta); 5319 xfs_btalloc(bta, XFS_BUF_COUNT(bp)); 5320 } 5321 } else if (be32_to_cpu((bta = d)->bb_magic) == XFS_ABTC_MAGIC) { 5322 if (summary) { 5323 kdb_printf("Alloc COUNT Btree blk, level %d (at 0x%p)\n", 5324 be16_to_cpu(bta->bb_level), bta); 5325 } else { 5326 kdb_printf("buf 0x%p abtcnt 0x%p\n", bp, bta); 5327 xfs_btalloc(bta, XFS_BUF_COUNT(bp)); 5328 } 5329 } else if (be32_to_cpu((btb = d)->bb_magic) == XFS_BMAP_MAGIC) { 5330 if (summary) { 5331 kdb_printf("Bmap Btree blk, level %d (at 0x%p)\n", 5332 be16_to_cpu(btb->bb_level), btb); 5333 } else { 5334 kdb_printf("buf 0x%p bmapbt 0x%p\n", bp, btb); 5335 xfs_btbmap(btb, XFS_BUF_COUNT(bp)); 5336 } 5337 } else if (be32_to_cpu((bti = d)->bb_magic) == XFS_IBT_MAGIC) { 5338 if (summary) { 5339 kdb_printf("Inode Btree blk, level %d (at 0x%p)\n", 5340 be16_to_cpu(bti->bb_level), bti); 5341 } else { 5342 kdb_printf("buf 0x%p inobt 0x%p\n", bp, bti); 5343 xfs_btino(bti, XFS_BUF_COUNT(bp)); 5344 } 5345 } else if (INT_GET((aleaf = d)->hdr.info.magic, ARCH_CONVERT) == XFS_ATTR_LEAF_MAGIC) { 5346 if (summary) { 5347 kdb_printf("Attr Leaf, 1st hash 0x%x (at 0x%p)\n", 5348 INT_GET(aleaf->entries[0].hashval, ARCH_CONVERT), aleaf); 5349 } else { 5350 kdb_printf("buf 0x%p attr leaf 0x%p\n", bp, aleaf); 5351 xfsidbg_xattrleaf(aleaf); 5352 } 5353 } else if (INT_GET((dleaf = d)->hdr.info.magic, ARCH_CONVERT) == XFS_DIR_LEAF_MAGIC) { 5354 if (summary) { 5355 kdb_printf("Dir Leaf, 1st hash 0x%x (at 0x%p)\n", 5356 dleaf->entries[0].hashval, dleaf); 5357 } else { 5358 kdb_printf("buf 0x%p dir leaf 0x%p\n", bp, dleaf); 5359 xfsidbg_xdirleaf(dleaf); 5360 } 5361 } else if (INT_GET((node = d)->hdr.info.magic, ARCH_CONVERT) == XFS_DA_NODE_MAGIC) { 5362 if (summary) { 5363 kdb_printf("Dir/Attr Node, level %d, 1st hash 0x%x (at 0x%p)\n", 5364 node->hdr.level, node->btree[0].hashval, node); 5365 } else { 5366 kdb_printf("buf 0x%p dir/attr node 0x%p\n", bp, node); 5367 xfsidbg_xdanode(node); 5368 } 5369 } else if (INT_GET((di = d)->di_core.di_magic, ARCH_CONVERT) == XFS_DINODE_MAGIC) { 5370 if (summary) { 5371 kdb_printf("Disk Inode (at 0x%p)\n", di); 5372 } else { 5373 kdb_printf("buf 0x%p dinode 0x%p\n", bp, di); 5374 xfs_inodebuf(bp); 5375 } 5376 } else if (INT_GET((sb = d)->sb_magicnum, ARCH_CONVERT) == XFS_SB_MAGIC) { 5377 if (summary) { 5378 kdb_printf("Superblock (at 0x%p)\n", sb); 5379 } else { 5380 kdb_printf("buf 0x%p sb 0x%p\n", bp, sb); 5381 /* SB in a buffer - we need to convert */ 5382 xfsidbg_xsb_convert(sb); 5383 } 5384 } else if ((dqb = d)->d_magic == cpu_to_be16(XFS_DQUOT_MAGIC)) { 5385#define XFSIDBG_DQTYPESTR(d) \ 5386 (((d)->d_flags & XFS_DQ_USER) ? "USR" : \ 5387 (((d)->d_flags & XFS_DQ_GROUP) ? "GRP" : \ 5388 (((d)->d_flags & XFS_DQ_PROJ) ? "PRJ" : "???"))) 5389 kdb_printf("Quota blk starting ID [%d], type %s at 0x%p\n", 5390 be32_to_cpu(dqb->d_id), XFSIDBG_DQTYPESTR(dqb), dqb); 5391 5392 } else if (INT_GET((d2block = d)->hdr.magic, ARCH_CONVERT) == XFS_DIR2_BLOCK_MAGIC) { 5393 if (summary) { 5394 kdb_printf("Dir2 block (at 0x%p)\n", d2block); 5395 } else { 5396 kdb_printf("buf 0x%p dir2 block 0x%p\n", bp, d2block); 5397 xfs_dir2data((void *)d2block, XFS_BUF_COUNT(bp)); 5398 } 5399 } else if (INT_GET((d2data = d)->hdr.magic, ARCH_CONVERT) == XFS_DIR2_DATA_MAGIC) { 5400 if (summary) { 5401 kdb_printf("Dir2 data (at 0x%p)\n", d2data); 5402 } else { 5403 kdb_printf("buf 0x%p dir2 data 0x%p\n", bp, d2data); 5404 xfs_dir2data((void *)d2data, XFS_BUF_COUNT(bp)); 5405 } 5406 } else if (INT_GET((d2leaf = d)->hdr.info.magic, ARCH_CONVERT) == XFS_DIR2_LEAF1_MAGIC) { 5407 if (summary) { 5408 kdb_printf("Dir2 leaf(1) (at 0x%p)\n", d2leaf); 5409 } else { 5410 kdb_printf("buf 0x%p dir2 leaf 0x%p\n", bp, d2leaf); 5411 xfs_dir2leaf(d2leaf, XFS_BUF_COUNT(bp)); 5412 } 5413 } else if (INT_GET(d2leaf->hdr.info.magic, ARCH_CONVERT) == XFS_DIR2_LEAFN_MAGIC) { 5414 if (summary) { 5415 kdb_printf("Dir2 leaf(n) (at 0x%p)\n", d2leaf); 5416 } else { 5417 kdb_printf("buf 0x%p dir2 leaf 0x%p\n", bp, d2leaf); 5418 xfs_dir2leaf(d2leaf, XFS_BUF_COUNT(bp)); 5419 } 5420 } else if (INT_GET((d2free = d)->hdr.magic, ARCH_CONVERT) == XFS_DIR2_FREE_MAGIC) { 5421 if (summary) { 5422 kdb_printf("Dir2 free (at 0x%p)\n", d2free); 5423 } else { 5424 kdb_printf("buf 0x%p dir2 free 0x%p\n", bp, d2free); 5425 xfsidbg_xdir2free(d2free); 5426 } 5427 } else { 5428 kdb_printf("buf 0x%p unknown 0x%p\n", bp, d); 5429 } 5430} 5431 5432#ifdef XFS_BMAP_TRACE 5433/* 5434 * Print out the last "count" entries in the bmap extent trace buffer. 5435 * The "a" is for "all" inodes. 5436 */ 5437static void 5438xfsidbg_xbxatrace(int count) 5439{ 5440 ktrace_entry_t *ktep; 5441 ktrace_snap_t kts; 5442 int nentries; 5443 int skip_entries; 5444 5445 if (xfs_bmap_trace_buf == NULL) { 5446 qprintf("The xfs bmap extent trace buffer is not initialized\n"); 5447 return; 5448 } 5449 nentries = ktrace_nentries(xfs_bmap_trace_buf); 5450 if (count == -1) { 5451 count = nentries; 5452 } 5453 if ((count <= 0) || (count > nentries)) { 5454 qprintf("Invalid count. There are %d entries.\n", nentries); 5455 return; 5456 } 5457 5458 ktep = ktrace_first(xfs_bmap_trace_buf, &kts); 5459 if (count != nentries) { 5460 /* 5461 * Skip the total minus the number to look at minus one 5462 * for the entry returned by ktrace_first(). 5463 */ 5464 skip_entries = nentries - count - 1; 5465 ktep = ktrace_skip(xfs_bmap_trace_buf, skip_entries, &kts); 5466 if (ktep == NULL) { 5467 qprintf("Skipped them all\n"); 5468 return; 5469 } 5470 } 5471 while (ktep != NULL) { 5472 if (xfs_bmap_trace_entry(ktep)) 5473 qprintf("\n"); 5474 ktep = ktrace_next(xfs_bmap_trace_buf, &kts); 5475 } 5476} 5477 5478/* 5479 * Print out the bmap extent trace buffer attached to the given inode. 5480 */ 5481static void 5482xfsidbg_xbxitrace(xfs_inode_t *ip) 5483{ 5484 ktrace_entry_t *ktep; 5485 ktrace_snap_t kts; 5486 if (ip->i_xtrace == NULL) { 5487 qprintf("The inode trace buffer is not initialized\n"); 5488 return; 5489 } 5490 5491 ktep = ktrace_first(ip->i_xtrace, &kts); 5492 while (ktep != NULL) { 5493 if (xfs_bmap_trace_entry(ktep)) 5494 qprintf("\n"); 5495 ktep = ktrace_next(ip->i_xtrace, &kts); 5496 } 5497} 5498 5499/* 5500 * Print out all the entries in the bmap extent trace buf corresponding 5501 * to the given inode. The "s" is for "single" inode. 5502 */ 5503static void 5504xfsidbg_xbxstrace(xfs_inode_t *ip) 5505{ 5506 ktrace_entry_t *ktep; 5507 ktrace_snap_t kts; 5508 5509 if (xfs_bmap_trace_buf == NULL) { 5510 qprintf("The xfs bmap extent trace buffer is not initialized\n"); 5511 return; 5512 } 5513 5514 ktep = ktrace_first(xfs_bmap_trace_buf, &kts); 5515 while (ktep != NULL) { 5516 if ((xfs_inode_t *)(ktep->val[3]) == ip) { 5517 if (xfs_bmap_trace_entry(ktep)) 5518 qprintf("\n"); 5519 } 5520 ktep = ktrace_next(xfs_bmap_trace_buf, &kts); 5521 } 5522} 5523#endif 5524 5525#ifdef XFS_ILOCK_TRACE 5526/* 5527 * Print out the ilock trace buffer attached to the given inode. 5528 */ 5529static void 5530xfsidbg_xilock_trace_entry(ktrace_entry_t *ktep) 5531{ 5532 static char *xiflags[] = { 5533 "IOLOCK_EXCL", 5534 "IOLOCK_SHAR", 5535 "ILOCK_EXCL", 5536 "ILOCK_SHAR", 5537 "IUNLK_NONOT", 5538 NULL 5539 }; 5540 5541 if ((__psint_t)ktep->val[0] && 5542 (__psint_t)ktep->val[7] == 0) { 5543 printflags((__psint_t)ktep->val[2], xiflags,"Flags "); 5544 if ((__psint_t)ktep->val[1] == 1) 5545 qprintf("LOCK\n"); 5546 else if ((__psint_t)ktep->val[1] == 2) 5547 qprintf("LOCK SHARED\n"); 5548 else if ((__psint_t)ktep->val[1] == 3) 5549 qprintf("UNLOCK\n"); 5550 qprintf("ip 0x%p %llx %ld\n", 5551 ktep->val[0], 5552 (unsigned long long)((xfs_inode_t*)ktep->val[0])->i_ino, 5553 (long)ktep->val[6]); 5554 qprintf("raddr 0x%p\n", ktep->val[3]); 5555 qprintf(" Pid %ld, cpu %ld\n", 5556 (long)ktep->val[5], 5557 (long)ktep->val[4]); 5558 qprintf("-----------------------\n"); 5559 5560 } else if ((__psint_t)ktep->val[7] == 1) { 5561 if ((__psint_t)ktep->val[1] == 1) 5562 qprintf("FlushLOCK "); 5563 else if ((__psint_t)ktep->val[1] == 2) 5564 qprintf("FlushTRYLOCK %ld ", 5565 (long)ktep->val[2]); 5566 else if ((__psint_t)ktep->val[1] == 3) 5567 qprintf("FlushUNLOCK "); 5568 else if ((__psint_t)ktep->val[1] == 4) 5569 qprintf("FlushInode 0x%p", 5570 ktep->val[2]); 5571 else if ((__psint_t)ktep->val[1] == 5) 5572 qprintf("FlushInodeInt "); 5573 else qprintf("FlushUNKNOWN "); 5574 qprintf("ip 0x%p ino %llx @ %ld\n", 5575 ktep->val[0], 5576 (unsigned long long)((xfs_inode_t*)ktep->val[0])->i_ino, 5577 (long)ktep->val[6]); 5578 qprintf("raddr 0x%p\n", ktep->val[3]); 5579 qprintf(" Pid %ld, cpu %ld\n", 5580 (long)ktep->val[5], 5581 (long)ktep->val[4]); 5582 qprintf("-----------------------\n"); 5583 } 5584} 5585 5586static void 5587xfsidbg_xilock_trace(xfs_inode_t *ip) 5588{ 5589 static char *xiflags[] = { 5590 "IOLOCK_EXCL", 5591 "IOLOCK_SHAR", 5592 "ILOCK_EXCL", 5593 "ILOCK_SHAR", 5594 "IUNLK_NONOT", 5595 NULL 5596 }; 5597 5598 ktrace_entry_t *ktep; 5599 ktrace_snap_t kts; 5600 if (ip->i_lock_trace == NULL) { 5601 qprintf("The inode ilock trace buffer is not initialized\n"); 5602 return; 5603 } 5604 5605 ktep = ktrace_first(ip->i_lock_trace, &kts); 5606 while (ktep != NULL) { 5607 if ((__psint_t)ktep->val[0] && 5608 (__psint_t)ktep->val[7] == 0) { 5609 printflags((__psint_t)ktep->val[2], xiflags,"Flags "); 5610 if ((__psint_t)ktep->val[1] == 1) 5611 qprintf("LOCK\n"); 5612 else if ((__psint_t)ktep->val[1] == 2) 5613 qprintf("LOCK SHARED\n"); 5614 else if ((__psint_t)ktep->val[1] == 3) 5615 qprintf("UNLOCK\n"); 5616 qprintf("ip 0x%p %lld %ld\n", 5617 ktep->val[0], (unsigned long long) 5618 ((xfs_inode_t*)ktep->val[0])->i_ino, 5619 (long)ktep->val[6]); 5620 qprintf("raddr 0x%p\n", ktep->val[3]); 5621 qprintf(" Pid %ld, cpu %ld\n", 5622 (long)ktep->val[5], 5623 (long)ktep->val[4]); 5624 qprintf("-----------------------\n"); 5625 } else if ((__psint_t)ktep->val[7] == 1) { 5626 if ((__psint_t)ktep->val[1] == 1) 5627 qprintf("LOCK "); 5628 else if ((__psint_t)ktep->val[1] == 2) 5629 qprintf("TRYLOCK %ld ", 5630 (long)ktep->val[2]); 5631 else if ((__psint_t)ktep->val[1] == 3) 5632 qprintf("UNLOCK "); 5633 else qprintf("UNKNOWN "); 5634 qprintf("ip 0x%p %lld %ld\n", 5635 ktep->val[0], (unsigned long long) 5636 ((xfs_inode_t*)ktep->val[0])->i_ino, 5637 (long)ktep->val[6]); 5638 qprintf("raddr 0x%p\n", ktep->val[3]); 5639 qprintf(" Pid %ld, cpu %ld\n", 5640 (long)ktep->val[5], 5641 (long)ktep->val[4]); 5642 qprintf("-----------------------\n"); 5643 } 5644 5645 ktep = ktrace_next(ip->i_lock_trace, &kts); 5646 } 5647} 5648 5649/* 5650 * Print out the last "count" entries in the inode lock trace buffer. 5651 * The "a" is for "all" entries. 5652 */ 5653static void 5654xfsidbg_xailock_trace(int count) 5655{ 5656 ktrace_entry_t *ktep; 5657 ktrace_snap_t kts; 5658 int nentries; 5659 int skip_entries; 5660 5661 if (xfs_ilock_trace_buf == NULL) { 5662 qprintf("The xfs inode lock trace buffer is not initialized\n"); return; 5663 } 5664 nentries = ktrace_nentries(xfs_ilock_trace_buf); 5665 if (count == -1) { 5666 count = nentries; 5667 } 5668 if ((count <= 0) || (count > nentries)) { 5669 qprintf("Invalid count. There are %d entries.\n", nentries); 5670 return; 5671 } 5672 5673 ktep = ktrace_first(xfs_ilock_trace_buf, &kts); 5674 if (count != nentries) { 5675 /* 5676 * Skip the total minus the number to look at minus one 5677 * for the entry returned by ktrace_first(). 5678 */ 5679 skip_entries = nentries - count - 1; 5680 ktep = ktrace_skip(xfs_ilock_trace_buf, skip_entries, &kts); 5681 if (ktep == NULL) { 5682 qprintf("Skipped them all\n"); 5683 return; 5684 } 5685 } 5686 while (ktep != NULL) { 5687 xfsidbg_xilock_trace_entry(ktep); 5688 ktep = ktrace_next(xfs_ilock_trace_buf, &kts); 5689 } 5690} 5691#endif 5692 5693/* 5694 * Compute & print buffer's checksum. 5695 */ 5696static void 5697xfsidbg_xchksum(uint *addr) 5698{ 5699 uint i, chksum = 0; 5700 5701 if (((__psint_t)addr) == ((__psint_t)-1)) { 5702 qprintf("USAGE xchksum <address>\n"); 5703 qprintf(" length is set with xarg\n"); 5704 } else { 5705 for (i=0; i<xargument; i++) { 5706 chksum ^= *addr; 5707 addr++; 5708 } 5709 qprintf("chksum (0x%x) length (%d)\n", chksum, xargument); 5710 } 5711} /* xfsidbg_xchksum */ 5712 5713/* 5714 * Print an xfs_da_args structure. 5715 */ 5716static void 5717xfsidbg_xdaargs(xfs_da_args_t *n) 5718{ 5719 char *ch; 5720 int i; 5721 5722 kdb_printf(" name \""); 5723 for (i = 0; i < n->namelen; i++) { 5724 kdb_printf("%c", n->name[i]); 5725 } 5726 kdb_printf("\"(%d) value ", n->namelen); 5727 if (n->value) { 5728 kdb_printf("\""); 5729 ch = n->value; 5730 for (i = 0; (i < n->valuelen) && (i < 32); ch++, i++) { 5731 switch(*ch) { 5732 case '\n': kdb_printf("\n"); break; 5733 case '\b': kdb_printf("\b"); break; 5734 case '\t': kdb_printf("\t"); break; 5735 default: kdb_printf("%c", *ch); break; 5736 } 5737 } 5738 if (i == 32) 5739 kdb_printf("..."); 5740 kdb_printf("\"(%d)\n", n->valuelen); 5741 } else { 5742 kdb_printf("(NULL)(%d)\n", n->valuelen); 5743 } 5744 kdb_printf(" hashval 0x%x whichfork %d flags <", 5745 (uint_t)n->hashval, n->whichfork); 5746 if (n->flags & ATTR_ROOT) 5747 kdb_printf("ROOT "); 5748 if (n->flags & ATTR_SECURE) 5749 kdb_printf("SECURE "); 5750 if (n->flags & ATTR_CREATE) 5751 kdb_printf("CREATE "); 5752 if (n->flags & ATTR_REPLACE) 5753 kdb_printf("REPLACE "); 5754 if (n->flags & XFS_ATTR_INCOMPLETE) 5755 kdb_printf("INCOMPLETE "); 5756 i = ~(ATTR_ROOT | ATTR_SECURE | 5757 ATTR_CREATE | ATTR_REPLACE | XFS_ATTR_INCOMPLETE); 5758 if ((n->flags & i) != 0) 5759 kdb_printf("0x%x", n->flags & i); 5760 kdb_printf(">\n"); 5761 kdb_printf(" rename %d justcheck %d addname %d oknoent %d\n", 5762 n->rename, n->justcheck, n->addname, n->oknoent); 5763 kdb_printf(" leaf: blkno %d index %d rmtblkno %d rmtblkcnt %d\n", 5764 n->blkno, n->index, n->rmtblkno, n->rmtblkcnt); 5765 kdb_printf(" leaf2: blkno %d index %d rmtblkno %d rmtblkcnt %d\n", 5766 n->blkno2, n->index2, n->rmtblkno2, n->rmtblkcnt2); 5767 kdb_printf(" inumber %llu dp 0x%p firstblock 0x%p flist 0x%p\n", 5768 (unsigned long long) n->inumber, 5769 n->dp, n->firstblock, n->flist); 5770 kdb_printf(" trans 0x%p total %d\n", 5771 n->trans, n->total); 5772} 5773 5774/* 5775 * Print a da buffer structure. 5776 */ 5777static void 5778xfsidbg_xdabuf(xfs_dabuf_t *dabuf) 5779{ 5780 int i; 5781 5782 kdb_printf("nbuf %d dirty %d bbcount %d data 0x%p bps", 5783 dabuf->nbuf, dabuf->dirty, dabuf->bbcount, dabuf->data); 5784 for (i = 0; i < dabuf->nbuf; i++) 5785 kdb_printf(" %d:0x%p", i, dabuf->bps[i]); 5786 kdb_printf("\n"); 5787#ifdef XFS_DABUF_DEBUG 5788 kdb_printf(" ra 0x%x prev 0x%x next 0x%x dev 0x%x blkno 0x%x\n", 5789 dabuf->ra, dabuf->prev, dabuf->next, dabuf->dev, dabuf->blkno); 5790#endif 5791} 5792 5793/* 5794 * Print a directory/attribute internal node block. 5795 */ 5796static void 5797xfsidbg_xdanode(xfs_da_intnode_t *node) 5798{ 5799 xfs_da_node_hdr_t *h; 5800 xfs_da_blkinfo_t *i; 5801 xfs_da_node_entry_t *e; 5802 int j; 5803 5804 h = &node->hdr; 5805 i = &h->info; 5806 kdb_printf("hdr info forw 0x%x back 0x%x magic 0x%x\n", 5807 INT_GET(i->forw, ARCH_CONVERT), INT_GET(i->back, ARCH_CONVERT), INT_GET(i->magic, ARCH_CONVERT)); 5808 kdb_printf("hdr count %d level %d\n", 5809 INT_GET(h->count, ARCH_CONVERT), INT_GET(h->level, ARCH_CONVERT)); 5810 for (j = 0, e = node->btree; j < INT_GET(h->count, ARCH_CONVERT); j++, e++) { 5811 kdb_printf("btree %d hashval 0x%x before 0x%x\n", 5812 j, (uint_t)INT_GET(e->hashval, ARCH_CONVERT), INT_GET(e->before, ARCH_CONVERT)); 5813 } 5814} 5815 5816/* 5817 * Print an xfs_da_state_blk structure. 5818 */ 5819static void 5820xfsidbg_xdastate(xfs_da_state_t *s) 5821{ 5822 xfs_da_state_blk_t *eblk; 5823 5824 kdb_printf("args 0x%p mp 0x%p blocksize %u node_ents %u inleaf %u\n", 5825 s->args, s->mp, s->blocksize, s->node_ents, s->inleaf); 5826 if (s->args) 5827 xfsidbg_xdaargs(s->args); 5828 5829 kdb_printf("path: "); 5830 xfs_dastate_path(&s->path); 5831 5832 kdb_printf("altpath: "); 5833 xfs_dastate_path(&s->altpath); 5834 5835 eblk = &s->extrablk; 5836 kdb_printf("extra: valid %d, after %d\n", s->extravalid, s->extraafter); 5837 kdb_printf(" bp 0x%p blkno 0x%x ", eblk->bp, eblk->blkno); 5838 kdb_printf("index %d hashval 0x%x\n", eblk->index, (uint_t)eblk->hashval); 5839} 5840 5841/* 5842 * Print a directory leaf block. 5843 */ 5844static void 5845xfsidbg_xdirleaf(xfs_dir_leafblock_t *leaf) 5846{ 5847 xfs_dir_leaf_hdr_t *h; 5848 xfs_da_blkinfo_t *i; 5849 xfs_dir_leaf_map_t *m; 5850 xfs_dir_leaf_entry_t *e; 5851 xfs_dir_leaf_name_t *n; 5852 int j, k; 5853 xfs_ino_t ino; 5854 5855 h = &leaf->hdr; 5856 i = &h->info; 5857 kdb_printf("hdr info forw 0x%x back 0x%x magic 0x%x\n", 5858 INT_GET(i->forw, ARCH_CONVERT), INT_GET(i->back, ARCH_CONVERT), INT_GET(i->magic, ARCH_CONVERT)); 5859 kdb_printf("hdr count %d namebytes %d firstused %d holes %d\n", 5860 INT_GET(h->count, ARCH_CONVERT), INT_GET(h->namebytes, ARCH_CONVERT), INT_GET(h->firstused, ARCH_CONVERT), h->holes); 5861 for (j = 0, m = h->freemap; j < XFS_DIR_LEAF_MAPSIZE; j++, m++) { 5862 kdb_printf("hdr freemap %d base %d size %d\n", 5863 j, INT_GET(m->base, ARCH_CONVERT), INT_GET(m->size, ARCH_CONVERT)); 5864 } 5865 for (j = 0, e = leaf->entries; j < INT_GET(h->count, ARCH_CONVERT); j++, e++) { 5866 n = XFS_DIR_LEAF_NAMESTRUCT(leaf, INT_GET(e->nameidx, ARCH_CONVERT)); 5867 XFS_DIR_SF_GET_DIRINO(&n->inumber, &ino); 5868 kdb_printf("leaf %d hashval 0x%x nameidx %d inumber %llu ", 5869 j, (uint_t)INT_GET(e->hashval, ARCH_CONVERT), 5870 INT_GET(e->nameidx, ARCH_CONVERT), 5871 (unsigned long long)ino); 5872 kdb_printf("namelen %d name \"", e->namelen); 5873 for (k = 0; k < e->namelen; k++) 5874 kdb_printf("%c", n->name[k]); 5875 kdb_printf("\"\n"); 5876 } 5877} 5878 5879/* 5880 * Print a directory v2 data block, single or multiple. 5881 */ 5882static void 5883xfs_dir2data(void *addr, int size) 5884{ 5885 xfs_dir2_data_t *db; 5886 xfs_dir2_block_t *bb; 5887 xfs_dir2_data_hdr_t *h; 5888 xfs_dir2_data_free_t *m; 5889 xfs_dir2_data_entry_t *e; 5890 xfs_dir2_data_unused_t *u; 5891 xfs_dir2_leaf_entry_t *l=NULL; 5892 int j, k; 5893 char *p; 5894 char *t; 5895 xfs_dir2_block_tail_t *tail=NULL; 5896 5897 db = (xfs_dir2_data_t *)addr; 5898 bb = (xfs_dir2_block_t *)addr; 5899 h = &db->hdr; 5900 kdb_printf("hdr magic 0x%x (%s)\nhdr bestfree", INT_GET(h->magic, ARCH_CONVERT), 5901 INT_GET(h->magic, ARCH_CONVERT) == XFS_DIR2_DATA_MAGIC ? "DATA" : 5902 (INT_GET(h->magic, ARCH_CONVERT) == XFS_DIR2_BLOCK_MAGIC ? "BLOCK" : "")); 5903 for (j = 0, m = h->bestfree; j < XFS_DIR2_DATA_FD_COUNT; j++, m++) { 5904 kdb_printf(" %d: 0x%x@0x%x", j, INT_GET(m->length, ARCH_CONVERT), INT_GET(m->offset, ARCH_CONVERT)); 5905 } 5906 kdb_printf("\n"); 5907 if (INT_GET(h->magic, ARCH_CONVERT) == XFS_DIR2_DATA_MAGIC) 5908 t = (char *)db + size; 5909 else { 5910 /* XFS_DIR2_BLOCK_TAIL_P */ 5911 tail = (xfs_dir2_block_tail_t *) 5912 ((char *)bb + size - sizeof(xfs_dir2_block_tail_t)); 5913 l = XFS_DIR2_BLOCK_LEAF_P(tail); 5914 t = (char *)l; 5915 } 5916 for (p = (char *)(h + 1); p < t; ) { 5917 u = (xfs_dir2_data_unused_t *)p; 5918 if (u->freetag == XFS_DIR2_DATA_FREE_TAG) { 5919 kdb_printf("0x%lx unused freetag 0x%x length 0x%x tag 0x%x\n", 5920 (unsigned long) (p - (char *)addr), 5921 INT_GET(u->freetag, ARCH_CONVERT), 5922 INT_GET(u->length, ARCH_CONVERT), 5923 INT_GET(*XFS_DIR2_DATA_UNUSED_TAG_P(u), ARCH_CONVERT)); 5924 p += INT_GET(u->length, ARCH_CONVERT); 5925 continue; 5926 } 5927 e = (xfs_dir2_data_entry_t *)p; 5928 kdb_printf("0x%lx entry inumber %llu namelen %d name \"", 5929 (unsigned long) (p - (char *)addr), 5930 (unsigned long long) INT_GET(e->inumber, ARCH_CONVERT), 5931 e->namelen); 5932 for (k = 0; k < e->namelen; k++) 5933 kdb_printf("%c", e->name[k]); 5934 kdb_printf("\" tag 0x%x\n", INT_GET(*XFS_DIR2_DATA_ENTRY_TAG_P(e), ARCH_CONVERT)); 5935 p += XFS_DIR2_DATA_ENTSIZE(e->namelen); 5936 } 5937 if (INT_GET(h->magic, ARCH_CONVERT) == XFS_DIR2_DATA_MAGIC) 5938 return; 5939 for (j = 0; j < INT_GET(tail->count, ARCH_CONVERT); j++, l++) { 5940 kdb_printf("0x%lx leaf %d hashval 0x%x address 0x%x (byte 0x%x)\n", 5941 (unsigned long) ((char *)l - (char *)addr), j, 5942 (uint_t)INT_GET(l->hashval, ARCH_CONVERT), 5943 INT_GET(l->address, ARCH_CONVERT), 5944 /* XFS_DIR2_DATAPTR_TO_BYTE */ 5945 INT_GET(l->address, ARCH_CONVERT) << XFS_DIR2_DATA_ALIGN_LOG); 5946 } 5947 kdb_printf("0x%lx tail count %d\n", 5948 (unsigned long) ((char *)tail - (char *)addr), 5949 INT_GET(tail->count, ARCH_CONVERT)); 5950} 5951 5952static void 5953xfs_dir2leaf(xfs_dir2_leaf_t *leaf, int size) 5954{ 5955 xfs_dir2_leaf_hdr_t *h; 5956 xfs_da_blkinfo_t *i; 5957 xfs_dir2_leaf_entry_t *e; 5958 xfs_dir2_data_off_t *b; 5959 xfs_dir2_leaf_tail_t *t; 5960 int j; 5961 5962 h = &leaf->hdr; 5963 i = &h->info; 5964 e = leaf->ents; 5965 kdb_printf("hdr info forw 0x%x back 0x%x magic 0x%x\n", 5966 INT_GET(i->forw, ARCH_CONVERT), INT_GET(i->back, ARCH_CONVERT), INT_GET(i->magic, ARCH_CONVERT)); 5967 kdb_printf("hdr count %d stale %d\n", INT_GET(h->count, ARCH_CONVERT), INT_GET(h->stale, ARCH_CONVERT)); 5968 for (j = 0; j < INT_GET(h->count, ARCH_CONVERT); j++, e++) { 5969 kdb_printf("0x%lx ent %d hashval 0x%x address 0x%x (byte 0x%x)\n", 5970 (unsigned long) ((char *)e - (char *)leaf), j, 5971 (uint_t)INT_GET(e->hashval, ARCH_CONVERT), 5972 INT_GET(e->address, ARCH_CONVERT), 5973 /* XFS_DIR2_DATAPTR_TO_BYTE */ 5974 INT_GET(e->address, ARCH_CONVERT) << XFS_DIR2_DATA_ALIGN_LOG); 5975 } 5976 if (INT_GET(i->magic, ARCH_CONVERT) == XFS_DIR2_LEAFN_MAGIC) 5977 return; 5978 /* XFS_DIR2_LEAF_TAIL_P */ 5979 t = (xfs_dir2_leaf_tail_t *)((char *)leaf + size - sizeof(*t)); 5980 b = XFS_DIR2_LEAF_BESTS_P(t); 5981 for (j = 0; j < INT_GET(t->bestcount, ARCH_CONVERT); j++, b++) { 5982 kdb_printf("0x%lx best %d 0x%x\n", 5983 (unsigned long) ((char *)b - (char *)leaf), j, 5984 INT_GET(*b, ARCH_CONVERT)); 5985 } 5986 kdb_printf("tail bestcount %d\n", INT_GET(t->bestcount, ARCH_CONVERT)); 5987} 5988 5989/* 5990 * Print a shortform directory. 5991 */ 5992static void 5993xfsidbg_xdirsf(xfs_dir_shortform_t *s) 5994{ 5995 xfs_dir_sf_hdr_t *sfh; 5996 xfs_dir_sf_entry_t *sfe; 5997 xfs_ino_t ino; 5998 int i, j; 5999 6000 sfh = &s->hdr; 6001 XFS_DIR_SF_GET_DIRINO(&sfh->parent, &ino); 6002 kdb_printf("hdr parent %llu", (unsigned long long)ino); 6003 kdb_printf(" count %d\n", sfh->count); 6004 for (i = 0, sfe = s->list; i < sfh->count; i++) { 6005 XFS_DIR_SF_GET_DIRINO(&sfe->inumber, &ino); 6006 kdb_printf("entry %d inumber %llu", i, (unsigned long long)ino); 6007 kdb_printf(" namelen %d name \"", sfe->namelen); 6008 for (j = 0; j < sfe->namelen; j++) 6009 kdb_printf("%c", sfe->name[j]); 6010 kdb_printf("\"\n"); 6011 sfe = XFS_DIR_SF_NEXTENTRY(sfe); 6012 } 6013} 6014 6015/* 6016 * Print a shortform v2 directory. 6017 */ 6018static void 6019xfsidbg_xdir2sf(xfs_dir2_sf_t *s) 6020{ 6021 xfs_dir2_sf_hdr_t *sfh; 6022 xfs_dir2_sf_entry_t *sfe; 6023 xfs_ino_t ino; 6024 int i, j; 6025 6026 sfh = &s->hdr; 6027 ino = XFS_DIR2_SF_GET_INUMBER(s, &sfh->parent); 6028 kdb_printf("hdr count %d i8count %d parent %llu\n", 6029 sfh->count, sfh->i8count, (unsigned long long) ino); 6030 for (i = 0, sfe = XFS_DIR2_SF_FIRSTENTRY(s); i < sfh->count; i++) { 6031 ino = XFS_DIR2_SF_GET_INUMBER(s, XFS_DIR2_SF_INUMBERP(sfe)); 6032 kdb_printf("entry %d inumber %llu offset 0x%x namelen %d name \"", 6033 i, (unsigned long long) ino, 6034 XFS_DIR2_SF_GET_OFFSET(sfe), 6035 sfe->namelen); 6036 for (j = 0; j < sfe->namelen; j++) 6037 kdb_printf("%c", sfe->name[j]); 6038 kdb_printf("\"\n"); 6039 sfe = XFS_DIR2_SF_NEXTENTRY(s, sfe); 6040 } 6041} 6042 6043/* 6044 * Print a node-form v2 directory freemap block. 6045 */ 6046static void 6047xfsidbg_xdir2free(xfs_dir2_free_t *f) 6048{ 6049 int i; 6050 6051 kdb_printf("hdr magic 0x%x firstdb %d nvalid %d nused %d\n", 6052 INT_GET(f->hdr.magic, ARCH_CONVERT), INT_GET(f->hdr.firstdb, ARCH_CONVERT), INT_GET(f->hdr.nvalid, ARCH_CONVERT), INT_GET(f->hdr.nused, ARCH_CONVERT)); 6053 for (i = 0; i < INT_GET(f->hdr.nvalid, ARCH_CONVERT); i++) { 6054 kdb_printf("entry %d db %d count %d\n", 6055 i, i + INT_GET(f->hdr.firstdb, ARCH_CONVERT), INT_GET(f->bests[i], ARCH_CONVERT)); 6056 } 6057} 6058 6059#ifdef XFS_DIR_TRACE 6060/* 6061 * Print out the last "count" entries in the directory trace buffer. 6062 */ 6063static void 6064xfsidbg_xdirtrace(int count) 6065{ 6066 ktrace_entry_t *ktep; 6067 ktrace_snap_t kts; 6068 int nentries; 6069 int skip_entries; 6070 6071 if (xfs_dir_trace_buf == NULL) { 6072 qprintf("The xfs directory trace buffer is not initialized\n"); 6073 return; 6074 } 6075 nentries = ktrace_nentries(xfs_dir_trace_buf); 6076 if (count == -1) { 6077 count = nentries; 6078 } 6079 if ((count <= 0) || (count > nentries)) { 6080 qprintf("Invalid count. There are %d entries.\n", nentries); 6081 return; 6082 } 6083 6084 ktep = ktrace_first(xfs_dir_trace_buf, &kts); 6085 if (count != nentries) { 6086 /* 6087 * Skip the total minus the number to look at minus one 6088 * for the entry returned by ktrace_first(). 6089 */ 6090 skip_entries = nentries - count - 1; 6091 ktep = ktrace_skip(xfs_dir_trace_buf, skip_entries, &kts); 6092 if (ktep == NULL) { 6093 qprintf("Skipped them all\n"); 6094 return; 6095 } 6096 } 6097 while (ktep != NULL) { 6098 if (xfs_dir_trace_entry(ktep)) 6099 qprintf("\n"); 6100 ktep = ktrace_next(xfs_dir_trace_buf, &kts); 6101 } 6102} 6103#endif 6104 6105#ifdef XFS_DIR2_TRACE 6106/* 6107 * Print out the last "count" entries in the directory v2 trace buffer. 6108 */ 6109static void 6110xfsidbg_xdir2atrace(int count) 6111{ 6112 ktrace_entry_t *ktep; 6113 ktrace_snap_t kts; 6114 int nentries; 6115 int skip_entries; 6116 6117 if (xfs_dir2_trace_buf == NULL) { 6118 qprintf("The xfs dirv2 trace buffer is not initialized\n"); 6119 return; 6120 } 6121 nentries = ktrace_nentries(xfs_dir2_trace_buf); 6122 if (count == -1) { 6123 count = nentries; 6124 } 6125 if ((count <= 0) || (count > nentries)) { 6126 qprintf("Invalid count. There are %d entries.\n", nentries); 6127 return; 6128 } 6129 6130 ktep = ktrace_first(xfs_dir2_trace_buf, &kts); 6131 if (count != nentries) { 6132 /* 6133 * Skip the total minus the number to look at minus one 6134 * for the entry returned by ktrace_first(). 6135 */ 6136 skip_entries = nentries - count - 1; 6137 ktep = ktrace_skip(xfs_dir2_trace_buf, skip_entries, &kts); 6138 if (ktep == NULL) { 6139 qprintf("Skipped them all\n"); 6140 return; 6141 } 6142 } 6143 while (ktep != NULL) { 6144 if (xfs_dir2_trace_entry(ktep)) 6145 qprintf("\n"); 6146 ktep = ktrace_next(xfs_dir2_trace_buf, &kts); 6147 } 6148} 6149 6150/* 6151 * Print out the directory v2 trace buffer attached to the given inode. 6152 */ 6153static void 6154xfsidbg_xdir2itrace(xfs_inode_t *ip) 6155{ 6156 ktrace_entry_t *ktep; 6157 ktrace_snap_t kts; 6158 6159 if (ip->i_dir_trace == NULL) { 6160 qprintf("The inode trace buffer is not initialized\n"); 6161 return; 6162 } 6163 6164 ktep = ktrace_first(ip->i_dir_trace, &kts); 6165 while (ktep != NULL) { 6166 if (xfs_dir2_trace_entry(ktep)) 6167 qprintf("\n"); 6168 ktep = ktrace_next(ip->i_dir_trace, &kts); 6169 } 6170} 6171#endif 6172 6173/* 6174 * Print xfs extent records. 6175 */ 6176static void 6177xfsidbg_xexlist(xfs_inode_t *ip) 6178{ 6179 xfs_xexlist_fork(ip, XFS_DATA_FORK); 6180 if (XFS_IFORK_Q(ip)) 6181 xfs_xexlist_fork(ip, XFS_ATTR_FORK); 6182} 6183 6184/* 6185 * Print an xfs free-extent records. 6186 */ 6187static void 6188xfsidbg_xflist(xfs_bmap_free_t *flist) 6189{ 6190 xfs_bmap_free_item_t *item; 6191 6192 kdb_printf("flist@0x%p: first 0x%p count %d low %d\n", flist, 6193 flist->xbf_first, flist->xbf_count, flist->xbf_low); 6194 for (item = flist->xbf_first; item; item = item->xbfi_next) { 6195 kdb_printf("item@0x%p: startblock %Lx blockcount %d", item, 6196 (xfs_dfsbno_t)item->xbfi_startblock, 6197 item->xbfi_blockcount); 6198 } 6199} 6200 6201/* 6202 * Print out the help messages for these functions. 6203 */ 6204static void 6205xfsidbg_xhelp(void) 6206{ 6207 struct xif *p; 6208 6209 for (p = xfsidbg_funcs; p->name; p++) 6210 kdb_printf("%-16s %s %s\n", p->name, p->args, p->help); 6211} 6212 6213/* 6214 * Print out an XFS in-core log structure. 6215 */ 6216static void 6217xfsidbg_xiclog(xlog_in_core_t *iclog) 6218{ 6219 int i; 6220 static char *ic_flags[] = { 6221 "ACTIVE", /* 0x0001 */ 6222 "WANT_SYNC", /* 0x0002 */ 6223 "SYNCING", /* 0X0004 */ 6224 "DONE_SYNC", /* 0X0008 */ 6225 "DO_CALLBACK", /* 0X0010 */ 6226 "CALLBACK", /* 0X0020 */ 6227 "DIRTY", /* 0X0040 */ 6228 "IOERROR", /* 0X0080 */ 6229 "NOTUSED", /* 0X8000 */ 6230 NULL 6231 }; 6232 6233 kdb_printf("xlog_in_core/header at 0x%p/0x%p\n", 6234 iclog, iclog->hic_data); 6235 kdb_printf("magicno: %x cycle: %d version: %d lsn: 0x%Lx\n", 6236 INT_GET(iclog->ic_header.h_magicno, ARCH_CONVERT), INT_GET(iclog->ic_header.h_cycle, ARCH_CONVERT), 6237 INT_GET(iclog->ic_header.h_version, ARCH_CONVERT), INT_GET(iclog->ic_header.h_lsn, ARCH_CONVERT)); 6238 kdb_printf("tail_lsn: 0x%Lx len: %d prev_block: %d num_ops: %d\n", 6239 INT_GET(iclog->ic_header.h_tail_lsn, ARCH_CONVERT), INT_GET(iclog->ic_header.h_len, ARCH_CONVERT), 6240 INT_GET(iclog->ic_header.h_prev_block, ARCH_CONVERT), INT_GET(iclog->ic_header.h_num_logops, ARCH_CONVERT)); 6241 kdb_printf("cycle_data: "); 6242 for (i=0; i<(iclog->ic_size>>BBSHIFT); i++) { 6243 kdb_printf("%x ", INT_GET(iclog->ic_header.h_cycle_data[i], ARCH_CONVERT)); 6244 } 6245 kdb_printf("\n"); 6246 kdb_printf("size: %d\n", INT_GET(iclog->ic_header.h_size, ARCH_CONVERT)); 6247 kdb_printf("\n"); 6248 kdb_printf("--------------------------------------------------\n"); 6249 kdb_printf("data: 0x%p &forcesema: 0x%p next: 0x%p bp: 0x%p\n", 6250 iclog->ic_datap, &iclog->ic_forcesema, iclog->ic_next, 6251 iclog->ic_bp); 6252 kdb_printf("log: 0x%p callb: 0x%p callb_tail: 0x%p\n", 6253 iclog->ic_log, iclog->ic_callback, iclog->ic_callback_tail); 6254 kdb_printf("size: %d (OFFSET: %d) trace: 0x%p refcnt: %d bwritecnt: %d", 6255 iclog->ic_size, iclog->ic_offset, 6256#ifdef XFS_LOG_TRACE 6257 iclog->ic_trace, 6258#else 6259 NULL, 6260#endif 6261 iclog->ic_refcnt, iclog->ic_bwritecnt); 6262 if (iclog->ic_state & XLOG_STATE_ALL) 6263 printflags(iclog->ic_state, ic_flags, " state:"); 6264 else 6265 kdb_printf(" state: INVALID 0x%x", iclog->ic_state); 6266 kdb_printf("\n"); 6267} /* xfsidbg_xiclog */ 6268 6269 6270/* 6271 * Print all incore logs. 6272 */ 6273static void 6274xfsidbg_xiclogall(xlog_in_core_t *iclog) 6275{ 6276 xlog_in_core_t *first_iclog = iclog; 6277 6278 do { 6279 xfsidbg_xiclog(iclog); 6280 kdb_printf("=================================================\n"); 6281 iclog = iclog->ic_next; 6282 } while (iclog != first_iclog); 6283} /* xfsidbg_xiclogall */ 6284 6285/* 6286 * Print out the callback structures attached to an iclog. 6287 */ 6288static void 6289xfsidbg_xiclogcb(xlog_in_core_t *iclog) 6290{ 6291 xfs_log_callback_t *cb; 6292 kdb_symtab_t symtab; 6293 6294 for (cb = iclog->ic_callback; cb != NULL; cb = cb->cb_next) { 6295 6296 if (kdbnearsym((unsigned long)cb->cb_func, &symtab)) { 6297 unsigned long offval; 6298 6299 offval = (unsigned long)cb->cb_func - symtab.sym_start; 6300 6301 if (offval) 6302 kdb_printf("func = %s+0x%lx", 6303 symtab.sym_name, 6304 offval); 6305 else 6306 kdb_printf("func = %s", symtab.sym_name); 6307 } else 6308 kdb_printf("func = ?? 0x%p", (void *)cb->cb_func); 6309 6310 kdb_printf(" arg 0x%p next 0x%p\n", cb->cb_arg, cb->cb_next); 6311 } 6312} 6313 6314#ifdef XFS_LOG_TRACE 6315/* 6316 * Print trace from incore log. 6317 */ 6318static void 6319xfsidbg_xiclogtrace(xlog_in_core_t *iclog) 6320{ 6321 ktrace_entry_t *ktep; 6322 ktrace_snap_t kts; 6323 ktrace_t *kt = iclog->ic_trace; 6324 6325 qprintf("iclog->ic_trace 0x%p\n", kt); 6326 ktep = ktrace_first(kt, &kts); 6327 while (ktep != NULL) { 6328 switch ((__psint_t)ktep->val[0]) { 6329 case XLOG_TRACE_GRAB_FLUSH: { 6330 qprintf("grabbing semaphore\n"); 6331 break; 6332 } 6333 case XLOG_TRACE_REL_FLUSH: { 6334 qprintf("releasing semaphore\n"); 6335 break; 6336 } 6337 case XLOG_TRACE_SLEEP_FLUSH: { 6338 qprintf("sleeping on semaphore\n"); 6339 break; 6340 } 6341 case XLOG_TRACE_WAKE_FLUSH: { 6342 qprintf("waking up on semaphore\n"); 6343 break; 6344 } 6345 default: { 6346 } 6347 } 6348 ktep = ktrace_next(kt, &kts); 6349 } 6350} /* xfsidbg_xiclogtrace */ 6351#endif 6352 6353/* 6354 * Print all of the inodes attached to the given mount structure. 6355 */ 6356static void 6357xfsidbg_xinodes(xfs_mount_t *mp) 6358{ 6359 xfs_inode_t *ip; 6360 6361 kdb_printf("xfs_mount at 0x%p\n", mp); 6362 ip = mp->m_inodes; 6363 if (ip != NULL) { 6364 do { 6365 if (ip->i_mount == NULL) { 6366 ip = ip->i_mnext; 6367 continue; 6368 } 6369 kdb_printf("\n"); 6370 xfsidbg_xnode(ip); 6371 ip = ip->i_mnext; 6372 } while (ip != mp->m_inodes); 6373 } 6374 kdb_printf("\nEnd of Inodes\n"); 6375} 6376 6377static void 6378xfsidbg_delayed_blocks(xfs_mount_t *mp) 6379{ 6380 xfs_inode_t *ip; 6381 unsigned int total = 0; 6382 unsigned int icount = 0; 6383 6384 ip = mp->m_inodes; 6385 if (ip != NULL) { 6386 do { 6387 if (ip->i_mount == NULL) { 6388 ip = ip->i_mnext; 6389 continue; 6390 } 6391 if (ip->i_delayed_blks) { 6392 total += ip->i_delayed_blks; 6393 icount++; 6394 } 6395 ip = ip->i_mnext; 6396 } while (ip != mp->m_inodes); 6397 } 6398 kdb_printf("delayed blocks total: %d in %d inodes\n", total, icount); 6399} 6400 6401static void 6402xfsidbg_xinodes_quiesce(xfs_mount_t *mp) 6403{ 6404 xfs_inode_t *ip; 6405 6406 kdb_printf("xfs_mount at 0x%p\n", mp); 6407 ip = mp->m_inodes; 6408 if (ip != NULL) { 6409 do { 6410 if (ip->i_mount == NULL) { 6411 ip = ip->i_mnext; 6412 continue; 6413 } 6414 if (!(ip->i_flags & XFS_IQUIESCE)) { 6415 kdb_printf("ip 0x%p not quiesced\n", ip); 6416 } 6417 ip = ip->i_mnext; 6418 } while (ip != mp->m_inodes); 6419 } 6420 kdb_printf("\nEnd of Inodes\n"); 6421} 6422 6423static char * 6424xfsidbg_get_cstate(int state) 6425{ 6426 switch(state) { 6427 case XLOG_STATE_COVER_IDLE: 6428 return("idle"); 6429 case XLOG_STATE_COVER_NEED: 6430 return("need"); 6431 case XLOG_STATE_COVER_DONE: 6432 return("done"); 6433 case XLOG_STATE_COVER_NEED2: 6434 return("need2"); 6435 case XLOG_STATE_COVER_DONE2: 6436 return("done2"); 6437 default: 6438 return("unknown"); 6439 } 6440} 6441 6442/* 6443 * Print out an XFS log structure. 6444 */ 6445static void 6446xfsidbg_xlog(xlog_t *log) 6447{ 6448 static char *t_flags[] = { 6449 "CHKSUM_MISMATCH", /* 0x01 */ 6450 "ACTIVE_RECOVERY", /* 0x02 */ 6451 "RECOVERY_NEEDED", /* 0x04 */ 6452 "IO_ERROR", /* 0x08 */ 6453 NULL 6454 }; 6455 6456 kdb_printf("xlog at 0x%p\n", log); 6457 kdb_printf("&flushsm: 0x%p flushcnt: %d tic_cnt: %d tic_tcnt: %d \n", 6458 &log->l_flushsema, log->l_flushcnt, 6459 log->l_ticket_cnt, log->l_ticket_tcnt); 6460 kdb_printf("freelist: 0x%p tail: 0x%p ICLOG: 0x%p \n", 6461 log->l_freelist, log->l_tail, log->l_iclog); 6462 kdb_printf("&icloglock: 0x%p tail_lsn: %s last_sync_lsn: %s \n", 6463 &log->l_icloglock, xfs_fmtlsn(&log->l_tail_lsn), 6464 xfs_fmtlsn(&log->l_last_sync_lsn)); 6465 kdb_printf("mp: 0x%p xbuf: 0x%p l_covered_state: %s \n", 6466 log->l_mp, log->l_xbuf, 6467 xfsidbg_get_cstate(log->l_covered_state)); 6468 kdb_printf("flags: "); 6469 printflags(log->l_flags, t_flags,"log"); 6470 kdb_printf(" logBBstart: %lld logsize: %d logBBsize: %d\n", 6471 (long long) log->l_logBBstart, 6472 log->l_logsize,log->l_logBBsize); 6473 kdb_printf("curr_cycle: %d prev_cycle: %d curr_block: %d prev_block: %d\n", 6474 log->l_curr_cycle, log->l_prev_cycle, log->l_curr_block, 6475 log->l_prev_block); 6476 kdb_printf("iclog_bak: 0x%p iclog_size: 0x%x (%d) num iclogs: %d\n", 6477 log->l_iclog_bak, log->l_iclog_size, log->l_iclog_size, 6478 log->l_iclog_bufs); 6479 kdb_printf("l_iclog_hsize %d l_iclog_heads %d\n", 6480 log->l_iclog_hsize, log->l_iclog_heads); 6481 kdb_printf("l_sectbb_log %u l_sectbb_mask %u\n", 6482 log->l_sectbb_log, log->l_sectbb_mask); 6483 kdb_printf("&grant_lock: 0x%p resHeadQ: 0x%p wrHeadQ: 0x%p\n", 6484 &log->l_grant_lock, log->l_reserve_headq, log->l_write_headq); 6485 kdb_printf("GResCycle: %d GResBytes: %d GWrCycle: %d GWrBytes: %d\n", 6486 log->l_grant_reserve_cycle, log->l_grant_reserve_bytes, 6487 log->l_grant_write_cycle, log->l_grant_write_bytes); 6488 qprintf("GResBlocks: %d GResRemain: %d GWrBlocks: %d GWrRemain: %d\n", 6489 (int)BTOBBT(log->l_grant_reserve_bytes), 6490 log->l_grant_reserve_bytes % BBSIZE, 6491 (int)BTOBBT(log->l_grant_write_bytes), 6492 log->l_grant_write_bytes % BBSIZE); 6493#ifdef XFS_LOG_TRACE 6494 qprintf("trace: 0x%p grant_trace: use xlog value\n", log->l_trace); 6495#endif 6496} /* xfsidbg_xlog */ 6497 6498static void 6499xfsidbg_print_trans_type(unsigned int t_type) 6500{ 6501 switch (t_type) { 6502 case XFS_TRANS_SETATTR_NOT_SIZE: kdb_printf("SETATTR_NOT_SIZE");break; 6503 case XFS_TRANS_SETATTR_SIZE: kdb_printf("SETATTR_SIZE"); break; 6504 case XFS_TRANS_INACTIVE: kdb_printf("INACTIVE"); break; 6505 case XFS_TRANS_CREATE: kdb_printf("CREATE"); break; 6506 case XFS_TRANS_CREATE_TRUNC: kdb_printf("CREATE_TRUNC"); break; 6507 case XFS_TRANS_TRUNCATE_FILE: kdb_printf("TRUNCATE_FILE"); break; 6508 case XFS_TRANS_REMOVE: kdb_printf("REMOVE"); break; 6509 case XFS_TRANS_LINK: kdb_printf("LINK"); break; 6510 case XFS_TRANS_RENAME: kdb_printf("RENAME"); break; 6511 case XFS_TRANS_MKDIR: kdb_printf("MKDIR"); break; 6512 case XFS_TRANS_RMDIR: kdb_printf("RMDIR"); break; 6513 case XFS_TRANS_SYMLINK: kdb_printf("SYMLINK"); break; 6514 case XFS_TRANS_SET_DMATTRS: kdb_printf("SET_DMATTRS"); break; 6515 case XFS_TRANS_GROWFS: kdb_printf("GROWFS"); break; 6516 case XFS_TRANS_STRAT_WRITE: kdb_printf("STRAT_WRITE"); break; 6517 case XFS_TRANS_DIOSTRAT: kdb_printf("DIOSTRAT"); break; 6518 case XFS_TRANS_WRITE_SYNC: kdb_printf("WRITE_SYNC"); break; 6519 case XFS_TRANS_WRITEID: kdb_printf("WRITEID"); break; 6520 case XFS_TRANS_ADDAFORK: kdb_printf("ADDAFORK"); break; 6521 case XFS_TRANS_ATTRINVAL: kdb_printf("ATTRINVAL"); break; 6522 case XFS_TRANS_ATRUNCATE: kdb_printf("ATRUNCATE"); break; 6523 case XFS_TRANS_ATTR_SET: kdb_printf("ATTR_SET"); break; 6524 case XFS_TRANS_ATTR_RM: kdb_printf("ATTR_RM"); break; 6525 case XFS_TRANS_ATTR_FLAG: kdb_printf("ATTR_FLAG"); break; 6526 case XFS_TRANS_CLEAR_AGI_BUCKET:kdb_printf("CLEAR_AGI_BUCKET"); break; 6527 case XFS_TRANS_QM_SBCHANGE: kdb_printf("QM_SBCHANGE"); break; 6528 case XFS_TRANS_QM_QUOTAOFF: kdb_printf("QM_QUOTAOFF"); break; 6529 case XFS_TRANS_QM_DQALLOC: kdb_printf("QM_DQALLOC"); break; 6530 case XFS_TRANS_QM_SETQLIM: kdb_printf("QM_SETQLIM"); break; 6531 case XFS_TRANS_QM_DQCLUSTER: kdb_printf("QM_DQCLUSTER"); break; 6532 case XFS_TRANS_QM_QINOCREATE: kdb_printf("QM_QINOCREATE"); break; 6533 case XFS_TRANS_QM_QUOTAOFF_END: kdb_printf("QM_QOFF_END"); break; 6534 case XFS_TRANS_SB_UNIT: kdb_printf("SB_UNIT"); break; 6535 case XFS_TRANS_FSYNC_TS: kdb_printf("FSYNC_TS"); break; 6536 case XFS_TRANS_GROWFSRT_ALLOC: kdb_printf("GROWFSRT_ALLOC"); break; 6537 case XFS_TRANS_GROWFSRT_ZERO: kdb_printf("GROWFSRT_ZERO"); break; 6538 case XFS_TRANS_GROWFSRT_FREE: kdb_printf("GROWFSRT_FREE"); break; 6539 default: kdb_printf("unknown(0x%x)", t_type); break; 6540 } 6541} 6542 6543#ifdef XFS_LOG_TRACE 6544/* 6545 * Print grant trace for a log. 6546 */ 6547static void 6548xfsidbg_xlog_granttrace(xlog_t *log) 6549{ 6550 ktrace_entry_t *ktep; 6551 ktrace_snap_t kts; 6552 ktrace_t *kt; 6553 int i = 0; 6554 unsigned long cnts,t_ocnt, t_cnt; 6555 6556 if (((__psint_t)log) == ((__psint_t)-1)) { 6557 qprintf("Usage: xl_grtr <log>\n"); 6558 return; 6559 } 6560 if ((kt = log->l_grant_trace)) 6561 qprintf("log->l_grant_trace 0x%p\n", kt); 6562 else { 6563 qprintf("log->l_grant_trace is empty!\n"); 6564 return; 6565 } 6566 ktep = ktrace_first(kt, &kts); 6567 while (ktep != NULL) { 6568 /* split cnts into two parts: cnt and ocnt */ 6569 cnts = (unsigned long)ktep->val[13]; 6570 t_ocnt = 0xff & cnts; 6571 t_cnt = cnts >> 8; 6572 6573 qprintf("%d: %s [", i++, (char *)ktep->val[11]); 6574 xfsidbg_print_trans_type((unsigned long)ktep->val[12]); 6575 qprintf("]\n"); 6576 qprintf(" t_ocnt = %lu, t_cnt = %lu, t_curr_res = %lu, " 6577 "t_unit_res = %lu\n", 6578 t_ocnt, t_cnt, (unsigned long)ktep->val[14], 6579 (unsigned long)ktep->val[15]); 6580 qprintf(" tic:0x%p resQ:0x%p wrQ:0x%p ", 6581 ktep->val[0], ktep->val[1], ktep->val[2]); 6582 qprintf(" GrResC:%ld GrResB:%ld GrWrC:%ld GrWrB:%ld \n", 6583 (long)ktep->val[3], (long)ktep->val[4], 6584 (long)ktep->val[5], (long)ktep->val[6]); 6585 qprintf(" HeadC:%ld HeadB:%ld TailC:%ld TailB:%ld\n", 6586 (long)ktep->val[7], (long)ktep->val[8], 6587 (long)ktep->val[9], (long)ktep->val[10]); 6588 ktep = ktrace_next(kt, &kts); 6589 } 6590} /* xfsidbg_xlog_granttrace */ 6591#endif 6592 6593/* 6594 * Print out an XFS recovery transaction 6595 */ 6596static void 6597xfsidbg_xlog_ritem(xlog_recover_item_t *item) 6598{ 6599 int i = XLOG_MAX_REGIONS_IN_ITEM; 6600 6601 kdb_printf("(xlog_recover_item 0x%p) ", item); 6602 kdb_printf("next: 0x%p prev: 0x%p type: %d cnt: %d ttl: %d\n", 6603 item->ri_next, item->ri_prev, ITEM_TYPE(item), item->ri_cnt, 6604 item->ri_total); 6605 for ( ; i > 0; i--) { 6606 if (!item->ri_buf[XLOG_MAX_REGIONS_IN_ITEM-i].i_addr) 6607 break; 6608 kdb_printf("a: 0x%p l: %d ", 6609 item->ri_buf[XLOG_MAX_REGIONS_IN_ITEM-i].i_addr, 6610 item->ri_buf[XLOG_MAX_REGIONS_IN_ITEM-i].i_len); 6611 } 6612 kdb_printf("\n"); 6613} /* xfsidbg_xlog_ritem */ 6614 6615/* 6616 * Print out an XFS recovery transaction 6617 */ 6618static void 6619xfsidbg_xlog_rtrans(xlog_recover_t *trans) 6620{ 6621 xlog_recover_item_t *rip, *first_rip; 6622 6623 kdb_printf("(xlog_recover 0x%p) ", trans); 6624 kdb_printf("tid: %x type: %d items: %d ttid: 0x%x ", 6625 trans->r_log_tid, trans->r_theader.th_type, 6626 trans->r_theader.th_num_items, trans->r_theader.th_tid); 6627 kdb_printf("itemq: 0x%p\n", trans->r_itemq); 6628 if (trans->r_itemq) { 6629 rip = first_rip = trans->r_itemq; 6630 do { 6631 kdb_printf("(recovery item: 0x%p) ", rip); 6632 kdb_printf("type: %d cnt: %d total: %d\n", 6633 ITEM_TYPE(rip), rip->ri_cnt, rip->ri_total); 6634 rip = rip->ri_next; 6635 } while (rip != first_rip); 6636 } 6637} /* xfsidbg_xlog_rtrans */ 6638 6639static void 6640xfsidbg_xlog_buf_logitem(xlog_recover_item_t *item) 6641{ 6642 xfs_buf_log_format_t *buf_f; 6643 int i, j; 6644 int bit; 6645 int nbits; 6646 unsigned int *data_map; 6647 unsigned int map_size; 6648 int size; 6649 6650 buf_f = (xfs_buf_log_format_t *)item->ri_buf[0].i_addr; 6651 if (buf_f->blf_flags & XFS_BLI_INODE_BUF) { 6652 kdb_printf("\tINODE BUF <blkno=0x%Lx, len=0x%x>\n", 6653 buf_f->blf_blkno, buf_f->blf_len); 6654 } else if (buf_f->blf_flags & 6655 (XFS_BLI_UDQUOT_BUF|XFS_BLI_PDQUOT_BUF|XFS_BLI_GDQUOT_BUF)) { 6656 kdb_printf("\tDQUOT BUF <blkno=0x%Lx, len=0x%x>\n", 6657 buf_f->blf_blkno, buf_f->blf_len); 6658 } else { 6659 data_map = buf_f->blf_data_map; 6660 map_size = buf_f->blf_map_size; 6661 kdb_printf("\tREG BUF <blkno=0x%Lx, len=0x%x map 0x%p size %d>\n", 6662 buf_f->blf_blkno, buf_f->blf_len, data_map, map_size); 6663 bit = 0; 6664 i = 0; /* 0 is the buf format structure */ 6665 while (1) { 6666 bit = xfs_next_bit(data_map, map_size, bit); 6667 if (bit == -1) 6668 break; 6669 nbits = xfs_contig_bits(data_map, map_size, bit); 6670 size = ((uint)bit << XFS_BLI_SHIFT)+(nbits<<XFS_BLI_SHIFT); 6671 kdb_printf("\t\tlogbuf.i_addr 0x%p, size 0x%x\n", 6672 item->ri_buf[i].i_addr, size); 6673 kdb_printf("\t\t\t\""); 6674 for (j=0; j<8 && j<size; j++) { 6675 kdb_printf("%02x", ((char *)item->ri_buf[i].i_addr)[j]); 6676 } 6677 kdb_printf("...\"\n"); 6678 i++; 6679 bit += nbits; 6680 } 6681 6682 } 6683} 6684 6685/* 6686 * Print out an ENTIRE XFS recovery transaction 6687 */ 6688static void 6689xfsidbg_xlog_rtrans_entire(xlog_recover_t *trans) 6690{ 6691 xlog_recover_item_t *item, *first_rip; 6692 6693 kdb_printf("(Recovering Xact 0x%p) ", trans); 6694 kdb_printf("tid: %x type: %d nitems: %d ttid: 0x%x ", 6695 trans->r_log_tid, trans->r_theader.th_type, 6696 trans->r_theader.th_num_items, trans->r_theader.th_tid); 6697 kdb_printf("itemq: 0x%p\n", trans->r_itemq); 6698 if (trans->r_itemq) { 6699 item = first_rip = trans->r_itemq; 6700 do { 6701 /* 6702 kdb_printf("(recovery item: 0x%x) ", item); 6703 kdb_printf("type: %d cnt: %d total: %d\n", 6704 item->ri_type, item->ri_cnt, item->ri_total); 6705 */ 6706 if ((ITEM_TYPE(item) == XFS_LI_BUF) || 6707 (ITEM_TYPE(item) == XFS_LI_6_1_BUF) || 6708 (ITEM_TYPE(item) == XFS_LI_5_3_BUF)) { 6709 kdb_printf("BUF:"); 6710 xfsidbg_xlog_buf_logitem(item); 6711 } else if ((ITEM_TYPE(item) == XFS_LI_INODE) || 6712 (ITEM_TYPE(item) == XFS_LI_6_1_INODE) || 6713 (ITEM_TYPE(item) == XFS_LI_5_3_INODE)) { 6714 kdb_printf("INODE:\n"); 6715 } else if (ITEM_TYPE(item) == XFS_LI_EFI) { 6716 kdb_printf("EFI:\n"); 6717 } else if (ITEM_TYPE(item) == XFS_LI_EFD) { 6718 kdb_printf("EFD:\n"); 6719 } else if (ITEM_TYPE(item) == XFS_LI_DQUOT) { 6720 kdb_printf("DQUOT:\n"); 6721 } else if ((ITEM_TYPE(item) == XFS_LI_QUOTAOFF)) { 6722 kdb_printf("QUOTAOFF:\n"); 6723 } else { 6724 kdb_printf("UNKNOWN LOGITEM 0x%x\n", ITEM_TYPE(item)); 6725 } 6726 item = item->ri_next; 6727 } while (item != first_rip); 6728 } 6729} /* xfsidbg_xlog_rtrans */ 6730 6731/* 6732 * Print out an XFS ticket structure. 6733 */ 6734static void 6735xfsidbg_xlog_tic(xlog_ticket_t *tic) 6736{ 6737 static char *t_flags[] = { 6738 "INIT", /* 0x1 */ 6739 "PERM_RES", /* 0x2 */ 6740 "IN_Q", /* 0x4 */ 6741 NULL 6742 }; 6743 6744 kdb_printf("xlog_ticket at 0x%p\n", tic); 6745 kdb_printf("next: 0x%p prev: 0x%p tid: 0x%x \n", 6746 tic->t_next, tic->t_prev, tic->t_tid); 6747 kdb_printf("curr_res: %d unit_res: %d ocnt: %d cnt: %d\n", 6748 tic->t_curr_res, tic->t_unit_res, (int)tic->t_ocnt, 6749 (int)tic->t_cnt); 6750 kdb_printf("clientid: %c \n", tic->t_clientid); 6751 printflags(tic->t_flags, t_flags,"ticket"); 6752 kdb_printf("\n"); 6753 qprintf("trans type: "); 6754 xfsidbg_print_trans_type(tic->t_trans_type); 6755 qprintf("\n"); 6756} /* xfsidbg_xlog_tic */ 6757 6758/* 6759 * Print out a single log item. 6760 */ 6761static void 6762xfsidbg_xlogitem(xfs_log_item_t *lip) 6763{ 6764 xfs_log_item_t *bio_lip; 6765 static char *lid_type[] = { 6766 "???", /* 0 */ 6767 "5-3-buf", /* 1 */ 6768 "5-3-inode", /* 2 */ 6769 "efi", /* 3 */ 6770 "efd", /* 4 */ 6771 "iunlink", /* 5 */ 6772 "6-1-inode", /* 6 */ 6773 "6-1-buf", /* 7 */ 6774 "inode", /* 8 */ 6775 "buf", /* 9 */ 6776 "dquot", /* 10 */ 6777 NULL 6778 }; 6779 static char *li_flags[] = { 6780 "in ail", /* 0x1 */ 6781 NULL 6782 }; 6783 6784 kdb_printf("type %s mountp 0x%p flags ", 6785 lid_type[lip->li_type - XFS_LI_5_3_BUF + 1], 6786 lip->li_mountp); 6787 printflags((uint)(lip->li_flags), li_flags,"log"); 6788 kdb_printf("\n"); 6789 kdb_printf("ail forw 0x%p ail back 0x%p lsn %s\ndesc %p ops 0x%p", 6790 lip->li_ail.ail_forw, lip->li_ail.ail_back, 6791 xfs_fmtlsn(&(lip->li_lsn)), lip->li_desc, lip->li_ops); 6792 kdb_printf(" iodonefunc &0x%p\n", lip->li_cb); 6793 if (lip->li_type == XFS_LI_BUF) { 6794 bio_lip = lip->li_bio_list; 6795 if (bio_lip != NULL) { 6796 kdb_printf("iodone list:\n"); 6797 } 6798 while (bio_lip != NULL) { 6799 kdb_printf("item 0x%p func 0x%p\n", 6800 bio_lip, bio_lip->li_cb); 6801 bio_lip = bio_lip->li_bio_list; 6802 } 6803 } 6804 switch (lip->li_type) { 6805 case XFS_LI_BUF: 6806 xfs_buf_item_print((xfs_buf_log_item_t *)lip, 0); 6807 break; 6808 case XFS_LI_INODE: 6809 xfs_inode_item_print((xfs_inode_log_item_t *)lip, 0); 6810 break; 6811 case XFS_LI_EFI: 6812 xfs_efi_item_print((xfs_efi_log_item_t *)lip, 0); 6813 break; 6814 case XFS_LI_EFD: 6815 xfs_efd_item_print((xfs_efd_log_item_t *)lip, 0); 6816 break; 6817 case XFS_LI_DQUOT: 6818 xfs_dquot_item_print((xfs_dq_logitem_t *)lip, 0); 6819 break; 6820 case XFS_LI_QUOTAOFF: 6821 xfs_qoff_item_print((xfs_qoff_logitem_t *)lip, 0); 6822 break; 6823 6824 default: 6825 kdb_printf("Unknown item type %d\n", lip->li_type); 6826 break; 6827 } 6828} 6829 6830/* 6831 * Print out a summary of the AIL hanging off of a mount struct. 6832 */ 6833static void 6834xfsidbg_xaildump(xfs_mount_t *mp) 6835{ 6836 xfs_log_item_t *lip; 6837 static char *lid_type[] = { 6838 "???", /* 0 */ 6839 "5-3-buf", /* 1 */ 6840 "5-3-inode", /* 2 */ 6841 "efi", /* 3 */ 6842 "efd", /* 4 */ 6843 "iunlink", /* 5 */ 6844 "6-1-inode", /* 6 */ 6845 "6-1-buf", /* 7 */ 6846 "inode", /* 8 */ 6847 "buf", /* 9 */ 6848 "dquot", /* 10 */ 6849 NULL 6850 }; 6851 static char *li_flags[] = { 6852 "in ail", /* 0x1 */ 6853 NULL 6854 }; 6855 int count; 6856 6857 if ((mp->m_ail.ail_forw == NULL) || 6858 (mp->m_ail.ail_forw == (xfs_log_item_t *)&mp->m_ail)) { 6859 kdb_printf("AIL is empty\n"); 6860 return; 6861 } 6862 kdb_printf("AIL for mp 0x%p, oldest first\n", mp); 6863 lip = (xfs_log_item_t*)mp->m_ail.ail_forw; 6864 for (count = 0; lip; count++) { 6865 kdb_printf("[%d] type %s ", count, 6866 lid_type[lip->li_type - XFS_LI_5_3_BUF + 1]); 6867 printflags((uint)(lip->li_flags), li_flags, "flags:"); 6868 kdb_printf(" lsn %s\n ", xfs_fmtlsn(&(lip->li_lsn))); 6869 switch (lip->li_type) { 6870 case XFS_LI_BUF: 6871 xfs_buf_item_print((xfs_buf_log_item_t *)lip, 1); 6872 break; 6873 case XFS_LI_INODE: 6874 xfs_inode_item_print((xfs_inode_log_item_t *)lip, 1); 6875 break; 6876 case XFS_LI_EFI: 6877 xfs_efi_item_print((xfs_efi_log_item_t *)lip, 1); 6878 break; 6879 case XFS_LI_EFD: 6880 xfs_efd_item_print((xfs_efd_log_item_t *)lip, 1); 6881 break; 6882 case XFS_LI_DQUOT: 6883 xfs_dquot_item_print((xfs_dq_logitem_t *)lip, 1); 6884 break; 6885 case XFS_LI_QUOTAOFF: 6886 xfs_qoff_item_print((xfs_qoff_logitem_t *)lip, 1); 6887 break; 6888 default: 6889 kdb_printf("Unknown item type %d\n", lip->li_type); 6890 break; 6891 } 6892 6893 if (lip->li_ail.ail_forw == (xfs_log_item_t*)&mp->m_ail) { 6894 lip = NULL; 6895 } else { 6896 lip = lip->li_ail.ail_forw; 6897 } 6898 } 6899} 6900 6901/* 6902 * Print xfs mount structure. 6903 */ 6904static void 6905xfsidbg_xmount(xfs_mount_t *mp) 6906{ 6907 static char *xmount_flags[] = { 6908 "WSYNC", /* 0x0001 */ 6909 "INO64", /* 0x0002 */ 6910 "UNUSED_4", /* 0x0004 */ 6911 "UNUSED_8", /* 0x0008 */ 6912 "FSSHUTDOWN", /* 0x0010 */ 6913 "NOATIME", /* 0x0020 */ 6914 "RETERR", /* 0x0040 */ 6915 "NOALIGN", /* 0x0080 */ 6916 "ATTR2", /* 0x0100 */ 6917 "UNUSED_200", /* 0x0200 */ 6918 "NORECOVERY", /* 0x0400 */ 6919 "SHARED", /* 0x0800 */ 6920 "DFLT_IOSIZE", /* 0x1000 */ 6921 "OSYNCISOSYNC", /* 0x2000 */ 6922 "32BITINODES", /* 0x4000 */ 6923 "32BITINOOPT", /* 0x8000 */ 6924 "NOUUID", /* 0x10000 */ 6925 "BARRIER", /* 0x20000 */ 6926 "IDELETE", /* 0x40000 */ 6927 "SWALLOC", /* 0x80000 */ 6928 "IHASHSIZE", /* 0x100000 */ 6929 "DIRSYNC", /* 0x200000 */ 6930 "COMPAT_IOSIZE",/* 0x400000 */ 6931 NULL 6932 }; 6933 6934 static char *quota_flags[] = { 6935 "UQ", /* 0x0001 */ 6936 "UQE", /* 0x0002 */ 6937 "UQCHKD", /* 0x0004 */ 6938 "PQ", /* 0x0008 */ 6939 "GQE", /* 0x0010 */ 6940 "GQCHKD", /* 0x0020 */ 6941 "GQ", /* 0x0040 */ 6942 "UQACTV", /* 0x0080 */ 6943 "GQACTV", /* 0x0100 */ 6944 "QMAYBE", /* 0x0200 */ 6945 NULL 6946 }; 6947 6948 kdb_printf("xfs_mount at 0x%p\n", mp); 6949 kdb_printf("vfsp 0x%p tid 0x%x ail_lock 0x%p &ail 0x%p\n", 6950 XFS_MTOVFS(mp), mp->m_tid, &mp->m_ail_lock, &mp->m_ail); 6951 kdb_printf("ail_gen 0x%x &sb 0x%p\n", 6952 mp->m_ail_gen, &mp->m_sb); 6953 kdb_printf("sb_lock 0x%p sb_bp 0x%p dev 0x%s logdev 0x%s rtdev 0x%s\n", 6954 &mp->m_sb_lock, mp->m_sb_bp, 6955 mp->m_ddev_targp ? devtoname(mp->m_ddev_targp->dev) : 0, 6956 mp->m_logdev_targp ? devtoname(mp->m_logdev_targp->dev) : 0, 6957 mp->m_rtdev_targp ? devtoname(mp->m_rtdev_targp->dev) : 0); 6958 kdb_printf("bsize %d agfrotor %d xfs_rotorstep %d agirotor %d\n", 6959 mp->m_bsize, mp->m_agfrotor, xfs_rotorstep, mp->m_agirotor); 6960 kdb_printf("ihash 0x%p ihsize %d\n", 6961 mp->m_ihash, mp->m_ihsize); 6962 kdb_printf("inodes 0x%p ilock 0x%p ireclaims 0x%x\n", 6963 mp->m_inodes, &mp->m_ilock, mp->m_ireclaims); 6964 kdb_printf("readio_log 0x%x readio_blocks 0x%x ", 6965 mp->m_readio_log, mp->m_readio_blocks); 6966 kdb_printf("writeio_log 0x%x writeio_blocks 0x%x\n", 6967 mp->m_writeio_log, mp->m_writeio_blocks); 6968 kdb_printf("logbufs %d logbsize %d LOG 0x%p\n", mp->m_logbufs, 6969 mp->m_logbsize, mp->m_log); 6970 kdb_printf("rsumlevels 0x%x rsumsize 0x%x rbmip 0x%p rsumip 0x%p\n", 6971 mp->m_rsumlevels, mp->m_rsumsize, mp->m_rbmip, mp->m_rsumip); 6972 kdb_printf("rootip 0x%p\n", mp->m_rootip); 6973 kdb_printf("dircook_elog %d blkbit_log %d blkbb_log %d agno_log %d\n", 6974 mp->m_dircook_elog, mp->m_blkbit_log, mp->m_blkbb_log, 6975 mp->m_agno_log); 6976 kdb_printf("agino_log %d nreadaheads %d inode cluster size %d\n", 6977 mp->m_agino_log, mp->m_nreadaheads, 6978 mp->m_inode_cluster_size); 6979 kdb_printf("blockmask 0x%x blockwsize 0x%x blockwmask 0x%x\n", 6980 mp->m_blockmask, mp->m_blockwsize, mp->m_blockwmask); 6981 kdb_printf("alloc_mxr[lf,nd] %d %d alloc_mnr[lf,nd] %d %d\n", 6982 mp->m_alloc_mxr[0], mp->m_alloc_mxr[1], 6983 mp->m_alloc_mnr[0], mp->m_alloc_mnr[1]); 6984 kdb_printf("bmap_dmxr[lfnr,ndnr] %d %d bmap_dmnr[lfnr,ndnr] %d %d\n", 6985 mp->m_bmap_dmxr[0], mp->m_bmap_dmxr[1], 6986 mp->m_bmap_dmnr[0], mp->m_bmap_dmnr[1]); 6987 kdb_printf("inobt_mxr[lf,nd] %d %d inobt_mnr[lf,nd] %d %d\n", 6988 mp->m_inobt_mxr[0], mp->m_inobt_mxr[1], 6989 mp->m_inobt_mnr[0], mp->m_inobt_mnr[1]); 6990 kdb_printf("ag_maxlevels %d bm_maxlevels[d,a] %d %d in_maxlevels %d\n", 6991 mp->m_ag_maxlevels, mp->m_bm_maxlevels[0], 6992 mp->m_bm_maxlevels[1], mp->m_in_maxlevels); 6993 kdb_printf("perag 0x%p &peraglock 0x%p &growlock 0x%p\n", 6994 mp->m_perag, &mp->m_peraglock, &mp->m_growlock); 6995 printflags(mp->m_flags, xmount_flags,"flags"); 6996 kdb_printf("ialloc_inos %d ialloc_blks %d litino %d\n", 6997 mp->m_ialloc_inos, mp->m_ialloc_blks, mp->m_litino); 6998 kdb_printf("dir_node_ents %u attr_node_ents %u\n", 6999 mp->m_dir_node_ents, mp->m_attr_node_ents); 7000 kdb_printf("attroffset %d maxicount %Ld inoalign_mask %d\n", 7001 mp->m_attroffset, mp->m_maxicount, mp->m_inoalign_mask); 7002 kdb_printf("resblks %Ld resblks_avail %Ld\n", mp->m_resblks, 7003 mp->m_resblks_avail); 7004#if XFS_BIG_INUMS 7005 kdb_printf(" inoadd %llx\n", (unsigned long long) mp->m_inoadd); 7006#else 7007 kdb_printf("\n"); 7008#endif 7009 if (mp->m_quotainfo) 7010 kdb_printf("quotainfo 0x%p (uqip = 0x%p, gqip = 0x%p)\n", 7011 mp->m_quotainfo, 7012 mp->m_quotainfo->qi_uquotaip, 7013 mp->m_quotainfo->qi_gquotaip); 7014 else 7015 kdb_printf("quotainfo NULL\n"); 7016 printflags(mp->m_qflags, quota_flags,"quotaflags"); 7017 kdb_printf("\n"); 7018 kdb_printf("dalign %d swidth %d sinoalign %d attr_magicpct %d dir_magicpct %d\n", 7019 mp->m_dalign, mp->m_swidth, mp->m_sinoalign, 7020 mp->m_attr_magicpct, mp->m_dir_magicpct); 7021 kdb_printf("mk_sharedro %d inode_quiesce %d sectbb_log %d\n", 7022 mp->m_mk_sharedro, mp->m_inode_quiesce, mp->m_sectbb_log); 7023 kdb_printf("dirversion %d dirblkfsbs %d &dirops 0x%p\n", 7024 mp->m_dirversion, mp->m_dirblkfsbs, &mp->m_dirops); 7025 kdb_printf("dirblksize %d dirdatablk 0x%Lx dirleafblk 0x%Lx dirfreeblk 0x%Lx\n", 7026 mp->m_dirblksize, 7027 (xfs_dfiloff_t)mp->m_dirdatablk, 7028 (xfs_dfiloff_t)mp->m_dirleafblk, 7029 (xfs_dfiloff_t)mp->m_dirfreeblk); 7030 kdb_printf("chsize %d chash 0x%p\n", 7031 mp->m_chsize, mp->m_chash); 7032 if (mp->m_fsname != NULL) 7033 kdb_printf("mountpoint \"%s\"\n", mp->m_fsname); 7034 else 7035 kdb_printf("No name!!!\n"); 7036 7037} 7038 7039static void 7040xfsidbg_xihash(xfs_mount_t *mp) 7041{ 7042 xfs_ihash_t *ih; 7043 int i; 7044 int j; 7045 int total; 7046 int numzeros; 7047 xfs_inode_t *ip; 7048 int *hist; 7049 int hist_bytes = mp->m_ihsize * sizeof(int); 7050 int hist2[21]; 7051 7052 hist = (int *) kmem_alloc(hist_bytes, KM_SLEEP); 7053 7054 if (hist == NULL) { 7055 kdb_printf("xfsidbg_xihash: kmalloc(%d) failed!\n", 7056 hist_bytes); 7057 return; 7058 } 7059 7060 for (i = 0; i < mp->m_ihsize; i++) { 7061 ih = mp->m_ihash + i; 7062 j = 0; 7063 for (ip = ih->ih_next; ip != NULL; ip = ip->i_next) 7064 j++; 7065 hist[i] = j; 7066 } 7067 7068 numzeros = total = 0; 7069 7070 for (i = 0; i < 21; i++) 7071 hist2[i] = 0; 7072 7073 for (i = 0; i < mp->m_ihsize; i++) { 7074 kdb_printf("%d ", hist[i]); 7075 total += hist[i]; 7076 numzeros += hist[i] == 0 ? 1 : 0; 7077 if (hist[i] > 20) 7078 j = 20; 7079 else 7080 j = hist[i]; 7081 7082 if (! (j <= 20)) { 7083 kdb_printf("xfsidbg_xihash: (j > 20)/%d @ line # %d\n", 7084 j, __LINE__); 7085 return; 7086 } 7087 7088 hist2[j]++; 7089 } 7090 7091 kdb_printf("\n"); 7092 7093 kdb_printf("total inodes = %d, average length = %d, adjusted average = %d \n", 7094 total, total / mp->m_ihsize, 7095 total / (mp->m_ihsize - numzeros)); 7096 7097 for (i = 0; i < 21; i++) { 7098 kdb_printf("%d - %d , ", i, hist2[i]); 7099 } 7100 kdb_printf("\n"); 7101 kmem_free(hist, hist_bytes); 7102} 7103 7104/* 7105 * Command to print xfs inodes: kp xnode <addr> 7106 */ 7107static void 7108xfsidbg_xnode(xfs_inode_t *ip) 7109{ 7110 static char *tab_flags[] = { 7111 "grio", /* XFS_IGRIO */ 7112 "uiosize", /* XFS_IUIOSZ */ 7113 "quiesce", /* XFS_IQUIESCE */ 7114 "reclaim", /* XFS_IRECLAIM */ 7115 "stale", /* XFS_ISTALE */ 7116 NULL 7117 }; 7118 7119 kdb_printf("hash 0x%p next 0x%p prevp 0x%p mount 0x%p\n", 7120 ip->i_hash, 7121 ip->i_next, 7122 ip->i_prevp, 7123 ip->i_mount); 7124 kdb_printf("mnext 0x%p mprev 0x%p vnode 0x%p \n", 7125 ip->i_mnext, 7126 ip->i_mprev, 7127 XFS_ITOV_NULL(ip)); 7128 kdb_printf("dev %s ino %s\n", 7129 devtoname(ip->i_mount->m_dev), 7130 xfs_fmtino(ip->i_ino, ip->i_mount)); 7131 kdb_printf("blkno 0x%llx len 0x%x boffset 0x%x\n", 7132 (long long) ip->i_blkno, 7133 ip->i_len, 7134 ip->i_boffset); 7135 kdb_printf("transp 0x%p &itemp 0x%p\n", 7136 ip->i_transp, 7137 ip->i_itemp); 7138 kdb_printf("&lock 0x%p &iolock 0x%p ", 7139 &ip->i_lock, 7140 &ip->i_iolock); 7141 kdb_printf("&flock 0x%p (%d) pincount 0x%x\n", 7142 &ip->i_flock, valusema(&ip->i_flock), 7143 xfs_ipincount(ip)); 7144 kdb_printf("udquotp 0x%p gdquotp 0x%p\n", 7145 ip->i_udquot, ip->i_gdquot); 7146 kdb_printf("new_size %Ld\n", ip->i_iocore.io_new_size); 7147 printflags((int)ip->i_flags, tab_flags, "flags"); 7148 kdb_printf("\n"); 7149 kdb_printf("update_core %d update size %d\n", 7150 (int)(ip->i_update_core), (int) ip->i_update_size); 7151 kdb_printf("gen 0x%x delayed blks %d", 7152 ip->i_gen, 7153 ip->i_delayed_blks); 7154#ifdef XFS_BMAP_TRACE 7155 qprintf(" bmap_trace 0x%p\n", ip->i_xtrace); 7156#endif 7157#ifdef XFS_BMBT_TRACE 7158 qprintf(" bmbt trace 0x%p\n", ip->i_btrace); 7159#endif 7160#ifdef XFS_RW_TRACE 7161 qprintf(" rw trace 0x%p\n", ip->i_rwtrace); 7162#endif 7163#ifdef XFS_ILOCK_TRACE 7164 qprintf(" ilock trace 0x%p\n", ip->i_lock_trace); 7165#endif 7166#ifdef XFS_DIR2_TRACE 7167 qprintf(" dir trace 0x%p\n", ip->i_dir_trace); 7168#endif 7169 kdb_printf("\n"); 7170 kdb_printf("chash 0x%p cnext 0x%p cprev 0x%p\n", 7171 ip->i_chash, 7172 ip->i_cnext, 7173 ip->i_cprev); 7174 xfs_xnode_fork("data", &ip->i_df); 7175 xfs_xnode_fork("attr", ip->i_afp); 7176 kdb_printf("\n"); 7177 xfs_prdinode_core(&ip->i_d); 7178} 7179 7180static void 7181xfsidbg_xcore(xfs_iocore_t *io) 7182{ 7183 kdb_printf("io_obj 0x%p io_flags 0x%x io_mount 0x%p\n", 7184 io->io_obj, io->io_flags, io->io_mount); 7185 kdb_printf("new_size %Lx\n", io->io_new_size); 7186} 7187 7188/* 7189 * Command to print xfs inode cluster hash table: kp xchash <addr> 7190 */ 7191static void 7192xfsidbg_xchash(xfs_mount_t *mp) 7193{ 7194 int i; 7195 xfs_chash_t *ch; 7196 7197 kdb_printf("m_chash 0x%p size %d\n", 7198 mp->m_chash, mp->m_chsize); 7199 for (i = 0; i < mp->m_chsize; i++) { 7200 ch = mp->m_chash + i; 7201 kdb_printf("[%3d] ch 0x%p chashlist 0x%p\n", i, ch, ch->ch_list); 7202 xfsidbg_xchashlist(ch->ch_list); 7203 } 7204} 7205 7206/* 7207 * Command to print xfs inode cluster hash list: kp xchashlist <addr> 7208 */ 7209static void 7210xfsidbg_xchashlist(xfs_chashlist_t *chl) 7211{ 7212 xfs_inode_t *ip; 7213 7214 while (chl != NULL) { 7215 kdb_printf("hashlist inode 0x%p blkno %lld buf 0x%p", 7216 chl->chl_ip, (long long) chl->chl_blkno, chl->chl_buf); 7217 7218 kdb_printf("\n"); 7219 7220 /* print inodes on chashlist */ 7221 ip = chl->chl_ip; 7222 do { 7223 kdb_printf("0x%p ", ip); 7224 ip = ip->i_cnext; 7225 } while (ip != chl->chl_ip); 7226 kdb_printf("\n"); 7227 7228 chl=chl->chl_next; 7229 } 7230} 7231 7232/* 7233 * Print xfs per-ag data structures for filesystem. 7234 */ 7235static void 7236xfsidbg_xperag(xfs_mount_t *mp) 7237{ 7238 xfs_agnumber_t agno; 7239 xfs_perag_t *pag; 7240 int busy; 7241 7242 pag = mp->m_perag; 7243 for (agno = 0; agno < mp->m_sb.sb_agcount; agno++, pag++) { 7244 kdb_printf("ag %d f_init %d i_init %d\n", 7245 agno, pag->pagf_init, pag->pagi_init); 7246 if (pag->pagf_init) 7247 kdb_printf( 7248 " f_levels[b,c] %d,%d f_flcount %d f_freeblks %d f_longest %d\n" 7249 " f__metadata %d\n", 7250 pag->pagf_levels[XFS_BTNUM_BNOi], 7251 pag->pagf_levels[XFS_BTNUM_CNTi], 7252 pag->pagf_flcount, pag->pagf_freeblks, 7253 pag->pagf_longest, pag->pagf_metadata); 7254 if (pag->pagi_init) 7255 kdb_printf(" i_freecount %d i_inodeok %d\n", 7256 pag->pagi_freecount, pag->pagi_inodeok); 7257 if (pag->pagf_init) { 7258 for (busy = 0; busy < XFS_PAGB_NUM_SLOTS; busy++) { 7259 if (pag->pagb_list[busy].busy_length != 0) { 7260 kdb_printf( 7261 " %04d: start %d length %d tp 0x%p\n", 7262 busy, 7263 pag->pagb_list[busy].busy_start, 7264 pag->pagb_list[busy].busy_length, 7265 pag->pagb_list[busy].busy_tp); 7266 } 7267 } 7268 } 7269 } 7270} 7271 7272#ifdef CONFIG_XFS_QUOTA 7273static void 7274xfsidbg_xqm(void) 7275{ 7276 if (xfs_Gqm == NULL) { 7277 kdb_printf("NULL XQM!!\n"); 7278 return; 7279 } 7280 7281 kdb_printf("usrhtab 0x%p grphtab 0x%p ndqfree 0x%x hashmask 0x%x\n", 7282 xfs_Gqm->qm_usr_dqhtable, 7283 xfs_Gqm->qm_grp_dqhtable, 7284 xfs_Gqm->qm_dqfreelist.qh_nelems, 7285 xfs_Gqm->qm_dqhashmask); 7286 kdb_printf("&freelist 0x%p, totaldquots 0x%x nrefs 0x%x\n", 7287 &xfs_Gqm->qm_dqfreelist, 7288 atomic_read(&xfs_Gqm->qm_totaldquots), 7289 xfs_Gqm->qm_nrefs); 7290} 7291#endif 7292 7293static void 7294xfsidbg_xqm_diskdq(xfs_disk_dquot_t *d) 7295{ 7296 kdb_printf("magic 0x%x\tversion 0x%x\tID 0x%x (%d)\t\n", 7297 be16_to_cpu(d->d_magic), d->d_version, 7298 be32_to_cpu(d->d_id), be32_to_cpu(d->d_id)); 7299 kdb_printf("bhard 0x%llx\tbsoft 0x%llx\tihard 0x%llx\tisoft 0x%llx\n", 7300 be64_to_cpu(d->d_blk_hardlimit), 7301 be64_to_cpu(d->d_blk_softlimit), 7302 be64_to_cpu(d->d_ino_hardlimit), 7303 be64_to_cpu(d->d_ino_softlimit)); 7304 kdb_printf("bcount 0x%llx icount 0x%llx\n", 7305 be64_to_cpu(d->d_bcount), 7306 be64_to_cpu(d->d_icount)); 7307 kdb_printf("btimer 0x%x itimer 0x%x \n", 7308 be32_to_cpu(d->d_btimer), 7309 be32_to_cpu(d->d_itimer)); 7310} 7311 7312static char *xdq_flags[] = { 7313 "USER", /* XFS_DQ_USER */ 7314 "PROJ", /* XFS_DQ_PROJ */ 7315 "GROUP", /* XFS_DQ_GROUP */ 7316 "FLKD", /* XFS_DQ_FLOCKED */ 7317 "DIRTY", /* XFS_DQ_DIRTY */ 7318 "WANT", /* XFS_DQ_WANT */ 7319 "INACT", /* XFS_DQ_INACTIVE */ 7320 "MARKER", /* XFS_DQ_MARKER */ 7321 NULL 7322}; 7323 7324static void 7325xfsidbg_xqm_dquot(xfs_dquot_t *dqp) 7326{ 7327 kdb_printf("mount 0x%p hash 0x%p gdquotp 0x%p HL_next 0x%p HL_prevp 0x%p\n", 7328 dqp->q_mount, 7329 dqp->q_hash, 7330 dqp->q_gdquot, 7331 dqp->HL_NEXT, 7332 dqp->HL_PREVP); 7333 kdb_printf("MPL_next 0x%p MPL_prevp 0x%p FL_next 0x%p FL_prev 0x%p\n", 7334 dqp->MPL_NEXT, 7335 dqp->MPL_PREVP, 7336 dqp->dq_flnext, 7337 dqp->dq_flprev); 7338 7339 kdb_printf("nrefs 0x%x blkno 0x%llx boffset 0x%x ", dqp->q_nrefs, 7340 (unsigned long long)dqp->q_blkno, dqp->q_bufoffset); 7341 printflags(dqp->dq_flags, xdq_flags, "flags:"); 7342 kdb_printf("res_bcount %llu res_icount %llu res_rtbcount %llu\n", 7343 (unsigned long long)dqp->q_res_bcount, 7344 (unsigned long long)dqp->q_res_icount, 7345 (unsigned long long)dqp->q_res_rtbcount); 7346 kdb_printf("qlock 0x%p flock 0x%p (%s) pincount 0x%x\n", 7347 &dqp->q_qlock, 7348 &dqp->q_flock, 7349 (valusema(&dqp->q_flock) <= 0) ? "LCK" : "UNLKD", 7350 dqp->q_pincount); 7351#ifdef XFS_DQUOT_TRACE 7352 qprintf("dqtrace 0x%p\n", dqp->q_trace); 7353#endif 7354 kdb_printf("disk-dquot 0x%p\n", &dqp->q_core); 7355 xfsidbg_xqm_diskdq(&dqp->q_core); 7356 7357} 7358 7359 7360#define XQMIDBG_LIST_PRINT(l, NXT) \ 7361{ \ 7362 xfs_dquot_t *dqp;\ 7363 int i = 0; \ 7364 kdb_printf("[#%d dquots]\n", (int) (l)->qh_nelems); \ 7365 for (dqp = (l)->qh_next; dqp != NULL; dqp = dqp->NXT) {\ 7366 kdb_printf( \ 7367 "\t%d. [0x%p] \"%d (%s)\"\t blks = %d, inos = %d refs = %d\n", \ 7368 ++i, dqp, (int) be32_to_cpu(dqp->q_core.d_id), \ 7369 DQFLAGTO_TYPESTR(dqp), \ 7370 (int) be64_to_cpu(dqp->q_core.d_bcount), \ 7371 (int) be64_to_cpu(dqp->q_core.d_icount), \ 7372 (int) dqp->q_nrefs); }\ 7373 kdb_printf("\n"); \ 7374} 7375 7376static void 7377xfsidbg_xqm_dqattached_inos(xfs_mount_t *mp) 7378{ 7379 xfs_inode_t *ip; 7380 int n = 0; 7381 7382 ip = mp->m_inodes; 7383 do { 7384 if (ip->i_mount == NULL) { 7385 ip = ip->i_mnext; 7386 continue; 7387 } 7388 if (ip->i_udquot || ip->i_gdquot) { 7389 n++; 7390 kdb_printf("inode = 0x%p, ino %d: udq 0x%p, gdq 0x%p\n", 7391 ip, (int)ip->i_ino, ip->i_udquot, ip->i_gdquot); 7392 } 7393 ip = ip->i_mnext; 7394 } while (ip != mp->m_inodes); 7395 kdb_printf("\nNumber of inodes with dquots attached: %d\n", n); 7396} 7397 7398#ifdef CONFIG_XFS_QUOTA 7399static void 7400xfsidbg_xqm_freelist_print(xfs_frlist_t *qlist, char *title) 7401{ 7402 xfs_dquot_t *dq; 7403 int i = 0; 7404 kdb_printf("%s (#%d)\n", title, (int) qlist->qh_nelems); 7405 FOREACH_DQUOT_IN_FREELIST(dq, qlist) { 7406 kdb_printf("\t%d.\t\"%d (%s:0x%p)\"\t bcnt = %d, icnt = %d " 7407 "refs = %d\n", 7408 ++i, (int) be32_to_cpu(dq->q_core.d_id), 7409 DQFLAGTO_TYPESTR(dq), dq, 7410 (int) be64_to_cpu(dq->q_core.d_bcount), 7411 (int) be64_to_cpu(dq->q_core.d_icount), 7412 (int) dq->q_nrefs); 7413 } 7414} 7415 7416static void 7417xfsidbg_xqm_freelist(void) 7418{ 7419 if (xfs_Gqm) { 7420 xfsidbg_xqm_freelist_print(&(xfs_Gqm->qm_dqfreelist), "Freelist"); 7421 } else 7422 kdb_printf("NULL XQM!!\n"); 7423} 7424 7425static void 7426xfsidbg_xqm_htab(void) 7427{ 7428 int i; 7429 xfs_dqhash_t *h; 7430 7431 if (xfs_Gqm == NULL) { 7432 kdb_printf("NULL XQM!!\n"); 7433 return; 7434 } 7435 for (i = 0; i <= xfs_Gqm->qm_dqhashmask; i++) { 7436 h = &xfs_Gqm->qm_usr_dqhtable[i]; 7437 if (h->qh_next) { 7438 kdb_printf("USR %d: ", i); 7439 XQMIDBG_LIST_PRINT(h, HL_NEXT); 7440 } 7441 } 7442 for (i = 0; i <= xfs_Gqm->qm_dqhashmask; i++) { 7443 h = &xfs_Gqm->qm_grp_dqhtable[i]; 7444 if (h->qh_next) { 7445 kdb_printf("GRP/PRJ %d: ", i); 7446 XQMIDBG_LIST_PRINT(h, HL_NEXT); 7447 } 7448 } 7449} 7450#endif 7451 7452#ifdef XFS_DQUOT_TRACE 7453static int 7454xfsidbg_xqm_pr_dqentry(ktrace_entry_t *ktep) 7455{ 7456 if ((__psint_t)ktep->val[0] == 0) 7457 return 0; 7458 switch ((__psint_t)ktep->val[0]) { 7459 case DQUOT_KTRACE_ENTRY: 7460 qprintf("[%ld] %s\t", 7461 (long)ktep->val[12], /* pid */ 7462 (char *)ktep->val[1]); 7463 printflags((__psint_t)ktep->val[3], xdq_flags,"flgs "); 7464 qprintf("\nnrefs = %u, " 7465 "flags = 0x%x, " 7466 "id = %d, " 7467 "res_bc = 0x%x\n" 7468 "bcnt = 0x%x [0x%x | 0x%x], " 7469 "icnt = 0x%x [0x%x | 0x%x]\n" 7470 "@ %ld\n", 7471 (unsigned int)(long)ktep->val[2], /* nrefs */ 7472 (unsigned int)(long)ktep->val[3], /* flags */ 7473 (unsigned int)(long)ktep->val[11], /* ID */ 7474 (unsigned int)(long)ktep->val[4], /* res_bc */ 7475 (unsigned int)(long)ktep->val[5], /* bcnt */ 7476 (unsigned int)(long)ktep->val[8], /* bsoft */ 7477 (unsigned int)(long)ktep->val[7], /* bhard */ 7478 (unsigned int)(long)ktep->val[6], /* icnt */ 7479 (unsigned int)(long)ktep->val[10], /* isoft */ 7480 (unsigned int)(long)ktep->val[9], /* ihard */ 7481 (long) ktep->val[13] /* time */ 7482 ); 7483 break; 7484 7485 default: 7486 qprintf("unknown dqtrace record\n"); 7487 break; 7488 } 7489 return (1); 7490} 7491 7492void 7493xfsidbg_xqm_dqtrace(xfs_dquot_t *dqp) 7494{ 7495 ktrace_entry_t *ktep; 7496 ktrace_snap_t kts; 7497 7498 if (dqp->q_trace == NULL) { 7499 qprintf("The xfs dquot trace buffer is not initialized\n"); 7500 return; 7501 } 7502 qprintf("xdqtrace dquot 0x%p\n", dqp); 7503 7504 ktep = ktrace_first(dqp->q_trace, &kts); 7505 while (ktep != NULL) { 7506 if (xfsidbg_xqm_pr_dqentry(ktep)) 7507 qprintf("---------------------------------\n"); 7508 ktep = ktrace_next(dqp->q_trace, &kts); 7509 } 7510} 7511#endif 7512 7513static void 7514xfsidbg_xqm_mplist(xfs_mount_t *mp) 7515{ 7516 if (mp->m_quotainfo == NULL) { 7517 kdb_printf("NULL quotainfo\n"); 7518 return; 7519 } 7520 7521 XQMIDBG_LIST_PRINT(&(mp->m_quotainfo->qi_dqlist), MPL_NEXT); 7522 7523} 7524 7525 7526static void 7527xfsidbg_xqm_qinfo(xfs_mount_t *mp) 7528{ 7529 if (mp == NULL || mp->m_quotainfo == NULL) { 7530 kdb_printf("NULL quotainfo\n"); 7531 return; 7532 } 7533 7534 kdb_printf("uqip 0x%p, gqip 0x%p, &pinlock 0x%p &dqlist 0x%p\n", 7535 mp->m_quotainfo->qi_uquotaip, 7536 mp->m_quotainfo->qi_gquotaip, 7537 &mp->m_quotainfo->qi_pinlock, 7538 &mp->m_quotainfo->qi_dqlist); 7539 7540 kdb_printf("btmlimit 0x%x, itmlimit 0x%x, RTbtmlim 0x%x\n", 7541 (int)mp->m_quotainfo->qi_btimelimit, 7542 (int)mp->m_quotainfo->qi_itimelimit, 7543 (int)mp->m_quotainfo->qi_rtbtimelimit); 7544 7545 kdb_printf("bwarnlim 0x%x, iwarnlim 0x%x, RTbwarnlim 0x%x\n", 7546 (int)mp->m_quotainfo->qi_bwarnlimit, 7547 (int)mp->m_quotainfo->qi_iwarnlimit, 7548 (int)mp->m_quotainfo->qi_rtbwarnlimit); 7549 7550 kdb_printf("nreclaims %d, &qofflock 0x%p, chunklen 0x%x, dqperchunk 0x%x\n", 7551 (int)mp->m_quotainfo->qi_dqreclaims, 7552 &mp->m_quotainfo->qi_quotaofflock, 7553 (int)mp->m_quotainfo->qi_dqchunklen, 7554 (int)mp->m_quotainfo->qi_dqperchunk); 7555} 7556 7557static void 7558xfsidbg_xqm_tpdqinfo(xfs_trans_t *tp) 7559{ 7560 xfs_dqtrx_t *qa, *q; 7561 int i,j; 7562 7563 kdb_printf("dqinfo 0x%p\n", tp->t_dqinfo); 7564 if (! tp->t_dqinfo) 7565 return; 7566 kdb_printf("USR: \n"); 7567 qa = tp->t_dqinfo->dqa_usrdquots; 7568 for (j = 0; j < 2; j++) { 7569 for (i = 0; i < XFS_QM_TRANS_MAXDQS; i++) { 7570 if (qa[i].qt_dquot == NULL) 7571 break; 7572 q = &qa[i]; 7573 kdb_printf( 7574 "\"%d\"[0x%p]: bres %d, bres-used %d, bdelta %d, del-delta %d, icnt-delta %d\n", 7575 (int) be32_to_cpu(q->qt_dquot->q_core.d_id), 7576 q->qt_dquot, 7577 (int) q->qt_blk_res, 7578 (int) q->qt_blk_res_used, 7579 (int) q->qt_bcount_delta, 7580 (int) q->qt_delbcnt_delta, 7581 (int) q->qt_icount_delta); 7582 } 7583 if (j == 0) { 7584 qa = tp->t_dqinfo->dqa_grpdquots; 7585 kdb_printf("GRP/PRJ: \n"); 7586 } 7587 } 7588} 7589 7590/* 7591 * Print xfs superblock. 7592 */ 7593static void 7594xfsidbg_xsb(xfs_sb_t *sbp) 7595{ 7596 kdb_printf("magicnum 0x%x blocksize 0x%x dblocks %Ld rblocks %Ld\n", 7597 sbp->sb_magicnum, sbp->sb_blocksize, 7598 sbp->sb_dblocks, sbp->sb_rblocks); 7599 kdb_printf("rextents %Ld uuid %s logstart %s\n", 7600 sbp->sb_rextents, xfs_fmtuuid(&sbp->sb_uuid), 7601 xfs_fmtfsblock(sbp->sb_logstart, NULL)); 7602 kdb_printf("rootino %s ", xfs_fmtino(sbp->sb_rootino, NULL)); 7603 kdb_printf("rbmino %s ", xfs_fmtino(sbp->sb_rbmino, NULL)); 7604 kdb_printf("rsumino %s\n", xfs_fmtino(sbp->sb_rsumino, NULL)); 7605 kdb_printf("rextsize 0x%x agblocks 0x%x agcount 0x%x rbmblocks 0x%x\n", 7606 sbp->sb_rextsize, sbp->sb_agblocks, sbp->sb_agcount, 7607 sbp->sb_rbmblocks); 7608 kdb_printf("logblocks 0x%x versionnum 0x%x sectsize 0x%x inodesize 0x%x\n", 7609 sbp->sb_logblocks, sbp->sb_versionnum, sbp->sb_sectsize, 7610 sbp->sb_inodesize); 7611 kdb_printf("inopblock 0x%x blocklog 0x%x sectlog 0x%x inodelog 0x%x\n", 7612 sbp->sb_inopblock, sbp->sb_blocklog, sbp->sb_sectlog, 7613 sbp->sb_inodelog); 7614 kdb_printf("inopblog %d agblklog %d rextslog %d inprogress %d imax_pct %d\n", 7615 sbp->sb_inopblog, sbp->sb_agblklog, sbp->sb_rextslog, 7616 sbp->sb_inprogress, sbp->sb_imax_pct); 7617 kdb_printf("icount %Lx ifree %Lx fdblocks %Lx frextents %Lx\n", 7618 sbp->sb_icount, sbp->sb_ifree, 7619 sbp->sb_fdblocks, sbp->sb_frextents); 7620 kdb_printf("uquotino %s ", xfs_fmtino(sbp->sb_uquotino, NULL)); 7621 kdb_printf("gquotino %s ", xfs_fmtino(sbp->sb_gquotino, NULL)); 7622 kdb_printf("qflags 0x%x flags 0x%x shared_vn %d inoaligmt %d\n", 7623 sbp->sb_qflags, sbp->sb_flags, sbp->sb_shared_vn, 7624 sbp->sb_inoalignmt); 7625 kdb_printf("unit %d width %d dirblklog %d\n", 7626 sbp->sb_unit, sbp->sb_width, sbp->sb_dirblklog); 7627 kdb_printf("log sunit %d\n", sbp->sb_logsunit); 7628} 7629 7630static void 7631xfsidbg_xsb_convert(xfs_sb_t *sbp) 7632{ 7633 xfs_sb_t sb; 7634 7635 xfs_xlatesb(sbp, &sb, 1, XFS_SB_ALL_BITS); 7636 7637 kdb_printf("<converted>\n"); 7638 xfsidbg_xsb(&sb); 7639} 7640 7641/* 7642 * Print out an XFS transaction structure. Print summaries for 7643 * each of the items. 7644 */ 7645static void 7646xfsidbg_xtp(xfs_trans_t *tp) 7647{ 7648 xfs_log_item_chunk_t *licp; 7649 xfs_log_item_desc_t *lidp; 7650 xfs_log_busy_chunk_t *lbcp; 7651 int i; 7652 int chunk; 7653 static char *xtp_flags[] = { 7654 "dirty", /* 0x1 */ 7655 "sb_dirty", /* 0x2 */ 7656 "perm_log_res", /* 0x4 */ 7657 "sync", /* 0x08 */ 7658 "dq_dirty", /* 0x10 */ 7659 NULL 7660 }; 7661 static char *lid_flags[] = { 7662 "dirty", /* 0x1 */ 7663 "pinned", /* 0x2 */ 7664 "sync unlock", /* 0x4 */ 7665 "buf stale", /* 0x8 */ 7666 NULL 7667 }; 7668 7669 kdb_printf("tp 0x%p type ", tp); 7670 xfsidbg_print_trans_type(tp->t_type); 7671 kdb_printf(" mount 0x%p\n", tp->t_mountp); 7672 kdb_printf("flags "); 7673 printflags(tp->t_flags, xtp_flags,"xtp"); 7674 kdb_printf("\n"); 7675 kdb_printf("callback 0x%p forw 0x%p back 0x%p\n", 7676 &tp->t_logcb, tp->t_forw, tp->t_back); 7677 kdb_printf("log res %d block res %d block res used %d\n", 7678 tp->t_log_res, tp->t_blk_res, tp->t_blk_res_used); 7679 kdb_printf("rt res %d rt res used %d\n", tp->t_rtx_res, 7680 tp->t_rtx_res_used); 7681 kdb_printf("ticket 0x%lx lsn %s commit_lsn %s\n", 7682 (unsigned long) tp->t_ticket, 7683 xfs_fmtlsn(&tp->t_lsn), 7684 xfs_fmtlsn(&tp->t_commit_lsn)); 7685 kdb_printf("callback 0x%p callarg 0x%p\n", 7686 tp->t_callback, tp->t_callarg); 7687 kdb_printf("icount delta %ld ifree delta %ld\n", 7688 tp->t_icount_delta, tp->t_ifree_delta); 7689 kdb_printf("blocks delta %ld res blocks delta %ld\n", 7690 tp->t_fdblocks_delta, tp->t_res_fdblocks_delta); 7691 kdb_printf("rt delta %ld res rt delta %ld\n", 7692 tp->t_frextents_delta, tp->t_res_frextents_delta); 7693 kdb_printf("ag freeblks delta %ld ag flist delta %ld ag btree delta %ld\n", 7694 tp->t_ag_freeblks_delta, tp->t_ag_flist_delta, 7695 tp->t_ag_btree_delta); 7696 kdb_printf("dblocks delta %ld agcount delta %ld imaxpct delta %ld\n", 7697 tp->t_dblocks_delta, tp->t_agcount_delta, tp->t_imaxpct_delta); 7698 kdb_printf("rextsize delta %ld rbmblocks delta %ld\n", 7699 tp->t_rextsize_delta, tp->t_rbmblocks_delta); 7700 kdb_printf("rblocks delta %ld rextents delta %ld rextslog delta %ld\n", 7701 tp->t_rblocks_delta, tp->t_rextents_delta, 7702 tp->t_rextslog_delta); 7703 kdb_printf("dqinfo 0x%p\n", tp->t_dqinfo); 7704 kdb_printf("log items:\n"); 7705 licp = &tp->t_items; 7706 chunk = 0; 7707 while (licp != NULL) { 7708 if (XFS_LIC_ARE_ALL_FREE(licp)) { 7709 licp = licp->lic_next; 7710 chunk++; 7711 continue; 7712 } 7713 for (i = 0; i < licp->lic_unused; i++) { 7714 if (XFS_LIC_ISFREE(licp, i)) { 7715 continue; 7716 } 7717 7718 lidp = XFS_LIC_SLOT(licp, i); 7719 kdb_printf("\n"); 7720 kdb_printf("chunk %d index %d item 0x%p size %d\n", 7721 chunk, i, lidp->lid_item, lidp->lid_size); 7722 kdb_printf("flags "); 7723 printflags(lidp->lid_flags, lid_flags,"lic"); 7724 kdb_printf("\n"); 7725 xfsidbg_xlogitem(lidp->lid_item); 7726 } 7727 chunk++; 7728 licp = licp->lic_next; 7729 } 7730 7731 kdb_printf("log busy free %d, list:\n", tp->t_busy_free); 7732 lbcp = &tp->t_busy; 7733 chunk = 0; 7734 while (lbcp != NULL) { 7735 kdb_printf("Chunk %d at 0x%p next 0x%p free 0x%08x unused %d\n", 7736 chunk, lbcp, lbcp->lbc_next, lbcp->lbc_free, 7737 lbcp->lbc_unused); 7738 for (i = 0; i < XFS_LBC_NUM_SLOTS; i++) { 7739 kdb_printf(" %02d: ag %d idx %d\n", 7740 i, 7741 lbcp->lbc_busy[i].lbc_ag, 7742 lbcp->lbc_busy[i].lbc_idx); 7743 } 7744 lbcp = lbcp->lbc_next; 7745 } 7746} 7747 7748static void 7749xfsidbg_xtrans_res( 7750 xfs_mount_t *mp) 7751{ 7752 xfs_trans_reservations_t *xtrp; 7753 7754 xtrp = &mp->m_reservations; 7755 kdb_printf("write: %d\ttruncate: %d\trename: %d\n", 7756 xtrp->tr_write, xtrp->tr_itruncate, xtrp->tr_rename); 7757 kdb_printf("link: %d\tremove: %d\tsymlink: %d\n", 7758 xtrp->tr_link, xtrp->tr_remove, xtrp->tr_symlink); 7759 kdb_printf("create: %d\tmkdir: %d\tifree: %d\n", 7760 xtrp->tr_create, xtrp->tr_mkdir, xtrp->tr_ifree); 7761 kdb_printf("ichange: %d\tgrowdata: %d\tswrite: %d\n", 7762 xtrp->tr_ichange, xtrp->tr_growdata, xtrp->tr_swrite); 7763 kdb_printf("addafork: %d\twriteid: %d\tattrinval: %d\n", 7764 xtrp->tr_addafork, xtrp->tr_writeid, xtrp->tr_attrinval); 7765 kdb_printf("attrset: %d\tattrrm: %d\tclearagi: %d\n", 7766 xtrp->tr_attrset, xtrp->tr_attrrm, xtrp->tr_clearagi); 7767 kdb_printf("growrtalloc: %d\tgrowrtzero: %d\tgrowrtfree: %d\n", 7768 xtrp->tr_growrtalloc, xtrp->tr_growrtzero, xtrp->tr_growrtfree); 7769} 7770