1 /*-
2 * Copyright (c) 2011 Konstantin Belousov <kib@FreeBSD.org>
3 * All rights reserved.
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
7 * are met:
8 * 1. Redistributions of source code must retain the above copyright
9 * notice, this list of conditions and the following disclaimer.
10 * 2. Redistributions in binary form must reproduce the above copyright
11 * notice, this list of conditions and the following disclaimer in the
12 * documentation and/or other materials provided with the distribution.
13 *
14 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
15 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
16 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
17 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
18 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
19 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
20 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
21 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
22 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
23 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
24 * SUCH DAMAGE.
25 *
26 */
27
28 #include <sys/cdefs.h>
29 __FBSDID("$FreeBSD$");
30
31 #include "opt_compat.h"
32
33 #include <sys/param.h>
34 #include <sys/systm.h>
35 #include <sys/malloc.h>
36 #include <sys/proc.h>
37 #include <sys/ptrace.h>
38 #include <sys/sysent.h>
39 #include <vm/vm.h>
40 #include <vm/pmap.h>
41 #include <machine/md_var.h>
42 #include <machine/pcb.h>
43 #include <machine/frame.h>
44 #include <machine/vmparam.h>
45
46 #ifdef COMPAT_FREEBSD32
47 struct ptrace_xstate_info32 {
48 uint32_t xsave_mask1, xsave_mask2;
49 uint32_t xsave_len;
50 };
51 #endif
52
53 static int
54 cpu_ptrace_xstate(struct thread *td, int req, void *addr, int data)
55 {
56 struct ptrace_xstate_info info;
57 #ifdef COMPAT_FREEBSD32
58 struct ptrace_xstate_info32 info32;
59 #endif
60 char *savefpu;
61 int error;
62
63 if (!use_xsave)
64 return (EOPNOTSUPP);
65
66 switch (req) {
67 case PT_GETXSTATE_OLD:
68 fpugetregs(td);
69 savefpu = (char *)(get_pcb_user_save_td(td) + 1);
70 error = copyout(savefpu, addr,
71 cpu_max_ext_state_size - sizeof(struct savefpu));
72 break;
73
74 case PT_SETXSTATE_OLD:
75 if (data > cpu_max_ext_state_size - sizeof(struct savefpu)) {
76 error = EINVAL;
77 break;
78 }
79 savefpu = malloc(data, M_TEMP, M_WAITOK);
80 error = copyin(addr, savefpu, data);
81 if (error == 0) {
82 fpugetregs(td);
83 error = fpusetxstate(td, savefpu, data);
84 }
85 free(savefpu, M_TEMP);
86 break;
87
88 case PT_GETXSTATE_INFO:
89 #ifdef COMPAT_FREEBSD32
90 if (SV_CURPROC_FLAG(SV_ILP32)) {
91 if (data != sizeof(info32)) {
92 error = EINVAL;
93 } else {
94 info32.xsave_len = cpu_max_ext_state_size;
95 info32.xsave_mask1 = xsave_mask;
96 info32.xsave_mask2 = xsave_mask >> 32;
97 error = copyout(&info32, addr, data);
98 }
99 } else
100 #endif
101 {
102 if (data != sizeof(info)) {
103 error = EINVAL;
104 } else {
105 bzero(&info, sizeof(info));
106 info.xsave_len = cpu_max_ext_state_size;
107 info.xsave_mask = xsave_mask;
108 error = copyout(&info, addr, data);
109 }
110 }
111 break;
112
113 case PT_GETXSTATE:
114 fpugetregs(td);
115 savefpu = (char *)(get_pcb_user_save_td(td));
116 error = copyout(savefpu, addr, cpu_max_ext_state_size);
117 break;
118
119 case PT_SETXSTATE:
120 if (data < sizeof(struct savefpu) ||
121 data > cpu_max_ext_state_size) {
122 error = EINVAL;
123 break;
124 }
125 savefpu = malloc(data, M_TEMP, M_WAITOK);
126 error = copyin(addr, savefpu, data);
127 if (error == 0)
128 error = fpusetregs(td, (struct savefpu *)savefpu,
129 savefpu + sizeof(struct savefpu), data -
130 sizeof(struct savefpu));
131 free(savefpu, M_TEMP);
132 break;
133
134 default:
135 error = EINVAL;
136 break;
137 }
138
139 return (error);
140 }
141
142 static void
143 cpu_ptrace_setbase(struct thread *td, int req, register_t r)
144 {
145
146 if (req == PT_SETFSBASE) {
147 td->td_pcb->pcb_fsbase = r;
148 td->td_frame->tf_fs = _ufssel;
149 } else {
150 td->td_pcb->pcb_gsbase = r;
151 td->td_frame->tf_gs = _ugssel;
152 }
153 set_pcb_flags(td->td_pcb, PCB_FULL_IRET);
154 }
155
156 #ifdef COMPAT_FREEBSD32
157 #define PT_I386_GETXMMREGS (PT_FIRSTMACH + 0)
158 #define PT_I386_SETXMMREGS (PT_FIRSTMACH + 1)
159
160 static int
161 cpu32_ptrace(struct thread *td, int req, void *addr, int data)
162 {
163 struct savefpu *fpstate;
164 uint32_t r;
165 int error;
166
167 switch (req) {
168 case PT_I386_GETXMMREGS:
169 fpugetregs(td);
170 error = copyout(get_pcb_user_save_td(td), addr,
171 sizeof(*fpstate));
172 break;
173
174 case PT_I386_SETXMMREGS:
175 fpugetregs(td);
176 fpstate = get_pcb_user_save_td(td);
177 error = copyin(addr, fpstate, sizeof(*fpstate));
178 fpstate->sv_env.en_mxcsr &= cpu_mxcsr_mask;
179 break;
180
181 case PT_GETXSTATE_OLD:
182 case PT_SETXSTATE_OLD:
183 case PT_GETXSTATE_INFO:
184 case PT_GETXSTATE:
185 case PT_SETXSTATE:
186 error = cpu_ptrace_xstate(td, req, addr, data);
187 break;
188
189 case PT_GETFSBASE:
190 case PT_GETGSBASE:
191 if (!SV_PROC_FLAG(td->td_proc, SV_ILP32)) {
192 error = EINVAL;
193 break;
194 }
195 r = req == PT_GETFSBASE ? td->td_pcb->pcb_fsbase :
196 td->td_pcb->pcb_gsbase;
197 error = copyout(&r, addr, sizeof(r));
198 break;
199
200 case PT_SETFSBASE:
201 case PT_SETGSBASE:
202 if (!SV_PROC_FLAG(td->td_proc, SV_ILP32)) {
203 error = EINVAL;
204 break;
205 }
206 error = copyin(addr, &r, sizeof(r));
207 if (error != 0)
208 break;
209 cpu_ptrace_setbase(td, req, r);
210 break;
211
212 default:
213 error = EINVAL;
214 break;
215 }
216
217 return (error);
218 }
219 #endif
220
221 int
222 cpu_ptrace(struct thread *td, int req, void *addr, int data)
223 {
224 register_t *r, rv;
225 int error;
226
227 #ifdef COMPAT_FREEBSD32
228 if (SV_CURPROC_FLAG(SV_ILP32))
229 return (cpu32_ptrace(td, req, addr, data));
230 #endif
231
232 /* Support old values of PT_GETXSTATE_OLD and PT_SETXSTATE_OLD. */
233 if (req == PT_FIRSTMACH + 0)
234 req = PT_GETXSTATE_OLD;
235 if (req == PT_FIRSTMACH + 1)
236 req = PT_SETXSTATE_OLD;
237
238 switch (req) {
239 case PT_GETXSTATE_OLD:
240 case PT_SETXSTATE_OLD:
241 case PT_GETXSTATE_INFO:
242 case PT_GETXSTATE:
243 case PT_SETXSTATE:
244 error = cpu_ptrace_xstate(td, req, addr, data);
245 break;
246
247 case PT_GETFSBASE:
248 case PT_GETGSBASE:
249 r = req == PT_GETFSBASE ? &td->td_pcb->pcb_fsbase :
250 &td->td_pcb->pcb_gsbase;
251 error = copyout(r, addr, sizeof(*r));
252 break;
253
254 case PT_SETFSBASE:
255 case PT_SETGSBASE:
256 error = copyin(addr, &rv, sizeof(rv));
257 if (error != 0)
258 break;
259 if (rv >= td->td_proc->p_sysent->sv_maxuser) {
260 error = EINVAL;
261 break;
262 }
263 cpu_ptrace_setbase(td, req, rv);
264 break;
265
266 default:
267 error = EINVAL;
268 break;
269 }
270
271 return (error);
272 }
Cache object: c03160e228511c11765a328b0712dbd6
|