fs/xfs/xfs_btree_trace.c

   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
  28 STATIC void
  29 xfs_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  */
  48 void
  49 xfs_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  */
  64 void
  65 xfs_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  */
  82 void
  83 xfs_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  */
 103 void
 104 xfs_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  */
 117 void
 118 xfs_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  */
 141 void
 142 xfs_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  */
 167 void
 168 xfs_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  */
 188 void
 189 xfs_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  */
 209 void
 210 xfs_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 }