自学教程：C++ swError函数代码示例

int swReactorPoll_create(swReactor *reactor, int max_fd_num){	//create reactor object	swReactorPoll *object = sw_malloc(sizeof(swReactorPoll));	if (object == NULL)	{		swError("malloc[0] failed");		return SW_ERR;	}	bzero(object, sizeof(swReactorPoll));	object->fds = sw_calloc(max_fd_num, sizeof(swPollFdInfo));	if (object->fds == NULL)	{		swError("malloc[1] failed");		return SW_ERR;	}	object->events = sw_calloc(max_fd_num, sizeof(struct pollfd));	if (object->events == NULL)	{		swError("malloc[2] failed");		return SW_ERR;	}	object->max_fd_num = max_fd_num;	bzero(reactor->handle, sizeof(reactor->handle));	reactor->object = object;	//binding method	reactor->add = swReactorPoll_add;	reactor->del = swReactorPoll_del;	reactor->set = swReactorPoll_set;	reactor->wait = swReactorPoll_wait;	reactor->free = swReactorPoll_free;	reactor->setHandle = swReactor_setHandle;	return SW_OK;}

/** * worker main loop */int swWorker_loop(swFactory *factory, int worker_id){    swServer *serv = factory->ptr;#ifndef SW_WORKER_USE_SIGNALFD    SwooleG.use_signalfd = 0;#endif    //worker_id    SwooleWG.id = worker_id;    SwooleWG.request_count = 0;    SwooleG.pid = getpid();    //signal init    swWorker_signal_init();    swWorker *worker = swServer_get_worker(serv, worker_id);    swServer_worker_init(serv, worker);    SwooleG.main_reactor = sw_malloc(sizeof(swReactor));    if (SwooleG.main_reactor == NULL)    {        swError("[Worker] malloc for reactor failed.");        return SW_ERR;    }    if (swReactor_create(SwooleG.main_reactor, SW_REACTOR_MAXEVENTS) < 0)    {        swError("[Worker] create worker_reactor failed.");        return SW_ERR;    }        serv->workers[worker_id].status = SW_WORKER_IDLE;    int pipe_worker = serv->workers[worker_id].pipe_worker;    swSetNonBlock(pipe_worker);    SwooleG.main_reactor->ptr = serv;    //这里的add函数是epoll的add函数    SwooleG.main_reactor->add(SwooleG.main_reactor, pipe_worker, SW_FD_PIPE | SW_EVENT_READ);    SwooleG.main_reactor->setHandle(SwooleG.main_reactor, SW_FD_PIPE, swWorker_onPipeReceive);    SwooleG.main_reactor->setHandle(SwooleG.main_reactor, SW_FD_PIPE | SW_FD_WRITE, swReactor_onWrite);    swWorker_onStart(serv);#ifdef HAVE_SIGNALFD    if (SwooleG.use_signalfd)    {        swSignalfd_setup(SwooleG.main_reactor);    }#endif    //main loop    SwooleG.main_reactor->wait(SwooleG.main_reactor, NULL);    //clear pipe buffer    swWorker_clean();    //worker shutdown    swWorker_onStop(serv);    return SW_OK;}

void swoole_init(void){    struct rlimit rlmt;    if (SwooleG.running == 0)    {        bzero(&SwooleG, sizeof(SwooleG));        bzero(sw_error, SW_ERROR_MSG_SIZE);        //初始化全局变量        SwooleG.running = 1;        sw_errno = 0;        SwooleG.cpu_num = sysconf(_SC_NPROCESSORS_ONLN);        SwooleG.pagesize = getpagesize();        if (getrlimit(RLIMIT_NOFILE, &rlmt) < 0)        {            swWarn("getrlimit() failed. Error: %s[%d]", strerror(errno), errno);        }        else        {            SwooleG.max_sockets = (uint32_t) rlmt.rlim_cur;        }        //random seed        srandom(time(NULL));        //init global lock        swMutex_create(&SwooleG.lock, 0);        //init signalfd#ifdef HAVE_SIGNALFD        swSignalfd_init();        SwooleG.use_signalfd = 1;#endif        //timerfd#ifdef HAVE_TIMERFD        SwooleG.use_timerfd = 1;#endif        SwooleG.use_timer_pipe = 1;        //将日志设置为标准输出        SwooleG.log_fd = STDOUT_FILENO;        //初始化全局内存        SwooleG.memory_pool = swMemoryGlobal_new(SW_GLOBAL_MEMORY_PAGESIZE, 1);        if (SwooleG.memory_pool == NULL)        {            swError("[Master] Fatal Error: create global memory fail. Error: %s[%d]", strerror(errno), errno);        }        SwooleGS = SwooleG.memory_pool->alloc(SwooleG.memory_pool, sizeof(swServerGS));        if (SwooleGS == NULL)        {            swError("[Master] Fatal Error: alloc memory for SwooleGS fail. Error: %s[%d]", strerror(errno), errno);        }    }}

static int swFactoryProcess_writer_start(swFactory *factory){	swFactoryProcess *this = factory->object;	swThreadParam *param;	int i;	pthread_t pidt;	swThreadStartFunc thread_main;#ifdef SW_USE_SHM_CHAN	thread_main = (swThreadStartFunc) swFactoryProcess_writer_loop_ex;#else	thread_main = (swThreadStartFunc)swFactoryProcess_writer_loop;#endif	for (i = 0; i < this->writer_num; i++)	{		param = sw_malloc(sizeof(swThreadParam));		if (param == NULL )		{			swError("malloc fail/n");			return SW_ERR;		}#ifdef SW_USE_SHM_CHAN#if defined(SW_CHAN_USE_MMAP) || SW_CHAN_USE_MMAP==1		mm = swShareMemory_mmap_create(&this->writers[i].shm, SW_CHAN_BUFFER_SIZE, 0);#else		mm = swShareMemory_sysv_create(&this->writers[i].shm, SW_CHAN_BUFFER_SIZE, SW_CHAN_SYSV_KEY);#endif		if (mm == NULL )		{			swError("shm_create fail/n");			return SW_ERR;		}		if (swChan_create(&this->writers[i].chan, mm, SW_CHAN_BUFFER_SIZE, SW_CHAN_ELEM_SIZE) < 0)		{			swError("swChan_create fail/n");			return SW_ERR;		}#endif		param->object = factory;		param->pti = i;		if (pthread_create(&pidt, NULL, thread_main, (void *) param) < 0)		{			swTrace("pthread_create fail/n");			return SW_ERR;		}		this->writers[i].ptid = pidt;		SW_START_SLEEP;	}	return SW_OK;}

static int swFactoryProcess_writer_start(swFactory *factory){	swFactoryProcess *object = factory->object;	swThreadParam *param;	int i;	pthread_t pidt;	swThreadStartFunc thread_main;#if SW_WORKER_IPC_MODE == 2	thread_main = (swThreadStartFunc) swFactoryProcess_writer_loop_queue;#else	thread_main = (swThreadStartFunc) swFactoryProcess_writer_loop_unsock;#endif	for (i = 0; i < object->writer_num; i++)	{		param = sw_malloc(sizeof(swPipe));		if (param == NULL)		{			swError("malloc fail/n");			return SW_ERR;		}		param->object = factory;		param->pti = i;		if (pthread_create(&pidt, NULL, thread_main, (void *) param) < 0)		{			swTrace("pthread_create fail/n");			return SW_ERR;		}		pthread_detach(pidt);		object->writers[i].ptid = pidt;		SW_START_SLEEP;	}	return SW_OK;}

static int swReactorPoll_add(swReactor *reactor, int fd, int fdtype){	swReactorPoll *object = reactor->object;	int cur = reactor->event_num;	if (reactor->event_num == object->max_fd_num)	{		swError("too many connection, more than %d", object->max_fd_num);		return SW_ERR;	}	object->fds[cur].fdtype = swReactor_fdtype(fdtype);	object->events[cur].fd = fd;	//object->events[cur].events = POLLRDHUP;	object->events[cur].events = 0;	if (swReactor_event_read(fdtype))	{		object->events[cur].events |= POLLIN;	}	if (swReactor_event_write(fdtype))	{		object->events[cur].events |= POLLOUT;	}	if (swReactor_event_error(fdtype))	{		object->events[cur].events |= POLLHUP;	}	reactor->event_num++;	return SW_OK;}

static int swFactoryProcess_writer_start(swFactory *factory){	swServer *serv = SwooleG.serv;	swThreadParam *param;	int i;	pthread_t pidt;	swThreadStartFunc thread_main;	if (serv->ipc_mode == SW_IPC_MSGQUEUE)	{		thread_main = (swThreadStartFunc) swFactoryProcess_writer_loop_queue;	}	else	{#if SW_USE_WRITER_THREAD		thread_main = (swThreadStartFunc) swFactoryProcess_writer_loop_unsock;#else		swError("never get here");#endif	}	for (i = 0; i < serv->writer_num; i++)	{		param = sw_malloc(sizeof(swPipe));		if (param == NULL)		{			swError("malloc fail/n");			return SW_ERR;		}		param->object = factory;		param->pti = i;		if (pthread_create(&pidt, NULL, thread_main, (void *) param) < 0)		{			swTrace("pthread_create fail/n");			return SW_ERR;		}		pthread_detach(pidt);		serv->writer_threads[i].ptid = pidt;		SW_START_SLEEP;	}	return SW_OK;}

void swSignalfd_init(){	sigemptyset(&swoole_signalfd_mask);	object.items = sw_calloc(SW_SIGNAL_INIT_NUM, sizeof(swSignal_item));	if (object.items == NULL)	{		swError("malloc for swSignal_item failed.");	}	object.size = SW_SIGNAL_INIT_NUM;	object.num = 0;}

/** * 主进程向worker进程发送数据 * @param worker_id 发到指定的worker进程 */int swFactoryProcess_send2worker(swFactory *factory, swEventData *data, int worker_id){	swFactoryProcess *object = factory->object;	swServer *serv = factory->ptr;	int pti;	int ret;	int send_len = sizeof(data->info) + data->info.len;	if (worker_id < 0)	{		//轮询		// data->info.from_id > serv->poll_thread_num, UDP必须使用轮询		if (serv->dispatch_mode == SW_DISPATCH_ROUND || data->info.from_id > serv->poll_thread_num)		{			pti = (object->worker_pti++) % object->worker_num;		}		//使用fd取摸来散列		else if (serv->dispatch_mode == SW_DISPATCH_FDMOD)		{			pti = data->info.fd % object->worker_num;		}		//使用抢占式队列(IPC消息队列)分配		else		{#if SW_WORKER_IPC_MODE != 2			swError("SW_DISPATCH_QUEUE must use (SW_WORKER_IPC_MODE = 2)");#endif			//msgsnd参数必须>0			//worker进程中正确的mtype应该是pti + 1			pti = object->worker_num;		}	}	//指定了worker_id	else	{		pti = worker_id;	}#if SW_WORKER_IPC_MODE == 2	//insert to msg queue	swQueue_data *in_data = (swQueue_data *)((void *)data - sizeof(long));	//加1防止id为0的worker进程出错	in_data->mtype = pti + 1;	swDataHead *info = (swDataHead *)in_data->mdata;	ret = object->rd_queue.in(&object->rd_queue, in_data, send_len);	swTrace("[Master]rd_queue[%ld]->in: fd=%d|type=%d|len=%d", in_data->mtype, info->fd, info->type, info->len);#else	//send to unix sock	ret = swWrite(object->workers[pti].pipe_master, (char *) data, send_len);#endif	return ret;}

void swoole_init(void){	if (SwooleG.running == 0)	{		bzero(&SwooleG, sizeof(SwooleG));		bzero(sw_error, SW_ERROR_MSG_SIZE);		//初始化全局变量		SwooleG.running = 1;		sw_errno = 0;		//init global lock		swMutex_create(&SwooleG.lock, 0);		//init signalfd#ifdef HAVE_SIGNALFD		swSignalfd_init();		SwooleG.use_signalfd = 1;#endif		//timerfd#ifdef HAVE_TIMERFD		SwooleG.use_timerfd = 1;#endif		//将日志设置为标准输出		SwooleG.log_fd = STDOUT_FILENO;		//初始化全局内存		SwooleG.memory_pool = swMemoryGlobal_new(SW_GLOBAL_MEMORY_PAGESIZE, 1);		if(SwooleG.memory_pool == NULL)		{			swError("[Master] Fatal Error: create global memory fail. Error: %s[%d]", strerror(errno), errno);		}		SwooleGS = SwooleG.memory_pool->alloc(SwooleG.memory_pool, sizeof(swServerGS));		if(SwooleGS == NULL)		{			swError("[Master] Fatal Error: alloc memory for SwooleGS fail. Error: %s[%d]", strerror(errno), errno);		}	}}

int swRingQueue_init(swRingQueue * p_queue, int buffer_size){	p_queue->data = sw_calloc(buffer_size, sizeof(void*));	if(p_queue->data == NULL)	{		swError("malloc fail/n");		return -1;	}	p_queue->size = buffer_size;	p_queue->head = 0;	p_queue->tail = 0;	p_queue->tag = 0;	return 0;}

void swSignalfd_add(int signo, __sighandler_t callback){	if (object.num == object.size)	{		object.items = sw_realloc(object.items, sizeof(swSignal_item) * object.size * 2);		if (object.items == NULL)		{			swError("realloc for swSignal_item failed.");			return;		}		object.size = object.size * 2;	}	sigaddset(&swoole_signalfd_mask, signo);	object.items[object.num].callback = callback;	object.items[object.num].signo = signo;	object.num ++;}

int swFactoryProcess_controller_start(swFactory *factory){	int i, pid;	swController *controller;	//循环fork	LL_FOREACH(manager_controller_list, controller)	{		controller->pipe_fd = manager_controller_pipes[controller->id].pipes[1];		pid = swFactoryProcess_controller_spawn(factory, controller);		if(pid < 0)		{			swError("Fork controller process fail.Errno=%d", errno);			return SW_ERR;		}		else		{			controller->pid = pid;		}	}

int swSocket_create(int type){    int _domain;    int _type;    switch (type)    {    case SW_SOCK_TCP:        _domain = PF_INET;        _type = SOCK_STREAM;        break;    case SW_SOCK_TCP6:        _domain = PF_INET6;        _type = SOCK_STREAM;        break;    case SW_SOCK_UDP:        _domain = PF_INET;        _type = SOCK_DGRAM;        break;    case SW_SOCK_UDP6:        _domain = PF_INET6;        _type = SOCK_DGRAM;        break;    case SW_SOCK_UNIX_DGRAM:        _domain = PF_UNIX;        _type = SOCK_DGRAM;        break;    case SW_SOCK_UNIX_STREAM:        _domain = PF_UNIX;        _type = SOCK_STREAM;        break;    default:        swError("unknow socket type [%d]", type);        return SW_ERR;    }    return socket(_domain, _type, 0);}

static int swFactoryProcess_worker_loop(swFactory *factory, int worker_pti){	struct {		long pti;		swEventData req;	} rdata;	swFactoryProcess *object = factory->object;	swServer *serv = factory->ptr;	int pipe_rd = object->workers[worker_pti].pipe_worker;	int n;	c_worker_pti = worker_pti;	object->manager_pid = getppid();#if SW_WORKER_IPC_MODE == 2	//抢占式,使用相同的队列type	if (serv->dispatch_mode == SW_DISPATCH_QUEUE)	{		//这里必须加1		rdata.pti = serv->worker_num + 1;	}	else	{		//必须加1		rdata.pti = worker_pti + 1;	}#else	SwooleG.main_reactor = sw_malloc(sizeof(swReactor));	if(SwooleG.main_reactor == NULL)	{		swError("[Worker] malloc for reactor fail");		return SW_ERR;	}	if(swReactor_auto(SwooleG.main_reactor, serv->max_conn) < 0)	{		swError("[Worker] create worker_reactor fail");		return SW_ERR;	}	SwooleG.main_reactor->ptr = serv;	SwooleG.main_reactor->add(SwooleG.main_reactor, pipe_rd, SW_FD_PIPE);	SwooleG.main_reactor->setHandle(SwooleG.main_reactor, SW_FD_PIPE, swFactoryProcess_worker_receive);#endif	if(factory->max_request < 1)	{		worker_task_always = 1;	}	else	{		worker_task_num = factory->max_request;		worker_task_num += get_rand(worker_pti);	}#ifdef HAVE_CPU_AFFINITY	if (serv->open_cpu_affinity == 1)	{		cpu_set_t cpu_set;		CPU_ZERO(&cpu_set);		CPU_SET(worker_pti % SW_CPU_NUM, &cpu_set);		if (0 != sched_setaffinity(getpid(), sizeof(cpu_set), &cpu_set))		{			swWarn("pthread_setaffinity_np set fail/n");		}	}#endif	if (serv->onWorkerStart != NULL)	{		//worker进程启动时调用		serv->onWorkerStart(serv, worker_pti);	}	struct timeval timeo;	timeo.tv_sec = SW_REACTOR_TIMEO_SEC;	timeo.tv_usec = SW_REACTOR_TIMEO_USEC;#if SW_WORKER_IPC_MODE == 2	//主线程	while (swoole_running > 0)	{		n = object->rd_queue.out(&object->rd_queue, (swQueue_data *)&rdata, sizeof(rdata.req));		if (n < 0)		{			swWarn("[Worker]rd_queue[%ld]->out wait. Error: %s [%d]", rdata.pti, strerror(errno), errno);			continue;		}		swFactoryProcess_worker_excute(factory, &rdata.req);	}#else	SwooleG.main_reactor->wait(SwooleG.main_reactor, &timeo);#endif	if (serv->onWorkerStop != NULL)	{		//worker进程结束时调用		serv->onWorkerStop(serv, worker_pti);	}	swTrace("[Worker]max request/n");	return SW_OK;}

//create worker child proccessstatic int swFactoryProcess_manager_start(swFactory *factory){	swFactoryProcess *object = factory->object;	int i, pid, ret;	int writer_pti;	swServer *serv = factory->ptr;#if SW_WORKER_IPC_MODE == 2#define _SW_PATH_BUF_LEN   128	//这里使用ftok来获取消息队列的key	char path_buf[_SW_PATH_BUF_LEN];	char *path_ptr = getcwd(path_buf, _SW_PATH_BUF_LEN);	//读数据队列	if(swQueueMsg_create(&object->rd_queue, 1, ftok(path_ptr, 1), 1) < 0)	{		swError("[Master] swPipeMsg_create[In] fail. Error: %s [%d]", strerror(errno), errno);		return SW_ERR;	}	//为TCP创建写队列	if (serv->have_tcp_sock == 1)	{		//写数据队列		if(swQueueMsg_create(&object->wt_queue, 1, ftok(path_ptr, 2), 1) < 0)		{			swError("[Master] swPipeMsg_create[out] fail. Error: %s [%d]", strerror(errno), errno);			return SW_ERR;		}	}#else	object->pipes = sw_calloc(object->worker_num, sizeof(swPipe));	if (object->pipes == NULL)	{		swError("malloc[worker_pipes] fail. Error: %s [%d]", strerror(errno), errno);		return SW_ERR;	}	//worker进程的pipes	for (i = 0; i < object->worker_num; i++)	{		if (swPipeUnsock_create(&object->pipes[i], 1, SOCK_DGRAM) < 0)		{			swError("create unix socket[1] fail");			return SW_ERR;		}		object->workers[i].pipe_master = object->pipes[i].getFd(&object->pipes[i], 1);		object->workers[i].pipe_worker = object->pipes[i].getFd(&object->pipes[i], 0);	}#endif	if (serv->task_worker_num > 0)	{		if (swProcessPool_create(&SwooleG.task_workers, serv->task_worker_num, serv->max_request)< 0)		{			swWarn("[Master] create task_workers fail");			return SW_ERR;		}		//设置指针和回调函数		SwooleG.task_workers.ptr = serv;		SwooleG.task_workers.onTask = swTaskWorker_onTask;	}	pid = fork();	switch (pid)	{	//创建manager进程	case 0:		for (i = 0; i < object->worker_num; i++)		{//			close(worker_pipes[i].pipes[0]);			writer_pti = (i % object->writer_num);			object->workers[i].writer_id = writer_pti;			pid = swFactoryProcess_worker_spawn(factory, i);			if (pid < 0)			{				swError("Fork worker process fail");				return SW_ERR;			}			else			{				object->workers[i].pid = pid;			}		}		//创建task_worker进程		if (serv->task_worker_num > 0)		{			swProcessPool_start(&SwooleG.task_workers);		}		//标识为管理进程		SwooleG.process_type = SW_PROCESS_MANAGER;		ret = swFactoryProcess_manager_loop(factory);		exit(ret);		break;		//主进程	default:		object->manager_pid = pid;		//TCP需要writer线程		if (serv->have_tcp_sock == 1)		{			int ret = swFactoryProcess_writer_start(factory);			if (ret < 0)			{//.........这里部分代码省略.........

static int swFactoryProcess_manager_loop(swFactory *factory){	int pid, new_pid;	int i, writer_pti;	int reload_worker_i = 0;	int ret;	swFactoryProcess *object = factory->object;	swServer *serv = factory->ptr;	swWorker *reload_workers;	reload_workers = sw_calloc(object->worker_num, sizeof(swWorker));	if (reload_workers == NULL)	{		swError("[manager] malloc[reload_workers] fail./n");		return SW_ERR;	}	//for reload	swSignalSet(SIGUSR1, swManagerSignalHanlde, 1, 0);	while (swoole_running > 0)	{		pid = wait(NULL);		swTrace("[manager] worker stop.pid=%d/n", pid);		if (pid < 0)		{			if (manager_worker_reloading == 0)			{				swTrace("[Manager] wait fail. Error: %s [%d]", strerror(errno), errno);			}			else if (manager_reload_flag == 0)			{				memcpy(reload_workers, object->workers, sizeof(swWorker) * object->worker_num);				manager_reload_flag = 1;				goto kill_worker;			}		}		if (swoole_running == 1)		{			for (i = 0; i < object->worker_num; i++)			{				//对比pid				if (pid != object->workers[i].pid)				{					continue;				}				else				{					pid = 0;					new_pid = swFactoryProcess_worker_spawn(factory, i);					if (new_pid < 0)					{						swWarn("Fork worker process fail. Error: %s [%d]", strerror(errno), errno);						return SW_ERR;					}					else					{						object->workers[i].pid = new_pid;					}				}			}			//task worker			if(pid > 0)			{				swWorker *exit_worker = swHashMap_find_int(&SwooleG.task_workers.map, pid);				if (exit_worker != NULL)				{					swProcessPool_spawn(&SwooleG.task_workers, exit_worker);				}			}		}		//reload worker		kill_worker: if (manager_worker_reloading == 1)		{			//reload finish			if (reload_worker_i >= object->worker_num)			{				manager_worker_reloading = 0;				reload_worker_i = 0;				continue;			}			ret = kill(reload_workers[reload_worker_i].pid, SIGTERM);			if (ret < 0)			{				swWarn("[Manager]kill fail.pid=%d. Error: %s [%d]", reload_workers[reload_worker_i].pid, strerror(errno), errno);				continue;			}			reload_worker_i++;		}	}	sw_free(reload_workers);	return SW_OK;}

void swoole_init(void){    struct rlimit rlmt;    if (SwooleG.running)    {        return;    }    bzero(&SwooleG, sizeof(SwooleG));    bzero(&SwooleWG, sizeof(SwooleWG));    bzero(sw_error, SW_ERROR_MSG_SIZE);    SwooleG.running = 1;    sw_errno = 0;    SwooleG.log_fd = STDOUT_FILENO;    SwooleG.cpu_num = sysconf(_SC_NPROCESSORS_ONLN);    SwooleG.pagesize = getpagesize();    SwooleG.pid = getpid();    SwooleG.socket_buffer_size = SW_SOCKET_BUFFER_SIZE;    //get system uname    uname(&SwooleG.uname);    //random seed    srandom(time(NULL));    //init global shared memory    SwooleG.memory_pool = swMemoryGlobal_new(SW_GLOBAL_MEMORY_PAGESIZE, 1);    if (SwooleG.memory_pool == NULL)    {        printf("[Master] Fatal Error: create global memory failed.");        exit(1);    }    SwooleGS = SwooleG.memory_pool->alloc(SwooleG.memory_pool, sizeof(swServerGS));    if (SwooleGS == NULL)    {        printf("[Master] Fatal Error: alloc memory for SwooleGS failed.");        exit(2);    }    //init global lock    swMutex_create(&SwooleGS->lock, 1);    swMutex_create(&SwooleGS->lock_2, 1);    if (getrlimit(RLIMIT_NOFILE, &rlmt) < 0)    {        swWarn("getrlimit() failed. Error: %s[%d]", strerror(errno), errno);        SwooleG.max_sockets = 1024;    }    else    {        SwooleG.max_sockets = (uint32_t) rlmt.rlim_cur;    }    SwooleG.module_stack = swString_new(8192);    if (SwooleG.module_stack == NULL)    {        exit(3);    }    if (!SwooleG.task_tmpdir)    {        SwooleG.task_tmpdir = strndup(SW_TASK_TMP_FILE, sizeof(SW_TASK_TMP_FILE));        SwooleG.task_tmpdir_len = sizeof(SW_TASK_TMP_FILE);    }    char *tmp_dir = swoole_dirname(SwooleG.task_tmpdir);    //create tmp dir    if (access(tmp_dir, R_OK) < 0 && swoole_mkdir_recursive(tmp_dir) < 0)    {        swWarn("create task tmp dir(%s) failed.", tmp_dir);    }    if (tmp_dir)    {        sw_strdup_free(tmp_dir);    }    //init signalfd#ifdef HAVE_SIGNALFD    swSignalfd_init();    SwooleG.use_signalfd = 1;#endif    //timerfd#ifdef HAVE_TIMERFD    SwooleG.use_timerfd = 1;#endif    SwooleG.use_timer_pipe = 1;    SwooleStats = SwooleG.memory_pool->alloc(SwooleG.memory_pool, sizeof(swServerStats));    if (SwooleStats == NULL)    {        swError("[Master] Fatal Error: alloc memory for SwooleStats failed.");    }    swoole_update_time();}

/** * worker main loop */int swWorker_loop(swFactory *factory, int worker_id){    swServer *serv = factory->ptr;#ifndef SW_WORKER_USE_SIGNALFD    SwooleG.use_signalfd = 0;#elif defined(HAVE_SIGNALFD)    SwooleG.use_signalfd = 1;#endif    //timerfd#ifdef HAVE_TIMERFD    SwooleG.use_timerfd = 1;#endif    //worker_id    SwooleWG.id = worker_id;    SwooleWG.request_count = 0;    SwooleG.pid = getpid();    //signal init    swWorker_signal_init();    swWorker *worker = swServer_get_worker(serv, worker_id);    swServer_worker_init(serv, worker);    SwooleG.main_reactor = sw_malloc(sizeof(swReactor));    if (SwooleG.main_reactor == NULL)    {        swError("[Worker] malloc for reactor failed.");        return SW_ERR;    }    if (swReactor_create(SwooleG.main_reactor, SW_REACTOR_MAXEVENTS) < 0)    {        swError("[Worker] create worker_reactor failed.");        return SW_ERR;    }        serv->workers[worker_id].status = SW_WORKER_IDLE;    int pipe_worker = serv->workers[worker_id].pipe_worker;    swSetNonBlock(pipe_worker);    SwooleG.main_reactor->ptr = serv;    SwooleG.main_reactor->add(SwooleG.main_reactor, pipe_worker, SW_FD_PIPE | SW_EVENT_READ);    SwooleG.main_reactor->setHandle(SwooleG.main_reactor, SW_FD_PIPE, swWorker_onPipeReceive);    SwooleG.main_reactor->setHandle(SwooleG.main_reactor, SW_FD_PIPE | SW_FD_WRITE, swReactor_onWrite);    /**     * set pipe buffer size     */    int i;    swConnection *pipe_socket;    for (i = 0; i < serv->worker_num + SwooleG.task_worker_num; i++)    {        worker = swServer_get_worker(serv, i);        pipe_socket = swReactor_get(SwooleG.main_reactor, worker->pipe_master);        pipe_socket->buffer_size = serv->pipe_buffer_size;        pipe_socket = swReactor_get(SwooleG.main_reactor, worker->pipe_worker);        pipe_socket->buffer_size = serv->pipe_buffer_size;    }    swWorker_onStart(serv);#ifdef HAVE_SIGNALFD    if (SwooleG.use_signalfd)    {        swSignalfd_setup(SwooleG.main_reactor);    }#endif    //main loop    SwooleG.main_reactor->wait(SwooleG.main_reactor, NULL);    //clear pipe buffer    swWorker_clean();    //worker shutdown    swWorker_onStop(serv);    return SW_OK;}

/** * worker main loop */static int swFactoryProcess_worker_loop(swFactory *factory, int worker_pti){	swFactoryProcess *object = factory->object;	swServer *serv = factory->ptr;	struct	{		long pti;		swEventData req;	} rdata;	int n;	int pipe_rd = object->workers[worker_pti].pipe_worker;#ifdef HAVE_CPU_AFFINITY	if (serv->open_cpu_affinity == 1)	{		cpu_set_t cpu_set;		CPU_ZERO(&cpu_set);		CPU_SET(worker_pti % SW_CPU_NUM, &cpu_set);		if (0 != sched_setaffinity(getpid(), sizeof(cpu_set), &cpu_set))		{			swWarn("pthread_setaffinity_np set failed");		}	}#endif	//signal init	swFactoryProcess_worker_signal_init();	//worker_id	SwooleWG.id = worker_pti;#ifndef SW_USE_RINGBUFFER	int i;	//for open_check_eof and  open_check_length	if (serv->open_eof_check || serv->open_length_check)	{		SwooleWG.buffer_input = sw_malloc(sizeof(swString*) * serv->reactor_num);		if (SwooleWG.buffer_input == NULL)		{			swError("malloc for SwooleWG.buffer_input failed.");			return SW_ERR;		}		for (i = 0; i < serv->reactor_num; i++)		{			SwooleWG.buffer_input[i] = swString_new(serv->buffer_input_size);			if (SwooleWG.buffer_input[i] == NULL)			{				swError("buffer_input init failed.");				return SW_ERR;			}		}	}#endif	if (serv->ipc_mode == SW_IPC_MSGQUEUE)	{		//抢占式,使用相同的队列type		if (serv->dispatch_mode == SW_DISPATCH_QUEUE)		{			//这里必须加1			rdata.pti = serv->worker_num + 1;		}		else		{			//必须加1			rdata.pti = worker_pti + 1;		}	}	else	{		SwooleG.main_reactor = sw_malloc(sizeof(swReactor));		if (SwooleG.main_reactor == NULL)		{			swError("[Worker] malloc for reactor failed.");			return SW_ERR;		}		if (swReactor_auto(SwooleG.main_reactor, SW_REACTOR_MAXEVENTS) < 0)		{			swError("[Worker] create worker_reactor failed.");			return SW_ERR;		}		swSetNonBlock(pipe_rd);		SwooleG.main_reactor->ptr = serv;		SwooleG.main_reactor->add(SwooleG.main_reactor, pipe_rd, SW_FD_PIPE);		SwooleG.main_reactor->setHandle(SwooleG.main_reactor, SW_FD_PIPE, swFactoryProcess_worker_receive);#ifdef HAVE_SIGNALFD		if (SwooleG.use_signalfd)		{			swSignalfd_setup(SwooleG.main_reactor);		}#endif	}//.........这里部分代码省略.........

int swTimer_start(swTimer *timer, int interval_ms){	struct timeval now;	if (gettimeofday(&now, NULL) < 0)	{		swWarn("malloc fail/n");		return SW_ERR;	}	timer->interval_ms = interval_ms;	timer->lasttime = interval_ms;	int sec = interval_ms / 1000;	int msec = (((float) interval_ms / 1000) - sec) * 1000;#ifdef HAVE_TIMERFD	struct itimerspec timer_set;	memset(&timer_set, 0, sizeof(timer_set));	timer->fd = timerfd_create(CLOCK_REALTIME, TFD_NONBLOCK | TFD_CLOEXEC);	if (timer->fd < 0)	{		swError("create timerfd fail/n");		return SW_ERR;	}	timer_set.it_value.tv_sec = now.tv_sec + sec;	timer_set.it_value.tv_nsec = now.tv_usec + msec * 1000;	timer_set.it_interval.tv_sec = sec;	timer_set.it_interval.tv_nsec = msec * 1000 * 1000;	if (timerfd_settime(timer->fd, TFD_TIMER_ABSTIME, &timer_set, NULL) == -1)	{		swWarn("set timer fail/n");		return SW_ERR;	}	timer->use_pipe = 0;#else	struct itimerval timer_set;	int ret;	//eventfd是2.6.26提供的,timerfd是2.6.27提供的#ifdef HAVE_EVENTFD	ret = swPipeEventfd_create(&timer->pipe, 0, 0);#else	ret = swPipeBase_create(&timer->pipe, 0);#endif	if (ret < 0)	{		swWarn("create timer pipe fail");		return SW_ERR;	}	memset(&timer_set, 0, sizeof(timer_set));	timer_set.it_value.tv_sec = sec;	timer_set.it_value.tv_usec = msec * 1000;	timer_set.it_interval.tv_sec = sec;	timer_set.it_interval.tv_usec = msec * 1000;	if (setitimer(ITIMER_REAL, &timer_set, NULL) < 0)	{		swWarn("set timer fail");		return SW_ERR;	}	timer->fd = timer->pipe.getFd(&timer->pipe, 0);	timer->use_pipe = 1;#endif	return SW_OK;}

static int swFactoryProcess_manager_loop(swFactory *factory){	int pid, new_pid;	int i;	int reload_worker_i = 0;	int ret;	int worker_exit_code;	SwooleG.use_signalfd = 0;	SwooleG.use_timerfd = 0;	swFactoryProcess *object = factory->object;	swServer *serv = factory->ptr;	swWorker *reload_workers;	if (serv->onManagerStart)	{		serv->onManagerStart(serv);	}	reload_workers = sw_calloc(serv->worker_num, sizeof(swWorker));	if (reload_workers == NULL)	{		swError("[manager] malloc[reload_workers] failed");		return SW_ERR;	}	//for reload	swSignal_add(SIGUSR1, swManagerSignalHanlde);	while (SwooleG.running > 0)	{		pid = wait(&worker_exit_code);		swTrace("[manager] worker stop.pid=%d/n", pid);		if (pid < 0)		{			if (manager_worker_reloading == 0)			{				swTrace("[Manager] wait failed. Error: %s [%d]", strerror(errno), errno);			}			else if (manager_reload_flag == 0)			{				memcpy(reload_workers, object->workers, sizeof(swWorker) * serv->worker_num);				manager_reload_flag = 1;				goto kill_worker;			}		}		if (SwooleG.running == 1)		{			for (i = 0; i < serv->worker_num; i++)			{				//对比pid				if (pid != object->workers[i].pid)				{					continue;				}				else				{					if(serv->onWorkerError!=NULL && WEXITSTATUS(worker_exit_code) > 0)					{						serv->onWorkerError(serv, i, pid, WEXITSTATUS(worker_exit_code));					}					pid = 0;					new_pid = swFactoryProcess_worker_spawn(factory, i);					if (new_pid < 0)					{						swWarn("Fork worker process failed. Error: %s [%d]", strerror(errno), errno);						return SW_ERR;					}					else					{						object->workers[i].pid = new_pid;					}				}			}			//task worker			if(pid > 0)			{				swWorker *exit_worker = swHashMap_find_int(&SwooleG.task_workers.map, pid);				if (exit_worker != NULL)				{					swProcessPool_spawn(exit_worker);				}			}		}		//reload worker		kill_worker: if (manager_worker_reloading == 1)		{			//reload finish			if (reload_worker_i >= serv->worker_num)			{				manager_worker_reloading = 0;				reload_worker_i = 0;				continue;			}			ret = kill(reload_workers[reload_worker_i].pid, SIGTERM);			if (ret < 0)			{				swWarn("[Manager]kill failed, pid=%d. Error: %s [%d]", reload_workers[reload_worker_i].pid, strerror(errno), errno);//.........这里部分代码省略.........

void swoole_init(void){    struct rlimit rlmt;    if (SwooleG.running)    {        return;    }    bzero(&SwooleG, sizeof(SwooleG));    bzero(&SwooleWG, sizeof(SwooleWG));    bzero(sw_error, SW_ERROR_MSG_SIZE);    SwooleG.running = 1;    sw_errno = 0;    SwooleG.log_fd = STDOUT_FILENO;    SwooleG.cpu_num = sysconf(_SC_NPROCESSORS_ONLN);    SwooleG.pagesize = getpagesize();    SwooleG.pid = getpid();    //get system uname    uname(&SwooleG.uname);    //random seed    srandom(time(NULL));    //init global shared memory    SwooleG.memory_pool = swMemoryGlobal_new(SW_GLOBAL_MEMORY_PAGESIZE, 1);    if (SwooleG.memory_pool == NULL)    {        printf("[Master] Fatal Error: create global memory failed.");        exit(1);    }    SwooleGS = SwooleG.memory_pool->alloc(SwooleG.memory_pool, sizeof(swServerGS));    if (SwooleGS == NULL)    {        printf("[Master] Fatal Error: alloc memory for SwooleGS failed.");        exit(2);    }    //init global lock    swMutex_create(&SwooleGS->lock, 1);    swMutex_create(&SwooleGS->lock_2, 1);    if (getrlimit(RLIMIT_NOFILE, &rlmt) < 0)    {        swWarn("getrlimit() failed. Error: %s[%d]", strerror(errno), errno);        SwooleG.max_sockets = 1024;    }    else    {        SwooleG.max_sockets = (uint32_t) rlmt.rlim_cur;    }    //init signalfd#ifdef HAVE_SIGNALFD    swSignalfd_init();    SwooleG.use_signalfd = 1;#endif    //timerfd#ifdef HAVE_TIMERFD    SwooleG.use_timerfd = 1;#endif    SwooleG.use_timer_pipe = 1;    SwooleStats = SwooleG.memory_pool->alloc(SwooleG.memory_pool, sizeof(swServerStats));    if (SwooleStats == NULL)    {        swError("[Master] Fatal Error: alloc memory for SwooleStats failed.");    }    swoole_update_time();}

/** * worker main loop */int swWorker_loop(swFactory *factory, int worker_id){    swServer *serv = factory->ptr;#ifndef SW_WORKER_USE_SIGNALFD    SwooleG.use_signalfd = 0;#endif    //worker_id    SwooleWG.id = worker_id;    SwooleG.pid = getpid();    //signal init    swWorker_signal_init();    swWorker *worker = swServer_get_worker(serv, worker_id);    swServer_worker_init(serv, worker);    SwooleG.main_reactor = sw_malloc(sizeof(swReactor));    if (SwooleG.main_reactor == NULL)    {        swError("[Worker] malloc for reactor failed.");        return SW_ERR;    }    if (swReactor_create(SwooleG.main_reactor, SW_REACTOR_MAXEVENTS) < 0)    {        swError("[Worker] create worker_reactor failed.");        return SW_ERR;    }    int pipe_worker = serv->workers[worker_id].pipe_worker;    swSetNonBlock(pipe_worker);    SwooleG.main_reactor->ptr = serv;    SwooleG.main_reactor->add(SwooleG.main_reactor, pipe_worker, SW_FD_PIPE | SW_EVENT_READ);    SwooleG.main_reactor->setHandle(SwooleG.main_reactor, SW_FD_PIPE, swWorker_onPipeReceive);    SwooleG.main_reactor->setHandle(SwooleG.main_reactor, SW_FD_PIPE | SW_FD_WRITE, swReactor_onWrite);    if (serv->max_request < 1)    {        SwooleWG.run_always = 1;    }    else    {        worker_task_num = serv->max_request;        if (worker_task_num > 10)        {            worker_task_num += swRandom(worker_id);        }    }    swWorker_onStart(serv);#ifdef HAVE_SIGNALFD    if (SwooleG.use_signalfd)    {        swSignalfd_setup(SwooleG.main_reactor);    }#endif    SwooleG.main_reactor->wait(SwooleG.main_reactor, NULL);    swWorker_onStop(serv);    return SW_OK;}

static int swFactoryProcess_manager_loop(swFactory *factory){	int pid, new_pid;	int i, writer_pti;	int reload_worker_i = 0;	int ret;	swFactoryProcess *this = factory->object;	swWorkerChild *reload_workers;	reload_workers = sw_calloc(this->worker_num, sizeof(swWorkerChild));	if (reload_workers == NULL )	{		swError("[manager] malloc[reload_workers] fail./n");		return SW_ERR;	}	//for reload	swSignalSet(SIGUSR1, swManagerSignalHanlde, 1, 0);	while (1)	{		pid = wait(NULL );		swTrace("[manager] worker stop.pid=%d/n", pid);		if (pid < 0)		{			if (manager_worker_reloading == 0)			{				swTrace("wait fail.errno=%d/n", errno);			}			else if (manager_reload_flag == 0)			{				memcpy(reload_workers, this->workers, sizeof(swWorkerChild) * this->worker_num);				manager_reload_flag = 1;				goto kill_worker;			}		}		for (i = 0; i < this->worker_num; i++)		{			if (pid != this->workers[i].pid)				continue;			writer_pti = (i % this->writer_num);			new_pid = swFactoryProcess_worker_spawn(factory, writer_pti, i);			if (new_pid < 0)			{				swWarn("Fork worker process fail.Errno=%d/n", errno);				return SW_ERR;			}			else			{				this->workers[i].pid = new_pid;			}		}		//reload worker		kill_worker: if (manager_worker_reloading == 1)		{			//reload finish			if (reload_worker_i >= this->worker_num)			{				manager_worker_reloading = 0;				reload_worker_i = 0;				continue;			}			ret = kill(reload_workers[reload_worker_i].pid, SIGTERM);			if (ret < 0)			{				swWarn("kill fail.pid=%d|errno=%d/n", reload_workers[reload_worker_i].pid, errno);				continue;			}			reload_worker_i++;		}	}	return SW_OK;}

int swProcessPool_wait(swProcessPool *pool){	int pid, new_pid;	int reload_worker_i = 0;	int ret, i;	swWorker *reload_workers;	reload_workers = sw_calloc(pool->worker_num, sizeof(swWorker));	if (reload_workers == NULL)	{		swError("[manager] malloc[reload_workers] fail./n");		return SW_ERR;	}	while (1)	{		pid = wait(NULL);		swTrace("[manager] worker stop.pid=%d/n", pid);		if (pid < 0)		{			if (pool->reloading == 0)			{				swTrace("[Manager] wait fail. Error: %s [%d]", strerror(errno), errno);			}			else if (pool->reload_flag == 0)			{				memcpy(reload_workers, pool->workers, sizeof(swWorker) * pool->worker_num);				pool->reload_flag = 1;				goto reload_worker;			}		}		if (SwooleG.running == 1)		{			swWorker *exit_worker = swHashMap_find_int(&pool->map, pid);			if (exit_worker == NULL)			{				swWarn("[Manager]unknow worker[pid=%d]", pid);				continue;			}			new_pid = swProcessPool_spawn(exit_worker);			if (new_pid < 0)			{				swWarn("Fork worker process fail. Error: %s [%d]", strerror(errno), errno);				return SW_ERR;			}			swHashMap_del_int(&pool->map, pid);		}		//reload worker		reload_worker: if (pool->reloading == 1)		{			//reload finish			if (reload_worker_i >= pool->worker_num)			{				pool->reloading = 0;				reload_worker_i = 0;				continue;			}			ret = kill(reload_workers[reload_worker_i].pid, SIGTERM);			if (ret < 0)			{				swWarn("[Manager]kill fail.pid=%d. Error: %s [%d]", reload_workers[reload_worker_i].pid,						strerror(errno), errno);				continue;			}			reload_worker_i++;		}	}	return SW_OK;}

//create worker child proccessstatic int swFactoryProcess_manager_start(swFactory *factory){	swFactoryProcess *object = factory->object;	int i, pid, ret;	int reactor_pti;	swServer *serv = factory->ptr;	if (serv->ipc_mode == SW_IPC_MSGQUEUE)	{		//读数据队列		if (swQueueMsg_create(&object->rd_queue, 1, serv->message_queue_key, 1) < 0)		{			swError("[Master] swPipeMsg_create[In] fail. Error: %s [%d]", strerror(errno), errno);			return SW_ERR;		}		//为TCP创建写队列		if (serv->have_tcp_sock == 1)		{			//写数据队列			if (swQueueMsg_create(&object->wt_queue, 1, serv->message_queue_key + 1, 1) < 0)			{				swError("[Master] swPipeMsg_create[out] fail. Error: %s [%d]", strerror(errno), errno);				return SW_ERR;			}		}	}	else	{		object->pipes = sw_calloc(serv->worker_num, sizeof(swPipe));		if (object->pipes == NULL)		{			swError("malloc[worker_pipes] fail. Error: %s [%d]", strerror(errno), errno);			return SW_ERR;		}		//worker进程的pipes		for (i = 0; i < serv->worker_num; i++)		{			if (swPipeUnsock_create(&object->pipes[i], 1, SOCK_DGRAM) < 0)			{				swError("create unix socket[1] fail");				return SW_ERR;			}			object->workers[i].pipe_master = object->pipes[i].getFd(&object->pipes[i], 1);			object->workers[i].pipe_worker = object->pipes[i].getFd(&object->pipes[i], 0);		}	}	if (SwooleG.task_worker_num > 0)	{		key_t msgqueue_key = 0;		if (SwooleG.task_ipc_mode > 0)		{			msgqueue_key =  serv->message_queue_key + 2;		}		if (swProcessPool_create(&SwooleG.task_workers, SwooleG.task_worker_num, serv->max_request, msgqueue_key)< 0)		{			swWarn("[Master] create task_workers fail");			return SW_ERR;		}		//设置指针和回调函数		SwooleG.task_workers.ptr = serv;		SwooleG.task_workers.onTask = swTaskWorker_onTask;		if (serv->onWorkerStart != NULL)		{			SwooleG.task_workers.onWorkerStart = swTaskWorker_onWorkerStart;		}	}	pid = fork();	switch (pid)	{	//创建manager进程	case 0:		//创建子进程		for (i = 0; i < serv->worker_num; i++)		{			//close(worker_pipes[i].pipes[0]);			reactor_pti = (i % serv->writer_num);			object->workers[i].reactor_id = reactor_pti;			pid = swFactoryProcess_worker_spawn(factory, i);			if (pid < 0)			{				swError("Fork worker process fail");				return SW_ERR;			}			else			{				object->workers[i].pid = pid;			}		}		/**		 * create task worker pool		 */		if (SwooleG.task_worker_num > 0)		{			swProcessPool_start(&SwooleG.task_workers);		}		//标识为管理进程		SwooleG.process_type = SW_PROCESS_MANAGER;//.........这里部分代码省略.........

/** * worker main loop */int swWorker_loop(swFactory *factory, int worker_id){    swServer *serv = factory->ptr;    struct    {        long pti;        swEventData req;    } rdata;    int n;#ifdef HAVE_CPU_AFFINITY    if (serv->open_cpu_affinity == 1)    {        cpu_set_t cpu_set;        CPU_ZERO(&cpu_set);        CPU_SET(worker_id % SW_CPU_NUM, &cpu_set);        if (0 != sched_setaffinity(getpid(), sizeof(cpu_set), &cpu_set))        {            swWarn("pthread_setaffinity_np set failed");        }    }#endif#ifndef SW_WORKER_USE_SIGNALFD    SwooleG.use_signalfd = 0;#endif    //signal init    swWorker_signal_init();    //worker_id    SwooleWG.id = worker_id;    int i;    SwooleWG.buffer_input = sw_malloc(sizeof(swString*) * serv->reactor_num);    if (SwooleWG.buffer_input == NULL)    {        swError("malloc for SwooleWG.buffer_input failed.");        return SW_ERR;    }#ifndef SW_USE_RINGBUFFER    int buffer_input_size;    if (serv->open_eof_check || serv->open_length_check || serv->open_http_protocol)    {        buffer_input_size = serv->package_max_length;    }    else    {        buffer_input_size = SW_BUFFER_SIZE_BIG;    }    for (i = 0; i < serv->reactor_num; i++)    {        SwooleWG.buffer_input[i] = swString_new(buffer_input_size);        if (SwooleWG.buffer_input[i] == NULL)        {            swError("buffer_input init failed.");            return SW_ERR;        }    }#endif    if (serv->ipc_mode == SW_IPC_MSGQUEUE)    {        //抢占式,使用相同的队列type        if (serv->dispatch_mode == SW_DISPATCH_QUEUE)        {            //这里必须加1            rdata.pti = serv->worker_num + 1;        }        else        {            //必须加1            rdata.pti = worker_id + 1;        }    }    else    {        SwooleG.main_reactor = sw_malloc(sizeof(swReactor));        if (SwooleG.main_reactor == NULL)        {            swError("[Worker] malloc for reactor failed.");            return SW_ERR;        }        if (swReactor_auto(SwooleG.main_reactor, SW_REACTOR_MAXEVENTS) < 0)        {            swError("[Worker] create worker_reactor failed.");            return SW_ERR;        }        int pipe_worker = serv->workers[worker_id].pipe_worker;        swSetNonBlock(pipe_worker);//.........这里部分代码省略.........

int swProcessPool_wait(swProcessPool *pool){    int pid, new_pid;    int reload_worker_i = 0;    int ret;    int status;    swWorker *reload_workers;    reload_workers = sw_calloc(pool->worker_num, sizeof(swWorker));    if (reload_workers == NULL)    {        swError("[manager] malloc[reload_workers] fail./n");        return SW_ERR;    }    while (SwooleG.running)    {        pid = wait(&status);        if (pid < 0)        {            if (pool->reloading == 0)            {                swTrace("[Manager] wait failed. Error: %s [%d]", strerror(errno), errno);            }            else if (pool->reload_flag == 0)            {                swTrace("[Manager] reload workers.");                memcpy(reload_workers, pool->workers, sizeof(swWorker) * pool->worker_num);                pool->reload_flag = 1;                goto reload_worker;            }            else if (SwooleG.running == 0)            {                break;            }        }        swTrace("[Manager] worker stop.pid=%d", pid);        if (SwooleG.running == 1)        {            swWorker *exit_worker = swHashMap_find_int(pool->map, pid);            if (exit_worker == NULL)            {                if (pool->onWorkerNotFound)                {                    pool->onWorkerNotFound(pool, pid, status);                }                else                {                    swWarn("[Manager]unknow worker[pid=%d]", pid);                }                continue;            }            if (!WIFEXITED(status))            {                swWarn("worker#%d abnormal exit, status=%d, signal=%d", exit_worker->id, WEXITSTATUS(status),  WTERMSIG(status));            }            new_pid = swProcessPool_spawn(exit_worker);            if (new_pid < 0)            {                swWarn("Fork worker process failed. Error: %s [%d]", strerror(errno), errno);                sw_free(reload_workers);                return SW_ERR;            }            swHashMap_del_int(pool->map, pid);        }        //reload worker        reload_worker:        if (pool->reloading == 1)        {            //reload finish            if (reload_worker_i >= pool->worker_num)            {                pool->reloading = 0;                reload_worker_i = 0;                continue;            }            ret = kill(reload_workers[reload_worker_i].pid, SIGTERM);            if (ret < 0)            {                swSysError("[Manager]kill(%d) failed.", reload_workers[reload_worker_i].pid);                continue;            }            reload_worker_i++;        }    }    sw_free(reload_workers);    return SW_OK;}

static int swFactoryProcess_manager_loop(swFactory *factory){    int pid, new_pid;    int i;    int reload_worker_i = 0;    int reload_worker_num;    int ret;    int worker_exit_code;    SwooleG.use_signalfd = 0;    SwooleG.use_timerfd = 0;    memset(&ManagerProcess, 0, sizeof(ManagerProcess));    swServer *serv = factory->ptr;    swWorker *reload_workers;    if (serv->onManagerStart)    {        serv->onManagerStart(serv);    }    reload_worker_num = serv->worker_num + SwooleG.task_worker_num;    reload_workers = sw_calloc(reload_worker_num, sizeof(swWorker));    if (reload_workers == NULL)    {        swError("malloc[reload_workers] failed");        return SW_ERR;    }    //for reload    swSignal_add(SIGTERM, swManager_signal_handle);    swSignal_add(SIGUSR1, swManager_signal_handle);    swSignal_add(SIGUSR2, swManager_signal_handle);    //swSignal_add(SIGINT, swManager_signal_handle);    while (SwooleG.running > 0)    {        pid = wait(&worker_exit_code);        if (pid < 0)        {            if (ManagerProcess.reloading == 0)            {                swTrace("wait() failed. Error: %s [%d]", strerror(errno), errno);            }            else if (ManagerProcess.reload_event_worker == 1)            {                memcpy(reload_workers, serv->workers, sizeof(swWorker) * serv->worker_num);                reload_worker_num = serv->worker_num;                if (SwooleG.task_worker_num > 0)                {                    memcpy(reload_workers + serv->worker_num, SwooleG.task_workers.workers,                            sizeof(swWorker) * SwooleG.task_worker_num);                    reload_worker_num += SwooleG.task_worker_num;                }                reload_worker_i = 0;                ManagerProcess.reload_event_worker = 0;                goto kill_worker;            }            else if (ManagerProcess.reload_task_worker == 1)            {                if (SwooleG.task_worker_num == 0)                {                    swWarn("Cannot reload workers, because server no have task workers.");                    continue;                }                memcpy(reload_workers, SwooleG.task_workers.workers, sizeof(swWorker) * SwooleG.task_worker_num);                reload_worker_num = SwooleG.task_worker_num;                reload_worker_i = 0;                ManagerProcess.reload_task_worker = 0;                goto kill_worker;            }        }        if (SwooleG.running == 1)        {            for (i = 0; i < serv->worker_num; i++)            {                //compare PID                if (pid != serv->workers[i].pid)                {                    continue;                }                else                {                    if (serv->onWorkerError != NULL && WEXITSTATUS(worker_exit_code) > 0)                    {                        serv->onWorkerError(serv, i, pid, WEXITSTATUS(worker_exit_code));                    }                    pid = 0;                    while (1)                    {                        new_pid = swFactoryProcess_worker_spawn(factory, i);                        if (new_pid < 0)                        {                            usleep(100000);                            continue;                        }                        else                        {//.........这里部分代码省略.........