tests/sys/fs/fusefs/fallocate.cc

   1 /*-
   2  * SPDX-License-Identifier: BSD-2-Clause
   3  *
   4  * Copyright (c) 2021 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 <sys/mount.h>
  33 #include <sys/resource.h>
  34 #include <sys/time.h>
  35
  36 #include <fcntl.h>
  37 #include <signal.h>
  38 #include <unistd.h>
  39
  40 #include "mntopts.h"    // for build_iovec
  41 }
  42
  43 #include "mockfs.hh"
  44 #include "utils.hh"
  45
  46 using namespace testing;
  47
  48 /* Is buf all zero? */
  49 static bool
  50 is_zero(const char *buf, uint64_t size)
  51 {
  52     return buf[0] == 0 && !memcmp(buf, buf + 1, size - 1);
  53 }
  54
  55 class Fallocate: public FuseTest {
  56 public:
  57 /*
  58  * expect VOP_DEALLOCATE to be implemented by vop_stddeallocate.
  59  */
  60 void expect_vop_stddeallocate(uint64_t ino, uint64_t off, uint64_t length)
  61 {
  62         /* XXX read offset and size may depend on cache mode */
  63         EXPECT_CALL(*m_mock, process(
  64                 ResultOf([=](auto in) {
  65                         return (in.header.opcode == FUSE_READ &&
  66                                 in.header.nodeid == ino &&
  67                                 in.body.read.offset <= off &&
  68                                 in.body.read.offset + in.body.read.size >=
  69                                         off + length);
  70                 }, Eq(true)),
  71                 _)
  72         ).WillOnce(Invoke(ReturnImmediate([=](auto in, auto& out) {
  73                 assert(in.body.read.size <= sizeof(out.body.bytes));
  74                 out.header.len = sizeof(struct fuse_out_header) +
  75                         in.body.read.size;
  76                 memset(out.body.bytes, 'X', in.body.read.size);
  77         }))).RetiresOnSaturation();
  78         EXPECT_CALL(*m_mock, process(
  79                 ResultOf([=](auto in) {
  80                         const char *buf = (const char*)in.body.bytes +
  81                                 sizeof(struct fuse_write_in);
  82
  83                         assert(length <= sizeof(in.body.bytes) -
  84                                 sizeof(struct fuse_write_in));
  85                         return (in.header.opcode == FUSE_WRITE &&
  86                                 in.header.nodeid == ino &&
  87                                 in.body.write.offset == off  &&
  88                                 in.body.write.size == length &&
  89                                 is_zero(buf, length));
  90                 }, Eq(true)),
  91                 _)
  92         ).WillOnce(Invoke(ReturnImmediate([=](auto in __unused, auto& out) {
  93                 SET_OUT_HEADER_LEN(out, write);
  94                 out.body.write.size = length;
  95         })));
  96 }
  97 };
  98
  99 class Fspacectl: public Fallocate {};
 100
 101 class Fspacectl_7_18: public Fspacectl {
 102 public:
 103 virtual void SetUp() {
 104         m_kernel_minor_version = 18;
 105         Fspacectl::SetUp();
 106 }
 107 };
 108
 109 class FspacectlCache: public Fspacectl, public WithParamInterface<cache_mode> {
 110 public:
 111 bool m_direct_io;
 112
 113 FspacectlCache(): m_direct_io(false) {};
 114
 115 virtual void SetUp() {
 116         int cache_mode = GetParam();
 117         switch (cache_mode) {
 118                 case Uncached:
 119                         m_direct_io = true;
 120                         break;
 121                 case WritebackAsync:
 122                         m_async = true;
 123                         /* FALLTHROUGH */
 124                 case Writeback:
 125                         m_init_flags |= FUSE_WRITEBACK_CACHE;
 126                         /* FALLTHROUGH */
 127                 case Writethrough:
 128                         break;
 129                 default:
 130                         FAIL() << "Unknown cache mode";
 131         }
 132
 133         FuseTest::SetUp();
 134         if (IsSkipped())
 135                 return;
 136 }
 137 };
 138
 139 class PosixFallocate: public Fallocate {
 140 public:
 141 static sig_atomic_t s_sigxfsz;
 142
 143 void SetUp() {
 144         s_sigxfsz = 0;
 145         FuseTest::SetUp();
 146 }
 147
 148 void TearDown() {
 149         struct sigaction sa;
 150
 151         bzero(&sa, sizeof(sa));
 152         sa.sa_handler = SIG_DFL;
 153         sigaction(SIGXFSZ, &sa, NULL);
 154
 155         Fallocate::TearDown();
 156 }
 157
 158 };
 159
 160 sig_atomic_t PosixFallocate::s_sigxfsz = 0;
 161
 162 void sigxfsz_handler(int __unused sig) {
 163         PosixFallocate::s_sigxfsz = 1;
 164 }
 165
 166 class PosixFallocate_7_18: public PosixFallocate {
 167 public:
 168 virtual void SetUp() {
 169         m_kernel_minor_version = 18;
 170         PosixFallocate::SetUp();
 171 }
 172 };
 173
 174
 175 /*
 176  * If the server returns ENOSYS, it indicates that the server does not support
 177  * FUSE_FALLOCATE.  This and future calls should fall back to vop_stddeallocate.
 178  */
 179 TEST_F(Fspacectl, enosys)
 180 {
 181         const char FULLPATH[] = "mountpoint/some_file.txt";
 182         const char RELPATH[] = "some_file.txt";
 183         off_t fsize = 1 << 20;
 184         off_t off0 = 100;
 185         off_t len0 = 500;
 186         struct spacectl_range rqsr = { .r_offset = off0, .r_len = len0 };
 187         uint64_t ino = 42;
 188         uint64_t off1 = fsize;
 189         uint64_t len1 = 1000;
 190         off_t off2 = fsize / 2;
 191         off_t len2 = 500;
 192         int fd;
 193
 194         expect_lookup(RELPATH, ino, S_IFREG | 0644, fsize, 1);
 195         expect_open(ino, 0, 1);
 196         expect_fallocate(ino, off0, len0,
 197                 FUSE_FALLOC_FL_KEEP_SIZE | FUSE_FALLOC_FL_PUNCH_HOLE, ENOSYS);
 198         expect_vop_stddeallocate(ino, off0, len0);
 199         expect_vop_stddeallocate(ino, off2, len2);
 200
 201         fd = open(FULLPATH, O_RDWR);
 202         ASSERT_LE(0, fd) << strerror(errno);
 203         EXPECT_EQ(0, fspacectl(fd, SPACECTL_DEALLOC, &rqsr, 0, NULL));
 204
 205         /* Subsequent calls shouldn't query the daemon either */
 206         rqsr.r_offset = off2;
 207         rqsr.r_len = len2;
 208         EXPECT_EQ(0, fspacectl(fd, SPACECTL_DEALLOC, &rqsr, 0, NULL));
 209
 210         /* Neither should posix_fallocate query the daemon */
 211         EXPECT_EQ(EINVAL, posix_fallocate(fd, off1, len1));
 212
 213         leak(fd);
 214 }
 215
 216 /*
 217  * EOPNOTSUPP means "the file system does not support fallocate with the
 218  * supplied mode on this particular file".  So we should fallback, but not
 219  * assume anything about whether the operation will fail on a different file or
 220  * with a different mode.
 221  */
 222 TEST_F(Fspacectl, eopnotsupp)
 223 {
 224         const char FULLPATH[] = "mountpoint/some_file.txt";
 225         const char RELPATH[] = "some_file.txt";
 226         struct spacectl_range rqsr;
 227         uint64_t ino = 42;
 228         uint64_t fsize = 1 << 20;
 229         uint64_t off0 = 500;
 230         uint64_t len = 1000;
 231         uint64_t off1 = fsize / 2;
 232         int fd;
 233
 234         expect_lookup(RELPATH, ino, S_IFREG | 0644, fsize, 1);
 235         expect_open(ino, 0, 1);
 236         expect_fallocate(ino, off0, len,
 237                 FUSE_FALLOC_FL_KEEP_SIZE | FUSE_FALLOC_FL_PUNCH_HOLE,
 238                         EOPNOTSUPP);
 239         expect_vop_stddeallocate(ino, off0, len);
 240         expect_fallocate(ino, off1, len,
 241                 FUSE_FALLOC_FL_KEEP_SIZE | FUSE_FALLOC_FL_PUNCH_HOLE,
 242                         EOPNOTSUPP);
 243         expect_vop_stddeallocate(ino, off1, len);
 244         expect_fallocate(ino, fsize, len, 0, 0);
 245
 246         fd = open(FULLPATH, O_RDWR);
 247         ASSERT_LE(0, fd) << strerror(errno);
 248
 249         /*
 250          * Though the FUSE daemon will reject the call, the kernel should fall
 251          * back to a read-modify-write approach.
 252          */
 253         rqsr.r_offset = off0;
 254         rqsr.r_len = len;
 255         EXPECT_EQ(0, fspacectl(fd, SPACECTL_DEALLOC, &rqsr, 0, NULL));
 256
 257         /* Subsequent calls should still query the daemon */
 258         rqsr.r_offset = off1;
 259         rqsr.r_len = len;
 260         EXPECT_EQ(0, fspacectl(fd, SPACECTL_DEALLOC, &rqsr, 0, NULL));
 261
 262         /* But subsequent posix_fallocate calls _should_ query the daemon */
 263         EXPECT_EQ(0, posix_fallocate(fd, fsize, len));
 264
 265         leak(fd);
 266 }
 267
 268 TEST_F(Fspacectl, erofs)
 269 {
 270         const char FULLPATH[] = "mountpoint/some_file.txt";
 271         const char RELPATH[] = "some_file.txt";
 272         struct statfs statbuf;
 273         uint64_t fsize = 2000;
 274         struct spacectl_range rqsr = { .r_offset = 0, .r_len = 1 };
 275         struct iovec *iov = NULL;
 276         int iovlen = 0;
 277         uint64_t ino = 42;
 278         int fd;
 279         int newflags;
 280
 281         expect_lookup(RELPATH, ino, S_IFREG | 0644, fsize, 1);
 282         expect_open(ino, 0, 1);
 283         EXPECT_CALL(*m_mock, process(
 284                 ResultOf([](auto in) {
 285                         return (in.header.opcode == FUSE_STATFS);
 286                 }, Eq(true)),
 287                 _)
 288         ).WillRepeatedly(Invoke(ReturnImmediate([=](auto in __unused, auto& out)
 289         {
 290                 /*
 291                  * All of the fields except f_flags are don't care, and f_flags
 292                  * is set by the VFS
 293                  */
 294                 SET_OUT_HEADER_LEN(out, statfs);
 295         })));
 296
 297         fd = open(FULLPATH, O_RDWR);
 298         ASSERT_LE(0, fd) << strerror(errno);
 299
 300         /* Remount read-only */
 301         ASSERT_EQ(0, statfs("mountpoint", &statbuf)) << strerror(errno);
 302         newflags = statbuf.f_flags | MNT_UPDATE | MNT_RDONLY;
 303         build_iovec(&iov, &iovlen, "fstype", (void*)statbuf.f_fstypename, -1);
 304         build_iovec(&iov, &iovlen, "fspath", (void*)statbuf.f_mntonname, -1);
 305         build_iovec(&iov, &iovlen, "from", __DECONST(void *, "/dev/fuse"), -1);
 306         ASSERT_EQ(0, nmount(iov, iovlen, newflags)) << strerror(errno);
 307
 308         EXPECT_EQ(-1, fspacectl(fd, SPACECTL_DEALLOC, &rqsr, 0, NULL));
 309         EXPECT_EQ(EROFS, errno);
 310
 311         leak(fd);
 312 }
 313
 314 TEST_F(Fspacectl, ok)
 315 {
 316         const char FULLPATH[] = "mountpoint/some_file.txt";
 317         const char RELPATH[] = "some_file.txt";
 318         struct spacectl_range rqsr, rmsr;
 319         struct stat sb0, sb1;
 320         uint64_t ino = 42;
 321         uint64_t fsize = 2000;
 322         uint64_t offset = 500;
 323         uint64_t length = 1000;
 324         int fd;
 325
 326         expect_lookup(RELPATH, ino, S_IFREG | 0644, fsize, 1);
 327         expect_open(ino, 0, 1);
 328         expect_fallocate(ino, offset, length,
 329                 FUSE_FALLOC_FL_KEEP_SIZE | FUSE_FALLOC_FL_PUNCH_HOLE, 0);
 330
 331         fd = open(FULLPATH, O_RDWR);
 332         ASSERT_LE(0, fd) << strerror(errno);
 333         ASSERT_EQ(0, fstat(fd, &sb0)) << strerror(errno);
 334         rqsr.r_offset = offset;
 335         rqsr.r_len = length;
 336         EXPECT_EQ(0, fspacectl(fd, SPACECTL_DEALLOC, &rqsr, 0, &rmsr));
 337         EXPECT_EQ(0, rmsr.r_len);
 338         EXPECT_EQ((off_t)(offset + length), rmsr.r_offset);
 339
 340         /*
 341          * The file's attributes should not have been invalidated, so this fstat
 342          * will not requery the daemon.
 343          */
 344         EXPECT_EQ(0, fstat(fd, &sb1));
 345         EXPECT_EQ(fsize, (uint64_t)sb1.st_size);
 346
 347         /* mtime and ctime should be updated */
 348         EXPECT_EQ(sb0.st_atime, sb1.st_atime);
 349         EXPECT_NE(sb0.st_mtime, sb1.st_mtime);
 350         EXPECT_NE(sb0.st_ctime, sb1.st_ctime);
 351
 352         leak(fd);
 353 }
 354
 355 /* The returned rqsr.r_off should be clipped at EoF */
 356 TEST_F(Fspacectl, past_eof)
 357 {
 358         const char FULLPATH[] = "mountpoint/some_file.txt";
 359         const char RELPATH[] = "some_file.txt";
 360         struct spacectl_range rqsr, rmsr;
 361         uint64_t ino = 42;
 362         uint64_t fsize = 1000;
 363         uint64_t offset = 1500;
 364         uint64_t length = 1000;
 365         int fd;
 366
 367         expect_lookup(RELPATH, ino, S_IFREG | 0644, fsize, 1);
 368         expect_open(ino, 0, 1);
 369         expect_fallocate(ino, offset, length,
 370                 FUSE_FALLOC_FL_KEEP_SIZE | FUSE_FALLOC_FL_PUNCH_HOLE, 0);
 371
 372         fd = open(FULLPATH, O_RDWR);
 373         ASSERT_LE(0, fd) << strerror(errno);
 374         rqsr.r_offset = offset;
 375         rqsr.r_len = length;
 376         EXPECT_EQ(0, fspacectl(fd, SPACECTL_DEALLOC, &rqsr, 0, &rmsr));
 377         EXPECT_EQ(0, rmsr.r_len);
 378         EXPECT_EQ((off_t)fsize, rmsr.r_offset);
 379
 380         leak(fd);
 381 }
 382
 383 /* The returned rqsr.r_off should be clipped at EoF */
 384 TEST_F(Fspacectl, spans_eof)
 385 {
 386         const char FULLPATH[] = "mountpoint/some_file.txt";
 387         const char RELPATH[] = "some_file.txt";
 388         struct spacectl_range rqsr, rmsr;
 389         uint64_t ino = 42;
 390         uint64_t fsize = 1000;
 391         uint64_t offset = 500;
 392         uint64_t length = 1000;
 393         int fd;
 394
 395         expect_lookup(RELPATH, ino, S_IFREG | 0644, fsize, 1);
 396         expect_open(ino, 0, 1);
 397         expect_fallocate(ino, offset, length,
 398                 FUSE_FALLOC_FL_KEEP_SIZE | FUSE_FALLOC_FL_PUNCH_HOLE, 0);
 399
 400         fd = open(FULLPATH, O_RDWR);
 401         ASSERT_LE(0, fd) << strerror(errno);
 402         rqsr.r_offset = offset;
 403         rqsr.r_len = length;
 404         EXPECT_EQ(0, fspacectl(fd, SPACECTL_DEALLOC, &rqsr, 0, &rmsr));
 405         EXPECT_EQ(0, rmsr.r_len);
 406         EXPECT_EQ((off_t)fsize, rmsr.r_offset);
 407
 408         leak(fd);
 409 }
 410
 411 /*
 412  * With older servers, no FUSE_FALLOCATE should be attempted.  The kernel
 413  * should fall back to vop_stddeallocate.
 414  */
 415 TEST_F(Fspacectl_7_18, ok)
 416 {
 417         const char FULLPATH[] = "mountpoint/some_file.txt";
 418         const char RELPATH[] = "some_file.txt";
 419         struct spacectl_range rqsr, rmsr;
 420         void *buf;
 421         uint64_t ino = 42;
 422         uint64_t fsize = 2000;
 423         uint64_t offset = 500;
 424         uint64_t length = 1000;
 425         int fd;
 426
 427         buf = malloc(length);
 428
 429         expect_lookup(RELPATH, ino, S_IFREG | 0644, fsize, 1);
 430         expect_open(ino, 0, 1);
 431         expect_vop_stddeallocate(ino, offset, length);
 432
 433         fd = open(FULLPATH, O_RDWR);
 434         ASSERT_LE(0, fd) << strerror(errno);
 435         rqsr.r_offset = offset;
 436         rqsr.r_len = length;
 437         EXPECT_EQ(0, fspacectl(fd, SPACECTL_DEALLOC, &rqsr, 0, &rmsr));
 438         EXPECT_EQ(0, rmsr.r_len);
 439         EXPECT_EQ((off_t)(offset + length), rmsr.r_offset);
 440
 441         leak(fd);
 442         free(buf);
 443 }
 444
 445 /*
 446  * A successful fspacectl should clear the zeroed data from the kernel cache.
 447  */
 448 TEST_P(FspacectlCache, clears_cache)
 449 {
 450         const char FULLPATH[] = "mountpoint/some_file.txt";
 451         const char RELPATH[] = "some_file.txt";
 452         const char *CONTENTS = "abcdefghijklmnopqrstuvwxyz";
 453         struct spacectl_range rqsr, rmsr;
 454         uint64_t ino = 42;
 455         ssize_t bufsize = strlen(CONTENTS);
 456         uint64_t fsize = bufsize;
 457         uint8_t buf[bufsize];
 458         char zbuf[bufsize];
 459         uint64_t offset = 0;
 460         uint64_t length = bufsize;
 461         int fd;
 462
 463         bzero(zbuf, bufsize);
 464
 465         expect_lookup(RELPATH, ino, S_IFREG | 0644, fsize, 1);
 466         expect_open(ino, 0, 1);
 467         /* NB: expectations are applied in LIFO order */
 468         expect_read(ino, 0, fsize, fsize, zbuf);
 469         expect_read(ino, 0, fsize, fsize, CONTENTS);
 470         expect_fallocate(ino, offset, length,
 471                 FUSE_FALLOC_FL_KEEP_SIZE | FUSE_FALLOC_FL_PUNCH_HOLE, 0);
 472
 473         fd = open(FULLPATH, O_RDWR);
 474         ASSERT_LE(0, fd) << strerror(errno);
 475
 476         /* Populate the cache */
 477         ASSERT_EQ(fsize, (uint64_t)pread(fd, buf, bufsize, 0))
 478                 << strerror(errno);
 479         ASSERT_EQ(0, memcmp(buf, CONTENTS, fsize));
 480
 481         /* Zero the file */
 482         rqsr.r_offset = offset;
 483         rqsr.r_len = length;
 484         EXPECT_EQ(0, fspacectl(fd, SPACECTL_DEALLOC, &rqsr, 0, &rmsr));
 485         EXPECT_EQ(0, rmsr.r_len);
 486         EXPECT_EQ((off_t)(offset + length), rmsr.r_offset);
 487
 488         /* Read again.  This should query the daemon */
 489         ASSERT_EQ(fsize, (uint64_t)pread(fd, buf, bufsize, 0))
 490                 << strerror(errno);
 491         ASSERT_EQ(0, memcmp(buf, zbuf, fsize));
 492
 493         leak(fd);
 494 }
 495
 496 INSTANTIATE_TEST_CASE_P(FspacectlCache, FspacectlCache,
 497         Values(Uncached, Writethrough, Writeback),
 498 );
 499
 500 /*
 501  * If the server returns ENOSYS, it indicates that the server does not support
 502  * FUSE_FALLOCATE.  This and future calls should return EINVAL.
 503  */
 504 TEST_F(PosixFallocate, enosys)
 505 {
 506         const char FULLPATH[] = "mountpoint/some_file.txt";
 507         const char RELPATH[] = "some_file.txt";
 508         uint64_t ino = 42;
 509         uint64_t off0 = 0;
 510         uint64_t len0 = 1000;
 511         off_t off1 = 100;
 512         off_t len1 = 200;
 513         uint64_t fsize = 500;
 514         struct spacectl_range rqsr = { .r_offset = off1, .r_len = len1 };
 515         int fd;
 516
 517         expect_lookup(RELPATH, ino, S_IFREG | 0644, fsize, 1);
 518         expect_open(ino, 0, 1);
 519         expect_fallocate(ino, off0, len0, 0, ENOSYS);
 520         expect_vop_stddeallocate(ino, off1, len1);
 521
 522         fd = open(FULLPATH, O_RDWR);
 523         ASSERT_LE(0, fd) << strerror(errno);
 524         EXPECT_EQ(EINVAL, posix_fallocate(fd, off0, len0));
 525
 526         /* Subsequent calls shouldn't query the daemon*/
 527         EXPECT_EQ(EINVAL, posix_fallocate(fd, off0, len0));
 528
 529         /* Neither should VOP_DEALLOCATE query the daemon */
 530         EXPECT_EQ(0, fspacectl(fd, SPACECTL_DEALLOC, &rqsr, 0, NULL));
 531
 532         leak(fd);
 533 }
 534
 535 /*
 536  * EOPNOTSUPP means "the file system does not support fallocate with the
 537  * supplied mode on this particular file".  So we should fallback, but not
 538  * assume anything about whether the operation will fail on a different file or
 539  * with a different mode.
 540  */
 541 TEST_F(PosixFallocate, eopnotsupp)
 542 {
 543         const char FULLPATH[] = "mountpoint/some_file.txt";
 544         const char RELPATH[] = "some_file.txt";
 545         struct spacectl_range rqsr;
 546         uint64_t ino = 42;
 547         uint64_t fsize = 2000;
 548         uint64_t offset = 0;
 549         uint64_t length = 1000;
 550         int fd;
 551
 552         expect_lookup(RELPATH, ino, S_IFREG | 0644, fsize, 1);
 553         expect_open(ino, 0, 1);
 554         expect_fallocate(ino, fsize, length, 0, EOPNOTSUPP);
 555         expect_fallocate(ino, offset, length, 0, EOPNOTSUPP);
 556         expect_fallocate(ino, offset, length,
 557                 FUSE_FALLOC_FL_KEEP_SIZE | FUSE_FALLOC_FL_PUNCH_HOLE, 0);
 558
 559         fd = open(FULLPATH, O_RDWR);
 560         ASSERT_LE(0, fd) << strerror(errno);
 561         EXPECT_EQ(EINVAL, posix_fallocate(fd, fsize, length));
 562
 563         /* Subsequent calls should still query the daemon*/
 564         EXPECT_EQ(EINVAL, posix_fallocate(fd, offset, length));
 565
 566         /* And subsequent VOP_DEALLOCATE calls should also query the daemon */
 567         rqsr.r_len = length;
 568         rqsr.r_offset = offset;
 569         EXPECT_EQ(0, fspacectl(fd, SPACECTL_DEALLOC, &rqsr, 0, NULL));
 570
 571         leak(fd);
 572 }
 573
 574 /* EIO is not a permanent error, and may be retried */
 575 TEST_F(PosixFallocate, eio)
 576 {
 577         const char FULLPATH[] = "mountpoint/some_file.txt";
 578         const char RELPATH[] = "some_file.txt";
 579         uint64_t ino = 42;
 580         uint64_t offset = 0;
 581         uint64_t length = 1000;
 582         int fd;
 583
 584         expect_lookup(RELPATH, ino, S_IFREG | 0644, 0, 1);
 585         expect_open(ino, 0, 1);
 586         expect_fallocate(ino, offset, length, 0, EIO);
 587
 588         fd = open(FULLPATH, O_RDWR);
 589         ASSERT_LE(0, fd) << strerror(errno);
 590         EXPECT_EQ(EIO, posix_fallocate(fd, offset, length));
 591
 592         expect_fallocate(ino, offset, length, 0, 0);
 593
 594         EXPECT_EQ(0, posix_fallocate(fd, offset, length));
 595
 596         leak(fd);
 597 }
 598
 599 TEST_F(PosixFallocate, erofs)
 600 {
 601         const char FULLPATH[] = "mountpoint/some_file.txt";
 602         const char RELPATH[] = "some_file.txt";
 603         struct statfs statbuf;
 604         struct iovec *iov = NULL;
 605         int iovlen = 0;
 606         uint64_t ino = 42;
 607         uint64_t offset = 0;
 608         uint64_t length = 1000;
 609         int fd;
 610         int newflags;
 611
 612         expect_lookup(RELPATH, ino, S_IFREG | 0644, 0, 1);
 613         expect_open(ino, 0, 1);
 614         EXPECT_CALL(*m_mock, process(
 615                 ResultOf([](auto in) {
 616                         return (in.header.opcode == FUSE_STATFS);
 617                 }, Eq(true)),
 618                 _)
 619         ).WillRepeatedly(Invoke(ReturnImmediate([=](auto in __unused, auto& out)
 620         {
 621                 /*
 622                  * All of the fields except f_flags are don't care, and f_flags
 623                  * is set by the VFS
 624                  */
 625                 SET_OUT_HEADER_LEN(out, statfs);
 626         })));
 627
 628         fd = open(FULLPATH, O_RDWR);
 629         ASSERT_LE(0, fd) << strerror(errno);
 630
 631         /* Remount read-only */
 632         ASSERT_EQ(0, statfs("mountpoint", &statbuf)) << strerror(errno);
 633         newflags = statbuf.f_flags | MNT_UPDATE | MNT_RDONLY;
 634         build_iovec(&iov, &iovlen, "fstype", (void*)statbuf.f_fstypename, -1);
 635         build_iovec(&iov, &iovlen, "fspath", (void*)statbuf.f_mntonname, -1);
 636         build_iovec(&iov, &iovlen, "from", __DECONST(void *, "/dev/fuse"), -1);
 637         ASSERT_EQ(0, nmount(iov, iovlen, newflags)) << strerror(errno);
 638
 639         EXPECT_EQ(EROFS, posix_fallocate(fd, offset, length));
 640
 641         leak(fd);
 642 }
 643
 644 TEST_F(PosixFallocate, ok)
 645 {
 646         const char FULLPATH[] = "mountpoint/some_file.txt";
 647         const char RELPATH[] = "some_file.txt";
 648         struct stat sb0, sb1;
 649         uint64_t ino = 42;
 650         uint64_t offset = 0;
 651         uint64_t length = 1000;
 652         int fd;
 653
 654         EXPECT_LOOKUP(FUSE_ROOT_ID, RELPATH)
 655         .WillOnce(Invoke(ReturnImmediate([=](auto in __unused, auto& out) {
 656                 SET_OUT_HEADER_LEN(out, entry);
 657                 out.body.entry.attr.mode = S_IFREG | 0644;
 658                 out.body.entry.nodeid = ino;
 659                 out.body.entry.entry_valid = UINT64_MAX;
 660                 out.body.entry.attr_valid = UINT64_MAX;
 661         })));
 662         expect_open(ino, 0, 1);
 663         expect_fallocate(ino, offset, length, 0, 0);
 664
 665         fd = open(FULLPATH, O_RDWR);
 666         ASSERT_LE(0, fd) << strerror(errno);
 667         ASSERT_EQ(0, fstat(fd, &sb0)) << strerror(errno);
 668         EXPECT_EQ(0, posix_fallocate(fd, offset, length));
 669         /*
 670          * Despite the originally cached file size of zero, stat should now
 671          * return either the new size or requery the daemon.
 672          */
 673         EXPECT_EQ(0, stat(FULLPATH, &sb1));
 674         EXPECT_EQ(length, (uint64_t)sb1.st_size);
 675
 676         /* mtime and ctime should be updated */
 677         EXPECT_EQ(sb0.st_atime, sb1.st_atime);
 678         EXPECT_NE(sb0.st_mtime, sb1.st_mtime);
 679         EXPECT_NE(sb0.st_ctime, sb1.st_ctime);
 680
 681         leak(fd);
 682 }
 683
 684 /* fusefs should respect RLIMIT_FSIZE */
 685 TEST_F(PosixFallocate, rlimit_fsize)
 686 {
 687         const char FULLPATH[] = "mountpoint/some_file.txt";
 688         const char RELPATH[] = "some_file.txt";
 689         struct rlimit rl;
 690         uint64_t ino = 42;
 691         uint64_t offset = 0;
 692         uint64_t length = 1'000'000;
 693         int fd;
 694
 695         expect_lookup(RELPATH, ino, S_IFREG | 0644, 0, 1);
 696         expect_open(ino, 0, 1);
 697
 698         rl.rlim_cur = length / 2;
 699         rl.rlim_max = 10 * length;
 700         ASSERT_EQ(0, setrlimit(RLIMIT_FSIZE, &rl)) << strerror(errno);
 701         ASSERT_NE(SIG_ERR, signal(SIGXFSZ, sigxfsz_handler)) << strerror(errno);
 702
 703         fd = open(FULLPATH, O_RDWR);
 704         ASSERT_LE(0, fd) << strerror(errno);
 705         EXPECT_EQ(EFBIG, posix_fallocate(fd, offset, length));
 706         EXPECT_EQ(1, s_sigxfsz);
 707
 708         leak(fd);
 709 }
 710
 711 /* With older servers, no FUSE_FALLOCATE should be attempted */
 712 TEST_F(PosixFallocate_7_18, einval)
 713 {
 714         const char FULLPATH[] = "mountpoint/some_file.txt";
 715         const char RELPATH[] = "some_file.txt";
 716         uint64_t ino = 42;
 717         uint64_t offset = 0;
 718         uint64_t length = 1000;
 719         int fd;
 720
 721         expect_lookup(RELPATH, ino, S_IFREG | 0644, 0, 1);
 722         expect_open(ino, 0, 1);
 723
 724         fd = open(FULLPATH, O_RDWR);
 725         ASSERT_LE(0, fd) << strerror(errno);
 726         EXPECT_EQ(EINVAL, posix_fallocate(fd, offset, length));
 727
 728         leak(fd);
 729 }