找到 lua 死循环代码

最近遇到 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 只有互斥锁的开销，没有临界资源竞争，锁的开销就非常小。再者，大多数项目中，死循环出现的可能性也比较低。

最后，欢迎评论！