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