1. 内核中通过lookup_symbol_name获取函数名称
内核中很多结构体成员是函数，有时可能比较复杂不知道具体使用哪一个函数。这是可以通过lookup_symbol_name来获取符号表名称。
int lookup_symbol_name(unsigned long addr, char *symname)
{
symname[] = '\0';
symname[KSYM_NAME_LEN - ] = '\0'; if (is_ksym_addr(addr)) {----------------------------------------地址有效性检查
unsigned long pos; pos = get_symbol_pos(addr, NULL, NULL);
/* Grab name */
kallsyms_expand_symbol(get_symbol_offset(pos), symname);-----获取不好名称到symname
return ;
}
/* See if it's in a module. */
return lookup_module_symbol_name(addr, symname);------------------从module符号表中查找
}
在timer_list.c和timer_stats.c中有使用，如下：
static void print_name_offset(struct seq_file *m, unsigned long addr)
{
char symname[KSYM_NAME_LEN]; if (lookup_symbol_name(addr, symname) < )
seq_printf(m, "<%p>", (void *)addr);
else
seq_printf(m, "%s", symname);
}
2. 通过__builtin_return_address获取调用者函数地址
2.1 背景介绍：__builtin_return_address是GCC提供的一个内置函数，用于判断给定函数的调用者。
6.49 Getting the Return or Frame Address of a Function里面有更多获取函数调用者的介绍。
void * __builtin_return_address (unsigned int level)
level为参数，如果level为0，那么就是请求当前函数的返回地址；如果level为1，那么就是请求进行调用的函数的返回地址。
2.2 使用实例
内核中ftrace使用的较多：
#define CALLER_ADDR0 ((unsigned long)__builtin_return_address(0))
#define CALLER_ADDR1 ((unsigned long)return_address(1))
#define CALLER_ADDR2 ((unsigned long)return_address(2))
#define CALLER_ADDR3 ((unsigned long)return_address(3))
#define CALLER_ADDR4 ((unsigned long)return_address(4))
#define CALLER_ADDR5 ((unsigned long)return_address(5))
#define CALLER_ADDR6 ((unsigned long)return_address(6))
一个测试示例：
#include <stdio.h> void func_e(void)
{
printf("func_e(0)=%p\n", __builtin_return_address());-------------------------打印返回层级地址
printf("func_e(1)=%p\n", __builtin_return_address());
printf("func_e(2)=%p\n", __builtin_return_address());
printf("func_e(3)=%p\n", __builtin_return_address());
printf("func_e(4)=%p\n", __builtin_return_address());
printf("func_e(5)=%p\n", __builtin_return_address());
} void func_d(void)
{
func_e();
} void func_c(void)
{
func_d();
} void func_b(void)
{
func_c();
} void func_a(void)
{
func_b();
} int main(int argc, char *agrv[])
{
func_a();
printf("func_a=%p, func_b=%p, func_c=%p, func_d=%p, func_e=%p\n", func_a, func_b, func_c, func_d, func_e);---------------------打印函数地址
}
执行结果如下：
func_e()=0x4005f2
func_e()=0x4005fd
func_e()=0x400608
func_e()=0x400613
func_e()=0x400629
func_e()=0x7fba4af1af45
func_a=0x40060a, func_b=0x4005ff, func_c=0x4005f4, func_d=0x4005e9, func_e=0x40052d
使用addr2line -e file -f addrs，可以看出编译是否-g的区别：
| gcc caller.c -o caller | gcc caller.c -o caller -g |
|
addr2line -e caller -f 4005f2 |
addr2line -e caller -f 4005f2 |
通过nm xxxx也可以找到地址对应的函数名：
000000000040060a T func_a
00000000004005ff T func_b
00000000004005f4 T func_c
00000000004005e9 T func_d
000000000040052d T func_e
参考文档：
3. 基于HW Breakpoints的调试
3.1 HW Breakpoints背景
3.2
参考文档：
1. 《Hardware Breakpoint(or watchpoint) usage in Linux Kernel》
4. likely和unlikely机制
1.likely和unlikely背景
likely和unlikely在include/linux/compiler.h中定义：
#if defined(CONFIG_TRACE_BRANCH_PROFILING) \------------------------------------------------------------------带调试信息的likely和unlikelly
&& !defined(DISABLE_BRANCH_PROFILING) && !defined(__CHECKER__)
...
# ifndef likely
# define likely(x) (__builtin_constant_p(x) ? !!(x) : __branch_check__(x, ))
# endif
# ifndef unlikely
# define unlikely(x) (__builtin_constant_p(x) ? !!(x) : __branch_check__(x, ))
# endif
...
#else
# define likely(x) __builtin_expect(!!(x), )--------------------------------------------------------------不带调试信息
# define unlikely(x) __builtin_expect(!!(x), )
#endif
__builtin_expect()是GCC从2.96开始支持的分支预测功能，降低因为指令跳转带来的分支下降，它的返回值就是它的第一个参数传递给它的值。
2.机制详解
__builtin_expect()通过改变汇编指令顺序，来充分利用处理器的流水线，直接执行最有可能的分支指令，而尽可能避免执行跳转指令(jmp)。因为jmp指令会刷新CPU流水线，而影响执行时间。
#include <stdio.h> #define likely(x) __builtin_expect(!!(x), 1)
#define unlikely(x) __builtin_expect(!!(x), 0) int main(char *argv[], int argc)
{
int a; /* Get the value from somewhere GCC can't optimize */
a = atoi (argv[]); if (unlikely (a == ))--------------------------if (likely (a == 2))
a++;
else
a--; printf ("%d\n", a); return ;
}
使用gcc xxx.c -o xxx -O2 -g编译。
通过gdb xxxx -q，然后disassemble main可以看出两者区别，左边是unlikely，右边是likely。
再来通过objdump -S xxx看一下结果。
unlikely反汇编结果如下：
Disassembly of section .text: 00000000004004b0 <main>: #define likely(x) __builtin_expect(!!(x), 1)
#define unlikely(x) __builtin_expect(!!(x), 0) int main(char *argv[], int argc)
{
4004b0: ec sub $0x8,%rsp
int a; /* Get the value from somewhere GCC can't optimize */
a = atoi (argv[]);
4004b4: 8b 7f mov 0x8(%rdi),%rdi
4004b8: c0 xor %eax,%eax
4004ba: e8 e1 ff ff ff callq 4004a0 <atoi@plt> if (unlikely (a == ))
4004bf: f8 cmp $0x2,%eax
4004c2: 1b je 4004df <main+0x2f>--------------------如果cmp返回的结果是等于，就跳转到0x4004df地址，也即a++。
a++;
else
a--;
4004c4: 8d ff lea -0x1(%rax),%edx-----------------------不跳转的情况下，顺序执行a--这条指令。这种情况不需要跳转，一直到retq结束。
} __fortify_function int
printf (const char *__restrict __fmt, ...)
{
return __printf_chk (__USE_FORTIFY_LEVEL - , __fmt, __va_arg_pack ());
4004c7: be mov $0x400654,%esi-----------------------printf也是接着a--这条语句，也不需要跳转。
4004cc: bf mov $0x1,%edi
4004d1: c0 xor %eax,%eax
4004d3: e8 b8 ff ff ff callq <__printf_chk@plt> printf ("%d\n", a); return ;
}
4004d8: c0 xor %eax,%eax
4004da: c4 add $0x8,%rsp
4004de: c3 retq /* Get the value from somewhere GCC can't optimize */
a = atoi (argv[]); if (unlikely (a == ))
a++;
4004df: ba mov $0x3,%edx----------------------------------对应a++这句指令。
4004e4: eb e1 jmp 4004c7 <main+0x17>-------------------------跳转到printf这条指令，这种情况跳转了两次。
likely反汇编结果如下：
00000000004004b0 <main>: #define likely(x) __builtin_expect(!!(x), 1)
#define unlikely(x) __builtin_expect(!!(x), 0) int main(char *argv[], int argc)
{
4004b0: ec sub $0x8,%rsp
int a; /* Get the value from somewhere GCC can't optimize */
a = atoi (argv[]);
4004b4: 8b 7f mov 0x8(%rdi),%rdi
4004b8: c0 xor %eax,%eax
4004ba: e8 e1 ff ff ff callq 4004a0 <atoi@plt> if (likely (a == ))
4004bf: f8 cmp $0x2,%eax
4004c2: 1d jne 4004e1 <main+0x31>------------------不等于就跳转到a--，预测是等于2的情况。所以紧接的语句是a++。
a++;
4004c4: ba mov $0x3,%edx---------------------------a++对应的指令。
} __fortify_function int
printf (const char *__restrict __fmt, ...)
{
return __printf_chk (__USE_FORTIFY_LEVEL - , __fmt, __va_arg_pack ());
4004c9: be mov $0x400654,%esi----------------------紧接着的是printf知道retq结束。
4004ce: bf mov $0x1,%edi
4004d3: c0 xor %eax,%eax
4004d5: e8 b6 ff ff ff callq <__printf_chk@plt>
a--; printf ("%d\n", a); return ;
}
4004da: c0 xor %eax,%eax
4004dc: c4 add $0x8,%rsp
4004e0: c3 retq
a = atoi (argv[]); if (likely (a == ))
a++;
else
a--;
4004e1: 8d ff lea -0x1(%rax),%edx---------------------在cmp不等于情况下，跳转到此处。
4004e4: eb e3 jmp 4004c9 <main+0x19>------------------a--之后再跳转回printf，两次跳转。
3.总结
如上汇编分析，__builtin_expect()的使用可以降低分置于句的跳转，按顺序执行，来减小对指令流水的刷新，从而加快程序的执行。
当预测a最有可能是2时，a++的指令紧接着判断语句，顺序执行的可能性很大。
当预测a最不可能是2是，a--的指令紧接着判断语句，a--被执行的可能性最大。
参考文档：
2. linux kernel中likely和unlikely宏的机制分析