最近遇到 lua 死循环的情况，就研究下如何找到死循环所在的代码，方便定位和解决问题。
首先，要找到出问题的协程（lua_State）。lua vm 实现时，每个协程都有自己独立的堆栈（stack），以及函数栈（CallInfo）。
所以，要先找到死循环的协程，再从这个协程函数栈找到代码。
怎么找到这个协程？
有三种办法：
方法1、 在死循环会执行到的 opcode ，加代码取得当前协程；
方法2、 遍历所有 gc 数据对象，找到当前正在执行的协程；
方法3、 重写 coroutine.resume 及 wrap 函数，取得当前协程。
方法2 找到 lua 协程
先说第 2 种方法，因为我一开始就是这么干的，能快速找到，不用修改 lua vm 代码，但弊端也有，需要处理多线程问题。
代码以5.3.4为例，其他可能要修改
global_State *g = G(L);
GCObject *p;
// 遍历所有的数据对象
for (p = g->allgc; p != NULL; p = p->next) {
// 找到所有 lua state 对象， LUA_TTHREAD 定义 8
if (p->tt == 8 ) {
// 存活对象， 由 !isdead(g,v) 展开
if ((p->marked ^ 3) & (g->currentwhite ^ 3)) {
// 取得 lua state， 由 gco2th(p) 展开
lua_State *thread = &((union GCUnion *)p)->th;
// lua state 正在运行， LUA_OK 定义 0
if (thread->status == 0 && thread->ci != &thread->base_ci) {
// 找到当前正在运行的协程
}
}
}
}
以上代码，在多线程下，你的线程正在遍历 gc 数据对象，而调度 lua vm 的线程执行 gc ，就会出问题，数据对象可能被释放掉了。
如果确定要用这个方法，可以利用 lua 预留的锁函数
// llimits.h
/*
** macros that are executed whenever program enters the Lua core
** ('lua_lock') and leaves the core ('lua_unlock')
*/
#if !defined(lua_lock)
#define lua_lock(L) ((void) 0)
#define lua_unlock(L) ((void) 0)
#endif
如下使用互斥锁，具体实现就不赘述了。
#define lua_lock(L) pthread_mutex_lock(&(_G(L)->lock)); #define lua_unlock(L) pthread_mutex_unlock(&(_G(L)->lock));
方法1 找到 lua 协程
在 skynet 的代码中， lua vm 处理 opcode 时，对于一些特定 opcode，加代码标记当前 lua_State， 涉及的 opcode 有 OP_JMP、 OP_FORLOOP、OP_TFORLOOP、OP_TAILCALL、OP_CALL
// lvm.c
vmcase(OP_JMP) {
lua_checksig(L); // skynet add
dojump(ci, i, 0);
vmbreak;
}
// skynet add
lua_State * skynet_sig_L = NULL;
LUA_API void
lua_checksig_(lua_State *L) {
// 实现退出死循环
if (skynet_sig_L == G(L)->mainthread) {
skynet_sig_L = NULL;
lua_pushnil(L);
lua_error(L);
}
}
// lua.h
// skynet add
LUA_API lua_State * skynet_sig_L;
LUA_API void (lua_checksig_)(lua_State *L);
#define lua_checksig(L) if (skynet_sig_L) { lua_checksig_(L); }
所以，出现死循环时，不需要知道哪个协程。只要标记 lua vm 的主协程（mainthread），主协程在 lua vm 初始化后不会改变。标记在 skynet_sig_L
这样，lua vm 处理 opcode 处理时，判定当前主协程为标记的协程，当前协程很大可能就是死循环的协程。
方法3 找到 lua 协程
在 skynet 新的代码中，通过重写 global 表的 coroutine.resume 、 coroutine.wrap 函数，取得当前协程
// service_snlua.c
static int
init_cb(struct snlua *l, skynet_context *ctx, const char * args, size_t sz) {
lua_State *L = l->L;
//...
luaL_openlibs(L);
luaL_requiref(L, "skynet.profile", init_profile, 0);
int profile_lib = lua_gettop(L);
// replace coroutine.resume / coroutine.wrap
lua_getglobal(L, "coroutine");
lua_getfield(L, profile_lib, "resume");
lua_setfield(L, -2, "resume");
lua_getfield(L, profile_lib, "wrap");
lua_setfield(L, -2, "wrap");
//...
}
static int
init_profile(lua_State *L) {
luaL_Reg l[] = {
{ "start", lstart },
{ "stop", lstop },
{ "resume", luaB_coresume },
{ "wrap", luaB_cowrap },
{ NULL, NULL },
};
luaL_newlibtable(L,l);
// ...
}
static int luaB_coresume (lua_State *L) {
int r = timing_resume(L, 1, lua_gettop(L) - 1);
// ...
}
static int
timing_resume(lua_State *L, int co_index, int n) {
lua_State *co = lua_tothread(L, co_index);
// ...
int r = auxresume(L, co, n);
// ...
return r;
}
static int auxresume (lua_State *L, lua_State *co, int narg) {
int status, nres;
lua_xmove(L, co, narg);
status = lua_resumeX(co, L, narg, &nres);
// ...
}
static int
lua_resumeX(lua_State *L, lua_State *from, int nargs, int *nresults) {
void *ud = NULL;
lua_getallocf(L, &ud);
struct snlua *l = (struct snlua *)ud;
switchL(L, l);
int err = lua_resume(L, from, nargs, nresults);
// ...
switchL(from, l);
return err;
}
static void
switchL(lua_State *L, struct snlua *l) {
l->activeL = L;
// ...
}
以上，l->activeL 为当前执行的协程。
找到当前正在运行的代码
遍历当前协程的函数栈，一直回溯，打印所有函数名和行数。
CallInfo *ci;
// 遍历函数栈
for (ci = thread->ci; ci != NULL && ci != &thread->base_ci; ci = ci->previous) {
// 如果是 lua function, 由 ttype(ci->func) == LUA_TLCL 展开
if (ci->func->tt_ & 0x3F == 6) {
// 找到代码，由 clLvalue(ci->func) ->p 展开
Proto *sp = ((union GCUnion *)(ci->func->value_.gc))->cl.l.p;
// 找到函数名，由 getstr(p->source) 展开
char * filename = sp->source ? (char *) ((char *)(sp->source) +
sizeof(UTString)) : "unknown";
printf("LUA FUNCTION : %s %d %d", filename, sp->linedefined,
sp->lastlinedefined);
}
}
死循环检查
如何发现 lua 代码出现了死循环，说下 skynet 的思路。
// skynet_server.c
// 每次处理消息，monitor 模块记录当前要调度的 skynet 服务 id
skynet_monitor_trigger(sm, msg.source , handle);
if (ctx->cb == NULL) {
skynet_free(msg.data);
} else {
dispatch_message(ctx, &msg);
}
// 消息处理完，monitor 模块取消记录服务 id
skynet_monitor_trigger(sm, 0,0);
看下 monitor 模块的处理。
// skynet_monitor.c
void
skynet_monitor_trigger(struct skynet_monitor *sm, uint32_t source, uint32_t destination) {
sm->source = source;
sm->destination = destination;
// 版本号自增
ATOM_INC(&sm->version);
}
然后，再起个线程定时检查版本号，如果版本号不变，则判定 lua 代码可能死循环
// skynet_monitor.c
void
skynet_monitor_check(struct skynet_monitor *sm) {
// 如果版本号和上次检查结果一样，则 lua 可能死循环
if (sm->version == sm->check_version) {
if (sm->destination) {
skynet_context_endless(sm->destination);
skynet_error(NULL, "A message from [ :%08x ] to [ :%08x ] maybe in an endless loop (version = %d)",
sm->source , sm->destination, sm->version);
}
} else {
sm->check_version = sm->version;
}
}
其他项目也可以参照 skynet 的思路，调用 lua 态时，调用一次自增一次版本号，再定时检查下版本号是否没改变。
结束语
方法2 要遍历所有的数据对象，在 vm 数据对象过多时，开销比较大，但这种方法也有优点，不改变 lua 原生代码的处理，没有调用时对 vm 只有互斥锁的开销，没有临界资源竞争，锁的开销就非常小。再者，大多数项目中，死循环出现的可能性也比较低。
最后，欢迎评论！
good