libuv学习笔记（10）

最新推荐文章于 2023-07-30 11:00:00 发布
最新推荐文章于 2023-07-30 11:00:00 发布
阅读量1.5k 收藏
点赞数
分类专栏： libuv学习笔记 文章标签： libuv uv-process
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/paohui0134/article/details/51671959
版权

libuv学习笔记（10）

uv_process_t数据结构与相关函数

数据结构

typedef struct uv_process_s uv_process_t;
struct uv_process_s {
  UV_HANDLE_FIELDS//uv_handle_t的成员，此处不再展开
  uv_exit_cb exit_cb;//回调函数
  int pid;//进程id
  //UV_PROCESS_PRIVATE_FIELDS宏展开：
  struct uv_process_exit_s {                                                 
    UV_REQ_FIELDS//uv_req_t的成员，此处不再展开，用来发送调用关闭回调的请求
  } exit_req;                                                                 
  BYTE* child_stdio_buffer;//要发送给子进程的文件描述符                                                   
  int exit_signal;//退出信号                                                            
  HANDLE wait_handle;//监控子进程是否关闭的句柄，不需要closehandle                                                         
  HANDLE process_handle;//进程句柄                                                      
  volatile char exit_cb_pending;//进程关闭监控回调是否调用的标记
};

进程配置结构体：

typedef struct uv_process_options_s {
  uv_exit_cb exit_cb; //进程退出后的回调
  const char* file;//进程路径  utf8编码

  //命令行参数utf8编码。 args[0]应该是进程路径。windows平台下调用CreateProcess函数，并将args参数
  //转换为字符串，这可能会导致一些奇怪的问题，参考windows_verbatim_arguments
  char** args;
  //设置子进程环境变量 utf8编码
  char** env;
  //工作目录 utf8编码
  const char* cwd;
  //控制uv_spawn函数的标记量
  unsigned int flags;
  //`stdio`成员指向一个uv_stdio_container_t数组，uv_stdio_container_t里面存放将会传递给子进
  //程的文件描述符。一般来说，stdio[0]指向stdin, fd 1是stdout, fd 2 是 stderr.
  //在windows平台下，只有当子进程使用MSVCRT运行时环境时才能支持超过2个的文件描述符
  int stdio_count;
  uv_stdio_container_t* stdio;
  //windows不支持
  uv_uid_t uid;
  uv_gid_t gid;
} uv_process_options_t;

相关函数

1.生成子进程。导出函数，在uv.h中声明，process.c中定义

初始化，内部函数，在uv_spawn中调用

static void uv_process_init(uv_loop_t* loop, uv_process_t* handle) {
  uv__handle_init(loop, (uv_handle_t*) handle, UV_PROCESS);
  handle->exit_cb = NULL;
  handle->pid = 0;
  handle->exit_signal = 0;
  handle->wait_handle = INVALID_HANDLE_VALUE;
  handle->process_handle = INVALID_HANDLE_VALUE;
  handle->child_stdio_buffer = NULL;
  handle->exit_cb_pending = 0;
  uv_req_init(loop, (uv_req_t*)&handle->exit_req);//初始化请求，类型为UV_PROCESS_EXIT
  handle->exit_req.type = UV_PROCESS_EXIT;
  handle->exit_req.data = handle;
}

生成子进程

int uv_spawn(uv_loop_t* loop,
             uv_process_t* process,
             const uv_process_options_t* options) 
{
  int i;
  int err = 0;
  WCHAR* path = NULL, *alloc_path = NULL;
  BOOL result;
  WCHAR* application_path = NULL, *application = NULL, *arguments = NULL,
         *env = NULL, *cwd = NULL;
  STARTUPINFOW startup;
  PROCESS_INFORMATION info;
  DWORD process_flags;
  uv_process_init(loop, process);//初始化uv_process_t
  process->exit_cb = options->exit_cb;//进程关闭时的回调函数
  if (options->flags & (UV_PROCESS_SETGID | UV_PROCESS_SETUID)) {
    return UV_ENOTSUP;//windows不支持
  }
  if (options->file == NULL || options->args == NULL) {
    return UV_EINVAL;//可执行文件路径或者命令行参数为空，直接返回错误
  }

  assert(options->file != NULL);
  assert(!(options->flags & ~(UV_PROCESS_DETACHED |
                              UV_PROCESS_SETGID |
                              UV_PROCESS_SETUID |
                              UV_PROCESS_WINDOWS_HIDE |
                              UV_PROCESS_WINDOWS_VERBATIM_ARGUMENTS)));
  //将utf8字符串转换为utf16
  err = uv_utf8_to_utf16_alloc(options->file, &application);
  if (err)
    goto done;
  //构建命令行参数，UV_PROCESS_WINDOWS_VERBATIM_ARGUMENTS表示命令行参数不要用“”
  err = make_program_args(
      options->args,
      options->flags & UV_PROCESS_WINDOWS_VERBATIM_ARGUMENTS,
      &arguments);
  if (err)
    goto done;
  //构建环境变量参数
  if (options->env) {
     err = make_program_env(options->env, &env);
     if (err)
       goto done;
  }
  //构建工作目录参数
  if (options->cwd) {
    /* Explicit cwd */
    err = uv_utf8_to_utf16_alloc(options->cwd, &cwd);
    if (err)
      goto done;

  } else {//没有工作目录，就用当前工作目录
    /* Inherit cwd */
    DWORD cwd_len, r;

    cwd_len = GetCurrentDirectoryW(0, NULL);
    if (!cwd_len) {
      err = GetLastError();
      goto done;
    }

    cwd = (WCHAR*) uv__malloc(cwd_len * sizeof(WCHAR));
    if (cwd == NULL) {
      err = ERROR_OUTOFMEMORY;
      goto done;
    }

    r = GetCurrentDirectoryW(cwd_len, cwd);
    if (r == 0 || r >= cwd_len) {
      err = GetLastError();
      goto done;
    }
  }

  //获取环境变量中的PATH
  path = find_path(env);
  if (path == NULL) {
    DWORD path_len, r;

    path_len = GetEnvironmentVariableW(L"PATH", NULL, 0);
    if (path_len == 0) {
      err = GetLastError();
      goto done;
    }

    alloc_path = (WCHAR*) uv__malloc(path_len * sizeof(WCHAR));
    if (alloc_path == NULL) {
      err = ERROR_OUTOFMEMORY;
      goto done;
    }
    path = alloc_path;

    r = GetEnvironmentVariableW(L"PATH", path, path_len);
    if (r == 0 || r >= path_len) {
      err = GetLastError();
      goto done;
    }
  }
  //通过options中的stdio数组构建process->child_stdio_buffer
  //child_stdio_buffer中至少有3个，最多255，如果option中少于3个，那么child_stdio_buffer中对应
  //的多余的文件描述符标记为UV_IGNORE（忽略）。根据options->stdio的类型，构建对应的传递给子进程的文
  //件描述符
  err = uv__stdio_create(loop, options, &process->child_stdio_buffer);
  if (err)
    goto done;
  //获取全路径（用户传入的可能是相对路径）
  application_path = search_path(application,
                                 cwd,
                                 path);
  if (application_path == NULL) {
    /* Not found. */
    err = ERROR_FILE_NOT_FOUND;
    goto done;
  }
  //构建startup（STARTUPINFOW）结构体
  startup.cb = sizeof(startup);
  startup.lpReserved = NULL;
  startup.lpDesktop = NULL;
  startup.lpTitle = NULL;
  startup.dwFlags = STARTF_USESTDHANDLES | STARTF_USESHOWWINDOW;

  startup.cbReserved2 = uv__stdio_size(process->child_stdio_buffer);
  startup.lpReserved2 = (BYTE*) process->child_stdio_buffer;
  //输入输出从定向（如果有的话）
  startup.hStdInput = uv__stdio_handle(process->child_stdio_buffer, 0);
  startup.hStdOutput = uv__stdio_handle(process->child_stdio_buffer, 1);
  startup.hStdError = uv__stdio_handle(process->child_stdio_buffer, 2);

  if (options->flags & UV_PROCESS_WINDOWS_HIDE) {
    /* Use SW_HIDE to avoid any potential process window. */
    startup.wShowWindow = SW_HIDE;
  } else {
    startup.wShowWindow = SW_SHOWDEFAULT;
  }

  process_flags = CREATE_UNICODE_ENVIRONMENT;

  if (options->flags & UV_PROCESS_DETACHED) {
    process_flags |= DETACHED_PROCESS | CREATE_NEW_PROCESS_GROUP;
  }
  //创建进程
  if (!CreateProcessW(application_path,
                     arguments,
                     NULL,
                     NULL,
                     1,
                     process_flags,
                     env,
                     cwd,
                     &startup,
                     &info)) {
    /* CreateProcessW failed. */
    err = GetLastError();
    goto done;
  }
  //获取进程句柄与进程id
  process->process_handle = info.hProcess;
  process->pid = info.dwProcessId;
  //如果子进程是非独立模式，将其分配给全局job对象，这样父进程关闭时也会关闭子进程
  if (!(options->flags & UV_PROCESS_DETACHED)) {
    //uv__init_global_job_handle函数只会调用一次，创建一个作业uv__init_global_job_handle
    uv_once(&uv_global_job_handle_init_guard_, uv__init_global_job_handle);
    //将子进程放入作业中
    if (!AssignProcessToJobObject(uv_global_job_handle_, info.hProcess)) {
      DWORD err = GetLastError();
      if (err != ERROR_ACCESS_DENIED)
        uv_fatal_error(err, "AssignProcessToJobObject");
    }
  }
  //设置所有的命名管道进程间通信的进程id
  for (i = 0; i < options->stdio_count; i++) {
    const uv_stdio_container_t* fdopt = &options->stdio[i];
    if (fdopt->flags & UV_CREATE_PIPE &&
        fdopt->data.stream->type == UV_NAMED_PIPE &&
        ((uv_pipe_t*) fdopt->data.stream)->ipc) {
      ((uv_pipe_t*) fdopt->data.stream)->pipe.conn.ipc_pid = info.dwProcessId;
    }
  }
  //开始对于进程句柄的监控，进程关闭后，系统会将其进程句柄设为有信号状态
  result = RegisterWaitForSingleObject(&process->wait_handle,
      process->process_handle, exit_wait_callback, (void*)process, INFINITE,
      WT_EXECUTEINWAITTHREAD | WT_EXECUTEONLYONCE);
  if (!result) {
    uv_fatal_error(GetLastError(), "RegisterWaitForSingleObject");
  }
  //关闭不再使用的进程句柄
  CloseHandle(info.hThread);
  assert(!err);
  //开始uv_process_t
  uv__handle_start(process);
  //清理资源
 done:
  uv__free(application);
  uv__free(application_path);
  uv__free(arguments);
  uv__free(cwd);
  uv__free(env);
  uv__free(alloc_path);
  //清理之前生成的传递给子进程的文件描述符
  if (process->child_stdio_buffer != NULL) {
    /* Clean up child stdio handles. */
    uv__stdio_destroy(process->child_stdio_buffer);
    process->child_stdio_buffer = NULL;
  }
  return uv_translate_sys_error(err);
}

监听到子线程关闭之后的回调函数exit_wait_callback，将会在windows的线程池中调用

static void CALLBACK exit_wait_callback(void* data, BOOLEAN didTimeout) 
{
  uv_process_t* process = (uv_process_t*) data;
  uv_loop_t* loop = process->loop;

  assert(didTimeout == FALSE);
  assert(process);
  assert(!process->exit_cb_pending);

  process->exit_cb_pending = 1;

  //向iocp发送信号
  POST_COMPLETION_FOR_REQ(loop, &process->exit_req);
}

uv_run中会在收到线程退出信息后，会调用uv_process_reqs处理请求，最终调用uv_process_proc_exit

void uv_process_proc_exit(uv_loop_t* loop, uv_process_t* handle) 
{
  int64_t exit_code;
  DWORD status;

  assert(handle->exit_cb_pending);
  handle->exit_cb_pending = 0;

  //如果handle是正在关闭状态，直接关闭handle。比如在监控关闭回调调用未完成时调用了uv_close关闭
  //handle
  /* callback now. */
  if (handle->flags & UV__HANDLE_CLOSING) {
    uv_want_endgame(loop, (uv_handle_t*) handle);
    return;
  }

  //去掉监视
  if (handle->wait_handle != INVALID_HANDLE_VALUE) {
    UnregisterWait(handle->wait_handle);
    handle->wait_handle = INVALID_HANDLE_VALUE;
  }
  //停止handle
  uv__handle_stop(handle);

  if (GetExitCodeProcess(handle->process_handle, &status)) {
    exit_code = status;
  } else {
    /* Unable to to obtain the exit code. This should never happen. */
    exit_code = uv_translate_sys_error(GetLastError());
  }
  //调用回调
  if (handle->exit_cb) {
    handle->exit_cb(handle, exit_code, handle->exit_signal);
  }
}

通过uv_close关闭uv_process_t，最终会调用uv_process_close

void uv_process_close(uv_loop_t* loop, uv_process_t* handle) 
{
  uv__handle_closing(handle);//状态变为UV_HANDLE_CLOSING

  if (handle->wait_handle != INVALID_HANDLE_VALUE) {
    //注销监视
    BOOL r = UnregisterWaitEx(handle->wait_handle, INVALID_HANDLE_VALUE);
    if (!r) {
      /* This should never happen, and if it happens, we can't recover... */
      uv_fatal_error(GetLastError(), "UnregisterWaitEx");
    }

    handle->wait_handle = INVALID_HANDLE_VALUE;
  }
  //监控进程关闭的回调函数exit_wait_callback还未调用，直接关闭handle，否则需要等到loop处理关闭回调
  //请求的时候再关闭handle
  if (!handle->exit_cb_pending) {
    uv_want_endgame(loop, (uv_handle_t*)handle);
  }
}

使用libuv创建子进程，可以设定输出、输入重定向，或使用命名管道来进行进程间通信，这部分内容与之后的uv_pipe_t以及uv_stream_t等内容相关。

paohui0134
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
libuv学习文档
03-14
这本'书'是一小部分关于使用libuv作为高性能事件I / O库的教程 Windows和Unix上的API相同。 它旨在涵盖libuv的主要领域，但不是讨论每个功能和数据的综合参考 结构体。可以查阅官方libuv文档以获取完整详细信息。 这...
learning-libuv:学习libuv
05-18
libuv学习笔记libuv介绍背景​是一个跨平台的异步IO库实现，刚开始是为Node.js而开发，Node.js完全构建于libuv之上。跨平台构建支持平台WindowsUnixAndroidOS X 注：ios需要自己移植。支持构建工具：autotoolsVisual...
libuv学习笔记（12）
paohui0134的博客
06-16 3831
libuv学习笔记（12） uv_tcp_t数据结构与相关函数(1)
libuv之介绍
JXES智能生态系统
05-16 9481
本人是在研究linux下socket TCP/IP通讯时，用到了一些linux下的API，比如socket, connect, bind,listen, accept等等，简单写个点对点的通讯，直接用这些API，再配合Linux下的事件处理机制，或多线程机制，应该都是可以实现的。这里我们就需要考虑的如下一些问题： 1.多个客户端并发处理时，怎么才能将服务端的负担降到最低 2.我的应用用到多事件
libuv源码解析之结构体全景图
标子 的专栏
01-05 243
libuv各结构体的关系和字段的意思全景图（基于linux版本）
libuv概览
baidu20008的专栏
10-15 1763
libuv 的API是C风格的，很容易读。你可能觉得uv.h中暴露了太多的数据结构了，不够简洁，我想是因为libuv涵盖的内容非常的广泛，从网络，pipe，文件，终端等等，包罗万象。而且uv.h也不是接口的全部，还有两个头文件，uv-unix.h和uv-win.h，里面定义了操作系统specific的数据结构。其实，libuv已经对接口的简化做了一些努力，比如说，通过uv_write一个函数，我们
Libuv库(探讨)---第六节:进程相关
knowledgebao的博客
08-31 1631
索引目录：https://blog.csdn.net/knowledgebao/article/details/84776754 libuv offers considerable child process management, abstracting the platform differences and allowing communication with the child pro...
libuv documentation.pdf
08-19
libuv 文档概述 libuv 是一个跨平台支持库，主要关注异步 I/O 操作。它最初是为 Node.js 开发的，但现在也被 Luvit、Julia、pyuv 等其他项目使用。 libuv 的主要特点是它提供了一个全功能的事件循环，支持 epoll、...
C语言libuv-1.42.0源码
最新发布
04-23
10. **API设计** - libuv的API设计简洁且强大，每个函数都有明确的功能，易于理解和使用。同时，libuv的API遵循了回调函数的模式，使得异步操作的结果能够在合适的时机被处理。 在实际项目中，`libuv-1.42.0`可以...
spawn:一个简单的“ uv_spawn”包装器API即可执行和管理子进程，并行异步PHP用于阻止IO
04-10
产生 一个简单的uv_spawn包装器API，用于执行和管理子进程（用于阻止I / O的并行/异步PHP）。 该软件包使用Node.js库的 （PHP扩展 ）的功能。 它的uv_spawn函数用于启动进程。 性能是一个更好的选择到了pcntl扩展，或使用proc_open 。 如果未安装libuv ，则此软件包将回退以使用[symfony / process]。 此程序包是我们的程序包的一部分，用于处理任何阻塞的I / O进程，而这些阻塞I / O进程不能被本地处理。 要了解更多关于libuv功能阅读在线教程。 安装 composer require symplely/spawn 如果可用，此软件包将使用libuv功能。 执行以下操作之一来安装。 对于像Debian这样的发行版，Ubuntu ... apt-get install libuv1-dev php-pear -y
glibc漏洞修复.rpm
02-25
新增了一个glibc-2.12-1.149.el6_6.5.i686.rpm包，其他的和之前的更新包相同，部分系统没有安装过这个包，直接批量更新可能回报错，说少个包。特此补上
Linux glibc 幽灵漏洞修复方案
02-06
Linux glibc 幽灵漏洞修复方案
swupjs:[已弃用]完整，灵活，易于使用的页面过渡库-swup扩展
05-02
swupjs 警告：不建议使用此存储库，而推荐使用 Swupjs是的延伸 ，其中修改用于使用JavaScript动画使用该模块。 Swupjs仅对swup进行了少许修改，其中swup的所有功能均保持不变，只有一个例外-时序和动画基于JavaScript，而不是CSS过渡。 有关swupjs的功能和思想的更多信息，请参阅文档。 安装 npm install swupjs 或包含dist文件夹中的文件 < script src =" ./dist/swupjs.js " > </ script > 这个怎么运作 Swupjs的启用方式与swup类似。 let options = { } const swupjs = new Swupjs ( options ) 动画选项 要将动画用于页面过渡，首先需要定义动画对象。 animations: { '*' : {
冷月手撕408之操作系统(5)-进程概述
学长冷月的博客
09-07 1733
操作系统的进程概述主要是介绍了进程的概念，进程的组成(进程实体)、进程的特征、进程的五状态模型、进程控制，其中重点掌握PCB、五状态模型及其状态转换。 主要的重点冷月做出了标识，知识点如下图（pdf版或xmind源文件请关注公众号：学长冷月，回复操作系统）。 冷月点睛 程序是静态的存储在计算机硬盘里面的计算机代码，而进程是程序在数据上的一次动态执行。 进程实体也叫进程映像，包括程序段、数据段、PCB。是进程的静态组成。 PCB，进程控制块，进程存在的唯一标识，常驻内存中。 进程最主要、最基本的特征是动态性
libuv库学习笔记-processes
DeepLearning_的博客
07-30 259
在函数。
通过源码分析nodejs的进程架构
标子 的专栏
03-26 331
我们知道nodejs是单进程（单线程）的，但是nodejs也为用户实现了多进程的能力，下面我们看一下nodejs里多进程的架构是怎么样的。     nodejs提供同步和异步创建进程的方式。我们首先看一下异步的方式，nodejs创建进程的方式由很多种。但是归根到底是通过spawn函数。所以我们从这个函数开始，看一下整个流程。 var spawn = expo...
libuv源码分析(2)
weixin_30632899的博客
07-19 139
这一篇来分析libuv的四个特殊的持续请求(uv_handle_t族),uv_idle_t,uv_check_t,uv_prepare_t,uv_async_t。它们直接以强类型保存在uv_loop_t中，而不像其它的持续请求保存在handle_queue中，也是最简单的持续请求。 在实现中，libuv利用C的内存布局模拟了面向对象的继承关系，uv_handle_t是基类，其所有子类都...
IO_FILE Exploitation
azraelxuemo的博客
04-11 1229
文章目录简介IO_FILE结构_IO_FILEIO_jump_t图示利用原理exit函数vtable checkexit函数的广泛性exit函数exit调用__run_exit_handlersRUN_HOOK__run_exit_handlers调用_IO_cleanup_IO_cleanup调用_IO_unbuffer_all例题hctf2018_the_end题目分析伪造vtable修改vtable地址为我们伪造的区域attackdlfini 简介 IO_FILE Exploitation也是ctf里
libuv API详解与实战示例
10. **信号处理**：libuv提供了处理操作系统信号的接口，如SIGINT、SIGTERM等，帮助应用程序优雅地响应退出请求。 11. **高分辨率时钟**：libuv提供了获取高精度时间的函数，对于需要精确计时的场景非常有用。 12....

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值