1 /*
2 * Kernel module help for s390.
3 *
4 * S390 version
5 * Copyright IBM Corp. 2002, 2003
6 * Author(s): Arnd Bergmann (arndb@de.ibm.com)
7 * Martin Schwidefsky (schwidefsky@de.ibm.com)
8 *
9 * based on i386 version
10 * Copyright (C) 2001 Rusty Russell.
11 *
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.
16 *
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.
21 *
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
25 */
26 #include <linux/module.h>
27 #include <linux/elf.h>
28 #include <linux/vmalloc.h>
29 #include <linux/fs.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>
35 #include <asm/nospec-branch.h>
36 #include <asm/facility.h>
37
38 #if 0
39 #define DEBUGP printk
40 #else
41 #define DEBUGP(fmt , ...)
42 #endif
43
44 #define PLT_ENTRY_SIZE 20
45
module_alloc(unsigned long size)46 void *module_alloc(unsigned long size)
47 {
48 if (PAGE_ALIGN(size) > MODULES_LEN)
49 return NULL;
50 return __vmalloc_node_range(size, 1, MODULES_VADDR, MODULES_END,
51 GFP_KERNEL, PAGE_KERNEL, 0, NUMA_NO_NODE,
52 __builtin_return_address(0));
53 }
54
module_arch_freeing_init(struct module * mod)55 void module_arch_freeing_init(struct module *mod)
56 {
57 if (is_livepatch_module(mod) &&
58 mod->state == MODULE_STATE_LIVE)
59 return;
60
61 vfree(mod->arch.syminfo);
62 mod->arch.syminfo = NULL;
63 }
64
check_rela(Elf_Rela * rela,struct module * me)65 static void check_rela(Elf_Rela *rela, struct module *me)
66 {
67 struct mod_arch_syminfo *info;
68
69 info = me->arch.syminfo + ELF_R_SYM (rela->r_info);
70 switch (ELF_R_TYPE (rela->r_info)) {
71 case R_390_GOT12: /* 12 bit GOT offset. */
72 case R_390_GOT16: /* 16 bit GOT offset. */
73 case R_390_GOT20: /* 20 bit GOT offset. */
74 case R_390_GOT32: /* 32 bit GOT offset. */
75 case R_390_GOT64: /* 64 bit GOT offset. */
76 case R_390_GOTENT: /* 32 bit PC rel. to GOT entry shifted by 1. */
77 case R_390_GOTPLT12: /* 12 bit offset to jump slot. */
78 case R_390_GOTPLT16: /* 16 bit offset to jump slot. */
79 case R_390_GOTPLT20: /* 20 bit offset to jump slot. */
80 case R_390_GOTPLT32: /* 32 bit offset to jump slot. */
81 case R_390_GOTPLT64: /* 64 bit offset to jump slot. */
82 case R_390_GOTPLTENT: /* 32 bit rel. offset to jump slot >> 1. */
83 if (info->got_offset == -1UL) {
84 info->got_offset = me->arch.got_size;
85 me->arch.got_size += sizeof(void*);
86 }
87 break;
88 case R_390_PLT16DBL: /* 16 bit PC rel. PLT shifted by 1. */
89 case R_390_PLT32DBL: /* 32 bit PC rel. PLT shifted by 1. */
90 case R_390_PLT32: /* 32 bit PC relative PLT address. */
91 case R_390_PLT64: /* 64 bit PC relative PLT address. */
92 case R_390_PLTOFF16: /* 16 bit offset from GOT to PLT. */
93 case R_390_PLTOFF32: /* 32 bit offset from GOT to PLT. */
94 case R_390_PLTOFF64: /* 16 bit offset from GOT to PLT. */
95 if (info->plt_offset == -1UL) {
96 info->plt_offset = me->arch.plt_size;
97 me->arch.plt_size += PLT_ENTRY_SIZE;
98 }
99 break;
100 case R_390_COPY:
101 case R_390_GLOB_DAT:
102 case R_390_JMP_SLOT:
103 case R_390_RELATIVE:
104 /* Only needed if we want to support loading of
105 modules linked with -shared. */
106 break;
107 }
108 }
109
110 /*
111 * Account for GOT and PLT relocations. We can't add sections for
112 * got and plt but we can increase the core module size.
113 */
module_frob_arch_sections(Elf_Ehdr * hdr,Elf_Shdr * sechdrs,char * secstrings,struct module * me)114 int module_frob_arch_sections(Elf_Ehdr *hdr, Elf_Shdr *sechdrs,
115 char *secstrings, struct module *me)
116 {
117 Elf_Shdr *symtab;
118 Elf_Sym *symbols;
119 Elf_Rela *rela;
120 char *strings;
121 int nrela, i, j;
122
123 /* Find symbol table and string table. */
124 symtab = NULL;
125 for (i = 0; i < hdr->e_shnum; i++)
126 switch (sechdrs[i].sh_type) {
127 case SHT_SYMTAB:
128 symtab = sechdrs + i;
129 break;
130 }
131 if (!symtab) {
132 printk(KERN_ERR "module %s: no symbol table\n", me->name);
133 return -ENOEXEC;
134 }
135
136 /* Allocate one syminfo structure per symbol. */
137 me->arch.nsyms = symtab->sh_size / sizeof(Elf_Sym);
138 me->arch.syminfo = vmalloc(me->arch.nsyms *
139 sizeof(struct mod_arch_syminfo));
140 if (!me->arch.syminfo)
141 return -ENOMEM;
142 symbols = (void *) hdr + symtab->sh_offset;
143 strings = (void *) hdr + sechdrs[symtab->sh_link].sh_offset;
144 for (i = 0; i < me->arch.nsyms; i++) {
145 if (symbols[i].st_shndx == SHN_UNDEF &&
146 strcmp(strings + symbols[i].st_name,
147 "_GLOBAL_OFFSET_TABLE_") == 0)
148 /* "Define" it as absolute. */
149 symbols[i].st_shndx = SHN_ABS;
150 me->arch.syminfo[i].got_offset = -1UL;
151 me->arch.syminfo[i].plt_offset = -1UL;
152 me->arch.syminfo[i].got_initialized = 0;
153 me->arch.syminfo[i].plt_initialized = 0;
154 }
155
156 /* Search for got/plt relocations. */
157 me->arch.got_size = me->arch.plt_size = 0;
158 for (i = 0; i < hdr->e_shnum; i++) {
159 if (sechdrs[i].sh_type != SHT_RELA)
160 continue;
161 nrela = sechdrs[i].sh_size / sizeof(Elf_Rela);
162 rela = (void *) hdr + sechdrs[i].sh_offset;
163 for (j = 0; j < nrela; j++)
164 check_rela(rela + j, me);
165 }
166
167 /* Increase core size by size of got & plt and set start
168 offsets for got and plt. */
169 me->core_layout.size = ALIGN(me->core_layout.size, 4);
170 me->arch.got_offset = me->core_layout.size;
171 me->core_layout.size += me->arch.got_size;
172 me->arch.plt_offset = me->core_layout.size;
173 if (me->arch.plt_size) {
174 if (IS_ENABLED(CONFIG_EXPOLINE) && !nospec_disable)
175 me->arch.plt_size += PLT_ENTRY_SIZE;
176 me->core_layout.size += me->arch.plt_size;
177 }
178 return 0;
179 }
180
apply_rela_bits(Elf_Addr loc,Elf_Addr val,int sign,int bits,int shift)181 static int apply_rela_bits(Elf_Addr loc, Elf_Addr val,
182 int sign, int bits, int shift)
183 {
184 unsigned long umax;
185 long min, max;
186
187 if (val & ((1UL << shift) - 1))
188 return -ENOEXEC;
189 if (sign) {
190 val = (Elf_Addr)(((long) val) >> shift);
191 min = -(1L << (bits - 1));
192 max = (1L << (bits - 1)) - 1;
193 if ((long) val < min || (long) val > max)
194 return -ENOEXEC;
195 } else {
196 val >>= shift;
197 umax = ((1UL << (bits - 1)) << 1) - 1;
198 if ((unsigned long) val > umax)
199 return -ENOEXEC;
200 }
201
202 if (bits == 8)
203 *(unsigned char *) loc = val;
204 else if (bits == 12)
205 *(unsigned short *) loc = (val & 0xfff) |
206 (*(unsigned short *) loc & 0xf000);
207 else if (bits == 16)
208 *(unsigned short *) loc = val;
209 else if (bits == 20)
210 *(unsigned int *) loc = (val & 0xfff) << 16 |
211 (val & 0xff000) >> 4 |
212 (*(unsigned int *) loc & 0xf00000ff);
213 else if (bits == 32)
214 *(unsigned int *) loc = val;
215 else if (bits == 64)
216 *(unsigned long *) loc = val;
217 return 0;
218 }
219
apply_rela(Elf_Rela * rela,Elf_Addr base,Elf_Sym * symtab,const char * strtab,struct module * me)220 static int apply_rela(Elf_Rela *rela, Elf_Addr base, Elf_Sym *symtab,
221 const char *strtab, struct module *me)
222 {
223 struct mod_arch_syminfo *info;
224 Elf_Addr loc, val;
225 int r_type, r_sym;
226 int rc = -ENOEXEC;
227
228 /* This is where to make the change */
229 loc = base + rela->r_offset;
230 /* This is the symbol it is referring to. Note that all
231 undefined symbols have been resolved. */
232 r_sym = ELF_R_SYM(rela->r_info);
233 r_type = ELF_R_TYPE(rela->r_info);
234 info = me->arch.syminfo + r_sym;
235 val = symtab[r_sym].st_value;
236
237 switch (r_type) {
238 case R_390_NONE: /* No relocation. */
239 rc = 0;
240 break;
241 case R_390_8: /* Direct 8 bit. */
242 case R_390_12: /* Direct 12 bit. */
243 case R_390_16: /* Direct 16 bit. */
244 case R_390_20: /* Direct 20 bit. */
245 case R_390_32: /* Direct 32 bit. */
246 case R_390_64: /* Direct 64 bit. */
247 val += rela->r_addend;
248 if (r_type == R_390_8)
249 rc = apply_rela_bits(loc, val, 0, 8, 0);
250 else if (r_type == R_390_12)
251 rc = apply_rela_bits(loc, val, 0, 12, 0);
252 else if (r_type == R_390_16)
253 rc = apply_rela_bits(loc, val, 0, 16, 0);
254 else if (r_type == R_390_20)
255 rc = apply_rela_bits(loc, val, 1, 20, 0);
256 else if (r_type == R_390_32)
257 rc = apply_rela_bits(loc, val, 0, 32, 0);
258 else if (r_type == R_390_64)
259 rc = apply_rela_bits(loc, val, 0, 64, 0);
260 break;
261 case R_390_PC16: /* PC relative 16 bit. */
262 case R_390_PC16DBL: /* PC relative 16 bit shifted by 1. */
263 case R_390_PC32DBL: /* PC relative 32 bit shifted by 1. */
264 case R_390_PC32: /* PC relative 32 bit. */
265 case R_390_PC64: /* PC relative 64 bit. */
266 val += rela->r_addend - loc;
267 if (r_type == R_390_PC16)
268 rc = apply_rela_bits(loc, val, 1, 16, 0);
269 else if (r_type == R_390_PC16DBL)
270 rc = apply_rela_bits(loc, val, 1, 16, 1);
271 else if (r_type == R_390_PC32DBL)
272 rc = apply_rela_bits(loc, val, 1, 32, 1);
273 else if (r_type == R_390_PC32)
274 rc = apply_rela_bits(loc, val, 1, 32, 0);
275 else if (r_type == R_390_PC64)
276 rc = apply_rela_bits(loc, val, 1, 64, 0);
277 break;
278 case R_390_GOT12: /* 12 bit GOT offset. */
279 case R_390_GOT16: /* 16 bit GOT offset. */
280 case R_390_GOT20: /* 20 bit GOT offset. */
281 case R_390_GOT32: /* 32 bit GOT offset. */
282 case R_390_GOT64: /* 64 bit GOT offset. */
283 case R_390_GOTENT: /* 32 bit PC rel. to GOT entry shifted by 1. */
284 case R_390_GOTPLT12: /* 12 bit offset to jump slot. */
285 case R_390_GOTPLT20: /* 20 bit offset to jump slot. */
286 case R_390_GOTPLT16: /* 16 bit offset to jump slot. */
287 case R_390_GOTPLT32: /* 32 bit offset to jump slot. */
288 case R_390_GOTPLT64: /* 64 bit offset to jump slot. */
289 case R_390_GOTPLTENT: /* 32 bit rel. offset to jump slot >> 1. */
290 if (info->got_initialized == 0) {
291 Elf_Addr *gotent;
292
293 gotent = me->core_layout.base + me->arch.got_offset +
294 info->got_offset;
295 *gotent = val;
296 info->got_initialized = 1;
297 }
298 val = info->got_offset + rela->r_addend;
299 if (r_type == R_390_GOT12 ||
300 r_type == R_390_GOTPLT12)
301 rc = apply_rela_bits(loc, val, 0, 12, 0);
302 else if (r_type == R_390_GOT16 ||
303 r_type == R_390_GOTPLT16)
304 rc = apply_rela_bits(loc, val, 0, 16, 0);
305 else if (r_type == R_390_GOT20 ||
306 r_type == R_390_GOTPLT20)
307 rc = apply_rela_bits(loc, val, 1, 20, 0);
308 else if (r_type == R_390_GOT32 ||
309 r_type == R_390_GOTPLT32)
310 rc = apply_rela_bits(loc, val, 0, 32, 0);
311 else if (r_type == R_390_GOT64 ||
312 r_type == R_390_GOTPLT64)
313 rc = apply_rela_bits(loc, val, 0, 64, 0);
314 else if (r_type == R_390_GOTENT ||
315 r_type == R_390_GOTPLTENT) {
316 val += (Elf_Addr) me->core_layout.base - loc;
317 rc = apply_rela_bits(loc, val, 1, 32, 1);
318 }
319 break;
320 case R_390_PLT16DBL: /* 16 bit PC rel. PLT shifted by 1. */
321 case R_390_PLT32DBL: /* 32 bit PC rel. PLT shifted by 1. */
322 case R_390_PLT32: /* 32 bit PC relative PLT address. */
323 case R_390_PLT64: /* 64 bit PC relative PLT address. */
324 case R_390_PLTOFF16: /* 16 bit offset from GOT to PLT. */
325 case R_390_PLTOFF32: /* 32 bit offset from GOT to PLT. */
326 case R_390_PLTOFF64: /* 16 bit offset from GOT to PLT. */
327 if (info->plt_initialized == 0) {
328 unsigned int *ip;
329 ip = me->core_layout.base + me->arch.plt_offset +
330 info->plt_offset;
331 ip[0] = 0x0d10e310; /* basr 1,0 */
332 ip[1] = 0x100a0004; /* lg 1,10(1) */
333 if (IS_ENABLED(CONFIG_EXPOLINE) && !nospec_disable) {
334 unsigned int *ij;
335 ij = me->core_layout.base +
336 me->arch.plt_offset +
337 me->arch.plt_size - PLT_ENTRY_SIZE;
338 ip[2] = 0xa7f40000 + /* j __jump_r1 */
339 (unsigned int)(u16)
340 (((unsigned long) ij - 8 -
341 (unsigned long) ip) / 2);
342 } else {
343 ip[2] = 0x07f10000; /* br %r1 */
344 }
345 ip[3] = (unsigned int) (val >> 32);
346 ip[4] = (unsigned int) val;
347 info->plt_initialized = 1;
348 }
349 if (r_type == R_390_PLTOFF16 ||
350 r_type == R_390_PLTOFF32 ||
351 r_type == R_390_PLTOFF64)
352 val = me->arch.plt_offset - me->arch.got_offset +
353 info->plt_offset + rela->r_addend;
354 else {
355 if (!((r_type == R_390_PLT16DBL &&
356 val - loc + 0xffffUL < 0x1ffffeUL) ||
357 (r_type == R_390_PLT32DBL &&
358 val - loc + 0xffffffffULL < 0x1fffffffeULL)))
359 val = (Elf_Addr) me->core_layout.base +
360 me->arch.plt_offset +
361 info->plt_offset;
362 val += rela->r_addend - loc;
363 }
364 if (r_type == R_390_PLT16DBL)
365 rc = apply_rela_bits(loc, val, 1, 16, 1);
366 else if (r_type == R_390_PLTOFF16)
367 rc = apply_rela_bits(loc, val, 0, 16, 0);
368 else if (r_type == R_390_PLT32DBL)
369 rc = apply_rela_bits(loc, val, 1, 32, 1);
370 else if (r_type == R_390_PLT32 ||
371 r_type == R_390_PLTOFF32)
372 rc = apply_rela_bits(loc, val, 0, 32, 0);
373 else if (r_type == R_390_PLT64 ||
374 r_type == R_390_PLTOFF64)
375 rc = apply_rela_bits(loc, val, 0, 64, 0);
376 break;
377 case R_390_GOTOFF16: /* 16 bit offset to GOT. */
378 case R_390_GOTOFF32: /* 32 bit offset to GOT. */
379 case R_390_GOTOFF64: /* 64 bit offset to GOT. */
380 val = val + rela->r_addend -
381 ((Elf_Addr) me->core_layout.base + me->arch.got_offset);
382 if (r_type == R_390_GOTOFF16)
383 rc = apply_rela_bits(loc, val, 0, 16, 0);
384 else if (r_type == R_390_GOTOFF32)
385 rc = apply_rela_bits(loc, val, 0, 32, 0);
386 else if (r_type == R_390_GOTOFF64)
387 rc = apply_rela_bits(loc, val, 0, 64, 0);
388 break;
389 case R_390_GOTPC: /* 32 bit PC relative offset to GOT. */
390 case R_390_GOTPCDBL: /* 32 bit PC rel. off. to GOT shifted by 1. */
391 val = (Elf_Addr) me->core_layout.base + me->arch.got_offset +
392 rela->r_addend - loc;
393 if (r_type == R_390_GOTPC)
394 rc = apply_rela_bits(loc, val, 1, 32, 0);
395 else if (r_type == R_390_GOTPCDBL)
396 rc = apply_rela_bits(loc, val, 1, 32, 1);
397 break;
398 case R_390_COPY:
399 case R_390_GLOB_DAT: /* Create GOT entry. */
400 case R_390_JMP_SLOT: /* Create PLT entry. */
401 case R_390_RELATIVE: /* Adjust by program base. */
402 /* Only needed if we want to support loading of
403 modules linked with -shared. */
404 return -ENOEXEC;
405 default:
406 printk(KERN_ERR "module %s: unknown relocation: %u\n",
407 me->name, r_type);
408 return -ENOEXEC;
409 }
410 if (rc) {
411 printk(KERN_ERR "module %s: relocation error for symbol %s "
412 "(r_type %i, value 0x%lx)\n",
413 me->name, strtab + symtab[r_sym].st_name,
414 r_type, (unsigned long) val);
415 return rc;
416 }
417 return 0;
418 }
419
apply_relocate_add(Elf_Shdr * sechdrs,const char * strtab,unsigned int symindex,unsigned int relsec,struct module * me)420 int apply_relocate_add(Elf_Shdr *sechdrs, const char *strtab,
421 unsigned int symindex, unsigned int relsec,
422 struct module *me)
423 {
424 Elf_Addr base;
425 Elf_Sym *symtab;
426 Elf_Rela *rela;
427 unsigned long i, n;
428 int rc;
429
430 DEBUGP("Applying relocate section %u to %u\n",
431 relsec, sechdrs[relsec].sh_info);
432 base = sechdrs[sechdrs[relsec].sh_info].sh_addr;
433 symtab = (Elf_Sym *) sechdrs[symindex].sh_addr;
434 rela = (Elf_Rela *) sechdrs[relsec].sh_addr;
435 n = sechdrs[relsec].sh_size / sizeof(Elf_Rela);
436
437 for (i = 0; i < n; i++, rela++) {
438 rc = apply_rela(rela, base, symtab, strtab, me);
439 if (rc)
440 return rc;
441 }
442 return 0;
443 }
444
module_finalize(const Elf_Ehdr * hdr,const Elf_Shdr * sechdrs,struct module * me)445 int module_finalize(const Elf_Ehdr *hdr,
446 const Elf_Shdr *sechdrs,
447 struct module *me)
448 {
449 const Elf_Shdr *s;
450 char *secstrings, *secname;
451 void *aseg;
452
453 if (IS_ENABLED(CONFIG_EXPOLINE) &&
454 !nospec_disable && me->arch.plt_size) {
455 unsigned int *ij;
456
457 ij = me->core_layout.base + me->arch.plt_offset +
458 me->arch.plt_size - PLT_ENTRY_SIZE;
459 if (test_facility(35)) {
460 ij[0] = 0xc6000000; /* exrl %r0,.+10 */
461 ij[1] = 0x0005a7f4; /* j . */
462 ij[2] = 0x000007f1; /* br %r1 */
463 } else {
464 ij[0] = 0x44000000 | (unsigned int)
465 offsetof(struct lowcore, br_r1_trampoline);
466 ij[1] = 0xa7f40000; /* j . */
467 }
468 }
469
470 secstrings = (void *)hdr + sechdrs[hdr->e_shstrndx].sh_offset;
471 for (s = sechdrs; s < sechdrs + hdr->e_shnum; s++) {
472 aseg = (void *) s->sh_addr;
473 secname = secstrings + s->sh_name;
474
475 if (!strcmp(".altinstructions", secname))
476 /* patch .altinstructions */
477 apply_alternatives(aseg, aseg + s->sh_size);
478
479 if (IS_ENABLED(CONFIG_EXPOLINE) &&
480 (!strncmp(".s390_indirect", secname, 14)))
481 nospec_revert(aseg, aseg + s->sh_size);
482
483 if (IS_ENABLED(CONFIG_EXPOLINE) &&
484 (!strncmp(".s390_return", secname, 12)))
485 nospec_revert(aseg, aseg + s->sh_size);
486 }
487
488 jump_label_apply_nops(me);
489 return 0;
490 }
491