Linux Audio

Check our new training course

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