Proper Implementation of Child Process Termination Upon Parent Exit

Fundamental Principles of Process Parent-Child Relationships

In Unix/Linux systems, processes establish hierarchical structures through parent-child relationships. When a parent process exits, child processes are not automatically terminated but are instead adopted by the init process (PID 1) as orphan processes. This design allows background tasks to continue running after user sessions end, but in certain scenarios, we need to ensure child processes exit along with their parent.

Linux-Specific Solution: PR_SET_PDEATHSIG

The Linux kernel provides the PR_SET_PDEATHSIG option in the prctl system call, which represents the most elegant solution. This mechanism allows child processes to register a signal that the kernel will automatically send when the parent process exits.

Implementation code example:

#include <sys/prctl.h>
#include <signal.h>
#include <unistd.h>

int main() {
    pid_t pid = fork();
    
    if (pid == 0) {
        // Child process code
        prctl(PR_SET_PDEATHSIG, SIGHUP);
        
        // Child process business logic
        while(1) {
            // Work code
            sleep(1);
        }
    } else if (pid > 0) {
        // Parent process code
        sleep(5);  // Simulate parent work
        // Parent process exits
    }
    
    return 0;
}

In this example, the child process registers the SIGHUP signal through prctl(PR_SET_PDEATHSIG, SIGHUP). When the parent process exits for any reason, the kernel sends SIGHUP to the child process, whose default behavior is process termination.

Mechanism Deep Dive

The working principle of PR_SET_PDEATHSIG is based on Linux kernel's process management mechanism:

• The kernel maintains the parent process PID for each process
• When detecting parent process exit, it checks if the child has set a death signal
• If set, the kernel sends the specified signal to the child process
• Signal delivery follows standard signal handling mechanisms

Advantages of this approach include:

• Completely handled by the kernel, no additional inter-process communication required
• Applicable to various parent exit scenarios (normal exit, signal kill, assertion failure, etc.)
• Minimal performance overhead

Cross-Platform Compatibility Considerations

It's important to note that PR_SET_PDEATHSIG is a Linux-specific feature. On other Unix variants like macOS and BSD systems, different approaches are necessary.

The test program in the reference article verifies standard Unix behavior: after parent process exit, child processes are adopted by the init process. This demonstrates that in most Unix systems, child processes do not automatically exit with their parent.

POSIX-Compliant Alternative Approaches

For scenarios requiring cross-platform compatibility, polling-based methods can be employed:

#include <unistd.h>
#include <sys/types.h>

void check_parent_exit() {
    while(1) {
        if (getppid() == 1) {
            // Parent has exited, adopted by init
            exit(0);
        }
        sleep(1);  // Check every second
    }
}

int main() {
    pid_t pid = fork();
    
    if (pid == 0) {
        // Run parent check in separate thread
        check_parent_exit();
        
        // Child process main logic
        while(1) {
            // Work code
        }
    }
    
    return 0;
}

While this approach is less elegant than the kernel-based solution, it offers good portability. The disadvantages include polling overhead and some delay in responding to parent process exit.

Best Practices for Signal Handling

When using PR_SET_PDEATHSIG, appropriate signal selection is recommended:

• SIGHUP: Traditionally used for terminal disconnection, suitable for most scenarios
• SIGTERM: Allows processes to perform cleanup operations
• SIGKILL: Immediate termination, cannot be caught or ignored

For custom cleanup logic, signal handlers can be established:

#include <signal.h>

void cleanup_handler(int sig) {
    // Perform cleanup operations
    // Close file descriptors
    // Release resources
    exit(0);
}

int main() {
    // Set up signal handling
    signal(SIGHUP, cleanup_handler);
    
    // Register parent death signal
    prctl(PR_SET_PDEATHSIG, SIGHUP);
    
    // Child process logic
    return 0;
}

Practical Application Scenarios

This technique finds important applications in various system programming contexts:

• Monitoring processes need to ensure exit when monitored processes exit
• Worker process managers need to clean up all child processes
• Testing frameworks need to ensure complete test process termination
• Service daemons need to manage their worker processes

Conclusion

In Linux environments, prctl(PR_SET_PDEATHSIG, signal) represents the optimal solution for ensuring child processes exit with their parent, leveraging kernel-level process management mechanisms to provide reliable and efficient functionality. For cross-platform compatibility requirements, polling-based parent PID checking offers a viable alternative. Developers should choose appropriate technical solutions based on specific requirements and application environments.