zabbix源码分析之基础篇

r囧r小猫 2022-06-06 03:28 384阅读 0赞

# zabbix\_aggentd 源码分析之基础篇 #

## zabbix 源码组织结构 ##

zabbix是采用Automake方式构建的开源项目，服务和工具是通过C语言实现，实现来跨平台的能力，目前zabbix\_server还不支持Windows系统。  
主要的目录是：  
src为C代码的源码目录，include为C代码的头文件，frontends为前端php代码。  
src目录libs，modules和各功能主程序的目录，zabbix\_agent就是本文需要分析的主目录。

## zabbix编码规范和宏定义的解释 ##

zabbix的代码中为了跨平台和开发的简洁采用了大量的宏定义，其中很多对于阅读代码而言又是一种煎熬：）

#### MAIN\_ZABBIX\_ENTRY ####

int MAIN_ZABBIX_ENTRY(int flags)

MAIN\_ZABBIX\_ENTRY定义来功能程序的开始入口，在这个入口之前，由真正的main函数调用，并且在调用之前需要检查参数，并对无需进入程序主功能的参数直接执行并处理。所以定义了MAIN\_ZABBIX\_ENTRY的主程序文件（例如：zabbix\_agent.c），就是实现zabbix代理功能的主入口，命令行参数的检测，help信息的输出，服务的安装，等等都由具体的程序模块实现。  
通过这个宏，就相当于定义了实现业务功能的main，无论是通过服务（Windows），还是通过deamon（\*nix下的守护进程）启动业务功能，都可以直接调用MAIN\_ZABBIX\_ENTRY(0)启动业务功能。

#### ZBX\_THREAD\_ENTRY ####

#if defined(_WINDOWS)
        #define ZBX_THREAD_ENTRY(entry_name, arg_name) \
            unsigned __stdcall entry_name(void *arg_name)
    #else /* not _WINDOWS */
        #define ZBX_THREAD_ENTRY(entry_name, arg_name) \
            unsigned entry_name(void *arg_name)
    #endif

ZBX\_THREAD\_ENTRY定义了功能线程的开始入口，如果需要调用一个开始线程，调用如下：  
zbx\_thread\_start(collector\_thread, thread\_args);  
而collector\_thread的函数声明如下：  
ZBX\_THREAD\_ENTRY(collector\_thread, args)  
这样通过宏，实际就是定义了函数collector\_thread。直接定义函数不好吗，非要通过宏来定义一个函数的名称吗？对于跨平台系统而言，是必须的，如果不通过宏定义，那么对于windows上的stdcall的声明就需要特殊定义了，或者定义一个STDAPI的宏，实现Windows和\*nix系统调用方式不同的生命方式（Windows系统定义为\_\_stdcall，而\*nix系统定义为空宏），相比较而言，zabbix采取的方法更好。

## Zabbix的内存处理相关辅助函数 ##

### 内存分配 ###

zaibbx的内存实现代码在libs/common/misc.c  
内存函数共4个：

#define zbx_calloc(old, nmemb, size) zbx_calloc2(__FILE__, __LINE__, old, nmemb, size)
    #define zbx_malloc(old, size) zbx_malloc2(__FILE__, __LINE__, old, size)
    #define zbx_realloc(src, size) zbx_realloc2(__FILE__, __LINE__, src, size)
    #define zbx_strdup(old, str) zbx_strdup2(__FILE__, __LINE__, old, str)

实际的实现函数后面有数字2（利用宏实现对用户调用文件和行号进行跟踪，具体实现在misc.c中。  
这里，咋们通过看一段代码就知道zabbix设计得有意思的地方：

void    *zbx_malloc2(const char *filename, int line, void *old, size_t size)
    {
        int max_attempts;
        void    *ptr = NULL;
    
        /* old pointer must be NULL */
        if (NULL != old)
        {
            zabbix_log(LOG_LEVEL_CRIT, "[file:%s,line:%d] zbx_malloc: allocating already allocated memory. "
                    "Please report this to Zabbix developers.",
                    filename, line);
        }
    
        for (
            max_attempts = 10, size = MAX(size, 1);
            0 < max_attempts && NULL == ptr;
            ptr = malloc(size), max_attempts--
        );
    
        if (NULL != ptr)
            return ptr;
    
        zabbix_log(LOG_LEVEL_CRIT, "[file:%s,line:%d] zbx_malloc: out of memory. Requested " ZBX_FS_SIZE_T " bytes.",
                filename, line, (zbx_fs_size_t)size);
    
        exit(EXIT_FAILURE);
    }

首先，他需要提供申请空间的指针，用于检测是否重复分配内存。调用函数是通过zbx\_malloc调用实现内存分配，例如下面代码：

static ZBX_METRIC   *commands = NULL;
    //...
    commands = zbx_malloc(commands, sizeof(ZBX_METRIC));

commands是一个内存变量指针。  
并且，在申请内存时尝试调用malloc函数10次，这样是否有实际意义？不得而知！  
如果分配失败，直接退出进程，结束程序运行。

在代码中，还可以看到很多zbx\_realloc的调用，用于动态扩展需要分配的空间。  
例如下面代码添加一个需要采集的指标到运行时采集列表：

int add_metric(ZBX_METRIC *metric, char *error, size_t max_error_len)
    {
        int i = 0;
    
        while (NULL != commands[i].key)
        {
            if (0 == strcmp(commands[i].key, metric->key))
            {
                zbx_snprintf(error, max_error_len, "key \"%s\" already exists", metric->key);
                return FAIL;    /* metric already exists */
            }
            i++;
        }
    
        commands[i].key = zbx_strdup(NULL, metric->key);
        commands[i].flags = metric->flags;
        commands[i].function = metric->function;
        commands[i].test_param = (NULL == metric->test_param ? NULL : zbx_strdup(NULL, metric->test_param));
    
        commands = zbx_realloc(commands, (i + 2) * sizeof(ZBX_METRIC));
        memset(&commands[i + 1], 0, sizeof(ZBX_METRIC));
    
        return SUCCEED;
    }

这里用到了zbx\_realloc来实现内存扩展，也就是，内存不是一次性分配好的，而是不断申请和分配的。内存分配开始是总是保留一个空位，数据开始填充在空位，然后重新分配一个空间（使用realloc实现内存复制），并设置最后一个空位为0值。  
这种分配内存的模式在zabbix源码中很常见，熟悉后，阅读起来就会省不少时间。  
这里再说一下zbx\_free的实现

#define zbx_free(ptr)       \                 \ do              \ {                \     if (ptr)        \     {            \         free(ptr);  \         ptr = NULL; \     }           \ }               \ while (0)

zbx\_free就是通过C语言的free实现的，这里为什么需要采用一个do-while的写法呢？  
这是在C中实现多行宏定义的一个通用方法，防止语句在宏扩张是产生语义错误，例如如果宏用在如下代码时：

#define zbx_free(p) \
        free(p);  \
        p = NULL;
    
    int status = do_somthing();
    if (status == 0) zbx_free(ptr);
    else{
        //using p pointer to do somthing...
    }

如果zbx\_free没有采用do-while的写法，那么就会出现错误的宏扩展：

if (status == 0) free(p);
    ptr = NULL;
    else{
        // using p pointer to do somthing...
    }

以上代码就会产生编译错误，最不好的情况是，直接出现运行时错误。原因就是宏使用时没有采用\{\}来包裹导致的问题，而采用do-while(0)时，该问题就可以避免。

### 字符串的处理 ###

zabbix处理字符串也是采用封装的方式进行，主要包括如下几个函数：

#define zbx_strdup(old, str)        zbx_strdup2(__FILE__, __LINE__, old, str)
    
    #define ZBX_STRDUP(var, str)    (var = zbx_strdup(var, str))

一般采用zbx\_strdup函数实现字符串的复制。  
例如前面的指标名称复制就是调用该函数实现复制的：

commands[i].key = zbx_strdup(NULL, metric->key);

zbx\_strdup的实现任采用C库的strdup实现，不过处理的原指针的释放。

char    *zbx_strdup2(const char *filename, int line, char *old, const char *str)
    {
        int retry;
        char    *ptr = NULL;
    
        zbx_free(old);
    
        for (retry = 10; 0 < retry && NULL == ptr; ptr = strdup(str), retry--)
            ;
    
        if (NULL != ptr)
            return ptr;
    
        zabbix_log(LOG_LEVEL_CRIT, "[file:%s,line:%d] zbx_strdup: out of memory. Requested " ZBX_FS_SIZE_T " bytes.",
                filename, line, (zbx_fs_size_t)(strlen(str) + 1));
    
        exit(EXIT_FAILURE);
    }

并且，仍然采用多次尝试的方法复制字符串。

## 动态字符数组(dynamic string array) ##

首先声明，这个地方有点复杂(^\_^)

函数的声明是这样：

void    zbx_strarr_init(char ***arr)
    {
        *arr = zbx_malloc(*arr, sizeof(char *));
        **arr = NULL;
    }

三个星号，你看看，太过复杂吧！一般人不用他！谁叫他是zabbix呢？  
代码创建一个二维指针空间：

p -> [x1, x2, x3, ...]
          |   |   |     |
          v   v   v     v
        char*    char*  null

这里参数为三个**\*，是为了把两个**的变量通过指针传递给zbx\_strarr\_init，以便初始化。

为更好的理解二维数组，我编写了以下简要的代码：

#include <stdlib.h>
    #include <stdio.h>
    
    void test_p(int **p)
    {
        // 外部实际是一个指针（一维）
        // 通过**传递，是希望由该函数实现内存分配，并输出到外部的指针变量
        // 这里为了方便，使用了临时变量a，如果直接使用p实现赋值，
        // 就需要通过数组方式访问咯，例如*p[0], *p[1] *p[2]
        int *a = *p = malloc(sizeof(int)*3);
        *a++=1;
        *a++=2;
        *a++=3;
    }
    
    void test_pp(int ***p)
    {
        // 二维指针的变量
        // 首先分配一维的指针变量
        // 然后对一维指针变量初始化数据内存
        int **a = *p = malloc(sizeof(int*) * 3);
        *a++ = malloc(sizeof(int) * 3);
        *a++ = malloc(sizeof(int) * 3);
        *a++ = malloc(sizeof(int) * 3);
        int **b = *p;
        printf("0x%lx\r\n", *b++);
        printf("0x%lx\r\n", *b++);
        printf("0x%lx\r\n", *b++);
        int **c = *p;
        int *c1 = *c++;
        int *c2 = *c++;
        int *c3 = *c++;
        *c1++ = 1; *c1++ = 2; *c1++ = 3;
        *c2++ = 4; *c2++ = 5; *c2++ = 6;
        *c3++ = 7; *c3++ = 8; *c3++ = 9;
    }
    
    void test_x(int *p){
            *p++=1;
            *p++=2;
            *p++=3;
    }
    
    int main(){
            printf("(1)*\r\n");
            int a[3] = {0};
            test_x(a);
            printf("%d %d %d\r\n", a[0], a[1], a[2]);
    
            printf("(2)**\r\n");
            int *b = 0;
            test_p(&b);
            printf("%d %d %d\r\n", b[0], b[1], b[2]);
            free(b);
    
            printf("(3) ***\r\n");
            int **c = 0;
            test_pp(&c);
            int *p;
            for (int i = 0; i < 3; i++){
                    p = c[i];
                    printf("addr is %lx\r\n", p);
                    for (int j = 0; j < 3; j++){
                            printf("%d ", p[j]);
                    }
                    printf("\r\n");
                    free(p);
            }
            free(c);
            return 0;
    }

上面程序执行的结果是：

(1)*
    1 2 3
    (2)**
    1 2 3
    (3) ***
    0x7fda91c025d0
    0x7fda91c02600
    0x7fda91c02610
    addr is 7fda91c025d0
    1 2 3
    addr is 7fda91c02600
    4 5 6
    addr is 7fda91c02610
    7 8 9

现在看zabbix的二维数组的初始化代码，实际上，只是分配咯一个元素的一位数组指针，并设置为空。

下面来看添加字符串实现：

void    zbx_strarr_add(char ***arr, const char *entry)
    {
        int i;
    
        assert(entry);
    
        for (i = 0; NULL != (*arr)[i]; i++)
            ;
    
        *arr = zbx_realloc(*arr, sizeof(char *) * (i + 2));
    
        (*arr)[i] = zbx_strdup((*arr)[i], entry);
        (*arr)[++i] = NULL;
    }

其实和前面的示例一样，不过这里通过zbx\_realloc实现内存扩张。首先，寻找最后一个为null元素，i 表示元素个数-1，所以为了扩张一个元素，需要i+2个指针变量的区域。  
然后，复制字符串到倒数一个指针位置，同时设置最后一个位置为null。