6 * You may not use this file except in compliance with the License.
7 *
8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9 * or http://www.opensolaris.org/os/licensing.
10 * See the License for the specific language governing permissions
11 * and limitations under the License.
12 *
13 * When distributing Covered Code, include this CDDL HEADER in each
14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15 * If applicable, add the following below this CDDL HEADER, with the
16 * fields enclosed by brackets "[]" replaced with your own identifying
17 * information: Portions Copyright [yyyy] [name of copyright owner]
18 *
19 * CDDL HEADER END
20 */
21 /*
22 * Copyright 2009 Sun Microsystems, Inc. All rights reserved.
23 * Use is subject to license terms.
24 */
25
26 #if defined(lint)
27 #include <sys/types.h>
28 #include <sys/cpuvar.h>
29 #else /*lint */
30 #include "assym.h"
31 #endif /* lint */
32
33 #include <sys/asm_linkage.h>
34 #include <sys/privregs.h>
35 #include <sys/x_call.h>
36 #include <sys/xc_impl.h>
37
38 #ifdef TRAPTRACE
39 #include <sys/traptrace.h>
40 #endif /* TRAPTRACE */
41
42
43 #if defined(lint)
44
45 /* ARGSUSED */
46 void
47 self_xcall(struct cpu *cpu, uint64_t arg1, uint64_t arg2, xcfunc_t *func)
48 {}
49
50 #else
51
52 /*
53 * Entered by the software trap (TT=ST_SELFXCALL, TL>0) thru send_self_xcall().
54 * Emulate the mondo handler - vec_interrupt().
55 *
56 * Global registers are the Alternate Globals.
57 * Arguments:
58 * %o0 - CPU
59 * ILP32 kernel:
60 * %o5 - function to call
61 * %o1, %o2, %o3, %o4 - arguments
62 * LP64 kernel:
63 * %o3 - function to call
64 * %o1, %o2 - arguments
65 */
66 ENTRY_NP(self_xcall)
67 !
68 ! TL>0 handlers are expected to do "retry"
69 ! prepare their return PC and nPC now
70 !
71 rdpr %tnpc, %g1
85 rdpr %tpc, %g6
86 stna %g6, [%g4 + TRAP_ENT_TPC]%asi
87 rdpr %tstate, %g6
88 stxa %g6, [%g4 + TRAP_ENT_TSTATE]%asi
89 stna %sp, [%g4 + TRAP_ENT_SP]%asi
90 stna %o1, [%g4 + TRAP_ENT_F1]%asi ! arg 1
91 stna %o2, [%g4 + TRAP_ENT_F2]%asi ! arg 2
92 stna %g0, [%g4 + TRAP_ENT_F3]%asi
93 stna %g0, [%g4 + TRAP_ENT_F4]%asi
94 TRACE_NEXT(%g4, %g6, %g3)
95 #endif /* TRAPTRACE */
96 !
97 ! Load the arguments for the fast trap handler.
98 !
99 mov %o1, %g1
100 jmp %o3 ! call the fast trap handler
101 mov %o2, %g2
102 /* Not Reached */
103 SET_SIZE(self_xcall)
104
105 #endif /* lint */
106
107 #ifdef TRAPTRACE
108 #if defined(lint)
109
110 /* ARGSUSED */
111 void
112 xc_trace(u_int traptype, cpuset_t *cpu_set, xcfunc_t *func,
113 uint64_t arg1, uint64_t arg2)
114 {}
115
116 #else /* lint */
117 ENTRY(xc_trace)
118 rdpr %pstate, %g1
119 andn %g1, PSTATE_IE | PSTATE_AM, %g2
120 wrpr %g0, %g2, %pstate /* disable interrupts */
121 TRACE_PTR(%g3, %g4)
122 GET_TRACE_TICK(%g6, %g4)
123 stxa %g6, [%g3 + TRAP_ENT_TICK]%asi
124 stha %g0, [%g3 + TRAP_ENT_TL]%asi
125 set TT_XCALL, %g2
126 or %o0, %g2, %g4
127 stha %g4, [%g3 + TRAP_ENT_TT]%asi
128 stna %o7, [%g3 + TRAP_ENT_TPC]%asi
129 ldn [%o1], %g2
130 stna %g2, [%g3 + TRAP_ENT_SP]%asi /* sp = cpuset */
131 stna %o2, [%g3 + TRAP_ENT_TR]%asi /* tr = func */
132 stna %o3, [%g3 + TRAP_ENT_F1]%asi /* f1 = arg1 */
133 stna %o4, [%g3 + TRAP_ENT_F2]%asi /* f2 = arg2 */
134 stna %g0, [%g3 + TRAP_ENT_F3]%asi /* f3 = 0 */
135 stna %i7, [%g3 + TRAP_ENT_F4]%asi /* f4 = xcall caller */
136 stxa %g1, [%g3 + TRAP_ENT_TSTATE]%asi /* tstate = pstate */
169 cmp %o1, %g5
170 bge 2f
171 ldn [%o1], %g2
172 stna %g2, [%g3 + TRAP_ENT_F3]%asi
173 add %o1, CLONGSIZE, %o1
174 cmp %o1, %g5
175 bge 2f
176 ldn [%o1], %g2
177 stna %g2, [%g3 + TRAP_ENT_F4]%asi
178 add %o1, CLONGSIZE, %o1
179 2:
180 TRACE_NEXT(%g2, %g3, %g4)
181 cmp %o1, %g5
182 bl 1b
183 inc %o2
184 #endif /* CPUSET_SIZE */
185 retl
186 wrpr %g0, %g1, %pstate /* enable interrupts */
187 SET_SIZE(xc_trace)
188
189 #endif /* lint */
190 #endif /* TRAPTRACE */
191
192 #if defined(lint)
193
194 /* ARGSUSED */
195 void
196 xt_sync_tl1(uint64_t *cpu_sync_addr)
197 {}
198
199 #else
200 /*
201 * This dummy tl1 function is there to ensure that previously called
202 * xtrap handlers have exececuted. The hardware (mondo dispatch
203 * mechanism) is such that return from xtrap doesn't guarantee execution
204 * of xtrap handler. So, callers can call this xtrap-handler to ensure
205 * that the previous one is complete. This is because the hardware only
206 * can handle 1 mondo at a time - when this mondo is handled, we are sure
207 * that the mondo for the previous xtrap must have been handled.
208 */
209 ENTRY_NP(xt_sync_tl1)
210 retry
211 SET_SIZE(xt_sync_tl1)
212
213 #endif /* lint */
|
6 * You may not use this file except in compliance with the License.
7 *
8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9 * or http://www.opensolaris.org/os/licensing.
10 * See the License for the specific language governing permissions
11 * and limitations under the License.
12 *
13 * When distributing Covered Code, include this CDDL HEADER in each
14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15 * If applicable, add the following below this CDDL HEADER, with the
16 * fields enclosed by brackets "[]" replaced with your own identifying
17 * information: Portions Copyright [yyyy] [name of copyright owner]
18 *
19 * CDDL HEADER END
20 */
21 /*
22 * Copyright 2009 Sun Microsystems, Inc. All rights reserved.
23 * Use is subject to license terms.
24 */
25
26 #include "assym.h"
27
28 #include <sys/asm_linkage.h>
29 #include <sys/privregs.h>
30 #include <sys/x_call.h>
31 #include <sys/xc_impl.h>
32
33 #ifdef TRAPTRACE
34 #include <sys/traptrace.h>
35 #endif /* TRAPTRACE */
36
37
38 /*
39 * Entered by the software trap (TT=ST_SELFXCALL, TL>0) thru send_self_xcall().
40 * Emulate the mondo handler - vec_interrupt().
41 *
42 * Global registers are the Alternate Globals.
43 * Arguments:
44 * %o0 - CPU
45 * ILP32 kernel:
46 * %o5 - function to call
47 * %o1, %o2, %o3, %o4 - arguments
48 * LP64 kernel:
49 * %o3 - function to call
50 * %o1, %o2 - arguments
51 */
52 ENTRY_NP(self_xcall)
53 !
54 ! TL>0 handlers are expected to do "retry"
55 ! prepare their return PC and nPC now
56 !
57 rdpr %tnpc, %g1
71 rdpr %tpc, %g6
72 stna %g6, [%g4 + TRAP_ENT_TPC]%asi
73 rdpr %tstate, %g6
74 stxa %g6, [%g4 + TRAP_ENT_TSTATE]%asi
75 stna %sp, [%g4 + TRAP_ENT_SP]%asi
76 stna %o1, [%g4 + TRAP_ENT_F1]%asi ! arg 1
77 stna %o2, [%g4 + TRAP_ENT_F2]%asi ! arg 2
78 stna %g0, [%g4 + TRAP_ENT_F3]%asi
79 stna %g0, [%g4 + TRAP_ENT_F4]%asi
80 TRACE_NEXT(%g4, %g6, %g3)
81 #endif /* TRAPTRACE */
82 !
83 ! Load the arguments for the fast trap handler.
84 !
85 mov %o1, %g1
86 jmp %o3 ! call the fast trap handler
87 mov %o2, %g2
88 /* Not Reached */
89 SET_SIZE(self_xcall)
90
91 #ifdef TRAPTRACE
92 ENTRY(xc_trace)
93 rdpr %pstate, %g1
94 andn %g1, PSTATE_IE | PSTATE_AM, %g2
95 wrpr %g0, %g2, %pstate /* disable interrupts */
96 TRACE_PTR(%g3, %g4)
97 GET_TRACE_TICK(%g6, %g4)
98 stxa %g6, [%g3 + TRAP_ENT_TICK]%asi
99 stha %g0, [%g3 + TRAP_ENT_TL]%asi
100 set TT_XCALL, %g2
101 or %o0, %g2, %g4
102 stha %g4, [%g3 + TRAP_ENT_TT]%asi
103 stna %o7, [%g3 + TRAP_ENT_TPC]%asi
104 ldn [%o1], %g2
105 stna %g2, [%g3 + TRAP_ENT_SP]%asi /* sp = cpuset */
106 stna %o2, [%g3 + TRAP_ENT_TR]%asi /* tr = func */
107 stna %o3, [%g3 + TRAP_ENT_F1]%asi /* f1 = arg1 */
108 stna %o4, [%g3 + TRAP_ENT_F2]%asi /* f2 = arg2 */
109 stna %g0, [%g3 + TRAP_ENT_F3]%asi /* f3 = 0 */
110 stna %i7, [%g3 + TRAP_ENT_F4]%asi /* f4 = xcall caller */
111 stxa %g1, [%g3 + TRAP_ENT_TSTATE]%asi /* tstate = pstate */
144 cmp %o1, %g5
145 bge 2f
146 ldn [%o1], %g2
147 stna %g2, [%g3 + TRAP_ENT_F3]%asi
148 add %o1, CLONGSIZE, %o1
149 cmp %o1, %g5
150 bge 2f
151 ldn [%o1], %g2
152 stna %g2, [%g3 + TRAP_ENT_F4]%asi
153 add %o1, CLONGSIZE, %o1
154 2:
155 TRACE_NEXT(%g2, %g3, %g4)
156 cmp %o1, %g5
157 bl 1b
158 inc %o2
159 #endif /* CPUSET_SIZE */
160 retl
161 wrpr %g0, %g1, %pstate /* enable interrupts */
162 SET_SIZE(xc_trace)
163
164 #endif /* TRAPTRACE */
165
166 /*
167 * This dummy tl1 function is there to ensure that previously called
168 * xtrap handlers have exececuted. The hardware (mondo dispatch
169 * mechanism) is such that return from xtrap doesn't guarantee execution
170 * of xtrap handler. So, callers can call this xtrap-handler to ensure
171 * that the previous one is complete. This is because the hardware only
172 * can handle 1 mondo at a time - when this mondo is handled, we are sure
173 * that the mondo for the previous xtrap must have been handled.
174 */
175 ENTRY_NP(xt_sync_tl1)
176 retry
177 SET_SIZE(xt_sync_tl1)
178
|