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