libuv学习笔记（9）

libuv学习笔记（9）

uv_signal_t数据结构与相关函数

uv_signal_t数据结构

typedef struct uv_signal_s uv_signal_t;
struct uv_signal_s {
UV_HANDLE_FIELDS//uv_handle_t的成员，此处不再展开
uv_signal_cb signal_cb;//回调函数
int signum;//信号
//UV_SIGNAL_PRIVATE_FIELDS宏展开：
RB_ENTRY(uv_signal_s) tree_entry;//红黑树节点
struct uv_req_s signal_req;//请求
unsigned long pending_signum;
};

相关函数

1.初始化，导出函数，在uv.h中声明，signal.c中定义

int uv_signal_init(uv_loop_t* loop, uv_signal_t* handle)
{
uv_req_t* req;
//初始化handle，添加到loop的handle列表，改变状态为引用状态
uv__handle_init(loop, (uv_handle_t*) handle, UV_SIGNAL);
handle->pending_signum = 0;
handle->signum = 0;
handle->signal_cb = NULL;

req = &handle->signal_req;

uv_req_init(loop, req);//初始化请求
req->type = UV_SIGNAL_REQ;//设置请求类型
req->data = handle;

return 0;
}

2.开始。导出函数，在uv.h中声明，signal.c中定义

int uv_signal_start(uv_signal_t* handle, uv_signal_cb signal_cb, int signum) {
int err;

//将信号值设为0，直接返回错误
//如果signum是无效值，那么uv__signal_register会检测出来
if (signum == 0) {
return UV_EINVAL;
}

//如果已经监控了这个信号，不会进入注销与注册流程。
if (signum == handle->signum) {
handle->signal_cb = signal_cb;
return 0;
}

//如果已经开始监控了，先停止
if (handle->signum != 0) {
int r = uv_signal_stop(handle);
/* uv_signal_stop is infallible. */
assert(r == 0);
}
//进入临界区
EnterCriticalSection(&uv__signal_lock);//此临界区是全局的

err = uv__signal_register(signum);//注册信号
if (err) {
/* Uh-oh, didn't work. */
LeaveCriticalSection(&uv__signal_lock);
return uv_translate_sys_error(err);
}

handle->signum = signum;
//将信号插入红黑树，key的比较函数为uv__signal_compare
RB_INSERT(uv_signal_tree_s, &uv__signal_tree, handle);

LeaveCriticalSection(&uv__signal_lock);

handle->signal_cb = signal_cb;
uv__handle_start(handle);//状态变为UV__HANDLE_ACTIVE,loop活动handle计数加一

return 0;
}

uv__signal_register

static int uv__signal_register(int signum)
{
switch (signum) {
//控制台相关的信号，通过安装控制台钩子来实现
case SIGINT:
case SIGBREAK:
case SIGHUP:
return uv__signal_register_control_handler();

case SIGWINCH:
/* SIGWINCH is generated in tty.c. No need to register anything. */
return 0;

case SIGILL:
case SIGABRT_COMPAT:
case SIGFPE:
case SIGSEGV:
case SIGTERM:
case SIGABRT:
/* Signal is never raised. */
return 0;

default:
/* Invalid signal. */
return ERROR_INVALID_PARAMETER;
}
}

uv__signal_register_control_handler()，安装控制台事件钩子处理控制台事件

static int uv__signal_register_control_handler() {
//调用本函数时，uv__signal_lock必须锁定

//如果已经添加了钩子，那么只用递增引用计数
if (uv__signal_control_handler_refs > 0) {
uv__signal_control_handler_refs++;
return 0;
}
//安装控制台事件钩子处理控制台程序事件
//回调函数会通过uv__signal_dispatch分发处理信号
if (!SetConsoleCtrlHandler(uv__signal_control_handler, TRUE))
return GetLastError();
uv__signal_control_handler_refs++;
return 0;
}

uv__signal_dispatch分发处理信号

int uv__signal_dispatch(int signum)
{
uv_signal_t lookup;
uv_signal_t* handle;
int dispatched = 0;
EnterCriticalSection(&uv__signal_lock);
lookup.signum = signum;
lookup.loop = NULL;
//遍历信号红黑树处理
//先找到第一个，然后依次比较下一个，直到信号值不相等
for (handle = RB_NFIND(uv_signal_tree_s, &uv__signal_tree, &lookup);
handle != NULL && handle->signum == signum;
handle = RB_NEXT(uv_signal_tree_s, &uv__signal_tree, handle)) {
unsigned long previous = InterlockedExchange(
(volatile LONG*) &handle->pending_signum, signum);
//没有正在处理的信号，向iocp端口发送事件通知，以便uv_run捕获处理,也就是说，有可能收到了多次信号，
//但是可能只处理了一次
if (!previous) {
POST_COMPLETION_FOR_REQ(handle->loop, &handle->signal_req);
}
dispatched = 1;
}
LeaveCriticalSection(&uv__signal_lock);
return dispatched;
}

在uv_run的io轮询中会获取uv__signal_dispatch发送的通知，并通过lpOverlapped获取对应的uv_req_t请求，接着在下一个迭代中通过uv_process_reqs处理这个请求

对于uv_signal_req类型的请求，最终会调用uv_process_signal_req

void uv_process_signal_req(uv_loop_t* loop, uv_signal_t* handle,
uv_req_t* req)
{
long dispatched_signum;

assert(handle->type == UV_SIGNAL);
assert(req->type == UV_SIGNAL_REQ);
//将uv_signal_t的等待处理的信号设为0
dispatched_signum = InterlockedExchange(
(volatile LONG*) &handle->pending_signum, 0);
assert(dispatched_signum != 0);

//信号相同，调用回调函数
if (dispatched_signum == handle->signum)
handle->signal_cb(handle, dispatched_signum);
//如果正在关闭，就添加到loop的关闭列表，比如在收到了信号但是还未处理的情况下调用了uv_close
if (handle->flags & UV__HANDLE_CLOSING) {
/* When it is closing, it must be stopped at this point. */
assert(handle->signum == 0);
uv_want_endgame(loop, (uv_handle_t*) handle);
}
}

3.停止监控。导出函数，在uv.h中声明，signal.c中定义

int uv_signal_stop(uv_signal_t* handle)
{
uv_signal_t* removed_handle;

//如果没有开始监控，直接返回
if (handle->signum == 0)
return 0;
//进入临界区
EnterCriticalSection(&uv__signal_lock);
//注销监控，递减引用计数，如果为0，卸载控制台程序钩子
uv__signal_unregister(handle->signum);
//从红黑树去掉
removed_handle = RB_REMOVE(uv_signal_tree_s, &uv__signal_tree, handle);
assert(removed_handle == handle);

LeaveCriticalSection(&uv__signal_lock);

handle->signum = 0;
//
uv__handle_stop(handle);

return 0;
}

通过uv_close关闭

最终会调用

void uv_signal_close(uv_loop_t* loop, uv_signal_t* handle)
{
uv_signal_stop(handle);//先停止
uv__handle_closing(handle);//handle状态变为UV_HANDLE_CLOSING

if (handle->pending_signum == 0) {
//如果没有等待处理的信号了，那么直接添加到loop的关闭handle队列，否则就需要在处理信号时添加到关闭队列
//了，参考uv_process_signal_req
uv_want_endgame(loop, (uv_handle_t*) handle);
}
}