io/tst-copy_file_range.c

   1 /* Tests for copy_file_range.
   2    Copyright (C) 2017-2021 Free Software Foundation, Inc.
   3    This file is part of the GNU C Library.
   4
   5    The GNU C Library is free software; you can redistribute it and/or
   6    modify it under the terms of the GNU Lesser General Public
   7    License as published by the Free Software Foundation; either
   8    version 2.1 of the License, or (at your option) any later version.
   9
  10    The GNU C Library is distributed in the hope that it will be useful,
  11    but WITHOUT ANY WARRANTY; without even the implied warranty of
  12    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13    Lesser General Public License for more details.
  14
  15    You should have received a copy of the GNU Lesser General Public
  16    License along with the GNU C Library; if not, see
  17    <https://www.gnu.org/licenses/>.  */
  18
  19 #include <array_length.h>
  20 #include <errno.h>
  21 #include <fcntl.h>
  22 #include <inttypes.h>
  23 #include <stdbool.h>
  24 #include <stdio.h>
  25 #include <stdlib.h>
  26 #include <string.h>
  27 #include <support/check.h>
  28 #include <support/support.h>
  29 #include <support/temp_file.h>
  30 #include <support/test-driver.h>
  31 #include <support/xunistd.h>
  32
  33 /* Boolean flags which indicate whether to use pointers with explicit
  34    output flags.  */
  35 static int do_inoff;
  36 static int do_outoff;
  37
  38 /* Name and descriptors of the input files.  Files are truncated and
  39    reopened (with O_RDWR) between tests.  */
  40 static char *infile;
  41 static int infd;
  42 static char *outfile;
  43 static int outfd;
  44
  45 /* Input and output offsets.  Set according to do_inoff and do_outoff
  46    before the test.  The offsets themselves are always set to
  47    zero.  */
  48 static off64_t inoff;
  49 static off64_t *pinoff;
  50 static off64_t outoff;
  51 static off64_t *poutoff;
  52
  53 /* These are a collection of copy sizes used in tests.    */
  54 enum { maximum_size = 99999 };
  55 static const int typical_sizes[] =
  56   { 0, 1, 2, 3, 1024, 2048, 4096, 8191, 8192, 8193, maximum_size };
  57
  58 /* The random contents of this array can be used as a pattern to check
  59    for correct write operations.  */
  60 static unsigned char random_data[maximum_size];
  61
  62 /* The size chosen by the test harness.  */
  63 static int current_size;
  64
  65 /* Perform a copy of a file.  */
  66 static void
  67 simple_file_copy (void)
  68 {
  69   xwrite (infd, random_data, current_size);
  70
  71   int length;
  72   int in_skipped; /* Expected skipped bytes in input.  */
  73   if (do_inoff)
  74     {
  75       xlseek (infd, 1, SEEK_SET);
  76       inoff = 2;
  77       length = current_size - 3;
  78       in_skipped = 2;
  79     }
  80   else
  81     {
  82       xlseek (infd, 3, SEEK_SET);
  83       length = current_size - 5;
  84       in_skipped = 3;
  85     }
  86   int out_skipped; /* Expected skipped bytes before the written data.  */
  87   if (do_outoff)
  88     {
  89       xlseek (outfd, 4, SEEK_SET);
  90       outoff = 5;
  91       out_skipped = 5;
  92     }
  93   else
  94     {
  95       xlseek (outfd, 6, SEEK_SET);
  96       length = current_size - 6;
  97       out_skipped = 6;
  98     }
  99   if (length < 0)
 100     length = 0;
 101
 102   TEST_COMPARE (copy_file_range (infd, pinoff, outfd, poutoff,
 103                                  length, 0), length);
 104   if (do_inoff)
 105     {
 106       TEST_COMPARE (inoff, 2 + length);
 107       TEST_COMPARE (xlseek (infd, 0, SEEK_CUR), 1);
 108     }
 109   else
 110     TEST_COMPARE (xlseek (infd, 0, SEEK_CUR), 3 + length);
 111   if (do_outoff)
 112     {
 113       TEST_COMPARE (outoff, 5 + length);
 114       TEST_COMPARE (xlseek (outfd, 0, SEEK_CUR), 4);
 115     }
 116   else
 117     TEST_COMPARE (xlseek (outfd, 0, SEEK_CUR), 6 + length);
 118
 119   struct stat64 st;
 120   xfstat (outfd, &st);
 121   if (length > 0)
 122     TEST_COMPARE (st.st_size, out_skipped + length);
 123   else
 124     {
 125       /* If we did not write anything, we also did not add any
 126          padding.  */
 127       TEST_COMPARE (st.st_size, 0);
 128       return;
 129     }
 130
 131   xlseek (outfd, 0, SEEK_SET);
 132   char *bytes = xmalloc (st.st_size);
 133   TEST_COMPARE (read (outfd, bytes, st.st_size), st.st_size);
 134   for (int i = 0; i < out_skipped; ++i)
 135     TEST_COMPARE (bytes[i], 0);
 136   TEST_VERIFY (memcmp (bytes + out_skipped, random_data + in_skipped,
 137                        length) == 0);
 138   free (bytes);
 139 }
 140
 141 /* Test that a short input file results in a shortened copy.  */
 142 static void
 143 short_copy (void)
 144 {
 145   if (current_size == 0)
 146     /* Nothing to shorten.  */
 147     return;
 148
 149   /* Two subtests, one with offset 0 and current_size - 1 bytes, and
 150      another one with current_size bytes, but offset 1.  */
 151   for (int shift = 0; shift < 2; ++shift)
 152     {
 153       if (test_verbose > 0)
 154         printf ("info:   shift=%d\n", shift);
 155       xftruncate (infd, 0);
 156       xlseek (infd, 0, SEEK_SET);
 157       xwrite (infd, random_data, current_size - !shift);
 158
 159       if (do_inoff)
 160         {
 161           inoff = shift;
 162           xlseek (infd, 2, SEEK_SET);
 163         }
 164       else
 165         {
 166           inoff = 3;
 167           xlseek (infd, shift, SEEK_SET);
 168         }
 169       ftruncate (outfd, 0);
 170       xlseek (outfd, 0, SEEK_SET);
 171       outoff = 0;
 172
 173       /* First call copies current_size - 1 bytes.  */
 174       TEST_COMPARE (copy_file_range (infd, pinoff, outfd, poutoff,
 175                                      current_size, 0), current_size - 1);
 176       char *buffer = xmalloc (current_size);
 177       TEST_COMPARE (pread64 (outfd, buffer, current_size, 0),
 178                     current_size - 1);
 179       TEST_VERIFY (memcmp (buffer, random_data + shift, current_size - 1)
 180                    == 0);
 181       free (buffer);
 182
 183       if (do_inoff)
 184         {
 185           TEST_COMPARE (inoff, current_size - 1 + shift);
 186           TEST_COMPARE (xlseek (infd, 0, SEEK_CUR), 2);
 187         }
 188       else
 189         TEST_COMPARE (xlseek (infd, 0, SEEK_CUR), current_size - 1 + shift);
 190       if (do_outoff)
 191         {
 192           TEST_COMPARE (outoff, current_size - 1);
 193           TEST_COMPARE (xlseek (outfd, 0, SEEK_CUR), 0);
 194         }
 195       else
 196         TEST_COMPARE (xlseek (outfd, 0, SEEK_CUR), current_size - 1);
 197
 198       /* First call copies zero bytes.  */
 199       TEST_COMPARE (copy_file_range (infd, pinoff, outfd, poutoff,
 200                                      current_size, 0), 0);
 201       /* And the offsets are unchanged.  */
 202       if (do_inoff)
 203         {
 204           TEST_COMPARE (inoff, current_size - 1 + shift);
 205           TEST_COMPARE (xlseek (infd, 0, SEEK_CUR), 2);
 206         }
 207       else
 208         TEST_COMPARE (xlseek (infd, 0, SEEK_CUR), current_size - 1 + shift);
 209       if (do_outoff)
 210         {
 211           TEST_COMPARE (outoff, current_size - 1);
 212           TEST_COMPARE (xlseek (outfd, 0, SEEK_CUR), 0);
 213         }
 214       else
 215         TEST_COMPARE (xlseek (outfd, 0, SEEK_CUR), current_size - 1);
 216     }
 217 }
 218
 219 /* A named test function.  */
 220 struct test_case
 221 {
 222   const char *name;
 223   void (*func) (void);
 224   bool sizes; /* If true, call the test with different current_size values.  */
 225 };
 226
 227 /* The available test cases.  */
 228 static struct test_case tests[] =
 229   {
 230     { "simple_file_copy", simple_file_copy, .sizes = true },
 231     { "short_copy", short_copy, .sizes = true },
 232   };
 233
 234 static int
 235 do_test (void)
 236 {
 237   for (unsigned char *p = random_data; p < array_end (random_data); ++p)
 238     *p = rand () >> 24;
 239
 240   infd = create_temp_file ("tst-copy_file_range-in-", &infile);
 241   outfd = create_temp_file ("tst-copy_file_range-out-", &outfile);
 242   {
 243     ssize_t ret = copy_file_range (infd, NULL, outfd, NULL, 0, 0);
 244     if (ret != 0)
 245       {
 246         if (errno == ENOSYS)
 247           FAIL_UNSUPPORTED ("copy_file_range is not support on this system");
 248         FAIL_EXIT1 ("copy_file_range probing call: %m");
 249       }
 250   }
 251   xclose (infd);
 252   xclose (outfd);
 253
 254   for (do_inoff = 0; do_inoff < 2; ++do_inoff)
 255     for (do_outoff = 0; do_outoff < 2; ++do_outoff)
 256       for (struct test_case *test = tests; test < array_end (tests); ++test)
 257         for (const int *size = typical_sizes;
 258              size < array_end (typical_sizes); ++size)
 259           {
 260             current_size = *size;
 261             if (test_verbose > 0)
 262               printf ("info: %s do_inoff=%d do_outoff=%d current_size=%d\n",
 263                       test->name, do_inoff, do_outoff, current_size);
 264
 265             inoff = 0;
 266             if (do_inoff)
 267               pinoff = &inoff;
 268             else
 269               pinoff = NULL;
 270             outoff = 0;
 271             if (do_outoff)
 272               poutoff = &outoff;
 273             else
 274               poutoff = NULL;
 275
 276             infd = xopen (infile, O_RDWR | O_LARGEFILE, 0);
 277             xftruncate (infd, 0);
 278             outfd = xopen (outfile, O_RDWR | O_LARGEFILE, 0);
 279             xftruncate (outfd, 0);
 280
 281             test->func ();
 282
 283             xclose (infd);
 284             xclose (outfd);
 285
 286             if (!test->sizes)
 287               /* Skip the other sizes unless they have been
 288                  requested.  */
 289               break;
 290           }
 291
 292   free (infile);
 293   free (outfile);
 294
 295   return 0;
 296 }
 297
 298 #include <support/test-driver.c>