1/*-
2 * SPDX-License-Identifier: BSD-2-Clause-FreeBSD
3 *
4 * Copyright 1996-1998 John D. Polstra.
5 * All rights reserved.
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 ``AS IS'' AND ANY EXPRESS OR
17 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
18 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
19 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
20 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
21 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
22 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
23 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
24 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
25 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
26 */
27
28#include <sys/cdefs.h>
29__FBSDID("$FreeBSD$");
30
31#include <sys/param.h>
32#include <sys/kernel.h>
33#include <sys/systm.h>
34#include <sys/exec.h>
35#include <sys/imgact.h>
36#include <sys/linker.h>
37#include <sys/sysent.h>
38#include <sys/imgact_elf.h>
39#include <sys/proc.h>
40#include <sys/syscall.h>
41#include <sys/signalvar.h>
42#include <sys/vnode.h>
43
44#include <vm/vm.h>
45#include <vm/pmap.h>
46#include <vm/vm_param.h>
47
48#include <machine/elf.h>
49#include <machine/md_var.h>
50#include <machine/stack.h>
51#ifdef VFP
52#include <machine/vfp.h>
53#endif
54
55#include "opt_ddb.h"            /* for OPT_DDB */
56#include "opt_global.h"         /* for OPT_KDTRACE_HOOKS */
57#include "opt_stack.h"          /* for OPT_STACK */
58
59static boolean_t elf32_arm_abi_supported(struct image_params *);
60
61u_long elf_hwcap;
62u_long elf_hwcap2;
63
64struct sysentvec elf32_freebsd_sysvec = {
65	.sv_size	= SYS_MAXSYSCALL,
66	.sv_table	= sysent,
67	.sv_errsize	= 0,
68	.sv_errtbl	= NULL,
69	.sv_transtrap	= NULL,
70	.sv_fixup	= __elfN(freebsd_fixup),
71	.sv_sendsig	= sendsig,
72	.sv_sigcode	= sigcode,
73	.sv_szsigcode	= &szsigcode,
74	.sv_name	= "FreeBSD ELF32",
75	.sv_coredump	= __elfN(coredump),
76	.sv_imgact_try	= NULL,
77	.sv_minsigstksz	= MINSIGSTKSZ,
78	.sv_minuser	= VM_MIN_ADDRESS,
79	.sv_maxuser	= VM_MAXUSER_ADDRESS,
80	.sv_usrstack	= USRSTACK,
81	.sv_psstrings	= PS_STRINGS,
82	.sv_stackprot	= VM_PROT_ALL,
83	.sv_copyout_auxargs = __elfN(freebsd_copyout_auxargs),
84	.sv_copyout_strings = exec_copyout_strings,
85	.sv_setregs	= exec_setregs,
86	.sv_fixlimit	= NULL,
87	.sv_maxssiz	= NULL,
88	.sv_flags	=
89#if __ARM_ARCH >= 6
90			  SV_ASLR | SV_SHP | SV_TIMEKEEP |
91#endif
92			  SV_ABI_FREEBSD | SV_ILP32 | SV_ASLR,
93	.sv_set_syscall_retval = cpu_set_syscall_retval,
94	.sv_fetch_syscall_args = cpu_fetch_syscall_args,
95	.sv_syscallnames = syscallnames,
96	.sv_shared_page_base = SHAREDPAGE,
97	.sv_shared_page_len = PAGE_SIZE,
98	.sv_schedtail	= NULL,
99	.sv_thread_detach = NULL,
100	.sv_trap	= NULL,
101	.sv_hwcap	= &elf_hwcap,
102	.sv_hwcap2	= &elf_hwcap2,
103};
104INIT_SYSENTVEC(elf32_sysvec, &elf32_freebsd_sysvec);
105
106static Elf32_Brandinfo freebsd_brand_info = {
107	.brand		= ELFOSABI_FREEBSD,
108	.machine	= EM_ARM,
109	.compat_3_brand	= "FreeBSD",
110	.emul_path	= NULL,
111	.interp_path	= "/libexec/ld-elf.so.1",
112	.sysvec		= &elf32_freebsd_sysvec,
113	.interp_newpath	= NULL,
114	.brand_note	= &elf32_freebsd_brandnote,
115	.flags		= BI_CAN_EXEC_DYN | BI_BRAND_NOTE,
116	.header_supported= elf32_arm_abi_supported,
117};
118
119SYSINIT(elf32, SI_SUB_EXEC, SI_ORDER_FIRST,
120	(sysinit_cfunc_t) elf32_insert_brand_entry,
121	&freebsd_brand_info);
122
123static boolean_t
124elf32_arm_abi_supported(struct image_params *imgp)
125{
126	const Elf_Ehdr *hdr = (const Elf_Ehdr *)imgp->image_header;
127
128	/*
129	 * When configured for EABI, FreeBSD supports EABI vesions 4 and 5.
130	 */
131	if (EF_ARM_EABI_VERSION(hdr->e_flags) < EF_ARM_EABI_FREEBSD_MIN) {
132		if (bootverbose)
133			uprintf("Attempting to execute non EABI binary (rev %d) image %s",
134			    EF_ARM_EABI_VERSION(hdr->e_flags), imgp->args->fname);
135		return (FALSE);
136	}
137	return (TRUE);
138}
139
140void
141elf32_dump_thread(struct thread *td, void *dst, size_t *off)
142{
143#ifdef VFP
144	mcontext_vfp_t vfp;
145
146	if (dst != NULL) {
147		get_vfpcontext(td, &vfp);
148		*off = elf32_populate_note(NT_ARM_VFP, &vfp, dst, sizeof(vfp),
149		    NULL);
150	} else
151		*off = elf32_populate_note(NT_ARM_VFP, NULL, NULL, sizeof(vfp),
152		    NULL);
153#endif
154}
155
156bool
157elf_is_ifunc_reloc(Elf_Size r_info __unused)
158{
159
160	return (false);
161}
162
163/*
164 * It is possible for the compiler to emit relocations for unaligned data.
165 * We handle this situation with these inlines.
166 */
167#define	RELOC_ALIGNED_P(x) \
168	(((uintptr_t)(x) & (sizeof(void *) - 1)) == 0)
169
170static __inline Elf_Addr
171load_ptr(Elf_Addr *where)
172{
173	Elf_Addr res;
174
175	if (RELOC_ALIGNED_P(where))
176		return *where;
177	memcpy(&res, where, sizeof(res));
178	return (res);
179}
180
181static __inline void
182store_ptr(Elf_Addr *where, Elf_Addr val)
183{
184	if (RELOC_ALIGNED_P(where))
185		*where = val;
186	else
187		memcpy(where, &val, sizeof(val));
188}
189#undef RELOC_ALIGNED_P
190
191
192/* Process one elf relocation with addend. */
193static int
194elf_reloc_internal(linker_file_t lf, Elf_Addr relocbase, const void *data,
195    int type, int local, elf_lookup_fn lookup)
196{
197	Elf_Addr *where;
198	Elf_Addr addr;
199	Elf_Addr addend;
200	Elf_Word rtype, symidx;
201	const Elf_Rel *rel;
202	const Elf_Rela *rela;
203	int error;
204
205	switch (type) {
206	case ELF_RELOC_REL:
207		rel = (const Elf_Rel *)data;
208		where = (Elf_Addr *) (relocbase + rel->r_offset);
209		addend = load_ptr(where);
210		rtype = ELF_R_TYPE(rel->r_info);
211		symidx = ELF_R_SYM(rel->r_info);
212		break;
213	case ELF_RELOC_RELA:
214		rela = (const Elf_Rela *)data;
215		where = (Elf_Addr *) (relocbase + rela->r_offset);
216		addend = rela->r_addend;
217		rtype = ELF_R_TYPE(rela->r_info);
218		symidx = ELF_R_SYM(rela->r_info);
219		break;
220	default:
221		panic("unknown reloc type %d\n", type);
222	}
223
224	if (local) {
225		if (rtype == R_ARM_RELATIVE) {	/* A + B */
226			addr = elf_relocaddr(lf, relocbase + addend);
227			if (load_ptr(where) != addr)
228				store_ptr(where, addr);
229		}
230		return (0);
231	}
232
233	switch (rtype) {
234
235		case R_ARM_NONE:	/* none */
236			break;
237
238		case R_ARM_ABS32:
239			error = lookup(lf, symidx, 1, &addr);
240			if (error != 0)
241				return -1;
242			store_ptr(where, addr + load_ptr(where));
243			break;
244
245		case R_ARM_COPY:	/* none */
246			/*
247			 * There shouldn't be copy relocations in kernel
248			 * objects.
249			 */
250			printf("kldload: unexpected R_COPY relocation\n");
251			return -1;
252			break;
253
254		case R_ARM_JUMP_SLOT:
255			error = lookup(lf, symidx, 1, &addr);
256			if (error == 0) {
257				store_ptr(where, addr);
258				return (0);
259			}
260			return (-1);
261		case R_ARM_RELATIVE:
262			break;
263
264		default:
265			printf("kldload: unexpected relocation type %d\n",
266			       rtype);
267			return -1;
268	}
269	return(0);
270}
271
272int
273elf_reloc(linker_file_t lf, Elf_Addr relocbase, const void *data, int type,
274    elf_lookup_fn lookup)
275{
276
277	return (elf_reloc_internal(lf, relocbase, data, type, 0, lookup));
278}
279
280int
281elf_reloc_local(linker_file_t lf, Elf_Addr relocbase, const void *data,
282    int type, elf_lookup_fn lookup)
283{
284
285	return (elf_reloc_internal(lf, relocbase, data, type, 1, lookup));
286}
287
288int
289elf_cpu_load_file(linker_file_t lf)
290{
291
292	/*
293	 * The pmap code does not do an icache sync upon establishing executable
294	 * mappings in the kernel pmap.  It's an optimization based on the fact
295	 * that kernel memory allocations always have EXECUTABLE protection even
296	 * when the memory isn't going to hold executable code.  The only time
297	 * kernel memory holding instructions does need a sync is after loading
298	 * a kernel module, and that's when this function gets called.
299	 *
300	 * This syncs data and instruction caches after loading a module.  We
301	 * don't worry about the kernel itself (lf->id is 1) as locore.S did
302	 * that on entry.  Even if data cache maintenance was done by IO code,
303	 * the relocation fixup process creates dirty cache entries that we must
304	 * write back before doing icache sync. The instruction cache sync also
305	 * invalidates the branch predictor cache on platforms that have one.
306	 */
307	if (lf->id == 1)
308		return (0);
309#if __ARM_ARCH >= 6
310	dcache_wb_pou((vm_offset_t)lf->address, (vm_size_t)lf->size);
311	icache_inv_all();
312#else
313	cpu_dcache_wb_range((vm_offset_t)lf->address, (vm_size_t)lf->size);
314	cpu_l2cache_wb_range((vm_offset_t)lf->address, (vm_size_t)lf->size);
315	cpu_icache_sync_range((vm_offset_t)lf->address, (vm_size_t)lf->size);
316#endif
317
318#if defined(DDB) || defined(KDTRACE_HOOKS) || defined(STACK)
319	/*
320	 * Inform the stack(9) code of the new module, so it can acquire its
321	 * per-module unwind data.
322	 */
323	unwind_module_loaded(lf);
324#endif
325
326	return (0);
327}
328
329int
330elf_cpu_parse_dynamic(linker_file_t lf __unused, Elf_Dyn *dynamic __unused)
331{
332
333	return (0);
334}
335
336int
337elf_cpu_unload_file(linker_file_t lf)
338{
339
340#if defined(DDB) || defined(KDTRACE_HOOKS) || defined(STACK)
341	/* Inform the stack(9) code that this module is gone. */
342	unwind_module_unloaded(lf);
343#endif
344	return (0);
345}
346