Merge branch 'kvakvs/zero-size-read_file/ERL-327/PR-1524/OTP-14637'

* kvakvs/zero-size-read_file/ERL-327/PR-1524/OTP-14637:
  erts: On zero-size files attempt to read until EOF

2 files changed, 105 insertions, 5 deletions

diff --git a/erts/emulator/drivers/common/efile_drv.c b/erts/emulator/drivers/common/efile_drv.c
index a1b15a2199..4e1d2f0d7f 100644
--- a/erts/emulator/drivers/common/efile_drv.c
+++ b/erts/emulator/drivers/common/efile_drv.c
@@ -1261,6 +1261,50 @@ static void free_read_line(void *data)
     EF_FREE(d);
 }
 
+void read_file_zero_size(struct t_data* d);
+#define ZERO_FILE_CHUNK (64 * 1024)
+
+/* [ERL-327] Some special files like /proc/... have reported size 0 */
+void read_file_zero_size(struct t_data* d) {
+    size_t total_read_size = 0;
+    size_t allocated_size = ZERO_FILE_CHUNK; /* allocd in invoke_read_file */
+    for (;;) {
+        size_t read_result;
+
+        /* Read until we hit EOF (read less than FILE_SEGMENT_READ) */
+        d->result_ok = efile_read(&d->errInfo,
+                                  EFILE_MODE_READ,
+                                  (int) d->fd,
+                                  (d->c.read_file.binp->orig_bytes +
+                                   total_read_size),
+                                  ZERO_FILE_CHUNK,
+                                  &read_result);
+        if (!d->result_ok) {
+            break;
+        }
+
+        total_read_size += read_result;
+        d->c.read_file.offset += read_result;
+        if (read_result < ZERO_FILE_CHUNK) {
+            break;
+        }
+
+        /* Grow before the next read call */
+        allocated_size = total_read_size + ZERO_FILE_CHUNK;
+        d->c.read_file.binp = driver_realloc_binary(d->c.read_file.binp,
+                                                    allocated_size);
+    }
+
+    /* Finalize the memory usage. Hopefully it was read fully on the first
+     * go, so the binary allocation overhead becomes:
+     * alloc ZERO_FILE_CHUNK (64kb) -> realloc real_size */
+    if (allocated_size != total_read_size) {
+        d->c.read_file.binp = driver_realloc_binary(d->c.read_file.binp,
+                                                    total_read_size);
+    }
+    d->again = 0;
+}
+
 static void invoke_read_file(void *data)
 {
     struct t_data *d = (struct t_data *) data;
@@ -1279,9 +1323,15 @@ static void invoke_read_file(void *data)
 	}
 	d->fd = fd;
 	d->c.read_file.size = (int) size;
-	if (size < 0 || size != d->c.read_file.size ||
-	    ! (d->c.read_file.binp = 
-	       driver_alloc_binary(d->c.read_file.size))) {
+
+        /* For zero sized files allocate a reasonable chunk to attempt reading
+         * anyway. Note: This will eat ZERO_FILE_CHUNK bytes for any 0 file
+         * and free them immediately after (if the file was empty). */
+        ERTS_ASSERT(size >= 0);
+        d->c.read_file.binp = driver_alloc_binary(size != 0 ? (size_t)size
+                                                            : ZERO_FILE_CHUNK);
+
+	if (size < 0 || size != d->c.read_file.size || !d->c.read_file.binp) {
 	    d->result_ok = 0;
 	    d->errInfo.posix_errno = ENOMEM;
 	    goto close;
@@ -1290,6 +1340,11 @@ static void invoke_read_file(void *data)
     }
     /* Invariant: d->c.read_file.size >= d->c.read_file.offset */
     
+    if (d->c.read_file.size == 0) {
+        read_file_zero_size(d);
+        goto close;
+    }
+
     read_size = (size_t) (d->c.read_file.size - d->c.read_file.offset);
     if (! read_size) goto close;
     chop = d->again && read_size >= FILE_SEGMENT_READ*2;
diff --git a/erts/emulator/test/efile_SUITE.erl b/erts/emulator/test/efile_SUITE.erl
index f0e1bcf04b..08d5597d78 100644
--- a/erts/emulator/test/efile_SUITE.erl
+++ b/erts/emulator/test/efile_SUITE.erl
@@ -19,16 +19,20 @@
 
 -module(efile_SUITE).
 -export([all/0, suite/0]).
--export([iter_max_files/1, async_dist/1]).
+-export([async_dist/1,
+         iter_max_files/1,
+         proc_zero_sized_files/1
+        ]).
 
 -export([do_iter_max_files/2, do_async_dist/1]).
 
 -include_lib("common_test/include/ct.hrl").
+-include_lib("stdlib/include/assert.hrl").
 
 suite() -> [{ct_hooks,[ts_install_cth]}].
 
 all() -> 
-    [iter_max_files, async_dist].
+    [iter_max_files, async_dist, proc_zero_sized_files].
 
 do_async_dist(Dir) ->
     X = 100,
@@ -162,3 +166,44 @@ open_files(Name) ->
             %		  io:format("Error reason: ~p", [_Reason]),
             []
     end.
+
+%% @doc If /proc filesystem exists (no way to know if it is real proc or just
+%% a /proc directory), let's read some zero sized files 500 times each, while
+%% ensuring that response isn't empty << >>
+proc_zero_sized_files(Config) when is_list(Config) ->
+    {Type, Flavor} = os:type(),
+    %% Some files which exist on Linux but might be missing on other systems
+    Inputs = ["/proc/cpuinfo",
+              "/proc/meminfo",
+              "/proc/partitions",
+              "/proc/swaps",
+              "/proc/version",
+              "/proc/uptime",
+              %% curproc is present on freebsd
+              "/proc/curproc/cmdline"],
+    case filelib:is_dir("/proc") of
+        false -> {skip, "/proc not found"}; % skip the test if no /proc
+        _ when Type =:= unix andalso Flavor =:= sunos ->
+            %% SunOS has a /proc, but no zero sized special files
+            {skip, "sunos does not have any zero sized special files"};
+        true ->
+            %% Take away files which do not exist in proc
+            Inputs1 = lists:filter(fun filelib:is_file/1, Inputs),
+
+            %% Fail if none of mentioned files exist in /proc, did we just get
+            %% a normal /proc directory without any special files?
+            ?assertNotEqual([], Inputs1),
+
+            %% For 6 inputs and 500 attempts each this do run anywhere
+            %% between 500 and 3000 function calls.
+            lists:foreach(
+                fun(Filename) -> do_proc_zero_sized(Filename, 500) end,
+                Inputs1)
+    end.
+
+%% @doc Test one file N times to also trigger possible leaking fds and memory
+do_proc_zero_sized(_Filename, 0) -> ok;
+do_proc_zero_sized(Filename, N) ->
+    Data = file:read_file(Filename),
+    ?assertNotEqual(<<>>, Data),
+    do_proc_zero_sized(Filename, N-1).