2 * Copyright (c) 2000-2005 Silicon Graphics, Inc.
5 * This program is free software; you can redistribute it and/or
6 * modify it under the terms of the GNU General Public License as
7 * published by the Free Software Foundation.
9 * This program is distributed in the hope that it would be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 * GNU General Public License for more details.
14 * You should have received a copy of the GNU General Public License
15 * along with this program; if not, write the Free Software Foundation,
16 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
21 #include "xfs_types.h"
25 #include "xfs_trans.h"
30 #include "xfs_dmapi.h"
31 #include "xfs_mount.h"
32 #include "xfs_alloc.h"
33 #include "xfs_da_btree.h"
34 #include "xfs_alloc_btree.h"
35 #include "xfs_bmap_btree.h"
36 #include "xfs_ialloc_btree.h"
37 #include "xfs_dir_sf.h"
38 #include "xfs_dir2_sf.h"
39 #include "xfs_attr_sf.h"
40 #include "xfs_dinode.h"
41 #include "xfs_inode.h"
42 #include "xfs_btree.h"
43 #include "xfs_buf_item.h"
44 #include "xfs_inode_item.h"
45 #include "xfs_extfree_item.h"
49 #include "xfs_attr_leaf.h"
50 #include "xfs_dir_leaf.h"
51 #include "xfs_dir2_data.h"
52 #include "xfs_dir2_leaf.h"
53 #include "xfs_dir2_block.h"
54 #include "xfs_dir2_node.h"
55 #include "xfs_dir2_trace.h"
56 #include "xfs_log_priv.h"
57 #include "xfs_log_recover.h"
58 #include "xfs_quota.h"
59 #include "quota/xfs_qm.h"
60 #include "xfs_iomap.h"
62 #include <support/kdb.h>
64 #define qprintf kdb_printf
67 * Command table functions. (tracing)
69 #ifdef XFS_ALLOC_TRACE
70 static void xfsidbg_xalatrace(int);
71 static void xfsidbg_xalbtrace(xfs_agblock_t);
72 static void xfsidbg_xalgtrace(xfs_agnumber_t);
73 static void xfsidbg_xalmtrace(xfs_mount_t *);
74 static void xfsidbg_xalttrace(int);
77 static void xfsidbg_xattrtrace(int);
80 static void xfsidbg_xblitrace(xfs_buf_log_item_t *);
83 static void xfsidbg_xbmatrace(int);
84 static void xfsidbg_xbmitrace(xfs_inode_t *);
85 static void xfsidbg_xbmstrace(xfs_inode_t *);
86 static void xfsidbg_xbxatrace(int);
87 static void xfsidbg_xbxitrace(xfs_inode_t *);
88 static void xfsidbg_xbxstrace(xfs_inode_t *);
90 #ifdef XFS_ILOCK_TRACE
91 static void xfsidbg_xilock_trace(xfs_inode_t *);
92 static void xfsidbg_xailock_trace(int);
95 static void xfsidbg_xdirtrace(int);
98 static void xfsidbg_xdir2atrace(int);
99 static void xfsidbg_xdir2itrace(xfs_inode_t *);
102 static void xfsidbg_xiclogtrace(xlog_in_core_t *);
103 static void xfsidbg_xlog_granttrace(xlog_t *);
105 #ifdef XFS_DQUOT_TRACE
106 static void xfsidbg_xqm_dqtrace(xfs_dquot_t *);
111 * Command table functions.
113 static void xfsidbg_xagf(xfs_agf_t *);
114 static void xfsidbg_xagi(xfs_agi_t *);
115 static void xfsidbg_xaildump(xfs_mount_t *);
116 static void xfsidbg_xalloc(xfs_alloc_arg_t *);
117 static void xfsidbg_xattrcontext(xfs_attr_list_context_t *);
118 static void xfsidbg_xattrleaf(xfs_attr_leafblock_t *);
119 static void xfsidbg_xattrsf(xfs_attr_shortform_t *);
120 static void xfsidbg_xbirec(xfs_bmbt_irec_t *r);
121 static void xfsidbg_xbmalla(xfs_bmalloca_t *);
122 static void xfsidbg_xbrec(xfs_bmbt_rec_64_t *);
123 static void xfsidbg_xbroot(xfs_inode_t *);
124 static void xfsidbg_xbroota(xfs_inode_t *);
125 static void xfsidbg_xbtcur(xfs_btree_cur_t *);
126 static void xfsidbg_xbuf(xfs_buf_t *);
127 static void xfsidbg_xbuf_real(xfs_buf_t *, int);
128 static void xfsidbg_xarg(int);
129 static void xfsidbg_xchksum(uint *);
130 static void xfsidbg_xchash(xfs_mount_t *mp);
131 static void xfsidbg_xchashlist(xfs_chashlist_t *chl);
132 static void xfsidbg_xdaargs(xfs_da_args_t *);
133 static void xfsidbg_xdabuf(xfs_dabuf_t *);
134 static void xfsidbg_xdanode(xfs_da_intnode_t *);
135 static void xfsidbg_xdastate(xfs_da_state_t *);
136 static void xfsidbg_xdirleaf(xfs_dir_leafblock_t *);
137 static void xfsidbg_xdirsf(xfs_dir_shortform_t *);
138 static void xfsidbg_xdir2free(xfs_dir2_free_t *);
139 static void xfsidbg_xdir2sf(xfs_dir2_sf_t *);
140 static void xfsidbg_xexlist(xfs_inode_t *);
141 static void xfsidbg_xflist(xfs_bmap_free_t *);
142 static void xfsidbg_xhelp(void);
143 static void xfsidbg_xiclog(xlog_in_core_t *);
144 static void xfsidbg_xiclogall(xlog_in_core_t *);
145 static void xfsidbg_xiclogcb(xlog_in_core_t *);
146 static void xfsidbg_xihash(xfs_mount_t *mp);
147 static void xfsidbg_xinodes(xfs_mount_t *);
148 static void xfsidbg_delayed_blocks(xfs_mount_t *);
149 static void xfsidbg_xinodes_quiesce(xfs_mount_t *);
150 static void xfsidbg_xlog(xlog_t *);
151 static void xfsidbg_xlog_ritem(xlog_recover_item_t *);
152 static void xfsidbg_xlog_rtrans(xlog_recover_t *);
153 static void xfsidbg_xlog_rtrans_entire(xlog_recover_t *);
154 static void xfsidbg_xlog_tic(xlog_ticket_t *);
155 static void xfsidbg_xlogitem(xfs_log_item_t *);
156 static void xfsidbg_xmount(xfs_mount_t *);
157 static void xfsidbg_xnode(xfs_inode_t *ip);
158 static void xfsidbg_xcore(xfs_iocore_t *io);
159 static void xfsidbg_xperag(xfs_mount_t *);
160 static void xfsidbg_xqm_diskdq(xfs_disk_dquot_t *);
161 static void xfsidbg_xqm_dqattached_inos(xfs_mount_t *);
162 static void xfsidbg_xqm_dquot(xfs_dquot_t *);
163 static void xfsidbg_xqm_mplist(xfs_mount_t *);
164 static void xfsidbg_xqm_qinfo(xfs_mount_t *mp);
165 static void xfsidbg_xqm_tpdqinfo(xfs_trans_t *tp);
166 static void xfsidbg_xsb(xfs_sb_t *);
167 static void xfsidbg_xsb_convert(xfs_sb_t *);
168 static void xfsidbg_xtp(xfs_trans_t *);
169 static void xfsidbg_xtrans_res(xfs_mount_t *);
170 #ifdef CONFIG_XFS_QUOTA
171 static void xfsidbg_xqm(void);
172 static void xfsidbg_xqm_htab(void);
173 static void xfsidbg_xqm_freelist_print(xfs_frlist_t *qlist, char *title);
174 static void xfsidbg_xqm_freelist(void);
177 #ifdef XFS_BMAP_TRACE
178 static void xfs_convert_extent(xfs_bmbt_rec_32_t *, xfs_dfiloff_t *,
179 xfs_dfsbno_t *, xfs_dfilblks_t *, int *);
183 * Prototypes for static functions.
185 #ifdef XFS_ALLOC_TRACE
186 static int xfs_alloc_trace_entry(ktrace_entry_t *ktep);
188 #ifdef XFS_ATTR_TRACE
189 static int xfs_attr_trace_entry(ktrace_entry_t *ktep);
191 #ifdef XFS_BMAP_TRACE
192 static int xfs_bmap_trace_entry(ktrace_entry_t *ktep);
194 #ifdef XFS_BMAP_TRACE
195 static int xfs_bmbt_trace_entry(ktrace_entry_t *ktep);
198 static int xfs_dir_trace_entry(ktrace_entry_t *ktep);
200 #ifdef XFS_DIR2_TRACE
201 static int xfs_dir2_trace_entry(ktrace_entry_t *ktep);
204 static void xfs_bunmap_trace_entry(ktrace_entry_t *ktep);
205 static void xfs_rw_enter_trace_entry(ktrace_entry_t *ktep);
206 static void xfs_page_trace_entry(ktrace_entry_t *ktep);
207 static int xfs_rw_trace_entry(ktrace_entry_t *ktep);
209 static void xfs_broot(xfs_inode_t *ip, xfs_ifork_t *f);
210 static void xfs_btalloc(xfs_alloc_block_t *bt, int bsz);
211 static void xfs_btbmap(xfs_bmbt_block_t *bt, int bsz);
212 static void xfs_btino(xfs_inobt_block_t *bt, int bsz);
213 static void xfs_buf_item_print(xfs_buf_log_item_t *blip, int summary);
214 static void xfs_dastate_path(xfs_da_state_path_t *p);
215 static void xfs_dir2data(void *addr, int size);
216 static void xfs_dir2leaf(xfs_dir2_leaf_t *leaf, int size);
217 static void xfs_dquot_item_print(xfs_dq_logitem_t *lip, int summary);
218 static void xfs_efd_item_print(xfs_efd_log_item_t *efdp, int summary);
219 static void xfs_efi_item_print(xfs_efi_log_item_t *efip, int summary);
220 static char * xfs_fmtformat(xfs_dinode_fmt_t f);
221 char * xfs_fmtfsblock(xfs_fsblock_t bno, xfs_mount_t *mp);
222 static char * xfs_fmtino(xfs_ino_t ino, xfs_mount_t *mp);
223 static char * xfs_fmtlsn(xfs_lsn_t *lsnp);
224 static char * xfs_fmtmode(int m);
225 static char * xfs_fmtsize(size_t i);
226 static char * xfs_fmtuuid(uuid_t *);
227 static void xfs_inode_item_print(xfs_inode_log_item_t *ilip, int summary);
228 static void xfs_inodebuf(xfs_buf_t *bp);
229 static void xfs_prdinode_core(xfs_dinode_core_t *dip);
230 static void xfs_qoff_item_print(xfs_qoff_logitem_t *lip, int summary);
231 static void xfs_xexlist_fork(xfs_inode_t *ip, int whichfork);
232 static void xfs_xnode_fork(char *name, xfs_ifork_t *f);
237 static int kdbm_xfs_xagf(
241 struct pt_regs *regs)
250 diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL, regs);
254 xfsidbg_xagf((xfs_agf_t *)addr);
258 static int kdbm_xfs_xagi(
262 struct pt_regs *regs)
271 diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL, regs);
275 xfsidbg_xagi((xfs_agi_t *)addr);
279 static int kdbm_xfs_xaildump(
283 struct pt_regs *regs)
292 diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL, regs);
296 xfsidbg_xaildump((xfs_mount_t *) addr);
300 #ifdef XFS_ALLOC_TRACE
301 static int kdbm_xfs_xalatrace(
305 struct pt_regs *regs)
315 diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL, regs);
319 xfsidbg_xalatrace((int) addr);
323 static int kdbm_xfs_xalbtrace(
327 struct pt_regs *regs)
337 diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL, regs);
341 xfsidbg_xalbtrace((xfs_agblock_t) addr);
345 static int kdbm_xfs_xalgtrace(
349 struct pt_regs *regs)
359 diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL, regs);
363 xfsidbg_xalgtrace((xfs_agnumber_t) addr);
368 #ifdef XFS_ATTR_TRACE
369 static int kdbm_xfs_xattrtrace(
373 struct pt_regs *regs)
383 diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL, regs);
387 xfsidbg_xattrtrace((int) addr);
393 static int kdbm_xfs_xblitrace(
397 struct pt_regs *regs)
407 diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL, regs);
411 xfsidbg_xblitrace((xfs_buf_log_item_t *) addr);
416 #ifdef XFS_BMAP_TRACE
417 static int kdbm_xfs_xbmatrace(
421 struct pt_regs *regs)
431 diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL, regs);
435 xfsidbg_xbmatrace((int) addr);
439 static int kdbm_xfs_xbmitrace(
443 struct pt_regs *regs)
453 diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL, regs);
457 xfsidbg_xbmitrace((xfs_inode_t *) addr);
461 static int kdbm_xfs_xbmstrace(
465 struct pt_regs *regs)
475 diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL, regs);
479 xfsidbg_xbmstrace((xfs_inode_t *) addr);
483 static int kdbm_xfs_xbxatrace(
487 struct pt_regs *regs)
497 diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL, regs);
501 xfsidbg_xbxatrace((int) addr);
505 static int kdbm_xfs_xbxitrace(
509 struct pt_regs *regs)
519 diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL, regs);
523 xfsidbg_xbxitrace((xfs_inode_t *) addr);
527 static int kdbm_xfs_xbxstrace(
531 struct pt_regs *regs)
541 diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL, regs);
545 xfsidbg_xbxstrace((xfs_inode_t *) addr);
550 #ifdef XFS_DIR2_TRACE
551 static int kdbm_xfs_xdir2atrace(
555 struct pt_regs *regs)
565 diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL, regs);
569 xfsidbg_xdir2atrace((int) addr);
573 static int kdbm_xfs_xdir2itrace(
577 struct pt_regs *regs)
587 diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL, regs);
591 xfsidbg_xdir2itrace((xfs_inode_t *) addr);
597 static int kdbm_xfs_xdirtrace(
601 struct pt_regs *regs)
611 diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL, regs);
615 xfsidbg_xdirtrace((int) addr);
621 static int kdbm_xfs_xiclogtrace(
625 struct pt_regs *regs)
635 diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL, regs);
639 xfsidbg_xiclogtrace((xlog_in_core_t *) addr);
644 #ifdef XFS_ILOCK_TRACE
645 static int kdbm_xfs_xilock_trace(
649 struct pt_regs *regs)
659 diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL, regs);
663 xfsidbg_xilock_trace((xfs_inode_t *) addr);
667 static int kdbm_xfs_xailock_trace(
671 struct pt_regs *regs)
681 diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL, regs);
685 xfsidbg_xailock_trace((int) addr);
691 static int kdbm_xfs_xlog_granttrace(
695 struct pt_regs *regs)
705 diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL, regs);
709 xfsidbg_xlog_granttrace((xlog_t *) addr);
714 #ifdef XFS_DQUOT_TRACE
715 static int kdbm_xfs_xqm_dqtrace(
719 struct pt_regs *regs)
729 diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL, regs);
733 xfsidbg_xqm_dqtrace((xfs_dquot_t *) addr);
739 static int kdbm_xfs_xrwtrace(
743 struct pt_regs *regs)
749 ktrace_entry_t *ktep;
756 diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL, regs);
760 ip = (xfs_inode_t *) addr;
761 if (ip->i_rwtrace == NULL) {
762 qprintf("The inode trace buffer is not initialized\n");
765 qprintf("i_rwtrace = 0x%p\n", ip->i_rwtrace);
766 ktep = ktrace_first(ip->i_rwtrace, &kts);
767 while (ktep != NULL) {
768 if (xfs_rw_trace_entry(ktep))
770 ktep = ktrace_next(ip->i_rwtrace, &kts);
776 static int kdbm_xfs_xalloc(
780 struct pt_regs *regs)
789 diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL, regs);
793 xfsidbg_xalloc((xfs_alloc_arg_t *) addr);
797 #ifdef XFS_ALLOC_TRACE
798 static int kdbm_xfs_xalmtrace(
802 struct pt_regs *regs)
811 diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL, regs);
815 xfsidbg_xalmtrace((xfs_mount_t *) addr);
819 static int kdbm_xfs_xalttrace(
823 struct pt_regs *regs)
832 diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL, regs);
836 xfsidbg_xalttrace((int) addr);
839 #endif /* XFS_ALLOC_TRACE */
841 static int kdbm_xfs_xattrcontext(
845 struct pt_regs *regs)
854 diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL, regs);
858 xfsidbg_xattrcontext((xfs_attr_list_context_t *) addr);
862 static int kdbm_xfs_xattrleaf(
866 struct pt_regs *regs)
875 diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL, regs);
879 xfsidbg_xattrleaf((xfs_attr_leafblock_t *) addr);
883 static int kdbm_xfs_xattrsf(
887 struct pt_regs *regs)
896 diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL, regs);
900 xfsidbg_xattrsf((xfs_attr_shortform_t *) addr);
904 static int kdbm_xfs_xbirec(
908 struct pt_regs *regs)
917 diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL, regs);
921 xfsidbg_xbirec((xfs_bmbt_irec_t *) addr);
925 static int kdbm_xfs_xbmalla(
929 struct pt_regs *regs)
938 diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL, regs);
942 xfsidbg_xbmalla((xfs_bmalloca_t *)addr);
946 static int kdbm_xfs_xbrec(
950 struct pt_regs *regs)
959 diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL, regs);
963 xfsidbg_xbrec((xfs_bmbt_rec_64_t *) addr);
967 static int kdbm_xfs_xbroot(
971 struct pt_regs *regs)
980 diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL, regs);
984 xfsidbg_xbroot((xfs_inode_t *) addr);
988 static int kdbm_xfs_xbroota(
992 struct pt_regs *regs)
1000 return KDB_ARGCOUNT;
1001 diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL, regs);
1005 xfsidbg_xbroota((xfs_inode_t *) addr);
1009 static int kdbm_xfs_xbtcur(
1013 struct pt_regs *regs)
1021 return KDB_ARGCOUNT;
1022 diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL, regs);
1026 xfsidbg_xbtcur((xfs_btree_cur_t *) addr);
1030 static int kdbm_xfs_xbuf(
1034 struct pt_regs *regs)
1042 return KDB_ARGCOUNT;
1043 diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL, regs);
1047 xfsidbg_xbuf((xfs_buf_t *) addr);
1052 static int kdbm_xfs_xarg(
1056 struct pt_regs *regs)
1064 return KDB_ARGCOUNT;
1065 diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL, regs);
1069 xfsidbg_xarg((int) addr);
1073 static int kdbm_xfs_xchksum(
1077 struct pt_regs *regs)
1085 return KDB_ARGCOUNT;
1086 diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL, regs);
1090 xfsidbg_xchksum((uint *) addr);
1095 static int kdbm_xfs_xchash(
1099 struct pt_regs *regs)
1107 return KDB_ARGCOUNT;
1108 diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL, regs);
1112 xfsidbg_xchash((xfs_mount_t *) addr);
1116 static int kdbm_xfs_xchashlist(
1120 struct pt_regs *regs)
1128 return KDB_ARGCOUNT;
1129 diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL, regs);
1133 xfsidbg_xchashlist((xfs_chashlist_t *) addr);
1138 static int kdbm_xfs_xdaargs(
1142 struct pt_regs *regs)
1150 return KDB_ARGCOUNT;
1151 diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL, regs);
1155 xfsidbg_xdaargs((xfs_da_args_t *) addr);
1159 static int kdbm_xfs_xdabuf(
1163 struct pt_regs *regs)
1171 return KDB_ARGCOUNT;
1172 diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL, regs);
1176 xfsidbg_xdabuf((xfs_dabuf_t *) addr);
1180 static int kdbm_xfs_xdanode(
1184 struct pt_regs *regs)
1192 return KDB_ARGCOUNT;
1193 diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL, regs);
1197 xfsidbg_xdanode((xfs_da_intnode_t *) addr);
1201 static int kdbm_xfs_xdastate(
1205 struct pt_regs *regs)
1213 return KDB_ARGCOUNT;
1214 diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL, regs);
1218 xfsidbg_xdastate((xfs_da_state_t *) addr);
1222 static int kdbm_xfs_xdirleaf(
1226 struct pt_regs *regs)
1234 return KDB_ARGCOUNT;
1235 diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL, regs);
1239 xfsidbg_xdirleaf((xfs_dir_leafblock_t *) addr);
1243 static int kdbm_xfs_xdirsf(
1247 struct pt_regs *regs)
1255 return KDB_ARGCOUNT;
1256 diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL, regs);
1260 xfsidbg_xdirsf((xfs_dir_shortform_t *) addr);
1264 static int kdbm_xfs_xdir2free(
1268 struct pt_regs *regs)
1276 return KDB_ARGCOUNT;
1277 diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL, regs);
1281 xfsidbg_xdir2free((xfs_dir2_free_t *) addr);
1285 static int kdbm_xfs_xdir2sf(
1289 struct pt_regs *regs)
1297 return KDB_ARGCOUNT;
1298 diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL, regs);
1302 xfsidbg_xdir2sf((xfs_dir2_sf_t *) addr);
1306 static int kdbm_xfs_xexlist(
1310 struct pt_regs *regs)
1318 return KDB_ARGCOUNT;
1319 diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL, regs);
1323 xfsidbg_xexlist((xfs_inode_t *) addr);
1327 static int kdbm_xfs_xflist(
1331 struct pt_regs *regs)
1339 return KDB_ARGCOUNT;
1340 diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL, regs);
1344 xfsidbg_xflist((xfs_bmap_free_t *) addr);
1348 static int kdbm_xfs_xhelp(
1352 struct pt_regs *regs)
1355 return KDB_ARGCOUNT;
1361 static int kdbm_xfs_xiclog(
1365 struct pt_regs *regs)
1373 return KDB_ARGCOUNT;
1374 diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL, regs);
1378 xfsidbg_xiclog((xlog_in_core_t *) addr);
1382 static int kdbm_xfs_xiclogall(
1386 struct pt_regs *regs)
1394 return KDB_ARGCOUNT;
1395 diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL, regs);
1399 xfsidbg_xiclogall((xlog_in_core_t *) addr);
1403 static int kdbm_xfs_xiclogcb(
1407 struct pt_regs *regs)
1415 return KDB_ARGCOUNT;
1416 diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL, regs);
1420 xfsidbg_xiclogcb((xlog_in_core_t *) addr);
1424 static int kdbm_xfs_xihash(
1428 struct pt_regs *regs)
1436 return KDB_ARGCOUNT;
1437 diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL, regs);
1441 xfsidbg_xihash((xfs_mount_t *) addr);
1445 static int kdbm_xfs_xinodes(
1449 struct pt_regs *regs)
1457 return KDB_ARGCOUNT;
1458 diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL, regs);
1462 xfsidbg_xinodes((xfs_mount_t *) addr);
1466 static int kdbm_xfs_delayed_blocks(
1470 struct pt_regs *regs)
1478 return KDB_ARGCOUNT;
1479 diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL, regs);
1483 xfsidbg_delayed_blocks((xfs_mount_t *) addr);
1488 static int kdbm_xfs_xinodes_quiesce(
1492 struct pt_regs *regs)
1500 return KDB_ARGCOUNT;
1501 diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL, regs);
1505 xfsidbg_xinodes_quiesce((xfs_mount_t *) addr);
1509 static int kdbm_xfs_xlog(
1513 struct pt_regs *regs)
1521 return KDB_ARGCOUNT;
1522 diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL, regs);
1526 xfsidbg_xlog((xlog_t *) addr);
1530 static int kdbm_xfs_xlog_ritem(
1534 struct pt_regs *regs)
1542 return KDB_ARGCOUNT;
1543 diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL, regs);
1547 xfsidbg_xlog_ritem((xlog_recover_item_t *) addr);
1551 static int kdbm_xfs_xlog_rtrans(
1555 struct pt_regs *regs)
1563 return KDB_ARGCOUNT;
1564 diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL, regs);
1568 xfsidbg_xlog_rtrans((xlog_recover_t *) addr);
1572 static int kdbm_xfs_xlog_rtrans_entire(
1576 struct pt_regs *regs)
1584 return KDB_ARGCOUNT;
1585 diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL, regs);
1589 xfsidbg_xlog_rtrans_entire((xlog_recover_t *) addr);
1593 static int kdbm_xfs_xlog_tic(
1597 struct pt_regs *regs)
1605 return KDB_ARGCOUNT;
1606 diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL, regs);
1610 xfsidbg_xlog_tic((xlog_ticket_t *) addr);
1614 static int kdbm_xfs_xlogitem(
1618 struct pt_regs *regs)
1626 return KDB_ARGCOUNT;
1627 diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL, regs);
1631 xfsidbg_xlogitem((xfs_log_item_t *) addr);
1635 static int kdbm_xfs_xmount(
1639 struct pt_regs *regs)
1647 return KDB_ARGCOUNT;
1648 diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL, regs);
1652 xfsidbg_xmount((xfs_mount_t *) addr);
1656 static int kdbm_xfs_xnode(
1660 struct pt_regs *regs)
1668 return KDB_ARGCOUNT;
1669 diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL, regs);
1673 xfsidbg_xnode((xfs_inode_t *) addr);
1677 static int kdbm_xfs_xcore(
1681 struct pt_regs *regs)
1689 return KDB_ARGCOUNT;
1690 diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL, regs);
1694 xfsidbg_xcore((xfs_iocore_t *) addr);
1698 static int kdbm_xfs_xperag(
1702 struct pt_regs *regs)
1710 return KDB_ARGCOUNT;
1711 diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL, regs);
1715 xfsidbg_xperag((xfs_mount_t *) addr);
1719 static int kdbm_xfs_xqm_diskdq(
1723 struct pt_regs *regs)
1731 return KDB_ARGCOUNT;
1732 diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL, regs);
1736 xfsidbg_xqm_diskdq((xfs_disk_dquot_t *) addr);
1740 static int kdbm_xfs_xqm_dqattached_inos(
1744 struct pt_regs *regs)
1752 return KDB_ARGCOUNT;
1753 diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL, regs);
1757 xfsidbg_xqm_dqattached_inos((xfs_mount_t *) addr);
1761 static int kdbm_xfs_xqm_dquot(
1765 struct pt_regs *regs)
1773 return KDB_ARGCOUNT;
1774 diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL, regs);
1778 xfsidbg_xqm_dquot((xfs_dquot_t *) addr);
1782 #ifdef CONFIG_XFS_QUOTA
1783 static int kdbm_xfs_xqm(
1787 struct pt_regs *regs)
1790 return KDB_ARGCOUNT;
1796 static int kdbm_xfs_xqm_freelist(
1800 struct pt_regs *regs)
1803 return KDB_ARGCOUNT;
1805 xfsidbg_xqm_freelist();
1809 static int kdbm_xfs_xqm_htab(
1813 struct pt_regs *regs)
1816 return KDB_ARGCOUNT;
1823 static int kdbm_xfs_xqm_mplist(
1827 struct pt_regs *regs)
1835 return KDB_ARGCOUNT;
1836 diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL, regs);
1840 xfsidbg_xqm_mplist((xfs_mount_t *) addr);
1844 static int kdbm_xfs_xqm_qinfo(
1848 struct pt_regs *regs)
1856 return KDB_ARGCOUNT;
1857 diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL, regs);
1861 xfsidbg_xqm_qinfo((xfs_mount_t *) addr);
1865 static int kdbm_xfs_xqm_tpdqinfo(
1869 struct pt_regs *regs)
1877 return KDB_ARGCOUNT;
1878 diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL, regs);
1882 xfsidbg_xqm_tpdqinfo((xfs_trans_t *) addr);
1886 static int kdbm_xfs_xsb(
1890 struct pt_regs *regs)
1893 unsigned long convert=0;
1898 if (argc != 1 && argc!=2)
1899 return KDB_ARGCOUNT;
1900 diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL, regs);
1904 /* extra argument - conversion flag */
1905 diag = kdbgetaddrarg(argc, argv, &nextarg, &convert, &offset, NULL, regs);
1911 xfsidbg_xsb_convert((xfs_sb_t *) addr);
1913 xfsidbg_xsb((xfs_sb_t *) addr);
1917 static int kdbm_xfs_xtp(
1921 struct pt_regs *regs)
1929 return KDB_ARGCOUNT;
1930 diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL, regs);
1934 xfsidbg_xtp((xfs_trans_t *) addr);
1938 static int kdbm_xfs_xtrans_res(
1942 struct pt_regs *regs)
1950 return KDB_ARGCOUNT;
1951 diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL, regs);
1955 xfsidbg_xtrans_res((xfs_mount_t *) addr);
1960 * Vnode descriptor dump.
1961 * This table is a string version of all the flags defined in vnode.h.
1963 char *tab_vflags[] = {
1964 /* local only flags */
1965 "VINACT", /* 0x01 */
1966 "VRECLM", /* 0x02 */
1968 "VMODIFIED", /* 0x08 */
1969 "INVALID0x10", /* 0x10 */
1970 "INVALID0x20", /* 0x20 */
1971 "INVALID0x40", /* 0x40 */
1972 "INVALID0x80", /* 0x80 */
1973 "INVALID0x100", /* 0x100 */
1974 "INVALID0x200", /* 0x200 */
1975 "INVALID0x400", /* 0x400 */
1976 "INVALID0x800", /* 0x800 */
1977 "INVALID0x1000", /* 0x1000 */
1978 "INVALID0x2000", /* 0x2000 */
1979 "INVALID0x4000", /* 0x4000 */
1980 "INVALID0x8000", /* 0x8000 */
1981 "INVALID0x10000", /* 0x10000 */
1982 "INVALID0x20000", /* 0x20000 */
1983 "INVALID0x40000", /* 0x40000 */
1984 "INVALID0x80000", /* 0x80000 */
1985 "VROOT", /* 0x100000 */
1986 "INVALID0x200000", /* 0x200000 */
1987 "INVALID00x400000", /* 0x400000 */
1988 "INVALID0x800000", /* 0x800000 */
1989 "INVALID0x1000000", /* 0x1000000 */
1990 "INVALID0x2000000", /* 0x2000000 */
1991 "VSHARE", /* 0x4000000 */
1992 "INVALID0x8000000", /* 0x8000000 */
1993 "VENF_LOCKING", /* 0x10000000 */
1994 "VOPLOCK", /* 0x20000000 */
1995 "VPURGE", /* 0x40000000 */
1996 "INVALID0x80000000", /* 0x80000000 */
2001 printflags(register uint64_t flags,
2002 register char **strings,
2003 register char *name)
2005 register uint64_t mask = 1;
2008 kdb_printf("%s 0x%llx <", name, (unsigned long long)flags);
2010 while (flags != 0 && *strings) {
2012 kdb_printf("%s ", *strings);
2026 static void printbhv(bhv_desc_t *bdp)
2028 int maxbhv = 20; /* if you get 20 bhvs you're in trouble already */
2029 kdb_symtab_t symtab;
2032 kdb_printf("NULL bhv\n");
2036 kdb_printf("bhv at 0x%p\n", bdp);
2037 while (bdp && maxbhv--) {
2038 if (kdbnearsym((unsigned long)bdp->bd_ops, &symtab))
2039 kdb_printf(" ops %s", symtab.sym_name);
2041 kdb_printf(" ops %s/0x%p", "???", (void *)bdp->bd_ops);
2043 kdb_printf(" vobj 0x%p pdata 0x%p next 0x%p\n",
2044 bdp->bd_vobj, bdp->bd_pdata, bdp->bd_next);
2051 static void printvnode(xfs_vnode_t *vp, unsigned long addr)
2053 kdb_printf("vnode: 0x%lx\n", addr);
2054 kdb_printf(" v_bh 0x%p\n", &vp->v_bh);
2056 printbhv(vp->v_fbhv);
2058 printflags((__psunsigned_t)vp->v_flag, tab_vflags, "flag =");
2061 #ifdef XFS_VNODE_TRACE
2062 kdb_printf(" v_trace 0x%p\n", vp->v_trace);
2063 #endif /* XFS_VNODE_TRACE */
2065 kdb_printf(" v_vfsp 0x%p v_number 0x%llx\n",
2066 vp->v_vfsp, (unsigned long long)vp->v_number);
2069 static int kdbm_vnode(
2073 struct pt_regs *regs)
2082 return KDB_ARGCOUNT;
2084 diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL, regs);
2089 if ((diag = kdb_getarea(vp, addr)))
2092 printvnode(&vp, addr);
2098 print_vfs(xfs_vfs_t *vfs, unsigned long addr)
2100 kdb_printf("vfsp at 0x%lx", addr);
2101 kdb_printf(" vfs_flag 0x%x\n", vfs->vfs_flag);
2102 kdb_printf(" vfs_mp 0x%p", vfs->vfs_mp);
2103 kdb_printf(" vfs_bh 0x%p\n", &vfs->vfs_bh);
2105 printbhv(vfs->vfs_fbhv);
2108 static int kdbm_bhv(
2112 struct pt_regs *regs)
2121 return KDB_ARGCOUNT;
2123 diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL, regs);
2128 bh = (bhv_desc_t *)addr;
2135 static int kdbm_vfs(
2139 struct pt_regs *regs)
2148 return KDB_ARGCOUNT;
2150 diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL, regs);
2155 if ((diag = kdb_getarea(vfs, addr)))
2158 print_vfs(&vfs, addr);
2164 #ifdef XFS_VNODE_TRACE
2166 * Print a vnode trace entry.
2169 vn_trace_pr_entry(ktrace_entry_t *ktep)
2172 kdb_symtab_t symtab;
2175 if ((__psint_t)ktep->val[0] == 0)
2178 if (kdbnearsym((unsigned int)ktep->val[8], &symtab)) {
2179 unsigned long offval;
2181 offval = (unsigned int)ktep->val[8] - symtab.sym_start;
2184 sprintf(funcname, "%s+0x%lx", symtab.sym_name, offval);
2186 sprintf(funcname, "%s", symtab.sym_name);
2191 switch ((__psint_t)ktep->val[0]) {
2192 case VNODE_KTRACE_ENTRY:
2193 kdb_printf("entry to %s i_count = %d",
2194 (char *)ktep->val[1],
2195 (__psint_t)ktep->val[3]);
2198 case VNODE_KTRACE_EXIT:
2199 kdb_printf("exit from %s i_count = %d",
2200 (char *)ktep->val[1],
2201 (__psint_t)ktep->val[3]);
2204 case VNODE_KTRACE_HOLD:
2205 if ((__psint_t)ktep->val[3] != 1)
2206 kdb_printf("hold @%s:%d(%s) i_count %d => %d ",
2207 (char *)ktep->val[1],
2208 (__psint_t)ktep->val[2],
2210 (__psint_t)ktep->val[3] - 1,
2211 (__psint_t)ktep->val[3]);
2213 kdb_printf("get @%s:%d(%s) i_count = %d",
2214 (char *)ktep->val[1],
2215 (__psint_t)ktep->val[2],
2217 (__psint_t)ktep->val[3]);
2220 case VNODE_KTRACE_REF:
2221 kdb_printf("ref @%s:%d(%s) i_count = %d",
2222 (char *)ktep->val[1],
2223 (__psint_t)ktep->val[2],
2225 (__psint_t)ktep->val[3]);
2228 case VNODE_KTRACE_RELE:
2229 if ((__psint_t)ktep->val[3] != 1)
2230 kdb_printf("rele @%s:%d(%s) i_count %d => %d ",
2231 (char *)ktep->val[1],
2232 (__psint_t)ktep->val[2],
2234 (__psint_t)ktep->val[3],
2235 (__psint_t)ktep->val[3] - 1);
2237 kdb_printf("free @%s:%d(%s) i_count = %d",
2238 (char *)ktep->val[1],
2239 (__psint_t)ktep->val[2],
2241 (__psint_t)ktep->val[3]);
2245 kdb_printf("unknown vntrace record\n");
2251 kdb_printf(" cpu = %d pid = %d ",
2252 (__psint_t)ktep->val[6], (pid_t)ktep->val[7]);
2254 printflags((__psunsigned_t)ktep->val[5], tab_vflags, "flag =");
2256 if (kdbnearsym((unsigned int)ktep->val[4], &symtab)) {
2257 unsigned long offval;
2259 offval = (unsigned int)ktep->val[4] - symtab.sym_start;
2262 kdb_printf(" ra = %s+0x%lx", symtab.sym_name, offval);
2264 kdb_printf(" ra = %s", symtab.sym_name);
2266 kdb_printf(" ra = ?? 0x%p", (void *)ktep->val[4]);
2273 * Print out the trace buffer attached to the given vnode.
2275 static int kdbm_vntrace(
2279 struct pt_regs *regs)
2286 ktrace_entry_t *ktep;
2291 return KDB_ARGCOUNT;
2293 diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL, regs);
2298 vp = (xfs_vnode_t *)addr;
2300 if (vp->v_trace == NULL) {
2301 kdb_printf("The vnode trace buffer is not initialized\n");
2306 kdb_printf("vntrace vp 0x%p\n", vp);
2308 ktep = ktrace_first(vp->v_trace, &kts);
2310 while (ktep != NULL) {
2311 if (vn_trace_pr_entry(ktep))
2314 ktep = ktrace_next(vp->v_trace, &kts);
2320 * Print out the trace buffer attached to the given vnode.
2322 static int kdbm_vntraceaddr(
2326 struct pt_regs *regs)
2333 ktrace_entry_t *ktep;
2338 return KDB_ARGCOUNT;
2340 diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL, regs);
2345 kt = (struct ktrace *)addr;
2347 kdb_printf("vntraceaddr kt 0x%p\n", kt);
2349 ktep = ktrace_first(kt, &kts);
2351 while (ktep != NULL) {
2352 if (vn_trace_pr_entry(ktep))
2355 ktep = ktrace_next(kt, &kts);
2360 #endif /* XFS_VNODE_TRACE */
2363 static void printinode(struct inode *ip)
2371 kdb_printf(" i_ino = %lu i_count = %u i_size %Ld\n",
2372 ip->i_ino, atomic_read(&ip->i_count),
2374 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,0)
2376 " i_mode = 0x%x i_nlink = %d i_rdev = 0x%x i_state = 0x%lx\n",
2377 ip->i_mode, ip->i_nlink,
2378 kdev_t_to_nr(ip->i_rdev), ip->i_state);
2379 kdb_printf(" i_hash.nxt = 0x%p i_hash.pprv = 0x%p\n",
2380 ip->i_hash.next, ip->i_hash.prev);
2383 " i_mode = 0x%x i_nlink = %d i_rdev = 0x%x i_state = 0x%lx\n",
2384 ip->i_mode, ip->i_nlink,
2385 ip->i_rdev, ip->i_state);
2386 kdb_printf(" i_hash.nxt = 0x%p i_hash.pprv = 0x%p\n",
2387 ip->i_hash.next, ip->i_hash.pprev);
2389 kdb_printf(" i_list.nxt = 0x%p i_list.prv = 0x%p\n",
2390 ip->i_list.next, ip->i_list.prev);
2391 kdb_printf(" i_dentry.nxt = 0x%p i_dentry.prv = 0x%p\n",
2395 addr = (unsigned long)ip;
2397 kdb_printf(" i_sb = 0x%p i_op = 0x%p i_data = 0x%lx nrpages = %lu\n",
2399 addr + offsetof(struct inode, i_data),
2400 ip->i_data.nrpages);
2402 kdb_printf(" vnode ptr 0x%p\n", vn_from_inode(ip));
2412 struct pt_regs *regs)
2422 #ifdef XFS_VNODE_TRACE
2423 ktrace_entry_t *ktep;
2428 return KDB_ARGCOUNT;
2430 diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL, regs);
2434 if ((diag = kdb_getarea(vp, addr)))
2438 ip = vn_to_inode((vnode_t *)addr);
2439 kdb_printf("--> Inode @ 0x%p\n", ip);
2443 kdb_printf("--> Vnode @ 0x%lx\n", addr);
2444 printvnode(&vp, addr);
2446 #ifdef XFS_VNODE_TRACE
2447 kdb_printf("--> Vntrace @ 0x%lx/0x%p\n", addr, vp.v_trace);
2448 if (vp.v_trace == NULL)
2450 ktep = ktrace_first(vp.v_trace, &kts);
2451 while (ktep != NULL) {
2452 if (vn_trace_pr_entry(ktep))
2455 ktep = ktrace_next(vp.v_trace, &kts);
2457 #endif /* XFS_VNODE_TRACE */
2464 static char *bp_flag_vals[] = {
2465 /* 0 */ "READ", "WRITE", "MAPPED", "PARTIAL", "ASYNC",
2466 /* 5 */ "NONE", "DELWRI", "STALE", "FS_MANAGED", "FS_DATAIOD",
2467 /* 10 */ "FORCEIO", "FLUSH", "READ_AHEAD", "DIRECTIO", "LOCK",
2468 /* 15 */ "TRYLOCK", "DONT_BLOCK", "PAGE_CACHE", "KMEM_ALLOC", "RUN_QUEUES",
2469 /* 20 */ "PRIVATE_BH", "DELWRI_Q",
2474 static char *iomap_flag_vals[] = {
2475 "EOF", "HOLE", "DELAY", "INVALID0x08",
2476 "INVALID0x10", "UNWRITTEN", "NEW", "INVALID0x80",
2480 static char *map_flags(unsigned long flags, char *mapping[])
2482 static char buffer[256];
2488 for (index = 0; flags && mapping[index]; flags >>= 1, index++) {
2490 if ((offset + strlen(mapping[index]) + 1) >= 80) {
2491 strcat(buffer, "\n ");
2493 } else if (offset > 12) {
2494 strcat(buffer, " ");
2497 strcat(buffer, mapping[index]);
2498 offset += strlen(mapping[index]);
2507 static char *bp_flags(xfs_buf_flags_t bp_flag)
2509 return(map_flags((unsigned long) bp_flag, bp_flag_vals));
2513 kdbm_bp_flags(int argc, const char **argv, const char **envp, struct pt_regs *regs)
2515 unsigned long flags;
2519 return KDB_ARGCOUNT;
2521 diag = kdbgetularg(argv[1], &flags);
2525 kdb_printf("bp flags 0x%lx = %s\n", flags, bp_flags(flags));
2535 unsigned long age = (xfs_buf_age_centisecs * HZ) / 100;
2537 kdb_printf("xfs_buf_t at 0x%lx\n", addr);
2538 kdb_printf(" b_flags %s\n", bp_flags(bp->b_flags));
2539 kdb_printf(" b_target 0x%p b_hold %d b_next 0x%p b_prev 0x%p\n",
2540 bp->b_target, bp->b_hold.counter,
2541 list_entry(bp->b_list.next, xfs_buf_t, b_list),
2542 list_entry(bp->b_list.prev, xfs_buf_t, b_list));
2543 kdb_printf(" b_hash 0x%p b_hash_next 0x%p b_hash_prev 0x%p\n",
2545 list_entry(bp->b_hash_list.next, xfs_buf_t, b_hash_list),
2546 list_entry(bp->b_hash_list.prev, xfs_buf_t, b_hash_list));
2547 kdb_printf(" b_file_offset 0x%llx b_buffer_length 0x%llx b_addr 0x%p\n",
2548 (unsigned long long) bp->b_file_offset,
2549 (unsigned long long) bp->b_buffer_length,
2551 kdb_printf(" b_bn 0x%llx b_count_desired 0x%lx b_locked %d\n",
2552 (unsigned long long)bp->b_bn,
2553 (unsigned long) bp->b_count_desired, (int)bp->b_locked);
2554 kdb_printf(" b_queuetime %ld (now=%ld/age=%ld) b_io_remaining %d\n",
2555 bp->b_queuetime, jiffies, bp->b_queuetime + age,
2556 bp->b_io_remaining.counter);
2557 kdb_printf(" b_page_count %u b_offset 0x%x b_pages 0x%p b_error %u\n",
2558 bp->b_page_count, bp->b_offset,
2559 bp->b_pages, bp->b_error);
2560 kdb_printf(" b_iodonesema (%d,%d) b_sema (%d,%d) b_pincount (%d)\n",
2561 bp->b_iodonesema.count.counter,
2562 bp->b_iodonesema.sleepers,
2563 bp->b_sema.count.counter, bp->b_sema.sleepers,
2564 bp->b_pin_count.counter);
2565 #ifdef XFS_BUF_LOCK_TRACKING
2566 kdb_printf(" last holder %d\n", bp->b_last_holder);
2568 if (bp->b_fspriv || bp->b_fspriv2) {
2569 kdb_printf( " b_fspriv 0x%p b_fspriv2 0x%p\n",
2570 bp->b_fspriv, bp->b_fspriv2);
2575 kdbm_bp(int argc, const char **argv, const char **envp, struct pt_regs *regs)
2584 return KDB_ARGCOUNT;
2587 if ((diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL, regs)) ||
2588 (diag = kdb_getarea(bp, addr)))
2591 print_xfs_buf(&bp, addr);
2597 kdbm_bpdelay(int argc, const char **argv, const char **envp,
2598 struct pt_regs *regs)
2601 extern struct list_head xfs_buftarg_list;
2602 struct list_head *curr, *next;
2603 xfs_buftarg_t *tp, *n;
2605 unsigned long addr, verbose = 0;
2606 int diag, count = 0;
2609 return KDB_ARGCOUNT;
2612 if ((diag = kdbgetularg(argv[1], &verbose))) {
2618 kdb_printf("index bp pin queuetime\n");
2622 list_for_each_entry_safe(tp, n, &xfs_buftarg_list, bt_list) {
2623 list_for_each_safe(curr, next, &tp->bt_delwrite_queue) {
2624 addr = (unsigned long)list_entry(curr, xfs_buf_t, b_list);
2625 if ((diag = kdb_getarea(bp, addr)))
2629 print_xfs_buf(&bp, addr);
2631 kdb_printf("%4d 0x%lx %d %ld\n",
2633 bp.b_pin_count.counter,
2639 kdb_printf("bt_delwrite_queue inaccessible (non-debug)\n");
2646 kdbm_iomap(int argc, const char **argv, const char **envp,
2647 struct pt_regs *regs)
2656 return KDB_ARGCOUNT;
2659 if ((diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL, regs)))
2661 if ((diag = kdb_getarea(iomap, addr)))
2664 kdb_printf("iomap_t at 0x%lx\n", addr);
2665 kdb_printf(" bn 0x%llx offset 0x%Lx delta 0x%lx bsize 0x%llx\n",
2666 (long long) iomap.iomap_bn, iomap.iomap_offset,
2667 (unsigned long)iomap.iomap_delta, (long long)iomap.iomap_bsize);
2668 kdb_printf(" iomap_flags %s\n",
2669 map_flags(iomap.iomap_flags, iomap_flag_vals));
2675 kdbm_i2vnode(int argc, const char **argv, const char **envp,
2676 struct pt_regs *regs)
2686 return KDB_ARGCOUNT;
2689 if ((diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL, regs)))
2691 ip = (struct inode *)addr;
2692 if ((diag = kdb_getarea(vp, (unsigned long)vn_from_inode(ip))))
2695 kdb_printf("--> Inode @ 0x%p\n", ip);
2698 kdb_printf("--> Vnode @ 0x%p\n", vn_from_inode(ip));
2699 printvnode(&vp, (unsigned long)vn_from_inode(ip));
2704 #ifdef XFS_BUF_TRACE
2705 static int xfs_buf_trace_entry(ktrace_entry_t *ktep)
2707 unsigned long long daddr;
2709 daddr = ((unsigned long long)(unsigned long)ktep->val[8] << 32)
2710 | ((unsigned long long)(unsigned long)ktep->val[9]);
2712 kdb_printf("bp 0x%p [%s] (hold %lu lock %ld) data 0x%p",
2714 (char *)ktep->val[1],
2715 (unsigned long)ktep->val[3],
2718 kdb_symbol_print((unsigned long)ktep->val[7], NULL,
2719 KDB_SP_SPACEB|KDB_SP_PAREN|KDB_SP_NEWLINE);
2720 kdb_printf(" offset 0x%llx size 0x%lx task 0x%p\n",
2721 daddr, (long)ktep->val[10], ktep->val[5]);
2722 kdb_printf(" flags: %s\n", bp_flags((int)(long)ktep->val[2]));
2727 kdbm_bptrace_offset(int argc, const char **argv, const char **envp,
2728 struct pt_regs *regs)
2731 unsigned long got_offset = 0, offset = 0;
2733 ktrace_entry_t *ktep;
2737 return KDB_ARGCOUNT;
2740 diag = kdbgetularg(argv[1], &offset);
2743 got_offset = 1; /* allows tracing offset zero */
2747 diag = kdbgetularg(argv[1], &mask); /* sign extent mask */
2752 ktep = ktrace_first(xfs_buf_trace_buf, &kts);
2754 unsigned long long daddr;
2758 daddr = ((unsigned long long)(unsigned long)ktep->val[8] << 32)
2759 | ((unsigned long long)(unsigned long)ktep->val[9]);
2760 if (got_offset && ((daddr & ~mask) != offset))
2762 if (xfs_buf_trace_entry(ktep))
2764 } while ((ktep = ktrace_next(xfs_buf_trace_buf, &kts)) != NULL);
2769 kdbm_bptrace(int argc, const char **argv, const char **envp,
2770 struct pt_regs *regs)
2772 unsigned long addr = 0;
2775 char *event_match = NULL;
2776 ktrace_entry_t *ktep;
2780 return KDB_ARGCOUNT;
2783 if (isupper(argv[1][0]) || islower(argv[1][0])) {
2784 event_match = (char *)argv[1];
2785 kdb_printf("event match on \"%s\"\n", event_match);
2789 diag = kdbgetaddrarg(argc, argv,
2790 &nextarg, &addr, &offset, NULL, regs);
2792 kdb_printf("non-numeric arg: %s\n", argv[1]);
2798 ktep = ktrace_first(xfs_buf_trace_buf, &kts);
2802 if (addr && (ktep->val[0] != (void *)addr))
2804 if (event_match && strcmp((char *)ktep->val[1], event_match))
2806 if (xfs_buf_trace_entry(ktep))
2808 } while ((ktep = ktrace_next(xfs_buf_trace_buf, &kts)) != NULL);
2816 int (*func)(int, const char **, const char **, struct pt_regs *);
2821 static struct xif xfsidbg_funcs[] = {
2822 { "bhv", kdbm_bhv, "<bhv>", "Dump bhv chain"},
2823 { "vn", kdbm_vn, "<vnode>", "Dump inode/vnode/trace"},
2824 { "vnode", kdbm_vnode, "<vnode>", "Dump vnode"},
2825 { "vfs", kdbm_vfs, "<vfs>", "Dump vfs"},
2826 #ifdef XFS_VNODE_TRACE
2827 { "vntrace", kdbm_vntrace, "<vntrace>", "Dump vnode Trace"},
2828 { "vntraceaddr", kdbm_vntraceaddr, "<vntrace>",
2829 "Dump vnode Trace by Address"},
2831 { "xagf", kdbm_xfs_xagf, "<agf>",
2832 "Dump XFS allocation group freespace" },
2833 { "xagi", kdbm_xfs_xagi, "<agi>",
2834 "Dump XFS allocation group inode" },
2835 { "xail", kdbm_xfs_xaildump, "<xfs_mount_t>",
2836 "Dump XFS AIL for a mountpoint" },
2837 #ifdef XFS_ALLOC_TRACE
2838 { "xalatrc", kdbm_xfs_xalatrace, "<count>",
2839 "Dump XFS alloc count trace" },
2840 { "xalbtrc", kdbm_xfs_xalbtrace, "<xfs_agblock_t>",
2841 "Dump XFS alloc block trace" },
2842 { "xalgtrc", kdbm_xfs_xalgtrace, "<xfs_agnumber_t>",
2843 "Dump XFS alloc alloc-group trace" },
2846 { "xalloc", kdbm_xfs_xalloc, "<xfs_alloc_arg_t>",
2847 "Dump XFS allocation args structure" },
2848 #ifdef XFS_ALLOC_TRACE
2849 { "xalmtrc", kdbm_xfs_xalmtrace, "<xfs_mount_t>",
2850 "Dump XFS alloc mount-point trace" },
2851 { "xalttrc", kdbm_xfs_xalttrace, "<tag>",
2852 "Dump XFS alloc trace by tag number" },
2854 { "xarg", kdbm_xfs_xarg, "<value>",
2855 "Input XFS argument for next function" },
2856 { "xattrcx", kdbm_xfs_xattrcontext, "<xfs_attr_list_context_t>",
2857 "Dump XFS attr_list context struct"},
2858 { "xattrlf", kdbm_xfs_xattrleaf, "<xfs_attr_leafblock_t>",
2859 "Dump XFS attribute leaf block"},
2860 { "xattrsf", kdbm_xfs_xattrsf, "<xfs_attr_shortform_t>",
2861 "Dump XFS attribute shortform"},
2862 #ifdef XFS_ATTR_TRACE
2863 { "xattrtr", kdbm_xfs_xattrtrace, "<count>",
2864 "Dump XFS attribute attr_list() trace" },
2866 { "xbirec", kdbm_xfs_xbirec, "<xfs_bmbt_irec_t",
2867 "Dump XFS bmap incore record"},
2868 #ifdef XFS_BLI_TRACE
2869 { "xblitrc", kdbm_xfs_xblitrace, "<xfs_buf_log_item_t>",
2870 "Dump XFS buf log item trace" },
2872 { "xbmalla", kdbm_xfs_xbmalla, "<xfs_bmalloca_t>",
2873 "Dump XFS bmalloc args structure"},
2874 #ifdef XFS_BMAP_TRACE
2875 { "xbmatrc", kdbm_xfs_xbmatrace, "<count>",
2876 "Dump XFS bmap btree count trace" },
2877 { "xbmitrc", kdbm_xfs_xbmitrace, "<xfs_inode_t>",
2878 "Dump XFS bmap btree per-inode trace" },
2879 { "xbmstrc", kdbm_xfs_xbmstrace, "<xfs_inode_t>",
2880 "Dump XFS bmap btree inode trace" },
2882 { "xbrec", kdbm_xfs_xbrec, "<xfs_bmbt_rec_64_t>",
2883 "Dump XFS bmap record"},
2884 { "xbroot", kdbm_xfs_xbroot, "<xfs_inode_t>",
2885 "Dump XFS bmap btree root (data)"},
2886 { "xbroota", kdbm_xfs_xbroota, "<xfs_inode_t>",
2887 "Dump XFS bmap btree root (attr)"},
2888 { "xbtcur", kdbm_xfs_xbtcur, "<xfs_btree_cur_t>",
2889 "Dump XFS btree cursor"},
2890 { "xbuf", kdbm_xfs_xbuf, "<xfs_buf_t>",
2891 "Dump XFS data from a buffer"},
2892 #ifdef XFS_BMAP_TRACE
2893 { "xbxatrc", kdbm_xfs_xbxatrace, "<count>",
2894 "Dump XFS bmap extent count trace" },
2895 { "xbxitrc", kdbm_xfs_xbxitrace, "<xfs_inode_t>",
2896 "Dump XFS bmap extent per-inode trace" },
2897 { "xbxstrc", kdbm_xfs_xbxstrace, "<xfs_inode_t>",
2898 "Dump XFS bmap extent inode trace" },
2900 { "xchash", kdbm_xfs_xchash, "<xfs_mount_t>",
2901 "Dump XFS cluster hash"},
2902 { "xchlist", kdbm_xfs_xchashlist, "<xfs_chashlist_t>",
2903 "Dump XFS cluster hash list"},
2904 { "xchksum", kdbm_xfs_xchksum, "<addr>", "Dump chksum" },
2905 #ifdef XFS_DIR2_TRACE
2906 { "xd2atrc", kdbm_xfs_xdir2atrace, "<count>",
2907 "Dump XFS directory v2 count trace" },
2909 { "xd2free", kdbm_xfs_xdir2free, "<xfs_dir2_free_t>",
2910 "Dump XFS directory v2 freemap"},
2911 #ifdef XFS_DIR2_TRACE
2912 { "xd2itrc", kdbm_xfs_xdir2itrace, "<xfs_inode_t>",
2913 "Dump XFS directory v2 per-inode trace" },
2915 { "xdaargs", kdbm_xfs_xdaargs, "<xfs_da_args_t>",
2916 "Dump XFS dir/attr args structure"},
2917 { "xdabuf", kdbm_xfs_xdabuf, "<xfs_dabuf_t>",
2918 "Dump XFS dir/attr buf structure"},
2919 { "xdanode", kdbm_xfs_xdanode, "<xfs_da_intnode_t>",
2920 "Dump XFS dir/attr node block"},
2921 { "xdastat", kdbm_xfs_xdastate, "<xfs_da_state_t>",
2922 "Dump XFS dir/attr state_blk struct"},
2923 { "xdelay", kdbm_xfs_delayed_blocks, "<xfs_mount_t>",
2924 "Dump delayed block totals"},
2925 { "xdirlf", kdbm_xfs_xdirleaf, "<xfs_dir_leafblock_t>",
2926 "Dump XFS directory leaf block"},
2927 { "xdirsf", kdbm_xfs_xdirsf, "<xfs_dir_shortform_t>",
2928 "Dump XFS directory shortform"},
2929 { "xdir2sf", kdbm_xfs_xdir2sf, "<xfs_dir2_sf_t>",
2930 "Dump XFS directory v2 shortform"},
2931 #ifdef XFS_DIR_TRACE
2932 { "xdirtrc", kdbm_xfs_xdirtrace, "<count>",
2933 "Dump XFS directory getdents() trace" },
2935 { "xdiskdq", kdbm_xfs_xqm_diskdq, "<xfs_disk_dquot_t>",
2936 "Dump XFS ondisk dquot (quota) struct"},
2937 { "xdqatt", kdbm_xfs_xqm_dqattached_inos, "<xfs_mount_t>",
2938 "All incore inodes with dquots"},
2939 { "xdqinfo", kdbm_xfs_xqm_tpdqinfo, "<xfs_trans_t>",
2940 "Dump dqinfo structure of a trans"},
2941 #ifdef XFS_DQUOT_TRACE
2942 { "xdqtrace",kdbm_xfs_xqm_dqtrace, "<xfs_dquot_t>",
2943 "Dump trace of a given dquot" },
2945 { "xdquot", kdbm_xfs_xqm_dquot, "<xfs_dquot_t>",
2946 "Dump XFS dquot (quota) structure"},
2947 { "xexlist", kdbm_xfs_xexlist, "<xfs_inode_t>",
2948 "Dump XFS bmap extents in inode"},
2949 { "xflist", kdbm_xfs_xflist, "<xfs_bmap_free_t>",
2950 "Dump XFS to-be-freed extent records"},
2951 { "xhelp", kdbm_xfs_xhelp, "",
2952 "Print idbg-xfs help"},
2953 { "xicall", kdbm_xfs_xiclogall, "<xlog_in_core_t>",
2954 "Dump All XFS in-core logs"},
2955 { "xiclog", kdbm_xfs_xiclog, "<xlog_in_core_t>",
2956 "Dump XFS in-core log"},
2957 #ifdef XFS_LOG_TRACE
2958 { "xictrc", kdbm_xfs_xiclogtrace, "<xlog_in_core_t>",
2959 "Dump XFS in-core log trace" },
2961 { "xihash", kdbm_xfs_xihash, "<xfs_mount_t>",
2962 "Dump XFS inode hash statistics"},
2963 #ifdef XFS_ILOCK_TRACE
2964 { "xilocktrc",kdbm_xfs_xilock_trace, "<xfs_inode_t>",
2965 "Dump XFS ilock trace" },
2966 { "xailcktrc",kdbm_xfs_xailock_trace,"<count>",
2967 "Dump XFS global ilock trace" },
2969 { "xinodes", kdbm_xfs_xinodes, "<xfs_mount_t>",
2970 "Dump XFS inodes per mount"},
2971 { "xquiesce",kdbm_xfs_xinodes_quiesce, "<xfs_mount_t>",
2972 "Dump non-quiesced XFS inodes per mount"},
2973 #ifdef XFS_LOG_TRACE
2974 { "xl_grtr", kdbm_xfs_xlog_granttrace, "<xlog_t>",
2975 "Dump XFS log grant trace" },
2977 { "xl_rcit", kdbm_xfs_xlog_ritem, "<xlog_recover_item_t>",
2978 "Dump XFS recovery item"},
2979 { "xl_rctr", kdbm_xfs_xlog_rtrans, "<xlog_recover_t>",
2980 "Dump XFS recovery transaction"},
2981 { "xl_rctr2",kdbm_xfs_xlog_rtrans_entire, "<xlog_recover_t>",
2982 "Dump entire recovery transaction"},
2983 { "xl_tic", kdbm_xfs_xlog_tic, "<xlog_ticket_t>",
2984 "Dump XFS log ticket"},
2985 { "xlog", kdbm_xfs_xlog, "<xlog_t>",
2987 { "xlogcb", kdbm_xfs_xiclogcb, "<xlog_in_core_t>",
2988 "Dump XFS in-core log callbacks"},
2989 { "xlogitm", kdbm_xfs_xlogitem, "<xfs_log_item_t>",
2990 "Dump XFS log item structure"},
2991 { "xmount", kdbm_xfs_xmount, "<xfs_mount_t>",
2992 "Dump XFS mount structure"},
2993 { "xnode", kdbm_xfs_xnode, "<xfs_inode_t>",
2995 { "xiocore", kdbm_xfs_xcore, "<xfs_iocore_t>",
2997 { "xperag", kdbm_xfs_xperag, "<xfs_mount_t>",
2998 "Dump XFS per-allocation group data"},
2999 { "xqinfo", kdbm_xfs_xqm_qinfo, "<xfs_mount_t>",
3000 "Dump mount->m_quotainfo structure"},
3001 #ifdef CONFIG_XFS_QUOTA
3002 { "xqm", kdbm_xfs_xqm, "",
3003 "Dump XFS quota manager structure"},
3004 { "xqmfree", kdbm_xfs_xqm_freelist, "",
3005 "Dump XFS global freelist of dquots"},
3006 { "xqmhtab", kdbm_xfs_xqm_htab, "",
3007 "Dump XFS hashtable of dquots"},
3008 #endif /* CONFIG_XFS_QUOTA */
3009 { "xqmplist",kdbm_xfs_xqm_mplist, "<xfs_mount_t>",
3010 "Dump XFS all dquots of a f/s"},
3012 { "xrwtrc", kdbm_xfs_xrwtrace, "<xfs_inode_t>",
3013 "Dump XFS inode read/write trace" },
3015 { "xsb", kdbm_xfs_xsb, "<xfs_sb_t> <cnv>",
3016 "Dump XFS superblock"},
3017 { "xtp", kdbm_xfs_xtp, "<xfs_trans_t>",
3018 "Dump XFS transaction structure"},
3019 { "xtrres", kdbm_xfs_xtrans_res, "<xfs_mount_t>",
3020 "Dump XFS reservation values"},
3021 { NULL, NULL, NULL }
3024 static struct xif xfsbuf_funcs[] = {
3025 { "bp", kdbm_bp, "<vaddr>", "Display xfs_buf_t" },
3026 { "bpflags", kdbm_bp_flags, "<flags>", "Display xfs_buf flags" },
3027 { "xiomap", kdbm_iomap, "<xfs_iomap_t *>", "Display IOmap" },
3028 { "i2vnode", kdbm_i2vnode, "<inode *>", "Display Vnode" },
3029 { "bpdelay", kdbm_bpdelay, "0|1", "Display delwri buffers" },
3030 #ifdef XFS_BUF_TRACE
3031 { "bptrace", kdbm_bptrace, "<vaddr>|<count>", "xfs_buf_t trace" },
3032 { "bpoffset",kdbm_bptrace_offset, "<daddr> [<mask>]","xfs_buf_t trace" },
3034 { NULL, NULL, NULL }
3042 for (p = xfsidbg_funcs; p->name; p++)
3043 kdb_register(p->name, p->func, p->args, p->help, 0);
3044 for (p = xfsbuf_funcs; p->name; p++)
3045 kdb_register(p->name, p->func, p->args, p->help, 0);
3054 for (p = xfsidbg_funcs; p->name; p++)
3055 kdb_unregister(p->name);
3056 for (p = xfsbuf_funcs; p->name; p++)
3057 kdb_unregister(p->name);
3061 * Argument to xfs_alloc routines, for allocation type.
3063 static char *xfs_alloctype[] = {
3064 "any_ag", "first_ag", "start_ag", "this_ag",
3065 "start_bno", "near_bno", "this_bno"
3072 #ifdef XFS_ALLOC_TRACE
3074 * Print xfs alloc trace buffer entry.
3077 xfs_alloc_trace_entry(ktrace_entry_t *ktep)
3079 static char *modagf_flags[] = {
3094 if (((__psint_t)ktep->val[0] & 0xffff) == 0)
3096 switch ((long)ktep->val[0] & 0xffffL) {
3097 case XFS_ALLOC_KTRACE_ALLOC:
3098 kdb_printf("alloc %s[%s %ld] mp 0x%p\n",
3099 (char *)ktep->val[1],
3100 ktep->val[2] ? (char *)ktep->val[2] : "",
3101 (long)ktep->val[0] >> 16,
3102 (xfs_mount_t *)ktep->val[3]);
3104 "agno %ld agbno %ld minlen %ld maxlen %ld mod %ld prod %ld minleft %ld\n",
3111 (long)ktep->val[10]);
3112 kdb_printf("total %ld alignment %ld len %ld type %s otype %s\n",
3113 (long)ktep->val[11],
3114 (long)ktep->val[12],
3115 (long)ktep->val[13],
3116 xfs_alloctype[((__psint_t)ktep->val[14]) >> 16],
3117 xfs_alloctype[((__psint_t)ktep->val[14]) & 0xffff]);
3118 kdb_printf("wasdel %d wasfromfl %d isfl %d userdata %d\n",
3119 ((__psint_t)ktep->val[15] & (1 << 3)) != 0,
3120 ((__psint_t)ktep->val[15] & (1 << 2)) != 0,
3121 ((__psint_t)ktep->val[15] & (1 << 1)) != 0,
3122 ((__psint_t)ktep->val[15] & (1 << 0)) != 0);
3124 case XFS_ALLOC_KTRACE_FREE:
3125 kdb_printf("free %s[%s %ld] mp 0x%p\n",
3126 (char *)ktep->val[1],
3127 ktep->val[2] ? (char *)ktep->val[2] : "",
3128 (long)ktep->val[0] >> 16,
3129 (xfs_mount_t *)ktep->val[3]);
3130 kdb_printf("agno %ld agbno %ld len %ld isfl %d\n",
3134 (__psint_t)ktep->val[7] != 0);
3136 case XFS_ALLOC_KTRACE_MODAGF:
3137 kdb_printf("modagf %s[%s %ld] mp 0x%p\n",
3138 (char *)ktep->val[1],
3139 ktep->val[2] ? (char *)ktep->val[2] : "",
3140 (long)ktep->val[0] >> 16,
3141 (xfs_mount_t *)ktep->val[3]);
3142 printflags((__psint_t)ktep->val[4], modagf_flags, "modified");
3143 kdb_printf("seqno %lu length %lu roots b %lu c %lu\n",
3144 (unsigned long)ktep->val[5],
3145 (unsigned long)ktep->val[6],
3146 (unsigned long)ktep->val[7],
3147 (unsigned long)ktep->val[8]);
3148 kdb_printf("levels b %lu c %lu flfirst %lu fllast %lu flcount %lu\n",
3149 (unsigned long)ktep->val[9],
3150 (unsigned long)ktep->val[10],
3151 (unsigned long)ktep->val[11],
3152 (unsigned long)ktep->val[12],
3153 (unsigned long)ktep->val[13]);
3154 kdb_printf("freeblks %lu longest %lu\n",
3155 (unsigned long)ktep->val[14],
3156 (unsigned long)ktep->val[15]);
3159 case XFS_ALLOC_KTRACE_UNBUSY:
3160 kdb_printf("unbusy %s [%s %ld] mp 0x%p\n",
3161 (char *)ktep->val[1],
3162 ktep->val[2] ? (char *)ktep->val[2] : "",
3163 (long)ktep->val[0] >> 16,
3164 (xfs_mount_t *)ktep->val[3]);
3165 kdb_printf(" agno %lu slot %lu tp 0x%p\n",
3166 (unsigned long)ktep->val[4],
3167 (unsigned long)ktep->val[7],
3168 (xfs_trans_t *)ktep->val[8]);
3170 case XFS_ALLOC_KTRACE_BUSY:
3171 kdb_printf("busy %s [%s %ld] mp 0x%p\n",
3172 (char *)ktep->val[1],
3173 ktep->val[2] ? (char *)ktep->val[2] : "",
3174 (long)ktep->val[0] >> 16,
3175 (xfs_mount_t *)ktep->val[3]);
3176 kdb_printf(" agno %lu agbno %lu len %lu slot %lu tp 0x%p\n",
3177 (unsigned long)ktep->val[4],
3178 (unsigned long)ktep->val[5],
3179 (unsigned long)ktep->val[6],
3180 (unsigned long)ktep->val[7],
3181 (xfs_trans_t *)ktep->val[8]);
3183 case XFS_ALLOC_KTRACE_BUSYSEARCH:
3184 kdb_printf("busy-search %s [%s %ld] mp 0x%p\n",
3185 (char *)ktep->val[1],
3186 ktep->val[2] ? (char *)ktep->val[2] : "",
3187 (long)ktep->val[0] >> 16,
3188 (xfs_mount_t *)ktep->val[3]);
3189 kdb_printf(" agno %ld agbno %ld len %ld slot %ld tp 0x%p\n",
3190 (unsigned long)ktep->val[4],
3191 (unsigned long)ktep->val[5],
3192 (unsigned long)ktep->val[6],
3193 (unsigned long)ktep->val[7],
3194 (xfs_trans_t *)ktep->val[8]);
3197 kdb_printf("unknown alloc trace record\n");
3202 #endif /* XFS_ALLOC_TRACE */
3204 #ifdef XFS_ATTR_TRACE
3206 * Print an attribute trace buffer entry.
3209 xfs_attr_trace_entry(ktrace_entry_t *ktep)
3211 static char *attr_arg_flags[] = {
3212 "DONTFOLLOW", /* 0x0001 */
3213 "ROOT", /* 0x0002 */
3214 "TRUSTED", /* 0x0004 */
3215 "SECURE", /* 0x0008 */
3216 "CREATE", /* 0x0010 */
3217 "REPLACE", /* 0x0020 */
3220 "SYSTEM", /* 0x0100 */
3224 "KERNOTIME", /* 0x1000 */
3225 "KERNOVAL", /* 0x2000 */
3226 "KERNAMELS", /* 0x4000 */
3227 "KERNFULLS", /* 0x8000 */
3234 qprintf("-- %s: cursor h/b/o 0x%lx/0x%lx/%lu, dupcnt %lu, dp 0x%p\n",
3235 (char *)ktep->val[1],
3236 (unsigned long)ktep->val[3],
3237 (unsigned long)ktep->val[4],
3238 (unsigned long)ktep->val[5],
3239 (unsigned long)ktep->val[11],
3240 (xfs_inode_t *)ktep->val[2]);
3241 qprintf(" alist 0x%p, size %lu, count %lu, firstu %lu, Llen %lu",
3242 (attrlist_t *)ktep->val[6],
3243 (unsigned long)ktep->val[7],
3244 (unsigned long)ktep->val[8],
3245 (unsigned long)ktep->val[9],
3246 (unsigned long)ktep->val[10]);
3247 printflags((__psunsigned_t)(ktep->val[12]), attr_arg_flags, ", flags");
3250 switch ((__psint_t)ktep->val[0]) {
3251 case XFS_ATTR_KTRACE_L_C:
3253 case XFS_ATTR_KTRACE_L_CN:
3254 qprintf(" node: count %lu, 1st hash 0x%lx, last hash 0x%lx\n",
3255 (unsigned long)ktep->val[13],
3256 (unsigned long)ktep->val[14],
3257 (unsigned long)ktep->val[15]);
3259 case XFS_ATTR_KTRACE_L_CB:
3260 qprintf(" btree: hash 0x%lx, blkno 0x%lx\n",
3261 (unsigned long)ktep->val[13],
3262 (unsigned long)ktep->val[14]);
3264 case XFS_ATTR_KTRACE_L_CL:
3265 qprintf(" leaf: count %ld, 1st hash 0x%lx, last hash 0x%lx\n",
3266 (unsigned long)ktep->val[13],
3267 (unsigned long)ktep->val[14],
3268 (unsigned long)ktep->val[15]);
3271 qprintf(" unknown attr trace record format\n");
3276 #endif /* XFS_ATTR_TRACE */
3278 #ifdef XFS_BMAP_TRACE
3280 * Print xfs bmap extent trace buffer entry.
3283 xfs_bmap_trace_entry(ktrace_entry_t *ktep)
3292 static char *ops[] = { "del", "ins", "pre", "post" };
3293 xfs_bmbt_rec_32_t r;
3296 opcode = ((__psint_t)ktep->val[0]) & 0xffff;
3299 whichfork = ((__psint_t)ktep->val[0]) >> 16;
3300 ip = (xfs_inode_t *)ktep->val[3];
3301 ino = ((xfs_ino_t)(unsigned long)ktep->val[6] << 32) |
3302 ((xfs_ino_t)(unsigned long)ktep->val[7]);
3303 qprintf("%s %s:%s ip %p ino %s %cf\n",
3304 ops[opcode - 1], (char *)ktep->val[1],
3305 (char *)ktep->val[2], ip, xfs_fmtino(ino, ip->i_mount),
3307 r.l0 = (xfs_bmbt_rec_base_t)(unsigned long)ktep->val[8];
3308 r.l1 = (xfs_bmbt_rec_base_t)(unsigned long)ktep->val[9];
3309 r.l2 = (xfs_bmbt_rec_base_t)(unsigned long)ktep->val[10];
3310 r.l3 = (xfs_bmbt_rec_base_t)(unsigned long)ktep->val[11];
3311 xfs_convert_extent(&r, &o, &b, &c, &flag);
3312 qprintf(" idx %ld offset %lld block %s",
3313 (long)ktep->val[4], o,
3314 xfs_fmtfsblock((xfs_fsblock_t)b, ip->i_mount));
3315 qprintf(" count %lld flag %d\n", c, flag);
3316 if ((__psint_t)ktep->val[5] != 2)
3318 r.l0 = (xfs_bmbt_rec_base_t)(unsigned long)ktep->val[12];
3319 r.l1 = (xfs_bmbt_rec_base_t)(unsigned long)ktep->val[13];
3320 r.l2 = (xfs_bmbt_rec_base_t)(unsigned long)ktep->val[14];
3321 r.l3 = (xfs_bmbt_rec_base_t)(unsigned long)ktep->val[15];
3322 xfs_convert_extent(&r, &o, &b, &c, &flag);
3323 qprintf(" offset %lld block %s", o,
3324 xfs_fmtfsblock((xfs_fsblock_t)b, ip->i_mount));
3325 qprintf(" count %lld flag %d\n", c, flag);
3330 * Print xfs bmap btree trace buffer entry.
3333 xfs_bmbt_trace_entry(
3334 ktrace_entry_t *ktep)
3337 xfs_bmbt_rec_32_t r;
3342 type = (__psint_t)ktep->val[0] & 0xff;
3345 whichfork = ((__psint_t)ktep->val[0] >> 8) & 0xff;
3346 line = ((__psint_t)ktep->val[0] >> 16) & 0xffff;
3347 qprintf("%s[%s@%d] ip 0x%p %cf cur 0x%p\n",
3348 (char *)ktep->val[1],
3349 (char *)ktep->val[2],
3351 (xfs_inode_t *)ktep->val[3],
3353 (xfs_btree_cur_t *)ktep->val[4]);
3355 case XFS_BMBT_KTRACE_ARGBI:
3356 qprintf(" buf 0x%p i %ld\n",
3357 (xfs_buf_t *)ktep->val[5],
3358 (long)ktep->val[6]);
3360 case XFS_BMBT_KTRACE_ARGBII:
3361 qprintf(" buf 0x%p i0 %ld i1 %ld\n",
3362 (xfs_buf_t *)ktep->val[5],
3364 (long)ktep->val[7]);
3366 case XFS_BMBT_KTRACE_ARGFFFI:
3367 qprintf(" o 0x%x%08x b 0x%x%08x i 0x%x%08x j %ld\n",
3368 (unsigned int)(long)ktep->val[5],
3369 (unsigned int)(long)ktep->val[6],
3370 (unsigned int)(long)ktep->val[7],
3371 (unsigned int)(long)ktep->val[8],
3372 (unsigned int)(long)ktep->val[9],
3373 (unsigned int)(long)ktep->val[10],
3374 (long)ktep->val[11]);
3376 case XFS_BMBT_KTRACE_ARGI:
3377 qprintf(" i 0x%lx\n",
3378 (long)ktep->val[5]);
3380 case XFS_BMBT_KTRACE_ARGIFK:
3381 qprintf(" i 0x%lx f 0x%x%08x o 0x%x%08x\n",
3383 (unsigned int)(long)ktep->val[6],
3384 (unsigned int)(long)ktep->val[7],
3385 (unsigned int)(long)ktep->val[8],
3386 (unsigned int)(long)ktep->val[9]);
3388 case XFS_BMBT_KTRACE_ARGIFR:
3389 qprintf(" i 0x%lx f 0x%x%08x ",
3391 (unsigned int)(long)ktep->val[6],
3392 (unsigned int)(long)ktep->val[7]);
3393 s.br_startoff = (xfs_fileoff_t)
3394 (((xfs_dfiloff_t)(unsigned long)ktep->val[8] << 32) |
3395 (xfs_dfiloff_t)(unsigned long)ktep->val[9]);
3396 s.br_startblock = (xfs_fsblock_t)
3397 (((xfs_dfsbno_t)(unsigned long)ktep->val[10] << 32) |
3398 (xfs_dfsbno_t)(unsigned long)ktep->val[11]);
3399 s.br_blockcount = (xfs_filblks_t)
3400 (((xfs_dfilblks_t)(unsigned long)ktep->val[12] << 32) |
3401 (xfs_dfilblks_t)(unsigned long)ktep->val[13]);
3404 case XFS_BMBT_KTRACE_ARGIK:
3405 qprintf(" i 0x%lx o 0x%x%08x\n",
3407 (unsigned int)(long)ktep->val[6],
3408 (unsigned int)(long)ktep->val[7]);
3410 case XFS_BMBT_KTRACE_CUR:
3411 qprintf(" nlevels %ld flags %ld allocated %ld ",
3412 ((long)ktep->val[5] >> 24) & 0xff,
3413 ((long)ktep->val[5] >> 16) & 0xff,
3414 (long)ktep->val[5] & 0xffff);
3415 r.l0 = (xfs_bmbt_rec_base_t)(unsigned long)ktep->val[6];
3416 r.l1 = (xfs_bmbt_rec_base_t)(unsigned long)ktep->val[7];
3417 r.l2 = (xfs_bmbt_rec_base_t)(unsigned long)ktep->val[8];
3418 r.l3 = (xfs_bmbt_rec_base_t)(unsigned long)ktep->val[9];
3419 xfsidbg_xbrec((xfs_bmbt_rec_64_t *)&r);
3420 qprintf(" bufs 0x%p 0x%p 0x%p 0x%p ",
3421 (xfs_buf_t *)ktep->val[10],
3422 (xfs_buf_t *)ktep->val[11],
3423 (xfs_buf_t *)ktep->val[12],
3424 (xfs_buf_t *)ktep->val[13]);
3425 qprintf("ptrs %ld %ld %ld %ld\n",
3426 (long)ktep->val[14] >> 16,
3427 (long)ktep->val[14] & 0xffff,
3428 (long)ktep->val[15] >> 16,
3429 (long)ktep->val[15] & 0xffff);
3432 qprintf("unknown bmbt trace record\n");
3440 * Print an xfs in-inode bmap btree root.
3443 xfs_broot(xfs_inode_t *ip, xfs_ifork_t *f)
3445 xfs_bmbt_block_t *broot;
3451 format = f == &ip->i_df ? ip->i_d.di_format : ip->i_d.di_aformat;
3452 if ((f->if_flags & XFS_IFBROOT) == 0 ||
3453 format != XFS_DINODE_FMT_BTREE) {
3454 kdb_printf("inode 0x%p not btree format\n", ip);
3457 broot = f->if_broot;
3458 kdb_printf("block @0x%p magic %x level %d numrecs %d\n",
3460 be32_to_cpu(broot->bb_magic),
3461 be16_to_cpu(broot->bb_level),
3462 be16_to_cpu(broot->bb_numrecs));
3463 kp = XFS_BMAP_BROOT_KEY_ADDR(broot, 1, f->if_broot_bytes);
3464 pp = XFS_BMAP_BROOT_PTR_ADDR(broot, 1, f->if_broot_bytes);
3465 for (i = 1; i <= be16_to_cpu(broot->bb_numrecs); i++)
3466 kdb_printf("\t%d: startoff %Ld ptr %Lx %s\n",
3467 i, INT_GET(kp[i - 1].br_startoff, ARCH_CONVERT), INT_GET(pp[i - 1], ARCH_CONVERT),
3468 xfs_fmtfsblock(INT_GET(pp[i - 1], ARCH_CONVERT), ip->i_mount));
3472 * Print allocation btree block.
3475 xfs_btalloc(xfs_alloc_block_t *bt, int bsz)
3479 kdb_printf("magic 0x%x level %d numrecs %d leftsib 0x%x rightsib 0x%x\n",
3480 be32_to_cpu(bt->bb_magic),
3481 be16_to_cpu(bt->bb_level),
3482 be16_to_cpu(bt->bb_numrecs),
3483 be32_to_cpu(bt->bb_leftsib),
3484 be32_to_cpu(bt->bb_rightsib));
3485 if (!bt->bb_level) {
3486 for (i = 1; i <= be16_to_cpu(bt->bb_numrecs); i++) {
3489 r = XFS_BTREE_REC_ADDR(bsz, xfs_alloc, bt, i, 0);
3490 kdb_printf("rec %d startblock 0x%x blockcount %d\n",
3492 be32_to_cpu(r->ar_startblock),
3493 be32_to_cpu(r->ar_blockcount));
3498 mxr = XFS_BTREE_BLOCK_MAXRECS(bsz, xfs_alloc, 0);
3499 for (i = 1; i <= be16_to_cpu(bt->bb_numrecs); i++) {
3503 k = XFS_BTREE_KEY_ADDR(bsz, xfs_alloc, bt, i, mxr);
3504 p = XFS_BTREE_PTR_ADDR(bsz, xfs_alloc, bt, i, mxr);
3505 kdb_printf("key %d startblock 0x%x blockcount %d ptr 0x%x\n",
3507 be32_to_cpu(k->ar_startblock),
3508 be32_to_cpu(k->ar_blockcount),
3515 * Print a bmap btree block.
3518 xfs_btbmap(xfs_bmbt_block_t *bt, int bsz)
3522 kdb_printf("magic 0x%x level %d numrecs %d leftsib %Lx rightsib %Lx\n",
3523 be32_to_cpu(bt->bb_magic),
3524 be16_to_cpu(bt->bb_level),
3525 be16_to_cpu(bt->bb_numrecs),
3526 be64_to_cpu(bt->bb_leftsib),
3527 be64_to_cpu(bt->bb_rightsib));
3528 if (!bt->bb_level) {
3529 for (i = 1; i <= be16_to_cpu(bt->bb_numrecs); i++) {
3531 xfs_bmbt_irec_t irec;
3533 r = (xfs_bmbt_rec_t *)XFS_BTREE_REC_ADDR(bsz,
3534 xfs_bmbt, bt, i, 0);
3536 xfs_bmbt_disk_get_all((xfs_bmbt_rec_t *)r, &irec);
3537 kdb_printf("rec %d startoff %Ld startblock %Lx blockcount %Ld flag %d\n",
3538 i, irec.br_startoff,
3539 (__uint64_t)irec.br_startblock,
3540 irec.br_blockcount, irec.br_state);
3545 mxr = XFS_BTREE_BLOCK_MAXRECS(bsz, xfs_bmbt, 0);
3546 for (i = 1; i <= be16_to_cpu(bt->bb_numrecs); i++) {
3550 k = XFS_BTREE_KEY_ADDR(bsz, xfs_bmbt, bt, i, mxr);
3551 p = XFS_BTREE_PTR_ADDR(bsz, xfs_bmbt, bt, i, mxr);
3552 kdb_printf("key %d startoff %Ld ",
3553 i, INT_GET(k->br_startoff, ARCH_CONVERT));
3554 kdb_printf("ptr %Lx\n", INT_GET(*p, ARCH_CONVERT));
3560 * Print an inode btree block.
3563 xfs_btino(xfs_inobt_block_t *bt, int bsz)
3567 kdb_printf("magic 0x%x level %d numrecs %d leftsib 0x%x rightsib 0x%x\n",
3568 be32_to_cpu(bt->bb_magic),
3569 be16_to_cpu(bt->bb_level),
3570 be16_to_cpu(bt->bb_numrecs),
3571 be32_to_cpu(bt->bb_leftsib),
3572 be32_to_cpu(bt->bb_rightsib));
3573 if (!bt->bb_level) {
3574 for (i = 1; i <= be16_to_cpu(bt->bb_numrecs); i++) {
3577 r = XFS_BTREE_REC_ADDR(bsz, xfs_inobt, bt, i, 0);
3578 kdb_printf("rec %d startino 0x%x freecount %d, free %Lx\n",
3579 i, INT_GET(r->ir_startino, ARCH_CONVERT),
3580 INT_GET(r->ir_freecount, ARCH_CONVERT),
3581 INT_GET(r->ir_free, ARCH_CONVERT));
3586 mxr = XFS_BTREE_BLOCK_MAXRECS(bsz, xfs_inobt, 0);
3587 for (i = 1; i <= be16_to_cpu(bt->bb_numrecs); i++) {
3591 k = XFS_BTREE_KEY_ADDR(bsz, xfs_inobt, bt, i, mxr);
3592 p = XFS_BTREE_PTR_ADDR(bsz, xfs_inobt, bt, i, mxr);
3593 kdb_printf("key %d startino 0x%x ptr 0x%x\n",
3594 i, INT_GET(k->ir_startino, ARCH_CONVERT),
3601 * Print a buf log item.
3604 xfs_buf_item_print(xfs_buf_log_item_t *blip, int summary)
3606 static char *bli_flags[] = {
3611 "ialloc", /* 0x10 */
3612 "inode_stale", /* 0x20 */
3615 static char *blf_flags[] = {
3622 kdb_printf("buf 0x%p blkno 0x%Lx ", blip->bli_buf,
3623 blip->bli_format.blf_blkno);
3624 printflags(blip->bli_flags, bli_flags, "flags:");
3626 xfsidbg_xbuf_real(blip->bli_buf, 1);
3629 kdb_printf("buf 0x%p recur %d refcount %d flags:",
3630 blip->bli_buf, blip->bli_recur,
3631 atomic_read(&blip->bli_refcount));
3632 printflags(blip->bli_flags, bli_flags, NULL);
3634 kdb_printf("size %d blkno 0x%Lx len 0x%x map size %d map 0x%p\n",
3635 blip->bli_format.blf_size, blip->bli_format.blf_blkno,
3636 (uint) blip->bli_format.blf_len, blip->bli_format.blf_map_size,
3637 &(blip->bli_format.blf_data_map[0]));
3638 kdb_printf("blf flags: ");
3639 printflags((uint)blip->bli_format.blf_flags, blf_flags, NULL);
3640 #ifdef XFS_TRANS_DEBUG
3641 kdb_printf("orig 0x%x logged 0x%x",
3642 blip->bli_orig, blip->bli_logged);
3647 #ifdef XFS_BMAP_TRACE
3649 * Convert an external extent descriptor to internal form.
3652 xfs_convert_extent(xfs_bmbt_rec_32_t *rp, xfs_dfiloff_t *op, xfs_dfsbno_t *sp,
3653 xfs_dfilblks_t *cp, int *fp)
3660 flag = (((xfs_dfiloff_t)rp->l0) >> 31) & 1;
3661 o = ((((xfs_dfiloff_t)rp->l0) & 0x7fffffff) << 23) |
3662 (((xfs_dfiloff_t)rp->l1) >> 9);
3663 s = (((xfs_dfsbno_t)(rp->l1 & 0x000001ff)) << 43) |
3664 (((xfs_dfsbno_t)rp->l2) << 11) |
3665 (((xfs_dfsbno_t)rp->l3) >> 21);
3666 c = (xfs_dfilblks_t)(rp->l3 & 0x001fffff);
3676 * Print itrunc entry trace.
3679 xfs_ctrunc_trace_entry(ktrace_entry_t *ktep)
3681 qprintf("ip 0x%p cpu %ld\n",
3682 (xfs_inode_t *)(unsigned long)ktep->val[1], (long)ktep->val[2]);
3687 * Print an xfs_da_state_path structure.
3690 xfs_dastate_path(xfs_da_state_path_t *p)
3694 kdb_printf("active %d\n", p->active);
3695 for (i = 0; i < XFS_DA_NODE_MAXDEPTH; i++) {
3696 kdb_printf(" blk %d bp 0x%p blkno 0x%x",
3697 i, p->blk[i].bp, p->blk[i].blkno);
3698 kdb_printf(" index %d hashval 0x%x ",
3699 p->blk[i].index, (uint_t)p->blk[i].hashval);
3700 switch(p->blk[i].magic) {
3701 case XFS_DA_NODE_MAGIC: kdb_printf("NODE\n"); break;
3702 case XFS_DIR_LEAF_MAGIC: kdb_printf("DIR\n"); break;
3703 case XFS_ATTR_LEAF_MAGIC: kdb_printf("ATTR\n"); break;
3704 case XFS_DIR2_LEAFN_MAGIC: kdb_printf("DIR2\n"); break;
3705 default: kdb_printf("type ?\n"); break;
3710 #ifdef XFS_DIR_TRACE
3712 * Print a xfs directory trace buffer entry.
3715 xfs_dir_trace_entry(ktrace_entry_t *ktep)
3721 if (!ktep->val[0] || !ktep->val[1])
3724 mp = (xfs_mount_t *)ktep->val[3];
3725 cookie = (__psunsigned_t)ktep->val[4];
3727 cookie |= (__psunsigned_t)ktep->val[5];
3728 qprintf("%s -- dp=0x%p b/e/h=%ld/%ld/0x%08lx resid=0x%lx ",
3729 (char *)ktep->val[1],
3730 (xfs_inode_t *)ktep->val[2],
3731 (long)XFS_DA_COOKIE_BNO(mp, cookie),
3732 (long)XFS_DA_COOKIE_ENTRY(mp, cookie),
3733 (unsigned long)XFS_DA_COOKIE_HASH(mp, cookie),
3734 (long)ktep->val[6]);
3736 switch ((__psint_t)ktep->val[0]) {
3737 case XFS_DIR_KTRACE_G_DU:
3739 case XFS_DIR_KTRACE_G_DUB:
3740 qprintf("bno=%ld", (long)ktep->val[7]);
3742 case XFS_DIR_KTRACE_G_DUN:
3743 qprintf("forw=%ld, cnt=%ld, 0x%08lx - 0x%08lx",
3746 (unsigned long)ktep->val[9],
3747 (unsigned long)ktep->val[10]);
3749 case XFS_DIR_KTRACE_G_DUL:
3750 qprintf("forw=%ld, cnt=%ld, 0x%08lx - 0x%08lx",
3753 (unsigned long)ktep->val[9],
3754 (unsigned long)ktep->val[10]);
3756 case XFS_DIR_KTRACE_G_DUE:
3757 qprintf("entry hashval 0x%08lx", (unsigned long)ktep->val[7]);
3759 case XFS_DIR_KTRACE_G_DUC:
3760 cookie = (__psunsigned_t)ktep->val[7];
3762 cookie |= (__psunsigned_t)ktep->val[8];
3763 hash = XFS_DA_COOKIE_HASH(mp, cookie);
3764 qprintf("b/e/h=%ld/%ld/0x%08x",
3765 (long)XFS_DA_COOKIE_BNO(mp, cookie),
3766 (long)XFS_DA_COOKIE_ENTRY(mp, cookie),
3770 qprintf("unknown dir trace record format");
3777 #ifdef XFS_DIR2_TRACE
3779 * Print a xfs v2 directory trace buffer entry.
3782 xfs_dir2_trace_entry(ktrace_entry_t *ktep)
3790 cp = (char *)&ktep->val[10];
3791 qprintf("%s: '", (char *)ktep->val[1]);
3792 len = min((__psint_t)ktep->val[9], (__psint_t)sizeof(ktep->val[10])*6);
3793 for (i = 0; i < len; i++)
3794 qprintf("%c", cp[i]);
3795 qprintf("'(%ld)", (long)ktep->val[9]);
3796 if ((__psunsigned_t)ktep->val[0] != XFS_DIR2_KTRACE_ARGS_BIBII)
3797 qprintf(" hashval 0x%llx inumber %lld dp 0x%p tp 0x%p check %d",
3798 (__uint64_t)(unsigned long)ktep->val[2],
3799 (__int64_t)(unsigned long)ktep->val[3],
3800 ktep->val[4], ktep->val[5],
3801 (int)(__psint_t)ktep->val[6]);
3802 switch ((__psunsigned_t)ktep->val[0]) {
3803 case XFS_DIR2_KTRACE_ARGS:
3805 case XFS_DIR2_KTRACE_ARGS_B:
3806 qprintf(" bp 0x%p", ktep->val[7]);
3808 case XFS_DIR2_KTRACE_ARGS_BB:
3809 qprintf(" lbp 0x%p dbp 0x%p", ktep->val[7], ktep->val[8]);
3811 case XFS_DIR2_KTRACE_ARGS_BIBII:
3812 qprintf(" dp 0x%p tp 0x%p srcbp 0x%p srci %d dstbp 0x%p dsti %d count %d",
3813 ktep->val[2], ktep->val[3], ktep->val[4],
3814 (int)(__psint_t)ktep->val[5], ktep->val[6],
3815 (int)(__psint_t)ktep->val[7],
3816 (int)(__psint_t)ktep->val[8]);
3818 case XFS_DIR2_KTRACE_ARGS_DB:
3819 qprintf(" db 0x%x bp 0x%p",
3820 (xfs_dir2_db_t)(unsigned long)ktep->val[7],
3823 case XFS_DIR2_KTRACE_ARGS_I:
3824 qprintf(" i 0x%lx", (unsigned long)ktep->val[7]);
3826 case XFS_DIR2_KTRACE_ARGS_S:
3827 qprintf(" s 0x%x", (int)(__psint_t)ktep->val[7]);
3829 case XFS_DIR2_KTRACE_ARGS_SB:
3830 qprintf(" s 0x%x bp 0x%p", (int)(__psint_t)ktep->val[7],
3834 qprintf("unknown dirv2 trace record format");
3842 * Print an efd log item.
3845 xfs_efd_item_print(xfs_efd_log_item_t *efdp, int summary)
3851 kdb_printf("Extent Free Done: ID 0x%Lx nextents %d (at 0x%p)\n",
3852 efdp->efd_format.efd_efi_id,
3853 efdp->efd_format.efd_nextents, efdp);
3856 kdb_printf("size %d nextents %d next extent %d efip 0x%p\n",
3857 efdp->efd_format.efd_size, efdp->efd_format.efd_nextents,
3858 efdp->efd_next_extent, efdp->efd_efip);
3859 kdb_printf("efi_id 0x%Lx\n", efdp->efd_format.efd_efi_id);
3860 kdb_printf("efd extents:\n");
3861 ep = &(efdp->efd_format.efd_extents[0]);
3862 for (i = 0; i < efdp->efd_next_extent; i++, ep++) {
3863 kdb_printf(" block %Lx len %d\n",
3864 ep->ext_start, ep->ext_len);
3869 * Print an efi log item.
3872 xfs_efi_item_print(xfs_efi_log_item_t *efip, int summary)
3876 static char *efi_flags[] = {
3877 "recovered", /* 0x1 */
3878 "committed", /* 0x2 */
3879 "cancelled", /* 0x4 */
3884 kdb_printf("Extent Free Intention: ID 0x%Lx nextents %d (at 0x%p)\n",
3885 efip->efi_format.efi_id,
3886 efip->efi_format.efi_nextents, efip);
3889 kdb_printf("size %d nextents %d next extent %d\n",
3890 efip->efi_format.efi_size, efip->efi_format.efi_nextents,
3891 efip->efi_next_extent);
3892 kdb_printf("id %Lx", efip->efi_format.efi_id);
3893 printflags(efip->efi_flags, efi_flags, "flags :");
3895 kdb_printf("efi extents:\n");
3896 ep = &(efip->efi_format.efi_extents[0]);
3897 for (i = 0; i < efip->efi_next_extent; i++, ep++) {
3898 kdb_printf(" block %Lx len %d\n",
3899 ep->ext_start, ep->ext_len);
3904 * Format inode "format" into a static buffer & return it.
3907 xfs_fmtformat(xfs_dinode_fmt_t f)
3909 static char *t[] = {
3921 * Format fsblock number into a static buffer & return it.
3924 xfs_fmtfsblock(xfs_fsblock_t bno, xfs_mount_t *mp)
3926 static char rval[50];
3928 if (bno == NULLFSBLOCK)
3929 sprintf(rval, "NULLFSBLOCK");
3930 else if (ISNULLSTARTBLOCK(bno))
3931 sprintf(rval, "NULLSTARTBLOCK(%Ld)", STARTBLOCKVAL(bno));
3933 sprintf(rval, "%Ld[%x:%x]", (xfs_dfsbno_t)bno,
3934 XFS_FSB_TO_AGNO(mp, bno), XFS_FSB_TO_AGBNO(mp, bno));
3936 sprintf(rval, "%Ld", (xfs_dfsbno_t)bno);
3941 * Format inode number into a static buffer & return it.
3944 xfs_fmtino(xfs_ino_t ino, xfs_mount_t *mp)
3946 static char rval[50];
3949 sprintf(rval, "%llu[%x:%x:%x]",
3950 (unsigned long long) ino,
3951 XFS_INO_TO_AGNO(mp, ino),
3952 XFS_INO_TO_AGBNO(mp, ino),
3953 XFS_INO_TO_OFFSET(mp, ino));
3955 sprintf(rval, "%llu", (unsigned long long) ino);
3960 * Format an lsn for printing into a static buffer & return it.
3963 xfs_fmtlsn(xfs_lsn_t *lsnp)
3967 static char buf[20];
3969 wordp = (uint *)lsnp;
3971 sprintf(buf, "[%u:%u]", *wordp, *word2p);
3977 * Format file mode into a static buffer & return it.
3982 static char rval[16];
3984 sprintf(rval, "%c%c%c%c%c%c%c%c%c%c%c%c%c",
3985 "?fc?dxb?r?l?S?m?"[(m & S_IFMT) >> 12],
3986 m & S_ISUID ? 'u' : '-',
3987 m & S_ISGID ? 'g' : '-',
3988 m & S_ISVTX ? 'v' : '-',
3989 m & S_IRUSR ? 'r' : '-',
3990 m & S_IWUSR ? 'w' : '-',
3991 m & S_IXUSR ? 'x' : '-',
3992 m & S_IRGRP ? 'r' : '-',
3993 m & S_IWGRP ? 'w' : '-',
3994 m & S_IXGRP ? 'x' : '-',
3995 m & S_IROTH ? 'r' : '-',
3996 m & S_IWOTH ? 'w' : '-',
3997 m & S_IXOTH ? 'x' : '-');
4002 * Format a size into a static buffer & return it.
4005 xfs_fmtsize(size_t i)
4007 static char rval[20];
4009 /* size_t is 32 bits in 32-bit kernel, 64 bits in 64-bit kernel */
4010 sprintf(rval, "0x%lx", (unsigned long) i);
4015 * Format a uuid into a static buffer & return it.
4018 xfs_fmtuuid(uuid_t *uu)
4020 static char rval[40];
4022 char *i = (unsigned char*)uu;
4025 for (b=0;b<16;b++) {
4026 o+=sprintf(o, "%02x", *i++);
4027 if (b==3||b==5||b==7||b==9) *o++='-';
4035 * Print an inode log item.
4038 xfs_inode_item_print(xfs_inode_log_item_t *ilip, int summary)
4040 static char *ili_flags[] = {
4042 "iolock excl", /* 0x2 */
4043 "iolock shrd", /* 0x4 */
4046 static char *ilf_fields[] = {
4048 "ddata", /* 0x002 */
4049 "dexts", /* 0x004 */
4050 "dbroot", /* 0x008 */
4053 "adata", /* 0x040 */
4055 "abroot", /* 0x100 */
4060 kdb_printf("inode 0x%p logged %d ",
4061 ilip->ili_inode, ilip->ili_logged);
4062 printflags(ilip->ili_flags, ili_flags, "flags:");
4063 printflags(ilip->ili_format.ilf_fields, ilf_fields, "format:");
4064 printflags(ilip->ili_last_fields, ilf_fields, "lastfield:");
4068 kdb_printf("inode 0x%p ino 0x%llu pushbuf %d logged %d flags: ",
4069 ilip->ili_inode, (unsigned long long) ilip->ili_format.ilf_ino,
4070 ilip->ili_pushbuf_flag, ilip->ili_logged);
4071 printflags(ilip->ili_flags, ili_flags, NULL);
4073 kdb_printf("ilock recur %d iolock recur %d ext buf 0x%p\n",
4074 ilip->ili_ilock_recur, ilip->ili_iolock_recur,
4075 ilip->ili_extents_buf);
4076 #ifdef XFS_TRANS_DEBUG
4077 kdb_printf("root bytes %d root orig 0x%x\n",
4078 ilip->ili_root_size, ilip->ili_orig_root);
4080 kdb_printf("size %d ", ilip->ili_format.ilf_size);
4081 printflags(ilip->ili_format.ilf_fields, ilf_fields, "fields:");
4082 printflags(ilip->ili_last_fields, ilf_fields, " last fields: ");
4084 kdb_printf(" flush lsn %s last lsn %s\n",
4085 xfs_fmtlsn(&(ilip->ili_flush_lsn)),
4086 xfs_fmtlsn(&(ilip->ili_last_lsn)));
4087 kdb_printf("dsize %d, asize %d, rdev 0x%x\n",
4088 ilip->ili_format.ilf_dsize,
4089 ilip->ili_format.ilf_asize,
4090 ilip->ili_format.ilf_u.ilfu_rdev);
4091 kdb_printf("blkno 0x%Lx len 0x%x boffset 0x%x\n",
4092 ilip->ili_format.ilf_blkno,
4093 ilip->ili_format.ilf_len,
4094 ilip->ili_format.ilf_boffset);
4098 * Print a dquot log item.
4102 xfs_dquot_item_print(xfs_dq_logitem_t *lip, int summary)
4104 kdb_printf("dquot 0x%p\n",
4110 * Print a quotaoff log item.
4114 xfs_qoff_item_print(xfs_qoff_logitem_t *lip, int summary)
4116 kdb_printf("start qoff item 0x%p flags 0x%x\n",
4117 lip->qql_start_lip, lip->qql_format.qf_flags);
4122 * Print buffer full of inodes.
4125 xfs_inodebuf(xfs_buf_t *bp)
4128 xfs_dinode_core_t dic;
4131 n = XFS_BUF_COUNT(bp) >> 8;
4132 for (i = 0; i < n; i++) {
4133 di = (xfs_dinode_t *)xfs_buf_offset(bp,
4136 xfs_xlate_dinode_core((xfs_caddr_t)&di->di_core, &dic, 1);
4137 xfs_prdinode_core(&dic);
4138 kdb_printf("next_unlinked 0x%x u@0x%p\n",
4139 INT_GET(di->di_next_unlinked, ARCH_CONVERT),
4146 * Print iomap entry trace.
4149 xfs_iomap_enter_trace_entry(ktrace_entry_t *ktep)
4151 qprintf("ip 0x%p size 0x%x%x offset 0x%x%x count 0x%x\n",
4153 (unsigned int)(long)ktep->val[2],
4154 (unsigned int)(long)ktep->val[3],
4155 (unsigned int)(long)ktep->val[4],
4156 (unsigned int)(long)ktep->val[5],
4157 (unsigned int)(long)ktep->val[6]);
4158 qprintf("io new size 0x%x%x pid=%d\n",
4159 (unsigned int)(long)ktep->val[7],
4160 (unsigned int)(long)ktep->val[8],
4161 (unsigned int)(long)ktep->val[9]);
4165 * Print iomap map trace.
4168 xfs_iomap_map_trace_entry(ktrace_entry_t *ktep)
4170 static char *bmapi_flags[] = {
4171 "read", /* BMAPI_READ */
4172 "write", /* BMAPI_WRITE */
4173 "allocate", /* BMAPI_ALLOCATE */
4174 "unwritten", /* BMAPI_UNWRITTEN */
4175 "ignstate", /* BMAPI_IGNSTATE */
4176 "direct", /* BMAPI_DIRECT */
4177 "mmap", /* BMAPI_MMAP */
4178 "sync", /* BMAPI_SYNC */
4179 "trylock", /* BMAPI_TRYLOCK */
4180 "device", /* BMAPI_DEVICE */
4184 qprintf("ip 0x%p size 0x%x%x offset 0x%x%x count 0x%x\n",
4186 (unsigned int)(long)ktep->val[2],
4187 (unsigned int)(long)ktep->val[3],
4188 (unsigned int)(long)ktep->val[4],
4189 (unsigned int)(long)ktep->val[5],
4190 (unsigned int)(long)ktep->val[6]);
4191 printflags((__psint_t)ktep->val[7], bmapi_flags, "bmapi flags");
4192 qprintf("iomap off 0x%x%x delta 0x%x bsize 0x%x bno 0x%x\n",
4193 (unsigned int)(long)ktep->val[8],
4194 (unsigned int)(long)ktep->val[9],
4195 (unsigned int)(long)ktep->val[10],
4196 (unsigned int)(long)ktep->val[11],
4197 (unsigned int)(long)ktep->val[12]);
4198 qprintf("imap off 0x%x count 0x%x block 0x%x\n",
4199 (unsigned int)(long)ktep->val[13],
4200 (unsigned int)(long)ktep->val[14],
4201 (unsigned int)(long)ktep->val[15]);
4205 * Print itrunc entry trace.
4208 xfs_itrunc_trace_entry(ktrace_entry_t *ktep)
4210 qprintf("ip 0x%p size 0x%x%x flag %ld new size 0x%x%x\n",
4212 (unsigned int)(long)ktep->val[2],
4213 (unsigned int)(long)ktep->val[3],
4215 (unsigned int)(long)ktep->val[5],
4216 (unsigned int)(long)ktep->val[6]);
4217 qprintf("toss start 0x%x%x toss finish 0x%x%x cpu id %ld pid %d\n",
4218 (unsigned int)(long)ktep->val[7],
4219 (unsigned int)(long)ktep->val[8],
4220 (unsigned int)(long)ktep->val[9],
4221 (unsigned int)(long)ktep->val[10],
4222 (long)ktep->val[11],
4223 (unsigned int)(long)ktep->val[12]);
4227 * Print bunmap entry trace.
4230 xfs_bunmap_trace_entry(ktrace_entry_t *ktep)
4232 static char *bunmapi_flags[] = {
4235 "entire", /* 0x04 */
4236 "metadata", /* 0x08 */
4238 "attrfork", /* 0x20 */
4240 "rsvblocks", /* 0x80 */
4244 qprintf("ip 0x%p size 0x%x%x bno 0x%x%x len 0x%x cpu id %ld\n",
4246 (unsigned int)(long)ktep->val[2],
4247 (unsigned int)(long)ktep->val[3],
4248 (unsigned int)(long)ktep->val[4],
4249 (unsigned int)(long)ktep->val[5],
4250 (unsigned int)(long)ktep->val[6],
4251 (long)ktep->val[8]);
4252 qprintf("ra 0x%p pid %d ", ktep->val[9], (int)(long)ktep->val[10]);
4253 printflags((__psint_t)ktep->val[7], bunmapi_flags, "flags");
4257 * Print inval_cached_pages entry trace.
4260 xfs_inval_cached_trace_entry(ktrace_entry_t *ktep)
4262 qprintf("ip 0x%p offset 0x%x%x len 0x%x%x first 0x%x%x last 0x%x%x pid %d\n",
4264 (unsigned int)(long)ktep->val[2],
4265 (unsigned int)(long)ktep->val[3],
4266 (unsigned int)(long)ktep->val[4],
4267 (unsigned int)(long)ktep->val[5],
4268 (unsigned int)(long)ktep->val[6],
4269 (unsigned int)(long)ktep->val[7],
4270 (unsigned int)(long)ktep->val[8],
4271 (unsigned int)(long)ktep->val[9],
4272 (unsigned int)(long)ktep->val[10]);
4278 * Print disk inode core.
4281 xfs_prdinode_core(xfs_dinode_core_t *dip)
4283 static char *diflags[] = {
4284 "realtime", /* XFS_DIFLAG_REALTIME */
4285 "prealloc", /* XFS_DIFLAG_PREALLOC */
4286 "newrtbm", /* XFS_DIFLAG_NEWRTBM */
4287 "immutable", /* XFS_DIFLAG_IMMUTABLE */
4288 "append", /* XFS_DIFLAG_APPEND */
4289 "sync", /* XFS_DIFLAG_SYNC */
4290 "noatime", /* XFS_DIFLAG_NOATIME */
4291 "nodump", /* XFS_DIFLAG_NODUMP */
4292 "rtinherit", /* XFS_DIFLAG_RTINHERIT */
4293 "projinherit", /* XFS_DIFLAG_PROJINHERIT */
4294 "nosymlinks", /* XFS_DIFLAG_NOSYMLINKS */
4295 "extsize", /* XFS_DIFLAG_EXTSIZE */
4296 "extszinherit", /* XFS_DIFLAG_EXTSZINHERIT */
4300 kdb_printf("magic 0x%x mode 0%o (%s) version 0x%x format 0x%x (%s)\n",
4301 dip->di_magic, dip->di_mode,
4302 xfs_fmtmode(dip->di_mode),
4303 dip->di_version, dip->di_format,
4304 xfs_fmtformat((xfs_dinode_fmt_t)dip->di_format));
4305 kdb_printf("nlink %d uid %d gid %d projid %d flushiter %u\n",
4309 (uint)dip->di_projid,
4310 (uint)dip->di_flushiter);
4311 kdb_printf("atime %u:%u mtime %ud:%u ctime %u:%u\n",
4312 dip->di_atime.t_sec, dip->di_atime.t_nsec,
4313 dip->di_mtime.t_sec, dip->di_mtime.t_nsec,
4314 dip->di_ctime.t_sec, dip->di_ctime.t_nsec);
4315 kdb_printf("size %Ld ", dip->di_size);
4316 kdb_printf("nblocks %Ld extsize 0x%x nextents 0x%x anextents 0x%x\n",
4317 dip->di_nblocks, dip->di_extsize, dip->di_nextents,
4319 kdb_printf("forkoff %d aformat 0x%x (%s) dmevmask 0x%x dmstate 0x%x ",
4320 dip->di_forkoff, dip->di_aformat,
4321 xfs_fmtformat((xfs_dinode_fmt_t)dip->di_aformat),
4322 dip->di_dmevmask, dip->di_dmstate);
4323 printflags(dip->di_flags, diflags, "flags");
4324 kdb_printf("gen 0x%x\n", dip->di_gen);
4329 * Print read/write entry trace.
4332 xfs_rw_enter_trace_entry(ktrace_entry_t *ktep)
4334 qprintf("ip 0x%p size 0x%x%x ptr 0x%p size %lu\n",
4336 (unsigned int)(long)ktep->val[2],
4337 (unsigned int)(long)ktep->val[3],
4339 (unsigned long)ktep->val[5]);
4340 qprintf("io offset 0x%x%x ioflags 0x%x new size 0x%x%x pid %d\n",
4341 (unsigned int)(long)ktep->val[6],
4342 (unsigned int)(long)ktep->val[7],
4343 (unsigned int)(long)ktep->val[8],
4344 (unsigned int)(long)ktep->val[9],
4345 (unsigned int)(long)ktep->val[10],
4346 (unsigned int)(long)ktep->val[11]);
4350 * Print page write/release trace.
4353 xfs_page_trace_entry(ktrace_entry_t *ktep)
4355 qprintf("ip 0x%p inode 0x%p page 0x%p\n",
4356 ktep->val[1], ktep->val[2], ktep->val[3]);
4357 qprintf("mask 0x%x di_size 0x%x%x isize 0x%x%x offset 0x%x%x\n",
4358 (unsigned int)(long)ktep->val[4],
4359 (unsigned int)(long)ktep->val[5],
4360 (unsigned int)(long)ktep->val[6],
4361 (unsigned int)(long)ktep->val[7],
4362 (unsigned int)(long)ktep->val[8],
4363 (unsigned int)(long)ktep->val[9],
4364 (unsigned int)(long)ktep->val[10]);
4365 qprintf("delalloc %d unmapped %d unwritten %d pid %d\n",
4366 (unsigned int)(long)ktep->val[11],
4367 (unsigned int)(long)ktep->val[12],
4368 (unsigned int)(long)ktep->val[13],
4369 (unsigned int)(long)ktep->val[14]);
4373 * Print read/write trace entry.
4376 xfs_rw_trace_entry(ktrace_entry_t *ktep)
4378 switch ( (long)ktep->val[0] ) {
4379 case XFS_READ_ENTER:
4380 qprintf("READ ENTER:\n");
4381 xfs_rw_enter_trace_entry(ktep);
4383 case XFS_WRITE_ENTER:
4384 qprintf("WRITE ENTER:\n");
4385 xfs_rw_enter_trace_entry(ktep);
4387 case XFS_SENDFILE_ENTER:
4388 qprintf("SENDFILE ENTER:\n");
4389 xfs_rw_enter_trace_entry(ktep);
4391 case XFS_IOMAP_READ_ENTER:
4392 qprintf("IOMAP READ ENTER:\n");
4393 xfs_iomap_enter_trace_entry(ktep);
4395 case XFS_IOMAP_WRITE_ENTER:
4396 qprintf("IOMAP WRITE ENTER:\n");
4397 xfs_iomap_enter_trace_entry(ktep);
4399 case XFS_IOMAP_WRITE_NOSPACE:
4400 qprintf("IOMAP WRITE NOSPACE:\n");
4401 xfs_iomap_enter_trace_entry(ktep);
4403 case XFS_IOMAP_READ_MAP:
4404 qprintf("IOMAP READ MAP:\n");
4405 xfs_iomap_map_trace_entry(ktep);
4407 case XFS_IOMAP_WRITE_MAP:
4408 qprintf("IOMAP WRITE MAP:\n");
4409 xfs_iomap_map_trace_entry(ktep);
4411 case XFS_ITRUNC_START:
4412 qprintf("ITRUNC START:\n");
4413 xfs_itrunc_trace_entry(ktep);
4415 case XFS_ITRUNC_FINISH1:
4416 qprintf("ITRUNC FINISH1:\n");
4417 xfs_itrunc_trace_entry(ktep);
4419 case XFS_ITRUNC_FINISH2:
4420 qprintf("ITRUNC FINISH2:\n");
4421 xfs_itrunc_trace_entry(ktep);
4424 qprintf("CTRUNC1:\n");
4425 xfs_ctrunc_trace_entry(ktep);
4428 qprintf("CTRUNC2:\n");
4429 xfs_ctrunc_trace_entry(ktep);
4432 qprintf("CTRUNC3:\n");
4433 xfs_ctrunc_trace_entry(ktep);
4436 qprintf("CTRUNC4:\n");
4437 xfs_ctrunc_trace_entry(ktep);
4440 qprintf("CTRUNC5:\n");
4441 xfs_ctrunc_trace_entry(ktep);
4444 qprintf("CTRUNC6:\n");
4445 xfs_ctrunc_trace_entry(ktep);
4448 qprintf("BUNMAP:\n");
4449 xfs_bunmap_trace_entry(ktep);
4451 case XFS_INVAL_CACHED:
4452 qprintf("INVAL CACHED:\n");
4453 xfs_inval_cached_trace_entry(ktep);
4455 case XFS_DIORD_ENTER:
4456 qprintf("DIORD ENTER:\n");
4457 xfs_rw_enter_trace_entry(ktep);
4459 case XFS_DIOWR_ENTER:
4460 qprintf("DIOWR ENTER:\n");
4461 xfs_rw_enter_trace_entry(ktep);
4463 case XFS_WRITEPAGE_ENTER:
4464 qprintf("PAGE WRITE:\n");
4465 xfs_page_trace_entry(ktep);
4467 case XFS_RELEASEPAGE_ENTER:
4468 qprintf("PAGE RELEASE:\n");
4469 xfs_page_trace_entry(ktep);
4471 case XFS_INVALIDPAGE_ENTER:
4472 qprintf("PAGE INVALIDATE:\n");
4473 xfs_page_trace_entry(ktep);
4475 case XFS_IOMAP_ALLOC_ENTER:
4476 qprintf("ALLOC ENTER:\n");
4477 xfs_iomap_enter_trace_entry(ktep);
4479 case XFS_IOMAP_ALLOC_MAP:
4480 qprintf("ALLOC MAP:\n");
4481 xfs_iomap_map_trace_entry(ktep);
4483 case XFS_IOMAP_UNWRITTEN:
4484 qprintf("UNWRITTEN:\n");
4485 xfs_iomap_enter_trace_entry(ktep);
4489 qprintf("UNKNOWN RW TRACE\n");
4498 * Print xfs extent records for a fork.
4501 xfs_xexlist_fork(xfs_inode_t *ip, int whichfork)
4505 xfs_bmbt_irec_t irec;
4507 ifp = XFS_IFORK_PTR(ip, whichfork);
4508 if (ifp->if_flags & XFS_IFEXTENTS) {
4509 nextents = ifp->if_bytes / (uint)sizeof(xfs_bmbt_rec_t);
4510 kdb_printf("inode 0x%p %cf extents 0x%p nextents 0x%x\n",
4511 ip, "da"[whichfork], xfs_iext_get_ext(ifp, 0),
4513 for (i = 0; i < nextents; i++) {
4514 xfs_bmbt_get_all(xfs_iext_get_ext(ifp, i), &irec);
4516 "%d: startoff %Ld startblock %s blockcount %Ld flag %d\n",
4517 i, irec.br_startoff,
4518 xfs_fmtfsblock(irec.br_startblock, ip->i_mount),
4519 irec.br_blockcount, irec.br_state);
4525 xfs_xnode_fork(char *name, xfs_ifork_t *f)
4527 static char *tab_flags[] = {
4528 "inline", /* XFS_IFINLINE */
4529 "extents", /* XFS_IFEXTENTS */
4530 "broot", /* XFS_IFBROOT */
4535 kdb_printf("%s fork", name);
4537 kdb_printf(" empty\n");
4541 kdb_printf(" bytes %s ", xfs_fmtsize(f->if_bytes));
4542 kdb_printf("real_bytes %s lastex 0x%x u1:%s 0x%p\n",
4543 xfs_fmtsize(f->if_real_bytes), f->if_lastex,
4544 f->if_flags & XFS_IFINLINE ? "data" : "extents",
4545 f->if_flags & XFS_IFINLINE ?
4547 (char *)f->if_u1.if_extents);
4548 kdb_printf(" broot 0x%p broot_bytes %s ext_max %d ",
4549 f->if_broot, xfs_fmtsize(f->if_broot_bytes), f->if_ext_max);
4550 printflags(f->if_flags, tab_flags, "flags");
4553 for (p = (int *)&f->if_u2;
4554 p < (int *)((char *)&f->if_u2 + XFS_INLINE_DATA);
4556 kdb_printf(" 0x%x", *p);
4561 * Command-level xfs-idbg functions.
4565 * Print xfs allocation group freespace header.
4568 xfsidbg_xagf(xfs_agf_t *agf)
4570 kdb_printf("magicnum 0x%x versionnum 0x%x seqno 0x%x length 0x%x\n",
4571 be32_to_cpu(agf->agf_magicnum),
4572 be32_to_cpu(agf->agf_versionnum),
4573 be32_to_cpu(agf->agf_seqno),
4574 be32_to_cpu(agf->agf_length));
4575 kdb_printf("roots b 0x%x c 0x%x levels b %d c %d\n",
4576 be32_to_cpu(agf->agf_roots[XFS_BTNUM_BNO]),
4577 be32_to_cpu(agf->agf_roots[XFS_BTNUM_CNT]),
4578 be32_to_cpu(agf->agf_levels[XFS_BTNUM_BNO]),
4579 be32_to_cpu(agf->agf_levels[XFS_BTNUM_CNT]));
4580 kdb_printf("flfirst %d fllast %d flcount %d freeblks %d longest %d\n",
4581 be32_to_cpu(agf->agf_flfirst),
4582 be32_to_cpu(agf->agf_fllast),
4583 be32_to_cpu(agf->agf_flcount),
4584 be32_to_cpu(agf->agf_freeblks),
4585 be32_to_cpu(agf->agf_longest));
4589 * Print xfs allocation group inode header.
4592 xfsidbg_xagi(xfs_agi_t *agi)
4597 kdb_printf("magicnum 0x%x versionnum 0x%x seqno 0x%x length 0x%x\n",
4598 be32_to_cpu(agi->agi_magicnum),
4599 be32_to_cpu(agi->agi_versionnum),
4600 be32_to_cpu(agi->agi_seqno),
4601 be32_to_cpu(agi->agi_length));
4602 kdb_printf("count 0x%x root 0x%x level 0x%x\n",
4603 be32_to_cpu(agi->agi_count),
4604 be32_to_cpu(agi->agi_root),
4605 be32_to_cpu(agi->agi_level));
4606 kdb_printf("freecount 0x%x newino 0x%x dirino 0x%x\n",
4607 be32_to_cpu(agi->agi_freecount),
4608 be32_to_cpu(agi->agi_newino),
4609 be32_to_cpu(agi->agi_dirino));
4611 kdb_printf("unlinked buckets\n");
4612 for (i = 0; i < XFS_AGI_UNLINKED_BUCKETS; i++) {
4613 for (j = 0; j < 4; j++, i++) {
4614 kdb_printf("0x%08x ",
4615 be32_to_cpu(agi->agi_unlinked[i]));
4621 #ifdef XFS_ALLOC_TRACE
4623 * Print out the last "count" entries in the allocation trace buffer.
4626 xfsidbg_xalatrace(int count)
4628 ktrace_entry_t *ktep;
4633 if (xfs_alloc_trace_buf == NULL) {
4634 qprintf("The xfs alloc trace buffer is not initialized\n");
4637 nentries = ktrace_nentries(xfs_alloc_trace_buf);
4641 if ((count <= 0) || (count > nentries)) {
4642 qprintf("Invalid count. There are %d entries.\n", nentries);
4646 ktep = ktrace_first(xfs_alloc_trace_buf, &kts);
4647 if (count != nentries) {
4649 * Skip the total minus the number to look at minus one
4650 * for the entry returned by ktrace_first().
4652 skip_entries = nentries - count - 1;
4653 ktep = ktrace_skip(xfs_alloc_trace_buf, skip_entries, &kts);
4655 qprintf("Skipped them all\n");
4659 while (ktep != NULL) {
4660 if (xfs_alloc_trace_entry(ktep))
4662 ktep = ktrace_next(xfs_alloc_trace_buf, &kts);
4667 * Print out all the entries in the alloc trace buf corresponding
4668 * to the given block number.
4671 xfsidbg_xalbtrace(xfs_agblock_t bno)
4673 ktrace_entry_t *ktep;
4676 if (xfs_alloc_trace_buf == NULL) {
4677 qprintf("The xfs alloc trace buffer is not initialized\n");
4681 ktep = ktrace_first(xfs_alloc_trace_buf, &kts);
4682 while (ktep != NULL) {
4683 switch ((__psint_t)ktep->val[0]) {
4684 case XFS_ALLOC_KTRACE_ALLOC:
4685 case XFS_ALLOC_KTRACE_FREE:
4686 if (bno >= (xfs_agblock_t)((__psint_t)ktep->val[5]) &&
4687 bno < (xfs_agblock_t)((__psint_t)ktep->val[5]) +
4688 (xfs_extlen_t)((__psint_t)ktep->val[13])) {
4689 (void)xfs_alloc_trace_entry(ktep);
4694 ktep = ktrace_next(xfs_alloc_trace_buf, &kts);
4699 * Print out all the entries in the alloc trace buf corresponding
4700 * to the given allocation group.
4703 xfsidbg_xalgtrace(xfs_agnumber_t agno)
4705 ktrace_entry_t *ktep;
4708 if (xfs_alloc_trace_buf == NULL) {
4709 qprintf("The xfs alloc trace buffer is not initialized\n");
4713 ktep = ktrace_first(xfs_alloc_trace_buf, &kts);
4714 while (ktep != NULL) {
4715 if ( (__psint_t)ktep->val[0] &&
4716 ((xfs_agnumber_t)((__psint_t)ktep->val[4])) == agno ) {
4717 (void)xfs_alloc_trace_entry(ktep);
4720 ktep = ktrace_next(xfs_alloc_trace_buf, &kts);
4726 * Print an allocation argument structure for XFS.
4729 xfsidbg_xalloc(xfs_alloc_arg_t *args)
4731 kdb_printf("tp 0x%p mp 0x%p agbp 0x%p pag 0x%p fsbno %s\n",
4732 args->tp, args->mp, args->agbp, args->pag,
4733 xfs_fmtfsblock(args->fsbno, args->mp));
4734 kdb_printf("agno 0x%x agbno 0x%x minlen 0x%x maxlen 0x%x mod 0x%x\n",
4735 args->agno, args->agbno, args->minlen, args->maxlen, args->mod);
4736 kdb_printf("prod 0x%x minleft 0x%x total 0x%x alignment 0x%x\n",
4737 args->prod, args->minleft, args->total, args->alignment);
4738 kdb_printf("minalignslop 0x%x len 0x%x type %s otype %s wasdel %d\n",
4739 args->minalignslop, args->len, xfs_alloctype[args->type],
4740 xfs_alloctype[args->otype], args->wasdel);
4741 kdb_printf("wasfromfl %d isfl %d userdata %d\n",
4742 args->wasfromfl, args->isfl, args->userdata);
4745 #ifdef XFS_ALLOC_TRACE
4747 * Print out all the entries in the alloc trace buf corresponding
4748 * to the given mount point.
4751 xfsidbg_xalmtrace(xfs_mount_t *mp)
4753 ktrace_entry_t *ktep;
4756 if (xfs_alloc_trace_buf == NULL) {
4757 kdb_printf("The xfs alloc trace buffer is not initialized\n");
4761 ktep = ktrace_first(xfs_alloc_trace_buf, &kts);
4762 while (ktep != NULL) {
4763 if ((__psint_t)ktep->val[0] &&
4764 (xfs_mount_t *)ktep->val[3] == mp) {
4765 (void)xfs_alloc_trace_entry(ktep);
4768 ktep = ktrace_next(xfs_alloc_trace_buf, &kts);
4773 * Print out all the entries in the alloc trace buf corresponding
4774 * to the given entry type.
4777 xfsidbg_xalttrace(int tag)
4779 ktrace_entry_t *ktep;
4782 if (xfs_alloc_trace_buf == NULL) {
4783 qprintf("The xfs alloc trace buffer is not initialized\n");
4787 ktep = ktrace_first(xfs_alloc_trace_buf, &kts);
4788 while (ktep != NULL) {
4789 if ((__psint_t)ktep->val[0] &&
4790 ((long)ktep->val[0] & 0xffffL) == (long)tag) {
4791 (void)xfs_alloc_trace_entry(ktep);
4794 ktep = ktrace_next(xfs_alloc_trace_buf, &kts);
4799 static int xargument = 0;
4802 * Set xtra argument, used by xchksum.
4805 xfsidbg_xarg(int xarg)
4808 qprintf("xargument: %d\n", xargument);
4811 } /* xfsidbg_xarg */
4814 * Print an attr_list() context structure.
4817 xfsidbg_xattrcontext(xfs_attr_list_context_t *context)
4819 static char *attr_arg_flags[] = {
4820 "DONTFOLLOW", /* 0x0001 */
4824 "CREATE", /* 0x0010 */
4832 "KERNOTIME", /* 0x1000 */
4836 kdb_printf("dp 0x%p, dupcnt %d, resynch %d",
4837 context->dp, context->dupcnt, context->resynch);
4838 printflags((__psunsigned_t)context->flags, attr_arg_flags, ", flags");
4839 kdb_printf("\ncursor h/b/o 0x%x/0x%x/%d -- p/p/i 0x%x/0x%x/0x%x\n",
4840 context->cursor->hashval, context->cursor->blkno,
4841 context->cursor->offset, context->cursor->pad1,
4842 context->cursor->pad2, context->cursor->initted);
4843 kdb_printf("alist 0x%p, bufsize 0x%x, count %d, firstu 0x%x\n",
4844 context->alist, context->bufsize, context->count,
4849 * Print attribute leaf block.
4852 xfsidbg_xattrleaf(xfs_attr_leafblock_t *leaf)
4854 xfs_attr_leaf_hdr_t *h;
4855 xfs_da_blkinfo_t *i;
4856 xfs_attr_leaf_map_t *m;
4857 xfs_attr_leaf_entry_t *e;
4858 xfs_attr_leaf_name_local_t *l;
4859 xfs_attr_leaf_name_remote_t *r;
4864 kdb_printf("hdr info forw 0x%x back 0x%x magic 0x%x\n",
4865 i->forw, i->back, i->magic);
4866 kdb_printf("hdr count %d usedbytes %d firstused %d holes %d\n",
4867 INT_GET(h->count, ARCH_CONVERT),
4868 INT_GET(h->usedbytes, ARCH_CONVERT),
4869 INT_GET(h->firstused, ARCH_CONVERT), h->holes);
4870 for (j = 0, m = h->freemap; j < XFS_ATTR_LEAF_MAPSIZE; j++, m++) {
4871 kdb_printf("hdr freemap %d base %d size %d\n",
4872 j, INT_GET(m->base, ARCH_CONVERT),
4873 INT_GET(m->size, ARCH_CONVERT));
4875 for (j = 0, e = leaf->entries; j < INT_GET(h->count, ARCH_CONVERT); j++, e++) {
4876 kdb_printf("[%2d] hash 0x%x nameidx %d flags 0x%x",
4877 j, INT_GET(e->hashval, ARCH_CONVERT),
4878 INT_GET(e->nameidx, ARCH_CONVERT), e->flags);
4879 if (e->flags & XFS_ATTR_LOCAL)
4880 kdb_printf("LOCAL ");
4881 if (e->flags & XFS_ATTR_ROOT)
4882 kdb_printf("ROOT ");
4883 if (e->flags & XFS_ATTR_SECURE)
4884 kdb_printf("SECURE ");
4885 if (e->flags & XFS_ATTR_INCOMPLETE)
4886 kdb_printf("INCOMPLETE ");
4887 k = ~(XFS_ATTR_LOCAL | XFS_ATTR_ROOT |
4888 XFS_ATTR_SECURE | XFS_ATTR_INCOMPLETE);
4889 if ((e->flags & k) != 0)
4890 kdb_printf("0x%x", e->flags & k);
4891 kdb_printf(">\n name \"");
4892 if (e->flags & XFS_ATTR_LOCAL) {
4893 l = XFS_ATTR_LEAF_NAME_LOCAL(leaf, j);
4894 for (k = 0; k < l->namelen; k++)
4895 kdb_printf("%c", l->nameval[k]);
4896 kdb_printf("\"(%d) value \"", l->namelen);
4897 for (k = 0; (k < INT_GET(l->valuelen, ARCH_CONVERT)) && (k < 32); k++)
4898 kdb_printf("%c", l->nameval[l->namelen + k]);
4901 kdb_printf("\"(%d)\n",
4902 INT_GET(l->valuelen, ARCH_CONVERT));
4904 r = XFS_ATTR_LEAF_NAME_REMOTE(leaf, j);
4905 for (k = 0; k < r->namelen; k++)
4906 kdb_printf("%c", r->name[k]);
4907 kdb_printf("\"(%d) value blk 0x%x len %d\n",
4909 INT_GET(r->valueblk, ARCH_CONVERT),
4910 INT_GET(r->valuelen, ARCH_CONVERT));
4916 * Print a shortform attribute list.
4919 xfsidbg_xattrsf(xfs_attr_shortform_t *s)
4921 xfs_attr_sf_hdr_t *sfh;
4922 xfs_attr_sf_entry_t *sfe;
4926 kdb_printf("hdr count %d\n", INT_GET(sfh->count, ARCH_CONVERT));
4927 for (i = 0, sfe = s->list; i < INT_GET(sfh->count, ARCH_CONVERT); i++) {
4928 kdb_printf("entry %d namelen %d name \"", i, sfe->namelen);
4929 for (j = 0; j < sfe->namelen; j++)
4930 kdb_printf("%c", sfe->nameval[j]);
4931 kdb_printf("\" valuelen %d value \"", INT_GET(sfe->valuelen, ARCH_CONVERT));
4932 for (j = 0; (j < INT_GET(sfe->valuelen, ARCH_CONVERT)) && (j < 32); j++)
4933 kdb_printf("%c", sfe->nameval[sfe->namelen + j]);
4937 sfe = XFS_ATTR_SF_NEXTENTRY(sfe);
4941 #ifdef XFS_ATTR_TRACE
4943 * Print out the last "count" entries in the attribute trace buffer.
4946 xfsidbg_xattrtrace(int count)
4948 ktrace_entry_t *ktep;
4953 if (xfs_attr_trace_buf == NULL) {
4954 qprintf("The xfs attribute trace buffer is not initialized\n");
4957 nentries = ktrace_nentries(xfs_attr_trace_buf);
4961 if ((count <= 0) || (count > nentries)) {
4962 qprintf("Invalid count. There are %d entries.\n", nentries);
4966 ktep = ktrace_first(xfs_attr_trace_buf, &kts);
4967 if (count != nentries) {
4969 * Skip the total minus the number to look at minus one
4970 * for the entry returned by ktrace_first().
4972 skip_entries = nentries - count - 1;
4973 ktep = ktrace_skip(xfs_attr_trace_buf, skip_entries, &kts);
4975 qprintf("Skipped them all\n");
4979 while (ktep != NULL) {
4980 xfs_attr_trace_entry(ktep);
4981 ktep = ktrace_next(xfs_attr_trace_buf, &kts);
4987 * Print xfs bmap internal record
4990 xfsidbg_xbirec(xfs_bmbt_irec_t *r)
4993 "startoff %Ld startblock %Lx blockcount %Ld state %Ld\n",
4994 (__uint64_t)r->br_startoff,
4995 (__uint64_t)r->br_startblock,
4996 (__uint64_t)r->br_blockcount,
4997 (__uint64_t)r->br_state);
5000 #ifdef XFS_BLI_TRACE
5002 * Print out the buf log item trace for the given buf log item.
5005 xfsidbg_xblitrace(xfs_buf_log_item_t *bip)
5007 ktrace_entry_t *ktep;
5010 static char *xbli_flags[] = {
5014 "logged", /* 0x08 */
5017 static char *xli_flags[] = {
5022 if (bip->bli_trace == NULL) {
5023 qprintf("The bli trace buffer is not initialized\n");
5027 ktep = ktrace_first(bip->bli_trace, &kts);
5028 while (ktep != NULL) {
5029 qprintf("%s bp 0x%p flags ",
5030 (char *)ktep->val[0], ktep->val[1]);
5031 printflags((__psint_t)(ktep->val[2]), xbli_flags, "xbli");
5033 qprintf("recur %ld refcount %ld blkno 0x%lx bcount 0x%lx\n",
5034 (long)ktep->val[3], (long)ktep->val[4],
5035 (unsigned long)ktep->val[5],
5036 (unsigned long)ktep->val[6]);
5037 flags = (((uint64_t)(unsigned long)ktep->val[7] << 32) &
5038 0xFFFFFFFF00000000ULL) |
5039 (((uint64_t)(unsigned long)ktep->val[8]) &
5040 0x00000000FFFFFFFFULL);
5041 qprintf("bp flags ");
5042 printflags(flags, bp_flag_vals, NULL);
5044 qprintf("fspriv 0x%p fspriv2 0x%p pincount %ld iodone 0x%p\n",
5045 ktep->val[9], ktep->val[10],
5046 (long)ktep->val[11], ktep->val[12]);
5047 qprintf("lockval %ld lid 0x%lx log item flags ",
5048 (long)ktep->val[13], (unsigned long)ktep->val[14]);
5049 printflags((__psint_t)(ktep->val[15]), xli_flags, "xli");
5052 ktep = ktrace_next(bip->bli_trace, &kts);
5058 * Print a bmap alloc argument structure for XFS.
5061 xfsidbg_xbmalla(xfs_bmalloca_t *a)
5063 kdb_printf("tp 0x%p ip 0x%p eof %d prevp 0x%p\n",
5064 a->tp, a->ip, a->eof, a->prevp);
5065 kdb_printf("gotp 0x%p firstblock %s alen %d total %d\n",
5066 a->gotp, xfs_fmtfsblock(a->firstblock, a->ip->i_mount),
5068 kdb_printf("off %s wasdel %d userdata %d minlen %d\n",
5069 xfs_fmtfsblock(a->off, a->ip->i_mount), a->wasdel,
5070 a->userdata, a->minlen);
5071 kdb_printf("minleft %d low %d rval %s aeof %d conv %d\n",
5072 a->minleft, a->low, xfs_fmtfsblock(a->rval, a->ip->i_mount),
5076 #ifdef XFS_BMAP_TRACE
5078 * Print out the last "count" entries in the bmap btree trace buffer.
5079 * The "a" is for "all" inodes.
5082 xfsidbg_xbmatrace(int count)
5084 ktrace_entry_t *ktep;
5089 if (xfs_bmbt_trace_buf == NULL) {
5090 qprintf("The xfs bmap btree trace buffer is not initialized\n"); return;
5092 nentries = ktrace_nentries(xfs_bmbt_trace_buf);
5096 if ((count <= 0) || (count > nentries)) {
5097 qprintf("Invalid count. There are %d entries.\n", nentries);
5101 ktep = ktrace_first(xfs_bmbt_trace_buf, &kts);
5102 if (count != nentries) {
5104 * Skip the total minus the number to look at minus one
5105 * for the entry returned by ktrace_first().
5107 skip_entries = nentries - count - 1;
5108 ktep = ktrace_skip(xfs_bmbt_trace_buf, skip_entries, &kts);
5110 qprintf("Skipped them all\n");
5114 while (ktep != NULL) {
5115 if (xfs_bmbt_trace_entry(ktep))
5117 ktep = ktrace_next(xfs_bmbt_trace_buf, &kts);
5122 * Print out the bmap btree trace buffer attached to the given inode.
5125 xfsidbg_xbmitrace(xfs_inode_t *ip)
5127 ktrace_entry_t *ktep;
5130 if (ip->i_btrace == NULL) {
5131 qprintf("The inode trace buffer is not initialized\n");
5135 ktep = ktrace_first(ip->i_btrace, &kts);
5136 while (ktep != NULL) {
5137 if (xfs_bmbt_trace_entry(ktep))
5139 ktep = ktrace_next(ip->i_btrace, &kts);
5144 * Print out all the entries in the bmap btree trace buf corresponding
5145 * to the given inode. The "s" is for "single" inode.
5148 xfsidbg_xbmstrace(xfs_inode_t *ip)
5150 ktrace_entry_t *ktep;
5153 if (xfs_bmbt_trace_buf == NULL) {
5154 qprintf("The xfs bmap btree trace buffer is not initialized\n"); return;
5157 ktep = ktrace_first(xfs_bmbt_trace_buf, &kts);
5158 while (ktep != NULL) {
5159 if ((xfs_inode_t *)(ktep->val[2]) == ip) {
5160 if (xfs_bmbt_trace_entry(ktep))
5163 ktep = ktrace_next(xfs_bmbt_trace_buf, &kts);
5169 * Print xfs bmap record
5172 xfsidbg_xbrec(xfs_bmbt_rec_64_t *r)
5174 xfs_bmbt_irec_t irec;
5176 xfs_bmbt_get_all((xfs_bmbt_rec_t *)r, &irec);
5177 kdb_printf("startoff %Ld startblock %Lx blockcount %Ld flag %d\n",
5178 irec.br_startoff, (__uint64_t)irec.br_startblock,
5179 irec.br_blockcount, irec.br_state);
5183 * Print an xfs in-inode bmap btree root (data fork).
5186 xfsidbg_xbroot(xfs_inode_t *ip)
5188 xfs_broot(ip, &ip->i_df);
5192 * Print an xfs in-inode bmap btree root (attribute fork).
5195 xfsidbg_xbroota(xfs_inode_t *ip)
5198 xfs_broot(ip, ip->i_afp);
5202 * Print xfs btree cursor.
5205 xfsidbg_xbtcur(xfs_btree_cur_t *c)
5209 kdb_printf("tp 0x%p mp 0x%p\n",
5212 if (c->bc_btnum == XFS_BTNUM_BMAP) {
5213 kdb_printf("rec.b ");
5214 xfsidbg_xbirec(&c->bc_rec.b);
5215 } else if (c->bc_btnum == XFS_BTNUM_INO) {
5216 kdb_printf("rec.i startino 0x%x freecount 0x%x free %Lx\n",
5217 c->bc_rec.i.ir_startino, c->bc_rec.i.ir_freecount,
5218 c->bc_rec.i.ir_free);
5220 kdb_printf("rec.a startblock 0x%x blockcount 0x%x\n",
5221 c->bc_rec.a.ar_startblock,
5222 c->bc_rec.a.ar_blockcount);
5225 for (l = 0; l < c->bc_nlevels; l++)
5226 kdb_printf(" 0x%p", c->bc_bufs[l]);
5229 for (l = 0; l < c->bc_nlevels; l++)
5230 kdb_printf(" 0x%x", c->bc_ptrs[l]);
5232 for (l = 0; l < c->bc_nlevels; l++)
5233 kdb_printf(" %d", c->bc_ra[l]);
5235 kdb_printf("nlevels %d btnum %s blocklog %d\n",
5237 c->bc_btnum == XFS_BTNUM_BNO ? "bno" :
5238 (c->bc_btnum == XFS_BTNUM_CNT ? "cnt" :
5239 (c->bc_btnum == XFS_BTNUM_BMAP ? "bmap" : "ino")),
5241 if (c->bc_btnum == XFS_BTNUM_BMAP) {
5242 kdb_printf("private forksize 0x%x whichfork %d ip 0x%p flags %d\n",
5243 c->bc_private.b.forksize,
5244 c->bc_private.b.whichfork,
5246 c->bc_private.b.flags);
5247 kdb_printf("private firstblock %s flist 0x%p allocated 0x%x\n",
5248 xfs_fmtfsblock(c->bc_private.b.firstblock, c->bc_mp),
5249 c->bc_private.b.flist,
5250 c->bc_private.b.allocated);
5251 } else if (c->bc_btnum == XFS_BTNUM_INO) {
5252 kdb_printf("private agbp 0x%p agno 0x%x\n",
5253 c->bc_private.i.agbp,
5254 c->bc_private.i.agno);
5256 kdb_printf("private agbp 0x%p agno 0x%x\n",
5257 c->bc_private.a.agbp,
5258 c->bc_private.a.agno);
5263 * Figure out what kind of xfs block the buffer contains,
5264 * and invoke a print routine.
5267 xfsidbg_xbuf(xfs_buf_t *bp)
5269 xfsidbg_xbuf_real(bp, 0);
5273 * Figure out what kind of xfs block the buffer contains,
5274 * and invoke a print routine (if asked to).
5277 xfsidbg_xbuf_real(xfs_buf_t *bp, int summary)
5283 xfs_alloc_block_t *bta;
5284 xfs_bmbt_block_t *btb;
5285 xfs_inobt_block_t *bti;
5286 xfs_attr_leafblock_t *aleaf;
5287 xfs_dir_leafblock_t *dleaf;
5288 xfs_da_intnode_t *node;
5290 xfs_disk_dquot_t *dqb;
5291 xfs_dir2_block_t *d2block;
5292 xfs_dir2_data_t *d2data;
5293 xfs_dir2_leaf_t *d2leaf;
5294 xfs_dir2_free_t *d2free;
5296 d = XFS_BUF_PTR(bp);
5297 if (be32_to_cpu((agf = d)->agf_magicnum) == XFS_AGF_MAGIC) {
5299 kdb_printf("freespace hdr for AG %d (at 0x%p)\n",
5300 be32_to_cpu(agf->agf_seqno), agf);
5302 kdb_printf("buf 0x%p agf 0x%p\n", bp, agf);
5305 } else if (be32_to_cpu((agi = d)->agi_magicnum) == XFS_AGI_MAGIC) {
5307 kdb_printf("Inode hdr for AG %d (at 0x%p)\n",
5308 be32_to_cpu(agi->agi_seqno), agi);
5310 kdb_printf("buf 0x%p agi 0x%p\n", bp, agi);
5313 } else if (be32_to_cpu((bta = d)->bb_magic) == XFS_ABTB_MAGIC) {
5315 kdb_printf("Alloc BNO Btree blk, level %d (at 0x%p)\n",
5316 be16_to_cpu(bta->bb_level), bta);
5318 kdb_printf("buf 0x%p abtbno 0x%p\n", bp, bta);
5319 xfs_btalloc(bta, XFS_BUF_COUNT(bp));
5321 } else if (be32_to_cpu((bta = d)->bb_magic) == XFS_ABTC_MAGIC) {
5323 kdb_printf("Alloc COUNT Btree blk, level %d (at 0x%p)\n",
5324 be16_to_cpu(bta->bb_level), bta);
5326 kdb_printf("buf 0x%p abtcnt 0x%p\n", bp, bta);
5327 xfs_btalloc(bta, XFS_BUF_COUNT(bp));
5329 } else if (be32_to_cpu((btb = d)->bb_magic) == XFS_BMAP_MAGIC) {
5331 kdb_printf("Bmap Btree blk, level %d (at 0x%p)\n",
5332 be16_to_cpu(btb->bb_level), btb);
5334 kdb_printf("buf 0x%p bmapbt 0x%p\n", bp, btb);
5335 xfs_btbmap(btb, XFS_BUF_COUNT(bp));
5337 } else if (be32_to_cpu((bti = d)->bb_magic) == XFS_IBT_MAGIC) {
5339 kdb_printf("Inode Btree blk, level %d (at 0x%p)\n",
5340 be16_to_cpu(bti->bb_level), bti);
5342 kdb_printf("buf 0x%p inobt 0x%p\n", bp, bti);
5343 xfs_btino(bti, XFS_BUF_COUNT(bp));
5345 } else if (INT_GET((aleaf = d)->hdr.info.magic, ARCH_CONVERT) == XFS_ATTR_LEAF_MAGIC) {
5347 kdb_printf("Attr Leaf, 1st hash 0x%x (at 0x%p)\n",
5348 INT_GET(aleaf->entries[0].hashval, ARCH_CONVERT), aleaf);
5350 kdb_printf("buf 0x%p attr leaf 0x%p\n", bp, aleaf);
5351 xfsidbg_xattrleaf(aleaf);
5353 } else if (INT_GET((dleaf = d)->hdr.info.magic, ARCH_CONVERT) == XFS_DIR_LEAF_MAGIC) {
5355 kdb_printf("Dir Leaf, 1st hash 0x%x (at 0x%p)\n",
5356 dleaf->entries[0].hashval, dleaf);
5358 kdb_printf("buf 0x%p dir leaf 0x%p\n", bp, dleaf);
5359 xfsidbg_xdirleaf(dleaf);
5361 } else if (INT_GET((node = d)->hdr.info.magic, ARCH_CONVERT) == XFS_DA_NODE_MAGIC) {
5363 kdb_printf("Dir/Attr Node, level %d, 1st hash 0x%x (at 0x%p)\n",
5364 node->hdr.level, node->btree[0].hashval, node);
5366 kdb_printf("buf 0x%p dir/attr node 0x%p\n", bp, node);
5367 xfsidbg_xdanode(node);
5369 } else if (INT_GET((di = d)->di_core.di_magic, ARCH_CONVERT) == XFS_DINODE_MAGIC) {
5371 kdb_printf("Disk Inode (at 0x%p)\n", di);
5373 kdb_printf("buf 0x%p dinode 0x%p\n", bp, di);
5376 } else if (INT_GET((sb = d)->sb_magicnum, ARCH_CONVERT) == XFS_SB_MAGIC) {
5378 kdb_printf("Superblock (at 0x%p)\n", sb);
5380 kdb_printf("buf 0x%p sb 0x%p\n", bp, sb);
5381 /* SB in a buffer - we need to convert */
5382 xfsidbg_xsb_convert(sb);
5384 } else if ((dqb = d)->d_magic == cpu_to_be16(XFS_DQUOT_MAGIC)) {
5385 #define XFSIDBG_DQTYPESTR(d) \
5386 (((d)->d_flags & XFS_DQ_USER) ? "USR" : \
5387 (((d)->d_flags & XFS_DQ_GROUP) ? "GRP" : \
5388 (((d)->d_flags & XFS_DQ_PROJ) ? "PRJ" : "???")))
5389 kdb_printf("Quota blk starting ID [%d], type %s at 0x%p\n",
5390 be32_to_cpu(dqb->d_id), XFSIDBG_DQTYPESTR(dqb), dqb);
5392 } else if (INT_GET((d2block = d)->hdr.magic, ARCH_CONVERT) == XFS_DIR2_BLOCK_MAGIC) {
5394 kdb_printf("Dir2 block (at 0x%p)\n", d2block);
5396 kdb_printf("buf 0x%p dir2 block 0x%p\n", bp, d2block);
5397 xfs_dir2data((void *)d2block, XFS_BUF_COUNT(bp));
5399 } else if (INT_GET((d2data = d)->hdr.magic, ARCH_CONVERT) == XFS_DIR2_DATA_MAGIC) {
5401 kdb_printf("Dir2 data (at 0x%p)\n", d2data);
5403 kdb_printf("buf 0x%p dir2 data 0x%p\n", bp, d2data);
5404 xfs_dir2data((void *)d2data, XFS_BUF_COUNT(bp));
5406 } else if (INT_GET((d2leaf = d)->hdr.info.magic, ARCH_CONVERT) == XFS_DIR2_LEAF1_MAGIC) {
5408 kdb_printf("Dir2 leaf(1) (at 0x%p)\n", d2leaf);
5410 kdb_printf("buf 0x%p dir2 leaf 0x%p\n", bp, d2leaf);
5411 xfs_dir2leaf(d2leaf, XFS_BUF_COUNT(bp));
5413 } else if (INT_GET(d2leaf->hdr.info.magic, ARCH_CONVERT) == XFS_DIR2_LEAFN_MAGIC) {
5415 kdb_printf("Dir2 leaf(n) (at 0x%p)\n", d2leaf);
5417 kdb_printf("buf 0x%p dir2 leaf 0x%p\n", bp, d2leaf);
5418 xfs_dir2leaf(d2leaf, XFS_BUF_COUNT(bp));
5420 } else if (INT_GET((d2free = d)->hdr.magic, ARCH_CONVERT) == XFS_DIR2_FREE_MAGIC) {
5422 kdb_printf("Dir2 free (at 0x%p)\n", d2free);
5424 kdb_printf("buf 0x%p dir2 free 0x%p\n", bp, d2free);
5425 xfsidbg_xdir2free(d2free);
5428 kdb_printf("buf 0x%p unknown 0x%p\n", bp, d);
5432 #ifdef XFS_BMAP_TRACE
5434 * Print out the last "count" entries in the bmap extent trace buffer.
5435 * The "a" is for "all" inodes.
5438 xfsidbg_xbxatrace(int count)
5440 ktrace_entry_t *ktep;
5445 if (xfs_bmap_trace_buf == NULL) {
5446 qprintf("The xfs bmap extent trace buffer is not initialized\n");
5449 nentries = ktrace_nentries(xfs_bmap_trace_buf);
5453 if ((count <= 0) || (count > nentries)) {
5454 qprintf("Invalid count. There are %d entries.\n", nentries);
5458 ktep = ktrace_first(xfs_bmap_trace_buf, &kts);
5459 if (count != nentries) {
5461 * Skip the total minus the number to look at minus one
5462 * for the entry returned by ktrace_first().
5464 skip_entries = nentries - count - 1;
5465 ktep = ktrace_skip(xfs_bmap_trace_buf, skip_entries, &kts);
5467 qprintf("Skipped them all\n");
5471 while (ktep != NULL) {
5472 if (xfs_bmap_trace_entry(ktep))
5474 ktep = ktrace_next(xfs_bmap_trace_buf, &kts);
5479 * Print out the bmap extent trace buffer attached to the given inode.
5482 xfsidbg_xbxitrace(xfs_inode_t *ip)
5484 ktrace_entry_t *ktep;
5486 if (ip->i_xtrace == NULL) {
5487 qprintf("The inode trace buffer is not initialized\n");
5491 ktep = ktrace_first(ip->i_xtrace, &kts);
5492 while (ktep != NULL) {
5493 if (xfs_bmap_trace_entry(ktep))
5495 ktep = ktrace_next(ip->i_xtrace, &kts);
5500 * Print out all the entries in the bmap extent trace buf corresponding
5501 * to the given inode. The "s" is for "single" inode.
5504 xfsidbg_xbxstrace(xfs_inode_t *ip)
5506 ktrace_entry_t *ktep;
5509 if (xfs_bmap_trace_buf == NULL) {
5510 qprintf("The xfs bmap extent trace buffer is not initialized\n");
5514 ktep = ktrace_first(xfs_bmap_trace_buf, &kts);
5515 while (ktep != NULL) {
5516 if ((xfs_inode_t *)(ktep->val[3]) == ip) {
5517 if (xfs_bmap_trace_entry(ktep))
5520 ktep = ktrace_next(xfs_bmap_trace_buf, &kts);
5525 #ifdef XFS_ILOCK_TRACE
5527 * Print out the ilock trace buffer attached to the given inode.
5530 xfsidbg_xilock_trace_entry(ktrace_entry_t *ktep)
5532 static char *xiflags[] = {
5541 if ((__psint_t)ktep->val[0] &&
5542 (__psint_t)ktep->val[7] == 0) {
5543 printflags((__psint_t)ktep->val[2], xiflags,"Flags ");
5544 if ((__psint_t)ktep->val[1] == 1)
5546 else if ((__psint_t)ktep->val[1] == 2)
5547 qprintf("LOCK SHARED\n");
5548 else if ((__psint_t)ktep->val[1] == 3)
5549 qprintf("UNLOCK\n");
5550 qprintf("ip 0x%p %llx %ld\n",
5552 (unsigned long long)((xfs_inode_t*)ktep->val[0])->i_ino,
5553 (long)ktep->val[6]);
5554 qprintf("raddr 0x%p\n", ktep->val[3]);
5555 qprintf(" Pid %ld, cpu %ld\n",
5557 (long)ktep->val[4]);
5558 qprintf("-----------------------\n");
5560 } else if ((__psint_t)ktep->val[7] == 1) {
5561 if ((__psint_t)ktep->val[1] == 1)
5562 qprintf("FlushLOCK ");
5563 else if ((__psint_t)ktep->val[1] == 2)
5564 qprintf("FlushTRYLOCK %ld ",
5565 (long)ktep->val[2]);
5566 else if ((__psint_t)ktep->val[1] == 3)
5567 qprintf("FlushUNLOCK ");
5568 else if ((__psint_t)ktep->val[1] == 4)
5569 qprintf("FlushInode 0x%p",
5571 else if ((__psint_t)ktep->val[1] == 5)
5572 qprintf("FlushInodeInt ");
5573 else qprintf("FlushUNKNOWN ");
5574 qprintf("ip 0x%p ino %llx @ %ld\n",
5576 (unsigned long long)((xfs_inode_t*)ktep->val[0])->i_ino,
5577 (long)ktep->val[6]);
5578 qprintf("raddr 0x%p\n", ktep->val[3]);
5579 qprintf(" Pid %ld, cpu %ld\n",
5581 (long)ktep->val[4]);
5582 qprintf("-----------------------\n");
5587 xfsidbg_xilock_trace(xfs_inode_t *ip)
5589 static char *xiflags[] = {
5598 ktrace_entry_t *ktep;
5600 if (ip->i_lock_trace == NULL) {
5601 qprintf("The inode ilock trace buffer is not initialized\n");
5605 ktep = ktrace_first(ip->i_lock_trace, &kts);
5606 while (ktep != NULL) {
5607 if ((__psint_t)ktep->val[0] &&
5608 (__psint_t)ktep->val[7] == 0) {
5609 printflags((__psint_t)ktep->val[2], xiflags,"Flags ");
5610 if ((__psint_t)ktep->val[1] == 1)
5612 else if ((__psint_t)ktep->val[1] == 2)
5613 qprintf("LOCK SHARED\n");
5614 else if ((__psint_t)ktep->val[1] == 3)
5615 qprintf("UNLOCK\n");
5616 qprintf("ip 0x%p %lld %ld\n",
5617 ktep->val[0], (unsigned long long)
5618 ((xfs_inode_t*)ktep->val[0])->i_ino,
5619 (long)ktep->val[6]);
5620 qprintf("raddr 0x%p\n", ktep->val[3]);
5621 qprintf(" Pid %ld, cpu %ld\n",
5623 (long)ktep->val[4]);
5624 qprintf("-----------------------\n");
5625 } else if ((__psint_t)ktep->val[7] == 1) {
5626 if ((__psint_t)ktep->val[1] == 1)
5628 else if ((__psint_t)ktep->val[1] == 2)
5629 qprintf("TRYLOCK %ld ",
5630 (long)ktep->val[2]);
5631 else if ((__psint_t)ktep->val[1] == 3)
5633 else qprintf("UNKNOWN ");
5634 qprintf("ip 0x%p %lld %ld\n",
5635 ktep->val[0], (unsigned long long)
5636 ((xfs_inode_t*)ktep->val[0])->i_ino,
5637 (long)ktep->val[6]);
5638 qprintf("raddr 0x%p\n", ktep->val[3]);
5639 qprintf(" Pid %ld, cpu %ld\n",
5641 (long)ktep->val[4]);
5642 qprintf("-----------------------\n");
5645 ktep = ktrace_next(ip->i_lock_trace, &kts);
5650 * Print out the last "count" entries in the inode lock trace buffer.
5651 * The "a" is for "all" entries.
5654 xfsidbg_xailock_trace(int count)
5656 ktrace_entry_t *ktep;
5661 if (xfs_ilock_trace_buf == NULL) {
5662 qprintf("The xfs inode lock trace buffer is not initialized\n"); return;
5664 nentries = ktrace_nentries(xfs_ilock_trace_buf);
5668 if ((count <= 0) || (count > nentries)) {
5669 qprintf("Invalid count. There are %d entries.\n", nentries);
5673 ktep = ktrace_first(xfs_ilock_trace_buf, &kts);
5674 if (count != nentries) {
5676 * Skip the total minus the number to look at minus one
5677 * for the entry returned by ktrace_first().
5679 skip_entries = nentries - count - 1;
5680 ktep = ktrace_skip(xfs_ilock_trace_buf, skip_entries, &kts);
5682 qprintf("Skipped them all\n");
5686 while (ktep != NULL) {
5687 xfsidbg_xilock_trace_entry(ktep);
5688 ktep = ktrace_next(xfs_ilock_trace_buf, &kts);
5694 * Compute & print buffer's checksum.
5697 xfsidbg_xchksum(uint *addr)
5701 if (((__psint_t)addr) == ((__psint_t)-1)) {
5702 qprintf("USAGE xchksum <address>\n");
5703 qprintf(" length is set with xarg\n");
5705 for (i=0; i<xargument; i++) {
5709 qprintf("chksum (0x%x) length (%d)\n", chksum, xargument);
5711 } /* xfsidbg_xchksum */
5714 * Print an xfs_da_args structure.
5717 xfsidbg_xdaargs(xfs_da_args_t *n)
5722 kdb_printf(" name \"");
5723 for (i = 0; i < n->namelen; i++) {
5724 kdb_printf("%c", n->name[i]);
5726 kdb_printf("\"(%d) value ", n->namelen);
5730 for (i = 0; (i < n->valuelen) && (i < 32); ch++, i++) {
5732 case '\n': kdb_printf("\n"); break;
5733 case '\b': kdb_printf("\b"); break;
5734 case '\t': kdb_printf("\t"); break;
5735 default: kdb_printf("%c", *ch); break;
5740 kdb_printf("\"(%d)\n", n->valuelen);
5742 kdb_printf("(NULL)(%d)\n", n->valuelen);
5744 kdb_printf(" hashval 0x%x whichfork %d flags <",
5745 (uint_t)n->hashval, n->whichfork);
5746 if (n->flags & ATTR_ROOT)
5747 kdb_printf("ROOT ");
5748 if (n->flags & ATTR_SECURE)
5749 kdb_printf("SECURE ");
5750 if (n->flags & ATTR_CREATE)
5751 kdb_printf("CREATE ");
5752 if (n->flags & ATTR_REPLACE)
5753 kdb_printf("REPLACE ");
5754 if (n->flags & XFS_ATTR_INCOMPLETE)
5755 kdb_printf("INCOMPLETE ");
5756 i = ~(ATTR_ROOT | ATTR_SECURE |
5757 ATTR_CREATE | ATTR_REPLACE | XFS_ATTR_INCOMPLETE);
5758 if ((n->flags & i) != 0)
5759 kdb_printf("0x%x", n->flags & i);
5761 kdb_printf(" rename %d justcheck %d addname %d oknoent %d\n",
5762 n->rename, n->justcheck, n->addname, n->oknoent);
5763 kdb_printf(" leaf: blkno %d index %d rmtblkno %d rmtblkcnt %d\n",
5764 n->blkno, n->index, n->rmtblkno, n->rmtblkcnt);
5765 kdb_printf(" leaf2: blkno %d index %d rmtblkno %d rmtblkcnt %d\n",
5766 n->blkno2, n->index2, n->rmtblkno2, n->rmtblkcnt2);
5767 kdb_printf(" inumber %llu dp 0x%p firstblock 0x%p flist 0x%p\n",
5768 (unsigned long long) n->inumber,
5769 n->dp, n->firstblock, n->flist);
5770 kdb_printf(" trans 0x%p total %d\n",
5771 n->trans, n->total);
5775 * Print a da buffer structure.
5778 xfsidbg_xdabuf(xfs_dabuf_t *dabuf)
5782 kdb_printf("nbuf %d dirty %d bbcount %d data 0x%p bps",
5783 dabuf->nbuf, dabuf->dirty, dabuf->bbcount, dabuf->data);
5784 for (i = 0; i < dabuf->nbuf; i++)
5785 kdb_printf(" %d:0x%p", i, dabuf->bps[i]);
5787 #ifdef XFS_DABUF_DEBUG
5788 kdb_printf(" ra 0x%x prev 0x%x next 0x%x dev 0x%x blkno 0x%x\n",
5789 dabuf->ra, dabuf->prev, dabuf->next, dabuf->dev, dabuf->blkno);
5794 * Print a directory/attribute internal node block.
5797 xfsidbg_xdanode(xfs_da_intnode_t *node)
5799 xfs_da_node_hdr_t *h;
5800 xfs_da_blkinfo_t *i;
5801 xfs_da_node_entry_t *e;
5806 kdb_printf("hdr info forw 0x%x back 0x%x magic 0x%x\n",
5807 INT_GET(i->forw, ARCH_CONVERT), INT_GET(i->back, ARCH_CONVERT), INT_GET(i->magic, ARCH_CONVERT));
5808 kdb_printf("hdr count %d level %d\n",
5809 INT_GET(h->count, ARCH_CONVERT), INT_GET(h->level, ARCH_CONVERT));
5810 for (j = 0, e = node->btree; j < INT_GET(h->count, ARCH_CONVERT); j++, e++) {
5811 kdb_printf("btree %d hashval 0x%x before 0x%x\n",
5812 j, (uint_t)INT_GET(e->hashval, ARCH_CONVERT), INT_GET(e->before, ARCH_CONVERT));
5817 * Print an xfs_da_state_blk structure.
5820 xfsidbg_xdastate(xfs_da_state_t *s)
5822 xfs_da_state_blk_t *eblk;
5824 kdb_printf("args 0x%p mp 0x%p blocksize %u node_ents %u inleaf %u\n",
5825 s->args, s->mp, s->blocksize, s->node_ents, s->inleaf);
5827 xfsidbg_xdaargs(s->args);
5829 kdb_printf("path: ");
5830 xfs_dastate_path(&s->path);
5832 kdb_printf("altpath: ");
5833 xfs_dastate_path(&s->altpath);
5835 eblk = &s->extrablk;
5836 kdb_printf("extra: valid %d, after %d\n", s->extravalid, s->extraafter);
5837 kdb_printf(" bp 0x%p blkno 0x%x ", eblk->bp, eblk->blkno);
5838 kdb_printf("index %d hashval 0x%x\n", eblk->index, (uint_t)eblk->hashval);
5842 * Print a directory leaf block.
5845 xfsidbg_xdirleaf(xfs_dir_leafblock_t *leaf)
5847 xfs_dir_leaf_hdr_t *h;
5848 xfs_da_blkinfo_t *i;
5849 xfs_dir_leaf_map_t *m;
5850 xfs_dir_leaf_entry_t *e;
5851 xfs_dir_leaf_name_t *n;
5857 kdb_printf("hdr info forw 0x%x back 0x%x magic 0x%x\n",
5858 INT_GET(i->forw, ARCH_CONVERT), INT_GET(i->back, ARCH_CONVERT), INT_GET(i->magic, ARCH_CONVERT));
5859 kdb_printf("hdr count %d namebytes %d firstused %d holes %d\n",
5860 INT_GET(h->count, ARCH_CONVERT), INT_GET(h->namebytes, ARCH_CONVERT), INT_GET(h->firstused, ARCH_CONVERT), h->holes);
5861 for (j = 0, m = h->freemap; j < XFS_DIR_LEAF_MAPSIZE; j++, m++) {
5862 kdb_printf("hdr freemap %d base %d size %d\n",
5863 j, INT_GET(m->base, ARCH_CONVERT), INT_GET(m->size, ARCH_CONVERT));
5865 for (j = 0, e = leaf->entries; j < INT_GET(h->count, ARCH_CONVERT); j++, e++) {
5866 n = XFS_DIR_LEAF_NAMESTRUCT(leaf, INT_GET(e->nameidx, ARCH_CONVERT));
5867 XFS_DIR_SF_GET_DIRINO(&n->inumber, &ino);
5868 kdb_printf("leaf %d hashval 0x%x nameidx %d inumber %llu ",
5869 j, (uint_t)INT_GET(e->hashval, ARCH_CONVERT),
5870 INT_GET(e->nameidx, ARCH_CONVERT),
5871 (unsigned long long)ino);
5872 kdb_printf("namelen %d name \"", e->namelen);
5873 for (k = 0; k < e->namelen; k++)
5874 kdb_printf("%c", n->name[k]);
5880 * Print a directory v2 data block, single or multiple.
5883 xfs_dir2data(void *addr, int size)
5885 xfs_dir2_data_t *db;
5886 xfs_dir2_block_t *bb;
5887 xfs_dir2_data_hdr_t *h;
5888 xfs_dir2_data_free_t *m;
5889 xfs_dir2_data_entry_t *e;
5890 xfs_dir2_data_unused_t *u;
5891 xfs_dir2_leaf_entry_t *l=NULL;
5895 xfs_dir2_block_tail_t *tail=NULL;
5897 db = (xfs_dir2_data_t *)addr;
5898 bb = (xfs_dir2_block_t *)addr;
5900 kdb_printf("hdr magic 0x%x (%s)\nhdr bestfree", INT_GET(h->magic, ARCH_CONVERT),
5901 INT_GET(h->magic, ARCH_CONVERT) == XFS_DIR2_DATA_MAGIC ? "DATA" :
5902 (INT_GET(h->magic, ARCH_CONVERT) == XFS_DIR2_BLOCK_MAGIC ? "BLOCK" : ""));
5903 for (j = 0, m = h->bestfree; j < XFS_DIR2_DATA_FD_COUNT; j++, m++) {
5904 kdb_printf(" %d: 0x%x@0x%x", j, INT_GET(m->length, ARCH_CONVERT), INT_GET(m->offset, ARCH_CONVERT));
5907 if (INT_GET(h->magic, ARCH_CONVERT) == XFS_DIR2_DATA_MAGIC)
5908 t = (char *)db + size;
5910 /* XFS_DIR2_BLOCK_TAIL_P */
5911 tail = (xfs_dir2_block_tail_t *)
5912 ((char *)bb + size - sizeof(xfs_dir2_block_tail_t));
5913 l = XFS_DIR2_BLOCK_LEAF_P(tail);
5916 for (p = (char *)(h + 1); p < t; ) {
5917 u = (xfs_dir2_data_unused_t *)p;
5918 if (u->freetag == XFS_DIR2_DATA_FREE_TAG) {
5919 kdb_printf("0x%lx unused freetag 0x%x length 0x%x tag 0x%x\n",
5920 (unsigned long) (p - (char *)addr),
5921 INT_GET(u->freetag, ARCH_CONVERT),
5922 INT_GET(u->length, ARCH_CONVERT),
5923 INT_GET(*XFS_DIR2_DATA_UNUSED_TAG_P(u), ARCH_CONVERT));
5924 p += INT_GET(u->length, ARCH_CONVERT);
5927 e = (xfs_dir2_data_entry_t *)p;
5928 kdb_printf("0x%lx entry inumber %llu namelen %d name \"",
5929 (unsigned long) (p - (char *)addr),
5930 (unsigned long long) INT_GET(e->inumber, ARCH_CONVERT),
5932 for (k = 0; k < e->namelen; k++)
5933 kdb_printf("%c", e->name[k]);
5934 kdb_printf("\" tag 0x%x\n", INT_GET(*XFS_DIR2_DATA_ENTRY_TAG_P(e), ARCH_CONVERT));
5935 p += XFS_DIR2_DATA_ENTSIZE(e->namelen);
5937 if (INT_GET(h->magic, ARCH_CONVERT) == XFS_DIR2_DATA_MAGIC)
5939 for (j = 0; j < INT_GET(tail->count, ARCH_CONVERT); j++, l++) {
5940 kdb_printf("0x%lx leaf %d hashval 0x%x address 0x%x (byte 0x%x)\n",
5941 (unsigned long) ((char *)l - (char *)addr), j,
5942 (uint_t)INT_GET(l->hashval, ARCH_CONVERT),
5943 INT_GET(l->address, ARCH_CONVERT),
5944 /* XFS_DIR2_DATAPTR_TO_BYTE */
5945 INT_GET(l->address, ARCH_CONVERT) << XFS_DIR2_DATA_ALIGN_LOG);
5947 kdb_printf("0x%lx tail count %d\n",
5948 (unsigned long) ((char *)tail - (char *)addr),
5949 INT_GET(tail->count, ARCH_CONVERT));
5953 xfs_dir2leaf(xfs_dir2_leaf_t *leaf, int size)
5955 xfs_dir2_leaf_hdr_t *h;
5956 xfs_da_blkinfo_t *i;
5957 xfs_dir2_leaf_entry_t *e;
5958 xfs_dir2_data_off_t *b;
5959 xfs_dir2_leaf_tail_t *t;
5965 kdb_printf("hdr info forw 0x%x back 0x%x magic 0x%x\n",
5966 INT_GET(i->forw, ARCH_CONVERT), INT_GET(i->back, ARCH_CONVERT), INT_GET(i->magic, ARCH_CONVERT));
5967 kdb_printf("hdr count %d stale %d\n", INT_GET(h->count, ARCH_CONVERT), INT_GET(h->stale, ARCH_CONVERT));
5968 for (j = 0; j < INT_GET(h->count, ARCH_CONVERT); j++, e++) {
5969 kdb_printf("0x%lx ent %d hashval 0x%x address 0x%x (byte 0x%x)\n",
5970 (unsigned long) ((char *)e - (char *)leaf), j,
5971 (uint_t)INT_GET(e->hashval, ARCH_CONVERT),
5972 INT_GET(e->address, ARCH_CONVERT),
5973 /* XFS_DIR2_DATAPTR_TO_BYTE */
5974 INT_GET(e->address, ARCH_CONVERT) << XFS_DIR2_DATA_ALIGN_LOG);
5976 if (INT_GET(i->magic, ARCH_CONVERT) == XFS_DIR2_LEAFN_MAGIC)
5978 /* XFS_DIR2_LEAF_TAIL_P */
5979 t = (xfs_dir2_leaf_tail_t *)((char *)leaf + size - sizeof(*t));
5980 b = XFS_DIR2_LEAF_BESTS_P(t);
5981 for (j = 0; j < INT_GET(t->bestcount, ARCH_CONVERT); j++, b++) {
5982 kdb_printf("0x%lx best %d 0x%x\n",
5983 (unsigned long) ((char *)b - (char *)leaf), j,
5984 INT_GET(*b, ARCH_CONVERT));
5986 kdb_printf("tail bestcount %d\n", INT_GET(t->bestcount, ARCH_CONVERT));
5990 * Print a shortform directory.
5993 xfsidbg_xdirsf(xfs_dir_shortform_t *s)
5995 xfs_dir_sf_hdr_t *sfh;
5996 xfs_dir_sf_entry_t *sfe;
6001 XFS_DIR_SF_GET_DIRINO(&sfh->parent, &ino);
6002 kdb_printf("hdr parent %llu", (unsigned long long)ino);
6003 kdb_printf(" count %d\n", sfh->count);
6004 for (i = 0, sfe = s->list; i < sfh->count; i++) {
6005 XFS_DIR_SF_GET_DIRINO(&sfe->inumber, &ino);
6006 kdb_printf("entry %d inumber %llu", i, (unsigned long long)ino);
6007 kdb_printf(" namelen %d name \"", sfe->namelen);
6008 for (j = 0; j < sfe->namelen; j++)
6009 kdb_printf("%c", sfe->name[j]);
6011 sfe = XFS_DIR_SF_NEXTENTRY(sfe);
6016 * Print a shortform v2 directory.
6019 xfsidbg_xdir2sf(xfs_dir2_sf_t *s)
6021 xfs_dir2_sf_hdr_t *sfh;
6022 xfs_dir2_sf_entry_t *sfe;
6027 ino = XFS_DIR2_SF_GET_INUMBER(s, &sfh->parent);
6028 kdb_printf("hdr count %d i8count %d parent %llu\n",
6029 sfh->count, sfh->i8count, (unsigned long long) ino);
6030 for (i = 0, sfe = XFS_DIR2_SF_FIRSTENTRY(s); i < sfh->count; i++) {
6031 ino = XFS_DIR2_SF_GET_INUMBER(s, XFS_DIR2_SF_INUMBERP(sfe));
6032 kdb_printf("entry %d inumber %llu offset 0x%x namelen %d name \"",
6033 i, (unsigned long long) ino,
6034 XFS_DIR2_SF_GET_OFFSET(sfe),
6036 for (j = 0; j < sfe->namelen; j++)
6037 kdb_printf("%c", sfe->name[j]);
6039 sfe = XFS_DIR2_SF_NEXTENTRY(s, sfe);
6044 * Print a node-form v2 directory freemap block.
6047 xfsidbg_xdir2free(xfs_dir2_free_t *f)
6051 kdb_printf("hdr magic 0x%x firstdb %d nvalid %d nused %d\n",
6052 INT_GET(f->hdr.magic, ARCH_CONVERT), INT_GET(f->hdr.firstdb, ARCH_CONVERT), INT_GET(f->hdr.nvalid, ARCH_CONVERT), INT_GET(f->hdr.nused, ARCH_CONVERT));
6053 for (i = 0; i < INT_GET(f->hdr.nvalid, ARCH_CONVERT); i++) {
6054 kdb_printf("entry %d db %d count %d\n",
6055 i, i + INT_GET(f->hdr.firstdb, ARCH_CONVERT), INT_GET(f->bests[i], ARCH_CONVERT));
6059 #ifdef XFS_DIR_TRACE
6061 * Print out the last "count" entries in the directory trace buffer.
6064 xfsidbg_xdirtrace(int count)
6066 ktrace_entry_t *ktep;
6071 if (xfs_dir_trace_buf == NULL) {
6072 qprintf("The xfs directory trace buffer is not initialized\n");
6075 nentries = ktrace_nentries(xfs_dir_trace_buf);
6079 if ((count <= 0) || (count > nentries)) {
6080 qprintf("Invalid count. There are %d entries.\n", nentries);
6084 ktep = ktrace_first(xfs_dir_trace_buf, &kts);
6085 if (count != nentries) {
6087 * Skip the total minus the number to look at minus one
6088 * for the entry returned by ktrace_first().
6090 skip_entries = nentries - count - 1;
6091 ktep = ktrace_skip(xfs_dir_trace_buf, skip_entries, &kts);
6093 qprintf("Skipped them all\n");
6097 while (ktep != NULL) {
6098 if (xfs_dir_trace_entry(ktep))
6100 ktep = ktrace_next(xfs_dir_trace_buf, &kts);
6105 #ifdef XFS_DIR2_TRACE
6107 * Print out the last "count" entries in the directory v2 trace buffer.
6110 xfsidbg_xdir2atrace(int count)
6112 ktrace_entry_t *ktep;
6117 if (xfs_dir2_trace_buf == NULL) {
6118 qprintf("The xfs dirv2 trace buffer is not initialized\n");
6121 nentries = ktrace_nentries(xfs_dir2_trace_buf);
6125 if ((count <= 0) || (count > nentries)) {
6126 qprintf("Invalid count. There are %d entries.\n", nentries);
6130 ktep = ktrace_first(xfs_dir2_trace_buf, &kts);
6131 if (count != nentries) {
6133 * Skip the total minus the number to look at minus one
6134 * for the entry returned by ktrace_first().
6136 skip_entries = nentries - count - 1;
6137 ktep = ktrace_skip(xfs_dir2_trace_buf, skip_entries, &kts);
6139 qprintf("Skipped them all\n");
6143 while (ktep != NULL) {
6144 if (xfs_dir2_trace_entry(ktep))
6146 ktep = ktrace_next(xfs_dir2_trace_buf, &kts);
6151 * Print out the directory v2 trace buffer attached to the given inode.
6154 xfsidbg_xdir2itrace(xfs_inode_t *ip)
6156 ktrace_entry_t *ktep;
6159 if (ip->i_dir_trace == NULL) {
6160 qprintf("The inode trace buffer is not initialized\n");
6164 ktep = ktrace_first(ip->i_dir_trace, &kts);
6165 while (ktep != NULL) {
6166 if (xfs_dir2_trace_entry(ktep))
6168 ktep = ktrace_next(ip->i_dir_trace, &kts);
6174 * Print xfs extent records.
6177 xfsidbg_xexlist(xfs_inode_t *ip)
6179 xfs_xexlist_fork(ip, XFS_DATA_FORK);
6180 if (XFS_IFORK_Q(ip))
6181 xfs_xexlist_fork(ip, XFS_ATTR_FORK);
6185 * Print an xfs free-extent records.
6188 xfsidbg_xflist(xfs_bmap_free_t *flist)
6190 xfs_bmap_free_item_t *item;
6192 kdb_printf("flist@0x%p: first 0x%p count %d low %d\n", flist,
6193 flist->xbf_first, flist->xbf_count, flist->xbf_low);
6194 for (item = flist->xbf_first; item; item = item->xbfi_next) {
6195 kdb_printf("item@0x%p: startblock %Lx blockcount %d", item,
6196 (xfs_dfsbno_t)item->xbfi_startblock,
6197 item->xbfi_blockcount);
6202 * Print out the help messages for these functions.
6209 for (p = xfsidbg_funcs; p->name; p++)
6210 kdb_printf("%-16s %s %s\n", p->name, p->args, p->help);
6214 * Print out an XFS in-core log structure.
6217 xfsidbg_xiclog(xlog_in_core_t *iclog)
6220 static char *ic_flags[] = {
6221 "ACTIVE", /* 0x0001 */
6222 "WANT_SYNC", /* 0x0002 */
6223 "SYNCING", /* 0X0004 */
6224 "DONE_SYNC", /* 0X0008 */
6225 "DO_CALLBACK", /* 0X0010 */
6226 "CALLBACK", /* 0X0020 */
6227 "DIRTY", /* 0X0040 */
6228 "IOERROR", /* 0X0080 */
6229 "NOTUSED", /* 0X8000 */
6233 kdb_printf("xlog_in_core/header at 0x%p/0x%p\n",
6234 iclog, iclog->hic_data);
6235 kdb_printf("magicno: %x cycle: %d version: %d lsn: 0x%Lx\n",
6236 INT_GET(iclog->ic_header.h_magicno, ARCH_CONVERT), INT_GET(iclog->ic_header.h_cycle, ARCH_CONVERT),
6237 INT_GET(iclog->ic_header.h_version, ARCH_CONVERT), INT_GET(iclog->ic_header.h_lsn, ARCH_CONVERT));
6238 kdb_printf("tail_lsn: 0x%Lx len: %d prev_block: %d num_ops: %d\n",
6239 INT_GET(iclog->ic_header.h_tail_lsn, ARCH_CONVERT), INT_GET(iclog->ic_header.h_len, ARCH_CONVERT),
6240 INT_GET(iclog->ic_header.h_prev_block, ARCH_CONVERT), INT_GET(iclog->ic_header.h_num_logops, ARCH_CONVERT));
6241 kdb_printf("cycle_data: ");
6242 for (i=0; i<(iclog->ic_size>>BBSHIFT); i++) {
6243 kdb_printf("%x ", INT_GET(iclog->ic_header.h_cycle_data[i], ARCH_CONVERT));
6246 kdb_printf("size: %d\n", INT_GET(iclog->ic_header.h_size, ARCH_CONVERT));
6248 kdb_printf("--------------------------------------------------\n");
6249 kdb_printf("data: 0x%p &forcesema: 0x%p next: 0x%p bp: 0x%p\n",
6250 iclog->ic_datap, &iclog->ic_forcesema, iclog->ic_next,
6252 kdb_printf("log: 0x%p callb: 0x%p callb_tail: 0x%p\n",
6253 iclog->ic_log, iclog->ic_callback, iclog->ic_callback_tail);
6254 kdb_printf("size: %d (OFFSET: %d) trace: 0x%p refcnt: %d bwritecnt: %d",
6255 iclog->ic_size, iclog->ic_offset,
6256 #ifdef XFS_LOG_TRACE
6261 iclog->ic_refcnt, iclog->ic_bwritecnt);
6262 if (iclog->ic_state & XLOG_STATE_ALL)
6263 printflags(iclog->ic_state, ic_flags, " state:");
6265 kdb_printf(" state: INVALID 0x%x", iclog->ic_state);
6267 } /* xfsidbg_xiclog */
6271 * Print all incore logs.
6274 xfsidbg_xiclogall(xlog_in_core_t *iclog)
6276 xlog_in_core_t *first_iclog = iclog;
6279 xfsidbg_xiclog(iclog);
6280 kdb_printf("=================================================\n");
6281 iclog = iclog->ic_next;
6282 } while (iclog != first_iclog);
6283 } /* xfsidbg_xiclogall */
6286 * Print out the callback structures attached to an iclog.
6289 xfsidbg_xiclogcb(xlog_in_core_t *iclog)
6291 xfs_log_callback_t *cb;
6292 kdb_symtab_t symtab;
6294 for (cb = iclog->ic_callback; cb != NULL; cb = cb->cb_next) {
6296 if (kdbnearsym((unsigned long)cb->cb_func, &symtab)) {
6297 unsigned long offval;
6299 offval = (unsigned long)cb->cb_func - symtab.sym_start;
6302 kdb_printf("func = %s+0x%lx",
6306 kdb_printf("func = %s", symtab.sym_name);
6308 kdb_printf("func = ?? 0x%p", (void *)cb->cb_func);
6310 kdb_printf(" arg 0x%p next 0x%p\n", cb->cb_arg, cb->cb_next);
6314 #ifdef XFS_LOG_TRACE
6316 * Print trace from incore log.
6319 xfsidbg_xiclogtrace(xlog_in_core_t *iclog)
6321 ktrace_entry_t *ktep;
6323 ktrace_t *kt = iclog->ic_trace;
6325 qprintf("iclog->ic_trace 0x%p\n", kt);
6326 ktep = ktrace_first(kt, &kts);
6327 while (ktep != NULL) {
6328 switch ((__psint_t)ktep->val[0]) {
6329 case XLOG_TRACE_GRAB_FLUSH: {
6330 qprintf("grabbing semaphore\n");
6333 case XLOG_TRACE_REL_FLUSH: {
6334 qprintf("releasing semaphore\n");
6337 case XLOG_TRACE_SLEEP_FLUSH: {
6338 qprintf("sleeping on semaphore\n");
6341 case XLOG_TRACE_WAKE_FLUSH: {
6342 qprintf("waking up on semaphore\n");
6348 ktep = ktrace_next(kt, &kts);
6350 } /* xfsidbg_xiclogtrace */
6354 * Print all of the inodes attached to the given mount structure.
6357 xfsidbg_xinodes(xfs_mount_t *mp)
6361 kdb_printf("xfs_mount at 0x%p\n", mp);
6365 if (ip->i_mount == NULL) {
6372 } while (ip != mp->m_inodes);
6374 kdb_printf("\nEnd of Inodes\n");
6378 xfsidbg_delayed_blocks(xfs_mount_t *mp)
6381 unsigned int total = 0;
6382 unsigned int icount = 0;
6387 if (ip->i_mount == NULL) {
6391 if (ip->i_delayed_blks) {
6392 total += ip->i_delayed_blks;
6396 } while (ip != mp->m_inodes);
6398 kdb_printf("delayed blocks total: %d in %d inodes\n", total, icount);
6402 xfsidbg_xinodes_quiesce(xfs_mount_t *mp)
6406 kdb_printf("xfs_mount at 0x%p\n", mp);
6410 if (ip->i_mount == NULL) {
6414 if (!(ip->i_flags & XFS_IQUIESCE)) {
6415 kdb_printf("ip 0x%p not quiesced\n", ip);
6418 } while (ip != mp->m_inodes);
6420 kdb_printf("\nEnd of Inodes\n");
6424 xfsidbg_get_cstate(int state)
6427 case XLOG_STATE_COVER_IDLE:
6429 case XLOG_STATE_COVER_NEED:
6431 case XLOG_STATE_COVER_DONE:
6433 case XLOG_STATE_COVER_NEED2:
6435 case XLOG_STATE_COVER_DONE2:
6443 * Print out an XFS log structure.
6446 xfsidbg_xlog(xlog_t *log)
6448 static char *t_flags[] = {
6449 "CHKSUM_MISMATCH", /* 0x01 */
6450 "ACTIVE_RECOVERY", /* 0x02 */
6451 "RECOVERY_NEEDED", /* 0x04 */
6452 "IO_ERROR", /* 0x08 */
6456 kdb_printf("xlog at 0x%p\n", log);
6457 kdb_printf("&flushsm: 0x%p flushcnt: %d tic_cnt: %d tic_tcnt: %d \n",
6458 &log->l_flushsema, log->l_flushcnt,
6459 log->l_ticket_cnt, log->l_ticket_tcnt);
6460 kdb_printf("freelist: 0x%p tail: 0x%p ICLOG: 0x%p \n",
6461 log->l_freelist, log->l_tail, log->l_iclog);
6462 kdb_printf("&icloglock: 0x%p tail_lsn: %s last_sync_lsn: %s \n",
6463 &log->l_icloglock, xfs_fmtlsn(&log->l_tail_lsn),
6464 xfs_fmtlsn(&log->l_last_sync_lsn));
6465 kdb_printf("mp: 0x%p xbuf: 0x%p l_covered_state: %s \n",
6466 log->l_mp, log->l_xbuf,
6467 xfsidbg_get_cstate(log->l_covered_state));
6468 kdb_printf("flags: ");
6469 printflags(log->l_flags, t_flags,"log");
6470 kdb_printf(" logBBstart: %lld logsize: %d logBBsize: %d\n",
6471 (long long) log->l_logBBstart,
6472 log->l_logsize,log->l_logBBsize);
6473 kdb_printf("curr_cycle: %d prev_cycle: %d curr_block: %d prev_block: %d\n",
6474 log->l_curr_cycle, log->l_prev_cycle, log->l_curr_block,
6476 kdb_printf("iclog_bak: 0x%p iclog_size: 0x%x (%d) num iclogs: %d\n",
6477 log->l_iclog_bak, log->l_iclog_size, log->l_iclog_size,
6479 kdb_printf("l_iclog_hsize %d l_iclog_heads %d\n",
6480 log->l_iclog_hsize, log->l_iclog_heads);
6481 kdb_printf("l_sectbb_log %u l_sectbb_mask %u\n",
6482 log->l_sectbb_log, log->l_sectbb_mask);
6483 kdb_printf("&grant_lock: 0x%p resHeadQ: 0x%p wrHeadQ: 0x%p\n",
6484 &log->l_grant_lock, log->l_reserve_headq, log->l_write_headq);
6485 kdb_printf("GResCycle: %d GResBytes: %d GWrCycle: %d GWrBytes: %d\n",
6486 log->l_grant_reserve_cycle, log->l_grant_reserve_bytes,
6487 log->l_grant_write_cycle, log->l_grant_write_bytes);
6488 qprintf("GResBlocks: %d GResRemain: %d GWrBlocks: %d GWrRemain: %d\n",
6489 (int)BTOBBT(log->l_grant_reserve_bytes),
6490 log->l_grant_reserve_bytes % BBSIZE,
6491 (int)BTOBBT(log->l_grant_write_bytes),
6492 log->l_grant_write_bytes % BBSIZE);
6493 #ifdef XFS_LOG_TRACE
6494 qprintf("trace: 0x%p grant_trace: use xlog value\n", log->l_trace);
6496 } /* xfsidbg_xlog */
6499 xfsidbg_print_trans_type(unsigned int t_type)
6502 case XFS_TRANS_SETATTR_NOT_SIZE: kdb_printf("SETATTR_NOT_SIZE");break;
6503 case XFS_TRANS_SETATTR_SIZE: kdb_printf("SETATTR_SIZE"); break;
6504 case XFS_TRANS_INACTIVE: kdb_printf("INACTIVE"); break;
6505 case XFS_TRANS_CREATE: kdb_printf("CREATE"); break;
6506 case XFS_TRANS_CREATE_TRUNC: kdb_printf("CREATE_TRUNC"); break;
6507 case XFS_TRANS_TRUNCATE_FILE: kdb_printf("TRUNCATE_FILE"); break;
6508 case XFS_TRANS_REMOVE: kdb_printf("REMOVE"); break;
6509 case XFS_TRANS_LINK: kdb_printf("LINK"); break;
6510 case XFS_TRANS_RENAME: kdb_printf("RENAME"); break;
6511 case XFS_TRANS_MKDIR: kdb_printf("MKDIR"); break;
6512 case XFS_TRANS_RMDIR: kdb_printf("RMDIR"); break;
6513 case XFS_TRANS_SYMLINK: kdb_printf("SYMLINK"); break;
6514 case XFS_TRANS_SET_DMATTRS: kdb_printf("SET_DMATTRS"); break;
6515 case XFS_TRANS_GROWFS: kdb_printf("GROWFS"); break;
6516 case XFS_TRANS_STRAT_WRITE: kdb_printf("STRAT_WRITE"); break;
6517 case XFS_TRANS_DIOSTRAT: kdb_printf("DIOSTRAT"); break;
6518 case XFS_TRANS_WRITE_SYNC: kdb_printf("WRITE_SYNC"); break;
6519 case XFS_TRANS_WRITEID: kdb_printf("WRITEID"); break;
6520 case XFS_TRANS_ADDAFORK: kdb_printf("ADDAFORK"); break;
6521 case XFS_TRANS_ATTRINVAL: kdb_printf("ATTRINVAL"); break;
6522 case XFS_TRANS_ATRUNCATE: kdb_printf("ATRUNCATE"); break;
6523 case XFS_TRANS_ATTR_SET: kdb_printf("ATTR_SET"); break;
6524 case XFS_TRANS_ATTR_RM: kdb_printf("ATTR_RM"); break;
6525 case XFS_TRANS_ATTR_FLAG: kdb_printf("ATTR_FLAG"); break;
6526 case XFS_TRANS_CLEAR_AGI_BUCKET:kdb_printf("CLEAR_AGI_BUCKET"); break;
6527 case XFS_TRANS_QM_SBCHANGE: kdb_printf("QM_SBCHANGE"); break;
6528 case XFS_TRANS_QM_QUOTAOFF: kdb_printf("QM_QUOTAOFF"); break;
6529 case XFS_TRANS_QM_DQALLOC: kdb_printf("QM_DQALLOC"); break;
6530 case XFS_TRANS_QM_SETQLIM: kdb_printf("QM_SETQLIM"); break;
6531 case XFS_TRANS_QM_DQCLUSTER: kdb_printf("QM_DQCLUSTER"); break;
6532 case XFS_TRANS_QM_QINOCREATE: kdb_printf("QM_QINOCREATE"); break;
6533 case XFS_TRANS_QM_QUOTAOFF_END: kdb_printf("QM_QOFF_END"); break;
6534 case XFS_TRANS_SB_UNIT: kdb_printf("SB_UNIT"); break;
6535 case XFS_TRANS_FSYNC_TS: kdb_printf("FSYNC_TS"); break;
6536 case XFS_TRANS_GROWFSRT_ALLOC: kdb_printf("GROWFSRT_ALLOC"); break;
6537 case XFS_TRANS_GROWFSRT_ZERO: kdb_printf("GROWFSRT_ZERO"); break;
6538 case XFS_TRANS_GROWFSRT_FREE: kdb_printf("GROWFSRT_FREE"); break;
6539 default: kdb_printf("unknown(0x%x)", t_type); break;
6543 #ifdef XFS_LOG_TRACE
6545 * Print grant trace for a log.
6548 xfsidbg_xlog_granttrace(xlog_t *log)
6550 ktrace_entry_t *ktep;
6554 unsigned long cnts,t_ocnt, t_cnt;
6556 if (((__psint_t)log) == ((__psint_t)-1)) {
6557 qprintf("Usage: xl_grtr <log>\n");
6560 if ((kt = log->l_grant_trace))
6561 qprintf("log->l_grant_trace 0x%p\n", kt);
6563 qprintf("log->l_grant_trace is empty!\n");
6566 ktep = ktrace_first(kt, &kts);
6567 while (ktep != NULL) {
6568 /* split cnts into two parts: cnt and ocnt */
6569 cnts = (unsigned long)ktep->val[13];
6570 t_ocnt = 0xff & cnts;
6573 qprintf("%d: %s [", i++, (char *)ktep->val[11]);
6574 xfsidbg_print_trans_type((unsigned long)ktep->val[12]);
6576 qprintf(" t_ocnt = %lu, t_cnt = %lu, t_curr_res = %lu, "
6577 "t_unit_res = %lu\n",
6578 t_ocnt, t_cnt, (unsigned long)ktep->val[14],
6579 (unsigned long)ktep->val[15]);
6580 qprintf(" tic:0x%p resQ:0x%p wrQ:0x%p ",
6581 ktep->val[0], ktep->val[1], ktep->val[2]);
6582 qprintf(" GrResC:%ld GrResB:%ld GrWrC:%ld GrWrB:%ld \n",
6583 (long)ktep->val[3], (long)ktep->val[4],
6584 (long)ktep->val[5], (long)ktep->val[6]);
6585 qprintf(" HeadC:%ld HeadB:%ld TailC:%ld TailB:%ld\n",
6586 (long)ktep->val[7], (long)ktep->val[8],
6587 (long)ktep->val[9], (long)ktep->val[10]);
6588 ktep = ktrace_next(kt, &kts);
6590 } /* xfsidbg_xlog_granttrace */
6594 * Print out an XFS recovery transaction
6597 xfsidbg_xlog_ritem(xlog_recover_item_t *item)
6599 int i = XLOG_MAX_REGIONS_IN_ITEM;
6601 kdb_printf("(xlog_recover_item 0x%p) ", item);
6602 kdb_printf("next: 0x%p prev: 0x%p type: %d cnt: %d ttl: %d\n",
6603 item->ri_next, item->ri_prev, ITEM_TYPE(item), item->ri_cnt,
6605 for ( ; i > 0; i--) {
6606 if (!item->ri_buf[XLOG_MAX_REGIONS_IN_ITEM-i].i_addr)
6608 kdb_printf("a: 0x%p l: %d ",
6609 item->ri_buf[XLOG_MAX_REGIONS_IN_ITEM-i].i_addr,
6610 item->ri_buf[XLOG_MAX_REGIONS_IN_ITEM-i].i_len);
6613 } /* xfsidbg_xlog_ritem */
6616 * Print out an XFS recovery transaction
6619 xfsidbg_xlog_rtrans(xlog_recover_t *trans)
6621 xlog_recover_item_t *rip, *first_rip;
6623 kdb_printf("(xlog_recover 0x%p) ", trans);
6624 kdb_printf("tid: %x type: %d items: %d ttid: 0x%x ",
6625 trans->r_log_tid, trans->r_theader.th_type,
6626 trans->r_theader.th_num_items, trans->r_theader.th_tid);
6627 kdb_printf("itemq: 0x%p\n", trans->r_itemq);
6628 if (trans->r_itemq) {
6629 rip = first_rip = trans->r_itemq;
6631 kdb_printf("(recovery item: 0x%p) ", rip);
6632 kdb_printf("type: %d cnt: %d total: %d\n",
6633 ITEM_TYPE(rip), rip->ri_cnt, rip->ri_total);
6635 } while (rip != first_rip);
6637 } /* xfsidbg_xlog_rtrans */
6640 xfsidbg_xlog_buf_logitem(xlog_recover_item_t *item)
6642 xfs_buf_log_format_t *buf_f;
6646 unsigned int *data_map;
6647 unsigned int map_size;
6650 buf_f = (xfs_buf_log_format_t *)item->ri_buf[0].i_addr;
6651 if (buf_f->blf_flags & XFS_BLI_INODE_BUF) {
6652 kdb_printf("\tINODE BUF <blkno=0x%Lx, len=0x%x>\n",
6653 buf_f->blf_blkno, buf_f->blf_len);
6654 } else if (buf_f->blf_flags &
6655 (XFS_BLI_UDQUOT_BUF|XFS_BLI_PDQUOT_BUF|XFS_BLI_GDQUOT_BUF)) {
6656 kdb_printf("\tDQUOT BUF <blkno=0x%Lx, len=0x%x>\n",
6657 buf_f->blf_blkno, buf_f->blf_len);
6659 data_map = buf_f->blf_data_map;
6660 map_size = buf_f->blf_map_size;
6661 kdb_printf("\tREG BUF <blkno=0x%Lx, len=0x%x map 0x%p size %d>\n",
6662 buf_f->blf_blkno, buf_f->blf_len, data_map, map_size);
6664 i = 0; /* 0 is the buf format structure */
6666 bit = xfs_next_bit(data_map, map_size, bit);
6669 nbits = xfs_contig_bits(data_map, map_size, bit);
6670 size = ((uint)bit << XFS_BLI_SHIFT)+(nbits<<XFS_BLI_SHIFT);
6671 kdb_printf("\t\tlogbuf.i_addr 0x%p, size 0x%x\n",
6672 item->ri_buf[i].i_addr, size);
6673 kdb_printf("\t\t\t\"");
6674 for (j=0; j<8 && j<size; j++) {
6675 kdb_printf("%02x", ((char *)item->ri_buf[i].i_addr)[j]);
6677 kdb_printf("...\"\n");
6686 * Print out an ENTIRE XFS recovery transaction
6689 xfsidbg_xlog_rtrans_entire(xlog_recover_t *trans)
6691 xlog_recover_item_t *item, *first_rip;
6693 kdb_printf("(Recovering Xact 0x%p) ", trans);
6694 kdb_printf("tid: %x type: %d nitems: %d ttid: 0x%x ",
6695 trans->r_log_tid, trans->r_theader.th_type,
6696 trans->r_theader.th_num_items, trans->r_theader.th_tid);
6697 kdb_printf("itemq: 0x%p\n", trans->r_itemq);
6698 if (trans->r_itemq) {
6699 item = first_rip = trans->r_itemq;
6702 kdb_printf("(recovery item: 0x%x) ", item);
6703 kdb_printf("type: %d cnt: %d total: %d\n",
6704 item->ri_type, item->ri_cnt, item->ri_total);
6706 if ((ITEM_TYPE(item) == XFS_LI_BUF) ||
6707 (ITEM_TYPE(item) == XFS_LI_6_1_BUF) ||
6708 (ITEM_TYPE(item) == XFS_LI_5_3_BUF)) {
6710 xfsidbg_xlog_buf_logitem(item);
6711 } else if ((ITEM_TYPE(item) == XFS_LI_INODE) ||
6712 (ITEM_TYPE(item) == XFS_LI_6_1_INODE) ||
6713 (ITEM_TYPE(item) == XFS_LI_5_3_INODE)) {
6714 kdb_printf("INODE:\n");
6715 } else if (ITEM_TYPE(item) == XFS_LI_EFI) {
6716 kdb_printf("EFI:\n");
6717 } else if (ITEM_TYPE(item) == XFS_LI_EFD) {
6718 kdb_printf("EFD:\n");
6719 } else if (ITEM_TYPE(item) == XFS_LI_DQUOT) {
6720 kdb_printf("DQUOT:\n");
6721 } else if ((ITEM_TYPE(item) == XFS_LI_QUOTAOFF)) {
6722 kdb_printf("QUOTAOFF:\n");
6724 kdb_printf("UNKNOWN LOGITEM 0x%x\n", ITEM_TYPE(item));
6726 item = item->ri_next;
6727 } while (item != first_rip);
6729 } /* xfsidbg_xlog_rtrans */
6732 * Print out an XFS ticket structure.
6735 xfsidbg_xlog_tic(xlog_ticket_t *tic)
6737 static char *t_flags[] = {
6739 "PERM_RES", /* 0x2 */
6744 kdb_printf("xlog_ticket at 0x%p\n", tic);
6745 kdb_printf("next: 0x%p prev: 0x%p tid: 0x%x \n",
6746 tic->t_next, tic->t_prev, tic->t_tid);
6747 kdb_printf("curr_res: %d unit_res: %d ocnt: %d cnt: %d\n",
6748 tic->t_curr_res, tic->t_unit_res, (int)tic->t_ocnt,
6750 kdb_printf("clientid: %c \n", tic->t_clientid);
6751 printflags(tic->t_flags, t_flags,"ticket");
6753 qprintf("trans type: ");
6754 xfsidbg_print_trans_type(tic->t_trans_type);
6756 } /* xfsidbg_xlog_tic */
6759 * Print out a single log item.
6762 xfsidbg_xlogitem(xfs_log_item_t *lip)
6764 xfs_log_item_t *bio_lip;
6765 static char *lid_type[] = {
6768 "5-3-inode", /* 2 */
6772 "6-1-inode", /* 6 */
6779 static char *li_flags[] = {
6784 kdb_printf("type %s mountp 0x%p flags ",
6785 lid_type[lip->li_type - XFS_LI_5_3_BUF + 1],
6787 printflags((uint)(lip->li_flags), li_flags,"log");
6789 kdb_printf("ail forw 0x%p ail back 0x%p lsn %s\ndesc %p ops 0x%p",
6790 lip->li_ail.ail_forw, lip->li_ail.ail_back,
6791 xfs_fmtlsn(&(lip->li_lsn)), lip->li_desc, lip->li_ops);
6792 kdb_printf(" iodonefunc &0x%p\n", lip->li_cb);
6793 if (lip->li_type == XFS_LI_BUF) {
6794 bio_lip = lip->li_bio_list;
6795 if (bio_lip != NULL) {
6796 kdb_printf("iodone list:\n");
6798 while (bio_lip != NULL) {
6799 kdb_printf("item 0x%p func 0x%p\n",
6800 bio_lip, bio_lip->li_cb);
6801 bio_lip = bio_lip->li_bio_list;
6804 switch (lip->li_type) {
6806 xfs_buf_item_print((xfs_buf_log_item_t *)lip, 0);
6809 xfs_inode_item_print((xfs_inode_log_item_t *)lip, 0);
6812 xfs_efi_item_print((xfs_efi_log_item_t *)lip, 0);
6815 xfs_efd_item_print((xfs_efd_log_item_t *)lip, 0);
6818 xfs_dquot_item_print((xfs_dq_logitem_t *)lip, 0);
6820 case XFS_LI_QUOTAOFF:
6821 xfs_qoff_item_print((xfs_qoff_logitem_t *)lip, 0);
6825 kdb_printf("Unknown item type %d\n", lip->li_type);
6831 * Print out a summary of the AIL hanging off of a mount struct.
6834 xfsidbg_xaildump(xfs_mount_t *mp)
6836 xfs_log_item_t *lip;
6837 static char *lid_type[] = {
6840 "5-3-inode", /* 2 */
6844 "6-1-inode", /* 6 */
6851 static char *li_flags[] = {
6857 if ((mp->m_ail.ail_forw == NULL) ||
6858 (mp->m_ail.ail_forw == (xfs_log_item_t *)&mp->m_ail)) {
6859 kdb_printf("AIL is empty\n");
6862 kdb_printf("AIL for mp 0x%p, oldest first\n", mp);
6863 lip = (xfs_log_item_t*)mp->m_ail.ail_forw;
6864 for (count = 0; lip; count++) {
6865 kdb_printf("[%d] type %s ", count,
6866 lid_type[lip->li_type - XFS_LI_5_3_BUF + 1]);
6867 printflags((uint)(lip->li_flags), li_flags, "flags:");
6868 kdb_printf(" lsn %s\n ", xfs_fmtlsn(&(lip->li_lsn)));
6869 switch (lip->li_type) {
6871 xfs_buf_item_print((xfs_buf_log_item_t *)lip, 1);
6874 xfs_inode_item_print((xfs_inode_log_item_t *)lip, 1);
6877 xfs_efi_item_print((xfs_efi_log_item_t *)lip, 1);
6880 xfs_efd_item_print((xfs_efd_log_item_t *)lip, 1);
6883 xfs_dquot_item_print((xfs_dq_logitem_t *)lip, 1);
6885 case XFS_LI_QUOTAOFF:
6886 xfs_qoff_item_print((xfs_qoff_logitem_t *)lip, 1);
6889 kdb_printf("Unknown item type %d\n", lip->li_type);
6893 if (lip->li_ail.ail_forw == (xfs_log_item_t*)&mp->m_ail) {
6896 lip = lip->li_ail.ail_forw;
6902 * Print xfs mount structure.
6905 xfsidbg_xmount(xfs_mount_t *mp)
6907 static char *xmount_flags[] = {
6908 "WSYNC", /* 0x0001 */
6909 "INO64", /* 0x0002 */
6910 "UNUSED_4", /* 0x0004 */
6911 "UNUSED_8", /* 0x0008 */
6912 "FSSHUTDOWN", /* 0x0010 */
6913 "NOATIME", /* 0x0020 */
6914 "RETERR", /* 0x0040 */
6915 "NOALIGN", /* 0x0080 */
6916 "ATTR2", /* 0x0100 */
6917 "UNUSED_200", /* 0x0200 */
6918 "NORECOVERY", /* 0x0400 */
6919 "SHARED", /* 0x0800 */
6920 "DFLT_IOSIZE", /* 0x1000 */
6921 "OSYNCISOSYNC", /* 0x2000 */
6922 "32BITINODES", /* 0x4000 */
6923 "32BITINOOPT", /* 0x8000 */
6924 "NOUUID", /* 0x10000 */
6925 "BARRIER", /* 0x20000 */
6926 "IDELETE", /* 0x40000 */
6927 "SWALLOC", /* 0x80000 */
6928 "IHASHSIZE", /* 0x100000 */
6929 "DIRSYNC", /* 0x200000 */
6930 "COMPAT_IOSIZE",/* 0x400000 */
6934 static char *quota_flags[] = {
6937 "UQCHKD", /* 0x0004 */
6940 "GQCHKD", /* 0x0020 */
6942 "UQACTV", /* 0x0080 */
6943 "GQACTV", /* 0x0100 */
6944 "QMAYBE", /* 0x0200 */
6948 kdb_printf("xfs_mount at 0x%p\n", mp);
6949 kdb_printf("vfsp 0x%p tid 0x%x ail_lock 0x%p &ail 0x%p\n",
6950 XFS_MTOVFS(mp), mp->m_tid, &mp->m_ail_lock, &mp->m_ail);
6951 kdb_printf("ail_gen 0x%x &sb 0x%p\n",
6952 mp->m_ail_gen, &mp->m_sb);
6953 kdb_printf("sb_lock 0x%p sb_bp 0x%p dev 0x%s logdev 0x%s rtdev 0x%s\n",
6954 &mp->m_sb_lock, mp->m_sb_bp,
6955 mp->m_ddev_targp ? devtoname(mp->m_ddev_targp->dev) : 0,
6956 mp->m_logdev_targp ? devtoname(mp->m_logdev_targp->dev) : 0,
6957 mp->m_rtdev_targp ? devtoname(mp->m_rtdev_targp->dev) : 0);
6958 kdb_printf("bsize %d agfrotor %d xfs_rotorstep %d agirotor %d\n",
6959 mp->m_bsize, mp->m_agfrotor, xfs_rotorstep, mp->m_agirotor);
6960 kdb_printf("ihash 0x%p ihsize %d\n",
6961 mp->m_ihash, mp->m_ihsize);
6962 kdb_printf("inodes 0x%p ilock 0x%p ireclaims 0x%x\n",
6963 mp->m_inodes, &mp->m_ilock, mp->m_ireclaims);
6964 kdb_printf("readio_log 0x%x readio_blocks 0x%x ",
6965 mp->m_readio_log, mp->m_readio_blocks);
6966 kdb_printf("writeio_log 0x%x writeio_blocks 0x%x\n",
6967 mp->m_writeio_log, mp->m_writeio_blocks);
6968 kdb_printf("logbufs %d logbsize %d LOG 0x%p\n", mp->m_logbufs,
6969 mp->m_logbsize, mp->m_log);
6970 kdb_printf("rsumlevels 0x%x rsumsize 0x%x rbmip 0x%p rsumip 0x%p\n",
6971 mp->m_rsumlevels, mp->m_rsumsize, mp->m_rbmip, mp->m_rsumip);
6972 kdb_printf("rootip 0x%p\n", mp->m_rootip);
6973 kdb_printf("dircook_elog %d blkbit_log %d blkbb_log %d agno_log %d\n",
6974 mp->m_dircook_elog, mp->m_blkbit_log, mp->m_blkbb_log,
6976 kdb_printf("agino_log %d nreadaheads %d inode cluster size %d\n",
6977 mp->m_agino_log, mp->m_nreadaheads,
6978 mp->m_inode_cluster_size);
6979 kdb_printf("blockmask 0x%x blockwsize 0x%x blockwmask 0x%x\n",
6980 mp->m_blockmask, mp->m_blockwsize, mp->m_blockwmask);
6981 kdb_printf("alloc_mxr[lf,nd] %d %d alloc_mnr[lf,nd] %d %d\n",
6982 mp->m_alloc_mxr[0], mp->m_alloc_mxr[1],
6983 mp->m_alloc_mnr[0], mp->m_alloc_mnr[1]);
6984 kdb_printf("bmap_dmxr[lfnr,ndnr] %d %d bmap_dmnr[lfnr,ndnr] %d %d\n",
6985 mp->m_bmap_dmxr[0], mp->m_bmap_dmxr[1],
6986 mp->m_bmap_dmnr[0], mp->m_bmap_dmnr[1]);
6987 kdb_printf("inobt_mxr[lf,nd] %d %d inobt_mnr[lf,nd] %d %d\n",
6988 mp->m_inobt_mxr[0], mp->m_inobt_mxr[1],
6989 mp->m_inobt_mnr[0], mp->m_inobt_mnr[1]);
6990 kdb_printf("ag_maxlevels %d bm_maxlevels[d,a] %d %d in_maxlevels %d\n",
6991 mp->m_ag_maxlevels, mp->m_bm_maxlevels[0],
6992 mp->m_bm_maxlevels[1], mp->m_in_maxlevels);
6993 kdb_printf("perag 0x%p &peraglock 0x%p &growlock 0x%p\n",
6994 mp->m_perag, &mp->m_peraglock, &mp->m_growlock);
6995 printflags(mp->m_flags, xmount_flags,"flags");
6996 kdb_printf("ialloc_inos %d ialloc_blks %d litino %d\n",
6997 mp->m_ialloc_inos, mp->m_ialloc_blks, mp->m_litino);
6998 kdb_printf("dir_node_ents %u attr_node_ents %u\n",
6999 mp->m_dir_node_ents, mp->m_attr_node_ents);
7000 kdb_printf("attroffset %d maxicount %Ld inoalign_mask %d\n",
7001 mp->m_attroffset, mp->m_maxicount, mp->m_inoalign_mask);
7002 kdb_printf("resblks %Ld resblks_avail %Ld\n", mp->m_resblks,
7003 mp->m_resblks_avail);
7005 kdb_printf(" inoadd %llx\n", (unsigned long long) mp->m_inoadd);
7009 if (mp->m_quotainfo)
7010 kdb_printf("quotainfo 0x%p (uqip = 0x%p, gqip = 0x%p)\n",
7012 mp->m_quotainfo->qi_uquotaip,
7013 mp->m_quotainfo->qi_gquotaip);
7015 kdb_printf("quotainfo NULL\n");
7016 printflags(mp->m_qflags, quota_flags,"quotaflags");
7018 kdb_printf("dalign %d swidth %d sinoalign %d attr_magicpct %d dir_magicpct %d\n",
7019 mp->m_dalign, mp->m_swidth, mp->m_sinoalign,
7020 mp->m_attr_magicpct, mp->m_dir_magicpct);
7021 kdb_printf("mk_sharedro %d inode_quiesce %d sectbb_log %d\n",
7022 mp->m_mk_sharedro, mp->m_inode_quiesce, mp->m_sectbb_log);
7023 kdb_printf("dirversion %d dirblkfsbs %d &dirops 0x%p\n",
7024 mp->m_dirversion, mp->m_dirblkfsbs, &mp->m_dirops);
7025 kdb_printf("dirblksize %d dirdatablk 0x%Lx dirleafblk 0x%Lx dirfreeblk 0x%Lx\n",
7027 (xfs_dfiloff_t)mp->m_dirdatablk,
7028 (xfs_dfiloff_t)mp->m_dirleafblk,
7029 (xfs_dfiloff_t)mp->m_dirfreeblk);
7030 kdb_printf("chsize %d chash 0x%p\n",
7031 mp->m_chsize, mp->m_chash);
7032 if (mp->m_fsname != NULL)
7033 kdb_printf("mountpoint \"%s\"\n", mp->m_fsname);
7035 kdb_printf("No name!!!\n");
7040 xfsidbg_xihash(xfs_mount_t *mp)
7049 int hist_bytes = mp->m_ihsize * sizeof(int);
7052 hist = (int *) kmem_alloc(hist_bytes, KM_SLEEP);
7055 kdb_printf("xfsidbg_xihash: kmalloc(%d) failed!\n",
7060 for (i = 0; i < mp->m_ihsize; i++) {
7061 ih = mp->m_ihash + i;
7063 for (ip = ih->ih_next; ip != NULL; ip = ip->i_next)
7068 numzeros = total = 0;
7070 for (i = 0; i < 21; i++)
7073 for (i = 0; i < mp->m_ihsize; i++) {
7074 kdb_printf("%d ", hist[i]);
7076 numzeros += hist[i] == 0 ? 1 : 0;
7083 kdb_printf("xfsidbg_xihash: (j > 20)/%d @ line # %d\n",
7093 kdb_printf("total inodes = %d, average length = %d, adjusted average = %d \n",
7094 total, total / mp->m_ihsize,
7095 total / (mp->m_ihsize - numzeros));
7097 for (i = 0; i < 21; i++) {
7098 kdb_printf("%d - %d , ", i, hist2[i]);
7101 kmem_free(hist, hist_bytes);
7105 * Command to print xfs inodes: kp xnode <addr>
7108 xfsidbg_xnode(xfs_inode_t *ip)
7110 static char *tab_flags[] = {
7111 "grio", /* XFS_IGRIO */
7112 "uiosize", /* XFS_IUIOSZ */
7113 "quiesce", /* XFS_IQUIESCE */
7114 "reclaim", /* XFS_IRECLAIM */
7115 "stale", /* XFS_ISTALE */
7119 kdb_printf("hash 0x%p next 0x%p prevp 0x%p mount 0x%p\n",
7124 kdb_printf("mnext 0x%p mprev 0x%p vnode 0x%p \n",
7128 kdb_printf("dev %s ino %s\n",
7129 devtoname(ip->i_mount->m_dev),
7130 xfs_fmtino(ip->i_ino, ip->i_mount));
7131 kdb_printf("blkno 0x%llx len 0x%x boffset 0x%x\n",
7132 (long long) ip->i_blkno,
7135 kdb_printf("transp 0x%p &itemp 0x%p\n",
7138 kdb_printf("&lock 0x%p &iolock 0x%p ",
7141 kdb_printf("&flock 0x%p (%d) pincount 0x%x\n",
7142 &ip->i_flock, valusema(&ip->i_flock),
7144 kdb_printf("udquotp 0x%p gdquotp 0x%p\n",
7145 ip->i_udquot, ip->i_gdquot);
7146 kdb_printf("new_size %Ld\n", ip->i_iocore.io_new_size);
7147 printflags((int)ip->i_flags, tab_flags, "flags");
7149 kdb_printf("update_core %d update size %d\n",
7150 (int)(ip->i_update_core), (int) ip->i_update_size);
7151 kdb_printf("gen 0x%x delayed blks %d",
7153 ip->i_delayed_blks);
7154 #ifdef XFS_BMAP_TRACE
7155 qprintf(" bmap_trace 0x%p\n", ip->i_xtrace);
7157 #ifdef XFS_BMBT_TRACE
7158 qprintf(" bmbt trace 0x%p\n", ip->i_btrace);
7161 qprintf(" rw trace 0x%p\n", ip->i_rwtrace);
7163 #ifdef XFS_ILOCK_TRACE
7164 qprintf(" ilock trace 0x%p\n", ip->i_lock_trace);
7166 #ifdef XFS_DIR2_TRACE
7167 qprintf(" dir trace 0x%p\n", ip->i_dir_trace);
7170 kdb_printf("chash 0x%p cnext 0x%p cprev 0x%p\n",
7174 xfs_xnode_fork("data", &ip->i_df);
7175 xfs_xnode_fork("attr", ip->i_afp);
7177 xfs_prdinode_core(&ip->i_d);
7181 xfsidbg_xcore(xfs_iocore_t *io)
7183 kdb_printf("io_obj 0x%p io_flags 0x%x io_mount 0x%p\n",
7184 io->io_obj, io->io_flags, io->io_mount);
7185 kdb_printf("new_size %Lx\n", io->io_new_size);
7189 * Command to print xfs inode cluster hash table: kp xchash <addr>
7192 xfsidbg_xchash(xfs_mount_t *mp)
7197 kdb_printf("m_chash 0x%p size %d\n",
7198 mp->m_chash, mp->m_chsize);
7199 for (i = 0; i < mp->m_chsize; i++) {
7200 ch = mp->m_chash + i;
7201 kdb_printf("[%3d] ch 0x%p chashlist 0x%p\n", i, ch, ch->ch_list);
7202 xfsidbg_xchashlist(ch->ch_list);
7207 * Command to print xfs inode cluster hash list: kp xchashlist <addr>
7210 xfsidbg_xchashlist(xfs_chashlist_t *chl)
7214 while (chl != NULL) {
7215 kdb_printf("hashlist inode 0x%p blkno %lld buf 0x%p",
7216 chl->chl_ip, (long long) chl->chl_blkno, chl->chl_buf);
7220 /* print inodes on chashlist */
7223 kdb_printf("0x%p ", ip);
7225 } while (ip != chl->chl_ip);
7233 * Print xfs per-ag data structures for filesystem.
7236 xfsidbg_xperag(xfs_mount_t *mp)
7238 xfs_agnumber_t agno;
7243 for (agno = 0; agno < mp->m_sb.sb_agcount; agno++, pag++) {
7244 kdb_printf("ag %d f_init %d i_init %d\n",
7245 agno, pag->pagf_init, pag->pagi_init);
7248 " f_levels[b,c] %d,%d f_flcount %d f_freeblks %d f_longest %d\n"
7249 " f__metadata %d\n",
7250 pag->pagf_levels[XFS_BTNUM_BNOi],
7251 pag->pagf_levels[XFS_BTNUM_CNTi],
7252 pag->pagf_flcount, pag->pagf_freeblks,
7253 pag->pagf_longest, pag->pagf_metadata);
7255 kdb_printf(" i_freecount %d i_inodeok %d\n",
7256 pag->pagi_freecount, pag->pagi_inodeok);
7257 if (pag->pagf_init) {
7258 for (busy = 0; busy < XFS_PAGB_NUM_SLOTS; busy++) {
7259 if (pag->pagb_list[busy].busy_length != 0) {
7261 " %04d: start %d length %d tp 0x%p\n",
7263 pag->pagb_list[busy].busy_start,
7264 pag->pagb_list[busy].busy_length,
7265 pag->pagb_list[busy].busy_tp);
7272 #ifdef CONFIG_XFS_QUOTA
7276 if (xfs_Gqm == NULL) {
7277 kdb_printf("NULL XQM!!\n");
7281 kdb_printf("usrhtab 0x%p grphtab 0x%p ndqfree 0x%x hashmask 0x%x\n",
7282 xfs_Gqm->qm_usr_dqhtable,
7283 xfs_Gqm->qm_grp_dqhtable,
7284 xfs_Gqm->qm_dqfreelist.qh_nelems,
7285 xfs_Gqm->qm_dqhashmask);
7286 kdb_printf("&freelist 0x%p, totaldquots 0x%x nrefs 0x%x\n",
7287 &xfs_Gqm->qm_dqfreelist,
7288 atomic_read(&xfs_Gqm->qm_totaldquots),
7294 xfsidbg_xqm_diskdq(xfs_disk_dquot_t *d)
7296 kdb_printf("magic 0x%x\tversion 0x%x\tID 0x%x (%d)\t\n",
7297 be16_to_cpu(d->d_magic), d->d_version,
7298 be32_to_cpu(d->d_id), be32_to_cpu(d->d_id));
7299 kdb_printf("bhard 0x%llx\tbsoft 0x%llx\tihard 0x%llx\tisoft 0x%llx\n",
7300 be64_to_cpu(d->d_blk_hardlimit),
7301 be64_to_cpu(d->d_blk_softlimit),
7302 be64_to_cpu(d->d_ino_hardlimit),
7303 be64_to_cpu(d->d_ino_softlimit));
7304 kdb_printf("bcount 0x%llx icount 0x%llx\n",
7305 be64_to_cpu(d->d_bcount),
7306 be64_to_cpu(d->d_icount));
7307 kdb_printf("btimer 0x%x itimer 0x%x \n",
7308 be32_to_cpu(d->d_btimer),
7309 be32_to_cpu(d->d_itimer));
7312 static char *xdq_flags[] = {
7313 "USER", /* XFS_DQ_USER */
7314 "PROJ", /* XFS_DQ_PROJ */
7315 "GROUP", /* XFS_DQ_GROUP */
7316 "FLKD", /* XFS_DQ_FLOCKED */
7317 "DIRTY", /* XFS_DQ_DIRTY */
7318 "WANT", /* XFS_DQ_WANT */
7319 "INACT", /* XFS_DQ_INACTIVE */
7320 "MARKER", /* XFS_DQ_MARKER */
7325 xfsidbg_xqm_dquot(xfs_dquot_t *dqp)
7327 kdb_printf("mount 0x%p hash 0x%p gdquotp 0x%p HL_next 0x%p HL_prevp 0x%p\n",
7333 kdb_printf("MPL_next 0x%p MPL_prevp 0x%p FL_next 0x%p FL_prev 0x%p\n",
7339 kdb_printf("nrefs 0x%x blkno 0x%llx boffset 0x%x ", dqp->q_nrefs,
7340 (unsigned long long)dqp->q_blkno, dqp->q_bufoffset);
7341 printflags(dqp->dq_flags, xdq_flags, "flags:");
7342 kdb_printf("res_bcount %llu res_icount %llu res_rtbcount %llu\n",
7343 (unsigned long long)dqp->q_res_bcount,
7344 (unsigned long long)dqp->q_res_icount,
7345 (unsigned long long)dqp->q_res_rtbcount);
7346 kdb_printf("qlock 0x%p flock 0x%p (%s) pincount 0x%x\n",
7349 (valusema(&dqp->q_flock) <= 0) ? "LCK" : "UNLKD",
7351 #ifdef XFS_DQUOT_TRACE
7352 qprintf("dqtrace 0x%p\n", dqp->q_trace);
7354 kdb_printf("disk-dquot 0x%p\n", &dqp->q_core);
7355 xfsidbg_xqm_diskdq(&dqp->q_core);
7360 #define XQMIDBG_LIST_PRINT(l, NXT) \
7364 kdb_printf("[#%d dquots]\n", (int) (l)->qh_nelems); \
7365 for (dqp = (l)->qh_next; dqp != NULL; dqp = dqp->NXT) {\
7367 "\t%d. [0x%p] \"%d (%s)\"\t blks = %d, inos = %d refs = %d\n", \
7368 ++i, dqp, (int) be32_to_cpu(dqp->q_core.d_id), \
7369 DQFLAGTO_TYPESTR(dqp), \
7370 (int) be64_to_cpu(dqp->q_core.d_bcount), \
7371 (int) be64_to_cpu(dqp->q_core.d_icount), \
7372 (int) dqp->q_nrefs); }\
7377 xfsidbg_xqm_dqattached_inos(xfs_mount_t *mp)
7384 if (ip->i_mount == NULL) {
7388 if (ip->i_udquot || ip->i_gdquot) {
7390 kdb_printf("inode = 0x%p, ino %d: udq 0x%p, gdq 0x%p\n",
7391 ip, (int)ip->i_ino, ip->i_udquot, ip->i_gdquot);
7394 } while (ip != mp->m_inodes);
7395 kdb_printf("\nNumber of inodes with dquots attached: %d\n", n);
7398 #ifdef CONFIG_XFS_QUOTA
7400 xfsidbg_xqm_freelist_print(xfs_frlist_t *qlist, char *title)
7404 kdb_printf("%s (#%d)\n", title, (int) qlist->qh_nelems);
7405 FOREACH_DQUOT_IN_FREELIST(dq, qlist) {
7406 kdb_printf("\t%d.\t\"%d (%s:0x%p)\"\t bcnt = %d, icnt = %d "
7408 ++i, (int) be32_to_cpu(dq->q_core.d_id),
7409 DQFLAGTO_TYPESTR(dq), dq,
7410 (int) be64_to_cpu(dq->q_core.d_bcount),
7411 (int) be64_to_cpu(dq->q_core.d_icount),
7417 xfsidbg_xqm_freelist(void)
7420 xfsidbg_xqm_freelist_print(&(xfs_Gqm->qm_dqfreelist), "Freelist");
7422 kdb_printf("NULL XQM!!\n");
7426 xfsidbg_xqm_htab(void)
7431 if (xfs_Gqm == NULL) {
7432 kdb_printf("NULL XQM!!\n");
7435 for (i = 0; i <= xfs_Gqm->qm_dqhashmask; i++) {
7436 h = &xfs_Gqm->qm_usr_dqhtable[i];
7438 kdb_printf("USR %d: ", i);
7439 XQMIDBG_LIST_PRINT(h, HL_NEXT);
7442 for (i = 0; i <= xfs_Gqm->qm_dqhashmask; i++) {
7443 h = &xfs_Gqm->qm_grp_dqhtable[i];
7445 kdb_printf("GRP/PRJ %d: ", i);
7446 XQMIDBG_LIST_PRINT(h, HL_NEXT);
7452 #ifdef XFS_DQUOT_TRACE
7454 xfsidbg_xqm_pr_dqentry(ktrace_entry_t *ktep)
7456 if ((__psint_t)ktep->val[0] == 0)
7458 switch ((__psint_t)ktep->val[0]) {
7459 case DQUOT_KTRACE_ENTRY:
7460 qprintf("[%ld] %s\t",
7461 (long)ktep->val[12], /* pid */
7462 (char *)ktep->val[1]);
7463 printflags((__psint_t)ktep->val[3], xdq_flags,"flgs ");
7464 qprintf("\nnrefs = %u, "
7468 "bcnt = 0x%x [0x%x | 0x%x], "
7469 "icnt = 0x%x [0x%x | 0x%x]\n"
7471 (unsigned int)(long)ktep->val[2], /* nrefs */
7472 (unsigned int)(long)ktep->val[3], /* flags */
7473 (unsigned int)(long)ktep->val[11], /* ID */
7474 (unsigned int)(long)ktep->val[4], /* res_bc */
7475 (unsigned int)(long)ktep->val[5], /* bcnt */
7476 (unsigned int)(long)ktep->val[8], /* bsoft */
7477 (unsigned int)(long)ktep->val[7], /* bhard */
7478 (unsigned int)(long)ktep->val[6], /* icnt */
7479 (unsigned int)(long)ktep->val[10], /* isoft */
7480 (unsigned int)(long)ktep->val[9], /* ihard */
7481 (long) ktep->val[13] /* time */
7486 qprintf("unknown dqtrace record\n");
7493 xfsidbg_xqm_dqtrace(xfs_dquot_t *dqp)
7495 ktrace_entry_t *ktep;
7498 if (dqp->q_trace == NULL) {
7499 qprintf("The xfs dquot trace buffer is not initialized\n");
7502 qprintf("xdqtrace dquot 0x%p\n", dqp);
7504 ktep = ktrace_first(dqp->q_trace, &kts);
7505 while (ktep != NULL) {
7506 if (xfsidbg_xqm_pr_dqentry(ktep))
7507 qprintf("---------------------------------\n");
7508 ktep = ktrace_next(dqp->q_trace, &kts);
7514 xfsidbg_xqm_mplist(xfs_mount_t *mp)
7516 if (mp->m_quotainfo == NULL) {
7517 kdb_printf("NULL quotainfo\n");
7521 XQMIDBG_LIST_PRINT(&(mp->m_quotainfo->qi_dqlist), MPL_NEXT);
7527 xfsidbg_xqm_qinfo(xfs_mount_t *mp)
7529 if (mp == NULL || mp->m_quotainfo == NULL) {
7530 kdb_printf("NULL quotainfo\n");
7534 kdb_printf("uqip 0x%p, gqip 0x%p, &pinlock 0x%p &dqlist 0x%p\n",
7535 mp->m_quotainfo->qi_uquotaip,
7536 mp->m_quotainfo->qi_gquotaip,
7537 &mp->m_quotainfo->qi_pinlock,
7538 &mp->m_quotainfo->qi_dqlist);
7540 kdb_printf("btmlimit 0x%x, itmlimit 0x%x, RTbtmlim 0x%x\n",
7541 (int)mp->m_quotainfo->qi_btimelimit,
7542 (int)mp->m_quotainfo->qi_itimelimit,
7543 (int)mp->m_quotainfo->qi_rtbtimelimit);
7545 kdb_printf("bwarnlim 0x%x, iwarnlim 0x%x, RTbwarnlim 0x%x\n",
7546 (int)mp->m_quotainfo->qi_bwarnlimit,
7547 (int)mp->m_quotainfo->qi_iwarnlimit,
7548 (int)mp->m_quotainfo->qi_rtbwarnlimit);
7550 kdb_printf("nreclaims %d, &qofflock 0x%p, chunklen 0x%x, dqperchunk 0x%x\n",
7551 (int)mp->m_quotainfo->qi_dqreclaims,
7552 &mp->m_quotainfo->qi_quotaofflock,
7553 (int)mp->m_quotainfo->qi_dqchunklen,
7554 (int)mp->m_quotainfo->qi_dqperchunk);
7558 xfsidbg_xqm_tpdqinfo(xfs_trans_t *tp)
7560 xfs_dqtrx_t *qa, *q;
7563 kdb_printf("dqinfo 0x%p\n", tp->t_dqinfo);
7566 kdb_printf("USR: \n");
7567 qa = tp->t_dqinfo->dqa_usrdquots;
7568 for (j = 0; j < 2; j++) {
7569 for (i = 0; i < XFS_QM_TRANS_MAXDQS; i++) {
7570 if (qa[i].qt_dquot == NULL)
7574 "\"%d\"[0x%p]: bres %d, bres-used %d, bdelta %d, del-delta %d, icnt-delta %d\n",
7575 (int) be32_to_cpu(q->qt_dquot->q_core.d_id),
7577 (int) q->qt_blk_res,
7578 (int) q->qt_blk_res_used,
7579 (int) q->qt_bcount_delta,
7580 (int) q->qt_delbcnt_delta,
7581 (int) q->qt_icount_delta);
7584 qa = tp->t_dqinfo->dqa_grpdquots;
7585 kdb_printf("GRP/PRJ: \n");
7591 * Print xfs superblock.
7594 xfsidbg_xsb(xfs_sb_t *sbp)
7596 kdb_printf("magicnum 0x%x blocksize 0x%x dblocks %Ld rblocks %Ld\n",
7597 sbp->sb_magicnum, sbp->sb_blocksize,
7598 sbp->sb_dblocks, sbp->sb_rblocks);
7599 kdb_printf("rextents %Ld uuid %s logstart %s\n",
7600 sbp->sb_rextents, xfs_fmtuuid(&sbp->sb_uuid),
7601 xfs_fmtfsblock(sbp->sb_logstart, NULL));
7602 kdb_printf("rootino %s ", xfs_fmtino(sbp->sb_rootino, NULL));
7603 kdb_printf("rbmino %s ", xfs_fmtino(sbp->sb_rbmino, NULL));
7604 kdb_printf("rsumino %s\n", xfs_fmtino(sbp->sb_rsumino, NULL));
7605 kdb_printf("rextsize 0x%x agblocks 0x%x agcount 0x%x rbmblocks 0x%x\n",
7606 sbp->sb_rextsize, sbp->sb_agblocks, sbp->sb_agcount,
7608 kdb_printf("logblocks 0x%x versionnum 0x%x sectsize 0x%x inodesize 0x%x\n",
7609 sbp->sb_logblocks, sbp->sb_versionnum, sbp->sb_sectsize,
7611 kdb_printf("inopblock 0x%x blocklog 0x%x sectlog 0x%x inodelog 0x%x\n",
7612 sbp->sb_inopblock, sbp->sb_blocklog, sbp->sb_sectlog,
7614 kdb_printf("inopblog %d agblklog %d rextslog %d inprogress %d imax_pct %d\n",
7615 sbp->sb_inopblog, sbp->sb_agblklog, sbp->sb_rextslog,
7616 sbp->sb_inprogress, sbp->sb_imax_pct);
7617 kdb_printf("icount %Lx ifree %Lx fdblocks %Lx frextents %Lx\n",
7618 sbp->sb_icount, sbp->sb_ifree,
7619 sbp->sb_fdblocks, sbp->sb_frextents);
7620 kdb_printf("uquotino %s ", xfs_fmtino(sbp->sb_uquotino, NULL));
7621 kdb_printf("gquotino %s ", xfs_fmtino(sbp->sb_gquotino, NULL));
7622 kdb_printf("qflags 0x%x flags 0x%x shared_vn %d inoaligmt %d\n",
7623 sbp->sb_qflags, sbp->sb_flags, sbp->sb_shared_vn,
7624 sbp->sb_inoalignmt);
7625 kdb_printf("unit %d width %d dirblklog %d\n",
7626 sbp->sb_unit, sbp->sb_width, sbp->sb_dirblklog);
7627 kdb_printf("log sunit %d\n", sbp->sb_logsunit);
7631 xfsidbg_xsb_convert(xfs_sb_t *sbp)
7635 xfs_xlatesb(sbp, &sb, 1, XFS_SB_ALL_BITS);
7637 kdb_printf("<converted>\n");
7642 * Print out an XFS transaction structure. Print summaries for
7643 * each of the items.
7646 xfsidbg_xtp(xfs_trans_t *tp)
7648 xfs_log_item_chunk_t *licp;
7649 xfs_log_item_desc_t *lidp;
7650 xfs_log_busy_chunk_t *lbcp;
7653 static char *xtp_flags[] = {
7655 "sb_dirty", /* 0x2 */
7656 "perm_log_res", /* 0x4 */
7658 "dq_dirty", /* 0x10 */
7661 static char *lid_flags[] = {
7664 "sync unlock", /* 0x4 */
7665 "buf stale", /* 0x8 */
7669 kdb_printf("tp 0x%p type ", tp);
7670 xfsidbg_print_trans_type(tp->t_type);
7671 kdb_printf(" mount 0x%p\n", tp->t_mountp);
7672 kdb_printf("flags ");
7673 printflags(tp->t_flags, xtp_flags,"xtp");
7675 kdb_printf("callback 0x%p forw 0x%p back 0x%p\n",
7676 &tp->t_logcb, tp->t_forw, tp->t_back);
7677 kdb_printf("log res %d block res %d block res used %d\n",
7678 tp->t_log_res, tp->t_blk_res, tp->t_blk_res_used);
7679 kdb_printf("rt res %d rt res used %d\n", tp->t_rtx_res,
7680 tp->t_rtx_res_used);
7681 kdb_printf("ticket 0x%lx lsn %s commit_lsn %s\n",
7682 (unsigned long) tp->t_ticket,
7683 xfs_fmtlsn(&tp->t_lsn),
7684 xfs_fmtlsn(&tp->t_commit_lsn));
7685 kdb_printf("callback 0x%p callarg 0x%p\n",
7686 tp->t_callback, tp->t_callarg);
7687 kdb_printf("icount delta %ld ifree delta %ld\n",
7688 tp->t_icount_delta, tp->t_ifree_delta);
7689 kdb_printf("blocks delta %ld res blocks delta %ld\n",
7690 tp->t_fdblocks_delta, tp->t_res_fdblocks_delta);
7691 kdb_printf("rt delta %ld res rt delta %ld\n",
7692 tp->t_frextents_delta, tp->t_res_frextents_delta);
7693 kdb_printf("ag freeblks delta %ld ag flist delta %ld ag btree delta %ld\n",
7694 tp->t_ag_freeblks_delta, tp->t_ag_flist_delta,
7695 tp->t_ag_btree_delta);
7696 kdb_printf("dblocks delta %ld agcount delta %ld imaxpct delta %ld\n",
7697 tp->t_dblocks_delta, tp->t_agcount_delta, tp->t_imaxpct_delta);
7698 kdb_printf("rextsize delta %ld rbmblocks delta %ld\n",
7699 tp->t_rextsize_delta, tp->t_rbmblocks_delta);
7700 kdb_printf("rblocks delta %ld rextents delta %ld rextslog delta %ld\n",
7701 tp->t_rblocks_delta, tp->t_rextents_delta,
7702 tp->t_rextslog_delta);
7703 kdb_printf("dqinfo 0x%p\n", tp->t_dqinfo);
7704 kdb_printf("log items:\n");
7705 licp = &tp->t_items;
7707 while (licp != NULL) {
7708 if (XFS_LIC_ARE_ALL_FREE(licp)) {
7709 licp = licp->lic_next;
7713 for (i = 0; i < licp->lic_unused; i++) {
7714 if (XFS_LIC_ISFREE(licp, i)) {
7718 lidp = XFS_LIC_SLOT(licp, i);
7720 kdb_printf("chunk %d index %d item 0x%p size %d\n",
7721 chunk, i, lidp->lid_item, lidp->lid_size);
7722 kdb_printf("flags ");
7723 printflags(lidp->lid_flags, lid_flags,"lic");
7725 xfsidbg_xlogitem(lidp->lid_item);
7728 licp = licp->lic_next;
7731 kdb_printf("log busy free %d, list:\n", tp->t_busy_free);
7734 while (lbcp != NULL) {
7735 kdb_printf("Chunk %d at 0x%p next 0x%p free 0x%08x unused %d\n",
7736 chunk, lbcp, lbcp->lbc_next, lbcp->lbc_free,
7738 for (i = 0; i < XFS_LBC_NUM_SLOTS; i++) {
7739 kdb_printf(" %02d: ag %d idx %d\n",
7741 lbcp->lbc_busy[i].lbc_ag,
7742 lbcp->lbc_busy[i].lbc_idx);
7744 lbcp = lbcp->lbc_next;
7752 xfs_trans_reservations_t *xtrp;
7754 xtrp = &mp->m_reservations;
7755 kdb_printf("write: %d\ttruncate: %d\trename: %d\n",
7756 xtrp->tr_write, xtrp->tr_itruncate, xtrp->tr_rename);
7757 kdb_printf("link: %d\tremove: %d\tsymlink: %d\n",
7758 xtrp->tr_link, xtrp->tr_remove, xtrp->tr_symlink);
7759 kdb_printf("create: %d\tmkdir: %d\tifree: %d\n",
7760 xtrp->tr_create, xtrp->tr_mkdir, xtrp->tr_ifree);
7761 kdb_printf("ichange: %d\tgrowdata: %d\tswrite: %d\n",
7762 xtrp->tr_ichange, xtrp->tr_growdata, xtrp->tr_swrite);
7763 kdb_printf("addafork: %d\twriteid: %d\tattrinval: %d\n",
7764 xtrp->tr_addafork, xtrp->tr_writeid, xtrp->tr_attrinval);
7765 kdb_printf("attrset: %d\tattrrm: %d\tclearagi: %d\n",
7766 xtrp->tr_attrset, xtrp->tr_attrrm, xtrp->tr_clearagi);
7767 kdb_printf("growrtalloc: %d\tgrowrtzero: %d\tgrowrtfree: %d\n",
7768 xtrp->tr_growrtalloc, xtrp->tr_growrtzero, xtrp->tr_growrtfree);