tests/sys/fs/fusefs/fifo.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/types.h>
  35 #include <sys/socket.h>
  36 #include <sys/un.h>
  37 #include <fcntl.h>
  38 }
  39
  40 #include "mockfs.hh"
  41 #include "utils.hh"
  42
  43 using namespace testing;
  44
  45 const char FULLPATH[] = "mountpoint/some_fifo";
  46 const char RELPATH[] = "some_fifo";
  47 const char MESSAGE[] = "Hello, World!\n";
  48 const int msgsize = sizeof(MESSAGE);
  49
  50 class Fifo: public FuseTest {
  51 public:
  52 pthread_t m_child;
  53
  54 Fifo(): m_child(NULL) {};
  55
  56 void TearDown() {
  57         if (m_child != NULL) {
  58                 pthread_join(m_child, NULL);
  59         }
  60         FuseTest::TearDown();
  61 }
  62 };
  63
  64 class Socket: public Fifo {};
  65
  66 /* Writer thread */
  67 static void* writer(void* arg) {
  68         ssize_t sent = 0;
  69         int fd;
  70
  71         fd = *(int*)arg;
  72         while (sent < msgsize) {
  73                 ssize_t r;
  74
  75                 r = write(fd, MESSAGE + sent, msgsize - sent);
  76                 if (r < 0)
  77                         return (void*)(intptr_t)errno;
  78                 else
  79                         sent += r;
  80
  81         }
  82         return 0;
  83 }
  84
  85 /*
  86  * Reading and writing FIFOs works.  None of the I/O actually goes through FUSE
  87  */
  88 TEST_F(Fifo, read_write)
  89 {
  90         mode_t mode = S_IFIFO | 0755;
  91         const int bufsize = 80;
  92         char message[bufsize];
  93         ssize_t recvd = 0, r;
  94         uint64_t ino = 42;
  95         int fd;
  96
  97         expect_lookup(RELPATH, ino, mode, 0, 1);
  98
  99         fd = open(FULLPATH, O_RDWR);
 100         ASSERT_LE(0, fd) << strerror(errno);
 101         ASSERT_EQ(0, pthread_create(&m_child, NULL, writer, &fd))
 102                 << strerror(errno);
 103         while (recvd < msgsize) {
 104                 r = read(fd, message + recvd, bufsize - recvd);
 105                 ASSERT_LE(0, r) << strerror(errno);
 106                 ASSERT_LT(0, r) << "unexpected EOF";
 107                 recvd += r;
 108         }
 109         ASSERT_STREQ(message, MESSAGE);
 110
 111         leak(fd);
 112 }
 113
 114 /* Writer thread */
 115 static void* socket_writer(void* arg __unused) {
 116         ssize_t sent = 0;
 117         int fd, err;
 118         struct sockaddr_un sa;
 119
 120         fd = socket(AF_UNIX, SOCK_STREAM, 0);
 121         if (fd < 0) {
 122                 perror("socket");
 123                 return (void*)(intptr_t)errno;
 124         }
 125         sa.sun_family = AF_UNIX;
 126         strlcpy(sa.sun_path, FULLPATH, sizeof(sa.sun_path));
 127         sa.sun_len = sizeof(FULLPATH);
 128         err = connect(fd, (struct sockaddr*)&sa, sizeof(sa));
 129         if (err < 0) {
 130                 perror("connect");
 131                 return (void*)(intptr_t)errno;
 132         }
 133
 134         while (sent < msgsize) {
 135                 ssize_t r;
 136
 137                 r = write(fd, MESSAGE + sent, msgsize - sent);
 138                 if (r < 0)
 139                         return (void*)(intptr_t)errno;
 140                 else
 141                         sent += r;
 142
 143         }
 144
 145         FuseTest::leak(fd);
 146         return 0;
 147 }
 148
 149 /*
 150  * Reading and writing unix-domain sockets works.  None of the I/O actually
 151  * goes through FUSE.
 152  */
 153 TEST_F(Socket, read_write)
 154 {
 155         mode_t mode = S_IFSOCK | 0755;
 156         const int bufsize = 80;
 157         char message[bufsize];
 158         struct sockaddr_un sa;
 159         ssize_t recvd = 0, r;
 160         uint64_t ino = 42;
 161         int fd, connected;
 162         Sequence seq;
 163
 164         EXPECT_LOOKUP(FUSE_ROOT_ID, RELPATH)
 165                 .WillOnce(Invoke(ReturnErrno(ENOENT)));
 166         EXPECT_CALL(*m_mock, process(
 167                 ResultOf([=](auto in) {
 168                         return (in.header.opcode == FUSE_MKNOD);
 169                 }, Eq(true)),
 170                 _)
 171         ).InSequence(seq)
 172         .WillOnce(Invoke(ReturnImmediate([=](auto in __unused, auto& out) {
 173                 SET_OUT_HEADER_LEN(out, entry);
 174                 out.body.entry.attr.mode = mode;
 175                 out.body.entry.nodeid = ino;
 176                 out.body.entry.entry_valid = UINT64_MAX;
 177                 out.body.entry.attr_valid = UINT64_MAX;
 178         })));
 179
 180         EXPECT_LOOKUP(FUSE_ROOT_ID, RELPATH)
 181         .InSequence(seq)
 182         .WillOnce(Invoke(ReturnImmediate([=](auto in __unused, auto& out) {
 183                 SET_OUT_HEADER_LEN(out, entry);
 184                 out.body.entry.attr.mode = mode;
 185                 out.body.entry.nodeid = ino;
 186                 out.body.entry.attr.nlink = 1;
 187                 out.body.entry.attr_valid = UINT64_MAX;
 188                 out.body.entry.entry_valid = UINT64_MAX;
 189         })));
 190
 191         fd = socket(AF_UNIX, SOCK_STREAM, 0);
 192         ASSERT_LE(0, fd) << strerror(errno);
 193         sa.sun_family = AF_UNIX;
 194         strlcpy(sa.sun_path, FULLPATH, sizeof(sa.sun_path));
 195         sa.sun_len = sizeof(FULLPATH);
 196         ASSERT_EQ(0, bind(fd, (struct sockaddr*)&sa, sizeof(sa)))
 197                 << strerror(errno);
 198         listen(fd, 5);
 199         ASSERT_EQ(0, pthread_create(&m_child, NULL, socket_writer, NULL))
 200                 << strerror(errno);
 201         connected = accept(fd, 0, 0);
 202         ASSERT_LE(0, connected) << strerror(errno);
 203
 204         while (recvd < msgsize) {
 205                 r = read(connected, message + recvd, bufsize - recvd);
 206                 ASSERT_LE(0, r) << strerror(errno);
 207                 ASSERT_LT(0, r) << "unexpected EOF";
 208                 recvd += r;
 209         }
 210         ASSERT_STREQ(message, MESSAGE);
 211
 212         leak(fd);
 213 }