I need to make sure that from the moment I find the process to when I kill it, no other process has the CPU. Can this be done?

This is the exact problem I am trying to avoid. Since everyone seems to agree that there is no easy 100% safe way to bypass the CPU scheduler, I will just double check right before I kill the PID (as danielcid recommends) and that should be enough. I am running on a winxp system and there is very little time between finding the PID and killing it. FYI: I use Win32::ToolHelp (to find by name) and Win32::Process (to kill by PID).

thanks, Kevin

Assuming that you are using the "cookbook" method;

use Config;
defined $Config{sig_name} or die "No sigs?";
$i = 0;                     # Config prepends fake 0 signal called "ZE
+RO".
foreach $name (split(' ', $Config{sig_name})) {
    $signo{$name} = $i;
    $signame[$i] = $name;
    $i++;
}
[download]

You should be able to send the kill command to a name -or- PID. This should solve your problem (or am I missing the point of your question?)

Which operating system do you use?

What do you know about the process you search for? If it's not its PID then there is no way to do it in an atomic operation. Tools like pgrep, pkill and killall search within the proc filesystem and can't be atomic.

Don't worry about your same PID problem. Linux for example uses 32768 different PID values. See and change PID_MAX_DEFAULT in include/linux/threads.h if that's not enough for you.

-- Frank

However, I think it's worth pointing out that the situation you describe is exceedingly unlikely to occur. Most operating systems don't start reusing PIDs until they reach their maximum PID, which is generally a long time even for a very fast system.

-sam

Most systems I've used _seemed_ to avoid reusing a PID at least for a little while. If this is true and your find/kill sequence is short enough, this should get you 99.99% there.

If you have root priviledge and the process you are trying to kill is owned by a non-root user, you could setuid to the user and then perform the kill. Of course this won't help if the same user gets the reused PID quickly enough.

Note that on OpenBSD and Linuces that have the "pid randomization patch" applied, they could, in theory, reuse a pid as soon as the old process that used it goes away. This is because they don't cycle through pids, they just randomly pick an unused one when the old goes away. However, collisions relating to this are bound to be quite rare.

It can help /only/ if the "time of check" and the "time
to use" are very close. However, if this program is doing
many things in the meanwhile (like checking other
process, reading a file, etc), renicing is not going to
help.

[]'s
DBC

You could also be notified with SIGCHLD whenever your child exits, if you do it in reverse.

I don't know of a way to do what you want reliably, but there are many other ways to get the same results.

There may be a way to achieve a "safe kill" on windows. There is an API OpenProcess that allows (with appropriate privalege) one process to obtain a system handle to another running process.

In my experiments, if one process (the killer) obtains a handle to another process (the killee), whilst it does not stop the latter dieing or being killed, it seems to prevent the process id for that process being re-used before the killer relingishes it's grip on the system handle returned by the API.

You'll understand this is a bit vague. Verifying that this is true is very difficult. My attempt was:

I started a copy of perl, found out it's pid.

Ran the following script to obtain and hold onto a system handle to that pid.

#! perl -slw
use strict;
use Win32::API::Prototype;
use constant PROCESS_TERMINATE => 1;

ApiLink( 'Kernel32',
    'HANDLE OpenProcess( DWORD dwDesiredAccess, BOOL bInheritHandle, D
+WORD dwProcessId )'
) or die $^E;

ApiLink( 'Kernel32',
    'BOOL TerminateProcess( HANDLE hProcess, UINT uExitCode )'
) or die $^E;

if( my $hProc = OpenProcess( PROCESS_TERMINATE, 0, $ARGV[ 0 ] ) ) {
    print "Got handle to process; Can you kill it?"; 
    die 'Drat' if <STDIN> =~ m[^y]i;
    print "I'll try";
    print TerminateProcess( $hProc, -1 ) 
        ? 'It sleeps with da fishies!'
        : 'Double drat!';
    
} 
else {
    print "OpenProcess failed: $^E";
}
[download]

I then killed the first copy of perl and left the second holding the handle.

I started a third copy of perl that constantly spawned new processes (I created a tiny dummy executable int main () { return 0; } for speed), that recorded and yelled if the process id of the first process had, was reused:

do{ 
    my $pid = open my $in, "p:/test/dummy.exe |" 
        or die $!; 
    $pid{ $pid }++; 
    printf "\r%7d : $pid    ", scalar keys %pid; 
    print " Reused\n\n" if $pid == 65992 ## The first pid
} for 1 .. 1_000_000;
[download]

I allowed this to run whilst I watch a movie. The pid was never re-used. I then killed the second process that was holding the system handle to the defunct first process. It's pid was then re-used twice within less than a minute.

  14281 : 65992     Reused


  19112 : 65992     Reused


  19112 : 60132    Terminating on signal SIGINT(2)
[download]

Far from definitive proof, and if it is true, it isn't the complete picture as there still remains the task of ensuring that the pid to which you obtained the handle is the same process as it was when you obtained the PID in the first place...