<!-- category: hidden-gems -->

kill 0 for Process Existence Checks

2026-04-26

if (kill 0, $pid)
{
    say "Process $pid exists";
}

One function call. One return value. Done.

Part 1: WHAT SIGNAL 0 MEANS

my $result = kill 0, $pid;

# $result == 1  ->  process exists and you can signal it
# $result == 0  ->  process doesn't exist OR you can't signal it

The kill function in Perl returns the number of processes successfully signaled. For a single PID with signal 0, that's either 1 (exists and you have permission) or 0 (doesn't exist or permission denied).

Part 2: RETURN VALUE SEMANTICS

my $pid = 12345;

if (kill 0, $pid)
{
    say "PID $pid exists and we can signal it";
}
else
{
    say "PID $pid either doesn't exist or we can't signal it";
}

1. The process does not exist (it died or was never created)
2. The process exists but you don't have permission to signal it

To tell them apart, check $! after a failure:

use Errno qw(ESRCH EPERM);

if (!kill 0, $pid)
{
    if ($! == ESRCH)
    {
        say "No such process: $pid";
    }
    elsif ($! == EPERM)
    {
        say "Process $pid exists but we can't signal it (permission denied)";
    }
    else
    {
        say "Unexpected error checking PID $pid: $!";
    }
}

This distinction matters. A monitoring script running as a regular user checking a root-owned daemon will get EPERM when the daemon is running and ESRCH when it's dead. Both return 0 from kill, but they mean opposite things.

Part 3: PRACTICAL PID FILE VALIDATION

sub is_daemon_running
{
    my ($pid_file) = @_;

    open my $fh, '<', $pid_file or return 0;
    my $pid = <$fh>;
    close $fh;

    chomp $pid;
    return 0 unless $pid =~ m~^\d+$~;
    return 0 unless $pid > 0;

    return kill 0, $pid;
}

if (is_daemon_running("/var/run/myapp.pid"))
{
    say "Daemon is running";
}
else
{
    say "Daemon is stopped (or stale PID file)";
}

A more thorough version checks that the PID belongs to the right process, not just any process that happened to reuse the PID:

sub validate_pid_file
{
    my ($pid_file, $process_name) = @_;

    open my $fh, '<', $pid_file or return (0, "no PID file");
    my $pid = <$fh>;
    close $fh;

    chomp $pid;
    return (0, "invalid PID in file") unless $pid =~ m~^\d+$~;

    if (!kill 0, $pid)
    {
        unlink $pid_file;    # clean up stale PID file
        return (0, "process $pid not found (stale PID file removed)");
    }

    # verify it's the right process (Linux-specific)
    if (-r "/proc/$pid/cmdline")
    {
        open my $cmd_fh, '<', "/proc/$pid/cmdline" or return (1, "running");
        my $cmdline = <$cmd_fh>;
        close $cmd_fh;

        if ($cmdline !~ m~\Q$process_name\E~)
        {
            return (0, "PID $pid is not $process_name (PID reuse)");
        }
    }

    return (1, "running as PID $pid");
}

my ($ok, $msg) = validate_pid_file("/var/run/nginx.pid", "nginx");
say "$msg";

Part 4: PROCESS MONITORING LOOPS

#!/usr/bin/env perl
use strict;
use warnings;
use feature 'say';
use POSIX qw(strftime);

my $pid_file = $ARGV[0] or die "Usage: $0 <pid_file>\n";
my $check_interval = 10;    # seconds

say "Monitoring PID file: $pid_file";

while (1)
{
    if (!-f $pid_file)
    {
        say timestamp() . " PID file missing!";
        sleep $check_interval;
        next;
    }

    open my $fh, '<', $pid_file or do
    {
        warn timestamp() . " Cannot read $pid_file: $!\n";
        sleep $check_interval;
        next;
    };

    my $pid = <$fh>;
    close $fh;
    chomp $pid;

    if (kill 0, $pid)
    {
        # process is fine, check again later
    }
    else
    {
        say timestamp() . " Process $pid is DOWN!";
        # could trigger restart, send alert, etc.
        restart_daemon();
    }

    sleep $check_interval;
}

sub timestamp
{
    return strftime("%Y-%m-%d %H:%M:%S", localtime);
}

sub restart_daemon
{
    say timestamp() . " Restarting daemon...";
    system("systemctl restart myapp");
}

Part 5: MULTIPLE PID CHECKS

my @pids = (1001, 1002, 1003, 1004);
my $alive = kill 0, @pids;

say "$alive out of " . scalar(@pids) . " processes are alive";

sub check_workers
{
    my (@pids) = @_;
    my @alive;
    my @dead;

    for my $pid (@pids)
    {
        if (kill 0, $pid)
        {
            push @alive, $pid;
        }
        else
        {
            push @dead, $pid;
        }
    }

    return (\@alive, \@dead);
}

my @workers = (4501, 4502, 4503, 4504);
my ($alive, $dead) = check_workers(@workers);

say "Alive: " . join(", ", @$alive);
say "Dead:  " . join(", ", @$dead);

Part 6: COMPARISON TO /proc/$pid ON LINUX

# Linux-specific
if (-d "/proc/$pid")
{
    say "Process exists";
}

METHOD             PORTABLE?    PERMISSION CHECK?    RACE SAFE?
kill 0, $pid       Yes (POSIX)  Yes                  No*
-d "/proc/$pid"    Linux only   No                   No*
parse `ps` output  Sort of      No                   No*

* None of them are truly race-safe. The process
  can die between the check and your next action.

kill 0 also tells you about permissions. If the process exists but you can't signal it, $! is EPERM. The /proc check doesn't distinguish between "exists but not mine" and "exists and is mine."

Part 7: RACE CONDITIONS

if (kill 0, $pid)
{
    # process existed a microsecond ago
    # it might be dead by now
    kill 'TERM', $pid;    # might signal the wrong process!
}

For most monitoring and health-check purposes, this doesn't matter. You're checking periodically. If the process dies between checks, you'll catch it on the next round.

For critical operations like "send SIGTERM to this specific process," the race condition is real but unavoidable. There is no atomic "check and signal" operation in POSIX. The standard approach is to accept the race and handle errors:

if (!kill 'TERM', $pid)
{
    if ($! == ESRCH)
    {
        say "Process already gone";
    }
    else
    {
        warn "Failed to signal $pid: $!";
    }
}

Part 8: REAPING ZOMBIES

A zombie is a process that has exited but hasn't been reaped by its parent. It still has an entry in the process table. The kernel keeps it around so the parent can call waitpid and collect the exit status.

my $pid = fork();

if ($pid == 0)
{
    # child: exit immediately
    exit 0;
}

# parent: child is now a zombie
sleep 1;

if (kill 0, $pid)
{
    say "PID $pid exists";    # true! it's a zombie
}

# reap the zombie
waitpid($pid, 0);

if (kill 0, $pid)
{
    say "still exists";       # false now
}
else
{
    say "gone after reap";    # this prints
}

For processes you didn't fork (like checking a daemon's PID file), zombies are someone else's problem. The daemon's parent should be reaping its children.

Part 9: BUILDING A SIMPLE LOCKFILE

use Fcntl qw(:flock);

sub acquire_lock
{
    my ($lock_file) = @_;

    # check for existing lock
    if (-f $lock_file)
    {
        open my $fh, '<', $lock_file or return 1;    # can't read, assume unlocked
        my $old_pid = <$fh>;
        close $fh;
        chomp $old_pid;

        if ($old_pid =~ m~^\d+$~ && kill 0, $old_pid)
        {
            die "Already running as PID $old_pid\n";
        }

        # stale lock file, remove it
        unlink $lock_file;
    }

    # write our PID
    open my $fh, '>', $lock_file or die "Cannot create lock: $!\n";
    print $fh "$$\n";
    close $fh;

    return 1;
}

sub release_lock
{
    my ($lock_file) = @_;
    unlink $lock_file;
}

# usage
acquire_lock("/tmp/myapp.lock");

# do work...
say "Working as PID $$";

release_lock("/tmp/myapp.lock");

Part 10: THE TAKEAWAY

+---------------------------------+
|  kill 0, $pid                   |
|                                 |
|  Returns 1: process exists,    |
|             you can signal it   |
|                                 |
|  Returns 0: check $!           |
|    ESRCH -> no such process    |
|    EPERM -> exists, not yours  |
+---------------------------------+

  "The quietest kill is no kill
   at all. Signal zero asks the
   question without pulling the
   trigger."

      .--.
     |o_o |
     |:_/ |
    //   \ \
   (|     | )
  /'\_   _/`\
  \___)=(___/

perl.gg