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
96int
97linux_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
120int
121linux_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
135int
136linux_mmap2(struct thread *td, struct linux_mmap2_args *args)
137{
138
139	return (linux_mmap_common(td, PTROUT(args->addr), args->len, args->prot,
140		args->flags, args->fd, args->pgoff));
141}
142
143int
144linux_mprotect(struct thread *td, struct linux_mprotect_args *uap)
145{
146
147	return (linux_mprotect_common(td, PTROUT(uap->addr), uap->len, uap->prot));
148}
149
150int
151linux_madvise(struct thread *td, struct linux_madvise_args *uap)
152{
153
154	return (linux_madvise_common(td, PTROUT(uap->addr), uap->len, uap->behav));
155}
156
157int
158linux_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
176int
177linux_rt_sigsuspend(struct thread *td, struct linux_rt_sigsuspend_args *uap)
178{
179	l_sigset_t lmask;
180	sigset_t sigmask;
181	int error;
182
183	LINUX_CTR2(rt_sigsuspend, "%p, %ld",
184	    uap->newset, uap->sigsetsize);
185
186	if (uap->sigsetsize != sizeof(l_sigset_t))
187		return (EINVAL);
188
189	error = copyin(uap->newset, &lmask, sizeof(l_sigset_t));
190	if (error)
191		return (error);
192
193	linux_to_bsd_sigset(&lmask, &sigmask);
194	return (kern_sigsuspend(td, sigmask));
195}
196
197int
198linux_pause(struct thread *td, struct linux_pause_args *args)
199{
200	struct proc *p = td->td_proc;
201	sigset_t sigmask;
202
203	LINUX_CTR(pause);
204
205	PROC_LOCK(p);
206	sigmask = td->td_sigmask;
207	PROC_UNLOCK(p);
208	return (kern_sigsuspend(td, sigmask));
209}
210
211int
212linux_sigaltstack(struct thread *td, struct linux_sigaltstack_args *uap)
213{
214	stack_t ss, oss;
215	l_stack_t lss;
216	int error;
217
218	memset(&lss, 0, sizeof(lss));
219	LINUX_CTR2(sigaltstack, "%p, %p", uap->uss, uap->uoss);
220
221	if (uap->uss != NULL) {
222		error = copyin(uap->uss, &lss, sizeof(l_stack_t));
223		if (error)
224			return (error);
225
226		ss.ss_sp = PTRIN(lss.ss_sp);
227		ss.ss_size = lss.ss_size;
228		ss.ss_flags = linux_to_bsd_sigaltstack(lss.ss_flags);
229	}
230	error = kern_sigaltstack(td, (uap->uss != NULL) ? &ss : NULL,
231	    (uap->uoss != NULL) ? &oss : NULL);
232	if (!error && uap->uoss != NULL) {
233		lss.ss_sp = PTROUT(oss.ss_sp);
234		lss.ss_size = oss.ss_size;
235		lss.ss_flags = bsd_to_linux_sigaltstack(oss.ss_flags);
236		error = copyout(&lss, uap->uoss, sizeof(l_stack_t));
237	}
238
239	return (error);
240}
241
242int
243linux_arch_prctl(struct thread *td, struct linux_arch_prctl_args *args)
244{
245	struct pcb *pcb;
246	int error;
247
248	pcb = td->td_pcb;
249	LINUX_CTR2(arch_prctl, "0x%x, %p", args->code, args->addr);
250
251	switch (args->code) {
252	case LINUX_ARCH_SET_GS:
253		if (args->addr < VM_MAXUSER_ADDRESS) {
254			update_pcb_bases(pcb);
255			pcb->pcb_gsbase = args->addr;
256			td->td_frame->tf_gs = _ugssel;
257			error = 0;
258		} else
259			error = EPERM;
260		break;
261	case LINUX_ARCH_SET_FS:
262		if (args->addr < VM_MAXUSER_ADDRESS) {
263			update_pcb_bases(pcb);
264			pcb->pcb_fsbase = args->addr;
265			td->td_frame->tf_fs = _ufssel;
266			error = 0;
267		} else
268			error = EPERM;
269		break;
270	case LINUX_ARCH_GET_FS:
271		error = copyout(&pcb->pcb_fsbase, PTRIN(args->addr),
272		    sizeof(args->addr));
273		break;
274	case LINUX_ARCH_GET_GS:
275		error = copyout(&pcb->pcb_gsbase, PTRIN(args->addr),
276		    sizeof(args->addr));
277		break;
278	default:
279		error = EINVAL;
280	}
281	return (error);
282}
283
284int
285linux_set_cloned_tls(struct thread *td, void *desc)
286{
287	struct pcb *pcb;
288
289	if ((uint64_t)desc >= VM_MAXUSER_ADDRESS)
290		return (EPERM);
291
292	pcb = td->td_pcb;
293	update_pcb_bases(pcb);
294	pcb->pcb_fsbase = (register_t)desc;
295	td->td_frame->tf_fs = _ufssel;
296
297	return (0);
298}
299
300int futex_xchgl_nosmap(int oparg, uint32_t *uaddr, int *oldval);
301int futex_xchgl_smap(int oparg, uint32_t *uaddr, int *oldval);
302DEFINE_IFUNC(, int, futex_xchgl, (int, uint32_t *, int *))
303{
304
305	return ((cpu_stdext_feature & CPUID_STDEXT_SMAP) != 0 ?
306	    futex_xchgl_smap : futex_xchgl_nosmap);
307}
308
309int futex_addl_nosmap(int oparg, uint32_t *uaddr, int *oldval);
310int futex_addl_smap(int oparg, uint32_t *uaddr, int *oldval);
311DEFINE_IFUNC(, int, futex_addl, (int, uint32_t *, int *))
312{
313
314	return ((cpu_stdext_feature & CPUID_STDEXT_SMAP) != 0 ?
315	    futex_addl_smap : futex_addl_nosmap);
316}
317
318int futex_orl_nosmap(int oparg, uint32_t *uaddr, int *oldval);
319int futex_orl_smap(int oparg, uint32_t *uaddr, int *oldval);
320DEFINE_IFUNC(, int, futex_orl, (int, uint32_t *, int *))
321{
322
323	return ((cpu_stdext_feature & CPUID_STDEXT_SMAP) != 0 ?
324	    futex_orl_smap : futex_orl_nosmap);
325}
326
327int futex_andl_nosmap(int oparg, uint32_t *uaddr, int *oldval);
328int futex_andl_smap(int oparg, uint32_t *uaddr, int *oldval);
329DEFINE_IFUNC(, int, futex_andl, (int, uint32_t *, int *))
330{
331
332	return ((cpu_stdext_feature & CPUID_STDEXT_SMAP) != 0 ?
333	    futex_andl_smap : futex_andl_nosmap);
334}
335
336int futex_xorl_nosmap(int oparg, uint32_t *uaddr, int *oldval);
337int futex_xorl_smap(int oparg, uint32_t *uaddr, int *oldval);
338DEFINE_IFUNC(, int, futex_xorl, (int, uint32_t *, int *))
339{
340
341	return ((cpu_stdext_feature & CPUID_STDEXT_SMAP) != 0 ?
342	    futex_xorl_smap : futex_xorl_nosmap);
343}
344