projects/linux·blob master · refs

633 lines · 17.5 KiB

1// SPDX-License-Identifier: GPL-2.0+
2/*
3 * Author: Hanlu Li <[email protected]>
4 * Huacai Chen <[email protected]>
5 *
6 * Copyright (C) 2020-2022 Loongson Technology Corporation Limited
7 */
8
9#define pr_fmt(fmt) "kmod: " fmt
10
11#include <linux/moduleloader.h>
12#include <linux/elf.h>
13#include <linux/mm.h>
14#include <linux/numa.h>
15#include <linux/vmalloc.h>
16#include <linux/slab.h>
17#include <linux/fs.h>
18#include <linux/ftrace.h>
19#include <linux/string.h>
20#include <linux/kernel.h>
21#include <asm/alternative.h>
22#include <asm/inst.h>
23#include <asm/unwind.h>
24
25/*
26 * reloc_rela_handler() - Apply a particular relocation to a module
27 * @mod: the module to apply the reloc to
28 * @location: the address at which the reloc is to be applied
29 * @v: the value of the reloc, with addend for RELA-style
30 * @rela_stack: the stack used for store relocation info, LOCAL to THIS module
31 * @rela_stac_top: where the stack operation(pop/push) applies to
32 *
33 * Return: 0 upon success, else -ERRNO
34 */
35typedef int (*reloc_rela_handler)(struct module *mod, u32 *location, Elf_Addr v,
36 long *rela_stack, size_t *rela_stack_top, unsigned int type);
37
38static int rela_stack_push(long stack_value, long *rela_stack, size_t *rela_stack_top)
39{
40 if (*rela_stack_top >= RELA_STACK_DEPTH)
41 return -ENOEXEC;
42
43 rela_stack[(*rela_stack_top)++] = stack_value;
44 pr_debug("%s stack_value = 0x%lx\n", __func__, stack_value);
45
46 return 0;
47}
48
49static int rela_stack_pop(long *stack_value, long *rela_stack, size_t *rela_stack_top)
50{
51 if (*rela_stack_top == 0)
52 return -ENOEXEC;
53
54 *stack_value = rela_stack[--(*rela_stack_top)];
55 pr_debug("%s stack_value = 0x%lx\n", __func__, *stack_value);
56
57 return 0;
58}
59
60static int apply_r_larch_none(struct module *mod, u32 *location, Elf_Addr v,
61 long *rela_stack, size_t *rela_stack_top, unsigned int type)
62{
63 return 0;
64}
65
66static int apply_r_larch_error(struct module *me, u32 *location, Elf_Addr v,
67 long *rela_stack, size_t *rela_stack_top, unsigned int type)
68{
69 pr_err("%s: Unsupport relocation type %u, please add its support.\n", me->name, type);
70 return -EINVAL;
71}
72
73static int apply_r_larch_32(struct module *mod, u32 *location, Elf_Addr v,
74 long *rela_stack, size_t *rela_stack_top, unsigned int type)
75{
76 *location = v;
77 return 0;
78}
79
80#ifdef CONFIG_32BIT
81#define apply_r_larch_64 apply_r_larch_error
82#else
83static int apply_r_larch_64(struct module *mod, u32 *location, Elf_Addr v,
84 long *rela_stack, size_t *rela_stack_top, unsigned int type)
85{
86 *(Elf_Addr *)location = v;
87 return 0;
88}
89#endif
90
91static int apply_r_larch_sop_push_pcrel(struct module *mod, u32 *location, Elf_Addr v,
92 long *rela_stack, size_t *rela_stack_top, unsigned int type)
93{
94 return rela_stack_push(v - (unsigned long)location, rela_stack, rela_stack_top);
95}
96
97static int apply_r_larch_sop_push_absolute(struct module *mod, u32 *location, Elf_Addr v,
98 long *rela_stack, size_t *rela_stack_top, unsigned int type)
99{
100 return rela_stack_push(v, rela_stack, rela_stack_top);
101}
102
103static int apply_r_larch_sop_push_dup(struct module *mod, u32 *location, Elf_Addr v,
104 long *rela_stack, size_t *rela_stack_top, unsigned int type)
105{
106 int err = 0;
107 long opr1;
108
109 err = rela_stack_pop(&opr1, rela_stack, rela_stack_top);
110 if (err)
111 return err;
112 err = rela_stack_push(opr1, rela_stack, rela_stack_top);
113 if (err)
114 return err;
115 err = rela_stack_push(opr1, rela_stack, rela_stack_top);
116 if (err)
117 return err;
118
119 return 0;
120}
121
122static int apply_r_larch_sop_push_plt_pcrel(struct module *mod,
123 Elf_Shdr *sechdrs, u32 *location, Elf_Addr v,
124 long *rela_stack, size_t *rela_stack_top, unsigned int type)
125{
126 ptrdiff_t offset = (void *)v - (void *)location;
127
128 if (offset >= SZ_128M)
129 v = module_emit_plt_entry(mod, sechdrs, v);
130
131 if (offset < -SZ_128M)
132 v = module_emit_plt_entry(mod, sechdrs, v);
133
134 return apply_r_larch_sop_push_pcrel(mod, location, v, rela_stack, rela_stack_top, type);
135}
136
137static int apply_r_larch_sop(struct module *mod, u32 *location, Elf_Addr v,
138 long *rela_stack, size_t *rela_stack_top, unsigned int type)
139{
140 int err = 0;
141 long opr1, opr2, opr3;
142
143 if (type == R_LARCH_SOP_IF_ELSE) {
144 err = rela_stack_pop(&opr3, rela_stack, rela_stack_top);
145 if (err)
146 return err;
147 }
148
149 err = rela_stack_pop(&opr2, rela_stack, rela_stack_top);
150 if (err)
151 return err;
152 err = rela_stack_pop(&opr1, rela_stack, rela_stack_top);
153 if (err)
154 return err;
155
156 switch (type) {
157 case R_LARCH_SOP_AND:
158 err = rela_stack_push(opr1 & opr2, rela_stack, rela_stack_top);
159 break;
160 case R_LARCH_SOP_ADD:
161 err = rela_stack_push(opr1 + opr2, rela_stack, rela_stack_top);
162 break;
163 case R_LARCH_SOP_SUB:
164 err = rela_stack_push(opr1 - opr2, rela_stack, rela_stack_top);
165 break;
166 case R_LARCH_SOP_SL:
167 err = rela_stack_push(opr1 << opr2, rela_stack, rela_stack_top);
168 break;
169 case R_LARCH_SOP_SR:
170 err = rela_stack_push(opr1 >> opr2, rela_stack, rela_stack_top);
171 break;
172 case R_LARCH_SOP_IF_ELSE:
173 err = rela_stack_push(opr1 ? opr2 : opr3, rela_stack, rela_stack_top);
174 break;
175 default:
176 pr_err("%s: Unsupport relocation type %u\n", mod->name, type);
177 return -EINVAL;
178 }
179
180 return err;
181}
182
183static int apply_r_larch_sop_imm_field(struct module *mod, u32 *location, Elf_Addr v,
184 long *rela_stack, size_t *rela_stack_top, unsigned int type)
185{
186 int err = 0;
187 long opr1;
188 union loongarch_instruction *insn = (union loongarch_instruction *)location;
189
190 err = rela_stack_pop(&opr1, rela_stack, rela_stack_top);
191 if (err)
192 return err;
193
194 switch (type) {
195 case R_LARCH_SOP_POP_32_U_10_12:
196 if (!unsigned_imm_check(opr1, 12))
197 goto overflow;
198
199 /* (*(uint32_t *) PC) [21 ... 10] = opr [11 ... 0] */
200 insn->reg2i12_format.immediate = opr1 & 0xfff;
201 return 0;
202 case R_LARCH_SOP_POP_32_S_10_12:
203 if (!signed_imm_check(opr1, 12))
204 goto overflow;
205
206 insn->reg2i12_format.immediate = opr1 & 0xfff;
207 return 0;
208 case R_LARCH_SOP_POP_32_S_10_16:
209 if (!signed_imm_check(opr1, 16))
210 goto overflow;
211
212 insn->reg2i16_format.immediate = opr1 & 0xffff;
213 return 0;
214 case R_LARCH_SOP_POP_32_S_10_16_S2:
215 if (opr1 % 4)
216 goto unaligned;
217
218 if (!signed_imm_check(opr1, 18))
219 goto overflow;
220
221 insn->reg2i16_format.immediate = (opr1 >> 2) & 0xffff;
222 return 0;
223 case R_LARCH_SOP_POP_32_S_5_20:
224 if (!signed_imm_check(opr1, 20))
225 goto overflow;
226
227 insn->reg1i20_format.immediate = (opr1) & 0xfffff;
228 return 0;
229 case R_LARCH_SOP_POP_32_S_0_5_10_16_S2:
230 if (opr1 % 4)
231 goto unaligned;
232
233 if (!signed_imm_check(opr1, 23))
234 goto overflow;
235
236 opr1 >>= 2;
237 insn->reg1i21_format.immediate_l = opr1 & 0xffff;
238 insn->reg1i21_format.immediate_h = (opr1 >> 16) & 0x1f;
239 return 0;
240 case R_LARCH_SOP_POP_32_S_0_10_10_16_S2:
241 if (opr1 % 4)
242 goto unaligned;
243
244 if (!signed_imm_check(opr1, 28))
245 goto overflow;
246
247 opr1 >>= 2;
248 insn->reg0i26_format.immediate_l = opr1 & 0xffff;
249 insn->reg0i26_format.immediate_h = (opr1 >> 16) & 0x3ff;
250 return 0;
251 case R_LARCH_SOP_POP_32_U:
252 if (!unsigned_imm_check(opr1, 32))
253 goto overflow;
254
255 /* (*(uint32_t *) PC) = opr */
256 *location = (u32)opr1;
257 return 0;
258 default:
259 pr_err("%s: Unsupport relocation type %u\n", mod->name, type);
260 return -EINVAL;
261 }
262
263overflow:
264 pr_err("module %s: opr1 = 0x%lx overflow! dangerous %s (%u) relocation\n",
265 mod->name, opr1, __func__, type);
266 return -ENOEXEC;
267
268unaligned:
269 pr_err("module %s: opr1 = 0x%lx unaligned! dangerous %s (%u) relocation\n",
270 mod->name, opr1, __func__, type);
271 return -ENOEXEC;
272}
273
274static int apply_r_larch_add_sub(struct module *mod, u32 *location, Elf_Addr v,
275 long *rela_stack, size_t *rela_stack_top, unsigned int type)
276{
277 switch (type) {
278 case R_LARCH_ADD32:
279 *(s32 *)location += v;
280 return 0;
281 case R_LARCH_SUB32:
282 *(s32 *)location -= v;
283 return 0;
284#ifdef CONFIG_64BIT
285 case R_LARCH_ADD64:
286 *(s64 *)location += v;
287 return 0;
288 case R_LARCH_SUB64:
289 *(s64 *)location -= v;
290#endif
291 return 0;
292 default:
293 pr_err("%s: Unsupport relocation type %u\n", mod->name, type);
294 return -EINVAL;
295 }
296}
297
298static int apply_r_larch_b26(struct module *mod,
299 Elf_Shdr *sechdrs, u32 *location, Elf_Addr v,
300 long *rela_stack, size_t *rela_stack_top, unsigned int type)
301{
302 ptrdiff_t offset = (void *)v - (void *)location;
303 union loongarch_instruction *insn = (union loongarch_instruction *)location;
304
305 if (offset >= SZ_128M)
306 v = module_emit_plt_entry(mod, sechdrs, v);
307
308 if (offset < -SZ_128M)
309 v = module_emit_plt_entry(mod, sechdrs, v);
310
311 offset = (void *)v - (void *)location;
312
313 if (offset & 3) {
314 pr_err("module %s: jump offset = 0x%llx unaligned! dangerous R_LARCH_B26 (%u) relocation\n",
315 mod->name, (long long)offset, type);
316 return -ENOEXEC;
317 }
318
319 if (!signed_imm_check(offset, 28)) {
320 pr_err("module %s: jump offset = 0x%llx overflow! dangerous R_LARCH_B26 (%u) relocation\n",
321 mod->name, (long long)offset, type);
322 return -ENOEXEC;
323 }
324
325 offset >>= 2;
326 insn->reg0i26_format.immediate_l = offset & 0xffff;
327 insn->reg0i26_format.immediate_h = (offset >> 16) & 0x3ff;
328
329 return 0;
330}
331
332static int apply_r_larch_pcadd(struct module *mod, u32 *location, Elf_Addr v,
333 long *rela_stack, size_t *rela_stack_top, unsigned int type)
334{
335 union loongarch_instruction *insn = (union loongarch_instruction *)location;
336 /* Use s32 for a sign-extension deliberately. */
337 s32 offset_hi20 = (void *)((v + 0x800)) - (void *)((Elf_Addr)location);
338
339 switch (type) {
340 case R_LARCH_PCADD_LO12:
341 insn->reg2i12_format.immediate = v & 0xfff;
342 break;
343 case R_LARCH_PCADD_HI20:
344 v = offset_hi20 >> 12;
345 insn->reg1i20_format.immediate = v & 0xfffff;
346 break;
347 default:
348 pr_err("%s: Unsupport relocation type %u\n", mod->name, type);
349 return -EINVAL;
350 }
351
352 return 0;
353}
354
355static int apply_r_larch_pcala(struct module *mod, u32 *location, Elf_Addr v,
356 long *rela_stack, size_t *rela_stack_top, unsigned int type)
357{
358 union loongarch_instruction *insn = (union loongarch_instruction *)location;
359 /* Use s32 for a sign-extension deliberately. */
360 s32 offset_hi20 = (void *)((v + 0x800) & ~0xfff) -
361 (void *)((Elf_Addr)location & ~0xfff);
362#ifdef CONFIG_64BIT
363 Elf_Addr anchor = (((Elf_Addr)location) & ~0xfff) + offset_hi20;
364 ptrdiff_t offset_rem = (void *)v - (void *)anchor;
365#endif
366
367 switch (type) {
368 case R_LARCH_PCALA_LO12:
369 insn->reg2i12_format.immediate = v & 0xfff;
370 break;
371 case R_LARCH_PCALA_HI20:
372 v = offset_hi20 >> 12;
373 insn->reg1i20_format.immediate = v & 0xfffff;
374 break;
375#ifdef CONFIG_64BIT
376 case R_LARCH_PCALA64_LO20:
377 v = offset_rem >> 32;
378 insn->reg1i20_format.immediate = v & 0xfffff;
379 break;
380 case R_LARCH_PCALA64_HI12:
381 v = offset_rem >> 52;
382 insn->reg2i12_format.immediate = v & 0xfff;
383 break;
384#endif
385 default:
386 pr_err("%s: Unsupport relocation type %u\n", mod->name, type);
387 return -EINVAL;
388 }
389
390 return 0;
391}
392
393static int apply_r_larch_got_pc(struct module *mod,
394 Elf_Shdr *sechdrs, u32 *location, Elf_Addr v,
395 long *rela_stack, size_t *rela_stack_top, unsigned int type)
396{
397 reloc_rela_handler got_handler;
398
399 if (type != R_LARCH_GOT_PCADD_LO12) {
400 v = module_emit_got_entry(mod, sechdrs, v);
401 if (!v)
402 return -EINVAL;
403 }
404
405 switch (type) {
406 case R_LARCH_GOT_PC_LO12:
407 type = R_LARCH_PCALA_LO12;
408 got_handler = apply_r_larch_pcala;
409 break;
410 case R_LARCH_GOT_PC_HI20:
411 type = R_LARCH_PCALA_HI20;
412 got_handler = apply_r_larch_pcala;
413 break;
414 case R_LARCH_GOT_PCADD_LO12:
415 type = R_LARCH_PCADD_LO12;
416 got_handler = apply_r_larch_pcadd;
417 break;
418 case R_LARCH_GOT_PCADD_HI20:
419 type = R_LARCH_PCADD_HI20;
420 got_handler = apply_r_larch_pcadd;
421 break;
422 default:
423 pr_err("%s: Unsupport relocation type %u\n", mod->name, type);
424 return -EINVAL;
425 }
426
427 return got_handler(mod, location, v, rela_stack, rela_stack_top, type);
428}
429
430static int apply_r_larch_32_pcrel(struct module *mod, u32 *location, Elf_Addr v,
431 long *rela_stack, size_t *rela_stack_top, unsigned int type)
432{
433 ptrdiff_t offset = (void *)v - (void *)location;
434
435 *(u32 *)location = offset;
436 return 0;
437}
438
439#ifdef CONFIG_32BIT
440#define apply_r_larch_64_pcrel apply_r_larch_error
441#else
442static int apply_r_larch_64_pcrel(struct module *mod, u32 *location, Elf_Addr v,
443 long *rela_stack, size_t *rela_stack_top, unsigned int type)
444{
445 ptrdiff_t offset = (void *)v - (void *)location;
446
447 *(u64 *)location = offset;
448 return 0;
449}
450#endif
451
452/* The handlers for known reloc types */
453static reloc_rela_handler reloc_rela_handlers[] = {
454 [R_LARCH_NONE ... R_LARCH_TLS_DESC_PCADD_LO12] = apply_r_larch_error,
455
456 [R_LARCH_NONE] = apply_r_larch_none,
457 [R_LARCH_32] = apply_r_larch_32,
458 [R_LARCH_64] = apply_r_larch_64,
459 [R_LARCH_MARK_LA] = apply_r_larch_none,
460 [R_LARCH_MARK_PCREL] = apply_r_larch_none,
461 [R_LARCH_SOP_PUSH_PCREL] = apply_r_larch_sop_push_pcrel,
462 [R_LARCH_SOP_PUSH_ABSOLUTE] = apply_r_larch_sop_push_absolute,
463 [R_LARCH_SOP_PUSH_DUP] = apply_r_larch_sop_push_dup,
464 [R_LARCH_SOP_SUB ... R_LARCH_SOP_IF_ELSE] = apply_r_larch_sop,
465 [R_LARCH_SOP_POP_32_S_10_5 ... R_LARCH_SOP_POP_32_U] = apply_r_larch_sop_imm_field,
466 [R_LARCH_ADD32 ... R_LARCH_SUB64] = apply_r_larch_add_sub,
467 [R_LARCH_PCADD_HI20 ... R_LARCH_PCADD_LO12] = apply_r_larch_pcadd,
468 [R_LARCH_PCALA_HI20 ... R_LARCH_PCALA64_HI12] = apply_r_larch_pcala,
469 [R_LARCH_32_PCREL] = apply_r_larch_32_pcrel,
470 [R_LARCH_64_PCREL] = apply_r_larch_64_pcrel,
471};
472
473int apply_relocate_add(Elf_Shdr *sechdrs, const char *strtab,
474 unsigned int symindex, unsigned int relsec,
475 struct module *mod)
476{
477 int err;
478 unsigned int i, idx, type;
479 unsigned int num_relocations;
480 long rela_stack[RELA_STACK_DEPTH];
481 size_t rela_stack_top = 0;
482 reloc_rela_handler handler;
483 void *location;
484 Elf_Addr v;
485 Elf_Sym *sym;
486 Elf_Rela *rel = (void *) sechdrs[relsec].sh_addr;
487
488 pr_debug("%s: Applying relocate section %u to %u\n", __func__, relsec,
489 sechdrs[relsec].sh_info);
490
491 idx = 0;
492 rela_stack_top = 0;
493 num_relocations = sechdrs[relsec].sh_size / sizeof(*rel);
494 for (i = 0; i < num_relocations; i++) {
495 /* This is where to make the change */
496 location = (void *)sechdrs[sechdrs[relsec].sh_info].sh_addr + rel[i].r_offset;
497 /* This is the symbol it is referring to */
498 sym = (Elf_Sym *)sechdrs[symindex].sh_addr + ELF_R_SYM(rel[i].r_info);
499 if (IS_ERR_VALUE(sym->st_value)) {
500 /* Ignore unresolved weak symbol */
501 if (ELF_ST_BIND(sym->st_info) == STB_WEAK)
502 continue;
503 pr_warn("%s: Unknown symbol %s\n", mod->name, strtab + sym->st_name);
504 return -ENOENT;
505 }
506
507 type = ELF_R_TYPE(rel[i].r_info);
508
509 if (type < ARRAY_SIZE(reloc_rela_handlers))
510 handler = reloc_rela_handlers[type];
511 else
512 handler = NULL;
513
514 if (!handler) {
515 pr_err("%s: Unknown relocation type %u\n", mod->name, type);
516 return -EINVAL;
517 }
518
519 pr_debug("type %d st_value %lx r_addend %lx loc %lx\n",
520 (int)ELF_R_TYPE(rel[i].r_info),
521 (unsigned long)sym->st_value, (unsigned long)rel[i].r_addend, (unsigned long)location);
522
523 v = sym->st_value + rel[i].r_addend;
524
525 if (type == R_LARCH_PCADD_LO12 || type == R_LARCH_GOT_PCADD_LO12) {
526 bool found = false;
527 unsigned int j = idx;
528
529 do {
530 u32 hi20_type = ELF_R_TYPE(rel[j].r_info);
531 unsigned long hi20_location =
532 sechdrs[sechdrs[relsec].sh_info].sh_addr + rel[j].r_offset;
533
534 /* Find the corresponding HI20 relocation entry */
535 if ((hi20_location == sym->st_value) && (hi20_type == type - 1)) {
536 s32 hi20, lo12;
537 Elf_Sym *hi20_sym =
538 (Elf_Sym *)sechdrs[symindex].sh_addr + ELF_R_SYM(rel[j].r_info);
539 unsigned long hi20_sym_val = hi20_sym->st_value + rel[j].r_addend;
540
541 /* Calculate LO12 offset */
542 size_t offset = hi20_sym_val - hi20_location;
543 if (hi20_type == R_LARCH_GOT_PCADD_HI20) {
544 offset = module_emit_got_entry(mod, sechdrs, hi20_sym_val);
545 offset = offset - hi20_location;
546 }
547 hi20 = (offset + 0x800) & 0xfffff000;
548 v = lo12 = offset - hi20;
549 found = true;
550 break;
551 }
552
553 j = (j + 1) % num_relocations;
554
555 } while (idx != j);
556
557 if (!found) {
558 pr_err("%s: Can not find HI20 relocation information\n", mod->name);
559 return -EINVAL;
560 }
561
562 idx = j; /* Record the previous j-loop end index */
563 }
564
565 switch (type) {
566 case R_LARCH_B26:
567 err = apply_r_larch_b26(mod, sechdrs, location,
568 v, rela_stack, &rela_stack_top, type);
569 break;
570 case R_LARCH_GOT_PC_HI20...R_LARCH_GOT_PC_LO12:
571 case R_LARCH_GOT_PCADD_HI20...R_LARCH_GOT_PCADD_LO12:
572 err = apply_r_larch_got_pc(mod, sechdrs, location,
573 v, rela_stack, &rela_stack_top, type);
574 break;
575 case R_LARCH_SOP_PUSH_PLT_PCREL:
576 err = apply_r_larch_sop_push_plt_pcrel(mod, sechdrs, location,
577 v, rela_stack, &rela_stack_top, type);
578 break;
579 default:
580 err = handler(mod, location, v, rela_stack, &rela_stack_top, type);
581 }
582 if (err)
583 return err;
584 }
585
586 return 0;
587}
588
589static void module_init_ftrace_plt(const Elf_Ehdr *hdr,
590 const Elf_Shdr *sechdrs, struct module *mod)
591{
592#ifdef CONFIG_DYNAMIC_FTRACE
593 struct plt_entry *ftrace_plts;
594
595 ftrace_plts = (void *)sechdrs->sh_addr;
596
597 ftrace_plts[FTRACE_PLT_IDX] = emit_plt_entry(FTRACE_ADDR);
598
599 if (IS_ENABLED(CONFIG_DYNAMIC_FTRACE_WITH_REGS))
600 ftrace_plts[FTRACE_REGS_PLT_IDX] = emit_plt_entry(FTRACE_REGS_ADDR);
601
602 mod->arch.ftrace_trampolines = ftrace_plts;
603#endif
604}
605
606int module_finalize(const Elf_Ehdr *hdr,
607 const Elf_Shdr *sechdrs, struct module *mod)
608{
609 const char *secstrs = (void *)hdr + sechdrs[hdr->e_shstrndx].sh_offset;
610 const Elf_Shdr *s, *alt = NULL, *orc = NULL, *orc_ip = NULL, *ftrace = NULL;
611
612 for (s = sechdrs; s < sechdrs + hdr->e_shnum; s++) {
613 if (!strcmp(".altinstructions", secstrs + s->sh_name))
614 alt = s;
615 if (!strcmp(".orc_unwind", secstrs + s->sh_name))
616 orc = s;
617 if (!strcmp(".orc_unwind_ip", secstrs + s->sh_name))
618 orc_ip = s;
619 if (!strcmp(".ftrace_trampoline", secstrs + s->sh_name))
620 ftrace = s;
621 }
622
623 if (alt)
624 apply_alternatives((void *)alt->sh_addr, (void *)alt->sh_addr + alt->sh_size);
625
626 if (orc && orc_ip)
627 unwind_module_init(mod, (void *)orc_ip->sh_addr, orc_ip->sh_size, (void *)orc->sh_addr, orc->sh_size);
628
629 if (ftrace)
630 module_init_ftrace_plt(hdr, ftrace, mod);
631
632 return 0;
633}