1/* 2 * Copyright (c) 2008 Silicon Graphics, Inc. 3 * All Rights Reserved. 4 * 5 * This program is free software; you can redistribute it and/or 6 * modify it under the terms of the GNU General Public License as 7 * published by the Free Software Foundation. 8 * 9 * This program is distributed in the hope that it would be useful, 10 * but WITHOUT ANY WARRANTY; without even the implied warranty of 11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 12 * GNU General Public License for more details. 13 * 14 * You should have received a copy of the GNU General Public License 15 * along with this program; if not, write the Free Software Foundation, 16 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA 17 */ 18#include "xfs.h" 19#include "xfs_types.h" 20#include "xfs_inum.h" 21#include "xfs_bmap_btree.h" 22#include "xfs_alloc_btree.h" 23#include "xfs_ialloc_btree.h" 24#include "xfs_inode.h" 25#include "xfs_btree.h" 26#include "xfs_btree_trace.h" 27 28STATIC void 29xfs_btree_trace_ptr( 30 struct xfs_btree_cur *cur, 31 union xfs_btree_ptr ptr, 32 __psunsigned_t *high, 33 __psunsigned_t *low) 34{ 35 if (cur->bc_flags & XFS_BTREE_LONG_PTRS) { 36 __u64 val = be64_to_cpu(ptr.l); 37 *high = val >> 32; 38 *low = (int)val; 39 } else { 40 *high = 0; 41 *low = be32_to_cpu(ptr.s); 42 } 43} 44 45/* 46 * Add a trace buffer entry for arguments, for a buffer & 1 integer arg. 47 */ 48void 49xfs_btree_trace_argbi( 50 const char *func, 51 struct xfs_btree_cur *cur, 52 struct xfs_buf *b, 53 int i, 54 int line) 55{ 56 cur->bc_ops->trace_enter(cur, func, XBT_ARGS, XFS_BTREE_KTRACE_ARGBI, 57 line, (__psunsigned_t)b, i, 0, 0, 0, 0, 0, 58 0, 0, 0, 0); 59} 60 61/* 62 * Add a trace buffer entry for arguments, for a buffer & 2 integer args. 63 */ 64void 65xfs_btree_trace_argbii( 66 const char *func, 67 struct xfs_btree_cur *cur, 68 struct xfs_buf *b, 69 int i0, 70 int i1, 71 int line) 72{ 73 cur->bc_ops->trace_enter(cur, func, XBT_ARGS, XFS_BTREE_KTRACE_ARGBII, 74 line, (__psunsigned_t)b, i0, i1, 0, 0, 0, 0, 75 0, 0, 0, 0); 76} 77 78/* 79 * Add a trace buffer entry for arguments, for 3 block-length args 80 * and an integer arg. 81 */ 82void 83xfs_btree_trace_argfffi( 84 const char *func, 85 struct xfs_btree_cur *cur, 86 xfs_dfiloff_t o, 87 xfs_dfsbno_t b, 88 xfs_dfilblks_t i, 89 int j, 90 int line) 91{ 92 cur->bc_ops->trace_enter(cur, func, XBT_ARGS, XFS_BTREE_KTRACE_ARGFFFI, 93 line, 94 o >> 32, (int)o, 95 b >> 32, (int)b, 96 i >> 32, (int)i, 97 (int)j, 0, 0, 0, 0); 98} 99 100/* 101 * Add a trace buffer entry for arguments, for one integer arg. 102 */ 103void 104xfs_btree_trace_argi( 105 const char *func, 106 struct xfs_btree_cur *cur, 107 int i, 108 int line) 109{ 110 cur->bc_ops->trace_enter(cur, func, XBT_ARGS, XFS_BTREE_KTRACE_ARGI, 111 line, i, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0); 112} 113 114/* 115 * Add a trace buffer entry for arguments, for int, fsblock, key. 116 */ 117void 118xfs_btree_trace_argipk( 119 const char *func, 120 struct xfs_btree_cur *cur, 121 int i, 122 union xfs_btree_ptr ptr, 123 union xfs_btree_key *key, 124 int line) 125{ 126 __psunsigned_t high, low; 127 __uint64_t l0, l1; 128 129 xfs_btree_trace_ptr(cur, ptr, &high, &low); 130 cur->bc_ops->trace_key(cur, key, &l0, &l1); 131 cur->bc_ops->trace_enter(cur, func, XBT_ARGS, XFS_BTREE_KTRACE_ARGIPK, 132 line, i, high, low, 133 l0 >> 32, (int)l0, 134 l1 >> 32, (int)l1, 135 0, 0, 0, 0); 136} 137 138/* 139 * Add a trace buffer entry for arguments, for int, fsblock, rec. 140 */ 141void 142xfs_btree_trace_argipr( 143 const char *func, 144 struct xfs_btree_cur *cur, 145 int i, 146 union xfs_btree_ptr ptr, 147 union xfs_btree_rec *rec, 148 int line) 149{ 150 __psunsigned_t high, low; 151 __uint64_t l0, l1, l2; 152 153 xfs_btree_trace_ptr(cur, ptr, &high, &low); 154 cur->bc_ops->trace_record(cur, rec, &l0, &l1, &l2); 155 cur->bc_ops->trace_enter(cur, func, XBT_ARGS, XFS_BTREE_KTRACE_ARGIPR, 156 line, i, 157 high, low, 158 l0 >> 32, (int)l0, 159 l1 >> 32, (int)l1, 160 l2 >> 32, (int)l2, 161 0, 0); 162} 163 164/* 165 * Add a trace buffer entry for arguments, for int, key. 166 */ 167void 168xfs_btree_trace_argik( 169 const char *func, 170 struct xfs_btree_cur *cur, 171 int i, 172 union xfs_btree_key *key, 173 int line) 174{ 175 __uint64_t l0, l1; 176 177 cur->bc_ops->trace_key(cur, key, &l0, &l1); 178 cur->bc_ops->trace_enter(cur, func, XBT_ARGS, XFS_BTREE_KTRACE_ARGIK, 179 line, i, 180 l0 >> 32, (int)l0, 181 l1 >> 32, (int)l1, 182 0, 0, 0, 0, 0, 0); 183} 184 185/* 186 * Add a trace buffer entry for arguments, for record. 187 */ 188void 189xfs_btree_trace_argr( 190 const char *func, 191 struct xfs_btree_cur *cur, 192 union xfs_btree_rec *rec, 193 int line) 194{ 195 __uint64_t l0, l1, l2; 196 197 cur->bc_ops->trace_record(cur, rec, &l0, &l1, &l2); 198 cur->bc_ops->trace_enter(cur, func, XBT_ARGS, XFS_BTREE_KTRACE_ARGR, 199 line, 200 l0 >> 32, (int)l0, 201 l1 >> 32, (int)l1, 202 l2 >> 32, (int)l2, 203 0, 0, 0, 0, 0); 204} 205 206/* 207 * Add a trace buffer entry for the cursor/operation. 208 */ 209void 210xfs_btree_trace_cursor( 211 const char *func, 212 struct xfs_btree_cur *cur, 213 int type, 214 int line) 215{ 216 __uint32_t s0; 217 __uint64_t l0, l1; 218 char *s; 219 220 switch (type) { 221 case XBT_ARGS: 222 s = "args"; 223 break; 224 case XBT_ENTRY: 225 s = "entry"; 226 break; 227 case XBT_ERROR: 228 s = "error"; 229 break; 230 case XBT_EXIT: 231 s = "exit"; 232 break; 233 default: 234 s = "unknown"; 235 break; 236 } 237 238 cur->bc_ops->trace_cursor(cur, &s0, &l0, &l1); 239 cur->bc_ops->trace_enter(cur, func, s, XFS_BTREE_KTRACE_CUR, line, 240 s0, 241 l0 >> 32, (int)l0, 242 l1 >> 32, (int)l1, 243 (__psunsigned_t)cur->bc_bufs[0], 244 (__psunsigned_t)cur->bc_bufs[1], 245 (__psunsigned_t)cur->bc_bufs[2], 246 (__psunsigned_t)cur->bc_bufs[3], 247 (cur->bc_ptrs[0] << 16) | cur->bc_ptrs[1], 248 (cur->bc_ptrs[2] << 16) | cur->bc_ptrs[3]); 249} 250