~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/arch/powerpc/oprofile/cell/vma_map.c

Version: ~ [ linux-5.6-rc3 ] ~ [ linux-5.5.6 ] ~ [ linux-5.4.22 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.106 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.171 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.214 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.214 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.140 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.82 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-3.9.11 ] ~ [ linux-3.8.13 ] ~ [ linux-3.7.10 ] ~ [ linux-3.6.11 ] ~ [ linux-3.5.7 ] ~ [ linux-3.4.113 ] ~ [ linux-3.3.8 ] ~ [ linux-3.2.102 ] ~ [ linux-3.1.10 ] ~ [ linux-3.0.101 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  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 
 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
 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 *
 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.  */
 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 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp