[linux.git] / kernel / kallsyms_selftest.c

// SPDX-License-Identifier: GPL-2.0-or-later
/*
 * Test the function and performance of kallsyms
 *
 * Copyright (C) Huawei Technologies Co., Ltd., 2022
 *
 * Authors: Zhen Lei <[email protected]> Huawei
 */

#define pr_fmt(fmt) "kallsyms_selftest: " fmt

#include <linux/init.h>
#include <linux/module.h>
#include <linux/kallsyms.h>
#include <linux/random.h>
#include <linux/sched/clock.h>
#include <linux/kthread.h>
#include <linux/vmalloc.h>

#include "kallsyms_internal.h"
#include "kallsyms_selftest.h"


#define MAX_NUM_OF_RECORDS		64

struct test_stat {
	int min;
	int max;
	int save_cnt;
	int real_cnt;
	int perf;
	u64 sum;
	char *name;
	unsigned long addr;
	unsigned long addrs[MAX_NUM_OF_RECORDS];
};

struct test_item {
	char *name;
	unsigned long addr;
};

#define ITEM_FUNC(s)				\
	{					\
		.name = #s,			\
		.addr = (unsigned long)s,	\
	}

#define ITEM_DATA(s)				\
	{					\
		.name = #s,			\
		.addr = (unsigned long)&s,	\
	}


static int kallsyms_test_var_bss_static;
static int kallsyms_test_var_data_static = 1;
int kallsyms_test_var_bss;
int kallsyms_test_var_data = 1;

static int kallsyms_test_func_static(void)
{
	kallsyms_test_var_bss_static++;
	kallsyms_test_var_data_static++;

	return 0;
}

int kallsyms_test_func(void)
{
	return kallsyms_test_func_static();
}

__weak int kallsyms_test_func_weak(void)
{
	kallsyms_test_var_bss++;
	kallsyms_test_var_data++;
	return 0;
}

static struct test_item test_items[] = {
	ITEM_FUNC(kallsyms_test_func_static),
	ITEM_FUNC(kallsyms_test_func),
	ITEM_FUNC(kallsyms_test_func_weak),
	ITEM_FUNC(vmalloc),
	ITEM_FUNC(vfree),
#ifdef CONFIG_KALLSYMS_ALL
	ITEM_DATA(kallsyms_test_var_bss_static),
	ITEM_DATA(kallsyms_test_var_data_static),
	ITEM_DATA(kallsyms_test_var_bss),
	ITEM_DATA(kallsyms_test_var_data),
	ITEM_DATA(vmap_area_list),
#endif
};

static char stub_name[KSYM_NAME_LEN];

static int stat_symbol_len(void *data, const char *name, unsigned long addr)
{
	*(u32 *)data += strlen(name);

	return 0;
}

static void test_kallsyms_compression_ratio(void)
{
	u32 pos, off, len, num;
	u32 ratio, total_size, total_len = 0;

	kallsyms_on_each_symbol(stat_symbol_len, &total_len);

	/*
	 * A symbol name cannot start with a number. This stub name helps us
	 * traverse the entire symbol table without finding a match. It's used
	 * for subsequent performance tests, and its length is the average
	 * length of all symbol names.
	 */
	memset(stub_name, '4', sizeof(stub_name));
	pos = total_len / kallsyms_num_syms;
	stub_name[pos] = 0;

	pos = 0;
	num = 0;
	off = 0;
	while (pos < kallsyms_num_syms) {
		len = kallsyms_names[off];
		num++;
		off++;
		pos++;
		if ((len & 0x80) != 0) {
			len = (len & 0x7f) | (kallsyms_names[off] << 7);
			num++;
			off++;
		}
		off += len;
	}

	/*
	 * 1. The length fields is not counted
	 * 2. The memory occupied by array kallsyms_token_table[] and
	 *    kallsyms_token_index[] needs to be counted.
	 */
	total_size = off - num;
	pos = kallsyms_token_index[0xff];
	total_size += pos + strlen(&kallsyms_token_table[pos]) + 1;
	total_size += 0x100 * sizeof(u16);

	pr_info(" ---------------------------------------------------------\n");
	pr_info("| nr_symbols | compressed size | original size | ratio(%%) |\n");
	pr_info("|---------------------------------------------------------|\n");
	ratio = (u32)div_u64(10000ULL * total_size, total_len);
	pr_info("| %10d |    %10d   |   %10d  |  %2d.%-2d   |\n",
		kallsyms_num_syms, total_size, total_len, ratio / 100, ratio % 100);
	pr_info(" ---------------------------------------------------------\n");
}

static int lookup_name(void *data, const char *name, unsigned long addr)
{
	u64 t0, t1, t;
	struct test_stat *stat = (struct test_stat *)data;

	t0 = ktime_get_ns();
	(void)kallsyms_lookup_name(name);
	t1 = ktime_get_ns();

	t = t1 - t0;
	if (t < stat->min)
		stat->min = t;

	if (t > stat->max)
		stat->max = t;

	stat->real_cnt++;
	stat->sum += t;

	return 0;
}

static void test_perf_kallsyms_lookup_name(void)
{
	struct test_stat stat;

	memset(&stat, 0, sizeof(stat));
	stat.min = INT_MAX;
	kallsyms_on_each_symbol(lookup_name, &stat);
	pr_info("kallsyms_lookup_name() looked up %d symbols\n", stat.real_cnt);
	pr_info("The time spent on each symbol is (ns): min=%d, max=%d, avg=%lld\n",
		stat.min, stat.max, div_u64(stat.sum, stat.real_cnt));
}

static bool match_cleanup_name(const char *s, const char *name)
{
	char *p;
	int len;

	if (!IS_ENABLED(CONFIG_LTO_CLANG))
		return false;

	p = strstr(s, ".llvm.");
	if (!p)
		return false;

	len = strlen(name);
	if (p - s != len)
		return false;

	return !strncmp(s, name, len);
}

static int find_symbol(void *data, const char *name, unsigned long addr)
{
	struct test_stat *stat = (struct test_stat *)data;

	if (strcmp(name, stat->name) == 0 ||
	    (!stat->perf && match_cleanup_name(name, stat->name))) {
		stat->real_cnt++;
		stat->addr = addr;

		if (stat->save_cnt < MAX_NUM_OF_RECORDS) {
			stat->addrs[stat->save_cnt] = addr;
			stat->save_cnt++;
		}

		if (stat->real_cnt == stat->max)
			return 1;
	}

	return 0;
}

static void test_perf_kallsyms_on_each_symbol(void)
{
	u64 t0, t1;
	struct test_stat stat;

	memset(&stat, 0, sizeof(stat));
	stat.max = INT_MAX;
	stat.name = stub_name;
	stat.perf = 1;
	t0 = ktime_get_ns();
	kallsyms_on_each_symbol(find_symbol, &stat);
	t1 = ktime_get_ns();
	pr_info("kallsyms_on_each_symbol() traverse all: %lld ns\n", t1 - t0);
}

static int match_symbol(void *data, unsigned long addr)
{
	struct test_stat *stat = (struct test_stat *)data;

	stat->real_cnt++;
	stat->addr = addr;

	if (stat->save_cnt < MAX_NUM_OF_RECORDS) {
		stat->addrs[stat->save_cnt] = addr;
		stat->save_cnt++;
	}

	if (stat->real_cnt == stat->max)
		return 1;

	return 0;
}

static void test_perf_kallsyms_on_each_match_symbol(void)
{
	u64 t0, t1;
	struct test_stat stat;

	memset(&stat, 0, sizeof(stat));
	stat.max = INT_MAX;
	stat.name = stub_name;
	t0 = ktime_get_ns();
	kallsyms_on_each_match_symbol(match_symbol, stat.name, &stat);
	t1 = ktime_get_ns();
	pr_info("kallsyms_on_each_match_symbol() traverse all: %lld ns\n", t1 - t0);
}

static int test_kallsyms_basic_function(void)
{
	int i, j, ret;
	int next = 0, nr_failed = 0;
	char *prefix;
	unsigned short rand;
	unsigned long addr, lookup_addr;
	char namebuf[KSYM_NAME_LEN];
	struct test_stat *stat, *stat2;

	stat = kmalloc(sizeof(*stat) * 2, GFP_KERNEL);
	if (!stat)
		return -ENOMEM;
	stat2 = stat + 1;

	prefix = "kallsyms_lookup_name() for";
	for (i = 0; i < ARRAY_SIZE(test_items); i++) {
		addr = kallsyms_lookup_name(test_items[i].name);
		if (addr != test_items[i].addr) {
			nr_failed++;
			pr_info("%s %s failed: addr=%lx, expect %lx\n",
				prefix, test_items[i].name, addr, test_items[i].addr);
		}
	}

	prefix = "kallsyms_on_each_symbol() for";
	for (i = 0; i < ARRAY_SIZE(test_items); i++) {
		memset(stat, 0, sizeof(*stat));
		stat->max = INT_MAX;
		stat->name = test_items[i].name;
		kallsyms_on_each_symbol(find_symbol, stat);
		if (stat->addr != test_items[i].addr || stat->real_cnt != 1) {
			nr_failed++;
			pr_info("%s %s failed: count=%d, addr=%lx, expect %lx\n",
				prefix, test_items[i].name,
				stat->real_cnt, stat->addr, test_items[i].addr);
		}
	}

	prefix = "kallsyms_on_each_match_symbol() for";
	for (i = 0; i < ARRAY_SIZE(test_items); i++) {
		memset(stat, 0, sizeof(*stat));
		stat->max = INT_MAX;
		stat->name = test_items[i].name;
		kallsyms_on_each_match_symbol(match_symbol, test_items[i].name, stat);
		if (stat->addr != test_items[i].addr || stat->real_cnt != 1) {
			nr_failed++;
			pr_info("%s %s failed: count=%d, addr=%lx, expect %lx\n",
				prefix, test_items[i].name,
				stat->real_cnt, stat->addr, test_items[i].addr);
		}
	}

	if (nr_failed) {
		kfree(stat);
		return -ESRCH;
	}

	for (i = 0; i < kallsyms_num_syms; i++) {
		addr = kallsyms_sym_address(i);
		if (!is_ksym_addr(addr))
			continue;

		ret = lookup_symbol_name(addr, namebuf);
		if (unlikely(ret)) {
			namebuf[0] = 0;
			pr_info("%d: lookup_symbol_name(%lx) failed\n", i, addr);
			goto failed;
		}

		lookup_addr = kallsyms_lookup_name(namebuf);

		memset(stat, 0, sizeof(*stat));
		stat->max = INT_MAX;
		kallsyms_on_each_match_symbol(match_symbol, namebuf, stat);

		/*
		 * kallsyms_on_each_symbol() is too slow, randomly select some
		 * symbols for test.
		 */
		if (i >= next) {
			memset(stat2, 0, sizeof(*stat2));
			stat2->max = INT_MAX;
			stat2->name = namebuf;
			kallsyms_on_each_symbol(find_symbol, stat2);

			/*
			 * kallsyms_on_each_symbol() and kallsyms_on_each_match_symbol()
			 * need to get the same traversal result.
			 */
			if (stat->addr != stat2->addr ||
			    stat->real_cnt != stat2->real_cnt ||
			    memcmp(stat->addrs, stat2->addrs,
				   stat->save_cnt * sizeof(stat->addrs[0]))) {
				pr_info("%s: mismatch between kallsyms_on_each_symbol() and kallsyms_on_each_match_symbol()\n",
					namebuf);
				goto failed;
			}

			/*
			 * The average of random increments is 128, that is, one of
			 * them is tested every 128 symbols.
			 */
			get_random_bytes(&rand, sizeof(rand));
			next = i + (rand & 0xff) + 1;
		}

		/* Need to be found at least once */
		if (!stat->real_cnt) {
			pr_info("%s: Never found\n", namebuf);
			goto failed;
		}

		/*
		 * kallsyms_lookup_name() returns the address of the first
		 * symbol found and cannot be NULL.
		 */
		if (!lookup_addr) {
			pr_info("%s: NULL lookup_addr?!\n", namebuf);
			goto failed;
		}
		if (lookup_addr != stat->addrs[0]) {
			pr_info("%s: lookup_addr != stat->addrs[0]\n", namebuf);
			goto failed;
		}

		/*
		 * If the addresses of all matching symbols are recorded, the
		 * target address needs to be exist.
		 */
		if (stat->real_cnt <= MAX_NUM_OF_RECORDS) {
			for (j = 0; j < stat->save_cnt; j++) {
				if (stat->addrs[j] == addr)
					break;
			}

			if (j == stat->save_cnt) {
				pr_info("%s: j == save_cnt?!\n", namebuf);
				goto failed;
			}
		}
	}

	kfree(stat);

	return 0;

failed:
	pr_info("Test for %dth symbol failed: (%s) addr=%lx", i, namebuf, addr);
	kfree(stat);
	return -ESRCH;
}

static int test_entry(void *p)
{
	int ret;

	do {
		schedule_timeout(5 * HZ);
	} while (system_state != SYSTEM_RUNNING);

	pr_info("start\n");
	ret = test_kallsyms_basic_function();
	if (ret) {
		pr_info("abort\n");
		return 0;
	}

	test_kallsyms_compression_ratio();
	test_perf_kallsyms_lookup_name();
	test_perf_kallsyms_on_each_symbol();
	test_perf_kallsyms_on_each_match_symbol();
	pr_info("finish\n");

	return 0;
}

static int __init kallsyms_test_init(void)
{
	struct task_struct *t;

	t = kthread_create(test_entry, NULL, "kallsyms_test");
	if (IS_ERR(t)) {
		pr_info("Create kallsyms selftest task failed\n");
		return PTR_ERR(t);
	}
	kthread_bind(t, 0);
	wake_up_process(t);

	return 0;
}
late_initcall(kallsyms_test_init);
Commit	Line	Data
30f3bb09 ZL	1	// SPDX-License-Identifier: GPL-2.0-or-later
	2	/*
	3	* Test the function and performance of kallsyms
	4	*
	5	* Copyright (C) Huawei Technologies Co., Ltd., 2022
	6	*
	7	* Authors: Zhen Lei <[email protected]> Huawei
	8	*/
	9
	10	#define pr_fmt(fmt) "kallsyms_selftest: " fmt
	11
	12	#include <linux/init.h>
	13	#include <linux/module.h>
	14	#include <linux/kallsyms.h>
	15	#include <linux/random.h>
	16	#include <linux/sched/clock.h>
	17	#include <linux/kthread.h>
	18	#include <linux/vmalloc.h>
	19
	20	#include "kallsyms_internal.h"
	21	#include "kallsyms_selftest.h"
	22
	23
	24	#define MAX_NUM_OF_RECORDS 64
	25
	26	struct test_stat {
	27	int min;
	28	int max;
	29	int save_cnt;
	30	int real_cnt;
	31	int perf;
	32	u64 sum;
	33	char *name;
	34	unsigned long addr;
	35	unsigned long addrs[MAX_NUM_OF_RECORDS];
	36	};
	37
	38	struct test_item {
	39	char *name;
	40	unsigned long addr;
	41	};
	42
	43	#define ITEM_FUNC(s) \
	44	{ \
	45	.name = #s, \
	46	.addr = (unsigned long)s, \
	47	}
	48
	49	#define ITEM_DATA(s) \
	50	{ \
	51	.name = #s, \
	52	.addr = (unsigned long)&s, \
	53	}
	54
	55
	56	static int kallsyms_test_var_bss_static;
	57	static int kallsyms_test_var_data_static = 1;
	58	int kallsyms_test_var_bss;
	59	int kallsyms_test_var_data = 1;
	60
	61	static int kallsyms_test_func_static(void)
	62	{
	63	kallsyms_test_var_bss_static++;
	64	kallsyms_test_var_data_static++;
65
66	return 0;
67	}
68
69	int kallsyms_test_func(void)
70	{
71	return kallsyms_test_func_static();
72	}
73
74	__weak int kallsyms_test_func_weak(void)
75	{
76	kallsyms_test_var_bss++;
77	kallsyms_test_var_data++;
78	return 0;
79	}
80
81	static struct test_item test_items[] = {
82	ITEM_FUNC(kallsyms_test_func_static),
83	ITEM_FUNC(kallsyms_test_func),
84	ITEM_FUNC(kallsyms_test_func_weak),
85	ITEM_FUNC(vmalloc),
86	ITEM_FUNC(vfree),
87	#ifdef CONFIG_KALLSYMS_ALL
88	ITEM_DATA(kallsyms_test_var_bss_static),
89	ITEM_DATA(kallsyms_test_var_data_static),
90	ITEM_DATA(kallsyms_test_var_bss),
91	ITEM_DATA(kallsyms_test_var_data),
92	ITEM_DATA(vmap_area_list),
93	#endif
94	};
95
96	static char stub_name[KSYM_NAME_LEN];
97
3703bd54	98	static int stat_symbol_len(void data, const char name, unsigned long addr)
30f3bb09 ZL	99	{
	100	(u32 )data += strlen(name);
	101
	102	return 0;
	103	}
	104
	105	static void test_kallsyms_compression_ratio(void)
	106	{
	107	u32 pos, off, len, num;
	108	u32 ratio, total_size, total_len = 0;
	109
	110	kallsyms_on_each_symbol(stat_symbol_len, &total_len);
	111
	112	/*
	113	* A symbol name cannot start with a number. This stub name helps us
	114	* traverse the entire symbol table without finding a match. It's used
	115	* for subsequent performance tests, and its length is the average
	116	* length of all symbol names.
	117	*/
	118	memset(stub_name, '4', sizeof(stub_name));
	119	pos = total_len / kallsyms_num_syms;
	120	stub_name[pos] = 0;
	121
	122	pos = 0;
	123	num = 0;
	124	off = 0;
	125	while (pos < kallsyms_num_syms) {
	126	len = kallsyms_names[off];
	127	num++;
	128	off++;
	129	pos++;
	130	if ((len & 0x80) != 0) {
	131	len = (len & 0x7f) \| (kallsyms_names[off] << 7);
	132	num++;
	133	off++;
	134	}
	135	off += len;
c86a514f	136	}
30f3bb09 ZL	137
	138	/*
	139	* 1. The length fields is not counted
	140	* 2. The memory occupied by array kallsyms_token_table[] and
	141	* kallsyms_token_index[] needs to be counted.
	142	*/
	143	total_size = off - num;
	144	pos = kallsyms_token_index[0xff];
	145	total_size += pos + strlen(&kallsyms_token_table[pos]) + 1;
	146	total_size += 0x100 * sizeof(u16);
	147
	148	pr_info(" ---------------------------------------------------------\n");
	149	pr_info("\| nr_symbols \| compressed size \| original size \| ratio(%%) \|\n");
	150	pr_info("\|---------------------------------------------------------\|\n");
	151	ratio = (u32)div_u64(10000ULL * total_size, total_len);
	152	pr_info("\| %10d \| %10d \| %10d \| %2d.%-2d \|\n",
	153	kallsyms_num_syms, total_size, total_len, ratio / 100, ratio % 100);
	154	pr_info(" ---------------------------------------------------------\n");
	155	}
	156
3703bd54	157	static int lookup_name(void data, const char name, unsigned long addr)
30f3bb09 ZL	158	{
30f3bb09 ZL	159	u64 t0, t1, t;
30f3bb09 ZL	160	struct test_stat stat = (struct test_stat )data;
30f3bb09 ZL	161
da35048f	162	t0 = ktime_get_ns();
30f3bb09	163	(void)kallsyms_lookup_name(name);
da35048f	164	t1 = ktime_get_ns();
30f3bb09 ZL	165
	166	t = t1 - t0;
	167	if (t < stat->min)
	168	stat->min = t;
	169
	170	if (t > stat->max)
	171	stat->max = t;
	172
	173	stat->real_cnt++;
	174	stat->sum += t;
	175
	176	return 0;
	177	}
	178
	179	static void test_perf_kallsyms_lookup_name(void)
	180	{
	181	struct test_stat stat;
	182
	183	memset(&stat, 0, sizeof(stat));
	184	stat.min = INT_MAX;
	185	kallsyms_on_each_symbol(lookup_name, &stat);
	186	pr_info("kallsyms_lookup_name() looked up %d symbols\n", stat.real_cnt);
	187	pr_info("The time spent on each symbol is (ns): min=%d, max=%d, avg=%lld\n",
	188	stat.min, stat.max, div_u64(stat.sum, stat.real_cnt));
	189	}
	190
	191	static bool match_cleanup_name(const char s, const char name)
	192	{
	193	char *p;
	194	int len;
	195
	196	if (!IS_ENABLED(CONFIG_LTO_CLANG))
	197	return false;
	198
33f0467f	199	p = strstr(s, ".llvm.");
30f3bb09 ZL	200	if (!p)
	201	return false;
	202
	203	len = strlen(name);
	204	if (p - s != len)
	205	return false;
	206
	207	return !strncmp(s, name, len);
	208	}
	209
3703bd54	210	static int find_symbol(void data, const char name, unsigned long addr)
30f3bb09 ZL	211	{
	212	struct test_stat stat = (struct test_stat )data;
	213
	214	if (strcmp(name, stat->name) == 0 \|\|
	215	(!stat->perf && match_cleanup_name(name, stat->name))) {
	216	stat->real_cnt++;
	217	stat->addr = addr;
	218
	219	if (stat->save_cnt < MAX_NUM_OF_RECORDS) {
	220	stat->addrs[stat->save_cnt] = addr;
	221	stat->save_cnt++;
	222	}
	223
	224	if (stat->real_cnt == stat->max)
	225	return 1;
	226	}
	227
	228	return 0;
	229	}
	230
	231	static void test_perf_kallsyms_on_each_symbol(void)
	232	{
	233	u64 t0, t1;
30f3bb09 ZL	234	struct test_stat stat;
	235
	236	memset(&stat, 0, sizeof(stat));
	237	stat.max = INT_MAX;
	238	stat.name = stub_name;
	239	stat.perf = 1;
da35048f	240	t0 = ktime_get_ns();
30f3bb09	241	kallsyms_on_each_symbol(find_symbol, &stat);
da35048f	242	t1 = ktime_get_ns();
30f3bb09 ZL	243	pr_info("kallsyms_on_each_symbol() traverse all: %lld ns\n", t1 - t0);
	244	}
	245
	246	static int match_symbol(void *data, unsigned long addr)
	247	{
	248	struct test_stat stat = (struct test_stat )data;
	249
	250	stat->real_cnt++;
	251	stat->addr = addr;
	252
	253	if (stat->save_cnt < MAX_NUM_OF_RECORDS) {
	254	stat->addrs[stat->save_cnt] = addr;
	255	stat->save_cnt++;
	256	}
	257
	258	if (stat->real_cnt == stat->max)
	259	return 1;
	260
	261	return 0;
	262	}
	263
	264	static void test_perf_kallsyms_on_each_match_symbol(void)
	265	{
	266	u64 t0, t1;
30f3bb09 ZL	267	struct test_stat stat;
	268
	269	memset(&stat, 0, sizeof(stat));
	270	stat.max = INT_MAX;
	271	stat.name = stub_name;
da35048f	272	t0 = ktime_get_ns();
30f3bb09	273	kallsyms_on_each_match_symbol(match_symbol, stat.name, &stat);
da35048f	274	t1 = ktime_get_ns();
30f3bb09 ZL	275	pr_info("kallsyms_on_each_match_symbol() traverse all: %lld ns\n", t1 - t0);
	276	}
	277
	278	static int test_kallsyms_basic_function(void)
	279	{
	280	int i, j, ret;
	281	int next = 0, nr_failed = 0;
	282	char *prefix;
	283	unsigned short rand;
	284	unsigned long addr, lookup_addr;
	285	char namebuf[KSYM_NAME_LEN];
	286	struct test_stat stat, stat2;
	287
	288	stat = kmalloc(sizeof(stat) 2, GFP_KERNEL);
	289	if (!stat)
	290	return -ENOMEM;
	291	stat2 = stat + 1;
	292
	293	prefix = "kallsyms_lookup_name() for";
	294	for (i = 0; i < ARRAY_SIZE(test_items); i++) {
	295	addr = kallsyms_lookup_name(test_items[i].name);
	296	if (addr != test_items[i].addr) {
	297	nr_failed++;
	298	pr_info("%s %s failed: addr=%lx, expect %lx\n",
	299	prefix, test_items[i].name, addr, test_items[i].addr);
	300	}
	301	}
	302
	303	prefix = "kallsyms_on_each_symbol() for";
	304	for (i = 0; i < ARRAY_SIZE(test_items); i++) {
	305	memset(stat, 0, sizeof(*stat));
	306	stat->max = INT_MAX;
	307	stat->name = test_items[i].name;
	308	kallsyms_on_each_symbol(find_symbol, stat);
	309	if (stat->addr != test_items[i].addr \|\| stat->real_cnt != 1) {
	310	nr_failed++;
	311	pr_info("%s %s failed: count=%d, addr=%lx, expect %lx\n",
	312	prefix, test_items[i].name,
	313	stat->real_cnt, stat->addr, test_items[i].addr);
	314	}
	315	}
	316
	317	prefix = "kallsyms_on_each_match_symbol() for";
	318	for (i = 0; i < ARRAY_SIZE(test_items); i++) {
	319	memset(stat, 0, sizeof(*stat));
	320	stat->max = INT_MAX;
	321	stat->name = test_items[i].name;
	322	kallsyms_on_each_match_symbol(match_symbol, test_items[i].name, stat);
	323	if (stat->addr != test_items[i].addr \|\| stat->real_cnt != 1) {
	324	nr_failed++;
	325	pr_info("%s %s failed: count=%d, addr=%lx, expect %lx\n",
	326	prefix, test_items[i].name,
	327	stat->real_cnt, stat->addr, test_items[i].addr);
	328	}
	329	}
	330
	331	if (nr_failed) {
	332	kfree(stat);
	333	return -ESRCH;
	334	}
	335
	336	for (i = 0; i < kallsyms_num_syms; i++) {
	337	addr = kallsyms_sym_address(i);
	338	if (!is_ksym_addr(addr))
339	continue;
340
341	ret = lookup_symbol_name(addr, namebuf);
342	if (unlikely(ret)) {
343	namebuf[0] = 0;
33c24bee	344	pr_info("%d: lookup_symbol_name(%lx) failed\n", i, addr);
30f3bb09 ZL	345	goto failed;
	346	}
	347
30f3bb09 ZL	348	lookup_addr = kallsyms_lookup_name(namebuf);
	349
	350	memset(stat, 0, sizeof(*stat));
	351	stat->max = INT_MAX;
	352	kallsyms_on_each_match_symbol(match_symbol, namebuf, stat);
	353
	354	/*
	355	* kallsyms_on_each_symbol() is too slow, randomly select some
	356	* symbols for test.
	357	*/
	358	if (i >= next) {
	359	memset(stat2, 0, sizeof(*stat2));
	360	stat2->max = INT_MAX;
	361	stat2->name = namebuf;
	362	kallsyms_on_each_symbol(find_symbol, stat2);
	363
	364	/*
	365	* kallsyms_on_each_symbol() and kallsyms_on_each_match_symbol()
	366	* need to get the same traversal result.
	367	*/
	368	if (stat->addr != stat2->addr \|\|
	369	stat->real_cnt != stat2->real_cnt \|\|
	370	memcmp(stat->addrs, stat2->addrs,
33c24bee KC	371	stat->save_cnt * sizeof(stat->addrs[0]))) {
	372	pr_info("%s: mismatch between kallsyms_on_each_symbol() and kallsyms_on_each_match_symbol()\n",
	373	namebuf);
30f3bb09	374	goto failed;
33c24bee	375	}
30f3bb09 ZL	376
	377	/*
	378	* The average of random increments is 128, that is, one of
	379	* them is tested every 128 symbols.
	380	*/
	381	get_random_bytes(&rand, sizeof(rand));
	382	next = i + (rand & 0xff) + 1;
	383	}
	384
	385	/* Need to be found at least once */
33c24bee KC	386	if (!stat->real_cnt) {
33c24bee KC	387	pr_info("%s: Never found\n", namebuf);
30f3bb09	388	goto failed;
33c24bee	389	}
30f3bb09 ZL	390
	391	/*
	392	* kallsyms_lookup_name() returns the address of the first
	393	* symbol found and cannot be NULL.
	394	*/
33c24bee KC	395	if (!lookup_addr) {
	396	pr_info("%s: NULL lookup_addr?!\n", namebuf);
	397	goto failed;
	398	}
	399	if (lookup_addr != stat->addrs[0]) {
	400	pr_info("%s: lookup_addr != stat->addrs[0]\n", namebuf);
30f3bb09	401	goto failed;
33c24bee	402	}
30f3bb09 ZL	403
	404	/*
	405	* If the addresses of all matching symbols are recorded, the
	406	* target address needs to be exist.
	407	*/
	408	if (stat->real_cnt <= MAX_NUM_OF_RECORDS) {
	409	for (j = 0; j < stat->save_cnt; j++) {
	410	if (stat->addrs[j] == addr)
	411	break;
	412	}
	413
33c24bee KC	414	if (j == stat->save_cnt) {
33c24bee KC	415	pr_info("%s: j == save_cnt?!\n", namebuf);
30f3bb09	416	goto failed;
33c24bee	417	}
30f3bb09 ZL	418	}
	419	}
	420
	421	kfree(stat);
	422
	423	return 0;
	424
	425	failed:
	426	pr_info("Test for %dth symbol failed: (%s) addr=%lx", i, namebuf, addr);
	427	kfree(stat);
	428	return -ESRCH;
	429	}
	430
	431	static int test_entry(void *p)
	432	{
	433	int ret;
	434
	435	do {
	436	schedule_timeout(5 * HZ);
	437	} while (system_state != SYSTEM_RUNNING);
	438
	439	pr_info("start\n");
	440	ret = test_kallsyms_basic_function();
	441	if (ret) {
	442	pr_info("abort\n");
	443	return 0;
	444	}
	445
	446	test_kallsyms_compression_ratio();
	447	test_perf_kallsyms_lookup_name();
	448	test_perf_kallsyms_on_each_symbol();
	449	test_perf_kallsyms_on_each_match_symbol();
	450	pr_info("finish\n");
	451
	452	return 0;
	453	}
	454
	455	static int __init kallsyms_test_init(void)
	456	{
	457	struct task_struct *t;
	458
	459	t = kthread_create(test_entry, NULL, "kallsyms_test");
	460	if (IS_ERR(t)) {
	461	pr_info("Create kallsyms selftest task failed\n");
	462	return PTR_ERR(t);
	463	}
	464	kthread_bind(t, 0);
	465	wake_up_process(t);
	466
	467	return 0;
	468	}
	469	late_initcall(kallsyms_test_init);