fs/xfs/xfsidbg.c

   1 /*
   2  * Copyright (c) 2000-2002 Silicon Graphics, Inc.  All Rights Reserved.
   3  *
   4  * This program is free software; you can redistribute it and/or modify it
   5  * under the terms of version 2 of the GNU General Public License as
   6  * published by the Free Software Foundation.
   7  *
   8  * This program is distributed in the hope that it would be useful, but
   9  * WITHOUT ANY WARRANTY; without even the implied warranty of
  10  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
  11  *
  12  * Further, this software is distributed without any warranty that it is
  13  * free of the rightful claim of any third person regarding infringement
  14  * or the like.  Any license provided herein, whether implied or
  15  * otherwise, applies only to this software file.  Patent licenses, if
  16  * any, provided herein do not apply to combinations of this program with
  17  * other software, or any other product whatsoever.
  18  *
  19  * You should have received a copy of the GNU General Public License along
  20  * with this program; if not, write the Free Software Foundation, Inc., 59
  21  * Temple Place - Suite 330, Boston MA 02111-1307, USA.
  22  *
  23  * Contact information: Silicon Graphics, Inc., 1600 Amphitheatre Pkwy,
  24  * Mountain View, CA  94043, or:
  25  *
  26  * http://www.sgi.com
  27  *
  28  * For further information regarding this notice, see:
  29  *
  30  * http://oss.sgi.com/projects/GenInfo/SGIGPLNoticeExplan/
  31  */
  32
  33 #include "xfs.h"
  34 #include "pagebuf/page_buf_internal.h"
  35
  36 #include <linux/ctype.h>
  37 #include <linux/kdb.h>
  38 #include <linux/kdbprivate.h>
  39 #include <linux/mm.h>
  40 #include <linux/init.h>
  41
  42 #include "xfs_macros.h"
  43 #include "xfs_types.h"
  44 #include "xfs_inum.h"
  45 #include "xfs_log.h"
  46 #include "xfs_trans.h"
  47 #include "xfs_sb.h"
  48 #include "xfs_dir.h"
  49 #include "xfs_dir2.h"
  50 #include "xfs_dmapi.h"
  51 #include "xfs_mount.h"
  52 #include "xfs_alloc.h"
  53 #include "xfs_ag.h"
  54 #include "xfs_alloc_btree.h"
  55 #include "xfs_bmap_btree.h"
  56 #include "xfs_ialloc_btree.h"
  57 #include "xfs_btree.h"
  58 #include "xfs_buf_item.h"
  59 #include "xfs_extfree_item.h"
  60 #include "xfs_inode_item.h"
  61 #include "xfs_attr_sf.h"
  62 #include "xfs_dir_sf.h"
  63 #include "xfs_dir2_sf.h"
  64 #include "xfs_dinode.h"
  65 #include "xfs_inode.h"
  66 #include "xfs_bmap.h"
  67 #include "xfs_da_btree.h"
  68 #include "xfs_attr.h"
  69 #include "xfs_attr_leaf.h"
  70 #include "xfs_dir_leaf.h"
  71 #include "xfs_dir2_data.h"
  72 #include "xfs_dir2_leaf.h"
  73 #include "xfs_dir2_block.h"
  74 #include "xfs_dir2_node.h"
  75 #include "xfs_dir2_trace.h"
  76 #include "xfs_log_priv.h"
  77 #include "xfs_log_recover.h"
  78 #include "xfs_rw.h"
  79 #include "xfs_bit.h"
  80 #include "xfs_quota.h"
  81 #include "xfs_log_recover.h"
  82 #include "quota/xfs_qm.h"
  83
  84 MODULE_AUTHOR("Silicon Graphics, Inc.");
  85 MODULE_DESCRIPTION("Additional kdb commands for debugging XFS");
  86 MODULE_LICENSE("GPL");
  87
  88 /*
  89  * Command table functions.
  90  */
  91 static void     xfsidbg_xagf(xfs_agf_t *);
  92 static void     xfsidbg_xagi(xfs_agi_t *);
  93 static void     xfsidbg_xaildump(xfs_mount_t *);
  94 static void     xfsidbg_xalloc(xfs_alloc_arg_t *);
  95 #ifdef DEBUG
  96 static void     xfsidbg_xalmtrace(xfs_mount_t *);
  97 #endif
  98 static void     xfsidbg_xattrcontext(xfs_attr_list_context_t *);
  99 static void     xfsidbg_xattrleaf(xfs_attr_leafblock_t *);
 100 static void     xfsidbg_xattrsf(xfs_attr_shortform_t *);
 101 static void     xfsidbg_xbirec(xfs_bmbt_irec_t *r);
 102 static void     xfsidbg_xbmalla(xfs_bmalloca_t *);
 103 static void     xfsidbg_xbrec(xfs_bmbt_rec_64_t *);
 104 static void     xfsidbg_xbroot(xfs_inode_t *);
 105 static void     xfsidbg_xbroota(xfs_inode_t *);
 106 static void     xfsidbg_xbtcur(xfs_btree_cur_t *);
 107 static void     xfsidbg_xbuf(xfs_buf_t *);
 108 static void     xfsidbg_xbuf_real(xfs_buf_t *, int);
 109 static void     xfsidbg_xchash(xfs_mount_t *mp);
 110 static void     xfsidbg_xchashlist(xfs_chashlist_t *chl);
 111 static void     xfsidbg_xdaargs(xfs_da_args_t *);
 112 static void     xfsidbg_xdabuf(xfs_dabuf_t *);
 113 static void     xfsidbg_xdanode(xfs_da_intnode_t *);
 114 static void     xfsidbg_xdastate(xfs_da_state_t *);
 115 static void     xfsidbg_xdirleaf(xfs_dir_leafblock_t *);
 116 static void     xfsidbg_xdirsf(xfs_dir_shortform_t *);
 117 static void     xfsidbg_xdir2free(xfs_dir2_free_t *);
 118 static void     xfsidbg_xdir2sf(xfs_dir2_sf_t *);
 119 static void     xfsidbg_xexlist(xfs_inode_t *);
 120 static void     xfsidbg_xflist(xfs_bmap_free_t *);
 121 static void     xfsidbg_xhelp(void);
 122 static void     xfsidbg_xiclog(xlog_in_core_t *);
 123 static void     xfsidbg_xiclogall(xlog_in_core_t *);
 124 static void     xfsidbg_xiclogcb(xlog_in_core_t *);
 125 static void     xfsidbg_xihash(xfs_mount_t *mp);
 126 static void     xfsidbg_xinodes(xfs_mount_t *);
 127 static void     xfsidbg_delayed_blocks(xfs_mount_t *);
 128 static void     xfsidbg_xinodes_quiesce(xfs_mount_t *);
 129 static void     xfsidbg_xlog(xlog_t *);
 130 static void     xfsidbg_xlog_ritem(xlog_recover_item_t *);
 131 static void     xfsidbg_xlog_rtrans(xlog_recover_t *);
 132 static void     xfsidbg_xlog_rtrans_entire(xlog_recover_t *);
 133 static void     xfsidbg_xlog_tic(xlog_ticket_t *);
 134 static void     xfsidbg_xlogitem(xfs_log_item_t *);
 135 static void     xfsidbg_xmount(xfs_mount_t *);
 136 static void     xfsidbg_xnode(xfs_inode_t *ip);
 137 static void     xfsidbg_xcore(xfs_iocore_t *io);
 138 static void     xfsidbg_xperag(xfs_mount_t *);
 139 static void     xfsidbg_xqm_diskdq(xfs_disk_dquot_t *);
 140 static void     xfsidbg_xqm_dqattached_inos(xfs_mount_t *);
 141 static void     xfsidbg_xqm_dquot(xfs_dquot_t *);
 142 static void     xfsidbg_xqm_mplist(xfs_mount_t *);
 143 static void     xfsidbg_xqm_qinfo(xfs_mount_t *mp);
 144 static void     xfsidbg_xqm_tpdqinfo(xfs_trans_t *tp);
 145 static void     xfsidbg_xsb(xfs_sb_t *, int convert);
 146 static void     xfsidbg_xtp(xfs_trans_t *);
 147 static void     xfsidbg_xtrans_res(xfs_mount_t *);
 148 #ifdef  CONFIG_XFS_QUOTA
 149 static void     xfsidbg_xqm(void);
 150 static void     xfsidbg_xqm_htab(void);
 151 static void     xfsidbg_xqm_freelist_print(xfs_frlist_t *qlist, char *title);
 152 static void     xfsidbg_xqm_freelist(void);
 153 #endif
 154
 155 /* kdb wrappers */
 156
 157 static int      kdbm_xfs_xagf(
 158         int     argc,
 159         const char **argv,
 160         const char **envp,
 161         struct pt_regs *regs)
 162 {
 163         unsigned long addr;
 164         int nextarg = 1;
 165         long offset = 0;
 166         int diag;
 167
 168         if (argc != 1)
 169                 return KDB_ARGCOUNT;
 170         diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL, regs);
 171         if (diag)
 172                 return diag;
 173
 174         xfsidbg_xagf((xfs_agf_t *)addr);
 175         return 0;
 176 }
 177
 178 static int      kdbm_xfs_xagi(
 179         int     argc,
 180         const char **argv,
 181         const char **envp,
 182         struct pt_regs *regs)
 183 {
 184         unsigned long addr;
 185         int nextarg = 1;
 186         long offset = 0;
 187         int diag;
 188
 189         if (argc != 1)
 190                 return KDB_ARGCOUNT;
 191         diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL, regs);
 192         if (diag)
 193                 return diag;
 194
 195         xfsidbg_xagi((xfs_agi_t *)addr);
 196         return 0;
 197 }
 198
 199 static int      kdbm_xfs_xaildump(
 200         int     argc,
 201         const char **argv,
 202         const char **envp,
 203         struct pt_regs *regs)
 204 {
 205         unsigned long addr;
 206         int nextarg = 1;
 207         long offset = 0;
 208         int diag;
 209
 210         if (argc != 1)
 211                 return KDB_ARGCOUNT;
 212         diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL, regs);
 213         if (diag)
 214                 return diag;
 215
 216         xfsidbg_xaildump((xfs_mount_t *) addr);
 217         return 0;
 218 }
 219
 220 static int      kdbm_xfs_xalloc(
 221         int     argc,
 222         const char **argv,
 223         const char **envp,
 224         struct pt_regs *regs)
 225 {
 226         unsigned long addr;
 227         int nextarg = 1;
 228         long offset = 0;
 229         int diag;
 230
 231         if (argc != 1)
 232                 return KDB_ARGCOUNT;
 233         diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL, regs);
 234         if (diag)
 235                 return diag;
 236
 237         xfsidbg_xalloc((xfs_alloc_arg_t *) addr);
 238         return 0;
 239 }
 240
 241 #ifdef DEBUG
 242 static int      kdbm_xfs_xalmtrace(
 243         int     argc,
 244         const char **argv,
 245         const char **envp,
 246         struct pt_regs *regs)
 247 {
 248         unsigned long addr;
 249         int nextarg = 1;
 250         long offset = 0;
 251         int diag;
 252
 253         if (argc != 1)
 254                 return KDB_ARGCOUNT;
 255         diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL, regs);
 256         if (diag)
 257                 return diag;
 258
 259         xfsidbg_xalmtrace((xfs_mount_t *) addr);
 260         return 0;
 261 }
 262 #endif /* DEBUG */
 263
 264 static int      kdbm_xfs_xattrcontext(
 265         int     argc,
 266         const char **argv,
 267         const char **envp,
 268         struct pt_regs *regs)
 269 {
 270         unsigned long addr;
 271         int nextarg = 1;
 272         long offset = 0;
 273         int diag;
 274
 275         if (argc != 1)
 276                 return KDB_ARGCOUNT;
 277         diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL, regs);
 278         if (diag)
 279                 return diag;
 280
 281         xfsidbg_xattrcontext((xfs_attr_list_context_t *) addr);
 282         return 0;
 283 }
 284
 285 static int      kdbm_xfs_xattrleaf(
 286         int     argc,
 287         const char **argv,
 288         const char **envp,
 289         struct pt_regs *regs)
 290 {
 291         unsigned long addr;
 292         int nextarg = 1;
 293         long offset = 0;
 294         int diag;
 295
 296         if (argc != 1)
 297                 return KDB_ARGCOUNT;
 298         diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL, regs);
 299         if (diag)
 300                 return diag;
 301
 302         xfsidbg_xattrleaf((xfs_attr_leafblock_t *) addr);
 303         return 0;
 304 }
 305
 306 static int      kdbm_xfs_xattrsf(
 307         int     argc,
 308         const char **argv,
 309         const char **envp,
 310         struct pt_regs *regs)
 311 {
 312         unsigned long addr;
 313         int nextarg = 1;
 314         long offset = 0;
 315         int diag;
 316
 317         if (argc != 1)
 318                 return KDB_ARGCOUNT;
 319         diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL, regs);
 320         if (diag)
 321                 return diag;
 322
 323         xfsidbg_xattrsf((xfs_attr_shortform_t *) addr);
 324         return 0;
 325 }
 326
 327 static int      kdbm_xfs_xbirec(
 328         int     argc,
 329         const char **argv,
 330         const char **envp,
 331         struct pt_regs *regs)
 332 {
 333         unsigned long addr;
 334         int nextarg = 1;
 335         long offset = 0;
 336         int diag;
 337
 338         if (argc != 1)
 339                 return KDB_ARGCOUNT;
 340         diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL, regs);
 341         if (diag)
 342                 return diag;
 343
 344         xfsidbg_xbirec((xfs_bmbt_irec_t *) addr);
 345         return 0;
 346 }
 347
 348 static int      kdbm_xfs_xbmalla(
 349         int     argc,
 350         const char **argv,
 351         const char **envp,
 352         struct pt_regs *regs)
 353 {
 354         unsigned long addr;
 355         int nextarg = 1;
 356         long offset = 0;
 357         int diag;
 358
 359         if (argc != 1)
 360                 return KDB_ARGCOUNT;
 361         diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL, regs);
 362         if (diag)
 363                 return diag;
 364
 365         xfsidbg_xbmalla((xfs_bmalloca_t *)addr);
 366         return 0;
 367 }
 368
 369 static int      kdbm_xfs_xbrec(
 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         diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL, regs);
 383         if (diag)
 384                 return diag;
 385
 386         xfsidbg_xbrec((xfs_bmbt_rec_64_t *) addr);
 387         return 0;
 388 }
 389
 390 static int      kdbm_xfs_xbroot(
 391         int     argc,
 392         const char **argv,
 393         const char **envp,
 394         struct pt_regs *regs)
 395 {
 396         unsigned long addr;
 397         int nextarg = 1;
 398         long offset = 0;
 399         int diag;
 400
 401         if (argc != 1)
 402                 return KDB_ARGCOUNT;
 403         diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL, regs);
 404         if (diag)
 405                 return diag;
 406
 407         xfsidbg_xbroot((xfs_inode_t *) addr);
 408         return 0;
 409 }
 410
 411 static int      kdbm_xfs_xbroota(
 412         int     argc,
 413         const char **argv,
 414         const char **envp,
 415         struct pt_regs *regs)
 416 {
 417         unsigned long addr;
 418         int nextarg = 1;
 419         long offset = 0;
 420         int diag;
 421
 422         if (argc != 1)
 423                 return KDB_ARGCOUNT;
 424         diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL, regs);
 425         if (diag)
 426                 return diag;
 427
 428         xfsidbg_xbroota((xfs_inode_t *) addr);
 429         return 0;
 430 }
 431
 432 static int      kdbm_xfs_xbtcur(
 433         int     argc,
 434         const char **argv,
 435         const char **envp,
 436         struct pt_regs *regs)
 437 {
 438         unsigned long addr;
 439         int nextarg = 1;
 440         long offset = 0;
 441         int diag;
 442
 443         if (argc != 1)
 444                 return KDB_ARGCOUNT;
 445         diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL, regs);
 446         if (diag)
 447                 return diag;
 448
 449         xfsidbg_xbtcur((xfs_btree_cur_t *) addr);
 450         return 0;
 451 }
 452
 453 static int      kdbm_xfs_xbuf(
 454         int     argc,
 455         const char **argv,
 456         const char **envp,
 457         struct pt_regs *regs)
 458 {
 459         unsigned long addr;
 460         int nextarg = 1;
 461         long offset = 0;
 462         int diag;
 463
 464         if (argc != 1)
 465                 return KDB_ARGCOUNT;
 466         diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL, regs);
 467         if (diag)
 468                 return diag;
 469
 470         xfsidbg_xbuf((xfs_buf_t *) addr);
 471         return 0;
 472 }
 473
 474
 475 static int      kdbm_xfs_xchash(
 476         int     argc,
 477         const char **argv,
 478         const char **envp,
 479         struct pt_regs *regs)
 480 {
 481         unsigned long addr;
 482         int nextarg = 1;
 483         long offset = 0;
 484         int diag;
 485
 486         if (argc != 1)
 487                 return KDB_ARGCOUNT;
 488         diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL, regs);
 489         if (diag)
 490                 return diag;
 491
 492         xfsidbg_xchash((xfs_mount_t *) addr);
 493         return 0;
 494 }
 495
 496 static int      kdbm_xfs_xchashlist(
 497         int     argc,
 498         const char **argv,
 499         const char **envp,
 500         struct pt_regs *regs)
 501 {
 502         unsigned long addr;
 503         int nextarg = 1;
 504         long offset = 0;
 505         int diag;
 506
 507         if (argc != 1)
 508                 return KDB_ARGCOUNT;
 509         diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL, regs);
 510         if (diag)
 511                 return diag;
 512
 513         xfsidbg_xchashlist((xfs_chashlist_t *) addr);
 514         return 0;
 515 }
 516
 517
 518 static int      kdbm_xfs_xdaargs(
 519         int     argc,
 520         const char **argv,
 521         const char **envp,
 522         struct pt_regs *regs)
 523 {
 524         unsigned long addr;
 525         int nextarg = 1;
 526         long offset = 0;
 527         int diag;
 528
 529         if (argc != 1)
 530                 return KDB_ARGCOUNT;
 531         diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL, regs);
 532         if (diag)
 533                 return diag;
 534
 535         xfsidbg_xdaargs((xfs_da_args_t *) addr);
 536         return 0;
 537 }
 538
 539 static int      kdbm_xfs_xdabuf(
 540         int     argc,
 541         const char **argv,
 542         const char **envp,
 543         struct pt_regs *regs)
 544 {
 545         unsigned long addr;
 546         int nextarg = 1;
 547         long offset = 0;
 548         int diag;
 549
 550         if (argc != 1)
 551                 return KDB_ARGCOUNT;
 552         diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL, regs);
 553         if (diag)
 554                 return diag;
 555
 556         xfsidbg_xdabuf((xfs_dabuf_t *) addr);
 557         return 0;
 558 }
 559
 560 static int      kdbm_xfs_xdanode(
 561         int     argc,
 562         const char **argv,
 563         const char **envp,
 564         struct pt_regs *regs)
 565 {
 566         unsigned long addr;
 567         int nextarg = 1;
 568         long offset = 0;
 569         int diag;
 570
 571         if (argc != 1)
 572                 return KDB_ARGCOUNT;
 573         diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL, regs);
 574         if (diag)
 575                 return diag;
 576
 577         xfsidbg_xdanode((xfs_da_intnode_t *) addr);
 578         return 0;
 579 }
 580
 581 static int      kdbm_xfs_xdastate(
 582         int     argc,
 583         const char **argv,
 584         const char **envp,
 585         struct pt_regs *regs)
 586 {
 587         unsigned long addr;
 588         int nextarg = 1;
 589         long offset = 0;
 590         int diag;
 591
 592         if (argc != 1)
 593                 return KDB_ARGCOUNT;
 594         diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL, regs);
 595         if (diag)
 596                 return diag;
 597
 598         xfsidbg_xdastate((xfs_da_state_t *) addr);
 599         return 0;
 600 }
 601
 602 static int      kdbm_xfs_xdirleaf(
 603         int     argc,
 604         const char **argv,
 605         const char **envp,
 606         struct pt_regs *regs)
 607 {
 608         unsigned long addr;
 609         int nextarg = 1;
 610         long offset = 0;
 611         int diag;
 612
 613         if (argc != 1)
 614                 return KDB_ARGCOUNT;
 615         diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL, regs);
 616         if (diag)
 617                 return diag;
 618
 619         xfsidbg_xdirleaf((xfs_dir_leafblock_t *) addr);
 620         return 0;
 621 }
 622
 623 static int      kdbm_xfs_xdirsf(
 624         int     argc,
 625         const char **argv,
 626         const char **envp,
 627         struct pt_regs *regs)
 628 {
 629         unsigned long addr;
 630         int nextarg = 1;
 631         long offset = 0;
 632         int diag;
 633
 634         if (argc != 1)
 635                 return KDB_ARGCOUNT;
 636         diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL, regs);
 637         if (diag)
 638                 return diag;
 639
 640         xfsidbg_xdirsf((xfs_dir_shortform_t *) addr);
 641         return 0;
 642 }
 643
 644 static int      kdbm_xfs_xdir2free(
 645         int     argc,
 646         const char **argv,
 647         const char **envp,
 648         struct pt_regs *regs)
 649 {
 650         unsigned long addr;
 651         int nextarg = 1;
 652         long offset = 0;
 653         int diag;
 654
 655         if (argc != 1)
 656                 return KDB_ARGCOUNT;
 657         diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL, regs);
 658         if (diag)
 659                 return diag;
 660
 661         xfsidbg_xdir2free((xfs_dir2_free_t *) addr);
 662         return 0;
 663 }
 664
 665 static int      kdbm_xfs_xdir2sf(
 666         int     argc,
 667         const char **argv,
 668         const char **envp,
 669         struct pt_regs *regs)
 670 {
 671         unsigned long addr;
 672         int nextarg = 1;
 673         long offset = 0;
 674         int diag;
 675
 676         if (argc != 1)
 677                 return KDB_ARGCOUNT;
 678         diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL, regs);
 679         if (diag)
 680                 return diag;
 681
 682         xfsidbg_xdir2sf((xfs_dir2_sf_t *) addr);
 683         return 0;
 684 }
 685
 686 static int      kdbm_xfs_xexlist(
 687         int     argc,
 688         const char **argv,
 689         const char **envp,
 690         struct pt_regs *regs)
 691 {
 692         unsigned long addr;
 693         int nextarg = 1;
 694         long offset = 0;
 695         int diag;
 696
 697         if (argc != 1)
 698                 return KDB_ARGCOUNT;
 699         diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL, regs);
 700         if (diag)
 701                 return diag;
 702
 703         xfsidbg_xexlist((xfs_inode_t *) addr);
 704         return 0;
 705 }
 706
 707 static int      kdbm_xfs_xflist(
 708         int     argc,
 709         const char **argv,
 710         const char **envp,
 711         struct pt_regs *regs)
 712 {
 713         unsigned long addr;
 714         int nextarg = 1;
 715         long offset = 0;
 716         int diag;
 717
 718         if (argc != 1)
 719                 return KDB_ARGCOUNT;
 720         diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL, regs);
 721         if (diag)
 722                 return diag;
 723
 724         xfsidbg_xflist((xfs_bmap_free_t *) addr);
 725         return 0;
 726 }
 727
 728 static int      kdbm_xfs_xhelp(
 729         int     argc,
 730         const char **argv,
 731         const char **envp,
 732         struct pt_regs *regs)
 733 {
 734         if (argc != 0)
 735                 return KDB_ARGCOUNT;
 736
 737         xfsidbg_xhelp();
 738         return 0;
 739 }
 740
 741 static int      kdbm_xfs_xiclog(
 742         int     argc,
 743         const char **argv,
 744         const char **envp,
 745         struct pt_regs *regs)
 746 {
 747         unsigned long addr;
 748         int nextarg = 1;
 749         long offset = 0;
 750         int diag;
 751
 752         if (argc != 1)
 753                 return KDB_ARGCOUNT;
 754         diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL, regs);
 755         if (diag)
 756                 return diag;
 757
 758         xfsidbg_xiclog((xlog_in_core_t *) addr);
 759         return 0;
 760 }
 761
 762 static int      kdbm_xfs_xiclogall(
 763         int     argc,
 764         const char **argv,
 765         const char **envp,
 766         struct pt_regs *regs)
 767 {
 768         unsigned long addr;
 769         int nextarg = 1;
 770         long offset = 0;
 771         int diag;
 772
 773         if (argc != 1)
 774                 return KDB_ARGCOUNT;
 775         diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL, regs);
 776         if (diag)
 777                 return diag;
 778
 779         xfsidbg_xiclogall((xlog_in_core_t *) addr);
 780         return 0;
 781 }
 782
 783 static int      kdbm_xfs_xiclogcb(
 784         int     argc,
 785         const char **argv,
 786         const char **envp,
 787         struct pt_regs *regs)
 788 {
 789         unsigned long addr;
 790         int nextarg = 1;
 791         long offset = 0;
 792         int diag;
 793
 794         if (argc != 1)
 795                 return KDB_ARGCOUNT;
 796         diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL, regs);
 797         if (diag)
 798                 return diag;
 799
 800         xfsidbg_xiclogcb((xlog_in_core_t *) addr);
 801         return 0;
 802 }
 803
 804 static int      kdbm_xfs_xihash(
 805         int     argc,
 806         const char **argv,
 807         const char **envp,
 808         struct pt_regs *regs)
 809 {
 810         unsigned long addr;
 811         int nextarg = 1;
 812         long offset = 0;
 813         int diag;
 814
 815         if (argc != 1)
 816                 return KDB_ARGCOUNT;
 817         diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL, regs);
 818         if (diag)
 819                 return diag;
 820
 821         xfsidbg_xihash((xfs_mount_t *) addr);
 822         return 0;
 823 }
 824
 825 static int      kdbm_xfs_xinodes(
 826         int     argc,
 827         const char **argv,
 828         const char **envp,
 829         struct pt_regs *regs)
 830 {
 831         unsigned long addr;
 832         int nextarg = 1;
 833         long offset = 0;
 834         int diag;
 835
 836         if (argc != 1)
 837                 return KDB_ARGCOUNT;
 838         diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL, regs);
 839         if (diag)
 840                 return diag;
 841
 842         xfsidbg_xinodes((xfs_mount_t *) addr);
 843         return 0;
 844 }
 845
 846 static int      kdbm_xfs_delayed_blocks(
 847         int     argc,
 848         const char **argv,
 849         const char **envp,
 850         struct pt_regs *regs)
 851 {
 852         unsigned long addr;
 853         int nextarg = 1;
 854         long offset = 0;
 855         int diag;
 856
 857         if (argc != 1)
 858                 return KDB_ARGCOUNT;
 859         diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL, regs);
 860         if (diag)
 861                 return diag;
 862
 863         xfsidbg_delayed_blocks((xfs_mount_t *) addr);
 864         return 0;
 865 }
 866
 867
 868 static int      kdbm_xfs_xinodes_quiesce(
 869         int     argc,
 870         const char **argv,
 871         const char **envp,
 872         struct pt_regs *regs)
 873 {
 874         unsigned long addr;
 875         int nextarg = 1;
 876         long offset = 0;
 877         int diag;
 878
 879         if (argc != 1)
 880                 return KDB_ARGCOUNT;
 881         diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL, regs);
 882         if (diag)
 883                 return diag;
 884
 885         xfsidbg_xinodes_quiesce((xfs_mount_t *) addr);
 886         return 0;
 887 }
 888
 889 static int      kdbm_xfs_xlog(
 890         int     argc,
 891         const char **argv,
 892         const char **envp,
 893         struct pt_regs *regs)
 894 {
 895         unsigned long addr;
 896         int nextarg = 1;
 897         long offset = 0;
 898         int diag;
 899
 900         if (argc != 1)
 901                 return KDB_ARGCOUNT;
 902         diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL, regs);
 903         if (diag)
 904                 return diag;
 905
 906         xfsidbg_xlog((xlog_t *) addr);
 907         return 0;
 908 }
 909
 910 static int      kdbm_xfs_xlog_ritem(
 911         int     argc,
 912         const char **argv,
 913         const char **envp,
 914         struct pt_regs *regs)
 915 {
 916         unsigned long addr;
 917         int nextarg = 1;
 918         long offset = 0;
 919         int diag;
 920
 921         if (argc != 1)
 922                 return KDB_ARGCOUNT;
 923         diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL, regs);
 924         if (diag)
 925                 return diag;
 926
 927         xfsidbg_xlog_ritem((xlog_recover_item_t *) addr);
 928         return 0;
 929 }
 930
 931 static int      kdbm_xfs_xlog_rtrans(
 932         int     argc,
 933         const char **argv,
 934         const char **envp,
 935         struct pt_regs *regs)
 936 {
 937         unsigned long addr;
 938         int nextarg = 1;
 939         long offset = 0;
 940         int diag;
 941
 942         if (argc != 1)
 943                 return KDB_ARGCOUNT;
 944         diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL, regs);
 945         if (diag)
 946                 return diag;
 947
 948         xfsidbg_xlog_rtrans((xlog_recover_t *) addr);
 949         return 0;
 950 }
 951
 952 static int      kdbm_xfs_xlog_rtrans_entire(
 953         int     argc,
 954         const char **argv,
 955         const char **envp,
 956         struct pt_regs *regs)
 957 {
 958         unsigned long addr;
 959         int nextarg = 1;
 960         long offset = 0;
 961         int diag;
 962
 963         if (argc != 1)
 964                 return KDB_ARGCOUNT;
 965         diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL, regs);
 966         if (diag)
 967                 return diag;
 968
 969         xfsidbg_xlog_rtrans_entire((xlog_recover_t *) addr);
 970         return 0;
 971 }
 972
 973 static int      kdbm_xfs_xlog_tic(
 974         int     argc,
 975         const char **argv,
 976         const char **envp,
 977         struct pt_regs *regs)
 978 {
 979         unsigned long addr;
 980         int nextarg = 1;
 981         long offset = 0;
 982         int diag;
 983
 984         if (argc != 1)
 985                 return KDB_ARGCOUNT;
 986         diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL, regs);
 987         if (diag)
 988                 return diag;
 989
 990         xfsidbg_xlog_tic((xlog_ticket_t *) addr);
 991         return 0;
 992 }
 993
 994 static int      kdbm_xfs_xlogitem(
 995         int     argc,
 996         const char **argv,
 997         const char **envp,
 998         struct pt_regs *regs)
 999 {
1000         unsigned long addr;
1001         int nextarg = 1;
1002         long offset = 0;
1003         int diag;
1004
1005         if (argc != 1)
1006                 return KDB_ARGCOUNT;
1007         diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL, regs);
1008         if (diag)
1009                 return diag;
1010
1011         xfsidbg_xlogitem((xfs_log_item_t *) addr);
1012         return 0;
1013 }
1014
1015 static int      kdbm_xfs_xmount(
1016         int     argc,
1017         const char **argv,
1018         const char **envp,
1019         struct pt_regs *regs)
1020 {
1021         unsigned long addr;
1022         int nextarg = 1;
1023         long offset = 0;
1024         int diag;
1025
1026         if (argc != 1)
1027                 return KDB_ARGCOUNT;
1028         diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL, regs);
1029         if (diag)
1030                 return diag;
1031
1032         xfsidbg_xmount((xfs_mount_t *) addr);
1033         return 0;
1034 }
1035
1036 static int      kdbm_xfs_xnode(
1037         int     argc,
1038         const char **argv,
1039         const char **envp,
1040         struct pt_regs *regs)
1041 {
1042         unsigned long addr;
1043         int nextarg = 1;
1044         long offset = 0;
1045         int diag;
1046
1047         if (argc != 1)
1048                 return KDB_ARGCOUNT;
1049         diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL, regs);
1050         if (diag)
1051                 return diag;
1052
1053         xfsidbg_xnode((xfs_inode_t *) addr);
1054         return 0;
1055 }
1056
1057 static int      kdbm_xfs_xcore(
1058         int     argc,
1059         const char **argv,
1060         const char **envp,
1061         struct pt_regs *regs)
1062 {
1063         unsigned long addr;
1064         int nextarg = 1;
1065         long offset = 0;
1066         int diag;
1067
1068         if (argc != 1)
1069                 return KDB_ARGCOUNT;
1070         diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL, regs);
1071         if (diag)
1072                 return diag;
1073
1074         xfsidbg_xcore((xfs_iocore_t *) addr);
1075         return 0;
1076 }
1077
1078 static int      kdbm_xfs_xperag(
1079         int     argc,
1080         const char **argv,
1081         const char **envp,
1082         struct pt_regs *regs)
1083 {
1084         unsigned long addr;
1085         int nextarg = 1;
1086         long offset = 0;
1087         int diag;
1088
1089         if (argc != 1)
1090                 return KDB_ARGCOUNT;
1091         diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL, regs);
1092         if (diag)
1093                 return diag;
1094
1095         xfsidbg_xperag((xfs_mount_t *) addr);
1096         return 0;
1097 }
1098
1099 static int      kdbm_xfs_xqm_diskdq(
1100         int     argc,
1101         const char **argv,
1102         const char **envp,
1103         struct pt_regs *regs)
1104 {
1105         unsigned long addr;
1106         int nextarg = 1;
1107         long offset = 0;
1108         int diag;
1109
1110         if (argc != 1)
1111                 return KDB_ARGCOUNT;
1112         diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL, regs);
1113         if (diag)
1114                 return diag;
1115
1116         xfsidbg_xqm_diskdq((xfs_disk_dquot_t *) addr);
1117         return 0;
1118 }
1119
1120 static int      kdbm_xfs_xqm_dqattached_inos(
1121         int     argc,
1122         const char **argv,
1123         const char **envp,
1124         struct pt_regs *regs)
1125 {
1126         unsigned long addr;
1127         int nextarg = 1;
1128         long offset = 0;
1129         int diag;
1130
1131         if (argc != 1)
1132                 return KDB_ARGCOUNT;
1133         diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL, regs);
1134         if (diag)
1135                 return diag;
1136
1137         xfsidbg_xqm_dqattached_inos((xfs_mount_t *) addr);
1138         return 0;
1139 }
1140
1141 static int      kdbm_xfs_xqm_dquot(
1142         int     argc,
1143         const char **argv,
1144         const char **envp,
1145         struct pt_regs *regs)
1146 {
1147         unsigned long addr;
1148         int nextarg = 1;
1149         long offset = 0;
1150         int diag;
1151
1152         if (argc != 1)
1153                 return KDB_ARGCOUNT;
1154         diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL, regs);
1155         if (diag)
1156                 return diag;
1157
1158         xfsidbg_xqm_dquot((xfs_dquot_t *) addr);
1159         return 0;
1160 }
1161
1162 #ifdef  CONFIG_XFS_QUOTA
1163 static int      kdbm_xfs_xqm(
1164         int     argc,
1165         const char **argv,
1166         const char **envp,
1167         struct pt_regs *regs)
1168 {
1169         if (argc != 0)
1170                 return KDB_ARGCOUNT;
1171
1172         xfsidbg_xqm();
1173         return 0;
1174 }
1175
1176 static int      kdbm_xfs_xqm_freelist(
1177         int     argc,
1178         const char **argv,
1179         const char **envp,
1180         struct pt_regs *regs)
1181 {
1182         if (argc != 0)
1183                 return KDB_ARGCOUNT;
1184
1185         xfsidbg_xqm_freelist();
1186         return 0;
1187 }
1188
1189 static int      kdbm_xfs_xqm_htab(
1190         int     argc,
1191         const char **argv,
1192         const char **envp,
1193         struct pt_regs *regs)
1194 {
1195         if (argc != 0)
1196                 return KDB_ARGCOUNT;
1197
1198         xfsidbg_xqm_htab();
1199         return 0;
1200 }
1201 #endif
1202
1203 static int      kdbm_xfs_xqm_mplist(
1204         int     argc,
1205         const char **argv,
1206         const char **envp,
1207         struct pt_regs *regs)
1208 {
1209         unsigned long addr;
1210         int nextarg = 1;
1211         long offset = 0;
1212         int diag;
1213
1214         if (argc != 1)
1215                 return KDB_ARGCOUNT;
1216         diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL, regs);
1217         if (diag)
1218                 return diag;
1219
1220         xfsidbg_xqm_mplist((xfs_mount_t *) addr);
1221         return 0;
1222 }
1223
1224 static int      kdbm_xfs_xqm_qinfo(
1225         int     argc,
1226         const char **argv,
1227         const char **envp,
1228         struct pt_regs *regs)
1229 {
1230         unsigned long addr;
1231         int nextarg = 1;
1232         long offset = 0;
1233         int diag;
1234
1235         if (argc != 1)
1236                 return KDB_ARGCOUNT;
1237         diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL, regs);
1238         if (diag)
1239                 return diag;
1240
1241         xfsidbg_xqm_qinfo((xfs_mount_t *) addr);
1242         return 0;
1243 }
1244
1245 static int      kdbm_xfs_xqm_tpdqinfo(
1246         int     argc,
1247         const char **argv,
1248         const char **envp,
1249         struct pt_regs *regs)
1250 {
1251         unsigned long addr;
1252         int nextarg = 1;
1253         long offset = 0;
1254         int diag;
1255
1256         if (argc != 1)
1257                 return KDB_ARGCOUNT;
1258         diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL, regs);
1259         if (diag)
1260                 return diag;
1261
1262         xfsidbg_xqm_tpdqinfo((xfs_trans_t *) addr);
1263         return 0;
1264 }
1265
1266 static int      kdbm_xfs_xsb(
1267         int     argc,
1268         const char **argv,
1269         const char **envp,
1270         struct pt_regs *regs)
1271 {
1272         unsigned long addr;
1273         unsigned long convert=0;
1274         int nextarg = 1;
1275         long offset = 0;
1276         int diag;
1277
1278         if (argc != 1 && argc!=2)
1279                 return KDB_ARGCOUNT;
1280         diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL, regs);
1281         if (diag)
1282                 return diag;
1283         if (argc==2) {
1284             /* extra argument - conversion flag */
1285             diag = kdbgetaddrarg(argc, argv, &nextarg, &convert, &offset, NULL, regs);
1286             if (diag)
1287                     return diag;
1288         }
1289
1290         xfsidbg_xsb((xfs_sb_t *) addr, (int)convert);
1291         return 0;
1292 }
1293
1294 static int      kdbm_xfs_xtp(
1295         int     argc,
1296         const char **argv,
1297         const char **envp,
1298         struct pt_regs *regs)
1299 {
1300         unsigned long addr;
1301         int nextarg = 1;
1302         long offset = 0;
1303         int diag;
1304
1305         if (argc != 1)
1306                 return KDB_ARGCOUNT;
1307         diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL, regs);
1308         if (diag)
1309                 return diag;
1310
1311         xfsidbg_xtp((xfs_trans_t *) addr);
1312         return 0;
1313 }
1314
1315 static int      kdbm_xfs_xtrans_res(
1316         int     argc,
1317         const char **argv,
1318         const char **envp,
1319         struct pt_regs *regs)
1320 {
1321         unsigned long addr;
1322         int nextarg = 1;
1323         long offset = 0;
1324         int diag;
1325
1326         if (argc != 1)
1327                 return KDB_ARGCOUNT;
1328         diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL, regs);
1329         if (diag)
1330                 return diag;
1331
1332         xfsidbg_xtrans_res((xfs_mount_t *) addr);
1333         return 0;
1334 }
1335
1336 /*
1337  * Vnode descriptor dump.
1338  * This table is a string version of all the flags defined in vnode.h.
1339  */
1340 char *tab_vflags[] = {
1341         /* local only flags */
1342         "VINACT",               /*       0x01 */
1343         "VRECLM",               /*       0x02 */
1344         "VWAIT",                /*       0x04 */
1345         "VMODIFIED",            /*       0x08 */
1346         "INVALID0x10",          /*       0x10 */
1347         "INVALID0x20",          /*       0x20 */
1348         "INVALID0x40",          /*       0x40 */
1349         "INVALID0x80",          /*       0x80 */
1350         "INVALID0x100",         /*      0x100 */
1351         "INVALID0x200",         /*      0x200 */
1352         "INVALID0x400",         /*      0x400 */
1353         "INVALID0x800",         /*      0x800 */
1354         "INVALID0x1000",        /*     0x1000 */
1355         "INVALID0x2000",        /*     0x2000 */
1356         "INVALID0x4000",        /*     0x4000 */
1357         "INVALID0x8000",        /*     0x8000 */
1358         "INVALID0x10000",       /*    0x10000 */
1359         "INVALID0x20000",       /*    0x20000 */
1360         "INVALID0x40000",       /*    0x40000 */
1361         "INVALID0x80000",       /*    0x80000 */
1362         "VROOT",                /*   0x100000 */
1363         "INVALID0x200000",      /*   0x200000 */
1364         "INVALID00x400000",     /*   0x400000 */
1365         "INVALID0x800000",      /*   0x800000 */
1366         "INVALID0x1000000",     /*  0x1000000 */
1367         "INVALID0x2000000",     /*  0x2000000 */
1368         "VSHARE",               /*  0x4000000 */
1369         "INVALID0x8000000",     /*  0x8000000 */
1370         "VENF_LOCKING",         /* 0x10000000 */
1371         "VOPLOCK",              /* 0x20000000 */
1372         "VPURGE",               /* 0x40000000 */
1373         "INVALID0x80000000",    /* 0x80000000 */
1374         0
1375 };
1376
1377
1378 static char *vnode_type[] = {
1379         "VNON", "VREG", "VDIR", "VBLK", "VLNK", "VFIFO", "VBAD", "VSOCK"
1380 };
1381
1382 static void
1383 printflags(register uint64_t flags,
1384         register char **strings,
1385         register char *name)
1386 {
1387         register uint64_t mask = 1;
1388
1389         if (name)
1390                 kdb_printf("%s 0x%llx <", name, (unsigned long long)flags);
1391
1392         while (flags != 0 && *strings) {
1393                 if (mask & flags) {
1394                         kdb_printf("%s ", *strings);
1395                         flags &= ~mask;
1396                 }
1397                 mask <<= 1;
1398                 strings++;
1399         }
1400
1401         if (name)
1402                 kdb_printf("> ");
1403
1404         return;
1405 }
1406
1407
1408 static void     printvnode(vnode_t *vp)
1409 {
1410         bhv_desc_t      *bh;
1411         kdb_symtab_t     symtab;
1412
1413
1414         kdb_printf("vnode: 0x%p type ", vp);
1415         if ((size_t)vp->v_type >= sizeof(vnode_type)/sizeof(vnode_type[0]))
1416                 kdb_printf("out of range 0x%x", vp->v_type);
1417         else
1418                 kdb_printf("%s", vnode_type[vp->v_type]);
1419         kdb_printf(" v_bh %p\n", &vp->v_bh);
1420
1421         if ((bh = vp->v_bh.bh_first)) {
1422                 kdb_printf("   v_inode 0x%p v_bh->bh_first 0x%p pobj 0x%p\n",
1423                                         LINVFS_GET_IP(vp), bh, bh->bd_pdata);
1424
1425                 if (kdbnearsym((unsigned long)bh->bd_ops, &symtab))
1426                         kdb_printf("   ops %s ", symtab.sym_name);
1427                 else
1428                         kdb_printf("   ops %s/0x%p ",
1429                                                 "???", (void *)bh->bd_ops);
1430         } else {
1431                 kdb_printf("   v_inode 0x%p v_bh->bh_first = NULLBHV ",
1432                                         LINVFS_GET_IP(vp));
1433         }
1434
1435         printflags((__psunsigned_t)vp->v_flag, tab_vflags, "flag =");
1436         kdb_printf("\n");
1437
1438 #ifdef  CONFIG_XFS_VNODE_TRACING
1439         kdb_printf("   v_trace 0x%p\n", vp->v_trace);
1440 #endif  /* CONFIG_XFS_VNODE_TRACING */
1441
1442         kdb_printf("   v_vfsp 0x%p v_number %Lx\n",
1443                 vp->v_vfsp, vp->v_number);
1444 }
1445
1446
1447 static int      kdbm_vnode(
1448         int     argc,
1449         const char **argv,
1450         const char **envp,
1451         struct pt_regs *regs)
1452 {
1453         unsigned long addr;
1454         int nextarg = 1;
1455         long offset = 0;
1456         int diag;
1457         vnode_t         *vp;
1458 /*      bhv_desc_t      *bh; */
1459 /*      kdb_symtab_t     symtab;*/
1460
1461         if (argc != 1)
1462                 return KDB_ARGCOUNT;
1463
1464         diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL, regs);
1465
1466         if (diag)
1467                 return diag;
1468
1469         vp = (vnode_t *)addr;
1470
1471         printvnode(vp);
1472
1473         return 0;
1474 }
1475
1476 #ifdef  CONFIG_XFS_VNODE_TRACING
1477 /*
1478  * Print a vnode trace entry.
1479  */
1480 static int
1481 vn_trace_pr_entry(ktrace_entry_t *ktep)
1482 {
1483         char            funcname[128];
1484         kdb_symtab_t    symtab;
1485
1486
1487         if ((__psint_t)ktep->val[0] == 0)
1488                 return 0;
1489
1490         if (kdbnearsym((unsigned int)ktep->val[8], &symtab)) {
1491                 unsigned long offval;
1492
1493                 offval = (unsigned int)ktep->val[8] - symtab.sym_start;
1494
1495                 if (offval)
1496                         sprintf(funcname, "%s+0x%lx", symtab.sym_name, offval);
1497                 else
1498                         sprintf(funcname, "%s", symtab.sym_name);
1499         } else
1500                 funcname[0] = '\0';
1501
1502
1503         switch ((__psint_t)ktep->val[0]) {
1504         case VNODE_KTRACE_ENTRY:
1505                 kdb_printf("entry to %s i_count = %d",
1506                                                 (char *)ktep->val[1],
1507                                                 (__psint_t)ktep->val[3]);
1508                 break;
1509
1510         case VNODE_KTRACE_EXIT:
1511                 kdb_printf("exit from %s i_count = %d",
1512                                                 (char *)ktep->val[1],
1513                                                 (__psint_t)ktep->val[3]);
1514                 break;
1515
1516         case VNODE_KTRACE_HOLD:
1517                 if ((__psint_t)ktep->val[3] != 1)
1518                         kdb_printf("hold @%s:%d(%s) i_count %d => %d ",
1519                                                 (char *)ktep->val[1],
1520                                                 (__psint_t)ktep->val[2],
1521                                                 funcname,
1522                                                 (__psint_t)ktep->val[3] - 1,
1523                                                 (__psint_t)ktep->val[3]);
1524                 else
1525                         kdb_printf("get @%s:%d(%s) i_count = %d",
1526                                                 (char *)ktep->val[1],
1527                                                 (__psint_t)ktep->val[2],
1528                                                 funcname,
1529                                                 (__psint_t)ktep->val[3]);
1530                 break;
1531
1532         case VNODE_KTRACE_REF:
1533                 kdb_printf("ref @%s:%d(%s) i_count = %d",
1534                                                 (char *)ktep->val[1],
1535                                                 (__psint_t)ktep->val[2],
1536                                                 funcname,
1537                                                 (__psint_t)ktep->val[3]);
1538                 break;
1539
1540         case VNODE_KTRACE_RELE:
1541                 if ((__psint_t)ktep->val[3] != 1)
1542                         kdb_printf("rele @%s:%d(%s) i_count %d => %d ",
1543                                                 (char *)ktep->val[1],
1544                                                 (__psint_t)ktep->val[2],
1545                                                 funcname,
1546                                                 (__psint_t)ktep->val[3],
1547                                                 (__psint_t)ktep->val[3] - 1);
1548                 else
1549                         kdb_printf("free @%s:%d(%s) i_count = %d",
1550                                                 (char *)ktep->val[1],
1551                                                 (__psint_t)ktep->val[2],
1552                                                 funcname,
1553                                                 (__psint_t)ktep->val[3]);
1554                 break;
1555
1556         default:
1557                 kdb_printf("unknown vntrace record\n");
1558                 return 1;
1559         }
1560
1561         kdb_printf("\n");
1562
1563         kdb_printf("  cpu = %d pid = %d ",
1564                         (__psint_t)ktep->val[6], (pid_t)ktep->val[7]);
1565
1566         printflags((__psunsigned_t)ktep->val[5], tab_vflags, "flag =");
1567
1568         if (kdbnearsym((unsigned int)ktep->val[4], &symtab)) {
1569                 unsigned long offval;
1570
1571                 offval = (unsigned int)ktep->val[4] - symtab.sym_start;
1572
1573                 if (offval)
1574                         kdb_printf("  ra = %s+0x%lx", symtab.sym_name, offval);
1575                 else
1576                         kdb_printf("  ra = %s", symtab.sym_name);
1577         } else
1578                 kdb_printf("  ra = ?? 0x%p", (void *)ktep->val[4]);
1579
1580         return 1;
1581 }
1582
1583
1584 /*
1585  * Print out the trace buffer attached to the given vnode.
1586  */
1587 static int      kdbm_vntrace(
1588         int     argc,
1589         const char **argv,
1590         const char **envp,
1591         struct pt_regs *regs)
1592 {
1593         int             diag;
1594         int             nextarg = 1;
1595         long            offset = 0;
1596         unsigned long   addr;
1597         vnode_t         *vp;
1598         ktrace_entry_t  *ktep;
1599         ktrace_snap_t   kts;
1600
1601
1602         if (argc != 1)
1603                 return KDB_ARGCOUNT;
1604
1605         diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL, regs);
1606
1607         if (diag)
1608                 return diag;
1609
1610         vp = (vnode_t *)addr;
1611
1612         if (vp->v_trace == NULL) {
1613                 kdb_printf("The vnode trace buffer is not initialized\n");
1614
1615                 return 0;
1616         }
1617
1618         kdb_printf("vntrace vp 0x%p\n", vp);
1619
1620         ktep = ktrace_first(vp->v_trace, &kts);
1621
1622         while (ktep != NULL) {
1623                 if (vn_trace_pr_entry(ktep))
1624                         kdb_printf("\n");
1625
1626                 ktep = ktrace_next(vp->v_trace, &kts);
1627         }
1628
1629         return 0;
1630 }
1631 /*
1632  * Print out the trace buffer attached to the given vnode.
1633  */
1634 static int      kdbm_vntraceaddr(
1635         int     argc,
1636         const char **argv,
1637         const char **envp,
1638         struct pt_regs *regs)
1639 {
1640         int             diag;
1641         int             nextarg = 1;
1642         long            offset = 0;
1643         unsigned long   addr;
1644         struct ktrace   *kt;
1645         ktrace_entry_t  *ktep;
1646         ktrace_snap_t   kts;
1647
1648
1649         if (argc != 1)
1650                 return KDB_ARGCOUNT;
1651
1652         diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL, regs);
1653
1654         if (diag)
1655                 return diag;
1656
1657         kt = (struct ktrace *)addr;
1658
1659         kdb_printf("vntraceaddr kt 0x%p\n", kt);
1660
1661         ktep = ktrace_first(kt, &kts);
1662
1663         while (ktep != NULL) {
1664                 if (vn_trace_pr_entry(ktep))
1665                         kdb_printf("\n");
1666
1667                 ktep = ktrace_next(kt, &kts);
1668         }
1669
1670         return 0;
1671 }
1672 #endif  /* CONFIG_XFS_VNODE_TRACING */
1673
1674
1675 static void     printinode(struct inode *ip)
1676 {
1677         unsigned long   addr;
1678
1679
1680         if (ip == NULL)
1681                 return;
1682
1683         kdb_printf(" i_ino = %lu i_count = %u i_size %Ld\n",
1684                                         ip->i_ino, atomic_read(&ip->i_count),
1685                                         ip->i_size);
1686
1687         kdb_printf(
1688                 " i_mode = 0x%x  i_nlink = %d  i_rdev = 0x%x i_state = 0x%lx\n",
1689                                         ip->i_mode, ip->i_nlink,
1690                                         kdev_t_to_nr(ip->i_rdev), ip->i_state);
1691
1692         kdb_printf(" i_hash.nxt = 0x%p i_hash.prv = 0x%p\n",
1693                                         ip->i_hash.next, ip->i_hash.prev);
1694         kdb_printf(" i_list.nxt = 0x%p i_list.prv = 0x%p\n",
1695                                         ip->i_list.next, ip->i_list.prev);
1696         kdb_printf(" i_dentry.nxt = 0x%p i_dentry.prv = 0x%p\n",
1697                                         ip->i_dentry.next,
1698                                         ip->i_dentry.prev);
1699
1700         addr = (unsigned long)ip;
1701
1702         kdb_printf(" i_sb = 0x%p i_op = 0x%p i_data = 0x%lx nrpages = %lu\n",
1703                                         ip->i_sb, ip->i_op,
1704                                         addr + offsetof(struct inode, i_data),
1705                                         ip->i_data.nrpages);
1706
1707         kdb_printf("  vnode ptr 0x%p\n", LINVFS_GET_VP(ip));
1708 }
1709
1710
1711 static int      kdbm_vn(
1712         int     argc,
1713         const char **argv,
1714         const char **envp,
1715         struct pt_regs *regs)
1716 {
1717         int             diag;
1718         int             nextarg = 1;
1719 /*      char            *symname; */
1720         long            offset = 0;
1721         unsigned long   addr;
1722         struct inode    *ip;
1723 /*      bhv_desc_t      *bh; */
1724 #ifdef  CONFIG_XFS_VNODE_TRACING
1725         ktrace_entry_t  *ktep;
1726         ktrace_snap_t   kts;
1727 #endif
1728         vnode_t         *vp;
1729
1730         if (argc != 1)
1731                 return KDB_ARGCOUNT;
1732
1733         diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL, regs);
1734
1735         if (diag)
1736                 return diag;
1737
1738         vp = (vnode_t *)addr;
1739
1740         ip = LINVFS_GET_IP(vp);
1741
1742         kdb_printf("--> Inode @ 0x%p\n", ip);
1743         printinode(ip);
1744
1745         kdb_printf("--> Vnode @ 0x%p\n", vp);
1746         printvnode(vp);
1747
1748 #ifdef  CONFIG_XFS_VNODE_TRACING
1749
1750         kdb_printf("--> Vntrace @ 0x%p/0x%p\n", vp, vp->v_trace);
1751
1752         if (vp->v_trace == NULL)
1753                 return 0;
1754
1755         ktep = ktrace_first(vp->v_trace, &kts);
1756
1757         while (ktep != NULL) {
1758                 if (vn_trace_pr_entry(ktep))
1759                         kdb_printf("\n");
1760
1761                 ktep = ktrace_next(vp->v_trace, &kts);
1762         }
1763 #endif  /* CONFIG_XFS_VNODE_TRACING */
1764
1765         return 0;
1766 }
1767
1768
1769 /* pagebuf stuff */
1770
1771 static char     *pb_flag_vals[] = {
1772 /*  0 */ "READ", "WRITE", "MAPPED", "PARTIAL", "ASYNC",
1773 /*  5 */ "NONE", "DELWRI", "FREED", "SYNC", "MAPPABLE",
1774 /* 10 */ "STALE", "FS_MANAGED", "INVALID12", "LOCK", "TRYLOCK",
1775 /* 15 */ "DONT_BLOCK", "LOCKABLE", "PRIVATE_BH", "ALL_PAGES_MAPPED",
1776          "ADDR_ALLOCATED",
1777 /* 20 */ "MEM_ALLOCATED", "FORCEIO", "FLUSH", "READ_AHEAD",
1778          NULL };
1779
1780 static char     *pbm_flag_vals[] = {
1781         "EOF", "HOLE", "DELAY", "INVALID0x08",
1782         "INVALID0x10", "UNWRITTEN", "INVALID0x40", "INVALID0x80",
1783         NULL };
1784
1785
1786 static char     *map_flags(unsigned long flags, char *mapping[])
1787 {
1788         static  char    buffer[256];
1789         int     index;
1790         int     offset = 12;
1791
1792         buffer[0] = '\0';
1793
1794         for (index = 0; flags && mapping[index]; flags >>= 1, index++) {
1795                 if (flags & 1) {
1796                         if ((offset + strlen(mapping[index]) + 1) >= 80) {
1797                                 strcat(buffer, "\n            ");
1798                                 offset = 12;
1799                         } else if (offset > 12) {
1800                                 strcat(buffer, " ");
1801                                 offset++;
1802                         }
1803                         strcat(buffer, mapping[index]);
1804                         offset += strlen(mapping[index]);
1805                 }
1806         }
1807
1808         return (buffer);
1809 }
1810
1811 static char     *pb_flags(page_buf_flags_t pb_flag)
1812 {
1813         return(map_flags((unsigned long) pb_flag, pb_flag_vals));
1814 }
1815
1816 static int
1817 kdbm_pb_flags(int argc, const char **argv, const char **envp, struct pt_regs *regs)
1818 {
1819         unsigned long flags;
1820         int diag;
1821
1822         if (argc != 1)
1823                 return KDB_ARGCOUNT;
1824
1825         diag = kdbgetularg(argv[1], &flags);
1826         if (diag)
1827                 return diag;
1828
1829         kdb_printf("pb flags 0x%lx = %s\n", flags, pb_flags(flags));
1830
1831         return 0;
1832 }
1833
1834 static int
1835 kdbm_pb(int argc, const char **argv, const char **envp, struct pt_regs *regs)
1836 {
1837         page_buf_t bp;
1838         unsigned long addr;
1839         long    offset=0;
1840         int nextarg;
1841         int diag;
1842
1843         if (argc != 1)
1844                 return KDB_ARGCOUNT;
1845
1846         nextarg = 1;
1847         if ((diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL, regs)) ||
1848             (diag = kdb_getarea(bp, addr)))
1849                 return diag;
1850
1851         kdb_printf("page_buf_t at 0x%lx\n", addr);
1852         kdb_printf("  pb_flags %s\n", pb_flags(bp.pb_flags));
1853         kdb_printf("  pb_target 0x%p pb_hold %d pb_next 0x%p pb_prev 0x%p\n",
1854                    bp.pb_target, bp.pb_hold.counter,
1855                    bp.pb_list.next, bp.pb_list.prev);
1856         kdb_printf("  pb_hash_index %d pb_hash_next 0x%p pb_hash_prev 0x%p\n",
1857                    bp.pb_hash_index,
1858                    bp.pb_hash_list.next,
1859                    bp.pb_hash_list.prev);
1860         kdb_printf("  pb_file_offset 0x%llx pb_buffer_length 0x%llx pb_addr 0x%p\n",
1861                    (unsigned long long) bp.pb_file_offset,
1862                    (unsigned long long) bp.pb_buffer_length,
1863                    bp.pb_addr);
1864         kdb_printf("  pb_bn 0x%Lx pb_count_desired 0x%lx\n",
1865                    bp.pb_bn,
1866                    (unsigned long) bp.pb_count_desired);
1867         kdb_printf("  pb_io_remaining %d pb_error %u\n",
1868                    bp.pb_io_remaining.counter,
1869                    bp.pb_error);
1870         kdb_printf("  pb_page_count %u pb_offset 0x%x pb_pages 0x%p\n",
1871                 bp.pb_page_count, bp.pb_offset,
1872                 bp.pb_pages);
1873 #ifdef PAGEBUF_LOCK_TRACKING
1874         kdb_printf("  pb_iodonesema (%d,%d) pb_sema (%d,%d) pincount (%d) last holder %d\n",
1875                    bp.pb_iodonesema.count.counter,
1876                    bp.pb_iodonesema.sleepers,
1877                    bp.pb_sema.count.counter, bp.pb_sema.sleepers,
1878                    bp.pb_pin_count.counter, bp.pb_last_holder);
1879 #else
1880         kdb_printf("  pb_iodonesema (%d,%d) pb_sema (%d,%d) pincount (%d)\n",
1881                    bp.pb_iodonesema.count.counter,
1882                    bp.pb_iodonesema.sleepers,
1883                    bp.pb_sema.count.counter, bp.pb_sema.sleepers,
1884                    bp.pb_pin_count.counter);
1885 #endif
1886         if (bp.pb_fspriv || bp.pb_fspriv2) {
1887                 kdb_printf(  "pb_fspriv 0x%p pb_fspriv2 0x%p\n",
1888                            bp.pb_fspriv, bp.pb_fspriv2);
1889         }
1890
1891         return 0;
1892 }
1893
1894 /* XXXXXXXXXXXXXXXXXXXXXX */
1895 /* The start of this deliberately looks like a read_descriptor_t in layout */
1896 typedef struct {
1897         read_descriptor_t io_rdesc;
1898
1899         /* 0x10 */
1900         page_buf_rw_t io_dir;   /* read or write */
1901         loff_t io_offset;       /* Starting offset of I/O */
1902         int io_iovec_nr;        /* Number of entries in iovec */
1903
1904         /* 0x20 */
1905         struct iovec **io_iovec;        /* iovec list indexed by iovec_index */
1906         loff_t io_iovec_offset; /* offset into current iovec. */
1907         int io_iovec_index;     /* current iovec being processed */
1908         unsigned int io_sshift; /* sector bit shift */
1909         loff_t io_i_size;       /* size of the file */
1910 } pb_io_desc_t;
1911
1912 static int
1913 kdbm_pbiodesc(int argc, const char **argv, const char **envp,
1914         struct pt_regs *regs)
1915 {
1916         pb_io_desc_t    pbio;
1917         unsigned long addr;
1918         long    offset=0;
1919         int nextarg;
1920         int diag;
1921
1922         if (argc != 1)
1923                 return KDB_ARGCOUNT;
1924
1925         nextarg = 1;
1926         if ((diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL, regs)) ||
1927             (diag = kdb_getarea(pbio, addr)))
1928
1929         kdb_printf("pb_io_desc_t at 0x%lx\n", addr);
1930         kdb_printf("  io_rdesc [ written 0x%lx count 0x%lx buf 0x%p error %d ]\n",
1931                         (unsigned long) pbio.io_rdesc.written,
1932                         (unsigned long) pbio.io_rdesc.count,
1933                         pbio.io_rdesc.buf, pbio.io_rdesc.error);
1934
1935         kdb_printf("  io_dir %d io_offset 0x%Lx io_iovec_nr 0x%d\n",
1936                         pbio.io_dir, pbio.io_offset, pbio.io_iovec_nr);
1937
1938         kdb_printf("  io_iovec 0x%p io_iovec_offset 0x%Lx io_iovec_index 0x%d\n",
1939                 pbio.io_iovec, pbio.io_iovec_offset, pbio.io_iovec_index);
1940
1941         kdb_printf("  io_sshift 0x%d io_i_size 0x%Lx\n",
1942                 pbio.io_sshift, pbio.io_i_size);
1943
1944         return 0;
1945 }
1946
1947 static int
1948 kdbm_pbmap(int argc, const char **argv, const char **envp,
1949         struct pt_regs *regs)
1950 {
1951         page_buf_bmap_t pbm;
1952         unsigned long addr;
1953         long    offset=0;
1954         int nextarg;
1955         int diag;
1956
1957         if (argc != 1)
1958                 return KDB_ARGCOUNT;
1959
1960         nextarg = 1;
1961         if ((diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL, regs)) ||
1962             (diag = kdb_getarea(pbm, addr)))
1963
1964         kdb_printf("page_buf_bmap_t at 0x%lx\n", addr);
1965         kdb_printf("  pbm_bn 0x%llx pbm_offset 0x%Lx pbm_delta 0x%lx pbm_bsize 0x%lx\n",
1966                 (long long) pbm.pbm_bn, pbm.pbm_offset,
1967                 (unsigned long) pbm.pbm_delta, (unsigned long) pbm.pbm_bsize);
1968
1969         kdb_printf("  pbm_flags %s\n", map_flags(pbm.pbm_flags, pbm_flag_vals));
1970
1971         return 0;
1972 }
1973
1974 #ifdef PAGEBUF_TRACE
1975 # ifdef __PAGEBUF_TRACE__
1976 # undef __PAGEBUF_TRACE__
1977 # undef PB_DEFINE_TRACES
1978 # undef PB_TRACE_START
1979 # undef PB_TRACE_REC
1980 # undef PB_TRACE_END
1981 # endif
1982 #include "pagebuf/page_buf_trace.h"
1983
1984 #define EV_SIZE (sizeof(event_names)/sizeof(char *))
1985
1986 void
1987 pb_trace_core(
1988         unsigned long match,
1989         char    *event_match,
1990         unsigned long long offset,
1991         long long mask)
1992 {
1993         extern struct pagebuf_trace_buf pb_trace;
1994         int i, total, end;
1995         pagebuf_trace_t *trace;
1996         char    *event;
1997         char    value[10];
1998
1999         end = pb_trace.start - 1;
2000         if (end < 0)
2001                 end = PB_TRACE_BUFSIZE - 1;
2002
2003         if (match && (match < PB_TRACE_BUFSIZE)) {
2004                 for (i = pb_trace.start, total = 0; i != end; i = CIRC_INC(i)) {
2005                         trace = &pb_trace.buf[i];
2006                         if (trace->pb == 0)
2007                                 continue;
2008                         total++;
2009                 }
2010                 total = total - match;
2011                 for (i = pb_trace.start; i != end && total; i = CIRC_INC(i)) {
2012                         trace = &pb_trace.buf[i];
2013                         if (trace->pb == 0)
2014                                 continue;
2015                         total--;
2016                 }
2017                 match = 0;
2018         } else
2019                 i = pb_trace.start;
2020         for ( ; i != end; i = CIRC_INC(i)) {
2021                 trace = &pb_trace.buf[i];
2022
2023                 if (offset) {
2024                         if ((trace->offset & ~mask) != offset)
2025                                 continue;
2026                 }
2027
2028                 if (trace->pb == 0)
2029                         continue;
2030
2031                 if ((match != 0) && (trace->pb != match))
2032                         continue;
2033
2034                 if ((trace->event < EV_SIZE-1) && event_names[trace->event]) {
2035                         event = event_names[trace->event];
2036                 } else if (trace->event == EV_SIZE-1) {
2037                         event = (char *)trace->misc;
2038                 } else {
2039                         event = value;
2040                         sprintf(value, "%8d", trace->event);
2041                 }
2042
2043                 if (event_match && strcmp(event, event_match)) {
2044                         continue;
2045                 }
2046
2047
2048                 kdb_printf("pb 0x%lx [%s] (hold %u lock %d) misc 0x%p",
2049                            trace->pb, event,
2050                            trace->hold, trace->lock_value,
2051                            trace->misc);
2052                 kdb_symbol_print((unsigned int)trace->ra, NULL,
2053                         KDB_SP_SPACEB|KDB_SP_PAREN|KDB_SP_NEWLINE);
2054                 kdb_printf("    offset 0x%Lx size 0x%x task 0x%p\n",
2055                            trace->offset, trace->size, trace->task);
2056                 kdb_printf("    flags: %s\n",
2057                            pb_flags(trace->flags));
2058         }
2059 }
2060
2061
2062 static int
2063 kdbm_pbtrace_offset(int argc, const char **argv, const char **envp,
2064         struct pt_regs *regs)
2065 {
2066         long mask = 0;
2067         unsigned long offset = 0;
2068         int diag;
2069
2070         if (argc > 2)
2071                 return KDB_ARGCOUNT;
2072
2073         if (argc > 0) {
2074                 diag = kdbgetularg(argv[1], &offset);
2075                 if (diag)
2076                         return diag;
2077         }
2078
2079         if (argc > 1) {
2080                 diag = kdbgetularg(argv[1], &mask);
2081                 if (diag)
2082                         return diag;
2083         }
2084
2085         pb_trace_core(0, NULL, (unsigned long long)offset,
2086                                (long long)mask);        /* sign extent mask */
2087         return 0;
2088 }
2089
2090 static int
2091 kdbm_pbtrace(int argc, const char **argv, const char **envp,
2092         struct pt_regs *regs)
2093 {
2094         unsigned long addr = 0;
2095         int diag, nextarg;
2096         long offset = 0;
2097         char    *event_match = NULL;
2098
2099         if (argc > 1)
2100                 return KDB_ARGCOUNT;
2101
2102         if (argc == 1) {
2103                 if (isupper(argv[1][0]) || islower(argv[1][0])) {
2104                         event_match = (char *)argv[1];
2105                         printk("event match on \"%s\"\n", event_match);
2106                         argc = 0;
2107                 } else {
2108                         nextarg = 1;
2109                         diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL, regs);
2110                         if (diag) {
2111                                 printk("failed to parse %s as a number\n",
2112                                                                 argv[1]);
2113                                 return diag;
2114                         }
2115                 }
2116         }
2117
2118         pb_trace_core(addr, event_match, 0LL, 0LL);
2119         return 0;
2120 }
2121
2122 #else   /* PAGEBUF_TRACE */
2123 static int
2124 kdbm_pbtrace(int argc, const char **argv, const char **envp,
2125         struct pt_regs *regs)
2126 {
2127         kdb_printf("pagebuf tracing not compiled in\n");
2128
2129         return 0;
2130 }
2131 #endif  /* PAGEBUF_TRACE */
2132
2133 static struct xif {
2134         char    *name;
2135         int     (*func)(int, const char **, const char **, struct pt_regs *);
2136         char    *args;
2137         char    *help;
2138 } xfsidbg_funcs[] = {
2139   {  "vn",      kdbm_vn,        "<vnode>", "Dump inode/vnode/trace"},
2140   {  "vnode",   kdbm_vnode,     "<vnode>", "Dump vnode"},
2141 #ifdef  CONFIG_XFS_VNODE_TRACING
2142   {  "vntrace", kdbm_vntrace,   "<vntrace>", "Dump vnode Trace"},
2143   {  "vntraceaddr",     kdbm_vntraceaddr, "<vntrace>", "Dump vnode Trace by Address"},
2144 #endif  /* CONFIG_XFS_VNODE_TRACING */
2145   {  "xagf",    kdbm_xfs_xagf,  "<agf>",
2146                                 "Dump XFS allocation group freespace" },
2147   {  "xagi",    kdbm_xfs_xagi,  "<agi>",
2148                                 "Dump XFS allocation group inode" },
2149   {  "xail",    kdbm_xfs_xaildump,      "<xfs_mount_t>",
2150                                 "Dump XFS AIL for a mountpoint" },
2151   {  "xalloc",  kdbm_xfs_xalloc,        "<xfs_alloc_arg_t>",
2152                                 "Dump XFS allocation args structure" },
2153 #ifdef DEBUG
2154   {  "xalmtrc", kdbm_xfs_xalmtrace,     "<xfs_mount_t>",
2155                                 "Dump XFS alloc mount-point trace" },
2156 #endif
2157   {  "xattrcx", kdbm_xfs_xattrcontext,  "<xfs_attr_list_context_t>",
2158                                 "Dump XFS attr_list context struct"},
2159   {  "xattrlf", kdbm_xfs_xattrleaf,     "<xfs_attr_leafblock_t>",
2160                                 "Dump XFS attribute leaf block"},
2161   {  "xattrsf", kdbm_xfs_xattrsf,       "<xfs_attr_shortform_t>",
2162                                 "Dump XFS attribute shortform"},
2163   {  "xbirec",  kdbm_xfs_xbirec,        "<xfs_bmbt_irec_t",
2164                                 "Dump XFS bmap incore record"},
2165   {  "xbmalla", kdbm_xfs_xbmalla,       "<xfs_bmalloca_t>",
2166                                 "Dump XFS bmalloc args structure"},
2167   {  "xbrec",   kdbm_xfs_xbrec,         "<xfs_bmbt_rec_64_t",
2168                                 "Dump XFS bmap record"},
2169   {  "xbroot",  kdbm_xfs_xbroot,        "<xfs_inode_t>",
2170                                 "Dump XFS bmap btree root (data)"},
2171   {  "xbroota", kdbm_xfs_xbroota,       "<xfs_inode_t>",
2172                                 "Dump XFS bmap btree root (attr)"},
2173   {  "xbtcur",  kdbm_xfs_xbtcur,        "<xfs_btree_cur_t>",
2174                                 "Dump XFS btree cursor"},
2175   {  "xbuf",    kdbm_xfs_xbuf,          "<xfs_buf_t>",
2176                                 "Dump XFS data from a buffer"},
2177   {  "xchash",  kdbm_xfs_xchash,        "<xfs_mount_t>",
2178                                 "Dump XFS cluster hash"},
2179   {  "xchlist", kdbm_xfs_xchashlist,    "<xfs_chashlist_t>",
2180                                 "Dump XFS cluster hash list"},
2181   {  "xd2free", kdbm_xfs_xdir2free,     "<xfs_dir2_free_t>",
2182                                 "Dump XFS directory v2 freemap"},
2183   {  "xdaargs", kdbm_xfs_xdaargs,       "<xfs_da_args_t>",
2184                                 "Dump XFS dir/attr args structure"},
2185   {  "xdabuf",  kdbm_xfs_xdabuf,        "<xfs_dabuf_t>",
2186                                 "Dump XFS dir/attr buf structure"},
2187   {  "xdanode", kdbm_xfs_xdanode,       "<xfs_da_intnode_t>",
2188                                 "Dump XFS dir/attr node block"},
2189   {  "xdastat", kdbm_xfs_xdastate,      "<xfs_da_state_t>",
2190                                 "Dump XFS dir/attr state_blk struct"},
2191   {  "xdelay",  kdbm_xfs_delayed_blocks,        "<xfs_mount_t>",
2192                                 "Dump delayed block totals"},
2193   {  "xdirlf",  kdbm_xfs_xdirleaf,      "<xfs_dir_leafblock_t>",
2194                                 "Dump XFS directory leaf block"},
2195   {  "xdirsf",  kdbm_xfs_xdirsf,        "<xfs_dir_shortform_t>",
2196                                 "Dump XFS directory shortform"},
2197   {  "xdir2sf", kdbm_xfs_xdir2sf,       "<xfs_dir2_sf_t>",
2198                                 "Dump XFS directory v2 shortform"},
2199   {  "xdiskdq", kdbm_xfs_xqm_diskdq,    "<xfs_disk_dquot_t>",
2200                                 "Dump XFS ondisk dquot (quota) struct"},
2201   {  "xdqatt",  kdbm_xfs_xqm_dqattached_inos,   "<xfs_mount_t>",
2202                                  "All incore inodes with dquots"},
2203   {  "xdqinfo", kdbm_xfs_xqm_tpdqinfo,  "<xfs_trans_t>",
2204                                 "Dump dqinfo structure of a trans"},
2205   {  "xdquot",  kdbm_xfs_xqm_dquot,     "<xfs_dquot_t>",
2206                                 "Dump XFS dquot (quota) structure"},
2207   {  "xexlist", kdbm_xfs_xexlist,       "<xfs_inode_t>",
2208                                 "Dump XFS bmap extents in inode"},
2209   {  "xflist",  kdbm_xfs_xflist,        "<xfs_bmap_free_t>",
2210                                 "Dump XFS to-be-freed extent list"},
2211   {  "xhelp",   kdbm_xfs_xhelp,         "",
2212                                 "Print idbg-xfs help"},
2213   {  "xicall",  kdbm_xfs_xiclogall,     "<xlog_in_core_t>",
2214                                 "Dump All XFS in-core logs"},
2215   {  "xiclog",  kdbm_xfs_xiclog,        "<xlog_in_core_t>",
2216                                 "Dump XFS in-core log"},
2217   {  "xihash",  kdbm_xfs_xihash,        "<xfs_mount_t>",
2218                                 "Dump XFS inode hash statistics"},
2219   {  "xinodes", kdbm_xfs_xinodes,       "<xfs_mount_t>",
2220                                 "Dump XFS inodes per mount"},
2221   {  "xquiesce",kdbm_xfs_xinodes_quiesce, "<xfs_mount_t>",
2222                                 "Dump non-quiesced XFS inodes per mount"},
2223   {  "xl_rcit", kdbm_xfs_xlog_ritem,    "<xlog_recover_item_t>",
2224                                 "Dump XFS recovery item"},
2225   {  "xl_rctr", kdbm_xfs_xlog_rtrans,   "<xlog_recover_t>",
2226                                 "Dump XFS recovery transaction"},
2227   {  "xl_rctr2",kdbm_xfs_xlog_rtrans_entire,    "<xlog_recover_t>",
2228                                 "Dump entire recovery transaction"},
2229   {  "xl_tic",  kdbm_xfs_xlog_tic,      "<xlog_ticket_t>",
2230                                 "Dump XFS log ticket"},
2231   {  "xlog",    kdbm_xfs_xlog,  "<xlog_t>",
2232                                 "Dump XFS log"},
2233   {  "xlogcb",  kdbm_xfs_xiclogcb,      "<xlog_in_core_t>",
2234                                 "Dump XFS in-core log callbacks"},
2235   {  "xlogitm", kdbm_xfs_xlogitem,      "<xfs_log_item_t>",
2236                                 "Dump XFS log item structure"},
2237   {  "xmount",  kdbm_xfs_xmount,        "<xfs_mount_t>",
2238                                 "Dump XFS mount structure"},
2239   {  "xnode",   kdbm_xfs_xnode,         "<xfs_inode_t>",
2240                                 "Dump XFS inode"},
2241   {  "xiocore", kdbm_xfs_xcore,         "<xfs_iocore_t>",
2242                                 "Dump XFS iocore"},
2243   {  "xperag",  kdbm_xfs_xperag,        "<xfs_mount_t>",
2244                                 "Dump XFS per-allocation group data"},
2245   {  "xqinfo",  kdbm_xfs_xqm_qinfo,     "<xfs_mount_t>",
2246                                 "Dump mount->m_quotainfo structure"},
2247 #ifdef  CONFIG_XFS_QUOTA
2248   {  "xqm",     kdbm_xfs_xqm,           "",
2249                                 "Dump XFS quota manager structure"},
2250   {  "xqmfree", kdbm_xfs_xqm_freelist,  "",
2251                                 "Dump XFS global freelist of dquots"},
2252   {  "xqmhtab", kdbm_xfs_xqm_htab,      "",
2253                                 "Dump XFS hashtable of dquots"},
2254 #endif  /* CONFIG_XFS_QUOTA */
2255   {  "xqmplist",kdbm_xfs_xqm_mplist,    "<xfs_mount_t>",
2256                                 "Dump XFS all dquots of a f/s"},
2257   {  "xsb",     kdbm_xfs_xsb,           "<xfs_sb_t> <cnv>",
2258                                 "Dump XFS superblock"},
2259   {  "xtp",     kdbm_xfs_xtp,           "<xfs_trans_t>",
2260                                 "Dump XFS transaction structure"},
2261   {  "xtrres",  kdbm_xfs_xtrans_res,    "<xfs_mount_t>",
2262                                 "Dump XFS reservation values"},
2263   {  0,         0,      0 }
2264 };
2265
2266 static int
2267 __init xfsidbg_init(void)
2268 {
2269         struct xif      *p;
2270
2271         for (p = xfsidbg_funcs; p->name; p++)
2272                 kdb_register(p->name, p->func, p->args, p->help, 0);
2273
2274         kdb_register("pb", kdbm_pb, "<vaddr>", "Display page_buf_t", 0);
2275         kdb_register("pbflags", kdbm_pb_flags, "<flags>",
2276                                         "Display page buf flags", 0);
2277         kdb_register("pbiodesc", kdbm_pbiodesc, "<pb_io_desc_t *>",
2278                                         "Display I/O Descriptor", 0);
2279         kdb_register("pbmap", kdbm_pbmap, "<page_buf_bmap_t *>",
2280                                         "Display Bmap", 0);
2281         kdb_register("pbtrace", kdbm_pbtrace, "<vaddr>|<count>",
2282                                         "page_buf_t trace", 0);
2283 #ifdef PAGEBUF_TRACE
2284         kdb_register("pboffset", kdbm_pbtrace_offset, "<addr> [<mask>]",
2285                                         "page_buf_t trace", 0);
2286 #endif
2287         return 0;
2288 }
2289
2290 static void
2291 __exit xfsidbg_exit(void)
2292 {
2293         struct xif      *p;
2294
2295         for (p = xfsidbg_funcs; p->name; p++)
2296                 kdb_unregister(p->name);
2297
2298         kdb_unregister("pb");
2299         kdb_unregister("pbflags");
2300         kdb_unregister("pbmap");
2301         kdb_unregister("pbiodesc");
2302         kdb_unregister("pbtrace");
2303 #ifdef PAGEBUF_TRACE
2304         kdb_unregister("pboffset");
2305 #endif
2306
2307 }
2308
2309 /*
2310  * Argument to xfs_alloc routines, for allocation type.
2311  */
2312 static char *xfs_alloctype[] = {
2313         "any_ag", "first_ag", "start_ag", "this_ag",
2314         "start_bno", "near_bno", "this_bno"
2315 };
2316
2317
2318 /*
2319  * Prototypes for static functions.
2320  */
2321 #ifdef DEBUG
2322 static int xfs_alloc_trace_entry(ktrace_entry_t *ktep);
2323 #endif
2324 static void xfs_broot(xfs_inode_t *ip, xfs_ifork_t *f);
2325 static void xfs_btalloc(xfs_alloc_block_t *bt, int bsz);
2326 static void xfs_btbmap(xfs_bmbt_block_t *bt, int bsz);
2327 static void xfs_btino(xfs_inobt_block_t *bt, int bsz);
2328 static void xfs_buf_item_print(xfs_buf_log_item_t *blip, int summary);
2329 static void xfs_dastate_path(xfs_da_state_path_t *p);
2330 static void xfs_dir2data(void *addr, int size);
2331 static void xfs_dir2leaf(xfs_dir2_leaf_t *leaf, int size);
2332 static void xfs_dquot_item_print(xfs_dq_logitem_t *lip, int summary);
2333 static void xfs_efd_item_print(xfs_efd_log_item_t *efdp, int summary);
2334 static void xfs_efi_item_print(xfs_efi_log_item_t *efip, int summary);
2335 static char *xfs_fmtformat(xfs_dinode_fmt_t f);
2336 static char *xfs_fmtfsblock(xfs_fsblock_t bno, xfs_mount_t *mp);
2337 static char *xfs_fmtino(xfs_ino_t ino, xfs_mount_t *mp);
2338 static char *xfs_fmtlsn(xfs_lsn_t *lsnp);
2339 static char *xfs_fmtmode(int m);
2340 static char *xfs_fmtsize(size_t i);
2341 static char *xfs_fmtuuid(uuid_t *);
2342 static void xfs_inode_item_print(xfs_inode_log_item_t *ilip, int summary);
2343 static void xfs_inodebuf(xfs_buf_t *bp);
2344 static void xfs_prdinode(xfs_dinode_t *di, int coreonly, int convert);
2345 static void xfs_prdinode_core(xfs_dinode_core_t *dip, int convert);
2346 static void xfs_qoff_item_print(xfs_qoff_logitem_t *lip, int summary);
2347 static void xfs_xexlist_fork(xfs_inode_t *ip, int whichfork);
2348 static void xfs_xnode_fork(char *name, xfs_ifork_t *f);
2349
2350 /*
2351  * Static functions.
2352  */
2353
2354 #ifdef DEBUG
2355 /*
2356  * Print xfs alloc trace buffer entry.
2357  */
2358 static int
2359 xfs_alloc_trace_entry(ktrace_entry_t *ktep)
2360 {
2361         static char *modagf_flags[] = {
2362                 "magicnum",
2363                 "versionnum",
2364                 "seqno",
2365                 "length",
2366                 "roots",
2367                 "levels",
2368                 "flfirst",
2369                 "fllast",
2370                 "flcount",
2371                 "freeblks",
2372                 "longest",
2373                 NULL
2374         };
2375
2376         if (((__psint_t)ktep->val[0] & 0xffff) == 0)
2377                 return 0;
2378         switch ((long)ktep->val[0] & 0xffffL) {
2379         case XFS_ALLOC_KTRACE_ALLOC:
2380                 kdb_printf("alloc %s[%s %d] mp 0x%p\n",
2381                         (char *)ktep->val[1],
2382                         ktep->val[2] ? (char *)ktep->val[2] : "",
2383                         (__psint_t)ktep->val[0] >> 16,
2384                         (xfs_mount_t *)ktep->val[3]);
2385                 kdb_printf(
2386         "agno %d agbno %d minlen %d maxlen %d mod %d prod %d minleft %d\n",
2387                         (__psunsigned_t)ktep->val[4],
2388                         (__psunsigned_t)ktep->val[5],
2389                         (__psunsigned_t)ktep->val[6],
2390                         (__psunsigned_t)ktep->val[7],
2391                         (__psunsigned_t)ktep->val[8],
2392                         (__psunsigned_t)ktep->val[9],
2393                         (__psunsigned_t)ktep->val[10]);
2394                 kdb_printf("total %d alignment %d len %d type %s otype %s\n",
2395                         (__psunsigned_t)ktep->val[11],
2396                         (__psunsigned_t)ktep->val[12],
2397                         (__psunsigned_t)ktep->val[13],
2398                         xfs_alloctype[((__psint_t)ktep->val[14]) >> 16],
2399                         xfs_alloctype[((__psint_t)ktep->val[14]) & 0xffff]);
2400                 kdb_printf("wasdel %d wasfromfl %d isfl %d userdata %d\n",
2401                         ((__psint_t)ktep->val[15] & (1 << 3)) != 0,
2402                         ((__psint_t)ktep->val[15] & (1 << 2)) != 0,
2403                         ((__psint_t)ktep->val[15] & (1 << 1)) != 0,
2404                         ((__psint_t)ktep->val[15] & (1 << 0)) != 0);
2405                 break;
2406         case XFS_ALLOC_KTRACE_FREE:
2407                 kdb_printf("free %s[%s %d] mp 0x%p\n",
2408                         (char *)ktep->val[1],
2409                         ktep->val[2] ? (char *)ktep->val[2] : "",
2410                         (__psint_t)ktep->val[0] >> 16,
2411                         (xfs_mount_t *)ktep->val[3]);
2412                 kdb_printf("agno %d agbno %d len %d isfl %d\n",
2413                         (__psunsigned_t)ktep->val[4],
2414                         (__psunsigned_t)ktep->val[5],
2415                         (__psunsigned_t)ktep->val[6],
2416                         (__psint_t)ktep->val[7]);
2417                 break;
2418         case XFS_ALLOC_KTRACE_MODAGF:
2419                 kdb_printf("modagf %s[%s %d] mp 0x%p\n",
2420                         (char *)ktep->val[1],
2421                         ktep->val[2] ? (char *)ktep->val[2] : "",
2422                         (__psint_t)ktep->val[0] >> 16,
2423                         (xfs_mount_t *)ktep->val[3]);
2424                 printflags((__psint_t)ktep->val[4], modagf_flags, "modified");
2425                 kdb_printf("seqno %d length %d roots b %d c %d\n",
2426                         (__psunsigned_t)ktep->val[5],
2427                         (__psunsigned_t)ktep->val[6],
2428                         (__psunsigned_t)ktep->val[7],
2429                         (__psunsigned_t)ktep->val[8]);
2430                 kdb_printf("levels b %d c %d flfirst %d fllast %d flcount %d\n",
2431                         (__psunsigned_t)ktep->val[9],
2432                         (__psunsigned_t)ktep->val[10],
2433                         (__psunsigned_t)ktep->val[11],
2434                         (__psunsigned_t)ktep->val[12],
2435                         (__psunsigned_t)ktep->val[13]);
2436                 kdb_printf("freeblks %d longest %d\n",
2437                         (__psunsigned_t)ktep->val[14],
2438                         (__psunsigned_t)ktep->val[15]);
2439                 break;
2440
2441         case XFS_ALLOC_KTRACE_UNBUSY:
2442                 kdb_printf("unbusy %s [%s %d] mp 0x%p\n",
2443                         (char *)ktep->val[1],
2444                         ktep->val[2] ? (char *)ktep->val[2] : "",
2445                         (__psint_t)ktep->val[0] >> 16,
2446                         (xfs_mount_t *)ktep->val[3]);
2447                 kdb_printf("      agno %d slot %d tp 0x%x\n",
2448                         (__psunsigned_t)ktep->val[4],
2449                         (__psunsigned_t)ktep->val[7],
2450                         (__psunsigned_t)ktep->val[8]);
2451                 break;
2452         case XFS_ALLOC_KTRACE_BUSY:
2453                 kdb_printf("busy %s [%s %d] mp 0x%p\n",
2454                         (char *)ktep->val[1],
2455                         ktep->val[2] ? (char *)ktep->val[2] : "",
2456                         (__psint_t)ktep->val[0] >> 16,
2457                         (xfs_mount_t *)ktep->val[3]);
2458                 kdb_printf("      agno %d agbno %d len %d slot %d tp 0x%x\n",
2459                         (__psunsigned_t)ktep->val[4],
2460                         (__psunsigned_t)ktep->val[5],
2461                         (__psunsigned_t)ktep->val[6],
2462                         (__psunsigned_t)ktep->val[7],
2463                         (__psunsigned_t)ktep->val[8]);
2464                 break;
2465         case XFS_ALLOC_KTRACE_BUSYSEARCH:
2466                 kdb_printf("busy-search %s [%s %d] mp 0x%p\n",
2467                         (char *)ktep->val[1],
2468                         ktep->val[2] ? (char *)ktep->val[2] : "",
2469                         (__psint_t)ktep->val[0] >> 16,
2470                         (xfs_mount_t *)ktep->val[3]);
2471                 kdb_printf("      agno %d agbno %d len %d slot %d tp 0x%x\n",
2472                         (__psunsigned_t)ktep->val[4],
2473                         (__psunsigned_t)ktep->val[5],
2474                         (__psunsigned_t)ktep->val[6],
2475                         (__psunsigned_t)ktep->val[7],
2476                         (__psunsigned_t)ktep->val[8]);
2477                 break;
2478         default:
2479                 kdb_printf("unknown alloc trace record\n");
2480                 break;
2481         }
2482         return 1;
2483 }
2484 #endif /* DEBUG */
2485
2486 /*
2487  * Print an xfs in-inode bmap btree root.
2488  */
2489 static void
2490 xfs_broot(xfs_inode_t *ip, xfs_ifork_t *f)
2491 {
2492         xfs_bmbt_block_t        *broot;
2493         int                     format;
2494         int                     i;
2495         xfs_bmbt_key_t          *kp;
2496         xfs_bmbt_ptr_t          *pp;
2497
2498         format = f == &ip->i_df ? ip->i_d.di_format : ip->i_d.di_aformat;
2499         if ((f->if_flags & XFS_IFBROOT) == 0 ||
2500             format != XFS_DINODE_FMT_BTREE) {
2501                 kdb_printf("inode 0x%p not btree format\n", ip);
2502                 return;
2503         }
2504         broot = f->if_broot;
2505         kdb_printf("block @0x%p magic %x level %d numrecs %d\n",
2506                 broot, INT_GET(broot->bb_magic, ARCH_CONVERT), INT_GET(broot->bb_level, ARCH_CONVERT), INT_GET(broot->bb_numrecs, ARCH_CONVERT));
2507         kp = XFS_BMAP_BROOT_KEY_ADDR(broot, 1, f->if_broot_bytes);
2508         pp = XFS_BMAP_BROOT_PTR_ADDR(broot, 1, f->if_broot_bytes);
2509         for (i = 1; i <= INT_GET(broot->bb_numrecs, ARCH_CONVERT); i++)
2510                 kdb_printf("\t%d: startoff %Ld ptr %Lx %s\n",
2511                         i, INT_GET(kp[i - 1].br_startoff, ARCH_CONVERT), INT_GET(pp[i - 1], ARCH_CONVERT),
2512                         xfs_fmtfsblock(INT_GET(pp[i - 1], ARCH_CONVERT), ip->i_mount));
2513 }
2514
2515 /*
2516  * Print allocation btree block.
2517  */
2518 static void
2519 xfs_btalloc(xfs_alloc_block_t *bt, int bsz)
2520 {
2521         int i;
2522
2523         kdb_printf("magic 0x%x level %d numrecs %d leftsib 0x%x rightsib 0x%x\n",
2524                 INT_GET(bt->bb_magic, ARCH_CONVERT), INT_GET(bt->bb_level, ARCH_CONVERT), INT_GET(bt->bb_numrecs, ARCH_CONVERT),
2525                 INT_GET(bt->bb_leftsib, ARCH_CONVERT), INT_GET(bt->bb_rightsib, ARCH_CONVERT));
2526         if (INT_ISZERO(bt->bb_level, ARCH_CONVERT)) {
2527
2528                 for (i = 1; i <= INT_GET(bt->bb_numrecs, ARCH_CONVERT); i++) {
2529                         xfs_alloc_rec_t *r;
2530
2531                         r = XFS_BTREE_REC_ADDR(bsz, xfs_alloc, bt, i, 0);
2532                         kdb_printf("rec %d startblock 0x%x blockcount %d\n",
2533                                 i, INT_GET(r->ar_startblock, ARCH_CONVERT), INT_GET(r->ar_blockcount, ARCH_CONVERT));
2534                 }
2535         } else {
2536                 int mxr;
2537
2538                 mxr = XFS_BTREE_BLOCK_MAXRECS(bsz, xfs_alloc, 0);
2539                 for (i = 1; i <= INT_GET(bt->bb_numrecs, ARCH_CONVERT); i++) {
2540                         xfs_alloc_key_t *k;
2541                         xfs_alloc_ptr_t *p;
2542
2543                         k = XFS_BTREE_KEY_ADDR(bsz, xfs_alloc, bt, i, mxr);
2544                         p = XFS_BTREE_PTR_ADDR(bsz, xfs_alloc, bt, i, mxr);
2545                         kdb_printf("key %d startblock 0x%x blockcount %d ptr 0x%x\n",
2546                                 i, INT_GET(k->ar_startblock, ARCH_CONVERT), INT_GET(k->ar_blockcount, ARCH_CONVERT), *p);
2547                 }
2548         }
2549 }
2550
2551 /*
2552  * Print a bmap btree block.
2553  */
2554 static void
2555 xfs_btbmap(xfs_bmbt_block_t *bt, int bsz)
2556 {
2557         int i;
2558
2559         kdb_printf("magic 0x%x level %d numrecs %d leftsib %Lx ",
2560                 INT_GET(bt->bb_magic, ARCH_CONVERT),
2561                 INT_GET(bt->bb_level, ARCH_CONVERT),
2562                 INT_GET(bt->bb_numrecs, ARCH_CONVERT),
2563                 INT_GET(bt->bb_leftsib, ARCH_CONVERT));
2564         kdb_printf("rightsib %Lx\n", INT_GET(bt->bb_rightsib, ARCH_CONVERT));
2565         if (INT_ISZERO(bt->bb_level, ARCH_CONVERT)) {
2566                 for (i = 1; i <= INT_GET(bt->bb_numrecs, ARCH_CONVERT); i++) {
2567                         xfs_bmbt_rec_t *r;
2568                         xfs_bmbt_irec_t irec;
2569
2570                         r = (xfs_bmbt_rec_t *)XFS_BTREE_REC_ADDR(bsz,
2571                                 xfs_bmbt, bt, i, 0);
2572
2573                         xfs_bmbt_disk_get_all((xfs_bmbt_rec_t *)r, &irec);
2574                         kdb_printf("rec %d startoff %Ld startblock %Lx blockcount %Ld flag %d\n",
2575                                 i, irec.br_startoff,
2576                                 (__uint64_t)irec.br_startblock,
2577                                 irec.br_blockcount, irec.br_state);
2578                 }
2579         } else {
2580                 int mxr;
2581
2582                 mxr = XFS_BTREE_BLOCK_MAXRECS(bsz, xfs_bmbt, 0);
2583                 for (i = 1; i <= INT_GET(bt->bb_numrecs, ARCH_CONVERT); i++) {
2584                         xfs_bmbt_key_t *k;
2585                         xfs_bmbt_ptr_t *p;
2586
2587                         k = XFS_BTREE_KEY_ADDR(bsz, xfs_bmbt, bt, i, mxr);
2588                         p = XFS_BTREE_PTR_ADDR(bsz, xfs_bmbt, bt, i, mxr);
2589                         kdb_printf("key %d startoff %Ld ",
2590                                 i, INT_GET(k->br_startoff, ARCH_CONVERT));
2591                         kdb_printf("ptr %Lx\n", INT_GET(*p, ARCH_CONVERT));
2592                 }
2593         }
2594 }
2595
2596 /*
2597  * Print an inode btree block.
2598  */
2599 static void
2600 xfs_btino(xfs_inobt_block_t *bt, int bsz)
2601 {
2602         int i;
2603
2604         kdb_printf("magic 0x%x level %d numrecs %d leftsib 0x%x rightsib 0x%x\n",
2605                 INT_GET(bt->bb_magic, ARCH_CONVERT), INT_GET(bt->bb_level, ARCH_CONVERT), INT_GET(bt->bb_numrecs, ARCH_CONVERT),
2606                 INT_GET(bt->bb_leftsib, ARCH_CONVERT), INT_GET(bt->bb_rightsib, ARCH_CONVERT));
2607         if (INT_ISZERO(bt->bb_level, ARCH_CONVERT)) {
2608
2609                 for (i = 1; i <= INT_GET(bt->bb_numrecs, ARCH_CONVERT); i++) {
2610                         xfs_inobt_rec_t *r;
2611
2612                         r = XFS_BTREE_REC_ADDR(bsz, xfs_inobt, bt, i, 0);
2613                         kdb_printf("rec %d startino 0x%x freecount %d, free %Lx\n",
2614                                 i, INT_GET(r->ir_startino, ARCH_CONVERT), INT_GET(r->ir_freecount, ARCH_CONVERT),
2615                                 INT_GET(r->ir_free, ARCH_CONVERT));
2616                 }
2617         } else {
2618                 int mxr;
2619
2620                 mxr = XFS_BTREE_BLOCK_MAXRECS(bsz, xfs_inobt, 0);
2621                 for (i = 1; i <= INT_GET(bt->bb_numrecs, ARCH_CONVERT); i++) {
2622                         xfs_inobt_key_t *k;
2623                         xfs_inobt_ptr_t *p;
2624
2625                         k = XFS_BTREE_KEY_ADDR(bsz, xfs_inobt, bt, i, mxr);
2626                         p = XFS_BTREE_PTR_ADDR(bsz, xfs_inobt, bt, i, mxr);
2627                         kdb_printf("key %d startino 0x%x ptr 0x%x\n",
2628                                 i, INT_GET(k->ir_startino, ARCH_CONVERT), INT_GET(*p, ARCH_CONVERT));
2629                 }
2630         }
2631 }
2632
2633 /*
2634  * Print a buf log item.
2635  */
2636 static void
2637 xfs_buf_item_print(xfs_buf_log_item_t *blip, int summary)
2638 {
2639         static char *bli_flags[] = {
2640                 "hold",         /* 0x1 */
2641                 "dirty",        /* 0x2 */
2642                 "stale",        /* 0x4 */
2643                 "logged",       /* 0x8 */
2644                 "ialloc",       /* 0x10 */
2645                 0
2646                 };
2647         static char *blf_flags[] = {
2648                 "inode",        /* 0x1 */
2649                 "cancel",       /* 0x2 */
2650                 0
2651                 };
2652
2653         if (summary) {
2654                 kdb_printf("buf 0x%p blkno 0x%Lx ", blip->bli_buf,
2655                              blip->bli_format.blf_blkno);
2656                 printflags(blip->bli_flags, bli_flags, "flags:");
2657                 kdb_printf("\n   ");
2658                 xfsidbg_xbuf_real(blip->bli_buf, 1);
2659                 return;
2660         }
2661         kdb_printf("buf 0x%p recur %d refcount %d flags:",
2662                 blip->bli_buf, blip->bli_recur,
2663                 atomic_read(&blip->bli_refcount));
2664         printflags(blip->bli_flags, bli_flags, NULL);
2665         kdb_printf("\n");
2666         kdb_printf("size %d blkno 0x%Lx len 0x%x map size %d map 0x%p\n",
2667                 blip->bli_format.blf_size, blip->bli_format.blf_blkno,
2668                 (uint) blip->bli_format.blf_len, blip->bli_format.blf_map_size,
2669                 &(blip->bli_format.blf_data_map[0]));
2670         kdb_printf("blf flags: ");
2671         printflags((uint)blip->bli_format.blf_flags, blf_flags, NULL);
2672 #ifdef XFS_TRANS_DEBUG
2673         kdb_printf("orig 0x%x logged 0x%x",
2674                 blip->bli_orig, blip->bli_logged);
2675 #endif
2676         kdb_printf("\n");
2677 }
2678
2679 /*
2680  * Print an xfs_da_state_path structure.
2681  */
2682 static void
2683 xfs_dastate_path(xfs_da_state_path_t *p)
2684 {
2685         int i;
2686
2687         kdb_printf("active %d\n", p->active);
2688         for (i = 0; i < XFS_DA_NODE_MAXDEPTH; i++) {
2689                 kdb_printf(" blk %d bp 0x%p blkno 0x%x",
2690                         i, p->blk[i].bp, p->blk[i].blkno);
2691                 kdb_printf(" index %d hashval 0x%x ",
2692                         p->blk[i].index, (uint_t)p->blk[i].hashval);
2693                 switch(p->blk[i].magic) {
2694                 case XFS_DA_NODE_MAGIC:         kdb_printf("NODE\n");   break;
2695                 case XFS_DIR_LEAF_MAGIC:        kdb_printf("DIR\n");    break;
2696                 case XFS_ATTR_LEAF_MAGIC:       kdb_printf("ATTR\n");   break;
2697                 case XFS_DIR2_LEAFN_MAGIC:      kdb_printf("DIR2\n");   break;
2698                 default:                        kdb_printf("type ??\n");        break;
2699                 }
2700         }
2701 }
2702
2703
2704 /*
2705  * Print an efd log item.
2706  */
2707 static void
2708 xfs_efd_item_print(xfs_efd_log_item_t *efdp, int summary)
2709 {
2710         int             i;
2711         xfs_extent_t    *ep;
2712
2713         if (summary) {
2714                 kdb_printf("Extent Free Done: ID 0x%Lx nextents %d (at 0x%p)\n",
2715                                 efdp->efd_format.efd_efi_id,
2716                                 efdp->efd_format.efd_nextents, efdp);
2717                 return;
2718         }
2719         kdb_printf("size %d nextents %d next extent %d efip 0x%p\n",
2720                 efdp->efd_format.efd_size, efdp->efd_format.efd_nextents,
2721                 efdp->efd_next_extent, efdp->efd_efip);
2722         kdb_printf("efi_id 0x%Lx\n", efdp->efd_format.efd_efi_id);
2723         kdb_printf("efd extents:\n");
2724         ep = &(efdp->efd_format.efd_extents[0]);
2725         for (i = 0; i < efdp->efd_next_extent; i++, ep++) {
2726                 kdb_printf("    block %Lx len %d\n",
2727                         ep->ext_start, ep->ext_len);
2728         }
2729 }
2730
2731 /*
2732  * Print an efi log item.
2733  */
2734 static void
2735 xfs_efi_item_print(xfs_efi_log_item_t *efip, int summary)
2736 {
2737         int             i;
2738         xfs_extent_t    *ep;
2739         static char *efi_flags[] = {
2740                 "recovered",    /* 0x1 */
2741                 "committed",    /* 0x2 */
2742                 "cancelled",    /* 0x4 */
2743                 0,
2744                 };
2745
2746         if (summary) {
2747                 kdb_printf("Extent Free Intention: ID 0x%Lx nextents %d (at 0x%p)\n",
2748                                 efip->efi_format.efi_id,
2749                                 efip->efi_format.efi_nextents, efip);
2750                 return;
2751         }
2752         kdb_printf("size %d nextents %d next extent %d\n",
2753                 efip->efi_format.efi_size, efip->efi_format.efi_nextents,
2754                 efip->efi_next_extent);
2755         kdb_printf("id %Lx", efip->efi_format.efi_id);
2756         printflags(efip->efi_flags, efi_flags, "flags :");
2757         kdb_printf("\n");
2758         kdb_printf("efi extents:\n");
2759         ep = &(efip->efi_format.efi_extents[0]);
2760         for (i = 0; i < efip->efi_next_extent; i++, ep++) {
2761                 kdb_printf("    block %Lx len %d\n",
2762                         ep->ext_start, ep->ext_len);
2763         }
2764 }
2765
2766 /*
2767  * Format inode "format" into a static buffer & return it.
2768  */
2769 static char *
2770 xfs_fmtformat(xfs_dinode_fmt_t f)
2771 {
2772         static char *t[] = {
2773                 "dev",
2774                 "local",
2775                 "extents",
2776                 "btree",
2777                 "uuid"
2778         };
2779
2780         return t[f];
2781 }
2782
2783 /*
2784  * Format fsblock number into a static buffer & return it.
2785  */
2786 static char *
2787 xfs_fmtfsblock(xfs_fsblock_t bno, xfs_mount_t *mp)
2788 {
2789         static char rval[50];
2790
2791         if (bno == NULLFSBLOCK)
2792                 sprintf(rval, "NULLFSBLOCK");
2793         else if (ISNULLSTARTBLOCK(bno))
2794                 sprintf(rval, "NULLSTARTBLOCK(%Ld)", STARTBLOCKVAL(bno));
2795         else if (mp)
2796                 sprintf(rval, "%Ld[%x:%x]", (xfs_dfsbno_t)bno,
2797                         XFS_FSB_TO_AGNO(mp, bno), XFS_FSB_TO_AGBNO(mp, bno));
2798         else
2799                 sprintf(rval, "%Ld", (xfs_dfsbno_t)bno);
2800         return rval;
2801 }
2802
2803 /*
2804  * Format inode number into a static buffer & return it.
2805  */
2806 static char *
2807 xfs_fmtino(xfs_ino_t ino, xfs_mount_t *mp)
2808 {
2809         static char rval[50];
2810
2811         if (mp)
2812                 sprintf(rval, "%llu[%x:%x:%x]",
2813                         (unsigned long long) ino,
2814                         XFS_INO_TO_AGNO(mp, ino),
2815                         XFS_INO_TO_AGBNO(mp, ino),
2816                         XFS_INO_TO_OFFSET(mp, ino));
2817         else
2818                 sprintf(rval, "%llu", (unsigned long long) ino);
2819         return rval;
2820 }
2821
2822 /*
2823  * Format an lsn for printing into a static buffer & return it.
2824  */
2825 static char *
2826 xfs_fmtlsn(xfs_lsn_t *lsnp)
2827 {
2828         uint            *wordp;
2829         uint            *word2p;
2830         static char     buf[20];
2831
2832         wordp = (uint *)lsnp;
2833         word2p = wordp++;
2834         sprintf(buf, "[%u:%u]", *wordp, *word2p);
2835
2836         return buf;
2837 }
2838
2839 /*
2840  * Format file mode into a static buffer & return it.
2841  */
2842 static char *
2843 xfs_fmtmode(int m)
2844 {
2845         static char rval[16];
2846
2847         sprintf(rval, "%c%c%c%c%c%c%c%c%c%c%c%c%c",
2848                 "?fc?dxb?r?l?S?m?"[(m & IFMT) >> 12],
2849                 m & ISUID ? 'u' : '-',
2850                 m & ISGID ? 'g' : '-',
2851                 m & ISVTX ? 'v' : '-',
2852                 m & IREAD ? 'r' : '-',
2853                 m & IWRITE ? 'w' : '-',
2854                 m & IEXEC ? 'x' : '-',
2855                 m & (IREAD >> 3) ? 'r' : '-',
2856                 m & (IWRITE >> 3) ? 'w' : '-',
2857                 m & (IEXEC >> 3) ? 'x' : '-',
2858                 m & (IREAD >> 6) ? 'r' : '-',
2859                 m & (IWRITE >> 6) ? 'w' : '-',
2860                 m & (IEXEC >> 6) ? 'x' : '-');
2861         return rval;
2862 }
2863
2864 /*
2865  * Format a size into a static buffer & return it.
2866  */
2867 static char *
2868 xfs_fmtsize(size_t i)
2869 {
2870         static char rval[20];
2871
2872         /* size_t is 32 bits in 32-bit kernel, 64 bits in 64-bit kernel */
2873         sprintf(rval, "0x%lx", (unsigned long) i);
2874         return rval;
2875 }
2876
2877 /*
2878  * Format a uuid into a static buffer & return it.
2879  */
2880 static char *
2881 xfs_fmtuuid(uuid_t *uu)
2882 {
2883         static char rval[40];
2884         char        *o          = rval;
2885         char        *i          = (unsigned char*)uu;
2886         int         b;
2887
2888         for (b=0;b<16;b++) {
2889             o+=sprintf(o, "%02x", *i++);
2890             if (b==3||b==5||b==7||b==9) *o++='-';
2891         }
2892         *o='\0';
2893
2894         return rval;
2895 }
2896
2897 /*
2898  * Print an inode log item.
2899  */
2900 static void
2901 xfs_inode_item_print(xfs_inode_log_item_t *ilip, int summary)
2902 {
2903         static char *ili_flags[] = {
2904                 "hold",         /* 0x1 */
2905                 "iolock excl",  /* 0x2 */
2906                 "iolock shrd",  /* 0x4 */
2907                 0
2908                 };
2909         static char *ilf_fields[] = {
2910                 "core",         /* 0x001 */
2911                 "ddata",        /* 0x002 */
2912                 "dexts",        /* 0x004 */
2913                 "dbroot",       /* 0x008 */
2914                 "dev",          /* 0x010 */
2915                 "uuid",         /* 0x020 */
2916                 "adata",        /* 0x040 */
2917                 "aext",         /* 0x080 */
2918                 "abroot",       /* 0x100 */
2919                 0
2920                 };
2921
2922         if (summary) {
2923                 kdb_printf("inode 0x%p logged %d ",
2924                         ilip->ili_inode, ilip->ili_logged);
2925                 printflags(ilip->ili_flags, ili_flags, "flags:");
2926                 printflags(ilip->ili_format.ilf_fields, ilf_fields, "format:");
2927                 printflags(ilip->ili_last_fields, ilf_fields, "lastfield:");
2928                 kdb_printf("\n");
2929                 return;
2930         }
2931         kdb_printf("inode 0x%p ino 0x%llu logged %d flags: ",
2932                 ilip->ili_inode, (unsigned long long) ilip->ili_format.ilf_ino,
2933                 ilip->ili_logged);
2934         printflags(ilip->ili_flags, ili_flags, NULL);
2935         kdb_printf("\n");
2936         kdb_printf("ilock recur %d iolock recur %d ext buf 0x%p\n",
2937                 ilip->ili_ilock_recur, ilip->ili_iolock_recur,
2938                 ilip->ili_extents_buf);
2939 #ifdef XFS_TRANS_DEBUG
2940         kdb_printf("root bytes %d root orig 0x%x\n",
2941                 ilip->ili_root_size, ilip->ili_orig_root);
2942 #endif
2943         kdb_printf("size %d fields: ", ilip->ili_format.ilf_size);
2944         printflags(ilip->ili_format.ilf_fields, ilf_fields, "formatfield");
2945         kdb_printf(" last fields: ");
2946         printflags(ilip->ili_last_fields, ilf_fields, "lastfield");
2947         kdb_printf("\n");
2948         kdb_printf(" flush lsn %s last lsn %s\n",
2949                 xfs_fmtlsn(&(ilip->ili_flush_lsn)),
2950                 xfs_fmtlsn(&(ilip->ili_last_lsn)));
2951         kdb_printf("dsize %d, asize %d, rdev 0x%x\n",
2952                 ilip->ili_format.ilf_dsize,
2953                 ilip->ili_format.ilf_asize,
2954                 ilip->ili_format.ilf_u.ilfu_rdev);
2955         kdb_printf("blkno 0x%Lx len 0x%x boffset 0x%x\n",
2956                 ilip->ili_format.ilf_blkno,
2957                 ilip->ili_format.ilf_len,
2958                 ilip->ili_format.ilf_boffset);
2959 }
2960
2961 /*
2962  * Print a dquot log item.
2963  */
2964 /* ARGSUSED */
2965 static void
2966 xfs_dquot_item_print(xfs_dq_logitem_t *lip, int summary)
2967 {
2968         kdb_printf("dquot 0x%p\n",
2969                 lip->qli_dquot);
2970
2971 }
2972
2973 /*
2974  * Print a quotaoff log item.
2975  */
2976 /* ARGSUSED */
2977 static void
2978 xfs_qoff_item_print(xfs_qoff_logitem_t *lip, int summary)
2979 {
2980         kdb_printf("start qoff item 0x%p flags 0x%x\n",
2981                 lip->qql_start_lip, lip->qql_format.qf_flags);
2982
2983 }
2984
2985 /*
2986  * Print buffer full of inodes.
2987  */
2988 static void
2989 xfs_inodebuf(xfs_buf_t *bp)
2990 {
2991         xfs_dinode_t *di;
2992         int n, i;
2993
2994         n = XFS_BUF_COUNT(bp) >> 8;
2995         for (i = 0; i < n; i++) {
2996                 di = (xfs_dinode_t *)xfs_buf_offset(bp,
2997                                         i * 256);
2998                 xfs_prdinode(di, 0, ARCH_CONVERT);
2999         }
3000 }
3001
3002
3003 /*
3004  * Print disk inode.
3005  */
3006 static void
3007 xfs_prdinode(xfs_dinode_t *di, int coreonly, int convert)
3008 {
3009         xfs_prdinode_core(&di->di_core, convert);
3010         if (!coreonly)
3011                 kdb_printf("next_unlinked 0x%x u@0x%p\n",
3012                         INT_GET(di->di_next_unlinked, convert),
3013                         &di->di_u);
3014 }
3015
3016 /*
3017  * Print disk inode core.
3018  */
3019 static void
3020 xfs_prdinode_core(xfs_dinode_core_t *dip, int convert)
3021 {
3022         static char *diflags[] = {
3023                 "realtime",             /* XFS_DIFLAG_REALTIME */
3024                 "prealloc",             /* XFS_DIFLAG_PREALLOC */
3025                 NULL
3026         };
3027
3028         kdb_printf("magic 0x%x mode 0%o (%s) version 0x%x format 0x%x (%s)\n",
3029                 INT_GET(dip->di_magic, convert),
3030                 INT_GET(dip->di_mode, convert),
3031                 xfs_fmtmode(INT_GET(dip->di_mode, convert)),
3032                 INT_GET(dip->di_version, convert),
3033                 INT_GET(dip->di_format, convert),
3034                 xfs_fmtformat(
3035                     (xfs_dinode_fmt_t)INT_GET(dip->di_format, convert)));
3036         kdb_printf("nlink 0x%x uid 0x%x gid 0x%x projid 0x%x\n",
3037                 INT_GET(dip->di_nlink, convert),
3038                 INT_GET(dip->di_uid, convert),
3039                 INT_GET(dip->di_gid, convert),
3040                 (uint)INT_GET(dip->di_projid, convert));
3041         kdb_printf("atime 0x%x:%x mtime 0x%x:%x ctime 0x%x:%x\n",
3042                 INT_GET(dip->di_atime.t_sec, convert),
3043                 INT_GET(dip->di_atime.t_nsec, convert),
3044                 INT_GET(dip->di_mtime.t_sec, convert),
3045                 INT_GET(dip->di_mtime.t_nsec, convert),
3046                 INT_GET(dip->di_ctime.t_sec, convert),
3047                 INT_GET(dip->di_ctime.t_nsec, convert));
3048         kdb_printf("size 0x%Lx ", INT_GET(dip->di_size, convert));
3049         kdb_printf("nblocks %Ld extsize 0x%x nextents 0x%x anextents 0x%x\n",
3050                 INT_GET(dip->di_nblocks, convert),
3051                 INT_GET(dip->di_extsize, convert),
3052                 INT_GET(dip->di_nextents, convert),
3053                 INT_GET(dip->di_anextents, convert));
3054         kdb_printf("forkoff %d aformat 0x%x (%s) dmevmask 0x%x dmstate 0x%x ",
3055                 INT_GET(dip->di_forkoff, convert),
3056                 INT_GET(dip->di_aformat, convert),
3057                 xfs_fmtformat(
3058                     (xfs_dinode_fmt_t)INT_GET(dip->di_aformat, convert)),
3059                 INT_GET(dip->di_dmevmask, convert),
3060                 INT_GET(dip->di_dmstate, convert));
3061         printflags(INT_GET(dip->di_flags, convert), diflags, "flags");
3062         kdb_printf("gen 0x%x\n", INT_GET(dip->di_gen, convert));
3063 }
3064
3065 /*
3066  * Print xfs extent list for a fork.
3067  */
3068 static void
3069 xfs_xexlist_fork(xfs_inode_t *ip, int whichfork)
3070 {
3071         int nextents, i;
3072         xfs_ifork_t *ifp;
3073         xfs_bmbt_irec_t irec;
3074
3075         ifp = XFS_IFORK_PTR(ip, whichfork);
3076         if (ifp->if_flags & XFS_IFEXTENTS) {
3077                 nextents = ifp->if_bytes / sizeof(xfs_bmbt_rec_64_t);
3078                 kdb_printf("inode 0x%p %cf extents 0x%p nextents 0x%x\n",
3079                         ip, "da"[whichfork], ifp->if_u1.if_extents, nextents);
3080                 for (i = 0; i < nextents; i++) {
3081                         xfs_bmbt_get_all(&ifp->if_u1.if_extents[i], &irec);
3082                         kdb_printf(
3083                 "%d: startoff %Ld startblock %s blockcount %Ld flag %d\n",
3084                         i, irec.br_startoff,
3085                         xfs_fmtfsblock(irec.br_startblock, ip->i_mount),
3086                         irec.br_blockcount, irec.br_state);
3087                 }
3088         }
3089 }
3090
3091 static void
3092 xfs_xnode_fork(char *name, xfs_ifork_t *f)
3093 {
3094         static char *tab_flags[] = {
3095                 "inline",       /* XFS_IFINLINE */
3096                 "extents",      /* XFS_IFEXTENTS */
3097                 "broot",        /* XFS_IFBROOT */
3098                 NULL
3099         };
3100         int *p;
3101
3102         kdb_printf("%s fork", name);
3103         if (f == NULL) {
3104                 kdb_printf(" empty\n");
3105                 return;
3106         } else
3107                 kdb_printf("\n");
3108         kdb_printf(" bytes %s ", xfs_fmtsize(f->if_bytes));
3109         kdb_printf("real_bytes %s lastex 0x%x u1:%s 0x%p\n",
3110                 xfs_fmtsize(f->if_real_bytes), f->if_lastex,
3111                 f->if_flags & XFS_IFINLINE ? "data" : "extents",
3112                 f->if_flags & XFS_IFINLINE ?
3113                         f->if_u1.if_data :
3114                         (char *)f->if_u1.if_extents);
3115         kdb_printf(" broot 0x%p broot_bytes %s ext_max %d ",
3116                 f->if_broot, xfs_fmtsize(f->if_broot_bytes), f->if_ext_max);
3117         printflags(f->if_flags, tab_flags, "flags");
3118         kdb_printf("\n");
3119         kdb_printf(" u2");
3120         for (p = (int *)&f->if_u2;
3121              p < (int *)((char *)&f->if_u2 + XFS_INLINE_DATA);
3122              p++)
3123                 kdb_printf(" 0x%x", *p);
3124         kdb_printf("\n");
3125 }
3126
3127 /*
3128  * Command-level xfs-idbg functions.
3129  */
3130
3131 /*
3132  * Print xfs allocation group freespace header.
3133  */
3134 static void
3135 xfsidbg_xagf(xfs_agf_t *agf)
3136 {
3137         kdb_printf("magicnum 0x%x versionnum 0x%x seqno 0x%x length 0x%x\n",
3138                 INT_GET(agf->agf_magicnum, ARCH_CONVERT),
3139                 INT_GET(agf->agf_versionnum, ARCH_CONVERT),
3140                 INT_GET(agf->agf_seqno, ARCH_CONVERT),
3141                 INT_GET(agf->agf_length, ARCH_CONVERT));
3142         kdb_printf("roots b 0x%x c 0x%x levels b %d c %d\n",
3143                 INT_GET(agf->agf_roots[XFS_BTNUM_BNO], ARCH_CONVERT),
3144                 INT_GET(agf->agf_roots[XFS_BTNUM_CNT], ARCH_CONVERT),
3145                 INT_GET(agf->agf_levels[XFS_BTNUM_BNO], ARCH_CONVERT),
3146                 INT_GET(agf->agf_levels[XFS_BTNUM_CNT], ARCH_CONVERT));
3147         kdb_printf("flfirst %d fllast %d flcount %d freeblks %d longest %d\n",
3148                 INT_GET(agf->agf_flfirst, ARCH_CONVERT),
3149                 INT_GET(agf->agf_fllast, ARCH_CONVERT),
3150                 INT_GET(agf->agf_flcount, ARCH_CONVERT),
3151                 INT_GET(agf->agf_freeblks, ARCH_CONVERT),
3152                 INT_GET(agf->agf_longest, ARCH_CONVERT));
3153 }
3154
3155 /*
3156  * Print xfs allocation group inode header.
3157  */
3158 static void
3159 xfsidbg_xagi(xfs_agi_t *agi)
3160 {
3161         int     i;
3162         int     j;
3163
3164         kdb_printf("magicnum 0x%x versionnum 0x%x seqno 0x%x length 0x%x\n",
3165                 INT_GET(agi->agi_magicnum, ARCH_CONVERT),
3166                 INT_GET(agi->agi_versionnum, ARCH_CONVERT),
3167                 INT_GET(agi->agi_seqno, ARCH_CONVERT),
3168                 INT_GET(agi->agi_length, ARCH_CONVERT));
3169         kdb_printf("count 0x%x root 0x%x level 0x%x\n",
3170                 INT_GET(agi->agi_count, ARCH_CONVERT),
3171                 INT_GET(agi->agi_root, ARCH_CONVERT),
3172                 INT_GET(agi->agi_level, ARCH_CONVERT));
3173         kdb_printf("freecount 0x%x newino 0x%x dirino 0x%x\n",
3174                 INT_GET(agi->agi_freecount, ARCH_CONVERT),
3175                 INT_GET(agi->agi_newino, ARCH_CONVERT),
3176                 INT_GET(agi->agi_dirino, ARCH_CONVERT));
3177
3178         kdb_printf("unlinked buckets\n");
3179         for (i = 0; i < XFS_AGI_UNLINKED_BUCKETS; i++) {
3180                 for (j = 0; j < 4; j++, i++) {
3181                         kdb_printf("0x%08x ",
3182                                 INT_GET(agi->agi_unlinked[i], ARCH_CONVERT));
3183                 }
3184                 kdb_printf("\n");
3185         }
3186 }
3187
3188
3189 /*
3190  * Print an allocation argument structure for XFS.
3191  */
3192 static void
3193 xfsidbg_xalloc(xfs_alloc_arg_t *args)
3194 {
3195         kdb_printf("tp 0x%p mp 0x%p agbp 0x%p pag 0x%p fsbno %s\n",
3196                 args->tp, args->mp, args->agbp, args->pag,
3197                 xfs_fmtfsblock(args->fsbno, args->mp));
3198         kdb_printf("agno 0x%x agbno 0x%x minlen 0x%x maxlen 0x%x mod 0x%x\n",
3199                 args->agno, args->agbno, args->minlen, args->maxlen, args->mod);
3200         kdb_printf("prod 0x%x minleft 0x%x total 0x%x alignment 0x%x\n",
3201                 args->prod, args->minleft, args->total, args->alignment);
3202         kdb_printf("minalignslop 0x%x len 0x%x type %s otype %s wasdel %d\n",
3203                 args->minalignslop, args->len, xfs_alloctype[args->type],
3204                 xfs_alloctype[args->otype], args->wasdel);
3205         kdb_printf("wasfromfl %d isfl %d userdata %d\n",
3206                 args->wasfromfl, args->isfl, args->userdata);
3207 }
3208
3209 #ifdef DEBUG
3210 /*
3211  * Print out all the entries in the alloc trace buf corresponding
3212  * to the given mount point.
3213  */
3214 static void
3215 xfsidbg_xalmtrace(xfs_mount_t *mp)
3216 {
3217         ktrace_entry_t  *ktep;
3218         ktrace_snap_t   kts;
3219         extern ktrace_t *xfs_alloc_trace_buf;
3220
3221         if (xfs_alloc_trace_buf == NULL) {
3222                 kdb_printf("The xfs alloc trace buffer is not initialized\n");
3223                 return;
3224         }
3225
3226         ktep = ktrace_first(xfs_alloc_trace_buf, &kts);
3227         while (ktep != NULL) {
3228                 if ((__psint_t)ktep->val[0] && (xfs_mount_t *)ktep->val[3] == mp) {
3229                         (void)xfs_alloc_trace_entry(ktep);
3230                         kdb_printf("\n");
3231                 }
3232                 ktep = ktrace_next(xfs_alloc_trace_buf, &kts);
3233         }
3234 }
3235 #endif /* DEBUG */
3236
3237 /*
3238  * Print an attr_list() context structure.
3239  */
3240 static void
3241 xfsidbg_xattrcontext(xfs_attr_list_context_t *context)
3242 {
3243         static char *attr_arg_flags[] = {
3244                 "DONTFOLLOW",   /* 0x0001 */
3245                 "?",            /* 0x0002 */
3246                 "?",            /* 0x0004 */
3247                 "?",            /* 0x0008 */
3248                 "CREATE",       /* 0x0010 */
3249                 "?",            /* 0x0020 */
3250                 "?",            /* 0x0040 */
3251                 "?",            /* 0x0080 */
3252                 "?",            /* 0x0100 */
3253                 "?",            /* 0x0200 */
3254                 "?",            /* 0x0400 */
3255                 "?",            /* 0x0800 */
3256                 "KERNOTIME",    /* 0x1000 */
3257                 NULL
3258         };
3259
3260         kdb_printf("dp 0x%p, dupcnt %d, resynch %d",
3261                     context->dp, context->dupcnt, context->resynch);
3262         printflags((__psunsigned_t)context->flags, attr_arg_flags, ", flags");
3263         kdb_printf("\ncursor h/b/o 0x%x/0x%x/%d -- p/p/i 0x%x/0x%x/0x%x\n",
3264                           context->cursor->hashval, context->cursor->blkno,
3265                           context->cursor->offset, context->cursor->pad1,
3266                           context->cursor->pad2, context->cursor->initted);
3267         kdb_printf("alist 0x%p, bufsize 0x%x, count %d, firstu 0x%x\n",
3268                        context->alist, context->bufsize, context->count,
3269                        context->firstu);
3270 }
3271
3272 /*
3273  * Print attribute leaf block.
3274  */
3275 static void
3276 xfsidbg_xattrleaf(xfs_attr_leafblock_t *leaf)
3277 {
3278         xfs_attr_leaf_hdr_t *h;
3279         xfs_da_blkinfo_t *i;
3280         xfs_attr_leaf_map_t *m;
3281         xfs_attr_leaf_entry_t *e;
3282         xfs_attr_leaf_name_local_t *l;
3283         xfs_attr_leaf_name_remote_t *r;
3284         int j, k;
3285
3286         h = &leaf->hdr;
3287         i = &h->info;
3288         kdb_printf("hdr info forw 0x%x back 0x%x magic 0x%x\n",
3289                 i->forw, i->back, i->magic);
3290         kdb_printf("hdr count %d usedbytes %d firstused %d holes %d\n",
3291                 INT_GET(h->count, ARCH_CONVERT),
3292                 INT_GET(h->usedbytes, ARCH_CONVERT),
3293                 INT_GET(h->firstused, ARCH_CONVERT), h->holes);
3294         for (j = 0, m = h->freemap; j < XFS_ATTR_LEAF_MAPSIZE; j++, m++) {
3295                 kdb_printf("hdr freemap %d base %d size %d\n",
3296                         j, INT_GET(m->base, ARCH_CONVERT),
3297                         INT_GET(m->size, ARCH_CONVERT));
3298         }
3299         for (j = 0, e = leaf->entries; j < INT_GET(h->count, ARCH_CONVERT); j++, e++) {
3300                 kdb_printf("[%2d] hash 0x%x nameidx %d flags 0x%x",
3301                         j, INT_GET(e->hashval, ARCH_CONVERT),
3302                         INT_GET(e->nameidx, ARCH_CONVERT), e->flags);
3303                 if (e->flags & XFS_ATTR_LOCAL)
3304                         kdb_printf("LOCAL ");
3305                 if (e->flags & XFS_ATTR_ROOT)
3306                         kdb_printf("ROOT ");
3307                 if (e->flags & XFS_ATTR_INCOMPLETE)
3308                         kdb_printf("INCOMPLETE ");
3309                 k = ~(XFS_ATTR_LOCAL | XFS_ATTR_ROOT | XFS_ATTR_INCOMPLETE);
3310                 if ((e->flags & k) != 0)
3311                         kdb_printf("0x%x", e->flags & k);
3312                 kdb_printf(">\n     name \"");
3313                 if (e->flags & XFS_ATTR_LOCAL) {
3314                         l = XFS_ATTR_LEAF_NAME_LOCAL(leaf, j);
3315                         for (k = 0; k < l->namelen; k++)
3316                                 kdb_printf("%c", l->nameval[k]);
3317                         kdb_printf("\"(%d) value \"", l->namelen);
3318                         for (k = 0; (k < INT_GET(l->valuelen, ARCH_CONVERT)) && (k < 32); k++)
3319                                 kdb_printf("%c", l->nameval[l->namelen + k]);
3320                         if (k == 32)
3321                                 kdb_printf("...");
3322                         kdb_printf("\"(%d)\n",
3323                                 INT_GET(l->valuelen, ARCH_CONVERT));
3324                 } else {
3325                         r = XFS_ATTR_LEAF_NAME_REMOTE(leaf, j);
3326                         for (k = 0; k < r->namelen; k++)
3327                                 kdb_printf("%c", r->name[k]);
3328                         kdb_printf("\"(%d) value blk 0x%x len %d\n",
3329                                     r->namelen,
3330                                     INT_GET(r->valueblk, ARCH_CONVERT),
3331                                     INT_GET(r->valuelen, ARCH_CONVERT));
3332                 }
3333         }
3334 }
3335
3336 /*
3337  * Print a shortform attribute list.
3338  */
3339 static void
3340 xfsidbg_xattrsf(xfs_attr_shortform_t *s)
3341 {
3342         xfs_attr_sf_hdr_t *sfh;
3343         xfs_attr_sf_entry_t *sfe;
3344         int i, j;
3345
3346         sfh = &s->hdr;
3347         kdb_printf("hdr count %d\n", INT_GET(sfh->count, ARCH_CONVERT));
3348         for (i = 0, sfe = s->list; i < INT_GET(sfh->count, ARCH_CONVERT); i++) {
3349                 kdb_printf("entry %d namelen %d name \"", i, sfe->namelen);
3350                 for (j = 0; j < sfe->namelen; j++)
3351                         kdb_printf("%c", sfe->nameval[j]);
3352                 kdb_printf("\" valuelen %d value \"", INT_GET(sfe->valuelen, ARCH_CONVERT));
3353                 for (j = 0; (j < INT_GET(sfe->valuelen, ARCH_CONVERT)) && (j < 32); j++)
3354                         kdb_printf("%c", sfe->nameval[sfe->namelen + j]);
3355                 if (j == 32)
3356                         kdb_printf("...");
3357                 kdb_printf("\"\n");
3358                 sfe = XFS_ATTR_SF_NEXTENTRY(sfe);
3359         }
3360 }
3361
3362
3363 /*
3364  * Print xfs bmap internal record
3365  */
3366 static void
3367 xfsidbg_xbirec(xfs_bmbt_irec_t *r)
3368 {
3369         kdb_printf(
3370         "startoff %Ld startblock %Lx blockcount %Ld state %Ld\n",
3371                 (__uint64_t)r->br_startoff,
3372                 (__uint64_t)r->br_startblock,
3373                 (__uint64_t)r->br_blockcount,
3374                 (__uint64_t)r->br_state);
3375 }
3376
3377
3378 /*
3379  * Print a bmap alloc argument structure for XFS.
3380  */
3381 static void
3382 xfsidbg_xbmalla(xfs_bmalloca_t *a)
3383 {
3384         kdb_printf("tp 0x%p ip 0x%p eof %d prevp 0x%p\n",
3385                 a->tp, a->ip, a->eof, a->prevp);
3386         kdb_printf("gotp 0x%p firstblock %s alen %d total %d\n",
3387                 a->gotp, xfs_fmtfsblock(a->firstblock, a->ip->i_mount),
3388                 a->alen, a->total);
3389         kdb_printf("off %s wasdel %d userdata %d minlen %d\n",
3390                 xfs_fmtfsblock(a->off, a->ip->i_mount), a->wasdel,
3391                 a->userdata, a->minlen);
3392         kdb_printf("minleft %d low %d rval %s aeof %d\n",
3393                 a->minleft, a->low, xfs_fmtfsblock(a->rval, a->ip->i_mount),
3394                 a->aeof);
3395 }
3396
3397
3398 /*
3399  * Print xfs bmap record
3400  */
3401 static void
3402 xfsidbg_xbrec(xfs_bmbt_rec_64_t *r)
3403 {
3404         xfs_bmbt_irec_t irec;
3405
3406         xfs_bmbt_get_all((xfs_bmbt_rec_t *)r, &irec);
3407         kdb_printf("startoff %Ld startblock %Lx blockcount %Ld flag %d\n",
3408                 irec.br_startoff, (__uint64_t)irec.br_startblock,
3409                 irec.br_blockcount, irec.br_state);
3410 }
3411
3412 /*
3413  * Print an xfs in-inode bmap btree root (data fork).
3414  */
3415 static void
3416 xfsidbg_xbroot(xfs_inode_t *ip)
3417 {
3418         xfs_broot(ip, &ip->i_df);
3419 }
3420
3421 /*
3422  * Print an xfs in-inode bmap btree root (attribute fork).
3423  */
3424 static void
3425 xfsidbg_xbroota(xfs_inode_t *ip)
3426 {
3427         if (ip->i_afp)
3428                 xfs_broot(ip, ip->i_afp);
3429 }
3430
3431 /*
3432  * Print xfs btree cursor.
3433  */
3434 static void
3435 xfsidbg_xbtcur(xfs_btree_cur_t *c)
3436 {
3437         int l;
3438
3439         kdb_printf("tp 0x%p mp 0x%p\n",
3440                 c->bc_tp,
3441                 c->bc_mp);
3442         if (c->bc_btnum == XFS_BTNUM_BMAP) {
3443                 kdb_printf("rec.b ");
3444                 xfsidbg_xbirec(&c->bc_rec.b);
3445         } else if (c->bc_btnum == XFS_BTNUM_INO) {
3446                 kdb_printf("rec.i startino 0x%x freecount 0x%x free %Lx\n",
3447                         c->bc_rec.i.ir_startino, c->bc_rec.i.ir_freecount,
3448                         c->bc_rec.i.ir_free);
3449         } else {
3450                 kdb_printf("rec.a startblock 0x%x blockcount 0x%x\n",
3451                         c->bc_rec.a.ar_startblock,
3452                         c->bc_rec.a.ar_blockcount);
3453         }
3454         kdb_printf("bufs");
3455         for (l = 0; l < c->bc_nlevels; l++)
3456                 kdb_printf(" 0x%p", c->bc_bufs[l]);
3457         kdb_printf("\n");
3458         kdb_printf("ptrs");
3459         for (l = 0; l < c->bc_nlevels; l++)
3460                 kdb_printf(" 0x%x", c->bc_ptrs[l]);
3461         kdb_printf("  ra");
3462         for (l = 0; l < c->bc_nlevels; l++)
3463                 kdb_printf(" %d", c->bc_ra[l]);
3464         kdb_printf("\n");
3465         kdb_printf("nlevels %d btnum %s blocklog %d\n",
3466                 c->bc_nlevels,
3467                 c->bc_btnum == XFS_BTNUM_BNO ? "bno" :
3468                 (c->bc_btnum == XFS_BTNUM_CNT ? "cnt" :
3469                  (c->bc_btnum == XFS_BTNUM_BMAP ? "bmap" : "ino")),
3470                 c->bc_blocklog);
3471         if (c->bc_btnum == XFS_BTNUM_BMAP) {
3472                 kdb_printf("private forksize 0x%x whichfork %d ip 0x%p flags %d\n",
3473                         c->bc_private.b.forksize,
3474                         c->bc_private.b.whichfork,
3475                         c->bc_private.b.ip,
3476                         c->bc_private.b.flags);
3477                 kdb_printf("private firstblock %s flist 0x%p allocated 0x%x\n",
3478                         xfs_fmtfsblock(c->bc_private.b.firstblock, c->bc_mp),
3479                         c->bc_private.b.flist,
3480                         c->bc_private.b.allocated);
3481         } else if (c->bc_btnum == XFS_BTNUM_INO) {
3482                 kdb_printf("private agbp 0x%p agno 0x%x\n",
3483                         c->bc_private.i.agbp,
3484                         c->bc_private.i.agno);
3485         } else {
3486                 kdb_printf("private agbp 0x%p agno 0x%x\n",
3487                         c->bc_private.a.agbp,
3488                         c->bc_private.a.agno);
3489         }
3490 }
3491
3492 /*
3493  * Figure out what kind of xfs block the buffer contains,
3494  * and invoke a print routine.
3495  */
3496 static void
3497 xfsidbg_xbuf(xfs_buf_t *bp)
3498 {
3499         xfsidbg_xbuf_real(bp, 0);
3500 }
3501
3502 /*
3503  * Figure out what kind of xfs block the buffer contains,
3504  * and invoke a print routine (if asked to).
3505  */
3506 static void
3507 xfsidbg_xbuf_real(xfs_buf_t *bp, int summary)
3508 {
3509         void *d;
3510         xfs_agf_t *agf;
3511         xfs_agi_t *agi;
3512         xfs_sb_t *sb;
3513         xfs_alloc_block_t *bta;
3514         xfs_bmbt_block_t *btb;
3515         xfs_inobt_block_t *bti;
3516         xfs_attr_leafblock_t *aleaf;
3517         xfs_dir_leafblock_t *dleaf;
3518         xfs_da_intnode_t *node;
3519         xfs_dinode_t *di;
3520         xfs_disk_dquot_t *dqb;
3521         xfs_dir2_block_t *d2block;
3522         xfs_dir2_data_t *d2data;
3523         xfs_dir2_leaf_t *d2leaf;
3524         xfs_dir2_free_t *d2free;
3525
3526         d = XFS_BUF_PTR(bp);
3527         if (INT_GET((agf = d)->agf_magicnum, ARCH_CONVERT) == XFS_AGF_MAGIC) {
3528                 if (summary) {
3529                         kdb_printf("freespace hdr for AG %d (at 0x%p)\n",
3530                                 INT_GET(agf->agf_seqno, ARCH_CONVERT), agf);
3531                 } else {
3532                         kdb_printf("buf 0x%p agf 0x%p\n", bp, agf);
3533                         xfsidbg_xagf(agf);
3534                 }
3535         } else if (INT_GET((agi = d)->agi_magicnum, ARCH_CONVERT) == XFS_AGI_MAGIC) {
3536                 if (summary) {
3537                         kdb_printf("Inode hdr for AG %d (at 0x%p)\n",
3538                                INT_GET(agi->agi_seqno, ARCH_CONVERT), agi);
3539                 } else {
3540                         kdb_printf("buf 0x%p agi 0x%p\n", bp, agi);
3541                         xfsidbg_xagi(agi);
3542                 }
3543         } else if (INT_GET((bta = d)->bb_magic, ARCH_CONVERT) == XFS_ABTB_MAGIC) {
3544                 if (summary) {
3545                         kdb_printf("Alloc BNO Btree blk, level %d (at 0x%p)\n",
3546                                        INT_GET(bta->bb_level, ARCH_CONVERT), bta);
3547                 } else {
3548                         kdb_printf("buf 0x%p abtbno 0x%p\n", bp, bta);
3549                         xfs_btalloc(bta, XFS_BUF_COUNT(bp));
3550                 }
3551         } else if (INT_GET((bta = d)->bb_magic, ARCH_CONVERT) == XFS_ABTC_MAGIC) {
3552                 if (summary) {
3553                         kdb_printf("Alloc COUNT Btree blk, level %d (at 0x%p)\n",
3554                                        INT_GET(bta->bb_level, ARCH_CONVERT), bta);
3555                 } else {
3556                         kdb_printf("buf 0x%p abtcnt 0x%p\n", bp, bta);
3557                         xfs_btalloc(bta, XFS_BUF_COUNT(bp));
3558                 }
3559         } else if (INT_GET((btb = d)->bb_magic, ARCH_CONVERT) == XFS_BMAP_MAGIC) {
3560                 if (summary) {
3561                         kdb_printf("Bmap Btree blk, level %d (at 0x%p)\n",
3562                                       INT_GET(btb->bb_level, ARCH_CONVERT), btb);
3563                 } else {
3564                         kdb_printf("buf 0x%p bmapbt 0x%p\n", bp, btb);
3565                         xfs_btbmap(btb, XFS_BUF_COUNT(bp));
3566                 }
3567         } else if (INT_GET((bti = d)->bb_magic, ARCH_CONVERT) == XFS_IBT_MAGIC) {
3568                 if (summary) {
3569                         kdb_printf("Inode Btree blk, level %d (at 0x%p)\n",
3570                                        INT_GET(bti->bb_level, ARCH_CONVERT), bti);
3571                 } else {
3572                         kdb_printf("buf 0x%p inobt 0x%p\n", bp, bti);
3573                         xfs_btino(bti, XFS_BUF_COUNT(bp));
3574                 }
3575         } else if (INT_GET((aleaf = d)->hdr.info.magic, ARCH_CONVERT) == XFS_ATTR_LEAF_MAGIC) {
3576                 if (summary) {
3577                         kdb_printf("Attr Leaf, 1st hash 0x%x (at 0x%p)\n",
3578                                       INT_GET(aleaf->entries[0].hashval, ARCH_CONVERT), aleaf);
3579                 } else {
3580                         kdb_printf("buf 0x%p attr leaf 0x%p\n", bp, aleaf);
3581                         xfsidbg_xattrleaf(aleaf);
3582                 }
3583         } else if (INT_GET((dleaf = d)->hdr.info.magic, ARCH_CONVERT) == XFS_DIR_LEAF_MAGIC) {
3584                 if (summary) {
3585                         kdb_printf("Dir Leaf, 1st hash 0x%x (at 0x%p)\n",
3586                                      dleaf->entries[0].hashval, dleaf);
3587                 } else {
3588                         kdb_printf("buf 0x%p dir leaf 0x%p\n", bp, dleaf);
3589                         xfsidbg_xdirleaf(dleaf);
3590                 }
3591         } else if (INT_GET((node = d)->hdr.info.magic, ARCH_CONVERT) == XFS_DA_NODE_MAGIC) {
3592                 if (summary) {
3593                         kdb_printf("Dir/Attr Node, level %d, 1st hash 0x%x (at 0x%p)\n",
3594                               node->hdr.level, node->btree[0].hashval, node);
3595                 } else {
3596                         kdb_printf("buf 0x%p dir/attr node 0x%p\n", bp, node);
3597                         xfsidbg_xdanode(node);
3598                 }
3599         } else if (INT_GET((di = d)->di_core.di_magic, ARCH_CONVERT) == XFS_DINODE_MAGIC) {
3600                 if (summary) {
3601                         kdb_printf("Disk Inode (at 0x%p)\n", di);
3602                 } else {
3603                         kdb_printf("buf 0x%p dinode 0x%p\n", bp, di);
3604                         xfs_inodebuf(bp);
3605                 }
3606         } else if (INT_GET((sb = d)->sb_magicnum, ARCH_CONVERT) == XFS_SB_MAGIC) {
3607                 if (summary) {
3608                         kdb_printf("Superblock (at 0x%p)\n", sb);
3609                 } else {
3610                         kdb_printf("buf 0x%p sb 0x%p\n", bp, sb);
3611                         /* SB in a buffer - we need to convert */
3612                         xfsidbg_xsb(sb, 1);
3613                 }
3614         } else if ((dqb = d)->d_magic == XFS_DQUOT_MAGIC) {
3615 #define XFSIDBG_DQTYPESTR(d)     \
3616         ((INT_GET((d)->d_flags, ARCH_CONVERT) & XFS_DQ_USER) ? "USR" : \
3617         ((INT_GET((d)->d_flags, ARCH_CONVERT) & XFS_DQ_GROUP) ? "GRP" : "???"))
3618                 kdb_printf("Quota blk starting ID [%d], type %s at 0x%p\n",
3619                         INT_GET(dqb->d_id, ARCH_CONVERT), XFSIDBG_DQTYPESTR(dqb), dqb);
3620
3621         } else if (INT_GET((d2block = d)->hdr.magic, ARCH_CONVERT) == XFS_DIR2_BLOCK_MAGIC) {
3622                 if (summary) {
3623                         kdb_printf("Dir2 block (at 0x%p)\n", d2block);
3624                 } else {
3625                         kdb_printf("buf 0x%p dir2 block 0x%p\n", bp, d2block);
3626                         xfs_dir2data((void *)d2block, XFS_BUF_COUNT(bp));
3627                 }
3628         } else if (INT_GET((d2data = d)->hdr.magic, ARCH_CONVERT) == XFS_DIR2_DATA_MAGIC) {
3629                 if (summary) {
3630                         kdb_printf("Dir2 data (at 0x%p)\n", d2data);
3631                 } else {
3632                         kdb_printf("buf 0x%p dir2 data 0x%p\n", bp, d2data);
3633                         xfs_dir2data((void *)d2data, XFS_BUF_COUNT(bp));
3634                 }
3635         } else if (INT_GET((d2leaf = d)->hdr.info.magic, ARCH_CONVERT) == XFS_DIR2_LEAF1_MAGIC) {
3636                 if (summary) {
3637                         kdb_printf("Dir2 leaf(1) (at 0x%p)\n", d2leaf);
3638                 } else {
3639                         kdb_printf("buf 0x%p dir2 leaf 0x%p\n", bp, d2leaf);
3640                         xfs_dir2leaf(d2leaf, XFS_BUF_COUNT(bp));
3641                 }
3642         } else if (INT_GET(d2leaf->hdr.info.magic, ARCH_CONVERT) == XFS_DIR2_LEAFN_MAGIC) {
3643                 if (summary) {
3644                         kdb_printf("Dir2 leaf(n) (at 0x%p)\n", d2leaf);
3645                 } else {
3646                         kdb_printf("buf 0x%p dir2 leaf 0x%p\n", bp, d2leaf);
3647                         xfs_dir2leaf(d2leaf, XFS_BUF_COUNT(bp));
3648                 }
3649         } else if (INT_GET((d2free = d)->hdr.magic, ARCH_CONVERT) == XFS_DIR2_FREE_MAGIC) {
3650                 if (summary) {
3651                         kdb_printf("Dir2 free (at 0x%p)\n", d2free);
3652                 } else {
3653                         kdb_printf("buf 0x%p dir2 free 0x%p\n", bp, d2free);
3654                         xfsidbg_xdir2free(d2free);
3655                 }
3656         } else {
3657                 kdb_printf("buf 0x%p unknown 0x%p\n", bp, d);
3658         }
3659 }
3660
3661
3662 /*
3663  * Print an xfs_da_args structure.
3664  */
3665 static void
3666 xfsidbg_xdaargs(xfs_da_args_t *n)
3667 {
3668         char *ch;
3669         int i;
3670
3671         kdb_printf(" name \"");
3672         for (i = 0; i < n->namelen; i++) {
3673                 kdb_printf("%c", n->name[i]);
3674         }
3675         kdb_printf("\"(%d) value ", n->namelen);
3676         if (n->value) {
3677                 kdb_printf("\"");
3678                 ch = n->value;
3679                 for (i = 0; (i < n->valuelen) && (i < 32); ch++, i++) {
3680                         switch(*ch) {
3681                         case '\n':      kdb_printf("\n");               break;
3682                         case '\b':      kdb_printf("\b");               break;
3683                         case '\t':      kdb_printf("\t");               break;
3684                         default:        kdb_printf("%c", *ch);  break;
3685                         }
3686                 }
3687                 if (i == 32)
3688                         kdb_printf("...");
3689                 kdb_printf("\"(%d)\n", n->valuelen);
3690         } else {
3691                 kdb_printf("(NULL)(%d)\n", n->valuelen);
3692         }
3693         kdb_printf(" hashval 0x%x whichfork %d flags <",
3694                   (uint_t)n->hashval, n->whichfork);
3695         if (n->flags & ATTR_ROOT)
3696                 kdb_printf("ROOT ");
3697         if (n->flags & ATTR_CREATE)
3698                 kdb_printf("CREATE ");
3699         if (n->flags & ATTR_REPLACE)
3700                 kdb_printf("REPLACE ");
3701         if (n->flags & XFS_ATTR_INCOMPLETE)
3702                 kdb_printf("INCOMPLETE ");
3703         i = ~(ATTR_ROOT | ATTR_CREATE | ATTR_REPLACE | XFS_ATTR_INCOMPLETE);
3704         if ((n->flags & i) != 0)
3705                 kdb_printf("0x%x", n->flags & i);
3706         kdb_printf(">\n");
3707         kdb_printf(" rename %d justcheck %d addname %d oknoent %d\n",
3708                   n->rename, n->justcheck, n->addname, n->oknoent);
3709         kdb_printf(" leaf: blkno %d index %d rmtblkno %d rmtblkcnt %d\n",
3710                   n->blkno, n->index, n->rmtblkno, n->rmtblkcnt);
3711         kdb_printf(" leaf2: blkno %d index %d rmtblkno %d rmtblkcnt %d\n",
3712                   n->blkno2, n->index2, n->rmtblkno2, n->rmtblkcnt2);
3713         kdb_printf(" inumber %llu dp 0x%p firstblock 0x%p flist 0x%p\n",
3714                   (unsigned long long) n->inumber,
3715                   n->dp, n->firstblock, n->flist);
3716         kdb_printf(" trans 0x%p total %d\n",
3717                   n->trans, n->total);
3718 }
3719
3720 /*
3721  * Print a da buffer structure.
3722  */
3723 static void
3724 xfsidbg_xdabuf(xfs_dabuf_t *dabuf)
3725 {
3726         int     i;
3727
3728         kdb_printf("nbuf %d dirty %d bbcount %d data 0x%p bps",
3729                 dabuf->nbuf, dabuf->dirty, dabuf->bbcount, dabuf->data);
3730         for (i = 0; i < dabuf->nbuf; i++)
3731                 kdb_printf(" %d:0x%p", i, dabuf->bps[i]);
3732         kdb_printf("\n");
3733 #ifdef XFS_DABUF_DEBUG
3734         kdb_printf(" ra 0x%x prev 0x%x next 0x%x dev 0x%x blkno 0x%x\n",
3735                 dabuf->ra, dabuf->prev, dabuf->next, dabuf->dev, dabuf->blkno);
3736 #endif
3737 }
3738
3739 /*
3740  * Print a directory/attribute internal node block.
3741  */
3742 static void
3743 xfsidbg_xdanode(xfs_da_intnode_t *node)
3744 {
3745         xfs_da_node_hdr_t *h;
3746         xfs_da_blkinfo_t *i;
3747         xfs_da_node_entry_t *e;
3748         int j;
3749
3750         h = &node->hdr;
3751         i = &h->info;
3752         kdb_printf("hdr info forw 0x%x back 0x%x magic 0x%x\n",
3753                 INT_GET(i->forw, ARCH_CONVERT), INT_GET(i->back, ARCH_CONVERT), INT_GET(i->magic, ARCH_CONVERT));
3754         kdb_printf("hdr count %d level %d\n",
3755                 INT_GET(h->count, ARCH_CONVERT), INT_GET(h->level, ARCH_CONVERT));
3756         for (j = 0, e = node->btree; j < INT_GET(h->count, ARCH_CONVERT); j++, e++) {
3757                 kdb_printf("btree %d hashval 0x%x before 0x%x\n",
3758                         j, (uint_t)INT_GET(e->hashval, ARCH_CONVERT), INT_GET(e->before, ARCH_CONVERT));
3759         }
3760 }
3761
3762 /*
3763  * Print an xfs_da_state_blk structure.
3764  */
3765 static void
3766 xfsidbg_xdastate(xfs_da_state_t *s)
3767 {
3768         xfs_da_state_blk_t *eblk;
3769
3770         kdb_printf("args 0x%p mp 0x%p blocksize %u node_ents %u inleaf %u\n",
3771                 s->args, s->mp, s->blocksize, s->node_ents, s->inleaf);
3772         if (s->args)
3773                 xfsidbg_xdaargs(s->args);
3774
3775         kdb_printf("path:  ");
3776         xfs_dastate_path(&s->path);
3777
3778         kdb_printf("altpath:  ");
3779         xfs_dastate_path(&s->altpath);
3780
3781         eblk = &s->extrablk;
3782         kdb_printf("extra: valid %d, after %d\n", s->extravalid, s->extraafter);
3783         kdb_printf(" bp 0x%p blkno 0x%x ", eblk->bp, eblk->blkno);
3784         kdb_printf("index %d hashval 0x%x\n", eblk->index, (uint_t)eblk->hashval);
3785 }
3786
3787 /*
3788  * Print a directory leaf block.
3789  */
3790 static void
3791 xfsidbg_xdirleaf(xfs_dir_leafblock_t *leaf)
3792 {
3793         xfs_dir_leaf_hdr_t *h;
3794         xfs_da_blkinfo_t *i;
3795         xfs_dir_leaf_map_t *m;
3796         xfs_dir_leaf_entry_t *e;
3797         xfs_dir_leaf_name_t *n;
3798         int j, k;
3799         xfs_ino_t ino;
3800
3801         h = &leaf->hdr;
3802         i = &h->info;
3803         kdb_printf("hdr info forw 0x%x back 0x%x magic 0x%x\n",
3804                 INT_GET(i->forw, ARCH_CONVERT), INT_GET(i->back, ARCH_CONVERT), INT_GET(i->magic, ARCH_CONVERT));
3805         kdb_printf("hdr count %d namebytes %d firstused %d holes %d\n",
3806                 INT_GET(h->count, ARCH_CONVERT), INT_GET(h->namebytes, ARCH_CONVERT), INT_GET(h->firstused, ARCH_CONVERT), h->holes);
3807         for (j = 0, m = h->freemap; j < XFS_DIR_LEAF_MAPSIZE; j++, m++) {
3808                 kdb_printf("hdr freemap %d base %d size %d\n",
3809                         j, INT_GET(m->base, ARCH_CONVERT), INT_GET(m->size, ARCH_CONVERT));
3810         }
3811         for (j = 0, e = leaf->entries; j < INT_GET(h->count, ARCH_CONVERT); j++, e++) {
3812                 n = XFS_DIR_LEAF_NAMESTRUCT(leaf, INT_GET(e->nameidx, ARCH_CONVERT));
3813                 XFS_DIR_SF_GET_DIRINO_ARCH(&n->inumber, &ino, ARCH_CONVERT);
3814                 kdb_printf("leaf %d hashval 0x%x nameidx %d inumber %llu ",
3815                         j, (uint_t)INT_GET(e->hashval, ARCH_CONVERT),
3816                         INT_GET(e->nameidx, ARCH_CONVERT),
3817                         (unsigned long long)ino);
3818                 kdb_printf("namelen %d name \"", e->namelen);
3819                 for (k = 0; k < e->namelen; k++)
3820                         kdb_printf("%c", n->name[k]);
3821                 kdb_printf("\"\n");
3822         }
3823 }
3824
3825 /*
3826  * Print a directory v2 data block, single or multiple.
3827  */
3828 static void
3829 xfs_dir2data(void *addr, int size)
3830 {
3831         xfs_dir2_data_t *db;
3832         xfs_dir2_block_t *bb;
3833         xfs_dir2_data_hdr_t *h;
3834         xfs_dir2_data_free_t *m;
3835         xfs_dir2_data_entry_t *e;
3836         xfs_dir2_data_unused_t *u;
3837         xfs_dir2_leaf_entry_t *l=NULL;
3838         int j, k;
3839         char *p;
3840         char *t;
3841         xfs_dir2_block_tail_t *tail=NULL;
3842
3843         db = (xfs_dir2_data_t *)addr;
3844         bb = (xfs_dir2_block_t *)addr;
3845         h = &db->hdr;
3846         kdb_printf("hdr magic 0x%x (%s)\nhdr bestfree", INT_GET(h->magic, ARCH_CONVERT),
3847                 INT_GET(h->magic, ARCH_CONVERT) == XFS_DIR2_DATA_MAGIC ? "DATA" :
3848                         (INT_GET(h->magic, ARCH_CONVERT) == XFS_DIR2_BLOCK_MAGIC ? "BLOCK" : ""));
3849         for (j = 0, m = h->bestfree; j < XFS_DIR2_DATA_FD_COUNT; j++, m++) {
3850                 kdb_printf(" %d: 0x%x@0x%x", j, INT_GET(m->length, ARCH_CONVERT), INT_GET(m->offset, ARCH_CONVERT));
3851         }
3852         kdb_printf("\n");
3853         if (INT_GET(h->magic, ARCH_CONVERT) == XFS_DIR2_DATA_MAGIC)
3854                 t = (char *)db + size;
3855         else {
3856                 /* XFS_DIR2_BLOCK_TAIL_P */
3857                 tail = (xfs_dir2_block_tail_t *)
3858                        ((char *)bb + size - sizeof(xfs_dir2_block_tail_t));
3859                 l = XFS_DIR2_BLOCK_LEAF_P_ARCH(tail, ARCH_CONVERT);
3860                 t = (char *)l;
3861         }
3862         for (p = (char *)(h + 1); p < t; ) {
3863                 u = (xfs_dir2_data_unused_t *)p;
3864                 if (u->freetag == XFS_DIR2_DATA_FREE_TAG) {
3865                         kdb_printf("0x%lx unused freetag 0x%x length 0x%x tag 0x%x\n",
3866                                 (unsigned long) (p - (char *)addr),
3867                                 INT_GET(u->freetag, ARCH_CONVERT),
3868                                 INT_GET(u->length, ARCH_CONVERT),
3869                                 INT_GET(*XFS_DIR2_DATA_UNUSED_TAG_P_ARCH(u, ARCH_CONVERT), ARCH_CONVERT));
3870                         p += INT_GET(u->length, ARCH_CONVERT);
3871                         continue;
3872                 }
3873                 e = (xfs_dir2_data_entry_t *)p;
3874                 kdb_printf("0x%lx entry inumber %llu namelen %d name \"",
3875                         (unsigned long) (p - (char *)addr),
3876                         (unsigned long long) INT_GET(e->inumber, ARCH_CONVERT),
3877                         e->namelen);
3878                 for (k = 0; k < e->namelen; k++)
3879                         kdb_printf("%c", e->name[k]);
3880                 kdb_printf("\" tag 0x%x\n", INT_GET(*XFS_DIR2_DATA_ENTRY_TAG_P(e), ARCH_CONVERT));
3881                 p += XFS_DIR2_DATA_ENTSIZE(e->namelen);
3882         }
3883         if (INT_GET(h->magic, ARCH_CONVERT) == XFS_DIR2_DATA_MAGIC)
3884                 return;
3885         for (j = 0; j < INT_GET(tail->count, ARCH_CONVERT); j++, l++) {
3886                 kdb_printf("0x%lx leaf %d hashval 0x%x address 0x%x (byte 0x%x)\n",
3887                         (unsigned long) ((char *)l - (char *)addr), j,
3888                         (uint_t)INT_GET(l->hashval, ARCH_CONVERT),
3889                         INT_GET(l->address, ARCH_CONVERT),
3890                         /* XFS_DIR2_DATAPTR_TO_BYTE */
3891                         INT_GET(l->address, ARCH_CONVERT) << XFS_DIR2_DATA_ALIGN_LOG);
3892         }
3893         kdb_printf("0x%lx tail count %d\n",
3894                 (unsigned long) ((char *)tail - (char *)addr),
3895                 INT_GET(tail->count, ARCH_CONVERT));
3896 }
3897
3898 static void
3899 xfs_dir2leaf(xfs_dir2_leaf_t *leaf, int size)
3900 {
3901         xfs_dir2_leaf_hdr_t *h;
3902         xfs_da_blkinfo_t *i;
3903         xfs_dir2_leaf_entry_t *e;
3904         xfs_dir2_data_off_t *b;
3905         xfs_dir2_leaf_tail_t *t;
3906         int j;
3907
3908         h = &leaf->hdr;
3909         i = &h->info;
3910         e = leaf->ents;
3911         kdb_printf("hdr info forw 0x%x back 0x%x magic 0x%x\n",
3912                 INT_GET(i->forw, ARCH_CONVERT), INT_GET(i->back, ARCH_CONVERT), INT_GET(i->magic, ARCH_CONVERT));
3913         kdb_printf("hdr count %d stale %d\n", INT_GET(h->count, ARCH_CONVERT), INT_GET(h->stale, ARCH_CONVERT));
3914         for (j = 0; j < INT_GET(h->count, ARCH_CONVERT); j++, e++) {
3915                 kdb_printf("0x%lx ent %d hashval 0x%x address 0x%x (byte 0x%x)\n",
3916                         (unsigned long) ((char *)e - (char *)leaf), j,
3917                         (uint_t)INT_GET(e->hashval, ARCH_CONVERT),
3918                         INT_GET(e->address, ARCH_CONVERT),
3919                         /* XFS_DIR2_DATAPTR_TO_BYTE */
3920                         INT_GET(e->address, ARCH_CONVERT) << XFS_DIR2_DATA_ALIGN_LOG);
3921         }
3922         if (INT_GET(i->magic, ARCH_CONVERT) == XFS_DIR2_LEAFN_MAGIC)
3923                 return;
3924         /* XFS_DIR2_LEAF_TAIL_P */
3925         t = (xfs_dir2_leaf_tail_t *)((char *)leaf + size - sizeof(*t));
3926         b = XFS_DIR2_LEAF_BESTS_P_ARCH(t, ARCH_CONVERT);
3927         for (j = 0; j < INT_GET(t->bestcount, ARCH_CONVERT); j++, b++) {
3928                 kdb_printf("0x%lx best %d 0x%x\n",
3929                         (unsigned long) ((char *)b - (char *)leaf), j,
3930                         INT_GET(*b, ARCH_CONVERT));
3931         }
3932         kdb_printf("tail bestcount %d\n", INT_GET(t->bestcount, ARCH_CONVERT));
3933 }
3934
3935 /*
3936  * Print a shortform directory.
3937  */
3938 static void
3939 xfsidbg_xdirsf(xfs_dir_shortform_t *s)
3940 {
3941         xfs_dir_sf_hdr_t *sfh;
3942         xfs_dir_sf_entry_t *sfe;
3943         xfs_ino_t ino;
3944         int i, j;
3945
3946         sfh = &s->hdr;
3947         XFS_DIR_SF_GET_DIRINO_ARCH(&sfh->parent, &ino, ARCH_CONVERT);
3948         kdb_printf("hdr parent %llu", (unsigned long long)ino);
3949         kdb_printf(" count %d\n", sfh->count);
3950         for (i = 0, sfe = s->list; i < sfh->count; i++) {
3951                 XFS_DIR_SF_GET_DIRINO_ARCH(&sfe->inumber, &ino, ARCH_CONVERT);
3952                 kdb_printf("entry %d inumber %llu", i, (unsigned long long)ino);
3953                 kdb_printf(" namelen %d name \"", sfe->namelen);
3954                 for (j = 0; j < sfe->namelen; j++)
3955                         kdb_printf("%c", sfe->name[j]);
3956                 kdb_printf("\"\n");
3957                 sfe = XFS_DIR_SF_NEXTENTRY(sfe);
3958         }
3959 }
3960
3961 /*
3962  * Print a shortform v2 directory.
3963  */
3964 static void
3965 xfsidbg_xdir2sf(xfs_dir2_sf_t *s)
3966 {
3967         xfs_dir2_sf_hdr_t *sfh;
3968         xfs_dir2_sf_entry_t *sfe;
3969         xfs_ino_t ino;
3970         int i, j;
3971
3972         sfh = &s->hdr;
3973         ino = XFS_DIR2_SF_GET_INUMBER_ARCH(s, &sfh->parent, ARCH_CONVERT);
3974         kdb_printf("hdr count %d i8count %d parent %llu\n",
3975                 sfh->count, sfh->i8count, (unsigned long long) ino);
3976         for (i = 0, sfe = XFS_DIR2_SF_FIRSTENTRY(s); i < sfh->count; i++) {
3977                 ino = XFS_DIR2_SF_GET_INUMBER_ARCH(s, XFS_DIR2_SF_INUMBERP(sfe), ARCH_CONVERT);
3978                 kdb_printf("entry %d inumber %llu offset 0x%x namelen %d name \"",
3979                         i, (unsigned long long) ino,
3980                         XFS_DIR2_SF_GET_OFFSET_ARCH(sfe, ARCH_CONVERT),
3981                         sfe->namelen);
3982                 for (j = 0; j < sfe->namelen; j++)
3983                         kdb_printf("%c", sfe->name[j]);
3984                 kdb_printf("\"\n");
3985                 sfe = XFS_DIR2_SF_NEXTENTRY(s, sfe);
3986         }
3987 }
3988
3989 /*
3990  * Print a node-form v2 directory freemap block.
3991  */
3992 static void
3993 xfsidbg_xdir2free(xfs_dir2_free_t *f)
3994 {
3995         int     i;
3996
3997         kdb_printf("hdr magic 0x%x firstdb %d nvalid %d nused %d\n",
3998                 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));
3999         for (i = 0; i < INT_GET(f->hdr.nvalid, ARCH_CONVERT); i++) {
4000                 kdb_printf("entry %d db %d count %d\n",
4001                         i, i + INT_GET(f->hdr.firstdb, ARCH_CONVERT), INT_GET(f->bests[i], ARCH_CONVERT));
4002         }
4003 }
4004
4005
4006 /*
4007  * Print xfs extent list.
4008  */
4009 static void
4010 xfsidbg_xexlist(xfs_inode_t *ip)
4011 {
4012         xfs_xexlist_fork(ip, XFS_DATA_FORK);
4013         if (XFS_IFORK_Q(ip))
4014                 xfs_xexlist_fork(ip, XFS_ATTR_FORK);
4015 }
4016
4017 /*
4018  * Print an xfs free-extent list.
4019  */
4020 static void
4021 xfsidbg_xflist(xfs_bmap_free_t *flist)
4022 {
4023         xfs_bmap_free_item_t    *item;
4024
4025         kdb_printf("flist@0x%p: first 0x%p count %d low %d\n", flist,
4026                 flist->xbf_first, flist->xbf_count, flist->xbf_low);
4027         for (item = flist->xbf_first; item; item = item->xbfi_next) {
4028                 kdb_printf("item@0x%p: startblock %Lx blockcount %d", item,
4029                         (xfs_dfsbno_t)item->xbfi_startblock,
4030                         item->xbfi_blockcount);
4031         }
4032 }
4033
4034 /*
4035  * Print out the help messages for these functions.
4036  */
4037 static void
4038 xfsidbg_xhelp(void)
4039 {
4040         struct xif      *p;
4041
4042         for (p = xfsidbg_funcs; p->name; p++)
4043                 kdb_printf("%-16s %s %s\n", p->name, p->args, p->help);
4044 }
4045
4046 /*
4047  * Print out an XFS in-core log structure.
4048  */
4049 static void
4050 xfsidbg_xiclog(xlog_in_core_t *iclog)
4051 {
4052         int i;
4053         static char *ic_flags[] = {
4054                 "ACTIVE",       /* 0x0001 */
4055                 "WANT_SYNC",    /* 0x0002 */
4056                 "SYNCING",      /* 0X0004 */
4057                 "DONE_SYNC",    /* 0X0008 */
4058                 "DO_CALLBACK",  /* 0X0010 */
4059                 "CALLBACK",     /* 0X0020 */
4060                 "DIRTY",        /* 0X0040 */
4061                 "IOERROR",      /* 0X0080 */
4062                 "NOTUSED",      /* 0X8000 */
4063                 0
4064         };
4065
4066         kdb_printf("xlog_in_core/header at 0x%p/0x%p\n",
4067                 iclog, iclog->hic_data);
4068         kdb_printf("magicno: %x  cycle: %d  version: %d  lsn: 0x%Lx\n",
4069                 INT_GET(iclog->ic_header.h_magicno, ARCH_CONVERT), INT_GET(iclog->ic_header.h_cycle, ARCH_CONVERT),
4070                 INT_GET(iclog->ic_header.h_version, ARCH_CONVERT), INT_GET(iclog->ic_header.h_lsn, ARCH_CONVERT));
4071         kdb_printf("tail_lsn: 0x%Lx  len: %d  prev_block: %d  num_ops: %d\n",
4072                 INT_GET(iclog->ic_header.h_tail_lsn, ARCH_CONVERT), INT_GET(iclog->ic_header.h_len, ARCH_CONVERT),
4073                 INT_GET(iclog->ic_header.h_prev_block, ARCH_CONVERT), INT_GET(iclog->ic_header.h_num_logops, ARCH_CONVERT));
4074         kdb_printf("cycle_data: ");
4075         for (i=0; i<(iclog->ic_size>>BBSHIFT); i++) {
4076                 kdb_printf("%x  ", INT_GET(iclog->ic_header.h_cycle_data[i], ARCH_CONVERT));
4077         }
4078         kdb_printf("\n");
4079         kdb_printf("size: %d\n", INT_GET(iclog->ic_header.h_size, ARCH_CONVERT));
4080         kdb_printf("\n");
4081         kdb_printf("--------------------------------------------------\n");
4082         kdb_printf("data: 0x%p  &forcesema: 0x%p  next: 0x%p bp: 0x%p\n",
4083                 iclog->ic_datap, &iclog->ic_forcesema, iclog->ic_next,
4084                 iclog->ic_bp);
4085         kdb_printf("log: 0x%p  callb: 0x%p  callb_tail: 0x%p  roundoff: %d\n",
4086                 iclog->ic_log, iclog->ic_callback, iclog->ic_callback_tail,
4087                 iclog->ic_roundoff);
4088         kdb_printf("size: %d (OFFSET: %d) refcnt: %d  bwritecnt: %d",
4089                 iclog->ic_size, iclog->ic_offset,
4090                 iclog->ic_refcnt, iclog->ic_bwritecnt);
4091         if (iclog->ic_state & XLOG_STATE_ALL)
4092                 printflags(iclog->ic_state, ic_flags, "state:");
4093         else
4094                 kdb_printf("state: ILLEGAL 0x%x", iclog->ic_state);
4095         kdb_printf("\n");
4096 }       /* xfsidbg_xiclog */
4097
4098
4099 /*
4100  * Print all incore logs.
4101  */
4102 static void
4103 xfsidbg_xiclogall(xlog_in_core_t *iclog)
4104 {
4105     xlog_in_core_t *first_iclog = iclog;
4106
4107     do {
4108         xfsidbg_xiclog(iclog);
4109         kdb_printf("=================================================\n");
4110         iclog = iclog->ic_next;
4111     } while (iclog != first_iclog);
4112 }       /* xfsidbg_xiclogall */
4113
4114 /*
4115  * Print out the callback structures attached to an iclog.
4116  */
4117 static void
4118 xfsidbg_xiclogcb(xlog_in_core_t *iclog)
4119 {
4120         xfs_log_callback_t      *cb;
4121         kdb_symtab_t             symtab;
4122
4123         for (cb = iclog->ic_callback; cb != NULL; cb = cb->cb_next) {
4124
4125                 if (kdbnearsym((unsigned long)cb->cb_func, &symtab)) {
4126                         unsigned long offval;
4127
4128                         offval = (unsigned long)cb->cb_func - symtab.sym_start;
4129
4130                         if (offval)
4131                                 kdb_printf("func = %s+0x%lx",
4132                                                         symtab.sym_name,
4133                                                         offval);
4134                         else
4135                                 kdb_printf("func = %s", symtab.sym_name);
4136                 } else
4137                         kdb_printf("func = ?? 0x%p", (void *)cb->cb_func);
4138
4139                 kdb_printf(" arg 0x%p next 0x%p\n", cb->cb_arg, cb->cb_next);
4140         }
4141 }
4142
4143
4144 /*
4145  * Print all of the inodes attached to the given mount structure.
4146  */
4147 static void
4148 xfsidbg_xinodes(xfs_mount_t *mp)
4149 {
4150         xfs_inode_t     *ip;
4151
4152         kdb_printf("xfs_mount at 0x%p\n", mp);
4153         ip = mp->m_inodes;
4154         if (ip != NULL) {
4155                 do {
4156                         if (ip->i_mount == NULL) {
4157                                 ip = ip->i_mnext;
4158                                 continue;
4159                         }
4160                         kdb_printf("\n");
4161                         xfsidbg_xnode(ip);
4162                         ip = ip->i_mnext;
4163                 } while (ip != mp->m_inodes);
4164         }
4165         kdb_printf("\nEnd of Inodes\n");
4166 }
4167
4168 static void
4169 xfsidbg_delayed_blocks(xfs_mount_t *mp)
4170 {
4171         xfs_inode_t     *ip;
4172         unsigned int    total = 0;
4173         unsigned int    icount = 0;
4174
4175         ip = mp->m_inodes;
4176         if (ip != NULL) {
4177                 do {
4178                         if (ip->i_mount == NULL) {
4179                                 ip = ip->i_mnext;
4180                                 continue;
4181                         }
4182                         if (ip->i_delayed_blks) {
4183                                 total += ip->i_delayed_blks;
4184                                 icount++;
4185                         }
4186                         ip = ip->i_mnext;
4187                 } while (ip != mp->m_inodes);
4188         }
4189         kdb_printf("delayed blocks total: %d in %d inodes\n", total, icount);
4190 }
4191
4192 static void
4193 xfsidbg_xinodes_quiesce(xfs_mount_t *mp)
4194 {
4195         xfs_inode_t     *ip;
4196
4197         kdb_printf("xfs_mount at 0x%p\n", mp);
4198         ip = mp->m_inodes;
4199         if (ip != NULL) {
4200                 do {
4201                         if (ip->i_mount == NULL) {
4202                                 ip = ip->i_mnext;
4203                                 continue;
4204                         }
4205                         if (!(ip->i_flags & XFS_IQUIESCE)) {
4206                                 kdb_printf("ip 0x%p not quiesced\n", ip);
4207                         }
4208                         ip = ip->i_mnext;
4209                 } while (ip != mp->m_inodes);
4210         }
4211         kdb_printf("\nEnd of Inodes\n");
4212 }
4213
4214 static char *
4215 xfsidbg_get_cstate(int state)
4216 {
4217         switch(state) {
4218         case  XLOG_STATE_COVER_IDLE:
4219                 return("idle");
4220         case  XLOG_STATE_COVER_NEED:
4221                 return("need");
4222         case  XLOG_STATE_COVER_DONE:
4223                 return("done");
4224         case  XLOG_STATE_COVER_NEED2:
4225                 return("need2");
4226         case  XLOG_STATE_COVER_DONE2:
4227                 return("done2");
4228         default:
4229                 return("unknown");
4230         }
4231 }
4232
4233 /*
4234  * Print out an XFS log structure.
4235  */
4236 static void
4237 xfsidbg_xlog(xlog_t *log)
4238 {
4239         int rbytes;
4240         int wbytes;
4241         static char *t_flags[] = {
4242                 "CHKSUM_MISMATCH",      /* 0x01 */
4243                 "ACTIVE_RECOVERY",      /* 0x02 */
4244                 "RECOVERY_NEEDED",      /* 0x04 */
4245                 "IO_ERROR",             /* 0x08 */
4246                 0
4247         };
4248
4249         kdb_printf("xlog at 0x%p\n", log);
4250         kdb_printf("&flushsm: 0x%p  flushcnt: %d tic_cnt: %d     tic_tcnt: %d  \n",
4251                 &log->l_flushsema, log->l_flushcnt,
4252                 log->l_ticket_cnt, log->l_ticket_tcnt);
4253         kdb_printf("freelist: 0x%p  tail: 0x%p  ICLOG: 0x%p  \n",
4254                 log->l_freelist, log->l_tail, log->l_iclog);
4255         kdb_printf("&icloglock: 0x%p  tail_lsn: %s  last_sync_lsn: %s \n",
4256                 &log->l_icloglock, xfs_fmtlsn(&log->l_tail_lsn),
4257                 xfs_fmtlsn(&log->l_last_sync_lsn));
4258         kdb_printf("mp: 0x%p  xbuf: 0x%p  roundoff: %d  l_covered_state: %s \n",
4259                 log->l_mp, log->l_xbuf, log->l_roundoff,
4260                         xfsidbg_get_cstate(log->l_covered_state));
4261         kdb_printf("flags: ");
4262         printflags(log->l_flags, t_flags,"log");
4263         kdb_printf("  dev: 0x%x logBBstart: %lld logsize: %d logBBsize: %d\n",
4264                 log->l_dev, (long long) log->l_logBBstart,
4265                 log->l_logsize,log->l_logBBsize);
4266         kdb_printf("curr_cycle: %d  prev_cycle: %d  curr_block: %d  prev_block: %d\n",
4267              log->l_curr_cycle, log->l_prev_cycle, log->l_curr_block,
4268              log->l_prev_block);
4269         kdb_printf("iclog_bak: 0x%p  iclog_size: 0x%x (%d)  num iclogs: %d\n",
4270                 log->l_iclog_bak, log->l_iclog_size, log->l_iclog_size,
4271                 log->l_iclog_bufs);
4272         kdb_printf("l_stripemask %d l_iclog_hsize %d l_iclog_heads %d\n",
4273                 log->l_stripemask, log->l_iclog_hsize, log->l_iclog_heads);
4274         kdb_printf("l_sectbb_log %u l_sectbb_mask %u\n",
4275                 log->l_sectbb_log, log->l_sectbb_mask);
4276         kdb_printf("&grant_lock: 0x%p  resHeadQ: 0x%p  wrHeadQ: 0x%p\n",
4277                 &log->l_grant_lock, log->l_reserve_headq, log->l_write_headq);
4278         kdb_printf("GResCycle: %d  GResBytes: %d  GWrCycle: %d  GWrBytes: %d\n",
4279                 log->l_grant_reserve_cycle, log->l_grant_reserve_bytes,
4280                 log->l_grant_write_cycle, log->l_grant_write_bytes);
4281         rbytes = log->l_grant_reserve_bytes + log->l_roundoff;
4282         wbytes = log->l_grant_write_bytes + log->l_roundoff;
4283        kdb_printf("GResBlocks: %d  GResRemain: %d  GWrBlocks: %d  GWrRemain: %d\n",
4284                rbytes / BBSIZE, rbytes % BBSIZE,
4285                wbytes / BBSIZE, wbytes % BBSIZE);
4286 }       /* xfsidbg_xlog */
4287
4288
4289 /*
4290  * Print out an XFS recovery transaction
4291  */
4292 static void
4293 xfsidbg_xlog_ritem(xlog_recover_item_t *item)
4294 {
4295         int i = XLOG_MAX_REGIONS_IN_ITEM;
4296
4297         kdb_printf("(xlog_recover_item 0x%p) ", item);
4298         kdb_printf("next: 0x%p prev: 0x%p type: %d cnt: %d ttl: %d\n",
4299                 item->ri_next, item->ri_prev, ITEM_TYPE(item), item->ri_cnt,
4300                 item->ri_total);
4301         for ( ; i > 0; i--) {
4302                 if (!item->ri_buf[XLOG_MAX_REGIONS_IN_ITEM-i].i_addr)
4303                         break;
4304                 kdb_printf("a: 0x%p l: %d ",
4305                         item->ri_buf[XLOG_MAX_REGIONS_IN_ITEM-i].i_addr,
4306                         item->ri_buf[XLOG_MAX_REGIONS_IN_ITEM-i].i_len);
4307         }
4308         kdb_printf("\n");
4309 }       /* xfsidbg_xlog_ritem */
4310
4311 /*
4312  * Print out an XFS recovery transaction
4313  */
4314 static void
4315 xfsidbg_xlog_rtrans(xlog_recover_t *trans)
4316 {
4317         xlog_recover_item_t *rip, *first_rip;
4318
4319         kdb_printf("(xlog_recover 0x%p) ", trans);
4320         kdb_printf("tid: %x type: %d items: %d ttid: 0x%x  ",
4321                 trans->r_log_tid, trans->r_theader.th_type,
4322                 trans->r_theader.th_num_items, trans->r_theader.th_tid);
4323         kdb_printf("itemq: 0x%p\n", trans->r_itemq);
4324         if (trans->r_itemq) {
4325                 rip = first_rip = trans->r_itemq;
4326                 do {
4327                         kdb_printf("(recovery item: 0x%p) ", rip);
4328                         kdb_printf("type: %d cnt: %d total: %d\n",
4329                                 ITEM_TYPE(rip), rip->ri_cnt, rip->ri_total);
4330                         rip = rip->ri_next;
4331                 } while (rip != first_rip);
4332         }
4333 }       /* xfsidbg_xlog_rtrans */
4334
4335 static void
4336 xfsidbg_xlog_buf_logitem(xlog_recover_item_t *item)
4337 {
4338         xfs_buf_log_format_t    *buf_f;
4339         int                     i, j;
4340         int                     bit;
4341         int                     nbits;
4342         unsigned int            *data_map;
4343         unsigned int            map_size;
4344         int                     size;
4345
4346         buf_f = (xfs_buf_log_format_t *)item->ri_buf[0].i_addr;
4347         if (buf_f->blf_flags & XFS_BLI_INODE_BUF) {
4348                 kdb_printf("\tINODE BUF <blkno=0x%Lx, len=0x%x>\n",
4349                         buf_f->blf_blkno, buf_f->blf_len);
4350         } else if (buf_f->blf_flags & (XFS_BLI_UDQUOT_BUF | XFS_BLI_GDQUOT_BUF)) {
4351                 kdb_printf("\tDQUOT BUF <blkno=0x%Lx, len=0x%x>\n",
4352                         buf_f->blf_blkno, buf_f->blf_len);
4353         } else {
4354                 data_map = buf_f->blf_data_map;
4355                 map_size = buf_f->blf_map_size;
4356                 kdb_printf("\tREG BUF <blkno=0x%Lx, len=0x%x map 0x%p size %d>\n",
4357                         buf_f->blf_blkno, buf_f->blf_len, data_map, map_size);
4358                 bit = 0;
4359                 i = 0;  /* 0 is the buf format structure */
4360                 while (1) {
4361                         bit = xfs_next_bit(data_map, map_size, bit);
4362                         if (bit == -1)
4363                                 break;
4364                         nbits = xfs_contig_bits(data_map, map_size, bit);
4365                         size = ((uint)bit << XFS_BLI_SHIFT)+(nbits<<XFS_BLI_SHIFT);
4366                         kdb_printf("\t\tlogbuf.i_addr 0x%p, size 0x%x\n",
4367                                 item->ri_buf[i].i_addr, size);
4368                         kdb_printf("\t\t\t\"");
4369                         for (j=0; j<8 && j<size; j++) {
4370                                 kdb_printf("%02x", ((char *)item->ri_buf[i].i_addr)[j]);
4371                         }
4372                         kdb_printf("...\"\n");
4373                         i++;
4374                         bit += nbits;
4375                 }
4376
4377         }
4378 }
4379
4380 /*
4381  * Print out an ENTIRE XFS recovery transaction
4382  */
4383 static void
4384 xfsidbg_xlog_rtrans_entire(xlog_recover_t *trans)
4385 {
4386         xlog_recover_item_t *item, *first_rip;
4387
4388         kdb_printf("(Recovering Xact 0x%p) ", trans);
4389         kdb_printf("tid: %x type: %d nitems: %d ttid: 0x%x  ",
4390                 trans->r_log_tid, trans->r_theader.th_type,
4391                 trans->r_theader.th_num_items, trans->r_theader.th_tid);
4392         kdb_printf("itemq: 0x%p\n", trans->r_itemq);
4393         if (trans->r_itemq) {
4394                 item = first_rip = trans->r_itemq;
4395                 do {
4396                         /*
4397                            kdb_printf("(recovery item: 0x%x) ", item);
4398                            kdb_printf("type: %d cnt: %d total: %d\n",
4399                                    item->ri_type, item->ri_cnt, item->ri_total);
4400                                    */
4401                         if ((ITEM_TYPE(item) == XFS_LI_BUF) ||
4402                             (ITEM_TYPE(item) == XFS_LI_6_1_BUF) ||
4403                             (ITEM_TYPE(item) == XFS_LI_5_3_BUF)) {
4404                                 kdb_printf("BUF:");
4405                                 xfsidbg_xlog_buf_logitem(item);
4406                         } else if ((ITEM_TYPE(item) == XFS_LI_INODE) ||
4407                                    (ITEM_TYPE(item) == XFS_LI_6_1_INODE) ||
4408                                    (ITEM_TYPE(item) == XFS_LI_5_3_INODE)) {
4409                                 kdb_printf("INODE:\n");
4410                         } else if (ITEM_TYPE(item) == XFS_LI_EFI) {
4411                                 kdb_printf("EFI:\n");
4412                         } else if (ITEM_TYPE(item) == XFS_LI_EFD) {
4413                                 kdb_printf("EFD:\n");
4414                         } else if (ITEM_TYPE(item) == XFS_LI_DQUOT) {
4415                                 kdb_printf("DQUOT:\n");
4416                         } else if ((ITEM_TYPE(item) == XFS_LI_QUOTAOFF)) {
4417                                 kdb_printf("QUOTAOFF:\n");
4418                         } else {
4419                                 kdb_printf("UNKNOWN LOGITEM 0x%x\n", ITEM_TYPE(item));
4420                         }
4421                         item = item->ri_next;
4422                 } while (item != first_rip);
4423         }
4424 }       /* xfsidbg_xlog_rtrans */
4425
4426 /*
4427  * Print out an XFS ticket structure.
4428  */
4429 static void
4430 xfsidbg_xlog_tic(xlog_ticket_t *tic)
4431 {
4432         static char *t_flags[] = {
4433                 "INIT",         /* 0x1 */
4434                 "PERM_RES",     /* 0x2 */
4435                 "IN_Q",         /* 0x4 */
4436                 0
4437         };
4438
4439         kdb_printf("xlog_ticket at 0x%p\n", tic);
4440         kdb_printf("next: 0x%p  prev: 0x%p  tid: 0x%x  \n",
4441                 tic->t_next, tic->t_prev, tic->t_tid);
4442         kdb_printf("curr_res: %d  unit_res: %d  ocnt: %d  cnt: %d\n",
4443                 tic->t_curr_res, tic->t_unit_res, (int)tic->t_ocnt,
4444                 (int)tic->t_cnt);
4445         kdb_printf("clientid: %c  \n", tic->t_clientid);
4446         printflags(tic->t_flags, t_flags,"ticket");
4447         kdb_printf("\n");
4448 }       /* xfsidbg_xlog_tic */
4449
4450 /*
4451  * Print out a single log item.
4452  */
4453 static void
4454 xfsidbg_xlogitem(xfs_log_item_t *lip)
4455 {
4456         xfs_log_item_t  *bio_lip;
4457         static char *lid_type[] = {
4458                 "???",          /* 0 */
4459                 "5-3-buf",      /* 1 */
4460                 "5-3-inode",    /* 2 */
4461                 "efi",          /* 3 */
4462                 "efd",          /* 4 */
4463                 "iunlink",      /* 5 */
4464                 "6-1-inode",    /* 6 */
4465                 "6-1-buf",      /* 7 */
4466                 "inode",        /* 8 */
4467                 "buf",          /* 9 */
4468                 "dquot",        /* 10 */
4469                 0
4470                 };
4471         static char *li_flags[] = {
4472                 "in ail",       /* 0x1 */
4473                 0
4474                 };
4475
4476         kdb_printf("type %s mountp 0x%p flags ",
4477                 lid_type[lip->li_type - XFS_LI_5_3_BUF + 1],
4478                 lip->li_mountp);
4479         printflags((uint)(lip->li_flags), li_flags,"log");
4480         kdb_printf("\n");
4481         kdb_printf("ail forw 0x%p ail back 0x%p lsn %s desc %p ops 0x%p\n",
4482                 lip->li_ail.ail_forw, lip->li_ail.ail_back,
4483                 xfs_fmtlsn(&(lip->li_lsn)), lip->li_desc, lip->li_ops);
4484         kdb_printf("iodonefunc &0x%p\n", lip->li_cb);
4485         if (lip->li_type == XFS_LI_BUF) {
4486                 bio_lip = lip->li_bio_list;
4487                 if (bio_lip != NULL) {
4488                         kdb_printf("iodone list:\n");
4489                 }
4490                 while (bio_lip != NULL) {
4491                         kdb_printf("item 0x%p func 0x%p\n",
4492                                 bio_lip, bio_lip->li_cb);
4493                         bio_lip = bio_lip->li_bio_list;
4494                 }
4495         }
4496         switch (lip->li_type) {
4497         case XFS_LI_BUF:
4498                 xfs_buf_item_print((xfs_buf_log_item_t *)lip, 0);
4499                 break;
4500         case XFS_LI_INODE:
4501                 xfs_inode_item_print((xfs_inode_log_item_t *)lip, 0);
4502                 break;
4503         case XFS_LI_EFI:
4504                 xfs_efi_item_print((xfs_efi_log_item_t *)lip, 0);
4505                 break;
4506         case XFS_LI_EFD:
4507                 xfs_efd_item_print((xfs_efd_log_item_t *)lip, 0);
4508                 break;
4509         case XFS_LI_DQUOT:
4510                 xfs_dquot_item_print((xfs_dq_logitem_t *)lip, 0);
4511                 break;
4512         case XFS_LI_QUOTAOFF:
4513                 xfs_qoff_item_print((xfs_qoff_logitem_t *)lip, 0);
4514                 break;
4515
4516         default:
4517                 kdb_printf("Unknown item type %d\n", lip->li_type);
4518                 break;
4519         }
4520 }
4521
4522 /*
4523  * Print out a summary of the AIL hanging off of a mount struct.
4524  */
4525 static void
4526 xfsidbg_xaildump(xfs_mount_t *mp)
4527 {
4528         xfs_log_item_t *lip;
4529         static char *lid_type[] = {
4530                 "???",          /* 0 */
4531                 "5-3-buf",      /* 1 */
4532                 "5-3-inode",    /* 2 */
4533                 "efi",          /* 3 */
4534                 "efd",          /* 4 */
4535                 "iunlink",      /* 5 */
4536                 "6-1-inode",    /* 6 */
4537                 "6-1-buf",      /* 7 */
4538                 "inode",        /* 8 */
4539                 "buf",          /* 9 */
4540                 "dquot",        /* 10 */
4541                 0
4542                 };
4543         static char *li_flags[] = {
4544                 "in ail",       /* 0x1 */
4545                 0
4546                 };
4547         int count;
4548
4549         if ((mp->m_ail.ail_forw == NULL) ||
4550             (mp->m_ail.ail_forw == (xfs_log_item_t *)&mp->m_ail)) {
4551                 kdb_printf("AIL is empty\n");
4552                 return;
4553         }
4554         kdb_printf("AIL for mp 0x%p, oldest first\n", mp);
4555         lip = (xfs_log_item_t*)mp->m_ail.ail_forw;
4556         for (count = 0; lip; count++) {
4557                 kdb_printf("[%d] type %s ", count,
4558                               lid_type[lip->li_type - XFS_LI_5_3_BUF + 1]);
4559                 printflags((uint)(lip->li_flags), li_flags, "flags:");
4560                 kdb_printf("  lsn %s\n   ", xfs_fmtlsn(&(lip->li_lsn)));
4561                 switch (lip->li_type) {
4562                 case XFS_LI_BUF:
4563                         xfs_buf_item_print((xfs_buf_log_item_t *)lip, 1);
4564                         break;
4565                 case XFS_LI_INODE:
4566                         xfs_inode_item_print((xfs_inode_log_item_t *)lip, 1);
4567                         break;
4568                 case XFS_LI_EFI:
4569                         xfs_efi_item_print((xfs_efi_log_item_t *)lip, 1);
4570                         break;
4571                 case XFS_LI_EFD:
4572                         xfs_efd_item_print((xfs_efd_log_item_t *)lip, 1);
4573                         break;
4574                 case XFS_LI_DQUOT:
4575                         xfs_dquot_item_print((xfs_dq_logitem_t *)lip, 1);
4576                         break;
4577                 case XFS_LI_QUOTAOFF:
4578                         xfs_qoff_item_print((xfs_qoff_logitem_t *)lip, 1);
4579                         break;
4580                 default:
4581                         kdb_printf("Unknown item type %d\n", lip->li_type);
4582                         break;
4583                 }
4584
4585                 if (lip->li_ail.ail_forw == (xfs_log_item_t*)&mp->m_ail) {
4586                         lip = NULL;
4587                 } else {
4588                         lip = lip->li_ail.ail_forw;
4589                 }
4590         }
4591 }
4592
4593 /*
4594  * Print xfs mount structure.
4595  */
4596 static void
4597 xfsidbg_xmount(xfs_mount_t *mp)
4598 {
4599         static char *xmount_flags[] = {
4600                 "WSYNC",        /* 0x0001 */
4601                 "INO64",        /* 0x0002 */
4602                 "RQCHK",        /* 0x0004 */
4603                 "FSCLEAN",      /* 0x0008 */
4604                 "FSSHUTDN",     /* 0x0010 */
4605                 "NOATIME",      /* 0x0020 */
4606                 "RETERR",       /* 0x0040 */
4607                 "NOALIGN",      /* 0x0080 */
4608                 "UNSHRD",       /* 0x0100 */
4609                 "RGSTRD",       /* 0x0200 */
4610                 "NORECVR",      /* 0x0400 */
4611                 "SHRD",         /* 0x0800 */
4612                 "IOSZ",         /* 0x1000 */
4613                 "OSYNC",        /* 0x2000 */
4614                 "NOUUID",       /* 0x4000 */
4615                 "32BIT",        /* 0x8000 */
4616                 "NOLOGFLUSH",   /* 0x10000 */
4617                 0
4618         };
4619
4620         static char *quota_flags[] = {
4621                 "UQ",           /* 0x0001 */
4622                 "UQE",          /* 0x0002 */
4623                 "UQCHKD",       /* 0x0004 */
4624                 "PQ",           /* 0x0008 (IRIX ondisk) */
4625                 "GQE",          /* 0x0010 */
4626                 "GQCHKD",       /* 0x0020 */
4627                 "GQ",           /* 0x0040 */
4628                 "UQACTV",       /* 0x0080 */
4629                 "GQACTV",       /* 0x0100 */
4630                 "QMAYBE",       /* 0x0200 */
4631                 0
4632         };
4633
4634         kdb_printf("xfs_mount at 0x%p\n", mp);
4635         kdb_printf("vfsp 0x%p tid 0x%x ail_lock 0x%p &ail 0x%p\n",
4636                 XFS_MTOVFS(mp), mp->m_tid, &mp->m_ail_lock, &mp->m_ail);
4637         kdb_printf("ail_gen 0x%x &sb 0x%p\n",
4638                 mp->m_ail_gen, &mp->m_sb);
4639         kdb_printf("sb_lock 0x%p sb_bp 0x%p dev 0x%x logdev 0x%x rtdev 0x%x\n",
4640                 &mp->m_sb_lock, mp->m_sb_bp,
4641                 mp->m_ddev_targp ? mp->m_ddev_targp->pbr_dev : 0,
4642                 mp->m_logdev_targp ? mp->m_logdev_targp->pbr_dev : 0,
4643                 mp->m_rtdev_targp ? mp->m_rtdev_targp->pbr_dev : 0);
4644         kdb_printf("bsize %d agfrotor %d agirotor %d ihash 0x%p ihsize %d\n",
4645                 mp->m_bsize, mp->m_agfrotor, mp->m_agirotor,
4646                 mp->m_ihash, mp->m_ihsize);
4647         kdb_printf("inodes 0x%p ilock 0x%p ireclaims 0x%x\n",
4648                 mp->m_inodes, &mp->m_ilock, mp->m_ireclaims);
4649         kdb_printf("readio_log 0x%x readio_blocks 0x%x ",
4650                 mp->m_readio_log, mp->m_readio_blocks);
4651         kdb_printf("writeio_log 0x%x writeio_blocks 0x%x\n",
4652                 mp->m_writeio_log, mp->m_writeio_blocks);
4653         kdb_printf("logbufs %d logbsize %d LOG 0x%p\n", mp->m_logbufs,
4654                 mp->m_logbsize, mp->m_log);
4655         kdb_printf("rsumlevels 0x%x rsumsize 0x%x rbmip 0x%p rsumip 0x%p\n",
4656                 mp->m_rsumlevels, mp->m_rsumsize, mp->m_rbmip, mp->m_rsumip);
4657         kdb_printf("rootip 0x%p\n", mp->m_rootip);
4658         kdb_printf("dircook_elog %d blkbit_log %d blkbb_log %d agno_log %d\n",
4659                 mp->m_dircook_elog, mp->m_blkbit_log, mp->m_blkbb_log,
4660                 mp->m_agno_log);
4661         kdb_printf("agino_log %d nreadaheads %d inode cluster size %d\n",
4662                 mp->m_agino_log, mp->m_nreadaheads,
4663                 mp->m_inode_cluster_size);
4664         kdb_printf("blockmask 0x%x blockwsize 0x%x blockwmask 0x%x\n",
4665                 mp->m_blockmask, mp->m_blockwsize, mp->m_blockwmask);
4666         kdb_printf("alloc_mxr[lf,nd] %d %d alloc_mnr[lf,nd] %d %d\n",
4667                 mp->m_alloc_mxr[0], mp->m_alloc_mxr[1],
4668                 mp->m_alloc_mnr[0], mp->m_alloc_mnr[1]);
4669         kdb_printf("bmap_dmxr[lfnr,ndnr] %d %d bmap_dmnr[lfnr,ndnr] %d %d\n",
4670                 mp->m_bmap_dmxr[0], mp->m_bmap_dmxr[1],
4671                 mp->m_bmap_dmnr[0], mp->m_bmap_dmnr[1]);
4672         kdb_printf("inobt_mxr[lf,nd] %d %d inobt_mnr[lf,nd] %d %d\n",
4673                 mp->m_inobt_mxr[0], mp->m_inobt_mxr[1],
4674                 mp->m_inobt_mnr[0], mp->m_inobt_mnr[1]);
4675         kdb_printf("ag_maxlevels %d bm_maxlevels[d,a] %d %d in_maxlevels %d\n",
4676                 mp->m_ag_maxlevels, mp->m_bm_maxlevels[0],
4677                 mp->m_bm_maxlevels[1], mp->m_in_maxlevels);
4678         kdb_printf("perag 0x%p &peraglock 0x%p &growlock 0x%p\n",
4679                 mp->m_perag, &mp->m_peraglock, &mp->m_growlock);
4680         printflags(mp->m_flags, xmount_flags,"flags");
4681         kdb_printf("ialloc_inos %d ialloc_blks %d litino %d\n",
4682                 mp->m_ialloc_inos, mp->m_ialloc_blks, mp->m_litino);
4683         kdb_printf("dir_node_ents %u attr_node_ents %u\n",
4684                 mp->m_dir_node_ents, mp->m_attr_node_ents);
4685         kdb_printf("attroffset %d maxicount %Ld inoalign_mask %d\n",
4686                 mp->m_attroffset, mp->m_maxicount, mp->m_inoalign_mask);
4687         kdb_printf("resblks %Ld resblks_avail %Ld\n", mp->m_resblks,
4688                 mp->m_resblks_avail);
4689 #if XFS_BIG_FILESYSTEMS
4690         kdb_printf(" inoadd %llx\n", (unsigned long long) mp->m_inoadd);
4691 #else
4692         kdb_printf("\n");
4693 #endif
4694         if (mp->m_quotainfo)
4695                 kdb_printf("quotainfo 0x%p (uqip = 0x%p, gqip = 0x%p)\n",
4696                         mp->m_quotainfo,
4697                         mp->m_quotainfo->qi_uquotaip,
4698                         mp->m_quotainfo->qi_gquotaip);
4699         else
4700                 kdb_printf("quotainfo NULL\n");
4701         printflags(mp->m_qflags, quota_flags,"quotaflags");
4702         kdb_printf("\n");
4703         kdb_printf("dalign %d swidth %d sinoalign %d attr_magicpct %d dir_magicpct %d\n",
4704                 mp->m_dalign, mp->m_swidth, mp->m_sinoalign,
4705                 mp->m_attr_magicpct, mp->m_dir_magicpct);
4706         kdb_printf("mk_sharedro %d inode_quiesce %d sectbb_log %d\n",
4707                 mp->m_mk_sharedro, mp->m_inode_quiesce, mp->m_sectbb_log);
4708         kdb_printf("dirversion %d dirblkfsbs %d &dirops 0x%p\n",
4709                 mp->m_dirversion, mp->m_dirblkfsbs, &mp->m_dirops);
4710         kdb_printf("dirblksize %d dirdatablk 0x%Lx dirleafblk 0x%Lx dirfreeblk 0x%Lx\n",
4711                 mp->m_dirblksize,
4712                 (xfs_dfiloff_t)mp->m_dirdatablk,
4713                 (xfs_dfiloff_t)mp->m_dirleafblk,
4714                 (xfs_dfiloff_t)mp->m_dirfreeblk);
4715         kdb_printf("chsize %d chash 0x%p\n",
4716                 mp->m_chsize, mp->m_chash);
4717         kdb_printf("m_frozen %d m_active_trans %d\n",
4718                 mp->m_frozen, mp->m_active_trans.counter);
4719         if (mp->m_fsname != NULL)
4720                 kdb_printf("mountpoint \"%s\"\n", mp->m_fsname);
4721         else
4722                 kdb_printf("No name!!!\n");
4723
4724 }
4725
4726 static void
4727 xfsidbg_xihash(xfs_mount_t *mp)
4728 {
4729         xfs_ihash_t     *ih;
4730         int             i;
4731         int             j;
4732         int             total;
4733         int             numzeros;
4734         xfs_inode_t     *ip;
4735         int             *hist;
4736         int             hist_bytes = mp->m_ihsize * sizeof(int);
4737         int             hist2[21];
4738
4739         hist = (int *) kmalloc(hist_bytes, GFP_KERNEL);
4740
4741         if (hist == NULL) {
4742                 kdb_printf("xfsidbg_xihash: kmalloc(%d) failed!\n",
4743                                                         hist_bytes);
4744                 return;
4745         }
4746
4747         for (i = 0; i < mp->m_ihsize; i++) {
4748                 ih = mp->m_ihash + i;
4749                 j = 0;
4750                 for (ip = ih->ih_next; ip != NULL; ip = ip->i_next)
4751                         j++;
4752                 hist[i] = j;
4753         }
4754
4755         numzeros = total = 0;
4756
4757         for (i = 0; i < 21; i++)
4758                 hist2[i] = 0;
4759
4760         for (i = 0; i < mp->m_ihsize; i++)  {
4761                 kdb_printf("%d ", hist[i]);
4762                 total += hist[i];
4763                 numzeros += hist[i] == 0 ? 1 : 0;
4764                 if (hist[i] > 20)
4765                         j = 20;
4766                 else
4767                         j = hist[i];
4768
4769                 if (! (j <= 20)) {
4770                         kdb_printf("xfsidbg_xihash: (j > 20)/%d @ line # %d\n",
4771                                                         j, __LINE__);
4772                         return;
4773                 }
4774
4775                 hist2[j]++;
4776         }
4777
4778         kdb_printf("\n");
4779
4780         kdb_printf("total inodes = %d, average length = %d, adjusted average = %d \n",
4781                 total, total / mp->m_ihsize,
4782                 total / (mp->m_ihsize - numzeros));
4783
4784         for (i = 0; i < 21; i++)  {
4785                 kdb_printf("%d - %d , ", i, hist2[i]);
4786         }
4787         kdb_printf("\n");
4788         kfree(hist);
4789 }
4790
4791 /*
4792  * Command to print xfs inodes: kp xnode <addr>
4793  */
4794 static void
4795 xfsidbg_xnode(xfs_inode_t *ip)
4796 {
4797         static char *tab_flags[] = {
4798                 "grio",         /* XFS_IGRIO */
4799                 "uiosize",      /* XFS_IUIOSZ */
4800                 "quiesce",      /* XFS_IQUIESCE */
4801                 "reclaim",      /* XFS_IRECLAIM */
4802                 NULL
4803         };
4804
4805         kdb_printf("hash 0x%p next 0x%p prevp 0x%p mount 0x%p\n",
4806                 ip->i_hash,
4807                 ip->i_next,
4808                 ip->i_prevp,
4809                 ip->i_mount);
4810         kdb_printf("mnext 0x%p mprev 0x%p vnode 0x%p \n",
4811                 ip->i_mnext,
4812                 ip->i_mprev,
4813                 XFS_ITOV_NULL(ip));
4814         kdb_printf("dev %x ino %s\n",
4815                 ip->i_mount->m_dev,
4816                 xfs_fmtino(ip->i_ino, ip->i_mount));
4817         kdb_printf("blkno 0x%llx len 0x%x boffset 0x%x\n",
4818                 (long long) ip->i_blkno,
4819                 ip->i_len,
4820                 ip->i_boffset);
4821         kdb_printf("transp 0x%p &itemp 0x%p\n",
4822                 ip->i_transp,
4823                 ip->i_itemp);
4824         kdb_printf("&lock 0x%p &iolock 0x%p",
4825                 &ip->i_lock,
4826                 &ip->i_iolock);
4827         kdb_printf("&flock 0x%p (%d) pincount 0x%x\n",
4828                 &ip->i_flock, valusema(&ip->i_flock),
4829                 xfs_ipincount(ip));
4830         kdb_printf("udquotp 0x%p gdquotp 0x%p\n",
4831                 ip->i_udquot, ip->i_gdquot);
4832         kdb_printf("new_size %Lx\n", ip->i_iocore.io_new_size);
4833         printflags((int)ip->i_flags, tab_flags, "flags");
4834         kdb_printf("\n");
4835         kdb_printf("update_core 0x%x update size 0x%x\n",
4836                 (int)(ip->i_update_core), (int) ip->i_update_size);
4837         kdb_printf("gen 0x%x delayed blks %d",
4838                 ip->i_gen,
4839                 ip->i_delayed_blks);
4840         kdb_printf("\n");
4841         kdb_printf("chash 0x%p cnext 0x%p cprev 0x%p\n",
4842                 ip->i_chash,
4843                 ip->i_cnext,
4844                 ip->i_cprev);
4845         xfs_xnode_fork("data", &ip->i_df);
4846         xfs_xnode_fork("attr", ip->i_afp);
4847         kdb_printf("\n");
4848         xfs_prdinode_core(&ip->i_d, ARCH_NOCONVERT);
4849 }
4850
4851 static void
4852 xfsidbg_xcore(xfs_iocore_t *io)
4853 {
4854         kdb_printf("io_obj 0x%p io_flags 0x%x io_mount 0x%p\n",
4855                         io->io_obj, io->io_flags, io->io_mount);
4856         kdb_printf("new_size %Lx\n", io->io_new_size);
4857 }
4858
4859 /*
4860  * Command to print xfs inode cluster hash table: kp xchash <addr>
4861  */
4862 static void
4863 xfsidbg_xchash(xfs_mount_t *mp)
4864 {
4865         int             i;
4866         xfs_chash_t     *ch;
4867
4868         kdb_printf("m_chash 0x%p size %d\n",
4869                 mp->m_chash, mp->m_chsize);
4870         for (i = 0; i < mp->m_chsize; i++) {
4871                 ch = mp->m_chash + i;
4872                 kdb_printf("[%3d] ch 0x%p chashlist 0x%p\n", i, ch, ch->ch_list);
4873                 xfsidbg_xchashlist(ch->ch_list);
4874         }
4875 }
4876
4877 /*
4878  * Command to print xfs inode cluster hash list: kp xchashlist <addr>
4879  */
4880 static void
4881 xfsidbg_xchashlist(xfs_chashlist_t *chl)
4882 {
4883         xfs_inode_t     *ip;
4884
4885         while (chl != NULL) {
4886                 kdb_printf("hashlist inode 0x%p blkno %lld buf 0x%p",
4887                        chl->chl_ip, (long long) chl->chl_blkno, chl->chl_buf);
4888
4889                 kdb_printf("\n");
4890
4891                 /* print inodes on chashlist */
4892                 ip = chl->chl_ip;
4893                 do {
4894                         kdb_printf("0x%p ", ip);
4895                         ip = ip->i_cnext;
4896                 } while (ip != chl->chl_ip);
4897                 kdb_printf("\n");
4898
4899                 chl=chl->chl_next;
4900         }
4901 }
4902
4903 /*
4904  * Print xfs per-ag data structures for filesystem.
4905  */
4906 static void
4907 xfsidbg_xperag(xfs_mount_t *mp)
4908 {
4909         xfs_agnumber_t  agno;
4910         xfs_perag_t     *pag;
4911         int             busy;
4912
4913         pag = mp->m_perag;
4914         for (agno = 0; agno < mp->m_sb.sb_agcount; agno++, pag++) {
4915                 kdb_printf("ag %d f_init %d i_init %d\n",
4916                         agno, pag->pagf_init, pag->pagi_init);
4917                 if (pag->pagf_init)
4918                         kdb_printf(
4919         "    f_levels[b,c] %d,%d f_flcount %d f_freeblks %d f_longest %d\n"
4920         "    f__metadata %d\n",
4921                                 pag->pagf_levels[XFS_BTNUM_BNOi],
4922                                 pag->pagf_levels[XFS_BTNUM_CNTi],
4923                                 pag->pagf_flcount, pag->pagf_freeblks,
4924                                 pag->pagf_longest, pag->pagf_metadata);
4925                 if (pag->pagi_init)
4926                         kdb_printf("    i_freecount %d i_inodeok %d\n",
4927                                 pag->pagi_freecount, pag->pagi_inodeok);
4928                 if (pag->pagf_init) {
4929                         for (busy = 0; busy < XFS_PAGB_NUM_SLOTS; busy++) {
4930                                 if (pag->pagb_list[busy].busy_length != 0) {
4931                                         kdb_printf(
4932                 "        %04d: start %d length %d tp 0x%p\n",
4933                                             busy,
4934                                             pag->pagb_list[busy].busy_start,
4935                                             pag->pagb_list[busy].busy_length,
4936                                             pag->pagb_list[busy].busy_tp);
4937                                 }
4938                         }
4939                 }
4940         }
4941 }
4942
4943 #ifdef CONFIG_XFS_QUOTA
4944 static void
4945 xfsidbg_xqm()
4946 {
4947         if (xfs_Gqm == NULL) {
4948                 kdb_printf("NULL XQM!!\n");
4949                 return;
4950         }
4951
4952         kdb_printf("usrhtab 0x%p\tgrphtab 0x%p\tndqfree 0x%x\thashmask 0x%x\n",
4953                 xfs_Gqm->qm_usr_dqhtable,
4954                 xfs_Gqm->qm_grp_dqhtable,
4955                 xfs_Gqm->qm_dqfreelist.qh_nelems,
4956                 xfs_Gqm->qm_dqhashmask);
4957         kdb_printf("&freelist 0x%p, totaldquots 0x%x nrefs 0x%x\n",
4958                 &xfs_Gqm->qm_dqfreelist,
4959                 atomic_read(&xfs_Gqm->qm_totaldquots),
4960                 xfs_Gqm->qm_nrefs);
4961 }
4962 #endif
4963
4964 static void
4965 xfsidbg_xqm_diskdq(xfs_disk_dquot_t *d)
4966 {
4967         kdb_printf("magic 0x%x\tversion 0x%x\tID 0x%x (%d)\t\n",
4968                 INT_GET(d->d_magic, ARCH_CONVERT),
4969                 INT_GET(d->d_version, ARCH_CONVERT),
4970                 INT_GET(d->d_id, ARCH_CONVERT),
4971                 INT_GET(d->d_id, ARCH_CONVERT));
4972         kdb_printf("bhard 0x%llx\tbsoft 0x%llx\tihard 0x%llx\tisoft 0x%llx\n",
4973                 (unsigned long long)INT_GET(d->d_blk_hardlimit, ARCH_CONVERT),
4974                 (unsigned long long)INT_GET(d->d_blk_softlimit, ARCH_CONVERT),
4975                 (unsigned long long)INT_GET(d->d_ino_hardlimit, ARCH_CONVERT),
4976                 (unsigned long long)INT_GET(d->d_ino_softlimit, ARCH_CONVERT));
4977         kdb_printf("bcount 0x%llx icount 0x%llx\n",
4978                 (unsigned long long)INT_GET(d->d_bcount, ARCH_CONVERT),
4979                 (unsigned long long)INT_GET(d->d_icount, ARCH_CONVERT));
4980         kdb_printf("btimer 0x%x itimer 0x%x \n",
4981                 (int)INT_GET(d->d_btimer, ARCH_CONVERT),
4982                 (int)INT_GET(d->d_itimer, ARCH_CONVERT));
4983 }
4984
4985 static void
4986 xfsidbg_xqm_dquot(xfs_dquot_t *dqp)
4987 {
4988         static char *qflags[] = {
4989                 "USR",
4990                 "GRP",
4991                 "LCKD",
4992                 "FLKD",
4993                 "DIRTY",
4994                 "WANT",
4995                 "INACT",
4996                 "MARKER",
4997                 0
4998         };
4999         kdb_printf("mount 0x%p hash 0x%p gdquotp 0x%p HL_next 0x%p HL_prevp 0x%p\n",
5000                 dqp->q_mount,
5001                 dqp->q_hash,
5002                 dqp->q_gdquot,
5003                 dqp->HL_NEXT,
5004                 dqp->HL_PREVP);
5005         kdb_printf("MPL_next 0x%p MPL_prevp 0x%p FL_next 0x%p FL_prev 0x%p\n",
5006                 dqp->MPL_NEXT,
5007                 dqp->MPL_PREVP,
5008                 dqp->dq_flnext,
5009                 dqp->dq_flprev);
5010
5011         kdb_printf("nrefs 0x%x, res_bcount %d, ",
5012                 dqp->q_nrefs, (int) dqp->q_res_bcount);
5013         printflags(dqp->dq_flags, qflags, "flags:");
5014         kdb_printf("\nblkno 0x%llx\tboffset 0x%x\n",
5015                 (unsigned long long) dqp->q_blkno, (int) dqp->q_bufoffset);
5016         kdb_printf("qlock 0x%p  flock 0x%p (%s) pincount 0x%x\n",
5017                 &dqp->q_qlock,
5018                 &dqp->q_flock,
5019                 (valusema(&dqp->q_flock) <= 0) ? "LCK" : "UNLKD",
5020                 dqp->q_pincount);
5021         kdb_printf("disk-dquot 0x%p\n", &dqp->q_core);
5022         xfsidbg_xqm_diskdq(&dqp->q_core);
5023
5024 }
5025
5026
5027 #define XQMIDBG_LIST_PRINT(l, NXT) \
5028 { \
5029           xfs_dquot_t   *dqp;\
5030           int i = 0; \
5031           kdb_printf("[#%d dquots]\n", (int) (l)->qh_nelems); \
5032           for (dqp = (l)->qh_next; dqp != NULL; dqp = dqp->NXT) {\
5033            kdb_printf( \
5034               "\t%d. [0x%p] \"%d (%s)\"\t blks = %d, inos = %d refs = %d\n", \
5035                          ++i, dqp, (int) INT_GET(dqp->q_core.d_id, ARCH_CONVERT), \
5036                          DQFLAGTO_TYPESTR(dqp),      \
5037                          (int) INT_GET(dqp->q_core.d_bcount, ARCH_CONVERT), \
5038                          (int) INT_GET(dqp->q_core.d_icount, ARCH_CONVERT), \
5039                          (int) dqp->q_nrefs); }\
5040           kdb_printf("\n"); \
5041 }
5042
5043 static void
5044 xfsidbg_xqm_dqattached_inos(xfs_mount_t *mp)
5045 {
5046         xfs_inode_t     *ip;
5047         int             n = 0;
5048
5049         ip = mp->m_inodes;
5050         do {
5051                 if (ip->i_mount == NULL) {
5052                         ip = ip->i_mnext;
5053                         continue;
5054                 }
5055                 if (ip->i_udquot || ip->i_gdquot) {
5056                         n++;
5057                         kdb_printf("inode = 0x%p, ino %d: udq 0x%p, gdq 0x%p\n",
5058                                 ip, (int)ip->i_ino, ip->i_udquot, ip->i_gdquot);
5059                 }
5060                 ip = ip->i_mnext;
5061         } while (ip != mp->m_inodes);
5062         kdb_printf("\nNumber of inodes with dquots attached: %d\n", n);
5063 }
5064
5065 #ifdef  CONFIG_XFS_QUOTA
5066 static void
5067 xfsidbg_xqm_freelist_print(xfs_frlist_t *qlist, char *title)
5068 {
5069         xfs_dquot_t *dq;
5070         int i = 0;
5071         kdb_printf("%s (#%d)\n", title, (int) qlist->qh_nelems);
5072         FOREACH_DQUOT_IN_FREELIST(dq, qlist) {
5073                 kdb_printf("\t%d.\t\"%d (%s:0x%p)\"\t bcnt = %d, icnt = %d "
5074                        "refs = %d\n",
5075                        ++i, (int) INT_GET(dq->q_core.d_id, ARCH_CONVERT),
5076                        DQFLAGTO_TYPESTR(dq), dq,
5077                        (int) INT_GET(dq->q_core.d_bcount, ARCH_CONVERT),
5078                        (int) INT_GET(dq->q_core.d_icount, ARCH_CONVERT),
5079                        (int) dq->q_nrefs);
5080         }
5081 }
5082
5083 static void
5084 xfsidbg_xqm_freelist(void)
5085 {
5086         if (xfs_Gqm) {
5087                 xfsidbg_xqm_freelist_print(&(xfs_Gqm->qm_dqfreelist), "Freelist");
5088         } else
5089                 kdb_printf("NULL XQM!!\n");
5090 }
5091
5092 static void
5093 xfsidbg_xqm_htab(void)
5094 {
5095         int             i;
5096         xfs_dqhash_t    *h;
5097
5098         if (xfs_Gqm == NULL) {
5099                 kdb_printf("NULL XQM!!\n");
5100                 return;
5101         }
5102         for (i = 0; i <= xfs_Gqm->qm_dqhashmask; i++) {
5103                 h = &xfs_Gqm->qm_usr_dqhtable[i];
5104                 if (h->qh_next) {
5105                         kdb_printf("USR %d: ", i);
5106                         XQMIDBG_LIST_PRINT(h, HL_NEXT);
5107                 }
5108         }
5109         for (i = 0; i <= xfs_Gqm->qm_dqhashmask; i++) {
5110                 h = &xfs_Gqm->qm_grp_dqhtable[i];
5111                 if (h->qh_next) {
5112                         kdb_printf("GRP %d: ", i);
5113                         XQMIDBG_LIST_PRINT(h, HL_NEXT);
5114                 }
5115         }
5116 }
5117 #endif
5118
5119 static void
5120 xfsidbg_xqm_mplist(xfs_mount_t *mp)
5121 {
5122         if (mp->m_quotainfo == NULL) {
5123                 kdb_printf("NULL quotainfo\n");
5124                 return;
5125         }
5126
5127         XQMIDBG_LIST_PRINT(&(mp->m_quotainfo->qi_dqlist), MPL_NEXT);
5128
5129 }
5130
5131
5132 static void
5133 xfsidbg_xqm_qinfo(xfs_mount_t *mp)
5134 {
5135         if (mp == NULL || mp->m_quotainfo == NULL) {
5136                 kdb_printf("NULL quotainfo\n");
5137                 return;
5138         }
5139
5140         kdb_printf("uqip 0x%p, gqip 0x%p, &pinlock 0x%p &dqlist 0x%p\n",
5141                 mp->m_quotainfo->qi_uquotaip,
5142                 mp->m_quotainfo->qi_gquotaip,
5143                 &mp->m_quotainfo->qi_pinlock,
5144                 &mp->m_quotainfo->qi_dqlist);
5145
5146         kdb_printf("nreclaims %d, btmlimit 0x%x, itmlimit 0x%x, RTbtmlim 0x%x\n",
5147                 (int)mp->m_quotainfo->qi_dqreclaims,
5148                 (int)mp->m_quotainfo->qi_btimelimit,
5149                 (int)mp->m_quotainfo->qi_itimelimit,
5150                 (int)mp->m_quotainfo->qi_rtbtimelimit);
5151
5152         kdb_printf("bwarnlim 0x%x, iwarnlim 0x%x, &qofflock 0x%p, "
5153                 "chunklen 0x%x, dqperchunk 0x%x\n",
5154                 (int)mp->m_quotainfo->qi_bwarnlimit,
5155                 (int)mp->m_quotainfo->qi_iwarnlimit,
5156                 &mp->m_quotainfo->qi_quotaofflock,
5157                 (int)mp->m_quotainfo->qi_dqchunklen,
5158                 (int)mp->m_quotainfo->qi_dqperchunk);
5159 }
5160
5161 static void
5162 xfsidbg_xqm_tpdqinfo(xfs_trans_t *tp)
5163 {
5164         xfs_dqtrx_t     *qa, *q;
5165         int             i,j;
5166
5167         kdb_printf("dqinfo 0x%p\n", tp->t_dqinfo);
5168         if (! tp->t_dqinfo)
5169                 return;
5170         kdb_printf("USR: \n");
5171         qa = tp->t_dqinfo->dqa_usrdquots;
5172         for (j = 0; j < 2; j++) {
5173                 for (i = 0; i < XFS_QM_TRANS_MAXDQS; i++) {
5174                         if (qa[i].qt_dquot == NULL)
5175                                 break;
5176                         q = &qa[i];
5177                         kdb_printf(
5178   "\"%d\"[0x%p]: bres %d, bres-used %d, bdelta %d, del-delta %d, icnt-delta %d\n",
5179                                 (int) q->qt_dquot->q_core.d_id,
5180                                 q->qt_dquot,
5181                                 (int) q->qt_blk_res,
5182                                 (int) q->qt_blk_res_used,
5183                                 (int) q->qt_bcount_delta,
5184                                 (int) q->qt_delbcnt_delta,
5185                                 (int) q->qt_icount_delta);
5186                 }
5187                 if (j == 0) {
5188                         qa = tp->t_dqinfo->dqa_grpdquots;
5189                         kdb_printf("GRP: \n");
5190                 }
5191         }
5192
5193 }
5194
5195
5196
5197 /*
5198  * Print xfs superblock.
5199  */
5200 static void
5201 xfsidbg_xsb(xfs_sb_t *sbp, int convert)
5202 {
5203         xfs_arch_t arch=convert?ARCH_CONVERT:ARCH_NOCONVERT;
5204
5205         kdb_printf(convert?"<converted>\n":"<unconverted>\n");
5206
5207         kdb_printf("magicnum 0x%x blocksize 0x%x dblocks %Ld rblocks %Ld\n",
5208                 INT_GET(sbp->sb_magicnum, arch), INT_GET(sbp->sb_blocksize, arch),
5209                 INT_GET(sbp->sb_dblocks, arch), INT_GET(sbp->sb_rblocks, arch));
5210         kdb_printf("rextents %Ld uuid %s logstart %s\n",
5211                 INT_GET(sbp->sb_rextents, arch),
5212                 xfs_fmtuuid(&sbp->sb_uuid),
5213                 xfs_fmtfsblock(INT_GET(sbp->sb_logstart, arch), NULL));
5214         kdb_printf("rootino %s ",
5215                 xfs_fmtino(INT_GET(sbp->sb_rootino, arch), NULL));
5216         kdb_printf("rbmino %s ",
5217                 xfs_fmtino(INT_GET(sbp->sb_rbmino, arch), NULL));
5218         kdb_printf("rsumino %s\n",
5219                 xfs_fmtino(INT_GET(sbp->sb_rsumino, arch), NULL));
5220         kdb_printf("rextsize 0x%x agblocks 0x%x agcount 0x%x rbmblocks 0x%x\n",
5221                 INT_GET(sbp->sb_rextsize, arch),
5222                 INT_GET(sbp->sb_agblocks, arch),
5223                 INT_GET(sbp->sb_agcount, arch),
5224                 INT_GET(sbp->sb_rbmblocks, arch));
5225         kdb_printf("logblocks 0x%x versionnum 0x%x sectsize 0x%x inodesize 0x%x\n",
5226                 INT_GET(sbp->sb_logblocks, arch),
5227                 INT_GET(sbp->sb_versionnum, arch),
5228                 INT_GET(sbp->sb_sectsize, arch),
5229                 INT_GET(sbp->sb_inodesize, arch));
5230         kdb_printf("inopblock 0x%x blocklog 0x%x sectlog 0x%x inodelog 0x%x\n",
5231                 INT_GET(sbp->sb_inopblock, arch),
5232                 INT_GET(sbp->sb_blocklog, arch),
5233                 INT_GET(sbp->sb_sectlog, arch),
5234                 INT_GET(sbp->sb_inodelog, arch));
5235         kdb_printf("inopblog %d agblklog %d rextslog %d inprogress %d imax_pct %d\n",
5236                 INT_GET(sbp->sb_inopblog, arch),
5237                 INT_GET(sbp->sb_agblklog, arch),
5238                 INT_GET(sbp->sb_rextslog, arch),
5239                 INT_GET(sbp->sb_inprogress, arch),
5240                 INT_GET(sbp->sb_imax_pct, arch));
5241         kdb_printf("icount %Lx ifree %Lx fdblocks %Lx frextents %Lx\n",
5242                 INT_GET(sbp->sb_icount, arch),
5243                 INT_GET(sbp->sb_ifree, arch),
5244                 INT_GET(sbp->sb_fdblocks, arch),
5245                 INT_GET(sbp->sb_frextents, arch));
5246         kdb_printf("uquotino %s ", xfs_fmtino(INT_GET(sbp->sb_uquotino, arch), NULL));
5247         kdb_printf("gquotino %s ", xfs_fmtino(INT_GET(sbp->sb_gquotino, arch), NULL));
5248         kdb_printf("qflags 0x%x flags 0x%x shared_vn %d inoaligmt %d\n",
5249                 INT_GET(sbp->sb_qflags, arch), INT_GET(sbp->sb_flags, arch), INT_GET(sbp->sb_shared_vn, arch),
5250                 INT_GET(sbp->sb_inoalignmt, arch));
5251         kdb_printf("unit %d width %d dirblklog %d\n",
5252                 INT_GET(sbp->sb_unit, arch), INT_GET(sbp->sb_width, arch), INT_GET(sbp->sb_dirblklog, arch));
5253         kdb_printf("log sunit %d\n", INT_GET(sbp->sb_logsunit, arch));
5254 }
5255
5256
5257 /*
5258  * Print out an XFS transaction structure.  Print summaries for
5259  * each of the items.
5260  */
5261 static void
5262 xfsidbg_xtp(xfs_trans_t *tp)
5263 {
5264         xfs_log_item_chunk_t    *licp;
5265         xfs_log_item_desc_t     *lidp;
5266         xfs_log_busy_chunk_t    *lbcp;
5267         int                     i;
5268         int                     chunk;
5269         static char *xtp_flags[] = {
5270                 "dirty",        /* 0x1 */
5271                 "sb_dirty",     /* 0x2 */
5272                 "perm_log_res", /* 0x4 */
5273                 "sync",         /* 0x08 */
5274                 "dq_dirty",     /* 0x10 */
5275                 0
5276                 };
5277         static char *lid_flags[] = {
5278                 "dirty",        /* 0x1 */
5279                 "pinned",       /* 0x2 */
5280                 "sync unlock",  /* 0x4 */
5281                 "buf stale",    /* 0x8 */
5282                 0
5283                 };
5284
5285         kdb_printf("tp 0x%p type ", tp);
5286         switch (tp->t_type) {
5287         case XFS_TRANS_SETATTR_NOT_SIZE: kdb_printf("SETATTR_NOT_SIZE");        break;
5288         case XFS_TRANS_SETATTR_SIZE:    kdb_printf("SETATTR_SIZE");     break;
5289         case XFS_TRANS_INACTIVE:        kdb_printf("INACTIVE");         break;
5290         case XFS_TRANS_CREATE:          kdb_printf("CREATE");           break;
5291         case XFS_TRANS_CREATE_TRUNC:    kdb_printf("CREATE_TRUNC");     break;
5292         case XFS_TRANS_TRUNCATE_FILE:   kdb_printf("TRUNCATE_FILE");    break;
5293         case XFS_TRANS_REMOVE:          kdb_printf("REMOVE");           break;
5294         case XFS_TRANS_LINK:            kdb_printf("LINK");             break;
5295         case XFS_TRANS_RENAME:          kdb_printf("RENAME");           break;
5296         case XFS_TRANS_MKDIR:           kdb_printf("MKDIR");            break;
5297         case XFS_TRANS_RMDIR:           kdb_printf("RMDIR");            break;
5298         case XFS_TRANS_SYMLINK:         kdb_printf("SYMLINK");          break;
5299         case XFS_TRANS_SET_DMATTRS:     kdb_printf("SET_DMATTRS");              break;
5300         case XFS_TRANS_GROWFS:          kdb_printf("GROWFS");           break;
5301         case XFS_TRANS_STRAT_WRITE:     kdb_printf("STRAT_WRITE");              break;
5302         case XFS_TRANS_DIOSTRAT:        kdb_printf("DIOSTRAT");         break;
5303         case XFS_TRANS_WRITE_SYNC:      kdb_printf("WRITE_SYNC");               break;
5304         case XFS_TRANS_WRITEID:         kdb_printf("WRITEID");          break;
5305         case XFS_TRANS_ADDAFORK:        kdb_printf("ADDAFORK");         break;
5306         case XFS_TRANS_ATTRINVAL:       kdb_printf("ATTRINVAL");                break;
5307         case XFS_TRANS_ATRUNCATE:       kdb_printf("ATRUNCATE");                break;
5308         case XFS_TRANS_ATTR_SET:        kdb_printf("ATTR_SET");         break;
5309         case XFS_TRANS_ATTR_RM:         kdb_printf("ATTR_RM");          break;
5310         case XFS_TRANS_ATTR_FLAG:       kdb_printf("ATTR_FLAG");                break;
5311         case XFS_TRANS_CLEAR_AGI_BUCKET:  kdb_printf("CLEAR_AGI_BUCKET");       break;
5312         case XFS_TRANS_QM_SBCHANGE:     kdb_printf("QM_SBCHANGE");      break;
5313         case XFS_TRANS_QM_QUOTAOFF:     kdb_printf("QM_QUOTAOFF");      break;
5314         case XFS_TRANS_QM_DQALLOC:      kdb_printf("QM_DQALLOC");               break;
5315         case XFS_TRANS_QM_SETQLIM:      kdb_printf("QM_SETQLIM");               break;
5316         case XFS_TRANS_QM_DQCLUSTER:    kdb_printf("QM_DQCLUSTER");     break;
5317         case XFS_TRANS_QM_QINOCREATE:   kdb_printf("QM_QINOCREATE");    break;
5318         case XFS_TRANS_QM_QUOTAOFF_END: kdb_printf("QM_QOFF_END");              break;
5319         case XFS_TRANS_SB_UNIT:         kdb_printf("SB_UNIT");          break;
5320         case XFS_TRANS_FSYNC_TS:        kdb_printf("FSYNC_TS");         break;
5321         case XFS_TRANS_GROWFSRT_ALLOC:  kdb_printf("GROWFSRT_ALLOC");   break;
5322         case XFS_TRANS_GROWFSRT_ZERO:   kdb_printf("GROWFSRT_ZERO");    break;
5323         case XFS_TRANS_GROWFSRT_FREE:   kdb_printf("GROWFSRT_FREE");    break;
5324
5325         default:                        kdb_printf("0x%x", tp->t_type); break;
5326         }
5327         kdb_printf(" mount 0x%p\n", tp->t_mountp);
5328         kdb_printf("flags ");
5329         printflags(tp->t_flags, xtp_flags,"xtp");
5330         kdb_printf("\n");
5331         kdb_printf("callback 0x%p forw 0x%p back 0x%p\n",
5332                 &tp->t_logcb, tp->t_forw, tp->t_back);
5333         kdb_printf("log res %d block res %d block res used %d\n",
5334                 tp->t_log_res, tp->t_blk_res, tp->t_blk_res_used);
5335         kdb_printf("rt res %d rt res used %d\n", tp->t_rtx_res,
5336                 tp->t_rtx_res_used);
5337         kdb_printf("ticket 0x%lx lsn %s commit_lsn %s\n",
5338                 (unsigned long) tp->t_ticket,
5339                 xfs_fmtlsn(&tp->t_lsn),
5340                 xfs_fmtlsn(&tp->t_commit_lsn));
5341         kdb_printf("callback 0x%p callarg 0x%p\n",
5342                 tp->t_callback, tp->t_callarg);
5343         kdb_printf("icount delta %ld ifree delta %ld\n",
5344                 tp->t_icount_delta, tp->t_ifree_delta);
5345         kdb_printf("blocks delta %ld res blocks delta %ld\n",
5346                 tp->t_fdblocks_delta, tp->t_res_fdblocks_delta);
5347         kdb_printf("rt delta %ld res rt delta %ld\n",
5348                 tp->t_frextents_delta, tp->t_res_frextents_delta);
5349         kdb_printf("ag freeblks delta %ld ag flist delta %ld ag btree delta %ld\n",
5350                 tp->t_ag_freeblks_delta, tp->t_ag_flist_delta,
5351                 tp->t_ag_btree_delta);
5352         kdb_printf("dblocks delta %ld agcount delta %ld imaxpct delta %ld\n",
5353                 tp->t_dblocks_delta, tp->t_agcount_delta, tp->t_imaxpct_delta);
5354         kdb_printf("rextsize delta %ld rbmblocks delta %ld\n",
5355                 tp->t_rextsize_delta, tp->t_rbmblocks_delta);
5356         kdb_printf("rblocks delta %ld rextents delta %ld rextslog delta %ld\n",
5357                 tp->t_rblocks_delta, tp->t_rextents_delta,
5358                 tp->t_rextslog_delta);
5359         kdb_printf("dqinfo 0x%p\n", tp->t_dqinfo);
5360         kdb_printf("log items:\n");
5361         licp = &tp->t_items;
5362         chunk = 0;
5363         while (licp != NULL) {
5364                 if (XFS_LIC_ARE_ALL_FREE(licp)) {
5365                         licp = licp->lic_next;
5366                         chunk++;
5367                         continue;
5368                 }
5369                 for (i = 0; i < licp->lic_unused; i++) {
5370                         if (XFS_LIC_ISFREE(licp, i)) {
5371                                 continue;
5372                         }
5373
5374                         lidp = XFS_LIC_SLOT(licp, i);
5375                         kdb_printf("\n");
5376                         kdb_printf("chunk %d index %d item 0x%p size %d\n",
5377                                 chunk, i, lidp->lid_item, lidp->lid_size);
5378                         kdb_printf("flags ");
5379                         printflags(lidp->lid_flags, lid_flags,"lic");
5380                         kdb_printf("\n");
5381                         xfsidbg_xlogitem(lidp->lid_item);
5382                 }
5383                 chunk++;
5384                 licp = licp->lic_next;
5385         }
5386
5387         kdb_printf("log busy free %d, list:\n", tp->t_busy_free);
5388         lbcp = &tp->t_busy;
5389         chunk = 0;
5390         while (lbcp != NULL) {
5391                 kdb_printf("Chunk %d at 0x%p next 0x%p free 0x%08x unused %d\n",
5392                         chunk, lbcp, lbcp->lbc_next, lbcp->lbc_free,
5393                         lbcp->lbc_unused);
5394                 for (i = 0; i < XFS_LBC_NUM_SLOTS; i++) {
5395                         kdb_printf("  %02d: ag %d idx %d\n",
5396                                 i,
5397                                 lbcp->lbc_busy[i].lbc_ag,
5398                                 lbcp->lbc_busy[i].lbc_idx);
5399                 }
5400                 lbcp = lbcp->lbc_next;
5401         }
5402 }
5403
5404 static void
5405 xfsidbg_xtrans_res(
5406         xfs_mount_t     *mp)
5407 {
5408         xfs_trans_reservations_t        *xtrp;
5409
5410         xtrp = &mp->m_reservations;
5411         kdb_printf("write: %d\ttruncate: %d\trename: %d\n",
5412                 xtrp->tr_write, xtrp->tr_itruncate, xtrp->tr_rename);
5413         kdb_printf("link: %d\tremove: %d\tsymlink: %d\n",
5414                 xtrp->tr_link, xtrp->tr_remove, xtrp->tr_symlink);
5415         kdb_printf("create: %d\tmkdir: %d\tifree: %d\n",
5416                 xtrp->tr_create, xtrp->tr_mkdir, xtrp->tr_ifree);
5417         kdb_printf("ichange: %d\tgrowdata: %d\tswrite: %d\n",
5418                 xtrp->tr_ichange, xtrp->tr_growdata, xtrp->tr_swrite);
5419         kdb_printf("addafork: %d\twriteid: %d\tattrinval: %d\n",
5420                 xtrp->tr_addafork, xtrp->tr_writeid, xtrp->tr_attrinval);
5421         kdb_printf("attrset: %d\tattrrm: %d\tclearagi: %d\n",
5422                 xtrp->tr_attrset, xtrp->tr_attrrm, xtrp->tr_clearagi);
5423         kdb_printf("growrtalloc: %d\tgrowrtzero: %d\tgrowrtfree: %d\n",
5424                 xtrp->tr_growrtalloc, xtrp->tr_growrtzero, xtrp->tr_growrtfree);
5425 }
5426
5427 module_init(xfsidbg_init)
5428 module_exit(xfsidbg_exit)