操作系统

使用 Clang 进行静态代码检测

2018-11-01 / Leave a Comment

一、Clang Static Analyzer 简介

Clang Static Analyzer 是一个工业级的静态源码检测工具，可以用来发现 C、C++ 和 Objective-C 程序中的 Bug。它既可以作为一个独立工具（scan-build）使用，也可以集成在 Xcode 中使用。

Clang Static Analyzer 建立在 Clang 和 LLVM 之上。严格地讲，它是 Clang 的一部分，因此它是完全开源的。Clang Static Analyzer 使用的静态分析引擎被实现为一个 C++ 库，可以在不同的客户端中重用，因此拥有很高的可扩展性。

二、scan-build 的使用

scan-build 就是 Clang Static Analyzer 的命令行工具。在 Clang 的二进制包中就可以直接找到它的身影，一般它与 Clang/Clang++ 同处于一个目录。

我们从一个示例开始：

#include<stdio.h>

#include<stdlib.h>

int main(int argc, const char* argv[]) {

void* ptr = malloc(sizeof(char));

free(ptr);

memset(ptr, 0, sizeof(char) * 2);

return 0;

}

scan-build 是在编译过程中检测代码的，因此必须和编译器一起协同工作，可以指定使用 gcc 或者 clang。注意，scan-build 会使用 clang/clang++ 做 analyze，即便指定编译器为 gcc/g++。

1	scan-build -o memleak gcc memleak.c

上述命令即对 memleak.c 进行检测，其中 -o 参数用于指定检测结果存放路径，检测结果会以 html 文件的形式保存：

可看到上述代码中的内存泄露问题被检测出来。以上是对于单个源码文件的检测，更好的方式是将 scan-build 直接与构建系统串接起来一起协同工作：

1	$ scan-build --use-cc gcc --use-c++ g++ make

三、使用 scan-build 处理交叉编译

交叉编译的场景下，除了指定 toolchain 之外，还要指定 analyzer-target，另外还需要指定 C/C++ 的 include 路径：

$ C_INCLUDE_PATH=path_1:path_2:...:path_n \

CPLUS_INCLUDE_PATH=path_1:path_2:...:path_n \

scan-build \

--use-cc=arm-linux-gnueabihf-gcc \

--use-c++=arm-linux-gnueabihf-g++ \

--analyzer-target=arm-linux-gnueabihf \

make [options]

其中 C_INCLUDE_PATH 和 CPLUS_INCLUDE_PATH 这两个变量都支持指定多个路径，中间使用冒号分隔。

对于大型程序，scan-build 会显著拖慢编译速度。另外，这类静态代码检测工具也有它的局限性，像内存访问越界类似的问题就不太可能检测得到，这时就要靠 Valgrind 和 Address Sanitizer 这些运行时的内存调试工具了。

参考：

进程退出的清理函数

2018-10-12 / Leave a Comment

有时候，我们期望在进程退出时做一些资源清理工作，比如释放共享内存、删除程序运行期间留下的一些临时文件等等。

一种方式是使用 __attribute__ 关键字将清理函数声明为 destructor 函数：

#include <stdio.h>

#include <stdlib.h>

__attribute__((destructor))

void cleanup() {

printf("%s\n", __func__);

}

int main() {

printf("%s\n", __func__);

return 0;

}

这样该清理函数就会在 main 函数结束后被执行。

$ ./a.out

main

cleanup

另外一种方式是使用 atexit 函数注册清理函数：

#include <stdio.h>

#include <stdlib.h>

__attribute__((constructor))

void func() {

printf("%s\n", __func__);

atexit([](){printf("global cleaner\n");});

}

int main() {

printf("%s\n", __func__);

atexit([]() {printf("main cleaner\n");});

return 0;

}

如上，在声明为 constructor 的 func 函数和 main 函数里面，通过 atexit 分别注册了两个匿名的清理函数，执行结果如下：

$ ./a.out

func

main

main cleanner

global cleanner

首先是 constructor 函数被执行，然后是 main 函数，接着是 main 函数注册的清理函数，最后是 constructor 函数注册的清理函数。这说明通过 atexit 注册的清理函数，其执行顺序是跟注册严格反序的，也就是最后注册的最先执行。

另外，值得注意的是，c++ 限制通过 atexit 最多可以注册 32 个清理函数。

重载 gcc 和 glibc 的内建函数

2018-10-11 / Leave a Comment

工作中常常遇到这样一种场景，出于调试需要，需要重载编译器或者运行库内建的一些函数，如 malloc、free 之类。

一、简单重载

最简单直接的方式就是重新定义：

void* malloc(size_t size) {

printf("my malloc");

return 0;

}

这样就会覆盖 glibc 内建的 malloc 函数。

二、符号别名

另外一种方式是使用 gcc 的 __attribute__ 关键字来为函数创建别名。

void* malloc(size_t) __attribute__((alias("my_malloc")));

void* my_malloc(size_t size) {

printf("%s\n", __func__);

return 0;

}

上述代码的含义是，为 my_malloc 函数创建了一个函数别名 malloc。这样一来，gcc 内建的 malloc 也就不再可用，所有调用到 malloc 的地方都将调用 my_malloc，也就达到了覆盖的目的。

三、LD_PRELOAD

LD_PRELOAD 是动态连接器支持的一个环境变量，可以指定共享库在程序运行时首先被装载，包括 C 语言运行库 glibc。

利用这个特性，如果在某个共享库里重载 glibc 内建的函数，然后使用 LD_PRELOAD 指定让其首先被装载，这样也能达到目的。

四、wrap 函数

以上几种方式的弊端在于，如果符号是对外可见的，那么所有模块的 malloc 函数都将被覆盖；如果符号不可见的话，只有模块内部才会使用重载的版本。如果我们期望某些模块使用重载的版本，而另一些模块使用编译器或者运行库内建的版本呢？

例如可执行程序 a.out 动态链接共享库 liba.so 和 libb.so，在 liba.so 里有对 gcc 编译器内建函数 malloc 的重载，我们期望 liba.so 和 a.out 都使用重载的 malloc，而 libb.so 使用 gcc 的版本。如果 liba.so 里面的 malloc 对外可见，那么 link 过程中，libb.so 和 a.out 都将使用重载的这一份；而如果不可见的话，a.out 将会使用 gcc 的这一份。

有人可能会想到，在每个需要重载的模块内都重载一遍 malloc，然后将其符号隐藏。这样确实可以达到目的，但是显得很笨拙，也会因重复的符号定义增大程序的体积。正确的方法是使用 ld 的 wrap 功能。

// malloc.c -> libmallo.so

#include <stdio.h>

void* __wrap_malloc(size_t size) {

printf("%s\n", __func__);

return NULL;

}

// liba.c -> liba.so

#include <stdio.h>

#include <stdlib.h>

void funcA() {

void* ptr1 = malloc(sizeof(int));

if (ptr1 == NULL) {

printf("%s malloc failed!\n", __func__);

} else {

printf("%s malloc success!\n", __func__);

}

// libb.c -> libb.so

#include <stdio.h>

#include <stdlib.h>

void funcB() {

void* ptr1 = malloc(sizeof(int));

if (ptr1 == NULL) {

printf("%s malloc failed!\n", __func__);

} else {

printf("%s malloc success!\n", __func__);

}

// test.c -> a.out

#include <stdio.h>

#include <stdlib.h>

extern void funcA();

extern void funcB();

int main(int argc, const char* argv[]) {

funcA();

funcB();

void* ptr1 = malloc(sizeof(int));

if (ptr1 == NULL) {

printf("%s malloc failed!\n", __func__);

} else {

printf("%s malloc success!\n", __func__);

}

return 0;

}

CC := gcc

CFLAGS := -g

libmalloc.so: malloc.c

$(CC) ${CFLAGS} -shared -fPIC $< -o $@ -fno-builtin-malloc -fvisibility=default -Wl,--wrap=malloc

liba.so: liba.c

$(CC) ${CFLAGS} -shared -fPIC $< -o $@ -Wl,--wrap=malloc

libb.so: libb.c

$(CC) ${CFLAGS} -shared -fPIC $< -o $@

a.out: test.c liba.so libb.so libmalloc.so

$(CC) ${CFLAGS} -pie -fPIE $< -o $@ -L./ -lb -la -lmalloc -Wl,--wrap=malloc

.PHONY: all clean rebuild

all: a.out

clean:

rm -rf *.o *.a *.so a.out core

rebuild: clean all

链接器会将 wrap 参数所指定的符号替换成重载的版本。这样可以对不同的共享库指定或者不指定 wrap 目标，来达成上述目的。

$ make all

gcc -g -shared -fPIC liba.c -o liba.so -Wl,--wrap=malloc

gcc -g -shared -fPIC libb.c -o libb.so

gcc -g -shared -fPIC malloc.c -o libmalloc.so -fno-builtin-malloc -fvisibility=default -Wl,--wrap=malloc

gcc -g -pie -fPIE test.c -o a.out -L./ -lb -la -lmalloc -Wl,--wrap=malloc

按照如上方式编译运行，结果如下：

$ ./a.out

__wrap_malloc

funcA malloc failed!

funcB malloc success!

__wrap_malloc

main malloc failed!

liba.so 和 a.out 都使用了重载的 malloc, 而 lib.so 使用的是 gcc 内置的版本。

一	二	三	四	五	六	日
						1
2	3	4	5	6	7	8
9	10	11	12	13	14	15
16	17	18	19	20	21	22
23	24	25	26	27	28	29
30	31

采蕨

码林野致

使用 Clang 进行静态代码检测

进程退出的清理函数

重载 gcc 和 glibc 的内建函数

一、简单重载

二、符号别名

三、LD_PRELOAD

四、wrap 函数