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
27void 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
36unsigned int
37vma_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
67static struct vma_to_fileoffset_map *
68vma_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.  */
95struct 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