1/*
  2 * sampleip: sample instruction pointer and frequency count in a BPF map.
  3 *
  4 * Copyright 2016 Netflix, Inc.
  5 *
  6 * This program is free software; you can redistribute it and/or
  7 * modify it under the terms of version 2 of the GNU General Public
  8 * License as published by the Free Software Foundation.
  9 */
 10#include <stdio.h>
 11#include <stdlib.h>
 12#include <stdio.h>
 13#include <unistd.h>
 14#include <errno.h>
 15#include <signal.h>
 16#include <string.h>
 17#include <assert.h>
 18#include <linux/perf_event.h>
 19#include <linux/ptrace.h>
 20#include <linux/bpf.h>
 21#include <sys/ioctl.h>
 22#include "libbpf.h"
 23#include "bpf_load.h"
 24#include "perf-sys.h"
 25
 26#define DEFAULT_FREQ	99
 27#define DEFAULT_SECS	5
 28#define MAX_IPS		8192
 29#define PAGE_OFFSET	0xffff880000000000
 30
 31static int nr_cpus;
 32
 33static void usage(void)
 34{
 35	printf("USAGE: sampleip [-F freq] [duration]\n");
 36	printf("       -F freq    # sample frequency (Hertz), default 99\n");
 37	printf("       duration   # sampling duration (seconds), default 5\n");
 38}
 39
 40static int sampling_start(int *pmu_fd, int freq)
 41{
 42	int i;
 43
 44	struct perf_event_attr pe_sample_attr = {
 45		.type = PERF_TYPE_SOFTWARE,
 46		.freq = 1,
 47		.sample_period = freq,
 48		.config = PERF_COUNT_SW_CPU_CLOCK,
 49		.inherit = 1,
 50	};
 51
 52	for (i = 0; i < nr_cpus; i++) {
 53		pmu_fd[i] = sys_perf_event_open(&pe_sample_attr, -1 /* pid */, i,
 54					    -1 /* group_fd */, 0 /* flags */);
 55		if (pmu_fd[i] < 0) {
 56			fprintf(stderr, "ERROR: Initializing perf sampling\n");
 57			return 1;
 58		}
 59		assert(ioctl(pmu_fd[i], PERF_EVENT_IOC_SET_BPF,
 60			     prog_fd[0]) == 0);
 61		assert(ioctl(pmu_fd[i], PERF_EVENT_IOC_ENABLE, 0) == 0);
 62	}
 63
 64	return 0;
 65}
 66
 67static void sampling_end(int *pmu_fd)
 68{
 69	int i;
 70
 71	for (i = 0; i < nr_cpus; i++)
 72		close(pmu_fd[i]);
 73}
 74
 75struct ipcount {
 76	__u64 ip;
 77	__u32 count;
 78};
 79
 80/* used for sorting */
 81struct ipcount counts[MAX_IPS];
 82
 83static int count_cmp(const void *p1, const void *p2)
 84{
 85	return ((struct ipcount *)p1)->count - ((struct ipcount *)p2)->count;
 86}
 87
 88static void print_ip_map(int fd)
 89{
 90	struct ksym *sym;
 91	__u64 key, next_key;
 92	__u32 value;
 93	int i, max;
 94
 95	printf("%-19s %-32s %s\n", "ADDR", "KSYM", "COUNT");
 96
 97	/* fetch IPs and counts */
 98	key = 0, i = 0;
 99	while (bpf_map_get_next_key(fd, &key, &next_key) == 0) {
100		bpf_map_lookup_elem(fd, &next_key, &value);
101		counts[i].ip = next_key;
102		counts[i++].count = value;
103		key = next_key;
104	}
105	max = i;
106
107	/* sort and print */
108	qsort(counts, max, sizeof(struct ipcount), count_cmp);
109	for (i = 0; i < max; i++) {
110		if (counts[i].ip > PAGE_OFFSET) {
111			sym = ksym_search(counts[i].ip);
112			printf("0x%-17llx %-32s %u\n", counts[i].ip, sym->name,
113			       counts[i].count);
114		} else {
115			printf("0x%-17llx %-32s %u\n", counts[i].ip, "(user)",
116			       counts[i].count);
117		}
118	}
119
120	if (max == MAX_IPS) {
121		printf("WARNING: IP hash was full (max %d entries); ", max);
122		printf("may have dropped samples\n");
123	}
124}
125
126static void int_exit(int sig)
127{
128	printf("\n");
129	print_ip_map(map_fd[0]);
130	exit(0);
131}
132
133int main(int argc, char **argv)
134{
135	char filename[256];
136	int *pmu_fd, opt, freq = DEFAULT_FREQ, secs = DEFAULT_SECS;
137
138	/* process arguments */
139	while ((opt = getopt(argc, argv, "F:h")) != -1) {
140		switch (opt) {
141		case 'F':
142			freq = atoi(optarg);
143			break;
144		case 'h':
145		default:
146			usage();
147			return 0;
148		}
149	}
150	if (argc - optind == 1)
151		secs = atoi(argv[optind]);
152	if (freq == 0 || secs == 0) {
153		usage();
154		return 1;
155	}
156
157	/* initialize kernel symbol translation */
158	if (load_kallsyms()) {
159		fprintf(stderr, "ERROR: loading /proc/kallsyms\n");
160		return 2;
161	}
162
163	/* create perf FDs for each CPU */
164	nr_cpus = sysconf(_SC_NPROCESSORS_CONF);
165	pmu_fd = malloc(nr_cpus * sizeof(int));
166	if (pmu_fd == NULL) {
167		fprintf(stderr, "ERROR: malloc of pmu_fd\n");
168		return 1;
169	}
170
171	/* load BPF program */
172	snprintf(filename, sizeof(filename), "%s_kern.o", argv[0]);
173	if (load_bpf_file(filename)) {
174		fprintf(stderr, "ERROR: loading BPF program (errno %d):\n",
175			errno);
176		if (strcmp(bpf_log_buf, "") == 0)
177			fprintf(stderr, "Try: ulimit -l unlimited\n");
178		else
179			fprintf(stderr, "%s", bpf_log_buf);
180		return 1;
181	}
182	signal(SIGINT, int_exit);
183
184	/* do sampling */
185	printf("Sampling at %d Hertz for %d seconds. Ctrl-C also ends.\n",
186	       freq, secs);
187	if (sampling_start(pmu_fd, freq) != 0)
188		return 1;
189	sleep(secs);
190	sampling_end(pmu_fd);
191	free(pmu_fd);
192
193	/* output sample counts */
194	print_ip_map(map_fd[0]);
195
196	return 0;
197}