Print this page
missed one
de-linting of .s files
| Split |
Close |
| Expand all |
| Collapse all |
--- old/usr/src/uts/intel/brand/common/brand_solaris.s
+++ new/usr/src/uts/intel/brand/common/brand_solaris.s
1 1 /*
2 2 * CDDL HEADER START
3 3 *
4 4 * The contents of this file are subject to the terms of the
5 5 * Common Development and Distribution License (the "License").
6 6 * You may not use this file except in compliance with the License.
7 7 *
8 8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9 9 * or http://www.opensolaris.org/os/licensing.
10 10 * See the License for the specific language governing permissions
11 11 * and limitations under the License.
12 12 *
13 13 * When distributing Covered Code, include this CDDL HEADER in each
14 14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15 15 * If applicable, add the following below this CDDL HEADER, with the
16 16 * fields enclosed by brackets "[]" replaced with your own identifying
17 17 * information: Portions Copyright [yyyy] [name of copyright owner]
18 18 *
19 19 * CDDL HEADER END
20 20 */
21 21 /*
22 22 * Copyright (c) 2009, 2010, Oracle and/or its affiliates. All rights reserved.
23 23 * Copyright 2019 Joyent, Inc.
24 24 */
|
↓ open down ↓ |
24 lines elided |
↑ open up ↑ |
25 25
26 26 /*
27 27 * This is an assembly file that gets #include-ed into the brand-specific
28 28 * assembly files (e.g. sn1_brand_asm.s) for Solaris-derived brands.
29 29 * We can't make these into functions since in the trap context there's
30 30 * no easy place to save the extra parameters that would be required, so
31 31 * each brand module needs its own copy of this code. We #include this and
32 32 * use brand-specific #defines to replace the XXX_brand_... definitions.
33 33 */
34 34
35 -#ifdef lint
36 -
37 -#include <sys/systm.h>
38 -
39 -#else /* !lint */
40 -
41 35 #include <sys/asm_linkage.h>
42 36 #include <sys/privregs.h>
43 37 #include <sys/segments.h>
44 38 #include "assym.h"
45 39 #include "brand_asm.h"
46 40
47 -#endif /* !lint */
48 -
49 -#ifdef lint
50 -
51 -void
52 -XXX_brand_sysenter_callback(void)
53 -{
54 -}
55 -
56 -void
57 -XXX_brand_syscall_callback(void)
58 -{
59 -}
60 -
61 -#if defined(__amd64)
62 -void
63 -XXX_brand_syscall32_callback(void)
64 -{
65 -}
66 -#endif /* amd64 */
67 -
68 -void
69 -XXX_brand_int91_callback(void)
70 -{
71 -}
72 -
73 -#else /* !lint */
74 -
75 41 #ifdef _ASM /* The remainder of this file is only for assembly files */
76 42
77 -#if defined(__amd64)
78 -
79 43 /*
80 44 * syscall handler for 32-bit user processes:
81 45 * See "64-BIT INTERPOSITION STACK" in brand_asm.h.
82 46 * To 'return' to our user-space handler, we just need to place its address
83 47 * into %rcx. The original return address is passed back in SYSCALL_REG.
84 48 */
85 49 ENTRY(XXX_brand_syscall32_callback)
86 50 CALLBACK_PROLOGUE(XXX_emulation_table, SPD_HANDLER, SYSCALL_REG,
87 51 SCR_REG, SCR_REGB);
88 52 CALC_TABLE_ADDR(SCR_REG, SPD_HANDLER);
89 53 mov %rcx, SYSCALL_REG; /* save orig return addr in syscall_reg */
90 54 mov SCR_REG, %rcx; /* place new return addr in %rcx */
91 55 mov %gs:CPU_RTMP_R15, SCR_REG; /* restore scratch register */
92 56 call x86_md_clear /* Flush micro-arch state */
93 57 mov V_SSP(SP_REG), SP_REG /* restore user stack pointer */
94 58 jmp nopop_sys_syscall32_swapgs_sysretl
95 59 9:
96 60 retq
97 61 SET_SIZE(XXX_brand_syscall32_callback)
98 62
99 63 /*
100 64 * syscall handler for 64-bit user processes:
101 65 * See "64-BIT INTERPOSITION STACK" in brand_asm.h.
102 66 * To 'return' to our user-space handler, we just need to place its address
103 67 * into %rcx. The original return address is passed back in SYSCALL_REG.
104 68 */
105 69 ENTRY(XXX_brand_syscall_callback)
106 70 CALLBACK_PROLOGUE(XXX_emulation_table, SPD_HANDLER, SYSCALL_REG,
107 71 SCR_REG, SCR_REGB);
108 72 CALC_TABLE_ADDR(SCR_REG, SPD_HANDLER);
109 73 mov %rcx, SYSCALL_REG; /* save orig return addr in syscall_reg */
110 74 mov SCR_REG, %rcx; /* place new return addr in %rcx */
111 75 mov %gs:CPU_RTMP_R15, SCR_REG; /* restore scratch register */
112 76 call x86_md_clear /* Flush micro-arch state */
113 77 mov V_SSP(SP_REG), SP_REG /* restore user stack pointer */
114 78 jmp nopop_sys_syscall_swapgs_sysretq
115 79 9:
116 80 retq
117 81 SET_SIZE(XXX_brand_syscall_callback)
118 82
119 83 /*
120 84 * See "64-BIT INTERPOSITION STACK" in brand_asm.h.
121 85 * To 'return' to our user-space handler, we just need to place its address
122 86 * into %rdx. The original return address is passed back in SYSCALL_REG.
123 87 */
124 88 ENTRY(XXX_brand_sysenter_callback)
125 89 CALLBACK_PROLOGUE(XXX_emulation_table, SPD_HANDLER, SYSCALL_REG,
126 90 SCR_REG, SCR_REGB);
127 91 CALC_TABLE_ADDR(SCR_REG, SPD_HANDLER);
128 92 mov %rdx, SYSCALL_REG; /* save orig return addr in syscall_reg */
129 93 mov SCR_REG, %rdx; /* place new return addr in %rdx */
130 94 mov %gs:CPU_RTMP_R15, SCR_REG; /* restore scratch register */
131 95 mov V_SSP(SP_REG), SP_REG /* restore user stack pointer */
132 96 jmp sys_sysenter_swapgs_sysexit
133 97 9:
134 98 ret
135 99 SET_SIZE(XXX_brand_sysenter_callback)
136 100
137 101 /*
138 102 * To 'return' to our user-space handler we need to update the user's %eip
139 103 * pointer in the saved interrupt state on the stack. The interrupt state was
140 104 * pushed onto our stack automatically when the interrupt occured; see the
141 105 * comments above. The original return address is passed back in SYSCALL_REG.
142 106 * See "64-BIT INTERPOSITION STACK" and "64-BIT INT STACK" in brand_asm.h.
143 107 */
144 108 ENTRY(XXX_brand_int91_callback)
145 109 CALLBACK_PROLOGUE(XXX_emulation_table, SPD_HANDLER, SYSCALL_REG,
146 110 SCR_REG, SCR_REGB);
147 111 CALC_TABLE_ADDR(SCR_REG, SPD_HANDLER); /* new ret addr is in scratch */
|
↓ open down ↓ |
59 lines elided |
↑ open up ↑ |
148 112 mov SCR_REG, SYSCALL_REG; /* place new ret addr in syscallreg */
149 113 mov %gs:CPU_RTMP_R15, SCR_REG; /* restore scratch register */
150 114 mov V_SSP(SP_REG), SP_REG; /* restore intr stack pointer */
151 115 /*CSTYLED*/
152 116 xchg (SP_REG), SYSCALL_REG /* swap new and orig. return addrs */
153 117 jmp sys_sysint_swapgs_iret
154 118 9:
155 119 retq
156 120 SET_SIZE(XXX_brand_int91_callback)
157 121
158 -#else /* !__amd64 */
159 -
160 -/*
161 - * To 'return' to our user-space handler, we need to replace the iret target
162 - * address. The original return address is passed back in %eax.
163 - * See "32-BIT INTERPOSITION STACK" and "32-BIT INT STACK" in brand_asm.h.
164 - */
165 -ENTRY(XXX_brand_syscall_callback)
166 - CALLBACK_PROLOGUE(XXX_emulation_table, SPD_HANDLER, SYSCALL_REG,
167 - SCR_REG, SCR_REGB);
168 - CALC_TABLE_ADDR(SCR_REG, SPD_HANDLER); /* new ret addr is in scratch */
169 - mov SCR_REG, SYSCALL_REG; /* place new ret addr in syscallreg */
170 - GET_V(SP_REG, 0, V_U_EBX, SCR_REG); /* restore scratch register */
171 - add $V_END, SP_REG; /* restore intr stack pointer */
172 - /*CSTYLED*/
173 - xchg (SP_REG), SYSCALL_REG /* swap new and orig. return addrs */
174 - jmp nopop_sys_rtt_syscall
175 -9:
176 - ret
177 -SET_SIZE(XXX_brand_syscall_callback)
178 -
179 -/*
180 - * To 'return' to our user-space handler, we just need to place its address
181 - * into %edx. The original return address is passed back in SYSCALL_REG.
182 - * See "32-BIT INTERPOSITION STACK" in brand_asm.h.
183 - */
184 -ENTRY(XXX_brand_sysenter_callback)
185 - CALLBACK_PROLOGUE(XXX_emulation_table, SPD_HANDLER, SYSCALL_REG,
186 - SCR_REG, SCR_REGB);
187 - mov %edx, SCR_REG; /* save orig return addr in scr reg */
188 - CALC_TABLE_ADDR(%edx, SPD_HANDLER); /* new return addr is in %edx */
189 - mov SCR_REG, SYSCALL_REG; /* save orig return addr in %eax */
190 - GET_V(SP_REG, 0, V_U_EBX, SCR_REG) /* restore scratch register */
191 - sysexit
192 -9:
193 - ret
194 -SET_SIZE(XXX_brand_sysenter_callback)
195 -
196 -#endif /* !__amd64 */
197 122 #endif /* _ASM */
198 -#endif /* !lint */
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX