[linux-2.6-block.git] / samples / bpf / tracex2_user.c

// SPDX-License-Identifier: GPL-2.0
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <signal.h>
#include <string.h>
#include <sys/resource.h>

#include <bpf/bpf.h>
#include <bpf/libbpf.h>
#include "bpf_util.h"

#define MAX_INDEX	64
#define MAX_STARS	38

/* my_map, my_hist_map */
static int map_fd[2];

static void stars(char *str, long val, long max, int width)
{
	int i;

	for (i = 0; i < (width * val / max) - 1 && i < width - 1; i++)
		str[i] = '*';
	if (val > max)
		str[i - 1] = '+';
	str[i] = '\0';
}

struct task {
	char comm[16];
	__u64 pid_tgid;
	__u64 uid_gid;
};

struct hist_key {
	struct task t;
	__u32 index;
};

#define SIZE sizeof(struct task)

static void print_hist_for_pid(int fd, void *task)
{
	unsigned int nr_cpus = bpf_num_possible_cpus();
	struct hist_key key = {}, next_key;
	long values[nr_cpus];
	char starstr[MAX_STARS];
	long value;
	long data[MAX_INDEX] = {};
	int max_ind = -1;
	long max_value = 0;
	int i, ind;

	while (bpf_map_get_next_key(fd, &key, &next_key) == 0) {
		if (memcmp(&next_key, task, SIZE)) {
			key = next_key;
			continue;
		}
		bpf_map_lookup_elem(fd, &next_key, values);
		value = 0;
		for (i = 0; i < nr_cpus; i++)
			value += values[i];
		ind = next_key.index;
		data[ind] = value;
		if (value && ind > max_ind)
			max_ind = ind;
		if (value > max_value)
			max_value = value;
		key = next_key;
	}

	printf("           syscall write() stats\n");
	printf("     byte_size       : count     distribution\n");
	for (i = 1; i <= max_ind + 1; i++) {
		stars(starstr, data[i - 1], max_value, MAX_STARS);
		printf("%8ld -> %-8ld : %-8ld |%-*s|\n",
		       (1l << i) >> 1, (1l << i) - 1, data[i - 1],
		       MAX_STARS, starstr);
	}
}

static void print_hist(int fd)
{
	struct hist_key key = {}, next_key;
	static struct task tasks[1024];
	int task_cnt = 0;
	int i;

	while (bpf_map_get_next_key(fd, &key, &next_key) == 0) {
		int found = 0;

		for (i = 0; i < task_cnt; i++)
			if (memcmp(&tasks[i], &next_key, SIZE) == 0)
				found = 1;
		if (!found)
			memcpy(&tasks[task_cnt++], &next_key, SIZE);
		key = next_key;
	}

	for (i = 0; i < task_cnt; i++) {
		printf("\npid %d cmd %s uid %d\n",
		       (__u32) tasks[i].pid_tgid,
		       tasks[i].comm,
		       (__u32) tasks[i].uid_gid);
		print_hist_for_pid(fd, &tasks[i]);
	}

}

static void int_exit(int sig)
{
	print_hist(map_fd[1]);
	exit(0);
}

int main(int ac, char **argv)
{
	long key, next_key, value;
	struct bpf_link *links[2];
	struct bpf_program *prog;
	struct bpf_object *obj;
	char filename[256];
	int i, j = 0;
	FILE *f;

	snprintf(filename, sizeof(filename), "%s_kern.o", argv[0]);
	obj = bpf_object__open_file(filename, NULL);
	if (libbpf_get_error(obj)) {
		fprintf(stderr, "ERROR: opening BPF object file failed\n");
		return 0;
	}

	/* load BPF program */
	if (bpf_object__load(obj)) {
		fprintf(stderr, "ERROR: loading BPF object file failed\n");
		goto cleanup;
	}

	map_fd[0] = bpf_object__find_map_fd_by_name(obj, "my_map");
	map_fd[1] = bpf_object__find_map_fd_by_name(obj, "my_hist_map");
	if (map_fd[0] < 0 || map_fd[1] < 0) {
		fprintf(stderr, "ERROR: finding a map in obj file failed\n");
		goto cleanup;
	}

	signal(SIGINT, int_exit);
	signal(SIGTERM, int_exit);

	/* start 'ping' in the background to have some kfree_skb events */
	f = popen("ping -4 -c5 localhost", "r");
	(void) f;

	/* start 'dd' in the background to have plenty of 'write' syscalls */
	f = popen("dd if=/dev/zero of=/dev/null count=5000000", "r");
	(void) f;

	bpf_object__for_each_program(prog, obj) {
		links[j] = bpf_program__attach(prog);
		if (libbpf_get_error(links[j])) {
			fprintf(stderr, "ERROR: bpf_program__attach failed\n");
			links[j] = NULL;
			goto cleanup;
		}
		j++;
	}

	for (i = 0; i < 5; i++) {
		key = 0;
		while (bpf_map_get_next_key(map_fd[0], &key, &next_key) == 0) {
			bpf_map_lookup_elem(map_fd[0], &next_key, &value);
			printf("location 0x%lx count %ld\n", next_key, value);
			key = next_key;
		}
		if (key)
			printf("\n");
		sleep(1);
	}
	print_hist(map_fd[1]);

cleanup:
	for (j--; j >= 0; j--)
		bpf_link__destroy(links[j]);

	bpf_object__close(obj);
	return 0;
}
Commit	Line	Data
b2441318	1	// SPDX-License-Identifier: GPL-2.0
d822a192 AS	2	#include <stdio.h>
	3	#include <unistd.h>
	4	#include <stdlib.h>
	5	#include <signal.h>
ffeedafb	6	#include <string.h>
55de1703	7	#include <sys/resource.h>
e00c7b21	8
2bf3e2ef	9	#include <bpf/bpf.h>
63841bc0	10	#include <bpf/libbpf.h>
e00c7b21	11	#include "bpf_util.h"
d822a192 AS	12
	13	#define MAX_INDEX 64
	14	#define MAX_STARS 38
	15
63841bc0 DL	16	/* my_map, my_hist_map */
	17	static int map_fd[2];
	18
d822a192 AS	19	static void stars(char *str, long val, long max, int width)
	20	{
	21	int i;
	22
	23	for (i = 0; i < (width * val / max) - 1 && i < width - 1; i++)
	24	str[i] = '*';
	25	if (val > max)
	26	str[i - 1] = '+';
	27	str[i] = '\0';
	28	}
	29
ffeedafb AS	30	struct task {
	31	char comm[16];
	32	__u64 pid_tgid;
	33	__u64 uid_gid;
	34	};
	35
	36	struct hist_key {
	37	struct task t;
	38	__u32 index;
	39	};
	40
	41	#define SIZE sizeof(struct task)
	42
	43	static void print_hist_for_pid(int fd, void *task)
d822a192	44	{
e00c7b21	45	unsigned int nr_cpus = bpf_num_possible_cpus();
ffeedafb	46	struct hist_key key = {}, next_key;
3059303f	47	long values[nr_cpus];
ffeedafb	48	char starstr[MAX_STARS];
d822a192 AS	49	long value;
d822a192 AS	50	long data[MAX_INDEX] = {};
d822a192 AS	51	int max_ind = -1;
d822a192 AS	52	long max_value = 0;
ffeedafb	53	int i, ind;
d822a192	54
d40fc181	55	while (bpf_map_get_next_key(fd, &key, &next_key) == 0) {
ffeedafb AS	56	if (memcmp(&next_key, task, SIZE)) {
	57	key = next_key;
	58	continue;
	59	}
d40fc181	60	bpf_map_lookup_elem(fd, &next_key, values);
3059303f AS	61	value = 0;
	62	for (i = 0; i < nr_cpus; i++)
	63	value += values[i];
ffeedafb AS	64	ind = next_key.index;
	65	data[ind] = value;
	66	if (value && ind > max_ind)
	67	max_ind = ind;
d822a192 AS	68	if (value > max_value)
d822a192 AS	69	max_value = value;
ffeedafb	70	key = next_key;
d822a192 AS	71	}
	72
	73	printf(" syscall write() stats\n");
	74	printf(" byte_size : count distribution\n");
	75	for (i = 1; i <= max_ind + 1; i++) {
	76	stars(starstr, data[i - 1], max_value, MAX_STARS);
	77	printf("%8ld -> %-8ld : %-8ld \|%-*s\|\n",
	78	(1l << i) >> 1, (1l << i) - 1, data[i - 1],
	79	MAX_STARS, starstr);
	80	}
	81	}
ffeedafb AS	82
	83	static void print_hist(int fd)
	84	{
	85	struct hist_key key = {}, next_key;
	86	static struct task tasks[1024];
	87	int task_cnt = 0;
	88	int i;
	89
d40fc181	90	while (bpf_map_get_next_key(fd, &key, &next_key) == 0) {
ffeedafb AS	91	int found = 0;
	92
	93	for (i = 0; i < task_cnt; i++)
	94	if (memcmp(&tasks[i], &next_key, SIZE) == 0)
	95	found = 1;
	96	if (!found)
	97	memcpy(&tasks[task_cnt++], &next_key, SIZE);
	98	key = next_key;
	99	}
	100
	101	for (i = 0; i < task_cnt; i++) {
	102	printf("\npid %d cmd %s uid %d\n",
	103	(__u32) tasks[i].pid_tgid,
	104	tasks[i].comm,
	105	(__u32) tasks[i].uid_gid);
	106	print_hist_for_pid(fd, &tasks[i]);
	107	}
	108
	109	}
	110
d822a192 AS	111	static void int_exit(int sig)
	112	{
	113	print_hist(map_fd[1]);
	114	exit(0);
	115	}
	116
	117	int main(int ac, char **argv)
	118	{
d822a192	119	long key, next_key, value;
63841bc0 DL	120	struct bpf_link *links[2];
	121	struct bpf_program *prog;
	122	struct bpf_object *obj;
	123	char filename[256];
	124	int i, j = 0;
d822a192	125	FILE *f;
d822a192	126
63841bc0 DL	127	snprintf(filename, sizeof(filename), "%s_kern.o", argv[0]);
	128	obj = bpf_object__open_file(filename, NULL);
	129	if (libbpf_get_error(obj)) {
	130	fprintf(stderr, "ERROR: opening BPF object file failed\n");
	131	return 0;
	132	}
	133
	134	/* load BPF program */
	135	if (bpf_object__load(obj)) {
	136	fprintf(stderr, "ERROR: loading BPF object file failed\n");
	137	goto cleanup;
	138	}
	139
	140	map_fd[0] = bpf_object__find_map_fd_by_name(obj, "my_map");
	141	map_fd[1] = bpf_object__find_map_fd_by_name(obj, "my_hist_map");
	142	if (map_fd[0] < 0 \|\| map_fd[1] < 0) {
	143	fprintf(stderr, "ERROR: finding a map in obj file failed\n");
	144	goto cleanup;
	145	}
	146
d822a192	147	signal(SIGINT, int_exit);
ad990dbe	148	signal(SIGTERM, int_exit);
d822a192 AS	149
d822a192 AS	150	/* start 'ping' in the background to have some kfree_skb events */
5c3cf87d	151	f = popen("ping -4 -c5 localhost", "r");
d822a192 AS	152	(void) f;
	153
	154	/* start 'dd' in the background to have plenty of 'write' syscalls */
	155	f = popen("dd if=/dev/zero of=/dev/null count=5000000", "r");
	156	(void) f;
	157
63841bc0 DL	158	bpf_object__for_each_program(prog, obj) {
	159	links[j] = bpf_program__attach(prog);
	160	if (libbpf_get_error(links[j])) {
	161	fprintf(stderr, "ERROR: bpf_program__attach failed\n");
	162	links[j] = NULL;
	163	goto cleanup;
	164	}
	165	j++;
d822a192 AS	166	}
	167
	168	for (i = 0; i < 5; i++) {
	169	key = 0;
d40fc181 JS	170	while (bpf_map_get_next_key(map_fd[0], &key, &next_key) == 0) {
d40fc181 JS	171	bpf_map_lookup_elem(map_fd[0], &next_key, &value);
d822a192 AS	172	printf("location 0x%lx count %ld\n", next_key, value);
	173	key = next_key;
	174	}
	175	if (key)
	176	printf("\n");
	177	sleep(1);
	178	}
	179	print_hist(map_fd[1]);
	180
63841bc0 DL	181	cleanup:
	182	for (j--; j >= 0; j--)
	183	bpf_link__destroy(links[j]);
	184
	185	bpf_object__close(obj);
d822a192 AS	186	return 0;
d822a192 AS	187	}