[MIPS] N32: Make sure pointer is good before passing it to sys_waitid().
[linux-2.6] / arch / mips / kernel / module.c
1 /*
2  *  This program is free software; you can redistribute it and/or modify
3  *  it under the terms of the GNU General Public License as published by
4  *  the Free Software Foundation; either version 2 of the License, or
5  *  (at your option) any later version.
6  *
7  *  This program is distributed in the hope that it will be useful,
8  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
9  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
10  *  GNU General Public License for more details.
11  *
12  *  You should have received a copy of the GNU General Public License
13  *  along with this program; if not, write to the Free Software
14  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
15  *
16  *  Copyright (C) 2001 Rusty Russell.
17  *  Copyright (C) 2003, 2004 Ralf Baechle (ralf@linux-mips.org)
18  *  Copyright (C) 2005 Thiemo Seufer
19  */
20
21 #undef DEBUG
22
23 #include <linux/moduleloader.h>
24 #include <linux/elf.h>
25 #include <linux/vmalloc.h>
26 #include <linux/slab.h>
27 #include <linux/fs.h>
28 #include <linux/string.h>
29 #include <linux/kernel.h>
30 #include <linux/module.h>
31 #include <linux/spinlock.h>
32
33 struct mips_hi16 {
34         struct mips_hi16 *next;
35         Elf_Addr *addr;
36         Elf_Addr value;
37 };
38
39 static struct mips_hi16 *mips_hi16_list;
40
41 static LIST_HEAD(dbe_list);
42 static DEFINE_SPINLOCK(dbe_lock);
43
44 void *module_alloc(unsigned long size)
45 {
46         if (size == 0)
47                 return NULL;
48         return vmalloc(size);
49 }
50
51 /* Free memory returned from module_alloc */
52 void module_free(struct module *mod, void *module_region)
53 {
54         vfree(module_region);
55         /* FIXME: If module_region == mod->init_region, trim exception
56            table entries. */
57 }
58
59 int module_frob_arch_sections(Elf_Ehdr *hdr, Elf_Shdr *sechdrs,
60                               char *secstrings, struct module *mod)
61 {
62         return 0;
63 }
64
65 static int apply_r_mips_none(struct module *me, u32 *location, Elf_Addr v)
66 {
67         return 0;
68 }
69
70 static int apply_r_mips_32_rel(struct module *me, u32 *location, Elf_Addr v)
71 {
72         *location += v;
73
74         return 0;
75 }
76
77 static int apply_r_mips_32_rela(struct module *me, u32 *location, Elf_Addr v)
78 {
79         *location = v;
80
81         return 0;
82 }
83
84 static int apply_r_mips_26_rel(struct module *me, u32 *location, Elf_Addr v)
85 {
86         if (v % 4) {
87                 printk(KERN_ERR "module %s: dangerous relocation\n", me->name);
88                 return -ENOEXEC;
89         }
90
91         if ((v & 0xf0000000) != (((unsigned long)location + 4) & 0xf0000000)) {
92                 printk(KERN_ERR
93                        "module %s: relocation overflow\n",
94                        me->name);
95                 return -ENOEXEC;
96         }
97
98         *location = (*location & ~0x03ffffff) |
99                     ((*location + (v >> 2)) & 0x03ffffff);
100
101         return 0;
102 }
103
104 static int apply_r_mips_26_rela(struct module *me, u32 *location, Elf_Addr v)
105 {
106         if (v % 4) {
107                 printk(KERN_ERR "module %s: dangerous relocation\n", me->name);
108                 return -ENOEXEC;
109         }
110
111         if ((v & 0xf0000000) != (((unsigned long)location + 4) & 0xf0000000)) {
112                 printk(KERN_ERR
113                        "module %s: relocation overflow\n",
114                        me->name);
115                 return -ENOEXEC;
116         }
117
118         *location = (*location & ~0x03ffffff) | ((v >> 2) & 0x03ffffff);
119
120         return 0;
121 }
122
123 static int apply_r_mips_hi16_rel(struct module *me, u32 *location, Elf_Addr v)
124 {
125         struct mips_hi16 *n;
126
127         /*
128          * We cannot relocate this one now because we don't know the value of
129          * the carry we need to add.  Save the information, and let LO16 do the
130          * actual relocation.
131          */
132         n = kmalloc(sizeof *n, GFP_KERNEL);
133         if (!n)
134                 return -ENOMEM;
135
136         n->addr = (Elf_Addr *)location;
137         n->value = v;
138         n->next = mips_hi16_list;
139         mips_hi16_list = n;
140
141         return 0;
142 }
143
144 static int apply_r_mips_hi16_rela(struct module *me, u32 *location, Elf_Addr v)
145 {
146         *location = (*location & 0xffff0000) |
147                     ((((long long) v + 0x8000LL) >> 16) & 0xffff);
148
149         return 0;
150 }
151
152 static int apply_r_mips_lo16_rel(struct module *me, u32 *location, Elf_Addr v)
153 {
154         unsigned long insnlo = *location;
155         Elf_Addr val, vallo;
156
157         /* Sign extend the addend we extract from the lo insn.  */
158         vallo = ((insnlo & 0xffff) ^ 0x8000) - 0x8000;
159
160         if (mips_hi16_list != NULL) {
161                 struct mips_hi16 *l;
162
163                 l = mips_hi16_list;
164                 while (l != NULL) {
165                         struct mips_hi16 *next;
166                         unsigned long insn;
167
168                         /*
169                          * The value for the HI16 had best be the same.
170                          */
171                         if (v != l->value)
172                                 goto out_danger;
173
174                         /*
175                          * Do the HI16 relocation.  Note that we actually don't
176                          * need to know anything about the LO16 itself, except
177                          * where to find the low 16 bits of the addend needed
178                          * by the LO16.
179                          */
180                         insn = *l->addr;
181                         val = ((insn & 0xffff) << 16) + vallo;
182                         val += v;
183
184                         /*
185                          * Account for the sign extension that will happen in
186                          * the low bits.
187                          */
188                         val = ((val >> 16) + ((val & 0x8000) != 0)) & 0xffff;
189
190                         insn = (insn & ~0xffff) | val;
191                         *l->addr = insn;
192
193                         next = l->next;
194                         kfree(l);
195                         l = next;
196                 }
197
198                 mips_hi16_list = NULL;
199         }
200
201         /*
202          * Ok, we're done with the HI16 relocs.  Now deal with the LO16.
203          */
204         val = v + vallo;
205         insnlo = (insnlo & ~0xffff) | (val & 0xffff);
206         *location = insnlo;
207
208         return 0;
209
210 out_danger:
211         printk(KERN_ERR "module %s: dangerous " "relocation\n", me->name);
212
213         return -ENOEXEC;
214 }
215
216 static int apply_r_mips_lo16_rela(struct module *me, u32 *location, Elf_Addr v)
217 {
218         *location = (*location & 0xffff0000) | (v & 0xffff);
219
220         return 0;
221 }
222
223 static int apply_r_mips_64_rela(struct module *me, u32 *location, Elf_Addr v)
224 {
225         *(Elf_Addr *)location = v;
226
227         return 0;
228 }
229
230 static int apply_r_mips_higher_rela(struct module *me, u32 *location,
231                                     Elf_Addr v)
232 {
233         *location = (*location & 0xffff0000) |
234                     ((((long long) v + 0x80008000LL) >> 32) & 0xffff);
235
236         return 0;
237 }
238
239 static int apply_r_mips_highest_rela(struct module *me, u32 *location,
240                                      Elf_Addr v)
241 {
242         *location = (*location & 0xffff0000) |
243                     ((((long long) v + 0x800080008000LL) >> 48) & 0xffff);
244
245         return 0;
246 }
247
248 static int (*reloc_handlers_rel[]) (struct module *me, u32 *location,
249                                 Elf_Addr v) = {
250         [R_MIPS_NONE]           = apply_r_mips_none,
251         [R_MIPS_32]             = apply_r_mips_32_rel,
252         [R_MIPS_26]             = apply_r_mips_26_rel,
253         [R_MIPS_HI16]           = apply_r_mips_hi16_rel,
254         [R_MIPS_LO16]           = apply_r_mips_lo16_rel
255 };
256
257 static int (*reloc_handlers_rela[]) (struct module *me, u32 *location,
258                                 Elf_Addr v) = {
259         [R_MIPS_NONE]           = apply_r_mips_none,
260         [R_MIPS_32]             = apply_r_mips_32_rela,
261         [R_MIPS_26]             = apply_r_mips_26_rela,
262         [R_MIPS_HI16]           = apply_r_mips_hi16_rela,
263         [R_MIPS_LO16]           = apply_r_mips_lo16_rela,
264         [R_MIPS_64]             = apply_r_mips_64_rela,
265         [R_MIPS_HIGHER]         = apply_r_mips_higher_rela,
266         [R_MIPS_HIGHEST]        = apply_r_mips_highest_rela
267 };
268
269 int apply_relocate(Elf_Shdr *sechdrs, const char *strtab,
270                    unsigned int symindex, unsigned int relsec,
271                    struct module *me)
272 {
273         Elf_Mips_Rel *rel = (void *) sechdrs[relsec].sh_addr;
274         Elf_Sym *sym;
275         u32 *location;
276         unsigned int i;
277         Elf_Addr v;
278         int res;
279
280         pr_debug("Applying relocate section %u to %u\n", relsec,
281                sechdrs[relsec].sh_info);
282
283         for (i = 0; i < sechdrs[relsec].sh_size / sizeof(*rel); i++) {
284                 /* This is where to make the change */
285                 location = (void *)sechdrs[sechdrs[relsec].sh_info].sh_addr
286                         + rel[i].r_offset;
287                 /* This is the symbol it is referring to */
288                 sym = (Elf_Sym *)sechdrs[symindex].sh_addr
289                         + ELF_MIPS_R_SYM(rel[i]);
290                 if (!sym->st_value) {
291                         printk(KERN_WARNING "%s: Unknown symbol %s\n",
292                                me->name, strtab + sym->st_name);
293                         return -ENOENT;
294                 }
295
296                 v = sym->st_value;
297
298                 res = reloc_handlers_rel[ELF_MIPS_R_TYPE(rel[i])](me, location, v);
299                 if (res)
300                         return res;
301         }
302
303         return 0;
304 }
305
306 int apply_relocate_add(Elf_Shdr *sechdrs, const char *strtab,
307                        unsigned int symindex, unsigned int relsec,
308                        struct module *me)
309 {
310         Elf_Mips_Rela *rel = (void *) sechdrs[relsec].sh_addr;
311         Elf_Sym *sym;
312         u32 *location;
313         unsigned int i;
314         Elf_Addr v;
315         int res;
316
317         pr_debug("Applying relocate section %u to %u\n", relsec,
318                sechdrs[relsec].sh_info);
319
320         for (i = 0; i < sechdrs[relsec].sh_size / sizeof(*rel); i++) {
321                 /* This is where to make the change */
322                 location = (void *)sechdrs[sechdrs[relsec].sh_info].sh_addr
323                         + rel[i].r_offset;
324                 /* This is the symbol it is referring to */
325                 sym = (Elf_Sym *)sechdrs[symindex].sh_addr
326                         + ELF_MIPS_R_SYM(rel[i]);
327                 if (!sym->st_value) {
328                         printk(KERN_WARNING "%s: Unknown symbol %s\n",
329                                me->name, strtab + sym->st_name);
330                         return -ENOENT;
331                 }
332
333                 v = sym->st_value + rel[i].r_addend;
334
335                 res = reloc_handlers_rela[ELF_MIPS_R_TYPE(rel[i])](me, location, v);
336                 if (res)
337                         return res;
338         }
339
340         return 0;
341 }
342
343 /* Given an address, look for it in the module exception tables. */
344 const struct exception_table_entry *search_module_dbetables(unsigned long addr)
345 {
346         unsigned long flags;
347         const struct exception_table_entry *e = NULL;
348         struct mod_arch_specific *dbe;
349
350         spin_lock_irqsave(&dbe_lock, flags);
351         list_for_each_entry(dbe, &dbe_list, dbe_list) {
352                 e = search_extable(dbe->dbe_start, dbe->dbe_end - 1, addr);
353                 if (e)
354                         break;
355         }
356         spin_unlock_irqrestore(&dbe_lock, flags);
357
358         /* Now, if we found one, we are running inside it now, hence
359            we cannot unload the module, hence no refcnt needed. */
360         return e;
361 }
362
363 /* Put in dbe list if neccessary. */
364 int module_finalize(const Elf_Ehdr *hdr,
365                     const Elf_Shdr *sechdrs,
366                     struct module *me)
367 {
368         const Elf_Shdr *s;
369         char *secstrings = (void *)hdr + sechdrs[hdr->e_shstrndx].sh_offset;
370
371         INIT_LIST_HEAD(&me->arch.dbe_list);
372         for (s = sechdrs; s < sechdrs + hdr->e_shnum; s++) {
373                 if (strcmp("__dbe_table", secstrings + s->sh_name) != 0)
374                         continue;
375                 me->arch.dbe_start = (void *)s->sh_addr;
376                 me->arch.dbe_end = (void *)s->sh_addr + s->sh_size;
377                 spin_lock_irq(&dbe_lock);
378                 list_add(&me->arch.dbe_list, &dbe_list);
379                 spin_unlock_irq(&dbe_lock);
380         }
381         return 0;
382 }
383
384 void module_arch_cleanup(struct module *mod)
385 {
386         spin_lock_irq(&dbe_lock);
387         list_del(&mod->arch.dbe_list);
388         spin_unlock_irq(&dbe_lock);
389 }