contrib/libarchive/libarchive/test/test_sparse_basic.c

   1 /*-
   2  * Copyright (c) 2010 Michihiro NAKAJIMA
   3  * All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  * 1. Redistributions of source code must retain the above copyright
   9  *    notice, this list of conditions and the following disclaimer.
  10  * 2. Redistributions in binary form must reproduce the above copyright
  11  *    notice, this list of conditions and the following disclaimer in the
  12  *    documentation and/or other materials provided with the distribution.
  13  *
  14  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR
  15  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  16  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  17  * IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT,
  18  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  19  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  20  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  21  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  22  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  23  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  24  */
  25 #include "test.h"
  26 __FBSDID("$FreeBSD$");
  27
  28 #ifdef HAVE_SYS_IOCTL_H
  29 #include <sys/ioctl.h>
  30 #endif
  31 #ifdef HAVE_SYS_PARAM_H
  32 #include <sys/param.h>
  33 #endif
  34 #ifdef HAVE_SYS_UTSNAME_H
  35 #include <sys/utsname.h>
  36 #endif
  37 #ifdef HAVE_FCNTL_H
  38 #include <fcntl.h>
  39 #endif
  40 #ifdef HAVE_LIMITS_H
  41 #include <limits.h>
  42 #endif
  43 #ifdef HAVE_UNISTD_H
  44 #include <unistd.h>
  45 #endif
  46 #ifdef HAVE_LINUX_FIEMAP_H
  47 #include <linux/fiemap.h>
  48 #endif
  49 #ifdef HAVE_LINUX_FS_H
  50 #include <linux/fs.h>
  51 #endif
  52
  53 /*
  54  * NOTE: On FreeBSD and Solaris, this test needs ZFS.
  55  * You may should perfom this test as
  56  * 'TMPDIR=<a directory on the ZFS> libarchive_test'.
  57  */
  58
  59 struct sparse {
  60         enum { DATA, HOLE, END } type;
  61         size_t  size;
  62 };
  63
  64 static void create_sparse_file(const char *, const struct sparse *);
  65
  66 #if defined(_WIN32) && !defined(__CYGWIN__)
  67 #include <winioctl.h>
  68 /*
  69  * Create a sparse file on Windows.
  70  */
  71
  72 #if !defined(PATH_MAX)
  73 #define PATH_MAX        MAX_PATH
  74 #endif
  75 #if !defined(__BORLANDC__)
  76 #define getcwd _getcwd
  77 #endif
  78
  79 static int
  80 is_sparse_supported(const char *path)
  81 {
  82         char root[MAX_PATH+1];
  83         char vol[MAX_PATH+1];
  84         char sys[MAX_PATH+1];
  85         DWORD flags;
  86         BOOL r;
  87
  88         strncpy(root, path, sizeof(root)-1);
  89         if (((root[0] >= 'c' && root[0] <= 'z') ||
  90             (root[0] >= 'C' && root[0] <= 'Z')) &&
  91                 root[1] == ':' &&
  92             (root[2] == '\\' || root[2] == '/'))
  93                 root[3] = '\0';
  94         else
  95                 return (0);
  96         assertEqualInt((r = GetVolumeInformation(root, vol,
  97             sizeof(vol), NULL, NULL, &flags, sys, sizeof(sys))), 1);
  98         return (r != 0 && (flags & FILE_SUPPORTS_SPARSE_FILES) != 0);
  99 }
 100
 101 static void
 102 create_sparse_file(const char *path, const struct sparse *s)
 103 {
 104         char buff[1024];
 105         HANDLE handle;
 106         DWORD dmy;
 107
 108         memset(buff, ' ', sizeof(buff));
 109
 110         handle = CreateFileA(path, GENERIC_WRITE, 0,
 111             NULL, CREATE_NEW, FILE_ATTRIBUTE_NORMAL,
 112             NULL);
 113         assert(handle != INVALID_HANDLE_VALUE);
 114         assert(DeviceIoControl(handle, FSCTL_SET_SPARSE, NULL, 0,
 115             NULL, 0, &dmy, NULL) != 0);
 116         while (s->type != END) {
 117                 if (s->type == HOLE) {
 118                         LARGE_INTEGER distance;
 119
 120                         distance.QuadPart = s->size;
 121                         assert(SetFilePointerEx(handle, distance,
 122                             NULL, FILE_CURRENT) != 0);
 123                 } else {
 124                         DWORD w, wr, size;
 125
 126                         size = s->size;
 127                         while (size) {
 128                                 if (size > sizeof(buff))
 129                                         w = sizeof(buff);
 130                                 else
 131                                         w = size;
 132                                 assert(WriteFile(handle, buff, w, &wr, NULL) != 0);
 133                                 size -= wr;
 134                         }
 135                 }
 136                 s++;
 137         }
 138         assertEqualInt(CloseHandle(handle), 1);
 139 }
 140
 141 #else
 142
 143 #if defined(_PC_MIN_HOLE_SIZE)
 144
 145 /*
 146  * FreeBSD and Solaris can detect 'hole' of a sparse file
 147  * through lseek(HOLE) on ZFS. (UFS does not support yet)
 148  */
 149
 150 static int
 151 is_sparse_supported(const char *path)
 152 {
 153         return (pathconf(path, _PC_MIN_HOLE_SIZE) > 0);
 154 }
 155
 156 #elif defined(__linux__)&& defined(HAVE_LINUX_FIEMAP_H)
 157
 158 /*
 159  * FIEMAP, which can detect 'hole' of a sparse file, has
 160  * been supported from 2.6.28
 161  */
 162
 163 static int
 164 is_sparse_supported(const char *path)
 165 {
 166         const struct sparse sparse_file[] = {
 167                 /* This hole size is too small to create a sparse
 168                  * files for almost filesystem. */
 169                 { HOLE,  1024 }, { DATA, 10240 },
 170                 { END,  0 }
 171         };
 172         struct utsname ut;
 173         char *p, *e;
 174         long d;
 175         int fd, r;
 176         struct fiemap *fm;
 177         char buff[1024];
 178         const char *testfile = "can_sparse";
 179
 180         (void)path; /* UNUSED */
 181         memset(&ut, 0, sizeof(ut));
 182         assertEqualInt(uname(&ut), 0);
 183         p = ut.release;
 184         d = strtol(p, &e, 10);
 185         if (d < 2 || *e != '.')
 186                 return (0);
 187         if (d == 2) {
 188                 p = e + 1;
 189                 d = strtol(p, &e, 10);
 190                 if (d < 6 || *e != '.')
 191                         return (0);
 192                 p = e + 1;
 193                 d = strtol(p, NULL, 10);
 194                 if (d < 28)
 195                         return (0);
 196         }
 197         create_sparse_file(testfile, sparse_file);
 198         fd = open(testfile,  O_RDWR);
 199         if (fd < 0)
 200                 return (0);
 201         fm = (struct fiemap *)buff;
 202         fm->fm_start = 0;
 203         fm->fm_length = ~0ULL;;
 204         fm->fm_flags = FIEMAP_FLAG_SYNC;
 205         fm->fm_extent_count = (sizeof(buff) - sizeof(*fm))/
 206                 sizeof(struct fiemap_extent);
 207         r = ioctl(fd, FS_IOC_FIEMAP, fm);
 208         if (r < 0 && (errno == ENOTTY || errno == EOPNOTSUPP))
 209                 return (0);/* Not supported. */
 210         close(fd);
 211         unlink(testfile);
 212         return (1);
 213 }
 214
 215 #else
 216
 217 /*
 218  * Other system may do not have the API such as lseek(HOLE),
 219  * which detect 'hole' of a sparse file.
 220  */
 221
 222 static int
 223 is_sparse_supported(const char *path)
 224 {
 225         (void)path; /* UNUSED */
 226         return (0);
 227 }
 228
 229 #endif
 230
 231 /*
 232  * Create a sparse file on POSIX like system.
 233  */
 234
 235 static void
 236 create_sparse_file(const char *path, const struct sparse *s)
 237 {
 238         char buff[1024];
 239         int fd;
 240
 241         memset(buff, ' ', sizeof(buff));
 242         assert((fd = open(path, O_CREAT | O_WRONLY, 0600)) != -1);
 243         while (s->type != END) {
 244                 if (s->type == HOLE) {
 245                         assert(lseek(fd, s->size, SEEK_CUR) != (off_t)-1);
 246                 } else {
 247                         size_t w, size;
 248
 249                         size = s->size;
 250                         while (size) {
 251                                 if (size > sizeof(buff))
 252                                         w = sizeof(buff);
 253                                 else
 254                                         w = size;
 255                                 assert(write(fd, buff, w) != (ssize_t)-1);
 256                                 size -= w;
 257                         }
 258                 }
 259                 s++;
 260         }
 261         close(fd);
 262 }
 263
 264 #endif
 265
 266 /*
 267  * Sparse test with directory traversals.
 268  */
 269 static void
 270 verify_sparse_file(struct archive *a, const char *path,
 271     const struct sparse *sparse, int blocks)
 272 {
 273         struct archive_entry *ae;
 274         const void *buff;
 275         size_t bytes_read;
 276         int64_t offset;
 277         int64_t total;
 278         int data_blocks, hole;
 279
 280         create_sparse_file(path, sparse);
 281         assert((ae = archive_entry_new()) != NULL);
 282         assertEqualIntA(a, ARCHIVE_OK, archive_read_disk_open(a, path));
 283         assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header2(a, ae));
 284         /* Verify the number of holes only, not its offset nor its
 285          * length because those alignments are deeply dependence on
 286          * its filesystem. */
 287         assertEqualInt(blocks, archive_entry_sparse_count(ae));
 288         total = 0;
 289         data_blocks = 0;
 290         hole = 0;
 291         while (ARCHIVE_OK == archive_read_data_block(a, &buff, &bytes_read,
 292             &offset)) {
 293                 if (offset > total || offset == 0) {
 294                         if (offset > total)
 295                                 hole = 1;
 296                         data_blocks++;
 297                 }
 298                 total = offset + bytes_read;
 299         }
 300         if (!hole && data_blocks == 1)
 301                 data_blocks = 0;/* There are no holes */
 302         assertEqualInt(blocks, data_blocks);
 303
 304         assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a));
 305         archive_entry_free(ae);
 306 }
 307
 308 #if defined(_WIN32) && !defined(__CYGWIN__)
 309 #define close           _close
 310 #define open            _open
 311 #endif
 312
 313 /*
 314  * Sparse test without directory traversals.
 315  */
 316 static void
 317 verify_sparse_file2(struct archive *a, const char *path,
 318     const struct sparse *sparse, int blocks, int preopen)
 319 {
 320         struct archive_entry *ae;
 321         int fd;
 322
 323         (void)sparse; /* UNUSED */
 324         assert((ae = archive_entry_new()) != NULL);
 325         archive_entry_set_pathname(ae, path);
 326         if (preopen)
 327                 fd = open(path, O_RDONLY | O_BINARY);
 328         else
 329                 fd = -1;
 330         assertEqualIntA(a, ARCHIVE_OK,
 331             archive_read_disk_entry_from_file(a, ae, fd, NULL));
 332         if (fd >= 0)
 333                 close(fd);
 334         /* Verify the number of holes only, not its offset nor its
 335          * length because those alignments are deeply dependence on
 336          * its filesystem. */
 337         assertEqualInt(blocks, archive_entry_sparse_count(ae));
 338         archive_entry_free(ae);
 339 }
 340
 341 static void
 342 test_sparse_whole_file_data()
 343 {
 344         struct archive_entry *ae;
 345         int64_t offset;
 346         int i;
 347
 348         assert((ae = archive_entry_new()) != NULL);
 349         archive_entry_set_size(ae, 1024*10);
 350
 351         /*
 352          * Add sparse block data up to the file size.
 353          */
 354         offset = 0;
 355         for (i = 0; i < 10; i++) {
 356                 archive_entry_sparse_add_entry(ae, offset, 1024);
 357                 offset += 1024;
 358         }
 359
 360         failure("There should be no sparse");
 361         assertEqualInt(0, archive_entry_sparse_count(ae));
 362         archive_entry_free(ae);
 363 }
 364
 365 DEFINE_TEST(test_sparse_basic)
 366 {
 367         char *cwd;
 368         struct archive *a;
 369         /*
 370          * The alignment of the hole of sparse files deeply depends
 371          * on filesystem. In my experience, sparse_file2 test with
 372          * 204800 bytes hole size did not pass on ZFS and the result
 373          * of that test seemed the size was too small, thus you should
 374          * keep a hole size more than 409600 bytes to pass this test
 375          * on all platform.
 376          */
 377         const struct sparse sparse_file0[] = {
 378                 { DATA,  1024 }, { HOLE,   2048000 },
 379                 { DATA,  2048 }, { HOLE,   2048000 },
 380                 { DATA,  4096 }, { HOLE,  20480000 },
 381                 { DATA,  8192 }, { HOLE, 204800000 },
 382                 { DATA,     1 }, { END, 0 }
 383         };
 384         const struct sparse sparse_file1[] = {
 385                 { HOLE, 409600 }, { DATA, 1 },
 386                 { HOLE, 409600 }, { DATA, 1 },
 387                 { HOLE, 409600 }, { END,  0 }
 388         };
 389         const struct sparse sparse_file2[] = {
 390                 { HOLE, 409600 * 1 }, { DATA, 1024 },
 391                 { HOLE, 409600 * 2 }, { DATA, 1024 },
 392                 { HOLE, 409600 * 3 }, { DATA, 1024 },
 393                 { HOLE, 409600 * 4 }, { DATA, 1024 },
 394                 { HOLE, 409600 * 5 }, { DATA, 1024 },
 395                 { HOLE, 409600 * 6 }, { DATA, 1024 },
 396                 { HOLE, 409600 * 7 }, { DATA, 1024 },
 397                 { HOLE, 409600 * 8 }, { DATA, 1024 },
 398                 { HOLE, 409600 * 9 }, { DATA, 1024 },
 399                 { HOLE, 409600 * 10}, { DATA, 1024 },/* 10 */
 400                 { HOLE, 409600 * 1 }, { DATA, 1024 * 1 },
 401                 { HOLE, 409600 * 2 }, { DATA, 1024 * 2 },
 402                 { HOLE, 409600 * 3 }, { DATA, 1024 * 3 },
 403                 { HOLE, 409600 * 4 }, { DATA, 1024 * 4 },
 404                 { HOLE, 409600 * 5 }, { DATA, 1024 * 5 },
 405                 { HOLE, 409600 * 6 }, { DATA, 1024 * 6 },
 406                 { HOLE, 409600 * 7 }, { DATA, 1024 * 7 },
 407                 { HOLE, 409600 * 8 }, { DATA, 1024 * 8 },
 408                 { HOLE, 409600 * 9 }, { DATA, 1024 * 9 },
 409                 { HOLE, 409600 * 10}, { DATA, 1024 * 10},/* 20 */
 410                 { END,  0 }
 411         };
 412         const struct sparse sparse_file3[] = {
 413                 /* This hole size is too small to create a sparse
 414                  * files for almost filesystem. */
 415                 { HOLE,  1024 }, { DATA, 10240 },
 416                 { END,  0 }
 417         };
 418
 419         /*
 420          * Test for the case that sparse data indicates just the whole file
 421          * data.
 422          */
 423         test_sparse_whole_file_data();
 424
 425         /* Check if the filesystem where CWD on can
 426          * report the number of the holes of a sparse file. */
 427 #ifdef PATH_MAX
 428         cwd = getcwd(NULL, PATH_MAX);/* Solaris getcwd needs the size. */
 429 #else
 430         cwd = getcwd(NULL, 0);
 431 #endif
 432         if (!assert(cwd != NULL))
 433                 return;
 434         if (!is_sparse_supported(cwd)) {
 435                 free(cwd);
 436                 skipping("This filesystem or platform do not support "
 437                     "the reporting of the holes of a sparse file through "
 438                     "API such as lseek(HOLE)");
 439                 return;
 440         }
 441
 442         /*
 443          * Get sparse data through directory traversals.
 444          */
 445         assert((a = archive_read_disk_new()) != NULL);
 446
 447         verify_sparse_file(a, "file0", sparse_file0, 5);
 448         verify_sparse_file(a, "file1", sparse_file1, 2);
 449         verify_sparse_file(a, "file2", sparse_file2, 20);
 450         verify_sparse_file(a, "file3", sparse_file3, 0);
 451
 452         assertEqualInt(ARCHIVE_OK, archive_read_free(a));
 453
 454         /*
 455          * Get sparse data through archive_read_disk_entry_from_file().
 456          */
 457         assert((a = archive_read_disk_new()) != NULL);
 458
 459         verify_sparse_file2(a, "file0", sparse_file0, 5, 0);
 460         verify_sparse_file2(a, "file0", sparse_file0, 5, 1);
 461
 462         assertEqualInt(ARCHIVE_OK, archive_read_free(a));
 463         free(cwd);
 464 }