skynet中动态库的处理

　　skynet中的.so动态库由service-src中的c文件编译完后生成，其中最重要的是snlua.c.

　　源码地址：https://github.com/cloudwu/skynet/service-src

　　这里不介绍如何生成动态库，而是介绍当编译成动态库后，skynet是如何利用里边的函数的.

　　源码：

　　#include "skynet.h"

　　#include <lua.h>
　　#include <lualib.h>
　　#include <lauxlib.h>

　　#include <assert.h>
　　#include <string.h>
　　#include <stdlib.h>
　　#include <stdio.h>

　　struct snlua {
　　　　lua_State * L;
　　　　struct skynet_context * ctx;
　　};

　　// LUA_CACHELIB may defined in patched lua for shared proto
　　#ifdef LUA_CACHELIB

　　#define codecache luaopen_cache

　　#else

　　static int
　　　　cleardummy(lua_State *L) {
　　　　return 0;
　　}

　　static int
　　codecache(lua_State *L) { //该函数由_init中luaL_requiref(L, /modname/ "skynet.codecache", /openf/ codecache , 0)
　　luaL_Reg l[] = {
　　　　{ "clear", cleardummy },
　　　　{ "mode", cleardummy },
　　　　{ NULL, NULL },
　　};
　　luaL_newlib(L,l); //向lua中注册“clear”和“mode”函数
　　lua_getglobal(L, "loadfile");//把全局变量 name 里的值压栈，返回该值的类型，目前尚不知道loadfile是在哪里注册到lua中的？
　　lua_setfield(L, -2, "loadfile");//做一个等价于 t[k] = v 的操作， 这里 t 是给出的索引处的值， 而 v 是栈顶的那个值。
　　return 1;
　　}　　

　　#endif

　　static int
　　traceback (lua_State *L) {
　　　　const char *msg = lua_tostring(L, 1);
　　　　if (msg)
　　　　luaL_traceback(L, L, msg, 1);
　　　　else {
　　　　lua_pushliteral(L, "(no error message)");
　　　　}
　　　　return 1;
　　}

　　static void
　　_report_launcher_error(struct skynet_context *ctx) {
　　　　// sizeof "ERROR" == 5
　　　　skynet_sendname(ctx, 0, ".launcher", PTYPE_TEXT, 0, "ERROR", 5);
　　}

　　static const char *
　　optstring(struct skynet_context *ctx, const char *key, const char * str) {
　　　　const char * ret = skynet_command(ctx, "GETENV", key);
　　　　if (ret == NULL) {
　　　　return str;
　　}
　　return ret;
　　}

　　static int
　　_init(struct snlua *l, struct skynet_context *ctx, const char * args, size_t sz) {
　　　　lua_State *L = l->L;
　　　　l->ctx = ctx;
　　　　lua_gc(L, LUA_GCSTOP, 0); //LUA_GCSTOP: 停止垃圾收集器
　　　　lua_pushboolean(L, 1); /* signal for libraries to ignore env. vars. */ //放个nil值到栈上
　　　　lua_setfield(L, LUA_REGISTRYINDEX, "LUA_NOENV"); //LUA_REGISTRYINDEX？，"LUA_NOENV"？
　　　　luaL_openlibs(L);
　　　　lua_pushlightuserdata(L, ctx); //lua中的lightuserdata存放的是c语言中的变量，这里为结构体指针
 　　 　 lua_setfield(L, LUA_REGISTRYINDEX, "skynet_context");
 　　　  luaL_requiref(L, /modname/ "skynet.codecache", /openf/ codecache , 0);
　　　　//如果 modname 不在 package.loaded 中， 则调用函数 openf ，并传入字符串 modname。 将其返回值置入 package.loaded[modname]。 这个行            为好似该函数通过 require 调用过一样。

　　　　//如果glb 为真， 同时也讲模块设到全局变量 modname 里。

　　　　//在栈上留下该模块的副本。
　　　　lua_pop(L,1);

　　　　const char *path = optstring(ctx, "lua_path","./lualib/?.lua;./lualib/?/init.lua");
　　　　lua_pushstring(L, path);
　　　　lua_setglobal(L, "LUA_PATH");
　　　　const char *cpath = optstring(ctx, "lua_cpath","./luaclib/?.so");
　　　　lua_pushstring(L, cpath);
　　　　lua_setglobal(L, "LUA_CPATH");
　　　　const char *service = optstring(ctx, "luaservice", "./service/?.lua");
　　　　lua_pushstring(L, service);
　　　　lua_setglobal(L, "LUA_SERVICE");
　　　　const char *preload = skynet_command(ctx, "GETENV", "preload");
　　　　lua_pushstring(L, preload);
　　　　lua_setglobal(L, "LUA_PRELOAD"); //

　　　　lua_pushcfunction(L, traceback); //以上将各种path注册到lua的全局变量中，变量名字即为 "LUA_xxxx"
　　　　assert(lua_gettop(L) == 1);

　　　　const char * loader = optstring(ctx, "lualoader", "./lualib/loader.lua");

　　　　int r = luaL_loadfile(L,loader); //加载loader.lua
　　　　if (r != LUA_OK) {
　　　　skynet_error(ctx, "Can't load %s : %s", loader, lua_tostring(L, -1));
　　　　_report_launcher_error(ctx);
　　　　return 1;
　　}
　　lua_pushlstring(L, args, sz); //将bootstart传入
　　r = lua_pcall(L,1,0,1); //load bootstart 服务
　　if (r != LUA_OK) {
　　　　skynet_error(ctx, "lua loader error : %s", lua_tostring(L, -1));
　　　　_report_launcher_error(ctx);
　　　　return 1;
　　}
　　lua_settop(L,0);

　　lua_gc(L, LUA_GCRESTART, 0);

　　return 0;
　　}

　　static int
　　_launch(struct skynet_context * context, void *ud, int type, int session, uint32_t source , const void * msg, size_t sz) { //ud就是服务中的结构体
　　　　assert(type == 0 && session == 0); //确保_launch服务在一个进程中只调用一次
　　　　struct snlua *l = ud;
　　　　skynet_callback(context, NULL, NULL);
　　　　int err = _init(l, context, msg, sz);
　　　　if (err) {
　　　　　　skynet_command(context, "EXIT", NULL);
　　　　}

　　　　return 0;
　　}

　　int
　　snlua_init(struct snlua *l, struct skynet_context *ctx, const char * args) { //BOOTSTART
　　　　int sz = strlen(args);
　　　　char * tmp = skynet_malloc(sz);
　　　　memcpy(tmp, args, sz);
　　　　skynet_callback(ctx, l , _launch); //注册回掉函数为_launch,当工作线程轮询到的时候调用的回掉函数即为"_launch"
　　　　const char * self = skynet_command(ctx, "REG", NULL); //服务有handle和名字，这里为服务注册名字，若名字为NULL，则返回handle的字符串 　　　　“:handle”
　　　　uint32_t handle_id = strtoul(self+1, NULL, 16);
　　　　// it must be first message
　　　　skynet_send(ctx, 0, handle_id, PTYPE_TAG_DONTCOPY,0, tmp, sz); //给他自己发送一个信息，目的地为刚注册的地址，最终将该消息push到对应的mq上
　　　　return 0;
　　}

　　struct snlua *
　　snlua_create(void) {
　　　　struct snlua * l = skynet_malloc(sizeof(*l));
　　　　memset(l,0,sizeof(*l));
　　　　l->L = lua_newstate(skynet_lalloc, NULL);
　　　　return l;
　　}

　　void
　　snlua_release(struct snlua *l) {
　　　　lua_close(l->L);
　　　　skynet_free(l);
　　}

　　void
　　snlua_signal(struct snlua *l, int signal) {
　　　　skynet_error(l->ctx, "recv a signal %d", signal);
　　　　#ifdef lua_checksig
　　　　// If our lua support signal (modified lua version by skynet), trigger it.
　　　　skynet_sig_L = l->L;
　　　　#endif
　　}

　　以上为service_snlua.c中的内容，初看起来一头雾水，我们来看一下整个过程。

　　skynet.main.c中的main函数最后调用skynet_start.c中的skynet_start函数，其中启动snlua服务代码部分如下：

　　bootstrap(ctx, config->bootstrap); //创建snlua服务模块，及ctx

　　这句话是启动snlua模块，具体bootstrap代码：

　　static void
　　bootstrap(struct skynet_context * logger, const char * cmdline) {
　　　　int sz = strlen(cmdline);
　　　　char name[sz+1];
　　　　char args[sz+1];
　　　　sscanf(cmdline, "%s %s", name, args);   //最终name = "snlua" , args = "bootstrap" 
　　　　struct skynet_context *ctx = skynet_context_new(name, args);  //启动snlua ， bootstarp为参数
　　　　if (ctx == NULL) {
　　　　skynet_error(NULL, "Bootstrap error : %s\n", cmdline);
　　　　skynet_context_dispatchall(logger);
　　　　exit(1);
　　　　}
　　}

　　函数参数 : logger,忽略

　　　　　　　cmdline : " snlua bootstrap”

　　让我们看一下skynet_contex_new( "snlua"  , "bootstrap" )都做了些什么,该函数在skynet_server.c中

　　

　　struct skynet_module {
　　　　const char * name;
　　　　void * module; 动态链接库的指针.so
　　　　skynet_dl_create create; 
　　　　skynet_dl_init init;
　　　　skynet_dl_release release;
　　　　skynet_dl_signal signal; //skynet.module.c
　　}; //结构体中的create init release signal 分别对应着service_snlua.c中的create init release signal的函数地址，skynet_dl_XX是宏定义

　　struct skynet_context *

　　skynet_context_new(const char * name, const char *param) { //name为服务名，param为需要的参数

　　　　struct skynet_module * mod = skynet_module_query(name); //根据name即"snlua"来得到对应名字的mod地址，有就直接查到，没有先打开动态库，获取里边的函数地址，并注册该服务，并返回
　　　　//module里实际上是改动态库中的内容
　　　　if (mod == NULL) //正常情况下mod不会为NULL
　　　　return NULL;

　　　　void *inst = skynet_module_instance_create(mod); //调用mod中的create函数，实际上就是service_snlua.c中的create，即调用dlopen来获得动态库
　　　　if (inst == NULL)
　　　　return NULL;
　　　　struct skynet_context * ctx = skynet_malloc(sizeof(*ctx)); //为每个服务创建一个ctx
　　　　CHECKCALLING_INIT(ctx)

　　　　ctx->mod = mod; //里边有动态库指针和动态库中的函数指针及该库的名字，根据名字已经注册到了skynet
　　　　ctx->instance = inst; //每个服务都有一个结构体，如logger的指针
　　　　ctx->ref = 2; //why
　　　　ctx->cb = NULL;
　　　　ctx->cb_ud = NULL;
　　　　ctx->session_id = 0;
　　　　ctx->logfile = NULL;

　　　　ctx->init = false;
　　　　ctx->endless = false;
　　　　// Should set to 0 first to avoid skynet_handle_retireall get an uninitialized handle
　　　　ctx->handle = 0;
　　　　ctx->handle = skynet_handle_register(ctx); //将该ctx注册到handle中
　　　　struct message_queue * queue = ctx->queue = skynet_mq_create(ctx->handle);
　　　　// init function maybe use ctx->handle, so it must init at last
　　　　context_inc();

　　　　CHECKCALLING_BEGIN(ctx)
　　　　int r = skynet_module_instance_init(mod, inst, ctx, param); //执行mod中的init函数，若为0执行成功
　　　　CHECKCALLING_END(ctx)
　　　　if (r == 0) {
　　　　　　struct skynet_context * ret = skynet_context_release(ctx); //减少ctx的引用计数，若为0，删除ctx资源
　　　　　　if (ret) {
　　　　　　　　ctx->init = true;
　　　　　　}
　　　　skynet_globalmq_push(queue); //将创建的服务对应的队列push到全局队列
　　　　if (ret) {
　　　　　　skynet_error(ret, "LAUNCH %s %s", name, param ? param : "");
　　　　}
　　　　return ret;
　　　　} else {
　　　　　　skynet_error(ctx, "FAILED launch %s", name);
　　　　　　uint32_t handle = ctx->handle;　　
　　　　　　skynet_context_release(ctx);
　　　　　　skynet_handle_retire(handle);
　　　　　　struct drop_t d = { handle };
　　　　　　skynet_mq_release(queue, drop_message, &d);
　　　　　　return NULL;
　　　　}
　　}

　　接下来我们看一下skynet_module.c中的关于动态库看起

　　应该从skynet_module_query(const char * name)看起 ， 此处name为“snlua”

　　

　　struct skynet_module * 
　　skynet_module_query(const char * name) {
　　　　struct skynet_module * result = _query(name);//首先查找snlua module是否存在
　　　　if (result)
　　　　　　return result; //存在则返回

　　　　SPIN_LOCK(M)

　　　　result = _query(name); // double check

　　　　if (result == NULL && M->count < MAX_MODULE_TYPE) { //不存在，接下来就是重点
　　　　　　int index = M->count; //M中记录共有多少个c module创建了，->count 为下一个module的索引
　　　　　　void * dl = _try_open(M,name); //调用dlopen来打开动态库，返回动态库指针
　　　　　　if (dl) {
　　　　　　　　M->m[index].name = name;
　　　　　　　　M->m[index].module = dl;

　　　　　　　　if (_open_sym(&M->m[index]) == 0) { //调用_open_sym来获取动态库中的函数地址，具体看下面实现
　　　　　　　　　　M->m[index].name = skynet_strdup(name);
　　　　　　　　　　M->count ++;
　　　　　　　　　　result = &M->m[index];
　　　　　　　　}
　　　　　　}
　　　　}

　　　　SPIN_UNLOCK(M)

　　　　return result;
　　}

　　struct modules {
　　　　int count;
　　　　struct spinlock lock;
　　　　const char * path;
　　　　struct skynet_module m[MAX_MODULE_TYPE];
　　};

　　static struct modules * M = NULL;

　　static void *
　　_try_open(struct modules *m, const char * name) { M ， “snlua”
　　　　const char *l;
　　　　const char * path = m->path; //path就是初始化M时传入的动态库所在的路径
　　　　size_t path_size = strlen(path);
　　　　size_t name_size = strlen(name); //“snlua”

　　　　int sz = path_size + name_size;
　　　　//search path
　　　　void * dl = NULL;
　　　　char tmp[sz];
　　　　do
　　　　{
　　　　　　memset(tmp,0,sz);
　　　　　　while (*path == ';') path++;
　　　　　　if (*path == '\0') break;
　　　　　　l = strchr(path, ';');
　　　　　　if (l == NULL) l = path + strlen(path);
　　　　　　int len = l - path;
　　　　　　int i;
　　　　　　for (i=0;path[i]!='?' && i < len ;i++) {
　　　　　　tmp[i] = path[i];
　　　　}
　　　　memcpy(tmp+i,name,name_size);
　　　　if (path[i] == '?') {
　　　　　　strncpy(tmp+i+name_size,path+i+1,len - i - 1);
　　　　} else {
　　　　　　fprintf(stderr,"Invalid C service path\n");
　　　　　　exit(1);
　　　　} //以上循环为拼凑出完成的动态库路径，用真是动态库名字替代 “?”
　　　　dl = dlopen(tmp, RTLD_NOW | RTLD_GLOBAL); //打开动态库，返回动态库指针
　　　　path = l;
　　　　}while(dl == NULL);

　　　　if (dl == NULL) {
　　　　fprintf(stderr, "try open %s failed : %s\n",name,dlerror());
　　}

　　return dl;
　　}

　　static struct skynet_module *
　　_query(const char * name) {
　　　　int i;
　　　　for (i=0;i<M->count;i++) {
　　　　　　if (strcmp(M->m[i].name,name)==0) {
　　　　　　　　return &M->m[i];
　　　　　　}
　　　　}
　　　　return NULL;
　　}

　　static int
　　_open_sym(struct skynet_module *mod) {
　　　　size_t name_size = strlen(mod->name);
　　　　char tmp[name_size + 9]; // create/init/release/signal , longest name is release (7)
　　　　memcpy(tmp, mod->name, name_size);
　　　　strcpy(tmp+name_size, "_create");
　　　　mod->create = dlsym(mod->module, tmp);//tmp为snlua_create
　　　　strcpy(tmp+name_size, "_init");
　　　　mod->init = dlsym(mod->module, tmp);//snlua_init
　　　　strcpy(tmp+name_size, "_release");//snlua_release
　　　　mod->release = dlsym(mod->module, tmp);
　　　　strcpy(tmp+name_size, "_signal");
　　　　mod->signal = dlsym(mod->module, tmp); //snlua_signal

　　　　return mod->init == NULL;
　　}

　　总结：snlua相当于lua服务的入口，在snlua的 _init函数中根据参数名称如（bootstrap）等启动对应的lua服务。

　　　　　即首先到module中查找该c服务（例如snlua）是否存在，若不存在则调用动态库函数打开该库，获取该库的必要函数。

　　　　　然后为该服务创建队列，并放到全局消息队列中。

　　　　　

　　skyney中每个动态库，都是扩展的服务，有自己的消息队列，回掉函数

　　下面介绍下标题内容即动态库操作的函数，这里用到：

　　

　　#include <dlfcn.h>

　　void *dlopen(const char *filename, int flag);

　　char *dlerror(void);

　　void *dlsym(void *handle, const char *symbol);

　　int dlclose(void *handle);
　　具体使用参考：http://www.cnblogs.com/Anker/p/3746802.html
　　
　　未完，待续。