nginx的worker进程如何创建lua虚拟机的？

待我称王封你为后i 2022-05-10 14:50 234阅读 0赞

**1，lua\_State在Lua中的定义如下：**  
    struct lua\_State \{  
        CommonHeader;  
        lu\_byte status;  
        StkId top;  /\* first free slot in the stack \*/  
        global\_State \*l\_G;  
        CallInfo \*ci;  /\* call info for current function\*/  
        const Instruction \*oldpc;  /\* last pc traced \*/  
        StkId stack\_last;    
        /\* last free slot in the stack\*/  
        StkId stack;  /\* stack base \*/  
        int stacksize;  
        unsigned short nny;   
        /\* number of non-yieldable calls in stack \*/  
        unsigned short nCcalls;   
        /\* number of nested C calls\*/  
        lu\_byte hookmask;  
        lu\_byte allowhook;  
        int basehookcount;  
        int hookcount;  
        lua\_Hook hook;  
        GCObject \*openupval;    
        /\* list of open upvalues in this stack \*/  
        GCObject \*gclist;  
        struct lua\_longjmp \*errorJmp;    
        /\* current error recover point \*/

ptrdiff\_t errfunc;    
        /\* current error handling function (stack index) \*/

CallInfo base\_ci;    
        /\* CallInfo for first level (C calling Lua) \*/  
    \};

**2，创建一个虚拟机，返回指针类型lua\_State**  
    不知道是不是老的版本，我在网上看到有网友的例子里这样写：  
        lua\_State \*L = lua\_open();  /\* opens Lua \*/

我下了Lua5.2编译后执行例子是不行的，找了lua源码也没有找到lua\_open()的定义。  
    暂不论它，现在生成lua\_State对像的方式应如下：  
        lua\_State \*L = luaL\_newstate();  
    luaL\_newstate在源码中的定义如下：  
        LUALIB\_API lua\_State \*luaL\_newstate (void)   
        \{  
            lua\_State \*L = lua\_newstate(l\_alloc, NULL);  
            if (L) lua\_atpanic(L, &panic);  
            return L;  
        \}

**3,luaL\_openlibs在源码中的定义：**  
    LUALIB\_API void luaL\_openlibs (lua\_State \*L)  
    \{  
        const luaL\_Reg \*lib;  
        /\* call open functions from 'loadedlibs' and set results to global table \*/  
        for (lib = loadedlibs; lib->func; lib++) \{  
            luaL\_requiref(L, lib->name, lib->func, 1);  
            lua\_pop(L, 1);  /\* remove lib \*/  
        \}  
        /\* add open functions from 'preloadedlibs' into 'package.preload' table \*/  
        luaL\_getsubtable(L, LUA\_REGISTRYINDEX, "\_PRELOAD");  
        for (lib = preloadedlibs; lib->func; lib++) \{  
            lua\_pushcfunction(L, lib->func);  
            lua\_setfield(L, -2, lib->name);  
        \}  
        lua\_pop(L, 1);  /\* remove \_PRELOAD table \*/  
    \}  
   把所有标准类库加载到指定的虚拟机。

4，意义  
   “Lua脚本的编译执行是相互独立的，在不同的进程上执行，通过luaL\_newstate()函数可以申请一个虚拟机，  
   返回指针类型lua\_State。今后其他所有Lua Api函数的调用都需要此指针作为第一参数，用来指定某个虚拟机。”

5，lua\_close  
   代码：  
   LUA\_API void lua\_close (lua\_State \*L) \{  
     L = G(L)->mainthread;  /\* only the main thread can be closed \*/  
     lua\_lock(L);  
     luai\_userstateclose(L);  
     close\_state(L);  
   \}  
   文档说明：  
       销毁指定虚拟机的所有对像（如果有垃圾回收相关的无方法则会调用该方法）  
       并收回所有由该虚拟机动态分配产生的内存，在有些平台下我们不需要调用此函数，因为当主程序退出时，  
       资源会被自然的释放掉，但是但一个长时间运行的程序，比如后台运行的web服务器，  
       需要立即回收虚拟机资源以避免内存过高占用。

**c语言中如何执行lua代码：**  
    c语言测试代码：  
        lua\_State\* L = NULL;

// 内部调用lua函数  
        double f(double x, double y)  
        \{  
            double z;  
            lua\_getglobal(L, "f");    // 获取lua函数f  
            lua\_pushnumber(L, x);    // 压入参数x和y  
            lua\_pushnumber(L, y);

if(lua\_pcall(L, 2, 1, 0) != 0)  
                error(L, "error running function 'f': %s", lua\_tostring(L, -1));

if(!lua\_isnumber(L, -1))  
                error(L, "function 'f' must return a number");  
            z = lua\_tonumber(L, -1);  
            lua\_pop(L, 1);  
            return z;  
        \}

int main(void)  
        \{  
            L = lua\_open();  
            luaL\_openlibs(L);

if(luaL\_loadfile(L, "c:\\\\luatest\\\\functest.lua") || lua\_pcall(L, 0, 0, 0))  
                error(L, "cannot run configuration file: %s", lua\_tostring(L, -1));  
            printf("%f\\n", f(1.0, 2.0));

return 0;  
        \}  
           
    functest.lua：  
        f = function(a, b)  
            return a + b  
        end  
          
这其中最关键的是调用函数的使用，在C中调用Lua函数的API主要由以下几个：  
    （1）void lua\_call (lua\_State \*L, int nargs, int nresults);  
    　　函数调用，nargs表示参数的个数，nresults表示返回值的个数  
    　　首先将lua函数压栈，然后将参数依次压栈，最后调用函数即可  
    　　函数调用时，参数和函数都会pop出栈，调用返回后，结果会push进栈  
    　　nresults==LUA\_MULTRET，所有的返回值都会push进栈  
    　　nresults!=LUA\_MULTRET，返回值个数根据nresults来调整  
    　　Lua语句：  
        a = f("how", t.x, 14)

在C中的实现：  
           
        lua\_getglobal(L, "f"); 　　　　　　 // 函数入栈  
        lua\_pushstring(L, "how"); 　　　  // 参数1入栈  
        lua\_getglobal(L, "t");　　　　　　 // 表t入栈  
        lua\_getfield(L, -1, "x"); 　　　　  // 参数2入栈  
        lua\_remove(L, -2); 　　　　　　  // 跳t出栈  
        lua\_pushinteger(L, 14);　　　　 // 参数3入栈  
        lua\_call(L, 3, 1); 　　　　　　     // 调用函数，参数和函数都会出栈  
        lua\_setglobal(L, "a");　　　　     // 给a赋值，栈顶出栈  
       
    　　上述代码执行完毕后，堆栈状态恢复原样。  
    （2）int lua\_pcall (lua\_State \*L, int nargs, int nresults, int msgh);  
    　　函数调用，在安全模式下，并且可以添加错误处理函数。  
    　　如果调用期间发生error，lua\_pcall会捕获之，然后push stack一个错误信息(会先将函数和参数pop出栈)，并且返回一个error code（非0的一个值）。  
    　　发生error时，如果指定了错误处理函数，会在error message入栈前调用错误处理函数，具体由msgh参数来决定：  
    　　（1）msgh==0，不指定错误处理函数，入栈信息不变；  
    　　（2）msgh!=0，msgh表示错误处理函数的堆栈index，错误处理函数会以error message为参数，并将返回的新的error message入栈。主要用来给error message添加　　更多的debug信息，比如堆栈跟踪，因为这些信息在pcall调用完之后是收集不到的。  
    　　函数返回代码：  
    　　LUA\_OK(0)：调用成功  
    　　LUA\_ERRRUN：runtime error  
    　　LUA\_ERRMEM：内存分配错误，这种情况下不会调用错误处理函数  
    　　LUA\_ERRERR：调用错误处理函数时出错，当然，不会再进一步调用错误处理函数  
    　　LUA\_ERRGCMM：调用metamethod.\_\_gc时报错，由gc引起，和函数本身没关系  
    （3）int lua\_pcallk (lua\_State \*L, int nargs, int nresults, int errfunc, int ctx, lua\_CFunction k);  
    　　函数调用，在安全模式下，并且允许函数yield。

**ngx每个worker中执行下面函数创建各自的lua虚拟机。**

ngx\_http\_lua\_init\_worker

---》ctx = ngx\_http\_lua\_create\_ctx(r);

---》 L = ngx\_http\_lua\_init\_vm(lmcf->lua, lmcf->cycle, r->pool, lmcf, r->connection->log, &cln);

**向HTTP模块介入的方式：**

通过向全局的ngx\_http\_core\_main\_conf\_t的phases\[xxx\]. handlers数组中添加ngx\_http\_handler\_pt方法来实现。该方法是通过必定会被调用的ngx\_http\_module\_t的postconfiguration方法向全局的ngx\_http\_core\_main\_conf\_t的phases\[xxx\]. handlers数组中添加ngx\_http\_handler\_pt方法来达成的，这个处理方法将应用于全部的http请求。

当access\_by\_lua\_file指令配置中存在时候处理函数ngx\_http\_lua\_access\_by\_lua中设置如下：      
    llcf->access\_handler = ngx\_http\_lua\_access\_handler\_file;  
    lmcf = ngx\_http\_conf\_get\_module\_main\_conf(cf, ngx\_http\_lua\_module);  
    lmcf->requires\_access = 1;  
    lmcf->requires\_capture\_filter = 1;

**ngx\_http\_lua\_module模块的ngx\_http\_lua\_init,/\*  postconfiguration \*/中功能如下：**  
    当requires\_access使能时候则向该阶段注册处理函数。  
    if (lmcf->requires\_access) \{  
        h = ngx\_array\_push(&cmcf->phases\[NGX\_HTTP\_ACCESS\_PHASE\].handlers);  
        if (h == NULL) \{  
            return NGX\_ERROR;  
        \}

\*h = ngx\_http\_lua\_access\_handler;//最终会执行llcf->access\_handler(r);即前面设置的ngx\_http\_lua\_access\_handler\_file函数。  
    \}

**例如通过指令access\_by\_lua\_file加载lua文件处理流程：**  
    ngx\_http\_lua\_access\_handler\_file  
    --》rc = ngx\_http\_lua\_cache\_loadfile(r->connection->log, L, script\_path, llcf->access\_src\_key);  
        --》rc = ngx\_http\_lua\_clfactory\_loadfile(L, (char \*) script);

--》最后执行ngx\_http\_lua\_access\_by\_chunk(L, r)--》 co = ngx\_http\_lua\_new\_thread(r, L, &co\_ref);--》 co = lua\_newthread(L);

**多个线程**  
       参考：[https://blog.csdn.net/sharemyfree/article/details/46754915][https_blog.csdn.net_sharemyfree_article_details_46754915]

从C API的角度来看，将线程想象成一个栈可能更形象些。从实现的观点来看，一个线程的确就是一个栈。每个栈都保留着一个线程中所有未完成的函数调用信息，这些信息包括调用的函数、每个调用的参数和局部变量。也就是说，一个栈拥有一个线程得以继续运行的所有信息。因此，多个线程就意味着多个独立的栈。  
当调用Lua C API中的大多数函数时，这些函数都作用于某个特定的栈。当我们调用lua\_pushnumber时，就会将数字压入一个栈中，那么Lua是如何知道该使用哪个栈的呢？答案就在类型lua\_State中。这些C API的第一个参数不仅表示了一个Lua状态，还表示了一个记录在该状态中的线程。  
只要创建一个Lua状态，Lua就会自动在这个状态中创建一个新线程，这个线程称为“主线程”。主线程永远不会被回收。当调用lua\_close关闭状态时，它会随着状态一起释放。调用lua\_newthread便可以在一个状态中创建其他的线程。  
lua\_State \*lua\_newthread(lua\_State \*L)  
这个函数返回一个lua\_State指针，表示新建的线程。它会将新线程作为一个类型为“thread”的值压入栈中。如果我们执行了：  
L1 = lua\_newthread(L);  
现在，我们拥有了两个线程L和L1，它们内部都引用了相同的Lua虚拟机。每个线程都有其自己的栈。新线程L1以一个空栈开始运行，老线程L的栈顶就是这个新线程。  
除了主线程以外，其它线程和其它Lua对象一样都是垃圾回收的对象。当新建一个线程时，线程会压入栈，这样能确保新线程不会成为垃圾，而有的时候，你在处理栈中数据时，不经意间就把线程弹出栈了，而当你再次使用该线程时，可能导致找不到对应的线程而程序崩溃。为了避免这种情况的发生，可以保持一个对线程的引用，比如在注册表中保存一个对线程的引用。  
当拥有了一个线程以后，我们就可以像主线程那样来使用它，以前博文中提到的对栈的操作，对这个新的线程都适用。然而，使用多线程的目的不是为了实现这些简单的功能，而是为了实现协同程序。  
为了挂起某些协同程序的执行，并在稍后恢复执行，我们可以使用lua\_resume函数来实现。  
int lua\_resume(lua\_State \*L, int narg);  
lua\_resume可以启动一个协同程序，它的用法就像lua\_call一样。将待调用的函数压入栈中，并压入其参数，最后在调用lua\_resume时传入参数的数量narg。这个行为与lua\_pcall类似，但有3点不同。  
lua\_resume没有参数用于指出期望的结果数量，它总是返回被调用函数的所有结果；  
它没有用于指定错误处理函数的参数，发生错误时不会展开栈，这就可以在发生错误后检查栈中的情况；  
如果正在运行的函数交出（yield）了控制权，lua\_resume就会返回一个特殊的代码LUA\_YIELD，并将线程置于一个可以被再次恢复执行的状态。  
当lua\_resume返回LUA\_YIELD时，线程的栈中只能看到交出控制权时所传递的那些值。调用lua\_gettop则会返回这些值的数量。若要将这些值移到另一个线程，可以使用lua\_xmove。  
为了恢复一个挂起线程的执行，可以再次调用lua\_resume。在这种调用中，Lua假设栈中所有的值都是由yield调用返回的，当然了，你也可以任意修改栈中的值。作为一个特例，如果在一个lua\_resume返回后与再次调用lua\_resume之间没有改变过线程栈中的内容，那么yield恰好返回它交出的值。如果能很好的理解这个特例是什么意思，那就说明你已经非常理解Lua中的协同程序了，如果你还是不知道我说的这个特例是什么意思，请再去读一遍《Lua中的协同程序》，如果你还不懂，那你就在下放留言吧（提醒：这个特例主要利用的是resume-yield之间的传参规则）。

[https_blog.csdn.net_sharemyfree_article_details_46754915]: https://blog.csdn.net/sharemyfree/article/details/46754915