完成环境设置 和 配置信息加载 之后调用skynet_start(&config)
// register SIGHUP for log file reopen
struct sigaction sa;
sa.sa_handler = &handle_hup;
sa.sa_flags = SA_RESTART;
sigfillset(&sa.sa_mask);
sigaction(SIGHUP, &sa, NULL);
一些IO系统调用执行时, 如 read 等待输入期间, 如果收到一个信号,系统将中断read, 转而执行信号处理函数。当信号处理返回后, 系统遇到了一个问题: 是重新开始这个系统调用, 还是让系统调用失败? 安装信号的时候, 设置 SA_RESTART属性, 那么当信号处理函数返回后, 被该信号中断的系统调用将自动恢复.
继续阅读代码，根据配置信息进行一系列初始化，
//初始化节点模块，用于集群，转发远程节点的消息
skynet_harbor_init(config->harbor);
//初始化句柄模块，用于给每个Skynet服务创建一个全局唯一的句柄值
skynet_handle_init(config->harbor);
//skynet_handle.c
void skynet_handle_init(int harbor) {
assert(H==NULL);
struct handle_storage * s = skynet_malloc(sizeof(*H));
s->slot_size = DEFAULT_SLOT_SIZE;
s->slot = skynet_malloc(s->slot_size * sizeof(struct skynet_context *));
memset(s->slot, 0, s->slot_size * sizeof(struct skynet_context *));
rwlock_init(&s->lock);
// reserve 0 for system
s->harbor = (uint32_t) (harbor & 0xff) << HANDLE_REMOTE_SHIFT;
s->handle_index = 1;
s->name_cap = 2;
s->name_count = 0;
s->name = skynet_malloc(s->name_cap * sizeof(struct handle_name));
H = s;
// Don't need to free H
}
//初始化消息队列模块，这是Skynet的主要数据结构
skynet_mq_init();
//skynet_mq.c
void skynet_mq_init() {
struct global_queue *q = skynet_malloc(sizeof(*q));
memset(q,0,sizeof(*q));
SPIN_INIT(q);
//全局消息队列
Q=q;
}
//初始化服务动态库加载模块，主要用于加载符合Skynet服务模块接口的动态链接库（.so）
skynet_module_init(config->module_path);
//初始化定时器模块
skynet_timer_init();
//初始化网络模块
skynet_socket_init();
//初始化是否统计每个服务使用了多少 cpu 时间
skynet_profile_enable(config->profile);
skynet_context_new实例化logservice
struct skynet_context *ctx = skynet_context_new(config->logservice, config->logger);
if (ctx == NULL) {
fprintf(stderr, "Can't launch %s service\n", config->logservice);
exit(1);
}
创建服务流程如下：
1.加载服务模块so，在module模块中全局静态变量M中找，找不到用_try_open函数加载，自己手写的c模块应该有init函数
struct skynet_context *
skynet_context_new(const char * name, const char *param) {
struct skynet_module * mod = skynet_module_query(name);
2.让加载出来的模块自动生成一个新的实例，调用模块的create函数，如果有
void *inst = skynet_module_instance_create(mod);
//skynet_module.c
void * skynet_module_instance_create(struct skynet_module *m) {
if (m->create) {
return m->create();
} else {
return (void *)(intptr_t)(~0);
}
}
3.给新实例注册一个事件处理的handle并创建这个实例的消息队列
ctx->handle = skynet_handle_register(ctx);
struct message_queue * queue = ctx->queue = skynet_mq_create(ctx->handle);
4.将实例的消息队列加到全局的消息队列中，这样才能收到消息回调
skynet_globalmq_push(queue);
有个奇怪的地方,引用计数一开始赋值为2，在创建完成后引用计数-1
ctx->ref = 2;
....
struct skynet_context * ret = skynet_context_release(ctx);
加载bootstrap 模块，同样使用 skynet_context_new() 与上面启动 logger 服务一样，先把 snlua.so 模块加载进来，然后调用此模块自身的实例化方法，去实例化一个 snlua 服务，并传入要实例化的 lua服务的脚本名称 为 bootstarp，bootstrap会根据config中 luaservice 配置的目录去获取指定名称的 lua脚本，按照默认目录最后会匹配到 service/bootstrap.lua 。snlua 是lua的沙盒服务，所有的 lua服务 都是一个 snlua 的实例。
static void bootstrap(struct skynet_context * logger, const char * cmdline) {
//获取字符串长度
int sz = strlen(cmdline);
char name[sz+1];
char args[sz+1];
//将传入的cmdline字符串按照格式分割成两部分，前部分模块名，后部分为模块初始化参数
sscanf(cmdline, "%s %s", name, args);
//创建并启动指定模块的一个服务
struct skynet_context *ctx = skynet_context_new(name, args);
//假如创建失败
if (ctx == NULL) {
//通过传入的logger服务接口构建错误信息假如logger消息队列
skynet_error(NULL, "Bootstrap error : %s\n", cmdline);
//输出消息队列中的错误信息
skynet_context_dispatchall(logger);
//结束程序
exit(1);
}
}
snlua 实例化的过程：
1.在snlua加载的时候，模块的create函数为"模块名字_方法名"
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);
strcpy(tmp+name_size, "_init");
mod->init = dlsym(mod->module, tmp);
strcpy(tmp+name_size, "_release");
mod->release = dlsym(mod->module, tmp);
strcpy(tmp+name_size, "_signal");
mod->signal = dlsym(mod->module, tmp);
return mod->init == NULL;
}
调用snlua的snlua_create函数,最后返回的是一个通过 lua_newstate 创建出来的 Lua vm（lua虚拟机），也就是一个沙盒环境，这是为了达到让每个 lua服务 都运行在独立的虚拟机中。
struct snlua *
snlua_create(void) {
struct snlua * l = skynet_malloc(sizeof(*l));
memset(l,0,sizeof(*l));
l->mem_report = MEMORY_WARNING_REPORT;
l->mem_limit = 0;
l->L = lua_newstate(lalloc, l);
return l;
}
2.lua服务的初始化
给当前服务实例注册绑定了一个回调函数 launch_cb
给本服务发送一条消息，内容就是之前传入的参数 bootstrap
当此服务的消息队列被push进全局的消息队列后，本服务收到的第一条消息就是上述在初始化中给自己发送的那条消息，此时便会调用回调函数launch_cb并执行处理逻辑：
int snlua_init(struct snlua *l, struct skynet_context *ctx, const char * args) {
int sz = strlen(args);
//在内存中准备一个空间（动态内存分配）
char * tmp = skynet_malloc(sz);
//内存拷贝：将args内容拷贝到内存中的temp指针指向地址的内存空间
memcpy(tmp, args, sz);
//注册回调函数为launch_cb这个函数，有消息传入时会调用回调函数并处理
skynet_callback(ctx, l , launch_cb);
const char * self = skynet_command(ctx, "REG", NULL);
//当前lua实例自己的句柄id（转为无符号长整型）
uint32_t handle_id = strtoul(self+1, NULL, 16);
// it must be first message
// 给自己发送一条消息，内容为args字符串
skynet_send(ctx, 0, handle_id, PTYPE_TAG_DONTCOPY,0, tmp, sz);
return 0;
}
static int launch_cb(struct skynet_context * context, void *ud, int type, int session, uint32_t source , const void * msg, size_t sz) {
assert(type == 0 && session == 0);
struct snlua *l = ud;
//将服务原本绑定的句柄和回调函数清空
//这个方法里把服务自己在C语言层面的回调函数给注销了，使它不再接收消息，目的是：在lua层重新注册它，把消息通过lua接口来接收。
skynet_callback(context, NULL, NULL);
//设置各项资源路径参数，并加载loader.lua
int err = init_cb(l, context, msg, sz);
if (err) {
skynet_command(context, "EXIT", NULL);
}
return 0;
}
转载 http://blog.csdn.net/linshuhe1/article/details/70174698
参考资料
1.http://blog.csdn.net/xiajun07061225/article/details/9250579