xref: /freebsd/sys/arm64/linux/linux_sysvec.c (revision 324cdd9320f58837c2fbaa7f6ceb9ea5c33d5b2a) 
1 /*-
2  * SPDX-License-Identifier: BSD-2-Clause-FreeBSD
3  *
4  * Copyright (c) 1994-1996 Søren Schmidt
5  * Copyright (c) 2018 Turing Robotic Industries Inc.
6  *
7  * Redistribution and use in source and binary forms, with or without
8  * modification, are permitted provided that the following conditions
9  * are met:
10  * 1. Redistributions of source code must retain the above copyright
11  *    notice, this list of conditions and the following disclaimer.
12  * 2. Redistributions in binary form must reproduce the above copyright
13  *    notice, this list of conditions and the following disclaimer in the
14  *    documentation and/or other materials provided with the distribution.
15  *
16  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
17  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
18  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
19  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
20  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
21  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
22  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
23  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
24  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
25  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
26  * SUCH DAMAGE.
27  */
28 
29 #include <sys/cdefs.h>
30 __FBSDID("$FreeBSD$");
31 
32 #include <sys/param.h>
33 #include <sys/systm.h>
34 #include <sys/cdefs.h>
35 #include <sys/elf.h>
36 #include <sys/exec.h>
37 #include <sys/imgact.h>
38 #include <sys/imgact_elf.h>
39 #include <sys/kernel.h>
40 #include <sys/lock.h>
41 #include <sys/module.h>
42 #include <sys/mutex.h>
43 #include <sys/proc.h>
44 #include <sys/signalvar.h>
45 #include <sys/sysctl.h>
46 #include <sys/sysent.h>
47 
48 #include <vm/vm_param.h>
49 
50 #include <arm64/linux/linux.h>
51 #include <arm64/linux/linux_proto.h>
52 #include <compat/linux/linux_dtrace.h>
53 #include <compat/linux/linux_emul.h>
54 #include <compat/linux/linux_ioctl.h>
55 #include <compat/linux/linux_mib.h>
56 #include <compat/linux/linux_misc.h>
57 #include <compat/linux/linux_vdso.h>
58 
59 MODULE_VERSION(linux64elf, 1);
60 
61 const char *linux_kplatform;
62 static int linux_szsigcode;
63 static vm_object_t linux_shared_page_obj;
64 static char *linux_shared_page_mapping;
65 extern char _binary_linux_locore_o_start;
66 extern char _binary_linux_locore_o_end;
67 
68 extern struct sysent linux_sysent[LINUX_SYS_MAXSYSCALL];
69 
70 SET_DECLARE(linux_ioctl_handler_set, struct linux_ioctl_handler);
71 
72 static int	linux_copyout_strings(struct image_params *imgp,
73 		    uintptr_t *stack_base);
74 static int	linux_elf_fixup(uintptr_t *stack_base,
75 		    struct image_params *iparams);
76 static bool	linux_trans_osrel(const Elf_Note *note, int32_t *osrel);
77 static void	linux_vdso_install(const void *param);
78 static void	linux_vdso_deinstall(const void *param);
79 static void	linux_set_syscall_retval(struct thread *td, int error);
80 static int	linux_fetch_syscall_args(struct thread *td);
81 static void	linux_exec_setregs(struct thread *td, struct image_params *imgp,
82 		    uintptr_t stack);
83 static int	linux_vsyscall(struct thread *td);
84 
85 /* DTrace init */
86 LIN_SDT_PROVIDER_DECLARE(LINUX_DTRACE);
87 
88 /* DTrace probes */
89 LIN_SDT_PROBE_DEFINE2(sysvec, linux_translate_traps, todo, "int", "int");
90 LIN_SDT_PROBE_DEFINE0(sysvec, linux_exec_setregs, todo);
91 LIN_SDT_PROBE_DEFINE0(sysvec, linux_copyout_auxargs, todo);
92 LIN_SDT_PROBE_DEFINE0(sysvec, linux_elf_fixup, todo);
93 LIN_SDT_PROBE_DEFINE0(sysvec, linux_rt_sigreturn, todo);
94 LIN_SDT_PROBE_DEFINE0(sysvec, linux_rt_sendsig, todo);
95 LIN_SDT_PROBE_DEFINE0(sysvec, linux_vsyscall, todo);
96 LIN_SDT_PROBE_DEFINE0(sysvec, linux_vdso_install, todo);
97 LIN_SDT_PROBE_DEFINE0(sysvec, linux_vdso_deinstall, todo);
98 
99 /* LINUXTODO: do we have traps to translate? */
100 static int
101 linux_translate_traps(int signal, int trap_code)
102 {
103 
104 	LIN_SDT_PROBE2(sysvec, linux_translate_traps, todo, signal, trap_code);
105 	return (signal);
106 }
107 
108 LINUX_VDSO_SYM_CHAR(linux_platform);
109 
110 static int
111 linux_fetch_syscall_args(struct thread *td)
112 {
113 	struct proc *p;
114 	struct syscall_args *sa;
115 	register_t *ap;
116 
117 	p = td->td_proc;
118 	ap = td->td_frame->tf_x;
119 	sa = &td->td_sa;
120 
121 	sa->code = td->td_frame->tf_x[8];
122 	/* LINUXTODO: generic syscall? */
123 	if (sa->code >= p->p_sysent->sv_size)
124 		sa->callp = &p->p_sysent->sv_table[0];
125 	else
126 		sa->callp = &p->p_sysent->sv_table[sa->code];
127 
128 	sa->narg = sa->callp->sy_narg;
129 	if (sa->narg > 8)
130 		panic("ARM64TODO: Could we have more than 8 args?");
131 	memcpy(sa->args, ap, 8 * sizeof(register_t));
132 
133 	td->td_retval[0] = 0;
134 	return (0);
135 }
136 
137 static void
138 linux_set_syscall_retval(struct thread *td, int error)
139 {
140 
141 	td->td_retval[1] = td->td_frame->tf_x[1];
142 	cpu_set_syscall_retval(td, error);
143 }
144 
145 static int
146 linux_copyout_auxargs(struct image_params *imgp, uintptr_t *base)
147 {
148 	Elf_Auxargs *args;
149 	Elf_Auxinfo *argarray, *pos;
150 	u_long auxlen;
151 	struct proc *p;
152 	int error, issetugid;
153 
154 	LIN_SDT_PROBE0(sysvec, linux_copyout_auxargs, todo);
155 	p = imgp->proc;
156 
157 	args = (Elf64_Auxargs *)imgp->auxargs;
158 	argarray = pos = malloc(LINUX_AT_COUNT * sizeof(*pos), M_TEMP,
159 	    M_WAITOK | M_ZERO);
160 
161 	issetugid = p->p_flag & P_SUGID ? 1 : 0;
162 	AUXARGS_ENTRY(pos, LINUX_AT_SYSINFO_EHDR,
163 	    imgp->proc->p_sysent->sv_shared_page_base);
164 #if 0	/* LINUXTODO: implement arm64 LINUX_AT_HWCAP */
165 	AUXARGS_ENTRY(pos, LINUX_AT_HWCAP, cpu_feature);
166 #endif
167 	AUXARGS_ENTRY(pos, LINUX_AT_CLKTCK, stclohz);
168 	AUXARGS_ENTRY(pos, AT_PHDR, args->phdr);
169 	AUXARGS_ENTRY(pos, AT_PHENT, args->phent);
170 	AUXARGS_ENTRY(pos, AT_PHNUM, args->phnum);
171 	AUXARGS_ENTRY(pos, AT_PAGESZ, args->pagesz);
172 	AUXARGS_ENTRY(pos, AT_BASE, args->base);
173 	AUXARGS_ENTRY(pos, AT_FLAGS, args->flags);
174 	AUXARGS_ENTRY(pos, AT_ENTRY, args->entry);
175 	AUXARGS_ENTRY(pos, AT_UID, imgp->proc->p_ucred->cr_ruid);
176 	AUXARGS_ENTRY(pos, AT_EUID, imgp->proc->p_ucred->cr_svuid);
177 	AUXARGS_ENTRY(pos, AT_GID, imgp->proc->p_ucred->cr_rgid);
178 	AUXARGS_ENTRY(pos, AT_EGID, imgp->proc->p_ucred->cr_svgid);
179 	AUXARGS_ENTRY(pos, LINUX_AT_SECURE, issetugid);
180 #if 0	/* LINUXTODO: implement arm64 LINUX_AT_PLATFORM */
181 	AUXARGS_ENTRY(pos, LINUX_AT_PLATFORM, PTROUT(linux_platform));
182 #endif
183 	AUXARGS_ENTRY(pos, LINUX_AT_RANDOM, imgp->canary);
184 	if (imgp->execpathp != 0)
185 		AUXARGS_ENTRY(pos, LINUX_AT_EXECFN, imgp->execpathp);
186 	if (args->execfd != -1)
187 		AUXARGS_ENTRY(pos, AT_EXECFD, args->execfd);
188 	AUXARGS_ENTRY(pos, AT_NULL, 0);
189 	free(imgp->auxargs, M_TEMP);
190 	imgp->auxargs = NULL;
191 	KASSERT(pos - argarray <= LINUX_AT_COUNT, ("Too many auxargs"));
192 
193 	auxlen = sizeof(*argarray) * (pos - argarray);
194 	*base -= auxlen;
195 	error = copyout(argarray, (void *)*base, auxlen);
196 	free(argarray, M_TEMP);
197 	return (error);
198 }
199 
200 static int
201 linux_elf_fixup(uintptr_t *stack_base, struct image_params *imgp)
202 {
203 
204 	LIN_SDT_PROBE0(sysvec, linux_elf_fixup, todo);
205 
206 	return (0);
207 }
208 
209 /*
210  * Copy strings out to the new process address space, constructing new arg
211  * and env vector tables. Return a pointer to the base so that it can be used
212  * as the initial stack pointer.
213  * LINUXTODO: deduplicate against other linuxulator archs
214  */
215 static int
216 linux_copyout_strings(struct image_params *imgp, uintptr_t *stack_base)
217 {
218 	char **vectp;
219 	char *stringp;
220 	uintptr_t destp, ustringp;
221 	struct ps_strings *arginfo;
222 	char canary[LINUX_AT_RANDOM_LEN];
223 	size_t execpath_len;
224 	struct proc *p;
225 	int argc, envc, error;
226 
227 	/* Calculate string base and vector table pointers. */
228 	if (imgp->execpath != NULL && imgp->auxargs != NULL)
229 		execpath_len = strlen(imgp->execpath) + 1;
230 	else
231 		execpath_len = 0;
232 
233 	p = imgp->proc;
234 	arginfo = (struct ps_strings *)p->p_sysent->sv_psstrings;
235 	destp = (uintptr_t)arginfo;
236 
237 	if (execpath_len != 0) {
238 		destp -= execpath_len;
239 		destp = rounddown2(destp, sizeof(void *));
240 		imgp->execpathp = destp;
241 		error = copyout(imgp->execpath, (void *)destp, execpath_len);
242 		if (error != 0)
243 			return (error);
244 	}
245 
246 	/* Prepare the canary for SSP. */
247 	arc4rand(canary, sizeof(canary), 0);
248 	destp -= roundup(sizeof(canary), sizeof(void *));
249 	imgp->canary = destp;
250 	error = copyout(canary, (void *)destp, sizeof(canary));
251 	if (error != 0)
252 		return (error);
253 
254 	/* Allocate room for the argument and environment strings. */
255 	destp -= ARG_MAX - imgp->args->stringspace;
256 	destp = rounddown2(destp, sizeof(void *));
257 	ustringp = destp;
258 
259 	if (imgp->auxargs) {
260 		error = imgp->sysent->sv_copyout_auxargs(imgp, &destp);
261 		if (error != 0)
262 			return (error);
263 	}
264 
265 	vectp = (char **)destp;
266 
267 	/*
268 	 * Allocate room for argc and the argv[] and env vectors including the
269 	 * terminating NULL pointers.
270 	 */
271 	vectp -= 1 + imgp->args->argc + 1 + imgp->args->envc + 1;
272 	vectp = (char **)STACKALIGN(vectp);
273 
274 	/* vectp also becomes our initial stack base. */
275 	*stack_base = (uintptr_t)vectp;
276 
277 	stringp = imgp->args->begin_argv;
278 	argc = imgp->args->argc;
279 	envc = imgp->args->envc;
280 
281 	/* Copy out strings - arguments and environment. */
282 	error = copyout(stringp, (void *)ustringp,
283 	    ARG_MAX - imgp->args->stringspace);
284 	if (error != 0)
285 		return (error);
286 
287 	/* Fill in "ps_strings" struct for ps, w, etc. */
288 	if (suword(&arginfo->ps_argvstr, (long)(intptr_t)vectp) != 0 ||
289 	    suword(&arginfo->ps_nargvstr, argc) != 0)
290 		return (EFAULT);
291 
292 	if (suword(vectp++, argc) != 0)
293 		return (EFAULT);
294 
295 	/* Fill in argument portion of vector table. */
296 	for (; argc > 0; --argc) {
297 		if (suword(vectp++, ustringp) != 0)
298 			return (EFAULT);
299 		while (*stringp++ != 0)
300 			ustringp++;
301 		ustringp++;
302 	}
303 
304 	/* A null vector table pointer separates the argp's from the envp's. */
305 	if (suword(vectp++, 0) != 0)
306 		return (EFAULT);
307 
308 	if (suword(&arginfo->ps_envstr, (long)(intptr_t)vectp) != 0 ||
309 	    suword(&arginfo->ps_nenvstr, envc) != 0)
310 		return (EFAULT);
311 
312 	/* Fill in environment portion of vector table. */
313 	for (; envc > 0; --envc) {
314 		if (suword(vectp++, ustringp) != 0)
315 			return (EFAULT);
316 		while (*stringp++ != 0)
317 			ustringp++;
318 		ustringp++;
319 	}
320 
321 	/* The end of the vector table is a null pointer. */
322 	if (suword(vectp, 0) != 0)
323 		return (EFAULT);
324 
325 	return (0);
326 }
327 
328 /*
329  * Reset registers to default values on exec.
330  */
331 static void
332 linux_exec_setregs(struct thread *td, struct image_params *imgp,
333     uintptr_t stack)
334 {
335 	struct trapframe *regs = td->td_frame;
336 
337 	/* LINUXTODO: validate */
338 	LIN_SDT_PROBE0(sysvec, linux_exec_setregs, todo);
339 
340 	memset(regs, 0, sizeof(*regs));
341 	/* glibc start.S registers function pointer in x0 with atexit. */
342         regs->tf_sp = stack;
343 #if 0	/* LINUXTODO: See if this is used. */
344 	regs->tf_lr = imgp->entry_addr;
345 #else
346         regs->tf_lr = 0xffffffffffffffff;
347 #endif
348         regs->tf_elr = imgp->entry_addr;
349 }
350 
351 int
352 linux_rt_sigreturn(struct thread *td, struct linux_rt_sigreturn_args *args)
353 {
354 
355 	/* LINUXTODO: implement */
356 	LIN_SDT_PROBE0(sysvec, linux_rt_sigreturn, todo);
357 	return (EDOOFUS);
358 }
359 
360 static void
361 linux_rt_sendsig(sig_t catcher, ksiginfo_t *ksi, sigset_t *mask)
362 {
363 
364 	/* LINUXTODO: implement */
365 	LIN_SDT_PROBE0(sysvec, linux_rt_sendsig, todo);
366 }
367 
368 static int
369 linux_vsyscall(struct thread *td)
370 {
371 
372 	/* LINUXTODO: implement */
373 	LIN_SDT_PROBE0(sysvec, linux_vsyscall, todo);
374 	return (EDOOFUS);
375 }
376 
377 struct sysentvec elf_linux_sysvec = {
378 	.sv_size	= LINUX_SYS_MAXSYSCALL,
379 	.sv_table	= linux_sysent,
380 	.sv_errsize	= ELAST + 1,
381 	.sv_errtbl	= linux_errtbl,
382 	.sv_transtrap	= linux_translate_traps,
383 	.sv_fixup	= linux_elf_fixup,
384 	.sv_sendsig	= linux_rt_sendsig,
385 	.sv_sigcode	= &_binary_linux_locore_o_start,
386 	.sv_szsigcode	= &linux_szsigcode,
387 	.sv_name	= "Linux ELF64",
388 	.sv_coredump	= elf64_coredump,
389 	.sv_imgact_try	= linux_exec_imgact_try,
390 	.sv_minsigstksz	= LINUX_MINSIGSTKSZ,
391 	.sv_minuser	= VM_MIN_ADDRESS,
392 	.sv_maxuser	= VM_MAXUSER_ADDRESS,
393 	.sv_usrstack	= USRSTACK,
394 	.sv_psstrings	= PS_STRINGS, /* XXX */
395 	.sv_stackprot	= VM_PROT_READ | VM_PROT_WRITE,
396 	.sv_copyout_auxargs = linux_copyout_auxargs,
397 	.sv_copyout_strings = linux_copyout_strings,
398 	.sv_setregs	= linux_exec_setregs,
399 	.sv_fixlimit	= NULL,
400 	.sv_maxssiz	= NULL,
401 	.sv_flags	= SV_ABI_LINUX | SV_LP64 | SV_SHP,
402 	.sv_set_syscall_retval = linux_set_syscall_retval,
403 	.sv_fetch_syscall_args = linux_fetch_syscall_args,
404 	.sv_syscallnames = NULL,
405 	.sv_shared_page_base = SHAREDPAGE,
406 	.sv_shared_page_len = PAGE_SIZE,
407 	.sv_schedtail	= linux_schedtail,
408 	.sv_thread_detach = linux_thread_detach,
409 	.sv_trap	= linux_vsyscall,
410 };
411 
412 static void
413 linux_vdso_install(const void *param)
414 {
415 
416 	linux_szsigcode = (&_binary_linux_locore_o_end -
417 	    &_binary_linux_locore_o_start);
418 
419 	if (linux_szsigcode > elf_linux_sysvec.sv_shared_page_len)
420 		panic("invalid Linux VDSO size\n");
421 
422 	__elfN(linux_vdso_fixup)(&elf_linux_sysvec);
423 
424 	linux_shared_page_obj = __elfN(linux_shared_page_init)
425 	    (&linux_shared_page_mapping);
426 
427 	__elfN(linux_vdso_reloc)(&elf_linux_sysvec);
428 
429 	memcpy(linux_shared_page_mapping, elf_linux_sysvec.sv_sigcode,
430 	    linux_szsigcode);
431 	elf_linux_sysvec.sv_shared_page_obj = linux_shared_page_obj;
432 
433 	printf("LINUXTODO: %s: fix linux_kplatform\n", __func__);
434 #if 0
435 	linux_kplatform = linux_shared_page_mapping +
436 	    (linux_platform - (caddr_t)elf_linux_sysvec.sv_shared_page_base);
437 #else
438 	linux_kplatform = "arm64";
439 #endif
440 }
441 SYSINIT(elf_linux_vdso_init, SI_SUB_EXEC, SI_ORDER_ANY,
442     linux_vdso_install, NULL);
443 
444 static void
445 linux_vdso_deinstall(const void *param)
446 {
447 
448 	LIN_SDT_PROBE0(sysvec, linux_vdso_deinstall, todo);
449 	__elfN(linux_shared_page_fini)(linux_shared_page_obj);
450 }
451 SYSUNINIT(elf_linux_vdso_uninit, SI_SUB_EXEC, SI_ORDER_FIRST,
452     linux_vdso_deinstall, NULL);
453 
454 static char GNU_ABI_VENDOR[] = "GNU";
455 static int GNU_ABI_LINUX = 0;
456 
457 /* LINUXTODO: deduplicate */
458 static bool
459 linux_trans_osrel(const Elf_Note *note, int32_t *osrel)
460 {
461 	const Elf32_Word *desc;
462 	uintptr_t p;
463 
464 	p = (uintptr_t)(note + 1);
465 	p += roundup2(note->n_namesz, sizeof(Elf32_Addr));
466 
467 	desc = (const Elf32_Word *)p;
468 	if (desc[0] != GNU_ABI_LINUX)
469 		return (false);
470 
471 	*osrel = LINUX_KERNVER(desc[1], desc[2], desc[3]);
472 	return (true);
473 }
474 
475 static Elf_Brandnote linux64_brandnote = {
476 	.hdr.n_namesz	= sizeof(GNU_ABI_VENDOR),
477 	.hdr.n_descsz	= 16,
478 	.hdr.n_type	= 1,
479 	.vendor		= GNU_ABI_VENDOR,
480 	.flags		= BN_TRANSLATE_OSREL,
481 	.trans_osrel	= linux_trans_osrel
482 };
483 
484 static Elf64_Brandinfo linux_glibc2brand = {
485 	.brand		= ELFOSABI_LINUX,
486 	.machine	= EM_AARCH64,
487 	.compat_3_brand	= "Linux",
488 	.emul_path	= "/compat/linux",
489 	.interp_path	= "/lib64/ld-linux-x86-64.so.2",
490 	.sysvec		= &elf_linux_sysvec,
491 	.interp_newpath	= NULL,
492 	.brand_note	= &linux64_brandnote,
493 	.flags		= BI_CAN_EXEC_DYN | BI_BRAND_NOTE
494 };
495 
496 Elf64_Brandinfo *linux_brandlist[] = {
497 	&linux_glibc2brand,
498 	NULL
499 };
500 
501 static int
502 linux64_elf_modevent(module_t mod, int type, void *data)
503 {
504 	Elf64_Brandinfo **brandinfo;
505 	struct linux_ioctl_handler**lihp;
506 	int error;
507 
508 	error = 0;
509 	switch(type) {
510 	case MOD_LOAD:
511 		for (brandinfo = &linux_brandlist[0]; *brandinfo != NULL;
512 		    ++brandinfo)
513 			if (elf64_insert_brand_entry(*brandinfo) < 0)
514 				error = EINVAL;
515 		if (error == 0) {
516 			SET_FOREACH(lihp, linux_ioctl_handler_set)
517 				linux_ioctl_register_handler(*lihp);
518 			stclohz = (stathz ? stathz : hz);
519 			if (bootverbose)
520 				printf("Linux arm64 ELF exec handler installed\n");
521 		}
522 		break;
523 	case MOD_UNLOAD:
524 		for (brandinfo = &linux_brandlist[0]; *brandinfo != NULL;
525 		    ++brandinfo)
526 			if (elf64_brand_inuse(*brandinfo))
527 				error = EBUSY;
528 		if (error == 0) {
529 			for (brandinfo = &linux_brandlist[0];
530 			    *brandinfo != NULL; ++brandinfo)
531 				if (elf64_remove_brand_entry(*brandinfo) < 0)
532 					error = EINVAL;
533 		}
534 		if (error == 0) {
535 			SET_FOREACH(lihp, linux_ioctl_handler_set)
536 				linux_ioctl_unregister_handler(*lihp);
537 			if (bootverbose)
538 				printf("Linux ELF exec handler removed\n");
539 		} else
540 			printf("Could not deinstall ELF interpreter entry\n");
541 		break;
542 	default:
543 		return (EOPNOTSUPP);
544 	}
545 	return (error);
546 }
547 
548 static moduledata_t linux64_elf_mod = {
549 	"linux64elf",
550 	linux64_elf_modevent,
551 	0
552 };
553 
554 DECLARE_MODULE_TIED(linux64elf, linux64_elf_mod, SI_SUB_EXEC, SI_ORDER_ANY);
555 MODULE_DEPEND(linux64elf, linux_common, 1, 1, 1);
556 FEATURE(linux64, "AArch64 Linux 64bit support");
557