The best you can do is either change the kernel to accomodate your desires (you could probably write a module) or you could implement that bit of code in C to reduce the amount of time you linger.

In perl, I would rewrite your code so that you open all the files first, then read from them one by one. In most unices, a file won't 'disappear' until the last file handle is closed.

foreach my $d(readdir(PROC)){
        next if $d !~ /^[0-9]+$/;

        my $procdir = "/proc/$d";
        open($filehandles{$procdir}, "<", $procdir/status") || warn "c
+an't open status with$procdir";
}
foreach my $fh ( keys %filehandles ) {
        while(<$fh>){
            @a = split(/\s+/, $_) if /Uid/;
            $temp[0] = $a[1];
            @b = split(/\s+/, $_) if /VmSize/;
            $temp[1] = $b[1];
        }
close $fh;
}
[download]

____________________
Jeremy
I didn't believe in evil until I dated it.

The first thing that comes to mind for me is 'locking' the directory. Do you get this error quite often? If this is happening because the files in this directory are changing quite rapidly, then I would suggest doing a lock of some kind on the directory while you fiddle around with it.

Note that this method only works if any and all programs that modify files in this directory follow this locking mechanism. For example, if this were a directory that users FTP files to and can delete files (from FTP) from this directory, this method simply would not work as desired because the users' FTP clients are not going to know that your lock exists, let alone how to go about gaining this lock. Having said that, here's how you'd do it:

Use a semaphore file to 'lock' the directory. Note the quotes around the word 'lock', because this does not deny any program access to the directory. If a program wants to walk in and change files, it is free to do so. The thought behind using a semaphore file is this: every single time you plan on modifying a file within the directory, you open a file for writing, lock it with Perl flock() command and then go about your business. Example code (untested):

#!/usr/bin/perl -w
use strict;
use Fcntl ':flock';

my $dir_path  = '/home/snam/subdir';
my $lock_file = $dir_path . '/lock.lck';

# Get a 'directory lock' (note the quotes again) :)
open LOCK, '>', $lock_file
  or die "Could not lock directory '$dir_path': $!";
flock LOCK, LOCK_EX;

# Now do whatever you want with this directory.
# If all programs use the locking mechanism, they
# won't have access to this directory until you execute
# a line that says "close LOCK;" (or when the script exits)

opendir DIR, $dir_path
  or die "Could not open directory '$dir_path': $!";
my @files = readdir DIR;
closedir DIR;

for my $d (@files) {
  next if $d !~ /^[0-9]+$/;

  my $procdir = "/proc/$d";
  open IN, '<', $procdir . '/status'
    or die "Can't open status with $procdir: $!";
  while (<IN>) {
    # Fill this in yourself...
  }
}

# We're done with the directory! Let someone else access it
close LOCK;
[download]

Update: As soon as I posted, I realized I left out the actual flock() statement to place an exclusive lock on the semaphore file {grin}

      C:\>shutdown -s
      >> Could not shut down computer:
      >> Microsoft is logged in remotely.
    

And you think the kernel is going to pay attention to any locks a user program might have? We are talking about the /proc file system here.

The content of the /proc filesystem rapidly changes, and there isn't much you can do about it. Remember that /proc is nothing more than some hooks inside the kernel. Processes come and go, and so do their associated files in /proc.

Abigail

This is a case where you may want to go to the system. The ps system call will take a snapshot of the processes on the system. The ephemeral nature of procfs does not interfere, as it does in your method. The ps call can have its output tailored to give what you want. Check your local 'man ps' to see if the options match in your version of ps.

my $psout = `/bin/ps -A h o uid,vsize`;
my @procs = map {[split]} split "\n", $psout;
# To get total vm usage by uid,
my %vm_usage;
$vm_usage{$_->[0]} += $_->[1] for @procs;
[download]

After Compline,
Zaxo

Thx, pg^^. Just like you said, I gave up on trying to improve the performance of my program, but instead, I checked whether the file that I stored in the variable exists or not by using "-e $filename". What you wrote was really helpful. Thank you again. snam