Linux Kernel  3.7.1
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
module.c
Go to the documentation of this file.
1 /*
2  * IA-64-specific support for kernel module loader.
3  *
4  * Copyright (C) 2003 Hewlett-Packard Co
5  * David Mosberger-Tang <[email protected]>
6  *
7  * Loosely based on patch by Rusty Russell.
8  */
9 
10 /* relocs tested so far:
11 
12  DIR64LSB
13  FPTR64LSB
14  GPREL22
15  LDXMOV
16  LDXMOV
17  LTOFF22
18  LTOFF22X
19  LTOFF22X
20  LTOFF_FPTR22
21  PCREL21B (for br.call only; br.cond is not supported out of modules!)
22  PCREL60B (for brl.cond only; brl.call is not supported for modules!)
23  PCREL64LSB
24  SECREL32LSB
25  SEGREL64LSB
26  */
27 
28 
29 #include <linux/kernel.h>
30 #include <linux/sched.h>
31 #include <linux/elf.h>
32 #include <linux/moduleloader.h>
33 #include <linux/string.h>
34 #include <linux/vmalloc.h>
35 
36 #include <asm/patch.h>
37 #include <asm/unaligned.h>
38 
39 #define ARCH_MODULE_DEBUG 0
40 
41 #if ARCH_MODULE_DEBUG
42 # define DEBUGP printk
43 # define inline
44 #else
45 # define DEBUGP(fmt , a...)
46 #endif
47 
48 #ifdef CONFIG_ITANIUM
49 # define USE_BRL 0
50 #else
51 # define USE_BRL 1
52 #endif
53 
54 #define MAX_LTOFF ((uint64_t) (1 << 22)) /* max. allowable linkage-table offset */
55 
56 /* Define some relocation helper macros/types: */
57 
58 #define FORMAT_SHIFT 0
59 #define FORMAT_BITS 3
60 #define FORMAT_MASK ((1 << FORMAT_BITS) - 1)
61 #define VALUE_SHIFT 3
62 #define VALUE_BITS 5
63 #define VALUE_MASK ((1 << VALUE_BITS) - 1)
64 
65 enum reloc_target_format {
66  /* direct encoded formats: */
67  RF_NONE = 0,
68  RF_INSN14 = 1,
69  RF_INSN22 = 2,
70  RF_INSN64 = 3,
71  RF_32MSB = 4,
72  RF_32LSB = 5,
73  RF_64MSB = 6,
74  RF_64LSB = 7,
75 
76  /* formats that cannot be directly decoded: */
77  RF_INSN60,
78  RF_INSN21B, /* imm21 form 1 */
79  RF_INSN21M, /* imm21 form 2 */
80  RF_INSN21F /* imm21 form 3 */
81 };
82 
83 enum reloc_value_formula {
84  RV_DIRECT = 4, /* S + A */
85  RV_GPREL = 5, /* @gprel(S + A) */
86  RV_LTREL = 6, /* @ltoff(S + A) */
87  RV_PLTREL = 7, /* @pltoff(S + A) */
88  RV_FPTR = 8, /* @fptr(S + A) */
89  RV_PCREL = 9, /* S + A - P */
90  RV_LTREL_FPTR = 10, /* @ltoff(@fptr(S + A)) */
91  RV_SEGREL = 11, /* @segrel(S + A) */
92  RV_SECREL = 12, /* @secrel(S + A) */
93  RV_BDREL = 13, /* BD + A */
94  RV_LTV = 14, /* S + A (like RV_DIRECT, except frozen at static link-time) */
95  RV_PCREL2 = 15, /* S + A - P */
96  RV_SPECIAL = 16, /* various (see below) */
97  RV_RSVD17 = 17,
98  RV_TPREL = 18, /* @tprel(S + A) */
99  RV_LTREL_TPREL = 19, /* @ltoff(@tprel(S + A)) */
100  RV_DTPMOD = 20, /* @dtpmod(S + A) */
101  RV_LTREL_DTPMOD = 21, /* @ltoff(@dtpmod(S + A)) */
102  RV_DTPREL = 22, /* @dtprel(S + A) */
103  RV_LTREL_DTPREL = 23, /* @ltoff(@dtprel(S + A)) */
104  RV_RSVD24 = 24,
105  RV_RSVD25 = 25,
106  RV_RSVD26 = 26,
107  RV_RSVD27 = 27
108  /* 28-31 reserved for implementation-specific purposes. */
109 };
110 
111 #define N(reloc) [R_IA64_##reloc] = #reloc
112 
113 static const char *reloc_name[256] = {
114  N(NONE), N(IMM14), N(IMM22), N(IMM64),
115  N(DIR32MSB), N(DIR32LSB), N(DIR64MSB), N(DIR64LSB),
116  N(GPREL22), N(GPREL64I), N(GPREL32MSB), N(GPREL32LSB),
117  N(GPREL64MSB), N(GPREL64LSB), N(LTOFF22), N(LTOFF64I),
118  N(PLTOFF22), N(PLTOFF64I), N(PLTOFF64MSB), N(PLTOFF64LSB),
119  N(FPTR64I), N(FPTR32MSB), N(FPTR32LSB), N(FPTR64MSB),
120  N(FPTR64LSB), N(PCREL60B), N(PCREL21B), N(PCREL21M),
121  N(PCREL21F), N(PCREL32MSB), N(PCREL32LSB), N(PCREL64MSB),
122  N(PCREL64LSB), N(LTOFF_FPTR22), N(LTOFF_FPTR64I), N(LTOFF_FPTR32MSB),
123  N(LTOFF_FPTR32LSB), N(LTOFF_FPTR64MSB), N(LTOFF_FPTR64LSB), N(SEGREL32MSB),
124  N(SEGREL32LSB), N(SEGREL64MSB), N(SEGREL64LSB), N(SECREL32MSB),
125  N(SECREL32LSB), N(SECREL64MSB), N(SECREL64LSB), N(REL32MSB),
126  N(REL32LSB), N(REL64MSB), N(REL64LSB), N(LTV32MSB),
127  N(LTV32LSB), N(LTV64MSB), N(LTV64LSB), N(PCREL21BI),
128  N(PCREL22), N(PCREL64I), N(IPLTMSB), N(IPLTLSB),
129  N(COPY), N(LTOFF22X), N(LDXMOV), N(TPREL14),
130  N(TPREL22), N(TPREL64I), N(TPREL64MSB), N(TPREL64LSB),
131  N(LTOFF_TPREL22), N(DTPMOD64MSB), N(DTPMOD64LSB), N(LTOFF_DTPMOD22),
132  N(DTPREL14), N(DTPREL22), N(DTPREL64I), N(DTPREL32MSB),
133  N(DTPREL32LSB), N(DTPREL64MSB), N(DTPREL64LSB), N(LTOFF_DTPREL22)
134 };
135 
136 #undef N
137 
138 /* Opaque struct for insns, to protect against derefs. */
139 struct insn;
140 
141 static inline uint64_t
142 bundle (const struct insn *insn)
143 {
144  return (uint64_t) insn & ~0xfUL;
145 }
146 
147 static inline int
148 slot (const struct insn *insn)
149 {
150  return (uint64_t) insn & 0x3;
151 }
152 
153 static int
154 apply_imm64 (struct module *mod, struct insn *insn, uint64_t val)
155 {
156  if (slot(insn) != 2) {
157  printk(KERN_ERR "%s: invalid slot number %d for IMM64\n",
158  mod->name, slot(insn));
159  return 0;
160  }
161  ia64_patch_imm64((u64) insn, val);
162  return 1;
163 }
164 
165 static int
166 apply_imm60 (struct module *mod, struct insn *insn, uint64_t val)
167 {
168  if (slot(insn) != 2) {
169  printk(KERN_ERR "%s: invalid slot number %d for IMM60\n",
170  mod->name, slot(insn));
171  return 0;
172  }
173  if (val + ((uint64_t) 1 << 59) >= (1UL << 60)) {
174  printk(KERN_ERR "%s: value %ld out of IMM60 range\n",
175  mod->name, (long) val);
176  return 0;
177  }
178  ia64_patch_imm60((u64) insn, val);
179  return 1;
180 }
181 
182 static int
183 apply_imm22 (struct module *mod, struct insn *insn, uint64_t val)
184 {
185  if (val + (1 << 21) >= (1 << 22)) {
186  printk(KERN_ERR "%s: value %li out of IMM22 range\n",
187  mod->name, (long)val);
188  return 0;
189  }
190  ia64_patch((u64) insn, 0x01fffcfe000UL, ( ((val & 0x200000UL) << 15) /* bit 21 -> 36 */
191  | ((val & 0x1f0000UL) << 6) /* bit 16 -> 22 */
192  | ((val & 0x00ff80UL) << 20) /* bit 7 -> 27 */
193  | ((val & 0x00007fUL) << 13) /* bit 0 -> 13 */));
194  return 1;
195 }
196 
197 static int
198 apply_imm21b (struct module *mod, struct insn *insn, uint64_t val)
199 {
200  if (val + (1 << 20) >= (1 << 21)) {
201  printk(KERN_ERR "%s: value %li out of IMM21b range\n",
202  mod->name, (long)val);
203  return 0;
204  }
205  ia64_patch((u64) insn, 0x11ffffe000UL, ( ((val & 0x100000UL) << 16) /* bit 20 -> 36 */
206  | ((val & 0x0fffffUL) << 13) /* bit 0 -> 13 */));
207  return 1;
208 }
209 
210 #if USE_BRL
211 
212 struct plt_entry {
213  /* Three instruction bundles in PLT. */
214  unsigned char bundle[2][16];
215 };
216 
217 static const struct plt_entry ia64_plt_template = {
218  {
219  {
220  0x04, 0x00, 0x00, 0x00, 0x01, 0x00, /* [MLX] nop.m 0 */
221  0x00, 0x00, 0x00, 0x00, 0x00, 0x20, /* movl gp=TARGET_GP */
222  0x00, 0x00, 0x00, 0x60
223  },
224  {
225  0x05, 0x00, 0x00, 0x00, 0x01, 0x00, /* [MLX] nop.m 0 */
226  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* brl.many gp=TARGET_GP */
227  0x08, 0x00, 0x00, 0xc0
228  }
229  }
230 };
231 
232 static int
233 patch_plt (struct module *mod, struct plt_entry *plt, long target_ip, unsigned long target_gp)
234 {
235  if (apply_imm64(mod, (struct insn *) (plt->bundle[0] + 2), target_gp)
236  && apply_imm60(mod, (struct insn *) (plt->bundle[1] + 2),
237  (target_ip - (int64_t) plt->bundle[1]) / 16))
238  return 1;
239  return 0;
240 }
241 
242 unsigned long
243 plt_target (struct plt_entry *plt)
244 {
245  uint64_t b0, b1, *b = (uint64_t *) plt->bundle[1];
246  long off;
247 
248  b0 = b[0]; b1 = b[1];
249  off = ( ((b1 & 0x00fffff000000000UL) >> 36) /* imm20b -> bit 0 */
250  | ((b0 >> 48) << 20) | ((b1 & 0x7fffffUL) << 36) /* imm39 -> bit 20 */
251  | ((b1 & 0x0800000000000000UL) << 0)); /* i -> bit 59 */
252  return (long) plt->bundle[1] + 16*off;
253 }
254 
255 #else /* !USE_BRL */
256 
257 struct plt_entry {
258  /* Three instruction bundles in PLT. */
259  unsigned char bundle[3][16];
260 };
261 
262 static const struct plt_entry ia64_plt_template = {
263  {
264  {
265  0x05, 0x00, 0x00, 0x00, 0x01, 0x00, /* [MLX] nop.m 0 */
266  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* movl r16=TARGET_IP */
267  0x02, 0x00, 0x00, 0x60
268  },
269  {
270  0x04, 0x00, 0x00, 0x00, 0x01, 0x00, /* [MLX] nop.m 0 */
271  0x00, 0x00, 0x00, 0x00, 0x00, 0x20, /* movl gp=TARGET_GP */
272  0x00, 0x00, 0x00, 0x60
273  },
274  {
275  0x11, 0x00, 0x00, 0x00, 0x01, 0x00, /* [MIB] nop.m 0 */
276  0x60, 0x80, 0x04, 0x80, 0x03, 0x00, /* mov b6=r16 */
277  0x60, 0x00, 0x80, 0x00 /* br.few b6 */
278  }
279  }
280 };
281 
282 static int
283 patch_plt (struct module *mod, struct plt_entry *plt, long target_ip, unsigned long target_gp)
284 {
285  if (apply_imm64(mod, (struct insn *) (plt->bundle[0] + 2), target_ip)
286  && apply_imm64(mod, (struct insn *) (plt->bundle[1] + 2), target_gp))
287  return 1;
288  return 0;
289 }
290 
291 unsigned long
292 plt_target (struct plt_entry *plt)
293 {
294  uint64_t b0, b1, *b = (uint64_t *) plt->bundle[0];
295 
296  b0 = b[0]; b1 = b[1];
297  return ( ((b1 & 0x000007f000000000) >> 36) /* imm7b -> bit 0 */
298  | ((b1 & 0x07fc000000000000) >> 43) /* imm9d -> bit 7 */
299  | ((b1 & 0x0003e00000000000) >> 29) /* imm5c -> bit 16 */
300  | ((b1 & 0x0000100000000000) >> 23) /* ic -> bit 21 */
301  | ((b0 >> 46) << 22) | ((b1 & 0x7fffff) << 40) /* imm41 -> bit 22 */
302  | ((b1 & 0x0800000000000000) << 4)); /* i -> bit 63 */
303 }
304 
305 #endif /* !USE_BRL */
306 
307 void
308 module_free (struct module *mod, void *module_region)
309 {
310  if (mod && mod->arch.init_unw_table &&
311  module_region == mod->module_init) {
312  unw_remove_unwind_table(mod->arch.init_unw_table);
313  mod->arch.init_unw_table = NULL;
314  }
315  vfree(module_region);
316 }
317 
318 /* Have we already seen one of these relocations? */
319 /* FIXME: we could look in other sections, too --RR */
320 static int
321 duplicate_reloc (const Elf64_Rela *rela, unsigned int num)
322 {
323  unsigned int i;
324 
325  for (i = 0; i < num; i++) {
326  if (rela[i].r_info == rela[num].r_info && rela[i].r_addend == rela[num].r_addend)
327  return 1;
328  }
329  return 0;
330 }
331 
332 /* Count how many GOT entries we may need */
333 static unsigned int
334 count_gots (const Elf64_Rela *rela, unsigned int num)
335 {
336  unsigned int i, ret = 0;
337 
338  /* Sure, this is order(n^2), but it's usually short, and not
339  time critical */
340  for (i = 0; i < num; i++) {
341  switch (ELF64_R_TYPE(rela[i].r_info)) {
342  case R_IA64_LTOFF22:
343  case R_IA64_LTOFF22X:
344  case R_IA64_LTOFF64I:
345  case R_IA64_LTOFF_FPTR22:
346  case R_IA64_LTOFF_FPTR64I:
347  case R_IA64_LTOFF_FPTR32MSB:
348  case R_IA64_LTOFF_FPTR32LSB:
349  case R_IA64_LTOFF_FPTR64MSB:
350  case R_IA64_LTOFF_FPTR64LSB:
351  if (!duplicate_reloc(rela, i))
352  ret++;
353  break;
354  }
355  }
356  return ret;
357 }
358 
359 /* Count how many PLT entries we may need */
360 static unsigned int
361 count_plts (const Elf64_Rela *rela, unsigned int num)
362 {
363  unsigned int i, ret = 0;
364 
365  /* Sure, this is order(n^2), but it's usually short, and not
366  time critical */
367  for (i = 0; i < num; i++) {
368  switch (ELF64_R_TYPE(rela[i].r_info)) {
369  case R_IA64_PCREL21B:
370  case R_IA64_PLTOFF22:
371  case R_IA64_PLTOFF64I:
372  case R_IA64_PLTOFF64MSB:
373  case R_IA64_PLTOFF64LSB:
374  case R_IA64_IPLTMSB:
375  case R_IA64_IPLTLSB:
376  if (!duplicate_reloc(rela, i))
377  ret++;
378  break;
379  }
380  }
381  return ret;
382 }
383 
384 /* We need to create an function-descriptors for any internal function
385  which is referenced. */
386 static unsigned int
387 count_fdescs (const Elf64_Rela *rela, unsigned int num)
388 {
389  unsigned int i, ret = 0;
390 
391  /* Sure, this is order(n^2), but it's usually short, and not time critical. */
392  for (i = 0; i < num; i++) {
393  switch (ELF64_R_TYPE(rela[i].r_info)) {
394  case R_IA64_FPTR64I:
395  case R_IA64_FPTR32LSB:
396  case R_IA64_FPTR32MSB:
397  case R_IA64_FPTR64LSB:
398  case R_IA64_FPTR64MSB:
399  case R_IA64_LTOFF_FPTR22:
400  case R_IA64_LTOFF_FPTR32LSB:
401  case R_IA64_LTOFF_FPTR32MSB:
402  case R_IA64_LTOFF_FPTR64I:
403  case R_IA64_LTOFF_FPTR64LSB:
404  case R_IA64_LTOFF_FPTR64MSB:
405  case R_IA64_IPLTMSB:
406  case R_IA64_IPLTLSB:
407  /*
408  * Jumps to static functions sometimes go straight to their
409  * offset. Of course, that may not be possible if the jump is
410  * from init -> core or vice. versa, so we need to generate an
411  * FDESC (and PLT etc) for that.
412  */
413  case R_IA64_PCREL21B:
414  if (!duplicate_reloc(rela, i))
415  ret++;
416  break;
417  }
418  }
419  return ret;
420 }
421 
422 int
423 module_frob_arch_sections (Elf_Ehdr *ehdr, Elf_Shdr *sechdrs, char *secstrings,
424  struct module *mod)
425 {
426  unsigned long core_plts = 0, init_plts = 0, gots = 0, fdescs = 0;
427  Elf64_Shdr *s, *sechdrs_end = sechdrs + ehdr->e_shnum;
428 
429  /*
430  * To store the PLTs and function-descriptors, we expand the .text section for
431  * core module-code and the .init.text section for initialization code.
432  */
433  for (s = sechdrs; s < sechdrs_end; ++s)
434  if (strcmp(".core.plt", secstrings + s->sh_name) == 0)
435  mod->arch.core_plt = s;
436  else if (strcmp(".init.plt", secstrings + s->sh_name) == 0)
437  mod->arch.init_plt = s;
438  else if (strcmp(".got", secstrings + s->sh_name) == 0)
439  mod->arch.got = s;
440  else if (strcmp(".opd", secstrings + s->sh_name) == 0)
441  mod->arch.opd = s;
442  else if (strcmp(".IA_64.unwind", secstrings + s->sh_name) == 0)
443  mod->arch.unwind = s;
444 #ifdef CONFIG_PARAVIRT
445  else if (strcmp(".paravirt_bundles",
446  secstrings + s->sh_name) == 0)
447  mod->arch.paravirt_bundles = s;
448  else if (strcmp(".paravirt_insts",
449  secstrings + s->sh_name) == 0)
450  mod->arch.paravirt_insts = s;
451 #endif
452 
453  if (!mod->arch.core_plt || !mod->arch.init_plt || !mod->arch.got || !mod->arch.opd) {
454  printk(KERN_ERR "%s: sections missing\n", mod->name);
455  return -ENOEXEC;
456  }
457 
458  /* GOT and PLTs can occur in any relocated section... */
459  for (s = sechdrs + 1; s < sechdrs_end; ++s) {
460  const Elf64_Rela *rels = (void *)ehdr + s->sh_offset;
461  unsigned long numrels = s->sh_size/sizeof(Elf64_Rela);
462 
463  if (s->sh_type != SHT_RELA)
464  continue;
465 
466  gots += count_gots(rels, numrels);
467  fdescs += count_fdescs(rels, numrels);
468  if (strstr(secstrings + s->sh_name, ".init"))
469  init_plts += count_plts(rels, numrels);
470  else
471  core_plts += count_plts(rels, numrels);
472  }
473 
474  mod->arch.core_plt->sh_type = SHT_NOBITS;
475  mod->arch.core_plt->sh_flags = SHF_EXECINSTR | SHF_ALLOC;
476  mod->arch.core_plt->sh_addralign = 16;
477  mod->arch.core_plt->sh_size = core_plts * sizeof(struct plt_entry);
478  mod->arch.init_plt->sh_type = SHT_NOBITS;
479  mod->arch.init_plt->sh_flags = SHF_EXECINSTR | SHF_ALLOC;
480  mod->arch.init_plt->sh_addralign = 16;
481  mod->arch.init_plt->sh_size = init_plts * sizeof(struct plt_entry);
482  mod->arch.got->sh_type = SHT_NOBITS;
483  mod->arch.got->sh_flags = ARCH_SHF_SMALL | SHF_ALLOC;
484  mod->arch.got->sh_addralign = 8;
485  mod->arch.got->sh_size = gots * sizeof(struct got_entry);
486  mod->arch.opd->sh_type = SHT_NOBITS;
487  mod->arch.opd->sh_flags = SHF_ALLOC;
488  mod->arch.opd->sh_addralign = 8;
489  mod->arch.opd->sh_size = fdescs * sizeof(struct fdesc);
490  DEBUGP("%s: core.plt=%lx, init.plt=%lx, got=%lx, fdesc=%lx\n",
491  __func__, mod->arch.core_plt->sh_size, mod->arch.init_plt->sh_size,
492  mod->arch.got->sh_size, mod->arch.opd->sh_size);
493  return 0;
494 }
495 
496 static inline int
497 in_init (const struct module *mod, uint64_t addr)
498 {
499  return addr - (uint64_t) mod->module_init < mod->init_size;
500 }
501 
502 static inline int
503 in_core (const struct module *mod, uint64_t addr)
504 {
505  return addr - (uint64_t) mod->module_core < mod->core_size;
506 }
507 
508 static inline int
509 is_internal (const struct module *mod, uint64_t value)
510 {
511  return in_init(mod, value) || in_core(mod, value);
512 }
513 
514 /*
515  * Get gp-relative offset for the linkage-table entry of VALUE.
516  */
517 static uint64_t
518 get_ltoff (struct module *mod, uint64_t value, int *okp)
519 {
520  struct got_entry *got, *e;
521 
522  if (!*okp)
523  return 0;
524 
525  got = (void *) mod->arch.got->sh_addr;
526  for (e = got; e < got + mod->arch.next_got_entry; ++e)
527  if (e->val == value)
528  goto found;
529 
530  /* Not enough GOT entries? */
531  BUG_ON(e >= (struct got_entry *) (mod->arch.got->sh_addr + mod->arch.got->sh_size));
532 
533  e->val = value;
534  ++mod->arch.next_got_entry;
535  found:
536  return (uint64_t) e - mod->arch.gp;
537 }
538 
539 static inline int
540 gp_addressable (struct module *mod, uint64_t value)
541 {
542  return value - mod->arch.gp + MAX_LTOFF/2 < MAX_LTOFF;
543 }
544 
545 /* Get PC-relative PLT entry for this value. Returns 0 on failure. */
546 static uint64_t
547 get_plt (struct module *mod, const struct insn *insn, uint64_t value, int *okp)
548 {
549  struct plt_entry *plt, *plt_end;
550  uint64_t target_ip, target_gp;
551 
552  if (!*okp)
553  return 0;
554 
555  if (in_init(mod, (uint64_t) insn)) {
556  plt = (void *) mod->arch.init_plt->sh_addr;
557  plt_end = (void *) plt + mod->arch.init_plt->sh_size;
558  } else {
559  plt = (void *) mod->arch.core_plt->sh_addr;
560  plt_end = (void *) plt + mod->arch.core_plt->sh_size;
561  }
562 
563  /* "value" is a pointer to a function-descriptor; fetch the target ip/gp from it: */
564  target_ip = ((uint64_t *) value)[0];
565  target_gp = ((uint64_t *) value)[1];
566 
567  /* Look for existing PLT entry. */
568  while (plt->bundle[0][0]) {
569  if (plt_target(plt) == target_ip)
570  goto found;
571  if (++plt >= plt_end)
572  BUG();
573  }
574  *plt = ia64_plt_template;
575  if (!patch_plt(mod, plt, target_ip, target_gp)) {
576  *okp = 0;
577  return 0;
578  }
579 #if ARCH_MODULE_DEBUG
580  if (plt_target(plt) != target_ip) {
581  printk("%s: mistargeted PLT: wanted %lx, got %lx\n",
582  __func__, target_ip, plt_target(plt));
583  *okp = 0;
584  return 0;
585  }
586 #endif
587  found:
588  return (uint64_t) plt;
589 }
590 
591 /* Get function descriptor for VALUE. */
592 static uint64_t
593 get_fdesc (struct module *mod, uint64_t value, int *okp)
594 {
595  struct fdesc *fdesc = (void *) mod->arch.opd->sh_addr;
596 
597  if (!*okp)
598  return 0;
599 
600  if (!value) {
601  printk(KERN_ERR "%s: fdesc for zero requested!\n", mod->name);
602  return 0;
603  }
604 
605  if (!is_internal(mod, value))
606  /*
607  * If it's not a module-local entry-point, "value" already points to a
608  * function-descriptor.
609  */
610  return value;
611 
612  /* Look for existing function descriptor. */
613  while (fdesc->ip) {
614  if (fdesc->ip == value)
615  return (uint64_t)fdesc;
616  if ((uint64_t) ++fdesc >= mod->arch.opd->sh_addr + mod->arch.opd->sh_size)
617  BUG();
618  }
619 
620  /* Create new one */
621  fdesc->ip = value;
622  fdesc->gp = mod->arch.gp;
623  return (uint64_t) fdesc;
624 }
625 
626 static inline int
627 do_reloc (struct module *mod, uint8_t r_type, Elf64_Sym *sym, uint64_t addend,
628  Elf64_Shdr *sec, void *location)
629 {
630  enum reloc_target_format format = (r_type >> FORMAT_SHIFT) & FORMAT_MASK;
631  enum reloc_value_formula formula = (r_type >> VALUE_SHIFT) & VALUE_MASK;
632  uint64_t val;
633  int ok = 1;
634 
635  val = sym->st_value + addend;
636 
637  switch (formula) {
638  case RV_SEGREL: /* segment base is arbitrarily chosen to be 0 for kernel modules */
639  case RV_DIRECT:
640  break;
641 
642  case RV_GPREL: val -= mod->arch.gp; break;
643  case RV_LTREL: val = get_ltoff(mod, val, &ok); break;
644  case RV_PLTREL: val = get_plt(mod, location, val, &ok); break;
645  case RV_FPTR: val = get_fdesc(mod, val, &ok); break;
646  case RV_SECREL: val -= sec->sh_addr; break;
647  case RV_LTREL_FPTR: val = get_ltoff(mod, get_fdesc(mod, val, &ok), &ok); break;
648 
649  case RV_PCREL:
650  switch (r_type) {
651  case R_IA64_PCREL21B:
652  if ((in_init(mod, val) && in_core(mod, (uint64_t)location)) ||
653  (in_core(mod, val) && in_init(mod, (uint64_t)location))) {
654  /*
655  * Init section may have been allocated far away from core,
656  * if the branch won't reach, then allocate a plt for it.
657  */
658  uint64_t delta = ((int64_t)val - (int64_t)location) / 16;
659  if (delta + (1 << 20) >= (1 << 21)) {
660  val = get_fdesc(mod, val, &ok);
661  val = get_plt(mod, location, val, &ok);
662  }
663  } else if (!is_internal(mod, val))
664  val = get_plt(mod, location, val, &ok);
665  /* FALL THROUGH */
666  default:
667  val -= bundle(location);
668  break;
669 
670  case R_IA64_PCREL32MSB:
671  case R_IA64_PCREL32LSB:
672  case R_IA64_PCREL64MSB:
673  case R_IA64_PCREL64LSB:
674  val -= (uint64_t) location;
675  break;
676 
677  }
678  switch (r_type) {
679  case R_IA64_PCREL60B: format = RF_INSN60; break;
680  case R_IA64_PCREL21B: format = RF_INSN21B; break;
681  case R_IA64_PCREL21M: format = RF_INSN21M; break;
682  case R_IA64_PCREL21F: format = RF_INSN21F; break;
683  default: break;
684  }
685  break;
686 
687  case RV_BDREL:
688  val -= (uint64_t) (in_init(mod, val) ? mod->module_init : mod->module_core);
689  break;
690 
691  case RV_LTV:
692  /* can link-time value relocs happen here? */
693  BUG();
694  break;
695 
696  case RV_PCREL2:
697  if (r_type == R_IA64_PCREL21BI) {
698  if (!is_internal(mod, val)) {
699  printk(KERN_ERR "%s: %s reloc against "
700  "non-local symbol (%lx)\n", __func__,
701  reloc_name[r_type], (unsigned long)val);
702  return -ENOEXEC;
703  }
704  format = RF_INSN21B;
705  }
706  val -= bundle(location);
707  break;
708 
709  case RV_SPECIAL:
710  switch (r_type) {
711  case R_IA64_IPLTMSB:
712  case R_IA64_IPLTLSB:
713  val = get_fdesc(mod, get_plt(mod, location, val, &ok), &ok);
714  format = RF_64LSB;
715  if (r_type == R_IA64_IPLTMSB)
716  format = RF_64MSB;
717  break;
718 
719  case R_IA64_SUB:
720  val = addend - sym->st_value;
721  format = RF_INSN64;
722  break;
723 
724  case R_IA64_LTOFF22X:
725  if (gp_addressable(mod, val))
726  val -= mod->arch.gp;
727  else
728  val = get_ltoff(mod, val, &ok);
729  format = RF_INSN22;
730  break;
731 
732  case R_IA64_LDXMOV:
733  if (gp_addressable(mod, val)) {
734  /* turn "ld8" into "mov": */
735  DEBUGP("%s: patching ld8 at %p to mov\n", __func__, location);
736  ia64_patch((u64) location, 0x1fff80fe000UL, 0x10000000000UL);
737  }
738  return 0;
739 
740  default:
741  if (reloc_name[r_type])
742  printk(KERN_ERR "%s: special reloc %s not supported",
743  mod->name, reloc_name[r_type]);
744  else
745  printk(KERN_ERR "%s: unknown special reloc %x\n",
746  mod->name, r_type);
747  return -ENOEXEC;
748  }
749  break;
750 
751  case RV_TPREL:
752  case RV_LTREL_TPREL:
753  case RV_DTPMOD:
754  case RV_LTREL_DTPMOD:
755  case RV_DTPREL:
756  case RV_LTREL_DTPREL:
757  printk(KERN_ERR "%s: %s reloc not supported\n",
758  mod->name, reloc_name[r_type] ? reloc_name[r_type] : "?");
759  return -ENOEXEC;
760 
761  default:
762  printk(KERN_ERR "%s: unknown reloc %x\n", mod->name, r_type);
763  return -ENOEXEC;
764  }
765 
766  if (!ok)
767  return -ENOEXEC;
768 
769  DEBUGP("%s: [%p]<-%016lx = %s(%lx)\n", __func__, location, val,
770  reloc_name[r_type] ? reloc_name[r_type] : "?", sym->st_value + addend);
771 
772  switch (format) {
773  case RF_INSN21B: ok = apply_imm21b(mod, location, (int64_t) val / 16); break;
774  case RF_INSN22: ok = apply_imm22(mod, location, val); break;
775  case RF_INSN64: ok = apply_imm64(mod, location, val); break;
776  case RF_INSN60: ok = apply_imm60(mod, location, (int64_t) val / 16); break;
777  case RF_32LSB: put_unaligned(val, (uint32_t *) location); break;
778  case RF_64LSB: put_unaligned(val, (uint64_t *) location); break;
779  case RF_32MSB: /* ia64 Linux is little-endian... */
780  case RF_64MSB: /* ia64 Linux is little-endian... */
781  case RF_INSN14: /* must be within-module, i.e., resolved by "ld -r" */
782  case RF_INSN21M: /* must be within-module, i.e., resolved by "ld -r" */
783  case RF_INSN21F: /* must be within-module, i.e., resolved by "ld -r" */
784  printk(KERN_ERR "%s: format %u needed by %s reloc is not supported\n",
785  mod->name, format, reloc_name[r_type] ? reloc_name[r_type] : "?");
786  return -ENOEXEC;
787 
788  default:
789  printk(KERN_ERR "%s: relocation %s resulted in unknown format %u\n",
790  mod->name, reloc_name[r_type] ? reloc_name[r_type] : "?", format);
791  return -ENOEXEC;
792  }
793  return ok ? 0 : -ENOEXEC;
794 }
795 
796 int
797 apply_relocate_add (Elf64_Shdr *sechdrs, const char *strtab, unsigned int symindex,
798  unsigned int relsec, struct module *mod)
799 {
800  unsigned int i, n = sechdrs[relsec].sh_size / sizeof(Elf64_Rela);
801  Elf64_Rela *rela = (void *) sechdrs[relsec].sh_addr;
802  Elf64_Shdr *target_sec;
803  int ret;
804 
805  DEBUGP("%s: applying section %u (%u relocs) to %u\n", __func__,
806  relsec, n, sechdrs[relsec].sh_info);
807 
808  target_sec = sechdrs + sechdrs[relsec].sh_info;
809 
810  if (target_sec->sh_entsize == ~0UL)
811  /*
812  * If target section wasn't allocated, we don't need to relocate it.
813  * Happens, e.g., for debug sections.
814  */
815  return 0;
816 
817  if (!mod->arch.gp) {
818  /*
819  * XXX Should have an arch-hook for running this after final section
820  * addresses have been selected...
821  */
822  uint64_t gp;
823  if (mod->core_size > MAX_LTOFF)
824  /*
825  * This takes advantage of fact that SHF_ARCH_SMALL gets allocated
826  * at the end of the module.
827  */
828  gp = mod->core_size - MAX_LTOFF / 2;
829  else
830  gp = mod->core_size / 2;
831  gp = (uint64_t) mod->module_core + ((gp + 7) & -8);
832  mod->arch.gp = gp;
833  DEBUGP("%s: placing gp at 0x%lx\n", __func__, gp);
834  }
835 
836  for (i = 0; i < n; i++) {
837  ret = do_reloc(mod, ELF64_R_TYPE(rela[i].r_info),
838  ((Elf64_Sym *) sechdrs[symindex].sh_addr
839  + ELF64_R_SYM(rela[i].r_info)),
840  rela[i].r_addend, target_sec,
841  (void *) target_sec->sh_addr + rela[i].r_offset);
842  if (ret < 0)
843  return ret;
844  }
845  return 0;
846 }
847 
848 /*
849  * Modules contain a single unwind table which covers both the core and the init text
850  * sections but since the two are not contiguous, we need to split this table up such that
851  * we can register (and unregister) each "segment" separately. Fortunately, this sounds
852  * more complicated than it really is.
853  */
854 static void
855 register_unwind_table (struct module *mod)
856 {
857  struct unw_table_entry *start = (void *) mod->arch.unwind->sh_addr;
858  struct unw_table_entry *end = start + mod->arch.unwind->sh_size / sizeof (*start);
859  struct unw_table_entry tmp, *e1, *e2, *core, *init;
860  unsigned long num_init = 0, num_core = 0;
861 
862  /* First, count how many init and core unwind-table entries there are. */
863  for (e1 = start; e1 < end; ++e1)
864  if (in_init(mod, e1->start_offset))
865  ++num_init;
866  else
867  ++num_core;
868  /*
869  * Second, sort the table such that all unwind-table entries for the init and core
870  * text sections are nicely separated. We do this with a stupid bubble sort
871  * (unwind tables don't get ridiculously huge).
872  */
873  for (e1 = start; e1 < end; ++e1) {
874  for (e2 = e1 + 1; e2 < end; ++e2) {
875  if (e2->start_offset < e1->start_offset) {
876  tmp = *e1;
877  *e1 = *e2;
878  *e2 = tmp;
879  }
880  }
881  }
882  /*
883  * Third, locate the init and core segments in the unwind table:
884  */
885  if (in_init(mod, start->start_offset)) {
886  init = start;
887  core = start + num_init;
888  } else {
889  core = start;
890  init = start + num_core;
891  }
892 
893  DEBUGP("%s: name=%s, gp=%lx, num_init=%lu, num_core=%lu\n", __func__,
894  mod->name, mod->arch.gp, num_init, num_core);
895 
896  /*
897  * Fourth, register both tables (if not empty).
898  */
899  if (num_core > 0) {
900  mod->arch.core_unw_table = unw_add_unwind_table(mod->name, 0, mod->arch.gp,
901  core, core + num_core);
902  DEBUGP("%s: core: handle=%p [%p-%p)\n", __func__,
903  mod->arch.core_unw_table, core, core + num_core);
904  }
905  if (num_init > 0) {
906  mod->arch.init_unw_table = unw_add_unwind_table(mod->name, 0, mod->arch.gp,
907  init, init + num_init);
908  DEBUGP("%s: init: handle=%p [%p-%p)\n", __func__,
909  mod->arch.init_unw_table, init, init + num_init);
910  }
911 }
912 
913 int
914 module_finalize (const Elf_Ehdr *hdr, const Elf_Shdr *sechdrs, struct module *mod)
915 {
916  DEBUGP("%s: init: entry=%p\n", __func__, mod->init);
917  if (mod->arch.unwind)
918  register_unwind_table(mod);
919 #ifdef CONFIG_PARAVIRT
920  if (mod->arch.paravirt_bundles) {
921  struct paravirt_patch_site_bundle *start =
922  (struct paravirt_patch_site_bundle *)
923  mod->arch.paravirt_bundles->sh_addr;
924  struct paravirt_patch_site_bundle *end =
925  (struct paravirt_patch_site_bundle *)
926  (mod->arch.paravirt_bundles->sh_addr +
927  mod->arch.paravirt_bundles->sh_size);
928 
929  paravirt_patch_apply_bundle(start, end);
930  }
931  if (mod->arch.paravirt_insts) {
932  struct paravirt_patch_site_inst *start =
933  (struct paravirt_patch_site_inst *)
934  mod->arch.paravirt_insts->sh_addr;
935  struct paravirt_patch_site_inst *end =
936  (struct paravirt_patch_site_inst *)
937  (mod->arch.paravirt_insts->sh_addr +
938  mod->arch.paravirt_insts->sh_size);
939 
940  paravirt_patch_apply_inst(start, end);
941  }
942 #endif
943  return 0;
944 }
945 
946 void
947 module_arch_cleanup (struct module *mod)
948 {
949  if (mod->arch.init_unw_table)
950  unw_remove_unwind_table(mod->arch.init_unw_table);
951  if (mod->arch.core_unw_table)
952  unw_remove_unwind_table(mod->arch.core_unw_table);
953 }
Generated on Thu Jan 10 2013 12:51:38 for Linux Kernel by   doxygen 1.8.2