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

static void run_ras(struct ast_channel *chan, char *args){	pid_t pid;	int status;	int res;	int signalled = 0;	struct dahdi_bufferinfo savebi;	int x;		res = ioctl(chan->fds[0], DAHDI_GET_BUFINFO, &savebi);	if(res) {		ast_log(LOG_WARNING, "Unable to check buffer policy on channel %s/n", chan->name);		return;	}	pid = spawn_ras(chan, args);	if (pid < 0) {		ast_log(LOG_WARNING, "Failed to spawn RAS/n");	} else {		for (;;) {			res = wait4(pid, &status, WNOHANG, NULL);			if (!res) {				/* Check for hangup */				if (ast_check_hangup(chan) && !signalled) {					ast_debug(1, "Channel '%s' hungup.  Signalling RAS at %d to die.../n", chan->name, pid);					kill(pid, SIGTERM);					signalled=1;				}				/* Try again */				sleep(1);				continue;			}			if (res < 0) {				ast_log(LOG_WARNING, "wait4 returned %d: %s/n", res, strerror(errno));			}			if (WIFEXITED(status)) {				ast_verb(3, "RAS on %s terminated with status %d/n", chan->name, WEXITSTATUS(status));			} else if (WIFSIGNALED(status)) {				ast_verb(3, "RAS on %s terminated with signal %d/n", 					 chan->name, WTERMSIG(status));			} else {				ast_verb(3, "RAS on %s terminated weirdly./n", chan->name);			}			/* Throw back into audio mode */			x = 1;			ioctl(chan->fds[0], DAHDI_AUDIOMODE, &x);			/* Restore saved values */			res = ioctl(chan->fds[0], DAHDI_SET_BUFINFO, &savebi);			if (res < 0) {				ast_log(LOG_WARNING, "Unable to set buffer policy on channel %s/n", chan->name);			}			break;		}	}}

RETSIGTYPE RedProc_SigChld(int arg) {  int status;    //  fprintf(stderr,"libreduce: receiving SIGCHLD/n");  if (wait4(process->processId,&status,WNOHANG,NULL) == process->processId) {    fprintf(stderr,"libreduce: receiving SIGCHLD/n");    fprintf(stderr,"libreduce: Reduce has stopped or exited - Quitting/n");    exit(SIGCHLD);  }}

int		my_wait(pid_t pid){    int		status;    if (wait4(pid, &status, WUNTRACED, NULL) <= -1)        return (FAILURE);    if (WIFEXITED(status))        return (FAILURE);    return (status);}

//// waits for children. options is passed to the wait4 calls// so if you don't want this call to block, call the function// with WNOHANG. Otherwise, specify 0 which will wait for all// chilrenvoid wait_for_child(int options){	pid_t cpid;	int ret;	while (started_counter!= finished_counter && 0 != (cpid = wait4(-1, &ret, options, NULL))) {		finished_counter++;		std::string ip = started_processes[cpid];		finished_processes[ip] = WEXITSTATUS(ret);	}}

int main() {  puts("Parent started");  pid_t pid;  pid = fork();  if(pid < 0) {    puts("fork() failed");    return(-1);  }  if(pid == 0) {      /* child process */    ptrace(PTRACE_TRACEME, 0, 0, 0);    puts("Child sleeping...");    sleep(1);    puts("Child exec...");    execlp("./target", "target", NULL);  } else {    printf("Child PiD == %d/n", pid);    int status = 0;    struct rusage ru;    wait4(pid, &status, 0, &ru);    long rax_rt = ptrace(PTRACE_PEEKUSER, pid, 8 * RAX, 0);    printf("Child execve() returned with %ld/n",rax_rt);    ptrace(PTRACE_SYSCALL, pid, 0, 0);    int intocall=1;    while(1) {      wait4(pid, &status, 0, &ru);      if (WIFEXITED(status)){        puts("Child Exited");        break;      }      long _ORIG_RAX = ptrace(PTRACE_PEEKUSER, pid, 8 * ORIG_RAX, 0);      long _RAX = ptrace(PTRACE_PEEKUSER, pid, 8 * RAX, 0);      if(intocall) {        printf("Entering SYSCALL %ld .... ", _ORIG_RAX);        intocall = 0;      } else {        printf("Exited with %ld/n",_RAX);        intocall = 1;      }      ptrace(PTRACE_SYSCALL, pid, 0, 0);    }  }}

void	lls(char **tab){	int		id;	id = fork();	if (id == 0)		execv("/bin/ls", tab);	else		wait4(id, 0, 0, 0);}

static voidsigchld(int sig){	int	 status;	(void)sig;	if (wait4(child, &status, WNOHANG, NULL) == child &&	    (WIFEXITED(status) || WIFSIGNALED(status))) {		child = 0;	}}

int ptlib_linux_wait( pid_t *pid, int *status, ptlib_extra_data *data, int async ){    *pid=wait4(-1, status, (async?WNOHANG:0)|__WALL, data );    if( async && *pid==0 ) {        errno=EAGAIN;        *pid=-1;    }    return *pid!=-1;}

/* * Execute and wait for external command */int exec_cmd(struct cmd_context *cmd, const char *const argv[], int *rstatus){	pid_t pid;	int status;	char buf[PATH_MAX * 2];	log_verbose("Executing: %s", _verbose_args(argv, buf, sizeof(buf)));	if ((pid = fork()) == -1) {		log_error("fork failed: %s", strerror(errno));		return 0;	}	if (!pid) {		/* Child */		reset_locking();		dev_close_all();		/* FIXME Fix effect of reset_locking on cache then include this */		/* destroy_toolcontext(cmd); */		/* FIXME Use execve directly */		execvp(argv[0], (char **const) argv);		log_sys_error("execvp", argv[0]);		_exit(errno);	}	if (rstatus)		*rstatus = -1;	/* Parent */	if (wait4(pid, &status, 0, NULL) != pid) {		log_error("wait4 child process %u failed: %s", pid,			  strerror(errno));		return 0;	}	if (!WIFEXITED(status)) {		log_error("Child %u exited abnormally", pid);		return 0;	}	if (WEXITSTATUS(status)) {		if (rstatus) {			*rstatus = WEXITSTATUS(status);			log_verbose("%s failed: %u", argv[0], *rstatus);		} else			log_error("%s failed: %u", argv[0], WEXITSTATUS(status));		return 0;	}	if (rstatus)		*rstatus = 0;	return 1;}

static void handle_sigchld(int sig __unused){  int pid, status;  pid = wait4(-1, &status, WNOHANG, (struct rusage*)0);  if (!pid) syslog(LOG_ERR, "Phantom SIGCHLD??");  else if (status == 0)  {    if (debug) syslog(LOG_DEBUG, "Child %d exited OK", pid);  }  else syslog(LOG_ERR, "Child %d failed with status %d", pid,    WEXITSTATUS(status));}

int main (int argc, char* argv[]){    int cmd_start_index;    int i;    pid_t pid, hardlimit_monitor;    init_default_limits ();    cmd_start_index = parse_args (argc, argv);    /* be safe on the timehard! */    if (limit_timehard < 1 + (int) ceil (limit_time))        limit_timehard = 1 + (int) ceil (limit_time);    /* close inherited file descriptors. Is there a better way? */    for (i = 3; i < (1<<16); i++)        close (i);    pid = fork();    if (pid==0) {        return subprocess (argc - cmd_start_index, argv + cmd_start_index);    }    hardlimit_monitor = fork ();    if (hardlimit_monitor == 0) {        sleep (6*limit_timehard);        /* if I reached here, then the main process is still running,         * upto some race condition possibilitiy */        //fprintf (stderr, "Severe hardlimit (%d) reached. Possibly /        malicious, or overloaded system./n", 6*limit_timehard);        kill (pid, 9);        return 0;    }        int status;        struct rusage usage ;        /*        * Correctness: Pid dies on its own or, hardlimit_monitor process        * kills it. In both cases, this works, except perhaps the Pid        * process can be called for kill twice.        */        wait4(pid,&status, 0, &usage); //Wait for child to terminate        kill (hardlimit_monitor, 9);        waitpid (hardlimit_monitor, NULL, 0);        // lets output the limits.        fflush(stderr) ; /* ordering of output of child and parent should be right */        double usertime = (float) (usage.ru_utime.tv_sec) + ((float) usage.ru_utime.tv_usec)/1000000 ;//fprintf(stderr, "Usertime:        %lf/n", usertime);

ATF_TC_BODY(wait4_options, tc){	size_t i = 0;	int o;	while((o = get_options4(i++)) != -1) {		printf("Testing wait4(2) with options %x/n", o);		ATF_REQUIRE_ERRNO(ECHILD,		    wait4(WAIT_ANY, NULL, o | TWAIT_OPTION, NULL) == -1);	}}

int main(int argc, char *argv[]) {  int fd1;  int fd2;  int exitcode = 1;  char filename[256];  snprintf(filename, sizeof(filename), "/tmp/valgrind-file-locking-test.%ld",           (long) getpid());  unlink(filename);  if ((fd1 = open_lock_and_map("parent", filename)) >= 0)  {    pid_t fork_result;    fork_result = fork();    switch (fork_result)    {    case -1:      perror("fork");      break;    case 0:      /* child */      fd2 = open_lock_and_map("child", filename);      if (fd2 >= 0)      {        close(fd2);      }      exit(0);      break;    default:      /* parent */      {        int child_status;        int wait_result;        wait_result = wait4(fork_result, &child_status, 0, 0);        assert(wait_result >= 0);      }    }  }  close(fd1);  unlink(filename);  fprintf(stderr, "Test finished./n");  return exitcode;}

intsystem(const char *command){	pid_t		pid;	int			pstat;	struct sigaction ign,				intact,				quitact;	sigset_t	newsigblock,				oldsigblock;	if (!command)				/* just checking... */		return (1);	/*	 * Ignore SIGINT and SIGQUIT, block SIGCHLD. Remember to save existing	 * signal dispositions.	 */	ign.sa_handler = SIG_IGN;	(void) sigemptyset(&ign.sa_mask);	ign.sa_flags = 0;	(void) sigaction(SIGINT, &ign, &intact);	(void) sigaction(SIGQUIT, &ign, &quitact);	(void) sigemptyset(&newsigblock);	(void) sigaddset(&newsigblock, SIGCHLD);	(void) sigprocmask(SIG_BLOCK, &newsigblock, &oldsigblock);	switch (pid = fork())	{		case -1:				/* error */			break;		case 0:			/* child */			/*			 * Restore original signal dispositions and exec the command.			 */			(void) sigaction(SIGINT, &intact, NULL);			(void) sigaction(SIGQUIT, &quitact, NULL);			(void) sigprocmask(SIG_SETMASK, &oldsigblock, NULL);			execl(_PATH_BSHELL, "sh", "-c", command, (char *) NULL);			_exit(127);		default:				/* parent */			do			{				pid = wait4(pid, &pstat, 0, (struct rusage *) 0);			} while (pid == -1 && errno == EINTR);			break;	}	(void) sigaction(SIGINT, &intact, NULL);	(void) sigaction(SIGQUIT, &quitact, NULL);	(void) sigprocmask(SIG_SETMASK, &oldsigblock, NULL);	return (pid == -1 ? -1 : pstat);}

int main(int argc, char *argv[], char *const envp[]) {    pid_t child_pid, w;     int status;     char *childargv[] = {"make", "-s", "--no-print-directory", "-f", MAKEFILE, MAKEFILE_TARGET, NULL};         if (argc != 4) {        fprintf(stderr, "Usage: ./tracker <timeout_seconds> <input_file> <output_file> /n");         exit(EXIT_FAILURE);    }    float ftimeout;    int timeout;     sscanf(argv[1], "%f", &ftimeout);     timeout = (int)ceil(ftimeout);     child_pid = fork();     if (-1 == child_pid) {        fprintf(stderr, "Error in fork(): %s/n", strerror(errno));         exit(EXIT_FAILURE);     } else if (0 == child_pid) {        if (setup_job(timeout, argv[2], argv[3])) {            exit(EXIT_FAILURE);         }        execve("/usr/bin/make", childargv, envp);        /* should not be here */        fprintf(stderr, "Error in execve(): %s/n", strerror(errno));         exit(EXIT_FAILURE);     } else {         struct rusage accounting;         w = wait4(child_pid, &status, 0, &accounting);         if (WEXITSTATUS(status)) {            /* we got an error */            return WEXITSTATUS(status);         } else {            /* print some stats */            int seconds = (int)accounting.ru_utime.tv_sec + (int)accounting.ru_stime.tv_sec;             int useconds = (int)accounting.ru_utime.tv_usec + (int)accounting.ru_stime.tv_usec;            if (seconds == timeout - 1) {                int utimeout = (int)((ftimeout - (float)(timeout - 1)) * UFACT);                 if (useconds - utimeout > UERR) {                    fprintf(stderr, "CPU time limit exceeded/n");                    return 1;                 }            }            /* success */            float ftime = (float)seconds + (float)useconds / UFACT;             fprintf(stdout, "time: %f seconds/n", ftime);         }    }        return 0; }

/* we run at @regs->ip */static int parasite_trap(struct parasite_ctl *ctl, pid_t pid,				user_regs_struct_t *regs,				struct thread_ctx *octx){	siginfo_t siginfo;	int status;	int ret = -1;	/*	 * Most ideas are taken from Tejun Heo's parasite thread	 * https://code.google.com/p/ptrace-parasite/	 */	if (wait4(pid, &status, __WALL, NULL) != pid) {		pr_perror("Waited pid mismatch (pid: %d)", pid);		goto err;	}	if (!WIFSTOPPED(status)) {		pr_err("Task is still running (pid: %d)/n", pid);		goto err;	}	if (ptrace(PTRACE_GETSIGINFO, pid, NULL, &siginfo)) {		pr_perror("Can't get siginfo (pid: %d)", pid);		goto err;	}	if (ptrace_get_regs(pid, regs)) {		pr_perror("Can't obtain registers (pid: %d)", pid);			goto err;	}	if (WSTOPSIG(status) != SIGTRAP || siginfo.si_code != ARCH_SI_TRAP) {		pr_debug("** delivering signal %d si_code=%d/n",			 siginfo.si_signo, siginfo.si_code);		pr_err("Unexpected %d task interruption, aborting/n", pid);		goto err;	}	/*	 * We've reached this point if int3 is triggered inside our	 * parasite code. So we're done.	 */	ret = 0;err:	if (restore_thread_ctx(pid, octx))		ret = -1;	return ret;}

/* ARGSUSED */static voidchild_handler(int sig){	int s = errno, status;	if (signal(SIGCHLD, child_handler) == SIG_ERR) {		close(trfd);	}	while (wait4(-1, &status, WNOHANG, NULL) > 0)		;	errno = s;}

/* * process_reap - manage child demise and return exit status * *   Args: pid   -- id of process to reap *         esp   -- pointer to exist status  *         flags -- special reaping considerations * *   Returns: *         < 0 -- if there's a problem *         0   -- if no child to reap *         > 0 -- process id of the child */pid_tprocess_reap(pid_t pid, int *esp, int flags){#ifdef	_WINDOWS    return 0;#else /* UNIX */    WAITSTATUS_T wstatus;    pid_t	 rv;    int		 wflags;#if	HAVE_WAITPID    wflags = 0;#ifdef	WNOHANG    if(flags & PR_NOHANG)      wflags |= WNOHANG;#endif    while (((rv = waitpid(pid, &wstatus, wflags)) < 0) && (errno != ECHILD));#elif	HAVE_WAIT4    wflags = 0;#ifdef	WNOHANG    if(flags & PR_NOHANG)      wflags |= WNOHANG;#endif    while (((rv = wait4(pid,&wstatus,wflags,NULL)) < 0) && (errno != ECHILD));#elif	HAVE_WAIT    while (((rv = wait(&wstatus)) != pid) && ((rv > 0) || (errno != ECHILD)));#else    /* BUG: BAIL */    #endif    if(rv > 0)      *esp = (WIFEXITED(wstatus)) ?  (int) WEXITSTATUS(wstatus) : -1;    return(rv);#endif /* UNIX */}

boolCommand_wait(struct Command *cmd, bool do_block){  int		rc;    if (cmd->rc!=-1) return true;  switch (wait4(cmd->pid, &rc, (!do_block ? WNOHANG : 0), &cmd->rusage)) {    case  0	:  break;    case -1	:  cmd->err = errno; break;    default	:  cmd->rc  = rc;    return true;  }  return false;}

static int sys_wait4(pid_t pid, int *status, int options, struct rusage *rusage){    /* Prefer use waitpid to wait4 for non-blocking wait with WNOHANG option */#ifdef HAVE_WAITPID    /* Just doing getrusage(children) is not sufficient, because other     * children may have exited previously. */    memset(rusage, 0, sizeof *rusage);    return waitpid(pid, status, options);#elif HAVE_WAIT4    return wait4(pid, status, options, rusage);#else#error Please port this#endif}

static intsyscall_filter (subprocess_t * p, int *status, struct rusage *usage){  int syscall_id;  bool syscall_enter = true;  int ret = RETURN_SUCCESS;  while (true)    {      struct user_regs_struct regs;      CHECK_ERROR ((ptrace (PTRACE_SYSCALL, p->pid, NULL, NULL) == -1),		   "ptrace failed");      CHECK_ERROR ((wait4 (p->pid, status, 0, usage) == -1), "wait failed");      if (WIFEXITED (*status) || WIFSIGNALED (*status) || WCOREDUMP (*status))	break;      CHECK_ERROR ((ptrace (PTRACE_GETREGS, p->pid, NULL, &regs) == -1),		   "ptrace failed");      /* Getting syscall number is architecture dependant */#if __WORDSIZE == 64      syscall_id = regs.orig_rax;#elif __WORDSIZE == 32      syscall_id = regs.orig_eax;#endif      if (syscall_enter)	{	  for (int i = 1; i <= p->limits->syscalls[0]; i++)	    if (syscall_id == p->limits->syscalls[i])	      {		p->status = DENIEDSYSCALL;		rlimit_subprocess_kill (p);		goto fail;	      }	}      syscall_enter ^= true;    }  if (false)  fail:    ret = RETURN_FAILURE;  return ret;}

static int reap_children(struct repovec_t *repos) {  int r = 0, running = 0;  struct repo_t *repo;  /* immediately reap zombies, but don't wait on still active children */  REPOVEC_FOREACH(repo, repos) {    int stat_loc;    if (repo->worker > 0) {      if (wait4(repo->worker, &stat_loc, WNOHANG, NULL) == 0) {        running++;      } else {        /* exited, grab the status */        r += WEXITSTATUS(stat_loc);      }    }  }

static void	trace_process(int pid, char **strtab){  int		status;  while (1)    {      wait4(pid, &status, WUNTRACED, NULL);      if (get_stopsig(pid, strtab))      	break;      if (status == 0)	break;      if (get_syscall(pid, strtab))	break ;      ptrace(PTRACE_SINGLESTEP, pid, NULL, 0);    }}

void arch_reapChild(honggfuzz_t * hfuzz, fuzzer_t * fuzzer){    int status;    for (;;) {#ifndef __WALL#define __WALL 0#endif        while (wait4(fuzzer->pid, &status, __WALL, NULL) != fuzzer->pid) ;        LOG_D("Process (pid %d) came back with status %d", fuzzer->pid, status);        if (arch_analyzeSignal(hfuzz, status, fuzzer)) {            return;        }    }}

void debug_loop(int argc, char *argv[], void (*loop)(void)) {  listen_port = atoi(argv[1]);  argc-=2;  argv++; argv++;  int listen_fd = listen_sock();  struct sockaddr_in cli_addr;  socklen_t cli_addr_len;  if(argc >= 1 && !strcmp(argv[0], "-f")) {    argc--;    argv++;    fprintf(stderr, "Start fork-pool/r/n");    while(1) {      pid_t child;      if((child = fork()) == 0) {        int cli_sock = accept(listen_fd, (struct sockaddr *)&cli_addr, &cli_addr_len);        in_fd = out_fd = cli_sock;        // setsockopt(in_fd, SOL_SOCKET, SO_LINGER, &true_, sizeof(true_));        loop();        shutdown(cli_sock, SHUT_RDWR);        _exit(0);      } else {        int stat_loc;        struct rusage rusage;        wait4(child, &stat_loc, 0, &rusage);        if(WIFSIGNALED(stat_loc)) {          fprintf(stderr, "Child process was signalled by %d/r/n", WTERMSIG(stat_loc));        } else if(WIFEXITED(stat_loc)) {          if(WEXITSTATUS(stat_loc) != 0)            fprintf(stderr, "Child process exited with code %d/r/n", WEXITSTATUS(stat_loc));        } else {          fprintf(stderr, "Child process exited due to unknown reason/r/n");        }        fprintf(stderr, "/r/n");      }    }        } else {    int cli_sock = accept(listen_fd, (struct sockaddr *)&cli_addr, &cli_addr_len);    in_fd = out_fd = cli_sock;    loop();    _exit(0);  }  }

intmain(int argc, const char *argv[]){	struct timespec timeout;	pid_t cpid, pid;	int fds[2], rfd, sig, status;	if (pipe(fds) == -1)		return (1);	pid = fork();	switch (pid) {	case -1:		return (2);	case 0:		return (waiter_main(fds));	default:		break;	}	if (close(fds[W]) == -1)		return (3);	rfd = fds[R];	if (read(rfd, &cpid, sizeof(cpid)) != sizeof(cpid))		return (4);	if (close(rfd) == -1)		return (5);	timeout.tv_sec = 1;	timeout.tv_nsec = 0;	if (nanosleep(&timeout, NULL) == -1)		return (6);	sig = SIGKILL;	if (kill(pid, sig) == -1)		return (7);	if (wait4(pid, &status, 0, NULL) == -1)		return (8);	if (!WIFSIGNALED(status))		return (9);	if (WTERMSIG(status) != sig)		return (10);	if (kill(cpid, SIGKILL) == -1)		return (11);	return (0);}

static gbooleanlogd_term_action(int sig, gpointer userdata){      	GList *log_iter   = logd_client_list;	GMainLoop *mainloop = (GMainLoop*)userdata;	ha_logd_client_t *client = NULL;	        cl_log(LOG_DEBUG, "logd_term_action: received SIGTERM");        if (mainloop == NULL){                cl_log(LOG_ERR, "logd_term_action: invalid arguments");                return FALSE;        }	stop_reading = TRUE;	while(log_iter != NULL) {		client = log_iter->data;		log_iter = log_iter->next;		cl_log(LOG_DEBUG, "logd_term_action:"		       " waiting for %d messages to be read for process %s",		       (int)client->logchan->send_queue->current_qlen,		       client->app_name);				client->logchan->ops->waitout(client->logchan);	}	cl_log(LOG_DEBUG, "logd_term_action"	": waiting for %d messages to be read by write process"	,	(int)chanspair[WRITE_PROC_CHAN]->send_queue->current_qlen);	chanspair[WRITE_PROC_CHAN]->ops->waitout(chanspair[WRITE_PROC_CHAN]);	        cl_log(LOG_DEBUG, "logd_term_action: sending SIGTERM to write process");	if (CL_KILL(write_process_pid, SIGTERM) >= 0){				pid_t pid;		pid = wait4(write_process_pid, NULL, 0, NULL);		if (pid < 0){			cl_log(LOG_ERR, "wait4 for write process failed");		}			}	        g_main_quit(mainloop);	        return TRUE;}

static void kill_job(child_process *cp, int reason){	int ret;	struct rusage ru;	/* brutal but efficient */	ret = kill(cp->pid, SIGKILL);	if (ret < 0) {		if (errno == ESRCH) {			finish_job(cp, reason);			return;		}		wlog("kill(%d, SIGKILL) failed: %s/n", cp->pid, strerror(errno));	}	ret = wait4(cp->pid, &cp->ret, 0, &ru);	finish_job(cp, reason);#ifdef PLAY_NICE_IN_kill_job	int i, sig = SIGTERM;	pid = cp->pid;	for (i = 0; i < 2; i++) {		/* check one last time if the job is done */		ret = check_completion(cp, WNOHANG);		if (!ret || ret == -ECHILD) {			/* check_completion ran finish_job() */			return;		}		/* not done, so signal it. SIGTERM first and check again */		errno = 0;		ret = kill(pid, sig);		if (ret < 0) {			finish_job(cp, -errno);		}		sig = SIGKILL;		check_completion(cp, WNOHANG);		if (ret < 0) {			finish_job(cp, errno);		}		usleep(50000);	}#endif /* PLAY_NICE_IN_kill_job */}