1/*-
2 * SPDX-License-Identifier: BSD-2-Clause
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/param.h>
29#include <sys/kernel.h>
30#include <sys/systm.h>
31#include <sys/exec.h>
32#include <sys/imgact.h>
33#include <sys/linker.h>
34#include <sys/reg.h>
35#include <sys/sysent.h>
36#include <sys/imgact_elf.h>
37#include <sys/proc.h>
38#include <sys/syscall.h>
39#include <sys/signalvar.h>
40#include <sys/vnode.h>
41
42#include <vm/vm.h>
43#include <vm/pmap.h>
44#include <vm/vm_param.h>
45
46#include <machine/elf.h>
47#include <machine/md_var.h>
48#include <machine/stack.h>
49#ifdef VFP
50#include <machine/vfp.h>
51#endif
52
53#include "opt_ddb.h"            /* for OPT_DDB */
54#include "opt_global.h"         /* for OPT_KDTRACE_HOOKS */
55#include "opt_stack.h"          /* for OPT_STACK */
56
57static bool elf32_arm_abi_supported(const struct image_params *,
58    const int32_t *, const uint32_t *);
59
60u_long elf_hwcap;
61u_long elf_hwcap2;
62
63struct sysentvec elf32_freebsd_sysvec = {
64	.sv_size	= SYS_MAXSYSCALL,
65	.sv_table	= sysent,
66	.sv_fixup	= __elfN(freebsd_fixup),
67	.sv_sendsig	= sendsig,
68	.sv_sigcode	= sigcode,
69	.sv_szsigcode	= &szsigcode,
70	.sv_name	= "FreeBSD ELF32",
71	.sv_coredump	= __elfN(coredump),
72	.sv_elf_core_osabi = ELFOSABI_FREEBSD,
73	.sv_elf_core_abi_vendor = FREEBSD_ABI_VENDOR,
74	.sv_elf_core_prepare_notes = __elfN(prepare_notes),
75	.sv_minsigstksz	= MINSIGSTKSZ,
76	.sv_minuser	= VM_MIN_ADDRESS,
77	.sv_maxuser	= VM_MAXUSER_ADDRESS,
78	.sv_usrstack	= USRSTACK,
79	.sv_psstrings	= PS_STRINGS,
80	.sv_psstringssz	= sizeof(struct ps_strings),
81	.sv_stackprot	= VM_PROT_ALL,
82	.sv_copyout_auxargs = __elfN(freebsd_copyout_auxargs),
83	.sv_copyout_strings = exec_copyout_strings,
84	.sv_setregs	= exec_setregs,
85	.sv_fixlimit	= NULL,
86	.sv_maxssiz	= NULL,
87	.sv_flags	=
88			  SV_ASLR | SV_SHP | SV_TIMEKEEP | SV_RNG_SEED_VER |
89			  SV_ABI_FREEBSD | SV_ILP32 | SV_SIGSYS,
90	.sv_set_syscall_retval = cpu_set_syscall_retval,
91	.sv_fetch_syscall_args = cpu_fetch_syscall_args,
92	.sv_syscallnames = syscallnames,
93	.sv_shared_page_base = SHAREDPAGE,
94	.sv_shared_page_len = PAGE_SIZE,
95	.sv_schedtail	= NULL,
96	.sv_thread_detach = NULL,
97	.sv_trap	= NULL,
98	.sv_hwcap	= &elf_hwcap,
99	.sv_hwcap2	= &elf_hwcap2,
100	.sv_onexec_old	= exec_onexec_old,
101	.sv_onexit	= exit_onexit,
102	.sv_regset_begin = SET_BEGIN(__elfN(regset)),
103	.sv_regset_end  = SET_LIMIT(__elfN(regset)),
104};
105INIT_SYSENTVEC(elf32_sysvec, &elf32_freebsd_sysvec);
106
107static Elf32_Brandinfo freebsd_brand_info = {
108	.brand		= ELFOSABI_FREEBSD,
109	.machine	= EM_ARM,
110	.compat_3_brand	= "FreeBSD",
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 bool
124elf32_arm_abi_supported(const struct image_params *imgp,
125    const int32_t *osrel __unused, const uint32_t *fctl0 __unused)
126{
127	const Elf_Ehdr *hdr = (const Elf_Ehdr *)imgp->image_header;
128
129	/*
130	 * When configured for EABI, FreeBSD supports EABI vesions 4 and 5.
131	 */
132	if (EF_ARM_EABI_VERSION(hdr->e_flags) < EF_ARM_EABI_FREEBSD_MIN) {
133		if (bootverbose)
134			uprintf("Attempting to execute non EABI binary (rev %d) image %s",
135			    EF_ARM_EABI_VERSION(hdr->e_flags), imgp->args->fname);
136		return (false);
137	}
138	return (true);
139}
140
141void
142elf32_dump_thread(struct thread *td __unused, void *dst __unused,
143    size_t *off __unused)
144{
145}
146
147bool
148elf_is_ifunc_reloc(Elf_Size r_info __unused)
149{
150
151	return (false);
152}
153
154/*
155 * It is possible for the compiler to emit relocations for unaligned data.
156 * We handle this situation with these inlines.
157 */
158#define	RELOC_ALIGNED_P(x) \
159	(((uintptr_t)(x) & (sizeof(void *) - 1)) == 0)
160
161static __inline Elf_Addr
162load_ptr(Elf_Addr *where)
163{
164	Elf_Addr res;
165
166	if (RELOC_ALIGNED_P(where))
167		return *where;
168	memcpy(&res, where, sizeof(res));
169	return (res);
170}
171
172static __inline void
173store_ptr(Elf_Addr *where, Elf_Addr val)
174{
175	if (RELOC_ALIGNED_P(where))
176		*where = val;
177	else
178		memcpy(where, &val, sizeof(val));
179}
180#undef RELOC_ALIGNED_P
181
182/* Process one elf relocation with addend. */
183static int
184elf_reloc_internal(linker_file_t lf, Elf_Addr relocbase, const void *data,
185    int type, int local, elf_lookup_fn lookup)
186{
187	Elf_Addr *where;
188	Elf_Addr addr;
189	Elf_Addr addend;
190	Elf_Word rtype, symidx;
191	const Elf_Rel *rel;
192	const Elf_Rela *rela;
193	int error;
194
195	switch (type) {
196	case ELF_RELOC_REL:
197		rel = (const Elf_Rel *)data;
198		where = (Elf_Addr *) (relocbase + rel->r_offset);
199		addend = load_ptr(where);
200		rtype = ELF_R_TYPE(rel->r_info);
201		symidx = ELF_R_SYM(rel->r_info);
202		break;
203	case ELF_RELOC_RELA:
204		rela = (const Elf_Rela *)data;
205		where = (Elf_Addr *) (relocbase + rela->r_offset);
206		addend = rela->r_addend;
207		rtype = ELF_R_TYPE(rela->r_info);
208		symidx = ELF_R_SYM(rela->r_info);
209		break;
210	default:
211		panic("unknown reloc type %d\n", type);
212	}
213
214	if (local) {
215		if (rtype == R_ARM_RELATIVE) {	/* A + B */
216			addr = elf_relocaddr(lf, relocbase + addend);
217			if (load_ptr(where) != addr)
218				store_ptr(where, addr);
219		}
220		return (0);
221	}
222
223	switch (rtype) {
224		case R_ARM_NONE:	/* none */
225			break;
226
227		case R_ARM_ABS32:
228			error = lookup(lf, symidx, 1, &addr);
229			if (error != 0)
230				return (-1);
231			store_ptr(where, addr + load_ptr(where));
232			break;
233
234		case R_ARM_COPY:	/* none */
235			/*
236			 * There shouldn't be copy relocations in kernel
237			 * objects.
238			 */
239			printf("kldload: unexpected R_COPY relocation, "
240			    "symbol index %d\n", symidx);
241			return (-1);
242			break;
243
244		case R_ARM_JUMP_SLOT:
245			error = lookup(lf, symidx, 1, &addr);
246			if (error == 0) {
247				store_ptr(where, addr);
248				return (0);
249			}
250			return (-1);
251		case R_ARM_RELATIVE:
252			break;
253
254		default:
255			printf("kldload: unexpected relocation type %d, "
256			    "symbol index %d\n", rtype, symidx);
257			return (-1);
258	}
259	return(0);
260}
261
262int
263elf_reloc(linker_file_t lf, Elf_Addr relocbase, const void *data, int type,
264    elf_lookup_fn lookup)
265{
266
267	return (elf_reloc_internal(lf, relocbase, data, type, 0, lookup));
268}
269
270int
271elf_reloc_local(linker_file_t lf, Elf_Addr relocbase, const void *data,
272    int type, elf_lookup_fn lookup)
273{
274
275	return (elf_reloc_internal(lf, relocbase, data, type, 1, lookup));
276}
277
278int
279elf_cpu_load_file(linker_file_t lf)
280{
281
282	/*
283	 * The pmap code does not do an icache sync upon establishing executable
284	 * mappings in the kernel pmap.  It's an optimization based on the fact
285	 * that kernel memory allocations always have EXECUTABLE protection even
286	 * when the memory isn't going to hold executable code.  The only time
287	 * kernel memory holding instructions does need a sync is after loading
288	 * a kernel module, and that's when this function gets called.
289	 *
290	 * This syncs data and instruction caches after loading a module.  We
291	 * don't worry about the kernel itself (lf->id is 1) as locore.S did
292	 * that on entry.  Even if data cache maintenance was done by IO code,
293	 * the relocation fixup process creates dirty cache entries that we must
294	 * write back before doing icache sync. The instruction cache sync also
295	 * invalidates the branch predictor cache on platforms that have one.
296	 */
297	if (lf->id == 1)
298		return (0);
299	dcache_wb_pou((vm_offset_t)lf->address, (vm_size_t)lf->size);
300	icache_inv_all();
301
302#if defined(DDB) || defined(KDTRACE_HOOKS) || defined(STACK)
303	/*
304	 * Inform the stack(9) code of the new module, so it can acquire its
305	 * per-module unwind data.
306	 */
307	unwind_module_loaded(lf);
308#endif
309
310	return (0);
311}
312
313int
314elf_cpu_parse_dynamic(caddr_t loadbase __unused, Elf_Dyn *dynamic __unused)
315{
316
317	return (0);
318}
319
320int
321elf_cpu_unload_file(linker_file_t lf)
322{
323
324#if defined(DDB) || defined(KDTRACE_HOOKS) || defined(STACK)
325	/* Inform the stack(9) code that this module is gone. */
326	unwind_module_unloaded(lf);
327#endif
328	return (0);
329}
330