tests/sys/fs/fusefs/statfs.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  * $FreeBSD$
  31  */
  32
  33 extern "C" {
  34 #include <sys/param.h>
  35 #include <sys/mount.h>
  36 #include <semaphore.h>
  37 }
  38
  39 #include "mockfs.hh"
  40 #include "utils.hh"
  41
  42 using namespace testing;
  43
  44 class Statfs: public FuseTest {};
  45
  46 TEST_F(Statfs, eio)
  47 {
  48         struct statfs statbuf;
  49
  50         EXPECT_CALL(*m_mock, process(
  51                 ResultOf([](auto in) {
  52                         return (in.header.opcode == FUSE_STATFS);
  53                 }, Eq(true)),
  54                 _)
  55         ).WillOnce(Invoke(ReturnErrno(EIO)));
  56
  57         ASSERT_NE(0, statfs("mountpoint", &statbuf));
  58         ASSERT_EQ(EIO, errno);
  59 }
  60
  61 /*
  62  * When the daemon is dead but the filesystem is still mounted, fuse(4) fakes
  63  * the statfs(2) response, which is necessary for unmounting.
  64  */
  65 TEST_F(Statfs, enotconn)
  66 {
  67         struct statfs statbuf;
  68         char mp[PATH_MAX];
  69
  70         m_mock->kill_daemon();
  71
  72         ASSERT_NE(nullptr, getcwd(mp, PATH_MAX)) << strerror(errno);
  73         strlcat(mp, "/mountpoint", PATH_MAX);
  74         ASSERT_EQ(0, statfs("mountpoint", &statbuf)) << strerror(errno);
  75
  76         EXPECT_EQ(getuid(), statbuf.f_owner);
  77         EXPECT_EQ(0, strcmp("fusefs", statbuf.f_fstypename));
  78         EXPECT_EQ(0, strcmp("/dev/fuse", statbuf.f_mntfromname));
  79         EXPECT_EQ(0, strcmp(mp, statbuf.f_mntonname));
  80 }
  81
  82 static void* statfs_th(void* arg) {
  83         ssize_t r;
  84         struct statfs *sb = (struct statfs*)arg;
  85
  86         r = statfs("mountpoint", sb);
  87         if (r >= 0)
  88                 return 0;
  89         else
  90                 return (void*)(intptr_t)errno;
  91 }
  92
  93 /*
  94  * Like the enotconn test, but in this case the daemon dies after we send the
  95  * FUSE_STATFS operation but before we get a response.
  96  */
  97 TEST_F(Statfs, enotconn_while_blocked)
  98 {
  99         struct statfs statbuf;
 100         void *thr0_value;
 101         pthread_t th0;
 102         char mp[PATH_MAX];
 103         sem_t sem;
 104
 105         ASSERT_EQ(0, sem_init(&sem, 0, 0)) << strerror(errno);
 106
 107         EXPECT_CALL(*m_mock, process(
 108                 ResultOf([](auto in) {
 109                         return (in.header.opcode == FUSE_STATFS);
 110                 }, Eq(true)),
 111                 _)
 112         ).WillOnce(Invoke([&](auto in __unused, auto &out __unused) {
 113                 sem_post(&sem);
 114                 /* Just block until the daemon dies */
 115         }));
 116
 117         ASSERT_NE(nullptr, getcwd(mp, PATH_MAX)) << strerror(errno);
 118         strlcat(mp, "/mountpoint", PATH_MAX);
 119         ASSERT_EQ(0, pthread_create(&th0, NULL, statfs_th, (void*)&statbuf))
 120                 << strerror(errno);
 121
 122         ASSERT_EQ(0, sem_wait(&sem)) << strerror(errno);
 123         m_mock->kill_daemon();
 124
 125         pthread_join(th0, &thr0_value);
 126         ASSERT_EQ(0, (intptr_t)thr0_value);
 127
 128         EXPECT_EQ(getuid(), statbuf.f_owner);
 129         EXPECT_EQ(0, strcmp("fusefs", statbuf.f_fstypename));
 130         EXPECT_EQ(0, strcmp("/dev/fuse", statbuf.f_mntfromname));
 131         EXPECT_EQ(0, strcmp(mp, statbuf.f_mntonname));
 132 }
 133
 134 TEST_F(Statfs, ok)
 135 {
 136         struct statfs statbuf;
 137         char mp[PATH_MAX];
 138
 139         EXPECT_CALL(*m_mock, process(
 140                 ResultOf([](auto in) {
 141                         return (in.header.opcode == FUSE_STATFS);
 142                 }, Eq(true)),
 143                 _)
 144         ).WillOnce(Invoke(ReturnImmediate([=](auto in __unused, auto& out) {
 145                 SET_OUT_HEADER_LEN(out, statfs);
 146                 out.body.statfs.st.blocks = 1000;
 147                 out.body.statfs.st.bfree = 100;
 148                 out.body.statfs.st.bavail = 200;
 149                 out.body.statfs.st.files = 5;
 150                 out.body.statfs.st.ffree = 6;
 151                 out.body.statfs.st.namelen = 128;
 152                 out.body.statfs.st.frsize = 1024;
 153         })));
 154
 155         ASSERT_NE(nullptr, getcwd(mp, PATH_MAX)) << strerror(errno);
 156         strlcat(mp, "/mountpoint", PATH_MAX);
 157         ASSERT_EQ(0, statfs("mountpoint", &statbuf)) << strerror(errno);
 158         EXPECT_EQ(1024ul, statbuf.f_bsize);
 159         /*
 160          * fuse(4) ignores the filesystem's reported optimal transfer size, and
 161          * chooses a size that works well with the rest of the system instead
 162          */
 163         EXPECT_EQ(1000ul, statbuf.f_blocks);
 164         EXPECT_EQ(100ul, statbuf.f_bfree);
 165         EXPECT_EQ(200l, statbuf.f_bavail);
 166         EXPECT_EQ(5ul, statbuf.f_files);
 167         EXPECT_EQ(6l, statbuf.f_ffree);
 168         EXPECT_EQ(128u, statbuf.f_namemax);
 169         EXPECT_EQ(getuid(), statbuf.f_owner);
 170         EXPECT_EQ(0, strcmp("fusefs", statbuf.f_fstypename));
 171         EXPECT_EQ(0, strcmp("/dev/fuse", statbuf.f_mntfromname));
 172         EXPECT_EQ(0, strcmp(mp, statbuf.f_mntonname));
 173 }