]> CyberLeo.Net >> Repos - FreeBSD/FreeBSD.git/blob - sys/amd64/linux/linux_machdep.c
linux: drop unneeded casts
[FreeBSD/FreeBSD.git] / sys / amd64 / linux / linux_machdep.c
1 /*-
2  * Copyright (c) 2013 Dmitry Chagin
3  * Copyright (c) 2004 Tim J. Robbins
4  * Copyright (c) 2002 Doug Rabson
5  * Copyright (c) 2000 Marcel Moolenaar
6  * All rights reserved.
7  *
8  * Redistribution and use in source and binary forms, with or without
9  * modification, are permitted provided that the following conditions
10  * are met:
11  * 1. Redistributions of source code must retain the above copyright
12  *    notice, this list of conditions and the following disclaimer
13  *    in this position and unchanged.
14  * 2. Redistributions in binary form must reproduce the above copyright
15  *    notice, this list of conditions and the following disclaimer in the
16  *    documentation and/or other materials provided with the distribution.
17  * 3. The name of the author may not be used to endorse or promote products
18  *    derived from this software without specific prior written permission.
19  *
20  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
21  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
22  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
23  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
24  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
25  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
26  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
27  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
28  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
29  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
30  */
31
32 #include <sys/cdefs.h>
33 __FBSDID("$FreeBSD$");
34
35 #include <sys/param.h>
36 #include <sys/capsicum.h>
37 #include <sys/clock.h>
38 #include <sys/dirent.h>
39 #include <sys/fcntl.h>
40 #include <sys/file.h>
41 #include <sys/filedesc.h>
42 #include <sys/imgact.h>
43 #include <sys/kernel.h>
44 #include <sys/ktr.h>
45 #include <sys/limits.h>
46 #include <sys/lock.h>
47 #include <sys/malloc.h>
48 #include <sys/mman.h>
49 #include <sys/mutex.h>
50 #include <sys/priv.h>
51 #include <sys/proc.h>
52 #include <sys/resource.h>
53 #include <sys/resourcevar.h>
54 #include <sys/sched.h>
55 #include <sys/syscallsubr.h>
56 #include <sys/sysproto.h>
57 #include <sys/systm.h>
58 #include <sys/unistd.h>
59 #include <sys/vnode.h>
60 #include <sys/wait.h>
61
62 #include <security/mac/mac_framework.h>
63
64 #include <ufs/ufs/extattr.h>
65 #include <ufs/ufs/quota.h>
66 #include <ufs/ufs/ufsmount.h>
67
68 #include <machine/frame.h>
69 #include <machine/md_var.h>
70 #include <machine/pcb.h>
71 #include <machine/psl.h>
72 #include <machine/segments.h>
73 #include <machine/specialreg.h>
74
75 #include <vm/pmap.h>
76 #include <vm/vm.h>
77 #include <vm/vm_extern.h>
78 #include <vm/vm_kern.h>
79 #include <vm/vm_map.h>
80
81 #include <x86/ifunc.h>
82 #include <x86/sysarch.h>
83
84 #include <security/audit/audit.h>
85
86 #include <amd64/linux/linux.h>
87 #include <amd64/linux/linux_proto.h>
88 #include <compat/linux/linux_emul.h>
89 #include <compat/linux/linux_file.h>
90 #include <compat/linux/linux_ipc.h>
91 #include <compat/linux/linux_misc.h>
92 #include <compat/linux/linux_mmap.h>
93 #include <compat/linux/linux_signal.h>
94 #include <compat/linux/linux_util.h>
95
96 int
97 linux_execve(struct thread *td, struct linux_execve_args *args)
98 {
99         struct image_args eargs;
100         char *path;
101         int error;
102
103         LINUX_CTR(execve);
104
105         if (!LUSECONVPATH(td)) {
106                 error = exec_copyin_args(&eargs, args->path, UIO_USERSPACE,
107                     args->argp, args->envp);
108         } else {
109                 LCONVPATHEXIST(td, args->path, &path);
110                 error = exec_copyin_args(&eargs, path, UIO_SYSSPACE, args->argp,
111                     args->envp);
112                 LFREEPATH(path);
113         }
114         if (error == 0)
115                 error = linux_common_execve(td, &eargs);
116         AUDIT_SYSCALL_EXIT(error == EJUSTRETURN ? 0 : error, td);
117         return (error);
118 }
119
120 int
121 linux_set_upcall(struct thread *td, register_t stack)
122 {
123
124         if (stack)
125                 td->td_frame->tf_rsp = stack;
126
127         /*
128          * The newly created Linux thread returns
129          * to the user space by the same path that a parent does.
130          */
131         td->td_frame->tf_rax = 0;
132         return (0);
133 }
134
135 int
136 linux_mmap2(struct thread *td, struct linux_mmap2_args *args)
137 {
138
139         return (linux_mmap_common(td, args->addr, args->len, args->prot,
140                 args->flags, args->fd, args->pgoff));
141 }
142
143 int
144 linux_mprotect(struct thread *td, struct linux_mprotect_args *uap)
145 {
146
147         return (linux_mprotect_common(td, uap->addr, uap->len, uap->prot));
148 }
149
150 int
151 linux_madvise(struct thread *td, struct linux_madvise_args *uap)
152 {
153
154         return (linux_madvise_common(td, uap->addr, uap->len, uap->behav));
155 }
156
157 int
158 linux_iopl(struct thread *td, struct linux_iopl_args *args)
159 {
160         int error;
161
162         LINUX_CTR(iopl);
163
164         if (args->level > 3)
165                 return (EINVAL);
166         if ((error = priv_check(td, PRIV_IO)) != 0)
167                 return (error);
168         if ((error = securelevel_gt(td->td_ucred, 0)) != 0)
169                 return (error);
170         td->td_frame->tf_rflags = (td->td_frame->tf_rflags & ~PSL_IOPL) |
171             (args->level * (PSL_IOPL / 3));
172
173         return (0);
174 }
175
176 int
177 linux_pause(struct thread *td, struct linux_pause_args *args)
178 {
179         struct proc *p = td->td_proc;
180         sigset_t sigmask;
181
182         LINUX_CTR(pause);
183
184         PROC_LOCK(p);
185         sigmask = td->td_sigmask;
186         PROC_UNLOCK(p);
187         return (kern_sigsuspend(td, sigmask));
188 }
189
190 int
191 linux_sigaltstack(struct thread *td, struct linux_sigaltstack_args *uap)
192 {
193         stack_t ss, oss;
194         l_stack_t lss;
195         int error;
196
197         memset(&lss, 0, sizeof(lss));
198         LINUX_CTR2(sigaltstack, "%p, %p", uap->uss, uap->uoss);
199
200         if (uap->uss != NULL) {
201                 error = copyin(uap->uss, &lss, sizeof(l_stack_t));
202                 if (error)
203                         return (error);
204
205                 ss.ss_sp = PTRIN(lss.ss_sp);
206                 ss.ss_size = lss.ss_size;
207                 ss.ss_flags = linux_to_bsd_sigaltstack(lss.ss_flags);
208         }
209         error = kern_sigaltstack(td, (uap->uss != NULL) ? &ss : NULL,
210             (uap->uoss != NULL) ? &oss : NULL);
211         if (!error && uap->uoss != NULL) {
212                 lss.ss_sp = PTROUT(oss.ss_sp);
213                 lss.ss_size = oss.ss_size;
214                 lss.ss_flags = bsd_to_linux_sigaltstack(oss.ss_flags);
215                 error = copyout(&lss, uap->uoss, sizeof(l_stack_t));
216         }
217
218         return (error);
219 }
220
221 int
222 linux_arch_prctl(struct thread *td, struct linux_arch_prctl_args *args)
223 {
224         unsigned long long cet[3];
225         struct pcb *pcb;
226         int error;
227
228         pcb = td->td_pcb;
229         LINUX_CTR2(arch_prctl, "0x%x, %p", args->code, args->addr);
230
231         switch (args->code) {
232         case LINUX_ARCH_SET_GS:
233                 if (args->addr < VM_MAXUSER_ADDRESS) {
234                         update_pcb_bases(pcb);
235                         pcb->pcb_gsbase = args->addr;
236                         td->td_frame->tf_gs = _ugssel;
237                         error = 0;
238                 } else
239                         error = EPERM;
240                 break;
241         case LINUX_ARCH_SET_FS:
242                 if (args->addr < VM_MAXUSER_ADDRESS) {
243                         update_pcb_bases(pcb);
244                         pcb->pcb_fsbase = args->addr;
245                         td->td_frame->tf_fs = _ufssel;
246                         error = 0;
247                 } else
248                         error = EPERM;
249                 break;
250         case LINUX_ARCH_GET_FS:
251                 error = copyout(&pcb->pcb_fsbase, PTRIN(args->addr),
252                     sizeof(args->addr));
253                 break;
254         case LINUX_ARCH_GET_GS:
255                 error = copyout(&pcb->pcb_gsbase, PTRIN(args->addr),
256                     sizeof(args->addr));
257                 break;
258         case LINUX_ARCH_CET_STATUS:
259                 memset(cet, 0, sizeof(cet));
260                 error = copyout(&cet, PTRIN(args->addr), sizeof(cet));
261                 break;
262         default:
263                 linux_msg(td, "unsupported arch_prctl code %#x", args->code);
264                 error = EINVAL;
265         }
266         return (error);
267 }
268
269 int
270 linux_set_cloned_tls(struct thread *td, void *desc)
271 {
272         struct pcb *pcb;
273
274         if ((uint64_t)desc >= VM_MAXUSER_ADDRESS)
275                 return (EPERM);
276
277         pcb = td->td_pcb;
278         update_pcb_bases(pcb);
279         pcb->pcb_fsbase = (register_t)desc;
280         td->td_frame->tf_fs = _ufssel;
281
282         return (0);
283 }
284
285 int futex_xchgl_nosmap(int oparg, uint32_t *uaddr, int *oldval);
286 int futex_xchgl_smap(int oparg, uint32_t *uaddr, int *oldval);
287 DEFINE_IFUNC(, int, futex_xchgl, (int, uint32_t *, int *))
288 {
289
290         return ((cpu_stdext_feature & CPUID_STDEXT_SMAP) != 0 ?
291             futex_xchgl_smap : futex_xchgl_nosmap);
292 }
293
294 int futex_addl_nosmap(int oparg, uint32_t *uaddr, int *oldval);
295 int futex_addl_smap(int oparg, uint32_t *uaddr, int *oldval);
296 DEFINE_IFUNC(, int, futex_addl, (int, uint32_t *, int *))
297 {
298
299         return ((cpu_stdext_feature & CPUID_STDEXT_SMAP) != 0 ?
300             futex_addl_smap : futex_addl_nosmap);
301 }
302
303 int futex_orl_nosmap(int oparg, uint32_t *uaddr, int *oldval);
304 int futex_orl_smap(int oparg, uint32_t *uaddr, int *oldval);
305 DEFINE_IFUNC(, int, futex_orl, (int, uint32_t *, int *))
306 {
307
308         return ((cpu_stdext_feature & CPUID_STDEXT_SMAP) != 0 ?
309             futex_orl_smap : futex_orl_nosmap);
310 }
311
312 int futex_andl_nosmap(int oparg, uint32_t *uaddr, int *oldval);
313 int futex_andl_smap(int oparg, uint32_t *uaddr, int *oldval);
314 DEFINE_IFUNC(, int, futex_andl, (int, uint32_t *, int *))
315 {
316
317         return ((cpu_stdext_feature & CPUID_STDEXT_SMAP) != 0 ?
318             futex_andl_smap : futex_andl_nosmap);
319 }
320
321 int futex_xorl_nosmap(int oparg, uint32_t *uaddr, int *oldval);
322 int futex_xorl_smap(int oparg, uint32_t *uaddr, int *oldval);
323 DEFINE_IFUNC(, int, futex_xorl, (int, uint32_t *, int *))
324 {
325
326         return ((cpu_stdext_feature & CPUID_STDEXT_SMAP) != 0 ?
327             futex_xorl_smap : futex_xorl_nosmap);
328 }