kernel/kallsyms_selftest.c

   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 <thunder.leizhen@huawei.com> 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
  98 static int stat_symbol_len(void *data, const char *name, struct module *mod, unsigned long addr)
  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;
 136         }
 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
 157 static int lookup_name(void *data, const char *name, struct module *mod, unsigned long addr)
 158 {
 159         u64 t0, t1, t;
 160         unsigned long flags;
 161         struct test_stat *stat = (struct test_stat *)data;
 162
 163         local_irq_save(flags);
 164         t0 = sched_clock();
 165         (void)kallsyms_lookup_name(name);
 166         t1 = sched_clock();
 167         local_irq_restore(flags);
 168
 169         t = t1 - t0;
 170         if (t < stat->min)
 171                 stat->min = t;
 172
 173         if (t > stat->max)
 174                 stat->max = t;
 175
 176         stat->real_cnt++;
 177         stat->sum += t;
 178
 179         return 0;
 180 }
 181
 182 static void test_perf_kallsyms_lookup_name(void)
 183 {
 184         struct test_stat stat;
 185
 186         memset(&stat, 0, sizeof(stat));
 187         stat.min = INT_MAX;
 188         kallsyms_on_each_symbol(lookup_name, &stat);
 189         pr_info("kallsyms_lookup_name() looked up %d symbols\n", stat.real_cnt);
 190         pr_info("The time spent on each symbol is (ns): min=%d, max=%d, avg=%lld\n",
 191                 stat.min, stat.max, div_u64(stat.sum, stat.real_cnt));
 192 }
 193
 194 static bool match_cleanup_name(const char *s, const char *name)
 195 {
 196         char *p;
 197         int len;
 198
 199         if (!IS_ENABLED(CONFIG_LTO_CLANG))
 200                 return false;
 201
 202         p = strchr(s, '.');
 203         if (!p)
 204                 return false;
 205
 206         len = strlen(name);
 207         if (p - s != len)
 208                 return false;
 209
 210         return !strncmp(s, name, len);
 211 }
 212
 213 static int find_symbol(void *data, const char *name, struct module *mod, unsigned long addr)
 214 {
 215         struct test_stat *stat = (struct test_stat *)data;
 216
 217         if (strcmp(name, stat->name) == 0 ||
 218             (!stat->perf && match_cleanup_name(name, stat->name))) {
 219                 stat->real_cnt++;
 220                 stat->addr = addr;
 221
 222                 if (stat->save_cnt < MAX_NUM_OF_RECORDS) {
 223                         stat->addrs[stat->save_cnt] = addr;
 224                         stat->save_cnt++;
 225                 }
 226
 227                 if (stat->real_cnt == stat->max)
 228                         return 1;
 229         }
 230
 231         return 0;
 232 }
 233
 234 static void test_perf_kallsyms_on_each_symbol(void)
 235 {
 236         u64 t0, t1;
 237         unsigned long flags;
 238         struct test_stat stat;
 239
 240         memset(&stat, 0, sizeof(stat));
 241         stat.max = INT_MAX;
 242         stat.name = stub_name;
 243         stat.perf = 1;
 244         local_irq_save(flags);
 245         t0 = sched_clock();
 246         kallsyms_on_each_symbol(find_symbol, &stat);
 247         t1 = sched_clock();
 248         local_irq_restore(flags);
 249         pr_info("kallsyms_on_each_symbol() traverse all: %lld ns\n", t1 - t0);
 250 }
 251
 252 static int match_symbol(void *data, unsigned long addr)
 253 {
 254         struct test_stat *stat = (struct test_stat *)data;
 255
 256         stat->real_cnt++;
 257         stat->addr = addr;
 258
 259         if (stat->save_cnt < MAX_NUM_OF_RECORDS) {
 260                 stat->addrs[stat->save_cnt] = addr;
 261                 stat->save_cnt++;
 262         }
 263
 264         if (stat->real_cnt == stat->max)
 265                 return 1;
 266
 267         return 0;
 268 }
 269
 270 static void test_perf_kallsyms_on_each_match_symbol(void)
 271 {
 272         u64 t0, t1;
 273         unsigned long flags;
 274         struct test_stat stat;
 275
 276         memset(&stat, 0, sizeof(stat));
 277         stat.max = INT_MAX;
 278         stat.name = stub_name;
 279         local_irq_save(flags);
 280         t0 = sched_clock();
 281         kallsyms_on_each_match_symbol(match_symbol, stat.name, &stat);
 282         t1 = sched_clock();
 283         local_irq_restore(flags);
 284         pr_info("kallsyms_on_each_match_symbol() traverse all: %lld ns\n", t1 - t0);
 285 }
 286
 287 static int test_kallsyms_basic_function(void)
 288 {
 289         int i, j, ret;
 290         int next = 0, nr_failed = 0;
 291         char *prefix;
 292         unsigned short rand;
 293         unsigned long addr, lookup_addr;
 294         char namebuf[KSYM_NAME_LEN];
 295         struct test_stat *stat, *stat2;
 296
 297         stat = kmalloc(sizeof(*stat) * 2, GFP_KERNEL);
 298         if (!stat)
 299                 return -ENOMEM;
 300         stat2 = stat + 1;
 301
 302         prefix = "kallsyms_lookup_name() for";
 303         for (i = 0; i < ARRAY_SIZE(test_items); i++) {
 304                 addr = kallsyms_lookup_name(test_items[i].name);
 305                 if (addr != test_items[i].addr) {
 306                         nr_failed++;
 307                         pr_info("%s %s failed: addr=%lx, expect %lx\n",
 308                                 prefix, test_items[i].name, addr, test_items[i].addr);
 309                 }
 310         }
 311
 312         prefix = "kallsyms_on_each_symbol() for";
 313         for (i = 0; i < ARRAY_SIZE(test_items); i++) {
 314                 memset(stat, 0, sizeof(*stat));
 315                 stat->max = INT_MAX;
 316                 stat->name = test_items[i].name;
 317                 kallsyms_on_each_symbol(find_symbol, stat);
 318                 if (stat->addr != test_items[i].addr || stat->real_cnt != 1) {
 319                         nr_failed++;
 320                         pr_info("%s %s failed: count=%d, addr=%lx, expect %lx\n",
 321                                 prefix, test_items[i].name,
 322                                 stat->real_cnt, stat->addr, test_items[i].addr);
 323                 }
 324         }
 325
 326         prefix = "kallsyms_on_each_match_symbol() for";
 327         for (i = 0; i < ARRAY_SIZE(test_items); i++) {
 328                 memset(stat, 0, sizeof(*stat));
 329                 stat->max = INT_MAX;
 330                 stat->name = test_items[i].name;
 331                 kallsyms_on_each_match_symbol(match_symbol, test_items[i].name, stat);
 332                 if (stat->addr != test_items[i].addr || stat->real_cnt != 1) {
 333                         nr_failed++;
 334                         pr_info("%s %s failed: count=%d, addr=%lx, expect %lx\n",
 335                                 prefix, test_items[i].name,
 336                                 stat->real_cnt, stat->addr, test_items[i].addr);
 337                 }
 338         }
 339
 340         if (nr_failed) {
 341                 kfree(stat);
 342                 return -ESRCH;
 343         }
 344
 345         for (i = 0; i < kallsyms_num_syms; i++) {
 346                 addr = kallsyms_sym_address(i);
 347                 if (!is_ksym_addr(addr))
 348                         continue;
 349
 350                 ret = lookup_symbol_name(addr, namebuf);
 351                 if (unlikely(ret)) {
 352                         namebuf[0] = 0;
 353                         goto failed;
 354                 }
 355
 356                 /*
 357                  * The first '.' may be the initial letter, in which case the
 358                  * entire symbol name will be truncated to an empty string in
 359                  * cleanup_symbol_name(). Do not test these symbols.
 360                  *
 361                  * For example:
 362                  * cat /proc/kallsyms | awk '{print $3}' | grep -E "^\." | head
 363                  * .E_read_words
 364                  * .E_leading_bytes
 365                  * .E_trailing_bytes
 366                  * .E_write_words
 367                  * .E_copy
 368                  * .str.292.llvm.12122243386960820698
 369                  * .str.24.llvm.12122243386960820698
 370                  * .str.29.llvm.12122243386960820698
 371                  * .str.75.llvm.12122243386960820698
 372                  * .str.99.llvm.12122243386960820698
 373                  */
 374                 if (IS_ENABLED(CONFIG_LTO_CLANG) && !namebuf[0])
 375                         continue;
 376
 377                 lookup_addr = kallsyms_lookup_name(namebuf);
 378
 379                 memset(stat, 0, sizeof(*stat));
 380                 stat->max = INT_MAX;
 381                 kallsyms_on_each_match_symbol(match_symbol, namebuf, stat);
 382
 383                 /*
 384                  * kallsyms_on_each_symbol() is too slow, randomly select some
 385                  * symbols for test.
 386                  */
 387                 if (i >= next) {
 388                         memset(stat2, 0, sizeof(*stat2));
 389                         stat2->max = INT_MAX;
 390                         stat2->name = namebuf;
 391                         kallsyms_on_each_symbol(find_symbol, stat2);
 392
 393                         /*
 394                          * kallsyms_on_each_symbol() and kallsyms_on_each_match_symbol()
 395                          * need to get the same traversal result.
 396                          */
 397                         if (stat->addr != stat2->addr ||
 398                             stat->real_cnt != stat2->real_cnt ||
 399                             memcmp(stat->addrs, stat2->addrs,
 400                                    stat->save_cnt * sizeof(stat->addrs[0])))
 401                                 goto failed;
 402
 403                         /*
 404                          * The average of random increments is 128, that is, one of
 405                          * them is tested every 128 symbols.
 406                          */
 407                         get_random_bytes(&rand, sizeof(rand));
 408                         next = i + (rand & 0xff) + 1;
 409                 }
 410
 411                 /* Need to be found at least once */
 412                 if (!stat->real_cnt)
 413                         goto failed;
 414
 415                 /*
 416                  * kallsyms_lookup_name() returns the address of the first
 417                  * symbol found and cannot be NULL.
 418                  */
 419                 if (!lookup_addr || lookup_addr != stat->addrs[0])
 420                         goto failed;
 421
 422                 /*
 423                  * If the addresses of all matching symbols are recorded, the
 424                  * target address needs to be exist.
 425                  */
 426                 if (stat->real_cnt <= MAX_NUM_OF_RECORDS) {
 427                         for (j = 0; j < stat->save_cnt; j++) {
 428                                 if (stat->addrs[j] == addr)
 429                                         break;
 430                         }
 431
 432                         if (j == stat->save_cnt)
 433                                 goto failed;
 434                 }
 435         }
 436
 437         kfree(stat);
 438
 439         return 0;
 440
 441 failed:
 442         pr_info("Test for %dth symbol failed: (%s) addr=%lx", i, namebuf, addr);
 443         kfree(stat);
 444         return -ESRCH;
 445 }
 446
 447 static int test_entry(void *p)
 448 {
 449         int ret;
 450
 451         do {
 452                 schedule_timeout(5 * HZ);
 453         } while (system_state != SYSTEM_RUNNING);
 454
 455         pr_info("start\n");
 456         ret = test_kallsyms_basic_function();
 457         if (ret) {
 458                 pr_info("abort\n");
 459                 return 0;
 460         }
 461
 462         test_kallsyms_compression_ratio();
 463         test_perf_kallsyms_lookup_name();
 464         test_perf_kallsyms_on_each_symbol();
 465         test_perf_kallsyms_on_each_match_symbol();
 466         pr_info("finish\n");
 467
 468         return 0;
 469 }
 470
 471 static int __init kallsyms_test_init(void)
 472 {
 473         struct task_struct *t;
 474
 475         t = kthread_create(test_entry, NULL, "kallsyms_test");
 476         if (IS_ERR(t)) {
 477                 pr_info("Create kallsyms selftest task failed\n");
 478                 return PTR_ERR(t);
 479         }
 480         kthread_bind(t, 0);
 481         wake_up_process(t);
 482
 483         return 0;
 484 }
 485 late_initcall(kallsyms_test_init);