[XFS] remove restricted chown parameter from xfs linux
[linux-2.6] / 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 }