arch/powerpc/oprofile/cell/vma_map.c

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