第三章 sysrepo-plugind源码分析

摘自：https://blog.csdn.net/m0_47413019/article/details/105867406

应用程序通过将对Sysrepo的调用通过Sysrepo提供的相应的API接口访问方法，称为Syrepo的间接访问方法。该方法是应用程序通过创建Deamon进程，通过IPC Shm机制与Sysrepo通信。可以做到对Sysrepo的即插即用，最后由Sysrepo纳管，这就是Plugind，命名为sysrepo-plugind。要快速的使用Sysrepo，并快速开发出适配于Sysrepo的插件，就要先了解sysrepo-plugind的实现原理与机制，就需要先从实现sysrepo-plugind的源码处着手。Sysrepo源码路径：git clone https://github.com/sysrepo/sysrepo.git Sysrepo-plugind实现的路径为sysrepo/src/executables/sysrepo-plugind.c。下面也就从该文件开始说。

2.1 数据结构

 1 struct srpd_plugin_s {
 2     void *handle;
 3     srp_init_cb_t init_cb;
 4     srp_cleanup_cb_t cleanup_cb;
 5     void *private_data;
 6 };
 7 /*结构参数说明*/
 8 handle:动态库句柄,在load_plugin中细说
 9  
10 srp_init_cb_t:
11 /*Sysrepo plugin initialization callback.*/
12 typedef int (*srp_init_cb_t)(sr_session_ctx_t *session, void **private_data);
13  
14 srp_cleanup_cb_t :
15 /*brief Sysrepo plugin cleanup callback.*/
16 typedef void (*srp_cleanup_cb_t)(sr_session_ctx_t *session, void *private_data);
17  
18 private_data:  Private context opaque to sysrepo

2.2 main函数实现

  1 int
  2 main(int argc, char** argv)
  3 {
  4     struct srpd_plugin_s *plugins = NULL;       /*plugin结构*/
  5     sr_conn_ctx_t *conn = NULL;                 /*sysrepo连接的上下文，该结构定义于common.h.in*/
  6     sr_session_ctx_t *sess = NULL;              /*sysrepo会话的上下文，该结构定义于common.h.in中*/
  7     sr_log_level_t log_level = SR_LL_ERR;       /*输出log等级，默认是ERR*/
  8     int plugin_count = 0, i, r, rc = EXIT_FAILURE, opt, debug = 0;
  9     struct option options[] = {
 10         {"help",      no_argument,       NULL, 'h'},
 11         {"version",   no_argument,       NULL, 'V'},
 12         {"verbosity", required_argument, NULL, 'v'},
 13         {"debug",     no_argument,       NULL, 'd'},
 14         {NULL,        0,                 NULL, 0},
 15     };                                          /*命令行支持的参数*/
 16  
 17     /* process options */
 18     opterr = 0;
 19  
 20     /*整个while循环是解析命令的参数，例如，在调试时，输入“sysrepo-plugind -d -v 4” 是debug模式        
 21      *下log级别DBG级，将会打印全部的调试信息
 22      */
 23     while ((opt = getopt_long(argc, argv, "hVv:d", options, NULL)) != -1) {
 24         switch (opt) {
 25         case 'h':
 26             version_print();
 27             help_print();
 28             rc = EXIT_SUCCESS;
 29             goto cleanup;
 30         case 'V':
 31             version_print();
 32             rc = EXIT_SUCCESS;
 33             goto cleanup;
 34         case 'v':
 35             if (!strcmp(optarg, "none")) {
 36                 log_level = SR_LL_NONE;
 37             } else if (!strcmp(optarg, "error")) {
 38                 log_level = SR_LL_ERR;
 39             } else if (!strcmp(optarg, "warning")) {
 40                 log_level = SR_LL_WRN;
 41             } else if (!strcmp(optarg, "info")) {
 42                 log_level = SR_LL_INF;
 43             } else if (!strcmp(optarg, "debug")) {
 44                 log_level = SR_LL_DBG;
 45             } else if ((strlen(optarg) == 1) && (optarg[0] >= '0') && (optarg[0] <= '4')) {
 46                 log_level = atoi(optarg);
 47             } else {
 48                 error_print(0, "Invalid verbosity "%s"", optarg);
 49                 goto cleanup;
 50             }
 51             break;
 52         case 'd':
 53             debug = 1;
 54             break;
 55         default:
 56             error_print(0, "Invalid option or missing argument: -%c", optopt);
 57             goto cleanup;
 58         }
 59     }
 60  
 61     /* check for additional argument */
 62     if (optind < argc) {
 63         error_print(0, "Redundant parameters");
 64         goto cleanup;
 65     }
 66  
 67     /* load plugins：将所有的pluginl加载，这是整个main第一处核心点，这关系用户开发的plugin能否正确加载*/
 68     if (load_plugins(&plugins, &plugin_count)) {
 69         goto cleanup;
 70     }
 71  
 72     /* daemonize, sysrepo-plugind no longer directly logs to stderr */
 73     daemon_init(debug, log_level);
 74  
 75     /* create connection (after we have forked so that our PID is correct) */
 76     /*调用sysrepo API(sr_connect)创建与sysrepo的连接，并将返回创建连接的上下发*/
 77     if ((r = sr_connect(0, &conn)) != SR_ERR_OK) {
 78         error_print(r, "Failed to connect");
 79         goto cleanup;
 80     }
 81  
 82     /* create session */
 83     /*调用sysrepo API(sr_session_start)创建与sysrepo running库的会话，并启动该会话*/
 84     if ((r = sr_session_start(conn, SR_DS_RUNNING, &sess)) != SR_ERR_OK) {
 85         error_print(r, "Failed to start new session");
 86         goto cleanup;
 87     }
 88     /*sr_connect(), sr_session_start(),是连接sysrepo基础，这两点基础实现，在后面sysrepo源码 
 89      *分析做详细说明，不在sysrepo-plugin中说明
 90      */
 91  
 92     /* init plugins */
 93     /*对所有已加载的plugin通过调用init_cb注册的回调初始化，这是整个main第二处核心点，与用户是强 
 94      *相关用户开发的插件，注册，订阅，初始化都通过init_cb，否则不能将sysrepol通信连接*/
 95     for (i = 0; i < plugin_count; ++i) {
 96         r = plugins[i].init_cb(sess, &plugins[i].private_data);
 97         if (r != SR_ERR_OK) {
 98             SRP_LOG_ERR("Plugin initialization failed (%s).", sr_strerror(r));
 99             goto cleanup;
100         }
101     }
102  
103     /* wait for a terminating signal */
104     pthread_mutex_lock(&lock);
105     while (!loop_finish) {
106         pthread_cond_wait(&cond, &lock);
107     }
108     pthread_mutex_unlock(&lock);
109  
110     /* cleanup plugins */
111     /* sysrepo-plugindf正常结束后，回收plugin初始化时分配的资源*/
112     for (i = 0; i < plugin_count; ++i) {
113         plugins[i].cleanup_cb(sess, plugins[i].private_data);
114     }
115  
116     /* success */
117     rc = EXIT_SUCCESS;
118  
119     /*结束后，回收已分配的全部资源*/
120 cleanup:
121     for (i = 0; i < plugin_count; ++i) {
122         dlclose(plugins[i].handle);
123     }
124     free(plugins);
125  
126     sr_disconnect(conn);
127     return rc;
128 }

2.3 load_plugins

  1 static int
  2 load_plugins(struct srpd_plugin_s **plugins, int *plugin_count)
  3 {
  4     void *mem, *handle;
  5     DIR *dir;
  6     struct dirent *ent;
  7     const char *plugins_dir;
  8     char *path;
  9     int rc = 0;
 10  
 11     *plugins = NULL;
 12     *plugin_count = 0;
 13  
 14     /* get plugins dir from environment variable, or use default one */
 15     /* bin_common.h.in #define SRPD_PLUGINS_PATH "@PLUGINS_PATH@"
 16      * @PLUGINS_PATH@在CMakeList.txt中定义，在编译时也可以自定义
 17      * CMakeList.txt对其定义如下
 18      * if(NOT PLUGINS_PATH)
 19      * set(PLUGINS_PATH             
 20      *    "${CMAKE_INSTALL_PREFIX}/${CMAKE_INSTALL_LIBDIR}/sysrepo/plugins/" CACHE PATH
 21      *   "Sysrepo plugin daemon plugins path.")
 22      *   endif()
 23      *  用户不指定plugin的路径时，debian系统默认将plugin的动态库文件*.so安装 
 24      *    于/usr/lib/x86_64-linux-gnu/sysrepo/plugins/目录下，
 25      *  而Centos系统的默认安装路径为/usr/lib/sysrepo/plugins，在开发plugind时，安装路径也需要 
 26      *  指定到该路径下，否则，*.so找不到，则load不成功。
 27      */
 28     plugins_dir = getenv("SRPD_PLUGINS_PATH");
 29     if (!plugins_dir) {
 30         plugins_dir = SRPD_PLUGINS_PATH;
 31     }
 32  
 33     /* create the directory if it does not exist */
 34     /* access函数，:检查调用进程是否可以对指定的文件执行某种操作， F_OK文件是否存在
 35      * 本段代码是检测SRPD_PLUGINS_PATH目录是否存在，如果不存在，调用sr_mkpath创建目录，并设置*            
 36      * 目录的访问权限000777。本段代码是安全性代码，确保指定的路径存在。对于实际开发中，是通过编 
 37      * 译是指定，不存在路径的动态库无法安装。
 38      */
 39     if (access(plugins_dir, F_OK) == -1) {
 40         if (errno != ENOENT) {
 41             error_print(0, "Checking plugins dir existence failed (%s).", strerror(errno));
 42             return -1;
 43         }
 44         if (sr_mkpath(plugins_dir, 00777) == -1) {
 45             error_print(0, "Creating plugins dir "%s" failed (%s).", plugins_dir, strerror(errno));
 46             return -1;
 47         }
 48     }
 49     
 50     /* opendir函数，找开指定的目录文件，并返回DIR*形态的目录流，
 51      * 目录的读取与搜查也都需要此目录流 
 52      */
 53     dir = opendir(plugins_dir);
 54     if (!dir) {
 55         error_print(0, "Opening "%s" directory failed (%s).", plugins_dir, strerror(errno));
 56         return -1;
 57     }
 58     
 59     /*readdir函数，读取目录，返回参数dir目录流的下个目录进入点
 60      * 返回的结果是struct dirent的内容*/
 61     while ((ent = readdir(dir))) {
 62         /*Linux系统中存在"." ".."两类目录，这两类目录名结构，在实际是不需要使用，需要跳过。*/
 63         if (!strcmp(ent->d_name, ".") || !strcmp(ent->d_name, "..")) {
 64             continue;
 65         }
 66         
 67         /* open the plugin */
 68         /*将SRPD_PLUGINS_PATH与也读取的目录文件名，组成一个完成的动态库路径，供后面操作。*/
 69         if (asprintf(&path, "%s/%s", plugins_dir, ent->d_name) == -1) {
 70             error_print(0, "asprintf() failed (%s).", strerror(errno));
 71             rc = -1;
 72             break;
 73         }
 74         
 75         /*RTLD_LAZY:暂缓决定，等有需要时再解出符号 
 76          *以RTLD_LAZY模式打开动态库，返回一个句柄给调用进程，如果失败，则返回。
 77          */
 78         handle = dlopen(path, RTLD_LAZY);
 79         if (!handle) {
 80             error_print(0, "Opening plugin "%s" failed (%s).", path, dlerror());
 81             free(path);
 82             rc = -1;
 83             break;
 84         }
 85         free(path);
 86         
 87         /* allocate new plugin */
 88         /* 分配一个新的plugin空间，并将新分配的men挂载plugins结构下*/
 89         mem = realloc(*plugins, (*plugin_count + 1) * sizeof **plugins);
 90         if (!mem) {
 91             error_print(0, "realloc() failed (%s).", strerror(errno));
 92             dlclose(handle);
 93             rc = -1;
 94             break;
 95         }
 96         *plugins = mem;
 97  
 98         /* find required functions */
 99         /* plugins结构中有两个必须的回调函数，一个是init_cb,另一个是cleanup_cb
100          * 通过 void *dlsym(void *handle, const char* symbol);，
101          * handle是使用dlopen函数之后返回的句柄，
102          * symbol是要求获取的函数的名称。
103          * SRP_INIT_CB定义如下：#define SRP_INIT_CB     "sr_plugin_init_cb"
104          * SRP_CLEANUP_CB定义下：#define SRP_CLEANUP_CB  "sr_plugin_cleanup_cb"
105          * 此两个CB函数，也就是在开发插件中必须实现的两个入口函数，如果不存在，则加载失败。
106          */
107         *(void **)&(*plugins)[*plugin_count].init_cb = dlsym(handle, SRP_INIT_CB);
108         if (!(*plugins)[*plugin_count].init_cb) {
109             error_print(0, "Failed to find function "%s" in plugin "%s".", SRP_INIT_CB, ent->d_name);
110             dlclose(handle);
111             rc = -1;
112             break;
113         }
114  
115         *(void **)&(*plugins)[*plugin_count].cleanup_cb = dlsym(handle, SRP_CLEANUP_CB);
116         if (!(*plugins)[*plugin_count].cleanup_cb) {
117             error_print(0, "Failed to find function "%s" in plugin "%s".", SRP_CLEANUP_CB, ent->d_name);
118             dlclose(handle);
119             rc = -1;
120             break;
121         }
122         
123         /* finally store the plugin */
124         /*最后，本次so解析成功，保存本次so的解析结果，执行一下次目录文件的读取*/
125         (*plugins)[*plugin_count].handle = handle;
126         (*plugins)[*plugin_count].private_data = NULL;
127         ++(*plugin_count);
128     }
129     /*目录文件读取结束，关闭目录读取流，返回的参考中有插件结构plugins。*/
130     closedir(dir);
131     return rc;
132 }

2.4 init_cb 

srpd_plugin_s结构中定义了init的回调函数
如下：
typedef int (*srp_init_cb_t)(sr_session_ctx_t *session, void **private_data);
在load plugin时，
#define SRP_INIT_CB "sr_plugin_init_cb"
init_cb = dlsym(handle, SRP_INIT_CB);
在sysrepo-plugind的main实现时，需要对plugin的初始化，实际就是需要用户对sr_plugin_init_cb()实现，是完成该plugin的资源分配，用户感兴趣的事情做订阅，Ｍodule change RPC/Action,Notify, get——items等操作，均在此处完成。有如下例子，请参考。

 1 int
 2 sr_plugin_init_cb(sr_session_ctx_t *session, void **private_ctx)
 3 {
 4     int rc;
 5     struct plugind_ctx *ctx;
 6     ctx = calloc(1, sizeof *ctx);
 7     if (!ctx) 
 8     {
 9         rc = SR_ERR_NOMEM;
10         goto error;
11     }
12  
13     /*在下面初始与之有关的操作，例如，本地数据结构的初始化，sysrepo的订阅初始化*/
14     ...
15   
16     SRP_LOG_DBGMSG("plugin initialized successfully.");
17     ctx->session = session;
18     *private_ctx = ctx;
19     return SR_ERR_OK;
20  
21 error:
22     SRP_LOG_ERR("plugin initialization failed (%s).", sr_strerror(rc));
23     sr_unsubscribe(ctx->subscription);
24     free(ctx);
25     return rc;
26 }

2.5 cleanup_cb

srpd_plugin_s结构中定义了cleanup的回调函数
如下：
typedef void (*srp_cleanup_cb_t)(sr_session_ctx_t *session, void *private_data);
在load plugin时，
#define SRP_CLEANUP_CB "sr_plugin_cleanup_cb"
cleanup_cb = dlsym(handle, SRP_CLEANUP_CB);
所以，对于用户来就，是需要对sr_plugin_cleanup_cb()实现，回收plugin在初始化时分配的资源。例如下面的cleanup实现，可以参考

 1 void
 2 sr_plugin_cleanup_cb(sr_session_ctx_t *session, void *private_ctx)
 3 {
 4     (void)session;
 5  
 6     struct plugind_ctx *ctx = (struct plugind_ctx *)private_ctx;
 7     sr_unsubscribe(ctx->subscription);
 8     free(ctx);
 9     
10     nb_terminate();
11     yang_terminate();
12     
13     SRP_LOG_DBGMSG("plugin cleanup finished.");
14 }

整个sysrepo-plugind.c代码结构简单，注释丰富，没有使用复杂的语法，还是非常容易理解的。

【推广】 免费学中医，健康全家人
原文地址：https://www.cnblogs.com/LiuYanYGZ/p/14271691.html