]>
git.proxmox.com Git - mirror_ubuntu-jammy-kernel.git/blob - arch/s390/kernel/module.c
2 * Kernel module help for s390.
5 * Copyright IBM Corp. 2002, 2003
6 * Author(s): Arnd Bergmann (arndb@de.ibm.com)
7 * Martin Schwidefsky (schwidefsky@de.ibm.com)
9 * based on i386 version
10 * Copyright (C) 2001 Rusty Russell.
12 * This program is free software; you can redistribute it and/or modify
13 * it under the terms of the GNU General Public License as published by
14 * the Free Software Foundation; either version 2 of the License, or
15 * (at your option) any later version.
17 * This program is distributed in the hope that it will be useful,
18 * but WITHOUT ANY WARRANTY; without even the implied warranty of
19 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
20 * GNU General Public License for more details.
22 * You should have received a copy of the GNU General Public License
23 * along with this program; if not, write to the Free Software
24 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
26 #include <linux/module.h>
27 #include <linux/elf.h>
28 #include <linux/vmalloc.h>
30 #include <linux/string.h>
31 #include <linux/kernel.h>
32 #include <linux/moduleloader.h>
33 #include <linux/bug.h>
34 #include <asm/alternative.h>
39 #define DEBUGP(fmt , ...)
42 #define PLT_ENTRY_SIZE 20
44 void *module_alloc(unsigned long size
)
46 if (PAGE_ALIGN(size
) > MODULES_LEN
)
48 return __vmalloc_node_range(size
, 1, MODULES_VADDR
, MODULES_END
,
49 GFP_KERNEL
, PAGE_KERNEL_EXEC
,
51 __builtin_return_address(0));
54 void module_arch_freeing_init(struct module
*mod
)
56 if (is_livepatch_module(mod
) &&
57 mod
->state
== MODULE_STATE_LIVE
)
60 vfree(mod
->arch
.syminfo
);
61 mod
->arch
.syminfo
= NULL
;
64 static void check_rela(Elf_Rela
*rela
, struct module
*me
)
66 struct mod_arch_syminfo
*info
;
68 info
= me
->arch
.syminfo
+ ELF_R_SYM (rela
->r_info
);
69 switch (ELF_R_TYPE (rela
->r_info
)) {
70 case R_390_GOT12
: /* 12 bit GOT offset. */
71 case R_390_GOT16
: /* 16 bit GOT offset. */
72 case R_390_GOT20
: /* 20 bit GOT offset. */
73 case R_390_GOT32
: /* 32 bit GOT offset. */
74 case R_390_GOT64
: /* 64 bit GOT offset. */
75 case R_390_GOTENT
: /* 32 bit PC rel. to GOT entry shifted by 1. */
76 case R_390_GOTPLT12
: /* 12 bit offset to jump slot. */
77 case R_390_GOTPLT16
: /* 16 bit offset to jump slot. */
78 case R_390_GOTPLT20
: /* 20 bit offset to jump slot. */
79 case R_390_GOTPLT32
: /* 32 bit offset to jump slot. */
80 case R_390_GOTPLT64
: /* 64 bit offset to jump slot. */
81 case R_390_GOTPLTENT
: /* 32 bit rel. offset to jump slot >> 1. */
82 if (info
->got_offset
== -1UL) {
83 info
->got_offset
= me
->arch
.got_size
;
84 me
->arch
.got_size
+= sizeof(void*);
87 case R_390_PLT16DBL
: /* 16 bit PC rel. PLT shifted by 1. */
88 case R_390_PLT32DBL
: /* 32 bit PC rel. PLT shifted by 1. */
89 case R_390_PLT32
: /* 32 bit PC relative PLT address. */
90 case R_390_PLT64
: /* 64 bit PC relative PLT address. */
91 case R_390_PLTOFF16
: /* 16 bit offset from GOT to PLT. */
92 case R_390_PLTOFF32
: /* 32 bit offset from GOT to PLT. */
93 case R_390_PLTOFF64
: /* 16 bit offset from GOT to PLT. */
94 if (info
->plt_offset
== -1UL) {
95 info
->plt_offset
= me
->arch
.plt_size
;
96 me
->arch
.plt_size
+= PLT_ENTRY_SIZE
;
103 /* Only needed if we want to support loading of
104 modules linked with -shared. */
110 * Account for GOT and PLT relocations. We can't add sections for
111 * got and plt but we can increase the core module size.
113 int module_frob_arch_sections(Elf_Ehdr
*hdr
, Elf_Shdr
*sechdrs
,
114 char *secstrings
, struct module
*me
)
122 /* Find symbol table and string table. */
124 for (i
= 0; i
< hdr
->e_shnum
; i
++)
125 switch (sechdrs
[i
].sh_type
) {
127 symtab
= sechdrs
+ i
;
131 printk(KERN_ERR
"module %s: no symbol table\n", me
->name
);
135 /* Allocate one syminfo structure per symbol. */
136 me
->arch
.nsyms
= symtab
->sh_size
/ sizeof(Elf_Sym
);
137 me
->arch
.syminfo
= vmalloc(me
->arch
.nsyms
*
138 sizeof(struct mod_arch_syminfo
));
139 if (!me
->arch
.syminfo
)
141 symbols
= (void *) hdr
+ symtab
->sh_offset
;
142 strings
= (void *) hdr
+ sechdrs
[symtab
->sh_link
].sh_offset
;
143 for (i
= 0; i
< me
->arch
.nsyms
; i
++) {
144 if (symbols
[i
].st_shndx
== SHN_UNDEF
&&
145 strcmp(strings
+ symbols
[i
].st_name
,
146 "_GLOBAL_OFFSET_TABLE_") == 0)
147 /* "Define" it as absolute. */
148 symbols
[i
].st_shndx
= SHN_ABS
;
149 me
->arch
.syminfo
[i
].got_offset
= -1UL;
150 me
->arch
.syminfo
[i
].plt_offset
= -1UL;
151 me
->arch
.syminfo
[i
].got_initialized
= 0;
152 me
->arch
.syminfo
[i
].plt_initialized
= 0;
155 /* Search for got/plt relocations. */
156 me
->arch
.got_size
= me
->arch
.plt_size
= 0;
157 for (i
= 0; i
< hdr
->e_shnum
; i
++) {
158 if (sechdrs
[i
].sh_type
!= SHT_RELA
)
160 nrela
= sechdrs
[i
].sh_size
/ sizeof(Elf_Rela
);
161 rela
= (void *) hdr
+ sechdrs
[i
].sh_offset
;
162 for (j
= 0; j
< nrela
; j
++)
163 check_rela(rela
+ j
, me
);
166 /* Increase core size by size of got & plt and set start
167 offsets for got and plt. */
168 me
->core_layout
.size
= ALIGN(me
->core_layout
.size
, 4);
169 me
->arch
.got_offset
= me
->core_layout
.size
;
170 me
->core_layout
.size
+= me
->arch
.got_size
;
171 me
->arch
.plt_offset
= me
->core_layout
.size
;
172 me
->core_layout
.size
+= me
->arch
.plt_size
;
176 static int apply_rela_bits(Elf_Addr loc
, Elf_Addr val
,
177 int sign
, int bits
, int shift
)
182 if (val
& ((1UL << shift
) - 1))
185 val
= (Elf_Addr
)(((long) val
) >> shift
);
186 min
= -(1L << (bits
- 1));
187 max
= (1L << (bits
- 1)) - 1;
188 if ((long) val
< min
|| (long) val
> max
)
192 umax
= ((1UL << (bits
- 1)) << 1) - 1;
193 if ((unsigned long) val
> umax
)
198 *(unsigned char *) loc
= val
;
200 *(unsigned short *) loc
= (val
& 0xfff) |
201 (*(unsigned short *) loc
& 0xf000);
203 *(unsigned short *) loc
= val
;
205 *(unsigned int *) loc
= (val
& 0xfff) << 16 |
206 (val
& 0xff000) >> 4 |
207 (*(unsigned int *) loc
& 0xf00000ff);
209 *(unsigned int *) loc
= val
;
211 *(unsigned long *) loc
= val
;
215 static int apply_rela(Elf_Rela
*rela
, Elf_Addr base
, Elf_Sym
*symtab
,
216 const char *strtab
, struct module
*me
)
218 struct mod_arch_syminfo
*info
;
223 /* This is where to make the change */
224 loc
= base
+ rela
->r_offset
;
225 /* This is the symbol it is referring to. Note that all
226 undefined symbols have been resolved. */
227 r_sym
= ELF_R_SYM(rela
->r_info
);
228 r_type
= ELF_R_TYPE(rela
->r_info
);
229 info
= me
->arch
.syminfo
+ r_sym
;
230 val
= symtab
[r_sym
].st_value
;
233 case R_390_NONE
: /* No relocation. */
236 case R_390_8
: /* Direct 8 bit. */
237 case R_390_12
: /* Direct 12 bit. */
238 case R_390_16
: /* Direct 16 bit. */
239 case R_390_20
: /* Direct 20 bit. */
240 case R_390_32
: /* Direct 32 bit. */
241 case R_390_64
: /* Direct 64 bit. */
242 val
+= rela
->r_addend
;
243 if (r_type
== R_390_8
)
244 rc
= apply_rela_bits(loc
, val
, 0, 8, 0);
245 else if (r_type
== R_390_12
)
246 rc
= apply_rela_bits(loc
, val
, 0, 12, 0);
247 else if (r_type
== R_390_16
)
248 rc
= apply_rela_bits(loc
, val
, 0, 16, 0);
249 else if (r_type
== R_390_20
)
250 rc
= apply_rela_bits(loc
, val
, 1, 20, 0);
251 else if (r_type
== R_390_32
)
252 rc
= apply_rela_bits(loc
, val
, 0, 32, 0);
253 else if (r_type
== R_390_64
)
254 rc
= apply_rela_bits(loc
, val
, 0, 64, 0);
256 case R_390_PC16
: /* PC relative 16 bit. */
257 case R_390_PC16DBL
: /* PC relative 16 bit shifted by 1. */
258 case R_390_PC32DBL
: /* PC relative 32 bit shifted by 1. */
259 case R_390_PC32
: /* PC relative 32 bit. */
260 case R_390_PC64
: /* PC relative 64 bit. */
261 val
+= rela
->r_addend
- loc
;
262 if (r_type
== R_390_PC16
)
263 rc
= apply_rela_bits(loc
, val
, 1, 16, 0);
264 else if (r_type
== R_390_PC16DBL
)
265 rc
= apply_rela_bits(loc
, val
, 1, 16, 1);
266 else if (r_type
== R_390_PC32DBL
)
267 rc
= apply_rela_bits(loc
, val
, 1, 32, 1);
268 else if (r_type
== R_390_PC32
)
269 rc
= apply_rela_bits(loc
, val
, 1, 32, 0);
270 else if (r_type
== R_390_PC64
)
271 rc
= apply_rela_bits(loc
, val
, 1, 64, 0);
273 case R_390_GOT12
: /* 12 bit GOT offset. */
274 case R_390_GOT16
: /* 16 bit GOT offset. */
275 case R_390_GOT20
: /* 20 bit GOT offset. */
276 case R_390_GOT32
: /* 32 bit GOT offset. */
277 case R_390_GOT64
: /* 64 bit GOT offset. */
278 case R_390_GOTENT
: /* 32 bit PC rel. to GOT entry shifted by 1. */
279 case R_390_GOTPLT12
: /* 12 bit offset to jump slot. */
280 case R_390_GOTPLT20
: /* 20 bit offset to jump slot. */
281 case R_390_GOTPLT16
: /* 16 bit offset to jump slot. */
282 case R_390_GOTPLT32
: /* 32 bit offset to jump slot. */
283 case R_390_GOTPLT64
: /* 64 bit offset to jump slot. */
284 case R_390_GOTPLTENT
: /* 32 bit rel. offset to jump slot >> 1. */
285 if (info
->got_initialized
== 0) {
288 gotent
= me
->core_layout
.base
+ me
->arch
.got_offset
+
291 info
->got_initialized
= 1;
293 val
= info
->got_offset
+ rela
->r_addend
;
294 if (r_type
== R_390_GOT12
||
295 r_type
== R_390_GOTPLT12
)
296 rc
= apply_rela_bits(loc
, val
, 0, 12, 0);
297 else if (r_type
== R_390_GOT16
||
298 r_type
== R_390_GOTPLT16
)
299 rc
= apply_rela_bits(loc
, val
, 0, 16, 0);
300 else if (r_type
== R_390_GOT20
||
301 r_type
== R_390_GOTPLT20
)
302 rc
= apply_rela_bits(loc
, val
, 1, 20, 0);
303 else if (r_type
== R_390_GOT32
||
304 r_type
== R_390_GOTPLT32
)
305 rc
= apply_rela_bits(loc
, val
, 0, 32, 0);
306 else if (r_type
== R_390_GOT64
||
307 r_type
== R_390_GOTPLT64
)
308 rc
= apply_rela_bits(loc
, val
, 0, 64, 0);
309 else if (r_type
== R_390_GOTENT
||
310 r_type
== R_390_GOTPLTENT
) {
311 val
+= (Elf_Addr
) me
->core_layout
.base
- loc
;
312 rc
= apply_rela_bits(loc
, val
, 1, 32, 1);
315 case R_390_PLT16DBL
: /* 16 bit PC rel. PLT shifted by 1. */
316 case R_390_PLT32DBL
: /* 32 bit PC rel. PLT shifted by 1. */
317 case R_390_PLT32
: /* 32 bit PC relative PLT address. */
318 case R_390_PLT64
: /* 64 bit PC relative PLT address. */
319 case R_390_PLTOFF16
: /* 16 bit offset from GOT to PLT. */
320 case R_390_PLTOFF32
: /* 32 bit offset from GOT to PLT. */
321 case R_390_PLTOFF64
: /* 16 bit offset from GOT to PLT. */
322 if (info
->plt_initialized
== 0) {
324 ip
= me
->core_layout
.base
+ me
->arch
.plt_offset
+
326 ip
[0] = 0x0d10e310; /* basr 1,0; lg 1,10(1); br 1 */
329 ip
[3] = (unsigned int) (val
>> 32);
330 ip
[4] = (unsigned int) val
;
331 info
->plt_initialized
= 1;
333 if (r_type
== R_390_PLTOFF16
||
334 r_type
== R_390_PLTOFF32
||
335 r_type
== R_390_PLTOFF64
)
336 val
= me
->arch
.plt_offset
- me
->arch
.got_offset
+
337 info
->plt_offset
+ rela
->r_addend
;
339 if (!((r_type
== R_390_PLT16DBL
&&
340 val
- loc
+ 0xffffUL
< 0x1ffffeUL
) ||
341 (r_type
== R_390_PLT32DBL
&&
342 val
- loc
+ 0xffffffffULL
< 0x1fffffffeULL
)))
343 val
= (Elf_Addr
) me
->core_layout
.base
+
344 me
->arch
.plt_offset
+
346 val
+= rela
->r_addend
- loc
;
348 if (r_type
== R_390_PLT16DBL
)
349 rc
= apply_rela_bits(loc
, val
, 1, 16, 1);
350 else if (r_type
== R_390_PLTOFF16
)
351 rc
= apply_rela_bits(loc
, val
, 0, 16, 0);
352 else if (r_type
== R_390_PLT32DBL
)
353 rc
= apply_rela_bits(loc
, val
, 1, 32, 1);
354 else if (r_type
== R_390_PLT32
||
355 r_type
== R_390_PLTOFF32
)
356 rc
= apply_rela_bits(loc
, val
, 0, 32, 0);
357 else if (r_type
== R_390_PLT64
||
358 r_type
== R_390_PLTOFF64
)
359 rc
= apply_rela_bits(loc
, val
, 0, 64, 0);
361 case R_390_GOTOFF16
: /* 16 bit offset to GOT. */
362 case R_390_GOTOFF32
: /* 32 bit offset to GOT. */
363 case R_390_GOTOFF64
: /* 64 bit offset to GOT. */
364 val
= val
+ rela
->r_addend
-
365 ((Elf_Addr
) me
->core_layout
.base
+ me
->arch
.got_offset
);
366 if (r_type
== R_390_GOTOFF16
)
367 rc
= apply_rela_bits(loc
, val
, 0, 16, 0);
368 else if (r_type
== R_390_GOTOFF32
)
369 rc
= apply_rela_bits(loc
, val
, 0, 32, 0);
370 else if (r_type
== R_390_GOTOFF64
)
371 rc
= apply_rela_bits(loc
, val
, 0, 64, 0);
373 case R_390_GOTPC
: /* 32 bit PC relative offset to GOT. */
374 case R_390_GOTPCDBL
: /* 32 bit PC rel. off. to GOT shifted by 1. */
375 val
= (Elf_Addr
) me
->core_layout
.base
+ me
->arch
.got_offset
+
376 rela
->r_addend
- loc
;
377 if (r_type
== R_390_GOTPC
)
378 rc
= apply_rela_bits(loc
, val
, 1, 32, 0);
379 else if (r_type
== R_390_GOTPCDBL
)
380 rc
= apply_rela_bits(loc
, val
, 1, 32, 1);
383 case R_390_GLOB_DAT
: /* Create GOT entry. */
384 case R_390_JMP_SLOT
: /* Create PLT entry. */
385 case R_390_RELATIVE
: /* Adjust by program base. */
386 /* Only needed if we want to support loading of
387 modules linked with -shared. */
390 printk(KERN_ERR
"module %s: unknown relocation: %u\n",
395 printk(KERN_ERR
"module %s: relocation error for symbol %s "
396 "(r_type %i, value 0x%lx)\n",
397 me
->name
, strtab
+ symtab
[r_sym
].st_name
,
398 r_type
, (unsigned long) val
);
404 int apply_relocate_add(Elf_Shdr
*sechdrs
, const char *strtab
,
405 unsigned int symindex
, unsigned int relsec
,
414 DEBUGP("Applying relocate section %u to %u\n",
415 relsec
, sechdrs
[relsec
].sh_info
);
416 base
= sechdrs
[sechdrs
[relsec
].sh_info
].sh_addr
;
417 symtab
= (Elf_Sym
*) sechdrs
[symindex
].sh_addr
;
418 rela
= (Elf_Rela
*) sechdrs
[relsec
].sh_addr
;
419 n
= sechdrs
[relsec
].sh_size
/ sizeof(Elf_Rela
);
421 for (i
= 0; i
< n
; i
++, rela
++) {
422 rc
= apply_rela(rela
, base
, symtab
, strtab
, me
);
429 int module_finalize(const Elf_Ehdr
*hdr
,
430 const Elf_Shdr
*sechdrs
,
436 secstrings
= (void *)hdr
+ sechdrs
[hdr
->e_shstrndx
].sh_offset
;
437 for (s
= sechdrs
; s
< sechdrs
+ hdr
->e_shnum
; s
++) {
438 if (!strcmp(".altinstructions", secstrings
+ s
->sh_name
)) {
439 /* patch .altinstructions */
440 void *aseg
= (void *)s
->sh_addr
;
442 apply_alternatives(aseg
, aseg
+ s
->sh_size
);
446 jump_label_apply_nops(me
);