• wait() API
• waitpid() API
• Sample Code
• Difference between wait() and waitpid()

wait() API()

• The wait() function suspends the execution of the calling process until one of its child terminates or was stopped by a signal or resumed by a signal.
• In the case of fork() API, a child process is created which has its life cycle and runs independently.
• If the parent process happens to terminate before the child process, the child process becomes orphan and gets re-parented by the Init process.
• If the child process terminates and the parent process does not remove its entry is still there in the process control block(PCB), it is considered as a Zombie process.
• Using wait(), parents process can get the exit status of the child process and can remove its entry and can avoid zombie process.
• If the parent process calls wait() API, and the child has already terminated it returns immediately without blocking the caller, and the return value is -1.
• If the parent process calls wait() and none of the child processes has terminated, the parent process is blocked indefinitely. Thus wait() API is a blocking call.
• On success, it returns the process ID(PID) of the terminated child.

Syntax:

pid_t wait (int *status);

The stat_loc points to a location where the exit status of the child process will be written if it is not NULL.

This integer can be inspected using the WIFEXITED and WEXITSTATUS macros.

WIFEXITED(stat_var) : Non-zero if the child is terminated normally and

WEXITSTATUS(sta_var) : It holds exit status if WIFEXITED is non-zero.

Return Value:

• It returns -1 in case of failure that is there is no child process.
• It returns the PID of the child terminated if there is a child and anyone has terminated.
• If non of the child has terminated, return nothing and the caller is blocked.

Sample Program

#include <stdio.h>
#include <unistd.h>
#include <string.h>
#include <errno.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/wait.h>

int main()
{
  int pid = fork();
  switch(pid)
  {
     case -1:
           printf("\n There is a failure in creating a child process");
           exit(1);
     case 0:
           printf("\n This is a child Process\n");
           break;
     default:
           printf("\n This is a parent Process\n");
           break;
   }

/* This section of program waits for the child to finish */
   if (pid !=0) /* It is parent process */
   {
        int stat_val;
        int child_pid = wait(&stat_val);
        if (child_pid == -1)
        {
           printf("\n There is no child process \n");
           exit(1);
        }
        
        if (WIFEXITED(stat_val))
            printf("\n Child exited normally with return status %d\n", WEXITSTATUS(stat_val));
        else
            printf("\n Child terminated Abnormally");
    }
  }  

waitpid()

• The waitpid() API suspends the execution of the caller process until a child specified by PID argument has either terminated or signaled to stop or resume.
• The call wait() is equivalent to waitpid ( -1, &status, 0).
• By default, waitpid() waits only for the terminated child, not for the signaled child but this can be changed by the use of options.
• The most important option is WNOHANG, which makes waitpid() a non-blocking call.

Syntax:

int waitpid( int pid, int * stat_var, int options);

Where

PID is the process id of the child to wait for termination or signaled.

The stat_loc points to a location where the exit status of the child process will be written if it is not NULL.

This integer can be inspected using the WIFEXITED and WEXITSTATUS macros.

WIFEXITED(stat_var): Non-zero if the child is terminated normally and

WEXITSTATUS(sta_var): It holds exit status if WIFEXITED is non-zero.

The most important option is WNOHANG which makes it non-blocking.

Return Value:

• It returns -1 in the case of failure that is there is no child process.
• It returns PID of the child terminated on success and
• Return 0 if the child exists but not terminated or stopped(used with WNOHANG)

Pid passed to function can have the following values:

• If the pid >0, means waits for specific process with value equal to pid.
• If the pid is 0, waits for child whose process group id equals that of calling process.
• If the pid is -1, wait for any child that is first terminating child.
• If the pid <-1, waits for child process whose group id is equals to absolute value of pid.

Difference between wait and waitpid():

• Wait() is a blocking call whereas waipid() can be made non-blocking with WNOHANG option.
• Wait() waits for any child process but waitpid() waits for a specific child equal to pid.
• By default waitpid() waits for the only terminated child where as wait() waits for both terminated or a signaled child.

Diag-1: wait() and waitpid()

Related Posts:

• fork() API
• Termination of a process
• Zombie, Daemon and Orphans process

Categories: Operating system (OS)