sys/gnu/fs/xfs/xfsidbg.c

   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
  70 static void     xfsidbg_xalatrace(int);
  71 static void     xfsidbg_xalbtrace(xfs_agblock_t);
  72 static void     xfsidbg_xalgtrace(xfs_agnumber_t);
  73 static void     xfsidbg_xalmtrace(xfs_mount_t *);
  74 static void     xfsidbg_xalttrace(int);
  75 #endif
  76 #ifdef XFS_ATTR_TRACE
  77 static void     xfsidbg_xattrtrace(int);
  78 #endif
  79 #ifdef XFS_BLI_TRACE
  80 static void     xfsidbg_xblitrace(xfs_buf_log_item_t *);
  81 #endif
  82 #ifdef XFS_BMAP_TRACE
  83 static void     xfsidbg_xbmatrace(int);
  84 static void     xfsidbg_xbmitrace(xfs_inode_t *);
  85 static void     xfsidbg_xbmstrace(xfs_inode_t *);
  86 static void     xfsidbg_xbxatrace(int);
  87 static void     xfsidbg_xbxitrace(xfs_inode_t *);
  88 static void     xfsidbg_xbxstrace(xfs_inode_t *);
  89 #endif
  90 #ifdef XFS_ILOCK_TRACE
  91 static void     xfsidbg_xilock_trace(xfs_inode_t *);
  92 static void     xfsidbg_xailock_trace(int);
  93 #endif
  94 #ifdef XFS_DIR_TRACE
  95 static void     xfsidbg_xdirtrace(int);
  96 #endif
  97 #ifdef XFS_DIR2_TRACE
  98 static void     xfsidbg_xdir2atrace(int);
  99 static void     xfsidbg_xdir2itrace(xfs_inode_t *);
 100 #endif
 101 #ifdef XFS_LOG_TRACE
 102 static void     xfsidbg_xiclogtrace(xlog_in_core_t *);
 103 static void     xfsidbg_xlog_granttrace(xlog_t *);
 104 #endif
 105 #ifdef XFS_DQUOT_TRACE
 106 static void     xfsidbg_xqm_dqtrace(xfs_dquot_t *);
 107 #endif
 108
 109
 110 /*
 111  * Command table functions.
 112  */
 113 static void     xfsidbg_xagf(xfs_agf_t *);
 114 static void     xfsidbg_xagi(xfs_agi_t *);
 115 static void     xfsidbg_xaildump(xfs_mount_t *);
 116 static void     xfsidbg_xalloc(xfs_alloc_arg_t *);
 117 static void     xfsidbg_xattrcontext(xfs_attr_list_context_t *);
 118 static void     xfsidbg_xattrleaf(xfs_attr_leafblock_t *);
 119 static void     xfsidbg_xattrsf(xfs_attr_shortform_t *);
 120 static void     xfsidbg_xbirec(xfs_bmbt_irec_t *r);
 121 static void     xfsidbg_xbmalla(xfs_bmalloca_t *);
 122 static void     xfsidbg_xbrec(xfs_bmbt_rec_64_t *);
 123 static void     xfsidbg_xbroot(xfs_inode_t *);
 124 static void     xfsidbg_xbroota(xfs_inode_t *);
 125 static void     xfsidbg_xbtcur(xfs_btree_cur_t *);
 126 static void     xfsidbg_xbuf(xfs_buf_t *);
 127 static void     xfsidbg_xbuf_real(xfs_buf_t *, int);
 128 static void     xfsidbg_xarg(int);
 129 static void     xfsidbg_xchksum(uint *);
 130 static void     xfsidbg_xchash(xfs_mount_t *mp);
 131 static void     xfsidbg_xchashlist(xfs_chashlist_t *chl);
 132 static void     xfsidbg_xdaargs(xfs_da_args_t *);
 133 static void     xfsidbg_xdabuf(xfs_dabuf_t *);
 134 static void     xfsidbg_xdanode(xfs_da_intnode_t *);
 135 static void     xfsidbg_xdastate(xfs_da_state_t *);
 136 static void     xfsidbg_xdirleaf(xfs_dir_leafblock_t *);
 137 static void     xfsidbg_xdirsf(xfs_dir_shortform_t *);
 138 static void     xfsidbg_xdir2free(xfs_dir2_free_t *);
 139 static void     xfsidbg_xdir2sf(xfs_dir2_sf_t *);
 140 static void     xfsidbg_xexlist(xfs_inode_t *);
 141 static void     xfsidbg_xflist(xfs_bmap_free_t *);
 142 static void     xfsidbg_xhelp(void);
 143 static void     xfsidbg_xiclog(xlog_in_core_t *);
 144 static void     xfsidbg_xiclogall(xlog_in_core_t *);
 145 static void     xfsidbg_xiclogcb(xlog_in_core_t *);
 146 static void     xfsidbg_xihash(xfs_mount_t *mp);
 147 static void     xfsidbg_xinodes(xfs_mount_t *);
 148 static void     xfsidbg_delayed_blocks(xfs_mount_t *);
 149 static void     xfsidbg_xinodes_quiesce(xfs_mount_t *);
 150 static void     xfsidbg_xlog(xlog_t *);
 151 static void     xfsidbg_xlog_ritem(xlog_recover_item_t *);
 152 static void     xfsidbg_xlog_rtrans(xlog_recover_t *);
 153 static void     xfsidbg_xlog_rtrans_entire(xlog_recover_t *);
 154 static void     xfsidbg_xlog_tic(xlog_ticket_t *);
 155 static void     xfsidbg_xlogitem(xfs_log_item_t *);
 156 static void     xfsidbg_xmount(xfs_mount_t *);
 157 static void     xfsidbg_xnode(xfs_inode_t *ip);
 158 static void     xfsidbg_xcore(xfs_iocore_t *io);
 159 static void     xfsidbg_xperag(xfs_mount_t *);
 160 static void     xfsidbg_xqm_diskdq(xfs_disk_dquot_t *);
 161 static void     xfsidbg_xqm_dqattached_inos(xfs_mount_t *);
 162 static void     xfsidbg_xqm_dquot(xfs_dquot_t *);
 163 static void     xfsidbg_xqm_mplist(xfs_mount_t *);
 164 static void     xfsidbg_xqm_qinfo(xfs_mount_t *mp);
 165 static void     xfsidbg_xqm_tpdqinfo(xfs_trans_t *tp);
 166 static void     xfsidbg_xsb(xfs_sb_t *);
 167 static void     xfsidbg_xsb_convert(xfs_sb_t *);
 168 static void     xfsidbg_xtp(xfs_trans_t *);
 169 static void     xfsidbg_xtrans_res(xfs_mount_t *);
 170 #ifdef CONFIG_XFS_QUOTA
 171 static void     xfsidbg_xqm(void);
 172 static void     xfsidbg_xqm_htab(void);
 173 static void     xfsidbg_xqm_freelist_print(xfs_frlist_t *qlist, char *title);
 174 static void     xfsidbg_xqm_freelist(void);
 175 #endif
 176
 177 #ifdef XFS_BMAP_TRACE
 178 static 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
 186 static int      xfs_alloc_trace_entry(ktrace_entry_t *ktep);
 187 #endif
 188 #ifdef XFS_ATTR_TRACE
 189 static int      xfs_attr_trace_entry(ktrace_entry_t *ktep);
 190 #endif
 191 #ifdef XFS_BMAP_TRACE
 192 static int      xfs_bmap_trace_entry(ktrace_entry_t *ktep);
 193 #endif
 194 #ifdef XFS_BMAP_TRACE
 195 static int      xfs_bmbt_trace_entry(ktrace_entry_t *ktep);
 196 #endif
 197 #ifdef XFS_DIR_TRACE
 198 static int      xfs_dir_trace_entry(ktrace_entry_t *ktep);
 199 #endif
 200 #ifdef XFS_DIR2_TRACE
 201 static int      xfs_dir2_trace_entry(ktrace_entry_t *ktep);
 202 #endif
 203 #ifdef XFS_RW_TRACE
 204 static void     xfs_bunmap_trace_entry(ktrace_entry_t   *ktep);
 205 static void     xfs_rw_enter_trace_entry(ktrace_entry_t *ktep);
 206 static void     xfs_page_trace_entry(ktrace_entry_t *ktep);
 207 static int      xfs_rw_trace_entry(ktrace_entry_t *ktep);
 208 #endif
 209 static void     xfs_broot(xfs_inode_t *ip, xfs_ifork_t *f);
 210 static void     xfs_btalloc(xfs_alloc_block_t *bt, int bsz);
 211 static void     xfs_btbmap(xfs_bmbt_block_t *bt, int bsz);
 212 static void     xfs_btino(xfs_inobt_block_t *bt, int bsz);
 213 static void     xfs_buf_item_print(xfs_buf_log_item_t *blip, int summary);
 214 static void     xfs_dastate_path(xfs_da_state_path_t *p);
 215 static void     xfs_dir2data(void *addr, int size);
 216 static void     xfs_dir2leaf(xfs_dir2_leaf_t *leaf, int size);
 217 static void     xfs_dquot_item_print(xfs_dq_logitem_t *lip, int summary);
 218 static void     xfs_efd_item_print(xfs_efd_log_item_t *efdp, int summary);
 219 static void     xfs_efi_item_print(xfs_efi_log_item_t *efip, int summary);
 220 static char *   xfs_fmtformat(xfs_dinode_fmt_t f);
 221 char *          xfs_fmtfsblock(xfs_fsblock_t bno, xfs_mount_t *mp);
 222 static char *   xfs_fmtino(xfs_ino_t ino, xfs_mount_t *mp);
 223 static char *   xfs_fmtlsn(xfs_lsn_t *lsnp);
 224 static char *   xfs_fmtmode(int m);
 225 static char *   xfs_fmtsize(size_t i);
 226 static char *   xfs_fmtuuid(uuid_t *);
 227 static void     xfs_inode_item_print(xfs_inode_log_item_t *ilip, int summary);
 228 static void     xfs_inodebuf(xfs_buf_t *bp);
 229 static void     xfs_prdinode_core(xfs_dinode_core_t *dip);
 230 static void     xfs_qoff_item_print(xfs_qoff_logitem_t *lip, int summary);
 231 static void     xfs_xexlist_fork(xfs_inode_t *ip, int whichfork);
 232 static void     xfs_xnode_fork(char *name, xfs_ifork_t *f);
 233
 234
 235 /* kdb wrappers */
 236
 237 static 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
 258 static 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
 279 static 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
 301 static 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
 323 static 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
 345 static 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
 369 static 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
 393 static 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
 417 static 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
 439 static 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
 461 static 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
 483 static 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
 505 static 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
 527 static 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
 551 static 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
 573 static 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
 597 static 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
 621 static 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
 645 static 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
 667 static 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
 691 static 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
 715 static 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
 739 static 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
 776 static 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
 798 static 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
 819 static 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
 841 static 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
 862 static 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
 883 static 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
 904 static 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
 925 static 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
 946 static 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
 967 static 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
 988 static 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
1009 static 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
1030 static 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
1052 static 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
1073 static 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
1095 static 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
1116 static 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
1138 static 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
1159 static 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
1180 static 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
1201 static 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
1222 static 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
1243 static 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
1264 static 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
1285 static 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
1306 static 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
1327 static 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
1348 static 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
1361 static 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
1382 static 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
1403 static 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
1424 static 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
1445 static 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
1466 static 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
1488 static 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
1509 static 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
1530 static 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
1551 static 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
1572 static 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
1593 static 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
1614 static 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
1635 static 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
1656 static 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
1677 static 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
1698 static 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
1719 static 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
1740 static 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
1761 static 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
1783 static 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
1796 static 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
1809 static 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
1823 static 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
1844 static 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
1865 static 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
1886 static 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
1917 static 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
1938 static 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  */
1963 char *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
2000 static void
2001 printflags(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
2026 static 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
2051 static 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
2069 static 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
2097 static void
2098 print_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
2108 static 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
2135 static 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  */
2168 static int
2169 vn_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  */
2275 static 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  */
2322 static 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__
2363 static 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
2408 static 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
2464 static 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
2474 static char     *iomap_flag_vals[] = {
2475         "EOF", "HOLE", "DELAY", "INVALID0x08",
2476         "INVALID0x10", "UNWRITTEN", "NEW", "INVALID0x80",
2477         NULL };
2478
2479
2480 static 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
2507 static char     *bp_flags(xfs_buf_flags_t bp_flag)
2508 {
2509         return(map_flags((unsigned long) bp_flag, bp_flag_vals));
2510 }
2511
2512 static int
2513 kdbm_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
2530 static void
2531 print_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
2574 static int
2575 kdbm_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
2596 static int
2597 kdbm_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
2645 static int
2646 kdbm_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
2674 static int
2675 kdbm_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
2705 static 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
2726 static int
2727 kdbm_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
2768 static int
2769 kdbm_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
2814 struct xif {
2815         char    *name;
2816         int     (*func)(int, const char **, const char **, struct pt_regs *);
2817         char    *args;
2818         char    *help;
2819 };
2820
2821 static 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
3024 static 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
3037 static int
3038 xfsidbg_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
3049 static void
3050 xfsidbg_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  */
3063 static 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  */
3076 static int
3077 xfs_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  */
3208 static int
3209 xfs_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  */
3282 static int
3283 xfs_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  */
3332 static int
3333 xfs_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  */
3442 static void
3443 xfs_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  */
3474 static void
3475 xfs_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  */
3517 static void
3518 xfs_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  */
3562 static void
3563 xfs_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  */
3603 static void
3604 xfs_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  */
3651 static void
3652 xfs_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  */
3678 static void
3679 xfs_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  */
3689 static void
3690 xfs_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  */
3714 static int
3715 xfs_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  */
3781 static int
3782 xfs_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  */
3844 static void
3845 xfs_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  */
3871 static void
3872 xfs_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  */
3906 static char *
3907 xfs_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  */
3923 char *
3924 xfs_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  */
3943 static char *
3944 xfs_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  */
3962 static char *
3963 xfs_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  */
3979 static char *
3980 xfs_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  */
4004 static char *
4005 xfs_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  */
4017 static char *
4018 xfs_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  */
4037 static void
4038 xfs_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 */
4101 static void
4102 xfs_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 */
4113 static void
4114 xfs_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  */
4124 static void
4125 xfs_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  */
4148 static void
4149 xfs_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  */
4167 static void
4168 xfs_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  */
4207 static void
4208 xfs_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  */
4229 static void
4230 xfs_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  */
4259 static void
4260 xfs_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  */
4280 static void
4281 xfs_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  */
4331 static void
4332 xfs_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  */
4352 static void
4353 xfs_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  */
4375 static int
4376 xfs_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  */
4500 static void
4501 xfs_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
4524 static void
4525 xfs_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  */
4567 static void
4568 xfsidbg_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  */
4591 static void
4592 xfsidbg_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  */
4625 static void
4626 xfsidbg_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  */
4670 static void
4671 xfsidbg_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  */
4702 static void
4703 xfsidbg_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  */
4728 static void
4729 xfsidbg_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  */
4750 static void
4751 xfsidbg_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  */
4776 static void
4777 xfsidbg_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
4799 static int xargument = 0;
4800
4801 /*
4802  * Set xtra argument, used by xchksum.
4803  */
4804 static void
4805 xfsidbg_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  */
4816 static void
4817 xfsidbg_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  */
4851 static void
4852 xfsidbg_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  */
4918 static void
4919 xfsidbg_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  */
4945 static void
4946 xfsidbg_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  */
4989 static void
4990 xfsidbg_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  */
5004 static void
5005 xfsidbg_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  */
5060 static void
5061 xfsidbg_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  */
5081 static void
5082 xfsidbg_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  */
5124 static void
5125 xfsidbg_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  */
5147 static void
5148 xfsidbg_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  */
5171 static void
5172 xfsidbg_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  */
5185 static void
5186 xfsidbg_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  */
5194 static void
5195 xfsidbg_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  */
5204 static void
5205 xfsidbg_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  */
5266 static void
5267 xfsidbg_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  */
5276 static void
5277 xfsidbg_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  */
5437 static void
5438 xfsidbg_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  */
5481 static void
5482 xfsidbg_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  */
5503 static void
5504 xfsidbg_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  */
5529 static void
5530 xfsidbg_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
5586 static void
5587 xfsidbg_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  */
5653 static void
5654 xfsidbg_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  */
5696 static void
5697 xfsidbg_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  */
5716 static void
5717 xfsidbg_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  */
5777 static void
5778 xfsidbg_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  */
5796 static void
5797 xfsidbg_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  */
5819 static void
5820 xfsidbg_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  */
5844 static void
5845 xfsidbg_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  */
5882 static void
5883 xfs_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
5952 static void
5953 xfs_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  */
5992 static void
5993 xfsidbg_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  */
6018 static void
6019 xfsidbg_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  */
6046 static void
6047 xfsidbg_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  */
6063 static void
6064 xfsidbg_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  */
6109 static void
6110 xfsidbg_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  */
6153 static void
6154 xfsidbg_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  */
6176 static void
6177 xfsidbg_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  */
6187 static void
6188 xfsidbg_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  */
6204 static void
6205 xfsidbg_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  */
6216 static void
6217 xfsidbg_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  */
6273 static void
6274 xfsidbg_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  */
6288 static void
6289 xfsidbg_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  */
6318 static void
6319 xfsidbg_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  */
6356 static void
6357 xfsidbg_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
6377 static void
6378 xfsidbg_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
6401 static void
6402 xfsidbg_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
6423 static char *
6424 xfsidbg_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  */
6445 static void
6446 xfsidbg_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
6498 static void
6499 xfsidbg_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  */
6547 static void
6548 xfsidbg_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  */
6596 static void
6597 xfsidbg_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  */
6618 static void
6619 xfsidbg_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
6639 static void
6640 xfsidbg_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  */
6688 static void
6689 xfsidbg_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  */
6734 static void
6735 xfsidbg_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  */
6761 static void
6762 xfsidbg_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  */
6833 static void
6834 xfsidbg_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  */
6904 static void
6905 xfsidbg_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
7039 static void
7040 xfsidbg_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  */
7107 static void
7108 xfsidbg_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
7180 static void
7181 xfsidbg_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  */
7191 static void
7192 xfsidbg_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  */
7209 static void
7210 xfsidbg_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  */
7235 static void
7236 xfsidbg_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
7273 static void
7274 xfsidbg_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
7293 static void
7294 xfsidbg_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
7312 static 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
7324 static void
7325 xfsidbg_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
7376 static void
7377 xfsidbg_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
7399 static void
7400 xfsidbg_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
7416 static void
7417 xfsidbg_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
7425 static void
7426 xfsidbg_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
7453 static int
7454 xfsidbg_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
7492 void
7493 xfsidbg_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
7513 static void
7514 xfsidbg_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
7526 static void
7527 xfsidbg_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
7557 static void
7558 xfsidbg_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  */
7593 static void
7594 xfsidbg_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
7630 static void
7631 xfsidbg_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  */
7645 static void
7646 xfsidbg_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
7748 static void
7749 xfsidbg_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 }