I have a supervisor process that creates child processes and monitors them with waitid() (this seems to be the most efficient means to monitor a child process to see if it crashes as far as I know).

However, if the supervisor process crashes or gets restarted/reloaded deliberately, it can no longer monitor the pid's of the "child" processes because they don't belong to the newly restarted supervisor process. btw, I'm keeping the pid's of the child process in a shared mem region so that they can be read by the restared supervisor process.

Is there efficient means of checking if a process is still running through its pid? Other than going through the /proc system which seems to me would be quite inefficient(?)

thank you

The easiest way is to create a file for each process, and have it contain only
the PID. The supervisor can then cat the contents of each file to find each
PID, and you can easily test whether or not that process is still alive.

1 members found this post helpful.

Thank you for the reply.

However, I already have the PID's in a shared mem region, so I don't need to keep another file containing the PID.

What I think I'm looking for is either a way to "re-inherit" a child process back when the supervisor process restarts (in this case re-inheriting from init, since the supervisor is spawned by init), or find an efficient means of determining if a non-child process is still running (checking a list of processes once per second). There's got be a syscall somewhere that allows one process to efficiently check for the existence of a process by PID, I would hope!

One thought I had was to open a file descriptor for /proc/<pid> and do read's on the fd until there is an error on the read, but I'll have to try to see if this works on not. This can't be much worse than calling waitid() I would think.

Thank you!

A coworker sent me a link to some code that used the kill(pid, 0) to check for a process. If an error is returned and errno == ESRCH, then the process does not exist. So this seems to work great.

Thanks for your help.

I use [ `ps -uww <PID> | grep <cmdname> >/dev/null` ] to test if a given
PID is running the expected command.

I'm curious about your coworker's solution.

There were two parts to the problem.

First, the supervisor has to be able to check the status of a process whether its a child or not. Using kill(pid, 0) will allow the supervisor to do this.

However, if the child process crashes and becomes a zombie, the kill() still returns success, but if the supervisor is not the parent (because it got restarted), it can't do a waidid() on the child of the previous supervisor process to "kill" the zombie because waitid() only works for child processes.

Therefore, the supervisor has to do a sigaction(), setting the sa_flags = SA_NOCLDWAIT, which means that a child process will not create a zombie if it crashes.

This way, the supervisor can call kill(pid, 0) and get the correct status of the process, whether its a child or not.

That's my solution and I'm sticking to it (for now).

Thanks.