1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
|
/*
* CDDL HEADER START
*
* The contents of this file are subject to the terms of the
* Common Development and Distribution License, Version 1.0 only
* (the "License"). You may not use this file except in compliance
* with the License.
*
* You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
* or http://www.opensolaris.org/os/licensing.
* See the License for the specific language governing permissions
* and limitations under the License.
*
* When distributing Covered Code, include this CDDL HEADER in each
* file and include the License file at usr/src/OPENSOLARIS.LICENSE.
* If applicable, add the following below this CDDL HEADER, with the
* fields enclosed by brackets "[]" replaced with your own identifying
* information: Portions Copyright [yyyy] [name of copyright owner]
*
* CDDL HEADER END
*/
/*
* Copyright (c) 1997 by Sun Microsystems, Inc.
* All rights reserved.
*/
#pragma ident "%Z%%M% %I% %E% SMI"
/*
* Kernel Basic Block Profiling - profiling initialization hooks
*/
#include <sys/param.h>
#include <sys/types.h>
#include <sys/t_lock.h>
#include <sys/cpuvar.h>
#include <sys/systm.h>
#include <sys/spl.h>
#include <sys/unix_bb_info.h>
#ifdef KCOV
/*
* routines to do kernel basic block coverage.
*/
struct bb_info *unix_bb_list;
lock_t unix_bb_lock;
/*
* There is the potential that we will be called by any C routine.
* So we avoid calling any C routines from here, as we'll get
* a recursive call.
* Also, we wish to avoid a deadlock due to being called by
* an interrupt handler, so we lock at the NMI level.
* Of course, that leaves the possibility that we'll
* be called from an NMI handler. If the lock is available,
* fine, otherwise, if we're on the interrupt stack at the
* NMI level, we just return.
*
* We will probably get another chance to add the bb_info structure
* to the list, since the bb_info structure is for the entire object file.
*/
#ifdef KCOV_TEST
int unix_bb_a, unix_bb_b, unix_bb_c;
int unix_bb_d, unix_bb_e, unix_bb_f, unix_bb_g;
processorid_t bb_last_who;
char *bb_last_where;
#endif
void
__bb_init_func(struct bb_info *bb)
{
u_short s;
/*
* a = c + g
* b = c + d
* a = c + e
* e = g
*
* a->b->c
* a->b->d->e->g
* a->b->d->e->f->g
* a->e->g
* a->e->f->g
*/
/*
* Raise the pil and try to get the lock.
*/
s = spl8();
#ifdef KCOV_TEST
unix_bb_a++;
#endif
if (!lock_try(&unix_bb_lock)) {
/*
* If we're on the interrrupt stack, we just return
* in case it's an NMI and we're looking at a deadlock
* situation. Otherwise, we use lock_set_spl()
*/
#ifdef KCOV_TEST
unix_bb_b++;
#endif
if (CPU_ON_INTR(CPU)) {
#ifdef KCOV_TEST
unix_bb_c++;
#endif
splx(s);
return;
}
#ifdef KCOV_TEST
unix_bb_d++;
#endif
splx(s);
lock_set_spl(&unix_bb_lock, ipltospl(NMI_LEVEL), &s);
}
#ifdef KCOV_TEST
bb_last_who = CPU->cpu_id;
bb_last_where = bb->bb_filename;
unix_bb_e++;
#endif
/*
* We've got the lock. If we have not been initialized, add us
* to the list and set the initialized flag.
*/
#ifdef KCOV_TEST
if (bb->bb_next == 0) {
unix_bb_f++;
#else
if (bb->bb_initflag == 0) {
bb->bb_initflag = 1;
#endif
bb->bb_next = unix_bb_list;
unix_bb_list = bb;
}
#ifdef KCOV_TEST
unix_bb_g++;
#endif
lock_clear_splx(&unix_bb_lock, s);
}
#endif /* KCOV */
|
