~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/arch/s390/kernel/module.c

Version: ~ [ linux-5.13-rc7 ] ~ [ linux-5.12.12 ] ~ [ linux-5.11.22 ] ~ [ linux-5.10.45 ] ~ [ linux-5.9.16 ] ~ [ linux-5.8.18 ] ~ [ linux-5.7.19 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.127 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.195 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.237 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.273 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.273 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.18.140 ] ~ [ linux-3.16.85 ] ~ [ linux-3.14.79 ] ~ [ linux-3.12.74 ] ~ [ linux-3.10.108 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

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

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp