/tools/perf/util/probe-event.c

  1/*
  2 * probe-event.c : perf-probe definition to kprobe_events format converter
  3 *
  4 * Written by Masami Hiramatsu <mhiramat@redhat.com>
  5 *
  6 * This program is free software; you can redistribute it and/or modify
  7 * it under the terms of the GNU General Public License as published by
  8 * the Free Software Foundation; either version 2 of the License, or
  9 * (at your option) any later version.
 10 *
 11 * This program is distributed in the hope that it will be useful,
 12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 14 * GNU General Public License for more details.
 15 *
 16 * You should have received a copy of the GNU General Public License
 17 * along with this program; if not, write to the Free Software
 18 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 19 *
 20 */
 21
 22#define _GNU_SOURCE
 23#include <sys/utsname.h>
 24#include <sys/types.h>
 25#include <sys/stat.h>
 26#include <fcntl.h>
 27#include <errno.h>
 28#include <stdio.h>
 29#include <unistd.h>
 30#include <stdlib.h>
 31#include <string.h>
 32#include <stdarg.h>
 33#include <limits.h>
 34
 35#undef _GNU_SOURCE
 36#include "event.h"
 37#include "string.h"
 38#include "strlist.h"
 39#include "debug.h"
 40#include "cache.h"
 41#include "color.h"
 42#include "parse-events.h"  /* For debugfs_path */
 43#include "probe-event.h"
 44
 45#define MAX_CMDLEN 256
 46#define MAX_PROBE_ARGS 128
 47#define PERFPROBE_GROUP "probe"
 48
 49#define semantic_error(msg ...) die("Semantic error :" msg)
 50
 51/* If there is no space to write, returns -E2BIG. */
 52static int e_snprintf(char *str, size_t size, const char *format, ...)
 53	__attribute__((format(printf, 3, 4)));
 54
 55static int e_snprintf(char *str, size_t size, const char *format, ...)
 56{
 57	int ret;
 58	va_list ap;
 59	va_start(ap, format);
 60	ret = vsnprintf(str, size, format, ap);
 61	va_end(ap);
 62	if (ret >= (int)size)
 63		ret = -E2BIG;
 64	return ret;
 65}
 66
 67void parse_line_range_desc(const char *arg, struct line_range *lr)
 68{
 69	const char *ptr;
 70	char *tmp;
 71	/*
 72	 * <Syntax>
 73	 * SRC:SLN[+NUM|-ELN]
 74	 * FUNC[:SLN[+NUM|-ELN]]
 75	 */
 76	ptr = strchr(arg, ':');
 77	if (ptr) {
 78		lr->start = (unsigned int)strtoul(ptr + 1, &tmp, 0);
 79		if (*tmp == '+')
 80			lr->end = lr->start + (unsigned int)strtoul(tmp + 1,
 81								    &tmp, 0);
 82		else if (*tmp == '-')
 83			lr->end = (unsigned int)strtoul(tmp + 1, &tmp, 0);
 84		else
 85			lr->end = 0;
 86		pr_debug("Line range is %u to %u\n", lr->start, lr->end);
 87		if (lr->end && lr->start > lr->end)
 88			semantic_error("Start line must be smaller"
 89				       " than end line.");
 90		if (*tmp != '\0')
 91			semantic_error("Tailing with invalid character '%d'.",
 92				       *tmp);
 93		tmp = strndup(arg, (ptr - arg));
 94	} else
 95		tmp = strdup(arg);
 96
 97	if (strchr(tmp, '.'))
 98		lr->file = tmp;
 99	else
100		lr->function = tmp;
101}
102
103/* Check the name is good for event/group */
104static bool check_event_name(const char *name)
105{
106	if (!isalpha(*name) && *name != '_')
107		return false;
108	while (*++name != '\0') {
109		if (!isalpha(*name) && !isdigit(*name) && *name != '_')
110			return false;
111	}
112	return true;
113}
114
115/* Parse probepoint definition. */
116static void parse_perf_probe_probepoint(char *arg, struct probe_point *pp)
117{
118	char *ptr, *tmp;
119	char c, nc = 0;
120	/*
121	 * <Syntax>
122	 * perf probe [EVENT=]SRC[:LN|;PTN]
123	 * perf probe [EVENT=]FUNC[@SRC][+OFFS|%return|:LN|;PAT]
124	 *
125	 * TODO:Group name support
126	 */
127
128	ptr = strpbrk(arg, ";=@+%");
129	if (ptr && *ptr == '=') {	/* Event name */
130		*ptr = '\0';
131		tmp = ptr + 1;
132		ptr = strchr(arg, ':');
133		if (ptr)	/* Group name is not supported yet. */
134			semantic_error("Group name is not supported yet.");
135		if (!check_event_name(arg))
136			semantic_error("%s is bad for event name -it must "
137				       "follow C symbol-naming rule.", arg);
138		pp->event = strdup(arg);
139		arg = tmp;
140	}
141
142	ptr = strpbrk(arg, ";:+@%");
143	if (ptr) {
144		nc = *ptr;
145		*ptr++ = '\0';
146	}
147
148	/* Check arg is function or file and copy it */
149	if (strchr(arg, '.'))	/* File */
150		pp->file = strdup(arg);
151	else			/* Function */
152		pp->function = strdup(arg);
153	DIE_IF(pp->file == NULL && pp->function == NULL);
154
155	/* Parse other options */
156	while (ptr) {
157		arg = ptr;
158		c = nc;
159		if (c == ';') {	/* Lazy pattern must be the last part */
160			pp->lazy_line = strdup(arg);
161			break;
162		}
163		ptr = strpbrk(arg, ";:+@%");
164		if (ptr) {
165			nc = *ptr;
166			*ptr++ = '\0';
167		}
168		switch (c) {
169		case ':':	/* Line number */
170			pp->line = strtoul(arg, &tmp, 0);
171			if (*tmp != '\0')
172				semantic_error("There is non-digit char"
173					       " in line number.");
174			break;
175		case '+':	/* Byte offset from a symbol */
176			pp->offset = strtoul(arg, &tmp, 0);
177			if (*tmp != '\0')
178				semantic_error("There is non-digit character"
179						" in offset.");
180			break;
181		case '@':	/* File name */
182			if (pp->file)
183				semantic_error("SRC@SRC is not allowed.");
184			pp->file = strdup(arg);
185			DIE_IF(pp->file == NULL);
186			break;
187		case '%':	/* Probe places */
188			if (strcmp(arg, "return") == 0) {
189				pp->retprobe = 1;
190			} else	/* Others not supported yet */
191				semantic_error("%%%s is not supported.", arg);
192			break;
193		default:
194			DIE_IF("Program has a bug.");
195			break;
196		}
197	}
198
199	/* Exclusion check */
200	if (pp->lazy_line && pp->line)
201		semantic_error("Lazy pattern can't be used with line number.");
202
203	if (pp->lazy_line && pp->offset)
204		semantic_error("Lazy pattern can't be used with offset.");
205
206	if (pp->line && pp->offset)
207		semantic_error("Offset can't be used with line number.");
208
209	if (!pp->line && !pp->lazy_line && pp->file && !pp->function)
210		semantic_error("File always requires line number or "
211			       "lazy pattern.");
212
213	if (pp->offset && !pp->function)
214		semantic_error("Offset requires an entry function.");
215
216	if (pp->retprobe && !pp->function)
217		semantic_error("Return probe requires an entry function.");
218
219	if ((pp->offset || pp->line || pp->lazy_line) && pp->retprobe)
220		semantic_error("Offset/Line/Lazy pattern can't be used with "
221			       "return probe.");
222
223	pr_debug("symbol:%s file:%s line:%d offset:%d return:%d lazy:%s\n",
224		 pp->function, pp->file, pp->line, pp->offset, pp->retprobe,
225		 pp->lazy_line);
226}
227
228/* Parse perf-probe event definition */
229void parse_perf_probe_event(const char *str, struct probe_point *pp,
230			    bool *need_dwarf)
231{
232	char **argv;
233	int argc, i;
234
235	*need_dwarf = false;
236
237	argv = argv_split(str, &argc);
238	if (!argv)
239		die("argv_split failed.");
240	if (argc > MAX_PROBE_ARGS + 1)
241		semantic_error("Too many arguments");
242
243	/* Parse probe point */
244	parse_perf_probe_probepoint(argv[0], pp);
245	if (pp->file || pp->line || pp->lazy_line)
246		*need_dwarf = true;
247
248	/* Copy arguments and ensure return probe has no C argument */
249	pp->nr_args = argc - 1;
250	pp->args = zalloc(sizeof(char *) * pp->nr_args);
251	for (i = 0; i < pp->nr_args; i++) {
252		pp->args[i] = strdup(argv[i + 1]);
253		if (!pp->args[i])
254			die("Failed to copy argument.");
255		if (is_c_varname(pp->args[i])) {
256			if (pp->retprobe)
257				semantic_error("You can't specify local"
258						" variable for kretprobe");
259			*need_dwarf = true;
260		}
261	}
262
263	argv_free(argv);
264}
265
266/* Parse kprobe_events event into struct probe_point */
267void parse_trace_kprobe_event(const char *str, struct probe_point *pp)
268{
269	char pr;
270	char *p;
271	int ret, i, argc;
272	char **argv;
273
274	pr_debug("Parsing kprobe_events: %s\n", str);
275	argv = argv_split(str, &argc);
276	if (!argv)
277		die("argv_split failed.");
278	if (argc < 2)
279		semantic_error("Too less arguments.");
280
281	/* Scan event and group name. */
282	ret = sscanf(argv[0], "%c:%a[^/ \t]/%a[^ \t]",
283		     &pr, (float *)(void *)&pp->group,
284		     (float *)(void *)&pp->event);
285	if (ret != 3)
286		semantic_error("Failed to parse event name: %s", argv[0]);
287	pr_debug("Group:%s Event:%s probe:%c\n", pp->group, pp->event, pr);
288
289	pp->retprobe = (pr == 'r');
290
291	/* Scan function name and offset */
292	ret = sscanf(argv[1], "%a[^+]+%d", (float *)(void *)&pp->function,
293		     &pp->offset);
294	if (ret == 1)
295		pp->offset = 0;
296
297	/* kprobe_events doesn't have this information */
298	pp->line = 0;
299	pp->file = NULL;
300
301	pp->nr_args = argc - 2;
302	pp->args = zalloc(sizeof(char *) * pp->nr_args);
303	for (i = 0; i < pp->nr_args; i++) {
304		p = strchr(argv[i + 2], '=');
305		if (p)	/* We don't need which register is assigned. */
306			*p = '\0';
307		pp->args[i] = strdup(argv[i + 2]);
308		if (!pp->args[i])
309			die("Failed to copy argument.");
310	}
311
312	argv_free(argv);
313}
314
315/* Synthesize only probe point (not argument) */
316int synthesize_perf_probe_point(struct probe_point *pp)
317{
318	char *buf;
319	char offs[64] = "", line[64] = "";
320	int ret;
321
322	pp->probes[0] = buf = zalloc(MAX_CMDLEN);
323	pp->found = 1;
324	if (!buf)
325		die("Failed to allocate memory by zalloc.");
326	if (pp->offset) {
327		ret = e_snprintf(offs, 64, "+%d", pp->offset);
328		if (ret <= 0)
329			goto error;
330	}
331	if (pp->line) {
332		ret = e_snprintf(line, 64, ":%d", pp->line);
333		if (ret <= 0)
334			goto error;
335	}
336
337	if (pp->function)
338		ret = e_snprintf(buf, MAX_CMDLEN, "%s%s%s%s", pp->function,
339				 offs, pp->retprobe ? "%return" : "", line);
340	else
341		ret = e_snprintf(buf, MAX_CMDLEN, "%s%s", pp->file, line);
342	if (ret <= 0) {
343error:
344		free(pp->probes[0]);
345		pp->probes[0] = NULL;
346		pp->found = 0;
347	}
348	return ret;
349}
350
351int synthesize_perf_probe_event(struct probe_point *pp)
352{
353	char *buf;
354	int i, len, ret;
355
356	len = synthesize_perf_probe_point(pp);
357	if (len < 0)
358		return 0;
359
360	buf = pp->probes[0];
361	for (i = 0; i < pp->nr_args; i++) {
362		ret = e_snprintf(&buf[len], MAX_CMDLEN - len, " %s",
363				 pp->args[i]);
364		if (ret <= 0)
365			goto error;
366		len += ret;
367	}
368	pp->found = 1;
369
370	return pp->found;
371error:
372	free(pp->probes[0]);
373	pp->probes[0] = NULL;
374
375	return ret;
376}
377
378int synthesize_trace_kprobe_event(struct probe_point *pp)
379{
380	char *buf;
381	int i, len, ret;
382
383	pp->probes[0] = buf = zalloc(MAX_CMDLEN);
384	if (!buf)
385		die("Failed to allocate memory by zalloc.");
386	ret = e_snprintf(buf, MAX_CMDLEN, "%s+%d", pp->function, pp->offset);
387	if (ret <= 0)
388		goto error;
389	len = ret;
390
391	for (i = 0; i < pp->nr_args; i++) {
392		ret = e_snprintf(&buf[len], MAX_CMDLEN - len, " %s",
393				 pp->args[i]);
394		if (ret <= 0)
395			goto error;
396		len += ret;
397	}
398	pp->found = 1;
399
400	return pp->found;
401error:
402	free(pp->probes[0]);
403	pp->probes[0] = NULL;
404
405	return ret;
406}
407
408static int open_kprobe_events(int flags, int mode)
409{
410	char buf[PATH_MAX];
411	int ret;
412
413	ret = e_snprintf(buf, PATH_MAX, "%s/../kprobe_events", debugfs_path);
414	if (ret < 0)
415		die("Failed to make kprobe_events path.");
416
417	ret = open(buf, flags, mode);
418	if (ret < 0) {
419		if (errno == ENOENT)
420			die("kprobe_events file does not exist -"
421			    " please rebuild with CONFIG_KPROBE_EVENT.");
422		else
423			die("Could not open kprobe_events file: %s",
424			    strerror(errno));
425	}
426	return ret;
427}
428
429/* Get raw string list of current kprobe_events */
430static struct strlist *get_trace_kprobe_event_rawlist(int fd)
431{
432	int ret, idx;
433	FILE *fp;
434	char buf[MAX_CMDLEN];
435	char *p;
436	struct strlist *sl;
437
438	sl = strlist__new(true, NULL);
439
440	fp = fdopen(dup(fd), "r");
441	while (!feof(fp)) {
442		p = fgets(buf, MAX_CMDLEN, fp);
443		if (!p)
444			break;
445
446		idx = strlen(p) - 1;
447		if (p[idx] == '\n')
448			p[idx] = '\0';
449		ret = strlist__add(sl, buf);
450		if (ret < 0)
451			die("strlist__add failed: %s", strerror(-ret));
452	}
453	fclose(fp);
454
455	return sl;
456}
457
458/* Free and zero clear probe_point */
459static void clear_probe_point(struct probe_point *pp)
460{
461	int i;
462
463	if (pp->event)
464		free(pp->event);
465	if (pp->group)
466		free(pp->group);
467	if (pp->function)
468		free(pp->function);
469	if (pp->file)
470		free(pp->file);
471	if (pp->lazy_line)
472		free(pp->lazy_line);
473	for (i = 0; i < pp->nr_args; i++)
474		free(pp->args[i]);
475	if (pp->args)
476		free(pp->args);
477	for (i = 0; i < pp->found; i++)
478		free(pp->probes[i]);
479	memset(pp, 0, sizeof(*pp));
480}
481
482/* Show an event */
483static void show_perf_probe_event(const char *event, const char *place,
484				  struct probe_point *pp)
485{
486	int i, ret;
487	char buf[128];
488
489	ret = e_snprintf(buf, 128, "%s:%s", pp->group, event);
490	if (ret < 0)
491		die("Failed to copy event: %s", strerror(-ret));
492	printf("  %-40s (on %s", buf, place);
493
494	if (pp->nr_args > 0) {
495		printf(" with");
496		for (i = 0; i < pp->nr_args; i++)
497			printf(" %s", pp->args[i]);
498	}
499	printf(")\n");
500}
501
502/* List up current perf-probe events */
503void show_perf_probe_events(void)
504{
505	int fd;
506	struct probe_point pp;
507	struct strlist *rawlist;
508	struct str_node *ent;
509
510	setup_pager();
511	memset(&pp, 0, sizeof(pp));
512
513	fd = open_kprobe_events(O_RDONLY, 0);
514	rawlist = get_trace_kprobe_event_rawlist(fd);
515	close(fd);
516
517	strlist__for_each(ent, rawlist) {
518		parse_trace_kprobe_event(ent->s, &pp);
519		/* Synthesize only event probe point */
520		synthesize_perf_probe_point(&pp);
521		/* Show an event */
522		show_perf_probe_event(pp.event, pp.probes[0], &pp);
523		clear_probe_point(&pp);
524	}
525
526	strlist__delete(rawlist);
527}
528
529/* Get current perf-probe event names */
530static struct strlist *get_perf_event_names(int fd, bool include_group)
531{
532	char buf[128];
533	struct strlist *sl, *rawlist;
534	struct str_node *ent;
535	struct probe_point pp;
536
537	memset(&pp, 0, sizeof(pp));
538	rawlist = get_trace_kprobe_event_rawlist(fd);
539
540	sl = strlist__new(true, NULL);
541	strlist__for_each(ent, rawlist) {
542		parse_trace_kprobe_event(ent->s, &pp);
543		if (include_group) {
544			if (e_snprintf(buf, 128, "%s:%s", pp.group,
545				       pp.event) < 0)
546				die("Failed to copy group:event name.");
547			strlist__add(sl, buf);
548		} else
549			strlist__add(sl, pp.event);
550		clear_probe_point(&pp);
551	}
552
553	strlist__delete(rawlist);
554
555	return sl;
556}
557
558static void write_trace_kprobe_event(int fd, const char *buf)
559{
560	int ret;
561
562	pr_debug("Writing event: %s\n", buf);
563	ret = write(fd, buf, strlen(buf));
564	if (ret <= 0)
565		die("Failed to write event: %s", strerror(errno));
566}
567
568static void get_new_event_name(char *buf, size_t len, const char *base,
569			       struct strlist *namelist, bool allow_suffix)
570{
571	int i, ret;
572
573	/* Try no suffix */
574	ret = e_snprintf(buf, len, "%s", base);
575	if (ret < 0)
576		die("snprintf() failed: %s", strerror(-ret));
577	if (!strlist__has_entry(namelist, buf))
578		return;
579
580	if (!allow_suffix) {
581		pr_warning("Error: event \"%s\" already exists. "
582			   "(Use -f to force duplicates.)\n", base);
583		die("Can't add new event.");
584	}
585
586	/* Try to add suffix */
587	for (i = 1; i < MAX_EVENT_INDEX; i++) {
588		ret = e_snprintf(buf, len, "%s_%d", base, i);
589		if (ret < 0)
590			die("snprintf() failed: %s", strerror(-ret));
591		if (!strlist__has_entry(namelist, buf))
592			break;
593	}
594	if (i == MAX_EVENT_INDEX)
595		die("Too many events are on the same function.");
596}
597
598void add_trace_kprobe_events(struct probe_point *probes, int nr_probes,
599			     bool force_add)
600{
601	int i, j, fd;
602	struct probe_point *pp;
603	char buf[MAX_CMDLEN];
604	char event[64];
605	struct strlist *namelist;
606	bool allow_suffix;
607
608	fd = open_kprobe_events(O_RDWR, O_APPEND);
609	/* Get current event names */
610	namelist = get_perf_event_names(fd, false);
611
612	for (j = 0; j < nr_probes; j++) {
613		pp = probes + j;
614		if (!pp->event)
615			pp->event = strdup(pp->function);
616		if (!pp->group)
617			pp->group = strdup(PERFPROBE_GROUP);
618		DIE_IF(!pp->event || !pp->group);
619		/* If force_add is true, suffix search is allowed */
620		allow_suffix = force_add;
621		for (i = 0; i < pp->found; i++) {
622			/* Get an unused new event name */
623			get_new_event_name(event, 64, pp->event, namelist,
624					   allow_suffix);
625			snprintf(buf, MAX_CMDLEN, "%c:%s/%s %s\n",
626				 pp->retprobe ? 'r' : 'p',
627				 pp->group, event,
628				 pp->probes[i]);
629			write_trace_kprobe_event(fd, buf);
630			printf("Added new event:\n");
631			/* Get the first parameter (probe-point) */
632			sscanf(pp->probes[i], "%s", buf);
633			show_perf_probe_event(event, buf, pp);
634			/* Add added event name to namelist */
635			strlist__add(namelist, event);
636			/*
637			 * Probes after the first probe which comes from same
638			 * user input are always allowed to add suffix, because
639			 * there might be several addresses corresponding to
640			 * one code line.
641			 */
642			allow_suffix = true;
643		}
644	}
645	/* Show how to use the event. */
646	printf("\nYou can now use it on all perf tools, such as:\n\n");
647	printf("\tperf record -e %s:%s -a sleep 1\n\n", PERFPROBE_GROUP, event);
648
649	strlist__delete(namelist);
650	close(fd);
651}
652
653static void __del_trace_kprobe_event(int fd, struct str_node *ent)
654{
655	char *p;
656	char buf[128];
657
658	/* Convert from perf-probe event to trace-kprobe event */
659	if (e_snprintf(buf, 128, "-:%s", ent->s) < 0)
660		die("Failed to copy event.");
661	p = strchr(buf + 2, ':');
662	if (!p)
663		die("Internal error: %s should have ':' but not.", ent->s);
664	*p = '/';
665
666	write_trace_kprobe_event(fd, buf);
667	printf("Remove event: %s\n", ent->s);
668}
669
670static void del_trace_kprobe_event(int fd, const char *group,
671				   const char *event, struct strlist *namelist)
672{
673	char buf[128];
674	struct str_node *ent, *n;
675	int found = 0;
676
677	if (e_snprintf(buf, 128, "%s:%s", group, event) < 0)
678		die("Failed to copy event.");
679
680	if (strpbrk(buf, "*?")) { /* Glob-exp */
681		strlist__for_each_safe(ent, n, namelist)
682			if (strglobmatch(ent->s, buf)) {
683				found++;
684				__del_trace_kprobe_event(fd, ent);
685				strlist__remove(namelist, ent);
686			}
687	} else {
688		ent = strlist__find(namelist, buf);
689		if (ent) {
690			found++;
691			__del_trace_kprobe_event(fd, ent);
692			strlist__remove(namelist, ent);
693		}
694	}
695	if (found == 0)
696		pr_info("Info: event \"%s\" does not exist, could not remove it.\n", buf);
697}
698
699void del_trace_kprobe_events(struct strlist *dellist)
700{
701	int fd;
702	const char *group, *event;
703	char *p, *str;
704	struct str_node *ent;
705	struct strlist *namelist;
706
707	fd = open_kprobe_events(O_RDWR, O_APPEND);
708	/* Get current event names */
709	namelist = get_perf_event_names(fd, true);
710
711	strlist__for_each(ent, dellist) {
712		str = strdup(ent->s);
713		if (!str)
714			die("Failed to copy event.");
715		pr_debug("Parsing: %s\n", str);
716		p = strchr(str, ':');
717		if (p) {
718			group = str;
719			*p = '\0';
720			event = p + 1;
721		} else {
722			group = "*";
723			event = str;
724		}
725		pr_debug("Group: %s, Event: %s\n", group, event);
726		del_trace_kprobe_event(fd, group, event, namelist);
727		free(str);
728	}
729	strlist__delete(namelist);
730	close(fd);
731}
732
733#define LINEBUF_SIZE 256
734#define NR_ADDITIONAL_LINES 2
735
736static void show_one_line(FILE *fp, unsigned int l, bool skip, bool show_num)
737{
738	char buf[LINEBUF_SIZE];
739	const char *color = PERF_COLOR_BLUE;
740
741	if (fgets(buf, LINEBUF_SIZE, fp) == NULL)
742		goto error;
743	if (!skip) {
744		if (show_num)
745			fprintf(stdout, "%7u  %s", l, buf);
746		else
747			color_fprintf(stdout, color, "         %s", buf);
748	}
749
750	while (strlen(buf) == LINEBUF_SIZE - 1 &&
751	       buf[LINEBUF_SIZE - 2] != '\n') {
752		if (fgets(buf, LINEBUF_SIZE, fp) == NULL)
753			goto error;
754		if (!skip) {
755			if (show_num)
756				fprintf(stdout, "%s", buf);
757			else
758				color_fprintf(stdout, color, "%s", buf);
759		}
760	}
761	return;
762error:
763	if (feof(fp))
764		die("Source file is shorter than expected.");
765	else
766		die("File read error: %s", strerror(errno));
767}
768
769void show_line_range(struct line_range *lr)
770{
771	unsigned int l = 1;
772	struct line_node *ln;
773	FILE *fp;
774
775	setup_pager();
776
777	if (lr->function)
778		fprintf(stdout, "<%s:%d>\n", lr->function,
779			lr->start - lr->offset);
780	else
781		fprintf(stdout, "<%s:%d>\n", lr->file, lr->start);
782
783	fp = fopen(lr->path, "r");
784	if (fp == NULL)
785		die("Failed to open %s: %s", lr->path, strerror(errno));
786	/* Skip to starting line number */
787	while (l < lr->start)
788		show_one_line(fp, l++, true, false);
789
790	list_for_each_entry(ln, &lr->line_list, list) {
791		while (ln->line > l)
792			show_one_line(fp, (l++) - lr->offset, false, false);
793		show_one_line(fp, (l++) - lr->offset, false, true);
794	}
795
796	if (lr->end == INT_MAX)
797		lr->end = l + NR_ADDITIONAL_LINES;
798	while (l < lr->end && !feof(fp))
799		show_one_line(fp, (l++) - lr->offset, false, false);
800
801	fclose(fp);
802}