glibc/io/tst-copy_file_range.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>