Merge master.kernel.org:/pub/scm/linux/kernel/git/davej/cpufreq
[linux-2.6] / fs / xfs / support / ktrace.c
1 /*
2  * Copyright (c) 2000-2003,2005 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
20 static kmem_zone_t *ktrace_hdr_zone;
21 static kmem_zone_t *ktrace_ent_zone;
22 static int          ktrace_zentries;
23
24 void
25 ktrace_init(int zentries)
26 {
27         ktrace_zentries = zentries;
28
29         ktrace_hdr_zone = kmem_zone_init(sizeof(ktrace_t),
30                                         "ktrace_hdr");
31         ASSERT(ktrace_hdr_zone);
32
33         ktrace_ent_zone = kmem_zone_init(ktrace_zentries
34                                         * sizeof(ktrace_entry_t),
35                                         "ktrace_ent");
36         ASSERT(ktrace_ent_zone);
37 }
38
39 void
40 ktrace_uninit(void)
41 {
42         kmem_zone_destroy(ktrace_hdr_zone);
43         kmem_zone_destroy(ktrace_ent_zone);
44 }
45
46 /*
47  * ktrace_alloc()
48  *
49  * Allocate a ktrace header and enough buffering for the given
50  * number of entries.
51  */
52 ktrace_t *
53 ktrace_alloc(int nentries, unsigned int __nocast sleep)
54 {
55         ktrace_t        *ktp;
56         ktrace_entry_t  *ktep;
57
58         ktp = (ktrace_t*)kmem_zone_alloc(ktrace_hdr_zone, sleep);
59
60         if (ktp == (ktrace_t*)NULL) {
61                 /*
62                  * KM_SLEEP callers don't expect failure.
63                  */
64                 if (sleep & KM_SLEEP)
65                         panic("ktrace_alloc: NULL memory on KM_SLEEP request!");
66
67                 return NULL;
68         }
69
70         /*
71          * Special treatment for buffers with the ktrace_zentries entries
72          */
73         if (nentries == ktrace_zentries) {
74                 ktep = (ktrace_entry_t*)kmem_zone_zalloc(ktrace_ent_zone,
75                                                             sleep);
76         } else {
77                 ktep = (ktrace_entry_t*)kmem_zalloc((nentries * sizeof(*ktep)),
78                                                             sleep);
79         }
80
81         if (ktep == NULL) {
82                 /*
83                  * KM_SLEEP callers don't expect failure.
84                  */
85                 if (sleep & KM_SLEEP)
86                         panic("ktrace_alloc: NULL memory on KM_SLEEP request!");
87
88                 kmem_free(ktp, sizeof(*ktp));
89
90                 return NULL;
91         }
92
93         spinlock_init(&(ktp->kt_lock), "kt_lock");
94
95         ktp->kt_entries  = ktep;
96         ktp->kt_nentries = nentries;
97         ktp->kt_index    = 0;
98         ktp->kt_rollover = 0;
99         return ktp;
100 }
101
102
103 /*
104  * ktrace_free()
105  *
106  * Free up the ktrace header and buffer.  It is up to the caller
107  * to ensure that no-one is referencing it.
108  */
109 void
110 ktrace_free(ktrace_t *ktp)
111 {
112         int     entries_size;
113
114         if (ktp == (ktrace_t *)NULL)
115                 return;
116
117         spinlock_destroy(&ktp->kt_lock);
118
119         /*
120          * Special treatment for the Vnode trace buffer.
121          */
122         if (ktp->kt_nentries == ktrace_zentries) {
123                 kmem_zone_free(ktrace_ent_zone, ktp->kt_entries);
124         } else {
125                 entries_size = (int)(ktp->kt_nentries * sizeof(ktrace_entry_t));
126
127                 kmem_free(ktp->kt_entries, entries_size);
128         }
129
130         kmem_zone_free(ktrace_hdr_zone, ktp);
131 }
132
133
134 /*
135  * Enter the given values into the "next" entry in the trace buffer.
136  * kt_index is always the index of the next entry to be filled.
137  */
138 void
139 ktrace_enter(
140         ktrace_t        *ktp,
141         void            *val0,
142         void            *val1,
143         void            *val2,
144         void            *val3,
145         void            *val4,
146         void            *val5,
147         void            *val6,
148         void            *val7,
149         void            *val8,
150         void            *val9,
151         void            *val10,
152         void            *val11,
153         void            *val12,
154         void            *val13,
155         void            *val14,
156         void            *val15)
157 {
158         static DEFINE_SPINLOCK(wrap_lock);
159         unsigned long   flags;
160         int             index;
161         ktrace_entry_t  *ktep;
162
163         ASSERT(ktp != NULL);
164
165         /*
166          * Grab an entry by pushing the index up to the next one.
167          */
168         spin_lock_irqsave(&wrap_lock, flags);
169         index = ktp->kt_index;
170         if (++ktp->kt_index == ktp->kt_nentries)
171                 ktp->kt_index = 0;
172         spin_unlock_irqrestore(&wrap_lock, flags);
173
174         if (!ktp->kt_rollover && index == ktp->kt_nentries - 1)
175                 ktp->kt_rollover = 1;
176
177         ASSERT((index >= 0) && (index < ktp->kt_nentries));
178
179         ktep = &(ktp->kt_entries[index]);
180
181         ktep->val[0]  = val0;
182         ktep->val[1]  = val1;
183         ktep->val[2]  = val2;
184         ktep->val[3]  = val3;
185         ktep->val[4]  = val4;
186         ktep->val[5]  = val5;
187         ktep->val[6]  = val6;
188         ktep->val[7]  = val7;
189         ktep->val[8]  = val8;
190         ktep->val[9]  = val9;
191         ktep->val[10] = val10;
192         ktep->val[11] = val11;
193         ktep->val[12] = val12;
194         ktep->val[13] = val13;
195         ktep->val[14] = val14;
196         ktep->val[15] = val15;
197 }
198
199 /*
200  * Return the number of entries in the trace buffer.
201  */
202 int
203 ktrace_nentries(
204         ktrace_t        *ktp)
205 {
206         if (ktp == NULL) {
207                 return 0;
208         }
209
210         return (ktp->kt_rollover ? ktp->kt_nentries : ktp->kt_index);
211 }
212
213 /*
214  * ktrace_first()
215  *
216  * This is used to find the start of the trace buffer.
217  * In conjunction with ktrace_next() it can be used to
218  * iterate through the entire trace buffer.  This code does
219  * not do any locking because it is assumed that it is called
220  * from the debugger.
221  *
222  * The caller must pass in a pointer to a ktrace_snap
223  * structure in which we will keep some state used to
224  * iterate through the buffer.  This state must not touched
225  * by any code outside of this module.
226  */
227 ktrace_entry_t *
228 ktrace_first(ktrace_t   *ktp, ktrace_snap_t     *ktsp)
229 {
230         ktrace_entry_t  *ktep;
231         int             index;
232         int             nentries;
233
234         if (ktp->kt_rollover)
235                 index = ktp->kt_index;
236         else
237                 index = 0;
238
239         ktsp->ks_start = index;
240         ktep = &(ktp->kt_entries[index]);
241
242         nentries = ktrace_nentries(ktp);
243         index++;
244         if (index < nentries) {
245                 ktsp->ks_index = index;
246         } else {
247                 ktsp->ks_index = 0;
248                 if (index > nentries)
249                         ktep = NULL;
250         }
251         return ktep;
252 }
253
254 /*
255  * ktrace_next()
256  *
257  * This is used to iterate through the entries of the given
258  * trace buffer.  The caller must pass in the ktrace_snap_t
259  * structure initialized by ktrace_first().  The return value
260  * will be either a pointer to the next ktrace_entry or NULL
261  * if all of the entries have been traversed.
262  */
263 ktrace_entry_t *
264 ktrace_next(
265         ktrace_t        *ktp,
266         ktrace_snap_t   *ktsp)
267 {
268         int             index;
269         ktrace_entry_t  *ktep;
270
271         index = ktsp->ks_index;
272         if (index == ktsp->ks_start) {
273                 ktep = NULL;
274         } else {
275                 ktep = &ktp->kt_entries[index];
276         }
277
278         index++;
279         if (index == ktrace_nentries(ktp)) {
280                 ktsp->ks_index = 0;
281         } else {
282                 ktsp->ks_index = index;
283         }
284
285         return ktep;
286 }
287
288 /*
289  * ktrace_skip()
290  *
291  * Skip the next "count" entries and return the entry after that.
292  * Return NULL if this causes us to iterate past the beginning again.
293  */
294 ktrace_entry_t *
295 ktrace_skip(
296         ktrace_t        *ktp,
297         int             count,
298         ktrace_snap_t   *ktsp)
299 {
300         int             index;
301         int             new_index;
302         ktrace_entry_t  *ktep;
303         int             nentries = ktrace_nentries(ktp);
304
305         index = ktsp->ks_index;
306         new_index = index + count;
307         while (new_index >= nentries) {
308                 new_index -= nentries;
309         }
310         if (index == ktsp->ks_start) {
311                 /*
312                  * We've iterated around to the start, so we're done.
313                  */
314                 ktep = NULL;
315         } else if ((new_index < index) && (index < ktsp->ks_index)) {
316                 /*
317                  * We've skipped past the start again, so we're done.
318                  */
319                 ktep = NULL;
320                 ktsp->ks_index = ktsp->ks_start;
321         } else {
322                 ktep = &(ktp->kt_entries[new_index]);
323                 new_index++;
324                 if (new_index == nentries) {
325                         ktsp->ks_index = 0;
326                 } else {
327                         ktsp->ks_index = new_index;
328                 }
329         }
330         return ktep;
331 }