首页 > 代码库 > 【转】linux内核kallsyms机制分析

【转】linux内核kallsyms机制分析

2024-07-27 15:32:09   233人阅读

  1. 一、前言
  2. Linux内核是一个整体结构，而模块是插入到内核中的插件。尽管内核不是一个可安装模块，但为了方便起见，Linux把内核也看作一个模块。那么模块与模块之间如何进行交互呢，一种常用的方法就是共享变量和函数。但并不是模块中的每个变量和函数都能被共享，内核只把各个模块中主要的变量和函数放在一个特定的区段，这些变量和函数就统称为符号。
  4. 因此，内核也有一个module结构，叫做kernel_module。另外，从kernel_module开始，所有已安装模块的module结构都链在一起成为一条链，内核中的全局变量module_list就指向这条链：
  5. struct module *module_list = &kernel_module；
  7. 一般来说，内核只会导出由EXPORT_PARM宏指定的符号给模块使用。为了使debugger提供更好的调试功能，需要使用kallsyms工具为内核生成__kallsyms段数据，该段描述所有不处在堆栈上的内核符号。这样debugger就能更好地解析内核符号，而不仅仅是内核指定导出的符号。
  9. 二、简介
  10. 在v2.6.0 的内核中，为了更好地调试内核，引入新的功能kallsyms.kallsyms把内核用到的所有函数地址和名称连接进内核文件，当内核启动后，同时加载到内存中.当发生oops，例如在内核中访问空地址时，内核就会解析eip位于哪个函数中，并打印出形如：
  11. EIP is at cleanup_module+0xb/0x1d [client]的信息,
  12. 调用栈也用可读的方式显示出来.
  13. Call Trace:
  14. [<c013096d>] sys_delete_module+0x191/0x1ce
  15. [<c02dd30a>] do_page_fault+0x189/0x51d
  16. [<c0102bc1>] syscall_call+0x7/0xb
  18. 当然功能不仅仅于此，还可以查找某个函数例如的sys_fork的地址，然后hook它，kprobe就是这么干的。在v2.6.20 中,还可以包含所有符号的地址，应此功能更强大，就相当于内核中有了System.map了,此时查找sys_call_table的地址易如反掌。
  20. 三.sym的生成
  21. 1.形成过程
  22. Linux内核符号表/proc/kallsyms的形成过程
  23. （1）./scripts/kallsyms.c负责生成System.map
  24. （2）./kernel/kallsyms.c负责生成/proc/kallsyms
  25. （3）./scripts/kallsyms.c解析vmlinux(.tmp_vmlinux)生成kallsyms.S(.tmp_kallsyms.S)，然后内核编译过程中将kallsyms.S(内核符号表)编入内核镜像uImage.内核启动后./kernel/kallsyms.c解析uImage形成/proc/kallsyms
  28. 2.内核配置
  29. 在2.6 内核中，为了更好地调试内核，引入了kallsyms。kallsyms抽取了内核用到的所有函数地址(全局的、静态的)和非栈数据变量地址，生成一个数据块，作为只读数据链接进kernel image，相当于内核中存了一个System.map。需要配置CONFIG_KALLSYMS。
  31. .config
  32. CONFIG_KALLSYMS=y 符号表中包含所有的函数
  33. CONFIG_KALLSYMS_ALL=y 符号表中包括所有的变量(包括没有用EXPORT_SYMBOL导出的变量)
  34. CONFIG_KALLSYMS_EXTRA_PASS=y
  35. make menuconfig
  36. General setup ---> 
  37.     [*] Configure standard kernel features (for small systems) --->
  38.         [*] Load all symbols for debugging/ksymoops （选中此项，才有/proc/kallsyms接口文件, oops问题，选中此选项即可，子选项可以忽略）
  40.               [*] Include all symbols in kallsyms
  41.               [*] Do an extra kallsyms pass 
  43. 3.编译生成列表
  44. 内核编译的最后阶段,make会执行
  45. nm -n vmlinux|scripts/kallsyms
  46. nm -n vmlinux生成所有的内核符号,并按地址排序,形如
  47. ......
  48. c0100000 T startup_32
  49. c0100000 A _text
  50. c01000c6 t checkCPUtype
  51. c0100147 t is486
  52. c010014e t is386
  53. c010019f t L6
  54. c01001a1 t check_x87
  55. c01001ca t setup_idt
  56. c01001e7 t rp_sidt
  57. c01001f4 t ignore_int
  58. c0100228 T calibrate_delay
  59. c0100228 T stext
  60. c0100228 T _stext
  61. c010036b t rest_init
  62. c0100410 t do_pre_smp_initcalls
  63. c0100415 t run_init_process
  64. ......
  65. v2.6.0 的行数是2.5万左右
  67. 4.处理列表
  68. scripts/kallsyms则处理这个列表，并生成连接所需的S文件kallsyms.S。在linux3.12中使用/scripts/kallsyms处理此列表。v2.6.0中形如：
  69. #include <asm/types.h>
  70. #if BITS_PER_LONG == 64
  71. #define PTR .quad
  72. #define ALGN .align 8
  73. #else
  74. #define PTR .long
  75. #define ALGN .align 4
  76. #endif
  77. .data
  78. .globl kallsyms_addresses
  79.         ALGN
  80. kallsyms_addresses:
  81.         PTR 0xc0100228
  82.         PTR 0xc010036b
  83.         PTR 0xc0100410
  84.         PTR 0xc0100415
  85.         PTR 0xc010043c
  86.         PTR 0xc0100614
  87. ...
  88. .globl kallsyms_num_syms
  89.         ALGN
  90. kallsyms_num_syms:
  91.         PTR 11228
  93. .globl kallsyms_names
  94.         ALGN
  95. kallsyms_names:
  96.         .byte 0x00
  97.         .asciz "calibrate_delay"
  98.         .byte 0x00
  99.         .asciz "stext"
  100.         .byte 0x00
  101.         .asciz "_stext"
  102. ...
  103. 生成的符号表部分如下：
  104. /*
  105.     ......
  106.     c1618b03 t __raw_write_unlock_irq.constprop.29
  107.     c1618b19 T panic
  108.     c1618c91 T printk
  109.     ......
  110.     c16a4d6b r __func__.17404
  111.     c16a4d78 R kallsyms_addresses
  112.     c16ef0dc R kallsyms_num_syms
  113.     c16ef0e0 R kallsyms_names
  114.     c17d5468 R kallsyms_markers
  115.     c17d590c R kallsyms_token_table
  116.     c17d5c78 R kallsyms_token_index    
  117.     ......
  118. */
  120. 5.生成的符号数组解析
  121. 1)kallsyms_addresses数组包含所有内核函数的地址(经过排序的),v2.6.0 中相同的地址在kallsyms_addresses中只允许出现一次，到后面的版本例如相同的地址可以出现多次，这样就允许同地址函数名的出现。
  122. 例如：
  123. kallsyms_addresses:
  124. PTR 0xc0100228
  125. PTR 0xc0100228
  126. PTR 0xc0100228
  127. PTR 0xc010036b
  128. 当查找某个地址时所在的函数时，v2.6.0 采用的是线性法，从头到尾地找，很低效，后来改成了折半查找，效率好多了。
  130. 2)kallsyms_num_syms是函数个数
  132. 3)kallsyms_names是函数名数组。
  134. <1>以前的算法是：函数名数组组成的一个大串,这个大串是有许多小串组成,格式是：
  135. .byte len
  136. .asciz 压缩串
  138. 格式例如：
  139. kallsyms_names:
  140. .byte 0x00
  141. .asciz "calibrate_delay"
  142. .byte 0x00
  143. .asciz "stext"
  144. .byte 0x00
  145. .asciz "_stext"
  146. .byte 0x00
  147. .asciz "rest_init"
  149. len代表本函数名和前一函数名相同前缀的大小，例如
  150. .byte 0x00
  151. .asciz "early_param_test"
  152. .byte 0x06
  153. .asciz "setup_test"
  154. .byte 0x06,说明串setup_test和串early_parm_test有着相同的前缀，长为6，即early_,所有setup_test最终解压后的函数名为early_setup_test.由于没有其他的辅助手段，函数名的解析过程也很低效,从头一直解析到该函数位置为止。
  156. <2>在后来的版本中，算法有了改善，使用了偏移索引和高频字符串压缩。也就是现在常用的算法。格式是：
  157. .byte len ascii字符 ascii字符...（len个ascii字符）
  159. 先建立token的概念,token就是所有函数名中，出现频率非常高的那些字符串.由于标识符命名
  160. 规则的限制，有许多ascii字符是未用到的，那么，可以用这些字符去替代这些高频串。例如下面的例子：
  161. 字符值 字符代表的串
  162. 190 .asciz "t.text.lock."
  163. 191 .asciz "text.lock."
  164. 192 .asciz "t.lock."
  165. 193 .asciz "lock."
  166. 210 .asciz "tex"
  167. 229 .asciz "t."
  168. 239 .asciz "loc"
  169. 249 .asciz "oc"
  170. 250 .asciz "te"
  172. 例如串.byte 0x03, 0xbe, 0xbc, 0x71的解析
  173. 串长3，
  174. 0xbe(190) .asciz "t.text.lock."
  175. 0xbc(189) .asciz "ir"
  176. 0x71(113) .asciz "q"
  177. 所以该串解析后的值是 t.text.lock.irq,注意实际的串值是.text.lock.irq,前面的t是类型,这是新版本加入的功能，将类型字符放在符号前。
  179. .byte 0x02, 0x08, 0xc2
  180. 串长2，
  181. 0x08,8 .asciz "Tide_"
  182. 0xc2,194 .asciz "init"
  183. 所以该串解析后的值是 Tide_init，即ide_init
  185. 4)为了解析而设置了数据结构kallsyms_token_table和kallsyms_token_index.结构kallsyms_token_table记录每个ascii字符的替代串，kallsyms_token_index记录每个ascii字符的替代串在kallsyms_token_table中的偏移.
  187. 5)而数据结构的改变是，把函数名每256个分一组，用一个数组kallsyms_markers记录这些组在
  188. kallsyms_names中的偏移，这样查找就方便多了，不必从头来。
  190. 四、符号表的查找
  191. 通过对以上格式的了解，我们就可以自己编写程序找到内核中的符号表，进而找到每个内核符号的地址。
  192. 1.首先找到kallsyms_addresses数组
  193. //首先获得kallsyms_addresses数组中的printk的地址
  194. printk_addr_addr = prink_addr_addr();
  196. static void * prink_addr_addr(void){
  197.     unsigned int i = 0xc0000000;
  198.     int k = 0;
  199.     
  200.     //kallsyms_addresses数组中都是保存的是内核符号的地址，所以这里查找的是地址下的保存的函数地址是否为printk的函数地址
  201.     for(;i < 0xf0000000; i += 4){
  202.         if(*((unsigned int *)i) == (unsigned int)printk){
  203.             //判断该地址前边都是有效的kallsyms_addresses数组函数地址        
  204.             if(isfunaddr(*((unsigned int *)(i-4)))&&isfunaddr(*((unsigned int *)(i-8)))){
  205.                 if(!k)
  206.                     return (void *)i;
  207.                 else
  208.                     ++k;
  209.             }
  210.         }        
  211.     }
  212.     return NULL;
  213. }
  215. //只要该函数符号在kallsyms_addresses数组中，通过%Ps打印结构一定是...+0x0/...
  216. static int isfunaddr(unsigned int addr){
  217.     char buff[200] = {0};
  218.     int i = 0;
  220.     memset(buff,0,sizeof(buff));
  221.     //get the %pS print format; 
  222.     sprintf(buff,"%pS",(void *)addr);
  224.     //if is a function addr ,it‘s %pS print format must be: ...+0x0/...
  225.     if((buff[0]==‘0‘)&&(buff[1]==‘x‘))
  226.         return 0;
  227.     while(buff[i++]){
  228.         if((buff[i] == ‘+‘)&&(buff[i+1]==‘0‘)&&(buff[i+2]==‘x‘)&&(buff[i+3]==‘0‘)&&(buff[i+4]==‘/‘))
  229.             return 1;
  230.     }
  231.     return 0;
  232. }
  234. //通过printk的地址查找到kallsyms_addresses的结束地址kallsyms_addresses数组结尾处
  235. funaddr_endaddr = find_funadd_endaddr(printk_addr_addr);
  237. //一直循环查找最后一个符号不为...+0x0/...结构，即找到了
  238. static void * find_funadd_endaddr(void * in){
  239.     unsigned int * p = in;
  240.     for(;isfunaddr(*p); ++p);
  241.     return (void *)(p-1);
  242. }
  244. //kallsyms_addresses数组尾地址+4就是符号个数kallsyms_num的地址，就能得到符号的个数
  245. kallsyms_num = *((unsigned int *)funaddr_endaddr + 1);
  247. //根据符号个数和kallsyms_addresses数组尾地址就能得到kallsyms_addresses数组的首地址
  248. kallsyms_addr = (unsigned int *)funaddr_endaddr - kallsyms_num + 1;
  250. 2.找到kallsyms_name地址。
  251. //kallsyms_num地址的下一项就是kallsyms_name地址
  252. kallsyms_name = (void *)((unsigned int *)funaddr_endaddr + 2);    
  254. 3.kallsyms_name数组的下一项是kallsyms_mark数组，但是他们的地址不是连续的。
  255. //把函数名每256个分一组，用一个数组kallsyms_markers记录这些组在kallsyms_names中的偏移
  256. kallsyms_mark = get_marker_addr(kallsyms_name );
  258. //因为数组kallsyms_name中的格式是：.byte len ascii码...(len个)
  259. static void * get_marker_addr(void * name){
  260.     int i = 0;
  261.     unsigned char * base = (char *)name;
  262.     
  263.     //base[0]存的是.byte替代串的ascii码，base[1]存的是ascii码个数
  264.     //所以依次跳过kallsyms_num个name就找到了kallsyms_mark数组的地址
  265.     for(; i < kallsyms_num ; ++i){
  266.         base += (base[0] +1);
  267.     }
  268.     
  269.     //4字节对齐
  270.     if((unsigned int)base%4){
  271.         base += (4-(unsigned int)base%4);
  272.     }
  274.     return (void *)base;    
  275. }
  277. 4.计算kallsyms_mark数组表项个数
  278. //根据符号个数计算kallsyms_mark数组的个数，符号以256个为一组
  279. mark_num = kallsyms_num%256 ? kallsyms_num/256 + 1:kallsyms_num/256;
  280.     
  281. 5.获取结构kallsyms_token_table地址
  282. //结构kallsyms_token_table记录每个ascii字符的替代串，位于kallsyms_mark数组之后
  283. kallsyms_token_tab = (void *)((unsigned int *)kallsyms_mark + mark_num);
  285. 6.获得kallsyms_token_indx地址
  286. //kallsyms_token_index记录每个ascii字符的替代串在kallsyms_token_table中的偏移.
  287. kallsyms_token_indx = get_index_addr(kallsyms_token_tab);
  289. //因为kallsyms_token_table里存放的都是字符类型，依次跳过合法的字符类型之后的地址就是kallsyms_token_indx地址
  290. static void * get_index_addr(void * base){
  291.     
  292.     char * p = (char *)base;
  293.     for(;is_funname_char(*p);p++){
  294.         for(;is_funname_char(*p); p++);
  295.     }
  297.     //align 4 bytes
  298.     if((unsigned int)p%4){
  299.         p += (4 -(unsigned int)p%4);
  300.     }
  301.     return (void *)p;
  302. }
  304. //检查是否为函数符号名的合法字符
  305. static int is_funname_char( char p){
  306.     if( ((p >= ‘a‘)&&(p <=‘z‘)) || ((p >= ‘A‘)&&(p <=‘Z‘)) || (p == ‘_‘) || ( (p >=‘0‘)&&(p <= ‘9‘) ) || (p == ‘.‘))
  307.         return 1;
  308.     else
  309.         return 0;
  310. }
  312. 7.查找函数名地址
  313. static void * name_2_addr(char * name){
  314.     char namebuff[200];
  315.     unsigned int i = 0;
  316.     unsigned int len = 0;
  317.     //符号名称数组
  318.     unsigned char * name_tab = (unsigned char *)kallsyms_name;
  319.     unsigned int mod_addr = 0;
  320.     char * buff_ptr = namebuff; 
  322.     //遍历所有符号
  323.     for(; i < kallsyms_num; ++i){ 
  324.         memset(namebuff,0,200);
  325.         buff_ptr = namebuff;
  326.         len = *name_tab;//符号名称长度
  327.         name_tab++;//符号名对应的ascii码
  329.         while(len){
  330.             //根据符号名对应的ascii码得到符号名
  331.             buff_ptr = cp_from_token_tab(buff_ptr,
  332.                                     //得到该ascii码对应的字符串在kallsyms_token_table中的偏移
  333.                                     ((unsigned short *)kallsyms_token_indx)[*name_tab]);
  334.             name_tab++;
  335.             len--;
  336.         }
  338.         //检查符号名是否一致，其中第一个字符为符号类型，忽略掉
  339.         if(my_strcmp(name,namebuff+1)==0){
  340.             //若相等返回该符号地址    
  341.             return (void *)((unsigned int *)kallsyms_addr)[i];
  342.         }
  343.     }
  344. }
  346. static char * cp_from_token_tab(char * buff,unsigned short off)
  347. {
  348.     int len = 0;
  349.     //从kallsyms_token_tab数组的偏移处取得字符串，字符串以“\0”隔开
  350.     char * token_tab = &(((char *)kallsyms_token_tab)[off]);
  351.     for(;token_tab[len]; ++len){
  352.         *buff = token_tab[len];
  353.         buff++;
  354.     };
  355.     return buff;
  356. }
  358. 五、符号解析
  359. //v2.6.20 当发生oops时，
  360. fastcall void __kprobes do_page_fault(struct pt_regs *regs,unsigned long error_code)
  361. {
  362.     ...
  363.     die("Oops", regs, error_code);
  364.     ...
  365. }
  367. void die(const char * str, struct pt_regs * regs, long err)
  368. {
  369.     ...
  370.     print_symbol("%s", regs->eip);//解析
  371.     ...
  372. }
  375. static inline void print_symbol(const char *fmt, unsigned long addr)
  376. {
  377.     __check_printsym_format(fmt, "");
  378.     __print_symbol(fmt, (unsigned long)__builtin_extract_return_addr((void *)addr));
  379. }
  382. void __print_symbol(const char *fmt, unsigned long address)
  383. {
  384.     char buffer[KSYM_SYMBOL_LEN];
  385.      
  386.      //取得该地址的符号信息，存入buffer中
  387.     sprint_symbol(buffer, address);
  388.   //将buffer中的符号信息打印出来
  389.     printk(fmt, buffer);
  390. }
  392. int sprint_symbol(char *buffer, unsigned long address)
  393. {
  394.     return __sprint_symbol(buffer, address, 0, 1);
  395. }
  397. static int __sprint_symbol(char *buffer, unsigned long address,int symbol_offset, int add_offset)
  398. {
  399.     char *modname;
  400.     const char *name;
  401.     unsigned long offset, size;
  402.     int len;
  403.     
  404.     address += symbol_offset;//符号偏移是0
  405.     //解析地址，返回函数起始地址，大小，偏移，函数名
  406.     name = kallsyms_lookup(address, &size, &offset, &modname, buffer);
  407.     if (!name)
  408.         return sprintf(buffer, "0x%lx", address);
  409.     
  410.     //先拷贝该地址对应的函数名给buffer[]
  411.     if (name != buffer)
  412.         strcpy(buffer, name);
  413.         
  414.     len = strlen(buffer);
  415.     offset -= symbol_offset;
  416.     
  417.     //将该函数符号的偏移地址和大小拷贝给buffer[]
  418.     if (add_offset)
  419.         len += sprintf(buffer + len, "+%#lx/%#lx", offset, size);
  420.     
  421.     //若属于模块，则拷贝模块名给buffer[]
  422.     if (modname)
  423.         len += sprintf(buffer + len, " [%s]", modname);
  424.     
  425.     return len;
  426. }
  428. const char *kallsyms_lookup(unsigned long addr,unsigned long *symbolsize,unsigned long *offset,char **modname, char *namebuf)
  429. {
  430.     namebuf[KSYM_NAME_LEN - 1] = 0;
  431.     namebuf[0] = 0;
  432.     
  433.     //检查是否为内核符号
  434.     if (is_ksym_addr(addr)) {
  435.         unsigned long pos;
  436.         //取得符号的大小和偏移，返回符号在kallsyms_addresses数组中的索引值
  437.         pos = get_symbol_pos(addr, symbolsize, offset);
  438.         //解析符号，获得符号名称存入namebuf
  439.         kallsyms_expand_symbol(get_symbol_offset(pos),namebuf, KSYM_NAME_LEN);
  440.         if (modname)
  441.             *modname = NULL;
  442.         return namebuf;
  443.     }
  444.     
  445.     //若不是内核符号，则扫描内核中已安装的模块中的符号
  446.     return module_address_lookup(addr, symbolsize, offset, modname,namebuf);
  447. }
  449. static unsigned long get_symbol_pos(unsigned long addr,unsigned long *symbolsize,unsigned long *offset)
  450. {
  451.     unsigned long symbol_start = 0, symbol_end = 0;
  452.     unsigned long i, low, high, mid;
  453.     
  454.     /* This kernel should never had been booted. */
  455.     BUG_ON(!kallsyms_addresses);
  456.     
  457.     low = 0;
  458.     //kallsyms_num_syms是内核函数个数
  459.     high = kallsyms_num_syms;
  460.     
  461.     //折半查找，kallsyms_addresses数组包含所有内核函数的地址(经过排序的)
  462.     while (high - low > 1) {
  463.         mid = low + (high - low) / 2;
  464.         if (kallsyms_addresses[mid] <= addr)
  465.             low = mid;
  466.         else
  467.             high = mid;
  468.     }
  469.     
  470.     //找到第一个对齐的符号，即相同地址中的第一个。v2.6.0中相同的地址在kallsyms_addresses中只允许出现一次，到后面的版本例如相同的地址可以出现多次，这样就允许同地址函数名的出现。
  471.     while (low && kallsyms_addresses[low-1] == kallsyms_addresses[low])
  472.         --low;
  473.     
  474.     //获得函数地址小于addr最接近的一个内核函数的地址作为符号的起始地址
  475.     symbol_start = kallsyms_addresses[low];
  476.     
  477.     //找到下一个不同的地址
  478.     for (i = low + 1; i < kallsyms_num_syms; i++) {
  479.         if (kallsyms_addresses[i] > symbol_start) {
  480.             symbol_end = kallsyms_addresses[i];
  481.             break;
  482.         }
  483.     }
  484.     
  485.     /* If we found no next symbol, we use the end of the section. */
  486.     if (!symbol_end) {
  487.         if (is_kernel_inittext(addr))
  488.             symbol_end = (unsigned long)_einittext;
  489.         else if (all_var)
  490.             symbol_end = (unsigned long)_end;
  491.         else
  492.             symbol_end = (unsigned long)_etext;
  493.     }
  494.     
  495.     //获得符号的大小
  496.     if (symbolsize)
  497.         *symbolsize = symbol_end - symbol_start;
  498.     
  499.     //符号的偏移量    
  500.     if (offset)
  501.         *offset = addr - symbol_start;
  502.     
  503.     //返回在kallsyms_addresses数组中的索引值
  504.     return low;
  505. }
  507. //返回符号在kallsyms_names中的偏移
  508. static unsigned int get_symbol_offset(unsigned long pos)
  509. {
  510.     const u8 *name;
  511.     int i;
  512.     
  513.     //找到该组在kallsyms_names中的偏移。pos>>8即是pos/256得到kallsyms_markers的索引，kallsyms_markers数组中存储的是每256个分一组的组在kallsyms_names的偏移。
  514.     //kallsyms_names是函数名组成的一个大串,这个大串是有许多小串组成,格式是:
  515.     //.byte len ascii码 ascii码...(len个)
  516.     name = &kallsyms_names[ kallsyms_markers[pos>>8] ];
  517.     
  518.     //依次跳过(pos&0xFF)个偏移即是当前符号的偏移地址处，(*name) + 1存的是len
  519.     for(i = 0; i < (pos&0xFF); i++)
  520.         name = name + (*name) + 1;//
  521.     
  522.     return name - kallsyms_names;//返回该符号在kallsyms_names组中偏移
  523. }
  525. static unsigned int kallsyms_expand_symbol(unsigned int off, char *result)
  526. {
  527.   int len, skipped_first = 0;
  528.   const u8 *tptr, *data;
  530.   /* get the compressed symbol length from the first symbol byte */
  531.   data = &kallsyms_names[off];//取该sym的首地址
  532.   len = *data;//取sym压缩后的长度
  533.   data++;//指向压缩串
  534.     
  535.     //指向下一个压缩串偏移
  536.   off += len + 1;
  538.   //为了解析而设置了数据结构kallsyms_token_table和kallsyms_token_indexkallsyms_token_table记录每个ascii字符的替代串，kallsyms_token_index记录每个ascii字符的替代串在kallsyms_token_table中的偏移.
  539.   while(len) {
  540.      //对于*data指向的字符，在token_index查找该字符所代表的解压串偏移，并从token_table中找到该解压串
  541.      tptr = &kallsyms_token_table[ kallsyms_token_index[*data] ];
  542.      data++;
  543.      len--;
  544.      while (*tptr) {
  545.       if(skipped_first) {//跳过类型字符，例如t,T
  546.         *result = *tptr;//拷贝解压串
  547.         result++;
  548.       } else
  549.         skipped_first = 1;
  550.       tptr++;
  551.      }
  552.   }
  553.   *result = ‘\0‘;
  554.   
  555.     //返回下一个压缩串偏移
  556.   return off;
  557. }
  559. const char *module_address_lookup(unsigned long addr,unsigned long *size,unsigned long *offset,char **modname,char *namebuf)
  560. {
  561.     struct module *mod;
  562.     const char *ret = NULL;
  563.     
  564.     preempt_disable();
  565.     //遍历内核中的所有模块
  566.     list_for_each_entry_rcu(mod, &modules, list) {
  567.         if (mod->state == MODULE_STATE_UNFORMED)
  568.             continue;
  569.         //addr是否在模块的init部分或者core部分
  570.         if (within_module_init(addr, mod) ||within_module_core(addr, mod)) {
  571.             if (modname)
  572.             *modname = mod->name;//取得模块名
  573.             ret = get_ksymbol(mod, addr, size, offset);
  574.             break;
  575.         }
  576.     }
  577.     /* Make a copy in here where it‘s safe */
  578.     if (ret) {
  579.         strncpy(namebuf, ret, KSYM_NAME_LEN - 1);
  580.         ret = namebuf;
  581.     }
  582.     preempt_enable();
  583.     return ret;
  584. }
  586. static const char *get_ksymbol(struct module *mod,unsigned long addr,unsigned long *size,unsigned long *offset)
  587. {
  588.     unsigned int i, best = 0;
  589.     unsigned long nextval;
  590.      
  591.     /* At worse, next value is at end of module */
  592.     if (within_module_init(addr, mod))
  593.         nextval = (unsigned long)mod->module_init+mod->init_text_size;
  594.     else
  595.         nextval = (unsigned long)mod->module_core+mod->core_text_size;
  596.     
  597.     /* Scan for closest preceding symbol, and next symbol. (ELF
  598.     starts real symbols at 1). */
  599.     //遍历模块的符号
  600.     for (i = 1; i < mod->num_symtab; i++) {
  601.         if (mod->symtab[i].st_shndx == SHN_UNDEF)//跳过未定义的符号
  602.             continue;
  603.     
  604.         /* We ignore unnamed symbols: they‘re uninformative
  605.         * and inserted at a whim. */
  606.         if (mod->symtab[i].st_value <= addr
  607.             && mod->symtab[i].st_value > mod->symtab[best].st_value
  608.             && *(mod->strtab + mod->symtab[i].st_name) != ‘\0‘
  609.             && !is_arm_mapping_symbol(mod->strtab + mod->symtab[i].st_name))
  610.                 best = i;
  611.         if (mod->symtab[i].st_value > addr
  612.             && mod->symtab[i].st_value < nextval
  613.             && *(mod->strtab + mod->symtab[i].st_name) != ‘\0‘
  614.             && !is_arm_mapping_symbol(mod->strtab + mod->symtab[i].st_name))
  615.                 nextval = mod->symtab[i].st_value;
  616.     }
  617.      
  618.     if (!best)
  619.         return NULL;
  620.     
  621.     if (size)
  622.         *size = nextval - mod->symtab[best].st_value;
  623.     if (offset)
  624.         *offset = addr - mod->symtab[best].st_value;
  625.     return mod->strtab + mod->symtab[best].st_name;
  626. }
  628. 六、符号属性
  629. 若符号在内核中是全局性的，则属性为大写字母，如T、U等。
  630. b:符号在未初始化数据区（BSS）
  631. c:普通符号，是未初始化区域
  632. d:符号在初始化数据区
  633. g:符号针对小object，在初始化数据区 
  634. i:非直接引用其他符号的符号 
  635. n:调试符号 
  636. r:符号在只读数据区 
  637. s:符号针对小object，在未初始化数据区 
  638. t:符号在代码段 
  639. u:符号未定义

【转】linux内核kallsyms机制分析


联系
我们