1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
|
// SPDX-License-Identifier: GPL-2.0
// Copyright (C) 2005-2017 Andes Technology Corporation
#include <linux/module.h>
#include <linux/elf.h>
#include <linux/vmalloc.h>
#include <linux/moduleloader.h>
#include <linux/pgtable.h>
void *module_alloc(unsigned long size)
{
return __vmalloc_node_range(size, 1, MODULES_VADDR, MODULES_END,
GFP_KERNEL, PAGE_KERNEL, 0, NUMA_NO_NODE,
__builtin_return_address(0));
}
void module_free(struct module *module, void *region)
{
vfree(region);
}
int module_frob_arch_sections(Elf_Ehdr * hdr,
Elf_Shdr * sechdrs,
char *secstrings, struct module *mod)
{
return 0;
}
void do_reloc16(unsigned int val, unsigned int *loc, unsigned int val_mask,
unsigned int val_shift, unsigned int loc_mask,
unsigned int partial_in_place, unsigned int swap)
{
unsigned int tmp = 0, tmp2 = 0;
__asm__ __volatile__("\tlhi.bi\t%0, [%2], 0\n"
"\tbeqz\t%3, 1f\n"
"\twsbh\t%0, %1\n"
"1:\n":"=r"(tmp):"0"(tmp), "r"(loc), "r"(swap)
);
tmp2 = tmp & loc_mask;
if (partial_in_place) {
tmp &= (~loc_mask);
tmp =
tmp2 | ((tmp + ((val & val_mask) >> val_shift)) & val_mask);
} else {
tmp = tmp2 | ((val & val_mask) >> val_shift);
}
__asm__ __volatile__("\tbeqz\t%3, 2f\n"
"\twsbh\t%0, %1\n"
"2:\n"
"\tshi.bi\t%0, [%2], 0\n":"=r"(tmp):"0"(tmp),
"r"(loc), "r"(swap)
);
}
void do_reloc32(unsigned int val, unsigned int *loc, unsigned int val_mask,
unsigned int val_shift, unsigned int loc_mask,
unsigned int partial_in_place, unsigned int swap)
{
unsigned int tmp = 0, tmp2 = 0;
__asm__ __volatile__("\tlmw.bi\t%0, [%2], %0, 0\n"
"\tbeqz\t%3, 1f\n"
"\twsbh\t%0, %1\n"
"\trotri\t%0, %1, 16\n"
"1:\n":"=r"(tmp):"0"(tmp), "r"(loc), "r"(swap)
);
tmp2 = tmp & loc_mask;
if (partial_in_place) {
tmp &= (~loc_mask);
tmp =
tmp2 | ((tmp + ((val & val_mask) >> val_shift)) & val_mask);
} else {
tmp = tmp2 | ((val & val_mask) >> val_shift);
}
__asm__ __volatile__("\tbeqz\t%3, 2f\n"
"\twsbh\t%0, %1\n"
"\trotri\t%0, %1, 16\n"
"2:\n"
"\tsmw.bi\t%0, [%2], %0, 0\n":"=r"(tmp):"0"(tmp),
"r"(loc), "r"(swap)
);
}
static inline int exceed_limit(int offset, unsigned int val_mask,
struct module *module, Elf32_Rela * rel,
unsigned int relindex, unsigned int reloc_order)
{
int abs_off = offset < 0 ? ~offset : offset;
if (abs_off & (~val_mask)) {
pr_err("\n%s: relocation type %d out of range.\n"
"please rebuild the kernel module with gcc option \"-Wa,-mno-small-text\".\n",
module->name, ELF32_R_TYPE(rel->r_info));
pr_err("section %d reloc %d offset 0x%x relative 0x%x.\n",
relindex, reloc_order, rel->r_offset, offset);
return true;
}
return false;
}
#ifdef __NDS32_EL__
#define NEED_SWAP 1
#else
#define NEED_SWAP 0
#endif
int
apply_relocate_add(Elf32_Shdr * sechdrs, const char *strtab,
unsigned int symindex, unsigned int relindex,
struct module *module)
{
Elf32_Shdr *symsec = sechdrs + symindex;
Elf32_Shdr *relsec = sechdrs + relindex;
Elf32_Shdr *dstsec = sechdrs + relsec->sh_info;
Elf32_Rela *rel = (void *)relsec->sh_addr;
unsigned int i;
for (i = 0; i < relsec->sh_size / sizeof(Elf32_Rela); i++, rel++) {
Elf32_Addr *loc;
Elf32_Sym *sym;
Elf32_Addr v;
s32 offset;
offset = ELF32_R_SYM(rel->r_info);
if (offset < 0
|| offset > (symsec->sh_size / sizeof(Elf32_Sym))) {
pr_err("%s: bad relocation\n", module->name);
pr_err("section %d reloc %d\n", relindex, i);
return -ENOEXEC;
}
sym = ((Elf32_Sym *) symsec->sh_addr) + offset;
if (rel->r_offset < 0
|| rel->r_offset > dstsec->sh_size - sizeof(u16)) {
pr_err("%s: out of bounds relocation\n", module->name);
pr_err("section %d reloc %d offset 0x%0x size %d\n",
relindex, i, rel->r_offset, dstsec->sh_size);
return -ENOEXEC;
}
loc = (Elf32_Addr *) (dstsec->sh_addr + rel->r_offset);
v = sym->st_value + rel->r_addend;
switch (ELF32_R_TYPE(rel->r_info)) {
case R_NDS32_NONE:
case R_NDS32_INSN16:
case R_NDS32_LABEL:
case R_NDS32_LONGCALL1:
case R_NDS32_LONGCALL2:
case R_NDS32_LONGCALL3:
case R_NDS32_LONGCALL4:
case R_NDS32_LONGJUMP1:
case R_NDS32_LONGJUMP2:
case R_NDS32_LONGJUMP3:
case R_NDS32_9_FIXED_RELA:
case R_NDS32_15_FIXED_RELA:
case R_NDS32_17_FIXED_RELA:
case R_NDS32_25_FIXED_RELA:
case R_NDS32_LOADSTORE:
case R_NDS32_DWARF2_OP1_RELA:
case R_NDS32_DWARF2_OP2_RELA:
case R_NDS32_DWARF2_LEB_RELA:
case R_NDS32_RELA_NOP_MIX ... R_NDS32_RELA_NOP_MAX:
break;
case R_NDS32_32_RELA:
do_reloc32(v, loc, 0xffffffff, 0, 0, 0, 0);
break;
case R_NDS32_HI20_RELA:
do_reloc32(v, loc, 0xfffff000, 12, 0xfff00000, 0,
NEED_SWAP);
break;
case R_NDS32_LO12S3_RELA:
do_reloc32(v, loc, 0x00000fff, 3, 0xfffff000, 0,
NEED_SWAP);
break;
case R_NDS32_LO12S2_RELA:
do_reloc32(v, loc, 0x00000fff, 2, 0xfffff000, 0,
NEED_SWAP);
break;
case R_NDS32_LO12S1_RELA:
do_reloc32(v, loc, 0x00000fff, 1, 0xfffff000, 0,
NEED_SWAP);
break;
case R_NDS32_LO12S0_RELA:
case R_NDS32_LO12S0_ORI_RELA:
do_reloc32(v, loc, 0x00000fff, 0, 0xfffff000, 0,
NEED_SWAP);
break;
case R_NDS32_9_PCREL_RELA:
if (exceed_limit
((v - (Elf32_Addr) loc), 0x000000ff, module, rel,
relindex, i))
return -ENOEXEC;
do_reloc16(v - (Elf32_Addr) loc, loc, 0x000001ff, 1,
0xffffff00, 0, NEED_SWAP);
break;
case R_NDS32_15_PCREL_RELA:
if (exceed_limit
((v - (Elf32_Addr) loc), 0x00003fff, module, rel,
relindex, i))
return -ENOEXEC;
do_reloc32(v - (Elf32_Addr) loc, loc, 0x00007fff, 1,
0xffffc000, 0, NEED_SWAP);
break;
case R_NDS32_17_PCREL_RELA:
if (exceed_limit
((v - (Elf32_Addr) loc), 0x0000ffff, module, rel,
relindex, i))
return -ENOEXEC;
do_reloc32(v - (Elf32_Addr) loc, loc, 0x0001ffff, 1,
0xffff0000, 0, NEED_SWAP);
break;
case R_NDS32_25_PCREL_RELA:
if (exceed_limit
((v - (Elf32_Addr) loc), 0x00ffffff, module, rel,
relindex, i))
return -ENOEXEC;
do_reloc32(v - (Elf32_Addr) loc, loc, 0x01ffffff, 1,
0xff000000, 0, NEED_SWAP);
break;
case R_NDS32_WORD_9_PCREL_RELA:
if (exceed_limit
((v - (Elf32_Addr) loc), 0x000000ff, module, rel,
relindex, i))
return -ENOEXEC;
do_reloc32(v - (Elf32_Addr) loc, loc, 0x000001ff, 1,
0xffffff00, 0, NEED_SWAP);
break;
case R_NDS32_SDA15S3_RELA:
case R_NDS32_SDA15S2_RELA:
case R_NDS32_SDA15S1_RELA:
case R_NDS32_SDA15S0_RELA:
pr_err("%s: unsupported relocation type %d.\n",
module->name, ELF32_R_TYPE(rel->r_info));
pr_err
("Small data section access doesn't work in the kernel space; "
"please rebuild the kernel module with gcc option -mcmodel=large.\n");
pr_err("section %d reloc %d offset 0x%x size %d\n",
relindex, i, rel->r_offset, dstsec->sh_size);
break;
default:
pr_err("%s: unsupported relocation type %d.\n",
module->name, ELF32_R_TYPE(rel->r_info));
pr_err("section %d reloc %d offset 0x%x size %d\n",
relindex, i, rel->r_offset, dstsec->sh_size);
}
}
return 0;
}
int
module_finalize(const Elf32_Ehdr * hdr, const Elf_Shdr * sechdrs,
struct module *module)
{
return 0;
}
void module_arch_cleanup(struct module *mod)
{
}
|
