1// SPDX-License-Identifier: GPL-2.0
  2/* Copyright (c) 2022 Meta Platforms, Inc. and affiliates. */
  3
  4#include <ctype.h>
  5#include <test_progs.h>
  6#include <bpf/btf.h>
  7
  8/*
  9 * Utility function uppercasing an entire string.
 10 */
 11static void uppercase(char *s)
 12{
 13	for (; *s != '\0'; s++)
 14		*s = toupper(*s);
 15}
 16
 17/*
 18 * Test case to check that all bpf_attach_type variants are covered by
 19 * libbpf_bpf_attach_type_str.
 20 */
 21static void test_libbpf_bpf_attach_type_str(void)
 22{
 23	struct btf *btf;
 24	const struct btf_type *t;
 25	const struct btf_enum *e;
 26	int i, n, id;
 27
 28	btf = btf__parse("/sys/kernel/btf/vmlinux", NULL);
 29	if (!ASSERT_OK_PTR(btf, "btf_parse"))
 30		return;
 31
 32	/* find enum bpf_attach_type and enumerate each value */
 33	id = btf__find_by_name_kind(btf, "bpf_attach_type", BTF_KIND_ENUM);
 34	if (!ASSERT_GT(id, 0, "bpf_attach_type_id"))
 35		goto cleanup;
 36	t = btf__type_by_id(btf, id);
 37	e = btf_enum(t);
 38	n = btf_vlen(t);
 39	for (i = 0; i < n; e++, i++) {
 40		enum bpf_attach_type attach_type = (enum bpf_attach_type)e->val;
 41		const char *attach_type_name;
 42		const char *attach_type_str;
 43		char buf[256];
 44
 45		if (attach_type == __MAX_BPF_ATTACH_TYPE)
 46			continue;
 47
 48		attach_type_name = btf__str_by_offset(btf, e->name_off);
 49		attach_type_str = libbpf_bpf_attach_type_str(attach_type);
 50		ASSERT_OK_PTR(attach_type_str, attach_type_name);
 51
 52		snprintf(buf, sizeof(buf), "BPF_%s", attach_type_str);
 53		uppercase(buf);
 54
 55		ASSERT_STREQ(buf, attach_type_name, "exp_str_value");
 56	}
 57
 58cleanup:
 59	btf__free(btf);
 60}
 61
 62/*
 63 * Test case to check that all bpf_link_type variants are covered by
 64 * libbpf_bpf_link_type_str.
 65 */
 66static void test_libbpf_bpf_link_type_str(void)
 67{
 68	struct btf *btf;
 69	const struct btf_type *t;
 70	const struct btf_enum *e;
 71	int i, n, id;
 72
 73	btf = btf__parse("/sys/kernel/btf/vmlinux", NULL);
 74	if (!ASSERT_OK_PTR(btf, "btf_parse"))
 75		return;
 76
 77	/* find enum bpf_link_type and enumerate each value */
 78	id = btf__find_by_name_kind(btf, "bpf_link_type", BTF_KIND_ENUM);
 79	if (!ASSERT_GT(id, 0, "bpf_link_type_id"))
 80		goto cleanup;
 81	t = btf__type_by_id(btf, id);
 82	e = btf_enum(t);
 83	n = btf_vlen(t);
 84	for (i = 0; i < n; e++, i++) {
 85		enum bpf_link_type link_type = (enum bpf_link_type)e->val;
 86		const char *link_type_name;
 87		const char *link_type_str;
 88		char buf[256];
 89
 90		if (link_type == __MAX_BPF_LINK_TYPE)
 91			continue;
 92
 93		link_type_name = btf__str_by_offset(btf, e->name_off);
 94		link_type_str = libbpf_bpf_link_type_str(link_type);
 95		ASSERT_OK_PTR(link_type_str, link_type_name);
 96
 97		snprintf(buf, sizeof(buf), "BPF_LINK_TYPE_%s", link_type_str);
 98		uppercase(buf);
 99
100		ASSERT_STREQ(buf, link_type_name, "exp_str_value");
101	}
102
103cleanup:
104	btf__free(btf);
105}
106
107/*
108 * Test case to check that all bpf_map_type variants are covered by
109 * libbpf_bpf_map_type_str.
110 */
111static void test_libbpf_bpf_map_type_str(void)
112{
113	struct btf *btf;
114	const struct btf_type *t;
115	const struct btf_enum *e;
116	int i, n, id;
117
118	btf = btf__parse("/sys/kernel/btf/vmlinux", NULL);
119	if (!ASSERT_OK_PTR(btf, "btf_parse"))
120		return;
121
122	/* find enum bpf_map_type and enumerate each value */
123	id = btf__find_by_name_kind(btf, "bpf_map_type", BTF_KIND_ENUM);
124	if (!ASSERT_GT(id, 0, "bpf_map_type_id"))
125		goto cleanup;
126	t = btf__type_by_id(btf, id);
127	e = btf_enum(t);
128	n = btf_vlen(t);
129	for (i = 0; i < n; e++, i++) {
130		enum bpf_map_type map_type = (enum bpf_map_type)e->val;
131		const char *map_type_name;
132		const char *map_type_str;
133		char buf[256];
134
135		if (map_type == __MAX_BPF_MAP_TYPE)
136			continue;
137
138		map_type_name = btf__str_by_offset(btf, e->name_off);
139		map_type_str = libbpf_bpf_map_type_str(map_type);
140		ASSERT_OK_PTR(map_type_str, map_type_name);
141
142		snprintf(buf, sizeof(buf), "BPF_MAP_TYPE_%s", map_type_str);
143		uppercase(buf);
144
145		/* Special case for map_type_name BPF_MAP_TYPE_CGROUP_STORAGE_DEPRECATED
146		 * where it and BPF_MAP_TYPE_CGROUP_STORAGE have the same enum value
147		 * (map_type). For this enum value, libbpf_bpf_map_type_str() picks
148		 * BPF_MAP_TYPE_CGROUP_STORAGE. The same for
149		 * BPF_MAP_TYPE_PERCPU_CGROUP_STORAGE_DEPRECATED and
150		 * BPF_MAP_TYPE_PERCPU_CGROUP_STORAGE.
151		 */
152		if (strcmp(map_type_name, "BPF_MAP_TYPE_CGROUP_STORAGE_DEPRECATED") == 0)
153			continue;
154		if (strcmp(map_type_name, "BPF_MAP_TYPE_PERCPU_CGROUP_STORAGE_DEPRECATED") == 0)
155			continue;
156
157		ASSERT_STREQ(buf, map_type_name, "exp_str_value");
158	}
159
160cleanup:
161	btf__free(btf);
162}
163
164/*
165 * Test case to check that all bpf_prog_type variants are covered by
166 * libbpf_bpf_prog_type_str.
167 */
168static void test_libbpf_bpf_prog_type_str(void)
169{
170	struct btf *btf;
171	const struct btf_type *t;
172	const struct btf_enum *e;
173	int i, n, id;
174
175	btf = btf__parse("/sys/kernel/btf/vmlinux", NULL);
176	if (!ASSERT_OK_PTR(btf, "btf_parse"))
177		return;
178
179	/* find enum bpf_prog_type and enumerate each value */
180	id = btf__find_by_name_kind(btf, "bpf_prog_type", BTF_KIND_ENUM);
181	if (!ASSERT_GT(id, 0, "bpf_prog_type_id"))
182		goto cleanup;
183	t = btf__type_by_id(btf, id);
184	e = btf_enum(t);
185	n = btf_vlen(t);
186	for (i = 0; i < n; e++, i++) {
187		enum bpf_prog_type prog_type = (enum bpf_prog_type)e->val;
188		const char *prog_type_name;
189		const char *prog_type_str;
190		char buf[256];
191
192		if (prog_type == __MAX_BPF_PROG_TYPE)
193			continue;
194
195		prog_type_name = btf__str_by_offset(btf, e->name_off);
196		prog_type_str = libbpf_bpf_prog_type_str(prog_type);
197		ASSERT_OK_PTR(prog_type_str, prog_type_name);
198
199		snprintf(buf, sizeof(buf), "BPF_PROG_TYPE_%s", prog_type_str);
200		uppercase(buf);
201
202		ASSERT_STREQ(buf, prog_type_name, "exp_str_value");
203	}
204
205cleanup:
206	btf__free(btf);
207}
208
209/*
210 * Run all libbpf str conversion tests.
211 */
212void test_libbpf_str(void)
213{
214	if (test__start_subtest("bpf_attach_type_str"))
215		test_libbpf_bpf_attach_type_str();
216
217	if (test__start_subtest("bpf_link_type_str"))
218		test_libbpf_bpf_link_type_str();
219
220	if (test__start_subtest("bpf_map_type_str"))
221		test_libbpf_bpf_map_type_str();
222
223	if (test__start_subtest("bpf_prog_type_str"))
224		test_libbpf_bpf_prog_type_str();
225}