mirror of
https://sourceware.org/git/glibc.git
synced 2024-11-10 07:10:06 +00:00
aa42b3dbcb
Otherwise, these tests fills up the entire disk (or just run very slowly and eventually time out).
841 lines
25 KiB
C
841 lines
25 KiB
C
/* Tests for copy_file_range.
|
|
Copyright (C) 2017-2018 Free Software Foundation, Inc.
|
|
This file is part of the GNU C Library.
|
|
|
|
The GNU C Library is free software; you can redistribute it and/or
|
|
modify it under the terms of the GNU Lesser General Public
|
|
License as published by the Free Software Foundation; either
|
|
version 2.1 of the License, or (at your option) any later version.
|
|
|
|
The GNU C Library is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
Lesser General Public License for more details.
|
|
|
|
You should have received a copy of the GNU Lesser General Public
|
|
License along with the GNU C Library; if not, see
|
|
<http://www.gnu.org/licenses/>. */
|
|
|
|
#include <array_length.h>
|
|
#include <errno.h>
|
|
#include <fcntl.h>
|
|
#include <inttypes.h>
|
|
#include <libgen.h>
|
|
#include <poll.h>
|
|
#include <sched.h>
|
|
#include <stdbool.h>
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
#include <support/check.h>
|
|
#include <support/namespace.h>
|
|
#include <support/support.h>
|
|
#include <support/temp_file.h>
|
|
#include <support/test-driver.h>
|
|
#include <support/xunistd.h>
|
|
#ifdef CLONE_NEWNS
|
|
# include <sys/mount.h>
|
|
#endif
|
|
|
|
/* Boolean flags which indicate whether to use pointers with explicit
|
|
output flags. */
|
|
static int do_inoff;
|
|
static int do_outoff;
|
|
|
|
/* Name and descriptors of the input files. Files are truncated and
|
|
reopened (with O_RDWR) between tests. */
|
|
static char *infile;
|
|
static int infd;
|
|
static char *outfile;
|
|
static int outfd;
|
|
|
|
/* Like the above, but on a different file system. xdevfile can be
|
|
NULL if no suitable file system has been found. */
|
|
static char *xdevfile;
|
|
|
|
/* Input and output offsets. Set according to do_inoff and do_outoff
|
|
before the test. The offsets themselves are always set to
|
|
zero. */
|
|
static off64_t inoff;
|
|
static off64_t *pinoff;
|
|
static off64_t outoff;
|
|
static off64_t *poutoff;
|
|
|
|
/* These are a collection of copy sizes used in tests. The selection
|
|
takes into account that the fallback implementation uses an
|
|
internal buffer of 8192 bytes. */
|
|
enum { maximum_size = 99999 };
|
|
static const int typical_sizes[] =
|
|
{ 0, 1, 2, 3, 1024, 2048, 4096, 8191, 8192, 8193, 16383, 16384, 16385,
|
|
maximum_size };
|
|
|
|
/* The random contents of this array can be used as a pattern to check
|
|
for correct write operations. */
|
|
static unsigned char random_data[maximum_size];
|
|
|
|
/* The size chosen by the test harness. */
|
|
static int current_size;
|
|
|
|
/* Maximum writable file offset. Updated by find_maximum_offset
|
|
below. */
|
|
static off64_t maximum_offset;
|
|
|
|
/* Error code when crossing the offset. */
|
|
static int maximum_offset_errno;
|
|
|
|
/* If true: Writes which cross the limit will fail. If false: Writes
|
|
which cross the limit will result in a partial write. */
|
|
static bool maximum_offset_hard_limit;
|
|
|
|
/* Fills maximum_offset etc. above. Truncates outfd as a side
|
|
effect. */
|
|
static void
|
|
find_maximum_offset (void)
|
|
{
|
|
xftruncate (outfd, 0);
|
|
if (maximum_offset != 0)
|
|
return;
|
|
|
|
uint64_t upper = -1;
|
|
upper >>= 1; /* Maximum of off64_t. */
|
|
TEST_VERIFY ((off64_t) upper > 0);
|
|
TEST_VERIFY ((off64_t) (upper + 1) < 0);
|
|
if (lseek64 (outfd, upper, SEEK_SET) >= 0)
|
|
{
|
|
if (write (outfd, "", 1) == 1)
|
|
FAIL_EXIT1 ("created a file larger than the off64_t range");
|
|
}
|
|
|
|
uint64_t lower = 1024 * 1024; /* A reasonable minimum file size. */
|
|
/* Loop invariant: writing at lower succeeds, writing at upper fails. */
|
|
while (lower + 1 < upper)
|
|
{
|
|
uint64_t middle = (lower + upper) / 2;
|
|
if (test_verbose > 0)
|
|
printf ("info: %s: remaining test range %" PRIu64 " .. %" PRIu64
|
|
", probe at %" PRIu64 "\n", __func__, lower, upper, middle);
|
|
xftruncate (outfd, 0);
|
|
if (lseek64 (outfd, middle, SEEK_SET) >= 0
|
|
&& write (outfd, "", 1) == 1)
|
|
lower = middle;
|
|
else
|
|
upper = middle;
|
|
}
|
|
TEST_VERIFY (lower + 1 == upper);
|
|
maximum_offset = lower;
|
|
printf ("info: maximum writable file offset: %" PRIu64 " (%" PRIx64 ")\n",
|
|
lower, lower);
|
|
|
|
/* Check that writing at the valid offset actually works. */
|
|
xftruncate (outfd, 0);
|
|
xlseek (outfd, lower, SEEK_SET);
|
|
TEST_COMPARE (write (outfd, "", 1), 1);
|
|
|
|
/* Cross the boundary with a two-byte write. This can either result
|
|
in a short write, or a failure. */
|
|
xlseek (outfd, lower, SEEK_SET);
|
|
ssize_t ret = write (outfd, " ", 2);
|
|
if (ret < 0)
|
|
{
|
|
maximum_offset_errno = errno;
|
|
maximum_offset_hard_limit = true;
|
|
}
|
|
else
|
|
maximum_offset_hard_limit = false;
|
|
|
|
/* Check that writing at the next offset actually fails. This also
|
|
obtains the expected errno value. */
|
|
xftruncate (outfd, 0);
|
|
const char *action;
|
|
if (lseek64 (outfd, lower + 1, SEEK_SET) != 0)
|
|
{
|
|
if (write (outfd, "", 1) != -1)
|
|
FAIL_EXIT1 ("write to impossible offset %" PRIu64 " succeeded",
|
|
lower + 1);
|
|
action = "writing";
|
|
int errno_copy = errno;
|
|
if (maximum_offset_hard_limit)
|
|
TEST_COMPARE (errno_copy, maximum_offset_errno);
|
|
else
|
|
maximum_offset_errno = errno_copy;
|
|
}
|
|
else
|
|
{
|
|
action = "seeking";
|
|
maximum_offset_errno = errno;
|
|
}
|
|
printf ("info: %s out of range fails with %m (%d)\n",
|
|
action, maximum_offset_errno);
|
|
|
|
xftruncate (outfd, 0);
|
|
xlseek (outfd, 0, SEEK_SET);
|
|
}
|
|
|
|
/* Perform a copy of a file. */
|
|
static void
|
|
simple_file_copy (void)
|
|
{
|
|
xwrite (infd, random_data, current_size);
|
|
|
|
int length;
|
|
int in_skipped; /* Expected skipped bytes in input. */
|
|
if (do_inoff)
|
|
{
|
|
xlseek (infd, 1, SEEK_SET);
|
|
inoff = 2;
|
|
length = current_size - 3;
|
|
in_skipped = 2;
|
|
}
|
|
else
|
|
{
|
|
xlseek (infd, 3, SEEK_SET);
|
|
length = current_size - 5;
|
|
in_skipped = 3;
|
|
}
|
|
int out_skipped; /* Expected skipped bytes before the written data. */
|
|
if (do_outoff)
|
|
{
|
|
xlseek (outfd, 4, SEEK_SET);
|
|
outoff = 5;
|
|
out_skipped = 5;
|
|
}
|
|
else
|
|
{
|
|
xlseek (outfd, 6, SEEK_SET);
|
|
length = current_size - 6;
|
|
out_skipped = 6;
|
|
}
|
|
if (length < 0)
|
|
length = 0;
|
|
|
|
TEST_COMPARE (copy_file_range (infd, pinoff, outfd, poutoff,
|
|
length, 0), length);
|
|
if (do_inoff)
|
|
{
|
|
TEST_COMPARE (inoff, 2 + length);
|
|
TEST_COMPARE (xlseek (infd, 0, SEEK_CUR), 1);
|
|
}
|
|
else
|
|
TEST_COMPARE (xlseek (infd, 0, SEEK_CUR), 3 + length);
|
|
if (do_outoff)
|
|
{
|
|
TEST_COMPARE (outoff, 5 + length);
|
|
TEST_COMPARE (xlseek (outfd, 0, SEEK_CUR), 4);
|
|
}
|
|
else
|
|
TEST_COMPARE (xlseek (outfd, 0, SEEK_CUR), 6 + length);
|
|
|
|
struct stat64 st;
|
|
xfstat (outfd, &st);
|
|
if (length > 0)
|
|
TEST_COMPARE (st.st_size, out_skipped + length);
|
|
else
|
|
{
|
|
/* If we did not write anything, we also did not add any
|
|
padding. */
|
|
TEST_COMPARE (st.st_size, 0);
|
|
return;
|
|
}
|
|
|
|
xlseek (outfd, 0, SEEK_SET);
|
|
char *bytes = xmalloc (st.st_size);
|
|
TEST_COMPARE (read (outfd, bytes, st.st_size), st.st_size);
|
|
for (int i = 0; i < out_skipped; ++i)
|
|
TEST_COMPARE (bytes[i], 0);
|
|
TEST_VERIFY (memcmp (bytes + out_skipped, random_data + in_skipped,
|
|
length) == 0);
|
|
free (bytes);
|
|
}
|
|
|
|
/* Test that reading from a pipe willfails. */
|
|
static void
|
|
pipe_as_source (void)
|
|
{
|
|
int pipefds[2];
|
|
xpipe (pipefds);
|
|
|
|
for (int length = 0; length < 2; ++length)
|
|
{
|
|
if (test_verbose > 0)
|
|
printf ("info: %s: length=%d\n", __func__, length);
|
|
|
|
/* Make sure that there is something to copy in the pipe. */
|
|
xwrite (pipefds[1], "@", 1);
|
|
|
|
TEST_COMPARE (copy_file_range (pipefds[0], pinoff, outfd, poutoff,
|
|
length, 0), -1);
|
|
/* Linux 4.10 and later return EINVAL. Older kernels return
|
|
EXDEV. */
|
|
TEST_VERIFY (errno == EINVAL || errno == EXDEV);
|
|
TEST_COMPARE (inoff, 0);
|
|
TEST_COMPARE (outoff, 0);
|
|
TEST_COMPARE (xlseek (outfd, 0, SEEK_CUR), 0);
|
|
|
|
/* Make sure that nothing was read. */
|
|
char buf = 'A';
|
|
TEST_COMPARE (read (pipefds[0], &buf, 1), 1);
|
|
TEST_COMPARE (buf, '@');
|
|
}
|
|
|
|
xclose (pipefds[0]);
|
|
xclose (pipefds[1]);
|
|
}
|
|
|
|
/* Test that writing to a pipe fails. */
|
|
static void
|
|
pipe_as_destination (void)
|
|
{
|
|
/* Make sure that there is something to read in the input file. */
|
|
xwrite (infd, "abc", 3);
|
|
xlseek (infd, 0, SEEK_SET);
|
|
|
|
int pipefds[2];
|
|
xpipe (pipefds);
|
|
|
|
for (int length = 0; length < 2; ++length)
|
|
{
|
|
if (test_verbose > 0)
|
|
printf ("info: %s: length=%d\n", __func__, length);
|
|
|
|
TEST_COMPARE (copy_file_range (infd, pinoff, pipefds[1], poutoff,
|
|
length, 0), -1);
|
|
/* Linux 4.10 and later return EINVAL. Older kernels return
|
|
EXDEV. */
|
|
TEST_VERIFY (errno == EINVAL || errno == EXDEV);
|
|
TEST_COMPARE (inoff, 0);
|
|
TEST_COMPARE (outoff, 0);
|
|
TEST_COMPARE (xlseek (infd, 0, SEEK_CUR), 0);
|
|
|
|
/* Make sure that nothing was written. */
|
|
struct pollfd pollfd = { .fd = pipefds[0], .events = POLLIN, };
|
|
TEST_COMPARE (poll (&pollfd, 1, 0), 0);
|
|
}
|
|
|
|
xclose (pipefds[0]);
|
|
xclose (pipefds[1]);
|
|
}
|
|
|
|
/* Test a write failure after (potentially) writing some bytes.
|
|
Failure occurs near the start of the buffer. */
|
|
static void
|
|
delayed_write_failure_beginning (void)
|
|
{
|
|
/* We need to write something to provoke the error. */
|
|
if (current_size == 0)
|
|
return;
|
|
xwrite (infd, random_data, sizeof (random_data));
|
|
xlseek (infd, 0, SEEK_SET);
|
|
|
|
/* Write failure near the start. The actual error code varies among
|
|
file systems. */
|
|
find_maximum_offset ();
|
|
off64_t where = maximum_offset;
|
|
|
|
if (current_size == 1)
|
|
++where;
|
|
outoff = where;
|
|
if (do_outoff)
|
|
xlseek (outfd, 1, SEEK_SET);
|
|
else
|
|
xlseek (outfd, where, SEEK_SET);
|
|
if (maximum_offset_hard_limit || where > maximum_offset)
|
|
{
|
|
TEST_COMPARE (copy_file_range (infd, pinoff, outfd, poutoff,
|
|
sizeof (random_data), 0), -1);
|
|
TEST_COMPARE (errno, maximum_offset_errno);
|
|
TEST_COMPARE (xlseek (infd, 0, SEEK_CUR), 0);
|
|
TEST_COMPARE (inoff, 0);
|
|
if (do_outoff)
|
|
TEST_COMPARE (xlseek (outfd, 0, SEEK_CUR), 1);
|
|
else
|
|
TEST_COMPARE (xlseek (outfd, 0, SEEK_CUR), where);
|
|
TEST_COMPARE (outoff, where);
|
|
struct stat64 st;
|
|
xfstat (outfd, &st);
|
|
TEST_COMPARE (st.st_size, 0);
|
|
}
|
|
else
|
|
{
|
|
/* The offset is not a hard limit. This means we write one
|
|
byte. */
|
|
TEST_COMPARE (copy_file_range (infd, pinoff, outfd, poutoff,
|
|
sizeof (random_data), 0), 1);
|
|
if (do_inoff)
|
|
{
|
|
TEST_COMPARE (inoff, 1);
|
|
TEST_COMPARE (xlseek (infd, 0, SEEK_CUR), 0);
|
|
}
|
|
else
|
|
{
|
|
TEST_COMPARE (xlseek (infd, 0, SEEK_CUR), 1);
|
|
TEST_COMPARE (inoff, 0);
|
|
}
|
|
if (do_outoff)
|
|
{
|
|
TEST_COMPARE (xlseek (outfd, 0, SEEK_CUR), 1);
|
|
TEST_COMPARE (outoff, where + 1);
|
|
}
|
|
else
|
|
{
|
|
TEST_COMPARE (xlseek (outfd, 0, SEEK_CUR), where + 1);
|
|
TEST_COMPARE (outoff, where);
|
|
}
|
|
struct stat64 st;
|
|
xfstat (outfd, &st);
|
|
TEST_COMPARE (st.st_size, where + 1);
|
|
}
|
|
}
|
|
|
|
/* Test a write failure after (potentially) writing some bytes.
|
|
Failure occurs near the end of the buffer. */
|
|
static void
|
|
delayed_write_failure_end (void)
|
|
{
|
|
if (current_size <= 1)
|
|
/* This would be same as the first test because there is not
|
|
enough data to write to make a difference. */
|
|
return;
|
|
xwrite (infd, random_data, sizeof (random_data));
|
|
xlseek (infd, 0, SEEK_SET);
|
|
|
|
find_maximum_offset ();
|
|
off64_t where = maximum_offset - current_size + 1;
|
|
if (current_size == sizeof (random_data))
|
|
/* Otherwise we do not reach the non-writable byte. */
|
|
++where;
|
|
outoff = where;
|
|
if (do_outoff)
|
|
xlseek (outfd, 1, SEEK_SET);
|
|
else
|
|
xlseek (outfd, where, SEEK_SET);
|
|
ssize_t ret = copy_file_range (infd, pinoff, outfd, poutoff,
|
|
sizeof (random_data), 0);
|
|
if (ret < 0)
|
|
{
|
|
TEST_COMPARE (ret, -1);
|
|
TEST_COMPARE (errno, maximum_offset_errno);
|
|
struct stat64 st;
|
|
xfstat (outfd, &st);
|
|
TEST_COMPARE (st.st_size, 0);
|
|
}
|
|
else
|
|
{
|
|
/* The first copy succeeded. This happens in the emulation
|
|
because the internal buffer of limited size does not
|
|
necessarily cross the off64_t boundary on the first write
|
|
operation. */
|
|
if (test_verbose > 0)
|
|
printf ("info: copy_file_range (%zu) returned %zd\n",
|
|
sizeof (random_data), ret);
|
|
TEST_VERIFY (ret > 0);
|
|
TEST_VERIFY (ret < maximum_size);
|
|
struct stat64 st;
|
|
xfstat (outfd, &st);
|
|
TEST_COMPARE (st.st_size, where + ret);
|
|
if (do_inoff)
|
|
{
|
|
TEST_COMPARE (inoff, ret);
|
|
TEST_COMPARE (xlseek (infd, 0, SEEK_CUR), 0);
|
|
}
|
|
else
|
|
TEST_COMPARE (xlseek (infd, 0, SEEK_CUR), ret);
|
|
|
|
char *buffer = xmalloc (ret);
|
|
TEST_COMPARE (pread64 (outfd, buffer, ret, where), ret);
|
|
TEST_VERIFY (memcmp (buffer, random_data, ret) == 0);
|
|
free (buffer);
|
|
|
|
/* The second copy fails. */
|
|
TEST_COMPARE (copy_file_range (infd, pinoff, outfd, poutoff,
|
|
sizeof (random_data), 0), -1);
|
|
TEST_COMPARE (errno, maximum_offset_errno);
|
|
}
|
|
}
|
|
|
|
/* Test a write failure across devices. */
|
|
static void
|
|
cross_device_failure (void)
|
|
{
|
|
if (xdevfile == NULL)
|
|
/* Subtest not supported due to missing cross-device file. */
|
|
return;
|
|
|
|
/* We need something to write. */
|
|
xwrite (infd, random_data, sizeof (random_data));
|
|
xlseek (infd, 0, SEEK_SET);
|
|
|
|
int xdevfd = xopen (xdevfile, O_RDWR | O_LARGEFILE, 0);
|
|
TEST_COMPARE (copy_file_range (infd, pinoff, xdevfd, poutoff,
|
|
current_size, 0), -1);
|
|
TEST_COMPARE (errno, EXDEV);
|
|
TEST_COMPARE (xlseek (infd, 0, SEEK_CUR), 0);
|
|
struct stat64 st;
|
|
xfstat (xdevfd, &st);
|
|
TEST_COMPARE (st.st_size, 0);
|
|
|
|
xclose (xdevfd);
|
|
}
|
|
|
|
/* Try to exercise ENOSPC behavior with a tempfs file system (so that
|
|
we do not have to fill up a regular file system to get the error).
|
|
This function runs in a subprocess, so that we do not change the
|
|
mount namespace of the actual test process. */
|
|
static void
|
|
enospc_failure_1 (void *closure)
|
|
{
|
|
#ifdef CLONE_NEWNS
|
|
support_become_root ();
|
|
|
|
/* Make sure that we do not alter the file system mounts of the
|
|
parents. */
|
|
if (! support_enter_mount_namespace ())
|
|
{
|
|
printf ("warning: ENOSPC test skipped\n");
|
|
return;
|
|
}
|
|
|
|
char *mountpoint = closure;
|
|
if (mount ("none", mountpoint, "tmpfs", MS_NODEV | MS_NOEXEC,
|
|
"size=500k") != 0)
|
|
{
|
|
printf ("warning: could not mount tmpfs at %s: %m\n", mountpoint);
|
|
return;
|
|
}
|
|
|
|
/* The source file must reside on the same file system. */
|
|
char *intmpfsfile = xasprintf ("%s/%s", mountpoint, "in");
|
|
int intmpfsfd = xopen (intmpfsfile, O_RDWR | O_CREAT | O_LARGEFILE, 0600);
|
|
xwrite (intmpfsfd, random_data, sizeof (random_data));
|
|
xlseek (intmpfsfd, 1, SEEK_SET);
|
|
inoff = 1;
|
|
|
|
char *outtmpfsfile = xasprintf ("%s/%s", mountpoint, "out");
|
|
int outtmpfsfd = xopen (outtmpfsfile, O_RDWR | O_CREAT | O_LARGEFILE, 0600);
|
|
|
|
/* Fill the file with data until ENOSPC is reached. */
|
|
while (true)
|
|
{
|
|
ssize_t ret = write (outtmpfsfd, random_data, sizeof (random_data));
|
|
if (ret < 0 && errno != ENOSPC)
|
|
FAIL_EXIT1 ("write to %s: %m", outtmpfsfile);
|
|
if (ret < sizeof (random_data))
|
|
break;
|
|
}
|
|
TEST_COMPARE (write (outtmpfsfd, "", 1), -1);
|
|
TEST_COMPARE (errno, ENOSPC);
|
|
off64_t maxsize = xlseek (outtmpfsfd, 0, SEEK_CUR);
|
|
TEST_VERIFY_EXIT (maxsize > sizeof (random_data));
|
|
|
|
/* Constructed the expected file contents. */
|
|
char *expected = xmalloc (maxsize);
|
|
TEST_COMPARE (pread64 (outtmpfsfd, expected, maxsize, 0), maxsize);
|
|
/* Go back a little, so some bytes can be written. */
|
|
enum { offset = 20000 };
|
|
TEST_VERIFY_EXIT (offset < maxsize);
|
|
TEST_VERIFY_EXIT (offset < sizeof (random_data));
|
|
memcpy (expected + maxsize - offset, random_data + 1, offset);
|
|
|
|
if (do_outoff)
|
|
{
|
|
outoff = maxsize - offset;
|
|
xlseek (outtmpfsfd, 2, SEEK_SET);
|
|
}
|
|
else
|
|
xlseek (outtmpfsfd, -offset, SEEK_CUR);
|
|
|
|
/* First call is expected to succeed because we made room for some
|
|
bytes. */
|
|
TEST_COMPARE (copy_file_range (intmpfsfd, pinoff, outtmpfsfd, poutoff,
|
|
maximum_size, 0), offset);
|
|
if (do_inoff)
|
|
{
|
|
TEST_COMPARE (inoff, 1 + offset);
|
|
TEST_COMPARE (xlseek (intmpfsfd, 0, SEEK_CUR), 1);
|
|
}
|
|
else
|
|
TEST_COMPARE (xlseek (intmpfsfd, 0, SEEK_CUR), 1 + offset);
|
|
if (do_outoff)
|
|
{
|
|
TEST_COMPARE (outoff, maxsize);
|
|
TEST_COMPARE (xlseek (outtmpfsfd, 0, SEEK_CUR), 2);
|
|
}
|
|
else
|
|
TEST_COMPARE (xlseek (outtmpfsfd, 0, SEEK_CUR), maxsize);
|
|
struct stat64 st;
|
|
xfstat (outtmpfsfd, &st);
|
|
TEST_COMPARE (st.st_size, maxsize);
|
|
char *actual = xmalloc (st.st_size);
|
|
TEST_COMPARE (pread64 (outtmpfsfd, actual, st.st_size, 0), st.st_size);
|
|
TEST_VERIFY (memcmp (expected, actual, maxsize) == 0);
|
|
|
|
/* Second call should fail with ENOSPC. */
|
|
TEST_COMPARE (copy_file_range (intmpfsfd, pinoff, outtmpfsfd, poutoff,
|
|
maximum_size, 0), -1);
|
|
TEST_COMPARE (errno, ENOSPC);
|
|
|
|
/* Offsets should be unchanged. */
|
|
if (do_inoff)
|
|
{
|
|
TEST_COMPARE (inoff, 1 + offset);
|
|
TEST_COMPARE (xlseek (intmpfsfd, 0, SEEK_CUR), 1);
|
|
}
|
|
else
|
|
TEST_COMPARE (xlseek (intmpfsfd, 0, SEEK_CUR), 1 + offset);
|
|
if (do_outoff)
|
|
{
|
|
TEST_COMPARE (outoff, maxsize);
|
|
TEST_COMPARE (xlseek (outtmpfsfd, 0, SEEK_CUR), 2);
|
|
}
|
|
else
|
|
TEST_COMPARE (xlseek (outtmpfsfd, 0, SEEK_CUR), maxsize);
|
|
TEST_COMPARE (xlseek (outtmpfsfd, 0, SEEK_END), maxsize);
|
|
TEST_COMPARE (pread64 (outtmpfsfd, actual, maxsize, 0), maxsize);
|
|
TEST_VERIFY (memcmp (expected, actual, maxsize) == 0);
|
|
|
|
free (actual);
|
|
free (expected);
|
|
|
|
xclose (intmpfsfd);
|
|
xclose (outtmpfsfd);
|
|
free (intmpfsfile);
|
|
free (outtmpfsfile);
|
|
|
|
#else /* !CLONE_NEWNS */
|
|
puts ("warning: ENOSPC test skipped (no mount namespaces)");
|
|
#endif
|
|
}
|
|
|
|
/* Call enospc_failure_1 in a subprocess. */
|
|
static void
|
|
enospc_failure (void)
|
|
{
|
|
char *mountpoint
|
|
= support_create_temp_directory ("tst-copy_file_range-enospc-");
|
|
support_isolate_in_subprocess (enospc_failure_1, mountpoint);
|
|
free (mountpoint);
|
|
}
|
|
|
|
/* The target file descriptor must have O_APPEND enabled. */
|
|
static void
|
|
oappend_failure (void)
|
|
{
|
|
/* Add data, to make sure we do not fail because there is
|
|
insufficient input data. */
|
|
xwrite (infd, random_data, current_size);
|
|
xlseek (infd, 0, SEEK_SET);
|
|
|
|
xclose (outfd);
|
|
outfd = xopen (outfile, O_RDWR | O_APPEND, 0);
|
|
TEST_COMPARE (copy_file_range (infd, pinoff, outfd, poutoff,
|
|
current_size, 0), -1);
|
|
TEST_COMPARE (errno, EBADF);
|
|
}
|
|
|
|
/* Test that a short input file results in a shortened copy. */
|
|
static void
|
|
short_copy (void)
|
|
{
|
|
if (current_size == 0)
|
|
/* Nothing to shorten. */
|
|
return;
|
|
|
|
/* Two subtests, one with offset 0 and current_size - 1 bytes, and
|
|
another one with current_size bytes, but offset 1. */
|
|
for (int shift = 0; shift < 2; ++shift)
|
|
{
|
|
if (test_verbose > 0)
|
|
printf ("info: shift=%d\n", shift);
|
|
xftruncate (infd, 0);
|
|
xlseek (infd, 0, SEEK_SET);
|
|
xwrite (infd, random_data, current_size - !shift);
|
|
|
|
if (do_inoff)
|
|
{
|
|
inoff = shift;
|
|
xlseek (infd, 2, SEEK_SET);
|
|
}
|
|
else
|
|
{
|
|
inoff = 3;
|
|
xlseek (infd, shift, SEEK_SET);
|
|
}
|
|
ftruncate (outfd, 0);
|
|
xlseek (outfd, 0, SEEK_SET);
|
|
outoff = 0;
|
|
|
|
/* First call copies current_size - 1 bytes. */
|
|
TEST_COMPARE (copy_file_range (infd, pinoff, outfd, poutoff,
|
|
current_size, 0), current_size - 1);
|
|
char *buffer = xmalloc (current_size);
|
|
TEST_COMPARE (pread64 (outfd, buffer, current_size, 0),
|
|
current_size - 1);
|
|
TEST_VERIFY (memcmp (buffer, random_data + shift, current_size - 1)
|
|
== 0);
|
|
free (buffer);
|
|
|
|
if (do_inoff)
|
|
{
|
|
TEST_COMPARE (inoff, current_size - 1 + shift);
|
|
TEST_COMPARE (xlseek (infd, 0, SEEK_CUR), 2);
|
|
}
|
|
else
|
|
TEST_COMPARE (xlseek (infd, 0, SEEK_CUR), current_size - 1 + shift);
|
|
if (do_outoff)
|
|
{
|
|
TEST_COMPARE (outoff, current_size - 1);
|
|
TEST_COMPARE (xlseek (outfd, 0, SEEK_CUR), 0);
|
|
}
|
|
else
|
|
TEST_COMPARE (xlseek (outfd, 0, SEEK_CUR), current_size - 1);
|
|
|
|
/* First call copies zero bytes. */
|
|
TEST_COMPARE (copy_file_range (infd, pinoff, outfd, poutoff,
|
|
current_size, 0), 0);
|
|
/* And the offsets are unchanged. */
|
|
if (do_inoff)
|
|
{
|
|
TEST_COMPARE (inoff, current_size - 1 + shift);
|
|
TEST_COMPARE (xlseek (infd, 0, SEEK_CUR), 2);
|
|
}
|
|
else
|
|
TEST_COMPARE (xlseek (infd, 0, SEEK_CUR), current_size - 1 + shift);
|
|
if (do_outoff)
|
|
{
|
|
TEST_COMPARE (outoff, current_size - 1);
|
|
TEST_COMPARE (xlseek (outfd, 0, SEEK_CUR), 0);
|
|
}
|
|
else
|
|
TEST_COMPARE (xlseek (outfd, 0, SEEK_CUR), current_size - 1);
|
|
}
|
|
}
|
|
|
|
/* A named test function. */
|
|
struct test_case
|
|
{
|
|
const char *name;
|
|
void (*func) (void);
|
|
bool sizes; /* If true, call the test with different current_size values. */
|
|
};
|
|
|
|
/* The available test cases. */
|
|
static struct test_case tests[] =
|
|
{
|
|
{ "simple_file_copy", simple_file_copy, .sizes = true },
|
|
{ "pipe_as_source", pipe_as_source, },
|
|
{ "pipe_as_destination", pipe_as_destination, },
|
|
{ "delayed_write_failure_beginning", delayed_write_failure_beginning,
|
|
.sizes = true },
|
|
{ "delayed_write_failure_end", delayed_write_failure_end, .sizes = true },
|
|
{ "cross_device_failure", cross_device_failure, .sizes = true },
|
|
{ "enospc_failure", enospc_failure, },
|
|
{ "oappend_failure", oappend_failure, .sizes = true },
|
|
{ "short_copy", short_copy, .sizes = true },
|
|
};
|
|
|
|
static int
|
|
do_test (void)
|
|
{
|
|
for (unsigned char *p = random_data; p < array_end (random_data); ++p)
|
|
*p = rand () >> 24;
|
|
|
|
infd = create_temp_file ("tst-copy_file_range-in-", &infile);
|
|
{
|
|
int outfd = create_temp_file ("tst-copy_file_range-out-", &outfile);
|
|
if (!support_descriptor_supports_holes (outfd))
|
|
FAIL_UNSUPPORTED ("File %s does not support holes", outfile);
|
|
xclose (outfd);
|
|
}
|
|
|
|
/* Try to find a different directory from the default input/output
|
|
file. */
|
|
{
|
|
struct stat64 instat;
|
|
xfstat (infd, &instat);
|
|
static const char *const candidates[] =
|
|
{ NULL, "/var/tmp", "/dev/shm" };
|
|
for (const char *const *c = candidates; c < array_end (candidates); ++c)
|
|
{
|
|
const char *path = *c;
|
|
char *to_free = NULL;
|
|
if (path == NULL)
|
|
{
|
|
to_free = xreadlink ("/proc/self/exe");
|
|
path = dirname (to_free);
|
|
}
|
|
|
|
struct stat64 cstat;
|
|
xstat (path, &cstat);
|
|
if (cstat.st_dev == instat.st_dev)
|
|
{
|
|
free (to_free);
|
|
continue;
|
|
}
|
|
|
|
printf ("info: using alternate temporary files directory: %s\n", path);
|
|
xdevfile = xasprintf ("%s/tst-copy_file_range-xdev-XXXXXX", path);
|
|
free (to_free);
|
|
break;
|
|
}
|
|
if (xdevfile != NULL)
|
|
{
|
|
int xdevfd = mkstemp (xdevfile);
|
|
if (xdevfd < 0)
|
|
FAIL_EXIT1 ("mkstemp (\"%s\"): %m", xdevfile);
|
|
struct stat64 xdevst;
|
|
xfstat (xdevfd, &xdevst);
|
|
TEST_VERIFY (xdevst.st_dev != instat.st_dev);
|
|
add_temp_file (xdevfile);
|
|
xclose (xdevfd);
|
|
}
|
|
else
|
|
puts ("warning: no alternate directory on different file system found");
|
|
}
|
|
xclose (infd);
|
|
|
|
for (do_inoff = 0; do_inoff < 2; ++do_inoff)
|
|
for (do_outoff = 0; do_outoff < 2; ++do_outoff)
|
|
for (struct test_case *test = tests; test < array_end (tests); ++test)
|
|
for (const int *size = typical_sizes;
|
|
size < array_end (typical_sizes); ++size)
|
|
{
|
|
current_size = *size;
|
|
if (test_verbose > 0)
|
|
printf ("info: %s do_inoff=%d do_outoff=%d current_size=%d\n",
|
|
test->name, do_inoff, do_outoff, current_size);
|
|
|
|
inoff = 0;
|
|
if (do_inoff)
|
|
pinoff = &inoff;
|
|
else
|
|
pinoff = NULL;
|
|
outoff = 0;
|
|
if (do_outoff)
|
|
poutoff = &outoff;
|
|
else
|
|
poutoff = NULL;
|
|
|
|
infd = xopen (infile, O_RDWR | O_LARGEFILE, 0);
|
|
xftruncate (infd, 0);
|
|
outfd = xopen (outfile, O_RDWR | O_LARGEFILE, 0);
|
|
xftruncate (outfd, 0);
|
|
|
|
test->func ();
|
|
|
|
xclose (infd);
|
|
xclose (outfd);
|
|
|
|
if (!test->sizes)
|
|
/* Skip the other sizes unless they have been
|
|
requested. */
|
|
break;
|
|
}
|
|
|
|
free (infile);
|
|
free (outfile);
|
|
free (xdevfile);
|
|
|
|
return 0;
|
|
}
|
|
|
|
#include <support/test-driver.c>
|