uloop_process

  • uloop_process主要数据结构
  • struct list_head processes
  • struct uloop_process
  • uloop_process_handler
  • uloop_process主要函数
  • uloop_handle_processes
  • uloop_process原理
  • uloop_process使用示例



uloop_process 是 Libubox 提供的一个进程管理工具,它并不会帮你创建进程，它主要用来等待子进程工作的结束，然后调用自定义的回调函数，所以一般需要配合

fork一起使用。

uloop_process主要数据结构

struct list_head processes

static struct list_head processes = LIST_HEAD_INIT(processes);

processes是一个全局链表，用于管理多个struct uloop_process.

struct uloop_process

struct uloop_process
{
	struct list_head list;
	bool pending;

	uloop_process_handler cb;
	pid_t pid;
};

struct uloop_process用来描述一个子进程，其中：

  • list 用于将struct uloop_process结构加入全局processes链表
  • pending标志此进程是否需要挂起(初始化时此参数务必置0)
  • cb是此进程运行结束后的回调函数
  • pid是进程ID(通常=fork()的返回值)

uloop_process_handler

typedef void (*uloop_process_handler)(struct uloop_process *c, int ret);

uloop_process_handler是子进程退出后会触发调用此回调函数(不是子进程自己调用，是运行uloop_run的进程会去调用)，其中子进程的一些退出状态码可以通过参数ret获取。
如果子进程使用exit(150);函数退出，那这里的ret就是150.
更多有关进程状态码的信息参考这位大佬的文章：wait/waitpid 的 status 参数

uloop_process主要函数

int uloop_process_add(struct uloop_process *p);
int uloop_process_delete(struct uloop_process *p);
  • uloop_process_add()函数是向全局链表中新增一个uloop_process
  • uloop_process_delete()函数是从全局链表中删除指定的uloop_process

uloop_handle_processes

static void uloop_handle_processes(void)

uloop_handle_processes()函数只会在uloop_run中被调用，用户不会主动调用此函数，它的作用是等待uloop_process ->pid对应的子进程运行结束，然后调用uloop_process ->cb函数。

uloop_process原理

uloop_process uloop_process_add_子进程

在uloop_init()中会重定向SIGCHLD信号处理函数为uloop_sigchld(),在这个函数中会设置do_sigchld=1。
当子进程主动退出或者被Kill后，就会向父进程发送SIGCHLD信号
在uloop_run()中会根据do_sigchld决定是否要处理子进程，如果需要处理，首先会调用uloop_process_delete从全局链表中删除子进程，然后调用struct uloop_process->cb函数。

uloop_process使用示例

示例中，父进程fork出一个子进程，然后让子进程执行test程序,随后将子进程添加到uloop进程管理队列，在子进程结束后，父进程会调用uloop_process->cb函数。

父进程源码：

#include <unistd.h>
#include <signal.h>
#include "libubus.h"


void u_process_cb(struct uloop_process *c, int ret)
{
	printf("[%s]currnt pid=%d\n",__FUNCTION__,getpid());
	printf("[%s]child process exec end,ret=%d\n",__FUNCTION__,ret);
}

int main(int argc, char **argv)
{
	static char *arg[]={"./test",NULL};
	struct uloop_process u;
	memset((void *)&u,0,sizeof(u));
	uloop_init();

	u.cb = u_process_cb;
	u.pid = fork();

	if(u.pid == 0)//child process
	{
		execvp(arg[0],arg);
	}

	if(uloop_process_add(&u) == 0)
	{
		printf("[father] father pid=%d child pid=%d\n",getpid(),u.pid);
		printf("[father] add pid(%d) to uloop_process success!\n",u.pid);
	}
	else
	{
		printf("[father] add pid(%d) to uloop_process failed!\n",u.pid);
	}

	uloop_run();
	uloop_done();

	return 0;
}

子进程源码如下：

#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>

int main(int argc, char **argv)
{
	printf("[child]Enter\n");
	sleep(2);
	printf("[child]Exit\n");
	return 0;
}

执行结果如下：

# ./uloop_process
[father] father pid=25305 child pid=25306
[father] add pid(25306) to uloop_process success!

[child]Enter # 子进程开始运行
[child]Exit  # 子进程退出

[u_process_cb]currnt pid=25305 # 父进程调用cb
[u_process_cb]child process exec end,ret=0