tests/sys/fs/fusefs/create.cc

   1 /*-
   2  * SPDX-License-Identifier: BSD-2-Clause-FreeBSD
   3  *
   4  * Copyright (c) 2019 The FreeBSD Foundation
   5  *
   6  * This software was developed by BFF Storage Systems, LLC under sponsorship
   7  * from the FreeBSD Foundation.
   8  *
   9  * Redistribution and use in source and binary forms, with or without
  10  * modification, are permitted provided that the following conditions
  11  * are met:
  12  * 1. Redistributions of source code must retain the above copyright
  13  *    notice, this list of conditions and the following disclaimer.
  14  * 2. Redistributions in binary form must reproduce the above copyright
  15  *    notice, this list of conditions and the following disclaimer in the
  16  *    documentation and/or other materials provided with the distribution.
  17  *
  18  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  19  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  20  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  21  * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  22  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  23  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  24  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  25  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  26  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  27  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  28  * SUCH DAMAGE.
  29  */
  30
  31 extern "C" {
  32 #include <fcntl.h>
  33 }
  34
  35 #include "mockfs.hh"
  36 #include "utils.hh"
  37
  38 using namespace testing;
  39
  40 class Create: public FuseTest {
  41 public:
  42
  43 void expect_create(const char *relpath, mode_t mode, ProcessMockerT r)
  44 {
  45         EXPECT_CALL(*m_mock, process(
  46                 ResultOf([=](auto in) {
  47                         const char *name = (const char*)in->body.bytes +
  48                                 sizeof(fuse_open_in);
  49                         return (in->header.opcode == FUSE_CREATE &&
  50                                 in->body.open.mode == mode &&
  51                                 (0 == strcmp(relpath, name)));
  52                 }, Eq(true)),
  53                 _)
  54         ).WillOnce(Invoke(r));
  55 }
  56
  57 };
  58
  59 /* FUSE_CREATE operations for a protocol 7.8 server */
  60 class Create_7_8: public Create {
  61 public:
  62 virtual void SetUp() {
  63         m_kernel_minor_version = 8;
  64         Create::SetUp();
  65 }
  66 };
  67
  68
  69 /*
  70  * If FUSE_CREATE sets attr_valid, then subsequent GETATTRs should use the
  71  * attribute cache
  72  */
  73 TEST_F(Create, attr_cache)
  74 {
  75         const char FULLPATH[] = "mountpoint/some_file.txt";
  76         const char RELPATH[] = "some_file.txt";
  77         mode_t mode = S_IFREG | 0755;
  78         uint64_t ino = 42;
  79         int fd;
  80
  81         EXPECT_LOOKUP(1, RELPATH).WillOnce(Invoke(ReturnErrno(ENOENT)));
  82         expect_create(RELPATH, mode,
  83                 ReturnImmediate([=](auto in __unused, auto out) {
  84                 SET_OUT_HEADER_LEN(out, create);
  85                 out->body.create.entry.attr.mode = mode;
  86                 out->body.create.entry.nodeid = ino;
  87                 out->body.create.entry.entry_valid = UINT64_MAX;
  88                 out->body.create.entry.attr_valid = UINT64_MAX;
  89         }));
  90
  91         EXPECT_CALL(*m_mock, process(
  92                 ResultOf([=](auto in) {
  93                         return (in->header.opcode == FUSE_GETATTR &&
  94                                 in->header.nodeid == ino);
  95                 }, Eq(true)),
  96                 _)
  97         ).Times(0);
  98
  99         fd = open(FULLPATH, O_CREAT | O_EXCL, mode);
 100         EXPECT_LE(0, fd) << strerror(errno);
 101         /* Deliberately leak fd.  close(2) will be tested in release.cc */
 102 }
 103
 104 /* A successful CREATE operation should purge the parent dir's attr cache */
 105 TEST_F(Create, clear_attr_cache)
 106 {
 107         const char FULLPATH[] = "mountpoint/src";
 108         const char RELPATH[] = "src";
 109         mode_t mode = S_IFREG | 0755;
 110         uint64_t ino = 42;
 111         int fd;
 112         struct stat sb;
 113
 114         EXPECT_LOOKUP(1, RELPATH).WillOnce(Invoke(ReturnErrno(ENOENT)));
 115         EXPECT_CALL(*m_mock, process(
 116                 ResultOf([=](auto in) {
 117                         return (in->header.opcode == FUSE_GETATTR &&
 118                                 in->header.nodeid == 1);
 119                 }, Eq(true)),
 120                 _)
 121         ).Times(2)
 122         .WillRepeatedly(Invoke(ReturnImmediate([=](auto i __unused, auto out) {
 123                 SET_OUT_HEADER_LEN(out, attr);
 124                 out->body.attr.attr.ino = 1;
 125                 out->body.attr.attr.mode = S_IFDIR | 0755;
 126                 out->body.attr.attr_valid = UINT64_MAX;
 127         })));
 128
 129         expect_create(RELPATH, mode,
 130                 ReturnImmediate([=](auto in __unused, auto out) {
 131                 SET_OUT_HEADER_LEN(out, create);
 132                 out->body.create.entry.attr.mode = mode;
 133                 out->body.create.entry.nodeid = ino;
 134                 out->body.create.entry.entry_valid = UINT64_MAX;
 135                 out->body.create.entry.attr_valid = UINT64_MAX;
 136         }));
 137
 138         EXPECT_EQ(0, stat("mountpoint", &sb)) << strerror(errno);
 139         fd = open(FULLPATH, O_CREAT | O_EXCL, mode);
 140         EXPECT_LE(0, fd) << strerror(errno);
 141         EXPECT_EQ(0, stat("mountpoint", &sb)) << strerror(errno);
 142
 143         /* Deliberately leak fd.  close(2) will be tested in release.cc */
 144 }
 145
 146 /*
 147  * The fuse daemon fails the request with EEXIST.  This usually indicates a
 148  * race condition: some other FUSE client created the file in between when the
 149  * kernel checked for it with lookup and tried to create it with create
 150  */
 151 TEST_F(Create, eexist)
 152 {
 153         const char FULLPATH[] = "mountpoint/some_file.txt";
 154         const char RELPATH[] = "some_file.txt";
 155         mode_t mode = S_IFREG | 0755;
 156
 157         EXPECT_LOOKUP(1, RELPATH).WillOnce(Invoke(ReturnErrno(ENOENT)));
 158         expect_create(RELPATH, mode, ReturnErrno(EEXIST));
 159         EXPECT_NE(0, open(FULLPATH, O_CREAT | O_EXCL, mode));
 160         EXPECT_EQ(EEXIST, errno);
 161 }
 162
 163 /*
 164  * If the daemon doesn't implement FUSE_CREATE, then the kernel should fallback
 165  * to FUSE_MKNOD/FUSE_OPEN
 166  */
 167 TEST_F(Create, Enosys)
 168 {
 169         const char FULLPATH[] = "mountpoint/some_file.txt";
 170         const char RELPATH[] = "some_file.txt";
 171         mode_t mode = S_IFREG | 0755;
 172         uint64_t ino = 42;
 173         int fd;
 174
 175         EXPECT_LOOKUP(1, RELPATH).WillOnce(Invoke(ReturnErrno(ENOENT)));
 176         expect_create(RELPATH, mode, ReturnErrno(ENOSYS));
 177
 178         EXPECT_CALL(*m_mock, process(
 179                 ResultOf([=](auto in) {
 180                         const char *name = (const char*)in->body.bytes +
 181                                 sizeof(fuse_mknod_in);
 182                         return (in->header.opcode == FUSE_MKNOD &&
 183                                 in->body.mknod.mode == (S_IFREG | mode) &&
 184                                 in->body.mknod.rdev == 0 &&
 185                                 (0 == strcmp(RELPATH, name)));
 186                 }, Eq(true)),
 187                 _)
 188         ).WillOnce(Invoke(ReturnImmediate([=](auto in __unused, auto out) {
 189                 SET_OUT_HEADER_LEN(out, entry);
 190                 out->body.entry.attr.mode = mode;
 191                 out->body.entry.nodeid = ino;
 192                 out->body.entry.entry_valid = UINT64_MAX;
 193                 out->body.entry.attr_valid = UINT64_MAX;
 194         })));
 195
 196         EXPECT_CALL(*m_mock, process(
 197                 ResultOf([=](auto in) {
 198                         return (in->header.opcode == FUSE_OPEN &&
 199                                 in->header.nodeid == ino);
 200                 }, Eq(true)),
 201                 _)
 202         ).WillOnce(Invoke(ReturnImmediate([](auto in __unused, auto out) {
 203                 out->header.len = sizeof(out->header);
 204                 SET_OUT_HEADER_LEN(out, open);
 205         })));
 206
 207         fd = open(FULLPATH, O_CREAT | O_EXCL, mode);
 208         EXPECT_LE(0, fd) << strerror(errno);
 209         /* Deliberately leak fd.  close(2) will be tested in release.cc */
 210 }
 211
 212 /*
 213  * Creating a new file after FUSE_LOOKUP returned a negative cache entry
 214  */
 215 TEST_F(Create, entry_cache_negative)
 216 {
 217         const char FULLPATH[] = "mountpoint/some_file.txt";
 218         const char RELPATH[] = "some_file.txt";
 219         mode_t mode = S_IFREG | 0755;
 220         uint64_t ino = 42;
 221         int fd;
 222         /*
 223          * Set entry_valid = 0 because this test isn't concerned with whether
 224          * or not we actually cache negative entries, only with whether we
 225          * interpret negative cache responses correctly.
 226          */
 227         struct timespec entry_valid = {.tv_sec = 0, .tv_nsec = 0};
 228
 229         /* create will first do a LOOKUP, adding a negative cache entry */
 230         EXPECT_LOOKUP(1, RELPATH).WillOnce(ReturnNegativeCache(&entry_valid));
 231         expect_create(RELPATH, mode,
 232                 ReturnImmediate([=](auto in __unused, auto out) {
 233                 SET_OUT_HEADER_LEN(out, create);
 234                 out->body.create.entry.attr.mode = mode;
 235                 out->body.create.entry.nodeid = ino;
 236                 out->body.create.entry.entry_valid = UINT64_MAX;
 237                 out->body.create.entry.attr_valid = UINT64_MAX;
 238         }));
 239
 240         fd = open(FULLPATH, O_CREAT | O_EXCL, mode);
 241         ASSERT_LE(0, fd) << strerror(errno);
 242         /* Deliberately leak fd.  close(2) will be tested in release.cc */
 243 }
 244
 245 /*
 246  * Creating a new file should purge any negative namecache entries
 247  */
 248 TEST_F(Create, entry_cache_negative_purge)
 249 {
 250         const char FULLPATH[] = "mountpoint/some_file.txt";
 251         const char RELPATH[] = "some_file.txt";
 252         mode_t mode = S_IFREG | 0755;
 253         uint64_t ino = 42;
 254         int fd;
 255         struct timespec entry_valid = {.tv_sec = TIME_T_MAX, .tv_nsec = 0};
 256
 257         /* create will first do a LOOKUP, adding a negative cache entry */
 258         EXPECT_LOOKUP(1, RELPATH).Times(1)
 259         .WillOnce(Invoke(ReturnNegativeCache(&entry_valid)))
 260         .RetiresOnSaturation();
 261
 262         /* Then the CREATE should purge the negative cache entry */
 263         expect_create(RELPATH, mode,
 264                 ReturnImmediate([=](auto in __unused, auto out) {
 265                 SET_OUT_HEADER_LEN(out, create);
 266                 out->body.create.entry.attr.mode = mode;
 267                 out->body.create.entry.nodeid = ino;
 268                 out->body.create.entry.attr_valid = UINT64_MAX;
 269         }));
 270
 271         fd = open(FULLPATH, O_CREAT | O_EXCL, mode);
 272         ASSERT_LE(0, fd) << strerror(errno);
 273
 274         /* Finally, a subsequent lookup should query the daemon */
 275         expect_lookup(RELPATH, ino, S_IFREG | mode, 0, 1);
 276
 277         ASSERT_EQ(0, access(FULLPATH, F_OK)) << strerror(errno);
 278         /* Deliberately leak fd.  close(2) will be tested in release.cc */
 279 }
 280
 281 /*
 282  * The daemon is responsible for checking file permissions (unless the
 283  * default_permissions mount option was used)
 284  */
 285 TEST_F(Create, eperm)
 286 {
 287         const char FULLPATH[] = "mountpoint/some_file.txt";
 288         const char RELPATH[] = "some_file.txt";
 289         mode_t mode = S_IFREG | 0755;
 290
 291         EXPECT_LOOKUP(1, RELPATH).WillOnce(Invoke(ReturnErrno(ENOENT)));
 292         expect_create(RELPATH, mode, ReturnErrno(EPERM));
 293
 294         EXPECT_NE(0, open(FULLPATH, O_CREAT | O_EXCL, mode));
 295         EXPECT_EQ(EPERM, errno);
 296 }
 297
 298 TEST_F(Create, ok)
 299 {
 300         const char FULLPATH[] = "mountpoint/some_file.txt";
 301         const char RELPATH[] = "some_file.txt";
 302         mode_t mode = S_IFREG | 0755;
 303         uint64_t ino = 42;
 304         int fd;
 305
 306         EXPECT_LOOKUP(1, RELPATH).WillOnce(Invoke(ReturnErrno(ENOENT)));
 307         expect_create(RELPATH, mode,
 308                 ReturnImmediate([=](auto in __unused, auto out) {
 309                 SET_OUT_HEADER_LEN(out, create);
 310                 out->body.create.entry.attr.mode = mode;
 311                 out->body.create.entry.nodeid = ino;
 312                 out->body.create.entry.entry_valid = UINT64_MAX;
 313                 out->body.create.entry.attr_valid = UINT64_MAX;
 314         }));
 315
 316         fd = open(FULLPATH, O_CREAT | O_EXCL, mode);
 317         EXPECT_LE(0, fd) << strerror(errno);
 318         /* Deliberately leak fd.  close(2) will be tested in release.cc */
 319 }
 320
 321 /*
 322  * A regression test for a bug that affected old FUSE implementations:
 323  * open(..., O_WRONLY | O_CREAT, 0444) should work despite the seeming
 324  * contradiction between O_WRONLY and 0444
 325  *
 326  * For example:
 327  * https://bugs.launchpad.net/ubuntu/+source/sshfs-fuse/+bug/44886
 328  */
 329 TEST_F(Create, wronly_0444)
 330 {
 331         const char FULLPATH[] = "mountpoint/some_file.txt";
 332         const char RELPATH[] = "some_file.txt";
 333         mode_t mode = S_IFREG | 0444;
 334         uint64_t ino = 42;
 335         int fd;
 336
 337         EXPECT_LOOKUP(1, RELPATH).WillOnce(Invoke(ReturnErrno(ENOENT)));
 338         expect_create(RELPATH, mode,
 339                 ReturnImmediate([=](auto in __unused, auto out) {
 340                 SET_OUT_HEADER_LEN(out, create);
 341                 out->body.create.entry.attr.mode = mode;
 342                 out->body.create.entry.nodeid = ino;
 343                 out->body.create.entry.entry_valid = UINT64_MAX;
 344                 out->body.create.entry.attr_valid = UINT64_MAX;
 345         }));
 346
 347         fd = open(FULLPATH, O_CREAT | O_WRONLY, mode);
 348         EXPECT_LE(0, fd) << strerror(errno);
 349         /* Deliberately leak fd.  close(2) will be tested in release.cc */
 350 }
 351
 352 TEST_F(Create_7_8, ok)
 353 {
 354         const char FULLPATH[] = "mountpoint/some_file.txt";
 355         const char RELPATH[] = "some_file.txt";
 356         mode_t mode = S_IFREG | 0755;
 357         uint64_t ino = 42;
 358         int fd;
 359
 360         EXPECT_LOOKUP(1, RELPATH).WillOnce(Invoke(ReturnErrno(ENOENT)));
 361         expect_create(RELPATH, mode,
 362                 ReturnImmediate([=](auto in __unused, auto out) {
 363                 SET_OUT_HEADER_LEN(out, create_7_8);
 364                 out->body.create.entry.attr.mode = mode;
 365                 out->body.create.entry.nodeid = ino;
 366                 out->body.create.entry.entry_valid = UINT64_MAX;
 367                 out->body.create.entry.attr_valid = UINT64_MAX;
 368         }));
 369
 370         fd = open(FULLPATH, O_CREAT | O_EXCL, mode);
 371         EXPECT_LE(0, fd) << strerror(errno);
 372         /* Deliberately leak fd.  close(2) will be tested in release.cc */
 373 }
 374
 375