1 /*
2 * Cell Broadband Engine OProfile Support
3 *
4 * (C) Copyright IBM Corporation 2006
5 *
6 * Author: Maynard Johnson <maynardj@us.ibm.com>
7 *
8 * This program is free software; you can redistribute it and/or
9 * modify it under the terms of the GNU General Public License
10 * as published by the Free Software Foundation; either version
11 * 2 of the License, or (at your option) any later version.
12 */
13
14 /* The code in this source file is responsible for generating
15 * vma-to-fileOffset maps for both overlay and non-overlay SPU
16 * applications.
17 */
18
19 #include <linux/mm.h>
20 #include <linux/string.h>
21 #include <linux/uaccess.h>
22 #include <linux/elf.h>
23 #include <linux/slab.h>
24 #include "pr_util.h"
25
26
vma_map_free(struct vma_to_fileoffset_map * map)27 void vma_map_free(struct vma_to_fileoffset_map *map)
28 {
29 while (map) {
30 struct vma_to_fileoffset_map *next = map->next;
31 kfree(map);
32 map = next;
33 }
34 }
35
36 unsigned int
vma_map_lookup(struct vma_to_fileoffset_map * map,unsigned int vma,const struct spu * aSpu,int * grd_val)37 vma_map_lookup(struct vma_to_fileoffset_map *map, unsigned int vma,
38 const struct spu *aSpu, int *grd_val)
39 {
40 /*
41 * Default the offset to the physical address + a flag value.
42 * Addresses of dynamically generated code can't be found in the vma
43 * map. For those addresses the flagged value will be sent on to
44 * the user space tools so they can be reported rather than just
45 * thrown away.
46 */
47 u32 offset = 0x10000000 + vma;
48 u32 ovly_grd;
49
50 for (; map; map = map->next) {
51 if (vma < map->vma || vma >= map->vma + map->size)
52 continue;
53
54 if (map->guard_ptr) {
55 ovly_grd = *(u32 *)(aSpu->local_store + map->guard_ptr);
56 if (ovly_grd != map->guard_val)
57 continue;
58 *grd_val = ovly_grd;
59 }
60 offset = vma - map->vma + map->offset;
61 break;
62 }
63
64 return offset;
65 }
66
67 static struct vma_to_fileoffset_map *
vma_map_add(struct vma_to_fileoffset_map * map,unsigned int vma,unsigned int size,unsigned int offset,unsigned int guard_ptr,unsigned int guard_val)68 vma_map_add(struct vma_to_fileoffset_map *map, unsigned int vma,
69 unsigned int size, unsigned int offset, unsigned int guard_ptr,
70 unsigned int guard_val)
71 {
72 struct vma_to_fileoffset_map *new =
73 kzalloc(sizeof(struct vma_to_fileoffset_map), GFP_KERNEL);
74 if (!new) {
75 printk(KERN_ERR "SPU_PROF: %s, line %d: malloc failed\n",
76 __func__, __LINE__);
77 vma_map_free(map);
78 return NULL;
79 }
80
81 new->next = map;
82 new->vma = vma;
83 new->size = size;
84 new->offset = offset;
85 new->guard_ptr = guard_ptr;
86 new->guard_val = guard_val;
87
88 return new;
89 }
90
91
92 /* Parse SPE ELF header and generate a list of vma_maps.
93 * A pointer to the first vma_map in the generated list
94 * of vma_maps is returned. */
create_vma_map(const struct spu * aSpu,unsigned long __spu_elf_start)95 struct vma_to_fileoffset_map *create_vma_map(const struct spu *aSpu,
96 unsigned long __spu_elf_start)
97 {
98 static const unsigned char expected[EI_PAD] = {
99 [EI_MAG0] = ELFMAG0,
100 [EI_MAG1] = ELFMAG1,
101 [EI_MAG2] = ELFMAG2,
102 [EI_MAG3] = ELFMAG3,
103 [EI_CLASS] = ELFCLASS32,
104 [EI_DATA] = ELFDATA2MSB,
105 [EI_VERSION] = EV_CURRENT,
106 [EI_OSABI] = ELFOSABI_NONE
107 };
108
109 int grd_val;
110 struct vma_to_fileoffset_map *map = NULL;
111 void __user *spu_elf_start = (void __user *)__spu_elf_start;
112 struct spu_overlay_info ovly;
113 unsigned int overlay_tbl_offset = -1;
114 Elf32_Phdr __user *phdr_start;
115 Elf32_Shdr __user *shdr_start;
116 Elf32_Ehdr ehdr;
117 Elf32_Phdr phdr;
118 Elf32_Shdr shdr, shdr_str;
119 Elf32_Sym sym;
120 int i, j;
121 char name[32];
122
123 unsigned int ovly_table_sym = 0;
124 unsigned int ovly_buf_table_sym = 0;
125 unsigned int ovly_table_end_sym = 0;
126 unsigned int ovly_buf_table_end_sym = 0;
127 struct spu_overlay_info __user *ovly_table;
128 unsigned int n_ovlys;
129
130 /* Get and validate ELF header. */
131
132 if (copy_from_user(&ehdr, spu_elf_start, sizeof (ehdr)))
133 goto fail;
134
135 if (memcmp(ehdr.e_ident, expected, EI_PAD) != 0) {
136 printk(KERN_ERR "SPU_PROF: "
137 "%s, line %d: Unexpected e_ident parsing SPU ELF\n",
138 __func__, __LINE__);
139 goto fail;
140 }
141 if (ehdr.e_machine != EM_SPU) {
142 printk(KERN_ERR "SPU_PROF: "
143 "%s, line %d: Unexpected e_machine parsing SPU ELF\n",
144 __func__, __LINE__);
145 goto fail;
146 }
147 if (ehdr.e_type != ET_EXEC) {
148 printk(KERN_ERR "SPU_PROF: "
149 "%s, line %d: Unexpected e_type parsing SPU ELF\n",
150 __func__, __LINE__);
151 goto fail;
152 }
153 phdr_start = spu_elf_start + ehdr.e_phoff;
154 shdr_start = spu_elf_start + ehdr.e_shoff;
155
156 /* Traverse program headers. */
157 for (i = 0; i < ehdr.e_phnum; i++) {
158 if (copy_from_user(&phdr, phdr_start + i, sizeof(phdr)))
159 goto fail;
160
161 if (phdr.p_type != PT_LOAD)
162 continue;
163 if (phdr.p_flags & (1 << 27))
164 continue;
165
166 map = vma_map_add(map, phdr.p_vaddr, phdr.p_memsz,
167 phdr.p_offset, 0, 0);
168 if (!map)
169 goto fail;
170 }
171
172 pr_debug("SPU_PROF: Created non-overlay maps\n");
173 /* Traverse section table and search for overlay-related symbols. */
174 for (i = 0; i < ehdr.e_shnum; i++) {
175 if (copy_from_user(&shdr, shdr_start + i, sizeof(shdr)))
176 goto fail;
177
178 if (shdr.sh_type != SHT_SYMTAB)
179 continue;
180 if (shdr.sh_entsize != sizeof (sym))
181 continue;
182
183 if (copy_from_user(&shdr_str,
184 shdr_start + shdr.sh_link,
185 sizeof(shdr)))
186 goto fail;
187
188 if (shdr_str.sh_type != SHT_STRTAB)
189 goto fail;
190
191 for (j = 0; j < shdr.sh_size / sizeof (sym); j++) {
192 if (copy_from_user(&sym, spu_elf_start +
193 shdr.sh_offset +
194 j * sizeof (sym),
195 sizeof (sym)))
196 goto fail;
197
198 if (copy_from_user(name,
199 spu_elf_start + shdr_str.sh_offset +
200 sym.st_name,
201 20))
202 goto fail;
203
204 if (memcmp(name, "_ovly_table", 12) == 0)
205 ovly_table_sym = sym.st_value;
206 if (memcmp(name, "_ovly_buf_table", 16) == 0)
207 ovly_buf_table_sym = sym.st_value;
208 if (memcmp(name, "_ovly_table_end", 16) == 0)
209 ovly_table_end_sym = sym.st_value;
210 if (memcmp(name, "_ovly_buf_table_end", 20) == 0)
211 ovly_buf_table_end_sym = sym.st_value;
212 }
213 }
214
215 /* If we don't have overlays, we're done. */
216 if (ovly_table_sym == 0 || ovly_buf_table_sym == 0
217 || ovly_table_end_sym == 0 || ovly_buf_table_end_sym == 0) {
218 pr_debug("SPU_PROF: No overlay table found\n");
219 goto out;
220 } else {
221 pr_debug("SPU_PROF: Overlay table found\n");
222 }
223
224 /* The _ovly_table symbol represents a table with one entry
225 * per overlay section. The _ovly_buf_table symbol represents
226 * a table with one entry per overlay region.
227 * The struct spu_overlay_info gives the structure of the _ovly_table
228 * entries. The structure of _ovly_table_buf is simply one
229 * u32 word per entry.
230 */
231 overlay_tbl_offset = vma_map_lookup(map, ovly_table_sym,
232 aSpu, &grd_val);
233 if (overlay_tbl_offset > 0x10000000) {
234 printk(KERN_ERR "SPU_PROF: "
235 "%s, line %d: Error finding SPU overlay table\n",
236 __func__, __LINE__);
237 goto fail;
238 }
239 ovly_table = spu_elf_start + overlay_tbl_offset;
240
241 n_ovlys = (ovly_table_end_sym -
242 ovly_table_sym) / sizeof (ovly);
243
244 /* Traverse overlay table. */
245 for (i = 0; i < n_ovlys; i++) {
246 if (copy_from_user(&ovly, ovly_table + i, sizeof (ovly)))
247 goto fail;
248
249 /* The ovly.vma/size/offset arguments are analogous to the same
250 * arguments used above for non-overlay maps. The final two
251 * args are referred to as the guard pointer and the guard
252 * value.
253 * The guard pointer is an entry in the _ovly_buf_table,
254 * computed using ovly.buf as the index into the table. Since
255 * ovly.buf values begin at '1' to reference the first (or 0th)
256 * entry in the _ovly_buf_table, the computation subtracts 1
257 * from ovly.buf.
258 * The guard value is stored in the _ovly_buf_table entry and
259 * is an index (starting at 1) back to the _ovly_table entry
260 * that is pointing at this _ovly_buf_table entry. So, for
261 * example, for an overlay scenario with one overlay segment
262 * and two overlay sections:
263 * - Section 1 points to the first entry of the
264 * _ovly_buf_table, which contains a guard value
265 * of '1', referencing the first (index=0) entry of
266 * _ovly_table.
267 * - Section 2 points to the second entry of the
268 * _ovly_buf_table, which contains a guard value
269 * of '2', referencing the second (index=1) entry of
270 * _ovly_table.
271 */
272 map = vma_map_add(map, ovly.vma, ovly.size, ovly.offset,
273 ovly_buf_table_sym + (ovly.buf-1) * 4, i+1);
274 if (!map)
275 goto fail;
276 }
277 goto out;
278
279 fail:
280 map = NULL;
281 out:
282 return map;
283 }
284