openresty源码剖析——lua代码的执行

刺骨的言语ヽ痛彻心扉 2024-04-17 06:23 58阅读 0赞

上一篇文章中([https://cloud.tencent.com/developer/article/1037840][https_cloud.tencent.com_developer_article_1037840])我们讨论了openresty是如何加载lua代码的

那么加载完成之后的lua代码又是如何执行的呢

**\#\#代码的执行**

在init\_by\_lua等阶段 openresty是在主协程中通过lua\_pcall直接执行lua代码

而在access\_by\_lua content\_by\_lua等阶段中，openresty创建一个新的协程，通过lua\_resume执行lua代码

二者的区别在于能否执行ngx.slepp. ngx.thread ngx.socket 这些有让出操作的函数

我们依旧以content\_by\_\*\*阶段为例进行讲解

**\#content\_by\_\*\*阶段**

content\_by\_\*\*阶段对应的请求来临时，执行流程为 ngx\_http\_lua\_content\_handler -> ngx\_http\_lua\_content\_handler\_file-> ngx\_http\_lua\_content\_by\_chunk

ngx\_http\_lua\_content\_handler 和 ngx\_http\_lua\_content\_handler\_file 完成了请求上下文初始化，代码加载等操作

ngx\_http\_lua\_content\_by\_chunk进行代码的执行工作

**\#ngx\_http\_lua\_content\_by\_chunk**

24 ngx_int_t
    25 ngx_http_lua_content_by_chunk(lua_State *L, ngx_http_request_t *r)
    26 {
    27 ...
    50     ctx->entered_content_phase = 1;//标示当前进入了content_phase
    51
    52     /*  {
      {
      { new coroutine to handle request */
    53     co = ngx_http_lua_new_thread(r, L, &co_ref);//创建了一个新的lua协程
    54
    61 ...
    62     /*  move code closure to new coroutine */
    63     lua_xmove(L, co, 1);//主协程的栈顶是需要执行的lua函数，通过lua_xmove将栈顶函数交换到新lua协程中
    64
    65     /*  set closure's env table to new coroutine's globals table */
    66     ngx_http_lua_get_globals_table(co);
    67     lua_setfenv(co, -2);
    68
    69     /*  save nginx request in coroutine globals table */
    70     ngx_http_lua_set_req(co, r);//把当前请求r赋值给新协程的全局变量中
    71 ...
    103     rc = ngx_http_lua_run_thread(L, r, ctx, 0);//运行新协程
    104 ...
    109     if (rc == NGX_AGAIN) {
    110         return ngx_http_lua_content_run_posted_threads(L, r, ctx, 0);//执行需要延后执行的协程，0表示上面传来的状态是NGX_AGAIN
    111     }
    112
    113     if (rc == NGX_DONE) {
    114         return ngx_http_lua_content_run_posted_threads(L, r, ctx, 1);//执行需要延后执行的协程，1表示上面传来的状态是NGX_DONE
    115     }
    116
    117     return NGX_OK;
    118 }

27-50行，有一步是重新设置请求的上下文，将用于标示当前进入了那个阶段的变量重置为0

855     ctx->entered_rewrite_phase = 0;
    856     ctx->entered_access_phase = 0;
    857     ctx->entered_content_phase = 0;

这几个字段的用处在ngx\_http\_lua\_content\_handler函数中用于确认之前是否进入过对应阶段

135 ngx_int_t
    136 ngx_http_lua_content_handler(ngx_http_request_t *r)
    137 {
    138 ...
    170     if (ctx->entered_content_phase) {
    171         dd("calling wev handler");
    172         rc = ctx->resume_handler(r);
    173         dd("wev handler returns %d", (int) rc);
    174         return rc;
    175     }
    176 ...
    206 }

53行，创建了一个新的lua协程

63行，加载代码的时候，我们把需要执行的lua函数放到了主协程的栈顶，所以这里我们需要通过lua\_xmove将函数移到新协程中

70行，把当前请求r赋值给新协程的全局变量中，从而可以让lua执行获取和请求相关的一些函数，比如ngx.req.get\_method()和ngx.set\_method,ngx.req.stat\_time()等

103行，运行新创建的lua协程

109-114行，ngx.thread.spawn中创建子协程后，会调用ngx\_http\_lua\_post\_thread。ngx\_http\_lua\_post\_thread函数将父协程放在了ctx->posted\_threads指向的链表中，这里的ngx\_http\_lua\_content\_run\_posted\_threads运行延后执行的主协程

**\#ngx\_http\_lua\_new\_thread创建协程**

303 lua_State *
    304 ngx_http_lua_new_thread(ngx_http_request_t *r, lua_State *L, int *ref)
    305 {
    306 ...
    312     base = lua_gettop(L);
    313
    314     lua_pushlightuserdata(L, &ngx_http_lua_coroutines_key);//获取全局变量中储存协程的table
    315     lua_rawget(L, LUA_REGISTRYINDEX);
    316
    317     co = lua_newthread(L);//创建新协程
    319 ...
    334     *ref = luaL_ref(L, -2);//将创建的新协程保存对应的全局变量中
    335
    336     if (*ref == LUA_NOREF) {
    337         lua_settop(L, base);  /* restore main thread stack */
    338         return NULL;
    339     }
    340
    341     lua_settop(L, base);//恢复主协程的栈空间大小
    342     return co;
    343 }

312行，获得了主协程栈中有多少元素

314-315行，获得全局变量中储存协程的table LUA\_REGISTRYINDEX\[‘ngx\_http\_lua\_code\_coroutines\_key’\]

因为lua中协程也是GC的对象，会被lua系统进行垃圾回收，为了保证挂起的协程不会被GC掉，openresty使用了 LUA\_REGISTRYINDEX\[‘ngx\_http\_lua\_code\_coroutines\_key’\]来保存新创建的协程，在协程执行完毕后将协程从table

中删除，使的GC可以将这个协程垃圾回收掉

317行，创建了一个lua\_newthread并把其压入主协程的栈顶

334行，将新创建的协程保存到LUA\_REGISTRYINDEX\[‘ngx\_http\_lua\_code\_coroutines\_key’\]

341行，恢复主协程的栈空间大小

343行，返回新创建的协程

**\#ngx\_http\_lua\_run\_thread运行协程**

ngx\_http\_lua\_run\_thread函数的代码行数比较多，有500多行，内容如下：

951 ngx_http_lua_run_thread(lua_State *L, ngx_http_request_t *r,
    952     ngx_http_lua_ctx_t *ctx, volatile int nrets)
    953 {
    954 ...
    973     NGX_LUA_EXCEPTION_TRY {
    974 ...
    982         for ( ;; ) {
    983 ...
    997             orig_coctx = ctx->cur_co_ctx;
    998 ...
    1015             rv = lua_resume(orig_coctx->co, nrets);//通过lua_resume执行协程中的函数
    1016 ...
    1032             switch (rv) {//处理lua_resume的返回值
    1033             case LUA_YIELD:
    1034 ..
    1047                 if (r->uri_changed) {
    1048                     return ngx_http_lua_handle_rewrite_jump(L, r, ctx);
    1049                 }
    1050                 if (ctx->exited) {
    1051                     return ngx_http_lua_handle_exit(L, r, ctx);
    1052                 }
    1053                 if (ctx->exec_uri.len) {
    1054                     return ngx_http_lua_handle_exec(L, r, ctx);
    1055                 }
    1056                 switch(ctx->co_op) {
    1057 ...
    1167                 }
    1168                 continue;
    1169             case 0:
    1170 ...
    1295                 continue;
    1296 ...
    1313             default:
    1314                 err = "unknown error";
    1315                 break;
    1316             }
    1317 ...
    1444         }
    1445     } NGX_LUA_EXCEPTION_CATCH {
    1446         dd("nginx execution restored");
    1447     }
    1448     return NGX_ERROR;
    1449
    1450 no_parent:
    1451 ...
    1465     return (r->header_sent || ctx->header_sent) ?
    1466                 NGX_ERROR : NGX_HTTP_INTERNAL_SERVER_ERROR;
    1467
    1468 done:
    1469 ...
    1481     return NGX_OK;
    1482 }

1015行，通过lua\_resume执行协程的函数，并根据返回的结果进行不同的处理

LUA\_YIELD: 协程被挂起

0: 协程执行结束

其他: 运行出错，如内存不足等

1032             switch (rv) {
    1033             case LUA_YIELD:
    1034 ...
    1047                 if (r->uri_changed) {
    1048                     return ngx_http_lua_handle_rewrite_jump(L, r, ctx);//调用了ngx.redirect
    1049                 }
    1050
    1051                 if (ctx->exited) {
    1052                     return ngx_http_lua_handle_exit(L, r, ctx);//调用了ngx.exit
    1053                 }
    1054
    1055                 if (ctx->exec_uri.len) {
    1056                     return ngx_http_lua_handle_exec(L, r, ctx);//调用了ngx.exec
    1057                 }

**lua\_resume返回LUA\_YIELD，表示被挂起**

先处理以下3种情况：

r->uri\_changed为true表明调用了ngx.redirect

ext->exited为true表明调用了ngx.exit

ctx->exec\_uri.len为true表明调用了ngx.exec

其余情况需要再比较ctx->co\_op的返回值

1063                 switch(ctx->co_op) {
    1064                 case NGX_HTTP_LUA_USER_CORO_NOP:
    1065 ...
    1069                     ctx->cur_co_ctx = NULL;
    1070                     return NGX_AGAIN;
    1071                 case NGX_HTTP_LUA_USER_THREAD_RESUME://ngx.thread.spawn
    1072 ...
    1075                     ctx->co_op = NGX_HTTP_LUA_USER_CORO_NOP;
    1076                     nrets = lua_gettop(ctx->cur_co_ctx->co) - 1;
    1077                     dd("nrets = %d", nrets);
    1078 ...
    1084                     break;
    1085                 case NGX_HTTP_LUA_USER_CORO_RESUME://coroutine.resume
    1086 ...
    1093                     ctx->co_op = NGX_HTTP_LUA_USER_CORO_NOP;
    1094                     old_co = ctx->cur_co_ctx->parent_co_ctx->co;
    1095                     nrets = lua_gettop(old_co);
    1096                     if (nrets) {
    1097                         dd("moving %d return values to parent", nrets);
    1098                         lua_xmove(old_co, ctx->cur_co_ctx->co, nrets);
    1099 ...
    1103                     }
    1104                     break;
    1105                 default://coroutine.yield
    1106 ...

在openresty内部重新实现的coroutine.yield 和coroutine.resume 和 ngx.thread.spawn中 会对ctx->co\_op进行赋值

1064行，case NGX\_HTTP\_LUA\_USER\_CORO\_NOP表示不再有协程需要处理了，跳出这一次循环，等待下一次的读写时间，或者定时器到期

1071行，case NGX\_HTTP\_USER\_THREAD\_RESUME 对应 ngx.thread.spawn被调用的情况

1085行，case NGX\_HTTP\_LUA\_CORO\_RESUME 对应有lua代码调用coroutine.resume，把当前线程标记为NGX\_HTTP\_LUA\_USER\_CORO\_NOP

1106行，default 对应NGX\_HTTP\_LUA\_CODO\_YIELD，对应coroutine.yield被调用的情况

1113                 default:
    1114 ...
    1119                     ctx->co_op = NGX_HTTP_LUA_USER_CORO_NOP;
    1120
    1121                     if (ngx_http_lua_is_thread(ctx)) {
    1122 ...
    1132                         ngx_http_lua_probe_info("set co running");
    1133                         ctx->cur_co_ctx->co_status = NGX_HTTP_LUA_CO_RUNNING;
    1134
    1135                         if (ctx->posted_threads) {
    1136                             ngx_http_lua_post_thread(r, ctx, ctx->cur_co_ctx);
    1137                             ctx->cur_co_ctx = NULL;
    1138                             return NGX_AGAIN;
    1139                         }
    1140 ...
    1144                         nrets = 0;
    1145                         continue;
    1146                     }
    1147 ...
    1150                     nrets = lua_gettop(ctx->cur_co_ctx->co);
    1151                     next_coctx = ctx->cur_co_ctx->parent_co_ctx;
    1152                     next_co = next_coctx->co;
    1153 ...
    1158                     lua_pushboolean(next_co, 1);
    1159
    1160                     if (nrets) {
    1161                         dd("moving %d return values to next co", nrets);
    1162                         lua_xmove(ctx->cur_co_ctx->co, next_co, nrets);
    1163                     }
    1164                     nrets++;  /* add the true boolean value */
    1165                     ctx->cur_co_ctx = next_coctx;
    1166                     break;
    1167                 }

default 对应NGX\_HTTP\_LUA\_CODO\_YIELD,表示coroutine.yield被调用的情况

1121行，判断是不是主协程，或者是调用ngx.thread.spawn的协程

1135行，判断链表中有没有排队需要执行的协程，如果有的话，调用ngx\_http\_lua\_post\_thread将这个协程放到他们的后面，没有的话，直接让他自己恢复执行即可，回到 for 循环开头

1136-1167行，ngx.thread.spawn创建的子协程,需要将返回值放入父协程中

1150-1152行和1165行，将当前需要执行的协程，由子协程切换为父协程

1159行，放入布尔值true

1161行，将子协程的所有返回值通过lua\_xmove放入父协程中

1170行，由于多了一个布尔值true返回值个数+1

1166行，回到for循环开头，在父协程上执行lua\_resume

**lua\_resume返回0，表示当前协程执行完毕**

这里因为有ngx.thread API的存在，可能有多个协程在跑，需要判断父协程和所有的子协程的运行情况。

1172             case 0:
    1173 ...
    1183                 if (ngx_http_lua_is_entry_thread(ctx)) {
    1184 ...
    1187                     ngx_http_lua_del_thread(r, L, ctx, ctx->cur_co_ctx);
    1188                     if (ctx->uthreads) {
    1189                         ctx->cur_co_ctx = NULL;
    1190                         return NGX_AGAIN;
    1191                     }
    1192                     /* all user threads terminated already */
    1193                     goto done;
    1194                 }
    1195                 if (ctx->cur_co_ctx->is_uthread) {
    1196 ...
    1223                     ngx_http_lua_del_thread(r, L, ctx, ctx->cur_co_ctx);
    1224                     ctx->uthreads--;
    1225                     if (ctx->uthreads == 0) {
    1226                         if (ngx_http_lua_entry_thread_alive(ctx)) {
    1227                             ctx->cur_co_ctx = NULL;
    1228                             return NGX_AGAIN;
    1229                         }
    1230                         goto done;
    1231                     }
    1232                     /* some other user threads still running */
    1233                     ctx->cur_co_ctx = NULL;
    1234                     return NGX_AGAIN;
    1235                 }

1183行，判断是不是主协程

1187行，执行完毕的协程是主协程，从全局table中删除这个协程

1188-1193行，判断还在运行的子协程个数，如果非0 返回NGX\_AGAIN,否则goto done 进行一些数据发送的相关工作并返回NGX\_OK

1195-1233，判断执行完毕的是不是子协程

1223行，由于协程已经执行完毕，从全局table中删除这个协程，可以被lua GC掉

1223行，还在运行的子协程个数-1

1226行，判断主协程是否还需要运行，是的话，返回NGX\_AGAIN，否则goto done，进行一些数据发送的相关工作并返回NGX\_OK

1232-1234行，表示有子协程还在运行，返回NGX\_AGAIN

**\#\#总结**

1、在init\_by\_lua等阶段 ，openresty是在主协程中通过lua\_pcall直接执行lua代码，而在access\_by\_lua、content\_by\_lua等阶段中，openresty创建一个新的协程，通过lua\_resume执行lua代码

2、openresty将要延后执行的协程放入链表中，在\*\_run\_posted\_threads函数中通过调用ngx\_http\_lua\_run\_thread进行执行

本文参与[腾讯云自媒体分享计划][Link 1]，欢迎正在阅读的你也加入，一起分享。

发表于 2018-02-06

[https_cloud.tencent.com_developer_article_1037840]: https://cloud.tencent.com/developer/article/1037840?from=10680
[Link 1]: https://cloud.tencent.com/developer/support-plan