tests/sys/fs/fusefs/cache.cc

   1 /*-
   2  * SPDX-License-Identifier: BSD-2-Clause
   3  *
   4  * Copyright (c) 2020 Alan Somers
   5  *
   6  * Redistribution and use in source and binary forms, with or without
   7  * modification, are permitted provided that the following conditions
   8  * are met:
   9  * 1. Redistributions of source code must retain the above copyright
  10  *    notice, this list of conditions and the following disclaimer.
  11  * 2. Redistributions in binary form must reproduce the above copyright
  12  *    notice, this list of conditions and the following disclaimer in the
  13  *    documentation and/or other materials provided with the distribution.
  14  *
  15  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  16  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  17  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  18  * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  19  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  20  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  21  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  22  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  23  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  24  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  25  * SUCH DAMAGE.
  26  *
  27  * $FreeBSD$
  28  */
  29
  30 extern "C" {
  31 #include <sys/param.h>
  32 #include <fcntl.h>
  33 }
  34
  35 #include "mockfs.hh"
  36 #include "utils.hh"
  37
  38 /*
  39  * Tests for thorny cache problems not specific to any one opcode
  40  */
  41
  42 using namespace testing;
  43
  44 /*
  45  * Parameters
  46  * - reopen file        - If true, close and reopen the file between reads
  47  * - cache lookups      - If true, allow lookups to be cached
  48  * - cache attrs        - If true, allow file attributes to be cached
  49  * - cache_mode         - uncached, writeback, or writethrough
  50  * - initial size       - File size before truncation
  51  * - truncated size     - File size after truncation
  52  */
  53 typedef tuple<tuple<bool, bool, bool>, cache_mode, ssize_t, ssize_t> CacheParam;
  54
  55 class Cache: public FuseTest, public WithParamInterface<CacheParam> {
  56 public:
  57 bool m_direct_io;
  58
  59 Cache(): m_direct_io(false) {};
  60
  61 virtual void SetUp() {
  62         int cache_mode = get<1>(GetParam());
  63         switch (cache_mode) {
  64                 case Uncached:
  65                         m_direct_io = true;
  66                         break;
  67                 case WritebackAsync:
  68                         m_async = true;
  69                         /* FALLTHROUGH */
  70                 case Writeback:
  71                         m_init_flags |= FUSE_WRITEBACK_CACHE;
  72                         /* FALLTHROUGH */
  73                 case Writethrough:
  74                         break;
  75                 default:
  76                         FAIL() << "Unknown cache mode";
  77         }
  78         m_noatime = true;       // To prevent SETATTR for atime on close
  79
  80         FuseTest::SetUp();
  81         if (IsSkipped())
  82                 return;
  83 }
  84
  85 void expect_getattr(uint64_t ino, int times, uint64_t size, uint64_t attr_valid)
  86 {
  87         EXPECT_CALL(*m_mock, process(
  88                 ResultOf([=](auto in) {
  89                         return (in.header.opcode == FUSE_GETATTR &&
  90                                 in.header.nodeid == ino);
  91                 }, Eq(true)),
  92                 _)
  93         ).Times(times)
  94         .WillRepeatedly(Invoke(ReturnImmediate([=](auto i __unused, auto& out) {
  95                 SET_OUT_HEADER_LEN(out, attr);
  96                 out.body.attr.attr_valid = attr_valid;
  97                 out.body.attr.attr.ino = ino;
  98                 out.body.attr.attr.mode = S_IFREG | 0644;
  99                 out.body.attr.attr.size = size;
 100         })));
 101 }
 102
 103 void expect_lookup(const char *relpath, uint64_t ino,
 104         uint64_t size, uint64_t entry_valid, uint64_t attr_valid)
 105 {
 106         EXPECT_LOOKUP(FUSE_ROOT_ID, relpath)
 107         .WillRepeatedly(Invoke(ReturnImmediate([=](auto in __unused, auto& out) {
 108                 SET_OUT_HEADER_LEN(out, entry);
 109                 out.body.entry.attr.mode = S_IFREG | 0644;
 110                 out.body.entry.nodeid = ino;
 111                 out.body.entry.attr.nlink = 1;
 112                 out.body.entry.attr_valid = attr_valid;
 113                 out.body.entry.attr.size = size;
 114                 out.body.entry.entry_valid = entry_valid;
 115         })));
 116 }
 117
 118 void expect_open(uint64_t ino, int times)
 119 {
 120         FuseTest::expect_open(ino, m_direct_io ? FOPEN_DIRECT_IO: 0, times);
 121 }
 122
 123 void expect_release(uint64_t ino, ProcessMockerT r)
 124 {
 125         EXPECT_CALL(*m_mock, process(
 126                 ResultOf([=](auto in) {
 127                         return (in.header.opcode == FUSE_RELEASE &&
 128                                 in.header.nodeid == ino);
 129                 }, Eq(true)),
 130                 _)
 131         ).WillRepeatedly(Invoke(r));
 132 }
 133
 134 };
 135
 136 // If the server truncates the file behind the kernel's back, the kernel should
 137 // invalidate cached pages beyond the new EOF
 138 TEST_P(Cache, truncate_by_surprise_invalidates_cache)
 139 {
 140         const char FULLPATH[] = "mountpoint/some_file.txt";
 141         const char RELPATH[] = "some_file.txt";
 142         const char *CONTENTS = "abcdefghijklmnopqrstuvwxyz";
 143         uint64_t ino = 42;
 144         uint64_t attr_valid, entry_valid;
 145         int fd;
 146         ssize_t bufsize = strlen(CONTENTS);
 147         uint8_t buf[bufsize];
 148         bool reopen = get<0>(get<0>(GetParam()));
 149         bool cache_lookups = get<1>(get<0>(GetParam()));
 150         bool cache_attrs = get<2>(get<0>(GetParam()));
 151         ssize_t osize = get<2>(GetParam());
 152         ssize_t nsize = get<3>(GetParam());
 153
 154         ASSERT_LE(osize, bufsize);
 155         ASSERT_LE(nsize, bufsize);
 156         if (cache_attrs)
 157                 attr_valid = UINT64_MAX;
 158         else
 159                 attr_valid = 0;
 160         if (cache_lookups)
 161                 entry_valid = UINT64_MAX;
 162         else
 163                 entry_valid = 0;
 164
 165         expect_lookup(RELPATH, ino, osize, entry_valid, attr_valid);
 166         expect_open(ino, 1);
 167         if (!cache_attrs)
 168                 expect_getattr(ino, 2, osize, attr_valid);
 169         expect_read(ino, 0, osize, osize, CONTENTS);
 170
 171         fd = open(FULLPATH, O_RDONLY);
 172         ASSERT_LE(0, fd) << strerror(errno);
 173
 174         ASSERT_EQ(osize, read(fd, buf, bufsize)) << strerror(errno);
 175         ASSERT_EQ(0, memcmp(buf, CONTENTS, osize));
 176
 177         // Now truncate the file behind the kernel's back.  The next read
 178         // should discard cache and fetch from disk again.
 179         if (reopen) {
 180                 // Close and reopen the file
 181                 expect_flush(ino, 1, ReturnErrno(ENOSYS));
 182                 expect_release(ino, ReturnErrno(0));
 183                 ASSERT_EQ(0, close(fd));
 184                 expect_lookup(RELPATH, ino, nsize, entry_valid, attr_valid);
 185                 expect_open(ino, 1);
 186                 fd = open(FULLPATH, O_RDONLY);
 187                 ASSERT_LE(0, fd) << strerror(errno);
 188         }
 189
 190         if (!cache_attrs)
 191                 expect_getattr(ino, 1, nsize, attr_valid);
 192         expect_read(ino, 0, nsize, nsize, CONTENTS);
 193         ASSERT_EQ(0, lseek(fd, 0, SEEK_SET));
 194         ASSERT_EQ(nsize, read(fd, buf, bufsize)) << strerror(errno);
 195         ASSERT_EQ(0, memcmp(buf, CONTENTS, nsize));
 196
 197         leak(fd);
 198 }
 199
 200 INSTANTIATE_TEST_CASE_P(Cache, Cache,
 201         Combine(
 202                 /* Test every combination that:
 203                  * - does not cache at least one of entries and attrs
 204                  * - either doesn't cache attrs, or reopens the file
 205                  * In the other combinations, the kernel will never learn that
 206                  * the file's size has changed.
 207                  */
 208                 Values(
 209                         std::make_tuple(false, false, false),
 210                         std::make_tuple(false, true, false),
 211                         std::make_tuple(true, false, false),
 212                         std::make_tuple(true, false, true),
 213                         std::make_tuple(true, true, false)
 214                 ),
 215                 Values(Writethrough, Writeback),
 216                 /* Test both reductions and extensions to file size */
 217                 Values(20),
 218                 Values(10, 25)
 219         )
 220 );