[PATCH] more SPIN_LOCK_UNLOCKED -> DEFINE_SPINLOCK conversions
[linux-3.10.git] / fs / xfs / support / ktrace.c
1 /*
2  * Copyright (c) 2000-2003 Silicon Graphics, Inc.  All Rights Reserved.
3  *
4  * This program is free software; you can redistribute it and/or modify it
5  * under the terms of version 2 of the GNU General Public License as
6  * published by the Free Software Foundation.
7  *
8  * This program is distributed in the hope that it would be useful, but
9  * WITHOUT ANY WARRANTY; without even the implied warranty of
10  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
11  *
12  * Further, this software is distributed without any warranty that it is
13  * free of the rightful claim of any third person regarding infringement
14  * or the like.  Any license provided herein, whether implied or
15  * otherwise, applies only to this software file.  Patent licenses, if
16  * any, provided herein do not apply to combinations of this program with
17  * other software, or any other product whatsoever.
18  *
19  * You should have received a copy of the GNU General Public License along
20  * with this program; if not, write the Free Software Foundation, Inc., 59
21  * Temple Place - Suite 330, Boston MA 02111-1307, USA.
22  *
23  * Contact information: Silicon Graphics, Inc., 1600 Amphitheatre Pkwy,
24  * Mountain View, CA  94043, or:
25  *
26  * http://www.sgi.com
27  *
28  * For further information regarding this notice, see:
29  *
30  * http://oss.sgi.com/projects/GenInfo/SGIGPLNoticeExplan/
31  */
32
33 #include <xfs.h>
34
35 static kmem_zone_t *ktrace_hdr_zone;
36 static kmem_zone_t *ktrace_ent_zone;
37 static int          ktrace_zentries;
38
39 void
40 ktrace_init(int zentries)
41 {
42         ktrace_zentries = zentries;
43
44         ktrace_hdr_zone = kmem_zone_init(sizeof(ktrace_t),
45                                         "ktrace_hdr");
46         ASSERT(ktrace_hdr_zone);
47
48         ktrace_ent_zone = kmem_zone_init(ktrace_zentries
49                                         * sizeof(ktrace_entry_t),
50                                         "ktrace_ent");
51         ASSERT(ktrace_ent_zone);
52 }
53
54 void
55 ktrace_uninit(void)
56 {
57         kmem_cache_destroy(ktrace_hdr_zone);
58         kmem_cache_destroy(ktrace_ent_zone);
59 }
60
61 /*
62  * ktrace_alloc()
63  *
64  * Allocate a ktrace header and enough buffering for the given
65  * number of entries.
66  */
67 ktrace_t *
68 ktrace_alloc(int nentries, int sleep)
69 {
70         ktrace_t        *ktp;
71         ktrace_entry_t  *ktep;
72
73         ktp = (ktrace_t*)kmem_zone_alloc(ktrace_hdr_zone, sleep);
74
75         if (ktp == (ktrace_t*)NULL) {
76                 /*
77                  * KM_SLEEP callers don't expect failure.
78                  */
79                 if (sleep & KM_SLEEP)
80                         panic("ktrace_alloc: NULL memory on KM_SLEEP request!");
81
82                 return NULL;
83         }
84
85         /*
86          * Special treatment for buffers with the ktrace_zentries entries
87          */
88         if (nentries == ktrace_zentries) {
89                 ktep = (ktrace_entry_t*)kmem_zone_zalloc(ktrace_ent_zone,
90                                                             sleep);
91         } else {
92                 ktep = (ktrace_entry_t*)kmem_zalloc((nentries * sizeof(*ktep)),
93                                                             sleep);
94         }
95
96         if (ktep == NULL) {
97                 /*
98                  * KM_SLEEP callers don't expect failure.
99                  */
100                 if (sleep & KM_SLEEP)
101                         panic("ktrace_alloc: NULL memory on KM_SLEEP request!");
102
103                 kmem_free(ktp, sizeof(*ktp));
104
105                 return NULL;
106         }
107
108         spinlock_init(&(ktp->kt_lock), "kt_lock");
109
110         ktp->kt_entries  = ktep;
111         ktp->kt_nentries = nentries;
112         ktp->kt_index    = 0;
113         ktp->kt_rollover = 0;
114         return ktp;
115 }
116
117
118 /*
119  * ktrace_free()
120  *
121  * Free up the ktrace header and buffer.  It is up to the caller
122  * to ensure that no-one is referencing it.
123  */
124 void
125 ktrace_free(ktrace_t *ktp)
126 {
127         int     entries_size;
128
129         if (ktp == (ktrace_t *)NULL)
130                 return;
131
132         spinlock_destroy(&ktp->kt_lock);
133
134         /*
135          * Special treatment for the Vnode trace buffer.
136          */
137         if (ktp->kt_nentries == ktrace_zentries) {
138                 kmem_zone_free(ktrace_ent_zone, ktp->kt_entries);
139         } else {
140                 entries_size = (int)(ktp->kt_nentries * sizeof(ktrace_entry_t));
141
142                 kmem_free(ktp->kt_entries, entries_size);
143         }
144
145         kmem_zone_free(ktrace_hdr_zone, ktp);
146 }
147
148
149 /*
150  * Enter the given values into the "next" entry in the trace buffer.
151  * kt_index is always the index of the next entry to be filled.
152  */
153 void
154 ktrace_enter(
155         ktrace_t        *ktp,
156         void            *val0,
157         void            *val1,
158         void            *val2,
159         void            *val3,
160         void            *val4,
161         void            *val5,
162         void            *val6,
163         void            *val7,
164         void            *val8,
165         void            *val9,
166         void            *val10,
167         void            *val11,
168         void            *val12,
169         void            *val13,
170         void            *val14,
171         void            *val15)
172 {
173         static DEFINE_SPINLOCK(wrap_lock);
174         unsigned long   flags;
175         int             index;
176         ktrace_entry_t  *ktep;
177
178         ASSERT(ktp != NULL);
179
180         /*
181          * Grab an entry by pushing the index up to the next one.
182          */
183         spin_lock_irqsave(&wrap_lock, flags);
184         index = ktp->kt_index;
185         if (++ktp->kt_index == ktp->kt_nentries)
186                 ktp->kt_index = 0;
187         spin_unlock_irqrestore(&wrap_lock, flags);
188
189         if (!ktp->kt_rollover && index == ktp->kt_nentries - 1)
190                 ktp->kt_rollover = 1;
191
192         ASSERT((index >= 0) && (index < ktp->kt_nentries));
193
194         ktep = &(ktp->kt_entries[index]);
195
196         ktep->val[0]  = val0;
197         ktep->val[1]  = val1;
198         ktep->val[2]  = val2;
199         ktep->val[3]  = val3;
200         ktep->val[4]  = val4;
201         ktep->val[5]  = val5;
202         ktep->val[6]  = val6;
203         ktep->val[7]  = val7;
204         ktep->val[8]  = val8;
205         ktep->val[9]  = val9;
206         ktep->val[10] = val10;
207         ktep->val[11] = val11;
208         ktep->val[12] = val12;
209         ktep->val[13] = val13;
210         ktep->val[14] = val14;
211         ktep->val[15] = val15;
212 }
213
214 /*
215  * Return the number of entries in the trace buffer.
216  */
217 int
218 ktrace_nentries(
219         ktrace_t        *ktp)
220 {
221         if (ktp == NULL) {
222                 return 0;
223         }
224
225         return (ktp->kt_rollover ? ktp->kt_nentries : ktp->kt_index);
226 }
227
228 /*
229  * ktrace_first()
230  *
231  * This is used to find the start of the trace buffer.
232  * In conjunction with ktrace_next() it can be used to
233  * iterate through the entire trace buffer.  This code does
234  * not do any locking because it is assumed that it is called
235  * from the debugger.
236  *
237  * The caller must pass in a pointer to a ktrace_snap
238  * structure in which we will keep some state used to
239  * iterate through the buffer.  This state must not touched
240  * by any code outside of this module.
241  */
242 ktrace_entry_t *
243 ktrace_first(ktrace_t   *ktp, ktrace_snap_t     *ktsp)
244 {
245         ktrace_entry_t  *ktep;
246         int             index;
247         int             nentries;
248
249         if (ktp->kt_rollover)
250                 index = ktp->kt_index;
251         else
252                 index = 0;
253
254         ktsp->ks_start = index;
255         ktep = &(ktp->kt_entries[index]);
256
257         nentries = ktrace_nentries(ktp);
258         index++;
259         if (index < nentries) {
260                 ktsp->ks_index = index;
261         } else {
262                 ktsp->ks_index = 0;
263                 if (index > nentries)
264                         ktep = NULL;
265         }
266         return ktep;
267 }
268
269 /*
270  * ktrace_next()
271  *
272  * This is used to iterate through the entries of the given
273  * trace buffer.  The caller must pass in the ktrace_snap_t
274  * structure initialized by ktrace_first().  The return value
275  * will be either a pointer to the next ktrace_entry or NULL
276  * if all of the entries have been traversed.
277  */
278 ktrace_entry_t *
279 ktrace_next(
280         ktrace_t        *ktp,
281         ktrace_snap_t   *ktsp)
282 {
283         int             index;
284         ktrace_entry_t  *ktep;
285
286         index = ktsp->ks_index;
287         if (index == ktsp->ks_start) {
288                 ktep = NULL;
289         } else {
290                 ktep = &ktp->kt_entries[index];
291         }
292
293         index++;
294         if (index == ktrace_nentries(ktp)) {
295                 ktsp->ks_index = 0;
296         } else {
297                 ktsp->ks_index = index;
298         }
299
300         return ktep;
301 }
302
303 /*
304  * ktrace_skip()
305  *
306  * Skip the next "count" entries and return the entry after that.
307  * Return NULL if this causes us to iterate past the beginning again.
308  */
309 ktrace_entry_t *
310 ktrace_skip(
311         ktrace_t        *ktp,
312         int             count,
313         ktrace_snap_t   *ktsp)
314 {
315         int             index;
316         int             new_index;
317         ktrace_entry_t  *ktep;
318         int             nentries = ktrace_nentries(ktp);
319
320         index = ktsp->ks_index;
321         new_index = index + count;
322         while (new_index >= nentries) {
323                 new_index -= nentries;
324         }
325         if (index == ktsp->ks_start) {
326                 /*
327                  * We've iterated around to the start, so we're done.
328                  */
329                 ktep = NULL;
330         } else if ((new_index < index) && (index < ktsp->ks_index)) {
331                 /*
332                  * We've skipped past the start again, so we're done.
333                  */
334                 ktep = NULL;
335                 ktsp->ks_index = ktsp->ks_start;
336         } else {
337                 ktep = &(ktp->kt_entries[new_index]);
338                 new_index++;
339                 if (new_index == nentries) {
340                         ktsp->ks_index = 0;
341                 } else {
342                         ktsp->ks_index = new_index;
343                 }
344         }
345         return ktep;
346 }