I've read at ulimit that it applies to "shell" launched stuff, is your perl program launched from shell?

The ulimit is set at system level - and has since been increased. I wanted to trap an error when perl tried to write to a file and exceeded the ulimit. The closing file handle worked ok.

Since then we have come up with the following to trap the error - although it has thrown up a strange error of not liking the "|| die" appearing on a separate line.

#!/usr/local/bin/perl
use strict;
use warnings FATAL => 'all';

open(OUT, '>', "splat")
    or die "Opening (write) 'splat' $!";

while (1) {
        my $line = time().’’;

        # THIS WORKS
        print (OUT $line) || die "writing 'splat' $!";

       # But putting || die on another line does not. i.e:
       # print (OUT $line) 
       #       || die "writing 'splat' $!";
}

close(OUT)
    or die "Closing 'splat' $!";
[download]

The error message produced is:

writing 'splat'

A file cannot be larger than the value set by ulimit. at u3.pl line 12.

You should always use low precedence or (in preference to ||) with the "or die" idiom. Also, you should normally avoid parens when calling print, so this is the recommended way to write it:

print OUT $line or die "writing 'splat' $!";
[download]

For a working example, see my reply below.

Update: further notice that lexical file handles (e.g. $fh in my reply below) are preferred to the old global file handles (e.g. OUT in your example code).

# THIS WORKS
print (OUT $line) || die "writing 'splat' $!";

# But putting || die on another line does not. i.e:
# print (OUT $line) 
#       || die "writing 'splat' $!";
[download]

That's strange. They both work for me.

Moreover, I see no reason why they would be different, in fact Deparse tells me they produce identical code:

% cat id1.pl
 print (OUT $line) || die "writing 'splat' $!";

% perl -MO=Deparse id1.pl
die "writing 'splat' $!" unless print OUT $line;
id1.pl syntax OK

% cat id2.pl
 print (OUT $line)
    || die "writing 'splat' $!";

% perl -MO=Deparse id2.pl
die "writing 'splat' $!" unless print OUT $line;
id2.pl syntax OK
[download]

Though you could dig further into the root cause of the difference you experienced, I suggest you just stick to the low precedence or and avoid parens with print as described earlier.

I think the error condition will normally not be detectable until you try to close() the file handle.

The return value from close() should be 0 and $! should indicate the error. The actual message will depend on the operating system.

Tested just now on aix61 and it worked for me. Saved the following program as f.pl:

# From /etc/security/limits:
#   Sizes are in multiples of 512 byte blocks
#   fsize      - soft file size in blocks
# To test this program, I set block size via:
#   ulimit -f 900

use strict;
use warnings;
$| = 1;
my $bsize = 512;
my $ulimit = `ulimit -f`;
chomp $ulimit;
print "ulimit=$ulimit blocks (block size=$bsize)\n";
my $fname = 'f.tmp';
open my $fh, '>', $fname or die "error: open '$fname': $!";
my $niter = 1000;
my $size = 0;
my $block = 'a' x $bsize;
for my $i (0..$niter) {
   $size += $bsize;
   print "$i: $size bytes written\n" if $i % 100 == 0;
   print $fh $block or die "$i: error in print: $!";
}
close $fh or die "error: close: $!";
[download]

ulimit -f 900
[download]

% perl f.pl
ulimit=900 blocks (block size=512)
0: 512 bytes written
100: 51712 bytes written
200: 102912 bytes written
300: 154112 bytes written
400: 205312 bytes written
500: 256512 bytes written
600: 307712 bytes written
700: 358912 bytes written
800: 410112 bytes written
900: 461312 bytes written
904: error in print: A file cannot be larger than the value set by uli
+mit. at f.pl line 22.
[download]

Update: The reason for the program stopping at 904, rather than 900, is user-space buffering by stdio. To verify that it stops at 900 with user-space buffering switched off, I adjusted the above program by adding a call to autoflush right after the output file is opened. Running this adjusted program:

use strict;
use warnings;
use IO::Handle;    # <-- Added this line for autoflush
$| = 1;
my $bsize = 512;
my $ulimit = `ulimit -f`;
chomp $ulimit;
print "ulimit=$ulimit blocks (block size=$bsize)\n";
my $fname = 'f.tmp';
open my $fh, '>', $fname or die "error: open '$fname': $!";
$fh->autoflush();    # <-- Added this line to make print autoflush
my $niter = 1000;
my $size = 0;
my $block = 'a' x $bsize;
for my $i (0..$niter) {
   print "$i: $size bytes written\n" if $i % 100 == 0;
   print $fh $block or die "$i: error in print: $!";
   $size += $bsize;    # <-- Moved this line to after successful print
}
close $fh or die "error: close: $!";
[download]

ulimit=900 blocks (block size=512)
0: 0 bytes written
100: 51200 bytes written
200: 102400 bytes written
300: 153600 bytes written
400: 204800 bytes written
500: 256000 bytes written
600: 307200 bytes written
700: 358400 bytes written
800: 409600 bytes written
900: 460800 bytes written
900: error in print: A file cannot be larger than the value set by uli
+mit. at f.pl line 23.
[download]

Note further that the above was run with the korn shell (ksh). The ulimit command is a shell builtin and the block size, on aix at least, seems to be 512 bytes for ksh and 1024 bytes for bash, as shown below:

% type ulimit
ulimit is a shell builtin.
% ulimit -f 900
% ulimit -f
900
% ksh -c 'ulimit -f'
900
% bash -c 'ulimit -f'
450
[download]