2 * Copyright (c) 2000-2003,2005 Silicon Graphics, Inc.
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.
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.
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
20 static kmem_zone_t *ktrace_hdr_zone;
21 static kmem_zone_t *ktrace_ent_zone;
22 static int ktrace_zentries;
25 ktrace_init(int zentries)
27 ktrace_zentries = zentries;
29 ktrace_hdr_zone = kmem_zone_init(sizeof(ktrace_t),
31 ASSERT(ktrace_hdr_zone);
33 ktrace_ent_zone = kmem_zone_init(ktrace_zentries
34 * sizeof(ktrace_entry_t),
36 ASSERT(ktrace_ent_zone);
42 kmem_zone_destroy(ktrace_hdr_zone);
43 kmem_zone_destroy(ktrace_ent_zone);
49 * Allocate a ktrace header and enough buffering for the given
53 ktrace_alloc(int nentries, unsigned int __nocast sleep)
58 ktp = (ktrace_t*)kmem_zone_alloc(ktrace_hdr_zone, sleep);
60 if (ktp == (ktrace_t*)NULL) {
62 * KM_SLEEP callers don't expect failure.
65 panic("ktrace_alloc: NULL memory on KM_SLEEP request!");
71 * Special treatment for buffers with the ktrace_zentries entries
73 if (nentries == ktrace_zentries) {
74 ktep = (ktrace_entry_t*)kmem_zone_zalloc(ktrace_ent_zone,
77 ktep = (ktrace_entry_t*)kmem_zalloc((nentries * sizeof(*ktep)),
83 * KM_SLEEP callers don't expect failure.
86 panic("ktrace_alloc: NULL memory on KM_SLEEP request!");
88 kmem_free(ktp, sizeof(*ktp));
93 ktp->kt_entries = ktep;
94 ktp->kt_nentries = nentries;
95 atomic_set(&ktp->kt_index, 0);
104 * Free up the ktrace header and buffer. It is up to the caller
105 * to ensure that no-one is referencing it.
108 ktrace_free(ktrace_t *ktp)
112 if (ktp == (ktrace_t *)NULL)
116 * Special treatment for the Vnode trace buffer.
118 if (ktp->kt_nentries == ktrace_zentries) {
119 kmem_zone_free(ktrace_ent_zone, ktp->kt_entries);
121 entries_size = (int)(ktp->kt_nentries * sizeof(ktrace_entry_t));
123 kmem_free(ktp->kt_entries, entries_size);
126 kmem_zone_free(ktrace_hdr_zone, ktp);
131 * Enter the given values into the "next" entry in the trace buffer.
132 * kt_index is always the index of the next entry to be filled.
155 ktrace_entry_t *ktep;
160 * Grab an entry by pushing the index up to the next one.
162 index = atomic_add_return(1, &ktp->kt_index);
163 index = (index - 1) % ktp->kt_nentries;
164 if (!ktp->kt_rollover && index == ktp->kt_nentries - 1)
165 ktp->kt_rollover = 1;
167 ASSERT((index >= 0) && (index < ktp->kt_nentries));
169 ktep = &(ktp->kt_entries[index]);
181 ktep->val[10] = val10;
182 ktep->val[11] = val11;
183 ktep->val[12] = val12;
184 ktep->val[13] = val13;
185 ktep->val[14] = val14;
186 ktep->val[15] = val15;
190 * Return the number of entries in the trace buffer.
200 index = atomic_read(&ktp->kt_index) % ktp->kt_nentries;
201 return (ktp->kt_rollover ? ktp->kt_nentries : index);
207 * This is used to find the start of the trace buffer.
208 * In conjunction with ktrace_next() it can be used to
209 * iterate through the entire trace buffer. This code does
210 * not do any locking because it is assumed that it is called
213 * The caller must pass in a pointer to a ktrace_snap
214 * structure in which we will keep some state used to
215 * iterate through the buffer. This state must not touched
216 * by any code outside of this module.
219 ktrace_first(ktrace_t *ktp, ktrace_snap_t *ktsp)
221 ktrace_entry_t *ktep;
225 if (ktp->kt_rollover)
226 index = atomic_read(&ktp->kt_index) % ktp->kt_nentries;
230 ktsp->ks_start = index;
231 ktep = &(ktp->kt_entries[index]);
233 nentries = ktrace_nentries(ktp);
235 if (index < nentries) {
236 ktsp->ks_index = index;
239 if (index > nentries)
248 * This is used to iterate through the entries of the given
249 * trace buffer. The caller must pass in the ktrace_snap_t
250 * structure initialized by ktrace_first(). The return value
251 * will be either a pointer to the next ktrace_entry or NULL
252 * if all of the entries have been traversed.
260 ktrace_entry_t *ktep;
262 index = ktsp->ks_index;
263 if (index == ktsp->ks_start) {
266 ktep = &ktp->kt_entries[index];
270 if (index == ktrace_nentries(ktp)) {
273 ktsp->ks_index = index;
282 * Skip the next "count" entries and return the entry after that.
283 * Return NULL if this causes us to iterate past the beginning again.
293 ktrace_entry_t *ktep;
294 int nentries = ktrace_nentries(ktp);
296 index = ktsp->ks_index;
297 new_index = index + count;
298 while (new_index >= nentries) {
299 new_index -= nentries;
301 if (index == ktsp->ks_start) {
303 * We've iterated around to the start, so we're done.
306 } else if ((new_index < index) && (index < ktsp->ks_index)) {
308 * We've skipped past the start again, so we're done.
311 ktsp->ks_index = ktsp->ks_start;
313 ktep = &(ktp->kt_entries[new_index]);
315 if (new_index == nentries) {
318 ktsp->ks_index = new_index;