OpenSSL异步模式流程梳理

源码

来源于 OpenSSL Master Commit ID d550d2aae531c6fa2e10b1a30d2acdf373663889。
总览

焦点入口函数为 ssl_start_async_job，以 SSL_do_handshake 为入口举例分析，同时通过标注步骤【1~N】，来明白阅读的次序。

• 步骤【1】到步骤【18】为一个阶段
  
• 步骤【19】到步骤【23】为一个阶段
  
• 步骤【24】到步骤【34】之后为一个阶段
  为了减少阅读的干扰和提升阅读服从，不相干的代码省略，同时部分代码会在表明中展示
  

流程

SSL_do_handshake

1. int SSL_do_handshake(SSL *s)
2. {
3.     SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s);
4.     /* 步骤【24】
5.      * 再次进入
6.      */
8.     if ((sc->mode & SSL_MODE_ASYNC) && ASYNC_get_current_job() == NULL) {
9.         /* 步骤【1】
10.          * 检测是否开启了异步模式，并且没有正在运行的 job
11.          * 通过 ASYNC_get_current_job 可获取当前正在运行的 job
12.          * ASYNC_get_current_job 中通过 async_get_ctx 获取线程变量 ctx
13.          * ctx 中的字段 currjob 即为返回值
14.          */
15.         struct ssl_async_args args;
16.         memset(&args, 0, sizeof(args));
17.         args.s = s;
19.         /* 步骤【2】
20.          * 通过 ssl_start_async_job 启动一个异步 job
21.          * 关注一下 args 中赋值的唯一一个参数 s
22.          *
23.          * 步骤【25】
24.          * 通过 ssl_start_async_job 启动一个异步 job
25.          */
26.         ret = ssl_start_async_job(s, &args, ssl_do_handshake_intern);
28.         /* 步骤【18】
29.          * 至此通过 ssl_start_async_job 得到了与 else 中一样的返回值
30.          * 因为提到过 ssl_start_async_job 中最终也是执行的 sc->handshake_func，且执行完成
31.          *
32.          * 步骤【23】
33.          * 返回值为 -1，但此时 job，并没有完成
34.          * 函数的调用者需要有能力处理这种情况，并且在适当实际继续执行 job
35.          * 这就需要调用者去适配 OpenSSL 异步模式
36.          */
37.     } else {
38.         ret = sc->handshake_func(s);
39.     }
40. }

复制代码

ssl_start_async_job

1. static int ssl_start_async_job(SSL *s, struct ssl_async_args *args,
2.                                int (*func) (void *))
3. {
4.     /* 步骤【3】
5.      * 启动一个 job
6.      * sc->job 在首次调用时为 NULL
7.      * args.s 为 s
8.      * func 为 ssl_do_handshake_intern
9.      *
10.      * 步骤【26】
11.      */
12.     switch (ASYNC_start_job(&sc->job, sc->waitctx, &ret, func, args,
13.                             sizeof(struct ssl_async_args))) {
14.     /* 步骤【16】
15.      * 返回值为 ASYNC_FINISH
16.      *
17.      * 步骤【21】
18.      * 返回值为 ASYNC_PAUSE
19.      */
20.     case ASYNC_ERR:
21.         sc->rwstate = SSL_NOTHING;
22.         ERR_raise(ERR_LIB_SSL, SSL_R_FAILED_TO_INIT_ASYNC);
23.         return -1;
24.     case ASYNC_PAUSE:
25.         /* 步骤【22】
26.          */
27.         sc->rwstate = SSL_ASYNC_PAUSED;
28.         return -1;
29.     case ASYNC_NO_JOBS:
30.         sc->rwstate = SSL_ASYNC_NO_JOBS;
31.         return -1;
32.     case ASYNC_FINISH:
33.         /* 步骤【17】
34.          */
35.         sc->job = NULL;
36.         return ret;
37.     default:
38.         sc->rwstate = SSL_NOTHING;
39.         ERR_raise(ERR_LIB_SSL, ERR_R_INTERNAL_ERROR);
40.         /* Shouldn't happen */
41.         return -1;
42.     }
43. }

复制代码

ASYNC_start_job

1. int ASYNC_start_job(ASYNC_JOB **job, ASYNC_WAIT_CTX *wctx, int *ret,
2.                     int (*func)(void *), void *args, size_t size)
3. {
4.     /* 步骤【4】
5.      * ctx 为线程变量，对线程而言全局可见，当前为第一次
6.      * 会创建 ctx，后续的 job 都能通过 async_get_ctx() 获取
7.      *
8.      * 步骤【27】
9.      * ctx 为线程变量，之前已经创建过，可以直接获取
10.      */
11.     ctx = async_get_ctx();
12.     if (ctx == NULL)
13.         ctx = async_ctx_new();
14.     if (ctx == NULL)
15.         return ASYNC_ERR;
17.     /* 步骤【5】
18.      * 首次调用 *job 应为 NULL
19.      *
20.      * 步骤【28】
21.      * job 有值
22.      */
23.     if (*job != NULL)
24.         ctx->currjob = *job;
26.     for (;;) {
27.         /* 步骤【6】
28.          * ctx 刚创建，ctx->currjob 为 NULL，跳过
29.          *
30.          * 步骤【14】
31.          * 此时 ctx->currjob 有值，且 ctx->currjob->status 为 ASYNC_JOB_STOPPING
32.          *
33.          * 步骤【29】
34.          * 此时 ctx->currjob 有值，且 ctx->currjob->status 为 ASYNC_JOB_PAUSED
35.          */
36.         if (ctx->currjob != NULL) {
37.             if (ctx->currjob->status == ASYNC_JOB_STOPPING) {
38.                 /* 步骤【15】
39.                  * job 完成，返回 ASYNC_FINISH
40.                  * 此时，可以释放针对该 job 申请的各种资源
41.                  * 重置线程变量 ctx 上有关的值
42.                  */
43.                 *ret = ctx->currjob->ret;
44.                 ctx->currjob->waitctx = NULL;
45.                 async_release_job(ctx->currjob);
46.                 ctx->currjob = NULL;
47.                 *job = NULL;
48.                 return ASYNC_FINISH;
49.             }
51.             if (ctx->currjob->status == ASYNC_JOB_PAUSING) {
52.                 /* 步骤【20】
53.                  * job 暂停，返回 ASYNC_PAUSE
54.                  * 此时，不要释放针对该 job 申请的各种资源
55.                  * 仅仅将 currjob 设置为 NULL
56.                  */
57.                 *job = ctx->currjob;
58.                 ctx->currjob->status = ASYNC_JOB_PAUSED;
59.                 ctx->currjob = NULL;
60.                 return ASYNC_PAUSE;
61.             }
63.             if (ctx->currjob->status == ASYNC_JOB_PAUSED) {
64.                 /* 步骤【30】
65.                  * 将 ctx->currjob->fibrectx->fibre 作为目标上下文切换
66.                  * ctx->currjob->fibrectx->fibre 中保存的即为
67.                  * ASYNC_pause_job 中切换上下文时保存的信息
68.                  * 当前上下午的信息保存在 ctx->dispatcher->fibre 中
69.                  */
70.                 if (!async_fibre_swapcontext(&ctx->dispatcher,
71.                         &ctx->currjob->fibrectx, 1)) {
72.                     ctx->currjob->libctx = OSSL_LIB_CTX_set0_default(libctx);
73.                     ERR_raise(ERR_LIB_ASYNC, ASYNC_R_FAILED_TO_SWAP_CONTEXT);
74.                     goto err;
75.                 }
77.                 /* 步骤【34】
78.                  * 上下文切换回此，由于 job 已经完成，status 为 ASYNC_JOB_STOPPING
79.                  * 接下来的流程与步骤【15】相同
80.                  */
81.                 continue;
82.             }
83.         }
85.         /* 步骤【7】
86.          * 由于 job 尚未创建，通过 async_get_pool_job 从池子中获取一个 job
87.          * 由于 job 中有参数需要关注，所以还要看一下 async_get_pool_job 的实现
88.          * 具体的 async_get_pool_job 中调用 async_job_new 创建 job
89.          * 然后调用 async_fibre_makecontext 初始化 job->fibrectx
90.          * 使用 makecontext(&fibre->fibre, async_start_func, 0)，其中的 fibre 即 job->fibrectx
91.          * makecontext 是 libc 提供的库，与之对应的是 swapcontext
92.          * makecontext 用于组装上下文信息，swapcontext 用于切换上下文信息
93.          * 后续有关 async_fibre_makecontext 和 async_fibre_swapcontext 其实就是
94.          * makecontext 与 swapcontext
95.          * 当通过 swapcontext 切换上下文，切换的目标为 job->fibrectx->fibre，就会调用 async_start_func
96.          */
97.         if ((ctx->currjob = async_get_pool_job()) == NULL)
98.             return ASYNC_NO_JOBS;
100.         /* 步骤【8】
101.          * 将 args，func（ssl_do_handshake_intern）等参数绑定至 ctx->currjob
102.          */
103.         if (args != NULL) {
104.             ctx->currjob->funcargs = OPENSSL_malloc(size);
105.             if (ctx->currjob->funcargs == NULL) {
106.                 async_release_job(ctx->currjob);
107.                 ctx->currjob = NULL;
108.                 return ASYNC_ERR;
109.             }
110.             memcpy(ctx->currjob->funcargs, args, size);
111.         } else {
112.             ctx->currjob->funcargs = NULL;
113.         }
114.         ctx->currjob->func = func;
115.         ctx->currjob->waitctx = wctx;
117.         /* 步骤【9】
118.          * 至此，job 初始化完成
119.          * 其中有几个关键参数，再总结一下，即
120.          * func 为 ssl_do_handshake_intern
121.          * args 中的 args.s 为 ssl_start_async_job 传入的 s
122.          * 该 job 也同时被绑定到了线程变量 ctx 的 currjob 上
123.          * job->fibrectx->fibre 与 async_start_func 绑定
124.          */
126.         /* 步骤【10】
127.          * 这是关键，用于做上下文切换，即上文提到过的
128.          * swapcontext(&o->fibre, &n->fibre)
129.          * 第一个参数中的 o 与第二个参数中的 n，分别对应 &ctx->dispatcher 和 &ctx->currjob->fibrectx
130.          * 第二个参数是目标，而这个目标就是上文反复提到的 job->fibrectx->fibre，因此会调用 async_start_func
131.          * 第一个参数用来存储当前状态，即会记录此时的上下文信息
132.          * 当下一次将 ctx->dispatcher 作为 swapcontext 的第二个参数时，就能恢复到此处继续执行
133.          */
134.         if (!async_fibre_swapcontext(&ctx->dispatcher,
135.                 &ctx->currjob->fibrectx, 1)) {
136.             ERR_raise(ERR_LIB_ASYNC, ASYNC_R_FAILED_TO_SWAP_CONTEXT);
137.             goto err;
138.         }
140.         /* 步骤【13】
141.          * 在 async_start_func 中完成 job->func 后执行 swapcontext 切换回此
142.          * 此时的 job->status 值为 ASYNC_JOB_STOPPING
143.          *
144.          * 步骤【19】
145.          * 在 ASYNC_pause_job 中，执行 swapcontext 切换回此
146.          * 此时的 job->status 值为 ASYNC_JOB_PAUSING
147.          */
148.     }
149. }

复制代码

async_start_func

1. void async_start_func(void)
2. {
3.     async_ctx *ctx = async_get_ctx();
5.     while (1) {
6.         /* 步骤【11】
7.          * 此处所有参数在前文都重点提到过
8.          * func 为 ssl_do_handshake_intern，参数 args，查看 ssl_do_handshake_intern
9.          * 实际上，就是调用的 sc->handshake_func
10.          * 这等同于步骤【1】中未开启异步模式的情况，区别就是现在是启动了一个 job 执行
11.          */
12.         job = ctx->currjob;
13.         job->ret = job->func(job->funcargs);
15.         /* 步骤【12】
16.          * job->func 执行完成，即 job 结束
17.          * 进行上下文切换，将 ctx->dispatcher 作为 swapcontext 的第二个参数
18.          * 回头看看，就知道切换到哪里了，当前现场保存在 job->fibrectx->fibre 中
19.          *
20.          * 步骤【33】
21.          * 暂停的 job 执行完成，上下文切换到目标 job->fibrectx->fibre
22.          */
23.         job->status = ASYNC_JOB_STOPPING;
24.         if (!async_fibre_swapcontext(&job->fibrectx,
25.                                      &ctx->dispatcher, 1)) {
26.             ERR_raise(ERR_LIB_ASYNC, ASYNC_R_FAILED_TO_SWAP_CONTEXT);
27.         }
28.     }
29. }

复制代码

停息

读到此处，不知是否会有这样的疑问？OpenSSL 异步模式，异步体现在哪里？上述步骤中，不就是通过一个新的上下文去实行了 sc->handshake_func 吗？这与步骤【1】的 else 中，直接实行 sc->handshake_func 有什么区别吗？如果你产生了这样的疑问，那就证明上面的步骤你应该是理解了。由于如果按照步骤这样一路看下来，确实不是异步模式，而是同步模式。
这是由于另有一个重要的机制没有介绍，那就是停息，这个机制允许上下文实行到某个地方，切换出去，做别的事情，然后再切换返来必须实行。而这个机制起作用的地方出现在步骤【11】到步骤【12】之间，实行 job->func 中。
思量一种情况，job->func 中，必要进行签名验签，加密解密，而这些算法是卸载到硬件的，调用算法必要等待硬件返回，而在这一段时间中，只能壅闭，导致 CPU 利用率低，例如如下代码。

1. void do_sign()
2. {
3.     // 获得一个硬件签名请求结构体并初始化
4.     struct req *r = sign_req_alloc();
5.     sign_req_init(r);
7.     // 利用硬件 API 发起签名请求
8.     // sign 中仅仅传递请求，就返回了，剩下就交给硬件
9.     sign(r);
11.     // 当硬件完成任务，会将 r->done 变为 true
12.     // 此处阻塞，不断的轮询 r->done 是否变为 true 来检测任务是否完成
13.     while (1) {
14.         if (r->done) {
15.             break;
16.         }
17.         usleep(0);
18.     }
20.     // 完成签名，退出
21.     return;
22. }

复制代码

可以看出，如果硬件没有完成使命，就会一直实行 while(1)，无法退出，导致无法处置惩罚其他使命。如果硬件性能很高，壅闭时间很短，可能影响会比力小，但是，如果硬件性能较差，壅闭时间长，就会导致 CPU 利用率很低。此时就可以使用 OpenSSL 异步模式中提供的 ASYNC_pause_job，如下代码。

1. void do_sign()
2. {
3.     // 获得一个硬件签名请求结构体并初始化
4.     struct req *r = sign_req_alloc();
5.     sign_req_init(r);
7.     // 利用硬件 API 发起签名请求
8.     // sign 中仅仅传递请求，就返回了，剩下就交给硬件
9.     sign(r);
11.     ASYNC_pause_job();
13.     /* 步骤【32】
14.      * do_sign 完成退出，会一直退到 async_start_func
15.      */
17.     // 完成签名，退出
18.     return;
19. }

复制代码

仅仅将必要壅闭等待的代码，更换为 ASYNC_pause_job 即可。
ASYNC_pause_job

1. int ASYNC_pause_job(void)
2. {
3.     job = ctx->currjob;
4.     job->status = ASYNC_JOB_PAUSING;
6.     /* 上下文切换，会切换到步骤【13】的地方继续执行
7.      * 需要注意的是，job 的状态设置成了 ASYNC_JOB_PAUSING
8.      * 并且将当前的上下文保存在 job->fibrectx->fibre 中
9.      * 紧接着步骤【19】
10.      */
11.     if (!async_fibre_swapcontext(&job->fibrectx,
12.                                  &ctx->dispatcher, 1)) {
13.         ERR_raise(ERR_LIB_ASYNC, ASYNC_R_FAILED_TO_SWAP_CONTEXT);
14.         return 0;
15.     }
17.     /* 步骤【31】
18.      * 上下文切换之后，继续执行，就回到了 do_sign 中
19.      */
20. }

复制代码

恢复

前文提到过，调用者必要有本领处置惩罚 SSL_do_handshake 返回值 -1，但 job 还存在的情况，这意味着 SSL_do_handshake 中通过 ASYNC_pause_job 停息的 job。
而调用者必要在一个合适的机遇，去继续运行该 job，怎样确定什么时候是合适的机遇，这是调用者必要思量的题目，此处仅介绍怎样恢复 job 的实行，很简单，再次调用 SSL_do_handshake 即可。
回到流程中，此时从步骤【24】开始。

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。