system/utest/fs/test-persist.cpp - zircon/ - Git at Google

 // Copyright 2017 The Fuchsia Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.

 #include <assert.h>
 #include <fcntl.h>
 #include <limits.h>
 #include <stdint.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <sys/stat.h>
 #include <unistd.h>

 #include <zircon/compiler.h>
 #include <zircon/syscalls.h>
 #include <fbl/algorithm.h>
 #include <fbl/alloc_checker.h>
 #include <fbl/array.h>
 #include <fbl/string_piece.h>
 #include <fbl/unique_ptr.h>

 #include "filesystems.h"
 #include "misc.h"

 constexpr bool is_directory(const char* const path) {
     return path[fbl::constexpr_strlen(path) - 1] == '/';
 }

 bool TestPersistSimple(void) {
     BEGIN_TEST;

     if (!test_info->can_be_mounted) {
         fprintf(stderr, "Filesystem cannot be mounted; cannot test persistence\n");
         return true;
     }

     const char* const paths[] = {
         "::abc",
         "::def/",
         "::def/def_subdir/",
         "::def/def_subdir/def_subfile",
         "::ghi",
         "::jkl",
         "::mnopqrstuvxyz"
     };
     for (size_t i = 0; i < fbl::count_of(paths); i++) {
         if (is_directory(paths[i])) {
             ASSERT_EQ(mkdir(paths[i], 0644), 0);
         } else {
             int fd = open(paths[i], O_RDWR | O_CREAT | O_EXCL, 0644);
             ASSERT_GT(fd, 0);
             ASSERT_EQ(close(fd), 0);
         }
     }

     ASSERT_TRUE(check_remount(), "Could not remount filesystem");

     // The files should still exist when we remount
     for (ssize_t i = fbl::count_of(paths) - 1; i >= 0; i--) {
         if (is_directory(paths[i])) {
             ASSERT_EQ(rmdir(paths[i]), 0);
         } else {
             ASSERT_EQ(unlink(paths[i]), 0);
         }
     }

     ASSERT_TRUE(check_remount(), "Could not remount filesystem");

     // But they should stay deleted!
     for (ssize_t i = fbl::count_of(paths) - 1; i >= 0; i--) {
         if (is_directory(paths[i])) {
             ASSERT_EQ(rmdir(paths[i]), -1);
         } else {
             ASSERT_EQ(unlink(paths[i]), -1);
         }
     }

     END_TEST;
 }

 bool TestPersistRapidRemount(void) {
     BEGIN_TEST;

     if (!test_info->can_be_mounted) {
         fprintf(stderr, "Filesystem cannot be mounted; cannot test persistence\n");
         return true;
     }

     for (size_t i = 0; i < 100; i++) {
         ASSERT_TRUE(check_remount(), "Could not remount filesystem");
     }

     END_TEST;
 }


 template <size_t BufferSize>
 bool TestPersistWithData(void) {
     BEGIN_TEST;

     if (!test_info->can_be_mounted) {
         fprintf(stderr, "Filesystem cannot be mounted; cannot test persistence\n");
         return true;
     }

     const char* const files[] = {
         "::abc",
         "::def",
         "::and-another-file-filled-with-data",
     };
     fbl::unique_ptr<uint8_t[]> buffers[fbl::count_of(files)];
     unsigned int seed = static_cast<unsigned int>(zx_ticks_get());
     unittest_printf("Persistent data test using seed: %u\n", seed);
     fbl::AllocChecker ac;
     for (size_t i = 0; i < fbl::count_of(files); i++) {
         buffers[i].reset(new (&ac) uint8_t[BufferSize]);
         ASSERT_TRUE(ac.check());

         for (size_t j = 0; j < BufferSize; j++) {
             buffers[i][j] = (uint8_t) rand_r(&seed);
         }
         int fd = open(files[i], O_RDWR | O_CREAT, 0644);
         ASSERT_GT(fd, 0);
         ASSERT_EQ(write(fd, &buffers[i][0], BufferSize), BufferSize);
         ASSERT_EQ(fsync(fd), 0);
         ASSERT_EQ(close(fd), 0);
     }

     ASSERT_TRUE(check_remount(), "Could not remount filesystem");

     // Read files
     for (size_t i = 0; i < fbl::count_of(files); i++) {
         fbl::unique_ptr<uint8_t[]> rbuf(new (&ac) uint8_t[BufferSize]);
         ASSERT_TRUE(ac.check());
         int fd = open(files[i], O_RDONLY, 0644);
         ASSERT_GT(fd, 0);

         struct stat buf;
         ASSERT_EQ(fstat(fd, &buf), 0);
         ASSERT_EQ(buf.st_nlink, 1);
         ASSERT_EQ(buf.st_size, BufferSize);

         ASSERT_EQ(read(fd, &rbuf[0], BufferSize), BufferSize);
         for (size_t j = 0; j < BufferSize; j++) {
             ASSERT_EQ(rbuf[j], buffers[i][j]);
         }

         ASSERT_EQ(close(fd), 0);
     }

     ASSERT_TRUE(check_remount(), "Could not remount filesystem");

     // Delete all files
     for (size_t i = 0; i < fbl::count_of(files); i++) {
         ASSERT_EQ(unlink(files[i]), 0);
     }

     ASSERT_TRUE(check_remount(), "Could not remount filesystem");

     // Files should stay deleted

     DIR* dirp = opendir("::.");
     ASSERT_NONNULL(dirp);
     struct dirent* de;
     de = readdir(dirp);
     ASSERT_NONNULL(de);
     ASSERT_EQ(strncmp(de->d_name, ".", 1), 0);
     ASSERT_NULL(readdir(dirp));
     ASSERT_EQ(closedir(dirp), 0);

     END_TEST;
 }

 constexpr size_t kMaxLoopLength = 26;

 template <bool MoveDirectory, size_t LoopLength, size_t Moves>
 bool TestRenameLoop(void) {
     BEGIN_TEST;

     if (!test_info->can_be_mounted) {
         fprintf(stderr, "Filesystem cannot be mounted; cannot test persistence\n");
         return true;
     }

     static_assert(LoopLength <= kMaxLoopLength, "Loop length too long");

     char src[128];
     // Create "LoopLength" directories
     for (size_t i = 0; i < LoopLength; i++) {
         ASSERT_GT(sprintf(src, "::%c", static_cast<char>('a' + i)), 0);
         ASSERT_EQ(mkdir(src, 0644), 0);
     }

     // Create a 'target'
     if (MoveDirectory) {
         ASSERT_EQ(mkdir("::a/target", 0644), 0);
     } else {
         int fd = open("::a/target", O_RDWR | O_CREAT);
         ASSERT_GT(fd, 0);
         ASSERT_EQ(close(fd), 0);
     }

     // Move the target through the loop a bunch of times
     size_t moves = Moves;
     strcpy(src, "::a/target");
     size_t char_index = 0;
     while (moves--) {
         char dst[128];
         strcpy(dst, src);
         char_index = (char_index + 1) % LoopLength;
         dst[2] = static_cast<char>('a' + char_index);
         ASSERT_EQ(rename(src, dst), 0);
         strcpy(src, dst);
     }

     ASSERT_TRUE(check_remount(), "Could not remount filesystem");

     // Check that the target only exists in ONE directory
     bool target_found = false;
     for (size_t i = 0; i < LoopLength; i++) {
         ASSERT_GT(sprintf(src, "::%c", static_cast<char>('a' + i)), 0);
         DIR* dirp = opendir(src);
         ASSERT_NONNULL(dirp);
         struct dirent* de;
         de = readdir(dirp);
         ASSERT_NONNULL(de);
         ASSERT_EQ(strcmp(de->d_name, "."), 0);
         de = readdir(dirp);
         if (de != nullptr) {
             ASSERT_FALSE(target_found, "Target found twice!");
             ASSERT_EQ(strcmp(de->d_name, "target"), 0, "Non-target found");
             target_found = true;
         }

         ASSERT_EQ(closedir(dirp), 0);
     }
     ASSERT_TRUE(target_found);

     ASSERT_TRUE(check_remount(), "Could not remount filesystem");

     // Clean up

     target_found = false;
     for (size_t i = 0; i < LoopLength; i++) {
         ASSERT_GT(sprintf(src, "::%c", static_cast<char>('a' + i)), 0);
         int ret = unlink(src);
         if (ret != 0) {
             ASSERT_FALSE(target_found);
             ASSERT_GT(sprintf(src, "::%c/target", static_cast<char>('a' + i)), 0);
             ASSERT_EQ(unlink(src), 0);
             ASSERT_GT(sprintf(src, "::%c", static_cast<char>('a' + i)), 0);
             ASSERT_EQ(unlink(src), 0);
             target_found = true;
         }
     }
     ASSERT_TRUE(target_found, "Target was never unlinked");

     END_TEST;
 }

 RUN_FOR_ALL_FILESYSTEMS(persistence_tests,
     RUN_TEST_MEDIUM(TestPersistSimple)
     RUN_TEST_LARGE(TestPersistRapidRemount)
     RUN_TEST_MEDIUM((TestPersistWithData<1>))
     RUN_TEST_MEDIUM((TestPersistWithData<100>))
     RUN_TEST_LARGE((TestPersistWithData<8192 - 1>))
     RUN_TEST_LARGE((TestPersistWithData<8192>))
     RUN_TEST_LARGE((TestPersistWithData<8192 + 1>))
     RUN_TEST_LARGE((TestPersistWithData<8192 * 128>))
     RUN_TEST_MEDIUM((TestRenameLoop<false, 2, 2>));
     RUN_TEST_LARGE((TestRenameLoop<false, 2, 100>));
     RUN_TEST_LARGE((TestRenameLoop<false, 15, 100>));
     RUN_TEST_LARGE((TestRenameLoop<false, 25, 500>));
     RUN_TEST_MEDIUM((TestRenameLoop<true, 2, 2>));
     RUN_TEST_LARGE((TestRenameLoop<true, 2, 100>));
     RUN_TEST_LARGE((TestRenameLoop<true, 15, 100>));
     RUN_TEST_LARGE((TestRenameLoop<true, 25, 500>));
 )
	// Copyright 2017 The Fuchsia Authors. All rights reserved.
	// Use of this source code is governed by a BSD-style license that can be
	// found in the LICENSE file.

	#include <assert.h>
	#include <fcntl.h>
	#include <limits.h>
	#include <stdint.h>
	#include <stdio.h>
	#include <stdlib.h>
	#include <string.h>
	#include <sys/stat.h>
	#include <unistd.h>

	#include <zircon/compiler.h>
	#include <zircon/syscalls.h>
	#include <fbl/algorithm.h>
	#include <fbl/alloc_checker.h>
	#include <fbl/array.h>
	#include <fbl/string_piece.h>
	#include <fbl/unique_ptr.h>

	#include "filesystems.h"
	#include "misc.h"

	constexpr bool is_directory(const char* const path) {
	return path[fbl::constexpr_strlen(path) - 1] == '/';
	}

	bool TestPersistSimple(void) {
	BEGIN_TEST;

	if (!test_info->can_be_mounted) {
	fprintf(stderr, "Filesystem cannot be mounted; cannot test persistence\n");
	return true;
	}

	const char* const paths[] = {
	"::abc",
	"::def/",
	"::def/def_subdir/",
	"::def/def_subdir/def_subfile",
	"::ghi",
	"::jkl",
	"::mnopqrstuvxyz"
	};
	for (size_t i = 0; i < fbl::count_of(paths); i++) {
	if (is_directory(paths[i])) {
	ASSERT_EQ(mkdir(paths[i], 0644), 0);
	} else {
	int fd = open(paths[i], O_RDWR \| O_CREAT \| O_EXCL, 0644);
	ASSERT_GT(fd, 0);
	ASSERT_EQ(close(fd), 0);
	}
	}

	ASSERT_TRUE(check_remount(), "Could not remount filesystem");

	// The files should still exist when we remount
	for (ssize_t i = fbl::count_of(paths) - 1; i >= 0; i--) {
	if (is_directory(paths[i])) {
	ASSERT_EQ(rmdir(paths[i]), 0);
	} else {
	ASSERT_EQ(unlink(paths[i]), 0);
	}
	}

	ASSERT_TRUE(check_remount(), "Could not remount filesystem");

	// But they should stay deleted!
	for (ssize_t i = fbl::count_of(paths) - 1; i >= 0; i--) {
	if (is_directory(paths[i])) {
	ASSERT_EQ(rmdir(paths[i]), -1);
	} else {
	ASSERT_EQ(unlink(paths[i]), -1);
	}
	}

	END_TEST;
	}

	bool TestPersistRapidRemount(void) {
	BEGIN_TEST;

	if (!test_info->can_be_mounted) {
	fprintf(stderr, "Filesystem cannot be mounted; cannot test persistence\n");
	return true;
	}

	for (size_t i = 0; i < 100; i++) {
	ASSERT_TRUE(check_remount(), "Could not remount filesystem");
	}

	END_TEST;
	}


	template <size_t BufferSize>
	bool TestPersistWithData(void) {
	BEGIN_TEST;

	if (!test_info->can_be_mounted) {
	fprintf(stderr, "Filesystem cannot be mounted; cannot test persistence\n");
	return true;
	}

	const char* const files[] = {
	"::abc",
	"::def",
	"::and-another-file-filled-with-data",
	};
	fbl::unique_ptr<uint8_t[]> buffers[fbl::count_of(files)];
	unsigned int seed = static_cast<unsigned int>(zx_ticks_get());
	unittest_printf("Persistent data test using seed: %u\n", seed);
	fbl::AllocChecker ac;
	for (size_t i = 0; i < fbl::count_of(files); i++) {
	buffers[i].reset(new (&ac) uint8_t[BufferSize]);
	ASSERT_TRUE(ac.check());

	for (size_t j = 0; j < BufferSize; j++) {
	buffers[i][j] = (uint8_t) rand_r(&seed);
	}
	int fd = open(files[i], O_RDWR \| O_CREAT, 0644);
	ASSERT_GT(fd, 0);
	ASSERT_EQ(write(fd, &buffers[i][0], BufferSize), BufferSize);
	ASSERT_EQ(fsync(fd), 0);
	ASSERT_EQ(close(fd), 0);
	}

	ASSERT_TRUE(check_remount(), "Could not remount filesystem");

	// Read files
	for (size_t i = 0; i < fbl::count_of(files); i++) {
	fbl::unique_ptr<uint8_t[]> rbuf(new (&ac) uint8_t[BufferSize]);
	ASSERT_TRUE(ac.check());
	int fd = open(files[i], O_RDONLY, 0644);
	ASSERT_GT(fd, 0);

	struct stat buf;
	ASSERT_EQ(fstat(fd, &buf), 0);
	ASSERT_EQ(buf.st_nlink, 1);
	ASSERT_EQ(buf.st_size, BufferSize);

	ASSERT_EQ(read(fd, &rbuf[0], BufferSize), BufferSize);
	for (size_t j = 0; j < BufferSize; j++) {
	ASSERT_EQ(rbuf[j], buffers[i][j]);
	}

	ASSERT_EQ(close(fd), 0);
	}

	ASSERT_TRUE(check_remount(), "Could not remount filesystem");

	// Delete all files
	for (size_t i = 0; i < fbl::count_of(files); i++) {
	ASSERT_EQ(unlink(files[i]), 0);
	}

	ASSERT_TRUE(check_remount(), "Could not remount filesystem");

	// Files should stay deleted

	DIR* dirp = opendir("::.");
	ASSERT_NONNULL(dirp);
	struct dirent* de;
	de = readdir(dirp);
	ASSERT_NONNULL(de);
	ASSERT_EQ(strncmp(de->d_name, ".", 1), 0);
	ASSERT_NULL(readdir(dirp));
	ASSERT_EQ(closedir(dirp), 0);

	END_TEST;
	}

	constexpr size_t kMaxLoopLength = 26;

	template <bool MoveDirectory, size_t LoopLength, size_t Moves>
	bool TestRenameLoop(void) {
	BEGIN_TEST;

	if (!test_info->can_be_mounted) {
	fprintf(stderr, "Filesystem cannot be mounted; cannot test persistence\n");
	return true;
	}

	static_assert(LoopLength <= kMaxLoopLength, "Loop length too long");

	char src[128];
	// Create "LoopLength" directories
	for (size_t i = 0; i < LoopLength; i++) {
	ASSERT_GT(sprintf(src, "::%c", static_cast<char>('a' + i)), 0);
	ASSERT_EQ(mkdir(src, 0644), 0);
	}

	// Create a 'target'
	if (MoveDirectory) {
	ASSERT_EQ(mkdir("::a/target", 0644), 0);
	} else {
	int fd = open("::a/target", O_RDWR \| O_CREAT);
	ASSERT_GT(fd, 0);
	ASSERT_EQ(close(fd), 0);
	}

	// Move the target through the loop a bunch of times
	size_t moves = Moves;
	strcpy(src, "::a/target");
	size_t char_index = 0;
	while (moves--) {
	char dst[128];
	strcpy(dst, src);
	char_index = (char_index + 1) % LoopLength;
	dst[2] = static_cast<char>('a' + char_index);
	ASSERT_EQ(rename(src, dst), 0);
	strcpy(src, dst);
	}

	ASSERT_TRUE(check_remount(), "Could not remount filesystem");

	// Check that the target only exists in ONE directory
	bool target_found = false;
	for (size_t i = 0; i < LoopLength; i++) {
	ASSERT_GT(sprintf(src, "::%c", static_cast<char>('a' + i)), 0);
	DIR* dirp = opendir(src);
	ASSERT_NONNULL(dirp);
	struct dirent* de;
	de = readdir(dirp);
	ASSERT_NONNULL(de);
	ASSERT_EQ(strcmp(de->d_name, "."), 0);
	de = readdir(dirp);
	if (de != nullptr) {
	ASSERT_FALSE(target_found, "Target found twice!");
	ASSERT_EQ(strcmp(de->d_name, "target"), 0, "Non-target found");
	target_found = true;
	}

	ASSERT_EQ(closedir(dirp), 0);
	}
	ASSERT_TRUE(target_found);

	ASSERT_TRUE(check_remount(), "Could not remount filesystem");

	// Clean up

	target_found = false;
	for (size_t i = 0; i < LoopLength; i++) {
	ASSERT_GT(sprintf(src, "::%c", static_cast<char>('a' + i)), 0);
	int ret = unlink(src);
	if (ret != 0) {
	ASSERT_FALSE(target_found);
	ASSERT_GT(sprintf(src, "::%c/target", static_cast<char>('a' + i)), 0);
	ASSERT_EQ(unlink(src), 0);
	ASSERT_GT(sprintf(src, "::%c", static_cast<char>('a' + i)), 0);
	ASSERT_EQ(unlink(src), 0);
	target_found = true;
	}
	}
	ASSERT_TRUE(target_found, "Target was never unlinked");

	END_TEST;
	}

	RUN_FOR_ALL_FILESYSTEMS(persistence_tests,
	RUN_TEST_MEDIUM(TestPersistSimple)
	RUN_TEST_LARGE(TestPersistRapidRemount)
	RUN_TEST_MEDIUM((TestPersistWithData<1>))
	RUN_TEST_MEDIUM((TestPersistWithData<100>))
	RUN_TEST_LARGE((TestPersistWithData<8192 - 1>))
	RUN_TEST_LARGE((TestPersistWithData<8192>))
	RUN_TEST_LARGE((TestPersistWithData<8192 + 1>))
	RUN_TEST_LARGE((TestPersistWithData<8192 * 128>))
	RUN_TEST_MEDIUM((TestRenameLoop<false, 2, 2>));
	RUN_TEST_LARGE((TestRenameLoop<false, 2, 100>));
	RUN_TEST_LARGE((TestRenameLoop<false, 15, 100>));
	RUN_TEST_LARGE((TestRenameLoop<false, 25, 500>));
	RUN_TEST_MEDIUM((TestRenameLoop<true, 2, 2>));
	RUN_TEST_LARGE((TestRenameLoop<true, 2, 100>));
	RUN_TEST_LARGE((TestRenameLoop<true, 15, 100>));
	RUN_TEST_LARGE((TestRenameLoop<true, 25, 500>));
	)