tests/sys/fs/fusefs/create.cc

   1 /*-
   2  * SPDX-License-Identifier: BSD-2-Clause
   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  * $FreeBSD$
  31  */
  32
  33 extern "C" {
  34 #include <fcntl.h>
  35 }
  36
  37 #include "mockfs.hh"
  38 #include "utils.hh"
  39
  40 using namespace testing;
  41
  42 class Create: public FuseTest {
  43 public:
  44
  45 void expect_create(const char *relpath, mode_t mode, ProcessMockerT r)
  46 {
  47         mode_t mask = umask(0);
  48         (void)umask(mask);
  49
  50         EXPECT_CALL(*m_mock, process(
  51                 ResultOf([=](auto in) {
  52                         const char *name = (const char*)in.body.bytes +
  53                                 sizeof(fuse_create_in);
  54                         return (in.header.opcode == FUSE_CREATE &&
  55                                 in.body.create.mode == mode &&
  56                                 in.body.create.umask == mask &&
  57                                 (0 == strcmp(relpath, name)));
  58                 }, Eq(true)),
  59                 _)
  60         ).WillOnce(Invoke(r));
  61 }
  62
  63 };
  64
  65 /* FUSE_CREATE operations for a protocol 7.8 server */
  66 class Create_7_8: public Create {
  67 public:
  68 virtual void SetUp() {
  69         m_kernel_minor_version = 8;
  70         Create::SetUp();
  71 }
  72
  73 void expect_create(const char *relpath, mode_t mode, ProcessMockerT r)
  74 {
  75         EXPECT_CALL(*m_mock, process(
  76                 ResultOf([=](auto in) {
  77                         const char *name = (const char*)in.body.bytes +
  78                                 sizeof(fuse_open_in);
  79                         return (in.header.opcode == FUSE_CREATE &&
  80                                 in.body.create.mode == mode &&
  81                                 (0 == strcmp(relpath, name)));
  82                 }, Eq(true)),
  83                 _)
  84         ).WillOnce(Invoke(r));
  85 }
  86
  87 };
  88
  89 /* FUSE_CREATE operations for a server built at protocol <= 7.11 */
  90 class Create_7_11: public FuseTest {
  91 public:
  92 virtual void SetUp() {
  93         m_kernel_minor_version = 11;
  94         FuseTest::SetUp();
  95 }
  96
  97 void expect_create(const char *relpath, mode_t mode, ProcessMockerT r)
  98 {
  99         EXPECT_CALL(*m_mock, process(
 100                 ResultOf([=](auto in) {
 101                         const char *name = (const char*)in.body.bytes +
 102                                 sizeof(fuse_open_in);
 103                         return (in.header.opcode == FUSE_CREATE &&
 104                                 in.body.create.mode == mode &&
 105                                 (0 == strcmp(relpath, name)));
 106                 }, Eq(true)),
 107                 _)
 108         ).WillOnce(Invoke(r));
 109 }
 110
 111 };
 112
 113
 114 /*
 115  * If FUSE_CREATE sets attr_valid, then subsequent GETATTRs should use the
 116  * attribute cache
 117  */
 118 TEST_F(Create, attr_cache)
 119 {
 120         const char FULLPATH[] = "mountpoint/some_file.txt";
 121         const char RELPATH[] = "some_file.txt";
 122         mode_t mode = S_IFREG | 0755;
 123         uint64_t ino = 42;
 124         int fd;
 125
 126         EXPECT_LOOKUP(FUSE_ROOT_ID, RELPATH)
 127                 .WillOnce(Invoke(ReturnErrno(ENOENT)));
 128         expect_create(RELPATH, mode,
 129                 ReturnImmediate([=](auto in __unused, auto& out) {
 130                 SET_OUT_HEADER_LEN(out, create);
 131                 out.body.create.entry.attr.mode = mode;
 132                 out.body.create.entry.nodeid = ino;
 133                 out.body.create.entry.entry_valid = UINT64_MAX;
 134                 out.body.create.entry.attr_valid = UINT64_MAX;
 135         }));
 136
 137         EXPECT_CALL(*m_mock, process(
 138                 ResultOf([=](auto in) {
 139                         return (in.header.opcode == FUSE_GETATTR &&
 140                                 in.header.nodeid == ino);
 141                 }, Eq(true)),
 142                 _)
 143         ).Times(0);
 144
 145         fd = open(FULLPATH, O_CREAT | O_EXCL, mode);
 146         ASSERT_LE(0, fd) << strerror(errno);
 147         leak(fd);
 148 }
 149
 150 /* A successful CREATE operation should purge the parent dir's attr cache */
 151 TEST_F(Create, clear_attr_cache)
 152 {
 153         const char FULLPATH[] = "mountpoint/src";
 154         const char RELPATH[] = "src";
 155         mode_t mode = S_IFREG | 0755;
 156         uint64_t ino = 42;
 157         int fd;
 158         struct stat sb;
 159
 160         EXPECT_LOOKUP(FUSE_ROOT_ID, RELPATH)
 161                 .WillOnce(Invoke(ReturnErrno(ENOENT)));
 162         EXPECT_CALL(*m_mock, process(
 163                 ResultOf([=](auto in) {
 164                         return (in.header.opcode == FUSE_GETATTR &&
 165                                 in.header.nodeid == FUSE_ROOT_ID);
 166                 }, Eq(true)),
 167                 _)
 168         ).Times(2)
 169         .WillRepeatedly(Invoke(ReturnImmediate([=](auto i __unused, auto& out) {
 170                 SET_OUT_HEADER_LEN(out, attr);
 171                 out.body.attr.attr.ino = FUSE_ROOT_ID;
 172                 out.body.attr.attr.mode = S_IFDIR | 0755;
 173                 out.body.attr.attr_valid = UINT64_MAX;
 174         })));
 175
 176         expect_create(RELPATH, mode,
 177                 ReturnImmediate([=](auto in __unused, auto& out) {
 178                 SET_OUT_HEADER_LEN(out, create);
 179                 out.body.create.entry.attr.mode = mode;
 180                 out.body.create.entry.nodeid = ino;
 181                 out.body.create.entry.entry_valid = UINT64_MAX;
 182                 out.body.create.entry.attr_valid = UINT64_MAX;
 183         }));
 184
 185         EXPECT_EQ(0, stat("mountpoint", &sb)) << strerror(errno);
 186         fd = open(FULLPATH, O_CREAT | O_EXCL, mode);
 187         ASSERT_LE(0, fd) << strerror(errno);
 188         EXPECT_EQ(0, stat("mountpoint", &sb)) << strerror(errno);
 189
 190         leak(fd);
 191 }
 192
 193 /*
 194  * The fuse daemon fails the request with EEXIST.  This usually indicates a
 195  * race condition: some other FUSE client created the file in between when the
 196  * kernel checked for it with lookup and tried to create it with create
 197  */
 198 TEST_F(Create, eexist)
 199 {
 200         const char FULLPATH[] = "mountpoint/some_file.txt";
 201         const char RELPATH[] = "some_file.txt";
 202         mode_t mode = S_IFREG | 0755;
 203
 204         EXPECT_LOOKUP(FUSE_ROOT_ID, RELPATH)
 205                 .WillOnce(Invoke(ReturnErrno(ENOENT)));
 206         expect_create(RELPATH, mode, ReturnErrno(EEXIST));
 207         EXPECT_EQ(-1, open(FULLPATH, O_CREAT | O_EXCL, mode));
 208         EXPECT_EQ(EEXIST, errno);
 209 }
 210
 211 /*
 212  * If the daemon doesn't implement FUSE_CREATE, then the kernel should fallback
 213  * to FUSE_MKNOD/FUSE_OPEN
 214  */
 215 TEST_F(Create, Enosys)
 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         EXPECT_LOOKUP(FUSE_ROOT_ID, RELPATH)
 224                 .WillOnce(Invoke(ReturnErrno(ENOENT)));
 225         expect_create(RELPATH, mode, ReturnErrno(ENOSYS));
 226
 227         EXPECT_CALL(*m_mock, process(
 228                 ResultOf([=](auto in) {
 229                         const char *name = (const char*)in.body.bytes +
 230                                 sizeof(fuse_mknod_in);
 231                         return (in.header.opcode == FUSE_MKNOD &&
 232                                 in.body.mknod.mode == (S_IFREG | mode) &&
 233                                 in.body.mknod.rdev == 0 &&
 234                                 (0 == strcmp(RELPATH, name)));
 235                 }, Eq(true)),
 236                 _)
 237         ).WillOnce(Invoke(ReturnImmediate([=](auto in __unused, auto& out) {
 238                 SET_OUT_HEADER_LEN(out, entry);
 239                 out.body.entry.attr.mode = mode;
 240                 out.body.entry.nodeid = ino;
 241                 out.body.entry.entry_valid = UINT64_MAX;
 242                 out.body.entry.attr_valid = UINT64_MAX;
 243         })));
 244
 245         EXPECT_CALL(*m_mock, process(
 246                 ResultOf([=](auto in) {
 247                         return (in.header.opcode == FUSE_OPEN &&
 248                                 in.header.nodeid == ino);
 249                 }, Eq(true)),
 250                 _)
 251         ).WillOnce(Invoke(ReturnImmediate([](auto in __unused, auto& out) {
 252                 out.header.len = sizeof(out.header);
 253                 SET_OUT_HEADER_LEN(out, open);
 254         })));
 255
 256         fd = open(FULLPATH, O_CREAT | O_EXCL, mode);
 257         ASSERT_LE(0, fd) << strerror(errno);
 258         leak(fd);
 259 }
 260
 261 /*
 262  * Creating a new file after FUSE_LOOKUP returned a negative cache entry
 263  */
 264 TEST_F(Create, entry_cache_negative)
 265 {
 266         const char FULLPATH[] = "mountpoint/some_file.txt";
 267         const char RELPATH[] = "some_file.txt";
 268         mode_t mode = S_IFREG | 0755;
 269         uint64_t ino = 42;
 270         int fd;
 271         /*
 272          * Set entry_valid = 0 because this test isn't concerned with whether
 273          * or not we actually cache negative entries, only with whether we
 274          * interpret negative cache responses correctly.
 275          */
 276         struct timespec entry_valid = {.tv_sec = 0, .tv_nsec = 0};
 277
 278         /* create will first do a LOOKUP, adding a negative cache entry */
 279         EXPECT_LOOKUP(FUSE_ROOT_ID, RELPATH)
 280                 .WillOnce(ReturnNegativeCache(&entry_valid));
 281         expect_create(RELPATH, mode,
 282                 ReturnImmediate([=](auto in __unused, auto& out) {
 283                 SET_OUT_HEADER_LEN(out, create);
 284                 out.body.create.entry.attr.mode = mode;
 285                 out.body.create.entry.nodeid = ino;
 286                 out.body.create.entry.entry_valid = UINT64_MAX;
 287                 out.body.create.entry.attr_valid = UINT64_MAX;
 288         }));
 289
 290         fd = open(FULLPATH, O_CREAT | O_EXCL, mode);
 291         ASSERT_LE(0, fd) << strerror(errno);
 292         leak(fd);
 293 }
 294
 295 /*
 296  * Creating a new file should purge any negative namecache entries
 297  */
 298 TEST_F(Create, entry_cache_negative_purge)
 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         struct timespec entry_valid = {.tv_sec = TIME_T_MAX, .tv_nsec = 0};
 306
 307         /* create will first do a LOOKUP, adding a negative cache entry */
 308         EXPECT_LOOKUP(FUSE_ROOT_ID, RELPATH).Times(1)
 309                 .WillOnce(Invoke(ReturnNegativeCache(&entry_valid)))
 310         .RetiresOnSaturation();
 311
 312         /* Then the CREATE should purge the negative cache entry */
 313         expect_create(RELPATH, mode,
 314                 ReturnImmediate([=](auto in __unused, auto& out) {
 315                 SET_OUT_HEADER_LEN(out, create);
 316                 out.body.create.entry.attr.mode = mode;
 317                 out.body.create.entry.nodeid = ino;
 318                 out.body.create.entry.attr_valid = UINT64_MAX;
 319         }));
 320
 321         fd = open(FULLPATH, O_CREAT | O_EXCL, mode);
 322         ASSERT_LE(0, fd) << strerror(errno);
 323
 324         /* Finally, a subsequent lookup should query the daemon */
 325         expect_lookup(RELPATH, ino, S_IFREG | mode, 0, 1);
 326
 327         ASSERT_EQ(0, access(FULLPATH, F_OK)) << strerror(errno);
 328         leak(fd);
 329 }
 330
 331 /*
 332  * The daemon is responsible for checking file permissions (unless the
 333  * default_permissions mount option was used)
 334  */
 335 TEST_F(Create, eperm)
 336 {
 337         const char FULLPATH[] = "mountpoint/some_file.txt";
 338         const char RELPATH[] = "some_file.txt";
 339         mode_t mode = S_IFREG | 0755;
 340
 341         EXPECT_LOOKUP(FUSE_ROOT_ID, RELPATH)
 342                 .WillOnce(Invoke(ReturnErrno(ENOENT)));
 343         expect_create(RELPATH, mode, ReturnErrno(EPERM));
 344
 345         EXPECT_EQ(-1, open(FULLPATH, O_CREAT | O_EXCL, mode));
 346         EXPECT_EQ(EPERM, errno);
 347 }
 348
 349 TEST_F(Create, ok)
 350 {
 351         const char FULLPATH[] = "mountpoint/some_file.txt";
 352         const char RELPATH[] = "some_file.txt";
 353         mode_t mode = S_IFREG | 0755;
 354         uint64_t ino = 42;
 355         int fd;
 356
 357         EXPECT_LOOKUP(FUSE_ROOT_ID, RELPATH)
 358                 .WillOnce(Invoke(ReturnErrno(ENOENT)));
 359         expect_create(RELPATH, mode,
 360                 ReturnImmediate([=](auto in __unused, auto& out) {
 361                 SET_OUT_HEADER_LEN(out, create);
 362                 out.body.create.entry.attr.mode = mode;
 363                 out.body.create.entry.nodeid = ino;
 364                 out.body.create.entry.entry_valid = UINT64_MAX;
 365                 out.body.create.entry.attr_valid = UINT64_MAX;
 366         }));
 367
 368         fd = open(FULLPATH, O_CREAT | O_EXCL, mode);
 369         ASSERT_LE(0, fd) << strerror(errno);
 370         leak(fd);
 371 }
 372
 373 /*
 374  * Nothing bad should happen if the server returns the parent's inode number
 375  * for the newly created file.  Regression test for bug 263662
 376  * https://bugs.freebsd.org/bugzilla/show_bug.cgi?id=263662
 377  */
 378 TEST_F(Create, parent_inode)
 379 {
 380         const char FULLPATH[] = "mountpoint/some_dir/some_file.txt";
 381         const char RELDIRPATH[] = "some_dir";
 382         const char RELPATH[] = "some_file.txt";
 383         mode_t mode = 0755;
 384         uint64_t ino = 42;
 385         int fd;
 386
 387         expect_lookup(RELDIRPATH, ino, S_IFDIR | mode, 0, 1);
 388         EXPECT_LOOKUP(ino, RELPATH)
 389                 .WillOnce(Invoke(ReturnErrno(ENOENT)));
 390         expect_create(RELPATH, S_IFREG | mode,
 391                 ReturnImmediate([=](auto in __unused, auto& out) {
 392                 SET_OUT_HEADER_LEN(out, create);
 393                 out.body.create.entry.attr.mode = S_IFREG | mode;
 394                 /* Return the same inode as the parent dir */
 395                 out.body.create.entry.nodeid = ino;
 396                 out.body.create.entry.entry_valid = UINT64_MAX;
 397                 out.body.create.entry.attr_valid = UINT64_MAX;
 398         }));
 399         // FUSE_RELEASE happens asynchronously, so it may or may not arrive
 400         // before the test completes.
 401         EXPECT_CALL(*m_mock, process(
 402                 ResultOf([=](auto in) {
 403                         return (in.header.opcode == FUSE_RELEASE);
 404                 }, Eq(true)),
 405                 _)
 406         ).Times(AtMost(1))
 407         .WillOnce(Invoke([=](auto in __unused, auto &out __unused) { }));
 408
 409         fd = open(FULLPATH, O_CREAT | O_EXCL, mode);
 410         ASSERT_EQ(-1, fd);
 411         EXPECT_EQ(EIO, errno);
 412 }
 413
 414 /*
 415  * A regression test for a bug that affected old FUSE implementations:
 416  * open(..., O_WRONLY | O_CREAT, 0444) should work despite the seeming
 417  * contradiction between O_WRONLY and 0444
 418  *
 419  * For example:
 420  * https://bugs.launchpad.net/ubuntu/+source/sshfs-fuse/+bug/44886
 421  */
 422 TEST_F(Create, wronly_0444)
 423 {
 424         const char FULLPATH[] = "mountpoint/some_file.txt";
 425         const char RELPATH[] = "some_file.txt";
 426         mode_t mode = S_IFREG | 0444;
 427         uint64_t ino = 42;
 428         int fd;
 429
 430         EXPECT_LOOKUP(FUSE_ROOT_ID, RELPATH)
 431                 .WillOnce(Invoke(ReturnErrno(ENOENT)));
 432         expect_create(RELPATH, mode,
 433                 ReturnImmediate([=](auto in __unused, auto& out) {
 434                 SET_OUT_HEADER_LEN(out, create);
 435                 out.body.create.entry.attr.mode = mode;
 436                 out.body.create.entry.nodeid = ino;
 437                 out.body.create.entry.entry_valid = UINT64_MAX;
 438                 out.body.create.entry.attr_valid = UINT64_MAX;
 439         }));
 440
 441         fd = open(FULLPATH, O_CREAT | O_WRONLY, mode);
 442         ASSERT_LE(0, fd) << strerror(errno);
 443         leak(fd);
 444 }
 445
 446 TEST_F(Create_7_8, ok)
 447 {
 448         const char FULLPATH[] = "mountpoint/some_file.txt";
 449         const char RELPATH[] = "some_file.txt";
 450         mode_t mode = S_IFREG | 0755;
 451         uint64_t ino = 42;
 452         int fd;
 453
 454         EXPECT_LOOKUP(FUSE_ROOT_ID, RELPATH)
 455                 .WillOnce(Invoke(ReturnErrno(ENOENT)));
 456         expect_create(RELPATH, mode,
 457                 ReturnImmediate([=](auto in __unused, auto& out) {
 458                 SET_OUT_HEADER_LEN(out, create_7_8);
 459                 out.body.create_7_8.entry.attr.mode = mode;
 460                 out.body.create_7_8.entry.nodeid = ino;
 461                 out.body.create_7_8.entry.entry_valid = UINT64_MAX;
 462                 out.body.create_7_8.entry.attr_valid = UINT64_MAX;
 463                 out.body.create_7_8.open.fh = FH;
 464         }));
 465         expect_flush(ino, 1, ReturnErrno(0));
 466         expect_release(ino, FH);
 467
 468         fd = open(FULLPATH, O_CREAT | O_EXCL, mode);
 469         ASSERT_LE(0, fd) << strerror(errno);
 470         close(fd);
 471 }
 472
 473 TEST_F(Create_7_11, ok)
 474 {
 475         const char FULLPATH[] = "mountpoint/some_file.txt";
 476         const char RELPATH[] = "some_file.txt";
 477         mode_t mode = S_IFREG | 0755;
 478         uint64_t ino = 42;
 479         int fd;
 480
 481         EXPECT_LOOKUP(FUSE_ROOT_ID, RELPATH)
 482                 .WillOnce(Invoke(ReturnErrno(ENOENT)));
 483         expect_create(RELPATH, mode,
 484                 ReturnImmediate([=](auto in __unused, auto& out) {
 485                 SET_OUT_HEADER_LEN(out, create);
 486                 out.body.create.entry.attr.mode = mode;
 487                 out.body.create.entry.nodeid = ino;
 488                 out.body.create.entry.entry_valid = UINT64_MAX;
 489                 out.body.create.entry.attr_valid = UINT64_MAX;
 490         }));
 491
 492         fd = open(FULLPATH, O_CREAT | O_EXCL, mode);
 493         ASSERT_LE(0, fd) << strerror(errno);
 494         leak(fd);
 495 }