skynet源码分析（1）--模块加载

作者：[email protected]，转载请注明作者

两个月前接触skynet，最初使用的时候过程是相当痛苦的，而且网络上可以找到的学习资料并不多。当时决定写一些skynet相关的文章，最近终于有空了，开始写这个东西。

skynet是云风开源的一个游戏框架，底层是c，中间层和上层都是lua。基于actor模型，使用消息队列进行内部通信。万丈高楼平地起，先开始看最底层的内容吧，因为上层的会涉及一些业务，而最底层的只涉及一些系统调用，理解起来更简单。

阅读代码使用的工具是eclipse cdt。代码提交tag是f94ca6f

skynet底层代码位于skynet/skynet-src下,模块加载相关在skynet-module.c skynet-module.h这两个文件里。这里的模块在linux下指的是so，在windows下指的是dll，在skynet中指的是config中配置的cpath下的文件。

//以下四行为函数指针声明
typedef void * (*skynet_dl_create)(void);
typedef int (*skynet_dl_init)(void * inst, struct skynet_context *, const char * parm);
typedef void (*skynet_dl_release)(void * inst);
typedef void (*skynet_dl_signal)(void * inst, int signal);

//单个模块的结构体
struct skynet_module {
    const char * name; //模块名
    void * module; //模块指针
    skynet_dl_create create;  //create函数
    skynet_dl_init init; //init函数
    skynet_dl_release release; //release函数
    skynet_dl_signal signal; //signal函数
};

//添加一个模块
void skynet_module_insert(struct skynet_module *mod);
//查询一个模块
struct skynet_module * skynet_module_query(const char * name);
//某个模块中的create函数调用
void * skynet_module_instance_create(struct skynet_module *);
//某个模块中的init函数调用
int skynet_module_instance_init(struct skynet_module *, void * inst, struct skynet_context *ctx, const char * parm);
//某个模块中的release函数调用
void skynet_module_instance_release(struct skynet_module *, void *inst);
//某个模块中的signal函数调用
void skynet_module_instance_signal(struct skynet_module *, void *inst, int signal);
//初始化模块管理
void skynet_module_init(const char *path);

从上面的代码可以看出，每个模块需要实现四个最基本的函数，create/init/release/signal。注意这里并不是说函数名字叫这个，函数名字具体叫什么下面会讲到。

#define MAX_MODULE_TYPE 32

//这里定义了模块列表数据结构
struct modules {
    int count;
    struct spinlock lock;
    const char * path;
    struct skynet_module m[MAX_MODULE_TYPE]; //最多只能加载32个模块
};

static struct modules * M = NULL;

//内部函数，打开一个动态库
static void *
_try_open(struct modules *m, const char * name) {
    const char *l;
    const char * path = m->path;
    size_t path_size = strlen(path);
    size_t name_size = strlen(name);

    int sz = path_size + name_size;
    //search path
    void * dl = NULL;
    char tmp[sz];
    //遍历路径查找so，路径以;分隔
    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);
        }
        //dlope打开so
        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;icount;i++) {
        if (strcmp(M->m[i].name,name)==0) {
            return &M->m[i];
        }
    }
    return NULL;
}

static void *
get_api(struct skynet_module *mod, const char *api_name) {
    size_t name_size = strlen(mod->name);
    size_t api_size = strlen(api_name);
    char tmp[name_size + api_size + 1];
        //将模块名附到tmp中
    memcpy(tmp, mod->name, name_size);
        //将方法名附到tmp中
    memcpy(tmp+name_size, api_name, api_size+1);
    char *ptr = strrchr(tmp, '.');
    if (ptr == NULL) {
        ptr = tmp;
    } else {
        ptr = ptr + 1;
    }
        // dlsym是一个系统函数，根据函数名字获取函数地址（指针）
    return dlsym(mod->module, ptr);
}

static int
open_sym(struct skynet_module *mod) {
    mod->create = get_api(mod, "_create");  //获取create方法
    mod->init = get_api(mod, "_init");  //获取init方法
    mod->release = get_api(mod, "_release");  //获取release方法
    mod->signal = get_api(mod, "_signal");  //获取signal方法

    return mod->init == NULL;  //然而这里只判定只要实现了init就可以了
}

//根据模块名查找模块
struct skynet_module * 
skynet_module_query(const char * name) {
        //先到列表里查
    struct skynet_module * result = _query(name);
    if (result)
        return result;

    SPIN_LOCK(M)

    result = _query(name); // double check
    //在列表里没查到
    if (result == NULL && M->count < MAX_MODULE_TYPE) {
        int index = M->count;
        //打开so
        void * dl = _try_open(M,name);
        if (dl) {
            M->m[index].name = name;
            M->m[index].module = dl;
            //获取so中的init/create/release/signal方法地址
            if (open_sym(&M->m[index]) == 0) {
                M->m[index].name = skynet_strdup(name);
                M->count ++;
                result = &M->m[index];
            }
        }
    }

    SPIN_UNLOCK(M)

    return result;
}

//添加模块到模块列表
void 
skynet_module_insert(struct skynet_module *mod) {
    SPIN_LOCK(M)

        //模块是不是已经在列表中了
    struct skynet_module * m = _query(mod->name);
    assert(m == NULL && M->count < MAX_MODULE_TYPE);
    int index = M->count;
    M->m[index] = *mod;
    ++M->count;

    SPIN_UNLOCK(M)
}

void * 
skynet_module_instance_create(struct skynet_module *m) {
    if (m->create) {
        return m->create(); //对应上文说的，调用模块的create函数
    } else {
        return (void *)(intptr_t)(~0);
    }
}

int
skynet_module_instance_init(struct skynet_module *m, void * inst, struct skynet_context *ctx, const char * parm) {
    return m->init(inst, ctx, parm); //对应上文说的，调用模块的init函数
}

void 
skynet_module_instance_release(struct skynet_module *m, void *inst) {
    if (m->release) {
        m->release(inst); //对应上文说的，调用模块的release函数
    }
}

void
skynet_module_instance_signal(struct skynet_module *m, void *inst, int signal) {
    if (m->signal) {
        m->signal(inst, signal); //对应上文说的，调用模块的release函数
    }
}

//初始化模块列表数据结构
void 
skynet_module_init(const char *path) {
    struct modules *m = skynet_malloc(sizeof(*m));
    m->count = 0;
    m->path = skynet_strdup(path);

    SPIN_INIT(m)

    M = m;
}

skynet_module_init在skynet-main.c中被调用，传进来的path是在运行时config中配置的，如果config文件中没有配置cpath，默认将cpath的值设为./cservice/?.so，加载cpath目录下的so文件。

从get_api可以看出来，skynet要求模块的create/init/release/signal方法的命名是模块名加一个下划线，后面带create/init/release/signal。在skynet/service-src目录下有现成的例子，大家可以去看一下。

到这里，整个模块加载功能就分析完了。从启动流程来分析是，首先在config文件中配置一个cpath，它包含了你想要加载的so的路径。然后skynet-main.c在启动的时候会把cpath读出来，设进moduls->path中。在skynet-server.c中的skynet_context_new中会调用skynet_module_query，skynet_module_query首先会在列表中查询so是否已经加载，如果没有就直接加载它。

模块一定要包含有四个函数init/create/release/signal，它的命名格式为，假定模块名为xxx，那么就是xxx_create/xxx_init/xxx_release/xxx_signal。这四个函数是干嘛用的？

create做内存分配。init做初始化，它可能会做一些其它的事情，比如打开网络，打开文件，函数回调挂载等等。relase做资源回收，包括内存资源，文件资源，网络资源等等，signal是发信号，比如kill信号，告诉模块该停了。