Filesystem quotas may stop you from using large files.

p4raw-id: //depot/cfgperl@4167

diff --git a/pod/perldelta.pod b/pod/perldelta.pod
index de5a718..1118c79 100644 (file)
--- a/pod/perldelta.pod
+++ b/pod/perldelta.pod
@@ -185,16 +185,23 @@ start losing precision (their lower digits).
 If you have filesystems that support "large files" (files larger than
 2 gigabytes), you may now also be able to create and access them from Perl.
 
-Note that in addition to requiring a proper file system to do this you
-may also need to adjust your per-process (or your per-system, or per-user-group)
-maximum filesize limits before running Perl scripts that try to handle large
-files, especially if you intend to write such files.
-
-Adjusting your file system/system limits is outside the scope of Perl.
-For process limits, you may try to increase the limits using your
-shell's limit/ulimit command before running Perl.  The BSD::Resource
-extension (not included with the standard Perl distribution) may also
-be of use, it contains getrlimit/setrlimit calls.
+Note that in addition to requiring a proper file system to do large
+files you may also need to adjust your per-process (or your
+per-system, or per-process-group, or per-user-group) maximum filesize
+limits before running Perl scripts that try to handle large files,
+especially if you intend to write such files.
+
+Finally, in addition to your process/process group maximum filesize
+limits, you may have quota limits on your filesystems that stop you
+(your user id or your user group id) from using large files.
+
+Adjusting your process/user/group/file system/operating system limits
+is outside the scope of Perl core language.  For process limits, you
+may try increasing the limits using your shell's limits/limit/ulimit
+command before running Perl.  The BSD::Resource extension (not
+included with the standard Perl distribution) may also be of use, it
+offers the getrlimit/setrlimit interface that can be used to adjust
+process resource usage limits, including the maximum filesize limit.
  
 (Large file support is related to 64-bit support, for obvious reasons.)
 

diff --git a/t/lib/syslfs.t b/t/lib/syslfs.t
index 4d38a8e..14a968a 100644 (file)
--- a/t/lib/syslfs.t
+++ b/t/lib/syslfs.t
@@ -30,13 +30,15 @@ sub explain {
     print <<EOM;
 #
 # If the lfs (large file support: large meaning larger than two gigabytes)
-# tests are skipped or fail, it may mean either that your process is not
-# allowed to write large files or that the file system you are running
-# the tests on doesn't support large files, or both.  You may also need
-# to reconfigure your kernel. (This is all very system-dependent.)
+# tests are skipped or fail, it may mean either that your process
+# (or process group) is not allowed to write large files (resource
+# limits) or that the file system you are running the tests on doesn't
+# let your user/group have large files (quota) or the filesystem simply
+# doesn't support large files.  You may even need to reconfigure your kernel.
+# (This is all very operating system and site-dependent.)
 #
 # Perl may still be able to support large files, once you have
-# such a process and such a (file) system.
+# such a process, enough quota, and such a (file) system.
 #
 EOM
 }
@@ -79,19 +81,27 @@ unless (@s == 13 &&
 # By now we better be sure that we do have sparse files:
 # if we are not, the following will hog 5 gigabytes of disk.  Ooops.
 
+$ENV{LC_ALL} = "C";
+
 sysopen(BIG, "big", O_WRONLY|O_CREAT|O_TRUNC) or
        do { warn "sysopen failed: $!\n"; bye };
 sysseek(BIG, 5_000_000_000, SEEK_SET);
+
 # The syswrite will fail if there are are filesize limitations (process or fs).
-unless(syswrite(BIG, "big") == 3) {
-    $ENV{LC_ALL} = "C";
+my $syswrite = syswrite(BIG, "big") == 3;
+my $close   = close BIG if $syswrite;
+unless($syswrite && $close) {
+    unless ($syswrite) {
+        print "# syswrite failed: $!\n"
+    } else {
+        print "# close failed: $!\n"
+    }
     if ($! =~/File too large/) {
        print "1..0\n# writing past 2GB failed\n";
        explain();
-       bye();
     }
+    bye();
 }
-close BIG;
 
 @s = stat("big");
 

diff --git a/t/op/lfs.t b/t/op/lfs.t
index ae6aac6..af7853b 100644 (file)
--- a/t/op/lfs.t
+++ b/t/op/lfs.t
@@ -29,13 +29,15 @@ sub explain {
     print <<EOM;
 #
 # If the lfs (large file support: large meaning larger than two gigabytes)
-# tests are skipped or fail, it may mean either that your process is not
-# allowed to write large files or that the file system you are running
-# the tests on doesn't support large files, or both.  You may also need
-# to reconfigure your kernel. (This is all very system-dependent.)
+# tests are skipped or fail, it may mean either that your process
+# (or process group) is not allowed to write large files (resource
+# limits) or that the file system you are running the tests on doesn't
+# let your user/group have large files (quota) or the filesystem simply
+# doesn't support large files.  You may even need to reconfigure your kernel.
+# (This is all very operating system and site-dependent.)
 #
 # Perl may still be able to support large files, once you have
-# such a process and such a (file) system.
+# such a process, enough quota, and such a (file) system.
 #
 EOM
 }
@@ -82,15 +84,22 @@ unless (@s == 13 &&
 # By now we better be sure that we do have sparse files:
 # if we are not, the following will hog 5 gigabytes of disk.  Ooops.
 
+$ENV{LC_ALL} = "C";
+
 open(BIG, ">big") or do { warn "open failed: $!\n"; bye };
 binmode BIG;
 seek(BIG, 5_000_000_000, $SEEK_SET);
+
 # Either the print or (more likely, thanks to buffering) the close will
 # fail if there are are filesize limitations (process or fs).
 my $print = print BIG "big";
 my $close = close BIG if $print;
 unless ($print && $close) {
-    $ENV{LC_ALL} = "C";
+    unless ($print) {
+        print "# print failed: $!\n"
+    } else {
+        print "# close failed: $!\n"
+    }
     if ($! =~/File too large/) {
        print "1..0\n# writing past 2GB failed\n";
        explain();