1 /* $NetBSD: crt0-common.c,v 1.28 2024/01/19 19:22:17 christos Exp $ */
2
3 /*
4 * Copyright (c) 1998 Christos Zoulas
5 * Copyright (c) 1995 Christopher G. Demetriou
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 * 2. Redistributions in binary form must reproduce the above copyright
14 * notice, this list of conditions and the following disclaimer in the
15 * documentation and/or other materials provided with the distribution.
16 * 3. All advertising materials mentioning features or use of this software
17 * must display the following acknowledgement:
18 * This product includes software developed for the
19 * NetBSD Project. See http://www.NetBSD.org/ for
20 * information about NetBSD.
21 * 4. The name of the author may not be used to endorse or promote products
22 * derived from this software without specific prior written permission.
23 *
24 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
25 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
26 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
27 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
28 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
29 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
30 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
31 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
32 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
33 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
34 *
35 * <<Id: LICENSE,v 1.2 2000/06/14 15:57:33 cgd Exp>>
36 */
37
38 #include <sys/cdefs.h>
39 __RCSID("$NetBSD: crt0-common.c,v 1.28 2024/01/19 19:22:17 christos Exp $");
40
41 #include <sys/types.h>
42 #include <sys/exec.h>
43 #include <sys/exec_elf.h>
44 #include <sys/syscall.h>
45 #include <machine/profile.h>
46 #include <stdlib.h>
47 #include <unistd.h>
48
49 #include "csu-common.h"
50
51 extern int main(int, char **, char **);
52
53 typedef void (*fptr_t)(void);
54 #ifndef HAVE_INITFINI_ARRAY
55 extern void _init(void);
56 extern void _fini(void);
57 #endif
58
59 /*
60 * Arrange for _DYNAMIC to be weak and undefined (and therefore to show up
61 * as being at address zero, unless something else defines it). That way,
62 * if we happen to be compiling without -static but with without any
63 * shared libs present, things will still work.
64 */
65
66 __weakref_visible int rtld_DYNAMIC __weak_reference(_DYNAMIC);
67
68 #ifdef MCRT0
69 extern void monstartup(u_long, u_long);
70 extern void _mcleanup(void);
71 extern unsigned char __etext, __eprol;
72 #endif /* MCRT0 */
73
74 static char empty_string[] = "";
75
76 char **environ __common;
77 struct ps_strings *__ps_strings __common = 0;
78 char *__progname __common = empty_string;
79
80 __dead __dso_hidden void ___start(void (*)(void), struct ps_strings *);
81
82 #define write(fd, s, n) __syscall(SYS_write, (fd), (s), (n))
83
84 #define _FATAL(str) \
85 do { \
86 write(2, str, sizeof(str)-1); \
87 _exit(1); \
88 } while (0)
89
90 /*
91 * If we are using INIT_ARRAY/FINI_ARRAY and we are linked statically,
92 * we have to process these instead of relying on RTLD to do it for us.
93 *
94 * Since we don't need .init or .fini sections, just code them in C
95 * to make life easier.
96 */
97 extern const fptr_t __preinit_array_start[] __dso_hidden;
98 extern const fptr_t __preinit_array_end[] __dso_hidden __weak;
99 extern const fptr_t __init_array_start[] __dso_hidden;
100 extern const fptr_t __init_array_end[] __dso_hidden __weak;
101 extern const fptr_t __fini_array_start[] __dso_hidden;
102 extern const fptr_t __fini_array_end[] __dso_hidden __weak;
103
104 static inline void
_preinit(void)105 _preinit(void)
106 {
107 for (const fptr_t *f = __preinit_array_start; f < __preinit_array_end; f++) {
108 (*f)();
109 }
110 }
111
112 static inline void
_initarray(void)113 _initarray(void)
114 {
115 for (const fptr_t *f = __init_array_start; f < __init_array_end; f++) {
116 (*f)();
117 }
118 }
119
120 static void
_finiarray(void)121 _finiarray(void)
122 {
123 for (const fptr_t *f = __fini_array_start; f < __fini_array_end; f++) {
124 (*f)();
125 }
126 }
127
128 #if \
129 defined(__aarch64__) || \
130 defined(__powerpc__) || \
131 defined(__sparc__) || \
132 defined(__x86_64__)
133 #define HAS_IPLTA
134 static void fix_iplta(void) __noinline;
135 #elif \
136 defined(__arm__) || \
137 defined(__i386__)
138 #define HAS_IPLT
139 static void fix_iplt(void) __noinline;
140 #endif
141
142
143 #ifdef HAS_IPLTA
144 #include <stdio.h>
145 extern const Elf_Rela __rela_iplt_start[] __dso_hidden __weak;
146 extern const Elf_Rela __rela_iplt_end[] __dso_hidden __weak;
147 #ifdef __sparc__
148 #define IFUNC_RELOCATION R_TYPE(JMP_IREL)
149 #include <machine/elf_support.h>
150 #define write_plt(where, value) sparc_write_branch((void *)where, (void *)value)
151 #else
152 #define IFUNC_RELOCATION R_TYPE(IRELATIVE)
153 #define write_plt(where, value) *where = value
154 #endif
155
156 static void
fix_iplta(void)157 fix_iplta(void)
158 {
159 const Elf_Rela *rela, *relalim;
160 uintptr_t relocbase = 0;
161 Elf_Addr *where, target;
162
163 rela = __rela_iplt_start;
164 relalim = __rela_iplt_end;
165 for (; rela < relalim; ++rela) {
166 if (ELF_R_TYPE(rela->r_info) != IFUNC_RELOCATION)
167 abort();
168 where = (Elf_Addr *)(relocbase + rela->r_offset);
169 target = (Elf_Addr)(relocbase + rela->r_addend);
170 target = ((Elf_Addr(*)(void))target)();
171 write_plt(where, target);
172 }
173 }
174 #endif
175 #ifdef HAS_IPLT
176 extern const Elf_Rel __rel_iplt_start[] __dso_hidden __weak;
177 extern const Elf_Rel __rel_iplt_end[] __dso_hidden __weak;
178 #define IFUNC_RELOCATION R_TYPE(IRELATIVE)
179
180 static void
fix_iplt(void)181 fix_iplt(void)
182 {
183 const Elf_Rel *rel, *rellim;
184 uintptr_t relocbase = 0;
185 Elf_Addr *where, target;
186
187 rel = __rel_iplt_start;
188 rellim = __rel_iplt_end;
189 for (; rel < rellim; ++rel) {
190 if (ELF_R_TYPE(rel->r_info) != IFUNC_RELOCATION)
191 abort();
192 where = (Elf_Addr *)(relocbase + rel->r_offset);
193 target = ((Elf_Addr(*)(void))*where)();
194 *where = target;
195 }
196 }
197 #endif
198
199 #if defined(__x86_64__) || defined(__i386__)
200 # define HAS_RELOCATE_SELF
201 # if defined(__x86_64__)
202 # define RELA
203 # define REL_TAG DT_RELA
204 # define RELSZ_TAG DT_RELASZ
205 # define REL_TYPE Elf_Rela
206 # else
207 # define REL_TAG DT_REL
208 # define RELSZ_TAG DT_RELSZ
209 # define REL_TYPE Elf_Rel
210 # endif
211
212 #include <elf.h>
213
214 static void relocate_self(struct ps_strings *) __noinline;
215
216 static void
relocate_self(struct ps_strings * ps_strings)217 relocate_self(struct ps_strings *ps_strings)
218 {
219 AuxInfo *aux = (AuxInfo *)(ps_strings->ps_argvstr + ps_strings->ps_nargvstr +
220 ps_strings->ps_nenvstr + 2);
221 uintptr_t relocbase = (uintptr_t)~0U;
222 const Elf_Phdr *phdr = NULL;
223 Elf_Half phnum = (Elf_Half)~0;
224
225 for (; aux->a_type != AT_NULL; ++aux) {
226 switch (aux->a_type) {
227 case AT_BASE:
228 if (aux->a_v)
229 return;
230 break;
231 case AT_PHDR:
232 phdr = (void *)aux->a_v;
233 break;
234 case AT_PHNUM:
235 phnum = (Elf_Half)aux->a_v;
236 break;
237 }
238 }
239
240 if (phdr == NULL || phnum == (Elf_Half)~0)
241 return;
242
243 const Elf_Phdr *phlimit = phdr + phnum, *dynphdr = NULL;
244
245 for (; phdr < phlimit; ++phdr) {
246 if (phdr->p_type == PT_DYNAMIC)
247 dynphdr = phdr;
248 if (phdr->p_type == PT_PHDR)
249 relocbase = (uintptr_t)phdr - phdr->p_vaddr;
250 }
251 if (dynphdr == NULL || relocbase == (uintptr_t)~0U)
252 return;
253
254 Elf_Dyn *dynp = (Elf_Dyn *)((uint8_t *)dynphdr->p_vaddr + relocbase);
255
256 const REL_TYPE *relocs = 0, *relocslim;
257 Elf_Addr relocssz = 0;
258
259 for (; dynp->d_tag != DT_NULL; dynp++) {
260 switch (dynp->d_tag) {
261 case REL_TAG:
262 relocs =
263 (const REL_TYPE *)(relocbase + dynp->d_un.d_ptr);
264 break;
265 case RELSZ_TAG:
266 relocssz = dynp->d_un.d_val;
267 break;
268 }
269 }
270 relocslim = (const REL_TYPE *)((const uint8_t *)relocs + relocssz);
271 for (; relocs < relocslim; ++relocs) {
272 Elf_Addr *where;
273
274 where = (Elf_Addr *)(relocbase + relocs->r_offset);
275
276 switch (ELF_R_TYPE(relocs->r_info)) {
277 case R_TYPE(RELATIVE): /* word64 B + A */
278 #ifdef RELA
279 *where = (Elf_Addr)(relocbase + relocs->r_addend);
280 #else
281 *where += (Elf_Addr)relocbase;
282 #endif
283 break;
284 #ifdef IFUNC_RELOCATION
285 case IFUNC_RELOCATION:
286 break;
287 #endif
288 default:
289 abort();
290 }
291 }
292 }
293 #endif
294
295 void
___start(void (* cleanup)(void),struct ps_strings * ps_strings)296 ___start(void (*cleanup)(void), /* from shared loader */
297 struct ps_strings *ps_strings)
298 {
299 #if defined(HAS_RELOCATE_SELF)
300 relocate_self(ps_strings);
301 #endif
302
303 if (ps_strings == NULL)
304 _FATAL("ps_strings missing\n");
305 __ps_strings = ps_strings;
306
307 environ = ps_strings->ps_envstr;
308
309 if (ps_strings->ps_argvstr[0] != NULL) {
310 char *c;
311 __progname = ps_strings->ps_argvstr[0];
312 for (c = ps_strings->ps_argvstr[0]; *c; ++c) {
313 if (*c == '/')
314 __progname = c + 1;
315 }
316 } else {
317 __progname = empty_string;
318 }
319
320 if (cleanup != NULL)
321 atexit(cleanup);
322
323 _libc_init();
324
325 if (&rtld_DYNAMIC == NULL) {
326 #ifdef HAS_IPLTA
327 fix_iplta();
328 #endif
329 #ifdef HAS_IPLT
330 fix_iplt();
331 #endif
332 }
333
334 _preinit();
335
336 #ifdef MCRT0
337 atexit(_mcleanup);
338 monstartup((u_long)&__eprol, (u_long)&__etext);
339 #endif
340
341 atexit(_finiarray);
342 _initarray();
343
344 #ifndef HAVE_INITFINI_ARRAY
345 atexit(_fini);
346 _init();
347 #endif
348
349 exit(main(ps_strings->ps_nargvstr, ps_strings->ps_argvstr, environ));
350 }
351