LXR linux/tools/perf/util/srccode.c

   1// SPDX-License-Identifier: GPL-2.0-only
   2/*
   3 * Manage printing of source lines
   4 * Copyright (c) 2017, Intel Corporation.
   5 * Author: Andi Kleen
   6 */
   7#include <linux/list.h>
   8#include <linux/zalloc.h>
   9#include <stdlib.h>
  10#include <sys/mman.h>
  11#include <sys/stat.h>
  12#include <fcntl.h>
  13#include <unistd.h>
  14#include <assert.h>
  15#include <string.h>
  16#include "srccode.h"
  17#include "debug.h"
  18#include <internal/lib.h> // page_size
  19#include "fncache.h"
  20
  21#define MAXSRCCACHE (32*1024*1024)
  22#define MAXSRCFILES     64
  23#define SRC_HTAB_SZ     64
  24
  25struct srcfile {
  26        struct hlist_node hash_nd;
  27        struct list_head nd;
  28        char *fn;
  29        char **lines;
  30        char *map;
  31        unsigned numlines;
  32        size_t maplen;
  33};
  34
  35static struct hlist_head srcfile_htab[SRC_HTAB_SZ];
  36static LIST_HEAD(srcfile_list);
  37static long map_total_sz;
  38static int num_srcfiles;
  39
  40static int countlines(char *map, int maplen)
  41{
  42        int numl;
  43        char *end = map + maplen;
  44        char *p = map;
  45
  46        if (maplen == 0)
  47                return 0;
  48        numl = 0;
  49        while (p < end && (p = memchr(p, '\n', end - p)) != NULL) {
  50                numl++;
  51                p++;
  52        }
  53        if (p < end)
  54                numl++;
  55        return numl;
  56}
  57
  58static void fill_lines(char **lines, int maxline, char *map, int maplen)
  59{
  60        int l;
  61        char *end = map + maplen;
  62        char *p = map;
  63
  64        if (maplen == 0 || maxline == 0)
  65                return;
  66        l = 0;
  67        lines[l++] = map;
  68        while (p < end && (p = memchr(p, '\n', end - p)) != NULL) {
  69                if (l >= maxline)
  70                        return;
  71                lines[l++] = ++p;
  72        }
  73        if (p < end)
  74                lines[l] = p;
  75}
  76
  77static void free_srcfile(struct srcfile *sf)
  78{
  79        list_del_init(&sf->nd);
  80        hlist_del(&sf->hash_nd);
  81        map_total_sz -= sf->maplen;
  82        munmap(sf->map, sf->maplen);
  83        zfree(&sf->lines);
  84        zfree(&sf->fn);
  85        free(sf);
  86        num_srcfiles--;
  87}
  88
  89static struct srcfile *find_srcfile(char *fn)
  90{
  91        struct stat st;
  92        struct srcfile *h;
  93        int fd;
  94        unsigned long sz;
  95        unsigned hval = shash((unsigned char *)fn) % SRC_HTAB_SZ;
  96
  97        hlist_for_each_entry (h, &srcfile_htab[hval], hash_nd) {
  98                if (!strcmp(fn, h->fn)) {
  99                        /* Move to front */
 100                        list_del(&h->nd);
 101                        list_add(&h->nd, &srcfile_list);
 102                        return h;
 103                }
 104        }
 105
 106        /* Only prune if there is more than one entry */
 107        while ((num_srcfiles > MAXSRCFILES || map_total_sz > MAXSRCCACHE) &&
 108               srcfile_list.next != &srcfile_list) {
 109                assert(!list_empty(&srcfile_list));
 110                h = list_entry(srcfile_list.prev, struct srcfile, nd);
 111                free_srcfile(h);
 112        }
 113
 114        fd = open(fn, O_RDONLY);
 115        if (fd < 0 || fstat(fd, &st) < 0) {
 116                pr_debug("cannot open source file %s\n", fn);
 117                return NULL;
 118        }
 119
 120        h = malloc(sizeof(struct srcfile));
 121        if (!h)
 122                return NULL;
 123
 124        h->fn = strdup(fn);
 125        if (!h->fn)
 126                goto out_h;
 127
 128        h->maplen = st.st_size;
 129        sz = (h->maplen + page_size - 1) & ~(page_size - 1);
 130        h->map = mmap(NULL, sz, PROT_READ, MAP_SHARED, fd, 0);
 131        close(fd);
 132        if (h->map == (char *)-1) {
 133                pr_debug("cannot mmap source file %s\n", fn);
 134                goto out_fn;
 135        }
 136        h->numlines = countlines(h->map, h->maplen);
 137        h->lines = calloc(h->numlines, sizeof(char *));
 138        if (!h->lines)
 139                goto out_map;
 140        fill_lines(h->lines, h->numlines, h->map, h->maplen);
 141        list_add(&h->nd, &srcfile_list);
 142        hlist_add_head(&h->hash_nd, &srcfile_htab[hval]);
 143        map_total_sz += h->maplen;
 144        num_srcfiles++;
 145        return h;
 146
 147out_map:
 148        munmap(h->map, sz);
 149out_fn:
 150        zfree(&h->fn);
 151out_h:
 152        free(h);
 153        return NULL;
 154}
 155
 156/* Result is not 0 terminated */
 157char *find_sourceline(char *fn, unsigned line, int *lenp)
 158{
 159        char *l, *p;
 160        struct srcfile *sf = find_srcfile(fn);
 161        if (!sf)
 162                return NULL;
 163        line--;
 164        if (line >= sf->numlines)
 165                return NULL;
 166        l = sf->lines[line];
 167        if (!l)
 168                return NULL;
 169        p = memchr(l, '\n', sf->map + sf->maplen - l);
 170        *lenp = p - l;
 171        return l;
 172}
 173